diff --git a/.bazelignore b/.bazelignore
new file mode 100644
index 00000000000..211ea0c2102
--- /dev/null
+++ b/.bazelignore
@@ -0,0 +1,3 @@
+# examples has its own WORKSPACE. Ignore as part of this root WORKSPACE so that
+# we don't need to repeat dependencies.
+examples/
diff --git a/.bazelrc b/.bazelrc
new file mode 100644
index 00000000000..53485cb9743
--- /dev/null
+++ b/.bazelrc
@@ -0,0 +1 @@
+build --cxxopt=-std=c++17 --host_cxxopt=-std=c++17
diff --git a/.gitattributes b/.gitattributes
index 6754557eab6..4343b9bd8ec 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,3 +1,4 @@
-TestService.java.txt binary
-TestServiceLite.java.txt binary
-TestServiceNano.java.txt binary
+TestService.java.txt -text
+TestServiceLite.java.txt -text
+TestDeprecatedService.java.txt -text
+TestDeprecatedServiceLite.java.txt -text
diff --git a/.github/ISSUE_TEMPLATE b/.github/ISSUE_TEMPLATE
deleted file mode 100644
index 5ffc3a7a9f1..00000000000
--- a/.github/ISSUE_TEMPLATE
+++ /dev/null
@@ -1,17 +0,0 @@
-Please answer these questions before submitting your issue.
-
-### What version of gRPC are you using?
-
-
-### What JVM are you using (`java -version`)?
-
-
-### What did you do?
-If possible, provide a recipe for reproducing the error.
-
-
-### What did you expect to see?
-
-
-### What did you see instead?
-
diff --git a/.github/ISSUE_TEMPLATE/ask_question.md b/.github/ISSUE_TEMPLATE/ask_question.md
new file mode 100644
index 00000000000..c384031e347
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/ask_question.md
@@ -0,0 +1,12 @@
+---
+name: Ask a question
+about: Asking a question related gRPC-Java
+labels: question
+---
+
+<!-- For questions not directly related to gRPC-Java, please use [stackoverflow](https://stackoverflow.com/questions/tagged/grpc-java).
+Also, if question is not gRPC-Java implementation specific, consider using [grpc.io](https://groups.google.com/forum/#!forum/grpc-io).
+
+Make sure you include information that can help us understand your question. -->
+
+<!-- Your question below this line. -->
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 00000000000..b6998dde7c2
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,19 @@
+---
+name: Report a bug
+about: Create a bug report to help us improve
+---
+
+<!-- Please answer these questions before submitting a bug report. -->
+
+### What version of gRPC-Java are you using?
+
+### What is your environment?
+<!-- operating system (Linux, Windows,...) and version, jdk version, etc. -->
+
+### What did you expect to see?
+
+### What did you see instead?
+
+### Steps to reproduce the bug
+
+<!-- Make sure you include information that can help us debug (full error message, exception listing, stack trace, logs). -->
diff --git a/.github/ISSUE_TEMPLATE/feature_report.md b/.github/ISSUE_TEMPLATE/feature_report.md
new file mode 100644
index 00000000000..ddc60838148
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_report.md
@@ -0,0 +1,19 @@
+---
+name: Request a feature
+about: Suggest an enhancement for gRPC
+labels: enhancement
+---
+
+<!-- Please answer these questions before submitting a feature request. -->
+
+### Is your feature request related to a problem?
+<!-- A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] -->
+
+### Describe the solution you'd like
+<!-- A clear and concise description of what you want to happen. -->
+
+### Describe alternatives you've considered
+<!-- A clear and concise description of any alternative solutions or features you've considered. -->
+
+### Additional context
+<!-- Add any other context about the feature request here. -->
diff --git a/.github/workflows/branch-testing.yml b/.github/workflows/branch-testing.yml
new file mode 100644
index 00000000000..ece8ec4cd58
--- /dev/null
+++ b/.github/workflows/branch-testing.yml
@@ -0,0 +1,41 @@
+name: GitHub Actions Branch Testing
+
+on:
+  push:
+    branches:
+    - master
+    - 'v1.*'
+  schedule:
+  - cron: '54 19 * * SUN' # weekly at a "random" time
+
+permissions:
+  contents: read
+
+jobs:
+  arm64:
+    runs-on: ubuntu-24.04-arm
+    strategy:
+      matrix:
+        jre: [17]
+      fail-fast: false # Should swap to true if we grow a large matrix
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-java@v4
+      with:
+        java-version: ${{ matrix.jre }}
+        distribution: 'temurin'
+
+    - name: Gradle cache
+      uses: actions/cache@v4
+      with:
+        path: |
+          ~/.gradle/caches
+          ~/.gradle/wrapper
+        key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+        restore-keys: |
+          ${{ runner.os }}-gradle-
+
+    - name: Build
+      run: ./gradlew -Dorg.gradle.parallel=true -Dorg.gradle.jvmargs='-Xmx1g' -PskipAndroid=true -PskipCodegen=true -PerrorProne=false test
+
diff --git a/.github/workflows/gradle-wrapper-validation.yml b/.github/workflows/gradle-wrapper-validation.yml
new file mode 100644
index 00000000000..da1e2fed114
--- /dev/null
+++ b/.github/workflows/gradle-wrapper-validation.yml
@@ -0,0 +1,13 @@
+name: "Validate Gradle Wrapper"
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  validation:
+    name: "Gradle wrapper validation"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: gradle/actions/wrapper-validation@v4
diff --git a/.github/workflows/lock.yml b/.github/workflows/lock.yml
new file mode 100644
index 00000000000..3070a1a2f7c
--- /dev/null
+++ b/.github/workflows/lock.yml
@@ -0,0 +1,20 @@
+name: 'Lock Threads'
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '37 3 * * *'
+
+permissions:
+  issues: write
+  pull-requests: write
+
+jobs:
+  lock:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: dessant/lock-threads@v5
+        with:
+          github-token: ${{ github.token }}
+          issue-inactive-days: 90
+          pr-inactive-days: 90
diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml
new file mode 100644
index 00000000000..ccabd9be79f
--- /dev/null
+++ b/.github/workflows/testing.yml
@@ -0,0 +1,110 @@
+name: GitHub Actions Linux Testing
+
+on:
+  push:
+    branches:
+    - master
+    - 'v1.*'
+  pull_request:
+  schedule:
+  - cron: '54 19 * * SUN' # weekly at a "random" time
+
+permissions:
+  contents: read
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        jre: [8, 11, 17, 21]
+      fail-fast: false # Should swap to true if we grow a large matrix
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-java@v4
+      with:
+        java-version: ${{ matrix.jre }}
+        distribution: 'temurin'
+
+    - name: Gradle cache
+      uses: actions/cache@v4
+      with:
+        path: |
+          ~/.gradle/caches
+          ~/.gradle/wrapper
+        key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+        restore-keys: |
+          ${{ runner.os }}-gradle-
+    - name: Maven cache
+      uses: actions/cache@v4
+      with:
+        path: |
+          ~/.m2/repository
+          !~/.m2/repository/io/grpc
+        key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml', 'build.gradle') }}
+        restore-keys: |
+          ${{ runner.os }}-maven-
+    - name: Protobuf cache
+      uses: actions/cache@v4
+      with:
+        path: /tmp/protobuf-cache
+        key: ${{ runner.os }}-maven-${{ hashFiles('buildscripts/make_dependencies.sh') }}
+
+    - name: Build
+      run: buildscripts/kokoro/unix.sh
+    - name: Post Failure Upload Test Reports to Artifacts
+      if: ${{ failure() }}
+      uses: actions/upload-artifact@v4
+      with:
+        name: Test Reports (JRE ${{ matrix.jre }})
+        path: |
+          ./*/build/reports/tests/**
+          ./*/*/build/reports/tests/**
+        retention-days: 14
+    - name: Check for modified codegen
+      run: test -z "$(git status --porcelain)" || (git status && echo Error Working directory is not clean. Forget to commit generated files? && false)
+
+    - name: Coveralls
+      if: matrix.jre == 8 # Upload once, instead of for each job in the matrix
+      env:
+        COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }}
+      run: ./gradlew :grpc-all:coveralls -PskipAndroid=true -x compileJava
+    - name: Codecov
+      uses: codecov/codecov-action@v4
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+
+  bazel:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        bzlmod: [true, false]
+    env:
+      USE_BAZEL_VERSION: 7.7.1
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Check versions match in MODULE.bazel and repositories.bzl
+      run: |
+        diff -u <(sed -n '/GRPC_DEPS_START/,/GRPC_DEPS_END/ {/GRPC_DEPS_/! p}' MODULE.bazel) \
+                <(sed -n '/GRPC_DEPS_START/,/GRPC_DEPS_END/ {/GRPC_DEPS_/! p}' repositories.bzl)
+
+    - name: Bazel cache
+      uses: actions/cache@v4
+      with:
+        path: |
+          ~/.cache/bazel/*/cache
+          ~/.cache/bazelisk/downloads
+        key: ${{ runner.os }}-bazel-${{ env.USE_BAZEL_VERSION }}-${{ hashFiles('WORKSPACE', 'repositories.bzl') }}
+
+    - name: Run bazel build
+      run: bazelisk build //... --enable_bzlmod=${{ matrix.bzlmod }}
+
+    - name: Run bazel test
+      run: bazelisk test //... --enable_bzlmod=${{ matrix.bzlmod }}
+
+    - name: Run example bazel build
+      run: bazelisk build //... --enable_bzlmod=${{ matrix.bzlmod }}
+      working-directory: ./examples
diff --git a/.gitignore b/.gitignore
index eb0afe5c13a..b078d891adf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,13 +3,26 @@ build
 gradle.properties
 .gradle
 local.properties
+out
 
 # Maven (examples)
 target
 
+# Bazel
+bazel-bin
+bazel-examples
+bazel-genfiles
+bazel-grpc-java
+bazel-out
+bazel-testlogs
+MODULE.bazel.lock
+
 # IntelliJ IDEA
 .idea
 *.iml
+*.ipr
+*.iws
+.ijwb
 
 # Eclipse
 .classpath
@@ -18,9 +31,18 @@ target
 .gitignore
 bin
 
+# VsCode
+.vscode
+
 # OS X
 .DS_Store
 
 # Emacs
 *~
 \#*\#
+
+# ARM tests
+qemu-arm-static
+
+# Temporary output dir for artifacts
+mvn-artifacts
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 30227741a5a..00000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,57 +0,0 @@
-sudo: false
-
-language: java
-
-env:
-  global:
-    - GRADLE_OPTS=-Xmx512m
-    - PROTOBUF_VERSION=3.2.0
-    - LDFLAGS=-L/tmp/protobuf/lib
-    - CXXFLAGS=-I/tmp/protobuf/include
-    - LD_LIBRARY_PATH=/tmp/protobuf/lib
-
-before_install:
-  - mkdir -p $HOME/.gradle/caches &&
-    ln -s /tmp/gradle-caches-modules-2 $HOME/.gradle/caches/modules-2
-  - mkdir -p $HOME/.gradle &&
-    ln -s /tmp/gradle-wrapper $HOME/.gradle/wrapper
-    # Work around https://github.com/travis-ci/travis-ci/issues/2317
-  - if \[ "$TRAVIS_OS_NAME" = linux \]; then jdk_switcher use oraclejdk8; fi
-  - buildscripts/make_dependencies.sh # build protoc into /tmp/protobuf-${PROTOBUF_VERSION}
-  - ln -s "/tmp/protobuf-${PROTOBUF_VERSION}/$(uname -s)-$(uname -p)" /tmp/protobuf
-  - mkdir -p $HOME/.gradle
-  - echo "checkstyle.ignoreFailures=false" >> $HOME/.gradle/gradle.properties
-  - echo "failOnWarnings=true" >> $HOME/.gradle/gradle.properties
-
-install:
-  - ./gradlew assemble generateTestProto install
-  - pushd examples && ./gradlew build && popd
-  - pushd examples && mvn verify && popd
-
-before_script:
-  - test -z "$(git status --porcelain)" || (git status && echo Error Working directory is not clean. Forget to commit generated files? && false)
-
-script:
-  - ./gradlew check :grpc-all:jacocoTestReport
-
-after_success:
-  - if \[ "$TRAVIS_OS_NAME" = linux \]; then ./gradlew :grpc-all:coveralls; fi
-  - bash <(curl -s https://codecov.io/bash)
-
-os:
-  - linux
-  - osx
-
-notifications:
-  email: false
-
-cache:
-  directories:
-    - /tmp/protobuf-${PROTOBUF_VERSION}
-    - /tmp/gradle-caches-modules-2
-    - /tmp/gradle-wrapper
-
-before_cache:
-  # The lock changes based on folder name; normally $HOME/.gradle/caches/modules-2/modules-2.lock
-  - rm /tmp/gradle-caches-modules-2/gradle-caches-modules-2.lock
-  - find $HOME/.gradle/wrapper -not -name "*-all.zip" -and -not -name "*-bin.zip" -delete
diff --git a/AUTHORS b/AUTHORS
new file mode 100644
index 00000000000..e491a9e7f78
--- /dev/null
+++ b/AUTHORS
@@ -0,0 +1 @@
+Google Inc.
diff --git a/BUILD.bazel b/BUILD.bazel
new file mode 100644
index 00000000000..27a99fb62eb
--- /dev/null
+++ b/BUILD.bazel
@@ -0,0 +1,71 @@
+# Copyright 2017 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.
+
+load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library")
+load("@rules_java//java:defs.bzl", "java_library", "java_plugin")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+load(":java_grpc_library.bzl", "java_grpc_library")
+
+java_proto_library(
+    name = "api_proto_java",
+    deps = ["@com_google_protobuf//:api_proto"],
+)
+
+java_grpc_library(
+    name = "java_grpc_library__external_repo_test",
+    srcs = ["@com_google_protobuf//:api_proto"],
+    deps = [":api_proto_java"],
+)
+
+java_library(
+    name = "java_grpc_library_deps__do_not_reference",
+    visibility = ["//visibility:public"],
+    exports = [
+        "//api",
+        "//protobuf",
+        "//stub",
+        "@com_google_protobuf//:protobuf_java",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
+    ],
+)
+
+java_library(
+    name = "java_lite_grpc_library_deps__do_not_reference",
+    visibility = ["//visibility:public"],
+    exports = [
+        "//api",
+        "//protobuf-lite",
+        "//stub",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
+    ],
+)
+
+java_plugin(
+    name = "auto_value",
+    generates_api = 1,
+    processor_class = "com.google.auto.value.processor.AutoValueProcessor",
+    deps = [artifact("com.google.auto.value:auto-value")],
+)
+
+java_library(
+    name = "auto_value_annotations",
+    exported_plugins = [":auto_value"],
+    neverlink = 1,
+    visibility = ["//:__subpackages__"],
+    exports = [
+        artifact("com.google.auto.value:auto-value-annotations"),
+    ],
+)
diff --git a/CHANGES.md b/CHANGES.md
deleted file mode 100644
index d38ae8e7501..00000000000
--- a/CHANGES.md
+++ /dev/null
@@ -1,11 +0,0 @@
-Changes between 0.9.0 and 0.10.0:
---------------------------------
-
-#### Features
-
-#### API Changes
-* OkHttpChannelBuilder.overrideHostForAuthority is deprecated
-
-#### Bug Fixes
-* ServerCall forces headers to be sent first
-* Servers cannot be started after shutting down (#1023)
diff --git a/CODE-OF-CONDUCT.md b/CODE-OF-CONDUCT.md
new file mode 100644
index 00000000000..9d4213ebca7
--- /dev/null
+++ b/CODE-OF-CONDUCT.md
@@ -0,0 +1,3 @@
+## Community Code of Conduct
+
+gRPC follows the [CNCF Code of Conduct](https://github.com/cncf/foundation/blob/master/code-of-conduct.md).
diff --git a/COMPILING.md b/COMPILING.md
index 03b807be269..b7df1319beb 100644
--- a/COMPILING.md
+++ b/COMPILING.md
@@ -1,15 +1,22 @@
 Building gRPC-Java
 ==================
 
-Building is only necessary if you are making changes to gRPC-Java.
+Building is only necessary if you are making changes to gRPC-Java or testing/using a non-released
+ version (e.g. master HEAD) of gRPC-Java library.
 
 Building requires JDK 8, as our tests use TLS.
 
 grpc-java has a C++ code generation plugin for protoc. Since many Java
-developers don't have C compilers installed and don't need to modify the
+developers don't have C compilers installed and don't need to run or modify the
 codegen, the build can skip it. To skip, create the file
 `<project-root>/gradle.properties` and add `skipCodegen=true`.
 
+Some parts of grpc-java depend on Android. Since many Java developers don't have
+the Android SDK installed and don't need to run or modify the Android
+components, the build can skip it. To skip, create the file
+`<project-root>/gradle.properties` and add `skipAndroid=true`.
+Otherwise, create the file `<project-root>/gradle.properties` and add `android.useAndroidX=true`.
+
 Then, to build, run:
 ```
 $ ./gradlew build
@@ -18,7 +25,17 @@ $ ./gradlew build
 To install the artifacts to your Maven local repository for use in your own
 project, run:
 ```
-$ ./gradlew install
+$ ./gradlew publishToMavenLocal
+```
+
+### Notes for IntelliJ
+Building in IntelliJ works best when you import the project as a Gradle project and delegate IDE
+build/run actions to Gradle.
+
+You can find this setting at:
+```Settings -> Build, Execution, Deployment
+      -> Build Tools -> Gradle -> Runner
+      -> Delegate IDE build/run actions to gradle.
 ```
 
 How to Build Code Generation Plugin
@@ -27,23 +44,22 @@ This section is only necessary if you are making changes to the code
 generation. Most users only need to use `skipCodegen=true` as discussed above.
 
 ### Build Protobuf
-The codegen plugin is C++ code and requires protobuf 3.0.0 or later.
+The codegen plugin is C++ code and requires protobuf 22.5 or later.
 
 For Linux, Mac and MinGW:
 ```
-$ git clone https://github.com/google/protobuf.git
-$ cd protobuf
-$ git checkout v3.2.0
-$ ./autogen.sh
-$ ./configure
-$ make
-$ make check
+$ PROTOBUF_VERSION=22.5
+$ curl -LO https://github.com/protocolbuffers/protobuf/releases/download/v$PROTOBUF_VERSION/protobuf-all-$PROTOBUF_VERSION.tar.gz
+$ tar xzf protobuf-all-$PROTOBUF_VERSION.tar.gz
+$ cd protobuf-$PROTOBUF_VERSION
+$ ./configure --disable-shared
+$ make   # You may want to pass -j to make this run faster; see make --help
 $ sudo make install
 ```
 
 If you are comfortable with C++ compilation and autotools, you can specify a
 ``--prefix`` for Protobuf and use ``-I`` in ``CXXFLAGS``, ``-L`` in
-``LDFLAGS``, ``LD_LIBRARY_PATH``, and ``PATH`` to reference it. The
+``LDFLAGS`` to reference it. The
 environment variables will be used when building grpc-java.
 
 Protobuf installs to ``/usr/local`` by default.
@@ -51,15 +67,8 @@ Protobuf installs to ``/usr/local`` by default.
 For Visual C++, please refer to the [Protobuf README](https://github.com/google/protobuf/blob/master/cmake/README.md)
 for how to compile Protobuf. gRPC-java assumes a Release build.
 
-#### Linux and MinGW
-If ``/usr/local/lib`` is not in your library search path, you can add it by running:
-```
-$ sudo sh -c 'echo /usr/local/lib >> /etc/ld.so.conf'
-$ sudo ldconfig
-```
-
 #### Mac
-Some versions of Mac OS X (e.g., 10.10) doesn't have ``/usr/local`` in the
+Some versions of Mac OS X (e.g., 10.10) don't have ``/usr/local`` in the
 default search paths for header files and libraries. It will fail the build of
 the codegen. To work around this, you will need to set environment variables:
 ```
@@ -71,17 +80,17 @@ $ export CXXFLAGS="-I/usr/local/include" LDFLAGS="-L/usr/local/lib"
 When building on Windows and VC++, you need to specify project properties for
 Gradle to find protobuf:
 ```
-.\gradlew install ^
-    -PvcProtobufInclude=C:\path\to\protobuf-3.2.0\src ^
-    -PvcProtobufLibs=C:\path\to\protobuf-3.2.0\vsprojects\Release ^
+.\gradlew publishToMavenLocal ^
+    -PvcProtobufInclude=C:\path\to\protobuf\src ^
+    -PvcProtobufLibs=C:\path\to\protobuf\vsprojects\Release ^
     -PtargetArch=x86_32
 ```
 
 Since specifying those properties every build is bothersome, you can instead
 create ``<project-root>\gradle.properties`` with contents like:
 ```
-vcProtobufInclude=C:\\path\\to\\protobuf-3.2.0\\src
-vcProtobufLibs=C:\\path\\to\\protobuf-3.2.0\\vsprojects\\Release
+vcProtobufInclude=C:\\path\\to\\protobuf\\src
+vcProtobufLibs=C:\\path\\to\\protobuf\\vsprojects\\Release
 targetArch=x86_32
 ```
 
@@ -105,3 +114,39 @@ use the one that has been built by your own, by adding this property to
 ```
 protoc=/path/to/protoc
 ```
+
+How to install Android SDK
+---------------------------
+This section is only necessary if you are building modules depending on Android 
+(e.g., `cronet`). Non-Android users only need to use `skipAndroid=true` as 
+discussed above.
+
+### Install via Android Studio (GUI)
+Download and install Android Studio from [Android Developer site](https://developer.android.com/studio).
+You can find the configuration for Android SDK at:
+```
+Preferences -> System Settings -> Android SDK
+```
+Select the version of Android SDK to be installed and click `apply`. The location
+of Android SDK being installed is shown at `Android SDK Location` at the same panel.
+The default is `$HOME/Library/Android/sdk` for Mac OS and `$HOME/Android/Sdk` for Linux. 
+You can change this to a custom location.
+
+### Install via Command line tools only
+Go to [Android SDK](https://developer.android.com/studio#command-tools) and
+download the commandlinetools package for your build machine OS. Decide where
+you want the Android SDK to be stored. `$HOME/Library/Android/sdk` is typical on
+Mac OS and `$HOME/Android/Sdk` for Linux.
+
+```sh
+export ANDROID_HOME=$HOME/Android/Sdk # Adjust to your liking
+mkdir $HOME/Android
+mkdir $ANDROID_HOME
+mkdir $ANDROID_HOME/cmdline-tools
+unzip -d $ANDROID_HOME/cmdline-tools DOWNLOADS/commandlinetools-*.zip
+mv $ANDROID_HOME/cmdline-tools/cmdline-tools $ANDROID_HOME/cmdline-tools/latest
+# Android SDK is now ready. Now accept licenses so the build can auto-download packages
+$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --licenses
+
+# Add 'export ANDROID_HOME=$HOME/Android/Sdk' to your .bashrc or equivalent
+```
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7b9fdfef9de..646a7d986fd 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,23 +1,27 @@
-# How to submit a bug report
-
-If you received an error message, please include it and any exceptions.
+# How to contribute
 
-We commonly need to know what platform you are on:
- * JDK/JRE version (i.e., ```java -version```)
- * Operating system (i.e., ```uname -a```)
+We definitely welcome your patches and contributions to gRPC! Please read the gRPC
+organization's [governance rules](https://github.com/grpc/grpc-community/blob/master/governance.md)
+and [contribution guidelines](https://github.com/grpc/grpc-community/blob/master/CONTRIBUTING.md) before proceeding.
 
-# How to contribute
 
-We definitely welcome patches and contributions to grpc! Here are some
-guideline and information about how to do so.
+If you are new to github, please start by reading [Pull Request howto](https://help.github.com/articles/about-pull-requests/)
 
-## Before getting started
+## Legal requirements
 
 In order to protect both you and ourselves, you will need to sign the
-[Contributor License Agreement](https://cla.developers.google.com/clas).
+[Contributor License Agreement](https://easycla.lfx.linuxfoundation.org/). When
+you make a PR, a CLA bot will provide a link for the process.
+
+## Compiling
+
+See [COMPILING.md](COMPILING.md). Specifically, you'll generally want to set
+`skipCodegen=true` so you don't need to deal with the C++ compilation.
+
+## Code style
 
 We follow the [Google Java Style
-Guide](https://google-styleguide.googlecode.com/svn/trunk/javaguide.html). Our
+Guide](https://google.github.io/styleguide/javaguide.html). Our
 build automatically will provide warnings for style issues.
 [Eclipse](https://raw.githubusercontent.com/google/styleguide/gh-pages/eclipse-java-google-style.xml)
 and
@@ -26,15 +30,38 @@ style configurations are commonly useful. For IntelliJ 14, copy the style to
 `~/.IdeaIC14/config/codestyles/`, start IntelliJ, go to File > Settings > Code
 Style, and set the Scheme to `GoogleStyle`.
 
-If planning on making a large change, feel free to [create an issue on
-GitHub](https://github.com/grpc/grpc-java/issues/new), visit the [#grpc IRC
-channel on Freenode](http://webchat.freenode.net/?channels=grpc), or send an
-email to [grpc-io@googlegroups.com](grpc-io@googlegroups.com) to discuss
-beforehand.
+## Guidelines for Pull Requests
+How to get your contributions merged smoothly and quickly.
+ 
+- Create **small PRs** that are narrowly focused on **addressing a single concern**. We often times receive PRs that are trying to fix several things at a time, but only one fix is considered acceptable, nothing gets merged and both author's & review's time is wasted. Create more PRs to address different concerns and everyone will be happy.
+ 
+- For speculative changes, consider opening an issue and discussing it to avoid
+  wasting time on an inappropriate approach. If you are suggesting a behavioral
+  or API change, consider starting with a [gRFC
+  proposal](https://github.com/grpc/proposal).
+
+- Follow [typical Git commit message](https://cbea.ms/git-commit/#seven-rules)
+  structure. Have a good **commit description** as a record of **what** and
+  **why** the change is being made. Link to a GitHub issue if it exists. The
+  commit description makes a good PR description and is auto-copied by GitHub if
+  you have a single commit when creating the PR.
+
+  If your change is mostly for a single module (e.g., other module changes are
+  trivial), prefix your commit summary with the module name changed. Instead of
+  "Add HTTP/2 faster-than-light support to gRPC Netty" it is more terse as
+  "netty: Add faster-than-light support".
+
+- Don't fix code style and formatting unless you are already changing that line
+  to address an issue. If you do want to fix formatting or style, do that in a
+  separate PR.
+
+- Unless your PR is trivial, you should expect there will be reviewer comments
+  that you'll need to address before merging. Address comments with additional
+  commits so the reviewer can review just the changes; do not squash reviewed
+  commits unless the reviewer agrees. PRs are squashed when merging.
 
-## Proposing changes
+- Keep your PR up to date with upstream/master (if there are merge conflicts, we can't really merge your change).
 
-Make sure that `./gradlew build` (`gradlew build` on Windows) completes
-successfully without any new warnings. Then create a Pull Request with your
-changes. When the changes are accepted, they will be merged or cherry-picked by
-a gRPC core developer.
+- **All tests need to be passing** before your change can be merged. We recommend you **run tests locally** before creating your PR to catch breakages early on. Also, `./gradlew build` (`gradlew build` on Windows) **must not introduce any new warnings**.
+ 
+- Exceptions to the rules can be made if there's a compelling reason for doing so.
diff --git a/GOVERNANCE.md b/GOVERNANCE.md
new file mode 100644
index 00000000000..d6ff2674710
--- /dev/null
+++ b/GOVERNANCE.md
@@ -0,0 +1 @@
+This repository is governed by the gRPC organization's [governance rules](https://github.com/grpc/grpc-community/blob/master/governance.md).
diff --git a/LICENSE b/LICENSE
index 2acb3d7503f..d6456956733 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,28 +1,202 @@
-Copyright 2014, Google Inc. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/MAINTAINERS.md b/MAINTAINERS.md
new file mode 100644
index 00000000000..5048c7c5aca
--- /dev/null
+++ b/MAINTAINERS.md
@@ -0,0 +1,35 @@
+This page lists all active maintainers of this repository. If you were a
+maintainer and would like to add your name to the Emeritus list, please send us a
+PR.
+
+See [GOVERNANCE.md](https://github.com/grpc/grpc-community/blob/master/governance.md)
+for governance guidelines and how to become a maintainer.
+See [CONTRIBUTING.md](https://github.com/grpc/grpc-community/blob/master/CONTRIBUTING.md)
+for general contribution guidelines.
+
+## Maintainers (in alphabetical order)
+- [ejona86](https://github.com/ejona86), Google LLC
+- [jdcormie](https://github.com/jdcormie), Google LLC
+- [kannanjgithub](https://github.com/kannanjgithub), Google LLC
+- [ran-su](https://github.com/ran-su), Google LLC
+- [sergiitk](https://github.com/sergiitk), Google LLC
+- [temawi](https://github.com/temawi), Google LLC
+- [YifeiZhuang](https://github.com/YifeiZhuang), Google LLC
+- [zhangkun83](https://github.com/zhangkun83), Google LLC
+
+## Emeritus Maintainers (in alphabetical order)
+- [carl-mastrangelo](https://github.com/carl-mastrangelo)
+- [creamsoup](https://github.com/creamsoup)
+- [dapengzhang0](https://github.com/dapengzhang0)
+- [ericgribkoff](https://github.com/ericgribkoff)
+- [jiangtaoli2016](https://github.com/jiangtaoli2016)
+- [jtattermusch](https://github.com/jtattermusch)
+- [larry-safran](https://github.com/larry-safran)
+- [louiscryan](https://github.com/louiscryan)
+- [markb74](https://github.com/markb74)
+- [nicolasnoble](https://github.com/nicolasnoble)
+- [nmittler](https://github.com/nmittler)
+- [sanjaypujare](https://github.com/sanjaypujare)
+- [srini100](https://github.com/srini100)
+- [voidzcy](https://github.com/voidzcy)
+- [zpencer](https://github.com/zpencer)
diff --git a/MODULE.bazel b/MODULE.bazel
new file mode 100644
index 00000000000..81d80ed7e1a
--- /dev/null
+++ b/MODULE.bazel
@@ -0,0 +1,159 @@
+module(
+    name = "grpc-java",
+    version = "1.80.0-SNAPSHOT",  # CURRENT_GRPC_VERSION
+    compatibility_level = 0,
+    repo_name = "io_grpc_grpc_java",
+)
+
+# GRPC_DEPS_START
+IO_GRPC_GRPC_JAVA_ARTIFACTS = [
+    "com.google.android:annotations:4.1.1.4",
+    "com.google.api.grpc:proto-google-common-protos:2.63.2",
+    "com.google.auth:google-auth-library-credentials:1.41.0",
+    "com.google.auth:google-auth-library-oauth2-http:1.41.0",
+    "com.google.auto.value:auto-value-annotations:1.11.0",
+    "com.google.auto.value:auto-value:1.11.0",
+    "com.google.code.findbugs:jsr305:3.0.2",
+    "com.google.code.gson:gson:2.12.1",
+    "com.google.errorprone:error_prone_annotations:2.45.0",
+    "com.google.guava:failureaccess:1.0.1",
+    "com.google.guava:guava:33.5.0-android",
+    "com.google.re2j:re2j:1.8",
+    "com.google.s2a.proto.v2:s2a-proto:0.1.3",
+    "com.google.truth:truth:1.4.5",
+    "com.squareup.okhttp:okhttp:2.7.5",
+    "com.squareup.okio:okio:2.10.0",  # 3.0+ needs swapping to -jvm; need work to avoid flag-day
+    "io.netty:netty-buffer:4.1.130.Final",
+    "io.netty:netty-codec-http2:4.1.130.Final",
+    "io.netty:netty-codec-http:4.1.130.Final",
+    "io.netty:netty-codec-socks:4.1.130.Final",
+    "io.netty:netty-codec:4.1.130.Final",
+    "io.netty:netty-common:4.1.130.Final",
+    "io.netty:netty-handler-proxy:4.1.130.Final",
+    "io.netty:netty-handler:4.1.130.Final",
+    "io.netty:netty-resolver:4.1.130.Final",
+    "io.netty:netty-tcnative-boringssl-static:2.0.74.Final",
+    "io.netty:netty-tcnative-classes:2.0.74.Final",
+    "io.netty:netty-transport-native-epoll:jar:linux-x86_64:4.1.130.Final",
+    "io.netty:netty-transport-native-unix-common:4.1.130.Final",
+    "io.netty:netty-transport:4.1.130.Final",
+    "io.opencensus:opencensus-api:0.31.0",
+    "io.opencensus:opencensus-contrib-grpc-metrics:0.31.0",
+    "io.perfmark:perfmark-api:0.27.0",
+    "junit:junit:4.13.2",
+    "org.checkerframework:checker-qual:3.49.5",
+    "org.codehaus.mojo:animal-sniffer-annotations:1.26",
+]
+# GRPC_DEPS_END
+
+bazel_dep(name = "bazel_jar_jar", version = "0.1.11.bcr.1")
+bazel_dep(name = "bazel_skylib", version = "1.7.1")
+bazel_dep(name = "googleapis", version = "0.0.0-20240326-1c8d509c5", repo_name = "com_google_googleapis")
+bazel_dep(name = "grpc-proto", version = "0.0.0-20240627-ec30f58.bcr.1", repo_name = "io_grpc_grpc_proto")
+bazel_dep(name = "protobuf", version = "33.4", repo_name = "com_google_protobuf")
+bazel_dep(name = "rules_cc", version = "0.0.9")
+bazel_dep(name = "rules_java", version = "9.1.0")
+bazel_dep(name = "rules_jvm_external", version = "6.0")
+
+maven = use_extension("@rules_jvm_external//:extensions.bzl", "maven")
+maven.install(
+    artifacts = IO_GRPC_GRPC_JAVA_ARTIFACTS,
+    repositories = [
+        "https://repo.maven.apache.org/maven2/",
+    ],
+    strict_visibility = True,
+)
+use_repo(maven, "maven")
+
+maven.override(
+    coordinates = "com.google.protobuf:protobuf-java",
+    target = "@com_google_protobuf//:protobuf_java",
+)
+maven.override(
+    coordinates = "com.google.protobuf:protobuf-java-util",
+    target = "@com_google_protobuf//:protobuf_java_util",
+)
+maven.override(
+    coordinates = "com.google.protobuf:protobuf-javalite",
+    target = "@com_google_protobuf//:protobuf_javalite",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-alts",
+    target = "@io_grpc_grpc_java//alts",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-api",
+    target = "@io_grpc_grpc_java//api",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-auth",
+    target = "@io_grpc_grpc_java//auth",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-census",
+    target = "@io_grpc_grpc_java//census",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-context",
+    target = "@io_grpc_grpc_java//context",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-core",
+    target = "@io_grpc_grpc_java//core:core_maven",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-googleapis",
+    target = "@io_grpc_grpc_java//googleapis",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-grpclb",
+    target = "@io_grpc_grpc_java//grpclb",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-inprocess",
+    target = "@io_grpc_grpc_java//inprocess",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-netty",
+    target = "@io_grpc_grpc_java//netty",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-netty-shaded",
+    target = "@io_grpc_grpc_java//netty:shaded_maven",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-okhttp",
+    target = "@io_grpc_grpc_java//okhttp",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-protobuf",
+    target = "@io_grpc_grpc_java//protobuf",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-protobuf-lite",
+    target = "@io_grpc_grpc_java//protobuf-lite",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-rls",
+    target = "@io_grpc_grpc_java//rls",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-services",
+    target = "@io_grpc_grpc_java//services:services_maven",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-stub",
+    target = "@io_grpc_grpc_java//stub",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-testing",
+    target = "@io_grpc_grpc_java//testing",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-xds",
+    target = "@io_grpc_grpc_java//xds:xds_maven",
+)
+maven.override(
+    coordinates = "io.grpc:grpc-util",
+    target = "@io_grpc_grpc_java//util",
+)
diff --git a/NOTICE.txt b/NOTICE.txt
index ee67bad4ba4..f70c5620cf7 100644
--- a/NOTICE.txt
+++ b/NOTICE.txt
@@ -1,31 +1,16 @@
-Copyright 2014, Google Inc. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Copyright 2014 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.
 
 -----------------------------------------------------------------------
 
@@ -38,4 +23,40 @@ at:
   * HOMEPAGE:
     * https://github.com/square/okhttp
   * LOCATION_IN_GRPC:
-    * okhttp/third_party/okhttp
\ No newline at end of file
+    * okhttp/third_party/okhttp
+
+This product contains a modified portion of 'Envoy', an open source
+cloud-native high-performance edge/middle/service proxy, which can be
+obtained at:
+
+  * LICENSE:
+    * xds/third_party/envoy/LICENSE (Apache License 2.0)
+  * NOTICE:
+    * xds/third_party/envoy/NOTICE
+  * HOMEPAGE:
+    * https://www.envoyproxy.io
+  * LOCATION_IN_GRPC:
+    * xds/third_party/envoy
+
+This product contains a modified portion of 'protoc-gen-validate (PGV)',
+an open source protoc plugin to generate polyglot message validators,
+which can be obtained at:
+
+  * LICENSE:
+    * xds/third_party/protoc-gen-validate/LICENSE (Apache License 2.0)
+  * NOTICE:
+      * xds/third_party/protoc-gen-validate/NOTICE
+  * HOMEPAGE:
+    * https://github.com/envoyproxy/protoc-gen-validate
+  * LOCATION_IN_GRPC:
+    * xds/third_party/protoc-gen-validate
+
+This product contains a modified portion of 'udpa',
+an open source universal data plane API, which can be obtained at:
+
+  * LICENSE:
+    * xds/third_party/udpa/LICENSE (Apache License 2.0)
+  * HOMEPAGE:
+    * https://github.com/cncf/udpa
+  * LOCATION_IN_GRPC:
+    * xds/third_party/udpa
diff --git a/PATENTS b/PATENTS
deleted file mode 100644
index 619f9dbfe63..00000000000
--- a/PATENTS
+++ /dev/null
@@ -1,22 +0,0 @@
-Additional IP Rights Grant (Patents)
-
-"This implementation" means the copyrightable works distributed by
-Google as part of the GRPC project.
-
-Google hereby grants to You a perpetual, worldwide, non-exclusive,
-no-charge, royalty-free, irrevocable (except as stated in this section)
-patent license to make, have made, use, offer to sell, sell, import,
-transfer and otherwise run, modify and propagate the contents of this
-implementation of GRPC, where such license applies only to those patent
-claims, both currently owned or controlled by Google and acquired in
-the future, licensable by Google that are necessarily infringed by this
-implementation of GRPC.  This grant does not include claims that would be
-infringed only as a consequence of further modification of this
-implementation.  If you or your agent or exclusive licensee institute or
-order or agree to the institution of patent litigation against any
-entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that this implementation of GRPC or any code incorporated within this
-implementation of GRPC constitutes direct or contributory patent
-infringement, or inducement of patent infringement, then any patent
-rights granted to you under this License for this implementation of GRPC
-shall terminate as of the date such litigation is filed.
diff --git a/README.md b/README.md
index 2aab764bb0a..205187b4000 100644
--- a/README.md
+++ b/README.md
@@ -1,14 +1,10 @@
 gRPC-Java - An RPC library and framework
 ========================================
 
-gRPC-Java works with JDK 6. TLS usage typically requires using Java 8, or Play
-Services Dynamic Security Provider on Android. Please see the [Security
-Readme](SECURITY.md).
-
 <table>
   <tr>
     <td><b>Homepage:</b></td>
-    <td><a href="http://www.grpc.io/">www.grpc.io</a></td>
+    <td><a href="https://grpc.io/">grpc.io</a></td>
   </tr>
   <tr>
     <td><b>Mailing List:</b></td>
@@ -17,8 +13,40 @@ Readme](SECURITY.md).
 </table>
 
 [![Join the chat at https://gitter.im/grpc/grpc](https://badges.gitter.im/grpc/grpc.svg)](https://gitter.im/grpc/grpc?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-[![Build Status](https://travis-ci.org/grpc/grpc-java.svg?branch=master)](https://travis-ci.org/grpc/grpc-java)
-[![Coverage Status](https://coveralls.io/repos/grpc/grpc-java/badge.svg?branch=master&service=github)](https://coveralls.io/github/grpc/grpc-java?branch=master)
+[![GitHub Actions Linux Testing](https://github.com/grpc/grpc-java/actions/workflows/testing.yml/badge.svg?branch=master)](https://github.com/grpc/grpc-java/actions/workflows/testing.yml?branch=master)
+[![Line Coverage Status](https://coveralls.io/repos/grpc/grpc-java/badge.svg?branch=master&service=github)](https://coveralls.io/github/grpc/grpc-java?branch=master)
+[![Branch-adjusted Line Coverage Status](https://codecov.io/gh/grpc/grpc-java/branch/master/graph/badge.svg)](https://codecov.io/gh/grpc/grpc-java)
+
+Supported Platforms
+-------------------
+
+gRPC-Java supports Java 8 and later. Android minSdkVersion 21 (Lollipop) and
+later are supported with [Java 8 language desugaring][android-java-8].
+
+TLS usage on Android typically requires Play Services Dynamic Security Provider.
+Please see the [Security Readme](SECURITY.md).
+
+Older Java versions are not directly supported, but a branch remains available
+for fixes and releases. See [gRFC P5 JDK Version Support
+Policy][P5-jdk-version-support].
+
+Java version | gRPC Branch
+------------ | -----------
+7            | 1.41.x
+
+[android-java-8]: https://developer.android.com/studio/write/java8-support#supported_features
+[P5-jdk-version-support]: https://github.com/grpc/proposal/blob/master/P5-jdk-version-support.md#proposal
+
+Getting Started
+---------------
+
+For a guided tour, take a look at the [quick start
+guide](https://grpc.io/docs/languages/java/quickstart) or the more explanatory [gRPC
+basics](https://grpc.io/docs/languages/java/basics).
+
+The [examples](https://github.com/grpc/grpc-java/tree/v1.78.0/examples) and the
+[Android example](https://github.com/grpc/grpc-java/tree/v1.78.0/examples/android)
+are standalone projects that showcase the usage of gRPC.
 
 Download
 --------
@@ -27,41 +55,49 @@ Download [the JARs][]. Or for Maven with non-Android, add to your `pom.xml`:
 ```xml
 <dependency>
   <groupId>io.grpc</groupId>
-  <artifactId>grpc-netty</artifactId>
-  <version>1.0.3</version>
+  <artifactId>grpc-netty-shaded</artifactId>
+  <version>1.78.0</version>
+  <scope>runtime</scope>
 </dependency>
 <dependency>
   <groupId>io.grpc</groupId>
   <artifactId>grpc-protobuf</artifactId>
-  <version>1.0.3</version>
+  <version>1.78.0</version>
 </dependency>
 <dependency>
   <groupId>io.grpc</groupId>
   <artifactId>grpc-stub</artifactId>
-  <version>1.0.3</version>
+  <version>1.78.0</version>
 </dependency>
 ```
 
 Or for Gradle with non-Android, add to your dependencies:
 ```gradle
-compile 'io.grpc:grpc-netty:1.0.3'
-compile 'io.grpc:grpc-protobuf:1.0.3'
-compile 'io.grpc:grpc-stub:1.0.3'
+runtimeOnly 'io.grpc:grpc-netty-shaded:1.78.0'
+implementation 'io.grpc:grpc-protobuf:1.78.0'
+implementation 'io.grpc:grpc-stub:1.78.0'
 ```
 
-For Android client, use `grpc-okhttp` instead of `grpc-netty` and
-`grpc-protobuf-lite` or `grpc-protobuf-nano` instead of `grpc-protobuf`:
+For Android client, use `grpc-okhttp` instead of `grpc-netty-shaded` and
+`grpc-protobuf-lite` instead of `grpc-protobuf`:
 ```gradle
-compile 'io.grpc:grpc-okhttp:1.0.3'
-compile 'io.grpc:grpc-protobuf-lite:1.0.3'
-compile 'io.grpc:grpc-stub:1.0.3'
+implementation 'io.grpc:grpc-okhttp:1.78.0'
+implementation 'io.grpc:grpc-protobuf-lite:1.78.0'
+implementation 'io.grpc:grpc-stub:1.78.0'
 ```
 
+For [Bazel](https://bazel.build), you can either
+[use Maven](https://github.com/bazelbuild/rules_jvm_external)
+(with the GAVs from above), or use `@io_grpc_grpc_java//api` et al (see below).
+
 [the JARs]:
-http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22io.grpc%22%20AND%20v%3A%221.0.3%22
+https://search.maven.org/search?q=g:io.grpc%20AND%20v:1.78.0
 
 Development snapshots are available in [Sonatypes's snapshot
-repository](https://oss.sonatype.org/content/repositories/snapshots/).
+repository](https://central.sonatype.com/repository/maven-snapshots/).
+
+Generated Code
+--------------
 
 For protobuf-based codegen, you can put your proto files in the `src/main/proto`
 and `src/test/proto` directories along with an appropriate plugin.
@@ -76,18 +112,18 @@ For protobuf-based codegen integrated with the Maven build system, you can use
     <extension>
       <groupId>kr.motd.maven</groupId>
       <artifactId>os-maven-plugin</artifactId>
-      <version>1.4.1.Final</version>
+      <version>1.7.1</version>
     </extension>
   </extensions>
   <plugins>
     <plugin>
       <groupId>org.xolstice.maven.plugins</groupId>
       <artifactId>protobuf-maven-plugin</artifactId>
-      <version>0.5.0</version>
+      <version>0.6.1</version>
       <configuration>
-        <protocArtifact>com.google.protobuf:protoc:3.0.2:exe:${os.detected.classifier}</protocArtifact>
+        <protocArtifact>com.google.protobuf:protoc:3.25.8:exe:${os.detected.classifier}</protocArtifact>
         <pluginId>grpc-java</pluginId>
-        <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.0.3:exe:${os.detected.classifier}</pluginArtifact>
+        <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.78.0:exe:${os.detected.classifier}</pluginArtifact>
       </configuration>
       <executions>
         <execution>
@@ -104,30 +140,20 @@ For protobuf-based codegen integrated with the Maven build system, you can use
 
 [protobuf-maven-plugin]: https://www.xolstice.org/protobuf-maven-plugin/
 
-For protobuf-based codegen integrated with the Gradle build system, you can use
-[protobuf-gradle-plugin][]:
+For non-Android protobuf-based codegen integrated with the Gradle build system,
+you can use [protobuf-gradle-plugin][]:
 ```gradle
-apply plugin: 'java'
-apply plugin: 'com.google.protobuf'
-
-buildscript {
-  repositories {
-    mavenCentral()
-  }
-  dependencies {
-    // ASSUMES GRADLE 2.12 OR HIGHER. Use plugin version 0.7.5 with earlier
-    // gradle versions
-    classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.0'
-  }
+plugins {
+    id 'com.google.protobuf' version '0.9.5'
 }
 
 protobuf {
   protoc {
-    artifact = "com.google.protobuf:protoc:3.0.2"
+    artifact = "com.google.protobuf:protoc:3.25.8"
   }
   plugins {
     grpc {
-      artifact = 'io.grpc:protoc-gen-grpc-java:1.0.3'
+      artifact = 'io.grpc:protoc-gen-grpc-java:1.78.0'
     }
   }
   generateProtoTasks {
@@ -140,18 +166,74 @@ protobuf {
 
 [protobuf-gradle-plugin]: https://github.com/google/protobuf-gradle-plugin
 
+The prebuilt protoc-gen-grpc-java binary uses glibc on Linux. If you are
+compiling on Alpine Linux, you may want to use the [Alpine grpc-java package][]
+which uses musl instead.
+
+[Alpine grpc-java package]: https://pkgs.alpinelinux.org/package/edge/community/x86_64/grpc-java
+
+For Android protobuf-based codegen integrated with the Gradle build system, also
+use protobuf-gradle-plugin but specify the 'lite' options:
+
+```gradle
+plugins {
+    id 'com.google.protobuf' version '0.9.5'
+}
+
+protobuf {
+  protoc {
+    artifact = "com.google.protobuf:protoc:3.25.8"
+  }
+  plugins {
+    grpc {
+      artifact = 'io.grpc:protoc-gen-grpc-java:1.78.0'
+    }
+  }
+  generateProtoTasks {
+    all().each { task ->
+      task.builtins {
+        java { option 'lite' }
+      }
+      task.plugins {
+        grpc { option 'lite' }
+      }
+    }
+  }
+}
+
+```
+
+For [Bazel](https://bazel.build), use the [`proto_library`](https://github.com/bazelbuild/rules_proto)
+and the [`java_proto_library`](https://bazel.build/reference/be/java#java_proto_library) (no `load()` required) 
+and `load("@io_grpc_grpc_java//:java_grpc_library.bzl", "java_grpc_library")` (from this project), as in
+[this example `BUILD.bazel`](https://github.com/grpc/grpc-java/blob/master/examples/BUILD.bazel).
+
+API Stability
+-------------
+
+APIs annotated with `@Internal` are for internal use by the gRPC library and
+should not be used by gRPC users. APIs annotated with `@ExperimentalApi` are
+subject to change in future releases, and library code that other projects
+may depend on should not use these APIs.
+
+We recommend using the
+[grpc-java-api-checker](https://github.com/grpc/grpc-java-api-checker)
+(an [Error Prone](https://github.com/google/error-prone) plugin)
+to check for usages of `@ExperimentalApi` and `@Internal` in any library code
+that depends on gRPC. It may also be used to check for `@Internal` usage or
+unintended `@ExperimentalApi` consumption in non-library code.
+
 How to Build
 ------------
 
 If you are making changes to gRPC-Java, see the [compiling
 instructions](COMPILING.md).
 
-Navigating Around the Source
-----------------------------
+High-level Components
+---------------------
 
-Here's a quick readers' guide to the code to help folks get started. At a high
-level there are three distinct layers to the library: __Stub__, __Channel__ &
-__Transport__.
+At a high level there are three distinct layers to the library: *Stub*,
+*Channel*, and *Transport*.
 
 ### Stub
 
@@ -159,81 +241,34 @@ The Stub layer is what is exposed to most developers and provides type-safe
 bindings to whatever datamodel/IDL/interface you are adapting. gRPC comes with
 a [plugin](https://github.com/google/grpc-java/blob/master/compiler) to the
 protocol-buffers compiler that generates Stub interfaces out of `.proto` files,
-but bindings to other datamodel/IDL should be trivial to add and are welcome.
-
-#### Key Interfaces
-
-[Stream Observer](https://github.com/google/grpc-java/blob/master/stub/src/main/java/io/grpc/stub/StreamObserver.java)
+but bindings to other datamodel/IDL are easy and encouraged.
 
 ### Channel
 
 The Channel layer is an abstraction over Transport handling that is suitable for
 interception/decoration and exposes more behavior to the application than the
 Stub layer. It is intended to be easy for application frameworks to use this
-layer to address cross-cutting concerns such as logging, monitoring, auth etc.
-Flow-control is also exposed at this layer to allow more sophisticated
-applications to interact with it directly.
-
-#### Common
-
-* [Metadata - headers & trailers](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/Metadata.java)
-* [Status - error code namespace & handling](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/Status.java)
-
-#### Client
-* [Channel - client side binding](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/Channel.java)
-* [Client Call](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/ClientCall.java)
-* [Client Interceptor](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/ClientInterceptor.java)
-
-#### Server
-* [Server call handler - analog to Channel on server](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/ServerCallHandler.java)
-* [Server Call](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/ServerCall.java)
-
+layer to address cross-cutting concerns such as logging, monitoring, auth, etc.
 
 ### Transport
 
 The Transport layer does the heavy lifting of putting and taking bytes off the
 wire. The interfaces to it are abstract just enough to allow plugging in of
-different implementations. Transports are modeled as `Stream` factories. The
-variation in interface between a server Stream and a client Stream exists to
-codify their differing semantics for cancellation and error reporting.
-
-Note the transport layer API is considered internal to gRPC and has weaker API
-guarantees than the core API under package `io.grpc`.
-
-gRPC comes with three Transport implementations:
-
-1. The [Netty-based](https://github.com/google/grpc-java/blob/master/netty)
-   transport is the main transport implementation based on
-   [Netty](http://netty.io). It is for both the client and the server.
-2. The [OkHttp-based](https://github.com/google/grpc-java/blob/master/okhttp)
-   transport is a lightweight transport based on
-   [OkHttp](http://square.github.io/okhttp/). It is mainly for use on Android
-   and is for client only.
-3. The
-   [inProcess](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/inprocess)
-   transport is for when a server is in the same process as the client. It is
-   useful for testing.
-
-#### Common
-
-* [Stream](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/internal/Stream.java)
-* [Stream Listener](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/internal/StreamListener.java)
-
-#### Client
-
-* [Client Stream](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/internal/ClientStream.java)
-* [Client Stream Listener](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/internal/ClientStreamListener.java)
-
-#### Server
-
-* [Server Stream](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/internal/ServerStream.java)
-* [Server Stream Listener](https://github.com/google/grpc-java/blob/master/core/src/main/java/io/grpc/internal/ServerStreamListener.java)
-
-
-Examples
---------
-
-The [examples](https://github.com/grpc/grpc-java/tree/master/examples)
-and the
-[Android example](https://github.com/grpc/grpc-java/tree/master/examples/android) are standalone projects that
-showcase the usage of gRPC.
+different implementations. Note the transport layer API is considered internal
+to gRPC and has weaker API guarantees than the core API under package `io.grpc`.
+
+gRPC comes with multiple Transport implementations:
+
+1. The Netty-based HTTP/2 transport is the main transport implementation based
+   on [Netty](https://netty.io). It is not officially supported on Android.
+   There is a "grpc-netty-shaded" version of this transport. It is generally
+   preferred over using the Netty-based transport directly as it requires less
+   dependency management and is easier to upgrade within many applications.
+2. The OkHttp-based HTTP/2 transport is a lightweight transport based on
+   [Okio](https://square.github.io/okio/) and forked low-level parts of
+   [OkHttp](https://square.github.io/okhttp/). It is mainly for use on Android.
+3. The in-process transport is for when a server is in the same process as the
+   client. It is used frequently for testing, while also being safe for
+   production use.
+4. The Binder transport is for Android cross-process communication on a single
+   device.
diff --git a/RELEASING.md b/RELEASING.md
index c7a63dc688e..c57829b8c25 100644
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -4,384 +4,249 @@ How to Create a Release of GRPC Java (for Maintainers Only)
 Build Environments
 ------------------
 We deploy GRPC to Maven Central under the following systems:
-- Ubuntu 14.04 with Docker 1.6.1 that runs CentOS 6.6
-- Windows 7 64-bit with MSYS2 with mingw32 and mingw64
-- Mac OS X 10.9.5
+- Ubuntu 14.04 with Docker 13.03.0 that runs CentOS 7
+- Windows 7 64-bit with Visual Studio
+- Mac OS X 10.14.6
 
 Other systems may also work, but we haven't verified them.
 
-Prerequisites
--------------
-
-### Setup OSSRH and Signing
-
-If you haven't deployed artifacts to Maven Central before, you need to setup
-your OSSRH (OSS Repository Hosting) account and signing keys.
-- Follow the instructions on [this
-  page](http://central.sonatype.org/pages/ossrh-guide.html) to set up an
-  account with OSSRH.
-  - You only need to create the account, not set up a new project
-  - Contact a gRPC maintainer to add your account after you have created it.
-- (For release deployment only) Install GnuPG and [generate your key
-  pair](https://www.gnupg.org/documentation/howtos.html). You'll also
-  need to [publish your public key](https://www.gnupg.org/gph/en/manual.html#AEN464)
-  to make it visible to the Sonatype servers
-  (e.g. `gpg --keyserver pgp.mit.edu --send-key <key ID>`).
-- Put your GnuPG key password and OSSRH account information in
-  `<your-home-directory>/.gradle/gradle.properties`.
+Common Variables
+----------------
+Many of the following commands expect release-specific variables to be set. Set
+them before continuing, and set them again when resuming.
 
+```bash
+MAJOR=1 MINOR=7 PATCH=0 # Set appropriately for new release
+VERSION_FILES=(
+  MODULE.bazel
+  build.gradle
+  core/src/main/java/io/grpc/internal/GrpcUtil.java
+  examples/MODULE.bazel
+  examples/build.gradle
+  examples/pom.xml
+  examples/android/clientcache/app/build.gradle
+  examples/android/helloworld/app/build.gradle
+  examples/android/routeguide/app/build.gradle
+  examples/android/strictmode/app/build.gradle
+  examples/example-*/build.gradle
+  examples/example-*/pom.xml
+  )
 ```
-# You need the signing properties only if you are making release deployment
-signing.keyId=<8-character-public-key-id>
-signing.password=<key-password>
-signing.secretKeyRingFile=<your-home-directory>/.gnupg/secring.gpg
-
-ossrhUsername=<ossrh-username>
-ossrhPassword=<ossrh-password>
-checkstyle.ignoreFailures=false
-```
-
-### Build Protobuf
-Protobuf libraries are needed for compiling the GRPC codegen. Despite that you
-may have installed Protobuf on your system, you may want to build Protobuf
-separately and install it under your personal directory, because
 
-1. The Protobuf version installed on your system may be different from what
-   GRPC requires. You may not want to pollute your system installation.
-2. We will deploy both 32-bit and 64-bit versions of the codegen, thus require
-   both variants of Protobuf libraries. You don't want to mix them in your
-   system paths.
 
-Please see the [Main Readme](README.md) for details on building protobuf.
-
-Tagging the Release
-----------------------
-The first step in the release process is to create a release branch, bump
-versions, and create a tag for the release. Our release branches follow the naming
+Branching the Release
+---------------------
+The first step in the release process is to create a release branch and bump
+the SNAPSHOT version. Our release branches follow the naming
 convention of `v<major>.<minor>.x`, while the tags include the patch version
-`v<major>.<minor>.<patch>`. For example, the same branch `v0.7.x`
-would be used to create all `v0.7` tags (e.g. `v0.7.0`, `v0.7.1`).
+`v<major>.<minor>.<patch>`. For example, the same branch `v1.7.x`
+would be used to create all `v1.7` tags (e.g. `v1.7.0`, `v1.7.1`).
 
-1. Create the release branch and push it to GitHub:
-
-   ```bash
-   $ MAJOR=0 MINOR=7 PATCH=0 # Set appropriately for new release
-   $ VERSION_FILES=(
-     build.gradle
-     android-interop-testing/app/build.gradle
-     examples/build.gradle
-     examples/pom.xml
-     examples/android/helloworld/app/build.gradle
-     examples/android/routeguide/app/build.gradle
-     examples/thrift/build.gradle
-     )
-   $ git checkout -b v$MAJOR.$MINOR.x master
-   $ git push upstream v$MAJOR.$MINOR.x
-   ```
+1. Review the issues in the current release [milestone](https://github.com/grpc/grpc-java/milestones)
+   for issues that won't make the cut. Check if any of them can be
+   closed. Be aware of the issues with the [TODO:release blocker][] label.
+   Consider reaching out to the assignee for the status update.
 2. For `master`, change root build files to the next minor snapshot (e.g.
-   ``0.8.0-SNAPSHOT``).
+   ``1.8.0-SNAPSHOT``).
 
    ```bash
-   $ git checkout -b bump-version master
+   git checkout -b bump-version master
    # Change version to next minor (and keep -SNAPSHOT)
-   $ sed -i 's/[0-9]\+\.[0-9]\+\.[0-9]\+\(.*CURRENT_GRPC_VERSION\)/'$MAJOR.$((MINOR+1)).0'\1/' \
+   sed -i 's/[0-9]\+\.[0-9]\+\.[0-9]\+\(.*CURRENT_GRPC_VERSION\)/'$MAJOR.$((MINOR+1)).0'\1/' \
      "${VERSION_FILES[@]}"
-   $ ./gradlew build
-   $ git commit -a -m "Start $MAJOR.$((MINOR+1)).0 development cycle"
-   ```
-3. Go through PR review and push the master branch to GitHub:
-
-   ```bash
-   $ git checkout master
-   $ git merge --ff-only bump-version
-   $ git push upstream master
+   sed -i s/$MAJOR.$MINOR.$PATCH/$MAJOR.$((MINOR+1)).0/ \
+     compiler/src/test{,Lite}/golden/Test{,Deprecated}Service.java.txt
+   ./gradlew build
+   git commit -a -m "Start $MAJOR.$((MINOR+1)).0 development cycle"
    ```
-4. For vMajor.Minor.x branch, change `README.md` to refer to the next release
-   version. _Also_ update the version numbers for protoc if the protobuf library
-   version was updated since the last release.
+3. Go through PR review and submit.
+4. Create the release branch starting just before your commit and push it to GitHub:
 
    ```bash
-   $ git checkout -b release v$MAJOR.$MINOR.x
-   # Bump documented versions. Don't forget protobuf version
-   $ ${EDITOR:-nano -w} README.md
-   $ git commit -a -m "Update README to reference $MAJOR.$MINOR.$PATCH"
+   git fetch upstream
+   git checkout -b v$MAJOR.$MINOR.x \
+     $(git log --pretty=format:%H --grep "^Start $MAJOR.$((MINOR+1)).0 development cycle" upstream/master)^
+   git push upstream v$MAJOR.$MINOR.x
    ```
-5. Change root build files to remove "-SNAPSHOT" for the next release version
-   (e.g. `0.7.0`). Commit the result and make a tag:
+5. Continue with Google-internal steps at go/grpc-java/releasing, but stop
+   before `Auto releasing using kokoro`.
+6. Create a milestone for the next release.
+7. Move items out of the release milestone that didn't make the cut. Issues that
+   may be backported should stay in the release milestone. Treat issues with the
+   'release blocker' label with special care.
+8. Begin compiling release notes. This produces a starting point:
 
    ```bash
-   # Change version to remove -SNAPSHOT
-   $ sed -i 's/-SNAPSHOT\(.*CURRENT_GRPC_VERSION\)/\1/' "${VERSION_FILES[@]}"
-   $ ./gradlew build
-   $ git commit -a -m "Bump version to $MAJOR.$MINOR.$PATCH"
-   $ git tag -a v$MAJOR.$MINOR.$PATCH -m "Version $MAJOR.$MINOR.$PATCH"
+   echo "## gRPC Java $MAJOR.$MINOR.0 Release Notes" && echo && \
+     git shortlog -e --format='%s (%h)' "$(git merge-base upstream/v$MAJOR.$((MINOR-1)).x upstream/v$MAJOR.$MINOR.x)"..upstream/v$MAJOR.$MINOR.x | cat && \
+     echo && echo && echo "Backported commits in previous release:" && \
+     git log --oneline "$(git merge-base v$MAJOR.$((MINOR-1)).0 upstream/v$MAJOR.$MINOR.x)"..v$MAJOR.$((MINOR-1)).0^
    ```
-6. Change root build files to the next snapshot version (e.g. `0.7.1-SNAPSHOT`).
-   Commit the result:
 
-   ```bash
-   # Change version to next patch and add -SNAPSHOT
-   $ sed -i 's/[0-9]\+\.[0-9]\+\.[0-9]\+\(.*CURRENT_GRPC_VERSION\)/'$MAJOR.$MINOR.$((PATCH+1))-SNAPSHOT'\1/' \
-     "${VERSION_FILES[@]}"
-   $ ./gradlew build
-   $ git commit -a -m "Bump version to $MAJOR.$MINOR.$((PATCH+1))-SNAPSHOT"
-   ```
-7. Go through PR review and push the release tag and updated release branch to
-   GitHub:
+[TODO:release blocker]: https://github.com/grpc/grpc-java/issues?q=label%3A%22TODO%3Arelease+blocker%22
+[TODO:backport]: https://github.com/grpc/grpc-java/issues?q=label%3ATODO%3Abackport
 
-   ```bash
-   $ git checkout v$MAJOR.$MINOR.x
-   $ git merge --ff-only release
-   $ git push upstream v$MAJOR.$MINOR.$PATCH
-   $ git push upstream v$MAJOR.$MINOR.x
-   ```
-8. Make sure you are [logged in](https://grpc-testing.appspot.com/manage) to
-   Jenkins, then make a [new release
-   job](https://grpc-testing.appspot.com/view/Releases/newJob)
-   * _Name_: gRPC-Java-$MAJOR.$MINOR-Windows
-   * _Copy from_: gRPC-Java-master-windows
-   * Click _OK_ button
-   * _Display Name_ under _Use custom workspace_ (not ~~Project
-     url~~): gRPC Java $MAJOR.$MINOR Windows
-   * Under _Source Code Management_, _Branches to build_'s
-   _Branch Specifier_: `*/v$MAJOR.$MINOR.x`
-   * Click _SAVE_ button
-   * Click _Build Now_
-   * Click on job #1, then _Console Output_. Verify the `git checkout` checked
-     out the correct commit
-
-Setup Build Environment
----------------------------
-
-### Linux
-The deployment for Linux uses [Docker](https://www.docker.com/) running
-CentOS 6.6 in order to ensure that we have a consistent deployment environment
-on Linux. You'll first need to install Docker if not already installed on your
-system.  Make sure to have at least version 1.7.1 or later.
-
-1. Under the [Protobuf source directory](https://github.com/google/protobuf), 
-   build the `protoc-artifacts` image:
-   
-   ```bash
-   protobuf$ docker build -t protoc-artifacts protoc-artifacts
-   ```
-2. Under the grpc-java source directory, build the `grpc-java-deploy` image:
+Tagging the Release
+-------------------
+
+1. Verify there are no open issues in the release milestone. Open issues should
+   either be deferred or resolved and the fix backported. Verify there are no
+   [TODO:release blocker][] nor [TODO:backport][] issues (open or closed), or
+   that they are tracking an issue for a different branch.
+2. Ensure that the Google-internal steps  
+   at go/grpc-java/releasing#before-tagging-a-release are completed.
+3. For vMajor.Minor.x branch, change `README.md` to refer to the next release
+   version. _Also_ update the version numbers for protoc if the protobuf library
+   version was updated since the last release.
 
    ```bash
-   grpc-java$ docker build -t grpc-java-deploy compiler
-   ```
-3. Start a Docker container that has the deploy environment set up for you. The
-   GRPC source is cloned into `/grpc-java`.
+   git checkout v$MAJOR.$MINOR.x
+   git pull upstream v$MAJOR.$MINOR.x
+   git checkout -b release-v$MAJOR.$MINOR.$PATCH
    
-   ```bash
-   $ docker run -it --rm=true grpc-java-deploy
-   ```
+   # Bump documented gRPC versions.
+   # Also update protoc version to match protobuf version in gradle/libs.versions.toml.
+   ${EDITOR:-nano -w} README.md
    
-   Note that the container will be deleted after you exit. Any changes you have
-   made (e.g., copied configuration files) will be lost. If you want to keep the
-   container, remove `--rm=true` from the command line.
-4. Next, you'll need to copy your OSSRH credentials and GnuPG keys to your docker container.
-   In Docker:
+   git commit -a -m "Update README etc to reference $MAJOR.$MINOR.$PATCH"
    ```
-   # mkdir /root/.gradle
-   ```
-   Find the container ID in your bash prompt, which is shown as `[root@<container-ID> ...]`.
-   In host:
-   ```
-   $ docker cp ~/.gnupg <container-ID>:/root/
-   $ docker cp ~/.gradle/gradle.properties <container-ID>:/root/.gradle/
-   ```
-   
-   You'll also need to update `signing.secretKeyRingFile` in
-   `/root/.gradle/gradle.properties` to point to `/root/.gnupg/secring.gpg`.
-
-### Windows
-
-#### Windows 64-bit with MSYS2 (Recommended for Windows)
-Because the gcc shipped with MSYS2 doesn't support multilib, you have to
-compile and deploy 32-bit and 64-bit binaries in separate steps.
-
-##### Under MinGW-w64 Win32 Shell
-1. Compile and install 32-bit protobuf:
-
-   ```bash
-   protobuf$ ./configure --disable-shared --prefix=$HOME/protobuf-32
-   protobuf$ make clean && make && make install
-   ```
-2. Configure CXXFLAGS needed by the protoc plugin when building.
-
-   ```bash
-   grpc-java$ export CXXFLAGS="-I$HOME/protobuf-32/include" \
-     LDFLAGS="-L$HOME/protobuf-32/lib"
-   ```
-
-##### Under MinGW-w64 Win64 Shell
-1. Compile and install 64-bit protobuf:
-
-   ```bash
-   protobuf$ ./configure --disable-shared --prefix=$HOME/protobuf-64
-   protobuf$ make clean && make && make install
-   ```
-2. Configure CXXFLAGS needed by the protoc plugin when building.
-
-   ```bash
-   grpc-java$ export CXXFLAGS="-I$HOME/protobuf-64/include" \
-     LDFLAGS="-L$HOME/protobuf-64/lib"
-   ```
-
-#### Windows 64-bit with Cygwin64 (TODO: incomplete)
-Because the MinGW gcc shipped with Cygwin64 doesn't support multilib, you have
-to compile and deploy 32-bit and 64-bit binaries in separate steps.
-
-1. Compile and install 32-bit protobuf. `-static-libgcc -static-libstdc++` are
-   needed for `protoc` to be successfully run in the unit test.
-   
-   ```bash
-   protobuf$ LDFLAGS="-static-libgcc -static-libstdc++" ./configure --host=i686-w64-mingw32 --disable-shared --prefix=$HOME/protobuf-32
-   protobuf$ make clean && make && make install
-   ```
-
-2. Compile and install 64-bit protobuf:
-
-   ```bash
-   protobuf$ ./configure --host=x86_64-w64-mingw32 --disable-shared --prefix=$HOME/protobuf-64
-   protobuf$ make clean && make && make install
-   ```
-
-### Mac
-Please refer to [Protobuf
-README](https://github.com/google/protobuf/blob/master/README.md) for how to
-set up GCC and Unix tools on Mac.
-
-Mac OS X has been 64-bit-only since 10.7 and we are compiling for 10.7 and up.
-We only build 64-bit artifact for Mac.
-
-1. Compile and install protobuf:
+4. Change root build files to remove "-SNAPSHOT" for the next release version
+   (e.g. `0.7.0`). Commit the result and make a tag:
 
    ```bash
-   protobuf$ CXXFLAGS="-m64" ./configure --disable-shared --prefix=$HOME/protobuf
-   protobuf$ make clean && make && make install
+   # Change version to remove -SNAPSHOT
+   sed -i 's/-SNAPSHOT\(.*CURRENT_GRPC_VERSION\)/\1/' "${VERSION_FILES[@]}"
+   sed -i s/-SNAPSHOT// compiler/src/test{,Lite}/golden/Test{,Deprecated}Service.java.txt
+   ./gradlew build
+   git commit -a -m "Bump version to $MAJOR.$MINOR.$PATCH"
+   git tag -a v$MAJOR.$MINOR.$PATCH -m "Version $MAJOR.$MINOR.$PATCH"
    ```
-2. Configure CXXFLAGS needed by the protoc plugin when building.
+5. Change root build files to the next snapshot version (e.g. `0.7.1-SNAPSHOT`).
+   Commit the result:
 
    ```bash
-   grpc-java$ export CXXFLAGS="-I$HOME/protobuf/include" \
-     LDFLAGS="$HOME/protobuf/lib/libprotobuf.a $HOME/protobuf/lib/libprotoc.a"
-   ```
-
-Build and Deploy
-----------------
-We currently distribute the following OSes and architectures:
-
-| OS | x86_32 | x86_64 |
-| --- | --- | --- |
-| Linux | X | X |
-| Windows | X | X |
-| Mac |  | X |
-
-Deployment to Maven Central (or the snapshot repo) is a two-step process. The only
-artifact that is platform-specific is codegen, so we only need to deploy the other
-jars once. So the first deployment is for all of the artifacts from one of the selected
-OS/architectures. After that, we then deploy the codegen artifacts for the remaining
-OS/architectures.
-
-**NOTE: _Before building/deploying, be sure to switch to the appropriate branch or tag in
-the grpc-java source directory._**
-
-### First Deployment
-
-As stated above, this only needs to be done once for one of the selected OS/architectures.
-The following command will build the whole project and upload it to Maven
-Central. Parallel building [is not safe during
-uploadArchives](https://issues.gradle.org/browse/GRADLE-3420).
-```bash
-grpc-java$ ./gradlew clean build && ./gradlew -Dorg.gradle.parallel=false uploadArchives
-```
-
-If the version has the `-SNAPSHOT` suffix, the artifacts will automatically
-go to the snapshot repository. Otherwise it's a release deployment and the
-artifacts will go to a freshly created staging repository.
-
-### Deploy GRPC Codegen for Additional Platforms
-The previous step will only deploy the codegen artifacts for the OS you run on
-it and the architecture of your JVM. For a fully fledged deployment, you will
-need to deploy the codegen for all other supported OSes and architectures.
-
-To deploy the codegen for an OS and architecture, you must run the following
-commands on that OS and specify the architecture by the flag `-PtargetArch=<arch>`.
-
-If you are doing a snapshot deployment:
+   # Change version to next patch and add -SNAPSHOT
+   sed -i 's/[0-9]\+\.[0-9]\+\.[0-9]\+\(.*CURRENT_GRPC_VERSION\)/'$MAJOR.$MINOR.$((PATCH+1))-SNAPSHOT'\1/' \
+     "${VERSION_FILES[@]}"
+   sed -i s/$MAJOR.$MINOR.$PATCH/$MAJOR.$MINOR.$((PATCH+1))-SNAPSHOT/ \
+     compiler/src/test{,Lite}/golden/Test{,Deprecated}Service.java.txt
+   ./gradlew build
+   git commit -a -m "Bump version to $MAJOR.$MINOR.$((PATCH+1))-SNAPSHOT"
+   git push -u origin release-v$MAJOR.$MINOR.$PATCH
+   ```
+   Raise a PR and set the base branch of the PR to v$MAJOR.$MINOR.x of the upstream grpc-java repo.
+6. Go through PR review and push the release tag and updated release branch to
+   GitHub (DO NOT click the merge button on the GitHub page):
+
+   ```bash
+   git checkout v$MAJOR.$MINOR.x
+   git merge --ff-only release-v$MAJOR.$MINOR.$PATCH
+   git push upstream v$MAJOR.$MINOR.x
+   git push upstream v$MAJOR.$MINOR.$PATCH
+   ```
+7. Close the release milestone.
+
+8. Trigger build as described in "Auto releasing using kokoro" at
+   go/grpc-java/releasing.
+
+    It runs three jobs on Kokoro, one on each platform. See their scripts:
+    `linux_artifacts.sh`, `windows.bat`, and `macos.sh`. The mvn-artifacts/
+    outputs of each script is combined into a single folder and then processed
+    by `upload_artifacts.sh`, which signs the files and uploads to Sonatype.
+
+9. Once all of the artifacts have been pushed to the staging repository, the
+   repository should have been closed by `upload_artifacts.sh`. Closing triggers
+   several sanity checks on the repository. If this completes successfully, the
+   repository can then be `released`, which will begin the process of pushing
+   the new artifacts to Maven Central (the staging repository will be destroyed
+   in the process). You can see the complete process for releasing to Maven
+   Central on the [OSSRH site](https://central.sonatype.org/publish/publish-portal-ossrh-staging-api/#deploying).
+
+10. We have containers for each release to detect compatibility regressions with
+    old releases. Generate one for the new release by following the [GCR image
+    generation instructions][gcr-image]. Summary:
+    ```bash
+    # If you haven't previously configured docker:
+    gcloud auth configure-docker us-docker.pkg.dev
+
+    # In main grpc repo, add the new version to matrix
+    ${EDITOR:-nano -w} tools/interop_matrix/client_matrix.py
+    tools/interop_matrix/create_matrix_images.py --git_checkout --release=v$MAJOR.$MINOR.$PATCH \
+        --upload_images --language java
+    docker pull us-docker.pkg.dev/grpc-testing/testing-images-public/grpc_interop_java:v$MAJOR.$MINOR.$PATCH
+    docker_image=us-docker.pkg.dev/grpc-testing/testing-images-public/grpc_interop_java:v$MAJOR.$MINOR.$PATCH \
+        tools/interop_matrix/testcases/java__master
+
+    # Commit the changes
+    git commit --all -m "[interop] Add grpc-java $MAJOR.$MINOR.$PATCH to client_matrix.py"
+
+    # Create a PR with the `release notes: no` label and run ad-hoc test against your PR
+    ```
+[gcr-image]: https://github.com/grpc/grpc/blob/master/tools/interop_matrix/README.md#step-by-step-instructions-for-adding-a-gcr-image-for-a-new-release-for-compatibility-test
+
+11. Update gh-pages with the new Javadoc. Generally the file is on repo1
+    15 minutes after publishing:
+
+    ```bash
+    git checkout gh-pages
+    git pull --ff-only upstream gh-pages
+    rm -r javadoc/
+    wget -O grpc-all-javadoc.jar "https://repo1.maven.org/maven2/io/grpc/grpc-all/$MAJOR.$MINOR.$PATCH/grpc-all-$MAJOR.$MINOR.$PATCH-javadoc.jar"
+    unzip -d javadoc grpc-all-javadoc.jar
+    patch -p1 < ga.patch
+    rm grpc-all-javadoc.jar
+    rm -r javadoc/META-INF/
+    git add -A javadoc
+    git commit -m "Javadoc for $MAJOR.$MINOR.$PATCH"
+    git push upstream gh-pages
+    ```
+
+    Verify the current version is [live on grpc.io](https://grpc.io/grpc-java/javadoc/).
+
+12. Add [Release Notes](https://github.com/grpc/grpc-java/releases) for the new tag.
+    *Make sure that any backports are reflected in the release notes.*
+
+13. Notify the Community. Post a release announcement to
+    [grpc-io](https://groups.google.com/forum/#!forum/grpc-io)
+    (`grpc-io@googlegroups.com`) with the title `gRPC-Java v$MAJOR.$MINOR.$PATCH
+    Released`. The email content should link to the GitHub release notes and
+    include a copy of them.
+
+14. Update README.md. Cherry-pick the commit that updated the README.md into the
+    master branch.
+
+    ```bash
+    git checkout -b bump-readme master
+    git cherry-pick v$MAJOR.$MINOR.$PATCH^
+    git push --set-upstream origin bump-readme
+    ```
+
+    Create a PR and go through the review process
+
+15. Update version referenced by tutorials. Update `params.grpc_vers.java` in
+    [config.yaml](https://github.com/grpc/grpc.io/blob/master/config.yaml) of
+    the grpc.io repository. Create a PR and go through the review process.
+
+Post-release upgrades
+---------------------
+Upgrade dependencies after the release so they can be well-tested before the
+next release.
 
-```bash
-grpc-java$ ./gradlew clean grpc-compiler:build grpc-compiler:uploadArchives \
-    -PtargetArch=<arch> -Dorg.gradle.parallel=false
-```
+Upgrade the Gradle plugins in `settings.gradle` and the Gradle version in
+`gradle/wrapper/gradle-wrapper.properties`. Make sure to read the release notes
+for each dependency upgraded. Test by doing a regular build.
 
-When deploying a Release, the first deployment will create
-[a new staging repository](https://oss.sonatype.org/#stagingRepositories). You'll need
-to look up the ID in the OSSRH UI (usually in the form of `iogrpc-*`). Codegen
-deployment commands should include `-PrepositoryId=<repository-id>` in order to
-ensure that the artifacts are pushed to the same staging repository.
+Upgrade the regular dependencies in `gradle/libs.versions.toml`, except for
+Netty and netty-tcnative. To find available upgrades:
 
 ```bash
-grpc-java$ ./gradlew clean grpc-compiler:build grpc-compiler:uploadArchives -PtargetArch=<arch> \
-    -PrepositoryId=<repository-id> -Dorg.gradle.parallel=false
+./gradlew checkForUpdates
 ```
 
-Releasing on Maven Central
---------------------------
-Once all of the artifacts have been pushed to the staging repository, the
-repository must first be `closed`, which will trigger several sanity checks
-on the repository. If this completes successfully, the repository can then
-be `released`, which will begin the process of pushing the new artifacts to
-Maven Central (the staging repository will be destroyed in the process). You can
-see the complete process for releasing to Maven Central on the [OSSRH site]
-(http://central.sonatype.org/pages/releasing-the-deployment.html).
-
-Update README.md
-----------------
-After waiting ~1 day and verifying that the release appears on [Maven Central]
-(http://mvnrepository.com/), cherry-pick the commit that updated the README into
-the master branch and go through review process.
-
-```
-$ git checkout -b bump-readme master
-$ git cherry-pick v$MAJOR.$MINOR.$PATCH^
-```
-
-Update version referenced by tutorials
---------------------------------------
-
-Update the `grpc_java_release_tag` in
-[\_data/config.yml](https://github.com/grpc/grpc.github.io/blob/master/_data/config.yml)
-of the grpc.github.io repository.
-
-Notify the Community
---------------------
-Finally, document and publicize the release.
-
-1. Add [Release Notes](https://github.com/grpc/grpc-java/releases) for the new tag.
-   The description should include any major fixes or features since the last release.
-   You may choose to add links to bugs, PRs, or commits if appropriate.
-2. Post a release announcement to [grpc-io](https://groups.google.com/forum/#!forum/grpc-io)
-   (`grpc-io@googlegroups.com`). The title should be something that clearly identifies
-   the release (e.g.`GRPC-Java <tag> Released`).
-
-Update Hosted Javadoc
----------------------
-
-Now we need to update gh-pages with the new Javadoc:
-
-```bash
-git checkout gh-pages
-rm -r javadoc/
-wget -O grpc-all-javadoc.jar "http://search.maven.org/remotecontent?filepath=io/grpc/grpc-all/$MAJOR.$MINOR.$PATCH/grpc-all-$MAJOR.$MINOR.$PATCH-javadoc.jar"
-unzip -d javadoc grpc-all-javadoc.jar
-rm grpc-all-javadoc.jar
-rm -r javadoc/META-INF/
-git add -A javadoc
-git commit -m "Javadoc for $MAJOR.$MINOR.$PATCH"
-```
+Test by doing a regular build. For each step, if a dependency cannot be
+upgraded, add a comment. Create issues in other projects for breakages, and in
+gRPC for things that will need a migration effort.
 
-Push gh-pages to the main repository and verify the current version is [live
-on grpc.io](http://www.grpc.io/grpc-java/javadoc/).
+When happy with the dependency upgrades, update the versions in `MODULE.bazel`,
+`repositories.bzl`, and the various `pom.xml` and `build.gradle` files in
+`examples/`.
diff --git a/SECURITY.md b/SECURITY.md
index 1ab534e204f..fa5b85c0e3a 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,113 +1,156 @@
+# Security Policy
+
+For information on gRPC Security Policy and reporting potentional security
+issues, please see [gRPC CVE Process][].
+
+[gRPC CVE Process]: https://github.com/grpc/proposal/blob/master/P4-grpc-cve-process.md
+
 # Authentication
 
-gRPC supports a number of different mechanisms for asserting identity between an client and server. This document provides code samples demonstrating how to provide SSL/TLS encryption support and identity assertions in Java, as well as passing OAuth2 tokens to services that support it.
+gRPC supports a number of different mechanisms for asserting identity between an
+client and server. This document provides code samples demonstrating how to
+provide SSL/TLS encryption support and identity assertions in Java, as well as
+passing OAuth2 tokens to services that support it.
 
 # Transport Security (TLS)
 
-HTTP/2 over TLS mandates the use of [ALPN](https://tools.ietf.org/html/draft-ietf-tls-applayerprotoneg-05) to negotiate the use of the h2 protocol. ALPN is a fairly new standard and (where possible) gRPC also supports protocol negotiation via [NPN](https://tools.ietf.org/html/draft-agl-tls-nextprotoneg-04) for systems that do not yet support ALPN.
+HTTP/2 over TLS mandates the use of [ALPN](https://tools.ietf.org/html/rfc7301)
+to negotiate the use of the h2 protocol and support for the GCM mode of AES.
 
-On Android, use the [Play Services Provider](#tls-on-android). For non-Android systems, use [OpenSSL](#tls-with-openssl).
+There are multiple options available, but on Android we recommend using the
+[Play Services Provider](#tls-on-android) and for non-Android systems we
+recommend [netty-tcnative with
+BoringSSL](#tls-with-netty-tcnative-on-boringssl).
 
 ## TLS on Android
 
-On Android we recommend the use of the [Play Services Dynamic Security Provider](http://appfoundry.be/blog/2014/11/18/Google-Play-Services-Dynamic-Security-Provider) to ensure your application has an up-to-date OpenSSL library with the necessary ciper-suites and a reliable ALPN implementation.
+On Android we recommend the use of the [Play Services Dynamic Security
+Provider][] to ensure your application has an up-to-date OpenSSL library with
+the necessary cipher-suites and a reliable ALPN implementation. This requires
+[updating the security provider at runtime][config-psdsp].
+
+Although ALPN mostly works on newer Android releases (especially since 5.0),
+there are bugs and discovered security vulnerabilities that are only fixed by
+upgrading the security provider. Thus, we recommend using the Play Service
+Dynamic Security Provider for all Android versions.
+
+*Note: The Dynamic Security Provider must be installed **before** creating a
+gRPC OkHttp channel. gRPC statically initializes the security protocol(s)
+available, which means that changes to the security provider after the first
+channel is created will not be noticed by gRPC.*
+
+[Play Services Dynamic Security Provider]: https://www.appfoundry.be/blog/2014/11/18/Google-Play-Services-Dynamic-Security-Provider/
+[config-psdsp]: https://developer.android.com/training/articles/security-gms-provider.html
 
-You may need to [update the security provider](https://developer.android.com/training/articles/security-gms-provider.html) to enable ALPN support, especially for Android versions < 5.0. If the provider fails to update, ALPN may not work.
+### Bundling Conscrypt
 
-## TLS with OpenSSL
+If depending on Play Services is not an option for your app, then you may bundle
+[Conscrypt](https://conscrypt.org) with your application. Binaries are available
+on [Maven Central][conscrypt-maven].
+
+Like the Play Services Dynamic Security Provider, you must still "install"
+Conscrypt before use.
+
+```java
+import org.conscrypt.Conscrypt;
+import java.security.Security;
+...
+
+Security.insertProviderAt(Conscrypt.newProvider(), 1);
+```
 
-This is currently the recommended approach for using gRPC over TLS (on non-Android systems).
+[conscrypt-maven]: https://search.maven.org/#search%7Cga%7C1%7Cg%3Aorg.conscrypt%20a%3Aconscrypt-android
 
-The main benefits of using OpenSSL are:
+## TLS on non-Android
 
-1. **Speed**: In local testing, we've seen performance improvements of 3x over the JDK. GCM, which is used by the only cipher suite required by the HTTP/2 spec, is 10-500x faster.
-2. **Ciphers**: OpenSSL has its own ciphers and is not dependent on the limitations of the JDK. This allows supporting GCM on Java 7.
-3. **ALPN to NPN Fallback**: if the remote endpoint doesn't support ALPN.
-4. **Version Independence**: does not require using a different library version depending on the JDK update.
+OpenJDK versions prior to Java 8u252 do not support ALPN. Java 8 has 10% the
+performance of OpenSSL.
 
-Support for OpenSSL is only provided for the Netty transport via [netty-tcnative](https://github.com/netty/netty-tcnative), which is a fork of
-[Apache Tomcat's tcnative](http://tomcat.apache.org/native-doc/), a JNI wrapper around OpenSSL.
+We recommend most users use grpc-netty-shaded, which includes netty-tcnative on
+BoringSSL. It includes pre-built libraries for 64 bit Windows, OS X, and 64 bit
+Linux. For 32 bit Windows, Conscrypt is an option. For all other platforms, Java
+9+ is required.
 
-### OpenSSL: Dynamic vs Static (which to use?)
+For users of xDS management protocol, the grpc-netty-shaded transport is
+particularly appropriate since it is already used internally for the xDS
+protocol and is a runtime dependency of grpc-xds.
 
-As of version `1.1.33.Fork14`, netty-tcnative provides two options for usage: statically or dynamically linked. For simplification of initial setup,
-we recommend that users first look at `netty-tcnative-boringssl-static`, which is statically linked against BoringSSL and Apache APR. Using this artifact requires no extra installation and guarantees that ALPN and the ciphers required for
-HTTP/2 are available. In addition, starting with `1.1.33.Fork16` binaries for
-all supported platforms can be included at compile time and the correct binary
-for the platform can be selected at runtime.
+For users of grpc-netty we recommend [netty-tcnative with
+BoringSSL](#tls-with-netty-tcnative-on-boringssl), although using the built-in
+JDK support in Java 9+, [Conscrypt](#tls-with-conscrypt), and [netty-tcnative
+with OpenSSL](#tls-with-netty-tcnative-on-openssl) are other valid options.
 
-Production systems, however, may require an easy upgrade path for OpenSSL security patches. In this case, relying on the statically linked artifact also implies waiting for the Netty team
-to release the new artifact to Maven Central, which can take some time. A better solution in this case is to use the dynamically linked `netty-tcnative` artifact, which allows the site administrator
-to easily upgrade OpenSSL in the standard way (e.g. apt-get) without relying on any new builds from Netty.
+[Netty TCNative](https://github.com/netty/netty-tcnative) is a fork of
+[Apache Tomcat's tcnative](https://tomcat.apache.org/native-doc/) and is a JNI
+wrapper around OpenSSL/BoringSSL/LibreSSL.
 
-### OpenSSL: Statically Linked (netty-tcnative-boringssl-static)
+We recommend BoringSSL for its simplicity and low occurrence of security
+vulnerabilities relative to OpenSSL. BoringSSL is used by Conscrypt as well.
 
-This is the simplest way to configure the Netty transport for OpenSSL. You just need to add the appropriate `netty-tcnative-boringssl-static` artifact to your application's classpath.
+### TLS with netty-tcnative on BoringSSL
 
-Artifacts are available on [Maven Central](http://repo1.maven.org/maven2/io/netty/netty-tcnative-boringssl-static/) for the following platforms:
+Netty-tcnative with BoringSSL includes BoringSSL statically linked in the
+binary. This means the system's pre-installed TLS libraries will not be used.
+Production systems that have centralized upgrade agility in the face of
+security vulnerabilities may want to use [netty-tcnative on
+OpenSSL](#tls-with-netty-tcnative-on-openssl) instead.
 
-Maven Classifier | Description
----------------- | -----------
-windows-x86_64 | Windows distribution
-osx-x86_64 | Mac distribution
-linux-x86_64 | Linux distribution
+Users of grpc-netty-shaded will automatically use netty-tcnative with
+BoringSSL.
 
-##### Getting netty-tcnative-boringssl-static from Maven
+grpc-netty users will need to add the appropriate
+`netty-tcnative-boringssl-static` artifact to the application's classpath.
+Artifacts are available for 64 bit Windows, OS X, and 64 bit Linux.
 
-In Maven, you can use the [os-maven-plugin](https://github.com/trustin/os-maven-plugin) to help simplify the dependency.
+Depending on netty-tcnative-boringssl-static will include binaries for all
+supported platforms. For Maven:
 
 ```xml
-<project>
   <dependencies>
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-tcnative-boringssl-static</artifactId>
-      <version>1.1.33.Fork26</version>
+      <version>2.0.20.Final</version> <!-- See table for correct version -->
+      <scope>runtime</scope>
     </dependency>
   </dependencies>
-</project>
 ```
 
-##### Getting netty-tcnative-boringssl-static from Gradle
-
-Gradle you can use the [osdetector-gradle-plugin](https://github.com/google/osdetector-gradle-plugin), which is a wrapper around the os-maven-plugin.
+And for Gradle:
 
 ```gradle
-buildscript {
-  repositories {
-    mavenCentral()
-  }
-}
-
 dependencies {
-    compile 'io.netty:netty-tcnative-boringssl-static:1.1.33.Fork26'
+  // See table for correct version
+  runtime 'io.netty:netty-tcnative-boringssl-static:2.0.20.Final'
 }
 ```
 
-### OpenSSL: Dynamically Linked (netty-tcnative)
-
-If for any reason you need to dynamically link against OpenSSL (e.g. you need control over the version of OpenSSL), you can instead use the `netty-tcnative` artifact.
+For projects sensitive to binary size, specify the classifier for the precise
+platform you need: `windows-x86_64`, `osx-x86_64`, `linux-x86_64`. You can also
+use [os-maven-plugin](https://github.com/trustin/os-maven-plugin) or
+[osdetector-gradle-plugin](https://github.com/google/osdetector-gradle-plugin),
+to choose the classifier for the platform running the build.
 
-Requirements:
+### TLS with netty-tcnative on OpenSSL
 
-1. [OpenSSL](https://www.openssl.org/) version >= 1.0.2 for ALPN support, or version >= 1.0.1 for NPN.
-2. [Apache APR library (libapr-1)](https://apr.apache.org/) version >= 1.5.2.
-3. [netty-tcnative](https://github.com/netty/netty-tcnative) version >= 1.1.33.Fork7 must be on classpath. Prior versions only supported NPN and only Fedora-derivatives were supported for Linux.
-
-Artifacts are available on [Maven Central](http://repo1.maven.org/maven2/io/netty/netty-tcnative/) for the following platforms:
+Using OpenSSL can have more initial configuration issues, but can be useful if
+your OS's OpenSSL version is recent and kept up-to-date with security fixes.
+OpenSSL is not included with tcnative, but instead is dynamically linked using
+your operating system's OpenSSL.
 
-Classifier | Description
----------------- | -----------
-windows-x86_64 | Windows distribution
-osx-x86_64 | Mac distribution
-linux-x86_64 | Used for non-Fedora derivatives of Linux
-linux-x86_64-fedora | Used for Fedora derivatives
+To use OpenSSL you will use the `netty-tcnative` artifact. It requires:
 
-On Linux it should be noted that OpenSSL uses a different soname for Fedora derivatives than other Linux releases. To work around this limitation, netty-tcnative deploys two separate versions for linux.
+1. [OpenSSL](https://www.openssl.org/) version >= 1.0.2 for ALPN support.
+2. [Apache APR library (libapr-1)](https://apr.apache.org/) version >= 1.5.2.
 
-##### Getting netty-tcnative from Maven
+You must specify a classifier for the correct netty-tcnative binary:
+`windows-x86_64`, `osx-x86_64`, `linux-x86_64`, or `linux-x86_64-fedora`.
+Fedora derivatives use a different soname from other Linux distributations, so
+you must select the "fedora" version on those distributions.
 
-In Maven, you can use the [os-maven-plugin](https://github.com/trustin/os-maven-plugin) to help simplify the dependency.
+In Maven, you can use the
+[os-maven-plugin](https://github.com/trustin/os-maven-plugin) to help simplify
+the dependency.
 
 ```xml
 <project>
@@ -115,8 +158,9 @@ In Maven, you can use the [os-maven-plugin](https://github.com/trustin/os-maven-
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-tcnative</artifactId>
-      <version>1.1.33.Fork26</version>
+      <version>2.0.20.Final</version> <!-- see table for correct version -->
       <classifier>${tcnative.classifier}</classifier>
+      <scope>runtime</scope>
     </dependency>
   </dependencies>
 
@@ -126,7 +170,7 @@ In Maven, you can use the [os-maven-plugin](https://github.com/trustin/os-maven-
       <extension>
         <groupId>kr.motd.maven</groupId>
         <artifactId>os-maven-plugin</artifactId>
-        <version>1.4.0.Final</version>
+        <version>1.7.1</version>
       </extension>
     </extensions>
     <plugins>
@@ -158,9 +202,8 @@ In Maven, you can use the [os-maven-plugin](https://github.com/trustin/os-maven-
 </project>
 ```
 
-##### Getting netty-tcnative from Gradle
-
-Gradle you can use the [osdetector-gradle-plugin](https://github.com/google/osdetector-gradle-plugin), which is a wrapper around the os-maven-plugin.
+And in Gradle you can use the
+[osdetector-gradle-plugin](https://github.com/google/osdetector-gradle-plugin).
 
 ```gradle
 buildscript {
@@ -183,58 +226,34 @@ if (osdetector.os == "linux" && osdetector.release.isLike("fedora")) {
 }
 
 dependencies {
-    compile 'io.netty:netty-tcnative:1.1.33.Fork26:' + tcnative_classifier
+    runtime 'io.netty:netty-tcnative:2.0.20.Final:' + tcnative_classifier
 }
 ```
 
-## TLS with JDK (Jetty ALPN/NPN)
-
-**WARNING: DON'T DO THIS!!**
-
-*For non-Android systems, the recommended approach is to use [OpenSSL](#tls-with-openssl). Using the JDK for ALPN is generally much slower and may not support the necessary ciphers for HTTP2.*
+### TLS with Conscrypt
 
-*Jetty ALPN brings its own baggage in that the Java bootclasspath needs to be modified, which may not be an option for some environments. In addition, a specific version of Jetty ALPN has to be used for a given version of the JRE. If the versions don't match the negotiation will fail, but you won't really know why. And since there is such a tight coupling between Jetty ALPN and the JRE, there are no guarantees that Jetty ALPN will support every JRE out in the wild.*
+[Conscrypt](https://conscrypt.org) provides an implementation of the JSSE
+security APIs based on BoringSSL. Pre-built binaries are available for 32 and
+64 bit Windows, OS X, and 64 bit Linux.
 
-*The moral of the story is: Don't use the JDK for ALPN!  But if you absolutely have to, here's how you do it... :)*
+Depend on `conscrypt-openjdk-uber` for binaries of all supported JRE platforms.
+For projects sensitive to binary size, depend on `conscrypt-openjdk` and
+specify the appropriate classifier. `os-maven-plugin` and
+`osdetector-gradle-plugin` may also be used. See the documentation for
+[netty-tcnative-boringssl-static](#tls-with-netty-tcnative-on-boringssl) for
+example usage of the plugins.
 
----
+Generally you will "install" Conscrypt before use, for gRPC to find.
 
-If not using the Netty transport (or you are unable to use OpenSSL for some reason) another alternative is to use the JDK for TLS.
-
-No standard Java release has built-in support for ALPN today ([there is a tracking issue](https://bugs.openjdk.java.net/browse/JDK-8051498) so go upvote it!) so we need to use the [Jetty-ALPN](https://github.com/jetty-project/jetty-alpn) (or [Jetty-NPN](https://github.com/jetty-project/jetty-npn) if on Java < 8) bootclasspath extension for OpenJDK. To do this, add an `Xbootclasspath` JVM option referencing the path to the Jetty `alpn-boot` jar.
-
-```sh
-java -Xbootclasspath/p:/path/to/jetty/alpn/extension.jar ...
-```
-
-Note that you must use the [release of the Jetty-ALPN jar](http://www.eclipse.org/jetty/documentation/current/alpn-chapter.html#alpn-versions) specific to the version of Java you are using. However, you can use the JVM agent [Jeety-ALPN-Agent](https://github.com/jetty-project/jetty-alpn-agent) to load the correct Jetty `alpn-boot` jar file for the current Java version. To do this, instead of adding an `Xbootclasspath` option, add a `javaagent` JVM option referencing the path to the Jetty `alpn-agent` jar.
+```java
+import org.conscrypt.Conscrypt;
+import java.security.Security;
+...
 
-```sh
-java -javaagent:/path/to/jetty-alpn-agent.jar ...
+// Somewhere in main()
+Security.insertProviderAt(Conscrypt.newProvider(), 1);
 ```
 
-### JDK Ciphers
-
-Java 7 does not support [the cipher suites recommended](https://tools.ietf.org/html/draft-ietf-httpbis-http2-17#section-9.2.2) by the HTTP2 specification. To address this we suggest servers use Java 8 where possible or use an alternative JCE implementation such as [Bouncy Castle](https://www.bouncycastle.org/java.html). If this is not practical it is possible to use other ciphers but you need to ensure that the services you intend to call have [allowed out-of-spec ciphers](https://github.com/grpc/grpc/issues/681) and have evaluated the security risks of doing so.
-
-Users should be aware that GCM is [_very_ slow (1 MB/s)](https://bugzilla.redhat.com/show_bug.cgi?id=1135504) before Java 8u60. With Java 8u60 GCM is 10x faster (10-20 MB/s), but that is still slow compared to OpenSSL (~200 MB/s), especially with AES-NI support (~1 GB/s). GCM cipher suites are the only suites available that comply with HTTP2's cipher requirements.
-
-### Configuring Jetty ALPN in Web Containers
-
-Some web containers, such as [Jetty](http://www.eclipse.org/jetty/documentation/current/jetty-classloading.html) restrict access to server classes for web applications. A gRPC client running within such a container must be properly configured to allow access to the ALPN classes. In Jetty, this is done by including a `WEB-INF/jetty-env.xml` file containing the following:
-
-```xml
-<?xml version="1.0"  encoding="ISO-8859-1"?>
-<!DOCTYPE Configure PUBLIC "-//Mort Bay Consulting//DTD Configure//EN" "http://www.eclipse.org/jetty/configure.dtd">
-<Configure class="org.eclipse.jetty.webapp.WebAppContext">
-    <!-- Must be done in jetty-env.xml, since jetty-web.xml is loaded too late.   -->
-    <!-- Removing ALPN from the blacklisted server classes (using "-" to remove). -->
-    <!-- Must prepend to the blacklist since order matters.                       -->
-    <Call name="prependServerClass">
-        <Arg>-org.eclipse.jetty.alpn.</Arg>
-    </Call>
-</Configure>
-```
 ## Enabling TLS on a server
 
 To use TLS on the server, a certificate chain and private key need to be
@@ -242,49 +261,156 @@ specified in PEM format. The standard TLS port is 443, but we use 8443 below to
 avoid needing extra permissions from the OS.
 
 ```java
-Server server = ServerBuilder.forPort(8443)
-    // Enable TLS
-    .useTransportSecurity(certChainFile, privateKeyFile)
+ServerCredentials creds = TlsServerCredentials.create(certChainFile, privateKeyFile);
+Server server = Grpc.newServerBuilderForPort(8443, creds)
     .addService(serviceImplementation)
-    .build();
-server.start();
+    .build()
+    .start();
 ```
 
 If the issuing certificate authority is not known to the client then a properly
-configured SslContext or SSLSocketFactory should be provided to the
-NettyChannelBuilder or OkHttpChannelBuilder, respectively.
+configured trust manager should be provided to TlsChannelCredentials and used to
+construct the channel.
 
 ## Mutual TLS
 
 [Mutual authentication][] (or "client-side authentication") configuration is similar to the server by providing truststores, a client certificate and private key to the client channel.  The server must also be configured to request a certificate from clients, as well as truststores for which client certificates it should allow.
 
 ```java
-Server server = NettyServerBuilder.forPort(8443)
-    .sslContext(GrpcSslContexts.forServer(certChainFile, privateKeyFile)
-        .trustManager(clientCertChainFile)
-        .clientAuth(ClientAuth.OPTIONAL)
-        .build());
+ServerCredentials creds = TlsServerCredentials.newBuilder()
+    .keyManager(certChainFile, privateKeyFile)
+    .trustManager(clientCAsFile)
+    .clientAuth(TlsServerCredentials.ClientAuth.REQUIRE)
+    .build();
 ```
 
-Negotiated client certificates are available in the SSLSession, which is found in the SSL_SESSION_KEY attribute of <a href="https://github.com/grpc/grpc-java/blob/master/core/src/main/java/io/grpc/ServerCall.java">ServerCall</a>.  A server interceptor can provide details in the current Context.
+Negotiated client certificates are available in the SSLSession, which is found
+in the `Grpc.TRANSPORT_ATTR_SSL_SESSION` attribute of the call. A server
+interceptor can provide details in the current Context.
 
 ```java
-public final static Context.Key<SSLSession> SSL_SESSION_CONTEXT = Context.key("SSLSession");
+// The application uses this in its handlers.
+public static final Context.Key<MySecurityInfo> SECURITY_INFO = Context.key("my.security.Info");
 
 @Override
-public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<RespT> call, 
+public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
     Metadata headers, ServerCallHandler<ReqT, RespT> next) {
-    SSLSession sslSession = call.attributes().get(ServerCall.SSL_SESSION_KEY);
+    SSLSession sslSession = call.getAttributes().get(Grpc.TRANSPORT_ATTR_SSL_SESSION);
     if (sslSession == null) {
-        return next.startCall(call, headers)
+        return next.startCall(call, headers);
     }
+    // This interceptor can provide a centralized policy to process the client's
+    // certificate. Avoid exposing low-level details (like SSLSession) and
+    // instead provide a higher-level concept like "authenticated user."
+    MySecurityInfo info = process(sslSession);
     return Contexts.interceptCall(
-        Context.current().withValue(SSL_SESSION_CONTEXT, clientContext), call, headers, next);
+        Context.current().withValue(SECURITY_INFO, info), call, headers, next);
 }
 ```
 
 [Mutual authentication]: http://en.wikipedia.org/wiki/Transport_Layer_Security#Client-authenticated_TLS_handshake
 
+## Troubleshooting
+
+If you received an error message "ALPN is not configured properly" or "Jetty ALPN/NPN has not been properly configured", it most likely means that:
+ - ALPN related dependencies are either not present in the classpath
+ - or that there is a classpath conflict
+ - or that a wrong version is used due to dependency management
+ - or you are on an unsupported platform (e.g., 32-bit OS). See [Transport
+   Security](#transport-security-tls) for supported platforms.
+
+### Netty
+If you aren't using gRPC on Android devices, you are most likely using `grpc-netty` transport.
+
+If you are developing for Android and have a dependency on `grpc-netty`, you should remove it as `grpc-netty` is unsupported on Android. Use `grpc-okhttp` instead.
+
+If you are on a 32-bit operating system, using Java 11+ may be the easiest
+solution, as ALPN was added to Java in Java 9. If on 32-bit Windows, [Conscrypt
+is an option](#tls-with-conscrypt). Otherwise you need to [build your own 32-bit
+version of
+`netty-tcnative`](https://netty.io/wiki/forked-tomcat-native.html#wiki-h2-6).
+
+If on Alpine Linux, depending on your specific JDK you may see a crash in
+netty_tcnative. This is generally caused by a missing symbol. Run `apk install
+gcompat` and use the environment variable `LD_PRELOAD=/lib/libgcompat.so.0` when
+executing Java.
+
+If on Fedora 30 or later and you see "libcrypt.so.1: cannot open shared object
+file: No such file or directory". Run `dnf -y install libxcrypt-compat` to
+install the necessary dependency.
+
+Most dependency versioning problems can be solved by using
+`io.grpc:grpc-netty-shaded` instead of `io.grpc:grpc-netty`, although this also
+limits your usage of the Netty-specific APIs. `io.grpc:grpc-netty-shaded`
+includes the proper version of Netty and `netty-tcnative-boringssl-static` in a
+way that won't conflict with other Netty usages.
+
+Find the dependency tree (e.g., `mvn dependency:tree`), and look for versions of:
+ - `io.grpc:grpc-netty`
+ - `io.netty:netty-handler` (really, make sure all of io.netty except for
+   netty-tcnative has the same version)
+ - `io.netty:netty-tcnative-boringssl-static:jar` 
+
+If `netty-tcnative-boringssl-static` is missing, then you either need to add it as a dependency, or use alternative methods of providing ALPN capability by reading the *Transport Security (TLS)* section carefully.
+
+If you have both `netty-handler` and `netty-tcnative-boringssl-static` dependencies, then check the versions carefully. These versions could've been overridden by dependency management from another BOM. You would receive the "ALPN is not configured properly" exception if you are using incompatible versions.
+
+If you have other `netty` dependencies, such as `netty-all`, that are pulled in from other libraries, then ultimately you should make sure only one `netty` dependency is used to avoid classpath conflict. The easiest way is to exclude transitive Netty dependencies from all the immediate dependencies, e.g., in Maven use `<exclusions>`, and then add an explict Netty dependency in your project along with the corresponding `tcnative` versions. See the versions table below.
+
+If you are running in a runtime environment that also uses Netty (e.g., Hadoop, Spark, Spring Boot 2) and you have no control over the Netty version at all, then you should use a shaded gRPC Netty dependency to avoid classpath conflicts with other Netty versions in runtime the classpath:
+ - Remove `io.grpc:grpc-netty` dependency
+ - Add `io.grpc:grpc-netty-shaded` dependency
+
+Below are known to work version combinations:
+
+grpc-netty version | netty-handler version | netty-tcnative-boringssl-static version
+------------------ |-----------------------| ---------------------------------------
+1.0.0-1.0.1        | 4.1.3.Final           | 1.1.33.Fork19
+1.0.2-1.0.3        | 4.1.6.Final           | 1.1.33.Fork23
+1.1.x-1.3.x        | 4.1.8.Final           | 1.1.33.Fork26
+1.4.x              | 4.1.11.Final          | 2.0.1.Final
+1.5.x              | 4.1.12.Final          | 2.0.5.Final
+1.6.x              | 4.1.14.Final          | 2.0.5.Final
+1.7.x-1.8.x        | 4.1.16.Final          | 2.0.6.Final
+1.9.x-1.10.x       | 4.1.17.Final          | 2.0.7.Final
+1.11.x-1.12.x      | 4.1.22.Final          | 2.0.7.Final
+1.13.x             | 4.1.25.Final          | 2.0.8.Final
+1.14.x-1.15.x      | 4.1.27.Final          | 2.0.12.Final
+1.16.x-1.17.x      | 4.1.30.Final          | 2.0.17.Final
+1.18.x-1.19.x      | 4.1.32.Final          | 2.0.20.Final
+1.20.x-1.21.x      | 4.1.34.Final          | 2.0.22.Final
+1.22.x             | 4.1.35.Final          | 2.0.25.Final
+1.23.x-1.24.x      | 4.1.38.Final          | 2.0.25.Final
+1.25.x-1.27.x      | 4.1.42.Final          | 2.0.26.Final
+1.28.x             | 4.1.45.Final          | 2.0.28.Final
+1.29.x-1.31.x      | 4.1.48.Final          | 2.0.30.Final
+1.32.x-1.34.x      | 4.1.51.Final          | 2.0.31.Final
+1.35.x-1.41.x      | 4.1.52.Final          | 2.0.34.Final
+1.42.x-1.43.x      | 4.1.63.Final          | 2.0.38.Final
+1.44.x-1.47.x      | 4.1.72.Final          | 2.0.46.Final
+1.48.x-1.49.x      | 4.1.77.Final          | 2.0.53.Final
+1.50.x-1.53.x      | 4.1.79.Final          | 2.0.54.Final
+1.54.x-1.55.x      | 4.1.87.Final          | 2.0.56.Final
+1.56.x             | 4.1.87.Final          | 2.0.61.Final
+1.57.x-1.58.x      | 4.1.93.Final          | 2.0.61.Final
+1.59.x             | 4.1.97.Final          | 2.0.61.Final
+1.60.x-1.66.x      | 4.1.100.Final         | 2.0.61.Final
+1.67.x-1.70.x      | 4.1.110.Final         | 2.0.65.Final
+1.71.x-1.74.x      | 4.1.110.Final         | 2.0.70.Final
+1.75.x-1.76.x      | 4.1.124.Final         | 2.0.72.Final
+1.77.x-1.78.x      | 4.1.127.Final         | 2.0.74.Final
+1.79.x-            | 4.1.130.Final         | 2.0.74.Final
+
+_(grpc-netty-shaded avoids issues with keeping these versions in sync.)_
+
+### OkHttp
+If you are using gRPC on Android devices, you are most likely using
+`grpc-okhttp` transport.
+
+Find the dependency tree (e.g., `mvn dependency:tree`), and look for
+`io.grpc:grpc-okhttp`. If you don't have `grpc-okhttp`, you should add it as a
+dependency.
+
 # gRPC over plaintext
 
 An option is provided to use gRPC over plaintext without TLS. While this is convenient for testing environments, users must be aware of the security risks of doing so for real production systems.
@@ -294,17 +420,12 @@ An option is provided to use gRPC over plaintext without TLS. While this is conv
 The following code snippet shows how you can call the Google Cloud PubSub API using gRPC with a service account. The credentials are loaded from a key stored in a well-known location or by detecting that the application is running in an environment that can provide one automatically, e.g. Google Compute Engine. While this example is specific to Google and it's services, similar patterns can be followed for other service providers.
 
 ```java
-// Create a channel to the test service.
-ManagedChannel channel = ManagedChannelBuilder.forTarget("pubsub.googleapis.com")
+// Use the default credentials from the environment
+ChannelCredentials creds = GoogleDefaultChannelCredentials.create();
+// Create a channel to the service
+ManagedChannel channel = Grpc.newChannelBuilder("dns:///pubsub.googleapis.com", creds)
     .build();
-// Get the default credentials from the environment
-GoogleCredentials creds = GoogleCredentials.getApplicationDefault();
-// Down-scope the credential to just the scopes required by the service
-creds = creds.createScoped(Arrays.asList("https://www.googleapis.com/auth/pubsub"));
-// Create an instance of {@link io.grpc.CallCredentials}
-CallCredentials callCreds = MoreCallCredentials.from(creds);
-// Create a stub with credential
-PublisherGrpc.PublisherBlockingStub publisherStub =
-    PublisherGrpc.newBlockingStub(channel).withCallCredentials(callCreds);
+// Create a stub and send an RPC
+PublisherGrpc.PublisherBlockingStub publisherStub = PublisherGrpc.newBlockingStub(channel);
 publisherStub.publish(someMessage);
 ```
diff --git a/WORKSPACE b/WORKSPACE
new file mode 100644
index 00000000000..1efdf2793a8
--- /dev/null
+++ b/WORKSPACE
@@ -0,0 +1,58 @@
+workspace(name = "io_grpc_grpc_java")
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("//:repositories.bzl", "IO_GRPC_GRPC_JAVA_ARTIFACTS", "IO_GRPC_GRPC_JAVA_OVERRIDE_TARGETS", "grpc_java_repositories")
+
+grpc_java_repositories()
+
+http_archive(
+    name = "rules_java",
+    sha256 = "47632cc506c858011853073449801d648e10483d4b50e080ec2549a4b2398960",
+    urls = [
+        "https://github.com/bazelbuild/rules_java/releases/download/8.15.2/rules_java-8.15.2.tar.gz",
+    ],
+)
+
+load("@com_google_protobuf//:protobuf_deps.bzl", "PROTOBUF_MAVEN_ARTIFACTS", "protobuf_deps")
+
+protobuf_deps()
+
+load("@rules_java//java:rules_java_deps.bzl", "rules_java_dependencies")
+
+rules_java_dependencies()
+
+load("@bazel_features//:deps.bzl", "bazel_features_deps")
+
+bazel_features_deps()
+
+load("@bazel_jar_jar//:jar_jar.bzl", "jar_jar_repositories")
+
+jar_jar_repositories()
+
+load("@rules_python//python:repositories.bzl", "py_repositories")
+
+py_repositories()
+
+load("@com_google_googleapis//:repository_rules.bzl", "switched_rules_by_language")
+
+switched_rules_by_language(
+    name = "com_google_googleapis_imports",
+)
+
+http_archive(
+    name = "rules_jvm_external",
+    sha256 = "d31e369b854322ca5098ea12c69d7175ded971435e55c18dd9dd5f29cc5249ac",
+    strip_prefix = "rules_jvm_external-5.3",
+    url = "https://github.com/bazelbuild/rules_jvm_external/releases/download/5.3/rules_jvm_external-5.3.tar.gz",
+)
+
+load("@rules_jvm_external//:defs.bzl", "maven_install")
+
+maven_install(
+    artifacts = IO_GRPC_GRPC_JAVA_ARTIFACTS + PROTOBUF_MAVEN_ARTIFACTS,
+    override_targets = IO_GRPC_GRPC_JAVA_OVERRIDE_TARGETS,
+    repositories = [
+        "https://repo.maven.apache.org/maven2/",
+    ],
+    strict_visibility = True,
+)
diff --git a/WORKSPACE.bzlmod b/WORKSPACE.bzlmod
new file mode 100644
index 00000000000..4ecb9e5d985
--- /dev/null
+++ b/WORKSPACE.bzlmod
@@ -0,0 +1 @@
+# When using bzlmod this makes sure nothing from the legacy WORKSPACE is loaded
diff --git a/all/build.gradle b/all/build.gradle
index 5a7a28832a6..11eec4b7ff8 100644
--- a/all/build.gradle
+++ b/all/build.gradle
@@ -1,41 +1,48 @@
-apply plugin: 'com.github.kt3k.coveralls'
+plugins {
+    id "java-library"
+    id "maven-publish"
 
-description = "gRPC: All"
-
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-    dependencies {
-        classpath 'org.kt3k.gradle.plugin:coveralls-gradle-plugin:2.0.1'
-    }
+    id "com.github.kt3k.coveralls"
 }
 
+description = "gRPC: All"
+
 def subprojects = [
-  project(':grpc-auth'),
-  project(':grpc-core'),
-  project(':grpc-context'),
-  project(':grpc-netty'),
-  project(':grpc-okhttp'),
-  project(':grpc-protobuf'),
-  project(':grpc-protobuf-lite'),
-  project(':grpc-protobuf-nano'),
-  project(':grpc-stub'),
-  // project(':grpc-thrift'), // not exported currently.
+    project(':grpc-api'),
+    project(':grpc-auth'),
+    project(':grpc-core'),
+    project(':grpc-grpclb'),
+    project(':grpc-gcp-csm-observability'),
+    project(':grpc-inprocess'),
+    project(':grpc-netty'),
+    project(':grpc-okhttp'),
+    project(':grpc-opentelemetry'),
+    project(':grpc-protobuf'),
+    project(':grpc-protobuf-lite'),
+    project(':grpc-rls'),
+    project(':grpc-services'),
+    project(':grpc-servlet'),
+    project(':grpc-servlet-jakarta'),
+    project(':grpc-stub'),
+    project(':grpc-testing'),
+    project(':grpc-util'),
+    project(':grpc-xds'),
 ]
 
-for (subproject in rootProject.subprojects) {
+for (subproject in subprojects) {
     if (subproject == project) {
         continue
     }
     evaluationDependsOn(subproject.path)
 }
+evaluationDependsOn(':grpc-interop-testing')
 
 dependencies {
-    compile subprojects
+    api subprojects.minus([project(':grpc-protobuf-lite')])
+    implementation libraries.guava.jre // JRE required by transitive protobuf-java-util
 }
 
-javadoc {
+tasks.named("javadoc").configure {
     classpath = files(subprojects.collect { subproject ->
         subproject.javadoc.classpath
     })
@@ -44,40 +51,29 @@ javadoc {
             continue;
         }
         source subproject.javadoc.source
-        options.links subproject.javadoc.options.links.toArray(new String[0])
+        options.linksOffline.addAll subproject.javadoc.options.linksOffline
     }
-    exclude 'io/grpc/internal/**'
 }
 
-task jacocoMerge(type: JacocoMerge) {
-    dependsOn(subprojects.jacocoTestReport.dependsOn)
+tasks.named("jacocoTestReport").configure {
     mustRunAfter(subprojects.jacocoTestReport.mustRunAfter)
-    destinationFile = file("${buildDir}/jacoco/test.exec")
-    executionData = files(subprojects.jacocoTestReport.executionData)
-        .plus(project(':grpc-interop-testing').jacocoTestReport.executionData)
-        .filter { f -> f.exists() }
-}
-
-jacocoTestReport {
-    dependsOn(jacocoMerge)
+    mustRunAfter(project(':grpc-interop-testing').jacocoTestReport.mustRunAfter)
+    executionData.from files(subprojects.jacocoTestReport.executionData)
+            .plus(project(':grpc-interop-testing').jacocoTestReport.executionData)
     reports {
-        xml.enabled = true
-        html.enabled = true
+        xml.required = true
+        html.required = true
     }
 
-    additionalSourceDirs = files(subprojects.sourceSets.main.allSource.srcDirs)
-    sourceDirectories = files(subprojects.sourceSets.main.allSource.srcDirs)
-    classDirectories = files(subprojects.sourceSets.main.output)
-    classDirectories = files(classDirectories.files.collect {
-        fileTree(dir: it,
-                exclude: ['**/io/grpc/okhttp/internal/**'])
-    })
+    subprojects.each { subproject ->
+        additionalSourceDirs.from(subproject.jacocoTestReport.additionalSourceDirs)
+        sourceDirectories.from(subproject.jacocoTestReport.sourceDirectories)
+        classDirectories.from(subproject.jacocoTestReport.classDirectories)
+    }
 }
 
 coveralls {
     sourceDirs = subprojects.sourceSets.main.allSource.srcDirs.flatten()
 }
 
-tasks.coveralls {
-    dependsOn(jacocoTestReport)
-}
+tasks.named("coveralls").configure { dependsOn tasks.named("jacocoTestReport") }
diff --git a/alts/BUILD.bazel b/alts/BUILD.bazel
new file mode 100644
index 00000000000..f29df303fbe
--- /dev/null
+++ b/alts/BUILD.bazel
@@ -0,0 +1,87 @@
+load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library")
+load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library")
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+load("//:java_grpc_library.bzl", "java_grpc_library")
+
+java_library(
+    name = "alts_internal",
+    srcs = glob([
+        "src/main/java/io/grpc/alts/internal/*.java",
+    ]),
+    deps = [
+        ":handshaker_java_grpc",
+        ":handshaker_java_proto",
+        "//api",
+        "//core:internal",
+        "//netty",
+        "//stub",
+        "@com_google_protobuf//:protobuf_java",
+        "@com_google_protobuf//:protobuf_java_util",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+        artifact("io.netty:netty-buffer"),
+        artifact("io.netty:netty-codec"),
+        artifact("io.netty:netty-common"),
+        artifact("io.netty:netty-handler"),
+        artifact("io.netty:netty-transport"),
+    ],
+)
+
+java_library(
+    name = "alts",
+    srcs = glob([
+        "src/main/java/io/grpc/alts/*.java",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        ":alts_internal",
+        ":handshaker_java_grpc",
+        ":handshaker_java_proto",
+        "//api",
+        "//auth",
+        "//core:internal",
+        "//netty",
+        artifact("com.google.auth:google-auth-library-oauth2-http"),
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
+        artifact("io.netty:netty-common"),
+        artifact("io.netty:netty-handler"),
+        artifact("io.netty:netty-transport"),
+    ],
+)
+
+# bazel only accepts proto import with absolute path.
+genrule(
+    name = "protobuf_imports",
+    srcs = glob(["src/main/proto/grpc/gcp/*.proto"]),
+    outs = [
+        "protobuf_out/grpc/gcp/altscontext.proto",
+        "protobuf_out/grpc/gcp/handshaker.proto",
+        "protobuf_out/grpc/gcp/transport_security_common.proto",
+    ],
+    cmd = "for fname in $(SRCS); do " +
+          "sed 's,import \",import \"alts/protobuf_out/,g' $$fname > " +
+          "$(@D)/protobuf_out/grpc/gcp/$$(basename $$fname); done",
+)
+
+proto_library(
+    name = "handshaker_proto",
+    srcs = [
+        "protobuf_out/grpc/gcp/altscontext.proto",
+        "protobuf_out/grpc/gcp/handshaker.proto",
+        "protobuf_out/grpc/gcp/transport_security_common.proto",
+    ],
+)
+
+java_proto_library(
+    name = "handshaker_java_proto",
+    deps = [":handshaker_proto"],
+)
+
+java_grpc_library(
+    name = "handshaker_java_grpc",
+    srcs = [":handshaker_proto"],
+    deps = [":handshaker_java_proto"],
+)
diff --git a/alts/build.gradle b/alts/build.gradle
new file mode 100644
index 00000000000..c206a37bcef
--- /dev/null
+++ b/alts/build.gradle
@@ -0,0 +1,104 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "com.google.protobuf"
+    id "com.gradleup.shadow"
+    id "ru.vyarus.animalsniffer"
+}
+
+description = "gRPC: ALTS"
+
+dependencies {
+    api project(':grpc-api')
+    implementation project(':grpc-auth'),
+            project(':grpc-core'),
+            project(":grpc-context"), // Override google-auth dependency with our newer version
+            project(':grpc-protobuf'),
+            project(':grpc-stub'),
+            libraries.protobuf.java,
+            libraries.conscrypt,
+            libraries.google.auth.oauth2Http
+    def nettyDependency = implementation project(':grpc-netty')
+
+    shadow configurations.implementation.getDependencies().minus(nettyDependency)
+    shadow project(path: ':grpc-netty-shaded', configuration: 'shadow')
+
+    testImplementation project(':grpc-testing'),
+            testFixtures(project(':grpc-core')),
+            project(':grpc-inprocess'),
+            project(':grpc-testing-proto'),
+            libraries.guava,
+            libraries.junit,
+            libraries.mockito.core,
+            libraries.truth
+
+    testImplementation libraries.guava.testlib
+    testRuntimeOnly libraries.netty.tcnative,
+            libraries.netty.tcnative.classes
+    testRuntimeOnly (libraries.netty.transport.epoll) {
+        artifact {
+            classifier = "linux-x86_64"
+        }
+    }
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+configureProtoCompilation()
+
+import net.ltgt.gradle.errorprone.CheckSeverity
+
+[tasks.named("compileJava"), tasks.named("compileTestJava")]*.configure {
+    // ALTS returns a lot of futures that we mostly don't care about.
+    options.errorprone.check("FutureReturnValueIgnored", CheckSeverity.OFF)
+}
+
+tasks.named("javadoc").configure {
+    exclude 'io/grpc/alts/internal/**'
+    exclude 'io/grpc/alts/Internal*'
+}
+
+tasks.named("jar").configure {
+    // Must use a different archiveClassifier to avoid conflicting with shadowJar
+    archiveClassifier = 'original'
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.alts')
+    }
+}
+
+// We want to use grpc-netty-shaded instead of grpc-netty. But we also want our
+// source to work with Bazel, so we rewrite the code as part of the build.
+tasks.named("shadowJar").configure {
+    archiveClassifier = null
+    dependencies {
+        exclude(dependency {true})
+    }
+    relocate 'io.grpc.netty', 'io.grpc.netty.shaded.io.grpc.netty'
+    relocate 'io.netty', 'io.grpc.netty.shaded.io.netty'
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            // We want this to throw an exception if it isn't working
+            def originalJar = artifacts.find { dep -> dep.classifier == 'original'}
+            artifacts.remove(originalJar)
+
+            pom.withXml {
+                def dependenciesNode = new Node(null, 'dependencies')
+                project.configurations.shadow.allDependencies.each { dep ->
+                    def dependencyNode = dependenciesNode.appendNode('dependency')
+                    dependencyNode.appendNode('groupId', dep.group)
+                    dependencyNode.appendNode('artifactId', dep.name)
+                    dependencyNode.appendNode('version', dep.version)
+                    dependencyNode.appendNode('scope', 'compile')
+                }
+                asNode().dependencies[0].replaceNode(dependenciesNode)
+            }
+        }
+    }
+}
diff --git a/alts/src/generated/main/grpc/io/grpc/alts/internal/HandshakerServiceGrpc.java b/alts/src/generated/main/grpc/io/grpc/alts/internal/HandshakerServiceGrpc.java
new file mode 100644
index 00000000000..07e4256eb75
--- /dev/null
+++ b/alts/src/generated/main/grpc/io/grpc/alts/internal/HandshakerServiceGrpc.java
@@ -0,0 +1,339 @@
+package io.grpc.alts.internal;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class HandshakerServiceGrpc {
+
+  private HandshakerServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.gcp.HandshakerService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.alts.internal.HandshakerReq,
+      io.grpc.alts.internal.HandshakerResp> getDoHandshakeMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "DoHandshake",
+      requestType = io.grpc.alts.internal.HandshakerReq.class,
+      responseType = io.grpc.alts.internal.HandshakerResp.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.alts.internal.HandshakerReq,
+      io.grpc.alts.internal.HandshakerResp> getDoHandshakeMethod() {
+    io.grpc.MethodDescriptor<io.grpc.alts.internal.HandshakerReq, io.grpc.alts.internal.HandshakerResp> getDoHandshakeMethod;
+    if ((getDoHandshakeMethod = HandshakerServiceGrpc.getDoHandshakeMethod) == null) {
+      synchronized (HandshakerServiceGrpc.class) {
+        if ((getDoHandshakeMethod = HandshakerServiceGrpc.getDoHandshakeMethod) == null) {
+          HandshakerServiceGrpc.getDoHandshakeMethod = getDoHandshakeMethod =
+              io.grpc.MethodDescriptor.<io.grpc.alts.internal.HandshakerReq, io.grpc.alts.internal.HandshakerResp>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DoHandshake"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.alts.internal.HandshakerReq.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.alts.internal.HandshakerResp.getDefaultInstance()))
+              .setSchemaDescriptor(new HandshakerServiceMethodDescriptorSupplier("DoHandshake"))
+              .build();
+        }
+      }
+    }
+    return getDoHandshakeMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static HandshakerServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<HandshakerServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<HandshakerServiceStub>() {
+        @java.lang.Override
+        public HandshakerServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new HandshakerServiceStub(channel, callOptions);
+        }
+      };
+    return HandshakerServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static HandshakerServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<HandshakerServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<HandshakerServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public HandshakerServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new HandshakerServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return HandshakerServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static HandshakerServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<HandshakerServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<HandshakerServiceBlockingStub>() {
+        @java.lang.Override
+        public HandshakerServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new HandshakerServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return HandshakerServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static HandshakerServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<HandshakerServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<HandshakerServiceFutureStub>() {
+        @java.lang.Override
+        public HandshakerServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new HandshakerServiceFutureStub(channel, callOptions);
+        }
+      };
+    return HandshakerServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Handshaker service accepts a stream of handshaker request, returning a
+     * stream of handshaker response. Client is expected to send exactly one
+     * message with either client_start or server_start followed by one or more
+     * messages with next. Each time client sends a request, the handshaker
+     * service expects to respond. Client does not have to wait for service's
+     * response before sending next request.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.alts.internal.HandshakerReq> doHandshake(
+        io.grpc.stub.StreamObserver<io.grpc.alts.internal.HandshakerResp> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getDoHandshakeMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service HandshakerService.
+   */
+  public static abstract class HandshakerServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return HandshakerServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service HandshakerService.
+   */
+  public static final class HandshakerServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<HandshakerServiceStub> {
+    private HandshakerServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected HandshakerServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new HandshakerServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Handshaker service accepts a stream of handshaker request, returning a
+     * stream of handshaker response. Client is expected to send exactly one
+     * message with either client_start or server_start followed by one or more
+     * messages with next. Each time client sends a request, the handshaker
+     * service expects to respond. Client does not have to wait for service's
+     * response before sending next request.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.alts.internal.HandshakerReq> doHandshake(
+        io.grpc.stub.StreamObserver<io.grpc.alts.internal.HandshakerResp> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getDoHandshakeMethod(), getCallOptions()), responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service HandshakerService.
+   */
+  public static final class HandshakerServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<HandshakerServiceBlockingV2Stub> {
+    private HandshakerServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected HandshakerServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new HandshakerServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Handshaker service accepts a stream of handshaker request, returning a
+     * stream of handshaker response. Client is expected to send exactly one
+     * message with either client_start or server_start followed by one or more
+     * messages with next. Each time client sends a request, the handshaker
+     * service expects to respond. Client does not have to wait for service's
+     * response before sending next request.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.alts.internal.HandshakerReq, io.grpc.alts.internal.HandshakerResp>
+        doHandshake() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getDoHandshakeMethod(), getCallOptions());
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service HandshakerService.
+   */
+  public static final class HandshakerServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<HandshakerServiceBlockingStub> {
+    private HandshakerServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected HandshakerServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new HandshakerServiceBlockingStub(channel, callOptions);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service HandshakerService.
+   */
+  public static final class HandshakerServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<HandshakerServiceFutureStub> {
+    private HandshakerServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected HandshakerServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new HandshakerServiceFutureStub(channel, callOptions);
+    }
+  }
+
+  private static final int METHODID_DO_HANDSHAKE = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_DO_HANDSHAKE:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.doHandshake(
+              (io.grpc.stub.StreamObserver<io.grpc.alts.internal.HandshakerResp>) responseObserver);
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getDoHandshakeMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.alts.internal.HandshakerReq,
+              io.grpc.alts.internal.HandshakerResp>(
+                service, METHODID_DO_HANDSHAKE)))
+        .build();
+  }
+
+  private static abstract class HandshakerServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    HandshakerServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.alts.internal.HandshakerProto.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("HandshakerService");
+    }
+  }
+
+  private static final class HandshakerServiceFileDescriptorSupplier
+      extends HandshakerServiceBaseDescriptorSupplier {
+    HandshakerServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class HandshakerServiceMethodDescriptorSupplier
+      extends HandshakerServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    HandshakerServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (HandshakerServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new HandshakerServiceFileDescriptorSupplier())
+              .addMethod(getDoHandshakeMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/AltsChannelBuilder.java b/alts/src/main/java/io/grpc/alts/AltsChannelBuilder.java
new file mode 100644
index 00000000000..ca33f8b00b9
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/AltsChannelBuilder.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2018 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.alts;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingChannelBuilder2;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
+import io.grpc.netty.NettyChannelBuilder;
+import javax.annotation.Nullable;
+
+/**
+ * ALTS version of {@code ManagedChannelBuilder}. This class sets up a secure and authenticated
+ * communication between two cloud VMs using ALTS.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4151")
+public final class AltsChannelBuilder extends ForwardingChannelBuilder2<AltsChannelBuilder> {
+  private final NettyChannelBuilder delegate;
+  private final AltsChannelCredentials.Builder credentialsBuilder =
+      new AltsChannelCredentials.Builder();
+
+  /** "Overrides" the static method in {@link ManagedChannelBuilder}. */
+  public static AltsChannelBuilder forTarget(String target) {
+    return new AltsChannelBuilder(target);
+  }
+
+  /** "Overrides" the static method in {@link ManagedChannelBuilder}. */
+  public static AltsChannelBuilder forAddress(String name, int port) {
+    return forTarget(GrpcUtil.authorityFromHostAndPort(name, port));
+  }
+
+  private AltsChannelBuilder(String target) {
+    delegate = NettyChannelBuilder.forTarget(target);
+  }
+
+  /**
+   * Adds an expected target service accounts. One of the added service accounts should match peer
+   * service account in the handshaker result. Otherwise, the handshake fails.
+   */
+  public AltsChannelBuilder addTargetServiceAccount(String targetServiceAccount) {
+    credentialsBuilder.addTargetServiceAccount(targetServiceAccount);
+    return this;
+  }
+
+  /**
+   * Enables untrusted ALTS for testing. If this function is called, we will not check whether ALTS
+   * is running on Google Cloud Platform.
+   */
+  public AltsChannelBuilder enableUntrustedAltsForTesting() {
+    credentialsBuilder.enableUntrustedAltsForTesting();
+    return this;
+  }
+
+  /** Sets a new handshaker service address for testing. */
+  public AltsChannelBuilder setHandshakerAddressForTesting(String handshakerAddress) {
+    credentialsBuilder.setHandshakerAddressForTesting(handshakerAddress);
+    return this;
+  }
+
+  @Override
+  protected NettyChannelBuilder delegate() {
+    return delegate;
+  }
+
+  @Override
+  public ManagedChannel build() {
+    InternalNettyChannelBuilder.setProtocolNegotiatorFactory(
+        delegate(),
+        credentialsBuilder.buildProtocolNegotiatorFactory());
+
+    return delegate().build();
+  }
+
+  @VisibleForTesting
+  @Nullable
+  ProtocolNegotiator getProtocolNegotiatorForTest() {
+    return credentialsBuilder.buildProtocolNegotiatorFactory().newNegotiator();
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/AltsChannelCredentials.java b/alts/src/main/java/io/grpc/alts/AltsChannelCredentials.java
new file mode 100644
index 00000000000..e12344f73d7
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/AltsChannelCredentials.java
@@ -0,0 +1,159 @@
+/*
+ * 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.alts;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.Channel;
+import io.grpc.ChannelCredentials;
+import io.grpc.ExperimentalApi;
+import io.grpc.Status;
+import io.grpc.alts.internal.AltsProtocolNegotiator.ClientAltsProtocolNegotiatorFactory;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.netty.GrpcHttp2ConnectionHandler;
+import io.grpc.netty.InternalNettyChannelCredentials;
+import io.grpc.netty.InternalProtocolNegotiator;
+import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerAdapter;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.util.AsciiString;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Provides secure and authenticated communication between two cloud VMs using ALTS.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4151")
+public final class AltsChannelCredentials {
+  private static final Logger logger = Logger.getLogger(AltsChannelCredentials.class.getName());
+
+  private AltsChannelCredentials() {}
+
+  public static ChannelCredentials create() {
+    return newBuilder().build();
+  }
+
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4151")
+  public static final class Builder {
+    private final ImmutableList.Builder<String> targetServiceAccountsBuilder =
+        ImmutableList.builder();
+    private ObjectPool<Channel> handshakerChannelPool =
+        SharedResourcePool.forResource(HandshakerServiceChannel.SHARED_HANDSHAKER_CHANNEL);
+    private boolean enableUntrustedAlts;
+
+    /**
+     * Adds an expected target service accounts. One of the added service accounts should match peer
+     * service account in the handshaker result. Otherwise, the handshake fails.
+     */
+    public Builder addTargetServiceAccount(String targetServiceAccount) {
+      targetServiceAccountsBuilder.add(targetServiceAccount);
+      return this;
+    }
+
+    /**
+     * Enables untrusted ALTS for testing. If this function is called, we will not check whether
+     * ALTS is running on Google Cloud Platform.
+     */
+    public Builder enableUntrustedAltsForTesting() {
+      enableUntrustedAlts = true;
+      return this;
+    }
+
+    /** Sets a new handshaker service address for testing. */
+    public Builder setHandshakerAddressForTesting(String handshakerAddress) {
+      // Instead of using the default shared channel to the handshaker service, create a separate
+      // resource to the test address.
+      handshakerChannelPool =
+          SharedResourcePool.forResource(
+              HandshakerServiceChannel.getHandshakerChannelForTesting(handshakerAddress));
+      return this;
+    }
+
+    public ChannelCredentials build() {
+      return InternalNettyChannelCredentials.create(buildProtocolNegotiatorFactory());
+    }
+
+    InternalProtocolNegotiator.ClientFactory buildProtocolNegotiatorFactory() {
+      if (!InternalCheckGcpEnvironment.isOnGcp()) {
+        if (enableUntrustedAlts) {
+          logger.log(
+              Level.WARNING,
+              "Untrusted ALTS mode is enabled and we cannot guarantee the trustworthiness of the "
+                  + "ALTS handshaker service");
+        } else {
+          Status status = Status.INTERNAL.withDescription(
+              "ALTS is only allowed to run on Google Cloud Platform");
+          return new FailingProtocolNegotiatorFactory(status);
+        }
+      }
+
+      return new ClientAltsProtocolNegotiatorFactory(
+          targetServiceAccountsBuilder.build(), handshakerChannelPool);
+    }
+  }
+
+  private static final class FailingProtocolNegotiatorFactory
+      implements InternalProtocolNegotiator.ClientFactory {
+    private final Status status;
+
+    public FailingProtocolNegotiatorFactory(Status status) {
+      this.status = status;
+    }
+
+    @Override
+    public ProtocolNegotiator newNegotiator() {
+      return new FailingProtocolNegotiator(status);
+    }
+
+    @Override
+    public int getDefaultPort() {
+      return 443;
+    }
+  }
+
+  private static final AsciiString SCHEME = AsciiString.of("https");
+
+  static final class FailingProtocolNegotiator implements ProtocolNegotiator {
+    private final Status status;
+
+    public FailingProtocolNegotiator(Status status) {
+      this.status = status;
+    }
+
+    @Override
+    public AsciiString scheme() {
+      return SCHEME;
+    }
+
+    @Override
+    public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+      return new ChannelHandlerAdapter() {
+        @Override public void handlerAdded(ChannelHandlerContext ctx) {
+          ctx.fireExceptionCaught(status.asRuntimeException());
+        }
+      };
+    }
+
+    @Override
+    public void close() {}
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/AltsContext.java b/alts/src/main/java/io/grpc/alts/AltsContext.java
new file mode 100644
index 00000000000..7680de4160e
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/AltsContext.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2018 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.alts;
+
+import io.grpc.ExperimentalApi;
+import io.grpc.alts.internal.AltsInternalContext;
+import io.grpc.alts.internal.HandshakerResult;
+import io.grpc.alts.internal.Identity;
+
+/** {@code AltsContext} contains security-related information on the ALTS channel. */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7864")
+public final class AltsContext {
+
+  private final AltsInternalContext wrapped;
+
+  AltsContext(AltsInternalContext wrapped) {
+    this.wrapped = wrapped;
+  }
+
+  /**
+   * Creates an {@code AltsContext} for testing purposes.
+   * @param peerServiceAccount the peer service account of the to be created {@code AltsContext}
+   * @param localServiceAccount the local service account of the to be created {@code AltsContext}
+   * @return the created {@code AltsContext}
+   */
+  public static AltsContext createTestInstance(String peerServiceAccount,
+      String localServiceAccount) {
+    return new AltsContext(new AltsInternalContext(HandshakerResult.newBuilder()
+        .setPeerIdentity(Identity.newBuilder().setServiceAccount(peerServiceAccount).build())
+        .setLocalIdentity(Identity.newBuilder().setServiceAccount(localServiceAccount).build())
+        .build()));
+  }
+
+  /**
+   * Get security level.
+   *
+   * @return the context's security level.
+   */
+  public SecurityLevel getSecurityLevel() {
+    switch (wrapped.getSecurityLevel()) {
+      case SECURITY_NONE:
+        return SecurityLevel.SECURITY_NONE;
+      case INTEGRITY_ONLY:
+        return SecurityLevel.INTEGRITY_ONLY;
+      case INTEGRITY_AND_PRIVACY:
+        return SecurityLevel.INTEGRITY_AND_PRIVACY;
+      default:
+        return SecurityLevel.UNKNOWN;
+    }
+  }
+
+  /**
+   * Get peer service account.
+   *
+   * @return the context's peer service account.
+   */
+  public String getPeerServiceAccount() {
+    return wrapped.getPeerServiceAccount();
+  }
+
+  /**
+   * Get local service account.
+   *
+   * @return the context's local service account.
+   */
+  public String getLocalServiceAccount() {
+    return wrapped.getLocalServiceAccount();
+  }
+
+  /** SecurityLevel of the ALTS channel. */
+  public enum SecurityLevel {
+    UNKNOWN,
+    SECURITY_NONE,
+    INTEGRITY_ONLY,
+    INTEGRITY_AND_PRIVACY,
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/AltsContextUtil.java b/alts/src/main/java/io/grpc/alts/AltsContextUtil.java
new file mode 100644
index 00000000000..f45179bbd91
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/AltsContextUtil.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2018 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.alts;
+
+import io.grpc.Attributes;
+import io.grpc.ClientCall;
+import io.grpc.ExperimentalApi;
+import io.grpc.ServerCall;
+import io.grpc.alts.internal.AltsInternalContext;
+import io.grpc.alts.internal.AltsProtocolNegotiator;
+
+/** Utility class for {@link AltsContext}. */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7864")
+public final class AltsContextUtil {
+
+  private AltsContextUtil() {}
+
+  /**
+   * Creates an {@link AltsContext} from ALTS context information in the {@link ServerCall}.
+   *
+   * @param call the {@link ServerCall} containing the ALTS information
+   * @return the created {@link AltsContext}
+   * @throws IllegalArgumentException if the {@link ServerCall} has no ALTS information.
+   */
+  public static AltsContext createFrom(ServerCall<?, ?> call) {
+    return createFrom(call.getAttributes());
+  }
+
+  /**
+   * Creates an {@link AltsContext} from ALTS context information in the {@link ClientCall}.
+   *
+   * @param call the {@link ClientCall} containing the ALTS information
+   * @return the created {@link AltsContext}
+   * @throws IllegalArgumentException if the {@link ClientCall} has no ALTS information.
+   */
+  public static AltsContext createFrom(ClientCall<?, ?> call) {
+    return createFrom(call.getAttributes());
+  }
+
+  /**
+   * Creates an {@link AltsContext} from ALTS context information in the {@link Attributes}.
+   *
+   * @param attributes the {@link Attributes} containing the ALTS information
+   * @return the created {@link AltsContext}
+   * @throws IllegalArgumentException if the {@link Attributes} has no ALTS information.
+   */
+  public static AltsContext createFrom(Attributes attributes) {
+    Object authContext = attributes.get(AltsProtocolNegotiator.AUTH_CONTEXT_KEY);
+    if (!(authContext instanceof AltsInternalContext)) {
+      throw new IllegalArgumentException("No ALTS context information found");
+    }
+    return new AltsContext((AltsInternalContext) authContext);
+  }
+
+  /**
+   * Checks if the {@link ServerCall} contains ALTS information.
+   *
+   * @param call the {@link ServerCall} to check
+   * @return true, if the {@link ServerCall} contains ALTS information and false otherwise.
+   */
+  public static boolean check(ServerCall<?, ?> call) {
+    return check(call.getAttributes());
+  }
+
+  /**
+   * Checks if the {@link ClientCall} contains ALTS information.
+   *
+   * @param call the {@link ClientCall} to check
+   * @return true, if the {@link ClientCall} contains ALTS information and false otherwise.
+   */
+  public static boolean check(ClientCall<?, ?> call) {
+    return check(call.getAttributes());
+  }
+
+  /**
+   * Checks if the {@link Attributes} contains ALTS information.
+   *
+   * @param attributes the {@link Attributes} to check
+   * @return true, if the {@link Attributes} contains ALTS information and false otherwise.
+   */
+  public static boolean check(Attributes attributes) {
+    Object authContext = attributes.get(AltsProtocolNegotiator.AUTH_CONTEXT_KEY);
+    return authContext instanceof AltsInternalContext;
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/AltsServerBuilder.java b/alts/src/main/java/io/grpc/alts/AltsServerBuilder.java
new file mode 100644
index 00000000000..e307fd1c63a
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/AltsServerBuilder.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright 2018 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.alts;
+
+import io.grpc.BindableService;
+import io.grpc.CompressorRegistry;
+import io.grpc.DecompressorRegistry;
+import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingServerBuilder;
+import io.grpc.HandlerRegistry;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.ServerStreamTracer;
+import io.grpc.ServerTransportFilter;
+import io.grpc.netty.NettyServerBuilder;
+import java.io.File;
+import java.net.InetSocketAddress;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * gRPC secure server builder used for ALTS. This class adds on the necessary ALTS support to create
+ * a production server on Google Cloud Platform.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4151")
+public final class AltsServerBuilder extends ForwardingServerBuilder<AltsServerBuilder> {
+  private final NettyServerBuilder delegate;
+  private final AltsServerCredentials.Builder credentialsBuilder =
+      new AltsServerCredentials.Builder();
+
+  private AltsServerBuilder(NettyServerBuilder nettyDelegate) {
+    this.delegate = nettyDelegate;
+  }
+
+  /** Creates a gRPC server builder for the given port. */
+  public static AltsServerBuilder forPort(int port) {
+    NettyServerBuilder nettyDelegate = NettyServerBuilder.forAddress(new InetSocketAddress(port));
+    return new AltsServerBuilder(nettyDelegate);
+  }
+
+  /**
+   * Enables untrusted ALTS for testing. If this function is called, we will not check whether ALTS
+   * is running on Google Cloud Platform.
+   */
+  public AltsServerBuilder enableUntrustedAltsForTesting() {
+    credentialsBuilder.enableUntrustedAltsForTesting();
+    return this;
+  }
+
+  /** Sets a new handshaker service address for testing. */
+  public AltsServerBuilder setHandshakerAddressForTesting(String handshakerAddress) {
+    credentialsBuilder.setHandshakerAddressForTesting(handshakerAddress);
+    return this;
+  }
+
+  @Override
+  protected ServerBuilder<?> delegate() {
+    return delegate;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public AltsServerBuilder handshakeTimeout(long timeout, TimeUnit unit) {
+    delegate.handshakeTimeout(timeout, unit);
+    return this;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public AltsServerBuilder directExecutor() {
+    delegate.directExecutor();
+    return this;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public AltsServerBuilder addStreamTracerFactory(ServerStreamTracer.Factory factory) {
+    delegate.addStreamTracerFactory(factory);
+    return this;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public AltsServerBuilder addTransportFilter(ServerTransportFilter filter) {
+    delegate.addTransportFilter(filter);
+    return this;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public AltsServerBuilder executor(Executor executor) {
+    delegate.executor(executor);
+    return this;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public AltsServerBuilder addService(ServerServiceDefinition service) {
+    delegate.addService(service);
+    return this;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public AltsServerBuilder addService(BindableService bindableService) {
+    delegate.addService(bindableService);
+    return this;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public AltsServerBuilder fallbackHandlerRegistry(HandlerRegistry fallbackRegistry) {
+    delegate.fallbackHandlerRegistry(fallbackRegistry);
+    return this;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public AltsServerBuilder useTransportSecurity(File certChain, File privateKey) {
+    throw new UnsupportedOperationException("Can't set TLS settings for ALTS");
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public AltsServerBuilder decompressorRegistry(DecompressorRegistry registry) {
+    delegate.decompressorRegistry(registry);
+    return this;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public AltsServerBuilder compressorRegistry(CompressorRegistry registry) {
+    delegate.compressorRegistry(registry);
+    return this;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public AltsServerBuilder intercept(ServerInterceptor interceptor) {
+    delegate.intercept(interceptor);
+    return this;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public Server build() {
+    delegate.protocolNegotiator(credentialsBuilder.buildProtocolNegotiator());
+    return delegate.build();
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/AltsServerCredentials.java b/alts/src/main/java/io/grpc/alts/AltsServerCredentials.java
new file mode 100644
index 00000000000..36dc9f6a4ae
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/AltsServerCredentials.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2018 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.alts;
+
+import io.grpc.Channel;
+import io.grpc.ExperimentalApi;
+import io.grpc.ServerCredentials;
+import io.grpc.Status;
+import io.grpc.alts.internal.AltsProtocolNegotiator;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.netty.InternalNettyServerCredentials;
+import io.grpc.netty.InternalProtocolNegotiator;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * gRPC secure server builder used for ALTS. This class adds on the necessary ALTS support to create
+ * a production server on Google Cloud Platform.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4151")
+public final class AltsServerCredentials {
+  private static final Logger logger = Logger.getLogger(AltsServerCredentials.class.getName());
+
+  private AltsServerCredentials() {}
+
+  public static ServerCredentials create() {
+    return newBuilder().build();
+  }
+
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4151")
+  public static final class Builder {
+    private ObjectPool<Channel> handshakerChannelPool =
+        SharedResourcePool.forResource(HandshakerServiceChannel.SHARED_HANDSHAKER_CHANNEL);
+    private boolean enableUntrustedAlts;
+
+    /**
+     * Enables untrusted ALTS for testing. If this function is called, we will not check whether
+     * ALTS is running on Google Cloud Platform.
+     */
+    public Builder enableUntrustedAltsForTesting() {
+      enableUntrustedAlts = true;
+      return this;
+    }
+
+    /** Sets a new handshaker service address for testing. */
+    public Builder setHandshakerAddressForTesting(String handshakerAddress) {
+      // Instead of using the default shared channel to the handshaker service, create a separate
+      // resource to the test address.
+      handshakerChannelPool =
+          SharedResourcePool.forResource(
+              HandshakerServiceChannel.getHandshakerChannelForTesting(handshakerAddress));
+      return this;
+    }
+
+    public ServerCredentials build() {
+      return InternalNettyServerCredentials.create(buildProtocolNegotiator());
+    }
+
+    InternalProtocolNegotiator.ProtocolNegotiator buildProtocolNegotiator() {
+      if (!InternalCheckGcpEnvironment.isOnGcp()) {
+        if (enableUntrustedAlts) {
+          logger.log(
+              Level.WARNING,
+              "Untrusted ALTS mode is enabled and we cannot guarantee the trustworthiness of the "
+                  + "ALTS handshaker service");
+        } else {
+          Status status = Status.INTERNAL.withDescription(
+              "ALTS is only allowed to run on Google Cloud Platform");
+          return new AltsChannelCredentials.FailingProtocolNegotiator(status);
+        }
+      }
+
+      return AltsProtocolNegotiator.serverAltsProtocolNegotiator(handshakerChannelPool);
+    }
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/AuthorizationUtil.java b/alts/src/main/java/io/grpc/alts/AuthorizationUtil.java
new file mode 100644
index 00000000000..53e45105d9b
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/AuthorizationUtil.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2019 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.alts;
+
+import io.grpc.ServerCall;
+import io.grpc.Status;
+import io.grpc.alts.internal.AltsInternalContext;
+import io.grpc.alts.internal.AltsProtocolNegotiator;
+import java.util.Collection;
+
+/** Utility class for ALTS client authorization. */
+public final class AuthorizationUtil {
+
+  private AuthorizationUtil() {}
+
+  /**
+   * Given a server call, performs client authorization check, i.e., checks if the client service
+   * account matches one of the expected service accounts. It returns OK if client is authorized and
+   * an error otherwise.
+   */
+  public static Status clientAuthorizationCheck(
+      ServerCall<?, ?> call, Collection<String> expectedServiceAccounts) {
+    AltsInternalContext altsContext =
+        (AltsInternalContext) call.getAttributes().get(AltsProtocolNegotiator.AUTH_CONTEXT_KEY);
+    if (altsContext == null) {
+      return Status.PERMISSION_DENIED.withDescription("Peer ALTS AuthContext not found");
+    }
+    if (expectedServiceAccounts.contains(altsContext.getPeerServiceAccount())) {
+      return Status.OK;
+    }
+    return Status.PERMISSION_DENIED.withDescription(
+        "Client " + altsContext.getPeerServiceAccount() + " is not authorized");
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/ComputeEngineChannelBuilder.java b/alts/src/main/java/io/grpc/alts/ComputeEngineChannelBuilder.java
new file mode 100644
index 00000000000..b5ee6a8d362
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/ComputeEngineChannelBuilder.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2019 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.alts;
+
+import io.grpc.ForwardingChannelBuilder;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.netty.NettyChannelBuilder;
+
+/**
+ * {@code ManagedChannelBuilder} for Google Compute Engine. This class sets up a secure channel
+ * using ALTS if applicable and using TLS as fallback.
+ */
+public final class ComputeEngineChannelBuilder
+    extends ForwardingChannelBuilder<ComputeEngineChannelBuilder> {
+
+  private final NettyChannelBuilder delegate;
+
+  private ComputeEngineChannelBuilder(String target) {
+    delegate = NettyChannelBuilder.forTarget(target, ComputeEngineChannelCredentials.create());
+  }
+
+  /** "Overrides" the static method in {@link ManagedChannelBuilder}. */
+  public static ComputeEngineChannelBuilder forTarget(String target) {
+    return new ComputeEngineChannelBuilder(target);
+  }
+
+  /** "Overrides" the static method in {@link ManagedChannelBuilder}. */
+  public static ComputeEngineChannelBuilder forAddress(String name, int port) {
+    return forTarget(GrpcUtil.authorityFromHostAndPort(name, port));
+  }
+
+  @Override
+  @SuppressWarnings("deprecation") // Not extending ForwardingChannelBuilder2 to preserve ABI.
+  protected NettyChannelBuilder delegate() {
+    return delegate;
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/ComputeEngineChannelCredentials.java b/alts/src/main/java/io/grpc/alts/ComputeEngineChannelCredentials.java
new file mode 100644
index 00000000000..518642a675d
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/ComputeEngineChannelCredentials.java
@@ -0,0 +1,72 @@
+/*
+ * 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.alts;
+
+import com.google.auth.oauth2.ComputeEngineCredentials;
+import com.google.common.collect.ImmutableList;
+import io.grpc.CallCredentials;
+import io.grpc.ChannelCredentials;
+import io.grpc.CompositeChannelCredentials;
+import io.grpc.Status;
+import io.grpc.alts.internal.AltsProtocolNegotiator.GoogleDefaultProtocolNegotiatorFactory;
+import io.grpc.auth.MoreCallCredentials;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.netty.GrpcSslContexts;
+import io.grpc.netty.InternalNettyChannelCredentials;
+import io.grpc.netty.InternalProtocolNegotiator;
+import io.netty.handler.ssl.SslContext;
+import javax.net.ssl.SSLException;
+
+/**
+ * Credentials appropriate to contact Google services when running on Google Compute Engine. This
+ * class sets up a secure channel using ALTS if applicable and using TLS as fallback. It is a subset
+ * of the functionality provided by {@link GoogleDefaultChannelCredentials}.
+ */
+public final class ComputeEngineChannelCredentials {
+  private ComputeEngineChannelCredentials() {}
+
+  /**
+   * Creates credentials for Google Compute Engine. This class sets up a secure channel using ALTS
+   * if applicable and using TLS as fallback.
+   */
+  public static ChannelCredentials create() {
+    ChannelCredentials nettyCredentials =
+        InternalNettyChannelCredentials.create(createClientFactory());
+    CallCredentials callCredentials;
+    if (InternalCheckGcpEnvironment.isOnGcp()) {
+      callCredentials = MoreCallCredentials.from(ComputeEngineCredentials.create());
+    } else {
+      callCredentials = new FailingCallCredentials(
+          Status.INTERNAL.withDescription(
+              "Compute Engine Credentials can only be used on Google Cloud Platform"));
+    }
+    return CompositeChannelCredentials.create(nettyCredentials, callCredentials);
+  }
+
+  private static InternalProtocolNegotiator.ClientFactory createClientFactory() {
+    SslContext sslContext;
+    try {
+      sslContext = GrpcSslContexts.forClient().build();
+    } catch (SSLException e) {
+      throw new RuntimeException(e);
+    }
+    return new GoogleDefaultProtocolNegotiatorFactory(
+        /* targetServiceAccounts= */ ImmutableList.<String>of(),
+        SharedResourcePool.forResource(HandshakerServiceChannel.SHARED_HANDSHAKER_CHANNEL),
+        sslContext);
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/DualCallCredentials.java b/alts/src/main/java/io/grpc/alts/DualCallCredentials.java
new file mode 100644
index 00000000000..08104712e65
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/DualCallCredentials.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2024 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.alts;
+
+import io.grpc.CallCredentials;
+import java.util.concurrent.Executor;
+
+/**
+ * {@code CallCredentials} that will pick the right credentials based on whether the established
+ * connection is ALTS or TLS.
+ */
+final class DualCallCredentials extends CallCredentials {
+  private final CallCredentials tlsCallCredentials;
+  private final CallCredentials altsCallCredentials;
+
+  public DualCallCredentials(CallCredentials tlsCallCreds, CallCredentials altsCallCreds) {
+    tlsCallCredentials = tlsCallCreds;
+    altsCallCredentials = altsCallCreds;
+  }
+
+  @Override
+  public void applyRequestMetadata(
+      CallCredentials.RequestInfo requestInfo,
+      Executor appExecutor,
+      CallCredentials.MetadataApplier applier) {
+    if (AltsContextUtil.check(requestInfo.getTransportAttrs())) {
+      altsCallCredentials.applyRequestMetadata(requestInfo, appExecutor, applier);
+    } else {
+      tlsCallCredentials.applyRequestMetadata(requestInfo, appExecutor, applier);
+    }
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/FailingCallCredentials.java b/alts/src/main/java/io/grpc/alts/FailingCallCredentials.java
new file mode 100644
index 00000000000..3c59c5b6d09
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/FailingCallCredentials.java
@@ -0,0 +1,41 @@
+/*
+ * 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.alts;
+
+import com.google.common.base.Preconditions;
+import io.grpc.CallCredentials;
+import io.grpc.Status;
+import java.util.concurrent.Executor;
+
+/**
+ * {@code CallCredentials} that always fail the RPC.
+ */
+final class FailingCallCredentials extends CallCredentials {
+  private final Status status;
+
+  public FailingCallCredentials(Status status) {
+    this.status = Preconditions.checkNotNull(status, "status");
+  }
+
+  @Override
+  public void applyRequestMetadata(
+      CallCredentials.RequestInfo requestInfo,
+      Executor appExecutor,
+      CallCredentials.MetadataApplier applier) {
+    applier.fail(status);
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/FailingClientCall.java b/alts/src/main/java/io/grpc/alts/FailingClientCall.java
new file mode 100644
index 00000000000..ab674364ee6
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/FailingClientCall.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2018 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.alts;
+
+import io.grpc.ClientCall;
+import io.grpc.Metadata;
+import io.grpc.Status;
+
+/** An implementation of {@link ClientCall} that fails when started. */
+final class FailingClientCall<ReqT, RespT> extends ClientCall<ReqT, RespT> {
+
+  private final Status error;
+
+  public FailingClientCall(Status error) {
+    this.error = error;
+  }
+
+  @Override
+  public void start(ClientCall.Listener<RespT> listener, Metadata headers) {
+    listener.onClose(error, new Metadata());
+  }
+
+  @Override
+  public void request(int numMessages) {}
+
+  @Override
+  public void cancel(String message, Throwable cause) {}
+
+  @Override
+  public void halfClose() {}
+
+  @Override
+  public void sendMessage(ReqT message) {}
+}
diff --git a/alts/src/main/java/io/grpc/alts/GoogleDefaultChannelBuilder.java b/alts/src/main/java/io/grpc/alts/GoogleDefaultChannelBuilder.java
new file mode 100644
index 00000000000..c78b94417c4
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/GoogleDefaultChannelBuilder.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2018 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.alts;
+
+import io.grpc.ForwardingChannelBuilder;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.netty.NettyChannelBuilder;
+
+/**
+ * Google default version of {@code ManagedChannelBuilder}. This class sets up a secure channel
+ * using ALTS if applicable and using TLS as fallback.
+ */
+public final class GoogleDefaultChannelBuilder
+    extends ForwardingChannelBuilder<GoogleDefaultChannelBuilder> {
+
+  private final NettyChannelBuilder delegate;
+
+  private GoogleDefaultChannelBuilder(String target) {
+    delegate = NettyChannelBuilder.forTarget(target, GoogleDefaultChannelCredentials.create());
+  }
+
+  /** "Overrides" the static method in {@link ManagedChannelBuilder}. */
+  public static GoogleDefaultChannelBuilder forTarget(String target) {
+    return new GoogleDefaultChannelBuilder(target);
+  }
+
+  /** "Overrides" the static method in {@link ManagedChannelBuilder}. */
+  public static GoogleDefaultChannelBuilder forAddress(String name, int port) {
+    return forTarget(GrpcUtil.authorityFromHostAndPort(name, port));
+  }
+
+  @Override
+  @SuppressWarnings("deprecation") // Not extending ForwardingChannelBuilder2 to preserve ABI.
+  protected NettyChannelBuilder delegate() {
+    return delegate;
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/GoogleDefaultChannelCredentials.java b/alts/src/main/java/io/grpc/alts/GoogleDefaultChannelCredentials.java
new file mode 100644
index 00000000000..1b5880120a4
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/GoogleDefaultChannelCredentials.java
@@ -0,0 +1,118 @@
+/*
+ * 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.alts;
+
+import com.google.auth.oauth2.GoogleCredentials;
+import com.google.common.collect.ImmutableList;
+import io.grpc.CallCredentials;
+import io.grpc.ChannelCredentials;
+import io.grpc.CompositeChannelCredentials;
+import io.grpc.Status;
+import io.grpc.alts.internal.AltsProtocolNegotiator.GoogleDefaultProtocolNegotiatorFactory;
+import io.grpc.auth.MoreCallCredentials;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.netty.GrpcSslContexts;
+import io.grpc.netty.InternalNettyChannelCredentials;
+import io.grpc.netty.InternalProtocolNegotiator;
+import io.netty.handler.ssl.SslContext;
+import java.io.IOException;
+import javax.net.ssl.SSLException;
+
+/**
+ * Credentials appropriate to contact Google services. This class sets up a secure channel using
+ * ALTS if applicable and uses TLS as fallback.
+ */
+public final class GoogleDefaultChannelCredentials {
+  private GoogleDefaultChannelCredentials() {}
+
+  /**
+   * Creates Google default credentials uses a secure channel with ALTS if applicable and uses TLS
+   * as fallback.
+   */
+  public static ChannelCredentials create() {
+    return newBuilder().build();
+  }
+
+  /**
+   * Returns a new instance of {@link Builder}.
+   *
+   * @since 1.43.0
+   */
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  /**
+   * Builder for {@link GoogleDefaultChannelCredentials} instances.
+   *
+   * @since 1.43.0
+   */
+  public static final class Builder {
+    private CallCredentials callCredentials;
+    private CallCredentials altsCallCredentials;
+
+    private Builder() {}
+
+    /** Constructs GoogleDefaultChannelCredentials with a given call credential. */
+    public Builder callCredentials(CallCredentials callCreds) {
+      callCredentials = callCreds;
+      return this;
+    }
+
+    /** Constructs GoogleDefaultChannelCredentials with an ALTS-specific call credential. */
+    public Builder altsCallCredentials(CallCredentials callCreds) {
+      altsCallCredentials = callCreds;
+      return this;
+    }
+
+    /** Builds a GoogleDefaultChannelCredentials instance. */
+    public ChannelCredentials build() {
+      ChannelCredentials nettyCredentials =
+          InternalNettyChannelCredentials.create(createClientFactory());
+      CallCredentials tlsCallCreds = callCredentials;
+      if (tlsCallCreds == null) {
+        try {
+          tlsCallCreds = MoreCallCredentials.from(GoogleCredentials.getApplicationDefault());
+        } catch (IOException e) {
+          tlsCallCreds =
+              new FailingCallCredentials(
+                  Status.UNAUTHENTICATED
+                      .withDescription("Failed to get Google default credentials")
+                      .withCause(e));
+        }
+      }
+      CallCredentials callCreds =
+          altsCallCredentials == null
+              ? tlsCallCreds
+              : new DualCallCredentials(tlsCallCreds, altsCallCredentials);
+      return CompositeChannelCredentials.create(nettyCredentials, callCreds);
+    }
+
+    private static InternalProtocolNegotiator.ClientFactory createClientFactory() {
+      SslContext sslContext;
+      try {
+        sslContext = GrpcSslContexts.forClient().build();
+      } catch (SSLException e) {
+        throw new RuntimeException(e);
+      }
+      return new GoogleDefaultProtocolNegotiatorFactory(
+          /* targetServiceAccounts= */ ImmutableList.<String>of(),
+          SharedResourcePool.forResource(HandshakerServiceChannel.SHARED_HANDSHAKER_CHANNEL),
+          sslContext);
+    }
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/HandshakerServiceChannel.java b/alts/src/main/java/io/grpc/alts/HandshakerServiceChannel.java
new file mode 100644
index 00000000000..5e32d22d901
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/HandshakerServiceChannel.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright 2018 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.alts;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ManagedChannel;
+import io.grpc.MethodDescriptor;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.SharedResourceHolder.Resource;
+import io.grpc.netty.NettyChannelBuilder;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.util.concurrent.DefaultThreadFactory;
+import java.net.InetSocketAddress;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Class for creating a single shared gRPC channel to the ALTS Handshaker Service using
+ * SharedResourceHolder. The channel to the handshaker service is local and is over plaintext. Each
+ * application will have at most one connection to the handshaker service.
+ */
+final class HandshakerServiceChannel {
+  // Port 8080 is necessary for ALTS handshake.
+  private static final int ALTS_PORT = 8080;
+  private static final String DEFAULT_TARGET = "metadata.google.internal.:8080";
+
+  static final Resource<Channel> SHARED_HANDSHAKER_CHANNEL =
+      new ChannelResource(getHandshakerTarget(System.getenv("GCE_METADATA_HOST")));
+  
+  /**
+   * Returns handshaker target. When GCE_METADATA_HOST is provided, it might contain port which we
+   * will discard and use ALTS_PORT instead.
+   */
+  static String getHandshakerTarget(String envValue) {
+    if (envValue == null || envValue.isEmpty()) {
+      return DEFAULT_TARGET;
+    }
+    String host = envValue;
+    int portIndex = host.lastIndexOf(':');
+    if (portIndex != -1) {
+      host = host.substring(0, portIndex); // Discard port if specified
+    }
+    return host + ":" + ALTS_PORT; // Utilize ALTS port in all cases
+  }
+  
+  /** Returns a resource of handshaker service channel for testing only. */
+  static Resource<Channel> getHandshakerChannelForTesting(String handshakerAddress) {
+    return new ChannelResource(handshakerAddress);
+  }
+
+  private static final boolean EXPERIMENTAL_ALTS_HANDSHAKER_KEEPALIVE_PARAMS =
+      GrpcUtil.getFlag("GRPC_EXPERIMENTAL_ALTS_HANDSHAKER_KEEPALIVE_PARAMS", false);
+
+  private static class ChannelResource implements Resource<Channel> {
+    private final String target;
+
+    public ChannelResource(String target) {
+      this.target = target;
+    }
+
+    @Override
+    public Channel create() {
+      /* Use its own event loop thread pool to avoid blocking. */
+      EventLoopGroup eventGroup =
+          new NioEventLoopGroup(1, new DefaultThreadFactory("handshaker pool", true));
+      NettyChannelBuilder channelBuilder =
+          NettyChannelBuilder.forTarget(target)
+          .channelType(NioSocketChannel.class, InetSocketAddress.class)
+          .directExecutor()
+          .eventLoopGroup(eventGroup)
+          .usePlaintext();
+      if (EXPERIMENTAL_ALTS_HANDSHAKER_KEEPALIVE_PARAMS) {
+        channelBuilder.keepAliveTime(10, TimeUnit.MINUTES).keepAliveTimeout(10, TimeUnit.SECONDS);
+      }
+      ManagedChannel channel = channelBuilder.build();
+      return new EventLoopHoldingChannel(channel, eventGroup);
+    }
+
+    @Override
+    public void close(Channel instanceChannel) {
+      ((EventLoopHoldingChannel) instanceChannel).close();
+    }
+
+    @Override
+    public String toString() {
+      return "grpc-alts-handshaker-service-channel";
+    }
+  }
+
+  private abstract static class ForwardingChannel extends Channel {
+    protected abstract Channel delegate();
+
+    @Override
+    public String authority() {
+      return delegate().authority();
+    }
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(
+        MethodDescriptor<ReqT, RespT> methodDescriptor, CallOptions options) {
+      return delegate().newCall(methodDescriptor, options);
+    }
+  }
+
+  private static class EventLoopHoldingChannel extends ForwardingChannel {
+    private final ManagedChannel delegate;
+    private final EventLoopGroup eventLoopGroup;
+
+    public EventLoopHoldingChannel(ManagedChannel delegate, EventLoopGroup eventLoopGroup) {
+      this.delegate = delegate;
+      this.eventLoopGroup = eventLoopGroup;
+    }
+
+    @Override
+    protected Channel delegate() {
+      return delegate;
+    }
+
+    @SuppressWarnings("FutureReturnValueIgnored") // netty ChannelFuture
+    public void close() {
+      // This method will generally be run on the ResourceHolder's ScheduledExecutorService thread
+      delegate.shutdownNow();
+      boolean terminated = false;
+      try {
+        terminated = delegate.awaitTermination(2, TimeUnit.SECONDS);
+      } catch (InterruptedException ex) {
+        // terminated will be false
+      }
+      // Try hard to shutdown abruptly so any bug is more likely to be noticed during testing.
+      long quietPeriodSeconds = terminated ? 0 : 1;
+      eventLoopGroup.shutdownGracefully(quietPeriodSeconds, 10, TimeUnit.SECONDS);
+    }
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/InternalCheckGcpEnvironment.java b/alts/src/main/java/io/grpc/alts/InternalCheckGcpEnvironment.java
new file mode 100644
index 00000000000..aae4a45d530
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/InternalCheckGcpEnvironment.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2018 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.alts;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Internal;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Locale;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Class for checking if the system is running on Google Cloud Platform (GCP). This is intended for
+ * usage internal to the gRPC team. If you *really* think you need to use this, contact the gRPC
+ * team first.
+ */
+@Internal
+public final class InternalCheckGcpEnvironment {
+
+  private static final Logger logger =
+      Logger.getLogger(InternalCheckGcpEnvironment.class.getName());
+  private static final String WINDOWS_COMMAND = "powershell.exe";
+  private static Boolean cachedResult = null;
+
+  // Construct me not!
+  private InternalCheckGcpEnvironment() {}
+
+  /** Returns {@code true} if currently running on Google Cloud Platform (GCP). */
+  public static synchronized boolean isOnGcp() {
+    if (cachedResult == null) {
+      cachedResult = isRunningOnGcp();
+    }
+    return cachedResult;
+  }
+
+  @VisibleForTesting
+  static boolean checkProductNameOnLinux(BufferedReader reader) throws IOException {
+    String name = reader.readLine().trim();
+    return name.equals("Google") || name.equals("Google Compute Engine");
+  }
+
+  @VisibleForTesting
+  static boolean checkBiosDataOnWindows(BufferedReader reader) throws IOException {
+    String line;
+    while ((line = reader.readLine()) != null) {
+      if (line.startsWith("Manufacturer")) {
+        String name = line.substring(line.indexOf(':') + 1).trim();
+        return name.equals("Google");
+      }
+    }
+    return false;
+  }
+
+  private static boolean isRunningOnGcp() {
+    String osName = System.getProperty("os.name").toLowerCase(Locale.ENGLISH);
+    try {
+      if (osName.startsWith("linux")) {
+        // Checks GCE residency on Linux platform.
+        return checkProductNameOnLinux(
+            Files.newBufferedReader(Paths.get("/sys/class/dmi/id/product_name"), UTF_8));
+      } else if (osName.startsWith("windows")) {
+        // Checks GCE residency on Windows platform.
+        Process p =
+            new ProcessBuilder()
+                .command(WINDOWS_COMMAND, "Get-WmiObject", "-Class", "Win32_BIOS")
+                .start();
+        return checkBiosDataOnWindows(
+            new BufferedReader(new InputStreamReader(p.getInputStream(), UTF_8)));
+      }
+    } catch (IOException e) {
+      logger.log(Level.WARNING, "Fail to read platform information: ", e);
+      return false;
+    }
+    // Platforms other than Linux and Windows are not supported.
+    return false;
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AeadCrypter.java b/alts/src/main/java/io/grpc/alts/internal/AeadCrypter.java
new file mode 100644
index 00000000000..4d99187c33d
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AeadCrypter.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+
+/**
+ * {@code AeadCrypter} performs authenticated encryption and decryption for a fixed key given unique
+ * nonces. Authenticated additional data is supported.
+ */
+interface AeadCrypter {
+  /**
+   * Encrypt plaintext into ciphertext buffer using the given nonce.
+   *
+   * @param ciphertext the encrypted plaintext and the tag will be written into this buffer.
+   * @param plaintext the input that should be encrypted.
+   * @param nonce the unique nonce used for the encryption.
+   * @throws GeneralSecurityException if ciphertext buffer is short or the nonce does not have the
+   *     expected size.
+   */
+  void encrypt(ByteBuffer ciphertext, ByteBuffer plaintext, byte[] nonce)
+      throws GeneralSecurityException;
+
+  /**
+   * Encrypt plaintext into ciphertext buffer using the given nonce with authenticated data.
+   *
+   * @param ciphertext the encrypted plaintext and the tag will be written into this buffer.
+   * @param plaintext the input that should be encrypted.
+   * @param aad additional data that should be authenticated, but not encrypted.
+   * @param nonce the unique nonce used for the encryption.
+   * @throws GeneralSecurityException if ciphertext buffer is short or the nonce does not have the
+   *     expected size.
+   */
+  void encrypt(ByteBuffer ciphertext, ByteBuffer plaintext, ByteBuffer aad, byte[] nonce)
+      throws GeneralSecurityException;
+
+  /**
+   * Decrypt ciphertext into plaintext buffer using the given nonce.
+   *
+   * @param plaintext the decrypted plaintext will be written into this buffer.
+   * @param ciphertext the ciphertext and tag that should be decrypted.
+   * @param nonce the nonce that was used for the encryption.
+   * @throws GeneralSecurityException if the tag is invalid or any of the inputs do not have the
+   *     expected size.
+   */
+  void decrypt(ByteBuffer plaintext, ByteBuffer ciphertext, byte[] nonce)
+      throws GeneralSecurityException;
+
+  /**
+   * Decrypt ciphertext into plaintext buffer using the given nonce.
+   *
+   * @param plaintext the decrypted plaintext will be written into this buffer.
+   * @param ciphertext the ciphertext and tag that should be decrypted.
+   * @param aad additional data that is checked for authenticity.
+   * @param nonce the nonce that was used for the encryption.
+   * @throws GeneralSecurityException if the tag is invalid or any of the inputs do not have the
+   *     expected size.
+   */
+  void decrypt(ByteBuffer plaintext, ByteBuffer ciphertext, ByteBuffer aad, byte[] nonce)
+      throws GeneralSecurityException;
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AesGcmAeadCrypter.java b/alts/src/main/java/io/grpc/alts/internal/AesGcmAeadCrypter.java
new file mode 100644
index 00000000000..e3e6302b591
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AesGcmAeadCrypter.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.internal.ConscryptLoader;
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+import java.security.Provider;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.crypto.Cipher;
+import javax.crypto.spec.GCMParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+/** AES128-GCM implementation of {@link AeadCrypter} that uses default JCE provider. */
+final class AesGcmAeadCrypter implements AeadCrypter {
+  private static final Logger logger = Logger.getLogger(AesGcmAeadCrypter.class.getName());
+  private static final int KEY_LENGTH = 16;
+  private static final int TAG_LENGTH = 16;
+  static final int NONCE_LENGTH = 12;
+
+  private static final String AES = "AES";
+  private static final String AES_GCM = AES + "/GCM/NoPadding";
+  // Conscrypt if available, otherwise null. Conscrypt is much faster than Java 8's JSSE
+  private static final Provider CONSCRYPT = getConscrypt();
+
+  private final byte[] key;
+  private final Cipher cipher;
+
+  AesGcmAeadCrypter(byte[] key) throws GeneralSecurityException {
+    checkArgument(key.length == KEY_LENGTH);
+    this.key = key;
+    if (CONSCRYPT != null) {
+      cipher = Cipher.getInstance(AES_GCM, CONSCRYPT);
+    } else {
+      cipher = Cipher.getInstance(AES_GCM);
+    }
+  }
+
+  private int encryptAad(
+      ByteBuffer ciphertext, ByteBuffer plaintext, @Nullable ByteBuffer aad, byte[] nonce)
+      throws GeneralSecurityException {
+    checkArgument(nonce.length == NONCE_LENGTH);
+    cipher.init(
+        Cipher.ENCRYPT_MODE,
+        new SecretKeySpec(this.key, AES),
+        new GCMParameterSpec(TAG_LENGTH * 8, nonce));
+    if (aad != null) {
+      cipher.updateAAD(aad);
+    }
+    return cipher.doFinal(plaintext, ciphertext);
+  }
+
+  private void decryptAad(
+      ByteBuffer plaintext, ByteBuffer ciphertext, @Nullable ByteBuffer aad, byte[] nonce)
+      throws GeneralSecurityException {
+    checkArgument(nonce.length == NONCE_LENGTH);
+    cipher.init(
+        Cipher.DECRYPT_MODE,
+        new SecretKeySpec(this.key, AES),
+        new GCMParameterSpec(TAG_LENGTH * 8, nonce));
+    if (aad != null) {
+      cipher.updateAAD(aad);
+    }
+    cipher.doFinal(ciphertext, plaintext);
+  }
+
+  @Override
+  public void encrypt(ByteBuffer ciphertext, ByteBuffer plaintext, byte[] nonce)
+      throws GeneralSecurityException {
+    encryptAad(ciphertext, plaintext, null, nonce);
+  }
+
+  @Override
+  public void encrypt(ByteBuffer ciphertext, ByteBuffer plaintext, ByteBuffer aad, byte[] nonce)
+      throws GeneralSecurityException {
+    encryptAad(ciphertext, plaintext, aad, nonce);
+  }
+
+  @Override
+  public void decrypt(ByteBuffer plaintext, ByteBuffer ciphertext, byte[] nonce)
+      throws GeneralSecurityException {
+    decryptAad(plaintext, ciphertext, null, nonce);
+  }
+
+  @Override
+  public void decrypt(ByteBuffer plaintext, ByteBuffer ciphertext, ByteBuffer aad, byte[] nonce)
+      throws GeneralSecurityException {
+    decryptAad(plaintext, ciphertext, aad, nonce);
+  }
+
+  static int getKeyLength() {
+    return KEY_LENGTH;
+  }
+
+  @VisibleForTesting
+  static Provider getConscrypt() {
+    if (!ConscryptLoader.isPresent()) {
+      return null;
+    }
+    // Conscrypt 2.1.0 or later is required. If an older version is used, it will fail with these
+    // sorts of errors:
+    //     "The underlying Cipher implementation does not support this method"
+    //     "error:1e000067:Cipher functions:OPENSSL_internal:BUFFER_TOO_SMALL"
+    //
+    // While we could use Conscrypt.version() to check compatibility, that is _very_ verbose via
+    // reflection. In practice, old conscrypts are probably not much of a problem.
+    Provider provider;
+    try {
+      provider = ConscryptLoader.newProvider();
+    } catch (Throwable t) {
+      logger.log(Level.INFO, "Could not load Conscrypt. Will use slower JDK implementation", t);
+      return null;
+    }
+    try {
+      Cipher.getInstance(AES_GCM, provider);
+    } catch (SecurityException t) {
+      // Pre-Java 7u121/Java 8u111 fails with SecurityException:
+      //   JCE cannot authenticate the provider Conscrypt
+      //
+      // This is because Conscrypt uses a newer (more secure) signing CA than the earlier Java
+      // supported. https://www.oracle.com/technetwork/java/javase/8u111-relnotes-3124969.html
+      // https://www.oracle.com/technetwork/java/javase/documentation/javase7supportreleasenotes-1601161.html#R170_121
+      //
+      // Use WARNING instead of INFO in this case because it is unlikely to be a supported
+      // environment. In the other cases we might be on Java 9+; it seems unlikely in this case.
+      // Note that on Java 7, we're likely to crash later because GCM is unsupported.
+      logger.log(
+          Level.WARNING,
+          "Could not load Conscrypt. Will try slower JDK implementation. This may be because the "
+          + "JDK is older than Java 7 update 121 or Java 8 update 111. If so, please update",
+          t);
+      return null;
+    } catch (Throwable t) {
+      logger.log(Level.INFO, "Could not load Conscrypt. Will use slower JDK implementation", t);
+      return null;
+    }
+    return provider;
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AesGcmHkdfAeadCrypter.java b/alts/src/main/java/io/grpc/alts/internal/AesGcmHkdfAeadCrypter.java
new file mode 100644
index 00000000000..b0f7535d35a
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AesGcmHkdfAeadCrypter.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+import java.util.Arrays;
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+
+/**
+ * {@link AeadCrypter} implementation based on {@link AesGcmAeadCrypter} with nonce-based rekeying
+ * using HKDF-expand and random nonce-mask that is XORed with the given nonce/counter. The AES-GCM
+ * key is computed as HKDF-expand(kdfKey, nonce[2..7]), i.e., the first 2 bytes are ignored to
+ * require rekeying only after 2^16 operations and the last 4 bytes (including the direction bit)
+ * are ignored to allow for optimizations (use same AEAD context for both directions, store counter
+ * as unsigned long and boolean for direction).
+ */
+final class AesGcmHkdfAeadCrypter implements AeadCrypter {
+  private static final int KDF_KEY_LENGTH = 32;
+  // Rekey after 2^(2*8) = 2^16 operations by ignoring the first 2 nonce bytes for key derivation.
+  private static final int KDF_COUNTER_OFFSET = 2;
+  // Use remaining bytes of 64-bit counter included in nonce for key derivation.
+  private static final int KDF_COUNTER_LENGTH = 6;
+  private static final int NONCE_LENGTH = AesGcmAeadCrypter.NONCE_LENGTH;
+  private static final int KEY_LENGTH = KDF_KEY_LENGTH + NONCE_LENGTH;
+
+  private final byte[] kdfKey;
+  private final byte[] kdfCounter = new byte[KDF_COUNTER_LENGTH];
+  private final byte[] nonceMask;
+  private final byte[] nonceBuffer = new byte[NONCE_LENGTH];
+
+  private AeadCrypter aeadCrypter;
+
+  AesGcmHkdfAeadCrypter(byte[] key) {
+    checkArgument(key.length == KEY_LENGTH);
+    this.kdfKey = Arrays.copyOf(key, KDF_KEY_LENGTH);
+    this.nonceMask = Arrays.copyOfRange(key, KDF_KEY_LENGTH, KDF_KEY_LENGTH + NONCE_LENGTH);
+  }
+
+  @Override
+  public void encrypt(ByteBuffer ciphertext, ByteBuffer plaintext, byte[] nonce)
+      throws GeneralSecurityException {
+    maybeRekey(nonce);
+    maskNonce(nonceBuffer, nonceMask, nonce);
+    aeadCrypter.encrypt(ciphertext, plaintext, nonceBuffer);
+  }
+
+  @Override
+  public void encrypt(ByteBuffer ciphertext, ByteBuffer plaintext, ByteBuffer aad, byte[] nonce)
+      throws GeneralSecurityException {
+    maybeRekey(nonce);
+    maskNonce(nonceBuffer, nonceMask, nonce);
+    aeadCrypter.encrypt(ciphertext, plaintext, aad, nonceBuffer);
+  }
+
+  @Override
+  public void decrypt(ByteBuffer plaintext, ByteBuffer ciphertext, byte[] nonce)
+      throws GeneralSecurityException {
+    maybeRekey(nonce);
+    maskNonce(nonceBuffer, nonceMask, nonce);
+    aeadCrypter.decrypt(plaintext, ciphertext, nonceBuffer);
+  }
+
+  @Override
+  public void decrypt(ByteBuffer plaintext, ByteBuffer ciphertext, ByteBuffer aad, byte[] nonce)
+      throws GeneralSecurityException {
+    maybeRekey(nonce);
+    maskNonce(nonceBuffer, nonceMask, nonce);
+    aeadCrypter.decrypt(plaintext, ciphertext, aad, nonceBuffer);
+  }
+
+  private void maybeRekey(byte[] nonce) throws GeneralSecurityException {
+    if (aeadCrypter != null
+        && arrayEqualOn(nonce, KDF_COUNTER_OFFSET, kdfCounter, 0, KDF_COUNTER_LENGTH)) {
+      return;
+    }
+    System.arraycopy(nonce, KDF_COUNTER_OFFSET, kdfCounter, 0, KDF_COUNTER_LENGTH);
+    int aeKeyLen = AesGcmAeadCrypter.getKeyLength();
+    byte[] aeKey = Arrays.copyOf(hkdfExpandSha256(kdfKey, kdfCounter), aeKeyLen);
+    aeadCrypter = new AesGcmAeadCrypter(aeKey);
+  }
+
+  private static void maskNonce(byte[] nonceBuffer, byte[] nonceMask, byte[] nonce) {
+    checkArgument(nonce.length == NONCE_LENGTH);
+    for (int i = 0; i < NONCE_LENGTH; i++) {
+      nonceBuffer[i] = (byte) (nonceMask[i] ^ nonce[i]);
+    }
+  }
+
+  private static byte[] hkdfExpandSha256(byte[] key, byte[] info) throws GeneralSecurityException {
+    Mac mac = Mac.getInstance("HMACSHA256");
+    mac.init(new SecretKeySpec(key, mac.getAlgorithm()));
+    mac.update(info);
+    mac.update((byte) 0x01);
+    return mac.doFinal();
+  }
+
+  private static boolean arrayEqualOn(byte[] a, int aPos, byte[] b, int bPos, int length) {
+    for (int i = 0; i < length; i++) {
+      if (a[aPos + i] != b[bPos + i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  static int getKeyLength() {
+    return KEY_LENGTH;
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AltsChannelCrypter.java b/alts/src/main/java/io/grpc/alts/internal/AltsChannelCrypter.java
new file mode 100644
index 00000000000..5e4c6fec301
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsChannelCrypter.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Verify.verify;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.netty.buffer.ByteBuf;
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+import java.util.List;
+
+/** Performs encryption and decryption with AES-GCM using JCE. All methods are thread-compatible. */
+final class AltsChannelCrypter implements ChannelCrypterNetty {
+  private static final int KEY_LENGTH = AesGcmHkdfAeadCrypter.getKeyLength();
+  private static final int COUNTER_LENGTH = 12;
+  // The counter will overflow after 2^64 operations and encryption/decryption will stop working.
+  private static final int COUNTER_OVERFLOW_LENGTH = 8;
+  private static final int TAG_LENGTH = 16;
+
+  private final AeadCrypter aeadCrypter;
+
+  private final byte[] outCounter = new byte[COUNTER_LENGTH];
+  private final byte[] inCounter = new byte[COUNTER_LENGTH];
+  private final byte[] oldCounter = new byte[COUNTER_LENGTH];
+
+  AltsChannelCrypter(byte[] key, boolean isClient) {
+    checkArgument(key.length == KEY_LENGTH);
+    byte[] counter = isClient ? inCounter : outCounter;
+    counter[counter.length - 1] = (byte) 0x80;
+    this.aeadCrypter = new AesGcmHkdfAeadCrypter(key);
+  }
+
+  static int getKeyLength() {
+    return KEY_LENGTH;
+  }
+
+  static int getCounterLength() {
+    return COUNTER_LENGTH;
+  }
+
+  @Override
+  public void encrypt(ByteBuf outBuf, List<ByteBuf> plainBufs) throws GeneralSecurityException {
+    checkArgument(outBuf.nioBufferCount() == 1);
+    // Copy plaintext buffers into outBuf for in-place encryption on single direct buffer.
+    ByteBuf plainBuf = outBuf.slice(outBuf.writerIndex(), outBuf.writableBytes());
+    plainBuf.writerIndex(0);
+    for (ByteBuf inBuf : plainBufs) {
+      plainBuf.writeBytes(inBuf);
+    }
+
+    verify(outBuf.writableBytes() == plainBuf.readableBytes() + TAG_LENGTH);
+    ByteBuffer out = outBuf.internalNioBuffer(outBuf.writerIndex(), outBuf.writableBytes());
+    ByteBuffer plain = out.duplicate();
+    plain.limit(out.limit() - TAG_LENGTH);
+
+    byte[] counter = incrementOutCounter();
+    int outPosition = out.position();
+    aeadCrypter.encrypt(out, plain, counter);
+    int bytesWritten = out.position() - outPosition;
+    outBuf.writerIndex(outBuf.writerIndex() + bytesWritten);
+    verify(!outBuf.isWritable());
+  }
+
+  @Override
+  public void decrypt(ByteBuf out, ByteBuf tag, List<ByteBuf> ciphertextBufs)
+      throws GeneralSecurityException {
+
+    ByteBuf cipherTextAndTag = out.slice(out.writerIndex(), out.writableBytes());
+    cipherTextAndTag.writerIndex(0);
+
+    for (ByteBuf inBuf : ciphertextBufs) {
+      cipherTextAndTag.writeBytes(inBuf);
+    }
+    cipherTextAndTag.writeBytes(tag);
+
+    decrypt(out, cipherTextAndTag);
+  }
+
+  @Override
+  public void decrypt(ByteBuf out, ByteBuf ciphertextAndTag) throws GeneralSecurityException {
+    int bytesRead = ciphertextAndTag.readableBytes();
+    checkArgument(bytesRead == out.writableBytes());
+
+    checkArgument(out.nioBufferCount() == 1);
+    ByteBuffer outBuffer = out.internalNioBuffer(out.writerIndex(), out.writableBytes());
+
+    checkArgument(ciphertextAndTag.nioBufferCount() == 1);
+    ByteBuffer ciphertextAndTagBuffer =
+        ciphertextAndTag.nioBuffer(ciphertextAndTag.readerIndex(), bytesRead);
+
+    byte[] counter = incrementInCounter();
+    int outPosition = outBuffer.position();
+    aeadCrypter.decrypt(outBuffer, ciphertextAndTagBuffer, counter);
+    int bytesWritten = outBuffer.position() - outPosition;
+    out.writerIndex(out.writerIndex() + bytesWritten);
+    ciphertextAndTag.readerIndex(out.readerIndex() + bytesRead);
+    verify(out.writableBytes() == TAG_LENGTH);
+  }
+
+  @Override
+  public int getSuffixLength() {
+    return TAG_LENGTH;
+  }
+
+  @Override
+  public void destroy() {
+    // no destroy required
+  }
+
+  /** Increments {@code counter}, store the unincremented value in {@code oldCounter}. */
+  static void incrementCounter(byte[] counter, byte[] oldCounter) throws GeneralSecurityException {
+    System.arraycopy(counter, 0, oldCounter, 0, counter.length);
+    int i = 0;
+    for (; i < COUNTER_OVERFLOW_LENGTH; i++) {
+      counter[i]++;
+      if (counter[i] != (byte) 0x00) {
+        break;
+      }
+    }
+
+    if (i == COUNTER_OVERFLOW_LENGTH) {
+      // Restore old counter value to ensure that encrypt and decrypt keep failing.
+      System.arraycopy(oldCounter, 0, counter, 0, counter.length);
+      throw new GeneralSecurityException("Counter has overflowed.");
+    }
+  }
+
+  /** Increments the input counter, returning the previous (unincremented) value. */
+  private byte[] incrementInCounter() throws GeneralSecurityException {
+    incrementCounter(inCounter, oldCounter);
+    return oldCounter;
+  }
+
+  /** Increments the output counter, returning the previous (unincremented) value. */
+  private byte[] incrementOutCounter() throws GeneralSecurityException {
+    incrementCounter(outCounter, oldCounter);
+    return oldCounter;
+  }
+
+  @VisibleForTesting
+  void incrementInCounterForTesting(int n) throws GeneralSecurityException {
+    for (int i = 0; i < n; i++) {
+      incrementInCounter();
+    }
+  }
+
+  @VisibleForTesting
+  void incrementOutCounterForTesting(int n) throws GeneralSecurityException {
+    for (int i = 0; i < n; i++) {
+      incrementOutCounter();
+    }
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AltsClientOptions.java b/alts/src/main/java/io/grpc/alts/internal/AltsClientOptions.java
new file mode 100644
index 00000000000..9ad614c9623
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsClientOptions.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import com.google.common.collect.ImmutableList;
+import javax.annotation.Nullable;
+
+/** Handshaker options for creating ALTS client channel. */
+public final class AltsClientOptions extends AltsHandshakerOptions {
+
+  // targetName is the server service account name for secure name checking.
+  @Nullable private final String targetName;
+  // targetServiceAccounts contains a list of expected target service accounts. One of these service
+  // accounts should match peer service account in the handshaker result. Otherwise, the handshake
+  // fails.
+  private final ImmutableList<String> targetServiceAccounts;
+
+  private AltsClientOptions(Builder builder) {
+    super(builder.rpcProtocolVersions);
+    targetName = builder.targetName;
+    targetServiceAccounts = builder.targetServiceAccounts;
+  }
+
+  public String getTargetName() {
+    return targetName;
+  }
+
+  public ImmutableList<String> getTargetServiceAccounts() {
+    return targetServiceAccounts;
+  }
+
+  /** Builder for AltsClientOptions. */
+  public static final class Builder {
+
+    @Nullable private String targetName;
+    @Nullable private RpcProtocolVersions rpcProtocolVersions;
+    private ImmutableList<String> targetServiceAccounts = ImmutableList.of();
+
+    public Builder setTargetName(String targetName) {
+      this.targetName = targetName;
+      return this;
+    }
+
+    public Builder setRpcProtocolVersions(RpcProtocolVersions rpcProtocolVersions) {
+      this.rpcProtocolVersions = rpcProtocolVersions;
+      return this;
+    }
+
+    public Builder setTargetServiceAccounts(ImmutableList<String> targetServiceAccounts) {
+      this.targetServiceAccounts = targetServiceAccounts;
+      return this;
+    }
+
+    public AltsClientOptions build() {
+      return new AltsClientOptions(this);
+    }
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AltsFraming.java b/alts/src/main/java/io/grpc/alts/internal/AltsFraming.java
new file mode 100644
index 00000000000..2571f937225
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsFraming.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import com.google.common.base.Preconditions;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.security.GeneralSecurityException;
+
+/** Framing and deframing methods and classes used by handshaker. */
+public final class AltsFraming {
+  // The size of the frame field. Must correspond to the size of int, 4 bytes.
+  // Left package-private for testing.
+  private static final int FRAME_LENGTH_HEADER_SIZE = 4;
+  private static final int FRAME_MESSAGE_TYPE_HEADER_SIZE = 4;
+  private static final int MAX_DATA_LENGTH = 1024 * 1024;
+  private static final int INITIAL_BUFFER_CAPACITY = 1024 * 64;
+
+  // TODO: Make this the responsibility of the caller.
+  private static final int MESSAGE_TYPE = 6;
+
+  private AltsFraming() {}
+
+  static int getFrameLengthHeaderSize() {
+    return FRAME_LENGTH_HEADER_SIZE;
+  }
+
+  static int getFrameMessageTypeHeaderSize() {
+    return FRAME_MESSAGE_TYPE_HEADER_SIZE;
+  }
+
+  static int getMaxDataLength() {
+    return MAX_DATA_LENGTH;
+  }
+
+  static int getFramingOverhead() {
+    return FRAME_LENGTH_HEADER_SIZE + FRAME_MESSAGE_TYPE_HEADER_SIZE;
+  }
+
+  /**
+   * Creates a frame of length dataSize + FRAME_HEADER_SIZE using the input bytes, if dataSize <=
+   * input.remaining(). Otherwise, a frame of length input.remaining() + FRAME_HEADER_SIZE is
+   * created.
+   */
+  static ByteBuffer toFrame(ByteBuffer input, int dataSize) throws GeneralSecurityException {
+    Preconditions.checkNotNull(input);
+    if (dataSize > input.remaining()) {
+      dataSize = input.remaining();
+    }
+    Producer producer = new Producer();
+    ByteBuffer inputAlias = input.duplicate();
+    ((Buffer) inputAlias).limit(input.position() + dataSize);
+    producer.readBytes(inputAlias);
+    producer.flush();
+    ((Buffer) input).position(inputAlias.position());
+    ByteBuffer output = producer.getRawFrame();
+    return output;
+  }
+
+  /**
+   * A helper class to write a frame.
+   *
+   * <p>This class guarantees that one of the following is true:
+   *
+   * <ul>
+   *   <li>readBytes will read from the input
+   *   <li>writeBytes will write to the output
+   * </ul>
+   *
+   * <p>Sample usage:
+   *
+   * <pre>{@code
+   * Producer producer = new Producer();
+   * ByteBuffer inputBuffer = readBytesFromMyStream();
+   * ByteBuffer outputBuffer = writeBytesToMyStream();
+   * while (inputBuffer.hasRemaining() || outputBuffer.hasRemaining()) {
+   *   producer.readBytes(inputBuffer);
+   *   producer.writeBytes(outputBuffer);
+   * }
+   * }</pre>
+   *
+   * <p>Alternatively, this class guarantees that one of the following is true:
+   *
+   * <ul>
+   *   <li>readBytes will read from the input
+   *   <li>{@code isComplete()} returns true and {@code getByteBuffer()} returns the contents of a
+   *       processed frame.
+   * </ul>
+   *
+   * <p>Sample usage:
+   *
+   * <pre>{@code
+   * Producer producer = new Producer();
+   * while (!producer.isComplete()) {
+   *   ByteBuffer inputBuffer = readBytesFromMyStream();
+   *   producer.readBytes(inputBuffer);
+   * }
+   * producer.flush();
+   * ByteBuffer outputBuffer = producer.getRawFrame();
+   * }</pre>
+   */
+  static final class Producer {
+    private ByteBuffer buffer;
+    private boolean isComplete;
+
+    Producer(int maxFrameSize) {
+      buffer = ByteBuffer.allocate(maxFrameSize);
+      reset();
+      Preconditions.checkArgument(maxFrameSize > getFramePrefixLength() + getFrameSuffixLength());
+    }
+
+    Producer() {
+      this(INITIAL_BUFFER_CAPACITY);
+    }
+
+    /** The length of the frame prefix data, including the message length/type fields. */
+    int getFramePrefixLength() {
+      int result = FRAME_LENGTH_HEADER_SIZE + FRAME_MESSAGE_TYPE_HEADER_SIZE;
+      return result;
+    }
+
+    int getFrameSuffixLength() {
+      return 0;
+    }
+
+    /**
+     * Reads bytes from input, parsing them into a frame. Returns false if and only if more data is
+     * needed. To obtain a full frame this method must be called repeatedly until it returns true.
+     */
+    boolean readBytes(ByteBuffer input) throws GeneralSecurityException {
+      Preconditions.checkNotNull(input);
+      if (isComplete) {
+        return true;
+      }
+      copy(buffer, input);
+      if (!buffer.hasRemaining()) {
+        flush();
+      }
+      return isComplete;
+    }
+
+    /**
+     * Completes the current frame, signaling that no further data is available to be passed to
+     * readBytes and that the client requires writeBytes to start returning data. isComplete() is
+     * guaranteed to return true after this call.
+     */
+    void flush() throws GeneralSecurityException {
+      if (isComplete) {
+        return;
+      }
+      // Get the length of the complete frame.
+      int frameLength = buffer.position() + getFrameSuffixLength();
+
+      // Set the limit and move to the start.
+      ((Buffer) buffer).flip();
+
+      // Advance the limit to allow a crypto suffix.
+      ((Buffer) buffer).limit(buffer.limit() + getFrameSuffixLength());
+
+      // Write the data length and the message type.
+      int dataLength = frameLength - FRAME_LENGTH_HEADER_SIZE;
+      buffer.order(ByteOrder.LITTLE_ENDIAN);
+      buffer.putInt(dataLength);
+      buffer.putInt(MESSAGE_TYPE);
+
+      // Move the position back to 0, the frame is ready.
+      ((Buffer) buffer).position(0);
+      isComplete = true;
+    }
+
+    /** Resets the state, preparing to construct a new frame. Must be called between frames. */
+    private void reset() {
+      ((Buffer) buffer).clear();
+
+      // Save some space for framing, we'll fill that in later.
+      ((Buffer) buffer).position(getFramePrefixLength());
+      ((Buffer) buffer).limit(buffer.limit() - getFrameSuffixLength());
+
+      isComplete = false;
+    }
+
+    /**
+     * Returns a ByteBuffer containing a complete raw frame, if it's available. Should only be
+     * called when isComplete() returns true, otherwise null is returned. The returned object
+     * aliases the internal buffer, that is, it shares memory with the internal buffer. No further
+     * operations are permitted on this object until the caller has processed the data it needs from
+     * the returned byte buffer.
+     */
+    ByteBuffer getRawFrame() {
+      if (!isComplete) {
+        return null;
+      }
+      ByteBuffer result = buffer.duplicate();
+      reset();
+      return result;
+    }
+  }
+
+  /**
+   * A helper class to read a frame.
+   *
+   * <p>This class guarantees that one of the following is true:
+   *
+   * <ul>
+   *   <li>readBytes will read from the input
+   *   <li>writeBytes will write to the output
+   * </ul>
+   *
+   * <p>Sample usage:
+   *
+   * <pre>{@code
+   * Parser parser = new Parser();
+   * ByteBuffer inputBuffer = readBytesFromMyStream();
+   * ByteBuffer outputBuffer = writeBytesToMyStream();
+   * while (inputBuffer.hasRemaining() || outputBuffer.hasRemaining()) {
+   *   parser.readBytes(inputBuffer);
+   *   parser.writeBytes(outputBuffer); }
+   * }</pre>
+   *
+   * <p>Alternatively, this class guarantees that one of the following is true:
+   *
+   * <ul>
+   *   <li>readBytes will read from the input
+   *   <li>{@code isComplete()} returns true and {@code getByteBuffer()} returns the contents of a
+   *       processed frame.
+   * </ul>
+   *
+   * <p>Sample usage:
+   *
+   * <pre>{@code
+   * Parser parser = new Parser();
+   * while (!parser.isComplete()) {
+   *   ByteBuffer inputBuffer = readBytesFromMyStream();
+   *   parser.readBytes(inputBuffer);
+   * }
+   * ByteBuffer outputBuffer = parser.getRawFrame();
+   * }</pre>
+   */
+  public static final class Parser {
+    private ByteBuffer buffer = ByteBuffer.allocate(INITIAL_BUFFER_CAPACITY);
+    private boolean isComplete = false;
+
+    public Parser() {
+      Preconditions.checkArgument(
+          INITIAL_BUFFER_CAPACITY > getFramePrefixLength() + getFrameSuffixLength());
+    }
+
+    /**
+     * Reads bytes from input, parsing them into a frame. Returns false if and only if more data is
+     * needed. To obtain a full frame this method must be called repeatedly until it returns true.
+     */
+    public boolean readBytes(ByteBuffer input) throws GeneralSecurityException {
+      Preconditions.checkNotNull(input);
+
+      if (isComplete) {
+        return true;
+      }
+
+      // Read enough bytes to determine the length
+      while (buffer.position() < FRAME_LENGTH_HEADER_SIZE && input.hasRemaining()) {
+        buffer.put(input.get());
+      }
+
+      // If we have enough bytes to determine the length, read the length and ensure that our
+      // internal buffer is large enough.
+      if (buffer.position() == FRAME_LENGTH_HEADER_SIZE && input.hasRemaining()) {
+        ByteBuffer bufferAlias = buffer.duplicate();
+        ((Buffer) bufferAlias).flip();
+        bufferAlias.order(ByteOrder.LITTLE_ENDIAN);
+        int dataLength = bufferAlias.getInt();
+        if (dataLength < FRAME_MESSAGE_TYPE_HEADER_SIZE || dataLength > MAX_DATA_LENGTH) {
+          throw new IllegalArgumentException("Invalid frame length " + dataLength);
+        }
+        // Maybe resize the buffer
+        int frameLength = dataLength + FRAME_LENGTH_HEADER_SIZE;
+        if (buffer.capacity() < frameLength) {
+          buffer = ByteBuffer.allocate(frameLength);
+          buffer.order(ByteOrder.LITTLE_ENDIAN);
+          buffer.putInt(dataLength);
+        }
+        ((Buffer) buffer).limit(frameLength);
+      }
+
+      // TODO: Similarly extract and check message type.
+
+      // Read the remaining data into the internal buffer.
+      copy(buffer, input);
+      if (!buffer.hasRemaining()) {
+        ((Buffer) buffer).flip();
+        isComplete = true;
+      }
+      return isComplete;
+    }
+
+    /** The length of the frame prefix data, including the message length/type fields. */
+    int getFramePrefixLength() {
+      int result = FRAME_LENGTH_HEADER_SIZE + FRAME_MESSAGE_TYPE_HEADER_SIZE;
+      return result;
+    }
+
+    int getFrameSuffixLength() {
+      return 0;
+    }
+
+    /** Returns true if we've parsed a complete frame. */
+    public boolean isComplete() {
+      return isComplete;
+    }
+
+    /** Resets the state, preparing to parse a new frame. Must be called between frames. */
+    private void reset() {
+      ((Buffer) buffer).clear();
+      isComplete = false;
+    }
+
+    /**
+     * Returns a ByteBuffer containing a complete raw frame, if it's available. Should only be
+     * called when isComplete() returns true, otherwise null is returned. The returned object
+     * aliases the internal buffer, that is, it shares memory with the internal buffer. No further
+     * operations are permitted on this object until the caller has processed the data it needs from
+     * the returned byte buffer.
+     */
+    public ByteBuffer getRawFrame() {
+      if (!isComplete) {
+        return null;
+      }
+      ByteBuffer result = buffer.duplicate();
+      reset();
+      return result;
+    }
+  }
+
+  /**
+   * Copy as much as possible to dst from src. Unlike {@link ByteBuffer#put(ByteBuffer)}, this stops
+   * early if there is no room left in dst.
+   */
+  private static void copy(ByteBuffer dst, ByteBuffer src) {
+    if (dst.hasRemaining() && src.hasRemaining()) {
+      // Avoid an allocation if possible.
+      if (dst.remaining() >= src.remaining()) {
+        dst.put(src);
+      } else {
+        int count = Math.min(dst.remaining(), src.remaining());
+        ByteBuffer slice = src.slice();
+        ((Buffer) slice).limit(count);
+        dst.put(slice);
+        ((Buffer) src).position(src.position() + count);
+      }
+    }
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerClient.java b/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerClient.java
new file mode 100644
index 00000000000..9eb07f3e86d
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerClient.java
@@ -0,0 +1,252 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import com.google.protobuf.ByteString;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.Status;
+import io.grpc.alts.internal.HandshakerServiceGrpc.HandshakerServiceStub;
+import java.io.IOException;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+
+/** An API for conducting handshakes via ALTS handshaker service. */
+class AltsHandshakerClient {
+  private static final String APPLICATION_PROTOCOL = "grpc";
+  private static final String RECORD_PROTOCOL = "ALTSRP_GCM_AES128_REKEY";
+  private static final int KEY_LENGTH = AltsChannelCrypter.getKeyLength();
+
+  private final AltsHandshakerStub handshakerStub;
+  private final AltsHandshakerOptions handshakerOptions;
+  private HandshakerResult result;
+  private HandshakerStatus status;
+  private final ChannelLogger logger;
+
+  /** Starts a new handshake interacting with the handshaker service. */
+  AltsHandshakerClient(
+      HandshakerServiceStub stub, AltsHandshakerOptions options, ChannelLogger logger) {
+    handshakerStub = new AltsHandshakerStub(stub);
+    handshakerOptions = options;
+    this.logger = logger;
+  }
+
+  @VisibleForTesting
+  AltsHandshakerClient(
+      AltsHandshakerStub handshakerStub, AltsHandshakerOptions options, ChannelLogger logger) {
+    this.handshakerStub = handshakerStub;
+    handshakerOptions = options;
+    this.logger = logger;
+  }
+
+  static String getApplicationProtocol() {
+    return APPLICATION_PROTOCOL;
+  }
+
+  static String getRecordProtocol() {
+    return RECORD_PROTOCOL;
+  }
+
+  /** Sets the start client fields for the passed handshake request. */
+  private void setStartClientFields(HandshakerReq.Builder req) {
+    // Sets the default values.
+    StartClientHandshakeReq.Builder startClientReq =
+        StartClientHandshakeReq.newBuilder()
+            .setHandshakeSecurityProtocol(HandshakeProtocol.ALTS)
+            .addApplicationProtocols(APPLICATION_PROTOCOL)
+            .addRecordProtocols(RECORD_PROTOCOL);
+    // Sets handshaker options.
+    if (handshakerOptions.getRpcProtocolVersions() != null) {
+      startClientReq.setRpcVersions(handshakerOptions.getRpcProtocolVersions());
+    }
+    if (handshakerOptions instanceof AltsClientOptions) {
+      AltsClientOptions clientOptions = (AltsClientOptions) handshakerOptions;
+      if (!Strings.isNullOrEmpty(clientOptions.getTargetName())) {
+        startClientReq.setTargetName(clientOptions.getTargetName());
+      }
+      for (String serviceAccount : clientOptions.getTargetServiceAccounts()) {
+        startClientReq.addTargetIdentitiesBuilder().setServiceAccount(serviceAccount);
+      }
+    }
+    startClientReq.setMaxFrameSize(AltsTsiFrameProtector.getMaxFrameSize());
+    req.setClientStart(startClientReq);
+  }
+
+  /** Sets the start server fields for the passed handshake request. */
+  private void setStartServerFields(HandshakerReq.Builder req, ByteBuffer inBytes) {
+    ServerHandshakeParameters serverParameters =
+        ServerHandshakeParameters.newBuilder().addRecordProtocols(RECORD_PROTOCOL).build();
+    StartServerHandshakeReq.Builder startServerReq =
+        StartServerHandshakeReq.newBuilder()
+            .addApplicationProtocols(APPLICATION_PROTOCOL)
+            .putHandshakeParameters(HandshakeProtocol.ALTS.getNumber(), serverParameters)
+            .setInBytes(ByteString.copyFrom(inBytes.duplicate()));
+    if (handshakerOptions.getRpcProtocolVersions() != null) {
+      startServerReq.setRpcVersions(handshakerOptions.getRpcProtocolVersions());
+    }
+    startServerReq.setMaxFrameSize(AltsTsiFrameProtector.getMaxFrameSize());
+    req.setServerStart(startServerReq);
+  }
+
+  /** Returns true if the handshake is complete. */
+  public boolean isFinished() {
+    // If we have a HandshakeResult, we are done.
+    if (result != null) {
+      return true;
+    }
+    // If we have an error status, we are done.
+    if (status != null && status.getCode() != Status.Code.OK.value()) {
+      return true;
+    }
+    return false;
+  }
+
+  /** Returns the handshake status. */
+  public HandshakerStatus getStatus() {
+    return status;
+  }
+
+  /** Returns the result data of the handshake, if the handshake is completed. */
+  public HandshakerResult getResult() {
+    return result;
+  }
+
+  /**
+   * Returns the resulting key of the handshake, if the handshake is completed. Note that the key
+   * data returned from the handshake may be more than the key length required for the record
+   * protocol, thus we need to truncate to the right size.
+   */
+  public byte[] getKey() {
+    if (result == null) {
+      return null;
+    }
+    if (result.getKeyData().size() < KEY_LENGTH) {
+      throw new IllegalStateException("Could not get enough key data from the handshake.");
+    }
+    byte[] key = new byte[KEY_LENGTH];
+    result.getKeyData().substring(0, KEY_LENGTH).copyTo(key, 0);
+    return key;
+  }
+
+  /**
+   * Parses a handshake response, setting the status, result, and closing the handshaker, as needed.
+   */
+  private void handleResponse(HandshakerResp resp) throws GeneralSecurityException {
+    status = resp.getStatus();
+    if (resp.hasResult()) {
+      result = resp.getResult();
+      close();
+    }
+    if (status.getCode() != Status.Code.OK.value()) {
+      String error = "Handshaker service error: " + status.getDetails();
+      logger.log(ChannelLogLevel.DEBUG, error);
+      close();
+      throw new GeneralSecurityException(error);
+    }
+  }
+
+  /**
+   * Starts a client handshake. A GeneralSecurityException is thrown if the handshaker service is
+   * interrupted or fails. Note that isFinished() must be false before this function is called.
+   *
+   * @return the frame to give to the peer.
+   * @throws GeneralSecurityException or IllegalStateException
+   */
+  public ByteBuffer startClientHandshake() throws GeneralSecurityException {
+    Preconditions.checkState(!isFinished(), "Handshake has already finished.");
+    HandshakerReq.Builder req = HandshakerReq.newBuilder();
+    setStartClientFields(req);
+    HandshakerResp resp;
+    try {
+      logger.log(ChannelLogLevel.DEBUG, "Send ALTS handshake request to upstream");
+      resp = handshakerStub.send(req.build());
+      logger.log(ChannelLogLevel.DEBUG, "Receive ALTS handshake response from upstream");
+    } catch (IOException | InterruptedException e) {
+      throw new GeneralSecurityException(e);
+    }
+    handleResponse(resp);
+    return resp.getOutFrames().asReadOnlyByteBuffer();
+  }
+
+  /**
+   * Starts a server handshake. A GeneralSecurityException is thrown if the handshaker service is
+   * interrupted or fails. Note that isFinished() must be false before this function is called.
+   *
+   * @param inBytes the bytes received from the peer.
+   * @return the frame to give to the peer.
+   * @throws GeneralSecurityException or IllegalStateException
+   */
+  public ByteBuffer startServerHandshake(ByteBuffer inBytes) throws GeneralSecurityException {
+    Preconditions.checkState(!isFinished(), "Handshake has already finished.");
+    HandshakerReq.Builder req = HandshakerReq.newBuilder();
+    setStartServerFields(req, inBytes);
+    HandshakerResp resp;
+    try {
+      resp = handshakerStub.send(req.build());
+    } catch (IOException | InterruptedException e) {
+      throw new GeneralSecurityException(e);
+    }
+    handleResponse(resp);
+    ((Buffer) inBytes).position(inBytes.position() + resp.getBytesConsumed());
+    return resp.getOutFrames().asReadOnlyByteBuffer();
+  }
+
+  /**
+   * Processes the next bytes in a handshake. A GeneralSecurityException is thrown if the handshaker
+   * service is interrupted or fails. Note that isFinished() must be false before this function is
+   * called.
+   *
+   * @param inBytes the bytes received from the peer.
+   * @return the frame to give to the peer.
+   * @throws GeneralSecurityException or IllegalStateException
+   */
+  public ByteBuffer next(ByteBuffer inBytes) throws GeneralSecurityException {
+    Preconditions.checkState(!isFinished(), "Handshake has already finished.");
+    HandshakerReq.Builder req =
+        HandshakerReq.newBuilder()
+            .setNext(
+                NextHandshakeMessageReq.newBuilder()
+                    .setInBytes(ByteString.copyFrom(inBytes.duplicate()))
+                    .build());
+    HandshakerResp resp;
+    try {
+      logger.log(ChannelLogLevel.DEBUG, "Send ALTS handshake request to upstream");
+      resp = handshakerStub.send(req.build());
+      logger.log(ChannelLogLevel.DEBUG, "Receive ALTS handshake response from upstream");
+    } catch (IOException | InterruptedException e) {
+      throw new GeneralSecurityException(e);
+    }
+    handleResponse(resp);
+    ((Buffer) inBytes).position(inBytes.position() + resp.getBytesConsumed());
+    return resp.getOutFrames().asReadOnlyByteBuffer();
+  }
+
+  private boolean closed = false;
+
+  /** Closes the connection. */
+  public void close() {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    handshakerStub.close();
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerOptions.java b/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerOptions.java
new file mode 100644
index 00000000000..d50f92f185f
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerOptions.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import javax.annotation.Nullable;
+
+/** Handshaker options for creating ALTS channel. */
+public class AltsHandshakerOptions {
+  @Nullable private final RpcProtocolVersions rpcProtocolVersions;
+
+  public AltsHandshakerOptions(RpcProtocolVersions rpcProtocolVersions) {
+    this.rpcProtocolVersions = rpcProtocolVersions;
+  }
+
+  public RpcProtocolVersions getRpcProtocolVersions() {
+    return rpcProtocolVersions;
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerStub.java b/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerStub.java
new file mode 100644
index 00000000000..6c2748dcc9c
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsHandshakerStub.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
+import io.grpc.alts.internal.HandshakerServiceGrpc.HandshakerServiceStub;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.atomic.AtomicReference;
+
+/** An interface to the ALTS handshaker service. */
+class AltsHandshakerStub {
+  private final StreamObserver<HandshakerResp> reader = new Reader();
+  private StreamObserver<HandshakerReq> writer;
+  private final HandshakerServiceStub serviceStub;
+  private final ArrayBlockingQueue<Optional<HandshakerResp>> responseQueue =
+      new ArrayBlockingQueue<>(1);
+  private final AtomicReference<ThrowableInfo> exceptionMessage = new AtomicReference<>();
+
+  private static final long HANDSHAKE_RPC_DEADLINE_SECS = 20;
+
+  AltsHandshakerStub(HandshakerServiceStub serviceStub) {
+    this.serviceStub = serviceStub;
+  }
+
+  @VisibleForTesting
+  AltsHandshakerStub() {
+    serviceStub = null;
+  }
+
+  @VisibleForTesting
+  AltsHandshakerStub(StreamObserver<HandshakerReq> writer) {
+    this.writer = writer;
+    serviceStub = null;
+  }
+
+  @VisibleForTesting
+  StreamObserver<HandshakerResp> getReaderForTest() {
+    return reader;
+  }
+
+  /** Send a handshaker request and return the handshaker response. */
+  public HandshakerResp send(HandshakerReq req) throws InterruptedException, IOException {
+    createWriterIfNull();
+    maybeThrowIoException();
+    if (!responseQueue.isEmpty()) {
+      throw new IOException("Received an unexpected response.");
+    }
+
+    writer.onNext(req);
+    Optional<HandshakerResp> result = responseQueue.take();
+    if (result.isPresent()) {
+      return result.get();
+    }
+
+    if (exceptionMessage.get() != null) {
+      throw new IOException(exceptionMessage.get().info, exceptionMessage.get().throwable);
+    } else {
+      throw new IOException("No handshaker response received");
+    }
+  }
+
+  /** Create a new writer if the writer is null. */
+  private void createWriterIfNull() {
+    if (writer == null) {
+      writer =
+          serviceStub.withDeadlineAfter(HANDSHAKE_RPC_DEADLINE_SECS, SECONDS).doHandshake(reader);
+    }
+  }
+
+  /** Throw exception if there is an outstanding exception. */
+  private void maybeThrowIoException() throws IOException {
+    if (exceptionMessage.get() != null) {
+      throw new IOException(exceptionMessage.get().info, exceptionMessage.get().throwable);
+    }
+  }
+
+  /** Close the connection. */
+  public void close() {
+    if (writer != null) {
+      writer.onCompleted();
+    }
+  }
+
+  private class Reader implements StreamObserver<HandshakerResp> {
+    /** Receive a handshaker response from the server. */
+    @Override
+    public void onNext(HandshakerResp resp) {
+      try {
+        AltsHandshakerStub.this.responseQueue.add(Optional.of(resp));
+      } catch (IllegalStateException e) {
+        AltsHandshakerStub.this.exceptionMessage.compareAndSet(
+            null, new ThrowableInfo(e, "Received an unexpected response."));
+        AltsHandshakerStub.this.close();
+      }
+    }
+
+    /** Receive an error from the server. */
+    @Override
+    public void onError(Throwable t) {
+      AltsHandshakerStub.this.exceptionMessage.compareAndSet(
+          null, new ThrowableInfo(t, "Received a terminating error."));
+      // Trigger the release of any blocked send.
+      Optional<HandshakerResp> result = Optional.absent();
+      AltsHandshakerStub.this.responseQueue.offer(result);
+    }
+
+    /** Receive the closing message from the server. */
+    @Override
+    public void onCompleted() {
+      AltsHandshakerStub.this.exceptionMessage.compareAndSet(
+          null, new ThrowableInfo(null, "Response stream closed."));
+      // Trigger the release of any blocked send.
+      Optional<HandshakerResp> result = Optional.absent();
+      AltsHandshakerStub.this.responseQueue.offer(result);
+    }
+  }
+
+  private static class ThrowableInfo {
+
+    private final Throwable throwable;
+    private final String info;
+
+    private ThrowableInfo(Throwable throwable, String info) {
+      this.throwable = throwable;
+      this.info = info;
+    }
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AltsInternalContext.java b/alts/src/main/java/io/grpc/alts/internal/AltsInternalContext.java
new file mode 100644
index 00000000000..a70c67b2933
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsInternalContext.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import com.google.common.annotations.VisibleForTesting;
+import java.util.Map;
+
+/** AltsInternalContext contains security-related context information about an ALTs connection. */
+public final class AltsInternalContext {
+  final AltsContext context;
+
+  /** Create a new AltsInternalContext. */
+  public AltsInternalContext(HandshakerResult result) {
+    context =
+        AltsContext.newBuilder()
+            .setApplicationProtocol(result.getApplicationProtocol())
+            .setRecordProtocol(result.getRecordProtocol())
+            // TODO: Set security level based on the handshaker result.
+            .setSecurityLevel(SecurityLevel.INTEGRITY_AND_PRIVACY)
+            .setPeerServiceAccount(result.getPeerIdentity().getServiceAccount())
+            .setLocalServiceAccount(result.getLocalIdentity().getServiceAccount())
+            .setPeerRpcVersions(result.getPeerRpcVersions())
+            .putAllPeerAttributes(result.getPeerIdentity().getAttributesMap())
+            .build();
+  }
+
+  @VisibleForTesting
+  public static AltsInternalContext getDefaultInstance() {
+    return new AltsInternalContext(HandshakerResult.newBuilder().build());
+  }
+
+  /**
+   * Get application protocol.
+   *
+   * @return the context's application protocol.
+   */
+  public String getApplicationProtocol() {
+    return context.getApplicationProtocol();
+  }
+
+  /**
+   * Get negotiated record protocol.
+   *
+   * @return the context's negotiated record protocol.
+   */
+  public String getRecordProtocol() {
+    return context.getRecordProtocol();
+  }
+
+  /**
+   * Get security level.
+   *
+   * @return the context's security level.
+   */
+  public SecurityLevel getSecurityLevel() {
+    return context.getSecurityLevel();
+  }
+
+  /**
+   * Get peer service account.
+   *
+   * @return the context's peer service account.
+   */
+  public String getPeerServiceAccount() {
+    return context.getPeerServiceAccount();
+  }
+
+  /**
+   * Get local service account.
+   *
+   * @return the context's local service account.
+   */
+  public String getLocalServiceAccount() {
+    return context.getLocalServiceAccount();
+  }
+
+  /**
+   * Get peer RPC versions.
+   *
+   * @return the context's peer RPC versions.
+   */
+  public RpcProtocolVersions getPeerRpcVersions() {
+    return context.getPeerRpcVersions();
+  }
+
+  /**
+   * Get peer attributes.
+   *
+   * @return the context's peer attributes.
+   */
+  public Map<String, String> getPeerAttributes() {
+    return context.getPeerAttributesMap();
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AltsProtocolNegotiator.java b/alts/src/main/java/io/grpc/alts/internal/AltsProtocolNegotiator.java
new file mode 100644
index 00000000000..9c51cf6a053
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsProtocolNegotiator.java
@@ -0,0 +1,452 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.Any;
+import io.grpc.Attributes;
+import io.grpc.Channel;
+import io.grpc.ChannelLogger;
+import io.grpc.Grpc;
+import io.grpc.InternalChannelz.OtherSecurity;
+import io.grpc.InternalChannelz.Security;
+import io.grpc.SecurityLevel;
+import io.grpc.Status;
+import io.grpc.alts.internal.RpcProtocolVersionsUtil.RpcVersionsCheckResult;
+import io.grpc.internal.ObjectPool;
+import io.grpc.netty.GrpcHttp2ConnectionHandler;
+import io.grpc.netty.InternalProtocolNegotiator;
+import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
+import io.grpc.netty.InternalProtocolNegotiators;
+import io.netty.channel.ChannelHandler;
+import io.netty.handler.ssl.SslContext;
+import io.netty.util.AsciiString;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.security.GeneralSecurityException;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * A gRPC {@link ProtocolNegotiator} for ALTS. This class creates a Netty handler that provides ALTS
+ * security on the wire, similar to Netty's {@code SslHandler}.
+ */
+// TODO(carl-mastrangelo): rename this AltsProtocolNegotiators.
+public final class AltsProtocolNegotiator {
+  private static final Logger logger = Logger.getLogger(AltsProtocolNegotiator.class.getName());
+
+  static final String ALTS_MAX_CONCURRENT_HANDSHAKES_ENV_VARIABLE =
+      "GRPC_ALTS_MAX_CONCURRENT_HANDSHAKES";
+  @VisibleForTesting static final int DEFAULT_ALTS_MAX_CONCURRENT_HANDSHAKES = 32;
+  private static final AsyncSemaphore handshakeSemaphore =
+      new AsyncSemaphore(getAltsMaxConcurrentHandshakes());
+
+  @Grpc.TransportAttr
+  public static final Attributes.Key<TsiPeer> TSI_PEER_KEY =
+      Attributes.Key.create("internal:TSI_PEER");
+  @Grpc.TransportAttr
+  public static final Attributes.Key<Object> AUTH_CONTEXT_KEY =
+      Attributes.Key.create("internal:AUTH_CONTEXT_KEY");
+
+  private static final AsciiString SCHEME = AsciiString.of("https");
+
+  private static final String DIRECT_PATH_SERVICE_CFE_CLUSTER_PREFIX = "google_cfe_";
+  private static final String CFE_CLUSTER_RESOURCE_NAME_PREFIX =
+      "/envoy.config.cluster.v3.Cluster/google_cfe_";
+  private static final String CFE_CLUSTER_AUTHORITY_NAME =
+      "traffic-director-c2p.xds.googleapis.com";
+
+  /**
+   * ClientAltsProtocolNegotiatorFactory is a factory for doing client side negotiation of an ALTS
+   * channel.
+   */
+  public static final class ClientAltsProtocolNegotiatorFactory
+      implements InternalProtocolNegotiator.ClientFactory {
+
+    private final ImmutableList<String> targetServiceAccounts;
+    private final ObjectPool<Channel> handshakerChannelPool;
+
+    public ClientAltsProtocolNegotiatorFactory(
+        List<String> targetServiceAccounts,
+        ObjectPool<Channel> handshakerChannelPool) {
+      this.targetServiceAccounts = ImmutableList.copyOf(targetServiceAccounts);
+      this.handshakerChannelPool = checkNotNull(handshakerChannelPool, "handshakerChannelPool");
+    }
+
+    @Override
+    public ProtocolNegotiator newNegotiator() {
+      return new ClientAltsProtocolNegotiator(
+          targetServiceAccounts,
+          handshakerChannelPool);
+    }
+
+    @Override
+    public int getDefaultPort() {
+      return 443;
+    }
+  }
+
+  private static final class ClientAltsProtocolNegotiator implements ProtocolNegotiator {
+    private final TsiHandshakerFactory handshakerFactory;
+    private final LazyChannel lazyHandshakerChannel;
+
+    ClientAltsProtocolNegotiator(
+        ImmutableList<String> targetServiceAccounts, ObjectPool<Channel> handshakerChannelPool) {
+      this.lazyHandshakerChannel = new LazyChannel(handshakerChannelPool);
+      this.handshakerFactory =
+          new ClientTsiHandshakerFactory(targetServiceAccounts, lazyHandshakerChannel);
+    }
+
+    @Override
+    public AsciiString scheme() {
+      return SCHEME;
+    }
+
+    @Override
+    public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+      ChannelLogger negotiationLogger = grpcHandler.getNegotiationLogger();
+      TsiHandshaker handshaker =
+          handshakerFactory.newHandshaker(grpcHandler.getAuthority(), negotiationLogger);
+      NettyTsiHandshaker nettyHandshaker = new NettyTsiHandshaker(handshaker);
+      ChannelHandler gnh = InternalProtocolNegotiators.grpcNegotiationHandler(grpcHandler);
+      ChannelHandler thh = new TsiHandshakeHandler(
+          gnh, nettyHandshaker, new AltsHandshakeValidator(), handshakeSemaphore,
+          negotiationLogger);
+      ChannelHandler wuah = InternalProtocolNegotiators.waitUntilActiveHandler(thh,
+          negotiationLogger);
+      return wuah;
+    }
+
+    @Override
+    public void close() {
+      lazyHandshakerChannel.close();
+    }
+  }
+
+  /**
+   * Creates a protocol negotiator for ALTS on the server side.
+   */
+  public static ProtocolNegotiator serverAltsProtocolNegotiator(
+      ObjectPool<Channel> handshakerChannelPool) {
+    final LazyChannel lazyHandshakerChannel = new LazyChannel(handshakerChannelPool);
+    final class ServerTsiHandshakerFactory implements TsiHandshakerFactory {
+
+      @Override
+      public TsiHandshaker newHandshaker(
+          @Nullable String authority, ChannelLogger negotiationLogger) {
+        assert authority == null;
+        return AltsTsiHandshaker.newServer(
+            HandshakerServiceGrpc.newStub(lazyHandshakerChannel.get()),
+            new AltsHandshakerOptions(RpcProtocolVersionsUtil.getRpcProtocolVersions()),
+            negotiationLogger);
+      }
+    }
+
+    return new ServerAltsProtocolNegotiator(
+        new ServerTsiHandshakerFactory(), lazyHandshakerChannel);
+  }
+
+  @VisibleForTesting
+  static final class ServerAltsProtocolNegotiator implements ProtocolNegotiator {
+    private final TsiHandshakerFactory handshakerFactory;
+    private final LazyChannel lazyHandshakerChannel;
+
+    @VisibleForTesting
+    ServerAltsProtocolNegotiator(
+        TsiHandshakerFactory handshakerFactory, LazyChannel lazyHandshakerChannel) {
+      this.handshakerFactory = checkNotNull(handshakerFactory, "handshakerFactory");
+      this.lazyHandshakerChannel = checkNotNull(lazyHandshakerChannel, "lazyHandshakerChannel");
+    }
+
+    @Override
+    public AsciiString scheme() {
+      return SCHEME;
+    }
+
+    @Override
+    public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+      ChannelLogger negotiationLogger = grpcHandler.getNegotiationLogger();
+      TsiHandshaker handshaker =
+          handshakerFactory.newHandshaker(/* authority= */ null, negotiationLogger);
+      NettyTsiHandshaker nettyHandshaker = new NettyTsiHandshaker(handshaker);
+      ChannelHandler gnh = InternalProtocolNegotiators.grpcNegotiationHandler(grpcHandler);
+      ChannelHandler thh = new TsiHandshakeHandler(
+          gnh, nettyHandshaker, new AltsHandshakeValidator(), handshakeSemaphore,
+          negotiationLogger);
+      ChannelHandler wuah = InternalProtocolNegotiators.waitUntilActiveHandler(thh,
+          negotiationLogger);
+      return wuah;
+    }
+
+    @Override
+    public void close() {
+      logger.finest("ALTS Server ProtocolNegotiator Closed");
+      lazyHandshakerChannel.close();
+    }
+  }
+
+  /**
+   * A Protocol Negotiator factory which can switch between ALTS and TLS based on EAG Attrs.
+   */
+  public static final class GoogleDefaultProtocolNegotiatorFactory
+      implements InternalProtocolNegotiator.ClientFactory {
+    @VisibleForTesting
+    @Nullable
+    static Attributes.Key<String> clusterNameAttrKey = loadClusterNameAttrKey();
+    private final ImmutableList<String> targetServiceAccounts;
+    private final ObjectPool<Channel> handshakerChannelPool;
+    private final SslContext sslContext;
+
+    /**
+     * Creates Negotiator Factory, which will either use the targetServiceAccounts and
+     * handshakerChannelPool, or the sslContext.
+     */
+    public GoogleDefaultProtocolNegotiatorFactory(
+        List<String> targetServiceAccounts,
+        ObjectPool<Channel> handshakerChannelPool,
+        SslContext sslContext) {
+      this.targetServiceAccounts = ImmutableList.copyOf(targetServiceAccounts);
+      this.handshakerChannelPool = checkNotNull(handshakerChannelPool, "handshakerChannelPool");
+      this.sslContext = checkNotNull(sslContext, "sslContext");
+    }
+
+    @Override
+    public ProtocolNegotiator newNegotiator() {
+      return new GoogleDefaultProtocolNegotiator(
+          targetServiceAccounts,
+          handshakerChannelPool,
+          sslContext,
+          clusterNameAttrKey);
+    }
+
+    @Override
+    public int getDefaultPort() {
+      return 443;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Nullable
+    private static Attributes.Key<String> loadClusterNameAttrKey() {
+      Attributes.Key<String> key = null;
+      try {
+        Class<?> klass = Class.forName("io.grpc.xds.InternalXdsAttributes");
+        key = (Attributes.Key<String>) klass.getField("ATTR_CLUSTER_NAME").get(null);
+      } catch (ClassNotFoundException e) {
+        logger.log(Level.FINE,
+            "Unable to load xDS endpoint cluster name key, this may be expected", e);
+      } catch (NoSuchFieldException e) {
+        logger.log(Level.FINE,
+            "Unable to load xDS endpoint cluster name key, this may be expected", e);
+      } catch (IllegalAccessException e) {
+        logger.log(Level.FINE,
+            "Unable to load xDS endpoint cluster name key, this may be expected", e);
+      }
+      return key;
+    }
+  }
+
+  private static final class GoogleDefaultProtocolNegotiator implements ProtocolNegotiator {
+    private final TsiHandshakerFactory handshakerFactory;
+    private final LazyChannel lazyHandshakerChannel;
+    private final SslContext sslContext;
+    @Nullable
+    private final Attributes.Key<String> clusterNameAttrKey;
+
+    GoogleDefaultProtocolNegotiator(
+        ImmutableList<String> targetServiceAccounts,
+        ObjectPool<Channel> handshakerChannelPool,
+        SslContext sslContext,
+        @Nullable Attributes.Key<String> clusterNameAttrKey) {
+      this.lazyHandshakerChannel = new LazyChannel(handshakerChannelPool);
+      this.handshakerFactory =
+          new ClientTsiHandshakerFactory(targetServiceAccounts, lazyHandshakerChannel);
+      this.sslContext = checkNotNull(sslContext, "checkNotNull");
+      this.clusterNameAttrKey = clusterNameAttrKey;
+    }
+
+    @Override
+    public AsciiString scheme() {
+      return SCHEME;
+    }
+
+    @Override
+    public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+      ChannelHandler gnh = InternalProtocolNegotiators.grpcNegotiationHandler(grpcHandler);
+      ChannelLogger negotiationLogger = grpcHandler.getNegotiationLogger();
+      ChannelHandler securityHandler;
+      boolean isXdsDirectPath = false;
+      if (clusterNameAttrKey != null) {
+        isXdsDirectPath = isDirectPathCluster(
+            grpcHandler.getEagAttributes().get(clusterNameAttrKey));
+      }
+      if (isXdsDirectPath) {
+        TsiHandshaker handshaker =
+            handshakerFactory.newHandshaker(grpcHandler.getAuthority(), negotiationLogger); 
+        NettyTsiHandshaker nettyHandshaker = new NettyTsiHandshaker(handshaker);
+        securityHandler = new TsiHandshakeHandler(
+            gnh, nettyHandshaker, new AltsHandshakeValidator(), handshakeSemaphore,
+            negotiationLogger);
+      } else {
+        securityHandler = InternalProtocolNegotiators.clientTlsHandler(
+            gnh, sslContext, grpcHandler.getAuthority(), negotiationLogger);
+      }
+      ChannelHandler wuah = InternalProtocolNegotiators.waitUntilActiveHandler(securityHandler,
+          negotiationLogger);
+      return wuah;
+    }
+
+    private boolean isDirectPathCluster(String clusterName) {
+      if (clusterName == null) {
+        return false;
+      }
+      if (clusterName.startsWith(DIRECT_PATH_SERVICE_CFE_CLUSTER_PREFIX)) {
+        return false;
+      }
+      if (!clusterName.startsWith("xdstp:")) {
+        return true;
+      }
+      try {
+        URI uri = new URI(clusterName);
+        // If authority AND path match our CFE checks, use TLS; otherwise use ALTS.
+        return !CFE_CLUSTER_AUTHORITY_NAME.equals(uri.getHost())
+            || !uri.getPath().startsWith(CFE_CLUSTER_RESOURCE_NAME_PREFIX);
+      } catch (URISyntaxException e) {
+        return true; // Shouldn't happen, but assume ALTS.
+      }
+    }
+
+    @Override
+    public void close() {
+      logger.finest("ALTS Server ProtocolNegotiator Closed");
+      lazyHandshakerChannel.close();
+    }
+  }
+
+  private static final class ClientTsiHandshakerFactory implements TsiHandshakerFactory {
+
+    private final ImmutableList<String> targetServiceAccounts;
+    private final LazyChannel lazyHandshakerChannel;
+
+    ClientTsiHandshakerFactory(
+        ImmutableList<String> targetServiceAccounts, LazyChannel lazyHandshakerChannel) {
+      this.targetServiceAccounts = checkNotNull(targetServiceAccounts, "targetServiceAccounts");
+      this.lazyHandshakerChannel = checkNotNull(lazyHandshakerChannel, "lazyHandshakerChannel");
+    }
+
+    @Override
+    public TsiHandshaker newHandshaker(
+        @Nullable String authority, ChannelLogger negotiationLogger) {
+      AltsClientOptions handshakerOptions =
+          new AltsClientOptions.Builder()
+              .setRpcProtocolVersions(RpcProtocolVersionsUtil.getRpcProtocolVersions())
+              .setTargetServiceAccounts(targetServiceAccounts)
+              .setTargetName(authority)
+              .build();
+      return AltsTsiHandshaker.newClient(
+          HandshakerServiceGrpc.newStub(lazyHandshakerChannel.get()),
+          handshakerOptions,
+          negotiationLogger);
+    }
+  }
+
+  /** Channel created from a channel pool lazily. */
+  @VisibleForTesting
+  static final class LazyChannel {
+    private final ObjectPool<Channel> channelPool;
+    private Channel channel;
+
+    @VisibleForTesting
+    LazyChannel(ObjectPool<Channel> channelPool) {
+      this.channelPool = checkNotNull(channelPool, "channelPool");
+    }
+
+    /**
+     * If channel is null, gets a channel from the channel pool, otherwise, returns the cached
+     * channel.
+     */
+    synchronized Channel get() {
+      if (channel == null) {
+        channel = channelPool.getObject();
+      }
+      return channel;
+    }
+
+    /** Returns the cached channel to the channel pool. */
+    synchronized void close() {
+      if (channel != null) {
+        channel = channelPool.returnObject(channel);
+      }
+    }
+  }
+
+  private static final class AltsHandshakeValidator extends TsiHandshakeHandler.HandshakeValidator {
+
+    @Override
+    public SecurityDetails validatePeerObject(Object peerObject) throws GeneralSecurityException {
+      AltsInternalContext altsContext = (AltsInternalContext) peerObject;
+      // Checks peer Rpc Protocol Versions in the ALTS auth context. Fails the connection if
+      // Rpc Protocol Versions mismatch.
+      RpcVersionsCheckResult checkResult =
+          RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+              RpcProtocolVersionsUtil.getRpcProtocolVersions(),
+              altsContext.getPeerRpcVersions());
+      if (!checkResult.getResult()) {
+        String errorMessage =
+            "Local Rpc Protocol Versions "
+                + RpcProtocolVersionsUtil.getRpcProtocolVersions()
+                + " are not compatible with peer Rpc Protocol Versions "
+                + altsContext.getPeerRpcVersions();
+        throw Status.UNAVAILABLE.withDescription(errorMessage).asRuntimeException();
+      }
+      return new SecurityDetails(
+          SecurityLevel.PRIVACY_AND_INTEGRITY,
+          new Security(new OtherSecurity("alts", Any.pack(altsContext.context))));
+    }
+  }
+
+  @VisibleForTesting
+  static int getAltsMaxConcurrentHandshakes(String altsMaxConcurrentHandshakes) {
+    if (altsMaxConcurrentHandshakes == null) {
+      return DEFAULT_ALTS_MAX_CONCURRENT_HANDSHAKES;
+    }
+    try {
+      int effectiveMaxConcurrentHandshakes = Integer.parseInt(altsMaxConcurrentHandshakes);
+      if (effectiveMaxConcurrentHandshakes < 0) {
+        logger.warning(
+            "GRPC_ALTS_MAX_CONCURRENT_HANDSHAKES environment variable set to invalid value.");
+        return DEFAULT_ALTS_MAX_CONCURRENT_HANDSHAKES;
+      }
+      return effectiveMaxConcurrentHandshakes;
+    } catch (NumberFormatException e) {
+      logger.warning(
+          "GRPC_ALTS_MAX_CONCURRENT_HANDSHAKES environment variable set to invalid value.");
+      return DEFAULT_ALTS_MAX_CONCURRENT_HANDSHAKES;
+    }
+  }
+
+  private static int getAltsMaxConcurrentHandshakes() {
+    return getAltsMaxConcurrentHandshakes(
+        System.getenv(ALTS_MAX_CONCURRENT_HANDSHAKES_ENV_VARIABLE));
+  }
+
+  private AltsProtocolNegotiator() {}
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AltsTsiFrameProtector.java b/alts/src/main/java/io/grpc/alts/internal/AltsTsiFrameProtector.java
new file mode 100644
index 00000000000..67d6637a130
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsTsiFrameProtector.java
@@ -0,0 +1,408 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Verify.verify;
+
+import com.google.common.primitives.Ints;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.List;
+
+/** Frame protector that uses the ALTS framing. */
+public final class AltsTsiFrameProtector implements TsiFrameProtector {
+  private static final int HEADER_LEN_FIELD_BYTES = 4;
+  private static final int HEADER_TYPE_FIELD_BYTES = 4;
+  private static final int HEADER_BYTES = HEADER_LEN_FIELD_BYTES + HEADER_TYPE_FIELD_BYTES;
+  private static final int HEADER_TYPE_DEFAULT = 6;
+  private static final int LIMIT_MAX_ALLOWED_FRAME_SIZE = 1024 * 1024;
+  // Frame size negotiation extends frame size range to [MIN_FRAME_SIZE, MAX_FRAME_SIZE].
+  private static final int MIN_FRAME_SIZE = 16 * 1024;
+  private static final int MAX_FRAME_SIZE = 128 * 1024;
+
+  private final Protector protector;
+  private final Unprotector unprotector;
+
+  /** Create a new AltsTsiFrameProtector. */
+  public AltsTsiFrameProtector(
+      int maxProtectedFrameBytes, ChannelCrypterNetty crypter, ByteBufAllocator alloc) {
+    checkArgument(maxProtectedFrameBytes > HEADER_BYTES + crypter.getSuffixLength());
+    maxProtectedFrameBytes = Math.min(LIMIT_MAX_ALLOWED_FRAME_SIZE, maxProtectedFrameBytes);
+    protector = new Protector(maxProtectedFrameBytes, crypter);
+    unprotector = new Unprotector(crypter, alloc);
+  }
+
+  static int getHeaderLenFieldBytes() {
+    return HEADER_LEN_FIELD_BYTES;
+  }
+
+  static int getHeaderTypeFieldBytes() {
+    return HEADER_TYPE_FIELD_BYTES;
+  }
+
+  public static int getHeaderBytes() {
+    return HEADER_BYTES;
+  }
+
+  static int getHeaderTypeDefault() {
+    return HEADER_TYPE_DEFAULT;
+  }
+
+  static int getLimitMaxAllowedFrameSize() {
+    return LIMIT_MAX_ALLOWED_FRAME_SIZE;
+  }
+
+  public static int getMinFrameSize() {
+    return MIN_FRAME_SIZE;
+  }
+
+  public static int getMaxFrameSize() {
+    return MAX_FRAME_SIZE;
+  }
+
+  @Override
+  public void protectFlush(
+      List<ByteBuf> unprotectedBufs, Consumer<ByteBuf> ctxWrite, ByteBufAllocator alloc)
+      throws GeneralSecurityException {
+    protector.protectFlush(unprotectedBufs, ctxWrite, alloc);
+  }
+
+  @Override
+  public void unprotect(ByteBuf in, List<Object> out, ByteBufAllocator alloc)
+      throws GeneralSecurityException {
+    unprotector.unprotect(in, out, alloc);
+  }
+
+  @Override
+  public void destroy() {
+    try {
+      unprotector.destroy();
+    } finally {
+      protector.destroy();
+    }
+  }
+
+  static final class Protector {
+    private final int maxUnprotectedBytesPerFrame;
+    private final int suffixBytes;
+    private ChannelCrypterNetty crypter;
+
+    Protector(int maxProtectedFrameBytes, ChannelCrypterNetty crypter) {
+      this.suffixBytes = crypter.getSuffixLength();
+      this.maxUnprotectedBytesPerFrame = maxProtectedFrameBytes - HEADER_BYTES - suffixBytes;
+      this.crypter = crypter;
+    }
+
+    void destroy() {
+      // Shared with Unprotector and destroyed there.
+      crypter = null;
+    }
+
+    void protectFlush(
+        List<ByteBuf> unprotectedBufs, Consumer<ByteBuf> ctxWrite, ByteBufAllocator alloc)
+        throws GeneralSecurityException {
+      checkState(crypter != null, "Cannot protectFlush after destroy.");
+      ByteBuf protectedBuf;
+      try {
+        protectedBuf = handleUnprotected(unprotectedBufs, alloc);
+      } finally {
+        for (ByteBuf buf : unprotectedBufs) {
+          buf.release();
+        }
+      }
+      if (protectedBuf != null) {
+        ctxWrite.accept(protectedBuf);
+      }
+    }
+
+    private ByteBuf handleUnprotected(List<ByteBuf> unprotectedBufs, ByteBufAllocator alloc)
+        throws GeneralSecurityException {
+      long unprotectedBytes = 0;
+      for (ByteBuf buf : unprotectedBufs) {
+        unprotectedBytes += buf.readableBytes();
+      }
+      // Empty plaintext not allowed since this should be handled as no-op in layer above.
+      checkArgument(unprotectedBytes > 0);
+
+      // Compute number of frames and allocate a single buffer for all frames.
+      long frameNum = unprotectedBytes / maxUnprotectedBytesPerFrame + 1;
+      int lastFrameUnprotectedBytes = (int) (unprotectedBytes % maxUnprotectedBytesPerFrame);
+      if (lastFrameUnprotectedBytes == 0) {
+        frameNum--;
+        lastFrameUnprotectedBytes = maxUnprotectedBytesPerFrame;
+      }
+      long protectedBytes = frameNum * (HEADER_BYTES + suffixBytes) + unprotectedBytes;
+
+      ByteBuf protectedBuf = alloc.directBuffer(Ints.checkedCast(protectedBytes));
+      try {
+        int bufferIdx = 0;
+        for (int frameIdx = 0; frameIdx < frameNum; ++frameIdx) {
+          int unprotectedBytesLeft =
+              (frameIdx == frameNum - 1) ? lastFrameUnprotectedBytes : maxUnprotectedBytesPerFrame;
+          // Write header (at most LIMIT_MAX_ALLOWED_FRAME_BYTES).
+          protectedBuf.writeIntLE(unprotectedBytesLeft + HEADER_TYPE_FIELD_BYTES + suffixBytes);
+          protectedBuf.writeIntLE(HEADER_TYPE_DEFAULT);
+
+          // Ownership of the backing buffer remains with protectedBuf.
+          ByteBuf frameOut = writeSlice(protectedBuf, unprotectedBytesLeft + suffixBytes);
+          List<ByteBuf> framePlain = new ArrayList<>();
+          while (unprotectedBytesLeft > 0) {
+            // Ownership of the buffer backing in remains with unprotectedBufs.
+            ByteBuf in = unprotectedBufs.get(bufferIdx);
+            if (in.readableBytes() <= unprotectedBytesLeft) {
+              // The complete buffer belongs to this frame.
+              framePlain.add(in);
+              unprotectedBytesLeft -= in.readableBytes();
+              bufferIdx++;
+            } else {
+              // The remainder of in will be part of the next frame.
+              framePlain.add(in.readSlice(unprotectedBytesLeft));
+              unprotectedBytesLeft = 0;
+            }
+          }
+          crypter.encrypt(frameOut, framePlain);
+          verify(!frameOut.isWritable());
+        }
+        protectedBuf.readerIndex(0);
+        protectedBuf.writerIndex(protectedBuf.capacity());
+        return protectedBuf.retain();
+      } finally {
+        protectedBuf.release();
+      }
+    }
+  }
+
+  static final class Unprotector {
+    private final int suffixBytes;
+    private final ChannelCrypterNetty crypter;
+
+    private DeframerState state = DeframerState.READ_HEADER;
+    private int requiredProtectedBytes;
+    private ByteBuf header;
+    private ByteBuf firstFrameTag;
+    private int unhandledIdx = 0;
+    private long unhandledBytes = 0;
+    private List<ByteBuf> unhandledBufs = new ArrayList<>(16);
+
+    Unprotector(ChannelCrypterNetty crypter, ByteBufAllocator alloc) {
+      this.crypter = crypter;
+      this.suffixBytes = crypter.getSuffixLength();
+      this.header = alloc.directBuffer(HEADER_BYTES);
+      this.firstFrameTag = alloc.directBuffer(suffixBytes);
+    }
+
+    private void addUnhandled(ByteBuf in) {
+      if (in.isReadable()) {
+        ByteBuf buf = in.readRetainedSlice(in.readableBytes());
+        unhandledBufs.add(buf);
+        unhandledBytes += buf.readableBytes();
+      }
+    }
+
+    void unprotect(ByteBuf in, List<Object> out, ByteBufAllocator alloc)
+        throws GeneralSecurityException {
+      checkState(header != null, "Cannot unprotect after destroy.");
+      addUnhandled(in);
+      decodeFrame(alloc, out);
+    }
+
+    @SuppressWarnings("fallthrough")
+    private void decodeFrame(ByteBufAllocator alloc, List<Object> out)
+        throws GeneralSecurityException {
+      switch (state) {
+        case READ_HEADER:
+          if (unhandledBytes < HEADER_BYTES) {
+            return;
+          }
+          handleHeader();
+          // fall through
+        case READ_PROTECTED_PAYLOAD:
+          if (unhandledBytes < requiredProtectedBytes) {
+            return;
+          }
+          ByteBuf unprotectedBuf;
+          try {
+            unprotectedBuf = handlePayload(alloc);
+          } finally {
+            clearState();
+          }
+          if (unprotectedBuf != null) {
+            out.add(unprotectedBuf);
+          }
+          break;
+        default:
+          throw new AssertionError("impossible enum value");
+      }
+    }
+
+    private void handleHeader() {
+      while (header.isWritable()) {
+        ByteBuf in = unhandledBufs.get(unhandledIdx);
+        int headerBytesToRead = Math.min(in.readableBytes(), header.writableBytes());
+        header.writeBytes(in, headerBytesToRead);
+        unhandledBytes -= headerBytesToRead;
+        if (!in.isReadable()) {
+          unhandledIdx++;
+        }
+      }
+      requiredProtectedBytes = header.readIntLE() - HEADER_TYPE_FIELD_BYTES;
+      checkArgument(
+          requiredProtectedBytes >= suffixBytes, "Invalid header field: frame size too small");
+      checkArgument(
+          requiredProtectedBytes <= LIMIT_MAX_ALLOWED_FRAME_SIZE - HEADER_BYTES,
+          "Invalid header field: frame size too large");
+      int frameType = header.readIntLE();
+      checkArgument(frameType == HEADER_TYPE_DEFAULT, "Invalid header field: frame type");
+      state = DeframerState.READ_PROTECTED_PAYLOAD;
+    }
+
+    private ByteBuf handlePayload(ByteBufAllocator alloc) throws GeneralSecurityException {
+      int requiredCiphertextBytes = requiredProtectedBytes - suffixBytes;
+      int firstFrameUnprotectedLen = requiredCiphertextBytes;
+
+      // We get the ciphertexts of the first frame and copy over the tag into a single buffer.
+      List<ByteBuf> firstFrameCiphertext = new ArrayList<>();
+      while (requiredCiphertextBytes > 0) {
+        ByteBuf buf = unhandledBufs.get(unhandledIdx);
+        if (buf.readableBytes() <= requiredCiphertextBytes) {
+          // We use the whole buffer.
+          firstFrameCiphertext.add(buf);
+          requiredCiphertextBytes -= buf.readableBytes();
+          unhandledIdx++;
+        } else {
+          firstFrameCiphertext.add(buf.readSlice(requiredCiphertextBytes));
+          requiredCiphertextBytes = 0;
+        }
+      }
+      int requiredSuffixBytes = suffixBytes;
+      while (true) {
+        ByteBuf buf = unhandledBufs.get(unhandledIdx);
+        if (buf.readableBytes() <= requiredSuffixBytes) {
+          // We use the whole buffer.
+          requiredSuffixBytes -= buf.readableBytes();
+          firstFrameTag.writeBytes(buf);
+          if (requiredSuffixBytes == 0) {
+            break;
+          }
+          unhandledIdx++;
+        } else {
+          firstFrameTag.writeBytes(buf, requiredSuffixBytes);
+          break;
+        }
+      }
+      verify(unhandledIdx == unhandledBufs.size() - 1);
+      ByteBuf lastBuf = unhandledBufs.get(unhandledIdx);
+
+      // We get the remaining ciphertexts and tags contained in the last buffer.
+      List<ByteBuf> ciphertextsAndTags = new ArrayList<>();
+      List<Integer> unprotectedLens = new ArrayList<>();
+      long requiredUnprotectedBytesCompleteFrames = firstFrameUnprotectedLen;
+      while (lastBuf.readableBytes() >= HEADER_BYTES + suffixBytes) {
+        // Read frame size.
+        int frameSize = lastBuf.readIntLE();
+        int payloadSize = frameSize - HEADER_TYPE_FIELD_BYTES - suffixBytes;
+        // Break and undo read if we don't have the complete frame yet.
+        if (lastBuf.readableBytes() < frameSize) {
+          lastBuf.readerIndex(lastBuf.readerIndex() - HEADER_LEN_FIELD_BYTES);
+          break;
+        }
+        // Check the type header.
+        checkArgument(lastBuf.readIntLE() == 6);
+        // Create a new frame (except for out buffer).
+        ciphertextsAndTags.add(lastBuf.readSlice(payloadSize + suffixBytes));
+        // Update sizes for frame.
+        requiredUnprotectedBytesCompleteFrames += payloadSize;
+        unprotectedLens.add(payloadSize);
+      }
+
+      // We leave space for suffixBytes to allow for in-place encryption. This allows for calling
+      // doFinal in the JCE implementation which can be optimized better than update and doFinal.
+      ByteBuf unprotectedBuf =
+          alloc.directBuffer(
+              Ints.checkedCast(requiredUnprotectedBytesCompleteFrames + suffixBytes));
+      try {
+
+        ByteBuf out = writeSlice(unprotectedBuf, firstFrameUnprotectedLen + suffixBytes);
+        crypter.decrypt(out, firstFrameTag, firstFrameCiphertext);
+        verify(out.writableBytes() == suffixBytes);
+        unprotectedBuf.writerIndex(unprotectedBuf.writerIndex() - suffixBytes);
+
+        for (int frameIdx = 0; frameIdx < ciphertextsAndTags.size(); ++frameIdx) {
+          out = writeSlice(unprotectedBuf, unprotectedLens.get(frameIdx) + suffixBytes);
+          crypter.decrypt(out, ciphertextsAndTags.get(frameIdx));
+          verify(out.writableBytes() == suffixBytes);
+          unprotectedBuf.writerIndex(unprotectedBuf.writerIndex() - suffixBytes);
+        }
+        return unprotectedBuf.retain();
+      } finally {
+        unprotectedBuf.release();
+      }
+    }
+
+    private void clearState() {
+      int bufsSize = unhandledBufs.size();
+      ByteBuf lastBuf = unhandledBufs.get(bufsSize - 1);
+      boolean keepLast = lastBuf.isReadable();
+      for (int bufIdx = 0; bufIdx < (keepLast ? bufsSize - 1 : bufsSize); ++bufIdx) {
+        unhandledBufs.get(bufIdx).release();
+      }
+      unhandledBufs.clear();
+      unhandledBytes = 0;
+      unhandledIdx = 0;
+      if (keepLast) {
+        unhandledBufs.add(lastBuf);
+        unhandledBytes = lastBuf.readableBytes();
+      }
+      state = DeframerState.READ_HEADER;
+      requiredProtectedBytes = 0;
+      header.clear();
+      firstFrameTag.clear();
+    }
+
+    void destroy() {
+      for (ByteBuf unhandledBuf : unhandledBufs) {
+        unhandledBuf.release();
+      }
+      unhandledBufs.clear();
+      if (header != null) {
+        header.release();
+        header = null;
+      }
+      if (firstFrameTag != null) {
+        firstFrameTag.release();
+        firstFrameTag = null;
+      }
+      crypter.destroy();
+    }
+  }
+
+  private enum DeframerState {
+    READ_HEADER,
+    READ_PROTECTED_PAYLOAD
+  }
+
+  private static ByteBuf writeSlice(ByteBuf in, int len) {
+    checkArgument(len <= in.writableBytes());
+    ByteBuf out = in.slice(in.writerIndex(), len);
+    in.writerIndex(in.writerIndex() + len);
+    return out.writerIndex(0);
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AltsTsiHandshaker.java b/alts/src/main/java/io/grpc/alts/internal/AltsTsiHandshaker.java
new file mode 100644
index 00000000000..2d6c322c1b1
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AltsTsiHandshaker.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.alts.internal.HandshakerServiceGrpc.HandshakerServiceStub;
+import io.netty.buffer.ByteBufAllocator;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Negotiates a grpc channel key to be used by the TsiFrameProtector, using ALTs handshaker service.
+ */
+public final class AltsTsiHandshaker implements TsiHandshaker {
+  private final ChannelLogger logger;
+
+  public static final String TSI_SERVICE_ACCOUNT_PEER_PROPERTY = "service_account";
+
+  private final boolean isClient;
+  private final AltsHandshakerClient handshaker;
+
+  private ByteBuffer outputFrame;
+
+  /** Starts a new TSI handshaker with client options. */
+  private AltsTsiHandshaker(
+      boolean isClient,
+      HandshakerServiceStub stub,
+      AltsHandshakerOptions options,
+      ChannelLogger logger) {
+    this.isClient = isClient;
+    this.logger = logger;
+    handshaker = new AltsHandshakerClient(stub, options, logger);
+  }
+
+  @VisibleForTesting
+  AltsTsiHandshaker(boolean isClient, AltsHandshakerClient handshaker, ChannelLogger logger) {
+    this.isClient = isClient;
+    this.handshaker = handshaker;
+    this.logger = logger;
+  }
+
+  /**
+   * Process the bytes received from the peer.
+   *
+   * @param bytes The buffer containing the handshake bytes from the peer.
+   * @return true, if the handshake has all the data it needs to process and false, if the method
+   *     must be called again to complete processing.
+   */
+  @Override
+  public boolean processBytesFromPeer(ByteBuffer bytes) throws GeneralSecurityException {
+    // If we're the client and we haven't given an output frame, we shouldn't be processing any
+    // bytes.
+    if (outputFrame == null && isClient) {
+      return true;
+    }
+    // If we already have bytes to write, just return.
+    if (outputFrame != null && outputFrame.hasRemaining()) {
+      return true;
+    }
+    int remaining = bytes.remaining();
+    // Call handshaker service to process the bytes.
+    if (outputFrame == null) {
+      checkState(!isClient, "Client handshaker should not process any frame at the beginning.");
+      outputFrame = handshaker.startServerHandshake(bytes);
+    } else {
+      logger.log(ChannelLogLevel.DEBUG, "Receive ALTS handshake from downstream");
+      outputFrame = handshaker.next(bytes);
+    }
+    // If handshake has finished or we already have bytes to write, just return true.
+    if (handshaker.isFinished() || outputFrame.hasRemaining()) {
+      return true;
+    }
+    // We have done processing input bytes, but no bytes to write. Thus we need more data.
+    if (!bytes.hasRemaining()) {
+      return false;
+    }
+    // There are still remaining bytes. Thus we need to continue processing the bytes.
+    // Prevent infinite loop by checking some bytes are consumed by handshaker.
+    checkState(bytes.remaining() < remaining, "Handshaker did not consume any bytes.");
+    return processBytesFromPeer(bytes);
+  }
+
+  /**
+   * Returns the peer extracted from a completed handshake.
+   *
+   * @return the extracted peer.
+   */
+  @Override
+  public TsiPeer extractPeer() throws GeneralSecurityException {
+    Preconditions.checkState(!isInProgress(), "Handshake is not complete.");
+    List<TsiPeer.Property<?>> peerProperties = new ArrayList<>();
+    peerProperties.add(
+        new TsiPeer.StringProperty(
+            TSI_SERVICE_ACCOUNT_PEER_PROPERTY,
+            handshaker.getResult().getPeerIdentity().getServiceAccount()));
+    return new TsiPeer(peerProperties);
+  }
+
+  /**
+   * Returns the peer extracted from a completed handshake.
+   *
+   * @return the extracted peer.
+   */
+  @Override
+  public Object extractPeerObject() throws GeneralSecurityException {
+    Preconditions.checkState(!isInProgress(), "Handshake is not complete.");
+    return new AltsInternalContext(handshaker.getResult());
+  }
+
+  /** Creates a new TsiHandshaker for use by the client. */
+  public static TsiHandshaker newClient(
+      HandshakerServiceStub stub, AltsHandshakerOptions options, ChannelLogger logger) {
+    return new AltsTsiHandshaker(true, stub, options, logger);
+  }
+
+  /** Creates a new TsiHandshaker for use by the server. */
+  public static TsiHandshaker newServer(
+      HandshakerServiceStub stub, AltsHandshakerOptions options, ChannelLogger logger) {
+    return new AltsTsiHandshaker(false, stub, options, logger);
+  }
+
+  /**
+   * Gets bytes that need to be sent to the peer.
+   *
+   * @param bytes The buffer to put handshake bytes.
+   */
+  @Override
+  public void getBytesToSendToPeer(ByteBuffer bytes) throws GeneralSecurityException {
+    if (outputFrame == null) { // A null outputFrame indicates we haven't started the handshake.
+      if (isClient) {
+        logger.log(ChannelLogLevel.DEBUG, "Initial ALTS handshake to downstream");
+        outputFrame = handshaker.startClientHandshake();
+      } else {
+        // The server needs bytes to process before it can start the handshake.
+        return;
+      }
+    }
+    logger.log(ChannelLogLevel.DEBUG, "Send ALTS request to downstream");
+    // Write as many bytes as we are able.
+    ByteBuffer outputFrameAlias = outputFrame;
+    if (outputFrame.remaining() > bytes.remaining()) {
+      outputFrameAlias = outputFrame.duplicate();
+      ((Buffer) outputFrameAlias).limit(outputFrameAlias.position() + bytes.remaining());
+    }
+    bytes.put(outputFrameAlias);
+    ((Buffer) outputFrame).position(outputFrameAlias.position());
+  }
+
+  /**
+   * Returns true if and only if the handshake is still in progress.
+   *
+   * @return true, if the handshake is still in progress, false otherwise.
+   */
+  @Override
+  public boolean isInProgress() {
+    return !handshaker.isFinished() || outputFrame.hasRemaining();
+  }
+
+  /**
+   * Creates a frame protector from a completed handshake. No other methods may be called after the
+   * frame protector is created.
+   *
+   * @param maxFrameSize the requested max frame size, the callee is free to ignore.
+   * @param alloc used for allocating ByteBufs.
+   * @return a new TsiFrameProtector.
+   */
+  @Override
+  public TsiFrameProtector createFrameProtector(int maxFrameSize, ByteBufAllocator alloc) {
+    Preconditions.checkState(!isInProgress(), "Handshake is not complete.");
+
+    byte[] key = handshaker.getKey();
+    Preconditions.checkState(key.length == AltsChannelCrypter.getKeyLength(), "Bad key length.");
+
+    // Frame size negotiation is not performed if the peer does not send max frame size (e.g. peer
+    // is gRPC Go or peer uses an old binary).
+    int peerMaxFrameSize = handshaker.getResult().getMaxFrameSize();
+    if (peerMaxFrameSize != 0) {
+      maxFrameSize = Math.min(peerMaxFrameSize, AltsTsiFrameProtector.getMaxFrameSize());
+      maxFrameSize = Math.max(AltsTsiFrameProtector.getMinFrameSize(), maxFrameSize);
+    }
+    logger.log(ChannelLogLevel.INFO, "Maximum frame size value is {0}.", maxFrameSize);
+    return new AltsTsiFrameProtector(maxFrameSize, new AltsChannelCrypter(key, isClient), alloc);
+  }
+
+  /**
+   * Creates a frame protector from a completed handshake. No other methods may be called after the
+   * frame protector is created.
+   *
+   * @param alloc used for allocating ByteBufs.
+   * @return a new TsiFrameProtector.
+   */
+  @Override
+  public TsiFrameProtector createFrameProtector(ByteBufAllocator alloc) {
+    return createFrameProtector(AltsTsiFrameProtector.getMinFrameSize(), alloc);
+  }
+
+  @Override
+  public void close() {
+    handshaker.close();
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/AsyncSemaphore.java b/alts/src/main/java/io/grpc/alts/internal/AsyncSemaphore.java
new file mode 100644
index 00000000000..a8251c7fbd3
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/AsyncSemaphore.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2021 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.alts.internal;
+
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import java.util.LinkedList;
+import java.util.Queue;
+
+/** Provides a semaphore primitive, without blocking waiting on permits. */
+final class AsyncSemaphore {
+  private final Object lock = new Object();
+  @SuppressWarnings("JdkObsolete") // LinkedList avoids high watermark memory issues
+  private final Queue<ChannelPromise> queue = new LinkedList<>();
+  @GuardedBy("lock")
+  private int permits;
+
+  public AsyncSemaphore(int permits) {
+    this.permits = permits;
+  }
+
+  public ChannelFuture acquire(ChannelHandlerContext ctx) {
+    synchronized (lock) {
+      if (permits > 0) {
+        permits--;
+        return ctx.newSucceededFuture();
+      }
+      ChannelPromise promise = ctx.newPromise();
+      queue.add(promise);
+      return promise;
+    }
+  }
+
+  public void release() {
+    ChannelPromise next;
+    synchronized (lock) {
+      next = queue.poll();
+      if (next == null) {
+        permits++;
+        return;
+      }
+    }
+    next.setSuccess();
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/BufUnwrapper.java b/alts/src/main/java/io/grpc/alts/internal/BufUnwrapper.java
new file mode 100644
index 00000000000..9934dd2ff55
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/BufUnwrapper.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.CompositeByteBuf;
+import java.nio.ByteBuffer;
+
+/** Unwraps {@link ByteBuf}s into {@link ByteBuffer}s. */
+final class BufUnwrapper implements AutoCloseable {
+
+  private final ByteBuffer[] singleReadBuffer = new ByteBuffer[1];
+  private final ByteBuffer[] singleWriteBuffer = new ByteBuffer[1];
+
+  /**
+   * Called to get access to the underlying NIO buffers for a {@link ByteBuf} that will be used for
+   * writing.
+   */
+  ByteBuffer[] writableNioBuffers(ByteBuf buf) {
+    // Set the writer index to the capacity to guarantee that the returned NIO buffers will have
+    // the capacity available.
+    int readerIndex = buf.readerIndex();
+    int writerIndex = buf.writerIndex();
+    buf.readerIndex(writerIndex);
+    buf.writerIndex(buf.capacity());
+
+    try {
+      return nioBuffers(buf, singleWriteBuffer);
+    } finally {
+      // Restore the writer index before returning.
+      buf.readerIndex(readerIndex);
+      buf.writerIndex(writerIndex);
+    }
+  }
+
+  /**
+   * Called to get access to the underlying NIO buffers for a {@link ByteBuf} that will be used for
+   * reading.
+   */
+  ByteBuffer[] readableNioBuffers(ByteBuf buf) {
+    return nioBuffers(buf, singleReadBuffer);
+  }
+
+  @Override
+  public void close() {
+    singleReadBuffer[0] = null;
+    singleWriteBuffer[0] = null;
+  }
+
+  /**
+   * Optimized accessor for obtaining the underlying NIO buffers for a Netty {@link ByteBuf}. Based
+   * on code from Netty's {@code SslHandler}. This method returns NIO buffers that span the readable
+   * region of the {@link ByteBuf}.
+   */
+  private static ByteBuffer[] nioBuffers(ByteBuf buf, ByteBuffer[] singleBuffer) {
+    // As CompositeByteBuf.nioBufferCount() can be expensive (as it needs to check all composed
+    // ByteBuf to calculate the count) we will just assume a CompositeByteBuf contains more than 1
+    // ByteBuf. The worst that can happen is that we allocate an extra ByteBuffer[] in
+    // CompositeByteBuf.nioBuffers() which is better than walking the composed ByteBuf in most
+    // cases.
+    if (!(buf instanceof CompositeByteBuf) && buf.nioBufferCount() == 1) {
+      // We know its only backed by 1 ByteBuffer so use internalNioBuffer to keep object
+      // allocation to a minimum.
+      singleBuffer[0] = buf.internalNioBuffer(buf.readerIndex(), buf.readableBytes());
+      return singleBuffer;
+    }
+
+    return buf.nioBuffers();
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/ChannelCrypterNetty.java b/alts/src/main/java/io/grpc/alts/internal/ChannelCrypterNetty.java
new file mode 100644
index 00000000000..e2e7d4046fb
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/ChannelCrypterNetty.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import io.netty.buffer.ByteBuf;
+import java.security.GeneralSecurityException;
+import java.util.List;
+
+/**
+ * A {@code ChannelCrypterNetty} performs stateful encryption and decryption of independent input
+ * and output streams. Both decrypt and encrypt gather their input from a list of Netty {@link
+ * ByteBuf} instances.
+ *
+ * <p>Note that we provide implementations of this interface that provide integrity only and
+ * implementations that provide privacy and integrity. All methods should be thread-compatible.
+ */
+public interface ChannelCrypterNetty {
+
+  /**
+   * Encrypt plaintext into output buffer.
+   *
+   * @param out the protected input will be written into this buffer. The buffer must be direct and
+   *     have enough space to hold all input buffers and the tag. Encrypt does not take ownership of
+   *     this buffer.
+   * @param plain the input buffers that should be protected. Encrypt does not modify or take
+   *     ownership of these buffers.
+   */
+  void encrypt(ByteBuf out, List<ByteBuf> plain) throws GeneralSecurityException;
+
+  /**
+   * Decrypt ciphertext into the given output buffer and check tag.
+   *
+   * @param out the unprotected input will be written into this buffer. The buffer must be direct
+   *     and have enough space to hold all ciphertext buffers and the tag, i.e., it must have
+   *     additional space for the tag, even though this space will be unused in the final result.
+   *     Decrypt does not take ownership of this buffer.
+   * @param tag the tag appended to the ciphertext. Decrypt does not modify or take ownership of
+   *     this buffer.
+   * @param ciphertext the buffers that should be unprotected (excluding the tag). Decrypt does not
+   *     modify or take ownership of these buffers.
+   */
+  void decrypt(ByteBuf out, ByteBuf tag, List<ByteBuf> ciphertext) throws GeneralSecurityException;
+
+  /**
+   * Decrypt ciphertext into the given output buffer and check tag.
+   *
+   * @param out the unprotected input will be written into this buffer. The buffer must be direct
+   *     and have enough space to hold all ciphertext buffers and the tag, i.e., it must have
+   *     additional space for the tag, even though this space will be unused in the final result.
+   *     Decrypt does not take ownership of this buffer.
+   * @param ciphertextAndTag single buffer containing ciphertext and tag that should be unprotected.
+   *     The buffer must be direct and either completely overlap with {@code out} or not overlap at
+   *     all.
+   */
+  void decrypt(ByteBuf out, ByteBuf ciphertextAndTag) throws GeneralSecurityException;
+
+  /** Returns the length of the tag in bytes. */
+  int getSuffixLength();
+
+  /** Must be called to release all associated resources (instance cannot be used afterwards). */
+  void destroy();
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/NettyTsiHandshaker.java b/alts/src/main/java/io/grpc/alts/internal/NettyTsiHandshaker.java
new file mode 100644
index 00000000000..b91cfdad08c
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/NettyTsiHandshaker.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+
+/**
+ * A wrapper for a {@link io.grpc.alts.internal.TsiHandshaker} that accepts netty {@link ByteBuf}s.
+ */
+public final class NettyTsiHandshaker {
+
+  private BufUnwrapper unwrapper = new BufUnwrapper();
+  private final TsiHandshaker internalHandshaker;
+
+  public NettyTsiHandshaker(TsiHandshaker handshaker) {
+    internalHandshaker = checkNotNull(handshaker);
+  }
+
+  /**
+   * Gets data that is ready to be sent to the to the remote peer. This should be called in a loop
+   * until no bytes are written to the output buffer.
+   *
+   * @param out the buffer to receive the bytes.
+   */
+  void getBytesToSendToPeer(ByteBuf out) throws GeneralSecurityException {
+    checkState(unwrapper != null, "protector already created");
+    try (BufUnwrapper unwrapper = this.unwrapper) {
+      // Write as many bytes as possible into the buffer.
+      int bytesWritten = 0;
+      for (ByteBuffer nioBuffer : unwrapper.writableNioBuffers(out)) {
+        if (!nioBuffer.hasRemaining()) {
+          // This buffer doesn't have any more space to write, go to the next buffer.
+          continue;
+        }
+
+        int prevPos = nioBuffer.position();
+        internalHandshaker.getBytesToSendToPeer(nioBuffer);
+        bytesWritten += nioBuffer.position() - prevPos;
+
+        // If the buffer position was not changed, the frame has been completely read into the
+        // buffers.
+        if (nioBuffer.position() == prevPos) {
+          break;
+        }
+      }
+
+      out.writerIndex(out.writerIndex() + bytesWritten);
+    }
+  }
+
+  /**
+   * Process handshake data received from the remote peer.
+   *
+   * @return {@code true}, if the handshake has all the data it needs to process and {@code false},
+   *     if the method must be called again to complete processing.
+   */
+  boolean processBytesFromPeer(ByteBuf data) throws GeneralSecurityException {
+    checkState(unwrapper != null, "protector already created");
+    try (BufUnwrapper unwrapper = this.unwrapper) {
+      int bytesRead = 0;
+      boolean done = false;
+      for (ByteBuffer nioBuffer : unwrapper.readableNioBuffers(data)) {
+        if (!nioBuffer.hasRemaining()) {
+          // This buffer has been fully read, continue to the next buffer.
+          continue;
+        }
+
+        int prevPos = nioBuffer.position();
+        done = internalHandshaker.processBytesFromPeer(nioBuffer);
+        bytesRead += nioBuffer.position() - prevPos;
+        if (done) {
+          break;
+        }
+      }
+
+      data.readerIndex(data.readerIndex() + bytesRead);
+      return done;
+    }
+  }
+
+  /**
+   * Returns true if and only if the handshake is still in progress.
+   *
+   * @return true, if the handshake is still in progress, false otherwise.
+   */
+  boolean isInProgress() {
+    return internalHandshaker.isInProgress();
+  }
+
+  /**
+   * Returns the peer extracted from a completed handshake.
+   *
+   * @return the extracted peer.
+   */
+  TsiPeer extractPeer() throws GeneralSecurityException {
+    checkState(!internalHandshaker.isInProgress());
+    return internalHandshaker.extractPeer();
+  }
+
+  /**
+   * Returns the peer extracted from a completed handshake.
+   *
+   * @return the extracted peer.
+   */
+  Object extractPeerObject() throws GeneralSecurityException {
+    checkState(!internalHandshaker.isInProgress());
+    return internalHandshaker.extractPeerObject();
+  }
+
+  /**
+   * Creates a frame protector from a completed handshake. No other methods may be called after the
+   * frame protector is created.
+   *
+   * @param maxFrameSize the requested max frame size, the callee is free to ignore.
+   * @return a new {@link io.grpc.alts.internal.TsiFrameProtector}.
+   */
+  TsiFrameProtector createFrameProtector(int maxFrameSize, ByteBufAllocator alloc) {
+    unwrapper = null;
+    return internalHandshaker.createFrameProtector(maxFrameSize, alloc);
+  }
+
+  /**
+   * Creates a frame protector from a completed handshake. No other methods may be called after the
+   * frame protector is created.
+   *
+   * @return a new {@link io.grpc.alts.internal.TsiFrameProtector}.
+   */
+  TsiFrameProtector createFrameProtector(ByteBufAllocator alloc) {
+    unwrapper = null;
+    return internalHandshaker.createFrameProtector(alloc);
+  }
+
+  void close() {
+    internalHandshaker.close();
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/ProtectedPromise.java b/alts/src/main/java/io/grpc/alts/internal/ProtectedPromise.java
new file mode 100644
index 00000000000..871a51f1bea
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/ProtectedPromise.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.base.Preconditions.checkState;
+
+import io.grpc.Internal;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.DefaultChannelPromise;
+import io.netty.util.concurrent.EventExecutor;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Promise used when flushing the {@code pendingUnprotectedWrites} queue. It manages the many-to
+ * many relationship between pending unprotected messages and the individual writes. Each protected
+ * frame will be written using the same instance of this promise and it will accumulate the results.
+ * Once all frames have been successfully written (or any failed), all of the promises for the
+ * pending unprotected writes are notified.
+ *
+ * <p>NOTE: this code is based on code in Netty's {@code Http2CodecUtil}.
+ */
+@Internal
+public final class ProtectedPromise extends DefaultChannelPromise {
+  private final List<ChannelPromise> unprotectedPromises;
+  private int expectedCount;
+  private int successfulCount;
+  private int failureCount;
+  private boolean doneAllocating;
+
+  public ProtectedPromise(Channel channel, EventExecutor executor, int numUnprotectedPromises) {
+    super(channel, executor);
+    unprotectedPromises = new ArrayList<>(numUnprotectedPromises);
+  }
+
+  /**
+   * Adds a promise for a pending unprotected write. This will be notified after all of the writes
+   * complete.
+   */
+  public void addUnprotectedPromise(ChannelPromise promise) {
+    unprotectedPromises.add(promise);
+  }
+
+  /**
+   * Allocate a new promise for the write of a protected frame. This will be used to aggregate the
+   * overall success of the unprotected promises.
+   *
+   * @return {@code this} promise.
+   */
+  public ChannelPromise newPromise() {
+    checkState(!doneAllocating, "Done allocating. No more promises can be allocated.");
+    expectedCount++;
+    return this;
+  }
+
+  /**
+   * Signify that no more {@link #newPromise()} allocations will be made. The aggregation can not be
+   * successful until this method is called.
+   *
+   * @return {@code this} promise.
+   */
+  public ChannelPromise doneAllocatingPromises() {
+    if (!doneAllocating) {
+      doneAllocating = true;
+      if (successfulCount == expectedCount) {
+        trySuccessInternal();
+        return super.setSuccess(null);
+      }
+    }
+    return this;
+  }
+
+  @Override
+  public boolean tryFailure(Throwable cause) {
+    if (awaitingPromises()) {
+      ++failureCount;
+      if (failureCount == 1) {
+        tryFailureInternal(cause);
+        return super.tryFailure(cause);
+      }
+      // TODO: We break the interface a bit here.
+      // Multiple failure events can be processed without issue because this is an aggregation.
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Fail this object if it has not already been failed.
+   *
+   * <p>This method will NOT throw an {@link IllegalStateException} if called multiple times because
+   * that may be expected.
+   */
+  @Override
+  public ChannelPromise setFailure(Throwable cause) {
+    tryFailure(cause);
+    return this;
+  }
+
+  private boolean awaitingPromises() {
+    return successfulCount + failureCount < expectedCount;
+  }
+
+  @Override
+  public ChannelPromise setSuccess(Void unused) {
+    trySuccess(null);
+    return this;
+  }
+
+  @Override
+  public boolean trySuccess(Void unused) {
+    if (awaitingPromises()) {
+      ++successfulCount;
+      if (successfulCount == expectedCount && doneAllocating) {
+        trySuccessInternal();
+        return super.trySuccess(null);
+      }
+      // TODO: We break the interface a bit here.
+      // Multiple success events can be processed without issue because this is an aggregation.
+      return true;
+    }
+    return false;
+  }
+
+  private void trySuccessInternal() {
+    for (int i = 0; i < unprotectedPromises.size(); ++i) {
+      unprotectedPromises.get(i).trySuccess(null);
+    }
+  }
+
+  private void tryFailureInternal(Throwable cause) {
+    for (int i = 0; i < unprotectedPromises.size(); ++i) {
+      unprotectedPromises.get(i).tryFailure(cause);
+    }
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/RpcProtocolVersionsUtil.java b/alts/src/main/java/io/grpc/alts/internal/RpcProtocolVersionsUtil.java
new file mode 100644
index 00000000000..005065b4e2e
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/RpcProtocolVersionsUtil.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.alts.internal.RpcProtocolVersions.Version;
+import javax.annotation.Nullable;
+
+/** Utility class for Rpc Protocol Versions. */
+public final class RpcProtocolVersionsUtil {
+
+  private static final int MAX_RPC_VERSION_MAJOR = 2;
+  private static final int MAX_RPC_VERSION_MINOR = 1;
+  private static final int MIN_RPC_VERSION_MAJOR = 2;
+  private static final int MIN_RPC_VERSION_MINOR = 1;
+  private static final RpcProtocolVersions RPC_PROTOCOL_VERSIONS =
+      RpcProtocolVersions.newBuilder()
+          .setMaxRpcVersion(
+              RpcProtocolVersions.Version.newBuilder()
+                  .setMajor(MAX_RPC_VERSION_MAJOR)
+                  .setMinor(MAX_RPC_VERSION_MINOR)
+                  .build())
+          .setMinRpcVersion(
+              RpcProtocolVersions.Version.newBuilder()
+                  .setMajor(MIN_RPC_VERSION_MAJOR)
+                  .setMinor(MIN_RPC_VERSION_MINOR)
+                  .build())
+          .build();
+
+  /** Returns default Rpc Protocol Versions. */
+  public static RpcProtocolVersions getRpcProtocolVersions() {
+    return RPC_PROTOCOL_VERSIONS;
+  }
+
+  /**
+   * Returns true if first Rpc Protocol Version is greater than or equal to the second one. Returns
+   * false otherwise.
+   */
+  @VisibleForTesting
+  static boolean isGreaterThanOrEqualTo(Version first, Version second) {
+    if ((first.getMajor() > second.getMajor())
+        || (first.getMajor() == second.getMajor() && first.getMinor() >= second.getMinor())) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Performs check between local and peer Rpc Protocol Versions. This function returns true and the
+   * highest common version if there exists a common Rpc Protocol Version to use, and returns false
+   * and null otherwise.
+   */
+  static RpcVersionsCheckResult checkRpcProtocolVersions(
+      RpcProtocolVersions localVersions, RpcProtocolVersions peerVersions) {
+    Version maxCommonVersion;
+    Version minCommonVersion;
+    // maxCommonVersion is MIN(local.max, peer.max)
+    if (isGreaterThanOrEqualTo(localVersions.getMaxRpcVersion(), peerVersions.getMaxRpcVersion())) {
+      maxCommonVersion = peerVersions.getMaxRpcVersion();
+    } else {
+      maxCommonVersion = localVersions.getMaxRpcVersion();
+    }
+    // minCommonVersion is MAX(local.min, peer.min)
+    if (isGreaterThanOrEqualTo(localVersions.getMinRpcVersion(), peerVersions.getMinRpcVersion())) {
+      minCommonVersion = localVersions.getMinRpcVersion();
+    } else {
+      minCommonVersion = peerVersions.getMinRpcVersion();
+    }
+    if (isGreaterThanOrEqualTo(maxCommonVersion, minCommonVersion)) {
+      return new RpcVersionsCheckResult.Builder()
+          .setResult(true)
+          .setHighestCommonVersion(maxCommonVersion)
+          .build();
+    }
+    return new RpcVersionsCheckResult.Builder().setResult(false).build();
+  }
+
+  /** Wrapper class that stores results of Rpc Protocol Versions check. */
+  static final class RpcVersionsCheckResult {
+    private final boolean result;
+    @Nullable private final Version highestCommonVersion;
+
+    private RpcVersionsCheckResult(Builder builder) {
+      result = builder.result;
+      highestCommonVersion = builder.highestCommonVersion;
+    }
+
+    boolean getResult() {
+      return result;
+    }
+
+    Version getHighestCommonVersion() {
+      return highestCommonVersion;
+    }
+
+    static final class Builder {
+      private boolean result;
+      @Nullable private Version highestCommonVersion = null;
+
+      public Builder setResult(boolean result) {
+        this.result = result;
+        return this;
+      }
+
+      public Builder setHighestCommonVersion(Version highestCommonVersion) {
+        this.highestCommonVersion = highestCommonVersion;
+        return this;
+      }
+
+      public RpcVersionsCheckResult build() {
+        return new RpcVersionsCheckResult(this);
+      }
+    }
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/TsiFrameHandler.java b/alts/src/main/java/io/grpc/alts/internal/TsiFrameHandler.java
new file mode 100644
index 00000000000..2294d7a07e6
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/TsiFrameHandler.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import io.grpc.alts.internal.TsiFrameProtector.Consumer;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelException;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelOutboundHandler;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.PendingWriteQueue;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import java.net.SocketAddress;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Encrypts and decrypts TSI Frames. Writes are buffered here until {@link #flush} is called. Writes
+ * must not be made before the TSI handshake is complete.
+ */
+public final class TsiFrameHandler extends ByteToMessageDecoder implements ChannelOutboundHandler {
+
+  private static final Logger logger = Logger.getLogger(TsiFrameHandler.class.getName());
+
+  private TsiFrameProtector protector;
+  private PendingWriteQueue pendingUnprotectedWrites;
+  private boolean closeInitiated;
+
+  public TsiFrameHandler(TsiFrameProtector protector) {
+    this.protector = checkNotNull(protector, "protector");
+  }
+
+  @Override
+  public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+    super.handlerAdded(ctx);
+    assert pendingUnprotectedWrites == null;
+    pendingUnprotectedWrites = new PendingWriteQueue(checkNotNull(ctx));
+  }
+
+  @Override
+  protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
+    checkState(protector != null, "decode() called after close()");
+    protector.unprotect(in, out, ctx.alloc());
+  }
+
+  @Override
+  @SuppressWarnings("FutureReturnValueIgnored") // for setSuccess
+  public void write(ChannelHandlerContext ctx, Object message, ChannelPromise promise) {
+    if (protector == null) {
+      promise.setFailure(new IllegalStateException("write() called after close()"));
+      return;
+    }
+    ByteBuf msg = (ByteBuf) message;
+    if (!msg.isReadable()) {
+      // Nothing to encode.
+      promise.setSuccess();
+      return;
+    }
+
+    // Just add the message to the pending queue. We'll write it on the next flush.
+    pendingUnprotectedWrites.add(msg, promise);
+  }
+
+  @Override
+  public void handlerRemoved0(ChannelHandlerContext ctx) throws Exception {
+    destroyProtectorAndWrites();
+  }
+
+  @Override
+  public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) {
+    doClose(ctx);
+    ctx.disconnect(promise);
+  }
+
+  @Override
+  public void close(ChannelHandlerContext ctx, ChannelPromise promise) {
+    doClose(ctx);
+    ctx.close(promise);
+  }
+
+  private void doClose(ChannelHandlerContext ctx) {
+    if (closeInitiated) {
+      return;
+    }
+    closeInitiated = true;
+    try {
+      // flush any remaining writes before close
+      if (!pendingUnprotectedWrites.isEmpty()) {
+        flush(ctx);
+      }
+    } catch (GeneralSecurityException e) {
+      logger.log(Level.FINE, "Ignored error on flush before close", e);
+    } finally {
+      destroyProtectorAndWrites();
+    }
+  }
+
+  @Override
+  @SuppressWarnings("FutureReturnValueIgnored") // for aggregatePromise.doneAllocatingPromises
+  public void flush(final ChannelHandlerContext ctx) throws GeneralSecurityException {
+    if (pendingUnprotectedWrites == null || pendingUnprotectedWrites.isEmpty()) {
+      // Return early if there's nothing to write. Otherwise protector.protectFlush() below may
+      // not check for "no-data" and go on writing the 0-byte "data" to the socket with the
+      // protection framing.
+      return;
+    }
+    // Flushes can happen after close, but only when there are no pending writes.
+    checkState(protector != null, "flush() called after close()");
+    final ProtectedPromise aggregatePromise =
+        new ProtectedPromise(ctx.channel(), ctx.executor(), pendingUnprotectedWrites.size());
+    List<ByteBuf> bufs = new ArrayList<>(pendingUnprotectedWrites.size());
+
+    // Drain the unprotected writes.
+    while (!pendingUnprotectedWrites.isEmpty()) {
+      ByteBuf in = (ByteBuf) pendingUnprotectedWrites.current();
+      bufs.add(in.retain());
+      // Remove and release the buffer and add its promise to the aggregate.
+      aggregatePromise.addUnprotectedPromise(pendingUnprotectedWrites.remove());
+    }
+
+    final class ProtectedFrameWriteFlusher implements Consumer<ByteBuf> {
+
+      @Override
+      public void accept(ByteBuf byteBuf) {
+        ctx.writeAndFlush(byteBuf, aggregatePromise.newPromise());
+      }
+    }
+
+    protector.protectFlush(bufs, new ProtectedFrameWriteFlusher(), ctx.alloc());
+    // We're done writing, start the flow of promise events.
+    aggregatePromise.doneAllocatingPromises();
+  }
+
+  // Only here to fulfill ChannelOutboundHandler
+  @Override
+  public void bind(ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise) {
+    ctx.bind(localAddress, promise);
+  }
+
+  // Only here to fulfill ChannelOutboundHandler
+  @Override
+  public void connect(
+      ChannelHandlerContext ctx,
+      SocketAddress remoteAddress,
+      SocketAddress localAddress,
+      ChannelPromise promise) {
+    ctx.connect(remoteAddress, localAddress, promise);
+  }
+
+  // Only here to fulfill ChannelOutboundHandler
+  @Override
+  public void deregister(ChannelHandlerContext ctx, ChannelPromise promise) {
+    ctx.deregister(promise);
+  }
+
+  // Only here to fulfill ChannelOutboundHandler
+  @Override
+  public void read(ChannelHandlerContext ctx) {
+    ctx.read();
+  }
+
+  private void destroyProtectorAndWrites() {
+    try {
+      if (pendingUnprotectedWrites != null && !pendingUnprotectedWrites.isEmpty()) {
+        pendingUnprotectedWrites.removeAndFailAll(
+            new ChannelException("Pending write on teardown of TSI handler"));
+      }
+    } finally {
+      pendingUnprotectedWrites = null;
+    }
+    if (protector != null) {
+      try {
+        protector.destroy();
+      } finally {
+        protector = null;
+      }
+    }
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/TsiFrameProtector.java b/alts/src/main/java/io/grpc/alts/internal/TsiFrameProtector.java
new file mode 100644
index 00000000000..b4227989ef2
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/TsiFrameProtector.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import java.security.GeneralSecurityException;
+import java.util.List;
+
+/**
+ * This object protects and unprotects netty buffers once the handshake is done.
+ *
+ * <p>Implementations of this object must be thread compatible.
+ */
+public interface TsiFrameProtector {
+
+  /**
+   * Protects the buffers by performing framing and encrypting/appending MACs.
+   *
+   * @param unprotectedBufs contain the payload that will be protected
+   * @param ctxWrite is called with buffers containing protected frames and must release the given
+   *     buffers
+   * @param alloc is used to allocate new buffers for the protected frames
+   */
+  void protectFlush(
+      List<ByteBuf> unprotectedBufs, Consumer<ByteBuf> ctxWrite, ByteBufAllocator alloc)
+      throws GeneralSecurityException;
+
+  /**
+   * Unprotects the buffers by removing the framing and decrypting/checking MACs.
+   *
+   * @param in contains (partial) protected frames
+   * @param out is only used to append unprotected payload buffers
+   * @param alloc is used to allocate new buffers for the unprotected frames
+   */
+  void unprotect(ByteBuf in, List<Object> out, ByteBufAllocator alloc)
+      throws GeneralSecurityException;
+
+  /** Must be called to release all associated resources (instance cannot be used afterwards). */
+  void destroy();
+
+  /** A mirror of java.util.function.Consumer without the Java 8 dependency. */
+  interface Consumer<T> {
+    void accept(T t);
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/TsiHandshakeHandler.java b/alts/src/main/java/io/grpc/alts/internal/TsiHandshakeHandler.java
new file mode 100644
index 00000000000..7964b122f8c
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/TsiHandshakeHandler.java
@@ -0,0 +1,250 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.alts.internal.AltsProtocolNegotiator.AUTH_CONTEXT_KEY;
+import static io.grpc.alts.internal.AltsProtocolNegotiator.TSI_PEER_KEY;
+
+import io.grpc.Attributes;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.InternalChannelz.Security;
+import io.grpc.SecurityLevel;
+import io.grpc.alts.internal.TsiHandshakeHandler.HandshakeValidator.SecurityDetails;
+import io.grpc.internal.GrpcAttributes;
+import io.grpc.netty.InternalProtocolNegotiationEvent;
+import io.grpc.netty.ProtocolNegotiationEvent;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import java.security.GeneralSecurityException;
+import java.util.List;
+import javax.annotation.Nullable;
+
+/**
+ * Performs The TSI Handshake.
+ */
+public final class TsiHandshakeHandler extends ByteToMessageDecoder {
+  /**
+   * Validates a Tsi Peer object.
+   */
+  public abstract static class HandshakeValidator {
+
+    public static final class SecurityDetails {
+
+      private final SecurityLevel securityLevel;
+      private final Security security;
+
+      /**
+       * Constructs SecurityDetails.
+       */
+      public SecurityDetails(io.grpc.SecurityLevel securityLevel, @Nullable Security security) {
+        this.securityLevel = checkNotNull(securityLevel, "securityLevel");
+        this.security = security;
+      }
+
+      public Security getSecurity() {
+        return security;
+      }
+
+      public SecurityLevel getSecurityLevel() {
+        return securityLevel;
+      }
+    }
+
+    /**
+     * Validates a Tsi Peer object.
+     */
+    public abstract SecurityDetails validatePeerObject(Object peerObject)
+        throws GeneralSecurityException;
+  }
+
+  private static final int HANDSHAKE_FRAME_SIZE = 1024;
+
+  private final NettyTsiHandshaker handshaker;
+  private final HandshakeValidator handshakeValidator;
+  private final ChannelHandler next;
+  private final AsyncSemaphore semaphore;
+
+  private ProtocolNegotiationEvent pne;
+  private boolean semaphoreAcquired;
+  private final ChannelLogger negotiationLogger;
+
+  /**
+   * Constructs a TsiHandshakeHandler.
+   */
+  public TsiHandshakeHandler(
+      ChannelHandler next, NettyTsiHandshaker handshaker, HandshakeValidator handshakeValidator,
+      ChannelLogger negotiationLogger) {
+    this(next, handshaker, handshakeValidator, null, negotiationLogger);
+  }
+
+  /**
+   * Constructs a TsHandshakeHandler. If a semaphore is provided, a permit from the semaphore is
+   * required to start the handshake and is returned when the handshake ends.
+   */
+  public TsiHandshakeHandler(
+      ChannelHandler next, NettyTsiHandshaker handshaker, HandshakeValidator handshakeValidator,
+      AsyncSemaphore semaphore, ChannelLogger negotiationLogger) {
+    this.handshaker = checkNotNull(handshaker, "handshaker");
+    this.handshakeValidator = checkNotNull(handshakeValidator, "handshakeValidator");
+    this.next = checkNotNull(next, "next");
+    this.semaphore = semaphore;
+    this.negotiationLogger = negotiationLogger;
+  }
+
+  @Override
+  protected void decodeLast(ChannelHandlerContext ctx, ByteBuf in, List<Object> out)
+      throws Exception {
+    // TODO: Not sure why override is needed. Investigate if it can be removed.
+    decode(ctx, in, out);
+  }
+
+  @Override
+  protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
+    // Process the data. If we need to send more data, do so now.
+    if (handshaker.processBytesFromPeer(in) && handshaker.isInProgress()) {
+      sendHandshake(ctx);
+    }
+
+    // If the handshake is complete, transition to the framing state.
+    if (!handshaker.isInProgress()) {
+      TsiPeer peer = handshaker.extractPeer();
+      Object authContext = handshaker.extractPeerObject();
+      SecurityDetails details = handshakeValidator.validatePeerObject(authContext);
+      // createFrameProtector must be called last.
+      TsiFrameProtector protector = handshaker.createFrameProtector(ctx.alloc());
+      TsiFrameHandler framer;
+      boolean success = false;
+      try {
+        framer = new TsiFrameHandler(protector);
+        // adding framer and next handler after this handler before removing Decoder (current
+        // handler). This will prevents any missing read from decoder and/or unframed write from
+        // next handler.
+        ctx.pipeline().addAfter(ctx.name(), null, framer);
+        ctx.pipeline().addAfter(ctx.pipeline().context(framer).name(), null, next);
+        ctx.pipeline().remove(ctx.name());
+        fireProtocolNegotiationEvent(ctx, peer, authContext, details);
+        success = true;
+      } finally {
+        if (!success && protector != null) {
+          protector.destroy();
+        }
+      }
+    }
+  }
+
+  @Override
+  public void userEventTriggered(final ChannelHandlerContext ctx, Object evt) throws Exception {
+    if (evt instanceof ProtocolNegotiationEvent) {
+      checkState(pne == null, "negotiation already started");
+      pne = (ProtocolNegotiationEvent) evt;
+      negotiationLogger.log(ChannelLogLevel.INFO, "TsiHandshake started");
+      ChannelFuture acquire = semaphoreAcquire(ctx);
+      if (acquire.isSuccess()) {
+        semaphoreAcquired = true;
+        sendHandshake(ctx);
+      } else {
+        acquire.addListener(new ChannelFutureListener() {
+          @Override public void operationComplete(ChannelFuture future) {
+            if (!future.isSuccess()) {
+              ctx.fireExceptionCaught(future.cause());
+              return;
+            }
+            if (ctx.isRemoved()) {
+              semaphoreRelease();
+              return;
+            }
+            semaphoreAcquired = true;
+            try {
+              sendHandshake(ctx);
+            } catch (Exception ex) {
+              ctx.fireExceptionCaught(ex);
+            }
+            ctx.flush();
+          }
+        });
+      }
+    } else {
+      super.userEventTriggered(ctx, evt);
+    }
+  }
+
+  private void fireProtocolNegotiationEvent(
+      ChannelHandlerContext ctx, TsiPeer peer, Object authContext, SecurityDetails details) {
+    checkState(pne != null, "negotiation not yet complete");
+    negotiationLogger.log(ChannelLogLevel.INFO, "TsiHandshake finished");
+    ProtocolNegotiationEvent localPne = pne;
+    Attributes.Builder attrs = InternalProtocolNegotiationEvent.getAttributes(localPne).toBuilder()
+        .set(TSI_PEER_KEY, peer)
+        .set(AUTH_CONTEXT_KEY, authContext)
+        .set(GrpcAttributes.ATTR_SECURITY_LEVEL, details.getSecurityLevel());
+    localPne = InternalProtocolNegotiationEvent.withAttributes(localPne, attrs.build());
+    localPne = InternalProtocolNegotiationEvent.withSecurity(localPne, details.getSecurity());
+    ctx.fireUserEventTriggered(localPne);
+  }
+
+  /** Sends as many bytes as are available from the handshaker to the remote peer. */
+  @SuppressWarnings("FutureReturnValueIgnored") // for addListener
+  private void sendHandshake(ChannelHandlerContext ctx) throws GeneralSecurityException {
+    while (true) {
+      boolean written = false;
+      ByteBuf buf = ctx.alloc().buffer(HANDSHAKE_FRAME_SIZE).retain(); // refcnt = 2
+      try {
+        handshaker.getBytesToSendToPeer(buf);
+        if (buf.isReadable()) {
+          ctx.writeAndFlush(buf).addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE);
+          written = true;
+        } else {
+          break;
+        }
+      } catch (GeneralSecurityException e) {
+        throw new GeneralSecurityException("TsiHandshakeHandler encountered exception", e);
+      } finally {
+        buf.release(written ? 1 : 2);
+      }
+    }
+  }
+
+  @Override
+  protected void handlerRemoved0(ChannelHandlerContext ctx) throws Exception {
+    if (semaphoreAcquired) {
+      semaphoreRelease();
+      semaphoreAcquired = false;
+    }
+    handshaker.close();
+  }
+
+  private ChannelFuture semaphoreAcquire(ChannelHandlerContext ctx) {
+    if (semaphore == null) {
+      return ctx.newSucceededFuture();
+    } else {
+      return semaphore.acquire(ctx);
+    }
+  }
+
+  private void semaphoreRelease() {
+    if (semaphore != null) {
+      semaphore.release();
+    }
+  }
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/TsiHandshaker.java b/alts/src/main/java/io/grpc/alts/internal/TsiHandshaker.java
new file mode 100644
index 00000000000..6580a4433c7
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/TsiHandshaker.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import io.netty.buffer.ByteBufAllocator;
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+
+/**
+ * This object protects and unprotects buffers once the handshake is done.
+ *
+ * <p>A typical usage of this object would be:
+ *
+ * <pre>{@code
+ * ByteBuffer buffer = allocateDirect(ALLOCATE_SIZE);
+ * while (true) {
+ *   while (true) {
+ *     tsiHandshaker.getBytesToSendToPeer(buffer.clear());
+ *     if (!buffer.hasRemaining()) break;
+ *     yourTransportSendMethod(buffer.flip());
+ *     assert(!buffer.hasRemaining());  // Guaranteed by yourTransportReceiveMethod(...)
+ *   }
+ *   if (!tsiHandshaker.isInProgress()) break;
+ *   while (true) {
+ *     assert(!buffer.hasRemaining());
+ *     yourTransportReceiveMethod(buffer.clear());
+ *     if (tsiHandshaker.processBytesFromPeer(buffer.flip())) break;
+ *   }
+ *   if (!tsiHandshaker.isInProgress()) break;
+ *   assert(!buffer.hasRemaining());
+ * }
+ * yourCheckPeerMethod(tsiHandshaker.extractPeer());
+ * TsiFrameProtector tsiFrameProtector = tsiHandshaker.createFrameProtector(MAX_FRAME_SIZE);
+ * if (buffer.hasRemaining()) tsiFrameProtector.unprotect(buffer, messageBuffer);
+ * }</pre>
+ *
+ * <p>Implementations of this object must be thread compatible.
+ */
+public interface TsiHandshaker {
+  /**
+   * Gets bytes that need to be sent to the peer.
+   *
+   * @param bytes The buffer to put handshake bytes.
+   */
+  void getBytesToSendToPeer(ByteBuffer bytes) throws GeneralSecurityException;
+
+  /**
+   * Process the bytes received from the peer.
+   *
+   * @param bytes The buffer containing the handshake bytes from the peer.
+   * @return true, if the handshake has all the data it needs to process and false, if the method
+   *     must be called again to complete processing.
+   */
+  boolean processBytesFromPeer(ByteBuffer bytes) throws GeneralSecurityException;
+
+  /**
+   * Returns true if and only if the handshake is still in progress.
+   *
+   * @return true, if the handshake is still in progress, false otherwise.
+   */
+  boolean isInProgress();
+
+  /**
+   * Returns the peer extracted from a completed handshake.
+   *
+   * @return the extracted peer.
+   */
+  TsiPeer extractPeer() throws GeneralSecurityException;
+
+  /**
+   * Returns the peer extracted from a completed handshake.
+   *
+   * @return the extracted peer.
+   */
+  Object extractPeerObject() throws GeneralSecurityException;
+
+  /**
+   * Creates a frame protector from a completed handshake. No other methods may be called after the
+   * frame protector is created.
+   *
+   * @param maxFrameSize the requested max frame size, the callee is free to ignore.
+   * @param alloc used for allocating ByteBufs.
+   * @return a new TsiFrameProtector.
+   */
+  TsiFrameProtector createFrameProtector(int maxFrameSize, ByteBufAllocator alloc);
+
+  /**
+   * Creates a frame protector from a completed handshake. No other methods may be called after the
+   * frame protector is created.
+   *
+   * @param alloc used for allocating ByteBufs.
+   * @return a new TsiFrameProtector.
+   */
+  TsiFrameProtector createFrameProtector(ByteBufAllocator alloc);
+
+  /**
+   * Closes resources.
+   */
+  void close();
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/TsiHandshakerFactory.java b/alts/src/main/java/io/grpc/alts/internal/TsiHandshakerFactory.java
new file mode 100644
index 00000000000..7d17a3954c8
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/TsiHandshakerFactory.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import io.grpc.ChannelLogger;
+import javax.annotation.Nullable;
+
+/** Factory that manufactures instances of {@link TsiHandshaker}. */
+public interface TsiHandshakerFactory {
+
+  /** Creates a new handshaker. */
+  TsiHandshaker newHandshaker(@Nullable String authority, ChannelLogger logger);
+}
diff --git a/alts/src/main/java/io/grpc/alts/internal/TsiPeer.java b/alts/src/main/java/io/grpc/alts/internal/TsiPeer.java
new file mode 100644
index 00000000000..c02188c50ac
--- /dev/null
+++ b/alts/src/main/java/io/grpc/alts/internal/TsiPeer.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import javax.annotation.Nonnull;
+
+/** A set of peer properties. */
+public final class TsiPeer {
+  private final List<Property<?>> properties;
+
+  public TsiPeer(List<Property<?>> properties) {
+    this.properties = Collections.unmodifiableList(properties);
+  }
+
+  public List<Property<?>> getProperties() {
+    return properties;
+  }
+
+  /** Get peer property. */
+  public Property<?> getProperty(String name) {
+    for (Property<?> property : properties) {
+      if (property.getName().equals(name)) {
+        return property;
+      }
+    }
+    return null;
+  }
+
+  @Override
+  public String toString() {
+    return new ArrayList<>(properties).toString();
+  }
+
+  /** A peer property. */
+  public abstract static class Property<T> {
+    private final String name;
+    private final T value;
+
+    protected Property(@Nonnull String name, @Nonnull T value) {
+      this.name = name;
+      this.value = value;
+    }
+
+    public final T getValue() {
+      return value;
+    }
+
+    public final String getName() {
+      return name;
+    }
+
+    @Override
+    public String toString() {
+      return String.format("%s=%s", name, value);
+    }
+  }
+
+  /** A peer property corresponding to a boolean. */
+  public static final class BooleanProperty extends Property<Boolean> {
+    public BooleanProperty(@Nonnull String name, boolean value) {
+      super(name, value);
+    }
+  }
+
+  /** A peer property corresponding to a signed 64-bit integer. */
+  public static final class SignedInt64Property extends Property<Long> {
+    public SignedInt64Property(@Nonnull String name, @Nonnull Long value) {
+      super(name, value);
+    }
+  }
+
+  /** A peer property corresponding to an unsigned 64-bit integer. */
+  public static final class UnsignedInt64Property extends Property<BigInteger> {
+    public UnsignedInt64Property(@Nonnull String name, @Nonnull BigInteger value) {
+      super(name, value);
+    }
+  }
+
+  /** A peer property corresponding to a double. */
+  public static final class DoubleProperty extends Property<Double> {
+    public DoubleProperty(@Nonnull String name, @Nonnull Double value) {
+      super(name, value);
+    }
+  }
+
+  /** A peer property corresponding to a string. */
+  public static final class StringProperty extends Property<String> {
+    public StringProperty(@Nonnull String name, @Nonnull String value) {
+      super(name, value);
+    }
+  }
+
+  /** A peer property corresponding to a list of peer properties. */
+  public static final class PropertyList extends Property<List<Property<?>>> {
+    public PropertyList(@Nonnull String name, @Nonnull List<Property<?>> value) {
+      super(name, value);
+    }
+  }
+}
diff --git a/alts/src/main/proto/grpc/gcp/altscontext.proto b/alts/src/main/proto/grpc/gcp/altscontext.proto
new file mode 100644
index 00000000000..a6cceb1c303
--- /dev/null
+++ b/alts/src/main/proto/grpc/gcp/altscontext.proto
@@ -0,0 +1,50 @@
+// Copyright 2018 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.
+
+// The canonical version of this proto can be found at
+// https://github.com/grpc/grpc-proto/blob/master/grpc/gcp/altscontext.proto
+
+syntax = "proto3";
+
+package grpc.gcp;
+
+import "grpc/gcp/transport_security_common.proto";
+
+option go_package = "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp";
+option java_multiple_files = true;
+option java_outer_classname = "AltsContextProto";
+option java_package = "io.grpc.alts.internal";
+
+message AltsContext {
+  // The application protocol negotiated for this connection.
+  string application_protocol = 1;
+
+  // The record protocol negotiated for this connection.
+  string record_protocol = 2;
+
+  // The security level of the created secure channel.
+  SecurityLevel security_level = 3;
+
+  // The peer service account.
+  string peer_service_account = 4;
+
+  // The local service account.
+  string local_service_account = 5;
+
+  // The RPC protocol versions supported by the peer.
+  RpcProtocolVersions peer_rpc_versions = 6;
+
+  // Additional attributes of the peer.
+  map<string, string> peer_attributes = 7;
+}
diff --git a/alts/src/main/proto/grpc/gcp/handshaker.proto b/alts/src/main/proto/grpc/gcp/handshaker.proto
new file mode 100644
index 00000000000..02764ba4c08
--- /dev/null
+++ b/alts/src/main/proto/grpc/gcp/handshaker.proto
@@ -0,0 +1,243 @@
+// Copyright 2018 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.
+
+// The canonical version of this proto can be found at
+// https://github.com/grpc/grpc-proto/blob/master/grpc/gcp/handshaker.proto
+
+syntax = "proto3";
+
+package grpc.gcp;
+
+import "grpc/gcp/transport_security_common.proto";
+
+option go_package = "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp";
+option java_multiple_files = true;
+option java_outer_classname = "HandshakerProto";
+option java_package = "io.grpc.alts.internal";
+
+
+enum HandshakeProtocol {
+  // Default value.
+  HANDSHAKE_PROTOCOL_UNSPECIFIED = 0;
+
+  // TLS handshake protocol.
+  TLS = 1;
+
+  // Application Layer Transport Security handshake protocol.
+  ALTS = 2;
+}
+
+enum NetworkProtocol {
+  NETWORK_PROTOCOL_UNSPECIFIED = 0;
+  TCP = 1;
+  UDP = 2;
+}
+
+message Endpoint {
+  // IP address. It should contain an IPv4 or IPv6 string literal, e.g.
+  // "192.168.0.1" or "2001:db8::1".
+  string ip_address = 1;
+
+  // Port number.
+  int32 port = 2;
+
+  // Network protocol (e.g., TCP, UDP) associated with this endpoint.
+  NetworkProtocol protocol = 3;
+}
+
+message Identity {
+  oneof identity_oneof {
+    // Service account of a connection endpoint.
+    string service_account = 1;
+
+    // Hostname of a connection endpoint.
+    string hostname = 2;
+  }
+
+  // Additional attributes of the identity.
+  map<string, string> attributes = 3;
+}
+
+message StartClientHandshakeReq {
+  // Handshake security protocol requested by the client.
+  HandshakeProtocol handshake_security_protocol = 1;
+
+  // The application protocols supported by the client, e.g., "h2" (for http2),
+  // "grpc".
+  repeated string application_protocols = 2;
+
+  // The record protocols supported by the client, e.g.,
+  // "ALTSRP_GCM_AES128".
+  repeated string record_protocols = 3;
+
+  // (Optional) Describes which server identities are acceptable by the client.
+  // If target identities are provided and none of them matches the peer
+  // identity of the server, handshake will fail.
+  repeated Identity target_identities = 4;
+
+  // (Optional) Application may specify a local identity. Otherwise, the
+  // handshaker chooses a default local identity.
+  Identity local_identity = 5;
+
+  // (Optional) Local endpoint information of the connection to the server,
+  // such as local IP address, port number, and network protocol.
+  Endpoint local_endpoint = 6;
+
+  // (Optional) Endpoint information of the remote server, such as IP address,
+  // port number, and network protocol.
+  Endpoint remote_endpoint = 7;
+
+  // (Optional) If target name is provided, a secure naming check is performed
+  // to verify that the peer authenticated identity is indeed authorized to run
+  // the target name.
+  string target_name = 8;
+
+  // (Optional) RPC protocol versions supported by the client.
+  RpcProtocolVersions rpc_versions = 9;
+
+  // (Optional) Maximum frame size supported by the client.
+  uint32 max_frame_size = 10;
+}
+
+message ServerHandshakeParameters {
+  // The record protocols supported by the server, e.g.,
+  // "ALTSRP_GCM_AES128".
+  repeated string record_protocols = 1;
+
+  // (Optional) A list of local identities supported by the server, if
+  // specified. Otherwise, the handshaker chooses a default local identity.
+  repeated Identity local_identities = 2;
+}
+
+message StartServerHandshakeReq {
+  // The application protocols supported by the server, e.g., "h2" (for http2),
+  // "grpc".
+  repeated string application_protocols = 1;
+
+  // Handshake parameters (record protocols and local identities supported by
+  // the server) mapped by the handshake protocol. Each handshake security
+  // protocol (e.g., TLS or ALTS) has its own set of record protocols and local
+  // identities. Since protobuf does not support enum as key to the map, the key
+  // to handshake_parameters is the integer value of HandshakeProtocol enum.
+  map<int32, ServerHandshakeParameters> handshake_parameters = 2;
+
+  // Bytes in out_frames returned from the peer's HandshakerResp. It is possible
+  // that the peer's out_frames are split into multiple HandshakReq messages.
+  bytes in_bytes = 3;
+
+  // (Optional) Local endpoint information of the connection to the client,
+  // such as local IP address, port number, and network protocol.
+  Endpoint local_endpoint = 4;
+
+  // (Optional) Endpoint information of the remote client, such as IP address,
+  // port number, and network protocol.
+  Endpoint remote_endpoint = 5;
+
+  // (Optional) RPC protocol versions supported by the server.
+  RpcProtocolVersions rpc_versions = 6;
+
+  // (Optional) Maximum frame size supported by the server.
+  uint32 max_frame_size = 7;
+}
+
+message NextHandshakeMessageReq {
+  // Bytes in out_frames returned from the peer's HandshakerResp. It is possible
+  // that the peer's out_frames are split into multiple NextHandshakerMessageReq
+  // messages.
+  bytes in_bytes = 1;
+}
+
+message HandshakerReq {
+  oneof req_oneof {
+    // The start client handshake request message.
+    StartClientHandshakeReq client_start = 1;
+
+    // The start server handshake request message.
+    StartServerHandshakeReq server_start = 2;
+
+    // The next handshake request message.
+    NextHandshakeMessageReq next = 3;
+  }
+}
+
+message HandshakerResult {
+  // The application protocol negotiated for this connection.
+  string application_protocol = 1;
+
+  // The record protocol negotiated for this connection.
+  string record_protocol = 2;
+
+  // Cryptographic key data. The key data may be more than the key length
+  // required for the record protocol, thus the client of the handshaker
+  // service needs to truncate the key data into the right key length.
+  bytes key_data = 3;
+
+  // The authenticated identity of the peer.
+  Identity peer_identity = 4;
+
+  // The local identity used in the handshake.
+  Identity local_identity = 5;
+
+  // Indicate whether the handshaker service client should keep the channel
+  // between the handshaker service open, e.g., in order to handle
+  // post-handshake messages in the future.
+  bool keep_channel_open = 6;
+
+  // The RPC protocol versions supported by the peer.
+  RpcProtocolVersions peer_rpc_versions = 7;
+
+  // The maximum frame size of the peer.
+  uint32 max_frame_size = 8;
+}
+
+message HandshakerStatus {
+  // The status code. This could be the gRPC status code.
+  uint32 code = 1;
+
+  // The status details.
+  string details = 2;
+}
+
+message HandshakerResp {
+  // Frames to be given to the peer for the NextHandshakeMessageReq. May be
+  // empty if no out_frames have to be sent to the peer or if in_bytes in the
+  // HandshakerReq are incomplete. All the non-empty out frames must be sent to
+  // the peer even if the handshaker status is not OK as these frames may
+  // contain the alert frames.
+  bytes out_frames = 1;
+
+  // Number of bytes in the in_bytes consumed by the handshaker. It is possible
+  // that part of in_bytes in HandshakerReq was unrelated to the handshake
+  // process.
+  uint32 bytes_consumed = 2;
+
+  // This is set iff the handshake was successful. out_frames may still be set
+  // to frames that needs to be forwarded to the peer.
+  HandshakerResult result = 3;
+
+  // Status of the handshaker.
+  HandshakerStatus status = 4;
+}
+
+service HandshakerService {
+  // Handshaker service accepts a stream of handshaker request, returning a
+  // stream of handshaker response. Client is expected to send exactly one
+  // message with either client_start or server_start followed by one or more
+  // messages with next. Each time client sends a request, the handshaker
+  // service expects to respond. Client does not have to wait for service's
+  // response before sending next request.
+  rpc DoHandshake(stream HandshakerReq)
+      returns (stream HandshakerResp) {
+  }
+}
diff --git a/alts/src/main/proto/grpc/gcp/transport_security_common.proto b/alts/src/main/proto/grpc/gcp/transport_security_common.proto
new file mode 100644
index 00000000000..8f01be79e36
--- /dev/null
+++ b/alts/src/main/proto/grpc/gcp/transport_security_common.proto
@@ -0,0 +1,46 @@
+// Copyright 2018 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.
+
+// The canonical version of this proto can be found at
+// https://github.com/grpc/grpc-proto/blob/master/grpc/gcp/transport_security_common.proto
+
+syntax = "proto3";
+
+package grpc.gcp;
+
+option go_package = "google.golang.org/grpc/credentials/alts/internal/proto/grpc_gcp";
+option java_multiple_files = true;
+option java_outer_classname = "TransportSecurityCommonProto";
+option java_package = "io.grpc.alts.internal";
+
+// The security level of the created channel. The list is sorted in increasing
+// level of security. This order must always be maintained.
+enum SecurityLevel {
+  SECURITY_NONE = 0;
+  INTEGRITY_ONLY = 1;
+  INTEGRITY_AND_PRIVACY = 2;
+}
+
+// Max and min supported RPC protocol versions.
+message RpcProtocolVersions {
+  // RPC version contains a major version and a minor version.
+  message Version {
+    uint32 major = 1;
+    uint32 minor = 2;
+  }
+  // Maximum supported RPC version.
+  Version max_rpc_version = 1;
+  // Minimum supported RPC version.
+  Version min_rpc_version = 2;
+}
diff --git a/alts/src/test/java/io/grpc/alts/AltsChannelBuilderTest.java b/alts/src/test/java/io/grpc/alts/AltsChannelBuilderTest.java
new file mode 100644
index 00000000000..a44de19b911
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/AltsChannelBuilderTest.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2018 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.alts;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class AltsChannelBuilderTest {
+
+  @Test
+  public void buildsNettyChannel() {
+    AltsChannelBuilder builder =
+        AltsChannelBuilder.forTarget("localhost:8080").enableUntrustedAltsForTesting();
+
+    ProtocolNegotiator protocolNegotiator = builder.getProtocolNegotiatorForTest();
+    assertThat(protocolNegotiator).isNotNull();
+    // Avoids exposing this class
+    assertThat(protocolNegotiator.getClass().getSimpleName())
+        .isEqualTo("ClientAltsProtocolNegotiator");
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/AltsContextUtilTest.java b/alts/src/test/java/io/grpc/alts/AltsContextUtilTest.java
new file mode 100644
index 00000000000..675fa29fc99
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/AltsContextUtilTest.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright 2018 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.alts;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import io.grpc.Attributes;
+import io.grpc.ClientCall;
+import io.grpc.ServerCall;
+import io.grpc.alts.AltsContext.SecurityLevel;
+import io.grpc.alts.internal.AltsInternalContext;
+import io.grpc.alts.internal.AltsProtocolNegotiator;
+import io.grpc.alts.internal.HandshakerResult;
+import io.grpc.alts.internal.Identity;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AltsContextUtil}. */
+@RunWith(JUnit4.class)
+public class AltsContextUtilTest {
+  @Test
+  public void check_noAttributeValue() {
+    assertFalse(AltsContextUtil.check(Attributes.newBuilder().build()));
+  }
+
+  @Test
+  public void check_unexpectedAttributeValueType() {
+    assertFalse(AltsContextUtil.check(Attributes.newBuilder()
+        .set(AltsProtocolNegotiator.AUTH_CONTEXT_KEY, new Object())
+        .build()));
+  }
+
+  @Test
+  public void check_altsInternalContext() {
+    assertTrue(AltsContextUtil.check(Attributes.newBuilder()
+        .set(AltsProtocolNegotiator.AUTH_CONTEXT_KEY, AltsInternalContext.getDefaultInstance())
+        .build()));
+  }
+
+  @Test
+  public void checkServer_altsInternalContext() {
+    ServerCall<?,?> call = mock(ServerCall.class);
+    when(call.getAttributes()).thenReturn(Attributes.newBuilder()
+        .set(AltsProtocolNegotiator.AUTH_CONTEXT_KEY, AltsInternalContext.getDefaultInstance())
+        .build());
+
+    assertTrue(AltsContextUtil.check(call));
+  }
+
+  @Test
+  public void checkClient_altsInternalContext() {
+    ClientCall<?,?> call = mock(ClientCall.class);
+    when(call.getAttributes()).thenReturn(Attributes.newBuilder()
+        .set(AltsProtocolNegotiator.AUTH_CONTEXT_KEY, AltsInternalContext.getDefaultInstance())
+        .build());
+
+    assertTrue(AltsContextUtil.check(call));
+  }
+
+  @Test
+  public void createFrom_altsInternalContext() {
+    HandshakerResult handshakerResult =
+        HandshakerResult.newBuilder()
+            .setPeerIdentity(Identity.newBuilder().setServiceAccount("remote@peer"))
+            .setLocalIdentity(Identity.newBuilder().setServiceAccount("local@peer"))
+            .build();
+
+    AltsContext context = AltsContextUtil.createFrom(Attributes.newBuilder()
+        .set(AltsProtocolNegotiator.AUTH_CONTEXT_KEY, new AltsInternalContext(handshakerResult))
+        .build());
+    assertEquals("remote@peer", context.getPeerServiceAccount());
+    assertEquals("local@peer", context.getLocalServiceAccount());
+    assertEquals(SecurityLevel.INTEGRITY_AND_PRIVACY, context.getSecurityLevel());
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void createFrom_noAttributeValue() {
+    AltsContextUtil.createFrom(Attributes.newBuilder().build());
+  }
+
+  @Test
+  public void createFromServer_altsInternalContext() {
+    HandshakerResult handshakerResult =
+        HandshakerResult.newBuilder()
+            .setPeerIdentity(Identity.newBuilder().setServiceAccount("remote@peer"))
+            .setLocalIdentity(Identity.newBuilder().setServiceAccount("local@peer"))
+            .build();
+
+    ServerCall<?,?> call = mock(ServerCall.class);
+    when(call.getAttributes()).thenReturn(Attributes.newBuilder()
+        .set(AltsProtocolNegotiator.AUTH_CONTEXT_KEY, new AltsInternalContext(handshakerResult))
+        .build());
+
+    AltsContext context = AltsContextUtil.createFrom(call);
+    assertEquals("remote@peer", context.getPeerServiceAccount());
+  }
+
+  @Test
+  public void createFromClient_altsInternalContext() {
+    HandshakerResult handshakerResult =
+        HandshakerResult.newBuilder()
+            .setPeerIdentity(Identity.newBuilder().setServiceAccount("remote@peer"))
+            .setLocalIdentity(Identity.newBuilder().setServiceAccount("local@peer"))
+            .build();
+
+    ClientCall<?,?> call = mock(ClientCall.class);
+    when(call.getAttributes()).thenReturn(Attributes.newBuilder()
+        .set(AltsProtocolNegotiator.AUTH_CONTEXT_KEY, new AltsInternalContext(handshakerResult))
+        .build());
+
+    AltsContext context = AltsContextUtil.createFrom(call);
+    assertEquals("remote@peer", context.getPeerServiceAccount());
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/AltsServerBuilderTest.java b/alts/src/test/java/io/grpc/alts/AltsServerBuilderTest.java
new file mode 100644
index 00000000000..f729a8be2b3
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/AltsServerBuilderTest.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2018 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.alts;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class AltsServerBuilderTest {
+
+  @Test
+  public void buildsNettyServer() throws Exception {
+    AltsServerBuilder.forPort(1234).enableUntrustedAltsForTesting().build();
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/AuthorizationUtilTest.java b/alts/src/test/java/io/grpc/alts/AuthorizationUtilTest.java
new file mode 100644
index 00000000000..8b4691df331
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/AuthorizationUtilTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2019 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.alts;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.Lists;
+import io.grpc.Attributes;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCall;
+import io.grpc.Status;
+import io.grpc.alts.internal.AltsInternalContext;
+import io.grpc.alts.internal.AltsProtocolNegotiator;
+import io.grpc.alts.internal.HandshakerResult;
+import io.grpc.alts.internal.Identity;
+import javax.annotation.Nullable;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AuthorizationUtil}. */
+@RunWith(JUnit4.class)
+public final class AuthorizationUtilTest {
+
+  @Test
+  public void altsAuthorizationCheck() throws Exception {
+    Status status =
+        AuthorizationUtil.clientAuthorizationCheck(
+            new FakeServerCall(null), Lists.newArrayList("Alice"));
+    assertThat(status.getCode()).isEqualTo(Status.Code.PERMISSION_DENIED);
+    assertThat(status.getDescription()).startsWith("Peer ALTS AuthContext not found");
+    status =
+        AuthorizationUtil.clientAuthorizationCheck(
+            new FakeServerCall("Alice"), Lists.newArrayList("Alice", "Bob"));
+    assertThat(status.getCode()).isEqualTo(Status.Code.OK);
+    status =
+        AuthorizationUtil.clientAuthorizationCheck(
+            new FakeServerCall("Alice"), Lists.newArrayList("Bob", "Joe"));
+    assertThat(status.getCode()).isEqualTo(Status.Code.PERMISSION_DENIED);
+    assertThat(status.getDescription()).endsWith("not authorized");
+  }
+
+  private static class FakeServerCall extends ServerCall<String, String> {
+    final Attributes attrs;
+
+    FakeServerCall(@Nullable String peerServiceAccount) {
+      Attributes.Builder attrsBuilder = Attributes.newBuilder();
+      if (peerServiceAccount != null) {
+        HandshakerResult handshakerResult =
+            HandshakerResult.newBuilder()
+                .setPeerIdentity(Identity.newBuilder().setServiceAccount(peerServiceAccount))
+                .build();
+        AltsInternalContext altsContext = new AltsInternalContext(handshakerResult);
+        attrsBuilder.set(AltsProtocolNegotiator.AUTH_CONTEXT_KEY, altsContext);
+      }
+      attrs = attrsBuilder.build();
+    }
+
+    @Override
+    public void request(int numMessages) {
+      throw new AssertionError("Should not be called");
+    }
+
+    @Override
+    public void sendHeaders(Metadata headers) {
+      throw new AssertionError("Should not be called");
+    }
+
+    @Override
+    public void sendMessage(String message) {
+      throw new AssertionError("Should not be called");
+    }
+
+    @Override
+    public void close(Status status, Metadata trailers) {
+      throw new AssertionError("Should not be called");
+    }
+
+    @Override
+    public boolean isCancelled() {
+      throw new AssertionError("Should not be called");
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return attrs;
+    }
+
+    @Override
+    public String getAuthority() {
+      throw new AssertionError("Should not be called");
+    }
+
+    @Override
+    public MethodDescriptor<String, String> getMethodDescriptor() {
+      throw new AssertionError("Should not be called");
+    }
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/ComputeEngineChannelBuilderTest.java b/alts/src/test/java/io/grpc/alts/ComputeEngineChannelBuilderTest.java
new file mode 100644
index 00000000000..03fd113a65e
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/ComputeEngineChannelBuilderTest.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2019 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.alts;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class ComputeEngineChannelBuilderTest {
+
+  @Test
+  public void buildsNettyChannel() throws Exception {
+    ComputeEngineChannelBuilder builder = ComputeEngineChannelBuilder.forTarget("localhost:8080");
+    builder.build();
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/DualCallCredentialsTest.java b/alts/src/test/java/io/grpc/alts/DualCallCredentialsTest.java
new file mode 100644
index 00000000000..29646191be1
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/DualCallCredentialsTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2024 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.alts;
+
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.Attributes;
+import io.grpc.CallCredentials;
+import io.grpc.CallCredentials.RequestInfo;
+import io.grpc.MethodDescriptor;
+import io.grpc.SecurityLevel;
+import io.grpc.alts.internal.AltsInternalContext;
+import io.grpc.alts.internal.AltsProtocolNegotiator;
+import io.grpc.testing.TestMethodDescriptors;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for {@link DualCallCredentials}. */
+@RunWith(JUnit4.class)
+public class DualCallCredentialsTest {
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock CallCredentials tlsCallCredentials;
+
+  @Mock CallCredentials altsCallCredentials;
+
+  private static final String AUTHORITY = "testauthority";
+  private static final SecurityLevel SECURITY_LEVEL = SecurityLevel.PRIVACY_AND_INTEGRITY;
+
+  @Test
+  public void invokeTlsCallCredentials() {
+    DualCallCredentials callCredentials =
+        new DualCallCredentials(tlsCallCredentials, altsCallCredentials);
+    RequestInfo requestInfo = new RequestInfoImpl(false);
+    callCredentials.applyRequestMetadata(requestInfo, null, null);
+
+    verify(altsCallCredentials, never()).applyRequestMetadata(any(), any(), any());
+    verify(tlsCallCredentials, times(1)).applyRequestMetadata(requestInfo, null, null);
+  }
+
+  @Test
+  public void invokeAltsCallCredentials() {
+    DualCallCredentials callCredentials =
+        new DualCallCredentials(tlsCallCredentials, altsCallCredentials);
+    RequestInfo requestInfo = new RequestInfoImpl(true);
+    callCredentials.applyRequestMetadata(requestInfo, null, null);
+
+    verify(altsCallCredentials, times(1)).applyRequestMetadata(requestInfo, null, null);
+    verify(tlsCallCredentials, never()).applyRequestMetadata(any(), any(), any());
+  }
+
+  private static final class RequestInfoImpl extends CallCredentials.RequestInfo {
+    private Attributes attrs;
+
+    RequestInfoImpl(boolean hasAltsContext) {
+      attrs =
+          hasAltsContext
+              ? Attributes.newBuilder()
+                  .set(
+                      AltsProtocolNegotiator.AUTH_CONTEXT_KEY,
+                      AltsInternalContext.getDefaultInstance())
+                  .build()
+              : Attributes.EMPTY;
+    }
+
+    @Override
+    public MethodDescriptor<?, ?> getMethodDescriptor() {
+      return TestMethodDescriptors.voidMethod();
+    }
+
+    @Override
+    public SecurityLevel getSecurityLevel() {
+      return SECURITY_LEVEL;
+    }
+
+    @Override
+    public String getAuthority() {
+      return AUTHORITY;
+    }
+
+    @Override
+    public Attributes getTransportAttrs() {
+      return attrs;
+    }
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/GoogleDefaultChannelBuilderTest.java b/alts/src/test/java/io/grpc/alts/GoogleDefaultChannelBuilderTest.java
new file mode 100644
index 00000000000..c73ef4444e9
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/GoogleDefaultChannelBuilderTest.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2018 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.alts;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class GoogleDefaultChannelBuilderTest {
+
+  @Test
+  public void buildsNettyChannel() throws Exception {
+    GoogleDefaultChannelBuilder builder = GoogleDefaultChannelBuilder.forTarget("localhost:8080");
+    builder.build();
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/HandshakerServiceChannelTest.java b/alts/src/test/java/io/grpc/alts/HandshakerServiceChannelTest.java
new file mode 100644
index 00000000000..221001157f1
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/HandshakerServiceChannelTest.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2018 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.alts;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.Channel;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.internal.SharedResourceHolder.Resource;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class HandshakerServiceChannelTest {
+  @Rule
+  public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+  private final Server server = grpcCleanup.register(
+      ServerBuilder.forPort(0)
+        .addService(new SimpleServiceGrpc.SimpleServiceImplBase() {
+          @Override
+          public void unaryRpc(SimpleRequest request, StreamObserver<SimpleResponse> so) {
+            so.onNext(SimpleResponse.getDefaultInstance());
+            so.onCompleted();
+          }
+        })
+          .build());
+  private Resource<Channel> resource;
+
+  @Before
+  public void setUp() throws Exception {
+    server.start();
+    resource =
+        HandshakerServiceChannel.getHandshakerChannelForTesting("localhost:" + server.getPort());
+  }
+
+  @Test
+  public void sharedChannel_authority() {
+    resource = HandshakerServiceChannel.SHARED_HANDSHAKER_CHANNEL;
+    Channel channel = resource.create();
+    try {
+      assertThat(channel.authority()).isEqualTo("metadata.google.internal.:8080");
+    } finally {
+      resource.close(channel);
+    }
+  }
+
+  @Test
+  public void getHandshakerTarget_nullEnvVar() {
+    assertThat(HandshakerServiceChannel.getHandshakerTarget(null))
+        .isEqualTo("metadata.google.internal.:8080");
+  }
+
+  @Test
+  public void getHandshakerTarget_envVarWithPort() {
+    assertThat(HandshakerServiceChannel.getHandshakerTarget("169.254.169.254:80"))
+        .isEqualTo("169.254.169.254:8080");
+  }
+
+  @Test
+  public void getHandshakerTarget_envVarWithHostOnly() {
+    assertThat(HandshakerServiceChannel.getHandshakerTarget("169.254.169.254"))
+        .isEqualTo("169.254.169.254:8080");
+  }
+  
+  @Test
+  public void resource_works() {
+    Channel channel = resource.create();
+    try {
+      // Do an RPC to verify that the channel actually works
+      doRpc(channel);
+    } finally {
+      resource.close(channel);
+    }
+  }
+
+  @Test
+  public void resource_lifecycleTwice() {
+    Channel channel = resource.create();
+    try {
+      doRpc(channel);
+    } finally {
+      resource.close(channel);
+    }
+    channel = resource.create();
+    try {
+      doRpc(channel);
+    } finally {
+      resource.close(channel);
+    }
+  }
+
+  private void doRpc(Channel channel) {
+    SimpleServiceGrpc.newBlockingStub(channel).unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/InternalCheckGcpEnvironmentTest.java b/alts/src/test/java/io/grpc/alts/InternalCheckGcpEnvironmentTest.java
new file mode 100644
index 00000000000..1234cfc49c3
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/InternalCheckGcpEnvironmentTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2018 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.alts;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.io.BufferedReader;
+import java.io.StringReader;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class InternalCheckGcpEnvironmentTest {
+
+  @Test
+  public void checkGcpLinuxPlatformData() throws Exception {
+    BufferedReader reader;
+    reader = new BufferedReader(new StringReader("HP Z440 Workstation"));
+    assertFalse(InternalCheckGcpEnvironment.checkProductNameOnLinux(reader));
+    reader = new BufferedReader(new StringReader("Google"));
+    assertTrue(InternalCheckGcpEnvironment.checkProductNameOnLinux(reader));
+    reader = new BufferedReader(new StringReader("Google Compute Engine"));
+    assertTrue(InternalCheckGcpEnvironment.checkProductNameOnLinux(reader));
+    reader = new BufferedReader(new StringReader("Google Compute Engine    "));
+    assertTrue(InternalCheckGcpEnvironment.checkProductNameOnLinux(reader));
+  }
+
+  @Test
+  public void checkGcpWindowsPlatformData() throws Exception {
+    BufferedReader reader;
+    reader = new BufferedReader(new StringReader("Product : Google"));
+    assertFalse(InternalCheckGcpEnvironment.checkBiosDataOnWindows(reader));
+    reader = new BufferedReader(new StringReader("Manufacturer : LENOVO"));
+    assertFalse(InternalCheckGcpEnvironment.checkBiosDataOnWindows(reader));
+    reader = new BufferedReader(new StringReader("Manufacturer : Google Compute Engine"));
+    assertFalse(InternalCheckGcpEnvironment.checkBiosDataOnWindows(reader));
+    reader = new BufferedReader(new StringReader("Manufacturer : Google"));
+    assertTrue(InternalCheckGcpEnvironment.checkBiosDataOnWindows(reader));
+    reader = new BufferedReader(new StringReader("Manufacturer:Google"));
+    assertTrue(InternalCheckGcpEnvironment.checkBiosDataOnWindows(reader));
+    reader = new BufferedReader(new StringReader("Manufacturer :   Google    "));
+    assertTrue(InternalCheckGcpEnvironment.checkBiosDataOnWindows(reader));
+    reader = new BufferedReader(new StringReader("BIOSVersion : 1.0\nManufacturer : Google\n"));
+    assertTrue(InternalCheckGcpEnvironment.checkBiosDataOnWindows(reader));
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/AesGcmAeadCrypterTest.java b/alts/src/test/java/io/grpc/alts/internal/AesGcmAeadCrypterTest.java
new file mode 100644
index 00000000000..bcf8c2810ee
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/AesGcmAeadCrypterTest.java
@@ -0,0 +1,34 @@
+/*
+ * 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.TruthJUnit.assume;
+
+import org.conscrypt.Conscrypt;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class AesGcmAeadCrypterTest {
+  @Test
+  public void getConscrypt_worksWhenConscryptIsAvailable() {
+    assume().that(Conscrypt.isAvailable()).isTrue();
+    assertThat(AesGcmAeadCrypter.getConscrypt()).isNotNull();
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/AesGcmHkdfAeadCrypterTest.java b/alts/src/test/java/io/grpc/alts/internal/AesGcmHkdfAeadCrypterTest.java
new file mode 100644
index 00000000000..06f2ff5365f
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/AesGcmHkdfAeadCrypterTest.java
@@ -0,0 +1,494 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertWithMessage;
+
+import com.google.common.io.BaseEncoding;
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+import java.util.Arrays;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AesGcmHkdfAeadCrypter}. */
+@RunWith(JUnit4.class)
+public final class AesGcmHkdfAeadCrypterTest {
+
+  private static class TestVector {
+    final String comment;
+    final byte[] key;
+    final byte[] nonce;
+    final byte[] aad;
+    final byte[] plaintext;
+    final byte[] ciphertext;
+
+    TestVector(TestVectorBuilder builder) {
+      comment = builder.comment;
+      key = builder.key;
+      nonce = builder.nonce;
+      aad = builder.aad;
+      plaintext = builder.plaintext;
+      ciphertext = builder.ciphertext;
+    }
+
+    static TestVectorBuilder builder() {
+      return new TestVectorBuilder();
+    }
+  }
+
+  private static class TestVectorBuilder {
+    String comment;
+    byte[] key;
+    byte[] nonce;
+    byte[] aad;
+    byte[] plaintext;
+    byte[] ciphertext;
+
+    TestVector build() {
+      if (comment == null
+          && key == null
+          && nonce == null
+          && aad == null
+          && plaintext == null
+          && ciphertext == null) {
+        throw new IllegalStateException("All fields must be set before calling build().");
+      }
+      return new TestVector(this);
+    }
+
+    TestVectorBuilder withComment(String comment) {
+      this.comment = comment;
+      return this;
+    }
+
+    TestVectorBuilder withKey(String key) {
+      this.key = BaseEncoding.base16().lowerCase().decode(key);
+      return this;
+    }
+
+    TestVectorBuilder withNonce(String nonce) {
+      this.nonce = BaseEncoding.base16().lowerCase().decode(nonce);
+      return this;
+    }
+
+    TestVectorBuilder withAad(String aad) {
+      this.aad = BaseEncoding.base16().lowerCase().decode(aad);
+      return this;
+    }
+
+    TestVectorBuilder withPlaintext(String plaintext) {
+      this.plaintext = BaseEncoding.base16().lowerCase().decode(plaintext);
+      return this;
+    }
+
+    TestVectorBuilder withCiphertext(String ciphertext) {
+      this.ciphertext = BaseEncoding.base16().lowerCase().decode(ciphertext);
+      return this;
+    }
+  }
+
+  @Test
+  public void testVectorEncrypt() throws GeneralSecurityException {
+    int i = 0;
+    for (TestVector testVector : testVectors) {
+      int bufferSize = testVector.ciphertext.length;
+      byte[] ciphertext = new byte[bufferSize];
+      ByteBuffer ciphertextBuffer = ByteBuffer.wrap(ciphertext);
+
+      AesGcmHkdfAeadCrypter aeadCrypter = new AesGcmHkdfAeadCrypter(testVector.key);
+      aeadCrypter.encrypt(
+          ciphertextBuffer,
+          ByteBuffer.wrap(testVector.plaintext),
+          ByteBuffer.wrap(testVector.aad),
+          testVector.nonce);
+      String msg = "Failure for test vector " + i + " " + testVector.comment;
+      assertWithMessage(msg)
+          .that(ciphertextBuffer.remaining())
+          .isEqualTo(bufferSize - testVector.ciphertext.length);
+      byte[] exactCiphertext = Arrays.copyOf(ciphertext, testVector.ciphertext.length);
+      assertWithMessage(msg).that(exactCiphertext).isEqualTo(testVector.ciphertext);
+      i++;
+    }
+  }
+
+  @Test
+  public void testVectorDecrypt() throws GeneralSecurityException {
+    int i = 0;
+    for (TestVector testVector : testVectors) {
+      // The plaintext buffer might require space for the tag to decrypt (e.g., for conscrypt).
+      int bufferSize = testVector.ciphertext.length;
+      byte[] plaintext = new byte[bufferSize];
+      ByteBuffer plaintextBuffer = ByteBuffer.wrap(plaintext);
+
+      AesGcmHkdfAeadCrypter aeadCrypter = new AesGcmHkdfAeadCrypter(testVector.key);
+      aeadCrypter.decrypt(
+          plaintextBuffer,
+          ByteBuffer.wrap(testVector.ciphertext),
+          ByteBuffer.wrap(testVector.aad),
+          testVector.nonce);
+      String msg = "Failure for test vector " + i + " " + testVector.comment;
+      assertWithMessage(msg)
+          .that(plaintextBuffer.remaining())
+          .isEqualTo(bufferSize - testVector.plaintext.length);
+      byte[] exactPlaintext = Arrays.copyOf(plaintext, testVector.plaintext.length);
+      assertWithMessage(msg).that(exactPlaintext).isEqualTo(testVector.plaintext);
+      i++;
+    }
+  }
+
+  /*
+   * NIST vectors from:
+   *  http://csrc.nist.gov/groups/ST/toolkit/BCM/documents/proposedmodes/gcm/gcm-revised-spec.pdf
+   *
+   *  IEEE vectors from:
+   *  http://www.ieee802.org/1/files/public/docs2011/bn-randall-test-vectors-0511-v1.pdf
+   * Key expanded by setting
+   * expandedKey = (key||(key ^ {0x01, .., 0x01})||key ^ {0x02,..,0x02}))[0:44].
+   */
+  private static final TestVector[] testVectors =
+      new TestVector[] {
+        TestVector.builder()
+            .withComment("Derived from NIST test vector 1")
+            .withKey(
+                "0000000000000000000000000000000001010101010101010101010101010101020202020202020202"
+                    + "020202")
+            .withNonce("000000000000000000000000")
+            .withAad("")
+            .withPlaintext("")
+            .withCiphertext("85e873e002f6ebdc4060954eb8675508")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from NIST test vector 2")
+            .withKey(
+                "0000000000000000000000000000000001010101010101010101010101010101020202020202020202"
+                    + "020202")
+            .withNonce("000000000000000000000000")
+            .withAad("")
+            .withPlaintext("00000000000000000000000000000000")
+            .withCiphertext("51e9a8cb23ca2512c8256afff8e72d681aca19a1148ac115e83df4888cc00d11")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from NIST test vector 3")
+            .withKey(
+                "feffe9928665731c6d6a8f9467308308fffee8938764721d6c6b8e9566318209fcfdeb908467711e6f"
+                    + "688d96")
+            .withNonce("cafebabefacedbaddecaf888")
+            .withAad("")
+            .withPlaintext(
+                "d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532f"
+                    + "cf0e2449a6b525b16aedf5aa0de657ba637b391aafd255")
+            .withCiphertext(
+                "1018ed5a1402a86516d6576d70b2ffccca261b94df88b58f53b64dfba435d18b2f6e3b7869f9353d4a"
+                    + "c8cf09afb1663daa7b4017e6fc2c177c0c087c0df1162129952213cee1bc6e9c8495dd705e1f"
+                    + "3d")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from NIST test vector 4")
+            .withKey(
+                "feffe9928665731c6d6a8f9467308308fffee8938764721d6c6b8e9566318209fcfdeb908467711e6f"
+                    + "688d96")
+            .withNonce("cafebabefacedbaddecaf888")
+            .withAad("feedfacedeadbeeffeedfacedeadbeefabaddad2")
+            .withPlaintext(
+                "d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532f"
+                    + "cf0e2449a6b525b16aedf5aa0de657ba637b39")
+            .withCiphertext(
+                "1018ed5a1402a86516d6576d70b2ffccca261b94df88b58f53b64dfba435d18b2f6e3b7869f9353d4a"
+                    + "c8cf09afb1663daa7b4017e6fc2c177c0c087c4764565d077e9124001ddb27fc0848c5")
+            .build(),
+        TestVector.builder()
+            .withComment(
+                "Derived from adapted NIST test vector 4"
+                    + " for KDF counter boundary (flip nonce bit 15)")
+            .withKey(
+                "feffe9928665731c6d6a8f9467308308fffee8938764721d6c6b8e9566318209fcfdeb908467711e6f"
+                    + "688d96")
+            .withNonce("ca7ebabefacedbaddecaf888")
+            .withAad("feedfacedeadbeeffeedfacedeadbeefabaddad2")
+            .withPlaintext(
+                "d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532f"
+                    + "cf0e2449a6b525b16aedf5aa0de657ba637b39")
+            .withCiphertext(
+                "e650d3c0fb879327f2d03287fa93cd07342b136215adbca00c3bd5099ec41832b1d18e0423ed26bb12"
+                    + "c6cd09debb29230a94c0cee15903656f85edb6fc509b1b28216382172ecbcc31e1e9b1")
+            .build(),
+        TestVector.builder()
+            .withComment(
+                "Derived from adapted NIST test vector 4"
+                    + " for KDF counter boundary (flip nonce bit 16)")
+            .withKey(
+                "feffe9928665731c6d6a8f9467308308fffee8938764721d6c6b8e9566318209fcfdeb908467711e6f"
+                    + "688d96")
+            .withNonce("cafebbbefacedbaddecaf888")
+            .withAad("feedfacedeadbeeffeedfacedeadbeefabaddad2")
+            .withPlaintext(
+                "d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532f"
+                    + "cf0e2449a6b525b16aedf5aa0de657ba637b39")
+            .withCiphertext(
+                "c0121e6c954d0767f96630c33450999791b2da2ad05c4190169ccad9ac86ff1c721e3d82f2ad22ab46"
+                    + "3bab4a0754b7dd68ca4de7ea2531b625eda01f89312b2ab957d5c7f8568dd95fcdcd1f")
+            .build(),
+        TestVector.builder()
+            .withComment(
+                "Derived from adapted NIST test vector 4"
+                    + " for KDF counter boundary (flip nonce bit 63)")
+            .withKey(
+                "feffe9928665731c6d6a8f9467308308fffee8938764721d6c6b8e9566318209fcfdeb908467711e6f"
+                    + "688d96")
+            .withNonce("cafebabefacedb2ddecaf888")
+            .withAad("feedfacedeadbeeffeedfacedeadbeefabaddad2")
+            .withPlaintext(
+                "d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532f"
+                    + "cf0e2449a6b525b16aedf5aa0de657ba637b39")
+            .withCiphertext(
+                "8af37ea5684a4d81d4fd817261fd9743099e7e6a025eaacf8e54b124fb5743149e05cb89f4a49467fe"
+                    + "2e5e5965f29a19f99416b0016b54585d12553783ba59e9f782e82e097c336bf7989f08")
+            .build(),
+        TestVector.builder()
+            .withComment(
+                "Derived from adapted NIST test vector 4"
+                    + " for KDF counter boundary (flip nonce bit 64)")
+            .withKey(
+                "feffe9928665731c6d6a8f9467308308fffee8938764721d6c6b8e9566318209fcfdeb908467711e6f"
+                    + "688d96")
+            .withNonce("cafebabefacedbaddfcaf888")
+            .withAad("feedfacedeadbeeffeedfacedeadbeefabaddad2")
+            .withPlaintext(
+                "d9313225f88406e5a55909c5aff5269a86a7a9531534f7da2e4c303d8a318a721c3c0c95956809532f"
+                    + "cf0e2449a6b525b16aedf5aa0de657ba637b39")
+            .withCiphertext(
+                "fbd528448d0346bfa878634864d407a35a039de9db2f1feb8e965b3ae9356ce6289441d77f8f0df294"
+                    + "891f37ea438b223e3bf2bdc53d4c5a74fb680bb312a8dec6f7252cbcd7f5799750ad78")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.1.1 54-byte auth")
+            .withKey(
+                "ad7a2bd03eac835a6f620fdcb506b345ac7b2ad13fad825b6e630eddb407b244af7829d23cae81586d"
+                    + "600dde")
+            .withNonce("12153524c0895e81b2c28465")
+            .withAad(
+                "d609b1f056637a0d46df998d88e5222ab2c2846512153524c0895e8108000f10111213141516171819"
+                    + "1a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233340001")
+            .withPlaintext("")
+            .withCiphertext("3ea0b584f3c85e93f9320ea591699efb")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.1.2 54-byte auth")
+            .withKey(
+                "e3c08a8f06c6e3ad95a70557b23f75483ce33021a9c72b7025666204c69c0b72e1c2888d04c4e1af97"
+                    + "a50755")
+            .withNonce("12153524c0895e81b2c28465")
+            .withAad(
+                "d609b1f056637a0d46df998d88e5222ab2c2846512153524c0895e8108000f10111213141516171819"
+                    + "1a1b1c1d1e1f202122232425262728292a2b2c2d2e2f30313233340001")
+            .withPlaintext("")
+            .withCiphertext("294e028bf1fe6f14c4e8f7305c933eb5")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.2.1 60-byte crypt")
+            .withKey(
+                "ad7a2bd03eac835a6f620fdcb506b345ac7b2ad13fad825b6e630eddb407b244af7829d23cae81586d"
+                    + "600dde")
+            .withNonce("12153524c0895e81b2c28465")
+            .withAad("d609b1f056637a0d46df998d88e52e00b2c2846512153524c0895e81")
+            .withPlaintext(
+                "08000f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435"
+                    + "363738393a0002")
+            .withCiphertext(
+                "db3d25719c6b0a3ca6145c159d5c6ed9aff9c6e0b79f17019ea923b8665ddf52137ad611f0d1bf417a"
+                    + "7ca85e45afe106ff9c7569d335d086ae6c03f00987ccd6")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.2.2 60-byte crypt")
+            .withKey(
+                "e3c08a8f06c6e3ad95a70557b23f75483ce33021a9c72b7025666204c69c0b72e1c2888d04c4e1af97"
+                    + "a50755")
+            .withNonce("12153524c0895e81b2c28465")
+            .withAad("d609b1f056637a0d46df998d88e52e00b2c2846512153524c0895e81")
+            .withPlaintext(
+                "08000f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435"
+                    + "363738393a0002")
+            .withCiphertext(
+                "1641f28ec13afcc8f7903389787201051644914933e9202bb9d06aa020c2a67ef51dfe7bc00a856c55"
+                    + "b8f8133e77f659132502bad63f5713d57d0c11e0f871ed")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.3.1 60-byte auth")
+            .withKey(
+                "071b113b0ca743fecccf3d051f737382061a103a0da642ffcdce3c041e727283051913390ea541fcce"
+                    + "cd3f07")
+            .withNonce("f0761e8dcd3d000176d457ed")
+            .withAad(
+                "e20106d7cd0df0761e8dcd3d88e5400076d457ed08000f101112131415161718191a1b1c1d1e1f2021"
+                    + "22232425262728292a2b2c2d2e2f303132333435363738393a0003")
+            .withPlaintext("")
+            .withCiphertext("58837a10562b0f1f8edbe58ca55811d3")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.3.2 60-byte auth")
+            .withKey(
+                "691d3ee909d7f54167fd1ca0b5d769081f2bde1aee655fdbab80bd5295ae6be76b1f3ceb0bd5f74365"
+                    + "ff1ea2")
+            .withNonce("f0761e8dcd3d000176d457ed")
+            .withAad(
+                "e20106d7cd0df0761e8dcd3d88e5400076d457ed08000f101112131415161718191a1b1c1d1e1f2021"
+                    + "22232425262728292a2b2c2d2e2f303132333435363738393a0003")
+            .withPlaintext("")
+            .withCiphertext("c2722ff6ca29a257718a529d1f0c6a3b")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.4.1 54-byte crypt")
+            .withKey(
+                "071b113b0ca743fecccf3d051f737382061a103a0da642ffcdce3c041e727283051913390ea541fcce"
+                    + "cd3f07")
+            .withNonce("f0761e8dcd3d000176d457ed")
+            .withAad("e20106d7cd0df0761e8dcd3d88e54c2a76d457ed")
+            .withPlaintext(
+                "08000f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333400"
+                    + "04")
+            .withCiphertext(
+                "fd96b715b93a13346af51e8acdf792cdc7b2686f8574c70e6b0cbf16291ded427ad73fec48cd298e05"
+                    + "28a1f4c644a949fc31dc9279706ddba33f")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.4.2 54-byte crypt")
+            .withKey(
+                "691d3ee909d7f54167fd1ca0b5d769081f2bde1aee655fdbab80bd5295ae6be76b1f3ceb0bd5f74365"
+                    + "ff1ea2")
+            .withNonce("f0761e8dcd3d000176d457ed")
+            .withAad("e20106d7cd0df0761e8dcd3d88e54c2a76d457ed")
+            .withPlaintext(
+                "08000f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333400"
+                    + "04")
+            .withCiphertext(
+                "b68f6300c2e9ae833bdc070e24021a3477118e78ccf84e11a485d861476c300f175353d5cdf92008a4"
+                    + "f878e6cc3577768085c50a0e98fda6cbb8")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.5.1 65-byte auth")
+            .withKey(
+                "013fe00b5f11be7f866d0cbbc55a7a90003ee10a5e10bf7e876c0dbac45b7b91033de2095d13bc7d84"
+                    + "6f0eb9")
+            .withNonce("7cfde9f9e33724c68932d612")
+            .withAad(
+                "84c5d513d2aaf6e5bbd2727788e523008932d6127cfde9f9e33724c608000f10111213141516171819"
+                    + "1a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
+                    + "0005")
+            .withPlaintext("")
+            .withCiphertext("cca20eecda6283f09bb3543dd99edb9b")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.5.2 65-byte auth")
+            .withKey(
+                "83c093b58de7ffe1c0da926ac43fb3609ac1c80fee1b624497ef942e2f79a82381c291b78fe5fde3c2"
+                    + "d89068")
+            .withNonce("7cfde9f9e33724c68932d612")
+            .withAad(
+                "84c5d513d2aaf6e5bbd2727788e523008932d6127cfde9f9e33724c608000f10111213141516171819"
+                    + "1a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
+                    + "0005")
+            .withPlaintext("")
+            .withCiphertext("b232cc1da5117bf15003734fa599d271")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE  2.6.1 61-byte crypt")
+            .withKey(
+                "013fe00b5f11be7f866d0cbbc55a7a90003ee10a5e10bf7e876c0dbac45b7b91033de2095d13bc7d84"
+                    + "6f0eb9")
+            .withNonce("7cfde9f9e33724c68932d612")
+            .withAad("84c5d513d2aaf6e5bbd2727788e52f008932d6127cfde9f9e33724c6")
+            .withPlaintext(
+                "08000f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435"
+                    + "363738393a3b0006")
+            .withCiphertext(
+                "ff1910d35ad7e5657890c7c560146fd038707f204b66edbc3d161f8ace244b985921023c436e3a1c35"
+                    + "32ecd5d09a056d70be583f0d10829d9387d07d33d872e490")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.6.2 61-byte crypt")
+            .withKey(
+                "83c093b58de7ffe1c0da926ac43fb3609ac1c80fee1b624497ef942e2f79a82381c291b78fe5fde3c2"
+                    + "d89068")
+            .withNonce("7cfde9f9e33724c68932d612")
+            .withAad("84c5d513d2aaf6e5bbd2727788e52f008932d6127cfde9f9e33724c6")
+            .withPlaintext(
+                "08000f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435"
+                    + "363738393a3b0006")
+            .withCiphertext(
+                "0db4cf956b5f97eca4eab82a6955307f9ae02a32dd7d93f83d66ad04e1cfdc5182ad12abdea5bbb619"
+                    + "a1bd5fb9a573590fba908e9c7a46c1f7ba0905d1b55ffda4")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.7.1 79-byte crypt")
+            .withKey(
+                "88ee087fd95da9fbf6725aa9d757b0cd89ef097ed85ca8faf7735ba8d656b1cc8aec0a7ddb5fabf9f4"
+                    + "7058ab")
+            .withNonce("7ae8e2ca4ec500012e58495c")
+            .withAad(
+                "68f2e77696ce7ae8e2ca4ec588e541002e58495c08000f101112131415161718191a1b1c1d1e1f2021"
+                    + "22232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344454647"
+                    + "48494a4b4c4d0007")
+            .withPlaintext("")
+            .withCiphertext("813f0e630f96fb2d030f58d83f5cdfd0")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.7.2 79-byte crypt")
+            .withKey(
+                "4c973dbc7364621674f8b5b89e5c15511fced9216490fb1c1a2caa0ffe0407e54e953fbe7166601476"
+                    + "fab7ba")
+            .withNonce("7ae8e2ca4ec500012e58495c")
+            .withAad(
+                "68f2e77696ce7ae8e2ca4ec588e541002e58495c08000f101112131415161718191a1b1c1d1e1f2021"
+                    + "22232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f4041424344454647"
+                    + "48494a4b4c4d0007")
+            .withPlaintext("")
+            .withCiphertext("77e5a44c21eb07188aacbd74d1980e97")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.8.1 61-byte crypt")
+            .withKey(
+                "88ee087fd95da9fbf6725aa9d757b0cd89ef097ed85ca8faf7735ba8d656b1cc8aec0a7ddb5fabf9f4"
+                    + "7058ab")
+            .withNonce("7ae8e2ca4ec500012e58495c")
+            .withAad("68f2e77696ce7ae8e2ca4ec588e54d002e58495c")
+            .withPlaintext(
+                "08000f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435"
+                    + "363738393a3b3c3d3e3f404142434445464748490008")
+            .withCiphertext(
+                "958ec3f6d60afeda99efd888f175e5fcd4c87b9bcc5c2f5426253a8b506296c8c43309ab2adb593946"
+                    + "2541d95e80811e04e706b1498f2c407c7fb234f8cc01a647550ee6b557b35a7e3945381821"
+                    + "f4")
+            .build(),
+        TestVector.builder()
+            .withComment("Derived from IEEE 2.8.2 61-byte crypt")
+            .withKey(
+                "4c973dbc7364621674f8b5b89e5c15511fced9216490fb1c1a2caa0ffe0407e54e953fbe7166601476"
+                    + "fab7ba")
+            .withNonce("7ae8e2ca4ec500012e58495c")
+            .withAad("68f2e77696ce7ae8e2ca4ec588e54d002e58495c")
+            .withPlaintext(
+                "08000f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435"
+                    + "363738393a3b3c3d3e3f404142434445464748490008")
+            .withCiphertext(
+                "b44d072011cd36d272a9b7a98db9aa90cbc5c67b93ddce67c854503214e2e896ec7e9db649ed4bcf6f"
+                    + "850aac0223d0cf92c83db80795c3a17ecc1248bb00591712b1ae71e268164196252162810b"
+                    + "00")
+            .build()
+      };
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsChannelCrypterTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsChannelCrypterTest.java
new file mode 100644
index 00000000000..0b40a8b31df
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsChannelCrypterTest.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.alts.internal.AltsChannelCrypter.incrementCounter;
+import static org.junit.Assert.fail;
+
+import com.google.common.testing.GcFinalization;
+import io.netty.util.ReferenceCounted;
+import io.netty.util.ResourceLeakDetector;
+import io.netty.util.ResourceLeakDetector.Level;
+import java.security.GeneralSecurityException;
+import java.util.Arrays;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AltsChannelCrypter}. */
+@RunWith(JUnit4.class)
+public final class AltsChannelCrypterTest extends ChannelCrypterNettyTestBase {
+
+  @Before
+  public void setUp() throws GeneralSecurityException {
+    ResourceLeakDetector.setLevel(Level.PARANOID);
+    client = new AltsChannelCrypter(new byte[AltsChannelCrypter.getKeyLength()], true);
+    server = new AltsChannelCrypter(new byte[AltsChannelCrypter.getKeyLength()], false);
+  }
+
+  @After
+  public void tearDown() throws GeneralSecurityException {
+    for (ReferenceCounted reference : references) {
+      reference.release();
+    }
+    references.clear();
+    client.destroy();
+    server.destroy();
+    // Increase our chances to detect ByteBuf leaks.
+    GcFinalization.awaitFullGc();
+  }
+
+  @Test
+  public void encryptDecryptKdfCounterIncr() throws GeneralSecurityException {
+    AltsChannelCrypter client =
+        new AltsChannelCrypter(new byte[AltsChannelCrypter.getKeyLength()], true);
+    AltsChannelCrypter server =
+        new AltsChannelCrypter(new byte[AltsChannelCrypter.getKeyLength()], false);
+
+    String message = "Hello world";
+    FrameEncrypt frameEncrypt1 = createFrameEncrypt(message);
+
+    client.encrypt(frameEncrypt1.out, frameEncrypt1.plain);
+    FrameDecrypt frameDecrypt1 = frameDecryptOfEncrypt(frameEncrypt1);
+
+    server.decrypt(frameDecrypt1.out, frameDecrypt1.tag, frameDecrypt1.ciphertext);
+    assertThat(frameEncrypt1.plain.get(0).slice(0, frameDecrypt1.out.readableBytes()))
+        .isEqualTo(frameDecrypt1.out);
+
+    // Increase counters to get a new KDF counter value (first two bytes are skipped).
+    client.incrementOutCounterForTesting(1 << 17);
+    server.incrementInCounterForTesting(1 << 17);
+
+    FrameEncrypt frameEncrypt2 = createFrameEncrypt(message);
+
+    client.encrypt(frameEncrypt2.out, frameEncrypt2.plain);
+    FrameDecrypt frameDecrypt2 = frameDecryptOfEncrypt(frameEncrypt2);
+
+    server.decrypt(frameDecrypt2.out, frameDecrypt2.tag, frameDecrypt2.ciphertext);
+    assertThat(frameEncrypt2.plain.get(0).slice(0, frameDecrypt2.out.readableBytes()))
+        .isEqualTo(frameDecrypt2.out);
+  }
+
+  @Test
+  public void overflowsClient() throws GeneralSecurityException {
+    byte[] maxFirst =
+        new byte[] {
+          (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+          (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+          (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00
+        };
+
+    byte[] maxFirstPred = Arrays.copyOf(maxFirst, maxFirst.length);
+    maxFirstPred[0]--;
+
+    byte[] oldCounter = new byte[AltsChannelCrypter.getCounterLength()];
+    byte[] counter = Arrays.copyOf(maxFirstPred, maxFirstPred.length);
+
+    incrementCounter(counter, oldCounter);
+
+    assertThat(oldCounter).isEqualTo(maxFirstPred);
+    assertThat(counter).isEqualTo(maxFirst);
+
+    try {
+      incrementCounter(counter, oldCounter);
+      fail("Exception expected");
+    } catch (GeneralSecurityException ex) {
+      assertThat(ex).hasMessageThat().contains("Counter has overflowed");
+    }
+
+    assertThat(oldCounter).isEqualTo(maxFirst);
+    assertThat(counter).isEqualTo(maxFirst);
+  }
+
+  @Test
+  public void overflowsServer() throws GeneralSecurityException {
+    byte[] maxSecond =
+        new byte[] {
+          (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+          (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+          (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x80
+        };
+
+    byte[] maxSecondPred = Arrays.copyOf(maxSecond, maxSecond.length);
+    maxSecondPred[0]--;
+
+    byte[] oldCounter = new byte[AltsChannelCrypter.getCounterLength()];
+    byte[] counter = Arrays.copyOf(maxSecondPred, maxSecondPred.length);
+
+    incrementCounter(counter, oldCounter);
+
+    assertThat(oldCounter).isEqualTo(maxSecondPred);
+    assertThat(counter).isEqualTo(maxSecond);
+
+    try {
+      incrementCounter(counter, oldCounter);
+      fail("Exception expected");
+    } catch (GeneralSecurityException ex) {
+      assertThat(ex).hasMessageThat().contains("Counter has overflowed");
+    }
+
+    assertThat(oldCounter).isEqualTo(maxSecond);
+    assertThat(counter).isEqualTo(maxSecond);
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsClientOptionsTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsClientOptionsTest.java
new file mode 100644
index 00000000000..45fac0aa301
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsClientOptionsTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AltsClientOptions}. */
+@RunWith(JUnit4.class)
+public final class AltsClientOptionsTest {
+
+  @Test
+  public void setAndGet() throws Exception {
+    String targetName = "foo";
+    String serviceAccount1 = "bar1";
+    String serviceAccount2 = "bar2";
+    RpcProtocolVersions rpcVersions =
+        RpcProtocolVersions.newBuilder()
+            .setMaxRpcVersion(
+                RpcProtocolVersions.Version.newBuilder().setMajor(2).setMinor(1).build())
+            .setMinRpcVersion(
+                RpcProtocolVersions.Version.newBuilder().setMajor(2).setMinor(1).build())
+            .build();
+    ImmutableList<String> serviceAccounts = ImmutableList.of(serviceAccount1, serviceAccount2);
+
+    AltsClientOptions options =
+        new AltsClientOptions.Builder()
+            .setTargetName(targetName)
+            .setTargetServiceAccounts(serviceAccounts)
+            .setRpcProtocolVersions(rpcVersions)
+            .build();
+
+    assertThat(options.getTargetName()).isEqualTo(targetName);
+    assertThat(options.getTargetServiceAccounts())
+        .containsAtLeast(serviceAccount1, serviceAccount2);
+    assertThat(options.getRpcProtocolVersions()).isEqualTo(rpcVersions);
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsFramingTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsFramingTest.java
new file mode 100644
index 00000000000..a4703e052ee
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsFramingTest.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.security.GeneralSecurityException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AltsFraming}. */
+@RunWith(JUnit4.class)
+public class AltsFramingTest {
+
+  @Test
+  public void parserFrameLengthNegativeFails() throws GeneralSecurityException {
+    AltsFraming.Parser parser = new AltsFraming.Parser();
+    // frame length + one remaining byte (required)
+    ByteBuffer buffer = ByteBuffer.allocate(AltsFraming.getFrameLengthHeaderSize() + 1);
+    buffer.order(ByteOrder.LITTLE_ENDIAN);
+    buffer.putInt(-1); // write invalid length
+    buffer.put((byte) 0); // write some byte
+    ((Buffer) buffer).flip();
+
+    try {
+      parser.readBytes(buffer);
+      fail("Exception expected");
+    } catch (IllegalArgumentException ex) {
+      assertThat(ex).hasMessageThat().contains("Invalid frame length");
+    }
+  }
+
+  @Test
+  public void parserFrameLengthSmallerMessageTypeFails() throws GeneralSecurityException {
+    AltsFraming.Parser parser = new AltsFraming.Parser();
+    // frame length + one remaining byte (required)
+    ByteBuffer buffer = ByteBuffer.allocate(AltsFraming.getFrameLengthHeaderSize() + 1);
+    buffer.order(ByteOrder.LITTLE_ENDIAN);
+    buffer.putInt(AltsFraming.getFrameMessageTypeHeaderSize() - 1); // write invalid length
+    buffer.put((byte) 0); // write some byte
+    ((Buffer) buffer).flip();
+
+    try {
+      parser.readBytes(buffer);
+      fail("Exception expected");
+    } catch (IllegalArgumentException ex) {
+      assertThat(ex).hasMessageThat().contains("Invalid frame length");
+    }
+  }
+
+  @Test
+  public void parserFrameLengthTooLargeFails() throws GeneralSecurityException {
+    AltsFraming.Parser parser = new AltsFraming.Parser();
+    // frame length + one remaining byte (required)
+    ByteBuffer buffer = ByteBuffer.allocate(AltsFraming.getFrameLengthHeaderSize() + 1);
+    buffer.order(ByteOrder.LITTLE_ENDIAN);
+    buffer.putInt(AltsFraming.getMaxDataLength() + 1); // write invalid length
+    buffer.put((byte) 0); // write some byte
+    ((Buffer) buffer).flip();
+
+    try {
+      parser.readBytes(buffer);
+      fail("Exception expected");
+    } catch (IllegalArgumentException ex) {
+      assertThat(ex).hasMessageThat().contains("Invalid frame length");
+    }
+  }
+
+  @Test
+  public void parserFrameLengthMaxOk() throws GeneralSecurityException {
+    AltsFraming.Parser parser = new AltsFraming.Parser();
+    // length of type header + data
+    int dataLength = AltsFraming.getMaxDataLength();
+    // complete frame + 1 byte
+    ByteBuffer buffer =
+        ByteBuffer.allocate(AltsFraming.getFrameLengthHeaderSize() + dataLength + 1);
+    buffer.order(ByteOrder.LITTLE_ENDIAN);
+    buffer.putInt(dataLength); // write invalid length
+    buffer.putInt(6); // default message type
+    buffer.put(new byte[dataLength - AltsFraming.getFrameMessageTypeHeaderSize()]); // write data
+    buffer.put((byte) 0);
+    ((Buffer) buffer).flip();
+
+    parser.readBytes(buffer);
+
+    assertThat(parser.isComplete()).isTrue();
+    assertThat(buffer.remaining()).isEqualTo(1);
+  }
+
+  @Test
+  public void parserFrameLengthZeroOk() throws GeneralSecurityException {
+    AltsFraming.Parser parser = new AltsFraming.Parser();
+    int dataLength = AltsFraming.getFrameMessageTypeHeaderSize();
+    // complete frame + 1 byte
+    ByteBuffer buffer =
+        ByteBuffer.allocate(AltsFraming.getFrameLengthHeaderSize() + dataLength + 1);
+    buffer.order(ByteOrder.LITTLE_ENDIAN);
+    buffer.putInt(dataLength); // write invalid length
+    buffer.putInt(6); // default message type
+    buffer.put((byte) 0);
+    ((Buffer) buffer).flip();
+
+    parser.readBytes(buffer);
+
+    assertThat(parser.isComplete()).isTrue();
+    assertThat(buffer.remaining()).isEqualTo(1);
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerClientTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerClientTest.java
new file mode 100644
index 00000000000..5a41fc0fc4f
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerClientTest.java
@@ -0,0 +1,280 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.ByteString;
+import io.grpc.internal.TestUtils.NoopChannelLogger;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+
+/** Unit tests for {@link AltsHandshakerClient}. */
+@RunWith(JUnit4.class)
+public class AltsHandshakerClientTest {
+  private static final int IN_BYTES_SIZE = 100;
+  private static final int BYTES_CONSUMED = 30;
+  private static final int PREFIX_POSITION = 20;
+  private static final String TEST_TARGET_NAME = "target name";
+  private static final String TEST_TARGET_SERVICE_ACCOUNT = "peer service account";
+
+  private AltsHandshakerStub mockStub;
+  private AltsHandshakerClient handshaker;
+  private AltsClientOptions clientOptions;
+
+  @Before
+  public void setUp() {
+    mockStub = mock(AltsHandshakerStub.class);
+    clientOptions =
+        new AltsClientOptions.Builder()
+            .setTargetName(TEST_TARGET_NAME)
+            .setTargetServiceAccounts(ImmutableList.of(TEST_TARGET_SERVICE_ACCOUNT))
+            .build();
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    handshaker = new AltsHandshakerClient(mockStub, clientOptions, channelLogger);
+  }
+
+  @Test
+  public void startClientHandshakeFailure() throws Exception {
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
+        .thenReturn(MockAltsHandshakerResp.getErrorResponse());
+
+    try {
+      handshaker.startClientHandshake();
+      fail("Exception expected");
+    } catch (GeneralSecurityException ex) {
+      assertThat(ex).hasMessageThat().contains(MockAltsHandshakerResp.getTestErrorDetails());
+    }
+  }
+
+  @Test
+  public void startClientHandshakeSuccess() throws Exception {
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
+        .thenReturn(MockAltsHandshakerResp.getOkResponse(0));
+
+    ByteBuffer outFrame = handshaker.startClientHandshake();
+
+    assertEquals(ByteString.copyFrom(outFrame), MockAltsHandshakerResp.getOutFrame());
+    assertFalse(handshaker.isFinished());
+    assertNull(handshaker.getResult());
+    assertNull(handshaker.getKey());
+  }
+
+  @Test
+  public void startClientHandshakeWithOptions() throws Exception {
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
+        .thenReturn(MockAltsHandshakerResp.getOkResponse(0));
+
+    ByteBuffer outFrame = handshaker.startClientHandshake();
+    assertEquals(ByteString.copyFrom(outFrame), MockAltsHandshakerResp.getOutFrame());
+
+    HandshakerReq req =
+        HandshakerReq.newBuilder()
+            .setClientStart(
+                StartClientHandshakeReq.newBuilder()
+                    .setHandshakeSecurityProtocol(HandshakeProtocol.ALTS)
+                    .addApplicationProtocols(AltsHandshakerClient.getApplicationProtocol())
+                    .addRecordProtocols(AltsHandshakerClient.getRecordProtocol())
+                    .setTargetName(TEST_TARGET_NAME)
+                    .addTargetIdentities(
+                        Identity.newBuilder().setServiceAccount(TEST_TARGET_SERVICE_ACCOUNT))
+                    .setMaxFrameSize(AltsTsiFrameProtector.getMaxFrameSize())
+                    .build())
+            .build();
+    verify(mockStub).send(req);
+  }
+
+  @Test
+  public void startServerHandshakeFailure() throws Exception {
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
+        .thenReturn(MockAltsHandshakerResp.getErrorResponse());
+
+    try {
+      ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
+      handshaker.startServerHandshake(inBytes);
+      fail("Exception expected");
+    } catch (GeneralSecurityException ex) {
+      assertThat(ex).hasMessageThat().contains(MockAltsHandshakerResp.getTestErrorDetails());
+    }
+  }
+
+  @Test
+  public void startServerHandshakeSuccess() throws Exception {
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
+        .thenReturn(MockAltsHandshakerResp.getOkResponse(BYTES_CONSUMED));
+
+    ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
+    ByteBuffer outFrame = handshaker.startServerHandshake(inBytes);
+
+    HandshakerReq req =
+        HandshakerReq.newBuilder()
+            .setServerStart(
+                StartServerHandshakeReq.newBuilder()
+                    .addApplicationProtocols(AltsHandshakerClient.getApplicationProtocol())
+                    .putHandshakeParameters(
+                      HandshakeProtocol.ALTS.getNumber(),
+                      ServerHandshakeParameters.newBuilder()
+                          .addRecordProtocols(AltsHandshakerClient.getRecordProtocol())
+                          .build())
+                    .setInBytes(ByteString.copyFrom(ByteBuffer.allocate(IN_BYTES_SIZE)))
+                    .setMaxFrameSize(AltsTsiFrameProtector.getMaxFrameSize())
+                    .build())
+            .build();
+    verify(mockStub).send(req);
+
+    assertEquals(ByteString.copyFrom(outFrame), MockAltsHandshakerResp.getOutFrame());
+    assertFalse(handshaker.isFinished());
+    assertNull(handshaker.getResult());
+    assertNull(handshaker.getKey());
+    assertEquals(IN_BYTES_SIZE - BYTES_CONSUMED, inBytes.remaining());
+  }
+
+  @Test
+  public void startServerHandshakeEmptyOutFrame() throws Exception {
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
+        .thenReturn(MockAltsHandshakerResp.getEmptyOutFrameResponse(BYTES_CONSUMED));
+
+    ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
+    ByteBuffer outFrame = handshaker.startServerHandshake(inBytes);
+
+    assertEquals(0, outFrame.remaining());
+    assertFalse(handshaker.isFinished());
+    assertNull(handshaker.getResult());
+    assertNull(handshaker.getKey());
+    assertEquals(IN_BYTES_SIZE - BYTES_CONSUMED, inBytes.remaining());
+  }
+
+  @Test
+  public void startServerHandshakeWithPrefixBuffer() throws Exception {
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
+        .thenReturn(MockAltsHandshakerResp.getOkResponse(BYTES_CONSUMED));
+
+    ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
+    ((Buffer) inBytes).position(PREFIX_POSITION);
+    ByteBuffer outFrame = handshaker.startServerHandshake(inBytes);
+
+    assertEquals(ByteString.copyFrom(outFrame), MockAltsHandshakerResp.getOutFrame());
+    assertFalse(handshaker.isFinished());
+    assertNull(handshaker.getResult());
+    assertNull(handshaker.getKey());
+    assertEquals(PREFIX_POSITION + BYTES_CONSUMED, inBytes.position());
+    assertEquals(IN_BYTES_SIZE - BYTES_CONSUMED - PREFIX_POSITION, inBytes.remaining());
+  }
+
+  @Test
+  public void nextFailure() throws Exception {
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
+        .thenReturn(MockAltsHandshakerResp.getErrorResponse());
+
+    try {
+      ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
+      handshaker.next(inBytes);
+      fail("Exception expected");
+    } catch (GeneralSecurityException ex) {
+      assertThat(ex).hasMessageThat().contains(MockAltsHandshakerResp.getTestErrorDetails());
+    }
+  }
+
+  @Test
+  public void nextSuccess() throws Exception {
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
+        .thenReturn(MockAltsHandshakerResp.getOkResponse(BYTES_CONSUMED));
+
+    ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
+    ByteBuffer outFrame = handshaker.next(inBytes);
+
+    assertEquals(ByteString.copyFrom(outFrame), MockAltsHandshakerResp.getOutFrame());
+    assertFalse(handshaker.isFinished());
+    assertNull(handshaker.getResult());
+    assertNull(handshaker.getKey());
+    assertEquals(IN_BYTES_SIZE - BYTES_CONSUMED, inBytes.remaining());
+  }
+
+  @Test
+  public void nextEmptyOutFrame() throws Exception {
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
+        .thenReturn(MockAltsHandshakerResp.getEmptyOutFrameResponse(BYTES_CONSUMED));
+
+    ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
+    ByteBuffer outFrame = handshaker.next(inBytes);
+
+    assertEquals(0, outFrame.remaining());
+    assertFalse(handshaker.isFinished());
+    assertNull(handshaker.getResult());
+    assertNull(handshaker.getKey());
+    assertEquals(IN_BYTES_SIZE - BYTES_CONSUMED, inBytes.remaining());
+  }
+
+  @Test
+  public void nextFinished() throws Exception {
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
+        .thenReturn(MockAltsHandshakerResp.getFinishedResponse(BYTES_CONSUMED));
+
+    ByteBuffer inBytes = ByteBuffer.allocate(IN_BYTES_SIZE);
+    ByteBuffer outFrame = handshaker.next(inBytes);
+
+    assertEquals(ByteString.copyFrom(outFrame), MockAltsHandshakerResp.getOutFrame());
+    assertTrue(handshaker.isFinished());
+    assertArrayEquals(handshaker.getKey(), MockAltsHandshakerResp.getTestKeyData());
+    assertEquals(IN_BYTES_SIZE - BYTES_CONSUMED, inBytes.remaining());
+  }
+
+  @Test
+  public void setRpcVersions() throws Exception {
+    when(mockStub.send(ArgumentMatchers.<HandshakerReq>any()))
+        .thenReturn(MockAltsHandshakerResp.getOkResponse(0));
+
+    RpcProtocolVersions rpcVersions =
+        RpcProtocolVersions.newBuilder()
+            .setMinRpcVersion(
+                RpcProtocolVersions.Version.newBuilder().setMajor(3).setMinor(4).build())
+            .setMaxRpcVersion(
+                RpcProtocolVersions.Version.newBuilder().setMajor(5).setMinor(6).build())
+            .build();
+    clientOptions =
+        new AltsClientOptions.Builder()
+            .setTargetName(TEST_TARGET_NAME)
+            .setTargetServiceAccounts(ImmutableList.of(TEST_TARGET_SERVICE_ACCOUNT))
+            .setRpcProtocolVersions(rpcVersions)
+            .build();
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    handshaker = new AltsHandshakerClient(mockStub, clientOptions, channelLogger);
+
+    handshaker.startClientHandshake();
+
+    ArgumentCaptor<HandshakerReq> reqCaptor = ArgumentCaptor.forClass(HandshakerReq.class);
+    verify(mockStub).send(reqCaptor.capture());
+    assertEquals(rpcVersions, reqCaptor.getValue().getClientStart().getRpcVersions());
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerOptionsTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerOptionsTest.java
new file mode 100644
index 00000000000..ab065f2f2ef
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerOptionsTest.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AltsHandshakerOptions}. */
+@RunWith(JUnit4.class)
+public final class AltsHandshakerOptionsTest {
+
+  @Test
+  public void setAndGet() throws Exception {
+    RpcProtocolVersions rpcVersions =
+        RpcProtocolVersions.newBuilder()
+            .setMaxRpcVersion(
+                RpcProtocolVersions.Version.newBuilder().setMajor(2).setMinor(1).build())
+            .setMinRpcVersion(
+                RpcProtocolVersions.Version.newBuilder().setMajor(2).setMinor(1).build())
+            .build();
+
+    AltsHandshakerOptions options = new AltsHandshakerOptions(rpcVersions);
+    assertThat(options.getRpcProtocolVersions()).isEqualTo(rpcVersions);
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerStubTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerStubTest.java
new file mode 100644
index 00000000000..7a6018b5064
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsHandshakerStubTest.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import com.google.protobuf.ByteString;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AltsHandshakerStub}. */
+@RunWith(JUnit4.class)
+public class AltsHandshakerStubTest {
+  /** Mock status of handshaker service. */
+  private enum Status {
+    OK,
+    ERROR,
+    COMPLETE
+  }
+
+  private AltsHandshakerStub stub;
+  private MockWriter writer;
+
+  @Before
+  public void setUp() {
+    writer = new MockWriter();
+    stub = new AltsHandshakerStub(writer);
+    writer.setReader(stub.getReaderForTest());
+  }
+
+  /** Send a message as in_bytes and expect same message as out_frames echo back. */
+  private void sendSuccessfulMessage() throws Exception {
+    String message = "hello world";
+    HandshakerReq.Builder req =
+        HandshakerReq.newBuilder()
+            .setNext(
+                NextHandshakeMessageReq.newBuilder()
+                    .setInBytes(ByteString.copyFromUtf8(message))
+                    .build());
+    HandshakerResp resp = stub.send(req.build());
+    assertEquals(resp.getOutFrames().toStringUtf8(), message);
+  }
+
+  /** Send a message and expect an IOException on error. */
+  private void sendAndExpectError() throws InterruptedException {
+    try {
+      stub.send(HandshakerReq.newBuilder().build());
+      fail("Exception expected");
+    } catch (IOException ex) {
+      assertThat(ex).hasMessageThat().contains("Received a terminating error");
+      assertThat(ex.getCause()).hasMessageThat().contains("Root cause message");
+    }
+  }
+
+  /** Send a message and expect an IOException on closing. */
+  private void sendAndExpectComplete() throws InterruptedException {
+    try {
+      stub.send(HandshakerReq.newBuilder().build());
+      fail("Exception expected");
+    } catch (IOException ex) {
+      assertThat(ex).hasMessageThat().contains("Response stream closed");
+    }
+  }
+
+  /** Send a message and expect an IOException on unexpected message. */
+  private void sendAndExpectUnexpectedMessage() throws InterruptedException {
+    try {
+      stub.send(HandshakerReq.newBuilder().build());
+      fail("Exception expected");
+    } catch (IOException ex) {
+      assertThat(ex).hasMessageThat().contains("Received an unexpected response");
+    }
+  }
+
+  @Test
+  public void sendSuccessfulMessageTest() throws Exception {
+    writer.setServiceStatus(Status.OK);
+    sendSuccessfulMessage();
+    stub.close();
+  }
+
+  @Test
+  public void getServiceErrorTest() throws InterruptedException {
+    writer.setServiceStatus(Status.ERROR);
+    sendAndExpectError();
+    stub.close();
+  }
+
+  @Test
+  public void getServiceCompleteTest() throws Exception {
+    writer.setServiceStatus(Status.COMPLETE);
+    sendAndExpectComplete();
+    stub.close();
+  }
+
+  @Test
+  public void getUnexpectedMessageTest() throws Exception {
+    writer.setServiceStatus(Status.OK);
+    writer.sendUnexpectedResponse();
+    sendAndExpectUnexpectedMessage();
+    stub.close();
+  }
+
+  @Test
+  public void closeEarlyTest() throws InterruptedException {
+    stub.close();
+    sendAndExpectComplete();
+  }
+
+  private static class MockWriter implements StreamObserver<HandshakerReq> {
+    private StreamObserver<HandshakerResp> reader;
+    private Status status = Status.OK;
+
+    private void setReader(StreamObserver<HandshakerResp> reader) {
+      this.reader = reader;
+    }
+
+    private void setServiceStatus(Status status) {
+      this.status = status;
+    }
+
+    /** Send a handshaker response to reader. */
+    private void sendUnexpectedResponse() {
+      reader.onNext(HandshakerResp.newBuilder().build());
+    }
+
+    /** Mock writer onNext. Will respond based on the server status. */
+    @Override
+    public void onNext(final HandshakerReq req) {
+      switch (status) {
+        case OK:
+          HandshakerResp.Builder resp = HandshakerResp.newBuilder();
+          reader.onNext(resp.setOutFrames(req.getNext().getInBytes()).build());
+          break;
+        case ERROR:
+          reader.onError(new RuntimeException("Root cause message"));
+          break;
+        case COMPLETE:
+          reader.onCompleted();
+          break;
+        default:
+          return;
+      }
+    }
+
+    @Override
+    public void onError(Throwable t) {}
+
+    /** Mock writer onComplete. */
+    @Override
+    public void onCompleted() {
+      reader.onCompleted();
+    }
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsInternalContextTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsInternalContextTest.java
new file mode 100644
index 00000000000..87898a3300b
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsInternalContextTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AltsInternalContext}. */
+@RunWith(JUnit4.class)
+public final class AltsInternalContextTest {
+  private static final int TEST_MAX_RPC_VERSION_MAJOR = 3;
+  private static final int TEST_MAX_RPC_VERSION_MINOR = 5;
+  private static final int TEST_MIN_RPC_VERSION_MAJOR = 2;
+  private static final int TEST_MIN_RPC_VERSION_MINOR = 1;
+  private static final SecurityLevel TEST_SECURITY_LEVEL = SecurityLevel.INTEGRITY_AND_PRIVACY;
+  private static final String TEST_APPLICATION_PROTOCOL = "grpc";
+  private static final String TEST_LOCAL_SERVICE_ACCOUNT = "local@gserviceaccount.com";
+  private static final String TEST_PEER_SERVICE_ACCOUNT = "peer@gserviceaccount.com";
+  private static final String TEST_RECORD_PROTOCOL = "ALTSRP_GCM_AES128";
+  private static final String TEST_PEER_ATTRIBUTES_KEY = "peer";
+  private static final String TEST_PEER_ATTRIBUTES_VALUE = "attributes";
+
+  private Map<String, String> testPeerAttributes;
+  private HandshakerResult handshakerResult;
+  private RpcProtocolVersions rpcVersions;
+
+  @Before
+  public void setUp() {
+    testPeerAttributes = new HashMap<String, String>();
+    testPeerAttributes.put(TEST_PEER_ATTRIBUTES_KEY, TEST_PEER_ATTRIBUTES_VALUE);
+    rpcVersions =
+        RpcProtocolVersions.newBuilder()
+            .setMaxRpcVersion(
+                RpcProtocolVersions.Version.newBuilder()
+                    .setMajor(TEST_MAX_RPC_VERSION_MAJOR)
+                    .setMinor(TEST_MAX_RPC_VERSION_MINOR)
+                    .build())
+            .setMinRpcVersion(
+                RpcProtocolVersions.Version.newBuilder()
+                    .setMajor(TEST_MIN_RPC_VERSION_MAJOR)
+                    .setMinor(TEST_MIN_RPC_VERSION_MINOR)
+                    .build())
+            .build();
+    Identity.Builder peerIdentity = Identity.newBuilder()
+        .setServiceAccount(TEST_PEER_SERVICE_ACCOUNT);
+    peerIdentity.putAllAttributes(testPeerAttributes);
+    handshakerResult =
+        HandshakerResult.newBuilder()
+            .setApplicationProtocol(TEST_APPLICATION_PROTOCOL)
+            .setRecordProtocol(TEST_RECORD_PROTOCOL)
+            .setPeerIdentity(peerIdentity)
+            .setLocalIdentity(Identity.newBuilder().setServiceAccount(TEST_LOCAL_SERVICE_ACCOUNT))
+            .setPeerRpcVersions(rpcVersions)
+            .build();
+  }
+
+  @Test
+  public void testAltsInternalContext() {
+    AltsInternalContext context = new AltsInternalContext(handshakerResult);
+    assertEquals(TEST_APPLICATION_PROTOCOL, context.getApplicationProtocol());
+    assertEquals(TEST_RECORD_PROTOCOL, context.getRecordProtocol());
+    assertEquals(TEST_SECURITY_LEVEL, context.getSecurityLevel());
+    assertEquals(TEST_PEER_SERVICE_ACCOUNT, context.getPeerServiceAccount());
+    assertEquals(TEST_LOCAL_SERVICE_ACCOUNT, context.getLocalServiceAccount());
+    assertEquals(rpcVersions, context.getPeerRpcVersions());
+    assertEquals(testPeerAttributes, context.getPeerAttributes());
+    assertEquals(TEST_PEER_ATTRIBUTES_VALUE, context.getPeerAttributes()
+        .get(TEST_PEER_ATTRIBUTES_KEY));
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsProtocolNegotiatorTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsProtocolNegotiatorTest.java
new file mode 100644
index 00000000000..24392af75fd
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsProtocolNegotiatorTest.java
@@ -0,0 +1,559 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import io.grpc.Attributes;
+import io.grpc.Channel;
+import io.grpc.ChannelLogger;
+import io.grpc.Grpc;
+import io.grpc.InternalChannelz;
+import io.grpc.ManagedChannel;
+import io.grpc.SecurityLevel;
+import io.grpc.alts.internal.AltsProtocolNegotiator.LazyChannel;
+import io.grpc.alts.internal.AltsProtocolNegotiator.ServerAltsProtocolNegotiator;
+import io.grpc.alts.internal.TsiFrameProtector.Consumer;
+import io.grpc.alts.internal.TsiPeer.Property;
+import io.grpc.internal.FixedObjectPool;
+import io.grpc.internal.GrpcAttributes;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.TestUtils.NoopChannelLogger;
+import io.grpc.netty.GrpcHttp2ConnectionHandler;
+import io.grpc.netty.InternalProtocolNegotiationEvent;
+import io.grpc.netty.NettyChannelBuilder;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.CompositeByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.embedded.EmbeddedChannel;
+import io.netty.handler.codec.http2.DefaultHttp2Connection;
+import io.netty.handler.codec.http2.DefaultHttp2ConnectionDecoder;
+import io.netty.handler.codec.http2.DefaultHttp2ConnectionEncoder;
+import io.netty.handler.codec.http2.DefaultHttp2FrameReader;
+import io.netty.handler.codec.http2.DefaultHttp2FrameWriter;
+import io.netty.handler.codec.http2.Http2Connection;
+import io.netty.handler.codec.http2.Http2ConnectionDecoder;
+import io.netty.handler.codec.http2.Http2ConnectionEncoder;
+import io.netty.handler.codec.http2.Http2FrameReader;
+import io.netty.handler.codec.http2.Http2FrameWriter;
+import io.netty.handler.codec.http2.Http2Settings;
+import io.netty.util.ReferenceCountUtil;
+import io.netty.util.ReferenceCounted;
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link AltsProtocolNegotiator}. */
+@RunWith(JUnit4.class)
+@SuppressWarnings("FutureReturnValueIgnored")
+public class AltsProtocolNegotiatorTest {
+
+  private final CapturingGrpcHttp2ConnectionHandler grpcHandler = capturingGrpcHandler();
+
+  private final List<ReferenceCounted> references = new ArrayList<>();
+  private final LinkedBlockingQueue<InterceptingProtector> protectors = new LinkedBlockingQueue<>();
+
+  private EmbeddedChannel channel;
+  private Throwable caughtException;
+
+  private TsiPeer mockedTsiPeer = new TsiPeer(Collections.<Property<?>>emptyList());
+  private AltsInternalContext mockedAltsContext =
+      new AltsInternalContext(
+          HandshakerResult.newBuilder()
+              .setPeerRpcVersions(RpcProtocolVersionsUtil.getRpcProtocolVersions())
+              .build());
+  private final TsiHandshaker mockHandshaker =
+      new DelegatingTsiHandshaker(FakeTsiHandshaker.newFakeHandshakerServer()) {
+        @Override
+        public TsiPeer extractPeer() {
+          return mockedTsiPeer;
+        }
+
+        @Override
+        public Object extractPeerObject() {
+          return mockedAltsContext;
+        }
+      };
+  private final NettyTsiHandshaker serverHandshaker = new NettyTsiHandshaker(mockHandshaker);
+
+  @Before
+  public void setup() throws Exception {
+    ChannelHandler uncaughtExceptionHandler =
+        new ChannelDuplexHandler() {
+          @Override
+          public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+            caughtException = cause;
+            super.exceptionCaught(ctx, cause);
+            ctx.close();
+          }
+        };
+
+    TsiHandshakerFactory handshakerFactory =
+        new DelegatingTsiHandshakerFactory(FakeTsiHandshaker.clientHandshakerFactory()) {
+          @Override
+          public TsiHandshaker newHandshaker(String authority, ChannelLogger logger) {
+            return new DelegatingTsiHandshaker(super.newHandshaker(authority, logger)) {
+              @Override
+              public TsiPeer extractPeer() throws GeneralSecurityException {
+                return mockedTsiPeer;
+              }
+
+              @Override
+              public Object extractPeerObject() throws GeneralSecurityException {
+                return mockedAltsContext;
+              }
+            };
+          }
+        };
+    ManagedChannel fakeChannel = NettyChannelBuilder.forTarget("localhost:8080").build();
+    ObjectPool<Channel> fakeChannelPool = new FixedObjectPool<Channel>(fakeChannel);
+    LazyChannel lazyFakeChannel = new LazyChannel(fakeChannelPool);
+    ChannelHandler altsServerHandler = new ServerAltsProtocolNegotiator(
+        handshakerFactory, lazyFakeChannel)
+        .newHandler(grpcHandler);
+    // On real server, WBAEH fires default ProtocolNegotiationEvent. KickNH provides this behavior.
+    ChannelHandler handler = new KickNegotiationHandler(altsServerHandler);
+    channel = new EmbeddedChannel(uncaughtExceptionHandler, handler);
+  }
+
+  @After
+  public void teardown() throws Exception {
+    if (channel != null) {
+      @SuppressWarnings("unused") // go/futurereturn-lsc
+      Future<?> possiblyIgnoredError = channel.close();
+    }
+
+    for (ReferenceCounted reference : references) {
+      ReferenceCountUtil.safeRelease(reference);
+    }
+  }
+
+  @Test
+  public void handshakeShouldBeSuccessful() throws Exception {
+    doHandshake();
+  }
+
+  @Test
+  @SuppressWarnings("unchecked") // List cast
+  public void protectShouldRoundtrip() throws Exception {
+    doHandshake();
+
+    // Write the message 1 character at a time. The message should be buffered
+    // and not interfere with the handshake.
+    final AtomicInteger writeCount = new AtomicInteger();
+    String message = "hello";
+    for (int ix = 0; ix < message.length(); ++ix) {
+      ByteBuf in = Unpooled.copiedBuffer(message, ix, 1, UTF_8);
+      @SuppressWarnings("unused") // go/futurereturn-lsc
+      Future<?> possiblyIgnoredError =
+          channel
+              .write(in)
+              .addListener(
+                  new ChannelFutureListener() {
+                    @Override
+                    public void operationComplete(ChannelFuture future) throws Exception {
+                      if (future.isSuccess()) {
+                        writeCount.incrementAndGet();
+                      }
+                    }
+                  });
+    }
+    channel.flush();
+
+    // Capture the protected data written to the wire.
+    assertEquals(1, channel.outboundMessages().size());
+    ByteBuf protectedData = channel.readOutbound();
+    assertEquals(message.length(), writeCount.get());
+
+    // Read the protected message at the server and verify it matches the original message.
+    TsiFrameProtector serverProtector = serverHandshaker.createFrameProtector(channel.alloc());
+    List<ByteBuf> unprotected = new ArrayList<>();
+    serverProtector.unprotect(protectedData, (List<Object>) (List<?>) unprotected, channel.alloc());
+    // We try our best to remove the HTTP2 handler as soon as possible, but just by constructing it
+    // a settings frame is written (and an HTTP2 preface).  This is hard coded into Netty, so we
+    // have to remove it here.  See {@code Http2ConnectionHandler.PrefaceDecode.sendPreface}.
+    int settingsFrameLength = 9;
+
+    CompositeByteBuf unprotectedAll =
+        new CompositeByteBuf(channel.alloc(), false, unprotected.size() + 1, unprotected);
+    ByteBuf unprotectedData = unprotectedAll.slice(settingsFrameLength, message.length());
+    assertEquals(message, unprotectedData.toString(UTF_8));
+
+    // Protect the same message at the server.
+    final AtomicReference<ByteBuf> newlyProtectedData = new AtomicReference<>();
+    serverProtector.protectFlush(
+        Collections.singletonList(unprotectedData),
+        new Consumer<ByteBuf>() {
+          @Override
+          public void accept(ByteBuf buf) {
+            newlyProtectedData.set(buf);
+          }
+        },
+        channel.alloc());
+
+    // Read the protected message at the client and verify that it matches the original message.
+    channel.writeInbound(newlyProtectedData.get());
+    assertEquals(1, channel.inboundMessages().size());
+    assertEquals(message, channel.<ByteBuf>readInbound().toString(UTF_8));
+  }
+
+  @Test
+  public void unprotectLargeIncomingFrame() throws Exception {
+
+    // We use a server frameprotector with twice the standard frame size.
+    int serverFrameSize = 4096 * 2;
+    // This should fit into one frame.
+    byte[] unprotectedBytes = new byte[serverFrameSize - 500];
+    Arrays.fill(unprotectedBytes, (byte) 7);
+    ByteBuf unprotectedData = Unpooled.wrappedBuffer(unprotectedBytes);
+    unprotectedData.writerIndex(unprotectedBytes.length);
+
+    // Perform handshake.
+    doHandshake();
+
+    // Protect the message on the server.
+    TsiFrameProtector serverProtector =
+        serverHandshaker.createFrameProtector(serverFrameSize, channel.alloc());
+    serverProtector.protectFlush(
+        Collections.singletonList(unprotectedData),
+        new Consumer<ByteBuf>() {
+          @Override
+          public void accept(ByteBuf buf) {
+            channel.writeInbound(buf);
+          }
+        },
+        channel.alloc());
+    channel.flushInbound();
+
+    // Read the protected message at the client and verify that it matches the original message.
+    assertEquals(1, channel.inboundMessages().size());
+
+    ByteBuf receivedData1 = channel.readInbound();
+    int receivedLen1 = receivedData1.readableBytes();
+    byte[] receivedBytes = new byte[receivedLen1];
+    receivedData1.readBytes(receivedBytes, 0, receivedLen1);
+
+    assertThat(unprotectedBytes.length).isEqualTo(receivedBytes.length);
+    assertThat(unprotectedBytes).isEqualTo(receivedBytes);
+  }
+
+  @Test
+  public void flushShouldFailAllPromises() throws Exception {
+    doHandshake();
+
+    channel
+        .pipeline()
+        .addFirst(
+            new ChannelDuplexHandler() {
+              @Override
+              public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
+                  throws Exception {
+                throw new Exception("Fake exception");
+              }
+            });
+
+    // Write the message 1 character at a time.
+    String message = "hello";
+    final AtomicInteger failures = new AtomicInteger();
+    for (int ix = 0; ix < message.length(); ++ix) {
+      ByteBuf in = Unpooled.copiedBuffer(message, ix, 1, UTF_8);
+      @SuppressWarnings("unused") // go/futurereturn-lsc
+      Future<?> possiblyIgnoredError =
+          channel
+              .write(in)
+              .addListener(
+                  new ChannelFutureListener() {
+                    @Override
+                    public void operationComplete(ChannelFuture future) throws Exception {
+                      if (!future.isSuccess()) {
+                        failures.incrementAndGet();
+                      }
+                    }
+                  });
+    }
+    channel.flush();
+
+    // Verify that the promises fail.
+    assertEquals(message.length(), failures.get());
+  }
+
+  @Test
+  public void doNotFlushEmptyBuffer() throws Exception {
+    doHandshake();
+    assertEquals(1, protectors.size());
+    InterceptingProtector protector = protectors.poll();
+
+    String message = "hello";
+    ByteBuf in = Unpooled.copiedBuffer(message, UTF_8);
+
+    assertEquals(0, protector.flushes.get());
+    Future<?> done = channel.write(in);
+    channel.flush();
+    done.get(5, TimeUnit.SECONDS);
+    assertEquals(1, protector.flushes.get());
+
+    done = channel.write(Unpooled.EMPTY_BUFFER);
+    channel.flush();
+    done.get(5, TimeUnit.SECONDS);
+    assertEquals(1, protector.flushes.get());
+  }
+
+  @Test
+  public void peerPropagated() throws Exception {
+    doHandshake();
+
+    assertThat(grpcHandler.attrs.get(AltsProtocolNegotiator.TSI_PEER_KEY)).isEqualTo(mockedTsiPeer);
+    assertThat(grpcHandler.attrs.get(AltsProtocolNegotiator.AUTH_CONTEXT_KEY))
+        .isEqualTo(mockedAltsContext);
+    assertThat(grpcHandler.attrs.get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR).toString())
+        .isEqualTo("embedded");
+    assertThat(grpcHandler.attrs.get(Grpc.TRANSPORT_ATTR_LOCAL_ADDR).toString())
+        .isEqualTo("embedded");
+    assertThat(grpcHandler.attrs.get(GrpcAttributes.ATTR_SECURITY_LEVEL))
+        .isEqualTo(SecurityLevel.PRIVACY_AND_INTEGRITY);
+  }
+
+  @Test
+  public void getAltsMaxConcurrentHandshakes_success() throws Exception {
+    assertThat(AltsProtocolNegotiator.getAltsMaxConcurrentHandshakes("10")).isEqualTo(10);
+  }
+
+  @Test
+  public void getAltsMaxConcurrentHandshakes_envVariableNotSet() throws Exception {
+    assertThat(AltsProtocolNegotiator.getAltsMaxConcurrentHandshakes(null))
+        .isEqualTo(AltsProtocolNegotiator.DEFAULT_ALTS_MAX_CONCURRENT_HANDSHAKES);
+  }
+
+  @Test
+  public void getAltsMaxConcurrentHandshakes_envVariableNotANumber() throws Exception {
+    assertThat(AltsProtocolNegotiator.getAltsMaxConcurrentHandshakes("not-a-number"))
+        .isEqualTo(AltsProtocolNegotiator.DEFAULT_ALTS_MAX_CONCURRENT_HANDSHAKES);
+  }
+
+  @Test
+  public void getAltsMaxConcurrentHandshakes_envVariableNegative() throws Exception {
+    assertThat(AltsProtocolNegotiator.getAltsMaxConcurrentHandshakes("-10"))
+        .isEqualTo(AltsProtocolNegotiator.DEFAULT_ALTS_MAX_CONCURRENT_HANDSHAKES);
+  }
+
+  private void doHandshake() throws Exception {
+    // Capture the client frame and add to the server.
+    assertEquals(1, channel.outboundMessages().size());
+    ByteBuf clientFrame = channel.readOutbound();
+    assertTrue(serverHandshaker.processBytesFromPeer(clientFrame));
+
+    // Get the server response handshake frames.
+    ByteBuf serverFrame = channel.alloc().buffer();
+    serverHandshaker.getBytesToSendToPeer(serverFrame);
+    channel.writeInbound(serverFrame);
+
+    // Capture the next client frame and add to the server.
+    assertEquals(1, channel.outboundMessages().size());
+    clientFrame = channel.readOutbound();
+    assertTrue(serverHandshaker.processBytesFromPeer(clientFrame));
+
+    // Get the server response handshake frames.
+    serverFrame = channel.alloc().buffer();
+    serverHandshaker.getBytesToSendToPeer(serverFrame);
+    channel.writeInbound(serverFrame);
+
+    // Ensure that both sides have confirmed that the handshake has completed.
+    assertFalse(serverHandshaker.isInProgress());
+
+    if (caughtException != null) {
+      throw new RuntimeException(caughtException);
+    }
+    assertNotNull(grpcHandler.attrs);
+  }
+
+  private CapturingGrpcHttp2ConnectionHandler capturingGrpcHandler() {
+    // Netty Boilerplate.  We don't really need any of this, but there is a tight coupling
+    // between an Http2ConnectionHandler and its dependencies.
+    Http2Connection connection = new DefaultHttp2Connection(true);
+    Http2FrameWriter frameWriter = new DefaultHttp2FrameWriter();
+    Http2FrameReader frameReader = new DefaultHttp2FrameReader(false);
+    DefaultHttp2ConnectionEncoder encoder =
+        new DefaultHttp2ConnectionEncoder(connection, frameWriter);
+    DefaultHttp2ConnectionDecoder decoder =
+        new DefaultHttp2ConnectionDecoder(connection, encoder, frameReader);
+
+    return new CapturingGrpcHttp2ConnectionHandler(decoder, encoder, new Http2Settings());
+  }
+
+  private final class CapturingGrpcHttp2ConnectionHandler extends GrpcHttp2ConnectionHandler {
+
+    private Attributes attrs;
+
+    private CapturingGrpcHttp2ConnectionHandler(
+        Http2ConnectionDecoder decoder,
+        Http2ConnectionEncoder encoder,
+        Http2Settings initialSettings) {
+      super(null, decoder, encoder, initialSettings, new NoopChannelLogger());
+    }
+
+    @Override
+    public void handleProtocolNegotiationCompleted(
+        Attributes attrs,
+        @SuppressWarnings("UnusedVariable") InternalChannelz.Security securityInfo) {
+      // If we are added to the pipeline, we need to remove ourselves.  The HTTP2 handler
+      channel.pipeline().remove(this);
+      this.attrs = attrs;
+    }
+  }
+
+  private static class DelegatingTsiHandshakerFactory implements TsiHandshakerFactory {
+
+    private TsiHandshakerFactory delegate;
+
+    DelegatingTsiHandshakerFactory(TsiHandshakerFactory delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    public TsiHandshaker newHandshaker(String authority, ChannelLogger logger) {
+      return delegate.newHandshaker(authority, logger);
+    }
+  }
+
+  private class DelegatingTsiHandshaker implements TsiHandshaker {
+
+    private final TsiHandshaker delegate;
+
+    DelegatingTsiHandshaker(TsiHandshaker delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    public void getBytesToSendToPeer(ByteBuffer bytes) throws GeneralSecurityException {
+      delegate.getBytesToSendToPeer(bytes);
+    }
+
+    @Override
+    public boolean processBytesFromPeer(ByteBuffer bytes) throws GeneralSecurityException {
+      return delegate.processBytesFromPeer(bytes);
+    }
+
+    @Override
+    public boolean isInProgress() {
+      return delegate.isInProgress();
+    }
+
+    @Override
+    public TsiPeer extractPeer() throws GeneralSecurityException {
+      return delegate.extractPeer();
+    }
+
+    @Override
+    public Object extractPeerObject() throws GeneralSecurityException {
+      return delegate.extractPeerObject();
+    }
+
+    @Override
+    public TsiFrameProtector createFrameProtector(ByteBufAllocator alloc) {
+      InterceptingProtector protector =
+          new InterceptingProtector(delegate.createFrameProtector(alloc));
+      protectors.add(protector);
+      return protector;
+    }
+
+    @Override
+    public TsiFrameProtector createFrameProtector(int maxFrameSize, ByteBufAllocator alloc) {
+      InterceptingProtector protector =
+          new InterceptingProtector(delegate.createFrameProtector(maxFrameSize, alloc));
+      protectors.add(protector);
+      return protector;
+    }
+
+    @Override
+    public void close() {
+      delegate.close();
+    }
+  }
+
+  private static class InterceptingProtector implements TsiFrameProtector {
+
+    private final TsiFrameProtector delegate;
+    final AtomicInteger flushes = new AtomicInteger();
+
+    InterceptingProtector(TsiFrameProtector delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    public void protectFlush(
+        List<ByteBuf> unprotectedBufs, Consumer<ByteBuf> ctxWrite, ByteBufAllocator alloc)
+        throws GeneralSecurityException {
+      flushes.incrementAndGet();
+      delegate.protectFlush(unprotectedBufs, ctxWrite, alloc);
+    }
+
+    @Override
+    public void unprotect(ByteBuf in, List<Object> out, ByteBufAllocator alloc)
+        throws GeneralSecurityException {
+      delegate.unprotect(in, out, alloc);
+    }
+
+    @Override
+    public void destroy() {
+      delegate.destroy();
+    }
+  }
+
+  /** Kicks off negotiation of the server. */
+  private static final class KickNegotiationHandler extends ChannelInboundHandlerAdapter {
+
+    private final ChannelHandler next;
+
+    KickNegotiationHandler(ChannelHandler next) {
+      this.next = checkNotNull(next, "next");
+    }
+
+    @Override
+    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+      super.handlerAdded(ctx);
+      ctx.pipeline().replace(ctx.name(), /*newName= */ null, next);
+      ctx.pipeline().fireUserEventTriggered(InternalProtocolNegotiationEvent.getDefault());
+    }
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsTsiFrameProtectorTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsTsiFrameProtectorTest.java
new file mode 100644
index 00000000000..cbda9dbcdc0
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsTsiFrameProtectorTest.java
@@ -0,0 +1,491 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.alts.internal.ByteBufTestUtils.getDirectBuffer;
+import static io.grpc.alts.internal.ByteBufTestUtils.getRandom;
+import static io.grpc.alts.internal.ByteBufTestUtils.writeSlice;
+import static org.junit.Assert.fail;
+
+import com.google.common.testing.GcFinalization;
+import io.grpc.alts.internal.ByteBufTestUtils.RegisterRef;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.util.ReferenceCounted;
+import io.netty.util.ResourceLeakDetector;
+import io.netty.util.ResourceLeakDetector.Level;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AltsTsiFrameProtector}. */
+@RunWith(JUnit4.class)
+public class AltsTsiFrameProtectorTest {
+  private static final int FRAME_MIN_SIZE =
+      AltsTsiFrameProtector.getHeaderTypeFieldBytes() + FakeChannelCrypter.getTagBytes();
+
+  private final List<ReferenceCounted> references = new ArrayList<>();
+  private final RegisterRef ref =
+      new RegisterRef() {
+        @Override
+        public ByteBuf register(ByteBuf buf) {
+          if (buf != null) {
+            references.add(buf);
+          }
+          return buf;
+        }
+      };
+
+  @Before
+  public void setUp() {
+    ResourceLeakDetector.setLevel(Level.PARANOID);
+  }
+
+  @After
+  public void teardown() {
+    for (ReferenceCounted reference : references) {
+      reference.release();
+    }
+    references.clear();
+    // Increase our chances to detect ByteBuf leaks.
+    GcFinalization.awaitFullGc();
+  }
+
+  @Test
+  public void parserHeader_frameLengthNegativeFails() throws GeneralSecurityException {
+    ByteBufAllocator alloc = ByteBufAllocator.DEFAULT;
+    List<Object> out = new ArrayList<>();
+    FakeChannelCrypter crypter = new FakeChannelCrypter();
+    AltsTsiFrameProtector.Unprotector unprotector =
+        new AltsTsiFrameProtector.Unprotector(crypter, alloc);
+    ByteBuf in = getDirectBuffer(AltsTsiFrameProtector.getHeaderBytes(), ref);
+    in.writeIntLE(-1);
+    in.writeIntLE(6);
+    try {
+      unprotector.unprotect(in, out, alloc);
+      fail("Exception expected");
+    } catch (IllegalArgumentException ex) {
+      assertThat(ex).hasMessageThat().contains("Invalid header field: frame size too small");
+    }
+
+    unprotector.destroy();
+  }
+
+  @Test
+  public void parserHeader_frameTooSmall() throws GeneralSecurityException {
+    ByteBufAllocator alloc = ByteBufAllocator.DEFAULT;
+    List<Object> out = new ArrayList<>();
+    FakeChannelCrypter crypter = new FakeChannelCrypter();
+    AltsTsiFrameProtector.Unprotector unprotector =
+        new AltsTsiFrameProtector.Unprotector(crypter, alloc);
+    ByteBuf in =
+        getDirectBuffer(
+            AltsTsiFrameProtector.getHeaderBytes() + FakeChannelCrypter.getTagBytes(), ref);
+    in.writeIntLE(FRAME_MIN_SIZE - 1);
+    in.writeIntLE(6);
+    try {
+      unprotector.unprotect(in, out, alloc);
+      fail("Exception expected");
+    } catch (IllegalArgumentException ex) {
+      assertThat(ex).hasMessageThat().contains("Invalid header field: frame size too small");
+    }
+
+    unprotector.destroy();
+  }
+
+  @Test
+  public void parserHeader_frameTooLarge() throws GeneralSecurityException {
+    ByteBufAllocator alloc = ByteBufAllocator.DEFAULT;
+    List<Object> out = new ArrayList<>();
+    FakeChannelCrypter crypter = new FakeChannelCrypter();
+    AltsTsiFrameProtector.Unprotector unprotector =
+        new AltsTsiFrameProtector.Unprotector(crypter, alloc);
+    ByteBuf in =
+        getDirectBuffer(
+            AltsTsiFrameProtector.getHeaderBytes() + FakeChannelCrypter.getTagBytes(), ref);
+    in.writeIntLE(
+        AltsTsiFrameProtector.getLimitMaxAllowedFrameSize()
+            - AltsTsiFrameProtector.getHeaderLenFieldBytes()
+            + 1);
+    in.writeIntLE(6);
+    try {
+      unprotector.unprotect(in, out, alloc);
+      fail("Exception expected");
+    } catch (IllegalArgumentException ex) {
+      assertThat(ex).hasMessageThat().contains("Invalid header field: frame size too large");
+    }
+
+    unprotector.destroy();
+  }
+
+  @Test
+  public void parserHeader_frameTypeInvalid() throws GeneralSecurityException {
+    ByteBufAllocator alloc = ByteBufAllocator.DEFAULT;
+    List<Object> out = new ArrayList<>();
+    FakeChannelCrypter crypter = new FakeChannelCrypter();
+    AltsTsiFrameProtector.Unprotector unprotector =
+        new AltsTsiFrameProtector.Unprotector(crypter, alloc);
+    ByteBuf in =
+        getDirectBuffer(
+            AltsTsiFrameProtector.getHeaderBytes() + FakeChannelCrypter.getTagBytes(), ref);
+    in.writeIntLE(FRAME_MIN_SIZE);
+    in.writeIntLE(5);
+    try {
+      unprotector.unprotect(in, out, alloc);
+      fail("Exception expected");
+    } catch (IllegalArgumentException ex) {
+      assertThat(ex).hasMessageThat().contains("Invalid header field: frame type");
+    }
+
+    unprotector.destroy();
+  }
+
+  @Test
+  public void parserHeader_frameZeroOk() throws GeneralSecurityException {
+    ByteBufAllocator alloc = ByteBufAllocator.DEFAULT;
+    List<Object> out = new ArrayList<>();
+    FakeChannelCrypter crypter = new FakeChannelCrypter();
+    AltsTsiFrameProtector.Unprotector unprotector =
+        new AltsTsiFrameProtector.Unprotector(crypter, alloc);
+    ByteBuf in =
+        getDirectBuffer(
+            AltsTsiFrameProtector.getHeaderBytes() + FakeChannelCrypter.getTagBytes(), ref);
+    in.writeIntLE(FRAME_MIN_SIZE);
+    in.writeIntLE(6);
+
+    unprotector.unprotect(in, out, alloc);
+    assertThat(in.readableBytes()).isEqualTo(0);
+
+    unprotector.destroy();
+  }
+
+  @Test
+  public void parserHeader_EmptyUnprotectNoRetain() throws GeneralSecurityException {
+    ByteBufAllocator alloc = ByteBufAllocator.DEFAULT;
+    List<Object> out = new ArrayList<>();
+    FakeChannelCrypter crypter = new FakeChannelCrypter();
+    AltsTsiFrameProtector.Unprotector unprotector =
+        new AltsTsiFrameProtector.Unprotector(crypter, alloc);
+    ByteBuf emptyBuf = getDirectBuffer(0, ref);
+    unprotector.unprotect(emptyBuf, out, alloc);
+
+    assertThat(emptyBuf.refCnt()).isEqualTo(1);
+
+    unprotector.destroy();
+  }
+
+  @Test
+  public void parserHeader_frameMaxOk() throws GeneralSecurityException {
+    ByteBufAllocator alloc = ByteBufAllocator.DEFAULT;
+    List<Object> out = new ArrayList<>();
+    FakeChannelCrypter crypter = new FakeChannelCrypter();
+    AltsTsiFrameProtector.Unprotector unprotector =
+        new AltsTsiFrameProtector.Unprotector(crypter, alloc);
+    ByteBuf in =
+        getDirectBuffer(
+            AltsTsiFrameProtector.getHeaderBytes() + FakeChannelCrypter.getTagBytes(), ref);
+    in.writeIntLE(
+        AltsTsiFrameProtector.getLimitMaxAllowedFrameSize()
+            - AltsTsiFrameProtector.getHeaderLenFieldBytes());
+    in.writeIntLE(6);
+
+    unprotector.unprotect(in, out, alloc);
+    assertThat(in.readableBytes()).isEqualTo(0);
+
+    unprotector.destroy();
+  }
+
+  @Test
+  public void parserHeader_frameOkFragment() throws GeneralSecurityException {
+    ByteBufAllocator alloc = ByteBufAllocator.DEFAULT;
+    List<Object> out = new ArrayList<>();
+    FakeChannelCrypter crypter = new FakeChannelCrypter();
+    AltsTsiFrameProtector.Unprotector unprotector =
+        new AltsTsiFrameProtector.Unprotector(crypter, alloc);
+    ByteBuf in =
+        getDirectBuffer(
+            AltsTsiFrameProtector.getHeaderBytes() + FakeChannelCrypter.getTagBytes(), ref);
+    in.writeIntLE(FRAME_MIN_SIZE);
+    in.writeIntLE(6);
+    ByteBuf in1 = in.readSlice(AltsTsiFrameProtector.getHeaderBytes() - 1);
+    ByteBuf in2 = in.readSlice(1);
+
+    unprotector.unprotect(in1, out, alloc);
+    assertThat(in1.readableBytes()).isEqualTo(0);
+
+    unprotector.unprotect(in2, out, alloc);
+    assertThat(in2.readableBytes()).isEqualTo(0);
+
+    unprotector.destroy();
+  }
+
+  @Test
+  public void parseHeader_frameFailFragment() throws GeneralSecurityException {
+    ByteBufAllocator alloc = ByteBufAllocator.DEFAULT;
+    List<Object> out = new ArrayList<>();
+    FakeChannelCrypter crypter = new FakeChannelCrypter();
+    AltsTsiFrameProtector.Unprotector unprotector =
+        new AltsTsiFrameProtector.Unprotector(crypter, alloc);
+    ByteBuf in =
+        getDirectBuffer(
+            AltsTsiFrameProtector.getHeaderBytes() + FakeChannelCrypter.getTagBytes(), ref);
+    in.writeIntLE(FRAME_MIN_SIZE - 1);
+    in.writeIntLE(6);
+    ByteBuf in1 = in.readSlice(AltsTsiFrameProtector.getHeaderBytes() - 1);
+    ByteBuf in2 = in.readSlice(1);
+
+    unprotector.unprotect(in1, out, alloc);
+    assertThat(in1.readableBytes()).isEqualTo(0);
+
+    try {
+      unprotector.unprotect(in2, out, alloc);
+      fail("Exception expected");
+    } catch (IllegalArgumentException ex) {
+      assertThat(ex).hasMessageThat().contains("Invalid header field: frame size too small");
+    }
+
+    assertThat(in2.readableBytes()).isEqualTo(0);
+
+    unprotector.destroy();
+  }
+
+  @Test
+  public void parseFrame_oneFrameNoFragment() throws GeneralSecurityException {
+    int payloadBytes = 1024;
+    ByteBufAllocator alloc = ByteBufAllocator.DEFAULT;
+    List<Object> out = new ArrayList<>();
+    FakeChannelCrypter crypter = new FakeChannelCrypter();
+    AltsTsiFrameProtector.Unprotector unprotector =
+        new AltsTsiFrameProtector.Unprotector(crypter, alloc);
+    ByteBuf plain = getRandom(payloadBytes, ref);
+    ByteBuf outFrame =
+        getDirectBuffer(
+            AltsTsiFrameProtector.getHeaderBytes()
+                + payloadBytes
+                + FakeChannelCrypter.getTagBytes(),
+            ref);
+
+    outFrame.writeIntLE(
+        AltsTsiFrameProtector.getHeaderTypeFieldBytes()
+            + payloadBytes
+            + FakeChannelCrypter.getTagBytes());
+    outFrame.writeIntLE(6);
+    List<ByteBuf> framePlain = Collections.singletonList(plain);
+    ByteBuf frameOut = writeSlice(outFrame, payloadBytes + FakeChannelCrypter.getTagBytes());
+    crypter.encrypt(frameOut, framePlain);
+    plain.readerIndex(0);
+
+    unprotector.unprotect(outFrame, out, alloc);
+    assertThat(outFrame.readableBytes()).isEqualTo(0);
+    assertThat(out.size()).isEqualTo(1);
+    ByteBuf out1 = ref((ByteBuf) out.get(0));
+    assertThat(out1).isEqualTo(plain);
+
+    unprotector.destroy();
+  }
+
+  @Test
+  public void parseFrame_twoFramesNoFragment() throws GeneralSecurityException {
+    int payloadBytes = 1536;
+    int payloadBytes1 = 1024;
+    int payloadBytes2 = payloadBytes - payloadBytes1;
+    ByteBufAllocator alloc = ByteBufAllocator.DEFAULT;
+    List<Object> out = new ArrayList<>();
+    FakeChannelCrypter crypter = new FakeChannelCrypter();
+    AltsTsiFrameProtector.Unprotector unprotector =
+        new AltsTsiFrameProtector.Unprotector(crypter, alloc);
+
+    ByteBuf plain = getRandom(payloadBytes, ref);
+    ByteBuf outFrame =
+        getDirectBuffer(
+            2 * (AltsTsiFrameProtector.getHeaderBytes() + FakeChannelCrypter.getTagBytes())
+                + payloadBytes,
+            ref);
+
+    outFrame.writeIntLE(
+        AltsTsiFrameProtector.getHeaderTypeFieldBytes()
+            + payloadBytes1
+            + FakeChannelCrypter.getTagBytes());
+    outFrame.writeIntLE(6);
+    List<ByteBuf> framePlain1 = Collections.singletonList(plain.readSlice(payloadBytes1));
+    ByteBuf frameOut1 = writeSlice(outFrame, payloadBytes1 + FakeChannelCrypter.getTagBytes());
+
+    outFrame.writeIntLE(
+        AltsTsiFrameProtector.getHeaderTypeFieldBytes()
+            + payloadBytes2
+            + FakeChannelCrypter.getTagBytes());
+    outFrame.writeIntLE(6);
+    List<ByteBuf> framePlain2 = Collections.singletonList(plain);
+    ByteBuf frameOut2 = writeSlice(outFrame, payloadBytes2 + FakeChannelCrypter.getTagBytes());
+
+    crypter.encrypt(frameOut1, framePlain1);
+    crypter.encrypt(frameOut2, framePlain2);
+    plain.readerIndex(0);
+
+    unprotector.unprotect(outFrame, out, alloc);
+    assertThat(out.size()).isEqualTo(1);
+    ByteBuf out1 = ref((ByteBuf) out.get(0));
+    assertThat(out1).isEqualTo(plain);
+    assertThat(outFrame.refCnt()).isEqualTo(1);
+    assertThat(outFrame.readableBytes()).isEqualTo(0);
+
+    unprotector.destroy();
+  }
+
+  @Test
+  public void parseFrame_twoFramesNoFragment_Leftover() throws GeneralSecurityException {
+    int payloadBytes = 1536;
+    int payloadBytes1 = 1024;
+    int payloadBytes2 = payloadBytes - payloadBytes1;
+    ByteBufAllocator alloc = ByteBufAllocator.DEFAULT;
+    List<Object> out = new ArrayList<>();
+    FakeChannelCrypter crypter = new FakeChannelCrypter();
+    AltsTsiFrameProtector.Unprotector unprotector =
+        new AltsTsiFrameProtector.Unprotector(crypter, alloc);
+
+    ByteBuf plain = getRandom(payloadBytes, ref);
+    ByteBuf protectedBuf =
+        getDirectBuffer(
+            2 * (AltsTsiFrameProtector.getHeaderBytes() + FakeChannelCrypter.getTagBytes())
+                + payloadBytes
+                + AltsTsiFrameProtector.getHeaderBytes(),
+            ref);
+
+    protectedBuf.writeIntLE(
+        AltsTsiFrameProtector.getHeaderTypeFieldBytes()
+            + payloadBytes1
+            + FakeChannelCrypter.getTagBytes());
+    protectedBuf.writeIntLE(6);
+    List<ByteBuf> framePlain1 = Collections.singletonList(plain.readSlice(payloadBytes1));
+    ByteBuf frameOut1 = writeSlice(protectedBuf, payloadBytes1 + FakeChannelCrypter.getTagBytes());
+
+    protectedBuf.writeIntLE(
+        AltsTsiFrameProtector.getHeaderTypeFieldBytes()
+            + payloadBytes2
+            + FakeChannelCrypter.getTagBytes());
+    protectedBuf.writeIntLE(6);
+    List<ByteBuf> framePlain2 = Collections.singletonList(plain);
+    ByteBuf frameOut2 = writeSlice(protectedBuf, payloadBytes2 + FakeChannelCrypter.getTagBytes());
+    // This is an invalid header length field, make sure it triggers an error
+    // when the remainder of the header is given.
+    protectedBuf.writeIntLE((byte) -1);
+
+    crypter.encrypt(frameOut1, framePlain1);
+    crypter.encrypt(frameOut2, framePlain2);
+    plain.readerIndex(0);
+
+    unprotector.unprotect(protectedBuf, out, alloc);
+    assertThat(out.size()).isEqualTo(1);
+    ByteBuf out1 = ref((ByteBuf) out.get(0));
+    assertThat(out1).isEqualTo(plain);
+
+    // The protectedBuf is buffered inside the unprotector.
+    assertThat(protectedBuf.readableBytes()).isEqualTo(0);
+    assertThat(protectedBuf.refCnt()).isEqualTo(2);
+
+    protectedBuf.writeIntLE(6);
+    try {
+      unprotector.unprotect(protectedBuf, out, alloc);
+      fail("Exception expected");
+    } catch (IllegalArgumentException ex) {
+      assertThat(ex).hasMessageThat().contains("Invalid header field: frame size too small");
+    }
+
+    unprotector.destroy();
+
+    // Make sure that unprotector does not hold onto buffered ByteBuf instance after destroy.
+    assertThat(protectedBuf.refCnt()).isEqualTo(1);
+
+    // Make sure that destroying twice does not throw.
+    unprotector.destroy();
+  }
+
+  @Test
+  public void parseFrame_twoFramesFragmentSecond() throws GeneralSecurityException {
+    int payloadBytes = 1536;
+    int payloadBytes1 = 1024;
+    int payloadBytes2 = payloadBytes - payloadBytes1;
+    ByteBufAllocator alloc = ByteBufAllocator.DEFAULT;
+    List<Object> out = new ArrayList<>();
+    FakeChannelCrypter crypter = new FakeChannelCrypter();
+    AltsTsiFrameProtector.Unprotector unprotector =
+        new AltsTsiFrameProtector.Unprotector(crypter, alloc);
+
+    ByteBuf plain = getRandom(payloadBytes, ref);
+    ByteBuf protectedBuf =
+        getDirectBuffer(
+            2 * (AltsTsiFrameProtector.getHeaderBytes() + FakeChannelCrypter.getTagBytes())
+                + payloadBytes
+                + AltsTsiFrameProtector.getHeaderBytes(),
+            ref);
+
+    protectedBuf.writeIntLE(
+        AltsTsiFrameProtector.getHeaderTypeFieldBytes()
+            + payloadBytes1
+            + FakeChannelCrypter.getTagBytes());
+    protectedBuf.writeIntLE(6);
+    List<ByteBuf> framePlain1 = Collections.singletonList(plain.readSlice(payloadBytes1));
+    ByteBuf frameOut1 = writeSlice(protectedBuf, payloadBytes1 + FakeChannelCrypter.getTagBytes());
+
+    protectedBuf.writeIntLE(
+        AltsTsiFrameProtector.getHeaderTypeFieldBytes()
+            + payloadBytes2
+            + FakeChannelCrypter.getTagBytes());
+    protectedBuf.writeIntLE(6);
+    List<ByteBuf> framePlain2 = Collections.singletonList(plain);
+    ByteBuf frameOut2 = writeSlice(protectedBuf, payloadBytes2 + FakeChannelCrypter.getTagBytes());
+
+    crypter.encrypt(frameOut1, framePlain1);
+    crypter.encrypt(frameOut2, framePlain2);
+    plain.readerIndex(0);
+
+    unprotector.unprotect(
+        protectedBuf.readSlice(
+            payloadBytes
+                + AltsTsiFrameProtector.getHeaderBytes()
+                + FakeChannelCrypter.getTagBytes()
+                + AltsTsiFrameProtector.getHeaderBytes()),
+        out,
+        alloc);
+    assertThat(out.size()).isEqualTo(1);
+    ByteBuf out1 = ref((ByteBuf) out.get(0));
+    assertThat(out1).isEqualTo(plain.readSlice(payloadBytes1));
+    assertThat(protectedBuf.refCnt()).isEqualTo(2);
+
+    unprotector.unprotect(protectedBuf, out, alloc);
+    assertThat(out.size()).isEqualTo(2);
+    ByteBuf out2 = ref((ByteBuf) out.get(1));
+    assertThat(out2).isEqualTo(plain);
+    assertThat(protectedBuf.refCnt()).isEqualTo(1);
+
+    unprotector.destroy();
+  }
+
+  private ByteBuf ref(ByteBuf buf) {
+    if (buf != null) {
+      references.add(buf);
+    }
+    return buf;
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsTsiHandshakerTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsTsiHandshakerTest.java
new file mode 100644
index 00000000000..ae1696401be
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsTsiHandshakerTest.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.protobuf.ByteString;
+import io.grpc.internal.TestUtils.NoopChannelLogger;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentMatchers;
+
+/** Unit tests for {@link AltsTsiHandshaker}. */
+@RunWith(JUnit4.class)
+public class AltsTsiHandshakerTest {
+  private static final String TEST_KEY_DATA = "super secret 123";
+  private static final String TEST_APPLICATION_PROTOCOL = "grpc";
+  private static final String TEST_RECORD_PROTOCOL = "ALTSRP_GCM_AES128";
+  private static final String TEST_CLIENT_SERVICE_ACCOUNT = "client@developer.gserviceaccount.com";
+  private static final String TEST_SERVER_SERVICE_ACCOUNT = "server@developer.gserviceaccount.com";
+  private static final int OUT_FRAME_SIZE = 100;
+  private static final int TRANSPORT_BUFFER_SIZE = 200;
+  private static final int TEST_MAX_RPC_VERSION_MAJOR = 3;
+  private static final int TEST_MAX_RPC_VERSION_MINOR = 2;
+  private static final int TEST_MIN_RPC_VERSION_MAJOR = 2;
+  private static final int TEST_MIN_RPC_VERSION_MINOR = 1;
+  private static final RpcProtocolVersions TEST_RPC_PROTOCOL_VERSIONS =
+      RpcProtocolVersions.newBuilder()
+          .setMaxRpcVersion(
+              RpcProtocolVersions.Version.newBuilder()
+                  .setMajor(TEST_MAX_RPC_VERSION_MAJOR)
+                  .setMinor(TEST_MAX_RPC_VERSION_MINOR)
+                  .build())
+          .setMinRpcVersion(
+              RpcProtocolVersions.Version.newBuilder()
+                  .setMajor(TEST_MIN_RPC_VERSION_MAJOR)
+                  .setMinor(TEST_MIN_RPC_VERSION_MINOR)
+                  .build())
+          .build();
+
+  private AltsHandshakerClient mockClient;
+  private AltsHandshakerClient mockServer;
+  private AltsTsiHandshaker handshakerClient;
+  private AltsTsiHandshaker handshakerServer;
+
+  @Before
+  public void setUp() throws Exception {
+    mockClient = mock(AltsHandshakerClient.class);
+    mockServer = mock(AltsHandshakerClient.class);
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    handshakerClient = new AltsTsiHandshaker(true, mockClient, channelLogger);
+    handshakerServer = new AltsTsiHandshaker(false, mockServer, channelLogger);
+  }
+
+  private HandshakerResult getHandshakerResult(boolean isClient) {
+    HandshakerResult.Builder builder =
+        HandshakerResult.newBuilder()
+            .setApplicationProtocol(TEST_APPLICATION_PROTOCOL)
+            .setRecordProtocol(TEST_RECORD_PROTOCOL)
+            .setKeyData(ByteString.copyFromUtf8(TEST_KEY_DATA))
+            .setPeerRpcVersions(TEST_RPC_PROTOCOL_VERSIONS);
+    if (isClient) {
+      builder.setPeerIdentity(
+          Identity.newBuilder().setServiceAccount(TEST_SERVER_SERVICE_ACCOUNT).build());
+      builder.setLocalIdentity(
+          Identity.newBuilder().setServiceAccount(TEST_CLIENT_SERVICE_ACCOUNT).build());
+    } else {
+      builder.setPeerIdentity(
+          Identity.newBuilder().setServiceAccount(TEST_CLIENT_SERVICE_ACCOUNT).build());
+      builder.setLocalIdentity(
+          Identity.newBuilder().setServiceAccount(TEST_SERVER_SERVICE_ACCOUNT).build());
+    }
+    return builder.build();
+  }
+
+  @Test
+  public void processBytesFromPeerFalseStart() throws Exception {
+    verify(mockClient, never()).startClientHandshake();
+    verify(mockClient, never()).startServerHandshake(ArgumentMatchers.<ByteBuffer>any());
+    verify(mockClient, never()).next(ArgumentMatchers.<ByteBuffer>any());
+
+    ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
+    assertTrue(handshakerClient.processBytesFromPeer(transportBuffer));
+  }
+
+  @Test
+  public void processBytesFromPeerStartServer() throws Exception {
+    ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
+    ByteBuffer outputFrame = ByteBuffer.allocate(OUT_FRAME_SIZE);
+    verify(mockServer, never()).startClientHandshake();
+    verify(mockServer, never()).next(ArgumentMatchers.<ByteBuffer>any());
+    // Mock transport buffer all consumed by processBytesFromPeer and there is an output frame.
+    ((Buffer) transportBuffer).position(transportBuffer.limit());
+    when(mockServer.startServerHandshake(transportBuffer)).thenReturn(outputFrame);
+    when(mockServer.isFinished()).thenReturn(false);
+
+    assertTrue(handshakerServer.processBytesFromPeer(transportBuffer));
+  }
+
+  @Test
+  public void processBytesFromPeerStartServerEmptyOutput() throws Exception {
+    ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
+    ByteBuffer emptyOutputFrame = ByteBuffer.allocate(0);
+    verify(mockServer, never()).startClientHandshake();
+    verify(mockServer, never()).next(ArgumentMatchers.<ByteBuffer>any());
+    // Mock transport buffer all consumed by processBytesFromPeer and output frame is empty.
+    // Expect processBytesFromPeer return False, because more data are needed from the peer.
+    ((Buffer) transportBuffer).position(transportBuffer.limit());
+    when(mockServer.startServerHandshake(transportBuffer)).thenReturn(emptyOutputFrame);
+    when(mockServer.isFinished()).thenReturn(false);
+
+    assertFalse(handshakerServer.processBytesFromPeer(transportBuffer));
+  }
+
+  @Test
+  public void processBytesFromPeerStartServerFinished() throws Exception {
+    ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
+    ByteBuffer outputFrame = ByteBuffer.allocate(OUT_FRAME_SIZE);
+    verify(mockServer, never()).startClientHandshake();
+    verify(mockServer, never()).next(ArgumentMatchers.<ByteBuffer>any());
+    // Mock handshake complete after processBytesFromPeer.
+    when(mockServer.startServerHandshake(transportBuffer)).thenReturn(outputFrame);
+    when(mockServer.isFinished()).thenReturn(true);
+
+    assertTrue(handshakerServer.processBytesFromPeer(transportBuffer));
+  }
+
+  @Test
+  public void processBytesFromPeerNoBytesConsumed() throws Exception {
+    ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
+    ByteBuffer emptyOutputFrame = ByteBuffer.allocate(0);
+    verify(mockServer, never()).startClientHandshake();
+    verify(mockServer, never()).next(ArgumentMatchers.<ByteBuffer>any());
+    when(mockServer.startServerHandshake(transportBuffer)).thenReturn(emptyOutputFrame);
+    when(mockServer.isFinished()).thenReturn(false);
+
+    try {
+      assertTrue(handshakerServer.processBytesFromPeer(transportBuffer));
+      fail("Expected IllegalStateException");
+    } catch (IllegalStateException expected) {
+      assertEquals("Handshaker did not consume any bytes.", expected.getMessage());
+    }
+  }
+
+  @Test
+  public void processBytesFromPeerClientNext() throws Exception {
+    ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
+    ByteBuffer outputFrame = ByteBuffer.allocate(OUT_FRAME_SIZE);
+    verify(mockClient, never()).startServerHandshake(ArgumentMatchers.<ByteBuffer>any());
+    when(mockClient.startClientHandshake()).thenReturn(outputFrame);
+    when(mockClient.next(transportBuffer)).thenReturn(outputFrame);
+    when(mockClient.isFinished()).thenReturn(false);
+
+    handshakerClient.getBytesToSendToPeer(transportBuffer);
+    ((Buffer) transportBuffer).position(transportBuffer.limit());
+    assertFalse(handshakerClient.processBytesFromPeer(transportBuffer));
+  }
+
+  @Test
+  public void processBytesFromPeerClientNextFinished() throws Exception {
+    ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
+    ByteBuffer outputFrame = ByteBuffer.allocate(OUT_FRAME_SIZE);
+    verify(mockClient, never()).startServerHandshake(ArgumentMatchers.<ByteBuffer>any());
+    when(mockClient.startClientHandshake()).thenReturn(outputFrame);
+    when(mockClient.next(transportBuffer)).thenReturn(outputFrame);
+    when(mockClient.isFinished()).thenReturn(true);
+
+    handshakerClient.getBytesToSendToPeer(transportBuffer);
+    assertTrue(handshakerClient.processBytesFromPeer(transportBuffer));
+  }
+
+  @Test
+  public void extractPeerFailure() throws Exception {
+    when(mockClient.isFinished()).thenReturn(false);
+
+    try {
+      handshakerClient.extractPeer();
+      fail("Expected IllegalStateException");
+    } catch (IllegalStateException expected) {
+      assertEquals("Handshake is not complete.", expected.getMessage());
+    }
+  }
+
+  @Test
+  public void extractPeerObjectFailure() throws Exception {
+    when(mockClient.isFinished()).thenReturn(false);
+
+    try {
+      handshakerClient.extractPeerObject();
+      fail("Expected IllegalStateException");
+    } catch (IllegalStateException expected) {
+      assertEquals("Handshake is not complete.", expected.getMessage());
+    }
+  }
+
+  @Test
+  public void extractClientPeerSuccess() throws Exception {
+    ByteBuffer outputFrame = ByteBuffer.allocate(OUT_FRAME_SIZE);
+    ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
+    when(mockClient.startClientHandshake()).thenReturn(outputFrame);
+    when(mockClient.isFinished()).thenReturn(true);
+    when(mockClient.getResult()).thenReturn(getHandshakerResult(/* isClient = */ true));
+
+    handshakerClient.getBytesToSendToPeer(transportBuffer);
+    TsiPeer clientPeer = handshakerClient.extractPeer();
+
+    assertEquals(1, clientPeer.getProperties().size());
+    assertEquals(
+        TEST_SERVER_SERVICE_ACCOUNT,
+        clientPeer.getProperty(AltsTsiHandshaker.TSI_SERVICE_ACCOUNT_PEER_PROPERTY).getValue());
+
+    AltsInternalContext clientContext = (AltsInternalContext) handshakerClient.extractPeerObject();
+    assertEquals(TEST_APPLICATION_PROTOCOL, clientContext.getApplicationProtocol());
+    assertEquals(TEST_RECORD_PROTOCOL, clientContext.getRecordProtocol());
+    assertEquals(TEST_SERVER_SERVICE_ACCOUNT, clientContext.getPeerServiceAccount());
+    assertEquals(TEST_CLIENT_SERVICE_ACCOUNT, clientContext.getLocalServiceAccount());
+    assertEquals(TEST_RPC_PROTOCOL_VERSIONS, clientContext.getPeerRpcVersions());
+  }
+
+  @Test
+  public void extractServerPeerSuccess() throws Exception {
+    ByteBuffer outputFrame = ByteBuffer.allocate(OUT_FRAME_SIZE);
+    ByteBuffer transportBuffer = ByteBuffer.allocate(TRANSPORT_BUFFER_SIZE);
+    when(mockServer.startServerHandshake(ArgumentMatchers.<ByteBuffer>any()))
+        .thenReturn(outputFrame);
+    when(mockServer.isFinished()).thenReturn(true);
+    when(mockServer.getResult()).thenReturn(getHandshakerResult(/* isClient = */ false));
+
+    handshakerServer.processBytesFromPeer(transportBuffer);
+    handshakerServer.getBytesToSendToPeer(transportBuffer);
+    TsiPeer serverPeer = handshakerServer.extractPeer();
+
+    assertEquals(1, serverPeer.getProperties().size());
+    assertEquals(
+        TEST_CLIENT_SERVICE_ACCOUNT,
+        serverPeer.getProperty(AltsTsiHandshaker.TSI_SERVICE_ACCOUNT_PEER_PROPERTY).getValue());
+
+    AltsInternalContext serverContext = (AltsInternalContext) handshakerServer.extractPeerObject();
+    assertEquals(TEST_APPLICATION_PROTOCOL, serverContext.getApplicationProtocol());
+    assertEquals(TEST_RECORD_PROTOCOL, serverContext.getRecordProtocol());
+    assertEquals(TEST_CLIENT_SERVICE_ACCOUNT, serverContext.getPeerServiceAccount());
+    assertEquals(TEST_SERVER_SERVICE_ACCOUNT, serverContext.getLocalServiceAccount());
+    assertEquals(TEST_RPC_PROTOCOL_VERSIONS, serverContext.getPeerRpcVersions());
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/AltsTsiTest.java b/alts/src/test/java/io/grpc/alts/internal/AltsTsiTest.java
new file mode 100644
index 00000000000..cb39abb9ddc
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/AltsTsiTest.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.testing.GcFinalization;
+import io.grpc.alts.internal.ByteBufTestUtils.RegisterRef;
+import io.grpc.alts.internal.TsiTest.Handshakers;
+import io.grpc.internal.TestUtils.NoopChannelLogger;
+import io.netty.buffer.ByteBuf;
+import io.netty.util.ReferenceCounted;
+import io.netty.util.ResourceLeakDetector;
+import io.netty.util.ResourceLeakDetector.Level;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AltsTsiHandshaker}. */
+@RunWith(JUnit4.class)
+public class AltsTsiTest {
+  private static final int OVERHEAD =
+      FakeChannelCrypter.getTagBytes() + AltsTsiFrameProtector.getHeaderBytes();
+
+  private final List<ReferenceCounted> references = new ArrayList<>();
+  private AltsHandshakerClient client;
+  private AltsHandshakerClient server;
+  private final RegisterRef ref =
+      new RegisterRef() {
+        @Override
+        public ByteBuf register(ByteBuf buf) {
+          if (buf != null) {
+            references.add(buf);
+          }
+          return buf;
+        }
+      };
+
+  @Before
+  public void setUp() throws Exception {
+    ResourceLeakDetector.setLevel(Level.PARANOID);
+    // Use MockAltsHandshakerStub for all the tests.
+    AltsHandshakerOptions handshakerOptions = new AltsHandshakerOptions(null);
+    MockAltsHandshakerStub clientStub = new MockAltsHandshakerStub();
+    MockAltsHandshakerStub serverStub = new MockAltsHandshakerStub();
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    client = new AltsHandshakerClient(clientStub, handshakerOptions, channelLogger);
+    server = new AltsHandshakerClient(serverStub, handshakerOptions, channelLogger);
+  }
+
+  @After
+  public void tearDown() {
+    for (ReferenceCounted reference : references) {
+      reference.release();
+    }
+    references.clear();
+    // Increase our chances to detect ByteBuf leaks.
+    GcFinalization.awaitFullGc();
+  }
+
+  private Handshakers newHandshakers() {
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    TsiHandshaker clientHandshaker = new AltsTsiHandshaker(true, client, channelLogger);
+    TsiHandshaker serverHandshaker = new AltsTsiHandshaker(false, server, channelLogger);
+    return new Handshakers(clientHandshaker, serverHandshaker);
+  }
+
+  @Test
+  public void verifyHandshakePeer() throws Exception {
+    Handshakers handshakers = newHandshakers();
+    TsiTest.performHandshake(TsiTest.getDefaultTransportBufferSize(), handshakers);
+    TsiPeer clientPeer = handshakers.getClient().extractPeer();
+    assertEquals(1, clientPeer.getProperties().size());
+    assertEquals(
+        MockAltsHandshakerResp.getTestPeerAccount(),
+        clientPeer.getProperty("service_account").getValue());
+    TsiPeer serverPeer = handshakers.getServer().extractPeer();
+    assertEquals(1, serverPeer.getProperties().size());
+    assertEquals(
+        MockAltsHandshakerResp.getTestPeerAccount(),
+        serverPeer.getProperty("service_account").getValue());
+  }
+
+  @Test
+  public void handshake() throws GeneralSecurityException {
+    TsiTest.handshakeTest(newHandshakers());
+  }
+
+  @Test
+  public void handshakeSmallBuffer() throws GeneralSecurityException {
+    TsiTest.handshakeSmallBufferTest(newHandshakers());
+  }
+
+  @Test
+  public void pingPong() throws GeneralSecurityException {
+    TsiTest.pingPongTest(newHandshakers(), ref);
+  }
+
+  @Test
+  public void pingPongExactFrameSize() throws GeneralSecurityException {
+    TsiTest.pingPongExactFrameSizeTest(newHandshakers(), ref);
+  }
+
+  @Test
+  public void pingPongSmallBuffer() throws GeneralSecurityException {
+    TsiTest.pingPongSmallBufferTest(newHandshakers(), ref);
+  }
+
+  @Test
+  public void pingPongSmallFrame() throws GeneralSecurityException {
+    TsiTest.pingPongSmallFrameTest(OVERHEAD, newHandshakers(), ref);
+  }
+
+  @Test
+  public void pingPongSmallFrameSmallBuffer() throws GeneralSecurityException {
+    TsiTest.pingPongSmallFrameSmallBufferTest(OVERHEAD, newHandshakers(), ref);
+  }
+
+  @Test
+  public void corruptedCounter() throws GeneralSecurityException {
+    TsiTest.corruptedCounterTest(newHandshakers(), ref);
+  }
+
+  @Test
+  public void corruptedCiphertext() throws GeneralSecurityException {
+    TsiTest.corruptedCiphertextTest(newHandshakers(), ref);
+  }
+
+  @Test
+  public void corruptedTag() throws GeneralSecurityException {
+    TsiTest.corruptedTagTest(newHandshakers(), ref);
+  }
+
+  @Test
+  public void reflectedCiphertext() throws GeneralSecurityException {
+    TsiTest.reflectedCiphertextTest(newHandshakers(), ref);
+  }
+
+  private static class MockAltsHandshakerStub extends AltsHandshakerStub {
+    private boolean started = false;
+
+    @Override
+    public HandshakerResp send(HandshakerReq req) {
+      if (started) {
+        // Expect handshake next message.
+        if (req.getReqOneofCase().getNumber() != 3) {
+          return MockAltsHandshakerResp.getErrorResponse();
+        }
+        return MockAltsHandshakerResp.getFinishedResponse(req.getNext().getInBytes().size());
+      } else {
+        List<String> recordProtocols;
+        int bytesConsumed = 0;
+        switch (req.getReqOneofCase().getNumber()) {
+          case 1:
+            recordProtocols = req.getClientStart().getRecordProtocolsList();
+            break;
+          case 2:
+            recordProtocols =
+                req.getServerStart()
+                    .getHandshakeParametersMap()
+                    .get(HandshakeProtocol.ALTS.getNumber())
+                    .getRecordProtocolsList();
+            bytesConsumed = req.getServerStart().getInBytes().size();
+            break;
+          default:
+            return MockAltsHandshakerResp.getErrorResponse();
+        }
+        if (recordProtocols.isEmpty()) {
+          return MockAltsHandshakerResp.getErrorResponse();
+        }
+        started = true;
+        return MockAltsHandshakerResp.getOkResponse(bytesConsumed);
+      }
+    }
+
+    @Override
+    public void close() {}
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/BufUnwrapperTest.java b/alts/src/test/java/io/grpc/alts/internal/BufUnwrapperTest.java
new file mode 100644
index 00000000000..67f318e8611
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/BufUnwrapperTest.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.truth.Truth;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.CompositeByteBuf;
+import io.netty.buffer.UnpooledByteBufAllocator;
+import java.nio.ByteBuffer;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class BufUnwrapperTest {
+
+  private final ByteBufAllocator alloc = UnpooledByteBufAllocator.DEFAULT;
+
+  @Test
+  public void closeEmptiesBuffers() {
+    BufUnwrapper unwrapper = new BufUnwrapper();
+    ByteBuf buf = alloc.buffer();
+    try {
+      ByteBuffer[] readableBufs = unwrapper.readableNioBuffers(buf);
+      ByteBuffer[] writableBufs = unwrapper.writableNioBuffers(buf);
+      Truth.assertThat(readableBufs).hasLength(1);
+      Truth.assertThat(readableBufs[0]).isNotNull();
+      Truth.assertThat(writableBufs).hasLength(1);
+      Truth.assertThat(writableBufs[0]).isNotNull();
+
+      unwrapper.close();
+
+      Truth.assertThat(readableBufs[0]).isNull();
+      Truth.assertThat(writableBufs[0]).isNull();
+    } finally {
+      buf.release();
+    }
+  }
+
+  @Test
+  public void readableNioBuffers_worksWithNormal() {
+    ByteBuf buf = alloc.buffer(1).writeByte('a');
+    try (BufUnwrapper unwrapper = new BufUnwrapper()) {
+      ByteBuffer[] internalBufs = unwrapper.readableNioBuffers(buf);
+      Truth.assertThat(internalBufs).hasLength(1);
+
+      assertEquals('a', internalBufs[0].get(0));
+    } finally {
+      buf.release();
+    }
+  }
+
+  @Test
+  public void readableNioBuffers_worksWithComposite() {
+    CompositeByteBuf buf = alloc.compositeBuffer();
+    buf.addComponent(true, alloc.buffer(1).writeByte('a'));
+    try (BufUnwrapper unwrapper = new BufUnwrapper()) {
+      ByteBuffer[] internalBufs = unwrapper.readableNioBuffers(buf);
+      Truth.assertThat(internalBufs).hasLength(1);
+
+      assertEquals('a', internalBufs[0].get(0));
+    } finally {
+      buf.release();
+    }
+  }
+
+  @Test
+  public void writableNioBuffers_indexesPreserved() {
+    ByteBuf buf = alloc.buffer(1);
+    int ridx = buf.readerIndex();
+    int widx = buf.writerIndex();
+    int cap = buf.capacity();
+    try (BufUnwrapper unwrapper = new BufUnwrapper()) {
+      ByteBuffer[] internalBufs = unwrapper.writableNioBuffers(buf);
+      Truth.assertThat(internalBufs).hasLength(1);
+
+      internalBufs[0].put((byte) 'a');
+
+      assertEquals(ridx, buf.readerIndex());
+      assertEquals(widx, buf.writerIndex());
+      assertEquals(cap, buf.capacity());
+    } finally {
+      buf.release();
+    }
+  }
+
+  @Test
+  public void writableNioBuffers_worksWithNormal() {
+    ByteBuf buf = alloc.buffer(1);
+    try (BufUnwrapper unwrapper = new BufUnwrapper()) {
+      ByteBuffer[] internalBufs = unwrapper.writableNioBuffers(buf);
+      Truth.assertThat(internalBufs).hasLength(1);
+
+      internalBufs[0].put((byte) 'a');
+
+      buf.writerIndex(1);
+      assertEquals('a', buf.readByte());
+    } finally {
+      buf.release();
+    }
+  }
+
+  @Test
+  public void writableNioBuffers_worksWithComposite() {
+    CompositeByteBuf buf = alloc.compositeBuffer();
+    buf.addComponent(alloc.buffer(1));
+    buf.capacity(1);
+    try (BufUnwrapper unwrapper = new BufUnwrapper()) {
+      ByteBuffer[] internalBufs = unwrapper.writableNioBuffers(buf);
+      Truth.assertThat(internalBufs).hasLength(1);
+
+      internalBufs[0].put((byte) 'a');
+
+      buf.writerIndex(1);
+      assertEquals('a', buf.readByte());
+    } finally {
+      buf.release();
+    }
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/ByteBufTestUtils.java b/alts/src/test/java/io/grpc/alts/internal/ByteBufTestUtils.java
new file mode 100644
index 00000000000..0d0f13c9cc4
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/ByteBufTestUtils.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import com.google.common.base.Preconditions;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public final class ByteBufTestUtils {
+  public interface RegisterRef {
+    ByteBuf register(ByteBuf buf);
+  }
+
+  private static final Random random = new SecureRandom();
+
+  // The {@code ref} argument can be used to register the buffer for {@code release}.
+  // TODO: allow the allocator to be passed in.
+  public static ByteBuf getDirectBuffer(int len, RegisterRef ref) {
+    return ref.register(Unpooled.directBuffer(len));
+  }
+
+  /** Get random bytes. */
+  public static ByteBuf getRandom(int len, RegisterRef ref) {
+    ByteBuf buf = getDirectBuffer(len, ref);
+    byte[] bytes = new byte[len];
+    random.nextBytes(bytes);
+    buf.writeBytes(bytes);
+    return buf;
+  }
+
+  /** Fragment byte buffer into multiple pieces. */
+  public static List<ByteBuf> fragmentByteBuf(ByteBuf in, int num, RegisterRef ref) {
+    ByteBuf buf = in.slice();
+    Preconditions.checkArgument(num > 0);
+    List<ByteBuf> fragmentedBufs = new ArrayList<>(num);
+    int fragmentSize = buf.readableBytes() / num;
+    while (buf.isReadable()) {
+      int readBytes = num == 0 ? buf.readableBytes() : fragmentSize;
+      ByteBuf tmpBuf = getDirectBuffer(readBytes, ref);
+      tmpBuf.writeBytes(buf, readBytes);
+      fragmentedBufs.add(tmpBuf);
+      num--;
+    }
+    return fragmentedBufs;
+  }
+
+  static ByteBuf writeSlice(ByteBuf in, int len) {
+    Preconditions.checkArgument(len <= in.writableBytes());
+    ByteBuf out = in.slice(in.writerIndex(), len);
+    in.writerIndex(in.writerIndex() + len);
+    return out.writerIndex(0);
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/ChannelCrypterNettyTestBase.java b/alts/src/test/java/io/grpc/alts/internal/ChannelCrypterNettyTestBase.java
new file mode 100644
index 00000000000..cab0765e7d7
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/ChannelCrypterNettyTestBase.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.alts.internal.ByteBufTestUtils.getDirectBuffer;
+import static io.grpc.alts.internal.ByteBufTestUtils.getRandom;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.fail;
+
+import io.grpc.alts.internal.ByteBufTestUtils.RegisterRef;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.util.ReferenceCounted;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import javax.crypto.AEADBadTagException;
+import org.junit.Test;
+
+/** Abstract class for unit tests of {@link ChannelCrypterNetty}. */
+public abstract class ChannelCrypterNettyTestBase {
+  private static final String DECRYPTION_FAILURE_MESSAGE_RE = "Tag mismatch|BAD_DECRYPT";
+
+  protected final List<ReferenceCounted> references = new ArrayList<>();
+  public ChannelCrypterNetty client;
+  public ChannelCrypterNetty server;
+  private final RegisterRef ref =
+      new RegisterRef() {
+        @Override
+        public ByteBuf register(ByteBuf buf) {
+          if (buf != null) {
+            references.add(buf);
+          }
+          return buf;
+        }
+      };
+
+  static final class FrameEncrypt {
+    List<ByteBuf> plain;
+    ByteBuf out;
+  }
+
+  static final class FrameDecrypt {
+    List<ByteBuf> ciphertext;
+    ByteBuf out;
+    ByteBuf tag;
+  }
+
+  FrameEncrypt createFrameEncrypt(String message) {
+    byte[] messageBytes = message.getBytes(UTF_8);
+    FrameEncrypt frame = new FrameEncrypt();
+    ByteBuf plain = getDirectBuffer(messageBytes.length, ref);
+    plain.writeBytes(messageBytes);
+    frame.plain = Collections.singletonList(plain);
+    frame.out = getDirectBuffer(messageBytes.length + client.getSuffixLength(), ref);
+    return frame;
+  }
+
+  FrameDecrypt frameDecryptOfEncrypt(FrameEncrypt frameEncrypt) {
+    int tagLen = client.getSuffixLength();
+    FrameDecrypt frameDecrypt = new FrameDecrypt();
+    ByteBuf out = frameEncrypt.out;
+    frameDecrypt.ciphertext =
+        Collections.singletonList(out.slice(out.readerIndex(), out.readableBytes() - tagLen));
+    frameDecrypt.tag = out.slice(out.readerIndex() + out.readableBytes() - tagLen, tagLen);
+    frameDecrypt.out = getDirectBuffer(out.readableBytes(), ref);
+    return frameDecrypt;
+  }
+
+  @Test
+  public void encryptDecrypt() throws GeneralSecurityException {
+    String message = "Hello world";
+    FrameEncrypt frameEncrypt = createFrameEncrypt(message);
+    client.encrypt(frameEncrypt.out, frameEncrypt.plain);
+    FrameDecrypt frameDecrypt = frameDecryptOfEncrypt(frameEncrypt);
+
+    server.decrypt(frameDecrypt.out, frameDecrypt.tag, frameDecrypt.ciphertext);
+    assertThat(frameEncrypt.plain.get(0).slice(0, frameDecrypt.out.readableBytes()))
+        .isEqualTo(frameDecrypt.out);
+  }
+
+  @Test
+  public void encryptDecryptLarge() throws GeneralSecurityException {
+    FrameEncrypt frameEncrypt = new FrameEncrypt();
+    ByteBuf plain = getRandom(17 * 1024, ref);
+    frameEncrypt.plain = Collections.singletonList(plain);
+    frameEncrypt.out = getDirectBuffer(plain.readableBytes() + client.getSuffixLength(), ref);
+
+    client.encrypt(frameEncrypt.out, frameEncrypt.plain);
+    FrameDecrypt frameDecrypt = frameDecryptOfEncrypt(frameEncrypt);
+
+    // Call decrypt overload that takes ciphertext and tag.
+    server.decrypt(frameDecrypt.out, frameEncrypt.out);
+    assertThat(frameEncrypt.plain.get(0).slice(0, frameDecrypt.out.readableBytes()))
+        .isEqualTo(frameDecrypt.out);
+  }
+
+  @Test
+  public void encryptDecryptMultiple() throws GeneralSecurityException {
+    String message = "Hello world";
+    for (int i = 0; i < 512; ++i) {
+      FrameEncrypt frameEncrypt = createFrameEncrypt(message);
+      client.encrypt(frameEncrypt.out, frameEncrypt.plain);
+      FrameDecrypt frameDecrypt = frameDecryptOfEncrypt(frameEncrypt);
+
+      server.decrypt(frameDecrypt.out, frameDecrypt.tag, frameDecrypt.ciphertext);
+      assertThat(frameEncrypt.plain.get(0).slice(0, frameDecrypt.out.readableBytes()))
+          .isEqualTo(frameDecrypt.out);
+    }
+  }
+
+  @Test
+  public void encryptDecryptComposite() throws GeneralSecurityException {
+    String message = "Hello world";
+    int lastLen = 2;
+    byte[] messageBytes = message.getBytes(UTF_8);
+    FrameEncrypt frameEncrypt = new FrameEncrypt();
+    ByteBuf plain1 = getDirectBuffer(messageBytes.length - lastLen, ref);
+    ByteBuf plain2 = getDirectBuffer(lastLen, ref);
+    plain1.writeBytes(messageBytes, 0, messageBytes.length - lastLen);
+    plain2.writeBytes(messageBytes, messageBytes.length - lastLen, lastLen);
+    ByteBuf plain = Unpooled.wrappedBuffer(plain1, plain2);
+    frameEncrypt.plain = Collections.singletonList(plain);
+    frameEncrypt.out = getDirectBuffer(messageBytes.length + client.getSuffixLength(), ref);
+
+    client.encrypt(frameEncrypt.out, frameEncrypt.plain);
+
+    int tagLen = client.getSuffixLength();
+    FrameDecrypt frameDecrypt = new FrameDecrypt();
+    ByteBuf out = frameEncrypt.out;
+    int outLen = out.readableBytes();
+    ByteBuf cipher1 = getDirectBuffer(outLen - lastLen - tagLen, ref);
+    ByteBuf cipher2 = getDirectBuffer(lastLen, ref);
+    cipher1.writeBytes(out, 0, outLen - lastLen - tagLen);
+    cipher2.writeBytes(out, outLen - tagLen - lastLen, lastLen);
+    ByteBuf cipher = Unpooled.wrappedBuffer(cipher1, cipher2);
+    frameDecrypt.ciphertext = Collections.singletonList(cipher);
+    frameDecrypt.tag = out.slice(out.readerIndex() + out.readableBytes() - tagLen, tagLen);
+    frameDecrypt.out = getDirectBuffer(out.readableBytes(), ref);
+
+    server.decrypt(frameDecrypt.out, frameDecrypt.tag, frameDecrypt.ciphertext);
+    assertThat(frameEncrypt.plain.get(0).slice(0, frameDecrypt.out.readableBytes()))
+        .isEqualTo(frameDecrypt.out);
+  }
+
+  @Test
+  public void reflection() throws GeneralSecurityException {
+    String message = "Hello world";
+    FrameEncrypt frameEncrypt = createFrameEncrypt(message);
+    client.encrypt(frameEncrypt.out, frameEncrypt.plain);
+    FrameDecrypt frameDecrypt = frameDecryptOfEncrypt(frameEncrypt);
+    try {
+      client.decrypt(frameDecrypt.out, frameDecrypt.tag, frameDecrypt.ciphertext);
+      fail("Exception expected");
+    } catch (AEADBadTagException ex) {
+      assertThat(ex).hasMessageThat().containsMatch(DECRYPTION_FAILURE_MESSAGE_RE);
+    }
+  }
+
+  @Test
+  public void skipMessage() throws GeneralSecurityException {
+    String message = "Hello world";
+    FrameEncrypt frameEncrypt1 = createFrameEncrypt(message);
+    client.encrypt(frameEncrypt1.out, frameEncrypt1.plain);
+    FrameEncrypt frameEncrypt2 = createFrameEncrypt(message);
+    client.encrypt(frameEncrypt2.out, frameEncrypt2.plain);
+    FrameDecrypt frameDecrypt = frameDecryptOfEncrypt(frameEncrypt2);
+
+    try {
+      client.decrypt(frameDecrypt.out, frameDecrypt.tag, frameDecrypt.ciphertext);
+      fail("Exception expected");
+    } catch (AEADBadTagException ex) {
+      assertThat(ex).hasMessageThat().containsMatch(DECRYPTION_FAILURE_MESSAGE_RE);
+    }
+  }
+
+  @Test
+  public void corruptMessage() throws GeneralSecurityException {
+    String message = "Hello world";
+    FrameEncrypt frameEncrypt = createFrameEncrypt(message);
+    client.encrypt(frameEncrypt.out, frameEncrypt.plain);
+    FrameDecrypt frameDecrypt = frameDecryptOfEncrypt(frameEncrypt);
+    frameEncrypt.out.setByte(3, frameEncrypt.out.getByte(3) + 1);
+
+    try {
+      client.decrypt(frameDecrypt.out, frameDecrypt.tag, frameDecrypt.ciphertext);
+      fail("Exception expected");
+    } catch (AEADBadTagException ex) {
+      assertThat(ex).hasMessageThat().containsMatch(DECRYPTION_FAILURE_MESSAGE_RE);
+    }
+  }
+
+  @Test
+  public void replayMessage() throws GeneralSecurityException {
+    String message = "Hello world";
+    FrameEncrypt frameEncrypt = createFrameEncrypt(message);
+    client.encrypt(frameEncrypt.out, frameEncrypt.plain);
+    FrameDecrypt frameDecrypt1 = frameDecryptOfEncrypt(frameEncrypt);
+    FrameDecrypt frameDecrypt2 = frameDecryptOfEncrypt(frameEncrypt);
+
+    server.decrypt(frameDecrypt1.out, frameDecrypt1.tag, frameDecrypt1.ciphertext);
+
+    try {
+      server.decrypt(frameDecrypt2.out, frameDecrypt2.tag, frameDecrypt2.ciphertext);
+      fail("Exception expected");
+    } catch (AEADBadTagException ex) {
+      assertThat(ex).hasMessageThat().containsMatch(DECRYPTION_FAILURE_MESSAGE_RE);
+    }
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/FakeChannelCrypter.java b/alts/src/test/java/io/grpc/alts/internal/FakeChannelCrypter.java
new file mode 100644
index 00000000000..037af017ae9
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/FakeChannelCrypter.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.base.Preconditions.checkState;
+
+import io.netty.buffer.ByteBuf;
+import java.security.GeneralSecurityException;
+import java.util.Collections;
+import java.util.List;
+import javax.crypto.AEADBadTagException;
+
+public final class FakeChannelCrypter implements ChannelCrypterNetty {
+  private static final int TAG_BYTES = 16;
+  private static final byte TAG_BYTE = (byte) 0xa1;
+
+  private boolean destroyCalled = false;
+
+  public static int getTagBytes() {
+    return TAG_BYTES;
+  }
+
+  @Override
+  public void encrypt(ByteBuf out, List<ByteBuf> plain) throws GeneralSecurityException {
+    checkState(!destroyCalled);
+    for (ByteBuf buf : plain) {
+      out.writeBytes(buf);
+      for (int i = 0; i < TAG_BYTES; ++i) {
+        out.writeByte(TAG_BYTE);
+      }
+    }
+  }
+
+  @Override
+  public void decrypt(ByteBuf out, ByteBuf tag, List<ByteBuf> ciphertext)
+      throws GeneralSecurityException {
+    checkState(!destroyCalled);
+    for (ByteBuf buf : ciphertext) {
+      out.writeBytes(buf);
+    }
+    while (tag.isReadable()) {
+      if (tag.readByte() != TAG_BYTE) {
+        throw new AEADBadTagException("Tag mismatch!");
+      }
+    }
+  }
+
+  @Override
+  public void decrypt(ByteBuf out, ByteBuf ciphertextAndTag) throws GeneralSecurityException {
+    checkState(!destroyCalled);
+    ByteBuf ciphertext = ciphertextAndTag.readSlice(ciphertextAndTag.readableBytes() - TAG_BYTES);
+    decrypt(out, /*tag=*/ ciphertextAndTag, Collections.singletonList(ciphertext));
+  }
+
+  @Override
+  public int getSuffixLength() {
+    return TAG_BYTES;
+  }
+
+  @Override
+  public void destroy() {
+    destroyCalled = true;
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/FakeTsiHandshaker.java b/alts/src/test/java/io/grpc/alts/internal/FakeTsiHandshaker.java
new file mode 100644
index 00000000000..7a6119dc0be
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/FakeTsiHandshaker.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.google.common.base.Preconditions;
+import io.grpc.ChannelLogger;
+import io.grpc.alts.internal.TsiPeer.Property;
+import io.grpc.internal.TestUtils.NoopChannelLogger;
+import io.netty.buffer.ByteBufAllocator;
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+import java.util.Collections;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A fake handshaker compatible with security/transport_security/fake_transport_security.h See
+ * {@link TsiHandshaker} for documentation.
+ */
+public class FakeTsiHandshaker implements TsiHandshaker {
+  private static final Logger logger = Logger.getLogger(FakeTsiHandshaker.class.getName());
+
+  private static final TsiHandshakerFactory clientHandshakerFactory =
+      new TsiHandshakerFactory() {
+        @Override
+        public TsiHandshaker newHandshaker(String authority, ChannelLogger logger) {
+          return new FakeTsiHandshaker(true);
+        }
+      };
+
+  private static final TsiHandshakerFactory serverHandshakerFactory =
+      new TsiHandshakerFactory() {
+        @Override
+        public TsiHandshaker newHandshaker(String authority, ChannelLogger logger) {
+          return new FakeTsiHandshaker(false);
+        }
+      };
+
+  private boolean isClient;
+  private ByteBuffer sendBuffer = null;
+  private AltsFraming.Parser frameParser = new AltsFraming.Parser();
+
+  private State sendState;
+  private State receiveState;
+
+  enum State {
+    CLIENT_NONE,
+    SERVER_NONE,
+    CLIENT_INIT,
+    SERVER_INIT,
+    CLIENT_FINISHED,
+    SERVER_FINISHED;
+
+    // Returns the next State. In order to advance to sendState=N, receiveState must be N-1.
+    @SuppressWarnings("EnumOrdinal")
+    public State next() {
+      if (ordinal() + 1 < values().length) {
+        return values()[ordinal() + 1];
+      }
+      throw new UnsupportedOperationException("Can't call next() on last element: " + this);
+    }
+  }
+
+  public static TsiHandshakerFactory clientHandshakerFactory() {
+    return clientHandshakerFactory;
+  }
+
+  public static TsiHandshakerFactory serverHandshakerFactory() {
+    return serverHandshakerFactory;
+  }
+
+  public static TsiHandshaker newFakeHandshakerClient() {
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    return clientHandshakerFactory.newHandshaker(null, channelLogger);
+  }
+
+  public static TsiHandshaker newFakeHandshakerServer() {
+    NoopChannelLogger channelLogger = new NoopChannelLogger();
+    return serverHandshakerFactory.newHandshaker(null, channelLogger);
+  }
+
+  protected FakeTsiHandshaker(boolean isClient) {
+    this.isClient = isClient;
+    if (isClient) {
+      sendState = State.CLIENT_NONE;
+      receiveState = State.SERVER_NONE;
+    } else {
+      sendState = State.SERVER_NONE;
+      receiveState = State.CLIENT_NONE;
+    }
+  }
+
+  private State getNextState(State state) {
+    switch (state) {
+      case CLIENT_NONE:
+        return State.CLIENT_INIT;
+      case SERVER_NONE:
+        return State.SERVER_INIT;
+      case CLIENT_INIT:
+        return State.CLIENT_FINISHED;
+      case SERVER_INIT:
+        return State.SERVER_FINISHED;
+      default:
+        return null;
+    }
+  }
+
+  private String getNextMessage() {
+    State result = getNextState(sendState);
+    return result == null ? "BAD STATE" : result.toString();
+  }
+
+  private String getExpectedMessage() {
+    State result = getNextState(receiveState);
+    return result == null ? "BAD STATE" : result.toString();
+  }
+
+  private void incrementSendState() {
+    sendState = getNextState(sendState);
+  }
+
+  private void incrementReceiveState() {
+    receiveState = getNextState(receiveState);
+  }
+
+  @Override
+  public void getBytesToSendToPeer(ByteBuffer bytes) throws GeneralSecurityException {
+    Preconditions.checkNotNull(bytes);
+
+    // If we're done, return nothing.
+    if (sendState == State.CLIENT_FINISHED || sendState == State.SERVER_FINISHED) {
+      return;
+    }
+
+    // Prepare the next message, if needed.
+    if (sendBuffer == null) {
+      if (sendState.next() != receiveState) {
+        // We're still waiting for bytes from the peer, so bail.
+        return;
+      }
+      ByteBuffer payload = ByteBuffer.wrap(getNextMessage().getBytes(UTF_8));
+      sendBuffer = AltsFraming.toFrame(payload, payload.remaining());
+      logger.log(Level.FINE, "Buffered message: {0}", getNextMessage());
+    }
+    while (bytes.hasRemaining() && sendBuffer.hasRemaining()) {
+      bytes.put(sendBuffer.get());
+    }
+    if (!sendBuffer.hasRemaining()) {
+      // Get ready to send the next message.
+      sendBuffer = null;
+      incrementSendState();
+    }
+  }
+
+  @Override
+  public boolean processBytesFromPeer(ByteBuffer bytes) throws GeneralSecurityException {
+    Preconditions.checkNotNull(bytes);
+
+    frameParser.readBytes(bytes);
+    if (frameParser.isComplete()) {
+      ByteBuffer messageBytes = frameParser.getRawFrame();
+      int offset = AltsFraming.getFramingOverhead();
+      int length = messageBytes.limit() - offset;
+      @SuppressWarnings("ByteBufferBackingArray") // ByteBuffer is created using allocate()
+      String message = new String(messageBytes.array(), offset, length, UTF_8);
+      logger.log(Level.FINE, "Read message: {0}", message);
+
+      if (!message.equals(getExpectedMessage())) {
+        throw new IllegalArgumentException(
+            "Bad handshake message. Got "
+                + message
+                + " (length = "
+                + message.length()
+                + ") expected "
+                + getExpectedMessage()
+                + " (length = "
+                + getExpectedMessage().length()
+                + ")");
+      }
+      incrementReceiveState();
+      return true;
+    }
+    return false;
+  }
+
+  @Override
+  public boolean isInProgress() {
+    boolean finishedReceiving =
+        receiveState == State.CLIENT_FINISHED || receiveState == State.SERVER_FINISHED;
+    boolean finishedSending =
+        sendState == State.CLIENT_FINISHED || sendState == State.SERVER_FINISHED;
+    return !finishedSending || !finishedReceiving;
+  }
+
+  @Override
+  public TsiPeer extractPeer() {
+    return new TsiPeer(Collections.<Property<?>>emptyList());
+  }
+
+  @Override
+  public Object extractPeerObject() {
+    return AltsInternalContext.getDefaultInstance();
+  }
+
+  @Override
+  public TsiFrameProtector createFrameProtector(int maxFrameSize, ByteBufAllocator alloc) {
+    Preconditions.checkState(!isInProgress(), "Handshake is not complete.");
+
+    // We use an all-zero key, since this is the fake handshaker.
+    byte[] key = new byte[AltsChannelCrypter.getKeyLength()];
+    return new AltsTsiFrameProtector(maxFrameSize, new AltsChannelCrypter(key, isClient), alloc);
+  }
+
+  @Override
+  public TsiFrameProtector createFrameProtector(ByteBufAllocator alloc) {
+    return createFrameProtector(AltsTsiFrameProtector.getMinFrameSize(), alloc);
+  }
+
+  @Override
+  public void close() {
+    // No-op
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/FakeTsiTest.java b/alts/src/test/java/io/grpc/alts/internal/FakeTsiTest.java
new file mode 100644
index 00000000000..f908160f958
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/FakeTsiTest.java
@@ -0,0 +1,214 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import com.google.common.testing.GcFinalization;
+import io.grpc.alts.internal.ByteBufTestUtils.RegisterRef;
+import io.grpc.alts.internal.TsiTest.Handshakers;
+import io.netty.buffer.ByteBuf;
+import io.netty.util.ReferenceCounted;
+import io.netty.util.ResourceLeakDetector;
+import io.netty.util.ResourceLeakDetector.Level;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link TsiHandshaker}. */
+@RunWith(JUnit4.class)
+public class FakeTsiTest {
+
+  private static final int OVERHEAD =
+      FakeChannelCrypter.getTagBytes() + AltsTsiFrameProtector.getHeaderBytes();
+
+  private final List<ReferenceCounted> references = new ArrayList<>();
+  private final RegisterRef ref =
+      new RegisterRef() {
+        @Override
+        public ByteBuf register(ByteBuf buf) {
+          if (buf != null) {
+            references.add(buf);
+          }
+          return buf;
+        }
+      };
+
+  private static Handshakers newHandshakers() {
+    TsiHandshaker clientHandshaker = FakeTsiHandshaker.newFakeHandshakerClient();
+    TsiHandshaker serverHandshaker = FakeTsiHandshaker.newFakeHandshakerServer();
+    return new Handshakers(clientHandshaker, serverHandshaker);
+  }
+
+  @Before
+  public void setUp() {
+    ResourceLeakDetector.setLevel(Level.PARANOID);
+  }
+
+  @After
+  public void tearDown() {
+    for (ReferenceCounted reference : references) {
+      reference.release();
+    }
+    references.clear();
+    // Increase our chances to detect ByteBuf leaks.
+    GcFinalization.awaitFullGc();
+  }
+
+  @Test
+  public void handshakeStateOrderTest() {
+    try {
+      Handshakers handshakers = newHandshakers();
+      TsiHandshaker clientHandshaker = handshakers.getClient();
+      TsiHandshaker serverHandshaker = handshakers.getServer();
+
+      byte[] transportBufferBytes = new byte[TsiTest.getDefaultTransportBufferSize()];
+      ByteBuffer transportBuffer = ByteBuffer.wrap(transportBufferBytes);
+      ((Buffer) transportBuffer).limit(0); // Start off with an empty buffer
+
+      ((Buffer) transportBuffer).clear();
+      clientHandshaker.getBytesToSendToPeer(transportBuffer);
+      ((Buffer) transportBuffer).flip();
+      assertEquals(
+          FakeTsiHandshaker.State.CLIENT_INIT.toString().trim(),
+          new String(transportBufferBytes, 4, transportBuffer.remaining(), UTF_8).trim());
+
+      serverHandshaker.processBytesFromPeer(transportBuffer);
+      assertFalse(transportBuffer.hasRemaining());
+
+      // client shouldn't offer any more bytes
+      ((Buffer) transportBuffer).clear();
+      clientHandshaker.getBytesToSendToPeer(transportBuffer);
+      ((Buffer) transportBuffer).flip();
+      assertFalse(transportBuffer.hasRemaining());
+
+      ((Buffer) transportBuffer).clear();
+      serverHandshaker.getBytesToSendToPeer(transportBuffer);
+      ((Buffer) transportBuffer).flip();
+      assertEquals(
+          FakeTsiHandshaker.State.SERVER_INIT.toString().trim(),
+          new String(transportBufferBytes, 4, transportBuffer.remaining(), UTF_8).trim());
+
+      clientHandshaker.processBytesFromPeer(transportBuffer);
+      assertFalse(transportBuffer.hasRemaining());
+
+      // server shouldn't offer any more bytes
+      ((Buffer) transportBuffer).clear();
+      serverHandshaker.getBytesToSendToPeer(transportBuffer);
+      ((Buffer) transportBuffer).flip();
+      assertFalse(transportBuffer.hasRemaining());
+
+      ((Buffer) transportBuffer).clear();
+      clientHandshaker.getBytesToSendToPeer(transportBuffer);
+      ((Buffer) transportBuffer).flip();
+      assertEquals(
+          FakeTsiHandshaker.State.CLIENT_FINISHED.toString().trim(),
+          new String(transportBufferBytes, 4, transportBuffer.remaining(), UTF_8).trim());
+
+      serverHandshaker.processBytesFromPeer(transportBuffer);
+      assertFalse(transportBuffer.hasRemaining());
+
+      // client shouldn't offer any more bytes
+      ((Buffer) transportBuffer).clear();
+      clientHandshaker.getBytesToSendToPeer(transportBuffer);
+      ((Buffer) transportBuffer).flip();
+      assertFalse(transportBuffer.hasRemaining());
+
+      ((Buffer) transportBuffer).clear();
+      serverHandshaker.getBytesToSendToPeer(transportBuffer);
+      ((Buffer) transportBuffer).flip();
+      assertEquals(
+          FakeTsiHandshaker.State.SERVER_FINISHED.toString().trim(),
+          new String(transportBufferBytes, 4, transportBuffer.remaining(), UTF_8).trim());
+
+      clientHandshaker.processBytesFromPeer(transportBuffer);
+      assertFalse(transportBuffer.hasRemaining());
+
+      // server shouldn't offer any more bytes
+      ((Buffer) transportBuffer).clear();
+      serverHandshaker.getBytesToSendToPeer(transportBuffer);
+      ((Buffer) transportBuffer).flip();
+      assertFalse(transportBuffer.hasRemaining());
+    } catch (GeneralSecurityException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  @Test
+  public void handshake() throws GeneralSecurityException {
+    TsiTest.handshakeTest(newHandshakers());
+  }
+
+  @Test
+  public void handshakeSmallBuffer() throws GeneralSecurityException {
+    TsiTest.handshakeSmallBufferTest(newHandshakers());
+  }
+
+  @Test
+  public void pingPong() throws GeneralSecurityException {
+    TsiTest.pingPongTest(newHandshakers(), ref);
+  }
+
+  @Test
+  public void pingPongExactFrameSize() throws GeneralSecurityException {
+    TsiTest.pingPongExactFrameSizeTest(newHandshakers(), ref);
+  }
+
+  @Test
+  public void pingPongSmallBuffer() throws GeneralSecurityException {
+    TsiTest.pingPongSmallBufferTest(newHandshakers(), ref);
+  }
+
+  @Test
+  public void pingPongSmallFrame() throws GeneralSecurityException {
+    TsiTest.pingPongSmallFrameTest(OVERHEAD, newHandshakers(), ref);
+  }
+
+  @Test
+  public void pingPongSmallFrameSmallBuffer() throws GeneralSecurityException {
+    TsiTest.pingPongSmallFrameSmallBufferTest(OVERHEAD, newHandshakers(), ref);
+  }
+
+  @Test
+  public void corruptedCounter() throws GeneralSecurityException {
+    TsiTest.corruptedCounterTest(newHandshakers(), ref);
+  }
+
+  @Test
+  public void corruptedCiphertext() throws GeneralSecurityException {
+    TsiTest.corruptedCiphertextTest(newHandshakers(), ref);
+  }
+
+  @Test
+  public void corruptedTag() throws GeneralSecurityException {
+    TsiTest.corruptedTagTest(newHandshakers(), ref);
+  }
+
+  @Test
+  public void reflectedCiphertext() throws GeneralSecurityException {
+    TsiTest.reflectedCiphertextTest(newHandshakers(), ref);
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/GoogleDefaultProtocolNegotiatorTest.java b/alts/src/test/java/io/grpc/alts/internal/GoogleDefaultProtocolNegotiatorTest.java
new file mode 100644
index 00000000000..14c19e554ae
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/GoogleDefaultProtocolNegotiatorTest.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.Attributes;
+import io.grpc.Channel;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.ManagedChannel;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.internal.ObjectPool;
+import io.grpc.netty.GrpcHttp2ConnectionHandler;
+import io.grpc.netty.GrpcSslContexts;
+import io.grpc.netty.InternalProtocolNegotiationEvent;
+import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.channel.embedded.EmbeddedChannel;
+import io.netty.handler.ssl.SslContext;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(Enclosed.class)
+public final class GoogleDefaultProtocolNegotiatorTest {
+
+  @RunWith(JUnit4.class)
+  public abstract static class HandlerSelectionTest {
+    private ProtocolNegotiator googleProtocolNegotiator;
+    private Attributes.Key<String> originalClusterNameAttrKey;
+    private final ObjectPool<Channel> handshakerChannelPool = new ObjectPool<Channel>() {
+
+      @Override
+      public Channel getObject() {
+        return InProcessChannelBuilder.forName("test").build();
+      }
+
+      @Override
+      public Channel returnObject(Object object) {
+        ((ManagedChannel) object).shutdownNow();
+        return null;
+      }
+    };
+
+    @Before
+    public void setUp() throws Exception {
+      SslContext sslContext = GrpcSslContexts.forClient().build();
+      originalClusterNameAttrKey =
+          AltsProtocolNegotiator.GoogleDefaultProtocolNegotiatorFactory.clusterNameAttrKey;
+      AltsProtocolNegotiator.GoogleDefaultProtocolNegotiatorFactory.clusterNameAttrKey =
+          getClusterNameAttrKey();
+      googleProtocolNegotiator = new AltsProtocolNegotiator.GoogleDefaultProtocolNegotiatorFactory(
+          ImmutableList.<String>of(),
+          handshakerChannelPool,
+          sslContext)
+          .newNegotiator();
+    }
+
+    @After
+    public void tearDown() {
+      googleProtocolNegotiator.close();
+      AltsProtocolNegotiator.GoogleDefaultProtocolNegotiatorFactory.clusterNameAttrKey =
+          originalClusterNameAttrKey;
+    }
+
+    @Nullable
+    abstract Attributes.Key<String> getClusterNameAttrKey();
+
+    @Test
+    public void tlsHandler_emptyAttributes() {
+      subtest_tlsHandler(Attributes.EMPTY);
+    }
+
+    void subtest_altsHandler(Attributes eagAttributes) {
+      GrpcHttp2ConnectionHandler mockHandler = mock(GrpcHttp2ConnectionHandler.class);
+      when(mockHandler.getEagAttributes()).thenReturn(eagAttributes);
+      ChannelLogger logger = mock(ChannelLogger.class);
+      doNothing().when(logger).log(any(ChannelLogLevel.class), anyString());
+      when(mockHandler.getNegotiationLogger()).thenReturn(logger);
+
+      final AtomicReference<Throwable> failure = new AtomicReference<>();
+      ChannelHandler exceptionCaught = new ChannelInboundHandlerAdapter() {
+        @Override
+        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+          failure.set(cause);
+          super.exceptionCaught(ctx, cause);
+        }
+      };
+      ChannelHandler h = googleProtocolNegotiator.newHandler(mockHandler);
+      EmbeddedChannel chan = new EmbeddedChannel(exceptionCaught);
+      // Add the negotiator handler last, but to the front. Putting this in ctor above would make
+      // it throw early.
+      chan.pipeline().addFirst(h);
+      chan.pipeline().fireUserEventTriggered(InternalProtocolNegotiationEvent.getDefault());
+
+      // Check that the message complained about the ALTS code, rather than SSL.  ALTS throws on
+      // being added, so it's hard to catch it at the right time to make this assertion.
+      assertThat(failure.get()).hasMessageThat().contains("TsiHandshakeHandler");
+    }
+
+    void subtest_tlsHandler(Attributes eagAttributes) {
+      GrpcHttp2ConnectionHandler mockHandler = mock(GrpcHttp2ConnectionHandler.class);
+      when(mockHandler.getEagAttributes()).thenReturn(eagAttributes);
+      when(mockHandler.getAuthority()).thenReturn("authority");
+      ChannelLogger logger = mock(ChannelLogger.class);
+      doNothing().when(logger).log(any(ChannelLogLevel.class), anyString());
+      when(mockHandler.getNegotiationLogger()).thenReturn(logger);
+
+      ChannelHandler h = googleProtocolNegotiator.newHandler(mockHandler);
+      EmbeddedChannel chan = new EmbeddedChannel(h);
+      chan.pipeline().fireUserEventTriggered(InternalProtocolNegotiationEvent.getDefault());
+
+      assertThat(chan.pipeline().first().getClass().getSimpleName()).isEqualTo("SslHandler");
+    }
+  }
+
+  @RunWith(JUnit4.class)
+  public static class WithoutXdsInClasspath extends HandlerSelectionTest {
+
+    @Nullable
+    @Override
+    Attributes.Key<String> getClusterNameAttrKey() {
+      return null;
+    }
+  }
+
+  @RunWith(JUnit4.class)
+  public static class WithXdsInClasspath extends HandlerSelectionTest {
+    // Same as io.grpc.xds.InternalXdsAttributes.ATTR_CLUSTER_NAME
+    private static final Attributes.Key<String> XDS_CLUSTER_NAME_ATTR_KEY =
+        Attributes.Key.create("io.grpc.xds.InternalXdsAttributes.clusterName");
+
+    @Nullable
+    @Override
+    Attributes.Key<String> getClusterNameAttrKey() {
+      return XDS_CLUSTER_NAME_ATTR_KEY;
+    }
+
+    @Test
+    public void altsHandler_xdsCluster() {
+      Attributes attrs =
+          Attributes.newBuilder().set(XDS_CLUSTER_NAME_ATTR_KEY, "api.googleapis.com").build();
+      subtest_altsHandler(attrs);
+    }
+
+    @Test
+    public void tlsHandler_googleCfe() {
+      Attributes attrs = Attributes.newBuilder().set(
+          XDS_CLUSTER_NAME_ATTR_KEY, "google_cfe_api.googleapis.com").build();
+      subtest_tlsHandler(attrs);
+    }
+
+    @Test
+    public void altsHandler_googleCfe_federation() {
+      Attributes attrs = Attributes.newBuilder().set(
+          XDS_CLUSTER_NAME_ATTR_KEY, "xdstp1://").build();
+      subtest_altsHandler(attrs);
+    }
+
+    @Test
+    public void tlsHanlder_googleCfe() {
+      Attributes attrs = Attributes.newBuilder().set(
+          XDS_CLUSTER_NAME_ATTR_KEY,
+          "xdstp://traffic-director-c2p.xds.googleapis.com/"
+              + "envoy.config.cluster.v3.Cluster/google_cfe_example/apis")
+          .build();
+      subtest_tlsHandler(attrs);
+    }
+
+    @Test
+    public void altsHanlder_nonGoogleCfe_authorityNotMatch() {
+      Attributes attrs = Attributes.newBuilder().set(
+              XDS_CLUSTER_NAME_ATTR_KEY,
+              "//example.com/envoy.config.cluster.v3.Cluster/google_cfe_")
+          .build();
+      subtest_altsHandler(attrs);
+    }
+
+    @Test
+    public void altsHanlder_nonGoogleCfe_pathNotMatch() {
+      Attributes attrs = Attributes.newBuilder().set(
+          XDS_CLUSTER_NAME_ATTR_KEY,
+          "//traffic-director-c2p.xds.googleapis.com/envoy.config.cluster.v3.Cluster/google_gfe")
+          .build();
+      subtest_altsHandler(attrs);
+    }
+
+    @Test
+    public void altsHandler_googleCfe_invalidUri() {
+      Attributes attrs = Attributes.newBuilder().set(
+          XDS_CLUSTER_NAME_ATTR_KEY, "//").build();
+      subtest_altsHandler(attrs);
+    }
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/MockAltsHandshakerResp.java b/alts/src/test/java/io/grpc/alts/internal/MockAltsHandshakerResp.java
new file mode 100644
index 00000000000..a21082be41f
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/MockAltsHandshakerResp.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.google.protobuf.ByteString;
+import io.grpc.Status;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.security.SecureRandom;
+import java.util.Random;
+
+/** A class for mocking ALTS Handshaker Responses. */
+class MockAltsHandshakerResp {
+  private static final String TEST_ERROR_DETAILS = "handshake error";
+  private static final String TEST_APPLICATION_PROTOCOL = "grpc";
+  private static final String TEST_RECORD_PROTOCOL = "ALTSRP_GCM_AES128";
+  private static final String TEST_OUT_FRAME = "output frame";
+  private static final String TEST_LOCAL_ACCOUNT = "local@developer.gserviceaccount.com";
+  private static final String TEST_PEER_ACCOUNT = "peer@developer.gserviceaccount.com";
+  private static final byte[] TEST_KEY_DATA = initializeTestKeyData();
+  private static final int FRAME_HEADER_SIZE = 4;
+
+  static String getTestErrorDetails() {
+    return TEST_ERROR_DETAILS;
+  }
+
+  static String getTestPeerAccount() {
+    return TEST_PEER_ACCOUNT;
+  }
+
+  private static byte[] initializeTestKeyData() {
+    Random random = new SecureRandom();
+    byte[] randombytes = new byte[AltsChannelCrypter.getKeyLength()];
+    random.nextBytes(randombytes);
+    return randombytes;
+  }
+
+  static byte[] getTestKeyData() {
+    return TEST_KEY_DATA;
+  }
+
+  /** Returns a mock output frame. */
+  static ByteString getOutFrame() {
+    int frameSize = TEST_OUT_FRAME.length();
+    ByteBuffer buffer = ByteBuffer.allocate(FRAME_HEADER_SIZE + frameSize);
+    buffer.order(ByteOrder.LITTLE_ENDIAN);
+    buffer.putInt(frameSize);
+    buffer.put(TEST_OUT_FRAME.getBytes(UTF_8));
+    ((Buffer) buffer).flip();
+    return ByteString.copyFrom(buffer);
+  }
+
+  /** Returns a mock error handshaker response. */
+  static HandshakerResp getErrorResponse() {
+    HandshakerResp.Builder resp = HandshakerResp.newBuilder();
+    resp.setStatus(
+        HandshakerStatus.newBuilder()
+            .setCode(Status.Code.UNKNOWN.value())
+            .setDetails(TEST_ERROR_DETAILS)
+            .build());
+    return resp.build();
+  }
+
+  /** Returns a mock normal handshaker response. */
+  static HandshakerResp getOkResponse(int bytesConsumed) {
+    HandshakerResp.Builder resp = HandshakerResp.newBuilder();
+    resp.setOutFrames(getOutFrame());
+    resp.setBytesConsumed(bytesConsumed);
+    resp.setStatus(HandshakerStatus.newBuilder().setCode(Status.Code.OK.value()).build());
+    return resp.build();
+  }
+
+  /** Returns a mock normal handshaker response. */
+  static HandshakerResp getEmptyOutFrameResponse(int bytesConsumed) {
+    HandshakerResp.Builder resp = HandshakerResp.newBuilder();
+    resp.setBytesConsumed(bytesConsumed);
+    resp.setStatus(HandshakerStatus.newBuilder().setCode(Status.Code.OK.value()).build());
+    return resp.build();
+  }
+
+  /** Returns a mock final handshaker response with handshake result. */
+  static HandshakerResp getFinishedResponse(int bytesConsumed) {
+    HandshakerResp.Builder resp = HandshakerResp.newBuilder();
+    HandshakerResult.Builder result =
+        HandshakerResult.newBuilder()
+            .setApplicationProtocol(TEST_APPLICATION_PROTOCOL)
+            .setRecordProtocol(TEST_RECORD_PROTOCOL)
+            .setPeerIdentity(Identity.newBuilder().setServiceAccount(TEST_PEER_ACCOUNT).build())
+            .setLocalIdentity(Identity.newBuilder().setServiceAccount(TEST_LOCAL_ACCOUNT).build())
+            .setKeyData(ByteString.copyFrom(TEST_KEY_DATA));
+    resp.setOutFrames(getOutFrame());
+    resp.setBytesConsumed(bytesConsumed);
+    resp.setStatus(HandshakerStatus.newBuilder().setCode(Status.Code.OK.value()).build());
+    resp.setResult(result.build());
+    return resp.build();
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/NettyTsiHandshakerTest.java b/alts/src/test/java/io/grpc/alts/internal/NettyTsiHandshakerTest.java
new file mode 100644
index 00000000000..d71ff16f352
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/NettyTsiHandshakerTest.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.UnpooledByteBufAllocator;
+import io.netty.util.ReferenceCounted;
+import java.lang.reflect.Method;
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class NettyTsiHandshakerTest {
+  private final UnpooledByteBufAllocator alloc = UnpooledByteBufAllocator.DEFAULT;
+  private final List<ReferenceCounted> references = new ArrayList<>();
+
+  private final NettyTsiHandshaker clientHandshaker =
+      new NettyTsiHandshaker(FakeTsiHandshaker.newFakeHandshakerClient());
+  private final NettyTsiHandshaker serverHandshaker =
+      new NettyTsiHandshaker(FakeTsiHandshaker.newFakeHandshakerServer());
+
+  @After
+  public void teardown() {
+    for (ReferenceCounted reference : references) {
+      reference.release(reference.refCnt());
+    }
+  }
+
+  @Test
+  public void failsOnNullHandshaker() {
+    try {
+      new NettyTsiHandshaker(null);
+      fail("Exception expected");
+    } catch (NullPointerException ex) {
+      // Do nothing.
+    }
+  }
+
+  @Test
+  public void processPeerHandshakeShouldAcceptPartialFrames() throws GeneralSecurityException {
+    for (int i = 0; i < 1024; i++) {
+      ByteBuf clientData = ref(alloc.buffer(1));
+      clientHandshaker.getBytesToSendToPeer(clientData);
+      if (clientData.isReadable()) {
+        if (serverHandshaker.processBytesFromPeer(clientData)) {
+          // Done.
+          return;
+        }
+      }
+    }
+    fail("Failed to process the handshake frame.");
+  }
+
+  @Test
+  public void handshakeShouldSucceed() throws GeneralSecurityException {
+    doHandshake();
+  }
+
+  @Test
+  public void isInProgress() throws GeneralSecurityException {
+    assertTrue(clientHandshaker.isInProgress());
+    assertTrue(serverHandshaker.isInProgress());
+
+    doHandshake();
+
+    assertFalse(clientHandshaker.isInProgress());
+    assertFalse(serverHandshaker.isInProgress());
+  }
+
+  @Test
+  public void extractPeer_notNull() throws GeneralSecurityException {
+    doHandshake();
+
+    assertNotNull(serverHandshaker.extractPeer());
+    assertNotNull(clientHandshaker.extractPeer());
+  }
+
+  @Test
+  public void extractPeer_failsBeforeHandshake() throws GeneralSecurityException {
+    try {
+      clientHandshaker.extractPeer();
+      fail("Exception expected");
+    } catch (IllegalStateException ex) {
+      // Do nothing.
+    }
+  }
+
+  @Test
+  public void extractPeerObject_notNull() throws GeneralSecurityException {
+    doHandshake();
+
+    assertNotNull(serverHandshaker.extractPeerObject());
+    assertNotNull(clientHandshaker.extractPeerObject());
+  }
+
+  @Test
+  public void extractPeerObject_failsBeforeHandshake() throws GeneralSecurityException {
+    try {
+      clientHandshaker.extractPeerObject();
+      fail("Exception expected");
+    } catch (IllegalStateException ex) {
+      // Do nothing.
+    }
+  }
+
+  /**
+   * NettyTsiHandshaker just converts {@link ByteBuffer} to {@link ByteBuf}, so check that the other
+   * methods are otherwise the same.
+   */
+  @Test
+  public void handshakerMethodsMatch() {
+    List<String> expectedMethods = new ArrayList<>();
+    for (Method m : TsiHandshaker.class.getDeclaredMethods()) {
+      expectedMethods.add(m.getName());
+    }
+
+    List<String> actualMethods = new ArrayList<>();
+    for (Method m : NettyTsiHandshaker.class.getDeclaredMethods()) {
+      actualMethods.add(m.getName());
+    }
+
+    assertThat(actualMethods).containsAtLeastElementsIn(expectedMethods);
+  }
+
+  static void doHandshake(
+      NettyTsiHandshaker clientHandshaker,
+      NettyTsiHandshaker serverHandshaker,
+      ByteBufAllocator alloc,
+      Function<ByteBuf, ByteBuf> ref)
+      throws GeneralSecurityException {
+    // Get the server response handshake frames.
+    for (int i = 0; i < 10; i++) {
+      if (!(clientHandshaker.isInProgress() || serverHandshaker.isInProgress())) {
+        return;
+      }
+
+      ByteBuf clientData = ref.apply(alloc.buffer());
+      clientHandshaker.getBytesToSendToPeer(clientData);
+      if (clientData.isReadable()) {
+        serverHandshaker.processBytesFromPeer(clientData);
+      }
+
+      ByteBuf serverData = ref.apply(alloc.buffer());
+      serverHandshaker.getBytesToSendToPeer(serverData);
+      if (serverData.isReadable()) {
+        clientHandshaker.processBytesFromPeer(serverData);
+      }
+    }
+
+    throw new AssertionError("Failed to complete the handshake.");
+  }
+
+  private void doHandshake() throws GeneralSecurityException {
+    doHandshake(
+        clientHandshaker,
+        serverHandshaker,
+        alloc,
+        new Function<ByteBuf, ByteBuf>() {
+          @Override
+          public ByteBuf apply(ByteBuf buf) {
+            return ref(buf);
+          }
+        });
+  }
+
+  private ByteBuf ref(ByteBuf buf) {
+    if (buf != null) {
+      references.add(buf);
+    }
+    return buf;
+  }
+
+  /** A mirror of java.util.function.Function without the Java 8 dependency. */
+  private interface Function<T, R> {
+    R apply(T t);
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/RpcProtocolVersionsUtilTest.java b/alts/src/test/java/io/grpc/alts/internal/RpcProtocolVersionsUtilTest.java
new file mode 100644
index 00000000000..07e0358e707
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/RpcProtocolVersionsUtilTest.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import io.grpc.alts.internal.RpcProtocolVersions.Version;
+import io.grpc.alts.internal.RpcProtocolVersionsUtil.RpcVersionsCheckResult;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link RpcProtocolVersionsUtil}. */
+@RunWith(JUnit4.class)
+public final class RpcProtocolVersionsUtilTest {
+
+  @Test
+  public void compareVersions() throws Exception {
+    assertTrue(
+        RpcProtocolVersionsUtil.isGreaterThanOrEqualTo(
+            Version.newBuilder().setMajor(3).setMinor(2).build(),
+            Version.newBuilder().setMajor(2).setMinor(1).build()));
+    assertTrue(
+        RpcProtocolVersionsUtil.isGreaterThanOrEqualTo(
+            Version.newBuilder().setMajor(3).setMinor(2).build(),
+            Version.newBuilder().setMajor(2).setMinor(1).build()));
+    assertTrue(
+        RpcProtocolVersionsUtil.isGreaterThanOrEqualTo(
+            Version.newBuilder().setMajor(3).setMinor(2).build(),
+            Version.newBuilder().setMajor(3).setMinor(2).build()));
+    assertFalse(
+        RpcProtocolVersionsUtil.isGreaterThanOrEqualTo(
+            Version.newBuilder().setMajor(2).setMinor(3).build(),
+            Version.newBuilder().setMajor(3).setMinor(2).build()));
+    assertFalse(
+        RpcProtocolVersionsUtil.isGreaterThanOrEqualTo(
+            Version.newBuilder().setMajor(3).setMinor(1).build(),
+            Version.newBuilder().setMajor(3).setMinor(2).build()));
+  }
+
+  @Test
+  public void checkRpcVersions() throws Exception {
+    // local.max > peer.max and local.min > peer.min
+    RpcVersionsCheckResult checkResult =
+        RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(3).setMinor(2).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .build(),
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(1).setMinor(2).build())
+                .build());
+    assertTrue(checkResult.getResult());
+    assertEquals(
+        Version.newBuilder().setMajor(2).setMinor(1).build(),
+        checkResult.getHighestCommonVersion());
+    // local.max > peer.max and local.min < peer.min
+    checkResult =
+        RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(3).setMinor(2).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(1).setMinor(2).build())
+                .build(),
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .build());
+    assertTrue(checkResult.getResult());
+    assertEquals(
+        Version.newBuilder().setMajor(2).setMinor(1).build(),
+        checkResult.getHighestCommonVersion());
+    // local.max > peer.max and local.min = peer.min
+    checkResult =
+        RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(3).setMinor(2).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .build(),
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .build());
+    assertTrue(checkResult.getResult());
+    assertEquals(
+        Version.newBuilder().setMajor(2).setMinor(1).build(),
+        checkResult.getHighestCommonVersion());
+    // local.max < peer.max and local.min > peer.min
+    checkResult =
+        RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .build(),
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(3).setMinor(2).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(1).setMinor(2).build())
+                .build());
+    assertTrue(checkResult.getResult());
+    assertEquals(
+        Version.newBuilder().setMajor(2).setMinor(1).build(),
+        checkResult.getHighestCommonVersion());
+    // local.max = peer.max and local.min > peer.min
+    checkResult =
+        RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .build(),
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(1).setMinor(2).build())
+                .build());
+    assertTrue(checkResult.getResult());
+    assertEquals(
+        Version.newBuilder().setMajor(2).setMinor(1).build(),
+        checkResult.getHighestCommonVersion());
+    // local.max < peer.max and local.min < peer.min
+    checkResult =
+        RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(1).setMinor(2).build())
+                .build(),
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(3).setMinor(2).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .build());
+    assertTrue(checkResult.getResult());
+    assertEquals(
+        Version.newBuilder().setMajor(2).setMinor(1).build(),
+        checkResult.getHighestCommonVersion());
+    // local.max < peer.max and local.min = peer.min
+    checkResult =
+        RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(1).setMinor(2).build())
+                .build(),
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(3).setMinor(2).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(1).setMinor(2).build())
+                .build());
+    assertTrue(checkResult.getResult());
+    assertEquals(
+        Version.newBuilder().setMajor(2).setMinor(1).build(),
+        checkResult.getHighestCommonVersion());
+    // local.max = peer.max and local.min < peer.min
+    checkResult =
+        RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(1).setMinor(2).build())
+                .build(),
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(1).setMinor(2).build())
+                .build());
+    assertTrue(checkResult.getResult());
+    assertEquals(
+        Version.newBuilder().setMajor(2).setMinor(1).build(),
+        checkResult.getHighestCommonVersion());
+    // all equal
+    checkResult =
+        RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .build(),
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .build());
+    assertTrue(checkResult.getResult());
+    assertEquals(
+        Version.newBuilder().setMajor(2).setMinor(1).build(),
+        checkResult.getHighestCommonVersion());
+    // max is smaller than min
+    checkResult =
+        RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(1).setMinor(2).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .build(),
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(1).setMinor(2).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .build());
+    assertFalse(checkResult.getResult());
+    assertEquals(null, checkResult.getHighestCommonVersion());
+    // no overlap, local > peer
+    checkResult =
+        RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(6).setMinor(5).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(4).setMinor(3).build())
+                .build(),
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(0).setMinor(0).build())
+                .build());
+    assertFalse(checkResult.getResult());
+    assertEquals(null, checkResult.getHighestCommonVersion());
+    // no overlap, local < peer
+    checkResult =
+        RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(1).setMinor(0).build())
+                .build(),
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(6).setMinor(5).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(4).setMinor(3).build())
+                .build());
+    assertFalse(checkResult.getResult());
+    assertEquals(null, checkResult.getHighestCommonVersion());
+    // no overlap, max < min
+    checkResult =
+        RpcProtocolVersionsUtil.checkRpcProtocolVersions(
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(4).setMinor(3).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(6).setMinor(5).build())
+                .build(),
+            RpcProtocolVersions.newBuilder()
+                .setMaxRpcVersion(Version.newBuilder().setMajor(1).setMinor(0).build())
+                .setMinRpcVersion(Version.newBuilder().setMajor(2).setMinor(1).build())
+                .build());
+    assertFalse(checkResult.getResult());
+    assertEquals(null, checkResult.getHighestCommonVersion());
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/TsiFrameHandlerTest.java b/alts/src/test/java/io/grpc/alts/internal/TsiFrameHandlerTest.java
new file mode 100644
index 00000000000..f9ed0fa4f97
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/TsiFrameHandlerTest.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelOutboundHandlerAdapter;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.embedded.EmbeddedChannel;
+import io.netty.util.CharsetUtil;
+import java.security.GeneralSecurityException;
+import java.util.List;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.DisableOnDebug;
+import org.junit.rules.TestRule;
+import org.junit.rules.Timeout;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link TsiFrameHandler}. */
+@RunWith(JUnit4.class)
+public class TsiFrameHandlerTest {
+
+  @Rule
+  public final TestRule globalTimeout = new DisableOnDebug(Timeout.seconds(5));
+
+  private final TsiFrameHandler tsiFrameHandler = new TsiFrameHandler(new IdentityFrameProtector());
+  private final EmbeddedChannel channel = new EmbeddedChannel(tsiFrameHandler);
+
+  @Test
+  public void writeAndFlush_handshakeSucceed() throws InterruptedException {
+    ByteBuf msg = Unpooled.copiedBuffer("message after handshake finished", CharsetUtil.UTF_8);
+
+    channel.writeAndFlush(msg);
+    Object actual = channel.readOutbound();
+
+    assertThat(actual).isEqualTo(msg);
+    channel.close().sync();
+    channel.checkException();
+  }
+
+  @Test
+  public void writeAndFlush_shouldBeIgnoredAfterClose() throws InterruptedException {
+    channel.close().sync();
+    ByteBuf msg = Unpooled.copiedBuffer("message after closed", CharsetUtil.UTF_8);
+
+    channel.writeAndFlush(msg);
+
+    assertThat(channel.outboundMessages()).isEmpty();
+    try {
+      channel.checkException();
+    } catch (Exception e) {
+      throw new AssertionError(
+          "Any attempt after close should be ignored without out exception", e);
+    }
+  }
+
+  @Test
+  public void close_shouldFlushRemainingMessage() throws InterruptedException {
+    ByteBuf msg = Unpooled.copiedBuffer("message after handshake failed", CharsetUtil.UTF_8);
+    channel.write(msg);
+
+    assertThat(channel.outboundMessages()).isEmpty();
+
+    channel.close().sync();
+    Object actual = channel.readOutbound();
+
+    assertWithMessage("pending write should be flushed on close").that(actual).isEqualTo(msg);
+    channel.checkException();
+  }
+
+  @Test
+  public void flushAfterCloseShouldWork() throws InterruptedException {
+    ByteBuf msg = Unpooled.copiedBuffer("message after handshake failed", CharsetUtil.UTF_8);
+    channel.write(msg);
+
+    channel.pipeline().addFirst(new ChannelOutboundHandlerAdapter() {
+      @Override
+      public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
+        // We have to call flush while doing a close, since close() tears down the pipeline
+        // immediately after.
+        channel.flush();
+        super.close(ctx, promise);
+      }
+    });
+
+    assertThat(channel.outboundMessages()).isEmpty();
+
+    channel.close().sync();
+    Object actual = channel.readOutbound();
+
+    assertWithMessage("pending write should be flushed on close").that(actual).isEqualTo(msg);
+    channel.checkException();
+  }
+
+  private static final class IdentityFrameProtector implements TsiFrameProtector {
+
+    @Override
+    public void protectFlush(List<ByteBuf> unprotectedBufs, Consumer<ByteBuf> ctxWrite,
+        ByteBufAllocator alloc) throws GeneralSecurityException {
+      for (ByteBuf unprotectedBuf : unprotectedBufs) {
+        ctxWrite.accept(unprotectedBuf);
+      }
+    }
+
+    @Override
+    public void unprotect(ByteBuf in, List<Object> out, ByteBufAllocator alloc)
+        throws GeneralSecurityException {
+      out.add(in.toString(CharsetUtil.UTF_8));
+    }
+
+    @Override
+    public void destroy() {}
+  }
+}
diff --git a/alts/src/test/java/io/grpc/alts/internal/TsiTest.java b/alts/src/test/java/io/grpc/alts/internal/TsiTest.java
new file mode 100644
index 00000000000..0241182f2db
--- /dev/null
+++ b/alts/src/test/java/io/grpc/alts/internal/TsiTest.java
@@ -0,0 +1,406 @@
+/*
+ * Copyright 2018 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.alts.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.alts.internal.ByteBufTestUtils.getDirectBuffer;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.fail;
+
+import io.grpc.alts.internal.ByteBufTestUtils.RegisterRef;
+import io.grpc.alts.internal.TsiFrameProtector.Consumer;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.buffer.UnpooledByteBufAllocator;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import javax.crypto.AEADBadTagException;
+
+/** Utility class that provides tests for implementations of {@link TsiHandshaker}. */
+public final class TsiTest {
+  private static final String DECRYPTION_FAILURE_RE = "Tag mismatch|BAD_DECRYPT";
+
+  private TsiTest() {}
+
+  /** A {@code TsiHandshaker} pair for running tests. */
+  public static class Handshakers {
+    private final TsiHandshaker client;
+    private final TsiHandshaker server;
+
+    public Handshakers(TsiHandshaker client, TsiHandshaker server) {
+      this.client = client;
+      this.server = server;
+    }
+
+    public TsiHandshaker getClient() {
+      return client;
+    }
+
+    public TsiHandshaker getServer() {
+      return server;
+    }
+  }
+
+  private static final int DEFAULT_TRANSPORT_BUFFER_SIZE = 2048;
+
+  private static final UnpooledByteBufAllocator alloc = UnpooledByteBufAllocator.DEFAULT;
+
+  private static final String EXAMPLE_MESSAGE1 = "hello world";
+  private static final String EXAMPLE_MESSAGE2 = "oysteroystersoysterseateateat";
+
+  private static final int EXAMPLE_MESSAGE1_LEN = EXAMPLE_MESSAGE1.getBytes(UTF_8).length;
+  private static final int EXAMPLE_MESSAGE2_LEN = EXAMPLE_MESSAGE2.getBytes(UTF_8).length;
+
+  static int getDefaultTransportBufferSize() {
+    return DEFAULT_TRANSPORT_BUFFER_SIZE;
+  }
+
+  /**
+   * Performs a handshake between the client handshaker and server handshaker using a transport of
+   * length transportBufferSize.
+   */
+  static void performHandshake(int transportBufferSize, Handshakers handshakers)
+      throws GeneralSecurityException {
+    TsiHandshaker clientHandshaker = handshakers.getClient();
+    TsiHandshaker serverHandshaker = handshakers.getServer();
+
+    byte[] transportBufferBytes = new byte[transportBufferSize];
+    ByteBuffer transportBuffer = ByteBuffer.wrap(transportBufferBytes);
+    ((Buffer) transportBuffer).limit(0); // Start off with an empty buffer
+
+    while (clientHandshaker.isInProgress() || serverHandshaker.isInProgress()) {
+      for (TsiHandshaker handshaker : new TsiHandshaker[] {clientHandshaker, serverHandshaker}) {
+        if (handshaker.isInProgress()) {
+          // Process any bytes on the wire.
+          if (transportBuffer.hasRemaining()) {
+            handshaker.processBytesFromPeer(transportBuffer);
+          }
+          // Put new bytes on the wire, if needed.
+          if (handshaker.isInProgress()) {
+            ((Buffer) transportBuffer).clear();
+            handshaker.getBytesToSendToPeer(transportBuffer);
+            ((Buffer) transportBuffer).flip();
+          }
+        }
+      }
+    }
+    clientHandshaker.extractPeer();
+    serverHandshaker.extractPeer();
+  }
+
+  public static void handshakeTest(Handshakers handshakers) throws GeneralSecurityException {
+    performHandshake(DEFAULT_TRANSPORT_BUFFER_SIZE, handshakers);
+  }
+
+  public static void handshakeSmallBufferTest(Handshakers handshakers)
+      throws GeneralSecurityException {
+    performHandshake(9, handshakers);
+  }
+
+  /** Sends a message between the sender and receiver. */
+  private static void sendMessage(
+      TsiFrameProtector sender,
+      TsiFrameProtector receiver,
+      int recvFragmentSize,
+      String message,
+      RegisterRef ref)
+      throws GeneralSecurityException {
+
+    ByteBuf plaintextBuffer = Unpooled.wrappedBuffer(message.getBytes(UTF_8));
+    final List<ByteBuf> protectOut = new ArrayList<>();
+    List<Object> unprotectOut = new ArrayList<>();
+
+    sender.protectFlush(
+        Collections.singletonList(plaintextBuffer),
+        new Consumer<ByteBuf>() {
+          @Override
+          public void accept(ByteBuf buf) {
+            protectOut.add(buf);
+          }
+        },
+        alloc);
+    assertThat(protectOut.size()).isEqualTo(1);
+
+    ByteBuf protect = ref.register(protectOut.get(0));
+    while (protect.isReadable()) {
+      ByteBuf buf = protect;
+      if (recvFragmentSize > 0) {
+        int size = Math.min(protect.readableBytes(), recvFragmentSize);
+        buf = protect.readSlice(size);
+      }
+      receiver.unprotect(buf, unprotectOut, alloc);
+    }
+    ByteBuf plaintextRecvd = getDirectBuffer(message.getBytes(UTF_8).length, ref);
+    for (Object unprotect : unprotectOut) {
+      ByteBuf unprotectBuf = ref.register((ByteBuf) unprotect);
+      plaintextRecvd.writeBytes(unprotectBuf);
+    }
+    assertThat(plaintextRecvd).isEqualTo(Unpooled.wrappedBuffer(message.getBytes(UTF_8)));
+  }
+
+  /** Ping pong test. */
+  public static void pingPongTest(Handshakers handshakers, RegisterRef ref)
+      throws GeneralSecurityException {
+    performHandshake(DEFAULT_TRANSPORT_BUFFER_SIZE, handshakers);
+
+    TsiFrameProtector clientProtector = handshakers.getClient().createFrameProtector(alloc);
+    TsiFrameProtector serverProtector = handshakers.getServer().createFrameProtector(alloc);
+
+    sendMessage(clientProtector, serverProtector, -1, EXAMPLE_MESSAGE1, ref);
+    sendMessage(serverProtector, clientProtector, -1, EXAMPLE_MESSAGE2, ref);
+
+    clientProtector.destroy();
+    serverProtector.destroy();
+  }
+
+  /** Ping pong test with exact frame size. */
+  public static void pingPongExactFrameSizeTest(Handshakers handshakers, RegisterRef ref)
+      throws GeneralSecurityException {
+    performHandshake(DEFAULT_TRANSPORT_BUFFER_SIZE, handshakers);
+
+    int frameSize =
+        EXAMPLE_MESSAGE1.getBytes(UTF_8).length
+            + AltsTsiFrameProtector.getHeaderBytes()
+            + FakeChannelCrypter.getTagBytes();
+
+    TsiFrameProtector clientProtector =
+        handshakers.getClient().createFrameProtector(frameSize, alloc);
+    TsiFrameProtector serverProtector =
+        handshakers.getServer().createFrameProtector(frameSize, alloc);
+
+    sendMessage(clientProtector, serverProtector, -1, EXAMPLE_MESSAGE1, ref);
+    sendMessage(serverProtector, clientProtector, -1, EXAMPLE_MESSAGE1, ref);
+
+    clientProtector.destroy();
+    serverProtector.destroy();
+  }
+
+  /** Ping pong test with small buffer size. */
+  public static void pingPongSmallBufferTest(Handshakers handshakers, RegisterRef ref)
+      throws GeneralSecurityException {
+    performHandshake(DEFAULT_TRANSPORT_BUFFER_SIZE, handshakers);
+
+    TsiFrameProtector clientProtector = handshakers.getClient().createFrameProtector(alloc);
+    TsiFrameProtector serverProtector = handshakers.getServer().createFrameProtector(alloc);
+
+    sendMessage(clientProtector, serverProtector, 1, EXAMPLE_MESSAGE1, ref);
+    sendMessage(serverProtector, clientProtector, 1, EXAMPLE_MESSAGE2, ref);
+
+    clientProtector.destroy();
+    serverProtector.destroy();
+  }
+
+  /** Ping pong test with small frame size. */
+  public static void pingPongSmallFrameTest(
+      int frameProtectorOverhead, Handshakers handshakers, RegisterRef ref)
+      throws GeneralSecurityException {
+    performHandshake(DEFAULT_TRANSPORT_BUFFER_SIZE, handshakers);
+
+    // We send messages using small non-aligned buffers. We use 3 and 5, small primes.
+    TsiFrameProtector clientProtector =
+        handshakers.getClient().createFrameProtector(frameProtectorOverhead + 3, alloc);
+    TsiFrameProtector serverProtector =
+        handshakers.getServer().createFrameProtector(frameProtectorOverhead + 5, alloc);
+
+    sendMessage(clientProtector, serverProtector, EXAMPLE_MESSAGE1_LEN, EXAMPLE_MESSAGE1, ref);
+    sendMessage(serverProtector, clientProtector, EXAMPLE_MESSAGE2_LEN, EXAMPLE_MESSAGE2, ref);
+
+    clientProtector.destroy();
+    serverProtector.destroy();
+  }
+
+  /** Ping pong test with small frame and small buffer. */
+  public static void pingPongSmallFrameSmallBufferTest(
+      int frameProtectorOverhead, Handshakers handshakers, RegisterRef ref)
+      throws GeneralSecurityException {
+    performHandshake(DEFAULT_TRANSPORT_BUFFER_SIZE, handshakers);
+
+    // We send messages using small non-aligned buffers. We use 3 and 5, small primes.
+    TsiFrameProtector clientProtector =
+        handshakers.getClient().createFrameProtector(frameProtectorOverhead + 3, alloc);
+    TsiFrameProtector serverProtector =
+        handshakers.getServer().createFrameProtector(frameProtectorOverhead + 5, alloc);
+
+    sendMessage(clientProtector, serverProtector, EXAMPLE_MESSAGE1_LEN, EXAMPLE_MESSAGE1, ref);
+    sendMessage(serverProtector, clientProtector, EXAMPLE_MESSAGE2_LEN, EXAMPLE_MESSAGE2, ref);
+
+    sendMessage(clientProtector, serverProtector, EXAMPLE_MESSAGE1_LEN, EXAMPLE_MESSAGE1, ref);
+    sendMessage(serverProtector, clientProtector, EXAMPLE_MESSAGE2_LEN, EXAMPLE_MESSAGE2, ref);
+
+    clientProtector.destroy();
+    serverProtector.destroy();
+  }
+
+  /** Test corrupted counter. */
+  public static void corruptedCounterTest(Handshakers handshakers, RegisterRef ref)
+      throws GeneralSecurityException {
+    performHandshake(DEFAULT_TRANSPORT_BUFFER_SIZE, handshakers);
+
+    TsiFrameProtector sender = handshakers.getClient().createFrameProtector(alloc);
+    TsiFrameProtector receiver = handshakers.getServer().createFrameProtector(alloc);
+
+    String message = "hello world";
+    ByteBuf plaintextBuffer = Unpooled.wrappedBuffer(message.getBytes(UTF_8));
+    final List<ByteBuf> protectOut = new ArrayList<>();
+    List<Object> unprotectOut = new ArrayList<>();
+
+    sender.protectFlush(
+        Collections.singletonList(plaintextBuffer),
+        new Consumer<ByteBuf>() {
+          @Override
+          public void accept(ByteBuf buf) {
+            protectOut.add(buf);
+          }
+        },
+        alloc);
+    assertThat(protectOut.size()).isEqualTo(1);
+
+    ByteBuf protect = ref.register(protectOut.get(0));
+    // Unprotect once to increase receiver counter.
+    receiver.unprotect(protect.slice(), unprotectOut, alloc);
+    assertThat(unprotectOut.size()).isEqualTo(1);
+    ref.register((ByteBuf) unprotectOut.get(0));
+
+    try {
+      receiver.unprotect(protect, unprotectOut, alloc);
+      fail("Exception expected");
+    } catch (AEADBadTagException ex) {
+      assertThat(ex).hasMessageThat().containsMatch(DECRYPTION_FAILURE_RE);
+    }
+
+    sender.destroy();
+    receiver.destroy();
+  }
+
+  /** Test corrupted ciphertext. */
+  public static void corruptedCiphertextTest(Handshakers handshakers, RegisterRef ref)
+      throws GeneralSecurityException {
+    performHandshake(DEFAULT_TRANSPORT_BUFFER_SIZE, handshakers);
+
+    TsiFrameProtector sender = handshakers.getClient().createFrameProtector(alloc);
+    TsiFrameProtector receiver = handshakers.getServer().createFrameProtector(alloc);
+
+    String message = "hello world";
+    ByteBuf plaintextBuffer = Unpooled.wrappedBuffer(message.getBytes(UTF_8));
+    final List<ByteBuf> protectOut = new ArrayList<>();
+    List<Object> unprotectOut = new ArrayList<>();
+
+    sender.protectFlush(
+        Collections.singletonList(plaintextBuffer),
+        new Consumer<ByteBuf>() {
+          @Override
+          public void accept(ByteBuf buf) {
+            protectOut.add(buf);
+          }
+        },
+        alloc);
+    assertThat(protectOut.size()).isEqualTo(1);
+
+    ByteBuf protect = ref.register(protectOut.get(0));
+    int ciphertextIdx = protect.writerIndex() - FakeChannelCrypter.getTagBytes() - 2;
+    protect.setByte(ciphertextIdx, protect.getByte(ciphertextIdx) + 1);
+
+    try {
+      receiver.unprotect(protect, unprotectOut, alloc);
+      fail("Exception expected");
+    } catch (AEADBadTagException ex) {
+      assertThat(ex).hasMessageThat().containsMatch(DECRYPTION_FAILURE_RE);
+    }
+
+    sender.destroy();
+    receiver.destroy();
+  }
+
+  /** Test corrupted tag. */
+  public static void corruptedTagTest(Handshakers handshakers, RegisterRef ref)
+      throws GeneralSecurityException {
+    performHandshake(DEFAULT_TRANSPORT_BUFFER_SIZE, handshakers);
+
+    TsiFrameProtector sender = handshakers.getClient().createFrameProtector(alloc);
+    TsiFrameProtector receiver = handshakers.getServer().createFrameProtector(alloc);
+
+    String message = "hello world";
+    ByteBuf plaintextBuffer = Unpooled.wrappedBuffer(message.getBytes(UTF_8));
+    final List<ByteBuf> protectOut = new ArrayList<>();
+    List<Object> unprotectOut = new ArrayList<>();
+
+    sender.protectFlush(
+        Collections.singletonList(plaintextBuffer),
+        new Consumer<ByteBuf>() {
+          @Override
+          public void accept(ByteBuf buf) {
+            protectOut.add(buf);
+          }
+        },
+        alloc);
+    assertThat(protectOut.size()).isEqualTo(1);
+
+    ByteBuf protect = ref.register(protectOut.get(0));
+    int tagIdx = protect.writerIndex() - 1;
+    protect.setByte(tagIdx, protect.getByte(tagIdx) + 1);
+
+    try {
+      receiver.unprotect(protect, unprotectOut, alloc);
+      fail("Exception expected");
+    } catch (AEADBadTagException ex) {
+      assertThat(ex).hasMessageThat().containsMatch(DECRYPTION_FAILURE_RE);
+    }
+
+    sender.destroy();
+    receiver.destroy();
+  }
+
+  /** Test reflected ciphertext. */
+  public static void reflectedCiphertextTest(Handshakers handshakers, RegisterRef ref)
+      throws GeneralSecurityException {
+    performHandshake(DEFAULT_TRANSPORT_BUFFER_SIZE, handshakers);
+
+    TsiFrameProtector sender = handshakers.getClient().createFrameProtector(alloc);
+    TsiFrameProtector receiver = handshakers.getServer().createFrameProtector(alloc);
+
+    String message = "hello world";
+    ByteBuf plaintextBuffer = Unpooled.wrappedBuffer(message.getBytes(UTF_8));
+    final List<ByteBuf> protectOut = new ArrayList<>();
+    List<Object> unprotectOut = new ArrayList<>();
+
+    sender.protectFlush(
+        Collections.singletonList(plaintextBuffer),
+        new Consumer<ByteBuf>() {
+          @Override
+          public void accept(ByteBuf buf) {
+            protectOut.add(buf);
+          }
+        },
+        alloc);
+    assertThat(protectOut.size()).isEqualTo(1);
+
+    ByteBuf protect = ref.register(protectOut.get(0));
+    try {
+      sender.unprotect(protect.slice(), unprotectOut, alloc);
+      fail("Exception expected");
+    } catch (AEADBadTagException ex) {
+      assertThat(ex).hasMessageThat().containsMatch(DECRYPTION_FAILURE_RE);
+    }
+
+    sender.destroy();
+    receiver.destroy();
+  }
+}
diff --git a/android-interop-testing/README.md b/android-interop-testing/README.md
index a00752c442e..bd7841e7e84 100644
--- a/android-interop-testing/README.md
+++ b/android-interop-testing/README.md
@@ -3,8 +3,6 @@ gRPC Android test App
 
 Implements gRPC integration tests in an Android App.
 
-TODO(madongfly) integrate this App into the gRPC-Java build system.
-
 In order to build this app, you need a local.properties file under this directory which specifies
 the location of your android sdk:
 ```
@@ -35,21 +33,19 @@ $ ../gradlew installDebug
 Then manually test it with the UI.
 
 
-Commandline test
+Instrumentation tests
 ----------------
 
-Run the test with arguments:
-```
-$ adb shell am instrument -w -e server_host <hostname or ip address> -e server_port <port> -e server_host_override foo.test.google.fr -e use_tls true -e use_test_ca true -e test_case all io.grpc.android.integrationtest/.TesterInstrumentation
-```
+Instrumentation tests must be run on a connected device or emulator. Run with the
+following gradle command:
 
-If the test passed successfully, it will output:
 ```
-INSTRUMENTATION_RESULT: grpc test result=Succeed!!!
-INSTRUMENTATION_CODE: 0
-```
-otherwise, output something like:
-```
-INSTRUMENTATION_RESULT: grpc test result=Failed... : <exception stacktrace if applicable>
-INSTRUMENTATION_CODE: 1
+$ ../gradlew connectedAndroidTest \
+    -Pandroid.testInstrumentationRunnerArguments.server_host=10.0.2.2 \
+    -Pandroid.testInstrumentationRunnerArguments.server_port=8080 \
+    -Pandroid.testInstrumentationRunnerArguments.use_tls=true \
+    -Pandroid.testInstrumentationRunnerArguments.server_host_override=foo.test.google.fr \
+    -Pandroid.testInstrumentationRunnerArguments.use_test_ca=true \
+    -Pandroid.testInstrumentationRunnerArguments.test_case=all
 ```
+
diff --git a/android-interop-testing/app/build.gradle b/android-interop-testing/app/build.gradle
deleted file mode 100644
index 587b2e0fc35..00000000000
--- a/android-interop-testing/app/build.gradle
+++ /dev/null
@@ -1,75 +0,0 @@
-apply plugin: 'com.android.application'
-apply plugin: 'com.google.protobuf'
-
-android {
-    compileSdkVersion 22
-    buildToolsVersion '22.0.1'
-
-    defaultConfig {
-        applicationId "io.grpc.android.integrationtest"
-        minSdkVersion 9
-        targetSdkVersion 22
-        versionCode 1
-        versionName "1.0"
-    }
-    buildTypes {
-        debug {
-            minifyEnabled false
-        }
-        release {
-            minifyEnabled true
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
-        }
-    }
-    lintOptions {
-        disable 'InvalidPackage', 'HardcodedText'
-    }
-}
-
-protobuf {
-    protoc {
-        artifact = 'com.google.protobuf:protoc:3.2.0'
-    }
-    plugins {
-        grpc {
-            artifact = 'io.grpc:protoc-gen-grpc-java:1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-        }
-    }
-    generateProtoTasks {
-        all().each { task ->
-            task.builtins {
-                javanano {
-                    // Options added to --javanano_out
-                    option 'ignore_services=true'
-                }
-            }
-
-            task.plugins {
-                grpc {
-                    // Options added to --grpc_out
-                    option 'nano'
-                }
-            }
-        }
-    }
-}
-
-dependencies {
-    compile 'com.android.support:appcompat-v7:22.1.1'
-    compile 'com.google.android.gms:play-services-base:7.3.0'
-    compile 'com.google.code.findbugs:jsr305:3.0.0'
-    compile 'com.google.guava:guava:18.0'
-    compile 'com.squareup.okhttp:okhttp:2.2.0'
-    // You need to build grpc-java to obtain these libraries below.
-    compile 'io.grpc:grpc-protobuf-nano:1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    compile 'io.grpc:grpc-okhttp:1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    compile 'io.grpc:grpc-stub:1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    compile 'io.grpc:grpc-testing:1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    compile 'javax.annotation:javax.annotation-api:1.2'
-}
-
-gradle.projectsEvaluated {
-    tasks.withType(JavaCompile) {
-        options.compilerArgs << "-Xlint:deprecation"
-    }
-}
diff --git a/android-interop-testing/app/proguard-rules.pro b/android-interop-testing/app/proguard-rules.pro
deleted file mode 100644
index 1c926cf2ce5..00000000000
--- a/android-interop-testing/app/proguard-rules.pro
+++ /dev/null
@@ -1,20 +0,0 @@
-# Add project specific ProGuard rules here.
-# By default, the flags in this file are appended to flags specified
-# in $ANDROID_HOME/tools/proguard/proguard-android.txt
-# You can edit the include path and order by changing the proguardFiles
-# directive in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# Add any project specific keep options here:
-
--dontwarn com.google.common.**
--dontwarn okio.**
--dontwarn org.mockito.**
--dontwarn sun.reflect.**
--dontwarn android.test.**
-# Ignores: can't find referenced class javax.lang.model.element.Modifier
--dontwarn com.google.errorprone.annotations.**
--keep class io.grpc.internal.DnsNameResolverProvider
--keep class io.grpc.okhttp.OkHttpChannelProvider
diff --git a/android-interop-testing/app/src/main/AndroidManifest.xml b/android-interop-testing/app/src/main/AndroidManifest.xml
deleted file mode 100644
index 8bb746cb31d..00000000000
--- a/android-interop-testing/app/src/main/AndroidManifest.xml
+++ /dev/null
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="io.grpc.android.integrationtest" >
-
-    <uses-permission android:name="android.permission.INTERNET" />
-
-    <application
-        android:allowBackup="true"
-        android:icon="@mipmap/ic_launcher"
-        android:label="@string/app_name"
-        android:theme="@style/Base.V7.Theme.AppCompat.Light" >
-        <activity
-            android:name=".TesterActivity"
-            android:label="@string/app_name" >
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-
-        <meta-data
-            android:name="com.google.android.gms.version"
-            android:value="@integer/google_play_services_version" />
-    </application>
-
-    <instrumentation android:functionalTest="true"
-    android:label="@string/app_name"
-    android:name=".TesterInstrumentation"
-    android:targetPackage="io.grpc.android.integrationtest" />
-
-</manifest>
diff --git a/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/InteropTester.java b/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/InteropTester.java
deleted file mode 100644
index 5c24d9a68ef..00000000000
--- a/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/InteropTester.java
+++ /dev/null
@@ -1,767 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.android.integrationtest;
-
-import static junit.framework.Assert.assertEquals;
-import static junit.framework.Assert.assertNull;
-import static junit.framework.Assert.assertTrue;
-import static junit.framework.Assert.fail;
-
-import com.google.protobuf.nano.EmptyProtos;
-import com.google.protobuf.nano.MessageNano;
-
-import android.os.AsyncTask;
-import android.util.Log;
-
-import io.grpc.CallOptions;
-import io.grpc.ClientCall;
-import io.grpc.ManagedChannel;
-import io.grpc.Metadata;
-import io.grpc.StatusRuntimeException;
-import io.grpc.android.integrationtest.nano.Messages;
-import io.grpc.android.integrationtest.nano.Messages.Payload;
-import io.grpc.android.integrationtest.nano.Messages.ResponseParameters;
-import io.grpc.android.integrationtest.nano.Messages.SimpleRequest;
-import io.grpc.android.integrationtest.nano.Messages.SimpleResponse;
-import io.grpc.android.integrationtest.nano.Messages.StreamingInputCallRequest;
-import io.grpc.android.integrationtest.nano.Messages.StreamingInputCallResponse;
-import io.grpc.android.integrationtest.nano.Messages.StreamingOutputCallRequest;
-import io.grpc.android.integrationtest.nano.Messages.StreamingOutputCallResponse;
-import io.grpc.android.integrationtest.nano.TestServiceGrpc;
-import io.grpc.android.integrationtest.nano.UnimplementedServiceGrpc;
-import io.grpc.stub.StreamObserver;
-import io.grpc.testing.StreamRecorder;
-
-import java.io.PrintWriter;
-import java.io.StringWriter;
-import java.lang.RuntimeException;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ArrayBlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.TimeUnit;
-
-/**
- * Implementation of the integration tests, as an AsyncTask.
- */
-final class InteropTester extends AsyncTask<Void, Void, String> {
-  static final String SUCCESS_MESSAGE = "Succeed!!!";
-  static final String LOG_TAG = "GrpcTest";
-
-  private ManagedChannel channel;
-  private TestServiceGrpc.TestServiceBlockingStub blockingStub;
-  private TestServiceGrpc.TestServiceStub asyncStub;
-  private String testCase;
-  private TestListener listener;
-  private static int TIMEOUT_MILLIS = 5000;
-
-  class ResponseObserver implements StreamObserver<Messages.StreamingOutputCallResponse> {
-    public LinkedBlockingQueue<Object> responses = new LinkedBlockingQueue<Object>();
-    final Object magicTailResponse = new Object();
-
-    @Override
-    public void onNext(Messages.StreamingOutputCallResponse value) {
-      responses.add(value);
-    }
-
-    @Override
-    public void onError(Throwable t) {
-      Log.e(LOG_TAG, "Encounter an error", t);
-      responses.add(t);
-    }
-
-    @Override
-    public void onCompleted() {
-      responses.add(magicTailResponse);
-    }
-  }
-
-
-  public InteropTester(String testCase,
-                       ManagedChannel channel,
-                       TestListener listener) {
-    this.testCase = testCase;
-    this.listener = listener;
-    this.channel = channel;
-    blockingStub = TestServiceGrpc.newBlockingStub(channel);
-    asyncStub = TestServiceGrpc.newStub(channel);
-  }
-
-  @Override
-  protected void onPreExecute() {
-    listener.onPreTest();
-  }
-
-  @Override
-  protected String doInBackground(Void... nothing) {
-    try {
-      runTest(testCase);
-      return SUCCESS_MESSAGE;
-    } catch (Throwable t) {
-      // Print the stack trace to logcat.
-      t.printStackTrace();
-      // Then print to the error message.
-      StringWriter sw = new StringWriter();
-      t.printStackTrace(new PrintWriter(sw));
-      return "Failed... : " + t.getMessage() + "\n" + sw.toString();
-    } finally {
-      shutdown();
-    }
-  }
-
-  @Override
-  protected void onPostExecute(String result) {
-    listener.onPostTest(result);
-  }
-
-
-  public void shutdown() {
-    channel.shutdown();
-  }
-
-  public void runTest(String testCase) throws Exception {
-    Log.i(LOG_TAG, "Running test " + testCase);
-    if ("all".equals(testCase)) {
-      runTest("empty_unary");
-      runTest("large_unary");
-      runTest("client_streaming");
-      runTest("server_streaming");
-      runTest("ping_pong");
-      runTest("empty_stream");
-      runTest("cancel_after_begin");
-      runTest("cancel_after_first_response");
-      runTest("full_duplex_call_should_succeed");
-      runTest("half_duplex_call_should_succeed");
-      runTest("server_streaming_should_be_flow_controlled");
-      runTest("very_large_request");
-      runTest("very_large_response");
-      runTest("deadline_not_exceeded");
-      runTest("deadline_exceeded");
-      runTest("deadline_exceeded_server_streaming");
-      runTest("unimplemented_method");
-      runTest("timeout_on_sleeping_server");
-      // This has to be the last one, because it will shut down the channel.
-      runTest("graceful_shutdown");
-    } else if ("empty_unary".equals(testCase)) {
-      emptyUnary();
-    } else if ("large_unary".equals(testCase)) {
-      largeUnary();
-    } else if ("client_streaming".equals(testCase)) {
-      clientStreaming();
-    } else if ("server_streaming".equals(testCase)) {
-      serverStreaming();
-    } else if ("ping_pong".equals(testCase)) {
-      pingPong();
-    } else if ("empty_stream".equals(testCase)) {
-      emptyStream();
-    } else if ("cancel_after_begin".equals(testCase)) {
-      cancelAfterBegin();
-    } else if ("cancel_after_first_response".equals(testCase)) {
-      cancelAfterFirstResponse();
-    } else if ("full_duplex_call_should_succeed".equals(testCase)) {
-      fullDuplexCallShouldSucceed();
-    } else if ("half_duplex_call_should_succeed".equals(testCase)) {
-      halfDuplexCallShouldSucceed();
-    } else if ("server_streaming_should_be_flow_controlled".equals(testCase)) {
-      serverStreamingShouldBeFlowControlled();
-    } else if ("very_large_request".equals(testCase)) {
-      veryLargeRequest();
-    } else if ("very_large_response".equals(testCase)) {
-      veryLargeResponse();
-    } else if ("deadline_not_exceeded".equals(testCase)) {
-      deadlineNotExceeded();
-    } else if ("deadline_exceeded".equals(testCase)) {
-      deadlineExceeded();
-    } else if ("deadline_exceeded_server_streaming".equals(testCase)) {
-      deadlineExceededServerStreaming();
-    } else if ("unimplemented_method".equals(testCase)) {
-      unimplementedMethod();
-    } else if ("timeout_on_sleeping_server".equals(testCase)) {
-      timeoutOnSleepingServer();
-    } else if ("graceful_shutdown".equals(testCase)) {
-      gracefulShutdown();
-    } else {
-      throw new IllegalArgumentException("Unimplemented/Unknown test case: " + testCase);
-    }
-  }
-
-  public void emptyUnary() {
-    assertMessageEquals(new EmptyProtos.Empty(), blockingStub.emptyCall(new EmptyProtos.Empty()));
-  }
-
-  public void largeUnary() {
-    if (shouldSkip()) {
-      return;
-    }
-    final Messages.SimpleRequest request = new Messages.SimpleRequest();
-    request.responseSize = 314159;
-    request.responseType = Messages.COMPRESSABLE;
-    request.payload = new Payload();
-    request.payload.body = new byte[271828];
-
-    final Messages.SimpleResponse goldenResponse = new Messages.SimpleResponse();
-    goldenResponse.payload = new Payload();
-    goldenResponse.payload.body = new byte[314159];
-    Messages.SimpleResponse response = blockingStub.unaryCall(request);
-    assertMessageEquals(goldenResponse, response);
-  }
-
-  public void serverStreaming() throws Exception {
-    final Messages.StreamingOutputCallRequest request = new Messages.StreamingOutputCallRequest();
-    request.responseType = Messages.COMPRESSABLE;
-    request.responseParameters = new Messages.ResponseParameters[4];
-    for (int i = 0; i < 4; i++) {
-      request.responseParameters[i] = new Messages.ResponseParameters();
-    }
-    request.responseParameters[0].size = 31415;
-    request.responseParameters[1].size = 9;
-    request.responseParameters[2].size = 2653;
-    request.responseParameters[3].size = 58979;
-
-    final Messages.StreamingOutputCallResponse[] goldenResponses =
-        new Messages.StreamingOutputCallResponse[4];
-    for (int i = 0; i < 4; i++) {
-      goldenResponses[i] = new Messages.StreamingOutputCallResponse();
-      goldenResponses[i].payload = new Payload();
-      goldenResponses[i].payload.type = Messages.COMPRESSABLE;
-    }
-    goldenResponses[0].payload.body = new byte[31415];
-    goldenResponses[1].payload.body = new byte[9];
-    goldenResponses[2].payload.body = new byte[2653];
-    goldenResponses[3].payload.body = new byte[58979];
-
-    StreamRecorder<Messages.StreamingOutputCallResponse> recorder = StreamRecorder.create();
-    asyncStub.streamingOutputCall(request, recorder);
-    assertTrue(recorder.awaitCompletion(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
-    assertSuccess(recorder);
-    assertMessageEquals(Arrays.asList(goldenResponses), recorder.getValues());
-  }
-
-  public void clientStreaming() throws Exception {
-    final Messages.StreamingInputCallRequest[] requests = new Messages.StreamingInputCallRequest[4];
-    for (int i = 0; i < 4; i++) {
-      requests[i] = new Messages.StreamingInputCallRequest();
-      requests[i].payload = new Payload();
-    }
-    requests[0].payload.body = new byte[27182];
-    requests[1].payload.body = new byte[8];
-    requests[2].payload.body = new byte[1828];
-    requests[3].payload.body = new byte[45904];
-
-    final Messages.StreamingInputCallResponse goldenResponse =
-        new Messages.StreamingInputCallResponse();
-    goldenResponse.aggregatedPayloadSize = 74922;
-
-    StreamRecorder<Messages.StreamingInputCallResponse> responseObserver = StreamRecorder.create();
-    StreamObserver<Messages.StreamingInputCallRequest> requestObserver =
-        asyncStub.streamingInputCall(responseObserver);
-    for (Messages.StreamingInputCallRequest request : requests) {
-      requestObserver.onNext(request);
-    }
-    requestObserver.onCompleted();
-    assertMessageEquals(goldenResponse, responseObserver.firstValue().get());
-  }
-
-  public void pingPong() throws Exception {
-    final Messages.StreamingOutputCallRequest[] requests =
-        new Messages.StreamingOutputCallRequest[4];
-    for (int i = 0; i < 4; i++) {
-      requests[i] = new Messages.StreamingOutputCallRequest();
-      requests[i].responseParameters = new Messages.ResponseParameters[1];
-      requests[i].responseParameters[0] = new Messages.ResponseParameters();
-      requests[i].payload = new Payload();
-    }
-    requests[0].responseParameters[0].size = 31415;
-    requests[0].payload.body = new byte[27182];
-    requests[1].responseParameters[0].size = 9;
-    requests[1].payload.body = new byte[8];
-    requests[2].responseParameters[0].size = 2653;
-    requests[2].payload.body = new byte[1828];
-    requests[3].responseParameters[0].size = 58979;
-    requests[3].payload.body = new byte[45904];
-
-
-    final Messages.StreamingOutputCallResponse[] goldenResponses =
-        new Messages.StreamingOutputCallResponse[4];
-    for (int i = 0; i < 4; i++) {
-      goldenResponses[i] = new Messages.StreamingOutputCallResponse();
-      goldenResponses[i].payload = new Payload();
-      goldenResponses[i].payload.type = Messages.COMPRESSABLE;
-    }
-    goldenResponses[0].payload.body = new byte[31415];
-    goldenResponses[1].payload.body = new byte[9];
-    goldenResponses[2].payload.body = new byte[2653];
-    goldenResponses[3].payload.body = new byte[58979];
-
-    @SuppressWarnings("unchecked")
-    ResponseObserver responseObserver = new ResponseObserver();
-    StreamObserver<Messages.StreamingOutputCallRequest> requestObserver
-        = asyncStub.fullDuplexCall(responseObserver);
-    for (int i = 0; i < requests.length; i++) {
-      requestObserver.onNext(requests[i]);
-      Object response = responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
-      if (!(response instanceof Messages.StreamingOutputCallResponse)) {
-        fail("Unexpected: " + response);
-      }
-      assertMessageEquals(goldenResponses[i], (Messages.StreamingOutputCallResponse) response);
-      assertTrue("More than 1 responses received for ping pong test.",
-          responseObserver.responses.isEmpty());
-    }
-    requestObserver.onCompleted();
-    assertEquals(responseObserver.magicTailResponse,
-        responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
-  }
-
-  public void emptyStream() throws Exception {
-    @SuppressWarnings("unchecked")
-    ResponseObserver responseObserver = new ResponseObserver();
-    StreamObserver<StreamingOutputCallRequest> requestObserver
-        = asyncStub.fullDuplexCall(responseObserver);
-    requestObserver.onCompleted();
-    assertEquals(responseObserver.magicTailResponse,
-        responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
-  }
-
-  public void cancelAfterBegin() throws Exception {
-    StreamRecorder<StreamingInputCallResponse> responseObserver = StreamRecorder.create();
-    StreamObserver<StreamingInputCallRequest> requestObserver =
-        asyncStub.streamingInputCall(responseObserver);
-    requestObserver.onError(new RuntimeException());
-    assertTrue(responseObserver.awaitCompletion(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
-    assertEquals(Arrays.<StreamingInputCallResponse>asList(), responseObserver.getValues());
-    assertCodeEquals(io.grpc.Status.CANCELLED,
-        io.grpc.Status.fromThrowable(responseObserver.getError()));
-  }
-
-  public void cancelAfterFirstResponse() throws Exception {
-    final StreamingOutputCallRequest request = new StreamingOutputCallRequest();
-    request.responseParameters = new Messages.ResponseParameters[1];
-    request.responseParameters[0] = new ResponseParameters();
-    request.responseParameters[0].size = 31415;
-    request.payload = new Payload();
-    request.payload.body = new byte[27182];
-    final StreamingOutputCallResponse goldenResponse = new StreamingOutputCallResponse();
-    goldenResponse.payload = new Payload();
-    goldenResponse.payload.type = Messages.COMPRESSABLE;
-    goldenResponse.payload.body = new byte[31415];
-
-    ResponseObserver responseObserver = new ResponseObserver();
-    StreamObserver<StreamingOutputCallRequest> requestObserver
-        = asyncStub.fullDuplexCall(responseObserver);
-    requestObserver.onNext(request);
-    Object response = responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
-    if (!(response instanceof Messages.StreamingOutputCallResponse)) {
-      fail("Unexpected: " + response);
-    }
-    assertMessageEquals(goldenResponse, (Messages.StreamingOutputCallResponse) response);
-
-    requestObserver.onError(new RuntimeException());
-    response = responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
-    if (!(response instanceof Throwable)) {
-      fail("Unexpected: " + response);
-    }
-    assertCodeEquals(io.grpc.Status.CANCELLED, io.grpc.Status.fromThrowable((Throwable) response));
-  }
-
-  public void fullDuplexCallShouldSucceed() throws Exception {
-    // Build the request.
-    Integer[] responseSizes = {50, 100, 150, 200};
-    final StreamingOutputCallRequest request = new StreamingOutputCallRequest();
-    request.responseParameters = new ResponseParameters[responseSizes.length];
-    request.responseType = Messages.COMPRESSABLE;
-    for (int i = 0; i < responseSizes.length; ++i) {
-      request.responseParameters[i] = new ResponseParameters();
-      request.responseParameters[i].size = responseSizes[i];
-      request.responseParameters[i].intervalUs = 0;
-    }
-
-    StreamRecorder<StreamingOutputCallResponse> recorder = StreamRecorder.create();
-    StreamObserver<StreamingOutputCallRequest> requestStream =
-        asyncStub.fullDuplexCall(recorder);
-
-    final int numRequests = 10;
-    for (int ix = numRequests; ix > 0; --ix) {
-      requestStream.onNext(request);
-    }
-    requestStream.onCompleted();
-    assertTrue(recorder.awaitCompletion(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
-    assertSuccess(recorder);
-    assertEquals(responseSizes.length * numRequests, recorder.getValues().size());
-    for (int ix = 0; ix < recorder.getValues().size(); ++ix) {
-      StreamingOutputCallResponse response = recorder.getValues().get(ix);
-      assertEquals(Messages.COMPRESSABLE, response.payload.type);
-      int length = response.payload.body.length;
-      int expectedSize = responseSizes[ix % responseSizes.length];
-      assertEquals("comparison failed at index " + ix, expectedSize, length);
-    }
-  }
-
-  public void halfDuplexCallShouldSucceed() throws Exception {
-    // Build the request.
-    Integer[] responseSizes = {50, 100, 150, 200};
-    final StreamingOutputCallRequest request = new StreamingOutputCallRequest();
-    request.responseParameters = new ResponseParameters[responseSizes.length];
-    request.responseType = Messages.COMPRESSABLE;
-    for (int i = 0; i < responseSizes.length; ++i) {
-      request.responseParameters[i] = new ResponseParameters();
-      request.responseParameters[i].size = responseSizes[i];
-      request.responseParameters[i].intervalUs = 0;
-    }
-
-    StreamRecorder<StreamingOutputCallResponse> recorder = StreamRecorder.create();
-    StreamObserver<StreamingOutputCallRequest> requestStream = asyncStub.halfDuplexCall(recorder);
-
-    final int numRequests = 10;
-    for (int ix = numRequests; ix > 0; --ix) {
-      requestStream.onNext(request);
-    }
-    requestStream.onCompleted();
-    assertTrue(recorder.awaitCompletion(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
-    assertSuccess(recorder);
-    assertEquals(responseSizes.length * numRequests, recorder.getValues().size());
-    for (int ix = 0; ix < recorder.getValues().size(); ++ix) {
-      StreamingOutputCallResponse response = recorder.getValues().get(ix);
-      assertEquals(Messages.COMPRESSABLE, response.payload.type);
-      int length = response.payload.body.length;
-      int expectedSize = responseSizes[ix % responseSizes.length];
-      assertEquals("comparison failed at index " + ix, expectedSize, length);
-    }
-  }
-
-  public void serverStreamingShouldBeFlowControlled() throws Exception {
-    final StreamingOutputCallRequest request = new StreamingOutputCallRequest();
-    request.responseType = Messages.COMPRESSABLE;
-    request.responseParameters = new ResponseParameters[2];
-    request.responseParameters[0] = new ResponseParameters();
-    request.responseParameters[0].size = 100000;
-    request.responseParameters[1] = new ResponseParameters();
-    request.responseParameters[1].size = 100001;
-    final StreamingOutputCallResponse[] goldenResponses = new StreamingOutputCallResponse[2];
-    goldenResponses[0] = new StreamingOutputCallResponse();
-    goldenResponses[0].payload = new Payload();
-    goldenResponses[0].payload.type = Messages.COMPRESSABLE;
-    goldenResponses[0].payload.body = new byte[100000];
-    goldenResponses[1] = new StreamingOutputCallResponse();
-    goldenResponses[1].payload = new Payload();
-    goldenResponses[1].payload.type = Messages.COMPRESSABLE;
-    goldenResponses[1].payload.body = new byte[100001];
-
-    long start = System.nanoTime();
-
-    final ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<Object>(10);
-    ClientCall<StreamingOutputCallRequest, StreamingOutputCallResponse> call =
-        channel.newCall(TestServiceGrpc.METHOD_STREAMING_OUTPUT_CALL, CallOptions.DEFAULT);
-    call.start(new ClientCall.Listener<StreamingOutputCallResponse>() {
-      @Override
-      public void onHeaders(Metadata headers) {}
-
-      @Override
-      public void onMessage(final StreamingOutputCallResponse message) {
-        queue.add(message);
-      }
-
-      @Override
-      public void onClose(io.grpc.Status status, Metadata trailers) {
-        queue.add(status);
-      }
-    }, new Metadata());
-    call.sendMessage(request);
-    call.halfClose();
-
-    // Time how long it takes to get the first response.
-    call.request(1);
-    assertMessageEquals(goldenResponses[0],
-        (StreamingOutputCallResponse) queue.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
-    long firstCallDuration = System.nanoTime() - start;
-
-    // Without giving additional flow control, make sure that we don't get another response. We wait
-    // until we are comfortable the next message isn't coming. We may have very low nanoTime
-    // resolution (like on Windows) or be using a testing, in-process transport where message
-    // handling is instantaneous. In both cases, firstCallDuration may be 0, so round up sleep time
-    // to at least 1ms.
-    assertNull(queue.poll(Math.max(firstCallDuration * 4, 1 * 1000 * 1000), TimeUnit.NANOSECONDS));
-
-    // Make sure that everything still completes.
-    call.request(1);
-    assertMessageEquals(goldenResponses[1],
-        (StreamingOutputCallResponse) queue.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
-    assertCodeEquals(io.grpc.Status.OK,
-        (io.grpc.Status) queue.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
-  }
-
-  public void veryLargeRequest() throws Exception {
-    if (shouldSkip()) {
-      return;
-    }
-    final SimpleRequest request = new SimpleRequest();
-    request.payload = new Payload();
-    request.payload.type = Messages.COMPRESSABLE;
-    request.payload.body = new byte[unaryPayloadLength()];
-    request.responseSize = 10;
-    request.responseType = Messages.COMPRESSABLE;
-    final SimpleResponse goldenResponse = new SimpleResponse();
-    goldenResponse.payload = new Payload();
-    goldenResponse.payload.type = Messages.COMPRESSABLE;
-    goldenResponse.payload.body = new byte[10];
-
-    assertMessageEquals(goldenResponse, blockingStub.unaryCall(request));
-  }
-
-  public void veryLargeResponse() throws Exception {
-    if (shouldSkip()) {
-      return;
-    }
-    final SimpleRequest request = new SimpleRequest();
-    request.responseSize = unaryPayloadLength();
-    request.responseType = Messages.COMPRESSABLE;
-
-    SimpleResponse resp = blockingStub.unaryCall(request);
-    final SimpleResponse goldenResponse = new SimpleResponse();
-    goldenResponse.payload = new Payload();
-    goldenResponse.payload.type = Messages.COMPRESSABLE;
-    goldenResponse.payload.body = new byte[unaryPayloadLength()];
-
-    assertMessageSizeEquals(goldenResponse, resp);
-  }
-
-  public void deadlineNotExceeded() {
-    // warm up the channel and JVM
-    blockingStub.emptyCall(new EmptyProtos.Empty());
-    StreamingOutputCallRequest request = new StreamingOutputCallRequest();
-    request.responseParameters = new ResponseParameters[1];
-    request.responseParameters[0] = new ResponseParameters();
-    request.responseParameters[0].intervalUs = 0;
-    TestServiceGrpc.newBlockingStub(channel)
-        .withDeadlineAfter(10, TimeUnit.SECONDS)
-        .streamingOutputCall(request);
-  }
-
-  public void deadlineExceeded() {
-    // warm up the channel and JVM
-    blockingStub.emptyCall(new EmptyProtos.Empty());
-    TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(channel)
-        .withDeadlineAfter(10, TimeUnit.MILLISECONDS);
-    StreamingOutputCallRequest request = new StreamingOutputCallRequest();
-    request.responseParameters = new ResponseParameters[1];
-    request.responseParameters[0] = new ResponseParameters();
-    request.responseParameters[0].intervalUs = 20000;
-    try {
-      stub.streamingOutputCall(request).next();
-      fail("Expected deadline to be exceeded");
-    } catch (StatusRuntimeException ex) {
-      assertCodeEquals(io.grpc.Status.DEADLINE_EXCEEDED, ex.getStatus());
-    }
-  }
-
-  public void deadlineExceededServerStreaming() throws Exception {
-    // warm up the channel and JVM
-    blockingStub.emptyCall(new EmptyProtos.Empty());
-    ResponseParameters responseParameters = new ResponseParameters();
-    responseParameters.size = 1;
-    responseParameters.intervalUs = 10000;
-    StreamingOutputCallRequest request = new StreamingOutputCallRequest();
-    request.responseType = Messages.COMPRESSABLE;
-    request.responseParameters = new ResponseParameters[4];
-    request.responseParameters[0] = responseParameters;
-    request.responseParameters[1] = responseParameters;
-    request.responseParameters[2] = responseParameters;
-    request.responseParameters[3] = responseParameters;
-    StreamRecorder<StreamingOutputCallResponse> recorder = StreamRecorder.create();
-    TestServiceGrpc.newStub(channel)
-        .withDeadlineAfter(30, TimeUnit.MILLISECONDS)
-        .streamingOutputCall(request, recorder);
-    assertTrue(recorder.awaitCompletion(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
-    assertCodeEquals(io.grpc.Status.DEADLINE_EXCEEDED,
-        io.grpc.Status.fromThrowable(recorder.getError()));
-  }
-
-  protected int unaryPayloadLength() {
-    // 10MiB.
-    return 10485760;
-  }
-
-  public void gracefulShutdown() throws Exception {
-    StreamingOutputCallRequest[] requests = new StreamingOutputCallRequest[3];
-    requests[0] = new StreamingOutputCallRequest();
-    requests[0].responseParameters = new ResponseParameters[1];
-    requests[0].responseParameters[0] = new ResponseParameters();
-    requests[0].responseParameters[0].size = 3;
-    requests[0].payload = new Payload();
-    requests[0].payload.body = new byte[2];
-    requests[1] = new StreamingOutputCallRequest();
-    requests[1].responseParameters = new ResponseParameters[1];
-    requests[1].responseParameters[0] = new ResponseParameters();
-    requests[1].responseParameters[0].size = 1;
-    requests[1].payload = new Payload();
-    requests[1].payload.body = new byte[7];
-    requests[2] = new StreamingOutputCallRequest();
-    requests[2].responseParameters = new ResponseParameters[1];
-    requests[2].responseParameters[0] = new ResponseParameters();
-    requests[2].responseParameters[0].size = 4;
-    requests[2].payload = new Payload();
-    requests[2].payload.body = new byte[1];
-
-    StreamingOutputCallResponse[] goldenResponses = new StreamingOutputCallResponse[3];
-    goldenResponses[0] = new StreamingOutputCallResponse();
-    goldenResponses[0].payload = new Payload();
-    goldenResponses[0].payload.type = Messages.COMPRESSABLE;
-    goldenResponses[0].payload.body = new byte[3];
-    goldenResponses[1] = new StreamingOutputCallResponse();
-    goldenResponses[1].payload = new Payload();
-    goldenResponses[1].payload.type = Messages.COMPRESSABLE;
-    goldenResponses[1].payload.body = new byte[1];
-    goldenResponses[2] = new StreamingOutputCallResponse();
-    goldenResponses[2].payload = new Payload();
-    goldenResponses[2].payload.type = Messages.COMPRESSABLE;
-    goldenResponses[2].payload.body = new byte[4];
-
-
-    ResponseObserver responseObserver = new ResponseObserver();
-    StreamObserver<StreamingOutputCallRequest> requestObserver
-        = asyncStub.fullDuplexCall(responseObserver);
-    requestObserver.onNext(requests[0]);
-    Object response = responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
-    assertTrue(response instanceof Messages.StreamingOutputCallResponse);
-    assertMessageEquals(goldenResponses[0], (Messages.StreamingOutputCallResponse) response);
-    // Initiate graceful shutdown.
-    channel.shutdown();
-    // The previous ping-pong could have raced with the shutdown, but this one certainly shouldn't.
-    requestObserver.onNext(requests[1]);
-    response = responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
-    assertTrue(response instanceof Messages.StreamingOutputCallResponse);
-    assertMessageEquals(goldenResponses[1], (Messages.StreamingOutputCallResponse) response);
-    requestObserver.onNext(requests[2]);
-    response = responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
-    assertTrue(response instanceof Messages.StreamingOutputCallResponse);
-    assertMessageEquals(goldenResponses[2], (Messages.StreamingOutputCallResponse) response);
-    requestObserver.onCompleted();
-    assertEquals(responseObserver.magicTailResponse,
-        responseObserver.responses.poll(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
-  }
-
-  /** Sends an rpc to an unimplemented method on the server. */
-  public void unimplementedMethod() {
-    UnimplementedServiceGrpc.UnimplementedServiceBlockingStub stub =
-        UnimplementedServiceGrpc.newBlockingStub(channel);
-    try {
-      stub.unimplementedCall(new EmptyProtos.Empty());
-      fail();
-    } catch (StatusRuntimeException e) {
-      assertCodeEquals(io.grpc.Status.UNIMPLEMENTED, e.getStatus());
-    }
-  }
-
-  /** Start a fullDuplexCall which the server will not respond, and verify the deadline expires. */
-  public void timeoutOnSleepingServer() throws Exception {
-    TestServiceGrpc.TestServiceStub stub = TestServiceGrpc.newStub(channel)
-        .withDeadlineAfter(1, TimeUnit.MILLISECONDS);
-    StreamRecorder<StreamingOutputCallResponse> recorder = StreamRecorder.create();
-    StreamObserver<StreamingOutputCallRequest> requestObserver
-        = stub.fullDuplexCall(recorder);
-
-    try {
-      StreamingOutputCallRequest request = new StreamingOutputCallRequest();
-      request.payload = new Messages.Payload();
-      request.payload.body = new byte[27182];
-      requestObserver.onNext(request);
-    } catch (IllegalStateException expected) {
-      // This can happen if the stream has already been terminated due to deadline exceeded.
-    }
-
-    assertTrue(recorder.awaitCompletion(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS));
-    assertCodeEquals(io.grpc.Status.DEADLINE_EXCEEDED,
-        io.grpc.Status.fromThrowable(recorder.getError()));
-  }
-
-  public static void assertMessageSizeEquals(MessageNano expected, MessageNano actual) {
-    assertEquals(expected.getSerializedSize(), actual.getSerializedSize());
-  }
-
-
-  private static void assertSuccess(StreamRecorder<?> recorder) {
-    if (recorder.getError() != null) {
-      throw new AssertionError(recorder.getError());
-    }
-  }
-
-  public static void assertMessageEquals(MessageNano expected, MessageNano actual) {
-    if (!MessageNano.messageNanoEquals(expected, actual)) {
-      assertEquals(expected.toString(), actual.toString());
-      fail("Messages not equal, but assertEquals didn't throw");
-    }
-  }
-
-  public static void assertMessageEquals(List<? extends MessageNano> expected,
-                                         List<? extends MessageNano> actual) {
-    if (expected == null || actual == null) {
-      assertEquals(expected, actual);
-    } else if (expected.size() != actual.size()) {
-      assertEquals(expected, actual);
-    } else {
-      for (int i = 0; i < expected.size(); i++) {
-        assertMessageEquals(expected.get(i), actual.get(i));
-      }
-    }
-  }
-
-  private static void assertCodeEquals(io.grpc.Status expected, io.grpc.Status actual) {
-    if (expected == null) {
-      fail("expected should not be null");
-    }
-    if (actual == null || !expected.getCode().equals(actual.getCode())) {
-      assertEquals(expected, actual);
-    }
-  }
-
-  public interface TestListener {
-    void onPreTest();
-
-    void onPostTest(String result);
-  }
-
-  /**
-   * Some tests run on memory constrained environments.  Rather than OOM, just give up.  64 is
-   * choosen as a maximum amount of memory a large test would need.
-   */
-  private static boolean shouldSkip() {
-    Runtime r = Runtime.getRuntime();
-    long usedMem = r.totalMemory() - r.freeMemory();
-    long actuallyFreeMemory = r.maxMemory() - usedMem;
-    long wantedFreeMemory = 64 * 1024 * 1024;
-    if (actuallyFreeMemory < wantedFreeMemory) {
-      Log.i(LOG_TAG, "Skipping due to lack of memory.  " + 
-          "Have: " + actuallyFreeMemory + " Want: " + wantedFreeMemory);
-      return true;
-    }
-    return false;
-  }
-}
diff --git a/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterActivity.java b/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterActivity.java
deleted file mode 100644
index c02e016ecce..00000000000
--- a/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterActivity.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.android.integrationtest;
-
-import com.google.android.gms.security.ProviderInstaller;
-
-import android.content.Context;
-import android.content.Intent;
-import android.os.Bundle;
-import android.support.v7.app.AppCompatActivity;
-import android.text.TextUtils;
-import android.util.Log;
-import android.view.View;
-import android.view.inputmethod.InputMethodManager;
-import android.widget.Button;
-import android.widget.EditText;
-import android.widget.TextView;
-
-import java.util.LinkedList;
-import java.util.List;
-
-public class TesterActivity extends AppCompatActivity
-    implements ProviderInstaller.ProviderInstallListener {
-  private List<Button> buttons;
-  private EditText hostEdit;
-  private EditText portEdit;
-  private TextView resultText;
-
-  @Override
-  protected void onCreate(Bundle savedInstanceState) {
-    super.onCreate(savedInstanceState);
-    setContentView(R.layout.activity_tester);
-    buttons = new LinkedList<>();
-    buttons.add((Button) findViewById(R.id.empty_unary_button));
-    buttons.add((Button) findViewById(R.id.large_unary_button));
-    buttons.add((Button) findViewById(R.id.client_streaming_button));
-    buttons.add((Button) findViewById(R.id.server_streaming_button));
-    buttons.add((Button) findViewById(R.id.ping_pong_button));
-
-    hostEdit = (EditText) findViewById(R.id.host_edit_text);
-    portEdit = (EditText) findViewById(R.id.port_edit_text);
-    resultText = (TextView) findViewById(R.id.grpc_response_text);
-
-    ProviderInstaller.installIfNeededAsync(this, this);
-    // Disable buttons until the security provider installing finishes.
-    enableButtons(false);
-  }
-
-  public void startEmptyUnary(View view) {
-    startTest("empty_unary");
-  }
-
-  public void startLargeUnary(View view) {
-    startTest("large_unary");
-  }
-
-  public void startClientStreaming(View view) {
-    startTest("client_streaming");
-  }
-
-  public void startServerStreaming(View view) {
-    startTest("server_streaming");
-  }
-
-  public void startPingPong(View view) {
-    startTest("ping_pong");
-  }
-
-  private void enableButtons(boolean enable) {
-    for (Button button : buttons) {
-      button.setEnabled(enable);
-    }
-  }
-
-  private void startTest(String testCase) {
-    ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(
-        hostEdit.getWindowToken(), 0);
-    enableButtons(false);
-    String host = hostEdit.getText().toString();
-    String portStr = portEdit.getText().toString();
-    int port = TextUtils.isEmpty(portStr) ? 8080 : Integer.valueOf(portStr);
-
-    // TODO (madongfly) support server_host_override, useTls and useTestCa in the App UI.
-    new InteropTester(testCase,
-        TesterOkHttpChannelBuilder.build(host, port, "foo.test.google.fr", true,
-            getResources().openRawResource(R.raw.ca), null),
-        new InteropTester.TestListener() {
-          @Override public void onPreTest() {
-            resultText.setText("Testing...");
-          }
-
-          @Override public void onPostTest(String result) {
-            resultText.setText(result);
-            enableButtons(true);
-          }
-        }).execute();
-  }
-
-  @Override
-  public void onProviderInstalled() {
-    // Provider is up-to-date, app can make secure network calls.
-    enableButtons(true);
-  }
-
-  @Override
-  public void onProviderInstallFailed(int errorCode, Intent recoveryIntent) {
-    // The provider is helpful, but it is possible to succeed without it.
-    // Hope that the system-provided libraries are new enough.
-    Log.w(InteropTester.LOG_TAG, "Failed installing security provider, error code: " + errorCode);
-    enableButtons(true);
-  }
-}
diff --git a/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterInstrumentation.java b/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterInstrumentation.java
deleted file mode 100644
index fb48fc80e24..00000000000
--- a/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterInstrumentation.java
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.android.integrationtest;
-
-import com.google.android.gms.common.GooglePlayServicesNotAvailableException;
-import com.google.android.gms.common.GooglePlayServicesRepairableException;
-import com.google.android.gms.security.ProviderInstaller;
-
-import android.app.Instrumentation;
-import android.os.Bundle;
-import android.util.Log;
-
-import java.io.InputStream;
-import java.lang.Throwable;
-
-
-/**
- * The instrumentation used to run the interop test from command line.
- */
-public class TesterInstrumentation extends Instrumentation {
-  private String testCase;
-  private String host;
-  private int port;
-  private String serverHostOverride;
-  private boolean useTls;
-  private boolean useTestCa;
-  private String androidSocketFactoryTls;
-
-  @Override
-  public void onCreate(Bundle args) {
-    super.onCreate(args);
-
-    testCase = args.getString("test_case") != null ? args.getString("test_case") : "empty_unary";
-    host = args.getString("server_host");
-    port = Integer.parseInt(args.getString("server_port"));
-    serverHostOverride = args.getString("server_host_override");
-    useTls = args.getString("use_tls") != null
-        ? Boolean.parseBoolean(args.getString("use_tls")) : true;
-    useTestCa = args.getString("use_test_ca") != null
-        ? Boolean.parseBoolean(args.getString("use_test_ca")) : false;
-    androidSocketFactoryTls = args.getString("android_socket_factory_tls");
-
-    InputStream testCa = null;
-    if (useTestCa) {
-      testCa = getContext().getResources().openRawResource(R.raw.ca);
-    }
-
-    if (useTls) {
-      try {
-        ProviderInstaller.installIfNeeded(getContext());
-      } catch (GooglePlayServicesRepairableException e) {
-        // The provider is helpful, but it is possible to succeed without it.
-        // Hope that the system-provided libraries are new enough.
-        Log.w(InteropTester.LOG_TAG, "Failed installing security provider", e);
-      } catch (GooglePlayServicesNotAvailableException e) {
-        // The provider is helpful, but it is possible to succeed without it.
-        // Hope that the system-provided libraries are new enough.
-        Log.w(InteropTester.LOG_TAG, "Failed installing security provider", e);
-      }
-    }
-
-    try {
-      new InteropTester(testCase,
-          TesterOkHttpChannelBuilder.build(host, port, serverHostOverride, useTls, testCa,
-              androidSocketFactoryTls),
-          new InteropTester.TestListener() {
-            @Override
-            public void onPreTest() {
-            }
-
-            @Override
-            public void onPostTest(String result) {
-              Bundle bundle = new Bundle();
-              bundle.putString("grpc test result", result);
-              if (InteropTester.SUCCESS_MESSAGE.equals(result)) {
-                finish(0, bundle);
-              } else {
-                finish(1, bundle);
-              }
-            }
-          }
-      ).execute();
-    } catch (Throwable t) {
-      Bundle bundle = new Bundle();
-      bundle.putString("Exception encountered", t.toString());
-      finish(1, bundle);
-    }
-  }
-}
diff --git a/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterOkHttpChannelBuilder.java b/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterOkHttpChannelBuilder.java
deleted file mode 100644
index 0ae9de4be13..00000000000
--- a/android-interop-testing/app/src/main/java/io/grpc/android/integrationtest/TesterOkHttpChannelBuilder.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.android.integrationtest;
-
-import android.annotation.TargetApi;
-import android.net.SSLCertificateSocketFactory;
-import android.os.Build;
-import android.support.annotation.Nullable;
-
-import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
-import io.grpc.okhttp.NegotiationType;
-import io.grpc.okhttp.OkHttpChannelBuilder;
-
-import java.io.InputStream;
-import java.lang.reflect.Method;
-import java.security.KeyStore;
-import java.security.cert.CertificateFactory;
-import java.security.cert.X509Certificate;
-
-import javax.net.ssl.SSLContext;
-import javax.net.ssl.SSLSocketFactory;
-import javax.net.ssl.TrustManager;
-import javax.net.ssl.TrustManagerFactory;
-import javax.security.auth.x500.X500Principal;
-
-/**
- * A helper class to create a OkHttp based channel.
- */
-class TesterOkHttpChannelBuilder {
-  public static ManagedChannel build(String host, int port, @Nullable String serverHostOverride,
-      boolean useTls, @Nullable InputStream testCa, @Nullable String androidSocketFactoryTls) {
-    ManagedChannelBuilder<?> channelBuilder = ManagedChannelBuilder.forAddress(host, port)
-        .maxInboundMessageSize(16 * 1024 * 1024);
-    if (serverHostOverride != null) {
-      // Force the hostname to match the cert the server uses.
-      channelBuilder.overrideAuthority(serverHostOverride);
-    }
-    if (useTls) {
-      try {
-        SSLSocketFactory factory;
-        if (androidSocketFactoryTls != null) {
-          factory = getSslCertificateSocketFactory(testCa, androidSocketFactoryTls);
-        } else {
-          factory = getSslSocketFactory(testCa);
-        }
-        ((OkHttpChannelBuilder) channelBuilder).negotiationType(NegotiationType.TLS);
-        ((OkHttpChannelBuilder) channelBuilder).sslSocketFactory(factory);
-      } catch (Exception e) {
-        throw new RuntimeException(e);
-      }
-    } else {
-      channelBuilder.usePlaintext(true);
-    }
-    return channelBuilder.build();
-  }
-
-  private static SSLSocketFactory getSslSocketFactory(@Nullable InputStream testCa)
-      throws Exception {
-    if (testCa == null) {
-      return (SSLSocketFactory) SSLSocketFactory.getDefault();
-    }
-
-    SSLContext context = SSLContext.getInstance("TLS");
-    context.init(null, getTrustManagers(testCa) , null);
-    return context.getSocketFactory();
-  }
-
-  @TargetApi(14)
-  private static SSLCertificateSocketFactory getSslCertificateSocketFactory(
-      @Nullable InputStream testCa, String androidSocketFatoryTls) throws Exception {
-    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.ICE_CREAM_SANDWICH /* API level 14 */) {
-      throw new RuntimeException(
-          "android_socket_factory_tls doesn't work with API level less than 14.");
-    }
-    SSLCertificateSocketFactory factory = (SSLCertificateSocketFactory)
-        SSLCertificateSocketFactory.getDefault(5000 /* Timeout in ms*/);
-    // Use HTTP/2.0
-    byte[] h2 = "h2".getBytes();
-    byte[][] protocols = new byte[][]{h2};
-    if (androidSocketFatoryTls.equals("alpn")) {
-      Method setAlpnProtocols =
-          factory.getClass().getDeclaredMethod("setAlpnProtocols", byte[][].class);
-      setAlpnProtocols.invoke(factory, new Object[] { protocols });
-    } else if (androidSocketFatoryTls.equals("npn")) {
-      Method setNpnProtocols =
-          factory.getClass().getDeclaredMethod("setNpnProtocols", byte[][].class);
-      setNpnProtocols.invoke(factory, new Object[]{protocols});
-    } else {
-      throw new RuntimeException("Unknown protocol: " + androidSocketFatoryTls);
-    }
-
-    if (testCa != null) {
-      factory.setTrustManagers(getTrustManagers(testCa));
-    }
-
-    return factory;
-  }
-
-  private static TrustManager[] getTrustManagers(InputStream testCa) throws Exception {
-    KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
-    ks.load(null);
-    CertificateFactory cf = CertificateFactory.getInstance("X.509");
-    X509Certificate cert = (X509Certificate) cf.generateCertificate(testCa);
-    X500Principal principal = cert.getSubjectX500Principal();
-    ks.setCertificateEntry(principal.getName("RFC2253"), cert);
-    // Set up trust manager factory to use our key store.
-    TrustManagerFactory trustManagerFactory =
-        TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
-    trustManagerFactory.init(ks);
-    return trustManagerFactory.getTrustManagers();
-  }
-}
-
diff --git a/android-interop-testing/app/src/main/proto/io/grpc/android/integrationtest/empty.proto b/android-interop-testing/app/src/main/proto/io/grpc/android/integrationtest/empty.proto
deleted file mode 100644
index e74f4165758..00000000000
--- a/android-interop-testing/app/src/main/proto/io/grpc/android/integrationtest/empty.proto
+++ /dev/null
@@ -1,46 +0,0 @@
-
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto2";
-
-package grpc.testing;
-
-option java_package = "com.google.protobuf";
-option java_outer_classname = "EmptyProtos";
-
-// An empty message that you can re-use to avoid defining duplicated empty
-// messages in your project. A typical example is to use it as argument or the
-// return value of a service API. For instance:
-//
-//   service Foo {
-//     rpc Bar (grpc.testing.Empty) returns (grpc.testing.Empty) { };
-//   };
-//
-message Empty {}
diff --git a/android-interop-testing/app/src/main/proto/io/grpc/android/integrationtest/messages.proto b/android-interop-testing/app/src/main/proto/io/grpc/android/integrationtest/messages.proto
deleted file mode 100644
index b798d791bf1..00000000000
--- a/android-interop-testing/app/src/main/proto/io/grpc/android/integrationtest/messages.proto
+++ /dev/null
@@ -1,138 +0,0 @@
-
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Message definitions to be used by integration test service definitions.
-
-syntax = "proto3";
-
-package grpc.testing;
-
-option java_package = "io.grpc.android.integrationtest";
-
-// The type of payload that should be returned.
-enum PayloadType {
-  // Compressable text format.
-  COMPRESSABLE = 0;
-
-  // Uncompressable binary format.
-  UNCOMPRESSABLE = 1;
-
-  // Randomly chosen from all other formats defined in this enum.
-  RANDOM = 2;
-}
-
-// A block of data, to simply increase gRPC message size.
-message Payload {
-  // The type of data in body.
-  PayloadType type = 1;
-  // Primary contents of payload.
-  bytes body = 2;
-}
-
-// Unary request.
-message SimpleRequest {
-  // Desired payload type in the response from the server.
-  // If response_type is RANDOM, server randomly chooses one from other formats.
-  PayloadType response_type = 1;
-
-  // Desired payload size in the response from the server.
-  // If response_type is COMPRESSABLE, this denotes the size before compression.
-  int32 response_size = 2;
-
-  // Optional input payload sent along with the request.
-  Payload payload = 3;
-
-  // Whether SimpleResponse should include username.
-  bool fill_username = 4;
-
-  // Whether SimpleResponse should include OAuth scope.
-  bool fill_oauth_scope = 5;
-}
-
-// Unary response, as configured by the request.
-message SimpleResponse {
-  // Payload to increase message size.
-  Payload payload = 1;
-  // The user the request came from, for verifying authentication was
-  // successful when the client expected it.
-  string username = 2;
-  // OAuth scope.
-  string oauth_scope = 3;
-}
-
-message SimpleContext {
-  string value = 1;
-}
-
-// Client-streaming request.
-message StreamingInputCallRequest {
-  // Optional input payload sent along with the request.
-  Payload payload = 1;
-
-  // Not expecting any payload from the response.
-}
-
-// Client-streaming response.
-message StreamingInputCallResponse {
-  // Aggregated size of payloads received from the client.
-  int32 aggregated_payload_size = 1;
-}
-
-// Configuration for a particular response.
-message ResponseParameters {
-  // Desired payload sizes in responses from the server.
-  // If response_type is COMPRESSABLE, this denotes the size before compression.
-  int32 size = 1;
-
-  // Desired interval between consecutive responses in the response stream in
-  // microseconds.
-  int32 interval_us = 2;
-}
-
-// Server-streaming request.
-message StreamingOutputCallRequest {
-  // Desired payload type in the response from the server.
-  // If response_type is RANDOM, the payload from each response in the stream
-  // might be of different types. This is to simulate a mixed type of payload
-  // stream.
-  PayloadType response_type = 1;
-
-  // Configuration for each expected response message.
-  repeated ResponseParameters response_parameters = 2;
-
-  // Optional input payload sent along with the request.
-  Payload payload = 3;
-}
-
-// Server-streaming response, as configured by the request and parameters.
-message StreamingOutputCallResponse {
-  // Payload to increase response size.
-  Payload payload = 1;
-}
diff --git a/android-interop-testing/app/src/main/proto/io/grpc/android/integrationtest/test.proto b/android-interop-testing/app/src/main/proto/io/grpc/android/integrationtest/test.proto
deleted file mode 100644
index c6df4ee8f1b..00000000000
--- a/android-interop-testing/app/src/main/proto/io/grpc/android/integrationtest/test.proto
+++ /dev/null
@@ -1,80 +0,0 @@
-
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// An integration test service that covers all the method signature permutations
-// of unary/streaming requests/responses.
-syntax = "proto3";
-
-import "io/grpc/android/integrationtest/empty.proto";
-import "io/grpc/android/integrationtest/messages.proto";
-
-package grpc.testing;
-
-option java_package = "io.grpc.android.integrationtest";
-
-// A simple service to test the various types of RPCs and experiment with
-// performance with various types of payload.
-service TestService {
-  // One empty request followed by one empty response.
-  rpc EmptyCall(grpc.testing.Empty) returns (grpc.testing.Empty);
-
-  // One request followed by one response.
-  rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
-
-  // One request followed by a sequence of responses (streamed download).
-  // The server returns the payload with client desired type and sizes.
-  rpc StreamingOutputCall(StreamingOutputCallRequest)
-      returns (stream StreamingOutputCallResponse);
-
-  // A sequence of requests followed by one response (streamed upload).
-  // The server returns the aggregated size of client payload as the result.
-  rpc StreamingInputCall(stream StreamingInputCallRequest)
-      returns (StreamingInputCallResponse);
-
-  // A sequence of requests with each request served by the server immediately.
-  // As one request could lead to multiple responses, this interface
-  // demonstrates the idea of full duplexing.
-  rpc FullDuplexCall(stream StreamingOutputCallRequest)
-      returns (stream StreamingOutputCallResponse);
-
-  // A sequence of requests followed by a sequence of responses.
-  // The server buffers all the client requests and then serves them in order. A
-  // stream of responses are returned to the client when the server starts with
-  // first request.
-  rpc HalfDuplexCall(stream StreamingOutputCallRequest)
-      returns (stream StreamingOutputCallResponse);
-}
-
-// A simple service NOT implemented at servers so clients can test for
-// that case.
-service UnimplementedService {
-  // A call that no server should implement
-  rpc UnimplementedCall(grpc.testing.Empty) returns(grpc.testing.Empty);
-}
diff --git a/android-interop-testing/app/src/main/res/layout/activity_tester.xml b/android-interop-testing/app/src/main/res/layout/activity_tester.xml
deleted file mode 100644
index 8c8581a4ead..00000000000
--- a/android-interop-testing/app/src/main/res/layout/activity_tester.xml
+++ /dev/null
@@ -1,97 +0,0 @@
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    tools:context=".MainActivity"
-    android:orientation="vertical"
-    >
-
-  <LinearLayout
-      android:layout_width="match_parent"
-      android:layout_height="wrap_content"
-      android:orientation="horizontal"
-      >
-    <EditText
-        android:id="@+id/host_edit_text"
-        android:layout_weight="2"
-        android:layout_width="0dp"
-        android:layout_height="wrap_content"
-        android:hint="Enter Host"
-        />
-    <EditText
-        android:id="@+id/port_edit_text"
-        android:layout_weight="1"
-        android:layout_width="0dp"
-        android:layout_height="wrap_content"
-        android:inputType="numberDecimal"
-        android:hint="Enter Port"
-        />
-  </LinearLayout>
-
-  <Button
-      android:id="@+id/empty_unary_button"
-      android:layout_width="match_parent"
-      android:layout_height="wrap_content"
-      android:onClick="startEmptyUnary"
-      android:text="Empty Unary"
-      />
-
-  <Button
-      android:id="@+id/large_unary_button"
-      android:layout_width="match_parent"
-      android:layout_height="wrap_content"
-      android:onClick="startLargeUnary"
-      android:text="Large Unary"
-      />
-
-  <Button
-      android:id="@+id/client_streaming_button"
-      android:layout_width="match_parent"
-      android:layout_height="wrap_content"
-      android:onClick="startClientStreaming"
-      android:text="Client Streaming"
-      />
-
-  <Button
-      android:id="@+id/server_streaming_button"
-      android:layout_width="match_parent"
-      android:layout_height="wrap_content"
-      android:onClick="startServerStreaming"
-      android:text="Server Streaming"
-      />
-
-  <Button
-      android:id="@+id/ping_pong_button"
-      android:layout_width="match_parent"
-      android:layout_height="wrap_content"
-      android:onClick="startPingPong"
-      android:text="Ping Pong"
-      />
-
-  <TextView
-      android:layout_width="match_parent"
-      android:layout_height="wrap_content"
-      android:paddingTop="12dp"
-      android:paddingBottom="12dp"
-      android:textSize="16sp"
-      android:text="Response:"
-      />
-
-  <ScrollView
-      android:id="@+id/result_area"
-      android:layout_width="fill_parent"
-      android:layout_height="wrap_content"
-      android:scrollbars="vertical"
-      android:fillViewport="true"
-      >
-
-    <TextView
-        android:id="@+id/grpc_response_text"
-        android:layout_width="fill_parent"
-        android:layout_height="wrap_content"
-        android:textSize="16sp"
-        />
-
-  </ScrollView>
-
-</LinearLayout>
diff --git a/android-interop-testing/app/src/main/res/raw/ca.pem b/android-interop-testing/app/src/main/res/raw/ca.pem
deleted file mode 100644
index 6c8511a73c6..00000000000
--- a/android-interop-testing/app/src/main/res/raw/ca.pem
+++ /dev/null
@@ -1,15 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICSjCCAbOgAwIBAgIJAJHGGR4dGioHMA0GCSqGSIb3DQEBCwUAMFYxCzAJBgNV
-BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX
-aWRnaXRzIFB0eSBMdGQxDzANBgNVBAMTBnRlc3RjYTAeFw0xNDExMTEyMjMxMjla
-Fw0yNDExMDgyMjMxMjlaMFYxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0
-YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxDzANBgNVBAMT
-BnRlc3RjYTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAwEDfBV5MYdlHVHJ7
-+L4nxrZy7mBfAVXpOc5vMYztssUI7mL2/iYujiIXM+weZYNTEpLdjyJdu7R5gGUu
-g1jSVK/EPHfc74O7AyZU34PNIP4Sh33N+/A5YexrNgJlPY+E3GdVYi4ldWJjgkAd
-Qah2PH5ACLrIIC6tRka9hcaBlIECAwEAAaMgMB4wDAYDVR0TBAUwAwEB/zAOBgNV
-HQ8BAf8EBAMCAgQwDQYJKoZIhvcNAQELBQADgYEAHzC7jdYlzAVmddi/gdAeKPau
-sPBG/C2HCWqHzpCUHcKuvMzDVkY/MP2o6JIW2DBbY64bO/FceExhjcykgaYtCH/m
-oIU63+CFOTtR7otyQAWHqXa7q4SbCDlG7DyRFxqG0txPtGvy12lgldA2+RgcigQG
-Dfcog5wrJytaQ6UA0wE=
------END CERTIFICATE-----
diff --git a/android-interop-testing/app/src/main/res/values/strings.xml b/android-interop-testing/app/src/main/res/values/strings.xml
deleted file mode 100644
index 6d5cb2a79ce..00000000000
--- a/android-interop-testing/app/src/main/res/values/strings.xml
+++ /dev/null
@@ -1,3 +0,0 @@
-<resources>
-    <string name="app_name">gRPC Integration Test</string>
-</resources>
diff --git a/android-interop-testing/build.gradle b/android-interop-testing/build.gradle
index 6aa55c2e0b9..17551465f05 100644
--- a/android-interop-testing/build.gradle
+++ b/android-interop-testing/build.gradle
@@ -1,52 +1,130 @@
-// Top-level build file where you can add configuration options common to all sub-projects/modules.
+plugins {
+    id "com.android.application"
+    id "com.google.protobuf"
+}
+
+description = 'gRPC: Android Integration Testing'
+
+repositories {
+    google()
+}
 
-buildscript {
-    repositories {
-        jcenter()
+android {
+    namespace = 'io.grpc.android.integrationtest'
+    sourceSets {
+        main {
+            java {
+                srcDirs += "${projectDir}/../interop-testing/src/main/java/"
+                setIncludes(["io/grpc/android/integrationtest/**",
+                             "io/grpc/testing/integration/AbstractInteropTest.java",
+                             "io/grpc/testing/integration/TestServiceImpl.java",
+                             "io/grpc/testing/integration/Util.java"])
+            }
+            proto {
+                srcDirs += "${projectDir}/../interop-testing/src/main/proto/"
+            }
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
     }
-    dependencies {
-        classpath 'com.android.tools.build:gradle:2.2.0'
-        classpath "com.google.protobuf:protobuf-gradle-plugin:0.8.0"
+    compileSdkVersion 34
 
-        // NOTE: Do not place your application dependencies here; they belong
-        // in the individual module build.gradle files
+    defaultConfig {
+        applicationId "io.grpc.android.integrationtest"
+        // Held back to 20 as Gradle fails to build at the 21 level. This is
+        // presumably a Gradle bug that can be revisited later.
+        // Maybe this issue: https://github.com/gradle/gradle/issues/20778
+        minSdkVersion 20
+        targetSdkVersion 33
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        multiDexEnabled = true
+    }
+    buildTypes {
+        debug { minifyEnabled false }
+        release {
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        disable 'InvalidPackage', 'HardcodedText', 'UsingOnClickInXml',
+                'MissingClass' // https://github.com/grpc/grpc-java/issues/8799
+    }
+    packagingOptions {
+        exclude 'META-INF/INDEX.LIST'
+        exclude 'META-INF/io.netty.versions.properties'
     }
 }
 
-allprojects {
-    repositories {
-        mavenLocal()
-        jcenter()
+dependencies {
+    implementation 'androidx.appcompat:appcompat:1.3.0'
+    implementation 'androidx.multidex:multidex:2.0.0'
+    implementation libraries.androidx.annotation
+    implementation 'com.google.android.gms:play-services-base:18.0.1'
+
+    implementation project(':grpc-android'),
+            project(':grpc-core'),
+            project(':grpc-census'),
+            project(':grpc-okhttp'),
+            project(':grpc-protobuf-lite'),
+            project(':grpc-stub'),
+            project(':grpc-testing'),
+            libraries.junit,
+            libraries.truth,
+            libraries.androidx.test.rules,
+            libraries.opencensus.contrib.grpc.metrics
+
+    implementation (project(':grpc-services')) {
+        exclude group: 'com.google.protobuf'
+        exclude group: 'com.google.guava'
     }
+
+    androidTestImplementation 'androidx.test.ext:junit:1.1.3',
+            'androidx.test:runner:1.4.0'
 }
 
-subprojects {
-    apply plugin: "checkstyle"
+// Checkstyle doesn't run automatically with android
+task checkStyleMain(type: Checkstyle) {
+    source 'src/main/java'
+    include '**/*.java'
+    classpath = files()
+}
 
-    checkstyle {
-        configFile = file("$rootDir/../checkstyle.xml")
-        toolVersion = "6.17"
-        ignoreFailures = false
-        if (rootProject.hasProperty("checkstyle.ignoreFailures")) {
-            ignoreFailures = rootProject.properties["checkstyle.ignoreFailures"].toBoolean()
-        }
-        configProperties["rootDir"] = "$rootDir/../"
-    }
+task checkStyleTest(type: Checkstyle) {
+    source 'src/androidTest/java'
+    include '**/*.java'
+    classpath = files()
+}
 
-    // Checkstyle doesn't run automatically with android
-    task checkStyleMain(type: Checkstyle) {
-        source 'src/main/java'
-        include '**/*.java'
-        classpath = files()
-    }
+project.tasks['check'].dependsOn checkStyleMain, checkStyleTest
 
-    task checkStyleTest(type: Checkstyle) {
-        source 'src/test/java'
-        include '**/*.java'
-        classpath = files()
-    }
+import net.ltgt.gradle.errorprone.CheckSeverity
+
+tasks.withType(JavaCompile).configureEach {
+    options.compilerArgs += [
+            "-Xlint:-cast",
+    ]
+    appendToProperty(it.options.errorprone.excludedPaths, ".*/R.java", "|")
+    appendToProperty(
+            it.options.errorprone.excludedPaths,
+            ".*/src/generated/.*",
+            "|")
+}
 
-    afterEvaluate { project ->
-        project.tasks['check'].dependsOn checkStyleMain, checkStyleTest
+afterEvaluate {
+    // Hack to workaround "Task ':grpc-android-interop-testing:extractIncludeDebugProto' uses this
+    // output of task ':grpc-context:jar' without declaring an explicit or implicit dependency." The
+    // issue started when grpc-context became empty.
+    tasks.named('extractIncludeDebugProto').configure {
+        dependsOn project(':grpc-context').tasks.named('jar')
+    }
+    tasks.named('extractIncludeReleaseProto').configure {
+        dependsOn project(':grpc-context').tasks.named('jar')
     }
 }
+
+configureProtoCompilation()
diff --git a/android-interop-testing/proguard-rules.pro b/android-interop-testing/proguard-rules.pro
new file mode 100644
index 00000000000..a9e696958b9
--- /dev/null
+++ b/android-interop-testing/proguard-rules.pro
@@ -0,0 +1,27 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in $ANDROID_HOME/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+-dontwarn android.test.**
+-dontwarn com.google.common.**
+-dontwarn javax.naming.**
+-dontwarn okio.**
+-dontwarn org.junit.**
+-dontwarn org.mockito.**
+-dontwarn sun.reflect.**
+# Ignores: can't find referenced class javax.lang.model.element.Modifier
+-dontwarn com.google.errorprone.annotations.**
+
+# Ignores: can't find referenced method from grpc-testing's compileOnly dependency on Truth
+-dontwarn io.grpc.testing.DeadlineSubject
+
+-keepclassmembers class io.grpc.testing.integration.Messages$* {
+    *;
+}
\ No newline at end of file
diff --git a/android-interop-testing/settings.gradle b/android-interop-testing/settings.gradle
deleted file mode 100644
index e7b4def49cb..00000000000
--- a/android-interop-testing/settings.gradle
+++ /dev/null
@@ -1 +0,0 @@
-include ':app'
diff --git a/android-interop-testing/src/androidTest/AndroidManifest.xml b/android-interop-testing/src/androidTest/AndroidManifest.xml
new file mode 100644
index 00000000000..b0507f10ab9
--- /dev/null
+++ b/android-interop-testing/src/androidTest/AndroidManifest.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" >
+
+    <instrumentation
+        android:name="androidx.test.runner.AndroidJUnitRunner"
+        android:targetPackage="io.grpc.android.integrationtest" />
+
+    <application
+        android:name="android.support.multidex.MultiDexApplication" >
+    </application>
+
+</manifest>
diff --git a/android-interop-testing/src/androidTest/java/io/grpc/android/integrationtest/InteropInstrumentationTest.java b/android-interop-testing/src/androidTest/java/io/grpc/android/integrationtest/InteropInstrumentationTest.java
new file mode 100644
index 00000000000..a5870063a87
--- /dev/null
+++ b/android-interop-testing/src/androidTest/java/io/grpc/android/integrationtest/InteropInstrumentationTest.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2017 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.android.integrationtest;
+
+import static org.junit.Assert.assertEquals;
+
+import android.util.Log;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+import com.google.android.gms.common.GooglePlayServicesNotAvailableException;
+import com.google.android.gms.common.GooglePlayServicesRepairableException;
+import com.google.android.gms.security.ProviderInstaller;
+import java.io.InputStream;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public class InteropInstrumentationTest {
+  private static final int TIMEOUT_SECONDS = 60;
+  private static final String LOG_TAG = "GrpcInteropInstrumentationTest";
+
+  private String host;
+  private int port;
+  private boolean useTls;
+  private String serverHostOverride;
+  private boolean useTestCa;
+  private String testCase;
+  private ExecutorService executor = Executors.newSingleThreadExecutor();
+
+  @Before
+  public void setUp() throws Exception {
+    host = InstrumentationRegistry.getArguments().getString("server_host", "10.0.2.2");
+    port =
+        Integer.parseInt(InstrumentationRegistry.getArguments().getString("server_port", "8080"));
+    useTls =
+        Boolean.parseBoolean(InstrumentationRegistry.getArguments().getString("use_tls", "true"));
+    serverHostOverride = InstrumentationRegistry.getArguments().getString("server_host_override");
+    useTestCa =
+        Boolean.parseBoolean(
+            InstrumentationRegistry.getArguments().getString("use_test_ca", "false"));
+    testCase = InstrumentationRegistry.getArguments().getString("test_case", "all");
+
+    if (useTls) {
+      try {
+        ProviderInstaller.installIfNeeded(ApplicationProvider.getApplicationContext());
+      } catch (GooglePlayServicesRepairableException e) {
+        // The provider is helpful, but it is possible to succeed without it.
+        // Hope that the system-provided libraries are new enough.
+        Log.i(LOG_TAG, "Failed installing security provider", e);
+      } catch (GooglePlayServicesNotAvailableException e) {
+        // The provider is helpful, but it is possible to succeed without it.
+        // Hope that the system-provided libraries are new enough.
+        Log.i(LOG_TAG, "Failed installing security provider", e);
+      }
+    }
+  }
+
+  @Test
+  public void interopTests() throws Exception {
+    if (testCase.equals("all")) {
+      runTest("empty_unary");
+      runTest("large_unary");
+      runTest("client_streaming");
+      runTest("server_streaming");
+      runTest("ping_pong");
+      runTest("empty_stream");
+      runTest("cancel_after_begin");
+      runTest("cancel_after_first_response");
+      runTest("full_duplex_call_should_succeed");
+      runTest("half_duplex_call_should_succeed");
+      runTest("server_streaming_should_be_flow_controlled");
+      runTest("very_large_request");
+      runTest("very_large_response");
+      runTest("deadline_not_exceeded");
+      runTest("deadline_exceeded");
+      runTest("deadline_exceeded_server_streaming");
+      runTest("unimplemented_method");
+      runTest("timeout_on_sleeping_server");
+      runTest("graceful_shutdown");
+    } else {
+      runTest(testCase);
+    }
+  }
+
+  private void runTest(String testCase) throws Exception {
+    InputStream testCa;
+    if (useTestCa) {
+      testCa = ApplicationProvider.getApplicationContext().getResources().openRawResource(R.raw.ca);
+    } else {
+      testCa = null;
+    }
+
+    String result = null;
+    try {
+      result = executor.submit(new TestCallable(
+              TesterOkHttpChannelBuilder.build(host, port, serverHostOverride, useTls, testCa),
+              testCase)).get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
+    } catch (ExecutionException | InterruptedException | TimeoutException e) {
+      Log.e(LOG_TAG, "Error while executing test case " + testCase, e);
+      result = e.getMessage();
+    }
+    assertEquals(testCase + " failed", TestCallable.SUCCESS_MESSAGE, result);
+  }
+}
diff --git a/android-interop-testing/src/androidTest/java/io/grpc/android/integrationtest/UdsChannelInteropTest.java b/android-interop-testing/src/androidTest/java/io/grpc/android/integrationtest/UdsChannelInteropTest.java
new file mode 100644
index 00000000000..f5e54da5d4e
--- /dev/null
+++ b/android-interop-testing/src/androidTest/java/io/grpc/android/integrationtest/UdsChannelInteropTest.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2021 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.android.integrationtest;
+
+import static org.junit.Assert.assertEquals;
+
+import android.net.LocalSocketAddress.Namespace;
+import androidx.test.InstrumentationRegistry;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.rule.ActivityTestRule;
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.android.UdsChannelBuilder;
+import io.grpc.testing.integration.TestServiceImpl;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * Tests for channels created with {@link UdsChannelBuilder}. The UDS Channel is only meant to talk
+ * to Unix Domain Socket endpoints on servers that are on-device, so a {@link LocalTestServer} is
+ * set up to expose a UDS endpoint.
+ */
+@RunWith(AndroidJUnit4.class)
+public class UdsChannelInteropTest {
+  private static final int TIMEOUT_SECONDS = 150;
+
+  private static final String UDS_PATH = "udspath";
+  private String testCase;
+
+  private Server server;
+  private UdsTcpEndpointConnector endpointConnector;
+
+  private ScheduledExecutorService serverExecutor = Executors.newScheduledThreadPool(2);
+  private ExecutorService testExecutor = Executors.newSingleThreadExecutor();
+
+  // Ensures Looper is initialized for tests running on API level 15. Otherwise instantiating an
+  // AsyncTask throws an exception.
+  @Rule
+  public ActivityTestRule<TesterActivity> activityRule =
+      new ActivityTestRule<TesterActivity>(TesterActivity.class);
+
+  @Before
+  public void setUp() throws IOException {
+    testCase = InstrumentationRegistry.getArguments().getString("test_case", "all");
+
+    // Start local server.
+    server =
+        Grpc.newServerBuilderForPort(0, InsecureServerCredentials.create())
+            .maxInboundMessageSize(16 * 1024 * 1024)
+            .addService(new TestServiceImpl(serverExecutor))
+            .build();
+    server.start();
+
+    // Connect uds endpoint to server's endpoint.
+    endpointConnector = new UdsTcpEndpointConnector(UDS_PATH, "0.0.0.0", server.getPort());
+    endpointConnector.start();
+  }
+
+  @After
+  public void teardown() {
+    server.shutdownNow();
+    endpointConnector.shutDown();
+  }
+
+  @Test
+  public void interopTests() throws Exception {
+    if (testCase.equals("all")) {
+      runTest("empty_unary");
+      runTest("large_unary");
+      runTest("client_streaming");
+      runTest("server_streaming");
+      runTest("ping_pong");
+      runTest("empty_stream");
+      runTest("cancel_after_begin");
+      runTest("cancel_after_first_response");
+      runTest("full_duplex_call_should_succeed");
+      runTest("half_duplex_call_should_succeed");
+      runTest("server_streaming_should_be_flow_controlled");
+      runTest("very_large_request");
+      runTest("very_large_response");
+      runTest("deadline_not_exceeded");
+      runTest("deadline_exceeded");
+      runTest("deadline_exceeded_server_streaming");
+      runTest("unimplemented_method");
+      runTest("timeout_on_sleeping_server");
+      runTest("graceful_shutdown");
+    } else {
+      runTest(testCase);
+    }
+  }
+
+  private void runTest(String testCase) throws Exception {
+    String result = null;
+    try {
+      result = testExecutor.submit(new TestCallable(
+              UdsChannelBuilder.forPath(UDS_PATH, Namespace.ABSTRACT)
+                      .maxInboundMessageSize(16 * 1024 * 1024)
+                      .build(),
+              testCase)).get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
+      assertEquals(testCase + " failed", TestCallable.SUCCESS_MESSAGE, result);
+    } catch (ExecutionException | InterruptedException e) {
+      result = e.getMessage();
+    }
+  }
+}
diff --git a/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java
new file mode 100644
index 00000000000..33b914bb4b3
--- /dev/null
+++ b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java
@@ -0,0 +1,423 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A service used to obtain stats for verifying LB behavior.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class LoadBalancerStatsServiceGrpc {
+
+  private LoadBalancerStatsServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.LoadBalancerStatsService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerStatsRequest,
+      io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> getGetClientStatsMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetClientStats",
+      requestType = io.grpc.testing.integration.Messages.LoadBalancerStatsRequest.class,
+      responseType = io.grpc.testing.integration.Messages.LoadBalancerStatsResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerStatsRequest,
+      io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> getGetClientStatsMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerStatsRequest, io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> getGetClientStatsMethod;
+    if ((getGetClientStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientStatsMethod) == null) {
+      synchronized (LoadBalancerStatsServiceGrpc.class) {
+        if ((getGetClientStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientStatsMethod) == null) {
+          LoadBalancerStatsServiceGrpc.getGetClientStatsMethod = getGetClientStatsMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.LoadBalancerStatsRequest, io.grpc.testing.integration.Messages.LoadBalancerStatsResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetClientStats"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.LoadBalancerStatsRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.LoadBalancerStatsResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getGetClientStatsMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest,
+      io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> getGetClientAccumulatedStatsMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetClientAccumulatedStats",
+      requestType = io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest.class,
+      responseType = io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest,
+      io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> getGetClientAccumulatedStatsMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest, io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> getGetClientAccumulatedStatsMethod;
+    if ((getGetClientAccumulatedStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientAccumulatedStatsMethod) == null) {
+      synchronized (LoadBalancerStatsServiceGrpc.class) {
+        if ((getGetClientAccumulatedStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientAccumulatedStatsMethod) == null) {
+          LoadBalancerStatsServiceGrpc.getGetClientAccumulatedStatsMethod = getGetClientAccumulatedStatsMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest, io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetClientAccumulatedStats"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getGetClientAccumulatedStatsMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceStub>() {
+        @java.lang.Override
+        public LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerStatsServiceStub(channel, callOptions);
+        }
+      };
+    return LoadBalancerStatsServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static LoadBalancerStatsServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public LoadBalancerStatsServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerStatsServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return LoadBalancerStatsServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static LoadBalancerStatsServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceBlockingStub>() {
+        @java.lang.Override
+        public LoadBalancerStatsServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerStatsServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return LoadBalancerStatsServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static LoadBalancerStatsServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceFutureStub>() {
+        @java.lang.Override
+        public LoadBalancerStatsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerStatsServiceFutureStub(channel, callOptions);
+        }
+      };
+    return LoadBalancerStatsServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    default void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetClientStatsMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    default void getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetClientAccumulatedStatsMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static abstract class LoadBalancerStatsServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return LoadBalancerStatsServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static final class LoadBalancerStatsServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<LoadBalancerStatsServiceStub> {
+    private LoadBalancerStatsServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerStatsServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerStatsServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetClientStatsMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    public void getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetClientAccumulatedStatsMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static final class LoadBalancerStatsServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<LoadBalancerStatsServiceBlockingV2Stub> {
+    private LoadBalancerStatsServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerStatsServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerStatsServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.LoadBalancerStatsResponse getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetClientStatsMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetClientAccumulatedStatsMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static final class LoadBalancerStatsServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<LoadBalancerStatsServiceBlockingStub> {
+    private LoadBalancerStatsServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerStatsServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerStatsServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.LoadBalancerStatsResponse getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetClientStatsMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetClientAccumulatedStatsMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static final class LoadBalancerStatsServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<LoadBalancerStatsServiceFutureStub> {
+    private LoadBalancerStatsServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerStatsServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerStatsServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> getClientStats(
+        io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetClientStatsMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> getClientAccumulatedStats(
+        io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetClientAccumulatedStatsMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_GET_CLIENT_STATS = 0;
+  private static final int METHODID_GET_CLIENT_ACCUMULATED_STATS = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_GET_CLIENT_STATS:
+          serviceImpl.getClientStats((io.grpc.testing.integration.Messages.LoadBalancerStatsRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerStatsResponse>) responseObserver);
+          break;
+        case METHODID_GET_CLIENT_ACCUMULATED_STATS:
+          serviceImpl.getClientAccumulatedStats((io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getGetClientStatsMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.LoadBalancerStatsRequest,
+              io.grpc.testing.integration.Messages.LoadBalancerStatsResponse>(
+                service, METHODID_GET_CLIENT_STATS)))
+        .addMethod(
+          getGetClientAccumulatedStatsMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest,
+              io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse>(
+                service, METHODID_GET_CLIENT_ACCUMULATED_STATS)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (LoadBalancerStatsServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getGetClientStatsMethod())
+              .addMethod(getGetClientAccumulatedStatsMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java
new file mode 100644
index 00000000000..c99abcff7cb
--- /dev/null
+++ b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java
@@ -0,0 +1,398 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class MetricsServiceGrpc {
+
+  private MetricsServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.MetricsService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.EmptyMessage,
+      io.grpc.testing.integration.Metrics.GaugeResponse> getGetAllGaugesMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetAllGauges",
+      requestType = io.grpc.testing.integration.Metrics.EmptyMessage.class,
+      responseType = io.grpc.testing.integration.Metrics.GaugeResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.EmptyMessage,
+      io.grpc.testing.integration.Metrics.GaugeResponse> getGetAllGaugesMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.EmptyMessage, io.grpc.testing.integration.Metrics.GaugeResponse> getGetAllGaugesMethod;
+    if ((getGetAllGaugesMethod = MetricsServiceGrpc.getGetAllGaugesMethod) == null) {
+      synchronized (MetricsServiceGrpc.class) {
+        if ((getGetAllGaugesMethod = MetricsServiceGrpc.getGetAllGaugesMethod) == null) {
+          MetricsServiceGrpc.getGetAllGaugesMethod = getGetAllGaugesMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Metrics.EmptyMessage, io.grpc.testing.integration.Metrics.GaugeResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetAllGauges"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Metrics.EmptyMessage.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getGetAllGaugesMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.GaugeRequest,
+      io.grpc.testing.integration.Metrics.GaugeResponse> getGetGaugeMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetGauge",
+      requestType = io.grpc.testing.integration.Metrics.GaugeRequest.class,
+      responseType = io.grpc.testing.integration.Metrics.GaugeResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.GaugeRequest,
+      io.grpc.testing.integration.Metrics.GaugeResponse> getGetGaugeMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.GaugeRequest, io.grpc.testing.integration.Metrics.GaugeResponse> getGetGaugeMethod;
+    if ((getGetGaugeMethod = MetricsServiceGrpc.getGetGaugeMethod) == null) {
+      synchronized (MetricsServiceGrpc.class) {
+        if ((getGetGaugeMethod = MetricsServiceGrpc.getGetGaugeMethod) == null) {
+          MetricsServiceGrpc.getGetGaugeMethod = getGetGaugeMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Metrics.GaugeRequest, io.grpc.testing.integration.Metrics.GaugeResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetGauge"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Metrics.GaugeRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getGetGaugeMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static MetricsServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<MetricsServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<MetricsServiceStub>() {
+        @java.lang.Override
+        public MetricsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new MetricsServiceStub(channel, callOptions);
+        }
+      };
+    return MetricsServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static MetricsServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<MetricsServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<MetricsServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public MetricsServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new MetricsServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return MetricsServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static MetricsServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<MetricsServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<MetricsServiceBlockingStub>() {
+        @java.lang.Override
+        public MetricsServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new MetricsServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return MetricsServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static MetricsServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<MetricsServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<MetricsServiceFutureStub>() {
+        @java.lang.Override
+        public MetricsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new MetricsServiceFutureStub(channel, callOptions);
+        }
+      };
+    return MetricsServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     * </pre>
+     */
+    default void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetAllGaugesMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    default void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetGaugeMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service MetricsService.
+   */
+  public static abstract class MetricsServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return MetricsServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service MetricsService.
+   */
+  public static final class MetricsServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<MetricsServiceStub> {
+    private MetricsServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected MetricsServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new MetricsServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     * </pre>
+     */
+    public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getGetAllGaugesMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetGaugeMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service MetricsService.
+   */
+  public static final class MetricsServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<MetricsServiceBlockingV2Stub> {
+    private MetricsServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected MetricsServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new MetricsServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<?, io.grpc.testing.integration.Metrics.GaugeResponse>
+        getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request) {
+      return io.grpc.stub.ClientCalls.blockingV2ServerStreamingCall(
+          getChannel(), getGetAllGaugesMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetGaugeMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service MetricsService.
+   */
+  public static final class MetricsServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<MetricsServiceBlockingStub> {
+    private MetricsServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected MetricsServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new MetricsServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     * </pre>
+     */
+    public java.util.Iterator<io.grpc.testing.integration.Metrics.GaugeResponse> getAllGauges(
+        io.grpc.testing.integration.Metrics.EmptyMessage request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getGetAllGaugesMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetGaugeMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service MetricsService.
+   */
+  public static final class MetricsServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<MetricsServiceFutureStub> {
+    private MetricsServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected MetricsServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new MetricsServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Metrics.GaugeResponse> getGauge(
+        io.grpc.testing.integration.Metrics.GaugeRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetGaugeMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_GET_ALL_GAUGES = 0;
+  private static final int METHODID_GET_GAUGE = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_GET_ALL_GAUGES:
+          serviceImpl.getAllGauges((io.grpc.testing.integration.Metrics.EmptyMessage) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse>) responseObserver);
+          break;
+        case METHODID_GET_GAUGE:
+          serviceImpl.getGauge((io.grpc.testing.integration.Metrics.GaugeRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getGetAllGaugesMethod(),
+          io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Metrics.EmptyMessage,
+              io.grpc.testing.integration.Metrics.GaugeResponse>(
+                service, METHODID_GET_ALL_GAUGES)))
+        .addMethod(
+          getGetGaugeMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Metrics.GaugeRequest,
+              io.grpc.testing.integration.Metrics.GaugeResponse>(
+                service, METHODID_GET_GAUGE)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (MetricsServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getGetAllGaugesMethod())
+              .addMethod(getGetGaugeMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java
new file mode 100644
index 00000000000..fffcaad2df2
--- /dev/null
+++ b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java
@@ -0,0 +1,393 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A service used to control reconnect server.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class ReconnectServiceGrpc {
+
+  private ReconnectServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.ReconnectService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ReconnectParams,
+      io.grpc.testing.integration.EmptyProtos.Empty> getStartMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Start",
+      requestType = io.grpc.testing.integration.Messages.ReconnectParams.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ReconnectParams,
+      io.grpc.testing.integration.EmptyProtos.Empty> getStartMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ReconnectParams, io.grpc.testing.integration.EmptyProtos.Empty> getStartMethod;
+    if ((getStartMethod = ReconnectServiceGrpc.getStartMethod) == null) {
+      synchronized (ReconnectServiceGrpc.class) {
+        if ((getStartMethod = ReconnectServiceGrpc.getStartMethod) == null) {
+          ReconnectServiceGrpc.getStartMethod = getStartMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.ReconnectParams, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Start"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.ReconnectParams.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getStartMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.Messages.ReconnectInfo> getStopMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Stop",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.Messages.ReconnectInfo.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.Messages.ReconnectInfo> getStopMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.Messages.ReconnectInfo> getStopMethod;
+    if ((getStopMethod = ReconnectServiceGrpc.getStopMethod) == null) {
+      synchronized (ReconnectServiceGrpc.class) {
+        if ((getStopMethod = ReconnectServiceGrpc.getStopMethod) == null) {
+          ReconnectServiceGrpc.getStopMethod = getStopMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.Messages.ReconnectInfo>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Stop"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.ReconnectInfo.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getStopMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static ReconnectServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceStub>() {
+        @java.lang.Override
+        public ReconnectServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReconnectServiceStub(channel, callOptions);
+        }
+      };
+    return ReconnectServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static ReconnectServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public ReconnectServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReconnectServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return ReconnectServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static ReconnectServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceBlockingStub>() {
+        @java.lang.Override
+        public ReconnectServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReconnectServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return ReconnectServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static ReconnectServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceFutureStub>() {
+        @java.lang.Override
+        public ReconnectServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReconnectServiceFutureStub(channel, callOptions);
+        }
+      };
+    return ReconnectServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     */
+    default void start(io.grpc.testing.integration.Messages.ReconnectParams request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStartMethod(), responseObserver);
+    }
+
+    /**
+     */
+    default void stop(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ReconnectInfo> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStopMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static abstract class ReconnectServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return ReconnectServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static final class ReconnectServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<ReconnectServiceStub> {
+    private ReconnectServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReconnectServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReconnectServiceStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public void start(io.grpc.testing.integration.Messages.ReconnectParams request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getStartMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     */
+    public void stop(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ReconnectInfo> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getStopMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static final class ReconnectServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<ReconnectServiceBlockingV2Stub> {
+    private ReconnectServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReconnectServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReconnectServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty start(io.grpc.testing.integration.Messages.ReconnectParams request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getStartMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.Messages.ReconnectInfo stop(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getStopMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static final class ReconnectServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<ReconnectServiceBlockingStub> {
+    private ReconnectServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReconnectServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReconnectServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty start(io.grpc.testing.integration.Messages.ReconnectParams request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getStartMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.Messages.ReconnectInfo stop(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getStopMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static final class ReconnectServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ReconnectServiceFutureStub> {
+    private ReconnectServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReconnectServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReconnectServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> start(
+        io.grpc.testing.integration.Messages.ReconnectParams request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getStartMethod(), getCallOptions()), request);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.ReconnectInfo> stop(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getStopMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_START = 0;
+  private static final int METHODID_STOP = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_START:
+          serviceImpl.start((io.grpc.testing.integration.Messages.ReconnectParams) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        case METHODID_STOP:
+          serviceImpl.stop((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ReconnectInfo>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getStartMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.ReconnectParams,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_START)))
+        .addMethod(
+          getStopMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.Messages.ReconnectInfo>(
+                service, METHODID_STOP)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (ReconnectServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getStartMethod())
+              .addMethod(getStopMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/TestServiceGrpc.java b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/TestServiceGrpc.java
new file mode 100644
index 00000000000..1d7805e3a3f
--- /dev/null
+++ b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/TestServiceGrpc.java
@@ -0,0 +1,969 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A simple service to test the various types of RPCs and experiment with
+ * performance with various types of payload.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class TestServiceGrpc {
+
+  private TestServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.TestService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getEmptyCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "EmptyCall",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getEmptyCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getEmptyCallMethod;
+    if ((getEmptyCallMethod = TestServiceGrpc.getEmptyCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getEmptyCallMethod = TestServiceGrpc.getEmptyCallMethod) == null) {
+          TestServiceGrpc.getEmptyCallMethod = getEmptyCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "EmptyCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getEmptyCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest,
+      io.grpc.testing.integration.Messages.SimpleResponse> getUnaryCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UnaryCall",
+      requestType = io.grpc.testing.integration.Messages.SimpleRequest.class,
+      responseType = io.grpc.testing.integration.Messages.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest,
+      io.grpc.testing.integration.Messages.SimpleResponse> getUnaryCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest, io.grpc.testing.integration.Messages.SimpleResponse> getUnaryCallMethod;
+    if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) {
+          TestServiceGrpc.getUnaryCallMethod = getUnaryCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.SimpleRequest, io.grpc.testing.integration.Messages.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnaryCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.SimpleResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getUnaryCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest,
+      io.grpc.testing.integration.Messages.SimpleResponse> getCacheableUnaryCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "CacheableUnaryCall",
+      requestType = io.grpc.testing.integration.Messages.SimpleRequest.class,
+      responseType = io.grpc.testing.integration.Messages.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest,
+      io.grpc.testing.integration.Messages.SimpleResponse> getCacheableUnaryCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest, io.grpc.testing.integration.Messages.SimpleResponse> getCacheableUnaryCallMethod;
+    if ((getCacheableUnaryCallMethod = TestServiceGrpc.getCacheableUnaryCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getCacheableUnaryCallMethod = TestServiceGrpc.getCacheableUnaryCallMethod) == null) {
+          TestServiceGrpc.getCacheableUnaryCallMethod = getCacheableUnaryCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.SimpleRequest, io.grpc.testing.integration.Messages.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CacheableUnaryCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.SimpleResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getCacheableUnaryCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getStreamingOutputCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingOutputCall",
+      requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getStreamingOutputCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getStreamingOutputCallMethod;
+    if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) {
+          TestServiceGrpc.getStreamingOutputCallMethod = getStreamingOutputCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingOutputCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getStreamingOutputCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingInputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingInputCallResponse> getStreamingInputCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingInputCall",
+      requestType = io.grpc.testing.integration.Messages.StreamingInputCallRequest.class,
+      responseType = io.grpc.testing.integration.Messages.StreamingInputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingInputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingInputCallResponse> getStreamingInputCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingInputCallRequest, io.grpc.testing.integration.Messages.StreamingInputCallResponse> getStreamingInputCallMethod;
+    if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) {
+          TestServiceGrpc.getStreamingInputCallMethod = getStreamingInputCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.StreamingInputCallRequest, io.grpc.testing.integration.Messages.StreamingInputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingInputCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingInputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingInputCallResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getStreamingInputCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getFullDuplexCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "FullDuplexCall",
+      requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getFullDuplexCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getFullDuplexCallMethod;
+    if ((getFullDuplexCallMethod = TestServiceGrpc.getFullDuplexCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getFullDuplexCallMethod = TestServiceGrpc.getFullDuplexCallMethod) == null) {
+          TestServiceGrpc.getFullDuplexCallMethod = getFullDuplexCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FullDuplexCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getFullDuplexCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getHalfDuplexCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "HalfDuplexCall",
+      requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getHalfDuplexCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getHalfDuplexCallMethod;
+    if ((getHalfDuplexCallMethod = TestServiceGrpc.getHalfDuplexCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getHalfDuplexCallMethod = TestServiceGrpc.getHalfDuplexCallMethod) == null) {
+          TestServiceGrpc.getHalfDuplexCallMethod = getHalfDuplexCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "HalfDuplexCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getHalfDuplexCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UnimplementedCall",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod;
+    if ((getUnimplementedCallMethod = TestServiceGrpc.getUnimplementedCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getUnimplementedCallMethod = TestServiceGrpc.getUnimplementedCallMethod) == null) {
+          TestServiceGrpc.getUnimplementedCallMethod = getUnimplementedCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnimplementedCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getUnimplementedCallMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static TestServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceStub>() {
+        @java.lang.Override
+        public TestServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceStub(channel, callOptions);
+        }
+      };
+    return TestServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static TestServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public TestServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return TestServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static TestServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingStub>() {
+        @java.lang.Override
+        public TestServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return TestServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static TestServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceFutureStub>() {
+        @java.lang.Override
+        public TestServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceFutureStub(channel, callOptions);
+        }
+      };
+    return TestServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    default void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getEmptyCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    default void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnaryCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    default void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCacheableUnaryCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    default void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStreamingOutputCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallRequest> streamingInputCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamingInputCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full duplexing.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> fullDuplexCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getFullDuplexCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> halfDuplexCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getHalfDuplexCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    default void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnimplementedCallMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static abstract class TestServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return TestServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static final class TestServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestServiceStub> {
+    private TestServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    public void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getEmptyCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    public void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getCacheableUnaryCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getStreamingOutputCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallRequest> streamingInputCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncClientStreamingCall(
+          getChannel().newCall(getStreamingInputCallMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full duplexing.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> fullDuplexCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getFullDuplexCallMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> halfDuplexCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getHalfDuplexCallMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static final class TestServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingV2Stub> {
+    private TestServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getEmptyCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.SimpleResponse unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.SimpleResponse cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getCacheableUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<?, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>
+        streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request) {
+      return io.grpc.stub.ClientCalls.blockingV2ServerStreamingCall(
+          getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.integration.Messages.StreamingInputCallRequest, io.grpc.testing.integration.Messages.StreamingInputCallResponse>
+        streamingInputCall() {
+      return io.grpc.stub.ClientCalls.blockingClientStreamingCall(
+          getChannel(), getStreamingInputCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full duplexing.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>
+        fullDuplexCall() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getFullDuplexCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>
+        halfDuplexCall() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getHalfDuplexCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static final class TestServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingStub> {
+    private TestServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getEmptyCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.SimpleResponse unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.SimpleResponse cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getCacheableUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    public java.util.Iterator<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> streamingOutputCall(
+        io.grpc.testing.integration.Messages.StreamingOutputCallRequest request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static final class TestServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestServiceFutureStub> {
+    private TestServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> emptyCall(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getEmptyCallMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.SimpleResponse> unaryCall(
+        io.grpc.testing.integration.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.SimpleResponse> cacheableUnaryCall(
+        io.grpc.testing.integration.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getCacheableUnaryCallMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> unimplementedCall(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_EMPTY_CALL = 0;
+  private static final int METHODID_UNARY_CALL = 1;
+  private static final int METHODID_CACHEABLE_UNARY_CALL = 2;
+  private static final int METHODID_STREAMING_OUTPUT_CALL = 3;
+  private static final int METHODID_UNIMPLEMENTED_CALL = 4;
+  private static final int METHODID_STREAMING_INPUT_CALL = 5;
+  private static final int METHODID_FULL_DUPLEX_CALL = 6;
+  private static final int METHODID_HALF_DUPLEX_CALL = 7;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_EMPTY_CALL:
+          serviceImpl.emptyCall((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        case METHODID_UNARY_CALL:
+          serviceImpl.unaryCall((io.grpc.testing.integration.Messages.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse>) responseObserver);
+          break;
+        case METHODID_CACHEABLE_UNARY_CALL:
+          serviceImpl.cacheableUnaryCall((io.grpc.testing.integration.Messages.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse>) responseObserver);
+          break;
+        case METHODID_STREAMING_OUTPUT_CALL:
+          serviceImpl.streamingOutputCall((io.grpc.testing.integration.Messages.StreamingOutputCallRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse>) responseObserver);
+          break;
+        case METHODID_UNIMPLEMENTED_CALL:
+          serviceImpl.unimplementedCall((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_STREAMING_INPUT_CALL:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamingInputCall(
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallResponse>) responseObserver);
+        case METHODID_FULL_DUPLEX_CALL:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.fullDuplexCall(
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse>) responseObserver);
+        case METHODID_HALF_DUPLEX_CALL:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.halfDuplexCall(
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse>) responseObserver);
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getEmptyCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_EMPTY_CALL)))
+        .addMethod(
+          getUnaryCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.SimpleRequest,
+              io.grpc.testing.integration.Messages.SimpleResponse>(
+                service, METHODID_UNARY_CALL)))
+        .addMethod(
+          getCacheableUnaryCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.SimpleRequest,
+              io.grpc.testing.integration.Messages.SimpleResponse>(
+                service, METHODID_CACHEABLE_UNARY_CALL)))
+        .addMethod(
+          getStreamingOutputCallMethod(),
+          io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+              io.grpc.testing.integration.Messages.StreamingOutputCallResponse>(
+                service, METHODID_STREAMING_OUTPUT_CALL)))
+        .addMethod(
+          getStreamingInputCallMethod(),
+          io.grpc.stub.ServerCalls.asyncClientStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.StreamingInputCallRequest,
+              io.grpc.testing.integration.Messages.StreamingInputCallResponse>(
+                service, METHODID_STREAMING_INPUT_CALL)))
+        .addMethod(
+          getFullDuplexCallMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+              io.grpc.testing.integration.Messages.StreamingOutputCallResponse>(
+                service, METHODID_FULL_DUPLEX_CALL)))
+        .addMethod(
+          getHalfDuplexCallMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+              io.grpc.testing.integration.Messages.StreamingOutputCallResponse>(
+                service, METHODID_HALF_DUPLEX_CALL)))
+        .addMethod(
+          getUnimplementedCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_UNIMPLEMENTED_CALL)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (TestServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getEmptyCallMethod())
+              .addMethod(getUnaryCallMethod())
+              .addMethod(getCacheableUnaryCallMethod())
+              .addMethod(getStreamingOutputCallMethod())
+              .addMethod(getStreamingInputCallMethod())
+              .addMethod(getFullDuplexCallMethod())
+              .addMethod(getHalfDuplexCallMethod())
+              .addMethod(getUnimplementedCallMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java
new file mode 100644
index 00000000000..bec9b5a723a
--- /dev/null
+++ b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java
@@ -0,0 +1,335 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A simple service NOT implemented at servers so clients can test for
+ * that case.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class UnimplementedServiceGrpc {
+
+  private UnimplementedServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.UnimplementedService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UnimplementedCall",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod;
+    if ((getUnimplementedCallMethod = UnimplementedServiceGrpc.getUnimplementedCallMethod) == null) {
+      synchronized (UnimplementedServiceGrpc.class) {
+        if ((getUnimplementedCallMethod = UnimplementedServiceGrpc.getUnimplementedCallMethod) == null) {
+          UnimplementedServiceGrpc.getUnimplementedCallMethod = getUnimplementedCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnimplementedCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getUnimplementedCallMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static UnimplementedServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceStub>() {
+        @java.lang.Override
+        public UnimplementedServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new UnimplementedServiceStub(channel, callOptions);
+        }
+      };
+    return UnimplementedServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static UnimplementedServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public UnimplementedServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new UnimplementedServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return UnimplementedServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static UnimplementedServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceBlockingStub>() {
+        @java.lang.Override
+        public UnimplementedServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new UnimplementedServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return UnimplementedServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static UnimplementedServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceFutureStub>() {
+        @java.lang.Override
+        public UnimplementedServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new UnimplementedServiceFutureStub(channel, callOptions);
+        }
+      };
+    return UnimplementedServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    default void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnimplementedCallMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static abstract class UnimplementedServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return UnimplementedServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static final class UnimplementedServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<UnimplementedServiceStub> {
+    private UnimplementedServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected UnimplementedServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new UnimplementedServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static final class UnimplementedServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<UnimplementedServiceBlockingV2Stub> {
+    private UnimplementedServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected UnimplementedServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new UnimplementedServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static final class UnimplementedServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<UnimplementedServiceBlockingStub> {
+    private UnimplementedServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected UnimplementedServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new UnimplementedServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static final class UnimplementedServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<UnimplementedServiceFutureStub> {
+    private UnimplementedServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected UnimplementedServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new UnimplementedServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> unimplementedCall(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_UNIMPLEMENTED_CALL = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_UNIMPLEMENTED_CALL:
+          serviceImpl.unimplementedCall((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getUnimplementedCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_UNIMPLEMENTED_CALL)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (UnimplementedServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getUnimplementedCallMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/XdsUpdateClientConfigureServiceGrpc.java b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/XdsUpdateClientConfigureServiceGrpc.java
new file mode 100644
index 00000000000..3453b6c01be
--- /dev/null
+++ b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/XdsUpdateClientConfigureServiceGrpc.java
@@ -0,0 +1,328 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A service to dynamically update the configuration of an xDS test client.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class XdsUpdateClientConfigureServiceGrpc {
+
+  private XdsUpdateClientConfigureServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.XdsUpdateClientConfigureService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ClientConfigureRequest,
+      io.grpc.testing.integration.Messages.ClientConfigureResponse> getConfigureMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Configure",
+      requestType = io.grpc.testing.integration.Messages.ClientConfigureRequest.class,
+      responseType = io.grpc.testing.integration.Messages.ClientConfigureResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ClientConfigureRequest,
+      io.grpc.testing.integration.Messages.ClientConfigureResponse> getConfigureMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ClientConfigureRequest, io.grpc.testing.integration.Messages.ClientConfigureResponse> getConfigureMethod;
+    if ((getConfigureMethod = XdsUpdateClientConfigureServiceGrpc.getConfigureMethod) == null) {
+      synchronized (XdsUpdateClientConfigureServiceGrpc.class) {
+        if ((getConfigureMethod = XdsUpdateClientConfigureServiceGrpc.getConfigureMethod) == null) {
+          XdsUpdateClientConfigureServiceGrpc.getConfigureMethod = getConfigureMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.ClientConfigureRequest, io.grpc.testing.integration.Messages.ClientConfigureResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Configure"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.ClientConfigureRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.ClientConfigureResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getConfigureMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static XdsUpdateClientConfigureServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceStub>() {
+        @java.lang.Override
+        public XdsUpdateClientConfigureServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateClientConfigureServiceStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateClientConfigureServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static XdsUpdateClientConfigureServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public XdsUpdateClientConfigureServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateClientConfigureServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return XdsUpdateClientConfigureServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static XdsUpdateClientConfigureServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceBlockingStub>() {
+        @java.lang.Override
+        public XdsUpdateClientConfigureServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateClientConfigureServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateClientConfigureServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static XdsUpdateClientConfigureServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceFutureStub>() {
+        @java.lang.Override
+        public XdsUpdateClientConfigureServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateClientConfigureServiceFutureStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateClientConfigureServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    default void configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ClientConfigureResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getConfigureMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static abstract class XdsUpdateClientConfigureServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return XdsUpdateClientConfigureServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static final class XdsUpdateClientConfigureServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<XdsUpdateClientConfigureServiceStub> {
+    private XdsUpdateClientConfigureServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateClientConfigureServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateClientConfigureServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    public void configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ClientConfigureResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getConfigureMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static final class XdsUpdateClientConfigureServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateClientConfigureServiceBlockingV2Stub> {
+    private XdsUpdateClientConfigureServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateClientConfigureServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateClientConfigureServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.ClientConfigureResponse configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getConfigureMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static final class XdsUpdateClientConfigureServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateClientConfigureServiceBlockingStub> {
+    private XdsUpdateClientConfigureServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateClientConfigureServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateClientConfigureServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.ClientConfigureResponse configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getConfigureMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static final class XdsUpdateClientConfigureServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<XdsUpdateClientConfigureServiceFutureStub> {
+    private XdsUpdateClientConfigureServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateClientConfigureServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateClientConfigureServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.ClientConfigureResponse> configure(
+        io.grpc.testing.integration.Messages.ClientConfigureRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getConfigureMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_CONFIGURE = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_CONFIGURE:
+          serviceImpl.configure((io.grpc.testing.integration.Messages.ClientConfigureRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ClientConfigureResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getConfigureMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.ClientConfigureRequest,
+              io.grpc.testing.integration.Messages.ClientConfigureResponse>(
+                service, METHODID_CONFIGURE)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (XdsUpdateClientConfigureServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getConfigureMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/XdsUpdateHealthServiceGrpc.java b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/XdsUpdateHealthServiceGrpc.java
new file mode 100644
index 00000000000..fb5f2cdebc7
--- /dev/null
+++ b/android-interop-testing/src/generated/debug/grpc/io/grpc/testing/integration/XdsUpdateHealthServiceGrpc.java
@@ -0,0 +1,393 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A service to remotely control health status of an xDS test server.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class XdsUpdateHealthServiceGrpc {
+
+  private XdsUpdateHealthServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.XdsUpdateHealthService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getSetServingMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "SetServing",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getSetServingMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getSetServingMethod;
+    if ((getSetServingMethod = XdsUpdateHealthServiceGrpc.getSetServingMethod) == null) {
+      synchronized (XdsUpdateHealthServiceGrpc.class) {
+        if ((getSetServingMethod = XdsUpdateHealthServiceGrpc.getSetServingMethod) == null) {
+          XdsUpdateHealthServiceGrpc.getSetServingMethod = getSetServingMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetServing"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getSetServingMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getSetNotServingMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "SetNotServing",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getSetNotServingMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getSetNotServingMethod;
+    if ((getSetNotServingMethod = XdsUpdateHealthServiceGrpc.getSetNotServingMethod) == null) {
+      synchronized (XdsUpdateHealthServiceGrpc.class) {
+        if ((getSetNotServingMethod = XdsUpdateHealthServiceGrpc.getSetNotServingMethod) == null) {
+          XdsUpdateHealthServiceGrpc.getSetNotServingMethod = getSetNotServingMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetNotServing"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getSetNotServingMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static XdsUpdateHealthServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceStub>() {
+        @java.lang.Override
+        public XdsUpdateHealthServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateHealthServiceStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateHealthServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static XdsUpdateHealthServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public XdsUpdateHealthServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateHealthServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return XdsUpdateHealthServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static XdsUpdateHealthServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceBlockingStub>() {
+        @java.lang.Override
+        public XdsUpdateHealthServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateHealthServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateHealthServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static XdsUpdateHealthServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceFutureStub>() {
+        @java.lang.Override
+        public XdsUpdateHealthServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateHealthServiceFutureStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateHealthServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     */
+    default void setServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetServingMethod(), responseObserver);
+    }
+
+    /**
+     */
+    default void setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetNotServingMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static abstract class XdsUpdateHealthServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return XdsUpdateHealthServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static final class XdsUpdateHealthServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<XdsUpdateHealthServiceStub> {
+    private XdsUpdateHealthServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateHealthServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateHealthServiceStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public void setServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getSetServingMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     */
+    public void setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getSetNotServingMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static final class XdsUpdateHealthServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateHealthServiceBlockingV2Stub> {
+    private XdsUpdateHealthServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateHealthServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateHealthServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty setServing(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getSetServingMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getSetNotServingMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static final class XdsUpdateHealthServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateHealthServiceBlockingStub> {
+    private XdsUpdateHealthServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateHealthServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateHealthServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty setServing(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getSetServingMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getSetNotServingMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static final class XdsUpdateHealthServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<XdsUpdateHealthServiceFutureStub> {
+    private XdsUpdateHealthServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateHealthServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateHealthServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> setServing(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getSetServingMethod(), getCallOptions()), request);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> setNotServing(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getSetNotServingMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_SET_SERVING = 0;
+  private static final int METHODID_SET_NOT_SERVING = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_SET_SERVING:
+          serviceImpl.setServing((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        case METHODID_SET_NOT_SERVING:
+          serviceImpl.setNotServing((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getSetServingMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_SET_SERVING)))
+        .addMethod(
+          getSetNotServingMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_SET_NOT_SERVING)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (XdsUpdateHealthServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getSetServingMethod())
+              .addMethod(getSetNotServingMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java
new file mode 100644
index 00000000000..33b914bb4b3
--- /dev/null
+++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java
@@ -0,0 +1,423 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A service used to obtain stats for verifying LB behavior.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class LoadBalancerStatsServiceGrpc {
+
+  private LoadBalancerStatsServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.LoadBalancerStatsService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerStatsRequest,
+      io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> getGetClientStatsMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetClientStats",
+      requestType = io.grpc.testing.integration.Messages.LoadBalancerStatsRequest.class,
+      responseType = io.grpc.testing.integration.Messages.LoadBalancerStatsResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerStatsRequest,
+      io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> getGetClientStatsMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerStatsRequest, io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> getGetClientStatsMethod;
+    if ((getGetClientStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientStatsMethod) == null) {
+      synchronized (LoadBalancerStatsServiceGrpc.class) {
+        if ((getGetClientStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientStatsMethod) == null) {
+          LoadBalancerStatsServiceGrpc.getGetClientStatsMethod = getGetClientStatsMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.LoadBalancerStatsRequest, io.grpc.testing.integration.Messages.LoadBalancerStatsResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetClientStats"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.LoadBalancerStatsRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.LoadBalancerStatsResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getGetClientStatsMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest,
+      io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> getGetClientAccumulatedStatsMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetClientAccumulatedStats",
+      requestType = io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest.class,
+      responseType = io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest,
+      io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> getGetClientAccumulatedStatsMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest, io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> getGetClientAccumulatedStatsMethod;
+    if ((getGetClientAccumulatedStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientAccumulatedStatsMethod) == null) {
+      synchronized (LoadBalancerStatsServiceGrpc.class) {
+        if ((getGetClientAccumulatedStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientAccumulatedStatsMethod) == null) {
+          LoadBalancerStatsServiceGrpc.getGetClientAccumulatedStatsMethod = getGetClientAccumulatedStatsMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest, io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetClientAccumulatedStats"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getGetClientAccumulatedStatsMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceStub>() {
+        @java.lang.Override
+        public LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerStatsServiceStub(channel, callOptions);
+        }
+      };
+    return LoadBalancerStatsServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static LoadBalancerStatsServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public LoadBalancerStatsServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerStatsServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return LoadBalancerStatsServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static LoadBalancerStatsServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceBlockingStub>() {
+        @java.lang.Override
+        public LoadBalancerStatsServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerStatsServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return LoadBalancerStatsServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static LoadBalancerStatsServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceFutureStub>() {
+        @java.lang.Override
+        public LoadBalancerStatsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerStatsServiceFutureStub(channel, callOptions);
+        }
+      };
+    return LoadBalancerStatsServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    default void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetClientStatsMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    default void getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetClientAccumulatedStatsMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static abstract class LoadBalancerStatsServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return LoadBalancerStatsServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static final class LoadBalancerStatsServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<LoadBalancerStatsServiceStub> {
+    private LoadBalancerStatsServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerStatsServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerStatsServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetClientStatsMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    public void getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetClientAccumulatedStatsMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static final class LoadBalancerStatsServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<LoadBalancerStatsServiceBlockingV2Stub> {
+    private LoadBalancerStatsServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerStatsServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerStatsServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.LoadBalancerStatsResponse getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetClientStatsMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetClientAccumulatedStatsMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static final class LoadBalancerStatsServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<LoadBalancerStatsServiceBlockingStub> {
+    private LoadBalancerStatsServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerStatsServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerStatsServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.LoadBalancerStatsResponse getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetClientStatsMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetClientAccumulatedStatsMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static final class LoadBalancerStatsServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<LoadBalancerStatsServiceFutureStub> {
+    private LoadBalancerStatsServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerStatsServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerStatsServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> getClientStats(
+        io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetClientStatsMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> getClientAccumulatedStats(
+        io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetClientAccumulatedStatsMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_GET_CLIENT_STATS = 0;
+  private static final int METHODID_GET_CLIENT_ACCUMULATED_STATS = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_GET_CLIENT_STATS:
+          serviceImpl.getClientStats((io.grpc.testing.integration.Messages.LoadBalancerStatsRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerStatsResponse>) responseObserver);
+          break;
+        case METHODID_GET_CLIENT_ACCUMULATED_STATS:
+          serviceImpl.getClientAccumulatedStats((io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getGetClientStatsMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.LoadBalancerStatsRequest,
+              io.grpc.testing.integration.Messages.LoadBalancerStatsResponse>(
+                service, METHODID_GET_CLIENT_STATS)))
+        .addMethod(
+          getGetClientAccumulatedStatsMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest,
+              io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse>(
+                service, METHODID_GET_CLIENT_ACCUMULATED_STATS)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (LoadBalancerStatsServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getGetClientStatsMethod())
+              .addMethod(getGetClientAccumulatedStatsMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java
new file mode 100644
index 00000000000..c99abcff7cb
--- /dev/null
+++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java
@@ -0,0 +1,398 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class MetricsServiceGrpc {
+
+  private MetricsServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.MetricsService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.EmptyMessage,
+      io.grpc.testing.integration.Metrics.GaugeResponse> getGetAllGaugesMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetAllGauges",
+      requestType = io.grpc.testing.integration.Metrics.EmptyMessage.class,
+      responseType = io.grpc.testing.integration.Metrics.GaugeResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.EmptyMessage,
+      io.grpc.testing.integration.Metrics.GaugeResponse> getGetAllGaugesMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.EmptyMessage, io.grpc.testing.integration.Metrics.GaugeResponse> getGetAllGaugesMethod;
+    if ((getGetAllGaugesMethod = MetricsServiceGrpc.getGetAllGaugesMethod) == null) {
+      synchronized (MetricsServiceGrpc.class) {
+        if ((getGetAllGaugesMethod = MetricsServiceGrpc.getGetAllGaugesMethod) == null) {
+          MetricsServiceGrpc.getGetAllGaugesMethod = getGetAllGaugesMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Metrics.EmptyMessage, io.grpc.testing.integration.Metrics.GaugeResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetAllGauges"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Metrics.EmptyMessage.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getGetAllGaugesMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.GaugeRequest,
+      io.grpc.testing.integration.Metrics.GaugeResponse> getGetGaugeMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetGauge",
+      requestType = io.grpc.testing.integration.Metrics.GaugeRequest.class,
+      responseType = io.grpc.testing.integration.Metrics.GaugeResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.GaugeRequest,
+      io.grpc.testing.integration.Metrics.GaugeResponse> getGetGaugeMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.GaugeRequest, io.grpc.testing.integration.Metrics.GaugeResponse> getGetGaugeMethod;
+    if ((getGetGaugeMethod = MetricsServiceGrpc.getGetGaugeMethod) == null) {
+      synchronized (MetricsServiceGrpc.class) {
+        if ((getGetGaugeMethod = MetricsServiceGrpc.getGetGaugeMethod) == null) {
+          MetricsServiceGrpc.getGetGaugeMethod = getGetGaugeMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Metrics.GaugeRequest, io.grpc.testing.integration.Metrics.GaugeResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetGauge"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Metrics.GaugeRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getGetGaugeMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static MetricsServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<MetricsServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<MetricsServiceStub>() {
+        @java.lang.Override
+        public MetricsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new MetricsServiceStub(channel, callOptions);
+        }
+      };
+    return MetricsServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static MetricsServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<MetricsServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<MetricsServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public MetricsServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new MetricsServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return MetricsServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static MetricsServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<MetricsServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<MetricsServiceBlockingStub>() {
+        @java.lang.Override
+        public MetricsServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new MetricsServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return MetricsServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static MetricsServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<MetricsServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<MetricsServiceFutureStub>() {
+        @java.lang.Override
+        public MetricsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new MetricsServiceFutureStub(channel, callOptions);
+        }
+      };
+    return MetricsServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     * </pre>
+     */
+    default void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetAllGaugesMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    default void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetGaugeMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service MetricsService.
+   */
+  public static abstract class MetricsServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return MetricsServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service MetricsService.
+   */
+  public static final class MetricsServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<MetricsServiceStub> {
+    private MetricsServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected MetricsServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new MetricsServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     * </pre>
+     */
+    public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getGetAllGaugesMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetGaugeMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service MetricsService.
+   */
+  public static final class MetricsServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<MetricsServiceBlockingV2Stub> {
+    private MetricsServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected MetricsServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new MetricsServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<?, io.grpc.testing.integration.Metrics.GaugeResponse>
+        getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request) {
+      return io.grpc.stub.ClientCalls.blockingV2ServerStreamingCall(
+          getChannel(), getGetAllGaugesMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetGaugeMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service MetricsService.
+   */
+  public static final class MetricsServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<MetricsServiceBlockingStub> {
+    private MetricsServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected MetricsServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new MetricsServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     * </pre>
+     */
+    public java.util.Iterator<io.grpc.testing.integration.Metrics.GaugeResponse> getAllGauges(
+        io.grpc.testing.integration.Metrics.EmptyMessage request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getGetAllGaugesMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetGaugeMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service MetricsService.
+   */
+  public static final class MetricsServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<MetricsServiceFutureStub> {
+    private MetricsServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected MetricsServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new MetricsServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Metrics.GaugeResponse> getGauge(
+        io.grpc.testing.integration.Metrics.GaugeRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetGaugeMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_GET_ALL_GAUGES = 0;
+  private static final int METHODID_GET_GAUGE = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_GET_ALL_GAUGES:
+          serviceImpl.getAllGauges((io.grpc.testing.integration.Metrics.EmptyMessage) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse>) responseObserver);
+          break;
+        case METHODID_GET_GAUGE:
+          serviceImpl.getGauge((io.grpc.testing.integration.Metrics.GaugeRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getGetAllGaugesMethod(),
+          io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Metrics.EmptyMessage,
+              io.grpc.testing.integration.Metrics.GaugeResponse>(
+                service, METHODID_GET_ALL_GAUGES)))
+        .addMethod(
+          getGetGaugeMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Metrics.GaugeRequest,
+              io.grpc.testing.integration.Metrics.GaugeResponse>(
+                service, METHODID_GET_GAUGE)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (MetricsServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getGetAllGaugesMethod())
+              .addMethod(getGetGaugeMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java
new file mode 100644
index 00000000000..fffcaad2df2
--- /dev/null
+++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java
@@ -0,0 +1,393 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A service used to control reconnect server.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class ReconnectServiceGrpc {
+
+  private ReconnectServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.ReconnectService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ReconnectParams,
+      io.grpc.testing.integration.EmptyProtos.Empty> getStartMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Start",
+      requestType = io.grpc.testing.integration.Messages.ReconnectParams.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ReconnectParams,
+      io.grpc.testing.integration.EmptyProtos.Empty> getStartMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ReconnectParams, io.grpc.testing.integration.EmptyProtos.Empty> getStartMethod;
+    if ((getStartMethod = ReconnectServiceGrpc.getStartMethod) == null) {
+      synchronized (ReconnectServiceGrpc.class) {
+        if ((getStartMethod = ReconnectServiceGrpc.getStartMethod) == null) {
+          ReconnectServiceGrpc.getStartMethod = getStartMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.ReconnectParams, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Start"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.ReconnectParams.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getStartMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.Messages.ReconnectInfo> getStopMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Stop",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.Messages.ReconnectInfo.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.Messages.ReconnectInfo> getStopMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.Messages.ReconnectInfo> getStopMethod;
+    if ((getStopMethod = ReconnectServiceGrpc.getStopMethod) == null) {
+      synchronized (ReconnectServiceGrpc.class) {
+        if ((getStopMethod = ReconnectServiceGrpc.getStopMethod) == null) {
+          ReconnectServiceGrpc.getStopMethod = getStopMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.Messages.ReconnectInfo>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Stop"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.ReconnectInfo.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getStopMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static ReconnectServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceStub>() {
+        @java.lang.Override
+        public ReconnectServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReconnectServiceStub(channel, callOptions);
+        }
+      };
+    return ReconnectServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static ReconnectServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public ReconnectServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReconnectServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return ReconnectServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static ReconnectServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceBlockingStub>() {
+        @java.lang.Override
+        public ReconnectServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReconnectServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return ReconnectServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static ReconnectServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceFutureStub>() {
+        @java.lang.Override
+        public ReconnectServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReconnectServiceFutureStub(channel, callOptions);
+        }
+      };
+    return ReconnectServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     */
+    default void start(io.grpc.testing.integration.Messages.ReconnectParams request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStartMethod(), responseObserver);
+    }
+
+    /**
+     */
+    default void stop(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ReconnectInfo> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStopMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static abstract class ReconnectServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return ReconnectServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static final class ReconnectServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<ReconnectServiceStub> {
+    private ReconnectServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReconnectServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReconnectServiceStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public void start(io.grpc.testing.integration.Messages.ReconnectParams request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getStartMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     */
+    public void stop(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ReconnectInfo> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getStopMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static final class ReconnectServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<ReconnectServiceBlockingV2Stub> {
+    private ReconnectServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReconnectServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReconnectServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty start(io.grpc.testing.integration.Messages.ReconnectParams request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getStartMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.Messages.ReconnectInfo stop(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getStopMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static final class ReconnectServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<ReconnectServiceBlockingStub> {
+    private ReconnectServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReconnectServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReconnectServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty start(io.grpc.testing.integration.Messages.ReconnectParams request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getStartMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.Messages.ReconnectInfo stop(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getStopMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static final class ReconnectServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ReconnectServiceFutureStub> {
+    private ReconnectServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReconnectServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReconnectServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> start(
+        io.grpc.testing.integration.Messages.ReconnectParams request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getStartMethod(), getCallOptions()), request);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.ReconnectInfo> stop(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getStopMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_START = 0;
+  private static final int METHODID_STOP = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_START:
+          serviceImpl.start((io.grpc.testing.integration.Messages.ReconnectParams) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        case METHODID_STOP:
+          serviceImpl.stop((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ReconnectInfo>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getStartMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.ReconnectParams,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_START)))
+        .addMethod(
+          getStopMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.Messages.ReconnectInfo>(
+                service, METHODID_STOP)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (ReconnectServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getStartMethod())
+              .addMethod(getStopMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/TestServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/TestServiceGrpc.java
new file mode 100644
index 00000000000..1d7805e3a3f
--- /dev/null
+++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/TestServiceGrpc.java
@@ -0,0 +1,969 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A simple service to test the various types of RPCs and experiment with
+ * performance with various types of payload.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class TestServiceGrpc {
+
+  private TestServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.TestService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getEmptyCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "EmptyCall",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getEmptyCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getEmptyCallMethod;
+    if ((getEmptyCallMethod = TestServiceGrpc.getEmptyCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getEmptyCallMethod = TestServiceGrpc.getEmptyCallMethod) == null) {
+          TestServiceGrpc.getEmptyCallMethod = getEmptyCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "EmptyCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getEmptyCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest,
+      io.grpc.testing.integration.Messages.SimpleResponse> getUnaryCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UnaryCall",
+      requestType = io.grpc.testing.integration.Messages.SimpleRequest.class,
+      responseType = io.grpc.testing.integration.Messages.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest,
+      io.grpc.testing.integration.Messages.SimpleResponse> getUnaryCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest, io.grpc.testing.integration.Messages.SimpleResponse> getUnaryCallMethod;
+    if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) {
+          TestServiceGrpc.getUnaryCallMethod = getUnaryCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.SimpleRequest, io.grpc.testing.integration.Messages.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnaryCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.SimpleResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getUnaryCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest,
+      io.grpc.testing.integration.Messages.SimpleResponse> getCacheableUnaryCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "CacheableUnaryCall",
+      requestType = io.grpc.testing.integration.Messages.SimpleRequest.class,
+      responseType = io.grpc.testing.integration.Messages.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest,
+      io.grpc.testing.integration.Messages.SimpleResponse> getCacheableUnaryCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest, io.grpc.testing.integration.Messages.SimpleResponse> getCacheableUnaryCallMethod;
+    if ((getCacheableUnaryCallMethod = TestServiceGrpc.getCacheableUnaryCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getCacheableUnaryCallMethod = TestServiceGrpc.getCacheableUnaryCallMethod) == null) {
+          TestServiceGrpc.getCacheableUnaryCallMethod = getCacheableUnaryCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.SimpleRequest, io.grpc.testing.integration.Messages.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CacheableUnaryCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.SimpleResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getCacheableUnaryCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getStreamingOutputCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingOutputCall",
+      requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getStreamingOutputCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getStreamingOutputCallMethod;
+    if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) {
+          TestServiceGrpc.getStreamingOutputCallMethod = getStreamingOutputCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingOutputCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getStreamingOutputCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingInputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingInputCallResponse> getStreamingInputCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingInputCall",
+      requestType = io.grpc.testing.integration.Messages.StreamingInputCallRequest.class,
+      responseType = io.grpc.testing.integration.Messages.StreamingInputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingInputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingInputCallResponse> getStreamingInputCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingInputCallRequest, io.grpc.testing.integration.Messages.StreamingInputCallResponse> getStreamingInputCallMethod;
+    if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) {
+          TestServiceGrpc.getStreamingInputCallMethod = getStreamingInputCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.StreamingInputCallRequest, io.grpc.testing.integration.Messages.StreamingInputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingInputCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingInputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingInputCallResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getStreamingInputCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getFullDuplexCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "FullDuplexCall",
+      requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getFullDuplexCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getFullDuplexCallMethod;
+    if ((getFullDuplexCallMethod = TestServiceGrpc.getFullDuplexCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getFullDuplexCallMethod = TestServiceGrpc.getFullDuplexCallMethod) == null) {
+          TestServiceGrpc.getFullDuplexCallMethod = getFullDuplexCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FullDuplexCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getFullDuplexCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getHalfDuplexCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "HalfDuplexCall",
+      requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getHalfDuplexCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getHalfDuplexCallMethod;
+    if ((getHalfDuplexCallMethod = TestServiceGrpc.getHalfDuplexCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getHalfDuplexCallMethod = TestServiceGrpc.getHalfDuplexCallMethod) == null) {
+          TestServiceGrpc.getHalfDuplexCallMethod = getHalfDuplexCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "HalfDuplexCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getHalfDuplexCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UnimplementedCall",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod;
+    if ((getUnimplementedCallMethod = TestServiceGrpc.getUnimplementedCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getUnimplementedCallMethod = TestServiceGrpc.getUnimplementedCallMethod) == null) {
+          TestServiceGrpc.getUnimplementedCallMethod = getUnimplementedCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnimplementedCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getUnimplementedCallMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static TestServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceStub>() {
+        @java.lang.Override
+        public TestServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceStub(channel, callOptions);
+        }
+      };
+    return TestServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static TestServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public TestServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return TestServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static TestServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingStub>() {
+        @java.lang.Override
+        public TestServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return TestServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static TestServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceFutureStub>() {
+        @java.lang.Override
+        public TestServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceFutureStub(channel, callOptions);
+        }
+      };
+    return TestServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    default void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getEmptyCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    default void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnaryCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    default void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCacheableUnaryCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    default void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStreamingOutputCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallRequest> streamingInputCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamingInputCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full duplexing.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> fullDuplexCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getFullDuplexCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> halfDuplexCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getHalfDuplexCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    default void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnimplementedCallMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static abstract class TestServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return TestServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static final class TestServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestServiceStub> {
+    private TestServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    public void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getEmptyCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    public void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getCacheableUnaryCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getStreamingOutputCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallRequest> streamingInputCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncClientStreamingCall(
+          getChannel().newCall(getStreamingInputCallMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full duplexing.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> fullDuplexCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getFullDuplexCallMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> halfDuplexCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getHalfDuplexCallMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static final class TestServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingV2Stub> {
+    private TestServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getEmptyCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.SimpleResponse unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.SimpleResponse cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getCacheableUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<?, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>
+        streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request) {
+      return io.grpc.stub.ClientCalls.blockingV2ServerStreamingCall(
+          getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.integration.Messages.StreamingInputCallRequest, io.grpc.testing.integration.Messages.StreamingInputCallResponse>
+        streamingInputCall() {
+      return io.grpc.stub.ClientCalls.blockingClientStreamingCall(
+          getChannel(), getStreamingInputCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full duplexing.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>
+        fullDuplexCall() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getFullDuplexCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>
+        halfDuplexCall() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getHalfDuplexCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static final class TestServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingStub> {
+    private TestServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getEmptyCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.SimpleResponse unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.SimpleResponse cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getCacheableUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    public java.util.Iterator<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> streamingOutputCall(
+        io.grpc.testing.integration.Messages.StreamingOutputCallRequest request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static final class TestServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestServiceFutureStub> {
+    private TestServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> emptyCall(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getEmptyCallMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.SimpleResponse> unaryCall(
+        io.grpc.testing.integration.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.SimpleResponse> cacheableUnaryCall(
+        io.grpc.testing.integration.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getCacheableUnaryCallMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> unimplementedCall(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_EMPTY_CALL = 0;
+  private static final int METHODID_UNARY_CALL = 1;
+  private static final int METHODID_CACHEABLE_UNARY_CALL = 2;
+  private static final int METHODID_STREAMING_OUTPUT_CALL = 3;
+  private static final int METHODID_UNIMPLEMENTED_CALL = 4;
+  private static final int METHODID_STREAMING_INPUT_CALL = 5;
+  private static final int METHODID_FULL_DUPLEX_CALL = 6;
+  private static final int METHODID_HALF_DUPLEX_CALL = 7;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_EMPTY_CALL:
+          serviceImpl.emptyCall((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        case METHODID_UNARY_CALL:
+          serviceImpl.unaryCall((io.grpc.testing.integration.Messages.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse>) responseObserver);
+          break;
+        case METHODID_CACHEABLE_UNARY_CALL:
+          serviceImpl.cacheableUnaryCall((io.grpc.testing.integration.Messages.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse>) responseObserver);
+          break;
+        case METHODID_STREAMING_OUTPUT_CALL:
+          serviceImpl.streamingOutputCall((io.grpc.testing.integration.Messages.StreamingOutputCallRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse>) responseObserver);
+          break;
+        case METHODID_UNIMPLEMENTED_CALL:
+          serviceImpl.unimplementedCall((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_STREAMING_INPUT_CALL:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamingInputCall(
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallResponse>) responseObserver);
+        case METHODID_FULL_DUPLEX_CALL:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.fullDuplexCall(
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse>) responseObserver);
+        case METHODID_HALF_DUPLEX_CALL:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.halfDuplexCall(
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse>) responseObserver);
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getEmptyCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_EMPTY_CALL)))
+        .addMethod(
+          getUnaryCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.SimpleRequest,
+              io.grpc.testing.integration.Messages.SimpleResponse>(
+                service, METHODID_UNARY_CALL)))
+        .addMethod(
+          getCacheableUnaryCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.SimpleRequest,
+              io.grpc.testing.integration.Messages.SimpleResponse>(
+                service, METHODID_CACHEABLE_UNARY_CALL)))
+        .addMethod(
+          getStreamingOutputCallMethod(),
+          io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+              io.grpc.testing.integration.Messages.StreamingOutputCallResponse>(
+                service, METHODID_STREAMING_OUTPUT_CALL)))
+        .addMethod(
+          getStreamingInputCallMethod(),
+          io.grpc.stub.ServerCalls.asyncClientStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.StreamingInputCallRequest,
+              io.grpc.testing.integration.Messages.StreamingInputCallResponse>(
+                service, METHODID_STREAMING_INPUT_CALL)))
+        .addMethod(
+          getFullDuplexCallMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+              io.grpc.testing.integration.Messages.StreamingOutputCallResponse>(
+                service, METHODID_FULL_DUPLEX_CALL)))
+        .addMethod(
+          getHalfDuplexCallMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+              io.grpc.testing.integration.Messages.StreamingOutputCallResponse>(
+                service, METHODID_HALF_DUPLEX_CALL)))
+        .addMethod(
+          getUnimplementedCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_UNIMPLEMENTED_CALL)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (TestServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getEmptyCallMethod())
+              .addMethod(getUnaryCallMethod())
+              .addMethod(getCacheableUnaryCallMethod())
+              .addMethod(getStreamingOutputCallMethod())
+              .addMethod(getStreamingInputCallMethod())
+              .addMethod(getFullDuplexCallMethod())
+              .addMethod(getHalfDuplexCallMethod())
+              .addMethod(getUnimplementedCallMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java
new file mode 100644
index 00000000000..bec9b5a723a
--- /dev/null
+++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java
@@ -0,0 +1,335 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A simple service NOT implemented at servers so clients can test for
+ * that case.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class UnimplementedServiceGrpc {
+
+  private UnimplementedServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.UnimplementedService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UnimplementedCall",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod;
+    if ((getUnimplementedCallMethod = UnimplementedServiceGrpc.getUnimplementedCallMethod) == null) {
+      synchronized (UnimplementedServiceGrpc.class) {
+        if ((getUnimplementedCallMethod = UnimplementedServiceGrpc.getUnimplementedCallMethod) == null) {
+          UnimplementedServiceGrpc.getUnimplementedCallMethod = getUnimplementedCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnimplementedCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getUnimplementedCallMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static UnimplementedServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceStub>() {
+        @java.lang.Override
+        public UnimplementedServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new UnimplementedServiceStub(channel, callOptions);
+        }
+      };
+    return UnimplementedServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static UnimplementedServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public UnimplementedServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new UnimplementedServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return UnimplementedServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static UnimplementedServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceBlockingStub>() {
+        @java.lang.Override
+        public UnimplementedServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new UnimplementedServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return UnimplementedServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static UnimplementedServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceFutureStub>() {
+        @java.lang.Override
+        public UnimplementedServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new UnimplementedServiceFutureStub(channel, callOptions);
+        }
+      };
+    return UnimplementedServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    default void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnimplementedCallMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static abstract class UnimplementedServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return UnimplementedServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static final class UnimplementedServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<UnimplementedServiceStub> {
+    private UnimplementedServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected UnimplementedServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new UnimplementedServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static final class UnimplementedServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<UnimplementedServiceBlockingV2Stub> {
+    private UnimplementedServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected UnimplementedServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new UnimplementedServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static final class UnimplementedServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<UnimplementedServiceBlockingStub> {
+    private UnimplementedServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected UnimplementedServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new UnimplementedServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static final class UnimplementedServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<UnimplementedServiceFutureStub> {
+    private UnimplementedServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected UnimplementedServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new UnimplementedServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> unimplementedCall(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_UNIMPLEMENTED_CALL = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_UNIMPLEMENTED_CALL:
+          serviceImpl.unimplementedCall((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getUnimplementedCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_UNIMPLEMENTED_CALL)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (UnimplementedServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getUnimplementedCallMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/XdsUpdateClientConfigureServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/XdsUpdateClientConfigureServiceGrpc.java
new file mode 100644
index 00000000000..3453b6c01be
--- /dev/null
+++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/XdsUpdateClientConfigureServiceGrpc.java
@@ -0,0 +1,328 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A service to dynamically update the configuration of an xDS test client.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class XdsUpdateClientConfigureServiceGrpc {
+
+  private XdsUpdateClientConfigureServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.XdsUpdateClientConfigureService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ClientConfigureRequest,
+      io.grpc.testing.integration.Messages.ClientConfigureResponse> getConfigureMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Configure",
+      requestType = io.grpc.testing.integration.Messages.ClientConfigureRequest.class,
+      responseType = io.grpc.testing.integration.Messages.ClientConfigureResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ClientConfigureRequest,
+      io.grpc.testing.integration.Messages.ClientConfigureResponse> getConfigureMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ClientConfigureRequest, io.grpc.testing.integration.Messages.ClientConfigureResponse> getConfigureMethod;
+    if ((getConfigureMethod = XdsUpdateClientConfigureServiceGrpc.getConfigureMethod) == null) {
+      synchronized (XdsUpdateClientConfigureServiceGrpc.class) {
+        if ((getConfigureMethod = XdsUpdateClientConfigureServiceGrpc.getConfigureMethod) == null) {
+          XdsUpdateClientConfigureServiceGrpc.getConfigureMethod = getConfigureMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.ClientConfigureRequest, io.grpc.testing.integration.Messages.ClientConfigureResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Configure"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.ClientConfigureRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.Messages.ClientConfigureResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getConfigureMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static XdsUpdateClientConfigureServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceStub>() {
+        @java.lang.Override
+        public XdsUpdateClientConfigureServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateClientConfigureServiceStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateClientConfigureServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static XdsUpdateClientConfigureServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public XdsUpdateClientConfigureServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateClientConfigureServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return XdsUpdateClientConfigureServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static XdsUpdateClientConfigureServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceBlockingStub>() {
+        @java.lang.Override
+        public XdsUpdateClientConfigureServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateClientConfigureServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateClientConfigureServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static XdsUpdateClientConfigureServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceFutureStub>() {
+        @java.lang.Override
+        public XdsUpdateClientConfigureServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateClientConfigureServiceFutureStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateClientConfigureServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    default void configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ClientConfigureResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getConfigureMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static abstract class XdsUpdateClientConfigureServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return XdsUpdateClientConfigureServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static final class XdsUpdateClientConfigureServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<XdsUpdateClientConfigureServiceStub> {
+    private XdsUpdateClientConfigureServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateClientConfigureServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateClientConfigureServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    public void configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ClientConfigureResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getConfigureMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static final class XdsUpdateClientConfigureServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateClientConfigureServiceBlockingV2Stub> {
+    private XdsUpdateClientConfigureServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateClientConfigureServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateClientConfigureServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.ClientConfigureResponse configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getConfigureMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static final class XdsUpdateClientConfigureServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateClientConfigureServiceBlockingStub> {
+    private XdsUpdateClientConfigureServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateClientConfigureServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateClientConfigureServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.ClientConfigureResponse configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getConfigureMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static final class XdsUpdateClientConfigureServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<XdsUpdateClientConfigureServiceFutureStub> {
+    private XdsUpdateClientConfigureServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateClientConfigureServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateClientConfigureServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.ClientConfigureResponse> configure(
+        io.grpc.testing.integration.Messages.ClientConfigureRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getConfigureMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_CONFIGURE = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_CONFIGURE:
+          serviceImpl.configure((io.grpc.testing.integration.Messages.ClientConfigureRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ClientConfigureResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getConfigureMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.ClientConfigureRequest,
+              io.grpc.testing.integration.Messages.ClientConfigureResponse>(
+                service, METHODID_CONFIGURE)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (XdsUpdateClientConfigureServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getConfigureMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/XdsUpdateHealthServiceGrpc.java b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/XdsUpdateHealthServiceGrpc.java
new file mode 100644
index 00000000000..fb5f2cdebc7
--- /dev/null
+++ b/android-interop-testing/src/generated/release/grpc/io/grpc/testing/integration/XdsUpdateHealthServiceGrpc.java
@@ -0,0 +1,393 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A service to remotely control health status of an xDS test server.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class XdsUpdateHealthServiceGrpc {
+
+  private XdsUpdateHealthServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.XdsUpdateHealthService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getSetServingMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "SetServing",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getSetServingMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getSetServingMethod;
+    if ((getSetServingMethod = XdsUpdateHealthServiceGrpc.getSetServingMethod) == null) {
+      synchronized (XdsUpdateHealthServiceGrpc.class) {
+        if ((getSetServingMethod = XdsUpdateHealthServiceGrpc.getSetServingMethod) == null) {
+          XdsUpdateHealthServiceGrpc.getSetServingMethod = getSetServingMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetServing"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getSetServingMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getSetNotServingMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "SetNotServing",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getSetNotServingMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getSetNotServingMethod;
+    if ((getSetNotServingMethod = XdsUpdateHealthServiceGrpc.getSetNotServingMethod) == null) {
+      synchronized (XdsUpdateHealthServiceGrpc.class) {
+        if ((getSetNotServingMethod = XdsUpdateHealthServiceGrpc.getSetNotServingMethod) == null) {
+          XdsUpdateHealthServiceGrpc.getSetNotServingMethod = getSetNotServingMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetNotServing"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getSetNotServingMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static XdsUpdateHealthServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceStub>() {
+        @java.lang.Override
+        public XdsUpdateHealthServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateHealthServiceStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateHealthServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static XdsUpdateHealthServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public XdsUpdateHealthServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateHealthServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return XdsUpdateHealthServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static XdsUpdateHealthServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceBlockingStub>() {
+        @java.lang.Override
+        public XdsUpdateHealthServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateHealthServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateHealthServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static XdsUpdateHealthServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceFutureStub>() {
+        @java.lang.Override
+        public XdsUpdateHealthServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateHealthServiceFutureStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateHealthServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     */
+    default void setServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetServingMethod(), responseObserver);
+    }
+
+    /**
+     */
+    default void setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetNotServingMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static abstract class XdsUpdateHealthServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return XdsUpdateHealthServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static final class XdsUpdateHealthServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<XdsUpdateHealthServiceStub> {
+    private XdsUpdateHealthServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateHealthServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateHealthServiceStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public void setServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getSetServingMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     */
+    public void setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getSetNotServingMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static final class XdsUpdateHealthServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateHealthServiceBlockingV2Stub> {
+    private XdsUpdateHealthServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateHealthServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateHealthServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty setServing(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getSetServingMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getSetNotServingMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static final class XdsUpdateHealthServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateHealthServiceBlockingStub> {
+    private XdsUpdateHealthServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateHealthServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateHealthServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty setServing(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getSetServingMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getSetNotServingMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static final class XdsUpdateHealthServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<XdsUpdateHealthServiceFutureStub> {
+    private XdsUpdateHealthServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateHealthServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateHealthServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> setServing(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getSetServingMethod(), getCallOptions()), request);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> setNotServing(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getSetNotServingMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_SET_SERVING = 0;
+  private static final int METHODID_SET_NOT_SERVING = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_SET_SERVING:
+          serviceImpl.setServing((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        case METHODID_SET_NOT_SERVING:
+          serviceImpl.setNotServing((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getSetServingMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_SET_SERVING)))
+        .addMethod(
+          getSetNotServingMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_SET_NOT_SERVING)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (XdsUpdateHealthServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getSetServingMethod())
+              .addMethod(getSetNotServingMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/android-interop-testing/src/main/AndroidManifest.xml b/android-interop-testing/src/main/AndroidManifest.xml
new file mode 100644
index 00000000000..da7ccef5b1d
--- /dev/null
+++ b/android-interop-testing/src/main/AndroidManifest.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <!-- For UDS -->
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+    <uses-permission
+        android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+        android:maxSdkVersion="28" />
+    <uses-sdk tools:overrideLibrary="io.grpc.android"/>
+
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:theme="@style/Base.V7.Theme.AppCompat.Light"
+        android:name="androidx.multidex.MultiDexApplication">
+        <activity
+            android:name=".TesterActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+        <!-- To support tests under binder, which need Android services -->
+        <service android:name="io.grpc.binder.HostServices$HostService1"/>
+        <service android:name="io.grpc.binder.HostServices$HostService2"/>
+    </application>
+
+</manifest>
diff --git a/android-interop-testing/src/main/java/io/grpc/android/integrationtest/TestCallable.java b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/TestCallable.java
new file mode 100644
index 00000000000..56ea75bb657
--- /dev/null
+++ b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/TestCallable.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright 2023 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.android.integrationtest;
+
+import android.util.Log;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.testing.integration.AbstractInteropTest;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.concurrent.Callable;
+import org.junit.AssumptionViolatedException;
+
+/**
+ * Used to run a single test case against a channel in a separate thread.
+ */
+public class TestCallable implements Callable<String> {
+  private final ManagedChannel channel;
+  private final String testCase;
+
+  private static final String LOG_TAG = "GrpcInteropTask";
+  static final String SUCCESS_MESSAGE = "Success!";
+
+  public TestCallable(ManagedChannel channel, String testCase) {
+    this.channel = channel;
+    this.testCase = testCase;
+  }
+
+  @Override
+  public String call() {
+    Tester tester = new Tester(channel);
+    tester.setUp();
+    try {
+      runTest(tester, testCase);
+      return SUCCESS_MESSAGE;
+    } catch (Throwable t) {
+      // Print the stack trace to logcat.
+      t.printStackTrace();
+      // Then print to the error message.
+      StringWriter sw = new StringWriter();
+      t.printStackTrace(new PrintWriter(sw));
+      return "Failed... : " + t.getMessage() + "\n" + sw;
+    } finally {
+      try {
+        tester.tearDown();
+      } catch (RuntimeException ex) {
+        throw ex;
+      } catch (Exception ex) {
+        throw new RuntimeException(ex);
+      }
+    }
+  }
+
+  private void runTest(Tester tester, String testCase) throws Exception {
+    Log.i(LOG_TAG, "Running test case: " + testCase);
+    if ("empty_unary".equals(testCase)) {
+      tester.emptyUnary();
+    } else if ("large_unary".equals(testCase)) {
+      try {
+        tester.largeUnary();
+      } catch (AssumptionViolatedException e) {
+        // This test case requires more memory than most Android devices have available
+        Log.w(LOG_TAG, "Skipping " + testCase + " due to assumption violation", e);
+      }
+    } else if ("client_streaming".equals(testCase)) {
+      tester.clientStreaming();
+    } else if ("server_streaming".equals(testCase)) {
+      tester.serverStreaming();
+    } else if ("ping_pong".equals(testCase)) {
+      tester.pingPong();
+    } else if ("empty_stream".equals(testCase)) {
+      tester.emptyStream();
+    } else if ("cancel_after_begin".equals(testCase)) {
+      tester.cancelAfterBegin();
+    } else if ("cancel_after_first_response".equals(testCase)) {
+      tester.cancelAfterFirstResponse();
+    } else if ("full_duplex_call_should_succeed".equals(testCase)) {
+      tester.fullDuplexCallShouldSucceed();
+    } else if ("half_duplex_call_should_succeed".equals(testCase)) {
+      tester.halfDuplexCallShouldSucceed();
+    } else if ("server_streaming_should_be_flow_controlled".equals(testCase)) {
+      tester.serverStreamingShouldBeFlowControlled();
+    } else if ("very_large_request".equals(testCase)) {
+      try {
+        tester.veryLargeRequest();
+      } catch (AssumptionViolatedException e) {
+        // This test case requires more memory than most Android devices have available
+        Log.w(LOG_TAG, "Skipping " + testCase + " due to assumption violation", e);
+      }
+    } else if ("very_large_response".equals(testCase)) {
+      try {
+        tester.veryLargeResponse();
+      } catch (AssumptionViolatedException e) {
+        // This test case requires more memory than most Android devices have available
+        Log.w(LOG_TAG, "Skipping " + testCase + " due to assumption violation", e);
+      }
+    } else if ("deadline_not_exceeded".equals(testCase)) {
+      tester.deadlineNotExceeded();
+    } else if ("deadline_exceeded".equals(testCase)) {
+      tester.deadlineExceeded();
+    } else if ("deadline_exceeded_server_streaming".equals(testCase)) {
+      tester.deadlineExceededServerStreaming();
+    } else if ("unimplemented_method".equals(testCase)) {
+      tester.unimplementedMethod();
+    } else if ("timeout_on_sleeping_server".equals(testCase)) {
+      tester.timeoutOnSleepingServer();
+    } else if ("graceful_shutdown".equals(testCase)) {
+      tester.gracefulShutdown();
+    } else {
+      throw new IllegalArgumentException("Unimplemented/Unknown test case: " + testCase);
+    }
+  }
+
+  private static class Tester extends AbstractInteropTest {
+
+    private Tester(ManagedChannel channel) {
+      this.channel = channel;
+    }
+
+    @Override
+    protected ManagedChannel createChannel() {
+      return channel;
+    }
+
+    @Override
+    protected ManagedChannelBuilder<?> createChannelBuilder() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    protected boolean metricsExpected() {
+      return false;
+    }
+  }
+}
diff --git a/android-interop-testing/src/main/java/io/grpc/android/integrationtest/TesterActivity.java b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/TesterActivity.java
new file mode 100644
index 00000000000..17c7e24cbfa
--- /dev/null
+++ b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/TesterActivity.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright 2015 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.android.integrationtest;
+
+import android.content.Context;
+import android.content.Intent;
+import android.net.LocalSocketAddress.Namespace;
+import android.os.Bundle;
+import android.text.TextUtils;
+import android.util.Log;
+import android.view.View;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.Button;
+import android.widget.CheckBox;
+import android.widget.EditText;
+import android.widget.TextView;
+import androidx.appcompat.app.AppCompatActivity;
+import com.google.android.gms.security.ProviderInstaller;
+import io.grpc.ManagedChannel;
+import io.grpc.android.UdsChannelBuilder;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class TesterActivity extends AppCompatActivity
+    implements ProviderInstaller.ProviderInstallListener {
+  private static final String LOG_TAG = "GrpcTesterActivity";
+
+  private List<Button> buttons;
+  private EditText hostEdit;
+  private EditText portEdit;
+  private CheckBox useUdsCheckBox;
+  private EditText udsEdit;
+  private TextView resultText;
+  private CheckBox testCertCheckBox;
+
+  private UdsTcpEndpointConnector endpointConnector;
+
+  private ExecutorService executor;
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.activity_tester);
+    buttons = new ArrayList<>();
+    buttons.add((Button) findViewById(R.id.empty_unary_button));
+    buttons.add((Button) findViewById(R.id.large_unary_button));
+    buttons.add((Button) findViewById(R.id.client_streaming_button));
+    buttons.add((Button) findViewById(R.id.server_streaming_button));
+    buttons.add((Button) findViewById(R.id.ping_pong_button));
+
+    hostEdit = (EditText) findViewById(R.id.host_edit_text);
+    portEdit = (EditText) findViewById(R.id.port_edit_text);
+    useUdsCheckBox = (CheckBox) findViewById(R.id.use_uds_checkbox);
+    udsEdit = (EditText) findViewById(R.id.uds_proxy_edit_text);
+    resultText = (TextView) findViewById(R.id.grpc_response_text);
+    testCertCheckBox = (CheckBox) findViewById(R.id.test_cert_checkbox);
+
+    ProviderInstaller.installIfNeededAsync(this, this);
+    // Disable buttons until the security provider installing finishes.
+    enableButtons(false);
+
+    executor = Executors.newSingleThreadExecutor();
+  }
+
+  /** Click handler for unix domain socket. */
+  public void enableUds(View view) {
+    boolean enabled = ((CheckBox) view).isChecked();
+    udsEdit.setEnabled(enabled);
+    testCertCheckBox.setEnabled(!enabled);
+    if (enabled) {
+      testCertCheckBox.setChecked(false);
+    }
+  }
+
+  public void startEmptyUnary(View view) {
+    startTest("empty_unary");
+  }
+
+  public void startLargeUnary(View view) {
+    startTest("large_unary");
+  }
+
+  public void startClientStreaming(View view) {
+    startTest("client_streaming");
+  }
+
+  public void startServerStreaming(View view) {
+    startTest("server_streaming");
+  }
+
+  public void startPingPong(View view) {
+    startTest("ping_pong");
+  }
+
+  private void enableButtons(boolean enable) {
+    for (Button button : buttons) {
+      button.setEnabled(enable);
+    }
+  }
+
+  private void startTest(String testCase) {
+    ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(
+        hostEdit.getWindowToken(), 0);
+    enableButtons(false);
+    resultText.setText(R.string.testing_message);
+
+    String host = hostEdit.getText().toString();
+    String portStr = portEdit.getText().toString();
+    int port = TextUtils.isEmpty(portStr) ? 8080 : Integer.valueOf(portStr);
+    boolean udsEnabled = useUdsCheckBox.isChecked();
+    String udsPath =
+        TextUtils.isEmpty(udsEdit.getText()) ? "default" : udsEdit.getText().toString();
+
+    String serverHostOverride;
+    InputStream testCert;
+    if (testCertCheckBox.isChecked()) {
+      serverHostOverride = "foo.test.google.fr";
+      testCert = getResources().openRawResource(R.raw.ca);
+    } else {
+      serverHostOverride = null;
+      testCert = null;
+    }
+
+    // Create Channel
+    ManagedChannel channel;
+    if (udsEnabled) {
+      channel = UdsChannelBuilder.forPath(udsPath, Namespace.ABSTRACT).build();
+    } else {
+      channel = TesterOkHttpChannelBuilder.build(host, port, serverHostOverride, true, testCert);
+    }
+
+    // Port-forward uds local port to server exposing tcp endpoint.
+    if (udsEnabled) {
+      endpointConnector = new UdsTcpEndpointConnector(udsPath, host, port);
+      try {
+        endpointConnector.start();
+      } catch (IOException e) {
+        Log.e(LOG_TAG, "Failed to start UDS-TCP Endpoint Connector.");
+      }
+    }
+
+    // Start Test.
+    String result = null;
+    try {
+      result = executor.submit(new TestCallable(channel, testCase)).get();
+    } catch (ExecutionException | InterruptedException e) {
+      result = e.getMessage();
+    } finally {
+      if (endpointConnector != null) {
+        endpointConnector.shutDown();
+        endpointConnector = null;
+      }
+      resultText.setText(result);
+      enableButtons(true);
+    }
+  }
+
+  @Override
+  public void onProviderInstalled() {
+    // Provider is up-to-date, app can make secure network calls.
+    enableButtons(true);
+  }
+
+  @Override
+  public void onProviderInstallFailed(int errorCode, Intent recoveryIntent) {
+    // The provider is helpful, but it is possible to succeed without it.
+    // Hope that the system-provided libraries are new enough.
+    Log.w(LOG_TAG, "Failed installing security provider, error code: " + errorCode);
+    enableButtons(true);
+  }
+}
diff --git a/android-interop-testing/src/main/java/io/grpc/android/integrationtest/TesterOkHttpChannelBuilder.java b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/TesterOkHttpChannelBuilder.java
new file mode 100644
index 00000000000..a663378dbf3
--- /dev/null
+++ b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/TesterOkHttpChannelBuilder.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2016 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.android.integrationtest;
+
+import androidx.annotation.Nullable;
+import io.grpc.ChannelCredentials;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.okhttp.OkHttpChannelBuilder;
+import java.io.InputStream;
+
+/**
+ * A helper class to create a OkHttp based channel.
+ */
+class TesterOkHttpChannelBuilder {
+  public static ManagedChannel build(
+      String host,
+      int port,
+      @Nullable String serverHostOverride,
+      boolean useTls,
+      @Nullable InputStream testCa) {
+    ChannelCredentials credentials;
+    if (useTls) {
+      if (testCa == null) {
+        credentials = TlsChannelCredentials.create();
+      } else {
+        try {
+          credentials = TlsChannelCredentials.newBuilder().trustManager(testCa).build();
+        } catch (Exception e) {
+          throw new RuntimeException(e);
+        }
+      }
+    } else {
+      credentials = InsecureChannelCredentials.create();
+    }
+
+    ManagedChannelBuilder<?> channelBuilder = Grpc.newChannelBuilderForAddress(
+          host, port, credentials)
+        .maxInboundMessageSize(16 * 1024 * 1024);
+    if (!(channelBuilder instanceof OkHttpChannelBuilder)) {
+      throw new RuntimeException("Did not receive an OkHttpChannelBuilder");
+    }
+    if (serverHostOverride != null) {
+      // Force the hostname to match the cert the server uses.
+      channelBuilder.overrideAuthority(serverHostOverride);
+    }
+    return channelBuilder.build();
+  }
+}
diff --git a/android-interop-testing/src/main/java/io/grpc/android/integrationtest/UdsTcpEndpointConnector.java b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/UdsTcpEndpointConnector.java
new file mode 100644
index 00000000000..61c1f4f8dad
--- /dev/null
+++ b/android-interop-testing/src/main/java/io/grpc/android/integrationtest/UdsTcpEndpointConnector.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright 2021 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.android.integrationtest;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import android.net.LocalServerSocket;
+import android.net.LocalSocket;
+import android.util.Log;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Funnels traffic between a given UDS endpoint and a local TCP endpoint. A client binds to the UDS
+ * endpoint, but effectively communicates with the TCP endpoint.
+ */
+public class UdsTcpEndpointConnector {
+
+  private static final String LOG_TAG = "EndpointConnector";
+
+  // Discard-policy, to allow dropping tasks that were received immediately after shutDown()
+  private final ThreadPoolExecutor executor =
+      new ThreadPoolExecutor(
+          5,
+          10,
+          1,
+          SECONDS,
+          new LinkedBlockingQueue<>(),
+          new ThreadPoolExecutor.DiscardOldestPolicy());
+
+  private final String udsPath;
+
+  private final String host;
+  private final int port;
+  private InetSocketAddress socketAddress;
+
+  private LocalServerSocket clientAcceptor;
+
+  private volatile boolean shutDownRequested = false;
+  private volatile boolean shutDownComplete = false;
+
+  /** Listen on udsPath and forward connections to host:port. */
+  public UdsTcpEndpointConnector(String udsPath, String host, int port) {
+    this.udsPath = udsPath;
+    this.host = host;
+    this.port = port;
+  }
+
+  /** Start listening and accept connections. */
+  public void start() throws IOException {
+    clientAcceptor = new LocalServerSocket(udsPath);
+    executor.execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            Log.i(LOG_TAG, "Starting connection from " + udsPath + " to " + socketAddress);
+            socketAddress = new InetSocketAddress(host, port);
+            while (!shutDownRequested) {
+              try {
+                LocalSocket clientSocket = clientAcceptor.accept();
+                if (shutDownRequested) {
+                  // Check if shut down during blocking accept().
+                  clientSocket.close();
+                  shutDownComplete = true;
+                  break;
+                }
+                Socket serverSocket = new Socket();
+                serverSocket.connect(socketAddress);
+                startWorkers(clientSocket, serverSocket);
+              } catch (IOException e) {
+                throw new RuntimeException(e);
+              }
+            }
+          }
+        });
+  }
+
+  /** Stop listening and release resources. */
+  public void shutDown() {
+    Log.i(LOG_TAG, "Shutting down connection from " + udsPath + " to " + socketAddress);
+    shutDownRequested = true;
+
+    try {
+      // Upon clientAcceptor.close(), clientAcceptor.accept() continues to block.
+      // Thus, once shutDownRequested=true, must send a connection request to unblock accept().
+      LocalSocket localSocket = new LocalSocket();
+      localSocket.connect(clientAcceptor.getLocalSocketAddress());
+      localSocket.close();
+      clientAcceptor.close();
+    } catch (IOException e) {
+      Log.w(LOG_TAG, "Failed to close LocalServerSocket", e);
+    }
+    executor.shutdownNow();
+  }
+
+  public boolean isShutdown() {
+    return shutDownComplete && executor.isShutdown();
+  }
+
+  private void startWorkers(LocalSocket clientSocket, Socket serverSocket) throws IOException {
+    DataInputStream clientIn = new DataInputStream(clientSocket.getInputStream());
+    DataOutputStream clientOut = new DataOutputStream(serverSocket.getOutputStream());
+    DataInputStream serverIn = new DataInputStream(serverSocket.getInputStream());
+    DataOutputStream serverOut = new DataOutputStream(clientSocket.getOutputStream());
+
+    AtomicInteger completionCount = new AtomicInteger(0);
+    StreamConnector.Listener cleanupListener =
+        new StreamConnector.Listener() {
+          @Override
+          public void onFinished() {
+            if (completionCount.incrementAndGet() == 2) {
+              try {
+                serverSocket.close();
+                clientSocket.close();
+              } catch (IOException e) {
+                Log.e(LOG_TAG, "Failed to clean up connected sockets.", e);
+              }
+            }
+          }
+        };
+    executor.execute(new StreamConnector(clientIn, clientOut).addListener(cleanupListener));
+    executor.execute(new StreamConnector(serverIn, serverOut).addListener(cleanupListener));
+  }
+
+  /**
+   * Funnels everything that comes in to a DataInputStream into an DataOutputStream, until the
+   * DataInputStream is closed. (detected by IOException).
+   */
+  private static final class StreamConnector implements Runnable {
+
+    interface Listener {
+      void onFinished();
+    }
+
+    private static final int BUFFER_SIZE = 1000;
+
+    private final DataInputStream in;
+    private final DataOutputStream out;
+    private final byte[] buffer = new byte[BUFFER_SIZE];
+
+    private boolean finished = false;
+
+    private final Collection<Listener> listeners = new ArrayList<>();
+
+    StreamConnector(DataInputStream in, DataOutputStream out) {
+      this.in = in;
+      this.out = out;
+    }
+
+    StreamConnector addListener(Listener listener) {
+      listeners.add(listener);
+      return this;
+    }
+
+    @Override
+    public void run() {
+      while (!finished) {
+        int bytesRead;
+        try {
+          bytesRead = in.read(buffer);
+          if (bytesRead == -1) {
+            finished = true;
+            out.close();
+            continue;
+          }
+          out.write(buffer, 0, bytesRead);
+        } catch (IOException e) {
+          finished = true;
+        }
+      }
+      for (StreamConnector.Listener listener : listeners) {
+        listener.onFinished();
+      }
+    }
+  }
+}
diff --git a/android-interop-testing/src/main/res/color/focus.xml b/android-interop-testing/src/main/res/color/focus.xml
new file mode 100644
index 00000000000..ced80c19819
--- /dev/null
+++ b/android-interop-testing/src/main/res/color/focus.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+  <item android:color="#AAA" android:state_focused="false"/>
+  <item android:color="#000" android:state_focused="true"/>
+</selector>
\ No newline at end of file
diff --git a/android-interop-testing/src/main/res/layout/activity_tester.xml b/android-interop-testing/src/main/res/layout/activity_tester.xml
new file mode 100644
index 00000000000..042da6437c0
--- /dev/null
+++ b/android-interop-testing/src/main/res/layout/activity_tester.xml
@@ -0,0 +1,138 @@
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".MainActivity"
+    android:orientation="vertical"
+    >
+
+  <LinearLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:orientation="horizontal"
+      >
+    <EditText
+        android:id="@+id/host_edit_text"
+        android:layout_weight="2"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:inputType="text"
+        android:hint="Enter Host"
+        />
+    <EditText
+        android:id="@+id/port_edit_text"
+        android:layout_weight="1"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:inputType="numberDecimal"
+        android:hint="Enter Port"
+        />
+  </LinearLayout>
+
+  <LinearLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+    android:orientation="horizontal">
+    <CheckBox android:id="@+id/use_uds_checkbox"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:onClick="enableUds"
+        android:textColor="@color/focus"
+        android:text="Use UDS (SSL not supported)"
+        tools:ignore="OnClick"
+        />
+    <EditText
+        android:id="@+id/uds_proxy_edit_text"
+        android:layout_height="wrap_content"
+        android:layout_width="match_parent"
+        android:enabled="false"
+        android:inputType="text"
+        android:hint="Enter Unix Domain Socket Abstract Namespace Address"
+        />
+  </LinearLayout>
+
+  <LinearLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:orientation="horizontal"
+      >
+    <CheckBox android:id="@+id/test_cert_checkbox"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:textColor="@color/focus"
+        android:text="Use Test Cert"
+        />
+  </LinearLayout>
+
+  <Button
+      android:id="@+id/empty_unary_button"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:onClick="startEmptyUnary"
+      android:text="Empty Unary"
+      tools:ignore="OnClick"
+      />
+
+  <Button
+      android:id="@+id/large_unary_button"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:onClick="startLargeUnary"
+      android:text="Large Unary"
+      tools:ignore="OnClick"
+      />
+
+  <Button
+      android:id="@+id/client_streaming_button"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:onClick="startClientStreaming"
+      android:text="Client Streaming"
+      tools:ignore="OnClick"
+      />
+
+  <Button
+      android:id="@+id/server_streaming_button"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:onClick="startServerStreaming"
+      android:text="Server Streaming"
+      tools:ignore="OnClick"
+      />
+
+  <Button
+      android:id="@+id/ping_pong_button"
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:onClick="startPingPong"
+      android:text="Ping Pong"
+      tools:ignore="OnClick"
+      />
+
+  <TextView
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:paddingTop="12dp"
+      android:paddingBottom="12dp"
+      android:textSize="16sp"
+      android:text="Response:"
+      />
+
+  <ScrollView
+      android:id="@+id/result_area"
+      android:layout_width="fill_parent"
+      android:layout_height="wrap_content"
+      android:scrollbars="vertical"
+      android:fillViewport="true"
+      >
+
+    <TextView
+        android:id="@+id/grpc_response_text"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:textSize="16sp"
+        />
+
+  </ScrollView>
+
+</LinearLayout>
diff --git a/android-interop-testing/app/src/main/res/mipmap-hdpi/ic_launcher.png b/android-interop-testing/src/main/res/mipmap-hdpi/ic_launcher.png
similarity index 100%
rename from android-interop-testing/app/src/main/res/mipmap-hdpi/ic_launcher.png
rename to android-interop-testing/src/main/res/mipmap-hdpi/ic_launcher.png
diff --git a/android-interop-testing/app/src/main/res/mipmap-mdpi/ic_launcher.png b/android-interop-testing/src/main/res/mipmap-mdpi/ic_launcher.png
similarity index 100%
rename from android-interop-testing/app/src/main/res/mipmap-mdpi/ic_launcher.png
rename to android-interop-testing/src/main/res/mipmap-mdpi/ic_launcher.png
diff --git a/android-interop-testing/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/android-interop-testing/src/main/res/mipmap-xhdpi/ic_launcher.png
similarity index 100%
rename from android-interop-testing/app/src/main/res/mipmap-xhdpi/ic_launcher.png
rename to android-interop-testing/src/main/res/mipmap-xhdpi/ic_launcher.png
diff --git a/android-interop-testing/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/android-interop-testing/src/main/res/mipmap-xxhdpi/ic_launcher.png
similarity index 100%
rename from android-interop-testing/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
rename to android-interop-testing/src/main/res/mipmap-xxhdpi/ic_launcher.png
diff --git a/android-interop-testing/src/main/res/raw/ca.pem b/android-interop-testing/src/main/res/raw/ca.pem
new file mode 100644
index 00000000000..49d39cd8ed5
--- /dev/null
+++ b/android-interop-testing/src/main/res/raw/ca.pem
@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDWjCCAkKgAwIBAgIUWrP0VvHcy+LP6UuYNtiL9gBhD5owDQYJKoZIhvcNAQEL
+BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTIw
+MDMxNzE4NTk1MVoXDTMwMDMxNTE4NTk1MVowVjELMAkGA1UEBhMCQVUxEzARBgNV
+BAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0
+ZDEPMA0GA1UEAwwGdGVzdGNhMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEAsGL0oXflF0LzoM+Bh+qUU9yhqzw2w8OOX5mu/iNCyUOBrqaHi7mGHx73GD01
+diNzCzvlcQqdNIH6NQSL7DTpBjca66jYT9u73vZe2MDrr1nVbuLvfu9850cdxiUO
+Inv5xf8+sTHG0C+a+VAvMhsLiRjsq+lXKRJyk5zkbbsETybqpxoJ+K7CoSy3yc/k
+QIY3TipwEtwkKP4hzyo6KiGd/DPexie4nBUInN3bS1BUeNZ5zeaIC2eg3bkeeW7c
+qT55b+Yen6CxY0TEkzBK6AKt/WUialKMgT0wbTxRZO7kUCH3Sq6e/wXeFdJ+HvdV
+LPlAg5TnMaNpRdQih/8nRFpsdwIDAQABoyAwHjAMBgNVHRMEBTADAQH/MA4GA1Ud
+DwEB/wQEAwICBDANBgkqhkiG9w0BAQsFAAOCAQEAkTrKZjBrJXHps/HrjNCFPb5a
+THuGPCSsepe1wkKdSp1h4HGRpLoCgcLysCJ5hZhRpHkRihhef+rFHEe60UePQO3S
+CVTtdJB4CYWpcNyXOdqefrbJW5QNljxgi6Fhvs7JJkBqdXIkWXtFk2eRgOIP2Eo9
+/OHQHlYnwZFrk6sp4wPyR+A95S0toZBcyDVz7u+hOW0pGK3wviOe9lvRgj/H3Pwt
+bewb0l+MhRig0/DVHamyVxrDRbqInU1/GTNCwcZkXKYFWSf92U+kIcTth24Q1gcw
+eZiLl5FfrWokUNytFElXob0V0a5/kbhiLc3yWmvWqHTpqCALbVyF+rKJo2f5Kw==
+-----END CERTIFICATE-----
diff --git a/android-interop-testing/src/main/res/values/strings.xml b/android-interop-testing/src/main/res/values/strings.xml
new file mode 100644
index 00000000000..33b28eb9456
--- /dev/null
+++ b/android-interop-testing/src/main/res/values/strings.xml
@@ -0,0 +1,4 @@
+<resources>
+    <string name="app_name">gRPC Integration Test</string>
+    <string name="testing_message">Testing…</string>
+</resources>
diff --git a/android/build.gradle b/android/build.gradle
new file mode 100644
index 00000000000..d0ae3b9c886
--- /dev/null
+++ b/android/build.gradle
@@ -0,0 +1,82 @@
+plugins {
+    id "maven-publish"
+
+    id "com.android.library"
+}
+
+description = 'gRPC: Android'
+
+android {
+    namespace = 'io.grpc.android'
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    compileSdkVersion 34
+    defaultConfig {
+        minSdkVersion 22
+        targetSdkVersion 33
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    lintOptions { abortOnError = true }
+    publishing {
+        singleVariant('release') {
+            withSourcesJar()
+            withJavadocJar()
+        }
+    }
+}
+
+repositories {
+    google()
+}
+
+dependencies {
+    api project(':grpc-api')
+    implementation project(':grpc-core')
+    implementation libraries.guava
+    testImplementation project('::grpc-okhttp')
+    testImplementation libraries.androidx.test.core
+    testImplementation libraries.junit
+    testImplementation libraries.robolectric
+    testImplementation libraries.truth
+}
+
+tasks.register("javadocs", Javadoc) {
+    source = android.sourceSets.main.java.srcDirs
+    classpath += files(android.getBootClasspath())
+    classpath += files({
+        android.libraryVariants.collect { variant ->
+            variant.javaCompileProvider.get().classpath
+        }
+    })
+    options {
+        // Disable JavaDoc doclint on Java 8.
+        if (JavaVersion.current().isJava8Compatible()) {
+            addStringOption('Xdoclint:none', '-quiet')
+        }
+    }
+}
+
+tasks.register("javadocJar", Jar) {
+    dependsOn javadocs
+    archiveClassifier = 'javadoc'
+    from javadocs.destinationDir
+}
+
+tasks.register("sourcesJar", Jar) {
+    archiveClassifier = 'sources'
+    from android.sourceSets.main.java.srcDirs
+}
+
+publishing {
+    publications {
+        maven {
+            afterEvaluate {
+                from components.release
+            }
+        }
+    }
+}
diff --git a/android/src/main/AndroidManifest.xml b/android/src/main/AndroidManifest.xml
new file mode 100644
index 00000000000..d6bda33f101
--- /dev/null
+++ b/android/src/main/AndroidManifest.xml
@@ -0,0 +1,5 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" >
+
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+
+</manifest>
diff --git a/android/src/main/java/io/grpc/android/AndroidChannelBuilder.java b/android/src/main/java/io/grpc/android/AndroidChannelBuilder.java
new file mode 100644
index 00000000000..3a750e02795
--- /dev/null
+++ b/android/src/main/java/io/grpc/android/AndroidChannelBuilder.java
@@ -0,0 +1,340 @@
+/*
+ * Copyright 2018 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.android;
+
+import android.annotation.TargetApi;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.os.Build;
+import android.util.Log;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.InlineMe;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.CallOptions;
+import io.grpc.ClientCall;
+import io.grpc.ConnectivityState;
+import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingChannelBuilder;
+import io.grpc.InternalManagedChannelProvider;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.ManagedChannelProvider;
+import io.grpc.MethodDescriptor;
+import io.grpc.internal.GrpcUtil;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * Builds a {@link ManagedChannel} that, when provided with a {@link Context}, will automatically
+ * monitor the Android device's network state to smoothly handle intermittent network failures.
+ *
+ * <p>Currently only compatible with gRPC's OkHttp transport, which must be available at runtime.
+ *
+ * <p>Requires the Android ACCESS_NETWORK_STATE permission.
+ *
+ * @since 1.12.0
+ */
+public final class AndroidChannelBuilder extends ForwardingChannelBuilder<AndroidChannelBuilder> {
+
+  private static final String LOG_TAG = "AndroidChannelBuilder";
+
+  @Nullable private static final ManagedChannelProvider OKHTTP_CHANNEL_PROVIDER = findOkHttp();
+
+  private static ManagedChannelProvider findOkHttp() {
+    Class<?> klassRaw;
+    try {
+      klassRaw = Class.forName("io.grpc.okhttp.OkHttpChannelProvider");
+    } catch (ClassNotFoundException e) {
+      Log.w(LOG_TAG, "Failed to find OkHttpChannelProvider", e);
+      return null;
+    }
+    Class<? extends ManagedChannelProvider> klass;
+    try {
+      klass = klassRaw.asSubclass(ManagedChannelProvider.class);
+    } catch (ClassCastException e) {
+      Log.w(LOG_TAG, "Couldn't cast OkHttpChannelProvider to ManagedChannelProvider", e);
+      return null;
+    }
+    ManagedChannelProvider provider;
+    try {
+      provider = klass.getConstructor().newInstance();
+    } catch (Exception e) {
+      Log.w(LOG_TAG, "Failed to construct OkHttpChannelProvider", e);
+      return null;
+    }
+    if (!InternalManagedChannelProvider.isAvailable(provider)) {
+      Log.w(LOG_TAG, "OkHttpChannelProvider.isAvailable() returned false");
+      return null;
+    }
+    return provider;
+  }
+
+  private final ManagedChannelBuilder<?> delegateBuilder;
+
+  @Nullable private Context context;
+
+  /**
+   * Creates a new builder with the given target string that will be resolved by
+   * {@link io.grpc.NameResolver}.
+   */
+  public static AndroidChannelBuilder forTarget(String target) {
+    return new AndroidChannelBuilder(target);
+  }
+
+  /**
+   * Creates a new builder with the given host and port.
+   */
+  public static AndroidChannelBuilder forAddress(String name, int port) {
+    return forTarget(GrpcUtil.authorityFromHostAndPort(name, port));
+  }
+
+  /**
+   * Creates a new builder, which delegates to the given ManagedChannelBuilder.
+   *
+   * @deprecated Use {@link #usingBuilder(ManagedChannelBuilder)} instead.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/6043")
+  @Deprecated
+  @InlineMe(
+      replacement = "AndroidChannelBuilder.usingBuilder(builder)",
+      imports = "io.grpc.android.AndroidChannelBuilder")
+  public static AndroidChannelBuilder fromBuilder(ManagedChannelBuilder<?> builder) {
+    return usingBuilder(builder);
+  }
+
+  /**
+   * Creates a new builder, which delegates to the given ManagedChannelBuilder.
+   *
+   * <p>The provided {@code builder} becomes "owned" by AndroidChannelBuilder. The caller should
+   * not modify the provided builder and AndroidChannelBuilder may modify it. That implies reusing
+   * the provided builder to build another channel may result with unexpected configurations. That
+   * usage should be discouraged.
+   *
+   * @since 1.24.0
+   */
+  public static AndroidChannelBuilder usingBuilder(ManagedChannelBuilder<?> builder) {
+    return new AndroidChannelBuilder(builder);
+  }
+
+  private AndroidChannelBuilder(String target) {
+    if (OKHTTP_CHANNEL_PROVIDER == null) {
+      throw new UnsupportedOperationException("Unable to load OkHttpChannelProvider");
+    }
+    delegateBuilder =
+        InternalManagedChannelProvider.builderForTarget(OKHTTP_CHANNEL_PROVIDER, target);
+  }
+
+  private AndroidChannelBuilder(ManagedChannelBuilder<?> delegateBuilder) {
+    this.delegateBuilder = Preconditions.checkNotNull(delegateBuilder, "delegateBuilder");
+  }
+
+  /**
+   * Enables automatic monitoring of the device's network state.
+   */
+  public AndroidChannelBuilder context(Context context) {
+    this.context = context;
+    return this;
+  }
+
+  @Override
+  @SuppressWarnings("deprecation") // Not extending ForwardingChannelBuilder2 to preserve ABI.
+  protected ManagedChannelBuilder<?> delegate() {
+    return delegateBuilder;
+  }
+
+  /**
+   * Builds a channel with current configurations.
+   */
+  @Override
+  public ManagedChannel build() {
+    return new AndroidChannel(delegateBuilder.build(), context);
+  }
+
+  /**
+   * Wraps an OkHttp channel and handles invoking the appropriate methods (e.g., {@link
+   * ManagedChannel#enterIdle}) when the device network state changes.
+   */
+  @VisibleForTesting
+  static final class AndroidChannel extends ManagedChannel {
+
+    private final ManagedChannel delegate;
+
+    @Nullable private final Context context;
+    @Nullable private final ConnectivityManager connectivityManager;
+
+    private final Object lock = new Object();
+
+    @GuardedBy("lock")
+    private Runnable unregisterRunnable;
+
+    @VisibleForTesting
+    AndroidChannel(final ManagedChannel delegate, @Nullable Context context) {
+      this.delegate = delegate;
+      this.context = context;
+
+      if (context != null) {
+        connectivityManager =
+            (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+        try {
+          configureNetworkMonitoring();
+        } catch (SecurityException e) {
+          Log.w(
+              LOG_TAG,
+              "Failed to configure network monitoring. Does app have ACCESS_NETWORK_STATE"
+                  + " permission?",
+              e);
+        }
+      } else {
+        connectivityManager = null;
+      }
+    }
+
+    @GuardedBy("lock")
+    private void configureNetworkMonitoring() {
+      // Android N added the registerDefaultNetworkCallback API to listen to changes in the device's
+      // default network. For earlier Android API levels, use the BroadcastReceiver API.
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && connectivityManager != null) {
+        final DefaultNetworkCallback defaultNetworkCallback = new DefaultNetworkCallback();
+        connectivityManager.registerDefaultNetworkCallback(defaultNetworkCallback);
+        unregisterRunnable =
+            new Runnable() {
+              @Override
+              public void run() {
+                connectivityManager.unregisterNetworkCallback(defaultNetworkCallback);
+              }
+            };
+      } else {
+        final NetworkReceiver networkReceiver = new NetworkReceiver();
+        @SuppressWarnings("deprecation")
+        IntentFilter networkIntentFilter =
+            new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
+        context.registerReceiver(networkReceiver, networkIntentFilter);
+        unregisterRunnable =
+            new Runnable() {
+              @Override
+              public void run() {
+                context.unregisterReceiver(networkReceiver);
+              }
+            };
+      }
+    }
+
+    private void unregisterNetworkListener() {
+      synchronized (lock) {
+        if (unregisterRunnable != null) {
+          unregisterRunnable.run();
+          unregisterRunnable = null;
+        }
+      }
+    }
+
+    @Override
+    public ManagedChannel shutdown() {
+      unregisterNetworkListener();
+      return delegate.shutdown();
+    }
+
+    @Override
+    public boolean isShutdown() {
+      return delegate.isShutdown();
+    }
+
+    @Override
+    public boolean isTerminated() {
+      return delegate.isTerminated();
+    }
+
+    @Override
+    public ManagedChannel shutdownNow() {
+      unregisterNetworkListener();
+      return delegate.shutdownNow();
+    }
+
+    @Override
+    public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+      return delegate.awaitTermination(timeout, unit);
+    }
+
+    @Override
+    public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+        MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+      return delegate.newCall(methodDescriptor, callOptions);
+    }
+
+    @Override
+    public String authority() {
+      return delegate.authority();
+    }
+
+    @Override
+    public ConnectivityState getState(boolean requestConnection) {
+      return delegate.getState(requestConnection);
+    }
+
+    @Override
+    public void notifyWhenStateChanged(ConnectivityState source, Runnable callback) {
+      delegate.notifyWhenStateChanged(source, callback);
+    }
+
+    @Override
+    public void resetConnectBackoff() {
+      delegate.resetConnectBackoff();
+    }
+
+    @Override
+    public void enterIdle() {
+      delegate.enterIdle();
+    }
+
+    /** Respond to changes in the default network. Only used on API levels 24+. */
+    @TargetApi(Build.VERSION_CODES.N)
+    private class DefaultNetworkCallback extends ConnectivityManager.NetworkCallback {
+      @Override
+      public void onAvailable(Network network) {
+        delegate.enterIdle();
+      }
+
+      @Override
+      public void onBlockedStatusChanged(Network network, boolean blocked) {
+        if (!blocked) {
+          delegate.enterIdle();
+        }
+      }
+    }
+
+    /** Respond to network changes. Only used on API levels < 24. */
+    private class NetworkReceiver extends BroadcastReceiver {
+
+      @SuppressWarnings("deprecation")
+      @Override
+      public void onReceive(Context context, Intent intent) {
+        ConnectivityManager conn =
+            (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+        android.net.NetworkInfo networkInfo = conn.getActiveNetworkInfo();
+
+        if (networkInfo != null && networkInfo.isConnected()) {
+          delegate.enterIdle();
+        }
+      }
+    }
+  }
+}
diff --git a/android/src/main/java/io/grpc/android/UdsChannelBuilder.java b/android/src/main/java/io/grpc/android/UdsChannelBuilder.java
new file mode 100644
index 00000000000..6f03aa0ee5e
--- /dev/null
+++ b/android/src/main/java/io/grpc/android/UdsChannelBuilder.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2021 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.android;
+
+import android.net.LocalSocketAddress.Namespace;
+import io.grpc.ChannelCredentials;
+import io.grpc.ExperimentalApi;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.internal.GrpcUtil;
+import java.lang.reflect.InvocationTargetException;
+import javax.annotation.Nullable;
+import javax.net.SocketFactory;
+
+/**
+ * Creates a UDS channel by passing in a specialized SocketFactory into an OkHttpChannelBuilder. The
+ * UdsSockets produced by this factory communicate over Android's LocalSockets.
+ *
+ * <p>Example Usage <code>
+ *   Channel channel = UdsChannelBuilder.forPath("/data/data/my.app/app.socket",
+ *     Namespace.FILESYSTEM).build();
+ *   stub = MyService.newStub(channel);
+ * </code>
+ *
+ * <p>This class uses a safe-for-production hack to workaround NameResolver's inability to safely
+ * return non-IP SocketAddress types. The hack simply ignores the name resolver results and connects
+ * to the UDS name provided during construction instead. This class is expected to be replaced with
+ * a `unix:` name resolver when possible.
+ */
+@ExperimentalApi("A stopgap. Not intended to be stabilized")
+public final class UdsChannelBuilder {
+  @Nullable
+  @SuppressWarnings("rawtypes")
+  private static final Class<? extends ManagedChannelBuilder> OKHTTP_CHANNEL_BUILDER_CLASS =
+      findOkHttp();
+
+  @SuppressWarnings("rawtypes")
+  private static Class<? extends ManagedChannelBuilder> findOkHttp() {
+    try {
+      return Class.forName("io.grpc.okhttp.OkHttpChannelBuilder")
+          .asSubclass(ManagedChannelBuilder.class);
+    } catch (ClassNotFoundException e) {
+      return null;
+    }
+  }
+
+  /**
+   * Returns a channel to the UDS endpoint specified by the file-path.
+   *
+   * @param path unix file system path to use for Unix Domain Socket.
+   * @param namespace the type of the namespace that the path belongs to.
+   */
+  public static ManagedChannelBuilder<?> forPath(String path, Namespace namespace) {
+    if (OKHTTP_CHANNEL_BUILDER_CLASS == null) {
+      throw new UnsupportedOperationException("OkHttpChannelBuilder not found on the classpath");
+    }
+    try {
+      // Target 'dns:///127.0.0.1' is unused, but necessary as an argument for OkHttpChannelBuilder.
+      // An IP address is used instead of localhost to avoid a DNS lookup (see #11442). This should
+      // work even if IPv4 is unavailable, as the DNS resolver doesn't need working IPv4 to parse an
+      // IPv4 address. Unavailable IPv4 fails when we connect(), not at resolution time.
+      // TLS is unsupported because Conscrypt assumes the platform Socket implementation to improve
+      // performance by using the file descriptor directly.
+      Object o = OKHTTP_CHANNEL_BUILDER_CLASS
+          .getMethod("forTarget", String.class, ChannelCredentials.class)
+          .invoke(null, "dns:///127.0.0.1", InsecureChannelCredentials.create());
+      ManagedChannelBuilder<?> builder = OKHTTP_CHANNEL_BUILDER_CLASS.cast(o);
+      OKHTTP_CHANNEL_BUILDER_CLASS
+          .getMethod("socketFactory", SocketFactory.class)
+          .invoke(builder, new UdsSocketFactory(path, namespace));
+      return builder.proxyDetector(GrpcUtil.NOOP_PROXY_DETECTOR);
+    } catch (IllegalAccessException e) {
+      throw new RuntimeException("Failed to create OkHttpChannelBuilder", e);
+    } catch (NoSuchMethodException e) {
+      throw new RuntimeException("Failed to create OkHttpChannelBuilder", e);
+    } catch (InvocationTargetException e) {
+      throw new RuntimeException("Failed to create OkHttpChannelBuilder", e);
+    }
+  }
+
+  private UdsChannelBuilder() {}
+}
diff --git a/android/src/main/java/io/grpc/android/UdsSocket.java b/android/src/main/java/io/grpc/android/UdsSocket.java
new file mode 100644
index 00000000000..bbe19e1ddb6
--- /dev/null
+++ b/android/src/main/java/io/grpc/android/UdsSocket.java
@@ -0,0 +1,312 @@
+/*
+ * Copyright 2021 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.android;
+
+import android.net.LocalSocket;
+import android.net.LocalSocketAddress;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import java.io.FilterInputStream;
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.SocketAddress;
+import java.net.SocketException;
+import java.nio.channels.SocketChannel;
+
+/**
+ * Adapter from Android's LocalSocket to Socket. This class is only needed by grpc-okhttp, so the
+ * adapter only has to support the things that grcp-okhttp uses. It is fine to support trivial
+ * things unused by the transport, to be less likely to break as the transport usage changes, but it
+ * is also unnecessary. It's okay to stretch the truth or lie when necessary. For example, little
+ * hurts with {@link #setTcpNoDelay(boolean)} being a noop since unix domain sockets don't have such
+ * unnecessary delays.
+ */
+@SuppressWarnings("UnsynchronizedOverridesSynchronized") // Rely on LocalSocket's synchronization
+class UdsSocket extends Socket {
+
+  private final LocalSocket localSocket;
+  private final LocalSocketAddress localSocketAddress;
+
+  @GuardedBy("this")
+  private boolean closed = false;
+
+  @GuardedBy("this")
+  private boolean inputShutdown = false;
+
+  @GuardedBy("this")
+  private boolean outputShutdown = false;
+
+  public UdsSocket(LocalSocketAddress localSocketAddress) {
+    this.localSocketAddress = localSocketAddress;
+    localSocket = new LocalSocket();
+  }
+
+  @Override
+  public void bind(SocketAddress bindpoint) {
+    // no-op
+  }
+
+  @Override
+  public synchronized void close() throws IOException {
+    if (closed) {
+      return;
+    }
+    if (!inputShutdown) {
+      shutdownInput();
+    }
+    if (!outputShutdown) {
+      shutdownOutput();
+    }
+    localSocket.close();
+    closed = true;
+  }
+
+  @Override
+  public void connect(SocketAddress endpoint) throws IOException {
+    localSocket.connect(localSocketAddress);
+  }
+
+  @Override
+  public void connect(SocketAddress endpoint, int timeout) throws IOException {
+    localSocket.connect(localSocketAddress, timeout);
+  }
+
+  @Override
+  public SocketChannel getChannel() {
+    throw new UnsupportedOperationException("getChannel() not supported");
+  }
+
+  @Override
+  public InetAddress getInetAddress() {
+    throw new UnsupportedOperationException("getInetAddress() not supported");
+  }
+
+  @Override
+  public InputStream getInputStream() throws IOException {
+    return new FilterInputStream(localSocket.getInputStream()) {
+      @Override
+      public void close() throws IOException {
+        UdsSocket.this.close();
+      }
+    };
+  }
+
+  @Override
+  public boolean getKeepAlive() {
+    throw new UnsupportedOperationException("Unsupported operation getKeepAlive()");
+  }
+
+  @Override
+  public InetAddress getLocalAddress() {
+    throw new UnsupportedOperationException("Unsupported operation getLocalAddress()");
+  }
+
+  @Override
+  public int getLocalPort() {
+    throw new UnsupportedOperationException("Unsupported operation getLocalPort()");
+  }
+
+  @Override
+  public SocketAddress getLocalSocketAddress() {
+    return new SocketAddress() {};
+  }
+
+  @Override
+  public boolean getOOBInline() {
+    throw new UnsupportedOperationException("Unsupported operation getOOBInline()");
+  }
+
+  @Override
+  public OutputStream getOutputStream() throws IOException {
+    return new FilterOutputStream(localSocket.getOutputStream()) {
+      @Override
+      public void close() throws IOException {
+        UdsSocket.this.close();
+      }
+    };
+  }
+
+  @Override
+  public int getPort() {
+    throw new UnsupportedOperationException("Unsupported operation getPort()");
+  }
+
+  @Override
+  public int getReceiveBufferSize() throws SocketException {
+    try {
+      return localSocket.getReceiveBufferSize();
+    } catch (IOException e) {
+      throw toSocketException(e);
+    }
+  }
+
+  @Override
+  public SocketAddress getRemoteSocketAddress() {
+    return new SocketAddress() {};
+  }
+
+  @Override
+  public boolean getReuseAddress() {
+    throw new UnsupportedOperationException("Unsupported operation getReuseAddress()");
+  }
+
+  @Override
+  public int getSendBufferSize() throws SocketException {
+    try {
+      return localSocket.getSendBufferSize();
+    } catch (IOException e) {
+      throw toSocketException(e);
+    }
+  }
+
+  @Override
+  public int getSoLinger() {
+    return -1; // unsupported
+  }
+
+  @Override
+  public int getSoTimeout() throws SocketException {
+    try {
+      return localSocket.getSoTimeout();
+    } catch (IOException e) {
+      throw toSocketException(e);
+    }
+  }
+
+  @Override
+  public boolean getTcpNoDelay() {
+    return true;
+  }
+
+  @Override
+  public int getTrafficClass() {
+    throw new UnsupportedOperationException("Unsupported operation getTrafficClass()");
+  }
+
+  @Override
+  public boolean isBound() {
+    return localSocket.isBound();
+  }
+
+  @Override
+  public synchronized boolean isClosed() {
+    return closed;
+  }
+
+  @Override
+  public boolean isConnected() {
+    return localSocket.isConnected();
+  }
+
+  @Override
+  public synchronized boolean isInputShutdown() {
+    return inputShutdown;
+  }
+
+  @Override
+  public synchronized boolean isOutputShutdown() {
+    return outputShutdown;
+  }
+
+  @Override
+  public void sendUrgentData(int data) {
+    throw new UnsupportedOperationException("Unsupported operation sendUrgentData()");
+  }
+
+  @Override
+  public void setKeepAlive(boolean on) {
+    throw new UnsupportedOperationException("Unsupported operation setKeepAlive()");
+  }
+
+  @Override
+  public void setOOBInline(boolean on) {
+    throw new UnsupportedOperationException("Unsupported operation setOOBInline()");
+  }
+
+  @Override
+  public void setPerformancePreferences(int connectionTime, int latency, int bandwidth) {
+    throw new UnsupportedOperationException("Unsupported operation setPerformancePreferences()");
+  }
+
+  @Override
+  public void setReceiveBufferSize(int size) throws SocketException {
+    try {
+      localSocket.setReceiveBufferSize(size);
+    } catch (IOException e) {
+      throw toSocketException(e);
+    }
+  }
+
+  @Override
+  public void setReuseAddress(boolean on) {
+    throw new UnsupportedOperationException("Unsupported operation setReuseAddress()");
+  }
+
+  @Override
+  public void setSendBufferSize(int size) throws SocketException {
+    try {
+      localSocket.setSendBufferSize(size);
+    } catch (IOException e) {
+      throw toSocketException(e);
+    }
+  }
+
+  @Override
+  public void setSoLinger(boolean on, int linger) {
+    throw new UnsupportedOperationException("Unsupported operation setSoLinger()");
+  }
+
+  @Override
+  public void setSoTimeout(int timeout) throws SocketException {
+    try {
+      localSocket.setSoTimeout(timeout);
+    } catch (IOException e) {
+      throw toSocketException(e);
+    }
+  }
+
+  @Override
+  public void setTcpNoDelay(boolean on) {
+    // no-op
+  }
+
+  @Override
+  public void setTrafficClass(int tc) {
+    throw new UnsupportedOperationException("Unsupported operation setTrafficClass()");
+  }
+
+  @Override
+  public synchronized void shutdownInput() throws IOException {
+    localSocket.shutdownInput();
+    inputShutdown = true;
+  }
+
+  @Override
+  public synchronized void shutdownOutput() throws IOException {
+    localSocket.shutdownOutput();
+    outputShutdown = true;
+  }
+
+  private static SocketException toSocketException(Throwable e) {
+    SocketException se = new SocketException();
+    se.initCause(e);
+    return se;
+  }
+}
diff --git a/android/src/main/java/io/grpc/android/UdsSocketFactory.java b/android/src/main/java/io/grpc/android/UdsSocketFactory.java
new file mode 100644
index 00000000000..93150196d97
--- /dev/null
+++ b/android/src/main/java/io/grpc/android/UdsSocketFactory.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2021 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.android;
+
+import android.net.LocalSocketAddress;
+import android.net.LocalSocketAddress.Namespace;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.net.SocketAddress;
+import javax.net.SocketFactory;
+
+/**
+ * A SocketFactory that produces {@link UdsSocket} instances. This is used to provide support for
+ * gRPC channels with an underlying Unix Domain Socket transport.
+ */
+class UdsSocketFactory extends SocketFactory {
+
+  private final LocalSocketAddress localSocketAddress;
+
+  public UdsSocketFactory(String path, Namespace namespace) {
+    localSocketAddress = new LocalSocketAddress(path, namespace);
+  }
+
+  @Override
+  public Socket createSocket() throws IOException {
+    return create();
+  }
+
+  @Override
+  public Socket createSocket(String host, int port) throws IOException {
+    return createAndConnect();
+  }
+
+  @Override
+  public Socket createSocket(String host, int port, InetAddress localHost, int localPort)
+      throws IOException {
+    return createAndConnect();
+  }
+
+  @Override
+  public Socket createSocket(InetAddress host, int port) throws IOException {
+    return createAndConnect();
+  }
+
+  @Override
+  public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort)
+      throws IOException {
+    return createAndConnect();
+  }
+
+  private Socket create() {
+    return new UdsSocket(localSocketAddress);
+  }
+
+  private Socket createAndConnect() throws IOException {
+    Socket socket = create();
+    SocketAddress unusedAddress = new InetSocketAddress(0);
+    socket.connect(unusedAddress);
+    return socket;
+  }
+}
diff --git a/android/src/test/java/io/grpc/android/AndroidChannelBuilderTest.java b/android/src/test/java/io/grpc/android/AndroidChannelBuilderTest.java
new file mode 100644
index 00000000000..c0884e4d7cf
--- /dev/null
+++ b/android/src/test/java/io/grpc/android/AndroidChannelBuilderTest.java
@@ -0,0 +1,366 @@
+/*
+ * Copyright 2018 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.android;
+
+import static android.os.Build.VERSION_CODES.LOLLIPOP;
+import static android.os.Build.VERSION_CODES.N;
+import static com.google.common.truth.Truth.assertThat;
+import static org.robolectric.RuntimeEnvironment.getApiLevel;
+import static org.robolectric.Shadows.shadowOf;
+import static org.robolectric.annotation.LooperMode.Mode.LEGACY;
+
+import android.content.Context;
+import android.content.Intent;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import androidx.test.core.app.ApplicationProvider;
+import io.grpc.CallOptions;
+import io.grpc.ClientCall;
+import io.grpc.ManagedChannel;
+import io.grpc.MethodDescriptor;
+import io.grpc.okhttp.OkHttpChannelBuilder;
+import java.util.HashSet;
+import java.util.concurrent.TimeUnit;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
+import org.robolectric.annotation.LooperMode;
+import org.robolectric.shadows.ShadowConnectivityManager;
+import org.robolectric.shadows.ShadowNetwork;
+import org.robolectric.shadows.ShadowNetworkInfo;
+
+@LooperMode(LEGACY)
+@RunWith(RobolectricTestRunner.class)
+@Config(shadows = {AndroidChannelBuilderTest.ShadowDefaultNetworkListenerConnectivityManager.class})
+@SuppressWarnings("deprecation")
+public final class AndroidChannelBuilderTest {
+  private final android.net.NetworkInfo WIFI_CONNECTED =
+      ShadowNetworkInfo.newInstance(
+          android.net.NetworkInfo.DetailedState.CONNECTED,
+          ConnectivityManager.TYPE_WIFI,
+          0,
+          true,
+          android.net.NetworkInfo.State.CONNECTED);
+  private final android.net.NetworkInfo WIFI_DISCONNECTED =
+      ShadowNetworkInfo.newInstance(
+          android.net.NetworkInfo.DetailedState.DISCONNECTED,
+          ConnectivityManager.TYPE_WIFI,
+          0,
+          true,
+          android.net.NetworkInfo.State.DISCONNECTED);
+  private final android.net.NetworkInfo MOBILE_CONNECTED =
+      ShadowNetworkInfo.newInstance(
+          android.net.NetworkInfo.DetailedState.CONNECTED,
+          ConnectivityManager.TYPE_MOBILE,
+          ConnectivityManager.TYPE_MOBILE_MMS,
+          true,
+          android.net.NetworkInfo.State.CONNECTED);
+  private final android.net.NetworkInfo MOBILE_DISCONNECTED =
+      ShadowNetworkInfo.newInstance(
+          android.net.NetworkInfo.DetailedState.DISCONNECTED,
+          ConnectivityManager.TYPE_MOBILE,
+          ConnectivityManager.TYPE_MOBILE_MMS,
+          true,
+          android.net.NetworkInfo.State.DISCONNECTED);
+
+  private ConnectivityManager connectivityManager;
+
+  @Before
+  public void setUp() {
+    connectivityManager =
+        (ConnectivityManager)
+            ApplicationProvider
+                .getApplicationContext()
+                .getSystemService(Context.CONNECTIVITY_SERVICE);
+  }
+
+  @Test
+  public void channelBuilderClassFoundReflectively() {
+    // This should not throw with OkHttpChannelBuilder on the classpath
+    AndroidChannelBuilder.forTarget("target");
+  }
+
+  @Test
+  public void usingBuilderConstructor() {
+    OkHttpChannelBuilder wrappedBuilder = OkHttpChannelBuilder.forTarget("target");
+    AndroidChannelBuilder androidBuilder = AndroidChannelBuilder.usingBuilder(wrappedBuilder);
+    assertThat(androidBuilder.delegate()).isSameInstanceAs(wrappedBuilder);
+  }
+
+  @Test
+  @Config(sdk = 23)
+  public void nullContextDoesNotThrow_api23() {
+    TestChannel delegateChannel = new TestChannel();
+    ManagedChannel androidChannel = new AndroidChannelBuilder.AndroidChannel(delegateChannel, null);
+
+    // Network change and shutdown should be no-op for the channel without an Android Context
+    shadowOf(connectivityManager).setActiveNetworkInfo(WIFI_CONNECTED);
+    ApplicationProvider
+        .getApplicationContext()
+        .sendBroadcast(new Intent(ConnectivityManager.CONNECTIVITY_ACTION));
+    androidChannel.shutdown();
+
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(0);
+  }
+
+  @Test
+  @Config(sdk = 24)
+  public void nullContextDoesNotThrow_api24() {
+    shadowOf(connectivityManager).setActiveNetworkInfo(MOBILE_DISCONNECTED);
+    TestChannel delegateChannel = new TestChannel();
+    ManagedChannel androidChannel = new AndroidChannelBuilder.AndroidChannel(delegateChannel, null);
+
+    // Network change and shutdown should be no-op for the channel without an Android Context
+    shadowOf(connectivityManager).setActiveNetworkInfo(MOBILE_CONNECTED);
+    androidChannel.shutdown();
+
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(0);
+  }
+
+  @Test
+  @Config(sdk = 23)
+  public void networkChanges_api23() {
+    TestChannel delegateChannel = new TestChannel();
+    ManagedChannel androidChannel =
+        new AndroidChannelBuilder.AndroidChannel(
+            delegateChannel, ApplicationProvider.getApplicationContext());
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(0);
+
+    // On API levels < 24, the broadcast receiver will invoke enterIdle() on the first
+    // connectivity action broadcast regardless of previous connection status
+    shadowOf(connectivityManager).setActiveNetworkInfo(WIFI_CONNECTED);
+    ApplicationProvider
+        .getApplicationContext()
+        .sendBroadcast(new Intent(ConnectivityManager.CONNECTIVITY_ACTION));
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(1);
+
+    // Drop the connection
+    shadowOf(connectivityManager).setActiveNetworkInfo(null);
+    ApplicationProvider
+        .getApplicationContext()
+        .sendBroadcast(new Intent(ConnectivityManager.CONNECTIVITY_ACTION));
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(1);
+
+    // Notify that a new but not connected network is available
+    shadowOf(connectivityManager).setActiveNetworkInfo(MOBILE_DISCONNECTED);
+    ApplicationProvider
+        .getApplicationContext()
+        .sendBroadcast(new Intent(ConnectivityManager.CONNECTIVITY_ACTION));
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(1);
+
+    // Establish a connection
+    shadowOf(connectivityManager).setActiveNetworkInfo(MOBILE_CONNECTED);
+    ApplicationProvider
+        .getApplicationContext()
+        .sendBroadcast(new Intent(ConnectivityManager.CONNECTIVITY_ACTION));
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(2);
+
+    // Disconnect, then shutdown the channel and verify that the broadcast receiver has been
+    // unregistered
+    shadowOf(connectivityManager).setActiveNetworkInfo(null);
+    ApplicationProvider
+        .getApplicationContext()
+        .sendBroadcast(new Intent(ConnectivityManager.CONNECTIVITY_ACTION));
+    androidChannel.shutdown();
+    shadowOf(connectivityManager).setActiveNetworkInfo(MOBILE_CONNECTED);
+    ApplicationProvider
+        .getApplicationContext()
+        .sendBroadcast(new Intent(ConnectivityManager.CONNECTIVITY_ACTION));
+
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(2);
+  }
+
+  @Test
+  @Config(sdk = 24)
+  public void networkChanges_api24() {
+    shadowOf(connectivityManager).setActiveNetworkInfo(MOBILE_DISCONNECTED);
+    TestChannel delegateChannel = new TestChannel();
+    ManagedChannel androidChannel =
+        new AndroidChannelBuilder.AndroidChannel(
+            delegateChannel, ApplicationProvider.getApplicationContext());
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(0);
+
+    // Establish an initial network connection
+    shadowOf(connectivityManager).setActiveNetworkInfo(MOBILE_CONNECTED);
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(1);
+
+    // Switch to another network to trigger enterIdle()
+    shadowOf(connectivityManager).setActiveNetworkInfo(WIFI_CONNECTED);
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(2);
+
+    // Switch to an offline network and then to null
+    shadowOf(connectivityManager).setActiveNetworkInfo(WIFI_DISCONNECTED);
+    shadowOf(connectivityManager).setActiveNetworkInfo(null);
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(2);
+
+    // Establish a connection
+    shadowOf(connectivityManager).setActiveNetworkInfo(MOBILE_CONNECTED);
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(3);
+
+    // Disconnect, then shutdown the channel and verify that the callback has been unregistered
+    shadowOf(connectivityManager).setActiveNetworkInfo(null);
+    androidChannel.shutdown();
+    shadowOf(connectivityManager).setActiveNetworkInfo(MOBILE_CONNECTED);
+
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(3);
+  }
+
+  @Test
+  @Config(sdk = 23)
+  public void shutdownNowUnregistersBroadcastReceiver_api23() {
+    TestChannel delegateChannel = new TestChannel();
+    ManagedChannel androidChannel =
+        new AndroidChannelBuilder.AndroidChannel(
+            delegateChannel, ApplicationProvider.getApplicationContext());
+
+    shadowOf(connectivityManager).setActiveNetworkInfo(null);
+    ApplicationProvider
+        .getApplicationContext()
+        .sendBroadcast(new Intent(ConnectivityManager.CONNECTIVITY_ACTION));
+    androidChannel.shutdownNow();
+    shadowOf(connectivityManager).setActiveNetworkInfo(WIFI_CONNECTED);
+    ApplicationProvider
+        .getApplicationContext()
+        .sendBroadcast(new Intent(ConnectivityManager.CONNECTIVITY_ACTION));
+
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(0);
+  }
+
+  @Test
+  @Config(sdk = 24)
+  public void shutdownNowUnregistersNetworkCallback_api24() {
+    shadowOf(connectivityManager).setActiveNetworkInfo(null);
+    TestChannel delegateChannel = new TestChannel();
+    ManagedChannel androidChannel =
+        new AndroidChannelBuilder.AndroidChannel(
+            delegateChannel, ApplicationProvider.getApplicationContext());
+
+    androidChannel.shutdownNow();
+    shadowOf(connectivityManager).setActiveNetworkInfo(WIFI_CONNECTED);
+
+    assertThat(delegateChannel.enterIdleCount).isEqualTo(0);
+  }
+
+  /**
+   * Extends Robolectric ShadowConnectivityManager to handle Android N's
+   * registerDefaultNetworkCallback API.
+   */
+  @Implements(value = ConnectivityManager.class)
+  public static class ShadowDefaultNetworkListenerConnectivityManager
+      extends ShadowConnectivityManager {
+    private HashSet<ConnectivityManager.NetworkCallback> defaultNetworkCallbacks = new HashSet<>();
+
+    public ShadowDefaultNetworkListenerConnectivityManager() {
+      super();
+    }
+
+    @Override
+    public void setActiveNetworkInfo(android.net.NetworkInfo activeNetworkInfo) {
+      if (getApiLevel() >= N) {
+        android.net.NetworkInfo previousNetworkInfo = getActiveNetworkInfo();
+        if (activeNetworkInfo != null && activeNetworkInfo.isConnected()) {
+          notifyDefaultNetworkCallbacksOnAvailable(
+              ShadowNetwork.newInstance(activeNetworkInfo.getType() /* use type as network ID */));
+        } else if (previousNetworkInfo != null) {
+          notifyDefaultNetworkCallbacksOnLost(
+              ShadowNetwork.newInstance(
+                  previousNetworkInfo.getType() /* use type as network ID */));
+        }
+      }
+      super.setActiveNetworkInfo(activeNetworkInfo);
+    }
+
+    private void notifyDefaultNetworkCallbacksOnAvailable(Network network) {
+      for (ConnectivityManager.NetworkCallback networkCallback : defaultNetworkCallbacks) {
+        networkCallback.onAvailable(network);
+      }
+    }
+
+    private void notifyDefaultNetworkCallbacksOnLost(Network network) {
+      for (ConnectivityManager.NetworkCallback networkCallback : defaultNetworkCallbacks) {
+        networkCallback.onLost(network);
+      }
+    }
+
+    @Implementation(minSdk = N)
+    @Override
+    protected void registerDefaultNetworkCallback(
+        ConnectivityManager.NetworkCallback networkCallback) {
+      defaultNetworkCallbacks.add(networkCallback);
+    }
+
+    @Implementation(minSdk = LOLLIPOP)
+    @Override
+    public void unregisterNetworkCallback(ConnectivityManager.NetworkCallback networkCallback) {
+      if (getApiLevel() >= N) {
+        if (networkCallback != null || defaultNetworkCallbacks.contains(networkCallback)) {
+          defaultNetworkCallbacks.remove(networkCallback);
+        }
+      }
+      super.unregisterNetworkCallback(networkCallback);
+    }
+  }
+
+  private static class TestChannel extends ManagedChannel {
+    int enterIdleCount;
+
+    @Override
+    public ManagedChannel shutdown() {
+      return null;
+    }
+
+    @Override
+    public boolean isShutdown() {
+      return false;
+    }
+
+    @Override
+    public boolean isTerminated() {
+      return false;
+    }
+
+    @Override
+    public ManagedChannel shutdownNow() {
+      return null;
+    }
+
+    @Override
+    public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+      return false;
+    }
+
+    @Override
+    public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+        MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+      return null;
+    }
+
+    @Override
+    public String authority() {
+      return null;
+    }
+
+    @Override
+    public void enterIdle() {
+      enterIdleCount++;
+    }
+  }
+}
diff --git a/api/BUILD.bazel b/api/BUILD.bazel
new file mode 100644
index 00000000000..4c5e750b5e4
--- /dev/null
+++ b/api/BUILD.bazel
@@ -0,0 +1,17 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "api",
+    srcs = glob([
+        "src/main/java/**/*.java",
+        "src/context/java/**/*.java",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:failureaccess"),  # future transitive dep of Guava. See #5214
+        artifact("com.google.guava:guava"),
+    ],
+)
diff --git a/api/build.gradle b/api/build.gradle
new file mode 100644
index 00000000000..745fa00b3f1
--- /dev/null
+++ b/api/build.gradle
@@ -0,0 +1,84 @@
+plugins {
+    id "java-library"
+    id "java-test-fixtures"
+    id "maven-publish"
+
+    id "me.champeau.jmh"
+    id "ru.vyarus.animalsniffer"
+}
+
+description = 'gRPC: API'
+
+sourceSets {
+    context
+    main {
+        output.classesDirs.from(sourceSets.context.output.classesDirs)
+    }
+}
+
+tasks.named("compileContextJava").configure {
+    if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_20)) {
+        println("!!! Javac does not support generating Java 7 bytecode. Do not use for release builds !!!")
+    } else if (JavaVersion.current().isJava9Compatible()) {
+        options.release = 7
+    } else {
+        sourceCompatibility = JavaVersion.VERSION_1_7
+        targetCompatibility = JavaVersion.VERSION_1_7
+    }
+}
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc')
+    }
+}
+
+dependencies {
+    compileOnly sourceSets.context.output
+    api libraries.jsr305,
+            libraries.errorprone.annotations
+    implementation libraries.guava
+
+    testFixturesApi libraries.truth
+    testFixturesImplementation libraries.jsr305
+    testFixturesImplementation libraries.guava,
+            libraries.junit,
+            libraries.mockito.core
+    testImplementation project(':grpc-core')
+    testImplementation project(':grpc-testing')
+    testImplementation libraries.guava.testlib
+    testImplementation libraries.truth
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+animalsniffer {
+    annotation = 'io.grpc.IgnoreJRERequirement'
+}
+
+tasks.named("javadoc").configure {
+    source sourceSets.context.allSource
+    // We want io.grpc.Internal, but not io.grpc.Internal*
+    exclude 'io/grpc/*MetricInstrument.java'
+    exclude 'io/grpc/*MetricInstrumentRegistry.java'
+    exclude 'io/grpc/Internal?*.java'
+    exclude 'io/grpc/MetricRecorder.java'
+    exclude 'io/grpc/MetricSink.java'
+    exclude 'io/grpc/Uri.java'
+}
+
+tasks.named("sourcesJar").configure {
+    from sourceSets.context.allSource
+}
+
+components.java.withVariantsFromConfiguration(configurations.testFixturesApiElements) { skip() }
+components.java.withVariantsFromConfiguration(configurations.testFixturesRuntimeElements) { skip() }
diff --git a/api/src/context/java/io/grpc/Context.java b/api/src/context/java/io/grpc/Context.java
new file mode 100644
index 00000000000..c19d2db9da3
--- /dev/null
+++ b/api/src/context/java/io/grpc/Context.java
@@ -0,0 +1,1124 @@
+/*
+ * Copyright 2015 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;
+
+import io.grpc.Context.CheckReturnValue;
+import io.grpc.PersistentHashArrayMappedTrie.Node;
+import java.io.Closeable;
+import java.util.ArrayList;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A context propagation mechanism which can carry scoped-values across API boundaries and between
+ * threads. Examples of state propagated via context include:
+ * <ul>
+ *   <li>Security principals and credentials.</li>
+ *   <li>Local and distributed tracing information.</li>
+ * </ul>
+ *
+ * <p>A Context object can be {@link #attach attached} to the {@link Storage}, which effectively
+ * forms a <b>scope</b> for the context.  The scope is bound to the current thread.  Within a scope,
+ * its Context is accessible even across API boundaries, through {@link #current}.  The scope is
+ * later exited by {@link #detach detaching} the Context.
+ *
+ * <p>Context objects are immutable and inherit state from their parent. To add or overwrite the
+ * current state a new context object must be created and then attached, replacing the previously
+ * bound context. For example:
+ *
+ * <pre>
+ *   Context withCredential = Context.current().withValue(CRED_KEY, cred);
+ *   withCredential.run(new Runnable() {
+ *     public void run() {
+ *        readUserRecords(userId, CRED_KEY.get());
+ *     }
+ *   });
+ * </pre>
+ *
+ * <p>Contexts are also used to represent a scoped unit of work. When the unit of work is done the
+ * context must be cancelled. This cancellation will cascade to all descendant contexts. You can
+ * add a {@link CancellationListener} to a context to be notified when it or one of its ancestors
+ * has been cancelled. Cancellation does not release the state stored by a context and it's
+ * perfectly valid to {@link #attach()} an already cancelled context to make it current. To cancel a
+ * context (and its descendants) you first create a {@link CancellableContext} and when you need to
+ * signal cancellation call {@link CancellableContext#cancel} or {@link
+ * CancellableContext#detachAndCancel}.
+ *
+ * <p>Contexts can also be created with a timeout relative to the system nano clock which will
+ * cause it to automatically cancel at the desired time.
+ *
+ *
+ * <p>Notes and cautions on use:
+ * <ul>
+ *    <li>Every {@code attach()} should have a {@code detach()} in the same method. And every
+ * CancellableContext should be cancelled at some point. Breaking these rules may lead to memory
+ * leaks.
+ *    <li>While Context objects are immutable they do not place such a restriction on the state
+ * they store.</li>
+ *    <li>Context is not intended for passing optional parameters to an API and developers should
+ * take care to avoid excessive dependence on context when designing an API.</li>
+ *    <li>Do not mock this class.  Use {@link #ROOT} for a non-null instance.
+ * </ul>
+ */
+/* @DoNotMock("Use ROOT for a non-null Context") // commented out to avoid dependencies  */
+@CheckReturnValue
+public class Context {
+
+  static final Logger log = Logger.getLogger(Context.class.getName());
+
+  // Long chains of contexts are suspicious and usually indicate a misuse of Context.
+  // The threshold is arbitrarily chosen.
+  // VisibleForTesting
+  static final int CONTEXT_DEPTH_WARN_THRESH = 1000;
+
+  /**
+   * The logical root context which is the ultimate ancestor of all contexts. This context
+   * is not cancellable and so will not cascade cancellation or retain listeners.
+   *
+   * <p>Never assume this is the default context for new threads, because {@link Storage} may define
+   * a default context that is different from ROOT.
+   */
+  public static final Context ROOT = new Context();
+
+  // Visible For testing
+  static Storage storage() {
+    return LazyStorage.storage;
+  }
+
+  // Lazy-loaded storage. Delaying storage initialization until after class initialization makes it
+  // much easier to avoid circular loading since there can still be references to Context as long as
+  // they don't depend on storage, like key() and currentContextExecutor(). It also makes it easier
+  // to handle exceptions.
+  private static final class LazyStorage {
+    static final Storage storage;
+
+    static {
+      AtomicReference<Throwable> deferredStorageFailure = new AtomicReference<>();
+      storage = createStorage(deferredStorageFailure);
+      Throwable failure = deferredStorageFailure.get();
+      // Logging must happen after storage has been set, as loggers may use Context.
+      if (failure != null) {
+        log.log(Level.FINE, "Storage override doesn't exist. Using default", failure);
+      }
+    }
+
+    private static Storage createStorage(
+        AtomicReference<? super ClassNotFoundException> deferredStorageFailure) {
+      try {
+        Class<?> clazz = Class.forName("io.grpc.override.ContextStorageOverride");
+        // The override's constructor is prohibited from triggering any code that can loop back to
+        // Context
+        return clazz.asSubclass(Storage.class).getConstructor().newInstance();
+      } catch (ClassNotFoundException e) {
+        deferredStorageFailure.set(e);
+        return new ThreadLocalContextStorage();
+      } catch (Exception e) {
+        throw new RuntimeException("Storage override failed to initialize", e);
+      }
+    }
+  }
+
+  /**
+   * Create a {@link Key} with the given debug name.
+   *
+   * @param debugString a name intended for debugging purposes and does not impact behavior.
+   *                    Multiple different keys may have the same debugString.
+   *                    The value should be not null.
+   */
+  public static <T> Key<T> key(String debugString) {
+    return new Key<>(debugString);
+  }
+
+  /**
+   * Create a {@link Key} with the given debug name and default value.
+   *
+   * @param debugString a name intended for debugging purposes and does not impact behavior.
+   *                    Multiple different keys may have the same debugString.
+   *                    The value should be not null.
+   */
+  public static <T> Key<T> keyWithDefault(String debugString, T defaultValue) {
+    return new Key<>(debugString, defaultValue);
+  }
+
+  /**
+   * Return the context associated with the current scope, will never return {@code null}.
+   *
+   * <p>Will never return {@link CancellableContext} even if one is attached, instead a
+   * {@link Context} is returned with the same properties and lifetime. This is to avoid
+   * code stealing the ability to cancel arbitrarily.
+   */
+  public static Context current() {
+    Context current = storage().current();
+    if (current == null) {
+      return ROOT;
+    }
+    return current;
+  }
+
+  final CancellableContext cancellableAncestor;
+  final Node<Key<?>, Object> keyValueEntries;
+  // The number parents between this context and the root context.
+  final int generation;
+
+  /**
+   * Construct a context that cannot be cancelled and will not cascade cancellation from its parent.
+   */
+  private Context(Node<Key<?>, Object> keyValueEntries, int generation) {
+    this.cancellableAncestor = null;
+    this.keyValueEntries = keyValueEntries;
+    this.generation = generation;
+    validateGeneration(generation);
+  }
+
+  /**
+   * Construct a context that cannot be cancelled but will cascade cancellation from its parent if
+   * it is cancellable.
+   */
+  private Context(Context parent, Node<Key<?>, Object> keyValueEntries) {
+    this.cancellableAncestor = cancellableAncestor(parent);
+    this.keyValueEntries = keyValueEntries;
+    this.generation = parent.generation + 1;
+    validateGeneration(generation);
+  }
+
+  /**
+   * Construct for {@link #ROOT}.
+   */
+  private Context() {
+    this.cancellableAncestor = null;
+    this.keyValueEntries = null;
+    this.generation = 0;
+    validateGeneration(generation);
+  }
+
+  /**
+   * Create a new context which is independently cancellable and also cascades cancellation from
+   * its parent. Callers <em>must</em> ensure that either {@link
+   * CancellableContext#cancel(Throwable)} or {@link CancellableContext#detachAndCancel(Context,
+   * Throwable)} are called at a later point, in order to allow this context to be garbage
+   * collected.
+   *
+   * <p>Sample usage:
+   * <pre>
+   *   Context.CancellableContext withCancellation = Context.current().withCancellation();
+   *   try {
+   *     withCancellation.run(new Runnable() {
+   *       public void run() {
+   *         Context current = Context.current();
+   *         while (!current.isCancelled()) {
+   *           keepWorking();
+   *         }
+   *       }
+   *     });
+   *   } finally {
+   *     withCancellation.cancel(null);
+   *   }
+   * </pre>
+   */
+  public CancellableContext withCancellation() {
+    return new CancellableContext(this);
+  }
+
+  /**
+   * Create a new context which will cancel itself after the given {@code duration} from now.
+   * The returned context will cascade cancellation of its parent. Callers may explicitly cancel
+   * the returned context prior to the deadline just as for {@link #withCancellation()}. If the unit
+   * of work completes before the deadline, the context should be explicitly cancelled to allow
+   * it to be garbage collected.
+   *
+   * <p>Sample usage:
+   * <pre>
+   *   Context.CancellableContext withDeadline = Context.current()
+   *       .withDeadlineAfter(5, TimeUnit.SECONDS, scheduler);
+   *   try {
+   *     withDeadline.run(new Runnable() {
+   *       public void run() {
+   *         Context current = Context.current();
+   *         while (!current.isCancelled()) {
+   *           keepWorking();
+   *         }
+   *       }
+   *     });
+   *   } finally {
+   *     withDeadline.cancel(null);
+   *   }
+   * </pre>
+   */
+  public CancellableContext withDeadlineAfter(long duration, TimeUnit unit,
+                                              ScheduledExecutorService scheduler) {
+    return withDeadline(Deadline.after(duration, unit), scheduler);
+  }
+
+  /**
+   * Create a new context which will cancel itself at the given {@link Deadline}.
+   * The returned context will cascade cancellation of its parent. Callers may explicitly cancel
+   * the returned context prior to the deadline just as for {@link #withCancellation()}. If the unit
+   * of work completes before the deadline, the context should be explicitly cancelled to allow
+   * it to be garbage collected.
+   *
+   * <p>Sample usage:
+   * <pre>
+   *   Context.CancellableContext withDeadline = Context.current()
+   *      .withDeadline(someReceivedDeadline, scheduler);
+   *   try {
+   *     withDeadline.run(new Runnable() {
+   *       public void run() {
+   *         Context current = Context.current();
+   *         while (!current.isCancelled() &amp;&amp; moreWorkToDo()) {
+   *           keepWorking();
+   *         }
+   *       }
+   *     });
+   *   } finally {
+   *     withDeadline.cancel(null);
+   *   }
+   * </pre>
+   */
+  public CancellableContext withDeadline(Deadline newDeadline, ScheduledExecutorService scheduler) {
+    checkNotNull(newDeadline, "deadline");
+    checkNotNull(scheduler, "scheduler");
+    Deadline existingDeadline = getDeadline();
+    boolean scheduleDeadlineCancellation = true;
+    if (existingDeadline != null && existingDeadline.compareTo(newDeadline) <= 0) {
+      // The new deadline won't have an effect, so ignore it
+      newDeadline = existingDeadline;
+      scheduleDeadlineCancellation = false;
+    }
+    CancellableContext newCtx = new CancellableContext(this, newDeadline);
+    if (scheduleDeadlineCancellation) {
+      newCtx.setUpDeadlineCancellation(newDeadline, scheduler);
+    }
+    return newCtx;
+  }
+
+  /**
+   * Create a new context with the given key value set. The new context will cascade cancellation
+   * from its parent.
+   *
+   <pre>
+   *   Context withCredential = Context.current().withValue(CRED_KEY, cred);
+   *   withCredential.run(new Runnable() {
+   *     public void run() {
+   *        readUserRecords(userId, CRED_KEY.get());
+   *     }
+   *   });
+   * </pre>
+   *
+   * <p>Note that multiple calls to {@link #withValue} can be chained together.
+   * That is,
+   *
+   * <pre>
+   * context.withValues(K1, V1, K2, V2);
+   * // is the same as
+   * context.withValue(K1, V1).withValue(K2, V2);
+   * </pre>
+   *
+   * <p>Nonetheless, {@link Context} should not be treated like a general purpose
+   * map with a large number of keys and values — combine multiple related items
+   * together into a single key instead of separating them. But if the items
+   * are unrelated, have separate keys for them.
+   */
+  public <V> Context withValue(Key<V> k1, V v1) {
+    Node<Key<?>, Object> newKeyValueEntries =
+        PersistentHashArrayMappedTrie.put(keyValueEntries, k1, v1);
+    return new Context(this, newKeyValueEntries);
+  }
+
+  /**
+   * Create a new context with the given key value set. The new context will cascade cancellation
+   * from its parent.
+   */
+  public <V1, V2> Context withValues(Key<V1> k1, V1 v1, Key<V2> k2, V2 v2) {
+    Node<Key<?>, Object> newKeyValueEntries =
+        PersistentHashArrayMappedTrie.put(keyValueEntries, k1, v1);
+    newKeyValueEntries = PersistentHashArrayMappedTrie.put(newKeyValueEntries, k2, v2);
+    return new Context(this, newKeyValueEntries);
+  }
+
+  /**
+   * Create a new context with the given key value set. The new context will cascade cancellation
+   * from its parent.
+   */
+  public <V1, V2, V3> Context withValues(Key<V1> k1, V1 v1, Key<V2> k2, V2 v2, Key<V3> k3, V3 v3) {
+    Node<Key<?>, Object> newKeyValueEntries =
+        PersistentHashArrayMappedTrie.put(keyValueEntries, k1, v1);
+    newKeyValueEntries = PersistentHashArrayMappedTrie.put(newKeyValueEntries, k2, v2);
+    newKeyValueEntries = PersistentHashArrayMappedTrie.put(newKeyValueEntries, k3, v3);
+    return new Context(this, newKeyValueEntries);
+  }
+
+  /**
+   * Create a new context with the given key value set. The new context will cascade cancellation
+   * from its parent.
+   *
+   * <p>For more than 4 key-value pairs, note that multiple calls to
+   * {@link #withValue} can be chained together. That is,
+   *
+   * <pre>
+   * context.withValues(K1, V1, K2, V2);
+   * // is the same as
+   * context.withValue(K1, V1).withValue(K2, V2);
+   * </pre>
+   *
+   * <p>Nonetheless, {@link Context} should not be treated like a general purpose
+   * map with a large number of keys and values — combine multiple related items
+   * together into a single key instead of separating them. But if the items
+   * are unrelated, have separate keys for them.
+   */
+  public <V1, V2, V3, V4> Context withValues(Key<V1> k1, V1 v1, Key<V2> k2, V2 v2,
+      Key<V3> k3, V3 v3, Key<V4> k4, V4 v4) {
+    Node<Key<?>, Object> newKeyValueEntries =
+        PersistentHashArrayMappedTrie.put(keyValueEntries, k1, v1);
+    newKeyValueEntries = PersistentHashArrayMappedTrie.put(newKeyValueEntries, k2, v2);
+    newKeyValueEntries = PersistentHashArrayMappedTrie.put(newKeyValueEntries, k3, v3);
+    newKeyValueEntries = PersistentHashArrayMappedTrie.put(newKeyValueEntries, k4, v4);
+    return new Context(this, newKeyValueEntries);
+  }
+
+  /**
+   * Create a new context which propagates the values of this context but does not cascade its
+   * cancellation.
+   */
+  public Context fork() {
+    return new Context(keyValueEntries, generation + 1);
+  }
+
+  /**
+   * Attach this context, thus enter a new scope within which this context is {@link #current}.  The
+   * previously current context is returned. It is allowed to attach contexts where {@link
+   * #isCancelled()} is {@code true}.
+   *
+   * <p>Instead of using {@code attach()} and {@link #detach(Context)} most use-cases are better
+   * served by using the {@link #run(Runnable)} or {@link #call(java.util.concurrent.Callable)} to
+   * execute work immediately within a context's scope. If work needs to be done in other threads it
+   * is recommended to use the 'wrap' methods or to use a propagating executor.
+   *
+   * <p>All calls to {@code attach()} should have a corresponding {@link #detach(Context)} within
+   * the same method:
+   * <pre>{@code Context previous = someContext.attach();
+   * try {
+   *   // Do work
+   * } finally {
+   *   someContext.detach(previous);
+   * }}</pre>
+   */
+  public Context attach() {
+    Context prev = storage().doAttach(this);
+    if (prev == null) {
+      return ROOT;
+    }
+    return prev;
+  }
+
+  /**
+   * Reverse an {@code attach()}, restoring the previous context and exiting the current scope.
+   *
+   * <p>This context should be the same context that was previously {@link #attach attached}.  The
+   * provided replacement should be what was returned by the same {@link #attach attach()} call.  If
+   * an {@code attach()} and a {@code detach()} meet above requirements, they match.
+   *
+   * <p>It is expected that between any pair of matching {@code attach()} and {@code detach()}, all
+   * {@code attach()}es and {@code detach()}es are called in matching pairs.  If this method finds
+   * that this context is not {@link #current current}, either you or some code in-between are not
+   * detaching correctly, and a SEVERE message will be logged but the context to attach will still
+   * be bound.  <strong>Never</strong> use {@code Context.current().detach()}, as this will
+   * compromise this error-detecting mechanism.
+   */
+  public void detach(Context toAttach) {
+    checkNotNull(toAttach, "toAttach");
+    storage().detach(this, toAttach);
+  }
+
+  // Visible for testing
+  boolean isCurrent() {
+    return current() == this;
+  }
+
+  /**
+   * Is this context cancelled.
+   */
+  public boolean isCancelled() {
+    if (cancellableAncestor == null) {
+      return false;
+    } else {
+      return cancellableAncestor.isCancelled();
+    }
+  }
+
+  /**
+   * If a context {@link #isCancelled()} then return the cause of the cancellation or
+   * {@code null} if context was cancelled without a cause. If the context is not yet cancelled
+   * will always return {@code null}.
+   *
+   * <p>The cancellation cause is provided for informational purposes only and implementations
+   * should generally assume that it has already been handled and logged properly.
+   */
+  public Throwable cancellationCause() {
+    if (cancellableAncestor == null) {
+      return null;
+    } else {
+      return cancellableAncestor.cancellationCause();
+    }
+  }
+
+  /**
+   * A context may have an associated {@link Deadline} at which it will be automatically cancelled.
+   * @return A {@link io.grpc.Deadline} or {@code null} if no deadline is set.
+   */
+  public Deadline getDeadline() {
+    if (cancellableAncestor == null) {
+      return null;
+    }
+    return cancellableAncestor.getDeadline();
+  }
+
+  /**
+   * Add a listener that will be notified when the context becomes cancelled.
+   */
+  public void addListener(final CancellationListener cancellationListener,
+                          final Executor executor) {
+    checkNotNull(cancellationListener, "cancellationListener");
+    checkNotNull(executor, "executor");
+    if (cancellableAncestor == null) {
+      return;
+    }
+    cancellableAncestor.addListenerInternal(
+        new ExecutableListener(executor, cancellationListener, this));
+  }
+
+  /**
+   * Remove a {@link CancellationListener}.
+   */
+  public void removeListener(CancellationListener cancellationListener) {
+    if (cancellableAncestor == null) {
+      return;
+    }
+    cancellableAncestor.removeListenerInternal(cancellationListener, this);
+  }
+
+  // Used in tests to ensure that listeners are defined and released when cancellation cascades.
+  // It's very important to ensure that we do not accidentally retain listeners.
+  int listenerCount() {
+    if (cancellableAncestor == null) {
+      return 0;
+    }
+    return cancellableAncestor.listenerCount();
+  }
+
+  /**
+   * Immediately run a {@link Runnable} with this context as the {@link #current} context.
+   * @param r {@link Runnable} to run.
+   */
+  public void run(Runnable r) {
+    Context previous = attach();
+    try {
+      r.run();
+    } finally {
+      detach(previous);
+    }
+  }
+
+  /**
+   * Immediately call a {@link Callable} with this context as the {@link #current} context.
+   * @param c {@link Callable} to call.
+   * @return result of call.
+   */
+  @CanIgnoreReturnValue
+  public <V> V call(Callable<V> c) throws Exception {
+    Context previous = attach();
+    try {
+      return c.call();
+    } finally {
+      detach(previous);
+    }
+  }
+
+  /**
+   * Wrap a {@link Runnable} so that it executes with this context as the {@link #current} context.
+   */
+  public Runnable wrap(final Runnable r) {
+    return new Runnable() {
+      @Override
+      public void run() {
+        Context previous = attach();
+        try {
+          r.run();
+        } finally {
+          detach(previous);
+        }
+      }
+    };
+  }
+
+  /**
+   * Wrap a {@link Callable} so that it executes with this context as the {@link #current} context.
+   */
+  public <C> Callable<C> wrap(final Callable<C> c) {
+    return new Callable<C>() {
+      @Override
+      public C call() throws Exception {
+        Context previous = attach();
+        try {
+          return c.call();
+        } finally {
+          detach(previous);
+        }
+      }
+    };
+  }
+
+  /**
+   * Wrap an {@link Executor} so that it always executes with this context as the {@link #current}
+   * context. It is generally expected that {@link #currentContextExecutor(Executor)} would be
+   * used more commonly than this method.
+   *
+   * <p>One scenario in which this executor may be useful is when a single thread is sharding work
+   * to multiple threads.
+   *
+   * @see #currentContextExecutor(Executor)
+   */
+  public Executor fixedContextExecutor(final Executor e) {
+    final class FixedContextExecutor implements Executor {
+      @Override
+      public void execute(Runnable r) {
+        e.execute(wrap(r));
+      }
+    }
+
+    return new FixedContextExecutor();
+  }
+
+  /**
+   * Create an executor that propagates the {@link #current} context when {@link Executor#execute}
+   * is called as the {@link #current} context of the {@code Runnable} scheduled. <em>Note that this
+   * is a static method.</em>
+   *
+   * @see #fixedContextExecutor(Executor)
+   */
+  public static Executor currentContextExecutor(final Executor e) {
+    final class CurrentContextExecutor implements Executor {
+      @Override
+      public void execute(Runnable r) {
+        e.execute(Context.current().wrap(r));
+      }
+    }
+
+    return new CurrentContextExecutor();
+  }
+
+  /**
+   * A context which inherits cancellation from its parent but which can also be independently
+   * cancelled and which will propagate cancellation to its descendants. To avoid leaking memory,
+   * every CancellableContext must have a defined lifetime, after which it is guaranteed to be
+   * cancelled.
+   *
+   * <p>This class must be cancelled by either calling {@link #close} or {@link #cancel}.
+   * {@link #close} is equivalent to calling {@code cancel(null)}. It is safe to call the methods
+   * more than once, but only the first call will have any effect. Because it's safe to call the
+   * methods multiple times, users are encouraged to always call {@link #close} at the end of
+   * the operation, and disregard whether {@link #cancel} was already called somewhere else.
+   *
+   * <p>Blocking code can use the try-with-resources idiom:
+   * <pre>
+   * try (CancellableContext c = Context.current()
+   *     .withDeadlineAfter(100, TimeUnit.MILLISECONDS, executor)) {
+   *   Context toRestore = c.attach();
+   *   try {
+   *     // do some blocking work
+   *   } finally {
+   *     c.detach(toRestore);
+   *   }
+   * }</pre>
+   *
+   * <p>Asynchronous code will have to manually track the end of the CancellableContext's lifetime,
+   * and cancel the context at the appropriate time.
+   */
+  public static final class CancellableContext extends Context implements Closeable {
+
+    private final Deadline deadline;
+    private final Context uncancellableSurrogate;
+
+    private ArrayList<ExecutableListener> listeners;
+    // parentListener is initialized when listeners is initialized (only if there is a
+    // cancellable ancestor), and uninitialized when listeners is uninitialized.
+    private CancellationListener parentListener;
+    private Throwable cancellationCause;
+    private ScheduledFuture<?> pendingDeadline;
+    private boolean cancelled;
+
+    /**
+     * Create a cancellable context that does not have a deadline.
+     */
+    private CancellableContext(Context parent) {
+      super(parent, parent.keyValueEntries);
+      deadline = parent.getDeadline();
+      // Create a surrogate that inherits from this to attach so that you cannot retrieve a
+      // cancellable context from Context.current()
+      uncancellableSurrogate = new Context(this, keyValueEntries);
+    }
+
+    /**
+     * Create a cancellable context that has a deadline.
+     */
+    private CancellableContext(Context parent, Deadline deadline) {
+      super(parent, parent.keyValueEntries);
+      this.deadline = deadline;
+      this.uncancellableSurrogate = new Context(this, keyValueEntries);
+    }
+
+    private void setUpDeadlineCancellation(Deadline deadline, ScheduledExecutorService scheduler) {
+      if (!deadline.isExpired()) {
+        final class CancelOnExpiration implements Runnable {
+          @Override
+          public void run() {
+            try {
+              cancel(new TimeoutException("context timed out"));
+            } catch (Throwable t) {
+              log.log(Level.SEVERE, "Cancel threw an exception, which should not happen", t);
+            }
+          }
+        }
+
+        synchronized (this) {
+          pendingDeadline = deadline.runOnExpiration(new CancelOnExpiration(), scheduler);
+        }
+      } else {
+        // Cancel immediately if the deadline is already expired.
+        cancel(new TimeoutException("context timed out"));
+      }
+    }
+
+    @Override
+    public Context attach() {
+      return uncancellableSurrogate.attach();
+    }
+
+    @Override
+    public void detach(Context toAttach) {
+      uncancellableSurrogate.detach(toAttach);
+    }
+
+    @Override
+    public void addListener(
+        final CancellationListener cancellationListener, final Executor executor) {
+      checkNotNull(cancellationListener, "cancellationListener");
+      checkNotNull(executor, "executor");
+      addListenerInternal(new ExecutableListener(executor, cancellationListener, this));
+    }
+
+    private void addListenerInternal(ExecutableListener executableListener) {
+      synchronized (this) {
+        if (isCancelled()) {
+          executableListener.deliver();
+        } else {
+          if (listeners == null) {
+            // Now that we have a listener we need to listen to our parent so
+            // we can cascade listener notification.
+            listeners = new ArrayList<>();
+            listeners.add(executableListener);
+            if (cancellableAncestor != null) {
+              parentListener =
+                  new CancellationListener() {
+                    @Override
+                    public void cancelled(Context context) {
+                      CancellableContext.this.cancel(context.cancellationCause());
+                    }
+                  };
+              cancellableAncestor.addListenerInternal(
+                  new ExecutableListener(DirectExecutor.INSTANCE, parentListener, this));
+            }
+          } else {
+            listeners.add(executableListener);
+          }
+        }
+      }
+    }
+
+    @Override
+    public void removeListener(CancellationListener cancellationListener) {
+      removeListenerInternal(cancellationListener, this);
+    }
+
+    private void removeListenerInternal(CancellationListener cancellationListener,
+        Context context) {
+      synchronized (this) {
+        if (listeners != null) {
+          for (int i = listeners.size() - 1; i >= 0; i--) {
+            ExecutableListener executableListener = listeners.get(i);
+            if (executableListener.listener == cancellationListener
+                && executableListener.context == context) {
+              listeners.remove(i);
+              // Just remove the first matching listener, given that we allow duplicate
+              // adds we should allow for duplicates after remove.
+              break;
+            }
+          }
+          // We have no listeners so no need to listen to our parent
+          if (listeners.isEmpty()) {
+            if (cancellableAncestor != null) {
+              cancellableAncestor.removeListener(parentListener);
+            }
+            parentListener = null;
+            listeners = null;
+          }
+        }
+      }
+    }
+
+    /**
+     * Returns true if the Context is the current context.
+     *
+     * @deprecated This method violates some GRPC class encapsulation and should not be used.
+     *     If you must know whether a Context is the current context, check whether it is the same
+     *     object returned by {@link Context#current()}.
+     */
+    //TODO(spencerfang): The superclass's method is package-private, so this should really match.
+    @Override
+    @Deprecated
+    public boolean isCurrent() {
+      return uncancellableSurrogate.isCurrent();
+    }
+
+    /**
+     * Cancel this context and optionally provide a cause (can be {@code null}) for the
+     * cancellation. This will trigger notification of listeners. It is safe to call this method
+     * multiple times. Only the first call will have any effect.
+     *
+     * <p>Calling {@code cancel(null)} is the same as calling {@link #close}.
+     *
+     * @return {@code true} if this context cancelled the context and notified listeners,
+     *         {@code false} if the context was already cancelled.
+     */
+    @CanIgnoreReturnValue
+    public boolean cancel(Throwable cause) {
+      boolean triggeredCancel = false;
+      ScheduledFuture<?> localPendingDeadline = null;
+      synchronized (this) {
+        if (!cancelled) {
+          cancelled = true;
+          if (pendingDeadline != null) {
+            // If we have a scheduled cancellation pending attempt to cancel it.
+            localPendingDeadline = pendingDeadline;
+            pendingDeadline = null;
+          }
+          this.cancellationCause = cause;
+          triggeredCancel = true;
+        }
+      }
+      if (localPendingDeadline != null) {
+        localPendingDeadline.cancel(false);
+      }
+      if (triggeredCancel) {
+        notifyAndClearListeners();
+      }
+      return triggeredCancel;
+    }
+
+    /**
+     * Notify all listeners that this context has been cancelled and immediately release
+     * any reference to them so that they may be garbage collected.
+     */
+    private void notifyAndClearListeners() {
+      ArrayList<ExecutableListener> tmpListeners;
+      CancellationListener tmpParentListener;
+      synchronized (this) {
+        if (listeners == null) {
+          return;
+        }
+        tmpParentListener = parentListener;
+        parentListener = null;
+        tmpListeners = listeners;
+        listeners = null;
+      }
+      // Deliver events to this context listeners before we notify child contexts. We do this
+      // to cancel higher level units of work before child units. This allows for a better error
+      // handling paradigm where the higher level unit of work knows it is cancelled and so can
+      // ignore errors that bubble up as a result of cancellation of lower level units.
+      for (ExecutableListener tmpListener : tmpListeners) {
+        if (tmpListener.context == this) {
+          tmpListener.deliver();
+        }
+      }
+      for (ExecutableListener tmpListener : tmpListeners) {
+        if (!(tmpListener.context == this)) {
+          tmpListener.deliver();
+        }
+      }
+      if (cancellableAncestor != null) {
+        cancellableAncestor.removeListener(tmpParentListener);
+      }
+    }
+
+    @Override
+    int listenerCount() {
+      synchronized (this) {
+        return listeners == null ? 0 : listeners.size();
+      }
+    }
+
+    /**
+     * Cancel this context and detach it as the current context.
+     *
+     * @param toAttach context to make current.
+     * @param cause of cancellation, can be {@code null}.
+     */
+    public void detachAndCancel(Context toAttach, Throwable cause) {
+      try {
+        detach(toAttach);
+      } finally {
+        cancel(cause);
+      }
+    }
+
+    @Override
+    public boolean isCancelled() {
+      synchronized (this) {
+        if (cancelled) {
+          return true;
+        }
+      }
+      // Detect cancellation of parent in the case where we have no listeners and
+      // record it.
+      if (super.isCancelled()) {
+        cancel(super.cancellationCause());
+        return true;
+      }
+      return false;
+    }
+
+    @Override
+    public Throwable cancellationCause() {
+      if (isCancelled()) {
+        return cancellationCause;
+      }
+      return null;
+    }
+
+    @Override
+    public Deadline getDeadline() {
+      return deadline;
+    }
+
+    /**
+     * Cleans up this object by calling {@code cancel(null)}.
+     */
+    @Override
+    public void close() {
+      cancel(null);
+    }
+  }
+
+  /**
+   * A listener notified on context cancellation.
+   */
+  public interface CancellationListener {
+    /**
+     * Notifies that a context was cancelled.
+     *
+     * @param context the newly cancelled context.
+     */
+    void cancelled(Context context);
+  }
+
+  /**
+   * Key for indexing values stored in a context. Keys use reference equality and Context does not
+   * provide a mechanism to loop over Keys. This means there is no way to access a Key's value from
+   * a Context without having access to the Key instance itself. This allows strong control over
+   * what code can get/set a key in the Context. For example, you might manage access to Key similar
+   * to a ThreadLocal using Java visibility (private/protected). Generally Keys are stored in static
+   * fields.
+   */
+  public static final class Key<T> {
+    private final String name;
+    private final T defaultValue;
+
+    Key(String name) {
+      this(name, null);
+    }
+
+    Key(String name, T defaultValue) {
+      this.name = checkNotNull(name, "name");
+      this.defaultValue = defaultValue;
+    }
+
+    /**
+     * Get the value from the {@link #current()} context for this key.
+     */
+    public T get() {
+      return get(Context.current());
+    }
+
+    /**
+     * Get the value from the specified context for this key.
+     */
+    @SuppressWarnings("unchecked")
+    public T get(Context context) {
+      T value = (T) PersistentHashArrayMappedTrie.get(context.keyValueEntries, this);
+      return value == null ? defaultValue : value;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
+
+  /**
+   * Defines the mechanisms for attaching and detaching the "current" context. The constructor for
+   * extending classes <em>must not</em> trigger any activity that can use Context, which includes
+   * logging, otherwise it can trigger an infinite initialization loop. Extending classes must not
+   * assume that only one instance will be created; Context guarantees it will only use one
+   * instance, but it may create multiple and then throw away all but one.
+   *
+   * <p>The default implementation will put the current context in a {@link ThreadLocal}.  If an
+   * alternative implementation named {@code io.grpc.override.ContextStorageOverride} exists in the
+   * classpath, it will be used instead of the default implementation.
+   *
+   * <p>This API is <a href="https://github.com/grpc/grpc-java/issues/2462">experimental</a> and
+   * subject to change.
+   */
+  public abstract static class Storage {
+    /**
+     * Implements {@link io.grpc.Context#attach}.
+     *
+     * <p>Caution: {@link Context#attach()} interprets a return value of {@code null} to mean
+     * the same thing as {@link Context#ROOT}.
+     *
+     * <p>See also: {@link #current()}.
+
+     * @param toAttach the context to be attached
+     * @return A {@link Context} that should be passed back into {@link #detach(Context, Context)}
+     *        as the {@code toRestore} parameter. {@code null} is a valid return value, but see
+     *        caution note.
+     */
+    public abstract Context doAttach(Context toAttach);
+
+    /**
+     * Implements {@link io.grpc.Context#detach}.
+     *
+     * @param toDetach the context to be detached. Should be, or be equivalent to, the current
+     *        context of the current scope
+     * @param toRestore the context to be the current.  Should be, or be equivalent to, the context
+     *        of the outer scope
+     */
+    public abstract void detach(Context toDetach, Context toRestore);
+
+    /**
+     * Implements {@link io.grpc.Context#current}.
+     *
+     * <p>Caution: {@link Context} interprets a return value of {@code null} to mean the same
+     * thing as {@link Context#ROOT}.
+     *
+     * <p>See also {@link #doAttach(Context)}.
+     *
+     * @return The context of the current scope. {@code null} is a valid return value, but see
+     *        caution note.
+     */
+    public abstract Context current();
+  }
+
+  /**
+   * Stores listener and executor pair.
+   */
+  private static final class ExecutableListener implements Runnable {
+    private final Executor executor;
+    final CancellationListener listener;
+    private final Context context;
+
+    ExecutableListener(Executor executor, CancellationListener listener, Context context) {
+      this.executor = executor;
+      this.listener = listener;
+      this.context = context;
+    }
+
+    void deliver() {
+      try {
+        executor.execute(this);
+      } catch (Throwable t) {
+        log.log(Level.INFO, "Exception notifying context listener", t);
+      }
+    }
+
+    @Override
+    public void run() {
+      listener.cancelled(context);
+    }
+  }
+
+  @CanIgnoreReturnValue
+  static <T> T checkNotNull(T reference, Object errorMessage) {
+    if (reference == null) {
+      throw new NullPointerException(String.valueOf(errorMessage));
+    }
+    return reference;
+  }
+
+  private enum DirectExecutor implements Executor {
+    INSTANCE;
+
+    @Override
+    public void execute(Runnable command) {
+      command.run();
+    }
+
+    @Override
+    public String toString() {
+      return "Context.DirectExecutor";
+    }
+  }
+
+  /**
+   * Returns {@code parent} if it is a {@link CancellableContext}, otherwise returns the parent's
+   * {@link #cancellableAncestor}.
+   */
+  static CancellableContext cancellableAncestor(Context parent) {
+    if (parent instanceof CancellableContext) {
+      return (CancellableContext) parent;
+    }
+    // The parent simply cascades cancellations.
+    // Bypass the parent and reference the ancestor directly (may be null).
+    return parent.cancellableAncestor;
+  }
+
+  /**
+   * If the ancestry chain length is unreasonably long, then print an error to the log and record
+   * the stack trace.
+   */
+  private static void validateGeneration(int generation) {
+    if (generation == CONTEXT_DEPTH_WARN_THRESH) {
+      log.log(
+          Level.SEVERE,
+          "Context ancestry chain length is abnormally long. "
+              + "This suggests an error in application code. "
+              + "Length exceeded: " + CONTEXT_DEPTH_WARN_THRESH,
+          new Exception());
+    }
+  }
+
+  // Not using the standard com.google.errorprone.annotations.CheckReturnValue because that will
+  // introduce dependencies that some io.grpc.Context API consumers may not want.
+  @interface CheckReturnValue {}
+
+  @interface CanIgnoreReturnValue {}
+}
diff --git a/api/src/context/java/io/grpc/Deadline.java b/api/src/context/java/io/grpc/Deadline.java
new file mode 100644
index 00000000000..92eeba5ffce
--- /dev/null
+++ b/api/src/context/java/io/grpc/Deadline.java
@@ -0,0 +1,288 @@
+/*
+ * Copyright 2016 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;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.Locale;
+import java.util.Objects;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * An absolute point in time, generally for tracking when a task should be completed. A deadline is
+ * immutable except for the passage of time causing it to expire.
+ *
+ * <p>Many systems use timeouts, which are relative to the start of the operation. However, being
+ * relative causes them to be poorly suited for managing higher-level tasks where there are many
+ * components and sub-operations that may not know the time of the initial "start of the operation."
+ * However, a timeout can be converted to a {@code Deadline} at the start of the operation and then
+ * passed to the various components unambiguously.
+ */
+public final class Deadline implements Comparable<Deadline> {
+  private static final Ticker SYSTEM_TICKER = new SystemTicker();
+  // nanoTime has a range of just under 300 years. Only allow up to 100 years in the past or future
+  // to prevent wraparound as long as process runs for less than ~100 years.
+  private static final long MAX_OFFSET = TimeUnit.DAYS.toNanos(100 * 365);
+  private static final long MIN_OFFSET = -MAX_OFFSET;
+  private static final long NANOS_PER_SECOND = TimeUnit.SECONDS.toNanos(1);
+
+  /**
+   * Returns the ticker that's based on system clock.
+   *
+   * <p>This is <strong>EXPERIMENTAL</strong> API and may subject to change.  If you'd like it to be
+   * stabilized or have any feedback, please
+   * <a href="https://github.com/grpc/grpc-java/issues/6030">let us know</a>.
+   *
+   * @since 1.24.0
+   */
+  public static Ticker getSystemTicker() {
+    return SYSTEM_TICKER;
+  }
+
+  /**
+   * Create a deadline that will expire at the specified offset based on the {@link #getSystemTicker
+   * system ticker}.
+   *
+   * <p>If the given offset is extraordinarily long, say 100 years, the actual deadline created
+   * might saturate.
+   *
+   * @param duration A non-negative duration.
+   * @param units The time unit for the duration.
+   * @return A new deadline.
+   */
+  public static Deadline after(long duration, TimeUnit units) {
+    return after(duration, units, SYSTEM_TICKER);
+  }
+
+  /**
+   * Create a deadline that will expire at the specified offset based on the given {@link Ticker}.
+   *
+   * <p>If the given offset is extraordinarily long, say 100 years, the actual deadline created
+   * might saturate.
+   *
+   * <p><strong>CAUTION</strong>: Only deadlines created with the same {@link Ticker} instance can
+   * be compared by methods like {@link #minimum}, {@link #isBefore} and {@link #compareTo}.  Custom
+   * Tickers should only be used in tests where you fake out the clock.  Always use the {@link
+   * #getSystemTicker system ticker} in production, or serious errors may occur.
+   *
+   * <p>This is <strong>EXPERIMENTAL</strong> API and may subject to change.  If you'd like it to be
+   * stabilized or have any feedback, please
+   * <a href="https://github.com/grpc/grpc-java/issues/6030">let us know</a>.
+   *
+   * @param duration A non-negative duration.
+   * @param units The time unit for the duration.
+   * @param ticker Where this deadline refer the current time
+   * @return A new deadline.
+   *
+   * @since 1.24.0
+   */
+  public static Deadline after(long duration, TimeUnit units, Ticker ticker) {
+    requireNonNull(units, "units");
+    return new Deadline(ticker, units.toNanos(duration), true);
+  }
+
+  private final Ticker ticker;
+  private final long deadlineNanos;
+  private volatile boolean expired;
+
+  private Deadline(Ticker ticker, long offset, boolean baseInstantAlreadyExpired) {
+    this(ticker, ticker.nanoTime(), offset, baseInstantAlreadyExpired);
+  }
+
+  private Deadline(Ticker ticker, long baseInstant, long offset,
+      boolean baseInstantAlreadyExpired) {
+    this.ticker = ticker;
+    // Clamp to range [MIN_OFFSET, MAX_OFFSET]
+    offset = Math.min(MAX_OFFSET, Math.max(MIN_OFFSET, offset));
+    deadlineNanos = baseInstant + offset;
+    expired = baseInstantAlreadyExpired && offset <= 0;
+  }
+
+  /**
+   * Returns whether this has deadline expired.
+   *
+   * @return {@code true} if it has, otherwise {@code false}.
+   */
+  public boolean isExpired() {
+    if (!expired) {
+      if (deadlineNanos - ticker.nanoTime() <= 0) {
+        expired = true;
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Is {@code this} deadline before another.  Two deadlines must be created using the same {@link
+   * Ticker}.
+   */
+  public boolean isBefore(Deadline other) {
+    checkTicker(other);
+    return this.deadlineNanos - other.deadlineNanos < 0;
+  }
+
+  /**
+   * Return the minimum deadline of {@code this} or an other deadline.  They must be created using
+   * the same {@link Ticker}.
+   *
+   * @param other deadline to compare with {@code this}.
+   */
+  public Deadline minimum(Deadline other) {
+    checkTicker(other);
+    return isBefore(other) ? this : other;
+  }
+
+  /**
+   * Create a new deadline that is offset from {@code this}.
+   *
+   * <p>If the given offset is extraordinarily long, say 100 years, the actual deadline created
+   * might saturate.
+   */
+  // TODO(ejona): This method can cause deadlines to grow too far apart. For example:
+  // Deadline.after(100 * 365, DAYS).offset(100 * 365, DAYS) would be less than
+  // Deadline.after(-100 * 365, DAYS)
+  public Deadline offset(long offset, TimeUnit units) {
+    // May already be expired
+    if (offset == 0) {
+      return this;
+    }
+    return new Deadline(ticker, deadlineNanos, units.toNanos(offset), isExpired());
+  }
+
+  /**
+   * How much time is remaining in the specified time unit. Internal units are maintained as
+   * nanoseconds and conversions are subject to the constraints documented for
+   * {@link TimeUnit#convert}. If there is no time remaining, the returned duration is how
+   * long ago the deadline expired.
+   */
+  public long timeRemaining(TimeUnit unit) {
+    final long nowNanos = ticker.nanoTime();
+    if (!expired && deadlineNanos - nowNanos <= 0) {
+      expired = true;
+    }
+    return unit.convert(deadlineNanos - nowNanos, TimeUnit.NANOSECONDS);
+  }
+
+  /**
+   * Schedule a task to be run when the deadline expires.
+   *
+   * <p>Note if this deadline was created with a custom {@link Ticker}, the {@code scheduler}'s
+   * underlying clock should be synchronized with that Ticker.  Otherwise the task won't be run at
+   * the expected point of time.
+   *
+   * @param task to run on expiration
+   * @param scheduler used to execute the task
+   * @return {@link ScheduledFuture} which can be used to cancel execution of the task
+   */
+  public ScheduledFuture<?> runOnExpiration(Runnable task, ScheduledExecutorService scheduler) {
+    requireNonNull(task, "task");
+    requireNonNull(scheduler, "scheduler");
+    return scheduler.schedule(task, deadlineNanos - ticker.nanoTime(), TimeUnit.NANOSECONDS);
+  }
+
+  @Override
+  public String toString() {
+    long remainingNanos = timeRemaining(TimeUnit.NANOSECONDS);
+    long seconds = Math.abs(remainingNanos) / NANOS_PER_SECOND;
+    long nanos = Math.abs(remainingNanos) % NANOS_PER_SECOND;
+
+    StringBuilder buf = new StringBuilder();
+    if (remainingNanos < 0) {
+      buf.append('-');
+    }
+    buf.append(seconds);
+    if (nanos > 0) {
+      buf.append(String.format(Locale.US, ".%09d", nanos));
+    }
+    buf.append("s from now");
+    if (ticker != SYSTEM_TICKER) {
+      buf.append(" (ticker=" + ticker + ")");
+    }
+    return buf.toString();
+  }
+
+  /**
+   * {@inheritDoc}
+   *
+   * <p>Both deadlines must be created with the same {@link Ticker}.
+   */
+  @Override
+  public int compareTo(Deadline that) {
+    checkTicker(that);
+    return Long.compare(this.deadlineNanos, that.deadlineNanos);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(this.ticker, this.deadlineNanos);
+  }
+
+  @Override
+  public boolean equals(final Object object) {
+    if (object == this) {
+      return true;
+    }
+    if (!(object instanceof Deadline)) {
+      return false;
+    }
+    final Deadline that = (Deadline) object;
+    if (this.ticker == null ? that.ticker != null : this.ticker != that.ticker) {
+      return false;
+    }
+    return this.deadlineNanos == that.deadlineNanos;
+  }
+
+  /**
+   * Time source representing nanoseconds since fixed but arbitrary point in time.
+   *
+   * <p>DO NOT use custom {@link Ticker} implementations in production, because deadlines created
+   * with custom tickers are incompatible with those created with the system ticker.  Always use
+   * the {@link #getSystemTicker system ticker} whenever you need to provide one in production code.
+   *
+   * <p>This is <strong>EXPERIMENTAL</strong> API and may subject to change.  If you'd like it to be
+   * stabilized or have any feedback, please
+   * <a href="https://github.com/grpc/grpc-java/issues/6030">let us know</a>.
+   *
+   * <p>In general implementations should be thread-safe, unless it's implemented and used in a
+   * localized environment (like unit tests) where you are sure the usages are synchronized.
+   *
+   * @since 1.24.0
+   */
+  public abstract static class Ticker {
+    /** Returns the number of nanoseconds elapsed since this ticker's reference point in time. */
+    public abstract long nanoTime();
+  }
+
+  private static final class SystemTicker extends Ticker {
+    @Override
+    public long nanoTime() {
+      return System.nanoTime();
+    }
+  }
+
+  private void checkTicker(Deadline other) {
+    if (ticker != other.ticker) {
+      throw new AssertionError(
+          "Tickers (" + ticker + " and " + other.ticker + ") don't match."
+          + " Custom Ticker should only be used in tests!");
+    }
+  }
+}
diff --git a/api/src/context/java/io/grpc/PersistentHashArrayMappedTrie.java b/api/src/context/java/io/grpc/PersistentHashArrayMappedTrie.java
new file mode 100644
index 00000000000..66ee8697226
--- /dev/null
+++ b/api/src/context/java/io/grpc/PersistentHashArrayMappedTrie.java
@@ -0,0 +1,301 @@
+/*
+ * Copyright 2017 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;
+
+import java.util.Arrays;
+
+/**
+ * A persistent (copy-on-write) hash tree/trie. Collisions are handled
+ * linearly. Delete is not supported, but replacement is. The implementation
+ * favors simplicity and low memory allocation during insertion. Although the
+ * asymptotics are good, it is optimized for small sizes like less than 20;
+ * "unbelievably large" would be 100.
+ *
+ * <p>Inspired by popcnt-based compression seen in Ideal Hash Trees, Phil
+ * Bagwell (2000). The rest of the implementation is ignorant of/ignores the
+ * paper.
+ */
+final class PersistentHashArrayMappedTrie {
+
+  private PersistentHashArrayMappedTrie() {}
+
+  /**
+   * Returns the value with the specified key, or {@code null} if it does not exist.
+   */
+  static <K,V> V get(Node<K,V> root, K key) {
+    if (root == null) {
+      return null;
+    }
+    return root.get(key, key.hashCode(), 0);
+  }
+
+  /**
+   * Returns a new trie where the key is set to the specified value.
+   */
+  static <K,V> Node<K,V> put(Node<K,V> root, K key, V value) {
+    if (root == null) {
+      return new Leaf<>(key, value);
+    }
+    return root.put(key, value, key.hashCode(), 0);
+  }
+
+  // Not actually annotated to avoid depending on guava
+  // @VisibleForTesting
+  static final class Leaf<K,V> implements Node<K,V> {
+    private final K key;
+    private final V value;
+
+    public Leaf(K key, V value) {
+      this.key = key;
+      this.value = value;
+    }
+
+    @Override
+    public int size() {
+      return 1;
+    }
+
+    @Override
+    public V get(K key, int hash, int bitsConsumed) {
+      if (this.key == key) {
+        return value;
+      } else {
+        return null;
+      }
+    }
+
+    @Override
+    public Node<K,V> put(K key, V value, int hash, int bitsConsumed) {
+      int thisHash = this.key.hashCode();
+      if (thisHash != hash) {
+        // Insert
+        return CompressedIndex.combine(
+            new Leaf<>(key, value), hash, this, thisHash, bitsConsumed);
+      } else if (this.key == key) {
+        // Replace
+        return new Leaf<>(key, value);
+      } else {
+        // Hash collision
+        return new CollisionLeaf<>(this.key, this.value, key, value);
+      }
+    }
+
+    @Override
+    public String toString() {
+      return String.format("Leaf(key=%s value=%s)", key, value);
+    }
+  }
+
+  // Not actually annotated to avoid depending on guava
+  // @VisibleForTesting
+  static final class CollisionLeaf<K,V> implements Node<K,V> {
+    // All keys must have same hash, but not have the same reference
+    private final K[] keys;
+    private final V[] values;
+
+    // Not actually annotated to avoid depending on guava
+    // @VisibleForTesting
+    @SuppressWarnings("unchecked")
+    CollisionLeaf(K key1, V value1, K key2, V value2) {
+      this((K[]) new Object[] {key1, key2}, (V[]) new Object[] {value1, value2});
+      assert key1 != key2;
+      assert key1.hashCode() == key2.hashCode();
+    }
+
+    private CollisionLeaf(K[] keys, V[] values) {
+      this.keys = keys;
+      this.values = values;
+    }
+
+    @Override
+    public int size() {
+      return values.length;
+    }
+
+    @Override
+    public V get(K key, int hash, int bitsConsumed) {
+      for (int i = 0; i < keys.length; i++) {
+        if (keys[i] == key) {
+          return values[i];
+        }
+      }
+      return null;
+    }
+
+    @Override
+    public Node<K,V> put(K key, V value, int hash, int bitsConsumed) {
+      int thisHash = keys[0].hashCode();
+      int keyIndex;
+      if (thisHash != hash) {
+        // Insert
+        return CompressedIndex.combine(
+            new Leaf<>(key, value), hash, this, thisHash, bitsConsumed);
+      } else if ((keyIndex = indexOfKey(key)) != -1) {
+        // Replace
+        K[] newKeys = Arrays.copyOf(keys, keys.length);
+        V[] newValues = Arrays.copyOf(values, keys.length);
+        newKeys[keyIndex] = key;
+        newValues[keyIndex] = value;
+        return new CollisionLeaf<>(newKeys, newValues);
+      } else {
+        // Yet another hash collision
+        K[] newKeys = Arrays.copyOf(keys, keys.length + 1);
+        V[] newValues = Arrays.copyOf(values, keys.length + 1);
+        newKeys[keys.length] = key;
+        newValues[keys.length] = value;
+        return new CollisionLeaf<>(newKeys, newValues);
+      }
+    }
+
+    // -1 if not found
+    private int indexOfKey(K key) {
+      for (int i = 0; i < keys.length; i++) {
+        if (keys[i] == key) {
+          return i;
+        }
+      }
+      return -1;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder valuesSb = new StringBuilder();
+      valuesSb.append("CollisionLeaf(");
+      for (int i = 0; i < values.length; i++) {
+        valuesSb.append("(key=").append(keys[i]).append(" value=").append(values[i]).append(") ");
+      }
+      return valuesSb.append(")").toString();
+    }
+  }
+
+  // Not actually annotated to avoid depending on guava
+  // @VisibleForTesting
+  static final class CompressedIndex<K,V> implements Node<K,V> {
+    private static final int BITS = 5;
+    private static final int BITS_MASK = 0x1F;
+
+    final int bitmap;
+    final Node<K,V>[] values;
+    private final int size;
+
+    private CompressedIndex(int bitmap, Node<K,V>[] values, int size) {
+      this.bitmap = bitmap;
+      this.values = values;
+      this.size = size;
+    }
+
+    @Override
+    public int size() {
+      return size;
+    }
+
+    @Override
+    public V get(K key, int hash, int bitsConsumed) {
+      int indexBit = indexBit(hash, bitsConsumed);
+      if ((bitmap & indexBit) == 0) {
+        return null;
+      }
+      int compressedIndex = compressedIndex(indexBit);
+      return values[compressedIndex].get(key, hash, bitsConsumed + BITS);
+    }
+
+    @Override
+    public Node<K,V> put(K key, V value, int hash, int bitsConsumed) {
+      int indexBit = indexBit(hash, bitsConsumed);
+      int compressedIndex = compressedIndex(indexBit);
+      if ((bitmap & indexBit) == 0) {
+        // Insert
+        int newBitmap = bitmap | indexBit;
+        @SuppressWarnings("unchecked")
+        Node<K,V>[] newValues = (Node<K,V>[]) new Node<?,?>[values.length + 1];
+        System.arraycopy(values, 0, newValues, 0, compressedIndex);
+        newValues[compressedIndex] = new Leaf<>(key, value);
+        System.arraycopy(
+            values,
+            compressedIndex,
+            newValues,
+            compressedIndex + 1,
+            values.length - compressedIndex);
+        return new CompressedIndex<>(newBitmap, newValues, size() + 1);
+      } else {
+        // Replace
+        Node<K,V>[] newValues = Arrays.copyOf(values, values.length);
+        newValues[compressedIndex] =
+            values[compressedIndex].put(key, value, hash, bitsConsumed + BITS);
+        int newSize = size();
+        newSize += newValues[compressedIndex].size();
+        newSize -= values[compressedIndex].size();
+        return new CompressedIndex<>(bitmap, newValues, newSize);
+      }
+    }
+
+    static <K,V> Node<K,V> combine(
+        Node<K,V> node1, int hash1, Node<K,V> node2, int hash2, int bitsConsumed) {
+      assert hash1 != hash2;
+      int indexBit1 = indexBit(hash1, bitsConsumed);
+      int indexBit2 = indexBit(hash2, bitsConsumed);
+      if (indexBit1 == indexBit2) {
+        Node<K,V> node = combine(node1, hash1, node2, hash2, bitsConsumed + BITS);
+        @SuppressWarnings("unchecked")
+        Node<K,V>[] values = (Node<K,V>[]) new Node<?,?>[] {node};
+        return new CompressedIndex<>(indexBit1, values, node.size());
+      } else {
+        // Make node1 the smallest
+        if (uncompressedIndex(hash1, bitsConsumed) > uncompressedIndex(hash2, bitsConsumed)) {
+          Node<K,V> nodeCopy = node1;
+          node1 = node2;
+          node2 = nodeCopy;
+        }
+        @SuppressWarnings("unchecked")
+        Node<K,V>[] values = (Node<K,V>[]) new Node<?,?>[] {node1, node2};
+        return new CompressedIndex<>(indexBit1 | indexBit2, values, node1.size() + node2.size());
+      }
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder valuesSb = new StringBuilder();
+      valuesSb.append("CompressedIndex(")
+          .append(String.format("bitmap=%s ", Integer.toBinaryString(bitmap)));
+      for (Node<K, V> value : values) {
+        valuesSb.append(value).append(" ");
+      }
+      return valuesSb.append(")").toString();
+    }
+
+    private int compressedIndex(int indexBit) {
+      return Integer.bitCount(bitmap & (indexBit - 1));
+    }
+
+    private static int uncompressedIndex(int hash, int bitsConsumed) {
+      return (hash >>> bitsConsumed) & BITS_MASK;
+    }
+
+    private static int indexBit(int hash, int bitsConsumed) {
+      int uncompressedIndex = uncompressedIndex(hash, bitsConsumed);
+      return 1 << uncompressedIndex;
+    }
+  }
+
+  interface Node<K,V> {
+    V get(K key, int hash, int bitsConsumed);
+
+    Node<K,V> put(K key, V value, int hash, int bitsConsumed);
+
+    int size();
+  }
+}
diff --git a/api/src/context/java/io/grpc/ThreadLocalContextStorage.java b/api/src/context/java/io/grpc/ThreadLocalContextStorage.java
new file mode 100644
index 00000000000..63f560462aa
--- /dev/null
+++ b/api/src/context/java/io/grpc/ThreadLocalContextStorage.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2016 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;
+
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A {@link ThreadLocal}-based context storage implementation.  Used by default.
+ */
+final class ThreadLocalContextStorage extends Context.Storage {
+  private static final Logger log = Logger.getLogger(ThreadLocalContextStorage.class.getName());
+
+  /**
+   * Currently bound context.
+   */
+  // VisibleForTesting
+  static final ThreadLocal<Context> localContext = new ThreadLocal<>();
+
+  @Override
+  public Context doAttach(Context toAttach) {
+    Context current = current();
+    localContext.set(toAttach);
+    return current;
+  }
+
+  @Override
+  public void detach(Context toDetach, Context toRestore) {
+    if (current() != toDetach) {
+      // Log a severe message instead of throwing an exception as the context to attach is assumed
+      // to be the correct one and the unbalanced state represents a coding mistake in a lower
+      // layer in the stack that cannot be recovered from here.
+      log.log(Level.SEVERE, "Context was not attached when detaching",
+          new Throwable().fillInStackTrace());
+    }
+    if (toRestore != Context.ROOT) {
+      localContext.set(toRestore);
+    } else {
+      // Avoid leaking our ClassLoader via ROOT if this Thread is reused across multiple
+      // ClassLoaders, as is common for Servlet Containers. The ThreadLocal is weakly referenced by
+      // the Thread, but its current value is strongly referenced and only lazily collected as new
+      // ThreadLocals are created.
+      //
+      // Use set(null) instead of remove() since remove() deletes the entry which is then re-created
+      // on the next get() (because of initialValue() handling). set(null) has same performance as
+      // set(toRestore).
+      localContext.set(null);
+    }
+  }
+
+  @Override
+  public Context current() {
+    Context current = localContext.get();
+    if (current == null) {
+      return Context.ROOT;
+    }
+    return current;
+  }
+}
diff --git a/api/src/jmh/java/io/grpc/AttachDetachBenchmark.java b/api/src/jmh/java/io/grpc/AttachDetachBenchmark.java
new file mode 100644
index 00000000000..10e845e7928
--- /dev/null
+++ b/api/src/jmh/java/io/grpc/AttachDetachBenchmark.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2016 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;
+
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.GroupThreads;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+
+/** StatusBenchmark. */
+@State(Scope.Benchmark)
+public class AttachDetachBenchmark {
+
+  private final Context.Key<Integer> key = Context.keyWithDefault("key", 9999);
+  private final Context cu = Context.current().withValue(key, 8888);
+
+  /**
+   * Javadoc comment.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  @GroupThreads(6)
+  public int attachDetach() {
+    Context old = cu.attach();
+    try {
+      return key.get();
+    } finally {
+      Context.current().detach(old);
+    }
+  }
+}
diff --git a/api/src/jmh/java/io/grpc/AttributesBenchmark.java b/api/src/jmh/java/io/grpc/AttributesBenchmark.java
new file mode 100644
index 00000000000..f387b81947c
--- /dev/null
+++ b/api/src/jmh/java/io/grpc/AttributesBenchmark.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2017 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;
+
+
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+
+/**
+ * Javadoc.
+ */
+@State(Scope.Benchmark)
+public class AttributesBenchmark {
+
+  public Attributes base = Attributes.EMPTY;
+
+  public Attributes.Key<Object>[] keys;
+  public Attributes withValue = base;
+
+  /**
+   * Javadoc.
+   */
+  @Setup
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  public void setUp() {
+    keys = new Attributes.Key[iterations];
+    for (int i = 0; i < iterations; i++) {
+      keys[i] = Attributes.Key.create("any");
+      withValue = withValue.toBuilder().set(keys[i], "yes").build();
+    }
+  }
+
+  @Param({"1", "2", "10"})
+  public int iterations;
+
+  /**
+   * Javadoc.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public Attributes chain() {
+    Attributes attr = base;
+    for (int i = 0; i < iterations; i++) {
+      attr = attr.toBuilder().set(keys[i], new Object()).build();
+    }
+    return attr;
+  }
+
+  /**
+   * Javadoc.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public Object lookup() {
+    return withValue.get(keys[0]);
+  }
+}
diff --git a/api/src/jmh/java/io/grpc/CallOptionsBenchmark.java b/api/src/jmh/java/io/grpc/CallOptionsBenchmark.java
new file mode 100644
index 00000000000..663a0b14bfb
--- /dev/null
+++ b/api/src/jmh/java/io/grpc/CallOptionsBenchmark.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2016 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;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+
+/**
+ * Call options benchmark.
+ */
+@State(Scope.Benchmark)
+public class CallOptionsBenchmark {
+
+  @Param({"1", "2", "4", "8"})
+  public int customOptionsCount;
+
+  private List<CallOptions.Key<String>> customOptions;
+
+  private CallOptions allOpts;
+  private List<CallOptions.Key<String>> shuffledCustomOptions;
+
+  /**
+   * Setup.
+   */
+  @Setup
+  public void setUp() throws Exception {
+    customOptions = new ArrayList<>(customOptionsCount);
+    for (int i = 0; i < customOptionsCount; i++) {
+      customOptions.add(CallOptions.Key.createWithDefault("name " + i, "defaultvalue"));
+    }
+
+    allOpts = CallOptions.DEFAULT;
+    for (int i = 0; i < customOptionsCount; i++) {
+      allOpts = allOpts.withOption(customOptions.get(i), "value");
+    }
+
+    shuffledCustomOptions = new ArrayList<>(customOptions);
+    // Make the shuffling deterministic
+    Collections.shuffle(shuffledCustomOptions, new Random(1));
+  }
+
+  /**
+   * Adding custom call options without duplicate keys.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public CallOptions withOption() {
+    CallOptions opts = CallOptions.DEFAULT;
+    for (int i = 0; i < customOptions.size(); i++) {
+      opts = opts.withOption(customOptions.get(i), "value");
+    }
+    return opts;
+  }
+
+  /**
+   * Adding custom call options, overwritting existing keys.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public CallOptions withOptionDuplicates() {
+    CallOptions opts = allOpts;
+    for (int i = 1; i < shuffledCustomOptions.size(); i++) {
+      opts = opts.withOption(shuffledCustomOptions.get(i), "value2");
+    }
+    return opts;
+  }
+}
diff --git a/api/src/jmh/java/io/grpc/DecompressorRegistryBenchmark.java b/api/src/jmh/java/io/grpc/DecompressorRegistryBenchmark.java
new file mode 100644
index 00000000000..65af12ea0a1
--- /dev/null
+++ b/api/src/jmh/java/io/grpc/DecompressorRegistryBenchmark.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2016 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;
+
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.TransportFrameUtil;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+
+/**
+ * Decomressor Registry encoding benchmark.
+ */
+@State(Scope.Benchmark)
+public class DecompressorRegistryBenchmark {
+
+  @Param({"0", "1", "2"})
+  public int extraEncodings;
+
+  private DecompressorRegistry reg = DecompressorRegistry.getDefaultInstance();
+
+  @Setup
+  public void setUp() throws Exception {
+    reg = DecompressorRegistry.getDefaultInstance();
+    for (int i = 0; i < extraEncodings; i++) {
+      reg = reg.with(new Decompressor() {
+
+        @Override
+        public String getMessageEncoding() {
+          return UUID.randomUUID().toString();
+
+        }
+
+        @Override
+        public InputStream decompress(InputStream is) throws IOException {
+          return null;
+
+        }
+      }, true);
+    }
+  }
+
+  /**
+   * Javadoc comment.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public byte[][] marshalOld() {
+    Metadata m = new Metadata();
+    m.put(
+        GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY,
+        InternalDecompressorRegistry.getRawAdvertisedMessageEncodings(reg));
+    return TransportFrameUtil.toHttp2Headers(m);
+  }
+}
+
diff --git a/api/src/jmh/java/io/grpc/ReadBenchmark.java b/api/src/jmh/java/io/grpc/ReadBenchmark.java
new file mode 100644
index 00000000000..8046008bec6
--- /dev/null
+++ b/api/src/jmh/java/io/grpc/ReadBenchmark.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2017 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;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.infra.Blackhole;
+
+/** Read benchmark. */
+public class ReadBenchmark {
+
+  @State(Scope.Benchmark)
+  public static class ContextState {
+    List<Context.Key<Object>> keys = new ArrayList<>();
+    List<Context> contexts = new ArrayList<>();
+
+    @Setup
+    public void setup() {
+      for (int i = 0; i < 8; i++) {
+        keys.add(Context.key("Key" + i));
+      }
+      contexts.add(Context.ROOT.withValue(keys.get(0), new Object()));
+      contexts.add(Context.ROOT.withValues(keys.get(0), new Object(), keys.get(1), new Object()));
+      contexts.add(
+          Context.ROOT.withValues(
+              keys.get(0), new Object(), keys.get(1), new Object(), keys.get(2), new Object()));
+      contexts.add(
+          Context.ROOT.withValues(
+              keys.get(0),
+              new Object(),
+              keys.get(1),
+              new Object(),
+              keys.get(2),
+              new Object(),
+              keys.get(3),
+              new Object()));
+      contexts.add(contexts.get(0).withValue(keys.get(1), new Object()));
+      contexts.add(
+          contexts.get(1).withValues(keys.get(2), new Object(), keys.get(3), new Object()));
+      contexts.add(
+          contexts
+              .get(2)
+              .withValues(
+                  keys.get(3), new Object(), keys.get(4), new Object(), keys.get(5), new Object()));
+      contexts.add(
+          contexts
+              .get(3)
+              .withValues(
+                  keys.get(4),
+                  new Object(),
+                  keys.get(5),
+                  new Object(),
+                  keys.get(6),
+                  new Object(),
+                  keys.get(7),
+                  new Object()));
+    }
+  }
+
+  /** Perform the read operation. */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public void testContextLookup(ContextState state, Blackhole bh) {
+    for (Context.Key<?> key : state.keys) {
+      for (Context ctx : state.contexts) {
+        bh.consume(key.get(ctx));
+      }
+    }
+  }
+}
diff --git a/api/src/jmh/java/io/grpc/StatusBenchmark.java b/api/src/jmh/java/io/grpc/StatusBenchmark.java
new file mode 100644
index 00000000000..e3f087c6204
--- /dev/null
+++ b/api/src/jmh/java/io/grpc/StatusBenchmark.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2016 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;
+
+import java.nio.charset.Charset;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+
+/** StatusBenchmark. */
+@State(Scope.Benchmark)
+public class StatusBenchmark {
+
+  /**
+   * Javadoc comment.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public byte[] messageEncodePlain() {
+    return Status.MESSAGE_KEY.toBytes("Unexpected RST in stream");
+  }
+
+  /**
+   * Javadoc comment.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public byte[] messageEncodeEscape() {
+    return Status.MESSAGE_KEY.toBytes("Some Error\nWasabi and Horseradish are the same");
+  }
+
+  /**
+   * Javadoc comment.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public String messageDecodePlain() {
+    return Status.MESSAGE_KEY.parseBytes(
+        "Unexpected RST in stream".getBytes(Charset.forName("US-ASCII")));
+  }
+
+  /**
+   * Javadoc comment.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public String messageDecodeEscape() {
+    return Status.MESSAGE_KEY.parseBytes(
+        "Some Error%10Wasabi and Horseradish are the same".getBytes(Charset.forName("US-ASCII")));
+  }
+
+  /**
+   * Javadoc comment.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public byte[] codeEncode() {
+    return Status.CODE_KEY.toBytes(Status.DATA_LOSS);
+  }
+
+  /**
+   * Javadoc comment.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public Status codeDecode() {
+    return Status.CODE_KEY.parseBytes("15".getBytes(Charset.forName("US-ASCII")));
+  }
+}
+
diff --git a/api/src/jmh/java/io/grpc/WriteBenchmark.java b/api/src/jmh/java/io/grpc/WriteBenchmark.java
new file mode 100644
index 00000000000..d4c27053e71
--- /dev/null
+++ b/api/src/jmh/java/io/grpc/WriteBenchmark.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2017 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;
+
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.infra.Blackhole;
+
+/** Write benchmark. */
+public class WriteBenchmark {
+  @State(Scope.Thread)
+  public static class ContextState {
+    @Param({"0", "10", "25", "100"})
+    public int preexistingKeys;
+
+    Context.Key<Object> key1 = Context.key("key1");
+    Context.Key<Object> key2 = Context.key("key2");
+    Context.Key<Object> key3 = Context.key("key3");
+    Context.Key<Object> key4 = Context.key("key4");
+    Context context;
+    Object val = new Object();
+
+    @Setup
+    public void setup() {
+      context = Context.ROOT;
+      for (int i = 0; i < preexistingKeys; i++) {
+        context = context.withValue(Context.key("preexisting_key" + i), val);
+      }
+    }
+  }
+
+  /** Perform the write operation. */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public Context doWrite(ContextState state, Blackhole bh) {
+    return state.context.withValues(
+        state.key1, state.val,
+        state.key2, state.val,
+        state.key3, state.val,
+        state.key4, state.val);
+  }
+}
diff --git a/api/src/main/java/io/grpc/Attributes.java b/api/src/main/java/io/grpc/Attributes.java
new file mode 100644
index 00000000000..c8550d176b4
--- /dev/null
+++ b/api/src/main/java/io/grpc/Attributes.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright 2015 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Objects;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * An immutable type-safe container of attributes.
+ *
+ * <h3>Annotation semantics</h3>
+ *
+ * <p>As a convention, annotations such as {@link Grpc.TransportAttr} is defined to associate
+ * attribute {@link Key}s and their propagation paths.  The annotation may be applied to a {@code
+ * Key} definition field, a method that returns {@link Attributes}, or a variable of type {@link
+ * Attributes}, to indicate that the annotated {@link Attributes} objects may contain the annotated
+ * {@code Key}.
+ *
+ * <p>Javadoc users may click "USE" on the navigation bars of the annotation's javadoc page to view
+ * references of such annotation.
+ *
+ * @since 1.13.0
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1764")
+@Immutable
+public final class Attributes {
+
+  private final IdentityHashMap<Key<?>, Object> data;
+
+  private static final IdentityHashMap<Key<?>, Object> EMPTY_MAP =
+      new IdentityHashMap<Key<?>, Object>();
+  public static final Attributes EMPTY = new Attributes(EMPTY_MAP);
+
+  private Attributes(IdentityHashMap<Key<?>, Object> data) {
+    assert data != null;
+    this.data = data;
+  }
+
+  /**
+   * Gets the value for the key, or {@code null} if it's not present.
+   */
+  @SuppressWarnings("unchecked")
+  @Nullable
+  public <T> T get(Key<T> key) {
+    return (T) data.get(key);
+  }
+
+  /**
+   * Returns set of keys stored in container.
+   *
+   * @return Set of Key objects.
+   * @deprecated This method is being considered for removal, if you feel this method is needed
+   *     please reach out on this Github issue:
+   *     <a href="https://github.com/grpc/grpc-java/issues/1764">grpc-java/issues/1764</a>.
+   */
+  @Deprecated
+  public Set<Key<?>> keys() {
+    return Collections.unmodifiableSet(data.keySet());
+  }
+
+  Set<Key<?>> keysForTest() {
+    return Collections.unmodifiableSet(data.keySet());
+  }
+
+  /**
+   * Create a new builder that is pre-populated with the content from a given container.
+   * @deprecated Use {@link Attributes#toBuilder()} on the {@link Attributes} instance instead.
+   *     This method will be removed in the future.
+   */
+  @Deprecated
+  public static Builder newBuilder(Attributes base) {
+    checkNotNull(base, "base");
+    return new Builder(base);
+  }
+
+  /**
+   * Create a new builder.
+   */
+  public static Builder newBuilder() {
+    return new Builder(EMPTY);
+  }
+
+  /**
+   * Creates a new builder that is pre-populated with the content of this container.
+   * @return a new builder.
+   */
+  public Builder toBuilder() {
+    return new Builder(this);
+  }
+
+  /**
+   * Key for an key-value pair. Uses reference equality.
+   *
+   * @param <T> type of the value in the key-value pair
+   */
+  @Immutable
+  @SuppressWarnings("UnusedTypeParameter")
+  public static final class Key<T> {
+    private final String debugString;
+
+    private Key(String debugString) {
+      this.debugString = debugString;
+    }
+
+    @Override
+    public String toString() {
+      return debugString;
+    }
+
+    /**
+     * Factory method for creating instances of {@link Key}.
+     *
+     * @param debugString a string used to describe the key, used for debugging.
+     * @param <T> Key type
+     * @return Key object
+     * @deprecated use {@link #create} instead. This method will be removed in the future.
+     */
+    @Deprecated
+    public static <T> Key<T> of(String debugString) {
+      return new Key<>(debugString);
+    }
+
+    /**
+     * Factory method for creating instances of {@link Key}.
+     *
+     * @param debugString a string used to describe the key, used for debugging.
+     * @param <T> Key type
+     * @return Key object
+     */
+    public static <T> Key<T> create(String debugString) {
+      return new Key<>(debugString);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return data.toString();
+  }
+
+  /**
+   * Returns true if the given object is also a {@link Attributes} with an equal attribute values.
+   *
+   * <p>Note that if a stored values are mutable, it is possible for two objects to be considered
+   * equal at one point in time and not equal at another (due to concurrent mutation of attribute
+   * values).
+   *
+   * <p>This method is not implemented efficiently and is meant for testing.
+   *
+   * @param o an object.
+   * @return true if the given object is a {@link Attributes} equal attributes.
+   */
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    Attributes that = (Attributes) o;
+    if (data.size() != that.data.size()) {
+      return false;
+    }
+    for (Map.Entry<Key<?>, Object> e : data.entrySet()) {
+      if (!that.data.containsKey(e.getKey())) {
+        return false;
+      }
+      if (!Objects.equal(e.getValue(), that.data.get(e.getKey()))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Returns a hash code for the attributes.
+   *
+   * <p>Note that if a stored values are mutable, it is possible for two objects to be considered
+   * equal at one point in time and not equal at another (due to concurrent mutation of attribute
+   * values).
+   *
+   * @return a hash code for the attributes map.
+   */
+  @Override
+  public int hashCode() {
+    int hashCode = 0;
+    for (Map.Entry<Key<?>, Object> e : data.entrySet()) {
+      hashCode += Objects.hashCode(e.getKey(), e.getValue());
+    }
+    return hashCode;
+  }
+
+  /**
+   * The helper class to build an Attributes instance.
+   */
+  public static final class Builder {
+    // Exactly one of base and newdata will be set
+    private Attributes base;
+    private IdentityHashMap<Key<?>, Object> newdata;
+
+    private Builder(Attributes base) {
+      assert base != null;
+      this.base = base;
+    }
+
+    private IdentityHashMap<Key<?>, Object> data(int size) {
+      if (newdata == null) {
+        newdata = new IdentityHashMap<>(base.data.size() + size);
+        newdata.putAll(base.data);
+        base = null;
+      }
+      assert base == null;
+      return newdata;
+    }
+
+    public <T> Builder set(Key<T> key, T value) {
+      data(1).put(key, value);
+      return this;
+    }
+
+    /**
+     * Removes the key and associated value from the attributes.
+     *
+     * @since 1.22.0
+     * @param key The key to remove
+     * @return this
+     */
+    public <T> Builder discard(Key<T> key) {
+      if (base != null) {
+        if (base.data.containsKey(key)) {
+          data(0).remove(key);
+        }
+      } else {
+        newdata.remove(key);
+      }
+      return this;
+    }
+
+    public Builder setAll(Attributes other) {
+      data(other.data.size()).putAll(other.data);
+      return this;
+    }
+
+    /**
+     * Build the attributes.
+     */
+    public Attributes build() {
+      if (newdata != null) {
+        base = new Attributes(newdata);
+        newdata = null;
+      }
+      return base;
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/BinaryLog.java b/api/src/main/java/io/grpc/BinaryLog.java
new file mode 100644
index 00000000000..9d11b63cf52
--- /dev/null
+++ b/api/src/main/java/io/grpc/BinaryLog.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2018, gRPC Authors All rights reserved.
+ *
+ * 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;
+
+import java.io.Closeable;
+
+/**
+ * A binary log that can be installed on a channel or server. {@link #close} must be called after
+ * all the servers and channels associated with the binary log are terminated.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4017")
+public abstract class BinaryLog implements Closeable {
+
+  public abstract <ReqT, RespT> ServerMethodDefinition<?, ?> wrapMethodDefinition(
+      ServerMethodDefinition<ReqT, RespT> oMethodDef);
+
+  public abstract Channel wrapChannel(Channel channel);
+}
diff --git a/api/src/main/java/io/grpc/BindableService.java b/api/src/main/java/io/grpc/BindableService.java
new file mode 100644
index 00000000000..682d959e69a
--- /dev/null
+++ b/api/src/main/java/io/grpc/BindableService.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2016 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;
+
+/**
+ * Provides a way to bind instance of service implementation to server.
+ *
+ * <p>It is used by service's abstract class generated by compiler (eg.:
+ * RouteGuideGrpc.RouteGuideImplBase for RouteGuide service) and lets implementation classes to be
+ * bind to server.
+ *
+ * <pre><code>
+ * class RouteGuideService extends RouteGuideGrpc.RouteGuideImplBase {
+ *   // ...
+ * }
+ *
+ * Server server = ServerBuilder.forPort(1234).addService(new RouteGuideService()).build();
+ * </code></pre></p>
+ */
+public interface BindableService {
+  /**
+   * Creates {@link ServerServiceDefinition} object for current instance of service implementation.
+   *
+   * @return ServerServiceDefinition object.
+   */
+  ServerServiceDefinition bindService();
+}
diff --git a/api/src/main/java/io/grpc/CallCredentials.java b/api/src/main/java/io/grpc/CallCredentials.java
new file mode 100644
index 00000000000..eb92a6f15fa
--- /dev/null
+++ b/api/src/main/java/io/grpc/CallCredentials.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2016 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;
+
+import java.util.concurrent.Executor;
+
+/**
+ * Carries credential data that will be propagated to the server via request metadata for each RPC.
+ *
+ * <p>This is used by {@link CallOptions#withCallCredentials} and {@code withCallCredentials()} on
+ * the generated stub, for example:
+ * <pre>
+ * FooGrpc.FooStub stub = FooGrpc.newStub(channel);
+ * response = stub.withCallCredentials(creds).bar(request);
+ * </pre>
+ *
+ * <p>The contents and nature of this class (and whether it remains an abstract class) is
+ * experimental, in that it can change. However, we are guaranteeing stability for the
+ * <em>name</em>. That is, we are guaranteeing stability for code to be returned a reference and
+ * pass that reference to gRPC for usage. However, code may not call or implement the {@code
+ * CallCredentials} itself if it wishes to only use stable APIs.
+ */
+public abstract class CallCredentials {
+
+  /**
+   * Pass the credential data to the given {@link CallCredentials.MetadataApplier}, which will
+   * propagate it to the request metadata.
+   *
+   * <p>It is called for each individual RPC, within the {@link Context} of the call, before the
+   * stream is about to be created on a transport. Implementations should not block in this
+   * method. If metadata is not immediately available, e.g., needs to be fetched from network, the
+   * implementation may give the {@code appExecutor} an asynchronous task which will eventually call
+   * the {@code applier}. The RPC proceeds only after the {@code applier} is called.
+   *
+   * @param requestInfo request-related information
+   * @param appExecutor The application thread-pool. It is provided to the implementation in case it
+   *        needs to perform blocking operations.
+   * @param applier The outlet of the produced headers. It can be called either before or after this
+   *        method returns.
+   */
+  public abstract void applyRequestMetadata(
+      RequestInfo requestInfo, Executor appExecutor, CallCredentials.MetadataApplier applier);
+
+  /**
+   * With this class now being stable this method moves from an abstract one to a normal one with
+   * a no-op implementation. This method is marked deprecated to allow extenders time to remove the
+   * method before it is removed here.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1914")
+  @Deprecated
+  public void thisUsesUnstableApi() {
+  }
+
+  /**
+   * The outlet of the produced headers. Not thread-safe.
+   *
+   * <p>Exactly one of its methods must be called to make the RPC proceed.
+   */
+  public abstract static class MetadataApplier {
+    /**
+     * Called when headers are successfully generated. They will be merged into the original
+     * headers.
+     */
+    public abstract void apply(Metadata headers);
+
+    /**
+     * Called when there has been an error when preparing the headers. This will fail the RPC.
+     */
+    public abstract void fail(Status status);
+  }
+
+  /**
+   * The request-related information passed to {@code CallCredentials.applyRequestMetadata()}.
+   */
+  public abstract static class RequestInfo {
+    /**
+     * The method descriptor of this RPC.
+     */
+    public abstract MethodDescriptor<?, ?> getMethodDescriptor();
+
+    /**
+     * The call options used to call this RPC.
+     */
+    public CallOptions getCallOptions() {
+      throw new UnsupportedOperationException("Not implemented");
+    }
+
+    /**
+     * The security level on the transport.
+     */
+    public abstract SecurityLevel getSecurityLevel();
+
+    /**
+     * Returns the authority string used to authenticate the server for this call.
+     */
+    public abstract String getAuthority();
+
+    /**
+     * Returns the transport attributes.
+     */
+    @Grpc.TransportAttr
+    public abstract Attributes getTransportAttrs();
+  }
+}
diff --git a/api/src/main/java/io/grpc/CallOptions.java b/api/src/main/java/io/grpc/CallOptions.java
new file mode 100644
index 00000000000..800bdfb6c90
--- /dev/null
+++ b/api/src/main/java/io/grpc/CallOptions.java
@@ -0,0 +1,542 @@
+/*
+ * Copyright 2015 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static io.grpc.TimeUtils.convertToNanos;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.CheckReturnValue;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * The collection of runtime options for a new RPC call.
+ *
+ * <p>A field that is not set is {@code null}.
+ */
+@Immutable
+@CheckReturnValue
+public final class CallOptions {
+  /**
+   * A blank {@code CallOptions} that all fields are not set.
+   */
+  public static final CallOptions DEFAULT;
+
+  static {
+    Builder b = new Builder();
+    b.customOptions = new Object[0][2];
+    b.streamTracerFactories = Collections.emptyList();
+    DEFAULT = b.build();
+  }
+
+  @Nullable
+  private final Deadline deadline;
+
+  @Nullable
+  private final Executor executor;
+
+  @Nullable
+  private final String authority;
+
+  @Nullable
+  private final CallCredentials credentials;
+
+  @Nullable
+  private final String compressorName;
+
+  private final Object[][] customOptions;
+
+  private final List<ClientStreamTracer.Factory> streamTracerFactories;
+
+  /**
+   * Opposite to fail fast.
+   */
+  @Nullable
+  private final Boolean waitForReady;
+
+  @Nullable
+  private final Integer maxInboundMessageSize;
+  @Nullable
+  private final Integer maxOutboundMessageSize;
+  @Nullable
+  private final Integer onReadyThreshold;
+
+  private CallOptions(Builder builder) {
+    this.deadline = builder.deadline;
+    this.executor = builder.executor;
+    this.authority = builder.authority;
+    this.credentials = builder.credentials;
+    this.compressorName = builder.compressorName;
+    this.customOptions = builder.customOptions;
+    this.streamTracerFactories = builder.streamTracerFactories;
+    this.waitForReady = builder.waitForReady;
+    this.maxInboundMessageSize = builder.maxInboundMessageSize;
+    this.maxOutboundMessageSize = builder.maxOutboundMessageSize;
+    this.onReadyThreshold = builder.onReadyThreshold;
+  }
+
+  static class Builder {
+    Deadline deadline;
+    Executor executor;
+    String authority;
+    CallCredentials credentials;
+    String compressorName;
+    Object[][] customOptions;
+    // Unmodifiable list
+    List<ClientStreamTracer.Factory> streamTracerFactories;
+    Boolean waitForReady;
+    Integer maxInboundMessageSize;
+    Integer maxOutboundMessageSize;
+    Integer onReadyThreshold;
+
+    private CallOptions build() {
+      return new CallOptions(this);
+    }
+  }
+
+  /**
+   * Override the HTTP/2 authority the channel claims to be connecting to. <em>This is not
+   * generally safe.</em> Overriding allows advanced users to re-use a single Channel for multiple
+   * services, even if those services are hosted on different domain names. That assumes the
+   * server is virtually hosting multiple domains and is guaranteed to continue doing so. It is
+   * rare for a service provider to make such a guarantee. <em>At this time, there is no security
+   * verification of the overridden value, such as making sure the authority matches the server's
+   * TLS certificate.</em>
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1767")
+  public CallOptions withAuthority(@Nullable String authority) {
+    Builder builder = toBuilder(this);
+    builder.authority = authority;
+    return builder.build();
+  }
+
+  /**
+   * Returns a new {@code CallOptions} with the given call credentials.
+   */
+  public CallOptions withCallCredentials(@Nullable CallCredentials credentials) {
+    Builder builder = toBuilder(this);
+    builder.credentials = credentials;
+    return builder.build();
+  }
+
+  /**
+   * Sets the compression to use for the call.  The compressor must be a valid name known in the
+   * {@link CompressorRegistry}.  By default, the "gzip" compressor will be available.
+   *
+   * <p>It is only safe to call this if the server supports the compression format chosen. There is
+   * no negotiation performed; if the server does not support the compression chosen, the call will
+   * fail.
+   */
+  public CallOptions withCompression(@Nullable String compressorName) {
+    Builder builder = toBuilder(this);
+    builder.compressorName = compressorName;
+    return builder.build();
+  }
+
+  /**
+   * Returns a new {@code CallOptions} with the given absolute deadline.
+   *
+   * <p>This is mostly used for propagating an existing deadline. {@link #withDeadlineAfter} is the
+   * recommended way of setting a new deadline,
+   *
+   * @param deadline the deadline or {@code null} for unsetting the deadline.
+   */
+  public CallOptions withDeadline(@Nullable Deadline deadline) {
+    Builder builder = toBuilder(this);
+    builder.deadline = deadline;
+    return builder.build();
+  }
+
+  /**
+   * Returns a new {@code CallOptions} with a deadline that is after the given {@code duration} from
+   * now.
+   */
+  public CallOptions withDeadlineAfter(long duration, TimeUnit unit) {
+    return withDeadline(Deadline.after(duration, unit));
+  }
+
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11657")
+  public CallOptions withDeadlineAfter(Duration duration) {
+    return withDeadlineAfter(convertToNanos(duration), TimeUnit.NANOSECONDS);
+  }
+
+  /**
+   * Returns the deadline or {@code null} if the deadline is not set.
+   */
+  @Nullable
+  public Deadline getDeadline() {
+    return deadline;
+  }
+
+  /**
+   * Enables <a href="https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md">
+   * 'wait for ready'</a> for the call. Wait-for-ready queues the RPC until a connection is
+   * available. This may dramatically increase the latency of the RPC, but avoids failing
+   * "unnecessarily." The default queues the RPC until an attempt to connect has completed, but
+   * fails RPCs without sending them if unable to connect.
+   */
+  public CallOptions withWaitForReady() {
+    Builder builder = toBuilder(this);
+    builder.waitForReady = Boolean.TRUE;
+    return builder.build();
+  }
+
+  /**
+   * Disables 'wait for ready' feature for the call.
+   * This method should be rarely used because the default is without 'wait for ready'.
+   */
+  public CallOptions withoutWaitForReady() {
+    Builder builder = toBuilder(this);
+    builder.waitForReady = Boolean.FALSE;
+    return builder.build();
+  }
+
+  /**
+   * Specifies how many bytes must be queued before the call is
+   * considered not ready to send more messages.
+   *
+   * @param numBytes The number of bytes that must be queued. Must be a
+   *                 positive integer.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11021")
+  public CallOptions withOnReadyThreshold(int numBytes) {
+    checkArgument(numBytes > 0, "numBytes must be positive: %s", numBytes);
+    Builder builder = toBuilder(this);
+    builder.onReadyThreshold = numBytes;
+    return builder.build();
+  }
+
+  /**
+   * Resets to the default number of bytes that must be queued before the
+   * call will leave the <a href="https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md">
+   * 'wait for ready'</a> state.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11021")
+  public CallOptions clearOnReadyThreshold() {
+    Builder builder = toBuilder(this);
+    builder.onReadyThreshold = null;
+    return builder.build();
+  }
+
+  /**
+   * Returns to the default number of bytes that must be queued before the
+   * call will leave the <a href="https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md">
+   * 'wait for ready'</a> state.
+   *
+   * @return null if the default threshold is used.
+   */
+  @Nullable
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11021")
+  public Integer getOnReadyThreshold() {
+    return onReadyThreshold;
+  }
+
+  /**
+   * Returns the compressor's name.
+   */
+  @Nullable
+  public String getCompressor() {
+    return compressorName;
+  }
+
+  /**
+   * Override the HTTP/2 authority the channel claims to be connecting to. <em>This is not
+   * generally safe.</em> Overriding allows advanced users to re-use a single Channel for multiple
+   * services, even if those services are hosted on different domain names. That assumes the
+   * server is virtually hosting multiple domains and is guaranteed to continue doing so. It is
+   * rare for a service provider to make such a guarantee. <em>At this time, there is no security
+   * verification of the overridden value, such as making sure the authority matches the server's
+   * TLS certificate.</em>
+   */
+  @Nullable
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1767")
+  public String getAuthority() {
+    return authority;
+  }
+
+  /**
+   * Returns the call credentials.
+   */
+  @Nullable
+  public CallCredentials getCredentials() {
+    return credentials;
+  }
+
+  /**
+   * Returns a new {@code CallOptions} with {@code executor} to be used instead of the default
+   * executor specified with {@link ManagedChannelBuilder#executor}.
+   */
+  public CallOptions withExecutor(@Nullable Executor executor) {
+    Builder builder = toBuilder(this);
+    builder.executor = executor;
+    return builder.build();
+  }
+
+  /**
+   * Returns a new {@code CallOptions} with a {@code ClientStreamTracerFactory} in addition to
+   * the existing factories.
+   *
+   * <p>This method doesn't replace existing factories, or try to de-duplicate factories.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
+  public CallOptions withStreamTracerFactory(ClientStreamTracer.Factory factory) {
+    ArrayList<ClientStreamTracer.Factory> newList =
+        new ArrayList<>(streamTracerFactories.size() + 1);
+    newList.addAll(streamTracerFactories);
+    newList.add(factory);
+    Builder builder = toBuilder(this);
+    builder.streamTracerFactories = Collections.unmodifiableList(newList);
+    return builder.build();
+  }
+
+  /**
+   * Returns an immutable list of {@code ClientStreamTracerFactory}s.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
+  public List<ClientStreamTracer.Factory> getStreamTracerFactories() {
+    return streamTracerFactories;
+  }
+
+  /**
+   * Key for a key-value pair. Uses reference equality.
+   */
+  public static final class Key<T> {
+    private final String debugString;
+    private final T defaultValue;
+
+    private Key(String debugString, T defaultValue) {
+      this.debugString = debugString;
+      this.defaultValue = defaultValue;
+    }
+
+    /**
+     * Returns the user supplied default value for this key.
+     */
+    public T getDefault() {
+      return defaultValue;
+    }
+
+    @Override
+    public String toString() {
+      return debugString;
+    }
+
+    /**
+     * Factory method for creating instances of {@link Key}.
+     *
+     * @param debugString a string used to describe this key, used for debugging.
+     * @param defaultValue default value to return when value for key not set
+     * @param <T> Key type
+     * @return Key object
+     * @deprecated Use {@link #create} or {@link #createWithDefault} instead. This method will
+     *     be removed.
+     */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1869")
+    @Deprecated
+    public static <T> Key<T> of(String debugString, T defaultValue) {
+      Preconditions.checkNotNull(debugString, "debugString");
+      return new Key<>(debugString, defaultValue);
+    }
+
+    /**
+     * Factory method for creating instances of {@link Key}. The default value of the
+     * key is {@code null}.
+     *
+     * @param debugString a debug string that describes this key.
+     * @param <T> Key type
+     * @return Key object
+     * @since 1.13.0
+     */
+    public static <T> Key<T> create(String debugString) {
+      Preconditions.checkNotNull(debugString, "debugString");
+      return new Key<>(debugString, /*defaultValue=*/ null);
+    }
+
+    /**
+     * Factory method for creating instances of {@link Key}.
+     *
+     * @param debugString a debug string that describes this key.
+     * @param defaultValue default value to return when value for key not set
+     * @param <T> Key type
+     * @return Key object
+     * @since 1.13.0
+     */
+    public static <T> Key<T> createWithDefault(String debugString, T defaultValue) {
+      Preconditions.checkNotNull(debugString, "debugString");
+      return new Key<>(debugString, defaultValue);
+    }
+  }
+
+  /**
+   * Sets a custom option. Any existing value for the key is overwritten.
+   *
+   * @param key The option key
+   * @param value The option value.
+   * @since 1.13.0
+   */
+  public <T> CallOptions withOption(Key<T> key, T value) {
+    Preconditions.checkNotNull(key, "key");
+    Preconditions.checkNotNull(value, "value");
+
+    Builder builder = toBuilder(this);
+    int existingIdx = -1;
+    for (int i = 0; i < customOptions.length; i++) {
+      if (key.equals(customOptions[i][0])) {
+        existingIdx = i;
+        break;
+      }
+    }
+
+    builder.customOptions = new Object[customOptions.length + (existingIdx == -1 ? 1 : 0)][2];
+    System.arraycopy(customOptions, 0, builder.customOptions, 0, customOptions.length);
+
+    if (existingIdx == -1) {
+      // Add a new option
+      builder.customOptions[customOptions.length] = new Object[] {key, value};
+    } else {
+      // Replace an existing option
+      builder.customOptions[existingIdx] = new Object[] {key, value};
+    }
+
+    return builder.build();
+  }
+
+  /**
+   * Get the value for a custom option or its inherent default.
+   * @param key Key identifying option
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1869")
+  @SuppressWarnings("unchecked")
+  public <T> T getOption(Key<T> key) {
+    Preconditions.checkNotNull(key, "key");
+    for (int i = 0; i < customOptions.length; i++) {
+      if (key.equals(customOptions[i][0])) {
+        return (T) customOptions[i][1];
+      }
+    }
+    return key.defaultValue;
+  }
+
+  /**
+   * Returns the executor override to use for this specific call, or {@code null} if there is no
+   * override. The executor is only for servicing this one call, so is not safe to use after
+   * {@link ClientCall.Listener#onClose}.
+   */
+  @Nullable
+  public Executor getExecutor() {
+    return executor;
+  }
+
+  /**
+   * Returns whether <a href="https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md">
+   * 'wait for ready'</a> option is enabled for the call. 'Fail fast' is the default option for gRPC
+   * calls and 'wait for ready' is the opposite to it.
+   */
+  public boolean isWaitForReady() {
+    return Boolean.TRUE.equals(waitForReady);
+  }
+
+  Boolean getWaitForReady() {
+    return waitForReady;
+  }
+
+  /**
+   * Sets the maximum allowed message size acceptable from the remote peer.  If unset, this will
+   * default to the value set on the {@link ManagedChannelBuilder#maxInboundMessageSize(int)}.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2563")
+  public CallOptions withMaxInboundMessageSize(int maxSize) {
+    checkArgument(maxSize >= 0, "invalid maxsize %s", maxSize);
+    Builder builder = toBuilder(this);
+    builder.maxInboundMessageSize = maxSize;
+    return builder.build();
+  }
+
+  /**
+   * Sets the maximum allowed message size acceptable sent to the remote peer.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2563")
+  public CallOptions withMaxOutboundMessageSize(int maxSize) {
+    checkArgument(maxSize >= 0, "invalid maxsize %s", maxSize);
+    Builder builder = toBuilder(this);
+    builder.maxOutboundMessageSize = maxSize;
+    return builder.build();
+  }
+
+  /**
+   * Gets the maximum allowed message size acceptable from the remote peer.
+   */
+  @Nullable
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2563")
+  public Integer getMaxInboundMessageSize() {
+    return maxInboundMessageSize;
+  }
+
+  /**
+   * Gets the maximum allowed message size acceptable to send the remote peer.
+   */
+  @Nullable
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2563")
+  public Integer getMaxOutboundMessageSize() {
+    return maxOutboundMessageSize;
+  }
+
+  /**
+   * Copy CallOptions.
+   */
+  private static Builder toBuilder(CallOptions other) {
+    Builder builder = new Builder();
+    builder.deadline = other.deadline;
+    builder.executor = other.executor;
+    builder.authority = other.authority;
+    builder.credentials = other.credentials;
+    builder.compressorName = other.compressorName;
+    builder.customOptions = other.customOptions;
+    builder.streamTracerFactories = other.streamTracerFactories;
+    builder.waitForReady = other.waitForReady;
+    builder.maxInboundMessageSize = other.maxInboundMessageSize;
+    builder.maxOutboundMessageSize = other.maxOutboundMessageSize;
+    builder.onReadyThreshold = other.onReadyThreshold;
+    return builder;
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("deadline", deadline)
+        .add("authority", authority)
+        .add("callCredentials", credentials)
+        .add("executor", executor != null ? executor.getClass() : null)
+        .add("compressorName", compressorName)
+        .add("customOptions", Arrays.deepToString(customOptions))
+        .add("waitForReady", isWaitForReady())
+        .add("maxInboundMessageSize", maxInboundMessageSize)
+        .add("maxOutboundMessageSize", maxOutboundMessageSize)
+        .add("onReadyThreshold", onReadyThreshold)
+        .add("streamTracerFactories", streamTracerFactories)
+        .toString();
+  }
+}
diff --git a/api/src/main/java/io/grpc/CallbackMetricInstrument.java b/api/src/main/java/io/grpc/CallbackMetricInstrument.java
new file mode 100644
index 00000000000..1d66d5340ed
--- /dev/null
+++ b/api/src/main/java/io/grpc/CallbackMetricInstrument.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2024 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;
+
+/**
+ * Tagging interface for MetricInstruments that can be used with batch callbacks.
+ */
+@Internal
+public interface CallbackMetricInstrument extends MetricInstrument {}
diff --git a/api/src/main/java/io/grpc/Channel.java b/api/src/main/java/io/grpc/Channel.java
new file mode 100644
index 00000000000..60ff76ff082
--- /dev/null
+++ b/api/src/main/java/io/grpc/Channel.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2014 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;
+
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A virtual connection to a conceptual endpoint, to perform RPCs. A channel is free to have zero or
+ * many actual connections to the endpoint based on configuration, load, etc. A channel is also free
+ * to determine which actual endpoints to use and may change it every RPC, permitting client-side
+ * load balancing. Applications are generally expected to use stubs instead of calling this class
+ * directly.
+ *
+ * <p>Applications can add common cross-cutting behaviors to stubs by decorating Channel
+ * implementations using {@link ClientInterceptor}. It is expected that most application
+ * code will not use this class directly but rather work with stubs that have been bound to a
+ * Channel that was decorated during application initialization.
+ */
+@ThreadSafe
+public abstract class Channel {
+  /**
+   * Create a {@link ClientCall} to the remote operation specified by the given
+   * {@link MethodDescriptor}. The returned {@link ClientCall} does not trigger any remote
+   * behavior until {@link ClientCall#start(ClientCall.Listener, Metadata)} is
+   * invoked.
+   *
+   * @param methodDescriptor describes the name and parameter types of the operation to call.
+   * @param callOptions runtime options to be applied to this call.
+   * @return a {@link ClientCall} bound to the specified method.
+   * @since 1.0.0
+   */
+  public abstract <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+      MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions);
+
+  /**
+   * The authority of the destination this channel connects to. Typically this is in the format
+   * {@code host:port}.
+   *
+   * @since 1.0.0
+   */
+  public abstract String authority();
+}
diff --git a/api/src/main/java/io/grpc/ChannelCredentials.java b/api/src/main/java/io/grpc/ChannelCredentials.java
new file mode 100644
index 00000000000..d95fc375eb6
--- /dev/null
+++ b/api/src/main/java/io/grpc/ChannelCredentials.java
@@ -0,0 +1,47 @@
+/*
+ * 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;
+
+/**
+ * Represents a security configuration to be used for channels. There is no generic mechanism for
+ * processing arbitrary {@code ChannelCredentials}; the consumer of the credential (the channel)
+ * must support each implementation explicitly and separately. Consumers are not required to support
+ * all types or even all possible configurations for types that are partially supported, but they
+ * <em>must</em> at least fully support {@link ChoiceChannelCredentials}.
+ *
+ * <p>A {@code ChannelCredential} provides client identity and authenticates the server. This is
+ * different from {@link CallCredentials}, which only provides client identity. They can also
+ * influence types of encryption used and similar security configuration.
+ *
+ * <p>The concrete credential type should not be relevant to most users of the API and may be an
+ * implementation decision. Users should generally use the {@code ChannelCredentials} type for
+ * variables instead of the concrete type. Freshly-constructed credentials should be returned as
+ * {@code ChannelCredentials} instead of a concrete type to encourage this pattern. Concrete types
+ * would only be used after {@code instanceof} checks (which must consider
+ * {@code ChoiceChannelCredentials}!).
+ */
+public abstract class ChannelCredentials {
+  /**
+   * Returns the ChannelCredentials stripped of its CallCredentials. In the future,
+   * this may strip only some of the CallCredentials, preserving call credentials
+   * that are safe from replay attacks (e.g., if the token is bound to the
+   * channel's certificate).
+   *
+   * @since 1.35.0
+   */
+  public abstract ChannelCredentials withoutBearerTokens();
+}
diff --git a/api/src/main/java/io/grpc/ChannelLogger.java b/api/src/main/java/io/grpc/ChannelLogger.java
new file mode 100644
index 00000000000..ce654ec9d5b
--- /dev/null
+++ b/api/src/main/java/io/grpc/ChannelLogger.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2018 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;
+
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A Channel-specific logger provided by GRPC library to {@link LoadBalancer} implementations.
+ * Information logged here goes to <strong>Channelz</strong>, and to the Java logger of this class
+ * as well.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/5029")
+@ThreadSafe
+public abstract class ChannelLogger {
+  /**
+   * Log levels.  See the table below for the mapping from the ChannelLogger levels to Channelz
+   * severity level (see {@code ChannelTraceEvent} from <a
+   * href="https://github.com/grpc/grpc-java/blob/master/services/src/main/proto/grpc/channelz/v1/channelz.proto">channelz.proto</a>)
+   * and Java logger levels.  Note that {@code DEBUG} level is not recorded on Channelz.
+   * <pre>
+   * +---------------------+-------------------+-------------------+
+   * | ChannelLogger Level | Channelz Severity | Java Logger Level |
+   * +---------------------+-------------------+-------------------+
+   * | DEBUG               | N/A               | FINEST            |
+   * | INFO                | CT_INFO           | FINER             |
+   * | WARNING             | CT_WARNING        | FINE             |
+   * | ERROR               | CT_ERROR          | FINE              |
+   * +---------------------+-------------------+-------------------+
+   * </pre>
+   */
+  public enum ChannelLogLevel {
+    DEBUG,
+    INFO,
+    WARNING,
+    ERROR
+  }
+
+  /**
+   * Logs a message.
+   */
+  public abstract void log(ChannelLogLevel level, String message);
+
+  /**
+   * Logs a message, using a message format and a list of arguments used to generate the log
+   * message with {@link java.text.MessageFormat}.
+   */
+  public abstract void log(ChannelLogLevel level, String messageFormat, Object... args);
+}
diff --git a/api/src/main/java/io/grpc/ChoiceChannelCredentials.java b/api/src/main/java/io/grpc/ChoiceChannelCredentials.java
new file mode 100644
index 00000000000..55d9c592da3
--- /dev/null
+++ b/api/src/main/java/io/grpc/ChoiceChannelCredentials.java
@@ -0,0 +1,66 @@
+/*
+ * 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;
+
+import static java.util.Collections.unmodifiableList;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Provides a list of {@link ChannelCredentials}, where any one may be used. The credentials are in
+ * preference order.
+ */
+public final class ChoiceChannelCredentials extends ChannelCredentials {
+  /**
+   * Constructs with the provided {@code creds} as options, with preferred credentials first.
+   *
+   * @throws IllegalArgumentException if no creds are provided
+   */
+  public static ChannelCredentials create(ChannelCredentials... creds) {
+    if (creds.length == 0) {
+      throw new IllegalArgumentException("At least one credential is required");
+    }
+    for (ChannelCredentials cred : creds) {
+      if (cred == null) {
+        throw new NullPointerException();
+      }
+    }
+    return new ChoiceChannelCredentials(unmodifiableList(new ArrayList<>(Arrays.asList(creds))));
+  }
+
+  private final List<ChannelCredentials> creds;
+
+  private ChoiceChannelCredentials(List<ChannelCredentials> creds) {
+    this.creds = creds;
+  }
+
+  /** Non-empty list of credentials, in preference order. */
+  public List<ChannelCredentials> getCredentialsList() {
+    return creds;
+  }
+
+  @Override
+  public ChannelCredentials withoutBearerTokens() {
+    List<ChannelCredentials> credsWithoutTokens = new ArrayList<>();
+    for (ChannelCredentials cred : creds) {
+      credsWithoutTokens.add(cred.withoutBearerTokens());
+    }
+    return new ChoiceChannelCredentials(unmodifiableList(credsWithoutTokens));
+  }
+}
diff --git a/api/src/main/java/io/grpc/ChoiceServerCredentials.java b/api/src/main/java/io/grpc/ChoiceServerCredentials.java
new file mode 100644
index 00000000000..87777d2e912
--- /dev/null
+++ b/api/src/main/java/io/grpc/ChoiceServerCredentials.java
@@ -0,0 +1,56 @@
+/*
+ * 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;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Provides a list of {@link ServerCredentials}, where any one may be used. The credentials are in
+ * preference order.
+ */
+public final class ChoiceServerCredentials extends ServerCredentials {
+  /**
+   * Constructs with the provided {@code creds} as options, with preferred credentials first.
+   *
+   * @throws IllegalArgumentException if no creds are provided
+   */
+  public static ServerCredentials create(ServerCredentials... creds) {
+    if (creds.length == 0) {
+      throw new IllegalArgumentException("At least one credential is required");
+    }
+    return new ChoiceServerCredentials(creds);
+  }
+
+  private final List<ServerCredentials> creds;
+
+  private ChoiceServerCredentials(ServerCredentials... creds) {
+    for (ServerCredentials cred : creds) {
+      if (cred == null) {
+        throw new NullPointerException();
+      }
+    }
+    this.creds = Collections.unmodifiableList(new ArrayList<>(Arrays.asList(creds)));
+  }
+
+  /** Non-empty list of credentials, in preference order. */
+  public List<ServerCredentials> getCredentialsList() {
+    return creds;
+  }
+}
diff --git a/api/src/main/java/io/grpc/ClientCall.java b/api/src/main/java/io/grpc/ClientCall.java
new file mode 100644
index 00000000000..c915c8beaac
--- /dev/null
+++ b/api/src/main/java/io/grpc/ClientCall.java
@@ -0,0 +1,290 @@
+/*
+ * Copyright 2014 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;
+
+import javax.annotation.Nullable;
+
+/**
+ * An instance of a call to a remote method. A call will send zero or more
+ * request messages to the server and receive zero or more response messages back.
+ *
+ * <p>Instances are created
+ * by a {@link Channel} and used by stubs to invoke their remote behavior.
+ *
+ * <p>More advanced usages may consume this interface directly as opposed to using a stub. Common
+ * reasons for doing so would be the need to interact with flow-control or when acting as a generic
+ * proxy for arbitrary operations.
+ *
+ * <p>{@link #start} must be called prior to calling any other methods, with the exception of
+ * {@link #cancel}. Whereas {@link #cancel} must not be followed by any other methods,
+ * but can be called more than once, while only the first one has effect.
+ *
+ * <p>No generic method for determining message receipt or providing acknowledgement is provided.
+ * Applications are expected to utilize normal payload messages for such signals, as a response
+ * naturally acknowledges its request.
+ *
+ * <p>Methods are guaranteed to be non-blocking. Not thread-safe except for {@link #request}, which
+ * may be called from any thread.
+ *
+ * <p>There is no interaction between the states on the {@link Listener Listener} and {@link
+ * ClientCall}, i.e., if {@link Listener#onClose Listener.onClose()} is called, it has no bearing on
+ * the permitted operations on {@code ClientCall} (but it may impact whether they do anything).
+ *
+ * <p>There is a race between {@link #cancel} and the completion/failure of the RPC in other ways.
+ * If {@link #cancel} won the race, {@link Listener#onClose Listener.onClose()} is called with
+ * {@link Status#CANCELLED CANCELLED}. Otherwise, {@link Listener#onClose Listener.onClose()} is
+ * called with whatever status the RPC was finished. We ensure that at most one is called.
+ *
+ * <h3>Usage examples</h3>
+ * <h4>Simple Unary (1 request, 1 response) RPC</h4>
+ * <pre>
+ *   call = channel.newCall(unaryMethod, callOptions);
+ *   call.start(listener, headers);
+ *   call.sendMessage(message);
+ *   call.halfClose();
+ *   call.request(1);
+ *   // wait for listener.onMessage()
+ * </pre>
+ *
+ * <h4>Flow-control in Streaming RPC</h4>
+ *
+ * <p>The following snippet demonstrates a bi-directional streaming case, where the client sends
+ * requests produced by a fictional <code>makeNextRequest()</code> in a flow-control-compliant
+ * manner, and notifies gRPC library to receive additional response after one is consumed by
+ * a fictional <code>processResponse()</code>.
+ *
+ * <pre>
+ *   call = channel.newCall(bidiStreamingMethod, callOptions);
+ *   listener = new ClientCall.Listener&lt;FooResponse&gt;() {
+ *     &#64;Override
+ *     public void onMessage(FooResponse response) {
+ *       processResponse(response);
+ *       // Notify gRPC to receive one additional response.
+ *       call.request(1);
+ *     }
+ *
+ *     &#64;Override
+ *     public void onReady() {
+ *       while (call.isReady()) {
+ *         FooRequest nextRequest = makeNextRequest();
+ *         if (nextRequest == null) {  // No more requests to send
+ *           call.halfClose();
+ *           return;
+ *         }
+ *         call.sendMessage(nextRequest);
+ *       }
+ *     }
+ *   }
+ *   call.start(listener, headers);
+ *   // Notify gRPC to receive one response. Without this line, onMessage() would never be called.
+ *   call.request(1);
+ * </pre>
+ *
+ * <p>DO NOT MOCK: Use InProcessServerBuilder and make a test server instead.
+ *
+ * @param <ReqT> type of message sent one or more times to the server.
+ * @param <RespT> type of message received one or more times from the server.
+ */
+public abstract class ClientCall<ReqT, RespT> {
+  /**
+   * Callbacks for receiving metadata, response messages and completion status from the server.
+   *
+   * <p>Implementations are free to block for extended periods of time. Implementations are not
+   * required to be thread-safe, but they must not be thread-hostile. The caller is free to call
+   * an instance from multiple threads, but only one call simultaneously. A single thread may
+   * interleave calls to multiple instances, so implementations using ThreadLocals must be careful
+   * to avoid leaking inappropriate state (e.g., clearing the ThreadLocal before returning).
+   *
+   * @param <T> type of message received.
+   */
+  public abstract static class Listener<T> {
+
+    /**
+     * The response headers have been received. Headers always precede messages.
+     *
+     * <p>Since {@link Metadata} is not thread-safe, the caller must not access (read or write)
+     * {@code headers} after this point.
+     *
+     * @param headers containing metadata sent by the server at the start of the response.
+     */
+    public void onHeaders(Metadata headers) {}
+
+    /**
+     * A response message has been received. May be called zero or more times depending on whether
+     * the call response is empty, a single message or a stream of messages.
+     *
+     * @param message returned by the server
+     */
+    public void onMessage(T message) {}
+
+    /**
+     * The ClientCall has been closed. Any additional calls to the {@code ClientCall} will not be
+     * processed by the server. No further receiving will occur and no further notifications will be
+     * made.
+     *
+     * <p>Since {@link Metadata} is not thread-safe, the caller must not access (read or write)
+     * {@code trailers} after this point.
+     *
+     * <p>If {@code status} returns false for {@link Status#isOk()}, then the call failed.
+     * An additional block of trailer metadata may be received at the end of the call from the
+     * server. An empty {@link Metadata} object is passed if no trailers are received.
+     *
+     * <p>This method should not throw. If this method throws, there is no way to be notified of the
+     * exception. Implementations should therefore be careful of exceptions which can accidentally 
+     * leak resources.
+     *
+     * @param status the result of the remote call.
+     * @param trailers metadata provided at call completion.
+     */
+    public void onClose(Status status, Metadata trailers) {}
+
+    /**
+     * This indicates that the ClientCall may now be capable of sending additional messages (via
+     * {@link #sendMessage}) without requiring excessive buffering internally. This event is
+     * just a suggestion and the application is free to ignore it, however doing so may
+     * result in excessive buffering within the ClientCall.
+     *
+     * <p>Because there is a processing delay to deliver this notification, it is possible for
+     * concurrent writes to cause {@code isReady() == false} within this callback. Handle "spurious"
+     * notifications by checking {@code isReady()}'s current value instead of assuming it is now
+     * {@code true}. If {@code isReady() == false} the normal expectations apply, so there would be
+     * <em>another</em> {@code onReady()} callback.
+     *
+     * <p>If the type of a call is either {@link MethodDescriptor.MethodType#UNARY} or
+     * {@link MethodDescriptor.MethodType#SERVER_STREAMING}, this callback may not be fired. Calls
+     * that send exactly one message should not await this callback.
+     */
+    public void onReady() {}
+  }
+
+  /**
+   * Start a call, using {@code responseListener} for processing response messages.
+   *
+   * <p>It must be called prior to any other method on this class, except for {@link #cancel} which
+   * may be called at any time.
+   *
+   * <p>Since {@link Metadata} is not thread-safe, the caller must not access (read or write) {@code
+   * headers} after this point.
+   *
+   * @param responseListener receives response messages
+   * @param headers which can contain extra call metadata, e.g. authentication credentials.
+   * @throws IllegalStateException if a method (including {@code start()}) on this class has been
+   *                               called.
+   */
+  public abstract void start(Listener<RespT> responseListener, Metadata headers);
+
+  /**
+   * Requests up to the given number of messages from the call to be delivered to
+   * {@link Listener#onMessage(Object)}. No additional messages will be delivered.
+   *
+   * <p>Message delivery is guaranteed to be sequential in the order received. In addition, the
+   * listener methods will not be accessed concurrently. While it is not guaranteed that the same
+   * thread will always be used, it is guaranteed that only a single thread will access the listener
+   * at a time.
+   *
+   * <p>If it is desired to bypass inbound flow control, a very large number of messages can be
+   * specified (e.g. {@link Integer#MAX_VALUE}).
+   *
+   * <p>If called multiple times, the number of messages able to delivered will be the sum of the
+   * calls.
+   *
+   * <p>This method is safe to call from multiple threads without external synchronization.
+   *
+   * @param numMessages the requested number of messages to be delivered to the listener. Must be
+   *                    non-negative.
+   * @throws IllegalStateException if call is not {@code start()}ed
+   * @throws IllegalArgumentException if numMessages is negative
+   */
+  public abstract void request(int numMessages);
+
+  /**
+   * Prevent any further processing for this {@code ClientCall}. No further messages may be sent or
+   * will be received. The server is informed of cancellations, but may not stop processing the
+   * call. Cancellation is permitted even if previously {@link #halfClose}d. Cancelling an already
+   * {@code cancel()}ed {@code ClientCall} has no effect.
+   *
+   * <p>No other methods on this class can be called after this method has been called.
+   *
+   * <p>It is recommended that at least one of the arguments to be non-{@code null}, to provide
+   * useful debug information. Both argument being null may log warnings and result in suboptimal
+   * performance. Also note that the provided information will not be sent to the server.
+   *
+   * @param message if not {@code null}, will appear as the description of the CANCELLED status
+   * @param cause if not {@code null}, will appear as the cause of the CANCELLED status
+   */
+  public abstract void cancel(@Nullable String message, @Nullable Throwable cause);
+
+  /**
+   * Close the call for request message sending. Incoming response messages are unaffected.  This
+   * should be called when no more messages will be sent from the client.
+   *
+   * @throws IllegalStateException if call is already {@code halfClose()}d or {@link #cancel}ed
+   */
+  public abstract void halfClose();
+
+  /**
+   * Send a request message to the server. May be called zero or more times depending on how many
+   * messages the server is willing to accept for the operation.
+   *
+   * @param message message to be sent to the server.
+   * @throws IllegalStateException if call is {@link #halfClose}d or explicitly {@link #cancel}ed
+   */
+  public abstract void sendMessage(ReqT message);
+
+  /**
+   * If {@code true}, indicates that the call is capable of sending additional messages
+   * without requiring excessive buffering internally. This event is
+   * just a suggestion and the application is free to ignore it, however doing so may
+   * result in excessive buffering within the call.
+   *
+   * <p>If {@code false}, {@link Listener#onReady()} will be called after {@code isReady()}
+   * transitions to {@code true}.
+   *
+   * <p>If the type of the call is either {@link MethodDescriptor.MethodType#UNARY} or
+   * {@link MethodDescriptor.MethodType#SERVER_STREAMING}, this method may persistently return
+   * false. Calls that send exactly one message should not check this method.
+   *
+   * <p>This abstract class's implementation always returns {@code true}. Implementations generally
+   * override the method.
+   */
+  public boolean isReady() {
+    return true;
+  }
+
+  /**
+   * Enables per-message compression, if an encoding type has been negotiated.  If no message
+   * encoding has been negotiated, this is a no-op. By default per-message compression is enabled,
+   * but may not have any effect if compression is not enabled on the call.
+   */
+  public void setMessageCompression(boolean enabled) {
+    // noop
+  }
+
+  /**
+   * Returns additional properties of the call. May only be called after {@link Listener#onHeaders}
+   * or {@link Listener#onClose}. If called prematurely, the implementation may throw {@code
+   * IllegalStateException} or return arbitrary {@code Attributes}.
+   *
+   * @return non-{@code null} attributes
+   * @throws IllegalStateException (optional) if called before permitted
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2607")
+  @Grpc.TransportAttr
+  public Attributes getAttributes() {
+    return Attributes.EMPTY;
+  }
+}
diff --git a/api/src/main/java/io/grpc/ClientInterceptor.java b/api/src/main/java/io/grpc/ClientInterceptor.java
new file mode 100644
index 00000000000..c27c31c8474
--- /dev/null
+++ b/api/src/main/java/io/grpc/ClientInterceptor.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2014 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;
+
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Interface for intercepting outgoing calls before they are dispatched by a {@link Channel}.
+ *
+ * <p>Implementers use this mechanism to add cross-cutting behavior to {@link Channel} and
+ * stub implementations. Common examples of such behavior include:
+ * <ul>
+ * <li>Logging and monitoring call behavior</li>
+ * <li>Adding metadata for proxies to observe</li>
+ * <li>Request and response rewriting</li>
+ * </ul>
+ *
+ * <p>Providing authentication credentials is better served by {@link
+ * CallCredentials}. But a {@code ClientInterceptor} could set the {@code
+ * CallCredentials} within the {@link CallOptions}.
+ *
+ * <p>The interceptor may be called for multiple {@link ClientCall calls} by one or more threads
+ * without completing the previous ones first. Refer to the
+ * {@link io.grpc.ClientCall.Listener ClientCall.Listener} docs for more details regarding thread
+ * safety of the returned listener.
+ */
+@ThreadSafe
+public interface ClientInterceptor {
+  /**
+   * Intercept {@link ClientCall} creation by the {@code next} {@link Channel}.
+   *
+   * <p>Many variations of interception are possible. Complex implementations may return a wrapper
+   * around the result of {@code next.newCall()}, whereas a simpler implementation may just modify
+   * the header metadata prior to returning the result of {@code next.newCall()}.
+   *
+   * <p>{@code next.newCall()} <strong>must not</strong> be called under a different {@link Context}
+   * other than the current {@code Context}. The outcome of such usage is undefined and may cause
+   * memory leak due to unbounded chain of {@code Context}s.
+   *
+   * @param method the remote method to be called.
+   * @param callOptions the runtime options to be applied to this call.
+   * @param next the channel which is being intercepted.
+   * @return the call object for the remote operation, never {@code null}.
+   */
+  <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+      MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next);
+}
diff --git a/api/src/main/java/io/grpc/ClientInterceptors.java b/api/src/main/java/io/grpc/ClientInterceptors.java
new file mode 100644
index 00000000000..81d0cf6da24
--- /dev/null
+++ b/api/src/main/java/io/grpc/ClientInterceptors.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright 2014 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;
+
+import com.google.common.base.Preconditions;
+import io.grpc.MethodDescriptor.Marshaller;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Utility methods for working with {@link ClientInterceptor}s.
+ */
+public class ClientInterceptors {
+
+  // Prevent instantiation
+  private ClientInterceptors() {}
+
+  /**
+   * Create a new {@link Channel} that will call {@code interceptors} before starting a call on the
+   * given channel. The first interceptor will have its {@link ClientInterceptor#interceptCall}
+   * called first.
+   *
+   * @param channel the underlying channel to intercept.
+   * @param interceptors array of interceptors to bind to {@code channel}.
+   * @return a new channel instance with the interceptors applied.
+   */
+  public static Channel interceptForward(Channel channel, ClientInterceptor... interceptors) {
+    return interceptForward(channel, Arrays.asList(interceptors));
+  }
+
+  /**
+   * Create a new {@link Channel} that will call {@code interceptors} before starting a call on the
+   * given channel. The first interceptor will have its {@link ClientInterceptor#interceptCall}
+   * called first.
+   *
+   * @param channel the underlying channel to intercept.
+   * @param interceptors a list of interceptors to bind to {@code channel}.
+   * @return a new channel instance with the interceptors applied.
+   */
+  public static Channel interceptForward(Channel channel,
+                                         List<? extends ClientInterceptor> interceptors) {
+    List<? extends ClientInterceptor> copy = new ArrayList<>(interceptors);
+    Collections.reverse(copy);
+    return intercept(channel, copy);
+  }
+
+  /**
+   * Create a new {@link Channel} that will call {@code interceptors} before starting a call on the
+   * given channel. The last interceptor will have its {@link ClientInterceptor#interceptCall}
+   * called first.
+   *
+   * @param channel the underlying channel to intercept.
+   * @param interceptors array of interceptors to bind to {@code channel}.
+   * @return a new channel instance with the interceptors applied.
+   */
+  public static Channel intercept(Channel channel, ClientInterceptor... interceptors) {
+    return intercept(channel, Arrays.asList(interceptors));
+  }
+
+  /**
+   * Create a new {@link Channel} that will call {@code interceptors} before starting a call on the
+   * given channel. The last interceptor will have its {@link ClientInterceptor#interceptCall}
+   * called first.
+   *
+   * @param channel the underlying channel to intercept.
+   * @param interceptors a list of interceptors to bind to {@code channel}.
+   * @return a new channel instance with the interceptors applied.
+   */
+  public static Channel intercept(Channel channel, List<? extends ClientInterceptor> interceptors) {
+    Preconditions.checkNotNull(channel, "channel");
+    for (ClientInterceptor interceptor : interceptors) {
+      channel = new InterceptorChannel(channel, interceptor);
+    }
+    return channel;
+  }
+
+  /**
+   * Creates a new ClientInterceptor that transforms requests into {@code WReqT} and responses into
+   * {@code WRespT} before passing them into the {@code interceptor}.
+   */
+  static <WReqT, WRespT> ClientInterceptor wrapClientInterceptor(
+      final ClientInterceptor interceptor,
+      final Marshaller<WReqT> reqMarshaller,
+      final Marshaller<WRespT> respMarshaller) {
+    return new ClientInterceptor() {
+      @Override
+      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+          final MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+        final MethodDescriptor<WReqT, WRespT> wrappedMethod =
+            method.toBuilder(reqMarshaller, respMarshaller).build();
+        final ClientCall<WReqT, WRespT> wrappedCall =
+            interceptor.interceptCall(wrappedMethod, callOptions, next);
+        return new PartialForwardingClientCall<ReqT, RespT>() {
+          @Override
+          public void start(final Listener<RespT> responseListener, Metadata headers) {
+            wrappedCall.start(new PartialForwardingClientCallListener<WRespT>() {
+              @Override
+              public void onMessage(WRespT wMessage) {
+                InputStream bytes = respMarshaller.stream(wMessage);
+                RespT message = method.getResponseMarshaller().parse(bytes);
+                responseListener.onMessage(message);
+              }
+
+              @Override
+              protected Listener<?> delegate() {
+                return responseListener;
+              }
+            }, headers);
+          }
+
+          @Override
+          public void sendMessage(ReqT message) {
+            InputStream bytes = method.getRequestMarshaller().stream(message);
+            WReqT wReq = reqMarshaller.parse(bytes);
+            wrappedCall.sendMessage(wReq);
+          }
+
+          @Override
+          protected ClientCall<?, ?> delegate() {
+            return wrappedCall;
+          }
+        };
+      }
+    };
+  }
+
+  private static class InterceptorChannel extends Channel {
+    private final Channel channel;
+    private final ClientInterceptor interceptor;
+
+    private InterceptorChannel(Channel channel, ClientInterceptor interceptor) {
+      this.channel = channel;
+      this.interceptor = Preconditions.checkNotNull(interceptor, "interceptor");
+    }
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions) {
+      return interceptor.interceptCall(method, callOptions, channel);
+    }
+
+    @Override
+    public String authority() {
+      return channel.authority();
+    }
+  }
+
+  private static final ClientCall<Object, Object> NOOP_CALL = new ClientCall<Object, Object>() {
+    @Override
+    public void start(Listener<Object> responseListener, Metadata headers) {}
+
+    @Override
+    public void request(int numMessages) {}
+
+    @Override
+    public void cancel(String message, Throwable cause) {}
+
+    @Override
+    public void halfClose() {}
+
+    @Override
+    public void sendMessage(Object message) {}
+
+    /**
+     * Always returns {@code false}, since this is only used when the startup of the {@link
+     * ClientCall} fails (i.e. the {@link ClientCall} is closed).
+     */
+    @Override
+    public boolean isReady() {
+      return false;
+    }
+  };
+
+  /**
+   * A {@link io.grpc.ForwardingClientCall} that delivers exceptions from its start logic to the
+   * call listener.
+   *
+   * <p>{@link ClientCall#start(ClientCall.Listener, Metadata)} should not throw any
+   * exception other than those caused by misuse, e.g., {@link IllegalStateException}.  {@code
+   * CheckedForwardingClientCall} provides {@code checkedStart()} in which throwing exceptions is
+   * allowed.
+   */
+  public abstract static class CheckedForwardingClientCall<ReqT, RespT>
+      extends io.grpc.ForwardingClientCall<ReqT, RespT> {
+
+    private ClientCall<ReqT, RespT> delegate;
+
+    /**
+     * Subclasses implement the start logic here that would normally belong to {@code start()}.
+     *
+     * <p>Implementation should call {@code this.delegate().start()} in the normal path. Exceptions
+     * may safely be thrown prior to calling {@code this.delegate().start()}. Such exceptions will
+     * be handled by {@code CheckedForwardingClientCall} and be delivered to {@code
+     * responseListener}.  Exceptions <em>must not</em> be thrown after calling {@code
+     * this.delegate().start()}, as this can result in {@link ClientCall.Listener#onClose} being
+     * called multiple times.
+     */
+    protected abstract void checkedStart(Listener<RespT> responseListener, Metadata headers)
+        throws Exception;
+
+    protected CheckedForwardingClientCall(ClientCall<ReqT, RespT> delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    protected final ClientCall<ReqT, RespT> delegate() {
+      return delegate;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public final void start(Listener<RespT> responseListener, Metadata headers) {
+      try {
+        checkedStart(responseListener, headers);
+      } catch (Exception e) {
+        // Because start() doesn't throw, the caller may still try to call other methods on this
+        // call object. Passing these invocations to the original delegate will cause
+        // IllegalStateException because delegate().start() was not called. We switch the delegate
+        // to a NO-OP one to prevent the IllegalStateException. The user will finally get notified
+        // about the error through the listener.
+        delegate = (ClientCall<ReqT, RespT>) NOOP_CALL;
+        Metadata trailers = Status.trailersFromThrowable(e);
+        responseListener.onClose(
+            Status.fromThrowable(e),
+            trailers != null ? trailers : new Metadata()
+        );
+      }
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/ClientStreamTracer.java b/api/src/main/java/io/grpc/ClientStreamTracer.java
new file mode 100644
index 00000000000..42e1fdfebea
--- /dev/null
+++ b/api/src/main/java/io/grpc/ClientStreamTracer.java
@@ -0,0 +1,273 @@
+/*
+ * Copyright 2017 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * {@link StreamTracer} for the client-side.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
+@ThreadSafe
+public abstract class ClientStreamTracer extends StreamTracer {
+  /**
+   * Indicates how long the call was delayed, in nanoseconds, due to waiting for name resolution
+   * result. If the call option is not set, the call did not experience name resolution delay.
+   */
+  public static final CallOptions.Key<Long> NAME_RESOLUTION_DELAYED =
+      CallOptions.Key.create("io.grpc.ClientStreamTracer.NAME_RESOLUTION_DELAYED");
+
+  /**
+   * The stream is being created on a ready transport.
+   *
+   * @param headers the mutable initial metadata. Modifications to it will be sent to the socket but
+   *     not be seen by client interceptors and the application.
+   *
+   * @since 1.40.0
+   */
+  public void streamCreated(@Grpc.TransportAttr Attributes transportAttrs, Metadata headers) {
+  }
+
+  /**
+   * Name resolution is completed and the connection starts getting established. This method is only
+   * invoked on the streams that encounter such delay.
+   *
+   * </p>gRPC buffers the client call if the remote address and configurations, e.g. timeouts and
+   * retry policy, are not ready. Asynchronously gRPC internally does the name resolution to get
+   * this information. The streams that are processed immediately on ready transports by the time
+   * the RPC comes do not go through the pending process, thus this callback will not be invoked.
+   */
+  public void createPendingStream() {
+  }
+
+  /**
+   * Headers has been sent to the socket.
+   */
+  public void outboundHeaders() {
+  }
+
+  /**
+   * Headers has been received from the server.
+   */
+  public void inboundHeaders() {
+  }
+
+  /**
+   * Headers has been received from the server. This method does not pass ownership to {@code
+   * headers}, so implementations must not access the metadata after returning. Modifications to the
+   * metadata within this method will be seen by interceptors and the application.
+   *
+   * @param headers the received header metadata
+   */
+  public void inboundHeaders(Metadata headers) {
+    inboundHeaders();
+  }
+
+  /**
+   * Trailing metadata has been received from the server. This method does not pass ownership to
+   * {@code trailers}, so implementations must not access the metadata after returning.
+   * Modifications to the metadata within this method will be seen by interceptors and the
+   * application.
+   *
+   * @param trailers the received trailing metadata
+   * @since 1.17.0
+   */
+  public void inboundTrailers(Metadata trailers) {
+  }
+
+  /**
+   * Information providing context to the call became available.
+   */
+  @Internal
+  public void addOptionalLabel(String key, String value) {
+  }
+
+  /**
+   * Factory class for {@link ClientStreamTracer}.
+   */
+  public abstract static class Factory {
+    /**
+     * Creates a {@link ClientStreamTracer} for a new client stream.  This is called inside the
+     * transport when it's creating the stream.
+     *
+     * @param info information about the stream
+     * @param headers the mutable headers of the stream. It can be safely mutated within this
+     *        method.  Changes made to it will be sent by the stream.  It should not be saved
+     *        because it is not safe for read or write after the method returns.
+     *
+     * @since 1.20.0
+     */
+    public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+      throw new UnsupportedOperationException("Not implemented");
+    }
+  }
+
+  /**
+   * Information about a stream.
+   *
+   * <p>Note this class doesn't override {@code equals()} and {@code hashCode}, as is the case for
+   * {@link CallOptions}.
+   *
+   * @since 1.20.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
+  public static final class StreamInfo {
+    private final CallOptions callOptions;
+    private final int previousAttempts;
+    private final boolean isTransparentRetry;
+    private final boolean isHedging;
+
+    StreamInfo(
+        CallOptions callOptions, int previousAttempts, boolean isTransparentRetry,
+        boolean isHedging) {
+      this.callOptions = checkNotNull(callOptions, "callOptions");
+      this.previousAttempts = previousAttempts;
+      this.isTransparentRetry = isTransparentRetry;
+      this.isHedging = isHedging;
+    }
+
+    /**
+     * Returns the effective CallOptions of the call.
+     */
+    public CallOptions getCallOptions() {
+      return callOptions;
+    }
+
+    /**
+     * Returns the number of preceding attempts for the RPC.
+     *
+     * @since 1.40.0
+     */
+    public int getPreviousAttempts() {
+      return previousAttempts;
+    }
+
+    /**
+     * Whether the stream is a transparent retry.
+     *
+     * @since 1.40.0
+     */
+    public boolean isTransparentRetry() {
+      return isTransparentRetry;
+    }
+
+    /**
+     * Whether the stream is hedging.
+     *
+     * @since 1.74.0
+     */
+    public boolean isHedging() {
+      return isHedging;
+    }
+
+    /**
+     * Converts this StreamInfo into a new Builder.
+     *
+     * @since 1.21.0
+     */
+    public Builder toBuilder() {
+      return new Builder()
+          .setCallOptions(callOptions)
+          .setPreviousAttempts(previousAttempts)
+          .setIsTransparentRetry(isTransparentRetry)
+          .setIsHedging(isHedging);
+
+    }
+
+    /**
+     * Creates an empty Builder.
+     *
+     * @since 1.21.0
+     */
+    public static Builder newBuilder() {
+      return new Builder();
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("callOptions", callOptions)
+          .add("previousAttempts", previousAttempts)
+          .add("isTransparentRetry", isTransparentRetry)
+          .add("isHedging", isHedging)
+          .toString();
+    }
+
+    /**
+     * Builds {@link StreamInfo} objects.
+     *
+     * @since 1.21.0
+     */
+    public static final class Builder {
+      private CallOptions callOptions = CallOptions.DEFAULT;
+      private int previousAttempts;
+      private boolean isTransparentRetry;
+      private boolean isHedging;
+
+      Builder() {
+      }
+
+      /**
+       * Sets the effective CallOptions of the call.  This field is optional.
+       */
+      public Builder setCallOptions(CallOptions callOptions) {
+        this.callOptions = checkNotNull(callOptions, "callOptions cannot be null");
+        return this;
+      }
+
+      /**
+       * Set the number of preceding attempts of the RPC.
+       *
+       * @since 1.40.0
+       */
+      public Builder setPreviousAttempts(int previousAttempts) {
+        this.previousAttempts = previousAttempts;
+        return this;
+      }
+
+      /**
+       * Sets whether the stream is a transparent retry.
+       *
+       * @since 1.40.0
+       */
+      public Builder setIsTransparentRetry(boolean isTransparentRetry) {
+        this.isTransparentRetry = isTransparentRetry;
+        return this;
+      }
+
+      /**
+       * Sets whether the stream is hedging.
+       *
+       * @since 1.74.0
+       */
+      public Builder setIsHedging(boolean isHedging) {
+        this.isHedging = isHedging;
+        return this;
+      }
+
+      /**
+       * Builds a new StreamInfo.
+       */
+      public StreamInfo build() {
+        return new StreamInfo(callOptions, previousAttempts, isTransparentRetry, isHedging);
+      }
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/ClientTransportFilter.java b/api/src/main/java/io/grpc/ClientTransportFilter.java
new file mode 100644
index 00000000000..5bcf4b6e195
--- /dev/null
+++ b/api/src/main/java/io/grpc/ClientTransportFilter.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2023 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;
+
+/**
+ * Listens on the client transport life-cycle events. These filters do not have the capability
+ * to modify the channels or transport life-cycle event behavior, but they can be useful hooks
+ * for transport observability. Multiple filters may be registered to the client.
+ *
+ * @since 1.62.0
+ */
+@ExperimentalApi("https://gitub.com/grpc/grpc-java/issues/10652")
+public abstract class ClientTransportFilter {
+  /**
+   * Called when a transport is ready to accept traffic (when a connection has been established).
+   * The default implementation is a no-op.
+   *
+   * @param transportAttrs current transport attributes
+   *
+   * @return new transport attributes. Default implementation returns the passed-in attributes
+   *     intact.
+   */
+  public Attributes transportReady(Attributes transportAttrs) {
+    return transportAttrs;
+  }
+
+  /**
+   * Called when a transport completed shutting down. All resources have been released.
+   * All streams have either been closed or transferred off this transport.
+   * Default implementation is a no-op
+   *
+   * @param transportAttrs the effective transport attributes, which is what is returned by {@link
+   * #transportReady} of the last executed filter.
+   */
+  public void transportTerminated(Attributes transportAttrs) {
+  }
+}
diff --git a/api/src/main/java/io/grpc/Codec.java b/api/src/main/java/io/grpc/Codec.java
new file mode 100644
index 00000000000..2d5b059f994
--- /dev/null
+++ b/api/src/main/java/io/grpc/Codec.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2015 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;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
+
+/**
+ * Encloses classes related to the compression and decompression of messages.
+ *
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
+public interface Codec extends Compressor, Decompressor {
+  /**
+   * A gzip compressor and decompressor.  In the future this will likely support other
+   * compression methods, such as compression level.
+   */
+  final class Gzip implements Codec {
+    @Override
+    public String getMessageEncoding() {
+      return "gzip";
+    }
+
+    @Override
+    public OutputStream compress(OutputStream os) throws IOException {
+      return new GZIPOutputStream(os);
+    }
+
+    @Override
+    public InputStream decompress(InputStream is) throws IOException {
+      return new GZIPInputStream(is);
+    }
+  }
+
+  /**
+   * The "identity", or "none" codec.  This codec is special in that it can be used to explicitly
+   * disable Call compression on a Channel that by default compresses.
+   */
+  final class Identity implements Codec {
+    /**
+     * Special sentinel codec indicating that no compression should be used.  Users should use
+     * reference equality to see if compression is disabled.
+     */
+    public static final Codec NONE = new Identity();
+
+    @Override
+    public InputStream decompress(InputStream is) {
+      return is;
+    }
+
+    @Override
+    public String getMessageEncoding() {
+      return "identity";
+    }
+
+    @Override
+    public OutputStream compress(OutputStream os) {
+      return os;
+    }
+
+    private Identity() {}
+  }
+}
diff --git a/api/src/main/java/io/grpc/CompositeCallCredentials.java b/api/src/main/java/io/grpc/CompositeCallCredentials.java
new file mode 100644
index 00000000000..6a8ac3872ea
--- /dev/null
+++ b/api/src/main/java/io/grpc/CompositeCallCredentials.java
@@ -0,0 +1,98 @@
+/*
+ * 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;
+
+import com.google.common.base.Preconditions;
+import java.util.concurrent.Executor;
+
+/**
+ * Uses multiple {@code CallCredentials} as if they were one. If the first credential fails, the
+ * second will not be used. Both must succeed to allow the RPC.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1914")
+public final class CompositeCallCredentials extends CallCredentials {
+  private final CallCredentials credentials1;
+  private final CallCredentials credentials2;
+
+  public CompositeCallCredentials(CallCredentials creds1, CallCredentials creds2) {
+    this.credentials1 = Preconditions.checkNotNull(creds1, "creds1");
+    this.credentials2 = Preconditions.checkNotNull(creds2, "creds2");
+  }
+
+  @Override
+  public void applyRequestMetadata(
+      RequestInfo requestInfo, Executor appExecutor, MetadataApplier applier) {
+    credentials1.applyRequestMetadata(requestInfo, appExecutor,
+        new WrappingMetadataApplier(requestInfo, appExecutor, applier, Context.current()));
+  }
+
+  private final class WrappingMetadataApplier extends MetadataApplier {
+    private final RequestInfo requestInfo;
+    private final Executor appExecutor;
+    private final MetadataApplier delegate;
+    private final Context context;
+
+    public WrappingMetadataApplier(
+        RequestInfo requestInfo, Executor appExecutor, MetadataApplier delegate, Context context) {
+      this.requestInfo = requestInfo;
+      this.appExecutor = appExecutor;
+      this.delegate = Preconditions.checkNotNull(delegate, "delegate");
+      this.context = Preconditions.checkNotNull(context, "context");
+    }
+
+    @Override
+    public void apply(Metadata headers) {
+      Preconditions.checkNotNull(headers, "headers");
+      Context previous = context.attach();
+      try {
+        credentials2.applyRequestMetadata(
+            requestInfo, appExecutor, new CombiningMetadataApplier(delegate, headers));
+      } finally {
+        context.detach(previous);
+      }
+    }
+
+    @Override
+    public void fail(Status status) {
+      delegate.fail(status);
+    }
+  }
+
+  private static final class CombiningMetadataApplier extends MetadataApplier {
+    private final MetadataApplier delegate;
+    private final Metadata firstHeaders;
+
+    public CombiningMetadataApplier(MetadataApplier delegate, Metadata firstHeaders) {
+      this.delegate = delegate;
+      this.firstHeaders = firstHeaders;
+    }
+
+    @Override
+    public void apply(Metadata headers) {
+      Preconditions.checkNotNull(headers, "headers");
+      Metadata combined = new Metadata();
+      combined.merge(firstHeaders);
+      combined.merge(headers);
+      delegate.apply(combined);
+    }
+
+    @Override
+    public void fail(Status status) {
+      delegate.fail(status);
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/CompositeChannelCredentials.java b/api/src/main/java/io/grpc/CompositeChannelCredentials.java
new file mode 100644
index 00000000000..3efa8b8627b
--- /dev/null
+++ b/api/src/main/java/io/grpc/CompositeChannelCredentials.java
@@ -0,0 +1,53 @@
+/*
+ * 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;
+
+import com.google.common.base.Preconditions;
+
+/**
+ * {@code ChannelCredentials} which use per-RPC {@link CallCredentials}. If the {@code
+ * ChannelCredentials} has multiple {@code CallCredentials} (e.g., a composite credential inside a
+ * composite credential), then all of the {@code CallCredentials} should be used; one {@code
+ * CallCredentials} does not override another.
+ */
+public final class CompositeChannelCredentials extends ChannelCredentials {
+  public static ChannelCredentials create(
+      ChannelCredentials channelCreds, CallCredentials callCreds) {
+    return new CompositeChannelCredentials(channelCreds, callCreds);
+  }
+
+  private final ChannelCredentials channelCredentials;
+  private final CallCredentials callCredentials;
+
+  private CompositeChannelCredentials(ChannelCredentials channelCreds, CallCredentials callCreds) {
+    this.channelCredentials = Preconditions.checkNotNull(channelCreds, "channelCreds");
+    this.callCredentials = Preconditions.checkNotNull(callCreds, "callCreds");
+  }
+
+  public ChannelCredentials getChannelCredentials() {
+    return channelCredentials;
+  }
+
+  public CallCredentials getCallCredentials() {
+    return callCredentials;
+  }
+
+  @Override
+  public ChannelCredentials withoutBearerTokens() {
+    return channelCredentials.withoutBearerTokens();
+  }
+}
diff --git a/api/src/main/java/io/grpc/Compressor.java b/api/src/main/java/io/grpc/Compressor.java
new file mode 100644
index 00000000000..a933faf51b9
--- /dev/null
+++ b/api/src/main/java/io/grpc/Compressor.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2015 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;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * Represents a message compressor.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
+public interface Compressor {
+  /**
+   * Returns the message encoding that this compressor uses.
+   *
+   * <p>This can be values such as "gzip", "deflate", "snappy", etc.
+   */
+  String getMessageEncoding();
+
+  /**
+   * Wraps an existing output stream with a compressing output stream.
+   * @param os The output stream of uncompressed data
+   * @return An output stream that compresses
+   */
+  OutputStream compress(OutputStream os) throws IOException;
+}
+
diff --git a/api/src/main/java/io/grpc/CompressorRegistry.java b/api/src/main/java/io/grpc/CompressorRegistry.java
new file mode 100644
index 00000000000..4711f6917d0
--- /dev/null
+++ b/api/src/main/java/io/grpc/CompressorRegistry.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2015 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.common.annotations.VisibleForTesting;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Encloses classes related to the compression and decompression of messages.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
+@ThreadSafe
+public final class CompressorRegistry {
+  private static final CompressorRegistry DEFAULT_INSTANCE = new CompressorRegistry(
+      new Codec.Gzip(),
+      Codec.Identity.NONE);
+
+  /**
+   * Returns the default instance used by gRPC when the registry is not specified.
+   * Currently the registry just contains support for gzip.
+   */
+  public static CompressorRegistry getDefaultInstance() {
+    return DEFAULT_INSTANCE;
+  }
+
+  /**
+   * Returns a new instance with no registered compressors.
+   */
+  public static CompressorRegistry newEmptyInstance() {
+    return new CompressorRegistry();
+  }
+
+  private final ConcurrentMap<String, Compressor> compressors;
+
+  @VisibleForTesting
+  CompressorRegistry(Compressor ...cs) {
+    compressors = new ConcurrentHashMap<>();
+    for (Compressor c : cs) {
+      compressors.put(c.getMessageEncoding(), c);
+    }
+  }
+
+  @Nullable
+  public Compressor lookupCompressor(String compressorName) {
+    return compressors.get(compressorName);
+  }
+
+  /**
+   * Registers a compressor for both decompression and message encoding negotiation.
+   *
+   * @param c The compressor to register
+   */
+  public void register(Compressor c) {
+    String encoding = c.getMessageEncoding();
+    checkArgument(!encoding.contains(","), "Comma is currently not allowed in message encoding");
+    compressors.put(encoding, c);
+  }
+}
diff --git a/api/src/main/java/io/grpc/Configurator.java b/api/src/main/java/io/grpc/Configurator.java
new file mode 100644
index 00000000000..90468769a8d
--- /dev/null
+++ b/api/src/main/java/io/grpc/Configurator.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 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;
+
+/**
+ * Provides hooks for modifying gRPC channels and servers during their construction.
+ */
+interface Configurator {
+  /**
+   * Allows implementations to modify the channel builder.
+   *
+   * @param channelBuilder the channel builder being constructed
+   */
+  default void configureChannelBuilder(ManagedChannelBuilder<?> channelBuilder) {}
+
+  /**
+   * Allows implementations to modify the server builder.
+   *
+   * @param serverBuilder the server builder being constructed
+   */
+  default void configureServerBuilder(ServerBuilder<?> serverBuilder) {}
+}
diff --git a/api/src/main/java/io/grpc/ConfiguratorRegistry.java b/api/src/main/java/io/grpc/ConfiguratorRegistry.java
new file mode 100644
index 00000000000..19d6703d308
--- /dev/null
+++ b/api/src/main/java/io/grpc/ConfiguratorRegistry.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2024 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;
+
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A registry for {@link Configurator} instances.
+ *
+ * <p>This class is responsible for maintaining a list of configurators and providing access to
+ * them. The default registry can be obtained using {@link #getDefaultRegistry()}.
+ */
+final class ConfiguratorRegistry {
+  private static ConfiguratorRegistry instance;
+
+  @GuardedBy("this")
+  private boolean wasConfiguratorsSet;
+  @GuardedBy("this")
+  private List<Configurator> configurators = Collections.emptyList();
+  @GuardedBy("this")
+  private int configuratorsCallCountBeforeSet = 0;
+
+  ConfiguratorRegistry() {}
+
+  /**
+   * Returns the default global instance of the configurator registry.
+   */
+  public static synchronized ConfiguratorRegistry getDefaultRegistry() {
+    if (instance == null) {
+      instance = new ConfiguratorRegistry();
+    }
+    return instance;
+  }
+
+  /**
+   * Sets the configurators in this registry. This method can only be called once.
+   *
+   * @param configurators the configurators to set
+   * @throws IllegalStateException if this method is called more than once
+   */
+  public synchronized void setConfigurators(List<? extends Configurator> configurators) {
+    if (wasConfiguratorsSet) {
+      throw new IllegalStateException("Configurators are already set");
+    }
+    this.configurators = Collections.unmodifiableList(new ArrayList<>(configurators));
+    wasConfiguratorsSet = true;
+  }
+
+  /**
+   * Returns a list of the configurators in this registry.
+   */
+  public synchronized List<Configurator> getConfigurators() {
+    if (!wasConfiguratorsSet) {
+      configuratorsCallCountBeforeSet++;
+    }
+    return configurators;
+  }
+
+  /**
+   * Returns the number of times getConfigurators() was called before
+   * setConfigurators() was successfully invoked.
+   */
+  public synchronized int getConfiguratorsCallCountBeforeSet() {
+    return configuratorsCallCountBeforeSet;
+  }
+
+  public synchronized boolean wasSetConfiguratorsCalled() {
+    return wasConfiguratorsSet;
+  }
+}
diff --git a/api/src/main/java/io/grpc/ConnectivityState.java b/api/src/main/java/io/grpc/ConnectivityState.java
new file mode 100644
index 00000000000..a7407efb2e9
--- /dev/null
+++ b/api/src/main/java/io/grpc/ConnectivityState.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2016 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;
+
+/**
+ * The connectivity states.
+ *
+ * @see <a href="https://github.com/grpc/grpc/blob/master/doc/connectivity-semantics-and-api.md">
+ *     more information</a>
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4359")
+public enum ConnectivityState {
+  /**
+   * The channel is trying to establish a connection and is waiting to make progress on one of the
+   * steps involved in name resolution, TCP connection establishment or TLS handshake. This may be
+   * used as the initial state for channels upon creation.
+   */
+  CONNECTING,
+
+  /**
+   * The channel has successfully established a connection all the way through TLS handshake (or
+   * equivalent) and all subsequent attempt to communicate have succeeded (or are pending without
+   * any known failure ).
+   */
+  READY,
+
+  /**
+   * There has been some transient failure (such as a TCP 3-way handshake timing out or a socket
+   * error). Channels in this state will eventually switch to the CONNECTING state and try to
+   * establish a connection again. Since retries are done with exponential backoff, channels that
+   * fail to connect will start out spending very little time in this state but as the attempts
+   * fail repeatedly, the channel will spend increasingly large amounts of time in this state. For
+   * many non-fatal failures (e.g., TCP connection attempts timing out because the server is not
+   * yet available), the channel may spend increasingly large amounts of time in this state.
+   */
+  TRANSIENT_FAILURE,
+
+  /**
+   * This is the state where the channel is not even trying to create a connection because of a
+   * lack of new or pending RPCs. New RPCs MAY be created in this state. Any attempt to start an
+   * RPC on the channel will push the channel out of this state to connecting. When there has been
+   * no RPC activity on a channel for a configurable IDLE_TIMEOUT, i.e., no new or pending (active)
+   * RPCs for this period, channels that are READY or CONNECTING switch to IDLE. Additionaly,
+   * channels that receive a GOAWAY when there are no active or pending RPCs should also switch to
+   * IDLE to avoid connection overload at servers that are attempting to shed connections.
+   */
+  IDLE,
+
+  /**
+   * This channel has started shutting down. Any new RPCs should fail immediately. Pending RPCs
+   * may continue running till the application cancels them. Channels may enter this state either
+   * because the application explicitly requested a shutdown or if a non-recoverable error has
+   * happened during attempts to connect communicate . (As of 6/12/2015, there are no known errors
+   * (while connecting or communicating) that are classified as non-recoverable) Channels that
+   * enter this state never leave this state.
+   */
+  SHUTDOWN
+}
diff --git a/api/src/main/java/io/grpc/ConnectivityStateInfo.java b/api/src/main/java/io/grpc/ConnectivityStateInfo.java
new file mode 100644
index 00000000000..e2c1624f36f
--- /dev/null
+++ b/api/src/main/java/io/grpc/ConnectivityStateInfo.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2016 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;
+
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+
+import com.google.common.base.Preconditions;
+
+/**
+ * A tuple of a {@link ConnectivityState} and its associated {@link Status}.
+ *
+ * <p>If the state is {@code TRANSIENT_FAILURE}, the status is never {@code OK}.  For other states,
+ * the status is always {@code OK}.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+public final class ConnectivityStateInfo {
+  private final ConnectivityState state;
+  private final Status status;
+
+  /**
+   * Returns an instance for a state that is not {@code TRANSIENT_FAILURE}.
+   *
+   * @throws IllegalArgumentException if {@code state} is {@code TRANSIENT_FAILURE}.
+   */
+  public static ConnectivityStateInfo forNonError(ConnectivityState state) {
+    Preconditions.checkArgument(
+        state != TRANSIENT_FAILURE,
+        "state is TRANSIENT_ERROR. Use forError() instead");
+    return new ConnectivityStateInfo(state, Status.OK);
+  }
+
+  /**
+   * Returns an instance for {@code TRANSIENT_FAILURE}, associated with an error status.
+   */
+  public static ConnectivityStateInfo forTransientFailure(Status error) {
+    Preconditions.checkArgument(!error.isOk(), "The error status must not be OK");
+    return new ConnectivityStateInfo(TRANSIENT_FAILURE, error);
+  }
+
+  /**
+   * Returns the state.
+   */
+  public ConnectivityState getState() {
+    return state;
+  }
+
+  /**
+   * Returns the status associated with the state.
+   *
+   * <p>If the state is {@code TRANSIENT_FAILURE}, the status is never {@code OK}.  For other
+   * states, the status is always {@code OK}.
+   */
+  public Status getStatus() {
+    return status;
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (!(other instanceof ConnectivityStateInfo)) {
+      return false;
+    }
+    ConnectivityStateInfo o = (ConnectivityStateInfo) other;
+    return state.equals(o.state) && status.equals(o.status);
+  }
+
+  @Override
+  public int hashCode() {
+    return state.hashCode() ^ status.hashCode();
+  }
+
+  @Override
+  public String toString() {
+    if (status.isOk()) {
+      return state.toString();
+    }
+    return state + "(" + status + ")";
+  }
+
+  private ConnectivityStateInfo(ConnectivityState state, Status status) {
+    this.state = Preconditions.checkNotNull(state, "state is null");
+    this.status = Preconditions.checkNotNull(status, "status is null");
+  }
+}
diff --git a/api/src/main/java/io/grpc/Contexts.java b/api/src/main/java/io/grpc/Contexts.java
new file mode 100644
index 00000000000..c62ffc80a38
--- /dev/null
+++ b/api/src/main/java/io/grpc/Contexts.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2015 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;
+
+import com.google.common.base.Preconditions;
+import java.util.concurrent.TimeoutException;
+
+/**
+ * Utility methods for working with {@link Context}s in GRPC.
+ */
+public final class Contexts {
+
+  private Contexts() {
+  }
+
+  /**
+   * Make the provided {@link Context} {@link Context#current()} for the creation of a listener
+   * to a received call and for all events received by that listener.
+   *
+   * <p>This utility is expected to be used by {@link ServerInterceptor} implementations that need
+   * to augment the {@link Context} in which the application does work when receiving events from
+   * the client.
+   *
+   * @param context to make {@link Context#current()}.
+   * @param call used to send responses to client.
+   * @param headers received from client.
+   * @param next handler used to create the listener to be wrapped.
+   * @return listener that will receive events in the scope of the provided context.
+   */
+  public static <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+        Context context,
+        ServerCall<ReqT, RespT> call,
+        Metadata headers,
+        ServerCallHandler<ReqT, RespT> next) {
+    Context previous = context.attach();
+    try {
+      return new ContextualizedServerCallListener<>(
+          next.startCall(call, headers),
+          context);
+    } finally {
+      context.detach(previous);
+    }
+  }
+
+  /**
+   * Implementation of {@link io.grpc.ForwardingServerCallListener} that attaches a context before
+   * dispatching calls to the delegate and detaches them after the call completes.
+   */
+  private static class ContextualizedServerCallListener<ReqT> extends
+      ForwardingServerCallListener.SimpleForwardingServerCallListener<ReqT> {
+    private final Context context;
+
+    public ContextualizedServerCallListener(ServerCall.Listener<ReqT> delegate, Context context) {
+      super(delegate);
+      this.context = context;
+    }
+
+    @Override
+    public void onMessage(ReqT message) {
+      Context previous = context.attach();
+      try {
+        super.onMessage(message);
+      } finally {
+        context.detach(previous);
+      }
+    }
+
+    @Override
+    public void onHalfClose() {
+      Context previous = context.attach();
+      try {
+        super.onHalfClose();
+      } finally {
+        context.detach(previous);
+      }
+    }
+
+    @Override
+    public void onCancel() {
+      Context previous = context.attach();
+      try {
+        super.onCancel();
+      } finally {
+        context.detach(previous);
+      }
+    }
+
+    @Override
+    public void onComplete() {
+      Context previous = context.attach();
+      try {
+        super.onComplete();
+      } finally {
+        context.detach(previous);
+      }
+    }
+
+    @Override
+    public void onReady() {
+      Context previous = context.attach();
+      try {
+        super.onReady();
+      } finally {
+        context.detach(previous);
+      }
+    }
+  }
+
+  /**
+   * Returns the {@link Status} of a cancelled context or {@code null} if the context
+   * is not cancelled.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1975")
+  public static Status statusFromCancelled(Context context) {
+    Preconditions.checkNotNull(context, "context must not be null");
+    if (!context.isCancelled()) {
+      return null;
+    }
+
+    Throwable cancellationCause = context.cancellationCause();
+    if (cancellationCause == null) {
+      return Status.CANCELLED.withDescription("io.grpc.Context was cancelled without error");
+    }
+    if (cancellationCause instanceof TimeoutException) {
+      return Status.DEADLINE_EXCEEDED
+          .withDescription(cancellationCause.getMessage())
+          .withCause(cancellationCause);
+    }
+    Status status = Status.fromThrowable(cancellationCause);
+    if (Status.Code.UNKNOWN.equals(status.getCode())
+        && status.getCause() == cancellationCause) {
+      // If fromThrowable could not determine a status, then
+      // just return CANCELLED.
+      return Status.CANCELLED.withDescription("Context cancelled").withCause(cancellationCause);
+    }
+    return status.withCause(cancellationCause);
+  }
+}
diff --git a/api/src/main/java/io/grpc/Decompressor.java b/api/src/main/java/io/grpc/Decompressor.java
new file mode 100644
index 00000000000..bdced215b39
--- /dev/null
+++ b/api/src/main/java/io/grpc/Decompressor.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2015 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;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Represents a message decompressor.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
+public interface Decompressor {
+  /**
+   * Returns the message encoding that this compressor uses.
+   *
+   * <p>This can be values such as "gzip", "deflate", "snappy", etc.
+   */
+  String getMessageEncoding();
+
+  /**
+   * Wraps an existing input stream with a decompressing input stream.
+   * @param is The input stream of uncompressed data
+   * @return An input stream that decompresses
+   */
+  InputStream decompress(InputStream is) throws IOException;
+}
+
diff --git a/api/src/main/java/io/grpc/DecompressorRegistry.java b/api/src/main/java/io/grpc/DecompressorRegistry.java
new file mode 100644
index 00000000000..ea0433d8d0a
--- /dev/null
+++ b/api/src/main/java/io/grpc/DecompressorRegistry.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2015 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Joiner;
+import java.nio.charset.Charset;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Encloses classes related to the compression and decompression of messages.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
+@ThreadSafe
+public final class DecompressorRegistry {
+  static final Joiner ACCEPT_ENCODING_JOINER = Joiner.on(',');
+
+  public static DecompressorRegistry emptyInstance() {
+    return new DecompressorRegistry();
+  }
+
+  private static final DecompressorRegistry DEFAULT_INSTANCE =
+      emptyInstance()
+      .with(new Codec.Gzip(), true)
+      .with(Codec.Identity.NONE, false);
+
+  public static DecompressorRegistry getDefaultInstance() {
+    return DEFAULT_INSTANCE;
+  }
+
+  private final Map<String, DecompressorInfo> decompressors;
+  private final byte[] advertisedDecompressors;
+
+  /**
+   * Registers a decompressor for both decompression and message encoding negotiation.  Returns a
+   * new registry.
+   *
+   * @param d The decompressor to register
+   * @param advertised If true, the message encoding will be listed in the Accept-Encoding header.
+   */
+  public DecompressorRegistry with(Decompressor d, boolean advertised) {
+    return new DecompressorRegistry(d, advertised, this);
+  }
+
+  private DecompressorRegistry(Decompressor d, boolean advertised, DecompressorRegistry parent) {
+    String encoding = d.getMessageEncoding();
+    checkArgument(!encoding.contains(","), "Comma is currently not allowed in message encoding");
+
+    int newSize = parent.decompressors.size();
+    if (!parent.decompressors.containsKey(d.getMessageEncoding())) {
+      newSize++;
+    }
+    Map<String, DecompressorInfo> newDecompressors =
+        new LinkedHashMap<>(newSize);
+    for (DecompressorInfo di : parent.decompressors.values()) {
+      String previousEncoding = di.decompressor.getMessageEncoding();
+      if (!previousEncoding.equals(encoding)) {
+        newDecompressors.put(
+            previousEncoding, new DecompressorInfo(di.decompressor, di.advertised));
+      }
+    }
+    newDecompressors.put(encoding, new DecompressorInfo(d, advertised));
+
+    decompressors = Collections.unmodifiableMap(newDecompressors);
+    advertisedDecompressors = ACCEPT_ENCODING_JOINER.join(getAdvertisedMessageEncodings())
+        .getBytes(Charset.forName("US-ASCII"));
+  }
+
+  private DecompressorRegistry() {
+    decompressors = new LinkedHashMap<>(0);
+    advertisedDecompressors = new byte[0];
+  }
+
+  /**
+   * Provides a list of all message encodings that have decompressors available.
+   */
+  public Set<String> getKnownMessageEncodings() {
+    return decompressors.keySet();
+  }
+
+
+  byte[] getRawAdvertisedMessageEncodings() {
+    return advertisedDecompressors;
+  }
+
+  /**
+   * Provides a list of all message encodings that have decompressors available and should be
+   * advertised.
+   *
+   * <p>The specification doesn't say anything about ordering, or preference, so the returned codes
+   * can be arbitrary.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
+  public Set<String> getAdvertisedMessageEncodings() {
+    Set<String> advertisedDecompressors = new HashSet<>(decompressors.size());
+    for (Map.Entry<String, DecompressorInfo> entry : decompressors.entrySet()) {
+      if (entry.getValue().advertised) {
+        advertisedDecompressors.add(entry.getKey());
+      }
+    }
+    return Collections.unmodifiableSet(advertisedDecompressors);
+  }
+
+  /**
+   * Returns a decompressor for the given message encoding, or {@code null} if none has been
+   * registered.
+   *
+   * <p>This ignores whether the compressor is advertised.  According to the spec, if we know how
+   * to process this encoding, we attempt to, regardless of whether or not it is part of the
+   * encodings sent to the remote host.
+   */
+  @Nullable
+  public Decompressor lookupDecompressor(String messageEncoding) {
+    DecompressorInfo info = decompressors.get(messageEncoding);
+    return info != null ? info.decompressor : null;
+  }
+
+  /**
+   * Information about a decompressor.
+   */
+  private static final class DecompressorInfo {
+    final Decompressor decompressor;
+    final boolean advertised;
+
+    DecompressorInfo(Decompressor decompressor, boolean advertised) {
+      this.decompressor = checkNotNull(decompressor, "decompressor");
+      this.advertised = advertised;
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/Detachable.java b/api/src/main/java/io/grpc/Detachable.java
new file mode 100644
index 00000000000..3cb0ed26502
--- /dev/null
+++ b/api/src/main/java/io/grpc/Detachable.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2021 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;
+
+import java.io.InputStream;
+
+/**
+ * An extension of {@link InputStream} that allows the underlying data source to be detached and
+ * transferred to a new instance of the same kind. The detached InputStream takes over the
+ * ownership of the underlying data source. That's said, the detached InputStream is responsible
+ * for releasing its resources after use. The detached InputStream preserves internal states of
+ * the underlying data source. Data can be consumed through the detached InputStream as if being
+ * continually consumed through the original instance. The original instance discards internal
+ * states of detached data source and is no longer consumable as if the data source is exhausted.
+ *
+ * <p>A normal usage of this API is to extend the lifetime of the data source owned by the
+ * original instance for doing extra processing before releasing it. For example, when combined
+ * with {@link HasByteBuffer}, a custom {@link io.grpc.MethodDescriptor.Marshaller} can take
+ * over the ownership of buffers containing inbound data and perform delayed deserialization.
+ */
+public interface Detachable {
+
+  /**
+   * Detaches the underlying data source from this instance and transfers to an {@link
+   * InputStream}. Detaching data from an already-detached instance gives an InputStream with
+   * zero bytes of data.
+   *
+   */
+  InputStream detach();
+}
diff --git a/api/src/main/java/io/grpc/DoubleCounterMetricInstrument.java b/api/src/main/java/io/grpc/DoubleCounterMetricInstrument.java
new file mode 100644
index 00000000000..3f07d83d58f
--- /dev/null
+++ b/api/src/main/java/io/grpc/DoubleCounterMetricInstrument.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2024 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;
+
+import java.util.List;
+
+/**
+ * Represents a double-valued counter metric instrument.
+ */
+@Internal
+public final class DoubleCounterMetricInstrument extends PartialMetricInstrument {
+  public DoubleCounterMetricInstrument(int index, String name, String description, String unit,
+      List<String> requiredLabelKeys, List<String> optionalLabelKeys, boolean enableByDefault) {
+    super(index, name, description, unit, requiredLabelKeys, optionalLabelKeys, enableByDefault);
+  }
+}
diff --git a/api/src/main/java/io/grpc/DoubleHistogramMetricInstrument.java b/api/src/main/java/io/grpc/DoubleHistogramMetricInstrument.java
new file mode 100644
index 00000000000..9039a8c62c1
--- /dev/null
+++ b/api/src/main/java/io/grpc/DoubleHistogramMetricInstrument.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2024 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;
+
+import java.util.List;
+
+/**
+ * Represents a double-valued histogram metric instrument.
+ */
+@Internal
+public final class DoubleHistogramMetricInstrument extends PartialMetricInstrument {
+  private final List<Double> bucketBoundaries;
+
+  public DoubleHistogramMetricInstrument(int index, String name, String description, String unit,
+      List<Double> bucketBoundaries, List<String> requiredLabelKeys, List<String> optionalLabelKeys,
+      boolean enableByDefault) {
+    super(index, name, description, unit, requiredLabelKeys, optionalLabelKeys, enableByDefault);
+    this.bucketBoundaries = bucketBoundaries;
+  }
+
+  public List<Double> getBucketBoundaries() {
+    return bucketBoundaries;
+  }
+}
diff --git a/api/src/main/java/io/grpc/Drainable.java b/api/src/main/java/io/grpc/Drainable.java
new file mode 100644
index 00000000000..7b7cf5ca2cc
--- /dev/null
+++ b/api/src/main/java/io/grpc/Drainable.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2014 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;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * Extension to an {@link java.io.InputStream} or alike by adding a method that transfers all
+ * content to an {@link OutputStream}.
+ *
+ * <p>This can be used for optimizing for the case where the content of the input stream will be
+ * written to an {@link OutputStream} eventually. Instead of copying the content to a byte array
+ * through {@code read()}, then writing the {@code OutputStream}, the implementation can write
+ * the content directly to the {@code OutputStream}.
+ */
+public interface Drainable {
+
+  /**
+   * Transfers the entire contents of this stream to the specified target.
+   *
+   * @param target to write to.
+   * @return number of bytes written.
+   */
+  int drainTo(OutputStream target) throws IOException;
+}
diff --git a/api/src/main/java/io/grpc/EquivalentAddressGroup.java b/api/src/main/java/io/grpc/EquivalentAddressGroup.java
new file mode 100644
index 00000000000..bf8a864902c
--- /dev/null
+++ b/api/src/main/java/io/grpc/EquivalentAddressGroup.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright 2015 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;
+
+import com.google.common.base.Preconditions;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A group of {@link SocketAddress}es that are considered equivalent when channel makes connections.
+ *
+ * <p>Usually the addresses are addresses resolved from the same host name, and connecting to any of
+ * them is equally sufficient. They do have order. An address appears earlier on the list is likely
+ * to be tried earlier.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
+public final class EquivalentAddressGroup {
+
+  /**
+   * The authority to be used when constructing Subchannels for this EquivalentAddressGroup.
+   * However, if the channel has overridden authority via
+   * {@link ManagedChannelBuilder#overrideAuthority(String)}, the transport will use the channel's
+   * authority override.
+   *
+   * <p>The authority <strong>must</strong> be from a trusted source, because if the authority is
+   * tampered with, RPCs may be sent to attackers which may leak sensitive user data. If the
+   * authority was acquired by doing I/O, the communication must be authenticated (e.g., via TLS).
+   * Recognize that the server that provided the authority can trivially impersonate the service.
+   */
+  @Attr
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/6138")
+  public static final Attributes.Key<String> ATTR_AUTHORITY_OVERRIDE =
+      Attributes.Key.create("io.grpc.EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE");
+  /**
+   * The name of the locality that this EquivalentAddressGroup is in.
+   */
+  public static final Attributes.Key<String> ATTR_LOCALITY_NAME =
+      Attributes.Key.create("io.grpc.EquivalentAddressGroup.LOCALITY");
+  private final List<SocketAddress> addrs;
+  private final Attributes attrs;
+
+  /**
+   * {@link SocketAddress} docs say that the addresses are immutable, so we cache the hashCode.
+   */
+  private final int hashCode;
+
+  /**
+   * List constructor without {@link Attributes}.
+   */
+  public EquivalentAddressGroup(List<SocketAddress> addrs) {
+    this(addrs, Attributes.EMPTY);
+  }
+
+  /**
+   * List constructor with {@link Attributes}.
+   */
+  public EquivalentAddressGroup(List<SocketAddress> addrs, @Attr Attributes attrs) {
+    Preconditions.checkArgument(!addrs.isEmpty(), "addrs is empty");
+    this.addrs = Collections.unmodifiableList(new ArrayList<>(addrs));
+    this.attrs = Preconditions.checkNotNull(attrs, "attrs");
+    // Attributes may contain mutable objects, which means Attributes' hashCode may change over
+    // time, thus we don't cache Attributes' hashCode.
+    hashCode = this.addrs.hashCode();
+  }
+
+  /**
+   * Singleton constructor without Attributes.
+   */
+  public EquivalentAddressGroup(SocketAddress addr) {
+    this(addr, Attributes.EMPTY);
+  }
+
+  /**
+   * Singleton constructor with Attributes.
+   */
+  public EquivalentAddressGroup(SocketAddress addr, @Attr Attributes attrs) {
+    this(Collections.singletonList(addr), attrs);
+  }
+
+  /**
+   * Returns an immutable list of the addresses.
+   */
+  public List<SocketAddress> getAddresses() {
+    return addrs;
+  }
+
+  /**
+   * Returns the attributes.
+   */
+  @Attr
+  public Attributes getAttributes() {
+    return attrs;
+  }
+
+  @Override
+  public String toString() {
+    // TODO(zpencer): Summarize return value if addr is very large
+    return "[" + addrs + "/" + attrs + "]";
+  }
+
+  @Override
+  public int hashCode() {
+    // Avoids creating an iterator on the underlying array list.
+    return hashCode;
+  }
+
+  /**
+   * Returns true if the given object is also an {@link EquivalentAddressGroup} with an equal
+   * address list and equal attribute values.
+   *
+   * <p>Note that if the attributes include mutable values, it is possible for two objects to be
+   * considered equal at one point in time and not equal at another (due to concurrent mutation of
+   * attribute values).
+   */
+  @Override
+  public boolean equals(Object other) {
+    if (this == other) {
+      return true;
+    }
+    if (!(other instanceof EquivalentAddressGroup)) {
+      return false;
+    }
+    EquivalentAddressGroup that = (EquivalentAddressGroup) other;
+    if (addrs.size() != that.addrs.size()) {
+      return false;
+    }
+    // Avoids creating an iterator on the underlying array list.
+    for (int i = 0; i < addrs.size(); i++) {
+      if (!addrs.get(i).equals(that.addrs.get(i))) {
+        return false;
+      }
+    }
+    if (!attrs.equals(that.attrs)) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * Annotation for {@link EquivalentAddressGroup}'s attributes. It follows the annotation semantics
+   * defined by {@link Attributes}.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4972")
+  @Retention(RetentionPolicy.SOURCE)
+  @Documented
+  public @interface Attr {}
+}
diff --git a/api/src/main/java/io/grpc/ExperimentalApi.java b/api/src/main/java/io/grpc/ExperimentalApi.java
new file mode 100644
index 00000000000..c7d5eec9291
--- /dev/null
+++ b/api/src/main/java/io/grpc/ExperimentalApi.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2015 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;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Indicates a public API that can change at any time, and has no guarantee of API stability and
+ * backward-compatibility. If users want stabilization or signature change of a specific API that
+ * is currently annotated {@code @ExperimentalApi}, please comment on its tracking issue on github
+ * with rationale, usecase, and so forth, so that the gRPC team may prioritize the process toward
+ * stabilization of the API.
+ *
+ * <p>Usage guidelines:
+ * <ol>
+ * <li>This annotation is used only on public API. Internal interfaces should not use it.</li>
+ * <li>After gRPC has gained API stability, this annotation can only be added to new API. Adding it
+ * to an existing API is considered API-breaking.</li>
+ * <li>Removing this annotation from an API gives it stable status.</li>
+ * </ol>
+ *
+ * <p>Note: This annotation is intended only for gRPC library code. Users should not attach this
+ * annotation to their own code.
+ *
+ * <p>See: <a href="https://github.com/grpc/grpc-java-api-checker">grpc-java-api-checker</a>, an
+ * Error Prone plugin to automatically check for usages of this API.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target({
+    ElementType.ANNOTATION_TYPE,
+    ElementType.CONSTRUCTOR,
+    ElementType.FIELD,
+    ElementType.METHOD,
+    ElementType.PACKAGE,
+    ElementType.TYPE})
+@Documented
+public @interface ExperimentalApi {
+  /**
+   * Context information such as links to discussion thread, tracking issue etc.
+   */
+  String value();
+}
diff --git a/api/src/main/java/io/grpc/ForwardingChannelBuilder.java b/api/src/main/java/io/grpc/ForwardingChannelBuilder.java
new file mode 100644
index 00000000000..1202582421a
--- /dev/null
+++ b/api/src/main/java/io/grpc/ForwardingChannelBuilder.java
@@ -0,0 +1,253 @@
+/*
+ * Copyright 2017 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;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link ManagedChannelBuilder} that delegates all its builder methods to another builder by
+ * default.
+ *
+ * <p>DEPRECATED: Use {@link ForwardingChannelBuilder2} instead!
+ *
+ * <p>This class mistakenly used {@code <T extends ForwardingChannelBuilder<T>>} which causes
+ * return types to be {@link ForwardingChannelBuilder} instead of {@link ManagedChannelBuilder}.
+ * This pollutes the ABI of its subclasses with undesired method signatures.
+ * {@link ForwardingChannelBuilder2} generates correct return types; use it instead.
+ *
+ * @param <T> The type of the subclass extending this abstract class.
+ * @since 1.7.0
+ */
+public abstract class ForwardingChannelBuilder<T extends ForwardingChannelBuilder<T>>
+    extends ForwardingChannelBuilder2<T> {
+  /**
+   * The default constructor.
+   */
+  protected ForwardingChannelBuilder() {
+  }
+
+
+  /**
+   * Returns the delegated {@code ManagedChannelBuilder}.
+   *
+   * <p>NOTE: this method is marked deprecated instead the class itself, so that classes extending
+   * {@link ForwardingChannelBuilder2} won't need class-level
+   * {@code @SuppressWarnings("deprecation")} annotation. Such annotation would suppress all
+   * deprecation warnings in all methods, inadvertently hiding any real deprecation warnings needing
+   * to be addressed. However, each child class is expected to implement {@code delegate()}.
+   * Therefore, the {@code @Deprecated} annotation is added to this method, and not to the class.
+   *
+   * @deprecated As of 1.60.0, use {@link ForwardingChannelBuilder2} instead.
+   */
+  @Override
+  @Deprecated
+  protected abstract ManagedChannelBuilder<?> delegate();
+
+  @Override
+  public T directExecutor() {
+    delegate().directExecutor();
+    return thisT();
+  }
+
+  @Override
+  public T executor(Executor executor) {
+    delegate().executor(executor);
+    return thisT();
+  }
+
+  @Override
+  public T offloadExecutor(Executor executor) {
+    delegate().offloadExecutor(executor);
+    return thisT();
+  }
+
+  @Override
+  public T intercept(List<ClientInterceptor> interceptors) {
+    delegate().intercept(interceptors);
+    return thisT();
+  }
+
+  @Override
+  public T intercept(ClientInterceptor... interceptors) {
+    delegate().intercept(interceptors);
+    return thisT();
+  }
+
+  @Override
+  public T userAgent(String userAgent) {
+    delegate().userAgent(userAgent);
+    return thisT();
+  }
+
+  @Override
+  public T overrideAuthority(String authority) {
+    delegate().overrideAuthority(authority);
+    return thisT();
+  }
+
+  @Override
+  public T usePlaintext() {
+    delegate().usePlaintext();
+    return thisT();
+  }
+
+  @Override
+  public T useTransportSecurity() {
+    delegate().useTransportSecurity();
+    return thisT();
+  }
+
+  @Deprecated
+  @Override
+  public T nameResolverFactory(NameResolver.Factory resolverFactory) {
+    delegate().nameResolverFactory(resolverFactory);
+    return thisT();
+  }
+
+  @Override
+  public T defaultLoadBalancingPolicy(String policy) {
+    delegate().defaultLoadBalancingPolicy(policy);
+    return thisT();
+  }
+
+  @Override
+  public T decompressorRegistry(DecompressorRegistry registry) {
+    delegate().decompressorRegistry(registry);
+    return thisT();
+  }
+
+  @Override
+  public T compressorRegistry(CompressorRegistry registry) {
+    delegate().compressorRegistry(registry);
+    return thisT();
+  }
+
+  @Override
+  public T idleTimeout(long value, TimeUnit unit) {
+    delegate().idleTimeout(value, unit);
+    return thisT();
+  }
+
+  @Override
+  public T maxInboundMessageSize(int max) {
+    delegate().maxInboundMessageSize(max);
+    return thisT();
+  }
+
+  @Override
+  public T maxInboundMetadataSize(int max) {
+    delegate().maxInboundMetadataSize(max);
+    return thisT();
+  }
+
+  @Override
+  public T keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    delegate().keepAliveTime(keepAliveTime, timeUnit);
+    return thisT();
+  }
+
+  @Override
+  public T keepAliveTimeout(long keepAliveTimeout, TimeUnit timeUnit) {
+    delegate().keepAliveTimeout(keepAliveTimeout, timeUnit);
+    return thisT();
+  }
+
+  @Override
+  public T keepAliveWithoutCalls(boolean enable) {
+    delegate().keepAliveWithoutCalls(enable);
+    return thisT();
+  }
+
+  @Override
+  public T maxRetryAttempts(int maxRetryAttempts) {
+    delegate().maxRetryAttempts(maxRetryAttempts);
+    return thisT();
+  }
+
+  @Override
+  public T maxHedgedAttempts(int maxHedgedAttempts) {
+    delegate().maxHedgedAttempts(maxHedgedAttempts);
+    return thisT();
+  }
+
+  @Override
+  public T retryBufferSize(long bytes) {
+    delegate().retryBufferSize(bytes);
+    return thisT();
+  }
+
+  @Override
+  public T perRpcBufferLimit(long bytes) {
+    delegate().perRpcBufferLimit(bytes);
+    return thisT();
+  }
+
+  @Override
+  public T disableRetry() {
+    delegate().disableRetry();
+    return thisT();
+  }
+
+  @Override
+  public T enableRetry() {
+    delegate().enableRetry();
+    return thisT();
+  }
+
+  @Override
+  public T setBinaryLog(BinaryLog binaryLog) {
+    delegate().setBinaryLog(binaryLog);
+    return thisT();
+  }
+
+  @Override
+  public T maxTraceEvents(int maxTraceEvents) {
+    delegate().maxTraceEvents(maxTraceEvents);
+    return thisT();
+  }
+
+  @Override
+  public T proxyDetector(ProxyDetector proxyDetector) {
+    delegate().proxyDetector(proxyDetector);
+    return thisT();
+  }
+
+  @Override
+  public T defaultServiceConfig(@Nullable Map<String, ?> serviceConfig) {
+    delegate().defaultServiceConfig(serviceConfig);
+    return thisT();
+  }
+
+  @Override
+  public T disableServiceConfigLookUp() {
+    delegate().disableServiceConfigLookUp();
+    return thisT();
+  }
+
+  /**
+   * Returns the correctly typed version of the builder.
+   */
+  private T thisT() {
+    @SuppressWarnings("unchecked")
+    T thisT = (T) this;
+    return thisT;
+  }
+}
diff --git a/api/src/main/java/io/grpc/ForwardingChannelBuilder2.java b/api/src/main/java/io/grpc/ForwardingChannelBuilder2.java
new file mode 100644
index 00000000000..78fe730d91a
--- /dev/null
+++ b/api/src/main/java/io/grpc/ForwardingChannelBuilder2.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright 2023 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;
+
+import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.DoNotCall;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link ManagedChannelBuilder} that delegates all its builder methods to another builder by
+ * default.
+ *
+ * <p>Always choose this over {@link ForwardingChannelBuilder}, because
+ * {@link ForwardingChannelBuilder2} is ABI-safe.
+ *
+ * @param <T> The type of the subclass extending this abstract class.
+ * @since 1.59.0
+ */
+public abstract class ForwardingChannelBuilder2<T extends ManagedChannelBuilder<T>>
+    extends ManagedChannelBuilder<T> {
+
+  /**
+   * The default constructor.
+   */
+  protected ForwardingChannelBuilder2() {
+  }
+
+  /**
+   * This method serves to force subclasses to "hide" this static factory.
+   */
+  @DoNotCall("Unsupported")
+  public static ManagedChannelBuilder<?> forAddress(String name, int port) {
+    throw new UnsupportedOperationException("Subclass failed to hide static factory");
+  }
+
+  /**
+   * This method serves to force subclasses to "hide" this static factory.
+   */
+  @DoNotCall("Unsupported")
+  public static ManagedChannelBuilder<?> forTarget(String target) {
+    throw new UnsupportedOperationException("Subclass failed to hide static factory");
+  }
+
+  /**
+   * Returns the delegated {@code ManagedChannelBuilder}.
+   */
+  protected abstract ManagedChannelBuilder<?> delegate();
+
+  @Override
+  public T directExecutor() {
+    delegate().directExecutor();
+    return thisT();
+  }
+
+  @Override
+  public T executor(Executor executor) {
+    delegate().executor(executor);
+    return thisT();
+  }
+
+  @Override
+  public T offloadExecutor(Executor executor) {
+    delegate().offloadExecutor(executor);
+    return thisT();
+  }
+
+  @Override
+  public T intercept(List<ClientInterceptor> interceptors) {
+    delegate().intercept(interceptors);
+    return thisT();
+  }
+
+  @Override
+  public T intercept(ClientInterceptor... interceptors) {
+    delegate().intercept(interceptors);
+    return thisT();
+  }
+
+  @Override
+  protected T interceptWithTarget(InterceptorFactory factory) {
+    delegate().interceptWithTarget(factory);
+    return thisT();
+  }
+
+  @Override
+  public T addTransportFilter(ClientTransportFilter transportFilter) {
+    delegate().addTransportFilter(transportFilter);
+    return thisT();
+  }
+
+  @Override
+  public T userAgent(String userAgent) {
+    delegate().userAgent(userAgent);
+    return thisT();
+  }
+
+  @Override
+  public T overrideAuthority(String authority) {
+    delegate().overrideAuthority(authority);
+    return thisT();
+  }
+
+  @Override
+  public T usePlaintext() {
+    delegate().usePlaintext();
+    return thisT();
+  }
+
+  @Override
+  public T useTransportSecurity() {
+    delegate().useTransportSecurity();
+    return thisT();
+  }
+
+  @Deprecated
+  @Override
+  public T nameResolverFactory(NameResolver.Factory resolverFactory) {
+    delegate().nameResolverFactory(resolverFactory);
+    return thisT();
+  }
+
+  @Override
+  public T defaultLoadBalancingPolicy(String policy) {
+    delegate().defaultLoadBalancingPolicy(policy);
+    return thisT();
+  }
+
+  @Override
+  public T decompressorRegistry(DecompressorRegistry registry) {
+    delegate().decompressorRegistry(registry);
+    return thisT();
+  }
+
+  @Override
+  public T compressorRegistry(CompressorRegistry registry) {
+    delegate().compressorRegistry(registry);
+    return thisT();
+  }
+
+  @Override
+  public T idleTimeout(long value, TimeUnit unit) {
+    delegate().idleTimeout(value, unit);
+    return thisT();
+  }
+
+  @Override
+  public T maxInboundMessageSize(int max) {
+    delegate().maxInboundMessageSize(max);
+    return thisT();
+  }
+
+  @Override
+  public T maxInboundMetadataSize(int max) {
+    delegate().maxInboundMetadataSize(max);
+    return thisT();
+  }
+
+  @Override
+  public T keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    delegate().keepAliveTime(keepAliveTime, timeUnit);
+    return thisT();
+  }
+
+  @Override
+  public T keepAliveTimeout(long keepAliveTimeout, TimeUnit timeUnit) {
+    delegate().keepAliveTimeout(keepAliveTimeout, timeUnit);
+    return thisT();
+  }
+
+  @Override
+  public T keepAliveWithoutCalls(boolean enable) {
+    delegate().keepAliveWithoutCalls(enable);
+    return thisT();
+  }
+
+  @Override
+  public T maxRetryAttempts(int maxRetryAttempts) {
+    delegate().maxRetryAttempts(maxRetryAttempts);
+    return thisT();
+  }
+
+  @Override
+  public T maxHedgedAttempts(int maxHedgedAttempts) {
+    delegate().maxHedgedAttempts(maxHedgedAttempts);
+    return thisT();
+  }
+
+  @Override
+  public T retryBufferSize(long bytes) {
+    delegate().retryBufferSize(bytes);
+    return thisT();
+  }
+
+  @Override
+  public T perRpcBufferLimit(long bytes) {
+    delegate().perRpcBufferLimit(bytes);
+    return thisT();
+  }
+
+  @Override
+  public T disableRetry() {
+    delegate().disableRetry();
+    return thisT();
+  }
+
+  @Override
+  public T enableRetry() {
+    delegate().enableRetry();
+    return thisT();
+  }
+
+  @Override
+  public T setBinaryLog(BinaryLog binaryLog) {
+    delegate().setBinaryLog(binaryLog);
+    return thisT();
+  }
+
+  @Override
+  public T maxTraceEvents(int maxTraceEvents) {
+    delegate().maxTraceEvents(maxTraceEvents);
+    return thisT();
+  }
+
+  @Override
+  public T proxyDetector(ProxyDetector proxyDetector) {
+    delegate().proxyDetector(proxyDetector);
+    return thisT();
+  }
+
+  @Override
+  public T defaultServiceConfig(@Nullable Map<String, ?> serviceConfig) {
+    delegate().defaultServiceConfig(serviceConfig);
+    return thisT();
+  }
+
+  @Override
+  public T disableServiceConfigLookUp() {
+    delegate().disableServiceConfigLookUp();
+    return thisT();
+  }
+
+  @Override
+  protected T addMetricSink(MetricSink metricSink) {
+    delegate().addMetricSink(metricSink);
+    return thisT();
+  }
+
+  @Override
+  public <X> T setNameResolverArg(NameResolver.Args.Key<X> key, X value) {
+    delegate().setNameResolverArg(key, value);
+    return thisT();
+  }
+
+  /**
+   * Returns the {@link ManagedChannel} built by the delegate by default. Overriding method can
+   * return different value.
+   */
+  @Override
+  public ManagedChannel build() {
+    return delegate().build();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+
+  /**
+   * Returns the correctly typed version of the builder.
+   */
+  private T thisT() {
+    @SuppressWarnings("unchecked")
+    T thisT = (T) this;
+    return thisT;
+  }
+}
diff --git a/api/src/main/java/io/grpc/ForwardingClientCall.java b/api/src/main/java/io/grpc/ForwardingClientCall.java
new file mode 100644
index 00000000000..626cd5d961d
--- /dev/null
+++ b/api/src/main/java/io/grpc/ForwardingClientCall.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2015 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;
+
+/**
+ * A {@link ClientCall} which forwards all of its methods to another {@link ClientCall}.
+ */
+public abstract class ForwardingClientCall<ReqT, RespT>
+    extends PartialForwardingClientCall<ReqT, RespT> {
+  /**
+   * Returns the delegated {@code ClientCall}.
+   */
+  @Override
+  protected abstract ClientCall<ReqT, RespT> delegate();
+
+  @Override
+  public void start(Listener<RespT> responseListener, Metadata headers) {
+    delegate().start(responseListener, headers);
+  }
+
+  @Override
+  public void sendMessage(ReqT message) {
+    delegate().sendMessage(message);
+  }
+
+  /**
+   * A simplified version of {@link ForwardingClientCall} where subclasses can pass in a {@link
+   * ClientCall} as the delegate.
+   */
+  public abstract static class SimpleForwardingClientCall<ReqT, RespT>
+      extends ForwardingClientCall<ReqT, RespT> {
+    private final ClientCall<ReqT, RespT> delegate;
+
+    protected SimpleForwardingClientCall(ClientCall<ReqT, RespT> delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    protected ClientCall<ReqT, RespT> delegate() {
+      return delegate;
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/ForwardingClientCallListener.java b/api/src/main/java/io/grpc/ForwardingClientCallListener.java
new file mode 100644
index 00000000000..01961b55744
--- /dev/null
+++ b/api/src/main/java/io/grpc/ForwardingClientCallListener.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2015 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;
+
+/**
+ * A {@link ClientCall.Listener} which forwards all of its methods to another {@link
+ * ClientCall.Listener}.
+ */
+public abstract class ForwardingClientCallListener<RespT>
+    extends PartialForwardingClientCallListener<RespT> {
+  /**
+   * Returns the delegated {@code ClientCall.Listener}.
+   */
+  @Override
+  protected abstract ClientCall.Listener<RespT> delegate();
+
+  @Override
+  public void onMessage(RespT message) {
+    delegate().onMessage(message);
+  }
+
+  /**
+   * A simplified version of {@link ForwardingClientCallListener} where subclasses can pass in a
+   * {@link ClientCall.Listener} as the delegate.
+   */
+  public abstract static class SimpleForwardingClientCallListener<RespT>
+      extends ForwardingClientCallListener<RespT> {
+
+    private final ClientCall.Listener<RespT> delegate;
+
+    protected SimpleForwardingClientCallListener(ClientCall.Listener<RespT> delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    protected ClientCall.Listener<RespT> delegate() {
+      return delegate;
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/ForwardingServerBuilder.java b/api/src/main/java/io/grpc/ForwardingServerBuilder.java
new file mode 100644
index 00000000000..9cef7cfa331
--- /dev/null
+++ b/api/src/main/java/io/grpc/ForwardingServerBuilder.java
@@ -0,0 +1,217 @@
+/*
+ * 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;
+
+import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.DoNotCall;
+import java.io.File;
+import java.io.InputStream;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link ServerBuilder} that delegates all its builder methods to another builder by default.
+ *
+ * @param <T> The type of the subclass extending this abstract class.
+ * @since 1.34.0
+ */
+public abstract class ForwardingServerBuilder<T extends ServerBuilder<T>> extends ServerBuilder<T> {
+
+  /** The default constructor. */
+  protected ForwardingServerBuilder() {}
+
+  /**
+   * This method serves to force sub classes to "hide" this static factory.
+   */
+  @DoNotCall("Unsupported")
+  public static ServerBuilder<?> forPort(int port) {
+    throw new UnsupportedOperationException("Subclass failed to hide static factory");
+  }
+
+  /**
+   * Returns the delegated {@code ServerBuilder}.
+   */
+  protected abstract ServerBuilder<?> delegate();
+
+  @Override
+  public T directExecutor() {
+    delegate().directExecutor();
+    return thisT();
+  }
+
+  @Override
+  public T executor(@Nullable Executor executor) {
+    delegate().executor(executor);
+    return thisT();
+  }
+
+  @Override
+  public T callExecutor(ServerCallExecutorSupplier executorSupplier) {
+    delegate().callExecutor(executorSupplier);
+    return thisT();
+  }
+
+  @Override
+  public T addService(ServerServiceDefinition service) {
+    delegate().addService(service);
+    return thisT();
+  }
+
+  @Override
+  public T addService(BindableService bindableService) {
+    delegate().addService(bindableService);
+    return thisT();
+  }
+
+  @Override
+  public T intercept(ServerInterceptor interceptor) {
+    delegate().intercept(interceptor);
+    return thisT();
+  }
+
+  @Override
+  public T addTransportFilter(ServerTransportFilter filter) {
+    delegate().addTransportFilter(filter);
+    return thisT();
+  }
+
+  @Override
+  public T addStreamTracerFactory(ServerStreamTracer.Factory factory) {
+    delegate().addStreamTracerFactory(factory);
+    return thisT();
+  }
+
+  @Override
+  public T fallbackHandlerRegistry(@Nullable HandlerRegistry fallbackRegistry) {
+    delegate().fallbackHandlerRegistry(fallbackRegistry);
+    return thisT();
+  }
+
+  @Override
+  public T useTransportSecurity(File certChain, File privateKey) {
+    delegate().useTransportSecurity(certChain, privateKey);
+    return thisT();
+  }
+
+  @Override
+  public T useTransportSecurity(InputStream certChain, InputStream privateKey) {
+    delegate().useTransportSecurity(certChain, privateKey);
+    return thisT();
+  }
+
+  @Override
+  public T decompressorRegistry(@Nullable DecompressorRegistry registry) {
+    delegate().decompressorRegistry(registry);
+    return thisT();
+  }
+
+  @Override
+  public T compressorRegistry(@Nullable CompressorRegistry registry) {
+    delegate().compressorRegistry(registry);
+    return thisT();
+  }
+
+  @Override
+  public T handshakeTimeout(long timeout, TimeUnit unit) {
+    delegate().handshakeTimeout(timeout, unit);
+    return thisT();
+  }
+
+  @Override
+  public T keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    delegate().keepAliveTime(keepAliveTime, timeUnit);
+    return thisT();
+  }
+
+  @Override
+  public T keepAliveTimeout(long keepAliveTimeout, TimeUnit timeUnit) {
+    delegate().keepAliveTimeout(keepAliveTimeout, timeUnit);
+    return thisT();
+  }
+
+  @Override
+  public T maxConnectionIdle(long maxConnectionIdle, TimeUnit timeUnit) {
+    delegate().maxConnectionIdle(maxConnectionIdle, timeUnit);
+    return thisT();
+  }
+
+  @Override
+  public T maxConnectionAge(long maxConnectionAge, TimeUnit timeUnit) {
+    delegate().maxConnectionAge(maxConnectionAge, timeUnit);
+    return thisT();
+  }
+
+  @Override
+  public T maxConnectionAgeGrace(long maxConnectionAgeGrace, TimeUnit timeUnit) {
+    delegate().maxConnectionAgeGrace(maxConnectionAgeGrace, timeUnit);
+    return thisT();
+  }
+
+  @Override
+  public T permitKeepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    delegate().permitKeepAliveTime(keepAliveTime, timeUnit);
+    return thisT();
+  }
+
+  @Override
+  public T permitKeepAliveWithoutCalls(boolean permit) {
+    delegate().permitKeepAliveWithoutCalls(permit);
+    return thisT();
+  }
+
+  @Override
+  public T maxInboundMessageSize(int bytes) {
+    delegate().maxInboundMessageSize(bytes);
+    return thisT();
+  }
+
+  @Override
+  public T maxInboundMetadataSize(int bytes) {
+    delegate().maxInboundMetadataSize(bytes);
+    return thisT();
+  }
+
+  @Override
+  public T setBinaryLog(BinaryLog binaryLog) {
+    delegate().setBinaryLog(binaryLog);
+    return thisT();
+  }
+
+  /**
+   * Returns the {@link Server} built by the delegate by default. Overriding method can return
+   * different value.
+   */
+  @Override
+  public Server build() {
+    return delegate().build();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+
+  /**
+   * Returns the correctly typed version of the builder.
+   */
+  private T thisT() {
+    @SuppressWarnings("unchecked")
+    T thisT = (T) this;
+    return thisT;
+  }
+}
diff --git a/api/src/main/java/io/grpc/ForwardingServerCall.java b/api/src/main/java/io/grpc/ForwardingServerCall.java
new file mode 100644
index 00000000000..d513d72dabf
--- /dev/null
+++ b/api/src/main/java/io/grpc/ForwardingServerCall.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2015 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;
+
+/**
+ * A {@link ServerCall} which forwards all of its methods to another {@link ServerCall}.
+ */
+public abstract class ForwardingServerCall<ReqT, RespT>
+    extends PartialForwardingServerCall<ReqT, RespT> {
+  /**
+   * Returns the delegated {@code ServerCall}.
+   */
+  @Override
+  protected abstract ServerCall<ReqT, RespT> delegate();
+
+  @Override
+  public void sendMessage(RespT message) {
+    delegate().sendMessage(message);
+  }
+
+  @Override
+  public MethodDescriptor<ReqT, RespT> getMethodDescriptor() {
+    return delegate().getMethodDescriptor();
+  }
+
+  /**
+   * A simplified version of {@link ForwardingServerCall} where subclasses can pass in a {@link
+   * ServerCall} as the delegate.
+   */
+  public abstract static class SimpleForwardingServerCall<ReqT, RespT>
+      extends ForwardingServerCall<ReqT, RespT> {
+
+    private final ServerCall<ReqT, RespT> delegate;
+
+    protected SimpleForwardingServerCall(ServerCall<ReqT, RespT> delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    protected ServerCall<ReqT, RespT> delegate() {
+      return delegate;
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/ForwardingServerCallListener.java b/api/src/main/java/io/grpc/ForwardingServerCallListener.java
new file mode 100644
index 00000000000..e978e4c9c6b
--- /dev/null
+++ b/api/src/main/java/io/grpc/ForwardingServerCallListener.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2015 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;
+
+/**
+ * A {@link ServerCall.Listener} which forwards all of its methods to another {@link
+ * ServerCall.Listener} of matching parameterized types.
+ */
+public abstract class ForwardingServerCallListener<ReqT>
+    extends PartialForwardingServerCallListener<ReqT> {
+  /**
+   * Returns the delegated {@code ServerCall.Listener}.
+   */
+  @Override
+  protected abstract ServerCall.Listener<ReqT> delegate();
+
+  @Override
+  public void onMessage(ReqT message) {
+    delegate().onMessage(message);
+  }
+
+  /**
+   * A simplified version of {@link ForwardingServerCallListener} where subclasses can pass in a
+   * {@link ServerCall.Listener} as the delegate.
+   */
+  public abstract static class SimpleForwardingServerCallListener<ReqT>
+      extends ForwardingServerCallListener<ReqT> {
+
+    private final ServerCall.Listener<ReqT> delegate;
+
+    protected SimpleForwardingServerCallListener(ServerCall.Listener<ReqT> delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    protected ServerCall.Listener<ReqT> delegate() {
+      return delegate;
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/Grpc.java b/api/src/main/java/io/grpc/Grpc.java
new file mode 100644
index 00000000000..baa9f5f0ab6
--- /dev/null
+++ b/api/src/main/java/io/grpc/Grpc.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2016 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;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.net.URISyntaxException;
+import javax.net.ssl.SSLSession;
+
+/**
+ * Stuff that are part of the public API but are not bound to particular classes, e.g., static
+ * methods, constants, attribute and context keys.
+ */
+public final class Grpc {
+  private Grpc() {
+  }
+
+  /**
+   * Attribute key for the remote address of a transport.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1710")
+  @TransportAttr
+  public static final Attributes.Key<SocketAddress> TRANSPORT_ATTR_REMOTE_ADDR =
+      Attributes.Key.create("io.grpc.Grpc.TRANSPORT_ATTR_REMOTE_ADDR");
+
+  /**
+   * Attribute key for the local address of a transport.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1710")
+  @TransportAttr
+  public static final Attributes.Key<SocketAddress> TRANSPORT_ATTR_LOCAL_ADDR =
+      Attributes.Key.create("io.grpc.Grpc.TRANSPORT_ATTR_LOCAL_ADDR");
+
+  /**
+   * Attribute key for SSL session of a transport.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1710")
+  @TransportAttr
+  public static final Attributes.Key<SSLSession> TRANSPORT_ATTR_SSL_SESSION =
+      Attributes.Key.create("io.grpc.Grpc.TRANSPORT_ATTR_SSL_SESSION");
+
+  /**
+   * Annotation for transport attributes. It follows the annotation semantics defined
+   * by {@link Attributes}.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4972")
+  @Retention(RetentionPolicy.SOURCE)
+  @Documented
+  public @interface TransportAttr {}
+
+  /**
+   * Creates a channel builder with a target string and credentials. The target can be either a
+   * valid {@link NameResolver}-compliant URI, or an authority string.
+   *
+   * <p>A {@code NameResolver}-compliant URI is an absolute hierarchical URI as defined by {@link
+   * java.net.URI}. Example URIs:
+   * <ul>
+   *   <li>{@code "dns:///foo.googleapis.com:8080"}</li>
+   *   <li>{@code "dns:///foo.googleapis.com"}</li>
+   *   <li>{@code "dns:///%5B2001:db8:85a3:8d3:1319:8a2e:370:7348%5D:443"}</li>
+   *   <li>{@code "dns://8.8.8.8/foo.googleapis.com:8080"}</li>
+   *   <li>{@code "dns://8.8.8.8/foo.googleapis.com"}</li>
+   *   <li>{@code "zookeeper://zk.example.com:9900/example_service"}</li>
+   * </ul>
+   *
+   * <p>An authority string will be converted to a {@code NameResolver}-compliant URI, which has
+   * the scheme from the name resolver with the highest priority (e.g. {@code "dns"}),
+   * no authority, and the original authority string as its path after properly escaped.
+   * We recommend libraries to specify the schema explicitly if it is known, since libraries cannot
+   * know which NameResolver will be default during runtime.
+   * Example authority strings:
+   * <ul>
+   *   <li>{@code "localhost"}</li>
+   *   <li>{@code "127.0.0.1"}</li>
+   *   <li>{@code "localhost:8080"}</li>
+   *   <li>{@code "foo.googleapis.com:8080"}</li>
+   *   <li>{@code "127.0.0.1:8080"}</li>
+   *   <li>{@code "[2001:db8:85a3:8d3:1319:8a2e:370:7348]"}</li>
+   *   <li>{@code "[2001:db8:85a3:8d3:1319:8a2e:370:7348]:443"}</li>
+   * </ul>
+   */
+  public static ManagedChannelBuilder<?> newChannelBuilder(
+      String target, ChannelCredentials creds) {
+    return ManagedChannelRegistry.getDefaultRegistry().newChannelBuilder(target, creds);
+  }
+
+  /**
+   * Creates a channel builder from a host, port, and credentials. The host and port are combined to
+   * form an authority string and then passed to {@link #newChannelBuilder(String,
+   * ChannelCredentials)}. IPv6 addresses are properly surrounded by square brackets ("[]").
+   */
+  public static ManagedChannelBuilder<?> newChannelBuilderForAddress(
+      String host, int port, ChannelCredentials creds) {
+    return newChannelBuilder(authorityFromHostAndPort(host, port), creds);
+  }
+
+  /**
+   * Combine a host and port into an authority string.
+   */
+  // A copy of GrpcUtil.authorityFromHostAndPort
+  private static String authorityFromHostAndPort(String host, int port) {
+    try {
+      return new URI(null, null, host, port, null, null, null).getAuthority();
+    } catch (URISyntaxException ex) {
+      throw new IllegalArgumentException("Invalid host or port: " + host + " " + port, ex);
+    }
+  }
+
+  /**
+   * Static factory for creating a new ServerBuilder.
+   *
+   * @param port the port to listen on
+   * @param creds the server identity
+   */
+  public static ServerBuilder<?> newServerBuilderForPort(int port, ServerCredentials creds) {
+    return ServerRegistry.getDefaultRegistry().newServerBuilderForPort(port, creds);
+  }
+}
diff --git a/api/src/main/java/io/grpc/HandlerRegistry.java b/api/src/main/java/io/grpc/HandlerRegistry.java
new file mode 100644
index 00000000000..4aaf0114fb1
--- /dev/null
+++ b/api/src/main/java/io/grpc/HandlerRegistry.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2014 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;
+
+import java.util.Collections;
+import java.util.List;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Registry of services and their methods used by servers to dispatching incoming calls.
+ */
+@ThreadSafe
+public abstract class HandlerRegistry {
+
+  /**
+   * Returns the {@link ServerServiceDefinition}s provided by the registry, or an empty list if not
+   * supported by the implementation.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
+  public List<ServerServiceDefinition> getServices() {
+    return Collections.emptyList();
+  }
+
+  /**
+   * Lookup a {@link ServerMethodDefinition} by its fully-qualified name.
+   *
+   * @param methodName to lookup {@link ServerMethodDefinition} for.
+   * @param authority the authority for the desired method (to do virtual hosting). If {@code null}
+   *        the first matching method will be returned.
+   * @return the resolved method or {@code null} if no method for that name exists.
+   */
+  @Nullable
+  public abstract ServerMethodDefinition<?, ?> lookupMethod(
+      String methodName, @Nullable String authority);
+
+  /**
+   * Lookup a {@link ServerMethodDefinition} by its fully-qualified name.
+   *
+   * @param methodName to lookup {@link ServerMethodDefinition} for.
+   * @return the resolved method or {@code null} if no method for that name exists.
+   */
+  @Nullable
+  public final ServerMethodDefinition<?, ?> lookupMethod(String methodName) {
+    return lookupMethod(methodName, null);
+  }
+
+}
diff --git a/api/src/main/java/io/grpc/HasByteBuffer.java b/api/src/main/java/io/grpc/HasByteBuffer.java
new file mode 100644
index 00000000000..c372d6c6150
--- /dev/null
+++ b/api/src/main/java/io/grpc/HasByteBuffer.java
@@ -0,0 +1,51 @@
+/*
+ * 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;
+
+import java.nio.ByteBuffer;
+import javax.annotation.Nullable;
+
+/**
+ * Extension to an {@link java.io.InputStream} whose content can be accessed as {@link
+ * ByteBuffer}s.
+ *
+ * <p>This can be used for optimizing the case for the consumer of a {@link ByteBuffer}-backed
+ * input stream supports efficient reading from {@link ByteBuffer}s directly. This turns the reader
+ * interface from an {@link java.io.InputStream} to {@link ByteBuffer}s, without copying the
+ * content to a byte array and read from it.
+ */
+public interface HasByteBuffer {
+
+  /**
+   * Indicates whether or not {@link #getByteBuffer} operation is supported.
+   */
+  boolean byteBufferSupported();
+
+  /**
+   * Gets a {@link ByteBuffer} containing some bytes of the content next to be read, or {@code
+   * null} if has reached end of the content. The number of bytes contained in the returned buffer
+   * is implementation specific. Calling this method does not change the position of the input
+   * stream. The returned buffer's content should not be modified, but the position, limit, and
+   * mark may be changed. Operations for changing the position, limit, and mark of the returned
+   * buffer does not affect the position, limit, and mark of this input stream. This is an optional
+   * method, so callers should first check {@link #byteBufferSupported}.
+   *
+   * @throws UnsupportedOperationException if this operation is not supported.
+   */
+  @Nullable
+  ByteBuffer getByteBuffer();
+}
diff --git a/api/src/main/java/io/grpc/HttpConnectProxiedSocketAddress.java b/api/src/main/java/io/grpc/HttpConnectProxiedSocketAddress.java
new file mode 100644
index 00000000000..0df8dc452c1
--- /dev/null
+++ b/api/src/main/java/io/grpc/HttpConnectProxiedSocketAddress.java
@@ -0,0 +1,212 @@
+/*
+ * Copyright 2019 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/**
+ * An {@link ProxiedSocketAddress} for making a connection to an endpoint via an HTTP CONNECT proxy.
+ */
+public final class HttpConnectProxiedSocketAddress extends ProxiedSocketAddress {
+  private static final long serialVersionUID = 0L;
+
+  private final SocketAddress proxyAddress;
+  private final InetSocketAddress targetAddress;
+  @SuppressWarnings("serial")
+  private final Map<String, String> headers;
+  @Nullable
+  private final String username;
+  @Nullable
+  private final String password;
+
+  private HttpConnectProxiedSocketAddress(
+      SocketAddress proxyAddress,
+      InetSocketAddress targetAddress,
+      Map<String, String> headers,
+      @Nullable String username,
+      @Nullable String password) {
+    checkNotNull(proxyAddress, "proxyAddress");
+    checkNotNull(targetAddress, "targetAddress");
+    // The resolution must be done by the HttpConnectProxiedSocketAddress producer, because
+    // consumers may not be allowed to do IO.
+    if (proxyAddress instanceof InetSocketAddress) {
+      checkState(!((InetSocketAddress) proxyAddress).isUnresolved(),
+          "The proxy address %s is not resolved", proxyAddress);
+    }
+    this.proxyAddress = proxyAddress;
+    this.targetAddress = targetAddress;
+    this.headers = headers;
+    this.username = username;
+    this.password = password;
+  }
+
+  /**
+   * Returns the password used to connect to the proxy. {@code null} if there is no password.
+   */
+  @Nullable
+  public String getPassword() {
+    return password;
+  }
+
+  /**
+   * Returns the username used to connect to the proxy. {@code null} if there is no username.
+   */
+  @Nullable
+  public String getUsername() {
+    return username;
+  }
+
+  /**
+   * Returns the address to the proxy, which is already resolved.
+   */
+  public SocketAddress getProxyAddress() {
+    return proxyAddress;
+  }
+
+  /**
+   * Returns the address to the target server.
+   */
+  public InetSocketAddress getTargetAddress() {
+    return targetAddress;
+  }
+
+  /**
+   * Returns the custom HTTP headers to be sent during the HTTP CONNECT handshake.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12479")
+  public Map<String, String> getHeaders() {
+    return headers;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (!(o instanceof HttpConnectProxiedSocketAddress)) {
+      return false;
+    }
+    HttpConnectProxiedSocketAddress that = (HttpConnectProxiedSocketAddress) o;
+    return Objects.equal(proxyAddress, that.proxyAddress)
+        && Objects.equal(targetAddress, that.targetAddress)
+        && Objects.equal(headers, that.headers)
+        && Objects.equal(username, that.username)
+        && Objects.equal(password, that.password);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(proxyAddress, targetAddress, username, password, headers);
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("proxyAddr", proxyAddress)
+        .add("targetAddr", targetAddress)
+        .add("headers", headers)
+        .add("username", username)
+        // Intentionally mask out password
+        .add("hasPassword", password != null)
+        .toString();
+  }
+
+  /**
+   * Create a new builder.
+   */
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  /**
+   * The builder for {@link HttpConnectProxiedSocketAddress}.
+   */
+  public static final class Builder {
+
+    private SocketAddress proxyAddress;
+    private InetSocketAddress targetAddress;
+    private Map<String, String> headers = Collections.emptyMap();
+    @Nullable
+    private String username;
+    @Nullable
+    private String password;
+
+    private Builder() {
+    }
+
+    /**
+     * Sets the address to the proxy, which is already resolved.  This is a required field.
+     */
+    public Builder setProxyAddress(SocketAddress proxyAddress) {
+      this.proxyAddress = checkNotNull(proxyAddress, "proxyAddress");
+      return this;
+    }
+
+    /**
+     * Sets the address to the target.  This is a required field.
+     */
+    public Builder setTargetAddress(InetSocketAddress targetAddress) {
+      this.targetAddress = checkNotNull(targetAddress, "targetAddress");
+      return this;
+    }
+
+    /**
+     * Sets custom HTTP headers to be sent during the HTTP CONNECT handshake. This is an optional
+     * field. The headers will be sent in addition to any authentication headers (if username and
+     * password are set).
+     */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12479")
+    public Builder setHeaders(Map<String, String> headers) {
+      this.headers = Collections.unmodifiableMap(
+          new HashMap<>(checkNotNull(headers, "headers")));
+      return this;
+    }
+
+    /**
+     * Sets the username used to connect to the proxy.  This is an optional field and can be {@code
+     * null}.
+     */
+    public Builder setUsername(@Nullable String username) {
+      this.username = username;
+      return this;
+    }
+
+    /**
+     * Sets the password used to connect to the proxy.  This is an optional field and can be {@code
+     * null}.
+     */
+    public Builder setPassword(@Nullable String password) {
+      this.password = password;
+      return this;
+    }
+
+    /**
+     * Creates an {@code HttpConnectProxiedSocketAddress}.
+     */
+    public HttpConnectProxiedSocketAddress build() {
+      return new HttpConnectProxiedSocketAddress(
+          proxyAddress, targetAddress, headers, username, password);
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/IgnoreJRERequirement.java b/api/src/main/java/io/grpc/IgnoreJRERequirement.java
new file mode 100644
index 00000000000..2db406c5953
--- /dev/null
+++ b/api/src/main/java/io/grpc/IgnoreJRERequirement.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2024 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;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+
+/**
+ * Disables Animal Sniffer's signature checking. This is our own package-private version to avoid
+ * dependening on animalsniffer-annotations.
+ *
+ * <p>FIELD is purposefully not supported, as Android wouldn't be able to ignore a field. Instead,
+ * the entire class would need to be avoided on Android.
+ */
+@Target({ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.TYPE})
+@interface IgnoreJRERequirement {}
diff --git a/api/src/main/java/io/grpc/InsecureChannelCredentials.java b/api/src/main/java/io/grpc/InsecureChannelCredentials.java
new file mode 100644
index 00000000000..f198d9ae480
--- /dev/null
+++ b/api/src/main/java/io/grpc/InsecureChannelCredentials.java
@@ -0,0 +1,31 @@
+/*
+ * 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;
+
+/** No client identity, authentication, or encryption is to be used. */
+public final class InsecureChannelCredentials extends ChannelCredentials {
+  public static ChannelCredentials create() {
+    return new InsecureChannelCredentials();
+  }
+
+  private InsecureChannelCredentials() {}
+
+  @Override
+  public ChannelCredentials withoutBearerTokens() {
+    return this;
+  }
+}
diff --git a/api/src/main/java/io/grpc/InsecureServerCredentials.java b/api/src/main/java/io/grpc/InsecureServerCredentials.java
new file mode 100644
index 00000000000..b33f64a688e
--- /dev/null
+++ b/api/src/main/java/io/grpc/InsecureServerCredentials.java
@@ -0,0 +1,26 @@
+/*
+ * 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;
+
+/** No server identity or encryption is to be used. */
+public final class InsecureServerCredentials extends ServerCredentials {
+  public static ServerCredentials create() {
+    return new InsecureServerCredentials();
+  }
+
+  private InsecureServerCredentials() {}
+}
diff --git a/api/src/main/java/io/grpc/Internal.java b/api/src/main/java/io/grpc/Internal.java
new file mode 100644
index 00000000000..394fe9edbe7
--- /dev/null
+++ b/api/src/main/java/io/grpc/Internal.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2015 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;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotates a program element (class, method, package, etc) which is internal to gRPC, not part of
+ * the public API, and should not be used by users of gRPC.
+ *
+ * <p>However, if you want to implement an alternative transport you may use the internal parts.
+ * Please consult the gRPC team first, because internal APIs don't have the same API stability
+ * guarantee as the public APIs do.
+ *
+ * <p>Note: This annotation is intended only for gRPC library code. Users should not attach this
+ * annotation to their own code.
+ *
+ * <p>See: <a href="https://github.com/grpc/grpc-java-api-checker">grpc-java-api-checker</a>, an
+ * Error Prone plugin to automatically check for usages of this API.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target({
+    ElementType.ANNOTATION_TYPE,
+    ElementType.CONSTRUCTOR,
+    ElementType.FIELD,
+    ElementType.METHOD,
+    ElementType.PACKAGE,
+    ElementType.TYPE})
+@Documented
+public @interface Internal {
+}
diff --git a/api/src/main/java/io/grpc/InternalCallOptions.java b/api/src/main/java/io/grpc/InternalCallOptions.java
new file mode 100644
index 00000000000..92546f05181
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalCallOptions.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2019 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;
+
+/**
+ * Internal accessor for {@link CallOptions}.
+ */
+@Internal
+public final class InternalCallOptions {
+  private InternalCallOptions() {}
+
+  /**
+   * Gets the waitForReady bit or {@code null} if it was never set.
+   */
+  public static Boolean getWaitForReady(CallOptions callOptions) {
+    return callOptions.getWaitForReady();
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalChannelz.java b/api/src/main/java/io/grpc/InternalChannelz.java
new file mode 100644
index 00000000000..35cbb4c2820
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalChannelz.java
@@ -0,0 +1,1105 @@
+/*
+ * Copyright 2018 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import java.net.SocketAddress;
+import java.security.cert.Certificate;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ConcurrentNavigableMap;
+import java.util.concurrent.ConcurrentSkipListMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+
+/**
+ * This is an internal API. Do NOT use.
+ */
+@Internal
+public final class InternalChannelz {
+  private static final Logger log = Logger.getLogger(InternalChannelz.class.getName());
+  private static final InternalChannelz INSTANCE = new InternalChannelz();
+
+  private final ConcurrentNavigableMap<Long, InternalInstrumented<ServerStats>> servers
+      = new ConcurrentSkipListMap<>();
+  private final ConcurrentNavigableMap<Long, InternalInstrumented<ChannelStats>> rootChannels
+      = new ConcurrentSkipListMap<>();
+  private final ConcurrentMap<Long, InternalInstrumented<ChannelStats>> subchannels
+      = new ConcurrentHashMap<>();
+  // An InProcessTransport can appear in both otherSockets and perServerSockets simultaneously
+  private final ConcurrentMap<Long, InternalInstrumented<SocketStats>> otherSockets
+      = new ConcurrentHashMap<>();
+  private final ConcurrentMap<Long, ServerSocketMap> perServerSockets
+      = new ConcurrentHashMap<>();
+
+  // A convenience class to avoid deeply nested types.
+  private static final class ServerSocketMap
+      extends ConcurrentSkipListMap<Long, InternalInstrumented<SocketStats>> {
+    private static final long serialVersionUID = -7883772124944661414L;
+  }
+
+  @VisibleForTesting
+  public InternalChannelz() {
+  }
+
+  public static InternalChannelz instance() {
+    return INSTANCE;
+  }
+
+  /** Adds a server. */
+  public void addServer(InternalInstrumented<ServerStats> server) {
+    ServerSocketMap prev = perServerSockets.put(id(server), new ServerSocketMap());
+    assert prev == null;
+    add(servers, server);
+  }
+
+  /** Adds a subchannel. */
+  public void addSubchannel(InternalInstrumented<ChannelStats> subchannel) {
+    add(subchannels, subchannel);
+  }
+
+  /** Adds a root channel. */
+  public void addRootChannel(InternalInstrumented<ChannelStats> rootChannel) {
+    add(rootChannels, rootChannel);
+  }
+
+  /** Adds a socket. */
+  public void addClientSocket(InternalInstrumented<SocketStats> socket) {
+    add(otherSockets, socket);
+  }
+
+  public void addListenSocket(InternalInstrumented<SocketStats> socket) {
+    add(otherSockets, socket);
+  }
+
+  /** Adds a server socket. */
+  public void addServerSocket(
+      InternalInstrumented<ServerStats> server, InternalInstrumented<SocketStats> socket) {
+    ServerSocketMap serverSockets = perServerSockets.get(id(server));
+    assert serverSockets != null;
+    add(serverSockets, socket);
+  }
+
+  /** Removes a server. */
+  public void removeServer(InternalInstrumented<ServerStats> server) {
+    remove(servers, server);
+    ServerSocketMap prev = perServerSockets.remove(id(server));
+    assert prev != null;
+    assert prev.isEmpty();
+  }
+
+  public void removeSubchannel(InternalInstrumented<ChannelStats> subchannel) {
+    remove(subchannels, subchannel);
+  }
+
+  public void removeRootChannel(InternalInstrumented<ChannelStats> channel) {
+    remove(rootChannels, channel);
+  }
+
+  public void removeClientSocket(InternalInstrumented<SocketStats> socket) {
+    remove(otherSockets, socket);
+  }
+
+  public void removeListenSocket(InternalInstrumented<SocketStats> socket) {
+    remove(otherSockets, socket);
+  }
+
+  /** Removes a server socket. */
+  public void removeServerSocket(
+      InternalInstrumented<ServerStats> server, InternalInstrumented<SocketStats> socket) {
+    ServerSocketMap socketsOfServer = perServerSockets.get(id(server));
+    assert socketsOfServer != null;
+    remove(socketsOfServer, socket);
+  }
+
+  /** Returns a {@link RootChannelList}. */
+  public RootChannelList getRootChannels(long fromId, int maxPageSize) {
+    List<InternalInstrumented<ChannelStats>> channelList
+        = new ArrayList<>();
+    Iterator<InternalInstrumented<ChannelStats>> iterator
+        = rootChannels.tailMap(fromId).values().iterator();
+
+    while (iterator.hasNext() && channelList.size() < maxPageSize) {
+      channelList.add(iterator.next());
+    }
+    return new RootChannelList(channelList, !iterator.hasNext());
+  }
+
+  /** Returns a channel. */
+  @Nullable
+  public InternalInstrumented<ChannelStats> getChannel(long id) {
+    return rootChannels.get(id);
+  }
+
+  /** Returns a subchannel. */
+  @Nullable
+  public InternalInstrumented<ChannelStats> getSubchannel(long id) {
+    return subchannels.get(id);
+  }
+
+  /** Returns a server list. */
+  public ServerList getServers(long fromId, int maxPageSize) {
+    List<InternalInstrumented<ServerStats>> serverList
+        = new ArrayList<>(maxPageSize);
+    Iterator<InternalInstrumented<ServerStats>> iterator
+        = servers.tailMap(fromId).values().iterator();
+
+    while (iterator.hasNext() && serverList.size() < maxPageSize) {
+      serverList.add(iterator.next());
+    }
+    return new ServerList(serverList, !iterator.hasNext());
+  }
+
+  /** Returns a server. */
+  @Nullable
+  public InternalInstrumented<ServerStats> getServer(long id) {
+    return servers.get(id);
+  }
+
+  /** Returns socket refs for a server. */
+  @Nullable
+  public ServerSocketsList getServerSockets(long serverId, long fromId, int maxPageSize) {
+    ServerSocketMap serverSockets = perServerSockets.get(serverId);
+    if (serverSockets == null) {
+      return null;
+    }
+    List<InternalWithLogId> socketList = new ArrayList<>(maxPageSize);
+    Iterator<InternalInstrumented<SocketStats>> iterator
+        = serverSockets.tailMap(fromId).values().iterator();
+    while (socketList.size() < maxPageSize && iterator.hasNext()) {
+      socketList.add(iterator.next());
+    }
+    return new ServerSocketsList(socketList, !iterator.hasNext());
+  }
+
+  /** Returns a socket. */
+  @Nullable
+  public InternalInstrumented<SocketStats> getSocket(long id) {
+    InternalInstrumented<SocketStats> clientSocket = otherSockets.get(id);
+    if (clientSocket != null) {
+      return clientSocket;
+    }
+    return getServerSocket(id);
+  }
+
+  private InternalInstrumented<SocketStats> getServerSocket(long id) {
+    for (ServerSocketMap perServerSockets : perServerSockets.values()) {
+      InternalInstrumented<SocketStats> serverSocket = perServerSockets.get(id);
+      if (serverSocket != null) {
+        return serverSocket;
+      }
+    }
+    return null;
+  }
+
+  @VisibleForTesting
+  public boolean containsServer(InternalLogId serverRef) {
+    return contains(servers, serverRef);
+  }
+
+  @VisibleForTesting
+  public boolean containsSubchannel(InternalLogId subchannelRef) {
+    return contains(subchannels, subchannelRef);
+  }
+
+  public InternalInstrumented<ChannelStats> getRootChannel(long id) {
+    return rootChannels.get(id);
+  }
+
+  @VisibleForTesting
+  public boolean containsClientSocket(InternalLogId transportRef) {
+    return contains(otherSockets, transportRef);
+  }
+
+  private static <T extends InternalInstrumented<?>> void add(Map<Long, T> map, T object) {
+    T prev = map.put(object.getLogId().getId(), object);
+    assert prev == null;
+  }
+
+  private static <T extends InternalInstrumented<?>> void remove(Map<Long, T> map, T object) {
+    T prev = map.remove(id(object));
+    assert prev != null;
+  }
+
+  private static <T extends InternalInstrumented<?>> boolean contains(
+      Map<Long, T> map, InternalLogId id) {
+    return map.containsKey(id.getId());
+  }
+
+  public static final class RootChannelList {
+    public final List<InternalInstrumented<ChannelStats>> channels;
+    public final boolean end;
+
+    /** Creates an instance. */
+    public RootChannelList(List<InternalInstrumented<ChannelStats>> channels, boolean end) {
+      this.channels = checkNotNull(channels);
+      this.end = end;
+    }
+  }
+
+  public static final class ServerList {
+    public final List<InternalInstrumented<ServerStats>> servers;
+    public final boolean end;
+
+    /** Creates an instance. */
+    public ServerList(List<InternalInstrumented<ServerStats>> servers, boolean end) {
+      this.servers = checkNotNull(servers);
+      this.end = end;
+    }
+  }
+
+  public static final class ServerSocketsList {
+    public final List<InternalWithLogId> sockets;
+    public final boolean end;
+
+    /** Creates an instance. */
+    public ServerSocketsList(List<InternalWithLogId> sockets, boolean end) {
+      this.sockets = sockets;
+      this.end = end;
+    }
+  }
+
+  @Immutable
+  public static final class ServerStats {
+    public final long callsStarted;
+    public final long callsSucceeded;
+    public final long callsFailed;
+    public final long lastCallStartedNanos;
+    public final List<InternalInstrumented<SocketStats>> listenSockets;
+
+    /**
+     * Creates an instance.
+     */
+    public ServerStats(
+        long callsStarted,
+        long callsSucceeded,
+        long callsFailed,
+        long lastCallStartedNanos,
+        List<InternalInstrumented<SocketStats>> listenSockets) {
+      this.callsStarted = callsStarted;
+      this.callsSucceeded = callsSucceeded;
+      this.callsFailed = callsFailed;
+      this.lastCallStartedNanos = lastCallStartedNanos;
+      this.listenSockets = checkNotNull(listenSockets);
+    }
+
+    public static final class Builder {
+      private long callsStarted;
+      private long callsSucceeded;
+      private long callsFailed;
+      private long lastCallStartedNanos;
+      public List<InternalInstrumented<SocketStats>> listenSockets = new ArrayList<>();
+
+      public Builder setCallsStarted(long callsStarted) {
+        this.callsStarted = callsStarted;
+        return this;
+      }
+
+      public Builder setCallsSucceeded(long callsSucceeded) {
+        this.callsSucceeded = callsSucceeded;
+        return this;
+      }
+
+      public Builder setCallsFailed(long callsFailed) {
+        this.callsFailed = callsFailed;
+        return this;
+      }
+
+      public Builder setLastCallStartedNanos(long lastCallStartedNanos) {
+        this.lastCallStartedNanos = lastCallStartedNanos;
+        return this;
+      }
+
+      /** Sets the listen sockets. */
+      public Builder addListenSockets(List<InternalInstrumented<SocketStats>> listenSockets) {
+        checkNotNull(listenSockets, "listenSockets");
+        for (InternalInstrumented<SocketStats> ss : listenSockets) {
+          this.listenSockets.add(checkNotNull(ss, "null listen socket"));
+        }
+        return this;
+      }
+
+      /**
+       * Builds an instance.
+       */
+      public ServerStats build() {
+        return new ServerStats(
+            callsStarted,
+            callsSucceeded,
+            callsFailed,
+            lastCallStartedNanos,
+            listenSockets);
+      }
+    }
+  }
+
+  /**
+   * A data class to represent a channel's stats.
+   */
+  @Immutable
+  public static final class ChannelStats {
+    public final String target;
+    public final ConnectivityState state;
+    @Nullable public final ChannelTrace channelTrace;
+    public final long callsStarted;
+    public final long callsSucceeded;
+    public final long callsFailed;
+    public final long lastCallStartedNanos;
+    public final List<InternalWithLogId> subchannels;
+    public final List<InternalWithLogId> sockets;
+
+    /**
+     * Creates an instance.
+     */
+    private ChannelStats(
+        String target,
+        ConnectivityState state,
+        @Nullable ChannelTrace channelTrace,
+        long callsStarted,
+        long callsSucceeded,
+        long callsFailed,
+        long lastCallStartedNanos,
+        List<InternalWithLogId> subchannels,
+        List<InternalWithLogId> sockets) {
+      checkState(
+          subchannels.isEmpty() || sockets.isEmpty(),
+          "channels can have subchannels only, subchannels can have either sockets OR subchannels, "
+              + "neither can have both");
+      this.target = target;
+      this.state = state;
+      this.channelTrace = channelTrace;
+      this.callsStarted = callsStarted;
+      this.callsSucceeded = callsSucceeded;
+      this.callsFailed = callsFailed;
+      this.lastCallStartedNanos = lastCallStartedNanos;
+      this.subchannels = checkNotNull(subchannels);
+      this.sockets = checkNotNull(sockets);
+    }
+
+    public static final class Builder {
+      private String target;
+      private ConnectivityState state;
+      private ChannelTrace channelTrace;
+      private long callsStarted;
+      private long callsSucceeded;
+      private long callsFailed;
+      private long lastCallStartedNanos;
+      private List<InternalWithLogId> subchannels = Collections.emptyList();
+      private List<InternalWithLogId> sockets = Collections.emptyList();
+
+      public Builder setTarget(String target) {
+        this.target = target;
+        return this;
+      }
+
+      public Builder setState(ConnectivityState state) {
+        this.state = state;
+        return this;
+      }
+
+      public Builder setChannelTrace(ChannelTrace channelTrace) {
+        this.channelTrace = channelTrace;
+        return this;
+      }
+
+      public Builder setCallsStarted(long callsStarted) {
+        this.callsStarted = callsStarted;
+        return this;
+      }
+
+      public Builder setCallsSucceeded(long callsSucceeded) {
+        this.callsSucceeded = callsSucceeded;
+        return this;
+      }
+
+      public Builder setCallsFailed(long callsFailed) {
+        this.callsFailed = callsFailed;
+        return this;
+      }
+
+      public Builder setLastCallStartedNanos(long lastCallStartedNanos) {
+        this.lastCallStartedNanos = lastCallStartedNanos;
+        return this;
+      }
+
+      /** Sets the subchannels. */
+      public Builder setSubchannels(List<InternalWithLogId> subchannels) {
+        checkState(sockets.isEmpty());
+        this.subchannels = Collections.unmodifiableList(checkNotNull(subchannels));
+        return this;
+      }
+
+      /** Sets the sockets. */
+      public Builder setSockets(List<InternalWithLogId> sockets) {
+        checkState(subchannels.isEmpty());
+        this.sockets = Collections.unmodifiableList(checkNotNull(sockets));
+        return this;
+      }
+
+      /**
+       * Builds an instance.
+       */
+      public ChannelStats build() {
+        return new ChannelStats(
+            target,
+            state,
+            channelTrace,
+            callsStarted,
+            callsSucceeded,
+            callsFailed,
+            lastCallStartedNanos,
+            subchannels,
+            sockets);
+      }
+    }
+  }
+
+  @Immutable
+  public static final class ChannelTrace {
+    public final long numEventsLogged;
+    public final long creationTimeNanos;
+    public final List<Event> events;
+
+    private ChannelTrace(long numEventsLogged, long creationTimeNanos, List<Event> events) {
+      this.numEventsLogged = numEventsLogged;
+      this.creationTimeNanos = creationTimeNanos;
+      this.events = events;
+    }
+
+    public static final class Builder {
+      private Long numEventsLogged;
+      private Long creationTimeNanos;
+      private List<Event> events = Collections.emptyList();
+
+      public Builder setNumEventsLogged(long numEventsLogged) {
+        this.numEventsLogged = numEventsLogged;
+        return this;
+      }
+
+      public Builder setCreationTimeNanos(long creationTimeNanos) {
+        this.creationTimeNanos = creationTimeNanos;
+        return this;
+      }
+
+      public Builder setEvents(List<Event> events) {
+        this.events = Collections.unmodifiableList(new ArrayList<>(events));
+        return this;
+      }
+
+      /** Builds a new ChannelTrace instance. */
+      public ChannelTrace build() {
+        checkNotNull(numEventsLogged, "numEventsLogged");
+        checkNotNull(creationTimeNanos, "creationTimeNanos");
+        return new ChannelTrace(numEventsLogged, creationTimeNanos, events);
+      }
+    }
+
+    @Immutable
+    public static final class Event {
+      public final String description;
+      public final Severity severity;
+      public final long timestampNanos;
+
+      // the oneof child_ref field in proto: one of channelRef and channelRef
+      @Nullable public final InternalWithLogId channelRef;
+      @Nullable public final InternalWithLogId subchannelRef;
+
+      public enum Severity {
+        CT_UNKNOWN, CT_INFO, CT_WARNING, CT_ERROR
+      }
+
+      private Event(
+          String description, Severity severity, long timestampNanos,
+          @Nullable InternalWithLogId channelRef, @Nullable InternalWithLogId subchannelRef) {
+        this.description = description;
+        this.severity = checkNotNull(severity, "severity");
+        this.timestampNanos = timestampNanos;
+        this.channelRef = channelRef;
+        this.subchannelRef = subchannelRef;
+      }
+
+      @Override
+      public int hashCode() {
+        return Objects.hashCode(description, severity, timestampNanos, channelRef, subchannelRef);
+      }
+
+      @Override
+      public boolean equals(Object o) {
+        if (o instanceof Event) {
+          Event that = (Event) o;
+          return Objects.equal(description, that.description)
+              && Objects.equal(severity, that.severity)
+              && timestampNanos == that.timestampNanos
+              && Objects.equal(channelRef, that.channelRef)
+              && Objects.equal(subchannelRef, that.subchannelRef);
+        }
+        return false;
+      }
+
+      @Override
+      public String toString() {
+        return MoreObjects.toStringHelper(this)
+            .add("description", description)
+            .add("severity", severity)
+            .add("timestampNanos", timestampNanos)
+            .add("channelRef", channelRef)
+            .add("subchannelRef", subchannelRef)
+            .toString();
+      }
+
+      public static final class Builder {
+        private String description;
+        private Severity severity;
+        private Long timestampNanos;
+        private InternalWithLogId channelRef;
+        private InternalWithLogId subchannelRef;
+
+        public Builder setDescription(String description) {
+          this.description = description;
+          return this;
+        }
+
+        public Builder setTimestampNanos(long timestampNanos) {
+          this.timestampNanos = timestampNanos;
+          return this;
+        }
+
+        public Builder setSeverity(Severity severity) {
+          this.severity = severity;
+          return this;
+        }
+
+        public Builder setChannelRef(InternalWithLogId channelRef) {
+          this.channelRef = channelRef;
+          return this;
+        }
+
+        public Builder setSubchannelRef(InternalWithLogId subchannelRef) {
+          this.subchannelRef = subchannelRef;
+          return this;
+        }
+
+        /** Builds a new Event instance. */
+        public Event build() {
+          checkNotNull(description, "description");
+          checkNotNull(severity, "severity");
+          checkNotNull(timestampNanos, "timestampNanos");
+          checkState(
+              channelRef == null || subchannelRef == null,
+              "at least one of channelRef and subchannelRef must be null");
+          return new Event(description, severity, timestampNanos, channelRef, subchannelRef);
+        }
+      }
+    }
+  }
+
+  public static final class Security {
+    @Nullable
+    public final Tls tls;
+    @Nullable
+    public final OtherSecurity other;
+
+    public Security(Tls tls) {
+      this.tls = checkNotNull(tls);
+      this.other = null;
+    }
+
+    public Security(OtherSecurity other) {
+      this.tls = null;
+      this.other = checkNotNull(other);
+    }
+  }
+
+  public static final class OtherSecurity {
+    public final String name;
+    @Nullable
+    public final Object any;
+
+    /**
+     * Creates an instance.
+     * @param name the name.
+     * @param any a com.google.protobuf.Any object
+     */
+    public OtherSecurity(String name, @Nullable Object any) {
+      this.name = checkNotNull(name);
+      checkState(
+          any == null || any.getClass().getName().endsWith("com.google.protobuf.Any"),
+          "the 'any' object must be of type com.google.protobuf.Any");
+      this.any = any;
+    }
+  }
+
+  @Immutable
+  public static final class Tls {
+    public final String cipherSuiteStandardName;
+    @Nullable public final Certificate localCert;
+    @Nullable public final Certificate remoteCert;
+
+    /**
+     * A constructor only for testing.
+     */
+    public Tls(String cipherSuiteName, Certificate localCert, Certificate remoteCert) {
+      this.cipherSuiteStandardName = cipherSuiteName;
+      this.localCert = localCert;
+      this.remoteCert = remoteCert;
+    }
+
+    /**
+     * Creates an instance.
+     */
+    public Tls(SSLSession session) {
+      String cipherSuiteStandardName = session.getCipherSuite();
+      Certificate localCert = null;
+      Certificate remoteCert = null;
+      Certificate[] localCerts = session.getLocalCertificates();
+      if (localCerts != null) {
+        localCert = localCerts[0];
+      }
+      try {
+        Certificate[] peerCerts = session.getPeerCertificates();
+        if (peerCerts != null) {
+          // The javadoc of getPeerCertificate states that the peer's own certificate is the first
+          // element of the list.
+          remoteCert = peerCerts[0];
+        }
+      } catch (SSLPeerUnverifiedException e) {
+        // peer cert is not available
+        log.log(
+            Level.FINE,
+            String.format("Peer cert not available for peerHost=%s", session.getPeerHost()),
+            e);
+      }
+      this.cipherSuiteStandardName = cipherSuiteStandardName;
+      this.localCert = localCert;
+      this.remoteCert = remoteCert;
+    }
+  }
+
+  public static final class SocketStats {
+    @Nullable public final TransportStats data;
+    @Nullable public final SocketAddress local;
+    @Nullable public final SocketAddress remote;
+    public final SocketOptions socketOptions;
+    // Can be null if plaintext
+    @Nullable public final Security security;
+
+    /** Creates an instance. */
+    public SocketStats(
+        TransportStats data,
+        @Nullable SocketAddress local,
+        @Nullable SocketAddress remote,
+        SocketOptions socketOptions,
+        Security security) {
+      this.data = data;
+      this.local = checkNotNull(local, "local socket");
+      this.remote = remote;
+      this.socketOptions = checkNotNull(socketOptions);
+      this.security = security;
+    }
+  }
+
+  public static final class TcpInfo {
+    public final int state;
+    public final int caState;
+    public final int retransmits;
+    public final int probes;
+    public final int backoff;
+    public final int options;
+    public final int sndWscale;
+    public final int rcvWscale;
+    public final int rto;
+    public final int ato;
+    public final int sndMss;
+    public final int rcvMss;
+    public final int unacked;
+    public final int sacked;
+    public final int lost;
+    public final int retrans;
+    public final int fackets;
+    public final int lastDataSent;
+    public final int lastAckSent;
+    public final int lastDataRecv;
+    public final int lastAckRecv;
+    public final int pmtu;
+    public final int rcvSsthresh;
+    public final int rtt;
+    public final int rttvar;
+    public final int sndSsthresh;
+    public final int sndCwnd;
+    public final int advmss;
+    public final int reordering;
+
+    TcpInfo(int state, int caState, int retransmits, int probes, int backoff, int options,
+        int sndWscale, int rcvWscale, int rto, int ato, int sndMss, int rcvMss, int unacked,
+        int sacked, int lost, int retrans, int fackets, int lastDataSent, int lastAckSent,
+        int lastDataRecv, int lastAckRecv, int pmtu, int rcvSsthresh, int rtt, int rttvar,
+        int sndSsthresh, int sndCwnd, int advmss, int reordering) {
+      this.state = state;
+      this.caState = caState;
+      this.retransmits = retransmits;
+      this.probes = probes;
+      this.backoff = backoff;
+      this.options = options;
+      this.sndWscale = sndWscale;
+      this.rcvWscale = rcvWscale;
+      this.rto = rto;
+      this.ato = ato;
+      this.sndMss = sndMss;
+      this.rcvMss = rcvMss;
+      this.unacked = unacked;
+      this.sacked = sacked;
+      this.lost = lost;
+      this.retrans = retrans;
+      this.fackets = fackets;
+      this.lastDataSent = lastDataSent;
+      this.lastAckSent = lastAckSent;
+      this.lastDataRecv = lastDataRecv;
+      this.lastAckRecv = lastAckRecv;
+      this.pmtu = pmtu;
+      this.rcvSsthresh = rcvSsthresh;
+      this.rtt = rtt;
+      this.rttvar = rttvar;
+      this.sndSsthresh = sndSsthresh;
+      this.sndCwnd = sndCwnd;
+      this.advmss = advmss;
+      this.reordering = reordering;
+    }
+
+    public static final class Builder {
+      private int state;
+      private int caState;
+      private int retransmits;
+      private int probes;
+      private int backoff;
+      private int options;
+      private int sndWscale;
+      private int rcvWscale;
+      private int rto;
+      private int ato;
+      private int sndMss;
+      private int rcvMss;
+      private int unacked;
+      private int sacked;
+      private int lost;
+      private int retrans;
+      private int fackets;
+      private int lastDataSent;
+      private int lastAckSent;
+      private int lastDataRecv;
+      private int lastAckRecv;
+      private int pmtu;
+      private int rcvSsthresh;
+      private int rtt;
+      private int rttvar;
+      private int sndSsthresh;
+      private int sndCwnd;
+      private int advmss;
+      private int reordering;
+
+      public Builder setState(int state) {
+        this.state = state;
+        return this;
+      }
+
+      public Builder setCaState(int caState) {
+        this.caState = caState;
+        return this;
+      }
+
+      public Builder setRetransmits(int retransmits) {
+        this.retransmits = retransmits;
+        return this;
+      }
+
+      public Builder setProbes(int probes) {
+        this.probes = probes;
+        return this;
+      }
+
+      public Builder setBackoff(int backoff) {
+        this.backoff = backoff;
+        return this;
+      }
+
+      public Builder setOptions(int options) {
+        this.options = options;
+        return this;
+      }
+
+      public Builder setSndWscale(int sndWscale) {
+        this.sndWscale = sndWscale;
+        return this;
+      }
+
+      public Builder setRcvWscale(int rcvWscale) {
+        this.rcvWscale = rcvWscale;
+        return this;
+      }
+
+      public Builder setRto(int rto) {
+        this.rto = rto;
+        return this;
+      }
+
+      public Builder setAto(int ato) {
+        this.ato = ato;
+        return this;
+      }
+
+      public Builder setSndMss(int sndMss) {
+        this.sndMss = sndMss;
+        return this;
+      }
+
+      public Builder setRcvMss(int rcvMss) {
+        this.rcvMss = rcvMss;
+        return this;
+      }
+
+      public Builder setUnacked(int unacked) {
+        this.unacked = unacked;
+        return this;
+      }
+
+      public Builder setSacked(int sacked) {
+        this.sacked = sacked;
+        return this;
+      }
+
+      public Builder setLost(int lost) {
+        this.lost = lost;
+        return this;
+      }
+
+      public Builder setRetrans(int retrans) {
+        this.retrans = retrans;
+        return this;
+      }
+
+      public Builder setFackets(int fackets) {
+        this.fackets = fackets;
+        return this;
+      }
+
+      public Builder setLastDataSent(int lastDataSent) {
+        this.lastDataSent = lastDataSent;
+        return this;
+      }
+
+      public Builder setLastAckSent(int lastAckSent) {
+        this.lastAckSent = lastAckSent;
+        return this;
+      }
+
+      public Builder setLastDataRecv(int lastDataRecv) {
+        this.lastDataRecv = lastDataRecv;
+        return this;
+      }
+
+      public Builder setLastAckRecv(int lastAckRecv) {
+        this.lastAckRecv = lastAckRecv;
+        return this;
+      }
+
+      public Builder setPmtu(int pmtu) {
+        this.pmtu = pmtu;
+        return this;
+      }
+
+      public Builder setRcvSsthresh(int rcvSsthresh) {
+        this.rcvSsthresh = rcvSsthresh;
+        return this;
+      }
+
+      public Builder setRtt(int rtt) {
+        this.rtt = rtt;
+        return this;
+      }
+
+      public Builder setRttvar(int rttvar) {
+        this.rttvar = rttvar;
+        return this;
+      }
+
+      public Builder setSndSsthresh(int sndSsthresh) {
+        this.sndSsthresh = sndSsthresh;
+        return this;
+      }
+
+      public Builder setSndCwnd(int sndCwnd) {
+        this.sndCwnd = sndCwnd;
+        return this;
+      }
+
+      public Builder setAdvmss(int advmss) {
+        this.advmss = advmss;
+        return this;
+      }
+
+      public Builder setReordering(int reordering) {
+        this.reordering = reordering;
+        return this;
+      }
+
+      /** Builds an instance. */
+      public TcpInfo build() {
+        return new TcpInfo(
+            state, caState, retransmits, probes, backoff, options, sndWscale, rcvWscale,
+            rto, ato, sndMss, rcvMss, unacked, sacked, lost, retrans, fackets, lastDataSent,
+            lastAckSent, lastDataRecv, lastAckRecv, pmtu, rcvSsthresh, rtt, rttvar, sndSsthresh,
+            sndCwnd, advmss, reordering);
+      }
+    }
+  }
+
+  public static final class SocketOptions {
+    public final Map<String, String> others;
+    // In netty, the value of a channel option may be null.
+    @Nullable public final Integer soTimeoutMillis;
+    @Nullable public final Integer lingerSeconds;
+    @Nullable public final TcpInfo tcpInfo;
+
+    /** Creates an instance. */
+    public SocketOptions(
+        @Nullable Integer timeoutMillis,
+        @Nullable Integer lingerSeconds,
+        @Nullable TcpInfo tcpInfo,
+        Map<String, String> others) {
+      checkNotNull(others);
+      this.soTimeoutMillis = timeoutMillis;
+      this.lingerSeconds = lingerSeconds;
+      this.tcpInfo = tcpInfo;
+      this.others = Collections.unmodifiableMap(new HashMap<>(others));
+    }
+
+    public static final class Builder {
+      private final Map<String, String> others = new HashMap<>();
+
+      private TcpInfo tcpInfo;
+      private Integer timeoutMillis;
+      private Integer lingerSeconds;
+
+      /** The value of {@link java.net.Socket#getSoTimeout()}. */
+      public Builder setSocketOptionTimeoutMillis(Integer timeoutMillis) {
+        this.timeoutMillis = timeoutMillis;
+        return this;
+      }
+
+      /** The value of {@link java.net.Socket#getSoLinger()}.
+       * Note: SO_LINGER is typically expressed in seconds.
+       */
+      public Builder setSocketOptionLingerSeconds(Integer lingerSeconds) {
+        this.lingerSeconds = lingerSeconds;
+        return this;
+      }
+
+      public Builder setTcpInfo(TcpInfo tcpInfo) {
+        this.tcpInfo = tcpInfo;
+        return this;
+      }
+
+      public Builder addOption(String name, String value) {
+        others.put(name, checkNotNull(value));
+        return this;
+      }
+
+      public Builder addOption(String name, int value) {
+        others.put(name, Integer.toString(value));
+        return this;
+      }
+
+      public Builder addOption(String name, boolean value) {
+        others.put(name, Boolean.toString(value));
+        return this;
+      }
+
+      public SocketOptions build() {
+        return new SocketOptions(timeoutMillis, lingerSeconds, tcpInfo, others);
+      }
+    }
+  }
+
+  /**
+   * A data class to represent transport stats.
+   */
+  @Immutable
+  public static final class TransportStats {
+    public final long streamsStarted;
+    public final long lastLocalStreamCreatedTimeNanos;
+    public final long lastRemoteStreamCreatedTimeNanos;
+    public final long streamsSucceeded;
+    public final long streamsFailed;
+    public final long messagesSent;
+    public final long messagesReceived;
+    public final long keepAlivesSent;
+    public final long lastMessageSentTimeNanos;
+    public final long lastMessageReceivedTimeNanos;
+    public final long localFlowControlWindow;
+    public final long remoteFlowControlWindow;
+    // TODO(zpencer): report socket flags and other info
+
+    /**
+     * Creates an instance.
+     */
+    public TransportStats(
+        long streamsStarted,
+        long lastLocalStreamCreatedTimeNanos,
+        long lastRemoteStreamCreatedTimeNanos,
+        long streamsSucceeded,
+        long streamsFailed,
+        long messagesSent,
+        long messagesReceived,
+        long keepAlivesSent,
+        long lastMessageSentTimeNanos,
+        long lastMessageReceivedTimeNanos,
+        long localFlowControlWindow,
+        long remoteFlowControlWindow) {
+      this.streamsStarted = streamsStarted;
+      this.lastLocalStreamCreatedTimeNanos = lastLocalStreamCreatedTimeNanos;
+      this.lastRemoteStreamCreatedTimeNanos = lastRemoteStreamCreatedTimeNanos;
+      this.streamsSucceeded = streamsSucceeded;
+      this.streamsFailed = streamsFailed;
+      this.messagesSent = messagesSent;
+      this.messagesReceived = messagesReceived;
+      this.keepAlivesSent = keepAlivesSent;
+      this.lastMessageSentTimeNanos = lastMessageSentTimeNanos;
+      this.lastMessageReceivedTimeNanos = lastMessageReceivedTimeNanos;
+      this.localFlowControlWindow = localFlowControlWindow;
+      this.remoteFlowControlWindow = remoteFlowControlWindow;
+    }
+  }
+
+  /** Unwraps a {@link InternalLogId} to return a {@code long}. */
+  public static long id(InternalWithLogId withLogId) {
+    return withLogId.getLogId().getId();
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalClientInterceptors.java b/api/src/main/java/io/grpc/InternalClientInterceptors.java
new file mode 100644
index 00000000000..e6c8acd52e5
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalClientInterceptors.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2018 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;
+
+import io.grpc.MethodDescriptor.Marshaller;
+
+/**
+ * Internal accessor. Do not use.
+ */
+@Internal
+public final class InternalClientInterceptors {
+  public static <ReqT, RespT> ClientInterceptor wrapClientInterceptor(
+      final ClientInterceptor interceptor,
+      final Marshaller<ReqT> reqMarshaller,
+      final Marshaller<RespT> respMarshaller) {
+    return ClientInterceptors.wrapClientInterceptor(interceptor, reqMarshaller, respMarshaller);
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalConfigSelector.java b/api/src/main/java/io/grpc/InternalConfigSelector.java
new file mode 100644
index 00000000000..a63009361d4
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalConfigSelector.java
@@ -0,0 +1,125 @@
+/*
+ * 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import javax.annotation.Nullable;
+
+// The class can not be located in io.grpc.internal since it is used as a cross-module API.
+// Otherwise, shading would break it.
+/**
+ * Per method config selector that the channel or load balancers will use to choose the appropriate
+ * config or take config related actions for an RPC.
+ */
+@Internal
+public abstract class InternalConfigSelector {
+  @NameResolver.ResolutionResultAttr
+  public static final Attributes.Key<io.grpc.InternalConfigSelector> KEY
+      = Attributes.Key.create("internal:io.grpc.config-selector");
+
+  // Use PickSubchannelArgs for SelectConfigArgs for now. May change over time.
+  /** Selects the config for an RPC. */
+  public abstract Result selectConfig(LoadBalancer.PickSubchannelArgs args);
+
+  public static final class Result {
+    private final Status status;
+    private final Object config;
+    @Nullable
+    public ClientInterceptor interceptor;
+
+    private Result(
+        Status status, Object config, ClientInterceptor interceptor) {
+      this.status = checkNotNull(status, "status");
+      this.config = config;
+      this.interceptor = interceptor;
+    }
+
+    /**
+     * Creates a {@code Result} with the given error status.
+     */
+    public static Result forError(Status status) {
+      checkArgument(!status.isOk(), "status is OK");
+      return new Result(status, null, null);
+    }
+
+    /**
+     * Returns the status of the config selection operation. If status is not {@link Status#OK},
+     * this result should not be used.
+     */
+    public Status getStatus() {
+      return status;
+    }
+
+    /**
+     * Returns a parsed config. Must have been returned via
+     * ServiceConfigParser.parseServiceConfig().getConfig()
+     */
+    public Object getConfig() {
+      return config;
+    }
+
+    /**
+     * Returns an interceptor that will be applies to calls.
+     */
+    @Nullable
+    public ClientInterceptor getInterceptor() {
+      return interceptor;
+    }
+
+    public static Builder newBuilder() {
+      return new Builder();
+    }
+
+    public static final class Builder {
+      private Object config;
+      private ClientInterceptor interceptor;
+
+      private Builder() {}
+
+      /**
+       * Sets the parsed config. This field is required.
+       *
+       * @return this
+       */
+      public Builder setConfig(Object config) {
+        this.config = checkNotNull(config, "config");
+        return this;
+      }
+
+      /**
+       * Sets the interceptor. This field is optional.
+       *
+       * @return this
+       */
+      public Builder setInterceptor(ClientInterceptor interceptor) {
+        this.interceptor = checkNotNull(interceptor, "interceptor");
+        return this;
+      }
+
+      /**
+       * Build this {@link Result}.
+       */
+      public Result build() {
+        checkState(config != null, "config is not set");
+        return new Result(Status.OK, config, interceptor);
+      }
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalConfigurator.java b/api/src/main/java/io/grpc/InternalConfigurator.java
new file mode 100644
index 00000000000..7091767a265
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalConfigurator.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2024 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;
+
+/**
+ * Internal access to Configurator API.
+ */
+@Internal
+public interface InternalConfigurator extends Configurator {}
diff --git a/api/src/main/java/io/grpc/InternalConfiguratorRegistry.java b/api/src/main/java/io/grpc/InternalConfiguratorRegistry.java
new file mode 100644
index 00000000000..f567dab74c4
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalConfiguratorRegistry.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2024 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;
+
+import java.util.List;
+
+/**
+ * Access internal global configurators.
+ */
+@Internal
+public final class InternalConfiguratorRegistry {
+  private InternalConfiguratorRegistry() {}
+
+  public static void setConfigurators(List<InternalConfigurator> configurators) {
+    ConfiguratorRegistry.getDefaultRegistry().setConfigurators(configurators);
+  }
+
+  public static List<?> getConfigurators() {
+    return ConfiguratorRegistry.getDefaultRegistry().getConfigurators();
+  }
+
+  public static void configureChannelBuilder(ManagedChannelBuilder<?> channelBuilder) {
+    for (Configurator configurator : ConfiguratorRegistry.getDefaultRegistry().getConfigurators()) {
+      configurator.configureChannelBuilder(channelBuilder);
+    }
+  }
+
+  public static void configureServerBuilder(ServerBuilder<?> serverBuilder) {
+    for (Configurator configurator : ConfiguratorRegistry.getDefaultRegistry().getConfigurators()) {
+      configurator.configureServerBuilder(serverBuilder);
+    }
+  }
+
+  public static boolean wasSetConfiguratorsCalled() {
+    return ConfiguratorRegistry.getDefaultRegistry().wasSetConfiguratorsCalled();
+  }
+
+  public static int getConfiguratorsCallCountBeforeSet() {
+    return ConfiguratorRegistry.getDefaultRegistry().getConfiguratorsCallCountBeforeSet();
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalDecompressorRegistry.java b/api/src/main/java/io/grpc/InternalDecompressorRegistry.java
new file mode 100644
index 00000000000..c0563a46e82
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalDecompressorRegistry.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2016 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;
+
+/**
+ * Private accessor for decompressor registries.  Don't use this.
+ */
+@Internal
+public final class InternalDecompressorRegistry {
+  private InternalDecompressorRegistry() {}
+
+  @Internal
+  public static byte[] getRawAdvertisedMessageEncodings(DecompressorRegistry reg) {
+    return reg.getRawAdvertisedMessageEncodings();
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalInstrumented.java b/api/src/main/java/io/grpc/InternalInstrumented.java
new file mode 100644
index 00000000000..44366d4a626
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalInstrumented.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2017 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;
+
+import com.google.common.util.concurrent.ListenableFuture;
+
+/**
+ * An internal class. Do not use.
+ *
+ * <p>An interface for types that <b>may</b> support instrumentation. If the actual type does not
+ * support instrumentation, then the future will return a {@code null}.
+ */
+@Internal
+public interface InternalInstrumented<T> extends InternalWithLogId {
+
+  /**
+   * Returns the stats object.
+   */
+  ListenableFuture<T> getStats();
+}
diff --git a/api/src/main/java/io/grpc/InternalKnownTransport.java b/api/src/main/java/io/grpc/InternalKnownTransport.java
new file mode 100644
index 00000000000..e05eb03d1a9
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalKnownTransport.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2016 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;
+
+/**
+ * All known transports.
+ *
+ * <p>Make sure to update MethodDescriptor.rawMethodNames if this is changed.
+ */
+@Internal
+public enum InternalKnownTransport {
+  NETTY,
+  NETTY_SHADED,
+  ;
+}
+
diff --git a/api/src/main/java/io/grpc/InternalLogId.java b/api/src/main/java/io/grpc/InternalLogId.java
new file mode 100644
index 00000000000..afb2779a478
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalLogId.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2017 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.util.concurrent.atomic.AtomicLong;
+import javax.annotation.Nullable;
+
+/**
+ * An internal class. Do not use.
+ *
+ *<p>An object that has an ID that is unique within the JVM, primarily for debug logging.
+ */
+@Internal
+public final class InternalLogId {
+
+  private static final AtomicLong idAlloc = new AtomicLong();
+
+  /**
+   * Creates a log id.
+   *
+   * @param type the "Type" to be used when logging this id.   The short name of this class will be
+   *     used, or else a default if the class is anonymous.
+   * @param details a short, human readable string that describes the object the id is attached to.
+   *     Typically this will be an address or target.
+   */
+  public static InternalLogId allocate(Class<?> type, @Nullable String details) {
+    return allocate(getClassName(type), details);
+  }
+
+  /**
+   * Creates a log id.
+   *
+   * @param typeName the "Type" to be used when logging this id.
+   * @param details a short, human readable string that describes the object the id is attached to.
+   *     Typically this will be an address or target.
+   */
+  public static InternalLogId allocate(String typeName, @Nullable String details) {
+    return new InternalLogId(typeName, details, getNextId());
+  }
+
+  static long getNextId() {
+    return idAlloc.incrementAndGet();
+  }
+
+  private final String typeName;
+  @Nullable
+  private final String details;
+  private final long id;
+
+  InternalLogId(String typeName, String details, long id) {
+    checkNotNull(typeName, "typeName");
+    checkArgument(!typeName.isEmpty(), "empty type");
+    this.typeName = typeName;
+    this.details = details;
+    this.id = id;
+  }
+
+  public String getTypeName() {
+    return typeName;
+  }
+
+  @Nullable
+  public String getDetails() {
+    return details;
+  }
+
+  public long getId() {
+    return id;
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+    sb.append(shortName());
+    if (details != null) {
+      sb.append(": (");
+      sb.append(details);
+      sb.append(')');
+    }
+    return sb.toString();
+  }
+
+  private static String getClassName(Class<?> type) {
+    String className = checkNotNull(type, "type").getSimpleName();
+    if (!className.isEmpty()) {
+      return className;
+    }
+    // + 1 removes the separating '.'
+    return type.getName().substring(type.getPackage().getName().length() + 1);
+  }
+
+  public String shortName() {
+    return typeName + "<" + id + ">";
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalManagedChannelBuilder.java b/api/src/main/java/io/grpc/InternalManagedChannelBuilder.java
new file mode 100644
index 00000000000..083cad40098
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalManagedChannelBuilder.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2024 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;
+
+/**
+ * Internal accessors for {@link ManagedChannelBuilder}.
+ */
+@Internal
+public final class InternalManagedChannelBuilder {
+  private InternalManagedChannelBuilder() {}
+
+  public static <T extends ManagedChannelBuilder<T>> T interceptWithTarget(
+      ManagedChannelBuilder<T> builder, InternalInterceptorFactory factory) {
+    return builder.interceptWithTarget(factory);
+  }
+
+  public static <T extends ManagedChannelBuilder<T>> T addMetricSink(
+      ManagedChannelBuilder<T> builder, MetricSink metricSink) {
+    return builder.addMetricSink(metricSink);
+  }
+
+  public interface InternalInterceptorFactory extends ManagedChannelBuilder.InterceptorFactory {}
+}
diff --git a/api/src/main/java/io/grpc/InternalManagedChannelProvider.java b/api/src/main/java/io/grpc/InternalManagedChannelProvider.java
new file mode 100644
index 00000000000..2b22e6013ed
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalManagedChannelProvider.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2022 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;
+
+import io.grpc.ManagedChannelProvider.NewChannelBuilderResult;
+
+/** Internal accessor for {@link ManagedChannelProvider}. */
+@Internal
+public final class InternalManagedChannelProvider {
+
+  private InternalManagedChannelProvider() {
+  }
+
+  public static boolean isAvailable(ManagedChannelProvider provider) {
+    return provider.isAvailable();
+  }
+
+  public static ManagedChannelBuilder<?> builderForAddress(ManagedChannelProvider provider,
+      String name, int port) {
+    return provider.builderForAddress(name, port);
+  }
+
+  public static ManagedChannelBuilder<?> builderForTarget(ManagedChannelProvider provider,
+      String target) {
+    return provider.builderForTarget(target);
+  }
+
+  public static NewChannelBuilderResult newChannelBuilder(ManagedChannelProvider provider,
+      String target, ChannelCredentials creds) {
+    return provider.newChannelBuilder(target, creds);
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalMayRequireSpecificExecutor.java b/api/src/main/java/io/grpc/InternalMayRequireSpecificExecutor.java
new file mode 100644
index 00000000000..0be807ce9dc
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalMayRequireSpecificExecutor.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2022 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;
+
+@Internal
+public interface InternalMayRequireSpecificExecutor {
+  boolean isSpecificExecutorRequired();
+}
diff --git a/api/src/main/java/io/grpc/InternalMetadata.java b/api/src/main/java/io/grpc/InternalMetadata.java
new file mode 100644
index 00000000000..cbf6b72aaf0
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalMetadata.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2016 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;
+
+import com.google.common.io.BaseEncoding;
+import io.grpc.Metadata.AsciiMarshaller;
+import io.grpc.Metadata.BinaryStreamMarshaller;
+import java.io.InputStream;
+import java.nio.charset.Charset;
+
+/**
+ * Internal {@link Metadata} accessor. This is intended for use by io.grpc.internal, and the
+ * specifically supported transport packages. If you *really* think you need to use this, contact
+ * the gRPC team first.
+ */
+@Internal
+public final class InternalMetadata {
+
+  /**
+   * A specialized plain ASCII marshaller. Both input and output are assumed to be valid header
+   * ASCII.
+   *
+   * <p>Extended here to break the dependency.
+   */
+  @Internal
+  public interface TrustedAsciiMarshaller<T> extends Metadata.TrustedAsciiMarshaller<T> {}
+
+  /**
+   * Copy of StandardCharsets, which is only available on Java 1.7 and above.
+   */
+  @Internal
+  public static final Charset US_ASCII = Charset.forName("US-ASCII");
+
+  /**
+   * An instance of base64 encoder that omits padding.
+   */
+  @Internal
+  public static final BaseEncoding BASE64_ENCODING_OMIT_PADDING
+      = Metadata.BASE64_ENCODING_OMIT_PADDING;
+
+  @Internal
+  public static <T> Metadata.Key<T> keyOf(String name, TrustedAsciiMarshaller<T> marshaller) {
+    boolean isPseudo = name != null && !name.isEmpty() && name.charAt(0) == ':';
+    return Metadata.Key.of(name, isPseudo, marshaller);
+  }
+
+  @Internal
+  public static <T> Metadata.Key<T> keyOf(String name, AsciiMarshaller<T> marshaller) {
+    boolean isPseudo = name != null && !name.isEmpty() && name.charAt(0) == ':';
+    return Metadata.Key.of(name, isPseudo, marshaller);
+  }
+
+  @Internal
+  public static Metadata newMetadata(byte[]... binaryValues) {
+    return new Metadata(binaryValues);
+  }
+
+  @Internal
+  public static Metadata newMetadata(int usedNames, byte[]... binaryValues) {
+    return new Metadata(usedNames, binaryValues);
+  }
+
+  @Internal
+  public static byte[][] serialize(Metadata md) {
+    return md.serialize();
+  }
+
+  @Internal
+  public static int headerCount(Metadata md) {
+    return md.headerCount();
+  }
+
+  /**
+   * Serializes all metadata entries, leaving some values as {@link InputStream}s.
+   *
+   * <p>Produces serialized names and values interleaved. result[i*2] are names, while
+   * result[i*2+1] are values.
+   *
+   * <p>Names are byte arrays as described according to the {@link Metadata#serialize}
+   * method. Values are either byte arrays or {@link InputStream}s.
+   */
+  @Internal
+  public static Object[] serializePartial(Metadata md) {
+    return md.serializePartial();
+  }
+
+  /**
+   * Creates a holder for a pre-parsed value read by the transport.
+   *
+   * @param marshaller The {@link Metadata.BinaryStreamMarshaller} associated with this value.
+   * @param value The value to store.
+   * @return an object holding the pre-parsed value for this key.
+   */
+  @Internal
+  public static <T> Object parsedValue(BinaryStreamMarshaller<T> marshaller, T value) {
+    return new Metadata.LazyValue<>(marshaller, value);
+  }
+
+  /**
+   * Creates a new {@link Metadata} instance from serialized data,
+   * with some values pre-parsed. Metadata will mutate the passed in array.
+   *
+   * @param usedNames The number of names used.
+   * @param namesAndValues An array of interleaved names and values,
+   *     with each name (at even indices) represented as a byte array,
+   *     and each value (at odd indices) represented as either a byte
+   *     array or an object returned by the {@link #parsedValue}
+   *     method.
+   */
+  @Internal
+  public static Metadata newMetadataWithParsedValues(int usedNames, Object[] namesAndValues) {
+    return new Metadata(usedNames, namesAndValues);
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalMethodDescriptor.java b/api/src/main/java/io/grpc/InternalMethodDescriptor.java
new file mode 100644
index 00000000000..345f6065813
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalMethodDescriptor.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2016 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+/**
+ * Accesses internal data and methods.  Do not use this.
+ */
+@Internal
+public final class InternalMethodDescriptor {
+  private final InternalKnownTransport transport;
+
+  public InternalMethodDescriptor(InternalKnownTransport transport) {
+    // TODO(carl-mastrangelo): maybe restrict access to this.
+    this.transport = checkNotNull(transport, "transport");
+  }
+
+  @SuppressWarnings("EnumOrdinal")
+  public Object geRawMethodName(MethodDescriptor<?, ?> descriptor) {
+    return descriptor.getRawMethodName(transport.ordinal());
+  }
+
+  @SuppressWarnings("EnumOrdinal")
+  public void setRawMethodName(MethodDescriptor<?, ?> descriptor, Object o) {
+    descriptor.setRawMethodName(transport.ordinal(), o);
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalServer.java b/api/src/main/java/io/grpc/InternalServer.java
new file mode 100644
index 00000000000..8a28c91fbec
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalServer.java
@@ -0,0 +1,31 @@
+/*
+ * 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;
+
+/**
+ * Internal accessor for getting the {@link Server} instance inside server RPC {@link Context}.
+ * This is intended for usage internal to the gRPC team. If you think you need to use
+ * this, contact the gRPC team first.
+ */
+@Internal
+public class InternalServer {
+  public static final Context.Key<Server> SERVER_CONTEXT_KEY = Server.SERVER_CONTEXT_KEY;
+
+  // Prevent instantiation.
+  private InternalServer() {
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalServerInterceptors.java b/api/src/main/java/io/grpc/InternalServerInterceptors.java
new file mode 100644
index 00000000000..e48c1468f1e
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalServerInterceptors.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2017 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;
+
+/**
+ * Accessor to internal methods of {@link ServerInterceptors}.
+ */
+@Internal
+public final class InternalServerInterceptors {
+  public static <OrigReqT, OrigRespT, WrapReqT, WrapRespT>
+      ServerMethodDefinition<WrapReqT, WrapRespT> wrapMethod(
+      final ServerMethodDefinition<OrigReqT, OrigRespT> definition,
+      final MethodDescriptor<WrapReqT, WrapRespT> wrappedMethod) {
+    return ServerInterceptors.wrapMethod(definition, wrappedMethod);
+  }
+
+  public static <ReqT, RespT> ServerCallHandler<ReqT, RespT> interceptCallHandlerCreate(
+      ServerInterceptor interceptor, ServerCallHandler<ReqT, RespT> callHandler) {
+    return ServerInterceptors.InterceptCallHandler.create(interceptor, callHandler);
+  }
+
+  private InternalServerInterceptors() {
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalServerProvider.java b/api/src/main/java/io/grpc/InternalServerProvider.java
new file mode 100644
index 00000000000..d8c1d77fe76
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalServerProvider.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 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;
+
+import io.grpc.ServerProvider.NewServerBuilderResult;
+
+/** Internal accessor for {@link ServerProvider}. */
+@Internal
+public final class InternalServerProvider {
+
+  private InternalServerProvider() {
+  }
+
+  public static ServerBuilder<?> builderForPort(ServerProvider provider, int port) {
+    return provider.builderForPort(port);
+  }
+
+  public static NewServerBuilderResult newServerBuilderForPort(ServerProvider provider, int port,
+      ServerCredentials creds) {
+    return provider.newServerBuilderForPort(port, creds);
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalServiceProviders.java b/api/src/main/java/io/grpc/InternalServiceProviders.java
new file mode 100644
index 00000000000..c72e01db67a
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalServiceProviders.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2017 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;
+
+import com.google.common.annotations.VisibleForTesting;
+import java.util.List;
+
+@Internal
+public final class InternalServiceProviders {
+  private InternalServiceProviders() {
+  }
+
+  /**
+   * Accessor for method.
+   */
+  public static <T> T load(
+      Class<T> klass,
+      Iterable<Class<?>> hardcoded,
+      ClassLoader classLoader,
+      PriorityAccessor<T> priorityAccessor) {
+    return ServiceProviders.load(klass, hardcoded, classLoader, priorityAccessor);
+  }
+
+  /**
+   * Accessor for method.
+   */
+  public static <T> List<T> loadAll(
+      Class<T> klass,
+      Iterable<Class<?>> hardCodedClasses,
+      ClassLoader classLoader,
+      PriorityAccessor<T> priorityAccessor) {
+    return ServiceProviders.loadAll(klass, hardCodedClasses, classLoader, priorityAccessor);
+  }
+
+  /**
+   * Accessor for method.
+   */
+  @VisibleForTesting
+  public static <T> Iterable<T> getCandidatesViaServiceLoader(Class<T> klass, ClassLoader cl) {
+    return ServiceProviders.getCandidatesViaServiceLoader(klass, cl);
+  }
+
+  /**
+   * Accessor for method.
+   */
+  @VisibleForTesting
+  public static <T> Iterable<T> getCandidatesViaHardCoded(
+      Class<T> klass, Iterable<Class<?>> hardcoded) {
+    return ServiceProviders.getCandidatesViaHardCoded(klass, hardcoded);
+  }
+
+  /**
+   * Accessor for {@link ServiceProviders#isAndroid}.
+   */
+  public static boolean isAndroid(ClassLoader cl) {
+    return ServiceProviders.isAndroid(cl);
+  }
+
+  public interface PriorityAccessor<T> extends ServiceProviders.PriorityAccessor<T> {}
+}
diff --git a/api/src/main/java/io/grpc/InternalStatus.java b/api/src/main/java/io/grpc/InternalStatus.java
new file mode 100644
index 00000000000..56df1decf38
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalStatus.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2017 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;
+
+import javax.annotation.Nullable;
+
+/**
+ * Accesses internal data.  Do not use this.
+ */
+@Internal
+public final class InternalStatus {
+  private InternalStatus() {}
+
+  /**
+   * Key to bind status message to trailing metadata.
+   */
+  @Internal
+  public static final Metadata.Key<String> MESSAGE_KEY = Status.MESSAGE_KEY;
+
+  /**
+   * Key to bind status code to trailing metadata.
+   */
+  @Internal
+  public static final Metadata.Key<Status> CODE_KEY = Status.CODE_KEY;
+
+  /**
+   * Create a new {@link StatusRuntimeException} skipping the filling of the stack trace.
+   */
+  @Internal
+  public static StatusRuntimeException asRuntimeExceptionWithoutStacktrace(Status status,
+      @Nullable Metadata trailers) {
+    return new InternalStatusRuntimeException(status, trailers);
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalStatusRuntimeException.java b/api/src/main/java/io/grpc/InternalStatusRuntimeException.java
new file mode 100644
index 00000000000..6090b701f0b
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalStatusRuntimeException.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2015 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;
+
+import javax.annotation.Nullable;
+
+/**
+ * StatusRuntimeException without stack trace, implemented as a subclass, as the
+ * {@code String, Throwable, boolean, boolean} constructor is not available in the supported
+ * version of Android.
+ *
+ * @see StatusRuntimeException
+ */
+class InternalStatusRuntimeException extends StatusRuntimeException {
+  private static final long serialVersionUID = 0;
+
+  public InternalStatusRuntimeException(Status status, @Nullable Metadata trailers) {
+    super(status, trailers);
+  }
+
+  @Override
+  public synchronized Throwable fillInStackTrace() {
+    return this;
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalSubchannelAddressAttributes.java b/api/src/main/java/io/grpc/InternalSubchannelAddressAttributes.java
new file mode 100644
index 00000000000..cfc2f7c5137
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalSubchannelAddressAttributes.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2024 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;
+
+/**
+ * An internal class. Do not use.
+ *
+ * <p>An interface to provide the attributes for address connected by subchannel.
+ */
+@Internal
+public interface InternalSubchannelAddressAttributes {
+
+  /**
+   * Return attributes of the server address connected by sub channel.
+   */
+  public Attributes getConnectedAddressAttributes();
+}
diff --git a/api/src/main/java/io/grpc/InternalTimeUtils.java b/api/src/main/java/io/grpc/InternalTimeUtils.java
new file mode 100644
index 00000000000..ef8022f53c5
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalTimeUtils.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2024 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;
+
+import java.time.Duration;
+
+@Internal
+public final class InternalTimeUtils {
+  public static long convert(Duration duration) {
+    return TimeUtils.convertToNanos(duration);
+  }
+}
diff --git a/api/src/main/java/io/grpc/InternalWithLogId.java b/api/src/main/java/io/grpc/InternalWithLogId.java
new file mode 100644
index 00000000000..e5051233e34
--- /dev/null
+++ b/api/src/main/java/io/grpc/InternalWithLogId.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2017 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;
+
+/**
+ * An internal class. Do not use.
+ *
+ * <p>A loggable ID, unique for the duration of the program.
+ */
+@Internal
+public interface InternalWithLogId {
+  /**
+   * Returns an ID that is primarily used in debug logs. It usually contains the class name and a
+   * numeric ID that is unique among the instances.
+   *
+   * <p>The subclasses of this interface usually want to include the log ID in their {@link
+   * Object#toString} results.
+   */
+  InternalLogId getLogId();
+}
diff --git a/api/src/main/java/io/grpc/KnownLength.java b/api/src/main/java/io/grpc/KnownLength.java
new file mode 100644
index 00000000000..f31c3383e96
--- /dev/null
+++ b/api/src/main/java/io/grpc/KnownLength.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2014 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;
+
+import java.io.IOException;
+
+/**
+ * An {@link java.io.InputStream} or alike whose total number of bytes that can be read is known
+ * upfront.
+ *
+ * <p>Usually it's a {@link java.io.InputStream} that also implements this interface, in which case
+ * {@link java.io.InputStream#available()} has a stronger semantic by returning an accurate number
+ * instead of an estimation.
+ */
+public interface KnownLength {
+  /**
+   * Returns the total number of bytes that can be read (or skipped over) from this object until all
+   * bytes have been read out.
+   */
+  int available() throws IOException;
+}
diff --git a/api/src/main/java/io/grpc/LoadBalancer.java b/api/src/main/java/io/grpc/LoadBalancer.java
new file mode 100644
index 00000000000..adc43b19841
--- /dev/null
+++ b/api/src/main/java/io/grpc/LoadBalancer.java
@@ -0,0 +1,1594 @@
+/*
+ * Copyright 2016 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import com.google.common.base.Preconditions;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ScheduledExecutorService;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+import javax.annotation.concurrent.NotThreadSafe;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A pluggable component that receives resolved addresses from {@link NameResolver} and provides the
+ * channel a usable subchannel when asked.
+ *
+ * <h3>Overview</h3>
+ *
+ * <p>A LoadBalancer typically implements three interfaces:
+ * <ol>
+ *   <li>{@link LoadBalancer} is the main interface.  All methods on it are invoked sequentially
+ *       in the same <strong>synchronization context</strong> (see next section) as returned by
+ *       {@link io.grpc.LoadBalancer.Helper#getSynchronizationContext}.  It receives the results
+ *       from the {@link NameResolver}, updates of subchannels' connectivity states, and the
+ *       channel's request for the LoadBalancer to shutdown.</li>
+ *   <li>{@link SubchannelPicker SubchannelPicker} does the actual load-balancing work.  It selects
+ *       a {@link Subchannel Subchannel} for each new RPC.</li>
+ *   <li>{@link Factory Factory} creates a new {@link LoadBalancer} instance.
+ * </ol>
+ *
+ * <p>{@link Helper Helper} is implemented by gRPC library and provided to {@link Factory
+ * Factory}. It provides functionalities that a {@code LoadBalancer} implementation would typically
+ * need.
+ *
+ * <h3>The Synchronization Context</h3>
+ *
+ * <p>All methods on the {@link LoadBalancer} interface are called from a Synchronization Context,
+ * meaning they are serialized, thus the balancer implementation doesn't need to worry about
+ * synchronization among them.  {@link io.grpc.LoadBalancer.Helper#getSynchronizationContext}
+ * allows implementations to schedule tasks to be run in the same Synchronization Context, with or
+ * without a delay, thus those tasks don't need to worry about synchronizing with the balancer
+ * methods.
+ * 
+ * <p>However, the actual running thread may be the network thread, thus the following rules must be
+ * followed to prevent blocking or even dead-locking in a network:
+ *
+ * <ol>
+ *
+ *   <li><strong>Never block in the Synchronization Context</strong>.  The callback methods must
+ *   return quickly.  Examples or work that must be avoided: CPU-intensive calculation, waiting on
+ *   synchronization primitives, blocking I/O, blocking RPCs, etc.</li>
+ *
+ *   <li><strong>Avoid calling into other components with lock held</strong>.  The Synchronization
+ *   Context may be under a lock, e.g., the transport lock of OkHttp.  If your LoadBalancer holds a
+ *   lock in a callback method (e.g., {@link #handleResolvedAddresses handleResolvedAddresses()})
+ *   while calling into another method that also involves locks, be cautious of deadlock.  Generally
+ *   you wouldn't need any locking in the LoadBalancer if you follow the canonical implementation
+ *   pattern below.</li>
+ *
+ * </ol>
+ *
+ * <h3>The canonical implementation pattern</h3>
+ *
+ * <p>A {@link LoadBalancer} keeps states like the latest addresses from NameResolver, the
+ * Subchannel(s) and their latest connectivity states.  These states are mutated within the
+ * Synchronization Context,
+ *
+ * <p>A typical {@link SubchannelPicker SubchannelPicker} holds a snapshot of these states.  It may
+ * have its own states, e.g., a picker from a round-robin load-balancer may keep a pointer to the
+ * next Subchannel, which are typically mutated by multiple threads.  The picker should only mutate
+ * its own state, and should not mutate or re-acquire the states of the LoadBalancer.  This way the
+ * picker only needs to synchronize its own states, which is typically trivial to implement.
+ *
+ * <p>When the LoadBalancer states changes, e.g., Subchannels has become or stopped being READY, and
+ * we want subsequent RPCs to use the latest list of READY Subchannels, LoadBalancer would create a
+ * new picker, which holds a snapshot of the latest Subchannel list.  Refer to the javadoc of {@link
+ * io.grpc.LoadBalancer.SubchannelStateListener#onSubchannelState onSubchannelState()} how to do
+ * this properly.
+ *
+ * <p>No synchronization should be necessary between LoadBalancer and its pickers if you follow
+ * the pattern above.  It may be possible to implement in a different way, but that would usually
+ * result in more complicated threading.
+ *
+ * @since 1.2.0
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+@NotThreadSafe
+public abstract class LoadBalancer {
+
+  @Internal
+  @NameResolver.ResolutionResultAttr
+  public static final Attributes.Key<Map<String, ?>> ATTR_HEALTH_CHECKING_CONFIG =
+      Attributes.Key.create("internal:health-checking-config");
+
+  @Internal
+  public static final LoadBalancer.CreateSubchannelArgs.Key<LoadBalancer.SubchannelStateListener>
+      HEALTH_CONSUMER_LISTENER_ARG_KEY =
+      LoadBalancer.CreateSubchannelArgs.Key.create("internal:health-check-consumer-listener");
+
+  @Internal
+  public static final LoadBalancer.CreateSubchannelArgs.Key<Boolean>
+      DISABLE_SUBCHANNEL_RECONNECT_KEY =
+      LoadBalancer.CreateSubchannelArgs.Key.createWithDefault(
+          "internal:disable-subchannel-reconnect", Boolean.FALSE);
+
+  @Internal
+  public static final Attributes.Key<Boolean>
+      HAS_HEALTH_PRODUCER_LISTENER_KEY =
+      Attributes.Key.create("internal:has-health-check-producer-listener");
+
+  public static final Attributes.Key<Boolean> IS_PETIOLE_POLICY =
+      Attributes.Key.create("io.grpc.IS_PETIOLE_POLICY");
+
+  /**
+   * A picker that always returns an erring pick.
+   *
+   * @deprecated Use {@code new FixedResultPicker(PickResult.withNoResult())} instead.
+   */
+  @Deprecated
+  public static final SubchannelPicker EMPTY_PICKER = new SubchannelPicker() {
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      return PickResult.withNoResult();
+    }
+
+    @Override
+    public String toString() {
+      return "EMPTY_PICKER";
+    }
+  };
+
+  private int recursionCount;
+
+  /**
+   * Handles newly resolved server groups and metadata attributes from name resolution system.
+   * {@code servers} contained in {@link EquivalentAddressGroup} should be considered equivalent
+   * but may be flattened into a single list if needed.
+   *
+   * <p>Implementations should not modify the given {@code servers}.
+   *
+   * @param resolvedAddresses the resolved server addresses, attributes, and config.
+   * @since 1.21.0
+   */
+  public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    if (recursionCount++ == 0) {
+      // Note that the information about the addresses actually being accepted will be lost
+      // if you rely on this method for backward compatibility.
+      acceptResolvedAddresses(resolvedAddresses);
+    }
+    recursionCount = 0;
+  }
+
+  /**
+   * Accepts newly resolved addresses from the name resolution system. The {@link
+   * EquivalentAddressGroup} addresses should be considered equivalent but may be flattened into a
+   * single list if needed.
+   *
+   * <p>Implementations can choose to reject the given addresses by returning {@code false}.
+   *
+   * <p>Implementations should not modify the given {@code addresses}.
+   *
+   * @param resolvedAddresses the resolved server addresses, attributes, and config.
+   * @return {@code true} if the resolved addresses were accepted. {@code false} if rejected.
+   * @since 1.49.0
+   */
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    if (resolvedAddresses.getAddresses().isEmpty()
+        && !canHandleEmptyAddressListFromNameResolution()) {
+      Status unavailableStatus = Status.UNAVAILABLE.withDescription(
+              "NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+                      + ", attrs=" + resolvedAddresses.getAttributes());
+      handleNameResolutionError(unavailableStatus);
+      return unavailableStatus;
+    } else {
+      if (recursionCount++ == 0) {
+        handleResolvedAddresses(resolvedAddresses);
+      }
+      recursionCount = 0;
+
+      return Status.OK;
+    }
+  }
+
+  /**
+   * Represents a combination of the resolved server address, associated attributes and a load
+   * balancing policy config.  The config is from the {@link
+   * LoadBalancerProvider#parseLoadBalancingPolicyConfig(Map)}.
+   *
+   * @since 1.21.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11657")
+  public static final class ResolvedAddresses {
+    private final List<EquivalentAddressGroup> addresses;
+    @NameResolver.ResolutionResultAttr
+    private final Attributes attributes;
+    @Nullable
+    private final Object loadBalancingPolicyConfig;
+    // Make sure to update toBuilder() below!
+
+    private ResolvedAddresses(
+        List<EquivalentAddressGroup> addresses,
+        @NameResolver.ResolutionResultAttr Attributes attributes,
+        Object loadBalancingPolicyConfig) {
+      this.addresses =
+          Collections.unmodifiableList(new ArrayList<>(checkNotNull(addresses, "addresses")));
+      this.attributes = checkNotNull(attributes, "attributes");
+      this.loadBalancingPolicyConfig = loadBalancingPolicyConfig;
+    }
+
+    /**
+     * Factory for constructing a new Builder.
+     *
+     * @since 1.21.0
+     */
+    public static Builder newBuilder() {
+      return new Builder();
+    }
+
+    /**
+     * Converts this back to a builder.
+     *
+     * @since 1.21.0
+     */
+    public Builder toBuilder() {
+      return newBuilder()
+          .setAddresses(addresses)
+          .setAttributes(attributes)
+          .setLoadBalancingPolicyConfig(loadBalancingPolicyConfig);
+    }
+
+    /**
+     * Gets the server addresses.
+     *
+     * @since 1.21.0
+     */
+    public List<EquivalentAddressGroup> getAddresses() {
+      return addresses;
+    }
+
+    /**
+     * Gets the attributes associated with these addresses.  If this was not previously set,
+     * {@link Attributes#EMPTY} will be returned.
+     *
+     * @since 1.21.0
+     */
+    @NameResolver.ResolutionResultAttr
+    public Attributes getAttributes() {
+      return attributes;
+    }
+
+    /**
+     * Gets the domain specific load balancing policy.  This is the config produced by
+     * {@link LoadBalancerProvider#parseLoadBalancingPolicyConfig(Map)}.
+     *
+     * @since 1.21.0
+     */
+    @Nullable
+    public Object getLoadBalancingPolicyConfig() {
+      return loadBalancingPolicyConfig;
+    }
+
+    /**
+     * Builder for {@link ResolvedAddresses}.
+     */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+    public static final class Builder {
+      private List<EquivalentAddressGroup> addresses;
+      @NameResolver.ResolutionResultAttr
+      private Attributes attributes = Attributes.EMPTY;
+      @Nullable
+      private Object loadBalancingPolicyConfig;
+
+      Builder() {}
+
+      /**
+       * Sets the addresses.  This field is required.
+       *
+       * @return this.
+       */
+      public Builder setAddresses(List<EquivalentAddressGroup> addresses) {
+        this.addresses = addresses;
+        return this;
+      }
+
+      /**
+       * Sets the attributes.  This field is optional; if not called, {@link Attributes#EMPTY}
+       * will be used.
+       *
+       * @return this.
+       */
+      public Builder setAttributes(@NameResolver.ResolutionResultAttr Attributes attributes) {
+        this.attributes = attributes;
+        return this;
+      }
+
+      /**
+       * Sets the load balancing policy config. This field is optional.
+       *
+       * @return this.
+       */
+      public Builder setLoadBalancingPolicyConfig(@Nullable Object loadBalancingPolicyConfig) {
+        this.loadBalancingPolicyConfig = loadBalancingPolicyConfig;
+        return this;
+      }
+
+      /**
+       * Constructs the {@link ResolvedAddresses}.
+       */
+      public ResolvedAddresses build() {
+        return new ResolvedAddresses(addresses, attributes, loadBalancingPolicyConfig);
+      }
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("addresses", addresses)
+          .add("attributes", attributes)
+          .add("loadBalancingPolicyConfig", loadBalancingPolicyConfig)
+          .toString();
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(addresses, attributes, loadBalancingPolicyConfig);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (!(obj instanceof ResolvedAddresses)) {
+        return false;
+      }
+      ResolvedAddresses that = (ResolvedAddresses) obj;
+      return Objects.equal(this.addresses, that.addresses)
+          && Objects.equal(this.attributes, that.attributes)
+          && Objects.equal(this.loadBalancingPolicyConfig, that.loadBalancingPolicyConfig);
+    }
+  }
+
+  /**
+   * Handles an error from the name resolution system.
+   *
+   * @param error a non-OK status
+   * @since 1.2.0
+   */
+  public abstract void handleNameResolutionError(Status error);
+
+  /**
+   * Handles a state change on a Subchannel.
+   *
+   * <p>The initial state of a Subchannel is IDLE. You won't get a notification for the initial IDLE
+   * state.
+   *
+   * <p>If the new state is not SHUTDOWN, this method should create a new picker and call {@link
+   * Helper#updateBalancingState Helper.updateBalancingState()}.  Failing to do so may result in
+   * unnecessary delays of RPCs. Please refer to {@link PickResult#withSubchannel
+   * PickResult.withSubchannel()}'s javadoc for more information.
+   *
+   * <p>SHUTDOWN can only happen in two cases.  One is that LoadBalancer called {@link
+   * Subchannel#shutdown} earlier, thus it should have already discarded this Subchannel.  The other
+   * is that Channel is doing a {@link ManagedChannel#shutdownNow forced shutdown} or has already
+   * terminated, thus there won't be further requests to LoadBalancer.  Therefore, the LoadBalancer
+   * usually don't need to react to a SHUTDOWN state.
+   *
+   * @param subchannel the involved Subchannel
+   * @param stateInfo the new state
+   * @since 1.2.0
+   * @deprecated This method will be removed.  Stop overriding it.  Instead, pass {@link
+   *             SubchannelStateListener} to {@link Subchannel#start} to receive Subchannel state
+   *             updates
+   */
+  @Deprecated
+  public void handleSubchannelState(
+      Subchannel subchannel, ConnectivityStateInfo stateInfo) {
+    // Do nothing.  If the implementation doesn't implement this, it will get subchannel states from
+    // the new API.  We don't throw because there may be forwarding LoadBalancers still plumb this.
+  }
+
+  /**
+   * The channel asks the load-balancer to shutdown.  No more methods on this class will be called
+   * after this method.  The implementation should shutdown all Subchannels and OOB channels, and do
+   * any other cleanup as necessary.
+   *
+   * @since 1.2.0
+   */
+  public abstract void shutdown();
+
+  /**
+   * Whether this LoadBalancer can handle empty address group list to be passed to {@link
+   * #handleResolvedAddresses(ResolvedAddresses)}.  The default implementation returns
+   * {@code false}, meaning that if the NameResolver returns an empty list, the Channel will turn
+   * that into an error and call {@link #handleNameResolutionError}.  LoadBalancers that want to
+   * accept empty lists should override this method and return {@code true}.
+   *
+   * <p>This method should always return a constant value.  It's not specified when this will be
+   * called.
+   */
+  public boolean canHandleEmptyAddressListFromNameResolution() {
+    return false;
+  }
+
+  /**
+   * The channel asks the LoadBalancer to establish connections now (if applicable) so that the
+   * upcoming RPC may then just pick a ready connection without waiting for connections.  This
+   * is triggered by {@link ManagedChannel#getState ManagedChannel.getState(true)}.
+   *
+   * <p>If LoadBalancer doesn't override it, this is no-op.  If it infeasible to create connections
+   * given the current state, e.g. no Subchannel has been created yet, LoadBalancer can ignore this
+   * request.
+   *
+   * @since 1.22.0
+   */
+  public void requestConnection() {}
+
+  /**
+   * The main balancing logic.  It <strong>must be thread-safe</strong>. Typically it should only
+   * synchronize on its own state, and avoid synchronizing with the LoadBalancer's state.
+   *
+   * @since 1.2.0
+   */
+  @ThreadSafe
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+  public abstract static class SubchannelPicker {
+    /**
+     * Make a balancing decision for a new RPC.
+     *
+     * @param args the pick arguments
+     * @since 1.3.0
+     */
+    public abstract PickResult pickSubchannel(PickSubchannelArgs args);
+  }
+
+  /**
+   * Provides arguments for a {@link SubchannelPicker#pickSubchannel(
+   * LoadBalancer.PickSubchannelArgs)}.
+   *
+   * @since 1.2.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+  public abstract static class PickSubchannelArgs {
+
+    /**
+     * Call options.
+     *
+     * @since 1.2.0
+     */
+    public abstract CallOptions getCallOptions();
+
+    /**
+     * Headers of the call. {@link SubchannelPicker#pickSubchannel} may mutate it before before
+     * returning.
+     *
+     * @since 1.2.0
+     */
+    public abstract Metadata getHeaders();
+
+    /**
+     * Call method.
+     *
+     * @since 1.2.0
+     */
+    public abstract MethodDescriptor<?, ?> getMethodDescriptor();
+
+    /**
+     * Gets an object that can be informed about what sort of pick was made.
+     */
+    @Internal
+    public PickDetailsConsumer getPickDetailsConsumer() {
+      return new PickDetailsConsumer() {};
+    }
+  }
+
+  /** Receives information about the pick being chosen. */
+  @Internal
+  public interface PickDetailsConsumer {
+    /**
+     * Optional labels that provide context of how the pick was routed. Particularly helpful for
+     * per-RPC metrics.
+     *
+     * @throws NullPointerException if key or value is {@code null}
+     */
+    default void addOptionalLabel(String key, String value) {
+      checkNotNull(key, "key");
+      checkNotNull(value, "value");
+    }
+  }
+
+  /**
+   * A balancing decision made by {@link SubchannelPicker SubchannelPicker} for an RPC.
+   *
+   * <p>The outcome of the decision will be one of the following:
+   * <ul>
+   *   <li>Proceed: if a Subchannel is provided via {@link #withSubchannel withSubchannel()}, and is
+   *       in READY state when the RPC tries to start on it, the RPC will proceed on that
+   *       Subchannel.</li>
+   *   <li>Error: if an error is provided via {@link #withError withError()}, and the RPC is not
+   *       wait-for-ready (i.e., {@link CallOptions#withWaitForReady} was not called), the RPC will
+   *       fail immediately with the given error.</li>
+   *   <li>Buffer: in all other cases, the RPC will be buffered in the Channel, until the next
+   *       picker is provided via {@link Helper#updateBalancingState Helper.updateBalancingState()},
+   *       when the RPC will go through the same picking process again.</li>
+   * </ul>
+   *
+   * @since 1.2.0
+   */
+  @Immutable
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+  public static final class PickResult {
+    private static final PickResult NO_RESULT = new PickResult(null, null, Status.OK, false);
+
+    @Nullable private final Subchannel subchannel;
+    @Nullable private final ClientStreamTracer.Factory streamTracerFactory;
+    // An error to be propagated to the application if subchannel == null
+    // Or OK if there is no error.
+    // subchannel being null and error being OK means RPC needs to wait
+    private final Status status;
+    // True if the result is created by withDrop()
+    private final boolean drop;
+    @Nullable private final String authorityOverride;
+
+    private PickResult(
+        @Nullable Subchannel subchannel, @Nullable ClientStreamTracer.Factory streamTracerFactory,
+        Status status, boolean drop) {
+      this.subchannel = subchannel;
+      this.streamTracerFactory = streamTracerFactory;
+      this.status = checkNotNull(status, "status");
+      this.drop = drop;
+      this.authorityOverride = null;
+    }
+
+    private PickResult(
+        @Nullable Subchannel subchannel, @Nullable ClientStreamTracer.Factory streamTracerFactory,
+        Status status, boolean drop, @Nullable String authorityOverride) {
+      this.subchannel = subchannel;
+      this.streamTracerFactory = streamTracerFactory;
+      this.status = checkNotNull(status, "status");
+      this.drop = drop;
+      this.authorityOverride = authorityOverride;
+    }
+
+    /**
+     * A decision to proceed the RPC on a Subchannel.
+     *
+     * <p>The Subchannel should either be an original Subchannel returned by {@link
+     * Helper#createSubchannel Helper.createSubchannel()}, or a wrapper of it preferably based on
+     * {@code ForwardingSubchannel}.  At the very least its {@link Subchannel#getInternalSubchannel
+     * getInternalSubchannel()} must return the same object as the one returned by the original.
+     * Otherwise the Channel cannot use it for the RPC.
+     *
+     * <p>When the RPC tries to use the return Subchannel, which is briefly after this method
+     * returns, the state of the Subchannel will decide where the RPC would go:
+     *
+     * <ul>
+     *   <li>READY: the RPC will proceed on this Subchannel.</li>
+     *   <li>IDLE: the RPC will be buffered.  Subchannel will attempt to create connection.</li>
+     *   <li>All other states: the RPC will be buffered.</li>
+     * </ul>
+     *
+     * <p><strong>All buffered RPCs will stay buffered</strong> until the next call of {@link
+     * Helper#updateBalancingState Helper.updateBalancingState()}, which will trigger a new picking
+     * process.
+     *
+     * <p>Note that Subchannel's state may change at the same time the picker is making the
+     * decision, which means the decision may be made with (to-be) outdated information.  For
+     * example, a picker may return a Subchannel known to be READY, but it has become IDLE when is
+     * about to be used by the RPC, which makes the RPC to be buffered.  The LoadBalancer will soon
+     * learn about the Subchannels' transition from READY to IDLE, create a new picker and allow the
+     * RPC to use another READY transport if there is any.
+     *
+     * <p>You will want to avoid running into a situation where there are READY Subchannels out
+     * there but some RPCs are still buffered for longer than a brief time.
+     * <ul>
+     *   <li>This can happen if you return Subchannels with states other than READY and IDLE.  For
+     *       example, suppose you round-robin on 2 Subchannels, in READY and CONNECTING states
+     *       respectively.  If the picker ignores the state and pick them equally, 50% of RPCs will
+     *       be stuck in buffered state until both Subchannels are READY.</li>
+     *   <li>This can also happen if you don't create a new picker at key state changes of
+     *       Subchannels.  Take the above round-robin example again.  Suppose you do pick only READY
+     *       and IDLE Subchannels, and initially both Subchannels are READY.  Now one becomes IDLE,
+     *       then CONNECTING and stays CONNECTING for a long time.  If you don't create a new picker
+     *       in response to the CONNECTING state to exclude that Subchannel, 50% of RPCs will hit it
+     *       and be buffered even though the other Subchannel is READY.</li>
+     * </ul>
+     *
+     * <p>In order to prevent unnecessary delay of RPCs, the rules of thumb are:
+     * <ol>
+     *   <li>The picker should only pick Subchannels that are known as READY or IDLE.  Whether to
+     *       pick IDLE Subchannels depends on whether you want Subchannels to connect on-demand or
+     *       actively:
+     *       <ul>
+     *         <li>If you want connect-on-demand, include IDLE Subchannels in your pick results,
+     *             because when an RPC tries to use an IDLE Subchannel, the Subchannel will try to
+     *             connect.</li>
+     *         <li>If you want Subchannels to be always connected even when there is no RPC, you
+     *             would call {@link Subchannel#requestConnection Subchannel.requestConnection()}
+     *             whenever the Subchannel has transitioned to IDLE, then you don't need to include
+     *             IDLE Subchannels in your pick results.</li>
+     *       </ul></li>
+     *   <li>Always create a new picker and call {@link Helper#updateBalancingState
+     *       Helper.updateBalancingState()} whenever {@link #handleSubchannelState
+     *       handleSubchannelState()} is called, unless the new state is SHUTDOWN. See
+     *       {@code handleSubchannelState}'s javadoc for more details.</li>
+     * </ol>
+     *
+     * @param subchannel the picked Subchannel.  It must have been {@link Subchannel#start started}
+     * @param streamTracerFactory if not null, will be used to trace the activities of the stream
+     *                            created as a result of this pick. Note it's possible that no
+     *                            stream is created at all in some cases.
+     * @since 1.3.0
+     */
+    public static PickResult withSubchannel(
+        Subchannel subchannel, @Nullable ClientStreamTracer.Factory streamTracerFactory) {
+      return new PickResult(
+          checkNotNull(subchannel, "subchannel"), streamTracerFactory, Status.OK,
+          false);
+    }
+
+    /**
+     * Same as {@code withSubchannel(subchannel, streamTracerFactory)} but with an authority name
+     * to override in the host header.
+     */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11656")
+    public static PickResult withSubchannel(
+        Subchannel subchannel, @Nullable ClientStreamTracer.Factory streamTracerFactory,
+        @Nullable String authorityOverride) {
+      return new PickResult(
+          checkNotNull(subchannel, "subchannel"), streamTracerFactory, Status.OK,
+          false, authorityOverride);
+    }
+
+    /**
+     * Equivalent to {@code withSubchannel(subchannel, null)}.
+     *
+     * @since 1.2.0
+     */
+    public static PickResult withSubchannel(Subchannel subchannel) {
+      return withSubchannel(subchannel, null);
+    }
+
+    /**
+     * A decision to report a connectivity error to the RPC.  If the RPC is {@link
+     * CallOptions#withWaitForReady wait-for-ready}, it will stay buffered.  Otherwise, it will fail
+     * with the given error.
+     *
+     * @param error the error status.  Must not be OK.
+     * @since 1.2.0
+     */
+    public static PickResult withError(Status error) {
+      Preconditions.checkArgument(!error.isOk(), "error status shouldn't be OK");
+      return new PickResult(null, null, error, false);
+    }
+
+    /**
+     * A decision to fail an RPC immediately.  This is a final decision and will ignore retry
+     * policy.
+     *
+     * @param status the status with which the RPC will fail.  Must not be OK.
+     * @since 1.8.0
+     */
+    public static PickResult withDrop(Status status) {
+      Preconditions.checkArgument(!status.isOk(), "drop status shouldn't be OK");
+      return new PickResult(null, null, status, true);
+    }
+
+    /**
+     * No decision could be made.  The RPC will stay buffered.
+     *
+     * @since 1.2.0
+     */
+    public static PickResult withNoResult() {
+      return NO_RESULT;
+    }
+
+    /** Returns the authority override if any. */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11656")
+    @Nullable
+    public String getAuthorityOverride() {
+      return authorityOverride;
+    }
+
+    /**
+     * The Subchannel if this result was created by {@link #withSubchannel withSubchannel()}, or
+     * null otherwise.
+     *
+     * @since 1.2.0
+     */
+    @Nullable
+    public Subchannel getSubchannel() {
+      return subchannel;
+    }
+
+    /**
+     * The stream tracer factory this result was created with.
+     *
+     * @since 1.3.0
+     */
+    @Nullable
+    public ClientStreamTracer.Factory getStreamTracerFactory() {
+      return streamTracerFactory;
+    }
+
+    /**
+     * The status associated with this result.  Non-{@code OK} if created with {@link #withError
+     * withError}, or {@code OK} otherwise.
+     *
+     * @since 1.2.0
+     */
+    public Status getStatus() {
+      return status;
+    }
+
+    /**
+     * Returns {@code true} if this result was created by {@link #withDrop withDrop()}.
+     *
+     * @since 1.8.0
+     */
+    public boolean isDrop() {
+      return drop;
+    }
+
+    /**
+     * Returns {@code true} if the pick was not created with {@link #withNoResult()}.
+     */
+    public boolean hasResult() {
+      return !(subchannel == null && status.isOk());
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("subchannel", subchannel)
+          .add("streamTracerFactory", streamTracerFactory)
+          .add("status", status)
+          .add("drop", drop)
+          .add("authority-override", authorityOverride)
+          .toString();
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(subchannel, status, streamTracerFactory, drop);
+    }
+
+    /**
+     * Returns true if the {@link Subchannel}, {@link Status}, and
+     * {@link ClientStreamTracer.Factory} all match.
+     */
+    @Override
+    public boolean equals(Object other) {
+      if (!(other instanceof PickResult)) {
+        return false;
+      }
+      PickResult that = (PickResult) other;
+      return Objects.equal(subchannel, that.subchannel) && Objects.equal(status, that.status)
+          && Objects.equal(streamTracerFactory, that.streamTracerFactory)
+          && drop == that.drop;
+    }
+  }
+
+  /**
+   * Arguments for creating a {@link Subchannel}.
+   *
+   * @since 1.22.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+  public static final class CreateSubchannelArgs {
+    private final List<EquivalentAddressGroup> addrs;
+    private final Attributes attrs;
+    private final Object[][] customOptions;
+
+    private CreateSubchannelArgs(
+        List<EquivalentAddressGroup> addrs, Attributes attrs, Object[][] customOptions) {
+      this.addrs = checkNotNull(addrs, "addresses are not set");
+      this.attrs = checkNotNull(attrs, "attrs");
+      this.customOptions = checkNotNull(customOptions, "customOptions");
+    }
+
+    /**
+     * Returns the addresses, which is an unmodifiable list.
+     */
+    public List<EquivalentAddressGroup> getAddresses() {
+      return addrs;
+    }
+
+    /**
+     * Returns the attributes.
+     */
+    public Attributes getAttributes() {
+      return attrs;
+    }
+
+    /**
+     * Get the value for a custom option or its inherent default.
+     *
+     * @param key Key identifying option
+     */
+    @SuppressWarnings("unchecked")
+    public <T> T getOption(Key<T> key) {
+      Preconditions.checkNotNull(key, "key");
+      for (int i = 0; i < customOptions.length; i++) {
+        if (key.equals(customOptions[i][0])) {
+          return (T) customOptions[i][1];
+        }
+      }
+      return key.defaultValue;
+    }
+
+    /**
+     * Returns a builder with the same initial values as this object.
+     */
+    public Builder toBuilder() {
+      return newBuilder().setAddresses(addrs).setAttributes(attrs).copyCustomOptions(customOptions);
+    }
+
+    /**
+     * Creates a new builder.
+     */
+    public static Builder newBuilder() {
+      return new Builder();
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("addrs", addrs)
+          .add("attrs", attrs)
+          .add("customOptions", Arrays.deepToString(customOptions))
+          .toString();
+    }
+
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+    public static final class Builder {
+
+      private static final Object[][] EMPTY_CUSTOM_OPTIONS = new Object[0][2];
+
+      private List<EquivalentAddressGroup> addrs;
+      private Attributes attrs = Attributes.EMPTY;
+      private Object[][] customOptions = EMPTY_CUSTOM_OPTIONS;
+
+      Builder() {
+      }
+
+      private Builder copyCustomOptions(Object[][] options) {
+        customOptions = new Object[options.length][2];
+        System.arraycopy(options, 0, customOptions, 0, options.length);
+        return this;
+      }
+
+      /**
+       * Add a custom option. Any existing value for the key is overwritten.
+       *
+       * <p>This is an <strong>optional</strong> property.
+       *
+       * @param key the option key
+       * @param value the option value
+       */
+      public <T> Builder addOption(Key<T> key, T value) {
+        Preconditions.checkNotNull(key, "key");
+        Preconditions.checkNotNull(value, "value");
+
+        int existingIdx = -1;
+        for (int i = 0; i < customOptions.length; i++) {
+          if (key.equals(customOptions[i][0])) {
+            existingIdx = i;
+            break;
+          }
+        }
+
+        if (existingIdx == -1) {
+          Object[][] newCustomOptions = new Object[customOptions.length + 1][2];
+          System.arraycopy(customOptions, 0, newCustomOptions, 0, customOptions.length);
+          customOptions = newCustomOptions;
+          existingIdx = customOptions.length - 1;
+        }
+        customOptions[existingIdx] = new Object[]{key, value};
+        return this;
+      }
+
+      /**
+       * The addresses to connect to.  All addresses are considered equivalent and will be tried
+       * in the order they are provided.
+       */
+      public Builder setAddresses(EquivalentAddressGroup addrs) {
+        this.addrs = Collections.singletonList(addrs);
+        return this;
+      }
+
+      /**
+       * The addresses to connect to.  All addresses are considered equivalent and will
+       * be tried in the order they are provided.
+       *
+       * <p>This is a <strong>required</strong> property.
+       *
+       * @throws IllegalArgumentException if {@code addrs} is empty
+       */
+      public Builder setAddresses(List<EquivalentAddressGroup> addrs) {
+        checkArgument(!addrs.isEmpty(), "addrs is empty");
+        this.addrs = Collections.unmodifiableList(new ArrayList<>(addrs));
+        return this;
+      }
+
+      /**
+       * Attributes provided here will be included in {@link Subchannel#getAttributes}.
+       *
+       * <p>This is an <strong>optional</strong> property.  Default is empty if not set.
+       */
+      public Builder setAttributes(Attributes attrs) {
+        this.attrs = checkNotNull(attrs, "attrs");
+        return this;
+      }
+
+      /**
+       * Creates a new args object.
+       */
+      public CreateSubchannelArgs build() {
+        return new CreateSubchannelArgs(addrs, attrs, customOptions);
+      }
+    }
+
+    /**
+     * Key for a key-value pair. Uses reference equality.
+     */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+    public static final class Key<T> {
+
+      private final String debugString;
+      private final T defaultValue;
+
+      private Key(String debugString, T defaultValue) {
+        this.debugString = debugString;
+        this.defaultValue = defaultValue;
+      }
+
+      /**
+       * Factory method for creating instances of {@link Key}. The default value of the key is
+       * {@code null}.
+       *
+       * @param debugString a debug string that describes this key.
+       * @param <T> Key type
+       * @return Key object
+       */
+      public static <T> Key<T> create(String debugString) {
+        Preconditions.checkNotNull(debugString, "debugString");
+        return new Key<>(debugString, /*defaultValue=*/ null);
+      }
+
+      /**
+       * Factory method for creating instances of {@link Key}.
+       *
+       * @param debugString a debug string that describes this key.
+       * @param defaultValue default value to return when value for key not set
+       * @param <T> Key type
+       * @return Key object
+       */
+      public static <T> Key<T> createWithDefault(String debugString, T defaultValue) {
+        Preconditions.checkNotNull(debugString, "debugString");
+        return new Key<>(debugString, defaultValue);
+      }
+
+      /**
+       * Returns the user supplied default value for this key.
+       */
+      public T getDefault() {
+        return defaultValue;
+      }
+
+      @Override
+      public String toString() {
+        return debugString;
+      }
+    }
+  }
+
+  /**
+   * Provides essentials for LoadBalancer implementations.
+   *
+   * @since 1.2.0
+   */
+  @ThreadSafe
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+  public abstract static class Helper {
+    /**
+     * Creates a Subchannel, which is a logical connection to the given group of addresses which are
+     * considered equivalent.  The {@code attrs} are custom attributes associated with this
+     * Subchannel, and can be accessed later through {@link Subchannel#getAttributes
+     * Subchannel.getAttributes()}.
+     *
+     * <p>The LoadBalancer is responsible for closing unused Subchannels, and closing all
+     * Subchannels within {@link #shutdown}.
+     *
+     * <p>It must be called from {@link #getSynchronizationContext the Synchronization Context}
+     *
+     * @return Must return a valid Subchannel object, may not return null.
+     *
+     * @since 1.22.0
+     */
+    public Subchannel createSubchannel(CreateSubchannelArgs args) {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Create an out-of-band channel for the LoadBalancer’s own RPC needs, e.g., talking to an
+     * external load-balancer service.
+     *
+     * <p>The LoadBalancer is responsible for closing unused OOB channels, and closing all OOB
+     * channels within {@link #shutdown}.
+     *
+     * @since 1.4.0
+     */
+    public abstract ManagedChannel createOobChannel(EquivalentAddressGroup eag, String authority);
+
+    /**
+     * Create an out-of-band channel for the LoadBalancer's own RPC needs, e.g., talking to an
+     * external load-balancer service. This version of the method allows multiple EAGs, so different
+     * addresses can have different authorities.
+     *
+     * <p>The LoadBalancer is responsible for closing unused OOB channels, and closing all OOB
+     * channels within {@link #shutdown}.
+     * */
+    public ManagedChannel createOobChannel(List<EquivalentAddressGroup> eag,
+        String authority) {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Updates the addresses used for connections in the {@code Channel} that was created by {@link
+     * #createOobChannel(EquivalentAddressGroup, String)}. This is superior to {@link
+     * #createOobChannel(EquivalentAddressGroup, String)} when the old and new addresses overlap,
+     * since the channel can continue using an existing connection.
+     *
+     * @throws IllegalArgumentException if {@code channel} was not returned from {@link
+     *     #createOobChannel}
+     * @since 1.4.0
+     */
+    public void updateOobChannelAddresses(ManagedChannel channel, EquivalentAddressGroup eag) {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Updates the addresses with a new EAG list. Connection is continued when old and new addresses
+     * overlap.
+     * */
+    public void updateOobChannelAddresses(ManagedChannel channel,
+        List<EquivalentAddressGroup> eag) {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Creates an out-of-band channel for LoadBalancer's own RPC needs, e.g., talking to an external
+     * load-balancer service, that is specified by a target string.  See the documentation on
+     * {@link ManagedChannelBuilder#forTarget} for the format of a target string.
+     *
+     * <p>The target string will be resolved by a {@link NameResolver} created according to the
+     * target string.
+     *
+     * <p>The LoadBalancer is responsible for closing unused OOB channels, and closing all OOB
+     * channels within {@link #shutdown}.
+     *
+     * @since 1.20.0
+     */
+    public ManagedChannel createResolvingOobChannel(String target) {
+      return createResolvingOobChannelBuilder(target).build();
+    }
+
+    /**
+     * Creates an out-of-band channel builder for LoadBalancer's own RPC needs, e.g., talking to an
+     * external load-balancer service, that is specified by a target string.  See the documentation
+     * on {@link ManagedChannelBuilder#forTarget} for the format of a target string.
+     *
+     * <p>The target string will be resolved by a {@link NameResolver} created according to the
+     * target string.
+     *
+     * <p>The returned oob-channel builder defaults to use the same authority and ChannelCredentials
+     * (without bearer tokens) as the parent channel's for authentication. This is different from
+     * {@link #createResolvingOobChannelBuilder(String, ChannelCredentials)}.
+     *
+     * <p>The LoadBalancer is responsible for closing unused OOB channels, and closing all OOB
+     * channels within {@link #shutdown}.
+     *
+     * @deprecated Use {@link #createResolvingOobChannelBuilder(String, ChannelCredentials)}
+     *     instead.
+     * @since 1.31.0
+     */
+    @Deprecated
+    public ManagedChannelBuilder<?> createResolvingOobChannelBuilder(String target) {
+      throw new UnsupportedOperationException("Not implemented");
+    }
+
+    /**
+     * Creates an out-of-band channel builder for LoadBalancer's own RPC needs, e.g., talking to an
+     * external load-balancer service, that is specified by a target string and credentials.  See
+     * the documentation on {@link Grpc#newChannelBuilder} for the format of a target string.
+     *
+     * <p>The target string will be resolved by a {@link NameResolver} created according to the
+     * target string.
+     *
+     * <p>The LoadBalancer is responsible for closing unused OOB channels, and closing all OOB
+     * channels within {@link #shutdown}.
+     *
+     * @since 1.35.0
+     */
+    public ManagedChannelBuilder<?> createResolvingOobChannelBuilder(
+        String target, ChannelCredentials creds) {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Set a new state with a new picker to the channel.
+     *
+     * <p>When a new picker is provided via {@code updateBalancingState()}, the channel will apply
+     * the picker on all buffered RPCs, by calling {@link SubchannelPicker#pickSubchannel(
+     * LoadBalancer.PickSubchannelArgs)}.
+     *
+     * <p>The channel will hold the picker and use it for all RPCs, until {@code
+     * updateBalancingState()} is called again and a new picker replaces the old one.  If {@code
+     * updateBalancingState()} has never been called, the channel will buffer all RPCs until a
+     * picker is provided.
+     *
+     * <p>It should be called from the Synchronization Context.  Currently will log a warning if
+     * violated.  It will become an exception eventually.  See <a
+     * href="https://github.com/grpc/grpc-java/issues/5015">#5015</a> for the background.
+     *
+     * <p>The passed state will be the channel's new state. The SHUTDOWN state should not be passed
+     * and its behavior is undefined.
+     *
+     * @since 1.6.0
+     */
+    public abstract void updateBalancingState(
+        @Nonnull ConnectivityState newState, @Nonnull SubchannelPicker newPicker);
+
+    /**
+     * Call {@link NameResolver#refresh} on the channel's resolver.
+     *
+     * <p>It should be called from the Synchronization Context.  Currently will log a warning if
+     * violated.  It will become an exception eventually.  See <a
+     * href="https://github.com/grpc/grpc-java/issues/5015">#5015</a> for the background.
+     *
+     * @since 1.18.0
+     */
+    public void refreshNameResolution() {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Historically the channel automatically refreshes name resolution if any subchannel
+     * connection is broken. It's transitioning to let load balancers make the decision. To
+     * avoid silent breakages, the channel checks if {@link #refreshNameResolution} is called
+     * by the load balancer. If not, it will do it and log a warning. This will be removed in
+     * the future and load balancers are completely responsible for triggering the refresh.
+     * See <a href="https://github.com/grpc/grpc-java/issues/8088">#8088</a> for the background.
+     *
+     * <p>This should rarely be used, but sometimes the address for the subchannel wasn't
+     * provided by the name resolver and a refresh needs to be directed somewhere else instead.
+     * Then you can call this method to disable the short-tem check for detecting LoadBalancers
+     * that need to be updated for the new expected behavior.
+     *
+     * @since 1.38.0
+     * @deprecated Warning has been removed
+     */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8088")
+    @Deprecated
+    public void ignoreRefreshNameResolutionCheck() {
+      // no-op
+    }
+
+    /**
+     * Returns a {@link SynchronizationContext} that runs tasks in the same Synchronization Context
+     * as that the callback methods on the {@link LoadBalancer} interface are run in.
+     *
+     * <p>Work added to the synchronization context might not run immediately, so LB implementations
+     * must be careful to ensure that any assumptions still hold when it is executed. In particular,
+     * the LB might have been shut down or subchannels might have changed state.
+     *
+     * <p>Pro-tip: in order to call {@link SynchronizationContext#schedule}, you need to provide a
+     * {@link ScheduledExecutorService}.  {@link #getScheduledExecutorService} is provided for your
+     * convenience.
+     *
+     * @since 1.17.0
+     */
+    public SynchronizationContext getSynchronizationContext() {
+      // TODO(zhangkun): make getSynchronizationContext() abstract after runSerialized() is deleted
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Returns a {@link ScheduledExecutorService} for scheduling delayed tasks.
+     *
+     * <p>This service is a shared resource and is only meant for quick tasks.  DO NOT block or run
+     * time-consuming tasks.
+     *
+     * <p>The returned service doesn't support {@link ScheduledExecutorService#shutdown shutdown()}
+     * and {@link ScheduledExecutorService#shutdownNow shutdownNow()}.  They will throw if called.
+     *
+     * @since 1.17.0
+     */
+    public ScheduledExecutorService getScheduledExecutorService() {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Returns the authority string of the channel, which is derived from the DNS-style target name.
+     * If overridden by a load balancer, {@link #getUnsafeChannelCredentials} must also be
+     * overridden to call {@link #getChannelCredentials} or provide appropriate credentials.
+     *
+     * @since 1.2.0
+     */
+    public abstract String getAuthority();
+
+    /**
+     * Returns the target string of the channel, guaranteed to include its scheme.
+     */
+    public String getChannelTarget() {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Returns the ChannelCredentials used to construct the channel, without bearer tokens.
+     *
+     * @since 1.35.0
+     */
+    public ChannelCredentials getChannelCredentials() {
+      return getUnsafeChannelCredentials().withoutBearerTokens();
+    }
+
+    /**
+     * Returns the UNSAFE ChannelCredentials used to construct the channel,
+     * including bearer tokens. Load balancers should generally have no use for
+     * these credentials and use of them is heavily discouraged. These must be used
+     * <em>very</em> carefully to avoid sending bearer tokens to untrusted servers
+     * as the server could then impersonate the client. Generally it is only safe
+     * to use these credentials when communicating with the backend.
+     *
+     * @since 1.35.0
+     */
+    public ChannelCredentials getUnsafeChannelCredentials() {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Returns the {@link ChannelLogger} for the Channel served by this LoadBalancer.
+     *
+     * @since 1.17.0
+     */
+    public ChannelLogger getChannelLogger() {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Returns the {@link NameResolver.Args} that the Channel uses to create {@link NameResolver}s.
+     *
+     * @since 1.22.0
+     */
+    public NameResolver.Args getNameResolverArgs() {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Returns the {@link NameResolverRegistry} that the Channel uses to look for {@link
+     * NameResolver}s.
+     *
+     * @since 1.22.0
+     */
+    public NameResolverRegistry getNameResolverRegistry() {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Returns the {@link MetricRecorder} that the channel uses to record metrics.
+     *
+     * @since 1.64.0
+     */
+    @Internal
+    public MetricRecorder getMetricRecorder() {
+      return new MetricRecorder() {};
+    }
+  }
+
+  /**
+   * A logical connection to a server, or a group of equivalent servers represented by an {@link 
+   * EquivalentAddressGroup}.
+   *
+   * <p>It maintains at most one physical connection (aka transport) for sending new RPCs, while
+   * also keeps track of previous transports that has been shut down but not terminated yet.
+   *
+   * <p>If there isn't an active transport yet, and an RPC is assigned to the Subchannel, it will
+   * create a new transport.  It won't actively create transports otherwise.  {@link
+   * #requestConnection requestConnection()} can be used to ask Subchannel to create a transport if
+   * there isn't any.
+   *
+   * <p>{@link #start} must be called prior to calling any other methods, with the exception of
+   * {@link #shutdown}, which can be called at any time.
+   *
+   * @since 1.2.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+  public abstract static class Subchannel {
+    /**
+     * Starts the Subchannel.  Can only be called once.
+     *
+     * <p>Must be called prior to any other method on this class, except for {@link #shutdown} which
+     * may be called at any time.
+     *
+     * <p>Must be called from the {@link Helper#getSynchronizationContext Synchronization Context},
+     * otherwise it may throw.  See <a href="https://github.com/grpc/grpc-java/issues/5015">
+     * #5015</a> for more discussions.
+     *
+     * @param listener receives state updates for this Subchannel.
+     */
+    public void start(SubchannelStateListener listener) {
+      throw new UnsupportedOperationException("Not implemented");
+    }
+
+    /**
+     * Shuts down the Subchannel.  After this method is called, this Subchannel should no longer
+     * be returned by the latest {@link SubchannelPicker picker}, and can be safely discarded.
+     *
+     * <p>Calling it on an already shut-down Subchannel has no effect.
+     *
+     * <p>It should be called from the Synchronization Context.  Currently will log a warning if
+     * violated.  It will become an exception eventually.  See <a
+     * href="https://github.com/grpc/grpc-java/issues/5015">#5015</a> for the background.
+     *
+     * @since 1.2.0
+     */
+    public abstract void shutdown();
+
+    /**
+     * Asks the Subchannel to create a connection (aka transport), if there isn't an active one.
+     *
+     * <p>It should be called from the Synchronization Context.  Currently will log a warning if
+     * violated.  It will become an exception eventually.  See <a
+     * href="https://github.com/grpc/grpc-java/issues/5015">#5015</a> for the background.
+     *
+     * @since 1.2.0
+     */
+    public abstract void requestConnection();
+
+    /**
+     * Returns the addresses that this Subchannel is bound to.  This can be called only if
+     * the Subchannel has only one {@link EquivalentAddressGroup}.  Under the hood it calls
+     * {@link #getAllAddresses}.
+     *
+     * <p>It should be called from the Synchronization Context.  Currently will log a warning if
+     * violated.  It will become an exception eventually.  See <a
+     * href="https://github.com/grpc/grpc-java/issues/5015">#5015</a> for the background.
+     *
+     * @throws IllegalStateException if this subchannel has more than one EquivalentAddressGroup.
+     *         Use {@link #getAllAddresses} instead
+     * @since 1.2.0
+     */
+    public final EquivalentAddressGroup getAddresses() {
+      List<EquivalentAddressGroup> groups = getAllAddresses();
+      Preconditions.checkState(groups != null && groups.size() == 1,
+          "%s does not have exactly one group", groups);
+      return groups.get(0);
+    }
+
+    /**
+     * Returns the addresses that this Subchannel is bound to. The returned list will not be empty.
+     *
+     * <p>It should be called from the Synchronization Context.  Currently will log a warning if
+     * violated.  It will become an exception eventually.  See <a
+     * href="https://github.com/grpc/grpc-java/issues/5015">#5015</a> for the background.
+     *
+     * @since 1.14.0
+     */
+    public List<EquivalentAddressGroup> getAllAddresses() {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * The same attributes passed to {@link Helper#createSubchannel Helper.createSubchannel()}.
+     * LoadBalancer can use it to attach additional information here, e.g., the shard this
+     * Subchannel belongs to.
+     *
+     * @since 1.2.0
+     */
+    public abstract Attributes getAttributes();
+
+    /**
+     * (Internal use only) returns a {@link Channel} that is backed by this Subchannel.  This allows
+     * a LoadBalancer to issue its own RPCs for auxiliary purposes, such as health-checking, on
+     * already-established connections.  This channel has certain restrictions:
+     * <ol>
+     *   <li>It can issue RPCs only if the Subchannel is {@code READY}. If {@link
+     *   Channel#newCall} is called when the Subchannel is not {@code READY}, the RPC will fail
+     *   immediately.</li>
+     *   <li>It doesn't support {@link CallOptions#withWaitForReady wait-for-ready} RPCs. Such RPCs
+     *   will fail immediately.</li>
+     * </ol>
+     *
+     * <p>RPCs made on this Channel is not counted when determining ManagedChannel's {@link
+     * ManagedChannelBuilder#idleTimeout idle mode}.  In other words, they won't prevent
+     * ManagedChannel from entering idle mode.
+     *
+     * <p>Warning: RPCs made on this channel will prevent a shut-down transport from terminating. If
+     * you make long-running RPCs, you need to make sure they will finish in time after the
+     * Subchannel has transitioned away from {@code READY} state
+     * (notified through {@link #handleSubchannelState}).
+     *
+     * <p>Warning: this is INTERNAL API, is not supposed to be used by external users, and may
+     * change without notice. If you think you must use it, please file an issue.
+     */
+    @Internal
+    public Channel asChannel() {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Returns a {@link ChannelLogger} for this Subchannel.
+     *
+     * @since 1.17.0
+     */
+    public ChannelLogger getChannelLogger() {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Replaces the existing addresses used with this {@code Subchannel}. If the new and old
+     * addresses overlap, the Subchannel can continue using an existing connection.
+     *
+     * <p>It must be called from the Synchronization Context or will throw.
+     *
+     * @throws IllegalArgumentException if {@code addrs} is empty
+     * @since 1.22.0
+     */
+    public void updateAddresses(List<EquivalentAddressGroup> addrs) {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * (Internal use only) returns an object that represents the underlying subchannel that is used
+     * by the Channel for sending RPCs when this {@link Subchannel} is picked.  This is an opaque
+     * object that is both provided and consumed by the Channel.  Its type <strong>is not</strong>
+     * {@code Subchannel}.
+     *
+     * <p>Warning: this is INTERNAL API, is not supposed to be used by external users, and may
+     * change without notice. If you think you must use it, please file an issue and we can consider
+     * removing its "internal" status.
+     */
+    @Internal
+    public Object getInternalSubchannel() {
+      throw new UnsupportedOperationException();
+    }
+
+    /**
+     * (Internal use only) returns attributes of the address subchannel is connected to.
+     *
+     * <p>Warning: this is INTERNAL API, is not supposed to be used by external users, and may
+     * change without notice. If you think you must use it, please file an issue and we can consider
+     * removing its "internal" status.
+     */
+    @Internal
+    public Attributes getConnectedAddressAttributes() {
+      throw new UnsupportedOperationException();
+    }
+  }
+
+  /**
+   * Receives state changes for one {@link Subchannel}. All methods are run under {@link
+   * Helper#getSynchronizationContext}.
+   *
+   * @since 1.22.0
+   */
+  public interface SubchannelStateListener {
+    /**
+     * Handles a state change on a Subchannel.
+     *
+     * <p>The initial state of a Subchannel is IDLE. You won't get a notification for the initial
+     * IDLE state.
+     *
+     * <p>If the new state is not SHUTDOWN, this method should create a new picker and call {@link
+     * Helper#updateBalancingState Helper.updateBalancingState()}.  Failing to do so may result in
+     * unnecessary delays of RPCs. Please refer to {@link PickResult#withSubchannel
+     * PickResult.withSubchannel()}'s javadoc for more information.
+     *
+     * <p>When a subchannel's state is IDLE or TRANSIENT_FAILURE and the address for the subchannel
+     * was received in {@link LoadBalancer#handleResolvedAddresses}, load balancers should call
+     * {@link Helper#refreshNameResolution} to inform polling name resolvers that it is an
+     * appropriate time to refresh the addresses. Without the refresh, changes to the addresses may
+     * never be detected.
+     *
+     * <p>SHUTDOWN can only happen in two cases.  One is that LoadBalancer called {@link
+     * Subchannel#shutdown} earlier, thus it should have already discarded this Subchannel.  The
+     * other is that Channel is doing a {@link ManagedChannel#shutdownNow forced shutdown} or has
+     * already terminated, thus there won't be further requests to LoadBalancer.  Therefore, the
+     * LoadBalancer usually don't need to react to a SHUTDOWN state.
+     *
+     * @param newState the new state
+     * @since 1.22.0
+     */
+    void onSubchannelState(ConnectivityStateInfo newState);
+  }
+
+  /**
+   * Factory to create {@link LoadBalancer} instance.
+   *
+   * @since 1.2.0
+   */
+  @ThreadSafe
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+  public abstract static class Factory {
+    /**
+     * Creates a {@link LoadBalancer} that will be used inside a channel.
+     *
+     * @since 1.2.0
+     */
+    public abstract LoadBalancer newLoadBalancer(Helper helper);
+  }
+
+  /**
+   * A picker that always returns an erring pick.
+   *
+   * @deprecated Use {@code new FixedResultPicker(PickResult.withError(error))} instead.
+   */
+  @Deprecated
+  public static final class ErrorPicker extends SubchannelPicker {
+
+    private final Status error;
+
+    public ErrorPicker(Status error) {
+      this.error = checkNotNull(error, "error");
+    }
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      return PickResult.withError(error);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("error", error)
+          .toString();
+    }
+  }
+
+  /** A picker that always returns the same result. */
+  public static final class FixedResultPicker extends SubchannelPicker {
+    private final PickResult result;
+
+    public FixedResultPicker(PickResult result) {
+      this.result = Preconditions.checkNotNull(result, "result");
+    }
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      return result;
+    }
+
+    @Override
+    public String toString() {
+      return "FixedResultPicker(" + result + ")";
+    }
+
+    @Override
+    public int hashCode() {
+      return result.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (!(o instanceof FixedResultPicker)) {
+        return false;
+      }
+      FixedResultPicker that = (FixedResultPicker) o;
+      return this.result.equals(that.result);
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/LoadBalancerProvider.java b/api/src/main/java/io/grpc/LoadBalancerProvider.java
new file mode 100644
index 00000000000..7dc30d6baaf
--- /dev/null
+++ b/api/src/main/java/io/grpc/LoadBalancerProvider.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2018 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;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.NameResolver.ConfigOrError;
+import java.util.Map;
+
+/**
+ * Provider of {@link LoadBalancer}s.  Each provider is bounded to a load-balancing policy name.
+ *
+ * <p>Implementations can be automatically discovered by gRPC via Java's SPI mechanism. For
+ * automatic discovery, the implementation must have a zero-argument constructor and include
+ * a resource named {@code META-INF/services/io.grpc.LoadBalancerProvider} in their JAR. The
+ * file's contents should be the implementation's class name. Implementations that need arguments in
+ * their constructor can be manually registered by {@link LoadBalancerRegistry#register}.
+ *
+ * <p>Implementations <em>should not</em> throw. If they do, it may interrupt class loading. If
+ * exceptions may reasonably occur for implementation-specific reasons, implementations should
+ * generally handle the exception gracefully and return {@code false} from {@link #isAvailable()}.
+ *
+ * @since 1.17.0
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+public abstract class LoadBalancerProvider extends LoadBalancer.Factory {
+
+  /**
+   * A sentinel value indicating that service config is not supported.   This can be used to
+   * indicate that parsing of the service config is neither right nor wrong, but doesn't have
+   * any meaning.
+   */
+  private static final ConfigOrError UNKNOWN_CONFIG = ConfigOrError.fromConfig(new UnknownConfig());
+
+  /**
+   * Whether this provider is available for use, taking the current environment into consideration.
+   * If {@code false}, {@link #newLoadBalancer} is not safe to be called.
+   */
+  public abstract boolean isAvailable();
+
+  /**
+   * A priority, from 0 to 10 that this provider should be used, taking the current environment into
+   * consideration. 5 should be considered the default, and then tweaked based on environment
+   * detection. A priority of 0 does not imply that the provider wouldn't work; just that it should
+   * be last in line.
+   */
+  public abstract int getPriority();
+
+  /**
+   * Returns the load-balancing policy name associated with this provider, which makes it selectable
+   * via {@link LoadBalancerRegistry#getProvider}.  This is called only when the class is loaded. It
+   * shouldn't change, and there is no point doing so.
+   *
+   * <p>The policy name should consist of only lower case letters letters, underscore and digits,
+   * and can only start with letters.
+   */
+  public abstract String getPolicyName();
+
+  /**
+   * Parses the config for the Load Balancing policy unpacked from the service config.  This will
+   * return a {@link ConfigOrError} which contains either the successfully parsed config, or the
+   * {@link Status} representing the failure to parse.  Implementations are expected to not throw
+   * exceptions but return a Status representing the failure.  If successful, the load balancing
+   * policy config should be immutable.
+   *
+   * @param rawLoadBalancingPolicyConfig The {@link Map} representation of the load balancing
+   *     policy choice.
+   * @return a tuple of the fully parsed and validated balancer configuration, else the Status.
+   * @since 1.20.0
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A24-lb-policy-config.md">
+   *     A24-lb-policy-config.md</a>
+   */
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawLoadBalancingPolicyConfig) {
+    return UNKNOWN_CONFIG;
+  }
+
+  @Override
+  public final String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("policy", getPolicyName())
+        .add("priority", getPriority())
+        .add("available", isAvailable())
+        .toString();
+  }
+
+  /**
+   * Uses identity equality.
+   */
+  @Override
+  public final boolean equals(Object other) {
+    return this == other;
+  }
+
+  @Override
+  public final int hashCode() {
+    return super.hashCode();
+  }
+
+  private static final class UnknownConfig {
+
+    UnknownConfig() {}
+
+    @Override
+    public String toString() {
+      return "service config is unused";
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/LoadBalancerRegistry.java b/api/src/main/java/io/grpc/LoadBalancerRegistry.java
new file mode 100644
index 00000000000..f6b69f978b8
--- /dev/null
+++ b/api/src/main/java/io/grpc/LoadBalancerRegistry.java
@@ -0,0 +1,171 @@
+/*
+ * Copyright 2018 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Registry of {@link LoadBalancerProvider}s.  The {@link #getDefaultRegistry default instance}
+ * loads providers at runtime through the Java service provider mechanism.
+ *
+ * @since 1.17.0
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+@ThreadSafe
+public final class LoadBalancerRegistry {
+  private static final Logger logger = Logger.getLogger(LoadBalancerRegistry.class.getName());
+  private static LoadBalancerRegistry instance;
+  private static final Iterable<Class<?>> HARDCODED_CLASSES = getHardCodedClasses();
+
+  private final LinkedHashSet<LoadBalancerProvider> allProviders =
+      new LinkedHashSet<>();
+  private final LinkedHashMap<String, LoadBalancerProvider> effectiveProviders =
+      new LinkedHashMap<>();
+
+  /**
+   * Register a provider.
+   *
+   * <p>If the provider's {@link LoadBalancerProvider#isAvailable isAvailable()} returns
+   * {@code false}, this method will throw {@link IllegalArgumentException}.
+   *
+   * <p>If more than one provider with the same {@link LoadBalancerProvider#getPolicyName policy
+   * name} are registered, the one with the highest {@link LoadBalancerProvider#getPriority
+   * priority} will be effective.  If there are more than one name-sake providers rank the highest
+   * priority, the one registered first will be effective.
+   */
+  public synchronized void register(LoadBalancerProvider provider) {
+    addProvider(provider);
+    refreshProviderMap();
+  }
+
+  private synchronized void addProvider(LoadBalancerProvider provider) {
+    checkArgument(provider.isAvailable(), "isAvailable() returned false");
+    allProviders.add(provider);
+  }
+
+  /**
+   * Deregisters a provider.  No-op if the provider is not in the registry.  If there are more
+   * than one providers with the same policy name as the deregistered one in the registry, one
+   * of them will become the effective provider for that policy, per the rule documented in {@link
+   * #register}.
+   *
+   * @param provider the provider that was added to the register via {@link #register}.
+   */
+  public synchronized void deregister(LoadBalancerProvider provider) {
+    allProviders.remove(provider);
+    refreshProviderMap();
+  }
+
+  private synchronized void refreshProviderMap() {
+    effectiveProviders.clear();
+    for (LoadBalancerProvider provider : allProviders) {
+      String policy = provider.getPolicyName();
+      LoadBalancerProvider existing = effectiveProviders.get(policy);
+      if (existing == null || existing.getPriority() < provider.getPriority()) {
+        effectiveProviders.put(policy, provider);
+      }
+    }
+  }
+
+  /**
+   * Returns the default registry that loads providers via the Java service loader mechanism.
+   */
+  public static synchronized LoadBalancerRegistry getDefaultRegistry() {
+    if (instance == null) {
+      List<LoadBalancerProvider> providerList = ServiceProviders.loadAll(
+          LoadBalancerProvider.class,
+          HARDCODED_CLASSES,
+          LoadBalancerProvider.class.getClassLoader(),
+          new LoadBalancerPriorityAccessor());
+      instance = new LoadBalancerRegistry();
+      for (LoadBalancerProvider provider : providerList) {
+        logger.fine("Service loader found " + provider);
+        instance.addProvider(provider);
+      }
+      instance.refreshProviderMap();
+    }
+    return instance;
+  }
+
+  /**
+   * Returns the effective provider for the given load-balancing policy, or {@code null} if no
+   * suitable provider can be found.  Each provider declares its policy name via {@link
+   * LoadBalancerProvider#getPolicyName}.
+   */
+  @Nullable
+  public synchronized LoadBalancerProvider getProvider(String policy) {
+    return effectiveProviders.get(checkNotNull(policy, "policy"));
+  }
+
+  /**
+   * Returns effective providers in a new map.
+   */
+  @VisibleForTesting
+  synchronized Map<String, LoadBalancerProvider> providers() {
+    return new LinkedHashMap<>(effectiveProviders);
+  }
+
+  @VisibleForTesting
+  static List<Class<?>> getHardCodedClasses() {
+    // Class.forName(String) is used to remove the need for ProGuard configuration. Note that
+    // ProGuard does not detect usages of Class.forName(String, boolean, ClassLoader):
+    // https://sourceforge.net/p/proguard/bugs/418/
+    ArrayList<Class<?>> list = new ArrayList<>();
+    try {
+      list.add(Class.forName("io.grpc.internal.PickFirstLoadBalancerProvider"));
+    } catch (ClassNotFoundException e) {
+      logger.log(Level.WARNING, "Unable to find pick-first LoadBalancer", e);
+    }
+    try {
+      list.add(Class.forName("io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider"));
+    } catch (ClassNotFoundException e) {
+      // Since hard-coded list is only used in Android environment, and we don't expect round-robin
+      // to be actually used there, we log it as a lower level.
+      logger.log(Level.FINE, "Unable to find round-robin LoadBalancer", e);
+    }
+    return Collections.unmodifiableList(list);
+  }
+
+  private static final class LoadBalancerPriorityAccessor
+      implements ServiceProviders.PriorityAccessor<LoadBalancerProvider> {
+
+    LoadBalancerPriorityAccessor() {}
+
+    @Override
+    public boolean isAvailable(LoadBalancerProvider provider) {
+      return provider.isAvailable();
+    }
+
+    @Override
+    public int getPriority(LoadBalancerProvider provider) {
+      return provider.getPriority();
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/LongCounterMetricInstrument.java b/api/src/main/java/io/grpc/LongCounterMetricInstrument.java
new file mode 100644
index 00000000000..73516dfb9e4
--- /dev/null
+++ b/api/src/main/java/io/grpc/LongCounterMetricInstrument.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2024 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;
+
+import java.util.List;
+
+/**
+ * Represents a long-valued counter metric instrument.
+ */
+@Internal
+public final class LongCounterMetricInstrument extends PartialMetricInstrument {
+  public LongCounterMetricInstrument(int index, String name, String description, String unit,
+      List<String> requiredLabelKeys, List<String> optionalLabelKeys, boolean enableByDefault) {
+    super(index, name, description, unit, requiredLabelKeys, optionalLabelKeys, enableByDefault);
+  }
+}
diff --git a/api/src/main/java/io/grpc/LongGaugeMetricInstrument.java b/api/src/main/java/io/grpc/LongGaugeMetricInstrument.java
new file mode 100644
index 00000000000..393bdeb355c
--- /dev/null
+++ b/api/src/main/java/io/grpc/LongGaugeMetricInstrument.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2024 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;
+
+import java.util.List;
+
+/**
+ * Represents a long-valued gauge metric instrument.
+ */
+@Internal
+public final class LongGaugeMetricInstrument extends PartialMetricInstrument
+    implements CallbackMetricInstrument {
+  public LongGaugeMetricInstrument(int index, String name, String description, String unit,
+      List<String> requiredLabelKeys, List<String> optionalLabelKeys, boolean enableByDefault) {
+    super(index, name, description, unit, requiredLabelKeys, optionalLabelKeys, enableByDefault);
+  }
+}
diff --git a/api/src/main/java/io/grpc/LongHistogramMetricInstrument.java b/api/src/main/java/io/grpc/LongHistogramMetricInstrument.java
new file mode 100644
index 00000000000..2a4e56ffd5a
--- /dev/null
+++ b/api/src/main/java/io/grpc/LongHistogramMetricInstrument.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2024 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;
+
+import java.util.List;
+
+/**
+ * Represents a long-valued histogram metric instrument.
+ */
+@Internal
+public final class LongHistogramMetricInstrument extends PartialMetricInstrument {
+  private final List<Long> bucketBoundaries;
+
+  public LongHistogramMetricInstrument(int index, String name, String description, String unit,
+      List<Long> bucketBoundaries, List<String> requiredLabelKeys, List<String> optionalLabelKeys,
+      boolean enableByDefault) {
+    super(index, name, description, unit, requiredLabelKeys, optionalLabelKeys, enableByDefault);
+    this.bucketBoundaries = bucketBoundaries;
+  }
+
+  public List<Long> getBucketBoundaries() {
+    return bucketBoundaries;
+  }
+}
diff --git a/api/src/main/java/io/grpc/LongUpDownCounterMetricInstrument.java b/api/src/main/java/io/grpc/LongUpDownCounterMetricInstrument.java
new file mode 100644
index 00000000000..07e099cde5d
--- /dev/null
+++ b/api/src/main/java/io/grpc/LongUpDownCounterMetricInstrument.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2025 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;
+
+import java.util.List;
+
+/**
+ * Represents a long-valued up down counter metric instrument.
+ */
+@Internal
+public final class LongUpDownCounterMetricInstrument extends PartialMetricInstrument {
+  public LongUpDownCounterMetricInstrument(int index, String name, String description, String unit,
+                                           List<String> requiredLabelKeys,
+                                           List<String> optionalLabelKeys,
+                                           boolean enableByDefault) {
+    super(index, name, description, unit, requiredLabelKeys, optionalLabelKeys, enableByDefault);
+  }
+}
\ No newline at end of file
diff --git a/api/src/main/java/io/grpc/ManagedChannel.java b/api/src/main/java/io/grpc/ManagedChannel.java
new file mode 100644
index 00000000000..7875fdb57f2
--- /dev/null
+++ b/api/src/main/java/io/grpc/ManagedChannel.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright 2015 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;
+
+import java.util.concurrent.TimeUnit;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A {@link Channel} that provides lifecycle management.
+ */
+@ThreadSafe
+public abstract class ManagedChannel extends Channel {
+  /**
+   * Initiates an orderly shutdown in which preexisting calls continue but new calls are immediately
+   * cancelled.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  public abstract ManagedChannel shutdown();
+
+  /**
+   * Returns whether the channel is shutdown. Shutdown channels immediately cancel any new calls,
+   * but may still have some calls being processed.
+   *
+   * @see #shutdown()
+   * @see #isTerminated()
+   * @since 1.0.0
+   */
+  public abstract boolean isShutdown();
+
+  /**
+   * Returns whether the channel is terminated. Terminated channels have no running calls and
+   * relevant resources released (like TCP connections).
+   *
+   * @see #isShutdown()
+   * @since 1.0.0
+   */
+  public abstract boolean isTerminated();
+
+  /**
+   * Initiates a forceful shutdown in which preexisting and new calls are cancelled. Although
+   * forceful, the shutdown process is still not instantaneous; {@link #isTerminated()} will likely
+   * return {@code false} immediately after this method returns.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  public abstract ManagedChannel shutdownNow();
+
+  /**
+   * Waits for the channel to become terminated, giving up if the timeout is reached.
+   *
+   * @return whether the channel is terminated, as would be done by {@link #isTerminated()}.
+   * @since 1.0.0
+   */
+  public abstract boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
+
+  /**
+   * Gets the current connectivity state. Note the result may soon become outdated.
+   *
+   * <p>Note that the core library did not provide an implementation of this method until v1.6.1.
+   *
+   * @param requestConnection if {@code true}, the channel will try to make a connection if it is
+   *        currently IDLE
+   * @throws UnsupportedOperationException if not supported by implementation
+   * @since 1.1.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4359")
+  public ConnectivityState getState(boolean requestConnection) {
+    throw new UnsupportedOperationException("Not implemented");
+  }
+
+  /**
+   * Registers a one-off callback that will be run if the connectivity state of the channel diverges
+   * from the given {@code source}, which is typically what has just been returned by {@link
+   * #getState}.  If the states are already different, the callback will be called immediately.  The
+   * callback is run in the same executor that runs Call listeners.
+   *
+   * <p>There is an inherent race between the notification to {@code callback} and any call to
+   * {@code getState()}. There is a similar race between {@code getState()} and a call to {@code
+   * notifyWhenStateChanged()}. The state can change during those races, so there is not a way to
+   * see every state transition. "Transitions" to the same state are possible, because intermediate
+   * states may not have been observed. The API is only reliable in tracking the <em>current</em>
+   * state.
+   *
+   * <p>Note that the core library did not provide an implementation of this method until v1.6.1.
+   *
+   * @param source the assumed current state, typically just returned by {@link #getState}
+   * @param callback the one-off callback
+   * @throws UnsupportedOperationException if not supported by implementation
+   * @since 1.1.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4359")
+  public void notifyWhenStateChanged(ConnectivityState source, Runnable callback) {
+    throw new UnsupportedOperationException("Not implemented");
+  }
+
+  /**
+   * For subchannels that are in TRANSIENT_FAILURE state, short-circuit the backoff timer and make
+   * them reconnect immediately. May also attempt to invoke {@link NameResolver#refresh}.
+   *
+   * <p>This is primarily intended for Android users, where the network may experience frequent
+   * temporary drops. Rather than waiting for gRPC's name resolution and reconnect timers to elapse
+   * before reconnecting, the app may use this method as a mechanism to notify gRPC that the network
+   * is now available and a reconnection attempt may occur immediately.
+   *
+   * <p>No-op if not supported by the implementation.
+   *
+   * @since 1.8.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4056")
+  public void resetConnectBackoff() {}
+
+  /**
+   * Invoking this method moves the channel into the IDLE state and triggers tear-down of the
+   * channel's name resolver and load balancer, while still allowing on-going RPCs on the channel to
+   * continue. New RPCs on the channel will trigger creation of a new connection.
+   *
+   * <p>This is primarily intended for Android users when a device is transitioning from a cellular
+   * to a wifi connection. The OS will issue a notification that a new network (wifi) has been made
+   * the default, but for approximately 30 seconds the device will maintain both the cellular
+   * and wifi connections. Apps may invoke this method to ensure that new RPCs are created using the
+   * new default wifi network, rather than the soon-to-be-disconnected cellular network.
+   *
+   * <p>No-op if not supported by implementation.
+   *
+   * @since 1.11.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4056")
+  public void enterIdle() {}
+}
diff --git a/api/src/main/java/io/grpc/ManagedChannelBuilder.java b/api/src/main/java/io/grpc/ManagedChannelBuilder.java
new file mode 100644
index 00000000000..3f370ab3003
--- /dev/null
+++ b/api/src/main/java/io/grpc/ManagedChannelBuilder.java
@@ -0,0 +1,679 @@
+/*
+ * Copyright 2015 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;
+
+import com.google.common.base.Preconditions;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * A builder for {@link ManagedChannel} instances.
+ *
+ * @param <T> The concrete type of this builder.
+ */
+public abstract class ManagedChannelBuilder<T extends ManagedChannelBuilder<T>> {
+  /**
+   * Creates a channel with the target's address and port number.
+   *
+   * <p>Note that there is an open JDK bug on {@link java.net.URI} class parsing an ipv6 scope ID:
+   * bugs.openjdk.org/browse/JDK-8199396. This method is exposed to this bug. If you experience an
+   * issue, a work-around is to convert the scope ID to its numeric form (e.g. by using
+   * Inet6Address.getScopeId()) before calling this method.
+   *
+   * @see #forTarget(String)
+   * @since 1.0.0
+   */
+  public static ManagedChannelBuilder<?> forAddress(String name, int port) {
+    return ManagedChannelProvider.provider().builderForAddress(name, port);
+  }
+
+  /**
+   * Creates a channel with a target string, which can be either a valid {@link
+   * NameResolver}-compliant URI, or an authority string.
+   *
+   * <p>A {@code NameResolver}-compliant URI is an absolute hierarchical URI as defined by {@link
+   * java.net.URI}. Example URIs:
+   * <ul>
+   *   <li>{@code "dns:///foo.googleapis.com:8080"}</li>
+   *   <li>{@code "dns:///foo.googleapis.com"}</li>
+   *   <li>{@code "dns:///%5B2001:db8:85a3:8d3:1319:8a2e:370:7348%5D:443"}</li>
+   *   <li>{@code "dns://8.8.8.8/foo.googleapis.com:8080"}</li>
+   *   <li>{@code "dns://8.8.8.8/foo.googleapis.com"}</li>
+   *   <li>{@code "zookeeper://zk.example.com:9900/example_service"}</li>
+   * </ul>
+   *
+   * <p>An authority string will be converted to a {@code NameResolver}-compliant URI, which has
+   * the scheme from the name resolver with the highest priority (e.g. {@code "dns"}),
+   * no authority, and the original authority string as its path after properly escaped.
+   * We recommend libraries to specify the schema explicitly if it is known, since libraries cannot
+   * know which NameResolver will be default during runtime.
+   * Example authority strings:
+   * <ul>
+   *   <li>{@code "localhost"}</li>
+   *   <li>{@code "127.0.0.1"}</li>
+   *   <li>{@code "localhost:8080"}</li>
+   *   <li>{@code "foo.googleapis.com:8080"}</li>
+   *   <li>{@code "127.0.0.1:8080"}</li>
+   *   <li>{@code "[2001:db8:85a3:8d3:1319:8a2e:370:7348]"}</li>
+   *   <li>{@code "[2001:db8:85a3:8d3:1319:8a2e:370:7348]:443"}</li>
+   * </ul>
+   *
+   * <p>Note that there is an open JDK bug on {@link java.net.URI} class parsing an ipv6 scope ID:
+   * bugs.openjdk.org/browse/JDK-8199396. This method is exposed to this bug. If you experience an
+   * issue, a work-around is to convert the scope ID to its numeric form (e.g. by using
+   * Inet6Address.getScopeId()) before calling this method.
+   * 
+   * @since 1.0.0
+   */
+  public static ManagedChannelBuilder<?> forTarget(String target) {
+    return ManagedChannelProvider.provider().builderForTarget(target);
+  }
+
+  /**
+   * Execute application code directly in the transport thread.
+   *
+   * <p>Depending on the underlying transport, using a direct executor may lead to substantial
+   * performance improvements. However, it also requires the application to not block under
+   * any circumstances.
+   *
+   * <p>Calling this method is semantically equivalent to calling {@link #executor(Executor)} and
+   * passing in a direct executor. However, this is the preferred way as it may allow the transport
+   * to perform special optimizations.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  public abstract T directExecutor();
+
+  /**
+   * Provides a custom executor.
+   *
+   * <p>It's an optional parameter. If the user has not provided an executor when the channel is
+   * built, the builder will use a static cached thread pool.
+   *
+   * <p>The channel won't take ownership of the given executor. It's caller's responsibility to
+   * shut down the executor when it's desired.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  public abstract T executor(Executor executor);
+
+  /**
+   * Provides a custom executor that will be used for operations that block or are expensive, to
+   * avoid blocking asynchronous code paths. For example, DNS queries and OAuth token fetching over
+   * HTTP could use this executor.
+   *
+   * <p>It's an optional parameter. If the user has not provided an executor when the channel is
+   * built, the builder will use a static cached thread pool.
+   *
+   * <p>The channel won't take ownership of the given executor. It's caller's responsibility to shut
+   * down the executor when it's desired.
+   *
+   * @return this
+   * @throws UnsupportedOperationException if unsupported
+   * @since 1.25.0
+   */
+  public T offloadExecutor(Executor executor) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Adds interceptors that will be called before the channel performs its real work. This is
+   * functionally equivalent to using {@link ClientInterceptors#intercept(Channel, List)}, but while
+   * still having access to the original {@code ManagedChannel}. Interceptors run in the reverse
+   * order in which they are added, just as with consecutive calls to {@code
+   * ClientInterceptors.intercept()}.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  public abstract T intercept(List<ClientInterceptor> interceptors);
+
+  /**
+   * Adds interceptors that will be called before the channel performs its real work. This is
+   * functionally equivalent to using {@link ClientInterceptors#intercept(Channel,
+   * ClientInterceptor...)}, but while still having access to the original {@code ManagedChannel}.
+   * Interceptors run in the reverse order in which they are added, just as with consecutive calls
+   * to {@code ClientInterceptors.intercept()}.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  public abstract T intercept(ClientInterceptor... interceptors);
+
+  /**
+   * Internal-only: Adds a factory that will construct an interceptor based on the channel's target.
+   * This can be used to work around nameResolverFactory() changing the target string.
+   */
+  @Internal
+  protected T interceptWithTarget(InterceptorFactory factory) {
+    throw new UnsupportedOperationException();
+  }
+
+  /** Internal-only. */
+  @Internal
+  protected interface InterceptorFactory {
+    ClientInterceptor newInterceptor(String target);
+  }
+
+  /**
+   * Adds a {@link ClientTransportFilter}. The order of filters being added is the order they will
+   * be executed
+   *
+   * @return this
+   * @since 1.60.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10652")
+  public T addTransportFilter(ClientTransportFilter filter) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Provides a custom {@code User-Agent} for the application.
+   *
+   * <p>It's an optional parameter. The library will provide a user agent independent of this
+   * option. If provided, the given agent will prepend the library's user agent information.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  public abstract T userAgent(String userAgent);
+
+  /**
+   * Overrides the authority used with TLS and HTTP virtual hosting. It does not change what host is
+   * actually connected to. Is commonly in the form {@code host:port}.
+   *
+   * <p>If the channel builder overrides authority, any authority override from name resolution
+   * result (via {@link EquivalentAddressGroup#ATTR_AUTHORITY_OVERRIDE}) will be discarded.
+   *
+   * <p>This method is intended for testing, but may safely be used outside of tests as an
+   * alternative to DNS overrides.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  public abstract T overrideAuthority(String authority);
+
+  /**
+   * Use of a plaintext connection to the server. By default a secure connection mechanism
+   * such as TLS will be used.
+   *
+   * <p>Should only be used for testing or for APIs where the use of such API or the data
+   * exchanged is not sensitive.
+   *
+   * <p>This assumes prior knowledge that the target of this channel is using plaintext.  It will
+   * not perform HTTP/1.1 upgrades.
+   *
+   * @return this
+   * @throws IllegalStateException if ChannelCredentials were provided when constructing the builder
+   * @throws UnsupportedOperationException if plaintext mode is not supported.
+   * @since 1.11.0
+   */
+  public T usePlaintext() {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Makes the client use TLS. Note: this is enabled by default.
+   *
+   * <p>It is recommended to use the {@link ChannelCredentials} API
+   * instead of this method.
+   *
+   * @return this
+   * @throws IllegalStateException if ChannelCredentials were provided when constructing the builder
+   * @throws UnsupportedOperationException if transport security is not supported.
+   * @since 1.9.0
+   */
+  public T useTransportSecurity() {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Provides a custom {@link NameResolver.Factory} for the channel. If this method is not called,
+   * the builder will try the providers registered in the default {@link NameResolverRegistry} for
+   * the given target.
+   *
+   * <p>This method should rarely be used, as name resolvers should provide a {@code
+   * NameResolverProvider} and users rely on service loading to find implementations in the class
+   * path. That allows application's configuration to easily choose the name resolver via the
+   * 'target' string passed to {@link ManagedChannelBuilder#forTarget(String)}.
+   *
+   * @return this
+   * @since 1.0.0
+   * @deprecated Most usages should use a globally-registered {@link NameResolverProvider} instead,
+   *     with either the SPI mechanism or {@link NameResolverRegistry#register}. Replacements for
+   *     all use-cases are not necessarily available yet. See
+   *     <a href="https://github.com/grpc/grpc-java/issues/7133">#7133</a>.
+   */
+  @Deprecated
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
+  public abstract T nameResolverFactory(NameResolver.Factory resolverFactory);
+
+  /**
+   * Sets the default load-balancing policy that will be used if the service config doesn't specify
+   * one.  If not set, the default will be the "pick_first" policy.
+   *
+   * <p>Policy implementations are looked up in the
+   * {@link LoadBalancerRegistry#getDefaultRegistry default LoadBalancerRegistry}.
+   *
+   * <p>This method is implemented by all stock channel builders that are shipped with gRPC, but may
+   * not be implemented by custom channel builders, in which case this method will throw.
+   *
+   * @return this
+   * @since 1.18.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+  public T defaultLoadBalancingPolicy(String policy) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Set the decompression registry for use in the channel. This is an advanced API call and
+   * shouldn't be used unless you are using custom message encoding. The default supported
+   * decompressors are in {@link DecompressorRegistry#getDefaultInstance}.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
+  public abstract T decompressorRegistry(DecompressorRegistry registry);
+
+  /**
+   * Set the compression registry for use in the channel.  This is an advanced API call and
+   * shouldn't be used unless you are using custom message encoding.   The default supported
+   * compressors are in {@link CompressorRegistry#getDefaultInstance}.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
+  public abstract T compressorRegistry(CompressorRegistry registry);
+
+  /**
+   * Set the duration without ongoing RPCs before going to idle mode.
+   *
+   * <p>In idle mode the channel shuts down all connections, the NameResolver and the
+   * LoadBalancer. A new RPC would take the channel out of idle mode. A channel starts in idle mode.
+   * Defaults to 30 minutes.
+   *
+   * <p>This is an advisory option. Do not rely on any specific behavior related to this option.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2022")
+  public abstract T idleTimeout(long value, TimeUnit unit);
+
+  /**
+   * Sets the maximum message size allowed to be received on the channel. If not called,
+   * defaults to 4 MiB. The default provides protection to clients who haven't considered the
+   * possibility of receiving large messages while trying to be large enough to not be hit in normal
+   * usage.
+   *
+   * <p>This method is advisory, and implementations may decide to not enforce this.  Currently,
+   * the only known transport to not enforce this is {@code InProcessTransport}.
+   *
+   * @param bytes the maximum number of bytes a single message can be.
+   * @return this
+   * @throws IllegalArgumentException if bytes is negative.
+   * @since 1.1.0
+   */
+  public T maxInboundMessageSize(int bytes) {
+    // intentional noop rather than throw, this method is only advisory.
+    Preconditions.checkArgument(bytes >= 0, "bytes must be >= 0");
+    return thisT();
+  }
+
+  /**
+   * Sets the maximum size of metadata allowed to be received. {@code Integer.MAX_VALUE} disables
+   * the enforcement. The default is implementation-dependent, but is not generally less than 8 KiB
+   * and may be unlimited.
+   *
+   * <p>This is cumulative size of the metadata. The precise calculation is
+   * implementation-dependent, but implementations are encouraged to follow the calculation used for
+   * <a href="http://httpwg.org/specs/rfc7540.html#rfc.section.6.5.2">
+   * HTTP/2's SETTINGS_MAX_HEADER_LIST_SIZE</a>. It sums the bytes from each entry's key and value,
+   * plus 32 bytes of overhead per entry.
+   *
+   * @param bytes the maximum size of received metadata
+   * @return this
+   * @throws IllegalArgumentException if bytes is non-positive
+   * @since 1.17.0
+   */
+  public T maxInboundMetadataSize(int bytes) {
+    Preconditions.checkArgument(bytes > 0, "maxInboundMetadataSize must be > 0");
+    // intentional noop rather than throw, this method is only advisory.
+    return thisT();
+  }
+
+  /**
+   * Sets the time without read activity before sending a keepalive ping. An unreasonably small
+   * value might be increased, and {@code Long.MAX_VALUE} nano seconds or an unreasonably large
+   * value will disable keepalive. Defaults to infinite.
+   *
+   * <p>Clients must receive permission from the service owner before enabling this option.
+   * Keepalives can increase the load on services and are commonly "invisible" making it hard to
+   * notice when they are causing excessive load. Clients are strongly encouraged to use only as
+   * small of a value as necessary.
+   *
+   * <p>When the channel implementation supports TCP_USER_TIMEOUT, enabling keepalive will also
+   * enable TCP_USER_TIMEOUT for the connection. This requires <em>all</em> sent packets to receive
+   * a TCP acknowledgement before the keepalive timeout. The keepalive time is not used for
+   * TCP_USER_TIMEOUT, except as a signal to enable the feature. grpc-netty supports
+   * TCP_USER_TIMEOUT on Linux platforms supported by netty-transport-native-epoll.
+   *
+   * @throws UnsupportedOperationException if unsupported
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A8-client-side-keepalive.md">gRFC A8
+   *     Client-side Keepalive</a>
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A18-tcp-user-timeout.md">gRFC A18
+   *     TCP User Timeout</a>
+   * @since 1.7.0
+   */
+  public T keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets the time waiting for read activity after sending a keepalive ping. If the time expires
+   * without any read activity on the connection, the connection is considered dead. An unreasonably
+   * small value might be increased. Defaults to 20 seconds.
+   *
+   * <p>This value should be at least multiple times the RTT to allow for lost packets.
+   *
+   * @throws UnsupportedOperationException if unsupported
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A8-client-side-keepalive.md">gRFC A8
+   *     Client-side Keepalive</a>
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A18-tcp-user-timeout.md">gRFC A18
+   *     TCP User Timeout</a>
+   * @since 1.7.0
+   */
+  public T keepAliveTimeout(long keepAliveTimeout, TimeUnit timeUnit) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets whether keepalive will be performed when there are no outstanding RPC on a connection.
+   * Defaults to {@code false}.
+   *
+   * <p>Clients must receive permission from the service owner before enabling this option.
+   * Keepalives on unused connections can easilly accidentally consume a considerable amount of
+   * bandwidth and CPU. {@link ManagedChannelBuilder#idleTimeout idleTimeout()} should generally be
+   * used instead of this option.
+   *
+   * @throws UnsupportedOperationException if unsupported
+   * @see #keepAliveTime(long, TimeUnit)
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A8-client-side-keepalive.md">gRFC A8
+   *     Client-side Keepalive</a>
+   * @since 1.7.0
+   */
+  public T keepAliveWithoutCalls(boolean enable) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets the maximum number of retry attempts that may be configured by the service config. If the
+   * service config specifies a larger value it will be reduced to this value.  Setting this number
+   * to zero is not effectively the same as {@code disableRetry()} because the former does not
+   * disable
+   * <a
+   * href="https://github.com/grpc/proposal/blob/master/A6-client-retries.md#transparent-retries">
+   * transparent retry</a>.
+   *
+   * <p>This method may not work as expected for the current release because retry is not fully
+   * implemented yet.
+   *
+   * @return this
+   * @since 1.11.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/3982")
+  public T maxRetryAttempts(int maxRetryAttempts) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets the maximum number of hedged attempts that may be configured by the service config. If the
+   * service config specifies a larger value it will be reduced to this value.
+   *
+   * <p>This method may not work as expected for the current release because retry is not fully
+   * implemented yet.
+   *
+   * @return this
+   * @since 1.11.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/3982")
+  public T maxHedgedAttempts(int maxHedgedAttempts) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets the retry buffer size in bytes. If the buffer limit is exceeded, no RPC
+   * could retry at the moment, and in hedging case all hedges but one of the same RPC will cancel.
+   * The implementation may only estimate the buffer size being used rather than count the
+   * exact physical memory allocated. The method does not have any effect if retry is disabled by
+   * the client.
+   *
+   * <p>This method may not work as expected for the current release because retry is not fully
+   * implemented yet.
+   *
+   * @return this
+   * @since 1.10.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/3982")
+  public T retryBufferSize(long bytes) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets the per RPC buffer limit in bytes used for retry. The RPC is not retriable if its buffer
+   * limit is exceeded. The implementation may only estimate the buffer size being used rather than
+   * count the exact physical memory allocated. It does not have any effect if retry is disabled by
+   * the client.
+   *
+   * <p>This method may not work as expected for the current release because retry is not fully
+   * implemented yet.
+   *
+   * @return this
+   * @since 1.10.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/3982")
+  public T perRpcBufferLimit(long bytes) {
+    throw new UnsupportedOperationException();
+  }
+
+
+  /**
+   * Disables the retry and hedging subsystem provided by the gRPC library. This is designed for the
+   * case when users have their own retry implementation and want to avoid their own retry taking
+   * place simultaneously with the gRPC library layer retry.
+   *
+   * @return this
+   * @since 1.11.0
+   */
+  public T disableRetry() {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Enables the retry and hedging subsystem which will use
+   * <a href="https://github.com/grpc/proposal/blob/master/A6-client-retries.md#integration-with-service-config">
+   * per-method configuration</a>. If a method is unconfigured, it will be limited to
+   * transparent retries, which are safe for non-idempotent RPCs. Service config is ideally provided
+   * by the name resolver, but may also be specified via {@link #defaultServiceConfig}.
+   *
+   * @return this
+   * @since 1.11.0
+   */
+  public T enableRetry() {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets the BinaryLog object that this channel should log to. The channel does not take
+   * ownership of the object, and users are responsible for calling {@link BinaryLog#close()}.
+   *
+   * @param binaryLog the object to provide logging.
+   * @return this
+   * @since 1.13.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4017")
+  public T setBinaryLog(BinaryLog binaryLog) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets the maximum number of channel trace events to keep in the tracer for each channel or
+   * subchannel. If set to 0, channel tracing is effectively disabled.
+   *
+   * @return this
+   * @since 1.13.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4471")
+  public T maxTraceEvents(int maxTraceEvents) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets the proxy detector to be used in addresses name resolution. If <code>null</code> is passed
+   * the default proxy detector will be used.  For how proxies work in gRPC, please refer to the
+   * documentation on {@link ProxyDetector}.
+   *
+   * @return this
+   * @since 1.19.0
+   */
+  public T proxyDetector(ProxyDetector proxyDetector) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Provides a service config to the channel. The channel will use the default service config when
+   * the name resolver provides no service config or if the channel disables lookup service config
+   * from name resolver (see {@link #disableServiceConfigLookUp()}). The argument
+   * {@code serviceConfig} is a nested map representing a Json object in the most natural way:
+   *
+   *        <table border="1">
+   *          <tr>
+   *            <td>Json entry</td><td>Java Type</td>
+   *          </tr>
+   *          <tr>
+   *            <td>object</td><td>{@link Map}</td>
+   *          </tr>
+   *          <tr>
+   *            <td>array</td><td>{@link List}</td>
+   *          </tr>
+   *          <tr>
+   *            <td>string</td><td>{@link String}</td>
+   *          </tr>
+   *          <tr>
+   *            <td>number</td><td>{@link Double}</td>
+   *          </tr>
+   *          <tr>
+   *            <td>boolean</td><td>{@link Boolean}</td>
+   *          </tr>
+   *          <tr>
+   *            <td>null</td><td>{@code null}</td>
+   *          </tr>
+   *        </table>
+   *
+   * <p>If null is passed, then there will be no default service config.
+   *
+   * <p>Your preferred JSON parser may not produce results in the format expected. For such cases,
+   * you can convert its output. For example, if your parser produces Integers and other Numbers
+   * in addition to Double:
+   *
+   * <pre>{@code @SuppressWarnings("unchecked")
+   * private static Object convertNumbers(Object o) {
+   *   if (o instanceof Map) {
+   *     ((Map) o).replaceAll((k,v) -> convertNumbers(v));
+   *   } else if (o instanceof List) {
+   *     ((List) o).replaceAll(YourClass::convertNumbers);
+   *   } else if (o instanceof Number && !(o instanceof Double)) {
+   *     o = ((Number) o).doubleValue();
+   *   }
+   *   return o;
+   * }}</pre>
+   *
+   * @return this
+   * @throws IllegalArgumentException When the given serviceConfig is invalid or the current version
+   *         of grpc library can not parse it gracefully. The state of the builder is unchanged if
+   *         an exception is thrown.
+   * @since 1.20.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/5189")
+  public T defaultServiceConfig(@Nullable Map<String, ?> serviceConfig) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Disables service config look-up from the naming system, which is enabled by default.
+   *
+   * @return this
+   * @since 1.20.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/5189")
+  public T disableServiceConfigLookUp() {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Adds a {@link MetricSink} for channel to use for configuring and recording metrics.
+   *
+   * @return this
+   * @since 1.64.0
+   */
+  @Internal
+  protected T addMetricSink(MetricSink metricSink) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Provides a "custom" argument for the {@link NameResolver}, if applicable, replacing any 'value'
+   * previously provided for 'key'.
+   *
+   * <p>NB: If the selected {@link NameResolver} does not understand 'key', or target URI resolution
+   * isn't needed at all, your custom argument will be silently ignored.
+   *
+   * <p>See {@link NameResolver.Args#getArg(NameResolver.Args.Key)} for more.
+   *
+   * @param key identifies the argument in a type-safe manner
+   * @param value the argument itself
+   * @return this
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
+  public <X> T setNameResolverArg(NameResolver.Args.Key<X> key, X value) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Builds a channel using the given parameters.
+   *
+   * @since 1.0.0
+   */
+  public abstract ManagedChannel build();
+
+  /**
+   * Returns the correctly typed version of the builder.
+   */
+  private T thisT() {
+    @SuppressWarnings("unchecked")
+    T thisT = (T) this;
+    return thisT;
+  }
+}
diff --git a/api/src/main/java/io/grpc/ManagedChannelProvider.java b/api/src/main/java/io/grpc/ManagedChannelProvider.java
new file mode 100644
index 00000000000..42941dfc809
--- /dev/null
+++ b/api/src/main/java/io/grpc/ManagedChannelProvider.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2015 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;
+
+import com.google.common.base.Preconditions;
+import java.net.SocketAddress;
+import java.util.Collection;
+
+/**
+ * Provider of managed channels for transport agnostic consumption.
+ *
+ * <p>Implementations can be automatically discovered by gRPC via Java's SPI mechanism. For
+ * automatic discovery, the implementation must have a zero-argument constructor and include
+ * a resource named {@code META-INF/services/io.grpc.ManagedChannelProvider} in their JAR. The
+ * file's contents should be the implementation's class name.
+ *
+ * <p>Implementations <em>should not</em> throw. If they do, it may interrupt class loading. If
+ * exceptions may reasonably occur for implementation-specific reasons, implementations should
+ * generally handle the exception gracefully and return {@code false} from {@link #isAvailable()}.
+ */
+@Internal
+public abstract class ManagedChannelProvider {
+  /**
+   * Returns the ClassLoader-wide default channel.
+   *
+   * @throws ProviderNotFoundException if no provider is available
+   */
+  public static ManagedChannelProvider provider() {
+    ManagedChannelProvider provider = ManagedChannelRegistry.getDefaultRegistry().provider();
+    if (provider == null) {
+      throw new ProviderNotFoundException("No functional channel service provider found. "
+          + "Try adding a dependency on the grpc-okhttp, grpc-netty, or grpc-netty-shaded "
+          + "artifact");
+    }
+    return provider;
+  }
+
+  /**
+   * Whether this provider is available for use, taking the current environment into consideration.
+   * If {@code false}, no other methods are safe to be called.
+   */
+  protected abstract boolean isAvailable();
+
+  /**
+   * A priority, from 0 to 10 that this provider should be used, taking the current environment into
+   * consideration. 5 should be considered the default, and then tweaked based on environment
+   * detection. A priority of 0 does not imply that the provider wouldn't work; just that it should
+   * be last in line.
+   */
+  protected abstract int priority();
+
+  /**
+   * Creates a new builder with the given host and port.
+   */
+  protected abstract ManagedChannelBuilder<?> builderForAddress(String name, int port);
+
+  /**
+   * Creates a new builder with the given target URI.
+   */
+  protected abstract ManagedChannelBuilder<?> builderForTarget(String target);
+
+  /**
+   * Creates a new builder with the given target URI and credentials. Returns an error-string result
+   * if unable to understand the credentials.
+   */
+  protected NewChannelBuilderResult newChannelBuilder(String target, ChannelCredentials creds) {
+    return NewChannelBuilderResult.error("ChannelCredentials are unsupported");
+  }
+
+  /**
+   * Returns the {@link SocketAddress} types this ManagedChannelProvider supports.
+   */
+  protected abstract Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes();
+
+  public static final class NewChannelBuilderResult {
+    private final ManagedChannelBuilder<?> channelBuilder;
+    private final String error;
+
+    private NewChannelBuilderResult(ManagedChannelBuilder<?> channelBuilder, String error) {
+      this.channelBuilder = channelBuilder;
+      this.error = error;
+    }
+
+    public static NewChannelBuilderResult channelBuilder(ManagedChannelBuilder<?> builder) {
+      return new NewChannelBuilderResult(Preconditions.checkNotNull(builder), null);
+    }
+
+    public static NewChannelBuilderResult error(String error) {
+      return new NewChannelBuilderResult(null, Preconditions.checkNotNull(error));
+    }
+
+    public ManagedChannelBuilder<?> getChannelBuilder() {
+      return channelBuilder;
+    }
+
+    public String getError() {
+      return error;
+    }
+  }
+
+  /**
+   * Thrown when no suitable {@link ManagedChannelProvider} objects can be found.
+   */
+  public static final class ProviderNotFoundException extends RuntimeException {
+    private static final long serialVersionUID = 1;
+
+    public ProviderNotFoundException(String msg) {
+      super(msg);
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/ManagedChannelRegistry.java b/api/src/main/java/io/grpc/ManagedChannelRegistry.java
new file mode 100644
index 00000000000..aed5eca9abf
--- /dev/null
+++ b/api/src/main/java/io/grpc/ManagedChannelRegistry.java
@@ -0,0 +1,228 @@
+/*
+ * 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;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Registry of {@link ManagedChannelProvider}s. The {@link #getDefaultRegistry default instance}
+ * loads providers at runtime through the Java service provider mechanism.
+ *
+ * @since 1.32.0
+ */
+@Internal
+@ThreadSafe
+public final class ManagedChannelRegistry {
+  private static final Logger logger = Logger.getLogger(ManagedChannelRegistry.class.getName());
+  private static ManagedChannelRegistry instance;
+
+  @GuardedBy("this")
+  private final LinkedHashSet<ManagedChannelProvider> allProviders = new LinkedHashSet<>();
+  /** Immutable, sorted version of {@code allProviders}. Is replaced instead of mutating. */
+  @GuardedBy("this")
+  private List<ManagedChannelProvider> effectiveProviders = Collections.emptyList();
+
+  /**
+   * Register a provider.
+   *
+   * <p>If the provider's {@link ManagedChannelProvider#isAvailable isAvailable()} returns
+   * {@code false}, this method will throw {@link IllegalArgumentException}.
+   *
+   * <p>Providers will be used in priority order. In case of ties, providers are used in
+   * registration order.
+   */
+  public synchronized void register(ManagedChannelProvider provider) {
+    addProvider(provider);
+    refreshProviders();
+  }
+
+  private synchronized void addProvider(ManagedChannelProvider provider) {
+    Preconditions.checkArgument(provider.isAvailable(), "isAvailable() returned false");
+    allProviders.add(provider);
+  }
+
+  /**
+   * Deregisters a provider.  No-op if the provider is not in the registry.
+   *
+   * @param provider the provider that was added to the register via {@link #register}.
+   */
+  public synchronized void deregister(ManagedChannelProvider provider) {
+    allProviders.remove(provider);
+    refreshProviders();
+  }
+
+  private synchronized void refreshProviders() {
+    List<ManagedChannelProvider> providers = new ArrayList<>(allProviders);
+    // Sort descending based on priority.
+    // sort() must be stable, as we prefer first-registered providers
+    Collections.sort(providers, Collections.reverseOrder(new Comparator<ManagedChannelProvider>() {
+      @Override
+      public int compare(ManagedChannelProvider o1, ManagedChannelProvider o2) {
+        return o1.priority() - o2.priority();
+      }
+    }));
+    effectiveProviders = Collections.unmodifiableList(providers);
+  }
+
+  /**
+   * Returns the default registry that loads providers via the Java service loader mechanism.
+   */
+  public static synchronized ManagedChannelRegistry getDefaultRegistry() {
+    if (instance == null) {
+      List<ManagedChannelProvider> providerList = ServiceProviders.loadAll(
+          ManagedChannelProvider.class,
+          getHardCodedClasses(),
+          ManagedChannelProvider.class.getClassLoader(),
+          new ManagedChannelPriorityAccessor());
+      instance = new ManagedChannelRegistry();
+      for (ManagedChannelProvider provider : providerList) {
+        logger.fine("Service loader found " + provider);
+        instance.addProvider(provider);
+      }
+      instance.refreshProviders();
+    }
+    return instance;
+  }
+
+  /**
+   * Returns effective providers, in priority order.
+   */
+  @VisibleForTesting
+  synchronized List<ManagedChannelProvider> providers() {
+    return effectiveProviders;
+  }
+
+  // For emulating ManagedChannelProvider.provider()
+  ManagedChannelProvider provider() {
+    List<ManagedChannelProvider> providers = providers();
+    return providers.isEmpty() ? null : providers.get(0);
+  }
+
+  @VisibleForTesting
+  static List<Class<?>> getHardCodedClasses() {
+    // Class.forName(String) is used to remove the need for ProGuard configuration. Note that
+    // ProGuard does not detect usages of Class.forName(String, boolean, ClassLoader):
+    // https://sourceforge.net/p/proguard/bugs/418/
+    List<Class<?>> list = new ArrayList<>();
+    try {
+      list.add(Class.forName("io.grpc.okhttp.OkHttpChannelProvider"));
+    } catch (ClassNotFoundException e) {
+      logger.log(Level.FINE, "Unable to find OkHttpChannelProvider", e);
+    }
+    try {
+      list.add(Class.forName("io.grpc.netty.NettyChannelProvider"));
+    } catch (ClassNotFoundException e) {
+      logger.log(Level.FINE, "Unable to find NettyChannelProvider", e);
+    }
+    try {
+      list.add(Class.forName("io.grpc.netty.UdsNettyChannelProvider"));
+    } catch (ClassNotFoundException e) {
+      logger.log(Level.FINE, "Unable to find UdsNettyChannelProvider", e);
+    }
+    return Collections.unmodifiableList(list);
+  }
+
+  ManagedChannelBuilder<?> newChannelBuilder(String target, ChannelCredentials creds) {
+    return newChannelBuilder(NameResolverRegistry.getDefaultRegistry(), target, creds);
+  }
+
+  @VisibleForTesting
+  ManagedChannelBuilder<?> newChannelBuilder(NameResolverRegistry nameResolverRegistry,
+      String target, ChannelCredentials creds) {
+    NameResolverProvider nameResolverProvider = null;
+    try {
+      URI uri = new URI(target);
+      nameResolverProvider = nameResolverRegistry.getProviderForScheme(uri.getScheme());
+    } catch (URISyntaxException ignore) {
+      // bad URI found, just ignore and continue
+    }
+    if (nameResolverProvider == null) {
+      nameResolverProvider = nameResolverRegistry.getProviderForScheme(
+          nameResolverRegistry.getDefaultScheme());
+    }
+    Collection<Class<? extends SocketAddress>> nameResolverSocketAddressTypes
+        = (nameResolverProvider != null)
+        ? nameResolverProvider.getProducedSocketAddressTypes() :
+        Collections.emptySet();
+
+    List<ManagedChannelProvider> providers = providers();
+    if (providers.isEmpty()) {
+      throw new ProviderNotFoundException("No functional channel service provider found. "
+          + "Try adding a dependency on the grpc-okhttp, grpc-netty, or grpc-netty-shaded "
+          + "artifact");
+    }
+    StringBuilder error = new StringBuilder();
+    for (ManagedChannelProvider provider : providers()) {
+      Collection<Class<? extends SocketAddress>> channelProviderSocketAddressTypes
+          = provider.getSupportedSocketAddressTypes();
+      if (!channelProviderSocketAddressTypes.containsAll(nameResolverSocketAddressTypes)) {
+        error.append("; ");
+        error.append(provider.getClass().getName());
+        error.append(": does not support 1 or more of ");
+        error.append(Arrays.toString(nameResolverSocketAddressTypes.toArray()));
+        continue;
+      }
+      ManagedChannelProvider.NewChannelBuilderResult result
+          = provider.newChannelBuilder(target, creds);
+      if (result.getChannelBuilder() != null) {
+        return result.getChannelBuilder();
+      }
+      error.append("; ");
+      error.append(provider.getClass().getName());
+      error.append(": ");
+      error.append(result.getError());
+    }
+    throw new ProviderNotFoundException(error.substring(2));
+  }
+
+  private static final class ManagedChannelPriorityAccessor
+      implements ServiceProviders.PriorityAccessor<ManagedChannelProvider> {
+    @Override
+    public boolean isAvailable(ManagedChannelProvider provider) {
+      return provider.isAvailable();
+    }
+
+    @Override
+    public int getPriority(ManagedChannelProvider provider) {
+      return provider.priority();
+    }
+  }
+
+  /** Thrown when no suitable {@link ManagedChannelProvider} objects can be found. */
+  public static final class ProviderNotFoundException extends RuntimeException {
+    private static final long serialVersionUID = 1;
+
+    public ProviderNotFoundException(String msg) {
+      super(msg);
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/Metadata.java b/api/src/main/java/io/grpc/Metadata.java
new file mode 100644
index 00000000000..8a958d127df
--- /dev/null
+++ b/api/src/main/java/io/grpc/Metadata.java
@@ -0,0 +1,1051 @@
+/*
+ * Copyright 2014 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static java.nio.charset.StandardCharsets.US_ASCII;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.common.io.BaseEncoding;
+import com.google.common.io.ByteStreams;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+import javax.annotation.concurrent.NotThreadSafe;
+
+/**
+ * Provides access to read and write metadata values to be exchanged during a call.
+ *
+ * <p>Keys are allowed to be associated with more than one value.
+ *
+ * <p>This class is not thread safe, implementations should ensure that header reads and writes do
+ * not occur in multiple threads concurrently.
+ */
+@NotThreadSafe
+public final class Metadata {
+  private static final Logger logger = Logger.getLogger(Metadata.class.getName());
+
+  /**
+   * All binary headers should have this suffix in their names. Vice versa.
+   *
+   * <p>Its value is {@code "-bin"}. An ASCII header's name must not end with this.
+   */
+  public static final String BINARY_HEADER_SUFFIX = "-bin";
+
+  /**
+   * Simple metadata marshaller that encodes bytes as is.
+   *
+   * <p>This should be used when raw bytes are favored over un-serialized version of object. Can be
+   * helpful in situations where more processing to bytes is needed on application side, avoids
+   * double encoding/decoding.
+   *
+   * <p>Both {@link BinaryMarshaller#toBytes} and {@link BinaryMarshaller#parseBytes} methods do not
+   * return a copy of the byte array. Do _not_ modify the byte arrays of either the arguments or
+   * return values.
+   */
+  public static final BinaryMarshaller<byte[]> BINARY_BYTE_MARSHALLER =
+      new BinaryMarshaller<byte[]>() {
+
+        @Override
+        public byte[] toBytes(byte[] value) {
+          return value;
+        }
+
+        @Override
+        public byte[] parseBytes(byte[] serialized) {
+          return serialized;
+        }
+      };
+
+  /**
+   * Simple metadata marshaller that encodes strings as is.
+   *
+   * <p>This should be used with ASCII strings that only contain the characters listed in the class
+   * comment of {@link AsciiMarshaller}. Otherwise the output may be considered invalid and
+   * discarded by the transport, or the call may fail.
+   */
+  public static final AsciiMarshaller<String> ASCII_STRING_MARSHALLER =
+      new AsciiMarshaller<String>() {
+
+        @Override
+        public String toAsciiString(String value) {
+          return value;
+        }
+
+        @Override
+        public String parseAsciiString(String serialized) {
+          return serialized;
+        }
+      };
+
+  static final BaseEncoding BASE64_ENCODING_OMIT_PADDING = BaseEncoding.base64().omitPadding();
+
+  /**
+   * Constructor called by the transport layer when it receives binary metadata. Metadata will
+   * mutate the passed in array.
+   */
+  Metadata(byte[]... binaryValues) {
+    this(binaryValues.length / 2, binaryValues);
+  }
+
+  /**
+   * Constructor called by the transport layer when it receives binary metadata. Metadata will
+   * mutate the passed in array.
+   *
+   * @param usedNames the number of names
+   */
+  Metadata(int usedNames, byte[]... binaryValues) {
+    this(usedNames, (Object[]) binaryValues);
+  }
+
+  /**
+   * Constructor called by the transport layer when it receives partially-parsed metadata.
+   * Metadata will mutate the passed in array.
+   *
+   * @param usedNames the number of names
+   * @param namesAndValues an array of interleaved names and values, with each name
+   *     (at even indices) represented by a byte array, and values (at odd indices) as
+   *     described by {@link InternalMetadata#newMetadataWithParsedValues}.
+   */
+  Metadata(int usedNames, Object[] namesAndValues) {
+    assert (namesAndValues.length & 1) == 0
+        : "Odd number of key-value pairs " + namesAndValues.length;
+    size = usedNames;
+    this.namesAndValues = namesAndValues;
+  }
+
+  private Object[] namesAndValues;
+  // The unscaled number of headers present.
+  private int size;
+
+  private byte[] name(int i) {
+    return (byte[]) namesAndValues[i * 2];
+  }
+
+  private void name(int i, byte[] name) {
+    namesAndValues[i * 2] = name;
+  }
+
+  private Object value(int i) {
+    return namesAndValues[i * 2 + 1];
+  }
+
+  private void value(int i, byte[] value) {
+    namesAndValues[i * 2 + 1] = value;
+  }
+
+  private void value(int i, Object value) {
+    if (namesAndValues instanceof byte[][]) {
+      // Reallocate an array of Object.
+      expand(cap());
+    }
+    namesAndValues[i * 2 + 1] = value;
+  }
+
+  private byte[] valueAsBytes(int i) {
+    Object value = value(i);
+    if (value instanceof byte[]) {
+      return (byte[]) value;
+    } else {
+      return ((LazyValue<?>) value).toBytes();
+    }
+  }
+
+  private Object valueAsBytesOrStream(int i) {
+    Object value = value(i);
+    if (value instanceof byte[]) {
+      return value;
+    } else {
+      return ((LazyValue<?>) value).toStream();
+    }
+  }
+
+  private <T> T valueAsT(int i, Key<T> key) {
+    Object value = value(i);
+    if (value instanceof byte[]) {
+      return key.parseBytes((byte[]) value);
+    } else {
+      return ((LazyValue<?>) value).toObject(key);
+    }
+  }
+
+  private int cap() {
+    return namesAndValues != null ? namesAndValues.length : 0;
+  }
+
+  // The scaled version of size.
+  private int len() {
+    return size * 2;
+  }
+
+  /** checks when {@link #namesAndValues} is null or has no elements. */
+  private boolean isEmpty() {
+    return size == 0;
+  }
+
+  /** Constructor called by the application layer when it wants to send metadata. */
+  public Metadata() {}
+
+  /** Returns the total number of key-value headers in this metadata, including duplicates. */
+  int headerCount() {
+    return size;
+  }
+
+  /**
+   * Returns true if a value is defined for the given key.
+   *
+   * <p>This is done by linear search, so if it is followed by {@link #get} or {@link #getAll},
+   * prefer calling them directly and checking the return value against {@code null}.
+   */
+  public boolean containsKey(Key<?> key) {
+    for (int i = 0; i < size; i++) {
+      if (bytesEqual(key.asciiName(), name(i))) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Returns the last metadata entry added with the name 'name' parsed as T.
+   *
+   * @return the parsed metadata entry or null if there are none.
+   */
+  @Nullable
+  public <T> T get(Key<T> key) {
+    for (int i = size - 1; i >= 0; i--) {
+      if (bytesEqual(key.asciiName(), name(i))) {
+        return valueAsT(i, key);
+      }
+    }
+    return null;
+  }
+
+  private final class IterableAt<T> implements Iterable<T> {
+    private final Key<T> key;
+    private int startIdx;
+
+    private IterableAt(Key<T> key, int startIdx) {
+      this.key = key;
+      this.startIdx = startIdx;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+      return new Iterator<T>() {
+        private boolean hasNext = true;
+        private int idx = startIdx;
+
+        @Override
+        public boolean hasNext() {
+          if (hasNext) {
+            return true;
+          }
+          for (; idx < size; idx++) {
+            if (bytesEqual(key.asciiName(), name(idx))) {
+              hasNext = true;
+              return hasNext;
+            }
+          }
+          return false;
+        }
+
+        @Override
+        public T next() {
+          if (hasNext()) {
+            hasNext = false;
+            return valueAsT(idx++, key);
+          }
+          throw new NoSuchElementException();
+        }
+
+        @Override
+        public void remove() {
+          throw new UnsupportedOperationException();
+        }
+      };
+    }
+  }
+
+  /**
+   * Returns all the metadata entries named 'name', in the order they were received, parsed as T, or
+   * null if there are none. The iterator is not guaranteed to be "live." It may or may not be
+   * accurate if Metadata is mutated.
+   */
+  @Nullable
+  public <T> Iterable<T> getAll(final Key<T> key) {
+    for (int i = 0; i < size; i++) {
+      if (bytesEqual(key.asciiName(), name(i))) {
+        return new IterableAt<>(key, i);
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Returns set of all keys in store.
+   *
+   * @return unmodifiable Set of keys
+   */
+  @SuppressWarnings("deprecation") // The String ctor is deprecated, but fast.
+  public Set<String> keys() {
+    if (isEmpty()) {
+      return Collections.emptySet();
+    }
+    Set<String> ks = Sets.newHashSetWithExpectedSize(size);
+    for (int i = 0; i < size; i++) {
+      ks.add(new String(name(i), 0 /* hibyte */));
+    }
+    // immutable in case we decide to change the implementation later.
+    return Collections.unmodifiableSet(ks);
+  }
+
+  /**
+   * Adds the {@code key, value} pair. If {@code key} already has values, {@code value} is added to
+   * the end. Duplicate values for the same key are permitted.
+   *
+   * @throws NullPointerException if key or value is null
+   */
+  public <T> void put(Key<T> key, T value) {
+    Preconditions.checkNotNull(key, "key");
+    Preconditions.checkNotNull(value, "value");
+    maybeExpand();
+    name(size, key.asciiName());
+    if (key.serializesToStreams()) {
+      value(size, LazyValue.create(key, value));
+    } else {
+      value(size, key.toBytes(value));
+    }
+    size++;
+  }
+
+  private void maybeExpand() {
+    if (len() == 0 || len() == cap()) {
+      expand(Math.max(len() * 2, 8));
+    }
+  }
+
+  // Expands to exactly the desired capacity.
+  private void expand(int newCapacity) {
+    Object[] newNamesAndValues = new Object[newCapacity];
+    if (!isEmpty()) {
+      System.arraycopy(namesAndValues, 0, newNamesAndValues, 0, len());
+    }
+    namesAndValues = newNamesAndValues;
+  }
+
+  /**
+   * Removes the first occurrence of {@code value} for {@code key}.
+   *
+   * @param key key for value
+   * @param value value
+   * @return {@code true} if {@code value} removed; {@code false} if {@code value} was not present
+   * @throws NullPointerException if {@code key} or {@code value} is null
+   */
+  public <T> boolean remove(Key<T> key, T value) {
+    Preconditions.checkNotNull(key, "key");
+    Preconditions.checkNotNull(value, "value");
+    for (int i = 0; i < size; i++) {
+      if (!bytesEqual(key.asciiName(), name(i))) {
+        continue;
+      }
+      T stored = valueAsT(i, key);
+      if (!value.equals(stored)) {
+        continue;
+      }
+      int writeIdx = i * 2;
+      int readIdx = (i + 1) * 2;
+      int readLen = len() - readIdx;
+      System.arraycopy(namesAndValues, readIdx, namesAndValues, writeIdx, readLen);
+      size -= 1;
+      name(size, null);
+      value(size, (byte[]) null);
+      return true;
+    }
+    return false;
+  }
+
+  /** Remove all values for the given key. If there were no values, {@code null} is returned. */
+  public <T> Iterable<T> removeAll(Key<T> key) {
+    if (isEmpty()) {
+      return null;
+    }
+    int writeIdx = 0;
+    int readIdx = 0;
+    List<T> ret = null;
+    for (; readIdx < size; readIdx++) {
+      if (bytesEqual(key.asciiName(), name(readIdx))) {
+        ret = ret != null ? ret : new ArrayList<T>();
+        ret.add(valueAsT(readIdx, key));
+        continue;
+      }
+      name(writeIdx, name(readIdx));
+      value(writeIdx, value(readIdx));
+      writeIdx++;
+    }
+    int newSize = writeIdx;
+    // Multiply by two since namesAndValues is interleaved.
+    Arrays.fill(namesAndValues, writeIdx * 2, len(), null);
+    size = newSize;
+    return ret;
+  }
+
+  /**
+   * Remove all values for the given key without returning them. This is a minor performance
+   * optimization if you do not need the previous values.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4691")
+  public <T> void discardAll(Key<T> key) {
+    if (isEmpty()) {
+      return;
+    }
+    int writeIdx = 0;
+    int readIdx = 0;
+    for (; readIdx < size; readIdx++) {
+      if (bytesEqual(key.asciiName(), name(readIdx))) {
+        continue;
+      }
+      name(writeIdx, name(readIdx));
+      value(writeIdx, value(readIdx));
+      writeIdx++;
+    }
+    int newSize = writeIdx;
+    // Multiply by two since namesAndValues is interleaved.
+    Arrays.fill(namesAndValues, writeIdx * 2, len(), null);
+    size = newSize;
+  }
+
+  /**
+   * Serialize all the metadata entries.
+   *
+   * <p>It produces serialized names and values interleaved. result[i*2] are names, while
+   * result[i*2+1] are values.
+   *
+   * <p>Names are ASCII string bytes that contains only the characters listed in the class comment
+   * of {@link Key}. If the name ends with {@code "-bin"}, the value can be raw binary. Otherwise,
+   * the value must contain only characters listed in the class comments of {@link AsciiMarshaller}
+   *
+   * <p>The returned individual byte arrays <em>must not</em> be modified. However, the top level
+   * array may be modified.
+   *
+   * <p>This method is intended for transport use only.
+   */
+  @Nullable
+  byte[][] serialize() {
+    byte[][] serialized = new byte[len()][];
+    if (namesAndValues instanceof byte[][]) {
+      System.arraycopy(namesAndValues, 0, serialized, 0, len());
+    } else {
+      for (int i = 0; i < size; i++) {
+        serialized[i * 2] = name(i);
+        serialized[i * 2 + 1] = valueAsBytes(i);
+      }
+    }
+    return serialized;
+  }
+
+  /**
+   * Serializes all metadata entries, leaving some values as {@link InputStream}s.
+   *
+   * <p>Produces serialized names and values interleaved. result[i*2] are names, while
+   * result[i*2+1] are values.
+   *
+   * <p>Names are byte arrays as described according to the {@link #serialize}
+   * method. Values are either byte arrays or {@link InputStream}s.
+   *
+   * <p>This method is intended for transport use only.
+   */
+  @Nullable
+  Object[] serializePartial() {
+    Object[] serialized = new Object[len()];
+    for (int i = 0; i < size; i++) {
+      serialized[i * 2] = name(i);
+      serialized[i * 2 + 1] = valueAsBytesOrStream(i);
+    }
+    return serialized;
+  }
+
+  /**
+   * Perform a simple merge of two sets of metadata.
+   *
+   * <p>This is a purely additive operation, because a single key can be associated with multiple
+   * values.
+   */
+  public void merge(Metadata other) {
+    if (other.isEmpty()) {
+      return;
+    }
+    int remaining = cap() - len();
+    if (isEmpty() || remaining < other.len()) {
+      expand(len() + other.len());
+    }
+    System.arraycopy(other.namesAndValues, 0, namesAndValues, len(), other.len());
+    size += other.size;
+  }
+
+  /**
+   * Merge values from the given set of keys into this set of metadata. If a key is present in keys,
+   * then all of the associated values will be copied over.
+   *
+   * @param other The source of the new key values.
+   * @param keys The subset of matching key we want to copy, if they exist in the source.
+   */
+  public void merge(Metadata other, Set<Key<?>> keys) {
+    Preconditions.checkNotNull(other, "other");
+    // Use ByteBuffer for equals and hashCode.
+    Map<ByteBuffer, Key<?>> asciiKeys = Maps.newHashMapWithExpectedSize(keys.size());
+    for (Key<?> key : keys) {
+      asciiKeys.put(ByteBuffer.wrap(key.asciiName()), key);
+    }
+    for (int i = 0; i < other.size; i++) {
+      ByteBuffer wrappedNamed = ByteBuffer.wrap(other.name(i));
+      if (asciiKeys.containsKey(wrappedNamed)) {
+        maybeExpand();
+        name(size, other.name(i));
+        value(size, other.value(i));
+        size++;
+      }
+    }
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder("Metadata(");
+    for (int i = 0; i < size; i++) {
+      if (i != 0) {
+        sb.append(',');
+      }
+      String headerName = new String(name(i), US_ASCII);
+      sb.append(headerName).append('=');
+      if (headerName.endsWith(BINARY_HEADER_SUFFIX)) {
+        sb.append(BASE64_ENCODING_OMIT_PADDING.encode(valueAsBytes(i)));
+      } else {
+        String headerValue = new String(valueAsBytes(i), US_ASCII);
+        sb.append(headerValue);
+      }
+    }
+    return sb.append(')').toString();
+  }
+
+  private boolean bytesEqual(byte[] left, byte[] right) {
+    return Arrays.equals(left, right);
+  }
+
+  /** Marshaller for metadata values that are serialized into raw binary. */
+  public interface BinaryMarshaller<T> {
+    /**
+     * Serialize a metadata value to bytes.
+     *
+     * @param value to serialize
+     * @return serialized version of value
+     */
+    byte[] toBytes(T value);
+
+    /**
+     * Parse a serialized metadata value from bytes.
+     *
+     * @param serialized value of metadata to parse
+     * @return a parsed instance of type T
+     */
+    T parseBytes(byte[] serialized);
+  }
+
+  /**
+   * Marshaller for metadata values that are serialized into ASCII strings. The strings contain only
+   * following characters:
+   *
+   * <ul>
+   * <li>Space: {@code 0x20}, but must not be at the beginning or at the end of the value. Leading
+   *     or trailing whitespace may not be preserved.
+   * <li>ASCII visible characters ({@code 0x21-0x7E}).
+   * </ul>
+   *
+   * <p>Note this has to be the subset of valid characters in {@code field-content} from RFC 7230
+   * Section 3.2.
+   */
+  public interface AsciiMarshaller<T> {
+    /**
+     * Serialize a metadata value to a ASCII string that contains only the characters listed in the
+     * class comment of {@link AsciiMarshaller}. Otherwise the output may be considered invalid and
+     * discarded by the transport, or the call may fail.
+     *
+     * @param value to serialize
+     * @return serialized version of value, or null if value cannot be transmitted.
+     */
+    String toAsciiString(T value);
+
+    /**
+     * Parse a serialized metadata value from an ASCII string.
+     *
+     * @param serialized value of metadata to parse
+     * @return a parsed instance of type T
+     */
+    T parseAsciiString(String serialized);
+  }
+
+  /** Marshaller for metadata values that are serialized to an InputStream. */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/6575")
+  public interface BinaryStreamMarshaller<T> {
+    /**
+     * Serializes a metadata value to an {@link InputStream}.
+     *
+     * @param value to serialize
+     * @return serialized version of value
+     */
+    InputStream toStream(T value);
+
+    /**
+     * Parses a serialized metadata value from an {@link InputStream}.
+     *
+     * @param stream of metadata to parse
+     * @return a parsed instance of type T
+     */
+    T parseStream(InputStream stream);
+  }
+
+  /**
+   * Key for metadata entries. Allows for parsing and serialization of metadata.
+   *
+   * <h3>Valid characters in key names</h3>
+   *
+   * <p>Only the following ASCII characters are allowed in the names of keys:
+   *
+   * <ul>
+   * <li>digits: {@code 0-9}
+   * <li>uppercase letters: {@code A-Z} (normalized to lower)
+   * <li>lowercase letters: {@code a-z}
+   * <li>special characters: {@code -_.}
+   * </ul>
+   *
+   * <p>This is a strict subset of the HTTP field-name rules. Applications may not send or receive
+   * metadata with invalid key names. However, the gRPC library may preserve any metadata received
+   * even if it does not conform to the above limitations. Additionally, if metadata contains non
+   * conforming field names, they will still be sent. In this way, unknown metadata fields are
+   * parsed, serialized and preserved, but never interpreted. They are similar to protobuf unknown
+   * fields.
+   *
+   * <p>Note this has to be the subset of valid HTTP/2 token characters as defined in RFC7230
+   * Section 3.2.6 and RFC5234 Section B.1
+   *
+   * <p>Note that a key is immutable but it may not be deeply immutable, because the key depends on
+   * its marshaller, and the marshaller can be mutable though not recommended.
+   *
+   * @see <a href="https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md">Wire Spec</a>
+   * @see <a href="https://tools.ietf.org/html/rfc7230#section-3.2.6">RFC7230</a>
+   * @see <a href="https://tools.ietf.org/html/rfc5234#appendix-B.1">RFC5234</a>
+   */
+  @Immutable
+  public abstract static class Key<T> {
+
+    /** Valid characters for field names as defined in RFC7230 and RFC5234. */
+    private static final BitSet VALID_T_CHARS = generateValidTChars();
+
+    /**
+     * Creates a key for a binary header.
+     *
+     * @param name Must contain only the valid key characters as defined in the class comment. Must
+     *     end with {@link #BINARY_HEADER_SUFFIX}.
+     */
+    public static <T> Key<T> of(String name, BinaryMarshaller<T> marshaller) {
+      return new BinaryKey<>(name, marshaller);
+    }
+
+    /**
+     * Creates a key for a binary header, serializing to input streams.
+     *
+     * @param name Must contain only the valid key characters as defined in the class comment. Must
+     *     end with {@link #BINARY_HEADER_SUFFIX}.
+     */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/6575")
+    public static <T> Key<T> of(String name, BinaryStreamMarshaller<T> marshaller) {
+      return new LazyStreamBinaryKey<>(name, marshaller);
+    }
+
+    /**
+     * Creates a key for an ASCII header.
+     *
+     * @param name Must contain only the valid key characters as defined in the class comment. Must
+     *     <b>not</b> end with {@link #BINARY_HEADER_SUFFIX}
+     */
+    public static <T> Key<T> of(String name, AsciiMarshaller<T> marshaller) {
+      return of(name, false, marshaller);
+    }
+
+    static <T> Key<T> of(String name, boolean pseudo, AsciiMarshaller<T> marshaller) {
+      return new AsciiKey<>(name, pseudo, marshaller);
+    }
+
+    static <T> Key<T> of(String name, boolean pseudo, TrustedAsciiMarshaller<T> marshaller) {
+      return new TrustedAsciiKey<>(name, pseudo, marshaller);
+    }
+
+    private final String originalName;
+
+    private final String name;
+    private final byte[] nameBytes;
+    private final Object marshaller;
+
+    private static BitSet generateValidTChars() {
+      BitSet valid = new BitSet(0x7f);
+      valid.set('-');
+      valid.set('_');
+      valid.set('.');
+      for (char c = '0'; c <= '9'; c++) {
+        valid.set(c);
+      }
+      // Only validates after normalization, so we exclude uppercase.
+      for (char c = 'a'; c <= 'z'; c++) {
+        valid.set(c);
+      }
+      return valid;
+    }
+
+    private static String validateName(String n, boolean pseudo) {
+      checkNotNull(n, "name");
+      checkArgument(!n.isEmpty(), "token must have at least 1 tchar");
+      if (n.equals("connection")) {
+        logger.log(
+            Level.WARNING,
+            "Metadata key is 'Connection', which should not be used. That is used by HTTP/1 for "
+            + "connection-specific headers which are not to be forwarded. There is probably an "
+            + "HTTP/1 conversion bug. Simply removing the Connection header is not enough; you "
+            + "should remove all headers it references as well. See RFC 7230 section 6.1",
+            new RuntimeException("exception to show backtrace"));
+      }
+      for (int i = 0; i < n.length(); i++) {
+        char tChar = n.charAt(i);
+        if (pseudo && tChar == ':' && i == 0) {
+          continue;
+        }
+
+        checkArgument(
+            VALID_T_CHARS.get(tChar), "Invalid character '%s' in key name '%s'", tChar, n);
+      }
+      return n;
+    }
+
+    private Key(String name, boolean pseudo, Object marshaller) {
+      this.originalName = checkNotNull(name, "name");
+      this.name = validateName(this.originalName.toLowerCase(Locale.ROOT), pseudo);
+      this.nameBytes = this.name.getBytes(US_ASCII);
+      this.marshaller = marshaller;
+    }
+
+    /**
+     * Returns the original name used to create this key.
+     */
+    public final String originalName() {
+      return originalName;
+    }
+
+    /**
+     * Returns the normalized name for this key.
+     */
+    public final String name() {
+      return name;
+    }
+
+    /**
+     * Get the name as bytes using ASCII-encoding.
+     *
+     * <p>The returned byte arrays <em>must not</em> be modified.
+     *
+     * <p>This method is intended for transport use only.
+     */
+    // TODO (louiscryan): Migrate to ByteString
+    @VisibleForTesting
+    byte[] asciiName() {
+      return nameBytes;
+    }
+
+    /**
+     * Returns true if the two objects are both Keys, and their names match (case insensitive).
+     */
+    @SuppressWarnings("EqualsGetClass")
+    @Override
+    public final boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      Key<?> key = (Key<?>) o;
+      return name.equals(key.name);
+    }
+
+    @Override
+    public final int hashCode() {
+      return name.hashCode();
+    }
+
+    @Override
+    public String toString() {
+      return "Key{name='" + name + "'}";
+    }
+
+    /**
+     * Serialize a metadata value to bytes.
+     *
+     * @param value to serialize
+     * @return serialized version of value
+     */
+    abstract byte[] toBytes(T value);
+
+    /**
+     * Parse a serialized metadata value from bytes.
+     *
+     * @param serialized value of metadata to parse
+     * @return a parsed instance of type T
+     */
+    abstract T parseBytes(byte[] serialized);
+
+    /**
+     * Returns whether this key will be serialized to bytes lazily.
+     */
+    boolean serializesToStreams() {
+      return false;
+    }
+
+    /**
+     * Gets this keys (implementation-specific) marshaller, or null if the
+     * marshaller is not of the given type.
+     *
+     * @param marshallerClass The type we expect the marshaller to be.
+     * @return the marshaller object for this key, or null.
+     */
+    @Nullable
+    final <M> M getMarshaller(Class<M> marshallerClass) {
+      if (marshallerClass.isInstance(marshaller)) {
+        return marshallerClass.cast(marshaller);
+      }
+      return null;
+    }
+  }
+
+  private static class BinaryKey<T> extends Key<T> {
+    private final BinaryMarshaller<T> marshaller;
+
+    /** Keys have a name and a binary marshaller used for serialization. */
+    private BinaryKey(String name, BinaryMarshaller<T> marshaller) {
+      super(name, false /* not pseudo */, marshaller);
+      checkArgument(
+          name.endsWith(BINARY_HEADER_SUFFIX),
+          "Binary header is named %s. It must end with %s",
+          name,
+          BINARY_HEADER_SUFFIX);
+      checkArgument(name.length() > BINARY_HEADER_SUFFIX.length(), "empty key name");
+      this.marshaller = checkNotNull(marshaller, "marshaller is null");
+    }
+
+    @Override
+    byte[] toBytes(T value) {
+      return Preconditions.checkNotNull(marshaller.toBytes(value), "null marshaller.toBytes()");
+    }
+
+    @Override
+    T parseBytes(byte[] serialized) {
+      return marshaller.parseBytes(serialized);
+    }
+  }
+
+  /** A binary key for values which should be serialized lazily to {@link InputStream}s. */
+  private static class LazyStreamBinaryKey<T> extends Key<T> {
+
+    private final BinaryStreamMarshaller<T> marshaller;
+
+    /** Keys have a name and a stream marshaller used for serialization. */
+    private LazyStreamBinaryKey(String name, BinaryStreamMarshaller<T> marshaller) {
+      super(name, false /* not pseudo */, marshaller);
+      checkArgument(
+          name.endsWith(BINARY_HEADER_SUFFIX),
+          "Binary header is named %s. It must end with %s",
+          name,
+          BINARY_HEADER_SUFFIX);
+      checkArgument(name.length() > BINARY_HEADER_SUFFIX.length(), "empty key name");
+      this.marshaller = checkNotNull(marshaller, "marshaller is null");
+    }
+
+    @Override
+    byte[] toBytes(T value) {
+      return streamToBytes(checkNotNull(marshaller.toStream(value), "null marshaller.toStream()"));
+    }
+
+    @Override
+    T parseBytes(byte[] serialized) {
+      return marshaller.parseStream(new ByteArrayInputStream(serialized));
+    }
+
+    @Override
+    boolean serializesToStreams() {
+      return true;
+    }
+  }
+
+  /** Internal holder for values which are serialized/de-serialized lazily. */
+  static final class LazyValue<T> {
+    private final BinaryStreamMarshaller<T> marshaller;
+    private final T value;
+    private volatile byte[] serialized;
+
+    static <T> LazyValue<T> create(Key<T> key, T value) {
+      return new LazyValue<>(checkNotNull(getBinaryStreamMarshaller(key)), value);
+    }
+
+    /** A value set by the application. */
+    LazyValue(BinaryStreamMarshaller<T> marshaller, T value) {
+      this.marshaller = marshaller;
+      this.value = value;
+    }
+
+    InputStream toStream() {
+      return checkNotNull(marshaller.toStream(value), "null marshaller.toStream()");
+    }
+
+    byte[] toBytes() {
+      if (serialized == null) {
+        synchronized (this) {
+          if (serialized == null) {
+            serialized = streamToBytes(toStream());
+          }
+        }
+      }
+      return serialized;
+    }
+
+    <T2> T2 toObject(Key<T2> key) {
+      if (key.serializesToStreams()) {
+        BinaryStreamMarshaller<T2> marshaller = getBinaryStreamMarshaller(key);
+        if (marshaller != null) {
+          return marshaller.parseStream(toStream());
+        }
+      }
+      return key.parseBytes(toBytes());
+    }
+
+    @Nullable
+    @SuppressWarnings("unchecked")
+    private static <T> BinaryStreamMarshaller<T> getBinaryStreamMarshaller(Key<T> key) {
+      return (BinaryStreamMarshaller<T>) key.getMarshaller(BinaryStreamMarshaller.class);
+    }
+  }
+
+  private static class AsciiKey<T> extends Key<T> {
+    private final AsciiMarshaller<T> marshaller;
+
+    /** Keys have a name and an ASCII marshaller used for serialization. */
+    private AsciiKey(String name, boolean pseudo, AsciiMarshaller<T> marshaller) {
+      super(name, pseudo, marshaller);
+      Preconditions.checkArgument(
+          !name.endsWith(BINARY_HEADER_SUFFIX),
+          "ASCII header is named %s.  Only binary headers may end with %s",
+          name,
+          BINARY_HEADER_SUFFIX);
+      this.marshaller = Preconditions.checkNotNull(marshaller, "marshaller");
+    }
+
+    @Override
+    byte[] toBytes(T value) {
+      String encoded = Preconditions.checkNotNull(
+          marshaller.toAsciiString(value), "null marshaller.toAsciiString()");
+      return encoded.getBytes(US_ASCII);
+    }
+
+    @Override
+    T parseBytes(byte[] serialized) {
+      return marshaller.parseAsciiString(new String(serialized, US_ASCII));
+    }
+  }
+
+  private static final class TrustedAsciiKey<T> extends Key<T> {
+    private final TrustedAsciiMarshaller<T> marshaller;
+
+    /** Keys have a name and an ASCII marshaller used for serialization. */
+    private TrustedAsciiKey(String name, boolean pseudo, TrustedAsciiMarshaller<T> marshaller) {
+      super(name, pseudo, marshaller);
+      Preconditions.checkArgument(
+          !name.endsWith(BINARY_HEADER_SUFFIX),
+          "ASCII header is named %s.  Only binary headers may end with %s",
+          name,
+          BINARY_HEADER_SUFFIX);
+      this.marshaller = Preconditions.checkNotNull(marshaller, "marshaller");
+    }
+
+    @Override
+    byte[] toBytes(T value) {
+      return Preconditions.checkNotNull(
+          marshaller.toAsciiString(value), "null marshaller.toAsciiString()");
+    }
+
+    @Override
+    T parseBytes(byte[] serialized) {
+      return marshaller.parseAsciiString(serialized);
+    }
+  }
+
+  /**
+   * A specialized plain ASCII marshaller. Both input and output are assumed to be valid header
+   * ASCII.
+   */
+  @Immutable
+  interface TrustedAsciiMarshaller<T> {
+    /**
+     * Serialize a metadata value to a ASCII string that contains only the characters listed in the
+     * class comment of {@link io.grpc.Metadata.AsciiMarshaller}. Otherwise the output may be
+     * considered invalid and discarded by the transport, or the call may fail.
+     *
+     * @param value to serialize
+     * @return serialized version of value, or null if value cannot be transmitted.
+     */
+    byte[] toAsciiString(T value);
+
+    /**
+     * Parse a serialized metadata value from an ASCII string.
+     *
+     * @param serialized value of metadata to parse
+     * @return a parsed instance of type T
+     */
+    T parseAsciiString(byte[] serialized);
+  }
+
+  private static byte[] streamToBytes(InputStream stream) {
+    try {
+      return ByteStreams.toByteArray(stream);
+    } catch (IOException ioe) {
+      throw new RuntimeException("failure reading serialized stream", ioe);
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/MethodDescriptor.java b/api/src/main/java/io/grpc/MethodDescriptor.java
new file mode 100644
index 00000000000..a02eb840deb
--- /dev/null
+++ b/api/src/main/java/io/grpc/MethodDescriptor.java
@@ -0,0 +1,629 @@
+/*
+ * Copyright 2014 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.CheckReturnValue;
+import java.io.InputStream;
+import java.util.concurrent.atomic.AtomicReferenceArray;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * Description of a remote method used by {@link Channel} to initiate a call.
+ *
+ * <p>Provides the name of the operation to execute as well as {@link Marshaller} instances
+ * used to parse and serialize request and response messages.
+ *
+ * <p>Can be constructed manually but will often be generated by stub code generators.
+ *
+ * @since 1.0.0
+ */
+@Immutable
+public final class MethodDescriptor<ReqT, RespT> {
+
+  private final MethodType type;
+  private final String fullMethodName;
+  @Nullable private final String serviceName;
+  private final Marshaller<ReqT> requestMarshaller;
+  private final Marshaller<RespT> responseMarshaller;
+  private final @Nullable Object schemaDescriptor;
+  private final boolean idempotent;
+  private final boolean safe;
+  private final boolean sampledToLocalTracing;
+
+  // Must be set to InternalKnownTransport.values().length
+  // Not referenced to break the dependency.
+  private final AtomicReferenceArray<Object> rawMethodNames = new AtomicReferenceArray<>(2);
+
+  /**
+   * Gets the cached "raw" method name for this Method Descriptor.  The raw name is transport
+   * specific, and should be set using {@link #setRawMethodName} by the transport.
+   *
+   * @param transportOrdinal the unique ID of the transport, given by
+   *        {@link InternalKnownTransport#ordinal}.
+   * @return a transport specific representation of the method name.
+   */
+  final Object getRawMethodName(int transportOrdinal) {
+    return rawMethodNames.get(transportOrdinal);
+  }
+
+  /**
+   * Safely, but weakly, sets the raw method name for this Method Descriptor.  This should only be
+   * called by the transport.  See {@link #getRawMethodName} for more detail.
+   */
+  final void setRawMethodName(int transportOrdinal, Object o) {
+    rawMethodNames.lazySet(transportOrdinal, o);
+  }
+
+  /**
+   * The call type of a method.
+   *
+   * @since 1.0.0
+   */
+  public enum MethodType {
+    /**
+     * One request message followed by one response message.
+     */
+    UNARY,
+
+    /**
+     * Zero or more request messages with one response message.
+     */
+    CLIENT_STREAMING,
+
+    /**
+     * One request message followed by zero or more response messages.
+     */
+    SERVER_STREAMING,
+
+    /**
+     * Zero or more request and response messages arbitrarily interleaved in time.
+     */
+    BIDI_STREAMING,
+
+    /**
+     * Cardinality and temporal relationships are not known. Implementations should not make
+     * buffering assumptions and should largely treat the same as {@link #BIDI_STREAMING}.
+     */
+    UNKNOWN;
+
+    /**
+     * Returns {@code true} for {@code UNARY} and {@code SERVER_STREAMING}, which do not permit the
+     * client to stream.
+     *
+     * @since 1.0.0
+     */
+    public final boolean clientSendsOneMessage() {
+      return this == UNARY || this == SERVER_STREAMING;
+    }
+
+    /**
+     * Returns {@code true} for {@code UNARY} and {@code CLIENT_STREAMING}, which do not permit the
+     * server to stream.
+     *
+     * @since 1.0.0
+     */
+    public final boolean serverSendsOneMessage() {
+      return this == UNARY || this == CLIENT_STREAMING;
+    }
+  }
+
+  /**
+   * A typed abstraction over message serialization and deserialization, a.k.a. marshalling and
+   * unmarshalling.
+   *
+   * <p>Stub implementations will define implementations of this interface for each of the request
+   * and response messages provided by a service.
+   *
+   * @param <T> type of serializable message
+   * @since 1.0.0
+   */
+  public interface Marshaller<T> {
+    /**
+     * Given a message, produce an {@link InputStream} for it so that it can be written to the wire.
+     * Where possible implementations should produce streams that are {@link io.grpc.KnownLength}
+     * to improve transport efficiency.
+     *
+     * @param value to serialize.
+     * @return serialized value as stream of bytes.
+     */
+    public InputStream stream(T value);
+
+    /**
+     * Given an {@link InputStream} parse it into an instance of the declared type so that it can be
+     * passed to application code.
+     *
+     * @param stream of bytes for serialized value
+     * @return parsed value
+     */
+    public T parse(InputStream stream);
+  }
+
+  /**
+   * A marshaller that supports retrieving its type parameter {@code T} at runtime.
+   *
+   * @since 1.1.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
+  public interface ReflectableMarshaller<T> extends Marshaller<T> {
+    /**
+     * Returns the {@code Class} that this marshaller serializes and deserializes. If inheritance is
+     * allowed, this is the base class or interface for all supported classes.
+     *
+     * @return non-{@code null} base class for all objects produced and consumed by this marshaller
+     */
+    public Class<T> getMessageClass();
+  }
+
+  /**
+   * A marshaller that uses a fixed instance of the type it produces.
+   *
+   * @since 1.1.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
+  public interface PrototypeMarshaller<T> extends ReflectableMarshaller<T> {
+    /**
+     * An instance of the expected message type, typically used as a schema and helper for producing
+     * other message instances. The {@code null} value may be a special value for the marshaller
+     * (like the equivalent of {@link Void}), so it is a valid return value. {@code null} does
+     * <em>not</em> mean "unsupported" or "unknown".
+     *
+     * <p>It is generally expected this would return the same instance each invocation, but it is
+     * not a requirement.
+     */
+    @Nullable
+    public T getMessagePrototype();
+  }
+
+  /**
+   * Creates a new {@code MethodDescriptor}.
+   *
+   * @param type the call type of this method
+   * @param fullMethodName the fully qualified name of this method
+   * @param requestMarshaller the marshaller used to encode and decode requests
+   * @param responseMarshaller the marshaller used to encode and decode responses
+   * @since 1.0.0
+   * @deprecated use {@link #newBuilder()}.
+   */
+  @Deprecated
+  public static <RequestT, ResponseT> MethodDescriptor<RequestT, ResponseT> create(
+      MethodType type, String fullMethodName,
+      Marshaller<RequestT> requestMarshaller,
+      Marshaller<ResponseT> responseMarshaller) {
+    return new MethodDescriptor<>(
+        type, fullMethodName, requestMarshaller, responseMarshaller, null, false, false, false);
+  }
+
+  private MethodDescriptor(
+      MethodType type,
+      String fullMethodName,
+      Marshaller<ReqT> requestMarshaller,
+      Marshaller<RespT> responseMarshaller,
+      Object schemaDescriptor,
+      boolean idempotent,
+      boolean safe,
+      boolean sampledToLocalTracing) {
+    assert !safe || idempotent : "safe should imply idempotent";
+    this.type = Preconditions.checkNotNull(type, "type");
+    this.fullMethodName = Preconditions.checkNotNull(fullMethodName, "fullMethodName");
+    this.serviceName = extractFullServiceName(fullMethodName);
+    this.requestMarshaller = Preconditions.checkNotNull(requestMarshaller, "requestMarshaller");
+    this.responseMarshaller = Preconditions.checkNotNull(responseMarshaller, "responseMarshaller");
+    this.schemaDescriptor = schemaDescriptor;
+    this.idempotent = idempotent;
+    this.safe = safe;
+    this.sampledToLocalTracing = sampledToLocalTracing;
+  }
+
+  /**
+   * The call type of the method.
+   *
+   * @since 1.0.0
+   */
+  public MethodType getType() {
+    return type;
+  }
+
+  /**
+   * The fully qualified name of the method.
+   *
+   * @since 1.0.0
+   */
+  public String getFullMethodName() {
+    return fullMethodName;
+  }
+
+  /**
+   * A convenience method for {@code extractFullServiceName(getFullMethodName())}.
+   *
+   * @since 1.21.0
+   */
+  @Nullable
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/5635")
+  public String getServiceName() {
+    return serviceName;
+  }
+
+  /**
+   * A convenience method for {@code extractBareMethodName(getFullMethodName())}.
+   *
+   * @since 1.33.0
+   */
+  @Nullable
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/5635")
+  public String getBareMethodName() {
+    return extractBareMethodName(fullMethodName);
+  }
+
+  /**
+   * Parse a response payload from the given {@link InputStream}.
+   *
+   * @param input stream containing response message to parse.
+   * @return parsed response message object.
+   * @since 1.0.0
+   */
+  public RespT parseResponse(InputStream input) {
+    return responseMarshaller.parse(input);
+  }
+
+  /**
+   * Convert a request message to an {@link InputStream}.
+   * The returned InputStream should be closed by the caller.
+   *
+   * @param requestMessage to serialize using the request {@link Marshaller}.
+   * @return serialized request message.
+   * @since 1.0.0
+   */
+  public InputStream streamRequest(ReqT requestMessage) {
+    return requestMarshaller.stream(requestMessage);
+  }
+
+  /**
+   * Parse an incoming request message.
+   *
+   * @param input the serialized message as a byte stream.
+   * @return a parsed instance of the message.
+   * @since 1.0.0
+   */
+  public ReqT parseRequest(InputStream input) {
+    return requestMarshaller.parse(input);
+  }
+
+  /**
+   * Serialize an outgoing response message.
+   * The returned InputStream should be closed by the caller.
+   *
+   * @param response the response message to serialize.
+   * @return the serialized message as a byte stream.
+   * @since 1.0.0
+   */
+  public InputStream streamResponse(RespT response) {
+    return responseMarshaller.stream(response);
+  }
+
+  /**
+   * Returns the marshaller for the request type. Allows introspection of the request marshaller.
+   *
+   * @since 1.1.0
+   */
+  public Marshaller<ReqT> getRequestMarshaller() {
+    return requestMarshaller;
+  }
+
+  /**
+   * Returns the marshaller for the response type. Allows introspection of the response marshaller.
+   *
+   * @since 1.1.0
+   */
+  public Marshaller<RespT> getResponseMarshaller() {
+    return responseMarshaller;
+  }
+
+  /**
+   * Returns the schema descriptor for this method. A schema descriptor is an object that is not
+   * used by gRPC core but includes information related to the service method. The type of the
+   * object is specific to the consumer, so both the code setting the schema descriptor and the code
+   * calling {@link #getSchemaDescriptor()} must coordinate.  For example, protobuf generated code
+   * sets this value, in order to be consumed by the server reflection service.  See also:
+   * {@code io.grpc.protobuf.ProtoMethodDescriptorSupplier}.
+   *
+   * @since 1.7.0
+   */
+  public @Nullable Object getSchemaDescriptor() {
+    return schemaDescriptor;
+  }
+
+  /**
+   * Returns whether this method is idempotent.
+   *
+   * @since 1.0.0
+   */
+  public boolean isIdempotent() {
+    return idempotent;
+  }
+
+  /**
+   * Returns whether this method is safe.
+   *
+   * <p>A safe request does nothing except retrieval so it has no side effects on the server side.
+   *
+   * @since 1.1.0
+   */
+  public boolean isSafe() {
+    return safe;
+  }
+
+  /**
+   * Returns whether RPCs for this method may be sampled into the local tracing store.
+   */
+  public boolean isSampledToLocalTracing() {
+    return sampledToLocalTracing;
+  }
+
+  /**
+   * Generate the fully qualified method name.  This matches the name
+   *
+   * @param fullServiceName the fully qualified service name that is prefixed with the package name
+   * @param methodName the short method name
+   * @since 1.0.0
+   */
+  public static String generateFullMethodName(String fullServiceName, String methodName) {
+    return checkNotNull(fullServiceName, "fullServiceName")
+        + "/"
+        + checkNotNull(methodName, "methodName");
+  }
+
+  /**
+   * Extract the fully qualified service name out of a fully qualified method name. May return
+   * {@code null} if the input is malformed, but you cannot rely on it for the validity of the
+   * input.
+   *
+   * @since 1.0.0
+   */
+  @Nullable
+  public static String extractFullServiceName(String fullMethodName) {
+    int index = checkNotNull(fullMethodName, "fullMethodName").lastIndexOf('/');
+    if (index == -1) {
+      return null;
+    }
+    return fullMethodName.substring(0, index);
+  }
+
+  /**
+   * Extract the method name out of a fully qualified method name. May return {@code null}
+   * if the input is malformed, but you cannot rely on it for the validity of the input.
+   *
+   * @since 1.33.0
+   */
+  @Nullable
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/5635")
+  public static String extractBareMethodName(String fullMethodName) {
+    int index = checkNotNull(fullMethodName, "fullMethodName").lastIndexOf('/');
+    if (index == -1) {
+      return null;
+    }
+    return fullMethodName.substring(index + 1);
+  }
+
+  /**
+   * Creates a new builder for a {@link MethodDescriptor}.
+   *
+   * @since 1.1.0
+   */
+  @CheckReturnValue
+  public static <ReqT, RespT> Builder<ReqT, RespT> newBuilder() {
+    return newBuilder(null, null);
+  }
+
+  /**
+   * Creates a new builder for a {@link MethodDescriptor}.
+   *
+   * @since 1.1.0
+   */
+  @CheckReturnValue
+  public static <ReqT, RespT> Builder<ReqT, RespT> newBuilder(
+      Marshaller<ReqT> requestMarshaller, Marshaller<RespT> responseMarshaller) {
+    return new Builder<ReqT, RespT>()
+        .setRequestMarshaller(requestMarshaller)
+        .setResponseMarshaller(responseMarshaller);
+  }
+
+  /**
+   * Turns this descriptor into a builder.
+   *
+   * @since 1.1.0
+   */
+  @CheckReturnValue
+  public Builder<ReqT, RespT> toBuilder() {
+    return toBuilder(requestMarshaller, responseMarshaller);
+  }
+
+  /**
+   * Turns this descriptor into a builder, replacing the request and response marshallers.
+   *
+   * @since 1.1.0
+   */
+  @CheckReturnValue
+  public <NewReqT, NewRespT> Builder<NewReqT, NewRespT> toBuilder(
+      Marshaller<NewReqT> requestMarshaller, Marshaller<NewRespT> responseMarshaller) {
+    return MethodDescriptor.<NewReqT, NewRespT>newBuilder()
+        .setRequestMarshaller(requestMarshaller)
+        .setResponseMarshaller(responseMarshaller)
+        .setType(type)
+        .setFullMethodName(fullMethodName)
+        .setIdempotent(idempotent)
+        .setSafe(safe)
+        .setSampledToLocalTracing(sampledToLocalTracing)
+        .setSchemaDescriptor(schemaDescriptor);
+  }
+
+  /**
+   * A builder for a {@link MethodDescriptor}.
+   *
+   * @since 1.1.0
+   */
+  public static final class Builder<ReqT, RespT> {
+
+    private Marshaller<ReqT> requestMarshaller;
+    private Marshaller<RespT> responseMarshaller;
+    private MethodType type;
+    private String fullMethodName;
+    private boolean idempotent;
+    private boolean safe;
+    private Object schemaDescriptor;
+    private boolean sampledToLocalTracing;
+
+    private Builder() {}
+
+    /**
+     * Sets the request marshaller.
+     *
+     * @param requestMarshaller the marshaller to use.
+     * @since 1.1.0
+     */
+    public Builder<ReqT, RespT> setRequestMarshaller(Marshaller<ReqT> requestMarshaller) {
+      this.requestMarshaller = requestMarshaller;
+      return this;
+    }
+
+    /**
+     * Sets the response marshaller.
+     *
+     * @param responseMarshaller the marshaller to use.
+     * @since 1.1.0
+     */
+    public Builder<ReqT, RespT> setResponseMarshaller(Marshaller<RespT> responseMarshaller) {
+      this.responseMarshaller = responseMarshaller;
+      return this;
+    }
+
+    /**
+     * Sets the method type.
+     *
+     * @param type the type of the method.
+     * @since 1.1.0
+     */
+    public Builder<ReqT, RespT> setType(MethodType type) {
+      this.type = type;
+      return this;
+    }
+
+    /**
+     * Sets the fully qualified (service and method) method name.
+     *
+     * @see MethodDescriptor#generateFullMethodName
+     * @since 1.1.0
+     */
+    public Builder<ReqT, RespT> setFullMethodName(String fullMethodName) {
+      this.fullMethodName = fullMethodName;
+      return this;
+    }
+
+    /**
+     * Sets the schema descriptor for this builder.  A schema descriptor is an object that is not
+     * used by gRPC core but includes information related to the methods. The type of the object
+     * is specific to the consumer, so both the code calling this and the code calling
+     * {@link MethodDescriptor#getSchemaDescriptor()} must coordinate.
+     *
+     * @param schemaDescriptor an object that describes the service structure.  Should be immutable.
+     * @since 1.7.0
+     */
+    public Builder<ReqT, RespT> setSchemaDescriptor(@Nullable Object schemaDescriptor) {
+      this.schemaDescriptor = schemaDescriptor;
+      return this;
+    }
+
+    /**
+     * Sets whether the method is idempotent.  If true, calling this method more than once doesn't
+     * have additional side effects. If {@code false}, method is also not safe. Note that implies
+     * calling {@code builder.setIdempotent(false).setIdempotent(true)} will leave {@code
+     * isSafe() == false}.
+     *
+     * @since 1.1.0
+     */
+    public Builder<ReqT, RespT> setIdempotent(boolean idempotent) {
+      this.idempotent = idempotent;
+      if (!idempotent) {
+        this.safe = false;
+      }
+      return this;
+    }
+
+    /**
+     * Sets whether this method is safe.  If true, calling this method any number of times doesn't
+     * have side effects. If {@code true}, method is also idempotent. Note that implies calling
+     * {@code builder.setSafe(true).setSafe(false)} will leave {@code isIdempotent() == true}.
+     *
+     * @since 1.1.0
+     */
+    public Builder<ReqT, RespT> setSafe(boolean safe) {
+      this.safe = safe;
+      if (safe) {
+        this.idempotent = true;
+      }
+      return this;
+    }
+
+    /**
+     * Sets whether RPCs for this method may be sampled into the local tracing store.  If true,
+     * sampled traces of this method may be kept in memory by tracing libraries.
+     *
+     * @since 1.8.0
+     */
+    public Builder<ReqT, RespT> setSampledToLocalTracing(boolean value) {
+      this.sampledToLocalTracing = value;
+      return this;
+    }
+
+    /**
+     * Builds the method descriptor.
+     *
+     * @since 1.1.0
+     */
+    @CheckReturnValue
+    public MethodDescriptor<ReqT, RespT> build() {
+      return new MethodDescriptor<>(
+          type,
+          fullMethodName,
+          requestMarshaller,
+          responseMarshaller,
+          schemaDescriptor,
+          idempotent,
+          safe,
+          sampledToLocalTracing);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+      .add("fullMethodName", fullMethodName)
+      .add("type", type)
+      .add("idempotent", idempotent)
+      .add("safe", safe)
+      .add("sampledToLocalTracing", sampledToLocalTracing)
+      .add("requestMarshaller", requestMarshaller)
+      .add("responseMarshaller", responseMarshaller)
+      .add("schemaDescriptor", schemaDescriptor)
+      .omitNullValues()
+      .toString();
+  }
+}
diff --git a/api/src/main/java/io/grpc/MetricInstrument.java b/api/src/main/java/io/grpc/MetricInstrument.java
new file mode 100644
index 00000000000..1930319060d
--- /dev/null
+++ b/api/src/main/java/io/grpc/MetricInstrument.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2024 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;
+
+import java.util.List;
+
+/**
+ * Represents a metric instrument. Metric instrument contains information used to describe a metric.
+ */
+@Internal
+public interface MetricInstrument {
+  /**
+   * Returns the unique index of this metric instrument.
+   *
+   * @return the index of the metric instrument.
+   */
+  public int getIndex();
+
+  /**
+   * Returns the name of the metric.
+   *
+   * @return the name of the metric.
+   */
+  public String getName();
+
+  /**
+   * Returns a description of the metric.
+   *
+   * @return a description of the metric.
+   */
+  public String getDescription();
+
+  /**
+   * Returns the unit of measurement for the metric.
+   *
+   * @return the unit of measurement.
+   */
+  public String getUnit();
+
+  /**
+   * Returns a list of required label keys for this metric instrument.
+   *
+   * @return a list of required label keys.
+   */
+  public List<String> getRequiredLabelKeys();
+
+  /**
+   * Returns a list of optional label keys for this metric instrument.
+   *
+   * @return a list of optional label keys.
+   */
+  public List<String> getOptionalLabelKeys();
+
+  /**
+   * Indicates whether this metric instrument is enabled by default.
+   *
+   * @return {@code true} if this metric instrument is enabled by default,
+   *         {@code false} otherwise.
+   */
+  public boolean isEnableByDefault();
+}
diff --git a/api/src/main/java/io/grpc/MetricInstrumentRegistry.java b/api/src/main/java/io/grpc/MetricInstrumentRegistry.java
new file mode 100644
index 00000000000..ce0f8f1b5cb
--- /dev/null
+++ b/api/src/main/java/io/grpc/MetricInstrumentRegistry.java
@@ -0,0 +1,317 @@
+/*
+ * Copyright 2024 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Strings;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * A registry for globally registered metric instruments.
+ */
+@Internal
+public final class MetricInstrumentRegistry {
+  static final int INITIAL_INSTRUMENT_CAPACITY = 5;
+  private static MetricInstrumentRegistry instance;
+  private final Object lock = new Object();
+  @GuardedBy("lock")
+  private final Set<String> registeredMetricNames = new HashSet<>();
+  @GuardedBy("lock")
+  private MetricInstrument[] metricInstruments =
+      new MetricInstrument[INITIAL_INSTRUMENT_CAPACITY];
+  @GuardedBy("lock")
+  private int nextAvailableMetricIndex;
+
+  @VisibleForTesting
+  MetricInstrumentRegistry() {}
+
+  /**
+   * Returns the default metric instrument registry.
+   */
+  public static synchronized MetricInstrumentRegistry getDefaultRegistry() {
+    if (instance == null) {
+      instance = new MetricInstrumentRegistry();
+    }
+    return instance;
+  }
+
+  /**
+   * Returns a list of registered metric instruments.
+   */
+  public List<MetricInstrument> getMetricInstruments() {
+    synchronized (lock) {
+      return Collections.unmodifiableList(
+          Arrays.asList(Arrays.copyOfRange(metricInstruments, 0, nextAvailableMetricIndex)));
+    }
+  }
+
+  /**
+   * Registers a new Double Counter metric instrument.
+   *
+   * @param name the name of the metric
+   * @param description a description of the metric
+   * @param unit the unit of measurement for the metric
+   * @param requiredLabelKeys a list of required label keys
+   * @param optionalLabelKeys a list of optional label keys
+   * @param enableByDefault whether the metric should be enabled by default
+   * @return the newly created DoubleCounterMetricInstrument
+   * @throws IllegalStateException if a metric with the same name already exists
+   */
+  public DoubleCounterMetricInstrument registerDoubleCounter(String name,
+      String description, String unit, List<String> requiredLabelKeys,
+      List<String> optionalLabelKeys, boolean enableByDefault) {
+    checkArgument(!Strings.isNullOrEmpty(name), "missing metric name");
+    checkNotNull(description, "description");
+    checkNotNull(unit, "unit");
+    checkNotNull(requiredLabelKeys, "requiredLabelKeys");
+    checkNotNull(optionalLabelKeys, "optionalLabelKeys");
+    synchronized (lock) {
+      if (registeredMetricNames.contains(name)) {
+        throw new IllegalStateException("Metric with name " + name + " already exists");
+      }
+      int index = nextAvailableMetricIndex;
+      if (index + 1 == metricInstruments.length) {
+        resizeMetricInstruments();
+      }
+      // TODO(dnvindhya): add limit for number of optional labels allowed
+      DoubleCounterMetricInstrument instrument = new DoubleCounterMetricInstrument(
+          index, name, description, unit, requiredLabelKeys, optionalLabelKeys,
+          enableByDefault);
+      metricInstruments[index] = instrument;
+      registeredMetricNames.add(name);
+      nextAvailableMetricIndex += 1;
+      return instrument;
+    }
+  }
+
+  /**
+   * Registers a new Long Counter metric instrument.
+   *
+   * @param name the name of the metric
+   * @param description a description of the metric
+   * @param unit the unit of measurement for the metric
+   * @param requiredLabelKeys a list of required label keys
+   * @param optionalLabelKeys a list of optional label keys
+   * @param enableByDefault whether the metric should be enabled by default
+   * @return the newly created LongCounterMetricInstrument
+   * @throws IllegalStateException if a metric with the same name already exists
+   */
+  public LongCounterMetricInstrument registerLongCounter(String name,
+      String description, String unit, List<String> requiredLabelKeys,
+      List<String> optionalLabelKeys, boolean enableByDefault) {
+    checkArgument(!Strings.isNullOrEmpty(name), "missing metric name");
+    checkNotNull(description, "description");
+    checkNotNull(unit, "unit");
+    checkNotNull(requiredLabelKeys, "requiredLabelKeys");
+    checkNotNull(optionalLabelKeys, "optionalLabelKeys");
+    synchronized (lock) {
+      if (registeredMetricNames.contains(name)) {
+        throw new IllegalStateException("Metric with name " + name + " already exists");
+      }
+      int index = nextAvailableMetricIndex;
+      if (index + 1 == metricInstruments.length) {
+        resizeMetricInstruments();
+      }
+      LongCounterMetricInstrument instrument = new LongCounterMetricInstrument(
+          index, name, description, unit, requiredLabelKeys, optionalLabelKeys,
+          enableByDefault);
+      metricInstruments[index] = instrument;
+      registeredMetricNames.add(name);
+      nextAvailableMetricIndex += 1;
+      return instrument;
+    }
+  }
+
+  /**
+   * Registers a new Long Up Down Counter metric instrument.
+   *
+   * @param name              the name of the metric
+   * @param description       a description of the metric
+   * @param unit              the unit of measurement for the metric
+   * @param requiredLabelKeys a list of required label keys
+   * @param optionalLabelKeys a list of optional label keys
+   * @param enableByDefault   whether the metric should be enabled by default
+   * @return the newly created LongUpDownCounterMetricInstrument
+   * @throws IllegalStateException if a metric with the same name already exists
+   */
+  public LongUpDownCounterMetricInstrument registerLongUpDownCounter(String name,
+                                                                     String description,
+                                                                     String unit,
+                                                                     List<String> requiredLabelKeys,
+                                                                     List<String> optionalLabelKeys,
+                                                                     boolean enableByDefault) {
+    checkArgument(!Strings.isNullOrEmpty(name), "missing metric name");
+    checkNotNull(description, "description");
+    checkNotNull(unit, "unit");
+    checkNotNull(requiredLabelKeys, "requiredLabelKeys");
+    checkNotNull(optionalLabelKeys, "optionalLabelKeys");
+    synchronized (lock) {
+      if (registeredMetricNames.contains(name)) {
+        throw new IllegalStateException("Metric with name " + name + " already exists");
+      }
+      int index = nextAvailableMetricIndex;
+      if (index + 1 == metricInstruments.length) {
+        resizeMetricInstruments();
+      }
+      LongUpDownCounterMetricInstrument instrument = new LongUpDownCounterMetricInstrument(
+          index, name, description, unit, requiredLabelKeys, optionalLabelKeys,
+          enableByDefault);
+      metricInstruments[index] = instrument;
+      registeredMetricNames.add(name);
+      nextAvailableMetricIndex += 1;
+      return instrument;
+    }
+  }
+
+  /**
+   * Registers a new Double Histogram metric instrument.
+   *
+   * @param name the name of the metric
+   * @param description a description of the metric
+   * @param unit the unit of measurement for the metric
+   * @param bucketBoundaries recommended set of explicit bucket boundaries for the histogram
+   * @param requiredLabelKeys a list of required label keys
+   * @param optionalLabelKeys a list of optional label keys
+   * @param enableByDefault whether the metric should be enabled by default
+   * @return the newly created DoubleHistogramMetricInstrument
+   * @throws IllegalStateException if a metric with the same name already exists
+   */
+  public DoubleHistogramMetricInstrument registerDoubleHistogram(String name,
+      String description, String unit, List<Double> bucketBoundaries,
+      List<String> requiredLabelKeys, List<String> optionalLabelKeys, boolean enableByDefault) {
+    checkArgument(!Strings.isNullOrEmpty(name), "missing metric name");
+    checkNotNull(description, "description");
+    checkNotNull(unit, "unit");
+    checkNotNull(bucketBoundaries, "bucketBoundaries");
+    checkNotNull(requiredLabelKeys, "requiredLabelKeys");
+    checkNotNull(optionalLabelKeys, "optionalLabelKeys");
+    synchronized (lock) {
+      if (registeredMetricNames.contains(name)) {
+        throw new IllegalStateException("Metric with name " + name + " already exists");
+      }
+      int index = nextAvailableMetricIndex;
+      if (index + 1 == metricInstruments.length) {
+        resizeMetricInstruments();
+      }
+      DoubleHistogramMetricInstrument instrument = new DoubleHistogramMetricInstrument(
+          index, name, description, unit, bucketBoundaries, requiredLabelKeys,
+          optionalLabelKeys,
+          enableByDefault);
+      metricInstruments[index] = instrument;
+      registeredMetricNames.add(name);
+      nextAvailableMetricIndex += 1;
+      return instrument;
+    }
+  }
+
+  /**
+   * Registers a new Long Histogram metric instrument.
+   *
+   * @param name the name of the metric
+   * @param description a description of the metric
+   * @param unit the unit of measurement for the metric
+   * @param bucketBoundaries recommended set of explicit bucket boundaries for the histogram
+   * @param requiredLabelKeys a list of required label keys
+   * @param optionalLabelKeys a list of optional label keys
+   * @param enableByDefault whether the metric should be enabled by default
+   * @return the newly created LongHistogramMetricInstrument
+   * @throws IllegalStateException if a metric with the same name already exists
+   */
+  public LongHistogramMetricInstrument registerLongHistogram(String name,
+      String description, String unit, List<Long> bucketBoundaries, List<String> requiredLabelKeys,
+      List<String> optionalLabelKeys, boolean enableByDefault) {
+    checkArgument(!Strings.isNullOrEmpty(name), "missing metric name");
+    checkNotNull(description, "description");
+    checkNotNull(unit, "unit");
+    checkNotNull(bucketBoundaries, "bucketBoundaries");
+    checkNotNull(requiredLabelKeys, "requiredLabelKeys");
+    checkNotNull(optionalLabelKeys, "optionalLabelKeys");
+    synchronized (lock) {
+      if (registeredMetricNames.contains(name)) {
+        throw new IllegalStateException("Metric with name " + name + " already exists");
+      }
+      int index = nextAvailableMetricIndex;
+      if (index + 1 == metricInstruments.length) {
+        resizeMetricInstruments();
+      }
+      LongHistogramMetricInstrument instrument = new LongHistogramMetricInstrument(
+          index, name, description, unit, bucketBoundaries, requiredLabelKeys,
+          optionalLabelKeys,
+          enableByDefault);
+      metricInstruments[index] = instrument;
+      registeredMetricNames.add(name);
+      nextAvailableMetricIndex += 1;
+      return instrument;
+    }
+  }
+
+
+  /**
+   * Registers a new Long Gauge metric instrument.
+   *
+   * @param name the name of the metric
+   * @param description a description of the metric
+   * @param unit the unit of measurement for the metric
+   * @param requiredLabelKeys a list of required label keys
+   * @param optionalLabelKeys a list of optional label keys
+   * @param enableByDefault whether the metric should be enabled by default
+   * @return the newly created LongGaugeMetricInstrument
+   * @throws IllegalStateException if a metric with the same name already exists
+   */
+  public LongGaugeMetricInstrument registerLongGauge(String name, String description,
+      String unit, List<String> requiredLabelKeys, List<String> optionalLabelKeys, boolean
+      enableByDefault) {
+    checkArgument(!Strings.isNullOrEmpty(name), "missing metric name");
+    checkNotNull(description, "description");
+    checkNotNull(unit, "unit");
+    checkNotNull(requiredLabelKeys, "requiredLabelKeys");
+    checkNotNull(optionalLabelKeys, "optionalLabelKeys");
+    synchronized (lock) {
+      if (registeredMetricNames.contains(name)) {
+        throw new IllegalStateException("Metric with name " + name + " already exists");
+      }
+      int index = nextAvailableMetricIndex;
+      if (index + 1 == metricInstruments.length) {
+        resizeMetricInstruments();
+      }
+      LongGaugeMetricInstrument instrument = new LongGaugeMetricInstrument(
+          index, name, description, unit, requiredLabelKeys, optionalLabelKeys,
+          enableByDefault);
+      metricInstruments[index] = instrument;
+      registeredMetricNames.add(name);
+      nextAvailableMetricIndex += 1;
+      return instrument;
+    }
+  }
+
+  @GuardedBy("lock")
+  private void resizeMetricInstruments() {
+    // Increase the capacity of the metricInstruments array by INITIAL_INSTRUMENT_CAPACITY
+    int newInstrumentsCapacity = metricInstruments.length + INITIAL_INSTRUMENT_CAPACITY;
+    MetricInstrument[] resizedMetricInstruments = Arrays.copyOf(metricInstruments,
+        newInstrumentsCapacity);
+    metricInstruments = resizedMetricInstruments;
+  }
+}
diff --git a/api/src/main/java/io/grpc/MetricRecorder.java b/api/src/main/java/io/grpc/MetricRecorder.java
new file mode 100644
index 00000000000..897c28011cd
--- /dev/null
+++ b/api/src/main/java/io/grpc/MetricRecorder.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright 2024 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import java.util.List;
+
+/**
+ * An interface used for recording gRPC metrics. Implementations of this interface are responsible
+ * for collecting and potentially reporting metrics from various gRPC components.
+ */
+@Internal
+public interface MetricRecorder {
+  /**
+   * Adds a value for a double-precision counter metric instrument.
+   *
+   * @param metricInstrument The counter metric instrument to add the value against.
+   * @param value The value to add.
+   * @param requiredLabelValues A list of required label values for the metric.
+   * @param optionalLabelValues A list of additional, optional label values for the metric.
+   */
+  default void addDoubleCounter(DoubleCounterMetricInstrument metricInstrument, double value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+    checkArgument(requiredLabelValues != null
+            && requiredLabelValues.size() == metricInstrument.getRequiredLabelKeys().size(),
+        "Incorrect number of required labels provided. Expected: %s",
+        metricInstrument.getRequiredLabelKeys().size());
+    checkArgument(optionalLabelValues != null
+            && optionalLabelValues.size() == metricInstrument.getOptionalLabelKeys().size(),
+        "Incorrect number of optional labels provided. Expected: %s",
+        metricInstrument.getOptionalLabelKeys().size());
+  }
+
+  /**
+   * Adds a value for a long valued counter metric instrument.
+   *
+   * @param metricInstrument The counter metric instrument to add the value against.
+   * @param value The value to add. MUST be non-negative.
+   * @param requiredLabelValues A list of required label values for the metric.
+   * @param optionalLabelValues A list of additional, optional label values for the metric.
+   */
+  default void addLongCounter(LongCounterMetricInstrument metricInstrument, long value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+    checkArgument(requiredLabelValues != null
+            && requiredLabelValues.size() == metricInstrument.getRequiredLabelKeys().size(),
+        "Incorrect number of required labels provided. Expected: %s",
+        metricInstrument.getRequiredLabelKeys().size());
+    checkArgument(optionalLabelValues != null
+            && optionalLabelValues.size() == metricInstrument.getOptionalLabelKeys().size(),
+        "Incorrect number of optional labels provided. Expected: %s",
+        metricInstrument.getOptionalLabelKeys().size());
+  }
+
+  /**
+   * Adds a value for a long valued up down counter metric instrument.
+   *
+   * @param metricInstrument    The counter metric instrument to add the value against.
+   * @param value               The value to add. May be positive, negative or zero.
+   * @param requiredLabelValues A list of required label values for the metric.
+   * @param optionalLabelValues A list of additional, optional label values for the metric.
+   */
+  default void addLongUpDownCounter(LongUpDownCounterMetricInstrument metricInstrument,
+                                    long value,
+                                    List<String> requiredLabelValues,
+                                    List<String> optionalLabelValues) {
+    checkArgument(requiredLabelValues != null
+            && requiredLabelValues.size() == metricInstrument.getRequiredLabelKeys().size(),
+        "Incorrect number of required labels provided. Expected: %s",
+        metricInstrument.getRequiredLabelKeys().size());
+    checkArgument(optionalLabelValues != null
+            && optionalLabelValues.size() == metricInstrument.getOptionalLabelKeys().size(),
+        "Incorrect number of optional labels provided. Expected: %s",
+        metricInstrument.getOptionalLabelKeys().size());
+  }
+
+
+  /**
+   * Records a value for a double-precision histogram metric instrument.
+   *
+   * @param metricInstrument The histogram metric instrument to record the value against.
+   * @param value The value to record.
+   * @param requiredLabelValues A list of required label values for the metric.
+   * @param optionalLabelValues A list of additional, optional label values for the metric.
+   */
+  default void recordDoubleHistogram(DoubleHistogramMetricInstrument metricInstrument, double value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+    checkArgument(requiredLabelValues != null
+            && requiredLabelValues.size() == metricInstrument.getRequiredLabelKeys().size(),
+        "Incorrect number of required labels provided. Expected: %s",
+        metricInstrument.getRequiredLabelKeys().size());
+    checkArgument(optionalLabelValues != null
+            && optionalLabelValues.size() == metricInstrument.getOptionalLabelKeys().size(),
+        "Incorrect number of optional labels provided. Expected: %s",
+        metricInstrument.getOptionalLabelKeys().size());
+  }
+
+  /**
+   * Records a value for a long valued histogram metric instrument.
+   *
+   * @param metricInstrument The histogram metric instrument to record the value against.
+   * @param value The value to record.
+   * @param requiredLabelValues A list of required label values for the metric.
+   * @param optionalLabelValues A list of additional, optional label values for the metric.
+   */
+  default void recordLongHistogram(LongHistogramMetricInstrument metricInstrument, long value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+    checkArgument(requiredLabelValues != null
+            && requiredLabelValues.size() == metricInstrument.getRequiredLabelKeys().size(),
+        "Incorrect number of required labels provided. Expected: %s",
+        metricInstrument.getRequiredLabelKeys().size());
+    checkArgument(optionalLabelValues != null
+            && optionalLabelValues.size() == metricInstrument.getOptionalLabelKeys().size(),
+        "Incorrect number of optional labels provided. Expected: %s",
+        metricInstrument.getOptionalLabelKeys().size());
+  }
+
+  /**
+   * Registers a callback to produce metric values for only the listed instruments. The returned
+   * registration must be closed when no longer needed, which will remove the callback.
+   *
+   * @param callback The callback to call to record.
+   * @param metricInstruments The metric instruments the callback will record against.
+   */
+  default Registration registerBatchCallback(BatchCallback callback,
+      CallbackMetricInstrument... metricInstruments) {
+    return () -> { };
+  }
+
+  /** Callback to record gauge values. */
+  interface BatchCallback {
+    /** Records instrument values into {@code recorder}. */
+    void accept(BatchRecorder recorder);
+  }
+
+  /** Recorder for instrument values produced by a batch callback. */
+  interface BatchRecorder {
+    /**
+     * Record a long gauge value.
+     *
+     * @param value The value to record.
+     * @param requiredLabelValues A list of required label values for the metric.
+     * @param optionalLabelValues A list of additional, optional label values for the metric.
+     */
+    default void recordLongGauge(LongGaugeMetricInstrument metricInstrument, long value,
+        List<String> requiredLabelValues, List<String> optionalLabelValues) {
+      checkArgument(requiredLabelValues != null
+              && requiredLabelValues.size() == metricInstrument.getRequiredLabelKeys().size(),
+          "Incorrect number of required labels provided. Expected: %s",
+          metricInstrument.getRequiredLabelKeys().size());
+      checkArgument(optionalLabelValues != null
+              && optionalLabelValues.size() == metricInstrument.getOptionalLabelKeys().size(),
+          "Incorrect number of optional labels provided. Expected: %s",
+          metricInstrument.getOptionalLabelKeys().size());
+    }
+  }
+
+  /** A handle to a registration, that allows unregistration. */
+  interface Registration extends AutoCloseable {
+    // Redefined to not throw an exception.
+    /** Unregister. */
+    @Override
+    void close();
+  }
+}
diff --git a/api/src/main/java/io/grpc/MetricSink.java b/api/src/main/java/io/grpc/MetricSink.java
new file mode 100644
index 00000000000..ce5d3822520
--- /dev/null
+++ b/api/src/main/java/io/grpc/MetricSink.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2024 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;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * An internal interface representing a receiver or aggregator of gRPC metrics data.
+ */
+@Internal
+public interface MetricSink {
+
+  /**
+   * Returns a set of names for the metrics that are currently enabled or disabled.
+   *
+   * @return A set of enabled metric names.
+   */
+  Map<String, Boolean> getEnabledMetrics();
+
+  /**
+   * Returns a set of optional label names for metrics that the sink actually wants.
+   *
+   * @return A set of optional label names.
+   */
+  Set<String> getOptionalLabels();
+
+  /**
+   * Returns size of metric measures used to record metric values. These measures are created
+   * based on registered metrics (via MetricInstrumentRegistry) and are ordered according to their
+   * registration sequence.
+   *
+   * @return Size of metric measures.
+   */
+  int getMeasuresSize();
+
+  /**
+   * Adds a value for a double-precision counter associated with specified metric instrument.
+   *
+   * @param metricInstrument The counter metric instrument identifies metric measure to add.
+   * @param value The value to record.
+   * @param requiredLabelValues A list of required label values for the metric.
+   * @param optionalLabelValues A list of additional, optional label values for the metric.
+   */
+  default void addDoubleCounter(DoubleCounterMetricInstrument metricInstrument, double value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+  }
+
+  /**
+   * Adds a value for a long valued counter metric associated with specified metric instrument.
+   *
+   * @param metricInstrument The counter metric instrument identifies metric measure to add.
+   * @param value The value to record. MUST be non-negative.
+   * @param requiredLabelValues A list of required label values for the metric.
+   * @param optionalLabelValues A list of additional, optional label values for the metric.
+   */
+  default void addLongCounter(LongCounterMetricInstrument metricInstrument, long value,
+                              List<String> requiredLabelValues, List<String> optionalLabelValues) {
+  }
+
+  /**
+   * Adds a value for a long valued up down counter metric associated with specified metric
+   * instrument.
+   *
+   * @param metricInstrument    The counter metric instrument identifies metric measure to add.
+   * @param value               The value to record. May be positive, negative or zero.
+   * @param requiredLabelValues A list of required label values for the metric.
+   * @param optionalLabelValues A list of additional, optional label values for the metric.
+   */
+  default void addLongUpDownCounter(LongUpDownCounterMetricInstrument metricInstrument, long value,
+                                    List<String> requiredLabelValues,
+                                    List<String> optionalLabelValues) {
+  }
+
+  /**
+   * Records a value for a double-precision histogram metric associated with specified metric
+   * instrument.
+   *
+   * @param metricInstrument The histogram metric instrument identifies metric measure to record.
+   * @param value The value to record.
+   * @param requiredLabelValues A list of required label values for the metric.
+   * @param optionalLabelValues A list of additional, optional label values for the metric.
+   */
+  default void recordDoubleHistogram(DoubleHistogramMetricInstrument metricInstrument, double value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+  }
+
+  /**
+   * Records a value for a long valued histogram metric associated with specified metric
+   * instrument.
+   *
+   * @param metricInstrument The histogram metric instrument identifies metric measure to record.
+   * @param value The value to record.
+   * @param requiredLabelValues A list of required label values for the metric.
+   * @param optionalLabelValues A list of additional, optional label values for the metric.
+   */
+  default void recordLongHistogram(LongHistogramMetricInstrument metricInstrument, long value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+  }
+
+  /**
+   * Record a long gauge value.
+   *
+   * @param value The value to record.
+   * @param requiredLabelValues A list of required label values for the metric.
+   * @param optionalLabelValues A list of additional, optional label values for the metric.
+   */
+  default void recordLongGauge(LongGaugeMetricInstrument metricInstrument, long value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues){
+  }
+
+  /**
+   * Registers a callback to produce metric values for only the listed instruments. The returned
+   * registration must be closed when no longer needed, which will remove the callback.
+   *
+   * @param callback The callback to call to record.
+   * @param metricInstruments The metric instruments the callback will record against.
+   */
+  default Registration registerBatchCallback(Runnable callback,
+      CallbackMetricInstrument... metricInstruments) {
+    return () -> { };
+  }
+
+  interface Registration extends MetricRecorder.Registration {}
+
+  void updateMeasures(List<MetricInstrument> instruments);
+}
diff --git a/api/src/main/java/io/grpc/NameResolver.java b/api/src/main/java/io/grpc/NameResolver.java
new file mode 100644
index 00000000000..53dbc5d6888
--- /dev/null
+++ b/api/src/main/java/io/grpc/NameResolver.java
@@ -0,0 +1,1040 @@
+/*
+ * Copyright 2015 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.MoreObjects.ToStringHelper;
+import com.google.common.base.Objects;
+import com.google.errorprone.annotations.InlineMe;
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.net.URI;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A pluggable component that resolves a target {@link URI} and return addresses to the caller.
+ *
+ * <p>A {@code NameResolver} uses the URI's scheme to determine whether it can resolve it, and uses
+ * the components after the scheme for actual resolution.
+ *
+ * <p>The addresses and attributes of a target may be changed over time, thus the caller registers a
+ * {@link Listener} to receive continuous updates.
+ *
+ * <p>A {@code NameResolver} does not need to automatically re-resolve on failure. Instead, the
+ * {@link Listener} is responsible for eventually (after an appropriate backoff period) invoking
+ * {@link #refresh()}.
+ *
+ * <p>Implementations <strong>don't need to be thread-safe</strong>.  All methods are guaranteed to
+ * be called sequentially.  Additionally, all methods that have side-effects, i.e.,
+ * {@link #start(Listener2)}, {@link #shutdown} and {@link #refresh} are called from the same
+ * {@link SynchronizationContext} as returned by {@link Args#getSynchronizationContext}. <strong>Do
+ * not block</strong> within the synchronization context; blocking I/O and time-consuming tasks
+ * should be offloaded to a separate thread, generally {@link Args#getOffloadExecutor}.
+ *
+ * @since 1.0.0
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
+public abstract class NameResolver {
+  /**
+   * Returns the authority used to authenticate connections to servers.  It <strong>must</strong> be
+   * from a trusted source, because if the authority is tampered with, RPCs may be sent to the
+   * attackers which may leak sensitive user data.
+   *
+   * <p>An implementation must generate it without blocking, typically in line, and
+   * <strong>must</strong> keep it unchanged. {@code NameResolver}s created from the same factory
+   * with the same argument must return the same authority.
+   *
+   * @since 1.0.0
+   */
+  public abstract String getServiceAuthority();
+
+  /**
+   * Starts the resolution. The method is not supposed to throw any exceptions. That might cause the
+   * Channel that the name resolver is serving to crash. Errors should be propagated
+   * through {@link Listener#onError}.
+   * 
+   * <p>An instance may not be started more than once, by any overload of this method, even after
+   * an intervening call to {@link #shutdown}.
+   *
+   * @param listener used to receive updates on the target
+   * @since 1.0.0
+   */
+  public void start(final Listener listener) {
+    if (listener instanceof Listener2) {
+      start((Listener2) listener);
+    } else {
+      start(new Listener2() {
+          @Override
+          public void onError(Status error) {
+            listener.onError(error);
+          }
+
+          @Override
+          public void onResult(ResolutionResult resolutionResult) {
+            StatusOr<List<EquivalentAddressGroup>> addressesOrError =
+                resolutionResult.getAddressesOrError();
+            if (addressesOrError.hasValue()) {
+              listener.onAddresses(addressesOrError.getValue(),
+                  resolutionResult.getAttributes());
+            } else {
+              listener.onError(addressesOrError.getStatus());
+            }
+          }
+      });
+    }
+  }
+
+  /**
+   * Starts the resolution. The method is not supposed to throw any exceptions. That might cause the
+   * Channel that the name resolver is serving to crash. Errors should be propagated
+   * through {@link Listener2#onError}.
+   * 
+   * <p>An instance may not be started more than once, by any overload of this method, even after
+   * an intervening call to {@link #shutdown}.
+   *
+   * @param listener used to receive updates on the target
+   * @since 1.21.0
+   */
+  public void start(Listener2 listener) {
+    start((Listener) listener);
+  }
+
+  /**
+   * Stops the resolution. Updates to the Listener will stop.
+   *
+   * @since 1.0.0
+   */
+  public abstract void shutdown();
+
+  /**
+   * Re-resolve the name.
+   *
+   * <p>Can only be called after {@link #start} has been called.
+   *
+   * <p>This is only a hint. Implementation takes it as a signal but may not start resolution
+   * immediately. It should never throw.
+   *
+   * <p>The default implementation is no-op.
+   *
+   * @since 1.0.0
+   */
+  public void refresh() {}
+
+  /**
+   * Factory that creates {@link NameResolver} instances.
+   *
+   * @since 1.0.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
+  public abstract static class Factory {
+    /**
+     * Creates a {@link NameResolver} for the given target URI, or {@code null} if the given URI
+     * cannot be resolved by this factory. The decision should be solely based on the scheme of the
+     * URI.
+     *
+     * <p>This method will eventually be deprecated and removed as part of a migration from {@code
+     * java.net.URI} to {@code io.grpc.Uri}. Implementations will override {@link
+     * #newNameResolver(Uri, Args)} instead.
+     *
+     * @param targetUri the target URI to be resolved, whose scheme must not be {@code null}
+     * @param args other information that may be useful
+     *
+     * @since 1.21.0
+     */
+    public abstract NameResolver newNameResolver(URI targetUri, final Args args);
+
+    /**
+     * Creates a {@link NameResolver} for the given target URI.
+     *
+     * <p>Implementations return {@code null} if 'targetUri' cannot be resolved by this factory. The
+     * decision should be solely based on the target's scheme.
+     *
+     * <p>All {@link NameResolver.Factory} implementations should override this method, as it will
+     * eventually replace {@link #newNameResolver(URI, Args)}. For backwards compatibility, this
+     * default implementation delegates to {@link #newNameResolver(URI, Args)} if 'targetUri' can be
+     * converted to a java.net.URI.
+     *
+     * <p>NB: Conversion is not always possible, for example {@code scheme:#frag} is a valid {@link
+     * Uri} but not a valid {@link URI} because its path is empty. The default implementation throws
+     * IllegalArgumentException in these cases.
+     *
+     * @param targetUri the target URI to be resolved
+     * @param args other information that may be useful
+     * @throws IllegalArgumentException if targetUri does not have the expected form
+     * @since 1.79
+     */
+    public NameResolver newNameResolver(Uri targetUri, final Args args) {
+      // Not every io.grpc.Uri can be converted but in the ordinary ManagedChannel creation flow,
+      // any IllegalArgumentException thrown here would happened anyway, just earlier. That's
+      // because parse/toString is transparent so java.net.URI#create here sees the original target
+      // string just like it did before the io.grpc.Uri migration.
+      //
+      // Throwing IAE shouldn't surprise non-framework callers either. After all, many existing
+      // Factory impls are picky about targetUri and throw IAE when it doesn't look how they expect.
+      return newNameResolver(URI.create(targetUri.toString()), args);
+    }
+
+    /**
+     * Returns the default scheme, which will be used to construct a URI when {@link
+     * ManagedChannelBuilder#forTarget(String)} is given an authority string instead of a compliant
+     * URI.
+     *
+     * @since 1.0.0
+     */
+    public abstract String getDefaultScheme();
+  }
+
+  /**
+   * Receives address updates.
+   *
+   * <p>All methods are expected to return quickly.
+   *
+   * @since 1.0.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
+  @ThreadSafe
+  public interface Listener {
+    /**
+     * Handles updates on resolved addresses and attributes.
+     *
+     * <p>Implementations will not modify the given {@code servers}.
+     *
+     * @param servers the resolved server addresses. An empty list will trigger {@link #onError}
+     * @param attributes extra information from naming system.
+     * @since 1.3.0
+     */
+    void onAddresses(
+        List<EquivalentAddressGroup> servers, @ResolutionResultAttr Attributes attributes);
+
+    /**
+     * Handles an error from the resolver. The listener is responsible for eventually invoking
+     * {@link #refresh()} to re-attempt resolution.
+     *
+     * @param error a non-OK status
+     * @since 1.0.0
+     */
+    void onError(Status error);
+  }
+
+  /**
+   * Receives address updates.
+   *
+   * <p>All methods are expected to return quickly.
+   *
+   * <p>This is a replacement API of {@code Listener}. However, we think this new API may change
+   * again, so we aren't yet encouraging mass-migration to it. It is fine to use and works.
+   *
+   * @since 1.21.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
+  public abstract static class Listener2 implements Listener {
+    /**
+     * Handles updates on resolved addresses and attributes.
+     *
+     * @deprecated This will be removed in 1.22.0
+     */
+    @Override
+    @Deprecated
+    @InlineMe(
+        replacement = "this.onResult(ResolutionResult.newBuilder().setAddressesOrError("
+            + "StatusOr.fromValue(servers)).setAttributes(attributes).build())",
+        imports = {"io.grpc.NameResolver.ResolutionResult", "io.grpc.StatusOr"})
+    public final void onAddresses(
+        List<EquivalentAddressGroup> servers, @ResolutionResultAttr Attributes attributes) {
+      // TODO(jihuncho) need to promote Listener2 if we want to use ConfigOrError
+      // Calling onResult and not onResult2 because onResult2 can only be called from a
+      // synchronization context.
+      onResult(
+          ResolutionResult.newBuilder().setAddressesOrError(
+              StatusOr.fromValue(servers)).setAttributes(attributes).build());
+    }
+
+    /**
+     * Handles updates on resolved addresses and attributes.  If
+     * {@link ResolutionResult#getAddressesOrError()} is empty, {@link #onError(Status)} will be
+     * called.
+     *
+     * <p>Newer NameResolver implementations should prefer calling onResult2. This method exists to
+     * facilitate older {@link Listener} implementations to migrate to {@link Listener2}.
+     *
+     * @param resolutionResult the resolved server addresses, attributes, and Service Config.
+     * @since 1.21.0
+     */
+    public abstract void onResult(ResolutionResult resolutionResult);
+
+    /**
+     * Handles a name resolving error from the resolver. The listener is responsible for eventually
+     * invoking {@link NameResolver#refresh()} to re-attempt resolution.
+     *
+     * <p>New NameResolver implementations should prefer calling onResult2 which will have the
+     * address resolution error in {@link ResolutionResult}'s addressesOrError. This method exists
+     * to facilitate older implementations using {@link Listener} to migrate to {@link Listener2}.
+     *
+     * @param error a non-OK status
+     * @since 1.21.0
+     */
+    @Override
+    public abstract void onError(Status error);
+
+    /**
+     * Handles updates on resolved addresses and attributes. Must be called from the same
+     * {@link SynchronizationContext} available in {@link NameResolver.Args} that is passed
+     * from the channel.
+     *
+     * @param resolutionResult the resolved server addresses or error in address resolution,
+     *     attributes, and Service Config or error
+     * @return status indicating whether the resolutionResult was accepted by the listener,
+     *     typically the result from a load balancer.
+     * @since 1.66
+     */
+    public Status onResult2(ResolutionResult resolutionResult) {
+      onResult(resolutionResult);
+      return Status.OK;
+    }
+  }
+
+  /**
+   * Annotation for name resolution result attributes. It follows the annotation semantics defined
+   * by {@link Attributes}.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4972")
+  @Retention(RetentionPolicy.SOURCE)
+  @Documented
+  public @interface ResolutionResultAttr {}
+
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11989")
+  @ResolutionResultAttr
+  public static final Attributes.Key<String> ATTR_BACKEND_SERVICE =
+      Attributes.Key.create("io.grpc.NameResolver.ATTR_BACKEND_SERVICE");
+
+  /**
+   * Information that a {@link Factory} uses to create a {@link NameResolver}.
+   *
+   * <p>Args applicable to all {@link NameResolver}s are defined here using ordinary setters and
+   * getters. This container can also hold externally-defined "custom" args that aren't so widely
+   * useful or that would be inappropriate dependencies for this low level API. See {@link
+   * Args#getArg} for more.
+   *
+   * <p>Note this class overrides neither {@code equals()} nor {@code hashCode()}.
+   *
+   * @since 1.21.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
+  public static final class Args {
+    private final int defaultPort;
+    private final ProxyDetector proxyDetector;
+    private final SynchronizationContext syncContext;
+    private final ServiceConfigParser serviceConfigParser;
+    @Nullable private final ScheduledExecutorService scheduledExecutorService;
+    @Nullable private final ChannelLogger channelLogger;
+    @Nullable private final Executor executor;
+    @Nullable private final String overrideAuthority;
+    @Nullable private final MetricRecorder metricRecorder;
+    @Nullable private final NameResolverRegistry nameResolverRegistry;
+    @Nullable private final IdentityHashMap<Key<?>, Object> customArgs;
+
+    private Args(Builder builder) {
+      this.defaultPort = checkNotNull(builder.defaultPort, "defaultPort not set");
+      this.proxyDetector = checkNotNull(builder.proxyDetector, "proxyDetector not set");
+      this.syncContext = checkNotNull(builder.syncContext, "syncContext not set");
+      this.serviceConfigParser =
+          checkNotNull(builder.serviceConfigParser, "serviceConfigParser not set");
+      this.scheduledExecutorService = builder.scheduledExecutorService;
+      this.channelLogger = builder.channelLogger;
+      this.executor = builder.executor;
+      this.overrideAuthority = builder.overrideAuthority;
+      this.metricRecorder = builder.metricRecorder;
+      this.nameResolverRegistry = builder.nameResolverRegistry;
+      this.customArgs = cloneCustomArgs(builder.customArgs);
+    }
+
+    /**
+     * The port number used in case the target or the underlying naming system doesn't provide a
+     * port number.
+     *
+     * @since 1.21.0
+     */
+    // <p>TODO: Only meaningful for InetSocketAddress producers. Make this a custom arg?
+    public int getDefaultPort() {
+      return defaultPort;
+    }
+
+    /**
+     * If the NameResolver wants to support proxy, it should inquire this {@link ProxyDetector}.
+     * See documentation on {@link ProxyDetector} about how proxies work in gRPC.
+     *
+     * @since 1.21.0
+     */
+    public ProxyDetector getProxyDetector() {
+      return proxyDetector;
+    }
+
+    /**
+     * Returns the {@link SynchronizationContext} where {@link #start(Listener2)}, {@link #shutdown}
+     * and {@link #refresh} are run from.
+     *
+     * @since 1.21.0
+     */
+    public SynchronizationContext getSynchronizationContext() {
+      return syncContext;
+    }
+
+    /**
+     * Returns a {@link ScheduledExecutorService} for scheduling delayed tasks.
+     *
+     * <p>This service is a shared resource and is only meant for quick tasks. DO NOT block or run
+     * time-consuming tasks.
+     *
+     * <p>The returned service doesn't support {@link ScheduledExecutorService#shutdown shutdown()}
+     *  and {@link ScheduledExecutorService#shutdownNow shutdownNow()}. They will throw if called.
+     *
+     * @since 1.26.0
+     */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/6454")
+    public ScheduledExecutorService getScheduledExecutorService() {
+      if (scheduledExecutorService == null) {
+        throw new IllegalStateException("ScheduledExecutorService not set in Builder");
+      }
+      return scheduledExecutorService;
+    }
+
+    /**
+     * Returns the {@link ServiceConfigParser}.
+     *
+     * @since 1.21.0
+     */
+    public ServiceConfigParser getServiceConfigParser() {
+      return serviceConfigParser;
+    }
+
+    /**
+     * Returns the value of a custom arg named 'key', or {@code null} if it's not set.
+     *
+     * <p>While ordinary {@link Args} should be universally useful and meaningful, custom arguments
+     * can apply just to resolvers of a certain URI scheme, just to resolvers producing a particular
+     * type of {@link java.net.SocketAddress}, or even an individual {@link NameResolver} subclass.
+     * Custom args are identified by an instance of {@link Args.Key} which should be a constant
+     * defined in a java package and class appropriate for the argument's scope.
+     *
+     * <p>{@link Args} are normally reserved for information in *support* of name resolution, not
+     * the name to be resolved itself. However, there are rare cases where all or part of the target
+     * name can't be represented by any standard URI scheme or can't be encoded as a String at all.
+     * Custom args, in contrast, can hold arbitrary Java types, making them a useful work around in
+     * these cases.
+     *
+     * <p>Custom args can also be used simply to avoid adding inappropriate deps to the low level
+     * io.grpc package.
+     */
+    @SuppressWarnings("unchecked") // Cast is safe because all put()s go through the setArg() API.
+    @Nullable
+    public <T> T getArg(Key<T> key) {
+      return customArgs != null ? (T) customArgs.get(key) : null;
+    }
+
+    /**
+     * Returns the {@link ChannelLogger} for the Channel served by this NameResolver.
+     *
+     * @since 1.26.0
+     */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/6438")
+    public ChannelLogger getChannelLogger() {
+      if (channelLogger == null) {
+        throw new IllegalStateException("ChannelLogger is not set in Builder");
+      }
+      return channelLogger;
+    }
+
+    /**
+     * Returns the Executor on which this resolver should execute long-running or I/O bound work.
+     * Null if no Executor was set.
+     *
+     * @since 1.25.0
+     */
+    @Nullable
+    public Executor getOffloadExecutor() {
+      return executor;
+    }
+
+    /**
+     * Returns the overrideAuthority from channel {@link ManagedChannelBuilder#overrideAuthority}.
+     * Overrides the host name for L7 HTTP virtual host matching. Almost all name resolvers should
+     * not use this.
+     *
+     * @since 1.49.0
+     */
+    @Nullable
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/9406")
+    public String getOverrideAuthority() {
+      return overrideAuthority;
+    }
+
+    /**
+     * Returns the {@link MetricRecorder} that the channel uses to record metrics.
+     */
+    @Nullable
+    public MetricRecorder getMetricRecorder() {
+      return metricRecorder;
+    }
+
+    /**
+     * Returns the {@link NameResolverRegistry} that the Channel uses to look for {@link
+     * NameResolver}s.
+     *
+     * @since 1.74.0
+     */
+    public NameResolverRegistry getNameResolverRegistry() {
+      if (nameResolverRegistry == null) {
+        throw new IllegalStateException("NameResolverRegistry is not set in Builder");
+      }
+      return nameResolverRegistry;
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("defaultPort", defaultPort)
+          .add("proxyDetector", proxyDetector)
+          .add("syncContext", syncContext)
+          .add("serviceConfigParser", serviceConfigParser)
+          .add("customArgs", customArgs)
+          .add("scheduledExecutorService", scheduledExecutorService)
+          .add("channelLogger", channelLogger)
+          .add("executor", executor)
+          .add("overrideAuthority", overrideAuthority)
+          .add("metricRecorder", metricRecorder)
+          .add("nameResolverRegistry", nameResolverRegistry)
+          .toString();
+    }
+
+    /**
+     * Returns a builder with the same initial values as this object.
+     *
+     * @since 1.21.0
+     */
+    public Builder toBuilder() {
+      Builder builder = new Builder();
+      builder.setDefaultPort(defaultPort);
+      builder.setProxyDetector(proxyDetector);
+      builder.setSynchronizationContext(syncContext);
+      builder.setServiceConfigParser(serviceConfigParser);
+      builder.setScheduledExecutorService(scheduledExecutorService);
+      builder.setChannelLogger(channelLogger);
+      builder.setOffloadExecutor(executor);
+      builder.setOverrideAuthority(overrideAuthority);
+      builder.setMetricRecorder(metricRecorder);
+      builder.setNameResolverRegistry(nameResolverRegistry);
+      builder.customArgs = cloneCustomArgs(customArgs);
+      return builder;
+    }
+
+    /**
+     * Creates a new builder.
+     *
+     * @since 1.21.0
+     */
+    public static Builder newBuilder() {
+      return new Builder();
+    }
+
+    /**
+     * Builder for {@link Args}.
+     *
+     * @since 1.21.0
+     */
+    public static final class Builder {
+      private Integer defaultPort;
+      private ProxyDetector proxyDetector;
+      private SynchronizationContext syncContext;
+      private ServiceConfigParser serviceConfigParser;
+      private ScheduledExecutorService scheduledExecutorService;
+      private ChannelLogger channelLogger;
+      private Executor executor;
+      private String overrideAuthority;
+      private MetricRecorder metricRecorder;
+      private NameResolverRegistry nameResolverRegistry;
+      private IdentityHashMap<Key<?>, Object> customArgs;
+
+      Builder() {
+      }
+
+      /**
+       * See {@link Args#getDefaultPort}.  This is a required field.
+       *
+       * @since 1.21.0
+       */
+      public Builder setDefaultPort(int defaultPort) {
+        this.defaultPort = defaultPort;
+        return this;
+      }
+
+      /**
+       * See {@link Args#getProxyDetector}.  This is required field.
+       *
+       * @since 1.21.0
+       */
+      public Builder setProxyDetector(ProxyDetector proxyDetector) {
+        this.proxyDetector = checkNotNull(proxyDetector);
+        return this;
+      }
+
+      /**
+       * See {@link Args#getSynchronizationContext}.  This is a required field.
+       *
+       * @since 1.21.0
+       */
+      public Builder setSynchronizationContext(SynchronizationContext syncContext) {
+        this.syncContext = checkNotNull(syncContext);
+        return this;
+      }
+
+      /**
+       * See {@link Args#getScheduledExecutorService}.
+       */
+      @ExperimentalApi("https://github.com/grpc/grpc-java/issues/6454")
+      public Builder setScheduledExecutorService(
+          ScheduledExecutorService scheduledExecutorService) {
+        this.scheduledExecutorService = checkNotNull(scheduledExecutorService);
+        return this;
+      }
+
+      /**
+       * See {@link Args#getServiceConfigParser}.  This is a required field.
+       *
+       * @since 1.21.0
+       */
+      public Builder setServiceConfigParser(ServiceConfigParser parser) {
+        this.serviceConfigParser = checkNotNull(parser);
+        return this;
+      }
+
+      /**
+       * See {@link Args#getChannelLogger}.
+       *
+       * @since 1.26.0
+       */
+      @ExperimentalApi("https://github.com/grpc/grpc-java/issues/6438")
+      public Builder setChannelLogger(ChannelLogger channelLogger) {
+        this.channelLogger = checkNotNull(channelLogger);
+        return this;
+      }
+
+      /**
+       * See {@link Args#getOffloadExecutor}. This is an optional field.
+       *
+       * @since 1.25.0
+       */
+      public Builder setOffloadExecutor(Executor executor) {
+        this.executor = executor;
+        return this;
+      }
+
+      /**
+       * See {@link Args#getOverrideAuthority()}. This is an optional field.
+       *
+       * @since 1.49.0
+       */
+      @ExperimentalApi("https://github.com/grpc/grpc-java/issues/9406")
+      public Builder setOverrideAuthority(String authority) {
+        this.overrideAuthority = authority;
+        return this;
+      }
+
+      /** See {@link Args#getArg(Key)}. */
+      public <T> Builder setArg(Key<T> key, T value) {
+        checkNotNull(key, "key");
+        checkNotNull(value, "value");
+        if (customArgs == null) {
+          customArgs = new IdentityHashMap<>();
+        }
+        customArgs.put(key, value);
+        return this;
+      }
+
+      /**
+       * See {@link Args#getMetricRecorder()}. This is an optional field.
+       */
+      public Builder setMetricRecorder(MetricRecorder metricRecorder) {
+        this.metricRecorder = metricRecorder;
+        return this;
+      }
+
+      /**
+       * See {@link Args#getNameResolverRegistry}.  This is an optional field.
+       *
+       * @since 1.74.0
+       */
+      public Builder setNameResolverRegistry(NameResolverRegistry registry) {
+        this.nameResolverRegistry = registry;
+        return this;
+      }
+
+      /**
+       * Builds an {@link Args}.
+       *
+       * @since 1.21.0
+       */
+      public Args build() {
+        return new Args(this);
+      }
+    }
+
+    /**
+     * Identifies an externally-defined custom argument that can be stored in {@link Args}.
+     *
+     * <p>Uses reference equality so keys should be defined as global constants.
+     *
+     * @param <T> type of values that can be stored under this key
+     */
+    @Immutable
+    @SuppressWarnings("UnusedTypeParameter")
+    public static final class Key<T> {
+      private final String debugString;
+
+      private Key(String debugString) {
+        this.debugString = debugString;
+      }
+
+      @Override
+      public String toString() {
+        return debugString;
+      }
+
+      /**
+       * Creates a new instance of {@link Key}.
+       *
+       * @param debugString a string used to describe the key, used for debugging.
+       * @param <T> Key type
+       * @return a new instance of Key
+       */
+      public static <T> Key<T> create(String debugString) {
+        return new Key<>(debugString);
+      }
+    }
+  }
+
+  /**
+   * Parses and validates service configuration.
+   *
+   * @since 1.21.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
+  public abstract static class ServiceConfigParser {
+    /**
+     * Parses and validates the service configuration chosen by the name resolver.  This will
+     * return a {@link ConfigOrError} which contains either the successfully parsed config, or the
+     * {@link Status} representing the failure to parse.  Implementations are expected to not throw
+     * exceptions but return a Status representing the failure.  The value inside the
+     * {@link ConfigOrError} should implement {@code equals()} and {@code hashCode()}.
+     *
+     * @param rawServiceConfig The {@link Map} representation of the service config
+     * @return a tuple of the fully parsed and validated channel configuration, else the Status.
+     * @since 1.21.0
+     */
+    public abstract ConfigOrError parseServiceConfig(Map<String, ?> rawServiceConfig);
+  }
+
+  /**
+   * Represents the results from a Name Resolver.
+   *
+   * @since 1.21.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
+  public static final class ResolutionResult {
+    private final StatusOr<List<EquivalentAddressGroup>> addressesOrError;
+    @ResolutionResultAttr
+    private final Attributes attributes;
+    @Nullable
+    private final ConfigOrError serviceConfig;
+
+    ResolutionResult(
+        StatusOr<List<EquivalentAddressGroup>> addressesOrError,
+        @ResolutionResultAttr Attributes attributes,
+        ConfigOrError serviceConfig) {
+      this.addressesOrError = addressesOrError;
+      this.attributes = checkNotNull(attributes, "attributes");
+      this.serviceConfig = serviceConfig;
+    }
+
+    /**
+     * Constructs a new builder of a name resolution result.
+     *
+     * @since 1.21.0
+     */
+    public static Builder newBuilder() {
+      return new Builder();
+    }
+
+    /**
+     * Converts these results back to a builder.
+     *
+     * @since 1.21.0
+     */
+    public Builder toBuilder() {
+      return newBuilder()
+          .setAddressesOrError(addressesOrError)
+          .setAttributes(attributes)
+          .setServiceConfig(serviceConfig);
+    }
+
+    /**
+     * Gets the addresses resolved by name resolution.
+     *
+     * @since 1.21.0
+     * @deprecated Will be superseded by getAddressesOrError
+     */
+    @Deprecated
+    public List<EquivalentAddressGroup> getAddresses() {
+      return addressesOrError.getValue();
+    }
+
+    /**
+     * Gets the addresses resolved by name resolution or the error in doing so.
+     *
+     * @since 1.65.0
+     */
+    public StatusOr<List<EquivalentAddressGroup>> getAddressesOrError() {
+      return addressesOrError;
+    }
+
+    /**
+     * Gets the attributes associated with the addresses resolved by name resolution.  If there are
+     * no attributes, {@link Attributes#EMPTY} will be returned.
+     *
+     * @since 1.21.0
+     */
+    @ResolutionResultAttr
+    public Attributes getAttributes() {
+      return attributes;
+    }
+
+    /**
+     * Gets the Service Config parsed by {@link Args#getServiceConfigParser}.
+     *
+     * @since 1.21.0
+     */
+    @Nullable
+    public ConfigOrError getServiceConfig() {
+      return serviceConfig;
+    }
+
+    @Override
+    public String toString() {
+      ToStringHelper stringHelper = MoreObjects.toStringHelper(this);
+      stringHelper.add("addressesOrError", addressesOrError.toString());
+      stringHelper.add("attributes", attributes);
+      stringHelper.add("serviceConfigOrError", serviceConfig);
+      return stringHelper.toString();
+    }
+
+    /**
+     * Useful for testing.  May be slow to calculate.
+     */
+    @Override
+    public boolean equals(Object obj) {
+      if (!(obj instanceof ResolutionResult)) {
+        return false;
+      }
+      ResolutionResult that = (ResolutionResult) obj;
+      return Objects.equal(this.addressesOrError, that.addressesOrError)
+          && Objects.equal(this.attributes, that.attributes)
+          && Objects.equal(this.serviceConfig, that.serviceConfig);
+    }
+
+    /**
+     * Useful for testing.  May be slow to calculate.
+     */
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(addressesOrError, attributes, serviceConfig);
+    }
+
+    /**
+     * A builder for {@link ResolutionResult}.
+     *
+     * @since 1.21.0
+     */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
+    public static final class Builder {
+      private StatusOr<List<EquivalentAddressGroup>> addresses =
+          StatusOr.fromValue(Collections.emptyList());
+      private Attributes attributes = Attributes.EMPTY;
+      @Nullable
+      private ConfigOrError serviceConfig;
+      //  Make sure to update #toBuilder above!
+
+      Builder() {}
+
+      /**
+       * Sets the addresses resolved by name resolution.  This field is required.
+       *
+       * @since 1.21.0
+       * @deprecated Will be superseded by setAddressesOrError
+       */
+      @Deprecated
+      public Builder setAddresses(List<EquivalentAddressGroup> addresses) {
+        setAddressesOrError(StatusOr.fromValue(addresses));
+        return this;
+      }
+
+      /**
+       * Sets the addresses resolved by name resolution or the error in doing so. This field is
+       * required.
+       * @param addresses Resolved addresses or an error in resolving addresses
+       */
+      public Builder setAddressesOrError(StatusOr<List<EquivalentAddressGroup>> addresses) {
+        this.addresses = checkNotNull(addresses, "StatusOr addresses cannot be null.");
+        return this;
+      }
+
+      /**
+       * Sets the attributes for the addresses resolved by name resolution.  If unset,
+       * {@link Attributes#EMPTY} will be used as a default.
+       *
+       * @since 1.21.0
+       */
+      public Builder setAttributes(Attributes attributes) {
+        this.attributes = attributes;
+        return this;
+      }
+
+      /**
+       * Sets the Service Config parsed by {@link Args#getServiceConfigParser}.
+       * This field is optional.
+       *
+       * @since 1.21.0
+       */
+      public Builder setServiceConfig(@Nullable ConfigOrError serviceConfig) {
+        this.serviceConfig = serviceConfig;
+        return this;
+      }
+
+      /**
+       * Constructs a new {@link ResolutionResult} from this builder.
+       *
+       * @since 1.21.0
+       */
+      public ResolutionResult build() {
+        return new ResolutionResult(addresses, attributes, serviceConfig);
+      }
+    }
+  }
+
+  /**
+   * Represents either a successfully parsed service config, containing all necessary parts to be
+   * later applied by the channel, or a Status containing the error encountered while parsing.
+   *
+   * @since 1.20.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
+  public static final class ConfigOrError {
+
+    /**
+     * Returns a {@link ConfigOrError} for the successfully parsed config.
+     */
+    public static ConfigOrError fromConfig(Object config) {
+      return new ConfigOrError(config);
+    }
+
+    /**
+     * Returns a {@link ConfigOrError} for the failure to parse the config.
+     *
+     * @param status a non-OK status
+     */
+    public static ConfigOrError fromError(Status status) {
+      return new ConfigOrError(status);
+    }
+
+    private final Status status;
+    private final Object config;
+
+    private ConfigOrError(Object config) {
+      this.config = checkNotNull(config, "config");
+      this.status = null;
+    }
+
+    private ConfigOrError(Status status) {
+      this.config = null;
+      this.status = checkNotNull(status, "status");
+      checkArgument(!status.isOk(), "cannot use OK status: %s", status);
+    }
+
+    /**
+     * Returns config if exists, otherwise null.
+     */
+    @Nullable
+    public Object getConfig() {
+      return config;
+    }
+
+    /**
+     * Returns error status if exists, otherwise null.
+     */
+    @Nullable
+    public Status getError() {
+      return status;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      ConfigOrError that = (ConfigOrError) o;
+      return Objects.equal(status, that.status) && Objects.equal(config, that.config);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(status, config);
+    }
+
+    @Override
+    public String toString() {
+      if (config != null) {
+        return MoreObjects.toStringHelper(this)
+            .add("config", config)
+            .toString();
+      } else {
+        assert status != null;
+        return MoreObjects.toStringHelper(this)
+            .add("error", status)
+            .toString();
+      }
+    }
+  }
+
+  @Nullable
+  private static IdentityHashMap<Args.Key<?>, Object> cloneCustomArgs(
+          @Nullable IdentityHashMap<Args.Key<?>, Object> customArgs) {
+    return customArgs != null ? new IdentityHashMap<>(customArgs) : null;
+  }
+}
diff --git a/api/src/main/java/io/grpc/NameResolverProvider.java b/api/src/main/java/io/grpc/NameResolverProvider.java
new file mode 100644
index 00000000000..70e22e366d5
--- /dev/null
+++ b/api/src/main/java/io/grpc/NameResolverProvider.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2016 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;
+
+import io.grpc.NameResolver.Factory;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * Provider of name resolvers for name agnostic consumption.
+ *
+ * <p>Implementations can be automatically discovered by gRPC via Java's SPI mechanism. For
+ * automatic discovery, the implementation must have a zero-argument constructor and include
+ * a resource named {@code META-INF/services/io.grpc.NameResolverProvider} in their JAR. The
+ * file's contents should be the implementation's class name. Implementations that need arguments in
+ * their constructor can be manually registered by {@link NameResolverRegistry#register}.
+ *
+ * <p>Implementations <em>should not</em> throw. If they do, it may interrupt class loading. If
+ * exceptions may reasonably occur for implementation-specific reasons, implementations should
+ * generally handle the exception gracefully and return {@code false} from {@link #isAvailable()}.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4159")
+public abstract class NameResolverProvider extends NameResolver.Factory {
+  /**
+   * Whether this provider is available for use, taking the current environment into consideration.
+   * If {@code false}, no other methods are safe to be called.
+   *
+   * @since 1.0.0
+   */
+  protected abstract boolean isAvailable();
+
+  /**
+   * A priority, from 0 to 10 that this provider should be used, taking the current environment into
+   * consideration. 5 should be considered the default, and then tweaked based on environment
+   * detection. A priority of 0 does not imply that the provider wouldn't work; just that it should
+   * be last in line.
+   *
+   * @since 1.0.0
+   */
+  protected abstract int priority();
+
+  /**
+   * Returns the scheme associated with the provider. The provider normally should only create a
+   * {@link NameResolver} when target URI scheme matches the provider scheme. It temporarily
+   * delegates to {@link Factory#getDefaultScheme()} before {@link NameResolver.Factory} is
+   * deprecated in https://github.com/grpc/grpc-java/issues/7133.
+   *
+   * <p>The scheme should be lower-case.
+   *
+   * @since 1.40.0
+   * */
+  protected String getScheme() {
+    return getDefaultScheme();
+  }
+
+  /**
+   * Returns the {@link SocketAddress} types this provider's name-resolver is capable of producing.
+   * This enables selection of the appropriate {@link ManagedChannelProvider} for a channel.
+   *
+   * @return the {@link SocketAddress} types this provider's name-resolver is capable of producing.
+   */
+  public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+    return Collections.singleton(InetSocketAddress.class);
+  }
+}
diff --git a/api/src/main/java/io/grpc/NameResolverRegistry.java b/api/src/main/java/io/grpc/NameResolverRegistry.java
new file mode 100644
index 00000000000..26eb5552b9b
--- /dev/null
+++ b/api/src/main/java/io/grpc/NameResolverRegistry.java
@@ -0,0 +1,203 @@
+/*
+ * Copyright 2019 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Registry of {@link NameResolverProvider}s.  The {@link #getDefaultRegistry default instance}
+ * loads providers at runtime through the Java service provider mechanism.
+ *
+ * @since 1.21.0
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4159")
+@ThreadSafe
+public final class NameResolverRegistry {
+  private static final Logger logger = Logger.getLogger(NameResolverRegistry.class.getName());
+  private static NameResolverRegistry instance;
+
+  private final NameResolver.Factory factory = new NameResolverFactory();
+  private static final String UNKNOWN_SCHEME = "unknown";
+  @GuardedBy("this")
+  private String defaultScheme = UNKNOWN_SCHEME;
+
+  @GuardedBy("this")
+  private final LinkedHashSet<NameResolverProvider> allProviders = new LinkedHashSet<>();
+  /** Generated from {@code allProviders}. Is mapping from scheme key to the highest priority
+   * {@link NameResolverProvider}. Is replaced instead of mutating. */
+  @GuardedBy("this")
+  private ImmutableMap<String, NameResolverProvider> effectiveProviders = ImmutableMap.of();
+
+  public synchronized String getDefaultScheme() {
+    return defaultScheme;
+  }
+
+  public NameResolverProvider getProviderForScheme(String scheme) {
+    if (scheme == null) {
+      return null;
+    }
+    return providers().get(scheme.toLowerCase(Locale.US));
+  }
+
+  /**
+   * Register a provider.
+   *
+   * <p>If the provider's {@link NameResolverProvider#isAvailable isAvailable()} returns
+   * {@code false}, this method will throw {@link IllegalArgumentException}.
+   *
+   * <p>Providers will be used in priority order. In case of ties, providers are used in
+   * registration order.
+   */
+  public synchronized void register(NameResolverProvider provider) {
+    addProvider(provider);
+    refreshProviders();
+  }
+
+  private synchronized void addProvider(NameResolverProvider provider) {
+    checkArgument(provider.isAvailable(), "isAvailable() returned false");
+    allProviders.add(provider);
+  }
+
+  /**
+   * Deregisters a provider.  No-op if the provider is not in the registry.
+   *
+   * @param provider the provider that was added to the register via {@link #register}.
+   */
+  public synchronized void deregister(NameResolverProvider provider) {
+    allProviders.remove(provider);
+    refreshProviders();
+  }
+
+  private synchronized void refreshProviders() {
+    Map<String, NameResolverProvider> refreshedProviders = new HashMap<>();
+    int maxPriority = Integer.MIN_VALUE;
+    String refreshedDefaultScheme = UNKNOWN_SCHEME;
+    // We prefer first-registered providers
+    for (NameResolverProvider provider : allProviders) {
+      String scheme = provider.getScheme();
+      NameResolverProvider existing = refreshedProviders.get(scheme);
+      if (existing == null || existing.priority() < provider.priority()) {
+        refreshedProviders.put(scheme, provider);
+      }
+      if (maxPriority < provider.priority()) {
+        maxPriority = provider.priority();
+        refreshedDefaultScheme = provider.getScheme();
+      }
+    }
+    effectiveProviders = ImmutableMap.copyOf(refreshedProviders);
+    defaultScheme = refreshedDefaultScheme;
+  }
+
+  /**
+   * Returns the default registry that loads providers via the Java service loader mechanism.
+   */
+  public static synchronized NameResolverRegistry getDefaultRegistry() {
+    if (instance == null) {
+      List<NameResolverProvider> providerList = ServiceProviders.loadAll(
+          NameResolverProvider.class,
+          getHardCodedClasses(),
+          NameResolverProvider.class.getClassLoader(),
+          new NameResolverPriorityAccessor());
+      if (providerList.isEmpty()) {
+        logger.warning("No NameResolverProviders found via ServiceLoader, including for DNS. This "
+            + "is probably due to a broken build. If using ProGuard, check your configuration");
+      }
+      instance = new NameResolverRegistry();
+      for (NameResolverProvider provider : providerList) {
+        logger.fine("Service loader found " + provider);
+        instance.addProvider(provider);
+      }
+      instance.refreshProviders();
+    }
+    return instance;
+  }
+
+  /**
+   * Returns effective providers map from scheme to the highest priority NameResolverProvider of
+   * that scheme.
+   */
+  @VisibleForTesting
+  synchronized Map<String, NameResolverProvider> providers() {
+    return effectiveProviders;
+  }
+
+  public NameResolver.Factory asFactory() {
+    return factory;
+  }
+
+  @VisibleForTesting
+  static List<Class<?>> getHardCodedClasses() {
+    // Class.forName(String) is used to remove the need for ProGuard configuration. Note that
+    // ProGuard does not detect usages of Class.forName(String, boolean, ClassLoader):
+    // https://sourceforge.net/p/proguard/bugs/418/
+    ArrayList<Class<?>> list = new ArrayList<>();
+    try {
+      list.add(Class.forName("io.grpc.internal.DnsNameResolverProvider"));
+    } catch (ClassNotFoundException e) {
+      logger.log(Level.FINE, "Unable to find DNS NameResolver", e);
+    }
+    try {
+      list.add(Class.forName("io.grpc.binder.internal.IntentNameResolverProvider"));
+    } catch (ClassNotFoundException e) {
+      logger.log(Level.FINE, "Unable to find IntentNameResolverProvider", e);
+    }
+    return Collections.unmodifiableList(list);
+  }
+
+  private final class NameResolverFactory extends NameResolver.Factory {
+    @Override
+    @Nullable
+    public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+      NameResolverProvider provider = getProviderForScheme(targetUri.getScheme());
+      return provider == null ? null : provider.newNameResolver(targetUri, args);
+    }
+
+    @Override
+    public String getDefaultScheme() {
+      return NameResolverRegistry.this.getDefaultScheme();
+    }
+  }
+
+  private static final class NameResolverPriorityAccessor
+      implements ServiceProviders.PriorityAccessor<NameResolverProvider> {
+    @Override
+    public boolean isAvailable(NameResolverProvider provider) {
+      return provider.isAvailable();
+    }
+
+    @Override
+    public int getPriority(NameResolverProvider provider) {
+      return provider.priority();
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/PartialForwardingClientCall.java b/api/src/main/java/io/grpc/PartialForwardingClientCall.java
new file mode 100644
index 00000000000..b49a1432926
--- /dev/null
+++ b/api/src/main/java/io/grpc/PartialForwardingClientCall.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2018 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;
+
+import com.google.common.base.MoreObjects;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link ClientCall} which forwards all of its methods to another {@link ClientCall} which
+ * may have a different sendMessage() message type.
+ */
+abstract class PartialForwardingClientCall<ReqT, RespT> extends ClientCall<ReqT, RespT> {
+  /**
+   * Returns the delegated {@code ClientCall}.
+   */
+  protected abstract ClientCall<?, ?> delegate();
+
+  @Override
+  public void request(int numMessages) {
+    delegate().request(numMessages);
+  }
+
+  @Override
+  public void cancel(@Nullable String message, @Nullable Throwable cause) {
+    delegate().cancel(message, cause);
+  }
+
+  @Override
+  public void halfClose() {
+    delegate().halfClose();
+  }
+
+  @Override
+  public void setMessageCompression(boolean enabled) {
+    delegate().setMessageCompression(enabled);
+  }
+
+  @Override
+  public boolean isReady() {
+    return delegate().isReady();
+  }
+
+  @Override
+  public Attributes getAttributes() {
+    return delegate().getAttributes();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+}
diff --git a/api/src/main/java/io/grpc/PartialForwardingClientCallListener.java b/api/src/main/java/io/grpc/PartialForwardingClientCallListener.java
new file mode 100644
index 00000000000..632e6a13609
--- /dev/null
+++ b/api/src/main/java/io/grpc/PartialForwardingClientCallListener.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2018 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;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * A {@link ClientCall.Listener} which forwards all of its methods to another {@link
+ * ClientCall.Listener} which may have a different parameterized type than the
+ * onMessage() message type.
+ */
+abstract class PartialForwardingClientCallListener<RespT> extends ClientCall.Listener<RespT> {
+  /**
+   * Returns the delegated {@code ClientCall.Listener}.
+   */
+  protected abstract ClientCall.Listener<?> delegate();
+
+  @Override
+  public void onHeaders(Metadata headers) {
+    delegate().onHeaders(headers);
+  }
+
+  @Override
+  public void onClose(Status status, Metadata trailers) {
+    delegate().onClose(status, trailers);
+  }
+
+  @Override
+  public void onReady() {
+    delegate().onReady();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+}
diff --git a/api/src/main/java/io/grpc/PartialForwardingServerCall.java b/api/src/main/java/io/grpc/PartialForwardingServerCall.java
new file mode 100644
index 00000000000..a313407b23e
--- /dev/null
+++ b/api/src/main/java/io/grpc/PartialForwardingServerCall.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2015 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;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * A {@link ServerCall} which forwards all of it's methods to another {@link ServerCall} which
+ * may have a different sendMessage() message type.
+ */
+abstract class PartialForwardingServerCall<ReqT, RespT> extends ServerCall<ReqT, RespT> {
+  /**
+   * Returns the delegated {@code ServerCall}.
+   */
+  protected abstract ServerCall<?, ?> delegate();
+
+  @Override
+  public void request(int numMessages) {
+    delegate().request(numMessages);
+  }
+
+  @Override
+  public void sendHeaders(Metadata headers) {
+    delegate().sendHeaders(headers);
+  }
+
+  @Override
+  public boolean isReady() {
+    return delegate().isReady();
+  }
+
+  @Override
+  public void close(Status status, Metadata trailers) {
+    delegate().close(status, trailers);
+  }
+
+  @Override
+  public boolean isCancelled() {
+    return delegate().isCancelled();
+  }
+
+  @Override
+  public void setMessageCompression(boolean enabled) {
+    delegate().setMessageCompression(enabled);
+  }
+
+  @Override
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11021")
+  public void setOnReadyThreshold(int numBytes) {
+    delegate().setOnReadyThreshold(numBytes);
+  }
+
+  @Override
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
+  public void setCompression(String compressor) {
+    delegate().setCompression(compressor);
+  }
+
+  @Override
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1779")
+  public Attributes getAttributes() {
+    return delegate().getAttributes();
+  }
+
+  @Override
+  public String getAuthority() {
+    return delegate().getAuthority();
+  }
+  
+  @Override
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4692")
+  public SecurityLevel getSecurityLevel() {
+    return delegate().getSecurityLevel();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+}
diff --git a/api/src/main/java/io/grpc/PartialForwardingServerCallListener.java b/api/src/main/java/io/grpc/PartialForwardingServerCallListener.java
new file mode 100644
index 00000000000..ca2fd0058c9
--- /dev/null
+++ b/api/src/main/java/io/grpc/PartialForwardingServerCallListener.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2015 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;
+
+import com.google.common.base.MoreObjects;
+
+/**
+ * A {@link ServerCall.Listener} which forwards all of its methods to another {@link
+ * ServerCall.Listener} which may have a different parameterized type than the
+ * onMessage() message type.
+ */
+abstract class PartialForwardingServerCallListener<ReqT>
+    extends ServerCall.Listener<ReqT> {
+  /**
+   * Returns the delegated {@code ServerCall.Listener}.
+   */
+  protected abstract ServerCall.Listener<?> delegate();
+
+  @Override
+  public void onHalfClose() {
+    delegate().onHalfClose();
+  }
+
+  @Override
+  public void onCancel() {
+    delegate().onCancel();
+  }
+
+  @Override
+  public void onComplete() {
+    delegate().onComplete();
+  }
+
+  @Override
+  public void onReady() {
+    delegate().onReady();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+}
diff --git a/api/src/main/java/io/grpc/PartialMetricInstrument.java b/api/src/main/java/io/grpc/PartialMetricInstrument.java
new file mode 100644
index 00000000000..7e032634f96
--- /dev/null
+++ b/api/src/main/java/io/grpc/PartialMetricInstrument.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2024 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;
+
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+
+/**
+ * A partial implementation of the {@link MetricInstrument} interface. This class
+ * provides common fields and functionality for metric instruments.
+ */
+@Internal
+abstract class PartialMetricInstrument implements MetricInstrument {
+  protected final int index;
+  protected final String name;
+  protected final String description;
+  protected final String unit;
+  protected final List<String> requiredLabelKeys;
+  protected final List<String> optionalLabelKeys;
+  protected final boolean enableByDefault;
+
+  /**
+   * Constructs a new PartialMetricInstrument with the specified attributes.
+   *
+   * @param index             the unique index of this metric instrument
+   * @param name              the name of the metric
+   * @param description       a description of the metric
+   * @param unit              the unit of measurement for the metric
+   * @param requiredLabelKeys a list of required label keys for the metric
+   * @param optionalLabelKeys a list of optional label keys for the metric
+   * @param enableByDefault   whether the metric should be enabled by default
+   */
+  protected PartialMetricInstrument(int index, String name, String description, String unit,
+      List<String> requiredLabelKeys, List<String> optionalLabelKeys, boolean enableByDefault) {
+    this.index = index;
+    this.name = name;
+    this.description = description;
+    this.unit = unit;
+    this.requiredLabelKeys = ImmutableList.copyOf(requiredLabelKeys);
+    this.optionalLabelKeys = ImmutableList.copyOf(optionalLabelKeys);
+    this.enableByDefault = enableByDefault;
+  }
+
+  @Override
+  public int getIndex() {
+    return index;
+  }
+
+  @Override
+  public String getName() {
+    return name;
+  }
+
+  @Override
+  public String getDescription() {
+    return description;
+  }
+
+  @Override
+  public String getUnit() {
+    return unit;
+  }
+
+  @Override
+  public List<String> getRequiredLabelKeys() {
+    return requiredLabelKeys;
+  }
+
+  @Override
+  public List<String> getOptionalLabelKeys() {
+    return optionalLabelKeys;
+  }
+
+  @Override
+  public boolean isEnableByDefault() {
+    return enableByDefault;
+  }
+
+  @Override
+  public String toString() {
+    return getClass().getName() + "(" + getName() + ")";
+  }
+}
diff --git a/api/src/main/java/io/grpc/ProxiedSocketAddress.java b/api/src/main/java/io/grpc/ProxiedSocketAddress.java
new file mode 100644
index 00000000000..56b543b5cbd
--- /dev/null
+++ b/api/src/main/java/io/grpc/ProxiedSocketAddress.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2019 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;
+
+import java.net.SocketAddress;
+
+/**
+ * An address that contains the information about making a connection via a proxy.  It is created by
+ * a {@link ProxyDetector}.
+ */
+public abstract class ProxiedSocketAddress extends SocketAddress {
+  private static final long serialVersionUID = 0L;
+}
diff --git a/api/src/main/java/io/grpc/ProxyDetector.java b/api/src/main/java/io/grpc/ProxyDetector.java
new file mode 100644
index 00000000000..1d3686f40eb
--- /dev/null
+++ b/api/src/main/java/io/grpc/ProxyDetector.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2017 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;
+
+import java.io.IOException;
+import java.net.SocketAddress;
+import javax.annotation.Nullable;
+
+/**
+ * A utility class to detect which proxy, if any, should be used for a given
+ * {@link java.net.SocketAddress}. This class performs network requests to resolve address names,
+ * and should only be used in places that are expected to do IO such as the
+ * {@link io.grpc.NameResolver}.
+ *
+ * <h1>How Proxies work in gRPC</h1>
+ *
+ * <p>In order for gRPC to use a proxy, {@link NameResolver}, {@link ProxyDetector} and the
+ * underlying transport need to work together.
+ *
+ * <p>The {@link NameResolver} should invoke the {@link ProxyDetector} retrieved from the {@link
+ * NameResolver.Args#getProxyDetector}, and pass the returned {@link ProxiedSocketAddress} to
+ * {@link NameResolver.Listener#onAddresses}.  The DNS name resolver shipped with gRPC is already
+ * doing so.
+ *
+ * <p>The default {@code ProxyDetector} uses Java's standard {@link java.net.ProxySelector} and
+ * {@link java.net.Authenticator} to detect proxies and authentication credentials and produce
+ * {@link HttpConnectProxiedSocketAddress}, which is for using an HTTP CONNECT proxy.  A custom
+ * {@code ProxyDetector} can be passed to {@link ManagedChannelBuilder#proxyDetector}.
+ *
+ * <p>The {@link ProxiedSocketAddress} is then handled by the transport.  The transport needs to
+ * support whatever type of {@code ProxiedSocketAddress} returned by {@link ProxyDetector}.  The
+ * Netty transport and the OkHttp transport currently only support {@link
+ * HttpConnectProxiedSocketAddress} which is returned by the default {@code ProxyDetector}.
+ */
+public interface ProxyDetector {
+  /**
+   * Given a target address, returns a proxied address if a proxy should be used. If no proxy should
+   * be used, then return value will be {@code null}.
+   *
+   * <p>If the returned {@code ProxiedSocketAddress} contains any address that needs to be resolved
+   * locally, it should be resolved before it's returned, and this method throws if unable to
+   * resolve it.
+   *
+   * @param targetServerAddress the target address, which is generally unresolved, because the proxy
+   *                            will resolve it.
+   */
+  @Nullable
+  ProxiedSocketAddress proxyFor(SocketAddress targetServerAddress) throws IOException;
+}
diff --git a/api/src/main/java/io/grpc/SecurityLevel.java b/api/src/main/java/io/grpc/SecurityLevel.java
new file mode 100644
index 00000000000..7d834aadb69
--- /dev/null
+++ b/api/src/main/java/io/grpc/SecurityLevel.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2016 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;
+
+/**
+ * The level of security guarantee in communications.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4692")
+public enum SecurityLevel {
+  /**
+   * No security guarantee.
+   */
+  NONE,
+
+  /**
+   * The other party is authenticated and the data is not tampered with.
+   */
+  INTEGRITY,
+
+  /**
+   * In addition to {@code INTEGRITY}, the data is only visible to the intended communication
+   * parties.
+   */
+  PRIVACY_AND_INTEGRITY
+}
diff --git a/api/src/main/java/io/grpc/Server.java b/api/src/main/java/io/grpc/Server.java
new file mode 100644
index 00000000000..97ea06a81c2
--- /dev/null
+++ b/api/src/main/java/io/grpc/Server.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2014 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;
+
+import java.io.IOException;
+import java.net.SocketAddress;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Server for listening for and dispatching incoming calls. It is not expected to be implemented by
+ * application code or interceptors.
+ */
+@ThreadSafe
+public abstract class Server {
+
+  /**
+   * Key for accessing the {@link Server} instance inside server RPC {@link Context}. It's
+   * unclear to us what users would need. If you think you need to use this, please file an
+   * issue for us to discuss a public API.
+   */
+  static final Context.Key<Server> SERVER_CONTEXT_KEY =
+      Context.key("io.grpc.Server");
+
+  /**
+   * Bind and start the server.  After this call returns, clients may begin connecting to the
+   * listening socket(s).
+   *
+   * @return {@code this} object
+   * @throws IllegalStateException if already started or shut down
+   * @throws IOException if unable to bind
+   * @since 1.0.0
+   */
+  public abstract Server start() throws IOException;
+
+  /**
+   * Returns the port number the server is listening on.  This can return -1 if there is no actual
+   * port or the result otherwise does not make sense.  Result is undefined after the server is
+   * terminated.  If there are multiple possible ports, this will return one arbitrarily.
+   * Implementations are encouraged to return the same port on each call.
+   *
+   * @see #getListenSockets()
+   * @throws IllegalStateException if the server has not yet been started.
+   * @since 1.0.0
+   */
+  public int getPort() {
+    return -1;
+  }
+
+  /**
+   * Returns a list of listening sockets for this server.  May be different than the originally
+   * requested sockets (e.g. listening on port '0' may end up listening on a different port).
+   * The list is unmodifiable.
+   *
+   * @throws IllegalStateException if the server has not yet been started.
+   * @since 1.19.0
+   */
+  public List<? extends SocketAddress> getListenSockets() {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Returns all services registered with the server, or an empty list if not supported by the
+   * implementation.
+   *
+   * @since 1.1.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
+  public List<ServerServiceDefinition> getServices() {
+    return Collections.emptyList();
+  }
+
+  /**
+   * Returns immutable services registered with the server, or an empty list if not supported by the
+   * implementation.
+   *
+   * @since 1.1.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
+  public List<ServerServiceDefinition> getImmutableServices() {
+    return Collections.emptyList();
+  }
+
+
+  /**
+   * Returns mutable services registered with the server, or an empty list if not supported by the
+   * implementation.
+   *
+   * @since 1.1.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
+  public List<ServerServiceDefinition> getMutableServices() {
+    return Collections.emptyList();
+  }
+
+  /**
+   * Initiates an orderly shutdown in which preexisting calls continue but new calls are rejected.
+   * After this call returns, this server has released the listening socket(s) and may be reused by
+   * another server.
+   *
+   * <p>Note that this method will not wait for preexisting calls to finish before returning.
+   * {@link #awaitTermination()} or {@link #awaitTermination(long, TimeUnit)} needs to be called to
+   * wait for existing calls to finish.
+   *
+   * <p>Calling this method before {@code start()} will shut down and terminate the server like
+   * normal, but prevents starting the server in the future.
+   *
+   * @return {@code this} object
+   * @since 1.0.0
+   */
+  public abstract Server shutdown();
+
+  /**
+   * Initiates a forceful shutdown in which preexisting and new calls are rejected. Although
+   * forceful, the shutdown process is still not instantaneous; {@link #isTerminated()} will likely
+   * return {@code false} immediately after this method returns. After this call returns, this
+   * server has released the listening socket(s) and may be reused by another server.
+   *
+   * <p>Calling this method before {@code start()} will shut down and terminate the server like
+   * normal, but prevents starting the server in the future.
+   *
+   * @return {@code this} object
+   * @since 1.0.0
+   */
+  public abstract Server shutdownNow();
+
+  /**
+   * Returns whether the server is shutdown. Shutdown servers reject any new calls, but may still
+   * have some calls being processed.
+   *
+   * @see #shutdown()
+   * @see #isTerminated()
+   * @since 1.0.0
+   */
+  public abstract boolean isShutdown();
+
+  /**
+   * Returns whether the server is terminated. Terminated servers have no running calls and
+   * relevant resources released (like TCP connections).
+   *
+   * @see #isShutdown()
+   * @since 1.0.0
+   */
+  public abstract boolean isTerminated();
+
+  /**
+   * Waits for the server to become terminated, giving up if the timeout is reached.
+   *
+   * <p>Calling this method before {@code start()} or {@code shutdown()} is permitted and does not
+   * change its behavior.
+   *
+   * @return whether the server is terminated, as would be done by {@link #isTerminated()}.
+   */
+  public abstract boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
+
+  /**
+   * Waits for the server to become terminated.
+   *
+   * <p>Calling this method before {@code start()} or {@code shutdown()} is permitted and does not
+   * change its behavior.
+   *
+   * @since 1.0.0
+   */
+  public abstract void awaitTermination() throws InterruptedException;
+}
diff --git a/api/src/main/java/io/grpc/ServerBuilder.java b/api/src/main/java/io/grpc/ServerBuilder.java
new file mode 100644
index 00000000000..cd1cddbb93f
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServerBuilder.java
@@ -0,0 +1,446 @@
+/*
+ * Copyright 2015 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Preconditions;
+import java.io.File;
+import java.io.InputStream;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * A builder for {@link Server} instances.
+ *
+ * @param <T> The concrete type of this builder.
+ * @since 1.0.0
+ */
+public abstract class ServerBuilder<T extends ServerBuilder<T>> {
+
+  /**
+   * Static factory for creating a new ServerBuilder.
+   *
+   * @param port the port to listen on
+   * @since 1.0.0
+   */
+  public static ServerBuilder<?> forPort(int port) {
+    return ServerProvider.provider().builderForPort(port);
+  }
+
+  /**
+   * Execute application code directly in the transport thread.
+   *
+   * <p>Depending on the underlying transport, using a direct executor may lead to substantial
+   * performance improvements. However, it also requires the application to not block under
+   * any circumstances.
+   *
+   * <p>Calling this method is semantically equivalent to calling {@link #executor(Executor)} and
+   * passing in a direct executor. However, this is the preferred way as it may allow the transport
+   * to perform special optimizations.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  public abstract T directExecutor();
+
+  /**
+   * Provides a custom executor.
+   *
+   * <p>It's an optional parameter. If the user has not provided an executor when the server is
+   * built, the builder will use a static cached thread pool.
+   *
+   * <p>The server won't take ownership of the given executor. It's caller's responsibility to
+   * shut down the executor when it's desired.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  public abstract T executor(@Nullable Executor executor);
+
+
+  /**
+   * Allows for defining a way to provide a custom executor to handle the server call.
+   * This executor is the result of calling
+   * {@link ServerCallExecutorSupplier#getExecutor(ServerCall, Metadata)} per RPC.
+   *
+   * <p>It's an optional parameter. If it is provided, the {@link #executor(Executor)} would still
+   * run necessary tasks before the {@link ServerCallExecutorSupplier} is ready to be called, then
+   * it switches over. But if calling {@link ServerCallExecutorSupplier} returns null, the server
+   * call is still handled by the default {@link #executor(Executor)} as a fallback.
+   *
+   * @param executorSupplier the server call executor provider
+   * @return this
+   * @since 1.39.0
+   *
+   * */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8274")
+  public T callExecutor(ServerCallExecutorSupplier executorSupplier) {
+    return thisT();
+  }
+
+  /**
+   * Adds a service implementation to the handler registry.
+   *
+   * @param service ServerServiceDefinition object
+   * @return this
+   * @since 1.0.0
+   */
+  public abstract T addService(ServerServiceDefinition service);
+
+  /**
+   * Adds a service implementation to the handler registry.
+   *
+   * @param bindableService BindableService object
+   * @return this
+   * @since 1.0.0
+   */
+  public abstract T addService(BindableService bindableService);
+
+  /**
+   * Adds a list of service implementations to the handler registry together. This exists for
+   * convenience - equivalent to repeatedly calling addService() with different services.
+   * If multiple services on the list use the same name, only the last one on the list will
+   * be added.
+   *
+   * @param services the list of ServerServiceDefinition objects
+   * @return this
+   * @since 1.37.0
+   */
+  public final T addServices(List<ServerServiceDefinition> services) {
+    checkNotNull(services, "services");
+    for (ServerServiceDefinition service : services) {
+      addService(service);
+    }
+    return thisT();
+  }
+
+  /**
+   * Adds a {@link ServerInterceptor} that is run for all services on the server.  Interceptors
+   * added through this method always run before per-service interceptors added through {@link
+   * ServerInterceptors}.  Interceptors run in the reverse order in which they are added, just as
+   * with consecutive calls to {@code ServerInterceptors.intercept()}.
+   *
+   * @param interceptor the all-service interceptor
+   * @return this
+   * @since 1.5.0
+   */
+  public T intercept(ServerInterceptor interceptor) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Adds a {@link ServerTransportFilter}. The order of filters being added is the order they will
+   * be executed.
+   *
+   * @return this
+   * @since 1.2.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2132")
+  public T addTransportFilter(ServerTransportFilter filter) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Adds a {@link ServerStreamTracer.Factory} to measure server-side traffic.  The order of
+   * factories being added is the order they will be executed.
+   *
+   * @return this
+   * @since 1.3.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
+  public T addStreamTracerFactory(ServerStreamTracer.Factory factory) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets a fallback handler registry that will be looked up in if a method is not found in the
+   * primary registry. The primary registry (configured via {@code addService()}) is faster but
+   * immutable. The fallback registry is more flexible and allows implementations to mutate over
+   * time and load services on-demand.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  public abstract T fallbackHandlerRegistry(@Nullable HandlerRegistry fallbackRegistry);
+
+  /**
+   * Makes the server use TLS.
+   *
+   * @param certChain file containing the full certificate chain
+   * @param privateKey file containing the private key
+   *
+   * @return this
+   * @throws UnsupportedOperationException if the server does not support TLS.
+   * @since 1.0.0
+   */
+  public abstract T useTransportSecurity(File certChain, File privateKey);
+
+  /**
+   * Makes the server use TLS.
+   *
+   * @param certChain InputStream containing the full certificate chain
+   * @param privateKey InputStream containing the private key
+   *
+   * @return this
+   * @throws UnsupportedOperationException if the server does not support TLS, or does not support
+   *         reading these files from an InputStream.
+   * @since 1.12.0
+   */
+  public T useTransportSecurity(InputStream certChain, InputStream privateKey) {
+    throw new UnsupportedOperationException();
+  }
+
+
+  /**
+   * Set the decompression registry for use in the channel.  This is an advanced API call and
+   * shouldn't be used unless you are using custom message encoding.   The default supported
+   * decompressors are in {@code DecompressorRegistry.getDefaultInstance}.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
+  public abstract T decompressorRegistry(@Nullable DecompressorRegistry registry);
+
+  /**
+   * Set the compression registry for use in the channel.  This is an advanced API call and
+   * shouldn't be used unless you are using custom message encoding.   The default supported
+   * compressors are in {@code CompressorRegistry.getDefaultInstance}.
+   *
+   * @return this
+   * @since 1.0.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
+  public abstract T compressorRegistry(@Nullable CompressorRegistry registry);
+
+  /**
+   * Sets the permitted time for new connections to complete negotiation handshakes before being
+   * killed. The default value is 2 minutes.
+   *
+   * @return this
+   * @throws IllegalArgumentException if timeout is negative
+   * @throws UnsupportedOperationException if unsupported
+   * @since 1.8.0
+   */
+  public T handshakeTimeout(long timeout, TimeUnit unit) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets the time without read activity before sending a keepalive ping. An unreasonably small
+   * value might be increased, and {@code Long.MAX_VALUE} nano seconds or an unreasonably large
+   * value will disable keepalive. The typical default is two hours when supported.
+   *
+   * @throws IllegalArgumentException if time is not positive
+   * @throws UnsupportedOperationException if unsupported
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A9-server-side-conn-mgt.md">gRFC A9
+   *     Server-side Connection Management</a>
+   * @since 1.47.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/9009")
+  public T keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets a time waiting for read activity after sending a keepalive ping. If the time expires
+   * without any read activity on the connection, the connection is considered dead. An unreasonably
+   * small value might be increased. Defaults to 20 seconds when supported.
+   *
+   * <p>This value should be at least multiple times the RTT to allow for lost packets.
+   *
+   * @throws IllegalArgumentException if timeout is not positive
+   * @throws UnsupportedOperationException if unsupported
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A9-server-side-conn-mgt.md">gRFC A9
+   *     Server-side Connection Management</a>
+   * @since 1.47.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/9009")
+  public T keepAliveTimeout(long keepAliveTimeout, TimeUnit timeUnit) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets the maximum connection idle time, connections being idle for longer than which will be
+   * gracefully terminated. Idleness duration is defined since the most recent time the number of
+   * outstanding RPCs became zero or the connection establishment. An unreasonably small value might
+   * be increased. {@code Long.MAX_VALUE} nano seconds or an unreasonably large value will disable
+   * max connection idle.
+   *
+   * @throws IllegalArgumentException if idle is not positive
+   * @throws UnsupportedOperationException if unsupported
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A9-server-side-conn-mgt.md">gRFC A9
+   *     Server-side Connection Management</a>
+   * @since 1.47.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/9009")
+  public T maxConnectionIdle(long maxConnectionIdle, TimeUnit timeUnit) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets the maximum connection age, connections lasting longer than which will be gracefully
+   * terminated. An unreasonably small value might be increased. A random jitter of +/-10% will be
+   * added to it. {@code Long.MAX_VALUE} nano seconds or an unreasonably large value will disable
+   * max connection age.
+   *
+   * @throws IllegalArgumentException if age is not positive
+   * @throws UnsupportedOperationException if unsupported
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A9-server-side-conn-mgt.md">gRFC A9
+   *     Server-side Connection Management</a>
+   * @since 1.47.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/9009")
+  public T maxConnectionAge(long maxConnectionAge, TimeUnit timeUnit) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets the grace time for the graceful connection termination. Once the max connection age
+   * is reached, RPCs have the grace time to complete. RPCs that do not complete in time will be
+   * cancelled, allowing the connection to terminate. {@code Long.MAX_VALUE} nano seconds or an
+   * unreasonably large value are considered infinite.
+   *
+   * @throws IllegalArgumentException if grace is negative
+   * @throws UnsupportedOperationException if unsupported
+   * @see #maxConnectionAge(long, TimeUnit)
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A9-server-side-conn-mgt.md">gRFC A9
+   *     Server-side Connection Management</a>
+   * @since 1.47.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/9009")
+  public T maxConnectionAgeGrace(long maxConnectionAgeGrace, TimeUnit timeUnit) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Specify the most aggressive keep-alive time clients are permitted to configure. The server will
+   * try to detect clients exceeding this rate and when detected will forcefully close the
+   * connection. The typical default is 5 minutes when supported.
+   *
+   * <p>Even though a default is defined that allows some keep-alives, clients must not use
+   * keep-alive without approval from the service owner. Otherwise, they may experience failures in
+   * the future if the service becomes more restrictive. When unthrottled, keep-alives can cause a
+   * significant amount of traffic and CPU usage, so clients and servers should be conservative in
+   * what they use and accept.
+   *
+   * @throws IllegalArgumentException if time is negative
+   * @throws UnsupportedOperationException if unsupported
+   * @see #permitKeepAliveWithoutCalls(boolean)
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A8-client-side-keepalive.md">gRFC A8
+   *     Client-side Keepalive</a>
+   * @since 1.47.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/9009")
+  public T permitKeepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets whether to allow clients to send keep-alive HTTP/2 PINGs even if there are no outstanding
+   * RPCs on the connection. Defaults to {@code false} when supported.
+   *
+   * @throws UnsupportedOperationException if unsupported
+   * @see #permitKeepAliveTime(long, TimeUnit)
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A8-client-side-keepalive.md">gRFC A8
+   *     Client-side Keepalive</a>
+   * @since 1.47.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/9009")
+  public T permitKeepAliveWithoutCalls(boolean permit) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Sets the maximum message size allowed to be received on the server. If not called,
+   * defaults to 4 MiB. The default provides protection to servers who haven't considered the
+   * possibility of receiving large messages while trying to be large enough to not be hit in normal
+   * usage.
+   *
+   * <p>This method is advisory, and implementations may decide to not enforce this.  Currently,
+   * the only known transport to not enforce this is {@code InProcessServer}.
+   *
+   * @param bytes the maximum number of bytes a single message can be.
+   * @return this
+   * @throws IllegalArgumentException if bytes is negative.
+   * @throws UnsupportedOperationException if unsupported.
+   * @since 1.13.0
+   */
+  public T maxInboundMessageSize(int bytes) {
+    // intentional noop rather than throw, this method is only advisory.
+    Preconditions.checkArgument(bytes >= 0, "bytes must be >= 0");
+    return thisT();
+  }
+
+  /**
+   * Sets the maximum size of metadata allowed to be received. {@code Integer.MAX_VALUE} disables
+   * the enforcement. The default is implementation-dependent, but is not generally less than 8 KiB
+   * and may be unlimited.
+   *
+   * <p>This is cumulative size of the metadata. The precise calculation is
+   * implementation-dependent, but implementations are encouraged to follow the calculation used for
+   * <a href="http://httpwg.org/specs/rfc7540.html#rfc.section.6.5.2">
+   * HTTP/2's SETTINGS_MAX_HEADER_LIST_SIZE</a>. It sums the bytes from each entry's key and value,
+   * plus 32 bytes of overhead per entry.
+   *
+   * @param bytes the maximum size of received metadata
+   * @return this
+   * @throws IllegalArgumentException if bytes is non-positive
+   * @since 1.17.0
+   */
+  public T maxInboundMetadataSize(int bytes) {
+    Preconditions.checkArgument(bytes > 0, "maxInboundMetadataSize must be > 0");
+    // intentional noop rather than throw, this method is only advisory.
+    return thisT();
+  }
+
+  /**
+   * Sets the BinaryLog object that this server should log to. The server does not take
+   * ownership of the object, and users are responsible for calling {@link BinaryLog#close()}.
+   *
+   * @param binaryLog the object to provide logging.
+   * @return this
+   * @since 1.13.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4017")
+  public T setBinaryLog(BinaryLog binaryLog) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Builds a server using the given parameters.
+   *
+   * <p>The returned service will not been started or be bound a port. You will need to start it
+   * with {@link Server#start()}.
+   *
+   * @return a new Server
+   * @since 1.0.0
+   */
+  public abstract Server build();
+
+  /**
+   * Returns the correctly typed version of the builder.
+   */
+  private T thisT() {
+    @SuppressWarnings("unchecked")
+    T thisT = (T) this;
+    return thisT;
+  }
+}
diff --git a/api/src/main/java/io/grpc/ServerCall.java b/api/src/main/java/io/grpc/ServerCall.java
new file mode 100644
index 00000000000..3db8ac30e83
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServerCall.java
@@ -0,0 +1,269 @@
+/*
+ * Copyright 2014 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import javax.annotation.Nullable;
+
+/**
+ * Encapsulates a single call received from a remote client. Calls may not simply be unary
+ * request-response even though this is the most common pattern. Calls may stream any number of
+ * requests and responses. This API is generally intended for use by generated handlers,
+ * but applications may use it directly if they need to.
+ *
+ * <p>Headers must be sent before any messages, which must be sent before closing.
+ *
+ * <p>No generic method for determining message receipt or providing acknowledgement is provided.
+ * Applications are expected to utilize normal messages for such signals, as a response
+ * naturally acknowledges its request.
+ *
+ * <p>Methods are guaranteed to be non-blocking. Implementations are not required to be thread-safe.
+ *
+ * <p>DO NOT MOCK: Use InProcessTransport and make a fake server instead.
+ *
+ * @param <ReqT> parsed type of request message.
+ * @param <RespT> parsed type of response message.
+ */
+public abstract class ServerCall<ReqT, RespT> {
+
+  /**
+   * Callbacks for consuming incoming RPC messages.
+   *
+   * <p>Any contexts are guaranteed to arrive before any messages, which are guaranteed before half
+   * close, which is guaranteed before completion.
+   *
+   * <p>Implementations are free to block for extended periods of time. Implementations are not
+   * required to be thread-safe, but they must not be thread-hostile. The caller is free to call
+   * an instance from multiple threads, but only one call simultaneously. A single thread may
+   * interleave calls to multiple instances, so implementations using ThreadLocals must be careful
+   * to avoid leaking inappropriate state (e.g., clearing the ThreadLocal before returning).
+   */
+  // TODO(ejona86): We need to decide what to do in the case of server closing with non-cancellation
+  // before client half closes. It may be that we treat such a case as an error. If we permit such
+  // a case then we either get to generate a half close or purposefully omit it.
+  public abstract static class Listener<ReqT> {
+    /**
+     * A request message has been received. For streaming calls, there may be zero or more request
+     * messages.
+     *
+     * @param message a received request message.
+     */
+    public void onMessage(ReqT message) {}
+
+    /**
+     * The client completed all message sending. However, the call may still be cancelled.
+     */
+    public void onHalfClose() {}
+
+    /**
+     * The call was cancelled and the server is encouraged to abort processing to save resources,
+     * since the client will not process any further messages. Cancellations can be caused by
+     * timeouts, explicit cancellation by the client, network errors, etc.
+     *
+     * <p>There will be no further callbacks for the call.
+     */
+    public void onCancel() {}
+
+    /**
+     * The call is considered complete and {@link #onCancel} is guaranteed not to be called.
+     * However, the client is not guaranteed to have received all messages.
+     *
+     * <p>There will be no further callbacks for the call.
+     */
+    public void onComplete() {}
+
+    /**
+     * This indicates that the call may now be capable of sending additional messages (via
+     * {@link #sendMessage}) without requiring excessive buffering internally. This event is
+     * just a suggestion and the application is free to ignore it, however doing so may
+     * result in excessive buffering within the call.
+     *
+     * <p>Because there is a processing delay to deliver this notification, it is possible for
+     * concurrent writes to cause {@code isReady() == false} within this callback. Handle "spurious"
+     * notifications by checking {@code isReady()}'s current value instead of assuming it is now
+     * {@code true}. If {@code isReady() == false} the normal expectations apply, so there would be
+     * <em>another</em> {@code onReady()} callback.
+     */
+    public void onReady() {}
+  }
+
+  /**
+   * Requests up to the given number of messages from the call to be delivered to
+   * {@link Listener#onMessage(Object)}. Once {@code numMessages} have been delivered
+   * no further request messages will be delivered until more messages are requested by
+   * calling this method again.
+   *
+   * <p>Servers use this mechanism to provide back-pressure to the client for flow-control.
+   *
+   * <p>This method is safe to call from multiple threads without external synchronization.
+   *
+   * @param numMessages the requested number of messages to be delivered to the listener.
+   */
+  public abstract void request(int numMessages);
+
+  /**
+   * Send response header metadata prior to sending a response message. This method may
+   * only be called once and cannot be called after calls to {@link #sendMessage} or {@link #close}.
+   *
+   * <p>Since {@link Metadata} is not thread-safe, the caller must not access (read or write) {@code
+   * headers} after this point.
+   *
+   * @param headers metadata to send prior to any response body.
+   * @throws IllegalStateException if {@code close} has been called, a message has been sent, or
+   *     headers have already been sent
+   */
+  public abstract void sendHeaders(Metadata headers);
+
+  /**
+   * Send a response message. Messages are the primary form of communication associated with
+   * RPCs. Multiple response messages may exist for streaming calls.
+   *
+   * @param message response message.
+   * @throws IllegalStateException if headers not sent or call is {@link #close}d
+   */
+  public abstract void sendMessage(RespT message);
+
+  /**
+   * If {@code true}, indicates that the call is capable of sending additional messages
+   * without requiring excessive buffering internally. This event is
+   * just a suggestion and the application is free to ignore it, however doing so may
+   * result in excessive buffering within the call.
+   *
+   * <p>If {@code false}, {@link Listener#onReady()} will be called after {@code isReady()}
+   * transitions to {@code true}.
+   *
+   * <p>This abstract class's implementation always returns {@code true}. Implementations generally
+   * override the method.
+   */
+  public boolean isReady() {
+    return true;
+  }
+
+  /**
+   * Close the call with the provided status. No further sending or receiving will occur. If {@link
+   * Status#isOk} is {@code false}, then the call is said to have failed.
+   *
+   * <p>If no errors or cancellations are known to have occurred, then a {@link Listener#onComplete}
+   * notification should be expected, independent of {@code status}. Otherwise {@link
+   * Listener#onCancel} has been or will be called.
+   *
+   * <p>Since {@link Metadata} is not thread-safe, the caller must not access (read or write) {@code
+   * trailers} after this point.
+   *
+   * <p>This method implies the caller completed processing the RPC, but it does not imply the RPC
+   * is complete. The call implementation will need additional time to complete the RPC and during
+   * this time the client is still able to cancel the request or a network error might cause the
+   * RPC to fail. If you wish to know when the call is actually completed/closed, you have to use
+   * {@link Listener#onComplete} or {@link Listener#onCancel} instead. This method is not
+   * necessarily invoked when Listener.onCancel() is called.
+   *
+   * @throws IllegalStateException if call is already {@code close}d
+   */
+  public abstract void close(Status status, Metadata trailers);
+
+  /**
+   * Returns {@code true} when the call is cancelled and the server is encouraged to abort
+   * processing to save resources, since the client will not be processing any further methods.
+   * Cancellations can be caused by timeouts, explicit cancel by client, network errors, and
+   * similar.
+   *
+   * <p>This method may safely be called concurrently from multiple threads.
+   */
+  public abstract boolean isCancelled();
+
+  /**
+   * Enables per-message compression, if an encoding type has been negotiated.  If no message
+   * encoding has been negotiated, this is a no-op. By default per-message compression is enabled,
+   * but may not have any effect if compression is not enabled on the call.
+   */
+  public void setMessageCompression(boolean enabled) {
+    // noop
+  }
+
+  /**
+   * Sets the compression algorithm for this call.  This compression is utilized for sending.  If
+   * the server does not support the compression algorithm, the call will fail.  This method may
+   * only be called before {@link #sendHeaders}.  The compressor to use will be looked up in the
+   * {@link CompressorRegistry}.  Default gRPC servers support the "gzip" compressor.
+   *
+   * <p>It is safe to call this even if the client does not support the compression format chosen.
+   * The implementation will handle negotiation with the client and may fall back to no compression.
+   *
+   * @param compressor the name of the compressor to use.
+   * @throws IllegalArgumentException if the compressor name can not be found.
+   */
+  public void setCompression(String compressor) {
+    // noop
+  }
+
+  /**
+   * A hint to the call that specifies how many bytes must be queued before
+   * {@link #isReady()} will return false. A call may ignore this property if
+   * unsupported. This may only be set before any messages are sent.
+   *
+   * @param numBytes The number of bytes that must be queued. Must be a
+   *                 positive integer.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11021")
+  public void setOnReadyThreshold(int numBytes) {
+    checkArgument(numBytes > 0, "numBytes must be positive: %s", numBytes);
+  }
+
+  /**
+   * Returns the level of security guarantee in communications
+   *
+   * <p>Determining the level of security offered by the transport for RPCs on server-side.
+   * This can be approximated by looking for the SSLSession, but that doesn't work for ALTS and
+   * maybe some future TLS approaches. May return a lower security level when it cannot be
+   * determined precisely.
+   *
+   * @return non-{@code null} SecurityLevel enum
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4692")
+  public SecurityLevel getSecurityLevel() {
+    return SecurityLevel.NONE;
+  }
+
+  /**
+   * Returns properties of a single call.
+   *
+   * <p>Attributes originate from the transport and can be altered by {@link ServerTransportFilter}.
+   *
+   * @return non-{@code null} Attributes container
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1779")
+  @Grpc.TransportAttr
+  public Attributes getAttributes() {
+    return Attributes.EMPTY;
+  }
+
+  /**
+   * Gets the authority this call is addressed to.
+   *
+   * @return the authority string. {@code null} if not available.
+   */
+  @Nullable
+  public String getAuthority() {
+    return null;
+  }
+
+  /**
+   * The {@link MethodDescriptor} for the call.
+   */
+  public abstract MethodDescriptor<ReqT, RespT> getMethodDescriptor();
+}
diff --git a/api/src/main/java/io/grpc/ServerCallExecutorSupplier.java b/api/src/main/java/io/grpc/ServerCallExecutorSupplier.java
new file mode 100644
index 00000000000..c990dc943e5
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServerCallExecutorSupplier.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2021 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;
+
+import java.util.concurrent.Executor;
+import javax.annotation.Nullable;
+
+/**
+ * Defines what executor handles the server call, based on each RPC call information at runtime.
+ * */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/8274")
+public interface ServerCallExecutorSupplier {
+
+  /**
+   * Returns an executor to handle the server call.
+   * It should never throw. It should return null to fallback to the default executor.
+   * */
+  @Nullable
+  <ReqT, RespT> Executor getExecutor(ServerCall<ReqT, RespT> call, Metadata metadata);
+}
diff --git a/api/src/main/java/io/grpc/ServerCallHandler.java b/api/src/main/java/io/grpc/ServerCallHandler.java
new file mode 100644
index 00000000000..fdfa9997957
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServerCallHandler.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2014 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;
+
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Interface to initiate processing of incoming remote calls. Advanced applications and generated
+ * code will implement this interface to allows {@link Server}s to invoke service methods.
+ */
+@ThreadSafe
+public interface ServerCallHandler<RequestT, ResponseT> {
+  /**
+   * Starts asynchronous processing of an incoming call.
+   *
+   * <p>Callers of this method transfer their ownership of the non-thread-safe {@link ServerCall}
+   * and {@link Metadata} arguments to the {@link ServerCallHandler} implementation for processing.
+   * Ownership means that the implementation may invoke methods on {@code call} and {@code headers}
+   * while {@link #startCall} runs and at any time after it returns normally. On the other hand, if
+   * {@link #startCall} throws, ownership of {@code call} and {@code headers} reverts to the caller
+   * and the implementation loses the right to call methods on these objects (from some other
+   * thread, say).
+   *
+   * <p>Ownership also includes the responsibility to eventually close {@code call}. In particular,
+   * if {@link #startCall} throws an exception, the caller must handle it by closing {@code call}
+   * with an error. Since {@code call} can only be closed once, an implementation can report errors
+   * either to {@link ServerCall#close} for itself or by throwing an exception, but not both.
+   *
+   * <p>Returns a non-{@code null} listener for the incoming call. Callers of this method must
+   * arrange for events associated with {@code call} to be delivered there.
+   *
+   * @param call object for responding to the remote client.
+   * @param headers request headers received from the client but open to modification by an owner
+   * @return listener for processing incoming request messages for {@code call}
+   */
+  ServerCall.Listener<RequestT> startCall(
+      ServerCall<RequestT, ResponseT> call,
+      Metadata headers);
+}
diff --git a/api/src/main/java/io/grpc/ServerCredentials.java b/api/src/main/java/io/grpc/ServerCredentials.java
new file mode 100644
index 00000000000..2b648aaeb7c
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServerCredentials.java
@@ -0,0 +1,36 @@
+/*
+ * 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;
+
+/**
+ * Represents a security configuration to be used for servers. There is no generic mechanism for
+ * processing arbitrary {@code ServerCredentials}; the consumer of the credential (the server)
+ * must support each implementation explicitly and separately. Consumers are not required to support
+ * all types or even all possible configurations for types that are partially supported, but they
+ * <em>must</em> at least fully support {@link ChoiceServerCredentials}.
+ *
+ * <p>A {@code ServerCredential} provides server identity. They can also influence types of
+ * encryption used and similar security configuration.
+ *
+ * <p>The concrete credential type should not be relevant to most users of the API and may be an
+ * implementation decision. Users should generally use the {@code ServerCredentials} type for
+ * variables instead of the concrete type. Freshly-constructed credentials should be returned as
+ * {@code ServerCredentials} instead of a concrete type to encourage this pattern. Concrete types
+ * would only be used after {@code instanceof} checks (which must consider
+ * {@code ChoiceServerCredentials}!).
+ */
+public abstract class ServerCredentials {}
diff --git a/api/src/main/java/io/grpc/ServerInterceptor.java b/api/src/main/java/io/grpc/ServerInterceptor.java
new file mode 100644
index 00000000000..9b2e76ef608
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServerInterceptor.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2014 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;
+
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Interface for intercepting incoming calls before they are dispatched by
+ * {@link ServerCallHandler}.
+ *
+ * <p>Implementers use this mechanism to add cross-cutting behavior to server-side calls. Common
+ * example of such behavior include:
+ * <ul>
+ * <li>Enforcing valid authentication credentials</li>
+ * <li>Logging and monitoring call behavior</li>
+ * <li>Delegating calls to other servers</li>
+ * </ul>
+ *
+ * <p>The interceptor may be called for multiple {@link ServerCall calls} by one or more threads
+ * without completing the previous ones first. Refer to the
+ * {@link io.grpc.ServerCall.Listener ServerCall.Listener} docs for more details regarding thread
+ * safety of the returned listener.
+ */
+@ThreadSafe
+public interface ServerInterceptor {
+  /**
+   * Intercept {@link ServerCall} dispatch by the {@code next} {@link ServerCallHandler}. General
+   * semantics of {@link ServerCallHandler#startCall} apply and the returned
+   * {@link io.grpc.ServerCall.Listener} must not be {@code null}.
+   *
+   * <p>If the implementation throws an exception, {@code call} will be closed with an error.
+   * Implementations must not throw an exception if they started processing that may use {@code
+   * call} on another thread.
+   *
+   * @param call object to receive response messages
+   * @param headers which can contain extra call metadata from {@link ClientCall#start},
+   *                e.g. authentication credentials.
+   * @param next next processor in the interceptor chain
+   * @return listener for processing incoming messages for {@code call}, never {@code null}.
+   */
+  <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+      ServerCall<ReqT, RespT> call,
+      Metadata headers,
+      ServerCallHandler<ReqT, RespT> next);
+}
diff --git a/api/src/main/java/io/grpc/ServerInterceptors.java b/api/src/main/java/io/grpc/ServerInterceptors.java
new file mode 100644
index 00000000000..6626c8e5810
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServerInterceptors.java
@@ -0,0 +1,331 @@
+/*
+ * Copyright 2014 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;
+
+import com.google.common.base.Preconditions;
+import java.io.BufferedInputStream;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Utility methods for working with {@link ServerInterceptor}s.
+ */
+public final class ServerInterceptors {
+  // Prevent instantiation
+  private ServerInterceptors() {}
+
+  /**
+   * Create a new {@code ServerServiceDefinition} whose {@link ServerCallHandler}s will call
+   * {@code interceptors} before calling the pre-existing {@code ServerCallHandler}. The first
+   * interceptor will have its {@link ServerInterceptor#interceptCall} called first.
+   *
+   * @param serviceDef   the service definition for which to intercept all its methods.
+   * @param interceptors array of interceptors to apply to the service.
+   * @return a wrapped version of {@code serviceDef} with the interceptors applied.
+   */
+  public static ServerServiceDefinition interceptForward(ServerServiceDefinition serviceDef,
+                                                         ServerInterceptor... interceptors) {
+    return interceptForward(serviceDef, Arrays.asList(interceptors));
+  }
+
+  public static ServerServiceDefinition interceptForward(BindableService bindableService,
+      ServerInterceptor... interceptors) {
+    return interceptForward(bindableService.bindService(), Arrays.asList(interceptors));
+  }
+
+  /**
+   * Create a new {@code ServerServiceDefinition} whose {@link ServerCallHandler}s will call
+   * {@code interceptors} before calling the pre-existing {@code ServerCallHandler}. The first
+   * interceptor will have its {@link ServerInterceptor#interceptCall} called first.
+   *
+   * @param serviceDef   the service definition for which to intercept all its methods.
+   * @param interceptors list of interceptors to apply to the service.
+   * @return a wrapped version of {@code serviceDef} with the interceptors applied.
+   */
+  public static ServerServiceDefinition interceptForward(
+      ServerServiceDefinition serviceDef,
+      List<? extends ServerInterceptor> interceptors) {
+    List<? extends ServerInterceptor> copy = new ArrayList<>(interceptors);
+    Collections.reverse(copy);
+    return intercept(serviceDef, copy);
+  }
+
+  public static ServerServiceDefinition interceptForward(
+      BindableService bindableService,
+      List<? extends ServerInterceptor> interceptors) {
+    return interceptForward(bindableService.bindService(), interceptors);
+  }
+
+  /**
+   * Create a new {@code ServerServiceDefinition} whose {@link ServerCallHandler}s will call
+   * {@code interceptors} before calling the pre-existing {@code ServerCallHandler}. The last
+   * interceptor will have its {@link ServerInterceptor#interceptCall} called first.
+   *
+   * @param serviceDef   the service definition for which to intercept all its methods.
+   * @param interceptors array of interceptors to apply to the service.
+   * @return a wrapped version of {@code serviceDef} with the interceptors applied.
+   */
+  public static ServerServiceDefinition intercept(ServerServiceDefinition serviceDef,
+                                                  ServerInterceptor... interceptors) {
+    return intercept(serviceDef, Arrays.asList(interceptors));
+  }
+
+  public static ServerServiceDefinition intercept(BindableService bindableService,
+      ServerInterceptor... interceptors) {
+    Preconditions.checkNotNull(bindableService, "bindableService");
+    return intercept(bindableService.bindService(), Arrays.asList(interceptors));
+  }
+
+  /**
+   * Create a new {@code ServerServiceDefinition} whose {@link ServerCallHandler}s will call
+   * {@code interceptors} before calling the pre-existing {@code ServerCallHandler}. The last
+   * interceptor will have its {@link ServerInterceptor#interceptCall} called first.
+   *
+   * @param serviceDef   the service definition for which to intercept all its methods.
+   * @param interceptors list of interceptors to apply to the service.
+   * @return a wrapped version of {@code serviceDef} with the interceptors applied.
+   */
+  public static ServerServiceDefinition intercept(ServerServiceDefinition serviceDef,
+                                                  List<? extends ServerInterceptor> interceptors) {
+    Preconditions.checkNotNull(serviceDef, "serviceDef");
+    if (interceptors.isEmpty()) {
+      return serviceDef;
+    }
+    ServerServiceDefinition.Builder serviceDefBuilder
+        = ServerServiceDefinition.builder(serviceDef.getServiceDescriptor());
+    for (ServerMethodDefinition<?, ?> method : serviceDef.getMethods()) {
+      wrapAndAddMethod(serviceDefBuilder, method, interceptors);
+    }
+    return serviceDefBuilder.build();
+  }
+
+  public static ServerServiceDefinition intercept(BindableService bindableService,
+      List<? extends ServerInterceptor> interceptors) {
+    Preconditions.checkNotNull(bindableService, "bindableService");
+    return intercept(bindableService.bindService(), interceptors);
+  }
+
+  /**
+   * Create a new {@code ServerServiceDefinition} whose {@link MethodDescriptor} serializes to
+   * and from InputStream for all methods.  The InputStream is guaranteed return true for
+   * markSupported().  The {@code ServerCallHandler} created will automatically
+   * convert back to the original types for request and response before calling the existing
+   * {@code ServerCallHandler}.  Calling this method combined with the intercept methods will
+   * allow the developer to choose whether to intercept messages of InputStream, or the modeled
+   * types of their application.
+   *
+   * @param serviceDef the service definition to convert messages to InputStream
+   * @return a wrapped version of {@code serviceDef} with the InputStream conversion applied.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1712")
+  public static ServerServiceDefinition useInputStreamMessages(
+      final ServerServiceDefinition serviceDef) {
+    final MethodDescriptor.Marshaller<InputStream> marshaller =
+        new MethodDescriptor.Marshaller<InputStream>() {
+          @Override
+          public InputStream stream(final InputStream value) {
+            return value;
+          }
+
+          @Override
+          public InputStream parse(final InputStream stream) {
+            if (stream.markSupported()) {
+              return stream;
+            } else if (stream instanceof KnownLength) {
+              return new KnownLengthBufferedInputStream(stream);
+            } else {
+              return new BufferedInputStream(stream);
+            }
+          }
+        };
+
+    return useMarshalledMessages(serviceDef, marshaller);
+  }
+
+  /** {@link BufferedInputStream} that also implements {@link KnownLength}. */
+  private static final class KnownLengthBufferedInputStream extends BufferedInputStream
+      implements KnownLength {
+    KnownLengthBufferedInputStream(InputStream in) {
+      super(in);
+    }
+  }
+
+  /**
+   * Create a new {@code ServerServiceDefinition} whose {@link MethodDescriptor} serializes to
+   * and from T for all methods.  The {@code ServerCallHandler} created will automatically
+   * convert back to the original types for request and response before calling the existing
+   * {@code ServerCallHandler}.  Calling this method combined with the intercept methods will
+   * allow the developer to choose whether to intercept messages of T, or the modeled types
+   * of their application.  This can also be chained to allow for interceptors to handle messages
+   * as multiple different T types within the chain if the added cost of serialization is not
+   * a concern.
+   *
+   * @param serviceDef the service definition to convert messages to T
+   * @return a wrapped version of {@code serviceDef} with the T conversion applied.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1712")
+  public static <T> ServerServiceDefinition useMarshalledMessages(
+      final ServerServiceDefinition serviceDef,
+      final MethodDescriptor.Marshaller<T> marshaller) {
+    return useMarshalledMessages(serviceDef, marshaller, marshaller);
+  }
+
+  /**
+   * Create a new {@code ServerServiceDefinition} with {@link MethodDescriptor} for deserializing
+   * requests and separate {@link MethodDescriptor} for serializing responses. The {@code
+   * ServerCallHandler} created will automatically convert back to the original types for request
+   * and response before calling the existing {@code ServerCallHandler}.  Calling this method
+   * combined with the intercept methods will allow the developer to choose whether to intercept
+   * messages of ReqT/RespT, or the modeled types of their application. This can also be chained
+   * to allow for interceptors to handle messages as multiple different ReqT/RespT types within
+   * the chain if the added cost of serialization is not a concern.
+   *
+   * @param serviceDef         the service definition to add request and response marshallers to.
+   * @param requestMarshaller  request marshaller
+   * @param responseMarshaller response marshaller
+   * @param <ReqT>             the request payload type
+   * @param <RespT>            the response payload type.
+   * @return a wrapped version of {@code serviceDef} with the ReqT and RespT conversion applied.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/9870")
+  public static <ReqT, RespT> ServerServiceDefinition useMarshalledMessages(
+      final ServerServiceDefinition serviceDef,
+      final MethodDescriptor.Marshaller<ReqT> requestMarshaller,
+      final MethodDescriptor.Marshaller<RespT> responseMarshaller) {
+    List<ServerMethodDefinition<?, ?>> wrappedMethods =
+        new ArrayList<>();
+    List<MethodDescriptor<?, ?>> wrappedDescriptors =
+        new ArrayList<>();
+    // Wrap the descriptors
+    for (final ServerMethodDefinition<?, ?> definition : serviceDef.getMethods()) {
+      final MethodDescriptor<?, ?> originalMethodDescriptor = definition.getMethodDescriptor();
+      final MethodDescriptor<ReqT, RespT> wrappedMethodDescriptor =
+          originalMethodDescriptor.toBuilder(requestMarshaller, responseMarshaller).build();
+      wrappedDescriptors.add(wrappedMethodDescriptor);
+      wrappedMethods.add(wrapMethod(definition, wrappedMethodDescriptor));
+    }
+    // Build the new service descriptor
+    final ServiceDescriptor.Builder serviceDescriptorBuilder =
+        ServiceDescriptor.newBuilder(serviceDef.getServiceDescriptor().getName())
+            .setSchemaDescriptor(serviceDef.getServiceDescriptor().getSchemaDescriptor());
+    for (MethodDescriptor<?, ?> wrappedDescriptor : wrappedDescriptors) {
+      serviceDescriptorBuilder.addMethod(wrappedDescriptor);
+    }
+    // Create the new service definition.
+    final ServerServiceDefinition.Builder serviceBuilder =
+        ServerServiceDefinition.builder(serviceDescriptorBuilder.build());
+    for (ServerMethodDefinition<?, ?> definition : wrappedMethods) {
+      serviceBuilder.addMethod(definition);
+    }
+    return serviceBuilder.build();
+  }
+
+  private static <ReqT, RespT> void wrapAndAddMethod(
+      ServerServiceDefinition.Builder serviceDefBuilder, ServerMethodDefinition<ReqT, RespT> method,
+      List<? extends ServerInterceptor> interceptors) {
+    ServerCallHandler<ReqT, RespT> callHandler = method.getServerCallHandler();
+    for (ServerInterceptor interceptor : interceptors) {
+      callHandler = InterceptCallHandler.create(interceptor, callHandler);
+    }
+    serviceDefBuilder.addMethod(method.withServerCallHandler(callHandler));
+  }
+
+  static final class InterceptCallHandler<ReqT, RespT> implements ServerCallHandler<ReqT, RespT> {
+    public static <ReqT, RespT> InterceptCallHandler<ReqT, RespT> create(
+        ServerInterceptor interceptor, ServerCallHandler<ReqT, RespT> callHandler) {
+      return new InterceptCallHandler<>(interceptor, callHandler);
+    }
+
+    private final ServerInterceptor interceptor;
+    private final ServerCallHandler<ReqT, RespT> callHandler;
+
+    private InterceptCallHandler(
+        ServerInterceptor interceptor, ServerCallHandler<ReqT, RespT> callHandler) {
+      this.interceptor = Preconditions.checkNotNull(interceptor, "interceptor");
+      this.callHandler = callHandler;
+    }
+
+    @Override
+    public ServerCall.Listener<ReqT> startCall(
+        ServerCall<ReqT, RespT> call,
+        Metadata headers) {
+      return interceptor.interceptCall(call, headers, callHandler);
+    }
+  }
+
+  static <OReqT, ORespT, WReqT, WRespT> ServerMethodDefinition<WReqT, WRespT> wrapMethod(
+      final ServerMethodDefinition<OReqT, ORespT> definition,
+      final MethodDescriptor<WReqT, WRespT> wrappedMethod) {
+    final ServerCallHandler<WReqT, WRespT> wrappedHandler = wrapHandler(
+        definition.getServerCallHandler(),
+        definition.getMethodDescriptor(),
+        wrappedMethod);
+    return ServerMethodDefinition.create(wrappedMethod, wrappedHandler);
+  }
+
+  private static <OReqT, ORespT, WReqT, WRespT> ServerCallHandler<WReqT, WRespT> wrapHandler(
+      final ServerCallHandler<OReqT, ORespT> originalHandler,
+      final MethodDescriptor<OReqT, ORespT> originalMethod,
+      final MethodDescriptor<WReqT, WRespT> wrappedMethod) {
+    return new ServerCallHandler<WReqT, WRespT>() {
+      @Override
+      public ServerCall.Listener<WReqT> startCall(
+          final ServerCall<WReqT, WRespT> call,
+          final Metadata headers) {
+        final ServerCall<OReqT, ORespT> unwrappedCall =
+            new PartialForwardingServerCall<OReqT, ORespT>() {
+              @Override
+              protected ServerCall<WReqT, WRespT> delegate() {
+                return call;
+              }
+
+              @Override
+              public void sendMessage(ORespT message) {
+                final InputStream is = originalMethod.streamResponse(message);
+                final WRespT wrappedMessage = wrappedMethod.parseResponse(is);
+                delegate().sendMessage(wrappedMessage);
+              }
+
+              @Override
+              public MethodDescriptor<OReqT, ORespT> getMethodDescriptor() {
+                return originalMethod;
+              }
+            };
+
+        final ServerCall.Listener<OReqT> originalListener = originalHandler
+            .startCall(unwrappedCall, headers);
+
+        return new PartialForwardingServerCallListener<WReqT>() {
+          @Override
+          protected ServerCall.Listener<OReqT> delegate() {
+            return originalListener;
+          }
+
+          @Override
+          public void onMessage(WReqT message) {
+            final InputStream is = wrappedMethod.streamRequest(message);
+            final OReqT originalMessage = originalMethod.parseRequest(is);
+            delegate().onMessage(originalMessage);
+          }
+        };
+      }
+    };
+  }
+}
diff --git a/api/src/main/java/io/grpc/ServerMethodDefinition.java b/api/src/main/java/io/grpc/ServerMethodDefinition.java
new file mode 100644
index 00000000000..b2f6ae7d832
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServerMethodDefinition.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2014 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;
+
+/**
+ * Definition of a method exposed by a {@link Server}.
+ *
+ * @see ServerServiceDefinition
+ */
+public final class ServerMethodDefinition<ReqT, RespT> {
+  private final MethodDescriptor<ReqT, RespT> method;
+  private final ServerCallHandler<ReqT, RespT> handler;
+
+  private ServerMethodDefinition(MethodDescriptor<ReqT, RespT> method,
+      ServerCallHandler<ReqT, RespT> handler) {
+    this.method = method;
+    this.handler = handler;
+  }
+
+  /**
+   * Create a new instance.
+   *
+   * @param method the {@link MethodDescriptor} for this method.
+   * @param handler to dispatch calls to.
+   * @return a new instance.
+   */
+  public static <ReqT, RespT> ServerMethodDefinition<ReqT, RespT> create(
+      MethodDescriptor<ReqT, RespT> method,
+      ServerCallHandler<ReqT, RespT> handler) {
+    return new ServerMethodDefinition<>(method, handler);
+  }
+
+  /** The {@code MethodDescriptor} for this method. */
+  public MethodDescriptor<ReqT, RespT> getMethodDescriptor() {
+    return method;
+  }
+
+  /** Handler for incoming calls. */
+  public ServerCallHandler<ReqT, RespT> getServerCallHandler() {
+    return handler;
+  }
+
+  /**
+   * Create a new method definition with a different call handler.
+   *
+   * @param handler to bind to a cloned instance of this.
+   * @return a cloned instance of this with the new handler bound.
+   */
+  public ServerMethodDefinition<ReqT, RespT> withServerCallHandler(
+      ServerCallHandler<ReqT, RespT> handler) {
+    return new ServerMethodDefinition<>(method, handler);
+  }
+}
diff --git a/api/src/main/java/io/grpc/ServerProvider.java b/api/src/main/java/io/grpc/ServerProvider.java
new file mode 100644
index 00000000000..f72880b375d
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServerProvider.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2015 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;
+
+import com.google.common.base.Preconditions;
+import io.grpc.ManagedChannelProvider.ProviderNotFoundException;
+
+/**
+ * Provider of servers for transport agnostic consumption.
+ *
+ * <p>Implementations can be automatically discovered by gRPC via Java's SPI mechanism. For
+ * automatic discovery, the implementation must have a zero-argument constructor and include
+ * a resource named {@code META-INF/services/io.grpc.ServerProvider} in their JAR. The
+ * file's contents should be the implementation's class name.
+ *
+ * <p>Implementations <em>should not</em> throw. If they do, it may interrupt class loading. If
+ * exceptions may reasonably occur for implementation-specific reasons, implementations should
+ * generally handle the exception gracefully and return {@code false} from {@link #isAvailable()}.
+ */
+@Internal
+public abstract class ServerProvider {
+  /**
+   * Returns the ClassLoader-wide default server.
+   *
+   * @throws ProviderNotFoundException if no provider is available
+   */
+  public static ServerProvider provider() {
+    ServerProvider provider = ServerRegistry.getDefaultRegistry().provider();
+    if (provider == null) {
+      throw new ProviderNotFoundException("No functional server found. "
+          + "Try adding a dependency on the grpc-netty or grpc-netty-shaded artifact");
+    }
+    return provider;
+  }
+
+  /**
+   * Whether this provider is available for use, taking the current environment into consideration.
+   * If {@code false}, no other methods are safe to be called.
+   */
+  protected abstract boolean isAvailable();
+
+  /**
+   * A priority, from 0 to 10 that this provider should be used, taking the current environment into
+   * consideration. 5 should be considered the default, and then tweaked based on environment
+   * detection. A priority of 0 does not imply that the provider wouldn't work; just that it should
+   * be last in line.
+   */
+  protected abstract int priority();
+
+  /**
+   * Creates a new builder with the given port.
+   */
+  protected abstract ServerBuilder<?> builderForPort(int port);
+
+  /**
+   * Creates a new builder with the given port and credentials. Returns an error-string result if
+   * unable to understand the credentials.
+   */
+  protected NewServerBuilderResult newServerBuilderForPort(int port, ServerCredentials creds) {
+    return NewServerBuilderResult.error("ServerCredentials are unsupported");
+  }
+
+  public static final class NewServerBuilderResult {
+    private final ServerBuilder<?> serverBuilder;
+    private final String error;
+
+    private NewServerBuilderResult(ServerBuilder<?> serverBuilder, String error) {
+      this.serverBuilder = serverBuilder;
+      this.error = error;
+    }
+
+    public static NewServerBuilderResult serverBuilder(ServerBuilder<?> builder) {
+      return new NewServerBuilderResult(Preconditions.checkNotNull(builder), null);
+    }
+
+    public static NewServerBuilderResult error(String error) {
+      return new NewServerBuilderResult(null, Preconditions.checkNotNull(error));
+    }
+
+    public ServerBuilder<?> getServerBuilder() {
+      return serverBuilder;
+    }
+
+    public String getError() {
+      return error;
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/ServerRegistry.java b/api/src/main/java/io/grpc/ServerRegistry.java
new file mode 100644
index 00000000000..5b9c8c558e7
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServerRegistry.java
@@ -0,0 +1,180 @@
+/*
+ * 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;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Registry of {@link ServerProvider}s. The {@link #getDefaultRegistry default instance} loads
+ * providers at runtime through the Java service provider mechanism.
+ */
+@Internal
+@ThreadSafe
+public final class ServerRegistry {
+  private static final Logger logger = Logger.getLogger(ServerRegistry.class.getName());
+  private static ServerRegistry instance;
+
+  @GuardedBy("this")
+  private final LinkedHashSet<ServerProvider> allProviders = new LinkedHashSet<>();
+  /** Immutable, sorted version of {@code allProviders}. Is replaced instead of mutating. */
+  @GuardedBy("this")
+  private List<ServerProvider> effectiveProviders = Collections.emptyList();
+
+  /**
+   * Register a provider.
+   *
+   * <p>If the provider's {@link ServerProvider#isAvailable isAvailable()} returns
+   * {@code false}, this method will throw {@link IllegalArgumentException}.
+   *
+   * <p>Providers will be used in priority order. In case of ties, providers are used in
+   * registration order.
+   */
+  public synchronized void register(ServerProvider provider) {
+    addProvider(provider);
+    refreshProviders();
+  }
+
+  private synchronized void addProvider(ServerProvider provider) {
+    Preconditions.checkArgument(provider.isAvailable(), "isAvailable() returned false");
+    allProviders.add(provider);
+  }
+
+  /**
+   * Deregisters a provider.  No-op if the provider is not in the registry.
+   *
+   * @param provider the provider that was added to the register via {@link #register}.
+   */
+  public synchronized void deregister(ServerProvider provider) {
+    allProviders.remove(provider);
+    refreshProviders();
+  }
+
+  private synchronized void refreshProviders() {
+    List<ServerProvider> providers = new ArrayList<>(allProviders);
+    // Sort descending based on priority.
+    // sort() must be stable, as we prefer first-registered providers
+    Collections.sort(providers, Collections.reverseOrder(new Comparator<ServerProvider>() {
+      @Override
+      public int compare(ServerProvider o1, ServerProvider o2) {
+        return o1.priority() - o2.priority();
+      }
+    }));
+    effectiveProviders = Collections.unmodifiableList(providers);
+  }
+
+  /**
+   * Returns the default registry that loads providers via the Java service loader mechanism.
+   */
+  public static synchronized ServerRegistry getDefaultRegistry() {
+    if (instance == null) {
+      List<ServerProvider> providerList = ServiceProviders.loadAll(
+          ServerProvider.class,
+          getHardCodedClasses(),
+          ServerProvider.class.getClassLoader(),
+          new ServerPriorityAccessor());
+      instance = new ServerRegistry();
+      for (ServerProvider provider : providerList) {
+        logger.fine("Service loader found " + provider);
+        instance.addProvider(provider);
+      }
+      instance.refreshProviders();
+    }
+    return instance;
+  }
+
+  /**
+   * Returns effective providers, in priority order.
+   */
+  @VisibleForTesting
+  synchronized List<ServerProvider> providers() {
+    return effectiveProviders;
+  }
+
+  // For emulating ServerProvider.provider()
+  ServerProvider provider() {
+    List<ServerProvider> providers = providers();
+    return providers.isEmpty() ? null : providers.get(0);
+  }
+
+  @VisibleForTesting
+  static List<Class<?>> getHardCodedClasses() {
+    // Class.forName(String) is used to remove the need for ProGuard configuration. Note that
+    // ProGuard does not detect usages of Class.forName(String, boolean, ClassLoader):
+    // https://sourceforge.net/p/proguard/bugs/418/
+    List<Class<?>> list = new ArrayList<>();
+    try {
+      list.add(Class.forName("io.grpc.okhttp.OkHttpServerProvider"));
+    } catch (ClassNotFoundException e) {
+      logger.log(Level.FINE, "Unable to find OkHttpServerProvider", e);
+    }
+    return Collections.unmodifiableList(list);
+  }
+
+  ServerBuilder<?> newServerBuilderForPort(int port, ServerCredentials creds) {
+    List<ServerProvider> providers = providers();
+    if (providers.isEmpty()) {
+      throw new ProviderNotFoundException("No functional server found. "
+          + "Try adding a dependency on the grpc-netty, grpc-netty-shaded, or grpc-okhttp "
+          + "artifact");
+    }
+    StringBuilder error = new StringBuilder();
+    for (ServerProvider provider : providers()) {
+      ServerProvider.NewServerBuilderResult result
+          = provider.newServerBuilderForPort(port, creds);
+      if (result.getServerBuilder() != null) {
+        return result.getServerBuilder();
+      }
+      error.append("; ");
+      error.append(provider.getClass().getName());
+      error.append(": ");
+      error.append(result.getError());
+    }
+    throw new ProviderNotFoundException(error.substring(2));
+  }
+
+  private static final class ServerPriorityAccessor
+      implements ServiceProviders.PriorityAccessor<ServerProvider> {
+    @Override
+    public boolean isAvailable(ServerProvider provider) {
+      return provider.isAvailable();
+    }
+
+    @Override
+    public int getPriority(ServerProvider provider) {
+      return provider.priority();
+    }
+  }
+
+  /** Thrown when no suitable {@link ServerProvider} objects can be found. */
+  public static final class ProviderNotFoundException extends RuntimeException {
+    private static final long serialVersionUID = 1;
+
+    public ProviderNotFoundException(String msg) {
+      super(msg);
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/ServerServiceDefinition.java b/api/src/main/java/io/grpc/ServerServiceDefinition.java
new file mode 100644
index 00000000000..75f1071820f
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServerServiceDefinition.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2014 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/** Definition of a service to be exposed via a Server. */
+public final class ServerServiceDefinition {
+  /** Convenience that constructs a {@link ServiceDescriptor} simultaneously. */
+  public static Builder builder(String serviceName) {
+    return new Builder(serviceName);
+  }
+
+  public static Builder builder(ServiceDescriptor serviceDescriptor) {
+    return new Builder(serviceDescriptor);
+  }
+
+  private final ServiceDescriptor serviceDescriptor;
+  private final Map<String, ServerMethodDefinition<?, ?>> methods;
+
+  private ServerServiceDefinition(
+      ServiceDescriptor serviceDescriptor, Map<String, ServerMethodDefinition<?, ?>> methods) {
+    this.serviceDescriptor = checkNotNull(serviceDescriptor, "serviceDescriptor");
+    this.methods = Collections.unmodifiableMap(new HashMap<>(methods));
+  }
+
+  /**
+   * The descriptor for the service.
+   */
+  public ServiceDescriptor getServiceDescriptor() {
+    return serviceDescriptor;
+  }
+
+  /**
+   * Gets all the methods of service.
+   */
+  public Collection<ServerMethodDefinition<?, ?>> getMethods() {
+    return methods.values();
+  }
+
+  /**
+   * Look up a method by its fully qualified name.
+   *
+   * @param methodName the fully qualified name without leading slash. E.g., "com.foo.Foo/Bar"
+   */
+  @Internal
+  public ServerMethodDefinition<?, ?> getMethod(String methodName) {
+    return methods.get(methodName);
+  }
+
+  /**
+   * Builder for constructing Service instances.
+   */
+  public static final class Builder {
+    private final String serviceName;
+    private final ServiceDescriptor serviceDescriptor;
+    private final Map<String, ServerMethodDefinition<?, ?>> methods = new HashMap<>();
+
+    private Builder(String serviceName) {
+      this.serviceName = checkNotNull(serviceName, "serviceName");
+      this.serviceDescriptor = null;
+    }
+
+    private Builder(ServiceDescriptor serviceDescriptor) {
+      this.serviceDescriptor = checkNotNull(serviceDescriptor, "serviceDescriptor");
+      this.serviceName = serviceDescriptor.getName();
+    }
+
+    /**
+     * Add a method to be supported by the service.
+     *
+     * @param method the {@link MethodDescriptor} of this method.
+     * @param handler handler for incoming calls
+     */
+    public <ReqT, RespT> Builder addMethod(
+        MethodDescriptor<ReqT, RespT> method, ServerCallHandler<ReqT, RespT> handler) {
+      return addMethod(ServerMethodDefinition.create(
+          checkNotNull(method, "method must not be null"),
+          checkNotNull(handler, "handler must not be null")));
+    }
+
+    /** Add a method to be supported by the service. */
+    public <ReqT, RespT> Builder addMethod(ServerMethodDefinition<ReqT, RespT> def) {
+      MethodDescriptor<ReqT, RespT> method = def.getMethodDescriptor();
+      checkArgument(
+          serviceName.equals(method.getServiceName()),
+          "Method name should be prefixed with service name and separated with '/'. "
+                  + "Expected service name: '%s'. Actual fully qualifed method name: '%s'.",
+          serviceName, method.getFullMethodName());
+      String name = method.getFullMethodName();
+      checkState(!methods.containsKey(name), "Method by same name already registered: %s", name);
+      methods.put(name, def);
+      return this;
+    }
+
+    /**
+     * Construct new ServerServiceDefinition.
+     */
+    public ServerServiceDefinition build() {
+      ServiceDescriptor serviceDescriptor = this.serviceDescriptor;
+      if (serviceDescriptor == null) {
+        List<MethodDescriptor<?, ?>> methodDescriptors
+            = new ArrayList<>(methods.size());
+        for (ServerMethodDefinition<?, ?> serverMethod : methods.values()) {
+          methodDescriptors.add(serverMethod.getMethodDescriptor());
+        }
+        serviceDescriptor = new ServiceDescriptor(serviceName, methodDescriptors);
+      }
+      Map<String, ServerMethodDefinition<?, ?>> tmpMethods = new HashMap<>(methods);
+      for (MethodDescriptor<?, ?> descriptorMethod : serviceDescriptor.getMethods()) {
+        ServerMethodDefinition<?, ?> removed = tmpMethods.remove(
+            descriptorMethod.getFullMethodName());
+        if (removed == null) {
+          throw new IllegalStateException(
+              "No method bound for descriptor entry " + descriptorMethod.getFullMethodName());
+        }
+        if (removed.getMethodDescriptor() != descriptorMethod) {
+          throw new IllegalStateException(
+              "Bound method for " + descriptorMethod.getFullMethodName()
+                  + " not same instance as method in service descriptor");
+        }
+      }
+      if (tmpMethods.size() > 0) {
+        throw new IllegalStateException(
+            "No entry in descriptor matching bound method "
+                + tmpMethods.values().iterator().next().getMethodDescriptor().getFullMethodName());
+      }
+      return new ServerServiceDefinition(serviceDescriptor, methods);
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/ServerStreamTracer.java b/api/src/main/java/io/grpc/ServerStreamTracer.java
new file mode 100644
index 00000000000..d522610ab3a
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServerStreamTracer.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2017 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;
+
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Listens to events on a stream to collect metrics.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
+@ThreadSafe
+public abstract class ServerStreamTracer extends StreamTracer {
+  /**
+   * Called before the interceptors and the call handlers and make changes to the Context object
+   * if needed.
+   */
+  public Context filterContext(Context context) {
+    return context;
+  }
+
+  /**
+   * Called when {@link ServerCall} is created.  This is for the tracer to access information about
+   * the {@code ServerCall}.  Called after {@link #filterContext} and before the application call
+   * handler.
+   */
+  @SuppressWarnings("deprecation")
+  public void serverCallStarted(ServerCallInfo<?, ?> callInfo) {
+    serverCallStarted(ReadOnlyServerCall.create(callInfo));
+  }
+
+  /**
+   * Called when {@link ServerCall} is created.  This is for the tracer to access information about
+   * the {@code ServerCall}.  Called after {@link #filterContext} and before the application call
+   * handler.
+   *
+   * @deprecated Implement {@link #serverCallStarted(ServerCallInfo)} instead. This method will be
+   *     removed in a future release of gRPC.
+   */
+  @Deprecated
+  public void serverCallStarted(ServerCall<?, ?> call) {
+  }
+
+  public abstract static class Factory {
+    /**
+     * Creates a {@link ServerStreamTracer} for a new server stream.
+     *
+     * <p>Called right before the stream is created
+     *
+     * @param fullMethodName the fully qualified method name
+     * @param headers the received request headers.  It can be safely mutated within this method.
+     *        It should not be saved because it is not safe for read or write after the method
+     *        returns.
+     */
+    public abstract ServerStreamTracer newServerStreamTracer(
+        String fullMethodName, Metadata headers);
+  }
+
+  /**
+   * A data class with info about the started {@link ServerCall}.
+   */
+  public abstract static class ServerCallInfo<ReqT, RespT> {
+    public abstract MethodDescriptor<ReqT, RespT> getMethodDescriptor();
+
+    public abstract Attributes getAttributes();
+
+    @Nullable
+    public abstract String getAuthority();
+  }
+
+  /**
+   * This class exists solely to help transition to the {@link ServerCallInfo} based API.
+   *
+   * @deprecated Will be deleted when {@link #serverCallStarted(ServerCall)} is removed.
+   */
+  @Deprecated
+  private static final class ReadOnlyServerCall<ReqT, RespT>
+      extends ForwardingServerCall<ReqT, RespT> {
+    private final ServerCallInfo<ReqT, RespT> callInfo;
+
+    private static <ReqT, RespT> ReadOnlyServerCall<ReqT, RespT> create(
+        ServerCallInfo<ReqT, RespT> callInfo) {
+      return new ReadOnlyServerCall<>(callInfo);
+    }
+
+    private ReadOnlyServerCall(ServerCallInfo<ReqT, RespT> callInfo) {
+      this.callInfo = callInfo;
+    }
+
+    @Override
+    public MethodDescriptor<ReqT, RespT> getMethodDescriptor() {
+      return callInfo.getMethodDescriptor();
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return callInfo.getAttributes();
+    }
+
+    @Override
+    public boolean isReady() {
+      // a dummy value
+      return false;
+    }
+
+    @Override
+    public boolean isCancelled() {
+      // a dummy value
+      return false;
+    }
+
+    @Override
+    public String getAuthority() {
+      return callInfo.getAuthority();
+    }
+
+    @Override
+    protected ServerCall<ReqT, RespT> delegate() {
+      throw new UnsupportedOperationException();
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/ServerTransportFilter.java b/api/src/main/java/io/grpc/ServerTransportFilter.java
new file mode 100644
index 00000000000..834a83bcc3f
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServerTransportFilter.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2016 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;
+
+/**
+ * Listens on server transport life-cycle events, with the capability to read and/or change
+ * transport attributes.  Attributes returned by this filter will be merged into {@link
+ * ServerCall#getAttributes}.
+ *
+ * <p>Multiple filters maybe registered to a server, in which case the output of a filter is the
+ * input of the next filter.  For example, what returned by {@link #transportReady} of a filter is
+ * passed to the same method of the next filter, and the last filter's return value is the effective
+ * transport attributes.
+ *
+ * <p>{@link Grpc} defines commonly used attributes.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2132")
+public abstract class ServerTransportFilter {
+  /**
+   * Called when a transport is ready to process streams.  All necessary handshakes, e.g., TLS
+   * handshake, are done at this point.
+   *
+   * <p>Note the implementation should always inherit the passed-in attributes using {@code
+   * Attributes.newBuilder(transportAttrs)}, instead of creating one from scratch.
+   *
+   * @param transportAttrs current transport attributes
+   *
+   * @return new transport attributes. Default implementation returns the passed-in attributes
+   *         intact.
+   */
+  public Attributes transportReady(Attributes transportAttrs) {
+    return transportAttrs;
+  }
+
+  /**
+   * Called when a transport is terminated.  Default implementation is no-op.
+   *
+   * @param transportAttrs the effective transport attributes, which is what returned by {@link
+   * #transportReady} of the last executed filter.
+   */
+  public void transportTerminated(Attributes transportAttrs) {
+  }
+}
diff --git a/api/src/main/java/io/grpc/ServiceDescriptor.java b/api/src/main/java/io/grpc/ServiceDescriptor.java
new file mode 100644
index 00000000000..a928a5d6589
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServiceDescriptor.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2016 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import javax.annotation.Nullable;
+
+/**
+ * Descriptor for a service.
+ *
+ * @since 1.0.0
+ */
+public final class ServiceDescriptor {
+
+  private final String name;
+  private final Collection<MethodDescriptor<?, ?>> methods;
+  private final Object schemaDescriptor;
+
+  /**
+   * Constructs a new Service Descriptor.  Users are encouraged to use {@link #newBuilder}
+   * instead.
+   *
+   * @param name The name of the service
+   * @param methods The methods that are part of the service
+   * @since 1.0.0
+   */
+  public ServiceDescriptor(String name, MethodDescriptor<?, ?>... methods) {
+    this(name, Arrays.asList(methods));
+  }
+
+  /**
+   * Constructs a new Service Descriptor.  Users are encouraged to use {@link #newBuilder}
+   * instead.
+   *
+   * @param name The name of the service
+   * @param methods The methods that are part of the service
+   * @since 1.0.0
+   */
+  public ServiceDescriptor(String name, Collection<MethodDescriptor<?, ?>> methods) {
+    this(newBuilder(name).addAllMethods(checkNotNull(methods, "methods")));
+  }
+
+  private ServiceDescriptor(Builder b) {
+    this.name = b.name;
+    validateMethodNames(name, b.methods);
+    this.methods = Collections.unmodifiableList(new ArrayList<>(b.methods));
+    this.schemaDescriptor = b.schemaDescriptor;
+  }
+
+  /**
+   * Simple name of the service. It is not an absolute path.
+   *
+   * @since 1.0.0
+   */
+  public String getName() {
+    return name;
+  }
+
+  /**
+   * A collection of {@link MethodDescriptor} instances describing the methods exposed by the
+   * service.
+   *
+   * @since 1.0.0
+   */
+  public Collection<MethodDescriptor<?, ?>> getMethods() {
+    return methods;
+  }
+
+  /**
+   * Returns the schema descriptor for this service.  A schema descriptor is an object that is not
+   * used by gRPC core but includes information related to the service.  The type of the object
+   * is specific to the consumer, so both the code setting the schema descriptor and the code
+   * calling {@link #getSchemaDescriptor()} must coordinate.  For example, protobuf generated code
+   * sets this value, in order to be consumed by the server reflection service.  See also:
+   * {@code io.grpc.protobuf.ProtoFileDescriptorSupplier}.
+   *
+   * @since 1.1.0
+   */
+  @Nullable
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
+  public Object getSchemaDescriptor() {
+    return schemaDescriptor;
+  }
+
+  static void validateMethodNames(String serviceName, Collection<MethodDescriptor<?, ?>> methods) {
+    Set<String> allNames = new HashSet<>(methods.size());
+    for (MethodDescriptor<?, ?> method : methods) {
+      checkNotNull(method, "method");
+      String methodServiceName = method.getServiceName();
+      checkArgument(serviceName.equals(methodServiceName),
+          "service names %s != %s", methodServiceName, serviceName);
+      checkArgument(allNames.add(method.getFullMethodName()),
+          "duplicate name %s", method.getFullMethodName());
+    }
+  }
+
+  /**
+   * Creates a new builder for a {@link ServiceDescriptor}.
+   *
+   * @since 1.1.0
+   */
+  public static Builder newBuilder(String name) {
+    return new Builder(name);
+  }
+
+  /**
+   * A builder for a {@link ServiceDescriptor}.
+   *
+   * @since 1.1.0
+   */
+  public static final class Builder {
+    private Builder(String name) {
+      setName(name);
+    }
+
+    private String name;
+    private List<MethodDescriptor<?, ?>> methods = new ArrayList<>();
+    private Object schemaDescriptor;
+
+    /**
+     * Sets the name.  This should be non-{@code null}.
+     *
+     * @param name The name of the service.
+     * @return this builder.
+     * @since 1.1.0
+     */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2666")
+    public Builder setName(String name) {
+      this.name = checkNotNull(name, "name");
+      return this;
+    }
+
+    /**
+     * Adds a method to this service.  This should be non-{@code null}.
+     *
+     * @param method the method to add to the descriptor.
+     * @return this builder.
+     * @since 1.1.0
+     */
+    public Builder addMethod(MethodDescriptor<?, ?> method) {
+      methods.add(checkNotNull(method, "method"));
+      return this;
+    }
+
+    /**
+     * Currently not exposed.  Bulk adds methods to this builder.
+     *
+     * @param methods the methods to add.
+     * @return this builder.
+     */
+    private Builder addAllMethods(Collection<MethodDescriptor<?, ?>> methods) {
+      this.methods.addAll(methods);
+      return this;
+    }
+
+    /**
+     * Sets the schema descriptor for this builder.  A schema descriptor is an object that is not
+     * used by gRPC core but includes information related to the service.  The type of the object
+     * is specific to the consumer, so both the code calling this and the code calling
+     * {@link ServiceDescriptor#getSchemaDescriptor()} must coordinate.  For example, protobuf
+     * generated code sets this value, in order to be consumed by the server reflection service.
+     *
+     * @param schemaDescriptor an object that describes the service structure.  Should be immutable.
+     * @return this builder.
+     * @since 1.1.0
+     */
+    public Builder setSchemaDescriptor(@Nullable Object schemaDescriptor) {
+      this.schemaDescriptor = schemaDescriptor;
+      return this;
+    }
+
+    /**
+     * Constructs a new {@link ServiceDescriptor}.  {@link #setName} should have been called with a
+     * non-{@code null} value before calling this.
+     *
+     * @return a new ServiceDescriptor
+     * @since 1.1.0
+     */
+    public ServiceDescriptor build() {
+      return new ServiceDescriptor(this);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("name", name)
+        .add("schemaDescriptor", schemaDescriptor)
+        .add("methods", methods)
+        .omitNullValues()
+        .toString();
+  }
+}
\ No newline at end of file
diff --git a/api/src/main/java/io/grpc/ServiceProviders.java b/api/src/main/java/io/grpc/ServiceProviders.java
new file mode 100644
index 00000000000..ac4b27d8783
--- /dev/null
+++ b/api/src/main/java/io/grpc/ServiceProviders.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2017 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;
+
+import com.google.common.annotations.VisibleForTesting;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.ServiceConfigurationError;
+import java.util.ServiceLoader;
+
+final class ServiceProviders {
+  private ServiceProviders() {
+    // do not instantiate
+  }
+
+  /**
+   * If this is not Android, returns the highest priority implementation of the class via
+   * {@link ServiceLoader}.
+   * If this is Android, returns an instance of the highest priority class in {@code hardcoded}.
+   */
+  public static <T> T load(
+      Class<T> klass,
+      Iterable<Class<?>> hardcoded,
+      ClassLoader cl,
+      PriorityAccessor<T> priorityAccessor) {
+    List<T> candidates = loadAll(klass, hardcoded, cl, priorityAccessor);
+    if (candidates.isEmpty()) {
+      return null;
+    }
+    return candidates.get(0);
+  }
+
+  /**
+   * If this is not Android, returns all available implementations discovered via
+   * {@link ServiceLoader}.
+   * If this is Android, returns all available implementations in {@code hardcoded}.
+   * The list is sorted in descending priority order.
+   */
+  public static <T> List<T> loadAll(
+      Class<T> klass,
+      Iterable<Class<?>> hardcoded,
+      ClassLoader cl,
+      final PriorityAccessor<T> priorityAccessor) {
+    Iterable<T> candidates;
+    if (isAndroid(cl)) {
+      candidates = getCandidatesViaHardCoded(klass, hardcoded);
+    } else {
+      candidates = getCandidatesViaServiceLoader(klass, cl);
+    }
+    List<T> list = new ArrayList<>();
+    for (T current: candidates) {
+      if (!priorityAccessor.isAvailable(current)) {
+        continue;
+      }
+      list.add(current);
+    }
+
+    // Sort descending based on priority.  If priorities are equal, compare the class names to
+    // get a reliable result.
+    Collections.sort(list, Collections.reverseOrder(new Comparator<T>() {
+      @Override
+      public int compare(T f1, T f2) {
+        int pd = priorityAccessor.getPriority(f1) - priorityAccessor.getPriority(f2);
+        if (pd != 0) {
+          return pd;
+        }
+        return f1.getClass().getName().compareTo(f2.getClass().getName());
+      }
+    }));
+    return Collections.unmodifiableList(list);
+  }
+
+  /**
+   * Returns true if the {@link ClassLoader} is for android.
+   */
+  static boolean isAndroid(ClassLoader cl) {
+    try {
+      // Specify a class loader instead of null because we may be running under Robolectric
+      Class.forName("android.app.Application", /*initialize=*/ false, cl);
+      return true;
+    } catch (Exception e) {
+      // If Application isn't loaded, it might as well not be Android.
+      return false;
+    }
+  }
+
+  /**
+   * Loads service providers for the {@code klass} service using {@link ServiceLoader}.
+   */
+  @VisibleForTesting
+  public static <T> Iterable<T> getCandidatesViaServiceLoader(Class<T> klass, ClassLoader cl) {
+    Iterable<T> i = ServiceLoader.load(klass, cl);
+    // Attempt to load using the context class loader and ServiceLoader.
+    // This allows frameworks like http://aries.apache.org/modules/spi-fly.html to plug in.
+    if (!i.iterator().hasNext()) {
+      i = ServiceLoader.load(klass);
+    }
+    return i;
+  }
+
+  /**
+   * Load providers from a hard-coded list. This avoids using getResource(), which has performance
+   * problems on Android (see https://github.com/grpc/grpc-java/issues/2037).
+   */
+  @VisibleForTesting
+  static <T> Iterable<T> getCandidatesViaHardCoded(Class<T> klass, Iterable<Class<?>> hardcoded) {
+    List<T> list = new ArrayList<>();
+    for (Class<?> candidate : hardcoded) {
+      T t = createForHardCoded(klass, candidate);
+      if (t == null) {
+        continue;
+      }
+      list.add(t);
+    }
+    return list;
+  }
+
+  private static <T> T createForHardCoded(Class<T> klass, Class<?> rawClass) {
+    try {
+      return rawClass.asSubclass(klass).getConstructor().newInstance();
+    } catch (ClassCastException ex) {
+      // Tools like Proguard that perform obfuscation rewrite strings only when the class they
+      // reference is known, as otherwise they wouldn't know its new name. This means some
+      // hard-coded Class.forNames() won't be rewritten. This can cause ClassCastException at
+      // runtime if the class ends up appearing on the classpath but that class is part of a
+      // separate copy of grpc. With tools like Maven Shade Plugin the class wouldn't be found at
+      // all and so would be skipped. We want to skip in this case as well.
+      return null;
+    } catch (Throwable t) {
+      throw new ServiceConfigurationError(
+          String.format("Provider %s could not be instantiated %s", rawClass.getName(), t), t);
+    }
+  }
+
+  /**
+   * An interface that allows us to get priority information about a provider.
+   */
+  public interface PriorityAccessor<T> {
+    /**
+     * Checks this provider is available for use, taking the current environment into consideration.
+     * If {@code false}, no other methods are safe to be called.
+     */
+    boolean isAvailable(T provider);
+
+    /**
+     * A priority, from 0 to 10 that this provider should be used, taking the current environment
+     * into consideration. 5 should be considered the default, and then tweaked based on environment
+     * detection. A priority of 0 does not imply that the provider wouldn't work; just that it
+     * should be last in line.
+     */
+    int getPriority(T provider);
+  }
+}
diff --git a/core/src/main/java/io/grpc/Status.java b/api/src/main/java/io/grpc/Status.java
similarity index 89%
rename from core/src/main/java/io/grpc/Status.java
rename to api/src/main/java/io/grpc/Status.java
index 3f7dcd23f4d..38cd9581f8e 100644
--- a/core/src/main/java/io/grpc/Status.java
+++ b/api/src/main/java/io/grpc/Status.java
@@ -1,53 +1,39 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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;
 
-import static com.google.common.base.Charsets.US_ASCII;
-import static com.google.common.base.Charsets.UTF_8;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Throwables.getStackTraceAsString;
+import static java.nio.charset.StandardCharsets.US_ASCII;
+import static java.nio.charset.StandardCharsets.UTF_8;
 
 import com.google.common.base.MoreObjects;
 import com.google.common.base.Objects;
+import com.google.errorprone.annotations.CheckReturnValue;
 import io.grpc.Metadata.TrustedAsciiMarshaller;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.TreeMap;
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.Immutable;
 
-
 /**
  * Defines the status of an operation by providing a standard {@link Code} in conjunction with an
  * optional descriptive message. Instances of {@code Status} are created by starting with the
@@ -63,8 +49,13 @@
  *
  * <p>Utility functions are provided to convert a status to an exception and to extract them
  * back out.
+ *
+ * <p>Extended descriptions, including a list of codes that should not be generated by the library,
+ * can be found at
+ * <a href="https://github.com/grpc/grpc/blob/master/doc/statuscodes.md">doc/statuscodes.md</a>
  */
 @Immutable
+@CheckReturnValue
 public final class Status {
 
   /**
@@ -195,7 +186,8 @@ public enum Code {
     /**
      * The service is currently unavailable.  This is a most likely a
      * transient condition and may be corrected by retrying with
-     * a backoff.
+     * a backoff. Note that it is not always safe to retry
+     * non-idempotent operations.
      *
      * <p>See litmus test above for deciding between FAILED_PRECONDITION,
      * ABORTED, and UNAVAILABLE.
@@ -214,6 +206,7 @@ public enum Code {
     UNAUTHENTICATED(16);
 
     private final int value;
+    @SuppressWarnings("ImmutableEnumChecker") // we make sure the byte[] can't be modified
     private final byte[] valueAscii;
 
     private Code(int value) {
@@ -228,6 +221,9 @@ public int value() {
       return value;
     }
 
+    /**
+     * Returns a {@link Status} object corresponding to this status code.
+     */
     public Status toStatus() {
       return STATUS_LIST.get(value);
     }
@@ -241,7 +237,7 @@ private byte[] valueAscii() {
   private static final List<Status> STATUS_LIST = buildStatusList();
 
   private static List<Status> buildStatusList() {
-    TreeMap<Integer, Status> canonicalizer = new TreeMap<Integer, Status>();
+    TreeMap<Integer, Status> canonicalizer = new TreeMap<>();
     for (Code code : Code.values()) {
       Status replaced = canonicalizer.put(code.value(), new Status(code));
       if (replaced != null) {
@@ -249,7 +245,7 @@ private static List<Status> buildStatusList() {
             + replaced.getCode().name() + " & " + code.name());
       }
     }
-    return Collections.unmodifiableList(new ArrayList<Status>(canonicalizer.values()));
+    return Collections.unmodifiableList(new ArrayList<>(canonicalizer.values()));
   }
 
   // A pseudo-enum of Status instances mapped 1:1 with values in Code. This simplifies construction
@@ -306,7 +302,7 @@ private static List<Status> buildStatusList() {
    * Return a {@link Status} given a canonical error {@link Code} value.
    */
   public static Status fromCodeValue(int codeValue) {
-    if (codeValue < 0 || codeValue > STATUS_LIST.size()) {
+    if (codeValue < 0 || codeValue >= STATUS_LIST.size()) {
       return UNKNOWN.withDescription("Unknown code " + codeValue);
     } else {
       return STATUS_LIST.get(codeValue);
@@ -356,9 +352,8 @@ public static Status fromCode(Code code) {
   /**
    * Key to bind status code to trailing metadata.
    */
-  @Internal
-  public static final Metadata.Key<Status> CODE_KEY
-      = Metadata.Key.of("grpc-status", new StatusCodeMarshaller());
+  static final Metadata.Key<Status> CODE_KEY
+      = Metadata.Key.of("grpc-status", false /* not pseudo */, new StatusCodeMarshaller());
 
   /**
    * Marshals status messages for ({@link #MESSAGE_KEY}.  gRPC does not use binary coding of
@@ -388,9 +383,8 @@ public static Status fromCode(Code code) {
   /**
    * Key to bind status message to trailing metadata.
    */
-  @Internal
-  public static final Metadata.Key<String> MESSAGE_KEY =
-      Metadata.Key.of("grpc-message", STATUS_MESSAGE_MARSHALLER);
+  static final Metadata.Key<String> MESSAGE_KEY =
+      Metadata.Key.of("grpc-message", false /* not pseudo */, STATUS_MESSAGE_MARSHALLER);
 
   /**
    * Extract an error {@link Status} from the causal chain of a {@link Throwable}.
@@ -418,7 +412,7 @@ public static Status fromThrowable(Throwable t) {
    *
    * @return the trailers or {@code null} if not found.
    */
-  @ExperimentalApi
+  @Nullable
   public static Metadata trailersFromThrowable(Throwable t) {
     Throwable cause = checkNotNull(t, "t");
     while (cause != null) {
@@ -534,8 +528,7 @@ public StatusRuntimeException asRuntimeException() {
    * Same as {@link #asRuntimeException()} but includes the provided trailers in the returned
    * exception.
    */
-  @ExperimentalApi
-  public StatusRuntimeException asRuntimeException(Metadata trailers) {
+  public StatusRuntimeException asRuntimeException(@Nullable Metadata trailers) {
     return new StatusRuntimeException(this, trailers);
   }
 
@@ -550,8 +543,7 @@ public StatusException asException() {
   /**
    * Same as {@link #asException()} but includes the provided trailers in the returned exception.
    */
-  @ExperimentalApi
-  public StatusException asException(Metadata trailers) {
+  public StatusException asException(@Nullable Metadata trailers) {
     return new StatusException(this, trailers);
   }
 
@@ -600,6 +592,8 @@ private static boolean isEscapingChar(byte b) {
     }
 
     /**
+     * Percent encode bytes to make them ASCII.
+     *
      * @param valueBytes the UTF-8 bytes
      * @param ri The reader index, pointed at the first byte that needs escaping.
      */
@@ -622,10 +616,7 @@ private static byte[] toAsciiStringSlow(byte[] valueBytes, int ri) {
         }
         escapedBytes[wi++] = b;
       }
-      byte[] dest = new byte[wi];
-      System.arraycopy(escapedBytes, 0, dest, 0, wi);
-
-      return dest;
+      return Arrays.copyOf(escapedBytes, wi);
     }
 
     @SuppressWarnings("deprecation") // Use fast but deprecated String ctor
diff --git a/api/src/main/java/io/grpc/StatusException.java b/api/src/main/java/io/grpc/StatusException.java
new file mode 100644
index 00000000000..c0a67a375b2
--- /dev/null
+++ b/api/src/main/java/io/grpc/StatusException.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2015 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;
+
+import javax.annotation.Nullable;
+
+/**
+ * {@link Status} in Exception form, for propagating Status information via exceptions. This is
+ * semantically equivalent to {@link StatusRuntimeException}, except for usage in APIs that promote
+ * checked exceptions. gRPC's stubs favor {@code StatusRuntimeException}.
+ */
+public class StatusException extends Exception {
+  private static final long serialVersionUID = -660954903976144640L;
+  @SuppressWarnings("serial")   // https://github.com/grpc/grpc-java/issues/1913
+  private final Status status;
+  @SuppressWarnings("serial")
+  private final Metadata trailers;
+
+  /**
+   * Constructs an exception with both a status.  See also {@link Status#asException()}.
+   *
+   * @since 1.0.0
+   */
+  public StatusException(Status status) {
+    this(status, null);
+  }
+
+  /**
+   * Constructs an exception with both a status and trailers.  See also
+   * {@link Status#asException(Metadata)}.
+   *
+   * @since 1.0.0
+   */
+  public StatusException(Status status, @Nullable Metadata trailers) {
+    super(Status.formatThrowableMessage(status), status.getCause());
+    this.status = status;
+    this.trailers = trailers;
+  }
+
+  /**
+   * Returns the status code as a {@link Status} object.
+   *
+   * @since 1.0.0
+   */
+  public final Status getStatus() {
+    return status;
+  }
+
+  /**
+   * Returns the received trailers.
+   *
+   * @since 1.0.0
+   */
+  @Nullable
+  public final Metadata getTrailers() {
+    return trailers;
+  }
+}
diff --git a/api/src/main/java/io/grpc/StatusOr.java b/api/src/main/java/io/grpc/StatusOr.java
new file mode 100644
index 00000000000..b7dd68cfd7b
--- /dev/null
+++ b/api/src/main/java/io/grpc/StatusOr.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2024 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.MoreObjects.ToStringHelper;
+import com.google.common.base.Objects;
+import javax.annotation.Nullable;
+
+/** Either a Status or a value. */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/11563")
+public class StatusOr<T> {
+  private StatusOr(Status status, T value) {
+    this.status = status;
+    this.value = value;
+  }
+
+  /** Construct from a value. */
+  public static <T> StatusOr<T> fromValue(T value) {
+    StatusOr<T> result = new StatusOr<T>(null, value);
+    return result;
+  }
+
+  /** Construct from a non-Ok status. */
+  public static <T> StatusOr<T> fromStatus(Status status) {
+    StatusOr<T> result = new StatusOr<T>(checkNotNull(status, "status"), null);
+    checkArgument(!status.isOk(), "cannot use OK status: %s", status);
+    return result;
+  }
+
+  /** Returns whether there is a value. */
+  public boolean hasValue() {
+    return status == null;
+  }
+
+  /**
+   * Returns the value if set or throws exception if there is no value set. This method is meant
+   * to be called after checking the return value of hasValue() first.
+   */
+  public T getValue() {
+    if (status != null) {
+      throw new IllegalStateException("No value present.");
+    }
+    return value;
+  }
+
+  /** Returns the status. If there is a value (which can be null), returns OK. */
+  public Status getStatus() {
+    return status == null ? Status.OK : status;
+  }
+
+  /**
+   * Note that StatusOr containing statuses, the equality comparision is delegated to
+   * {@link Status#equals} which just does a reference equality check because equality on
+   * Statuses is not well defined.
+   * Instead, do comparison based on their Code with {@link Status#getCode}.  The description and
+   * cause of the Status are unlikely to be stable, and additional fields may be added to Status
+   * in the future.
+   */
+  @Override
+  public boolean equals(Object other) {
+    if (!(other instanceof StatusOr)) {
+      return false;
+    }
+    StatusOr<?> otherStatus = (StatusOr<?>) other;
+    if (hasValue() != otherStatus.hasValue()) {
+      return false;
+    }
+    if (hasValue()) {
+      return Objects.equal(value, otherStatus.value);
+    }
+    return Objects.equal(status, otherStatus.status);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(status, value);
+  }
+
+  @Override
+  public String toString() {
+    ToStringHelper stringHelper = MoreObjects.toStringHelper(this);
+    if (status == null) {
+      stringHelper.add("value", value);
+    } else {
+      stringHelper.add("error", status);
+    }
+    return stringHelper.toString();
+  }
+
+  @Nullable
+  private final Status status;
+  private final T value;
+}
diff --git a/api/src/main/java/io/grpc/StatusRuntimeException.java b/api/src/main/java/io/grpc/StatusRuntimeException.java
new file mode 100644
index 00000000000..ebcc2f0d671
--- /dev/null
+++ b/api/src/main/java/io/grpc/StatusRuntimeException.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2015 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;
+
+import javax.annotation.Nullable;
+
+/**
+ * {@link Status} in RuntimeException form, for propagating Status information via exceptions.
+ *
+ * @see StatusException
+ */
+public class StatusRuntimeException extends RuntimeException {
+
+  private static final long serialVersionUID = 1950934672280720624L;
+  @SuppressWarnings("serial")   // https://github.com/grpc/grpc-java/issues/1913
+  private final Status status;
+  @SuppressWarnings("serial")
+  private final Metadata trailers;
+
+  /**
+   * Constructs the exception with a status. See also {@link Status#asRuntimeException()}.
+   *
+   * @since 1.0.0
+   */
+  public StatusRuntimeException(Status status) {
+    this(status, null);
+  }
+
+  /**
+   * Constructs the exception with both a status and trailers. See also {@link
+   * Status#asRuntimeException(Metadata)}.
+   *
+   * @since 1.0.0
+   */
+  public StatusRuntimeException(Status status, @Nullable Metadata trailers) {
+    super(Status.formatThrowableMessage(status), status.getCause());
+    this.status = status;
+    this.trailers = trailers;
+  }
+
+  /**
+   * Returns the status code as a {@link Status} object.
+   *
+   * @since 1.0.0
+   */
+  public final Status getStatus() {
+    return status;
+  }
+
+  /**
+   * Returns the received trailers.
+   *
+   * @since 1.0.0
+   */
+  @Nullable
+  public final Metadata getTrailers() {
+    return trailers;
+  }
+}
diff --git a/api/src/main/java/io/grpc/StreamTracer.java b/api/src/main/java/io/grpc/StreamTracer.java
new file mode 100644
index 00000000000..66b3de8be6b
--- /dev/null
+++ b/api/src/main/java/io/grpc/StreamTracer.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2017 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;
+
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Listens to events on a stream to collect metrics.
+ *
+ * <p>DO NOT MOCK: Use TestStreamTracer. Mocks are not thread-safe
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
+@ThreadSafe
+public abstract class StreamTracer {
+  /**
+   * Stream is closed.  This will be called exactly once.
+   */
+  public void streamClosed(Status status) {
+  }
+
+  /**
+   * An outbound message has been passed to the stream.  This is called as soon as the stream knows
+   * about the message, but doesn't have further guarantee such as whether the message is serialized
+   * or not.
+   *
+   * @param seqNo the sequential number of the message within the stream, starting from 0.  It can
+   *              be used to correlate with {@link #outboundMessageSent} for the same message.
+   */
+  public void outboundMessage(int seqNo) {
+  }
+
+  /**
+   * An inbound message has been received by the stream.  This is called as soon as the stream knows
+   * about the message, but doesn't have further guarantee such as whether the message is
+   * deserialized or not.
+   *
+   * @param seqNo the sequential number of the message within the stream, starting from 0.  It can
+   *              be used to correlate with {@link #inboundMessageRead} for the same message.
+   */
+  public void inboundMessage(int seqNo) {
+  }
+
+  /**
+   * An outbound message has been serialized and sent to the transport.
+   *
+   * @param seqNo the sequential number of the message within the stream, starting from 0.  It can
+   *              be used to correlate with {@link #outboundMessage(int)} for the same message.
+   * @param optionalWireSize the wire size of the message. -1 if unknown
+   * @param optionalUncompressedSize the uncompressed serialized size of the message. -1 if unknown
+   */
+  public void outboundMessageSent(int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+  }
+
+  /**
+   * An inbound message has been fully read from the transport.
+   *
+   * @param seqNo the sequential number of the message within the stream, starting from 0.  It can
+   *              be used to correlate with {@link #inboundMessage(int)} for the same message.
+   * @param optionalWireSize the wire size of the message. -1 if unknown
+   * @param optionalUncompressedSize the uncompressed serialized size of the message. -1 if unknown
+   */
+  public void inboundMessageRead(int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+  }
+
+  /**
+   * The wire size of some outbound data is revealed. This can only used to record the accumulative
+   * outbound wire size. There is no guarantee wrt timing or granularity of this method.
+   */
+  public void outboundWireSize(long bytes) {
+  }
+
+  /**
+   * The uncompressed size of some outbound data is revealed. This can only used to record the
+   * accumulative outbound uncompressed size. There is no guarantee wrt timing or granularity of
+   * this method.
+   */
+  public void outboundUncompressedSize(long bytes) {
+  }
+
+  /**
+   * The wire size of some inbound data is revealed. This can only be used to record the
+   * accumulative received wire size. There is no guarantee wrt timing or granularity of this
+   * method.
+   */
+  public void inboundWireSize(long bytes) {
+  }
+
+  /**
+   * The uncompressed size of some inbound data is revealed. This can only used to record the
+   * accumulative received uncompressed size. There is no guarantee wrt timing or granularity of
+   * this method.
+   */
+  public void inboundUncompressedSize(long bytes) {
+  }
+}
diff --git a/api/src/main/java/io/grpc/SynchronizationContext.java b/api/src/main/java/io/grpc/SynchronizationContext.java
new file mode 100644
index 00000000000..94916a1b473
--- /dev/null
+++ b/api/src/main/java/io/grpc/SynchronizationContext.java
@@ -0,0 +1,265 @@
+/*
+ * Copyright 2018 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.TimeUtils.convertToNanos;
+
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.time.Duration;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A synchronization context is a queue of tasks that run in sequence.  It offers following
+ * guarantees:
+ *
+ * <ul>
+ *    <li>Ordering.  Tasks are run in the same order as they are submitted via {@link #execute}
+ *        and {@link #executeLater}.</li>
+ *    <li>Serialization.  Tasks are run in sequence and establish a happens-before relationship
+ *        between them. </li>
+ *    <li>Non-reentrancy.  If a task running in a synchronization context executes or schedules
+ *        another task in the same synchronization context, the latter task will never run
+ *        inline.  It will instead be queued and run only after the current task has returned.</li>
+ * </ul>
+ *
+ * <p>It doesn't own any thread.  Tasks are run from caller's or caller-provided threads.
+ *
+ * <p>Conceptually, it is fairly accurate to think of {@code SynchronizationContext} like a cheaper
+ * {@code Executors.newSingleThreadExecutor()} when used for synchronization (not long-running
+ * tasks). Both use a queue for tasks that are run in order and neither guarantee that tasks have
+ * completed before returning from {@code execute()}. However, the behavior does diverge if locks
+ * are held when calling the context. So it is encouraged to avoid mixing locks and synchronization
+ * context except via {@link #executeLater}.
+ *
+ * <p>This class is thread-safe.
+ *
+ * @since 1.17.0
+ */
+@ThreadSafe
+public final class SynchronizationContext implements Executor {
+  private final UncaughtExceptionHandler uncaughtExceptionHandler;
+
+  private final Queue<Runnable> queue = new ConcurrentLinkedQueue<>();
+  private final AtomicReference<Thread> drainingThread = new AtomicReference<>();
+
+  /**
+   * Creates a SynchronizationContext.
+   *
+   * @param uncaughtExceptionHandler handles exceptions thrown out of the tasks.  Different from
+   *        what's documented on {@link UncaughtExceptionHandler#uncaughtException}, the thread is
+   *        not terminated when the handler is called.
+   */
+  public SynchronizationContext(UncaughtExceptionHandler uncaughtExceptionHandler) {
+    this.uncaughtExceptionHandler =
+        checkNotNull(uncaughtExceptionHandler, "uncaughtExceptionHandler");
+  }
+
+  /**
+   * Run all tasks in the queue in the current thread, if no other thread is running this method.
+   * Otherwise do nothing.
+   *
+   * <p>Upon returning, it guarantees that all tasks submitted by {@code #executeLater} before it
+   * have been or will eventually be run, while not requiring any more calls to {@code drain()}.
+   */
+  public final void drain() {
+    do {
+      if (!drainingThread.compareAndSet(null, Thread.currentThread())) {
+        return;
+      }
+      try {
+        Runnable runnable;
+        while ((runnable = queue.poll()) != null) {
+          try {
+            runnable.run();
+          } catch (Throwable t) {
+            uncaughtExceptionHandler.uncaughtException(Thread.currentThread(), t);
+          }
+        }
+      } finally {
+        drainingThread.set(null);
+      }
+      // must check queue again here to catch any added prior to clearing drainingThread
+    } while (!queue.isEmpty());
+  }
+
+  /**
+   * Adds a task that will be run when {@link #drain} is called.
+   *
+   * <p>This is useful for cases where you want to enqueue a task while under a lock of your own,
+   * but don't want the tasks to be run under your lock (for fear of deadlock).  You can call {@link
+   * #executeLater} in the lock, and call {@link #drain} outside the lock.
+   */
+  public final void executeLater(Runnable runnable) {
+    queue.add(checkNotNull(runnable, "runnable is null"));
+  }
+
+  /**
+   * Adds a task and run it in this synchronization context as soon as possible.  The task may run
+   * inline.  If there are tasks that are previously queued by {@link #executeLater} but have not
+   * been run, this method will trigger them to be run before the given task.  This is equivalent to
+   * calling {@link #executeLater} immediately followed by {@link #drain}.
+   */
+  @Override
+  public final void execute(Runnable task) {
+    executeLater(task);
+    drain();
+  }
+
+  /**
+   * Throw {@link IllegalStateException} if this method is not called from this synchronization
+   * context.
+   */
+  public void throwIfNotInThisSynchronizationContext() {
+    checkState(Thread.currentThread() == drainingThread.get(),
+        "Not called from the SynchronizationContext");
+  }
+
+  /**
+   * Schedules a task to be added and run via {@link #execute} after a delay.
+   *
+   * @param task the task being scheduled
+   * @param delay the delay
+   * @param unit the time unit for the delay
+   * @param timerService the {@code ScheduledExecutorService} that provides delayed execution
+   *
+   * @return an object for checking the status and/or cancel the scheduled task
+   */
+  public final ScheduledHandle schedule(
+      final Runnable task, long delay, TimeUnit unit, ScheduledExecutorService timerService) {
+    final ManagedRunnable runnable = new ManagedRunnable(task);
+    ScheduledFuture<?> future = timerService.schedule(new Runnable() {
+        @Override
+        public void run() {
+          execute(runnable);
+        }
+
+        @Override
+        public String toString() {
+          return task.toString() + "(scheduled in SynchronizationContext)";
+        }
+      }, delay, unit);
+    return new ScheduledHandle(runnable, future);
+  }
+
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11657")
+  public final ScheduledHandle schedule(
+      final Runnable task, Duration delay, ScheduledExecutorService timerService) {
+    return schedule(task, convertToNanos(delay), TimeUnit.NANOSECONDS, timerService);
+  }
+
+  /**
+   * Schedules a task to be added and run via {@link #execute} after an initial delay and then
+   * repeated after the delay until cancelled.
+   *
+   * @param task the task being scheduled
+   * @param initialDelay the delay before the first run
+   * @param delay the delay after the first run.
+   * @param unit the time unit for the delay
+   * @param timerService the {@code ScheduledExecutorService} that provides delayed execution
+   *
+   * @return an object for checking the status and/or cancel the scheduled task
+   */
+  public final ScheduledHandle scheduleWithFixedDelay(
+      final Runnable task, long initialDelay, long delay, TimeUnit unit,
+      ScheduledExecutorService timerService) {
+    final ManagedRunnable runnable = new ManagedRunnable(task);
+    ScheduledFuture<?> future = timerService.scheduleWithFixedDelay(new Runnable() {
+      @Override
+      public void run() {
+        execute(runnable);
+      }
+
+      @Override
+      public String toString() {
+        return task.toString() + "(scheduled in SynchronizationContext with delay of " + delay
+            + ")";
+      }
+    }, initialDelay, delay, unit);
+    return new ScheduledHandle(runnable, future);
+  }
+
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11657")
+  public final ScheduledHandle scheduleWithFixedDelay(
+      final Runnable task, Duration initialDelay, Duration delay,
+      ScheduledExecutorService timerService) {
+    return scheduleWithFixedDelay(task, convertToNanos(initialDelay), convertToNanos(delay),
+        TimeUnit.NANOSECONDS, timerService);
+  }
+
+
+  private static class ManagedRunnable implements Runnable {
+    final Runnable task;
+    boolean isCancelled;
+    boolean hasStarted;
+
+    ManagedRunnable(Runnable task) {
+      this.task = checkNotNull(task, "task");
+    }
+
+    @Override
+    public void run() {
+      // The task may have been cancelled after timerService calls SynchronizationContext.execute()
+      // but before the runnable is actually run.  We must guarantee that the task will not be run
+      // in this case.
+      if (!isCancelled) {
+        hasStarted = true;
+        task.run();
+      }
+    }
+  }
+
+  /**
+   * Allows the user to check the status and/or cancel a task scheduled by {@link #schedule}.
+   *
+   * <p>This class is NOT thread-safe.  All methods must be run from the same {@link
+   * SynchronizationContext} as which the task was scheduled in.
+   */
+  public static final class ScheduledHandle {
+    private final ManagedRunnable runnable;
+    private final ScheduledFuture<?> future;
+
+    private ScheduledHandle(ManagedRunnable runnable, ScheduledFuture<?> future) {
+      this.runnable = checkNotNull(runnable, "runnable");
+      this.future = checkNotNull(future, "future");
+    }
+
+    /**
+     * Cancel the task if it's still {@link #isPending pending}.
+     */
+    public void cancel() {
+      runnable.isCancelled = true;
+      future.cancel(false);
+    }
+
+    /**
+     * Returns {@code true} if the task will eventually run, meaning that it has neither started
+     * running nor been cancelled.
+     */
+    public boolean isPending() {
+      return !(runnable.hasStarted || runnable.isCancelled);
+    }
+  }
+}
\ No newline at end of file
diff --git a/api/src/main/java/io/grpc/TimeUtils.java b/api/src/main/java/io/grpc/TimeUtils.java
new file mode 100644
index 00000000000..01b8c158822
--- /dev/null
+++ b/api/src/main/java/io/grpc/TimeUtils.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2024 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;
+
+import java.time.Duration;
+
+final class TimeUtils {
+  private TimeUtils() {}
+
+  @IgnoreJRERequirement
+  static long convertToNanos(Duration duration) {
+    try {
+      return duration.toNanos();
+    } catch (ArithmeticException tooBig) {
+      return duration.isNegative() ? Long.MIN_VALUE : Long.MAX_VALUE;
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/TlsChannelCredentials.java b/api/src/main/java/io/grpc/TlsChannelCredentials.java
new file mode 100644
index 00000000000..b58048be0b2
--- /dev/null
+++ b/api/src/main/java/io/grpc/TlsChannelCredentials.java
@@ -0,0 +1,368 @@
+/*
+ * 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;
+
+import com.google.common.io.ByteStreams;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Set;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.TrustManager;
+
+/**
+ * TLS credentials, providing server authentication and encryption. Consumers of this credential
+ * must verify they understand the configuration via the {@link #incomprehensible
+ * incomprehensible()} method. Unless overridden by a {@code Feature}, server verification should
+ * use customary default root certificates.
+ */
+public final class TlsChannelCredentials extends ChannelCredentials {
+  /** Use TLS with its defaults. */
+  public static ChannelCredentials create() {
+    return newBuilder().build();
+  }
+
+  private final boolean fakeFeature;
+  private final byte[] certificateChain;
+  private final byte[] privateKey;
+  private final String privateKeyPassword;
+  private final List<KeyManager> keyManagers;
+  private final byte[] rootCertificates;
+  private final List<TrustManager> trustManagers;
+
+  TlsChannelCredentials(Builder builder) {
+    fakeFeature = builder.fakeFeature;
+    certificateChain = builder.certificateChain;
+    privateKey = builder.privateKey;
+    privateKeyPassword = builder.privateKeyPassword;
+    keyManagers = builder.keyManagers;
+    rootCertificates = builder.rootCertificates;
+    trustManagers = builder.trustManagers;
+  }
+
+  /**
+   * The certificate chain for the client's identity, as a new byte array. Generally should be
+   * PEM-encoded. If {@code null}, some feature is providing key manager information via a different
+   * method or no client identity is available.
+   */
+  public byte[] getCertificateChain() {
+    if (certificateChain == null) {
+      return null;
+    }
+    return Arrays.copyOf(certificateChain, certificateChain.length);
+  }
+
+  /**
+   * The private key for the client's identity, as a new byte array. Generally should be in PKCS#8
+   * format. If encrypted, {@link #getPrivateKeyPassword} is the decryption key. If unencrypted, the
+   * password will be {@code null}. If {@code null}, some feature is providing key manager
+   * information via a different method or no client identity is available.
+   */
+  public byte[] getPrivateKey() {
+    if (privateKey == null) {
+      return null;
+    }
+    return Arrays.copyOf(privateKey, privateKey.length);
+  }
+
+  /** Returns the password to decrypt the private key, or {@code null} if unencrypted. */
+  public String getPrivateKeyPassword() {
+    return privateKeyPassword;
+  }
+
+  /**
+   * Returns the key manager list which provides the client's identity. Entries are scanned checking
+   * for specific types, like {@link javax.net.ssl.X509KeyManager}. Only a single entry for a type
+   * is used. Entries earlier in the list are higher priority. If {@code null}, key manager
+   * information is provided via a different method or no client identity is available.
+   */
+  public List<KeyManager> getKeyManagers() {
+    return keyManagers;
+  }
+
+  /**
+   * Root trust certificates for verifying the server's identity that override the system's
+   * defaults. Generally PEM-encoded with multiple certificates concatenated.
+   */
+  public byte[] getRootCertificates() {
+    if (rootCertificates == null) {
+      return null;
+    }
+    return Arrays.copyOf(rootCertificates, rootCertificates.length);
+  }
+
+  /**
+   * Returns the trust manager list which verifies the server's identity. Entries are scanned
+   * checking for specific types, like {@link javax.net.ssl.X509TrustManager}. Only a single entry
+   * for a type is used. Entries earlier in the list are higher priority. If {@code null}, trust
+   * manager information is provided via the system's default or a different method.
+   */
+  public List<TrustManager> getTrustManagers() {
+    return trustManagers;
+  }
+
+  /**
+   * Returns an empty set if this credential can be adequately understood via
+   * the features listed, otherwise returns a hint of features that are lacking
+   * to understand the configuration to be used for manual debugging.
+   *
+   * <p>An "understood" feature does not imply the caller is able to fully
+   * handle the feature. It simply means the caller understands the feature
+   * enough to use the appropriate APIs to read the configuration. The caller
+   * may support just a subset of a feature, in which case the caller would
+   * need to look at the configuration to determine if only the supported
+   * subset is used.
+   *
+   * <p>This method may not be as simple as a set difference. There may be
+   * multiple features that can independently satisfy a piece of configuration.
+   * If the configuration is incomprehensible, all such features would be
+   * returned, even though only one may be necessary.
+   *
+   * <p>An empty set does not imply that the credentials are fully understood.
+   * There may be optional configuration that can be ignored if not understood.
+   *
+   * <p>Since {@code Feature} is an {@code enum}, {@code understoodFeatures}
+   * should generally be an {@link java.util.EnumSet}. {@code
+   * understoodFeatures} will not be modified.
+   *
+   * @param understoodFeatures the features understood by the caller
+   * @return empty set if the caller can adequately understand the configuration
+   */
+  public Set<Feature> incomprehensible(Set<Feature> understoodFeatures) {
+    Set<Feature> incomprehensible = EnumSet.noneOf(Feature.class);
+    if (fakeFeature) {
+      requiredFeature(understoodFeatures, incomprehensible, Feature.FAKE);
+    }
+    if (rootCertificates != null || privateKey != null || keyManagers != null) {
+      requiredFeature(understoodFeatures, incomprehensible, Feature.MTLS);
+    }
+    if (keyManagers != null || trustManagers != null) {
+      requiredFeature(understoodFeatures, incomprehensible, Feature.CUSTOM_MANAGERS);
+    }
+    return Collections.unmodifiableSet(incomprehensible);
+  }
+
+  private static void requiredFeature(
+      Set<Feature> understoodFeatures, Set<Feature> incomprehensible, Feature feature) {
+    if (!understoodFeatures.contains(feature)) {
+      incomprehensible.add(feature);
+    }
+  }
+
+  @Override
+  public ChannelCredentials withoutBearerTokens() {
+    return this;
+  }
+
+  /**
+   * Features to understand TLS configuration. Additional enum values may be added in the future.
+   */
+  public enum Feature {
+    /**
+     * A feature that no consumer should understand. It should be used for unit testing to confirm
+     * a call to {@link #incomprehensible incomprehensible()} is implemented properly.
+     */
+    FAKE,
+    /**
+     * Client identity may be provided and server verification can be tuned. This feature requires
+     * observing {@link #getCertificateChain}, {@link #getPrivateKey}, and {@link
+     * #getPrivateKeyPassword} as well as {@link #getRootCertificates()}. The certificate chain and
+     * private key are used to configure a key manager to provide the client's identity. If no
+     * certificate chain and private key are provided the client will have no identity. The root
+     * certificates are used to configure a trust manager for verifying the server's identity. If no
+     * root certificates are provided the trust manager will default to the system's root
+     * certificates.
+     */
+    MTLS,
+    /**
+     * Key managers and trust managers may be specified as {@link KeyManager} and {@link
+     * TrustManager} objects. This feature requires observing {@link #getKeyManagers()} and {@link
+     * #getTrustManagers()}. Generally {@link #MTLS} should also be supported, as that is the more
+     * common method of configuration. When a manager is non-{@code null}, then it is wholly
+     * responsible for key or trust material and usage; there is no need to check other manager
+     * sources like {@link #getCertificateChain()} or {@link #getPrivateKey()} (if {@code
+     * KeyManager} is available), or {@link #getRootCertificates()} (if {@code TrustManager} is
+     * available).
+     *
+     * <p>If other manager sources are available (e.g., {@code getPrivateKey() != null}), then they
+     * may be alternative representations of the same configuration and the consumer is free to use
+     * those alternative representations if it prefers. But before doing so it <em>must</em> first
+     * check that it understands that alternative representation by using {@link #incomprehensible}
+     * <em>without</em> the {@code CUSTOM_MANAGERS} feature.
+     */
+    CUSTOM_MANAGERS,
+    ;
+  }
+
+  /** Creates a builder for changing default configuration. */
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  /** Builder for {@link TlsChannelCredentials}. */
+  public static final class Builder {
+    private boolean fakeFeature;
+    private byte[] certificateChain;
+    private byte[] privateKey;
+    private String privateKeyPassword;
+    private List<KeyManager> keyManagers;
+    private byte[] rootCertificates;
+    private List<TrustManager> trustManagers;
+
+    private Builder() {}
+
+    /**
+     * Requires {@link Feature#FAKE} to be understood. For use in testing consumers of this
+     * credential.
+     */
+    public Builder requireFakeFeature() {
+      fakeFeature = true;
+      return this;
+    }
+
+    /**
+     * Use the provided certificate chain and private key as the client's identity. Generally they
+     * should be PEM-encoded and the key is an unencrypted PKCS#8 key (file headers have "BEGIN
+     * CERTIFICATE" and "BEGIN PRIVATE KEY").
+     */
+    public Builder keyManager(File certChain, File privateKey) throws IOException {
+      return keyManager(certChain, privateKey, null);
+    }
+
+    /**
+     * Use the provided certificate chain and possibly-encrypted private key as the client's
+     * identity. Generally they should be PEM-encoded and the key is a PKCS#8 key. If the private
+     * key is unencrypted, then password must be {@code null}.
+     */
+    public Builder keyManager(File certChain, File privateKey, String privateKeyPassword)
+        throws IOException {
+      InputStream certChainIs = new FileInputStream(certChain);
+      try {
+        InputStream privateKeyIs = new FileInputStream(privateKey);
+        try {
+          return keyManager(certChainIs, privateKeyIs, privateKeyPassword);
+        } finally {
+          privateKeyIs.close();
+        }
+      } finally {
+        certChainIs.close();
+      }
+    }
+
+    /**
+     * Use the provided certificate chain and private key as the client's identity. Generally they
+     * should be PEM-encoded and the key is an unencrypted PKCS#8 key (file headers have "BEGIN
+     * CERTIFICATE" and "BEGIN PRIVATE KEY").
+     */
+    public Builder keyManager(InputStream certChain, InputStream privateKey) throws IOException {
+      return keyManager(certChain, privateKey, null);
+    }
+
+    /**
+     * Use the provided certificate chain and possibly-encrypted private key as the client's
+     * identity. Generally they should be PEM-encoded and the key is a PKCS#8 key. If the private
+     * key is unencrypted, then password must be {@code null}.
+     */
+    public Builder keyManager(
+        InputStream certChain, InputStream privateKey, String privateKeyPassword)
+        throws IOException {
+      byte[] certChainBytes = ByteStreams.toByteArray(certChain);
+      byte[] privateKeyBytes = ByteStreams.toByteArray(privateKey);
+      clearKeyManagers();
+      this.certificateChain = certChainBytes;
+      this.privateKey = privateKeyBytes;
+      this.privateKeyPassword = privateKeyPassword;
+      return this;
+    }
+
+    /**
+     * Have the provided key manager select the client's identity. Although multiple are allowed,
+     * only the first instance implementing a particular interface is used. So generally there will
+     * just be a single entry and it implements {@link javax.net.ssl.X509KeyManager}.
+     */
+    public Builder keyManager(KeyManager... keyManagers) {
+      List<KeyManager> keyManagerList = Collections.unmodifiableList(new ArrayList<>(
+          Arrays.asList(keyManagers)));
+      clearKeyManagers();
+      this.keyManagers = keyManagerList;
+      return this;
+    }
+
+    private void clearKeyManagers() {
+      this.certificateChain = null;
+      this.privateKey = null;
+      this.privateKeyPassword = null;
+      this.keyManagers = null;
+    }
+
+    /**
+     * Use the provided root certificates to verify the server's identity instead of the system's
+     * default. Generally they should be PEM-encoded with all the certificates concatenated together
+     * (file header has "BEGIN CERTIFICATE", and would occur once per certificate).
+     */
+    public Builder trustManager(File rootCerts) throws IOException {
+      InputStream rootCertsIs = new FileInputStream(rootCerts);
+      try {
+        return trustManager(rootCertsIs);
+      } finally {
+        rootCertsIs.close();
+      }
+    }
+
+    /**
+     * Use the provided root certificates to verify the server's identity instead of the system's
+     * default. Generally they should be PEM-encoded with all the certificates concatenated together
+     * (file header has "BEGIN CERTIFICATE", and would occur once per certificate).
+     */
+    public Builder trustManager(InputStream rootCerts) throws IOException {
+      byte[] rootCertsBytes = ByteStreams.toByteArray(rootCerts);
+      clearTrustManagers();
+      this.rootCertificates = rootCertsBytes;
+      return this;
+    }
+
+    /**
+     * Have the provided trust manager verify the server's identity instead of the system's default.
+     * Although multiple are allowed, only the first instance implementing a particular interface is
+     * used. So generally there will just be a single entry and it implements {@link
+     * javax.net.ssl.X509TrustManager}.
+     */
+    public Builder trustManager(TrustManager... trustManagers) {
+      List<TrustManager> trustManagerList = Collections.unmodifiableList(new ArrayList<>(
+          Arrays.asList(trustManagers)));
+      clearTrustManagers();
+      this.trustManagers = trustManagerList;
+      return this;
+    }
+
+    private void clearTrustManagers() {
+      this.rootCertificates = null;
+      this.trustManagers = null;
+    }
+
+    /** Construct the credentials. */
+    public ChannelCredentials build() {
+      return new TlsChannelCredentials(this);
+    }
+  }
+}
diff --git a/api/src/main/java/io/grpc/TlsServerCredentials.java b/api/src/main/java/io/grpc/TlsServerCredentials.java
new file mode 100644
index 00000000000..ef20149eef6
--- /dev/null
+++ b/api/src/main/java/io/grpc/TlsServerCredentials.java
@@ -0,0 +1,418 @@
+/*
+ * 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;
+
+import com.google.common.base.Preconditions;
+import com.google.common.io.ByteStreams;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Set;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.TrustManager;
+
+/**
+ * TLS credentials, providing server identity and encryption. Consumers of this credential must
+ * verify they understand the configuration via the {@link #incomprehensible incomprehensible()}
+ * method. Unless overridden by a {@code Feature}, server identity is provided via {@link
+ * #getCertificateChain}, {@link #getPrivateKey}, and {@link #getPrivateKeyPassword}.
+ */
+public final class TlsServerCredentials extends ServerCredentials {
+  /**
+   * Creates an instance using provided certificate chain and private key. Generally they should be
+   * PEM-encoded and the key is an unencrypted PKCS#8 key (file headers have "BEGIN CERTIFICATE" and
+   * "BEGIN PRIVATE KEY").
+   */
+  public static ServerCredentials create(File certChain, File privateKey) throws IOException {
+    return newBuilder().keyManager(certChain, privateKey).build();
+  }
+
+  /**
+   * Creates an instance using provided certificate chain and private key. Generally they should be
+   * PEM-encoded and the key is an unencrypted PKCS#8 key (file headers have "BEGIN CERTIFICATE" and
+   * "BEGIN PRIVATE KEY").
+   *
+   * <p>The streams will not be automatically closed.
+   */
+  public static ServerCredentials create(
+      InputStream certChain, InputStream privateKey) throws IOException {
+    return newBuilder().keyManager(certChain, privateKey).build();
+  }
+
+  private final boolean fakeFeature;
+  private final byte[] certificateChain;
+  private final byte[] privateKey;
+  private final String privateKeyPassword;
+  private final List<KeyManager> keyManagers;
+  private final ClientAuth clientAuth;
+  private final byte[] rootCertificates;
+  private final List<TrustManager> trustManagers;
+
+  TlsServerCredentials(Builder builder) {
+    fakeFeature = builder.fakeFeature;
+    certificateChain = builder.certificateChain;
+    privateKey = builder.privateKey;
+    privateKeyPassword = builder.privateKeyPassword;
+    keyManagers = builder.keyManagers;
+    clientAuth = builder.clientAuth;
+    rootCertificates = builder.rootCertificates;
+    trustManagers = builder.trustManagers;
+  }
+
+  /**
+   * The certificate chain for the server's identity, as a new byte array. Generally should be
+   * PEM-encoded. If {@code null}, some feature is providing key manager information via a different
+   * method.
+   */
+  public byte[] getCertificateChain() {
+    if (certificateChain == null) {
+      return null;
+    }
+    return Arrays.copyOf(certificateChain, certificateChain.length);
+  }
+
+  /**
+   * The private key for the server's identity, as a new byte array. Generally should be in PKCS#8
+   * format. If encrypted, {@link #getPrivateKeyPassword} is the decryption key. If unencrypted, the
+   * password will be {@code null}. If {@code null}, some feature is providing key manager
+   * information via a different method.
+   */
+  public byte[] getPrivateKey() {
+    if (privateKey == null) {
+      return null;
+    }
+    return Arrays.copyOf(privateKey, privateKey.length);
+  }
+
+  /** Returns the password to decrypt the private key, or {@code null} if unencrypted. */
+  public String getPrivateKeyPassword() {
+    return privateKeyPassword;
+  }
+
+  /**
+   * Returns the key manager list which provides the server's identity. Entries are scanned checking
+   * for specific types, like {@link javax.net.ssl.X509KeyManager}. Only a single entry for a type
+   * is used. Entries earlier in the list are higher priority. If {@code null}, key manager
+   * information is provided via a different method.
+   */
+  public List<KeyManager> getKeyManagers() {
+    return keyManagers;
+  }
+
+  /** Non-{@code null} setting indicating whether the server should expect a client's identity. */
+  public ClientAuth getClientAuth() {
+    return clientAuth;
+  }
+
+  /**
+   * Root trust certificates for verifying the client's identity that override the system's
+   * defaults. Generally PEM-encoded with multiple certificates concatenated.
+   */
+  public byte[] getRootCertificates() {
+    if (rootCertificates == null) {
+      return null;
+    }
+    return Arrays.copyOf(rootCertificates, rootCertificates.length);
+  }
+
+  /**
+   * Returns the trust manager list which verifies the client's identity. Entries are scanned
+   * checking for specific types, like {@link javax.net.ssl.X509TrustManager}. Only a single entry
+   * for a type is used. Entries earlier in the list are higher priority. If {@code null}, trust
+   * manager information is provided via the system's default or a different method.
+   */
+  public List<TrustManager> getTrustManagers() {
+    return trustManagers;
+  }
+
+  /**
+   * Returns an empty set if this credential can be adequately understood via
+   * the features listed, otherwise returns a hint of features that are lacking
+   * to understand the configuration to be used for manual debugging.
+   *
+   * <p>An "understood" feature does not imply the caller is able to fully
+   * handle the feature. It simply means the caller understands the feature
+   * enough to use the appropriate APIs to read the configuration. The caller
+   * may support just a subset of a feature, in which case the caller would
+   * need to look at the configuration to determine if only the supported
+   * subset is used.
+   *
+   * <p>This method may not be as simple as a set difference. There may be
+   * multiple features that can independently satisfy a piece of configuration.
+   * If the configuration is incomprehensible, all such features would be
+   * returned, even though only one may be necessary.
+   *
+   * <p>An empty set does not imply that the credentials are fully understood.
+   * There may be optional configuration that can be ignored if not understood.
+   *
+   * <p>Since {@code Feature} is an {@code enum}, {@code understoodFeatures}
+   * should generally be an {@link java.util.EnumSet}. {@code
+   * understoodFeatures} will not be modified.
+   *
+   * @param understoodFeatures the features understood by the caller
+   * @return empty set if the caller can adequately understand the configuration
+   */
+  public Set<Feature> incomprehensible(Set<Feature> understoodFeatures) {
+    Set<Feature> incomprehensible = EnumSet.noneOf(Feature.class);
+    if (fakeFeature) {
+      requiredFeature(understoodFeatures, incomprehensible, Feature.FAKE);
+    }
+    if (clientAuth != ClientAuth.NONE) {
+      requiredFeature(understoodFeatures, incomprehensible, Feature.MTLS);
+    }
+    if (keyManagers != null || trustManagers != null) {
+      requiredFeature(understoodFeatures, incomprehensible, Feature.CUSTOM_MANAGERS);
+    }
+    return Collections.unmodifiableSet(incomprehensible);
+  }
+
+  private static void requiredFeature(
+      Set<Feature> understoodFeatures, Set<Feature> incomprehensible, Feature feature) {
+    if (!understoodFeatures.contains(feature)) {
+      incomprehensible.add(feature);
+    }
+  }
+
+  /**
+   * Features to understand TLS configuration. Additional enum values may be added in the future.
+   */
+  public enum Feature {
+    /**
+     * A feature that no consumer should understand. It should be used for unit testing to confirm
+     * a call to {@link #incomprehensible incomprehensible()} is implemented properly.
+     */
+    FAKE,
+    /**
+     * Client certificates may be requested and verified. This feature requires observing {@link
+     * #getRootCertificates()} and {@link #getClientAuth()}. The root certificates are used to
+     * configure a trust manager for verifying the client's identity. If no root certificates are
+     * provided the trust manager will default to the system's root certificates.
+     */
+    MTLS,
+    /**
+     * Key managers and trust managers may be specified as {@link KeyManager} and {@link
+     * TrustManager} objects. This feature by itself only implies {@link #getKeyManagers()} needs to
+     * be observed. But along with {@link #MTLS}, then {@link #getTrustManagers()} needs to be
+     * observed as well. When a manager is non-{@code null}, then it is wholly responsible for key
+     * or trust material and usage; there is no need to check other manager sources like {@link
+     * #getCertificateChain()} or {@link #getPrivateKey()} (if {@code KeyManager} is available), or
+     * {@link #getRootCertificates()} (if {@code TrustManager} is available).
+     *
+     * <p>If other manager sources are available (e.g., {@code getPrivateKey() != null}), then they
+     * may be alternative representations of the same configuration and the consumer is free to use
+     * those alternative representations if it prefers. But before doing so it <em>must</em> first
+     * check that it understands that alternative representation by using {@link #incomprehensible}
+     * <em>without</em> the {@code CUSTOM_MANAGERS} feature.
+     */
+    CUSTOM_MANAGERS,
+    ;
+  }
+
+  /**
+   * Creates a builder for changing default configuration. There is no default key manager, so key
+   * material must be specified. The default trust manager uses the system's root certificates. By
+   * default no client authentication will occur.
+   */
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  /** Builder for {@link TlsServerCredentials}. */
+  public static final class Builder {
+    private boolean fakeFeature;
+    private byte[] certificateChain;
+    private byte[] privateKey;
+    private String privateKeyPassword;
+    private List<KeyManager> keyManagers;
+    private ClientAuth clientAuth = ClientAuth.NONE;
+    private byte[] rootCertificates;
+    private List<TrustManager> trustManagers;
+
+    private Builder() {}
+
+    /**
+     * Requires {@link Feature#FAKE} to be understood. For use in testing consumers of this
+     * credential.
+     */
+    public Builder requireFakeFeature() {
+      fakeFeature = true;
+      return this;
+    }
+
+    /**
+     * Use the provided certificate chain and private key as the server's identity. Generally they
+     * should be PEM-encoded and the key is an unencrypted PKCS#8 key (file headers have "BEGIN
+     * CERTIFICATE" and "BEGIN PRIVATE KEY").
+     */
+    public Builder keyManager(File certChain, File privateKey) throws IOException {
+      return keyManager(certChain, privateKey, null);
+    }
+
+    /**
+     * Use the provided certificate chain and possibly-encrypted private key as the server's
+     * identity. Generally they should be PEM-encoded and the key is a PKCS#8 key. If the private
+     * key is unencrypted, then password must be {@code null}.
+     */
+    public Builder keyManager(File certChain, File privateKey, String privateKeyPassword)
+        throws IOException {
+      InputStream certChainIs = new FileInputStream(certChain);
+      try {
+        InputStream privateKeyIs = new FileInputStream(privateKey);
+        try {
+          return keyManager(certChainIs, privateKeyIs, privateKeyPassword);
+        } finally {
+          privateKeyIs.close();
+        }
+      } finally {
+        certChainIs.close();
+      }
+    }
+
+    /**
+     * Use the provided certificate chain and private key as the server's identity. Generally they
+     * should be PEM-encoded and the key is an unencrypted PKCS#8 key (file headers have "BEGIN
+     * CERTIFICATE" and "BEGIN PRIVATE KEY").
+     */
+    public Builder keyManager(InputStream certChain, InputStream privateKey) throws IOException {
+      return keyManager(certChain, privateKey, null);
+    }
+
+    /**
+     * Use the provided certificate chain and possibly-encrypted private key as the server's
+     * identity. Generally they should be PEM-encoded and the key is a PKCS#8 key. If the private
+     * key is unencrypted, then password must be {@code null}.
+     */
+    public Builder keyManager(
+        InputStream certChain, InputStream privateKey, String privateKeyPassword)
+        throws IOException {
+      byte[] certChainBytes = ByteStreams.toByteArray(certChain);
+      byte[] privateKeyBytes = ByteStreams.toByteArray(privateKey);
+      clearKeyManagers();
+      this.certificateChain = certChainBytes;
+      this.privateKey = privateKeyBytes;
+      this.privateKeyPassword = privateKeyPassword;
+      return this;
+    }
+
+    /**
+     * Have the provided key manager select the server's identity. Although multiple are allowed,
+     * only the first instance implementing a particular interface is used. So generally there will
+     * just be a single entry and it implements {@link javax.net.ssl.X509KeyManager}.
+     */
+    public Builder keyManager(KeyManager... keyManagers) {
+      List<KeyManager> keyManagerList = Collections.unmodifiableList(new ArrayList<>(
+          Arrays.asList(keyManagers)));
+      clearKeyManagers();
+      this.keyManagers = keyManagerList;
+      return this;
+    }
+
+    private void clearKeyManagers() {
+      this.certificateChain = null;
+      this.privateKey = null;
+      this.privateKeyPassword = null;
+      this.keyManagers = null;
+    }
+
+    /**
+     * Indicates whether the server should expect a client's identity. Must not be {@code null}.
+     * Defaults to {@link ClientAuth#NONE}.
+     */
+    public Builder clientAuth(ClientAuth clientAuth) {
+      Preconditions.checkNotNull(clientAuth, "clientAuth");
+      this.clientAuth = clientAuth;
+      return this;
+    }
+
+    /**
+     * Use the provided root certificates to verify the client's identity instead of the system's
+     * default. Generally they should be PEM-encoded with all the certificates concatenated together
+     * (file header has "BEGIN CERTIFICATE", and would occur once per certificate).
+     */
+    public Builder trustManager(File rootCerts) throws IOException {
+      InputStream rootCertsIs = new FileInputStream(rootCerts);
+      try {
+        return trustManager(rootCertsIs);
+      } finally {
+        rootCertsIs.close();
+      }
+    }
+
+    /**
+     * Use the provided root certificates to verify the client's identity instead of the system's
+     * default. Generally they should be PEM-encoded with all the certificates concatenated together
+     * (file header has "BEGIN CERTIFICATE", and would occur once per certificate).
+     */
+    public Builder trustManager(InputStream rootCerts) throws IOException {
+      byte[] rootCertsBytes = ByteStreams.toByteArray(rootCerts);
+      clearTrustManagers();
+      this.rootCertificates = rootCertsBytes;
+      return this;
+    }
+
+    /**
+     * Have the provided trust manager verify the client's identity instead of the system's default.
+     * Although multiple are allowed, only the first instance implementing a particular interface is
+     * used. So generally there will just be a single entry and it implements {@link
+     * javax.net.ssl.X509TrustManager}.
+     */
+    public Builder trustManager(TrustManager... trustManagers) {
+      List<TrustManager> trustManagerList = Collections.unmodifiableList(new ArrayList<>(
+          Arrays.asList(trustManagers)));
+      clearTrustManagers();
+      this.trustManagers = trustManagerList;
+      return this;
+    }
+
+    private void clearTrustManagers() {
+      this.rootCertificates = null;
+      this.trustManagers = null;
+    }
+
+    /** Construct the credentials. */
+    public ServerCredentials build() {
+      if (certificateChain == null && keyManagers == null) {
+        throw new IllegalStateException("A key manager is required");
+      }
+      return new TlsServerCredentials(this);
+    }
+  }
+
+  /** The level of authentication the server should expect from the client. */
+  public enum ClientAuth {
+    /** Clients will not present any identity. */
+    NONE,
+
+    /**
+     * Clients are requested to present their identity, but clients without identities are
+     * permitted.
+     */
+    OPTIONAL,
+
+    /**
+     * Clients are requested to present their identity, and are required to provide a valid
+     * identity.
+     */
+    REQUIRE;
+  }
+}
diff --git a/api/src/main/java/io/grpc/Uri.java b/api/src/main/java/io/grpc/Uri.java
new file mode 100644
index 00000000000..3034211752b
--- /dev/null
+++ b/api/src/main/java/io/grpc/Uri.java
@@ -0,0 +1,1094 @@
+/*
+ * Copyright 2025 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;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.base.VerifyException;
+import com.google.common.collect.ImmutableList;
+import com.google.common.net.InetAddresses;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import java.net.InetAddress;
+import java.net.URISyntaxException;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CodingErrorAction;
+import java.nio.charset.MalformedInputException;
+import java.nio.charset.StandardCharsets;
+import java.util.BitSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import javax.annotation.Nullable;
+
+/**
+ * A not-quite-general-purpose representation of a Uniform Resource Identifier (URI), as defined by
+ * <a href="https://datatracker.ietf.org/doc/html/rfc3986">RFC 3986</a>.
+ *
+ * <h1>The URI</h1>
+ *
+ * <p>A URI identifies a resource by its name or location or both. The resource could be a file,
+ * service, or some other abstract entity.
+ *
+ * <h2>Examples</h2>
+ *
+ * <ul>
+ *   <li><code>http://admin@example.com:8080/controlpanel?filter=users#settings</code>
+ *   <li><code>ftp://[2001:db8::7]/docs/report.pdf</code>
+ *   <li><code>file:///My%20Computer/Documents/letter.doc</code>
+ *   <li><code>dns://8.8.8.8/storage.googleapis.com</code>
+ *   <li><code>mailto:John.Doe@example.com</code>
+ *   <li><code>tel:+1-206-555-1212</code>
+ *   <li><code>urn:isbn:978-1492082798</code>
+ * </ul>
+ *
+ * <h2>Limitations</h2>
+ *
+ * <p>This class aims to meet the needs of grpc-java itself and RPC related code that depend on it.
+ * It isn't quite general-purpose. It definitely would not be suitable for building an HTTP user
+ * agent or proxy server. In particular, it:
+ *
+ * <ul>
+ *   <li>Can only represent a URI, not a "URI-reference" or "relative reference". In other words, a
+ *       "scheme" is always required.
+ *   <li>Has no knowledge of the particulars of any scheme, with respect to normalization and
+ *       comparison. We don't know <code>https://google.com</code> is the same as <code>
+ *       https://google.com:443</code>, that <code>file:///</code> is the same as <code>
+ *       file://localhost</code>, or that <code>joe@example.com</code> is the same as <code>
+ *       joe@EXAMPLE.COM</code>. No one class can or should know everything about every scheme so
+ *       all this is better handled at a higher layer.
+ *   <li>Implements {@link #equals(Object)} as a char-by-char comparison. Expect false negatives.
+ *   <li>Does not support "IPvFuture" literal addresses.
+ *   <li>Does not reflect how web browsers parse user input or the <a
+ *       href="https://url.spec.whatwg.org/">URL Living Standard</a>.
+ *   <li>Does not support different character encodings. Assumes UTF-8 in several places.
+ * </ul>
+ *
+ * <h2>Migrating from RFC 2396 and {@link java.net.URI}</h2>
+ *
+ * <p>Those migrating from {@link java.net.URI} and/or its primary specification in RFC 2396 should
+ * note some differences.
+ *
+ * <h3>Uniform Hierarchical Syntax</h3>
+ *
+ * <p>RFC 3986 unifies the older ideas of "hierarchical" and "opaque" URIs into a single generic
+ * syntax. What RFC 2396 called an opaque "scheme-specific part" is always broken out by RFC 3986
+ * into an authority and path hierarchy, followed by query and fragment components. Accordingly,
+ * this class has only getters for those components but no {@link
+ * java.net.URI#getSchemeSpecificPart()} analog.
+ *
+ * <p>The RFC 3986 definition of path is now more liberal to accommodate this:
+ *
+ * <ul>
+ *   <li>Path doesn't have to start with a slash. For example, the path of <code>
+ *       urn:isbn:978-1492082798</code> is <code>isbn:978-1492082798</code> even though it doesn't
+ *       look much like a file system path.
+ *   <li>The path can now be empty. So Android's <code>
+ *       intent:#Intent;action=MAIN;category=LAUNCHER;end</code> is now a valid {@link Uri}. Even
+ *       the scheme-only <code>about:</code> is now valid.
+ * </ul>
+ *
+ * <p>The uniform syntax always understands what follows a '?' to be a query string. For example,
+ * <code>mailto:me@example.com?subject=foo</code> now has a query component whereas RFC 2396
+ * considered everything after the <code>mailto:</code> scheme to be opaque.
+ *
+ * <p>Same goes for fragment. <code>data:image/png;...#xywh=0,0,10,10</code> now has a fragment
+ * whereas RFC 2396 considered everything after the scheme to be opaque.
+ *
+ * <h3>Uniform Authority Syntax</h3>
+ *
+ * <p>RFC 2396 tried to guess if an authority was a "server" (host:port) or "registry-based"
+ * (arbitrary string) based on its contents. RFC 3986 expects every authority to look like
+ * [userinfo@]host[:port] and loosens the definition of a "host" to accommodate. Accordingly, this
+ * class has no equivalent to {@link java.net.URI#parseServerAuthority()} -- authority was parsed
+ * into its components and checked for validity when the {@link Uri} was created.
+ *
+ * <h3>Other Specific Differences</h3>
+ *
+ * <p>RFC 2396 does not allow underscores in a host name, meaning {@link java.net.URI} switches to
+ * opaque mode when it sees one. {@link Uri} does allow underscores in host, to accommodate
+ * registries other than DNS. So <code>http://my_site.com:8080/index.html</code> now parses as a
+ * host, port and path rather than a single opaque scheme-specific part.
+ *
+ * <p>{@link Uri} strictly *requires* square brackets in the query string and fragment to be
+ * percent-encoded whereas RFC 2396 merely recommended doing so.
+ *
+ * <p>Other URx classes are "liberal in what they accept and strict in what they produce." {@link
+ * Uri#parse(String)} and {@link Uri#create(String)}, however, are strict in what they accept and
+ * transparent when asked to reproduce it via {@link Uri#toString()}. The former policy may be
+ * appropriate for parsing user input or web content, but this class is meant for gRPC clients,
+ * servers and plugins like name resolvers where human error at runtime is less likely and best
+ * detected early. {@link java.net.URI#create(String)} is similarly strict, which makes migration
+ * easy, except for the server/registry-based ambiguity addressed by {@link
+ * java.net.URI#parseServerAuthority()}.
+ *
+ * <p>{@link java.net.URI} and {@link Uri} both support IPv6 literals in square brackets as defined
+ * by RFC 2732.
+ *
+ * <p>{@link java.net.URI} supports IPv6 scope IDs but accepts and emits a non-standard syntax.
+ * {@link Uri} implements the newer RFC 6874, which percent encodes scope IDs and the % delimiter
+ * itself. RFC 9844 claims to obsolete RFC 6874 because web browsers would not support it. This
+ * class implements RFC 6874 anyway, mostly to avoid creating a barrier to migration away from
+ * {@link java.net.URI}.
+ */
+@Internal
+public final class Uri {
+  // Components are stored percent-encoded, just as originally parsed for transparent parse/toString
+  // round-tripping.
+  private final String scheme; // != null since we don't support relative references.
+  @Nullable private final String userInfo;
+  @Nullable private final String host;
+  @Nullable private final String port;
+  private final String path; // In RFC 3986, path is always defined (but can be empty).
+  @Nullable private final String query;
+  @Nullable private final String fragment;
+
+  private Uri(Builder builder) {
+    this.scheme = checkNotNull(builder.scheme, "scheme");
+    this.userInfo = builder.userInfo;
+    this.host = builder.host;
+    this.port = builder.port;
+    this.path = builder.path;
+    this.query = builder.query;
+    this.fragment = builder.fragment;
+
+    // Checks common to the parse() and Builder code paths.
+    if (hasAuthority()) {
+      if (!path.isEmpty() && !path.startsWith("/")) {
+        throw new IllegalArgumentException("Has authority -- Non-empty path must start with '/'");
+      }
+    } else {
+      if (path.startsWith("//")) {
+        throw new IllegalArgumentException("No authority -- Path cannot start with '//'");
+      }
+    }
+  }
+
+  /**
+   * Parses a URI from its string form.
+   *
+   * @throws URISyntaxException if 's' is not a valid RFC 3986 URI.
+   */
+  public static Uri parse(String s) throws URISyntaxException {
+    try {
+      return create(s);
+    } catch (IllegalArgumentException e) {
+      throw new URISyntaxException(s, e.getMessage());
+    }
+  }
+
+  /**
+   * Creates a URI from a string assumed to be valid.
+   *
+   * <p>Useful for defining URI constants in code. Not for user input.
+   *
+   * @throws IllegalArgumentException if 's' is not a valid RFC 3986 URI.
+   */
+  public static Uri create(String s) {
+    Builder builder = new Builder();
+    int i = 0;
+    final int n = s.length();
+
+    // 3.1. Scheme: Look for a ':' before '/', '?', or '#'.
+    int schemeColon = -1;
+    for (; i < n; ++i) {
+      char c = s.charAt(i);
+      if (c == ':') {
+        schemeColon = i;
+        break;
+      } else if (c == '/' || c == '?' || c == '#') {
+        break;
+      }
+    }
+    if (schemeColon < 0) {
+      throw new IllegalArgumentException("Missing required scheme.");
+    }
+    builder.setRawScheme(s.substring(0, schemeColon));
+
+    // 3.2. Authority. Look for '//' then keep scanning until '/', '?', or '#'.
+    i = schemeColon + 1;
+    if (i + 1 < n && s.charAt(i) == '/' && s.charAt(i + 1) == '/') {
+      // "//" just means we have an authority. Skip over it.
+      i += 2;
+
+      int authorityStart = i;
+      for (; i < n; ++i) {
+        char c = s.charAt(i);
+        if (c == '/' || c == '?' || c == '#') {
+          break;
+        }
+      }
+      String authority = s.substring(authorityStart, i);
+
+      // 3.2.1. UserInfo. Easy, because '@' cannot appear unencoded inside userinfo or host.
+      int userInfoEnd = authority.indexOf('@');
+      if (userInfoEnd >= 0) {
+        builder.setRawUserInfo(authority.substring(0, userInfoEnd));
+      }
+
+      // 3.2.2/3. Host/Port.
+      int hostStart = userInfoEnd >= 0 ? userInfoEnd + 1 : 0;
+      int portStartColon = findPortStartColon(authority, hostStart);
+      if (portStartColon < 0) {
+        builder.setRawHost(authority.substring(hostStart, authority.length()));
+      } else {
+        builder.setRawHost(authority.substring(hostStart, portStartColon));
+        builder.setRawPort(authority.substring(portStartColon + 1));
+      }
+    }
+
+    // 3.3. Path: Whatever is left before '?' or '#'.
+    int pathStart = i;
+    for (; i < n; ++i) {
+      char c = s.charAt(i);
+      if (c == '?' || c == '#') {
+        break;
+      }
+    }
+    builder.setRawPath(s.substring(pathStart, i));
+
+    // 3.4. Query, if we stopped at '?'.
+    if (i < n && s.charAt(i) == '?') {
+      i++; // Skip '?'
+      int queryStart = i;
+      for (; i < n; ++i) {
+        char c = s.charAt(i);
+        if (c == '#') {
+          break;
+        }
+      }
+      builder.setRawQuery(s.substring(queryStart, i));
+    }
+
+    // 3.5. Fragment, if we stopped at '#'.
+    if (i < n && s.charAt(i) == '#') {
+      ++i; // Skip '#'
+      builder.setRawFragment(s.substring(i));
+    }
+
+    return builder.build();
+  }
+
+  private static int findPortStartColon(String authority, int hostStart) {
+    for (int i = authority.length() - 1; i >= hostStart; --i) {
+      char c = authority.charAt(i);
+      if (c == ':') {
+        return i;
+      }
+      if (c == ']') {
+        // Hit the end of IP-literal. Any further colon is inside it and couldn't indicate a port.
+        break;
+      }
+      if (!digitChars.get(c)) {
+        // Found a non-digit, non-colon, non-bracket.
+        // This means there is no valid port (e.g. host is "example.com")
+        break;
+      }
+    }
+    return -1;
+  }
+
+  // Checks a raw path for validity and parses it into segments. Let 'out' be null to just validate.
+  private static void parseAssumedUtf8PathIntoSegments(
+      String path, ImmutableList.Builder<String> out) {
+    // Skip the first slash so it doesn't count as an empty segment at the start.
+    // (e.g., "/a" -> ["a"], not ["", "a"])
+    int start = path.startsWith("/") ? 1 : 0;
+
+    for (int i = start; i < path.length(); ) {
+      int nextSlash = path.indexOf('/', i);
+      String segment;
+      if (nextSlash >= 0) {
+        // Typical segment case (e.g., "foo" in "/foo/bar").
+        segment = path.substring(i, nextSlash);
+        i = nextSlash + 1;
+      } else {
+        // Final segment case (e.g., "bar" in "/foo/bar").
+        segment = path.substring(i);
+        i = path.length();
+      }
+      if (out != null) {
+        out.add(percentDecodeAssumedUtf8(segment));
+      } else {
+        checkPercentEncodedArg(segment, "path segment", pChars);
+      }
+    }
+
+    // RFC 3986 says a trailing slash creates a final empty segment.
+    // (e.g., "/foo/" -> ["foo", ""])
+    if (path.endsWith("/") && out != null) {
+      out.add("");
+    }
+  }
+
+  /** Returns the scheme of this URI. */
+  public String getScheme() {
+    return scheme;
+  }
+
+  /**
+   * Returns the percent-decoded "Authority" component of this URI, or null if not present.
+   *
+   * <p>NB: This method assumes the "host" component was encoded as UTF-8, as mandated by RFC 3986.
+   * This method also assumes the "user information" part of authority was encoded as UTF-8,
+   * although RFC 3986 doesn't specify an encoding.
+   *
+   * <p>Decoding errors are indicated by a {@code '\u005CuFFFD'} unicode replacement character in
+   * the output. Callers who want to detect and handle errors in some other way should call {@link
+   * #getRawAuthority()}, {@link #percentDecode(CharSequence)}, then decode the bytes for
+   * themselves.
+   */
+  @Nullable
+  public String getAuthority() {
+    return percentDecodeAssumedUtf8(getRawAuthority());
+  }
+
+  private boolean hasAuthority() {
+    return host != null;
+  }
+
+  /**
+   * Returns the "authority" component of this URI in its originally parsed, possibly
+   * percent-encoded form.
+   */
+  @Nullable
+  public String getRawAuthority() {
+    if (hasAuthority()) {
+      StringBuilder sb = new StringBuilder();
+      appendAuthority(sb);
+      return sb.toString();
+    }
+    return null;
+  }
+
+  private void appendAuthority(StringBuilder sb) {
+    if (userInfo != null) {
+      sb.append(userInfo).append('@');
+    }
+    if (host != null) {
+      sb.append(host);
+    }
+    if (port != null) {
+      sb.append(':').append(port);
+    }
+  }
+
+  /**
+   * Returns the percent-decoded "User Information" component of this URI, or null if not present.
+   *
+   * <p>NB: This method *assumes* this component was encoded as UTF-8, although RFC 3986 doesn't
+   * specify an encoding.
+   *
+   * <p>Decoding errors are indicated by a {@code '\u005CuFFFD'} unicode replacement character in
+   * the output. Callers who want to detect and handle errors in some other way should call {@link
+   * #getRawUserInfo()}, {@link #percentDecode(CharSequence)}, then decode the bytes for themselves.
+   */
+  @Nullable
+  public String getUserInfo() {
+    return percentDecodeAssumedUtf8(userInfo);
+  }
+
+  /**
+   * Returns the "User Information" component of this URI in its originally parsed, possibly
+   * percent-encoded form.
+   */
+  @Nullable
+  public String getRawUserInfo() {
+    return userInfo;
+  }
+
+  /**
+   * Returns the percent-decoded "host" component of this URI, or null if not present.
+   *
+   * <p>This method assumes the host was encoded as UTF-8, as mandated by RFC 3986.
+   *
+   * <p>Decoding errors are indicated by a {@code '\u005CuFFFD'} unicode replacement character in
+   * the output. Callers who want to detect and handle errors in some other way should call {@link
+   * #getRawHost()}, {@link #percentDecode(CharSequence)}, then decode the bytes for themselves.
+   */
+  @Nullable
+  public String getHost() {
+    return percentDecodeAssumedUtf8(host);
+  }
+
+  /**
+   * Returns the host component of this URI in its originally parsed, possibly percent-encoded form.
+   */
+  @Nullable
+  public String getRawHost() {
+    return host;
+  }
+
+  /** Returns the "port" component of this URI, or -1 if not present. */
+  public int getPort() {
+    return port != null ? Integer.parseInt(port) : -1;
+  }
+
+  /** Returns the raw port component of this URI in its originally parsed form. */
+  @Nullable
+  public String getRawPort() {
+    return port;
+  }
+
+  /**
+   * Returns the (possibly empty) percent-decoded "path" component of this URI.
+   *
+   * <p>NB: This method *assumes* the path was encoded as UTF-8, although RFC 3986 doesn't specify
+   * an encoding.
+   *
+   * <p>Decoding errors are indicated by a {@code '\u005CuFFFD'} unicode replacement character in
+   * the output. Callers who want to detect and handle errors in some other way should call {@link
+   * #getRawPath()}, {@link #percentDecode(CharSequence)}, then decode the bytes for themselves.
+   *
+   * <p>NB: Prefer {@link #getPathSegments()} because this method's decoding is lossy. For example,
+   * consider these (different) URIs:
+   *
+   * <ul>
+   *   <li>file:///home%2Ffolder/my%20file
+   *   <li>file:///home/folder/my%20file
+   * </ul>
+   *
+   * <p>Calling getPath() on each returns the same string: <code>/home/folder/my file</code>. You
+   * can't tell whether the second '/' character is part of the first path segment or separates the
+   * first and second path segments. This method only exists to ease migration from {@link
+   * java.net.URI}.
+   */
+  public String getPath() {
+    return percentDecodeAssumedUtf8(path);
+  }
+
+  /**
+   * Returns this URI's path as a list of path segments not including the '/' segment delimiters.
+   *
+   * <p>Prefer this method over {@link #getPath()} because it preserves the distinction between
+   * segment separators and literal '/'s within a path segment.
+   *
+   * <p>A trailing '/' delimiter in the path results in the empty string as the last element in the
+   * returned list. For example, <code>file://localhost/foo/bar/</code> has path segments <code>
+   * ["foo", "bar", ""]</code>
+   *
+   * <p>A leading '/' delimiter cannot be detected using this method. For example, both <code>
+   * dns:example.com</code> and <code>dns:///example.com</code> have the same list of path segments:
+   * <code>["example.com"]</code>. Use {@link #isPathAbsolute()} or {@link #isPathRootless()} to
+   * distinguish these cases.
+   *
+   * <p>The returned list is immutable.
+   */
+  public List<String> getPathSegments() {
+    // Returned list must be immutable but we intentionally keep guava out of the public API.
+    ImmutableList.Builder<String> segmentsBuilder = ImmutableList.builder();
+    parseAssumedUtf8PathIntoSegments(path, segmentsBuilder);
+    return segmentsBuilder.build();
+  }
+
+  /**
+   * Returns true iff this URI's path component starts with a path segment (rather than the '/'
+   * segment delimiter).
+   *
+   * <p>The path of an RFC 3986 URI is either empty, absolute (starts with the '/' segment
+   * delimiter) or rootless (starts with a path segment). For example, <code>tel:+1-206-555-1212
+   * </code>, <code>mailto:me@example.com</code> and <code>urn:isbn:978-1492082798</code> all have
+   * rootless paths. <code>mailto:%2Fdev%2Fnull@example.com</code> is also rootless because its
+   * percent-encoded slashes are not segment delimiters but rather part of the first and only path
+   * segment.
+   *
+   * <p>Contrast rootless paths with absolute ones (see {@link #isPathAbsolute()}.
+   */
+  public boolean isPathRootless() {
+    return !path.isEmpty() && !path.startsWith("/");
+  }
+
+  /**
+   * Returns true iff this URI's path component starts with the '/' segment delimiter (rather than a
+   * path segment).
+   *
+   * <p>The path of an RFC 3986 URI is either empty, absolute (starts with the '/' segment
+   * delimiter) or rootless (starts with a path segment). For example, <code>file:///resume.txt
+   * </code>, <code>file:/resume.txt</code> and <code>file://localhost/</code> all have absolute
+   * paths while <code>tel:+1-206-555-1212</code>'s path is not absolute. <code>
+   * mailto:%2Fdev%2Fnull@example.com</code> is also not absolute because its percent-encoded
+   * slashes are not segment delimiters but rather part of the first and only path segment.
+   *
+   * <p>Contrast absolute paths with rootless ones (see {@link #isPathRootless()}.
+   *
+   * <p>NB: The term "absolute" has two different meanings in RFC 3986 which are easily confused.
+   * This method tests for a property of this URI's path component. Contrast with {@link
+   * #isAbsolute()} which tests the URI itself for a different property.
+   */
+  public boolean isPathAbsolute() {
+    return path.startsWith("/");
+  }
+
+  /**
+   * Returns the path component of this URI in its originally parsed, possibly percent-encoded form.
+   */
+  public String getRawPath() {
+    return path;
+  }
+
+  /**
+   * Returns the percent-decoded "query" component of this URI, or null if not present.
+   *
+   * <p>NB: This method assumes the query was encoded as UTF-8, although RFC 3986 doesn't specify an
+   * encoding.
+   *
+   * <p>Decoding errors are indicated by a {@code '\u005CuFFFD'} unicode replacement character in
+   * the output. Callers who want to detect and handle errors in some other way should call {@link
+   * #getRawQuery()}, {@link #percentDecode(CharSequence)}, then decode the bytes for themselves.
+   */
+  @Nullable
+  public String getQuery() {
+    return percentDecodeAssumedUtf8(query);
+  }
+
+  /**
+   * Returns the query component of this URI in its originally parsed, possibly percent-encoded
+   * form, without any leading '?' character.
+   */
+  @Nullable
+  public String getRawQuery() {
+    return query;
+  }
+
+  /**
+   * Returns the percent-decoded "fragment" component of this URI, or null if not present.
+   *
+   * <p>NB: This method assumes the fragment was encoded as UTF-8, although RFC 3986 doesn't specify
+   * an encoding.
+   *
+   * <p>Decoding errors are indicated by a {@code '\u005CuFFFD'} unicode replacement character in
+   * the output. Callers who want to detect and handle errors in some other way should call {@link
+   * #getRawFragment()}, {@link #percentDecode(CharSequence)}, then decode the bytes for themselves.
+   */
+  @Nullable
+  public String getFragment() {
+    return percentDecodeAssumedUtf8(fragment);
+  }
+
+  /**
+   * Returns the fragment component of this URI in its original, possibly percent-encoded form, and
+   * without any leading '#' character.
+   */
+  @Nullable
+  public String getRawFragment() {
+    return fragment;
+  }
+
+  /**
+   * {@inheritDoc}
+   *
+   * <p>If this URI was created by {@link #parse(String)} or {@link #create(String)}, then the
+   * returned string will match that original input exactly.
+   */
+  @Override
+  public String toString() {
+    // https://datatracker.ietf.org/doc/html/rfc3986#section-5.3
+    StringBuilder sb = new StringBuilder();
+    sb.append(scheme).append(':');
+    if (hasAuthority()) {
+      sb.append("//");
+      appendAuthority(sb);
+    }
+    sb.append(path);
+    if (query != null) {
+      sb.append('?').append(query);
+    }
+    if (fragment != null) {
+      sb.append('#').append(fragment);
+    }
+    return sb.toString();
+  }
+
+  /**
+   * Returns true iff this URI has a scheme and an authority/path hierarchy, but no fragment.
+   *
+   * <p>All instances of {@link Uri} are RFC 3986 URIs, not "relative references", so this method is
+   * equivalent to {@code getFragment() == null}. It mostly exists for compatibility with {@link
+   * java.net.URI}.
+   */
+  public boolean isAbsolute() {
+    return scheme != null && fragment == null;
+  }
+
+  /**
+   * {@inheritDoc}
+   *
+   * <p>Two instances of {@link Uri} are equal if and only if they have the same string
+   * representation, which RFC 3986 calls "Simple String Comparison" (6.2.1). Callers with a higher
+   * layer expectation of equality (e.g. <code>http://some%2Dhost:80/foo/./bar.txt</code> ~= <code>
+   * http://some-host/foo/bar.txt</code>) will experience false negatives.
+   */
+  @Override
+  public boolean equals(Object otherObj) {
+    if (!(otherObj instanceof Uri)) {
+      return false;
+    }
+    Uri other = (Uri) otherObj;
+    return Objects.equals(scheme, other.scheme)
+        && Objects.equals(userInfo, other.userInfo)
+        && Objects.equals(host, other.host)
+        && Objects.equals(port, other.port)
+        && Objects.equals(path, other.path)
+        && Objects.equals(query, other.query)
+        && Objects.equals(fragment, other.fragment);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(scheme, userInfo, host, port, path, query, fragment);
+  }
+
+  /** Returns a new Builder initialized with the fields of this URI. */
+  public Builder toBuilder() {
+    return new Builder(this);
+  }
+
+  /** Creates a new {@link Builder} with all fields uninitialized or set to their default values. */
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  /** Builder for {@link Uri}. */
+  public static final class Builder {
+    private String scheme;
+    private String path = "";
+    private String query;
+    private String fragment;
+    private String userInfo;
+    private String host;
+    private String port;
+
+    private Builder() {}
+
+    Builder(Uri prototype) {
+      this.scheme = prototype.scheme;
+      this.userInfo = prototype.userInfo;
+      this.host = prototype.host;
+      this.port = prototype.port;
+      this.path = prototype.path;
+      this.query = prototype.query;
+      this.fragment = prototype.fragment;
+    }
+
+    /**
+     * Sets the scheme, e.g. "https", "dns" or "xds".
+     *
+     * <p>This field is required.
+     *
+     * @return this, for fluent building
+     * @throws IllegalArgumentException if the scheme is invalid.
+     */
+    @CanIgnoreReturnValue
+    public Builder setScheme(String scheme) {
+      return setRawScheme(scheme.toLowerCase(Locale.ROOT));
+    }
+
+    @CanIgnoreReturnValue
+    Builder setRawScheme(String scheme) {
+      if (scheme.isEmpty() || !alphaChars.get(scheme.charAt(0))) {
+        throw new IllegalArgumentException("Scheme must start with an alphabetic char");
+      }
+      for (int i = 0; i < scheme.length(); i++) {
+        char c = scheme.charAt(i);
+        if (!schemeChars.get(c)) {
+          throw new IllegalArgumentException("Invalid character in scheme at index " + i);
+        }
+      }
+      this.scheme = scheme;
+      return this;
+    }
+
+    /**
+     * Specifies the new URI's path component as a string of zero or more '/' delimited segments.
+     *
+     * <p>Path segments can consist of any string of codepoints. Codepoints that can't be encoded
+     * literally will be percent-encoded for you.
+     *
+     * <p>If a URI contains an authority component, then the path component must either be empty or
+     * begin with a slash ("/") character. If a URI does not contain an authority component, then
+     * the path cannot begin with two slash characters ("//").
+     *
+     * <p>This method interprets all '/' characters in 'path' as segment delimiters. If any of your
+     * segments contain literal '/' characters, call {@link #setRawPath(String)} instead.
+     *
+     * <p>See <a href="https://datatracker.ietf.org/doc/html/rfc3986#section-3.3">RFC 3986 3.3</a>
+     * for more.
+     *
+     * <p>This field is required but can be empty (its default value).
+     *
+     * @param path the new path
+     * @return this, for fluent building
+     */
+    @CanIgnoreReturnValue
+    public Builder setPath(String path) {
+      checkArgument(path != null, "Path can be empty but not null");
+      this.path = percentEncode(path, pCharsAndSlash);
+      return this;
+    }
+
+    /**
+     * Specifies the new URI's path component as a string of zero or more '/' delimited segments.
+     *
+     * <p>Path segments can consist of any string of codepoints but the caller must first percent-
+     * encode anything other than RFC 3986's "pchar" character class using UTF-8.
+     *
+     * <p>If a URI contains an authority component, then the path component must either be empty or
+     * begin with a slash ("/") character. If a URI does not contain an authority component, then
+     * the path cannot begin with two slash characters ("//").
+     *
+     * <p>This method interprets all '/' characters in 'path' as segment delimiters. If any of your
+     * segments contain literal '/' characters, you must percent-encode them.
+     *
+     * <p>See <a href="https://datatracker.ietf.org/doc/html/rfc3986#section-3.3">RFC 3986 3.3</a>
+     * for more.
+     *
+     * <p>This field is required but can be empty (its default value).
+     *
+     * @param path the new path, a string consisting of characters from "pchar"
+     * @return this, for fluent building
+     */
+    @CanIgnoreReturnValue
+    public Builder setRawPath(String path) {
+      checkArgument(path != null, "Path can be empty but not null");
+      parseAssumedUtf8PathIntoSegments(path, null);
+      this.path = path;
+      return this;
+    }
+
+    /**
+     * Specifies the query component of the new URI (not including the leading '?').
+     *
+     * <p>Query can contain any string of codepoints. Codepoints that can't be encoded literally
+     * will be percent-encoded for you as UTF-8.
+     *
+     * <p>This field is optional.
+     *
+     * @param query the new query component, or null to clear this field
+     * @return this, for fluent building
+     */
+    @CanIgnoreReturnValue
+    public Builder setQuery(@Nullable String query) {
+      this.query = percentEncode(query, queryChars);
+      return this;
+    }
+
+    @CanIgnoreReturnValue
+    Builder setRawQuery(String query) {
+      checkPercentEncodedArg(query, "query", queryChars);
+      this.query = query;
+      return this;
+    }
+
+    /**
+     * Specifies the fragment component of the new URI (not including the leading '#').
+     *
+     * <p>The fragment can contain any string of codepoints. Codepoints that can't be encoded
+     * literally will be percent-encoded for you as UTF-8.
+     *
+     * <p>This field is optional.
+     *
+     * @param fragment the new fragment component, or null to clear this field
+     * @return this, for fluent building
+     */
+    @CanIgnoreReturnValue
+    public Builder setFragment(@Nullable String fragment) {
+      this.fragment = percentEncode(fragment, fragmentChars);
+      return this;
+    }
+
+    @CanIgnoreReturnValue
+    Builder setRawFragment(String fragment) {
+      checkPercentEncodedArg(fragment, "fragment", fragmentChars);
+      this.fragment = fragment;
+      return this;
+    }
+
+    /**
+     * Set the "user info" component of the new URI, e.g. "username:password", not including the
+     * trailing '@' character.
+     *
+     * <p>User info can contain any string of codepoints. Codepoints that can't be encoded literally
+     * will be percent-encoded for you as UTF-8.
+     *
+     * <p>This field is optional.
+     *
+     * @param userInfo the new "user info" component, or null to clear this field
+     * @return this, for fluent building
+     */
+    @CanIgnoreReturnValue
+    public Builder setUserInfo(@Nullable String userInfo) {
+      this.userInfo = percentEncode(userInfo, userInfoChars);
+      return this;
+    }
+
+    @CanIgnoreReturnValue
+    Builder setRawUserInfo(String userInfo) {
+      checkPercentEncodedArg(userInfo, "userInfo", userInfoChars);
+      this.userInfo = userInfo;
+      return this;
+    }
+
+    /**
+     * Specifies the "host" component of the new URI in its "registered name" form (usually DNS),
+     * e.g. "server.com".
+     *
+     * <p>The registered name can contain any string of codepoints. Codepoints that can't be encoded
+     * literally will be percent-encoded for you as UTF-8.
+     *
+     * <p>This field is optional.
+     *
+     * @param regName the new host component in "registered name" form, or null to clear this field
+     * @return this, for fluent building
+     */
+    @CanIgnoreReturnValue
+    public Builder setHost(@Nullable String regName) {
+      if (regName != null) {
+        regName = regName.toLowerCase(Locale.ROOT);
+        regName = percentEncode(regName, regNameChars);
+      }
+      this.host = regName;
+      return this;
+    }
+
+    /**
+     * Specifies the "host" component of the new URI as an IP address.
+     *
+     * <p>This field is optional.
+     *
+     * @param addr the new "host" component in InetAddress form, or null to clear this field
+     * @return this, for fluent building
+     */
+    @CanIgnoreReturnValue
+    public Builder setHost(@Nullable InetAddress addr) {
+      this.host = addr != null ? toUriString(addr) : null;
+      return this;
+    }
+
+    private static String toUriString(InetAddress addr) {
+      // InetAddresses.toUriString(addr) is almost enough but neglects RFC 6874 percent encoding.
+      String inetAddrStr = InetAddresses.toUriString(addr);
+      int percentIndex = inetAddrStr.indexOf('%');
+      if (percentIndex < 0) {
+        return inetAddrStr;
+      }
+
+      String scope = inetAddrStr.substring(percentIndex, inetAddrStr.length() - 1);
+      return inetAddrStr.substring(0, percentIndex) + percentEncode(scope, unreservedChars) + "]";
+    }
+
+    @CanIgnoreReturnValue
+    Builder setRawHost(String host) {
+      if (host.startsWith("[") && host.endsWith("]")) {
+        // IP-literal: Guava's isUriInetAddress() is almost enough but it doesn't check the scope.
+        int percentIndex = host.indexOf('%');
+        if (percentIndex > 0) {
+          String scope = host.substring(percentIndex, host.length() - 1);
+          checkPercentEncodedArg(scope, "scope", unreservedChars);
+        }
+      }
+      // IP-literal validation is complicated so we delegate it to Guava. We use this particular
+      // method of InetAddresses because it doesn't try to match interfaces on the local machine.
+      // (The validity of a URI should be the same no matter which machine does the parsing.)
+      // TODO(jdcormie): IPFuture
+      if (!InetAddresses.isUriInetAddress(host)) {
+        // Must be a "registered name".
+        checkPercentEncodedArg(host, "host", regNameChars);
+      }
+      this.host = host;
+      return this;
+    }
+
+    /**
+     * Specifies the "port" component of the new URI, e.g. "8080".
+     *
+     * <p>The port can be any non-negative integer. A negative value represents "no port".
+     *
+     * <p>This field is optional.
+     *
+     * @param port the new "port" component, or -1 to clear this field
+     * @return this, for fluent building
+     */
+    @CanIgnoreReturnValue
+    public Builder setPort(int port) {
+      this.port = port < 0 ? null : Integer.toString(port);
+      return this;
+    }
+
+    @CanIgnoreReturnValue
+    Builder setRawPort(String port) {
+      try {
+        Integer.parseInt(port); // Result unused.
+      } catch (NumberFormatException e) {
+        throw new IllegalArgumentException("Invalid port", e);
+      }
+      this.port = port;
+      return this;
+    }
+
+    /** Builds a new instance of {@link Uri} as specified by the setters. */
+    public Uri build() {
+      checkState(scheme != null, "Missing required scheme.");
+      if (host == null) {
+        checkState(port == null, "Cannot set port without host.");
+        checkState(userInfo == null, "Cannot set userInfo without host.");
+      }
+      return new Uri(this);
+    }
+  }
+
+  /**
+   * Decodes a string of characters in the range [U+0000, U+007F] to bytes.
+   *
+   * <p>Each percent-encoded sequence (e.g. "%F0" or "%2a", as defined by RFC 3986 2.1) is decoded
+   * to the octet it encodes. Other characters are decoded to their code point's single byte value.
+   * A literal % character must be encoded as %25.
+   *
+   * @throws IllegalArgumentException if 's' contains characters out of range or invalid percent
+   *     encoding sequences.
+   */
+  public static ByteBuffer percentDecode(CharSequence s) {
+    // This is large enough because each input character needs *at most* one byte of output.
+    ByteBuffer outBuf = ByteBuffer.allocate(s.length());
+    percentDecode(s, "input", null, outBuf);
+    outBuf.flip();
+    return outBuf;
+  }
+
+  private static void percentDecode(
+      CharSequence s, String what, BitSet allowedChars, ByteBuffer outBuf) {
+    for (int i = 0; i < s.length(); i++) {
+      char c = s.charAt(i);
+      if (c == '%') {
+        if (i + 2 >= s.length()) {
+          throw new IllegalArgumentException(
+              "Invalid percent-encoding at index " + i + " of " + what + ": " + s);
+        }
+        int h1 = Character.digit(s.charAt(i + 1), 16);
+        int h2 = Character.digit(s.charAt(i + 2), 16);
+        if (h1 == -1 || h2 == -1) {
+          throw new IllegalArgumentException(
+              "Invalid hex digit in " + what + " at index " + i + " of: " + s);
+        }
+        if (outBuf != null) {
+          outBuf.put((byte) (h1 << 4 | h2));
+        }
+        i += 2;
+      } else if (allowedChars == null || allowedChars.get(c)) {
+        if (outBuf != null) {
+          outBuf.put((byte) c);
+        }
+      } else {
+        throw new IllegalArgumentException("Invalid character in " + what + " at index " + i);
+      }
+    }
+  }
+
+  @Nullable
+  private static String percentDecodeAssumedUtf8(@Nullable String s) {
+    if (s == null || s.indexOf('%') == -1) {
+      return s;
+    }
+
+    ByteBuffer utf8Bytes = percentDecode(s);
+    try {
+      return StandardCharsets.UTF_8
+          .newDecoder()
+          .onMalformedInput(CodingErrorAction.REPLACE)
+          .onUnmappableCharacter(CodingErrorAction.REPLACE)
+          .decode(utf8Bytes)
+          .toString();
+    } catch (CharacterCodingException e) {
+      throw new VerifyException(e); // Should not happen in REPLACE mode.
+    }
+  }
+
+  @Nullable
+  private static String percentEncode(String s, BitSet allowedCodePoints) {
+    if (s == null) {
+      return null;
+    }
+    CharsetEncoder encoder =
+        StandardCharsets.UTF_8
+            .newEncoder()
+            .onMalformedInput(CodingErrorAction.REPORT)
+            .onUnmappableCharacter(CodingErrorAction.REPORT);
+    ByteBuffer utf8Bytes;
+    try {
+      utf8Bytes = encoder.encode(CharBuffer.wrap(s));
+    } catch (MalformedInputException e) {
+      throw new IllegalArgumentException("Malformed input", e); // Must be a broken surrogate pair.
+    } catch (CharacterCodingException e) {
+      throw new VerifyException(e); // Should not happen when encoding to UTF-8.
+    }
+
+    StringBuilder sb = new StringBuilder();
+    while (utf8Bytes.hasRemaining()) {
+      int b = 0xff & utf8Bytes.get();
+      if (allowedCodePoints.get(b)) {
+        sb.append((char) b);
+      } else {
+        sb.append('%');
+        sb.append(hexDigitsByVal[(b & 0xF0) >> 4]);
+        sb.append(hexDigitsByVal[b & 0x0F]);
+      }
+    }
+    return sb.toString();
+  }
+
+  private static void checkPercentEncodedArg(String s, String what, BitSet allowedChars) {
+    percentDecode(s, what, allowedChars, null);
+  }
+
+  // See UriTest for how these were computed from the ABNF constants in RFC 3986.
+  static final BitSet digitChars = BitSet.valueOf(new long[] {0x3ff000000000000L});
+  static final BitSet alphaChars = BitSet.valueOf(new long[] {0L, 0x7fffffe07fffffeL});
+  // scheme        = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
+  static final BitSet schemeChars =
+      BitSet.valueOf(new long[] {0x3ff680000000000L, 0x7fffffe07fffffeL});
+  // unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+  static final BitSet unreservedChars =
+      BitSet.valueOf(new long[] {0x3ff600000000000L, 0x47fffffe87fffffeL});
+  // gen-delims    = ":" / "/" / "?" / "#" / "[" / "]" / "@"
+  static final BitSet genDelimsChars =
+      BitSet.valueOf(new long[] {0x8400800800000000L, 0x28000001L});
+  // sub-delims    = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+  static final BitSet subDelimsChars = BitSet.valueOf(new long[] {0x28001fd200000000L});
+  // reserved      = gen-delims / sub-delims
+  static final BitSet reservedChars = BitSet.valueOf(new long[] {0xac009fda00000000L, 0x28000001L});
+  // reg-name      = *( unreserved / pct-encoded / sub-delims )
+  static final BitSet regNameChars =
+      BitSet.valueOf(new long[] {0x2bff7fd200000000L, 0x47fffffe87fffffeL});
+  // userinfo      = *( unreserved / pct-encoded / sub-delims / ":" )
+  static final BitSet userInfoChars =
+      BitSet.valueOf(new long[] {0x2fff7fd200000000L, 0x47fffffe87fffffeL});
+  // pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
+  static final BitSet pChars =
+      BitSet.valueOf(new long[] {0x2fff7fd200000000L, 0x47fffffe87ffffffL});
+  static final BitSet pCharsAndSlash =
+      BitSet.valueOf(new long[] {0x2fffffd200000000L, 0x47fffffe87ffffffL});
+  //  query         = *( pchar / "/" / "?" )
+  static final BitSet queryChars =
+      BitSet.valueOf(new long[] {0xafffffd200000000L, 0x47fffffe87ffffffL});
+  // fragment      = *( pchar / "/" / "?" )
+  static final BitSet fragmentChars = queryChars;
+
+  private static final char[] hexDigitsByVal = "0123456789ABCDEF".toCharArray();
+}
diff --git a/api/src/main/java/io/grpc/package-info.java b/api/src/main/java/io/grpc/package-info.java
new file mode 100644
index 00000000000..8663d75cc6b
--- /dev/null
+++ b/api/src/main/java/io/grpc/package-info.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * The gRPC core public API.
+ *
+ * <p>gRPC is based on a client-server model of remote procedure calls. A client creates a channel
+ * which is connected to a server. RPCs are initiated from the client and sent to the server which
+ * then responds back to the client. When the client and server are done sending messages, they half
+ * close their respective connections. The RPC is complete as soon as the server closes.
+ *
+ * <p>To send an RPC, first create a {@link io.grpc.Channel} using {@link
+ * io.grpc.ManagedChannelBuilder#forTarget}. When using auto generate Protobuf stubs, the stub class
+ * will have constructors for wrapping the channel. These include {@code newBlockingStub}, {@code
+ * newStub}, and {@code newFutureStub} which you can use based on your design. The stub is the
+ * primary way a client interacts with a server.
+ *
+ * <p>To receive RPCs, create a {@link io.grpc.Server} using {@link io.grpc.ServerBuilder#forPort}.
+ * The Protobuf stub will contain an abstract class called AbstractFoo, where Foo is the name of
+ * your service. Extend this class, and pass an instance of it to {@link
+ * io.grpc.ServerBuilder#addService}. Once your server is built, call {@link io.grpc.Server#start}
+ * to begin accepting RPCs.
+ *
+ * <p>Both Clients and Servers should use a custom {@link java.util.concurrent.Executor}. The gRPC
+ * runtime includes a default executor that eases testing and examples, but is not ideal for use in
+ * a production environment. See the associated documentation in the respective builders.
+ *
+ * <p>Clients and Servers can also be shutdown gracefully using the {@code shutdown} method. The API
+ * to conduct an orderly shutdown is modeled from the {@link java.util.concurrent.ExecutorService}.
+ *
+ * <p>gRPC also includes support for more advanced features, such as name resolution, load
+ * balancing, bidirectional streaming, health checking, and more. See the relative methods in the
+ * client and server builders.
+ *
+ * <p>Development of gRPC is done primary on Github at <a
+ * href="https://github.com/grpc/grpc-java">https://github.com/grpc/grpc-java</a>, where the gRPC
+ * team welcomes contributions and bug reports. There is also a mailing list at <a
+ * href="https://groups.google.com/forum/#!forum/grpc-io">grpc-io</a> if you have questions about
+ * gRPC.
+ */
+package io.grpc;
diff --git a/api/src/test/java/io/grpc/AttributesTest.java b/api/src/test/java/io/grpc/AttributesTest.java
new file mode 100644
index 00000000000..3d981e0f69c
--- /dev/null
+++ b/api/src/test/java/io/grpc/AttributesTest.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2016 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link Attributes}. */
+@RunWith(JUnit4.class)
+public class AttributesTest {
+  private static final Attributes.Key<String> YOLO_KEY = Attributes.Key.create("yolo");
+
+  @Test
+  public void buildAttributes() {
+    Attributes attrs = Attributes.newBuilder().set(YOLO_KEY, "To be, or not to be?").build();
+    assertSame("To be, or not to be?", attrs.get(YOLO_KEY));
+    assertThat(attrs.keysForTest()).hasSize(1);
+  }
+
+  @Test
+  public void duplicates() {
+    Attributes attrs = Attributes.newBuilder()
+        .set(YOLO_KEY, "To be?")
+        .set(YOLO_KEY, "Or not to be?")
+        .set(Attributes.Key.create("yolo"), "I'm not a duplicate")
+        .build();
+    assertThat(attrs.get(YOLO_KEY)).isEqualTo("Or not to be?");
+    assertThat(attrs.keysForTest()).hasSize(2);
+  }
+
+  @Test
+  public void toBuilder() {
+    Attributes attrs = Attributes.newBuilder()
+        .set(YOLO_KEY, "To be?")
+        .build()
+        .toBuilder()
+        .set(YOLO_KEY, "Or not to be?")
+        .set(Attributes.Key.create("yolo"), "I'm not a duplicate")
+        .build();
+    assertThat(attrs.get(YOLO_KEY)).isEqualTo("Or not to be?");
+    assertThat(attrs.keysForTest()).hasSize(2);
+  }
+
+  @Test
+  public void empty() {
+    assertThat(Attributes.EMPTY.keysForTest()).isEmpty();
+  }
+
+  @Test
+  public void valueEquality() {
+    class EqualObject {
+      @Override public boolean equals(Object o) {
+        return o instanceof EqualObject;
+      }
+
+      @Override public int hashCode() {
+        return 42;
+      }
+    }
+
+    Attributes.Key<EqualObject> key = Attributes.Key.create("ints");
+    EqualObject v1 = new EqualObject();
+    EqualObject v2 = new EqualObject();
+
+    assertNotSame(v1, v2);
+    assertEquals(v1, v2);
+
+    Attributes attr1 = Attributes.newBuilder().set(key, v1).build();
+    Attributes attr2 = Attributes.newBuilder().set(key, v2).build();
+
+    assertEquals(attr1, attr2);
+    assertEquals(attr1.hashCode(), attr2.hashCode());
+  }
+
+  @Test
+  public void discard_baseAttributes() {
+    Attributes attrs = Attributes.newBuilder().set(YOLO_KEY, "value").build();
+
+    Attributes newAttrs = attrs.toBuilder().discard(YOLO_KEY).build();
+    assertNull(newAttrs.get(YOLO_KEY));
+    assertThat(newAttrs.keysForTest()).doesNotContain(YOLO_KEY);
+  }
+
+  @Test
+  public void discard_noBase() {
+    Attributes.Builder attrs = Attributes.newBuilder().set(YOLO_KEY, "value");
+
+    Attributes newAttrs = attrs.discard(YOLO_KEY).build();
+    assertNull(newAttrs.get(YOLO_KEY));
+    assertThat(newAttrs.keysForTest()).doesNotContain(YOLO_KEY);
+  }
+
+  @Test
+  public void discard_baseAttributesAndBuilder() {
+    Attributes attrs = Attributes.newBuilder().set(YOLO_KEY, "value").build();
+
+    Attributes.Builder attrsBuilder = attrs.toBuilder().set(YOLO_KEY, "other value");
+    Attributes newAttrs = attrsBuilder.discard(YOLO_KEY).build();
+    assertNull(newAttrs.get(YOLO_KEY));
+    assertThat(newAttrs.keysForTest()).doesNotContain(YOLO_KEY);
+  }
+
+  @Test
+  public void discard_empty() {
+    Attributes newAttrs = Attributes.EMPTY.toBuilder().discard(YOLO_KEY).build();
+    
+    assertNull(newAttrs.get(YOLO_KEY));
+    assertThat(newAttrs.keysForTest()).doesNotContain(YOLO_KEY);
+  }
+}
diff --git a/api/src/test/java/io/grpc/CallOptionsTest.java b/api/src/test/java/io/grpc/CallOptionsTest.java
new file mode 100644
index 00000000000..65fb7ff3bf2
--- /dev/null
+++ b/api/src/test/java/io/grpc/CallOptionsTest.java
@@ -0,0 +1,302 @@
+/*
+ * Copyright 2015 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;
+
+import static com.google.common.truth.Truth.assertAbout;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
+import static io.grpc.testing.DeadlineSubject.deadline;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.MINUTES;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+import com.google.common.base.Objects;
+import io.grpc.ClientStreamTracer.StreamInfo;
+import io.grpc.internal.SerializingExecutor;
+import java.time.Duration;
+import java.util.concurrent.Executor;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link CallOptions}. */
+@RunWith(JUnit4.class)
+public class CallOptionsTest {
+  private static final CallOptions.Key<String> OPTION_1
+      = CallOptions.Key.createWithDefault("option1", "default");
+  private static final CallOptions.Key<String> OPTION_2
+      = CallOptions.Key.createWithDefault("option2", "default");
+  private final String sampleAuthority = "authority";
+  private final String sampleCompressor = "compressor";
+  private final Deadline.Ticker ticker = new FakeTicker();
+  private final Deadline sampleDeadline = Deadline.after(1, NANOSECONDS, ticker);
+  private final CallCredentials sampleCreds = mock(CallCredentials.class);
+  private final ClientStreamTracer.Factory tracerFactory1 = new FakeTracerFactory("tracerFactory1");
+  private final ClientStreamTracer.Factory tracerFactory2 = new FakeTracerFactory("tracerFactory2");
+  private final CallOptions allSet = CallOptions.DEFAULT
+      .withAuthority(sampleAuthority)
+      .withDeadline(sampleDeadline)
+      .withCallCredentials(sampleCreds)
+      .withCompression(sampleCompressor)
+      .withWaitForReady()
+      .withExecutor(directExecutor())
+      .withOption(OPTION_1, "value1")
+      .withStreamTracerFactory(tracerFactory1)
+      .withOption(OPTION_2, "value2")
+      .withStreamTracerFactory(tracerFactory2);
+
+  @Test
+  public void defaultsAreAllNull() {
+    assertThat(CallOptions.DEFAULT.getDeadline()).isNull();
+    assertThat(CallOptions.DEFAULT.getAuthority()).isNull();
+    assertThat(CallOptions.DEFAULT.getExecutor()).isNull();
+    assertThat(CallOptions.DEFAULT.getCredentials()).isNull();
+    assertThat(CallOptions.DEFAULT.getCompressor()).isNull();
+    assertThat(CallOptions.DEFAULT.isWaitForReady()).isFalse();
+    assertThat(CallOptions.DEFAULT.getStreamTracerFactories()).isEmpty();
+  }
+
+  @Test
+  public void withAndWithoutWaitForReady() {
+    assertThat(CallOptions.DEFAULT.withWaitForReady().isWaitForReady()).isTrue();
+    assertThat(CallOptions.DEFAULT.withWaitForReady().withoutWaitForReady().isWaitForReady())
+        .isFalse();
+  }
+
+  @Test
+  public void withOnReadyThreshold() {
+    int onReadyThreshold = 1024;
+    CallOptions callOptions = CallOptions.DEFAULT.withOnReadyThreshold(onReadyThreshold);
+    callOptions = callOptions.withWaitForReady();
+    assertThat(callOptions.getOnReadyThreshold()).isEqualTo(onReadyThreshold);
+    callOptions = callOptions.clearOnReadyThreshold();
+    assertThat(callOptions.getOnReadyThreshold()).isNull();
+  }
+
+  @Test
+  public void allWiths() {
+    assertThat(allSet.getAuthority()).isSameInstanceAs(sampleAuthority);
+    assertThat(allSet.getDeadline()).isSameInstanceAs(sampleDeadline);
+    assertThat(allSet.getCredentials()).isSameInstanceAs(sampleCreds);
+    assertThat(allSet.getCompressor()).isSameInstanceAs(sampleCompressor);
+    assertThat(allSet.getExecutor()).isSameInstanceAs(directExecutor());
+    assertThat(allSet.getOption(OPTION_1)).isSameInstanceAs("value1");
+    assertThat(allSet.getOption(OPTION_2)).isSameInstanceAs("value2");
+    assertThat(allSet.isWaitForReady()).isTrue();
+  }
+
+  @Test
+  public void noStrayModifications() {
+    assertThat(equal(allSet, allSet.withAuthority("blah").withAuthority(sampleAuthority)))
+        .isTrue();
+    assertThat(
+        equal(allSet,
+            allSet.withDeadline(Deadline.after(314, NANOSECONDS)).withDeadline(sampleDeadline)))
+        .isTrue();
+    assertThat(
+        equal(allSet,
+            allSet.withCallCredentials(mock(CallCredentials.class))
+            .withCallCredentials(sampleCreds)))
+        .isTrue();
+  }
+
+  @Test
+  public void mutation() {
+    Deadline deadline = Deadline.after(10, SECONDS);
+    CallOptions options1 = CallOptions.DEFAULT.withDeadline(deadline);
+    assertThat(CallOptions.DEFAULT.getDeadline()).isNull();
+    assertThat(deadline).isSameInstanceAs(options1.getDeadline());
+
+    CallOptions options2 = options1.withDeadline(null);
+    assertThat(deadline).isSameInstanceAs(options1.getDeadline());
+    assertThat(options2.getDeadline()).isNull();
+  }
+
+  @Test
+  public void mutateExecutor() {
+    Executor executor = directExecutor();
+    CallOptions options1 = CallOptions.DEFAULT.withExecutor(executor);
+    assertThat(CallOptions.DEFAULT.getExecutor()).isNull();
+    assertThat(executor).isSameInstanceAs(options1.getExecutor());
+
+    CallOptions options2 = options1.withExecutor(null);
+    assertThat(executor).isSameInstanceAs(options1.getExecutor());
+    assertThat(options2.getExecutor()).isNull();
+  }
+
+  @Test
+  public void withDeadlineAfter() {
+    Deadline actual = CallOptions.DEFAULT.withDeadlineAfter(1, MINUTES).getDeadline();
+    Deadline expected = Deadline.after(1, MINUTES);
+
+    assertAbout(deadline()).that(actual).isWithin(10, MILLISECONDS).of(expected);
+  }
+
+  @Test
+  @IgnoreJRERequirement
+  public void withDeadlineAfterDuration() {
+    Deadline actual = CallOptions.DEFAULT.withDeadlineAfter(Duration.ofMinutes(1L)).getDeadline();
+    Deadline expected = Deadline.after(1, MINUTES);
+
+    assertAbout(deadline()).that(actual).isWithin(10, MILLISECONDS).of(expected);
+  }
+
+  @Test
+  public void toStringMatches_noDeadline_default() {
+    String actual = allSet
+        .withDeadline(null)
+        .withExecutor(new SerializingExecutor(directExecutor()))
+        .withCallCredentials(null)
+        .withMaxInboundMessageSize(44)
+        .withMaxOutboundMessageSize(55)
+        .withOnReadyThreshold(1024)
+        .toString();
+
+    assertThat(actual).contains("deadline=null");
+    assertThat(actual).contains("authority=authority");
+    assertThat(actual).contains("callCredentials=null");
+    assertThat(actual).contains("executor=class io.grpc.internal.SerializingExecutor");
+    assertThat(actual).contains("compressorName=compressor");
+    assertThat(actual).contains("customOptions=[[option1, value1], [option2, value2]]");
+    assertThat(actual).contains("waitForReady=true");
+    assertThat(actual).contains("maxInboundMessageSize=44");
+    assertThat(actual).contains("maxOutboundMessageSize=55");
+    assertThat(actual).contains("onReadyThreshold=1024");
+    assertThat(actual).contains("streamTracerFactories=[tracerFactory1, tracerFactory2]");
+  }
+
+  @Test
+  public void toStringMatches_noDeadline() {
+    String actual = CallOptions.DEFAULT.toString();
+    assertThat(actual).contains("deadline=null");
+  }
+
+  @Test
+  public void toStringMatches_withDeadline() {
+    assertThat(allSet.toString()).contains("0.000000001s from now");
+  }
+
+  @Test
+  public void withCustomOptionDefault() {
+    CallOptions opts = CallOptions.DEFAULT;
+    assertThat(opts.getOption(OPTION_1)).isEqualTo("default");
+  }
+
+  @Test
+  public void withCustomOption() {
+    CallOptions opts = CallOptions.DEFAULT.withOption(OPTION_1, "v1");
+    assertThat(opts.getOption(OPTION_1)).isEqualTo("v1");
+  }
+
+  @Test
+  public void withCustomOptionLastOneWins() {
+    CallOptions opts = CallOptions.DEFAULT.withOption(OPTION_1, "v1").withOption(OPTION_1, "v2");
+    assertThat(opts.getOption(OPTION_1)).isEqualTo("v2");
+  }
+
+  @Test
+  public void withMultipleCustomOption() {
+    CallOptions opts = CallOptions.DEFAULT.withOption(OPTION_1, "v1").withOption(OPTION_2, "v2");
+    assertThat(opts.getOption(OPTION_1)).isEqualTo("v1");
+    assertThat(opts.getOption(OPTION_2)).isEqualTo("v2");
+  }
+
+  @Test
+  public void withOptionDoesNotMutateOriginal() {
+    CallOptions defaultOpt = CallOptions.DEFAULT;
+    CallOptions opt1 = defaultOpt.withOption(OPTION_1, "v1");
+    CallOptions opt2 = opt1.withOption(OPTION_1, "v2");
+
+    assertThat(defaultOpt.getOption(OPTION_1)).isEqualTo("default");
+    assertThat(opt1.getOption(OPTION_1)).isEqualTo("v1");
+    assertThat(opt2.getOption(OPTION_1)).isEqualTo("v2");
+  }
+
+  @Test
+  public void withStreamTracerFactory() {
+    CallOptions opts1 = CallOptions.DEFAULT.withStreamTracerFactory(tracerFactory1);
+    CallOptions opts2 = opts1.withStreamTracerFactory(tracerFactory2);
+    CallOptions opts3 = opts2.withStreamTracerFactory(tracerFactory2);
+
+    assertThat(opts1.getStreamTracerFactories()).containsExactly(tracerFactory1);
+    assertThat(opts2.getStreamTracerFactories()).containsExactly(tracerFactory1, tracerFactory2)
+        .inOrder();
+    assertThat(opts3.getStreamTracerFactories())
+        .containsExactly(tracerFactory1, tracerFactory2, tracerFactory2).inOrder();
+
+    try {
+      CallOptions.DEFAULT.getStreamTracerFactories().add(tracerFactory1);
+      fail("Should have thrown. The list should be unmodifiable.");
+    } catch (UnsupportedOperationException e) {
+      // Expected
+    }
+
+    try {
+      opts2.getStreamTracerFactories().clear();
+      fail("Should have thrown. The list should be unmodifiable.");
+    } catch (UnsupportedOperationException e) {
+      // Expected
+    }
+  }
+
+  @Test
+  public void getWaitForReady() {
+    assertNull(CallOptions.DEFAULT.getWaitForReady());
+    assertSame(CallOptions.DEFAULT.withWaitForReady().getWaitForReady(), Boolean.TRUE);
+    assertSame(CallOptions.DEFAULT.withoutWaitForReady().getWaitForReady(), Boolean.FALSE);
+  }
+
+  // Only used in noStrayModifications()
+  // TODO(carl-mastrangelo): consider making a CallOptionsSubject for Truth.
+  private static boolean equal(CallOptions o1, CallOptions o2) {
+    return Objects.equal(o1.getDeadline(), o2.getDeadline())
+        && Objects.equal(o1.getAuthority(), o2.getAuthority())
+        && Objects.equal(o1.getCredentials(), o2.getCredentials());
+  }
+
+  private static class FakeTicker extends Deadline.Ticker {
+    private long time;
+
+    @Override
+    public long nanoTime() {
+      return time;
+    }
+  }
+
+  private static class FakeTracerFactory extends ClientStreamTracer.Factory {
+    final String name;
+
+    FakeTracerFactory(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+      return new ClientStreamTracer() {};
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
+}
diff --git a/api/src/test/java/io/grpc/ChoiceChannelCredentialsTest.java b/api/src/test/java/io/grpc/ChoiceChannelCredentialsTest.java
new file mode 100644
index 00000000000..2b126b5d37d
--- /dev/null
+++ b/api/src/test/java/io/grpc/ChoiceChannelCredentialsTest.java
@@ -0,0 +1,51 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link ChoiceChannelCredentials}. */
+@RunWith(JUnit4.class)
+public class ChoiceChannelCredentialsTest {
+  @Test
+  public void withoutBearTokenGivesChoiceOfCredsWithoutToken() {
+    final ChannelCredentials creds1WithoutToken = mock(ChannelCredentials.class);
+    ChannelCredentials creds1 = new ChannelCredentials() {
+      @Override
+      public ChannelCredentials withoutBearerTokens() {
+        return creds1WithoutToken;
+      }
+    };
+    final ChannelCredentials creds2WithoutToken = mock(ChannelCredentials.class);
+    ChannelCredentials creds2 = new ChannelCredentials() {
+      @Override
+      public ChannelCredentials withoutBearerTokens() {
+        return creds2WithoutToken;
+      }
+    };
+    ChannelCredentials choice = ChoiceChannelCredentials.create(creds1, creds2);
+    ChannelCredentials choiceWithouToken = choice.withoutBearerTokens();
+    assertThat(choiceWithouToken).isInstanceOf(ChoiceChannelCredentials.class);
+    assertThat(((ChoiceChannelCredentials) choiceWithouToken).getCredentialsList())
+        .containsExactly(creds1WithoutToken, creds2WithoutToken);
+  }
+}
diff --git a/core/src/test/java/io/grpc/ClientInterceptorsTest.java b/api/src/test/java/io/grpc/ClientInterceptorsTest.java
similarity index 82%
rename from core/src/test/java/io/grpc/ClientInterceptorsTest.java
rename to api/src/test/java/io/grpc/ClientInterceptorsTest.java
index 636524d43d9..555e9405764 100644
--- a/core/src/test/java/io/grpc/ClientInterceptorsTest.java
+++ b/api/src/test/java/io/grpc/ClientInterceptorsTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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;
@@ -38,11 +23,11 @@
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Matchers.same;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
@@ -56,18 +41,23 @@
 import java.util.Arrays;
 import java.util.List;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /** Unit tests for {@link ClientInterceptors}. */
 @RunWith(JUnit4.class)
 public class ClientInterceptorsTest {
 
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
   @Mock
   private Channel channel;
 
@@ -79,9 +69,8 @@ public class ClientInterceptorsTest {
    * Sets up mocks.
    */
   @Before public void setUp() {
-    MockitoAnnotations.initMocks(this);
     when(channel.newCall(
-        Mockito.<MethodDescriptor<String, Integer>>any(), any(CallOptions.class)))
+            ArgumentMatchers.<MethodDescriptor<String, Integer>>any(), any(CallOptions.class)))
         .thenReturn(call);
   }
 
@@ -107,19 +96,21 @@ public void noop() {
 
   @Test
   public void channelAndInterceptorCalled() {
-    ClientInterceptor interceptor = spy(new NoopInterceptor());
+    ClientInterceptor interceptor =
+        mock(ClientInterceptor.class, delegatesTo(new NoopInterceptor()));
     Channel intercepted = ClientInterceptors.intercept(channel, interceptor);
     CallOptions callOptions = CallOptions.DEFAULT;
     // First call
     assertSame(call, intercepted.newCall(method, callOptions));
     verify(channel).newCall(same(method), same(callOptions));
-    verify(interceptor).interceptCall(same(method), same(callOptions), Mockito.<Channel>any());
+    verify(interceptor)
+        .interceptCall(same(method), same(callOptions), ArgumentMatchers.<Channel>any());
     verifyNoMoreInteractions(channel, interceptor);
     // Second call
     assertSame(call, intercepted.newCall(method, callOptions));
     verify(channel, times(2)).newCall(same(method), same(callOptions));
     verify(interceptor, times(2))
-        .interceptCall(same(method), same(callOptions), Mockito.<Channel>any());
+        .interceptCall(same(method), same(callOptions), ArgumentMatchers.<Channel>any());
     verifyNoMoreInteractions(channel, interceptor);
   }
 
@@ -144,7 +135,7 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
 
   @Test
   public void ordered() {
-    final List<String> order = new ArrayList<String>();
+    final List<String> order = new ArrayList<>();
     channel = new Channel() {
       @SuppressWarnings("unchecked")
       @Override
@@ -186,7 +177,7 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
 
   @Test
   public void orderedForward() {
-    final List<String> order = new ArrayList<String>();
+    final List<String> order = new ArrayList<>();
     channel = new Channel() {
       @SuppressWarnings("unchecked")
       @Override
@@ -231,19 +222,20 @@ public void callOptions() {
     final CallOptions initialCallOptions = CallOptions.DEFAULT.withDeadlineAfter(100, NANOSECONDS);
     final CallOptions newCallOptions = initialCallOptions.withDeadlineAfter(300, NANOSECONDS);
     assertNotSame(initialCallOptions, newCallOptions);
-    ClientInterceptor interceptor = spy(new ClientInterceptor() {
-      @Override
-      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
-          MethodDescriptor<ReqT, RespT> method,
-          CallOptions callOptions,
-          Channel next) {
-        return next.newCall(method, newCallOptions);
-      }
-    });
+    ClientInterceptor interceptor =
+        mock(ClientInterceptor.class, delegatesTo(new ClientInterceptor() {
+          @Override
+          public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+              MethodDescriptor<ReqT, RespT> method,
+              CallOptions callOptions,
+              Channel next) {
+            return next.newCall(method, newCallOptions);
+          }
+        }));
     Channel intercepted = ClientInterceptors.intercept(channel, interceptor);
     intercepted.newCall(method, initialCallOptions);
-    verify(interceptor).interceptCall(
-        same(method), same(initialCallOptions), Mockito.<Channel>any());
+    verify(interceptor)
+        .interceptCall(same(method), same(initialCallOptions), ArgumentMatchers.<Channel>any());
     verify(channel).newCall(same(method), same(newCallOptions));
   }
 
@@ -280,7 +272,7 @@ public void start(ClientCall.Listener<RespT> responseListener, Metadata headers)
 
   @Test
   public void examineInboundHeaders() {
-    final List<Metadata> examinedHeaders = new ArrayList<Metadata>();
+    final List<Metadata> examinedHeaders = new ArrayList<>();
     ClientInterceptor interceptor = new ClientInterceptor() {
       @Override
       public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
@@ -337,7 +329,7 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
     assertSame(listener, call.listener);
     assertSame(headers, call.headers);
     interceptedCall.sendMessage(null /*request*/);
-    assertThat(call.messages).containsExactly((Void) null /*request*/);
+    assertThat(call.messages).containsExactly((String) null);
     interceptedCall.halfClose();
     assertTrue(call.halfClosed);
     interceptedCall.request(1);
@@ -408,10 +400,11 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
 
   @Test
   public void customOptionAccessible() {
-    CallOptions.Key<String> customOption = CallOptions.Key.of("custom", null);
+    CallOptions.Key<String> customOption = CallOptions.Key.create("custom");
     CallOptions callOptions = CallOptions.DEFAULT.withOption(customOption, "value");
     ArgumentCaptor<CallOptions> passedOptions = ArgumentCaptor.forClass(CallOptions.class);
-    ClientInterceptor interceptor = spy(new NoopInterceptor());
+    ClientInterceptor interceptor =
+        mock(ClientInterceptor.class, delegatesTo(new NoopInterceptor()));
 
     Channel intercepted = ClientInterceptors.intercept(channel, interceptor);
 
@@ -435,11 +428,9 @@ private static class BaseClientCall extends ClientCall<String, Integer> {
     private boolean done;
     private ClientCall.Listener<Integer> listener;
     private Metadata headers;
-    private List<Integer> requests = new ArrayList<Integer>();
-    private List<String> messages = new ArrayList<String>();
+    private List<Integer> requests = new ArrayList<>();
+    private List<String> messages = new ArrayList<>();
     private boolean halfClosed;
-    private Throwable cancelCause;
-    private String cancelMessage;
 
     @Override
     public void start(ClientCall.Listener<Integer> listener, Metadata headers) {
@@ -459,8 +450,6 @@ public void request(int numMessages) {
     @Override
     public void cancel(String message, Throwable cause) {
       checkNotDone();
-      this.cancelMessage = message;
-      this.cancelCause = cause;
     }
 
     @Override
diff --git a/api/src/test/java/io/grpc/ClientStreamTracerTest.java b/api/src/test/java/io/grpc/ClientStreamTracerTest.java
new file mode 100644
index 00000000000..5ddee77f5c0
--- /dev/null
+++ b/api/src/test/java/io/grpc/ClientStreamTracerTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2019, gRPC Authors All rights reserved.
+ *
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.util.concurrent.TimeUnit.MINUTES;
+
+import io.grpc.ClientStreamTracer.StreamInfo;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for the embedded classes in {@link ClientStreamTracer}. */
+@RunWith(JUnit4.class)
+public class ClientStreamTracerTest {
+  private final CallOptions callOptions = CallOptions.DEFAULT.withDeadlineAfter(1, MINUTES);
+
+  @Test
+  public void streamInfo_empty() {
+    StreamInfo info = StreamInfo.newBuilder().build();
+    assertThat(info.getCallOptions()).isSameInstanceAs(CallOptions.DEFAULT);
+  }
+
+  @Test
+  public void streamInfo_withInfo() {
+    StreamInfo info = StreamInfo.newBuilder().setCallOptions(callOptions).build();
+    assertThat(info.getCallOptions()).isSameInstanceAs(callOptions);
+  }
+
+  @Test
+  public void streamInfo_noEquality() {
+    StreamInfo info1 = StreamInfo.newBuilder().setCallOptions(callOptions).build();
+    StreamInfo info2 = StreamInfo.newBuilder().setCallOptions(callOptions).build();
+
+    assertThat(info1).isNotSameInstanceAs(info2);
+    assertThat(info1).isNotEqualTo(info2);
+  }
+
+  @Test
+  public void streamInfo_toBuilder() {
+    StreamInfo info1 = StreamInfo.newBuilder()
+        .setCallOptions(callOptions).build();
+    StreamInfo info2 = info1.toBuilder().build();
+    assertThat(info2.getCallOptions()).isSameInstanceAs(callOptions);
+  }
+}
diff --git a/api/src/test/java/io/grpc/CompositeCallCredentialsTest.java b/api/src/test/java/io/grpc/CompositeCallCredentialsTest.java
new file mode 100644
index 00000000000..e4647a0b38f
--- /dev/null
+++ b/api/src/test/java/io/grpc/CompositeCallCredentialsTest.java
@@ -0,0 +1,113 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import java.util.concurrent.Executor;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class CompositeCallCredentialsTest {
+  private static final Metadata.Key<String> METADATA_KEY =
+      Metadata.Key.of("key", Metadata.ASCII_STRING_MARSHALLER);
+
+  private CompositeCallCredentials callCredentials;
+  private CallCredentials.RequestInfo requestInfo;
+  private Executor appExecutor;
+  private FakeMetadataApplier applier = new FakeMetadataApplier();
+
+  @Test
+  public void applyRequestMetadata_firstFails() {
+    Status failure = Status.UNAVAILABLE.withDescription("expected");
+    callCredentials = new CompositeCallCredentials(
+        new FakeCallCredentials(failure),
+        new FakeCallCredentials(createMetadata(METADATA_KEY, "value2")));
+    callCredentials.applyRequestMetadata(requestInfo, appExecutor, applier);
+    assertThat(applier.status).isSameInstanceAs(failure);
+  }
+
+  @Test
+  public void applyRequestMetadata_secondFails() {
+    Status failure = Status.UNAVAILABLE.withDescription("expected");
+    callCredentials = new CompositeCallCredentials(
+        new FakeCallCredentials(createMetadata(METADATA_KEY, "value1")),
+        new FakeCallCredentials(failure));
+    callCredentials.applyRequestMetadata(requestInfo, appExecutor, applier);
+    assertThat(applier.status).isSameInstanceAs(failure);
+  }
+
+  @Test
+  public void applyRequestMetadata_bothSucceed() {
+    callCredentials = new CompositeCallCredentials(
+        new FakeCallCredentials(createMetadata(METADATA_KEY, "value1")),
+        new FakeCallCredentials(createMetadata(METADATA_KEY, "value2")));
+    callCredentials.applyRequestMetadata(requestInfo, appExecutor, applier);
+    assertThat(applier.headers).isNotNull();
+    assertThat(applier.headers.getAll(METADATA_KEY)).containsExactly("value1", "value2");
+  }
+
+  private static Metadata createMetadata(Metadata.Key<String> key, String value) {
+    Metadata metadata = new Metadata();
+    metadata.put(key, value);
+    return metadata;
+  }
+
+  private static class FakeMetadataApplier extends CallCredentials.MetadataApplier {
+    private Metadata headers;
+    private Status status;
+
+    @Override public void apply(Metadata headers) {
+      assertThat(this.headers).isNull();
+      assertThat(this.status).isNull();
+      this.headers = headers;
+    }
+
+    @Override public void fail(Status status) {
+      assertThat(this.headers).isNull();
+      assertThat(this.status).isNull();
+      this.status = status;
+    }
+  }
+
+  private static class FakeCallCredentials extends CallCredentials {
+    private final Metadata headers;
+    private final Status status;
+
+    public FakeCallCredentials(Metadata headers) {
+      this.headers = headers;
+      this.status = null;
+    }
+
+    public FakeCallCredentials(Status status) {
+      this.headers = null;
+      this.status = status;
+    }
+
+    @Override public void applyRequestMetadata(
+        CallCredentials.RequestInfo requestInfo, Executor appExecutor,
+        CallCredentials.MetadataApplier applier) {
+      if (headers != null) {
+        applier.apply(headers);
+      } else {
+        applier.fail(status);
+      }
+    }
+  }
+}
diff --git a/api/src/test/java/io/grpc/CompositeChannelCredentialsTest.java b/api/src/test/java/io/grpc/CompositeChannelCredentialsTest.java
new file mode 100644
index 00000000000..cf9914b2edb
--- /dev/null
+++ b/api/src/test/java/io/grpc/CompositeChannelCredentialsTest.java
@@ -0,0 +1,41 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link CompositeChannelCredentials}. */
+@RunWith(JUnit4.class)
+public class CompositeChannelCredentialsTest {
+  @Test
+  public void withoutBearTokenGivesCredsWithoutCallCreds() {
+    ChannelCredentials channelChreds = new ChannelCredentials() {
+      @Override
+      public ChannelCredentials withoutBearerTokens() {
+        return this;
+      }
+    };
+    CallCredentials callCreds = mock(CallCredentials.class);
+    ChannelCredentials comp = CompositeChannelCredentials.create(channelChreds, callCreds);
+    assertThat(comp.withoutBearerTokens()).isEqualTo(channelChreds);
+  }
+}
diff --git a/api/src/test/java/io/grpc/ConfiguratorRegistryTest.java b/api/src/test/java/io/grpc/ConfiguratorRegistryTest.java
new file mode 100644
index 00000000000..457d5a36e77
--- /dev/null
+++ b/api/src/test/java/io/grpc/ConfiguratorRegistryTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2022 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.regex.Pattern;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ConfiguratorRegistryTest {
+
+  private final StaticTestingClassLoader classLoader =
+      new StaticTestingClassLoader(
+          getClass().getClassLoader(), Pattern.compile("io\\.grpc\\.[^.]+"));
+
+  @Test
+  public void setConfigurators() throws Exception {
+    Class<?> runnable = classLoader.loadClass(StaticTestingClassLoaderSet.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  @Test
+  public void setGlobalConfigurators_twice() throws Exception {
+    Class<?> runnable = classLoader.loadClass(StaticTestingClassLoaderSetTwice.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  @Test
+  public void getBeforeSet() throws Exception {
+    Class<?> runnable =
+        classLoader.loadClass(
+            StaticTestingClassLoaderGetBeforeSet.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  // UsedReflectively
+  public static final class StaticTestingClassLoaderSet implements Runnable {
+    @Override
+    public void run() {
+      List<Configurator> configurators = Arrays.asList(new NoopConfigurator());
+
+      ConfiguratorRegistry.getDefaultRegistry().setConfigurators(configurators);
+
+      assertThat(ConfiguratorRegistry.getDefaultRegistry().getConfigurators())
+          .isEqualTo(configurators);
+    }
+  }
+
+  public static final class StaticTestingClassLoaderSetTwice implements Runnable {
+    @Override
+    public void run() {
+      ConfiguratorRegistry.getDefaultRegistry()
+          .setConfigurators(Arrays.asList(new NoopConfigurator()));
+      try {
+        ConfiguratorRegistry.getDefaultRegistry()
+            .setConfigurators(Arrays.asList(new NoopConfigurator()));
+        fail("should have failed for calling setConfigurators() again");
+      } catch (IllegalStateException e) {
+        assertThat(e).hasMessageThat().isEqualTo("Configurators are already set");
+      }
+    }
+  }
+
+  public static final class StaticTestingClassLoaderGetBeforeSet implements Runnable {
+    @Override
+    public void run() {
+      assertThat(ConfiguratorRegistry.getDefaultRegistry().getConfigurators()).isEmpty();
+      NoopConfigurator noopConfigurator = new NoopConfigurator();
+      ConfiguratorRegistry.getDefaultRegistry()
+              .setConfigurators(Arrays.asList(noopConfigurator));
+      assertThat(ConfiguratorRegistry.getDefaultRegistry().getConfigurators())
+              .containsExactly(noopConfigurator);
+      assertThat(InternalConfiguratorRegistry.getConfiguratorsCallCountBeforeSet()).isEqualTo(1);
+    }
+  }
+
+  private static class NoopConfigurator implements Configurator {}
+}
diff --git a/api/src/test/java/io/grpc/ConnectivityStateInfoTest.java b/api/src/test/java/io/grpc/ConnectivityStateInfoTest.java
new file mode 100644
index 00000000000..4ba755e7438
--- /dev/null
+++ b/api/src/test/java/io/grpc/ConnectivityStateInfoTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2016 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;
+
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotSame;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ConnectivityStateInfo}. */
+@RunWith(JUnit4.class)
+public class ConnectivityStateInfoTest {
+  @Test
+  public void forNonError() {
+    ConnectivityStateInfo info = ConnectivityStateInfo.forNonError(IDLE);
+    assertEquals(IDLE, info.getState());
+    assertEquals(Status.OK, info.getStatus());
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void forNonErrorInvalid() {
+    ConnectivityStateInfo.forNonError(TRANSIENT_FAILURE);
+  }
+
+  @Test
+  public void forTransientFailure() {
+    ConnectivityStateInfo info = ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE);
+    assertEquals(TRANSIENT_FAILURE, info.getState());
+    assertEquals(Status.UNAVAILABLE, info.getStatus());
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void forTransientFailureInvalid() {
+    ConnectivityStateInfo.forTransientFailure(Status.OK);
+  }
+
+  @Test
+  public void equality() {
+    ConnectivityStateInfo info1 = ConnectivityStateInfo.forNonError(IDLE);
+    ConnectivityStateInfo info2 = ConnectivityStateInfo.forNonError(CONNECTING);
+    ConnectivityStateInfo info3 = ConnectivityStateInfo.forNonError(IDLE);
+    ConnectivityStateInfo info4 = ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE);
+    ConnectivityStateInfo info5 = ConnectivityStateInfo.forTransientFailure(Status.INTERNAL);
+    ConnectivityStateInfo info6 = ConnectivityStateInfo.forTransientFailure(Status.INTERNAL);
+
+    assertEquals(info1, info3);
+    assertNotSame(info1, info3);
+    assertEquals(info1.hashCode(), info3.hashCode());
+    assertEquals(info5, info6);
+    assertEquals(info5.hashCode(), info6.hashCode());
+    assertNotSame(info5, info6);
+
+    assertNotEquals(info1, info2);
+    assertNotEquals(info1, info4);
+    assertNotEquals(info4, info6);
+
+    assertFalse(info1.equals(null));
+    // Extra cast to avoid ErrorProne EqualsIncompatibleType failure
+    assertFalse(((Object) info1).equals(this));
+  }
+}
diff --git a/api/src/test/java/io/grpc/ContextTest.java b/api/src/test/java/io/grpc/ContextTest.java
new file mode 100644
index 00000000000..7f24ff4461d
--- /dev/null
+++ b/api/src/test/java/io/grpc/ContextTest.java
@@ -0,0 +1,1057 @@
+/*
+ * Copyright 2015 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;
+
+import static com.google.common.truth.TruthJUnit.assume;
+import static io.grpc.Context.cancellableAncestor;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import java.util.regex.Pattern;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link Context}.
+ */
+@RunWith(JUnit4.class)
+@SuppressWarnings("CheckReturnValue") // false-positive in test for current ver errorprone plugin
+public class ContextTest {
+
+  private static final Context.Key<String> PET = Context.key("pet");
+  private static final Context.Key<String> FOOD = Context.keyWithDefault("food", "lasagna");
+  private static final Context.Key<String> COLOR = Context.key("color");
+  private static final Context.Key<Object> FAVORITE = Context.key("favorite");
+  private static final Context.Key<Integer> LUCKY = Context.key("lucky");
+
+  private Context listenerNotifedContext;
+  private CountDownLatch deadlineLatch = new CountDownLatch(1);
+  private final Context.CancellationListener cancellationListener =
+      new Context.CancellationListener() {
+        @Override
+        public void cancelled(Context context) {
+          listenerNotifedContext = context;
+          deadlineLatch.countDown();
+        }
+      };
+
+  private Context observed;
+  private final Runnable runner = new Runnable() {
+    @Override
+    public void run() {
+      observed = Context.current();
+    }
+  };
+  private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+
+  @Before
+  public void setUp() {
+    Context.ROOT.attach();
+  }
+
+  @After
+  public void tearDown()  {
+    scheduler.shutdown();
+    assertEquals(Context.ROOT, Context.current());
+  }
+
+  @Test
+  public void defaultContext() throws Exception {
+    final SettableFuture<Context> contextOfNewThread = SettableFuture.create();
+    Context contextOfThisThread = Context.ROOT.withValue(PET, "dog");
+    Context toRestore = contextOfThisThread.attach();
+    new Thread(new Runnable() {
+      @Override
+      public void run() {
+        contextOfNewThread.set(Context.current());
+      }
+      }).start();
+    assertNotNull(contextOfNewThread.get(5, TimeUnit.SECONDS));
+    assertNotSame(contextOfThisThread, contextOfNewThread.get());
+    assertSame(contextOfThisThread, Context.current());
+    contextOfThisThread.detach(toRestore);
+  }
+
+  @Test
+  public void rootCanBeAttached() {
+    Context fork = Context.ROOT.fork();
+    Context toRestore1 = fork.attach();
+    Context toRestore2 = Context.ROOT.attach();
+    assertTrue(Context.ROOT.isCurrent());
+
+    Context toRestore3 = fork.attach();
+    assertTrue(fork.isCurrent());
+
+    fork.detach(toRestore3);
+    Context.ROOT.detach(toRestore2);
+    fork.detach(toRestore1);
+  }
+
+  @Test
+  public void rootCanNeverHaveAListener() {
+    Context root = Context.current();
+    root.addListener(cancellationListener, MoreExecutors.directExecutor());
+    assertEquals(0, root.listenerCount());
+  }
+
+  @Test
+  public void rootIsNotCancelled() {
+    assertFalse(Context.ROOT.isCancelled());
+    assertNull(Context.ROOT.cancellationCause());
+  }
+
+  @Test
+  public void attachedCancellableContextCannotBeCastFromCurrent() {
+    Context initial = Context.current();
+    Context.CancellableContext base = initial.withCancellation();
+    base.attach();
+    assertFalse(Context.current() instanceof Context.CancellableContext);
+    assertNotSame(base, Context.current());
+    assertNotSame(initial, Context.current());
+    base.detachAndCancel(initial, null);
+    assertSame(initial, Context.current());
+  }
+
+  @Test
+  public void attachingNonCurrentReturnsCurrent() {
+    Context initial = Context.current();
+    Context base = initial.withValue(PET, "dog");
+    assertSame(initial, base.attach());
+    assertSame(base, initial.attach());
+  }
+
+  @Test
+  public void detachingNonCurrentLogsSevereMessage() {
+    final AtomicReference<LogRecord> logRef = new AtomicReference<>();
+    Handler handler = new Handler() {
+      @Override
+      public void publish(LogRecord record) {
+        logRef.set(record);
+      }
+
+      @Override
+      public void flush() {
+      }
+
+      @Override
+      public void close() throws SecurityException {
+      }
+    };
+    Logger logger = Logger.getLogger(Context.storage().getClass().getName());
+    try {
+      logger.addHandler(handler);
+      Context initial = Context.current();
+      Context base = initial.withValue(PET, "dog");
+      // Base is not attached
+      base.detach(initial);
+      assertSame(initial, Context.current());
+      assertNotNull(logRef.get());
+      assertEquals(Level.SEVERE, logRef.get().getLevel());
+    } finally {
+      logger.removeHandler(handler);
+    }
+  }
+
+  @Test
+  public void valuesAndOverrides() {
+    Context base = Context.current().withValue(PET, "dog");
+    Context child = base.withValues(PET, null, FOOD, "cheese");
+
+    base.attach();
+
+    assertEquals("dog", PET.get());
+    assertEquals("lasagna", FOOD.get());
+    assertNull(COLOR.get());
+
+    child.attach();
+
+    assertNull(PET.get());
+    assertEquals("cheese", FOOD.get());
+    assertNull(COLOR.get());
+
+    child.detach(base);
+
+    // Should have values from base
+    assertEquals("dog", PET.get());
+    assertEquals("lasagna", FOOD.get());
+    assertNull(COLOR.get());
+
+    base.detach(Context.ROOT);
+
+    assertNull(PET.get());
+    assertEquals("lasagna", FOOD.get());
+    assertNull(COLOR.get());
+  }
+
+  @Test
+  public void withValuesThree() {
+    Object fav = new Object();
+    Context base = Context.current().withValues(PET, "dog", COLOR, "blue");
+    Context child = base.withValues(PET, "cat", FOOD, "cheese", FAVORITE, fav);
+
+    Context toRestore = child.attach();
+
+    assertEquals("cat", PET.get());
+    assertEquals("cheese", FOOD.get());
+    assertEquals("blue", COLOR.get());
+    assertEquals(fav, FAVORITE.get());
+
+    child.detach(toRestore);
+  }
+
+  @Test
+  public void withValuesFour() {
+    Object fav = new Object();
+    Context base = Context.current().withValues(PET, "dog", COLOR, "blue");
+    Context child = base.withValues(PET, "cat", FOOD, "cheese", FAVORITE, fav, LUCKY, 7);
+
+    Context toRestore = child.attach();
+
+    assertEquals("cat", PET.get());
+    assertEquals("cheese", FOOD.get());
+    assertEquals("blue", COLOR.get());
+    assertEquals(fav, FAVORITE.get());
+    assertEquals(7, (int) LUCKY.get());
+
+    child.detach(toRestore);
+  }
+
+  @Test
+  public void cancelReturnsFalseIfAlreadyCancelled() {
+    Context.CancellableContext base = Context.current().withCancellation();
+    assertTrue(base.cancel(null));
+    assertTrue(base.isCancelled());
+    assertFalse(base.cancel(null));
+  }
+
+  @Test
+  public void notifyListenersOnCancel() {
+    class SetContextCancellationListener implements Context.CancellationListener {
+      private final AtomicReference<Context> observed;
+
+      public SetContextCancellationListener(AtomicReference<Context> observed) {
+        this.observed = observed;
+      }
+
+      @Override
+      public void cancelled(Context context) {
+        observed.set(context);
+      }
+    }
+
+    Context.CancellableContext base = Context.current().withCancellation();
+    final AtomicReference<Context> observed1 = new AtomicReference<>();
+    base.addListener(new SetContextCancellationListener(observed1), MoreExecutors.directExecutor());
+    final AtomicReference<Context> observed2 = new AtomicReference<>();
+    base.addListener(new SetContextCancellationListener(observed2), MoreExecutors.directExecutor());
+    assertNull(observed1.get());
+    assertNull(observed2.get());
+    base.cancel(null);
+    assertSame(base, observed1.get());
+    assertSame(base, observed2.get());
+
+    final AtomicReference<Context> observed3 = new AtomicReference<>();
+    base.addListener(new SetContextCancellationListener(observed3), MoreExecutors.directExecutor());
+    assertSame(base, observed3.get());
+  }
+
+  @Test
+  public void removeListenersFromContextAndChildContext() {
+    class SetContextCancellationListener implements Context.CancellationListener {
+      private final List<Context> observedContexts;
+
+      SetContextCancellationListener() {
+        this.observedContexts = Collections.synchronizedList(new ArrayList<Context>());
+      }
+
+      @Override
+      public void cancelled(Context context) {
+        observedContexts.add(context);
+      }
+    }
+
+    Context.CancellableContext base = Context.current().withCancellation();
+    Context child = base.withValue(PET, "tiger");
+    Context childOfChild = base.withValue(PET, "lion");
+    final SetContextCancellationListener listener = new SetContextCancellationListener();
+    base.addListener(listener, MoreExecutors.directExecutor());
+    child.addListener(listener, MoreExecutors.directExecutor());
+    childOfChild.addListener(listener, MoreExecutors.directExecutor());
+    base.removeListener(listener);
+    childOfChild.removeListener(listener);
+    base.cancel(null);
+    assertEquals(1, listener.observedContexts.size());
+    assertSame(child, listener.observedContexts.get(0));
+  }
+
+  @Test
+  public void exceptionOfExecutorDoesntThrow() {
+    final AtomicReference<Throwable> loggedThrowable = new AtomicReference<>();
+    Handler logHandler = new Handler() {
+      @Override
+      public void publish(LogRecord record) {
+        Throwable thrown = record.getThrown();
+        if (thrown != null) {
+          if (loggedThrowable.get() == null) {
+            loggedThrowable.set(thrown);
+          } else {
+            loggedThrowable.set(new RuntimeException("Too many exceptions", thrown));
+          }
+        }
+      }
+
+      @Override
+      public void close() {}
+
+      @Override
+      public void flush() {}
+    };
+    Logger logger = Logger.getLogger(Context.class.getName());
+    logger.addHandler(logHandler);
+    try {
+      Context.CancellableContext base = Context.current().withCancellation();
+      final AtomicReference<Runnable> observed1 = new AtomicReference<>();
+      final Error err = new Error();
+      base.addListener(cancellationListener, new Executor() {
+        @Override
+        public void execute(Runnable runnable) {
+          observed1.set(runnable);
+          throw err;
+        }
+      });
+      assertNull(observed1.get());
+      assertNull(loggedThrowable.get());
+      base.cancel(null);
+      assertNotNull(observed1.get());
+      assertSame(err, loggedThrowable.get());
+
+      final Error err2 = new Error();
+      loggedThrowable.set(null);
+      final AtomicReference<Runnable> observed2 = new AtomicReference<>();
+      base.addListener(cancellationListener, new Executor() {
+        @Override
+        public void execute(Runnable runnable) {
+          observed2.set(runnable);
+          throw err2;
+        }
+      });
+      assertNotNull(observed2.get());
+      assertSame(err2, loggedThrowable.get());
+    } finally {
+      logger.removeHandler(logHandler);
+    }
+  }
+
+  @Test
+  public void cascadingCancellationNotifiesChild() {
+    // Root is not cancellable so we can't cascade from it
+    Context.CancellableContext base = Context.current().withCancellation();
+    assertEquals(0, base.listenerCount());
+    Context child = base.withValue(FOOD, "lasagna");
+    assertEquals(0, child.listenerCount());
+    child.addListener(cancellationListener, MoreExecutors.directExecutor());
+    assertEquals(1, child.listenerCount());
+    assertEquals(1, base.listenerCount()); // child is now listening to base
+    assertFalse(base.isCancelled());
+    assertFalse(child.isCancelled());
+    IllegalStateException cause = new IllegalStateException();
+    base.cancel(cause);
+    assertTrue(base.isCancelled());
+    assertSame(cause, base.cancellationCause());
+    assertSame(child, listenerNotifedContext);
+    assertTrue(child.isCancelled());
+    assertSame(cause, child.cancellationCause());
+    assertEquals(0, base.listenerCount());
+    assertEquals(0, child.listenerCount());
+  }
+
+  @Test
+  public void cascadingCancellationWithoutListener() {
+    Context.CancellableContext base = Context.current().withCancellation();
+    Context child = base.withCancellation();
+    Throwable t = new Throwable();
+    base.cancel(t);
+    assertTrue(child.isCancelled());
+    assertSame(t, child.cancellationCause());
+  }
+
+  // Context#isCurrent() and Context.CancellableContext#isCurrent() are intended
+  // to be visible only for testing. The deprecation is meant for users.
+  @SuppressWarnings("deprecation")
+  @Test
+  public void cancellableContextIsAttached() {
+    Context.CancellableContext base = Context.current().withValue(FOOD, "fish").withCancellation();
+    assertFalse(base.isCurrent());
+    Context toRestore = base.attach();
+
+    Context attached = Context.current();
+    assertSame("fish", FOOD.get());
+    assertFalse(attached.isCancelled());
+    assertNull(attached.cancellationCause());
+    assertTrue(attached.isCurrent());
+    assertTrue(base.isCurrent());
+
+    attached.addListener(cancellationListener, MoreExecutors.directExecutor());
+    Throwable t = new Throwable();
+    base.cancel(t);
+    assertTrue(attached.isCancelled());
+    assertSame(t, attached.cancellationCause());
+    assertSame(attached, listenerNotifedContext);
+
+    base.detach(toRestore);
+  }
+
+  @Test
+  public void cancellableContextCascadesFromCancellableParent() {
+    // Root is not cancellable so we can't cascade from it
+    Context.CancellableContext base = Context.current().withCancellation();
+    Context child = base.withCancellation();
+    child.addListener(cancellationListener, MoreExecutors.directExecutor());
+    assertFalse(base.isCancelled());
+    assertFalse(child.isCancelled());
+    IllegalStateException cause = new IllegalStateException();
+    base.cancel(cause);
+    assertTrue(base.isCancelled());
+    assertSame(cause, base.cancellationCause());
+    assertSame(child, listenerNotifedContext);
+    assertTrue(child.isCancelled());
+    assertSame(cause, child.cancellationCause());
+    assertEquals(0, base.listenerCount());
+    assertEquals(0, child.listenerCount());
+  }
+
+  @Test
+  public void nonCascadingCancellationDoesNotNotifyForked() {
+    Context.CancellableContext base = Context.current().withCancellation();
+    Context fork = base.fork();
+    fork.addListener(cancellationListener, MoreExecutors.directExecutor());
+    assertEquals(0, base.listenerCount());
+    assertEquals(0, fork.listenerCount());
+    assertTrue(base.cancel(new Throwable()));
+    assertNull(listenerNotifedContext);
+    assertFalse(fork.isCancelled());
+    assertNull(fork.cancellationCause());
+  }
+
+  @Test
+  public void testWrapRunnable() {
+    Context base = Context.current().withValue(PET, "cat");
+    Context current = Context.current().withValue(PET, "fish");
+    current.attach();
+
+    base.wrap(runner).run();
+    assertSame(base, observed);
+    assertSame(current, Context.current());
+
+    current.wrap(runner).run();
+    assertSame(current, observed);
+    assertSame(current, Context.current());
+
+    final TestError err = new TestError();
+    try {
+      base.wrap(new Runnable() {
+        @Override
+        public void run() {
+          throw err;
+        }
+      }).run();
+      fail("Expected exception");
+    } catch (TestError ex) {
+      assertSame(err, ex);
+    }
+    assertSame(current, Context.current());
+
+    current.detach(Context.ROOT);
+  }
+
+  @Test
+  public void testWrapCallable() throws Exception {
+    Context base = Context.current().withValue(PET, "cat");
+    Context current = Context.current().withValue(PET, "fish");
+    current.attach();
+
+    final Object ret = new Object();
+    Callable<Object> callable = new Callable<Object>() {
+      @Override
+      public Object call() {
+        runner.run();
+        return ret;
+      }
+    };
+
+    assertSame(ret, base.wrap(callable).call());
+    assertSame(base, observed);
+    assertSame(current, Context.current());
+
+    assertSame(ret, current.wrap(callable).call());
+    assertSame(current, observed);
+    assertSame(current, Context.current());
+
+    final TestError err = new TestError();
+    try {
+      base.wrap(new Callable<Object>() {
+        @Override
+        public Object call() {
+          throw err;
+        }
+      }).call();
+      fail("Excepted exception");
+    } catch (TestError ex) {
+      assertSame(err, ex);
+    }
+    assertSame(current, Context.current());
+
+    current.detach(Context.ROOT);
+  }
+
+  @Test
+  public void currentContextExecutor() {
+    QueuedExecutor queuedExecutor = new QueuedExecutor();
+    Executor executor = Context.currentContextExecutor(queuedExecutor);
+    Context base = Context.current().withValue(PET, "cat");
+    Context previous = base.attach();
+    try {
+      executor.execute(runner);
+    } finally {
+      base.detach(previous);
+    }
+    assertEquals(1, queuedExecutor.runnables.size());
+    queuedExecutor.runnables.remove().run();
+    assertSame(base, observed);
+  }
+
+  @Test
+  public void fixedContextExecutor() {
+    Context base = Context.current().withValue(PET, "cat");
+    QueuedExecutor queuedExecutor = new QueuedExecutor();
+    base.fixedContextExecutor(queuedExecutor).execute(runner);
+    assertEquals(1, queuedExecutor.runnables.size());
+    queuedExecutor.runnables.remove().run();
+    assertSame(base, observed);
+  }
+
+  @Test
+  public void typicalTryFinallyHandling() {
+    Context base = Context.current().withValue(COLOR, "blue");
+    Context previous = base.attach();
+    try {
+      assertTrue(base.isCurrent());
+      // Do something
+    } finally {
+      base.detach(previous);
+    }
+    assertFalse(base.isCurrent());
+  }
+
+  @Test
+  public void typicalCancellableTryCatchFinallyHandling() {
+    Context.CancellableContext base = Context.current().withCancellation();
+    Context previous = base.attach();
+    try {
+      // Do something
+      throw new IllegalStateException("Argh");
+    } catch (IllegalStateException ise) {
+      base.cancel(ise);
+    } finally {
+      base.detachAndCancel(previous, null);
+    }
+    assertTrue(base.isCancelled());
+    assertNotNull(base.cancellationCause());
+  }
+
+  @Test
+  public void rootHasNoDeadline() {
+    assertNull(Context.ROOT.getDeadline());
+  }
+
+  @Test
+  public void contextWithDeadlineHasDeadline() {
+    Context.CancellableContext cancellableContext =
+        Context.ROOT.withDeadlineAfter(1, TimeUnit.SECONDS, scheduler);
+    assertNotNull(cancellableContext.getDeadline());
+  }
+
+  @Test
+  public void earlierParentDeadlineTakesPrecedenceOverLaterChildDeadline() throws Exception {
+    final Deadline sooner = Deadline.after(100, TimeUnit.MILLISECONDS);
+    final Deadline later = Deadline.after(1, TimeUnit.MINUTES);
+    Context.CancellableContext parent = Context.ROOT.withDeadline(sooner, scheduler);
+    Context.CancellableContext child = parent.withDeadline(later, scheduler);
+    assertSame(parent.getDeadline(), sooner);
+    assertSame(child.getDeadline(), sooner);
+    final CountDownLatch latch = new CountDownLatch(1);
+    final AtomicReference<Exception> error = new AtomicReference<>();
+    child.addListener(new Context.CancellationListener() {
+      @Override
+      public void cancelled(Context context) {
+        try {
+          assertTrue(sooner.isExpired());
+          assertFalse(later.isExpired());
+        } catch (Exception e) {
+          error.set(e);
+        }
+        latch.countDown();
+      }
+    }, MoreExecutors.directExecutor());
+    assertTrue("cancellation failed", latch.await(3, TimeUnit.SECONDS));
+    if (error.get() != null) {
+      throw error.get();
+    }
+  }
+
+  @Test
+  public void earlierChldDeadlineTakesPrecedenceOverLaterParentDeadline() {
+    Deadline sooner = Deadline.after(1, TimeUnit.HOURS);
+    Deadline later = Deadline.after(1, TimeUnit.DAYS);
+    Context.CancellableContext parent = Context.ROOT.withDeadline(later, scheduler);
+    Context.CancellableContext child = parent.withDeadline(sooner, scheduler);
+    assertSame(parent.getDeadline(), later);
+    assertSame(child.getDeadline(), sooner);
+  }
+
+  @Test
+  public void forkingContextDoesNotCarryDeadline() {
+    Deadline deadline = Deadline.after(1, TimeUnit.HOURS);
+    Context.CancellableContext parent = Context.ROOT.withDeadline(deadline, scheduler);
+    Context fork = parent.fork();
+    assertNull(fork.getDeadline());
+  }
+
+  @Test
+  public void cancellationDoesNotExpireDeadline() {
+    Deadline deadline = Deadline.after(1, TimeUnit.HOURS);
+    Context.CancellableContext parent = Context.ROOT.withDeadline(deadline, scheduler);
+    parent.cancel(null);
+    assertFalse(deadline.isExpired());
+  }
+
+  @Test
+  public void absoluteDeadlineTriggersAndPropagates() throws Exception {
+    Context base = Context.current().withDeadline(Deadline.after(1, TimeUnit.SECONDS), scheduler);
+    Context child = base.withValue(FOOD, "lasagna");
+    child.addListener(cancellationListener, MoreExecutors.directExecutor());
+    assertFalse(base.isCancelled());
+    assertFalse(child.isCancelled());
+    assertTrue(deadlineLatch.await(2, TimeUnit.SECONDS));
+    assertTrue(base.isCancelled());
+    assertTrue(base.cancellationCause() instanceof TimeoutException);
+    assertSame(child, listenerNotifedContext);
+    assertTrue(child.isCancelled());
+    assertSame(base.cancellationCause(), child.cancellationCause());
+  }
+
+  @Test
+  public void relativeDeadlineTriggersAndPropagates() throws Exception {
+    Context base = Context.current().withDeadline(Deadline.after(1, TimeUnit.SECONDS), scheduler);
+    Context child = base.withValue(FOOD, "lasagna");
+    child.addListener(cancellationListener, MoreExecutors.directExecutor());
+    assertFalse(base.isCancelled());
+    assertFalse(child.isCancelled());
+    assertTrue(deadlineLatch.await(2, TimeUnit.SECONDS));
+    assertTrue(base.isCancelled());
+    assertTrue(base.cancellationCause() instanceof TimeoutException);
+    assertSame(child, listenerNotifedContext);
+    assertTrue(child.isCancelled());
+    assertSame(base.cancellationCause(), child.cancellationCause());
+  }
+
+  @Test
+  public void innerDeadlineCompletesBeforeOuter() throws Exception {
+    Context base = Context.current().withDeadline(Deadline.after(3, TimeUnit.SECONDS), scheduler);
+    Context child = base.withDeadline(Deadline.after(1, TimeUnit.SECONDS), scheduler);
+    child.addListener(cancellationListener, MoreExecutors.directExecutor());
+    assertFalse(base.isCancelled());
+    assertFalse(child.isCancelled());
+    assertTrue(deadlineLatch.await(2, TimeUnit.SECONDS));
+    assertFalse(base.isCancelled());
+    assertSame(child, listenerNotifedContext);
+    assertTrue(child.isCancelled());
+    assertTrue(child.cancellationCause() instanceof TimeoutException);
+
+    deadlineLatch = new CountDownLatch(1);
+    base.addListener(cancellationListener, MoreExecutors.directExecutor());
+    assertTrue(deadlineLatch.await(4, TimeUnit.SECONDS));
+    assertTrue(base.isCancelled());
+    assertTrue(base.cancellationCause() instanceof TimeoutException);
+    assertNotSame(base.cancellationCause(), child.cancellationCause());
+  }
+
+  @Test
+  public void cancellationCancelsScheduledTask() {
+    ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
+    try {
+      assertEquals(0, executor.getQueue().size());
+      Context.CancellableContext base
+          = Context.current().withDeadline(Deadline.after(1, TimeUnit.DAYS), executor);
+      assertEquals(1, executor.getQueue().size());
+      base.cancel(null);
+      executor.purge();
+      assertEquals(0, executor.getQueue().size());
+    } finally {
+      executor.shutdown();
+    }
+  }
+
+  private static class QueuedExecutor implements Executor {
+    private final Queue<Runnable> runnables = new ArrayDeque<>();
+
+    @Override
+    public void execute(Runnable r) {
+      runnables.add(r);
+    }
+  }
+
+  @Test
+  public void childContextListenerNotifiedAfterParentListener() {
+    Context.CancellableContext parent = Context.current().withCancellation();
+    Context child = parent.withValue(COLOR, "red");
+    final AtomicBoolean childAfterParent = new AtomicBoolean();
+    final AtomicBoolean parentCalled = new AtomicBoolean();
+    child.addListener(new Context.CancellationListener() {
+      @Override
+      public void cancelled(Context context) {
+        if (parentCalled.get()) {
+          childAfterParent.set(true);
+        }
+      }
+    }, MoreExecutors.directExecutor());
+    parent.addListener(new Context.CancellationListener() {
+      @Override
+      public void cancelled(Context context) {
+        parentCalled.set(true);
+      }
+    }, MoreExecutors.directExecutor());
+    parent.cancel(null);
+    assertTrue(parentCalled.get());
+    assertTrue(childAfterParent.get());
+  }
+
+  @Test
+  public void expiredDeadlineShouldCancelContextImmediately() {
+    Context parent = Context.current();
+    assertFalse(parent.isCancelled());
+
+    Context.CancellableContext context = parent.withDeadlineAfter(0, TimeUnit.SECONDS, scheduler);
+    assertTrue(context.isCancelled());
+    assertThat(context.cancellationCause(), instanceOf(TimeoutException.class));
+
+    assertFalse(parent.isCancelled());
+    Deadline deadline = Deadline.after(-10, TimeUnit.SECONDS);
+    assertTrue(deadline.isExpired());
+    context = parent.withDeadline(deadline, scheduler);
+    assertTrue(context.isCancelled());
+    assertThat(context.cancellationCause(), instanceOf(TimeoutException.class));
+  }
+
+  /**
+   * Tests initializing the {@link Context} class with a custom logger which uses Context's storage
+   * when logging.
+   */
+  @Test
+  public void initContextWithCustomClassLoaderWithCustomLogger() throws Exception {
+    StaticTestingClassLoader classLoader =
+        new StaticTestingClassLoader(
+            getClass().getClassLoader(), Pattern.compile("io\\.grpc\\.[^.]+"));
+    Class<?> runnable =
+        classLoader.loadClass(LoadMeWithStaticTestingClassLoader.class.getName());
+
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  /**
+   * Ensure that newly created threads can attach/detach a context.
+   * The current test thread already has a context manually attached in {@link #setUp()}.
+   */
+  @Test
+  public void newThreadAttachContext() throws Exception {
+    Context parent = Context.current().withValue(COLOR, "blue");
+    parent.call(new Callable<Object>() {
+      @Override
+      public Object call() throws Exception {
+        assertEquals("blue", COLOR.get());
+
+        final Context child = Context.current().withValue(COLOR, "red");
+        Future<String> workerThreadVal = scheduler
+            .submit(new Callable<String>() {
+              @Override
+              public String call() {
+                Context initial = Context.current();
+                assertNotNull(initial);
+                Context toRestore = child.attach();
+                try {
+                  assertNotNull(toRestore);
+                  return COLOR.get();
+                } finally {
+                  child.detach(toRestore);
+                  assertEquals(initial, Context.current());
+                }
+              }
+            });
+        assertEquals("red", workerThreadVal.get());
+
+        assertEquals("blue", COLOR.get());
+        return null;
+      }
+    });
+  }
+
+  /**
+   * Similar to {@link #newThreadAttachContext()} but without giving the new thread a specific ctx.
+   */
+  @Test
+  public void newThreadWithoutContext() throws Exception {
+    Context parent = Context.current().withValue(COLOR, "blue");
+    parent.call(new Callable<Object>() {
+      @Override
+      public Object call() throws Exception {
+        assertEquals("blue", COLOR.get());
+
+        Future<String> workerThreadVal = scheduler
+            .submit(new Callable<String>() {
+              @Override
+              public String call() {
+                assertNotNull(Context.current());
+                return COLOR.get();
+              }
+            });
+        assertNull(workerThreadVal.get());
+
+        assertEquals("blue", COLOR.get());
+        return null;
+      }
+    });
+  }
+
+  @Test
+  public void storageReturnsNullTest() throws Exception {
+    // TODO(sergiitk): JDK-8210522 changes the behaviour of Java reflection to filter out
+    //   security-sensitive fields in the java.lang.reflect.Field. This prohibits
+    //   Field.class.getDeclaredFields("modifiers") call we rely on in this test.
+    //   Until we have a good solution for setting a custom storage for testing purposes,
+    //   we'll have to skip this test for JDK >= 11. Ref https://bugs.openjdk.org/browse/JDK-8210522
+    double javaVersion;
+    // Graceful version check. Run the test if the version undetermined.
+    try {
+      javaVersion = Double.parseDouble(System.getProperty("java.specification.version", "0"));
+    } catch (NumberFormatException e) {
+      javaVersion = 0;
+    }
+    assume().that(javaVersion).isLessThan(11);
+
+    Class<?> lazyStorageClass = Class.forName("io.grpc.Context$LazyStorage");
+    Field storage = lazyStorageClass.getDeclaredField("storage");
+    assertTrue(Modifier.isFinal(storage.getModifiers()));
+    // use reflection to forcibly change the storage object to a test object
+    storage.setAccessible(true);
+    Field modifiersField = Field.class.getDeclaredField("modifiers");
+    modifiersField.setAccessible(true);
+    int storageModifiers = modifiersField.getInt(storage);
+    modifiersField.set(storage, storageModifiers & ~Modifier.FINAL);
+    Object o = storage.get(null);
+    Context.Storage originalStorage = (Context.Storage) o;
+    try {
+      storage.set(null, new Context.Storage() {
+        @Override
+        public Context doAttach(Context toAttach) {
+          return null;
+        }
+
+        @Override
+        public void detach(Context toDetach, Context toRestore) {
+          // noop
+        }
+
+        @Override
+        public Context current() {
+          return null;
+        }
+      });
+      // current() returning null gets transformed into ROOT
+      assertEquals(Context.ROOT, Context.current());
+
+      // doAttach() returning null gets transformed into ROOT
+      Context blueContext = Context.current().withValue(COLOR, "blue");
+      Context toRestore = blueContext.attach();
+      assertEquals(Context.ROOT, toRestore);
+
+      // final sanity check
+      blueContext.detach(toRestore);
+      assertEquals(Context.ROOT, Context.current());
+    } finally {
+      // undo the changes
+      storage.set(null, originalStorage);
+      storage.setAccessible(false);
+      modifiersField.set(storage, storageModifiers | Modifier.FINAL);
+      modifiersField.setAccessible(false);
+    }
+  }
+
+  @Test
+  public void cancellableAncestorTest() {
+    Context c = Context.current();
+    assertNull(cancellableAncestor(c));
+
+    Context.CancellableContext withCancellation = c.withCancellation();
+    assertEquals(withCancellation, cancellableAncestor(withCancellation));
+
+    Context child = withCancellation.withValue(COLOR, "blue");
+    assertFalse(child instanceof Context.CancellableContext);
+    assertEquals(withCancellation, cancellableAncestor(child));
+
+    Context grandChild = child.withValue(COLOR, "red");
+    assertFalse(grandChild instanceof Context.CancellableContext);
+    assertEquals(withCancellation, cancellableAncestor(grandChild));
+  }
+
+  @Test
+  public void cancellableAncestorIntegrationTest() {
+    Context base = Context.current();
+
+    Context blue = base.withValue(COLOR, "blue");
+    assertNull(blue.cancellableAncestor);
+    Context.CancellableContext cancellable = blue.withCancellation();
+    assertNull(cancellable.cancellableAncestor);
+    Context childOfCancel = cancellable.withValue(PET, "cat");
+    assertSame(cancellable, childOfCancel.cancellableAncestor);
+    Context grandChildOfCancel = childOfCancel.withValue(FOOD, "lasagna");
+    assertSame(cancellable, grandChildOfCancel.cancellableAncestor);
+
+    Context.CancellableContext cancellable2 = childOfCancel.withCancellation();
+    assertSame(cancellable, cancellable2.cancellableAncestor);
+    Context childOfCancellable2 = cancellable2.withValue(PET, "dog");
+    assertSame(cancellable2, childOfCancellable2.cancellableAncestor);
+  }
+
+  @Test
+  public void cancellableAncestorFork() {
+    Context.CancellableContext cancellable = Context.current().withCancellation();
+    Context fork = cancellable.fork();
+    assertNull(fork.cancellableAncestor);
+  }
+
+  @Test
+  public void cancellableContext_closeCancelsWithNullCause() {
+    Context.CancellableContext cancellable = Context.current().withCancellation();
+    cancellable.close();
+    assertTrue(cancellable.isCancelled());
+    assertNull(cancellable.cancellationCause());
+  }
+
+  @Test
+  public void errorWhenAncestryLengthLong() {
+    final AtomicReference<LogRecord> logRef = new AtomicReference<>();
+    Handler handler = new Handler() {
+      @Override
+      public void publish(LogRecord record) {
+        logRef.set(record);
+      }
+
+      @Override
+      public void flush() {
+      }
+
+      @Override
+      public void close() throws SecurityException {
+      }
+    };
+    Logger logger = Logger.getLogger(Context.class.getName());
+    try {
+      logger.addHandler(handler);
+      Context ctx = Context.current();
+      for (int i = 0; i < Context.CONTEXT_DEPTH_WARN_THRESH ; i++) {
+        assertNull(logRef.get());
+        ctx = ctx.fork();
+      }
+      ctx.fork();
+      assertNotNull(logRef.get());
+      assertNotNull(logRef.get().getThrown());
+      assertEquals(Level.SEVERE, logRef.get().getLevel());
+    } finally {
+      logger.removeHandler(handler);
+    }
+  }
+
+  // UsedReflectively
+  public static final class LoadMeWithStaticTestingClassLoader implements Runnable {
+    @Override
+    public void run() {
+      Logger logger = Logger.getLogger(Context.class.getName());
+      logger.setLevel(Level.ALL);
+      Handler handler = new Handler() {
+        @Override
+        public void publish(LogRecord record) {
+          Context ctx = Context.current();
+          Context previous = ctx.attach();
+          ctx.detach(previous);
+        }
+
+        @Override
+        public void flush() {
+        }
+
+        @Override
+        public void close() throws SecurityException {
+        }
+      };
+      logger.addHandler(handler);
+
+      try {
+        assertNotNull(Context.ROOT);
+      } finally {
+        logger.removeHandler(handler);
+      }
+    }
+  }
+
+  /** Allows more precise catch blocks than plain Error to avoid catching AssertionError. */
+  private static final class TestError extends Error {}
+}
diff --git a/core/src/test/java/io/grpc/ContextsTest.java b/api/src/test/java/io/grpc/ContextsTest.java
similarity index 77%
rename from core/src/test/java/io/grpc/ContextsTest.java
rename to api/src/test/java/io/grpc/ContextsTest.java
index 36bc9d6186c..ec9dc3929a2 100644
--- a/core/src/test/java/io/grpc/ContextsTest.java
+++ b/api/src/test/java/io/grpc/ContextsTest.java
@@ -1,53 +1,38 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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;
 
+import static com.google.common.truth.Truth.assertThat;
 import static io.grpc.Contexts.interceptCall;
 import static io.grpc.Contexts.statusFromCancelled;
-import static org.hamcrest.core.IsInstanceOf.instanceOf;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
-import io.grpc.internal.FakeClock;
-import io.grpc.testing.NoopServerCall;
+import com.google.common.util.concurrent.testing.TestingExecutors;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import org.junit.Test;
@@ -63,14 +48,14 @@ public class ContextsTest {
   /** For use in comparing context by reference. */
   private Context uniqueContext = Context.ROOT.withValue(contextKey, new Object());
   @SuppressWarnings("unchecked")
-  private ServerCall<Object, Object> call = new NoopServerCall<Object, Object>();
+  private ServerCall<Object, Object> call = new NoopServerCall<>();
   private Metadata headers = new Metadata();
 
   @Test
   public void interceptCall_basic() {
     Context origContext = Context.current();
     final Object message = new Object();
-    final List<Integer> methodCalls = new ArrayList<Integer>();
+    final List<Integer> methodCalls = new ArrayList<>();
     final ServerCall.Listener<Object> listener = new ServerCall.Listener<Object>() {
       @Override public void onMessage(Object messageIn) {
         assertSame(message, messageIn);
@@ -228,14 +213,32 @@ public void statusFromCancelled_shouldReturnStatusWithCauseAttached() {
 
   @Test
   public void statusFromCancelled_TimeoutExceptionShouldMapToDeadlineExceeded() {
-    FakeClock fakeClock = new FakeClock();
+    final long expectedDelay = 100;
+    final TimeUnit expectedUnit = TimeUnit.SECONDS;
+    class MockScheduledExecutorService extends ForwardingScheduledExecutorService {
+      private ScheduledExecutorService delegate = TestingExecutors.noOpScheduledExecutor();
+      Runnable command;
+
+      @Override public ScheduledExecutorService delegate() {
+        return delegate;
+      }
+
+      @Override public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
+        if (delay > unit.convert(expectedDelay, expectedUnit)) {
+          fail("Delay larger than expected: " + delay + " " + unit);
+        }
+        this.command = command;
+        return super.schedule(command, delay, unit);
+      }
+    }
+
+    MockScheduledExecutorService executorService = new MockScheduledExecutorService();
     Context.CancellableContext cancellableContext = Context.current()
-        .withDeadlineAfter(100, TimeUnit.MILLISECONDS, fakeClock.getScheduledExecutorService());
-    fakeClock.forwardTime(System.nanoTime(), TimeUnit.NANOSECONDS);
-    fakeClock.forwardMillis(100);
+        .withDeadlineAfter(expectedDelay, expectedUnit, executorService);
+    executorService.command.run();
 
     assertTrue(cancellableContext.isCancelled());
-    assertThat(cancellableContext.cancellationCause(), instanceOf(TimeoutException.class));
+    assertThat(cancellableContext.cancellationCause()).isInstanceOf(TimeoutException.class);
 
     Status status = statusFromCancelled(cancellableContext);
     assertNotNull(status);
diff --git a/api/src/test/java/io/grpc/DeadlineTest.java b/api/src/test/java/io/grpc/DeadlineTest.java
new file mode 100644
index 00000000000..69f849bea7c
--- /dev/null
+++ b/api/src/test/java/io/grpc/DeadlineTest.java
@@ -0,0 +1,352 @@
+/*
+ * Copyright 2016 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;
+
+import static com.google.common.truth.Truth.assertAbout;
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.testing.DeadlineSubject.deadline;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.testing.EqualsTester;
+import com.google.common.truth.Truth;
+import java.util.Arrays;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.mockito.ArgumentCaptor;
+
+/**
+ * Tests for {@link Context}.
+ */
+@RunWith(Parameterized.class)
+public class DeadlineTest {
+  /** Ticker epochs to vary testing. */
+  @Parameters
+  public static Iterable<Object[]> data() {
+    return Arrays.asList(new Object[][] {
+      // MAX_VALUE / 2 is important because the signs are generally the same for past and future
+      // deadlines.
+      {Long.MAX_VALUE / 2}, {0}, {Long.MAX_VALUE}, {Long.MIN_VALUE}
+    });
+  }
+
+  private FakeTicker ticker = new FakeTicker();
+
+  public DeadlineTest(long epoch) {
+    ticker.reset(epoch);
+  }
+
+  @Test
+  public void defaultTickerIsSystemTicker() {
+    Deadline d = Deadline.after(0, TimeUnit.SECONDS);
+    ticker.reset(System.nanoTime());
+    Deadline reference = Deadline.after(0, TimeUnit.SECONDS, ticker);
+    // Allow inaccuracy to account for system time advancing during test.
+    assertAbout(deadline()).that(d).isWithin(1, TimeUnit.SECONDS).of(reference);
+  }
+
+  @Test
+  public void minimum() {
+    Deadline d1 = Deadline.after(1, TimeUnit.MINUTES, ticker);
+    Deadline d2 = Deadline.after(2, TimeUnit.MINUTES, ticker);
+    Deadline d3 = Deadline.after(3, TimeUnit.MINUTES, ticker);
+
+    assertThat(d1.minimum(d2)).isSameInstanceAs(d1);
+    assertThat(d2.minimum(d1)).isSameInstanceAs(d1);
+    assertThat(d3.minimum(d2)).isSameInstanceAs(d2);
+    assertThat(d2.minimum(d3)).isSameInstanceAs(d2);
+  }
+
+  @Test
+  public void timeCanOverflow() {
+    ticker.reset(Long.MAX_VALUE);
+    Deadline d = Deadline.after(10, TimeUnit.DAYS, ticker);
+    assertEquals(10, d.timeRemaining(TimeUnit.DAYS));
+    assertTrue(Deadline.after(0, TimeUnit.DAYS, ticker).isBefore(d));
+    assertFalse(d.isExpired());
+
+    ticker.increment(10, TimeUnit.DAYS);
+    assertTrue(d.isExpired());
+  }
+
+  @Test
+  public void timeCanUnderflow() {
+    ticker.reset(Long.MIN_VALUE);
+    Deadline d = Deadline.after(-10, TimeUnit.DAYS, ticker);
+    assertEquals(-10, d.timeRemaining(TimeUnit.DAYS));
+    assertTrue(d.isBefore(Deadline.after(0, TimeUnit.DAYS, ticker)));
+    assertTrue(d.isExpired());
+  }
+
+  @Test
+  public void deadlineClamps() {
+    Deadline d = Deadline.after(-300 * 365, TimeUnit.DAYS, ticker);
+    Deadline d2 = Deadline.after(300 * 365, TimeUnit.DAYS, ticker);
+    assertTrue(d.isBefore(d2));
+
+    Deadline d3 = Deadline.after(-200 * 365, TimeUnit.DAYS, ticker);
+    // d and d3 are equal
+    assertFalse(d.isBefore(d3));
+    assertFalse(d3.isBefore(d));
+  }
+
+  @Test
+  public void immediateDeadlineIsExpired() {
+    Deadline deadline = Deadline.after(0, TimeUnit.SECONDS, ticker);
+    assertTrue(deadline.isExpired());
+  }
+
+  @Test
+  public void shortDeadlineEventuallyExpires() throws Exception {
+    Deadline d = Deadline.after(100, TimeUnit.MILLISECONDS, ticker);
+    assertTrue(d.timeRemaining(TimeUnit.NANOSECONDS) > 0);
+    assertFalse(d.isExpired());
+    ticker.increment(101, TimeUnit.MILLISECONDS);
+
+    assertTrue(d.isExpired());
+    assertEquals(-1, d.timeRemaining(TimeUnit.MILLISECONDS));
+  }
+
+  @Test
+  public void deadlineMatchesLongValue() {
+    assertEquals(10, Deadline.after(10, TimeUnit.MINUTES, ticker).timeRemaining(TimeUnit.MINUTES));
+  }
+
+  @Test
+  public void pastDeadlineIsExpired() {
+    Deadline d = Deadline.after(-1, TimeUnit.SECONDS, ticker);
+    assertTrue(d.isExpired());
+    assertEquals(-1000, d.timeRemaining(TimeUnit.MILLISECONDS));
+  }
+
+  @Test
+  public void deadlineDoesNotOverflowOrUnderflow() {
+    Deadline after = Deadline.after(Long.MAX_VALUE, TimeUnit.NANOSECONDS, ticker);
+    assertFalse(after.isExpired());
+
+    Deadline before = Deadline.after(-Long.MAX_VALUE, TimeUnit.NANOSECONDS, ticker);
+    assertTrue(before.isExpired());
+
+    assertTrue(before.isBefore(after));
+  }
+
+  @Test
+  public void beforeExpiredDeadlineIsExpired() {
+    Deadline base = Deadline.after(0, TimeUnit.SECONDS, ticker);
+    assertTrue(base.isExpired());
+    assertTrue(base.offset(-1, TimeUnit.SECONDS).isExpired());
+  }
+
+  @Test
+  public void beforeNotExpiredDeadlineMayBeExpired() {
+    Deadline base = Deadline.after(10, TimeUnit.SECONDS, ticker);
+    assertFalse(base.isExpired());
+    assertFalse(base.offset(-1, TimeUnit.SECONDS).isExpired());
+    assertTrue(base.offset(-11, TimeUnit.SECONDS).isExpired());
+  }
+
+  @Test
+  public void afterExpiredDeadlineMayBeExpired() {
+    Deadline base = Deadline.after(-10, TimeUnit.SECONDS, ticker);
+    assertTrue(base.isExpired());
+    assertTrue(base.offset(1, TimeUnit.SECONDS).isExpired());
+    assertFalse(base.offset(11, TimeUnit.SECONDS).isExpired());
+  }
+
+  @Test
+  public void zeroOffsetIsSameDeadline() {
+    Deadline base = Deadline.after(0, TimeUnit.SECONDS, ticker);
+    assertSame(base, base.offset(0, TimeUnit.SECONDS));
+  }
+
+  @Test
+  public void runOnEventualExpirationIsExecuted() throws Exception {
+    Deadline base = Deadline.after(50, TimeUnit.MICROSECONDS, ticker);
+    ScheduledExecutorService mockScheduler = mock(ScheduledExecutorService.class);
+    final AtomicBoolean executed = new AtomicBoolean();
+    Future<?> unused = base.runOnExpiration(
+        new Runnable() {
+          @Override
+          public void run() {
+            executed.set(true);
+          }
+        }, mockScheduler);
+    assertFalse(executed.get());
+    ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);
+    verify(mockScheduler).schedule(runnableCaptor.capture(), eq(50000L), eq(TimeUnit.NANOSECONDS));
+    runnableCaptor.getValue().run();
+    assertTrue(executed.get());
+  }
+
+  @Test
+  public void runOnAlreadyExpiredIsExecutedOnExecutor() throws Exception {
+    Deadline base = Deadline.after(0, TimeUnit.MICROSECONDS, ticker);
+    ScheduledExecutorService mockScheduler = mock(ScheduledExecutorService.class);
+    final AtomicBoolean executed = new AtomicBoolean();
+    Future<?> unused = base.runOnExpiration(
+        new Runnable() {
+          @Override
+          public void run() {
+            executed.set(true);
+          }
+        }, mockScheduler);
+    assertFalse(executed.get());
+    ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);
+    verify(mockScheduler).schedule(runnableCaptor.capture(), eq(0L), eq(TimeUnit.NANOSECONDS));
+    runnableCaptor.getValue().run();
+    assertTrue(executed.get());
+  }
+
+  @Test
+  public void toString_systemTickerNotShown() {
+    Deadline d = Deadline.after(0, TimeUnit.MILLISECONDS);
+    assertThat(d.toString()).endsWith("s from now");
+  }
+
+  @Test
+  public void toString_exact() {
+    Deadline d = Deadline.after(0, TimeUnit.MILLISECONDS, ticker);
+    assertEquals("0s from now (ticker=FAKE_TICKER)", d.toString());
+  }
+
+  @Test
+  public void toString_after() {
+    Deadline d;
+
+    d = Deadline.after(-1, TimeUnit.MINUTES, ticker);
+    assertEquals("-60s from now (ticker=FAKE_TICKER)", d.toString());
+    d = Deadline.after(-1, TimeUnit.MILLISECONDS, ticker);
+    assertEquals("-0.001000000s from now (ticker=FAKE_TICKER)", d.toString());
+    d = Deadline.after(-500, TimeUnit.MILLISECONDS, ticker);
+    assertEquals("-0.500000000s from now (ticker=FAKE_TICKER)", d.toString());
+    d = Deadline.after(-1000, TimeUnit.MILLISECONDS, ticker);
+    assertEquals("-1s from now (ticker=FAKE_TICKER)", d.toString());
+    d = Deadline.after(-1500, TimeUnit.MILLISECONDS, ticker);
+    assertEquals("-1.500000000s from now (ticker=FAKE_TICKER)", d.toString());
+    d = Deadline.after(-1023456789, TimeUnit.NANOSECONDS, ticker);
+    assertEquals("-1.023456789s from now (ticker=FAKE_TICKER)", d.toString());
+  }
+
+  @Test
+  public void compareTo_greater() {
+    Deadline d1 = Deadline.after(10, TimeUnit.SECONDS, ticker);
+    ticker.increment(1, TimeUnit.NANOSECONDS);
+    Deadline d2 = Deadline.after(10, TimeUnit.SECONDS, ticker);
+    Truth.assertThat(d2).isGreaterThan(d1);
+  }
+
+  @Test
+  public void compareTo_less() {
+    Deadline d1 = Deadline.after(10, TimeUnit.SECONDS, ticker);
+    ticker.increment(1, TimeUnit.NANOSECONDS);
+    Deadline d2 = Deadline.after(10, TimeUnit.SECONDS, ticker);
+    Truth.assertThat(d1).isLessThan(d2);
+  }
+
+  @Test
+  public void compareTo_same() {
+    Deadline d1 = Deadline.after(10, TimeUnit.SECONDS, ticker);
+    Deadline d2 = Deadline.after(10, TimeUnit.SECONDS, ticker);
+    Truth.assertThat(d1).isEquivalentAccordingToCompareTo(d2);
+  }
+
+  @Test
+  public void tickersDontMatch() {
+    Deadline d1 = Deadline.after(10, TimeUnit.SECONDS);
+    Deadline d2 = Deadline.after(10, TimeUnit.SECONDS, ticker);
+    boolean success = false;
+    try {
+      d1.compareTo(d2);
+      success = true;
+    } catch (AssertionError e) {
+      // Expected
+    }
+    assertFalse(success);
+
+    try {
+      d1.minimum(d2);
+      success = true;
+    } catch (AssertionError e) {
+      // Expected
+    }
+    assertFalse(success);
+
+    try {
+      d1.isBefore(d2);
+      success = true;
+    } catch (AssertionError e) {
+      // Expected
+    }
+    assertFalse(success);
+  }
+
+  @Test
+  public void toString_before() {
+    Deadline d = Deadline.after(12, TimeUnit.MICROSECONDS, ticker);
+    assertEquals("0.000012000s from now (ticker=FAKE_TICKER)", d.toString());
+  }
+
+  @Test
+  public void equality() {
+    final Deadline d1 = Deadline.after(12, TimeUnit.MICROSECONDS, ticker);
+    final Deadline d2 = Deadline.after(12, TimeUnit.MICROSECONDS, ticker);
+    final Deadline d3 = Deadline.after(12, TimeUnit.MICROSECONDS, new FakeTicker());
+    final Deadline d4 = Deadline.after(10, TimeUnit.MICROSECONDS, ticker);
+
+    new EqualsTester()
+            .addEqualityGroup(d1, d2)
+            .addEqualityGroup(d3)
+            .addEqualityGroup(d4)
+            .testEquals();
+  }
+
+  private static class FakeTicker extends Deadline.Ticker {
+    private long time;
+
+    @Override
+    public long nanoTime() {
+      return time;
+    }
+
+    public void reset(long time) {
+      this.time = time;
+    }
+
+    public void increment(long period, TimeUnit unit) {
+      if (period < 0) {
+        throw new IllegalArgumentException();
+      }
+      this.time += unit.toNanos(period);
+    }
+
+    @Override
+    public String toString() {
+      return "FAKE_TICKER";
+    }
+  }
+}
diff --git a/api/src/test/java/io/grpc/DecompressorRegistryTest.java b/api/src/test/java/io/grpc/DecompressorRegistryTest.java
new file mode 100644
index 00000000000..f916e926e97
--- /dev/null
+++ b/api/src/test/java/io/grpc/DecompressorRegistryTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2015 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;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashSet;
+import java.util.Set;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link DecompressorRegistry}.
+ */
+@RunWith(JUnit4.class)
+public class DecompressorRegistryTest {
+
+  private final Dummy dummyDecompressor = new Dummy();
+  private DecompressorRegistry registry = DecompressorRegistry.emptyInstance();
+
+  @Test
+  public void lookupDecompressor_checkDefaultMessageEncodingsExist() {
+    // Explicitly put the names in, rather than link against MessageEncoding
+    assertNotNull("Expected identity to be registered",
+        DecompressorRegistry.getDefaultInstance().lookupDecompressor("identity"));
+    assertNotNull("Expected gzip to be registered",
+        DecompressorRegistry.getDefaultInstance().lookupDecompressor("gzip"));
+  }
+
+  @Test
+  public void getKnownMessageEncodings_checkDefaultMessageEncodingsExist() {
+    Set<String> knownEncodings = new HashSet<>();
+    knownEncodings.add("identity");
+    knownEncodings.add("gzip");
+
+    assertEquals(knownEncodings,
+        DecompressorRegistry.getDefaultInstance().getKnownMessageEncodings());
+  }
+
+  /*
+   * This test will likely change once encoders are advertised
+   */
+  @Test
+  public void getAdvertisedMessageEncodings_noEncodingsAdvertised() {
+    assertTrue(registry.getAdvertisedMessageEncodings().isEmpty());
+  }
+
+  @Test
+  public void registerDecompressor_advertisedDecompressor() {
+    registry = registry.with(dummyDecompressor, true);
+
+    assertTrue(registry.getAdvertisedMessageEncodings()
+        .contains(dummyDecompressor.getMessageEncoding()));
+  }
+
+  @Test
+  public void registerDecompressor_nonadvertisedDecompressor() {
+    registry = registry.with(dummyDecompressor, false);
+
+    assertFalse(registry.getAdvertisedMessageEncodings()
+        .contains(dummyDecompressor.getMessageEncoding()));
+  }
+
+  private static final class Dummy implements Decompressor {
+    @Override
+    public String getMessageEncoding() {
+      return "dummy";
+    }
+
+    @Override
+    public InputStream decompress(InputStream is) throws IOException {
+      return is;
+    }
+  }
+}
+
diff --git a/api/src/test/java/io/grpc/ForwardingChannelBuilder2Test.java b/api/src/test/java/io/grpc/ForwardingChannelBuilder2Test.java
new file mode 100644
index 00000000000..491dd076c79
--- /dev/null
+++ b/api/src/test/java/io/grpc/ForwardingChannelBuilder2Test.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2023 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+
+import com.google.common.base.Defaults;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link ForwardingChannelBuilder2}.
+ */
+@RunWith(JUnit4.class)
+public class ForwardingChannelBuilder2Test {
+  private final ManagedChannelBuilder<?> mockDelegate = mock(ManagedChannelBuilder.class);
+
+  private final ForwardingChannelBuilder2<?> testChannelBuilder = new TestBuilder();
+
+  private final class TestBuilder extends ForwardingChannelBuilder2<TestBuilder> {
+    @Override
+    protected ManagedChannelBuilder<?> delegate() {
+      return mockDelegate;
+    }
+  }
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        ManagedChannelBuilder.class,
+        mockDelegate,
+        testChannelBuilder,
+        Collections.emptyList(),
+        new ForwardingTestUtil.ArgumentProvider() {
+          @Override
+          public Object get(Method method, int argPos, Class<?> clazz) {
+            if (method.getName().equals("maxInboundMetadataSize")) {
+              assertThat(argPos).isEqualTo(0);
+              return 1; // an arbitrary positive number
+            }
+            return null;
+          }
+        });
+  }
+
+  @Test
+  public void allBuilderMethodsReturnThis() throws Exception {
+    for (Method method : ManagedChannelBuilder.class.getDeclaredMethods()) {
+      if (Modifier.isStatic(method.getModifiers()) || Modifier.isPrivate(method.getModifiers())) {
+        continue;
+      }
+      if (method.getName().equals("build")) {
+        continue;
+      }
+      Class<?>[] argTypes = method.getParameterTypes();
+      Object[] args = new Object[argTypes.length];
+      for (int i = 0; i < argTypes.length; i++) {
+        args[i] = Defaults.defaultValue(argTypes[i]);
+      }
+      if (method.getName().equals("maxInboundMetadataSize")) {
+        args[0] = 1; // an arbitrary positive number
+      }
+
+      Object returnedValue = method.invoke(testChannelBuilder, args);
+
+      assertThat(returnedValue).isSameInstanceAs(testChannelBuilder);
+    }
+  }
+
+  @Test
+  public void buildReturnsDelegateBuildByDefault() {
+    ManagedChannel mockChannel = mock(ManagedChannel.class);
+    doReturn(mockChannel).when(mockDelegate).build();
+
+    assertThat(testChannelBuilder.build()).isSameInstanceAs(mockChannel);
+  }
+}
diff --git a/api/src/test/java/io/grpc/ForwardingChannelBuilderTest.java b/api/src/test/java/io/grpc/ForwardingChannelBuilderTest.java
new file mode 100644
index 00000000000..8ea99929f4f
--- /dev/null
+++ b/api/src/test/java/io/grpc/ForwardingChannelBuilderTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2017 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+
+import com.google.common.base.Defaults;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link ForwardingChannelBuilder}.
+ */
+@RunWith(JUnit4.class)
+public class ForwardingChannelBuilderTest {
+  private final ManagedChannelBuilder<?> mockDelegate = mock(ManagedChannelBuilder.class);
+
+  private final ForwardingChannelBuilder<?> testChannelBuilder = new TestBuilder();
+
+  private final class TestBuilder extends ForwardingChannelBuilder<TestBuilder> {
+    @Override
+    @SuppressWarnings("deprecation")
+    protected ManagedChannelBuilder<?> delegate() {
+      return mockDelegate;
+    }
+  }
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        ManagedChannelBuilder.class,
+        mockDelegate,
+        testChannelBuilder,
+        Collections.<Method>emptyList(),
+        new ForwardingTestUtil.ArgumentProvider() {
+          @Override
+          public Object get(Method method, int argPos, Class<?> clazz) {
+            if (method.getName().equals("maxInboundMetadataSize")) {
+              assertThat(argPos).isEqualTo(0);
+              return 1; // an arbitrary positive number
+            }
+            return null;
+          }
+        });
+  }
+
+  @Test
+  public void allBuilderMethodsReturnThis() throws Exception {
+    for (Method method : ManagedChannelBuilder.class.getDeclaredMethods()) {
+      if (Modifier.isStatic(method.getModifiers()) || Modifier.isPrivate(method.getModifiers())) {
+        continue;
+      }
+      if (method.getName().equals("build")) {
+        continue;
+      }
+      Class<?>[] argTypes = method.getParameterTypes();
+      Object[] args = new Object[argTypes.length];
+      for (int i = 0; i < argTypes.length; i++) {
+        args[i] = Defaults.defaultValue(argTypes[i]);
+      }
+      if (method.getName().equals("maxInboundMetadataSize")) {
+        args[0] = 1; // an arbitrary positive number
+      }
+
+      Object returnedValue = method.invoke(testChannelBuilder, args);
+
+      assertThat(returnedValue).isSameInstanceAs(testChannelBuilder);
+    }
+  }
+
+  @Test
+  public void buildReturnsDelegateBuildByDefault() {
+    ManagedChannel mockChannel = mock(ManagedChannel.class);
+    doReturn(mockChannel).when(mockDelegate).build();
+
+    assertThat(testChannelBuilder.build()).isSameInstanceAs(mockChannel);
+  }
+}
diff --git a/api/src/test/java/io/grpc/ForwardingScheduledExecutorService.java b/api/src/test/java/io/grpc/ForwardingScheduledExecutorService.java
new file mode 100644
index 00000000000..d3004222537
--- /dev/null
+++ b/api/src/test/java/io/grpc/ForwardingScheduledExecutorService.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2019 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;
+
+import com.google.common.util.concurrent.ForwardingExecutorService;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Forwards all methods to delegate.
+ */
+abstract class ForwardingScheduledExecutorService extends ForwardingExecutorService
+    implements ScheduledExecutorService {
+  @Override
+  protected abstract ScheduledExecutorService delegate();
+
+  @Override
+  public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
+    return delegate().schedule(callable, delay, unit);
+  }
+
+  @Override
+  public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
+    return delegate().schedule(command, delay, unit);
+  }
+
+  @Override
+  public ScheduledFuture<?> scheduleAtFixedRate(
+      Runnable command, long initialDelay, long period, TimeUnit unit) {
+    return delegate().scheduleAtFixedRate(command, initialDelay, period, unit);
+  }
+
+  @Override
+  public ScheduledFuture<?> scheduleWithFixedDelay(
+      Runnable command, long initialDelay, long delay, TimeUnit unit) {
+    return delegate().scheduleWithFixedDelay(command, initialDelay, delay, unit);
+  }
+}
diff --git a/api/src/test/java/io/grpc/ForwardingServerBuilderTest.java b/api/src/test/java/io/grpc/ForwardingServerBuilderTest.java
new file mode 100644
index 00000000000..d77eeb30d57
--- /dev/null
+++ b/api/src/test/java/io/grpc/ForwardingServerBuilderTest.java
@@ -0,0 +1,85 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+
+import com.google.common.base.Defaults;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link ForwardingServerBuilder}.
+ */
+@RunWith(JUnit4.class)
+public class ForwardingServerBuilderTest {
+  private final ServerBuilder<?> mockDelegate = mock(ServerBuilder.class);
+  private final ForwardingServerBuilder<?> testServerBuilder = new TestBuilder();
+
+  private final class TestBuilder extends ForwardingServerBuilder<TestBuilder> {
+    @Override
+    protected ServerBuilder<?> delegate() {
+      return mockDelegate;
+    }
+  }
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        ServerBuilder.class,
+        mockDelegate,
+        testServerBuilder,
+        Collections.<Method>emptyList());
+  }
+
+  @Test
+  public void allBuilderMethodsReturnThis() throws Exception {
+    for (Method method : ServerBuilder.class.getDeclaredMethods()) {
+      if (Modifier.isStatic(method.getModifiers())
+          || Modifier.isPrivate(method.getModifiers())
+          || Modifier.isFinal(method.getModifiers())) {
+        continue;
+      }
+      if (method.getName().equals("build")) {
+        continue;
+      }
+      Class<?>[] argTypes = method.getParameterTypes();
+      Object[] args = new Object[argTypes.length];
+      for (int i = 0; i < argTypes.length; i++) {
+        args[i] = Defaults.defaultValue(argTypes[i]);
+      }
+
+      Object returnedValue = method.invoke(testServerBuilder, args);
+
+      assertThat(returnedValue).isSameInstanceAs(testServerBuilder);
+    }
+  }
+
+  @Test
+  public void buildReturnsDelegateBuildByDefault() {
+    Server server = mock(Server.class);
+    doReturn(server).when(mockDelegate).build();
+
+    assertThat(testServerBuilder.build()).isSameInstanceAs(server);
+  }
+}
diff --git a/api/src/test/java/io/grpc/ForwardingServerCallListenerTest.java b/api/src/test/java/io/grpc/ForwardingServerCallListenerTest.java
new file mode 100644
index 00000000000..54bef1dea12
--- /dev/null
+++ b/api/src/test/java/io/grpc/ForwardingServerCallListenerTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2015 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;
+
+import static org.mockito.Mockito.verify;
+
+import io.grpc.ForwardingServerCallListener.SimpleForwardingServerCallListener;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Unit tests for {@link ForwardingServerCallListener}.
+ */
+@RunWith(JUnit4.class)
+public class ForwardingServerCallListenerTest {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock private ServerCall.Listener<Integer> serverCallListener;
+  private ForwardingServerCallListener<Integer> forwarder;
+
+  @Before
+  public void setUp() {
+    forwarder = new SimpleForwardingServerCallListener<Integer>(serverCallListener) {};
+  }
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        ServerCall.Listener.class, serverCallListener, forwarder, Collections.<Method>emptyList());
+  }
+
+  @Test
+  public void onMessage() {
+    forwarder.onMessage(12345);
+
+    verify(serverCallListener).onMessage(12345);
+  }
+}
+
diff --git a/api/src/test/java/io/grpc/ForwardingServerCallTest.java b/api/src/test/java/io/grpc/ForwardingServerCallTest.java
new file mode 100644
index 00000000000..8030b65ecc7
--- /dev/null
+++ b/api/src/test/java/io/grpc/ForwardingServerCallTest.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2023 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;
+
+import static org.mockito.Mockito.verify;
+
+import java.lang.reflect.Method;
+import java.util.Collections;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Unit tests for {@link ForwardingServerCall}.
+ */
+@RunWith(JUnit4.class)
+public class ForwardingServerCallTest {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock private ServerCall<Integer, Integer> serverCall;
+  private ForwardingServerCall<Integer, Integer> forwarder;
+
+  @Before
+  public void setUp() {
+    forwarder =
+        new ForwardingServerCall<Integer, Integer>() {
+          @Override
+          protected ServerCall<Integer, Integer> delegate() {
+            return serverCall;
+          }
+        };
+  }
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        ServerCall.class, serverCall, forwarder, Collections.<Method>emptyList());
+  }
+
+  @Test
+  public void sendMessage() {
+    forwarder.sendMessage(12345);
+
+    verify(serverCall).sendMessage(12345);
+  }
+}
+
diff --git a/api/src/test/java/io/grpc/HttpConnectProxiedSocketAddressTest.java b/api/src/test/java/io/grpc/HttpConnectProxiedSocketAddressTest.java
new file mode 100644
index 00000000000..6620a7d413a
--- /dev/null
+++ b/api/src/test/java/io/grpc/HttpConnectProxiedSocketAddressTest.java
@@ -0,0 +1,248 @@
+/*
+ * Copyright 2025 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertThrows;
+
+import com.google.common.testing.EqualsTester;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class HttpConnectProxiedSocketAddressTest {
+
+  private final InetSocketAddress proxyAddress = 
+      new InetSocketAddress(InetAddress.getLoopbackAddress(), 8080);
+  private final InetSocketAddress targetAddress = 
+      InetSocketAddress.createUnresolved("example.com", 443);
+
+  @Test
+  public void buildWithAllFields() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put("X-Custom-Header", "custom-value");
+    headers.put("Proxy-Authorization", "Bearer token");
+
+    HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+        .setProxyAddress(proxyAddress)
+        .setTargetAddress(targetAddress)
+        .setHeaders(headers)
+        .setUsername("user")
+        .setPassword("pass")
+        .build();
+
+    assertThat(address.getProxyAddress()).isEqualTo(proxyAddress);
+    assertThat(address.getTargetAddress()).isEqualTo(targetAddress);
+    assertThat(address.getHeaders()).hasSize(2);
+    assertThat(address.getHeaders()).containsEntry("X-Custom-Header", "custom-value");
+    assertThat(address.getHeaders()).containsEntry("Proxy-Authorization", "Bearer token");
+    assertThat(address.getUsername()).isEqualTo("user");
+    assertThat(address.getPassword()).isEqualTo("pass");
+  }
+
+  @Test
+  public void buildWithoutOptionalFields() {
+    HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+        .setProxyAddress(proxyAddress)
+        .setTargetAddress(targetAddress)
+        .build();
+
+    assertThat(address.getProxyAddress()).isEqualTo(proxyAddress);
+    assertThat(address.getTargetAddress()).isEqualTo(targetAddress);
+    assertThat(address.getHeaders()).isEmpty();
+    assertThat(address.getUsername()).isNull();
+    assertThat(address.getPassword()).isNull();
+  }
+
+  @Test
+  public void buildWithEmptyHeaders() {
+    HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+        .setProxyAddress(proxyAddress)
+        .setTargetAddress(targetAddress)
+        .setHeaders(Collections.emptyMap())
+        .build();
+
+    assertThat(address.getHeaders()).isEmpty();
+  }
+
+  @Test
+  public void headersAreImmutable() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put("key1", "value1");
+
+    HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+        .setProxyAddress(proxyAddress)
+        .setTargetAddress(targetAddress)
+        .setHeaders(headers)
+        .build();
+
+    headers.put("key2", "value2");
+
+    assertThat(address.getHeaders()).hasSize(1);
+    assertThat(address.getHeaders()).containsEntry("key1", "value1");
+    assertThat(address.getHeaders()).doesNotContainKey("key2");
+  }
+
+  @Test
+  public void returnedHeadersAreUnmodifiable() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put("key", "value");
+
+    HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+        .setProxyAddress(proxyAddress)
+        .setTargetAddress(targetAddress)
+        .setHeaders(headers)
+        .build();
+
+    assertThrows(UnsupportedOperationException.class,
+        () -> address.getHeaders().put("newKey", "newValue"));
+  }
+
+  @Test
+  public void nullHeadersThrowsException() {
+    assertThrows(NullPointerException.class,
+        () -> HttpConnectProxiedSocketAddress.newBuilder()
+            .setProxyAddress(proxyAddress)
+            .setTargetAddress(targetAddress)
+            .setHeaders(null)
+            .build());
+  }
+
+  @Test
+  public void equalsAndHashCode() {
+    Map<String, String> headers1 = new HashMap<>();
+    headers1.put("header", "value");
+
+    Map<String, String> headers2 = new HashMap<>();
+    headers2.put("header", "value");
+
+    Map<String, String> differentHeaders = new HashMap<>();
+    differentHeaders.put("different", "header");
+
+    new EqualsTester()
+        .addEqualityGroup(
+            HttpConnectProxiedSocketAddress.newBuilder()
+                .setProxyAddress(proxyAddress)
+                .setTargetAddress(targetAddress)
+                .setHeaders(headers1)
+                .setUsername("user")
+                .setPassword("pass")
+                .build(),
+            HttpConnectProxiedSocketAddress.newBuilder()
+                .setProxyAddress(proxyAddress)
+                .setTargetAddress(targetAddress)
+                .setHeaders(headers2)
+                .setUsername("user")
+                .setPassword("pass")
+                .build())
+        .addEqualityGroup(
+            HttpConnectProxiedSocketAddress.newBuilder()
+                .setProxyAddress(proxyAddress)
+                .setTargetAddress(targetAddress)
+                .setHeaders(differentHeaders)
+                .setUsername("user")
+                .setPassword("pass")
+                .build())
+        .addEqualityGroup(
+            HttpConnectProxiedSocketAddress.newBuilder()
+                .setProxyAddress(proxyAddress)
+                .setTargetAddress(targetAddress)
+                .build())
+        .testEquals();
+  }
+
+  @Test
+  public void toStringContainsHeaders() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put("X-Test", "test-value");
+
+    HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+        .setProxyAddress(proxyAddress)
+        .setTargetAddress(targetAddress)
+        .setHeaders(headers)
+        .setUsername("user")
+        .setPassword("secret")
+        .build();
+
+    String toString = address.toString();
+    assertThat(toString).contains("headers");
+    assertThat(toString).contains("X-Test");
+    assertThat(toString).contains("hasPassword=true");
+    assertThat(toString).doesNotContain("secret");
+  }
+
+  @Test
+  public void toStringWithoutPassword() {
+    HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+        .setProxyAddress(proxyAddress)
+        .setTargetAddress(targetAddress)
+        .build();
+
+    String toString = address.toString();
+    assertThat(toString).contains("hasPassword=false");
+  }
+
+  @Test
+  public void hashCodeDependsOnHeaders() {
+    Map<String, String> headers1 = new HashMap<>();
+    headers1.put("header", "value1");
+
+    Map<String, String> headers2 = new HashMap<>();
+    headers2.put("header", "value2");
+
+    HttpConnectProxiedSocketAddress address1 = HttpConnectProxiedSocketAddress.newBuilder()
+        .setProxyAddress(proxyAddress)
+        .setTargetAddress(targetAddress)
+        .setHeaders(headers1)
+        .build();
+
+    HttpConnectProxiedSocketAddress address2 = HttpConnectProxiedSocketAddress.newBuilder()
+        .setProxyAddress(proxyAddress)
+        .setTargetAddress(targetAddress)
+        .setHeaders(headers2)
+        .build();
+
+    assertNotEquals(address1.hashCode(), address2.hashCode());
+  }
+
+  @Test
+  public void multipleHeadersSupported() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put("X-Header-1", "value1");
+    headers.put("X-Header-2", "value2");
+    headers.put("X-Header-3", "value3");
+
+    HttpConnectProxiedSocketAddress address = HttpConnectProxiedSocketAddress.newBuilder()
+        .setProxyAddress(proxyAddress)
+        .setTargetAddress(targetAddress)
+        .setHeaders(headers)
+        .build();
+
+    assertThat(address.getHeaders()).hasSize(3);
+    assertThat(address.getHeaders()).containsEntry("X-Header-1", "value1");
+    assertThat(address.getHeaders()).containsEntry("X-Header-2", "value2");
+    assertThat(address.getHeaders()).containsEntry("X-Header-3", "value3");
+  }
+}
+
diff --git a/api/src/test/java/io/grpc/InsecureChannelCredentialsTest.java b/api/src/test/java/io/grpc/InsecureChannelCredentialsTest.java
new file mode 100644
index 00000000000..8d6504a0bed
--- /dev/null
+++ b/api/src/test/java/io/grpc/InsecureChannelCredentialsTest.java
@@ -0,0 +1,33 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link InsecureChannelCredentials}. */
+@RunWith(JUnit4.class)
+public class InsecureChannelCredentialsTest {
+  @Test
+  public void withoutBearTokenGivesItself() {
+    ChannelCredentials insecureCreds = InsecureChannelCredentials.create();
+    assertThat(insecureCreds.withoutBearerTokens()).isEqualTo(insecureCreds);
+  }
+}
diff --git a/api/src/test/java/io/grpc/InternalChannelzTest.java b/api/src/test/java/io/grpc/InternalChannelzTest.java
new file mode 100644
index 00000000000..c000ad2ad12
--- /dev/null
+++ b/api/src/test/java/io/grpc/InternalChannelzTest.java
@@ -0,0 +1,318 @@
+/*
+ * Copyright 2018 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.InternalChannelz.id;
+import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import io.grpc.InternalChannelz.ChannelStats;
+import io.grpc.InternalChannelz.RootChannelList;
+import io.grpc.InternalChannelz.ServerList;
+import io.grpc.InternalChannelz.ServerSocketsList;
+import io.grpc.InternalChannelz.ServerStats;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalChannelz.Tls;
+import java.security.cert.Certificate;
+import javax.net.ssl.SSLSession;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class InternalChannelzTest {
+
+  private final InternalChannelz channelz = new InternalChannelz();
+
+  @Test
+  public void getRootChannels_empty() {
+    RootChannelList rootChannels = channelz.getRootChannels(/*fromId=*/ 0, /*maxPageSize=*/ 1);
+    assertTrue(rootChannels.end);
+    assertThat(rootChannels.channels).isEmpty();
+  }
+
+  @Test
+  public void getRootChannels_onePage() {
+    InternalInstrumented<ChannelStats> root1 = create();
+    channelz.addRootChannel(root1);
+    RootChannelList page = channelz.getRootChannels(/*fromId=*/ 0, /*maxPageSize=*/ 1);
+    assertTrue(page.end);
+    assertThat(page.channels).containsExactly(root1);
+  }
+
+  @Test
+  public void getRootChannels_onePage_multi() {
+    InternalInstrumented<ChannelStats> root1 = create();
+    InternalInstrumented<ChannelStats> root2 = create();
+    channelz.addRootChannel(root1);
+    channelz.addRootChannel(root2);
+    RootChannelList page = channelz.getRootChannels(/*fromId=*/ 0, /*maxPageSize=*/ 2);
+    assertTrue(page.end);
+    assertThat(page.channels).containsExactly(root1, root2);
+  }
+
+  @Test
+  public void getRootChannels_paginate() {
+    InternalInstrumented<ChannelStats> root1 = create();
+    InternalInstrumented<ChannelStats> root2 = create();
+    channelz.addRootChannel(root1);
+    channelz.addRootChannel(root2);
+    RootChannelList page1 = channelz.getRootChannels(/*fromId=*/ 0, /*maxPageSize=*/ 1);
+    assertFalse(page1.end);
+    assertThat(page1.channels).containsExactly(root1);
+    RootChannelList page2
+        = channelz.getRootChannels(/*fromId=*/ id(root1) + 1, /*maxPageSize=*/ 1);
+    assertTrue(page2.end);
+    assertThat(page2.channels).containsExactly(root2);
+  }
+
+  @Test
+  public void getRootChannels_remove() {
+    InternalInstrumented<ChannelStats> root1 = create();
+    channelz.addRootChannel(root1);
+    channelz.removeRootChannel(root1);
+    RootChannelList page = channelz.getRootChannels(/*fromId=*/ 0, /*maxPageSize=*/ 1);
+    assertTrue(page.end);
+    assertThat(page.channels).isEmpty();
+  }
+
+  @Test
+  public void getRootChannels_addAfterLastPage() {
+    InternalInstrumented<ChannelStats> root1 = create();
+    {
+      channelz.addRootChannel(root1);
+      RootChannelList page1 = channelz.getRootChannels(/*fromId=*/ 0, /*maxPageSize=*/ 1);
+      assertTrue(page1.end);
+      assertThat(page1.channels).containsExactly(root1);
+    }
+
+    InternalInstrumented<ChannelStats> root2 = create();
+    {
+      channelz.addRootChannel(root2);
+      RootChannelList page2
+          = channelz.getRootChannels(/*fromId=*/ id(root1) + 1, /*maxPageSize=*/ 1);
+      assertTrue(page2.end);
+      assertThat(page2.channels).containsExactly(root2);
+    }
+  }
+
+  @Test
+  public void getServers_empty() {
+    ServerList servers = channelz.getServers(/*fromId=*/ 0, /*maxPageSize=*/ 1);
+    assertTrue(servers.end);
+    assertThat(servers.servers).isEmpty();
+  }
+
+  @Test
+  public void getServers_onePage() {
+    InternalInstrumented<ServerStats> server1 = create();
+    channelz.addServer(server1);
+    ServerList page = channelz.getServers(/*fromId=*/ 0, /*maxPageSize=*/ 1);
+    assertTrue(page.end);
+    assertThat(page.servers).containsExactly(server1);
+  }
+
+  @Test
+  public void getServers_onePage_multi() {
+    InternalInstrumented<ServerStats> server1 = create();
+    InternalInstrumented<ServerStats> server2 = create();
+    channelz.addServer(server1);
+    channelz.addServer(server2);
+    ServerList page = channelz.getServers(/*fromId=*/ 0, /*maxPageSize=*/ 2);
+    assertTrue(page.end);
+    assertThat(page.servers).containsExactly(server1, server2);
+  }
+
+  @Test
+  public void getServers_paginate() {
+    InternalInstrumented<ServerStats> server1 = create();
+    InternalInstrumented<ServerStats> server2 = create();
+    channelz.addServer(server1);
+    channelz.addServer(server2);
+    ServerList page1 = channelz.getServers(/*fromId=*/ 0, /*maxPageSize=*/ 1);
+    assertFalse(page1.end);
+    assertThat(page1.servers).containsExactly(server1);
+    ServerList page2
+        = channelz.getServers(/*fromId=*/ id(server1) + 1, /*maxPageSize=*/ 1);
+    assertTrue(page2.end);
+    assertThat(page2.servers).containsExactly(server2);
+  }
+
+  @Test
+  public void getServers_remove() {
+    InternalInstrumented<ServerStats> server1 = create();
+    channelz.addServer(server1);
+    channelz.removeServer(server1);
+    ServerList page = channelz.getServers(/*fromId=*/ 0, /*maxPageSize=*/ 1);
+    assertTrue(page.end);
+    assertThat(page.servers).isEmpty();
+  }
+
+  @Test
+  public void getServers_addAfterLastPage() {
+    InternalInstrumented<ServerStats> server1 = create();
+    {
+      channelz.addServer(server1);
+      ServerList page = channelz.getServers(/*fromId=*/ 0, /*maxPageSize=*/ 1);
+      assertTrue(page.end);
+      assertThat(page.servers).containsExactly(server1);
+    }
+
+    InternalInstrumented<ServerStats> server2 = create();
+    {
+      channelz.addServer(server2);
+      ServerList page
+          = channelz.getServers(/*fromId=*/ id(server1) + 1, /*maxPageSize=*/ 1);
+      assertTrue(page.end);
+      assertThat(page.servers).containsExactly(server2);
+    }
+  }
+
+  @Test
+  public void getChannel() {
+    InternalInstrumented<ChannelStats> root = create();
+    assertNull(channelz.getChannel(id(root)));
+
+    channelz.addRootChannel(root);
+    assertSame(root, channelz.getChannel(id(root)));
+    assertNull(channelz.getSubchannel(id(root)));
+
+    channelz.removeRootChannel(root);
+    assertNull(channelz.getRootChannel(id(root)));
+  }
+
+  @Test
+  public void getSubchannel() {
+    InternalInstrumented<ChannelStats> sub = create();
+    assertNull(channelz.getSubchannel(id(sub)));
+
+    channelz.addSubchannel(sub);
+    assertSame(sub, channelz.getSubchannel(id(sub)));
+    assertNull(channelz.getChannel(id(sub)));
+
+    channelz.removeSubchannel(sub);
+    assertNull(channelz.getSubchannel(id(sub)));
+  }
+
+  @Test
+  public void getSocket() {
+    InternalInstrumented<SocketStats> socket = create();
+    assertNull(channelz.getSocket(id(socket)));
+
+    channelz.addClientSocket(socket);
+    assertSame(socket, channelz.getSocket(id(socket)));
+
+    channelz.removeClientSocket(socket);
+    assertNull(channelz.getSocket(id(socket)));
+  }
+
+  @Test
+  public void serverSocket_noServer() {
+    assertNull(channelz.getServerSockets(/*serverId=*/ 1, /*fromId=*/0, /*maxPageSize=*/ 1));
+  }
+
+  @Test
+  public void serverSocket() {
+    InternalInstrumented<ServerStats> server = create();
+    channelz.addServer(server);
+
+    InternalInstrumented<SocketStats> socket = create();
+    assertEmptyServerSocketsPage(id(server), id(socket));
+
+    channelz.addServerSocket(server, socket);
+    ServerSocketsList page
+        = channelz.getServerSockets(id(server), id(socket), /*maxPageSize=*/ 1);
+    assertNotNull(page);
+    assertTrue(page.end);
+    assertThat(page.sockets).containsExactly(socket);
+
+    channelz.removeServerSocket(server, socket);
+    assertEmptyServerSocketsPage(id(server), id(socket));
+  }
+
+  @Test
+  public void serverSocket_eachServerSeparate() {
+    InternalInstrumented<ServerStats> server1 = create();
+    InternalInstrumented<ServerStats> server2 = create();
+
+    InternalInstrumented<SocketStats> socket1 = create();
+    InternalInstrumented<SocketStats> socket2 = create();
+
+    channelz.addServer(server1);
+    channelz.addServer(server2);
+    channelz.addServerSocket(server1, socket1);
+    channelz.addServerSocket(server2, socket2);
+
+    ServerSocketsList list1
+        = channelz.getServerSockets(id(server1), /*fromId=*/ 0, /*maxPageSize=*/ 2);
+    assertNotNull(list1);
+    assertTrue(list1.end);
+    assertThat(list1.sockets).containsExactly(socket1);
+
+    ServerSocketsList list2
+        = channelz.getServerSockets(id(server2), /*fromId=*/ 0, /*maxPageSize=*/2);
+    assertNotNull(list2);
+    assertTrue(list2.end);
+    assertThat(list2.sockets).containsExactly(socket2);
+  }
+
+  @Test
+  public void tlsSecurityInfo() throws Exception {
+    Certificate local = io.grpc.internal.testing.TestUtils.loadX509Cert("client.pem");
+    Certificate remote = io.grpc.internal.testing.TestUtils.loadX509Cert("server0.pem");
+    final SSLSession session = mock(SSLSession.class);
+    when(session.getCipherSuite()).thenReturn("TLS_NULL_WITH_NULL_NULL");
+    when(session.getLocalCertificates()).thenReturn(new Certificate[]{local});
+    when(session.getPeerCertificates()).thenReturn(new Certificate[]{remote});
+
+    Tls tls = new Tls(session);
+    assertEquals(local, tls.localCert);
+    assertEquals(remote, tls.remoteCert);
+    assertEquals("TLS_NULL_WITH_NULL_NULL", tls.cipherSuiteStandardName);
+  }
+
+  private void assertEmptyServerSocketsPage(long serverId, long socketId) {
+    ServerSocketsList emptyPage
+        = channelz.getServerSockets(serverId, socketId, /*maxPageSize=*/ 1);
+    assertNotNull(emptyPage);
+    assertTrue(emptyPage.end);
+    assertThat(emptyPage.sockets).isEmpty();
+  }
+
+  private static <T> InternalInstrumented<T> create() {
+    return new InternalInstrumented<T>() {
+      final InternalLogId id = InternalLogId.allocate("fake-type", /*details=*/ null);
+      @Override
+      public ListenableFuture<T> getStats() {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override
+      public InternalLogId getLogId() {
+        return id;
+      }
+    };
+  }
+}
diff --git a/api/src/test/java/io/grpc/InternalConfigSelectorTest.java b/api/src/test/java/io/grpc/InternalConfigSelectorTest.java
new file mode 100644
index 00000000000..4eeac64fd8c
--- /dev/null
+++ b/api/src/test/java/io/grpc/InternalConfigSelectorTest.java
@@ -0,0 +1,50 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.InternalConfigSelector.Result;
+import io.grpc.Status.Code;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link InternalConfigSelector}. */
+@RunWith(JUnit4.class)
+public class InternalConfigSelectorTest {
+  @Test
+  public void resultBuilder() {
+    Object config = "fake_config";
+    InternalConfigSelector.Result.Builder builder = InternalConfigSelector.Result.newBuilder();
+    ClientInterceptor interceptor = mock(ClientInterceptor.class);
+    InternalConfigSelector.Result result =
+        builder.setConfig(config).setInterceptor(interceptor).build();
+    assertThat(result.getStatus().isOk()).isTrue();
+    assertThat(result.getConfig()).isEqualTo(config);
+    assertThat(result.getInterceptor()).isSameInstanceAs(interceptor);
+  }
+
+  @Test
+  public void errorResult() {
+    Result result = Result.forError(Status.INTERNAL.withDescription("failed"));
+    assertThat(result.getStatus().isOk()).isFalse();
+    assertThat(result.getStatus().getCode()).isEqualTo(Code.INTERNAL);
+    assertThat(result.getStatus().getDescription()).isEqualTo("failed");
+  }
+}
diff --git a/api/src/test/java/io/grpc/InternalLogIdTest.java b/api/src/test/java/io/grpc/InternalLogIdTest.java
new file mode 100644
index 00000000000..bdf2511d12a
--- /dev/null
+++ b/api/src/test/java/io/grpc/InternalLogIdTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2018 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;
+
+import com.google.common.truth.Truth;
+import java.io.Serializable;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class InternalLogIdTest {
+  
+  private static final String NO_DETAILS = null;
+
+  @Test
+  public void shortName() {
+    InternalLogId name = InternalLogId.allocate("foo", NO_DETAILS);
+    Truth.assertThat(name.shortName()).matches("foo<\\d+>");
+  }
+
+  @Test
+  public void toString_includesDetails() {
+    InternalLogId name = InternalLogId.allocate("foo", "deets");
+    Truth.assertThat(name.toString()).matches("foo<\\d+>: \\(deets\\)");
+  }
+
+  @Test
+  public void shortClassName() {
+    InternalLogId name = InternalLogId.allocate(getClass(), "deets");
+    Truth.assertThat(name.toString()).matches("InternalLogIdTest<\\d+>: \\(deets\\)");
+  }
+
+  @Test
+  public void shortAnonymousClassName() {
+    InternalLogId name = InternalLogId.allocate(new Serializable() {}.getClass(), "deets");
+    Truth.assertThat(name.toString()).matches("InternalLogIdTest\\$\\d+<\\d+>: \\(deets\\)");
+  }
+}
diff --git a/api/src/test/java/io/grpc/LoadBalancerRegistryTest.java b/api/src/test/java/io/grpc/LoadBalancerRegistryTest.java
new file mode 100644
index 00000000000..690db6622e0
--- /dev/null
+++ b/api/src/test/java/io/grpc/LoadBalancerRegistryTest.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright 2018 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import io.grpc.internal.PickFirstLoadBalancerProvider;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link LoadBalancerRegistry}. */
+@RunWith(JUnit4.class)
+public class LoadBalancerRegistryTest {
+  @Test
+  public void getClassesViaHardcoded_classesPresent() throws Exception {
+    List<Class<?>> classes = LoadBalancerRegistry.getHardCodedClasses();
+    assertThat(classes).hasSize(2);
+    assertThat(classes.get(0)).isEqualTo(PickFirstLoadBalancerProvider.class);
+    assertThat(classes.get(1).getName()).isEqualTo(
+        "io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider");
+  }
+
+  @Test
+  public void stockProviders() {
+    LoadBalancerRegistry defaultRegistry = LoadBalancerRegistry.getDefaultRegistry();
+    assertThat(defaultRegistry.providers()).hasSize(4);
+
+    LoadBalancerProvider pickFirst = defaultRegistry.getProvider("pick_first");
+    assertThat(pickFirst).isInstanceOf(PickFirstLoadBalancerProvider.class);
+    assertThat(pickFirst.getPriority()).isEqualTo(5);
+
+    LoadBalancerProvider roundRobin = defaultRegistry.getProvider("round_robin");
+    assertThat(roundRobin.getClass().getName()).isEqualTo(
+        "io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider");
+    assertThat(roundRobin.getPriority()).isEqualTo(5);
+
+    LoadBalancerProvider outlierDetection = defaultRegistry.getProvider(
+        "outlier_detection_experimental");
+    assertThat(outlierDetection.getClass().getName()).isEqualTo(
+        "io.grpc.util.OutlierDetectionLoadBalancerProvider");
+    assertThat(roundRobin.getPriority()).isEqualTo(5);
+
+    LoadBalancerProvider randomSubsetting = defaultRegistry.getProvider(
+        "random_subsetting_experimental");
+    assertThat(randomSubsetting.getClass().getName()).isEqualTo(
+        "io.grpc.util.RandomSubsettingLoadBalancerProvider");
+    assertThat(randomSubsetting.getPriority()).isEqualTo(5);
+  }
+
+  @Test
+  public void unavilableProviderThrows() {
+    LoadBalancerRegistry reg = new LoadBalancerRegistry();
+    try {
+      reg.register(new FakeProvider("great", 5, false));
+      fail("Should throw");
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage()).contains("isAvailable() returned false");
+    }
+    assertThat(reg.getProvider("great")).isNull();
+  }
+
+  @Test
+  public void registerAndDeregister() {
+    LoadBalancerProvider[] providers = new LoadBalancerProvider[] {
+      new FakeProvider("cool", 5, true),
+      new FakeProvider("cool", 6, true),
+      new FakeProvider("great", 5, true),
+      new FakeProvider("great", 4, true),
+      new FakeProvider("excellent", 5, true),
+      new FakeProvider("excellent", 5, true)};
+    LoadBalancerRegistry reg = new LoadBalancerRegistry();
+    for (LoadBalancerProvider provider : providers) {
+      reg.register(provider);
+    }
+
+    assertThat(reg.providers()).hasSize(3);
+    assertThat(reg.getProvider("cool")).isSameInstanceAs(providers[1]);
+    assertThat(reg.getProvider("great")).isSameInstanceAs(providers[2]);
+    assertThat(reg.getProvider("excellent")).isSameInstanceAs(providers[4]);
+
+    reg.deregister(providers[1]);
+    assertThat(reg.getProvider("cool")).isSameInstanceAs(providers[0]);
+    reg.deregister(providers[2]);
+    assertThat(reg.getProvider("great")).isSameInstanceAs(providers[3]);
+    reg.deregister(providers[4]);
+    assertThat(reg.getProvider("excellent")).isSameInstanceAs(providers[5]);
+  }
+
+  private static class FakeProvider extends LoadBalancerProvider {
+    final String policy;
+    final int priority;
+    final boolean isAvailable;
+
+    FakeProvider(String policy, int priority, boolean isAvailable) {
+      this.policy = policy;
+      this.priority = priority;
+      this.isAvailable = isAvailable;
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return isAvailable;
+    }
+
+    @Override
+    public int getPriority() {
+      return priority;
+    }
+
+    @Override
+    public String getPolicyName() {
+      return policy;
+    }
+
+    @Override
+    public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+      throw new AssertionError("Should not be called in test");
+    }
+  }
+}
diff --git a/api/src/test/java/io/grpc/LoadBalancerTest.java b/api/src/test/java/io/grpc/LoadBalancerTest.java
new file mode 100644
index 00000000000..5e9e5cbe816
--- /dev/null
+++ b/api/src/test/java/io/grpc/LoadBalancerTest.java
@@ -0,0 +1,365 @@
+/*
+ * Copyright 2017 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for the inner classes in {@link LoadBalancer}. */
+@RunWith(JUnit4.class)
+public class LoadBalancerTest {
+  private final Subchannel subchannel = mock(Subchannel.class);
+  private final Subchannel subchannel2 = mock(Subchannel.class);
+  private final ClientStreamTracer.Factory tracerFactory = mock(ClientStreamTracer.Factory.class);
+  private final Status status = Status.UNAVAILABLE.withDescription("for test");
+  private final Status status2 = Status.UNAVAILABLE.withDescription("for test 2");
+  private final EquivalentAddressGroup eag = new EquivalentAddressGroup(new SocketAddress() {});
+  private final Attributes attrs = Attributes.newBuilder()
+      .set(Attributes.Key.create("trash"), new Object())
+      .build();
+
+  @Test
+  public void pickResult_withSubchannel() {
+    PickResult result = PickResult.withSubchannel(subchannel);
+    assertThat(result.getSubchannel()).isSameInstanceAs(subchannel);
+    assertThat(result.getStatus()).isSameInstanceAs(Status.OK);
+    assertThat(result.getStreamTracerFactory()).isNull();
+    assertThat(result.isDrop()).isFalse();
+  }
+
+  @Test
+  public void pickResult_withSubchannelAndTracer() {
+    PickResult result = PickResult.withSubchannel(subchannel, tracerFactory);
+    assertThat(result.getSubchannel()).isSameInstanceAs(subchannel);
+    assertThat(result.getStatus()).isSameInstanceAs(Status.OK);
+    assertThat(result.getStreamTracerFactory()).isSameInstanceAs(tracerFactory);
+    assertThat(result.isDrop()).isFalse();
+  }
+
+  @Test
+  public void pickResult_withNoResult() {
+    PickResult result = PickResult.withNoResult();
+    assertThat(result.getSubchannel()).isNull();
+    assertThat(result.getStatus()).isSameInstanceAs(Status.OK);
+    assertThat(result.getStreamTracerFactory()).isNull();
+    assertThat(result.isDrop()).isFalse();
+  }
+
+  @Test
+  public void pickResult_withError() {
+    PickResult result = PickResult.withError(status);
+    assertThat(result.getSubchannel()).isNull();
+    assertThat(result.getStatus()).isSameInstanceAs(status);
+    assertThat(result.getStreamTracerFactory()).isNull();
+    assertThat(result.isDrop()).isFalse();
+  }
+
+  @Test
+  public void pickResult_withDrop() {
+    PickResult result = PickResult.withDrop(status);
+    assertThat(result.getSubchannel()).isNull();
+    assertThat(result.getStatus()).isSameInstanceAs(status);
+    assertThat(result.getStreamTracerFactory()).isNull();
+    assertThat(result.isDrop()).isTrue();
+  }
+
+  @Test
+  public void pickResult_equals() {
+    PickResult sc1 = PickResult.withSubchannel(subchannel);
+    PickResult sc2 = PickResult.withSubchannel(subchannel);
+    PickResult sc3 = PickResult.withSubchannel(subchannel, tracerFactory);
+    PickResult sc4 = PickResult.withSubchannel(subchannel2);
+    PickResult nr = PickResult.withNoResult();
+    PickResult error1 = PickResult.withError(status);
+    PickResult error2 = PickResult.withError(status2);
+    PickResult error3 = PickResult.withError(status2);
+    PickResult drop1 = PickResult.withDrop(status);
+    PickResult drop2 = PickResult.withDrop(status);
+    PickResult drop3 = PickResult.withDrop(status2);
+
+    assertThat(sc1).isNotEqualTo(nr);
+    assertThat(sc1).isNotEqualTo(error1);
+    assertThat(sc1).isNotEqualTo(drop1);
+    assertThat(sc1).isEqualTo(sc2);
+    assertThat(sc1).isNotEqualTo(sc3);
+    assertThat(sc1).isNotEqualTo(sc4);
+
+    assertThat(error1).isNotEqualTo(error2);
+    assertThat(error2).isEqualTo(error3);
+
+    assertThat(drop1).isEqualTo(drop2);
+    assertThat(drop1).isNotEqualTo(drop3);
+
+    assertThat(error1.getStatus()).isEqualTo(drop1.getStatus());
+    assertThat(error1).isNotEqualTo(drop1);
+  }
+
+  @Test
+  public void helper_createSubchannelList_throws() {
+    try {
+      new NoopHelper().createSubchannel(CreateSubchannelArgs.newBuilder()
+          .setAddresses(eag)
+          .setAttributes(attrs)
+          .build());
+      fail("Should throw");
+    } catch (UnsupportedOperationException e) {
+      // expected
+    }
+  }
+
+  @Test
+  public void subchannel_getAddresses_delegates() {
+    class OverrideGetAllAddresses extends EmptySubchannel {
+      boolean ran;
+
+      @Override public List<EquivalentAddressGroup> getAllAddresses() {
+        ran = true;
+        return Arrays.asList(eag);
+      }
+    }
+
+    OverrideGetAllAddresses subchannel = new OverrideGetAllAddresses();
+    assertThat(subchannel.getAddresses()).isEqualTo(eag);
+    assertThat(subchannel.ran).isTrue();
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void subchannel_getAddresses_throwsOnTwoAddrs() {
+    new EmptySubchannel() {
+      boolean ran;
+
+      @Override public List<EquivalentAddressGroup> getAllAddresses() {
+        ran = true;
+        // Doubling up eag is technically a bad idea, but nothing here cares
+        return Arrays.asList(eag, eag);
+      }
+    }.getAddresses();
+  }
+
+  @Test
+  public void createSubchannelArgs_option_keyOps() {
+    CreateSubchannelArgs.Key<String> testKey = CreateSubchannelArgs.Key.create("test-key");
+    String testValue = "test-value";
+    CreateSubchannelArgs.Key<String> testWithDefaultKey = CreateSubchannelArgs.Key
+        .createWithDefault("test-key", testValue);
+    CreateSubchannelArgs args = CreateSubchannelArgs.newBuilder()
+        .setAddresses(eag)
+        .setAttributes(attrs)
+        .build();
+    assertThat(args.getOption(testKey)).isNull();
+    assertThat(args.getOption(testWithDefaultKey)).isSameInstanceAs(testValue);
+  }
+
+  @Test
+  public void createSubchannelArgs_option_addGet() {
+    String testValue = "test-value";
+    CreateSubchannelArgs.Key<String> testKey = CreateSubchannelArgs.Key.create("test-key");
+    CreateSubchannelArgs args = CreateSubchannelArgs.newBuilder()
+        .setAddresses(eag)
+        .setAttributes(attrs)
+        .addOption(testKey, testValue)
+        .build();
+    assertThat(args.getOption(testKey)).isEqualTo(testValue);
+  }
+
+  @Test
+  public void createSubchannelArgs_option_lastOneWins() {
+    String testValue1 = "test-value-1";
+    String testValue2 = "test-value-2";
+    CreateSubchannelArgs.Key<String> testKey = CreateSubchannelArgs.Key.create("test-key");
+    CreateSubchannelArgs args = CreateSubchannelArgs.newBuilder()
+        .setAddresses(eag)
+        .setAttributes(attrs)
+        .addOption(testKey, testValue1)
+        .addOption(testKey, testValue2)
+        .build();
+    assertThat(args.getOption(testKey)).isEqualTo(testValue2);
+  }
+
+  @Test
+  public void createSubchannelArgs_build() {
+    CreateSubchannelArgs.Key<Object> testKey = CreateSubchannelArgs.Key.create("test-key");
+    Object testValue = new Object();
+    CreateSubchannelArgs args = CreateSubchannelArgs.newBuilder()
+        .setAddresses(eag)
+        .setAttributes(attrs)
+        .addOption(testKey, testValue)
+        .build();
+    CreateSubchannelArgs rebuildedArgs = args.toBuilder().build();
+    assertThat(rebuildedArgs.getAddresses()).containsExactly(eag);
+    assertThat(rebuildedArgs.getAttributes()).isSameInstanceAs(attrs);
+    assertThat(rebuildedArgs.getOption(testKey)).isSameInstanceAs(testValue);
+  }
+
+  @Test
+  public void createSubchannelArgs_toString() {
+    CreateSubchannelArgs.Key<String> testKey = CreateSubchannelArgs.Key.create("test-key");
+    CreateSubchannelArgs args = CreateSubchannelArgs.newBuilder()
+        .setAddresses(eag)
+        .setAttributes(attrs)
+        .addOption(testKey, "test-value")
+        .build();
+    String str = args.toString();
+    assertThat(str).contains("addrs=");
+    assertThat(str).contains("attrs=");
+    assertThat(str).contains("customOptions=");
+  }
+
+  @Deprecated
+  @Test
+  public void handleResolvedAddresses_delegatesToAcceptResolvedAddresses() {
+    final AtomicReference<ResolvedAddresses> resultCapture = new AtomicReference<>();
+
+    LoadBalancer balancer = new LoadBalancer() {
+        @Override
+        public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+          resultCapture.set(resolvedAddresses);
+          return Status.OK;
+        }
+
+        @Override
+        public void handleNameResolutionError(Status error) {
+        }
+
+        @Override
+        public void handleSubchannelState(Subchannel subchannel, ConnectivityStateInfo state) {
+        }
+
+        @Override
+        public void shutdown() {
+        }
+      };
+
+    List<EquivalentAddressGroup> servers = Arrays.asList(
+        new EquivalentAddressGroup(new SocketAddress(){}),
+        new EquivalentAddressGroup(new SocketAddress(){}));
+    ResolvedAddresses addresses = ResolvedAddresses.newBuilder().setAddresses(servers)
+        .setAttributes(attrs).build();
+    balancer.handleResolvedAddresses(addresses);
+    assertThat(resultCapture.get()).isEqualTo(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(attrs).build());
+  }
+
+  @Deprecated
+  @Test
+  public void acceptResolvedAddresses_delegatesToHandleResolvedAddressGroups() {
+    final AtomicReference<ResolvedAddresses> addressesCapture = new AtomicReference<>();
+
+    LoadBalancer balancer = new LoadBalancer() {
+        @Override
+        public void handleResolvedAddresses(ResolvedAddresses addresses) {
+          addressesCapture.set(addresses);
+        }
+
+        @Override
+        public void handleNameResolutionError(Status error) {
+        }
+
+        @Override
+        public void handleSubchannelState(Subchannel subchannel, ConnectivityStateInfo state) {
+        }
+
+        @Override
+        public void shutdown() {
+        }
+      };
+
+    List<EquivalentAddressGroup> servers = Arrays.asList(
+        new EquivalentAddressGroup(new SocketAddress(){}),
+        new EquivalentAddressGroup(new SocketAddress(){}));
+    ResolvedAddresses addresses = ResolvedAddresses.newBuilder().setAddresses(servers)
+        .setAttributes(attrs).build();
+    balancer.handleResolvedAddresses(addresses);
+    assertThat(addressesCapture.get().getAddresses()).isEqualTo(servers);
+    assertThat(addressesCapture.get().getAttributes()).isEqualTo(attrs);
+  }
+
+  @Deprecated
+  @Test
+  public void acceptResolvedAddresses_noInfiniteLoop() {
+    final List<ResolvedAddresses> addressesCapture = new ArrayList<>();
+
+    LoadBalancer balancer = new LoadBalancer() {
+      @Override
+      public void handleResolvedAddresses(ResolvedAddresses addresses) {
+        addressesCapture.add(addresses);
+        super.handleResolvedAddresses(addresses);
+      }
+
+      @Override
+      public void handleNameResolutionError(Status error) {
+      }
+
+      @Override
+      public void shutdown() {
+      }
+    };
+
+    List<EquivalentAddressGroup> servers = Arrays.asList(
+        new EquivalentAddressGroup(new SocketAddress(){}),
+        new EquivalentAddressGroup(new SocketAddress(){}));
+    ResolvedAddresses addresses = ResolvedAddresses.newBuilder().setAddresses(servers)
+        .setAttributes(attrs).build();
+    balancer.handleResolvedAddresses(addresses);
+    assertThat(addressesCapture).hasSize(1);
+    assertThat(addressesCapture.get(0).getAddresses()).isEqualTo(servers);
+    assertThat(addressesCapture.get(0).getAttributes()).isEqualTo(attrs);
+  }
+
+  private static class NoopHelper extends LoadBalancer.Helper {
+    @Override
+    public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String authority) {
+      return null;
+    }
+
+    @Override
+    public void updateBalancingState(
+        ConnectivityState newState, LoadBalancer.SubchannelPicker newPicker) {}
+
+    @Override public SynchronizationContext getSynchronizationContext() {
+      return null;
+    }
+
+    @Override public String getAuthority() {
+      return null;
+    }
+  }
+
+  private static class EmptySubchannel extends LoadBalancer.Subchannel {
+    @Override public void shutdown() {}
+
+    @Override public void requestConnection() {}
+
+    @Override public Attributes getAttributes() {
+      return null;
+    }
+  }
+}
diff --git a/api/src/test/java/io/grpc/ManagedChannelRegistryTest.java b/api/src/test/java/io/grpc/ManagedChannelRegistryTest.java
new file mode 100644
index 00000000000..30de2477d77
--- /dev/null
+++ b/api/src/test/java/io/grpc/ManagedChannelRegistryTest.java
@@ -0,0 +1,444 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableSet;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.Collection;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ManagedChannelRegistry}. */
+@RunWith(JUnit4.class)
+public class ManagedChannelRegistryTest {
+  private String target = "testing123";
+  private ChannelCredentials creds = new ChannelCredentials() {
+    @Override
+    public ChannelCredentials withoutBearerTokens() {
+      throw new UnsupportedOperationException();
+    }
+  };
+
+  @Test
+  public void register_unavailableProviderThrows() {
+    ManagedChannelRegistry reg = new ManagedChannelRegistry();
+    try {
+      reg.register(new BaseProvider(false, 5));
+      fail("Should throw");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().contains("isAvailable() returned false");
+    }
+    assertThat(reg.providers()).isEmpty();
+  }
+
+  @Test
+  public void deregister() {
+    ManagedChannelRegistry reg = new ManagedChannelRegistry();
+    ManagedChannelProvider p1 = new BaseProvider(true, 5);
+    ManagedChannelProvider p2 = new BaseProvider(true, 5);
+    ManagedChannelProvider p3 = new BaseProvider(true, 5);
+    reg.register(p1);
+    reg.register(p2);
+    reg.register(p3);
+    assertThat(reg.providers()).containsExactly(p1, p2, p3).inOrder();
+    reg.deregister(p2);
+    assertThat(reg.providers()).containsExactly(p1, p3).inOrder();
+  }
+
+  @Test
+  public void provider_sorted() {
+    ManagedChannelRegistry reg = new ManagedChannelRegistry();
+    ManagedChannelProvider p1 = new BaseProvider(true, 5);
+    ManagedChannelProvider p2 = new BaseProvider(true, 3);
+    ManagedChannelProvider p3 = new BaseProvider(true, 8);
+    ManagedChannelProvider p4 = new BaseProvider(true, 3);
+    ManagedChannelProvider p5 = new BaseProvider(true, 8);
+    reg.register(p1);
+    reg.register(p2);
+    reg.register(p3);
+    reg.register(p4);
+    reg.register(p5);
+    assertThat(reg.providers()).containsExactly(p3, p5, p1, p2, p4).inOrder();
+  }
+
+  @Test
+  public void getProvider_noProvider() {
+    assertThat(new ManagedChannelRegistry().provider()).isNull();
+  }
+
+  @Test
+  public void newChannelBuilder_providerReturnsError() {
+    final String errorString = "brisking";
+    class ErrorProvider extends BaseProvider {
+      ErrorProvider() {
+        super(true, 5);
+      }
+
+      @Override
+      public NewChannelBuilderResult newChannelBuilder(
+          String passedTarget, ChannelCredentials passedCreds) {
+        assertThat(passedTarget).isSameInstanceAs(target);
+        assertThat(passedCreds).isSameInstanceAs(creds);
+        return NewChannelBuilderResult.error(errorString);
+      }
+    }
+
+    ManagedChannelRegistry registry = new ManagedChannelRegistry();
+    registry.register(new ErrorProvider());
+    try {
+      registry.newChannelBuilder(target, creds);
+      fail("expected exception");
+    } catch (ManagedChannelRegistry.ProviderNotFoundException ex) {
+      assertThat(ex).hasMessageThat().contains(errorString);
+      assertThat(ex).hasMessageThat().contains(ErrorProvider.class.getName());
+    }
+  }
+
+  @Test
+  public void newChannelBuilder_providerReturnsNonNull() {
+    ManagedChannelRegistry registry = new ManagedChannelRegistry();
+    registry.register(new BaseProvider(true, 5) {
+      @Override
+      public NewChannelBuilderResult newChannelBuilder(
+          String passedTarget, ChannelCredentials passedCreds) {
+        return NewChannelBuilderResult.error("dodging");
+      }
+    });
+    class MockChannelBuilder extends ForwardingChannelBuilder2<MockChannelBuilder> {
+      @Override public ManagedChannelBuilder<?> delegate() {
+        throw new UnsupportedOperationException();
+      }
+    }
+
+    final ManagedChannelBuilder<?> mcb = new MockChannelBuilder();
+    registry.register(new BaseProvider(true, 4) {
+      @Override
+      public NewChannelBuilderResult newChannelBuilder(
+          String passedTarget, ChannelCredentials passedCreds) {
+        return NewChannelBuilderResult.channelBuilder(mcb);
+      }
+    });
+    registry.register(new BaseProvider(true, 3) {
+      @Override
+      public NewChannelBuilderResult newChannelBuilder(
+          String passedTarget, ChannelCredentials passedCreds) {
+        fail("Should not be called");
+        throw new AssertionError();
+      }
+    });
+    assertThat(registry.newChannelBuilder(target, creds)).isSameInstanceAs(mcb);
+  }
+
+  @Test
+  public void newChannelBuilder_noProvider() {
+    ManagedChannelRegistry registry = new ManagedChannelRegistry();
+    try {
+      registry.newChannelBuilder(target, creds);
+      fail("expected exception");
+    } catch (ManagedChannelRegistry.ProviderNotFoundException ex) {
+      assertThat(ex).hasMessageThat().contains("No functional channel service provider found");
+      assertThat(ex).hasMessageThat().contains("grpc-netty");
+    }
+  }
+
+  @Test
+  public void newChannelBuilder_usesScheme() {
+    NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
+    class SocketAddress1 extends SocketAddress {
+    }
+
+    class SocketAddress2 extends SocketAddress {
+    }
+
+    nameResolverRegistry.register(new BaseNameResolverProvider(true, 5, "sc1") {
+      @Override
+      public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+        return Collections.singleton(SocketAddress1.class);
+      }
+    });
+    nameResolverRegistry.register(new BaseNameResolverProvider(true, 6, "sc2") {
+      @Override
+      public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+        fail("Should not be called");
+        throw new AssertionError();
+      }
+    });
+
+    ManagedChannelRegistry registry = new ManagedChannelRegistry();
+    registry.register(new BaseProvider(true, 5) {
+      @Override
+      protected Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+        return Collections.singleton(SocketAddress2.class);
+      }
+
+      @Override
+      public NewChannelBuilderResult newChannelBuilder(
+              String passedTarget, ChannelCredentials passedCreds) {
+        fail("Should not be called");
+        throw new AssertionError();
+      }
+    });
+    class MockChannelBuilder extends ForwardingChannelBuilder2<MockChannelBuilder> {
+      @Override public ManagedChannelBuilder<?> delegate() {
+        throw new UnsupportedOperationException();
+      }
+    }
+
+    final ManagedChannelBuilder<?> mcb = new MockChannelBuilder();
+    registry.register(new BaseProvider(true, 4) {
+      @Override
+      protected Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+        return Collections.singleton(SocketAddress1.class);
+      }
+
+      @Override
+      public NewChannelBuilderResult newChannelBuilder(
+              String passedTarget, ChannelCredentials passedCreds) {
+        return NewChannelBuilderResult.channelBuilder(mcb);
+      }
+    });
+    assertThat(
+        registry.newChannelBuilder(nameResolverRegistry, "sc1:" + target, creds)).isSameInstanceAs(
+        mcb);
+  }
+
+  @Test
+  public void newChannelBuilder_unsupportedSocketAddressTypes() {
+    NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
+    class SocketAddress1 extends SocketAddress {
+    }
+
+    class SocketAddress2 extends SocketAddress {
+    }
+
+    nameResolverRegistry.register(new BaseNameResolverProvider(true, 5, "sc1") {
+      @Override
+      public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+        return ImmutableSet.of(SocketAddress1.class, SocketAddress2.class);
+      }
+    });
+
+    ManagedChannelRegistry registry = new ManagedChannelRegistry();
+    registry.register(new BaseProvider(true, 5) {
+      @Override
+      protected Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+        return Collections.singleton(SocketAddress2.class);
+      }
+
+      @Override
+      public NewChannelBuilderResult newChannelBuilder(
+              String passedTarget, ChannelCredentials passedCreds) {
+        fail("Should not be called");
+        throw new AssertionError();
+      }
+    });
+
+    registry.register(new BaseProvider(true, 4) {
+      @Override
+      protected Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+        return Collections.singleton(SocketAddress1.class);
+      }
+
+      @Override
+      public NewChannelBuilderResult newChannelBuilder(
+              String passedTarget, ChannelCredentials passedCreds) {
+        fail("Should not be called");
+        throw new AssertionError();
+      }
+    });
+    try {
+      registry.newChannelBuilder(nameResolverRegistry, "sc1:" + target, creds);
+      fail("expected exception");
+    } catch (ManagedChannelRegistry.ProviderNotFoundException ex) {
+      assertThat(ex).hasMessageThat().contains("does not support 1 or more of");
+      assertThat(ex).hasMessageThat().contains("SocketAddress1");
+      assertThat(ex).hasMessageThat().contains("SocketAddress2");
+    }
+  }
+
+  @Test
+  public void newChannelBuilder_emptySet_asDefault() {
+    NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
+
+    ManagedChannelRegistry registry = new ManagedChannelRegistry();
+    class MockChannelBuilder extends ForwardingChannelBuilder2<MockChannelBuilder> {
+      @Override public ManagedChannelBuilder<?> delegate() {
+        throw new UnsupportedOperationException();
+      }
+    }
+
+    final ManagedChannelBuilder<?> mcb = new MockChannelBuilder();
+    registry.register(new BaseProvider(true, 4) {
+      @Override
+      protected Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+        return Collections.emptySet();
+      }
+
+      @Override
+      public NewChannelBuilderResult newChannelBuilder(
+              String passedTarget, ChannelCredentials passedCreds) {
+        return NewChannelBuilderResult.channelBuilder(mcb);
+      }
+    });
+    assertThat(
+        registry.newChannelBuilder(nameResolverRegistry, "sc1:" + target, creds)).isSameInstanceAs(
+        mcb);
+  }
+
+  @Test
+  public void newChannelBuilder_noSchemeUsesDefaultScheme() {
+    NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
+    class SocketAddress1 extends SocketAddress {
+    }
+
+    nameResolverRegistry.register(new BaseNameResolverProvider(true, 5, "sc1") {
+      @Override
+      public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+        return Collections.singleton(SocketAddress1.class);
+      }
+    });
+
+    ManagedChannelRegistry registry = new ManagedChannelRegistry();
+    class MockChannelBuilder extends ForwardingChannelBuilder2<MockChannelBuilder> {
+      @Override public ManagedChannelBuilder<?> delegate() {
+        throw new UnsupportedOperationException();
+      }
+    }
+
+    final ManagedChannelBuilder<?> mcb = new MockChannelBuilder();
+    registry.register(new BaseProvider(true, 4) {
+      @Override
+      protected Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+        return Collections.singleton(SocketAddress1.class);
+      }
+
+      @Override
+      public NewChannelBuilderResult newChannelBuilder(
+              String passedTarget, ChannelCredentials passedCreds) {
+        return NewChannelBuilderResult.channelBuilder(mcb);
+      }
+    });
+    assertThat(registry.newChannelBuilder(nameResolverRegistry, target, creds)).isSameInstanceAs(
+        mcb);
+  }
+
+  @Test
+  public void newChannelBuilder_badUri() {
+    NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
+    class SocketAddress1 extends SocketAddress {
+    }
+
+    ManagedChannelRegistry registry = new ManagedChannelRegistry();
+
+    class MockChannelBuilder extends ForwardingChannelBuilder2<MockChannelBuilder> {
+      @Override public ManagedChannelBuilder<?> delegate() {
+        throw new UnsupportedOperationException();
+      }
+    }
+
+    final ManagedChannelBuilder<?> mcb = new MockChannelBuilder();
+    registry.register(new BaseProvider(true, 4) {
+      @Override
+      protected Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+        return Collections.singleton(SocketAddress1.class);
+      }
+
+      @Override
+      public NewChannelBuilderResult newChannelBuilder(
+          String passedTarget, ChannelCredentials passedCreds) {
+        return NewChannelBuilderResult.channelBuilder(mcb);
+      }
+    });
+    assertThat(
+        registry.newChannelBuilder(nameResolverRegistry, ":testing123", creds)).isSameInstanceAs(
+        mcb);
+  }
+
+  private static class BaseNameResolverProvider extends NameResolverProvider {
+    private final boolean isAvailable;
+    private final int priority;
+    private final String defaultScheme;
+
+    public BaseNameResolverProvider(boolean isAvailable, int priority, String defaultScheme) {
+      this.isAvailable = isAvailable;
+      this.priority = priority;
+      this.defaultScheme = defaultScheme;
+    }
+
+    @Override
+    public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+      return null;
+    }
+
+    @Override
+    public String getDefaultScheme() {
+      return defaultScheme;
+    }
+
+    @Override
+    protected boolean isAvailable() {
+      return isAvailable;
+    }
+
+    @Override
+    protected int priority() {
+      return priority;
+    }
+  }
+
+  private static class BaseProvider extends ManagedChannelProvider {
+    private final boolean isAvailable;
+    private final int priority;
+
+    public BaseProvider(boolean isAvailable, int priority) {
+      this.isAvailable = isAvailable;
+      this.priority = priority;
+    }
+
+    @Override
+    protected boolean isAvailable() {
+      return isAvailable;
+    }
+
+    @Override
+    protected int priority() {
+      return priority;
+    }
+
+    @Override
+    protected ManagedChannelBuilder<?> builderForAddress(String name, int port) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    protected ManagedChannelBuilder<?> builderForTarget(String target) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    protected Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+      return Collections.singleton(InetSocketAddress.class);
+    }
+  }
+}
diff --git a/api/src/test/java/io/grpc/MetadataTest.java b/api/src/test/java/io/grpc/MetadataTest.java
new file mode 100644
index 00000000000..a858fff5e5a
--- /dev/null
+++ b/api/src/test/java/io/grpc/MetadataTest.java
@@ -0,0 +1,511 @@
+/*
+ * Copyright 2014 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.US_ASCII;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Lists;
+import com.google.common.io.ByteStreams;
+import com.google.common.testing.EqualsTester;
+import io.grpc.internal.GrpcUtil;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Locale;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link Metadata}.
+ */
+@RunWith(JUnit4.class)
+public class MetadataTest {
+
+  private static final Metadata.BinaryMarshaller<Fish> FISH_MARSHALLER =
+      new Metadata.BinaryMarshaller<Fish>() {
+        @Override
+        public byte[] toBytes(Fish fish) {
+          return fish.name.getBytes(UTF_8);
+        }
+
+        @Override
+        public Fish parseBytes(byte[] serialized) {
+          return new Fish(new String(serialized, UTF_8));
+        }
+      };
+
+  private static class FishStreamMarshaller implements Metadata.BinaryStreamMarshaller<Fish> {
+    @Override
+    public InputStream toStream(Fish fish) {
+      return new ByteArrayInputStream(FISH_MARSHALLER.toBytes(fish));
+    }
+
+    @Override
+    public Fish parseStream(InputStream stream) {
+      try {
+        return FISH_MARSHALLER.parseBytes(ByteStreams.toByteArray(stream));
+      } catch (IOException ioe) {
+        throw new AssertionError();
+      }
+    }
+  }
+
+  private static final Metadata.BinaryStreamMarshaller<Fish> FISH_STREAM_MARSHALLER =
+      new FishStreamMarshaller();
+
+  /** A pattern commonly used to avoid unnecessary serialization of immutable objects. */
+  private static final class FakeFishStream extends InputStream {
+    final Fish fish;
+
+    FakeFishStream(Fish fish) {
+      this.fish = fish;
+    }
+
+    @Override
+    public int read() throws IOException {
+      throw new IOException("Not actually a stream");
+    }
+  }
+
+  private static final Metadata.BinaryStreamMarshaller<Fish> IMMUTABLE_FISH_MARSHALLER =
+      new Metadata.BinaryStreamMarshaller<Fish>() {
+        @Override
+        public InputStream toStream(Fish fish) {
+          return new FakeFishStream(fish);
+        }
+
+        @Override
+        public Fish parseStream(InputStream stream) {
+          return ((FakeFishStream) stream).fish;
+        }
+      };
+
+  private static final String LANCE = "lance";
+  private static final byte[] LANCE_BYTES = LANCE.getBytes(US_ASCII);
+  private static final Metadata.Key<Fish> KEY = Metadata.Key.of("test-bin", FISH_MARSHALLER);
+  private static final Metadata.Key<Fish> KEY_STREAMED =
+      Metadata.Key.of("streamed-bin", FISH_STREAM_MARSHALLER);
+  private static final Metadata.Key<Fish> KEY_IMMUTABLE =
+      Metadata.Key.of("immutable-bin", IMMUTABLE_FISH_MARSHALLER);
+
+  @Test
+  public void noPseudoHeaders() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> Metadata.Key.of(":test-bin", FISH_MARSHALLER));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid character ':' in key name ':test-bin'");
+  }
+
+  @Test
+  public void testMutations() {
+    Fish lance = new Fish(LANCE);
+    Fish cat = new Fish("cat");
+    Metadata metadata = new Metadata();
+
+    assertNull(metadata.get(KEY));
+    metadata.put(KEY, lance);
+    assertEquals(Arrays.asList(lance), Lists.newArrayList(metadata.getAll(KEY)));
+    assertEquals(lance, metadata.get(KEY));
+    metadata.put(KEY, lance);
+    assertEquals(Arrays.asList(lance, lance), Lists.newArrayList(metadata.getAll(KEY)));
+    assertTrue(metadata.remove(KEY, lance));
+    assertEquals(Arrays.asList(lance), Lists.newArrayList(metadata.getAll(KEY)));
+
+    assertFalse(metadata.remove(KEY, cat));
+    metadata.put(KEY, cat);
+    assertEquals(cat, metadata.get(KEY));
+    metadata.put(KEY, lance);
+    assertEquals(Arrays.asList(lance, cat, lance), Lists.newArrayList(metadata.getAll(KEY)));
+    assertEquals(lance, metadata.get(KEY));
+    assertTrue(metadata.remove(KEY, lance));
+    assertEquals(Arrays.asList(cat, lance), Lists.newArrayList(metadata.getAll(KEY)));
+    metadata.put(KEY, lance);
+    assertTrue(metadata.remove(KEY, cat));
+    assertEquals(Arrays.asList(lance, lance), Lists.newArrayList(metadata.getAll(KEY)));
+
+    assertEquals(Arrays.asList(lance, lance), Lists.newArrayList(metadata.removeAll(KEY)));
+    assertNull(metadata.getAll(KEY));
+    assertNull(metadata.get(KEY));
+  }
+
+  @Test
+  public void discardAll() {
+    Fish lance = new Fish(LANCE);
+    Metadata metadata = new Metadata();
+
+    metadata.put(KEY, lance);
+    metadata.discardAll(KEY);
+    assertNull(metadata.getAll(KEY));
+    assertNull(metadata.get(KEY));
+  }
+
+  @Test
+  public void discardAll_empty() {
+    Metadata metadata = new Metadata();
+    metadata.discardAll(KEY);
+    assertNull(metadata.getAll(KEY));
+    assertNull(metadata.get(KEY));
+  }
+
+  @Test
+  public void testGetAllNoRemove() {
+    Fish lance = new Fish(LANCE);
+    Metadata metadata = new Metadata();
+    metadata.put(KEY, lance);
+    Iterator<Fish> i = metadata.getAll(KEY).iterator();
+    assertEquals(lance, i.next());
+
+    assertThrows(UnsupportedOperationException.class, i::remove);
+  }
+
+  @Test
+  public void testWriteParsed() {
+    Fish lance = new Fish(LANCE);
+    Metadata metadata = new Metadata();
+    metadata.put(KEY, lance);
+    assertEquals(lance, metadata.get(KEY));
+    Iterator<Fish> fishes = metadata.getAll(KEY).iterator();
+    assertTrue(fishes.hasNext());
+    assertEquals(fishes.next(), lance);
+    assertFalse(fishes.hasNext());
+    byte[][] serialized = metadata.serialize();
+    assertEquals(2, serialized.length);
+    assertEquals("test-bin", new String(serialized[0], US_ASCII));
+    assertArrayEquals(LANCE_BYTES, serialized[1]);
+    assertEquals(lance, metadata.get(KEY));
+    assertEquals(serialized[0], metadata.serialize()[0]);
+    assertEquals(serialized[1], metadata.serialize()[1]);
+  }
+
+  @Test
+  public void testWriteRaw() {
+    Metadata raw = new Metadata(KEY.asciiName(), LANCE_BYTES);
+    Fish lance = raw.get(KEY);
+    assertEquals(lance, new Fish(LANCE));
+    // Reading again should return the same parsed instance
+    assertEquals(lance, raw.get(KEY));
+  }
+
+  @Test
+  public void testSerializeRaw() {
+    Metadata raw = new Metadata(KEY.asciiName(), LANCE_BYTES);
+    byte[][] serialized = raw.serialize();
+    assertArrayEquals(serialized[0], KEY.asciiName());
+    assertArrayEquals(serialized[1], LANCE_BYTES);
+  }
+
+  @Test
+  public void testMergeByteConstructed() {
+    Metadata raw = new Metadata(KEY.asciiName(), LANCE_BYTES);
+    Metadata serializable = new Metadata();
+    serializable.merge(raw);
+
+    byte[][] serialized = serializable.serialize();
+    assertArrayEquals(serialized[0], KEY.asciiName());
+    assertArrayEquals(serialized[1], LANCE_BYTES);
+    assertEquals(new Fish(LANCE), serializable.get(KEY));
+  }
+
+  @Test
+  public void headerMergeShouldCopyValues() {
+    Fish lance = new Fish(LANCE);
+    Metadata h1 = new Metadata();
+
+    Metadata h2 = new Metadata();
+    h2.put(KEY, lance);
+
+    h1.merge(h2);
+
+    Iterator<Fish> fishes = h1.getAll(KEY).iterator();
+    assertTrue(fishes.hasNext());
+    assertEquals(fishes.next(), lance);
+    assertFalse(fishes.hasNext());
+  }
+
+  @Test
+  public void mergeExpands() {
+    Fish lance = new Fish(LANCE);
+    Metadata h1 = new Metadata();
+    h1.put(KEY, lance);
+
+    Metadata h2 = new Metadata();
+    h2.put(KEY, lance);
+    h2.put(KEY, lance);
+    h2.put(KEY, lance);
+    h2.put(KEY, lance);
+
+    h1.merge(h2);
+  }
+
+  @Test
+  public void shortBinaryKeyName() {
+    assertThrows(IllegalArgumentException.class, () -> Metadata.Key.of("-bin", FISH_MARSHALLER));
+  }
+
+  @Test
+  public void invalidSuffixBinaryKeyName() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> Metadata.Key.of("nonbinary", FISH_MARSHALLER));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Binary header is named nonbinary. It must end with -bin");
+  }
+
+  @Test
+  public void verifyToString() {
+    Metadata h = new Metadata();
+    h.put(KEY, new Fish("binary"));
+    h.put(Metadata.Key.of("test", Metadata.ASCII_STRING_MARSHALLER), "ascii");
+    assertEquals("Metadata(test-bin=YmluYXJ5,test=ascii)", h.toString());
+
+    Metadata t = new Metadata();
+    t.put(Metadata.Key.of("test", Metadata.ASCII_STRING_MARSHALLER), "ascii");
+    assertEquals("Metadata(test=ascii)", t.toString());
+
+    t = new Metadata("test".getBytes(US_ASCII), "ascii".getBytes(US_ASCII),
+        "test-bin".getBytes(US_ASCII), "binary".getBytes(US_ASCII));
+    assertEquals("Metadata(test=ascii,test-bin=YmluYXJ5)", t.toString());
+  }
+
+  @Test
+  public void verifyToString_usingBinary() {
+    Metadata h = new Metadata();
+    h.put(KEY, new Fish("binary"));
+    h.put(Metadata.Key.of("test", Metadata.ASCII_STRING_MARSHALLER), "ascii");
+    assertEquals("Metadata(test-bin=YmluYXJ5,test=ascii)", h.toString());
+
+    Metadata t = new Metadata();
+    t.put(Metadata.Key.of("test", Metadata.ASCII_STRING_MARSHALLER), "ascii");
+    assertEquals("Metadata(test=ascii)", t.toString());
+  }
+
+  @Test
+  @SuppressWarnings("StringCaseLocaleUsage")  // System locale is exactly what we're testing.
+  public void testKeyCaseHandling() {
+    Locale originalLocale = Locale.getDefault();
+    Locale.setDefault(new Locale("tr", "TR"));
+    try {
+      // In Turkish, both I and i (which are in ASCII) change into non-ASCII characters when their
+      // case is changed as ı and İ, respectively.
+      assertEquals("İ", "i".toUpperCase());
+      assertEquals("ı", "I".toLowerCase());
+
+      Metadata.Key<String> keyTitleCase
+          = Metadata.Key.of("If-Modified-Since", Metadata.ASCII_STRING_MARSHALLER);
+      Metadata.Key<String> keyLowerCase
+          = Metadata.Key.of("if-modified-since", Metadata.ASCII_STRING_MARSHALLER);
+      Metadata.Key<String> keyUpperCase
+          = Metadata.Key.of("IF-MODIFIED-SINCE", Metadata.ASCII_STRING_MARSHALLER);
+
+      Metadata metadata = new Metadata();
+      metadata.put(keyTitleCase, "plain string");
+      assertEquals("plain string", metadata.get(keyTitleCase));
+      assertEquals("plain string", metadata.get(keyLowerCase));
+      assertEquals("plain string", metadata.get(keyUpperCase));
+
+      byte[][] bytes = metadata.serialize();
+      assertEquals(2, bytes.length);
+      assertArrayEquals("if-modified-since".getBytes(US_ASCII), bytes[0]);
+      assertArrayEquals("plain string".getBytes(US_ASCII), bytes[1]);
+    } finally {
+      Locale.setDefault(originalLocale);
+    }
+  }
+
+  @Test
+  public void removeIgnoresMissingValue() {
+    Metadata m = new Metadata();
+    // Any key will work.
+    Metadata.Key<String> key = GrpcUtil.USER_AGENT_KEY;
+
+    boolean success = m.remove(key, "agent");
+    assertFalse(success);
+  }
+
+  @Test
+  public void removeAllIgnoresMissingValue() {
+    Metadata m = new Metadata();
+    // Any key will work.
+    Metadata.Key<String> key = GrpcUtil.USER_AGENT_KEY;
+
+    Iterable<String> removed = m.removeAll(key);
+    assertNull(removed);
+  }
+
+  @Test
+  public void keyEqualsHashNameWorks() {
+    Metadata.Key<?> k1 = Metadata.Key.of("case", Metadata.ASCII_STRING_MARSHALLER);
+    Metadata.Key<?> k2 = Metadata.Key.of("CASE", Metadata.ASCII_STRING_MARSHALLER);
+
+    new EqualsTester()
+        .addEqualityGroup(k1, k2)
+        .addEqualityGroup(new Object(){})
+        .testEquals();
+    // Check that the casing is preserved.
+    assertEquals("CASE", k2.originalName());
+    assertEquals("case", k2.name());
+  }
+
+  @Test
+  public void invalidKeyName() {
+    try {
+      Metadata.Key.of("io.grpc/key1", Metadata.ASCII_STRING_MARSHALLER);
+      fail("Should have thrown");
+    } catch (IllegalArgumentException e) {
+      assertEquals("Invalid character '/' in key name 'io.grpc/key1'", e.getMessage());
+    }
+  }
+
+  @Test
+  public void streamedValue() {
+    Fish salmon = new Fish("salmon");
+    Metadata h = new Metadata();
+    h.put(KEY_STREAMED, salmon);
+    assertEquals(salmon, h.get(KEY_STREAMED));
+  }
+
+  @Test
+  public void streamedValueDifferentKey() {
+    Fish salmon = new Fish("salmon");
+    Metadata h = new Metadata();
+    h.put(KEY_STREAMED, salmon);
+
+    // Get using a different key instance (but the same marshaller).
+    Fish fish = h.get(copyKey(KEY_STREAMED, FISH_STREAM_MARSHALLER));
+    assertEquals(salmon, fish);
+  }
+
+  @Test
+  public void streamedValueDifferentMarshaller() {
+    Fish salmon = new Fish("salmon");
+    Metadata h = new Metadata();
+    h.put(KEY_STREAMED, salmon);
+
+    // Get using a different marshaller instance.
+    Fish fish = h.get(copyKey(KEY_STREAMED, new FishStreamMarshaller()));
+    assertEquals(salmon, fish);
+  }
+
+  @Test
+  public void serializeParseMetadataWithStreams() {
+    Metadata h = new Metadata();
+    Fish salmon = new Fish("salmon");
+    h.put(KEY_STREAMED, salmon);
+
+    Metadata parsed = new Metadata(h.serialize());
+    assertEquals(salmon, parsed.get(KEY_STREAMED));
+  }
+
+  @Test
+  public void immutableMarshaller() {
+    Metadata h = new Metadata(KEY.asciiName(), LANCE_BYTES);
+    Fish salmon = new Fish("salmon");
+    h.put(KEY_IMMUTABLE, salmon);
+    assertSame(salmon, h.get(KEY_IMMUTABLE));
+    // Even though the key differs, the marshaller can chose to avoid serialization.
+    assertSame(salmon, h.get(copyKey(KEY_IMMUTABLE, IMMUTABLE_FISH_MARSHALLER)));
+  }
+
+  @Test
+  public void partialSerialization() {
+    Metadata h = new Metadata(KEY.asciiName(), LANCE_BYTES);
+    Fish salmon = new Fish("salmon");
+    h.put(KEY_STREAMED, salmon);
+    h.put(KEY_IMMUTABLE, salmon);
+
+    Object[] serialized = InternalMetadata.serializePartial(h);
+    assertEquals(6, serialized.length);
+    assertEquals("test-bin", new String((byte[]) serialized[0], US_ASCII));
+    assertArrayEquals(LANCE_BYTES, (byte[]) serialized[1]);
+
+    assertEquals("streamed-bin", new String((byte[]) serialized[2], US_ASCII));
+    assertEquals(salmon, FISH_STREAM_MARSHALLER.parseStream((InputStream) serialized[3]));
+    assertNotSame(salmon, FISH_STREAM_MARSHALLER.parseStream((InputStream) serialized[3]));
+
+    assertEquals("immutable-bin", new String((byte[]) serialized[4], US_ASCII));
+    assertSame(salmon, IMMUTABLE_FISH_MARSHALLER.parseStream((InputStream) serialized[5]));
+  }
+
+  @Test
+  public void createFromPartial() {
+    Metadata h = new Metadata(KEY.asciiName(), LANCE_BYTES);
+    Fish salmon = new Fish("salmon");
+    h.put(KEY_STREAMED, salmon);
+    h.put(KEY_IMMUTABLE, salmon);
+
+    Fish anotherSalmon = new Fish("salmon");
+
+    Object[] partial = InternalMetadata.serializePartial(h);
+    partial[3] = InternalMetadata.parsedValue(FISH_STREAM_MARSHALLER, anotherSalmon);
+    partial[5] = InternalMetadata.parsedValue(IMMUTABLE_FISH_MARSHALLER, anotherSalmon);
+
+    Metadata h2 = new Metadata(3, partial);
+    assertEquals(new Fish(LANCE), h2.get(KEY));
+    assertEquals(anotherSalmon, h2.get(KEY_STREAMED));
+    assertSame(anotherSalmon, h2.get(KEY_IMMUTABLE));
+  }
+
+  private static final class Fish {
+    private String name;
+
+    private Fish(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      Fish fish = (Fish) o;
+      if (name != null ? !name.equals(fish.name) : fish.name != null) {
+        return false;
+      }
+      return true;
+    }
+
+    @Override
+    public int hashCode() {
+      return name.hashCode();
+    }
+
+    @Override
+    public String toString() {
+      return "Fish(" + name + ")";
+    }
+  }
+
+  private static <T> Metadata.Key<T> copyKey(
+      Metadata.Key<T> key, Metadata.BinaryStreamMarshaller<T> marshaller) {
+    return Metadata.Key.of(key.originalName(), marshaller);
+  }
+}
diff --git a/api/src/test/java/io/grpc/MethodDescriptorTest.java b/api/src/test/java/io/grpc/MethodDescriptorTest.java
new file mode 100644
index 00000000000..e068e0c1108
--- /dev/null
+++ b/api/src/test/java/io/grpc/MethodDescriptorTest.java
@@ -0,0 +1,271 @@
+/*
+ * Copyright 2016 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;
+
+import static junit.framework.TestCase.assertSame;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import io.grpc.MethodDescriptor.Marshaller;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.testing.TestMethodDescriptors;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link MethodDescriptor}.
+ */
+@RunWith(JUnit4.class)
+public class MethodDescriptorTest {
+  @Test
+  public void createMethodDescriptor() {
+    MethodDescriptor<String, String> descriptor = MethodDescriptor.<String, String>newBuilder()
+        .setType(MethodType.CLIENT_STREAMING)
+        .setFullMethodName("package.service/method")
+        .setRequestMarshaller(new StringMarshaller())
+        .setResponseMarshaller(new StringMarshaller())
+        .build();
+
+    assertEquals(MethodType.CLIENT_STREAMING, descriptor.getType());
+    assertEquals("package.service/method", descriptor.getFullMethodName());
+    assertFalse(descriptor.isIdempotent());
+    assertFalse(descriptor.isSafe());
+  }
+
+  @Test
+  public void idempotent() {
+    MethodDescriptor<String, String> descriptor = MethodDescriptor.<String, String>newBuilder()
+        .setType(MethodType.SERVER_STREAMING)
+        .setFullMethodName("package.service/method")
+        .setRequestMarshaller(new StringMarshaller())
+        .setResponseMarshaller(new StringMarshaller())
+        .build();
+
+    assertFalse(descriptor.isIdempotent());
+
+    // Create a new descriptor by setting idempotent to true
+    MethodDescriptor<String, String> newDescriptor =
+        descriptor.toBuilder().setIdempotent(true).build();
+    assertTrue(newDescriptor.isIdempotent());
+    // All other fields should staty the same
+    assertEquals(MethodType.SERVER_STREAMING, newDescriptor.getType());
+    assertEquals("package.service/method", newDescriptor.getFullMethodName());
+  }
+
+  @Test
+  public void safe() {
+    MethodDescriptor<String, String> descriptor = MethodDescriptor.<String, String>newBuilder()
+        .setType(MethodType.UNARY)
+        .setFullMethodName("package.service/method")
+        .setRequestMarshaller(new StringMarshaller())
+        .setResponseMarshaller(new StringMarshaller())
+        .build();
+    assertFalse(descriptor.isSafe());
+
+    // Create a new descriptor by setting safe to true
+    MethodDescriptor<String, String> newDescriptor = descriptor.toBuilder().setSafe(true).build();
+    assertTrue(newDescriptor.isSafe());
+    // All other fields should staty the same
+    assertEquals(MethodType.UNARY, newDescriptor.getType());
+    assertEquals("package.service/method", newDescriptor.getFullMethodName());
+  }
+
+  @Test
+  public void safeImpliesIdempotent() {
+    MethodDescriptor<String, String> descriptor = MethodDescriptor.<String, String>newBuilder()
+        .setType(MethodType.UNARY)
+        .setFullMethodName("package.service/method")
+        .setRequestMarshaller(new StringMarshaller())
+        .setResponseMarshaller(new StringMarshaller())
+        .setSafe(true)
+        .build();
+    assertTrue(descriptor.isSafe());
+    assertTrue(descriptor.isIdempotent());
+    descriptor = descriptor.toBuilder().setIdempotent(false).build();
+    assertFalse(descriptor.isSafe());
+    assertFalse(descriptor.isIdempotent());
+  }
+
+  @Test
+  public void safeAndNonUnary() {
+    MethodDescriptor<String, String> descriptor = MethodDescriptor.<String, String>newBuilder()
+        .setType(MethodType.SERVER_STREAMING)
+        .setFullMethodName("package.service/method")
+        .setRequestMarshaller(new StringMarshaller())
+        .setResponseMarshaller(new StringMarshaller())
+        .build();
+
+    // Verify it does not throw
+    MethodDescriptor<String, String> newDescriptor = descriptor.toBuilder().setSafe(true).build();
+    assertTrue(newDescriptor.isSafe());
+  }
+
+  @Test
+  public void sampledToLocalTracing() {
+    MethodDescriptor<String, String> md1 = MethodDescriptor.<String, String>newBuilder()
+        .setType(MethodType.SERVER_STREAMING)
+        .setFullMethodName("package.service/method")
+        .setRequestMarshaller(new StringMarshaller())
+        .setResponseMarshaller(new StringMarshaller())
+        .setSampledToLocalTracing(true)
+        .build();
+    assertTrue(md1.isSampledToLocalTracing());
+
+    MethodDescriptor<String, String> md2 = md1.toBuilder()
+        .setFullMethodName("package.service/method2")
+        .build();
+    assertTrue(md2.isSampledToLocalTracing());
+
+    // Same method name as md1, but not setting sampledToLocalTracing
+    MethodDescriptor<String, String> md3 = MethodDescriptor.<String, String>newBuilder()
+        .setType(MethodType.SERVER_STREAMING)
+        .setFullMethodName("package.service/method")
+        .setRequestMarshaller(new StringMarshaller())
+        .setResponseMarshaller(new StringMarshaller())
+        .build();
+    assertFalse(md3.isSampledToLocalTracing());
+
+    MethodDescriptor<String, String> md4 = md3.toBuilder()
+        .setFullMethodName("package.service/method2")
+        .setSampledToLocalTracing(true)
+        .build();
+    assertTrue(md4.isSampledToLocalTracing());
+  }
+
+  @Test
+  public void getServiceName_extractsService() {
+    Marshaller<Void> marshaller = TestMethodDescriptors.voidMarshaller();
+    MethodDescriptor<?, ?> md = MethodDescriptor.newBuilder(marshaller, marshaller)
+        .setType(MethodType.UNARY)
+        .setFullMethodName("foo/bar")
+        .build();
+
+    assertEquals("foo", md.getServiceName());
+  }
+
+  @Test
+  public void getServiceName_returnsNull() {
+    Marshaller<Void> marshaller = TestMethodDescriptors.voidMarshaller();
+    MethodDescriptor<?, ?> md = MethodDescriptor.newBuilder(marshaller, marshaller)
+        .setType(MethodType.UNARY)
+        .setFullMethodName("foo-bar")
+        .build();
+
+    assertNull(md.getServiceName());
+  }
+
+  @Test
+  public void getBareMethodName_extractsMethod() {
+    Marshaller<Void> marshaller = TestMethodDescriptors.voidMarshaller();
+    MethodDescriptor<?, ?> md = MethodDescriptor.newBuilder(marshaller, marshaller)
+        .setType(MethodType.UNARY)
+        .setFullMethodName("foo/bar")
+        .build();
+
+    assertEquals("bar", md.getBareMethodName());
+  }
+
+  @Test
+  public void getBareMethodName_returnsNull() {
+    Marshaller<Void> marshaller = TestMethodDescriptors.voidMarshaller();
+    MethodDescriptor<?, ?> md = MethodDescriptor.newBuilder(marshaller, marshaller)
+        .setType(MethodType.UNARY)
+        .setFullMethodName("foo-bar")
+        .build();
+
+    assertNull(md.getBareMethodName());
+  }
+
+  @Test
+  public void getBareMethodName_returnsEmptyStringWithMethodMissing() {
+    Marshaller<Void> marshaller = TestMethodDescriptors.voidMarshaller();
+    MethodDescriptor<?, ?> md = MethodDescriptor.newBuilder(marshaller, marshaller)
+        .setType(MethodType.UNARY)
+        .setFullMethodName("foo/")
+        .build();
+
+    assertTrue(md.getBareMethodName().isEmpty());
+  }
+
+  @Test
+  public void toBuilderTest() {
+    MethodDescriptor<String, String> md1 = MethodDescriptor.<String, String>newBuilder()
+        .setType(MethodType.UNARY)
+        .setFullMethodName("package.service/method")
+        .setRequestMarshaller(StringMarshaller.INSTANCE)
+        .setResponseMarshaller(StringMarshaller.INSTANCE)
+        .setSampledToLocalTracing(true)
+        .setIdempotent(true)
+        .setSafe(true)
+        .setSchemaDescriptor(new Object())
+        .build();
+    // Verify that we are not using any default builder values, so if md1 and md2 matches,
+    // it's because toBuilder explicitly copied it.
+    MethodDescriptor<String, String> defaults = MethodDescriptor.<String, String>newBuilder()
+        .setType(MethodType.UNARY)
+        .setFullMethodName("package.service/method")
+        .setRequestMarshaller(StringMarshaller.INSTANCE)
+        .setResponseMarshaller(StringMarshaller.INSTANCE)
+        .build();
+    assertNotEquals(md1.isSampledToLocalTracing(), defaults.isSampledToLocalTracing());
+    assertNotEquals(md1.isIdempotent(), defaults.isIdempotent());
+    assertNotEquals(md1.isSafe(), defaults.isSafe());
+    assertNotEquals(md1.getSchemaDescriptor(), defaults.getSchemaDescriptor());
+
+    // Verify that the builder correctly copied over the values
+    MethodDescriptor<Integer, Integer> md2 = md1.toBuilder(
+        IntegerMarshaller.INSTANCE,
+        IntegerMarshaller.INSTANCE).build();
+    assertSame(md1.getType(), md2.getType());
+    assertSame(md1.getFullMethodName(), md2.getFullMethodName());
+    assertSame(IntegerMarshaller.INSTANCE, md2.getRequestMarshaller());
+    assertSame(IntegerMarshaller.INSTANCE, md2.getResponseMarshaller());
+    assertEquals(md1.isSampledToLocalTracing(), md2.isSampledToLocalTracing());
+    assertEquals(md1.isIdempotent(), md2.isIdempotent());
+    assertEquals(md1.isSafe(), md2.isSafe());
+    assertSame(md1.getSchemaDescriptor(), md2.getSchemaDescriptor());
+  }
+
+  @Test
+  public void toStringTest() {
+    MethodDescriptor<String, String> descriptor = MethodDescriptor.<String, String>newBuilder()
+        .setType(MethodType.UNARY)
+        .setFullMethodName("package.service/method")
+        .setRequestMarshaller(StringMarshaller.INSTANCE)
+        .setResponseMarshaller(StringMarshaller.INSTANCE)
+        .setSampledToLocalTracing(true)
+        .setIdempotent(true)
+        .setSafe(true)
+        .setSchemaDescriptor(new Object())
+        .build();
+
+    String toString = descriptor.toString();
+    assertTrue(toString.contains("MethodDescriptor"));
+    assertTrue(toString.contains("fullMethodName=package.service/method"));
+    assertTrue(toString.contains("type=UNARY"));
+    assertTrue(toString.contains("idempotent=true"));
+    assertTrue(toString.contains("safe=true"));
+    assertTrue(toString.contains("sampledToLocalTracing=true"));
+    assertTrue(toString.contains("requestMarshaller=io.grpc.StringMarshaller"));
+    assertTrue(toString.contains("responseMarshaller=io.grpc.StringMarshaller"));
+    assertTrue(toString.contains("schemaDescriptor=java.lang.Object"));
+  }
+}
diff --git a/api/src/test/java/io/grpc/MetricInstrumentRegistryTest.java b/api/src/test/java/io/grpc/MetricInstrumentRegistryTest.java
new file mode 100644
index 00000000000..b378f4aaef5
--- /dev/null
+++ b/api/src/test/java/io/grpc/MetricInstrumentRegistryTest.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright 2024 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.MetricInstrumentRegistry.INITIAL_INSTRUMENT_CAPACITY;
+
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit test for {@link MetricInstrumentRegistry}.
+ */
+@RunWith(JUnit4.class)
+public class MetricInstrumentRegistryTest {
+  private static final ImmutableList<String> REQUIRED_LABEL_KEYS = ImmutableList.of("KEY1", "KEY2");
+  private static final ImmutableList<String> OPTIONAL_LABEL_KEYS = ImmutableList.of(
+      "OPTIONAL_KEY_1");
+  private static final ImmutableList<Double> DOUBLE_HISTOGRAM_BUCKETS = ImmutableList.of(0.01, 0.1);
+  private static final ImmutableList<Long> LONG_HISTOGRAM_BUCKETS = ImmutableList.of(1L, 10L);
+  private static final String METRIC_NAME_1 = "testMetric1";
+  private static final String DESCRIPTION_1 = "description1";
+  private static final String DESCRIPTION_2 = "description2";
+  private static final String UNIT_1 = "unit1";
+  private static final String UNIT_2 = "unit2";
+  private static final boolean ENABLED = true;
+  private static final boolean DISABLED = false;
+  private MetricInstrumentRegistry registry = new MetricInstrumentRegistry();
+
+  @Test
+  public void registerDoubleCounterSuccess() {
+    DoubleCounterMetricInstrument instrument = registry.registerDoubleCounter(
+        METRIC_NAME_1, DESCRIPTION_1, UNIT_1, REQUIRED_LABEL_KEYS, OPTIONAL_LABEL_KEYS, ENABLED);
+    assertThat(registry.getMetricInstruments().contains(instrument)).isTrue();
+    assertThat(registry.getMetricInstruments().size()).isEqualTo(1);
+    assertThat(instrument.getName()).isEqualTo(METRIC_NAME_1);
+    assertThat(instrument.getDescription()).isEqualTo(DESCRIPTION_1);
+    assertThat(instrument.getUnit()).isEqualTo(UNIT_1);
+    assertThat(instrument.getRequiredLabelKeys()).isEqualTo(REQUIRED_LABEL_KEYS);
+    assertThat(instrument.getOptionalLabelKeys()).isEqualTo(OPTIONAL_LABEL_KEYS);
+    assertThat(instrument.isEnableByDefault()).isTrue();
+  }
+
+  @Test
+  public void registerLongCounterSuccess() {
+    LongCounterMetricInstrument instrument2 = registry.registerLongCounter(
+        METRIC_NAME_1, DESCRIPTION_1, UNIT_1, REQUIRED_LABEL_KEYS, OPTIONAL_LABEL_KEYS, ENABLED);
+    assertThat(registry.getMetricInstruments().contains(instrument2)).isTrue();
+    assertThat(registry.getMetricInstruments().size()).isEqualTo(1);
+    assertThat(instrument2.getName()).isEqualTo(METRIC_NAME_1);
+    assertThat(instrument2.getDescription()).isEqualTo(DESCRIPTION_1);
+    assertThat(instrument2.getUnit()).isEqualTo(UNIT_1);
+    assertThat(instrument2.getRequiredLabelKeys()).isEqualTo(REQUIRED_LABEL_KEYS);
+    assertThat(instrument2.getOptionalLabelKeys()).isEqualTo(OPTIONAL_LABEL_KEYS);
+    assertThat(instrument2.isEnableByDefault()).isTrue();
+  }
+
+  @Test
+  public void registerDoubleHistogramSuccess() {
+    DoubleHistogramMetricInstrument instrument3 = registry.registerDoubleHistogram(
+        METRIC_NAME_1, DESCRIPTION_1, UNIT_1, DOUBLE_HISTOGRAM_BUCKETS, REQUIRED_LABEL_KEYS,
+        OPTIONAL_LABEL_KEYS, ENABLED);
+    assertThat(registry.getMetricInstruments().contains(instrument3)).isTrue();
+    assertThat(registry.getMetricInstruments().size()).isEqualTo(1);
+    assertThat(instrument3.getName()).isEqualTo(METRIC_NAME_1);
+    assertThat(instrument3.getDescription()).isEqualTo(DESCRIPTION_1);
+    assertThat(instrument3.getUnit()).isEqualTo(UNIT_1);
+    assertThat(instrument3.getBucketBoundaries()).isEqualTo(DOUBLE_HISTOGRAM_BUCKETS);
+    assertThat(instrument3.getRequiredLabelKeys()).isEqualTo(REQUIRED_LABEL_KEYS);
+    assertThat(instrument3.getOptionalLabelKeys()).isEqualTo(OPTIONAL_LABEL_KEYS);
+    assertThat(instrument3.isEnableByDefault()).isTrue();
+  }
+
+  @Test
+  public void registerLongHistogramSuccess() {
+    LongHistogramMetricInstrument instrument4 = registry.registerLongHistogram(
+        METRIC_NAME_1, DESCRIPTION_1, UNIT_1, LONG_HISTOGRAM_BUCKETS, REQUIRED_LABEL_KEYS,
+        OPTIONAL_LABEL_KEYS, ENABLED);
+    assertThat(registry.getMetricInstruments().contains(instrument4)).isTrue();
+    assertThat(registry.getMetricInstruments().size()).isEqualTo(1);
+    assertThat(instrument4.getName()).isEqualTo(METRIC_NAME_1);
+    assertThat(instrument4.getDescription()).isEqualTo(DESCRIPTION_1);
+    assertThat(instrument4.getUnit()).isEqualTo(UNIT_1);
+    assertThat(instrument4.getBucketBoundaries()).isEqualTo(LONG_HISTOGRAM_BUCKETS);
+    assertThat(instrument4.getRequiredLabelKeys()).isEqualTo(REQUIRED_LABEL_KEYS);
+    assertThat(instrument4.getOptionalLabelKeys()).isEqualTo(OPTIONAL_LABEL_KEYS);
+    assertThat(instrument4.isEnableByDefault()).isTrue();
+  }
+
+  @Test
+  public void registerLongGaugeSuccess() {
+    LongGaugeMetricInstrument instrument4 = registry.registerLongGauge(
+        METRIC_NAME_1, DESCRIPTION_1, UNIT_1, REQUIRED_LABEL_KEYS,
+        OPTIONAL_LABEL_KEYS, ENABLED);
+    assertThat(registry.getMetricInstruments().contains(instrument4)).isTrue();
+    assertThat(registry.getMetricInstruments().size()).isEqualTo(1);
+    assertThat(instrument4.getName()).isEqualTo(METRIC_NAME_1);
+    assertThat(instrument4.getDescription()).isEqualTo(DESCRIPTION_1);
+    assertThat(instrument4.getUnit()).isEqualTo(UNIT_1);
+    assertThat(instrument4.getRequiredLabelKeys()).isEqualTo(REQUIRED_LABEL_KEYS);
+    assertThat(instrument4.getOptionalLabelKeys()).isEqualTo(OPTIONAL_LABEL_KEYS);
+    assertThat(instrument4.isEnableByDefault()).isTrue();
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void registerDoubleCounterDuplicateName() {
+    registry.registerDoubleCounter(METRIC_NAME_1, DESCRIPTION_1, UNIT_1, REQUIRED_LABEL_KEYS,
+        OPTIONAL_LABEL_KEYS, ENABLED);
+    registry.registerDoubleCounter(METRIC_NAME_1, DESCRIPTION_2, UNIT_2, REQUIRED_LABEL_KEYS,
+        OPTIONAL_LABEL_KEYS, DISABLED);
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void registerLongCounterDuplicateName() {
+    registry.registerDoubleCounter(METRIC_NAME_1, DESCRIPTION_1, UNIT_1, REQUIRED_LABEL_KEYS,
+        OPTIONAL_LABEL_KEYS, ENABLED);
+    registry.registerLongCounter(METRIC_NAME_1, DESCRIPTION_2, UNIT_2, REQUIRED_LABEL_KEYS,
+        OPTIONAL_LABEL_KEYS, DISABLED);
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void registerDoubleHistogramDuplicateName() {
+    registry.registerLongHistogram(METRIC_NAME_1, DESCRIPTION_1, UNIT_1, LONG_HISTOGRAM_BUCKETS,
+        REQUIRED_LABEL_KEYS, OPTIONAL_LABEL_KEYS, ENABLED);
+    registry.registerDoubleHistogram(METRIC_NAME_1, DESCRIPTION_2, UNIT_2, DOUBLE_HISTOGRAM_BUCKETS,
+        REQUIRED_LABEL_KEYS, OPTIONAL_LABEL_KEYS, DISABLED);
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void registerLongHistogramDuplicateName() {
+    registry.registerLongCounter(METRIC_NAME_1, DESCRIPTION_1, UNIT_1, REQUIRED_LABEL_KEYS,
+        OPTIONAL_LABEL_KEYS, ENABLED);
+    registry.registerLongHistogram(METRIC_NAME_1, DESCRIPTION_2, UNIT_2, LONG_HISTOGRAM_BUCKETS,
+        REQUIRED_LABEL_KEYS, OPTIONAL_LABEL_KEYS, DISABLED);
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void registerLongGaugeDuplicateName() {
+    registry.registerDoubleHistogram(METRIC_NAME_1, DESCRIPTION_1, UNIT_1, DOUBLE_HISTOGRAM_BUCKETS,
+        REQUIRED_LABEL_KEYS, OPTIONAL_LABEL_KEYS, ENABLED);
+    registry.registerLongGauge(METRIC_NAME_1, DESCRIPTION_2, UNIT_2, REQUIRED_LABEL_KEYS,
+        OPTIONAL_LABEL_KEYS, DISABLED);
+  }
+
+  @Test
+  public void getMetricInstrumentsMultipleRegistered() {
+    DoubleCounterMetricInstrument instrument1 = registry.registerDoubleCounter(
+        "testMetric1", DESCRIPTION_1, UNIT_1, REQUIRED_LABEL_KEYS, OPTIONAL_LABEL_KEYS, ENABLED);
+    LongCounterMetricInstrument instrument2 = registry.registerLongCounter(
+        "testMetric2", DESCRIPTION_2, UNIT_2, REQUIRED_LABEL_KEYS, OPTIONAL_LABEL_KEYS, DISABLED);
+    DoubleHistogramMetricInstrument instrument3 = registry.registerDoubleHistogram(
+        "testMetric3", DESCRIPTION_2, UNIT_2, DOUBLE_HISTOGRAM_BUCKETS, REQUIRED_LABEL_KEYS,
+        OPTIONAL_LABEL_KEYS, DISABLED);
+
+    List<MetricInstrument> instruments = registry.getMetricInstruments();
+    assertThat(instruments.size()).isEqualTo(3);
+    assertThat(instruments.contains(instrument1)).isTrue();
+    assertThat(instruments.contains(instrument2)).isTrue();
+    assertThat(instruments.contains(instrument3)).isTrue();
+  }
+
+  @Test
+  public void resizeMetricInstrumentsCapacityIncrease() {
+    int initialCapacity = INITIAL_INSTRUMENT_CAPACITY;
+    MetricInstrumentRegistry testRegistry = new MetricInstrumentRegistry();
+
+    // Registering enough instruments to trigger resize
+    for (int i = 0; i < initialCapacity + 1; i++) {
+      testRegistry.registerLongHistogram("name" + i, "desc", "unit", ImmutableList.of(),
+          ImmutableList.of(), ImmutableList.of(), true);
+    }
+
+    assertThat(testRegistry.getMetricInstruments().size()).isGreaterThan(initialCapacity);
+  }
+
+}
diff --git a/api/src/test/java/io/grpc/NameResolverRegistryTest.java b/api/src/test/java/io/grpc/NameResolverRegistryTest.java
new file mode 100644
index 00000000000..2fd23e3a974
--- /dev/null
+++ b/api/src/test/java/io/grpc/NameResolverRegistryTest.java
@@ -0,0 +1,269 @@
+/*
+ * Copyright 2016 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.internal.DnsNameResolverProvider;
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.net.URI;
+import java.util.List;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link NameResolverRegistry}. */
+@RunWith(JUnit4.class)
+public class NameResolverRegistryTest {
+  private final URI uri = URI.create("dns:///localhost");
+  private final NameResolver.Args args = NameResolver.Args.newBuilder()
+      .setDefaultPort(8080)
+      .setProxyDetector(mock(ProxyDetector.class))
+      .setSynchronizationContext(new SynchronizationContext(mock(UncaughtExceptionHandler.class)))
+      .setServiceConfigParser(mock(ServiceConfigParser.class))
+      .setChannelLogger(mock(ChannelLogger.class))
+      .build();
+
+  @Test
+  public void register_unavilableProviderThrows() {
+    NameResolverRegistry reg = new NameResolverRegistry();
+    try {
+      reg.register(new BaseProvider(false, 5));
+      fail("Should throw");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().contains("isAvailable() returned false");
+    }
+    assertThat(reg.providers()).isEmpty();
+  }
+
+  @Test
+  public void deregister() {
+    NameResolverRegistry reg = new NameResolverRegistry();
+    NameResolverProvider p1 = new BaseProvider(true, 5);
+    NameResolverProvider p2 = new BaseProvider(true, 5);
+    NameResolverProvider p3 = new BaseProvider(true, 5);
+    String sameScheme = p1.getDefaultScheme();
+    reg.register(p1);
+    reg.register(p2);
+    reg.register(p3);
+    assertThat(reg.providers().get(sameScheme)).isSameInstanceAs(p1);
+    reg.deregister(p2);
+    assertThat(reg.providers().get(sameScheme)).isSameInstanceAs(p1);
+    reg.deregister(p1);
+    assertThat(reg.providers().get(sameScheme)).isSameInstanceAs(p3);
+
+  }
+
+  @Test
+  public void provider_sorted() {
+    NameResolverRegistry reg = new NameResolverRegistry();
+    NameResolverProvider p1 = new BaseProvider(true, 5);
+    NameResolverProvider p2 = new BaseProvider(true, 3);
+    NameResolverProvider p3 = new BaseProvider(true, 8);
+    NameResolverProvider p4 = new BaseProvider(true, 3);
+    NameResolverProvider p5 = new BaseProvider(true, 8);
+    String sameScheme = p1.getDefaultScheme();
+    reg.register(p1);
+    reg.register(p2);
+    reg.register(p3);
+    reg.register(p4);
+    reg.register(p5);
+    assertThat(reg.providers().get(sameScheme)).isSameInstanceAs(p3);
+  }
+
+  @Test
+  public void getDefaultScheme_noProvider() {
+    NameResolver.Factory factory = new NameResolverRegistry().asFactory();
+    assertThat(factory.getDefaultScheme()).isEqualTo("unknown");
+  }
+
+  @Test
+  public void newNameResolver_providerReturnsNull() {
+    NameResolverRegistry registry = new NameResolverRegistry();
+    registry.register(
+        new BaseProvider(true, 5, "noScheme") {
+          @Override
+          public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
+            assertThat(passedUri).isSameInstanceAs(uri);
+            assertThat(passedArgs).isSameInstanceAs(args);
+            return null;
+          }
+        });
+    assertThat(registry.asFactory().newNameResolver(uri, args)).isNull();
+    assertThat(registry.asFactory().getDefaultScheme()).isEqualTo("noScheme");
+  }
+
+  @Test
+  public void newNameResolver_providerReturnsNonNull() {
+    NameResolverRegistry registry = new NameResolverRegistry();
+    registry.register(new BaseProvider(true, 5, uri.getScheme()) {
+      @Override
+      public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
+        return null;
+      }
+    });
+    final NameResolver nr = new NameResolver() {
+      @Override public String getServiceAuthority() {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override public void start(Listener2 listener) {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override public void shutdown() {
+        throw new UnsupportedOperationException();
+      }
+    };
+    registry.register(
+        new BaseProvider(true, 4, uri.getScheme()) {
+          @Override
+          public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
+            return nr;
+          }
+        });
+    registry.register(
+        new BaseProvider(true, 3, uri.getScheme()) {
+          @Override
+          public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
+            fail("Should not be called");
+            throw new AssertionError();
+          }
+        });
+    assertThat(registry.asFactory().newNameResolver(uri, args)).isNull();
+    assertThat(registry.asFactory().getDefaultScheme()).isEqualTo(uri.getScheme());
+  }
+
+  @Test
+  public void newNameResolver_multipleScheme() {
+    NameResolverRegistry registry = new NameResolverRegistry();
+    registry.register(new BaseProvider(true, 5, uri.getScheme()) {
+      @Override
+      public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
+        return null;
+      }
+    });
+    final NameResolver nr = new NameResolver() {
+      @Override public String getServiceAuthority() {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override public void start(Listener2 listener) {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override public void shutdown() {
+        throw new UnsupportedOperationException();
+      }
+    };
+    registry.register(
+        new BaseProvider(true, 4, "other") {
+          @Override
+          public NameResolver newNameResolver(URI passedUri, NameResolver.Args passedArgs) {
+            return nr;
+          }
+        });
+
+    assertThat(registry.asFactory().newNameResolver(uri, args)).isNull();
+    assertThat(registry.asFactory().newNameResolver(URI.create("/0.0.0.0:80"), args)).isNull();
+    assertThat(registry.asFactory().newNameResolver(URI.create("///0.0.0.0:80"), args)).isNull();
+    assertThat(registry.asFactory().newNameResolver(URI.create("other:///0.0.0.0:80"), args))
+            .isSameInstanceAs(nr);
+    assertThat(registry.asFactory().newNameResolver(URI.create("OTHER:///0.0.0.0:80"), args))
+            .isSameInstanceAs(nr);
+    assertThat(registry.asFactory().getDefaultScheme()).isEqualTo("dns");
+  }
+
+  @Test
+  public void newNameResolver_noProvider() {
+    NameResolver.Factory factory = new NameResolverRegistry().asFactory();
+    assertThat(factory.newNameResolver(uri, args)).isNull();
+    assertThat(factory.getDefaultScheme()).isEqualTo("unknown");
+  }
+
+  @Test
+  public void baseProviders() {
+    Map<String, NameResolverProvider> providers =
+            NameResolverRegistry.getDefaultRegistry().providers();
+    assertThat(providers).hasSize(1);
+    // 2 name resolvers from core
+    assertThat(providers.get("dns"))
+        .isInstanceOf(io.grpc.internal.DnsNameResolverProvider.class);
+    assertThat(NameResolverRegistry.getDefaultRegistry().asFactory().getDefaultScheme())
+        .isEqualTo("dns");
+  }
+
+  @Test
+  public void getClassesViaHardcoded_classesPresent() throws Exception {
+    List<Class<?>> classes = NameResolverRegistry.getHardCodedClasses();
+    assertThat(classes).containsExactly(io.grpc.internal.DnsNameResolverProvider.class);
+  }
+
+  @Test
+  public void provided() {
+    for (NameResolverProvider current
+        : InternalServiceProviders.getCandidatesViaServiceLoader(
+        NameResolverProvider.class, getClass().getClassLoader())) {
+      if (current instanceof DnsNameResolverProvider) {
+        return;
+      }
+    }
+    fail("DnsNameResolverProvider not registered");
+  }
+
+  private static class BaseProvider extends NameResolverProvider {
+    private final boolean isAvailable;
+    private final int priority;
+    private final String scheme;
+
+    public BaseProvider(boolean isAvailable, int priority) {
+      this.isAvailable = isAvailable;
+      this.priority = priority;
+      this.scheme = null;
+    }
+
+    public BaseProvider(boolean isAvailable, int priority, String scheme) {
+      this.isAvailable = isAvailable;
+      this.priority = priority;
+      this.scheme = scheme;
+    }
+
+    @Override
+    protected boolean isAvailable() {
+      return isAvailable;
+    }
+
+    @Override
+    protected int priority() {
+      return priority;
+    }
+
+    @Override
+    public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public String getDefaultScheme() {
+      return scheme == null ? "scheme" + getClass().getSimpleName() : scheme;
+    }
+  }
+}
diff --git a/api/src/test/java/io/grpc/NameResolverTest.java b/api/src/test/java/io/grpc/NameResolverTest.java
new file mode 100644
index 00000000000..82abe5c7505
--- /dev/null
+++ b/api/src/test/java/io/grpc/NameResolverTest.java
@@ -0,0 +1,257 @@
+/*
+ * Copyright 2017 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.base.Objects;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.NameResolver.Listener2;
+import io.grpc.NameResolver.ResolutionResult;
+import io.grpc.NameResolver.ServiceConfigParser;
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.net.SocketAddress;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for the inner classes in {@link NameResolver}. */
+@RunWith(JUnit4.class)
+public class NameResolverTest {
+  private static final List<EquivalentAddressGroup> ADDRESSES =
+      Collections.singletonList(
+          new EquivalentAddressGroup(new FakeSocketAddress("fake-address-1"), Attributes.EMPTY));
+  private static final Attributes.Key<String> YOLO_ATTR_KEY = Attributes.Key.create("yolo");
+  private static Attributes ATTRIBUTES =
+      Attributes.newBuilder().set(YOLO_ATTR_KEY, "To be, or not to be?").build();
+  private static final NameResolver.Args.Key<Integer> FOO_ARG_KEY =
+      NameResolver.Args.Key.create("foo");
+  private static final NameResolver.Args.Key<Integer> BAR_ARG_KEY =
+          NameResolver.Args.Key.create("bar");
+  private static ConfigOrError CONFIG = ConfigOrError.fromConfig("foo");
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  private final int defaultPort = 293;
+  private final ProxyDetector proxyDetector = mock(ProxyDetector.class);
+  private final SynchronizationContext syncContext =
+      new SynchronizationContext(mock(UncaughtExceptionHandler.class));
+  private final ServiceConfigParser parser = mock(ServiceConfigParser.class);
+  private final ScheduledExecutorService scheduledExecutorService =
+      mock(ScheduledExecutorService.class);
+  private final ChannelLogger channelLogger = mock(ChannelLogger.class);
+  private final Executor executor = Executors.newSingleThreadExecutor();
+  private final String overrideAuthority = "grpc.io";
+  private final MetricRecorder metricRecorder = new MetricRecorder() {};
+  private final int customArgValue = 42;
+  @Mock NameResolver.Listener mockListener;
+
+  @Test
+  public void args() {
+    NameResolver.Args args = createArgs();
+    assertThat(args.getDefaultPort()).isEqualTo(defaultPort);
+    assertThat(args.getProxyDetector()).isSameInstanceAs(proxyDetector);
+    assertThat(args.getSynchronizationContext()).isSameInstanceAs(syncContext);
+    assertThat(args.getServiceConfigParser()).isSameInstanceAs(parser);
+    assertThat(args.getScheduledExecutorService()).isSameInstanceAs(scheduledExecutorService);
+    assertThat(args.getChannelLogger()).isSameInstanceAs(channelLogger);
+    assertThat(args.getOffloadExecutor()).isSameInstanceAs(executor);
+    assertThat(args.getOverrideAuthority()).isSameInstanceAs(overrideAuthority);
+    assertThat(args.getMetricRecorder()).isSameInstanceAs(metricRecorder);
+    assertThat(args.getArg(FOO_ARG_KEY)).isEqualTo(customArgValue);
+    assertThat(args.getArg(BAR_ARG_KEY)).isNull();
+
+    NameResolver.Args args2 = args.toBuilder().build();
+    assertThat(args2.getDefaultPort()).isEqualTo(defaultPort);
+    assertThat(args2.getProxyDetector()).isSameInstanceAs(proxyDetector);
+    assertThat(args2.getSynchronizationContext()).isSameInstanceAs(syncContext);
+    assertThat(args2.getServiceConfigParser()).isSameInstanceAs(parser);
+    assertThat(args2.getScheduledExecutorService()).isSameInstanceAs(scheduledExecutorService);
+    assertThat(args2.getChannelLogger()).isSameInstanceAs(channelLogger);
+    assertThat(args2.getOffloadExecutor()).isSameInstanceAs(executor);
+    assertThat(args2.getOverrideAuthority()).isSameInstanceAs(overrideAuthority);
+    assertThat(args.getMetricRecorder()).isSameInstanceAs(metricRecorder);
+    assertThat(args.getArg(FOO_ARG_KEY)).isEqualTo(customArgValue);
+    assertThat(args.getArg(BAR_ARG_KEY)).isNull();
+
+    assertThat(args2).isNotSameInstanceAs(args);
+    assertThat(args2).isNotEqualTo(args);
+  }
+
+  private NameResolver.Args createArgs() {
+    return NameResolver.Args.newBuilder()
+        .setDefaultPort(defaultPort)
+        .setProxyDetector(proxyDetector)
+        .setSynchronizationContext(syncContext)
+        .setServiceConfigParser(parser)
+        .setScheduledExecutorService(scheduledExecutorService)
+        .setChannelLogger(channelLogger)
+        .setOffloadExecutor(executor)
+        .setOverrideAuthority(overrideAuthority)
+        .setMetricRecorder(metricRecorder)
+        .setArg(FOO_ARG_KEY, customArgValue)
+        .build();
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void startOnOldListener_wrapperListener2UsedToStart() {
+    final Listener2[] listener2 = new Listener2[1];
+    NameResolver nameResolver = new NameResolver() {
+      @Override
+      public String getServiceAuthority() {
+        return null;
+      }
+
+      @Override
+      public void shutdown() {}
+
+      @Override
+      public void start(Listener2 listener2Arg) {
+        listener2[0] = listener2Arg;
+      }
+    };
+    nameResolver.start(mockListener);
+
+    listener2[0].onResult(ResolutionResult.newBuilder().setAddresses(ADDRESSES)
+        .setAttributes(ATTRIBUTES).build());
+    verify(mockListener).onAddresses(eq(ADDRESSES), eq(ATTRIBUTES));
+    listener2[0].onError(Status.CANCELLED);
+    verify(mockListener).onError(Status.CANCELLED);
+  }
+
+  @Test
+  @SuppressWarnings({"deprecation", "InlineMeInliner"})
+  public void listener2AddressesToListener2ResolutionResultConversion() {
+    final ResolutionResult[] resolutionResult = new ResolutionResult[1];
+    NameResolver.Listener2 listener2 = new Listener2() {
+      @Override
+      public void onResult(ResolutionResult resolutionResultArg) {
+        resolutionResult[0] = resolutionResultArg;
+      }
+
+      @Override
+      public void onError(Status error) {}
+    };
+
+    listener2.onAddresses(ADDRESSES, ATTRIBUTES);
+
+    assertThat(resolutionResult[0].getAddressesOrError().getValue()).isEqualTo(ADDRESSES);
+    assertThat(resolutionResult[0].getAttributes()).isEqualTo(ATTRIBUTES);
+  }
+
+  @Test
+  public void resolutionResult_toString_addressesAttributesAndConfig() {
+    ResolutionResult resolutionResult = ResolutionResult.newBuilder()
+        .setAddressesOrError(StatusOr.fromValue(ADDRESSES))
+        .setAttributes(ATTRIBUTES)
+        .setServiceConfig(CONFIG)
+        .build();
+
+    assertThat(resolutionResult.toString()).isEqualTo(
+        "ResolutionResult{addressesOrError=StatusOr{value="
+            + "[[[FakeSocketAddress-fake-address-1]/{}]]}, attributes={yolo=To be, or not to be?}, "
+            + "serviceConfigOrError=ConfigOrError{config=foo}}");
+  }
+
+  @Test
+  public void resolutionResult_hashCode() {
+    ResolutionResult resolutionResult = ResolutionResult.newBuilder()
+        .setAddressesOrError(StatusOr.fromValue(ADDRESSES))
+        .setAttributes(ATTRIBUTES)
+        .setServiceConfig(CONFIG)
+        .build();
+
+    assertThat(resolutionResult.hashCode()).isEqualTo(
+        Objects.hashCode(StatusOr.fromValue(ADDRESSES), ATTRIBUTES, CONFIG));
+  }
+
+  @Test
+  public void startOnOldListener_resolverReportsError() {
+    final boolean[] onErrorCalled = new boolean[1];
+    final Status[] receivedError = new Status[1];
+
+    NameResolver resolver = new NameResolver() {
+      @Override
+      public String getServiceAuthority() {
+        return "example.com";
+      }
+
+      @Override
+      public void shutdown() {
+      }
+
+      @Override
+      public void start(Listener2 listener2) {
+        ResolutionResult errorResult = ResolutionResult.newBuilder()
+            .setAddressesOrError(StatusOr.fromStatus(
+                Status.UNAVAILABLE
+                    .withDescription("DNS resolution failed with UNAVAILABLE")))
+            .build();
+
+        listener2.onResult(errorResult);
+      }
+    };
+
+    NameResolver.Listener listener = new NameResolver.Listener() {
+      @Override
+      public void onAddresses(
+          List<EquivalentAddressGroup> servers,
+          Attributes attributes) {
+        throw new AssertionError("Called onAddresses on error");
+      }
+
+      @Override
+      public void onError(Status error) {
+        onErrorCalled[0] = true;
+        receivedError[0] = error;
+      }
+    };
+
+    resolver.start(listener);
+
+    assertThat(onErrorCalled[0]).isTrue();
+    assertThat(receivedError[0].getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(receivedError[0].getDescription()).isEqualTo(
+        "DNS resolution failed with UNAVAILABLE");
+  }
+
+  private static class FakeSocketAddress extends SocketAddress {
+    final String name;
+
+    FakeSocketAddress(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public String toString() {
+      return "FakeSocketAddress-" + name;
+    }
+  }
+}
diff --git a/api/src/test/java/io/grpc/PersistentHashArrayMappedTrieTest.java b/api/src/test/java/io/grpc/PersistentHashArrayMappedTrieTest.java
new file mode 100644
index 00000000000..aeac2f51a5b
--- /dev/null
+++ b/api/src/test/java/io/grpc/PersistentHashArrayMappedTrieTest.java
@@ -0,0 +1,261 @@
+/*
+ * Copyright 2017 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;
+
+import static junit.framework.TestCase.assertTrue;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+
+import io.grpc.PersistentHashArrayMappedTrie.CollisionLeaf;
+import io.grpc.PersistentHashArrayMappedTrie.CompressedIndex;
+import io.grpc.PersistentHashArrayMappedTrie.Leaf;
+import io.grpc.PersistentHashArrayMappedTrie.Node;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class PersistentHashArrayMappedTrieTest {
+  @Test
+  public void leaf_replace() {
+    Key key = new Key(0);
+    Object value1 = new Object();
+    Object value2 = new Object();
+    Leaf<Key, Object> leaf = new Leaf<>(key, value1);
+    Node<Key, Object> ret = leaf.put(key, value2, key.hashCode(), 0);
+    assertTrue(ret instanceof Leaf);
+    assertSame(value2, ret.get(key, key.hashCode(), 0));
+
+    assertSame(value1, leaf.get(key, key.hashCode(), 0));
+
+    assertEquals(1, leaf.size());
+    assertEquals(1, ret.size());
+  }
+
+  @Test
+  public void leaf_collision() {
+    Key key1 = new Key(0);
+    Key key2 = new Key(0);
+    Object value1 = new Object();
+    Object value2 = new Object();
+    Leaf<Key, Object> leaf = new Leaf<>(key1, value1);
+    Node<Key, Object> ret = leaf.put(key2, value2, key2.hashCode(), 0);
+    assertTrue(ret instanceof CollisionLeaf);
+    assertSame(value1, ret.get(key1, key1.hashCode(), 0));
+    assertSame(value2, ret.get(key2, key2.hashCode(), 0));
+
+    assertSame(value1, leaf.get(key1, key1.hashCode(), 0));
+    assertSame(null, leaf.get(key2, key2.hashCode(), 0));
+
+    assertEquals(1, leaf.size());
+    assertEquals(2, ret.size());
+  }
+
+  @Test
+  public void leaf_insert() {
+    Key key1 = new Key(0);
+    Key key2 = new Key(1);
+    Object value1 = new Object();
+    Object value2 = new Object();
+    Leaf<Key, Object> leaf = new Leaf<>(key1, value1);
+    Node<Key, Object> ret = leaf.put(key2, value2, key2.hashCode(), 0);
+    assertTrue(ret instanceof CompressedIndex);
+    assertSame(value1, ret.get(key1, key1.hashCode(), 0));
+    assertSame(value2, ret.get(key2, key2.hashCode(), 0));
+
+    assertSame(value1, leaf.get(key1, key1.hashCode(), 0));
+    assertSame(null, leaf.get(key2, key2.hashCode(), 0));
+
+    assertEquals(1, leaf.size());
+    assertEquals(2, ret.size());
+  }
+
+  @SuppressWarnings("CheckReturnValue")
+  @Test
+  public void collisionLeaf_assertKeysDifferent() {
+    Key key1 = new Key(0);
+    try {
+      new CollisionLeaf<>(key1, new Object(), key1, new Object());
+      throw new Error();
+    } catch (AssertionError expected) {
+    }
+  }
+
+  @SuppressWarnings("CheckReturnValue")
+  @Test
+  public void collisionLeaf_assertHashesSame() {
+    try {
+      new CollisionLeaf<>(new Key(0), new Object(), new Key(1), new Object());
+      throw new Error();
+    } catch (AssertionError expected) {
+    }
+  }
+
+  @Test
+  public void collisionLeaf_insert() {
+    Key key1 = new Key(0);
+    Key key2 = new Key(key1.hashCode());
+    Key insertKey = new Key(1);
+    Object value1 = new Object();
+    Object value2 = new Object();
+    Object insertValue = new Object();
+    CollisionLeaf<Key, Object> leaf =
+        new CollisionLeaf<>(key1, value1, key2, value2);
+
+    Node<Key, Object> ret = leaf.put(insertKey, insertValue, insertKey.hashCode(), 0);
+    assertTrue(ret instanceof CompressedIndex);
+    assertSame(value1, ret.get(key1, key1.hashCode(), 0));
+    assertSame(value2, ret.get(key2, key2.hashCode(), 0));
+    assertSame(insertValue, ret.get(insertKey, insertKey.hashCode(), 0));
+
+    assertSame(value1, leaf.get(key1, key1.hashCode(), 0));
+    assertSame(value2, leaf.get(key2, key2.hashCode(), 0));
+    assertSame(null, leaf.get(insertKey, insertKey.hashCode(), 0));
+
+    assertEquals(2, leaf.size());
+    assertEquals(3, ret.size());
+  }
+
+  @Test
+  public void collisionLeaf_replace() {
+    Key replaceKey = new Key(0);
+    Object originalValue = new Object();
+    Key key = new Key(replaceKey.hashCode());
+    Object value = new Object();
+    CollisionLeaf<Key, Object> leaf =
+        new CollisionLeaf<>(replaceKey, originalValue, key, value);
+    Object replaceValue = new Object();
+    Node<Key, Object> ret = leaf.put(replaceKey, replaceValue, replaceKey.hashCode(), 0);
+    assertTrue(ret instanceof CollisionLeaf);
+    assertSame(replaceValue, ret.get(replaceKey, replaceKey.hashCode(), 0));
+    assertSame(value, ret.get(key, key.hashCode(), 0));
+
+    assertSame(value, leaf.get(key, key.hashCode(), 0));
+    assertSame(originalValue, leaf.get(replaceKey, replaceKey.hashCode(), 0));
+
+    assertEquals(2, leaf.size());
+    assertEquals(2, ret.size());
+  }
+
+  @Test
+  public void collisionLeaf_collision() {
+    Key key1 = new Key(0);
+    Key key2 = new Key(key1.hashCode());
+    Key key3 = new Key(key1.hashCode());
+    Object value1 = new Object();
+    Object value2 = new Object();
+    Object value3 = new Object();
+    CollisionLeaf<Key, Object> leaf =
+        new CollisionLeaf<>(key1, value1, key2, value2);
+
+    Node<Key, Object> ret = leaf.put(key3, value3, key3.hashCode(), 0);
+    assertTrue(ret instanceof CollisionLeaf);
+    assertSame(value1, ret.get(key1, key1.hashCode(), 0));
+    assertSame(value2, ret.get(key2, key2.hashCode(), 0));
+    assertSame(value3, ret.get(key3, key3.hashCode(), 0));
+
+    assertSame(value1, leaf.get(key1, key1.hashCode(), 0));
+    assertSame(value2, leaf.get(key2, key2.hashCode(), 0));
+    assertSame(null, leaf.get(key3, key3.hashCode(), 0));
+
+    assertEquals(2, leaf.size());
+    assertEquals(3, ret.size());
+  }
+
+  @Test
+  public void compressedIndex_combine_differentIndexBit() {
+    final Key key1 = new Key(7);
+    final Key key2 = new Key(19);
+    final Object value1 = new Object();
+    final Object value2 = new Object();
+    Leaf<Key, Object> leaf1 = new Leaf<>(key1, value1);
+    Leaf<Key, Object> leaf2 = new Leaf<>(key2, value2);
+    class Verifier {
+      private void verify(Node<Key, Object> ret) {
+        CompressedIndex<Key, Object> collisionLeaf = (CompressedIndex<Key, Object>) ret;
+        assertEquals((1 << 7) | (1 << 19), collisionLeaf.bitmap);
+        assertEquals(2, collisionLeaf.values.length);
+        assertSame(value1, collisionLeaf.values[0].get(key1, key1.hashCode(), 0));
+        assertSame(value2, collisionLeaf.values[1].get(key2, key2.hashCode(), 0));
+
+        assertSame(value1, ret.get(key1, key1.hashCode(), 0));
+        assertSame(value2, ret.get(key2, key2.hashCode(), 0));
+
+        assertEquals(2, ret.size());
+      }
+    }
+
+    Verifier verifier = new Verifier();
+    verifier.verify(CompressedIndex.combine(leaf1, key1.hashCode(), leaf2, key2.hashCode(), 0));
+    verifier.verify(CompressedIndex.combine(leaf2, key2.hashCode(), leaf1, key1.hashCode(), 0));
+
+    assertEquals(1, leaf1.size());
+    assertEquals(1, leaf2.size());
+  }
+
+  @Test
+  public void compressedIndex_combine_sameIndexBit() {
+    final Key key1 = new Key(17 << 5 | 1); // 5 bit regions: (17, 1)
+    final Key key2 = new Key(31 << 5 | 1); // 5 bit regions: (31, 1)
+    final Object value1 = new Object();
+    final Object value2 = new Object();
+    Leaf<Key, Object> leaf1 = new Leaf<>(key1, value1);
+    Leaf<Key, Object> leaf2 = new Leaf<>(key2, value2);
+    class Verifier {
+      private void verify(Node<Key, Object> ret) {
+        CompressedIndex<Key, Object> collisionInternal = (CompressedIndex<Key, Object>) ret;
+        assertEquals(1 << 1, collisionInternal.bitmap);
+        assertEquals(1, collisionInternal.values.length);
+        CompressedIndex<Key, Object> collisionLeaf =
+            (CompressedIndex<Key, Object>) collisionInternal.values[0];
+        assertEquals((1 << 31) | (1 << 17), collisionLeaf.bitmap);
+        assertSame(value1, ret.get(key1, key1.hashCode(), 0));
+        assertSame(value2, ret.get(key2, key2.hashCode(), 0));
+
+        assertEquals(2, ret.size());
+      }
+    }
+
+    Verifier verifier = new Verifier();
+    verifier.verify(CompressedIndex.combine(leaf1, key1.hashCode(), leaf2, key2.hashCode, 0));
+    verifier.verify(CompressedIndex.combine(leaf2, key2.hashCode(), leaf1, key1.hashCode, 0));
+
+    assertEquals(1, leaf1.size());
+    assertEquals(1, leaf2.size());
+  }
+
+  /**
+   * A key with a settable hashcode.
+   */
+  static final class Key {
+    private final int hashCode;
+
+    Key(int hashCode) {
+      this.hashCode = hashCode;
+    }
+
+    @Override
+    public int hashCode() {
+      return hashCode;
+    }
+
+    @Override
+    public String toString() {
+      return String.format("Key(hashCode=%x)", hashCode);
+    }
+  }
+}
diff --git a/api/src/test/java/io/grpc/ReplacingClassLoader.java b/api/src/test/java/io/grpc/ReplacingClassLoader.java
new file mode 100644
index 00000000000..0cd34f80135
--- /dev/null
+++ b/api/src/test/java/io/grpc/ReplacingClassLoader.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2016 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;
+
+import java.io.IOException;
+import java.net.URL;
+import java.util.Enumeration;
+
+/**
+ * A ClassLoader to help test service providers.
+ */
+public class ReplacingClassLoader extends ClassLoader {
+  private final String resource;
+  private final String replacement;
+
+  /**
+   * Construct an instance where {@code replacement} is loaded instead of {@code resource}.
+   */
+  public ReplacingClassLoader(ClassLoader parent, String resource, String replacement) {
+    super(parent);
+    this.resource = resource;
+    this.replacement = replacement;
+  }
+
+  @Override
+  public URL getResource(String name) {
+    if (resource.equals(name)) {
+      return getParent().getResource(replacement);
+    }
+    return super.getResource(name);
+  }
+
+  @Override
+  public Enumeration<URL> getResources(String name) throws IOException {
+    if (resource.equals(name)) {
+      return getParent().getResources(replacement);
+    }
+    return super.getResources(name);
+  }
+}
+
diff --git a/core/src/test/java/io/grpc/ServerInterceptorsTest.java b/api/src/test/java/io/grpc/ServerInterceptorsTest.java
similarity index 75%
rename from core/src/test/java/io/grpc/ServerInterceptorsTest.java
rename to api/src/test/java/io/grpc/ServerInterceptorsTest.java
index 3ab50e4ece2..b84b3838afa 100644
--- a/core/src/test/java/io/grpc/ServerInterceptorsTest.java
+++ b/api/src/test/java/io/grpc/ServerInterceptorsTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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;
@@ -34,18 +19,19 @@
 import static com.google.common.collect.Iterables.getOnlyElement;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.same;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
 
 import io.grpc.MethodDescriptor.Marshaller;
 import io.grpc.MethodDescriptor.MethodType;
 import io.grpc.ServerCall.Listener;
-import io.grpc.testing.NoopServerCall;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.util.ArrayList;
@@ -53,16 +39,22 @@
 import java.util.List;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /** Unit tests for {@link ServerInterceptors}. */
 @RunWith(JUnit4.class)
 public class ServerInterceptorsTest {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
   @Mock
   private Marshaller<String> requestMarshaller;
 
@@ -77,7 +69,7 @@ public class ServerInterceptorsTest {
 
   private MethodDescriptor<String, Integer> flowMethod;
 
-  private ServerCall<String, Integer> call = new NoopServerCall<String, Integer>();
+  private ServerCall<String, Integer> call = new NoopServerCall<>();
 
   private ServerServiceDefinition serviceDefinition;
 
@@ -86,7 +78,6 @@ public class ServerInterceptorsTest {
   /** Set up for test. */
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
     flowMethod = MethodDescriptor.<String, Integer>newBuilder()
         .setType(MethodType.UNKNOWN)
         .setFullMethodName("basic/flow")
@@ -94,8 +85,10 @@ public void setUp() {
         .setResponseMarshaller(responseMarshaller)
         .build();
 
-    Mockito.when(handler.startCall(
-        Mockito.<ServerCall<String, Integer>>any(), Mockito.<Metadata>any()))
+    Mockito.when(
+            handler.startCall(
+                ArgumentMatchers.<ServerCall<String, Integer>>any(),
+                ArgumentMatchers.<Metadata>any()))
             .thenReturn(listener);
 
     serviceDefinition = ServerServiceDefinition.builder(new ServiceDescriptor("basic", flowMethod))
@@ -105,25 +98,30 @@ public void setUp() {
   /** Final checks for all tests. */
   @After
   public void makeSureExpectedMocksUnused() {
-    verifyZeroInteractions(requestMarshaller);
-    verifyZeroInteractions(responseMarshaller);
-    verifyZeroInteractions(listener);
+    verifyNoInteractions(requestMarshaller);
+    verifyNoInteractions(responseMarshaller);
+    verifyNoInteractions(listener);
   }
 
-  @Test(expected = NullPointerException.class)
+  @Test
   public void npeForNullServiceDefinition() {
     ServerServiceDefinition serviceDef = null;
-    ServerInterceptors.intercept(serviceDef, Arrays.<ServerInterceptor>asList());
+    List<ServerInterceptor> interceptors = Arrays.asList();
+    assertThrows(NullPointerException.class,
+        () -> ServerInterceptors.intercept(serviceDef, interceptors));
   }
 
-  @Test(expected = NullPointerException.class)
+  @Test
   public void npeForNullInterceptorList() {
-    ServerInterceptors.intercept(serviceDefinition, (List<ServerInterceptor>) null);
+    assertThrows(NullPointerException.class,
+        () -> ServerInterceptors.intercept(serviceDefinition, (List<ServerInterceptor>) null));
   }
 
-  @Test(expected = NullPointerException.class)
+  @Test
   public void npeForNullInterceptor() {
-    ServerInterceptors.intercept(serviceDefinition, Arrays.asList((ServerInterceptor) null));
+    List<ServerInterceptor> interceptors = Arrays.asList((ServerInterceptor) null);
+    assertThrows(NullPointerException.class,
+        () -> ServerInterceptors.intercept(serviceDefinition, interceptors));
   }
 
   @Test
@@ -134,7 +132,8 @@ public void noop() {
 
   @Test
   public void multipleInvocationsOfHandler() {
-    ServerInterceptor interceptor = Mockito.spy(new NoopInterceptor());
+    ServerInterceptor interceptor =
+        mock(ServerInterceptor.class, delegatesTo(new NoopInterceptor()));
     ServerServiceDefinition intercepted
         = ServerInterceptors.intercept(serviceDefinition, Arrays.asList(interceptor));
     assertSame(listener,
@@ -197,7 +196,7 @@ public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
 
   @Test
   public void ordered() {
-    final List<String> order = new ArrayList<String>();
+    final List<String> order = new ArrayList<>();
     handler = new ServerCallHandler<String, Integer>() {
           @Override
           public ServerCall.Listener<String> startCall(
@@ -239,7 +238,7 @@ public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
 
   @Test
   public void orderedForward() {
-    final List<String> order = new ArrayList<String>();
+    final List<String> order = new ArrayList<>();
     handler = new ServerCallHandler<String, Integer>() {
       @Override
       public ServerCall.Listener<String> startCall(
@@ -281,8 +280,7 @@ public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
 
   @Test
   public void argumentsPassed() {
-    @SuppressWarnings("unchecked")
-    final ServerCall<String, Integer> call2 = new NoopServerCall<String, Integer>();
+    final ServerCall<String, Integer> call2 = new NoopServerCall<>();
     @SuppressWarnings("unchecked")
     final ServerCall.Listener<String> listener2 = mock(ServerCall.Listener.class);
 
@@ -309,7 +307,7 @@ public <R1, R2> ServerCall.Listener<R1> interceptCall(
   @Test
   @SuppressWarnings("unchecked")
   public void typedMarshalledMessages() {
-    final List<String> order = new ArrayList<String>();
+    final List<String> order = new ArrayList<>();
     Marshaller<Holder> marshaller = new Marshaller<Holder>() {
       @Override
       public InputStream stream(Holder value) {
@@ -411,7 +409,7 @@ public void onMessage(ReqT message) {
         .intercept(inputStreamMessageService, interceptor2);
     ServerMethodDefinition<InputStream, InputStream> serverMethod =
         (ServerMethodDefinition<InputStream, InputStream>) intercepted2.getMethod("basic/wrapped");
-    ServerCall<InputStream, InputStream> call2 = new NoopServerCall<InputStream, InputStream>();
+    ServerCall<InputStream, InputStream> call2 = new NoopServerCall<>();
     byte[] bytes = {};
     serverMethod
         .getServerCallHandler()
@@ -422,6 +420,80 @@ public void onMessage(ReqT message) {
         order);
   }
 
+  /**
+   * Tests the ServerInterceptors#useMarshalledMessages()} with two marshallers. Makes sure that
+   * on incoming request the request marshaller's stream method is called and on response the
+   * response marshaller's parse method is called
+   */
+  @Test
+  @SuppressWarnings("unchecked")
+  public void distinctMarshallerForRequestAndResponse() {
+    final List<String> requestFlowOrder = new ArrayList<>();
+
+    final Marshaller<String> requestMarshaller = new Marshaller<String>() {
+      @Override
+      public InputStream stream(String value) {
+        requestFlowOrder.add("RequestStream");
+        return null;
+      }
+
+      @Override
+      public String parse(InputStream stream) {
+        requestFlowOrder.add("RequestParse");
+        return null;
+      }
+    };
+    final Marshaller<String> responseMarshaller = new Marshaller<String>() {
+      @Override
+      public InputStream stream(String value) {
+        requestFlowOrder.add("ResponseStream");
+        return null;
+      }
+
+      @Override
+      public String parse(InputStream stream) {
+        requestFlowOrder.add("ResponseParse");
+        return null;
+      }
+    };
+    final Marshaller<Holder> dummyMarshaller = new Marshaller<Holder>() {
+      @Override
+      public InputStream stream(Holder value) {
+        return value.get();
+      }
+
+      @Override
+      public Holder parse(InputStream stream) {
+        return new Holder(stream);
+      }
+    };
+    ServerCallHandler<Holder, Holder> handler = (call, headers) -> new Listener<Holder>() {
+      @Override
+      public void onMessage(Holder message) {
+        requestFlowOrder.add("handler");
+        call.sendMessage(message);
+      }
+    };
+
+    MethodDescriptor<Holder, Holder> wrappedMethod = MethodDescriptor.<Holder, Holder>newBuilder()
+        .setType(MethodType.UNKNOWN)
+        .setFullMethodName("basic/wrapped")
+        .setRequestMarshaller(dummyMarshaller)
+        .setResponseMarshaller(dummyMarshaller)
+        .build();
+    ServerServiceDefinition serviceDef = ServerServiceDefinition.builder(
+            new ServiceDescriptor("basic", wrappedMethod))
+        .addMethod(wrappedMethod, handler).build();
+    ServerServiceDefinition intercepted = ServerInterceptors.useMarshalledMessages(serviceDef,
+        requestMarshaller, responseMarshaller);
+    ServerMethodDefinition<String, String> serverMethod =
+        (ServerMethodDefinition<String, String>) intercepted.getMethod("basic/wrapped");
+    ServerCall<String, String> serverCall = new NoopServerCall<>();
+    serverMethod.getServerCallHandler().startCall(serverCall, headers).onMessage("TestMessage");
+
+    assertEquals(Arrays.asList("RequestStream",  "handler", "ResponseParse"), requestFlowOrder);
+  }
+
   @SuppressWarnings("unchecked")
   private static ServerMethodDefinition<String, Integer> getSoleMethod(
       ServerServiceDefinition serviceDef) {
@@ -438,7 +510,7 @@ private static ServerMethodDefinition<String, Integer> getMethod(
   }
 
   private ServerCallHandler<String, Integer> anyCallHandler() {
-    return Mockito.<ServerCallHandler<String, Integer>>any();
+    return ArgumentMatchers.any();
   }
 
   private static class NoopInterceptor implements ServerInterceptor {
diff --git a/api/src/test/java/io/grpc/ServerRegistryTest.java b/api/src/test/java/io/grpc/ServerRegistryTest.java
new file mode 100644
index 00000000000..377f9eda737
--- /dev/null
+++ b/api/src/test/java/io/grpc/ServerRegistryTest.java
@@ -0,0 +1,178 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ServerRegistry}. */
+@RunWith(JUnit4.class)
+public class ServerRegistryTest {
+  private int port = 123;
+  private ServerCredentials creds = new ServerCredentials() {};
+
+  @Test
+  public void register_unavailableProviderThrows() {
+    ServerRegistry reg = new ServerRegistry();
+    try {
+      reg.register(new BaseProvider(false, 5));
+      fail("Should throw");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().contains("isAvailable() returned false");
+    }
+    assertThat(reg.providers()).isEmpty();
+  }
+
+  @Test
+  public void deregister() {
+    ServerRegistry reg = new ServerRegistry();
+    ServerProvider p1 = new BaseProvider(true, 5);
+    ServerProvider p2 = new BaseProvider(true, 5);
+    ServerProvider p3 = new BaseProvider(true, 5);
+    reg.register(p1);
+    reg.register(p2);
+    reg.register(p3);
+    assertThat(reg.providers()).containsExactly(p1, p2, p3).inOrder();
+    reg.deregister(p2);
+    assertThat(reg.providers()).containsExactly(p1, p3).inOrder();
+  }
+
+  @Test
+  public void provider_sorted() {
+    ServerRegistry reg = new ServerRegistry();
+    ServerProvider p1 = new BaseProvider(true, 5);
+    ServerProvider p2 = new BaseProvider(true, 3);
+    ServerProvider p3 = new BaseProvider(true, 8);
+    ServerProvider p4 = new BaseProvider(true, 3);
+    ServerProvider p5 = new BaseProvider(true, 8);
+    reg.register(p1);
+    reg.register(p2);
+    reg.register(p3);
+    reg.register(p4);
+    reg.register(p5);
+    assertThat(reg.providers()).containsExactly(p3, p5, p1, p2, p4).inOrder();
+  }
+
+  @Test
+  public void getProvider_noProvider() {
+    assertThat(new ServerRegistry().provider()).isNull();
+  }
+
+  @Test
+  public void newServerBuilderForPort_providerReturnsError() {
+    final String errorString = "brisking";
+    class ErrorProvider extends BaseProvider {
+      ErrorProvider() {
+        super(true, 5);
+      }
+
+      @Override
+      public NewServerBuilderResult newServerBuilderForPort(
+          int passedPort, ServerCredentials passedCreds) {
+        assertThat(passedPort).isEqualTo(port);
+        assertThat(passedCreds).isSameInstanceAs(creds);
+        return NewServerBuilderResult.error(errorString);
+      }
+    }
+
+    ServerRegistry registry = new ServerRegistry();
+    registry.register(new ErrorProvider());
+    try {
+      registry.newServerBuilderForPort(port, creds);
+      fail("expected exception");
+    } catch (ServerRegistry.ProviderNotFoundException ex) {
+      assertThat(ex).hasMessageThat().contains(errorString);
+      assertThat(ex).hasMessageThat().contains(ErrorProvider.class.getName());
+    }
+  }
+
+  @Test
+  public void newServerBuilderForPort_providerReturnsNonNull() {
+    ServerRegistry registry = new ServerRegistry();
+    registry.register(new BaseProvider(true, 5) {
+      @Override
+      public NewServerBuilderResult newServerBuilderForPort(
+          int passedPort, ServerCredentials passedCreds) {
+        return NewServerBuilderResult.error("dodging");
+      }
+    });
+    class MockServerBuilder extends ForwardingServerBuilder<MockServerBuilder> {
+      @Override public ServerBuilder<?> delegate() {
+        throw new UnsupportedOperationException();
+      }
+    }
+
+    final ServerBuilder<?> mcb = new MockServerBuilder();
+    registry.register(new BaseProvider(true, 4) {
+      @Override
+      public NewServerBuilderResult newServerBuilderForPort(
+          int passedPort, ServerCredentials passedCreds) {
+        return NewServerBuilderResult.serverBuilder(mcb);
+      }
+    });
+    registry.register(new BaseProvider(true, 3) {
+      @Override
+      public NewServerBuilderResult newServerBuilderForPort(
+          int passedPort, ServerCredentials passedCreds) {
+        fail("Should not be called");
+        throw new AssertionError();
+      }
+    });
+    assertThat(registry.newServerBuilderForPort(port, creds)).isSameInstanceAs(mcb);
+  }
+
+  @Test
+  public void newServerBuilderForPort_noProvider() {
+    ServerRegistry registry = new ServerRegistry();
+    try {
+      registry.newServerBuilderForPort(port, creds);
+      fail("expected exception");
+    } catch (ServerRegistry.ProviderNotFoundException ex) {
+      assertThat(ex).hasMessageThat().contains("No functional server found");
+      assertThat(ex).hasMessageThat().contains("grpc-netty");
+    }
+  }
+
+  private static class BaseProvider extends ServerProvider {
+    private final boolean isAvailable;
+    private final int priority;
+
+    public BaseProvider(boolean isAvailable, int priority) {
+      this.isAvailable = isAvailable;
+      this.priority = priority;
+    }
+
+    @Override
+    protected boolean isAvailable() {
+      return isAvailable;
+    }
+
+    @Override
+    protected int priority() {
+      return priority;
+    }
+
+    @Override
+    protected ServerBuilder<?> builderForPort(int port) {
+      throw new UnsupportedOperationException();
+    }
+  }
+}
diff --git a/api/src/test/java/io/grpc/ServerServiceDefinitionTest.java b/api/src/test/java/io/grpc/ServerServiceDefinitionTest.java
new file mode 100644
index 00000000000..9e43302e210
--- /dev/null
+++ b/api/src/test/java/io/grpc/ServerServiceDefinitionTest.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2016 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;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ServerServiceDefinition}. */
+@RunWith(JUnit4.class)
+public class ServerServiceDefinitionTest {
+  private String serviceName = "com.example.service";
+  private MethodDescriptor<String, Integer> method1 = MethodDescriptor.<String, Integer>newBuilder()
+      .setType(MethodDescriptor.MethodType.UNKNOWN)
+      .setFullMethodName(MethodDescriptor.generateFullMethodName(serviceName, "method1"))
+      .setRequestMarshaller(StringMarshaller.INSTANCE)
+      .setResponseMarshaller(IntegerMarshaller.INSTANCE)
+      .build();
+  private MethodDescriptor<String, Integer> diffMethod1 =
+      method1.toBuilder().setIdempotent(true).build();
+  private MethodDescriptor<String, Integer> method2 = method1.toBuilder()
+      .setFullMethodName(MethodDescriptor.generateFullMethodName(serviceName, "method2"))
+      .build();
+  private ServerCallHandler<String, Integer> methodHandler1
+      = new NoopServerCallHandler<>();
+  private ServerCallHandler<String, Integer> methodHandler2
+      = new NoopServerCallHandler<>();
+  private ServerMethodDefinition<String, Integer> methodDef1
+        = ServerMethodDefinition.create(method1, methodHandler1);
+  private ServerMethodDefinition<String, Integer> methodDef2
+        = ServerMethodDefinition.create(method2, methodHandler2);
+
+  @Test
+  public void noMethods() {
+    ServiceDescriptor sd = new ServiceDescriptor(serviceName);
+    ServerServiceDefinition ssd = ServerServiceDefinition.builder(sd)
+        .build();
+    assertSame(sd, ssd.getServiceDescriptor());
+    assertEquals(Collections.<MethodDescriptor<?, ?>>emptyList(),
+        new ArrayList<>(ssd.getServiceDescriptor().getMethods()));
+  }
+
+  @Test
+  public void addMethod_twoArg() {
+    ServiceDescriptor sd = new ServiceDescriptor(serviceName, method1, method2);
+    ServerServiceDefinition ssd = ServerServiceDefinition.builder(sd)
+        .addMethod(method1, methodHandler1)
+        .addMethod(method2, methodHandler2)
+        .build();
+    assertSame(sd, ssd.getServiceDescriptor());
+    for (ServerMethodDefinition<?, ?> serverMethod : ssd.getMethods()) {
+      MethodDescriptor<?, ?> method = serverMethod.getMethodDescriptor();
+      if (method1.equals(method)) {
+        assertSame(methodHandler1, serverMethod.getServerCallHandler());
+      } else if (method2.equals(method)) {
+        assertSame(methodHandler2, serverMethod.getServerCallHandler());
+      } else {
+        fail("Unexpected method descriptor: " + method.getFullMethodName());
+      }
+    }
+  }
+
+  @Test
+  public void addMethod_duplicateName() {
+    ServiceDescriptor sd = new ServiceDescriptor(serviceName, method1);
+    ServerServiceDefinition.Builder ssd = ServerServiceDefinition.builder(sd)
+        .addMethod(method1, methodHandler1);
+    assertThrows(IllegalStateException.class, () -> ssd.addMethod(diffMethod1, methodHandler2));
+  }
+
+  @Test
+  public void buildMisaligned_extraMethod() {
+    ServiceDescriptor sd = new ServiceDescriptor(serviceName);
+    ServerServiceDefinition.Builder ssd = ServerServiceDefinition.builder(sd)
+        .addMethod(methodDef1);
+    assertThrows(IllegalStateException.class, ssd::build);
+  }
+
+  @Test
+  public void buildMisaligned_diffMethodInstance() {
+    ServiceDescriptor sd = new ServiceDescriptor(serviceName, method1);
+    ServerServiceDefinition.Builder ssd = ServerServiceDefinition.builder(sd)
+        .addMethod(diffMethod1, methodHandler1);
+    assertThrows(IllegalStateException.class, ssd::build);
+  }
+
+  @Test
+  public void buildMisaligned_missingMethod() {
+    ServiceDescriptor sd = new ServiceDescriptor(serviceName, method1);
+    ServerServiceDefinition.Builder ssd = ServerServiceDefinition.builder(sd);
+    assertThrows(IllegalStateException.class, ssd::build);
+  }
+
+  @Test
+  public void builderWithServiceName() {
+    ServerServiceDefinition ssd = ServerServiceDefinition.builder(serviceName)
+        .addMethod(methodDef1)
+        .addMethod(methodDef2)
+        .build();
+    assertEquals(serviceName, ssd.getServiceDescriptor().getName());
+
+    HashSet<MethodDescriptor<?, ?>> goldenMethods = new HashSet<>();
+    goldenMethods.add(method1);
+    goldenMethods.add(method2);
+    assertEquals(goldenMethods,
+        new HashSet<>(ssd.getServiceDescriptor().getMethods()));
+
+    HashSet<ServerMethodDefinition<?, ?>> goldenMethodDefs
+        = new HashSet<>();
+    goldenMethodDefs.add(methodDef1);
+    goldenMethodDefs.add(methodDef2);
+    assertEquals(goldenMethodDefs, new HashSet<>(ssd.getMethods()));
+  }
+
+  @Test
+  public void builderWithServiceName_noMethods() {
+    ServerServiceDefinition ssd = ServerServiceDefinition.builder(serviceName)
+        .build();
+    assertEquals(Collections.<MethodDescriptor<?, ?>>emptyList(),
+        new ArrayList<>(ssd.getServiceDescriptor().getMethods()));
+    assertEquals(Collections.<ServerMethodDefinition<?, ?>>emptySet(),
+        new HashSet<>(ssd.getMethods()));
+  }
+
+  private static class NoopServerCallHandler<ReqT, RespT>
+      implements ServerCallHandler<ReqT, RespT> {
+    @Override
+    public ServerCall.Listener<ReqT> startCall(ServerCall<ReqT, RespT> call, Metadata headers) {
+      throw new UnsupportedOperationException();
+    }
+  }
+}
diff --git a/api/src/test/java/io/grpc/ServiceDescriptorTest.java b/api/src/test/java/io/grpc/ServiceDescriptorTest.java
new file mode 100644
index 00000000000..89bdead3632
--- /dev/null
+++ b/api/src/test/java/io/grpc/ServiceDescriptorTest.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2017 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.truth.StringSubject;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.testing.TestMethodDescriptors;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link ServiceDescriptor}.
+ */
+@RunWith(JUnit4.class)
+public class ServiceDescriptorTest {
+
+  @Test
+  public void failsOnNullName() {
+    List<MethodDescriptor<?, ?>> methods = Collections.emptyList();
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> new ServiceDescriptor(null, methods));
+    assertThat(e).hasMessageThat().isEqualTo("name");
+  }
+
+  @Test
+  public void failsOnNullMethods() {
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> new ServiceDescriptor("name", (Collection<MethodDescriptor<?, ?>>) null));
+    assertThat(e).hasMessageThat().isEqualTo("methods");
+  }
+
+  @Test
+  public void failsOnNullMethod() {
+    List<MethodDescriptor<?, ?>> methods = Collections.singletonList(null);
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> new ServiceDescriptor("name", methods));
+    assertThat(e).hasMessageThat().isEqualTo("method");
+  }
+
+  @Test
+  public void failsOnNonMatchingNames() {
+    List<MethodDescriptor<?, ?>> descriptors = Collections.<MethodDescriptor<?, ?>>singletonList(
+        MethodDescriptor.<Void, Void>newBuilder()
+          .setType(MethodType.UNARY)
+          .setFullMethodName(MethodDescriptor.generateFullMethodName("wrongService", "method"))
+          .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+          .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
+          .build());
+
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> new ServiceDescriptor("fooService", descriptors));
+    StringSubject error = assertThat(e).hasMessageThat();
+    error.contains("service names");
+    error.contains("fooService");
+    error.contains("wrongService");
+  }
+
+  @Test
+  public void failsOnNonDuplicateNames() {
+    List<MethodDescriptor<?, ?>> descriptors = Arrays.<MethodDescriptor<?, ?>>asList(
+        MethodDescriptor.<Void, Void>newBuilder()
+          .setType(MethodType.UNARY)
+          .setFullMethodName(MethodDescriptor.generateFullMethodName("name", "method"))
+          .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+          .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
+          .build(),
+        MethodDescriptor.<Void, Void>newBuilder()
+          .setType(MethodType.UNARY)
+          .setFullMethodName(MethodDescriptor.generateFullMethodName("name", "method"))
+          .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+          .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
+          .build());
+
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> new ServiceDescriptor("name", descriptors));
+    assertThat(e).hasMessageThat().isEqualTo("duplicate name name/method");
+  }
+
+  @Test
+  public void toStringTest() {
+    ServiceDescriptor descriptor = new ServiceDescriptor("package.service",
+        Arrays.<MethodDescriptor<?, ?>>asList(
+        MethodDescriptor.<Void, Void>newBuilder()
+          .setType(MethodType.UNARY)
+          .setFullMethodName(MethodDescriptor.generateFullMethodName("package.service",
+            "methodOne"))
+          .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+          .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
+          .build(),
+        MethodDescriptor.<Void, Void>newBuilder()
+          .setType(MethodType.UNARY)
+          .setFullMethodName(MethodDescriptor.generateFullMethodName("package.service",
+            "methodTwo"))
+          .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+          .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
+          .build()));
+
+    String toString = descriptor.toString();
+    assertTrue(toString.contains("ServiceDescriptor"));
+    assertTrue(toString.contains("name=package.service"));
+    assertTrue(toString.contains("package.service/methodOne"));
+    assertTrue(toString.contains("package.service/methodTwo"));
+  }
+}
diff --git a/api/src/test/java/io/grpc/ServiceProvidersTest.java b/api/src/test/java/io/grpc/ServiceProvidersTest.java
new file mode 100644
index 00000000000..7d4388a5bb9
--- /dev/null
+++ b/api/src/test/java/io/grpc/ServiceProvidersTest.java
@@ -0,0 +1,334 @@
+/*
+ * Copyright 2015 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;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.InternalServiceProviders.PriorityAccessor;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ServiceConfigurationError;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ServiceProviders}. */
+@RunWith(JUnit4.class)
+public class ServiceProvidersTest {
+  private static final List<Class<?>> NO_HARDCODED = Collections.emptyList();
+  private static final PriorityAccessor<ServiceProvidersTestAbstractProvider> ACCESSOR =
+      new PriorityAccessor<ServiceProvidersTestAbstractProvider>() {
+        @Override
+        public boolean isAvailable(ServiceProvidersTestAbstractProvider provider) {
+          return provider.isAvailable();
+        }
+
+        @Override
+        public int getPriority(ServiceProvidersTestAbstractProvider provider) {
+          return provider.priority();
+        }
+      };
+  private final String serviceFile =
+      "META-INF/services/io.grpc.ServiceProvidersTestAbstractProvider";
+
+  @Test
+  public void contextClassLoaderProvider() {
+    ClassLoader ccl = Thread.currentThread().getContextClassLoader();
+    try {
+      ClassLoader cl = new ReplacingClassLoader(
+          getClass().getClassLoader(),
+          serviceFile,
+          "io/grpc/ServiceProvidersTestAbstractProvider-multipleProvider.txt");
+
+      // test that the context classloader is used as fallback
+      ClassLoader rcll = new ReplacingClassLoader(
+          getClass().getClassLoader(),
+          serviceFile,
+          "io/grpc/ServiceProvidersTestAbstractProvider-empty.txt");
+      Thread.currentThread().setContextClassLoader(rcll);
+      assertEquals(
+          Available7Provider.class,
+          ServiceProviders.load(
+              ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR).getClass());
+    } finally {
+      Thread.currentThread().setContextClassLoader(ccl);
+    }
+  }
+
+  @Test
+  public void noProvider() {
+    ClassLoader ccl = Thread.currentThread().getContextClassLoader();
+    try {
+      ClassLoader cl = new ReplacingClassLoader(
+          getClass().getClassLoader(),
+          serviceFile,
+          "io/grpc/ServiceProvidersTestAbstractProvider-doesNotExist.txt");
+      Thread.currentThread().setContextClassLoader(cl);
+      assertNull(ServiceProviders.load(
+          ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR));
+    } finally {
+      Thread.currentThread().setContextClassLoader(ccl);
+    }
+  }
+
+  @Test
+  public void multipleProvider() throws Exception {
+    ClassLoader cl = new ReplacingClassLoader(getClass().getClassLoader(), serviceFile,
+        "io/grpc/ServiceProvidersTestAbstractProvider-multipleProvider.txt");
+    assertSame(
+        Available7Provider.class,
+        ServiceProviders.load(
+            ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR).getClass());
+
+    List<ServiceProvidersTestAbstractProvider> providers = ServiceProviders.loadAll(
+        ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+    assertEquals(3, providers.size());
+    assertEquals(Available7Provider.class, providers.get(0).getClass());
+    assertEquals(Available5Provider.class, providers.get(1).getClass());
+    assertEquals(Available0Provider.class, providers.get(2).getClass());
+  }
+
+  @Test
+  public void unavailableProvider() {
+    // tries to load Available7 and UnavailableProvider, which has priority 10
+    ClassLoader cl = new ReplacingClassLoader(getClass().getClassLoader(), serviceFile,
+        "io/grpc/ServiceProvidersTestAbstractProvider-unavailableProvider.txt");
+    assertEquals(
+        Available7Provider.class,
+        ServiceProviders.load(
+            ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR).getClass());
+  }
+
+  @Test
+  public void unknownClassProvider() {
+    ClassLoader cl = new ReplacingClassLoader(getClass().getClassLoader(), serviceFile,
+        "io/grpc/ServiceProvidersTestAbstractProvider-unknownClassProvider.txt");
+    try {
+      ServiceProviders.load(
+          ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+      fail("Exception expected");
+    } catch (ServiceConfigurationError e) {
+      // noop
+    }
+  }
+
+  @Test
+  public void exceptionSurfacedToCaller_failAtInit() {
+    ClassLoader cl = new ReplacingClassLoader(getClass().getClassLoader(), serviceFile,
+        "io/grpc/ServiceProvidersTestAbstractProvider-failAtInitProvider.txt");
+    try {
+      // Even though there is a working provider, if any providers fail then we should fail
+      // completely to avoid returning something unexpected.
+      ServiceProviders.load(
+          ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+      fail("Expected exception");
+    } catch (ServiceConfigurationError expected) {
+      // noop
+    }
+  }
+
+  @Test
+  public void exceptionSurfacedToCaller_failAtPriority() {
+    ClassLoader cl = new ReplacingClassLoader(getClass().getClassLoader(), serviceFile,
+        "io/grpc/ServiceProvidersTestAbstractProvider-failAtPriorityProvider.txt");
+    try {
+      // The exception should be surfaced to the caller
+      ServiceProviders.load(
+          ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+      fail("Expected exception");
+    } catch (FailAtPriorityProvider.PriorityException expected) {
+      // noop
+    }
+  }
+
+  @Test
+  public void exceptionSurfacedToCaller_failAtAvailable() {
+    ClassLoader cl = new ReplacingClassLoader(getClass().getClassLoader(), serviceFile,
+        "io/grpc/ServiceProvidersTestAbstractProvider-failAtAvailableProvider.txt");
+    try {
+      // The exception should be surfaced to the caller
+      ServiceProviders.load(
+          ServiceProvidersTestAbstractProvider.class, NO_HARDCODED, cl, ACCESSOR);
+      fail("Expected exception");
+    } catch (FailAtAvailableProvider.AvailableException expected) {
+      // noop
+    }
+  }
+
+  @Test
+  public void getCandidatesViaHardCoded_multipleProvider() throws Exception {
+    Iterator<ServiceProvidersTestAbstractProvider> candidates =
+        ServiceProviders.getCandidatesViaHardCoded(
+            ServiceProvidersTestAbstractProvider.class,
+            ImmutableList.<Class<?>>of(
+                Available7Provider.class,
+                Available0Provider.class))
+            .iterator();
+    assertEquals(Available7Provider.class, candidates.next().getClass());
+    assertEquals(Available0Provider.class, candidates.next().getClass());
+    assertFalse(candidates.hasNext());
+  }
+
+  @Test
+  public void getCandidatesViaHardCoded_failAtInit() throws Exception {
+    try {
+      ServiceProviders.getCandidatesViaHardCoded(
+          ServiceProvidersTestAbstractProvider.class,
+          Collections.<Class<?>>singletonList(FailAtInitProvider.class));
+      fail("Expected exception");
+    } catch (ServiceConfigurationError expected) {
+      // noop
+    }
+  }
+
+  @Test
+  public void getCandidatesViaHardCoded_failAtInit_moreCandidates() throws Exception {
+    try {
+      ServiceProviders.getCandidatesViaHardCoded(
+          ServiceProvidersTestAbstractProvider.class,
+          ImmutableList.<Class<?>>of(FailAtInitProvider.class, Available0Provider.class));
+      fail("Expected exception");
+    } catch (ServiceConfigurationError expected) {
+      // noop
+    }
+  }
+
+  @Test
+  public void getCandidatesViaHardCoded_throwsErrorOnMisconfiguration() throws Exception {
+    class PrivateClass extends BaseProvider {
+      private PrivateClass() {
+        super(true, 5);
+      }
+    }
+
+    try {
+      ServiceProviders.getCandidatesViaHardCoded(
+          ServiceProvidersTestAbstractProvider.class,
+          Collections.<Class<?>>singletonList(PrivateClass.class));
+      fail("Expected exception");
+    } catch (ServiceConfigurationError expected) {
+      assertTrue("Expected NoSuchMethodException cause: " + expected.getCause(),
+          expected.getCause() instanceof NoSuchMethodException);
+    }
+  }
+
+  @Test
+  public void getCandidatesViaHardCoded_skipsWrongClassType() throws Exception {
+    class RandomClass {}
+
+    Iterable<ServiceProvidersTestAbstractProvider> candidates =
+        ServiceProviders.getCandidatesViaHardCoded(
+            ServiceProvidersTestAbstractProvider.class,
+            Collections.<Class<?>>singletonList(RandomClass.class));
+    assertFalse(candidates.iterator().hasNext());
+  }
+
+  private static class BaseProvider extends ServiceProvidersTestAbstractProvider {
+    private final boolean isAvailable;
+    private final int priority;
+
+    public BaseProvider(boolean isAvailable, int priority) {
+      this.isAvailable = isAvailable;
+      this.priority = priority;
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return isAvailable;
+    }
+
+    @Override
+    public int priority() {
+      return priority;
+    }
+  }
+
+  public static final class Available0Provider extends BaseProvider {
+    public Available0Provider() {
+      super(true, 0);
+    }
+  }
+
+  public static final class Available5Provider extends BaseProvider {
+    public Available5Provider() {
+      super(true, 5);
+    }
+  }
+
+  public static final class Available7Provider extends BaseProvider {
+    public Available7Provider() {
+      super(true, 7);
+    }
+  }
+
+  public static final class UnavailableProvider extends BaseProvider {
+    public UnavailableProvider() {
+      super(false, 10);
+    }
+  }
+
+  public static final class FailAtInitProvider extends ServiceProvidersTestAbstractProvider {
+    public FailAtInitProvider() {
+      throw new RuntimeException("intentionally broken");
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int priority() {
+      return 0;
+    }
+  }
+
+  public static final class FailAtPriorityProvider extends ServiceProvidersTestAbstractProvider {
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int priority() {
+      throw new PriorityException();
+    }
+
+    public static final class PriorityException extends RuntimeException {}
+  }
+
+  public static final class FailAtAvailableProvider extends ServiceProvidersTestAbstractProvider {
+    @Override
+    public boolean isAvailable() {
+      throw new AvailableException();
+    }
+
+    @Override
+    public int priority() {
+      return 0;
+    }
+
+    public static final class AvailableException extends RuntimeException {}
+  }
+}
diff --git a/api/src/test/java/io/grpc/ServiceProvidersTestAbstractProvider.java b/api/src/test/java/io/grpc/ServiceProvidersTestAbstractProvider.java
new file mode 100644
index 00000000000..cc998976d9d
--- /dev/null
+++ b/api/src/test/java/io/grpc/ServiceProvidersTestAbstractProvider.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2018 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;
+
+/**
+ * A provider class for the {@link ServiceProvidersTest}.
+ */
+// Nesting the class inside the test leads to a class name that has a '$' in it, which causes
+// issues with our build pipeline.
+abstract class ServiceProvidersTestAbstractProvider {
+  abstract boolean isAvailable();
+
+  abstract int priority();
+}
diff --git a/api/src/test/java/io/grpc/ServiceProvidersTestUtil.java b/api/src/test/java/io/grpc/ServiceProvidersTestUtil.java
new file mode 100644
index 00000000000..f273d25d4a4
--- /dev/null
+++ b/api/src/test/java/io/grpc/ServiceProvidersTestUtil.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2018 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;
+
+import static com.google.common.truth.Truth.assertWithMessage;
+
+import com.google.common.collect.Iterators;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+final class ServiceProvidersTestUtil {
+  /**
+   * Creates an iterator from the callable class via reflection, and checks that all expected
+   * classes were loaded.
+   *
+   * <p>{@code callableClassName} is a {@code Callable<Iterable<Class<?>>} rather than the iterable
+   * class name itself so that the iterable class can be non-public.
+   *
+   * <p>We accept class names as input so that we can test against classes not in the
+   * testing class path.
+   */
+  static void testHardcodedClasses(
+      String callableClassName,
+      ClassLoader cl,
+      Set<String> hardcodedClassNames) throws Exception {
+    final Set<String> notLoaded = new HashSet<>(hardcodedClassNames);
+    cl = new ClassLoader(cl) {
+      @Override
+      public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+        if (notLoaded.remove(name)) {
+          throw new ClassNotFoundException();
+        } else {
+          return super.loadClass(name, resolve);
+        }
+      }
+    };
+    cl = new StaticTestingClassLoader(cl, Pattern.compile("io\\.grpc\\.[^.]*"));
+    // Some classes fall back to the context class loader.
+    // Ensure that the context class loader is not an accidental backdoor.
+    ClassLoader ccl = Thread.currentThread().getContextClassLoader();
+    try {
+      Thread.currentThread().setContextClassLoader(cl);
+      Object[] results = Iterators.toArray(
+          invokeIteratorCallable(callableClassName, cl), Object.class);
+      assertWithMessage("The Iterable loaded a class that was not in hardcodedClassNames")
+          .that(results).isEmpty();
+      assertWithMessage(
+          "The Iterable did not attempt to load some classes from hardcodedClassNames")
+          .that(notLoaded).isEmpty();
+    } finally {
+      Thread.currentThread().setContextClassLoader(ccl);
+    }
+  }
+
+  private static Iterator<?> invokeIteratorCallable(
+      String callableClassName, ClassLoader cl) throws Exception {
+    Class<?> klass = Class.forName(callableClassName, true, cl);
+    Constructor<?> ctor = klass.getDeclaredConstructor();
+    Object instance = ctor.newInstance();
+    Method callMethod = klass.getMethod("call");
+    return (Iterator<?>) callMethod.invoke(instance);
+  }
+}
diff --git a/api/src/test/java/io/grpc/StatusExceptionTest.java b/api/src/test/java/io/grpc/StatusExceptionTest.java
new file mode 100644
index 00000000000..410cfb2289a
--- /dev/null
+++ b/api/src/test/java/io/grpc/StatusExceptionTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2018 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;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link StatusException}.
+ */
+@RunWith(JUnit4.class)
+public class StatusExceptionTest {
+
+  @Test
+  public void normalCtorKeepsStack() {
+    StackTraceElement[] trace =
+        new StatusException(Status.CANCELLED, null) {}.getStackTrace();
+
+    assertThat(trace).isNotEmpty();
+  }
+
+  @Test
+  public void extendPreservesStack() {
+    StackTraceElement[] trace = new StatusException(Status.CANCELLED) {}.getStackTrace();
+
+    assertThat(trace).isNotEmpty();
+  }
+
+  @Test
+  public void extendAndOverridePreservesStack() {
+    final StackTraceElement element = new StackTraceElement("a", "b", "c", 4);
+    StatusException exception = new StatusException(Status.CANCELLED, new Metadata()) {
+
+      @Override
+      public synchronized Throwable fillInStackTrace() {
+        setStackTrace(new StackTraceElement[]{element});
+        return this;
+      }
+    };
+    assertThat(exception.getStackTrace()).asList().containsExactly(element);
+  }
+}
diff --git a/api/src/test/java/io/grpc/StatusOrTest.java b/api/src/test/java/io/grpc/StatusOrTest.java
new file mode 100644
index 00000000000..f63a314a2bb
--- /dev/null
+++ b/api/src/test/java/io/grpc/StatusOrTest.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2015 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static junit.framework.TestCase.fail;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link StatusOr}. **/
+@RunWith(JUnit4.class)
+public class StatusOrTest {
+
+  @Test
+  public void getValue_throwsIfNoValuePresent() {
+    try {
+      StatusOr.fromStatus(Status.ABORTED).getValue();
+
+      fail("Expected exception.");
+    } catch (IllegalStateException expected) { }
+  }
+
+  @Test
+  @SuppressWarnings("TruthIncompatibleType")
+  public void equals_differentValueTypes() {
+    assertThat(StatusOr.fromValue(1)).isNotEqualTo(StatusOr.fromValue("1"));
+  }
+
+  @Test
+  public void equals_differentValues() {
+    assertThat(StatusOr.fromValue(1)).isNotEqualTo(StatusOr.fromValue(2));
+  }
+
+  @Test
+  public void equals_sameValues() {
+    assertThat(StatusOr.fromValue(1)).isEqualTo(StatusOr.fromValue(1));
+  }
+
+  @Test
+  public void equals_differentStatuses() {
+    assertThat(StatusOr.fromStatus(Status.ABORTED)).isNotEqualTo(
+        StatusOr.fromStatus(Status.CANCELLED));
+  }
+
+  @Test
+  public void equals_sameStatuses() {
+    assertThat(StatusOr.fromStatus(Status.ABORTED)).isEqualTo(StatusOr.fromStatus(Status.ABORTED));
+  }
+
+  @Test
+  public void toString_value() {
+    assertThat(StatusOr.fromValue(1).toString()).isEqualTo("StatusOr{value=1}");
+  }
+
+  @Test
+  public void toString_nullValue() {
+    assertThat(StatusOr.fromValue(null).toString()).isEqualTo("StatusOr{value=null}");
+  }
+
+  @Test
+  public void toString_errorStatus() {
+    assertThat(StatusOr.fromStatus(Status.ABORTED).toString()).isEqualTo(
+        "StatusOr{error=Status{code=ABORTED, description=null, cause=null}}");
+  }
+}
\ No newline at end of file
diff --git a/api/src/test/java/io/grpc/StatusRuntimeExceptionTest.java b/api/src/test/java/io/grpc/StatusRuntimeExceptionTest.java
new file mode 100644
index 00000000000..d965ed86253
--- /dev/null
+++ b/api/src/test/java/io/grpc/StatusRuntimeExceptionTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2018 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;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link StatusRuntimeException}.
+ */
+@RunWith(JUnit4.class)
+public class StatusRuntimeExceptionTest {
+
+  @Test
+  public void internalCtorRemovesStack() {
+    StackTraceElement[] trace =
+        new InternalStatusRuntimeException(Status.CANCELLED, null) {}.getStackTrace();
+
+    assertThat(trace).isEmpty();
+  }
+
+  @Test
+  public void normalCtorKeepsStack() {
+    StackTraceElement[] trace =
+        new StatusRuntimeException(Status.CANCELLED, null) {}.getStackTrace();
+
+    assertThat(trace).isNotEmpty();
+  }
+
+  @Test
+  public void extendPreservesStack() {
+    StackTraceElement[] trace = new StatusRuntimeException(Status.CANCELLED) {}.getStackTrace();
+
+    assertThat(trace).isNotEmpty();
+  }
+
+  @Test
+  public void extendAndOverridePreservesStack() {
+    final StackTraceElement element = new StackTraceElement("a", "b", "c", 4);
+    StatusRuntimeException error = new StatusRuntimeException(Status.CANCELLED, new Metadata()) {
+      @Override
+      public synchronized Throwable fillInStackTrace() {
+        setStackTrace(new StackTraceElement[]{element});
+        return this;
+      }
+    };
+    assertThat(error.getStackTrace()).asList().containsExactly(element);
+  }
+}
diff --git a/api/src/test/java/io/grpc/StatusTest.java b/api/src/test/java/io/grpc/StatusTest.java
new file mode 100644
index 00000000000..5c8a1b2ae86
--- /dev/null
+++ b/api/src/test/java/io/grpc/StatusTest.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2014 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;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+
+import io.grpc.Status.Code;
+import java.nio.charset.Charset;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link Status}. */
+@RunWith(JUnit4.class)
+public class StatusTest {
+  private final Charset ascii = Charset.forName("US-ASCII");
+
+  @Test
+  public void verifyExceptionMessage() {
+    assertEquals("UNKNOWN", Status.UNKNOWN.asRuntimeException().getMessage());
+    assertEquals("CANCELLED: This is a test",
+        Status.CANCELLED.withDescription("This is a test").asRuntimeException().getMessage());
+    assertEquals("UNKNOWN", Status.UNKNOWN.asException().getMessage());
+    assertEquals("CANCELLED: This is a test",
+        Status.CANCELLED.withDescription("This is a test").asException().getMessage());
+  }
+
+  @Test
+  public void impossibleCodeValue() {
+    assertEquals(Code.UNKNOWN, Status.fromCodeValue(-1).getCode());
+    assertEquals(Code.UNKNOWN, Status.fromCodeValue(17).getCode());
+  }
+
+  @Test
+  public void sameCauseReturnsSelf() {
+    assertSame(Status.CANCELLED, Status.CANCELLED.withCause(null));
+  }
+
+  @Test
+  public void sameDescriptionReturnsSelf() {
+    assertSame(Status.CANCELLED, Status.CANCELLED.withDescription(null));
+    assertSame(Status.CANCELLED, Status.CANCELLED.augmentDescription(null));
+  }
+
+  @Test
+  public void useObjectHashCode() {
+    assertEquals(Status.CANCELLED.hashCode(), System.identityHashCode(Status.CANCELLED));
+  }
+
+  @Test
+  public void metadataEncode_lowAscii() {
+    byte[] b = Status.MESSAGE_KEY.toBytes("my favorite character is \u0000");
+    assertEquals("my favorite character is %00", new String(b, ascii));
+  }
+
+  @Test
+  public void metadataEncode_percent() {
+    byte[] b = Status.MESSAGE_KEY.toBytes("my favorite character is %");
+    assertEquals("my favorite character is %25", new String(b, ascii));
+  }
+
+  @Test
+  public void metadataEncode_surrogatePair() {
+    byte[] b = Status.MESSAGE_KEY.toBytes("my favorite character is 𐀁");
+    assertEquals("my favorite character is %F0%90%80%81", new String(b, ascii));
+  }
+
+  @Test
+  public void metadataEncode_unmatchedHighSurrogate() {
+    byte[] b = Status.MESSAGE_KEY.toBytes("my favorite character is " + ((char) 0xD801));
+    assertEquals("my favorite character is ?", new String(b, ascii));
+  }
+
+  @Test
+  public void metadataEncode_unmatchedLowSurrogate() {
+    byte[] b = Status.MESSAGE_KEY.toBytes("my favorite character is " + ((char)0xDC37));
+    assertEquals("my favorite character is ?", new String(b, ascii));
+  }
+
+  @Test
+  public void metadataEncode_maxSurrogatePair() {
+    byte[] b = Status.MESSAGE_KEY.toBytes(
+        "my favorite character is " + ((char)0xDBFF) + ((char)0xDFFF));
+    assertEquals("my favorite character is %F4%8F%BF%BF", new String(b, ascii));
+  }
+
+  @Test
+  public void metadataDecode_ascii() {
+    String s = Status.MESSAGE_KEY.parseBytes(new byte[]{'H', 'e', 'l', 'l', 'o'});
+    assertEquals("Hello", s);
+  }
+
+  @Test
+  public void metadataDecode_percent() {
+    String s = Status.MESSAGE_KEY.parseBytes(new byte[]{'H', '%', '6', '1', 'o'});
+    assertEquals("Hao", s);
+  }
+
+  @Test
+  public void metadataDecode_percentUnderflow() {
+    String s = Status.MESSAGE_KEY.parseBytes(new byte[]{'H', '%', '6'});
+    assertEquals("H%6", s);
+  }
+
+  @Test
+  public void metadataDecode_surrogate() {
+    String s = Status.MESSAGE_KEY.parseBytes(
+        new byte[]{'%', 'F', '0', '%', '9', '0', '%', '8', '0', '%', '8', '1'});
+    assertEquals("𐀁", s);
+  }
+
+  @Test
+  public void metadataDecode_badEncoding() {
+    String s = Status.MESSAGE_KEY.parseBytes(new byte[]{'%', 'G', '0'});
+    assertEquals("%G0", s);
+  }
+}
diff --git a/api/src/test/java/io/grpc/SynchronizationContextTest.java b/api/src/test/java/io/grpc/SynchronizationContextTest.java
new file mode 100644
index 00000000000..668f5ae4d6d
--- /dev/null
+++ b/api/src/test/java/io/grpc/SynchronizationContextTest.java
@@ -0,0 +1,407 @@
+/*
+ * Copyright 2016 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.util.concurrent.testing.TestingExecutors;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import java.time.Duration;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.After;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
+
+/**
+ * Unit tests for {@link SynchronizationContext}.
+ */
+@RunWith(JUnit4.class)
+public class SynchronizationContextTest {
+  private final BlockingQueue<Throwable> uncaughtErrors = new LinkedBlockingQueue<>();
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          uncaughtErrors.add(e);
+        }
+      });
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock
+  private Runnable task1;
+
+  @Mock
+  private Runnable task2;
+
+  @Mock
+  private Runnable task3;
+
+  @After public void tearDown() {
+    assertThat(uncaughtErrors).isEmpty();
+  }
+
+  @Test
+  public void singleThread() {
+    syncContext.executeLater(task1);
+    syncContext.executeLater(task2);
+    InOrder inOrder = inOrder(task1, task2, task3);
+    inOrder.verifyNoMoreInteractions();
+    syncContext.drain();
+    inOrder.verify(task1).run();
+    inOrder.verify(task2).run();
+
+    syncContext.executeLater(task3);
+    inOrder.verifyNoMoreInteractions();
+    syncContext.drain();
+    inOrder.verify(task3).run();
+  }
+
+  @Test
+  public void multiThread() throws Exception {
+    InOrder inOrder = inOrder(task1, task2);
+
+    final CountDownLatch task1Added = new CountDownLatch(1);
+    final CountDownLatch task1Running = new CountDownLatch(1);
+    final CountDownLatch task1Proceed = new CountDownLatch(1);
+    final CountDownLatch sideThreadDone = new CountDownLatch(1);
+    final AtomicReference<Thread> task1Thread = new AtomicReference<>();
+    final AtomicReference<Thread> task2Thread = new AtomicReference<>();
+
+    doAnswer(new Answer<Void>() {
+        @Override
+        public Void answer(InvocationOnMock invocation) {
+          task1Thread.set(Thread.currentThread());
+          task1Running.countDown();
+          try {
+            assertTrue(task1Proceed.await(5, TimeUnit.SECONDS));
+          } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+          }
+          return null;
+        }
+      }).when(task1).run();
+
+    doAnswer(new Answer<Void>() {
+        @Override
+        public Void answer(InvocationOnMock invocation) {
+          task2Thread.set(Thread.currentThread());
+          return null;
+        }
+      }).when(task2).run();
+
+    Thread sideThread = new Thread() {
+        @Override
+        public void run() {
+          syncContext.executeLater(task1);
+          task1Added.countDown();
+          syncContext.drain();
+          sideThreadDone.countDown();
+        }
+      };
+    sideThread.start();
+
+    assertTrue(task1Added.await(5, TimeUnit.SECONDS));
+    syncContext.executeLater(task2);
+    assertTrue(task1Running.await(5, TimeUnit.SECONDS));
+    // This will do nothing because task1 is running until task1Proceed is set
+    syncContext.drain();
+
+    inOrder.verify(task1).run();
+    inOrder.verifyNoMoreInteractions();
+
+    task1Proceed.countDown();
+    // drain() on the side thread has returned, which runs task2
+    assertTrue(sideThreadDone.await(5, TimeUnit.SECONDS));
+    inOrder.verify(task2).run();
+
+    assertSame(sideThread, task1Thread.get());
+    assertSame(sideThread, task2Thread.get());
+  }
+
+  @Test
+  public void throwIfNotInThisSynchronizationContext() throws Exception {
+    final AtomicBoolean taskSuccess = new AtomicBoolean(false);
+    final CountDownLatch task1Running = new CountDownLatch(1);
+    final CountDownLatch task1Proceed = new CountDownLatch(1);
+
+    doAnswer(new Answer<Void>() {
+        @Override
+        public Void answer(InvocationOnMock invocation) {
+          task1Running.countDown();
+          syncContext.throwIfNotInThisSynchronizationContext();
+          try {
+            assertTrue(task1Proceed.await(5, TimeUnit.SECONDS));
+          } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+          }
+          taskSuccess.set(true);
+          return null;
+        }
+      }).when(task1).run();
+
+    Thread sideThread = new Thread() {
+        @Override
+        public void run() {
+          syncContext.execute(task1);
+        }
+      };
+    sideThread.start();
+
+    assertThat(task1Running.await(5, TimeUnit.SECONDS)).isTrue();
+
+    // syncContext is draining, but the current thread is not in the context
+    try {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      fail("Should throw");
+    } catch (IllegalStateException e) {
+      assertThat(e.getMessage()).isEqualTo("Not called from the SynchronizationContext");
+    }
+
+    // Let task1 finish
+    task1Proceed.countDown();
+    sideThread.join();
+
+    // throwIfNotInThisSynchronizationContext() didn't throw in task1
+    assertThat(taskSuccess.get()).isTrue();
+
+    // syncContext is not draining, but the current thread is not in the context
+    try {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      fail("Should throw");
+    } catch (IllegalStateException e) {
+      assertThat(e.getMessage()).isEqualTo("Not called from the SynchronizationContext");
+    }
+  }
+
+  @Test
+  public void taskThrows() {
+    InOrder inOrder = inOrder(task1, task2, task3);
+    final RuntimeException e = new RuntimeException("Simulated");
+    doAnswer(new Answer<Void>() {
+        @Override
+        public Void answer(InvocationOnMock invocation) {
+          throw e;
+        }
+      }).when(task2).run();
+    syncContext.executeLater(task1);
+    syncContext.executeLater(task2);
+    syncContext.executeLater(task3);
+    syncContext.drain();
+    inOrder.verify(task1).run();
+    inOrder.verify(task2).run();
+    inOrder.verify(task3).run();
+    assertThat(uncaughtErrors).containsExactly(e);
+    uncaughtErrors.clear();
+  }
+
+  @Test
+  public void schedule() {
+    MockScheduledExecutorService executorService = new MockScheduledExecutorService();
+    ScheduledHandle handle =
+        syncContext.schedule(task1, 110, TimeUnit.NANOSECONDS, executorService);
+    assertThat(executorService.delay)
+        .isEqualTo(executorService.unit.convert(110, TimeUnit.NANOSECONDS));
+    assertThat(handle.isPending()).isTrue();
+    verify(task1, never()).run();
+
+    executorService.command.run();
+    assertThat(handle.isPending()).isFalse();
+    verify(task1).run();
+  }
+
+  @Test
+  @IgnoreJRERequirement
+  public void scheduleDuration() {
+    MockScheduledExecutorService executorService = new MockScheduledExecutorService();
+    ScheduledHandle handle =
+        syncContext.schedule(task1, Duration.ofSeconds(10), executorService);
+
+    assertThat(executorService.delay)
+        .isEqualTo(executorService.unit.convert(10, TimeUnit.SECONDS));
+    assertThat(handle.isPending()).isTrue();
+    verify(task1, never()).run();
+
+    executorService.command.run();
+
+    assertThat(handle.isPending()).isFalse();
+    verify(task1).run();
+  }
+
+  @Test
+  @IgnoreJRERequirement
+  public void scheduleWithFixedDelayDuration() {
+    MockScheduledExecutorService executorService = new MockScheduledExecutorService();
+    ScheduledHandle handle =
+        syncContext.scheduleWithFixedDelay(task1, Duration.ofSeconds(10),
+            Duration.ofSeconds(10), executorService);
+
+    assertThat(executorService.delay)
+        .isEqualTo(executorService.unit.convert(10, TimeUnit.SECONDS));
+    assertThat(handle.isPending()).isTrue();
+    verify(task1, never()).run();
+
+    executorService.command.run();
+
+    assertThat(handle.isPending()).isFalse();
+    verify(task1).run();
+  }
+
+  @Test
+  public void scheduleDueImmediately() {
+    MockScheduledExecutorService executorService = new MockScheduledExecutorService();
+    ScheduledHandle handle = syncContext.schedule(task1, -1, TimeUnit.NANOSECONDS, executorService);
+    assertThat(executorService.delay)
+        .isEqualTo(executorService.unit.convert(-1, TimeUnit.NANOSECONDS));
+    verify(task1, never()).run();
+    assertThat(handle.isPending()).isTrue();
+
+    executorService.command.run();
+    assertThat(handle.isPending()).isFalse();
+    verify(task1).run();
+  }
+
+  @Test
+  public void scheduleHandle_cancel() {
+    MockScheduledExecutorService executorService = new MockScheduledExecutorService();
+    ScheduledHandle handle =
+        syncContext.schedule(task1, 110, TimeUnit.NANOSECONDS, executorService);
+    assertThat(handle.isPending()).isTrue();
+    assertThat(executorService.delay)
+        .isEqualTo(executorService.unit.convert(110, TimeUnit.NANOSECONDS));
+
+    handle.cancel();
+    assertThat(handle.isPending()).isFalse();
+    syncContext.drain();
+    assertThat(executorService.future.isCancelled()).isTrue();
+    verify(task1, never()).run();
+  }
+
+  // Test that a scheduled task is cancelled after the timer has expired on the
+  // ScheduledExecutorService, but before the task is run.
+  @Test
+  public void scheduledHandle_cancelRacesWithTimerExpiration() throws Exception {
+    MockScheduledExecutorService executorService = new MockScheduledExecutorService();
+
+    final CountDownLatch task1Running = new CountDownLatch(1);
+    final LinkedBlockingQueue<ScheduledHandle> task2HandleQueue = new LinkedBlockingQueue<>();
+    final AtomicBoolean task1Done = new AtomicBoolean();
+    final CountDownLatch sideThreadDone = new CountDownLatch(1);
+
+    doAnswer(new Answer<Void>() {
+        @Override
+        public Void answer(InvocationOnMock invocation) {
+          task1Running.countDown();
+          try {
+            ScheduledHandle task2Handle;
+            assertThat(task2Handle = task2HandleQueue.poll(5, TimeUnit.SECONDS)).isNotNull();
+            task2Handle.cancel();
+          } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+          }
+          task1Done.set(true);
+          return null;
+        }
+      }).when(task1).run();
+
+    Thread sideThread = new Thread() {
+        @Override
+        public void run() {
+          syncContext.execute(task1);
+          sideThreadDone.countDown();
+        }
+      };
+
+    ScheduledHandle handle = syncContext.schedule(task2, 10, TimeUnit.NANOSECONDS, executorService);
+    // This will execute and block in task1
+    sideThread.start();
+
+    // Make sure task1 is running and blocking the execution
+    assertThat(task1Running.await(5, TimeUnit.SECONDS)).isTrue();
+
+    // Timer expires. task2 will be enqueued, but blocked by task1
+    assertThat(executorService.delay)
+        .isEqualTo(executorService.unit.convert(10, TimeUnit.NANOSECONDS));
+    executorService.command.run();
+    assertThat(handle.isPending()).isTrue();
+
+    // Enqueue task3 following task2
+    syncContext.executeLater(task3);
+
+    // Let task1 proceed and cancel task2
+    task2HandleQueue.add(handle);
+
+    // Wait until sideThread is done, which would have finished task1 and task3, while skipping
+    // task2.
+    assertThat(sideThreadDone.await(5, TimeUnit.SECONDS)).isTrue();
+    assertThat(task1Done.get()).isTrue();
+    assertThat(handle.isPending()).isFalse();
+    verify(task2, never()).run();
+    verify(task3).run();
+  }
+
+  static class MockScheduledExecutorService extends ForwardingScheduledExecutorService {
+    private ScheduledExecutorService delegate = TestingExecutors.noOpScheduledExecutor();
+
+    Runnable command;
+    long delay;
+    TimeUnit unit;
+    ScheduledFuture<?> future;
+
+    @Override public ScheduledExecutorService delegate() {
+      return delegate;
+    }
+
+    @Override public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
+      this.command = command;
+      this.delay = delay;
+      this.unit = unit;
+      return future = super.schedule(command, delay, unit);
+    }
+
+    @Override public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long intialDelay,
+        long delay, TimeUnit unit) {
+      this.command = command;
+      this.delay = delay;
+      this.unit = unit;
+      return future = super.scheduleWithFixedDelay(command, intialDelay, delay, unit);
+    }
+  }
+}
diff --git a/api/src/test/java/io/grpc/ThreadLocalContextStorageTest.java b/api/src/test/java/io/grpc/ThreadLocalContextStorageTest.java
new file mode 100644
index 00000000000..9a2aaad09b5
--- /dev/null
+++ b/api/src/test/java/io/grpc/ThreadLocalContextStorageTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2019 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;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class ThreadLocalContextStorageTest {
+  private static final Context.Key<Object> KEY = Context.key("test-key");
+  private static final ThreadLocalContextStorage storage = new ThreadLocalContextStorage();
+
+  private Context contextBeforeTest;
+
+  @Before public void saveContext() {
+    contextBeforeTest = storage.doAttach(Context.ROOT);
+  }
+
+  @After public void restoreContext() {
+    storage.detach(Context.ROOT, contextBeforeTest);
+  }
+
+  @Test
+  public void detach_threadLocalClearedOnRoot() {
+    Context context = Context.ROOT.withValue(KEY, new Object());
+    Context old = storage.doAttach(context);
+    assertThat(storage.current()).isSameInstanceAs(context);
+    assertThat(ThreadLocalContextStorage.localContext.get()).isSameInstanceAs(context);
+    storage.detach(context, old);
+    // thread local must contain null to avoid leaking our ClassLoader via ROOT
+    assertThat(ThreadLocalContextStorage.localContext.get()).isNull();
+  }
+
+  @Test
+  public void detach_detachRoot() {
+    final List<LogRecord> logs = new ArrayList<>();
+    Handler handler = new Handler() {
+      @Override public void publish(LogRecord record) {
+        logs.add(record);
+      }
+
+      @Override public void flush() {}
+
+      @Override public void close() {}
+    };
+
+    // Explicitly choose ROOT as the current context
+    Context context = Context.ROOT;
+    Context old = storage.doAttach(context);
+
+    // Attach and detach a random context
+    Context innerContext = Context.ROOT.withValue(KEY, new Object());
+    storage.detach(innerContext, storage.doAttach(innerContext));
+
+    Logger logger = Logger.getLogger(ThreadLocalContextStorage.class.getName());
+    logger.addHandler(handler);
+    try {
+      // Make sure detaching ROOT doesn't log a warning
+      storage.detach(context, old);
+    } finally {
+      logger.removeHandler(handler);
+    }
+    assertThat(logs).isEmpty();
+  }
+}
diff --git a/api/src/test/java/io/grpc/TimeUtilsTest.java b/api/src/test/java/io/grpc/TimeUtilsTest.java
new file mode 100644
index 00000000000..728b8512cd7
--- /dev/null
+++ b/api/src/test/java/io/grpc/TimeUtilsTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2024 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;
+
+import static org.junit.Assert.assertEquals;
+
+import java.time.Duration;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link TimeUtils}. */
+@RunWith(JUnit4.class)
+@IgnoreJRERequirement
+public class TimeUtilsTest {
+
+  @Test
+  public void testConvertNormalDuration() {
+    Duration duration = Duration.ofSeconds(10);
+    long expected = 10 * 1_000_000_000L;
+
+    assertEquals(expected, TimeUtils.convertToNanos(duration));
+  }
+
+  @Test
+  public void testConvertNegativeDuration() {
+    Duration duration = Duration.ofSeconds(-3);
+    long expected = -3 * 1_000_000_000L;
+
+    assertEquals(expected, TimeUtils.convertToNanos(duration));
+  }
+
+  @Test
+  public void testConvertTooLargeDuration() {
+    Duration duration = Duration.ofSeconds(Long.MAX_VALUE / 1_000_000_000L + 1);
+
+    assertEquals(Long.MAX_VALUE, TimeUtils.convertToNanos(duration));
+  }
+
+  @Test
+  public void testConvertTooLargeNegativeDuration() {
+    Duration duration = Duration.ofSeconds(Long.MIN_VALUE / 1_000_000_000L - 1);
+
+    assertEquals(Long.MIN_VALUE, TimeUtils.convertToNanos(duration));
+  }
+}
diff --git a/api/src/test/java/io/grpc/TlsChannelCredentialsTest.java b/api/src/test/java/io/grpc/TlsChannelCredentialsTest.java
new file mode 100644
index 00000000000..78324c4f3a5
--- /dev/null
+++ b/api/src/test/java/io/grpc/TlsChannelCredentialsTest.java
@@ -0,0 +1,33 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link TlsChannelCredentials}. */
+@RunWith(JUnit4.class)
+public class TlsChannelCredentialsTest {
+  @Test
+  public void withoutBearTokenGivesItself() {
+    ChannelCredentials tlsCreds = TlsChannelCredentials.create();
+    assertThat(tlsCreds.withoutBearerTokens()).isEqualTo(tlsCreds);
+  }
+}
diff --git a/api/src/test/java/io/grpc/UriTest.java b/api/src/test/java/io/grpc/UriTest.java
new file mode 100644
index 00000000000..e34319e8910
--- /dev/null
+++ b/api/src/test/java/io/grpc/UriTest.java
@@ -0,0 +1,696 @@
+/*
+ * Copyright 2025 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assume.assumeNoException;
+
+import com.google.common.net.InetAddresses;
+import com.google.common.testing.EqualsTester;
+import java.net.Inet6Address;
+import java.net.URISyntaxException;
+import java.net.UnknownHostException;
+import java.util.BitSet;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class UriTest {
+
+  @Test
+  public void parse_allComponents() throws URISyntaxException {
+    Uri uri = Uri.parse("scheme://user@host:0443/path?query#fragment");
+    assertThat(uri.getScheme()).isEqualTo("scheme");
+    assertThat(uri.getAuthority()).isEqualTo("user@host:0443");
+    assertThat(uri.getUserInfo()).isEqualTo("user");
+    assertThat(uri.getPort()).isEqualTo(443);
+    assertThat(uri.getRawPort()).isEqualTo("0443");
+    assertThat(uri.getPath()).isEqualTo("/path");
+    assertThat(uri.getQuery()).isEqualTo("query");
+    assertThat(uri.getFragment()).isEqualTo("fragment");
+    assertThat(uri.toString()).isEqualTo("scheme://user@host:0443/path?query#fragment");
+    assertThat(uri.isAbsolute()).isFalse(); // Has a fragment.
+    assertThat(uri.isPathAbsolute()).isTrue();
+    assertThat(uri.isPathRootless()).isFalse();
+  }
+
+  @Test
+  public void parse_noAuthority() throws URISyntaxException {
+    Uri uri = Uri.parse("scheme:/path?query#fragment");
+    assertThat(uri.getScheme()).isEqualTo("scheme");
+    assertThat(uri.getAuthority()).isNull();
+    assertThat(uri.getPath()).isEqualTo("/path");
+    assertThat(uri.getQuery()).isEqualTo("query");
+    assertThat(uri.getFragment()).isEqualTo("fragment");
+    assertThat(uri.toString()).isEqualTo("scheme:/path?query#fragment");
+    assertThat(uri.isAbsolute()).isFalse(); // Has a fragment.
+  }
+
+  @Test
+  public void parse_ipv6Literal_withPort() throws URISyntaxException {
+    Uri uri = Uri.parse("scheme://[2001:db8::7]:012345");
+    assertThat(uri.getAuthority()).isEqualTo("[2001:db8::7]:012345");
+    assertThat(uri.getRawHost()).isEqualTo("[2001:db8::7]");
+    assertThat(uri.getHost()).isEqualTo("[2001:db8::7]");
+    assertThat(uri.getRawPort()).isEqualTo("012345");
+    assertThat(uri.getPort()).isEqualTo(12345);
+  }
+
+  @Test
+  public void parse_ipv6Literal_noPort() throws URISyntaxException {
+    Uri uri = Uri.parse("scheme://[2001:db8::7]");
+    assertThat(uri.getAuthority()).isEqualTo("[2001:db8::7]");
+    assertThat(uri.getRawHost()).isEqualTo("[2001:db8::7]");
+    assertThat(uri.getHost()).isEqualTo("[2001:db8::7]");
+    assertThat(uri.getRawPort()).isNull();
+    assertThat(uri.getPort()).isLessThan(0);
+  }
+
+  @Test
+  public void parse_ipv6ScopedLiteral() throws URISyntaxException {
+    Uri uri = Uri.parse("http://[fe80::1%25eth0]");
+    assertThat(uri.getRawHost()).isEqualTo("[fe80::1%25eth0]");
+    assertThat(uri.getHost()).isEqualTo("[fe80::1%eth0]");
+  }
+
+  @Test
+  public void parse_ipv6ScopedPercentEncodedLiteral() throws URISyntaxException {
+    Uri uri = Uri.parse("http://[fe80::1%25foo-bar%2Fblah]");
+    assertThat(uri.getRawHost()).isEqualTo("[fe80::1%25foo-bar%2Fblah]");
+    assertThat(uri.getHost()).isEqualTo("[fe80::1%foo-bar/blah]");
+  }
+
+  @Test
+  public void parse_noQuery() throws URISyntaxException {
+    Uri uri = Uri.parse("scheme://authority/path#fragment");
+    assertThat(uri.getScheme()).isEqualTo("scheme");
+    assertThat(uri.getAuthority()).isEqualTo("authority");
+    assertThat(uri.getPath()).isEqualTo("/path");
+    assertThat(uri.getQuery()).isNull();
+    assertThat(uri.getFragment()).isEqualTo("fragment");
+    assertThat(uri.toString()).isEqualTo("scheme://authority/path#fragment");
+  }
+
+  @Test
+  public void parse_noFragment() throws URISyntaxException {
+    Uri uri = Uri.parse("scheme://authority/path?query");
+    assertThat(uri.getScheme()).isEqualTo("scheme");
+    assertThat(uri.getAuthority()).isEqualTo("authority");
+    assertThat(uri.getPath()).isEqualTo("/path");
+    assertThat(uri.getQuery()).isEqualTo("query");
+    assertThat(uri.getFragment()).isNull();
+    assertThat(uri.toString()).isEqualTo("scheme://authority/path?query");
+    assertThat(uri.isAbsolute()).isTrue();
+  }
+
+  @Test
+  public void parse_emptyPathWithAuthority() throws URISyntaxException {
+    Uri uri = Uri.parse("scheme://authority");
+    assertThat(uri.getScheme()).isEqualTo("scheme");
+    assertThat(uri.getAuthority()).isEqualTo("authority");
+    assertThat(uri.getPath()).isEmpty();
+    assertThat(uri.getQuery()).isNull();
+    assertThat(uri.getFragment()).isNull();
+    assertThat(uri.toString()).isEqualTo("scheme://authority");
+    assertThat(uri.isAbsolute()).isTrue();
+    assertThat(uri.isPathAbsolute()).isFalse();
+    assertThat(uri.isPathRootless()).isFalse();
+  }
+
+  @Test
+  public void parse_rootless() throws URISyntaxException {
+    Uri uri = Uri.parse("mailto:ceo@company.com?subject=raise");
+    assertThat(uri.getScheme()).isEqualTo("mailto");
+    assertThat(uri.getAuthority()).isNull();
+    assertThat(uri.getPath()).isEqualTo("ceo@company.com");
+    assertThat(uri.getQuery()).isEqualTo("subject=raise");
+    assertThat(uri.getFragment()).isNull();
+    assertThat(uri.toString()).isEqualTo("mailto:ceo@company.com?subject=raise");
+    assertThat(uri.isAbsolute()).isTrue();
+    assertThat(uri.isPathAbsolute()).isFalse();
+    assertThat(uri.isPathRootless()).isTrue();
+  }
+
+  @Test
+  public void parse_emptyPath() throws URISyntaxException {
+    Uri uri = Uri.parse("scheme:");
+    assertThat(uri.getScheme()).isEqualTo("scheme");
+    assertThat(uri.getAuthority()).isNull();
+    assertThat(uri.getPath()).isEmpty();
+    assertThat(uri.getQuery()).isNull();
+    assertThat(uri.getFragment()).isNull();
+    assertThat(uri.toString()).isEqualTo("scheme:");
+    assertThat(uri.isAbsolute()).isTrue();
+    assertThat(uri.isPathAbsolute()).isFalse();
+    assertThat(uri.isPathRootless()).isFalse();
+  }
+
+  @Test
+  public void parse_invalidScheme_throws() {
+    URISyntaxException e =
+        assertThrows(URISyntaxException.class, () -> Uri.parse("1scheme://authority/path"));
+    assertThat(e).hasMessageThat().contains("Scheme must start with an alphabetic char");
+
+    e = assertThrows(URISyntaxException.class, () -> Uri.parse(":path"));
+    assertThat(e).hasMessageThat().contains("Scheme must start with an alphabetic char");
+  }
+
+  @Test
+  public void parse_unTerminatedScheme_throws() {
+    URISyntaxException e = assertThrows(URISyntaxException.class, () -> Uri.parse("scheme/"));
+    assertThat(e).hasMessageThat().contains("Missing required scheme");
+
+    e = assertThrows(URISyntaxException.class, () -> Uri.parse("scheme?"));
+    assertThat(e).hasMessageThat().contains("Missing required scheme");
+
+    e = assertThrows(URISyntaxException.class, () -> Uri.parse("scheme#"));
+    assertThat(e).hasMessageThat().contains("Missing required scheme");
+  }
+
+  @Test
+  public void parse_invalidCharactersInScheme_throws() {
+    URISyntaxException e =
+        assertThrows(URISyntaxException.class, () -> Uri.parse("schem e://authority/path"));
+    assertThat(e).hasMessageThat().contains("Invalid character in scheme");
+  }
+
+  @Test
+  public void parse_unTerminatedAuthority_throws() {
+    Uri uri = Uri.create("s://auth/");
+    assertThat(uri.getAuthority()).isEqualTo("auth");
+    uri = Uri.create("s://auth?");
+    assertThat(uri.getAuthority()).isEqualTo("auth");
+    uri = Uri.create("s://auth#");
+    assertThat(uri.getAuthority()).isEqualTo("auth");
+  }
+
+  @Test
+  public void parse_invalidCharactersInUserinfo_throws() {
+    URISyntaxException e =
+        assertThrows(URISyntaxException.class, () -> Uri.parse("scheme://u ser@host/path"));
+    assertThat(e).hasMessageThat().contains("Invalid character in userInfo");
+  }
+
+  @Test
+  public void parse_invalidBackslashInUserinfo_throws() {
+    URISyntaxException e =
+        assertThrows(URISyntaxException.class, () -> Uri.parse("http://other.com\\@intended.com"));
+    assertThat(e).hasMessageThat().contains("Invalid character in userInfo");
+  }
+
+  @Test
+  public void parse_invalidCharactersInHost_throws() {
+    URISyntaxException e =
+        assertThrows(URISyntaxException.class, () -> Uri.parse("scheme://h ost/path"));
+    assertThat(e).hasMessageThat().contains("Invalid character in host");
+  }
+
+  @Test
+  public void parse_invalidBackslashInHost_throws() {
+    URISyntaxException e =
+        assertThrows(URISyntaxException.class, () -> Uri.parse("http://other.com\\.intended.com"));
+    assertThat(e).hasMessageThat().contains("Invalid character in host");
+  }
+
+  @Test
+  public void parse_invalidBackslashScope_throws() {
+    URISyntaxException e =
+        assertThrows(URISyntaxException.class, () -> Uri.parse("http://[::1%25foo\\bar]"));
+    assertThat(e).hasMessageThat().contains("Invalid character in scope");
+  }
+
+  @Test
+  public void parse_emptyPort_throws() {
+    URISyntaxException e =
+        assertThrows(URISyntaxException.class, () -> Uri.parse("scheme://user@host:/path"));
+    assertThat(e).hasMessageThat().contains("Invalid port");
+  }
+
+  @Test
+  public void parse_invalidCharactersInPort_throws() {
+    URISyntaxException e =
+        assertThrows(URISyntaxException.class, () -> Uri.parse("scheme://user@host:8 0/path"));
+    assertThat(e).hasMessageThat().contains("Invalid character");
+  }
+
+  @Test
+  public void parse_nonAsciiCharacterInPath_throws() throws URISyntaxException {
+    URISyntaxException e = assertThrows(URISyntaxException.class, () -> Uri.parse("foo:bär"));
+    assertThat(e).hasMessageThat().contains("Invalid character in path");
+  }
+
+  @Test
+  public void parse_invalidCharactersInPath_throws() {
+    URISyntaxException e = assertThrows(URISyntaxException.class, () -> Uri.parse("scheme:/p ath"));
+    assertThat(e).hasMessageThat().contains("Invalid character in path");
+  }
+
+  @Test
+  public void parse_invalidCharactersInQuery_throws() {
+    URISyntaxException e =
+        assertThrows(URISyntaxException.class, () -> Uri.parse("scheme://user@host/p?q[]uery"));
+    assertThat(e).hasMessageThat().contains("Invalid character in query");
+  }
+
+  @Test
+  public void parse_invalidCharactersInFragment_throws() {
+    URISyntaxException e =
+        assertThrows(URISyntaxException.class, () -> Uri.parse("scheme://user@host/path#f[]rag"));
+    assertThat(e).hasMessageThat().contains("Invalid character in fragment");
+  }
+
+  @Test
+  public void parse_nonAsciiCharacterInFragment_throws() throws URISyntaxException {
+    URISyntaxException e = assertThrows(URISyntaxException.class, () -> Uri.parse("foo:#bär"));
+    assertThat(e).hasMessageThat().contains("Invalid character in fragment");
+  }
+
+  @Test
+  public void parse_decoding() throws URISyntaxException {
+    Uri uri = Uri.parse("s://user%2Ename:pass%2Eword@a%2db:1234/p%20ath?q%20uery#f%20ragment");
+    assertThat(uri.getAuthority()).isEqualTo("user.name:pass.word@a-b:1234");
+    assertThat(uri.getRawAuthority()).isEqualTo("user%2Ename:pass%2Eword@a%2db:1234");
+    assertThat(uri.getUserInfo()).isEqualTo("user.name:pass.word");
+    assertThat(uri.getRawUserInfo()).isEqualTo("user%2Ename:pass%2Eword");
+    assertThat(uri.getHost()).isEqualTo("a-b");
+    assertThat(uri.getRawHost()).isEqualTo("a%2db");
+    assertThat(uri.getPort()).isEqualTo(1234);
+    assertThat(uri.getPath()).isEqualTo("/p ath");
+    assertThat(uri.getRawPath()).isEqualTo("/p%20ath");
+    assertThat(uri.getQuery()).isEqualTo("q uery");
+    assertThat(uri.getRawQuery()).isEqualTo("q%20uery");
+    assertThat(uri.getFragment()).isEqualTo("f ragment");
+    assertThat(uri.getRawFragment()).isEqualTo("f%20ragment");
+  }
+
+  @Test
+  public void parse_decodingNonAscii() throws URISyntaxException {
+    Uri uri = Uri.parse("s://a/%E2%82%AC");
+    assertThat(uri.getPath()).isEqualTo("/€");
+  }
+
+  @Test
+  public void parse_decodingPercent() throws URISyntaxException {
+    Uri uri = Uri.parse("s://a/p%2520ath?q%25uery#f%25ragment");
+    assertThat(uri.getPath()).isEqualTo("/p%20ath");
+    assertThat(uri.getQuery()).isEqualTo("q%uery");
+    assertThat(uri.getFragment()).isEqualTo("f%ragment");
+  }
+
+  @Test
+  public void parse_invalidPercentEncoding_throws() {
+    URISyntaxException e = assertThrows(URISyntaxException.class, () -> Uri.parse("s://a/p%2"));
+    assertThat(e).hasMessageThat().contains("Invalid");
+
+    e = assertThrows(URISyntaxException.class, () -> Uri.parse("s://a/p%2G"));
+    assertThat(e).hasMessageThat().contains("Invalid");
+  }
+
+  @Test
+  public void parse_emptyAuthority() {
+    Uri uri = Uri.create("file:///foo/bar");
+    assertThat(uri.getAuthority()).isEmpty();
+    assertThat(uri.getHost()).isEmpty();
+    assertThat(uri.getUserInfo()).isNull();
+    assertThat(uri.getPort()).isEqualTo(-1);
+    assertThat(uri.getPath()).isEqualTo("/foo/bar");
+  }
+
+  @Test
+  public void parse_pathSegments_empty() throws URISyntaxException {
+    Uri uri = Uri.create("scheme:");
+    assertThat(uri.getPathSegments()).isEmpty();
+  }
+
+  @Test
+  public void parse_pathSegments_root() throws URISyntaxException {
+    Uri uri = Uri.create("scheme:/");
+    assertThat(uri.getPathSegments()).containsExactly("");
+  }
+
+  @Test
+  public void parse_onePathSegment() throws URISyntaxException {
+    Uri uri = Uri.create("file:/foo");
+    assertThat(uri.getPathSegments()).containsExactly("foo");
+  }
+
+  @Test
+  public void parse_onePathSegment_trailingSlash() throws URISyntaxException {
+    Uri uri = Uri.create("file:/foo/");
+    assertThat(uri.getPathSegments()).containsExactly("foo", "");
+  }
+
+  @Test
+  public void parse_onePathSegment_rootless() throws URISyntaxException {
+    Uri uri = Uri.create("dns:www.example.com");
+    assertThat(uri.getPathSegments()).containsExactly("www.example.com");
+    assertThat(uri.isPathAbsolute()).isFalse();
+    assertThat(uri.isPathRootless()).isTrue();
+  }
+
+  @Test
+  public void parse_twoPathSegments() throws URISyntaxException {
+    Uri uri = Uri.create("file:/foo/bar");
+    assertThat(uri.getPathSegments()).containsExactly("foo", "bar");
+  }
+
+  @Test
+  public void parse_twoPathSegments_rootless() throws URISyntaxException {
+    Uri uri = Uri.create("file:foo/bar");
+    assertThat(uri.getPathSegments()).containsExactly("foo", "bar");
+  }
+
+  @Test
+  public void parse_percentEncodedPathSegment_rootless() throws URISyntaxException {
+    Uri uri = Uri.create("mailto:%2Fdev%2Fnull@example.com");
+    assertThat(uri.getPathSegments()).containsExactly("/dev/null@example.com");
+    assertThat(uri.isPathAbsolute()).isFalse();
+    assertThat(uri.isPathRootless()).isTrue();
+  }
+
+  @Test
+  public void toString_percentEncoding() throws URISyntaxException {
+    Uri uri =
+        Uri.newBuilder()
+            .setScheme("s")
+            .setHost("a b")
+            .setPath("/p ath")
+            .setQuery("q uery")
+            .setFragment("f ragment")
+            .build();
+    assertThat(uri.toString()).isEqualTo("s://a%20b/p%20ath?q%20uery#f%20ragment");
+  }
+
+  @Test
+  public void parse_transparentRoundTrip_ipLiteral() {
+    Uri uri = Uri.create("http://[2001:dB8::7]:080/%4a%4B%2f%2F?%4c%4D#%4e%4F").toBuilder().build();
+    assertThat(uri.toString()).isEqualTo("http://[2001:dB8::7]:080/%4a%4B%2f%2F?%4c%4D#%4e%4F");
+
+    // IPv6 host has non-canonical :: zeros and mixed case hex digits.
+    assertThat(uri.getRawHost()).isEqualTo("[2001:dB8::7]");
+    assertThat(uri.getHost()).isEqualTo("[2001:dB8::7]");
+    assertThat(uri.getRawPort()).isEqualTo("080"); // Leading zeros.
+    assertThat(uri.getPort()).isEqualTo(80);
+    // Unnecessary and mixed case percent encodings.
+    assertThat(uri.getRawPath()).isEqualTo("/%4a%4B%2f%2F");
+    assertThat(uri.getPathSegments()).containsExactly("JK//");
+    assertThat(uri.getRawQuery()).isEqualTo("%4c%4D");
+    assertThat(uri.getQuery()).isEqualTo("LM");
+    assertThat(uri.getRawFragment()).isEqualTo("%4e%4F");
+    assertThat(uri.getFragment()).isEqualTo("NO");
+  }
+
+  @Test
+  public void parse_transparentRoundTrip_regName() {
+    Uri uri = Uri.create("http://aB%4A%4b:080/%4a%4B%2f%2F?%4c%4D#%4e%4F").toBuilder().build();
+    assertThat(uri.toString()).isEqualTo("http://aB%4A%4b:080/%4a%4B%2f%2F?%4c%4D#%4e%4F");
+
+    // Mixed case literal chars and hex digits.
+    assertThat(uri.getRawHost()).isEqualTo("aB%4A%4b");
+    assertThat(uri.getHost()).isEqualTo("aBJK");
+    assertThat(uri.getRawPort()).isEqualTo("080"); // Leading zeros.
+    assertThat(uri.getPort()).isEqualTo(80);
+    // Unnecessary and mixed case percent encodings.
+    assertThat(uri.getRawPath()).isEqualTo("/%4a%4B%2f%2F");
+    assertThat(uri.getPathSegments()).containsExactly("JK//");
+    assertThat(uri.getRawQuery()).isEqualTo("%4c%4D");
+    assertThat(uri.getQuery()).isEqualTo("LM");
+    assertThat(uri.getRawFragment()).isEqualTo("%4e%4F");
+    assertThat(uri.getFragment()).isEqualTo("NO");
+  }
+
+  @Test
+  public void builder_numericPort() throws URISyntaxException {
+    Uri uri = Uri.newBuilder().setScheme("scheme").setHost("host").setPort(80).build();
+    assertThat(uri.toString()).isEqualTo("scheme://host:80");
+  }
+
+  @Test
+  public void builder_ipv6Literal() throws URISyntaxException {
+    Uri uri =
+        Uri.newBuilder()
+            .setScheme("scheme")
+            .setHost(InetAddresses.forString("2001:4860:4860::8844"))
+            .build();
+    assertThat(uri.toString()).isEqualTo("scheme://[2001:4860:4860::8844]");
+  }
+
+  @Test
+  public void builder_ipv6ScopedLiteral_numeric() throws UnknownHostException {
+    Uri uri =
+        Uri.newBuilder()
+            .setScheme("http")
+            // Create an address with a numeric scope_id, which should always be valid.
+            .setHost(
+                Inet6Address.getByAddress(null, InetAddresses.forString("fe80::1").getAddress(), 1))
+            .build();
+
+    // We expect the scope ID to be percent encoded.
+    assertThat(uri.getRawHost()).isEqualTo("[fe80::1%251]");
+    assertThat(uri.getHost()).isEqualTo("[fe80::1%1]");
+  }
+
+  @Test
+  public void builder_ipv6ScopedLiteral_named() throws UnknownHostException {
+    // Unfortunately, there's no Java API to create an Inet6Address with an arbitrary interface-
+    // scoped name. There's actually no way to hermetically create an Inet6Address with a scope name
+    // at all! The following address/interface is likely to be present on Linux test runners.
+    Inet6Address address;
+    try {
+      address = (Inet6Address) InetAddresses.forString("::1%lo");
+    } catch (IllegalArgumentException e) {
+      assumeNoException(e);
+      return; // Not reached.
+    }
+    Uri uri = Uri.newBuilder().setScheme("http").setHost(address).build();
+
+    // We expect the scope ID to be percent encoded.
+    assertThat(uri.getRawHost()).isEqualTo("[::1%25lo]");
+    assertThat(uri.getHost()).isEqualTo("[::1%lo]");
+  }
+
+  @Test
+  public void builder_ipv6PercentEncodedScopedLiteral() {
+    Uri uri = Uri.newBuilder().setScheme("http").setRawHost("[fe80::1%25foo%2Dbar%2Fblah]").build();
+    assertThat(uri.getRawHost()).isEqualTo("[fe80::1%25foo%2Dbar%2Fblah]");
+    assertThat(uri.getHost()).isEqualTo("[fe80::1%foo-bar/blah]");
+  }
+
+  @Test
+  public void builder_encodingWithAllowedReservedChars() throws URISyntaxException {
+    Uri uri =
+        Uri.newBuilder()
+            .setScheme("s")
+            .setUserInfo("u@")
+            .setHost("a[]")
+            .setPath("/p:/@")
+            .setQuery("q/?")
+            .setFragment("f/?")
+            .build();
+    assertThat(uri.toString()).isEqualTo("s://u%40@a%5B%5D/p:/@?q/?#f/?");
+  }
+
+  @Test
+  public void builder_percentEncodingNonAscii() throws URISyntaxException {
+    Uri uri = Uri.newBuilder().setScheme("s").setHost("a").setPath("/€").build();
+    assertThat(uri.toString()).isEqualTo("s://a/%E2%82%AC");
+  }
+
+  @Test
+  public void builder_percentEncodingLoneHighSurrogate_throws() {
+    IllegalArgumentException e =
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> Uri.newBuilder().setPath("\uD83D")); // Lone high surrogate.
+    assertThat(e.getMessage()).contains("Malformed input");
+  }
+
+  @Test
+  public void builder_hasAuthority_pathStartsWithSlash_throws() throws URISyntaxException {
+    IllegalArgumentException e =
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> Uri.newBuilder().setScheme("s").setHost("a").setPath("path").build());
+    assertThat(e.getMessage()).contains("Non-empty path must start with '/'");
+  }
+
+  @Test
+  public void builder_noAuthority_pathStartsWithDoubleSlash_throws() throws URISyntaxException {
+    IllegalArgumentException e =
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> Uri.newBuilder().setScheme("s").setPath("//path").build());
+    assertThat(e.getMessage()).contains("Path cannot start with '//'");
+  }
+
+  @Test
+  public void builder_noScheme_throws() {
+    IllegalStateException e =
+        assertThrows(IllegalStateException.class, () -> Uri.newBuilder().build());
+    assertThat(e.getMessage()).contains("Missing required scheme");
+  }
+
+  @Test
+  public void builder_noHost_hasUserInfo_throws() {
+    IllegalStateException e =
+        assertThrows(
+            IllegalStateException.class,
+            () -> Uri.newBuilder().setScheme("scheme").setUserInfo("user").build());
+    assertThat(e.getMessage()).contains("Cannot set userInfo without host");
+  }
+
+  @Test
+  public void builder_noHost_hasPort_throws() {
+    IllegalStateException e =
+        assertThrows(
+            IllegalStateException.class,
+            () -> Uri.newBuilder().setScheme("scheme").setPort(1234).build());
+    assertThat(e.getMessage()).contains("Cannot set port without host");
+  }
+
+  @Test
+  public void builder_normalizesCaseWhereAppropriate() {
+    Uri uri =
+        Uri.newBuilder()
+            .setScheme("hTtP") // #section-3.1 says producers (Builder) should normalize to lower.
+            .setHost("aBc") // #section-3.2.2 says producers (Builder) should normalize to lower.
+            .setPath("/CdE") // #section-6.2.2.1 says the rest are assumed to be case-sensitive
+            .setQuery("fGh")
+            .setFragment("IjK")
+            .build();
+    assertThat(uri.toString()).isEqualTo("http://abc/CdE?fGh#IjK");
+  }
+
+  @Test
+  public void builder_normalizesIpv6Literal() {
+    Uri uri =
+        Uri.newBuilder().setScheme("scheme").setHost(InetAddresses.forString("ABCD::EFAB")).build();
+    assertThat(uri.toString()).isEqualTo("scheme://[abcd::efab]");
+  }
+
+  @Test
+  public void builder_canClearAllOptionalFields() {
+    Uri uri =
+        Uri.create("http://user@host:80/path?query#fragment").toBuilder()
+            .setHost((String) null)
+            .setPath("")
+            .setUserInfo(null)
+            .setPort(-1)
+            .setQuery(null)
+            .setFragment(null)
+            .build();
+    assertThat(uri.toString()).isEqualTo("http:");
+  }
+
+  @Test
+  public void toString_percentEncodingMultiChar() throws URISyntaxException {
+    Uri uri =
+        Uri.newBuilder()
+            .setScheme("s")
+            .setHost("a")
+            .setPath("/emojis/😊/icon.png") // Smile requires two chars to express in a java String.
+            .build();
+    assertThat(uri.toString()).isEqualTo("s://a/emojis/%F0%9F%98%8A/icon.png");
+  }
+
+  @Test
+  public void toString_percentEncodingLiteralPercent() throws URISyntaxException {
+    Uri uri =
+        Uri.newBuilder()
+            .setScheme("s")
+            .setHost("a")
+            .setPath("/p%20ath")
+            .setQuery("q%uery")
+            .setFragment("f%ragment")
+            .build();
+    assertThat(uri.toString()).isEqualTo("s://a/p%2520ath?q%25uery#f%25ragment");
+  }
+
+  @Test
+  public void equalsAndHashCode() {
+    new EqualsTester()
+        .addEqualityGroup(
+            Uri.create("scheme://authority/path?query#fragment"),
+            Uri.create("scheme://authority/path?query#fragment"))
+        .addEqualityGroup(Uri.create("scheme://authority/path"))
+        .addEqualityGroup(Uri.create("scheme://authority/path?query"))
+        .addEqualityGroup(Uri.create("scheme:/path"))
+        .addEqualityGroup(Uri.create("scheme:/path?query"))
+        .addEqualityGroup(Uri.create("scheme:/path#fragment"))
+        .addEqualityGroup(Uri.create("scheme:path"))
+        .addEqualityGroup(Uri.create("scheme:path?query"))
+        .addEqualityGroup(Uri.create("scheme:path#fragment"))
+        .addEqualityGroup(Uri.create("scheme:"))
+        .testEquals();
+  }
+
+  @Test
+  public void isAbsolute() {
+    assertThat(Uri.create("scheme://authority/path").isAbsolute()).isTrue();
+    assertThat(Uri.create("scheme://authority/path?query").isAbsolute()).isTrue();
+    assertThat(Uri.create("scheme://authority/path#fragment").isAbsolute()).isFalse();
+    assertThat(Uri.create("scheme://authority/path?query#fragment").isAbsolute()).isFalse();
+  }
+
+  @Test
+  public void serializedCharacterClasses_matchComputed() {
+    assertThat(Uri.digitChars).isEqualTo(bitSetOfRange('0', '9'));
+    assertThat(Uri.alphaChars).isEqualTo(or(bitSetOfRange('A', 'Z'), bitSetOfRange('a', 'z')));
+    assertThat(Uri.schemeChars)
+        .isEqualTo(or(Uri.digitChars, Uri.alphaChars, bitSetOf('+', '-', '.')));
+    assertThat(Uri.unreservedChars)
+        .isEqualTo(or(Uri.alphaChars, Uri.digitChars, bitSetOf('-', '.', '_', '~')));
+    assertThat(Uri.genDelimsChars).isEqualTo(bitSetOf(':', '/', '?', '#', '[', ']', '@'));
+    assertThat(Uri.subDelimsChars)
+        .isEqualTo(bitSetOf('!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '='));
+    assertThat(Uri.reservedChars).isEqualTo(or(Uri.genDelimsChars, Uri.subDelimsChars));
+    assertThat(Uri.regNameChars).isEqualTo(or(Uri.unreservedChars, Uri.subDelimsChars));
+    assertThat(Uri.userInfoChars)
+        .isEqualTo(or(Uri.unreservedChars, Uri.subDelimsChars, bitSetOf(':')));
+    assertThat(Uri.pChars)
+        .isEqualTo(or(Uri.unreservedChars, Uri.subDelimsChars, bitSetOf(':', '@')));
+    assertThat(Uri.pCharsAndSlash).isEqualTo(or(Uri.pChars, bitSetOf('/')));
+    assertThat(Uri.queryChars).isEqualTo(or(Uri.pChars, bitSetOf('/', '?')));
+    assertThat(Uri.fragmentChars).isEqualTo(or(Uri.pChars, bitSetOf('/', '?')));
+  }
+
+  private static BitSet bitSetOfRange(char from, char to) {
+    BitSet bitset = new BitSet();
+    for (char c = from; c <= to; c++) {
+      bitset.set(c);
+    }
+    return bitset;
+  }
+
+  private static BitSet bitSetOf(char... chars) {
+    BitSet bitset = new BitSet();
+    for (char c : chars) {
+      bitset.set(c);
+    }
+    return bitset;
+  }
+
+  private static BitSet or(BitSet... bitsets) {
+    BitSet bitset = new BitSet();
+    for (BitSet bs : bitsets) {
+      bitset.or(bs);
+    }
+    return bitset;
+  }
+}
diff --git a/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-empty.txt b/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-empty.txt
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-failAtAvailableProvider.txt b/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-failAtAvailableProvider.txt
new file mode 100644
index 00000000000..61cc58e1522
--- /dev/null
+++ b/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-failAtAvailableProvider.txt
@@ -0,0 +1,2 @@
+io.grpc.ServiceProvidersTest$FailAtAvailableProvider
+io.grpc.ServiceProvidersTest$Available5Provider
diff --git a/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-failAtInitProvider.txt b/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-failAtInitProvider.txt
new file mode 100644
index 00000000000..c2ec06a1b5f
--- /dev/null
+++ b/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-failAtInitProvider.txt
@@ -0,0 +1,2 @@
+io.grpc.ServiceProvidersTest$FailAtInitProvider
+io.grpc.ServiceProvidersTest$Available5Provider
diff --git a/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-failAtPriorityProvider.txt b/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-failAtPriorityProvider.txt
new file mode 100644
index 00000000000..3a3aa792930
--- /dev/null
+++ b/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-failAtPriorityProvider.txt
@@ -0,0 +1,2 @@
+io.grpc.ServiceProvidersTest$FailAtPriorityProvider
+io.grpc.ServiceProvidersTest$Available5Provider
diff --git a/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-multipleProvider.txt b/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-multipleProvider.txt
new file mode 100644
index 00000000000..cb247903295
--- /dev/null
+++ b/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-multipleProvider.txt
@@ -0,0 +1,3 @@
+io.grpc.ServiceProvidersTest$Available5Provider
+io.grpc.ServiceProvidersTest$Available7Provider
+io.grpc.ServiceProvidersTest$Available0Provider
diff --git a/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-unavailableProvider.txt b/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-unavailableProvider.txt
new file mode 100644
index 00000000000..55175ff1806
--- /dev/null
+++ b/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-unavailableProvider.txt
@@ -0,0 +1,2 @@
+io.grpc.ServiceProvidersTest$UnavailableProvider
+io.grpc.ServiceProvidersTest$Available7Provider
diff --git a/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-unknownClassProvider.txt b/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-unknownClassProvider.txt
new file mode 100644
index 00000000000..58c264107c7
--- /dev/null
+++ b/api/src/test/resources/io/grpc/ServiceProvidersTestAbstractProvider-unknownClassProvider.txt
@@ -0,0 +1 @@
+io.grpc.ServiceProvidersTest$UnknownClassProvider
diff --git a/api/src/testFixtures/java/io/grpc/ForwardingTestUtil.java b/api/src/testFixtures/java/io/grpc/ForwardingTestUtil.java
new file mode 100644
index 00000000000..b7c91caee03
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/ForwardingTestUtil.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2017 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;
+
+import static junit.framework.TestCase.assertFalse;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mockingDetails;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.base.Defaults;
+import com.google.common.base.MoreObjects;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Collection;
+import javax.annotation.Nullable;
+
+/**
+ * A util class to help test forwarding classes.
+ */
+public final class ForwardingTestUtil {
+  /**
+   * Use reflection to perform a basic sanity test. The forwarding class should forward all public
+   * methods to the delegate, except for those in skippedMethods.  This does NOT verify that
+   * arguments or return values are forwarded properly.
+   *
+   * @param delegateClass The class whose methods should be forwarded.
+   * @param mockDelegate The mockito mock of the delegate class.
+   * @param forwarder The forwarder object that forwards to the mockDelegate.
+   * @param skippedMethods A collection of methods that are skipped by the test.
+   */
+  public static <T> void testMethodsForwarded(
+      Class<T> delegateClass,
+      T mockDelegate,
+      T forwarder,
+      Collection<Method> skippedMethods) throws Exception {
+    testMethodsForwarded(
+        delegateClass, mockDelegate, forwarder, skippedMethods,
+        new ArgumentProvider() {
+          @Override
+          public Object get(Method method, int argPos, Class<?> clazz) {
+            return null;
+          }
+        });
+  }
+
+  /**
+   * Use reflection to perform a basic sanity test. The forwarding class should forward all public
+   * methods to the delegate, except for those in skippedMethods.  This does NOT verify that return
+   * values are forwarded properly, and can only verify the propagation of arguments for which
+   * {@code argProvider} returns distinctive non-null values.
+   *
+   * @param delegateClass The class whose methods should be forwarded.
+   * @param mockDelegate The mockito mock of the delegate class.
+   * @param forwarder The forwarder object that forwards to the mockDelegate.
+   * @param skippedMethods A collection of methods that are skipped by the test.
+   * @param argProvider provides argument to be passed to tested forwarding methods.
+   */
+  public static <T> void testMethodsForwarded(
+      Class<T> delegateClass,
+      T mockDelegate,
+      T forwarder,
+      Collection<Method> skippedMethods,
+      ArgumentProvider argProvider) throws Exception {
+    assertTrue(mockingDetails(mockDelegate).isMock());
+    assertFalse(mockingDetails(forwarder).isMock());
+
+    for (Method method : delegateClass.getDeclaredMethods()) {
+      if (Modifier.isStatic(method.getModifiers())
+          || Modifier.isPrivate(method.getModifiers())
+          || Modifier.isFinal(method.getModifiers())
+          || skippedMethods.contains(method)) {
+        continue;
+      }
+      Class<?>[] argTypes = method.getParameterTypes();
+      Object[] args = new Object[argTypes.length];
+      for (int i = 0; i < argTypes.length; i++) {
+        if ((args[i] = argProvider.get(method, i, argTypes[i])) == null) {
+          args[i] = Defaults.defaultValue(argTypes[i]);
+        }
+      }
+      method.invoke(forwarder, args);
+      try {
+        method.invoke(verify(mockDelegate), args);
+      } catch (InvocationTargetException e) {
+        AssertionError ae =
+            new AssertionError(String.format("Method was not forwarded: %s", method));
+        ae.initCause(e);
+        throw ae;
+      }
+    }
+
+    boolean skipToString = false;
+    for (Method method : skippedMethods) {
+      if (method.getName().equals("toString")) {
+        skipToString = true;
+        break;
+      }
+    }
+    if (!skipToString) {
+      String actual = forwarder.toString();
+      String expected =
+          MoreObjects.toStringHelper(forwarder).add("delegate", mockDelegate).toString();
+      assertEquals("Method toString() was not forwarded properly", expected, actual);
+    }
+  }
+
+  /**
+   * Provides arguments for forwarded methods tested in {@link #testMethodsForwarded}.
+   */
+  public interface ArgumentProvider {
+    /**
+     * Return an instance of the given class to be used as an argument passed to one method call.
+     * If one method has multiple arguments with the same type, each occurrence will call this
+     * method once.  It is recommended that each invocation returns a distinctive object for the
+     * same type, in order to verify that arguments are passed by the tested class correctly.
+     *
+     * @return a value to be passed as an argument.  If {@code null}, {@link Defaults#defaultValue}
+     *         will be used.
+     */
+    @Nullable Object get(Method method, int argPos, Class<?> clazz);
+  }
+}
diff --git a/api/src/testFixtures/java/io/grpc/IntegerMarshaller.java b/api/src/testFixtures/java/io/grpc/IntegerMarshaller.java
new file mode 100644
index 00000000000..44b378683db
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/IntegerMarshaller.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2015 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;
+
+import java.io.InputStream;
+
+/** Marshalls decimal-encoded integers. */
+public class IntegerMarshaller implements MethodDescriptor.Marshaller<Integer> {
+  public static final IntegerMarshaller INSTANCE = new IntegerMarshaller();
+
+  @Override
+  public InputStream stream(Integer value) {
+    return StringMarshaller.INSTANCE.stream(value.toString());
+  }
+
+  @Override
+  public Integer parse(InputStream stream) {
+    return Integer.valueOf(StringMarshaller.INSTANCE.parse(stream));
+  }
+}
diff --git a/api/src/testFixtures/java/io/grpc/LoadBalancerMatchers.java b/api/src/testFixtures/java/io/grpc/LoadBalancerMatchers.java
new file mode 100644
index 00000000000..861039d94ba
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/LoadBalancerMatchers.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2023 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;
+
+import static org.mockito.Mockito.argThat;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import org.mockito.ArgumentMatcher;
+
+/**
+ * Mockito matchers for testing LoadBalancers.
+ */
+public final class LoadBalancerMatchers {
+  private LoadBalancerMatchers() {}
+
+  public static SubchannelPicker pickerReturns(final PickResult result) {
+    return pickerReturns(new ArgumentMatcher<PickResult>() {
+      @Override public boolean matches(PickResult obj) {
+        return result.equals(obj);
+      }
+
+      @Override public String toString() {
+        return "[equals " + result + "]";
+      }
+    });
+  }
+
+  public static SubchannelPicker pickerReturns(Status.Code code) {
+    return pickerReturns(new ArgumentMatcher<PickResult>() {
+      @Override public boolean matches(PickResult obj) {
+        return obj.getStatus() != null && code.equals(obj.getStatus().getCode());
+      }
+
+      @Override public String toString() {
+        return "[with code " + code + "]";
+      }
+    });
+  }
+
+  public static SubchannelPicker pickerReturns(final ArgumentMatcher<PickResult> matcher) {
+    return argThat(new ArgumentMatcher<SubchannelPicker>() {
+      @Override public boolean matches(SubchannelPicker picker) {
+        return matcher.matches(picker.pickSubchannel(mock(PickSubchannelArgs.class)));
+      }
+
+      @Override public String toString() {
+        return "[picker returns: result " + matcher + "]";
+      }
+    });
+  }
+}
diff --git a/api/src/testFixtures/java/io/grpc/ManagedChannelRegistryAccessor.java b/api/src/testFixtures/java/io/grpc/ManagedChannelRegistryAccessor.java
new file mode 100644
index 00000000000..5c65c8e5328
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/ManagedChannelRegistryAccessor.java
@@ -0,0 +1,26 @@
+/*
+ * 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;
+
+/** Accesses test-only methods of {@link ManagedChannelRegistry}. */
+public final class ManagedChannelRegistryAccessor {
+  private ManagedChannelRegistryAccessor() {}
+
+  public static Iterable<Class<?>> getHardCodedClasses() {
+    return ManagedChannelRegistry.getHardCodedClasses();
+  }
+}
diff --git a/api/src/testFixtures/java/io/grpc/MetricInstrumentRegistryAccessor.java b/api/src/testFixtures/java/io/grpc/MetricInstrumentRegistryAccessor.java
new file mode 100644
index 00000000000..bd17dccad58
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/MetricInstrumentRegistryAccessor.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2024 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;
+
+/**
+ * Accesses test-only methods of {@link MetricInstrumentRegistry}.
+ */
+public final class MetricInstrumentRegistryAccessor {
+
+  private MetricInstrumentRegistryAccessor() {
+  }
+
+  public static MetricInstrumentRegistry createMetricInstrumentRegistry() {
+    return new MetricInstrumentRegistry();
+  }
+}
diff --git a/api/src/testFixtures/java/io/grpc/NoopClientCall.java b/api/src/testFixtures/java/io/grpc/NoopClientCall.java
new file mode 100644
index 00000000000..0b2b0fbadad
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/NoopClientCall.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2016 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;
+
+/**
+ * {@link NoopClientCall} is a class that is designed for use in tests.  It is designed to be used
+ * in places where a scriptable call is necessary.  By default, all methods are noops, and designed
+ * to be overridden.
+ */
+public class NoopClientCall<ReqT, RespT> extends ClientCall<ReqT, RespT> {
+
+  /**
+   * {@link NoopClientCall.NoopClientCallListener} is a class that is designed for use in tests.
+   * It is designed to be used in places where a scriptable call listener is necessary.  By
+   * default, all methods are noops, and designed to be overridden.
+   */
+  public static class NoopClientCallListener<T> extends ClientCall.Listener<T> {
+  }
+
+  @Override
+  public void start(ClientCall.Listener<RespT> listener, Metadata headers) {}
+
+  @Override
+  public void request(int numMessages) {}
+
+  @Override
+  public void cancel(String message, Throwable cause) {}
+
+  @Override
+  public void halfClose() {}
+
+  @Override
+  public void sendMessage(ReqT message) {}
+}
diff --git a/api/src/testFixtures/java/io/grpc/NoopMetricSink.java b/api/src/testFixtures/java/io/grpc/NoopMetricSink.java
new file mode 100644
index 00000000000..b7717d75bcf
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/NoopMetricSink.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2024 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;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A MetricSink that discards all records.
+ */
+public class NoopMetricSink implements MetricSink {
+  private int size;
+
+  @Override
+  public Map<String, Boolean> getEnabledMetrics() {
+    return Collections.emptyMap();
+  }
+
+  @Override
+  public Set<String> getOptionalLabels() {
+    return Collections.emptySet();
+  }
+
+  @Override
+  public synchronized int getMeasuresSize() {
+    return size;
+  }
+
+  @Override
+  public synchronized void updateMeasures(List<MetricInstrument> instruments) {
+    size = instruments.size();
+  }
+}
diff --git a/api/src/testFixtures/java/io/grpc/NoopServerCall.java b/api/src/testFixtures/java/io/grpc/NoopServerCall.java
new file mode 100644
index 00000000000..f4010851630
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/NoopServerCall.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2016 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;
+
+/**
+ * {@link NoopServerCall} is a class that is designed for use in tests.  It is designed to be used
+ * in places where a scriptable call is necessary.  By default, all methods are noops, and designed
+ * to be overridden.
+ */
+public class NoopServerCall<ReqT, RespT> extends ServerCall<ReqT, RespT> {
+
+  /**
+   * {@link NoopServerCall.NoopServerCallListener} is a class that is designed for use in tests.
+   * It is designed to be used in places where a scriptable call listener is necessary.  By
+   * default, all methods are noops, and designed to be overridden.
+   */
+  public static class NoopServerCallListener<T> extends ServerCall.Listener<T> {
+  }
+
+  @Override
+  public void request(int numMessages) {}
+
+  @Override
+  public void sendHeaders(Metadata headers) {}
+
+  @Override
+  public void sendMessage(RespT message) {}
+
+  @Override
+  public void close(Status status, Metadata trailers) {}
+
+  @Override
+  public boolean isCancelled() {
+    return false;
+  }
+
+  @Override
+  public MethodDescriptor<ReqT, RespT> getMethodDescriptor() {
+    return null;
+  }
+}
diff --git a/api/src/testFixtures/java/io/grpc/PickSubchannelArgsMatcher.java b/api/src/testFixtures/java/io/grpc/PickSubchannelArgsMatcher.java
new file mode 100644
index 00000000000..50140649810
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/PickSubchannelArgsMatcher.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2024 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;
+
+import com.google.common.base.Preconditions;
+import io.grpc.CallOptions;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import org.mockito.ArgumentMatcher;
+import org.mockito.ArgumentMatchers;
+
+/**
+ * Mockito Matcher for {@link PickSubchannelArgs}.
+ */
+public final class PickSubchannelArgsMatcher implements ArgumentMatcher<PickSubchannelArgs> {
+  private final MethodDescriptor<?, ?> method;
+  private final Metadata headers;
+  private final CallOptions callOptions;
+
+  public PickSubchannelArgsMatcher(
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions) {
+    this.method = Preconditions.checkNotNull(method, "method");
+    this.headers = Preconditions.checkNotNull(headers, "headers");
+    this.callOptions = Preconditions.checkNotNull(callOptions, "callOptions");
+  }
+
+  @Override
+  public boolean matches(PickSubchannelArgs args) {
+    return args != null
+        && method.equals(args.getMethodDescriptor())
+        && headers.equals(args.getHeaders())
+        && callOptions.equals(args.getCallOptions());
+  }
+
+  @Override
+  public final String toString() {
+    return "[method=" + method + " headers=" + headers + " callOptions=" + callOptions + "]";
+  }
+
+  public static PickSubchannelArgs eqPickSubchannelArgs(
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions) {
+    return ArgumentMatchers.argThat(new PickSubchannelArgsMatcher(method, headers, callOptions));
+  }
+}
diff --git a/api/src/testFixtures/java/io/grpc/ServerRegistryAccessor.java b/api/src/testFixtures/java/io/grpc/ServerRegistryAccessor.java
new file mode 100644
index 00000000000..b15d4dfde19
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/ServerRegistryAccessor.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2023 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;
+
+/** Accesses test-only methods of {@link ServerRegistry}. */
+public final class ServerRegistryAccessor {
+  private ServerRegistryAccessor() {}
+
+  public static Iterable<Class<?>> getHardCodedClasses() {
+    return ServerRegistry.getHardCodedClasses();
+  }
+}
diff --git a/api/src/testFixtures/java/io/grpc/StaticTestingClassLoader.java b/api/src/testFixtures/java/io/grpc/StaticTestingClassLoader.java
new file mode 100644
index 00000000000..716a887e8da
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/StaticTestingClassLoader.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2017 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;
+
+import com.google.common.base.Preconditions;
+import com.google.common.io.ByteStreams;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.regex.Pattern;
+
+/**
+ * A class loader that can be used to repeatedly trigger static initialization of a class. A new
+ * instance is required per test.
+ */
+public final class StaticTestingClassLoader extends ClassLoader {
+  private final Pattern classesToDefine;
+
+  public StaticTestingClassLoader(ClassLoader parent, Pattern classesToDefine) {
+    super(parent);
+    this.classesToDefine = Preconditions.checkNotNull(classesToDefine, "classesToDefine");
+  }
+
+  @Override
+  protected Class<?> findClass(String name) throws ClassNotFoundException {
+    if (!classesToDefine.matcher(name).matches()) {
+      throw new ClassNotFoundException(name);
+    }
+    InputStream is = getResourceAsStream(name.replace('.', '/') + ".class");
+    if (is == null) {
+      throw new ClassNotFoundException(name);
+    }
+    byte[] b;
+    try {
+      b = ByteStreams.toByteArray(is);
+    } catch (IOException ex) {
+      throw new ClassNotFoundException(name, ex);
+    }
+    return defineClass(name, b, 0, b.length);
+  }
+
+  @Override
+  protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+    // Reverse normal loading order; check this class loader before its parent
+    synchronized (getClassLoadingLock(name)) {
+      Class<?> klass = findLoadedClass(name);
+      if (klass == null) {
+        try {
+          klass = findClass(name);
+        } catch (ClassNotFoundException e) {
+          // This ClassLoader doesn't know a class with that name; that's part of normal operation
+        }
+      }
+      if (klass == null) {
+        klass = super.loadClass(name, false);
+      }
+      if (resolve) {
+        resolveClass(klass);
+      }
+      return klass;
+    }
+  }
+}
diff --git a/api/src/testFixtures/java/io/grpc/StatusMatcher.java b/api/src/testFixtures/java/io/grpc/StatusMatcher.java
new file mode 100644
index 00000000000..f464b2d709d
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/StatusMatcher.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2025 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import org.mockito.ArgumentMatcher;
+
+/**
+ * Mockito matcher for {@link Status}.
+ */
+public final class StatusMatcher implements ArgumentMatcher<Status> {
+  public static StatusMatcher statusHasCode(ArgumentMatcher<Status.Code> codeMatcher) {
+    return new StatusMatcher(codeMatcher, null);
+  }
+
+  public static StatusMatcher statusHasCode(Status.Code code) {
+    return statusHasCode(new EqualsMatcher<>(code));
+  }
+
+  private final ArgumentMatcher<Status.Code> codeMatcher;
+  private final ArgumentMatcher<String> descriptionMatcher;
+
+  private StatusMatcher(
+      ArgumentMatcher<Status.Code> codeMatcher,
+      ArgumentMatcher<String> descriptionMatcher) {
+    this.codeMatcher = checkNotNull(codeMatcher, "codeMatcher");
+    this.descriptionMatcher = descriptionMatcher;
+  }
+
+  public StatusMatcher andDescription(ArgumentMatcher<String> descriptionMatcher) {
+    checkState(this.descriptionMatcher == null, "Already has a description matcher");
+    return new StatusMatcher(codeMatcher, descriptionMatcher);
+  }
+
+  public StatusMatcher andDescription(String description) {
+    return andDescription(new EqualsMatcher<>(description));
+  }
+
+  public StatusMatcher andDescriptionContains(String substring) {
+    return andDescription(new StringContainsMatcher(substring));
+  }
+
+  @Override
+  public boolean matches(Status status) {
+    return status != null
+        && codeMatcher.matches(status.getCode())
+        && (descriptionMatcher == null || descriptionMatcher.matches(status.getDescription()));
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+    sb.append("{code=");
+    sb.append(codeMatcher);
+    if (descriptionMatcher != null) {
+      sb.append(", description=");
+      sb.append(descriptionMatcher);
+    }
+    sb.append("}");
+    return sb.toString();
+  }
+
+  // Use instead of lambda for better error message.
+  static final class EqualsMatcher<T> implements ArgumentMatcher<T> {
+    private final T obj;
+
+    EqualsMatcher(T obj) {
+      this.obj = checkNotNull(obj, "obj");
+    }
+
+    @Override
+    public boolean matches(Object other) {
+      return obj.equals(other);
+    }
+
+    @Override
+    public String toString() {
+      return obj.toString();
+    }
+  }
+
+  static final class StringContainsMatcher implements ArgumentMatcher<String> {
+    private final String needle;
+
+    StringContainsMatcher(String needle) {
+      this.needle = checkNotNull(needle, "needle");
+    }
+
+    @Override
+    public boolean matches(String haystack) {
+      if (haystack == null) {
+        return false;
+      }
+      return haystack.contains(needle);
+    }
+
+    @Override
+    public String toString() {
+      return "contains " + needle;
+    }
+  }
+}
diff --git a/api/src/testFixtures/java/io/grpc/StatusOrMatcher.java b/api/src/testFixtures/java/io/grpc/StatusOrMatcher.java
new file mode 100644
index 00000000000..1e70ae97853
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/StatusOrMatcher.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2025 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import org.mockito.ArgumentMatcher;
+
+/**
+ * Mockito matcher for {@link StatusOr}.
+ */
+public final class StatusOrMatcher<T> implements ArgumentMatcher<StatusOr<T>> {
+  public static <T> StatusOrMatcher<T> hasValue(ArgumentMatcher<T> valueMatcher) {
+    return new StatusOrMatcher<T>(checkNotNull(valueMatcher, "valueMatcher"), null);
+  }
+
+  public static <T> StatusOrMatcher<T> hasStatus(ArgumentMatcher<Status> statusMatcher) {
+    return new StatusOrMatcher<T>(null, checkNotNull(statusMatcher, "statusMatcher"));
+  }
+
+  private final ArgumentMatcher<T> valueMatcher;
+  private final ArgumentMatcher<Status> statusMatcher;
+
+  private StatusOrMatcher(ArgumentMatcher<T> valueMatcher, ArgumentMatcher<Status> statusMatcher) {
+    this.valueMatcher = valueMatcher;
+    this.statusMatcher = statusMatcher;
+  }
+
+  @Override
+  public boolean matches(StatusOr<T> statusOr) {
+    if (statusOr == null) {
+      return false;
+    }
+    if (statusOr.hasValue() != (valueMatcher != null)) {
+      return false;
+    }
+    if (valueMatcher != null) {
+      return valueMatcher.matches(statusOr.getValue());
+    } else {
+      return statusMatcher.matches(statusOr.getStatus());
+    }
+  }
+
+  @Override
+  public String toString() {
+    if (valueMatcher != null) {
+      return "{value=" + valueMatcher + "}";
+    } else {
+      return "{status=" + statusMatcher + "}";
+    }
+  }
+}
diff --git a/api/src/testFixtures/java/io/grpc/StringMarshaller.java b/api/src/testFixtures/java/io/grpc/StringMarshaller.java
new file mode 100644
index 00000000000..e8358b76333
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/StringMarshaller.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2015 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;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.google.common.io.ByteStreams;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/** Marshalls UTF-8 encoded strings. */
+public class StringMarshaller implements MethodDescriptor.Marshaller<String> {
+  public static StringMarshaller INSTANCE = new StringMarshaller();
+
+  @Override
+  public InputStream stream(String value) {
+    return new ByteArrayInputStream(value.getBytes(UTF_8));
+  }
+
+  @Override
+  public String parse(InputStream stream) {
+    try {
+      return new String(ByteStreams.toByteArray(stream), UTF_8);
+    } catch (IOException ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+}
diff --git a/api/src/testFixtures/java/io/grpc/testing/DeadlineSubject.java b/api/src/testFixtures/java/io/grpc/testing/DeadlineSubject.java
new file mode 100644
index 00000000000..c2b4d8412a7
--- /dev/null
+++ b/api/src/testFixtures/java/io/grpc/testing/DeadlineSubject.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2016 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.testing;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.truth.Fact.fact;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import com.google.common.truth.ComparableSubject;
+import com.google.common.truth.FailureMetadata;
+import com.google.common.truth.Subject;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.Deadline;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/** Propositions for {@link Deadline} subjects. */
+@SuppressWarnings("rawtypes") // Generics in this class are going away in a subsequent Truth.
+public final class DeadlineSubject extends ComparableSubject {
+  public static final double NANOSECONDS_IN_A_SECOND = SECONDS.toNanos(1) * 1.0;
+  private static final Subject.Factory<DeadlineSubject, Deadline> deadlineFactory =
+      new Factory();
+
+  public static Subject.Factory<DeadlineSubject, Deadline> deadline() {
+    return deadlineFactory;
+  }
+
+  private final Deadline actual;
+
+  @SuppressWarnings("unchecked")
+  private DeadlineSubject(FailureMetadata metadata, Deadline subject) {
+    super(metadata, subject);
+    this.actual = subject;
+  }
+
+  /**
+   * Prepares for a check that the subject is deadline within the given tolerance of an
+   * expected value that will be provided in the next call in the fluent chain.
+   */
+  @CheckReturnValue
+  public TolerantDeadlineComparison isWithin(final long delta, final TimeUnit timeUnit) {
+    return new TolerantDeadlineComparison() {
+      @Override
+      public void of(Deadline expected) {
+        Deadline actual = DeadlineSubject.this.actual;
+        checkNotNull(actual, "actual value cannot be null. expected=%s", expected);
+
+        // This is probably overkill, but easier than thinking about overflow.
+        long actualNanos = actual.timeRemaining(NANOSECONDS);
+        long expectedNanos = expected.timeRemaining(NANOSECONDS);
+        long deltaNanos = timeUnit.toNanos(delta) ;
+        if (Math.abs(actualNanos - expectedNanos) > deltaNanos) {
+          failWithoutActual(
+              fact("expected", expectedNanos / NANOSECONDS_IN_A_SECOND),
+              fact("but was", actualNanos  / NANOSECONDS_IN_A_SECOND),
+              fact("outside tolerance in seconds",  deltaNanos  / NANOSECONDS_IN_A_SECOND));
+        }
+      }
+    };
+  }
+
+  // TODO(carl-mastrangelo):  Add a isNotWithin method once there is need for one.  Currently there
+  // is no such method since there is no code that uses it, and would lower our coverage numbers.
+
+  /**
+   * A partially specified proposition about an approximate relationship to a {@code deadline}
+   * subject using a tolerance.
+   */
+  public abstract static class TolerantDeadlineComparison {
+
+    private TolerantDeadlineComparison() {}
+
+    /**
+     * Fails if the subject was expected to be within the tolerance of the given value but was not
+     * <i>or</i> if it was expected <i>not</i> to be within the tolerance but was. The expectation,
+     * subject, and tolerance are all specified earlier in the fluent call chain.
+     */
+    public abstract void of(Deadline expectedDeadline);
+
+    /**
+     * Do not call this method.
+     *
+     * @throws UnsupportedOperationException always
+     * @deprecated {@link Object#equals(Object)} is not supported on TolerantDeadlineComparison
+     *     If you meant to compare deadlines, use {@link #of(Deadline)} instead.
+     */
+    // Deprecation used to signal visual warning in IDE for the unaware users.
+    // This method is created as a precaution and won't be removed as part of deprecation policy.
+    @Deprecated
+    @Override
+    public boolean equals(@Nullable Object o) {
+      throw new UnsupportedOperationException(
+          "If you meant to compare deadlines, use .of(Deadline) instead.");
+    }
+
+    /**
+     * Do not call this method.
+     *
+     * @throws UnsupportedOperationException always
+     * @deprecated {@link Object#hashCode()} is not supported on TolerantDeadlineComparison
+     */
+    // Deprecation used to signal visual warning in IDE for the unaware users.
+    // This method is created as a precaution and won't be removed as part of deprecation policy.
+    @Deprecated
+    @Override
+    public int hashCode() {
+      throw new UnsupportedOperationException("Subject.hashCode() is not supported.");
+    }
+  }
+
+  private static final class Factory implements Subject.Factory<DeadlineSubject, Deadline>  {
+    @Override
+    public DeadlineSubject createSubject(FailureMetadata metadata, Deadline that) {
+      return new DeadlineSubject(metadata, that);
+    }
+  }
+}
diff --git a/auth/BUILD.bazel b/auth/BUILD.bazel
new file mode 100644
index 00000000000..da44243e583
--- /dev/null
+++ b/auth/BUILD.bazel
@@ -0,0 +1,16 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "auth",
+    srcs = glob([
+        "src/main/java/io/grpc/auth/*.java",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api",
+        artifact("com.google.auth:google-auth-library-credentials"),
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
+    ],
+)
diff --git a/auth/build.gradle b/auth/build.gradle
index 7b9e65f63ce..d56802c14ca 100644
--- a/auth/build.gradle
+++ b/auth/build.gradle
@@ -1,7 +1,35 @@
-description = "gRpc: Auth"
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "me.champeau.gradle.japicmp"
+    id "ru.vyarus.animalsniffer"
+}
+
+description = "gRPC: Auth"
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.auth')
+    }
+}
+
 dependencies {
-    compile project(':grpc-core'),
-            libraries.google_auth_credentials
-    testCompile libraries.oauth_client
-    signature "org.codehaus.mojo.signature:java16:+@signature"
+    api project(':grpc-api'),
+            libraries.google.auth.credentials
+    implementation libraries.guava
+    testImplementation project(':grpc-testing'),
+            project(':grpc-core'),
+            project(":grpc-context"), // Override google-auth dependency with our newer version
+            libraries.google.auth.oauth2Http
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
diff --git a/auth/src/main/java/io/grpc/auth/ClientAuthInterceptor.java b/auth/src/main/java/io/grpc/auth/ClientAuthInterceptor.java
index 68f4a44dafd..ec5b4f0fa78 100644
--- a/auth/src/main/java/io/grpc/auth/ClientAuthInterceptor.java
+++ b/auth/src/main/java/io/grpc/auth/ClientAuthInterceptor.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.auth;
@@ -117,7 +102,7 @@ private URI serviceUri(Channel channel, MethodDescriptor<?, ?> method) throws St
     // Always use HTTPS, by definition.
     final String scheme = "https";
     final int defaultPort = 443;
-    String path = "/" + MethodDescriptor.extractFullServiceName(method.getFullMethodName());
+    String path = "/" + method.getServiceName();
     URI uri;
     try {
       uri = new URI(scheme, authority, path, null, null);
@@ -147,7 +132,8 @@ private Map<String, List<String>> getRequestMetadata(URI uri) throws StatusExcep
     try {
       return credentials.getRequestMetadata(uri);
     } catch (IOException e) {
-      throw Status.UNAUTHENTICATED.withCause(e).asException();
+      throw Status.UNAUTHENTICATED.withDescription("Unable to get request metadata").withCause(e)
+          .asException();
     }
   }
 
diff --git a/auth/src/main/java/io/grpc/auth/GoogleAuthLibraryCallCredentials.java b/auth/src/main/java/io/grpc/auth/GoogleAuthLibraryCallCredentials.java
index 7c8556c422b..b4b7f5b89e4 100644
--- a/auth/src/main/java/io/grpc/auth/GoogleAuthLibraryCallCredentials.java
+++ b/auth/src/main/java/io/grpc/auth/GoogleAuthLibraryCallCredentials.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.auth;
@@ -34,19 +19,21 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.auth.Credentials;
+import com.google.auth.RequestMetadataCallback;
+import com.google.auth.Retryable;
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.io.BaseEncoding;
-import io.grpc.Attributes;
-import io.grpc.CallCredentials;
+import io.grpc.InternalMayRequireSpecificExecutor;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
+import io.grpc.SecurityLevel;
 import io.grpc.Status;
 import io.grpc.StatusException;
-import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.security.PrivateKey;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -56,20 +43,28 @@
 import javax.annotation.Nullable;
 
 /**
- * Wraps {@link Credentials} as a {@link CallCredentials}.
+ * Wraps {@link Credentials} as a {@link io.grpc.CallCredentials}.
  */
-final class GoogleAuthLibraryCallCredentials implements CallCredentials {
+final class GoogleAuthLibraryCallCredentials extends io.grpc.CallCredentials
+    implements InternalMayRequireSpecificExecutor {
   private static final Logger log
       = Logger.getLogger(GoogleAuthLibraryCallCredentials.class.getName());
   private static final JwtHelper jwtHelper
       = createJwtHelperOrNull(GoogleAuthLibraryCallCredentials.class.getClassLoader());
+  private static final Class<? extends Credentials> GOOGLE_CREDENTIALS_CLASS
+      = loadGoogleCredentialsClass();
+  private static final Class<?> APP_ENGINE_CREDENTIALS_CLASS
+      = loadAppEngineCredentials();
 
+  private final boolean requirePrivacy;
   @VisibleForTesting
   final Credentials creds;
 
   private Metadata lastHeaders;
   private Map<String, List<String>> lastMetadata;
 
+  private final boolean requiresSpecificExecutor;
+
   public GoogleAuthLibraryCallCredentials(Credentials creds) {
     this(creds, jwtHelper);
   }
@@ -77,54 +72,89 @@ public GoogleAuthLibraryCallCredentials(Credentials creds) {
   @VisibleForTesting
   GoogleAuthLibraryCallCredentials(Credentials creds, JwtHelper jwtHelper) {
     checkNotNull(creds, "creds");
+    boolean requirePrivacy = false;
+    if (GOOGLE_CREDENTIALS_CLASS != null) {
+      // All GoogleCredentials instances are bearer tokens and should only be used on private
+      // channels. This catches all return values from GoogleCredentials.getApplicationDefault().
+      // This should be checked before upgrading the Service Account to JWT, as JWT is also a bearer
+      // token.
+      requirePrivacy = GOOGLE_CREDENTIALS_CLASS.isInstance(creds);
+    }
     if (jwtHelper != null) {
       creds = jwtHelper.tryServiceAccountToJwt(creds);
     }
+    this.requirePrivacy = requirePrivacy;
     this.creds = creds;
+
+    // Cache the value so we only need to try to load the class once
+    if (APP_ENGINE_CREDENTIALS_CLASS == null) {
+      requiresSpecificExecutor = false;
+    } else {
+      requiresSpecificExecutor = APP_ENGINE_CREDENTIALS_CLASS.isInstance(creds);
+    }
   }
 
   @Override
-  public void applyRequestMetadata(MethodDescriptor<?, ?> method, Attributes attrs,
-      Executor appExecutor, final MetadataApplier applier) {
-    String authority = checkNotNull(attrs.get(ATTR_AUTHORITY), "authority");
+  public void applyRequestMetadata(
+      RequestInfo info, Executor appExecutor, final MetadataApplier applier) {
+    SecurityLevel security = info.getSecurityLevel();
+    if (requirePrivacy && security != SecurityLevel.PRIVACY_AND_INTEGRITY) {
+      applier.fail(Status.UNAUTHENTICATED
+          .withDescription("Credentials require channel with PRIVACY_AND_INTEGRITY security level. "
+              + "Observed security level: " + security));
+      return;
+    }
+
+    String authority = checkNotNull(info.getAuthority(), "authority");
     final URI uri;
     try {
-      uri = serviceUri(authority, method);
+      uri = serviceUri(authority, info.getMethodDescriptor());
     } catch (StatusException e) {
       applier.fail(e.getStatus());
       return;
     }
-    appExecutor.execute(new Runnable() {
-        @Override
-        public void run() {
-          try {
-            // Credentials is expected to manage caching internally if the metadata is fetched over
-            // the network.
-            //
-            // TODO(zhangkun83): we don't know whether there is valid cache data. If there is, we
-            // would waste a context switch by always scheduling in executor. However, we have to
-            // do so because we can't risk blocking the network thread. This can be resolved after
-            // https://github.com/google/google-auth-library-java/issues/3 is resolved.
-            //
-            // Some implementations may return null here.
-            Map<String, List<String>> metadata = creds.getRequestMetadata(uri);
-            // Re-use the headers if getRequestMetadata() returns the same map. It may return a
-            // different map based on the provided URI, i.e., for JWT. However, today it does not
-            // cache JWT and so we won't bother tring to save its return value based on the URI.
-            Metadata headers;
-            synchronized (GoogleAuthLibraryCallCredentials.this) {
-              if (lastMetadata == null || lastMetadata != metadata) {
-                lastMetadata = metadata;
-                lastHeaders = toHeaders(metadata);
-              }
-              headers = lastHeaders;
+    // Credentials is expected to manage caching internally if the metadata is fetched over
+    // the network.
+    creds.getRequestMetadata(uri, appExecutor, new RequestMetadataCallback() {
+      @Override
+      public void onSuccess(Map<String, List<String>> metadata) {
+        // Some implementations may pass null metadata.
+
+        // Re-use the headers if getRequestMetadata() returns the same map. It may return a
+        // different map based on the provided URI, i.e., for JWT. However, today it does not
+        // cache JWT and so we won't bother tring to save its return value based on the URI.
+        Metadata headers;
+        try {
+          synchronized (GoogleAuthLibraryCallCredentials.this) {
+            if (lastMetadata == null || lastMetadata != metadata) {
+              lastHeaders = toHeaders(metadata);
+              lastMetadata = metadata;
             }
-            applier.apply(headers);
-          } catch (Throwable e) {
-            applier.fail(Status.UNAUTHENTICATED.withCause(e));
+            headers = lastHeaders;
           }
+        } catch (Throwable t) {
+          applier.fail(Status.UNAUTHENTICATED
+              .withDescription("Failed to convert credential metadata")
+              .withCause(t));
+          return;
         }
-      });
+        applier.apply(headers);
+      }
+
+      @Override
+      public void onFailure(Throwable e) {
+        if (e instanceof Retryable && ((Retryable) e).isRetryable()) {
+          // Let the call be retried with UNAVAILABLE.
+          applier.fail(Status.UNAVAILABLE
+              .withDescription("Credentials failed to obtain metadata")
+              .withCause(e));
+        } else {
+          applier.fail(Status.UNAUTHENTICATED
+              .withDescription("Failed computing credential metadata")
+              .withCause(e));
+        }
+      }
+    });
   }
 
   /**
@@ -134,13 +164,10 @@ public void run() {
    */
   private static URI serviceUri(String authority, MethodDescriptor<?, ?> method)
       throws StatusException {
-    if (authority == null) {
-      throw Status.UNAUTHENTICATED.withDescription("Channel has no authority").asException();
-    }
     // Always use HTTPS, by definition.
     final String scheme = "https";
     final int defaultPort = 443;
-    String path = "/" + MethodDescriptor.extractFullServiceName(method.getFullMethodName());
+    String path = "/" + method.getServiceName();
     URI uri;
     try {
       uri = new URI(scheme, authority, path, null, null);
@@ -190,50 +217,130 @@ private static Metadata toHeaders(@Nullable Map<String, List<String>> metadata)
   static JwtHelper createJwtHelperOrNull(ClassLoader loader) {
     Class<?> rawServiceAccountClass;
     try {
-      // Specify loader so it can be overriden in tests
+      // Specify loader so it can be overridden in tests
       rawServiceAccountClass
           = Class.forName("com.google.auth.oauth2.ServiceAccountCredentials", false, loader);
     } catch (ClassNotFoundException ex) {
       return null;
     }
+    Exception caughtException;
     try {
       return new JwtHelper(rawServiceAccountClass, loader);
-    } catch (ReflectiveOperationException ex) {
+    } catch (ClassNotFoundException ex) {
+      caughtException = ex;
+    } catch (NoSuchMethodException ex) {
+      caughtException = ex;
+    }
+    if (caughtException != null) {
       // Failure is a bug in this class, but we still choose to gracefully recover
-      log.log(Level.WARNING, "Failed to create JWT helper. This is unexpected", ex);
+      log.log(Level.WARNING, "Failed to create JWT helper. This is unexpected", caughtException);
+    }
+    return null;
+  }
+
+  @Nullable
+  private static Class<? extends Credentials> loadGoogleCredentialsClass() {
+    Class<?> rawGoogleCredentialsClass;
+    try {
+      // Can't use a loader as it disables ProGuard's reference detection and would fail to rename
+      // this reference. Unfortunately this will initialize the class.
+      rawGoogleCredentialsClass = Class.forName("com.google.auth.oauth2.GoogleCredentials");
+    } catch (ClassNotFoundException ex) {
+      log.log(Level.FINE, "Failed to load GoogleCredentials", ex);
+      return null;
+    }
+    return rawGoogleCredentialsClass.asSubclass(Credentials.class);
+  }
+
+  @Nullable
+  private static Class<?> loadAppEngineCredentials() {
+    try {
+      return Class.forName("com.google.auth.appengine.AppEngineCredentials");
+    } catch (ClassNotFoundException ex) {
+      log.log(Level.FINE, "AppEngineCredentials not available in classloader", ex);
       return null;
     }
   }
 
+  private static class MethodPair {
+    private final Method getter;
+    private final Method builderSetter;
+
+    private MethodPair(Method getter, Method builderSetter) {
+      this.getter = getter;
+      this.builderSetter = builderSetter;
+    }
+
+    private void apply(Credentials credentials, Object builder)
+        throws InvocationTargetException, IllegalAccessException {
+      builderSetter.invoke(builder, getter.invoke(credentials));
+    }
+  }
+
   @VisibleForTesting
   static class JwtHelper {
     private final Class<? extends Credentials> serviceAccountClass;
-    private final Constructor<? extends Credentials> jwtConstructor;
+    private final Method newJwtBuilder;
+    private final Method build;
     private final Method getScopes;
-    private final Method getClientId;
-    private final Method getClientEmail;
-    private final Method getPrivateKey;
-    private final Method getPrivateKeyId;
+    private final List<MethodPair> methodPairs;
 
     public JwtHelper(Class<?> rawServiceAccountClass, ClassLoader loader)
-        throws ReflectiveOperationException {
+        throws ClassNotFoundException, NoSuchMethodException {
       serviceAccountClass = rawServiceAccountClass.asSubclass(Credentials.class);
       getScopes = serviceAccountClass.getMethod("getScopes");
-      getClientId = serviceAccountClass.getMethod("getClientId");
-      getClientEmail = serviceAccountClass.getMethod("getClientEmail");
-      getPrivateKey = serviceAccountClass.getMethod("getPrivateKey");
-      getPrivateKeyId = serviceAccountClass.getMethod("getPrivateKeyId");
       Class<? extends Credentials> jwtClass = Class.forName(
           "com.google.auth.oauth2.ServiceAccountJwtAccessCredentials", false, loader)
           .asSubclass(Credentials.class);
-      jwtConstructor
-          = jwtClass.getConstructor(String.class, String.class, PrivateKey.class, String.class);
+      newJwtBuilder = jwtClass.getDeclaredMethod("newBuilder");
+      Class<?> builderClass = newJwtBuilder.getReturnType();
+      build = builderClass.getMethod("build");
+
+      methodPairs = new ArrayList<>();
+
+      {
+        Method getter = serviceAccountClass.getMethod("getClientId");
+        Method setter = builderClass.getMethod("setClientId", getter.getReturnType());
+        methodPairs.add(new MethodPair(getter, setter));
+      }
+      {
+        Method getter = serviceAccountClass.getMethod("getClientEmail");
+        Method setter = builderClass.getMethod("setClientEmail", getter.getReturnType());
+        methodPairs.add(new MethodPair(getter, setter));
+      }
+      {
+        Method getter = serviceAccountClass.getMethod("getPrivateKey");
+        Method setter = builderClass.getMethod("setPrivateKey", getter.getReturnType());
+        methodPairs.add(new MethodPair(getter, setter));
+      }
+      {
+        Method getter = serviceAccountClass.getMethod("getPrivateKeyId");
+        Method setter = builderClass.getMethod("setPrivateKeyId", getter.getReturnType());
+        methodPairs.add(new MethodPair(getter, setter));
+      }
+      {
+        Method getter = serviceAccountClass.getMethod("getQuotaProjectId");
+        Method setter = builderClass.getMethod("setQuotaProjectId", getter.getReturnType());
+        methodPairs.add(new MethodPair(getter, setter));
+      }
     }
 
+    /**
+     * This method tries to convert a {@link Credentials} object to a
+     * ServiceAccountJwtAccessCredentials.  The original credentials will be returned if:
+     * <ul>
+     *   <li> The Credentials is not a ServiceAccountCredentials</li>
+     *   <li> The ServiceAccountCredentials has scopes</li>
+     *   <li> Something unexpected happens </li>
+     * </ul>
+     * @param creds the Credentials to convert
+     * @return either the original Credentials or a fully formed ServiceAccountJwtAccessCredentials.
+     */
     public Credentials tryServiceAccountToJwt(Credentials creds) {
       if (!serviceAccountClass.isInstance(creds)) {
         return creds;
       }
+      Exception caughtException;
       try {
         creds = serviceAccountClass.cast(creds);
         Collection<?> scopes = (Collection<?>) getScopes.invoke(creds);
@@ -241,17 +348,40 @@ public Credentials tryServiceAccountToJwt(Credentials creds) {
           // Leave as-is, since the scopes may limit access within the service.
           return creds;
         }
-        return jwtConstructor.newInstance(
-            getClientId.invoke(creds),
-            getClientEmail.invoke(creds),
-            getPrivateKey.invoke(creds),
-            getPrivateKeyId.invoke(creds));
-      } catch (ReflectiveOperationException ex) {
+        // Create the JWT Credentials Builder
+        Object builder = newJwtBuilder.invoke(null);
+
+        // Get things from the credentials, and set them on the builder.
+        for (MethodPair pair : this.methodPairs) {
+          pair.apply(creds, builder);
+        }
+
+        // Call builder.build()
+        return (Credentials) build.invoke(builder);
+      } catch (IllegalAccessException ex) {
+        caughtException = ex;
+      } catch (InvocationTargetException ex) {
+        caughtException = ex;
+      }
+      if (caughtException != null) {
         // Failure is a bug in this class, but we still choose to gracefully recover
-        log.log(Level.WARNING,
-            "Failed converting service account credential to JWT. This is unexpected", ex);
-        return creds;
+        log.log(
+            Level.WARNING,
+            "Failed converting service account credential to JWT. This is unexpected",
+            caughtException);
       }
+      return creds;
     }
   }
+
+  /**
+   * This method is to support the hack for AppEngineCredentials which need to run on a
+   * specific thread.
+   * @return Whether a specific executor is needed or if any executor can be used
+   */
+  @Override
+  public boolean isSpecificExecutorRequired() {
+    return requiresSpecificExecutor;
+  }
+
 }
diff --git a/auth/src/main/java/io/grpc/auth/MoreCallCredentials.java b/auth/src/main/java/io/grpc/auth/MoreCallCredentials.java
index 9961b6253db..8c6f2dc80ed 100644
--- a/auth/src/main/java/io/grpc/auth/MoreCallCredentials.java
+++ b/auth/src/main/java/io/grpc/auth/MoreCallCredentials.java
@@ -1,47 +1,35 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.auth;
 
 import com.google.auth.Credentials;
 import io.grpc.CallCredentials;
-import io.grpc.ExperimentalApi;
 
 /**
  * A utility class that converts other types of credentials to {@link CallCredentials}.
  */
-@ExperimentalApi("https//github.com/grpc/grpc-java/issues/1914")
 public final class MoreCallCredentials {
   /**
    * Converts a Google Auth Library {@link Credentials} to {@link CallCredentials}.
+   *
+   * <p>Although this is a stable API, note that the returned instance's API is not stable. You are
+   * free to use the class name {@code CallCredentials} and pass the instance to other code, but the
+   * instance can't be called directly from code expecting stable behavior. See {@link
+   * CallCredentials}.
    */
   public static CallCredentials from(Credentials creds) {
     return new GoogleAuthLibraryCallCredentials(creds);
diff --git a/auth/src/main/java/io/grpc/auth/package-info.java b/auth/src/main/java/io/grpc/auth/package-info.java
new file mode 100644
index 00000000000..fb707bdf1db
--- /dev/null
+++ b/auth/src/main/java/io/grpc/auth/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2017 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.
+ */
+
+/**
+ * Implementations of {@link io.grpc.CallCredentials} and authentication related API.
+ */
+package io.grpc.auth;
diff --git a/auth/src/test/java/io/grpc/auth/ClientAuthInterceptorTest.java b/auth/src/test/java/io/grpc/auth/ClientAuthInterceptorTest.java
index 9dd4429cd09..4c1c66bff02 100644
--- a/auth/src/test/java/io/grpc/auth/ClientAuthInterceptorTest.java
+++ b/auth/src/test/java/io/grpc/auth/ClientAuthInterceptorTest.java
@@ -1,41 +1,26 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.auth;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -61,13 +46,15 @@
 import java.util.concurrent.Executor;
 import org.junit.Assert;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /**
  * Tests for {@link ClientAuthInterceptor}.
@@ -83,6 +70,9 @@ public class ClientAuthInterceptorTest {
 
   private final Executor executor = MoreExecutors.directExecutor();
 
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
   @Mock
   Credentials credentials;
 
@@ -107,7 +97,6 @@ public class ClientAuthInterceptorTest {
   /** Set up for test. */
   @Before
   public void startUp() {
-    MockitoAnnotations.initMocks(this);
     descriptor = MethodDescriptor.<String, Integer>newBuilder()
         .setType(MethodDescriptor.MethodType.UNKNOWN)
         .setFullMethodName("a.service/method")
@@ -199,11 +188,6 @@ public void verifyServiceUri() throws IOException {
   private static final class ClientCallRecorder extends ClientCall<String, Integer> {
     private ClientCall.Listener<Integer> responseListener;
     private Metadata headers;
-    private int numMessages;
-    private String cancelMessage;
-    private Throwable cancelCause;
-    private boolean halfClosed;
-    private String sentMessage;
 
     @Override
     public void start(ClientCall.Listener<Integer> responseListener, Metadata headers) {
@@ -213,23 +197,18 @@ public void start(ClientCall.Listener<Integer> responseListener, Metadata header
 
     @Override
     public void request(int numMessages) {
-      this.numMessages = numMessages;
     }
 
     @Override
     public void cancel(String message, Throwable cause) {
-      this.cancelMessage = message;
-      this.cancelCause = cause;
     }
 
     @Override
     public void halfClose() {
-      halfClosed = true;
     }
 
     @Override
     public void sendMessage(String message) {
-      sentMessage = message;
     }
 
   }
diff --git a/auth/src/test/java/io/grpc/auth/GoogleAuthLibraryCallCredentialsTest.java b/auth/src/test/java/io/grpc/auth/GoogleAuthLibraryCallCredentialsTest.java
index c88e15d9421..75026fd7c18 100644
--- a/auth/src/test/java/io/grpc/auth/GoogleAuthLibraryCallCredentialsTest.java
+++ b/auth/src/test/java/io/grpc/auth/GoogleAuthLibraryCallCredentialsTest.java
@@ -1,56 +1,46 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.auth;
 
-import static com.google.common.base.Charsets.US_ASCII;
+import static java.nio.charset.StandardCharsets.US_ASCII;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import com.google.auth.Credentials;
+import com.google.auth.RequestMetadataCallback;
+import com.google.auth.Retryable;
+import com.google.auth.http.HttpTransportFactory;
 import com.google.auth.oauth2.AccessToken;
+import com.google.auth.oauth2.GoogleCredentials;
 import com.google.auth.oauth2.OAuth2Credentials;
 import com.google.auth.oauth2.ServiceAccountCredentials;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.LinkedListMultimap;
 import com.google.common.collect.ListMultimap;
 import com.google.common.collect.Multimaps;
+import com.google.common.io.BaseEncoding;
 import io.grpc.Attributes;
 import io.grpc.CallCredentials;
 import io.grpc.CallCredentials.MetadataApplier;
@@ -58,24 +48,32 @@
 import io.grpc.MethodDescriptor;
 import io.grpc.SecurityLevel;
 import io.grpc.Status;
+import io.grpc.internal.JsonParser;
+import io.grpc.testing.TestMethodDescriptors;
+import io.grpc.testing.TlsTesting;
+import io.grpc.util.CertificateUtils;
 import java.io.IOException;
+import java.io.InputStream;
 import java.net.URI;
-import java.security.KeyPair;
-import java.security.KeyPairGenerator;
+import java.security.PrivateKey;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.Executor;
+import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Captor;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.Mockito;
 import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.mockito.stubbing.Answer;
 
 /**
@@ -84,25 +82,25 @@
 @RunWith(JUnit4.class)
 public class GoogleAuthLibraryCallCredentialsTest {
 
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
   private static final Metadata.Key<String> AUTHORIZATION = Metadata.Key.of("Authorization",
       Metadata.ASCII_STRING_MARSHALLER);
   private static final Metadata.Key<byte[]> EXTRA_AUTHORIZATION = Metadata.Key.of(
       "Extra-Authorization-bin", Metadata.BINARY_BYTE_MARSHALLER);
 
-  @Mock
-  private MethodDescriptor.Marshaller<String> stringMarshaller;
-
-  @Mock
-  private MethodDescriptor.Marshaller<Integer> intMarshaller;
-
   @Mock
   private Credentials credentials;
 
   @Mock
   private MetadataApplier applier;
 
-  @Mock
-  private Executor executor;
+  private Executor executor = new Executor() {
+    @Override public void execute(Runnable r) {
+      pendingRunnables.add(r);
+    }
+  };
 
   @Captor
   private ArgumentCaptor<Metadata> headersCaptor;
@@ -110,35 +108,47 @@ public class GoogleAuthLibraryCallCredentialsTest {
   @Captor
   private ArgumentCaptor<Status> statusCaptor;
 
-  private MethodDescriptor<String, Integer> method;
-  private URI expectedUri;
-
-  private final String authority = "testauthority";
-  private final Attributes attrs = Attributes.newBuilder()
-      .set(CallCredentials.ATTR_AUTHORITY, authority)
-      .set(CallCredentials.ATTR_SECURITY_LEVEL, SecurityLevel.PRIVACY_AND_INTEGRITY)
+  private MethodDescriptor<Void, Void> method = MethodDescriptor.<Void, Void>newBuilder()
+      .setType(MethodDescriptor.MethodType.UNKNOWN)
+      .setFullMethodName("a.service/method")
+      .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+      .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
       .build();
+  private URI expectedUri = URI.create("https://testauthority/a.service");
 
-  private ArrayList<Runnable> pendingRunnables = new ArrayList<Runnable>();
+  private static final String AUTHORITY = "testauthority";
+  private static final SecurityLevel SECURITY_LEVEL = SecurityLevel.PRIVACY_AND_INTEGRITY;
+
+  private ArrayList<Runnable> pendingRunnables = new ArrayList<>();
 
   @Before
   public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
-    method = MethodDescriptor.<String, Integer>newBuilder()
-        .setType(MethodDescriptor.MethodType.UNKNOWN)
-        .setFullMethodName("a.service/method")
-        .setRequestMarshaller(stringMarshaller)
-        .setResponseMarshaller(intMarshaller)
-        .build();
-    expectedUri = new URI("https://testauthority/a.service");
     doAnswer(new Answer<Void>() {
-        @Override
-        public Void answer(InvocationOnMock invocation) {
-          Runnable r = (Runnable) invocation.getArguments()[0];
-          pendingRunnables.add(r);
+      @Override
+      public Void answer(InvocationOnMock invocation) {
+        Credentials mock = (Credentials) invocation.getMock();
+        URI uri = (URI) invocation.getArguments()[0];
+        RequestMetadataCallback callback = (RequestMetadataCallback) invocation.getArguments()[2];
+        Map<String, List<String>> metadata;
+        try {
+          // Default to calling the blocking method, since it is easier to mock
+          metadata = mock.getRequestMetadata(uri);
+        } catch (Exception ex) {
+          callback.onFailure(ex);
           return null;
         }
-      }).when(executor).execute(any(Runnable.class));
+        callback.onSuccess(metadata);
+        return null;
+      }
+    }).when(credentials).getRequestMetadata(
+        any(URI.class),
+        any(Executor.class),
+        any(RequestMetadataCallback.class));
+  }
+
+  @After
+  public void tearDown() {
+    assertEquals(0, pendingRunnables.size());
   }
 
   @Test
@@ -152,8 +162,7 @@ public void copyCredentialsToHeaders() throws Exception {
 
     GoogleAuthLibraryCallCredentials callCredentials =
         new GoogleAuthLibraryCallCredentials(credentials);
-    callCredentials.applyRequestMetadata(method, attrs, executor, applier);
-    assertEquals(1, runPendingRunnables());
+    callCredentials.applyRequestMetadata(new RequestInfoImpl(), executor, applier);
 
     verify(credentials).getRequestMetadata(eq(expectedUri));
     verify(applier).apply(headersCaptor.capture());
@@ -175,8 +184,7 @@ public void invalidBase64() throws Exception {
 
     GoogleAuthLibraryCallCredentials callCredentials =
         new GoogleAuthLibraryCallCredentials(credentials);
-    callCredentials.applyRequestMetadata(method, attrs, executor, applier);
-    assertEquals(1, runPendingRunnables());
+    callCredentials.applyRequestMetadata(new RequestInfoImpl(), executor, applier);
 
     verify(credentials).getRequestMetadata(eq(expectedUri));
     verify(applier).fail(statusCaptor.capture());
@@ -186,14 +194,47 @@ public void invalidBase64() throws Exception {
   }
 
   @Test
-  public void credentialsThrows() throws Exception {
-    IOException exception = new IOException("Broken");
+  public void credentialsFailsWithRetryableRetryableException() throws Exception {
+    boolean retryable = true;
+    Exception exception = new RetryableException(retryable);
     when(credentials.getRequestMetadata(eq(expectedUri))).thenThrow(exception);
 
     GoogleAuthLibraryCallCredentials callCredentials =
         new GoogleAuthLibraryCallCredentials(credentials);
-    callCredentials.applyRequestMetadata(method, attrs, executor, applier);
-    assertEquals(1, runPendingRunnables());
+    callCredentials.applyRequestMetadata(new RequestInfoImpl(), executor, applier);
+
+    verify(credentials).getRequestMetadata(eq(expectedUri));
+    verify(applier).fail(statusCaptor.capture());
+    Status status = statusCaptor.getValue();
+    assertEquals(Status.Code.UNAVAILABLE, status.getCode());
+    assertEquals(exception, status.getCause());
+  }
+
+  @Test
+  public void credentialsFailsWithUnretryableRetryableException() throws Exception {
+    boolean retryable = false;
+    Exception exception = new RetryableException(retryable);
+    when(credentials.getRequestMetadata(eq(expectedUri))).thenThrow(exception);
+
+    GoogleAuthLibraryCallCredentials callCredentials =
+        new GoogleAuthLibraryCallCredentials(credentials);
+    callCredentials.applyRequestMetadata(new RequestInfoImpl(), executor, applier);
+
+    verify(credentials).getRequestMetadata(eq(expectedUri));
+    verify(applier).fail(statusCaptor.capture());
+    Status status = statusCaptor.getValue();
+    assertEquals(Status.Code.UNAUTHENTICATED, status.getCode());
+    assertEquals(exception, status.getCause());
+  }
+
+  @Test
+  public void credentialsFailsWithRuntimeException() throws Exception {
+    Exception exception = new RuntimeException("Broken");
+    when(credentials.getRequestMetadata(eq(expectedUri))).thenThrow(exception);
+
+    GoogleAuthLibraryCallCredentials callCredentials =
+        new GoogleAuthLibraryCallCredentials(credentials);
+    callCredentials.applyRequestMetadata(new RequestInfoImpl(), executor, applier);
 
     verify(credentials).getRequestMetadata(eq(expectedUri));
     verify(applier).fail(statusCaptor.capture());
@@ -208,33 +249,32 @@ public void credentialsReturnNullMetadata() throws Exception {
     ListMultimap<String, String> values = LinkedListMultimap.create();
     values.put("Authorization", "token1");
     when(credentials.getRequestMetadata(eq(expectedUri)))
-        .thenReturn(null, Multimaps.<String, String>asMap(values), null);
+        .thenReturn(null, Multimaps.asMap(values), null);
 
     GoogleAuthLibraryCallCredentials callCredentials =
         new GoogleAuthLibraryCallCredentials(credentials);
     for (int i = 0; i < 3; i++) {
-      callCredentials.applyRequestMetadata(method, attrs, executor, applier);
+      callCredentials.applyRequestMetadata(new RequestInfoImpl(), executor, applier);
     }
 
-    assertEquals(3, runPendingRunnables());
     verify(credentials, times(3)).getRequestMetadata(eq(expectedUri));
 
     verify(applier, times(3)).apply(headersCaptor.capture());
     List<Metadata> headerList = headersCaptor.getAllValues();
     assertEquals(3, headerList.size());
 
-    assertEquals(0, headerList.get(0).headerCount());
+    assertEquals(0, headerList.get(0).keys().size());
 
     Iterable<String> authorization = headerList.get(1).getAll(AUTHORIZATION);
     assertArrayEquals(new String[]{"token1"}, Iterables.toArray(authorization, String.class));
 
-    assertEquals(0, headerList.get(2).headerCount());
+    assertEquals(0, headerList.get(2).keys().size());
   }
 
   @Test
   public void oauth2Credential() {
     final AccessToken token = new AccessToken("allyourbase", new Date(Long.MAX_VALUE));
-    final OAuth2Credentials credentials = new OAuth2Credentials() {
+    OAuth2Credentials credentials = new OAuth2Credentials() {
       @Override
       public AccessToken refreshAccessToken() throws IOException {
         return token;
@@ -243,7 +283,8 @@ public AccessToken refreshAccessToken() throws IOException {
 
     GoogleAuthLibraryCallCredentials callCredentials =
         new GoogleAuthLibraryCallCredentials(credentials);
-    callCredentials.applyRequestMetadata(method, attrs, executor, applier);
+    callCredentials.applyRequestMetadata(
+        new RequestInfoImpl(SecurityLevel.NONE), executor, applier);
     assertEquals(1, runPendingRunnables());
 
     verify(applier).apply(headersCaptor.capture());
@@ -253,44 +294,76 @@ public AccessToken refreshAccessToken() throws IOException {
         Iterables.toArray(authorization, String.class));
   }
 
+  @Test
+  public void googleCredential_privacyAndIntegrityAllowed() {
+    final AccessToken token = new AccessToken("allyourbase", new Date(Long.MAX_VALUE));
+    final Credentials credentials = GoogleCredentials.create(token);
+
+    GoogleAuthLibraryCallCredentials callCredentials =
+        new GoogleAuthLibraryCallCredentials(credentials);
+    callCredentials.applyRequestMetadata(
+        new RequestInfoImpl(SecurityLevel.PRIVACY_AND_INTEGRITY), executor, applier);
+    runPendingRunnables();
+
+    verify(applier).apply(headersCaptor.capture());
+    Metadata headers = headersCaptor.getValue();
+    Iterable<String> authorization = headers.getAll(AUTHORIZATION);
+    assertArrayEquals(new String[]{"Bearer allyourbase"},
+        Iterables.toArray(authorization, String.class));
+  }
+
+  @Test
+  public void googleCredential_integrityDenied() {
+    final AccessToken token = new AccessToken("allyourbase", new Date(Long.MAX_VALUE));
+    final Credentials credentials = GoogleCredentials.create(token);
+    // Anything less than PRIVACY_AND_INTEGRITY should fail
+
+    GoogleAuthLibraryCallCredentials callCredentials =
+        new GoogleAuthLibraryCallCredentials(credentials);
+    callCredentials.applyRequestMetadata(
+        new RequestInfoImpl(SecurityLevel.INTEGRITY), executor, applier);
+    runPendingRunnables();
+
+    verify(applier).fail(statusCaptor.capture());
+    Status status = statusCaptor.getValue();
+    assertEquals(Status.Code.UNAUTHENTICATED, status.getCode());
+  }
+
   @Test
   public void serviceUri() throws Exception {
     GoogleAuthLibraryCallCredentials callCredentials =
         new GoogleAuthLibraryCallCredentials(credentials);
-    callCredentials.applyRequestMetadata(method,
-        Attributes.newBuilder()
-            .setAll(attrs)
-            .set(CallCredentials.ATTR_AUTHORITY, "example.com:443")
-            .build(),
-        executor, applier);
-    assertEquals(1, runPendingRunnables());
+    callCredentials.applyRequestMetadata(
+        new RequestInfoImpl("example.com:443"), executor, applier);
     verify(credentials).getRequestMetadata(eq(new URI("https://example.com/a.service")));
 
-    callCredentials.applyRequestMetadata(method,
-        Attributes.newBuilder()
-            .setAll(attrs)
-            .set(CallCredentials.ATTR_AUTHORITY, "example.com:123")
-            .build(),
-        executor, applier);
-    assertEquals(1, runPendingRunnables());
+    callCredentials.applyRequestMetadata(
+        new RequestInfoImpl("example.com:123"), executor, applier);
     verify(credentials).getRequestMetadata(eq(new URI("https://example.com:123/a.service")));
   }
 
   @Test
   public void serviceAccountToJwt() throws Exception {
-    KeyPair pair = KeyPairGenerator.getInstance("RSA").generateKeyPair();
-    ServiceAccountCredentials credentials = new ServiceAccountCredentials(
-        null, "email@example.com", pair.getPrivate(), null, null) {
-      @Override
-      public AccessToken refreshAccessToken() {
-        throw new AssertionError();
-      }
-    };
+    PrivateKey privateKey;
+    try (InputStream server1Key = TlsTesting.loadCert("server1.key")) {
+      privateKey = CertificateUtils.getPrivateKey(server1Key);
+    }
+
+    HttpTransportFactory factory = Mockito.mock(HttpTransportFactory.class);
+    Mockito.when(factory.create()).thenThrow(new AssertionError());
+
+    ServiceAccountCredentials credentials =
+        ServiceAccountCredentials.newBuilder()
+            .setClientEmail("test-email@example.com")
+            .setPrivateKey(privateKey)
+            .setPrivateKeyId("test-private-key-id")
+            .setHttpTransportFactory(factory)
+            .build();
 
     GoogleAuthLibraryCallCredentials callCredentials =
         new GoogleAuthLibraryCallCredentials(credentials);
-    callCredentials.applyRequestMetadata(method, attrs, executor, applier);
-    assertEquals(1, runPendingRunnables());
+    callCredentials.applyRequestMetadata(new RequestInfoImpl(), executor, applier);
+    assertEquals(0, runPendingRunnables());
 
     verify(applier).apply(headersCaptor.capture());
     Metadata headers = headersCaptor.getValue();
@@ -301,30 +374,6 @@ public AccessToken refreshAccessToken() {
     assertTrue(authorization[0], authorization[0].length() > 300);
   }
 
-  @Test
-  public void serviceAccountWithScopeNotToJwt() throws Exception {
-    final AccessToken token = new AccessToken("allyourbase", new Date(Long.MAX_VALUE));
-    KeyPair pair = KeyPairGenerator.getInstance("RSA").generateKeyPair();
-    ServiceAccountCredentials credentials = new ServiceAccountCredentials(
-        null, "email@example.com", pair.getPrivate(), null, Arrays.asList("somescope")) {
-      @Override
-      public AccessToken refreshAccessToken() {
-        return token;
-      }
-    };
-
-    GoogleAuthLibraryCallCredentials callCredentials =
-        new GoogleAuthLibraryCallCredentials(credentials);
-    callCredentials.applyRequestMetadata(method, attrs, executor, applier);
-    assertEquals(1, runPendingRunnables());
-
-    verify(applier).apply(headersCaptor.capture());
-    Metadata headers = headersCaptor.getValue();
-    Iterable<String> authorization = headers.getAll(AUTHORIZATION);
-    assertArrayEquals(new String[]{"Bearer allyourbase"},
-        Iterables.toArray(authorization, String.class));
-  }
-
   @Test
   public void oauthClassesNotInClassPath() throws Exception {
     ListMultimap<String, String> values = LinkedListMultimap.create();
@@ -334,8 +383,7 @@ public void oauthClassesNotInClassPath() throws Exception {
     assertNull(GoogleAuthLibraryCallCredentials.createJwtHelperOrNull(null));
     GoogleAuthLibraryCallCredentials callCredentials =
         new GoogleAuthLibraryCallCredentials(credentials, null);
-    callCredentials.applyRequestMetadata(method, attrs, executor, applier);
-    assertEquals(1, runPendingRunnables());
+    callCredentials.applyRequestMetadata(new RequestInfoImpl(), executor, applier);
 
     verify(credentials).getRequestMetadata(eq(expectedUri));
     verify(applier).apply(headersCaptor.capture());
@@ -345,12 +393,113 @@ public void oauthClassesNotInClassPath() throws Exception {
         Iterables.toArray(authorization, String.class));
   }
 
+  @Test
+  public void jwtAccessCredentialsInRequestMetadata() throws Exception {
+    PrivateKey privateKey;
+    try (InputStream server1Key = TlsTesting.loadCert("server1.key")) {
+      privateKey = CertificateUtils.getPrivateKey(server1Key);
+    }
+
+    ServiceAccountCredentials credentials =
+        ServiceAccountCredentials.newBuilder()
+            .setClientId("test-client")
+            .setClientEmail("test-email@example.com")
+            .setPrivateKey(privateKey)
+            .setPrivateKeyId("test-private-key-id")
+            .setQuotaProjectId("test-quota-project-id")
+            .build();
+    GoogleAuthLibraryCallCredentials callCredentials =
+        new GoogleAuthLibraryCallCredentials(credentials);
+    callCredentials.applyRequestMetadata(new RequestInfoImpl("example.com:123"), executor, applier);
+
+    verify(applier).apply(headersCaptor.capture());
+    Metadata headers = headersCaptor.getValue();
+    String token =
+        Iterables.getOnlyElement(headers.getAll(AUTHORIZATION)).substring("Bearer ".length());
+    String[] parts = token.split("\\.", 3);
+    String jsonHeader = new String(BaseEncoding.base64Url().decode(parts[0]), US_ASCII);
+    String jsonPayload = new String(BaseEncoding.base64Url().decode(parts[1]), US_ASCII);
+    Map<?, ?> header = (Map<?, ?>) JsonParser.parse(jsonHeader);
+    assertEquals("test-private-key-id", header.get("kid"));
+    Map<?, ?> payload = (Map<?, ?>) JsonParser.parse(jsonPayload);
+    // google-auth-library-java 0.25.2 began stripping the grpc service name from the audience.
+    // Allow tests to pass with both the old and new versions for a while to avoid an atomic upgrade
+    // everywhere google-auth-library-java is used.
+    assertTrue("https://example.com/".equals(payload.get("aud"))
+        || "https://example.com:123/a.service".equals(payload.get("aud")));
+    assertEquals("test-email@example.com", payload.get("iss"));
+    assertEquals("test-email@example.com", payload.get("sub"));
+
+    Metadata.Key<String> quotaProject = Metadata.Key
+        .of("X-Goog-User-Project", Metadata.ASCII_STRING_MARSHALLER);
+    assertEquals("test-quota-project-id", Iterables.getOnlyElement(headers.getAll(quotaProject)));
+  }
+
   private int runPendingRunnables() {
     ArrayList<Runnable> savedPendingRunnables = pendingRunnables;
-    pendingRunnables = new ArrayList<Runnable>();
+    pendingRunnables = new ArrayList<>();
     for (Runnable r : savedPendingRunnables) {
       r.run();
     }
     return savedPendingRunnables.size();
   }
+
+  private final class RequestInfoImpl extends CallCredentials.RequestInfo {
+    final String authority;
+    final SecurityLevel securityLevel;
+
+    RequestInfoImpl() {
+      this(AUTHORITY, SECURITY_LEVEL);
+    }
+
+    RequestInfoImpl(SecurityLevel securityLevel) {
+      this(AUTHORITY, securityLevel);
+    }
+
+    RequestInfoImpl(String authority) {
+      this(authority, SECURITY_LEVEL);
+    }
+
+    RequestInfoImpl(String authority, SecurityLevel securityLevel) {
+      this.authority = authority;
+      this.securityLevel = securityLevel;
+    }
+
+    @Override
+    public MethodDescriptor<?, ?> getMethodDescriptor() {
+      return method;
+    }
+
+    @Override
+    public SecurityLevel getSecurityLevel() {
+      return securityLevel;
+    }
+
+    @Override
+    public String getAuthority() {
+      return authority;
+    }
+
+    @Override
+    public Attributes getTransportAttrs() {
+      return Attributes.EMPTY;
+    }
+  }
+
+  private static class RetryableException extends IOException implements Retryable {
+    private final boolean retryable;
+
+    public RetryableException(boolean retryable) {
+      super("Broken");
+      this.retryable = retryable;
+    }
+
+    @Override public boolean isRetryable() {
+      return retryable;
+    }
+
+    @Override public int getRetryCount() {
+      return 0;
+    }
+  }
 }
diff --git a/authz/build.gradle b/authz/build.gradle
new file mode 100644
index 00000000000..4b02b01aa29
--- /dev/null
+++ b/authz/build.gradle
@@ -0,0 +1,82 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "com.google.protobuf"
+    id "com.gradleup.shadow"
+    id "ru.vyarus.animalsniffer"
+}
+
+description = "gRPC: Authorization"
+
+dependencies {
+    implementation project(':grpc-protobuf'),
+            project(':grpc-core'),
+            libraries.guava.jre // JRE required by transitive protobuf-java-util
+
+    annotationProcessor libraries.auto.value
+
+    testImplementation project(':grpc-testing'),
+            project(':grpc-testing-proto'),
+            testFixtures(project(':grpc-core'))
+    testImplementation libraries.guava.testlib
+
+    def xdsDependency = implementation project(':grpc-xds')
+    shadow configurations.implementation.getDependencies().minus([xdsDependency])
+    shadow project(path: ':grpc-xds', configuration: 'shadow')
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+tasks.named("jar").configure {
+    archiveClassifier = 'original'
+}
+
+tasks.named("shadowJar").configure {
+    archiveClassifier = null
+    dependencies {
+        exclude(dependency {true})
+    }
+    relocate 'io.grpc.xds', 'io.grpc.xds.shaded.io.grpc.xds'
+    relocate 'udpa.annotations', 'io.grpc.xds.shaded.udpa.annotations'
+    relocate 'com.github.udpa', 'io.grpc.xds.shaded.com.github.udpa'
+    relocate 'envoy.annotations', 'io.grpc.xds.shaded.envoy.annotations'
+    relocate 'io.envoyproxy', 'io.grpc.xds.shaded.io.envoyproxy'
+    relocate 'com.google.api.expr', 'io.grpc.xds.shaded.com.google.api.expr'
+}
+
+tasks.named("compileJava").configure {
+    it.options.compilerArgs += [
+        "-Xlint:-processing",
+    ]
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            // We want this to throw an exception if it isn't working
+            def originalJar = artifacts.find { dep -> dep.classifier == 'original'}
+            artifacts.remove(originalJar)
+
+            pom.withXml {
+                def dependenciesNode = new Node(null, 'dependencies')
+                project.configurations.shadow.allDependencies.each { dep ->
+                    def dependencyNode = dependenciesNode.appendNode('dependency')
+                    dependencyNode.appendNode('groupId', dep.group)
+                    dependencyNode.appendNode('artifactId', dep.name)
+                    dependencyNode.appendNode('version', dep.version)
+                    dependencyNode.appendNode('scope', 'compile')
+                }
+                asNode().dependencies[0].replaceNode(dependenciesNode)
+            }
+        }
+    }
+}
+
+tasks.named("publishMavenPublicationToMavenRepository").configure {
+    enabled = false
+}
diff --git a/authz/src/main/java/io/grpc/authz/AuthorizationPolicyTranslator.java b/authz/src/main/java/io/grpc/authz/AuthorizationPolicyTranslator.java
new file mode 100644
index 00000000000..183ae2c3f55
--- /dev/null
+++ b/authz/src/main/java/io/grpc/authz/AuthorizationPolicyTranslator.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright 2021 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.authz;
+
+import com.google.common.collect.ImmutableList;
+import io.envoyproxy.envoy.config.rbac.v3.Permission;
+import io.envoyproxy.envoy.config.rbac.v3.Policy;
+import io.envoyproxy.envoy.config.rbac.v3.Principal;
+import io.envoyproxy.envoy.config.rbac.v3.Principal.Authenticated;
+import io.envoyproxy.envoy.config.rbac.v3.RBAC;
+import io.envoyproxy.envoy.config.rbac.v3.RBAC.Action;
+import io.envoyproxy.envoy.config.route.v3.HeaderMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.PathMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.RegexMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import io.grpc.internal.JsonParser;
+import io.grpc.internal.JsonUtil;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+/**
+ * Translates a gRPC authorization policy in JSON string to Envoy RBAC policies.
+ */
+class AuthorizationPolicyTranslator {
+  private static final ImmutableList<String> UNSUPPORTED_HEADERS = ImmutableList.of(
+      "host", "connection", "keep-alive", "proxy-authenticate", "proxy-authorization",
+      "te", "trailer", "transfer-encoding", "upgrade");
+
+  private static StringMatcher getStringMatcher(String value) {
+    if (value.equals("*")) {
+      return StringMatcher.newBuilder().setSafeRegex(
+        RegexMatcher.newBuilder().setRegex(".+").build()).build();
+    } else if (value.startsWith("*")) {
+      return StringMatcher.newBuilder().setSuffix(value.substring(1)).build();
+    } else if (value.endsWith("*")) {
+      return StringMatcher.newBuilder().setPrefix(value.substring(0, value.length() - 1)).build();
+    }
+    return StringMatcher.newBuilder().setExact(value).build();
+  }
+
+  private static Principal parseSource(Map<String, ?> source) {
+    List<String> principalsList = JsonUtil.getListOfStrings(source, "principals");
+    if (principalsList == null || principalsList.isEmpty()) {
+      return Principal.newBuilder().setAny(true).build();
+    }
+    Principal.Set.Builder principalsSet = Principal.Set.newBuilder();
+    for (String principal: principalsList) {           
+      principalsSet.addIds(
+          Principal.newBuilder().setAuthenticated(
+            Authenticated.newBuilder().setPrincipalName(
+              getStringMatcher(principal)).build()).build());
+    }
+    return Principal.newBuilder().setOrIds(principalsSet.build()).build();
+  }
+
+  private static Permission parseHeader(Map<String, ?> header) throws IllegalArgumentException {
+    String key = JsonUtil.getString(header, "key");
+    if (key == null || key.isEmpty()) {
+      throw new IllegalArgumentException("\"key\" is absent or empty");
+    }
+    if (key.charAt(0) == ':'
+        || key.startsWith("grpc-")
+        || UNSUPPORTED_HEADERS.contains(key.toLowerCase(Locale.ROOT))) {
+      throw new IllegalArgumentException(String.format("Unsupported \"key\" %s", key));
+    }
+    List<String> valuesList = JsonUtil.getListOfStrings(header, "values");
+    if (valuesList == null || valuesList.isEmpty()) {
+      throw new IllegalArgumentException("\"values\" is absent or empty");
+    }
+    Permission.Set.Builder orSet = Permission.Set.newBuilder();
+    for (String value: valuesList) {
+      orSet.addRules(
+          Permission.newBuilder().setHeader(
+            HeaderMatcher.newBuilder()
+            .setName(key)
+            .setStringMatch(getStringMatcher(value)).build()).build());     
+    }
+    return Permission.newBuilder().setOrRules(orSet.build()).build();
+  }
+
+  private static Permission parseRequest(Map<String, ?> request) throws IllegalArgumentException {
+    Permission.Set.Builder andSet = Permission.Set.newBuilder();
+    List<String> pathsList = JsonUtil.getListOfStrings(request, "paths"); 
+    if (pathsList != null && !pathsList.isEmpty()) {
+      Permission.Set.Builder pathsSet = Permission.Set.newBuilder();
+      for (String path: pathsList) {           
+        pathsSet.addRules(
+            Permission.newBuilder().setUrlPath(
+              PathMatcher.newBuilder().setPath(
+                getStringMatcher(path)).build()).build());
+      }
+      andSet.addRules(Permission.newBuilder().setOrRules(pathsSet.build()).build());
+    }
+    List<Map<String, ?>> headersList = JsonUtil.getListOfObjects(request, "headers"); 
+    if (headersList != null && !headersList.isEmpty()) {
+      Permission.Set.Builder headersSet = Permission.Set.newBuilder();
+      for (Map<String, ?> header: headersList) {           
+        headersSet.addRules(parseHeader(header));
+      }
+      andSet.addRules(Permission.newBuilder().setAndRules(headersSet.build()).build());
+    }
+    if (andSet.getRulesCount() == 0) {
+      return Permission.newBuilder().setAny(true).build();
+    }
+    return Permission.newBuilder().setAndRules(andSet.build()).build();
+  }
+
+  private static Map<String, Policy> parseRules(
+      List<Map<String, ?>> objects, String name) throws IllegalArgumentException {
+    Map<String, Policy> policies = new LinkedHashMap<String, Policy>();
+    for (Map<String, ?> object: objects) {
+      String policyName = JsonUtil.getString(object, "name");
+      if (policyName == null || policyName.isEmpty()) {
+        throw new IllegalArgumentException("rule \"name\" is absent or empty");
+      }
+      List<Principal> principals = new ArrayList<>();
+      Map<String, ?> source = JsonUtil.getObject(object, "source");
+      if (source != null) {
+        principals.add(parseSource(source));
+      } else {
+        principals.add(Principal.newBuilder().setAny(true).build());
+      }
+      List<Permission> permissions = new ArrayList<>();
+      Map<String, ?> request = JsonUtil.getObject(object, "request");
+      if (request != null) {
+        permissions.add(parseRequest(request));
+      } else {
+        permissions.add(Permission.newBuilder().setAny(true).build());
+      }
+      Policy policy = 
+          Policy.newBuilder()
+          .addAllPermissions(permissions)
+          .addAllPrincipals(principals)
+          .build();
+      policies.put(name + "_" + policyName, policy);
+    }
+    return policies;
+  }
+
+  /** 
+   * Translates a gRPC authorization policy in JSON string to Envoy RBAC policies.
+   * On success, will return one of the following -
+   * 1. One allow RBAC policy or,
+   * 2. Two RBAC policies, deny policy followed by allow policy.
+   * If the policy cannot be parsed or is invalid, an exception will be thrown.
+   */
+  public static List<RBAC> translate(String authorizationPolicy) 
+            throws IllegalArgumentException, IOException {
+    Object jsonObject = JsonParser.parse(authorizationPolicy);
+    if (!(jsonObject instanceof Map)) {
+      throw new IllegalArgumentException(
+          "Authorization policy should be a JSON object. Found: "
+          + (jsonObject == null ? null : jsonObject.getClass()));
+    }
+    @SuppressWarnings("unchecked")
+    Map<String, ?> json = (Map<String, ?>)jsonObject;
+    String name = JsonUtil.getString(json, "name");
+    if (name == null || name.isEmpty()) {
+      throw new IllegalArgumentException("\"name\" is absent or empty");
+    }
+    List<RBAC> rbacs = new ArrayList<>();
+    List<Map<String, ?>> objects = JsonUtil.getListOfObjects(json, "deny_rules");
+    if (objects != null && !objects.isEmpty()) {
+      rbacs.add(
+          RBAC.newBuilder()
+          .setAction(Action.DENY)
+          .putAllPolicies(parseRules(objects, name))
+          .build());
+    }
+    objects = JsonUtil.getListOfObjects(json, "allow_rules");
+    if (objects == null || objects.isEmpty()) {
+      throw new IllegalArgumentException("\"allow_rules\" is absent");
+    }
+    rbacs.add(
+        RBAC.newBuilder()
+        .setAction(Action.ALLOW)
+        .putAllPolicies(parseRules(objects, name))
+        .build());
+    return rbacs;
+  }
+}
diff --git a/authz/src/main/java/io/grpc/authz/AuthorizationServerInterceptor.java b/authz/src/main/java/io/grpc/authz/AuthorizationServerInterceptor.java
new file mode 100644
index 00000000000..2c01e356f59
--- /dev/null
+++ b/authz/src/main/java/io/grpc/authz/AuthorizationServerInterceptor.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2022 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.authz;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.envoyproxy.envoy.config.rbac.v3.RBAC;
+import io.grpc.ExperimentalApi;
+import io.grpc.InternalServerInterceptors;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.xds.InternalRbacFilter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Authorization server interceptor for static policy. The class will get
+ * <a href="https://github.com/grpc/proposal/blob/master/A43-grpc-authorization-api.md#user-facing-authorization-policy">
+ * gRPC Authorization policy</a> as a JSON string during initialization.
+ * This policy will be translated to Envoy RBAC policies to make
+ * authorization decisions. The policy cannot be changed once created. To
+ * change the policy after creation, see FileWatcherAuthorizationServerInterceptor.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/9746")
+public final class AuthorizationServerInterceptor implements ServerInterceptor {
+  private final List<ServerInterceptor> interceptors = new ArrayList<>();
+
+  private AuthorizationServerInterceptor(String authorizationPolicy) 
+      throws IOException {
+    List<RBAC> rbacs = AuthorizationPolicyTranslator.translate(authorizationPolicy);
+    if (rbacs == null || rbacs.isEmpty() || rbacs.size() > 2) {
+      throw new IllegalArgumentException("Failed to translate authorization policy");
+    }
+    for (RBAC rbac: rbacs) {
+      interceptors.add(
+          InternalRbacFilter.createInterceptor(
+            io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBAC.newBuilder()
+            .setRules(rbac).build()));
+    }
+  }
+
+  @Override
+  public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+      ServerCall<ReqT, RespT> call, Metadata headers, 
+      ServerCallHandler<ReqT, RespT> next) {
+    for (ServerInterceptor interceptor: interceptors) {
+      next = InternalServerInterceptors.interceptCallHandlerCreate(interceptor, next);
+    }
+    return next.startCall(call, headers);
+  }
+
+  // Static method that creates an AuthorizationServerInterceptor.
+  public static AuthorizationServerInterceptor create(String authorizationPolicy) 
+      throws IOException {
+    checkNotNull(authorizationPolicy, "authorizationPolicy");
+    return new AuthorizationServerInterceptor(authorizationPolicy);
+  }
+}
diff --git a/authz/src/main/java/io/grpc/authz/FileWatcherAuthorizationServerInterceptor.java b/authz/src/main/java/io/grpc/authz/FileWatcherAuthorizationServerInterceptor.java
new file mode 100644
index 00000000000..ee7264e72fe
--- /dev/null
+++ b/authz/src/main/java/io/grpc/authz/FileWatcherAuthorizationServerInterceptor.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2022 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.authz;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import io.grpc.ExperimentalApi;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Authorization server interceptor for policy from file with refresh capability.
+ * The class will get <a href="https://github.com/grpc/proposal/blob/master/A43-grpc-authorization-api.md#user-facing-authorization-policy">
+ * gRPC Authorization policy</a> from a JSON file during initialization.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/9746")
+public final class FileWatcherAuthorizationServerInterceptor implements ServerInterceptor {
+  private static final Logger logger = 
+      Logger.getLogger(FileWatcherAuthorizationServerInterceptor.class.getName());
+
+  private volatile AuthorizationServerInterceptor internalAuthzServerInterceptor;
+
+  private final File policyFile;
+  private String policyContents;
+
+  private FileWatcherAuthorizationServerInterceptor(File policyFile) throws IOException {
+    this.policyFile = policyFile;
+    updateInternalInterceptor();
+  }
+
+  @Override
+  public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+      ServerCall<ReqT, RespT> call, Metadata headers,
+      ServerCallHandler<ReqT, RespT> next) {
+    return internalAuthzServerInterceptor.interceptCall(call, headers, next);
+  }
+
+  void updateInternalInterceptor() throws IOException {
+    String currentPolicyContents = new String(Files.readAllBytes(policyFile.toPath()), UTF_8);
+    if (currentPolicyContents.equals(policyContents)) {
+      return;
+    }
+    policyContents = currentPolicyContents;
+    internalAuthzServerInterceptor = AuthorizationServerInterceptor.create(policyContents);
+  }
+
+  /** 
+   * Policy is reloaded periodically as per the provided refresh interval. Unlike the
+   * constructor, exception thrown during reload will be caught and logged and the
+   * previous AuthorizationServerInterceptor will be used to make authorization
+   * decisions.
+   * 
+   * @param period the period between successive file load executions.
+   * @param unit the time unit for period parameter
+   * @param executor the execute service we use to read and update authorization policy
+   * @return an object that caller should close when the file refreshes are not needed
+   */
+  public Closeable scheduleRefreshes(
+      long period, TimeUnit unit, ScheduledExecutorService executor) throws IOException {
+    checkNotNull(executor, "scheduledExecutorService");
+    if (period <= 0) {
+      throw new IllegalArgumentException("Refresh interval must be greater than 0");
+    }
+    final ScheduledFuture<?> future = 
+        executor.scheduleWithFixedDelay(new Runnable() {
+          @Override
+          public void run() {
+            try {
+              updateInternalInterceptor();
+            } catch (Exception e) {
+              logger.log(Level.WARNING, "Authorization Policy file reload failed", e);
+            }
+          }
+        }, period, period, unit);
+    return new Closeable() {
+      @Override public void close() {
+        future.cancel(false);
+      }
+    };
+  }
+
+  public static FileWatcherAuthorizationServerInterceptor create(File policyFile) 
+      throws IOException {
+    checkNotNull(policyFile, "policyFile");
+    return new FileWatcherAuthorizationServerInterceptor(policyFile);
+  }
+}
diff --git a/authz/src/test/java/io/grpc/authz/AuthorizationEnd2EndTest.java b/authz/src/test/java/io/grpc/authz/AuthorizationEnd2EndTest.java
new file mode 100644
index 00000000000..0b80fad9879
--- /dev/null
+++ b/authz/src/test/java/io/grpc/authz/AuthorizationEnd2EndTest.java
@@ -0,0 +1,791 @@
+/*
+ * Copyright 2022 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.authz;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.ServerCredentials;
+import io.grpc.ServerInterceptor;
+import io.grpc.StatusRuntimeException;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.TlsServerCredentials;
+import io.grpc.TlsServerCredentials.ClientAuth;
+import io.grpc.internal.FakeClock;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.TlsTesting;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import java.io.Closeable;
+import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class AuthorizationEnd2EndTest {
+  public static final String SERVER_0_KEY_FILE = "server0.key";
+  public static final String SERVER_0_PEM_FILE = "server0.pem";
+  public static final String CLIENT_0_KEY_FILE = "client.key";
+  public static final String CLIENT_0_PEM_FILE = "client.pem";
+  public static final String CA_PEM_FILE = "ca.pem";
+
+  private Server server;
+  private ManagedChannel channel;
+
+  private FakeClock fakeClock = new FakeClock();
+  private File policyFile;
+
+  private AuthorizationServerInterceptor createStaticAuthorizationInterceptor(
+      String authorizationPolicy) throws Exception {
+    AuthorizationServerInterceptor interceptor =
+        AuthorizationServerInterceptor.create(authorizationPolicy);
+    assertNotNull(interceptor);
+    return interceptor;
+  }
+
+  private FileWatcherAuthorizationServerInterceptor 
+      createFileWatcherAuthorizationInterceptor(File policyFile) throws Exception {
+    FileWatcherAuthorizationServerInterceptor interceptor =
+        FileWatcherAuthorizationServerInterceptor.create(policyFile);
+    assertNotNull(interceptor);
+    return interceptor;
+  }
+
+  private void initServerWithAuthzInterceptor(
+      ServerInterceptor authzInterceptor, ServerCredentials serverCredentials) throws Exception {
+    server = Grpc.newServerBuilderForPort(0, serverCredentials)
+                .addService(new SimpleServiceImpl())
+                .intercept(authzInterceptor)
+                .build()
+                .start();
+  }
+
+  private void createTempAuthorizationPolicy(String authorizationPolicy) throws Exception {
+    policyFile = File.createTempFile("temp", "json");
+    Files.write(Paths.get(policyFile.getAbsolutePath()), authorizationPolicy.getBytes(UTF_8));
+  }
+
+  private void rewriteAuthorizationPolicy(String newPolicy) throws Exception {
+    assertNotNull(policyFile);
+    Files.write(Paths.get(policyFile.getAbsolutePath()), newPolicy.getBytes(UTF_8));
+  }
+
+  private SimpleServiceGrpc.SimpleServiceBlockingStub getStub() {
+    if (channel == null) {
+      channel = Grpc.newChannelBuilderForAddress(
+        "localhost", server.getPort(), InsecureChannelCredentials.create())
+        .build();
+    }
+    return SimpleServiceGrpc.newBlockingStub(channel);
+  }
+
+  private SimpleServiceGrpc.SimpleServiceBlockingStub getStub(
+      ChannelCredentials channelCredentials) {
+    channel = Grpc.newChannelBuilderForAddress(
+        "localhost", server.getPort(), channelCredentials)
+            .overrideAuthority("foo.test.google.com.au")
+            .build();
+    return SimpleServiceGrpc.newBlockingStub(channel);
+  }
+
+  @After
+  public void tearDown() {
+    if (policyFile != null) {
+      policyFile.delete();
+    }
+    if (server != null) {
+      server.shutdown();
+    }
+    if (channel != null) {
+      channel.shutdown();
+    }
+  }
+
+  @Test
+  public void staticAuthzAllowsRpcNoMatchInDenyMatchInAllowTest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"deny_rules\": ["
+        + "   {"
+        + "     \"name\": \"deny_UnaryRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/UnaryRpc\""
+        + "       ],"
+        + "       \"headers\": ["
+        + "         {"
+        + "           \"key\": \"dev-path\","
+        + "           \"values\": [\"/dev/path/*\"]"
+        + "         }"
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ],"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_all\""
+        + "   }"
+        + " ]"
+        + "}";
+    AuthorizationServerInterceptor interceptor = createStaticAuthorizationInterceptor(policy);
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+
+  @Test
+  public void staticAuthzDeniesRpcNoMatchInDenyAndAllowTest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"deny_rules\": ["
+        + "   {"
+        + "     \"name\": \"deny_foo\","
+        + "     \"source\": {"
+        + "       \"principals\": ["
+        + "         \"foo\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ],"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_ClientStreamingRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/ClientStreamingRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    AuthorizationServerInterceptor interceptor = createStaticAuthorizationInterceptor(policy);
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+          "PERMISSION_DENIED: Access Denied");
+    }
+  }
+
+  @Test
+  public void staticAuthzDeniesRpcMatchInDenyAndAllowTest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"deny_rules\": ["
+        + "   {"
+        + "     \"name\": \"deny_UnaryRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/UnaryRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ],"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_UnaryRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/UnaryRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    AuthorizationServerInterceptor interceptor = createStaticAuthorizationInterceptor(policy);
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+          "PERMISSION_DENIED: Access Denied");
+    }
+  }
+
+  @Test
+  public void staticAuthzDeniesRpcMatchInDenyNoMatchInAllowTest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"deny_rules\": ["
+        + "   {"
+        + "     \"name\": \"deny_UnaryRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/UnaryRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ],"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_ClientStreamingRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/ClientStreamingRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    AuthorizationServerInterceptor interceptor = createStaticAuthorizationInterceptor(policy);
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+          "PERMISSION_DENIED: Access Denied");
+    }
+  }
+
+  @Test
+  public void staticAuthzAllowsRpcEmptyDenyMatchInAllowTest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_UnaryRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/UnaryRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    AuthorizationServerInterceptor interceptor = createStaticAuthorizationInterceptor(policy);
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+
+  @Test
+  public void staticAuthzDeniesRpcEmptyDenyNoMatchInAllowTest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_ClientStreamingRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/ClientStreamingRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    AuthorizationServerInterceptor interceptor = createStaticAuthorizationInterceptor(policy);
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+          "PERMISSION_DENIED: Access Denied");
+    }
+  }
+
+  @Test
+  public void staticAuthzDeniesRpcWithPrincipalsFieldOnUnauthenticatedConnectionTest() 
+        throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_authenticated\","
+        + "     \"source\": {"
+        + "       \"principals\": [\"*\", \"\"]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    AuthorizationServerInterceptor interceptor = createStaticAuthorizationInterceptor(policy);
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+          "PERMISSION_DENIED: Access Denied");
+    }
+  }
+
+  @Test
+  public void staticAuthzAllowsRpcWithPrincipalsFieldOnMtlsAuthenticatedConnectionTest() 
+        throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_mtls\","
+        + "     \"source\": {"
+        + "       \"principals\": [\"*\"]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    AuthorizationServerInterceptor interceptor = createStaticAuthorizationInterceptor(policy);
+    ServerCredentials serverCredentials = TlsServerCredentials.newBuilder()
+        .keyManager(TlsTesting.loadCert(SERVER_0_PEM_FILE), TlsTesting.loadCert(SERVER_0_KEY_FILE))
+        .trustManager(TlsTesting.loadCert(CA_PEM_FILE))
+        .clientAuth(ClientAuth.REQUIRE)
+        .build();
+    initServerWithAuthzInterceptor(interceptor, serverCredentials);
+    ChannelCredentials channelCredentials = TlsChannelCredentials.newBuilder()
+        .keyManager(TlsTesting.loadCert(CLIENT_0_PEM_FILE), TlsTesting.loadCert(CLIENT_0_KEY_FILE))
+        .trustManager(TlsTesting.loadCert(CA_PEM_FILE))
+        .build();
+    getStub(channelCredentials).unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+
+  @Test
+  public void staticAuthzAllowsRpcWithPrincipalsFieldOnTlsAuthenticatedConnectionTest() 
+        throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_tls\","
+        + "     \"source\": {"
+        + "       \"principals\": [\"\"]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    AuthorizationServerInterceptor interceptor = createStaticAuthorizationInterceptor(policy);
+    ServerCredentials serverCredentials = TlsServerCredentials.newBuilder()
+        .keyManager(TlsTesting.loadCert(SERVER_0_PEM_FILE), TlsTesting.loadCert(SERVER_0_KEY_FILE))
+        .trustManager(TlsTesting.loadCert(CA_PEM_FILE))
+        .clientAuth(ClientAuth.OPTIONAL)
+        .build();
+    initServerWithAuthzInterceptor(interceptor, serverCredentials);
+    ChannelCredentials channelCredentials = TlsChannelCredentials.newBuilder()
+        .trustManager(TlsTesting.loadCert(CA_PEM_FILE))
+        .build();
+    getStub(channelCredentials).unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+
+  @Test
+  public void fileWatcherAuthzAllowsRpcNoMatchInDenyMatchInAllowTest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"deny_rules\": ["
+        + "   {"
+        + "     \"name\": \"deny_UnaryRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/UnaryRpc\""
+        + "       ],"
+        + "       \"headers\": ["
+        + "         {"
+        + "           \"key\": \"dev-path\","
+        + "           \"values\": [\"/dev/path/*\"]"
+        + "         }"
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ],"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_all\""
+        + "   }"
+        + " ]"
+        + "}";
+    createTempAuthorizationPolicy(policy);
+    FileWatcherAuthorizationServerInterceptor interceptor = 
+        createFileWatcherAuthorizationInterceptor(policyFile);
+    Closeable closeable = interceptor.scheduleRefreshes(
+        100, TimeUnit.MILLISECONDS, fakeClock.getScheduledExecutorService());
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    closeable.close();
+    getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+
+  @Test
+  public void fileWatcherAuthzDeniesRpcNoMatchInDenyAndAllowTest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"deny_rules\": ["
+        + "   {"
+        + "     \"name\": \"deny_foo\","
+        + "     \"source\": {"
+        + "       \"principals\": ["
+        + "         \"foo\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ],"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_ClientStreamingRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/ClientStreamingRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    createTempAuthorizationPolicy(policy);
+    FileWatcherAuthorizationServerInterceptor interceptor = 
+        createFileWatcherAuthorizationInterceptor(policyFile);
+    Closeable closeable = interceptor.scheduleRefreshes(
+        100, TimeUnit.MILLISECONDS, fakeClock.getScheduledExecutorService());
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    closeable.close();
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+          "PERMISSION_DENIED: Access Denied");
+    }
+  }
+
+  @Test
+  public void fileWatcherAuthzDeniesRpcMatchInDenyAndAllowTest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"deny_rules\": ["
+        + "   {"
+        + "     \"name\": \"deny_UnaryRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/UnaryRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ],"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_UnaryRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/UnaryRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    createTempAuthorizationPolicy(policy);
+    FileWatcherAuthorizationServerInterceptor interceptor = 
+        createFileWatcherAuthorizationInterceptor(policyFile);
+    Closeable closeable = interceptor.scheduleRefreshes(
+        100, TimeUnit.MILLISECONDS, fakeClock.getScheduledExecutorService());
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    closeable.close();
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+          "PERMISSION_DENIED: Access Denied");
+    }
+  }
+
+  @Test
+  public void fileWatcherAuthzDeniesRpcMatchInDenyNoMatchInAllowTest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"deny_rules\": ["
+        + "   {"
+        + "     \"name\": \"deny_UnaryRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/UnaryRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ],"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_ClientStreamingRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/ClientStreamingRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    createTempAuthorizationPolicy(policy);
+    FileWatcherAuthorizationServerInterceptor interceptor = 
+        createFileWatcherAuthorizationInterceptor(policyFile);
+    Closeable closeable = interceptor.scheduleRefreshes(
+        100, TimeUnit.MILLISECONDS, fakeClock.getScheduledExecutorService());
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    closeable.close();
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+          "PERMISSION_DENIED: Access Denied");
+    }
+  }
+
+  @Test
+  public void fileWatcherAuthzAllowsRpcEmptyDenyMatchInAllowTest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_UnaryRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/UnaryRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    createTempAuthorizationPolicy(policy);
+    FileWatcherAuthorizationServerInterceptor interceptor = 
+        createFileWatcherAuthorizationInterceptor(policyFile);
+    Closeable closeable = interceptor.scheduleRefreshes(
+        100, TimeUnit.MILLISECONDS, fakeClock.getScheduledExecutorService());
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    closeable.close();
+    getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+
+  @Test
+  public void fileWatcherAuthzDeniesRpcEmptyDenyNoMatchInAllowTest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_ClientStreamingRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/ClientStreamingRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    createTempAuthorizationPolicy(policy);
+    FileWatcherAuthorizationServerInterceptor interceptor = 
+        createFileWatcherAuthorizationInterceptor(policyFile);
+    Closeable closeable = interceptor.scheduleRefreshes(
+        100, TimeUnit.MILLISECONDS, fakeClock.getScheduledExecutorService());
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    closeable.close();
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+          "PERMISSION_DENIED: Access Denied");
+    }
+  }
+
+  @Test
+  public void fileWatcherAuthzValidPolicyRefreshTest() throws Exception {
+    String policy1 = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"deny_rules\": ["
+        + "   {"
+        + "     \"name\": \"deny_UnaryRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/UnaryRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ],"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_all\""
+        + "   }"
+        + " ]"
+        + "}";
+    createTempAuthorizationPolicy(policy1);
+    FileWatcherAuthorizationServerInterceptor interceptor = 
+        createFileWatcherAuthorizationInterceptor(policyFile);
+    Closeable closeable = interceptor.scheduleRefreshes(
+        100, TimeUnit.NANOSECONDS, fakeClock.getScheduledExecutorService());
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    String policy2 = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_UnaryRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/UnaryRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    rewriteAuthorizationPolicy(policy2);
+    // Reload is yet to take place at 100ns. policy1 will be active here.
+    assertEquals(0, fakeClock.forwardNanos(99));
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+          "PERMISSION_DENIED: Access Denied");
+    }
+    // Reload will take place making policy2 the active policy.
+    assertEquals(1, fakeClock.forwardNanos(2));
+    closeable.close();
+    getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+
+  @Test
+  public void fileWatcherAuthzInvalidPolicySkipRefreshTest() throws Exception {
+    String validPolicy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_ClientStreamingRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/ClientStreamingRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    createTempAuthorizationPolicy(validPolicy);
+    FileWatcherAuthorizationServerInterceptor interceptor = 
+        createFileWatcherAuthorizationInterceptor(policyFile);
+    Closeable closeable = interceptor.scheduleRefreshes(
+        100, TimeUnit.NANOSECONDS, fakeClock.getScheduledExecutorService());
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    String invalidPolicy = "{}";
+    rewriteAuthorizationPolicy(invalidPolicy);
+    // Reload is yet to take place at 100ns. validPolicy will be active here.
+    assertEquals(0, fakeClock.forwardNanos(99));
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+          "PERMISSION_DENIED: Access Denied");
+    }
+    // Reload will take place which skips the invalidPolicy. validPolicy remains
+    // the active policy.
+    assertEquals(1, fakeClock.forwardNanos(2));
+    closeable.close();
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+          "PERMISSION_DENIED: Access Denied");
+    }
+  }
+
+  @Test
+  public void fileWatcherAuthzRecoversFromReloadTest() throws Exception {
+    String validPolicy1 = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_ClientStreamingRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/ClientStreamingRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    createTempAuthorizationPolicy(validPolicy1);
+    FileWatcherAuthorizationServerInterceptor interceptor = 
+        createFileWatcherAuthorizationInterceptor(policyFile);
+    Closeable closeable = interceptor.scheduleRefreshes(
+        100, TimeUnit.NANOSECONDS, fakeClock.getScheduledExecutorService());
+    initServerWithAuthzInterceptor(interceptor, InsecureServerCredentials.create());
+    String invalidPolicy = "{}";
+    rewriteAuthorizationPolicy(invalidPolicy);
+    // Reload is yet to take place at 100ns. validPolicy1 will be active here.
+    assertEquals(0, fakeClock.forwardNanos(99));
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+            "PERMISSION_DENIED: Access Denied");
+    }
+    // Reload will take place which skips the invalidPolicy. validPolicy1 remains
+    // the active policy.
+    assertEquals(1, fakeClock.forwardNanos(2));
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+            "PERMISSION_DENIED: Access Denied");
+    }
+    String validPolicy2 = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_UnaryRpc\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*/UnaryRpc\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    rewriteAuthorizationPolicy(validPolicy2);
+    // Next reload is yet to take place. validPolicy1 remains the active policy.
+    assertEquals(0, fakeClock.forwardNanos(98));
+    try {
+      getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasMessageThat().isEqualTo(
+            "PERMISSION_DENIED: Access Denied");
+    }
+    // Reload occurs making validPolicy2 the active policy.
+    assertEquals(1, fakeClock.forwardNanos(2));
+    closeable.close();
+    getStub().unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+
+  private static class SimpleServiceImpl extends SimpleServiceGrpc.SimpleServiceImplBase {
+    @Override
+    public void unaryRpc(SimpleRequest req, StreamObserver<SimpleResponse> respOb) {
+      respOb.onNext(SimpleResponse.getDefaultInstance());
+      respOb.onCompleted();
+    }
+  }
+}
diff --git a/authz/src/test/java/io/grpc/authz/AuthorizationPolicyTranslatorTest.java b/authz/src/test/java/io/grpc/authz/AuthorizationPolicyTranslatorTest.java
new file mode 100644
index 00000000000..17e6d4fe98b
--- /dev/null
+++ b/authz/src/test/java/io/grpc/authz/AuthorizationPolicyTranslatorTest.java
@@ -0,0 +1,549 @@
+/*
+ * Copyright 2021 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.authz;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import io.envoyproxy.envoy.config.rbac.v3.Permission;
+import io.envoyproxy.envoy.config.rbac.v3.Policy;
+import io.envoyproxy.envoy.config.rbac.v3.Principal;
+import io.envoyproxy.envoy.config.rbac.v3.Principal.Authenticated;
+import io.envoyproxy.envoy.config.rbac.v3.RBAC;
+import io.envoyproxy.envoy.config.rbac.v3.RBAC.Action;
+import io.envoyproxy.envoy.config.route.v3.HeaderMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.PathMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.RegexMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import java.io.IOException;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class AuthorizationPolicyTranslatorTest {
+  @Test
+  public void invalidPolicy() throws Exception {
+    String policy = "{ \"name\": \"abc\",, }";
+    try {
+      AuthorizationPolicyTranslator.translate(policy);
+      fail("exception expected");
+    } catch (IOException ioe) {
+      assertThat(ioe).hasMessageThat().contains("malformed JSON");
+      assertThat(ioe).hasMessageThat().contains("at line 1 column 18 path $.name");
+    }
+  }
+
+  @Test
+  public void missingAuthorizationPolicyName() throws Exception {
+    String policy = "{}";
+    try {
+      AuthorizationPolicyTranslator.translate(policy);
+      fail("exception expected");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae).hasMessageThat().isEqualTo("\"name\" is absent or empty");
+    }
+  }
+
+  @Test
+  public void incorrectAuthorizationPolicyName() throws Exception {
+    String policy = "{ \"name\": [\"abc\"] }";
+    try {
+      AuthorizationPolicyTranslator.translate(policy);
+      fail("exception expected");
+    } catch (ClassCastException cce) {
+      assertThat(cce).hasMessageThat().isEqualTo(
+          "value '[abc]' for key 'name' in '{name=[abc]}' is not String");
+    }
+  }
+
+  @Test
+  public void missingAllowRules() throws Exception {
+    String policy = "{ \"name\": \"authz\" }";
+    try {
+      AuthorizationPolicyTranslator.translate(policy);
+      fail("exception expected");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae).hasMessageThat().isEqualTo("\"allow_rules\" is absent");
+    }
+  }
+
+  @Test
+  public void missingRuleName() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"abc\" ,"
+        + " \"allow_rules\" : ["
+        + "   {}"
+        + " ]"
+        + "}";
+    try {
+      AuthorizationPolicyTranslator.translate(policy);
+      fail("exception expected");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae).hasMessageThat().isEqualTo("rule \"name\" is absent or empty");
+    }
+  }
+
+  @Test
+  public void missingSourceAndRequest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\" : ["
+        + "   {"
+        + "     \"name\": \"allow_all\""
+        + "   }"
+        + " ]"
+        + "}";
+    List<RBAC> rbacs = AuthorizationPolicyTranslator.translate(policy);
+    assertEquals(1, rbacs.size());
+    RBAC expected_rbac = 
+        RBAC.newBuilder()
+        .setAction(Action.ALLOW)
+        .putPolicies("authz_allow_all", 
+            Policy.newBuilder()
+            .addPrincipals(Principal.newBuilder().setAny(true))
+            .addPermissions(Permission.newBuilder().setAny(true))
+            .build())
+        .build();
+    assertEquals(expected_rbac, rbacs.get(0));
+  }
+
+  @Test
+  public void emptySourceAndRequest() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\" : ["
+        + "   {"
+        + "     \"name\": \"allow_all\","
+        + "     \"source\": {},"
+        + "     \"request\": {}"
+        + "   }"
+        + " ]"
+        + "}";
+    List<RBAC> rbacs = AuthorizationPolicyTranslator.translate(policy);
+    assertEquals(1, rbacs.size());
+    RBAC expected_rbac = 
+        RBAC.newBuilder()
+        .setAction(Action.ALLOW)
+        .putPolicies("authz_allow_all", 
+            Policy.newBuilder()
+            .addPrincipals(Principal.newBuilder().setAny(true))
+            .addPermissions(Permission.newBuilder().setAny(true))
+            .build())
+        .build();
+    assertEquals(expected_rbac, rbacs.get(0));
+  }
+
+  @Test
+  public void incorrectRulesType() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"abc\" ,"
+        + " \"allow_rules\" : {}"
+        + "}";
+    try {
+      AuthorizationPolicyTranslator.translate(policy);
+      fail("exception expected");
+    } catch (ClassCastException cce) {
+      assertThat(cce).hasMessageThat().isEqualTo(
+          "value '{}' for key 'allow_rules' in '{name=abc, allow_rules={}}' is not List");
+    }
+  }
+
+  @Test
+  public void parseSourceSuccess() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"deny_rules\": ["
+        + "   {"
+        + "     \"name\": \"deny_users\","
+        + "     \"source\": {"
+        + "       \"principals\": ["
+        + "         \"spiffe://foo.com\","
+        + "         \"spiffe://bar*\","
+        + "         \"*baz\","
+        + "         \"spiffe://*.com\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ],"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_any\","
+        + "     \"source\": {"
+        + "       \"principals\": ["
+        + "         \"*\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    List<RBAC> rbacs = AuthorizationPolicyTranslator.translate(policy);
+    assertEquals(2, rbacs.size());
+    RBAC expected_deny_rbac = 
+        RBAC.newBuilder()
+        .setAction(Action.DENY)
+        .putPolicies("authz_deny_users", 
+            Policy.newBuilder()
+            .addPrincipals(Principal.newBuilder()
+                .setOrIds(
+                    Principal.Set.newBuilder()
+                    .addIds(Principal.newBuilder()
+                        .setAuthenticated(Authenticated.newBuilder()
+                            .setPrincipalName(StringMatcher.newBuilder()
+                                .setExact("spiffe://foo.com").build()).build()).build())
+                    .addIds(Principal.newBuilder()
+                        .setAuthenticated(Authenticated.newBuilder()
+                            .setPrincipalName(StringMatcher.newBuilder()
+                                .setPrefix("spiffe://bar").build()).build()).build())
+                    .addIds(Principal.newBuilder()
+                        .setAuthenticated(Authenticated.newBuilder()
+                            .setPrincipalName(StringMatcher.newBuilder()
+                                .setSuffix("baz").build()).build()).build())
+                    .addIds(Principal.newBuilder()
+                        .setAuthenticated(Authenticated.newBuilder()
+                            .setPrincipalName(StringMatcher.newBuilder()
+                                .setExact("spiffe://*.com").build()).build()).build())
+                    .build()).build())
+            .addPermissions(Permission.newBuilder().setAny(true))
+            .build()).build();
+    RBAC expected_allow_rbac = 
+        RBAC.newBuilder()
+        .setAction(Action.ALLOW)
+        .putPolicies("authz_allow_any", 
+            Policy.newBuilder()
+            .addPrincipals(Principal.newBuilder()
+                .setOrIds(
+                    Principal.Set.newBuilder()
+                    .addIds(Principal.newBuilder()
+                        .setAuthenticated(Authenticated.newBuilder()
+                            .setPrincipalName(StringMatcher.newBuilder()
+                                .setSafeRegex(RegexMatcher.newBuilder()
+                                    .setRegex(".+").build()).build()).build())
+                        .build())
+                    .build()).build())
+            .addPermissions(Permission.newBuilder().setAny(true))
+            .build()).build();
+    assertEquals(expected_deny_rbac, rbacs.get(0));
+    assertEquals(expected_allow_rbac, rbacs.get(1));
+  }
+
+  @Test
+  public void unsupportedPseudoHeaders() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_access\","
+        + "     \"request\": {"
+        + "       \"headers\": ["
+        + "         {"
+        + "           \"key\": \":method\","
+        + "           \"values\": ["
+        + "             \"foo\""
+        + "           ]"
+        + "         }"
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    try {
+      AuthorizationPolicyTranslator.translate(policy);
+      fail("exception expected");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae).hasMessageThat().isEqualTo("Unsupported \"key\" :method");
+    }
+  }
+
+  @Test
+  public void unsupportedGrpcPrefixHeaders() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_access\","
+        + "     \"request\": {"
+        + "       \"headers\": ["
+        + "         {"
+        + "           \"key\": \"grpc-xxx\","
+        + "           \"values\": ["
+        + "             \"foo\""
+        + "           ]"
+        + "         }"
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    try {
+      AuthorizationPolicyTranslator.translate(policy);
+      fail("exception expected");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae).hasMessageThat().isEqualTo("Unsupported \"key\" grpc-xxx");
+    }
+  }
+
+  @Test
+  public void unsupportedHostHeaders() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_access\","
+        + "     \"request\": {"
+        + "       \"headers\": ["
+        + "         {"
+        + "           \"key\": \"Host\","
+        + "           \"values\": ["
+        + "             \"foo\""
+        + "           ]"
+        + "         }"
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    try {
+      AuthorizationPolicyTranslator.translate(policy);
+      fail("exception expected");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae).hasMessageThat().isEqualTo("Unsupported \"key\" Host");
+    }
+  }
+
+  @Test
+  public void missingHeaderKey() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_dev\","
+        + "     \"request\": {"
+        + "       \"headers\": ["
+        + "         {}"
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    try {
+      AuthorizationPolicyTranslator.translate(policy);
+      fail("exception expected");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae).hasMessageThat().isEqualTo("\"key\" is absent or empty");
+    }
+  }
+
+  @Test
+  public void missingHeaderValues() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_dev\","
+        + "     \"request\": {"
+        + "       \"headers\": ["
+        + "         {"
+        + "           \"key\": \"dev-path\""
+        + "         }"
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    try {
+      AuthorizationPolicyTranslator.translate(policy);
+      fail("exception expected");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae).hasMessageThat().isEqualTo("\"values\" is absent or empty");
+    }
+  }
+
+  @Test
+  public void emptyHeaderValues() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_dev\","
+        + "     \"request\": {"
+        + "       \"headers\": ["
+        + "         {"
+        + "           \"key\": \"dev-path\","
+        + "           \"values\": []"
+        + "         }"
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    try {
+      AuthorizationPolicyTranslator.translate(policy);
+      fail("exception expected");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae).hasMessageThat().isEqualTo("\"values\" is absent or empty");
+    }
+  }
+
+  @Test
+  public void parseRequestSuccess() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\" ,"
+        + " \"deny_rules\": ["
+        + "   {"
+        + "     \"name\": \"deny_access\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"/pkg.service/foo\","
+        + "         \"/pkg.service/bar*\""
+        + "       ],"
+        + "       \"headers\": ["
+        + "         {"
+        + "           \"key\": \"dev-path\","
+        + "           \"values\": [\"/dev/path/*\"]"
+        + "         }"
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ],"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_access1\","
+        + "     \"request\": {"
+        + "       \"headers\": ["
+        + "         {"
+        + "           \"key\": \"key-1\","
+        + "           \"values\": ["
+        + "             \"foo\","
+        + "             \"*bar\""
+        + "           ]"
+        + "         },"
+        + "         {"
+        + "           \"key\": \"key-2\","
+        + "           \"values\": ["
+        + "             \"*\""
+        + "           ]"
+        + "         }"
+        + "       ]"
+        + "     }"
+        + "   },"
+        + "   {"
+        + "     \"name\": \"allow_access2\","
+        + "     \"request\": {"
+        + "       \"paths\": ["
+        + "         \"*baz\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ]"
+        + "}";
+    List<RBAC> rbacs = AuthorizationPolicyTranslator.translate(policy);
+    assertEquals(2, rbacs.size());
+    RBAC expected_deny_rbac = 
+        RBAC.newBuilder()
+        .setAction(Action.DENY)
+        .putPolicies("authz_deny_access", 
+            Policy.newBuilder()
+            .addPermissions(Permission.newBuilder()
+                .setAndRules(Permission.Set.newBuilder()
+                    .addRules(Permission.newBuilder()
+                        .setOrRules(Permission.Set.newBuilder()
+                            .addRules(Permission.newBuilder()
+                                .setUrlPath(PathMatcher.newBuilder()
+                                    .setPath(StringMatcher.newBuilder()
+                                        .setExact("/pkg.service/foo").build()).build()).build())
+                            .addRules(Permission.newBuilder()
+                                .setUrlPath(PathMatcher.newBuilder()
+                                    .setPath(StringMatcher.newBuilder()
+                                        .setPrefix("/pkg.service/bar").build()).build()).build())
+                            .build()).build())
+                    .addRules(Permission.newBuilder()
+                        .setAndRules(Permission.Set.newBuilder()
+                            .addRules(Permission.newBuilder()
+                                .setOrRules(Permission.Set.newBuilder()
+                                    .addRules(Permission.newBuilder()
+                                        .setHeader(HeaderMatcher.newBuilder()
+                                            .setName("dev-path")
+                                            .setStringMatch(StringMatcher.newBuilder()
+                                                .setPrefix("/dev/path/").build())
+                                            .build())
+                                        .build())
+                                    .build()).build())
+                            .build()).build())
+                    .build()))
+            .addPrincipals(Principal.newBuilder().setAny(true))
+            .build()).build();
+    RBAC expected_allow_rbac = 
+        RBAC.newBuilder()
+        .setAction(Action.ALLOW)
+        .putPolicies("authz_allow_access1",
+            Policy.newBuilder()
+            .addPermissions(Permission.newBuilder()
+                .setAndRules(Permission.Set.newBuilder()
+                    .addRules(Permission.newBuilder()
+                        .setAndRules(Permission.Set.newBuilder()
+                            .addRules(Permission.newBuilder()
+                                .setOrRules(Permission.Set.newBuilder()
+                                    .addRules(Permission.newBuilder()
+                                        .setHeader(HeaderMatcher.newBuilder()
+                                            .setName("key-1")
+                                            .setStringMatch(StringMatcher.newBuilder()
+                                                .setExact("foo").build())
+                                            .build())
+                                        .build())
+                                    .addRules(Permission.newBuilder()
+                                        .setHeader(HeaderMatcher.newBuilder()
+                                            .setName("key-1")
+                                            .setStringMatch(StringMatcher.newBuilder()
+                                                .setSuffix("bar").build())
+                                            .build())
+                                        .build())
+                                    .build()).build())
+                            .addRules(Permission.newBuilder()
+                                .setOrRules(Permission.Set.newBuilder()
+                                    .addRules(Permission.newBuilder()
+                                        .setHeader(HeaderMatcher.newBuilder()
+                                            .setName("key-2")
+                                            .setStringMatch(StringMatcher.newBuilder()
+                                                .setSafeRegex(RegexMatcher.newBuilder()
+                                                    .setRegex(".+").build()).build())
+                                            .build())
+                                        .build())
+                                    .build()).build()).build()).build()).build()))
+            .addPrincipals(Principal.newBuilder().setAny(true))
+            .build())
+        .putPolicies("authz_allow_access2",
+            Policy.newBuilder()
+            .addPermissions(Permission.newBuilder()
+                .setAndRules(Permission.Set.newBuilder()
+                    .addRules(Permission.newBuilder()
+                        .setOrRules(Permission.Set.newBuilder()
+                            .addRules(Permission.newBuilder()
+                                .setUrlPath(PathMatcher.newBuilder()
+                                    .setPath(StringMatcher.newBuilder()
+                                        .setSuffix("baz").build()).build()).build())
+                            .build()).build())
+                    .build()))
+            .addPrincipals(Principal.newBuilder().setAny(true))
+            .build())
+        .build();
+    assertEquals(expected_deny_rbac, rbacs.get(0));
+    assertEquals(expected_allow_rbac, rbacs.get(1));
+  }
+}
diff --git a/authz/src/test/java/io/grpc/authz/AuthorizationServerInterceptorTest.java b/authz/src/test/java/io/grpc/authz/AuthorizationServerInterceptorTest.java
new file mode 100644
index 00000000000..65c08ef247f
--- /dev/null
+++ b/authz/src/test/java/io/grpc/authz/AuthorizationServerInterceptorTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2022 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.authz;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+
+@RunWith(JUnit4.class)
+public class AuthorizationServerInterceptorTest {
+  @Test
+  public void invalidPolicyFailsStaticAuthzInterceptorCreation() throws Exception {
+    String policy = "{ \"name\": \"abc\",, }";
+    try {
+      AuthorizationServerInterceptor.create(policy);
+      fail("exception expected");
+    } catch (IOException ioe) {
+      assertThat(ioe).hasMessageThat().contains("malformed JSON");
+      assertThat(ioe).hasMessageThat().contains("at line 1 column 18 path $.name");
+    }
+  }
+
+  @Test
+  public void validPolicyCreatesStaticAuthzInterceptor() throws Exception {
+    String policy = "{"
+        + " \"name\" : \"authz\","
+        + " \"deny_rules\": ["
+        + "   {"
+        + "     \"name\": \"deny_foo\","
+        + "     \"source\": {"
+        + "       \"principals\": ["
+        + "         \"spiffe://foo.com\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ],"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_all\""
+        + "   }"
+        + " ]"
+        + "}";
+    assertNotNull(AuthorizationServerInterceptor.create(policy));
+  }
+}
diff --git a/authz/src/test/java/io/grpc/authz/FileWatcherAuthorizationServerInterceptorTest.java b/authz/src/test/java/io/grpc/authz/FileWatcherAuthorizationServerInterceptorTest.java
new file mode 100644
index 00000000000..0ed63541fa6
--- /dev/null
+++ b/authz/src/test/java/io/grpc/authz/FileWatcherAuthorizationServerInterceptorTest.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2022 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.authz;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class FileWatcherAuthorizationServerInterceptorTest {
+  @Test
+  public void invalidPolicyFailsAuthzInterceptorCreation() throws Exception {
+    File policyFile = File.createTempFile("temp", "json");
+    policyFile.deleteOnExit();
+    String policy = "{ \"name\": \"abc\",, }";
+    Files.write(Paths.get(policyFile.getAbsolutePath()), policy.getBytes(UTF_8));
+    try {
+      FileWatcherAuthorizationServerInterceptor.create(policyFile);
+      fail("exception expected");
+    } catch (IOException ioe) {
+      assertThat(ioe).hasMessageThat().contains("malformed");
+    }
+  }
+
+  @Test
+  public void validPolicyCreatesFileWatcherAuthzInterceptor() throws Exception {
+    File policyFile = File.createTempFile("temp", "json");
+    policyFile.deleteOnExit();
+    String policy = "{"
+        + " \"name\" : \"authz\","
+        + " \"deny_rules\": ["
+        + "   {"
+        + "     \"name\": \"deny_foo\","
+        + "     \"source\": {"
+        + "       \"principals\": ["
+        + "         \"spiffe://foo.com\""
+        + "       ]"
+        + "     }"
+        + "   }"
+        + " ],"
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_all\""
+        + "   }"
+        + " ]"
+        + "}";
+    Files.write(Paths.get(policyFile.getAbsolutePath()), policy.getBytes(UTF_8));
+    FileWatcherAuthorizationServerInterceptor interceptor = 
+        FileWatcherAuthorizationServerInterceptor.create(policyFile);
+    assertNotNull(interceptor);
+  }
+
+  @Test
+  public void invalidRefreshIntervalFailsScheduleRefreshes() throws Exception {
+    File policyFile = File.createTempFile("temp", "json");
+    policyFile.deleteOnExit();
+    String policy = "{"
+        + " \"name\" : \"authz\","
+        + " \"allow_rules\": ["
+        + "   {"
+        + "     \"name\": \"allow_all\""
+        + "   }"
+        + " ]"
+        + "}";
+    Files.write(Paths.get(policyFile.getAbsolutePath()), policy.getBytes(UTF_8));
+    FileWatcherAuthorizationServerInterceptor interceptor = 
+        FileWatcherAuthorizationServerInterceptor.create(policyFile);
+    assertNotNull(interceptor);
+    try {
+      interceptor.scheduleRefreshes(0, TimeUnit.SECONDS, 
+          Executors.newSingleThreadScheduledExecutor());
+      fail("exception expected");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae).hasMessageThat().isEqualTo(
+          "Refresh interval must be greater than 0");
+    }
+  }
+}
diff --git a/benchmarks/README.md b/benchmarks/README.md
index edc2d4db656..48933fff88c 100644
--- a/benchmarks/README.md
+++ b/benchmarks/README.md
@@ -17,9 +17,49 @@ You can now find the client and the server executables in `benchmarks/build/inst
 
 The `C++` counterpart can be found at https://github.com/grpc/grpc/tree/master/test/cpp/qps
 
+The [netty benchmark](src/jmh/java/io/grpc/benchmarks/netty) directory contains
+the standard benchmarks used to assess the performance of GRPC. Since these
+benchmarks run on localhost over loopback the performance of the underlying network is considerably
+different to real networks and their behavior. To address this issue we recommend the use of
+a network emulator to make loopback behave more like a real network. To this end the benchmark
+code looks for a loopback interface with 'benchmark' in its name and attempts to use the address
+bound to that interface when creating the client and server. If it cannot find such an interface it
+will print a warning and continue with the default localhost address.
+
+To attempt to standardize benchmark behavior across machines we attempt to emulate a 10gbit
+ethernet interface with a packet delay of 0.1ms.
+
+### Linux
+
+On Linux we can use [netem](https://www.linuxfoundation.org/collaborate/workgroups/networking/netem)  to shape the traffic appropriately.
+
+```sh
+# Remove all traffic shaping from loopback
+sudo tc qdisc del dev lo root
+# Add a priority traffic class to the root of loopback
+sudo tc qdisc add dev lo root handle 1: prio
+# Add a qdisc under the new class with the appropriate shaping
+sudo tc qdisc add dev lo parent 1:1 handle 2: netem delay 0.1ms rate 10gbit
+# Add a filter which selects the new qdisc class for traffic to 127.127.127.127
+sudo tc filter add dev lo parent 1:0 protocol ip prio 1 u32 match ip dst 127.127.127.127 flowid 2:1
+# Create an interface alias call 'lo:benchmark' that maps 127.127.127.127 to loopback
+sudo ip addr add dev lo 127.127.127.127/32 label lo:benchmark
+```
+
+to remove this configuration
+
+```sh
+sudo tc qdisc del dev lo root
+sudo ip addr del dev lo 127.127.127.127/32 label lo:benchmark
+```
+
+### Other Platforms
+
+Contributions are welcome!
+
 ## Visualizing the Latency Distribution
 
-The QPS client comes with the option `--save_histogram=FILE`, if set it serializes the histogram to `FILE` which can then be used with a plotter to visualize the latency distribution. The histogram is stored in the file format of [HdrHistogram](http://hdrhistogram.org/). That way it can be plotted very easily using a browser based tool like http://hdrhistogram.github.io/HdrHistogram/plotFiles.html. Simply upload the generated file and it will generate a beautiful graph for you. It also allows you to plot two or more histograms on the same surface in order two easily compare latency distributions.
+The QPS client comes with the option `--save_histogram=FILE`, if set it serializes the histogram to `FILE` which can then be used with a plotter to visualize the latency distribution. The histogram is stored in the file format of [HdrHistogram](https://hdrhistogram.org/). That way it can be plotted very easily using a browser based tool like https://hdrhistogram.github.io/HdrHistogram/plotFiles.html. Simply upload the generated file and it will generate a beautiful graph for you. It also allows you to plot two or more histograms on the same surface in order two easily compare latency distributions.
 
 ## JVM Options
 
diff --git a/benchmarks/build.gradle b/benchmarks/build.gradle
index ceb6d4743b1..88b26397e78 100644
--- a/benchmarks/build.gradle
+++ b/benchmarks/build.gradle
@@ -1,109 +1,126 @@
-buildscript {
-    repositories {
-        mavenCentral()
-        maven {
-            url "https://plugins.gradle.org/m2/"
-        }
-    }
-    dependencies {
-        classpath libraries.math
-        classpath libraries.protobuf_plugin
-    }
-}
-
 plugins {
-  id "me.champeau.gradle.jmh" version "0.3.0"
-}
+    id "application"
+    id "java"
+    id "maven-publish"
 
-apply plugin: 'application'
+    id "com.google.protobuf"
+    id "me.champeau.jmh"
+    id "ru.vyarus.animalsniffer"
+}
 
 description = "grpc Benchmarks"
 
-startScripts.enabled = false
-run.enabled = false
+tasks.named("jmh").configure {
+    jvmArgs = ["-server", "-Xms2g", "-Xmx2g"]
+}
 
-jmh {
-    jmhVersion = '1.17.3'
-    warmupIterations = 10
-    iterations = 10
-    fork = 1
-    jvmArgs = "-server -Xms2g -Xmx2g"
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.benchmarks')
+    }
 }
 
 dependencies {
-    compile project(':grpc-core'),
+    implementation project(':grpc-core'),
+            project(':grpc-inprocess'),
             project(':grpc-netty'),
             project(':grpc-okhttp'),
             project(':grpc-stub'),
             project(':grpc-protobuf'),
             project(':grpc-testing'),
-            libraries.junit,
-            libraries.mockito,
+            project(path: ':grpc-xds', configuration: 'shadow'),
             libraries.hdrhistogram,
-            libraries.netty_tcnative,
-            libraries.netty_epoll,
-            libraries.math
+            libraries.netty.tcnative,
+            libraries.netty.tcnative.classes,
+            libraries.commons.math3
+    implementation (libraries.netty.transport.epoll) {
+        artifact {
+            classifier = "linux-x86_64"
+        }
+    }
+
+    testImplementation libraries.junit,
+            libraries.mockito.core
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
-compileJmhJava {
-  options.compilerArgs = compileJava.options.compilerArgs
+import net.ltgt.gradle.errorprone.CheckSeverity
+
+tasks.named("compileJava").configure {
+    // The Control.Void protobuf clashes
+    options.errorprone.check("JavaLangClash", CheckSeverity.OFF)
 }
 
 configureProtoCompilation()
 
 def vmArgs = [
-        "-server",
-        "-Xms2g",
-        "-Xmx2g",
-        "-XX:+PrintGCDetails",
-        "-XX:+PrintFlagsFinal"
+    "-server",
+    "-Xms2g",
+    "-Xmx2g",
+    "-XX:+PrintGCDetails"
 ]
 
-task qps_client(type: CreateStartScripts) {
-    mainClassName = "io.grpc.benchmarks.qps.AsyncClient"
+tasks.named("startScripts").configure {
+    enabled = false
+}
+
+tasks.named("run").configure {
+    enabled = false
+}
+
+def qps_client = tasks.register("qps_client", CreateStartScripts) {
+    mainClass = "io.grpc.benchmarks.qps.AsyncClient"
     applicationName = "qps_client"
-    defaultJvmOpts = ["-javaagent:" + configurations.alpnagent.asPath] + vmArgs
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = jar.outputs.files + project.configurations.runtime
+    defaultJvmOpts = vmArgs
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
 }
 
-task openloop_client(type: CreateStartScripts) {
-    mainClassName = "io.grpc.benchmarks.qps.OpenLoopClient"
+def openloop_client = tasks.register("openloop_client", CreateStartScripts) {
+    mainClass = "io.grpc.benchmarks.qps.OpenLoopClient"
     applicationName = "openloop_client"
-    defaultJvmOpts = ["-javaagent:" + configurations.alpnagent.asPath] + vmArgs
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = jar.outputs.files + project.configurations.runtime
+    defaultJvmOpts = vmArgs
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
 }
 
-task qps_server(type: CreateStartScripts) {
-    mainClassName = "io.grpc.benchmarks.qps.AsyncServer"
+def qps_server = tasks.register("qps_server", CreateStartScripts) {
+    mainClass = "io.grpc.benchmarks.qps.AsyncServer"
     applicationName = "qps_server"
-    defaultJvmOpts = ["-javaagent:" + configurations.alpnagent.asPath] + vmArgs
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = jar.outputs.files + project.configurations.runtime
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
 }
 
-task benchmark_worker(type: CreateStartScripts) {
-    mainClassName = "io.grpc.benchmarks.driver.LoadWorker"
+def benchmark_worker = tasks.register("benchmark_worker", CreateStartScripts) {
+    mainClass = "io.grpc.benchmarks.driver.LoadWorker"
     applicationName = "benchmark_worker"
-    defaultJvmOpts = ["-javaagent:" + configurations.alpnagent.asPath] + vmArgs
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = jar.outputs.files + project.configurations.runtime
+    defaultJvmOpts = vmArgs
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
 }
 
-applicationDistribution.into("bin") {
-    from(qps_client)
-    from(openloop_client)
-    from(qps_server)
-    from(benchmark_worker)
-    fileMode = 0755
+application {
+    applicationDistribution.into("bin") {
+        from(qps_client)
+        from(openloop_client)
+        from(qps_server)
+        from(benchmark_worker)
+        filePermissions {
+            unix(0755)
+        }
+    }
 }
 
-// Let intellij projects refer to generated code
-idea {
-    module {
-        sourceDirs += file("${projectDir}/src/generated/main/java");
-        sourceDirs += file("${projectDir}/src/generated/main/grpc");
+publishing {
+    publications {
+        maven(MavenPublication) {
+            artifact distZip
+            artifact distTar
+        }
     }
 }
-
diff --git a/benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/BenchmarkServiceGrpc.java b/benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/BenchmarkServiceGrpc.java
index e617f60a8cc..68e911afc4a 100644
--- a/benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/BenchmarkServiceGrpc.java
+++ b/benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/BenchmarkServiceGrpc.java
@@ -1,56 +1,199 @@
 package io.grpc.benchmarks.proto;
 
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
 import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: services.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class BenchmarkServiceGrpc {
 
   private BenchmarkServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.BenchmarkService";
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.BenchmarkService";
 
   // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest,
-      io.grpc.benchmarks.proto.Messages.SimpleResponse> METHOD_UNARY_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.testing.BenchmarkService", "UnaryCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Messages.SimpleRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Messages.SimpleResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest,
-      io.grpc.benchmarks.proto.Messages.SimpleResponse> METHOD_STREAMING_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.BenchmarkService", "StreamingCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Messages.SimpleRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Messages.SimpleResponse.getDefaultInstance()));
+  private static volatile io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest,
+      io.grpc.benchmarks.proto.Messages.SimpleResponse> getUnaryCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UnaryCall",
+      requestType = io.grpc.benchmarks.proto.Messages.SimpleRequest.class,
+      responseType = io.grpc.benchmarks.proto.Messages.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest,
+      io.grpc.benchmarks.proto.Messages.SimpleResponse> getUnaryCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest, io.grpc.benchmarks.proto.Messages.SimpleResponse> getUnaryCallMethod;
+    if ((getUnaryCallMethod = BenchmarkServiceGrpc.getUnaryCallMethod) == null) {
+      synchronized (BenchmarkServiceGrpc.class) {
+        if ((getUnaryCallMethod = BenchmarkServiceGrpc.getUnaryCallMethod) == null) {
+          BenchmarkServiceGrpc.getUnaryCallMethod = getUnaryCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.benchmarks.proto.Messages.SimpleRequest, io.grpc.benchmarks.proto.Messages.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnaryCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Messages.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Messages.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new BenchmarkServiceMethodDescriptorSupplier("UnaryCall"))
+              .build();
+        }
+      }
+    }
+    return getUnaryCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest,
+      io.grpc.benchmarks.proto.Messages.SimpleResponse> getStreamingCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingCall",
+      requestType = io.grpc.benchmarks.proto.Messages.SimpleRequest.class,
+      responseType = io.grpc.benchmarks.proto.Messages.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest,
+      io.grpc.benchmarks.proto.Messages.SimpleResponse> getStreamingCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest, io.grpc.benchmarks.proto.Messages.SimpleResponse> getStreamingCallMethod;
+    if ((getStreamingCallMethod = BenchmarkServiceGrpc.getStreamingCallMethod) == null) {
+      synchronized (BenchmarkServiceGrpc.class) {
+        if ((getStreamingCallMethod = BenchmarkServiceGrpc.getStreamingCallMethod) == null) {
+          BenchmarkServiceGrpc.getStreamingCallMethod = getStreamingCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.benchmarks.proto.Messages.SimpleRequest, io.grpc.benchmarks.proto.Messages.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Messages.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Messages.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new BenchmarkServiceMethodDescriptorSupplier("StreamingCall"))
+              .build();
+        }
+      }
+    }
+    return getStreamingCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest,
+      io.grpc.benchmarks.proto.Messages.SimpleResponse> getStreamingFromClientMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingFromClient",
+      requestType = io.grpc.benchmarks.proto.Messages.SimpleRequest.class,
+      responseType = io.grpc.benchmarks.proto.Messages.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest,
+      io.grpc.benchmarks.proto.Messages.SimpleResponse> getStreamingFromClientMethod() {
+    io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest, io.grpc.benchmarks.proto.Messages.SimpleResponse> getStreamingFromClientMethod;
+    if ((getStreamingFromClientMethod = BenchmarkServiceGrpc.getStreamingFromClientMethod) == null) {
+      synchronized (BenchmarkServiceGrpc.class) {
+        if ((getStreamingFromClientMethod = BenchmarkServiceGrpc.getStreamingFromClientMethod) == null) {
+          BenchmarkServiceGrpc.getStreamingFromClientMethod = getStreamingFromClientMethod =
+              io.grpc.MethodDescriptor.<io.grpc.benchmarks.proto.Messages.SimpleRequest, io.grpc.benchmarks.proto.Messages.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingFromClient"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Messages.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Messages.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new BenchmarkServiceMethodDescriptorSupplier("StreamingFromClient"))
+              .build();
+        }
+      }
+    }
+    return getStreamingFromClientMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest,
+      io.grpc.benchmarks.proto.Messages.SimpleResponse> getStreamingFromServerMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingFromServer",
+      requestType = io.grpc.benchmarks.proto.Messages.SimpleRequest.class,
+      responseType = io.grpc.benchmarks.proto.Messages.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest,
+      io.grpc.benchmarks.proto.Messages.SimpleResponse> getStreamingFromServerMethod() {
+    io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest, io.grpc.benchmarks.proto.Messages.SimpleResponse> getStreamingFromServerMethod;
+    if ((getStreamingFromServerMethod = BenchmarkServiceGrpc.getStreamingFromServerMethod) == null) {
+      synchronized (BenchmarkServiceGrpc.class) {
+        if ((getStreamingFromServerMethod = BenchmarkServiceGrpc.getStreamingFromServerMethod) == null) {
+          BenchmarkServiceGrpc.getStreamingFromServerMethod = getStreamingFromServerMethod =
+              io.grpc.MethodDescriptor.<io.grpc.benchmarks.proto.Messages.SimpleRequest, io.grpc.benchmarks.proto.Messages.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingFromServer"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Messages.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Messages.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new BenchmarkServiceMethodDescriptorSupplier("StreamingFromServer"))
+              .build();
+        }
+      }
+    }
+    return getStreamingFromServerMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest,
+      io.grpc.benchmarks.proto.Messages.SimpleResponse> getStreamingBothWaysMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingBothWays",
+      requestType = io.grpc.benchmarks.proto.Messages.SimpleRequest.class,
+      responseType = io.grpc.benchmarks.proto.Messages.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest,
+      io.grpc.benchmarks.proto.Messages.SimpleResponse> getStreamingBothWaysMethod() {
+    io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Messages.SimpleRequest, io.grpc.benchmarks.proto.Messages.SimpleResponse> getStreamingBothWaysMethod;
+    if ((getStreamingBothWaysMethod = BenchmarkServiceGrpc.getStreamingBothWaysMethod) == null) {
+      synchronized (BenchmarkServiceGrpc.class) {
+        if ((getStreamingBothWaysMethod = BenchmarkServiceGrpc.getStreamingBothWaysMethod) == null) {
+          BenchmarkServiceGrpc.getStreamingBothWaysMethod = getStreamingBothWaysMethod =
+              io.grpc.MethodDescriptor.<io.grpc.benchmarks.proto.Messages.SimpleRequest, io.grpc.benchmarks.proto.Messages.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingBothWays"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Messages.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Messages.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new BenchmarkServiceMethodDescriptorSupplier("StreamingBothWays"))
+              .build();
+        }
+      }
+    }
+    return getStreamingBothWaysMethod;
+  }
 
   /**
    * Creates a new async stub that supports all call types for the service
    */
   public static BenchmarkServiceStub newStub(io.grpc.Channel channel) {
-    return new BenchmarkServiceStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<BenchmarkServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<BenchmarkServiceStub>() {
+        @java.lang.Override
+        public BenchmarkServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new BenchmarkServiceStub(channel, callOptions);
+        }
+      };
+    return BenchmarkServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static BenchmarkServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<BenchmarkServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<BenchmarkServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public BenchmarkServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new BenchmarkServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return BenchmarkServiceBlockingV2Stub.newStub(factory, channel);
   }
 
   /**
@@ -58,20 +201,34 @@ public static BenchmarkServiceStub newStub(io.grpc.Channel channel) {
    */
   public static BenchmarkServiceBlockingStub newBlockingStub(
       io.grpc.Channel channel) {
-    return new BenchmarkServiceBlockingStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<BenchmarkServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<BenchmarkServiceBlockingStub>() {
+        @java.lang.Override
+        public BenchmarkServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new BenchmarkServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return BenchmarkServiceBlockingStub.newStub(factory, channel);
   }
 
   /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
    */
   public static BenchmarkServiceFutureStub newFutureStub(
       io.grpc.Channel channel) {
-    return new BenchmarkServiceFutureStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<BenchmarkServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<BenchmarkServiceFutureStub>() {
+        @java.lang.Override
+        public BenchmarkServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new BenchmarkServiceFutureStub(channel, callOptions);
+        }
+      };
+    return BenchmarkServiceFutureStub.newStub(factory, channel);
   }
 
   /**
    */
-  public static abstract class BenchmarkServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -79,57 +236,81 @@ public static abstract class BenchmarkServiceImplBase implements io.grpc.Bindabl
      * The server returns the client payload as-is.
      * </pre>
      */
-    public void unaryCall(io.grpc.benchmarks.proto.Messages.SimpleRequest request,
+    default void unaryCall(io.grpc.benchmarks.proto.Messages.SimpleRequest request,
         io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_UNARY_CALL, responseObserver);
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnaryCallMethod(), responseObserver);
     }
 
     /**
      * <pre>
-     * One request followed by one response.
-     * The server returns the client payload as-is.
+     * Repeated sequence of one request followed by one response.
+     * Should be called streaming ping-pong
+     * The server returns the client payload as-is on each response
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleRequest> streamingCall(
+    default io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleRequest> streamingCall(
         io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_STREAMING_CALL, responseObserver);
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamingCallMethod(), responseObserver);
     }
 
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_UNARY_CALL,
-            asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.benchmarks.proto.Messages.SimpleRequest,
-                io.grpc.benchmarks.proto.Messages.SimpleResponse>(
-                  this, METHODID_UNARY_CALL)))
-          .addMethod(
-            METHOD_STREAMING_CALL,
-            asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.benchmarks.proto.Messages.SimpleRequest,
-                io.grpc.benchmarks.proto.Messages.SimpleResponse>(
-                  this, METHODID_STREAMING_CALL)))
-          .build();
+    /**
+     * <pre>
+     * Single-sided unbounded streaming from client to server
+     * The server returns the client payload as-is once the client does WritesDone
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleRequest> streamingFromClient(
+        io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamingFromClientMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Single-sided unbounded streaming from server to client
+     * The server repeatedly returns the client payload as-is
+     * </pre>
+     */
+    default void streamingFromServer(io.grpc.benchmarks.proto.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStreamingFromServerMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Two-sided unbounded streaming between server to client
+     * Both sides send the content of their own choice to the other
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleRequest> streamingBothWays(
+        io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamingBothWaysMethod(), responseObserver);
     }
   }
 
   /**
+   * Base class for the server implementation of the service BenchmarkService.
    */
-  public static final class BenchmarkServiceStub extends io.grpc.stub.AbstractStub<BenchmarkServiceStub> {
-    private BenchmarkServiceStub(io.grpc.Channel channel) {
-      super(channel);
+  public static abstract class BenchmarkServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return BenchmarkServiceGrpc.bindService(this);
     }
+  }
 
-    private BenchmarkServiceStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service BenchmarkService.
+   */
+  public static final class BenchmarkServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<BenchmarkServiceStub> {
+    private BenchmarkServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected BenchmarkServiceStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected BenchmarkServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new BenchmarkServiceStub(channel, callOptions);
     }
 
@@ -141,38 +322,154 @@ protected BenchmarkServiceStub build(io.grpc.Channel channel,
      */
     public void unaryCall(io.grpc.benchmarks.proto.Messages.SimpleRequest request,
         io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_UNARY_CALL, getCallOptions()), request, responseObserver);
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request, responseObserver);
     }
 
     /**
      * <pre>
-     * One request followed by one response.
-     * The server returns the client payload as-is.
+     * Repeated sequence of one request followed by one response.
+     * Should be called streaming ping-pong
+     * The server returns the client payload as-is on each response
      * </pre>
      */
     public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleRequest> streamingCall(
         io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse> responseObserver) {
-      return asyncBidiStreamingCall(
-          getChannel().newCall(METHOD_STREAMING_CALL, getCallOptions()), responseObserver);
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getStreamingCallMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Single-sided unbounded streaming from client to server
+     * The server returns the client payload as-is once the client does WritesDone
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleRequest> streamingFromClient(
+        io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncClientStreamingCall(
+          getChannel().newCall(getStreamingFromClientMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Single-sided unbounded streaming from server to client
+     * The server repeatedly returns the client payload as-is
+     * </pre>
+     */
+    public void streamingFromServer(io.grpc.benchmarks.proto.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getStreamingFromServerMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Two-sided unbounded streaming between server to client
+     * Both sides send the content of their own choice to the other
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleRequest> streamingBothWays(
+        io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getStreamingBothWaysMethod(), getCallOptions()), responseObserver);
     }
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service BenchmarkService.
    */
-  public static final class BenchmarkServiceBlockingStub extends io.grpc.stub.AbstractStub<BenchmarkServiceBlockingStub> {
-    private BenchmarkServiceBlockingStub(io.grpc.Channel channel) {
-      super(channel);
+  public static final class BenchmarkServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<BenchmarkServiceBlockingV2Stub> {
+    private BenchmarkServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected BenchmarkServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new BenchmarkServiceBlockingV2Stub(channel, callOptions);
     }
 
-    private BenchmarkServiceBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    /**
+     * <pre>
+     * One request followed by one response.
+     * The server returns the client payload as-is.
+     * </pre>
+     */
+    public io.grpc.benchmarks.proto.Messages.SimpleResponse unaryCall(io.grpc.benchmarks.proto.Messages.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Repeated sequence of one request followed by one response.
+     * Should be called streaming ping-pong
+     * The server returns the client payload as-is on each response
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.benchmarks.proto.Messages.SimpleRequest, io.grpc.benchmarks.proto.Messages.SimpleResponse>
+        streamingCall() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getStreamingCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * Single-sided unbounded streaming from client to server
+     * The server returns the client payload as-is once the client does WritesDone
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.benchmarks.proto.Messages.SimpleRequest, io.grpc.benchmarks.proto.Messages.SimpleResponse>
+        streamingFromClient() {
+      return io.grpc.stub.ClientCalls.blockingClientStreamingCall(
+          getChannel(), getStreamingFromClientMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * Single-sided unbounded streaming from server to client
+     * The server repeatedly returns the client payload as-is
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<?, io.grpc.benchmarks.proto.Messages.SimpleResponse>
+        streamingFromServer(io.grpc.benchmarks.proto.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingV2ServerStreamingCall(
+          getChannel(), getStreamingFromServerMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Two-sided unbounded streaming between server to client
+     * Both sides send the content of their own choice to the other
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.benchmarks.proto.Messages.SimpleRequest, io.grpc.benchmarks.proto.Messages.SimpleResponse>
+        streamingBothWays() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getStreamingBothWaysMethod(), getCallOptions());
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service BenchmarkService.
+   */
+  public static final class BenchmarkServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<BenchmarkServiceBlockingStub> {
+    private BenchmarkServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected BenchmarkServiceBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected BenchmarkServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new BenchmarkServiceBlockingStub(channel, callOptions);
     }
 
@@ -183,26 +480,36 @@ protected BenchmarkServiceBlockingStub build(io.grpc.Channel channel,
      * </pre>
      */
     public io.grpc.benchmarks.proto.Messages.SimpleResponse unaryCall(io.grpc.benchmarks.proto.Messages.SimpleRequest request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_UNARY_CALL, getCallOptions(), request);
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Single-sided unbounded streaming from server to client
+     * The server repeatedly returns the client payload as-is
+     * </pre>
+     */
+    public java.util.Iterator<io.grpc.benchmarks.proto.Messages.SimpleResponse> streamingFromServer(
+        io.grpc.benchmarks.proto.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getStreamingFromServerMethod(), getCallOptions(), request);
     }
   }
 
   /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service BenchmarkService.
    */
-  public static final class BenchmarkServiceFutureStub extends io.grpc.stub.AbstractStub<BenchmarkServiceFutureStub> {
-    private BenchmarkServiceFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private BenchmarkServiceFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class BenchmarkServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<BenchmarkServiceFutureStub> {
+    private BenchmarkServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected BenchmarkServiceFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected BenchmarkServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new BenchmarkServiceFutureStub(channel, callOptions);
     }
 
@@ -214,23 +521,26 @@ protected BenchmarkServiceFutureStub build(io.grpc.Channel channel,
      */
     public com.google.common.util.concurrent.ListenableFuture<io.grpc.benchmarks.proto.Messages.SimpleResponse> unaryCall(
         io.grpc.benchmarks.proto.Messages.SimpleRequest request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_UNARY_CALL, getCallOptions()), request);
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request);
     }
   }
 
   private static final int METHODID_UNARY_CALL = 0;
-  private static final int METHODID_STREAMING_CALL = 1;
+  private static final int METHODID_STREAMING_FROM_SERVER = 1;
+  private static final int METHODID_STREAMING_CALL = 2;
+  private static final int METHODID_STREAMING_FROM_CLIENT = 3;
+  private static final int METHODID_STREAMING_BOTH_WAYS = 4;
 
   private static final class MethodHandlers<Req, Resp> implements
       io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final BenchmarkServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(BenchmarkServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -243,6 +553,10 @@ public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserv
           serviceImpl.unaryCall((io.grpc.benchmarks.proto.Messages.SimpleRequest) request,
               (io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse>) responseObserver);
           break;
+        case METHODID_STREAMING_FROM_SERVER:
+          serviceImpl.streamingFromServer((io.grpc.benchmarks.proto.Messages.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse>) responseObserver);
+          break;
         default:
           throw new AssertionError();
       }
@@ -256,17 +570,91 @@ public io.grpc.stub.StreamObserver<Req> invoke(
         case METHODID_STREAMING_CALL:
           return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamingCall(
               (io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse>) responseObserver);
+        case METHODID_STREAMING_FROM_CLIENT:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamingFromClient(
+              (io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse>) responseObserver);
+        case METHODID_STREAMING_BOTH_WAYS:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamingBothWays(
+              (io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Messages.SimpleResponse>) responseObserver);
         default:
           throw new AssertionError();
       }
     }
   }
 
-  private static final class BenchmarkServiceDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getUnaryCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.benchmarks.proto.Messages.SimpleRequest,
+              io.grpc.benchmarks.proto.Messages.SimpleResponse>(
+                service, METHODID_UNARY_CALL)))
+        .addMethod(
+          getStreamingCallMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.benchmarks.proto.Messages.SimpleRequest,
+              io.grpc.benchmarks.proto.Messages.SimpleResponse>(
+                service, METHODID_STREAMING_CALL)))
+        .addMethod(
+          getStreamingFromClientMethod(),
+          io.grpc.stub.ServerCalls.asyncClientStreamingCall(
+            new MethodHandlers<
+              io.grpc.benchmarks.proto.Messages.SimpleRequest,
+              io.grpc.benchmarks.proto.Messages.SimpleResponse>(
+                service, METHODID_STREAMING_FROM_CLIENT)))
+        .addMethod(
+          getStreamingFromServerMethod(),
+          io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+            new MethodHandlers<
+              io.grpc.benchmarks.proto.Messages.SimpleRequest,
+              io.grpc.benchmarks.proto.Messages.SimpleResponse>(
+                service, METHODID_STREAMING_FROM_SERVER)))
+        .addMethod(
+          getStreamingBothWaysMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.benchmarks.proto.Messages.SimpleRequest,
+              io.grpc.benchmarks.proto.Messages.SimpleResponse>(
+                service, METHODID_STREAMING_BOTH_WAYS)))
+        .build();
+  }
+
+  private static abstract class BenchmarkServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    BenchmarkServiceBaseDescriptorSupplier() {}
+
     @java.lang.Override
     public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
       return io.grpc.benchmarks.proto.Services.getDescriptor();
     }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("BenchmarkService");
+    }
+  }
+
+  private static final class BenchmarkServiceFileDescriptorSupplier
+      extends BenchmarkServiceBaseDescriptorSupplier {
+    BenchmarkServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class BenchmarkServiceMethodDescriptorSupplier
+      extends BenchmarkServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    BenchmarkServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
   }
 
   private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
@@ -278,9 +666,12 @@ public static io.grpc.ServiceDescriptor getServiceDescriptor() {
         result = serviceDescriptor;
         if (result == null) {
           serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new BenchmarkServiceDescriptorSupplier())
-              .addMethod(METHOD_UNARY_CALL)
-              .addMethod(METHOD_STREAMING_CALL)
+              .setSchemaDescriptor(new BenchmarkServiceFileDescriptorSupplier())
+              .addMethod(getUnaryCallMethod())
+              .addMethod(getStreamingCallMethod())
+              .addMethod(getStreamingFromClientMethod())
+              .addMethod(getStreamingFromServerMethod())
+              .addMethod(getStreamingBothWaysMethod())
               .build();
         }
       }
diff --git a/benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/ReportQpsScenarioServiceGrpc.java b/benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/ReportQpsScenarioServiceGrpc.java
new file mode 100644
index 00000000000..c5064875bb6
--- /dev/null
+++ b/benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/ReportQpsScenarioServiceGrpc.java
@@ -0,0 +1,344 @@
+package io.grpc.benchmarks.proto;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class ReportQpsScenarioServiceGrpc {
+
+  private ReportQpsScenarioServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.ReportQpsScenarioService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.ScenarioResult,
+      io.grpc.benchmarks.proto.Control.Void> getReportScenarioMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "ReportScenario",
+      requestType = io.grpc.benchmarks.proto.Control.ScenarioResult.class,
+      responseType = io.grpc.benchmarks.proto.Control.Void.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.ScenarioResult,
+      io.grpc.benchmarks.proto.Control.Void> getReportScenarioMethod() {
+    io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.ScenarioResult, io.grpc.benchmarks.proto.Control.Void> getReportScenarioMethod;
+    if ((getReportScenarioMethod = ReportQpsScenarioServiceGrpc.getReportScenarioMethod) == null) {
+      synchronized (ReportQpsScenarioServiceGrpc.class) {
+        if ((getReportScenarioMethod = ReportQpsScenarioServiceGrpc.getReportScenarioMethod) == null) {
+          ReportQpsScenarioServiceGrpc.getReportScenarioMethod = getReportScenarioMethod =
+              io.grpc.MethodDescriptor.<io.grpc.benchmarks.proto.Control.ScenarioResult, io.grpc.benchmarks.proto.Control.Void>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ReportScenario"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Control.ScenarioResult.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Control.Void.getDefaultInstance()))
+              .setSchemaDescriptor(new ReportQpsScenarioServiceMethodDescriptorSupplier("ReportScenario"))
+              .build();
+        }
+      }
+    }
+    return getReportScenarioMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static ReportQpsScenarioServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReportQpsScenarioServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReportQpsScenarioServiceStub>() {
+        @java.lang.Override
+        public ReportQpsScenarioServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReportQpsScenarioServiceStub(channel, callOptions);
+        }
+      };
+    return ReportQpsScenarioServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static ReportQpsScenarioServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReportQpsScenarioServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReportQpsScenarioServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public ReportQpsScenarioServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReportQpsScenarioServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return ReportQpsScenarioServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static ReportQpsScenarioServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReportQpsScenarioServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReportQpsScenarioServiceBlockingStub>() {
+        @java.lang.Override
+        public ReportQpsScenarioServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReportQpsScenarioServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return ReportQpsScenarioServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static ReportQpsScenarioServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReportQpsScenarioServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReportQpsScenarioServiceFutureStub>() {
+        @java.lang.Override
+        public ReportQpsScenarioServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReportQpsScenarioServiceFutureStub(channel, callOptions);
+        }
+      };
+    return ReportQpsScenarioServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Report results of a QPS test benchmark scenario.
+     * </pre>
+     */
+    default void reportScenario(io.grpc.benchmarks.proto.Control.ScenarioResult request,
+        io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.Void> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getReportScenarioMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service ReportQpsScenarioService.
+   */
+  public static abstract class ReportQpsScenarioServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return ReportQpsScenarioServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service ReportQpsScenarioService.
+   */
+  public static final class ReportQpsScenarioServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<ReportQpsScenarioServiceStub> {
+    private ReportQpsScenarioServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReportQpsScenarioServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReportQpsScenarioServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Report results of a QPS test benchmark scenario.
+     * </pre>
+     */
+    public void reportScenario(io.grpc.benchmarks.proto.Control.ScenarioResult request,
+        io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.Void> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getReportScenarioMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service ReportQpsScenarioService.
+   */
+  public static final class ReportQpsScenarioServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<ReportQpsScenarioServiceBlockingV2Stub> {
+    private ReportQpsScenarioServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReportQpsScenarioServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReportQpsScenarioServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Report results of a QPS test benchmark scenario.
+     * </pre>
+     */
+    public io.grpc.benchmarks.proto.Control.Void reportScenario(io.grpc.benchmarks.proto.Control.ScenarioResult request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getReportScenarioMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service ReportQpsScenarioService.
+   */
+  public static final class ReportQpsScenarioServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<ReportQpsScenarioServiceBlockingStub> {
+    private ReportQpsScenarioServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReportQpsScenarioServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReportQpsScenarioServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Report results of a QPS test benchmark scenario.
+     * </pre>
+     */
+    public io.grpc.benchmarks.proto.Control.Void reportScenario(io.grpc.benchmarks.proto.Control.ScenarioResult request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getReportScenarioMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service ReportQpsScenarioService.
+   */
+  public static final class ReportQpsScenarioServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ReportQpsScenarioServiceFutureStub> {
+    private ReportQpsScenarioServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReportQpsScenarioServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReportQpsScenarioServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Report results of a QPS test benchmark scenario.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.benchmarks.proto.Control.Void> reportScenario(
+        io.grpc.benchmarks.proto.Control.ScenarioResult request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getReportScenarioMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_REPORT_SCENARIO = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_REPORT_SCENARIO:
+          serviceImpl.reportScenario((io.grpc.benchmarks.proto.Control.ScenarioResult) request,
+              (io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.Void>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getReportScenarioMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.benchmarks.proto.Control.ScenarioResult,
+              io.grpc.benchmarks.proto.Control.Void>(
+                service, METHODID_REPORT_SCENARIO)))
+        .build();
+  }
+
+  private static abstract class ReportQpsScenarioServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    ReportQpsScenarioServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.benchmarks.proto.Services.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("ReportQpsScenarioService");
+    }
+  }
+
+  private static final class ReportQpsScenarioServiceFileDescriptorSupplier
+      extends ReportQpsScenarioServiceBaseDescriptorSupplier {
+    ReportQpsScenarioServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class ReportQpsScenarioServiceMethodDescriptorSupplier
+      extends ReportQpsScenarioServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    ReportQpsScenarioServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (ReportQpsScenarioServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new ReportQpsScenarioServiceFileDescriptorSupplier())
+              .addMethod(getReportScenarioMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/WorkerServiceGrpc.java b/benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/WorkerServiceGrpc.java
index 9cff56827a5..721b4f9ab19 100644
--- a/benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/WorkerServiceGrpc.java
+++ b/benchmarks/src/generated/main/grpc/io/grpc/benchmarks/proto/WorkerServiceGrpc.java
@@ -1,74 +1,168 @@
 package io.grpc.benchmarks.proto;
 
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
 import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: services.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class WorkerServiceGrpc {
 
   private WorkerServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.WorkerService";
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.WorkerService";
 
   // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.ServerArgs,
-      io.grpc.benchmarks.proto.Control.ServerStatus> METHOD_RUN_SERVER =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.WorkerService", "RunServer"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Control.ServerArgs.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Control.ServerStatus.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.ClientArgs,
-      io.grpc.benchmarks.proto.Control.ClientStatus> METHOD_RUN_CLIENT =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.WorkerService", "RunClient"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Control.ClientArgs.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Control.ClientStatus.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.CoreRequest,
-      io.grpc.benchmarks.proto.Control.CoreResponse> METHOD_CORE_COUNT =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.testing.WorkerService", "CoreCount"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Control.CoreRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Control.CoreResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.Void,
-      io.grpc.benchmarks.proto.Control.Void> METHOD_QUIT_WORKER =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.testing.WorkerService", "QuitWorker"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Control.Void.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.benchmarks.proto.Control.Void.getDefaultInstance()));
+  private static volatile io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.ServerArgs,
+      io.grpc.benchmarks.proto.Control.ServerStatus> getRunServerMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "RunServer",
+      requestType = io.grpc.benchmarks.proto.Control.ServerArgs.class,
+      responseType = io.grpc.benchmarks.proto.Control.ServerStatus.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.ServerArgs,
+      io.grpc.benchmarks.proto.Control.ServerStatus> getRunServerMethod() {
+    io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.ServerArgs, io.grpc.benchmarks.proto.Control.ServerStatus> getRunServerMethod;
+    if ((getRunServerMethod = WorkerServiceGrpc.getRunServerMethod) == null) {
+      synchronized (WorkerServiceGrpc.class) {
+        if ((getRunServerMethod = WorkerServiceGrpc.getRunServerMethod) == null) {
+          WorkerServiceGrpc.getRunServerMethod = getRunServerMethod =
+              io.grpc.MethodDescriptor.<io.grpc.benchmarks.proto.Control.ServerArgs, io.grpc.benchmarks.proto.Control.ServerStatus>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "RunServer"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Control.ServerArgs.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Control.ServerStatus.getDefaultInstance()))
+              .setSchemaDescriptor(new WorkerServiceMethodDescriptorSupplier("RunServer"))
+              .build();
+        }
+      }
+    }
+    return getRunServerMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.ClientArgs,
+      io.grpc.benchmarks.proto.Control.ClientStatus> getRunClientMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "RunClient",
+      requestType = io.grpc.benchmarks.proto.Control.ClientArgs.class,
+      responseType = io.grpc.benchmarks.proto.Control.ClientStatus.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.ClientArgs,
+      io.grpc.benchmarks.proto.Control.ClientStatus> getRunClientMethod() {
+    io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.ClientArgs, io.grpc.benchmarks.proto.Control.ClientStatus> getRunClientMethod;
+    if ((getRunClientMethod = WorkerServiceGrpc.getRunClientMethod) == null) {
+      synchronized (WorkerServiceGrpc.class) {
+        if ((getRunClientMethod = WorkerServiceGrpc.getRunClientMethod) == null) {
+          WorkerServiceGrpc.getRunClientMethod = getRunClientMethod =
+              io.grpc.MethodDescriptor.<io.grpc.benchmarks.proto.Control.ClientArgs, io.grpc.benchmarks.proto.Control.ClientStatus>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "RunClient"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Control.ClientArgs.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Control.ClientStatus.getDefaultInstance()))
+              .setSchemaDescriptor(new WorkerServiceMethodDescriptorSupplier("RunClient"))
+              .build();
+        }
+      }
+    }
+    return getRunClientMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.CoreRequest,
+      io.grpc.benchmarks.proto.Control.CoreResponse> getCoreCountMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "CoreCount",
+      requestType = io.grpc.benchmarks.proto.Control.CoreRequest.class,
+      responseType = io.grpc.benchmarks.proto.Control.CoreResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.CoreRequest,
+      io.grpc.benchmarks.proto.Control.CoreResponse> getCoreCountMethod() {
+    io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.CoreRequest, io.grpc.benchmarks.proto.Control.CoreResponse> getCoreCountMethod;
+    if ((getCoreCountMethod = WorkerServiceGrpc.getCoreCountMethod) == null) {
+      synchronized (WorkerServiceGrpc.class) {
+        if ((getCoreCountMethod = WorkerServiceGrpc.getCoreCountMethod) == null) {
+          WorkerServiceGrpc.getCoreCountMethod = getCoreCountMethod =
+              io.grpc.MethodDescriptor.<io.grpc.benchmarks.proto.Control.CoreRequest, io.grpc.benchmarks.proto.Control.CoreResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CoreCount"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Control.CoreRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Control.CoreResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new WorkerServiceMethodDescriptorSupplier("CoreCount"))
+              .build();
+        }
+      }
+    }
+    return getCoreCountMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.Void,
+      io.grpc.benchmarks.proto.Control.Void> getQuitWorkerMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "QuitWorker",
+      requestType = io.grpc.benchmarks.proto.Control.Void.class,
+      responseType = io.grpc.benchmarks.proto.Control.Void.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.Void,
+      io.grpc.benchmarks.proto.Control.Void> getQuitWorkerMethod() {
+    io.grpc.MethodDescriptor<io.grpc.benchmarks.proto.Control.Void, io.grpc.benchmarks.proto.Control.Void> getQuitWorkerMethod;
+    if ((getQuitWorkerMethod = WorkerServiceGrpc.getQuitWorkerMethod) == null) {
+      synchronized (WorkerServiceGrpc.class) {
+        if ((getQuitWorkerMethod = WorkerServiceGrpc.getQuitWorkerMethod) == null) {
+          WorkerServiceGrpc.getQuitWorkerMethod = getQuitWorkerMethod =
+              io.grpc.MethodDescriptor.<io.grpc.benchmarks.proto.Control.Void, io.grpc.benchmarks.proto.Control.Void>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "QuitWorker"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Control.Void.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.benchmarks.proto.Control.Void.getDefaultInstance()))
+              .setSchemaDescriptor(new WorkerServiceMethodDescriptorSupplier("QuitWorker"))
+              .build();
+        }
+      }
+    }
+    return getQuitWorkerMethod;
+  }
 
   /**
    * Creates a new async stub that supports all call types for the service
    */
   public static WorkerServiceStub newStub(io.grpc.Channel channel) {
-    return new WorkerServiceStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<WorkerServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<WorkerServiceStub>() {
+        @java.lang.Override
+        public WorkerServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new WorkerServiceStub(channel, callOptions);
+        }
+      };
+    return WorkerServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static WorkerServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<WorkerServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<WorkerServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public WorkerServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new WorkerServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return WorkerServiceBlockingV2Stub.newStub(factory, channel);
   }
 
   /**
@@ -76,20 +170,34 @@ public static WorkerServiceStub newStub(io.grpc.Channel channel) {
    */
   public static WorkerServiceBlockingStub newBlockingStub(
       io.grpc.Channel channel) {
-    return new WorkerServiceBlockingStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<WorkerServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<WorkerServiceBlockingStub>() {
+        @java.lang.Override
+        public WorkerServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new WorkerServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return WorkerServiceBlockingStub.newStub(factory, channel);
   }
 
   /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
    */
   public static WorkerServiceFutureStub newFutureStub(
       io.grpc.Channel channel) {
-    return new WorkerServiceFutureStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<WorkerServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<WorkerServiceFutureStub>() {
+        @java.lang.Override
+        public WorkerServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new WorkerServiceFutureStub(channel, callOptions);
+        }
+      };
+    return WorkerServiceFutureStub.newStub(factory, channel);
   }
 
   /**
    */
-  public static abstract class WorkerServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -101,9 +209,9 @@ public static abstract class WorkerServiceImplBase implements io.grpc.BindableSe
      * this RPC.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ServerArgs> runServer(
+    default io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ServerArgs> runServer(
         io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ServerStatus> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_RUN_SERVER, responseObserver);
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getRunServerMethod(), responseObserver);
     }
 
     /**
@@ -116,9 +224,9 @@ public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ServerArgs>
      * this RPC.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ClientArgs> runClient(
+    default io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ClientArgs> runClient(
         io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ClientStatus> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_RUN_CLIENT, responseObserver);
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getRunClientMethod(), responseObserver);
     }
 
     /**
@@ -126,9 +234,9 @@ public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ClientArgs>
      * Just return the core count - unary call
      * </pre>
      */
-    public void coreCount(io.grpc.benchmarks.proto.Control.CoreRequest request,
+    default void coreCount(io.grpc.benchmarks.proto.Control.CoreRequest request,
         io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.CoreResponse> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_CORE_COUNT, responseObserver);
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCoreCountMethod(), responseObserver);
     }
 
     /**
@@ -136,60 +244,36 @@ public void coreCount(io.grpc.benchmarks.proto.Control.CoreRequest request,
      * Quit this worker
      * </pre>
      */
-    public void quitWorker(io.grpc.benchmarks.proto.Control.Void request,
+    default void quitWorker(io.grpc.benchmarks.proto.Control.Void request,
         io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.Void> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_QUIT_WORKER, responseObserver);
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getQuitWorkerMethod(), responseObserver);
     }
+  }
+
+  /**
+   * Base class for the server implementation of the service WorkerService.
+   */
+  public static abstract class WorkerServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
 
     @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_RUN_SERVER,
-            asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.benchmarks.proto.Control.ServerArgs,
-                io.grpc.benchmarks.proto.Control.ServerStatus>(
-                  this, METHODID_RUN_SERVER)))
-          .addMethod(
-            METHOD_RUN_CLIENT,
-            asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.benchmarks.proto.Control.ClientArgs,
-                io.grpc.benchmarks.proto.Control.ClientStatus>(
-                  this, METHODID_RUN_CLIENT)))
-          .addMethod(
-            METHOD_CORE_COUNT,
-            asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.benchmarks.proto.Control.CoreRequest,
-                io.grpc.benchmarks.proto.Control.CoreResponse>(
-                  this, METHODID_CORE_COUNT)))
-          .addMethod(
-            METHOD_QUIT_WORKER,
-            asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.benchmarks.proto.Control.Void,
-                io.grpc.benchmarks.proto.Control.Void>(
-                  this, METHODID_QUIT_WORKER)))
-          .build();
+      return WorkerServiceGrpc.bindService(this);
     }
   }
 
   /**
+   * A stub to allow clients to do asynchronous rpc calls to service WorkerService.
    */
-  public static final class WorkerServiceStub extends io.grpc.stub.AbstractStub<WorkerServiceStub> {
-    private WorkerServiceStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private WorkerServiceStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class WorkerServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<WorkerServiceStub> {
+    private WorkerServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected WorkerServiceStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected WorkerServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new WorkerServiceStub(channel, callOptions);
     }
 
@@ -205,8 +289,8 @@ protected WorkerServiceStub build(io.grpc.Channel channel,
      */
     public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ServerArgs> runServer(
         io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ServerStatus> responseObserver) {
-      return asyncBidiStreamingCall(
-          getChannel().newCall(METHOD_RUN_SERVER, getCallOptions()), responseObserver);
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getRunServerMethod(), getCallOptions()), responseObserver);
     }
 
     /**
@@ -221,8 +305,8 @@ public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ServerArgs>
      */
     public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ClientArgs> runClient(
         io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ClientStatus> responseObserver) {
-      return asyncBidiStreamingCall(
-          getChannel().newCall(METHOD_RUN_CLIENT, getCallOptions()), responseObserver);
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getRunClientMethod(), getCallOptions()), responseObserver);
     }
 
     /**
@@ -232,8 +316,8 @@ public io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.ClientArgs>
      */
     public void coreCount(io.grpc.benchmarks.proto.Control.CoreRequest request,
         io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.CoreResponse> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_CORE_COUNT, getCallOptions()), request, responseObserver);
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getCoreCountMethod(), getCallOptions()), request, responseObserver);
     }
 
     /**
@@ -243,26 +327,95 @@ public void coreCount(io.grpc.benchmarks.proto.Control.CoreRequest request,
      */
     public void quitWorker(io.grpc.benchmarks.proto.Control.Void request,
         io.grpc.stub.StreamObserver<io.grpc.benchmarks.proto.Control.Void> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_QUIT_WORKER, getCallOptions()), request, responseObserver);
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getQuitWorkerMethod(), getCallOptions()), request, responseObserver);
     }
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service WorkerService.
    */
-  public static final class WorkerServiceBlockingStub extends io.grpc.stub.AbstractStub<WorkerServiceBlockingStub> {
-    private WorkerServiceBlockingStub(io.grpc.Channel channel) {
-      super(channel);
+  public static final class WorkerServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<WorkerServiceBlockingV2Stub> {
+    private WorkerServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected WorkerServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new WorkerServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Start server with specified workload.
+     * First request sent specifies the ServerConfig followed by ServerStatus
+     * response. After that, a "Mark" can be sent anytime to request the latest
+     * stats. Closing the stream will initiate shutdown of the test server
+     * and once the shutdown has finished, the OK status is sent to terminate
+     * this RPC.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.benchmarks.proto.Control.ServerArgs, io.grpc.benchmarks.proto.Control.ServerStatus>
+        runServer() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getRunServerMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * Start client with specified workload.
+     * First request sent specifies the ClientConfig followed by ClientStatus
+     * response. After that, a "Mark" can be sent anytime to request the latest
+     * stats. Closing the stream will initiate shutdown of the test client
+     * and once the shutdown has finished, the OK status is sent to terminate
+     * this RPC.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.benchmarks.proto.Control.ClientArgs, io.grpc.benchmarks.proto.Control.ClientStatus>
+        runClient() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getRunClientMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * Just return the core count - unary call
+     * </pre>
+     */
+    public io.grpc.benchmarks.proto.Control.CoreResponse coreCount(io.grpc.benchmarks.proto.Control.CoreRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getCoreCountMethod(), getCallOptions(), request);
     }
 
-    private WorkerServiceBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    /**
+     * <pre>
+     * Quit this worker
+     * </pre>
+     */
+    public io.grpc.benchmarks.proto.Control.Void quitWorker(io.grpc.benchmarks.proto.Control.Void request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getQuitWorkerMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service WorkerService.
+   */
+  public static final class WorkerServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<WorkerServiceBlockingStub> {
+    private WorkerServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected WorkerServiceBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected WorkerServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new WorkerServiceBlockingStub(channel, callOptions);
     }
 
@@ -272,8 +425,8 @@ protected WorkerServiceBlockingStub build(io.grpc.Channel channel,
      * </pre>
      */
     public io.grpc.benchmarks.proto.Control.CoreResponse coreCount(io.grpc.benchmarks.proto.Control.CoreRequest request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_CORE_COUNT, getCallOptions(), request);
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getCoreCountMethod(), getCallOptions(), request);
     }
 
     /**
@@ -282,26 +435,24 @@ public io.grpc.benchmarks.proto.Control.CoreResponse coreCount(io.grpc.benchmark
      * </pre>
      */
     public io.grpc.benchmarks.proto.Control.Void quitWorker(io.grpc.benchmarks.proto.Control.Void request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_QUIT_WORKER, getCallOptions(), request);
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getQuitWorkerMethod(), getCallOptions(), request);
     }
   }
 
   /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service WorkerService.
    */
-  public static final class WorkerServiceFutureStub extends io.grpc.stub.AbstractStub<WorkerServiceFutureStub> {
-    private WorkerServiceFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private WorkerServiceFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class WorkerServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<WorkerServiceFutureStub> {
+    private WorkerServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected WorkerServiceFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected WorkerServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new WorkerServiceFutureStub(channel, callOptions);
     }
 
@@ -312,8 +463,8 @@ protected WorkerServiceFutureStub build(io.grpc.Channel channel,
      */
     public com.google.common.util.concurrent.ListenableFuture<io.grpc.benchmarks.proto.Control.CoreResponse> coreCount(
         io.grpc.benchmarks.proto.Control.CoreRequest request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_CORE_COUNT, getCallOptions()), request);
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getCoreCountMethod(), getCallOptions()), request);
     }
 
     /**
@@ -323,8 +474,8 @@ public com.google.common.util.concurrent.ListenableFuture<io.grpc.benchmarks.pro
      */
     public com.google.common.util.concurrent.ListenableFuture<io.grpc.benchmarks.proto.Control.Void> quitWorker(
         io.grpc.benchmarks.proto.Control.Void request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_QUIT_WORKER, getCallOptions()), request);
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getQuitWorkerMethod(), getCallOptions()), request);
     }
   }
 
@@ -338,10 +489,10 @@ private static final class MethodHandlers<Req, Resp> implements
       io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final WorkerServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(WorkerServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -380,11 +531,72 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
-  private static final class WorkerServiceDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getRunServerMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.benchmarks.proto.Control.ServerArgs,
+              io.grpc.benchmarks.proto.Control.ServerStatus>(
+                service, METHODID_RUN_SERVER)))
+        .addMethod(
+          getRunClientMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.benchmarks.proto.Control.ClientArgs,
+              io.grpc.benchmarks.proto.Control.ClientStatus>(
+                service, METHODID_RUN_CLIENT)))
+        .addMethod(
+          getCoreCountMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.benchmarks.proto.Control.CoreRequest,
+              io.grpc.benchmarks.proto.Control.CoreResponse>(
+                service, METHODID_CORE_COUNT)))
+        .addMethod(
+          getQuitWorkerMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.benchmarks.proto.Control.Void,
+              io.grpc.benchmarks.proto.Control.Void>(
+                service, METHODID_QUIT_WORKER)))
+        .build();
+  }
+
+  private static abstract class WorkerServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    WorkerServiceBaseDescriptorSupplier() {}
+
     @java.lang.Override
     public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
       return io.grpc.benchmarks.proto.Services.getDescriptor();
     }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("WorkerService");
+    }
+  }
+
+  private static final class WorkerServiceFileDescriptorSupplier
+      extends WorkerServiceBaseDescriptorSupplier {
+    WorkerServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class WorkerServiceMethodDescriptorSupplier
+      extends WorkerServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    WorkerServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
   }
 
   private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
@@ -396,11 +608,11 @@ public static io.grpc.ServiceDescriptor getServiceDescriptor() {
         result = serviceDescriptor;
         if (result == null) {
           serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new WorkerServiceDescriptorSupplier())
-              .addMethod(METHOD_RUN_SERVER)
-              .addMethod(METHOD_RUN_CLIENT)
-              .addMethod(METHOD_CORE_COUNT)
-              .addMethod(METHOD_QUIT_WORKER)
+              .setSchemaDescriptor(new WorkerServiceFileDescriptorSupplier())
+              .addMethod(getRunServerMethod())
+              .addMethod(getRunClientMethod())
+              .addMethod(getCoreCountMethod())
+              .addMethod(getQuitWorkerMethod())
               .build();
         }
       }
diff --git a/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Control.java b/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Control.java
deleted file mode 100644
index c43e879a65f..00000000000
--- a/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Control.java
+++ /dev/null
@@ -1,13044 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: control.proto
-
-package io.grpc.benchmarks.proto;
-
-public final class Control {
-  private Control() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  /**
-   * Protobuf enum {@code grpc.testing.ClientType}
-   */
-  public enum ClientType
-      implements com.google.protobuf.ProtocolMessageEnum {
-    /**
-     * <code>SYNC_CLIENT = 0;</code>
-     */
-    SYNC_CLIENT(0),
-    /**
-     * <code>ASYNC_CLIENT = 1;</code>
-     */
-    ASYNC_CLIENT(1),
-    UNRECOGNIZED(-1),
-    ;
-
-    /**
-     * <code>SYNC_CLIENT = 0;</code>
-     */
-    public static final int SYNC_CLIENT_VALUE = 0;
-    /**
-     * <code>ASYNC_CLIENT = 1;</code>
-     */
-    public static final int ASYNC_CLIENT_VALUE = 1;
-
-
-    public final int getNumber() {
-      if (this == UNRECOGNIZED) {
-        throw new java.lang.IllegalArgumentException(
-            "Can't get the number of an unknown enum value.");
-      }
-      return value;
-    }
-
-    /**
-     * @deprecated Use {@link #forNumber(int)} instead.
-     */
-    @java.lang.Deprecated
-    public static ClientType valueOf(int value) {
-      return forNumber(value);
-    }
-
-    public static ClientType forNumber(int value) {
-      switch (value) {
-        case 0: return SYNC_CLIENT;
-        case 1: return ASYNC_CLIENT;
-        default: return null;
-      }
-    }
-
-    public static com.google.protobuf.Internal.EnumLiteMap<ClientType>
-        internalGetValueMap() {
-      return internalValueMap;
-    }
-    private static final com.google.protobuf.Internal.EnumLiteMap<
-        ClientType> internalValueMap =
-          new com.google.protobuf.Internal.EnumLiteMap<ClientType>() {
-            public ClientType findValueByNumber(int number) {
-              return ClientType.forNumber(number);
-            }
-          };
-
-    public final com.google.protobuf.Descriptors.EnumValueDescriptor
-        getValueDescriptor() {
-      return getDescriptor().getValues().get(ordinal());
-    }
-    public final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptorForType() {
-      return getDescriptor();
-    }
-    public static final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.getDescriptor().getEnumTypes().get(0);
-    }
-
-    private static final ClientType[] VALUES = values();
-
-    public static ClientType valueOf(
-        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
-      if (desc.getType() != getDescriptor()) {
-        throw new java.lang.IllegalArgumentException(
-          "EnumValueDescriptor is not for this type.");
-      }
-      if (desc.getIndex() == -1) {
-        return UNRECOGNIZED;
-      }
-      return VALUES[desc.getIndex()];
-    }
-
-    private final int value;
-
-    private ClientType(int value) {
-      this.value = value;
-    }
-
-    // @@protoc_insertion_point(enum_scope:grpc.testing.ClientType)
-  }
-
-  /**
-   * Protobuf enum {@code grpc.testing.ServerType}
-   */
-  public enum ServerType
-      implements com.google.protobuf.ProtocolMessageEnum {
-    /**
-     * <code>SYNC_SERVER = 0;</code>
-     */
-    SYNC_SERVER(0),
-    /**
-     * <code>ASYNC_SERVER = 1;</code>
-     */
-    ASYNC_SERVER(1),
-    /**
-     * <code>ASYNC_GENERIC_SERVER = 2;</code>
-     */
-    ASYNC_GENERIC_SERVER(2),
-    UNRECOGNIZED(-1),
-    ;
-
-    /**
-     * <code>SYNC_SERVER = 0;</code>
-     */
-    public static final int SYNC_SERVER_VALUE = 0;
-    /**
-     * <code>ASYNC_SERVER = 1;</code>
-     */
-    public static final int ASYNC_SERVER_VALUE = 1;
-    /**
-     * <code>ASYNC_GENERIC_SERVER = 2;</code>
-     */
-    public static final int ASYNC_GENERIC_SERVER_VALUE = 2;
-
-
-    public final int getNumber() {
-      if (this == UNRECOGNIZED) {
-        throw new java.lang.IllegalArgumentException(
-            "Can't get the number of an unknown enum value.");
-      }
-      return value;
-    }
-
-    /**
-     * @deprecated Use {@link #forNumber(int)} instead.
-     */
-    @java.lang.Deprecated
-    public static ServerType valueOf(int value) {
-      return forNumber(value);
-    }
-
-    public static ServerType forNumber(int value) {
-      switch (value) {
-        case 0: return SYNC_SERVER;
-        case 1: return ASYNC_SERVER;
-        case 2: return ASYNC_GENERIC_SERVER;
-        default: return null;
-      }
-    }
-
-    public static com.google.protobuf.Internal.EnumLiteMap<ServerType>
-        internalGetValueMap() {
-      return internalValueMap;
-    }
-    private static final com.google.protobuf.Internal.EnumLiteMap<
-        ServerType> internalValueMap =
-          new com.google.protobuf.Internal.EnumLiteMap<ServerType>() {
-            public ServerType findValueByNumber(int number) {
-              return ServerType.forNumber(number);
-            }
-          };
-
-    public final com.google.protobuf.Descriptors.EnumValueDescriptor
-        getValueDescriptor() {
-      return getDescriptor().getValues().get(ordinal());
-    }
-    public final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptorForType() {
-      return getDescriptor();
-    }
-    public static final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.getDescriptor().getEnumTypes().get(1);
-    }
-
-    private static final ServerType[] VALUES = values();
-
-    public static ServerType valueOf(
-        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
-      if (desc.getType() != getDescriptor()) {
-        throw new java.lang.IllegalArgumentException(
-          "EnumValueDescriptor is not for this type.");
-      }
-      if (desc.getIndex() == -1) {
-        return UNRECOGNIZED;
-      }
-      return VALUES[desc.getIndex()];
-    }
-
-    private final int value;
-
-    private ServerType(int value) {
-      this.value = value;
-    }
-
-    // @@protoc_insertion_point(enum_scope:grpc.testing.ServerType)
-  }
-
-  /**
-   * Protobuf enum {@code grpc.testing.RpcType}
-   */
-  public enum RpcType
-      implements com.google.protobuf.ProtocolMessageEnum {
-    /**
-     * <code>UNARY = 0;</code>
-     */
-    UNARY(0),
-    /**
-     * <code>STREAMING = 1;</code>
-     */
-    STREAMING(1),
-    UNRECOGNIZED(-1),
-    ;
-
-    /**
-     * <code>UNARY = 0;</code>
-     */
-    public static final int UNARY_VALUE = 0;
-    /**
-     * <code>STREAMING = 1;</code>
-     */
-    public static final int STREAMING_VALUE = 1;
-
-
-    public final int getNumber() {
-      if (this == UNRECOGNIZED) {
-        throw new java.lang.IllegalArgumentException(
-            "Can't get the number of an unknown enum value.");
-      }
-      return value;
-    }
-
-    /**
-     * @deprecated Use {@link #forNumber(int)} instead.
-     */
-    @java.lang.Deprecated
-    public static RpcType valueOf(int value) {
-      return forNumber(value);
-    }
-
-    public static RpcType forNumber(int value) {
-      switch (value) {
-        case 0: return UNARY;
-        case 1: return STREAMING;
-        default: return null;
-      }
-    }
-
-    public static com.google.protobuf.Internal.EnumLiteMap<RpcType>
-        internalGetValueMap() {
-      return internalValueMap;
-    }
-    private static final com.google.protobuf.Internal.EnumLiteMap<
-        RpcType> internalValueMap =
-          new com.google.protobuf.Internal.EnumLiteMap<RpcType>() {
-            public RpcType findValueByNumber(int number) {
-              return RpcType.forNumber(number);
-            }
-          };
-
-    public final com.google.protobuf.Descriptors.EnumValueDescriptor
-        getValueDescriptor() {
-      return getDescriptor().getValues().get(ordinal());
-    }
-    public final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptorForType() {
-      return getDescriptor();
-    }
-    public static final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.getDescriptor().getEnumTypes().get(2);
-    }
-
-    private static final RpcType[] VALUES = values();
-
-    public static RpcType valueOf(
-        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
-      if (desc.getType() != getDescriptor()) {
-        throw new java.lang.IllegalArgumentException(
-          "EnumValueDescriptor is not for this type.");
-      }
-      if (desc.getIndex() == -1) {
-        return UNRECOGNIZED;
-      }
-      return VALUES[desc.getIndex()];
-    }
-
-    private final int value;
-
-    private RpcType(int value) {
-      this.value = value;
-    }
-
-    // @@protoc_insertion_point(enum_scope:grpc.testing.RpcType)
-  }
-
-  public interface PoissonParamsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.PoissonParams)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * The rate of arrivals (a.k.a. lambda parameter of the exp distribution).
-     * </pre>
-     *
-     * <code>double offered_load = 1;</code>
-     */
-    double getOfferedLoad();
-  }
-  /**
-   * <pre>
-   * Parameters of poisson process distribution, which is a good representation
-   * of activity coming in from independent identical stationary sources.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.PoissonParams}
-   */
-  public  static final class PoissonParams extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.PoissonParams)
-      PoissonParamsOrBuilder {
-    // Use PoissonParams.newBuilder() to construct.
-    private PoissonParams(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private PoissonParams() {
-      offeredLoad_ = 0D;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private PoissonParams(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 9: {
-
-              offeredLoad_ = input.readDouble();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_PoissonParams_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_PoissonParams_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.PoissonParams.class, io.grpc.benchmarks.proto.Control.PoissonParams.Builder.class);
-    }
-
-    public static final int OFFERED_LOAD_FIELD_NUMBER = 1;
-    private double offeredLoad_;
-    /**
-     * <pre>
-     * The rate of arrivals (a.k.a. lambda parameter of the exp distribution).
-     * </pre>
-     *
-     * <code>double offered_load = 1;</code>
-     */
-    public double getOfferedLoad() {
-      return offeredLoad_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (offeredLoad_ != 0D) {
-        output.writeDouble(1, offeredLoad_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (offeredLoad_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(1, offeredLoad_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.PoissonParams)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.PoissonParams other = (io.grpc.benchmarks.proto.Control.PoissonParams) obj;
-
-      boolean result = true;
-      result = result && (
-          java.lang.Double.doubleToLongBits(getOfferedLoad())
-          == java.lang.Double.doubleToLongBits(
-              other.getOfferedLoad()));
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + OFFERED_LOAD_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getOfferedLoad()));
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.PoissonParams parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.PoissonParams parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.PoissonParams parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.PoissonParams parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.PoissonParams parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.PoissonParams parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.PoissonParams parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.PoissonParams parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.PoissonParams parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.PoissonParams parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.PoissonParams prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Parameters of poisson process distribution, which is a good representation
-     * of activity coming in from independent identical stationary sources.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.PoissonParams}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.PoissonParams)
-        io.grpc.benchmarks.proto.Control.PoissonParamsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_PoissonParams_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_PoissonParams_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.PoissonParams.class, io.grpc.benchmarks.proto.Control.PoissonParams.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.PoissonParams.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        offeredLoad_ = 0D;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_PoissonParams_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.PoissonParams getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.PoissonParams.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.PoissonParams build() {
-        io.grpc.benchmarks.proto.Control.PoissonParams result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.PoissonParams buildPartial() {
-        io.grpc.benchmarks.proto.Control.PoissonParams result = new io.grpc.benchmarks.proto.Control.PoissonParams(this);
-        result.offeredLoad_ = offeredLoad_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.PoissonParams) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.PoissonParams)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.PoissonParams other) {
-        if (other == io.grpc.benchmarks.proto.Control.PoissonParams.getDefaultInstance()) return this;
-        if (other.getOfferedLoad() != 0D) {
-          setOfferedLoad(other.getOfferedLoad());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.PoissonParams parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.PoissonParams) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private double offeredLoad_ ;
-      /**
-       * <pre>
-       * The rate of arrivals (a.k.a. lambda parameter of the exp distribution).
-       * </pre>
-       *
-       * <code>double offered_load = 1;</code>
-       */
-      public double getOfferedLoad() {
-        return offeredLoad_;
-      }
-      /**
-       * <pre>
-       * The rate of arrivals (a.k.a. lambda parameter of the exp distribution).
-       * </pre>
-       *
-       * <code>double offered_load = 1;</code>
-       */
-      public Builder setOfferedLoad(double value) {
-        
-        offeredLoad_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * The rate of arrivals (a.k.a. lambda parameter of the exp distribution).
-       * </pre>
-       *
-       * <code>double offered_load = 1;</code>
-       */
-      public Builder clearOfferedLoad() {
-        
-        offeredLoad_ = 0D;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.PoissonParams)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.PoissonParams)
-    private static final io.grpc.benchmarks.proto.Control.PoissonParams DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.PoissonParams();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.PoissonParams getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<PoissonParams>
-        PARSER = new com.google.protobuf.AbstractParser<PoissonParams>() {
-      public PoissonParams parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new PoissonParams(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<PoissonParams> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<PoissonParams> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.PoissonParams getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface UniformParamsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.UniformParams)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>double interarrival_lo = 1;</code>
-     */
-    double getInterarrivalLo();
-
-    /**
-     * <code>double interarrival_hi = 2;</code>
-     */
-    double getInterarrivalHi();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.UniformParams}
-   */
-  public  static final class UniformParams extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.UniformParams)
-      UniformParamsOrBuilder {
-    // Use UniformParams.newBuilder() to construct.
-    private UniformParams(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private UniformParams() {
-      interarrivalLo_ = 0D;
-      interarrivalHi_ = 0D;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private UniformParams(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 9: {
-
-              interarrivalLo_ = input.readDouble();
-              break;
-            }
-            case 17: {
-
-              interarrivalHi_ = input.readDouble();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_UniformParams_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_UniformParams_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.UniformParams.class, io.grpc.benchmarks.proto.Control.UniformParams.Builder.class);
-    }
-
-    public static final int INTERARRIVAL_LO_FIELD_NUMBER = 1;
-    private double interarrivalLo_;
-    /**
-     * <code>double interarrival_lo = 1;</code>
-     */
-    public double getInterarrivalLo() {
-      return interarrivalLo_;
-    }
-
-    public static final int INTERARRIVAL_HI_FIELD_NUMBER = 2;
-    private double interarrivalHi_;
-    /**
-     * <code>double interarrival_hi = 2;</code>
-     */
-    public double getInterarrivalHi() {
-      return interarrivalHi_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (interarrivalLo_ != 0D) {
-        output.writeDouble(1, interarrivalLo_);
-      }
-      if (interarrivalHi_ != 0D) {
-        output.writeDouble(2, interarrivalHi_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (interarrivalLo_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(1, interarrivalLo_);
-      }
-      if (interarrivalHi_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(2, interarrivalHi_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.UniformParams)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.UniformParams other = (io.grpc.benchmarks.proto.Control.UniformParams) obj;
-
-      boolean result = true;
-      result = result && (
-          java.lang.Double.doubleToLongBits(getInterarrivalLo())
-          == java.lang.Double.doubleToLongBits(
-              other.getInterarrivalLo()));
-      result = result && (
-          java.lang.Double.doubleToLongBits(getInterarrivalHi())
-          == java.lang.Double.doubleToLongBits(
-              other.getInterarrivalHi()));
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + INTERARRIVAL_LO_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getInterarrivalLo()));
-      hash = (37 * hash) + INTERARRIVAL_HI_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getInterarrivalHi()));
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.UniformParams parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.UniformParams parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.UniformParams parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.UniformParams parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.UniformParams parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.UniformParams parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.UniformParams parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.UniformParams parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.UniformParams parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.UniformParams parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.UniformParams prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.UniformParams}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.UniformParams)
-        io.grpc.benchmarks.proto.Control.UniformParamsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_UniformParams_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_UniformParams_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.UniformParams.class, io.grpc.benchmarks.proto.Control.UniformParams.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.UniformParams.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        interarrivalLo_ = 0D;
-
-        interarrivalHi_ = 0D;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_UniformParams_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.UniformParams getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.UniformParams.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.UniformParams build() {
-        io.grpc.benchmarks.proto.Control.UniformParams result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.UniformParams buildPartial() {
-        io.grpc.benchmarks.proto.Control.UniformParams result = new io.grpc.benchmarks.proto.Control.UniformParams(this);
-        result.interarrivalLo_ = interarrivalLo_;
-        result.interarrivalHi_ = interarrivalHi_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.UniformParams) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.UniformParams)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.UniformParams other) {
-        if (other == io.grpc.benchmarks.proto.Control.UniformParams.getDefaultInstance()) return this;
-        if (other.getInterarrivalLo() != 0D) {
-          setInterarrivalLo(other.getInterarrivalLo());
-        }
-        if (other.getInterarrivalHi() != 0D) {
-          setInterarrivalHi(other.getInterarrivalHi());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.UniformParams parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.UniformParams) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private double interarrivalLo_ ;
-      /**
-       * <code>double interarrival_lo = 1;</code>
-       */
-      public double getInterarrivalLo() {
-        return interarrivalLo_;
-      }
-      /**
-       * <code>double interarrival_lo = 1;</code>
-       */
-      public Builder setInterarrivalLo(double value) {
-        
-        interarrivalLo_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>double interarrival_lo = 1;</code>
-       */
-      public Builder clearInterarrivalLo() {
-        
-        interarrivalLo_ = 0D;
-        onChanged();
-        return this;
-      }
-
-      private double interarrivalHi_ ;
-      /**
-       * <code>double interarrival_hi = 2;</code>
-       */
-      public double getInterarrivalHi() {
-        return interarrivalHi_;
-      }
-      /**
-       * <code>double interarrival_hi = 2;</code>
-       */
-      public Builder setInterarrivalHi(double value) {
-        
-        interarrivalHi_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>double interarrival_hi = 2;</code>
-       */
-      public Builder clearInterarrivalHi() {
-        
-        interarrivalHi_ = 0D;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.UniformParams)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.UniformParams)
-    private static final io.grpc.benchmarks.proto.Control.UniformParams DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.UniformParams();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.UniformParams getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<UniformParams>
-        PARSER = new com.google.protobuf.AbstractParser<UniformParams>() {
-      public UniformParams parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new UniformParams(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<UniformParams> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<UniformParams> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.UniformParams getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface DeterministicParamsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.DeterministicParams)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>double offered_load = 1;</code>
-     */
-    double getOfferedLoad();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.DeterministicParams}
-   */
-  public  static final class DeterministicParams extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.DeterministicParams)
-      DeterministicParamsOrBuilder {
-    // Use DeterministicParams.newBuilder() to construct.
-    private DeterministicParams(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private DeterministicParams() {
-      offeredLoad_ = 0D;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private DeterministicParams(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 9: {
-
-              offeredLoad_ = input.readDouble();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_DeterministicParams_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_DeterministicParams_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.DeterministicParams.class, io.grpc.benchmarks.proto.Control.DeterministicParams.Builder.class);
-    }
-
-    public static final int OFFERED_LOAD_FIELD_NUMBER = 1;
-    private double offeredLoad_;
-    /**
-     * <code>double offered_load = 1;</code>
-     */
-    public double getOfferedLoad() {
-      return offeredLoad_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (offeredLoad_ != 0D) {
-        output.writeDouble(1, offeredLoad_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (offeredLoad_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(1, offeredLoad_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.DeterministicParams)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.DeterministicParams other = (io.grpc.benchmarks.proto.Control.DeterministicParams) obj;
-
-      boolean result = true;
-      result = result && (
-          java.lang.Double.doubleToLongBits(getOfferedLoad())
-          == java.lang.Double.doubleToLongBits(
-              other.getOfferedLoad()));
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + OFFERED_LOAD_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getOfferedLoad()));
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.DeterministicParams parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.DeterministicParams parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.DeterministicParams parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.DeterministicParams parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.DeterministicParams parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.DeterministicParams parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.DeterministicParams parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.DeterministicParams parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.DeterministicParams parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.DeterministicParams parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.DeterministicParams prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.DeterministicParams}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.DeterministicParams)
-        io.grpc.benchmarks.proto.Control.DeterministicParamsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_DeterministicParams_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_DeterministicParams_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.DeterministicParams.class, io.grpc.benchmarks.proto.Control.DeterministicParams.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.DeterministicParams.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        offeredLoad_ = 0D;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_DeterministicParams_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.DeterministicParams getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.DeterministicParams.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.DeterministicParams build() {
-        io.grpc.benchmarks.proto.Control.DeterministicParams result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.DeterministicParams buildPartial() {
-        io.grpc.benchmarks.proto.Control.DeterministicParams result = new io.grpc.benchmarks.proto.Control.DeterministicParams(this);
-        result.offeredLoad_ = offeredLoad_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.DeterministicParams) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.DeterministicParams)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.DeterministicParams other) {
-        if (other == io.grpc.benchmarks.proto.Control.DeterministicParams.getDefaultInstance()) return this;
-        if (other.getOfferedLoad() != 0D) {
-          setOfferedLoad(other.getOfferedLoad());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.DeterministicParams parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.DeterministicParams) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private double offeredLoad_ ;
-      /**
-       * <code>double offered_load = 1;</code>
-       */
-      public double getOfferedLoad() {
-        return offeredLoad_;
-      }
-      /**
-       * <code>double offered_load = 1;</code>
-       */
-      public Builder setOfferedLoad(double value) {
-        
-        offeredLoad_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>double offered_load = 1;</code>
-       */
-      public Builder clearOfferedLoad() {
-        
-        offeredLoad_ = 0D;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.DeterministicParams)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.DeterministicParams)
-    private static final io.grpc.benchmarks.proto.Control.DeterministicParams DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.DeterministicParams();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.DeterministicParams getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<DeterministicParams>
-        PARSER = new com.google.protobuf.AbstractParser<DeterministicParams>() {
-      public DeterministicParams parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new DeterministicParams(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<DeterministicParams> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<DeterministicParams> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.DeterministicParams getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ParetoParamsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ParetoParams)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>double interarrival_base = 1;</code>
-     */
-    double getInterarrivalBase();
-
-    /**
-     * <code>double alpha = 2;</code>
-     */
-    double getAlpha();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.ParetoParams}
-   */
-  public  static final class ParetoParams extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ParetoParams)
-      ParetoParamsOrBuilder {
-    // Use ParetoParams.newBuilder() to construct.
-    private ParetoParams(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ParetoParams() {
-      interarrivalBase_ = 0D;
-      alpha_ = 0D;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ParetoParams(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 9: {
-
-              interarrivalBase_ = input.readDouble();
-              break;
-            }
-            case 17: {
-
-              alpha_ = input.readDouble();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ParetoParams_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ParetoParams_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.ParetoParams.class, io.grpc.benchmarks.proto.Control.ParetoParams.Builder.class);
-    }
-
-    public static final int INTERARRIVAL_BASE_FIELD_NUMBER = 1;
-    private double interarrivalBase_;
-    /**
-     * <code>double interarrival_base = 1;</code>
-     */
-    public double getInterarrivalBase() {
-      return interarrivalBase_;
-    }
-
-    public static final int ALPHA_FIELD_NUMBER = 2;
-    private double alpha_;
-    /**
-     * <code>double alpha = 2;</code>
-     */
-    public double getAlpha() {
-      return alpha_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (interarrivalBase_ != 0D) {
-        output.writeDouble(1, interarrivalBase_);
-      }
-      if (alpha_ != 0D) {
-        output.writeDouble(2, alpha_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (interarrivalBase_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(1, interarrivalBase_);
-      }
-      if (alpha_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(2, alpha_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.ParetoParams)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.ParetoParams other = (io.grpc.benchmarks.proto.Control.ParetoParams) obj;
-
-      boolean result = true;
-      result = result && (
-          java.lang.Double.doubleToLongBits(getInterarrivalBase())
-          == java.lang.Double.doubleToLongBits(
-              other.getInterarrivalBase()));
-      result = result && (
-          java.lang.Double.doubleToLongBits(getAlpha())
-          == java.lang.Double.doubleToLongBits(
-              other.getAlpha()));
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + INTERARRIVAL_BASE_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getInterarrivalBase()));
-      hash = (37 * hash) + ALPHA_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getAlpha()));
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ParetoParams parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ParetoParams parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ParetoParams parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ParetoParams parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ParetoParams parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ParetoParams parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ParetoParams parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ParetoParams parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ParetoParams parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ParetoParams parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.ParetoParams prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.ParetoParams}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ParetoParams)
-        io.grpc.benchmarks.proto.Control.ParetoParamsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ParetoParams_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ParetoParams_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.ParetoParams.class, io.grpc.benchmarks.proto.Control.ParetoParams.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.ParetoParams.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        interarrivalBase_ = 0D;
-
-        alpha_ = 0D;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ParetoParams_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ParetoParams getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.ParetoParams.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.ParetoParams build() {
-        io.grpc.benchmarks.proto.Control.ParetoParams result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ParetoParams buildPartial() {
-        io.grpc.benchmarks.proto.Control.ParetoParams result = new io.grpc.benchmarks.proto.Control.ParetoParams(this);
-        result.interarrivalBase_ = interarrivalBase_;
-        result.alpha_ = alpha_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.ParetoParams) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.ParetoParams)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.ParetoParams other) {
-        if (other == io.grpc.benchmarks.proto.Control.ParetoParams.getDefaultInstance()) return this;
-        if (other.getInterarrivalBase() != 0D) {
-          setInterarrivalBase(other.getInterarrivalBase());
-        }
-        if (other.getAlpha() != 0D) {
-          setAlpha(other.getAlpha());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.ParetoParams parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.ParetoParams) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private double interarrivalBase_ ;
-      /**
-       * <code>double interarrival_base = 1;</code>
-       */
-      public double getInterarrivalBase() {
-        return interarrivalBase_;
-      }
-      /**
-       * <code>double interarrival_base = 1;</code>
-       */
-      public Builder setInterarrivalBase(double value) {
-        
-        interarrivalBase_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>double interarrival_base = 1;</code>
-       */
-      public Builder clearInterarrivalBase() {
-        
-        interarrivalBase_ = 0D;
-        onChanged();
-        return this;
-      }
-
-      private double alpha_ ;
-      /**
-       * <code>double alpha = 2;</code>
-       */
-      public double getAlpha() {
-        return alpha_;
-      }
-      /**
-       * <code>double alpha = 2;</code>
-       */
-      public Builder setAlpha(double value) {
-        
-        alpha_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>double alpha = 2;</code>
-       */
-      public Builder clearAlpha() {
-        
-        alpha_ = 0D;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ParetoParams)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ParetoParams)
-    private static final io.grpc.benchmarks.proto.Control.ParetoParams DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.ParetoParams();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ParetoParams getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ParetoParams>
-        PARSER = new com.google.protobuf.AbstractParser<ParetoParams>() {
-      public ParetoParams parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ParetoParams(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ParetoParams> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ParetoParams> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.ParetoParams getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ClosedLoopParamsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ClosedLoopParams)
-      com.google.protobuf.MessageOrBuilder {
-  }
-  /**
-   * <pre>
-   * Once an RPC finishes, immediately start a new one.
-   * No configuration parameters needed.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.ClosedLoopParams}
-   */
-  public  static final class ClosedLoopParams extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ClosedLoopParams)
-      ClosedLoopParamsOrBuilder {
-    // Use ClosedLoopParams.newBuilder() to construct.
-    private ClosedLoopParams(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ClosedLoopParams() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ClosedLoopParams(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClosedLoopParams_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClosedLoopParams_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.ClosedLoopParams.class, io.grpc.benchmarks.proto.Control.ClosedLoopParams.Builder.class);
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.ClosedLoopParams)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.ClosedLoopParams other = (io.grpc.benchmarks.proto.Control.ClosedLoopParams) obj;
-
-      boolean result = true;
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ClosedLoopParams parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClosedLoopParams parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClosedLoopParams parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClosedLoopParams parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClosedLoopParams parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClosedLoopParams parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClosedLoopParams parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClosedLoopParams parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClosedLoopParams parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClosedLoopParams parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.ClosedLoopParams prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Once an RPC finishes, immediately start a new one.
-     * No configuration parameters needed.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.ClosedLoopParams}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ClosedLoopParams)
-        io.grpc.benchmarks.proto.Control.ClosedLoopParamsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClosedLoopParams_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClosedLoopParams_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.ClosedLoopParams.class, io.grpc.benchmarks.proto.Control.ClosedLoopParams.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.ClosedLoopParams.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClosedLoopParams_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ClosedLoopParams getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.ClosedLoopParams.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.ClosedLoopParams build() {
-        io.grpc.benchmarks.proto.Control.ClosedLoopParams result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ClosedLoopParams buildPartial() {
-        io.grpc.benchmarks.proto.Control.ClosedLoopParams result = new io.grpc.benchmarks.proto.Control.ClosedLoopParams(this);
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.ClosedLoopParams) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.ClosedLoopParams)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.ClosedLoopParams other) {
-        if (other == io.grpc.benchmarks.proto.Control.ClosedLoopParams.getDefaultInstance()) return this;
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.ClosedLoopParams parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.ClosedLoopParams) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ClosedLoopParams)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ClosedLoopParams)
-    private static final io.grpc.benchmarks.proto.Control.ClosedLoopParams DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.ClosedLoopParams();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ClosedLoopParams getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ClosedLoopParams>
-        PARSER = new com.google.protobuf.AbstractParser<ClosedLoopParams>() {
-      public ClosedLoopParams parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ClosedLoopParams(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ClosedLoopParams> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ClosedLoopParams> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.ClosedLoopParams getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface LoadParamsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.LoadParams)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>.grpc.testing.ClosedLoopParams closed_loop = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Control.ClosedLoopParams getClosedLoop();
-    /**
-     * <code>.grpc.testing.ClosedLoopParams closed_loop = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Control.ClosedLoopParamsOrBuilder getClosedLoopOrBuilder();
-
-    /**
-     * <code>.grpc.testing.PoissonParams poisson = 2;</code>
-     */
-    io.grpc.benchmarks.proto.Control.PoissonParams getPoisson();
-    /**
-     * <code>.grpc.testing.PoissonParams poisson = 2;</code>
-     */
-    io.grpc.benchmarks.proto.Control.PoissonParamsOrBuilder getPoissonOrBuilder();
-
-    /**
-     * <code>.grpc.testing.UniformParams uniform = 3;</code>
-     */
-    io.grpc.benchmarks.proto.Control.UniformParams getUniform();
-    /**
-     * <code>.grpc.testing.UniformParams uniform = 3;</code>
-     */
-    io.grpc.benchmarks.proto.Control.UniformParamsOrBuilder getUniformOrBuilder();
-
-    /**
-     * <code>.grpc.testing.DeterministicParams determ = 4;</code>
-     */
-    io.grpc.benchmarks.proto.Control.DeterministicParams getDeterm();
-    /**
-     * <code>.grpc.testing.DeterministicParams determ = 4;</code>
-     */
-    io.grpc.benchmarks.proto.Control.DeterministicParamsOrBuilder getDetermOrBuilder();
-
-    /**
-     * <code>.grpc.testing.ParetoParams pareto = 5;</code>
-     */
-    io.grpc.benchmarks.proto.Control.ParetoParams getPareto();
-    /**
-     * <code>.grpc.testing.ParetoParams pareto = 5;</code>
-     */
-    io.grpc.benchmarks.proto.Control.ParetoParamsOrBuilder getParetoOrBuilder();
-
-    public io.grpc.benchmarks.proto.Control.LoadParams.LoadCase getLoadCase();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.LoadParams}
-   */
-  public  static final class LoadParams extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.LoadParams)
-      LoadParamsOrBuilder {
-    // Use LoadParams.newBuilder() to construct.
-    private LoadParams(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private LoadParams() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private LoadParams(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              io.grpc.benchmarks.proto.Control.ClosedLoopParams.Builder subBuilder = null;
-              if (loadCase_ == 1) {
-                subBuilder = ((io.grpc.benchmarks.proto.Control.ClosedLoopParams) load_).toBuilder();
-              }
-              load_ =
-                  input.readMessage(io.grpc.benchmarks.proto.Control.ClosedLoopParams.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom((io.grpc.benchmarks.proto.Control.ClosedLoopParams) load_);
-                load_ = subBuilder.buildPartial();
-              }
-              loadCase_ = 1;
-              break;
-            }
-            case 18: {
-              io.grpc.benchmarks.proto.Control.PoissonParams.Builder subBuilder = null;
-              if (loadCase_ == 2) {
-                subBuilder = ((io.grpc.benchmarks.proto.Control.PoissonParams) load_).toBuilder();
-              }
-              load_ =
-                  input.readMessage(io.grpc.benchmarks.proto.Control.PoissonParams.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom((io.grpc.benchmarks.proto.Control.PoissonParams) load_);
-                load_ = subBuilder.buildPartial();
-              }
-              loadCase_ = 2;
-              break;
-            }
-            case 26: {
-              io.grpc.benchmarks.proto.Control.UniformParams.Builder subBuilder = null;
-              if (loadCase_ == 3) {
-                subBuilder = ((io.grpc.benchmarks.proto.Control.UniformParams) load_).toBuilder();
-              }
-              load_ =
-                  input.readMessage(io.grpc.benchmarks.proto.Control.UniformParams.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom((io.grpc.benchmarks.proto.Control.UniformParams) load_);
-                load_ = subBuilder.buildPartial();
-              }
-              loadCase_ = 3;
-              break;
-            }
-            case 34: {
-              io.grpc.benchmarks.proto.Control.DeterministicParams.Builder subBuilder = null;
-              if (loadCase_ == 4) {
-                subBuilder = ((io.grpc.benchmarks.proto.Control.DeterministicParams) load_).toBuilder();
-              }
-              load_ =
-                  input.readMessage(io.grpc.benchmarks.proto.Control.DeterministicParams.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom((io.grpc.benchmarks.proto.Control.DeterministicParams) load_);
-                load_ = subBuilder.buildPartial();
-              }
-              loadCase_ = 4;
-              break;
-            }
-            case 42: {
-              io.grpc.benchmarks.proto.Control.ParetoParams.Builder subBuilder = null;
-              if (loadCase_ == 5) {
-                subBuilder = ((io.grpc.benchmarks.proto.Control.ParetoParams) load_).toBuilder();
-              }
-              load_ =
-                  input.readMessage(io.grpc.benchmarks.proto.Control.ParetoParams.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom((io.grpc.benchmarks.proto.Control.ParetoParams) load_);
-                load_ = subBuilder.buildPartial();
-              }
-              loadCase_ = 5;
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_LoadParams_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_LoadParams_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.LoadParams.class, io.grpc.benchmarks.proto.Control.LoadParams.Builder.class);
-    }
-
-    private int loadCase_ = 0;
-    private java.lang.Object load_;
-    public enum LoadCase
-        implements com.google.protobuf.Internal.EnumLite {
-      CLOSED_LOOP(1),
-      POISSON(2),
-      UNIFORM(3),
-      DETERM(4),
-      PARETO(5),
-      LOAD_NOT_SET(0);
-      private final int value;
-      private LoadCase(int value) {
-        this.value = value;
-      }
-      /**
-       * @deprecated Use {@link #forNumber(int)} instead.
-       */
-      @java.lang.Deprecated
-      public static LoadCase valueOf(int value) {
-        return forNumber(value);
-      }
-
-      public static LoadCase forNumber(int value) {
-        switch (value) {
-          case 1: return CLOSED_LOOP;
-          case 2: return POISSON;
-          case 3: return UNIFORM;
-          case 4: return DETERM;
-          case 5: return PARETO;
-          case 0: return LOAD_NOT_SET;
-          default: return null;
-        }
-      }
-      public int getNumber() {
-        return this.value;
-      }
-    };
-
-    public LoadCase
-    getLoadCase() {
-      return LoadCase.forNumber(
-          loadCase_);
-    }
-
-    public static final int CLOSED_LOOP_FIELD_NUMBER = 1;
-    /**
-     * <code>.grpc.testing.ClosedLoopParams closed_loop = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.ClosedLoopParams getClosedLoop() {
-      if (loadCase_ == 1) {
-         return (io.grpc.benchmarks.proto.Control.ClosedLoopParams) load_;
-      }
-      return io.grpc.benchmarks.proto.Control.ClosedLoopParams.getDefaultInstance();
-    }
-    /**
-     * <code>.grpc.testing.ClosedLoopParams closed_loop = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.ClosedLoopParamsOrBuilder getClosedLoopOrBuilder() {
-      if (loadCase_ == 1) {
-         return (io.grpc.benchmarks.proto.Control.ClosedLoopParams) load_;
-      }
-      return io.grpc.benchmarks.proto.Control.ClosedLoopParams.getDefaultInstance();
-    }
-
-    public static final int POISSON_FIELD_NUMBER = 2;
-    /**
-     * <code>.grpc.testing.PoissonParams poisson = 2;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.PoissonParams getPoisson() {
-      if (loadCase_ == 2) {
-         return (io.grpc.benchmarks.proto.Control.PoissonParams) load_;
-      }
-      return io.grpc.benchmarks.proto.Control.PoissonParams.getDefaultInstance();
-    }
-    /**
-     * <code>.grpc.testing.PoissonParams poisson = 2;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.PoissonParamsOrBuilder getPoissonOrBuilder() {
-      if (loadCase_ == 2) {
-         return (io.grpc.benchmarks.proto.Control.PoissonParams) load_;
-      }
-      return io.grpc.benchmarks.proto.Control.PoissonParams.getDefaultInstance();
-    }
-
-    public static final int UNIFORM_FIELD_NUMBER = 3;
-    /**
-     * <code>.grpc.testing.UniformParams uniform = 3;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.UniformParams getUniform() {
-      if (loadCase_ == 3) {
-         return (io.grpc.benchmarks.proto.Control.UniformParams) load_;
-      }
-      return io.grpc.benchmarks.proto.Control.UniformParams.getDefaultInstance();
-    }
-    /**
-     * <code>.grpc.testing.UniformParams uniform = 3;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.UniformParamsOrBuilder getUniformOrBuilder() {
-      if (loadCase_ == 3) {
-         return (io.grpc.benchmarks.proto.Control.UniformParams) load_;
-      }
-      return io.grpc.benchmarks.proto.Control.UniformParams.getDefaultInstance();
-    }
-
-    public static final int DETERM_FIELD_NUMBER = 4;
-    /**
-     * <code>.grpc.testing.DeterministicParams determ = 4;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.DeterministicParams getDeterm() {
-      if (loadCase_ == 4) {
-         return (io.grpc.benchmarks.proto.Control.DeterministicParams) load_;
-      }
-      return io.grpc.benchmarks.proto.Control.DeterministicParams.getDefaultInstance();
-    }
-    /**
-     * <code>.grpc.testing.DeterministicParams determ = 4;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.DeterministicParamsOrBuilder getDetermOrBuilder() {
-      if (loadCase_ == 4) {
-         return (io.grpc.benchmarks.proto.Control.DeterministicParams) load_;
-      }
-      return io.grpc.benchmarks.proto.Control.DeterministicParams.getDefaultInstance();
-    }
-
-    public static final int PARETO_FIELD_NUMBER = 5;
-    /**
-     * <code>.grpc.testing.ParetoParams pareto = 5;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.ParetoParams getPareto() {
-      if (loadCase_ == 5) {
-         return (io.grpc.benchmarks.proto.Control.ParetoParams) load_;
-      }
-      return io.grpc.benchmarks.proto.Control.ParetoParams.getDefaultInstance();
-    }
-    /**
-     * <code>.grpc.testing.ParetoParams pareto = 5;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.ParetoParamsOrBuilder getParetoOrBuilder() {
-      if (loadCase_ == 5) {
-         return (io.grpc.benchmarks.proto.Control.ParetoParams) load_;
-      }
-      return io.grpc.benchmarks.proto.Control.ParetoParams.getDefaultInstance();
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (loadCase_ == 1) {
-        output.writeMessage(1, (io.grpc.benchmarks.proto.Control.ClosedLoopParams) load_);
-      }
-      if (loadCase_ == 2) {
-        output.writeMessage(2, (io.grpc.benchmarks.proto.Control.PoissonParams) load_);
-      }
-      if (loadCase_ == 3) {
-        output.writeMessage(3, (io.grpc.benchmarks.proto.Control.UniformParams) load_);
-      }
-      if (loadCase_ == 4) {
-        output.writeMessage(4, (io.grpc.benchmarks.proto.Control.DeterministicParams) load_);
-      }
-      if (loadCase_ == 5) {
-        output.writeMessage(5, (io.grpc.benchmarks.proto.Control.ParetoParams) load_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (loadCase_ == 1) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, (io.grpc.benchmarks.proto.Control.ClosedLoopParams) load_);
-      }
-      if (loadCase_ == 2) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(2, (io.grpc.benchmarks.proto.Control.PoissonParams) load_);
-      }
-      if (loadCase_ == 3) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(3, (io.grpc.benchmarks.proto.Control.UniformParams) load_);
-      }
-      if (loadCase_ == 4) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(4, (io.grpc.benchmarks.proto.Control.DeterministicParams) load_);
-      }
-      if (loadCase_ == 5) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(5, (io.grpc.benchmarks.proto.Control.ParetoParams) load_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.LoadParams)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.LoadParams other = (io.grpc.benchmarks.proto.Control.LoadParams) obj;
-
-      boolean result = true;
-      result = result && getLoadCase().equals(
-          other.getLoadCase());
-      if (!result) return false;
-      switch (loadCase_) {
-        case 1:
-          result = result && getClosedLoop()
-              .equals(other.getClosedLoop());
-          break;
-        case 2:
-          result = result && getPoisson()
-              .equals(other.getPoisson());
-          break;
-        case 3:
-          result = result && getUniform()
-              .equals(other.getUniform());
-          break;
-        case 4:
-          result = result && getDeterm()
-              .equals(other.getDeterm());
-          break;
-        case 5:
-          result = result && getPareto()
-              .equals(other.getPareto());
-          break;
-        case 0:
-        default:
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      switch (loadCase_) {
-        case 1:
-          hash = (37 * hash) + CLOSED_LOOP_FIELD_NUMBER;
-          hash = (53 * hash) + getClosedLoop().hashCode();
-          break;
-        case 2:
-          hash = (37 * hash) + POISSON_FIELD_NUMBER;
-          hash = (53 * hash) + getPoisson().hashCode();
-          break;
-        case 3:
-          hash = (37 * hash) + UNIFORM_FIELD_NUMBER;
-          hash = (53 * hash) + getUniform().hashCode();
-          break;
-        case 4:
-          hash = (37 * hash) + DETERM_FIELD_NUMBER;
-          hash = (53 * hash) + getDeterm().hashCode();
-          break;
-        case 5:
-          hash = (37 * hash) + PARETO_FIELD_NUMBER;
-          hash = (53 * hash) + getPareto().hashCode();
-          break;
-        case 0:
-        default:
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.LoadParams parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.LoadParams parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.LoadParams parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.LoadParams parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.LoadParams parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.LoadParams parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.LoadParams parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.LoadParams parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.LoadParams parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.LoadParams parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.LoadParams prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.LoadParams}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.LoadParams)
-        io.grpc.benchmarks.proto.Control.LoadParamsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_LoadParams_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_LoadParams_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.LoadParams.class, io.grpc.benchmarks.proto.Control.LoadParams.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.LoadParams.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        loadCase_ = 0;
-        load_ = null;
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_LoadParams_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.LoadParams getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.LoadParams.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.LoadParams build() {
-        io.grpc.benchmarks.proto.Control.LoadParams result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.LoadParams buildPartial() {
-        io.grpc.benchmarks.proto.Control.LoadParams result = new io.grpc.benchmarks.proto.Control.LoadParams(this);
-        if (loadCase_ == 1) {
-          if (closedLoopBuilder_ == null) {
-            result.load_ = load_;
-          } else {
-            result.load_ = closedLoopBuilder_.build();
-          }
-        }
-        if (loadCase_ == 2) {
-          if (poissonBuilder_ == null) {
-            result.load_ = load_;
-          } else {
-            result.load_ = poissonBuilder_.build();
-          }
-        }
-        if (loadCase_ == 3) {
-          if (uniformBuilder_ == null) {
-            result.load_ = load_;
-          } else {
-            result.load_ = uniformBuilder_.build();
-          }
-        }
-        if (loadCase_ == 4) {
-          if (determBuilder_ == null) {
-            result.load_ = load_;
-          } else {
-            result.load_ = determBuilder_.build();
-          }
-        }
-        if (loadCase_ == 5) {
-          if (paretoBuilder_ == null) {
-            result.load_ = load_;
-          } else {
-            result.load_ = paretoBuilder_.build();
-          }
-        }
-        result.loadCase_ = loadCase_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.LoadParams) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.LoadParams)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.LoadParams other) {
-        if (other == io.grpc.benchmarks.proto.Control.LoadParams.getDefaultInstance()) return this;
-        switch (other.getLoadCase()) {
-          case CLOSED_LOOP: {
-            mergeClosedLoop(other.getClosedLoop());
-            break;
-          }
-          case POISSON: {
-            mergePoisson(other.getPoisson());
-            break;
-          }
-          case UNIFORM: {
-            mergeUniform(other.getUniform());
-            break;
-          }
-          case DETERM: {
-            mergeDeterm(other.getDeterm());
-            break;
-          }
-          case PARETO: {
-            mergePareto(other.getPareto());
-            break;
-          }
-          case LOAD_NOT_SET: {
-            break;
-          }
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.LoadParams parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.LoadParams) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      private int loadCase_ = 0;
-      private java.lang.Object load_;
-      public LoadCase
-          getLoadCase() {
-        return LoadCase.forNumber(
-            loadCase_);
-      }
-
-      public Builder clearLoad() {
-        loadCase_ = 0;
-        load_ = null;
-        onChanged();
-        return this;
-      }
-
-
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.ClosedLoopParams, io.grpc.benchmarks.proto.Control.ClosedLoopParams.Builder, io.grpc.benchmarks.proto.Control.ClosedLoopParamsOrBuilder> closedLoopBuilder_;
-      /**
-       * <code>.grpc.testing.ClosedLoopParams closed_loop = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ClosedLoopParams getClosedLoop() {
-        if (closedLoopBuilder_ == null) {
-          if (loadCase_ == 1) {
-            return (io.grpc.benchmarks.proto.Control.ClosedLoopParams) load_;
-          }
-          return io.grpc.benchmarks.proto.Control.ClosedLoopParams.getDefaultInstance();
-        } else {
-          if (loadCase_ == 1) {
-            return closedLoopBuilder_.getMessage();
-          }
-          return io.grpc.benchmarks.proto.Control.ClosedLoopParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ClosedLoopParams closed_loop = 1;</code>
-       */
-      public Builder setClosedLoop(io.grpc.benchmarks.proto.Control.ClosedLoopParams value) {
-        if (closedLoopBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          load_ = value;
-          onChanged();
-        } else {
-          closedLoopBuilder_.setMessage(value);
-        }
-        loadCase_ = 1;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClosedLoopParams closed_loop = 1;</code>
-       */
-      public Builder setClosedLoop(
-          io.grpc.benchmarks.proto.Control.ClosedLoopParams.Builder builderForValue) {
-        if (closedLoopBuilder_ == null) {
-          load_ = builderForValue.build();
-          onChanged();
-        } else {
-          closedLoopBuilder_.setMessage(builderForValue.build());
-        }
-        loadCase_ = 1;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClosedLoopParams closed_loop = 1;</code>
-       */
-      public Builder mergeClosedLoop(io.grpc.benchmarks.proto.Control.ClosedLoopParams value) {
-        if (closedLoopBuilder_ == null) {
-          if (loadCase_ == 1 &&
-              load_ != io.grpc.benchmarks.proto.Control.ClosedLoopParams.getDefaultInstance()) {
-            load_ = io.grpc.benchmarks.proto.Control.ClosedLoopParams.newBuilder((io.grpc.benchmarks.proto.Control.ClosedLoopParams) load_)
-                .mergeFrom(value).buildPartial();
-          } else {
-            load_ = value;
-          }
-          onChanged();
-        } else {
-          if (loadCase_ == 1) {
-            closedLoopBuilder_.mergeFrom(value);
-          }
-          closedLoopBuilder_.setMessage(value);
-        }
-        loadCase_ = 1;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClosedLoopParams closed_loop = 1;</code>
-       */
-      public Builder clearClosedLoop() {
-        if (closedLoopBuilder_ == null) {
-          if (loadCase_ == 1) {
-            loadCase_ = 0;
-            load_ = null;
-            onChanged();
-          }
-        } else {
-          if (loadCase_ == 1) {
-            loadCase_ = 0;
-            load_ = null;
-          }
-          closedLoopBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClosedLoopParams closed_loop = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ClosedLoopParams.Builder getClosedLoopBuilder() {
-        return getClosedLoopFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.ClosedLoopParams closed_loop = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ClosedLoopParamsOrBuilder getClosedLoopOrBuilder() {
-        if ((loadCase_ == 1) && (closedLoopBuilder_ != null)) {
-          return closedLoopBuilder_.getMessageOrBuilder();
-        } else {
-          if (loadCase_ == 1) {
-            return (io.grpc.benchmarks.proto.Control.ClosedLoopParams) load_;
-          }
-          return io.grpc.benchmarks.proto.Control.ClosedLoopParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ClosedLoopParams closed_loop = 1;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.ClosedLoopParams, io.grpc.benchmarks.proto.Control.ClosedLoopParams.Builder, io.grpc.benchmarks.proto.Control.ClosedLoopParamsOrBuilder> 
-          getClosedLoopFieldBuilder() {
-        if (closedLoopBuilder_ == null) {
-          if (!(loadCase_ == 1)) {
-            load_ = io.grpc.benchmarks.proto.Control.ClosedLoopParams.getDefaultInstance();
-          }
-          closedLoopBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Control.ClosedLoopParams, io.grpc.benchmarks.proto.Control.ClosedLoopParams.Builder, io.grpc.benchmarks.proto.Control.ClosedLoopParamsOrBuilder>(
-                  (io.grpc.benchmarks.proto.Control.ClosedLoopParams) load_,
-                  getParentForChildren(),
-                  isClean());
-          load_ = null;
-        }
-        loadCase_ = 1;
-        onChanged();;
-        return closedLoopBuilder_;
-      }
-
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.PoissonParams, io.grpc.benchmarks.proto.Control.PoissonParams.Builder, io.grpc.benchmarks.proto.Control.PoissonParamsOrBuilder> poissonBuilder_;
-      /**
-       * <code>.grpc.testing.PoissonParams poisson = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.PoissonParams getPoisson() {
-        if (poissonBuilder_ == null) {
-          if (loadCase_ == 2) {
-            return (io.grpc.benchmarks.proto.Control.PoissonParams) load_;
-          }
-          return io.grpc.benchmarks.proto.Control.PoissonParams.getDefaultInstance();
-        } else {
-          if (loadCase_ == 2) {
-            return poissonBuilder_.getMessage();
-          }
-          return io.grpc.benchmarks.proto.Control.PoissonParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.PoissonParams poisson = 2;</code>
-       */
-      public Builder setPoisson(io.grpc.benchmarks.proto.Control.PoissonParams value) {
-        if (poissonBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          load_ = value;
-          onChanged();
-        } else {
-          poissonBuilder_.setMessage(value);
-        }
-        loadCase_ = 2;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.PoissonParams poisson = 2;</code>
-       */
-      public Builder setPoisson(
-          io.grpc.benchmarks.proto.Control.PoissonParams.Builder builderForValue) {
-        if (poissonBuilder_ == null) {
-          load_ = builderForValue.build();
-          onChanged();
-        } else {
-          poissonBuilder_.setMessage(builderForValue.build());
-        }
-        loadCase_ = 2;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.PoissonParams poisson = 2;</code>
-       */
-      public Builder mergePoisson(io.grpc.benchmarks.proto.Control.PoissonParams value) {
-        if (poissonBuilder_ == null) {
-          if (loadCase_ == 2 &&
-              load_ != io.grpc.benchmarks.proto.Control.PoissonParams.getDefaultInstance()) {
-            load_ = io.grpc.benchmarks.proto.Control.PoissonParams.newBuilder((io.grpc.benchmarks.proto.Control.PoissonParams) load_)
-                .mergeFrom(value).buildPartial();
-          } else {
-            load_ = value;
-          }
-          onChanged();
-        } else {
-          if (loadCase_ == 2) {
-            poissonBuilder_.mergeFrom(value);
-          }
-          poissonBuilder_.setMessage(value);
-        }
-        loadCase_ = 2;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.PoissonParams poisson = 2;</code>
-       */
-      public Builder clearPoisson() {
-        if (poissonBuilder_ == null) {
-          if (loadCase_ == 2) {
-            loadCase_ = 0;
-            load_ = null;
-            onChanged();
-          }
-        } else {
-          if (loadCase_ == 2) {
-            loadCase_ = 0;
-            load_ = null;
-          }
-          poissonBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.PoissonParams poisson = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.PoissonParams.Builder getPoissonBuilder() {
-        return getPoissonFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.PoissonParams poisson = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.PoissonParamsOrBuilder getPoissonOrBuilder() {
-        if ((loadCase_ == 2) && (poissonBuilder_ != null)) {
-          return poissonBuilder_.getMessageOrBuilder();
-        } else {
-          if (loadCase_ == 2) {
-            return (io.grpc.benchmarks.proto.Control.PoissonParams) load_;
-          }
-          return io.grpc.benchmarks.proto.Control.PoissonParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.PoissonParams poisson = 2;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.PoissonParams, io.grpc.benchmarks.proto.Control.PoissonParams.Builder, io.grpc.benchmarks.proto.Control.PoissonParamsOrBuilder> 
-          getPoissonFieldBuilder() {
-        if (poissonBuilder_ == null) {
-          if (!(loadCase_ == 2)) {
-            load_ = io.grpc.benchmarks.proto.Control.PoissonParams.getDefaultInstance();
-          }
-          poissonBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Control.PoissonParams, io.grpc.benchmarks.proto.Control.PoissonParams.Builder, io.grpc.benchmarks.proto.Control.PoissonParamsOrBuilder>(
-                  (io.grpc.benchmarks.proto.Control.PoissonParams) load_,
-                  getParentForChildren(),
-                  isClean());
-          load_ = null;
-        }
-        loadCase_ = 2;
-        onChanged();;
-        return poissonBuilder_;
-      }
-
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.UniformParams, io.grpc.benchmarks.proto.Control.UniformParams.Builder, io.grpc.benchmarks.proto.Control.UniformParamsOrBuilder> uniformBuilder_;
-      /**
-       * <code>.grpc.testing.UniformParams uniform = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.UniformParams getUniform() {
-        if (uniformBuilder_ == null) {
-          if (loadCase_ == 3) {
-            return (io.grpc.benchmarks.proto.Control.UniformParams) load_;
-          }
-          return io.grpc.benchmarks.proto.Control.UniformParams.getDefaultInstance();
-        } else {
-          if (loadCase_ == 3) {
-            return uniformBuilder_.getMessage();
-          }
-          return io.grpc.benchmarks.proto.Control.UniformParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.UniformParams uniform = 3;</code>
-       */
-      public Builder setUniform(io.grpc.benchmarks.proto.Control.UniformParams value) {
-        if (uniformBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          load_ = value;
-          onChanged();
-        } else {
-          uniformBuilder_.setMessage(value);
-        }
-        loadCase_ = 3;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.UniformParams uniform = 3;</code>
-       */
-      public Builder setUniform(
-          io.grpc.benchmarks.proto.Control.UniformParams.Builder builderForValue) {
-        if (uniformBuilder_ == null) {
-          load_ = builderForValue.build();
-          onChanged();
-        } else {
-          uniformBuilder_.setMessage(builderForValue.build());
-        }
-        loadCase_ = 3;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.UniformParams uniform = 3;</code>
-       */
-      public Builder mergeUniform(io.grpc.benchmarks.proto.Control.UniformParams value) {
-        if (uniformBuilder_ == null) {
-          if (loadCase_ == 3 &&
-              load_ != io.grpc.benchmarks.proto.Control.UniformParams.getDefaultInstance()) {
-            load_ = io.grpc.benchmarks.proto.Control.UniformParams.newBuilder((io.grpc.benchmarks.proto.Control.UniformParams) load_)
-                .mergeFrom(value).buildPartial();
-          } else {
-            load_ = value;
-          }
-          onChanged();
-        } else {
-          if (loadCase_ == 3) {
-            uniformBuilder_.mergeFrom(value);
-          }
-          uniformBuilder_.setMessage(value);
-        }
-        loadCase_ = 3;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.UniformParams uniform = 3;</code>
-       */
-      public Builder clearUniform() {
-        if (uniformBuilder_ == null) {
-          if (loadCase_ == 3) {
-            loadCase_ = 0;
-            load_ = null;
-            onChanged();
-          }
-        } else {
-          if (loadCase_ == 3) {
-            loadCase_ = 0;
-            load_ = null;
-          }
-          uniformBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.UniformParams uniform = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.UniformParams.Builder getUniformBuilder() {
-        return getUniformFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.UniformParams uniform = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.UniformParamsOrBuilder getUniformOrBuilder() {
-        if ((loadCase_ == 3) && (uniformBuilder_ != null)) {
-          return uniformBuilder_.getMessageOrBuilder();
-        } else {
-          if (loadCase_ == 3) {
-            return (io.grpc.benchmarks.proto.Control.UniformParams) load_;
-          }
-          return io.grpc.benchmarks.proto.Control.UniformParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.UniformParams uniform = 3;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.UniformParams, io.grpc.benchmarks.proto.Control.UniformParams.Builder, io.grpc.benchmarks.proto.Control.UniformParamsOrBuilder> 
-          getUniformFieldBuilder() {
-        if (uniformBuilder_ == null) {
-          if (!(loadCase_ == 3)) {
-            load_ = io.grpc.benchmarks.proto.Control.UniformParams.getDefaultInstance();
-          }
-          uniformBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Control.UniformParams, io.grpc.benchmarks.proto.Control.UniformParams.Builder, io.grpc.benchmarks.proto.Control.UniformParamsOrBuilder>(
-                  (io.grpc.benchmarks.proto.Control.UniformParams) load_,
-                  getParentForChildren(),
-                  isClean());
-          load_ = null;
-        }
-        loadCase_ = 3;
-        onChanged();;
-        return uniformBuilder_;
-      }
-
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.DeterministicParams, io.grpc.benchmarks.proto.Control.DeterministicParams.Builder, io.grpc.benchmarks.proto.Control.DeterministicParamsOrBuilder> determBuilder_;
-      /**
-       * <code>.grpc.testing.DeterministicParams determ = 4;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.DeterministicParams getDeterm() {
-        if (determBuilder_ == null) {
-          if (loadCase_ == 4) {
-            return (io.grpc.benchmarks.proto.Control.DeterministicParams) load_;
-          }
-          return io.grpc.benchmarks.proto.Control.DeterministicParams.getDefaultInstance();
-        } else {
-          if (loadCase_ == 4) {
-            return determBuilder_.getMessage();
-          }
-          return io.grpc.benchmarks.proto.Control.DeterministicParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.DeterministicParams determ = 4;</code>
-       */
-      public Builder setDeterm(io.grpc.benchmarks.proto.Control.DeterministicParams value) {
-        if (determBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          load_ = value;
-          onChanged();
-        } else {
-          determBuilder_.setMessage(value);
-        }
-        loadCase_ = 4;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.DeterministicParams determ = 4;</code>
-       */
-      public Builder setDeterm(
-          io.grpc.benchmarks.proto.Control.DeterministicParams.Builder builderForValue) {
-        if (determBuilder_ == null) {
-          load_ = builderForValue.build();
-          onChanged();
-        } else {
-          determBuilder_.setMessage(builderForValue.build());
-        }
-        loadCase_ = 4;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.DeterministicParams determ = 4;</code>
-       */
-      public Builder mergeDeterm(io.grpc.benchmarks.proto.Control.DeterministicParams value) {
-        if (determBuilder_ == null) {
-          if (loadCase_ == 4 &&
-              load_ != io.grpc.benchmarks.proto.Control.DeterministicParams.getDefaultInstance()) {
-            load_ = io.grpc.benchmarks.proto.Control.DeterministicParams.newBuilder((io.grpc.benchmarks.proto.Control.DeterministicParams) load_)
-                .mergeFrom(value).buildPartial();
-          } else {
-            load_ = value;
-          }
-          onChanged();
-        } else {
-          if (loadCase_ == 4) {
-            determBuilder_.mergeFrom(value);
-          }
-          determBuilder_.setMessage(value);
-        }
-        loadCase_ = 4;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.DeterministicParams determ = 4;</code>
-       */
-      public Builder clearDeterm() {
-        if (determBuilder_ == null) {
-          if (loadCase_ == 4) {
-            loadCase_ = 0;
-            load_ = null;
-            onChanged();
-          }
-        } else {
-          if (loadCase_ == 4) {
-            loadCase_ = 0;
-            load_ = null;
-          }
-          determBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.DeterministicParams determ = 4;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.DeterministicParams.Builder getDetermBuilder() {
-        return getDetermFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.DeterministicParams determ = 4;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.DeterministicParamsOrBuilder getDetermOrBuilder() {
-        if ((loadCase_ == 4) && (determBuilder_ != null)) {
-          return determBuilder_.getMessageOrBuilder();
-        } else {
-          if (loadCase_ == 4) {
-            return (io.grpc.benchmarks.proto.Control.DeterministicParams) load_;
-          }
-          return io.grpc.benchmarks.proto.Control.DeterministicParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.DeterministicParams determ = 4;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.DeterministicParams, io.grpc.benchmarks.proto.Control.DeterministicParams.Builder, io.grpc.benchmarks.proto.Control.DeterministicParamsOrBuilder> 
-          getDetermFieldBuilder() {
-        if (determBuilder_ == null) {
-          if (!(loadCase_ == 4)) {
-            load_ = io.grpc.benchmarks.proto.Control.DeterministicParams.getDefaultInstance();
-          }
-          determBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Control.DeterministicParams, io.grpc.benchmarks.proto.Control.DeterministicParams.Builder, io.grpc.benchmarks.proto.Control.DeterministicParamsOrBuilder>(
-                  (io.grpc.benchmarks.proto.Control.DeterministicParams) load_,
-                  getParentForChildren(),
-                  isClean());
-          load_ = null;
-        }
-        loadCase_ = 4;
-        onChanged();;
-        return determBuilder_;
-      }
-
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.ParetoParams, io.grpc.benchmarks.proto.Control.ParetoParams.Builder, io.grpc.benchmarks.proto.Control.ParetoParamsOrBuilder> paretoBuilder_;
-      /**
-       * <code>.grpc.testing.ParetoParams pareto = 5;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ParetoParams getPareto() {
-        if (paretoBuilder_ == null) {
-          if (loadCase_ == 5) {
-            return (io.grpc.benchmarks.proto.Control.ParetoParams) load_;
-          }
-          return io.grpc.benchmarks.proto.Control.ParetoParams.getDefaultInstance();
-        } else {
-          if (loadCase_ == 5) {
-            return paretoBuilder_.getMessage();
-          }
-          return io.grpc.benchmarks.proto.Control.ParetoParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ParetoParams pareto = 5;</code>
-       */
-      public Builder setPareto(io.grpc.benchmarks.proto.Control.ParetoParams value) {
-        if (paretoBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          load_ = value;
-          onChanged();
-        } else {
-          paretoBuilder_.setMessage(value);
-        }
-        loadCase_ = 5;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ParetoParams pareto = 5;</code>
-       */
-      public Builder setPareto(
-          io.grpc.benchmarks.proto.Control.ParetoParams.Builder builderForValue) {
-        if (paretoBuilder_ == null) {
-          load_ = builderForValue.build();
-          onChanged();
-        } else {
-          paretoBuilder_.setMessage(builderForValue.build());
-        }
-        loadCase_ = 5;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ParetoParams pareto = 5;</code>
-       */
-      public Builder mergePareto(io.grpc.benchmarks.proto.Control.ParetoParams value) {
-        if (paretoBuilder_ == null) {
-          if (loadCase_ == 5 &&
-              load_ != io.grpc.benchmarks.proto.Control.ParetoParams.getDefaultInstance()) {
-            load_ = io.grpc.benchmarks.proto.Control.ParetoParams.newBuilder((io.grpc.benchmarks.proto.Control.ParetoParams) load_)
-                .mergeFrom(value).buildPartial();
-          } else {
-            load_ = value;
-          }
-          onChanged();
-        } else {
-          if (loadCase_ == 5) {
-            paretoBuilder_.mergeFrom(value);
-          }
-          paretoBuilder_.setMessage(value);
-        }
-        loadCase_ = 5;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ParetoParams pareto = 5;</code>
-       */
-      public Builder clearPareto() {
-        if (paretoBuilder_ == null) {
-          if (loadCase_ == 5) {
-            loadCase_ = 0;
-            load_ = null;
-            onChanged();
-          }
-        } else {
-          if (loadCase_ == 5) {
-            loadCase_ = 0;
-            load_ = null;
-          }
-          paretoBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ParetoParams pareto = 5;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ParetoParams.Builder getParetoBuilder() {
-        return getParetoFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.ParetoParams pareto = 5;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ParetoParamsOrBuilder getParetoOrBuilder() {
-        if ((loadCase_ == 5) && (paretoBuilder_ != null)) {
-          return paretoBuilder_.getMessageOrBuilder();
-        } else {
-          if (loadCase_ == 5) {
-            return (io.grpc.benchmarks.proto.Control.ParetoParams) load_;
-          }
-          return io.grpc.benchmarks.proto.Control.ParetoParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ParetoParams pareto = 5;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.ParetoParams, io.grpc.benchmarks.proto.Control.ParetoParams.Builder, io.grpc.benchmarks.proto.Control.ParetoParamsOrBuilder> 
-          getParetoFieldBuilder() {
-        if (paretoBuilder_ == null) {
-          if (!(loadCase_ == 5)) {
-            load_ = io.grpc.benchmarks.proto.Control.ParetoParams.getDefaultInstance();
-          }
-          paretoBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Control.ParetoParams, io.grpc.benchmarks.proto.Control.ParetoParams.Builder, io.grpc.benchmarks.proto.Control.ParetoParamsOrBuilder>(
-                  (io.grpc.benchmarks.proto.Control.ParetoParams) load_,
-                  getParentForChildren(),
-                  isClean());
-          load_ = null;
-        }
-        loadCase_ = 5;
-        onChanged();;
-        return paretoBuilder_;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.LoadParams)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.LoadParams)
-    private static final io.grpc.benchmarks.proto.Control.LoadParams DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.LoadParams();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.LoadParams getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<LoadParams>
-        PARSER = new com.google.protobuf.AbstractParser<LoadParams>() {
-      public LoadParams parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new LoadParams(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<LoadParams> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<LoadParams> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.LoadParams getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface SecurityParamsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.SecurityParams)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>bool use_test_ca = 1;</code>
-     */
-    boolean getUseTestCa();
-
-    /**
-     * <code>string server_host_override = 2;</code>
-     */
-    java.lang.String getServerHostOverride();
-    /**
-     * <code>string server_host_override = 2;</code>
-     */
-    com.google.protobuf.ByteString
-        getServerHostOverrideBytes();
-  }
-  /**
-   * <pre>
-   * presence of SecurityParams implies use of TLS
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.SecurityParams}
-   */
-  public  static final class SecurityParams extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.SecurityParams)
-      SecurityParamsOrBuilder {
-    // Use SecurityParams.newBuilder() to construct.
-    private SecurityParams(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private SecurityParams() {
-      useTestCa_ = false;
-      serverHostOverride_ = "";
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private SecurityParams(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              useTestCa_ = input.readBool();
-              break;
-            }
-            case 18: {
-              java.lang.String s = input.readStringRequireUtf8();
-
-              serverHostOverride_ = s;
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_SecurityParams_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_SecurityParams_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.SecurityParams.class, io.grpc.benchmarks.proto.Control.SecurityParams.Builder.class);
-    }
-
-    public static final int USE_TEST_CA_FIELD_NUMBER = 1;
-    private boolean useTestCa_;
-    /**
-     * <code>bool use_test_ca = 1;</code>
-     */
-    public boolean getUseTestCa() {
-      return useTestCa_;
-    }
-
-    public static final int SERVER_HOST_OVERRIDE_FIELD_NUMBER = 2;
-    private volatile java.lang.Object serverHostOverride_;
-    /**
-     * <code>string server_host_override = 2;</code>
-     */
-    public java.lang.String getServerHostOverride() {
-      java.lang.Object ref = serverHostOverride_;
-      if (ref instanceof java.lang.String) {
-        return (java.lang.String) ref;
-      } else {
-        com.google.protobuf.ByteString bs = 
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        serverHostOverride_ = s;
-        return s;
-      }
-    }
-    /**
-     * <code>string server_host_override = 2;</code>
-     */
-    public com.google.protobuf.ByteString
-        getServerHostOverrideBytes() {
-      java.lang.Object ref = serverHostOverride_;
-      if (ref instanceof java.lang.String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        serverHostOverride_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (useTestCa_ != false) {
-        output.writeBool(1, useTestCa_);
-      }
-      if (!getServerHostOverrideBytes().isEmpty()) {
-        com.google.protobuf.GeneratedMessageV3.writeString(output, 2, serverHostOverride_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (useTestCa_ != false) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeBoolSize(1, useTestCa_);
-      }
-      if (!getServerHostOverrideBytes().isEmpty()) {
-        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, serverHostOverride_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.SecurityParams)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.SecurityParams other = (io.grpc.benchmarks.proto.Control.SecurityParams) obj;
-
-      boolean result = true;
-      result = result && (getUseTestCa()
-          == other.getUseTestCa());
-      result = result && getServerHostOverride()
-          .equals(other.getServerHostOverride());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + USE_TEST_CA_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
-          getUseTestCa());
-      hash = (37 * hash) + SERVER_HOST_OVERRIDE_FIELD_NUMBER;
-      hash = (53 * hash) + getServerHostOverride().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.SecurityParams parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.SecurityParams parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.SecurityParams parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.SecurityParams parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.SecurityParams parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.SecurityParams parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.SecurityParams parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.SecurityParams parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.SecurityParams parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.SecurityParams parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.SecurityParams prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * presence of SecurityParams implies use of TLS
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.SecurityParams}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.SecurityParams)
-        io.grpc.benchmarks.proto.Control.SecurityParamsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_SecurityParams_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_SecurityParams_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.SecurityParams.class, io.grpc.benchmarks.proto.Control.SecurityParams.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.SecurityParams.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        useTestCa_ = false;
-
-        serverHostOverride_ = "";
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_SecurityParams_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.SecurityParams getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.SecurityParams.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.SecurityParams build() {
-        io.grpc.benchmarks.proto.Control.SecurityParams result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.SecurityParams buildPartial() {
-        io.grpc.benchmarks.proto.Control.SecurityParams result = new io.grpc.benchmarks.proto.Control.SecurityParams(this);
-        result.useTestCa_ = useTestCa_;
-        result.serverHostOverride_ = serverHostOverride_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.SecurityParams) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.SecurityParams)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.SecurityParams other) {
-        if (other == io.grpc.benchmarks.proto.Control.SecurityParams.getDefaultInstance()) return this;
-        if (other.getUseTestCa() != false) {
-          setUseTestCa(other.getUseTestCa());
-        }
-        if (!other.getServerHostOverride().isEmpty()) {
-          serverHostOverride_ = other.serverHostOverride_;
-          onChanged();
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.SecurityParams parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.SecurityParams) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private boolean useTestCa_ ;
-      /**
-       * <code>bool use_test_ca = 1;</code>
-       */
-      public boolean getUseTestCa() {
-        return useTestCa_;
-      }
-      /**
-       * <code>bool use_test_ca = 1;</code>
-       */
-      public Builder setUseTestCa(boolean value) {
-        
-        useTestCa_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>bool use_test_ca = 1;</code>
-       */
-      public Builder clearUseTestCa() {
-        
-        useTestCa_ = false;
-        onChanged();
-        return this;
-      }
-
-      private java.lang.Object serverHostOverride_ = "";
-      /**
-       * <code>string server_host_override = 2;</code>
-       */
-      public java.lang.String getServerHostOverride() {
-        java.lang.Object ref = serverHostOverride_;
-        if (!(ref instanceof java.lang.String)) {
-          com.google.protobuf.ByteString bs =
-              (com.google.protobuf.ByteString) ref;
-          java.lang.String s = bs.toStringUtf8();
-          serverHostOverride_ = s;
-          return s;
-        } else {
-          return (java.lang.String) ref;
-        }
-      }
-      /**
-       * <code>string server_host_override = 2;</code>
-       */
-      public com.google.protobuf.ByteString
-          getServerHostOverrideBytes() {
-        java.lang.Object ref = serverHostOverride_;
-        if (ref instanceof String) {
-          com.google.protobuf.ByteString b = 
-              com.google.protobuf.ByteString.copyFromUtf8(
-                  (java.lang.String) ref);
-          serverHostOverride_ = b;
-          return b;
-        } else {
-          return (com.google.protobuf.ByteString) ref;
-        }
-      }
-      /**
-       * <code>string server_host_override = 2;</code>
-       */
-      public Builder setServerHostOverride(
-          java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  
-        serverHostOverride_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>string server_host_override = 2;</code>
-       */
-      public Builder clearServerHostOverride() {
-        
-        serverHostOverride_ = getDefaultInstance().getServerHostOverride();
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>string server_host_override = 2;</code>
-       */
-      public Builder setServerHostOverrideBytes(
-          com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-        
-        serverHostOverride_ = value;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.SecurityParams)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.SecurityParams)
-    private static final io.grpc.benchmarks.proto.Control.SecurityParams DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.SecurityParams();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.SecurityParams getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<SecurityParams>
-        PARSER = new com.google.protobuf.AbstractParser<SecurityParams>() {
-      public SecurityParams parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new SecurityParams(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<SecurityParams> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<SecurityParams> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.SecurityParams getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ClientConfigOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ClientConfig)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * List of targets to connect to. At least one target needs to be specified.
-     * </pre>
-     *
-     * <code>repeated string server_targets = 1;</code>
-     */
-    java.util.List<java.lang.String>
-        getServerTargetsList();
-    /**
-     * <pre>
-     * List of targets to connect to. At least one target needs to be specified.
-     * </pre>
-     *
-     * <code>repeated string server_targets = 1;</code>
-     */
-    int getServerTargetsCount();
-    /**
-     * <pre>
-     * List of targets to connect to. At least one target needs to be specified.
-     * </pre>
-     *
-     * <code>repeated string server_targets = 1;</code>
-     */
-    java.lang.String getServerTargets(int index);
-    /**
-     * <pre>
-     * List of targets to connect to. At least one target needs to be specified.
-     * </pre>
-     *
-     * <code>repeated string server_targets = 1;</code>
-     */
-    com.google.protobuf.ByteString
-        getServerTargetsBytes(int index);
-
-    /**
-     * <code>.grpc.testing.ClientType client_type = 2;</code>
-     */
-    int getClientTypeValue();
-    /**
-     * <code>.grpc.testing.ClientType client_type = 2;</code>
-     */
-    io.grpc.benchmarks.proto.Control.ClientType getClientType();
-
-    /**
-     * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-     */
-    boolean hasSecurityParams();
-    /**
-     * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-     */
-    io.grpc.benchmarks.proto.Control.SecurityParams getSecurityParams();
-    /**
-     * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-     */
-    io.grpc.benchmarks.proto.Control.SecurityParamsOrBuilder getSecurityParamsOrBuilder();
-
-    /**
-     * <pre>
-     * How many concurrent RPCs to start for each channel.
-     * For synchronous client, use a separate thread for each outstanding RPC.
-     * </pre>
-     *
-     * <code>int32 outstanding_rpcs_per_channel = 4;</code>
-     */
-    int getOutstandingRpcsPerChannel();
-
-    /**
-     * <pre>
-     * Number of independent client channels to create.
-     * i-th channel will connect to server_target[i % server_targets.size()]
-     * </pre>
-     *
-     * <code>int32 client_channels = 5;</code>
-     */
-    int getClientChannels();
-
-    /**
-     * <pre>
-     * Only for async client. Number of threads to use to start/manage RPCs.
-     * </pre>
-     *
-     * <code>int32 async_client_threads = 7;</code>
-     */
-    int getAsyncClientThreads();
-
-    /**
-     * <code>.grpc.testing.RpcType rpc_type = 8;</code>
-     */
-    int getRpcTypeValue();
-    /**
-     * <code>.grpc.testing.RpcType rpc_type = 8;</code>
-     */
-    io.grpc.benchmarks.proto.Control.RpcType getRpcType();
-
-    /**
-     * <pre>
-     * The requested load for the entire client (aggregated over all the threads).
-     * </pre>
-     *
-     * <code>.grpc.testing.LoadParams load_params = 10;</code>
-     */
-    boolean hasLoadParams();
-    /**
-     * <pre>
-     * The requested load for the entire client (aggregated over all the threads).
-     * </pre>
-     *
-     * <code>.grpc.testing.LoadParams load_params = 10;</code>
-     */
-    io.grpc.benchmarks.proto.Control.LoadParams getLoadParams();
-    /**
-     * <pre>
-     * The requested load for the entire client (aggregated over all the threads).
-     * </pre>
-     *
-     * <code>.grpc.testing.LoadParams load_params = 10;</code>
-     */
-    io.grpc.benchmarks.proto.Control.LoadParamsOrBuilder getLoadParamsOrBuilder();
-
-    /**
-     * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-     */
-    boolean hasPayloadConfig();
-    /**
-     * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-     */
-    io.grpc.benchmarks.proto.Payloads.PayloadConfig getPayloadConfig();
-    /**
-     * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-     */
-    io.grpc.benchmarks.proto.Payloads.PayloadConfigOrBuilder getPayloadConfigOrBuilder();
-
-    /**
-     * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-     */
-    boolean hasHistogramParams();
-    /**
-     * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-     */
-    io.grpc.benchmarks.proto.Stats.HistogramParams getHistogramParams();
-    /**
-     * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-     */
-    io.grpc.benchmarks.proto.Stats.HistogramParamsOrBuilder getHistogramParamsOrBuilder();
-
-    /**
-     * <pre>
-     * Specify the cores we should run the client on, if desired
-     * </pre>
-     *
-     * <code>repeated int32 core_list = 13;</code>
-     */
-    java.util.List<java.lang.Integer> getCoreListList();
-    /**
-     * <pre>
-     * Specify the cores we should run the client on, if desired
-     * </pre>
-     *
-     * <code>repeated int32 core_list = 13;</code>
-     */
-    int getCoreListCount();
-    /**
-     * <pre>
-     * Specify the cores we should run the client on, if desired
-     * </pre>
-     *
-     * <code>repeated int32 core_list = 13;</code>
-     */
-    int getCoreList(int index);
-
-    /**
-     * <code>int32 core_limit = 14;</code>
-     */
-    int getCoreLimit();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.ClientConfig}
-   */
-  public  static final class ClientConfig extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ClientConfig)
-      ClientConfigOrBuilder {
-    // Use ClientConfig.newBuilder() to construct.
-    private ClientConfig(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ClientConfig() {
-      serverTargets_ = com.google.protobuf.LazyStringArrayList.EMPTY;
-      clientType_ = 0;
-      outstandingRpcsPerChannel_ = 0;
-      clientChannels_ = 0;
-      asyncClientThreads_ = 0;
-      rpcType_ = 0;
-      coreList_ = java.util.Collections.emptyList();
-      coreLimit_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ClientConfig(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              java.lang.String s = input.readStringRequireUtf8();
-              if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
-                serverTargets_ = new com.google.protobuf.LazyStringArrayList();
-                mutable_bitField0_ |= 0x00000001;
-              }
-              serverTargets_.add(s);
-              break;
-            }
-            case 16: {
-              int rawValue = input.readEnum();
-
-              clientType_ = rawValue;
-              break;
-            }
-            case 26: {
-              io.grpc.benchmarks.proto.Control.SecurityParams.Builder subBuilder = null;
-              if (securityParams_ != null) {
-                subBuilder = securityParams_.toBuilder();
-              }
-              securityParams_ = input.readMessage(io.grpc.benchmarks.proto.Control.SecurityParams.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(securityParams_);
-                securityParams_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 32: {
-
-              outstandingRpcsPerChannel_ = input.readInt32();
-              break;
-            }
-            case 40: {
-
-              clientChannels_ = input.readInt32();
-              break;
-            }
-            case 56: {
-
-              asyncClientThreads_ = input.readInt32();
-              break;
-            }
-            case 64: {
-              int rawValue = input.readEnum();
-
-              rpcType_ = rawValue;
-              break;
-            }
-            case 82: {
-              io.grpc.benchmarks.proto.Control.LoadParams.Builder subBuilder = null;
-              if (loadParams_ != null) {
-                subBuilder = loadParams_.toBuilder();
-              }
-              loadParams_ = input.readMessage(io.grpc.benchmarks.proto.Control.LoadParams.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(loadParams_);
-                loadParams_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 90: {
-              io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder subBuilder = null;
-              if (payloadConfig_ != null) {
-                subBuilder = payloadConfig_.toBuilder();
-              }
-              payloadConfig_ = input.readMessage(io.grpc.benchmarks.proto.Payloads.PayloadConfig.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(payloadConfig_);
-                payloadConfig_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 98: {
-              io.grpc.benchmarks.proto.Stats.HistogramParams.Builder subBuilder = null;
-              if (histogramParams_ != null) {
-                subBuilder = histogramParams_.toBuilder();
-              }
-              histogramParams_ = input.readMessage(io.grpc.benchmarks.proto.Stats.HistogramParams.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(histogramParams_);
-                histogramParams_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 104: {
-              if (!((mutable_bitField0_ & 0x00000400) == 0x00000400)) {
-                coreList_ = new java.util.ArrayList<java.lang.Integer>();
-                mutable_bitField0_ |= 0x00000400;
-              }
-              coreList_.add(input.readInt32());
-              break;
-            }
-            case 106: {
-              int length = input.readRawVarint32();
-              int limit = input.pushLimit(length);
-              if (!((mutable_bitField0_ & 0x00000400) == 0x00000400) && input.getBytesUntilLimit() > 0) {
-                coreList_ = new java.util.ArrayList<java.lang.Integer>();
-                mutable_bitField0_ |= 0x00000400;
-              }
-              while (input.getBytesUntilLimit() > 0) {
-                coreList_.add(input.readInt32());
-              }
-              input.popLimit(limit);
-              break;
-            }
-            case 112: {
-
-              coreLimit_ = input.readInt32();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
-          serverTargets_ = serverTargets_.getUnmodifiableView();
-        }
-        if (((mutable_bitField0_ & 0x00000400) == 0x00000400)) {
-          coreList_ = java.util.Collections.unmodifiableList(coreList_);
-        }
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientConfig_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientConfig_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.ClientConfig.class, io.grpc.benchmarks.proto.Control.ClientConfig.Builder.class);
-    }
-
-    private int bitField0_;
-    public static final int SERVER_TARGETS_FIELD_NUMBER = 1;
-    private com.google.protobuf.LazyStringList serverTargets_;
-    /**
-     * <pre>
-     * List of targets to connect to. At least one target needs to be specified.
-     * </pre>
-     *
-     * <code>repeated string server_targets = 1;</code>
-     */
-    public com.google.protobuf.ProtocolStringList
-        getServerTargetsList() {
-      return serverTargets_;
-    }
-    /**
-     * <pre>
-     * List of targets to connect to. At least one target needs to be specified.
-     * </pre>
-     *
-     * <code>repeated string server_targets = 1;</code>
-     */
-    public int getServerTargetsCount() {
-      return serverTargets_.size();
-    }
-    /**
-     * <pre>
-     * List of targets to connect to. At least one target needs to be specified.
-     * </pre>
-     *
-     * <code>repeated string server_targets = 1;</code>
-     */
-    public java.lang.String getServerTargets(int index) {
-      return serverTargets_.get(index);
-    }
-    /**
-     * <pre>
-     * List of targets to connect to. At least one target needs to be specified.
-     * </pre>
-     *
-     * <code>repeated string server_targets = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getServerTargetsBytes(int index) {
-      return serverTargets_.getByteString(index);
-    }
-
-    public static final int CLIENT_TYPE_FIELD_NUMBER = 2;
-    private int clientType_;
-    /**
-     * <code>.grpc.testing.ClientType client_type = 2;</code>
-     */
-    public int getClientTypeValue() {
-      return clientType_;
-    }
-    /**
-     * <code>.grpc.testing.ClientType client_type = 2;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.ClientType getClientType() {
-      io.grpc.benchmarks.proto.Control.ClientType result = io.grpc.benchmarks.proto.Control.ClientType.valueOf(clientType_);
-      return result == null ? io.grpc.benchmarks.proto.Control.ClientType.UNRECOGNIZED : result;
-    }
-
-    public static final int SECURITY_PARAMS_FIELD_NUMBER = 3;
-    private io.grpc.benchmarks.proto.Control.SecurityParams securityParams_;
-    /**
-     * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-     */
-    public boolean hasSecurityParams() {
-      return securityParams_ != null;
-    }
-    /**
-     * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.SecurityParams getSecurityParams() {
-      return securityParams_ == null ? io.grpc.benchmarks.proto.Control.SecurityParams.getDefaultInstance() : securityParams_;
-    }
-    /**
-     * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.SecurityParamsOrBuilder getSecurityParamsOrBuilder() {
-      return getSecurityParams();
-    }
-
-    public static final int OUTSTANDING_RPCS_PER_CHANNEL_FIELD_NUMBER = 4;
-    private int outstandingRpcsPerChannel_;
-    /**
-     * <pre>
-     * How many concurrent RPCs to start for each channel.
-     * For synchronous client, use a separate thread for each outstanding RPC.
-     * </pre>
-     *
-     * <code>int32 outstanding_rpcs_per_channel = 4;</code>
-     */
-    public int getOutstandingRpcsPerChannel() {
-      return outstandingRpcsPerChannel_;
-    }
-
-    public static final int CLIENT_CHANNELS_FIELD_NUMBER = 5;
-    private int clientChannels_;
-    /**
-     * <pre>
-     * Number of independent client channels to create.
-     * i-th channel will connect to server_target[i % server_targets.size()]
-     * </pre>
-     *
-     * <code>int32 client_channels = 5;</code>
-     */
-    public int getClientChannels() {
-      return clientChannels_;
-    }
-
-    public static final int ASYNC_CLIENT_THREADS_FIELD_NUMBER = 7;
-    private int asyncClientThreads_;
-    /**
-     * <pre>
-     * Only for async client. Number of threads to use to start/manage RPCs.
-     * </pre>
-     *
-     * <code>int32 async_client_threads = 7;</code>
-     */
-    public int getAsyncClientThreads() {
-      return asyncClientThreads_;
-    }
-
-    public static final int RPC_TYPE_FIELD_NUMBER = 8;
-    private int rpcType_;
-    /**
-     * <code>.grpc.testing.RpcType rpc_type = 8;</code>
-     */
-    public int getRpcTypeValue() {
-      return rpcType_;
-    }
-    /**
-     * <code>.grpc.testing.RpcType rpc_type = 8;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.RpcType getRpcType() {
-      io.grpc.benchmarks.proto.Control.RpcType result = io.grpc.benchmarks.proto.Control.RpcType.valueOf(rpcType_);
-      return result == null ? io.grpc.benchmarks.proto.Control.RpcType.UNRECOGNIZED : result;
-    }
-
-    public static final int LOAD_PARAMS_FIELD_NUMBER = 10;
-    private io.grpc.benchmarks.proto.Control.LoadParams loadParams_;
-    /**
-     * <pre>
-     * The requested load for the entire client (aggregated over all the threads).
-     * </pre>
-     *
-     * <code>.grpc.testing.LoadParams load_params = 10;</code>
-     */
-    public boolean hasLoadParams() {
-      return loadParams_ != null;
-    }
-    /**
-     * <pre>
-     * The requested load for the entire client (aggregated over all the threads).
-     * </pre>
-     *
-     * <code>.grpc.testing.LoadParams load_params = 10;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.LoadParams getLoadParams() {
-      return loadParams_ == null ? io.grpc.benchmarks.proto.Control.LoadParams.getDefaultInstance() : loadParams_;
-    }
-    /**
-     * <pre>
-     * The requested load for the entire client (aggregated over all the threads).
-     * </pre>
-     *
-     * <code>.grpc.testing.LoadParams load_params = 10;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.LoadParamsOrBuilder getLoadParamsOrBuilder() {
-      return getLoadParams();
-    }
-
-    public static final int PAYLOAD_CONFIG_FIELD_NUMBER = 11;
-    private io.grpc.benchmarks.proto.Payloads.PayloadConfig payloadConfig_;
-    /**
-     * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-     */
-    public boolean hasPayloadConfig() {
-      return payloadConfig_ != null;
-    }
-    /**
-     * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-     */
-    public io.grpc.benchmarks.proto.Payloads.PayloadConfig getPayloadConfig() {
-      return payloadConfig_ == null ? io.grpc.benchmarks.proto.Payloads.PayloadConfig.getDefaultInstance() : payloadConfig_;
-    }
-    /**
-     * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-     */
-    public io.grpc.benchmarks.proto.Payloads.PayloadConfigOrBuilder getPayloadConfigOrBuilder() {
-      return getPayloadConfig();
-    }
-
-    public static final int HISTOGRAM_PARAMS_FIELD_NUMBER = 12;
-    private io.grpc.benchmarks.proto.Stats.HistogramParams histogramParams_;
-    /**
-     * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-     */
-    public boolean hasHistogramParams() {
-      return histogramParams_ != null;
-    }
-    /**
-     * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-     */
-    public io.grpc.benchmarks.proto.Stats.HistogramParams getHistogramParams() {
-      return histogramParams_ == null ? io.grpc.benchmarks.proto.Stats.HistogramParams.getDefaultInstance() : histogramParams_;
-    }
-    /**
-     * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-     */
-    public io.grpc.benchmarks.proto.Stats.HistogramParamsOrBuilder getHistogramParamsOrBuilder() {
-      return getHistogramParams();
-    }
-
-    public static final int CORE_LIST_FIELD_NUMBER = 13;
-    private java.util.List<java.lang.Integer> coreList_;
-    /**
-     * <pre>
-     * Specify the cores we should run the client on, if desired
-     * </pre>
-     *
-     * <code>repeated int32 core_list = 13;</code>
-     */
-    public java.util.List<java.lang.Integer>
-        getCoreListList() {
-      return coreList_;
-    }
-    /**
-     * <pre>
-     * Specify the cores we should run the client on, if desired
-     * </pre>
-     *
-     * <code>repeated int32 core_list = 13;</code>
-     */
-    public int getCoreListCount() {
-      return coreList_.size();
-    }
-    /**
-     * <pre>
-     * Specify the cores we should run the client on, if desired
-     * </pre>
-     *
-     * <code>repeated int32 core_list = 13;</code>
-     */
-    public int getCoreList(int index) {
-      return coreList_.get(index);
-    }
-    private int coreListMemoizedSerializedSize = -1;
-
-    public static final int CORE_LIMIT_FIELD_NUMBER = 14;
-    private int coreLimit_;
-    /**
-     * <code>int32 core_limit = 14;</code>
-     */
-    public int getCoreLimit() {
-      return coreLimit_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      getSerializedSize();
-      for (int i = 0; i < serverTargets_.size(); i++) {
-        com.google.protobuf.GeneratedMessageV3.writeString(output, 1, serverTargets_.getRaw(i));
-      }
-      if (clientType_ != io.grpc.benchmarks.proto.Control.ClientType.SYNC_CLIENT.getNumber()) {
-        output.writeEnum(2, clientType_);
-      }
-      if (securityParams_ != null) {
-        output.writeMessage(3, getSecurityParams());
-      }
-      if (outstandingRpcsPerChannel_ != 0) {
-        output.writeInt32(4, outstandingRpcsPerChannel_);
-      }
-      if (clientChannels_ != 0) {
-        output.writeInt32(5, clientChannels_);
-      }
-      if (asyncClientThreads_ != 0) {
-        output.writeInt32(7, asyncClientThreads_);
-      }
-      if (rpcType_ != io.grpc.benchmarks.proto.Control.RpcType.UNARY.getNumber()) {
-        output.writeEnum(8, rpcType_);
-      }
-      if (loadParams_ != null) {
-        output.writeMessage(10, getLoadParams());
-      }
-      if (payloadConfig_ != null) {
-        output.writeMessage(11, getPayloadConfig());
-      }
-      if (histogramParams_ != null) {
-        output.writeMessage(12, getHistogramParams());
-      }
-      if (getCoreListList().size() > 0) {
-        output.writeUInt32NoTag(106);
-        output.writeUInt32NoTag(coreListMemoizedSerializedSize);
-      }
-      for (int i = 0; i < coreList_.size(); i++) {
-        output.writeInt32NoTag(coreList_.get(i));
-      }
-      if (coreLimit_ != 0) {
-        output.writeInt32(14, coreLimit_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      {
-        int dataSize = 0;
-        for (int i = 0; i < serverTargets_.size(); i++) {
-          dataSize += computeStringSizeNoTag(serverTargets_.getRaw(i));
-        }
-        size += dataSize;
-        size += 1 * getServerTargetsList().size();
-      }
-      if (clientType_ != io.grpc.benchmarks.proto.Control.ClientType.SYNC_CLIENT.getNumber()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeEnumSize(2, clientType_);
-      }
-      if (securityParams_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(3, getSecurityParams());
-      }
-      if (outstandingRpcsPerChannel_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(4, outstandingRpcsPerChannel_);
-      }
-      if (clientChannels_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(5, clientChannels_);
-      }
-      if (asyncClientThreads_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(7, asyncClientThreads_);
-      }
-      if (rpcType_ != io.grpc.benchmarks.proto.Control.RpcType.UNARY.getNumber()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeEnumSize(8, rpcType_);
-      }
-      if (loadParams_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(10, getLoadParams());
-      }
-      if (payloadConfig_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(11, getPayloadConfig());
-      }
-      if (histogramParams_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(12, getHistogramParams());
-      }
-      {
-        int dataSize = 0;
-        for (int i = 0; i < coreList_.size(); i++) {
-          dataSize += com.google.protobuf.CodedOutputStream
-            .computeInt32SizeNoTag(coreList_.get(i));
-        }
-        size += dataSize;
-        if (!getCoreListList().isEmpty()) {
-          size += 1;
-          size += com.google.protobuf.CodedOutputStream
-              .computeInt32SizeNoTag(dataSize);
-        }
-        coreListMemoizedSerializedSize = dataSize;
-      }
-      if (coreLimit_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(14, coreLimit_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.ClientConfig)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.ClientConfig other = (io.grpc.benchmarks.proto.Control.ClientConfig) obj;
-
-      boolean result = true;
-      result = result && getServerTargetsList()
-          .equals(other.getServerTargetsList());
-      result = result && clientType_ == other.clientType_;
-      result = result && (hasSecurityParams() == other.hasSecurityParams());
-      if (hasSecurityParams()) {
-        result = result && getSecurityParams()
-            .equals(other.getSecurityParams());
-      }
-      result = result && (getOutstandingRpcsPerChannel()
-          == other.getOutstandingRpcsPerChannel());
-      result = result && (getClientChannels()
-          == other.getClientChannels());
-      result = result && (getAsyncClientThreads()
-          == other.getAsyncClientThreads());
-      result = result && rpcType_ == other.rpcType_;
-      result = result && (hasLoadParams() == other.hasLoadParams());
-      if (hasLoadParams()) {
-        result = result && getLoadParams()
-            .equals(other.getLoadParams());
-      }
-      result = result && (hasPayloadConfig() == other.hasPayloadConfig());
-      if (hasPayloadConfig()) {
-        result = result && getPayloadConfig()
-            .equals(other.getPayloadConfig());
-      }
-      result = result && (hasHistogramParams() == other.hasHistogramParams());
-      if (hasHistogramParams()) {
-        result = result && getHistogramParams()
-            .equals(other.getHistogramParams());
-      }
-      result = result && getCoreListList()
-          .equals(other.getCoreListList());
-      result = result && (getCoreLimit()
-          == other.getCoreLimit());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      if (getServerTargetsCount() > 0) {
-        hash = (37 * hash) + SERVER_TARGETS_FIELD_NUMBER;
-        hash = (53 * hash) + getServerTargetsList().hashCode();
-      }
-      hash = (37 * hash) + CLIENT_TYPE_FIELD_NUMBER;
-      hash = (53 * hash) + clientType_;
-      if (hasSecurityParams()) {
-        hash = (37 * hash) + SECURITY_PARAMS_FIELD_NUMBER;
-        hash = (53 * hash) + getSecurityParams().hashCode();
-      }
-      hash = (37 * hash) + OUTSTANDING_RPCS_PER_CHANNEL_FIELD_NUMBER;
-      hash = (53 * hash) + getOutstandingRpcsPerChannel();
-      hash = (37 * hash) + CLIENT_CHANNELS_FIELD_NUMBER;
-      hash = (53 * hash) + getClientChannels();
-      hash = (37 * hash) + ASYNC_CLIENT_THREADS_FIELD_NUMBER;
-      hash = (53 * hash) + getAsyncClientThreads();
-      hash = (37 * hash) + RPC_TYPE_FIELD_NUMBER;
-      hash = (53 * hash) + rpcType_;
-      if (hasLoadParams()) {
-        hash = (37 * hash) + LOAD_PARAMS_FIELD_NUMBER;
-        hash = (53 * hash) + getLoadParams().hashCode();
-      }
-      if (hasPayloadConfig()) {
-        hash = (37 * hash) + PAYLOAD_CONFIG_FIELD_NUMBER;
-        hash = (53 * hash) + getPayloadConfig().hashCode();
-      }
-      if (hasHistogramParams()) {
-        hash = (37 * hash) + HISTOGRAM_PARAMS_FIELD_NUMBER;
-        hash = (53 * hash) + getHistogramParams().hashCode();
-      }
-      if (getCoreListCount() > 0) {
-        hash = (37 * hash) + CORE_LIST_FIELD_NUMBER;
-        hash = (53 * hash) + getCoreListList().hashCode();
-      }
-      hash = (37 * hash) + CORE_LIMIT_FIELD_NUMBER;
-      hash = (53 * hash) + getCoreLimit();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ClientConfig parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientConfig parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientConfig parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientConfig parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientConfig parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientConfig parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientConfig parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientConfig parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientConfig parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientConfig parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.ClientConfig prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.ClientConfig}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ClientConfig)
-        io.grpc.benchmarks.proto.Control.ClientConfigOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientConfig_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientConfig_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.ClientConfig.class, io.grpc.benchmarks.proto.Control.ClientConfig.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.ClientConfig.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        serverTargets_ = com.google.protobuf.LazyStringArrayList.EMPTY;
-        bitField0_ = (bitField0_ & ~0x00000001);
-        clientType_ = 0;
-
-        if (securityParamsBuilder_ == null) {
-          securityParams_ = null;
-        } else {
-          securityParams_ = null;
-          securityParamsBuilder_ = null;
-        }
-        outstandingRpcsPerChannel_ = 0;
-
-        clientChannels_ = 0;
-
-        asyncClientThreads_ = 0;
-
-        rpcType_ = 0;
-
-        if (loadParamsBuilder_ == null) {
-          loadParams_ = null;
-        } else {
-          loadParams_ = null;
-          loadParamsBuilder_ = null;
-        }
-        if (payloadConfigBuilder_ == null) {
-          payloadConfig_ = null;
-        } else {
-          payloadConfig_ = null;
-          payloadConfigBuilder_ = null;
-        }
-        if (histogramParamsBuilder_ == null) {
-          histogramParams_ = null;
-        } else {
-          histogramParams_ = null;
-          histogramParamsBuilder_ = null;
-        }
-        coreList_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000400);
-        coreLimit_ = 0;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientConfig_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ClientConfig getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.ClientConfig.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.ClientConfig build() {
-        io.grpc.benchmarks.proto.Control.ClientConfig result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ClientConfig buildPartial() {
-        io.grpc.benchmarks.proto.Control.ClientConfig result = new io.grpc.benchmarks.proto.Control.ClientConfig(this);
-        int from_bitField0_ = bitField0_;
-        int to_bitField0_ = 0;
-        if (((bitField0_ & 0x00000001) == 0x00000001)) {
-          serverTargets_ = serverTargets_.getUnmodifiableView();
-          bitField0_ = (bitField0_ & ~0x00000001);
-        }
-        result.serverTargets_ = serverTargets_;
-        result.clientType_ = clientType_;
-        if (securityParamsBuilder_ == null) {
-          result.securityParams_ = securityParams_;
-        } else {
-          result.securityParams_ = securityParamsBuilder_.build();
-        }
-        result.outstandingRpcsPerChannel_ = outstandingRpcsPerChannel_;
-        result.clientChannels_ = clientChannels_;
-        result.asyncClientThreads_ = asyncClientThreads_;
-        result.rpcType_ = rpcType_;
-        if (loadParamsBuilder_ == null) {
-          result.loadParams_ = loadParams_;
-        } else {
-          result.loadParams_ = loadParamsBuilder_.build();
-        }
-        if (payloadConfigBuilder_ == null) {
-          result.payloadConfig_ = payloadConfig_;
-        } else {
-          result.payloadConfig_ = payloadConfigBuilder_.build();
-        }
-        if (histogramParamsBuilder_ == null) {
-          result.histogramParams_ = histogramParams_;
-        } else {
-          result.histogramParams_ = histogramParamsBuilder_.build();
-        }
-        if (((bitField0_ & 0x00000400) == 0x00000400)) {
-          coreList_ = java.util.Collections.unmodifiableList(coreList_);
-          bitField0_ = (bitField0_ & ~0x00000400);
-        }
-        result.coreList_ = coreList_;
-        result.coreLimit_ = coreLimit_;
-        result.bitField0_ = to_bitField0_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.ClientConfig) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.ClientConfig)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.ClientConfig other) {
-        if (other == io.grpc.benchmarks.proto.Control.ClientConfig.getDefaultInstance()) return this;
-        if (!other.serverTargets_.isEmpty()) {
-          if (serverTargets_.isEmpty()) {
-            serverTargets_ = other.serverTargets_;
-            bitField0_ = (bitField0_ & ~0x00000001);
-          } else {
-            ensureServerTargetsIsMutable();
-            serverTargets_.addAll(other.serverTargets_);
-          }
-          onChanged();
-        }
-        if (other.clientType_ != 0) {
-          setClientTypeValue(other.getClientTypeValue());
-        }
-        if (other.hasSecurityParams()) {
-          mergeSecurityParams(other.getSecurityParams());
-        }
-        if (other.getOutstandingRpcsPerChannel() != 0) {
-          setOutstandingRpcsPerChannel(other.getOutstandingRpcsPerChannel());
-        }
-        if (other.getClientChannels() != 0) {
-          setClientChannels(other.getClientChannels());
-        }
-        if (other.getAsyncClientThreads() != 0) {
-          setAsyncClientThreads(other.getAsyncClientThreads());
-        }
-        if (other.rpcType_ != 0) {
-          setRpcTypeValue(other.getRpcTypeValue());
-        }
-        if (other.hasLoadParams()) {
-          mergeLoadParams(other.getLoadParams());
-        }
-        if (other.hasPayloadConfig()) {
-          mergePayloadConfig(other.getPayloadConfig());
-        }
-        if (other.hasHistogramParams()) {
-          mergeHistogramParams(other.getHistogramParams());
-        }
-        if (!other.coreList_.isEmpty()) {
-          if (coreList_.isEmpty()) {
-            coreList_ = other.coreList_;
-            bitField0_ = (bitField0_ & ~0x00000400);
-          } else {
-            ensureCoreListIsMutable();
-            coreList_.addAll(other.coreList_);
-          }
-          onChanged();
-        }
-        if (other.getCoreLimit() != 0) {
-          setCoreLimit(other.getCoreLimit());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.ClientConfig parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.ClientConfig) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      private int bitField0_;
-
-      private com.google.protobuf.LazyStringList serverTargets_ = com.google.protobuf.LazyStringArrayList.EMPTY;
-      private void ensureServerTargetsIsMutable() {
-        if (!((bitField0_ & 0x00000001) == 0x00000001)) {
-          serverTargets_ = new com.google.protobuf.LazyStringArrayList(serverTargets_);
-          bitField0_ |= 0x00000001;
-         }
-      }
-      /**
-       * <pre>
-       * List of targets to connect to. At least one target needs to be specified.
-       * </pre>
-       *
-       * <code>repeated string server_targets = 1;</code>
-       */
-      public com.google.protobuf.ProtocolStringList
-          getServerTargetsList() {
-        return serverTargets_.getUnmodifiableView();
-      }
-      /**
-       * <pre>
-       * List of targets to connect to. At least one target needs to be specified.
-       * </pre>
-       *
-       * <code>repeated string server_targets = 1;</code>
-       */
-      public int getServerTargetsCount() {
-        return serverTargets_.size();
-      }
-      /**
-       * <pre>
-       * List of targets to connect to. At least one target needs to be specified.
-       * </pre>
-       *
-       * <code>repeated string server_targets = 1;</code>
-       */
-      public java.lang.String getServerTargets(int index) {
-        return serverTargets_.get(index);
-      }
-      /**
-       * <pre>
-       * List of targets to connect to. At least one target needs to be specified.
-       * </pre>
-       *
-       * <code>repeated string server_targets = 1;</code>
-       */
-      public com.google.protobuf.ByteString
-          getServerTargetsBytes(int index) {
-        return serverTargets_.getByteString(index);
-      }
-      /**
-       * <pre>
-       * List of targets to connect to. At least one target needs to be specified.
-       * </pre>
-       *
-       * <code>repeated string server_targets = 1;</code>
-       */
-      public Builder setServerTargets(
-          int index, java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  ensureServerTargetsIsMutable();
-        serverTargets_.set(index, value);
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * List of targets to connect to. At least one target needs to be specified.
-       * </pre>
-       *
-       * <code>repeated string server_targets = 1;</code>
-       */
-      public Builder addServerTargets(
-          java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  ensureServerTargetsIsMutable();
-        serverTargets_.add(value);
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * List of targets to connect to. At least one target needs to be specified.
-       * </pre>
-       *
-       * <code>repeated string server_targets = 1;</code>
-       */
-      public Builder addAllServerTargets(
-          java.lang.Iterable<java.lang.String> values) {
-        ensureServerTargetsIsMutable();
-        com.google.protobuf.AbstractMessageLite.Builder.addAll(
-            values, serverTargets_);
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * List of targets to connect to. At least one target needs to be specified.
-       * </pre>
-       *
-       * <code>repeated string server_targets = 1;</code>
-       */
-      public Builder clearServerTargets() {
-        serverTargets_ = com.google.protobuf.LazyStringArrayList.EMPTY;
-        bitField0_ = (bitField0_ & ~0x00000001);
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * List of targets to connect to. At least one target needs to be specified.
-       * </pre>
-       *
-       * <code>repeated string server_targets = 1;</code>
-       */
-      public Builder addServerTargetsBytes(
-          com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-        ensureServerTargetsIsMutable();
-        serverTargets_.add(value);
-        onChanged();
-        return this;
-      }
-
-      private int clientType_ = 0;
-      /**
-       * <code>.grpc.testing.ClientType client_type = 2;</code>
-       */
-      public int getClientTypeValue() {
-        return clientType_;
-      }
-      /**
-       * <code>.grpc.testing.ClientType client_type = 2;</code>
-       */
-      public Builder setClientTypeValue(int value) {
-        clientType_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClientType client_type = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ClientType getClientType() {
-        io.grpc.benchmarks.proto.Control.ClientType result = io.grpc.benchmarks.proto.Control.ClientType.valueOf(clientType_);
-        return result == null ? io.grpc.benchmarks.proto.Control.ClientType.UNRECOGNIZED : result;
-      }
-      /**
-       * <code>.grpc.testing.ClientType client_type = 2;</code>
-       */
-      public Builder setClientType(io.grpc.benchmarks.proto.Control.ClientType value) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        
-        clientType_ = value.getNumber();
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClientType client_type = 2;</code>
-       */
-      public Builder clearClientType() {
-        
-        clientType_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private io.grpc.benchmarks.proto.Control.SecurityParams securityParams_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.SecurityParams, io.grpc.benchmarks.proto.Control.SecurityParams.Builder, io.grpc.benchmarks.proto.Control.SecurityParamsOrBuilder> securityParamsBuilder_;
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-       */
-      public boolean hasSecurityParams() {
-        return securityParamsBuilder_ != null || securityParams_ != null;
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.SecurityParams getSecurityParams() {
-        if (securityParamsBuilder_ == null) {
-          return securityParams_ == null ? io.grpc.benchmarks.proto.Control.SecurityParams.getDefaultInstance() : securityParams_;
-        } else {
-          return securityParamsBuilder_.getMessage();
-        }
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-       */
-      public Builder setSecurityParams(io.grpc.benchmarks.proto.Control.SecurityParams value) {
-        if (securityParamsBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          securityParams_ = value;
-          onChanged();
-        } else {
-          securityParamsBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-       */
-      public Builder setSecurityParams(
-          io.grpc.benchmarks.proto.Control.SecurityParams.Builder builderForValue) {
-        if (securityParamsBuilder_ == null) {
-          securityParams_ = builderForValue.build();
-          onChanged();
-        } else {
-          securityParamsBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-       */
-      public Builder mergeSecurityParams(io.grpc.benchmarks.proto.Control.SecurityParams value) {
-        if (securityParamsBuilder_ == null) {
-          if (securityParams_ != null) {
-            securityParams_ =
-              io.grpc.benchmarks.proto.Control.SecurityParams.newBuilder(securityParams_).mergeFrom(value).buildPartial();
-          } else {
-            securityParams_ = value;
-          }
-          onChanged();
-        } else {
-          securityParamsBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-       */
-      public Builder clearSecurityParams() {
-        if (securityParamsBuilder_ == null) {
-          securityParams_ = null;
-          onChanged();
-        } else {
-          securityParams_ = null;
-          securityParamsBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.SecurityParams.Builder getSecurityParamsBuilder() {
-        
-        onChanged();
-        return getSecurityParamsFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.SecurityParamsOrBuilder getSecurityParamsOrBuilder() {
-        if (securityParamsBuilder_ != null) {
-          return securityParamsBuilder_.getMessageOrBuilder();
-        } else {
-          return securityParams_ == null ?
-              io.grpc.benchmarks.proto.Control.SecurityParams.getDefaultInstance() : securityParams_;
-        }
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 3;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.SecurityParams, io.grpc.benchmarks.proto.Control.SecurityParams.Builder, io.grpc.benchmarks.proto.Control.SecurityParamsOrBuilder> 
-          getSecurityParamsFieldBuilder() {
-        if (securityParamsBuilder_ == null) {
-          securityParamsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Control.SecurityParams, io.grpc.benchmarks.proto.Control.SecurityParams.Builder, io.grpc.benchmarks.proto.Control.SecurityParamsOrBuilder>(
-                  getSecurityParams(),
-                  getParentForChildren(),
-                  isClean());
-          securityParams_ = null;
-        }
-        return securityParamsBuilder_;
-      }
-
-      private int outstandingRpcsPerChannel_ ;
-      /**
-       * <pre>
-       * How many concurrent RPCs to start for each channel.
-       * For synchronous client, use a separate thread for each outstanding RPC.
-       * </pre>
-       *
-       * <code>int32 outstanding_rpcs_per_channel = 4;</code>
-       */
-      public int getOutstandingRpcsPerChannel() {
-        return outstandingRpcsPerChannel_;
-      }
-      /**
-       * <pre>
-       * How many concurrent RPCs to start for each channel.
-       * For synchronous client, use a separate thread for each outstanding RPC.
-       * </pre>
-       *
-       * <code>int32 outstanding_rpcs_per_channel = 4;</code>
-       */
-      public Builder setOutstandingRpcsPerChannel(int value) {
-        
-        outstandingRpcsPerChannel_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * How many concurrent RPCs to start for each channel.
-       * For synchronous client, use a separate thread for each outstanding RPC.
-       * </pre>
-       *
-       * <code>int32 outstanding_rpcs_per_channel = 4;</code>
-       */
-      public Builder clearOutstandingRpcsPerChannel() {
-        
-        outstandingRpcsPerChannel_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private int clientChannels_ ;
-      /**
-       * <pre>
-       * Number of independent client channels to create.
-       * i-th channel will connect to server_target[i % server_targets.size()]
-       * </pre>
-       *
-       * <code>int32 client_channels = 5;</code>
-       */
-      public int getClientChannels() {
-        return clientChannels_;
-      }
-      /**
-       * <pre>
-       * Number of independent client channels to create.
-       * i-th channel will connect to server_target[i % server_targets.size()]
-       * </pre>
-       *
-       * <code>int32 client_channels = 5;</code>
-       */
-      public Builder setClientChannels(int value) {
-        
-        clientChannels_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Number of independent client channels to create.
-       * i-th channel will connect to server_target[i % server_targets.size()]
-       * </pre>
-       *
-       * <code>int32 client_channels = 5;</code>
-       */
-      public Builder clearClientChannels() {
-        
-        clientChannels_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private int asyncClientThreads_ ;
-      /**
-       * <pre>
-       * Only for async client. Number of threads to use to start/manage RPCs.
-       * </pre>
-       *
-       * <code>int32 async_client_threads = 7;</code>
-       */
-      public int getAsyncClientThreads() {
-        return asyncClientThreads_;
-      }
-      /**
-       * <pre>
-       * Only for async client. Number of threads to use to start/manage RPCs.
-       * </pre>
-       *
-       * <code>int32 async_client_threads = 7;</code>
-       */
-      public Builder setAsyncClientThreads(int value) {
-        
-        asyncClientThreads_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Only for async client. Number of threads to use to start/manage RPCs.
-       * </pre>
-       *
-       * <code>int32 async_client_threads = 7;</code>
-       */
-      public Builder clearAsyncClientThreads() {
-        
-        asyncClientThreads_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private int rpcType_ = 0;
-      /**
-       * <code>.grpc.testing.RpcType rpc_type = 8;</code>
-       */
-      public int getRpcTypeValue() {
-        return rpcType_;
-      }
-      /**
-       * <code>.grpc.testing.RpcType rpc_type = 8;</code>
-       */
-      public Builder setRpcTypeValue(int value) {
-        rpcType_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.RpcType rpc_type = 8;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.RpcType getRpcType() {
-        io.grpc.benchmarks.proto.Control.RpcType result = io.grpc.benchmarks.proto.Control.RpcType.valueOf(rpcType_);
-        return result == null ? io.grpc.benchmarks.proto.Control.RpcType.UNRECOGNIZED : result;
-      }
-      /**
-       * <code>.grpc.testing.RpcType rpc_type = 8;</code>
-       */
-      public Builder setRpcType(io.grpc.benchmarks.proto.Control.RpcType value) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        
-        rpcType_ = value.getNumber();
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.RpcType rpc_type = 8;</code>
-       */
-      public Builder clearRpcType() {
-        
-        rpcType_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private io.grpc.benchmarks.proto.Control.LoadParams loadParams_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.LoadParams, io.grpc.benchmarks.proto.Control.LoadParams.Builder, io.grpc.benchmarks.proto.Control.LoadParamsOrBuilder> loadParamsBuilder_;
-      /**
-       * <pre>
-       * The requested load for the entire client (aggregated over all the threads).
-       * </pre>
-       *
-       * <code>.grpc.testing.LoadParams load_params = 10;</code>
-       */
-      public boolean hasLoadParams() {
-        return loadParamsBuilder_ != null || loadParams_ != null;
-      }
-      /**
-       * <pre>
-       * The requested load for the entire client (aggregated over all the threads).
-       * </pre>
-       *
-       * <code>.grpc.testing.LoadParams load_params = 10;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.LoadParams getLoadParams() {
-        if (loadParamsBuilder_ == null) {
-          return loadParams_ == null ? io.grpc.benchmarks.proto.Control.LoadParams.getDefaultInstance() : loadParams_;
-        } else {
-          return loadParamsBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * The requested load for the entire client (aggregated over all the threads).
-       * </pre>
-       *
-       * <code>.grpc.testing.LoadParams load_params = 10;</code>
-       */
-      public Builder setLoadParams(io.grpc.benchmarks.proto.Control.LoadParams value) {
-        if (loadParamsBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          loadParams_ = value;
-          onChanged();
-        } else {
-          loadParamsBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * The requested load for the entire client (aggregated over all the threads).
-       * </pre>
-       *
-       * <code>.grpc.testing.LoadParams load_params = 10;</code>
-       */
-      public Builder setLoadParams(
-          io.grpc.benchmarks.proto.Control.LoadParams.Builder builderForValue) {
-        if (loadParamsBuilder_ == null) {
-          loadParams_ = builderForValue.build();
-          onChanged();
-        } else {
-          loadParamsBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * The requested load for the entire client (aggregated over all the threads).
-       * </pre>
-       *
-       * <code>.grpc.testing.LoadParams load_params = 10;</code>
-       */
-      public Builder mergeLoadParams(io.grpc.benchmarks.proto.Control.LoadParams value) {
-        if (loadParamsBuilder_ == null) {
-          if (loadParams_ != null) {
-            loadParams_ =
-              io.grpc.benchmarks.proto.Control.LoadParams.newBuilder(loadParams_).mergeFrom(value).buildPartial();
-          } else {
-            loadParams_ = value;
-          }
-          onChanged();
-        } else {
-          loadParamsBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * The requested load for the entire client (aggregated over all the threads).
-       * </pre>
-       *
-       * <code>.grpc.testing.LoadParams load_params = 10;</code>
-       */
-      public Builder clearLoadParams() {
-        if (loadParamsBuilder_ == null) {
-          loadParams_ = null;
-          onChanged();
-        } else {
-          loadParams_ = null;
-          loadParamsBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * The requested load for the entire client (aggregated over all the threads).
-       * </pre>
-       *
-       * <code>.grpc.testing.LoadParams load_params = 10;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.LoadParams.Builder getLoadParamsBuilder() {
-        
-        onChanged();
-        return getLoadParamsFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * The requested load for the entire client (aggregated over all the threads).
-       * </pre>
-       *
-       * <code>.grpc.testing.LoadParams load_params = 10;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.LoadParamsOrBuilder getLoadParamsOrBuilder() {
-        if (loadParamsBuilder_ != null) {
-          return loadParamsBuilder_.getMessageOrBuilder();
-        } else {
-          return loadParams_ == null ?
-              io.grpc.benchmarks.proto.Control.LoadParams.getDefaultInstance() : loadParams_;
-        }
-      }
-      /**
-       * <pre>
-       * The requested load for the entire client (aggregated over all the threads).
-       * </pre>
-       *
-       * <code>.grpc.testing.LoadParams load_params = 10;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.LoadParams, io.grpc.benchmarks.proto.Control.LoadParams.Builder, io.grpc.benchmarks.proto.Control.LoadParamsOrBuilder> 
-          getLoadParamsFieldBuilder() {
-        if (loadParamsBuilder_ == null) {
-          loadParamsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Control.LoadParams, io.grpc.benchmarks.proto.Control.LoadParams.Builder, io.grpc.benchmarks.proto.Control.LoadParamsOrBuilder>(
-                  getLoadParams(),
-                  getParentForChildren(),
-                  isClean());
-          loadParams_ = null;
-        }
-        return loadParamsBuilder_;
-      }
-
-      private io.grpc.benchmarks.proto.Payloads.PayloadConfig payloadConfig_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Payloads.PayloadConfig, io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder, io.grpc.benchmarks.proto.Payloads.PayloadConfigOrBuilder> payloadConfigBuilder_;
-      /**
-       * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-       */
-      public boolean hasPayloadConfig() {
-        return payloadConfigBuilder_ != null || payloadConfig_ != null;
-      }
-      /**
-       * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.PayloadConfig getPayloadConfig() {
-        if (payloadConfigBuilder_ == null) {
-          return payloadConfig_ == null ? io.grpc.benchmarks.proto.Payloads.PayloadConfig.getDefaultInstance() : payloadConfig_;
-        } else {
-          return payloadConfigBuilder_.getMessage();
-        }
-      }
-      /**
-       * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-       */
-      public Builder setPayloadConfig(io.grpc.benchmarks.proto.Payloads.PayloadConfig value) {
-        if (payloadConfigBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payloadConfig_ = value;
-          onChanged();
-        } else {
-          payloadConfigBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-       */
-      public Builder setPayloadConfig(
-          io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder builderForValue) {
-        if (payloadConfigBuilder_ == null) {
-          payloadConfig_ = builderForValue.build();
-          onChanged();
-        } else {
-          payloadConfigBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-       */
-      public Builder mergePayloadConfig(io.grpc.benchmarks.proto.Payloads.PayloadConfig value) {
-        if (payloadConfigBuilder_ == null) {
-          if (payloadConfig_ != null) {
-            payloadConfig_ =
-              io.grpc.benchmarks.proto.Payloads.PayloadConfig.newBuilder(payloadConfig_).mergeFrom(value).buildPartial();
-          } else {
-            payloadConfig_ = value;
-          }
-          onChanged();
-        } else {
-          payloadConfigBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-       */
-      public Builder clearPayloadConfig() {
-        if (payloadConfigBuilder_ == null) {
-          payloadConfig_ = null;
-          onChanged();
-        } else {
-          payloadConfig_ = null;
-          payloadConfigBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder getPayloadConfigBuilder() {
-        
-        onChanged();
-        return getPayloadConfigFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.PayloadConfigOrBuilder getPayloadConfigOrBuilder() {
-        if (payloadConfigBuilder_ != null) {
-          return payloadConfigBuilder_.getMessageOrBuilder();
-        } else {
-          return payloadConfig_ == null ?
-              io.grpc.benchmarks.proto.Payloads.PayloadConfig.getDefaultInstance() : payloadConfig_;
-        }
-      }
-      /**
-       * <code>.grpc.testing.PayloadConfig payload_config = 11;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Payloads.PayloadConfig, io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder, io.grpc.benchmarks.proto.Payloads.PayloadConfigOrBuilder> 
-          getPayloadConfigFieldBuilder() {
-        if (payloadConfigBuilder_ == null) {
-          payloadConfigBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Payloads.PayloadConfig, io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder, io.grpc.benchmarks.proto.Payloads.PayloadConfigOrBuilder>(
-                  getPayloadConfig(),
-                  getParentForChildren(),
-                  isClean());
-          payloadConfig_ = null;
-        }
-        return payloadConfigBuilder_;
-      }
-
-      private io.grpc.benchmarks.proto.Stats.HistogramParams histogramParams_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Stats.HistogramParams, io.grpc.benchmarks.proto.Stats.HistogramParams.Builder, io.grpc.benchmarks.proto.Stats.HistogramParamsOrBuilder> histogramParamsBuilder_;
-      /**
-       * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-       */
-      public boolean hasHistogramParams() {
-        return histogramParamsBuilder_ != null || histogramParams_ != null;
-      }
-      /**
-       * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-       */
-      public io.grpc.benchmarks.proto.Stats.HistogramParams getHistogramParams() {
-        if (histogramParamsBuilder_ == null) {
-          return histogramParams_ == null ? io.grpc.benchmarks.proto.Stats.HistogramParams.getDefaultInstance() : histogramParams_;
-        } else {
-          return histogramParamsBuilder_.getMessage();
-        }
-      }
-      /**
-       * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-       */
-      public Builder setHistogramParams(io.grpc.benchmarks.proto.Stats.HistogramParams value) {
-        if (histogramParamsBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          histogramParams_ = value;
-          onChanged();
-        } else {
-          histogramParamsBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-       */
-      public Builder setHistogramParams(
-          io.grpc.benchmarks.proto.Stats.HistogramParams.Builder builderForValue) {
-        if (histogramParamsBuilder_ == null) {
-          histogramParams_ = builderForValue.build();
-          onChanged();
-        } else {
-          histogramParamsBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-       */
-      public Builder mergeHistogramParams(io.grpc.benchmarks.proto.Stats.HistogramParams value) {
-        if (histogramParamsBuilder_ == null) {
-          if (histogramParams_ != null) {
-            histogramParams_ =
-              io.grpc.benchmarks.proto.Stats.HistogramParams.newBuilder(histogramParams_).mergeFrom(value).buildPartial();
-          } else {
-            histogramParams_ = value;
-          }
-          onChanged();
-        } else {
-          histogramParamsBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-       */
-      public Builder clearHistogramParams() {
-        if (histogramParamsBuilder_ == null) {
-          histogramParams_ = null;
-          onChanged();
-        } else {
-          histogramParams_ = null;
-          histogramParamsBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-       */
-      public io.grpc.benchmarks.proto.Stats.HistogramParams.Builder getHistogramParamsBuilder() {
-        
-        onChanged();
-        return getHistogramParamsFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-       */
-      public io.grpc.benchmarks.proto.Stats.HistogramParamsOrBuilder getHistogramParamsOrBuilder() {
-        if (histogramParamsBuilder_ != null) {
-          return histogramParamsBuilder_.getMessageOrBuilder();
-        } else {
-          return histogramParams_ == null ?
-              io.grpc.benchmarks.proto.Stats.HistogramParams.getDefaultInstance() : histogramParams_;
-        }
-      }
-      /**
-       * <code>.grpc.testing.HistogramParams histogram_params = 12;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Stats.HistogramParams, io.grpc.benchmarks.proto.Stats.HistogramParams.Builder, io.grpc.benchmarks.proto.Stats.HistogramParamsOrBuilder> 
-          getHistogramParamsFieldBuilder() {
-        if (histogramParamsBuilder_ == null) {
-          histogramParamsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Stats.HistogramParams, io.grpc.benchmarks.proto.Stats.HistogramParams.Builder, io.grpc.benchmarks.proto.Stats.HistogramParamsOrBuilder>(
-                  getHistogramParams(),
-                  getParentForChildren(),
-                  isClean());
-          histogramParams_ = null;
-        }
-        return histogramParamsBuilder_;
-      }
-
-      private java.util.List<java.lang.Integer> coreList_ = java.util.Collections.emptyList();
-      private void ensureCoreListIsMutable() {
-        if (!((bitField0_ & 0x00000400) == 0x00000400)) {
-          coreList_ = new java.util.ArrayList<java.lang.Integer>(coreList_);
-          bitField0_ |= 0x00000400;
-         }
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the client on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 13;</code>
-       */
-      public java.util.List<java.lang.Integer>
-          getCoreListList() {
-        return java.util.Collections.unmodifiableList(coreList_);
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the client on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 13;</code>
-       */
-      public int getCoreListCount() {
-        return coreList_.size();
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the client on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 13;</code>
-       */
-      public int getCoreList(int index) {
-        return coreList_.get(index);
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the client on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 13;</code>
-       */
-      public Builder setCoreList(
-          int index, int value) {
-        ensureCoreListIsMutable();
-        coreList_.set(index, value);
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the client on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 13;</code>
-       */
-      public Builder addCoreList(int value) {
-        ensureCoreListIsMutable();
-        coreList_.add(value);
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the client on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 13;</code>
-       */
-      public Builder addAllCoreList(
-          java.lang.Iterable<? extends java.lang.Integer> values) {
-        ensureCoreListIsMutable();
-        com.google.protobuf.AbstractMessageLite.Builder.addAll(
-            values, coreList_);
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the client on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 13;</code>
-       */
-      public Builder clearCoreList() {
-        coreList_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000400);
-        onChanged();
-        return this;
-      }
-
-      private int coreLimit_ ;
-      /**
-       * <code>int32 core_limit = 14;</code>
-       */
-      public int getCoreLimit() {
-        return coreLimit_;
-      }
-      /**
-       * <code>int32 core_limit = 14;</code>
-       */
-      public Builder setCoreLimit(int value) {
-        
-        coreLimit_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>int32 core_limit = 14;</code>
-       */
-      public Builder clearCoreLimit() {
-        
-        coreLimit_ = 0;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ClientConfig)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ClientConfig)
-    private static final io.grpc.benchmarks.proto.Control.ClientConfig DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.ClientConfig();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ClientConfig getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ClientConfig>
-        PARSER = new com.google.protobuf.AbstractParser<ClientConfig>() {
-      public ClientConfig parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ClientConfig(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ClientConfig> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ClientConfig> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.ClientConfig getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ClientStatusOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ClientStatus)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>.grpc.testing.ClientStats stats = 1;</code>
-     */
-    boolean hasStats();
-    /**
-     * <code>.grpc.testing.ClientStats stats = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Stats.ClientStats getStats();
-    /**
-     * <code>.grpc.testing.ClientStats stats = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Stats.ClientStatsOrBuilder getStatsOrBuilder();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.ClientStatus}
-   */
-  public  static final class ClientStatus extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ClientStatus)
-      ClientStatusOrBuilder {
-    // Use ClientStatus.newBuilder() to construct.
-    private ClientStatus(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ClientStatus() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ClientStatus(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              io.grpc.benchmarks.proto.Stats.ClientStats.Builder subBuilder = null;
-              if (stats_ != null) {
-                subBuilder = stats_.toBuilder();
-              }
-              stats_ = input.readMessage(io.grpc.benchmarks.proto.Stats.ClientStats.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(stats_);
-                stats_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientStatus_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientStatus_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.ClientStatus.class, io.grpc.benchmarks.proto.Control.ClientStatus.Builder.class);
-    }
-
-    public static final int STATS_FIELD_NUMBER = 1;
-    private io.grpc.benchmarks.proto.Stats.ClientStats stats_;
-    /**
-     * <code>.grpc.testing.ClientStats stats = 1;</code>
-     */
-    public boolean hasStats() {
-      return stats_ != null;
-    }
-    /**
-     * <code>.grpc.testing.ClientStats stats = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Stats.ClientStats getStats() {
-      return stats_ == null ? io.grpc.benchmarks.proto.Stats.ClientStats.getDefaultInstance() : stats_;
-    }
-    /**
-     * <code>.grpc.testing.ClientStats stats = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Stats.ClientStatsOrBuilder getStatsOrBuilder() {
-      return getStats();
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (stats_ != null) {
-        output.writeMessage(1, getStats());
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (stats_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, getStats());
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.ClientStatus)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.ClientStatus other = (io.grpc.benchmarks.proto.Control.ClientStatus) obj;
-
-      boolean result = true;
-      result = result && (hasStats() == other.hasStats());
-      if (hasStats()) {
-        result = result && getStats()
-            .equals(other.getStats());
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      if (hasStats()) {
-        hash = (37 * hash) + STATS_FIELD_NUMBER;
-        hash = (53 * hash) + getStats().hashCode();
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ClientStatus parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientStatus parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientStatus parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientStatus parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientStatus parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientStatus parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientStatus parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientStatus parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientStatus parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientStatus parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.ClientStatus prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.ClientStatus}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ClientStatus)
-        io.grpc.benchmarks.proto.Control.ClientStatusOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientStatus_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientStatus_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.ClientStatus.class, io.grpc.benchmarks.proto.Control.ClientStatus.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.ClientStatus.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        if (statsBuilder_ == null) {
-          stats_ = null;
-        } else {
-          stats_ = null;
-          statsBuilder_ = null;
-        }
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientStatus_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ClientStatus getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.ClientStatus.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.ClientStatus build() {
-        io.grpc.benchmarks.proto.Control.ClientStatus result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ClientStatus buildPartial() {
-        io.grpc.benchmarks.proto.Control.ClientStatus result = new io.grpc.benchmarks.proto.Control.ClientStatus(this);
-        if (statsBuilder_ == null) {
-          result.stats_ = stats_;
-        } else {
-          result.stats_ = statsBuilder_.build();
-        }
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.ClientStatus) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.ClientStatus)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.ClientStatus other) {
-        if (other == io.grpc.benchmarks.proto.Control.ClientStatus.getDefaultInstance()) return this;
-        if (other.hasStats()) {
-          mergeStats(other.getStats());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.ClientStatus parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.ClientStatus) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private io.grpc.benchmarks.proto.Stats.ClientStats stats_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Stats.ClientStats, io.grpc.benchmarks.proto.Stats.ClientStats.Builder, io.grpc.benchmarks.proto.Stats.ClientStatsOrBuilder> statsBuilder_;
-      /**
-       * <code>.grpc.testing.ClientStats stats = 1;</code>
-       */
-      public boolean hasStats() {
-        return statsBuilder_ != null || stats_ != null;
-      }
-      /**
-       * <code>.grpc.testing.ClientStats stats = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Stats.ClientStats getStats() {
-        if (statsBuilder_ == null) {
-          return stats_ == null ? io.grpc.benchmarks.proto.Stats.ClientStats.getDefaultInstance() : stats_;
-        } else {
-          return statsBuilder_.getMessage();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ClientStats stats = 1;</code>
-       */
-      public Builder setStats(io.grpc.benchmarks.proto.Stats.ClientStats value) {
-        if (statsBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          stats_ = value;
-          onChanged();
-        } else {
-          statsBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClientStats stats = 1;</code>
-       */
-      public Builder setStats(
-          io.grpc.benchmarks.proto.Stats.ClientStats.Builder builderForValue) {
-        if (statsBuilder_ == null) {
-          stats_ = builderForValue.build();
-          onChanged();
-        } else {
-          statsBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClientStats stats = 1;</code>
-       */
-      public Builder mergeStats(io.grpc.benchmarks.proto.Stats.ClientStats value) {
-        if (statsBuilder_ == null) {
-          if (stats_ != null) {
-            stats_ =
-              io.grpc.benchmarks.proto.Stats.ClientStats.newBuilder(stats_).mergeFrom(value).buildPartial();
-          } else {
-            stats_ = value;
-          }
-          onChanged();
-        } else {
-          statsBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClientStats stats = 1;</code>
-       */
-      public Builder clearStats() {
-        if (statsBuilder_ == null) {
-          stats_ = null;
-          onChanged();
-        } else {
-          stats_ = null;
-          statsBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClientStats stats = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Stats.ClientStats.Builder getStatsBuilder() {
-        
-        onChanged();
-        return getStatsFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.ClientStats stats = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Stats.ClientStatsOrBuilder getStatsOrBuilder() {
-        if (statsBuilder_ != null) {
-          return statsBuilder_.getMessageOrBuilder();
-        } else {
-          return stats_ == null ?
-              io.grpc.benchmarks.proto.Stats.ClientStats.getDefaultInstance() : stats_;
-        }
-      }
-      /**
-       * <code>.grpc.testing.ClientStats stats = 1;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Stats.ClientStats, io.grpc.benchmarks.proto.Stats.ClientStats.Builder, io.grpc.benchmarks.proto.Stats.ClientStatsOrBuilder> 
-          getStatsFieldBuilder() {
-        if (statsBuilder_ == null) {
-          statsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Stats.ClientStats, io.grpc.benchmarks.proto.Stats.ClientStats.Builder, io.grpc.benchmarks.proto.Stats.ClientStatsOrBuilder>(
-                  getStats(),
-                  getParentForChildren(),
-                  isClean());
-          stats_ = null;
-        }
-        return statsBuilder_;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ClientStatus)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ClientStatus)
-    private static final io.grpc.benchmarks.proto.Control.ClientStatus DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.ClientStatus();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ClientStatus getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ClientStatus>
-        PARSER = new com.google.protobuf.AbstractParser<ClientStatus>() {
-      public ClientStatus parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ClientStatus(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ClientStatus> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ClientStatus> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.ClientStatus getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface MarkOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.Mark)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * if true, the stats will be reset after taking their snapshot.
-     * </pre>
-     *
-     * <code>bool reset = 1;</code>
-     */
-    boolean getReset();
-  }
-  /**
-   * <pre>
-   * Request current stats
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.Mark}
-   */
-  public  static final class Mark extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.Mark)
-      MarkOrBuilder {
-    // Use Mark.newBuilder() to construct.
-    private Mark(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private Mark() {
-      reset_ = false;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private Mark(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              reset_ = input.readBool();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_Mark_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_Mark_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.Mark.class, io.grpc.benchmarks.proto.Control.Mark.Builder.class);
-    }
-
-    public static final int RESET_FIELD_NUMBER = 1;
-    private boolean reset_;
-    /**
-     * <pre>
-     * if true, the stats will be reset after taking their snapshot.
-     * </pre>
-     *
-     * <code>bool reset = 1;</code>
-     */
-    public boolean getReset() {
-      return reset_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (reset_ != false) {
-        output.writeBool(1, reset_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (reset_ != false) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeBoolSize(1, reset_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.Mark)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.Mark other = (io.grpc.benchmarks.proto.Control.Mark) obj;
-
-      boolean result = true;
-      result = result && (getReset()
-          == other.getReset());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + RESET_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
-          getReset());
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.Mark parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.Mark parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.Mark parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.Mark parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.Mark parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.Mark parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.Mark parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.Mark parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.Mark parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.Mark parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.Mark prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Request current stats
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.Mark}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.Mark)
-        io.grpc.benchmarks.proto.Control.MarkOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_Mark_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_Mark_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.Mark.class, io.grpc.benchmarks.proto.Control.Mark.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.Mark.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        reset_ = false;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_Mark_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.Mark getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.Mark build() {
-        io.grpc.benchmarks.proto.Control.Mark result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.Mark buildPartial() {
-        io.grpc.benchmarks.proto.Control.Mark result = new io.grpc.benchmarks.proto.Control.Mark(this);
-        result.reset_ = reset_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.Mark) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.Mark)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.Mark other) {
-        if (other == io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance()) return this;
-        if (other.getReset() != false) {
-          setReset(other.getReset());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.Mark parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.Mark) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private boolean reset_ ;
-      /**
-       * <pre>
-       * if true, the stats will be reset after taking their snapshot.
-       * </pre>
-       *
-       * <code>bool reset = 1;</code>
-       */
-      public boolean getReset() {
-        return reset_;
-      }
-      /**
-       * <pre>
-       * if true, the stats will be reset after taking their snapshot.
-       * </pre>
-       *
-       * <code>bool reset = 1;</code>
-       */
-      public Builder setReset(boolean value) {
-        
-        reset_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * if true, the stats will be reset after taking their snapshot.
-       * </pre>
-       *
-       * <code>bool reset = 1;</code>
-       */
-      public Builder clearReset() {
-        
-        reset_ = false;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.Mark)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.Mark)
-    private static final io.grpc.benchmarks.proto.Control.Mark DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.Mark();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.Mark getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<Mark>
-        PARSER = new com.google.protobuf.AbstractParser<Mark>() {
-      public Mark parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new Mark(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<Mark> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<Mark> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.Mark getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ClientArgsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ClientArgs)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>.grpc.testing.ClientConfig setup = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Control.ClientConfig getSetup();
-    /**
-     * <code>.grpc.testing.ClientConfig setup = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Control.ClientConfigOrBuilder getSetupOrBuilder();
-
-    /**
-     * <code>.grpc.testing.Mark mark = 2;</code>
-     */
-    io.grpc.benchmarks.proto.Control.Mark getMark();
-    /**
-     * <code>.grpc.testing.Mark mark = 2;</code>
-     */
-    io.grpc.benchmarks.proto.Control.MarkOrBuilder getMarkOrBuilder();
-
-    public io.grpc.benchmarks.proto.Control.ClientArgs.ArgtypeCase getArgtypeCase();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.ClientArgs}
-   */
-  public  static final class ClientArgs extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ClientArgs)
-      ClientArgsOrBuilder {
-    // Use ClientArgs.newBuilder() to construct.
-    private ClientArgs(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ClientArgs() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ClientArgs(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              io.grpc.benchmarks.proto.Control.ClientConfig.Builder subBuilder = null;
-              if (argtypeCase_ == 1) {
-                subBuilder = ((io.grpc.benchmarks.proto.Control.ClientConfig) argtype_).toBuilder();
-              }
-              argtype_ =
-                  input.readMessage(io.grpc.benchmarks.proto.Control.ClientConfig.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom((io.grpc.benchmarks.proto.Control.ClientConfig) argtype_);
-                argtype_ = subBuilder.buildPartial();
-              }
-              argtypeCase_ = 1;
-              break;
-            }
-            case 18: {
-              io.grpc.benchmarks.proto.Control.Mark.Builder subBuilder = null;
-              if (argtypeCase_ == 2) {
-                subBuilder = ((io.grpc.benchmarks.proto.Control.Mark) argtype_).toBuilder();
-              }
-              argtype_ =
-                  input.readMessage(io.grpc.benchmarks.proto.Control.Mark.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom((io.grpc.benchmarks.proto.Control.Mark) argtype_);
-                argtype_ = subBuilder.buildPartial();
-              }
-              argtypeCase_ = 2;
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientArgs_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientArgs_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.ClientArgs.class, io.grpc.benchmarks.proto.Control.ClientArgs.Builder.class);
-    }
-
-    private int argtypeCase_ = 0;
-    private java.lang.Object argtype_;
-    public enum ArgtypeCase
-        implements com.google.protobuf.Internal.EnumLite {
-      SETUP(1),
-      MARK(2),
-      ARGTYPE_NOT_SET(0);
-      private final int value;
-      private ArgtypeCase(int value) {
-        this.value = value;
-      }
-      /**
-       * @deprecated Use {@link #forNumber(int)} instead.
-       */
-      @java.lang.Deprecated
-      public static ArgtypeCase valueOf(int value) {
-        return forNumber(value);
-      }
-
-      public static ArgtypeCase forNumber(int value) {
-        switch (value) {
-          case 1: return SETUP;
-          case 2: return MARK;
-          case 0: return ARGTYPE_NOT_SET;
-          default: return null;
-        }
-      }
-      public int getNumber() {
-        return this.value;
-      }
-    };
-
-    public ArgtypeCase
-    getArgtypeCase() {
-      return ArgtypeCase.forNumber(
-          argtypeCase_);
-    }
-
-    public static final int SETUP_FIELD_NUMBER = 1;
-    /**
-     * <code>.grpc.testing.ClientConfig setup = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.ClientConfig getSetup() {
-      if (argtypeCase_ == 1) {
-         return (io.grpc.benchmarks.proto.Control.ClientConfig) argtype_;
-      }
-      return io.grpc.benchmarks.proto.Control.ClientConfig.getDefaultInstance();
-    }
-    /**
-     * <code>.grpc.testing.ClientConfig setup = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.ClientConfigOrBuilder getSetupOrBuilder() {
-      if (argtypeCase_ == 1) {
-         return (io.grpc.benchmarks.proto.Control.ClientConfig) argtype_;
-      }
-      return io.grpc.benchmarks.proto.Control.ClientConfig.getDefaultInstance();
-    }
-
-    public static final int MARK_FIELD_NUMBER = 2;
-    /**
-     * <code>.grpc.testing.Mark mark = 2;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.Mark getMark() {
-      if (argtypeCase_ == 2) {
-         return (io.grpc.benchmarks.proto.Control.Mark) argtype_;
-      }
-      return io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance();
-    }
-    /**
-     * <code>.grpc.testing.Mark mark = 2;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.MarkOrBuilder getMarkOrBuilder() {
-      if (argtypeCase_ == 2) {
-         return (io.grpc.benchmarks.proto.Control.Mark) argtype_;
-      }
-      return io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance();
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (argtypeCase_ == 1) {
-        output.writeMessage(1, (io.grpc.benchmarks.proto.Control.ClientConfig) argtype_);
-      }
-      if (argtypeCase_ == 2) {
-        output.writeMessage(2, (io.grpc.benchmarks.proto.Control.Mark) argtype_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (argtypeCase_ == 1) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, (io.grpc.benchmarks.proto.Control.ClientConfig) argtype_);
-      }
-      if (argtypeCase_ == 2) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(2, (io.grpc.benchmarks.proto.Control.Mark) argtype_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.ClientArgs)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.ClientArgs other = (io.grpc.benchmarks.proto.Control.ClientArgs) obj;
-
-      boolean result = true;
-      result = result && getArgtypeCase().equals(
-          other.getArgtypeCase());
-      if (!result) return false;
-      switch (argtypeCase_) {
-        case 1:
-          result = result && getSetup()
-              .equals(other.getSetup());
-          break;
-        case 2:
-          result = result && getMark()
-              .equals(other.getMark());
-          break;
-        case 0:
-        default:
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      switch (argtypeCase_) {
-        case 1:
-          hash = (37 * hash) + SETUP_FIELD_NUMBER;
-          hash = (53 * hash) + getSetup().hashCode();
-          break;
-        case 2:
-          hash = (37 * hash) + MARK_FIELD_NUMBER;
-          hash = (53 * hash) + getMark().hashCode();
-          break;
-        case 0:
-        default:
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ClientArgs parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientArgs parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientArgs parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientArgs parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientArgs parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientArgs parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientArgs parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientArgs parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientArgs parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ClientArgs parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.ClientArgs prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.ClientArgs}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ClientArgs)
-        io.grpc.benchmarks.proto.Control.ClientArgsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientArgs_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientArgs_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.ClientArgs.class, io.grpc.benchmarks.proto.Control.ClientArgs.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.ClientArgs.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        argtypeCase_ = 0;
-        argtype_ = null;
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ClientArgs_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ClientArgs getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.ClientArgs.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.ClientArgs build() {
-        io.grpc.benchmarks.proto.Control.ClientArgs result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ClientArgs buildPartial() {
-        io.grpc.benchmarks.proto.Control.ClientArgs result = new io.grpc.benchmarks.proto.Control.ClientArgs(this);
-        if (argtypeCase_ == 1) {
-          if (setupBuilder_ == null) {
-            result.argtype_ = argtype_;
-          } else {
-            result.argtype_ = setupBuilder_.build();
-          }
-        }
-        if (argtypeCase_ == 2) {
-          if (markBuilder_ == null) {
-            result.argtype_ = argtype_;
-          } else {
-            result.argtype_ = markBuilder_.build();
-          }
-        }
-        result.argtypeCase_ = argtypeCase_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.ClientArgs) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.ClientArgs)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.ClientArgs other) {
-        if (other == io.grpc.benchmarks.proto.Control.ClientArgs.getDefaultInstance()) return this;
-        switch (other.getArgtypeCase()) {
-          case SETUP: {
-            mergeSetup(other.getSetup());
-            break;
-          }
-          case MARK: {
-            mergeMark(other.getMark());
-            break;
-          }
-          case ARGTYPE_NOT_SET: {
-            break;
-          }
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.ClientArgs parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.ClientArgs) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      private int argtypeCase_ = 0;
-      private java.lang.Object argtype_;
-      public ArgtypeCase
-          getArgtypeCase() {
-        return ArgtypeCase.forNumber(
-            argtypeCase_);
-      }
-
-      public Builder clearArgtype() {
-        argtypeCase_ = 0;
-        argtype_ = null;
-        onChanged();
-        return this;
-      }
-
-
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.ClientConfig, io.grpc.benchmarks.proto.Control.ClientConfig.Builder, io.grpc.benchmarks.proto.Control.ClientConfigOrBuilder> setupBuilder_;
-      /**
-       * <code>.grpc.testing.ClientConfig setup = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ClientConfig getSetup() {
-        if (setupBuilder_ == null) {
-          if (argtypeCase_ == 1) {
-            return (io.grpc.benchmarks.proto.Control.ClientConfig) argtype_;
-          }
-          return io.grpc.benchmarks.proto.Control.ClientConfig.getDefaultInstance();
-        } else {
-          if (argtypeCase_ == 1) {
-            return setupBuilder_.getMessage();
-          }
-          return io.grpc.benchmarks.proto.Control.ClientConfig.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ClientConfig setup = 1;</code>
-       */
-      public Builder setSetup(io.grpc.benchmarks.proto.Control.ClientConfig value) {
-        if (setupBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          argtype_ = value;
-          onChanged();
-        } else {
-          setupBuilder_.setMessage(value);
-        }
-        argtypeCase_ = 1;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClientConfig setup = 1;</code>
-       */
-      public Builder setSetup(
-          io.grpc.benchmarks.proto.Control.ClientConfig.Builder builderForValue) {
-        if (setupBuilder_ == null) {
-          argtype_ = builderForValue.build();
-          onChanged();
-        } else {
-          setupBuilder_.setMessage(builderForValue.build());
-        }
-        argtypeCase_ = 1;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClientConfig setup = 1;</code>
-       */
-      public Builder mergeSetup(io.grpc.benchmarks.proto.Control.ClientConfig value) {
-        if (setupBuilder_ == null) {
-          if (argtypeCase_ == 1 &&
-              argtype_ != io.grpc.benchmarks.proto.Control.ClientConfig.getDefaultInstance()) {
-            argtype_ = io.grpc.benchmarks.proto.Control.ClientConfig.newBuilder((io.grpc.benchmarks.proto.Control.ClientConfig) argtype_)
-                .mergeFrom(value).buildPartial();
-          } else {
-            argtype_ = value;
-          }
-          onChanged();
-        } else {
-          if (argtypeCase_ == 1) {
-            setupBuilder_.mergeFrom(value);
-          }
-          setupBuilder_.setMessage(value);
-        }
-        argtypeCase_ = 1;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClientConfig setup = 1;</code>
-       */
-      public Builder clearSetup() {
-        if (setupBuilder_ == null) {
-          if (argtypeCase_ == 1) {
-            argtypeCase_ = 0;
-            argtype_ = null;
-            onChanged();
-          }
-        } else {
-          if (argtypeCase_ == 1) {
-            argtypeCase_ = 0;
-            argtype_ = null;
-          }
-          setupBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ClientConfig setup = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ClientConfig.Builder getSetupBuilder() {
-        return getSetupFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.ClientConfig setup = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ClientConfigOrBuilder getSetupOrBuilder() {
-        if ((argtypeCase_ == 1) && (setupBuilder_ != null)) {
-          return setupBuilder_.getMessageOrBuilder();
-        } else {
-          if (argtypeCase_ == 1) {
-            return (io.grpc.benchmarks.proto.Control.ClientConfig) argtype_;
-          }
-          return io.grpc.benchmarks.proto.Control.ClientConfig.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ClientConfig setup = 1;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.ClientConfig, io.grpc.benchmarks.proto.Control.ClientConfig.Builder, io.grpc.benchmarks.proto.Control.ClientConfigOrBuilder> 
-          getSetupFieldBuilder() {
-        if (setupBuilder_ == null) {
-          if (!(argtypeCase_ == 1)) {
-            argtype_ = io.grpc.benchmarks.proto.Control.ClientConfig.getDefaultInstance();
-          }
-          setupBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Control.ClientConfig, io.grpc.benchmarks.proto.Control.ClientConfig.Builder, io.grpc.benchmarks.proto.Control.ClientConfigOrBuilder>(
-                  (io.grpc.benchmarks.proto.Control.ClientConfig) argtype_,
-                  getParentForChildren(),
-                  isClean());
-          argtype_ = null;
-        }
-        argtypeCase_ = 1;
-        onChanged();;
-        return setupBuilder_;
-      }
-
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.Mark, io.grpc.benchmarks.proto.Control.Mark.Builder, io.grpc.benchmarks.proto.Control.MarkOrBuilder> markBuilder_;
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.Mark getMark() {
-        if (markBuilder_ == null) {
-          if (argtypeCase_ == 2) {
-            return (io.grpc.benchmarks.proto.Control.Mark) argtype_;
-          }
-          return io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance();
-        } else {
-          if (argtypeCase_ == 2) {
-            return markBuilder_.getMessage();
-          }
-          return io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public Builder setMark(io.grpc.benchmarks.proto.Control.Mark value) {
-        if (markBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          argtype_ = value;
-          onChanged();
-        } else {
-          markBuilder_.setMessage(value);
-        }
-        argtypeCase_ = 2;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public Builder setMark(
-          io.grpc.benchmarks.proto.Control.Mark.Builder builderForValue) {
-        if (markBuilder_ == null) {
-          argtype_ = builderForValue.build();
-          onChanged();
-        } else {
-          markBuilder_.setMessage(builderForValue.build());
-        }
-        argtypeCase_ = 2;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public Builder mergeMark(io.grpc.benchmarks.proto.Control.Mark value) {
-        if (markBuilder_ == null) {
-          if (argtypeCase_ == 2 &&
-              argtype_ != io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance()) {
-            argtype_ = io.grpc.benchmarks.proto.Control.Mark.newBuilder((io.grpc.benchmarks.proto.Control.Mark) argtype_)
-                .mergeFrom(value).buildPartial();
-          } else {
-            argtype_ = value;
-          }
-          onChanged();
-        } else {
-          if (argtypeCase_ == 2) {
-            markBuilder_.mergeFrom(value);
-          }
-          markBuilder_.setMessage(value);
-        }
-        argtypeCase_ = 2;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public Builder clearMark() {
-        if (markBuilder_ == null) {
-          if (argtypeCase_ == 2) {
-            argtypeCase_ = 0;
-            argtype_ = null;
-            onChanged();
-          }
-        } else {
-          if (argtypeCase_ == 2) {
-            argtypeCase_ = 0;
-            argtype_ = null;
-          }
-          markBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.Mark.Builder getMarkBuilder() {
-        return getMarkFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.MarkOrBuilder getMarkOrBuilder() {
-        if ((argtypeCase_ == 2) && (markBuilder_ != null)) {
-          return markBuilder_.getMessageOrBuilder();
-        } else {
-          if (argtypeCase_ == 2) {
-            return (io.grpc.benchmarks.proto.Control.Mark) argtype_;
-          }
-          return io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.Mark, io.grpc.benchmarks.proto.Control.Mark.Builder, io.grpc.benchmarks.proto.Control.MarkOrBuilder> 
-          getMarkFieldBuilder() {
-        if (markBuilder_ == null) {
-          if (!(argtypeCase_ == 2)) {
-            argtype_ = io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance();
-          }
-          markBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Control.Mark, io.grpc.benchmarks.proto.Control.Mark.Builder, io.grpc.benchmarks.proto.Control.MarkOrBuilder>(
-                  (io.grpc.benchmarks.proto.Control.Mark) argtype_,
-                  getParentForChildren(),
-                  isClean());
-          argtype_ = null;
-        }
-        argtypeCase_ = 2;
-        onChanged();;
-        return markBuilder_;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ClientArgs)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ClientArgs)
-    private static final io.grpc.benchmarks.proto.Control.ClientArgs DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.ClientArgs();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ClientArgs getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ClientArgs>
-        PARSER = new com.google.protobuf.AbstractParser<ClientArgs>() {
-      public ClientArgs parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ClientArgs(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ClientArgs> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ClientArgs> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.ClientArgs getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ServerConfigOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ServerConfig)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>.grpc.testing.ServerType server_type = 1;</code>
-     */
-    int getServerTypeValue();
-    /**
-     * <code>.grpc.testing.ServerType server_type = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Control.ServerType getServerType();
-
-    /**
-     * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-     */
-    boolean hasSecurityParams();
-    /**
-     * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-     */
-    io.grpc.benchmarks.proto.Control.SecurityParams getSecurityParams();
-    /**
-     * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-     */
-    io.grpc.benchmarks.proto.Control.SecurityParamsOrBuilder getSecurityParamsOrBuilder();
-
-    /**
-     * <pre>
-     * Port on which to listen. Zero means pick unused port.
-     * </pre>
-     *
-     * <code>int32 port = 4;</code>
-     */
-    int getPort();
-
-    /**
-     * <pre>
-     * Only for async server. Number of threads used to serve the requests.
-     * </pre>
-     *
-     * <code>int32 async_server_threads = 7;</code>
-     */
-    int getAsyncServerThreads();
-
-    /**
-     * <pre>
-     * Specify the number of cores to limit server to, if desired
-     * </pre>
-     *
-     * <code>int32 core_limit = 8;</code>
-     */
-    int getCoreLimit();
-
-    /**
-     * <pre>
-     * payload config, used in generic server
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-     */
-    boolean hasPayloadConfig();
-    /**
-     * <pre>
-     * payload config, used in generic server
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-     */
-    io.grpc.benchmarks.proto.Payloads.PayloadConfig getPayloadConfig();
-    /**
-     * <pre>
-     * payload config, used in generic server
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-     */
-    io.grpc.benchmarks.proto.Payloads.PayloadConfigOrBuilder getPayloadConfigOrBuilder();
-
-    /**
-     * <pre>
-     * Specify the cores we should run the server on, if desired
-     * </pre>
-     *
-     * <code>repeated int32 core_list = 10;</code>
-     */
-    java.util.List<java.lang.Integer> getCoreListList();
-    /**
-     * <pre>
-     * Specify the cores we should run the server on, if desired
-     * </pre>
-     *
-     * <code>repeated int32 core_list = 10;</code>
-     */
-    int getCoreListCount();
-    /**
-     * <pre>
-     * Specify the cores we should run the server on, if desired
-     * </pre>
-     *
-     * <code>repeated int32 core_list = 10;</code>
-     */
-    int getCoreList(int index);
-  }
-  /**
-   * Protobuf type {@code grpc.testing.ServerConfig}
-   */
-  public  static final class ServerConfig extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ServerConfig)
-      ServerConfigOrBuilder {
-    // Use ServerConfig.newBuilder() to construct.
-    private ServerConfig(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ServerConfig() {
-      serverType_ = 0;
-      port_ = 0;
-      asyncServerThreads_ = 0;
-      coreLimit_ = 0;
-      coreList_ = java.util.Collections.emptyList();
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ServerConfig(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-              int rawValue = input.readEnum();
-
-              serverType_ = rawValue;
-              break;
-            }
-            case 18: {
-              io.grpc.benchmarks.proto.Control.SecurityParams.Builder subBuilder = null;
-              if (securityParams_ != null) {
-                subBuilder = securityParams_.toBuilder();
-              }
-              securityParams_ = input.readMessage(io.grpc.benchmarks.proto.Control.SecurityParams.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(securityParams_);
-                securityParams_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 32: {
-
-              port_ = input.readInt32();
-              break;
-            }
-            case 56: {
-
-              asyncServerThreads_ = input.readInt32();
-              break;
-            }
-            case 64: {
-
-              coreLimit_ = input.readInt32();
-              break;
-            }
-            case 74: {
-              io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder subBuilder = null;
-              if (payloadConfig_ != null) {
-                subBuilder = payloadConfig_.toBuilder();
-              }
-              payloadConfig_ = input.readMessage(io.grpc.benchmarks.proto.Payloads.PayloadConfig.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(payloadConfig_);
-                payloadConfig_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 80: {
-              if (!((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
-                coreList_ = new java.util.ArrayList<java.lang.Integer>();
-                mutable_bitField0_ |= 0x00000040;
-              }
-              coreList_.add(input.readInt32());
-              break;
-            }
-            case 82: {
-              int length = input.readRawVarint32();
-              int limit = input.pushLimit(length);
-              if (!((mutable_bitField0_ & 0x00000040) == 0x00000040) && input.getBytesUntilLimit() > 0) {
-                coreList_ = new java.util.ArrayList<java.lang.Integer>();
-                mutable_bitField0_ |= 0x00000040;
-              }
-              while (input.getBytesUntilLimit() > 0) {
-                coreList_.add(input.readInt32());
-              }
-              input.popLimit(limit);
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        if (((mutable_bitField0_ & 0x00000040) == 0x00000040)) {
-          coreList_ = java.util.Collections.unmodifiableList(coreList_);
-        }
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerConfig_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerConfig_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.ServerConfig.class, io.grpc.benchmarks.proto.Control.ServerConfig.Builder.class);
-    }
-
-    private int bitField0_;
-    public static final int SERVER_TYPE_FIELD_NUMBER = 1;
-    private int serverType_;
-    /**
-     * <code>.grpc.testing.ServerType server_type = 1;</code>
-     */
-    public int getServerTypeValue() {
-      return serverType_;
-    }
-    /**
-     * <code>.grpc.testing.ServerType server_type = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.ServerType getServerType() {
-      io.grpc.benchmarks.proto.Control.ServerType result = io.grpc.benchmarks.proto.Control.ServerType.valueOf(serverType_);
-      return result == null ? io.grpc.benchmarks.proto.Control.ServerType.UNRECOGNIZED : result;
-    }
-
-    public static final int SECURITY_PARAMS_FIELD_NUMBER = 2;
-    private io.grpc.benchmarks.proto.Control.SecurityParams securityParams_;
-    /**
-     * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-     */
-    public boolean hasSecurityParams() {
-      return securityParams_ != null;
-    }
-    /**
-     * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.SecurityParams getSecurityParams() {
-      return securityParams_ == null ? io.grpc.benchmarks.proto.Control.SecurityParams.getDefaultInstance() : securityParams_;
-    }
-    /**
-     * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.SecurityParamsOrBuilder getSecurityParamsOrBuilder() {
-      return getSecurityParams();
-    }
-
-    public static final int PORT_FIELD_NUMBER = 4;
-    private int port_;
-    /**
-     * <pre>
-     * Port on which to listen. Zero means pick unused port.
-     * </pre>
-     *
-     * <code>int32 port = 4;</code>
-     */
-    public int getPort() {
-      return port_;
-    }
-
-    public static final int ASYNC_SERVER_THREADS_FIELD_NUMBER = 7;
-    private int asyncServerThreads_;
-    /**
-     * <pre>
-     * Only for async server. Number of threads used to serve the requests.
-     * </pre>
-     *
-     * <code>int32 async_server_threads = 7;</code>
-     */
-    public int getAsyncServerThreads() {
-      return asyncServerThreads_;
-    }
-
-    public static final int CORE_LIMIT_FIELD_NUMBER = 8;
-    private int coreLimit_;
-    /**
-     * <pre>
-     * Specify the number of cores to limit server to, if desired
-     * </pre>
-     *
-     * <code>int32 core_limit = 8;</code>
-     */
-    public int getCoreLimit() {
-      return coreLimit_;
-    }
-
-    public static final int PAYLOAD_CONFIG_FIELD_NUMBER = 9;
-    private io.grpc.benchmarks.proto.Payloads.PayloadConfig payloadConfig_;
-    /**
-     * <pre>
-     * payload config, used in generic server
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-     */
-    public boolean hasPayloadConfig() {
-      return payloadConfig_ != null;
-    }
-    /**
-     * <pre>
-     * payload config, used in generic server
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-     */
-    public io.grpc.benchmarks.proto.Payloads.PayloadConfig getPayloadConfig() {
-      return payloadConfig_ == null ? io.grpc.benchmarks.proto.Payloads.PayloadConfig.getDefaultInstance() : payloadConfig_;
-    }
-    /**
-     * <pre>
-     * payload config, used in generic server
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-     */
-    public io.grpc.benchmarks.proto.Payloads.PayloadConfigOrBuilder getPayloadConfigOrBuilder() {
-      return getPayloadConfig();
-    }
-
-    public static final int CORE_LIST_FIELD_NUMBER = 10;
-    private java.util.List<java.lang.Integer> coreList_;
-    /**
-     * <pre>
-     * Specify the cores we should run the server on, if desired
-     * </pre>
-     *
-     * <code>repeated int32 core_list = 10;</code>
-     */
-    public java.util.List<java.lang.Integer>
-        getCoreListList() {
-      return coreList_;
-    }
-    /**
-     * <pre>
-     * Specify the cores we should run the server on, if desired
-     * </pre>
-     *
-     * <code>repeated int32 core_list = 10;</code>
-     */
-    public int getCoreListCount() {
-      return coreList_.size();
-    }
-    /**
-     * <pre>
-     * Specify the cores we should run the server on, if desired
-     * </pre>
-     *
-     * <code>repeated int32 core_list = 10;</code>
-     */
-    public int getCoreList(int index) {
-      return coreList_.get(index);
-    }
-    private int coreListMemoizedSerializedSize = -1;
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      getSerializedSize();
-      if (serverType_ != io.grpc.benchmarks.proto.Control.ServerType.SYNC_SERVER.getNumber()) {
-        output.writeEnum(1, serverType_);
-      }
-      if (securityParams_ != null) {
-        output.writeMessage(2, getSecurityParams());
-      }
-      if (port_ != 0) {
-        output.writeInt32(4, port_);
-      }
-      if (asyncServerThreads_ != 0) {
-        output.writeInt32(7, asyncServerThreads_);
-      }
-      if (coreLimit_ != 0) {
-        output.writeInt32(8, coreLimit_);
-      }
-      if (payloadConfig_ != null) {
-        output.writeMessage(9, getPayloadConfig());
-      }
-      if (getCoreListList().size() > 0) {
-        output.writeUInt32NoTag(82);
-        output.writeUInt32NoTag(coreListMemoizedSerializedSize);
-      }
-      for (int i = 0; i < coreList_.size(); i++) {
-        output.writeInt32NoTag(coreList_.get(i));
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (serverType_ != io.grpc.benchmarks.proto.Control.ServerType.SYNC_SERVER.getNumber()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeEnumSize(1, serverType_);
-      }
-      if (securityParams_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(2, getSecurityParams());
-      }
-      if (port_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(4, port_);
-      }
-      if (asyncServerThreads_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(7, asyncServerThreads_);
-      }
-      if (coreLimit_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(8, coreLimit_);
-      }
-      if (payloadConfig_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(9, getPayloadConfig());
-      }
-      {
-        int dataSize = 0;
-        for (int i = 0; i < coreList_.size(); i++) {
-          dataSize += com.google.protobuf.CodedOutputStream
-            .computeInt32SizeNoTag(coreList_.get(i));
-        }
-        size += dataSize;
-        if (!getCoreListList().isEmpty()) {
-          size += 1;
-          size += com.google.protobuf.CodedOutputStream
-              .computeInt32SizeNoTag(dataSize);
-        }
-        coreListMemoizedSerializedSize = dataSize;
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.ServerConfig)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.ServerConfig other = (io.grpc.benchmarks.proto.Control.ServerConfig) obj;
-
-      boolean result = true;
-      result = result && serverType_ == other.serverType_;
-      result = result && (hasSecurityParams() == other.hasSecurityParams());
-      if (hasSecurityParams()) {
-        result = result && getSecurityParams()
-            .equals(other.getSecurityParams());
-      }
-      result = result && (getPort()
-          == other.getPort());
-      result = result && (getAsyncServerThreads()
-          == other.getAsyncServerThreads());
-      result = result && (getCoreLimit()
-          == other.getCoreLimit());
-      result = result && (hasPayloadConfig() == other.hasPayloadConfig());
-      if (hasPayloadConfig()) {
-        result = result && getPayloadConfig()
-            .equals(other.getPayloadConfig());
-      }
-      result = result && getCoreListList()
-          .equals(other.getCoreListList());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + SERVER_TYPE_FIELD_NUMBER;
-      hash = (53 * hash) + serverType_;
-      if (hasSecurityParams()) {
-        hash = (37 * hash) + SECURITY_PARAMS_FIELD_NUMBER;
-        hash = (53 * hash) + getSecurityParams().hashCode();
-      }
-      hash = (37 * hash) + PORT_FIELD_NUMBER;
-      hash = (53 * hash) + getPort();
-      hash = (37 * hash) + ASYNC_SERVER_THREADS_FIELD_NUMBER;
-      hash = (53 * hash) + getAsyncServerThreads();
-      hash = (37 * hash) + CORE_LIMIT_FIELD_NUMBER;
-      hash = (53 * hash) + getCoreLimit();
-      if (hasPayloadConfig()) {
-        hash = (37 * hash) + PAYLOAD_CONFIG_FIELD_NUMBER;
-        hash = (53 * hash) + getPayloadConfig().hashCode();
-      }
-      if (getCoreListCount() > 0) {
-        hash = (37 * hash) + CORE_LIST_FIELD_NUMBER;
-        hash = (53 * hash) + getCoreListList().hashCode();
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ServerConfig parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerConfig parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerConfig parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerConfig parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerConfig parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerConfig parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerConfig parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerConfig parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerConfig parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerConfig parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.ServerConfig prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.ServerConfig}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ServerConfig)
-        io.grpc.benchmarks.proto.Control.ServerConfigOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerConfig_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerConfig_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.ServerConfig.class, io.grpc.benchmarks.proto.Control.ServerConfig.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.ServerConfig.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        serverType_ = 0;
-
-        if (securityParamsBuilder_ == null) {
-          securityParams_ = null;
-        } else {
-          securityParams_ = null;
-          securityParamsBuilder_ = null;
-        }
-        port_ = 0;
-
-        asyncServerThreads_ = 0;
-
-        coreLimit_ = 0;
-
-        if (payloadConfigBuilder_ == null) {
-          payloadConfig_ = null;
-        } else {
-          payloadConfig_ = null;
-          payloadConfigBuilder_ = null;
-        }
-        coreList_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000040);
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerConfig_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ServerConfig getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.ServerConfig.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.ServerConfig build() {
-        io.grpc.benchmarks.proto.Control.ServerConfig result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ServerConfig buildPartial() {
-        io.grpc.benchmarks.proto.Control.ServerConfig result = new io.grpc.benchmarks.proto.Control.ServerConfig(this);
-        int from_bitField0_ = bitField0_;
-        int to_bitField0_ = 0;
-        result.serverType_ = serverType_;
-        if (securityParamsBuilder_ == null) {
-          result.securityParams_ = securityParams_;
-        } else {
-          result.securityParams_ = securityParamsBuilder_.build();
-        }
-        result.port_ = port_;
-        result.asyncServerThreads_ = asyncServerThreads_;
-        result.coreLimit_ = coreLimit_;
-        if (payloadConfigBuilder_ == null) {
-          result.payloadConfig_ = payloadConfig_;
-        } else {
-          result.payloadConfig_ = payloadConfigBuilder_.build();
-        }
-        if (((bitField0_ & 0x00000040) == 0x00000040)) {
-          coreList_ = java.util.Collections.unmodifiableList(coreList_);
-          bitField0_ = (bitField0_ & ~0x00000040);
-        }
-        result.coreList_ = coreList_;
-        result.bitField0_ = to_bitField0_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.ServerConfig) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.ServerConfig)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.ServerConfig other) {
-        if (other == io.grpc.benchmarks.proto.Control.ServerConfig.getDefaultInstance()) return this;
-        if (other.serverType_ != 0) {
-          setServerTypeValue(other.getServerTypeValue());
-        }
-        if (other.hasSecurityParams()) {
-          mergeSecurityParams(other.getSecurityParams());
-        }
-        if (other.getPort() != 0) {
-          setPort(other.getPort());
-        }
-        if (other.getAsyncServerThreads() != 0) {
-          setAsyncServerThreads(other.getAsyncServerThreads());
-        }
-        if (other.getCoreLimit() != 0) {
-          setCoreLimit(other.getCoreLimit());
-        }
-        if (other.hasPayloadConfig()) {
-          mergePayloadConfig(other.getPayloadConfig());
-        }
-        if (!other.coreList_.isEmpty()) {
-          if (coreList_.isEmpty()) {
-            coreList_ = other.coreList_;
-            bitField0_ = (bitField0_ & ~0x00000040);
-          } else {
-            ensureCoreListIsMutable();
-            coreList_.addAll(other.coreList_);
-          }
-          onChanged();
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.ServerConfig parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.ServerConfig) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      private int bitField0_;
-
-      private int serverType_ = 0;
-      /**
-       * <code>.grpc.testing.ServerType server_type = 1;</code>
-       */
-      public int getServerTypeValue() {
-        return serverType_;
-      }
-      /**
-       * <code>.grpc.testing.ServerType server_type = 1;</code>
-       */
-      public Builder setServerTypeValue(int value) {
-        serverType_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ServerType server_type = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ServerType getServerType() {
-        io.grpc.benchmarks.proto.Control.ServerType result = io.grpc.benchmarks.proto.Control.ServerType.valueOf(serverType_);
-        return result == null ? io.grpc.benchmarks.proto.Control.ServerType.UNRECOGNIZED : result;
-      }
-      /**
-       * <code>.grpc.testing.ServerType server_type = 1;</code>
-       */
-      public Builder setServerType(io.grpc.benchmarks.proto.Control.ServerType value) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        
-        serverType_ = value.getNumber();
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ServerType server_type = 1;</code>
-       */
-      public Builder clearServerType() {
-        
-        serverType_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private io.grpc.benchmarks.proto.Control.SecurityParams securityParams_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.SecurityParams, io.grpc.benchmarks.proto.Control.SecurityParams.Builder, io.grpc.benchmarks.proto.Control.SecurityParamsOrBuilder> securityParamsBuilder_;
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-       */
-      public boolean hasSecurityParams() {
-        return securityParamsBuilder_ != null || securityParams_ != null;
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.SecurityParams getSecurityParams() {
-        if (securityParamsBuilder_ == null) {
-          return securityParams_ == null ? io.grpc.benchmarks.proto.Control.SecurityParams.getDefaultInstance() : securityParams_;
-        } else {
-          return securityParamsBuilder_.getMessage();
-        }
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-       */
-      public Builder setSecurityParams(io.grpc.benchmarks.proto.Control.SecurityParams value) {
-        if (securityParamsBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          securityParams_ = value;
-          onChanged();
-        } else {
-          securityParamsBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-       */
-      public Builder setSecurityParams(
-          io.grpc.benchmarks.proto.Control.SecurityParams.Builder builderForValue) {
-        if (securityParamsBuilder_ == null) {
-          securityParams_ = builderForValue.build();
-          onChanged();
-        } else {
-          securityParamsBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-       */
-      public Builder mergeSecurityParams(io.grpc.benchmarks.proto.Control.SecurityParams value) {
-        if (securityParamsBuilder_ == null) {
-          if (securityParams_ != null) {
-            securityParams_ =
-              io.grpc.benchmarks.proto.Control.SecurityParams.newBuilder(securityParams_).mergeFrom(value).buildPartial();
-          } else {
-            securityParams_ = value;
-          }
-          onChanged();
-        } else {
-          securityParamsBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-       */
-      public Builder clearSecurityParams() {
-        if (securityParamsBuilder_ == null) {
-          securityParams_ = null;
-          onChanged();
-        } else {
-          securityParams_ = null;
-          securityParamsBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.SecurityParams.Builder getSecurityParamsBuilder() {
-        
-        onChanged();
-        return getSecurityParamsFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.SecurityParamsOrBuilder getSecurityParamsOrBuilder() {
-        if (securityParamsBuilder_ != null) {
-          return securityParamsBuilder_.getMessageOrBuilder();
-        } else {
-          return securityParams_ == null ?
-              io.grpc.benchmarks.proto.Control.SecurityParams.getDefaultInstance() : securityParams_;
-        }
-      }
-      /**
-       * <code>.grpc.testing.SecurityParams security_params = 2;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.SecurityParams, io.grpc.benchmarks.proto.Control.SecurityParams.Builder, io.grpc.benchmarks.proto.Control.SecurityParamsOrBuilder> 
-          getSecurityParamsFieldBuilder() {
-        if (securityParamsBuilder_ == null) {
-          securityParamsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Control.SecurityParams, io.grpc.benchmarks.proto.Control.SecurityParams.Builder, io.grpc.benchmarks.proto.Control.SecurityParamsOrBuilder>(
-                  getSecurityParams(),
-                  getParentForChildren(),
-                  isClean());
-          securityParams_ = null;
-        }
-        return securityParamsBuilder_;
-      }
-
-      private int port_ ;
-      /**
-       * <pre>
-       * Port on which to listen. Zero means pick unused port.
-       * </pre>
-       *
-       * <code>int32 port = 4;</code>
-       */
-      public int getPort() {
-        return port_;
-      }
-      /**
-       * <pre>
-       * Port on which to listen. Zero means pick unused port.
-       * </pre>
-       *
-       * <code>int32 port = 4;</code>
-       */
-      public Builder setPort(int value) {
-        
-        port_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Port on which to listen. Zero means pick unused port.
-       * </pre>
-       *
-       * <code>int32 port = 4;</code>
-       */
-      public Builder clearPort() {
-        
-        port_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private int asyncServerThreads_ ;
-      /**
-       * <pre>
-       * Only for async server. Number of threads used to serve the requests.
-       * </pre>
-       *
-       * <code>int32 async_server_threads = 7;</code>
-       */
-      public int getAsyncServerThreads() {
-        return asyncServerThreads_;
-      }
-      /**
-       * <pre>
-       * Only for async server. Number of threads used to serve the requests.
-       * </pre>
-       *
-       * <code>int32 async_server_threads = 7;</code>
-       */
-      public Builder setAsyncServerThreads(int value) {
-        
-        asyncServerThreads_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Only for async server. Number of threads used to serve the requests.
-       * </pre>
-       *
-       * <code>int32 async_server_threads = 7;</code>
-       */
-      public Builder clearAsyncServerThreads() {
-        
-        asyncServerThreads_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private int coreLimit_ ;
-      /**
-       * <pre>
-       * Specify the number of cores to limit server to, if desired
-       * </pre>
-       *
-       * <code>int32 core_limit = 8;</code>
-       */
-      public int getCoreLimit() {
-        return coreLimit_;
-      }
-      /**
-       * <pre>
-       * Specify the number of cores to limit server to, if desired
-       * </pre>
-       *
-       * <code>int32 core_limit = 8;</code>
-       */
-      public Builder setCoreLimit(int value) {
-        
-        coreLimit_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Specify the number of cores to limit server to, if desired
-       * </pre>
-       *
-       * <code>int32 core_limit = 8;</code>
-       */
-      public Builder clearCoreLimit() {
-        
-        coreLimit_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private io.grpc.benchmarks.proto.Payloads.PayloadConfig payloadConfig_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Payloads.PayloadConfig, io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder, io.grpc.benchmarks.proto.Payloads.PayloadConfigOrBuilder> payloadConfigBuilder_;
-      /**
-       * <pre>
-       * payload config, used in generic server
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-       */
-      public boolean hasPayloadConfig() {
-        return payloadConfigBuilder_ != null || payloadConfig_ != null;
-      }
-      /**
-       * <pre>
-       * payload config, used in generic server
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.PayloadConfig getPayloadConfig() {
-        if (payloadConfigBuilder_ == null) {
-          return payloadConfig_ == null ? io.grpc.benchmarks.proto.Payloads.PayloadConfig.getDefaultInstance() : payloadConfig_;
-        } else {
-          return payloadConfigBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * payload config, used in generic server
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-       */
-      public Builder setPayloadConfig(io.grpc.benchmarks.proto.Payloads.PayloadConfig value) {
-        if (payloadConfigBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payloadConfig_ = value;
-          onChanged();
-        } else {
-          payloadConfigBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * payload config, used in generic server
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-       */
-      public Builder setPayloadConfig(
-          io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder builderForValue) {
-        if (payloadConfigBuilder_ == null) {
-          payloadConfig_ = builderForValue.build();
-          onChanged();
-        } else {
-          payloadConfigBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * payload config, used in generic server
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-       */
-      public Builder mergePayloadConfig(io.grpc.benchmarks.proto.Payloads.PayloadConfig value) {
-        if (payloadConfigBuilder_ == null) {
-          if (payloadConfig_ != null) {
-            payloadConfig_ =
-              io.grpc.benchmarks.proto.Payloads.PayloadConfig.newBuilder(payloadConfig_).mergeFrom(value).buildPartial();
-          } else {
-            payloadConfig_ = value;
-          }
-          onChanged();
-        } else {
-          payloadConfigBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * payload config, used in generic server
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-       */
-      public Builder clearPayloadConfig() {
-        if (payloadConfigBuilder_ == null) {
-          payloadConfig_ = null;
-          onChanged();
-        } else {
-          payloadConfig_ = null;
-          payloadConfigBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * payload config, used in generic server
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder getPayloadConfigBuilder() {
-        
-        onChanged();
-        return getPayloadConfigFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * payload config, used in generic server
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.PayloadConfigOrBuilder getPayloadConfigOrBuilder() {
-        if (payloadConfigBuilder_ != null) {
-          return payloadConfigBuilder_.getMessageOrBuilder();
-        } else {
-          return payloadConfig_ == null ?
-              io.grpc.benchmarks.proto.Payloads.PayloadConfig.getDefaultInstance() : payloadConfig_;
-        }
-      }
-      /**
-       * <pre>
-       * payload config, used in generic server
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadConfig payload_config = 9;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Payloads.PayloadConfig, io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder, io.grpc.benchmarks.proto.Payloads.PayloadConfigOrBuilder> 
-          getPayloadConfigFieldBuilder() {
-        if (payloadConfigBuilder_ == null) {
-          payloadConfigBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Payloads.PayloadConfig, io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder, io.grpc.benchmarks.proto.Payloads.PayloadConfigOrBuilder>(
-                  getPayloadConfig(),
-                  getParentForChildren(),
-                  isClean());
-          payloadConfig_ = null;
-        }
-        return payloadConfigBuilder_;
-      }
-
-      private java.util.List<java.lang.Integer> coreList_ = java.util.Collections.emptyList();
-      private void ensureCoreListIsMutable() {
-        if (!((bitField0_ & 0x00000040) == 0x00000040)) {
-          coreList_ = new java.util.ArrayList<java.lang.Integer>(coreList_);
-          bitField0_ |= 0x00000040;
-         }
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the server on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 10;</code>
-       */
-      public java.util.List<java.lang.Integer>
-          getCoreListList() {
-        return java.util.Collections.unmodifiableList(coreList_);
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the server on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 10;</code>
-       */
-      public int getCoreListCount() {
-        return coreList_.size();
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the server on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 10;</code>
-       */
-      public int getCoreList(int index) {
-        return coreList_.get(index);
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the server on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 10;</code>
-       */
-      public Builder setCoreList(
-          int index, int value) {
-        ensureCoreListIsMutable();
-        coreList_.set(index, value);
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the server on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 10;</code>
-       */
-      public Builder addCoreList(int value) {
-        ensureCoreListIsMutable();
-        coreList_.add(value);
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the server on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 10;</code>
-       */
-      public Builder addAllCoreList(
-          java.lang.Iterable<? extends java.lang.Integer> values) {
-        ensureCoreListIsMutable();
-        com.google.protobuf.AbstractMessageLite.Builder.addAll(
-            values, coreList_);
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Specify the cores we should run the server on, if desired
-       * </pre>
-       *
-       * <code>repeated int32 core_list = 10;</code>
-       */
-      public Builder clearCoreList() {
-        coreList_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000040);
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ServerConfig)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ServerConfig)
-    private static final io.grpc.benchmarks.proto.Control.ServerConfig DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.ServerConfig();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ServerConfig getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ServerConfig>
-        PARSER = new com.google.protobuf.AbstractParser<ServerConfig>() {
-      public ServerConfig parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ServerConfig(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ServerConfig> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ServerConfig> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.ServerConfig getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ServerArgsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ServerArgs)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>.grpc.testing.ServerConfig setup = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Control.ServerConfig getSetup();
-    /**
-     * <code>.grpc.testing.ServerConfig setup = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Control.ServerConfigOrBuilder getSetupOrBuilder();
-
-    /**
-     * <code>.grpc.testing.Mark mark = 2;</code>
-     */
-    io.grpc.benchmarks.proto.Control.Mark getMark();
-    /**
-     * <code>.grpc.testing.Mark mark = 2;</code>
-     */
-    io.grpc.benchmarks.proto.Control.MarkOrBuilder getMarkOrBuilder();
-
-    public io.grpc.benchmarks.proto.Control.ServerArgs.ArgtypeCase getArgtypeCase();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.ServerArgs}
-   */
-  public  static final class ServerArgs extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ServerArgs)
-      ServerArgsOrBuilder {
-    // Use ServerArgs.newBuilder() to construct.
-    private ServerArgs(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ServerArgs() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ServerArgs(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              io.grpc.benchmarks.proto.Control.ServerConfig.Builder subBuilder = null;
-              if (argtypeCase_ == 1) {
-                subBuilder = ((io.grpc.benchmarks.proto.Control.ServerConfig) argtype_).toBuilder();
-              }
-              argtype_ =
-                  input.readMessage(io.grpc.benchmarks.proto.Control.ServerConfig.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom((io.grpc.benchmarks.proto.Control.ServerConfig) argtype_);
-                argtype_ = subBuilder.buildPartial();
-              }
-              argtypeCase_ = 1;
-              break;
-            }
-            case 18: {
-              io.grpc.benchmarks.proto.Control.Mark.Builder subBuilder = null;
-              if (argtypeCase_ == 2) {
-                subBuilder = ((io.grpc.benchmarks.proto.Control.Mark) argtype_).toBuilder();
-              }
-              argtype_ =
-                  input.readMessage(io.grpc.benchmarks.proto.Control.Mark.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom((io.grpc.benchmarks.proto.Control.Mark) argtype_);
-                argtype_ = subBuilder.buildPartial();
-              }
-              argtypeCase_ = 2;
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerArgs_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerArgs_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.ServerArgs.class, io.grpc.benchmarks.proto.Control.ServerArgs.Builder.class);
-    }
-
-    private int argtypeCase_ = 0;
-    private java.lang.Object argtype_;
-    public enum ArgtypeCase
-        implements com.google.protobuf.Internal.EnumLite {
-      SETUP(1),
-      MARK(2),
-      ARGTYPE_NOT_SET(0);
-      private final int value;
-      private ArgtypeCase(int value) {
-        this.value = value;
-      }
-      /**
-       * @deprecated Use {@link #forNumber(int)} instead.
-       */
-      @java.lang.Deprecated
-      public static ArgtypeCase valueOf(int value) {
-        return forNumber(value);
-      }
-
-      public static ArgtypeCase forNumber(int value) {
-        switch (value) {
-          case 1: return SETUP;
-          case 2: return MARK;
-          case 0: return ARGTYPE_NOT_SET;
-          default: return null;
-        }
-      }
-      public int getNumber() {
-        return this.value;
-      }
-    };
-
-    public ArgtypeCase
-    getArgtypeCase() {
-      return ArgtypeCase.forNumber(
-          argtypeCase_);
-    }
-
-    public static final int SETUP_FIELD_NUMBER = 1;
-    /**
-     * <code>.grpc.testing.ServerConfig setup = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.ServerConfig getSetup() {
-      if (argtypeCase_ == 1) {
-         return (io.grpc.benchmarks.proto.Control.ServerConfig) argtype_;
-      }
-      return io.grpc.benchmarks.proto.Control.ServerConfig.getDefaultInstance();
-    }
-    /**
-     * <code>.grpc.testing.ServerConfig setup = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.ServerConfigOrBuilder getSetupOrBuilder() {
-      if (argtypeCase_ == 1) {
-         return (io.grpc.benchmarks.proto.Control.ServerConfig) argtype_;
-      }
-      return io.grpc.benchmarks.proto.Control.ServerConfig.getDefaultInstance();
-    }
-
-    public static final int MARK_FIELD_NUMBER = 2;
-    /**
-     * <code>.grpc.testing.Mark mark = 2;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.Mark getMark() {
-      if (argtypeCase_ == 2) {
-         return (io.grpc.benchmarks.proto.Control.Mark) argtype_;
-      }
-      return io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance();
-    }
-    /**
-     * <code>.grpc.testing.Mark mark = 2;</code>
-     */
-    public io.grpc.benchmarks.proto.Control.MarkOrBuilder getMarkOrBuilder() {
-      if (argtypeCase_ == 2) {
-         return (io.grpc.benchmarks.proto.Control.Mark) argtype_;
-      }
-      return io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance();
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (argtypeCase_ == 1) {
-        output.writeMessage(1, (io.grpc.benchmarks.proto.Control.ServerConfig) argtype_);
-      }
-      if (argtypeCase_ == 2) {
-        output.writeMessage(2, (io.grpc.benchmarks.proto.Control.Mark) argtype_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (argtypeCase_ == 1) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, (io.grpc.benchmarks.proto.Control.ServerConfig) argtype_);
-      }
-      if (argtypeCase_ == 2) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(2, (io.grpc.benchmarks.proto.Control.Mark) argtype_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.ServerArgs)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.ServerArgs other = (io.grpc.benchmarks.proto.Control.ServerArgs) obj;
-
-      boolean result = true;
-      result = result && getArgtypeCase().equals(
-          other.getArgtypeCase());
-      if (!result) return false;
-      switch (argtypeCase_) {
-        case 1:
-          result = result && getSetup()
-              .equals(other.getSetup());
-          break;
-        case 2:
-          result = result && getMark()
-              .equals(other.getMark());
-          break;
-        case 0:
-        default:
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      switch (argtypeCase_) {
-        case 1:
-          hash = (37 * hash) + SETUP_FIELD_NUMBER;
-          hash = (53 * hash) + getSetup().hashCode();
-          break;
-        case 2:
-          hash = (37 * hash) + MARK_FIELD_NUMBER;
-          hash = (53 * hash) + getMark().hashCode();
-          break;
-        case 0:
-        default:
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ServerArgs parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerArgs parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerArgs parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerArgs parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerArgs parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerArgs parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerArgs parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerArgs parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerArgs parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerArgs parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.ServerArgs prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.ServerArgs}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ServerArgs)
-        io.grpc.benchmarks.proto.Control.ServerArgsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerArgs_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerArgs_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.ServerArgs.class, io.grpc.benchmarks.proto.Control.ServerArgs.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.ServerArgs.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        argtypeCase_ = 0;
-        argtype_ = null;
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerArgs_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ServerArgs getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.ServerArgs.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.ServerArgs build() {
-        io.grpc.benchmarks.proto.Control.ServerArgs result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ServerArgs buildPartial() {
-        io.grpc.benchmarks.proto.Control.ServerArgs result = new io.grpc.benchmarks.proto.Control.ServerArgs(this);
-        if (argtypeCase_ == 1) {
-          if (setupBuilder_ == null) {
-            result.argtype_ = argtype_;
-          } else {
-            result.argtype_ = setupBuilder_.build();
-          }
-        }
-        if (argtypeCase_ == 2) {
-          if (markBuilder_ == null) {
-            result.argtype_ = argtype_;
-          } else {
-            result.argtype_ = markBuilder_.build();
-          }
-        }
-        result.argtypeCase_ = argtypeCase_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.ServerArgs) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.ServerArgs)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.ServerArgs other) {
-        if (other == io.grpc.benchmarks.proto.Control.ServerArgs.getDefaultInstance()) return this;
-        switch (other.getArgtypeCase()) {
-          case SETUP: {
-            mergeSetup(other.getSetup());
-            break;
-          }
-          case MARK: {
-            mergeMark(other.getMark());
-            break;
-          }
-          case ARGTYPE_NOT_SET: {
-            break;
-          }
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.ServerArgs parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.ServerArgs) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      private int argtypeCase_ = 0;
-      private java.lang.Object argtype_;
-      public ArgtypeCase
-          getArgtypeCase() {
-        return ArgtypeCase.forNumber(
-            argtypeCase_);
-      }
-
-      public Builder clearArgtype() {
-        argtypeCase_ = 0;
-        argtype_ = null;
-        onChanged();
-        return this;
-      }
-
-
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.ServerConfig, io.grpc.benchmarks.proto.Control.ServerConfig.Builder, io.grpc.benchmarks.proto.Control.ServerConfigOrBuilder> setupBuilder_;
-      /**
-       * <code>.grpc.testing.ServerConfig setup = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ServerConfig getSetup() {
-        if (setupBuilder_ == null) {
-          if (argtypeCase_ == 1) {
-            return (io.grpc.benchmarks.proto.Control.ServerConfig) argtype_;
-          }
-          return io.grpc.benchmarks.proto.Control.ServerConfig.getDefaultInstance();
-        } else {
-          if (argtypeCase_ == 1) {
-            return setupBuilder_.getMessage();
-          }
-          return io.grpc.benchmarks.proto.Control.ServerConfig.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ServerConfig setup = 1;</code>
-       */
-      public Builder setSetup(io.grpc.benchmarks.proto.Control.ServerConfig value) {
-        if (setupBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          argtype_ = value;
-          onChanged();
-        } else {
-          setupBuilder_.setMessage(value);
-        }
-        argtypeCase_ = 1;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ServerConfig setup = 1;</code>
-       */
-      public Builder setSetup(
-          io.grpc.benchmarks.proto.Control.ServerConfig.Builder builderForValue) {
-        if (setupBuilder_ == null) {
-          argtype_ = builderForValue.build();
-          onChanged();
-        } else {
-          setupBuilder_.setMessage(builderForValue.build());
-        }
-        argtypeCase_ = 1;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ServerConfig setup = 1;</code>
-       */
-      public Builder mergeSetup(io.grpc.benchmarks.proto.Control.ServerConfig value) {
-        if (setupBuilder_ == null) {
-          if (argtypeCase_ == 1 &&
-              argtype_ != io.grpc.benchmarks.proto.Control.ServerConfig.getDefaultInstance()) {
-            argtype_ = io.grpc.benchmarks.proto.Control.ServerConfig.newBuilder((io.grpc.benchmarks.proto.Control.ServerConfig) argtype_)
-                .mergeFrom(value).buildPartial();
-          } else {
-            argtype_ = value;
-          }
-          onChanged();
-        } else {
-          if (argtypeCase_ == 1) {
-            setupBuilder_.mergeFrom(value);
-          }
-          setupBuilder_.setMessage(value);
-        }
-        argtypeCase_ = 1;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ServerConfig setup = 1;</code>
-       */
-      public Builder clearSetup() {
-        if (setupBuilder_ == null) {
-          if (argtypeCase_ == 1) {
-            argtypeCase_ = 0;
-            argtype_ = null;
-            onChanged();
-          }
-        } else {
-          if (argtypeCase_ == 1) {
-            argtypeCase_ = 0;
-            argtype_ = null;
-          }
-          setupBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ServerConfig setup = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ServerConfig.Builder getSetupBuilder() {
-        return getSetupFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.ServerConfig setup = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.ServerConfigOrBuilder getSetupOrBuilder() {
-        if ((argtypeCase_ == 1) && (setupBuilder_ != null)) {
-          return setupBuilder_.getMessageOrBuilder();
-        } else {
-          if (argtypeCase_ == 1) {
-            return (io.grpc.benchmarks.proto.Control.ServerConfig) argtype_;
-          }
-          return io.grpc.benchmarks.proto.Control.ServerConfig.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ServerConfig setup = 1;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.ServerConfig, io.grpc.benchmarks.proto.Control.ServerConfig.Builder, io.grpc.benchmarks.proto.Control.ServerConfigOrBuilder> 
-          getSetupFieldBuilder() {
-        if (setupBuilder_ == null) {
-          if (!(argtypeCase_ == 1)) {
-            argtype_ = io.grpc.benchmarks.proto.Control.ServerConfig.getDefaultInstance();
-          }
-          setupBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Control.ServerConfig, io.grpc.benchmarks.proto.Control.ServerConfig.Builder, io.grpc.benchmarks.proto.Control.ServerConfigOrBuilder>(
-                  (io.grpc.benchmarks.proto.Control.ServerConfig) argtype_,
-                  getParentForChildren(),
-                  isClean());
-          argtype_ = null;
-        }
-        argtypeCase_ = 1;
-        onChanged();;
-        return setupBuilder_;
-      }
-
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.Mark, io.grpc.benchmarks.proto.Control.Mark.Builder, io.grpc.benchmarks.proto.Control.MarkOrBuilder> markBuilder_;
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.Mark getMark() {
-        if (markBuilder_ == null) {
-          if (argtypeCase_ == 2) {
-            return (io.grpc.benchmarks.proto.Control.Mark) argtype_;
-          }
-          return io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance();
-        } else {
-          if (argtypeCase_ == 2) {
-            return markBuilder_.getMessage();
-          }
-          return io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public Builder setMark(io.grpc.benchmarks.proto.Control.Mark value) {
-        if (markBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          argtype_ = value;
-          onChanged();
-        } else {
-          markBuilder_.setMessage(value);
-        }
-        argtypeCase_ = 2;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public Builder setMark(
-          io.grpc.benchmarks.proto.Control.Mark.Builder builderForValue) {
-        if (markBuilder_ == null) {
-          argtype_ = builderForValue.build();
-          onChanged();
-        } else {
-          markBuilder_.setMessage(builderForValue.build());
-        }
-        argtypeCase_ = 2;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public Builder mergeMark(io.grpc.benchmarks.proto.Control.Mark value) {
-        if (markBuilder_ == null) {
-          if (argtypeCase_ == 2 &&
-              argtype_ != io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance()) {
-            argtype_ = io.grpc.benchmarks.proto.Control.Mark.newBuilder((io.grpc.benchmarks.proto.Control.Mark) argtype_)
-                .mergeFrom(value).buildPartial();
-          } else {
-            argtype_ = value;
-          }
-          onChanged();
-        } else {
-          if (argtypeCase_ == 2) {
-            markBuilder_.mergeFrom(value);
-          }
-          markBuilder_.setMessage(value);
-        }
-        argtypeCase_ = 2;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public Builder clearMark() {
-        if (markBuilder_ == null) {
-          if (argtypeCase_ == 2) {
-            argtypeCase_ = 0;
-            argtype_ = null;
-            onChanged();
-          }
-        } else {
-          if (argtypeCase_ == 2) {
-            argtypeCase_ = 0;
-            argtype_ = null;
-          }
-          markBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.Mark.Builder getMarkBuilder() {
-        return getMarkFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Control.MarkOrBuilder getMarkOrBuilder() {
-        if ((argtypeCase_ == 2) && (markBuilder_ != null)) {
-          return markBuilder_.getMessageOrBuilder();
-        } else {
-          if (argtypeCase_ == 2) {
-            return (io.grpc.benchmarks.proto.Control.Mark) argtype_;
-          }
-          return io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.Mark mark = 2;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Control.Mark, io.grpc.benchmarks.proto.Control.Mark.Builder, io.grpc.benchmarks.proto.Control.MarkOrBuilder> 
-          getMarkFieldBuilder() {
-        if (markBuilder_ == null) {
-          if (!(argtypeCase_ == 2)) {
-            argtype_ = io.grpc.benchmarks.proto.Control.Mark.getDefaultInstance();
-          }
-          markBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Control.Mark, io.grpc.benchmarks.proto.Control.Mark.Builder, io.grpc.benchmarks.proto.Control.MarkOrBuilder>(
-                  (io.grpc.benchmarks.proto.Control.Mark) argtype_,
-                  getParentForChildren(),
-                  isClean());
-          argtype_ = null;
-        }
-        argtypeCase_ = 2;
-        onChanged();;
-        return markBuilder_;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ServerArgs)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ServerArgs)
-    private static final io.grpc.benchmarks.proto.Control.ServerArgs DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.ServerArgs();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ServerArgs getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ServerArgs>
-        PARSER = new com.google.protobuf.AbstractParser<ServerArgs>() {
-      public ServerArgs parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ServerArgs(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ServerArgs> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ServerArgs> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.ServerArgs getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ServerStatusOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ServerStatus)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>.grpc.testing.ServerStats stats = 1;</code>
-     */
-    boolean hasStats();
-    /**
-     * <code>.grpc.testing.ServerStats stats = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Stats.ServerStats getStats();
-    /**
-     * <code>.grpc.testing.ServerStats stats = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Stats.ServerStatsOrBuilder getStatsOrBuilder();
-
-    /**
-     * <pre>
-     * the port bound by the server
-     * </pre>
-     *
-     * <code>int32 port = 2;</code>
-     */
-    int getPort();
-
-    /**
-     * <pre>
-     * Number of cores available to the server
-     * </pre>
-     *
-     * <code>int32 cores = 3;</code>
-     */
-    int getCores();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.ServerStatus}
-   */
-  public  static final class ServerStatus extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ServerStatus)
-      ServerStatusOrBuilder {
-    // Use ServerStatus.newBuilder() to construct.
-    private ServerStatus(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ServerStatus() {
-      port_ = 0;
-      cores_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ServerStatus(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              io.grpc.benchmarks.proto.Stats.ServerStats.Builder subBuilder = null;
-              if (stats_ != null) {
-                subBuilder = stats_.toBuilder();
-              }
-              stats_ = input.readMessage(io.grpc.benchmarks.proto.Stats.ServerStats.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(stats_);
-                stats_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 16: {
-
-              port_ = input.readInt32();
-              break;
-            }
-            case 24: {
-
-              cores_ = input.readInt32();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerStatus_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerStatus_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.ServerStatus.class, io.grpc.benchmarks.proto.Control.ServerStatus.Builder.class);
-    }
-
-    public static final int STATS_FIELD_NUMBER = 1;
-    private io.grpc.benchmarks.proto.Stats.ServerStats stats_;
-    /**
-     * <code>.grpc.testing.ServerStats stats = 1;</code>
-     */
-    public boolean hasStats() {
-      return stats_ != null;
-    }
-    /**
-     * <code>.grpc.testing.ServerStats stats = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Stats.ServerStats getStats() {
-      return stats_ == null ? io.grpc.benchmarks.proto.Stats.ServerStats.getDefaultInstance() : stats_;
-    }
-    /**
-     * <code>.grpc.testing.ServerStats stats = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Stats.ServerStatsOrBuilder getStatsOrBuilder() {
-      return getStats();
-    }
-
-    public static final int PORT_FIELD_NUMBER = 2;
-    private int port_;
-    /**
-     * <pre>
-     * the port bound by the server
-     * </pre>
-     *
-     * <code>int32 port = 2;</code>
-     */
-    public int getPort() {
-      return port_;
-    }
-
-    public static final int CORES_FIELD_NUMBER = 3;
-    private int cores_;
-    /**
-     * <pre>
-     * Number of cores available to the server
-     * </pre>
-     *
-     * <code>int32 cores = 3;</code>
-     */
-    public int getCores() {
-      return cores_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (stats_ != null) {
-        output.writeMessage(1, getStats());
-      }
-      if (port_ != 0) {
-        output.writeInt32(2, port_);
-      }
-      if (cores_ != 0) {
-        output.writeInt32(3, cores_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (stats_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, getStats());
-      }
-      if (port_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(2, port_);
-      }
-      if (cores_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(3, cores_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.ServerStatus)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.ServerStatus other = (io.grpc.benchmarks.proto.Control.ServerStatus) obj;
-
-      boolean result = true;
-      result = result && (hasStats() == other.hasStats());
-      if (hasStats()) {
-        result = result && getStats()
-            .equals(other.getStats());
-      }
-      result = result && (getPort()
-          == other.getPort());
-      result = result && (getCores()
-          == other.getCores());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      if (hasStats()) {
-        hash = (37 * hash) + STATS_FIELD_NUMBER;
-        hash = (53 * hash) + getStats().hashCode();
-      }
-      hash = (37 * hash) + PORT_FIELD_NUMBER;
-      hash = (53 * hash) + getPort();
-      hash = (37 * hash) + CORES_FIELD_NUMBER;
-      hash = (53 * hash) + getCores();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ServerStatus parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerStatus parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerStatus parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerStatus parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerStatus parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerStatus parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerStatus parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerStatus parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerStatus parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.ServerStatus parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.ServerStatus prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.ServerStatus}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ServerStatus)
-        io.grpc.benchmarks.proto.Control.ServerStatusOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerStatus_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerStatus_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.ServerStatus.class, io.grpc.benchmarks.proto.Control.ServerStatus.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.ServerStatus.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        if (statsBuilder_ == null) {
-          stats_ = null;
-        } else {
-          stats_ = null;
-          statsBuilder_ = null;
-        }
-        port_ = 0;
-
-        cores_ = 0;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_ServerStatus_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ServerStatus getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.ServerStatus.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.ServerStatus build() {
-        io.grpc.benchmarks.proto.Control.ServerStatus result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.ServerStatus buildPartial() {
-        io.grpc.benchmarks.proto.Control.ServerStatus result = new io.grpc.benchmarks.proto.Control.ServerStatus(this);
-        if (statsBuilder_ == null) {
-          result.stats_ = stats_;
-        } else {
-          result.stats_ = statsBuilder_.build();
-        }
-        result.port_ = port_;
-        result.cores_ = cores_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.ServerStatus) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.ServerStatus)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.ServerStatus other) {
-        if (other == io.grpc.benchmarks.proto.Control.ServerStatus.getDefaultInstance()) return this;
-        if (other.hasStats()) {
-          mergeStats(other.getStats());
-        }
-        if (other.getPort() != 0) {
-          setPort(other.getPort());
-        }
-        if (other.getCores() != 0) {
-          setCores(other.getCores());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.ServerStatus parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.ServerStatus) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private io.grpc.benchmarks.proto.Stats.ServerStats stats_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Stats.ServerStats, io.grpc.benchmarks.proto.Stats.ServerStats.Builder, io.grpc.benchmarks.proto.Stats.ServerStatsOrBuilder> statsBuilder_;
-      /**
-       * <code>.grpc.testing.ServerStats stats = 1;</code>
-       */
-      public boolean hasStats() {
-        return statsBuilder_ != null || stats_ != null;
-      }
-      /**
-       * <code>.grpc.testing.ServerStats stats = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Stats.ServerStats getStats() {
-        if (statsBuilder_ == null) {
-          return stats_ == null ? io.grpc.benchmarks.proto.Stats.ServerStats.getDefaultInstance() : stats_;
-        } else {
-          return statsBuilder_.getMessage();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ServerStats stats = 1;</code>
-       */
-      public Builder setStats(io.grpc.benchmarks.proto.Stats.ServerStats value) {
-        if (statsBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          stats_ = value;
-          onChanged();
-        } else {
-          statsBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ServerStats stats = 1;</code>
-       */
-      public Builder setStats(
-          io.grpc.benchmarks.proto.Stats.ServerStats.Builder builderForValue) {
-        if (statsBuilder_ == null) {
-          stats_ = builderForValue.build();
-          onChanged();
-        } else {
-          statsBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ServerStats stats = 1;</code>
-       */
-      public Builder mergeStats(io.grpc.benchmarks.proto.Stats.ServerStats value) {
-        if (statsBuilder_ == null) {
-          if (stats_ != null) {
-            stats_ =
-              io.grpc.benchmarks.proto.Stats.ServerStats.newBuilder(stats_).mergeFrom(value).buildPartial();
-          } else {
-            stats_ = value;
-          }
-          onChanged();
-        } else {
-          statsBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ServerStats stats = 1;</code>
-       */
-      public Builder clearStats() {
-        if (statsBuilder_ == null) {
-          stats_ = null;
-          onChanged();
-        } else {
-          stats_ = null;
-          statsBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ServerStats stats = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Stats.ServerStats.Builder getStatsBuilder() {
-        
-        onChanged();
-        return getStatsFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.ServerStats stats = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Stats.ServerStatsOrBuilder getStatsOrBuilder() {
-        if (statsBuilder_ != null) {
-          return statsBuilder_.getMessageOrBuilder();
-        } else {
-          return stats_ == null ?
-              io.grpc.benchmarks.proto.Stats.ServerStats.getDefaultInstance() : stats_;
-        }
-      }
-      /**
-       * <code>.grpc.testing.ServerStats stats = 1;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Stats.ServerStats, io.grpc.benchmarks.proto.Stats.ServerStats.Builder, io.grpc.benchmarks.proto.Stats.ServerStatsOrBuilder> 
-          getStatsFieldBuilder() {
-        if (statsBuilder_ == null) {
-          statsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Stats.ServerStats, io.grpc.benchmarks.proto.Stats.ServerStats.Builder, io.grpc.benchmarks.proto.Stats.ServerStatsOrBuilder>(
-                  getStats(),
-                  getParentForChildren(),
-                  isClean());
-          stats_ = null;
-        }
-        return statsBuilder_;
-      }
-
-      private int port_ ;
-      /**
-       * <pre>
-       * the port bound by the server
-       * </pre>
-       *
-       * <code>int32 port = 2;</code>
-       */
-      public int getPort() {
-        return port_;
-      }
-      /**
-       * <pre>
-       * the port bound by the server
-       * </pre>
-       *
-       * <code>int32 port = 2;</code>
-       */
-      public Builder setPort(int value) {
-        
-        port_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * the port bound by the server
-       * </pre>
-       *
-       * <code>int32 port = 2;</code>
-       */
-      public Builder clearPort() {
-        
-        port_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private int cores_ ;
-      /**
-       * <pre>
-       * Number of cores available to the server
-       * </pre>
-       *
-       * <code>int32 cores = 3;</code>
-       */
-      public int getCores() {
-        return cores_;
-      }
-      /**
-       * <pre>
-       * Number of cores available to the server
-       * </pre>
-       *
-       * <code>int32 cores = 3;</code>
-       */
-      public Builder setCores(int value) {
-        
-        cores_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Number of cores available to the server
-       * </pre>
-       *
-       * <code>int32 cores = 3;</code>
-       */
-      public Builder clearCores() {
-        
-        cores_ = 0;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ServerStatus)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ServerStatus)
-    private static final io.grpc.benchmarks.proto.Control.ServerStatus DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.ServerStatus();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.ServerStatus getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ServerStatus>
-        PARSER = new com.google.protobuf.AbstractParser<ServerStatus>() {
-      public ServerStatus parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ServerStatus(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ServerStatus> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ServerStatus> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.ServerStatus getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface CoreRequestOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.CoreRequest)
-      com.google.protobuf.MessageOrBuilder {
-  }
-  /**
-   * Protobuf type {@code grpc.testing.CoreRequest}
-   */
-  public  static final class CoreRequest extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.CoreRequest)
-      CoreRequestOrBuilder {
-    // Use CoreRequest.newBuilder() to construct.
-    private CoreRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private CoreRequest() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private CoreRequest(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_CoreRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_CoreRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.CoreRequest.class, io.grpc.benchmarks.proto.Control.CoreRequest.Builder.class);
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.CoreRequest)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.CoreRequest other = (io.grpc.benchmarks.proto.Control.CoreRequest) obj;
-
-      boolean result = true;
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.CoreRequest parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreRequest parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreRequest parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreRequest parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreRequest parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreRequest parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreRequest parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreRequest parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreRequest parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreRequest parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.CoreRequest prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.CoreRequest}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.CoreRequest)
-        io.grpc.benchmarks.proto.Control.CoreRequestOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_CoreRequest_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_CoreRequest_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.CoreRequest.class, io.grpc.benchmarks.proto.Control.CoreRequest.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.CoreRequest.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_CoreRequest_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.CoreRequest getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.CoreRequest.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.CoreRequest build() {
-        io.grpc.benchmarks.proto.Control.CoreRequest result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.CoreRequest buildPartial() {
-        io.grpc.benchmarks.proto.Control.CoreRequest result = new io.grpc.benchmarks.proto.Control.CoreRequest(this);
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.CoreRequest) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.CoreRequest)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.CoreRequest other) {
-        if (other == io.grpc.benchmarks.proto.Control.CoreRequest.getDefaultInstance()) return this;
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.CoreRequest parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.CoreRequest) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.CoreRequest)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.CoreRequest)
-    private static final io.grpc.benchmarks.proto.Control.CoreRequest DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.CoreRequest();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.CoreRequest getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<CoreRequest>
-        PARSER = new com.google.protobuf.AbstractParser<CoreRequest>() {
-      public CoreRequest parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new CoreRequest(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<CoreRequest> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<CoreRequest> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.CoreRequest getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface CoreResponseOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.CoreResponse)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Number of cores available on the server
-     * </pre>
-     *
-     * <code>int32 cores = 1;</code>
-     */
-    int getCores();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.CoreResponse}
-   */
-  public  static final class CoreResponse extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.CoreResponse)
-      CoreResponseOrBuilder {
-    // Use CoreResponse.newBuilder() to construct.
-    private CoreResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private CoreResponse() {
-      cores_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private CoreResponse(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              cores_ = input.readInt32();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_CoreResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_CoreResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.CoreResponse.class, io.grpc.benchmarks.proto.Control.CoreResponse.Builder.class);
-    }
-
-    public static final int CORES_FIELD_NUMBER = 1;
-    private int cores_;
-    /**
-     * <pre>
-     * Number of cores available on the server
-     * </pre>
-     *
-     * <code>int32 cores = 1;</code>
-     */
-    public int getCores() {
-      return cores_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (cores_ != 0) {
-        output.writeInt32(1, cores_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (cores_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(1, cores_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.CoreResponse)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.CoreResponse other = (io.grpc.benchmarks.proto.Control.CoreResponse) obj;
-
-      boolean result = true;
-      result = result && (getCores()
-          == other.getCores());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + CORES_FIELD_NUMBER;
-      hash = (53 * hash) + getCores();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.CoreResponse parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreResponse parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreResponse parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreResponse parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreResponse parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreResponse parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreResponse parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreResponse parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreResponse parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.CoreResponse parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.CoreResponse prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.CoreResponse}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.CoreResponse)
-        io.grpc.benchmarks.proto.Control.CoreResponseOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_CoreResponse_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_CoreResponse_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.CoreResponse.class, io.grpc.benchmarks.proto.Control.CoreResponse.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.CoreResponse.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        cores_ = 0;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_CoreResponse_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.CoreResponse getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.CoreResponse.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.CoreResponse build() {
-        io.grpc.benchmarks.proto.Control.CoreResponse result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.CoreResponse buildPartial() {
-        io.grpc.benchmarks.proto.Control.CoreResponse result = new io.grpc.benchmarks.proto.Control.CoreResponse(this);
-        result.cores_ = cores_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.CoreResponse) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.CoreResponse)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.CoreResponse other) {
-        if (other == io.grpc.benchmarks.proto.Control.CoreResponse.getDefaultInstance()) return this;
-        if (other.getCores() != 0) {
-          setCores(other.getCores());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.CoreResponse parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.CoreResponse) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int cores_ ;
-      /**
-       * <pre>
-       * Number of cores available on the server
-       * </pre>
-       *
-       * <code>int32 cores = 1;</code>
-       */
-      public int getCores() {
-        return cores_;
-      }
-      /**
-       * <pre>
-       * Number of cores available on the server
-       * </pre>
-       *
-       * <code>int32 cores = 1;</code>
-       */
-      public Builder setCores(int value) {
-        
-        cores_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Number of cores available on the server
-       * </pre>
-       *
-       * <code>int32 cores = 1;</code>
-       */
-      public Builder clearCores() {
-        
-        cores_ = 0;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.CoreResponse)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.CoreResponse)
-    private static final io.grpc.benchmarks.proto.Control.CoreResponse DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.CoreResponse();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.CoreResponse getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<CoreResponse>
-        PARSER = new com.google.protobuf.AbstractParser<CoreResponse>() {
-      public CoreResponse parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new CoreResponse(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<CoreResponse> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<CoreResponse> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.CoreResponse getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface VoidOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.Void)
-      com.google.protobuf.MessageOrBuilder {
-  }
-  /**
-   * Protobuf type {@code grpc.testing.Void}
-   */
-  public  static final class Void extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.Void)
-      VoidOrBuilder {
-    // Use Void.newBuilder() to construct.
-    private Void(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private Void() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private Void(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_Void_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_Void_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Control.Void.class, io.grpc.benchmarks.proto.Control.Void.Builder.class);
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Control.Void)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Control.Void other = (io.grpc.benchmarks.proto.Control.Void) obj;
-
-      boolean result = true;
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Control.Void parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.Void parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.Void parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Control.Void parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.Void parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.Void parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.Void parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.Void parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Control.Void parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Control.Void parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Control.Void prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.Void}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.Void)
-        io.grpc.benchmarks.proto.Control.VoidOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_Void_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_Void_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Control.Void.class, io.grpc.benchmarks.proto.Control.Void.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Control.Void.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Control.internal_static_grpc_testing_Void_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Control.Void getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Control.Void.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Control.Void build() {
-        io.grpc.benchmarks.proto.Control.Void result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Control.Void buildPartial() {
-        io.grpc.benchmarks.proto.Control.Void result = new io.grpc.benchmarks.proto.Control.Void(this);
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Control.Void) {
-          return mergeFrom((io.grpc.benchmarks.proto.Control.Void)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Control.Void other) {
-        if (other == io.grpc.benchmarks.proto.Control.Void.getDefaultInstance()) return this;
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Control.Void parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Control.Void) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.Void)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.Void)
-    private static final io.grpc.benchmarks.proto.Control.Void DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Control.Void();
-    }
-
-    public static io.grpc.benchmarks.proto.Control.Void getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<Void>
-        PARSER = new com.google.protobuf.AbstractParser<Void>() {
-      public Void parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new Void(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<Void> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<Void> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Control.Void getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_PoissonParams_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_PoissonParams_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_UniformParams_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_UniformParams_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_DeterministicParams_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_DeterministicParams_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ParetoParams_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ParetoParams_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ClosedLoopParams_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ClosedLoopParams_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_LoadParams_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_LoadParams_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_SecurityParams_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_SecurityParams_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ClientConfig_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ClientConfig_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ClientStatus_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ClientStatus_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_Mark_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_Mark_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ClientArgs_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ClientArgs_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ServerConfig_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ServerConfig_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ServerArgs_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ServerArgs_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ServerStatus_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ServerStatus_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_CoreRequest_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_CoreRequest_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_CoreResponse_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_CoreResponse_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_Void_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_Void_fieldAccessorTable;
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n\rcontrol.proto\022\014grpc.testing\032\016payloads." +
-      "proto\032\013stats.proto\"%\n\rPoissonParams\022\024\n\014o" +
-      "ffered_load\030\001 \001(\001\"A\n\rUniformParams\022\027\n\017in" +
-      "terarrival_lo\030\001 \001(\001\022\027\n\017interarrival_hi\030\002" +
-      " \001(\001\"+\n\023DeterministicParams\022\024\n\014offered_l" +
-      "oad\030\001 \001(\001\"8\n\014ParetoParams\022\031\n\021interarriva" +
-      "l_base\030\001 \001(\001\022\r\n\005alpha\030\002 \001(\001\"\022\n\020ClosedLoo" +
-      "pParams\"\216\002\n\nLoadParams\0225\n\013closed_loop\030\001 " +
-      "\001(\0132\036.grpc.testing.ClosedLoopParamsH\000\022.\n" +
-      "\007poisson\030\002 \001(\0132\033.grpc.testing.PoissonPar",
-      "amsH\000\022.\n\007uniform\030\003 \001(\0132\033.grpc.testing.Un" +
-      "iformParamsH\000\0223\n\006determ\030\004 \001(\0132!.grpc.tes" +
-      "ting.DeterministicParamsH\000\022,\n\006pareto\030\005 \001" +
-      "(\0132\032.grpc.testing.ParetoParamsH\000B\006\n\004load" +
-      "\"C\n\016SecurityParams\022\023\n\013use_test_ca\030\001 \001(\010\022" +
-      "\034\n\024server_host_override\030\002 \001(\t\"\326\003\n\014Client" +
-      "Config\022\026\n\016server_targets\030\001 \003(\t\022-\n\013client" +
-      "_type\030\002 \001(\0162\030.grpc.testing.ClientType\0225\n" +
-      "\017security_params\030\003 \001(\0132\034.grpc.testing.Se" +
-      "curityParams\022$\n\034outstanding_rpcs_per_cha",
-      "nnel\030\004 \001(\005\022\027\n\017client_channels\030\005 \001(\005\022\034\n\024a" +
-      "sync_client_threads\030\007 \001(\005\022\'\n\010rpc_type\030\010 " +
-      "\001(\0162\025.grpc.testing.RpcType\022-\n\013load_param" +
-      "s\030\n \001(\0132\030.grpc.testing.LoadParams\0223\n\016pay" +
-      "load_config\030\013 \001(\0132\033.grpc.testing.Payload" +
-      "Config\0227\n\020histogram_params\030\014 \001(\0132\035.grpc." +
-      "testing.HistogramParams\022\021\n\tcore_list\030\r \003" +
-      "(\005\022\022\n\ncore_limit\030\016 \001(\005\"8\n\014ClientStatus\022(" +
-      "\n\005stats\030\001 \001(\0132\031.grpc.testing.ClientStats" +
-      "\"\025\n\004Mark\022\r\n\005reset\030\001 \001(\010\"h\n\nClientArgs\022+\n",
-      "\005setup\030\001 \001(\0132\032.grpc.testing.ClientConfig" +
-      "H\000\022\"\n\004mark\030\002 \001(\0132\022.grpc.testing.MarkH\000B\t" +
-      "\n\007argtype\"\374\001\n\014ServerConfig\022-\n\013server_typ" +
-      "e\030\001 \001(\0162\030.grpc.testing.ServerType\0225\n\017sec" +
-      "urity_params\030\002 \001(\0132\034.grpc.testing.Securi" +
-      "tyParams\022\014\n\004port\030\004 \001(\005\022\034\n\024async_server_t" +
-      "hreads\030\007 \001(\005\022\022\n\ncore_limit\030\010 \001(\005\0223\n\016payl" +
-      "oad_config\030\t \001(\0132\033.grpc.testing.PayloadC" +
-      "onfig\022\021\n\tcore_list\030\n \003(\005\"h\n\nServerArgs\022+" +
-      "\n\005setup\030\001 \001(\0132\032.grpc.testing.ServerConfi",
-      "gH\000\022\"\n\004mark\030\002 \001(\0132\022.grpc.testing.MarkH\000B" +
-      "\t\n\007argtype\"U\n\014ServerStatus\022(\n\005stats\030\001 \001(" +
-      "\0132\031.grpc.testing.ServerStats\022\014\n\004port\030\002 \001" +
-      "(\005\022\r\n\005cores\030\003 \001(\005\"\r\n\013CoreRequest\"\035\n\014Core" +
-      "Response\022\r\n\005cores\030\001 \001(\005\"\006\n\004Void*/\n\nClien" +
-      "tType\022\017\n\013SYNC_CLIENT\020\000\022\020\n\014ASYNC_CLIENT\020\001" +
-      "*I\n\nServerType\022\017\n\013SYNC_SERVER\020\000\022\020\n\014ASYNC" +
-      "_SERVER\020\001\022\030\n\024ASYNC_GENERIC_SERVER\020\002*#\n\007R" +
-      "pcType\022\t\n\005UNARY\020\000\022\r\n\tSTREAMING\020\001B#\n\030io.g" +
-      "rpc.benchmarks.protoB\007Controlb\006proto3"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-          io.grpc.benchmarks.proto.Payloads.getDescriptor(),
-          io.grpc.benchmarks.proto.Stats.getDescriptor(),
-        }, assigner);
-    internal_static_grpc_testing_PoissonParams_descriptor =
-      getDescriptor().getMessageTypes().get(0);
-    internal_static_grpc_testing_PoissonParams_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_PoissonParams_descriptor,
-        new java.lang.String[] { "OfferedLoad", });
-    internal_static_grpc_testing_UniformParams_descriptor =
-      getDescriptor().getMessageTypes().get(1);
-    internal_static_grpc_testing_UniformParams_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_UniformParams_descriptor,
-        new java.lang.String[] { "InterarrivalLo", "InterarrivalHi", });
-    internal_static_grpc_testing_DeterministicParams_descriptor =
-      getDescriptor().getMessageTypes().get(2);
-    internal_static_grpc_testing_DeterministicParams_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_DeterministicParams_descriptor,
-        new java.lang.String[] { "OfferedLoad", });
-    internal_static_grpc_testing_ParetoParams_descriptor =
-      getDescriptor().getMessageTypes().get(3);
-    internal_static_grpc_testing_ParetoParams_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ParetoParams_descriptor,
-        new java.lang.String[] { "InterarrivalBase", "Alpha", });
-    internal_static_grpc_testing_ClosedLoopParams_descriptor =
-      getDescriptor().getMessageTypes().get(4);
-    internal_static_grpc_testing_ClosedLoopParams_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ClosedLoopParams_descriptor,
-        new java.lang.String[] { });
-    internal_static_grpc_testing_LoadParams_descriptor =
-      getDescriptor().getMessageTypes().get(5);
-    internal_static_grpc_testing_LoadParams_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_LoadParams_descriptor,
-        new java.lang.String[] { "ClosedLoop", "Poisson", "Uniform", "Determ", "Pareto", "Load", });
-    internal_static_grpc_testing_SecurityParams_descriptor =
-      getDescriptor().getMessageTypes().get(6);
-    internal_static_grpc_testing_SecurityParams_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_SecurityParams_descriptor,
-        new java.lang.String[] { "UseTestCa", "ServerHostOverride", });
-    internal_static_grpc_testing_ClientConfig_descriptor =
-      getDescriptor().getMessageTypes().get(7);
-    internal_static_grpc_testing_ClientConfig_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ClientConfig_descriptor,
-        new java.lang.String[] { "ServerTargets", "ClientType", "SecurityParams", "OutstandingRpcsPerChannel", "ClientChannels", "AsyncClientThreads", "RpcType", "LoadParams", "PayloadConfig", "HistogramParams", "CoreList", "CoreLimit", });
-    internal_static_grpc_testing_ClientStatus_descriptor =
-      getDescriptor().getMessageTypes().get(8);
-    internal_static_grpc_testing_ClientStatus_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ClientStatus_descriptor,
-        new java.lang.String[] { "Stats", });
-    internal_static_grpc_testing_Mark_descriptor =
-      getDescriptor().getMessageTypes().get(9);
-    internal_static_grpc_testing_Mark_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_Mark_descriptor,
-        new java.lang.String[] { "Reset", });
-    internal_static_grpc_testing_ClientArgs_descriptor =
-      getDescriptor().getMessageTypes().get(10);
-    internal_static_grpc_testing_ClientArgs_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ClientArgs_descriptor,
-        new java.lang.String[] { "Setup", "Mark", "Argtype", });
-    internal_static_grpc_testing_ServerConfig_descriptor =
-      getDescriptor().getMessageTypes().get(11);
-    internal_static_grpc_testing_ServerConfig_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ServerConfig_descriptor,
-        new java.lang.String[] { "ServerType", "SecurityParams", "Port", "AsyncServerThreads", "CoreLimit", "PayloadConfig", "CoreList", });
-    internal_static_grpc_testing_ServerArgs_descriptor =
-      getDescriptor().getMessageTypes().get(12);
-    internal_static_grpc_testing_ServerArgs_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ServerArgs_descriptor,
-        new java.lang.String[] { "Setup", "Mark", "Argtype", });
-    internal_static_grpc_testing_ServerStatus_descriptor =
-      getDescriptor().getMessageTypes().get(13);
-    internal_static_grpc_testing_ServerStatus_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ServerStatus_descriptor,
-        new java.lang.String[] { "Stats", "Port", "Cores", });
-    internal_static_grpc_testing_CoreRequest_descriptor =
-      getDescriptor().getMessageTypes().get(14);
-    internal_static_grpc_testing_CoreRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_CoreRequest_descriptor,
-        new java.lang.String[] { });
-    internal_static_grpc_testing_CoreResponse_descriptor =
-      getDescriptor().getMessageTypes().get(15);
-    internal_static_grpc_testing_CoreResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_CoreResponse_descriptor,
-        new java.lang.String[] { "Cores", });
-    internal_static_grpc_testing_Void_descriptor =
-      getDescriptor().getMessageTypes().get(16);
-    internal_static_grpc_testing_Void_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_Void_descriptor,
-        new java.lang.String[] { });
-    io.grpc.benchmarks.proto.Payloads.getDescriptor();
-    io.grpc.benchmarks.proto.Stats.getDescriptor();
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Messages.java b/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Messages.java
deleted file mode 100644
index 06c7fb48c4f..00000000000
--- a/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Messages.java
+++ /dev/null
@@ -1,8520 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: messages.proto
-
-package io.grpc.benchmarks.proto;
-
-public final class Messages {
-  private Messages() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  /**
-   * <pre>
-   * The type of payload that should be returned.
-   * </pre>
-   *
-   * Protobuf enum {@code grpc.testing.PayloadType}
-   */
-  public enum PayloadType
-      implements com.google.protobuf.ProtocolMessageEnum {
-    /**
-     * <pre>
-     * Compressable text format.
-     * </pre>
-     *
-     * <code>COMPRESSABLE = 0;</code>
-     */
-    COMPRESSABLE(0),
-    /**
-     * <pre>
-     * Uncompressable binary format.
-     * </pre>
-     *
-     * <code>UNCOMPRESSABLE = 1;</code>
-     */
-    UNCOMPRESSABLE(1),
-    /**
-     * <pre>
-     * Randomly chosen from all other formats defined in this enum.
-     * </pre>
-     *
-     * <code>RANDOM = 2;</code>
-     */
-    RANDOM(2),
-    UNRECOGNIZED(-1),
-    ;
-
-    /**
-     * <pre>
-     * Compressable text format.
-     * </pre>
-     *
-     * <code>COMPRESSABLE = 0;</code>
-     */
-    public static final int COMPRESSABLE_VALUE = 0;
-    /**
-     * <pre>
-     * Uncompressable binary format.
-     * </pre>
-     *
-     * <code>UNCOMPRESSABLE = 1;</code>
-     */
-    public static final int UNCOMPRESSABLE_VALUE = 1;
-    /**
-     * <pre>
-     * Randomly chosen from all other formats defined in this enum.
-     * </pre>
-     *
-     * <code>RANDOM = 2;</code>
-     */
-    public static final int RANDOM_VALUE = 2;
-
-
-    public final int getNumber() {
-      if (this == UNRECOGNIZED) {
-        throw new java.lang.IllegalArgumentException(
-            "Can't get the number of an unknown enum value.");
-      }
-      return value;
-    }
-
-    /**
-     * @deprecated Use {@link #forNumber(int)} instead.
-     */
-    @java.lang.Deprecated
-    public static PayloadType valueOf(int value) {
-      return forNumber(value);
-    }
-
-    public static PayloadType forNumber(int value) {
-      switch (value) {
-        case 0: return COMPRESSABLE;
-        case 1: return UNCOMPRESSABLE;
-        case 2: return RANDOM;
-        default: return null;
-      }
-    }
-
-    public static com.google.protobuf.Internal.EnumLiteMap<PayloadType>
-        internalGetValueMap() {
-      return internalValueMap;
-    }
-    private static final com.google.protobuf.Internal.EnumLiteMap<
-        PayloadType> internalValueMap =
-          new com.google.protobuf.Internal.EnumLiteMap<PayloadType>() {
-            public PayloadType findValueByNumber(int number) {
-              return PayloadType.forNumber(number);
-            }
-          };
-
-    public final com.google.protobuf.Descriptors.EnumValueDescriptor
-        getValueDescriptor() {
-      return getDescriptor().getValues().get(ordinal());
-    }
-    public final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptorForType() {
-      return getDescriptor();
-    }
-    public static final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Messages.getDescriptor().getEnumTypes().get(0);
-    }
-
-    private static final PayloadType[] VALUES = values();
-
-    public static PayloadType valueOf(
-        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
-      if (desc.getType() != getDescriptor()) {
-        throw new java.lang.IllegalArgumentException(
-          "EnumValueDescriptor is not for this type.");
-      }
-      if (desc.getIndex() == -1) {
-        return UNRECOGNIZED;
-      }
-      return VALUES[desc.getIndex()];
-    }
-
-    private final int value;
-
-    private PayloadType(int value) {
-      this.value = value;
-    }
-
-    // @@protoc_insertion_point(enum_scope:grpc.testing.PayloadType)
-  }
-
-  /**
-   * <pre>
-   * Compression algorithms
-   * </pre>
-   *
-   * Protobuf enum {@code grpc.testing.CompressionType}
-   */
-  public enum CompressionType
-      implements com.google.protobuf.ProtocolMessageEnum {
-    /**
-     * <pre>
-     * No compression
-     * </pre>
-     *
-     * <code>NONE = 0;</code>
-     */
-    NONE(0),
-    /**
-     * <code>GZIP = 1;</code>
-     */
-    GZIP(1),
-    /**
-     * <code>DEFLATE = 2;</code>
-     */
-    DEFLATE(2),
-    UNRECOGNIZED(-1),
-    ;
-
-    /**
-     * <pre>
-     * No compression
-     * </pre>
-     *
-     * <code>NONE = 0;</code>
-     */
-    public static final int NONE_VALUE = 0;
-    /**
-     * <code>GZIP = 1;</code>
-     */
-    public static final int GZIP_VALUE = 1;
-    /**
-     * <code>DEFLATE = 2;</code>
-     */
-    public static final int DEFLATE_VALUE = 2;
-
-
-    public final int getNumber() {
-      if (this == UNRECOGNIZED) {
-        throw new java.lang.IllegalArgumentException(
-            "Can't get the number of an unknown enum value.");
-      }
-      return value;
-    }
-
-    /**
-     * @deprecated Use {@link #forNumber(int)} instead.
-     */
-    @java.lang.Deprecated
-    public static CompressionType valueOf(int value) {
-      return forNumber(value);
-    }
-
-    public static CompressionType forNumber(int value) {
-      switch (value) {
-        case 0: return NONE;
-        case 1: return GZIP;
-        case 2: return DEFLATE;
-        default: return null;
-      }
-    }
-
-    public static com.google.protobuf.Internal.EnumLiteMap<CompressionType>
-        internalGetValueMap() {
-      return internalValueMap;
-    }
-    private static final com.google.protobuf.Internal.EnumLiteMap<
-        CompressionType> internalValueMap =
-          new com.google.protobuf.Internal.EnumLiteMap<CompressionType>() {
-            public CompressionType findValueByNumber(int number) {
-              return CompressionType.forNumber(number);
-            }
-          };
-
-    public final com.google.protobuf.Descriptors.EnumValueDescriptor
-        getValueDescriptor() {
-      return getDescriptor().getValues().get(ordinal());
-    }
-    public final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptorForType() {
-      return getDescriptor();
-    }
-    public static final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Messages.getDescriptor().getEnumTypes().get(1);
-    }
-
-    private static final CompressionType[] VALUES = values();
-
-    public static CompressionType valueOf(
-        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
-      if (desc.getType() != getDescriptor()) {
-        throw new java.lang.IllegalArgumentException(
-          "EnumValueDescriptor is not for this type.");
-      }
-      if (desc.getIndex() == -1) {
-        return UNRECOGNIZED;
-      }
-      return VALUES[desc.getIndex()];
-    }
-
-    private final int value;
-
-    private CompressionType(int value) {
-      this.value = value;
-    }
-
-    // @@protoc_insertion_point(enum_scope:grpc.testing.CompressionType)
-  }
-
-  public interface PayloadOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.Payload)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * The type of data in body.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType type = 1;</code>
-     */
-    int getTypeValue();
-    /**
-     * <pre>
-     * The type of data in body.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType type = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.PayloadType getType();
-
-    /**
-     * <pre>
-     * Primary contents of payload.
-     * </pre>
-     *
-     * <code>bytes body = 2;</code>
-     */
-    com.google.protobuf.ByteString getBody();
-  }
-  /**
-   * <pre>
-   * A block of data, to simply increase gRPC message size.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.Payload}
-   */
-  public  static final class Payload extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.Payload)
-      PayloadOrBuilder {
-    // Use Payload.newBuilder() to construct.
-    private Payload(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private Payload() {
-      type_ = 0;
-      body_ = com.google.protobuf.ByteString.EMPTY;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private Payload(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-              int rawValue = input.readEnum();
-
-              type_ = rawValue;
-              break;
-            }
-            case 18: {
-
-              body_ = input.readBytes();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_Payload_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_Payload_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Messages.Payload.class, io.grpc.benchmarks.proto.Messages.Payload.Builder.class);
-    }
-
-    public static final int TYPE_FIELD_NUMBER = 1;
-    private int type_;
-    /**
-     * <pre>
-     * The type of data in body.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType type = 1;</code>
-     */
-    public int getTypeValue() {
-      return type_;
-    }
-    /**
-     * <pre>
-     * The type of data in body.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType type = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.PayloadType getType() {
-      io.grpc.benchmarks.proto.Messages.PayloadType result = io.grpc.benchmarks.proto.Messages.PayloadType.valueOf(type_);
-      return result == null ? io.grpc.benchmarks.proto.Messages.PayloadType.UNRECOGNIZED : result;
-    }
-
-    public static final int BODY_FIELD_NUMBER = 2;
-    private com.google.protobuf.ByteString body_;
-    /**
-     * <pre>
-     * Primary contents of payload.
-     * </pre>
-     *
-     * <code>bytes body = 2;</code>
-     */
-    public com.google.protobuf.ByteString getBody() {
-      return body_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (type_ != io.grpc.benchmarks.proto.Messages.PayloadType.COMPRESSABLE.getNumber()) {
-        output.writeEnum(1, type_);
-      }
-      if (!body_.isEmpty()) {
-        output.writeBytes(2, body_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (type_ != io.grpc.benchmarks.proto.Messages.PayloadType.COMPRESSABLE.getNumber()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeEnumSize(1, type_);
-      }
-      if (!body_.isEmpty()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeBytesSize(2, body_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Messages.Payload)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Messages.Payload other = (io.grpc.benchmarks.proto.Messages.Payload) obj;
-
-      boolean result = true;
-      result = result && type_ == other.type_;
-      result = result && getBody()
-          .equals(other.getBody());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + TYPE_FIELD_NUMBER;
-      hash = (53 * hash) + type_;
-      hash = (37 * hash) + BODY_FIELD_NUMBER;
-      hash = (53 * hash) + getBody().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.Payload parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.Payload parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.Payload parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.Payload parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.Payload parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.Payload parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.Payload parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.Payload parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.Payload parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.Payload parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Messages.Payload prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * A block of data, to simply increase gRPC message size.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.Payload}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.Payload)
-        io.grpc.benchmarks.proto.Messages.PayloadOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_Payload_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_Payload_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Messages.Payload.class, io.grpc.benchmarks.proto.Messages.Payload.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Messages.Payload.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        type_ = 0;
-
-        body_ = com.google.protobuf.ByteString.EMPTY;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_Payload_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.Payload getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Messages.Payload build() {
-        io.grpc.benchmarks.proto.Messages.Payload result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.Payload buildPartial() {
-        io.grpc.benchmarks.proto.Messages.Payload result = new io.grpc.benchmarks.proto.Messages.Payload(this);
-        result.type_ = type_;
-        result.body_ = body_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Messages.Payload) {
-          return mergeFrom((io.grpc.benchmarks.proto.Messages.Payload)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Messages.Payload other) {
-        if (other == io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance()) return this;
-        if (other.type_ != 0) {
-          setTypeValue(other.getTypeValue());
-        }
-        if (other.getBody() != com.google.protobuf.ByteString.EMPTY) {
-          setBody(other.getBody());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Messages.Payload parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Messages.Payload) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int type_ = 0;
-      /**
-       * <pre>
-       * The type of data in body.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType type = 1;</code>
-       */
-      public int getTypeValue() {
-        return type_;
-      }
-      /**
-       * <pre>
-       * The type of data in body.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType type = 1;</code>
-       */
-      public Builder setTypeValue(int value) {
-        type_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * The type of data in body.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType type = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.PayloadType getType() {
-        io.grpc.benchmarks.proto.Messages.PayloadType result = io.grpc.benchmarks.proto.Messages.PayloadType.valueOf(type_);
-        return result == null ? io.grpc.benchmarks.proto.Messages.PayloadType.UNRECOGNIZED : result;
-      }
-      /**
-       * <pre>
-       * The type of data in body.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType type = 1;</code>
-       */
-      public Builder setType(io.grpc.benchmarks.proto.Messages.PayloadType value) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        
-        type_ = value.getNumber();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * The type of data in body.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType type = 1;</code>
-       */
-      public Builder clearType() {
-        
-        type_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private com.google.protobuf.ByteString body_ = com.google.protobuf.ByteString.EMPTY;
-      /**
-       * <pre>
-       * Primary contents of payload.
-       * </pre>
-       *
-       * <code>bytes body = 2;</code>
-       */
-      public com.google.protobuf.ByteString getBody() {
-        return body_;
-      }
-      /**
-       * <pre>
-       * Primary contents of payload.
-       * </pre>
-       *
-       * <code>bytes body = 2;</code>
-       */
-      public Builder setBody(com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  
-        body_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Primary contents of payload.
-       * </pre>
-       *
-       * <code>bytes body = 2;</code>
-       */
-      public Builder clearBody() {
-        
-        body_ = getDefaultInstance().getBody();
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.Payload)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.Payload)
-    private static final io.grpc.benchmarks.proto.Messages.Payload DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Messages.Payload();
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.Payload getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<Payload>
-        PARSER = new com.google.protobuf.AbstractParser<Payload>() {
-      public Payload parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new Payload(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<Payload> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<Payload> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Messages.Payload getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface EchoStatusOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.EchoStatus)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>int32 code = 1;</code>
-     */
-    int getCode();
-
-    /**
-     * <code>string message = 2;</code>
-     */
-    java.lang.String getMessage();
-    /**
-     * <code>string message = 2;</code>
-     */
-    com.google.protobuf.ByteString
-        getMessageBytes();
-  }
-  /**
-   * <pre>
-   * A protobuf representation for grpc status. This is used by test
-   * clients to specify a status that the server should attempt to return.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.EchoStatus}
-   */
-  public  static final class EchoStatus extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.EchoStatus)
-      EchoStatusOrBuilder {
-    // Use EchoStatus.newBuilder() to construct.
-    private EchoStatus(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private EchoStatus() {
-      code_ = 0;
-      message_ = "";
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private EchoStatus(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              code_ = input.readInt32();
-              break;
-            }
-            case 18: {
-              java.lang.String s = input.readStringRequireUtf8();
-
-              message_ = s;
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_EchoStatus_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_EchoStatus_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Messages.EchoStatus.class, io.grpc.benchmarks.proto.Messages.EchoStatus.Builder.class);
-    }
-
-    public static final int CODE_FIELD_NUMBER = 1;
-    private int code_;
-    /**
-     * <code>int32 code = 1;</code>
-     */
-    public int getCode() {
-      return code_;
-    }
-
-    public static final int MESSAGE_FIELD_NUMBER = 2;
-    private volatile java.lang.Object message_;
-    /**
-     * <code>string message = 2;</code>
-     */
-    public java.lang.String getMessage() {
-      java.lang.Object ref = message_;
-      if (ref instanceof java.lang.String) {
-        return (java.lang.String) ref;
-      } else {
-        com.google.protobuf.ByteString bs = 
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        message_ = s;
-        return s;
-      }
-    }
-    /**
-     * <code>string message = 2;</code>
-     */
-    public com.google.protobuf.ByteString
-        getMessageBytes() {
-      java.lang.Object ref = message_;
-      if (ref instanceof java.lang.String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        message_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (code_ != 0) {
-        output.writeInt32(1, code_);
-      }
-      if (!getMessageBytes().isEmpty()) {
-        com.google.protobuf.GeneratedMessageV3.writeString(output, 2, message_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (code_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(1, code_);
-      }
-      if (!getMessageBytes().isEmpty()) {
-        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, message_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Messages.EchoStatus)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Messages.EchoStatus other = (io.grpc.benchmarks.proto.Messages.EchoStatus) obj;
-
-      boolean result = true;
-      result = result && (getCode()
-          == other.getCode());
-      result = result && getMessage()
-          .equals(other.getMessage());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + CODE_FIELD_NUMBER;
-      hash = (53 * hash) + getCode();
-      hash = (37 * hash) + MESSAGE_FIELD_NUMBER;
-      hash = (53 * hash) + getMessage().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.EchoStatus parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.EchoStatus parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.EchoStatus parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.EchoStatus parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.EchoStatus parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.EchoStatus parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.EchoStatus parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.EchoStatus parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.EchoStatus parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.EchoStatus parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Messages.EchoStatus prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * A protobuf representation for grpc status. This is used by test
-     * clients to specify a status that the server should attempt to return.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.EchoStatus}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.EchoStatus)
-        io.grpc.benchmarks.proto.Messages.EchoStatusOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_EchoStatus_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_EchoStatus_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Messages.EchoStatus.class, io.grpc.benchmarks.proto.Messages.EchoStatus.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Messages.EchoStatus.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        code_ = 0;
-
-        message_ = "";
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_EchoStatus_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.EchoStatus getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Messages.EchoStatus.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Messages.EchoStatus build() {
-        io.grpc.benchmarks.proto.Messages.EchoStatus result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.EchoStatus buildPartial() {
-        io.grpc.benchmarks.proto.Messages.EchoStatus result = new io.grpc.benchmarks.proto.Messages.EchoStatus(this);
-        result.code_ = code_;
-        result.message_ = message_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Messages.EchoStatus) {
-          return mergeFrom((io.grpc.benchmarks.proto.Messages.EchoStatus)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Messages.EchoStatus other) {
-        if (other == io.grpc.benchmarks.proto.Messages.EchoStatus.getDefaultInstance()) return this;
-        if (other.getCode() != 0) {
-          setCode(other.getCode());
-        }
-        if (!other.getMessage().isEmpty()) {
-          message_ = other.message_;
-          onChanged();
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Messages.EchoStatus parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Messages.EchoStatus) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int code_ ;
-      /**
-       * <code>int32 code = 1;</code>
-       */
-      public int getCode() {
-        return code_;
-      }
-      /**
-       * <code>int32 code = 1;</code>
-       */
-      public Builder setCode(int value) {
-        
-        code_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>int32 code = 1;</code>
-       */
-      public Builder clearCode() {
-        
-        code_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private java.lang.Object message_ = "";
-      /**
-       * <code>string message = 2;</code>
-       */
-      public java.lang.String getMessage() {
-        java.lang.Object ref = message_;
-        if (!(ref instanceof java.lang.String)) {
-          com.google.protobuf.ByteString bs =
-              (com.google.protobuf.ByteString) ref;
-          java.lang.String s = bs.toStringUtf8();
-          message_ = s;
-          return s;
-        } else {
-          return (java.lang.String) ref;
-        }
-      }
-      /**
-       * <code>string message = 2;</code>
-       */
-      public com.google.protobuf.ByteString
-          getMessageBytes() {
-        java.lang.Object ref = message_;
-        if (ref instanceof String) {
-          com.google.protobuf.ByteString b = 
-              com.google.protobuf.ByteString.copyFromUtf8(
-                  (java.lang.String) ref);
-          message_ = b;
-          return b;
-        } else {
-          return (com.google.protobuf.ByteString) ref;
-        }
-      }
-      /**
-       * <code>string message = 2;</code>
-       */
-      public Builder setMessage(
-          java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  
-        message_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>string message = 2;</code>
-       */
-      public Builder clearMessage() {
-        
-        message_ = getDefaultInstance().getMessage();
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>string message = 2;</code>
-       */
-      public Builder setMessageBytes(
-          com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-        
-        message_ = value;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.EchoStatus)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.EchoStatus)
-    private static final io.grpc.benchmarks.proto.Messages.EchoStatus DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Messages.EchoStatus();
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.EchoStatus getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<EchoStatus>
-        PARSER = new com.google.protobuf.AbstractParser<EchoStatus>() {
-      public EchoStatus parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new EchoStatus(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<EchoStatus> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<EchoStatus> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Messages.EchoStatus getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface SimpleRequestOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.SimpleRequest)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, server randomly chooses one from other formats.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    int getResponseTypeValue();
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, server randomly chooses one from other formats.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.PayloadType getResponseType();
-
-    /**
-     * <pre>
-     * Desired payload size in the response from the server.
-     * If response_type is COMPRESSABLE, this denotes the size before compression.
-     * </pre>
-     *
-     * <code>int32 response_size = 2;</code>
-     */
-    int getResponseSize();
-
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    boolean hasPayload();
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.Payload getPayload();
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder();
-
-    /**
-     * <pre>
-     * Whether SimpleResponse should include username.
-     * </pre>
-     *
-     * <code>bool fill_username = 4;</code>
-     */
-    boolean getFillUsername();
-
-    /**
-     * <pre>
-     * Whether SimpleResponse should include OAuth scope.
-     * </pre>
-     *
-     * <code>bool fill_oauth_scope = 5;</code>
-     */
-    boolean getFillOauthScope();
-
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    int getResponseCompressionValue();
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.CompressionType getResponseCompression();
-
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    boolean hasResponseStatus();
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.EchoStatus getResponseStatus();
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.EchoStatusOrBuilder getResponseStatusOrBuilder();
-  }
-  /**
-   * <pre>
-   * Unary request.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.SimpleRequest}
-   */
-  public  static final class SimpleRequest extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.SimpleRequest)
-      SimpleRequestOrBuilder {
-    // Use SimpleRequest.newBuilder() to construct.
-    private SimpleRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private SimpleRequest() {
-      responseType_ = 0;
-      responseSize_ = 0;
-      fillUsername_ = false;
-      fillOauthScope_ = false;
-      responseCompression_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private SimpleRequest(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-              int rawValue = input.readEnum();
-
-              responseType_ = rawValue;
-              break;
-            }
-            case 16: {
-
-              responseSize_ = input.readInt32();
-              break;
-            }
-            case 26: {
-              io.grpc.benchmarks.proto.Messages.Payload.Builder subBuilder = null;
-              if (payload_ != null) {
-                subBuilder = payload_.toBuilder();
-              }
-              payload_ = input.readMessage(io.grpc.benchmarks.proto.Messages.Payload.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(payload_);
-                payload_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 32: {
-
-              fillUsername_ = input.readBool();
-              break;
-            }
-            case 40: {
-
-              fillOauthScope_ = input.readBool();
-              break;
-            }
-            case 48: {
-              int rawValue = input.readEnum();
-
-              responseCompression_ = rawValue;
-              break;
-            }
-            case 58: {
-              io.grpc.benchmarks.proto.Messages.EchoStatus.Builder subBuilder = null;
-              if (responseStatus_ != null) {
-                subBuilder = responseStatus_.toBuilder();
-              }
-              responseStatus_ = input.readMessage(io.grpc.benchmarks.proto.Messages.EchoStatus.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(responseStatus_);
-                responseStatus_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_SimpleRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_SimpleRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Messages.SimpleRequest.class, io.grpc.benchmarks.proto.Messages.SimpleRequest.Builder.class);
-    }
-
-    public static final int RESPONSE_TYPE_FIELD_NUMBER = 1;
-    private int responseType_;
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, server randomly chooses one from other formats.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    public int getResponseTypeValue() {
-      return responseType_;
-    }
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, server randomly chooses one from other formats.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.PayloadType getResponseType() {
-      io.grpc.benchmarks.proto.Messages.PayloadType result = io.grpc.benchmarks.proto.Messages.PayloadType.valueOf(responseType_);
-      return result == null ? io.grpc.benchmarks.proto.Messages.PayloadType.UNRECOGNIZED : result;
-    }
-
-    public static final int RESPONSE_SIZE_FIELD_NUMBER = 2;
-    private int responseSize_;
-    /**
-     * <pre>
-     * Desired payload size in the response from the server.
-     * If response_type is COMPRESSABLE, this denotes the size before compression.
-     * </pre>
-     *
-     * <code>int32 response_size = 2;</code>
-     */
-    public int getResponseSize() {
-      return responseSize_;
-    }
-
-    public static final int PAYLOAD_FIELD_NUMBER = 3;
-    private io.grpc.benchmarks.proto.Messages.Payload payload_;
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    public boolean hasPayload() {
-      return payload_ != null;
-    }
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.Payload getPayload() {
-      return payload_ == null ? io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-    }
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-      return getPayload();
-    }
-
-    public static final int FILL_USERNAME_FIELD_NUMBER = 4;
-    private boolean fillUsername_;
-    /**
-     * <pre>
-     * Whether SimpleResponse should include username.
-     * </pre>
-     *
-     * <code>bool fill_username = 4;</code>
-     */
-    public boolean getFillUsername() {
-      return fillUsername_;
-    }
-
-    public static final int FILL_OAUTH_SCOPE_FIELD_NUMBER = 5;
-    private boolean fillOauthScope_;
-    /**
-     * <pre>
-     * Whether SimpleResponse should include OAuth scope.
-     * </pre>
-     *
-     * <code>bool fill_oauth_scope = 5;</code>
-     */
-    public boolean getFillOauthScope() {
-      return fillOauthScope_;
-    }
-
-    public static final int RESPONSE_COMPRESSION_FIELD_NUMBER = 6;
-    private int responseCompression_;
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    public int getResponseCompressionValue() {
-      return responseCompression_;
-    }
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.CompressionType getResponseCompression() {
-      io.grpc.benchmarks.proto.Messages.CompressionType result = io.grpc.benchmarks.proto.Messages.CompressionType.valueOf(responseCompression_);
-      return result == null ? io.grpc.benchmarks.proto.Messages.CompressionType.UNRECOGNIZED : result;
-    }
-
-    public static final int RESPONSE_STATUS_FIELD_NUMBER = 7;
-    private io.grpc.benchmarks.proto.Messages.EchoStatus responseStatus_;
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    public boolean hasResponseStatus() {
-      return responseStatus_ != null;
-    }
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.EchoStatus getResponseStatus() {
-      return responseStatus_ == null ? io.grpc.benchmarks.proto.Messages.EchoStatus.getDefaultInstance() : responseStatus_;
-    }
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.EchoStatusOrBuilder getResponseStatusOrBuilder() {
-      return getResponseStatus();
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (responseType_ != io.grpc.benchmarks.proto.Messages.PayloadType.COMPRESSABLE.getNumber()) {
-        output.writeEnum(1, responseType_);
-      }
-      if (responseSize_ != 0) {
-        output.writeInt32(2, responseSize_);
-      }
-      if (payload_ != null) {
-        output.writeMessage(3, getPayload());
-      }
-      if (fillUsername_ != false) {
-        output.writeBool(4, fillUsername_);
-      }
-      if (fillOauthScope_ != false) {
-        output.writeBool(5, fillOauthScope_);
-      }
-      if (responseCompression_ != io.grpc.benchmarks.proto.Messages.CompressionType.NONE.getNumber()) {
-        output.writeEnum(6, responseCompression_);
-      }
-      if (responseStatus_ != null) {
-        output.writeMessage(7, getResponseStatus());
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (responseType_ != io.grpc.benchmarks.proto.Messages.PayloadType.COMPRESSABLE.getNumber()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeEnumSize(1, responseType_);
-      }
-      if (responseSize_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(2, responseSize_);
-      }
-      if (payload_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(3, getPayload());
-      }
-      if (fillUsername_ != false) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeBoolSize(4, fillUsername_);
-      }
-      if (fillOauthScope_ != false) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeBoolSize(5, fillOauthScope_);
-      }
-      if (responseCompression_ != io.grpc.benchmarks.proto.Messages.CompressionType.NONE.getNumber()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeEnumSize(6, responseCompression_);
-      }
-      if (responseStatus_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(7, getResponseStatus());
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Messages.SimpleRequest)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Messages.SimpleRequest other = (io.grpc.benchmarks.proto.Messages.SimpleRequest) obj;
-
-      boolean result = true;
-      result = result && responseType_ == other.responseType_;
-      result = result && (getResponseSize()
-          == other.getResponseSize());
-      result = result && (hasPayload() == other.hasPayload());
-      if (hasPayload()) {
-        result = result && getPayload()
-            .equals(other.getPayload());
-      }
-      result = result && (getFillUsername()
-          == other.getFillUsername());
-      result = result && (getFillOauthScope()
-          == other.getFillOauthScope());
-      result = result && responseCompression_ == other.responseCompression_;
-      result = result && (hasResponseStatus() == other.hasResponseStatus());
-      if (hasResponseStatus()) {
-        result = result && getResponseStatus()
-            .equals(other.getResponseStatus());
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + RESPONSE_TYPE_FIELD_NUMBER;
-      hash = (53 * hash) + responseType_;
-      hash = (37 * hash) + RESPONSE_SIZE_FIELD_NUMBER;
-      hash = (53 * hash) + getResponseSize();
-      if (hasPayload()) {
-        hash = (37 * hash) + PAYLOAD_FIELD_NUMBER;
-        hash = (53 * hash) + getPayload().hashCode();
-      }
-      hash = (37 * hash) + FILL_USERNAME_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
-          getFillUsername());
-      hash = (37 * hash) + FILL_OAUTH_SCOPE_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
-          getFillOauthScope());
-      hash = (37 * hash) + RESPONSE_COMPRESSION_FIELD_NUMBER;
-      hash = (53 * hash) + responseCompression_;
-      if (hasResponseStatus()) {
-        hash = (37 * hash) + RESPONSE_STATUS_FIELD_NUMBER;
-        hash = (53 * hash) + getResponseStatus().hashCode();
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.SimpleRequest parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleRequest parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleRequest parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleRequest parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleRequest parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleRequest parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleRequest parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleRequest parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleRequest parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleRequest parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Messages.SimpleRequest prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Unary request.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.SimpleRequest}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.SimpleRequest)
-        io.grpc.benchmarks.proto.Messages.SimpleRequestOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_SimpleRequest_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_SimpleRequest_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Messages.SimpleRequest.class, io.grpc.benchmarks.proto.Messages.SimpleRequest.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Messages.SimpleRequest.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        responseType_ = 0;
-
-        responseSize_ = 0;
-
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-        fillUsername_ = false;
-
-        fillOauthScope_ = false;
-
-        responseCompression_ = 0;
-
-        if (responseStatusBuilder_ == null) {
-          responseStatus_ = null;
-        } else {
-          responseStatus_ = null;
-          responseStatusBuilder_ = null;
-        }
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_SimpleRequest_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.SimpleRequest getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Messages.SimpleRequest.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Messages.SimpleRequest build() {
-        io.grpc.benchmarks.proto.Messages.SimpleRequest result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.SimpleRequest buildPartial() {
-        io.grpc.benchmarks.proto.Messages.SimpleRequest result = new io.grpc.benchmarks.proto.Messages.SimpleRequest(this);
-        result.responseType_ = responseType_;
-        result.responseSize_ = responseSize_;
-        if (payloadBuilder_ == null) {
-          result.payload_ = payload_;
-        } else {
-          result.payload_ = payloadBuilder_.build();
-        }
-        result.fillUsername_ = fillUsername_;
-        result.fillOauthScope_ = fillOauthScope_;
-        result.responseCompression_ = responseCompression_;
-        if (responseStatusBuilder_ == null) {
-          result.responseStatus_ = responseStatus_;
-        } else {
-          result.responseStatus_ = responseStatusBuilder_.build();
-        }
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Messages.SimpleRequest) {
-          return mergeFrom((io.grpc.benchmarks.proto.Messages.SimpleRequest)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Messages.SimpleRequest other) {
-        if (other == io.grpc.benchmarks.proto.Messages.SimpleRequest.getDefaultInstance()) return this;
-        if (other.responseType_ != 0) {
-          setResponseTypeValue(other.getResponseTypeValue());
-        }
-        if (other.getResponseSize() != 0) {
-          setResponseSize(other.getResponseSize());
-        }
-        if (other.hasPayload()) {
-          mergePayload(other.getPayload());
-        }
-        if (other.getFillUsername() != false) {
-          setFillUsername(other.getFillUsername());
-        }
-        if (other.getFillOauthScope() != false) {
-          setFillOauthScope(other.getFillOauthScope());
-        }
-        if (other.responseCompression_ != 0) {
-          setResponseCompressionValue(other.getResponseCompressionValue());
-        }
-        if (other.hasResponseStatus()) {
-          mergeResponseStatus(other.getResponseStatus());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Messages.SimpleRequest parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Messages.SimpleRequest) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int responseType_ = 0;
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, server randomly chooses one from other formats.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public int getResponseTypeValue() {
-        return responseType_;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, server randomly chooses one from other formats.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public Builder setResponseTypeValue(int value) {
-        responseType_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, server randomly chooses one from other formats.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.PayloadType getResponseType() {
-        io.grpc.benchmarks.proto.Messages.PayloadType result = io.grpc.benchmarks.proto.Messages.PayloadType.valueOf(responseType_);
-        return result == null ? io.grpc.benchmarks.proto.Messages.PayloadType.UNRECOGNIZED : result;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, server randomly chooses one from other formats.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public Builder setResponseType(io.grpc.benchmarks.proto.Messages.PayloadType value) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        
-        responseType_ = value.getNumber();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, server randomly chooses one from other formats.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public Builder clearResponseType() {
-        
-        responseType_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private int responseSize_ ;
-      /**
-       * <pre>
-       * Desired payload size in the response from the server.
-       * If response_type is COMPRESSABLE, this denotes the size before compression.
-       * </pre>
-       *
-       * <code>int32 response_size = 2;</code>
-       */
-      public int getResponseSize() {
-        return responseSize_;
-      }
-      /**
-       * <pre>
-       * Desired payload size in the response from the server.
-       * If response_type is COMPRESSABLE, this denotes the size before compression.
-       * </pre>
-       *
-       * <code>int32 response_size = 2;</code>
-       */
-      public Builder setResponseSize(int value) {
-        
-        responseSize_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired payload size in the response from the server.
-       * If response_type is COMPRESSABLE, this denotes the size before compression.
-       * </pre>
-       *
-       * <code>int32 response_size = 2;</code>
-       */
-      public Builder clearResponseSize() {
-        
-        responseSize_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private io.grpc.benchmarks.proto.Messages.Payload payload_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder> payloadBuilder_;
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public boolean hasPayload() {
-        return payloadBuilder_ != null || payload_ != null;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.Payload getPayload() {
-        if (payloadBuilder_ == null) {
-          return payload_ == null ? io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-        } else {
-          return payloadBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder setPayload(io.grpc.benchmarks.proto.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payload_ = value;
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder setPayload(
-          io.grpc.benchmarks.proto.Messages.Payload.Builder builderForValue) {
-        if (payloadBuilder_ == null) {
-          payload_ = builderForValue.build();
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder mergePayload(io.grpc.benchmarks.proto.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (payload_ != null) {
-            payload_ =
-              io.grpc.benchmarks.proto.Messages.Payload.newBuilder(payload_).mergeFrom(value).buildPartial();
-          } else {
-            payload_ = value;
-          }
-          onChanged();
-        } else {
-          payloadBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder clearPayload() {
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-          onChanged();
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.Payload.Builder getPayloadBuilder() {
-        
-        onChanged();
-        return getPayloadFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-        if (payloadBuilder_ != null) {
-          return payloadBuilder_.getMessageOrBuilder();
-        } else {
-          return payload_ == null ?
-              io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-        }
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder> 
-          getPayloadFieldBuilder() {
-        if (payloadBuilder_ == null) {
-          payloadBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder>(
-                  getPayload(),
-                  getParentForChildren(),
-                  isClean());
-          payload_ = null;
-        }
-        return payloadBuilder_;
-      }
-
-      private boolean fillUsername_ ;
-      /**
-       * <pre>
-       * Whether SimpleResponse should include username.
-       * </pre>
-       *
-       * <code>bool fill_username = 4;</code>
-       */
-      public boolean getFillUsername() {
-        return fillUsername_;
-      }
-      /**
-       * <pre>
-       * Whether SimpleResponse should include username.
-       * </pre>
-       *
-       * <code>bool fill_username = 4;</code>
-       */
-      public Builder setFillUsername(boolean value) {
-        
-        fillUsername_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether SimpleResponse should include username.
-       * </pre>
-       *
-       * <code>bool fill_username = 4;</code>
-       */
-      public Builder clearFillUsername() {
-        
-        fillUsername_ = false;
-        onChanged();
-        return this;
-      }
-
-      private boolean fillOauthScope_ ;
-      /**
-       * <pre>
-       * Whether SimpleResponse should include OAuth scope.
-       * </pre>
-       *
-       * <code>bool fill_oauth_scope = 5;</code>
-       */
-      public boolean getFillOauthScope() {
-        return fillOauthScope_;
-      }
-      /**
-       * <pre>
-       * Whether SimpleResponse should include OAuth scope.
-       * </pre>
-       *
-       * <code>bool fill_oauth_scope = 5;</code>
-       */
-      public Builder setFillOauthScope(boolean value) {
-        
-        fillOauthScope_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether SimpleResponse should include OAuth scope.
-       * </pre>
-       *
-       * <code>bool fill_oauth_scope = 5;</code>
-       */
-      public Builder clearFillOauthScope() {
-        
-        fillOauthScope_ = false;
-        onChanged();
-        return this;
-      }
-
-      private int responseCompression_ = 0;
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public int getResponseCompressionValue() {
-        return responseCompression_;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public Builder setResponseCompressionValue(int value) {
-        responseCompression_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.CompressionType getResponseCompression() {
-        io.grpc.benchmarks.proto.Messages.CompressionType result = io.grpc.benchmarks.proto.Messages.CompressionType.valueOf(responseCompression_);
-        return result == null ? io.grpc.benchmarks.proto.Messages.CompressionType.UNRECOGNIZED : result;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public Builder setResponseCompression(io.grpc.benchmarks.proto.Messages.CompressionType value) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        
-        responseCompression_ = value.getNumber();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public Builder clearResponseCompression() {
-        
-        responseCompression_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private io.grpc.benchmarks.proto.Messages.EchoStatus responseStatus_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.EchoStatus, io.grpc.benchmarks.proto.Messages.EchoStatus.Builder, io.grpc.benchmarks.proto.Messages.EchoStatusOrBuilder> responseStatusBuilder_;
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public boolean hasResponseStatus() {
-        return responseStatusBuilder_ != null || responseStatus_ != null;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.EchoStatus getResponseStatus() {
-        if (responseStatusBuilder_ == null) {
-          return responseStatus_ == null ? io.grpc.benchmarks.proto.Messages.EchoStatus.getDefaultInstance() : responseStatus_;
-        } else {
-          return responseStatusBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder setResponseStatus(io.grpc.benchmarks.proto.Messages.EchoStatus value) {
-        if (responseStatusBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          responseStatus_ = value;
-          onChanged();
-        } else {
-          responseStatusBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder setResponseStatus(
-          io.grpc.benchmarks.proto.Messages.EchoStatus.Builder builderForValue) {
-        if (responseStatusBuilder_ == null) {
-          responseStatus_ = builderForValue.build();
-          onChanged();
-        } else {
-          responseStatusBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder mergeResponseStatus(io.grpc.benchmarks.proto.Messages.EchoStatus value) {
-        if (responseStatusBuilder_ == null) {
-          if (responseStatus_ != null) {
-            responseStatus_ =
-              io.grpc.benchmarks.proto.Messages.EchoStatus.newBuilder(responseStatus_).mergeFrom(value).buildPartial();
-          } else {
-            responseStatus_ = value;
-          }
-          onChanged();
-        } else {
-          responseStatusBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder clearResponseStatus() {
-        if (responseStatusBuilder_ == null) {
-          responseStatus_ = null;
-          onChanged();
-        } else {
-          responseStatus_ = null;
-          responseStatusBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.EchoStatus.Builder getResponseStatusBuilder() {
-        
-        onChanged();
-        return getResponseStatusFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.EchoStatusOrBuilder getResponseStatusOrBuilder() {
-        if (responseStatusBuilder_ != null) {
-          return responseStatusBuilder_.getMessageOrBuilder();
-        } else {
-          return responseStatus_ == null ?
-              io.grpc.benchmarks.proto.Messages.EchoStatus.getDefaultInstance() : responseStatus_;
-        }
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.EchoStatus, io.grpc.benchmarks.proto.Messages.EchoStatus.Builder, io.grpc.benchmarks.proto.Messages.EchoStatusOrBuilder> 
-          getResponseStatusFieldBuilder() {
-        if (responseStatusBuilder_ == null) {
-          responseStatusBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Messages.EchoStatus, io.grpc.benchmarks.proto.Messages.EchoStatus.Builder, io.grpc.benchmarks.proto.Messages.EchoStatusOrBuilder>(
-                  getResponseStatus(),
-                  getParentForChildren(),
-                  isClean());
-          responseStatus_ = null;
-        }
-        return responseStatusBuilder_;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.SimpleRequest)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.SimpleRequest)
-    private static final io.grpc.benchmarks.proto.Messages.SimpleRequest DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Messages.SimpleRequest();
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.SimpleRequest getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<SimpleRequest>
-        PARSER = new com.google.protobuf.AbstractParser<SimpleRequest>() {
-      public SimpleRequest parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new SimpleRequest(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<SimpleRequest> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<SimpleRequest> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Messages.SimpleRequest getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface SimpleResponseOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.SimpleResponse)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Payload to increase message size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    boolean hasPayload();
-    /**
-     * <pre>
-     * Payload to increase message size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.Payload getPayload();
-    /**
-     * <pre>
-     * Payload to increase message size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder();
-
-    /**
-     * <pre>
-     * The user the request came from, for verifying authentication was
-     * successful when the client expected it.
-     * </pre>
-     *
-     * <code>string username = 2;</code>
-     */
-    java.lang.String getUsername();
-    /**
-     * <pre>
-     * The user the request came from, for verifying authentication was
-     * successful when the client expected it.
-     * </pre>
-     *
-     * <code>string username = 2;</code>
-     */
-    com.google.protobuf.ByteString
-        getUsernameBytes();
-
-    /**
-     * <pre>
-     * OAuth scope.
-     * </pre>
-     *
-     * <code>string oauth_scope = 3;</code>
-     */
-    java.lang.String getOauthScope();
-    /**
-     * <pre>
-     * OAuth scope.
-     * </pre>
-     *
-     * <code>string oauth_scope = 3;</code>
-     */
-    com.google.protobuf.ByteString
-        getOauthScopeBytes();
-  }
-  /**
-   * <pre>
-   * Unary response, as configured by the request.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.SimpleResponse}
-   */
-  public  static final class SimpleResponse extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.SimpleResponse)
-      SimpleResponseOrBuilder {
-    // Use SimpleResponse.newBuilder() to construct.
-    private SimpleResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private SimpleResponse() {
-      username_ = "";
-      oauthScope_ = "";
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private SimpleResponse(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              io.grpc.benchmarks.proto.Messages.Payload.Builder subBuilder = null;
-              if (payload_ != null) {
-                subBuilder = payload_.toBuilder();
-              }
-              payload_ = input.readMessage(io.grpc.benchmarks.proto.Messages.Payload.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(payload_);
-                payload_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 18: {
-              java.lang.String s = input.readStringRequireUtf8();
-
-              username_ = s;
-              break;
-            }
-            case 26: {
-              java.lang.String s = input.readStringRequireUtf8();
-
-              oauthScope_ = s;
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_SimpleResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_SimpleResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Messages.SimpleResponse.class, io.grpc.benchmarks.proto.Messages.SimpleResponse.Builder.class);
-    }
-
-    public static final int PAYLOAD_FIELD_NUMBER = 1;
-    private io.grpc.benchmarks.proto.Messages.Payload payload_;
-    /**
-     * <pre>
-     * Payload to increase message size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public boolean hasPayload() {
-      return payload_ != null;
-    }
-    /**
-     * <pre>
-     * Payload to increase message size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.Payload getPayload() {
-      return payload_ == null ? io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-    }
-    /**
-     * <pre>
-     * Payload to increase message size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-      return getPayload();
-    }
-
-    public static final int USERNAME_FIELD_NUMBER = 2;
-    private volatile java.lang.Object username_;
-    /**
-     * <pre>
-     * The user the request came from, for verifying authentication was
-     * successful when the client expected it.
-     * </pre>
-     *
-     * <code>string username = 2;</code>
-     */
-    public java.lang.String getUsername() {
-      java.lang.Object ref = username_;
-      if (ref instanceof java.lang.String) {
-        return (java.lang.String) ref;
-      } else {
-        com.google.protobuf.ByteString bs = 
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        username_ = s;
-        return s;
-      }
-    }
-    /**
-     * <pre>
-     * The user the request came from, for verifying authentication was
-     * successful when the client expected it.
-     * </pre>
-     *
-     * <code>string username = 2;</code>
-     */
-    public com.google.protobuf.ByteString
-        getUsernameBytes() {
-      java.lang.Object ref = username_;
-      if (ref instanceof java.lang.String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        username_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-
-    public static final int OAUTH_SCOPE_FIELD_NUMBER = 3;
-    private volatile java.lang.Object oauthScope_;
-    /**
-     * <pre>
-     * OAuth scope.
-     * </pre>
-     *
-     * <code>string oauth_scope = 3;</code>
-     */
-    public java.lang.String getOauthScope() {
-      java.lang.Object ref = oauthScope_;
-      if (ref instanceof java.lang.String) {
-        return (java.lang.String) ref;
-      } else {
-        com.google.protobuf.ByteString bs = 
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        oauthScope_ = s;
-        return s;
-      }
-    }
-    /**
-     * <pre>
-     * OAuth scope.
-     * </pre>
-     *
-     * <code>string oauth_scope = 3;</code>
-     */
-    public com.google.protobuf.ByteString
-        getOauthScopeBytes() {
-      java.lang.Object ref = oauthScope_;
-      if (ref instanceof java.lang.String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        oauthScope_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (payload_ != null) {
-        output.writeMessage(1, getPayload());
-      }
-      if (!getUsernameBytes().isEmpty()) {
-        com.google.protobuf.GeneratedMessageV3.writeString(output, 2, username_);
-      }
-      if (!getOauthScopeBytes().isEmpty()) {
-        com.google.protobuf.GeneratedMessageV3.writeString(output, 3, oauthScope_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (payload_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, getPayload());
-      }
-      if (!getUsernameBytes().isEmpty()) {
-        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, username_);
-      }
-      if (!getOauthScopeBytes().isEmpty()) {
-        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, oauthScope_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Messages.SimpleResponse)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Messages.SimpleResponse other = (io.grpc.benchmarks.proto.Messages.SimpleResponse) obj;
-
-      boolean result = true;
-      result = result && (hasPayload() == other.hasPayload());
-      if (hasPayload()) {
-        result = result && getPayload()
-            .equals(other.getPayload());
-      }
-      result = result && getUsername()
-          .equals(other.getUsername());
-      result = result && getOauthScope()
-          .equals(other.getOauthScope());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      if (hasPayload()) {
-        hash = (37 * hash) + PAYLOAD_FIELD_NUMBER;
-        hash = (53 * hash) + getPayload().hashCode();
-      }
-      hash = (37 * hash) + USERNAME_FIELD_NUMBER;
-      hash = (53 * hash) + getUsername().hashCode();
-      hash = (37 * hash) + OAUTH_SCOPE_FIELD_NUMBER;
-      hash = (53 * hash) + getOauthScope().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.SimpleResponse parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleResponse parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleResponse parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleResponse parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleResponse parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleResponse parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleResponse parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleResponse parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleResponse parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.SimpleResponse parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Messages.SimpleResponse prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Unary response, as configured by the request.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.SimpleResponse}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.SimpleResponse)
-        io.grpc.benchmarks.proto.Messages.SimpleResponseOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_SimpleResponse_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_SimpleResponse_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Messages.SimpleResponse.class, io.grpc.benchmarks.proto.Messages.SimpleResponse.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Messages.SimpleResponse.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-        username_ = "";
-
-        oauthScope_ = "";
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_SimpleResponse_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.SimpleResponse getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Messages.SimpleResponse.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Messages.SimpleResponse build() {
-        io.grpc.benchmarks.proto.Messages.SimpleResponse result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.SimpleResponse buildPartial() {
-        io.grpc.benchmarks.proto.Messages.SimpleResponse result = new io.grpc.benchmarks.proto.Messages.SimpleResponse(this);
-        if (payloadBuilder_ == null) {
-          result.payload_ = payload_;
-        } else {
-          result.payload_ = payloadBuilder_.build();
-        }
-        result.username_ = username_;
-        result.oauthScope_ = oauthScope_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Messages.SimpleResponse) {
-          return mergeFrom((io.grpc.benchmarks.proto.Messages.SimpleResponse)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Messages.SimpleResponse other) {
-        if (other == io.grpc.benchmarks.proto.Messages.SimpleResponse.getDefaultInstance()) return this;
-        if (other.hasPayload()) {
-          mergePayload(other.getPayload());
-        }
-        if (!other.getUsername().isEmpty()) {
-          username_ = other.username_;
-          onChanged();
-        }
-        if (!other.getOauthScope().isEmpty()) {
-          oauthScope_ = other.oauthScope_;
-          onChanged();
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Messages.SimpleResponse parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Messages.SimpleResponse) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private io.grpc.benchmarks.proto.Messages.Payload payload_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder> payloadBuilder_;
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public boolean hasPayload() {
-        return payloadBuilder_ != null || payload_ != null;
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.Payload getPayload() {
-        if (payloadBuilder_ == null) {
-          return payload_ == null ? io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-        } else {
-          return payloadBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder setPayload(io.grpc.benchmarks.proto.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payload_ = value;
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder setPayload(
-          io.grpc.benchmarks.proto.Messages.Payload.Builder builderForValue) {
-        if (payloadBuilder_ == null) {
-          payload_ = builderForValue.build();
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder mergePayload(io.grpc.benchmarks.proto.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (payload_ != null) {
-            payload_ =
-              io.grpc.benchmarks.proto.Messages.Payload.newBuilder(payload_).mergeFrom(value).buildPartial();
-          } else {
-            payload_ = value;
-          }
-          onChanged();
-        } else {
-          payloadBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder clearPayload() {
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-          onChanged();
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.Payload.Builder getPayloadBuilder() {
-        
-        onChanged();
-        return getPayloadFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-        if (payloadBuilder_ != null) {
-          return payloadBuilder_.getMessageOrBuilder();
-        } else {
-          return payload_ == null ?
-              io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-        }
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder> 
-          getPayloadFieldBuilder() {
-        if (payloadBuilder_ == null) {
-          payloadBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder>(
-                  getPayload(),
-                  getParentForChildren(),
-                  isClean());
-          payload_ = null;
-        }
-        return payloadBuilder_;
-      }
-
-      private java.lang.Object username_ = "";
-      /**
-       * <pre>
-       * The user the request came from, for verifying authentication was
-       * successful when the client expected it.
-       * </pre>
-       *
-       * <code>string username = 2;</code>
-       */
-      public java.lang.String getUsername() {
-        java.lang.Object ref = username_;
-        if (!(ref instanceof java.lang.String)) {
-          com.google.protobuf.ByteString bs =
-              (com.google.protobuf.ByteString) ref;
-          java.lang.String s = bs.toStringUtf8();
-          username_ = s;
-          return s;
-        } else {
-          return (java.lang.String) ref;
-        }
-      }
-      /**
-       * <pre>
-       * The user the request came from, for verifying authentication was
-       * successful when the client expected it.
-       * </pre>
-       *
-       * <code>string username = 2;</code>
-       */
-      public com.google.protobuf.ByteString
-          getUsernameBytes() {
-        java.lang.Object ref = username_;
-        if (ref instanceof String) {
-          com.google.protobuf.ByteString b = 
-              com.google.protobuf.ByteString.copyFromUtf8(
-                  (java.lang.String) ref);
-          username_ = b;
-          return b;
-        } else {
-          return (com.google.protobuf.ByteString) ref;
-        }
-      }
-      /**
-       * <pre>
-       * The user the request came from, for verifying authentication was
-       * successful when the client expected it.
-       * </pre>
-       *
-       * <code>string username = 2;</code>
-       */
-      public Builder setUsername(
-          java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  
-        username_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * The user the request came from, for verifying authentication was
-       * successful when the client expected it.
-       * </pre>
-       *
-       * <code>string username = 2;</code>
-       */
-      public Builder clearUsername() {
-        
-        username_ = getDefaultInstance().getUsername();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * The user the request came from, for verifying authentication was
-       * successful when the client expected it.
-       * </pre>
-       *
-       * <code>string username = 2;</code>
-       */
-      public Builder setUsernameBytes(
-          com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-        
-        username_ = value;
-        onChanged();
-        return this;
-      }
-
-      private java.lang.Object oauthScope_ = "";
-      /**
-       * <pre>
-       * OAuth scope.
-       * </pre>
-       *
-       * <code>string oauth_scope = 3;</code>
-       */
-      public java.lang.String getOauthScope() {
-        java.lang.Object ref = oauthScope_;
-        if (!(ref instanceof java.lang.String)) {
-          com.google.protobuf.ByteString bs =
-              (com.google.protobuf.ByteString) ref;
-          java.lang.String s = bs.toStringUtf8();
-          oauthScope_ = s;
-          return s;
-        } else {
-          return (java.lang.String) ref;
-        }
-      }
-      /**
-       * <pre>
-       * OAuth scope.
-       * </pre>
-       *
-       * <code>string oauth_scope = 3;</code>
-       */
-      public com.google.protobuf.ByteString
-          getOauthScopeBytes() {
-        java.lang.Object ref = oauthScope_;
-        if (ref instanceof String) {
-          com.google.protobuf.ByteString b = 
-              com.google.protobuf.ByteString.copyFromUtf8(
-                  (java.lang.String) ref);
-          oauthScope_ = b;
-          return b;
-        } else {
-          return (com.google.protobuf.ByteString) ref;
-        }
-      }
-      /**
-       * <pre>
-       * OAuth scope.
-       * </pre>
-       *
-       * <code>string oauth_scope = 3;</code>
-       */
-      public Builder setOauthScope(
-          java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  
-        oauthScope_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * OAuth scope.
-       * </pre>
-       *
-       * <code>string oauth_scope = 3;</code>
-       */
-      public Builder clearOauthScope() {
-        
-        oauthScope_ = getDefaultInstance().getOauthScope();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * OAuth scope.
-       * </pre>
-       *
-       * <code>string oauth_scope = 3;</code>
-       */
-      public Builder setOauthScopeBytes(
-          com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-        
-        oauthScope_ = value;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.SimpleResponse)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.SimpleResponse)
-    private static final io.grpc.benchmarks.proto.Messages.SimpleResponse DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Messages.SimpleResponse();
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.SimpleResponse getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<SimpleResponse>
-        PARSER = new com.google.protobuf.AbstractParser<SimpleResponse>() {
-      public SimpleResponse parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new SimpleResponse(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<SimpleResponse> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<SimpleResponse> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Messages.SimpleResponse getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface StreamingInputCallRequestOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.StreamingInputCallRequest)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    boolean hasPayload();
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.Payload getPayload();
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder();
-  }
-  /**
-   * <pre>
-   * Client-streaming request.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.StreamingInputCallRequest}
-   */
-  public  static final class StreamingInputCallRequest extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.StreamingInputCallRequest)
-      StreamingInputCallRequestOrBuilder {
-    // Use StreamingInputCallRequest.newBuilder() to construct.
-    private StreamingInputCallRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private StreamingInputCallRequest() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private StreamingInputCallRequest(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              io.grpc.benchmarks.proto.Messages.Payload.Builder subBuilder = null;
-              if (payload_ != null) {
-                subBuilder = payload_.toBuilder();
-              }
-              payload_ = input.readMessage(io.grpc.benchmarks.proto.Messages.Payload.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(payload_);
-                payload_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingInputCallRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingInputCallRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest.class, io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest.Builder.class);
-    }
-
-    public static final int PAYLOAD_FIELD_NUMBER = 1;
-    private io.grpc.benchmarks.proto.Messages.Payload payload_;
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public boolean hasPayload() {
-      return payload_ != null;
-    }
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.Payload getPayload() {
-      return payload_ == null ? io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-    }
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-      return getPayload();
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (payload_ != null) {
-        output.writeMessage(1, getPayload());
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (payload_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, getPayload());
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest other = (io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest) obj;
-
-      boolean result = true;
-      result = result && (hasPayload() == other.hasPayload());
-      if (hasPayload()) {
-        result = result && getPayload()
-            .equals(other.getPayload());
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      if (hasPayload()) {
-        hash = (37 * hash) + PAYLOAD_FIELD_NUMBER;
-        hash = (53 * hash) + getPayload().hashCode();
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Client-streaming request.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.StreamingInputCallRequest}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.StreamingInputCallRequest)
-        io.grpc.benchmarks.proto.Messages.StreamingInputCallRequestOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingInputCallRequest_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingInputCallRequest_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest.class, io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingInputCallRequest_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest build() {
-        io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest buildPartial() {
-        io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest result = new io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest(this);
-        if (payloadBuilder_ == null) {
-          result.payload_ = payload_;
-        } else {
-          result.payload_ = payloadBuilder_.build();
-        }
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest) {
-          return mergeFrom((io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest other) {
-        if (other == io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest.getDefaultInstance()) return this;
-        if (other.hasPayload()) {
-          mergePayload(other.getPayload());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private io.grpc.benchmarks.proto.Messages.Payload payload_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder> payloadBuilder_;
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public boolean hasPayload() {
-        return payloadBuilder_ != null || payload_ != null;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.Payload getPayload() {
-        if (payloadBuilder_ == null) {
-          return payload_ == null ? io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-        } else {
-          return payloadBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder setPayload(io.grpc.benchmarks.proto.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payload_ = value;
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder setPayload(
-          io.grpc.benchmarks.proto.Messages.Payload.Builder builderForValue) {
-        if (payloadBuilder_ == null) {
-          payload_ = builderForValue.build();
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder mergePayload(io.grpc.benchmarks.proto.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (payload_ != null) {
-            payload_ =
-              io.grpc.benchmarks.proto.Messages.Payload.newBuilder(payload_).mergeFrom(value).buildPartial();
-          } else {
-            payload_ = value;
-          }
-          onChanged();
-        } else {
-          payloadBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder clearPayload() {
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-          onChanged();
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.Payload.Builder getPayloadBuilder() {
-        
-        onChanged();
-        return getPayloadFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-        if (payloadBuilder_ != null) {
-          return payloadBuilder_.getMessageOrBuilder();
-        } else {
-          return payload_ == null ?
-              io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-        }
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder> 
-          getPayloadFieldBuilder() {
-        if (payloadBuilder_ == null) {
-          payloadBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder>(
-                  getPayload(),
-                  getParentForChildren(),
-                  isClean());
-          payload_ = null;
-        }
-        return payloadBuilder_;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.StreamingInputCallRequest)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.StreamingInputCallRequest)
-    private static final io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest();
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<StreamingInputCallRequest>
-        PARSER = new com.google.protobuf.AbstractParser<StreamingInputCallRequest>() {
-      public StreamingInputCallRequest parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new StreamingInputCallRequest(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<StreamingInputCallRequest> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<StreamingInputCallRequest> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Messages.StreamingInputCallRequest getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface StreamingInputCallResponseOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.StreamingInputCallResponse)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Aggregated size of payloads received from the client.
-     * </pre>
-     *
-     * <code>int32 aggregated_payload_size = 1;</code>
-     */
-    int getAggregatedPayloadSize();
-  }
-  /**
-   * <pre>
-   * Client-streaming response.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.StreamingInputCallResponse}
-   */
-  public  static final class StreamingInputCallResponse extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.StreamingInputCallResponse)
-      StreamingInputCallResponseOrBuilder {
-    // Use StreamingInputCallResponse.newBuilder() to construct.
-    private StreamingInputCallResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private StreamingInputCallResponse() {
-      aggregatedPayloadSize_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private StreamingInputCallResponse(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              aggregatedPayloadSize_ = input.readInt32();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingInputCallResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingInputCallResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse.class, io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse.Builder.class);
-    }
-
-    public static final int AGGREGATED_PAYLOAD_SIZE_FIELD_NUMBER = 1;
-    private int aggregatedPayloadSize_;
-    /**
-     * <pre>
-     * Aggregated size of payloads received from the client.
-     * </pre>
-     *
-     * <code>int32 aggregated_payload_size = 1;</code>
-     */
-    public int getAggregatedPayloadSize() {
-      return aggregatedPayloadSize_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (aggregatedPayloadSize_ != 0) {
-        output.writeInt32(1, aggregatedPayloadSize_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (aggregatedPayloadSize_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(1, aggregatedPayloadSize_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse other = (io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse) obj;
-
-      boolean result = true;
-      result = result && (getAggregatedPayloadSize()
-          == other.getAggregatedPayloadSize());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + AGGREGATED_PAYLOAD_SIZE_FIELD_NUMBER;
-      hash = (53 * hash) + getAggregatedPayloadSize();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Client-streaming response.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.StreamingInputCallResponse}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.StreamingInputCallResponse)
-        io.grpc.benchmarks.proto.Messages.StreamingInputCallResponseOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingInputCallResponse_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingInputCallResponse_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse.class, io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        aggregatedPayloadSize_ = 0;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingInputCallResponse_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse build() {
-        io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse buildPartial() {
-        io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse result = new io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse(this);
-        result.aggregatedPayloadSize_ = aggregatedPayloadSize_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse) {
-          return mergeFrom((io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse other) {
-        if (other == io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse.getDefaultInstance()) return this;
-        if (other.getAggregatedPayloadSize() != 0) {
-          setAggregatedPayloadSize(other.getAggregatedPayloadSize());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int aggregatedPayloadSize_ ;
-      /**
-       * <pre>
-       * Aggregated size of payloads received from the client.
-       * </pre>
-       *
-       * <code>int32 aggregated_payload_size = 1;</code>
-       */
-      public int getAggregatedPayloadSize() {
-        return aggregatedPayloadSize_;
-      }
-      /**
-       * <pre>
-       * Aggregated size of payloads received from the client.
-       * </pre>
-       *
-       * <code>int32 aggregated_payload_size = 1;</code>
-       */
-      public Builder setAggregatedPayloadSize(int value) {
-        
-        aggregatedPayloadSize_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Aggregated size of payloads received from the client.
-       * </pre>
-       *
-       * <code>int32 aggregated_payload_size = 1;</code>
-       */
-      public Builder clearAggregatedPayloadSize() {
-        
-        aggregatedPayloadSize_ = 0;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.StreamingInputCallResponse)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.StreamingInputCallResponse)
-    private static final io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse();
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<StreamingInputCallResponse>
-        PARSER = new com.google.protobuf.AbstractParser<StreamingInputCallResponse>() {
-      public StreamingInputCallResponse parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new StreamingInputCallResponse(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<StreamingInputCallResponse> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<StreamingInputCallResponse> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Messages.StreamingInputCallResponse getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ResponseParametersOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ResponseParameters)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Desired payload sizes in responses from the server.
-     * If response_type is COMPRESSABLE, this denotes the size before compression.
-     * </pre>
-     *
-     * <code>int32 size = 1;</code>
-     */
-    int getSize();
-
-    /**
-     * <pre>
-     * Desired interval between consecutive responses in the response stream in
-     * microseconds.
-     * </pre>
-     *
-     * <code>int32 interval_us = 2;</code>
-     */
-    int getIntervalUs();
-  }
-  /**
-   * <pre>
-   * Configuration for a particular response.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.ResponseParameters}
-   */
-  public  static final class ResponseParameters extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ResponseParameters)
-      ResponseParametersOrBuilder {
-    // Use ResponseParameters.newBuilder() to construct.
-    private ResponseParameters(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ResponseParameters() {
-      size_ = 0;
-      intervalUs_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ResponseParameters(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              size_ = input.readInt32();
-              break;
-            }
-            case 16: {
-
-              intervalUs_ = input.readInt32();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_ResponseParameters_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_ResponseParameters_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Messages.ResponseParameters.class, io.grpc.benchmarks.proto.Messages.ResponseParameters.Builder.class);
-    }
-
-    public static final int SIZE_FIELD_NUMBER = 1;
-    private int size_;
-    /**
-     * <pre>
-     * Desired payload sizes in responses from the server.
-     * If response_type is COMPRESSABLE, this denotes the size before compression.
-     * </pre>
-     *
-     * <code>int32 size = 1;</code>
-     */
-    public int getSize() {
-      return size_;
-    }
-
-    public static final int INTERVAL_US_FIELD_NUMBER = 2;
-    private int intervalUs_;
-    /**
-     * <pre>
-     * Desired interval between consecutive responses in the response stream in
-     * microseconds.
-     * </pre>
-     *
-     * <code>int32 interval_us = 2;</code>
-     */
-    public int getIntervalUs() {
-      return intervalUs_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (size_ != 0) {
-        output.writeInt32(1, size_);
-      }
-      if (intervalUs_ != 0) {
-        output.writeInt32(2, intervalUs_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (size_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(1, size_);
-      }
-      if (intervalUs_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(2, intervalUs_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Messages.ResponseParameters)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Messages.ResponseParameters other = (io.grpc.benchmarks.proto.Messages.ResponseParameters) obj;
-
-      boolean result = true;
-      result = result && (getSize()
-          == other.getSize());
-      result = result && (getIntervalUs()
-          == other.getIntervalUs());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + SIZE_FIELD_NUMBER;
-      hash = (53 * hash) + getSize();
-      hash = (37 * hash) + INTERVAL_US_FIELD_NUMBER;
-      hash = (53 * hash) + getIntervalUs();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.ResponseParameters parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ResponseParameters parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ResponseParameters parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ResponseParameters parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ResponseParameters parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ResponseParameters parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ResponseParameters parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ResponseParameters parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ResponseParameters parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ResponseParameters parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Messages.ResponseParameters prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Configuration for a particular response.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.ResponseParameters}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ResponseParameters)
-        io.grpc.benchmarks.proto.Messages.ResponseParametersOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_ResponseParameters_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_ResponseParameters_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Messages.ResponseParameters.class, io.grpc.benchmarks.proto.Messages.ResponseParameters.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Messages.ResponseParameters.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        size_ = 0;
-
-        intervalUs_ = 0;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_ResponseParameters_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.ResponseParameters getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Messages.ResponseParameters.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Messages.ResponseParameters build() {
-        io.grpc.benchmarks.proto.Messages.ResponseParameters result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.ResponseParameters buildPartial() {
-        io.grpc.benchmarks.proto.Messages.ResponseParameters result = new io.grpc.benchmarks.proto.Messages.ResponseParameters(this);
-        result.size_ = size_;
-        result.intervalUs_ = intervalUs_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Messages.ResponseParameters) {
-          return mergeFrom((io.grpc.benchmarks.proto.Messages.ResponseParameters)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Messages.ResponseParameters other) {
-        if (other == io.grpc.benchmarks.proto.Messages.ResponseParameters.getDefaultInstance()) return this;
-        if (other.getSize() != 0) {
-          setSize(other.getSize());
-        }
-        if (other.getIntervalUs() != 0) {
-          setIntervalUs(other.getIntervalUs());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Messages.ResponseParameters parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Messages.ResponseParameters) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int size_ ;
-      /**
-       * <pre>
-       * Desired payload sizes in responses from the server.
-       * If response_type is COMPRESSABLE, this denotes the size before compression.
-       * </pre>
-       *
-       * <code>int32 size = 1;</code>
-       */
-      public int getSize() {
-        return size_;
-      }
-      /**
-       * <pre>
-       * Desired payload sizes in responses from the server.
-       * If response_type is COMPRESSABLE, this denotes the size before compression.
-       * </pre>
-       *
-       * <code>int32 size = 1;</code>
-       */
-      public Builder setSize(int value) {
-        
-        size_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired payload sizes in responses from the server.
-       * If response_type is COMPRESSABLE, this denotes the size before compression.
-       * </pre>
-       *
-       * <code>int32 size = 1;</code>
-       */
-      public Builder clearSize() {
-        
-        size_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private int intervalUs_ ;
-      /**
-       * <pre>
-       * Desired interval between consecutive responses in the response stream in
-       * microseconds.
-       * </pre>
-       *
-       * <code>int32 interval_us = 2;</code>
-       */
-      public int getIntervalUs() {
-        return intervalUs_;
-      }
-      /**
-       * <pre>
-       * Desired interval between consecutive responses in the response stream in
-       * microseconds.
-       * </pre>
-       *
-       * <code>int32 interval_us = 2;</code>
-       */
-      public Builder setIntervalUs(int value) {
-        
-        intervalUs_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired interval between consecutive responses in the response stream in
-       * microseconds.
-       * </pre>
-       *
-       * <code>int32 interval_us = 2;</code>
-       */
-      public Builder clearIntervalUs() {
-        
-        intervalUs_ = 0;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ResponseParameters)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ResponseParameters)
-    private static final io.grpc.benchmarks.proto.Messages.ResponseParameters DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Messages.ResponseParameters();
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.ResponseParameters getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ResponseParameters>
-        PARSER = new com.google.protobuf.AbstractParser<ResponseParameters>() {
-      public ResponseParameters parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ResponseParameters(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ResponseParameters> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ResponseParameters> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Messages.ResponseParameters getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface StreamingOutputCallRequestOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.StreamingOutputCallRequest)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, the payload from each response in the stream
-     * might be of different types. This is to simulate a mixed type of payload
-     * stream.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    int getResponseTypeValue();
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, the payload from each response in the stream
-     * might be of different types. This is to simulate a mixed type of payload
-     * stream.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.PayloadType getResponseType();
-
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    java.util.List<io.grpc.benchmarks.proto.Messages.ResponseParameters> 
-        getResponseParametersList();
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.ResponseParameters getResponseParameters(int index);
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    int getResponseParametersCount();
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    java.util.List<? extends io.grpc.benchmarks.proto.Messages.ResponseParametersOrBuilder> 
-        getResponseParametersOrBuilderList();
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.ResponseParametersOrBuilder getResponseParametersOrBuilder(
-        int index);
-
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    boolean hasPayload();
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.Payload getPayload();
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder();
-
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    int getResponseCompressionValue();
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.CompressionType getResponseCompression();
-
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    boolean hasResponseStatus();
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.EchoStatus getResponseStatus();
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.EchoStatusOrBuilder getResponseStatusOrBuilder();
-  }
-  /**
-   * <pre>
-   * Server-streaming request.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.StreamingOutputCallRequest}
-   */
-  public  static final class StreamingOutputCallRequest extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.StreamingOutputCallRequest)
-      StreamingOutputCallRequestOrBuilder {
-    // Use StreamingOutputCallRequest.newBuilder() to construct.
-    private StreamingOutputCallRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private StreamingOutputCallRequest() {
-      responseType_ = 0;
-      responseParameters_ = java.util.Collections.emptyList();
-      responseCompression_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private StreamingOutputCallRequest(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-              int rawValue = input.readEnum();
-
-              responseType_ = rawValue;
-              break;
-            }
-            case 18: {
-              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
-                responseParameters_ = new java.util.ArrayList<io.grpc.benchmarks.proto.Messages.ResponseParameters>();
-                mutable_bitField0_ |= 0x00000002;
-              }
-              responseParameters_.add(
-                  input.readMessage(io.grpc.benchmarks.proto.Messages.ResponseParameters.parser(), extensionRegistry));
-              break;
-            }
-            case 26: {
-              io.grpc.benchmarks.proto.Messages.Payload.Builder subBuilder = null;
-              if (payload_ != null) {
-                subBuilder = payload_.toBuilder();
-              }
-              payload_ = input.readMessage(io.grpc.benchmarks.proto.Messages.Payload.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(payload_);
-                payload_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 48: {
-              int rawValue = input.readEnum();
-
-              responseCompression_ = rawValue;
-              break;
-            }
-            case 58: {
-              io.grpc.benchmarks.proto.Messages.EchoStatus.Builder subBuilder = null;
-              if (responseStatus_ != null) {
-                subBuilder = responseStatus_.toBuilder();
-              }
-              responseStatus_ = input.readMessage(io.grpc.benchmarks.proto.Messages.EchoStatus.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(responseStatus_);
-                responseStatus_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
-          responseParameters_ = java.util.Collections.unmodifiableList(responseParameters_);
-        }
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingOutputCallRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingOutputCallRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest.class, io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest.Builder.class);
-    }
-
-    private int bitField0_;
-    public static final int RESPONSE_TYPE_FIELD_NUMBER = 1;
-    private int responseType_;
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, the payload from each response in the stream
-     * might be of different types. This is to simulate a mixed type of payload
-     * stream.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    public int getResponseTypeValue() {
-      return responseType_;
-    }
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, the payload from each response in the stream
-     * might be of different types. This is to simulate a mixed type of payload
-     * stream.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.PayloadType getResponseType() {
-      io.grpc.benchmarks.proto.Messages.PayloadType result = io.grpc.benchmarks.proto.Messages.PayloadType.valueOf(responseType_);
-      return result == null ? io.grpc.benchmarks.proto.Messages.PayloadType.UNRECOGNIZED : result;
-    }
-
-    public static final int RESPONSE_PARAMETERS_FIELD_NUMBER = 2;
-    private java.util.List<io.grpc.benchmarks.proto.Messages.ResponseParameters> responseParameters_;
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    public java.util.List<io.grpc.benchmarks.proto.Messages.ResponseParameters> getResponseParametersList() {
-      return responseParameters_;
-    }
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    public java.util.List<? extends io.grpc.benchmarks.proto.Messages.ResponseParametersOrBuilder> 
-        getResponseParametersOrBuilderList() {
-      return responseParameters_;
-    }
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    public int getResponseParametersCount() {
-      return responseParameters_.size();
-    }
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.ResponseParameters getResponseParameters(int index) {
-      return responseParameters_.get(index);
-    }
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.ResponseParametersOrBuilder getResponseParametersOrBuilder(
-        int index) {
-      return responseParameters_.get(index);
-    }
-
-    public static final int PAYLOAD_FIELD_NUMBER = 3;
-    private io.grpc.benchmarks.proto.Messages.Payload payload_;
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    public boolean hasPayload() {
-      return payload_ != null;
-    }
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.Payload getPayload() {
-      return payload_ == null ? io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-    }
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-      return getPayload();
-    }
-
-    public static final int RESPONSE_COMPRESSION_FIELD_NUMBER = 6;
-    private int responseCompression_;
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    public int getResponseCompressionValue() {
-      return responseCompression_;
-    }
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.CompressionType getResponseCompression() {
-      io.grpc.benchmarks.proto.Messages.CompressionType result = io.grpc.benchmarks.proto.Messages.CompressionType.valueOf(responseCompression_);
-      return result == null ? io.grpc.benchmarks.proto.Messages.CompressionType.UNRECOGNIZED : result;
-    }
-
-    public static final int RESPONSE_STATUS_FIELD_NUMBER = 7;
-    private io.grpc.benchmarks.proto.Messages.EchoStatus responseStatus_;
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    public boolean hasResponseStatus() {
-      return responseStatus_ != null;
-    }
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.EchoStatus getResponseStatus() {
-      return responseStatus_ == null ? io.grpc.benchmarks.proto.Messages.EchoStatus.getDefaultInstance() : responseStatus_;
-    }
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.EchoStatusOrBuilder getResponseStatusOrBuilder() {
-      return getResponseStatus();
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (responseType_ != io.grpc.benchmarks.proto.Messages.PayloadType.COMPRESSABLE.getNumber()) {
-        output.writeEnum(1, responseType_);
-      }
-      for (int i = 0; i < responseParameters_.size(); i++) {
-        output.writeMessage(2, responseParameters_.get(i));
-      }
-      if (payload_ != null) {
-        output.writeMessage(3, getPayload());
-      }
-      if (responseCompression_ != io.grpc.benchmarks.proto.Messages.CompressionType.NONE.getNumber()) {
-        output.writeEnum(6, responseCompression_);
-      }
-      if (responseStatus_ != null) {
-        output.writeMessage(7, getResponseStatus());
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (responseType_ != io.grpc.benchmarks.proto.Messages.PayloadType.COMPRESSABLE.getNumber()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeEnumSize(1, responseType_);
-      }
-      for (int i = 0; i < responseParameters_.size(); i++) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(2, responseParameters_.get(i));
-      }
-      if (payload_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(3, getPayload());
-      }
-      if (responseCompression_ != io.grpc.benchmarks.proto.Messages.CompressionType.NONE.getNumber()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeEnumSize(6, responseCompression_);
-      }
-      if (responseStatus_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(7, getResponseStatus());
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest other = (io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest) obj;
-
-      boolean result = true;
-      result = result && responseType_ == other.responseType_;
-      result = result && getResponseParametersList()
-          .equals(other.getResponseParametersList());
-      result = result && (hasPayload() == other.hasPayload());
-      if (hasPayload()) {
-        result = result && getPayload()
-            .equals(other.getPayload());
-      }
-      result = result && responseCompression_ == other.responseCompression_;
-      result = result && (hasResponseStatus() == other.hasResponseStatus());
-      if (hasResponseStatus()) {
-        result = result && getResponseStatus()
-            .equals(other.getResponseStatus());
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + RESPONSE_TYPE_FIELD_NUMBER;
-      hash = (53 * hash) + responseType_;
-      if (getResponseParametersCount() > 0) {
-        hash = (37 * hash) + RESPONSE_PARAMETERS_FIELD_NUMBER;
-        hash = (53 * hash) + getResponseParametersList().hashCode();
-      }
-      if (hasPayload()) {
-        hash = (37 * hash) + PAYLOAD_FIELD_NUMBER;
-        hash = (53 * hash) + getPayload().hashCode();
-      }
-      hash = (37 * hash) + RESPONSE_COMPRESSION_FIELD_NUMBER;
-      hash = (53 * hash) + responseCompression_;
-      if (hasResponseStatus()) {
-        hash = (37 * hash) + RESPONSE_STATUS_FIELD_NUMBER;
-        hash = (53 * hash) + getResponseStatus().hashCode();
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Server-streaming request.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.StreamingOutputCallRequest}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.StreamingOutputCallRequest)
-        io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequestOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingOutputCallRequest_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingOutputCallRequest_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest.class, io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-          getResponseParametersFieldBuilder();
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        responseType_ = 0;
-
-        if (responseParametersBuilder_ == null) {
-          responseParameters_ = java.util.Collections.emptyList();
-          bitField0_ = (bitField0_ & ~0x00000002);
-        } else {
-          responseParametersBuilder_.clear();
-        }
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-        responseCompression_ = 0;
-
-        if (responseStatusBuilder_ == null) {
-          responseStatus_ = null;
-        } else {
-          responseStatus_ = null;
-          responseStatusBuilder_ = null;
-        }
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingOutputCallRequest_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest build() {
-        io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest buildPartial() {
-        io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest result = new io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest(this);
-        int from_bitField0_ = bitField0_;
-        int to_bitField0_ = 0;
-        result.responseType_ = responseType_;
-        if (responseParametersBuilder_ == null) {
-          if (((bitField0_ & 0x00000002) == 0x00000002)) {
-            responseParameters_ = java.util.Collections.unmodifiableList(responseParameters_);
-            bitField0_ = (bitField0_ & ~0x00000002);
-          }
-          result.responseParameters_ = responseParameters_;
-        } else {
-          result.responseParameters_ = responseParametersBuilder_.build();
-        }
-        if (payloadBuilder_ == null) {
-          result.payload_ = payload_;
-        } else {
-          result.payload_ = payloadBuilder_.build();
-        }
-        result.responseCompression_ = responseCompression_;
-        if (responseStatusBuilder_ == null) {
-          result.responseStatus_ = responseStatus_;
-        } else {
-          result.responseStatus_ = responseStatusBuilder_.build();
-        }
-        result.bitField0_ = to_bitField0_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest) {
-          return mergeFrom((io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest other) {
-        if (other == io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest.getDefaultInstance()) return this;
-        if (other.responseType_ != 0) {
-          setResponseTypeValue(other.getResponseTypeValue());
-        }
-        if (responseParametersBuilder_ == null) {
-          if (!other.responseParameters_.isEmpty()) {
-            if (responseParameters_.isEmpty()) {
-              responseParameters_ = other.responseParameters_;
-              bitField0_ = (bitField0_ & ~0x00000002);
-            } else {
-              ensureResponseParametersIsMutable();
-              responseParameters_.addAll(other.responseParameters_);
-            }
-            onChanged();
-          }
-        } else {
-          if (!other.responseParameters_.isEmpty()) {
-            if (responseParametersBuilder_.isEmpty()) {
-              responseParametersBuilder_.dispose();
-              responseParametersBuilder_ = null;
-              responseParameters_ = other.responseParameters_;
-              bitField0_ = (bitField0_ & ~0x00000002);
-              responseParametersBuilder_ = 
-                com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
-                   getResponseParametersFieldBuilder() : null;
-            } else {
-              responseParametersBuilder_.addAllMessages(other.responseParameters_);
-            }
-          }
-        }
-        if (other.hasPayload()) {
-          mergePayload(other.getPayload());
-        }
-        if (other.responseCompression_ != 0) {
-          setResponseCompressionValue(other.getResponseCompressionValue());
-        }
-        if (other.hasResponseStatus()) {
-          mergeResponseStatus(other.getResponseStatus());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      private int bitField0_;
-
-      private int responseType_ = 0;
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, the payload from each response in the stream
-       * might be of different types. This is to simulate a mixed type of payload
-       * stream.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public int getResponseTypeValue() {
-        return responseType_;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, the payload from each response in the stream
-       * might be of different types. This is to simulate a mixed type of payload
-       * stream.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public Builder setResponseTypeValue(int value) {
-        responseType_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, the payload from each response in the stream
-       * might be of different types. This is to simulate a mixed type of payload
-       * stream.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.PayloadType getResponseType() {
-        io.grpc.benchmarks.proto.Messages.PayloadType result = io.grpc.benchmarks.proto.Messages.PayloadType.valueOf(responseType_);
-        return result == null ? io.grpc.benchmarks.proto.Messages.PayloadType.UNRECOGNIZED : result;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, the payload from each response in the stream
-       * might be of different types. This is to simulate a mixed type of payload
-       * stream.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public Builder setResponseType(io.grpc.benchmarks.proto.Messages.PayloadType value) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        
-        responseType_ = value.getNumber();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, the payload from each response in the stream
-       * might be of different types. This is to simulate a mixed type of payload
-       * stream.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public Builder clearResponseType() {
-        
-        responseType_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private java.util.List<io.grpc.benchmarks.proto.Messages.ResponseParameters> responseParameters_ =
-        java.util.Collections.emptyList();
-      private void ensureResponseParametersIsMutable() {
-        if (!((bitField0_ & 0x00000002) == 0x00000002)) {
-          responseParameters_ = new java.util.ArrayList<io.grpc.benchmarks.proto.Messages.ResponseParameters>(responseParameters_);
-          bitField0_ |= 0x00000002;
-         }
-      }
-
-      private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.ResponseParameters, io.grpc.benchmarks.proto.Messages.ResponseParameters.Builder, io.grpc.benchmarks.proto.Messages.ResponseParametersOrBuilder> responseParametersBuilder_;
-
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public java.util.List<io.grpc.benchmarks.proto.Messages.ResponseParameters> getResponseParametersList() {
-        if (responseParametersBuilder_ == null) {
-          return java.util.Collections.unmodifiableList(responseParameters_);
-        } else {
-          return responseParametersBuilder_.getMessageList();
-        }
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public int getResponseParametersCount() {
-        if (responseParametersBuilder_ == null) {
-          return responseParameters_.size();
-        } else {
-          return responseParametersBuilder_.getCount();
-        }
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.ResponseParameters getResponseParameters(int index) {
-        if (responseParametersBuilder_ == null) {
-          return responseParameters_.get(index);
-        } else {
-          return responseParametersBuilder_.getMessage(index);
-        }
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder setResponseParameters(
-          int index, io.grpc.benchmarks.proto.Messages.ResponseParameters value) {
-        if (responseParametersBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          ensureResponseParametersIsMutable();
-          responseParameters_.set(index, value);
-          onChanged();
-        } else {
-          responseParametersBuilder_.setMessage(index, value);
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder setResponseParameters(
-          int index, io.grpc.benchmarks.proto.Messages.ResponseParameters.Builder builderForValue) {
-        if (responseParametersBuilder_ == null) {
-          ensureResponseParametersIsMutable();
-          responseParameters_.set(index, builderForValue.build());
-          onChanged();
-        } else {
-          responseParametersBuilder_.setMessage(index, builderForValue.build());
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder addResponseParameters(io.grpc.benchmarks.proto.Messages.ResponseParameters value) {
-        if (responseParametersBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          ensureResponseParametersIsMutable();
-          responseParameters_.add(value);
-          onChanged();
-        } else {
-          responseParametersBuilder_.addMessage(value);
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder addResponseParameters(
-          int index, io.grpc.benchmarks.proto.Messages.ResponseParameters value) {
-        if (responseParametersBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          ensureResponseParametersIsMutable();
-          responseParameters_.add(index, value);
-          onChanged();
-        } else {
-          responseParametersBuilder_.addMessage(index, value);
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder addResponseParameters(
-          io.grpc.benchmarks.proto.Messages.ResponseParameters.Builder builderForValue) {
-        if (responseParametersBuilder_ == null) {
-          ensureResponseParametersIsMutable();
-          responseParameters_.add(builderForValue.build());
-          onChanged();
-        } else {
-          responseParametersBuilder_.addMessage(builderForValue.build());
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder addResponseParameters(
-          int index, io.grpc.benchmarks.proto.Messages.ResponseParameters.Builder builderForValue) {
-        if (responseParametersBuilder_ == null) {
-          ensureResponseParametersIsMutable();
-          responseParameters_.add(index, builderForValue.build());
-          onChanged();
-        } else {
-          responseParametersBuilder_.addMessage(index, builderForValue.build());
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder addAllResponseParameters(
-          java.lang.Iterable<? extends io.grpc.benchmarks.proto.Messages.ResponseParameters> values) {
-        if (responseParametersBuilder_ == null) {
-          ensureResponseParametersIsMutable();
-          com.google.protobuf.AbstractMessageLite.Builder.addAll(
-              values, responseParameters_);
-          onChanged();
-        } else {
-          responseParametersBuilder_.addAllMessages(values);
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder clearResponseParameters() {
-        if (responseParametersBuilder_ == null) {
-          responseParameters_ = java.util.Collections.emptyList();
-          bitField0_ = (bitField0_ & ~0x00000002);
-          onChanged();
-        } else {
-          responseParametersBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder removeResponseParameters(int index) {
-        if (responseParametersBuilder_ == null) {
-          ensureResponseParametersIsMutable();
-          responseParameters_.remove(index);
-          onChanged();
-        } else {
-          responseParametersBuilder_.remove(index);
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.ResponseParameters.Builder getResponseParametersBuilder(
-          int index) {
-        return getResponseParametersFieldBuilder().getBuilder(index);
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.ResponseParametersOrBuilder getResponseParametersOrBuilder(
-          int index) {
-        if (responseParametersBuilder_ == null) {
-          return responseParameters_.get(index);  } else {
-          return responseParametersBuilder_.getMessageOrBuilder(index);
-        }
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public java.util.List<? extends io.grpc.benchmarks.proto.Messages.ResponseParametersOrBuilder> 
-           getResponseParametersOrBuilderList() {
-        if (responseParametersBuilder_ != null) {
-          return responseParametersBuilder_.getMessageOrBuilderList();
-        } else {
-          return java.util.Collections.unmodifiableList(responseParameters_);
-        }
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.ResponseParameters.Builder addResponseParametersBuilder() {
-        return getResponseParametersFieldBuilder().addBuilder(
-            io.grpc.benchmarks.proto.Messages.ResponseParameters.getDefaultInstance());
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.ResponseParameters.Builder addResponseParametersBuilder(
-          int index) {
-        return getResponseParametersFieldBuilder().addBuilder(
-            index, io.grpc.benchmarks.proto.Messages.ResponseParameters.getDefaultInstance());
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public java.util.List<io.grpc.benchmarks.proto.Messages.ResponseParameters.Builder> 
-           getResponseParametersBuilderList() {
-        return getResponseParametersFieldBuilder().getBuilderList();
-      }
-      private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.ResponseParameters, io.grpc.benchmarks.proto.Messages.ResponseParameters.Builder, io.grpc.benchmarks.proto.Messages.ResponseParametersOrBuilder> 
-          getResponseParametersFieldBuilder() {
-        if (responseParametersBuilder_ == null) {
-          responseParametersBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.grpc.benchmarks.proto.Messages.ResponseParameters, io.grpc.benchmarks.proto.Messages.ResponseParameters.Builder, io.grpc.benchmarks.proto.Messages.ResponseParametersOrBuilder>(
-                  responseParameters_,
-                  ((bitField0_ & 0x00000002) == 0x00000002),
-                  getParentForChildren(),
-                  isClean());
-          responseParameters_ = null;
-        }
-        return responseParametersBuilder_;
-      }
-
-      private io.grpc.benchmarks.proto.Messages.Payload payload_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder> payloadBuilder_;
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public boolean hasPayload() {
-        return payloadBuilder_ != null || payload_ != null;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.Payload getPayload() {
-        if (payloadBuilder_ == null) {
-          return payload_ == null ? io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-        } else {
-          return payloadBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder setPayload(io.grpc.benchmarks.proto.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payload_ = value;
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder setPayload(
-          io.grpc.benchmarks.proto.Messages.Payload.Builder builderForValue) {
-        if (payloadBuilder_ == null) {
-          payload_ = builderForValue.build();
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder mergePayload(io.grpc.benchmarks.proto.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (payload_ != null) {
-            payload_ =
-              io.grpc.benchmarks.proto.Messages.Payload.newBuilder(payload_).mergeFrom(value).buildPartial();
-          } else {
-            payload_ = value;
-          }
-          onChanged();
-        } else {
-          payloadBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder clearPayload() {
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-          onChanged();
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.Payload.Builder getPayloadBuilder() {
-        
-        onChanged();
-        return getPayloadFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-        if (payloadBuilder_ != null) {
-          return payloadBuilder_.getMessageOrBuilder();
-        } else {
-          return payload_ == null ?
-              io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-        }
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder> 
-          getPayloadFieldBuilder() {
-        if (payloadBuilder_ == null) {
-          payloadBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder>(
-                  getPayload(),
-                  getParentForChildren(),
-                  isClean());
-          payload_ = null;
-        }
-        return payloadBuilder_;
-      }
-
-      private int responseCompression_ = 0;
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public int getResponseCompressionValue() {
-        return responseCompression_;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public Builder setResponseCompressionValue(int value) {
-        responseCompression_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.CompressionType getResponseCompression() {
-        io.grpc.benchmarks.proto.Messages.CompressionType result = io.grpc.benchmarks.proto.Messages.CompressionType.valueOf(responseCompression_);
-        return result == null ? io.grpc.benchmarks.proto.Messages.CompressionType.UNRECOGNIZED : result;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public Builder setResponseCompression(io.grpc.benchmarks.proto.Messages.CompressionType value) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        
-        responseCompression_ = value.getNumber();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public Builder clearResponseCompression() {
-        
-        responseCompression_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private io.grpc.benchmarks.proto.Messages.EchoStatus responseStatus_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.EchoStatus, io.grpc.benchmarks.proto.Messages.EchoStatus.Builder, io.grpc.benchmarks.proto.Messages.EchoStatusOrBuilder> responseStatusBuilder_;
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public boolean hasResponseStatus() {
-        return responseStatusBuilder_ != null || responseStatus_ != null;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.EchoStatus getResponseStatus() {
-        if (responseStatusBuilder_ == null) {
-          return responseStatus_ == null ? io.grpc.benchmarks.proto.Messages.EchoStatus.getDefaultInstance() : responseStatus_;
-        } else {
-          return responseStatusBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder setResponseStatus(io.grpc.benchmarks.proto.Messages.EchoStatus value) {
-        if (responseStatusBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          responseStatus_ = value;
-          onChanged();
-        } else {
-          responseStatusBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder setResponseStatus(
-          io.grpc.benchmarks.proto.Messages.EchoStatus.Builder builderForValue) {
-        if (responseStatusBuilder_ == null) {
-          responseStatus_ = builderForValue.build();
-          onChanged();
-        } else {
-          responseStatusBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder mergeResponseStatus(io.grpc.benchmarks.proto.Messages.EchoStatus value) {
-        if (responseStatusBuilder_ == null) {
-          if (responseStatus_ != null) {
-            responseStatus_ =
-              io.grpc.benchmarks.proto.Messages.EchoStatus.newBuilder(responseStatus_).mergeFrom(value).buildPartial();
-          } else {
-            responseStatus_ = value;
-          }
-          onChanged();
-        } else {
-          responseStatusBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder clearResponseStatus() {
-        if (responseStatusBuilder_ == null) {
-          responseStatus_ = null;
-          onChanged();
-        } else {
-          responseStatus_ = null;
-          responseStatusBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.EchoStatus.Builder getResponseStatusBuilder() {
-        
-        onChanged();
-        return getResponseStatusFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.EchoStatusOrBuilder getResponseStatusOrBuilder() {
-        if (responseStatusBuilder_ != null) {
-          return responseStatusBuilder_.getMessageOrBuilder();
-        } else {
-          return responseStatus_ == null ?
-              io.grpc.benchmarks.proto.Messages.EchoStatus.getDefaultInstance() : responseStatus_;
-        }
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.EchoStatus, io.grpc.benchmarks.proto.Messages.EchoStatus.Builder, io.grpc.benchmarks.proto.Messages.EchoStatusOrBuilder> 
-          getResponseStatusFieldBuilder() {
-        if (responseStatusBuilder_ == null) {
-          responseStatusBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Messages.EchoStatus, io.grpc.benchmarks.proto.Messages.EchoStatus.Builder, io.grpc.benchmarks.proto.Messages.EchoStatusOrBuilder>(
-                  getResponseStatus(),
-                  getParentForChildren(),
-                  isClean());
-          responseStatus_ = null;
-        }
-        return responseStatusBuilder_;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.StreamingOutputCallRequest)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.StreamingOutputCallRequest)
-    private static final io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest();
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<StreamingOutputCallRequest>
-        PARSER = new com.google.protobuf.AbstractParser<StreamingOutputCallRequest>() {
-      public StreamingOutputCallRequest parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new StreamingOutputCallRequest(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<StreamingOutputCallRequest> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<StreamingOutputCallRequest> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Messages.StreamingOutputCallRequest getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface StreamingOutputCallResponseOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.StreamingOutputCallResponse)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Payload to increase response size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    boolean hasPayload();
-    /**
-     * <pre>
-     * Payload to increase response size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.Payload getPayload();
-    /**
-     * <pre>
-     * Payload to increase response size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder();
-  }
-  /**
-   * <pre>
-   * Server-streaming response, as configured by the request and parameters.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.StreamingOutputCallResponse}
-   */
-  public  static final class StreamingOutputCallResponse extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.StreamingOutputCallResponse)
-      StreamingOutputCallResponseOrBuilder {
-    // Use StreamingOutputCallResponse.newBuilder() to construct.
-    private StreamingOutputCallResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private StreamingOutputCallResponse() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private StreamingOutputCallResponse(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              io.grpc.benchmarks.proto.Messages.Payload.Builder subBuilder = null;
-              if (payload_ != null) {
-                subBuilder = payload_.toBuilder();
-              }
-              payload_ = input.readMessage(io.grpc.benchmarks.proto.Messages.Payload.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(payload_);
-                payload_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingOutputCallResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingOutputCallResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse.class, io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse.Builder.class);
-    }
-
-    public static final int PAYLOAD_FIELD_NUMBER = 1;
-    private io.grpc.benchmarks.proto.Messages.Payload payload_;
-    /**
-     * <pre>
-     * Payload to increase response size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public boolean hasPayload() {
-      return payload_ != null;
-    }
-    /**
-     * <pre>
-     * Payload to increase response size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.Payload getPayload() {
-      return payload_ == null ? io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-    }
-    /**
-     * <pre>
-     * Payload to increase response size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-      return getPayload();
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (payload_ != null) {
-        output.writeMessage(1, getPayload());
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (payload_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, getPayload());
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse other = (io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse) obj;
-
-      boolean result = true;
-      result = result && (hasPayload() == other.hasPayload());
-      if (hasPayload()) {
-        result = result && getPayload()
-            .equals(other.getPayload());
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      if (hasPayload()) {
-        hash = (37 * hash) + PAYLOAD_FIELD_NUMBER;
-        hash = (53 * hash) + getPayload().hashCode();
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Server-streaming response, as configured by the request and parameters.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.StreamingOutputCallResponse}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.StreamingOutputCallResponse)
-        io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponseOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingOutputCallResponse_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingOutputCallResponse_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse.class, io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_StreamingOutputCallResponse_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse build() {
-        io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse buildPartial() {
-        io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse result = new io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse(this);
-        if (payloadBuilder_ == null) {
-          result.payload_ = payload_;
-        } else {
-          result.payload_ = payloadBuilder_.build();
-        }
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse) {
-          return mergeFrom((io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse other) {
-        if (other == io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse.getDefaultInstance()) return this;
-        if (other.hasPayload()) {
-          mergePayload(other.getPayload());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private io.grpc.benchmarks.proto.Messages.Payload payload_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder> payloadBuilder_;
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public boolean hasPayload() {
-        return payloadBuilder_ != null || payload_ != null;
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.Payload getPayload() {
-        if (payloadBuilder_ == null) {
-          return payload_ == null ? io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-        } else {
-          return payloadBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder setPayload(io.grpc.benchmarks.proto.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payload_ = value;
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder setPayload(
-          io.grpc.benchmarks.proto.Messages.Payload.Builder builderForValue) {
-        if (payloadBuilder_ == null) {
-          payload_ = builderForValue.build();
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder mergePayload(io.grpc.benchmarks.proto.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (payload_ != null) {
-            payload_ =
-              io.grpc.benchmarks.proto.Messages.Payload.newBuilder(payload_).mergeFrom(value).buildPartial();
-          } else {
-            payload_ = value;
-          }
-          onChanged();
-        } else {
-          payloadBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder clearPayload() {
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-          onChanged();
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.Payload.Builder getPayloadBuilder() {
-        
-        onChanged();
-        return getPayloadFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-        if (payloadBuilder_ != null) {
-          return payloadBuilder_.getMessageOrBuilder();
-        } else {
-          return payload_ == null ?
-              io.grpc.benchmarks.proto.Messages.Payload.getDefaultInstance() : payload_;
-        }
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder> 
-          getPayloadFieldBuilder() {
-        if (payloadBuilder_ == null) {
-          payloadBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Messages.Payload, io.grpc.benchmarks.proto.Messages.Payload.Builder, io.grpc.benchmarks.proto.Messages.PayloadOrBuilder>(
-                  getPayload(),
-                  getParentForChildren(),
-                  isClean());
-          payload_ = null;
-        }
-        return payloadBuilder_;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.StreamingOutputCallResponse)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.StreamingOutputCallResponse)
-    private static final io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse();
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<StreamingOutputCallResponse>
-        PARSER = new com.google.protobuf.AbstractParser<StreamingOutputCallResponse>() {
-      public StreamingOutputCallResponse parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new StreamingOutputCallResponse(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<StreamingOutputCallResponse> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<StreamingOutputCallResponse> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Messages.StreamingOutputCallResponse getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ReconnectInfoOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ReconnectInfo)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>bool passed = 1;</code>
-     */
-    boolean getPassed();
-
-    /**
-     * <code>repeated int32 backoff_ms = 2;</code>
-     */
-    java.util.List<java.lang.Integer> getBackoffMsList();
-    /**
-     * <code>repeated int32 backoff_ms = 2;</code>
-     */
-    int getBackoffMsCount();
-    /**
-     * <code>repeated int32 backoff_ms = 2;</code>
-     */
-    int getBackoffMs(int index);
-  }
-  /**
-   * <pre>
-   * For reconnect interop test only.
-   * Server tells client whether its reconnects are following the spec and the
-   * reconnect backoffs it saw.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.ReconnectInfo}
-   */
-  public  static final class ReconnectInfo extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ReconnectInfo)
-      ReconnectInfoOrBuilder {
-    // Use ReconnectInfo.newBuilder() to construct.
-    private ReconnectInfo(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ReconnectInfo() {
-      passed_ = false;
-      backoffMs_ = java.util.Collections.emptyList();
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ReconnectInfo(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              passed_ = input.readBool();
-              break;
-            }
-            case 16: {
-              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
-                backoffMs_ = new java.util.ArrayList<java.lang.Integer>();
-                mutable_bitField0_ |= 0x00000002;
-              }
-              backoffMs_.add(input.readInt32());
-              break;
-            }
-            case 18: {
-              int length = input.readRawVarint32();
-              int limit = input.pushLimit(length);
-              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) {
-                backoffMs_ = new java.util.ArrayList<java.lang.Integer>();
-                mutable_bitField0_ |= 0x00000002;
-              }
-              while (input.getBytesUntilLimit() > 0) {
-                backoffMs_.add(input.readInt32());
-              }
-              input.popLimit(limit);
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
-          backoffMs_ = java.util.Collections.unmodifiableList(backoffMs_);
-        }
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_ReconnectInfo_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_ReconnectInfo_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Messages.ReconnectInfo.class, io.grpc.benchmarks.proto.Messages.ReconnectInfo.Builder.class);
-    }
-
-    private int bitField0_;
-    public static final int PASSED_FIELD_NUMBER = 1;
-    private boolean passed_;
-    /**
-     * <code>bool passed = 1;</code>
-     */
-    public boolean getPassed() {
-      return passed_;
-    }
-
-    public static final int BACKOFF_MS_FIELD_NUMBER = 2;
-    private java.util.List<java.lang.Integer> backoffMs_;
-    /**
-     * <code>repeated int32 backoff_ms = 2;</code>
-     */
-    public java.util.List<java.lang.Integer>
-        getBackoffMsList() {
-      return backoffMs_;
-    }
-    /**
-     * <code>repeated int32 backoff_ms = 2;</code>
-     */
-    public int getBackoffMsCount() {
-      return backoffMs_.size();
-    }
-    /**
-     * <code>repeated int32 backoff_ms = 2;</code>
-     */
-    public int getBackoffMs(int index) {
-      return backoffMs_.get(index);
-    }
-    private int backoffMsMemoizedSerializedSize = -1;
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      getSerializedSize();
-      if (passed_ != false) {
-        output.writeBool(1, passed_);
-      }
-      if (getBackoffMsList().size() > 0) {
-        output.writeUInt32NoTag(18);
-        output.writeUInt32NoTag(backoffMsMemoizedSerializedSize);
-      }
-      for (int i = 0; i < backoffMs_.size(); i++) {
-        output.writeInt32NoTag(backoffMs_.get(i));
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (passed_ != false) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeBoolSize(1, passed_);
-      }
-      {
-        int dataSize = 0;
-        for (int i = 0; i < backoffMs_.size(); i++) {
-          dataSize += com.google.protobuf.CodedOutputStream
-            .computeInt32SizeNoTag(backoffMs_.get(i));
-        }
-        size += dataSize;
-        if (!getBackoffMsList().isEmpty()) {
-          size += 1;
-          size += com.google.protobuf.CodedOutputStream
-              .computeInt32SizeNoTag(dataSize);
-        }
-        backoffMsMemoizedSerializedSize = dataSize;
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Messages.ReconnectInfo)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Messages.ReconnectInfo other = (io.grpc.benchmarks.proto.Messages.ReconnectInfo) obj;
-
-      boolean result = true;
-      result = result && (getPassed()
-          == other.getPassed());
-      result = result && getBackoffMsList()
-          .equals(other.getBackoffMsList());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + PASSED_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
-          getPassed());
-      if (getBackoffMsCount() > 0) {
-        hash = (37 * hash) + BACKOFF_MS_FIELD_NUMBER;
-        hash = (53 * hash) + getBackoffMsList().hashCode();
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.ReconnectInfo parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ReconnectInfo parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ReconnectInfo parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ReconnectInfo parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ReconnectInfo parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ReconnectInfo parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ReconnectInfo parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ReconnectInfo parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ReconnectInfo parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Messages.ReconnectInfo parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Messages.ReconnectInfo prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * For reconnect interop test only.
-     * Server tells client whether its reconnects are following the spec and the
-     * reconnect backoffs it saw.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.ReconnectInfo}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ReconnectInfo)
-        io.grpc.benchmarks.proto.Messages.ReconnectInfoOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_ReconnectInfo_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_ReconnectInfo_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Messages.ReconnectInfo.class, io.grpc.benchmarks.proto.Messages.ReconnectInfo.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Messages.ReconnectInfo.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        passed_ = false;
-
-        backoffMs_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000002);
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Messages.internal_static_grpc_testing_ReconnectInfo_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.ReconnectInfo getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Messages.ReconnectInfo.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Messages.ReconnectInfo build() {
-        io.grpc.benchmarks.proto.Messages.ReconnectInfo result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Messages.ReconnectInfo buildPartial() {
-        io.grpc.benchmarks.proto.Messages.ReconnectInfo result = new io.grpc.benchmarks.proto.Messages.ReconnectInfo(this);
-        int from_bitField0_ = bitField0_;
-        int to_bitField0_ = 0;
-        result.passed_ = passed_;
-        if (((bitField0_ & 0x00000002) == 0x00000002)) {
-          backoffMs_ = java.util.Collections.unmodifiableList(backoffMs_);
-          bitField0_ = (bitField0_ & ~0x00000002);
-        }
-        result.backoffMs_ = backoffMs_;
-        result.bitField0_ = to_bitField0_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Messages.ReconnectInfo) {
-          return mergeFrom((io.grpc.benchmarks.proto.Messages.ReconnectInfo)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Messages.ReconnectInfo other) {
-        if (other == io.grpc.benchmarks.proto.Messages.ReconnectInfo.getDefaultInstance()) return this;
-        if (other.getPassed() != false) {
-          setPassed(other.getPassed());
-        }
-        if (!other.backoffMs_.isEmpty()) {
-          if (backoffMs_.isEmpty()) {
-            backoffMs_ = other.backoffMs_;
-            bitField0_ = (bitField0_ & ~0x00000002);
-          } else {
-            ensureBackoffMsIsMutable();
-            backoffMs_.addAll(other.backoffMs_);
-          }
-          onChanged();
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Messages.ReconnectInfo parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Messages.ReconnectInfo) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      private int bitField0_;
-
-      private boolean passed_ ;
-      /**
-       * <code>bool passed = 1;</code>
-       */
-      public boolean getPassed() {
-        return passed_;
-      }
-      /**
-       * <code>bool passed = 1;</code>
-       */
-      public Builder setPassed(boolean value) {
-        
-        passed_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>bool passed = 1;</code>
-       */
-      public Builder clearPassed() {
-        
-        passed_ = false;
-        onChanged();
-        return this;
-      }
-
-      private java.util.List<java.lang.Integer> backoffMs_ = java.util.Collections.emptyList();
-      private void ensureBackoffMsIsMutable() {
-        if (!((bitField0_ & 0x00000002) == 0x00000002)) {
-          backoffMs_ = new java.util.ArrayList<java.lang.Integer>(backoffMs_);
-          bitField0_ |= 0x00000002;
-         }
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public java.util.List<java.lang.Integer>
-          getBackoffMsList() {
-        return java.util.Collections.unmodifiableList(backoffMs_);
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public int getBackoffMsCount() {
-        return backoffMs_.size();
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public int getBackoffMs(int index) {
-        return backoffMs_.get(index);
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public Builder setBackoffMs(
-          int index, int value) {
-        ensureBackoffMsIsMutable();
-        backoffMs_.set(index, value);
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public Builder addBackoffMs(int value) {
-        ensureBackoffMsIsMutable();
-        backoffMs_.add(value);
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public Builder addAllBackoffMs(
-          java.lang.Iterable<? extends java.lang.Integer> values) {
-        ensureBackoffMsIsMutable();
-        com.google.protobuf.AbstractMessageLite.Builder.addAll(
-            values, backoffMs_);
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public Builder clearBackoffMs() {
-        backoffMs_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000002);
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ReconnectInfo)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ReconnectInfo)
-    private static final io.grpc.benchmarks.proto.Messages.ReconnectInfo DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Messages.ReconnectInfo();
-    }
-
-    public static io.grpc.benchmarks.proto.Messages.ReconnectInfo getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ReconnectInfo>
-        PARSER = new com.google.protobuf.AbstractParser<ReconnectInfo>() {
-      public ReconnectInfo parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ReconnectInfo(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ReconnectInfo> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ReconnectInfo> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Messages.ReconnectInfo getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_Payload_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_Payload_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_EchoStatus_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_EchoStatus_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_SimpleRequest_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_SimpleRequest_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_SimpleResponse_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_SimpleResponse_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_StreamingInputCallRequest_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_StreamingInputCallRequest_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_StreamingInputCallResponse_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_StreamingInputCallResponse_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ResponseParameters_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ResponseParameters_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_StreamingOutputCallRequest_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_StreamingOutputCallRequest_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_StreamingOutputCallResponse_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_StreamingOutputCallResponse_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ReconnectInfo_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ReconnectInfo_fieldAccessorTable;
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n\016messages.proto\022\014grpc.testing\"@\n\007Payloa" +
-      "d\022\'\n\004type\030\001 \001(\0162\031.grpc.testing.PayloadTy" +
-      "pe\022\014\n\004body\030\002 \001(\014\"+\n\nEchoStatus\022\014\n\004code\030\001" +
-      " \001(\005\022\017\n\007message\030\002 \001(\t\"\241\002\n\rSimpleRequest\022" +
-      "0\n\rresponse_type\030\001 \001(\0162\031.grpc.testing.Pa" +
-      "yloadType\022\025\n\rresponse_size\030\002 \001(\005\022&\n\007payl" +
-      "oad\030\003 \001(\0132\025.grpc.testing.Payload\022\025\n\rfill" +
-      "_username\030\004 \001(\010\022\030\n\020fill_oauth_scope\030\005 \001(" +
-      "\010\022;\n\024response_compression\030\006 \001(\0162\035.grpc.t" +
-      "esting.CompressionType\0221\n\017response_statu",
-      "s\030\007 \001(\0132\030.grpc.testing.EchoStatus\"_\n\016Sim" +
-      "pleResponse\022&\n\007payload\030\001 \001(\0132\025.grpc.test" +
-      "ing.Payload\022\020\n\010username\030\002 \001(\t\022\023\n\013oauth_s" +
-      "cope\030\003 \001(\t\"C\n\031StreamingInputCallRequest\022" +
-      "&\n\007payload\030\001 \001(\0132\025.grpc.testing.Payload\"" +
-      "=\n\032StreamingInputCallResponse\022\037\n\027aggrega" +
-      "ted_payload_size\030\001 \001(\005\"7\n\022ResponseParame" +
-      "ters\022\014\n\004size\030\001 \001(\005\022\023\n\013interval_us\030\002 \001(\005\"" +
-      "\245\002\n\032StreamingOutputCallRequest\0220\n\rrespon" +
-      "se_type\030\001 \001(\0162\031.grpc.testing.PayloadType",
-      "\022=\n\023response_parameters\030\002 \003(\0132 .grpc.tes" +
-      "ting.ResponseParameters\022&\n\007payload\030\003 \001(\013" +
-      "2\025.grpc.testing.Payload\022;\n\024response_comp" +
-      "ression\030\006 \001(\0162\035.grpc.testing.Compression" +
-      "Type\0221\n\017response_status\030\007 \001(\0132\030.grpc.tes" +
-      "ting.EchoStatus\"E\n\033StreamingOutputCallRe" +
-      "sponse\022&\n\007payload\030\001 \001(\0132\025.grpc.testing.P" +
-      "ayload\"3\n\rReconnectInfo\022\016\n\006passed\030\001 \001(\010\022" +
-      "\022\n\nbackoff_ms\030\002 \003(\005*?\n\013PayloadType\022\020\n\014CO" +
-      "MPRESSABLE\020\000\022\022\n\016UNCOMPRESSABLE\020\001\022\n\n\006RAND",
-      "OM\020\002*2\n\017CompressionType\022\010\n\004NONE\020\000\022\010\n\004GZI" +
-      "P\020\001\022\013\n\007DEFLATE\020\002B$\n\030io.grpc.benchmarks.p" +
-      "rotoB\010Messagesb\006proto3"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-        }, assigner);
-    internal_static_grpc_testing_Payload_descriptor =
-      getDescriptor().getMessageTypes().get(0);
-    internal_static_grpc_testing_Payload_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_Payload_descriptor,
-        new java.lang.String[] { "Type", "Body", });
-    internal_static_grpc_testing_EchoStatus_descriptor =
-      getDescriptor().getMessageTypes().get(1);
-    internal_static_grpc_testing_EchoStatus_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_EchoStatus_descriptor,
-        new java.lang.String[] { "Code", "Message", });
-    internal_static_grpc_testing_SimpleRequest_descriptor =
-      getDescriptor().getMessageTypes().get(2);
-    internal_static_grpc_testing_SimpleRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_SimpleRequest_descriptor,
-        new java.lang.String[] { "ResponseType", "ResponseSize", "Payload", "FillUsername", "FillOauthScope", "ResponseCompression", "ResponseStatus", });
-    internal_static_grpc_testing_SimpleResponse_descriptor =
-      getDescriptor().getMessageTypes().get(3);
-    internal_static_grpc_testing_SimpleResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_SimpleResponse_descriptor,
-        new java.lang.String[] { "Payload", "Username", "OauthScope", });
-    internal_static_grpc_testing_StreamingInputCallRequest_descriptor =
-      getDescriptor().getMessageTypes().get(4);
-    internal_static_grpc_testing_StreamingInputCallRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_StreamingInputCallRequest_descriptor,
-        new java.lang.String[] { "Payload", });
-    internal_static_grpc_testing_StreamingInputCallResponse_descriptor =
-      getDescriptor().getMessageTypes().get(5);
-    internal_static_grpc_testing_StreamingInputCallResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_StreamingInputCallResponse_descriptor,
-        new java.lang.String[] { "AggregatedPayloadSize", });
-    internal_static_grpc_testing_ResponseParameters_descriptor =
-      getDescriptor().getMessageTypes().get(6);
-    internal_static_grpc_testing_ResponseParameters_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ResponseParameters_descriptor,
-        new java.lang.String[] { "Size", "IntervalUs", });
-    internal_static_grpc_testing_StreamingOutputCallRequest_descriptor =
-      getDescriptor().getMessageTypes().get(7);
-    internal_static_grpc_testing_StreamingOutputCallRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_StreamingOutputCallRequest_descriptor,
-        new java.lang.String[] { "ResponseType", "ResponseParameters", "Payload", "ResponseCompression", "ResponseStatus", });
-    internal_static_grpc_testing_StreamingOutputCallResponse_descriptor =
-      getDescriptor().getMessageTypes().get(8);
-    internal_static_grpc_testing_StreamingOutputCallResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_StreamingOutputCallResponse_descriptor,
-        new java.lang.String[] { "Payload", });
-    internal_static_grpc_testing_ReconnectInfo_descriptor =
-      getDescriptor().getMessageTypes().get(9);
-    internal_static_grpc_testing_ReconnectInfo_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ReconnectInfo_descriptor,
-        new java.lang.String[] { "Passed", "BackoffMs", });
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Payloads.java b/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Payloads.java
deleted file mode 100644
index 129f2570092..00000000000
--- a/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Payloads.java
+++ /dev/null
@@ -1,2495 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: payloads.proto
-
-package io.grpc.benchmarks.proto;
-
-public final class Payloads {
-  private Payloads() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  public interface ByteBufferParamsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ByteBufferParams)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>int32 req_size = 1;</code>
-     */
-    int getReqSize();
-
-    /**
-     * <code>int32 resp_size = 2;</code>
-     */
-    int getRespSize();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.ByteBufferParams}
-   */
-  public  static final class ByteBufferParams extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ByteBufferParams)
-      ByteBufferParamsOrBuilder {
-    // Use ByteBufferParams.newBuilder() to construct.
-    private ByteBufferParams(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ByteBufferParams() {
-      reqSize_ = 0;
-      respSize_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ByteBufferParams(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              reqSize_ = input.readInt32();
-              break;
-            }
-            case 16: {
-
-              respSize_ = input.readInt32();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_ByteBufferParams_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_ByteBufferParams_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Payloads.ByteBufferParams.class, io.grpc.benchmarks.proto.Payloads.ByteBufferParams.Builder.class);
-    }
-
-    public static final int REQ_SIZE_FIELD_NUMBER = 1;
-    private int reqSize_;
-    /**
-     * <code>int32 req_size = 1;</code>
-     */
-    public int getReqSize() {
-      return reqSize_;
-    }
-
-    public static final int RESP_SIZE_FIELD_NUMBER = 2;
-    private int respSize_;
-    /**
-     * <code>int32 resp_size = 2;</code>
-     */
-    public int getRespSize() {
-      return respSize_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (reqSize_ != 0) {
-        output.writeInt32(1, reqSize_);
-      }
-      if (respSize_ != 0) {
-        output.writeInt32(2, respSize_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (reqSize_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(1, reqSize_);
-      }
-      if (respSize_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(2, respSize_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Payloads.ByteBufferParams)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Payloads.ByteBufferParams other = (io.grpc.benchmarks.proto.Payloads.ByteBufferParams) obj;
-
-      boolean result = true;
-      result = result && (getReqSize()
-          == other.getReqSize());
-      result = result && (getRespSize()
-          == other.getRespSize());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + REQ_SIZE_FIELD_NUMBER;
-      hash = (53 * hash) + getReqSize();
-      hash = (37 * hash) + RESP_SIZE_FIELD_NUMBER;
-      hash = (53 * hash) + getRespSize();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Payloads.ByteBufferParams parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ByteBufferParams parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ByteBufferParams parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ByteBufferParams parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ByteBufferParams parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ByteBufferParams parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ByteBufferParams parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ByteBufferParams parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ByteBufferParams parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ByteBufferParams parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Payloads.ByteBufferParams prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.ByteBufferParams}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ByteBufferParams)
-        io.grpc.benchmarks.proto.Payloads.ByteBufferParamsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_ByteBufferParams_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_ByteBufferParams_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Payloads.ByteBufferParams.class, io.grpc.benchmarks.proto.Payloads.ByteBufferParams.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Payloads.ByteBufferParams.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        reqSize_ = 0;
-
-        respSize_ = 0;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_ByteBufferParams_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Payloads.ByteBufferParams getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Payloads.ByteBufferParams.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Payloads.ByteBufferParams build() {
-        io.grpc.benchmarks.proto.Payloads.ByteBufferParams result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Payloads.ByteBufferParams buildPartial() {
-        io.grpc.benchmarks.proto.Payloads.ByteBufferParams result = new io.grpc.benchmarks.proto.Payloads.ByteBufferParams(this);
-        result.reqSize_ = reqSize_;
-        result.respSize_ = respSize_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Payloads.ByteBufferParams) {
-          return mergeFrom((io.grpc.benchmarks.proto.Payloads.ByteBufferParams)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Payloads.ByteBufferParams other) {
-        if (other == io.grpc.benchmarks.proto.Payloads.ByteBufferParams.getDefaultInstance()) return this;
-        if (other.getReqSize() != 0) {
-          setReqSize(other.getReqSize());
-        }
-        if (other.getRespSize() != 0) {
-          setRespSize(other.getRespSize());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Payloads.ByteBufferParams parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Payloads.ByteBufferParams) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int reqSize_ ;
-      /**
-       * <code>int32 req_size = 1;</code>
-       */
-      public int getReqSize() {
-        return reqSize_;
-      }
-      /**
-       * <code>int32 req_size = 1;</code>
-       */
-      public Builder setReqSize(int value) {
-        
-        reqSize_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>int32 req_size = 1;</code>
-       */
-      public Builder clearReqSize() {
-        
-        reqSize_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private int respSize_ ;
-      /**
-       * <code>int32 resp_size = 2;</code>
-       */
-      public int getRespSize() {
-        return respSize_;
-      }
-      /**
-       * <code>int32 resp_size = 2;</code>
-       */
-      public Builder setRespSize(int value) {
-        
-        respSize_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>int32 resp_size = 2;</code>
-       */
-      public Builder clearRespSize() {
-        
-        respSize_ = 0;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ByteBufferParams)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ByteBufferParams)
-    private static final io.grpc.benchmarks.proto.Payloads.ByteBufferParams DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Payloads.ByteBufferParams();
-    }
-
-    public static io.grpc.benchmarks.proto.Payloads.ByteBufferParams getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ByteBufferParams>
-        PARSER = new com.google.protobuf.AbstractParser<ByteBufferParams>() {
-      public ByteBufferParams parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ByteBufferParams(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ByteBufferParams> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ByteBufferParams> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Payloads.ByteBufferParams getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface SimpleProtoParamsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.SimpleProtoParams)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>int32 req_size = 1;</code>
-     */
-    int getReqSize();
-
-    /**
-     * <code>int32 resp_size = 2;</code>
-     */
-    int getRespSize();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.SimpleProtoParams}
-   */
-  public  static final class SimpleProtoParams extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.SimpleProtoParams)
-      SimpleProtoParamsOrBuilder {
-    // Use SimpleProtoParams.newBuilder() to construct.
-    private SimpleProtoParams(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private SimpleProtoParams() {
-      reqSize_ = 0;
-      respSize_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private SimpleProtoParams(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              reqSize_ = input.readInt32();
-              break;
-            }
-            case 16: {
-
-              respSize_ = input.readInt32();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_SimpleProtoParams_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_SimpleProtoParams_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.class, io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.Builder.class);
-    }
-
-    public static final int REQ_SIZE_FIELD_NUMBER = 1;
-    private int reqSize_;
-    /**
-     * <code>int32 req_size = 1;</code>
-     */
-    public int getReqSize() {
-      return reqSize_;
-    }
-
-    public static final int RESP_SIZE_FIELD_NUMBER = 2;
-    private int respSize_;
-    /**
-     * <code>int32 resp_size = 2;</code>
-     */
-    public int getRespSize() {
-      return respSize_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (reqSize_ != 0) {
-        output.writeInt32(1, reqSize_);
-      }
-      if (respSize_ != 0) {
-        output.writeInt32(2, respSize_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (reqSize_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(1, reqSize_);
-      }
-      if (respSize_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(2, respSize_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Payloads.SimpleProtoParams)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Payloads.SimpleProtoParams other = (io.grpc.benchmarks.proto.Payloads.SimpleProtoParams) obj;
-
-      boolean result = true;
-      result = result && (getReqSize()
-          == other.getReqSize());
-      result = result && (getRespSize()
-          == other.getRespSize());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + REQ_SIZE_FIELD_NUMBER;
-      hash = (53 * hash) + getReqSize();
-      hash = (37 * hash) + RESP_SIZE_FIELD_NUMBER;
-      hash = (53 * hash) + getRespSize();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Payloads.SimpleProtoParams parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.SimpleProtoParams parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.SimpleProtoParams parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.SimpleProtoParams parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.SimpleProtoParams parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.SimpleProtoParams parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.SimpleProtoParams parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.SimpleProtoParams parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.SimpleProtoParams parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.SimpleProtoParams parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Payloads.SimpleProtoParams prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.SimpleProtoParams}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.SimpleProtoParams)
-        io.grpc.benchmarks.proto.Payloads.SimpleProtoParamsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_SimpleProtoParams_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_SimpleProtoParams_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.class, io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        reqSize_ = 0;
-
-        respSize_ = 0;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_SimpleProtoParams_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Payloads.SimpleProtoParams getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Payloads.SimpleProtoParams build() {
-        io.grpc.benchmarks.proto.Payloads.SimpleProtoParams result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Payloads.SimpleProtoParams buildPartial() {
-        io.grpc.benchmarks.proto.Payloads.SimpleProtoParams result = new io.grpc.benchmarks.proto.Payloads.SimpleProtoParams(this);
-        result.reqSize_ = reqSize_;
-        result.respSize_ = respSize_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Payloads.SimpleProtoParams) {
-          return mergeFrom((io.grpc.benchmarks.proto.Payloads.SimpleProtoParams)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Payloads.SimpleProtoParams other) {
-        if (other == io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.getDefaultInstance()) return this;
-        if (other.getReqSize() != 0) {
-          setReqSize(other.getReqSize());
-        }
-        if (other.getRespSize() != 0) {
-          setRespSize(other.getRespSize());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Payloads.SimpleProtoParams parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Payloads.SimpleProtoParams) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int reqSize_ ;
-      /**
-       * <code>int32 req_size = 1;</code>
-       */
-      public int getReqSize() {
-        return reqSize_;
-      }
-      /**
-       * <code>int32 req_size = 1;</code>
-       */
-      public Builder setReqSize(int value) {
-        
-        reqSize_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>int32 req_size = 1;</code>
-       */
-      public Builder clearReqSize() {
-        
-        reqSize_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private int respSize_ ;
-      /**
-       * <code>int32 resp_size = 2;</code>
-       */
-      public int getRespSize() {
-        return respSize_;
-      }
-      /**
-       * <code>int32 resp_size = 2;</code>
-       */
-      public Builder setRespSize(int value) {
-        
-        respSize_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>int32 resp_size = 2;</code>
-       */
-      public Builder clearRespSize() {
-        
-        respSize_ = 0;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.SimpleProtoParams)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.SimpleProtoParams)
-    private static final io.grpc.benchmarks.proto.Payloads.SimpleProtoParams DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Payloads.SimpleProtoParams();
-    }
-
-    public static io.grpc.benchmarks.proto.Payloads.SimpleProtoParams getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<SimpleProtoParams>
-        PARSER = new com.google.protobuf.AbstractParser<SimpleProtoParams>() {
-      public SimpleProtoParams parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new SimpleProtoParams(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<SimpleProtoParams> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<SimpleProtoParams> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Payloads.SimpleProtoParams getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ComplexProtoParamsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ComplexProtoParams)
-      com.google.protobuf.MessageOrBuilder {
-  }
-  /**
-   * <pre>
-   * TODO (vpai): Fill this in once the details of complex, representative
-   *              protos are decided
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.ComplexProtoParams}
-   */
-  public  static final class ComplexProtoParams extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ComplexProtoParams)
-      ComplexProtoParamsOrBuilder {
-    // Use ComplexProtoParams.newBuilder() to construct.
-    private ComplexProtoParams(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ComplexProtoParams() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ComplexProtoParams(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_ComplexProtoParams_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_ComplexProtoParams_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.class, io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.Builder.class);
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Payloads.ComplexProtoParams)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Payloads.ComplexProtoParams other = (io.grpc.benchmarks.proto.Payloads.ComplexProtoParams) obj;
-
-      boolean result = true;
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Payloads.ComplexProtoParams parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ComplexProtoParams parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ComplexProtoParams parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ComplexProtoParams parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ComplexProtoParams parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ComplexProtoParams parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ComplexProtoParams parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ComplexProtoParams parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ComplexProtoParams parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.ComplexProtoParams parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Payloads.ComplexProtoParams prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * TODO (vpai): Fill this in once the details of complex, representative
-     *              protos are decided
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.ComplexProtoParams}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ComplexProtoParams)
-        io.grpc.benchmarks.proto.Payloads.ComplexProtoParamsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_ComplexProtoParams_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_ComplexProtoParams_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.class, io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_ComplexProtoParams_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Payloads.ComplexProtoParams getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Payloads.ComplexProtoParams build() {
-        io.grpc.benchmarks.proto.Payloads.ComplexProtoParams result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Payloads.ComplexProtoParams buildPartial() {
-        io.grpc.benchmarks.proto.Payloads.ComplexProtoParams result = new io.grpc.benchmarks.proto.Payloads.ComplexProtoParams(this);
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Payloads.ComplexProtoParams) {
-          return mergeFrom((io.grpc.benchmarks.proto.Payloads.ComplexProtoParams)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Payloads.ComplexProtoParams other) {
-        if (other == io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.getDefaultInstance()) return this;
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Payloads.ComplexProtoParams parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Payloads.ComplexProtoParams) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ComplexProtoParams)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ComplexProtoParams)
-    private static final io.grpc.benchmarks.proto.Payloads.ComplexProtoParams DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Payloads.ComplexProtoParams();
-    }
-
-    public static io.grpc.benchmarks.proto.Payloads.ComplexProtoParams getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ComplexProtoParams>
-        PARSER = new com.google.protobuf.AbstractParser<ComplexProtoParams>() {
-      public ComplexProtoParams parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ComplexProtoParams(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ComplexProtoParams> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ComplexProtoParams> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Payloads.ComplexProtoParams getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface PayloadConfigOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.PayloadConfig)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>.grpc.testing.ByteBufferParams bytebuf_params = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Payloads.ByteBufferParams getBytebufParams();
-    /**
-     * <code>.grpc.testing.ByteBufferParams bytebuf_params = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Payloads.ByteBufferParamsOrBuilder getBytebufParamsOrBuilder();
-
-    /**
-     * <code>.grpc.testing.SimpleProtoParams simple_params = 2;</code>
-     */
-    io.grpc.benchmarks.proto.Payloads.SimpleProtoParams getSimpleParams();
-    /**
-     * <code>.grpc.testing.SimpleProtoParams simple_params = 2;</code>
-     */
-    io.grpc.benchmarks.proto.Payloads.SimpleProtoParamsOrBuilder getSimpleParamsOrBuilder();
-
-    /**
-     * <code>.grpc.testing.ComplexProtoParams complex_params = 3;</code>
-     */
-    io.grpc.benchmarks.proto.Payloads.ComplexProtoParams getComplexParams();
-    /**
-     * <code>.grpc.testing.ComplexProtoParams complex_params = 3;</code>
-     */
-    io.grpc.benchmarks.proto.Payloads.ComplexProtoParamsOrBuilder getComplexParamsOrBuilder();
-
-    public io.grpc.benchmarks.proto.Payloads.PayloadConfig.PayloadCase getPayloadCase();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.PayloadConfig}
-   */
-  public  static final class PayloadConfig extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.PayloadConfig)
-      PayloadConfigOrBuilder {
-    // Use PayloadConfig.newBuilder() to construct.
-    private PayloadConfig(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private PayloadConfig() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private PayloadConfig(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              io.grpc.benchmarks.proto.Payloads.ByteBufferParams.Builder subBuilder = null;
-              if (payloadCase_ == 1) {
-                subBuilder = ((io.grpc.benchmarks.proto.Payloads.ByteBufferParams) payload_).toBuilder();
-              }
-              payload_ =
-                  input.readMessage(io.grpc.benchmarks.proto.Payloads.ByteBufferParams.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom((io.grpc.benchmarks.proto.Payloads.ByteBufferParams) payload_);
-                payload_ = subBuilder.buildPartial();
-              }
-              payloadCase_ = 1;
-              break;
-            }
-            case 18: {
-              io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.Builder subBuilder = null;
-              if (payloadCase_ == 2) {
-                subBuilder = ((io.grpc.benchmarks.proto.Payloads.SimpleProtoParams) payload_).toBuilder();
-              }
-              payload_ =
-                  input.readMessage(io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom((io.grpc.benchmarks.proto.Payloads.SimpleProtoParams) payload_);
-                payload_ = subBuilder.buildPartial();
-              }
-              payloadCase_ = 2;
-              break;
-            }
-            case 26: {
-              io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.Builder subBuilder = null;
-              if (payloadCase_ == 3) {
-                subBuilder = ((io.grpc.benchmarks.proto.Payloads.ComplexProtoParams) payload_).toBuilder();
-              }
-              payload_ =
-                  input.readMessage(io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom((io.grpc.benchmarks.proto.Payloads.ComplexProtoParams) payload_);
-                payload_ = subBuilder.buildPartial();
-              }
-              payloadCase_ = 3;
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_PayloadConfig_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_PayloadConfig_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Payloads.PayloadConfig.class, io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder.class);
-    }
-
-    private int payloadCase_ = 0;
-    private java.lang.Object payload_;
-    public enum PayloadCase
-        implements com.google.protobuf.Internal.EnumLite {
-      BYTEBUF_PARAMS(1),
-      SIMPLE_PARAMS(2),
-      COMPLEX_PARAMS(3),
-      PAYLOAD_NOT_SET(0);
-      private final int value;
-      private PayloadCase(int value) {
-        this.value = value;
-      }
-      /**
-       * @deprecated Use {@link #forNumber(int)} instead.
-       */
-      @java.lang.Deprecated
-      public static PayloadCase valueOf(int value) {
-        return forNumber(value);
-      }
-
-      public static PayloadCase forNumber(int value) {
-        switch (value) {
-          case 1: return BYTEBUF_PARAMS;
-          case 2: return SIMPLE_PARAMS;
-          case 3: return COMPLEX_PARAMS;
-          case 0: return PAYLOAD_NOT_SET;
-          default: return null;
-        }
-      }
-      public int getNumber() {
-        return this.value;
-      }
-    };
-
-    public PayloadCase
-    getPayloadCase() {
-      return PayloadCase.forNumber(
-          payloadCase_);
-    }
-
-    public static final int BYTEBUF_PARAMS_FIELD_NUMBER = 1;
-    /**
-     * <code>.grpc.testing.ByteBufferParams bytebuf_params = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Payloads.ByteBufferParams getBytebufParams() {
-      if (payloadCase_ == 1) {
-         return (io.grpc.benchmarks.proto.Payloads.ByteBufferParams) payload_;
-      }
-      return io.grpc.benchmarks.proto.Payloads.ByteBufferParams.getDefaultInstance();
-    }
-    /**
-     * <code>.grpc.testing.ByteBufferParams bytebuf_params = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Payloads.ByteBufferParamsOrBuilder getBytebufParamsOrBuilder() {
-      if (payloadCase_ == 1) {
-         return (io.grpc.benchmarks.proto.Payloads.ByteBufferParams) payload_;
-      }
-      return io.grpc.benchmarks.proto.Payloads.ByteBufferParams.getDefaultInstance();
-    }
-
-    public static final int SIMPLE_PARAMS_FIELD_NUMBER = 2;
-    /**
-     * <code>.grpc.testing.SimpleProtoParams simple_params = 2;</code>
-     */
-    public io.grpc.benchmarks.proto.Payloads.SimpleProtoParams getSimpleParams() {
-      if (payloadCase_ == 2) {
-         return (io.grpc.benchmarks.proto.Payloads.SimpleProtoParams) payload_;
-      }
-      return io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.getDefaultInstance();
-    }
-    /**
-     * <code>.grpc.testing.SimpleProtoParams simple_params = 2;</code>
-     */
-    public io.grpc.benchmarks.proto.Payloads.SimpleProtoParamsOrBuilder getSimpleParamsOrBuilder() {
-      if (payloadCase_ == 2) {
-         return (io.grpc.benchmarks.proto.Payloads.SimpleProtoParams) payload_;
-      }
-      return io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.getDefaultInstance();
-    }
-
-    public static final int COMPLEX_PARAMS_FIELD_NUMBER = 3;
-    /**
-     * <code>.grpc.testing.ComplexProtoParams complex_params = 3;</code>
-     */
-    public io.grpc.benchmarks.proto.Payloads.ComplexProtoParams getComplexParams() {
-      if (payloadCase_ == 3) {
-         return (io.grpc.benchmarks.proto.Payloads.ComplexProtoParams) payload_;
-      }
-      return io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.getDefaultInstance();
-    }
-    /**
-     * <code>.grpc.testing.ComplexProtoParams complex_params = 3;</code>
-     */
-    public io.grpc.benchmarks.proto.Payloads.ComplexProtoParamsOrBuilder getComplexParamsOrBuilder() {
-      if (payloadCase_ == 3) {
-         return (io.grpc.benchmarks.proto.Payloads.ComplexProtoParams) payload_;
-      }
-      return io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.getDefaultInstance();
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (payloadCase_ == 1) {
-        output.writeMessage(1, (io.grpc.benchmarks.proto.Payloads.ByteBufferParams) payload_);
-      }
-      if (payloadCase_ == 2) {
-        output.writeMessage(2, (io.grpc.benchmarks.proto.Payloads.SimpleProtoParams) payload_);
-      }
-      if (payloadCase_ == 3) {
-        output.writeMessage(3, (io.grpc.benchmarks.proto.Payloads.ComplexProtoParams) payload_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (payloadCase_ == 1) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, (io.grpc.benchmarks.proto.Payloads.ByteBufferParams) payload_);
-      }
-      if (payloadCase_ == 2) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(2, (io.grpc.benchmarks.proto.Payloads.SimpleProtoParams) payload_);
-      }
-      if (payloadCase_ == 3) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(3, (io.grpc.benchmarks.proto.Payloads.ComplexProtoParams) payload_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Payloads.PayloadConfig)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Payloads.PayloadConfig other = (io.grpc.benchmarks.proto.Payloads.PayloadConfig) obj;
-
-      boolean result = true;
-      result = result && getPayloadCase().equals(
-          other.getPayloadCase());
-      if (!result) return false;
-      switch (payloadCase_) {
-        case 1:
-          result = result && getBytebufParams()
-              .equals(other.getBytebufParams());
-          break;
-        case 2:
-          result = result && getSimpleParams()
-              .equals(other.getSimpleParams());
-          break;
-        case 3:
-          result = result && getComplexParams()
-              .equals(other.getComplexParams());
-          break;
-        case 0:
-        default:
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      switch (payloadCase_) {
-        case 1:
-          hash = (37 * hash) + BYTEBUF_PARAMS_FIELD_NUMBER;
-          hash = (53 * hash) + getBytebufParams().hashCode();
-          break;
-        case 2:
-          hash = (37 * hash) + SIMPLE_PARAMS_FIELD_NUMBER;
-          hash = (53 * hash) + getSimpleParams().hashCode();
-          break;
-        case 3:
-          hash = (37 * hash) + COMPLEX_PARAMS_FIELD_NUMBER;
-          hash = (53 * hash) + getComplexParams().hashCode();
-          break;
-        case 0:
-        default:
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Payloads.PayloadConfig parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.PayloadConfig parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.PayloadConfig parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.PayloadConfig parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.PayloadConfig parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.PayloadConfig parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.PayloadConfig parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.PayloadConfig parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.PayloadConfig parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Payloads.PayloadConfig parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Payloads.PayloadConfig prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.PayloadConfig}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.PayloadConfig)
-        io.grpc.benchmarks.proto.Payloads.PayloadConfigOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_PayloadConfig_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_PayloadConfig_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Payloads.PayloadConfig.class, io.grpc.benchmarks.proto.Payloads.PayloadConfig.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Payloads.PayloadConfig.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        payloadCase_ = 0;
-        payload_ = null;
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Payloads.internal_static_grpc_testing_PayloadConfig_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Payloads.PayloadConfig getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Payloads.PayloadConfig.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Payloads.PayloadConfig build() {
-        io.grpc.benchmarks.proto.Payloads.PayloadConfig result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Payloads.PayloadConfig buildPartial() {
-        io.grpc.benchmarks.proto.Payloads.PayloadConfig result = new io.grpc.benchmarks.proto.Payloads.PayloadConfig(this);
-        if (payloadCase_ == 1) {
-          if (bytebufParamsBuilder_ == null) {
-            result.payload_ = payload_;
-          } else {
-            result.payload_ = bytebufParamsBuilder_.build();
-          }
-        }
-        if (payloadCase_ == 2) {
-          if (simpleParamsBuilder_ == null) {
-            result.payload_ = payload_;
-          } else {
-            result.payload_ = simpleParamsBuilder_.build();
-          }
-        }
-        if (payloadCase_ == 3) {
-          if (complexParamsBuilder_ == null) {
-            result.payload_ = payload_;
-          } else {
-            result.payload_ = complexParamsBuilder_.build();
-          }
-        }
-        result.payloadCase_ = payloadCase_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Payloads.PayloadConfig) {
-          return mergeFrom((io.grpc.benchmarks.proto.Payloads.PayloadConfig)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Payloads.PayloadConfig other) {
-        if (other == io.grpc.benchmarks.proto.Payloads.PayloadConfig.getDefaultInstance()) return this;
-        switch (other.getPayloadCase()) {
-          case BYTEBUF_PARAMS: {
-            mergeBytebufParams(other.getBytebufParams());
-            break;
-          }
-          case SIMPLE_PARAMS: {
-            mergeSimpleParams(other.getSimpleParams());
-            break;
-          }
-          case COMPLEX_PARAMS: {
-            mergeComplexParams(other.getComplexParams());
-            break;
-          }
-          case PAYLOAD_NOT_SET: {
-            break;
-          }
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Payloads.PayloadConfig parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Payloads.PayloadConfig) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      private int payloadCase_ = 0;
-      private java.lang.Object payload_;
-      public PayloadCase
-          getPayloadCase() {
-        return PayloadCase.forNumber(
-            payloadCase_);
-      }
-
-      public Builder clearPayload() {
-        payloadCase_ = 0;
-        payload_ = null;
-        onChanged();
-        return this;
-      }
-
-
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Payloads.ByteBufferParams, io.grpc.benchmarks.proto.Payloads.ByteBufferParams.Builder, io.grpc.benchmarks.proto.Payloads.ByteBufferParamsOrBuilder> bytebufParamsBuilder_;
-      /**
-       * <code>.grpc.testing.ByteBufferParams bytebuf_params = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.ByteBufferParams getBytebufParams() {
-        if (bytebufParamsBuilder_ == null) {
-          if (payloadCase_ == 1) {
-            return (io.grpc.benchmarks.proto.Payloads.ByteBufferParams) payload_;
-          }
-          return io.grpc.benchmarks.proto.Payloads.ByteBufferParams.getDefaultInstance();
-        } else {
-          if (payloadCase_ == 1) {
-            return bytebufParamsBuilder_.getMessage();
-          }
-          return io.grpc.benchmarks.proto.Payloads.ByteBufferParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ByteBufferParams bytebuf_params = 1;</code>
-       */
-      public Builder setBytebufParams(io.grpc.benchmarks.proto.Payloads.ByteBufferParams value) {
-        if (bytebufParamsBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payload_ = value;
-          onChanged();
-        } else {
-          bytebufParamsBuilder_.setMessage(value);
-        }
-        payloadCase_ = 1;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ByteBufferParams bytebuf_params = 1;</code>
-       */
-      public Builder setBytebufParams(
-          io.grpc.benchmarks.proto.Payloads.ByteBufferParams.Builder builderForValue) {
-        if (bytebufParamsBuilder_ == null) {
-          payload_ = builderForValue.build();
-          onChanged();
-        } else {
-          bytebufParamsBuilder_.setMessage(builderForValue.build());
-        }
-        payloadCase_ = 1;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ByteBufferParams bytebuf_params = 1;</code>
-       */
-      public Builder mergeBytebufParams(io.grpc.benchmarks.proto.Payloads.ByteBufferParams value) {
-        if (bytebufParamsBuilder_ == null) {
-          if (payloadCase_ == 1 &&
-              payload_ != io.grpc.benchmarks.proto.Payloads.ByteBufferParams.getDefaultInstance()) {
-            payload_ = io.grpc.benchmarks.proto.Payloads.ByteBufferParams.newBuilder((io.grpc.benchmarks.proto.Payloads.ByteBufferParams) payload_)
-                .mergeFrom(value).buildPartial();
-          } else {
-            payload_ = value;
-          }
-          onChanged();
-        } else {
-          if (payloadCase_ == 1) {
-            bytebufParamsBuilder_.mergeFrom(value);
-          }
-          bytebufParamsBuilder_.setMessage(value);
-        }
-        payloadCase_ = 1;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ByteBufferParams bytebuf_params = 1;</code>
-       */
-      public Builder clearBytebufParams() {
-        if (bytebufParamsBuilder_ == null) {
-          if (payloadCase_ == 1) {
-            payloadCase_ = 0;
-            payload_ = null;
-            onChanged();
-          }
-        } else {
-          if (payloadCase_ == 1) {
-            payloadCase_ = 0;
-            payload_ = null;
-          }
-          bytebufParamsBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ByteBufferParams bytebuf_params = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.ByteBufferParams.Builder getBytebufParamsBuilder() {
-        return getBytebufParamsFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.ByteBufferParams bytebuf_params = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.ByteBufferParamsOrBuilder getBytebufParamsOrBuilder() {
-        if ((payloadCase_ == 1) && (bytebufParamsBuilder_ != null)) {
-          return bytebufParamsBuilder_.getMessageOrBuilder();
-        } else {
-          if (payloadCase_ == 1) {
-            return (io.grpc.benchmarks.proto.Payloads.ByteBufferParams) payload_;
-          }
-          return io.grpc.benchmarks.proto.Payloads.ByteBufferParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ByteBufferParams bytebuf_params = 1;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Payloads.ByteBufferParams, io.grpc.benchmarks.proto.Payloads.ByteBufferParams.Builder, io.grpc.benchmarks.proto.Payloads.ByteBufferParamsOrBuilder> 
-          getBytebufParamsFieldBuilder() {
-        if (bytebufParamsBuilder_ == null) {
-          if (!(payloadCase_ == 1)) {
-            payload_ = io.grpc.benchmarks.proto.Payloads.ByteBufferParams.getDefaultInstance();
-          }
-          bytebufParamsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Payloads.ByteBufferParams, io.grpc.benchmarks.proto.Payloads.ByteBufferParams.Builder, io.grpc.benchmarks.proto.Payloads.ByteBufferParamsOrBuilder>(
-                  (io.grpc.benchmarks.proto.Payloads.ByteBufferParams) payload_,
-                  getParentForChildren(),
-                  isClean());
-          payload_ = null;
-        }
-        payloadCase_ = 1;
-        onChanged();;
-        return bytebufParamsBuilder_;
-      }
-
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Payloads.SimpleProtoParams, io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.Builder, io.grpc.benchmarks.proto.Payloads.SimpleProtoParamsOrBuilder> simpleParamsBuilder_;
-      /**
-       * <code>.grpc.testing.SimpleProtoParams simple_params = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.SimpleProtoParams getSimpleParams() {
-        if (simpleParamsBuilder_ == null) {
-          if (payloadCase_ == 2) {
-            return (io.grpc.benchmarks.proto.Payloads.SimpleProtoParams) payload_;
-          }
-          return io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.getDefaultInstance();
-        } else {
-          if (payloadCase_ == 2) {
-            return simpleParamsBuilder_.getMessage();
-          }
-          return io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.SimpleProtoParams simple_params = 2;</code>
-       */
-      public Builder setSimpleParams(io.grpc.benchmarks.proto.Payloads.SimpleProtoParams value) {
-        if (simpleParamsBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payload_ = value;
-          onChanged();
-        } else {
-          simpleParamsBuilder_.setMessage(value);
-        }
-        payloadCase_ = 2;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.SimpleProtoParams simple_params = 2;</code>
-       */
-      public Builder setSimpleParams(
-          io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.Builder builderForValue) {
-        if (simpleParamsBuilder_ == null) {
-          payload_ = builderForValue.build();
-          onChanged();
-        } else {
-          simpleParamsBuilder_.setMessage(builderForValue.build());
-        }
-        payloadCase_ = 2;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.SimpleProtoParams simple_params = 2;</code>
-       */
-      public Builder mergeSimpleParams(io.grpc.benchmarks.proto.Payloads.SimpleProtoParams value) {
-        if (simpleParamsBuilder_ == null) {
-          if (payloadCase_ == 2 &&
-              payload_ != io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.getDefaultInstance()) {
-            payload_ = io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.newBuilder((io.grpc.benchmarks.proto.Payloads.SimpleProtoParams) payload_)
-                .mergeFrom(value).buildPartial();
-          } else {
-            payload_ = value;
-          }
-          onChanged();
-        } else {
-          if (payloadCase_ == 2) {
-            simpleParamsBuilder_.mergeFrom(value);
-          }
-          simpleParamsBuilder_.setMessage(value);
-        }
-        payloadCase_ = 2;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.SimpleProtoParams simple_params = 2;</code>
-       */
-      public Builder clearSimpleParams() {
-        if (simpleParamsBuilder_ == null) {
-          if (payloadCase_ == 2) {
-            payloadCase_ = 0;
-            payload_ = null;
-            onChanged();
-          }
-        } else {
-          if (payloadCase_ == 2) {
-            payloadCase_ = 0;
-            payload_ = null;
-          }
-          simpleParamsBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.SimpleProtoParams simple_params = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.Builder getSimpleParamsBuilder() {
-        return getSimpleParamsFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.SimpleProtoParams simple_params = 2;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.SimpleProtoParamsOrBuilder getSimpleParamsOrBuilder() {
-        if ((payloadCase_ == 2) && (simpleParamsBuilder_ != null)) {
-          return simpleParamsBuilder_.getMessageOrBuilder();
-        } else {
-          if (payloadCase_ == 2) {
-            return (io.grpc.benchmarks.proto.Payloads.SimpleProtoParams) payload_;
-          }
-          return io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.SimpleProtoParams simple_params = 2;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Payloads.SimpleProtoParams, io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.Builder, io.grpc.benchmarks.proto.Payloads.SimpleProtoParamsOrBuilder> 
-          getSimpleParamsFieldBuilder() {
-        if (simpleParamsBuilder_ == null) {
-          if (!(payloadCase_ == 2)) {
-            payload_ = io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.getDefaultInstance();
-          }
-          simpleParamsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Payloads.SimpleProtoParams, io.grpc.benchmarks.proto.Payloads.SimpleProtoParams.Builder, io.grpc.benchmarks.proto.Payloads.SimpleProtoParamsOrBuilder>(
-                  (io.grpc.benchmarks.proto.Payloads.SimpleProtoParams) payload_,
-                  getParentForChildren(),
-                  isClean());
-          payload_ = null;
-        }
-        payloadCase_ = 2;
-        onChanged();;
-        return simpleParamsBuilder_;
-      }
-
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Payloads.ComplexProtoParams, io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.Builder, io.grpc.benchmarks.proto.Payloads.ComplexProtoParamsOrBuilder> complexParamsBuilder_;
-      /**
-       * <code>.grpc.testing.ComplexProtoParams complex_params = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.ComplexProtoParams getComplexParams() {
-        if (complexParamsBuilder_ == null) {
-          if (payloadCase_ == 3) {
-            return (io.grpc.benchmarks.proto.Payloads.ComplexProtoParams) payload_;
-          }
-          return io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.getDefaultInstance();
-        } else {
-          if (payloadCase_ == 3) {
-            return complexParamsBuilder_.getMessage();
-          }
-          return io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ComplexProtoParams complex_params = 3;</code>
-       */
-      public Builder setComplexParams(io.grpc.benchmarks.proto.Payloads.ComplexProtoParams value) {
-        if (complexParamsBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payload_ = value;
-          onChanged();
-        } else {
-          complexParamsBuilder_.setMessage(value);
-        }
-        payloadCase_ = 3;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ComplexProtoParams complex_params = 3;</code>
-       */
-      public Builder setComplexParams(
-          io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.Builder builderForValue) {
-        if (complexParamsBuilder_ == null) {
-          payload_ = builderForValue.build();
-          onChanged();
-        } else {
-          complexParamsBuilder_.setMessage(builderForValue.build());
-        }
-        payloadCase_ = 3;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ComplexProtoParams complex_params = 3;</code>
-       */
-      public Builder mergeComplexParams(io.grpc.benchmarks.proto.Payloads.ComplexProtoParams value) {
-        if (complexParamsBuilder_ == null) {
-          if (payloadCase_ == 3 &&
-              payload_ != io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.getDefaultInstance()) {
-            payload_ = io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.newBuilder((io.grpc.benchmarks.proto.Payloads.ComplexProtoParams) payload_)
-                .mergeFrom(value).buildPartial();
-          } else {
-            payload_ = value;
-          }
-          onChanged();
-        } else {
-          if (payloadCase_ == 3) {
-            complexParamsBuilder_.mergeFrom(value);
-          }
-          complexParamsBuilder_.setMessage(value);
-        }
-        payloadCase_ = 3;
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ComplexProtoParams complex_params = 3;</code>
-       */
-      public Builder clearComplexParams() {
-        if (complexParamsBuilder_ == null) {
-          if (payloadCase_ == 3) {
-            payloadCase_ = 0;
-            payload_ = null;
-            onChanged();
-          }
-        } else {
-          if (payloadCase_ == 3) {
-            payloadCase_ = 0;
-            payload_ = null;
-          }
-          complexParamsBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <code>.grpc.testing.ComplexProtoParams complex_params = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.Builder getComplexParamsBuilder() {
-        return getComplexParamsFieldBuilder().getBuilder();
-      }
-      /**
-       * <code>.grpc.testing.ComplexProtoParams complex_params = 3;</code>
-       */
-      public io.grpc.benchmarks.proto.Payloads.ComplexProtoParamsOrBuilder getComplexParamsOrBuilder() {
-        if ((payloadCase_ == 3) && (complexParamsBuilder_ != null)) {
-          return complexParamsBuilder_.getMessageOrBuilder();
-        } else {
-          if (payloadCase_ == 3) {
-            return (io.grpc.benchmarks.proto.Payloads.ComplexProtoParams) payload_;
-          }
-          return io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.getDefaultInstance();
-        }
-      }
-      /**
-       * <code>.grpc.testing.ComplexProtoParams complex_params = 3;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Payloads.ComplexProtoParams, io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.Builder, io.grpc.benchmarks.proto.Payloads.ComplexProtoParamsOrBuilder> 
-          getComplexParamsFieldBuilder() {
-        if (complexParamsBuilder_ == null) {
-          if (!(payloadCase_ == 3)) {
-            payload_ = io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.getDefaultInstance();
-          }
-          complexParamsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Payloads.ComplexProtoParams, io.grpc.benchmarks.proto.Payloads.ComplexProtoParams.Builder, io.grpc.benchmarks.proto.Payloads.ComplexProtoParamsOrBuilder>(
-                  (io.grpc.benchmarks.proto.Payloads.ComplexProtoParams) payload_,
-                  getParentForChildren(),
-                  isClean());
-          payload_ = null;
-        }
-        payloadCase_ = 3;
-        onChanged();;
-        return complexParamsBuilder_;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.PayloadConfig)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.PayloadConfig)
-    private static final io.grpc.benchmarks.proto.Payloads.PayloadConfig DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Payloads.PayloadConfig();
-    }
-
-    public static io.grpc.benchmarks.proto.Payloads.PayloadConfig getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<PayloadConfig>
-        PARSER = new com.google.protobuf.AbstractParser<PayloadConfig>() {
-      public PayloadConfig parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new PayloadConfig(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<PayloadConfig> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<PayloadConfig> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Payloads.PayloadConfig getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ByteBufferParams_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ByteBufferParams_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_SimpleProtoParams_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_SimpleProtoParams_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ComplexProtoParams_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ComplexProtoParams_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_PayloadConfig_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_PayloadConfig_fieldAccessorTable;
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n\016payloads.proto\022\014grpc.testing\"7\n\020ByteBu" +
-      "fferParams\022\020\n\010req_size\030\001 \001(\005\022\021\n\tresp_siz" +
-      "e\030\002 \001(\005\"8\n\021SimpleProtoParams\022\020\n\010req_size" +
-      "\030\001 \001(\005\022\021\n\tresp_size\030\002 \001(\005\"\024\n\022ComplexProt" +
-      "oParams\"\312\001\n\rPayloadConfig\0228\n\016bytebuf_par" +
-      "ams\030\001 \001(\0132\036.grpc.testing.ByteBufferParam" +
-      "sH\000\0228\n\rsimple_params\030\002 \001(\0132\037.grpc.testin" +
-      "g.SimpleProtoParamsH\000\022:\n\016complex_params\030" +
-      "\003 \001(\0132 .grpc.testing.ComplexProtoParamsH" +
-      "\000B\t\n\007payloadB$\n\030io.grpc.benchmarks.proto",
-      "B\010Payloadsb\006proto3"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-        }, assigner);
-    internal_static_grpc_testing_ByteBufferParams_descriptor =
-      getDescriptor().getMessageTypes().get(0);
-    internal_static_grpc_testing_ByteBufferParams_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ByteBufferParams_descriptor,
-        new java.lang.String[] { "ReqSize", "RespSize", });
-    internal_static_grpc_testing_SimpleProtoParams_descriptor =
-      getDescriptor().getMessageTypes().get(1);
-    internal_static_grpc_testing_SimpleProtoParams_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_SimpleProtoParams_descriptor,
-        new java.lang.String[] { "ReqSize", "RespSize", });
-    internal_static_grpc_testing_ComplexProtoParams_descriptor =
-      getDescriptor().getMessageTypes().get(2);
-    internal_static_grpc_testing_ComplexProtoParams_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ComplexProtoParams_descriptor,
-        new java.lang.String[] { });
-    internal_static_grpc_testing_PayloadConfig_descriptor =
-      getDescriptor().getMessageTypes().get(3);
-    internal_static_grpc_testing_PayloadConfig_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_PayloadConfig_descriptor,
-        new java.lang.String[] { "BytebufParams", "SimpleParams", "ComplexParams", "Payload", });
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Services.java b/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Services.java
deleted file mode 100644
index 4372cf8ffbe..00000000000
--- a/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Services.java
+++ /dev/null
@@ -1,61 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: services.proto
-
-package io.grpc.benchmarks.proto;
-
-public final class Services {
-  private Services() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n\016services.proto\022\014grpc.testing\032\016messages" +
-      ".proto\032\rcontrol.proto2\252\001\n\020BenchmarkServi" +
-      "ce\022F\n\tUnaryCall\022\033.grpc.testing.SimpleReq" +
-      "uest\032\034.grpc.testing.SimpleResponse\022N\n\rSt" +
-      "reamingCall\022\033.grpc.testing.SimpleRequest" +
-      "\032\034.grpc.testing.SimpleResponse(\0010\0012\227\002\n\rW" +
-      "orkerService\022E\n\tRunServer\022\030.grpc.testing" +
-      ".ServerArgs\032\032.grpc.testing.ServerStatus(" +
-      "\0010\001\022E\n\tRunClient\022\030.grpc.testing.ClientAr" +
-      "gs\032\032.grpc.testing.ClientStatus(\0010\001\022B\n\tCo",
-      "reCount\022\031.grpc.testing.CoreRequest\032\032.grp" +
-      "c.testing.CoreResponse\0224\n\nQuitWorker\022\022.g" +
-      "rpc.testing.Void\032\022.grpc.testing.VoidB$\n\030" +
-      "io.grpc.benchmarks.protoB\010Servicesb\006prot" +
-      "o3"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-          io.grpc.benchmarks.proto.Messages.getDescriptor(),
-          io.grpc.benchmarks.proto.Control.getDescriptor(),
-        }, assigner);
-    io.grpc.benchmarks.proto.Messages.getDescriptor();
-    io.grpc.benchmarks.proto.Control.getDescriptor();
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Stats.java b/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Stats.java
deleted file mode 100644
index 013f5648387..00000000000
--- a/benchmarks/src/generated/main/java/io/grpc/benchmarks/proto/Stats.java
+++ /dev/null
@@ -1,2992 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: stats.proto
-
-package io.grpc.benchmarks.proto;
-
-public final class Stats {
-  private Stats() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  public interface ServerStatsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ServerStats)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * wall clock time change in seconds since last reset
-     * </pre>
-     *
-     * <code>double time_elapsed = 1;</code>
-     */
-    double getTimeElapsed();
-
-    /**
-     * <pre>
-     * change in user time (in seconds) used by the server since last reset
-     * </pre>
-     *
-     * <code>double time_user = 2;</code>
-     */
-    double getTimeUser();
-
-    /**
-     * <pre>
-     * change in server time (in seconds) used by the server process and all
-     * threads since last reset
-     * </pre>
-     *
-     * <code>double time_system = 3;</code>
-     */
-    double getTimeSystem();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.ServerStats}
-   */
-  public  static final class ServerStats extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ServerStats)
-      ServerStatsOrBuilder {
-    // Use ServerStats.newBuilder() to construct.
-    private ServerStats(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ServerStats() {
-      timeElapsed_ = 0D;
-      timeUser_ = 0D;
-      timeSystem_ = 0D;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ServerStats(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 9: {
-
-              timeElapsed_ = input.readDouble();
-              break;
-            }
-            case 17: {
-
-              timeUser_ = input.readDouble();
-              break;
-            }
-            case 25: {
-
-              timeSystem_ = input.readDouble();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_ServerStats_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_ServerStats_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Stats.ServerStats.class, io.grpc.benchmarks.proto.Stats.ServerStats.Builder.class);
-    }
-
-    public static final int TIME_ELAPSED_FIELD_NUMBER = 1;
-    private double timeElapsed_;
-    /**
-     * <pre>
-     * wall clock time change in seconds since last reset
-     * </pre>
-     *
-     * <code>double time_elapsed = 1;</code>
-     */
-    public double getTimeElapsed() {
-      return timeElapsed_;
-    }
-
-    public static final int TIME_USER_FIELD_NUMBER = 2;
-    private double timeUser_;
-    /**
-     * <pre>
-     * change in user time (in seconds) used by the server since last reset
-     * </pre>
-     *
-     * <code>double time_user = 2;</code>
-     */
-    public double getTimeUser() {
-      return timeUser_;
-    }
-
-    public static final int TIME_SYSTEM_FIELD_NUMBER = 3;
-    private double timeSystem_;
-    /**
-     * <pre>
-     * change in server time (in seconds) used by the server process and all
-     * threads since last reset
-     * </pre>
-     *
-     * <code>double time_system = 3;</code>
-     */
-    public double getTimeSystem() {
-      return timeSystem_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (timeElapsed_ != 0D) {
-        output.writeDouble(1, timeElapsed_);
-      }
-      if (timeUser_ != 0D) {
-        output.writeDouble(2, timeUser_);
-      }
-      if (timeSystem_ != 0D) {
-        output.writeDouble(3, timeSystem_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (timeElapsed_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(1, timeElapsed_);
-      }
-      if (timeUser_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(2, timeUser_);
-      }
-      if (timeSystem_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(3, timeSystem_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Stats.ServerStats)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Stats.ServerStats other = (io.grpc.benchmarks.proto.Stats.ServerStats) obj;
-
-      boolean result = true;
-      result = result && (
-          java.lang.Double.doubleToLongBits(getTimeElapsed())
-          == java.lang.Double.doubleToLongBits(
-              other.getTimeElapsed()));
-      result = result && (
-          java.lang.Double.doubleToLongBits(getTimeUser())
-          == java.lang.Double.doubleToLongBits(
-              other.getTimeUser()));
-      result = result && (
-          java.lang.Double.doubleToLongBits(getTimeSystem())
-          == java.lang.Double.doubleToLongBits(
-              other.getTimeSystem()));
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + TIME_ELAPSED_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getTimeElapsed()));
-      hash = (37 * hash) + TIME_USER_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getTimeUser()));
-      hash = (37 * hash) + TIME_SYSTEM_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getTimeSystem()));
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Stats.ServerStats parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ServerStats parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ServerStats parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ServerStats parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ServerStats parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ServerStats parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ServerStats parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ServerStats parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ServerStats parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ServerStats parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Stats.ServerStats prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.ServerStats}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ServerStats)
-        io.grpc.benchmarks.proto.Stats.ServerStatsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_ServerStats_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_ServerStats_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Stats.ServerStats.class, io.grpc.benchmarks.proto.Stats.ServerStats.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Stats.ServerStats.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        timeElapsed_ = 0D;
-
-        timeUser_ = 0D;
-
-        timeSystem_ = 0D;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_ServerStats_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Stats.ServerStats getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Stats.ServerStats.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Stats.ServerStats build() {
-        io.grpc.benchmarks.proto.Stats.ServerStats result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Stats.ServerStats buildPartial() {
-        io.grpc.benchmarks.proto.Stats.ServerStats result = new io.grpc.benchmarks.proto.Stats.ServerStats(this);
-        result.timeElapsed_ = timeElapsed_;
-        result.timeUser_ = timeUser_;
-        result.timeSystem_ = timeSystem_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Stats.ServerStats) {
-          return mergeFrom((io.grpc.benchmarks.proto.Stats.ServerStats)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Stats.ServerStats other) {
-        if (other == io.grpc.benchmarks.proto.Stats.ServerStats.getDefaultInstance()) return this;
-        if (other.getTimeElapsed() != 0D) {
-          setTimeElapsed(other.getTimeElapsed());
-        }
-        if (other.getTimeUser() != 0D) {
-          setTimeUser(other.getTimeUser());
-        }
-        if (other.getTimeSystem() != 0D) {
-          setTimeSystem(other.getTimeSystem());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Stats.ServerStats parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Stats.ServerStats) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private double timeElapsed_ ;
-      /**
-       * <pre>
-       * wall clock time change in seconds since last reset
-       * </pre>
-       *
-       * <code>double time_elapsed = 1;</code>
-       */
-      public double getTimeElapsed() {
-        return timeElapsed_;
-      }
-      /**
-       * <pre>
-       * wall clock time change in seconds since last reset
-       * </pre>
-       *
-       * <code>double time_elapsed = 1;</code>
-       */
-      public Builder setTimeElapsed(double value) {
-        
-        timeElapsed_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * wall clock time change in seconds since last reset
-       * </pre>
-       *
-       * <code>double time_elapsed = 1;</code>
-       */
-      public Builder clearTimeElapsed() {
-        
-        timeElapsed_ = 0D;
-        onChanged();
-        return this;
-      }
-
-      private double timeUser_ ;
-      /**
-       * <pre>
-       * change in user time (in seconds) used by the server since last reset
-       * </pre>
-       *
-       * <code>double time_user = 2;</code>
-       */
-      public double getTimeUser() {
-        return timeUser_;
-      }
-      /**
-       * <pre>
-       * change in user time (in seconds) used by the server since last reset
-       * </pre>
-       *
-       * <code>double time_user = 2;</code>
-       */
-      public Builder setTimeUser(double value) {
-        
-        timeUser_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * change in user time (in seconds) used by the server since last reset
-       * </pre>
-       *
-       * <code>double time_user = 2;</code>
-       */
-      public Builder clearTimeUser() {
-        
-        timeUser_ = 0D;
-        onChanged();
-        return this;
-      }
-
-      private double timeSystem_ ;
-      /**
-       * <pre>
-       * change in server time (in seconds) used by the server process and all
-       * threads since last reset
-       * </pre>
-       *
-       * <code>double time_system = 3;</code>
-       */
-      public double getTimeSystem() {
-        return timeSystem_;
-      }
-      /**
-       * <pre>
-       * change in server time (in seconds) used by the server process and all
-       * threads since last reset
-       * </pre>
-       *
-       * <code>double time_system = 3;</code>
-       */
-      public Builder setTimeSystem(double value) {
-        
-        timeSystem_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * change in server time (in seconds) used by the server process and all
-       * threads since last reset
-       * </pre>
-       *
-       * <code>double time_system = 3;</code>
-       */
-      public Builder clearTimeSystem() {
-        
-        timeSystem_ = 0D;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ServerStats)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ServerStats)
-    private static final io.grpc.benchmarks.proto.Stats.ServerStats DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Stats.ServerStats();
-    }
-
-    public static io.grpc.benchmarks.proto.Stats.ServerStats getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ServerStats>
-        PARSER = new com.google.protobuf.AbstractParser<ServerStats>() {
-      public ServerStats parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ServerStats(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ServerStats> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ServerStats> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Stats.ServerStats getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface HistogramParamsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.HistogramParams)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * first bucket is [0, 1 + resolution)
-     * </pre>
-     *
-     * <code>double resolution = 1;</code>
-     */
-    double getResolution();
-
-    /**
-     * <pre>
-     * use enough buckets to allow this value
-     * </pre>
-     *
-     * <code>double max_possible = 2;</code>
-     */
-    double getMaxPossible();
-  }
-  /**
-   * <pre>
-   * Histogram params based on grpc/support/histogram.c
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.HistogramParams}
-   */
-  public  static final class HistogramParams extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.HistogramParams)
-      HistogramParamsOrBuilder {
-    // Use HistogramParams.newBuilder() to construct.
-    private HistogramParams(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private HistogramParams() {
-      resolution_ = 0D;
-      maxPossible_ = 0D;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private HistogramParams(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 9: {
-
-              resolution_ = input.readDouble();
-              break;
-            }
-            case 17: {
-
-              maxPossible_ = input.readDouble();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_HistogramParams_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_HistogramParams_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Stats.HistogramParams.class, io.grpc.benchmarks.proto.Stats.HistogramParams.Builder.class);
-    }
-
-    public static final int RESOLUTION_FIELD_NUMBER = 1;
-    private double resolution_;
-    /**
-     * <pre>
-     * first bucket is [0, 1 + resolution)
-     * </pre>
-     *
-     * <code>double resolution = 1;</code>
-     */
-    public double getResolution() {
-      return resolution_;
-    }
-
-    public static final int MAX_POSSIBLE_FIELD_NUMBER = 2;
-    private double maxPossible_;
-    /**
-     * <pre>
-     * use enough buckets to allow this value
-     * </pre>
-     *
-     * <code>double max_possible = 2;</code>
-     */
-    public double getMaxPossible() {
-      return maxPossible_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (resolution_ != 0D) {
-        output.writeDouble(1, resolution_);
-      }
-      if (maxPossible_ != 0D) {
-        output.writeDouble(2, maxPossible_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (resolution_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(1, resolution_);
-      }
-      if (maxPossible_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(2, maxPossible_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Stats.HistogramParams)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Stats.HistogramParams other = (io.grpc.benchmarks.proto.Stats.HistogramParams) obj;
-
-      boolean result = true;
-      result = result && (
-          java.lang.Double.doubleToLongBits(getResolution())
-          == java.lang.Double.doubleToLongBits(
-              other.getResolution()));
-      result = result && (
-          java.lang.Double.doubleToLongBits(getMaxPossible())
-          == java.lang.Double.doubleToLongBits(
-              other.getMaxPossible()));
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + RESOLUTION_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getResolution()));
-      hash = (37 * hash) + MAX_POSSIBLE_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getMaxPossible()));
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Stats.HistogramParams parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramParams parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramParams parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramParams parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramParams parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramParams parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramParams parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramParams parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramParams parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramParams parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Stats.HistogramParams prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Histogram params based on grpc/support/histogram.c
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.HistogramParams}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.HistogramParams)
-        io.grpc.benchmarks.proto.Stats.HistogramParamsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_HistogramParams_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_HistogramParams_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Stats.HistogramParams.class, io.grpc.benchmarks.proto.Stats.HistogramParams.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Stats.HistogramParams.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        resolution_ = 0D;
-
-        maxPossible_ = 0D;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_HistogramParams_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Stats.HistogramParams getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Stats.HistogramParams.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Stats.HistogramParams build() {
-        io.grpc.benchmarks.proto.Stats.HistogramParams result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Stats.HistogramParams buildPartial() {
-        io.grpc.benchmarks.proto.Stats.HistogramParams result = new io.grpc.benchmarks.proto.Stats.HistogramParams(this);
-        result.resolution_ = resolution_;
-        result.maxPossible_ = maxPossible_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Stats.HistogramParams) {
-          return mergeFrom((io.grpc.benchmarks.proto.Stats.HistogramParams)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Stats.HistogramParams other) {
-        if (other == io.grpc.benchmarks.proto.Stats.HistogramParams.getDefaultInstance()) return this;
-        if (other.getResolution() != 0D) {
-          setResolution(other.getResolution());
-        }
-        if (other.getMaxPossible() != 0D) {
-          setMaxPossible(other.getMaxPossible());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Stats.HistogramParams parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Stats.HistogramParams) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private double resolution_ ;
-      /**
-       * <pre>
-       * first bucket is [0, 1 + resolution)
-       * </pre>
-       *
-       * <code>double resolution = 1;</code>
-       */
-      public double getResolution() {
-        return resolution_;
-      }
-      /**
-       * <pre>
-       * first bucket is [0, 1 + resolution)
-       * </pre>
-       *
-       * <code>double resolution = 1;</code>
-       */
-      public Builder setResolution(double value) {
-        
-        resolution_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * first bucket is [0, 1 + resolution)
-       * </pre>
-       *
-       * <code>double resolution = 1;</code>
-       */
-      public Builder clearResolution() {
-        
-        resolution_ = 0D;
-        onChanged();
-        return this;
-      }
-
-      private double maxPossible_ ;
-      /**
-       * <pre>
-       * use enough buckets to allow this value
-       * </pre>
-       *
-       * <code>double max_possible = 2;</code>
-       */
-      public double getMaxPossible() {
-        return maxPossible_;
-      }
-      /**
-       * <pre>
-       * use enough buckets to allow this value
-       * </pre>
-       *
-       * <code>double max_possible = 2;</code>
-       */
-      public Builder setMaxPossible(double value) {
-        
-        maxPossible_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * use enough buckets to allow this value
-       * </pre>
-       *
-       * <code>double max_possible = 2;</code>
-       */
-      public Builder clearMaxPossible() {
-        
-        maxPossible_ = 0D;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.HistogramParams)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.HistogramParams)
-    private static final io.grpc.benchmarks.proto.Stats.HistogramParams DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Stats.HistogramParams();
-    }
-
-    public static io.grpc.benchmarks.proto.Stats.HistogramParams getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<HistogramParams>
-        PARSER = new com.google.protobuf.AbstractParser<HistogramParams>() {
-      public HistogramParams parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new HistogramParams(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<HistogramParams> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<HistogramParams> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Stats.HistogramParams getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface HistogramDataOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.HistogramData)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>repeated uint32 bucket = 1;</code>
-     */
-    java.util.List<java.lang.Integer> getBucketList();
-    /**
-     * <code>repeated uint32 bucket = 1;</code>
-     */
-    int getBucketCount();
-    /**
-     * <code>repeated uint32 bucket = 1;</code>
-     */
-    int getBucket(int index);
-
-    /**
-     * <code>double min_seen = 2;</code>
-     */
-    double getMinSeen();
-
-    /**
-     * <code>double max_seen = 3;</code>
-     */
-    double getMaxSeen();
-
-    /**
-     * <code>double sum = 4;</code>
-     */
-    double getSum();
-
-    /**
-     * <code>double sum_of_squares = 5;</code>
-     */
-    double getSumOfSquares();
-
-    /**
-     * <code>double count = 6;</code>
-     */
-    double getCount();
-  }
-  /**
-   * <pre>
-   * Histogram data based on grpc/support/histogram.c
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.HistogramData}
-   */
-  public  static final class HistogramData extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.HistogramData)
-      HistogramDataOrBuilder {
-    // Use HistogramData.newBuilder() to construct.
-    private HistogramData(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private HistogramData() {
-      bucket_ = java.util.Collections.emptyList();
-      minSeen_ = 0D;
-      maxSeen_ = 0D;
-      sum_ = 0D;
-      sumOfSquares_ = 0D;
-      count_ = 0D;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private HistogramData(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-              if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
-                bucket_ = new java.util.ArrayList<java.lang.Integer>();
-                mutable_bitField0_ |= 0x00000001;
-              }
-              bucket_.add(input.readUInt32());
-              break;
-            }
-            case 10: {
-              int length = input.readRawVarint32();
-              int limit = input.pushLimit(length);
-              if (!((mutable_bitField0_ & 0x00000001) == 0x00000001) && input.getBytesUntilLimit() > 0) {
-                bucket_ = new java.util.ArrayList<java.lang.Integer>();
-                mutable_bitField0_ |= 0x00000001;
-              }
-              while (input.getBytesUntilLimit() > 0) {
-                bucket_.add(input.readUInt32());
-              }
-              input.popLimit(limit);
-              break;
-            }
-            case 17: {
-
-              minSeen_ = input.readDouble();
-              break;
-            }
-            case 25: {
-
-              maxSeen_ = input.readDouble();
-              break;
-            }
-            case 33: {
-
-              sum_ = input.readDouble();
-              break;
-            }
-            case 41: {
-
-              sumOfSquares_ = input.readDouble();
-              break;
-            }
-            case 49: {
-
-              count_ = input.readDouble();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
-          bucket_ = java.util.Collections.unmodifiableList(bucket_);
-        }
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_HistogramData_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_HistogramData_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Stats.HistogramData.class, io.grpc.benchmarks.proto.Stats.HistogramData.Builder.class);
-    }
-
-    private int bitField0_;
-    public static final int BUCKET_FIELD_NUMBER = 1;
-    private java.util.List<java.lang.Integer> bucket_;
-    /**
-     * <code>repeated uint32 bucket = 1;</code>
-     */
-    public java.util.List<java.lang.Integer>
-        getBucketList() {
-      return bucket_;
-    }
-    /**
-     * <code>repeated uint32 bucket = 1;</code>
-     */
-    public int getBucketCount() {
-      return bucket_.size();
-    }
-    /**
-     * <code>repeated uint32 bucket = 1;</code>
-     */
-    public int getBucket(int index) {
-      return bucket_.get(index);
-    }
-    private int bucketMemoizedSerializedSize = -1;
-
-    public static final int MIN_SEEN_FIELD_NUMBER = 2;
-    private double minSeen_;
-    /**
-     * <code>double min_seen = 2;</code>
-     */
-    public double getMinSeen() {
-      return minSeen_;
-    }
-
-    public static final int MAX_SEEN_FIELD_NUMBER = 3;
-    private double maxSeen_;
-    /**
-     * <code>double max_seen = 3;</code>
-     */
-    public double getMaxSeen() {
-      return maxSeen_;
-    }
-
-    public static final int SUM_FIELD_NUMBER = 4;
-    private double sum_;
-    /**
-     * <code>double sum = 4;</code>
-     */
-    public double getSum() {
-      return sum_;
-    }
-
-    public static final int SUM_OF_SQUARES_FIELD_NUMBER = 5;
-    private double sumOfSquares_;
-    /**
-     * <code>double sum_of_squares = 5;</code>
-     */
-    public double getSumOfSquares() {
-      return sumOfSquares_;
-    }
-
-    public static final int COUNT_FIELD_NUMBER = 6;
-    private double count_;
-    /**
-     * <code>double count = 6;</code>
-     */
-    public double getCount() {
-      return count_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      getSerializedSize();
-      if (getBucketList().size() > 0) {
-        output.writeUInt32NoTag(10);
-        output.writeUInt32NoTag(bucketMemoizedSerializedSize);
-      }
-      for (int i = 0; i < bucket_.size(); i++) {
-        output.writeUInt32NoTag(bucket_.get(i));
-      }
-      if (minSeen_ != 0D) {
-        output.writeDouble(2, minSeen_);
-      }
-      if (maxSeen_ != 0D) {
-        output.writeDouble(3, maxSeen_);
-      }
-      if (sum_ != 0D) {
-        output.writeDouble(4, sum_);
-      }
-      if (sumOfSquares_ != 0D) {
-        output.writeDouble(5, sumOfSquares_);
-      }
-      if (count_ != 0D) {
-        output.writeDouble(6, count_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      {
-        int dataSize = 0;
-        for (int i = 0; i < bucket_.size(); i++) {
-          dataSize += com.google.protobuf.CodedOutputStream
-            .computeUInt32SizeNoTag(bucket_.get(i));
-        }
-        size += dataSize;
-        if (!getBucketList().isEmpty()) {
-          size += 1;
-          size += com.google.protobuf.CodedOutputStream
-              .computeInt32SizeNoTag(dataSize);
-        }
-        bucketMemoizedSerializedSize = dataSize;
-      }
-      if (minSeen_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(2, minSeen_);
-      }
-      if (maxSeen_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(3, maxSeen_);
-      }
-      if (sum_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(4, sum_);
-      }
-      if (sumOfSquares_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(5, sumOfSquares_);
-      }
-      if (count_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(6, count_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Stats.HistogramData)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Stats.HistogramData other = (io.grpc.benchmarks.proto.Stats.HistogramData) obj;
-
-      boolean result = true;
-      result = result && getBucketList()
-          .equals(other.getBucketList());
-      result = result && (
-          java.lang.Double.doubleToLongBits(getMinSeen())
-          == java.lang.Double.doubleToLongBits(
-              other.getMinSeen()));
-      result = result && (
-          java.lang.Double.doubleToLongBits(getMaxSeen())
-          == java.lang.Double.doubleToLongBits(
-              other.getMaxSeen()));
-      result = result && (
-          java.lang.Double.doubleToLongBits(getSum())
-          == java.lang.Double.doubleToLongBits(
-              other.getSum()));
-      result = result && (
-          java.lang.Double.doubleToLongBits(getSumOfSquares())
-          == java.lang.Double.doubleToLongBits(
-              other.getSumOfSquares()));
-      result = result && (
-          java.lang.Double.doubleToLongBits(getCount())
-          == java.lang.Double.doubleToLongBits(
-              other.getCount()));
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      if (getBucketCount() > 0) {
-        hash = (37 * hash) + BUCKET_FIELD_NUMBER;
-        hash = (53 * hash) + getBucketList().hashCode();
-      }
-      hash = (37 * hash) + MIN_SEEN_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getMinSeen()));
-      hash = (37 * hash) + MAX_SEEN_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getMaxSeen()));
-      hash = (37 * hash) + SUM_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getSum()));
-      hash = (37 * hash) + SUM_OF_SQUARES_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getSumOfSquares()));
-      hash = (37 * hash) + COUNT_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getCount()));
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Stats.HistogramData parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramData parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramData parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramData parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramData parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramData parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramData parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramData parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramData parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Stats.HistogramData parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Stats.HistogramData prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Histogram data based on grpc/support/histogram.c
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.HistogramData}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.HistogramData)
-        io.grpc.benchmarks.proto.Stats.HistogramDataOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_HistogramData_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_HistogramData_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Stats.HistogramData.class, io.grpc.benchmarks.proto.Stats.HistogramData.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Stats.HistogramData.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        bucket_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000001);
-        minSeen_ = 0D;
-
-        maxSeen_ = 0D;
-
-        sum_ = 0D;
-
-        sumOfSquares_ = 0D;
-
-        count_ = 0D;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_HistogramData_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Stats.HistogramData getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Stats.HistogramData.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Stats.HistogramData build() {
-        io.grpc.benchmarks.proto.Stats.HistogramData result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Stats.HistogramData buildPartial() {
-        io.grpc.benchmarks.proto.Stats.HistogramData result = new io.grpc.benchmarks.proto.Stats.HistogramData(this);
-        int from_bitField0_ = bitField0_;
-        int to_bitField0_ = 0;
-        if (((bitField0_ & 0x00000001) == 0x00000001)) {
-          bucket_ = java.util.Collections.unmodifiableList(bucket_);
-          bitField0_ = (bitField0_ & ~0x00000001);
-        }
-        result.bucket_ = bucket_;
-        result.minSeen_ = minSeen_;
-        result.maxSeen_ = maxSeen_;
-        result.sum_ = sum_;
-        result.sumOfSquares_ = sumOfSquares_;
-        result.count_ = count_;
-        result.bitField0_ = to_bitField0_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Stats.HistogramData) {
-          return mergeFrom((io.grpc.benchmarks.proto.Stats.HistogramData)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Stats.HistogramData other) {
-        if (other == io.grpc.benchmarks.proto.Stats.HistogramData.getDefaultInstance()) return this;
-        if (!other.bucket_.isEmpty()) {
-          if (bucket_.isEmpty()) {
-            bucket_ = other.bucket_;
-            bitField0_ = (bitField0_ & ~0x00000001);
-          } else {
-            ensureBucketIsMutable();
-            bucket_.addAll(other.bucket_);
-          }
-          onChanged();
-        }
-        if (other.getMinSeen() != 0D) {
-          setMinSeen(other.getMinSeen());
-        }
-        if (other.getMaxSeen() != 0D) {
-          setMaxSeen(other.getMaxSeen());
-        }
-        if (other.getSum() != 0D) {
-          setSum(other.getSum());
-        }
-        if (other.getSumOfSquares() != 0D) {
-          setSumOfSquares(other.getSumOfSquares());
-        }
-        if (other.getCount() != 0D) {
-          setCount(other.getCount());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Stats.HistogramData parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Stats.HistogramData) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      private int bitField0_;
-
-      private java.util.List<java.lang.Integer> bucket_ = java.util.Collections.emptyList();
-      private void ensureBucketIsMutable() {
-        if (!((bitField0_ & 0x00000001) == 0x00000001)) {
-          bucket_ = new java.util.ArrayList<java.lang.Integer>(bucket_);
-          bitField0_ |= 0x00000001;
-         }
-      }
-      /**
-       * <code>repeated uint32 bucket = 1;</code>
-       */
-      public java.util.List<java.lang.Integer>
-          getBucketList() {
-        return java.util.Collections.unmodifiableList(bucket_);
-      }
-      /**
-       * <code>repeated uint32 bucket = 1;</code>
-       */
-      public int getBucketCount() {
-        return bucket_.size();
-      }
-      /**
-       * <code>repeated uint32 bucket = 1;</code>
-       */
-      public int getBucket(int index) {
-        return bucket_.get(index);
-      }
-      /**
-       * <code>repeated uint32 bucket = 1;</code>
-       */
-      public Builder setBucket(
-          int index, int value) {
-        ensureBucketIsMutable();
-        bucket_.set(index, value);
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>repeated uint32 bucket = 1;</code>
-       */
-      public Builder addBucket(int value) {
-        ensureBucketIsMutable();
-        bucket_.add(value);
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>repeated uint32 bucket = 1;</code>
-       */
-      public Builder addAllBucket(
-          java.lang.Iterable<? extends java.lang.Integer> values) {
-        ensureBucketIsMutable();
-        com.google.protobuf.AbstractMessageLite.Builder.addAll(
-            values, bucket_);
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>repeated uint32 bucket = 1;</code>
-       */
-      public Builder clearBucket() {
-        bucket_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000001);
-        onChanged();
-        return this;
-      }
-
-      private double minSeen_ ;
-      /**
-       * <code>double min_seen = 2;</code>
-       */
-      public double getMinSeen() {
-        return minSeen_;
-      }
-      /**
-       * <code>double min_seen = 2;</code>
-       */
-      public Builder setMinSeen(double value) {
-        
-        minSeen_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>double min_seen = 2;</code>
-       */
-      public Builder clearMinSeen() {
-        
-        minSeen_ = 0D;
-        onChanged();
-        return this;
-      }
-
-      private double maxSeen_ ;
-      /**
-       * <code>double max_seen = 3;</code>
-       */
-      public double getMaxSeen() {
-        return maxSeen_;
-      }
-      /**
-       * <code>double max_seen = 3;</code>
-       */
-      public Builder setMaxSeen(double value) {
-        
-        maxSeen_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>double max_seen = 3;</code>
-       */
-      public Builder clearMaxSeen() {
-        
-        maxSeen_ = 0D;
-        onChanged();
-        return this;
-      }
-
-      private double sum_ ;
-      /**
-       * <code>double sum = 4;</code>
-       */
-      public double getSum() {
-        return sum_;
-      }
-      /**
-       * <code>double sum = 4;</code>
-       */
-      public Builder setSum(double value) {
-        
-        sum_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>double sum = 4;</code>
-       */
-      public Builder clearSum() {
-        
-        sum_ = 0D;
-        onChanged();
-        return this;
-      }
-
-      private double sumOfSquares_ ;
-      /**
-       * <code>double sum_of_squares = 5;</code>
-       */
-      public double getSumOfSquares() {
-        return sumOfSquares_;
-      }
-      /**
-       * <code>double sum_of_squares = 5;</code>
-       */
-      public Builder setSumOfSquares(double value) {
-        
-        sumOfSquares_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>double sum_of_squares = 5;</code>
-       */
-      public Builder clearSumOfSquares() {
-        
-        sumOfSquares_ = 0D;
-        onChanged();
-        return this;
-      }
-
-      private double count_ ;
-      /**
-       * <code>double count = 6;</code>
-       */
-      public double getCount() {
-        return count_;
-      }
-      /**
-       * <code>double count = 6;</code>
-       */
-      public Builder setCount(double value) {
-        
-        count_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>double count = 6;</code>
-       */
-      public Builder clearCount() {
-        
-        count_ = 0D;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.HistogramData)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.HistogramData)
-    private static final io.grpc.benchmarks.proto.Stats.HistogramData DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Stats.HistogramData();
-    }
-
-    public static io.grpc.benchmarks.proto.Stats.HistogramData getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<HistogramData>
-        PARSER = new com.google.protobuf.AbstractParser<HistogramData>() {
-      public HistogramData parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new HistogramData(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<HistogramData> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<HistogramData> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Stats.HistogramData getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ClientStatsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ClientStats)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Latency histogram. Data points are in nanoseconds.
-     * </pre>
-     *
-     * <code>.grpc.testing.HistogramData latencies = 1;</code>
-     */
-    boolean hasLatencies();
-    /**
-     * <pre>
-     * Latency histogram. Data points are in nanoseconds.
-     * </pre>
-     *
-     * <code>.grpc.testing.HistogramData latencies = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Stats.HistogramData getLatencies();
-    /**
-     * <pre>
-     * Latency histogram. Data points are in nanoseconds.
-     * </pre>
-     *
-     * <code>.grpc.testing.HistogramData latencies = 1;</code>
-     */
-    io.grpc.benchmarks.proto.Stats.HistogramDataOrBuilder getLatenciesOrBuilder();
-
-    /**
-     * <pre>
-     * See ServerStats for details.
-     * </pre>
-     *
-     * <code>double time_elapsed = 2;</code>
-     */
-    double getTimeElapsed();
-
-    /**
-     * <code>double time_user = 3;</code>
-     */
-    double getTimeUser();
-
-    /**
-     * <code>double time_system = 4;</code>
-     */
-    double getTimeSystem();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.ClientStats}
-   */
-  public  static final class ClientStats extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ClientStats)
-      ClientStatsOrBuilder {
-    // Use ClientStats.newBuilder() to construct.
-    private ClientStats(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ClientStats() {
-      timeElapsed_ = 0D;
-      timeUser_ = 0D;
-      timeSystem_ = 0D;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ClientStats(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              io.grpc.benchmarks.proto.Stats.HistogramData.Builder subBuilder = null;
-              if (latencies_ != null) {
-                subBuilder = latencies_.toBuilder();
-              }
-              latencies_ = input.readMessage(io.grpc.benchmarks.proto.Stats.HistogramData.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(latencies_);
-                latencies_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 17: {
-
-              timeElapsed_ = input.readDouble();
-              break;
-            }
-            case 25: {
-
-              timeUser_ = input.readDouble();
-              break;
-            }
-            case 33: {
-
-              timeSystem_ = input.readDouble();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_ClientStats_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_ClientStats_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.benchmarks.proto.Stats.ClientStats.class, io.grpc.benchmarks.proto.Stats.ClientStats.Builder.class);
-    }
-
-    public static final int LATENCIES_FIELD_NUMBER = 1;
-    private io.grpc.benchmarks.proto.Stats.HistogramData latencies_;
-    /**
-     * <pre>
-     * Latency histogram. Data points are in nanoseconds.
-     * </pre>
-     *
-     * <code>.grpc.testing.HistogramData latencies = 1;</code>
-     */
-    public boolean hasLatencies() {
-      return latencies_ != null;
-    }
-    /**
-     * <pre>
-     * Latency histogram. Data points are in nanoseconds.
-     * </pre>
-     *
-     * <code>.grpc.testing.HistogramData latencies = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Stats.HistogramData getLatencies() {
-      return latencies_ == null ? io.grpc.benchmarks.proto.Stats.HistogramData.getDefaultInstance() : latencies_;
-    }
-    /**
-     * <pre>
-     * Latency histogram. Data points are in nanoseconds.
-     * </pre>
-     *
-     * <code>.grpc.testing.HistogramData latencies = 1;</code>
-     */
-    public io.grpc.benchmarks.proto.Stats.HistogramDataOrBuilder getLatenciesOrBuilder() {
-      return getLatencies();
-    }
-
-    public static final int TIME_ELAPSED_FIELD_NUMBER = 2;
-    private double timeElapsed_;
-    /**
-     * <pre>
-     * See ServerStats for details.
-     * </pre>
-     *
-     * <code>double time_elapsed = 2;</code>
-     */
-    public double getTimeElapsed() {
-      return timeElapsed_;
-    }
-
-    public static final int TIME_USER_FIELD_NUMBER = 3;
-    private double timeUser_;
-    /**
-     * <code>double time_user = 3;</code>
-     */
-    public double getTimeUser() {
-      return timeUser_;
-    }
-
-    public static final int TIME_SYSTEM_FIELD_NUMBER = 4;
-    private double timeSystem_;
-    /**
-     * <code>double time_system = 4;</code>
-     */
-    public double getTimeSystem() {
-      return timeSystem_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (latencies_ != null) {
-        output.writeMessage(1, getLatencies());
-      }
-      if (timeElapsed_ != 0D) {
-        output.writeDouble(2, timeElapsed_);
-      }
-      if (timeUser_ != 0D) {
-        output.writeDouble(3, timeUser_);
-      }
-      if (timeSystem_ != 0D) {
-        output.writeDouble(4, timeSystem_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (latencies_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, getLatencies());
-      }
-      if (timeElapsed_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(2, timeElapsed_);
-      }
-      if (timeUser_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(3, timeUser_);
-      }
-      if (timeSystem_ != 0D) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(4, timeSystem_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.benchmarks.proto.Stats.ClientStats)) {
-        return super.equals(obj);
-      }
-      io.grpc.benchmarks.proto.Stats.ClientStats other = (io.grpc.benchmarks.proto.Stats.ClientStats) obj;
-
-      boolean result = true;
-      result = result && (hasLatencies() == other.hasLatencies());
-      if (hasLatencies()) {
-        result = result && getLatencies()
-            .equals(other.getLatencies());
-      }
-      result = result && (
-          java.lang.Double.doubleToLongBits(getTimeElapsed())
-          == java.lang.Double.doubleToLongBits(
-              other.getTimeElapsed()));
-      result = result && (
-          java.lang.Double.doubleToLongBits(getTimeUser())
-          == java.lang.Double.doubleToLongBits(
-              other.getTimeUser()));
-      result = result && (
-          java.lang.Double.doubleToLongBits(getTimeSystem())
-          == java.lang.Double.doubleToLongBits(
-              other.getTimeSystem()));
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      if (hasLatencies()) {
-        hash = (37 * hash) + LATENCIES_FIELD_NUMBER;
-        hash = (53 * hash) + getLatencies().hashCode();
-      }
-      hash = (37 * hash) + TIME_ELAPSED_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getTimeElapsed()));
-      hash = (37 * hash) + TIME_USER_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getTimeUser()));
-      hash = (37 * hash) + TIME_SYSTEM_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-          java.lang.Double.doubleToLongBits(getTimeSystem()));
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.benchmarks.proto.Stats.ClientStats parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ClientStats parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ClientStats parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ClientStats parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ClientStats parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ClientStats parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ClientStats parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ClientStats parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ClientStats parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.benchmarks.proto.Stats.ClientStats parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.benchmarks.proto.Stats.ClientStats prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.ClientStats}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ClientStats)
-        io.grpc.benchmarks.proto.Stats.ClientStatsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_ClientStats_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_ClientStats_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.benchmarks.proto.Stats.ClientStats.class, io.grpc.benchmarks.proto.Stats.ClientStats.Builder.class);
-      }
-
-      // Construct using io.grpc.benchmarks.proto.Stats.ClientStats.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        if (latenciesBuilder_ == null) {
-          latencies_ = null;
-        } else {
-          latencies_ = null;
-          latenciesBuilder_ = null;
-        }
-        timeElapsed_ = 0D;
-
-        timeUser_ = 0D;
-
-        timeSystem_ = 0D;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.benchmarks.proto.Stats.internal_static_grpc_testing_ClientStats_descriptor;
-      }
-
-      public io.grpc.benchmarks.proto.Stats.ClientStats getDefaultInstanceForType() {
-        return io.grpc.benchmarks.proto.Stats.ClientStats.getDefaultInstance();
-      }
-
-      public io.grpc.benchmarks.proto.Stats.ClientStats build() {
-        io.grpc.benchmarks.proto.Stats.ClientStats result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.benchmarks.proto.Stats.ClientStats buildPartial() {
-        io.grpc.benchmarks.proto.Stats.ClientStats result = new io.grpc.benchmarks.proto.Stats.ClientStats(this);
-        if (latenciesBuilder_ == null) {
-          result.latencies_ = latencies_;
-        } else {
-          result.latencies_ = latenciesBuilder_.build();
-        }
-        result.timeElapsed_ = timeElapsed_;
-        result.timeUser_ = timeUser_;
-        result.timeSystem_ = timeSystem_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.benchmarks.proto.Stats.ClientStats) {
-          return mergeFrom((io.grpc.benchmarks.proto.Stats.ClientStats)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.benchmarks.proto.Stats.ClientStats other) {
-        if (other == io.grpc.benchmarks.proto.Stats.ClientStats.getDefaultInstance()) return this;
-        if (other.hasLatencies()) {
-          mergeLatencies(other.getLatencies());
-        }
-        if (other.getTimeElapsed() != 0D) {
-          setTimeElapsed(other.getTimeElapsed());
-        }
-        if (other.getTimeUser() != 0D) {
-          setTimeUser(other.getTimeUser());
-        }
-        if (other.getTimeSystem() != 0D) {
-          setTimeSystem(other.getTimeSystem());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.benchmarks.proto.Stats.ClientStats parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.benchmarks.proto.Stats.ClientStats) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private io.grpc.benchmarks.proto.Stats.HistogramData latencies_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Stats.HistogramData, io.grpc.benchmarks.proto.Stats.HistogramData.Builder, io.grpc.benchmarks.proto.Stats.HistogramDataOrBuilder> latenciesBuilder_;
-      /**
-       * <pre>
-       * Latency histogram. Data points are in nanoseconds.
-       * </pre>
-       *
-       * <code>.grpc.testing.HistogramData latencies = 1;</code>
-       */
-      public boolean hasLatencies() {
-        return latenciesBuilder_ != null || latencies_ != null;
-      }
-      /**
-       * <pre>
-       * Latency histogram. Data points are in nanoseconds.
-       * </pre>
-       *
-       * <code>.grpc.testing.HistogramData latencies = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Stats.HistogramData getLatencies() {
-        if (latenciesBuilder_ == null) {
-          return latencies_ == null ? io.grpc.benchmarks.proto.Stats.HistogramData.getDefaultInstance() : latencies_;
-        } else {
-          return latenciesBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Latency histogram. Data points are in nanoseconds.
-       * </pre>
-       *
-       * <code>.grpc.testing.HistogramData latencies = 1;</code>
-       */
-      public Builder setLatencies(io.grpc.benchmarks.proto.Stats.HistogramData value) {
-        if (latenciesBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          latencies_ = value;
-          onChanged();
-        } else {
-          latenciesBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Latency histogram. Data points are in nanoseconds.
-       * </pre>
-       *
-       * <code>.grpc.testing.HistogramData latencies = 1;</code>
-       */
-      public Builder setLatencies(
-          io.grpc.benchmarks.proto.Stats.HistogramData.Builder builderForValue) {
-        if (latenciesBuilder_ == null) {
-          latencies_ = builderForValue.build();
-          onChanged();
-        } else {
-          latenciesBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Latency histogram. Data points are in nanoseconds.
-       * </pre>
-       *
-       * <code>.grpc.testing.HistogramData latencies = 1;</code>
-       */
-      public Builder mergeLatencies(io.grpc.benchmarks.proto.Stats.HistogramData value) {
-        if (latenciesBuilder_ == null) {
-          if (latencies_ != null) {
-            latencies_ =
-              io.grpc.benchmarks.proto.Stats.HistogramData.newBuilder(latencies_).mergeFrom(value).buildPartial();
-          } else {
-            latencies_ = value;
-          }
-          onChanged();
-        } else {
-          latenciesBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Latency histogram. Data points are in nanoseconds.
-       * </pre>
-       *
-       * <code>.grpc.testing.HistogramData latencies = 1;</code>
-       */
-      public Builder clearLatencies() {
-        if (latenciesBuilder_ == null) {
-          latencies_ = null;
-          onChanged();
-        } else {
-          latencies_ = null;
-          latenciesBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Latency histogram. Data points are in nanoseconds.
-       * </pre>
-       *
-       * <code>.grpc.testing.HistogramData latencies = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Stats.HistogramData.Builder getLatenciesBuilder() {
-        
-        onChanged();
-        return getLatenciesFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Latency histogram. Data points are in nanoseconds.
-       * </pre>
-       *
-       * <code>.grpc.testing.HistogramData latencies = 1;</code>
-       */
-      public io.grpc.benchmarks.proto.Stats.HistogramDataOrBuilder getLatenciesOrBuilder() {
-        if (latenciesBuilder_ != null) {
-          return latenciesBuilder_.getMessageOrBuilder();
-        } else {
-          return latencies_ == null ?
-              io.grpc.benchmarks.proto.Stats.HistogramData.getDefaultInstance() : latencies_;
-        }
-      }
-      /**
-       * <pre>
-       * Latency histogram. Data points are in nanoseconds.
-       * </pre>
-       *
-       * <code>.grpc.testing.HistogramData latencies = 1;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.benchmarks.proto.Stats.HistogramData, io.grpc.benchmarks.proto.Stats.HistogramData.Builder, io.grpc.benchmarks.proto.Stats.HistogramDataOrBuilder> 
-          getLatenciesFieldBuilder() {
-        if (latenciesBuilder_ == null) {
-          latenciesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.benchmarks.proto.Stats.HistogramData, io.grpc.benchmarks.proto.Stats.HistogramData.Builder, io.grpc.benchmarks.proto.Stats.HistogramDataOrBuilder>(
-                  getLatencies(),
-                  getParentForChildren(),
-                  isClean());
-          latencies_ = null;
-        }
-        return latenciesBuilder_;
-      }
-
-      private double timeElapsed_ ;
-      /**
-       * <pre>
-       * See ServerStats for details.
-       * </pre>
-       *
-       * <code>double time_elapsed = 2;</code>
-       */
-      public double getTimeElapsed() {
-        return timeElapsed_;
-      }
-      /**
-       * <pre>
-       * See ServerStats for details.
-       * </pre>
-       *
-       * <code>double time_elapsed = 2;</code>
-       */
-      public Builder setTimeElapsed(double value) {
-        
-        timeElapsed_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * See ServerStats for details.
-       * </pre>
-       *
-       * <code>double time_elapsed = 2;</code>
-       */
-      public Builder clearTimeElapsed() {
-        
-        timeElapsed_ = 0D;
-        onChanged();
-        return this;
-      }
-
-      private double timeUser_ ;
-      /**
-       * <code>double time_user = 3;</code>
-       */
-      public double getTimeUser() {
-        return timeUser_;
-      }
-      /**
-       * <code>double time_user = 3;</code>
-       */
-      public Builder setTimeUser(double value) {
-        
-        timeUser_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>double time_user = 3;</code>
-       */
-      public Builder clearTimeUser() {
-        
-        timeUser_ = 0D;
-        onChanged();
-        return this;
-      }
-
-      private double timeSystem_ ;
-      /**
-       * <code>double time_system = 4;</code>
-       */
-      public double getTimeSystem() {
-        return timeSystem_;
-      }
-      /**
-       * <code>double time_system = 4;</code>
-       */
-      public Builder setTimeSystem(double value) {
-        
-        timeSystem_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>double time_system = 4;</code>
-       */
-      public Builder clearTimeSystem() {
-        
-        timeSystem_ = 0D;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ClientStats)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ClientStats)
-    private static final io.grpc.benchmarks.proto.Stats.ClientStats DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.benchmarks.proto.Stats.ClientStats();
-    }
-
-    public static io.grpc.benchmarks.proto.Stats.ClientStats getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ClientStats>
-        PARSER = new com.google.protobuf.AbstractParser<ClientStats>() {
-      public ClientStats parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ClientStats(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ClientStats> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ClientStats> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.benchmarks.proto.Stats.ClientStats getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ServerStats_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ServerStats_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_HistogramParams_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_HistogramParams_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_HistogramData_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_HistogramData_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ClientStats_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ClientStats_fieldAccessorTable;
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n\013stats.proto\022\014grpc.testing\"K\n\013ServerSta" +
-      "ts\022\024\n\014time_elapsed\030\001 \001(\001\022\021\n\ttime_user\030\002 " +
-      "\001(\001\022\023\n\013time_system\030\003 \001(\001\";\n\017HistogramPar" +
-      "ams\022\022\n\nresolution\030\001 \001(\001\022\024\n\014max_possible\030" +
-      "\002 \001(\001\"w\n\rHistogramData\022\016\n\006bucket\030\001 \003(\r\022\020" +
-      "\n\010min_seen\030\002 \001(\001\022\020\n\010max_seen\030\003 \001(\001\022\013\n\003su" +
-      "m\030\004 \001(\001\022\026\n\016sum_of_squares\030\005 \001(\001\022\r\n\005count" +
-      "\030\006 \001(\001\"{\n\013ClientStats\022.\n\tlatencies\030\001 \001(\013" +
-      "2\033.grpc.testing.HistogramData\022\024\n\014time_el" +
-      "apsed\030\002 \001(\001\022\021\n\ttime_user\030\003 \001(\001\022\023\n\013time_s",
-      "ystem\030\004 \001(\001B!\n\030io.grpc.benchmarks.protoB" +
-      "\005Statsb\006proto3"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-        }, assigner);
-    internal_static_grpc_testing_ServerStats_descriptor =
-      getDescriptor().getMessageTypes().get(0);
-    internal_static_grpc_testing_ServerStats_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ServerStats_descriptor,
-        new java.lang.String[] { "TimeElapsed", "TimeUser", "TimeSystem", });
-    internal_static_grpc_testing_HistogramParams_descriptor =
-      getDescriptor().getMessageTypes().get(1);
-    internal_static_grpc_testing_HistogramParams_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_HistogramParams_descriptor,
-        new java.lang.String[] { "Resolution", "MaxPossible", });
-    internal_static_grpc_testing_HistogramData_descriptor =
-      getDescriptor().getMessageTypes().get(2);
-    internal_static_grpc_testing_HistogramData_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_HistogramData_descriptor,
-        new java.lang.String[] { "Bucket", "MinSeen", "MaxSeen", "Sum", "SumOfSquares", "Count", });
-    internal_static_grpc_testing_ClientStats_descriptor =
-      getDescriptor().getMessageTypes().get(3);
-    internal_static_grpc_testing_ClientStats_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ClientStats_descriptor,
-        new java.lang.String[] { "Latencies", "TimeElapsed", "TimeUser", "TimeSystem", });
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/benchmarks/src/jmh/java/io/grpc/DecompressorRegistryBenchmark.java b/benchmarks/src/jmh/java/io/grpc/DecompressorRegistryBenchmark.java
deleted file mode 100644
index 61a7a56c190..00000000000
--- a/benchmarks/src/jmh/java/io/grpc/DecompressorRegistryBenchmark.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static io.grpc.DecompressorRegistry.ACCEPT_ENCODING_JOINER;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.UUID;
-import java.util.concurrent.TimeUnit;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.BenchmarkMode;
-import org.openjdk.jmh.annotations.Mode;
-import org.openjdk.jmh.annotations.OutputTimeUnit;
-import org.openjdk.jmh.annotations.Param;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
-import org.openjdk.jmh.annotations.State;
-
-/**
- * Decomressor Registry encoding benchmark.
- */
-@State(Scope.Benchmark)
-public class DecompressorRegistryBenchmark {
-
-  @Param({"0", "1", "2"})
-  public int extraEncodings;
-
-  private DecompressorRegistry reg = DecompressorRegistry.getDefaultInstance();
-
-  @Setup
-  public void setUp() throws Exception {
-    reg = DecompressorRegistry.getDefaultInstance();
-    for (int i = 0; i < extraEncodings; i++) {
-      reg = reg.with(new Decompressor() {
-
-        @Override
-        public String getMessageEncoding() {
-          return UUID.randomUUID().toString();
-
-        }
-
-        @Override
-        public InputStream decompress(InputStream is) throws IOException {
-          return null;
-
-        }
-      }, true);
-    }
-  }
-
-  /**
-   * Javadoc comment.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public String dynamicAcceptEncoding() {
-    if (!reg.getAdvertisedMessageEncodings().isEmpty()) {
-      return ACCEPT_ENCODING_JOINER.join(reg.getAdvertisedMessageEncodings());
-    }
-    return "";
-  }
-
-  /**
-   * Javadoc comment.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public String staticAcceptEncoding() {
-    return reg.getRawAdvertisedMessageEncodings();
-  }
-}
-
diff --git a/benchmarks/src/jmh/java/io/grpc/StatusBenchmark.java b/benchmarks/src/jmh/java/io/grpc/StatusBenchmark.java
deleted file mode 100644
index 24740ecf0be..00000000000
--- a/benchmarks/src/jmh/java/io/grpc/StatusBenchmark.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.nio.charset.Charset;
-import java.util.concurrent.TimeUnit;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.BenchmarkMode;
-import org.openjdk.jmh.annotations.Mode;
-import org.openjdk.jmh.annotations.OutputTimeUnit;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.State;
-
-/** StatusBenchmark. */
-@State(Scope.Benchmark)
-public class StatusBenchmark {
-
-  /**
-   * Javadoc comment.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public byte[] messageEncodePlain() {
-    return Status.MESSAGE_KEY.toBytes("Unexpected RST in stream");
-  }
-
-  /**
-   * Javadoc comment.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public byte[] messageEncodeEscape() {
-    return Status.MESSAGE_KEY.toBytes("Some Error\nWasabi and Horseradish are the same");
-  }
-
-  /**
-   * Javadoc comment.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public String messageDecodePlain() {
-    return Status.MESSAGE_KEY.parseBytes(
-        "Unexpected RST in stream".getBytes(Charset.forName("US-ASCII")));
-  }
-
-  /**
-   * Javadoc comment.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public String messageDecodeEscape() {
-    return Status.MESSAGE_KEY.parseBytes(
-        "Some Error%10Wasabi and Horseradish are the same".getBytes(Charset.forName("US-ASCII")));
-  }
-
-  /**
-   * Javadoc comment.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public byte[] codeEncode() {
-    return Status.CODE_KEY.toBytes(Status.DATA_LOSS);
-  }
-
-  /**
-   * Javadoc comment.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public Status codeDecode() {
-    return Status.CODE_KEY.parseBytes("15".getBytes(Charset.forName("US-ASCII")));
-  }
-}
-
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/CallOptionsBenchmark.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/CallOptionsBenchmark.java
deleted file mode 100644
index cf9a4b5d721..00000000000
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/CallOptionsBenchmark.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.benchmarks;
-
-import io.grpc.CallOptions;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.TimeUnit;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.BenchmarkMode;
-import org.openjdk.jmh.annotations.Mode;
-import org.openjdk.jmh.annotations.OutputTimeUnit;
-import org.openjdk.jmh.annotations.Param;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
-import org.openjdk.jmh.annotations.State;
-
-/**
- * Call options benchmark.
- */
-@State(Scope.Benchmark)
-public class CallOptionsBenchmark {
-
-  @Param({"1", "2", "4", "8"})
-  public int customOptionsCount;
-
-  private List<CallOptions.Key<String>> customOptions;
-
-  private CallOptions allOpts;
-  private List<CallOptions.Key<String>> shuffledCustomOptions;
-
-  /**
-   * Setup.
-   */
-  @Setup
-  public void setUp() throws Exception {
-    customOptions = new ArrayList<CallOptions.Key<String>>(customOptionsCount);
-    for (int i = 0; i < customOptionsCount; i++) {
-      customOptions.add(CallOptions.Key.of("name " + i, "defaultvalue"));
-    }
-
-    allOpts = CallOptions.DEFAULT;
-    for (int i = 0; i < customOptionsCount; i++) {
-      allOpts = allOpts.withOption(customOptions.get(i), "value");
-    }
-
-    shuffledCustomOptions = new ArrayList<CallOptions.Key<String>>(customOptions);
-    // Make the shuffling deterministic
-    Collections.shuffle(shuffledCustomOptions, new Random(1));
-  }
-
-  /**
-   * Adding custom call options without duplicate keys.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public CallOptions withOption() {
-    CallOptions opts = CallOptions.DEFAULT;
-    for (int i = 0; i < customOptions.size(); i++) {
-      opts = opts.withOption(customOptions.get(i), "value");
-    }
-    return opts;
-  }
-
-  /**
-   * Adding custom call options, overwritting existing keys.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public CallOptions withOptionDuplicates() {
-    CallOptions opts = allOpts;
-    for (int i = 1; i < shuffledCustomOptions.size(); i++) {
-      opts = opts.withOption(shuffledCustomOptions.get(i), "value2");
-    }
-    return opts;
-  }
-}
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/CancellableInterceptor.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/CancellableInterceptor.java
new file mode 100644
index 00000000000..97d81830818
--- /dev/null
+++ b/benchmarks/src/jmh/java/io/grpc/benchmarks/CancellableInterceptor.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2018, gRPC Authors All rights reserved.
+ *
+ * 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.benchmarks;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.MethodDescriptor;
+
+/** Interceptor that lets you cancel the most recent call made. This class is not thread-safe. */
+class CancellableInterceptor implements ClientInterceptor {
+  private ClientCall<?, ?> call;
+
+  @Override
+  public <ReqT,RespT> ClientCall<ReqT,RespT> interceptCall(
+      MethodDescriptor<ReqT,RespT> method, CallOptions callOptions, Channel next) {
+    ClientCall<ReqT, RespT> call = next.newCall(method, callOptions);
+    this.call = call;
+    return call;
+  }
+
+  public void cancel(String message, Throwable cause) {
+    if (call == null) {
+      throw new NullPointerException("No previous call");
+    }
+    call.cancel(message, cause);
+  }
+}
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/ThreadlessExecutor.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/ThreadlessExecutor.java
new file mode 100644
index 00000000000..3c566e24ff9
--- /dev/null
+++ b/benchmarks/src/jmh/java/io/grpc/benchmarks/ThreadlessExecutor.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2018, gRPC Authors All rights reserved.
+ *
+ * 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.benchmarks;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Executor;
+import java.util.concurrent.LinkedBlockingQueue;
+
+final class ThreadlessExecutor implements Executor {
+  private final BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();
+
+  /**
+   * Waits until there is a Runnable, then executes it and all queued Runnables after it.
+   */
+  public void waitAndDrain() throws InterruptedException {
+    Runnable runnable = queue.take();
+    while (runnable != null) {
+      try {
+        runnable.run();
+      } catch (Throwable t) {
+        throw new RuntimeException("Runnable threw exception", t);
+      }
+      runnable = queue.poll();
+    }
+  }
+
+  @Override
+  public void execute(Runnable runnable) {
+    queue.add(runnable);
+  }
+}
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/TransportBenchmark.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/TransportBenchmark.java
index 2614e3b96fc..d0de1571a59 100644
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/TransportBenchmark.java
+++ b/benchmarks/src/jmh/java/io/grpc/benchmarks/TransportBenchmark.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks;
@@ -34,8 +19,15 @@
 import static io.grpc.benchmarks.Utils.pickUnusedPort;
 
 import com.google.protobuf.ByteString;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
 import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
 import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCredentials;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
 import io.grpc.benchmarks.proto.BenchmarkServiceGrpc;
 import io.grpc.benchmarks.proto.Messages.Payload;
 import io.grpc.benchmarks.proto.Messages.SimpleRequest;
@@ -43,30 +35,33 @@
 import io.grpc.benchmarks.qps.AsyncServer;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
-import io.grpc.internal.AbstractManagedChannelImplBuilder;
-import io.grpc.internal.AbstractServerImplBuilder;
 import io.grpc.netty.NegotiationType;
 import io.grpc.netty.NettyChannelBuilder;
 import io.grpc.netty.NettyServerBuilder;
 import io.grpc.okhttp.OkHttpChannelBuilder;
+import io.grpc.stub.StreamObserver;
 import io.netty.channel.Channel;
+import io.netty.channel.DefaultEventLoopGroup;
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.ServerChannel;
 import io.netty.channel.local.LocalAddress;
 import io.netty.channel.local.LocalChannel;
 import io.netty.channel.local.LocalServerChannel;
 import java.net.InetSocketAddress;
+import java.util.Iterator;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
 import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OperationsPerInvocation;
 import org.openjdk.jmh.annotations.OutputTimeUnit;
 import org.openjdk.jmh.annotations.Param;
 import org.openjdk.jmh.annotations.Scope;
 import org.openjdk.jmh.annotations.Setup;
 import org.openjdk.jmh.annotations.State;
 import org.openjdk.jmh.annotations.TearDown;
+import org.openjdk.jmh.annotations.Threads;
 
 /** Some text. */
 @State(Scope.Benchmark)
@@ -75,7 +70,7 @@ public enum Transport {
     INPROCESS, NETTY, NETTY_LOCAL, NETTY_EPOLL, OKHTTP
   }
 
-  @Param({"INPROCESS", "NETTY", "NETTY_LOCAL", "OKHTTP"})
+  @Param({"INPROCESS", "NETTY", "OKHTTP"})
   public Transport transport;
   @Param({"true", "false"})
   public boolean direct;
@@ -83,71 +78,73 @@ public enum Transport {
   private ManagedChannel channel;
   private Server server;
   private BenchmarkServiceGrpc.BenchmarkServiceBlockingStub stub;
-  private volatile EventLoopGroup groupToShutdown;
+  private BenchmarkServiceGrpc.BenchmarkServiceStub asyncStub;
+  private EventLoopGroup groupToShutdown;
 
   @Setup
   public void setUp() throws Exception {
-    AbstractServerImplBuilder<?> serverBuilder;
-    AbstractManagedChannelImplBuilder<?> channelBuilder;
+    ServerCredentials serverCreds = InsecureServerCredentials.create();
+    ServerBuilder<?> serverBuilder;
+    ManagedChannelBuilder<?> channelBuilder;
     switch (transport) {
-      case INPROCESS:
-      {
+      case INPROCESS: {
         String name = "bench" + Math.random();
         serverBuilder = InProcessServerBuilder.forName(name);
         channelBuilder = InProcessChannelBuilder.forName(name);
         break;
       }
-      case NETTY:
-      {
+      case NETTY: {
         InetSocketAddress address = new InetSocketAddress("localhost", pickUnusedPort());
-        serverBuilder = NettyServerBuilder.forAddress(address);
+        serverBuilder = NettyServerBuilder.forAddress(address, serverCreds);
         channelBuilder = NettyChannelBuilder.forAddress(address)
             .negotiationType(NegotiationType.PLAINTEXT);
         break;
       }
-      case NETTY_LOCAL:
-      {
+      case NETTY_LOCAL: {
         String name = "bench" + Math.random();
         LocalAddress address = new LocalAddress(name);
-        serverBuilder = NettyServerBuilder.forAddress(address)
+        EventLoopGroup group = new DefaultEventLoopGroup();
+        serverBuilder = NettyServerBuilder.forAddress(address, serverCreds)
+            .bossEventLoopGroup(group)
+            .workerEventLoopGroup(group)
             .channelType(LocalServerChannel.class);
         channelBuilder = NettyChannelBuilder.forAddress(address)
-            .channelType(LocalChannel.class)
+            .eventLoopGroup(group)
+            .channelType(LocalChannel.class, LocalAddress.class)
             .negotiationType(NegotiationType.PLAINTEXT);
+        groupToShutdown = group;
         break;
       }
-      case NETTY_EPOLL:
-      {
+      case NETTY_EPOLL: {
         InetSocketAddress address = new InetSocketAddress("localhost", pickUnusedPort());
 
         // Reflection used since they are only available on linux.
         Class<?> groupClass = Class.forName("io.netty.channel.epoll.EpollEventLoopGroup");
         EventLoopGroup group = (EventLoopGroup) groupClass.getConstructor().newInstance();
 
-        @SuppressWarnings("unchecked")
-        Class<? extends ServerChannel> serverChannelClass = (Class<? extends ServerChannel>)
-            Class.forName("io.netty.channel.epoll.EpollServerSocketChannel");
-        serverBuilder = NettyServerBuilder.forAddress(address)
+        Class<? extends ServerChannel> serverChannelClass =
+            Class.forName("io.netty.channel.epoll.EpollServerSocketChannel")
+              .asSubclass(ServerChannel.class);
+        serverBuilder = NettyServerBuilder.forAddress(address, serverCreds)
             .bossEventLoopGroup(group)
             .workerEventLoopGroup(group)
             .channelType(serverChannelClass);
-        @SuppressWarnings("unchecked")
-        Class<? extends Channel> channelClass = (Class<? extends Channel>)
-            Class.forName("io.netty.channel.epoll.EpollSocketChannel");
+        Class<? extends Channel> channelClass =
+            Class.forName("io.netty.channel.epoll.EpollSocketChannel")
+              .asSubclass(Channel.class);
         channelBuilder = NettyChannelBuilder.forAddress(address)
             .eventLoopGroup(group)
-            .channelType(channelClass)
+            .channelType(channelClass, InetSocketAddress.class)
             .negotiationType(NegotiationType.PLAINTEXT);
         groupToShutdown = group;
         break;
       }
-      case OKHTTP:
-      {
+      case OKHTTP: {
         int port = pickUnusedPort();
         InetSocketAddress address = new InetSocketAddress("localhost", port);
-        serverBuilder = NettyServerBuilder.forAddress(address);
-        channelBuilder = OkHttpChannelBuilder.forAddress("localhost", port)
-            .negotiationType(io.grpc.okhttp.NegotiationType.PLAINTEXT);
+        serverBuilder = NettyServerBuilder.forAddress(address, serverCreds);
+        channelBuilder = OkHttpChannelBuilder
+            .forAddress("localhost", port, InsecureChannelCredentials.create());
         break;
       }
       default:
@@ -166,6 +163,7 @@ public void setUp() throws Exception {
     server.start();
     channel = channelBuilder.build();
     stub = BenchmarkServiceGrpc.newBlockingStub(channel);
+    asyncStub = BenchmarkServiceGrpc.newStub(channel);
     // Wait for channel to start
     stub.unaryCall(SimpleRequest.getDefaultInstance());
   }
@@ -191,7 +189,7 @@ public void tearDown() throws Exception {
     }
   }
 
-  private SimpleRequest simpleRequest = SimpleRequest.newBuilder()
+  private static final SimpleRequest UNARY_CALL_1024_REQUEST = SimpleRequest.newBuilder()
       .setResponseSize(1024)
       .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[1024])))
       .build();
@@ -199,7 +197,129 @@ public void tearDown() throws Exception {
   @Benchmark
   @BenchmarkMode(Mode.SampleTime)
   @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public SimpleResponse unaryCall1024() {
-    return stub.unaryCall(simpleRequest);
+  public SimpleResponse unaryCall1024Latency() {
+    return stub.unaryCall(UNARY_CALL_1024_REQUEST);
+  }
+
+  private static final int BYTE_THROUGHPUT_RESPONSE_SIZE = 1048576;
+  private static final SimpleRequest BYTE_THROUGHPUT_REQUEST = SimpleRequest.newBuilder()
+      .setResponseSize(BYTE_THROUGHPUT_RESPONSE_SIZE)
+      .build();
+
+  @Benchmark
+  @BenchmarkMode(Mode.Throughput)
+  @OperationsPerInvocation(BYTE_THROUGHPUT_RESPONSE_SIZE)
+  @Threads(10)
+  public SimpleResponse unaryCallsByteThroughput() {
+    return stub.unaryCall(BYTE_THROUGHPUT_REQUEST);
+  }
+
+  @SuppressWarnings("StaticAssignmentOfThrowable")
+  private static final Throwable OK_THROWABLE = new RuntimeException("OK");
+
+  @State(Scope.Thread)
+  public static class PingPongStreamState {
+    private final ThreadlessExecutor executor = new ThreadlessExecutor();
+    private StreamObserver<SimpleRequest> requestObserver;
+    private SimpleResponse response;
+    private Throwable status;
+
+    @Setup
+    public void setUp(TransportBenchmark bench) {
+      requestObserver = bench.asyncStub
+          .withExecutor(executor)
+          .streamingCall(new StreamObserver<SimpleResponse>() {
+            @Override public void onNext(SimpleResponse next) {
+              assert response == null;
+              response = next;
+            }
+
+            @Override public void onError(Throwable t) {
+              status = t;
+            }
+
+            @Override public void onCompleted() {
+              status = OK_THROWABLE;
+            }
+          });
+    }
+
+    /** Issues request and waits for response. */
+    public SimpleResponse pingPong(SimpleRequest request) throws InterruptedException {
+      requestObserver.onNext(request);
+      while (true) {
+        executor.waitAndDrain();
+        if (response != null) {
+          SimpleResponse savedResponse = response;
+          response = null;
+          return savedResponse;
+        }
+        if (status != null) {
+          throw new RuntimeException("Unexpected stream termination", status);
+        }
+      }
+    }
+
+    @TearDown
+    public void tearDown() throws InterruptedException {
+      requestObserver.onCompleted();
+      while (status == null) {
+        executor.waitAndDrain();
+      }
+      if (status != OK_THROWABLE) {
+        throw new RuntimeException("Non-graceful stream shutdown", status);
+      }
+    }
+  }
+
+  @Benchmark
+  @BenchmarkMode(Mode.Throughput)
+  @OperationsPerInvocation(BYTE_THROUGHPUT_RESPONSE_SIZE)
+  @Threads(10)
+  public SimpleResponse streamingCallsByteThroughput(PingPongStreamState state)
+      throws InterruptedException {
+    return state.pingPong(BYTE_THROUGHPUT_REQUEST);
+  }
+
+  @State(Scope.Thread)
+  public static class InfiniteStreamState {
+    private final CancellableInterceptor cancellableInterceptor = new CancellableInterceptor();
+    private Iterator<SimpleResponse> iter;
+
+    @Setup
+    public void setUp(TransportBenchmark bench) {
+      iter = bench.stub
+          .withInterceptors(cancellableInterceptor)
+          .streamingFromServer(SimpleRequest.getDefaultInstance());
+    }
+
+    public SimpleResponse recv() throws InterruptedException {
+      return iter.next();
+    }
+
+    @TearDown
+    public void tearDown() throws InterruptedException {
+      cancellableInterceptor.cancel("Normal tear-down", null);
+      try {
+        // Need to drain the queue
+        while (iter.hasNext()) {
+          iter.next();
+        }
+      } catch (StatusRuntimeException ex) {
+        if (!Status.Code.CANCELLED.equals(ex.getStatus().getCode())) {
+          throw ex;
+        }
+      }
+    }
+  }
+
+  // NOTE: Causes OOM with NETTY_LOCAL. Probably a flow control problem in NETTY_LOCAL, but we
+  // aren't too concerned.
+  @Benchmark
+  @BenchmarkMode(Mode.Throughput)
+  @Threads(10)
+  public SimpleResponse streamingCallsMessageThroughput(InfiniteStreamState state)
+      throws InterruptedException {
+    return state.recv();
   }
 }
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/AbstractBenchmark.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/AbstractBenchmark.java
index 325dc0fe93d..6d8a9ec8a8e 100644
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/AbstractBenchmark.java
+++ b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/AbstractBenchmark.java
@@ -1,38 +1,24 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.netty;
 
 import io.grpc.CallOptions;
 import io.grpc.ClientCall;
+import io.grpc.InsecureServerCredentials;
 import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
@@ -40,6 +26,7 @@
 import io.grpc.Server;
 import io.grpc.ServerCall;
 import io.grpc.ServerCallHandler;
+import io.grpc.ServerCredentials;
 import io.grpc.ServerServiceDefinition;
 import io.grpc.ServiceDescriptor;
 import io.grpc.Status;
@@ -55,6 +42,8 @@
 import io.netty.channel.local.LocalChannel;
 import io.netty.channel.local.LocalServerChannel;
 import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
 import io.netty.util.concurrent.DefaultThreadFactory;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
@@ -89,6 +78,7 @@ public enum MessageSize {
     SMALL(10), MEDIUM(1024), LARGE(65536), JUMBO(1048576);
 
     private final int bytes;
+
     MessageSize(int bytes) {
       this.bytes = bytes;
     }
@@ -105,6 +95,7 @@ public enum FlowWindowSize {
     SMALL(16383), MEDIUM(65535), LARGE(1048575), JUMBO(8388607);
 
     private final int bytes;
+
     FlowWindowSize(int bytes) {
       this.bytes = bytes;
     }
@@ -150,6 +141,7 @@ public enum ChannelType {
    * sudo ip addr add dev lo 127.127.127.127/32 label lo:benchmark
    * </pre>
    */
+  @SuppressWarnings("JdkObsolete") // No choice but to use Enumeration
   private static InetAddress buildBenchmarkAddr() {
     InetAddress tmp = null;
     try {
@@ -193,7 +185,7 @@ private static InetAddress buildBenchmarkAddr() {
   private MethodDescriptor<ByteBuf, ByteBuf> flowControlledStreaming;
   protected ManagedChannel[] channels;
 
-  public AbstractBenchmark() {
+  protected AbstractBenchmark() {
   }
 
   /**
@@ -207,22 +199,25 @@ public void setup(ExecutorType clientExecutor,
                     ChannelType channelType,
                     int maxConcurrentStreams,
                     int channelCount) throws Exception {
+    ServerCredentials serverCreds = InsecureServerCredentials.create();
     NettyServerBuilder serverBuilder;
     NettyChannelBuilder channelBuilder;
     if (channelType == ChannelType.LOCAL) {
       LocalAddress address = new LocalAddress("netty-e2e-benchmark");
-      serverBuilder = NettyServerBuilder.forAddress(address);
+      serverBuilder = NettyServerBuilder.forAddress(address, serverCreds);
       serverBuilder.channelType(LocalServerChannel.class);
       channelBuilder = NettyChannelBuilder.forAddress(address);
-      channelBuilder.channelType(LocalChannel.class);
+      channelBuilder.channelType(LocalChannel.class, LocalAddress.class);
     } else {
       ServerSocket sock = new ServerSocket();
       // Pick a port using an ephemeral socket.
       sock.bind(new InetSocketAddress(BENCHMARK_ADDR, 0));
       SocketAddress address = sock.getLocalSocketAddress();
       sock.close();
-      serverBuilder = NettyServerBuilder.forAddress(address);
-      channelBuilder = NettyChannelBuilder.forAddress(address);
+      serverBuilder = NettyServerBuilder.forAddress(address, serverCreds)
+          .channelType(NioServerSocketChannel.class);
+      channelBuilder = NettyChannelBuilder.forAddress(address).channelType(NioSocketChannel.class,
+          InetSocketAddress.class);
     }
 
     if (serverExecutor == ExecutorType.DIRECT) {
@@ -235,6 +230,7 @@ public void setup(ExecutorType clientExecutor,
     // Always use a different worker group from the client.
     ThreadFactory serverThreadFactory = new DefaultThreadFactory("STF pool", true /* daemon */);
     serverBuilder.workerEventLoopGroup(new NioEventLoopGroup(0, serverThreadFactory));
+    serverBuilder.bossEventLoopGroup(new NioEventLoopGroup(1, serverThreadFactory));
 
     // Always set connection and stream window size to same value
     serverBuilder.flowControlWindow(windowSize.bytes());
@@ -447,7 +443,7 @@ protected CountDownLatch startStreamingCalls(int callsPerChannel, final AtomicLo
         final ClientCall<ByteBuf, ByteBuf> streamingCall =
             channel.newCall(pingPongMethod, CALL_OPTIONS);
         final AtomicReference<StreamObserver<ByteBuf>> requestObserverRef =
-            new AtomicReference<StreamObserver<ByteBuf>>();
+            new AtomicReference<>();
         final AtomicBoolean ignoreMessages = new AtomicBoolean();
         StreamObserver<ByteBuf> requestObserver = ClientCalls.asyncBidiStreamingCall(
             streamingCall,
@@ -501,7 +497,7 @@ protected CountDownLatch startFlowControlledStreamingCalls(int callsPerChannel,
         final ClientCall<ByteBuf, ByteBuf> streamingCall =
             channel.newCall(flowControlledStreaming, CALL_OPTIONS);
         final AtomicReference<StreamObserver<ByteBuf>> requestObserverRef =
-            new AtomicReference<StreamObserver<ByteBuf>>();
+            new AtomicReference<>();
         final AtomicBoolean ignoreMessages = new AtomicBoolean();
         StreamObserver<ByteBuf> requestObserver = ClientCalls.asyncBidiStreamingCall(
             streamingCall,
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/FlowControlledMessagesPerSecondBenchmark.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/FlowControlledMessagesPerSecondBenchmark.java
deleted file mode 100644
index 3b4dcf9ea13..00000000000
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/FlowControlledMessagesPerSecondBenchmark.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.benchmarks.netty;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.logging.Logger;
-import org.openjdk.jmh.annotations.AuxCounters;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.Fork;
-import org.openjdk.jmh.annotations.Level;
-import org.openjdk.jmh.annotations.Param;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
-import org.openjdk.jmh.annotations.State;
-import org.openjdk.jmh.annotations.TearDown;
-
-/**
- * Benchmark measuring messages per second received from a streaming server. The server
- * is obeying outbound flow-control.
- */
-@State(Scope.Benchmark)
-@Fork(1)
-public class FlowControlledMessagesPerSecondBenchmark extends AbstractBenchmark {
-
-  private static final Logger logger =
-      Logger.getLogger(FlowControlledMessagesPerSecondBenchmark.class.getName());
-
-  @Param({"1", "2", "4"})
-  public int channelCount = 1;
-
-  @Param({"1", "2", "10", "100"})
-  public int maxConcurrentStreams = 1;
-
-  @Param
-  public ExecutorType clientExecutor = ExecutorType.DIRECT;
-
-  @Param({"SMALL"})
-  public MessageSize responseSize = MessageSize.SMALL;
-
-  private static AtomicLong callCounter;
-  private AtomicBoolean completed;
-  private AtomicBoolean record;
-  private CountDownLatch latch;
-
-  /**
-   * Use an AuxCounter so we can measure that calls as they occur without consuming CPU
-   * in the benchmark method.
-   */
-  @AuxCounters
-  @State(Scope.Thread)
-  public static class AdditionalCounters {
-
-    @Setup(Level.Iteration)
-    public void clean() {
-      callCounter.set(0);
-    }
-
-    public long messagesPerSecond() {
-      return callCounter.get();
-    }
-  }
-
-  /**
-   * Setup with direct executors, small payloads and the default flow-control window.
-   */
-  @Setup(Level.Trial)
-  public void setup() throws Exception {
-    super.setup(clientExecutor,
-        ExecutorType.DIRECT,
-        MessageSize.SMALL,
-        responseSize,
-        FlowWindowSize.MEDIUM,
-        ChannelType.NIO,
-        maxConcurrentStreams,
-        channelCount);
-    callCounter = new AtomicLong();
-    completed = new AtomicBoolean();
-    record = new AtomicBoolean();
-    latch =
-        startFlowControlledStreamingCalls(maxConcurrentStreams, callCounter, record, completed, 1);
-  }
-
-  /**
-   * Stop the running calls then stop the server and client channels.
-   */
-  @Override
-  @TearDown(Level.Trial)
-  public void teardown() throws Exception {
-    completed.set(true);
-    if (!latch.await(5, TimeUnit.SECONDS)) {
-      logger.warning("Failed to shutdown all calls.");
-    }
-
-    super.teardown();
-  }
-
-  /**
-   * Measure the rate of messages received. The calls are already running, we just observe a counter
-   * of received responses.
-   */
-  @Benchmark
-  public void stream(AdditionalCounters counters) throws Exception {
-    record.set(true);
-    // No need to do anything, just sleep here.
-    Thread.sleep(1001);
-    record.set(false);
-  }
-
-  /**
-   * Useful for triggering a subset of the benchmark in a profiler.
-   */
-  public static void main(String[] argv) throws Exception {
-    FlowControlledMessagesPerSecondBenchmark bench = new FlowControlledMessagesPerSecondBenchmark();
-    bench.setup();
-    Thread.sleep(30000);
-    bench.teardown();
-    System.exit(0);
-  }
-}
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/HandlerRegistryBenchmark.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/HandlerRegistryBenchmark.java
deleted file mode 100644
index 7c00056b92e..00000000000
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/HandlerRegistryBenchmark.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.benchmarks.netty;
-
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.ServerCall;
-import io.grpc.ServerCall.Listener;
-import io.grpc.ServerCallHandler;
-import io.grpc.ServerServiceDefinition;
-import io.grpc.ServiceDescriptor;
-import io.grpc.testing.TestMethodDescriptors;
-import io.grpc.util.MutableHandlerRegistry;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.Fork;
-import org.openjdk.jmh.annotations.Level;
-import org.openjdk.jmh.annotations.Param;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
-import org.openjdk.jmh.annotations.State;
-import org.openjdk.jmh.infra.Blackhole;
-
-/**
- * Benchmark for {@link MutableHandlerRegistry}.
- */
-@State(Scope.Benchmark)
-@Fork(1)
-public class HandlerRegistryBenchmark {
-
-  private static final String VALID_CHARACTERS =
-          "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.";
-
-  @Param({"50"})
-  public int nameLength;
-
-  @Param({"100"})
-  public int serviceCount;
-
-  @Param({"100"})
-  public int methodCountPerService;
-
-  private MutableHandlerRegistry registry;
-  private List<String> fullMethodNames;
-
-  /**
-   * Set up the registry.
-   */
-  @Setup(Level.Trial)
-  public void setup() throws Exception {
-    registry = new MutableHandlerRegistry();
-    fullMethodNames = new ArrayList<String>(serviceCount * methodCountPerService);
-    for (int serviceIndex = 0; serviceIndex < serviceCount; ++serviceIndex) {
-      String serviceName = randomString();
-      ServerServiceDefinition.Builder serviceBuilder = ServerServiceDefinition.builder(
-          new ServiceDescriptor(serviceName));
-      for (int methodIndex = 0; methodIndex < methodCountPerService; ++methodIndex) {
-        String methodName = randomString();
-
-        MethodDescriptor<Void, Void> methodDescriptor = MethodDescriptor.<Void, Void>newBuilder()
-            .setType(MethodDescriptor.MethodType.UNKNOWN)
-            .setFullMethodName(MethodDescriptor.generateFullMethodName(serviceName, methodName))
-            .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
-            .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
-            .build();
-        serviceBuilder.addMethod(methodDescriptor,
-            new ServerCallHandler<Void, Void>() {
-              @Override
-              public Listener<Void> startCall(ServerCall<Void, Void> call,
-                  Metadata headers) {
-                return null;
-              }
-            });
-        fullMethodNames.add(methodDescriptor.getFullMethodName());
-      }
-      registry.addService(serviceBuilder.build());
-    }
-  }
-
-  /**
-   * Benchmark the {@link MutableHandlerRegistry#lookupMethod(String)} throughput.
-   */
-  @Benchmark
-  public void lookupMethod(Blackhole bh) {
-    for (String fullMethodName : fullMethodNames) {
-      bh.consume(registry.lookupMethod(fullMethodName));
-    }
-  }
-
-  private String randomString() {
-    Random r = new Random();
-    char[] bytes = new char[nameLength];
-    for (int ix = 0; ix < nameLength; ++ix) {
-      int charIx = r.nextInt(VALID_CHARACTERS.length());
-      bytes[ix] = VALID_CHARACTERS.charAt(charIx);
-    }
-    return new String(bytes);
-  }
-}
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/README.md b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/README.md
deleted file mode 100644
index ae594ff311c..00000000000
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/README.md
+++ /dev/null
@@ -1,45 +0,0 @@
-Benchmarks
-==========
-
-This directory contains the standard benchmarks used to assess the performance of GRPC. Since these
-benchmarks run on localhost over loopback the performance of the underlying network is considerably
-different to real networks and their behavior. To address this issue we recommend the use of
-a network emulator to make loopback behave more like a real network. To this end the benchmark
-code looks for a loopback interface with 'benchmark' in its name and attempts to use the address
-bound to that interface when creating the client and server. If it cannot find such an interface it
-will print a warning and continue with the default localhost address.
-
-To attempt to standardize benchmark behavior across machines we attempt to emulate a 10gbit
-ethernet interface with a packet delay of 0.1ms.
-
-
-Linux
-=====
-
-On Linux we can use [netem](http://www.linuxfoundation.org/collaborate/workgroups/networking/netem)  to shape the traffic appropriately.
-
-```sh
-# Remove all traffic shaping from loopback
-sudo tc qdisc del dev lo root
-# Add a priority traffic class to the root of loopback
-sudo tc qdisc add dev lo root handle 1: prio
-# Add a qdisc under the new class with the appropriate shaping
-sudo tc qdisc add dev lo parent 1:1 handle 2: netem delay 0.1ms rate 10gbit
-# Add a filter which selects the new qdisc class for traffic to 127.127.127.127
-sudo tc filter add dev lo parent 1:0 protocol ip prio 1 u32 match ip dst 127.127.127.127 flowid 2:1
-# Create an interface alias call 'lo:benchmark' that maps 127.127.127.127 to loopback
-sudo ip addr add dev lo 127.127.127.127/32 label lo:benchmark
-```
-
-to remove this configuration
-
-```sh
-sudo tc qdisc del dev lo root
-sudo ip addr del dev lo 127.127.127.127/32 label lo:benchmark
-```
-
-Other Platforms
-===============
-
-Contributions welcome!
-
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/SingleThreadBlockingQpsBenchmark.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/SingleThreadBlockingQpsBenchmark.java
deleted file mode 100644
index 3ad482edc68..00000000000
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/SingleThreadBlockingQpsBenchmark.java
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.benchmarks.netty;
-
-import io.grpc.CallOptions;
-import io.grpc.stub.ClientCalls;
-import io.netty.buffer.Unpooled;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.Fork;
-import org.openjdk.jmh.annotations.Level;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
-import org.openjdk.jmh.annotations.State;
-import org.openjdk.jmh.annotations.TearDown;
-
-/**
- * Benchmark showing performance of a linear sequence of blocking calls in a single thread which
- * is the worst case for throughput. The benchmark permutes response payload size and
- * client inbound flow-control window size.
- */
-@State(Scope.Benchmark)
-@Fork(1)
-public class SingleThreadBlockingQpsBenchmark extends AbstractBenchmark {
-
-  /**
-   * Setup with direct executors, small payloads and the default flow control window.
-   */
-  @Setup(Level.Trial)
-  public void setup() throws Exception {
-    super.setup(ExecutorType.DIRECT,
-        ExecutorType.DIRECT,
-        MessageSize.SMALL,
-        MessageSize.SMALL,
-        FlowWindowSize.MEDIUM,
-        ChannelType.NIO,
-        1,
-        1);
-  }
-
-  /**
-   * Stop the server and client channels.
-   */
-  @Override
-  @TearDown(Level.Trial)
-  public void teardown() throws Exception {
-    Thread.sleep(5000);
-    super.teardown();
-  }
-
-  /**
-   * Issue a unary call and wait for the response.
-   */
-  @Benchmark
-  public void blockingUnary() throws Exception {
-    ClientCalls.blockingUnaryCall(
-        channels[0].newCall(unaryMethod, CallOptions.DEFAULT), Unpooled.EMPTY_BUFFER);
-  }
-
-  /**
-   * Useful for triggering a subset of the benchmark in a profiler.
-   */
-  public static void main(String[] argv) throws Exception {
-    SingleThreadBlockingQpsBenchmark bench = new SingleThreadBlockingQpsBenchmark();
-    bench.setup();
-    for  (int i = 0; i < 10000; i++) {
-      bench.blockingUnary();
-    }
-    Thread.sleep(30000);
-    bench.teardown();
-    System.exit(0);
-  }
-}
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/StreamingPingPongsPerSecondBenchmark.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/StreamingPingPongsPerSecondBenchmark.java
index 787121ff855..1b56b769f7a 100644
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/StreamingPingPongsPerSecondBenchmark.java
+++ b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/StreamingPingPongsPerSecondBenchmark.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.netty;
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/StreamingResponseBandwidthBenchmark.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/StreamingResponseBandwidthBenchmark.java
deleted file mode 100644
index cd0403c11f3..00000000000
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/StreamingResponseBandwidthBenchmark.java
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.benchmarks.netty;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
-import org.openjdk.jmh.annotations.AuxCounters;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.Fork;
-import org.openjdk.jmh.annotations.Level;
-import org.openjdk.jmh.annotations.Param;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
-import org.openjdk.jmh.annotations.State;
-import org.openjdk.jmh.annotations.TearDown;
-
-/**
- * Benchmark intended to test response bandwidth in bytes/sec for streaming calls by permuting
- * payload size and flow-control windows with number of concurrent calls. Async stubs are used
- * to avoid context-switching overheads.
- */
-@State(Scope.Benchmark)
-@Fork(1)
-public class StreamingResponseBandwidthBenchmark extends AbstractBenchmark {
-
-  @Param({"1", "10"})
-  public int maxConcurrentStreams = 1;
-
-  @Param({"LARGE", "JUMBO"})
-  public MessageSize responseSize = MessageSize.JUMBO;
-
-  @Param({"MEDIUM", "LARGE", "JUMBO"})
-  public FlowWindowSize clientInboundFlowWindow = FlowWindowSize.MEDIUM;
-
-  private static AtomicLong callCounter;
-  private AtomicBoolean completed;
-  private AtomicBoolean record;
-  private CountDownLatch latch;
-
-  /**
-   * Use an AuxCounter so we can measure that calls as they occur without consuming CPU
-   * in the benchmark method.
-   */
-  @AuxCounters
-  @State(Scope.Thread)
-  public static class AdditionalCounters {
-
-    @Setup(Level.Iteration)
-    public void clean() {
-      callCounter.set(0);
-    }
-
-    public long megabitsPerSecond() {
-      return (callCounter.get() * 8) >> 20;
-    }
-  }
-
-  /**
-   * Setup with direct executors and one channel.
-   */
-  @Setup(Level.Trial)
-  public void setup() throws Exception {
-    super.setup(ExecutorType.DIRECT,
-        ExecutorType.DIRECT,
-        MessageSize.SMALL,
-        responseSize,
-        clientInboundFlowWindow,
-        ChannelType.NIO,
-        maxConcurrentStreams,
-        1);
-    callCounter = new AtomicLong();
-    completed = new AtomicBoolean();
-    record = new AtomicBoolean();
-    latch = startFlowControlledStreamingCalls(maxConcurrentStreams, callCounter, record, completed,
-        responseSize.bytes());
-  }
-
-  /**
-   * Stop the running calls then stop the server and client channels.
-   */
-  @Override
-  @TearDown(Level.Trial)
-  public void teardown() throws Exception {
-    completed.set(true);
-    if (!latch.await(5, TimeUnit.SECONDS)) {
-      System.err.println("Failed to shutdown all calls.");
-    }
-    super.teardown();
-  }
-
-  /**
-   * Measure bandwidth of streamed responses.
-   */
-  @Benchmark
-  public void stream(AdditionalCounters counters) throws Exception {
-    record.set(true);
-    // No need to do anything, just sleep here.
-    Thread.sleep(1001);
-    record.set(false);
-  }
-
-  /**
-   * Useful for triggering a subset of the benchmark in a profiler.
-   */
-  public static void main(String[] argv) throws Exception {
-    StreamingResponseBandwidthBenchmark bench = new StreamingResponseBandwidthBenchmark();
-    bench.setup();
-    Thread.sleep(30000);
-    bench.teardown();
-    System.exit(0);
-  }
-}
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/UnaryCallQpsBenchmark.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/UnaryCallQpsBenchmark.java
index 6deeadacfec..6e12513a765 100644
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/UnaryCallQpsBenchmark.java
+++ b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/UnaryCallQpsBenchmark.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.netty;
diff --git a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/UnaryCallResponseBandwidthBenchmark.java b/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/UnaryCallResponseBandwidthBenchmark.java
deleted file mode 100644
index a1b146b6fe8..00000000000
--- a/benchmarks/src/jmh/java/io/grpc/benchmarks/netty/UnaryCallResponseBandwidthBenchmark.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.benchmarks.netty;
-
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
-import org.openjdk.jmh.annotations.AuxCounters;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.Fork;
-import org.openjdk.jmh.annotations.Level;
-import org.openjdk.jmh.annotations.Param;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
-import org.openjdk.jmh.annotations.State;
-import org.openjdk.jmh.annotations.TearDown;
-
-/**
- * Benchmark intended to test response bandwidth in bytes/sec for unary calls  by permuting
- * payload size and flow-control windows with number of concurrent calls. Async stubs are used
- * to avoid context-switching overheads.
- */
-@State(Scope.Benchmark)
-@Fork(1)
-public class UnaryCallResponseBandwidthBenchmark extends AbstractBenchmark {
-
-  @Param({"1", "10"})
-  public int maxConcurrentStreams = 1;
-
-  @Param({"LARGE", "JUMBO"})
-  public MessageSize responseSize = MessageSize.JUMBO;
-
-  @Param({"MEDIUM", "LARGE", "JUMBO"})
-  public FlowWindowSize clientInboundFlowWindow = FlowWindowSize.MEDIUM;
-
-  private static AtomicLong callCounter;
-  private AtomicBoolean completed;
-
-  /**
-   * Use an AuxCounter so we can measure that calls as they occur without consuming CPU
-   * in the benchmark method.
-   */
-  @AuxCounters
-  @State(Scope.Thread)
-  public static class AdditionalCounters {
-
-    @Setup(Level.Iteration)
-    public void clean() {
-      callCounter.set(0);
-    }
-
-    public long megabitsPerSecond() {
-      // Convert bytes into megabits
-      return (callCounter.get() * 8) >> 20;
-    }
-  }
-
-  /**
-   * Setup with direct executors, small payloads and a large flow control window.
-   */
-  @Setup(Level.Trial)
-  public void setup() throws Exception {
-    super.setup(ExecutorType.DIRECT,
-        ExecutorType.DIRECT,
-        MessageSize.SMALL,
-        responseSize,
-        clientInboundFlowWindow,
-        ChannelType.NIO,
-        maxConcurrentStreams,
-        1);
-    callCounter = new AtomicLong();
-    completed = new AtomicBoolean();
-    startUnaryCalls(maxConcurrentStreams, callCounter, completed, responseSize.bytes());
-  }
-
-  /**
-   * Stop the running calls then stop the server and client channels.
-   */
-  @Override
-  @TearDown(Level.Trial)
-  public void teardown() throws Exception {
-    completed.set(true);
-    Thread.sleep(5000);
-    super.teardown();
-  }
-
-  /**
-   * Measure bandwidth of unary call responses. The calls are already running, we just observe a
-   * counter of received responses.
-   */
-  @Benchmark
-  public void unary(AdditionalCounters counters) throws Exception {
-    // No need to do anything, just sleep here.
-    Thread.sleep(1001);
-  }
-
-  /**
-   * Useful for triggering a subset of the benchmark in a profiler.
-   */
-  public static void main(String[] argv) throws Exception {
-    UnaryCallResponseBandwidthBenchmark bench = new UnaryCallResponseBandwidthBenchmark();
-    bench.setup();
-    Thread.sleep(30000);
-    bench.teardown();
-    System.exit(0);
-  }
-}
diff --git a/benchmarks/src/jmh/java/io/grpc/netty/InboundHeadersBenchmark.java b/benchmarks/src/jmh/java/io/grpc/netty/InboundHeadersBenchmark.java
deleted file mode 100644
index 66c0accd015..00000000000
--- a/benchmarks/src/jmh/java/io/grpc/netty/InboundHeadersBenchmark.java
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.netty;
-
-import static io.grpc.netty.Utils.CONTENT_TYPE_HEADER;
-import static io.grpc.netty.Utils.TE_TRAILERS;
-import static io.netty.util.AsciiString.of;
-
-import io.grpc.netty.GrpcHttp2HeadersDecoder.GrpcHttp2RequestHeaders;
-import io.grpc.netty.GrpcHttp2HeadersDecoder.GrpcHttp2ResponseHeaders;
-import io.netty.handler.codec.http2.DefaultHttp2Headers;
-import io.netty.handler.codec.http2.Http2Headers;
-import io.netty.util.AsciiString;
-import java.util.concurrent.TimeUnit;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.BenchmarkMode;
-import org.openjdk.jmh.annotations.CompilerControl;
-import org.openjdk.jmh.annotations.Mode;
-import org.openjdk.jmh.annotations.OutputTimeUnit;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.State;
-import org.openjdk.jmh.infra.Blackhole;
-
-/**
- * Benchmarks for {@link GrpcHttp2RequestHeaders} and {@link GrpcHttp2ResponseHeaders}.
- */
-@State(Scope.Thread)
-public class InboundHeadersBenchmark {
-
-  private static AsciiString[] requestHeaders;
-  private static AsciiString[] responseHeaders;
-
-  static {
-    setupRequestHeaders();
-    setupResponseHeaders();
-  }
-
-  // Headers taken from the gRPC spec.
-  private static void setupRequestHeaders() {
-    requestHeaders = new AsciiString[18];
-    int i = 0;
-    requestHeaders[i++] = of(":method");
-    requestHeaders[i++] = of("POST");
-    requestHeaders[i++] = of(":scheme");
-    requestHeaders[i++] = of("http");
-    requestHeaders[i++] = of(":path");
-    requestHeaders[i++] = of("/google.pubsub.v2.PublisherService/CreateTopic");
-    requestHeaders[i++] = of(":authority");
-    requestHeaders[i++] = of("pubsub.googleapis.com");
-    requestHeaders[i++] = of("te");
-    requestHeaders[i++] = of("trailers");
-    requestHeaders[i++] = of("grpc-timeout");
-    requestHeaders[i++] = of("1S");
-    requestHeaders[i++] = of("content-type");
-    requestHeaders[i++] = of("application/grpc+proto");
-    requestHeaders[i++] = of("grpc-encoding");
-    requestHeaders[i++] = of("gzip");
-    requestHeaders[i++] = of("authorization");
-    requestHeaders[i] = of("Bearer y235.wef315yfh138vh31hv93hv8h3v");
-  }
-
-  private static void setupResponseHeaders() {
-    responseHeaders = new AsciiString[4];
-    int i = 0;
-    responseHeaders[i++] = of(":status");
-    responseHeaders[i++] = of("200");
-    responseHeaders[i++] = of("grpc-encoding");
-    responseHeaders[i] = of("gzip");
-  }
-
-  /**
-   * Checkstyle.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.AverageTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public void grpcHeaders_serverHandler(Blackhole bh) {
-    serverHandler(bh, new GrpcHttp2RequestHeaders(4));
-  }
-
-  /**
-   * Checkstyle.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.AverageTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public void defaultHeaders_serverHandler(Blackhole bh) {
-    serverHandler(bh, new DefaultHttp2Headers(true, 9));
-  }
-
-  /**
-   *  Checkstyle.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.AverageTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public void grpcHeaders_clientHandler(Blackhole bh) {
-    clientHandler(bh, new GrpcHttp2ResponseHeaders(2));
-  }
-
-  /**
-   * Checkstyle.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.AverageTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public void defaultHeaders_clientHandler(Blackhole bh) {
-    clientHandler(bh, new DefaultHttp2Headers(true, 2));
-  }
-
-  @CompilerControl(CompilerControl.Mode.INLINE)
-  private static void serverHandler(Blackhole bh, Http2Headers headers) {
-    for (int i = 0; i < requestHeaders.length; i += 2) {
-      bh.consume(headers.add(requestHeaders[i], requestHeaders[i + 1]));
-    }
-
-    // Sequence of headers accessed in NettyServerHandler
-    bh.consume(headers.get(TE_TRAILERS));
-    bh.consume(headers.get(CONTENT_TYPE_HEADER));
-    bh.consume(headers.method());
-    bh.consume(headers.get(CONTENT_TYPE_HEADER));
-    bh.consume(headers.path());
-
-    bh.consume(Utils.convertHeaders(headers));
-  }
-
-  @CompilerControl(CompilerControl.Mode.INLINE)
-  private static void clientHandler(Blackhole bh, Http2Headers headers) {
-    // NettyClientHandler does not directly access headers, but convert to Metadata immediately.
-
-    bh.consume(headers.add(responseHeaders[0], responseHeaders[1]));
-    bh.consume(headers.add(responseHeaders[2], responseHeaders[3]));
-
-    bh.consume(Utils.convertHeaders(headers));
-  }
-
-//  /**
-//   * Prints the size of the header objects in bytes. Needs JOL (Java Object Layout) as a
-//   * dependency.
-//   */
-//  public static void main(String... args) {
-//    Http2Headers grpcRequestHeaders = new GrpcHttp2RequestHeaders(4);
-//    Http2Headers defaultRequestHeaders = new DefaultHttp2Headers(true, 9);
-//    for (int i = 0; i < requestHeaders.length; i += 2) {
-//      grpcRequestHeaders.add(requestHeaders[i], requestHeaders[i + 1]);
-//      defaultRequestHeaders.add(requestHeaders[i], requestHeaders[i + 1]);
-//    }
-//    long c = 10L;
-//    int m = ((int) c) / 20;
-//
-//    long grpcRequestHeadersBytes = GraphLayout.parseInstance(grpcRequestHeaders).totalSize();
-//    long defaultRequestHeadersBytes =
-//        GraphLayout.parseInstance(defaultRequestHeaders).totalSize();
-//
-//    System.out.printf("gRPC Request Headers: %d bytes%nNetty Request Headers: %d bytes%n",
-//        grpcRequestHeadersBytes, defaultRequestHeadersBytes);
-//
-//    Http2Headers grpcResponseHeaders = new GrpcHttp2RequestHeaders(4);
-//    Http2Headers defaultResponseHeaders = new DefaultHttp2Headers(true, 9);
-//    for (int i = 0; i < responseHeaders.length; i += 2) {
-//      grpcResponseHeaders.add(responseHeaders[i], responseHeaders[i + 1]);
-//      defaultResponseHeaders.add(responseHeaders[i], responseHeaders[i + 1]);
-//    }
-//
-//    long grpcResponseHeadersBytes = GraphLayout.parseInstance(grpcResponseHeaders).totalSize();
-//    long defaultResponseHeadersBytes =
-//        GraphLayout.parseInstance(defaultResponseHeaders).totalSize();
-//
-//    System.out.printf("gRPC Response Headers: %d bytes%nNetty Response Headers: %d bytes%n",
-//        grpcResponseHeadersBytes, defaultResponseHeadersBytes);
-//  }
-}
diff --git a/benchmarks/src/jmh/java/io/grpc/netty/MethodDescriptorBenchmark.java b/benchmarks/src/jmh/java/io/grpc/netty/MethodDescriptorBenchmark.java
deleted file mode 100644
index c11d6c90d3e..00000000000
--- a/benchmarks/src/jmh/java/io/grpc/netty/MethodDescriptorBenchmark.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.netty;
-
-import io.grpc.InternalKnownTransport;
-import io.grpc.InternalMethodDescriptor;
-import io.grpc.MethodDescriptor;
-import io.netty.util.AsciiString;
-import java.io.ByteArrayInputStream;
-import java.io.InputStream;
-import java.util.concurrent.TimeUnit;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.BenchmarkMode;
-import org.openjdk.jmh.annotations.Mode;
-import org.openjdk.jmh.annotations.OutputTimeUnit;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.State;
-
-/**
- * Benchmark for Method Descriptors.
- */
-@State(Scope.Benchmark)
-public class MethodDescriptorBenchmark {
-
-  private static final MethodDescriptor.Marshaller<Void> marshaller =
-      new MethodDescriptor.Marshaller<Void>() {
-    @Override
-    public InputStream stream(Void value) {
-      return new ByteArrayInputStream(new byte[]{});
-    }
-
-    @Override
-    public Void parse(InputStream stream) {
-      return null;
-    }
-  };
-
-  MethodDescriptor<Void, Void> method = MethodDescriptor.<Void, Void>newBuilder()
-      .setType(MethodDescriptor.MethodType.UNARY)
-      .setFullMethodName("Service/Method")
-      .setRequestMarshaller(marshaller)
-      .setResponseMarshaller(marshaller)
-      .build();
-
-  InternalMethodDescriptor imd = new InternalMethodDescriptor(InternalKnownTransport.NETTY);
-
-  byte[] directBytes = new AsciiString("/" + method.getFullMethodName()).toByteArray();
-
-  /** Foo bar. */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public AsciiString old() {
-    return new AsciiString("/" + method.getFullMethodName());
-  }
-
-  /** Foo bar. */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public AsciiString transportSpecific() {
-    AsciiString path;
-    if ((path = (AsciiString) imd.geRawMethodName(method)) != null) {
-      path = new AsciiString("/" + method.getFullMethodName());
-      imd.setRawMethodName(method, path);
-    }
-    return path;
-  }
-
-  /** Foo bar. */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public AsciiString direct() {
-    return new AsciiString(directBytes, false);
-  }
-}
-
diff --git a/benchmarks/src/jmh/java/io/grpc/netty/OutboundHeadersBenchmark.java b/benchmarks/src/jmh/java/io/grpc/netty/OutboundHeadersBenchmark.java
deleted file mode 100644
index e38a1e5cd63..00000000000
--- a/benchmarks/src/jmh/java/io/grpc/netty/OutboundHeadersBenchmark.java
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.netty;
-
-import io.grpc.Metadata;
-import io.grpc.Metadata.AsciiMarshaller;
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.UnpooledByteBufAllocator;
-import io.netty.handler.codec.http2.DefaultHttp2HeadersEncoder;
-import io.netty.handler.codec.http2.Http2Headers;
-import io.netty.handler.codec.http2.Http2HeadersEncoder;
-import io.netty.util.AsciiString;
-import java.util.UUID;
-import java.util.concurrent.TimeUnit;
-import org.openjdk.jmh.annotations.Benchmark;
-import org.openjdk.jmh.annotations.BenchmarkMode;
-import org.openjdk.jmh.annotations.Mode;
-import org.openjdk.jmh.annotations.OutputTimeUnit;
-import org.openjdk.jmh.annotations.Param;
-import org.openjdk.jmh.annotations.Scope;
-import org.openjdk.jmh.annotations.Setup;
-import org.openjdk.jmh.annotations.State;
-
-/**
- * Header encoding benchmark.
- */
-@State(Scope.Benchmark)
-public class OutboundHeadersBenchmark {
-  @Param({"1", "5", "10", "20"})
-  public int headerCount;
-
-  private final AsciiMarshaller<String> keyMarshaller = new AsciiMarshaller<String>() {
-    @Override
-    public String toAsciiString(String value) {
-      return value;
-    }
-
-    @Override
-    public String parseAsciiString(String serialized) {
-      return serialized;
-    }
-  };
-
-  private final Metadata metadata = new Metadata();
-  private final AsciiString scheme = new AsciiString("https");
-  private final AsciiString defaultPath = new AsciiString("/Service.MethodMethodMethod");
-  private final AsciiString authority = new AsciiString("authority.googleapis.bogus");
-  private final AsciiString userAgent = new AsciiString("grpc-java-netty");
-  private final Http2HeadersEncoder headersEncoder = new DefaultHttp2HeadersEncoder();
-  private final ByteBuf scratchBuffer = UnpooledByteBufAllocator.DEFAULT.buffer(4096);
-
-  @Setup
-  public void setUp() throws Exception {
-    for (int i = 0; i < headerCount; i++) {
-      metadata.put(Metadata.Key.of("key-" + i, keyMarshaller), UUID.randomUUID().toString());
-    }
-  }
-
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public Http2Headers convertClientHeaders() {
-    return Utils.convertClientHeaders(metadata, scheme, defaultPath, authority, userAgent);
-  }
-
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public Http2Headers convertServerHeaders() {
-    return Utils.convertServerHeaders(metadata);
-  }
-
-  /**
-   * This will encode the random metadata fields, and repeatedly lookup the default other headers.
-   */
-  @Benchmark
-  @BenchmarkMode(Mode.SampleTime)
-  @OutputTimeUnit(TimeUnit.NANOSECONDS)
-  public ByteBuf encodeClientHeaders() throws Exception {
-    scratchBuffer.clear();
-    Http2Headers headers =
-        Utils.convertClientHeaders(metadata, scheme, defaultPath, authority, userAgent);
-    headersEncoder.encodeHeaders(1, headers, scratchBuffer);
-    return scratchBuffer;
-  }
-}
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/ByteBufInputStream.java b/benchmarks/src/main/java/io/grpc/benchmarks/ByteBufInputStream.java
index 91ba08bc576..c3e9e0a85c7 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/ByteBufInputStream.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/ByteBufInputStream.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks;
@@ -41,6 +26,7 @@
 /**
  * A {@link Drainable} {@code InputStream} that reads an {@link ByteBuf}.
  */
+@SuppressWarnings("InputStreamSlowMultibyteRead") // doesn't matter if slow. It'll throw
 public class ByteBufInputStream extends InputStream
     implements Drainable, KnownLength {
 
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/ByteBufOutputMarshaller.java b/benchmarks/src/main/java/io/grpc/benchmarks/ByteBufOutputMarshaller.java
index efa50492b88..49ae105bdb6 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/ByteBufOutputMarshaller.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/ByteBufOutputMarshaller.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks;
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/SocketAddressValidator.java b/benchmarks/src/main/java/io/grpc/benchmarks/SocketAddressValidator.java
index b21b7305800..c35cc7e5c38 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/SocketAddressValidator.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/SocketAddressValidator.java
@@ -1,42 +1,29 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks;
 
+import com.google.errorprone.annotations.Immutable;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 
 /**
  * Verifies whether or not the given {@link SocketAddress} is valid.
  */
+@Immutable
 public interface SocketAddressValidator {
   /**
    * Verifier for {@link InetSocketAddress}es.
@@ -46,6 +33,11 @@ public interface SocketAddressValidator {
     public boolean isValidSocketAddress(SocketAddress address) {
       return address instanceof InetSocketAddress;
     }
+
+    @Override
+    public boolean isValidSocketAddress(String address) {
+      return !address.startsWith("unix://");
+    }
   };
 
   /**
@@ -56,10 +48,20 @@ public boolean isValidSocketAddress(SocketAddress address) {
     public boolean isValidSocketAddress(SocketAddress address) {
       return "DomainSocketAddress".equals(address.getClass().getSimpleName());
     }
+
+    @Override
+    public boolean isValidSocketAddress(String address) {
+      return address.startsWith("unix://");
+    }
   };
 
   /**
    * Returns {@code true} if the given address is valid.
    */
   boolean isValidSocketAddress(SocketAddress address);
+
+  /**
+   * Returns {@code true} if the given address is valid.
+   */
+  boolean isValidSocketAddress(String address);
 }
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/Transport.java b/benchmarks/src/main/java/io/grpc/benchmarks/Transport.java
index 4a10da31174..fa21e03b6b8 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/Transport.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/Transport.java
@@ -1,37 +1,22 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks;
 
-import java.net.SocketAddress;
+import java.util.Locale;
 
 /**
  * All of the supported transports.
@@ -64,7 +49,7 @@ public enum Transport {
    *
    * @throws IllegalArgumentException if the given address is invalid for this transport.
    */
-  public void validateSocketAddress(SocketAddress address) {
+  public void validateSocketAddress(String address) {
     if (!socketAddressValidator.isValidSocketAddress(address)) {
       throw new IllegalArgumentException(
           "Invalid address " + address + " for transport " + this);
@@ -81,11 +66,16 @@ public static String getDescriptionString() {
       if (!first) {
         builder.append("\n");
       }
-      builder.append(transport.name().toLowerCase());
+      builder.append(transport);
       builder.append(": ");
       builder.append(transport.description);
       first = false;
     }
     return builder.toString();
   }
+
+  @Override
+  public String toString() {
+    return name().toLowerCase(Locale.ROOT);
+  }
 }
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java b/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java
index 0d064422919..c4ba99e1639 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/Utils.java
@@ -1,63 +1,45 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks;
 
 import static java.util.concurrent.ForkJoinPool.defaultForkJoinWorkerThreadFactory;
 
+import com.google.common.base.Preconditions;
 import com.google.common.util.concurrent.UncaughtExceptionHandlers;
 import com.google.protobuf.ByteString;
+import io.grpc.ChannelCredentials;
+import io.grpc.InsecureChannelCredentials;
 import io.grpc.ManagedChannel;
 import io.grpc.ManagedChannelBuilder;
 import io.grpc.Status;
+import io.grpc.TlsChannelCredentials;
 import io.grpc.benchmarks.proto.Messages;
 import io.grpc.benchmarks.proto.Messages.Payload;
 import io.grpc.benchmarks.proto.Messages.SimpleRequest;
 import io.grpc.benchmarks.proto.Messages.SimpleResponse;
-import io.grpc.internal.GrpcUtil;
-import io.grpc.netty.GrpcSslContexts;
-import io.grpc.netty.NegotiationType;
 import io.grpc.netty.NettyChannelBuilder;
 import io.grpc.okhttp.OkHttpChannelBuilder;
-import io.grpc.okhttp.internal.Platform;
-import io.grpc.testing.TestUtils;
+import io.grpc.testing.TlsTesting;
 import io.netty.channel.epoll.EpollDomainSocketChannel;
 import io.netty.channel.epoll.EpollEventLoopGroup;
 import io.netty.channel.epoll.EpollSocketChannel;
 import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.nio.NioSocketChannel;
 import io.netty.channel.unix.DomainSocketAddress;
-import io.netty.handler.ssl.SslContext;
-import io.netty.handler.ssl.SslContextBuilder;
-import io.netty.handler.ssl.SslProvider;
 import io.netty.util.concurrent.DefaultThreadFactory;
 import java.io.File;
 import java.io.FileOutputStream;
@@ -72,7 +54,6 @@
 import java.util.concurrent.ForkJoinWorkerThread;
 import java.util.concurrent.atomic.AtomicInteger;
 import javax.annotation.Nullable;
-import javax.net.ssl.SSLSocketFactory;
 import org.HdrHistogram.Histogram;
 
 /**
@@ -100,15 +81,10 @@ public static boolean parseBoolean(String value) {
   /**
    * Parse a {@link SocketAddress} from the given string.
    */
-  public static SocketAddress parseSocketAddress(String value) {
+  public static SocketAddress parseServerSocketAddress(String value) {
     if (value.startsWith(UNIX_DOMAIN_SOCKET_PREFIX)) {
-      // Unix Domain Socket address.
-      // Create the underlying file for the Unix Domain Socket.
-      String filePath = value.substring(UNIX_DOMAIN_SOCKET_PREFIX.length());
-      File file = new File(filePath);
-      if (!file.isAbsolute()) {
-        throw new IllegalArgumentException("File path must be absolute: " + filePath);
-      }
+      DomainSocketAddress domainAddress = parseUnixSocketAddress(value);
+      File file = new File(domainAddress.path());
       try {
         if (file.createNewFile()) {
           // If this application created the file, delete it when the application exits.
@@ -117,8 +93,7 @@ public static SocketAddress parseSocketAddress(String value) {
       } catch (IOException ex) {
         throw new RuntimeException(ex);
       }
-      // Create the SocketAddress referencing the file.
-      return new DomainSocketAddress(file);
+      return domainAddress;
     } else {
       // Standard TCP/IP address.
       String[] parts = value.split(":", 2);
@@ -132,81 +107,44 @@ public static SocketAddress parseSocketAddress(String value) {
     }
   }
 
-  private static OkHttpChannelBuilder newOkhttpClientChannel(
-      SocketAddress address, boolean tls, boolean testca, @Nullable String authorityOverride) {
-    InetSocketAddress addr = (InetSocketAddress) address;
-    OkHttpChannelBuilder builder =
-        OkHttpChannelBuilder.forAddress(addr.getHostName(), addr.getPort());
-    if (tls) {
-      builder.negotiationType(io.grpc.okhttp.NegotiationType.TLS);
-      SSLSocketFactory factory;
-      if (testca) {
-        builder.overrideAuthority(
-            GrpcUtil.authorityFromHostAndPort(authorityOverride, addr.getPort()));
-        try {
-          factory = TestUtils.newSslSocketFactoryForCa(
-              Platform.get().getProvider(),
-              TestUtils.loadCert("ca.pem"));
-        } catch (Exception e) {
-          throw new RuntimeException(e);
-        }
-      } else {
-        factory = (SSLSocketFactory) SSLSocketFactory.getDefault();
-      }
-      builder.sslSocketFactory(factory);
-    } else {
-      builder.negotiationType(io.grpc.okhttp.NegotiationType.PLAINTEXT);
+  private static DomainSocketAddress parseUnixSocketAddress(String value) {
+    Preconditions.checkArgument(
+        value.startsWith(UNIX_DOMAIN_SOCKET_PREFIX),
+        "Must start with %s: %s", UNIX_DOMAIN_SOCKET_PREFIX, value);
+    // Unix Domain Socket address.
+    // Create the underlying file for the Unix Domain Socket.
+    String filePath = value.substring(UNIX_DOMAIN_SOCKET_PREFIX.length());
+    File file = new File(filePath);
+    if (!file.isAbsolute()) {
+      throw new IllegalArgumentException("File path must be absolute: " + filePath);
     }
-    return builder;
+    // Create the SocketAddress referencing the file.
+    return new DomainSocketAddress(file);
   }
 
-  private static NettyChannelBuilder newNettyClientChannel(Transport transport,
-      SocketAddress address, boolean tls, boolean testca, int flowControlWindow,
-      boolean useDefaultCiphers) throws IOException {
-    NettyChannelBuilder builder =
-        NettyChannelBuilder.forAddress(address).flowControlWindow(flowControlWindow);
-    if (tls) {
-      builder.negotiationType(NegotiationType.TLS);
-      SslContext sslContext = null;
-      if (testca) {
-        File cert = TestUtils.loadCert("ca.pem");
-        SslContextBuilder sslContextBuilder = GrpcSslContexts.forClient().trustManager(cert);
-        if (transport == Transport.NETTY_NIO) {
-          sslContextBuilder = GrpcSslContexts.configure(sslContextBuilder, SslProvider.JDK);
-        } else {
-          // Native transport with OpenSSL
-          sslContextBuilder = GrpcSslContexts.configure(sslContextBuilder, SslProvider.OPENSSL);
-        }
-        if (useDefaultCiphers) {
-          sslContextBuilder.ciphers(null);
-        }
-        sslContext = sslContextBuilder.build();
-      }
-      builder.sslContext(sslContext);
-    } else {
-      builder.negotiationType(NegotiationType.PLAINTEXT);
-    }
-
+  private static NettyChannelBuilder configureNetty(
+      NettyChannelBuilder builder, Transport transport, int flowControlWindow) {
+    builder.flowControlWindow(flowControlWindow);
     DefaultThreadFactory tf = new DefaultThreadFactory("client-elg-", true /*daemon */);
     switch (transport) {
       case NETTY_NIO:
         builder
             .eventLoopGroup(new NioEventLoopGroup(0, tf))
-            .channelType(NioSocketChannel.class);
+            .channelType(NioSocketChannel.class, InetSocketAddress.class);
         break;
 
       case NETTY_EPOLL:
         // These classes only work on Linux.
         builder
             .eventLoopGroup(new EpollEventLoopGroup(0, tf))
-            .channelType(EpollSocketChannel.class);
+            .channelType(EpollSocketChannel.class, InetSocketAddress.class);
         break;
 
       case NETTY_UNIX_DOMAIN_SOCKET:
         // These classes only work on Linux.
         builder
             .eventLoopGroup(new EpollEventLoopGroup(0, tf))
-            .channelType(EpollDomainSocketChannel.class);
+            .channelType(EpollDomainSocketChannel.class, DomainSocketAddress.class);
         break;
 
       default:
@@ -239,18 +177,38 @@ public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
   /**
    * Create a {@link ManagedChannel} for the given parameters.
    */
-  public static ManagedChannel newClientChannel(Transport transport, SocketAddress address,
-        boolean tls, boolean testca, @Nullable String authorityOverride, boolean useDefaultCiphers,
+  public static ManagedChannel newClientChannel(Transport transport, String target,
+        boolean tls, boolean testca, @Nullable String authorityOverride,
         int flowControlWindow, boolean directExecutor) {
+    ChannelCredentials credentials;
+    if (tls) {
+      if (testca) {
+        try {
+          credentials = TlsChannelCredentials.newBuilder()
+              .trustManager(TlsTesting.loadCert("ca.pem"))
+              .build();
+        } catch (IOException ex) {
+          throw new RuntimeException(ex);
+        }
+      } else {
+        credentials = TlsChannelCredentials.create();
+      }
+    } else {
+      credentials = InsecureChannelCredentials.create();
+    }
     ManagedChannelBuilder<?> builder;
     if (transport == Transport.OK_HTTP) {
-      builder = newOkhttpClientChannel(address, tls, testca, authorityOverride);
+      builder = OkHttpChannelBuilder.forTarget(target, credentials)
+          .flowControlWindow(flowControlWindow);
     } else {
-      try {
-        builder = newNettyClientChannel(
-            transport, address, tls, testca, flowControlWindow, useDefaultCiphers);
-      } catch (Exception e) {
-        throw new RuntimeException(e);
+      if (target.startsWith(UNIX_DOMAIN_SOCKET_PREFIX)) {
+        builder = configureNetty(
+            NettyChannelBuilder.forAddress(parseUnixSocketAddress(target), credentials),
+            transport, flowControlWindow);
+      } else {
+        builder = configureNetty(
+            NettyChannelBuilder.forTarget(target, credentials),
+            transport, flowControlWindow);
       }
     }
     if (authorityOverride != null) {
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadClient.java b/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadClient.java
index 6eb559a78a2..6b37718a49b 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadClient.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadClient.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.driver;
@@ -97,13 +82,12 @@ class LoadClient {
       channels[i] =
           Utils.newClientChannel(
               Epoll.isAvailable() ?  Transport.NETTY_EPOLL : Transport.NETTY_NIO,
-              Utils.parseSocketAddress(config.getServerTargets(i % config.getServerTargetsCount())),
+              config.getServerTargets(i % config.getServerTargetsCount()),
               config.hasSecurityParams(),
               config.hasSecurityParams() && config.getSecurityParams().getUseTestCa(),
               config.hasSecurityParams()
                   ? config.getSecurityParams().getServerHostOverride()
                   : null,
-              true,
               Utils.DEFAULT_FLOW_CONTROL_WINDOW,
               false);
     }
@@ -261,9 +245,9 @@ Stats.ClientStats getStats() {
       latenciesBuilder.addBucket(0);
       base = base * resolution;
     }
-    latenciesBuilder.setMaxSeen(intervalHistogram.getMaxValue());
-    latenciesBuilder.setMinSeen(intervalHistogram.getMinNonZeroValue());
-    latenciesBuilder.setCount(intervalHistogram.getTotalCount());
+    latenciesBuilder.setMaxSeen((double) intervalHistogram.getMaxValue());
+    latenciesBuilder.setMinSeen((double) intervalHistogram.getMinNonZeroValue());
+    latenciesBuilder.setCount((double) intervalHistogram.getTotalCount());
     latenciesBuilder.setSum(intervalHistogram.getMean()
         * intervalHistogram.getTotalCount());
     // TODO: No support for sum of squares
@@ -395,7 +379,7 @@ public void run() {
       while (!shutdown) {
         maxOutstanding.acquireUninterruptibly();
         final AtomicReference<StreamObserver<Messages.SimpleRequest>> requestObserver =
-            new AtomicReference<StreamObserver<Messages.SimpleRequest>>();
+            new AtomicReference<>();
         requestObserver.set(stub.streamingCall(
             new StreamObserver<Messages.SimpleResponse>() {
               long now = System.nanoTime();
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadServer.java b/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadServer.java
index 873cb7f0bfb..ed91135e6c3 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadServer.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadServer.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.driver;
@@ -49,13 +34,12 @@
 import io.grpc.benchmarks.Utils;
 import io.grpc.benchmarks.proto.BenchmarkServiceGrpc;
 import io.grpc.benchmarks.proto.Control;
-import io.grpc.benchmarks.proto.Messages;
 import io.grpc.benchmarks.proto.Stats;
-import io.grpc.stub.StreamObserver;
-import io.grpc.testing.TestUtils;
+import io.grpc.benchmarks.qps.AsyncServer;
+import io.grpc.testing.TlsTesting;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.PooledByteBufAllocator;
-import java.io.File;
+import java.io.InputStream;
 import java.lang.management.ManagementFactory;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
@@ -76,22 +60,21 @@ final class LoadServer {
    * Generic version of the unary method call.
    */
   static final MethodDescriptor<ByteBuf, ByteBuf> GENERIC_UNARY_METHOD =
-      BenchmarkServiceGrpc.METHOD_UNARY_CALL.toBuilder(marshaller, marshaller)
+      BenchmarkServiceGrpc.getUnaryCallMethod().toBuilder(marshaller, marshaller)
           .build();
 
   /**
    * Generic version of the streaming ping-pong method call.
    */
   static final MethodDescriptor<ByteBuf, ByteBuf> GENERIC_STREAMING_PING_PONG_METHOD =
-      BenchmarkServiceGrpc.METHOD_STREAMING_CALL.toBuilder(marshaller, marshaller)
+      BenchmarkServiceGrpc.getStreamingCallMethod().toBuilder(marshaller, marshaller)
           .build();
 
   private static final Logger log = Logger.getLogger(LoadServer.class.getName());
 
   private final Server server;
-  private final BenchmarkServiceImpl benchmarkService;
+  private final AsyncServer.BenchmarkServiceImpl benchmarkService;
   private final OperatingSystemMXBean osBean;
-  private volatile boolean shutdown;
   private final int port;
   private ByteBuf genericResponse;
   private long lastStatTime;
@@ -132,11 +115,11 @@ final class LoadServer {
       }
     }
     if (config.hasSecurityParams()) {
-      File cert = TestUtils.loadCert("server1.pem");
-      File key = TestUtils.loadCert("server1.key");
+      InputStream cert = TlsTesting.loadCert("server1.pem");
+      InputStream key = TlsTesting.loadCert("server1.key");
       serverBuilder.useTransportSecurity(cert, key);
     }
-    benchmarkService = new BenchmarkServiceImpl();
+    benchmarkService = new AsyncServer.BenchmarkServiceImpl();
     if (config.getServerType() == Control.ServerType.ASYNC_GENERIC_SERVER) {
       serverBuilder.addService(
           ServerServiceDefinition
@@ -207,45 +190,10 @@ Stats.ServerStats getStats() {
   }
 
   void shutdownNow() {
-    shutdown = true;
+    benchmarkService.shutdown();
     server.shutdownNow();
   }
 
-  private class BenchmarkServiceImpl extends BenchmarkServiceGrpc.BenchmarkServiceImplBase {
-
-    @Override
-    public void unaryCall(Messages.SimpleRequest request,
-                          StreamObserver<Messages.SimpleResponse> responseObserver) {
-      responseObserver.onNext(Utils.makeResponse(request));
-      responseObserver.onCompleted();
-    }
-
-    @Override
-    public StreamObserver<Messages.SimpleRequest> streamingCall(
-        final StreamObserver<Messages.SimpleResponse> responseObserver) {
-      return new StreamObserver<Messages.SimpleRequest>() {
-        @Override
-        public void onNext(Messages.SimpleRequest value) {
-          if (!shutdown) {
-            responseObserver.onNext(Utils.makeResponse(value));
-          } else {
-            responseObserver.onCompleted();
-          }
-        }
-
-        @Override
-        public void onError(Throwable t) {
-          responseObserver.onError(t);
-        }
-
-        @Override
-        public void onCompleted() {
-          responseObserver.onCompleted();
-        }
-      };
-    }
-  }
-
   private class GenericServiceCallHandler implements ServerCallHandler<ByteBuf, ByteBuf> {
 
     @Override
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadWorker.java b/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadWorker.java
index 1e462a4115b..63fbef0cabe 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadWorker.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/driver/LoadWorker.java
@@ -1,47 +1,34 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.driver;
 
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
 import io.grpc.Status;
 import io.grpc.benchmarks.proto.Control;
 import io.grpc.benchmarks.proto.Control.ClientArgs;
 import io.grpc.benchmarks.proto.Control.ServerArgs;
 import io.grpc.benchmarks.proto.Control.ServerArgs.ArgtypeCase;
 import io.grpc.benchmarks.proto.WorkerServiceGrpc;
-import io.grpc.internal.ServerImpl;
 import io.grpc.netty.NettyServerBuilder;
 import io.grpc.stub.StreamObserver;
 import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -54,7 +41,7 @@ public class LoadWorker {
   private static final Logger log = Logger.getLogger(LoadWorker.class.getName());
 
   private final int serverPort;
-  private final ServerImpl driverServer;
+  private final Server driverServer;
 
   LoadWorker(int driverPort, int serverPort) throws Exception {
     this.serverPort = serverPort;
@@ -63,8 +50,9 @@ public class LoadWorker {
             .setDaemon(true)
             .setNameFormat("load-worker-%d")
             .build());
-    this.driverServer = NettyServerBuilder.forPort(driverPort)
+    this.driverServer = NettyServerBuilder.forPort(driverPort, InsecureServerCredentials.create())
         .directExecutor()
+        .channelType(NioServerSocketChannel.class)
         .workerEventLoopGroup(singleThreadGroup)
         .bossEventLoopGroup(singleThreadGroup)
         .addService(new WorkerServiceImpl())
@@ -117,7 +105,8 @@ public static void main(String[] args) throws Exception {
               + "\n  --driver_port=<port>"
               + "\n    Port to expose grpc.testing.WorkerService, used by driver to initiate work."
               + "\n  --server_port=<port>"
-              + "\n    Port to start load servers on. Defaults to any available port");
+              + "\n    Port to start load servers on, if not specified by the server config"
+              + "\n    message. Defaults to any available port.");
       System.exit(1);
     }
     LoadWorker loadWorker = new LoadWorker(driverPort, serverPort);
@@ -266,7 +255,7 @@ public void quitWorker(Control.Void request,
         log.log(Level.INFO, "Received quitWorker request.");
         responseObserver.onNext(Control.Void.getDefaultInstance());
         responseObserver.onCompleted();
-        driverServer.shutdownNow();
+        driverServer.shutdown();
       } catch (Throwable t) {
         log.log(Level.WARNING, "Error during shutdown", t);
       }
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/qps/AbstractConfigurationBuilder.java b/benchmarks/src/main/java/io/grpc/benchmarks/qps/AbstractConfigurationBuilder.java
index 216ba59c94b..1606b194d39 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/AbstractConfigurationBuilder.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/AbstractConfigurationBuilder.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.qps;
@@ -38,6 +23,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
@@ -70,6 +56,7 @@ public boolean isRequired() {
       return false;
     }
 
+    @Override
     public String getDefaultValue() {
       return null;
     }
@@ -122,7 +109,7 @@ protected interface Param {
   public final T build(String[] args) {
     T config = newConfiguration();
     Map<String, Param> paramMap = getParamMap();
-    Set<String> appliedParams = new TreeSet<String>(CASE_INSENSITIVE_ORDER);
+    Set<String> appliedParams = new TreeSet<>(CASE_INSENSITIVE_ORDER);
 
     for (String arg : args) {
       if (!arg.startsWith("--")) {
@@ -160,10 +147,11 @@ public final T build(String[] args) {
   }
 
   @Override
+  @SuppressWarnings("InlineMeInliner") // String.repeat() requires Java 11
   public final void printUsage() {
     System.out.println("Usage: [ARGS...]");
     int column1Width = 0;
-    List<Param> params = new ArrayList<Param>();
+    List<Param> params = new ArrayList<>();
     params.add(HELP);
     params.addAll(getParams());
 
@@ -210,7 +198,7 @@ public final void printUsage() {
   protected abstract T build0(T config);
 
   private Map<String, Param> getParamMap() {
-    Map<String, Param> map = new TreeMap<String, Param>(CASE_INSENSITIVE_ORDER);
+    Map<String, Param> map = new TreeMap<>(CASE_INSENSITIVE_ORDER);
     for (Param param : getParams()) {
       map.put(param.getName(), param);
     }
@@ -218,15 +206,16 @@ private Map<String, Param> getParamMap() {
   }
 
   private static String commandLineFlag(Param param) {
-    String name = param.getName().toLowerCase();
+    String name = param.getName().toLowerCase(Locale.ROOT);
     String type = (!param.getType().isEmpty() ? '=' + param.getType() : "");
     return "--" + name + type;
   }
 
+  @SuppressWarnings("InlineMeInliner") // String.repeat() requires Java 11
   private static String wordWrap(String text, int startPos, int maxPos) {
     StringBuilder builder = new StringBuilder();
     int pos = startPos;
-    String[] parts = text.split("\\n");
+    String[] parts = text.split("\\n", -1);
     boolean isBulleted = parts.length > 1;
     for (String part : parts) {
       int lineStart = startPos;
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncClient.java b/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncClient.java
index 4871bcf61ff..358e4474bb5 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncClient.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncClient.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.qps;
@@ -47,14 +32,12 @@
 import static io.grpc.benchmarks.qps.ClientConfiguration.ClientParam.TESTCA;
 import static io.grpc.benchmarks.qps.ClientConfiguration.ClientParam.TLS;
 import static io.grpc.benchmarks.qps.ClientConfiguration.ClientParam.TRANSPORT;
-import static io.grpc.benchmarks.qps.ClientConfiguration.ClientParam.USE_DEFAULT_CIPHERS;
 import static io.grpc.benchmarks.qps.ClientConfiguration.ClientParam.WARMUP_DURATION;
 
-import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.SettableFuture;
 import com.google.protobuf.ByteString;
 import io.grpc.Channel;
 import io.grpc.ManagedChannel;
-import io.grpc.Status;
 import io.grpc.benchmarks.proto.BenchmarkServiceGrpc;
 import io.grpc.benchmarks.proto.BenchmarkServiceGrpc.BenchmarkServiceStub;
 import io.grpc.benchmarks.proto.Messages.Payload;
@@ -63,11 +46,8 @@
 import io.grpc.stub.StreamObserver;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
 import org.HdrHistogram.Histogram;
 import org.HdrHistogram.HistogramIterationValue;
 
@@ -92,7 +72,7 @@ public void run() throws Exception {
 
     SimpleRequest req = newRequest();
 
-    List<ManagedChannel> channels = new ArrayList<ManagedChannel>(config.channels);
+    List<ManagedChannel> channels = new ArrayList<>(config.channels);
     for (int i = 0; i < config.channels; i++) {
       channels.add(config.newChannel());
     }
@@ -140,7 +120,7 @@ private List<Histogram> doBenchmark(SimpleRequest req,
                                       long endTime) throws Exception {
     // Initiate the concurrent calls
     List<Future<Histogram>> futures =
-        new ArrayList<Future<Histogram>>(config.outstandingRpcsPerChannel);
+        new ArrayList<>(config.outstandingRpcsPerChannel);
     for (int i = 0; i < config.channels; i++) {
       for (int j = 0; j < config.outstandingRpcsPerChannel; j++) {
         Channel channel = channels.get(i);
@@ -148,7 +128,7 @@ private List<Histogram> doBenchmark(SimpleRequest req,
       }
     }
     // Wait for completion
-    List<Histogram> histograms = new ArrayList<Histogram>(futures.size());
+    List<Histogram> histograms = new ArrayList<>(futures.size());
     for (Future<Histogram> future : futures) {
       histograms.add(future.get());
     }
@@ -170,7 +150,7 @@ private Future<Histogram> doUnaryCalls(Channel channel, final SimpleRequest requ
                                          final long endTime) {
     final BenchmarkServiceStub stub = BenchmarkServiceGrpc.newStub(channel);
     final Histogram histogram = new Histogram(HISTOGRAM_MAX_VALUE, HISTOGRAM_PRECISION);
-    final HistogramFuture future = new HistogramFuture(histogram);
+    final SettableFuture<Histogram> future = SettableFuture.create();
 
     stub.unaryCall(request, new StreamObserver<SimpleResponse>() {
       long lastCall = System.nanoTime();
@@ -181,11 +161,7 @@ public void onNext(SimpleResponse value) {
 
       @Override
       public void onError(Throwable t) {
-        Status status = Status.fromThrowable(t);
-        System.err.println("Encountered an error in unaryCall. Status is " + status);
-        t.printStackTrace();
-
-        future.cancel(true);
+        future.setException(new RuntimeException("Encountered an error in unaryCall", t));
       }
 
       @Override
@@ -195,10 +171,10 @@ public void onCompleted() {
         histogram.recordValue((now - lastCall) / 1000);
         lastCall = now;
 
-        if (endTime > now) {
+        if (endTime - now > 0) {
           stub.unaryCall(request, this);
         } else {
-          future.done();
+          future.set(histogram);
         }
       }
     });
@@ -210,7 +186,7 @@ private static Future<Histogram> doStreamingCalls(Channel channel, final SimpleR
                                              final long endTime) {
     final BenchmarkServiceStub stub = BenchmarkServiceGrpc.newStub(channel);
     final Histogram histogram = new Histogram(HISTOGRAM_MAX_VALUE, HISTOGRAM_PRECISION);
-    final HistogramFuture future = new HistogramFuture(histogram);
+    final SettableFuture<Histogram> future = SettableFuture.create();
 
     ThisIsAHackStreamObserver responseObserver =
         new ThisIsAHackStreamObserver(request, histogram, future, endTime);
@@ -229,7 +205,7 @@ private static class ThisIsAHackStreamObserver implements StreamObserver<SimpleR
 
     final SimpleRequest request;
     final Histogram histogram;
-    final HistogramFuture future;
+    final SettableFuture<Histogram> future;
     final long endTime;
     long lastCall = System.nanoTime();
 
@@ -237,7 +213,7 @@ private static class ThisIsAHackStreamObserver implements StreamObserver<SimpleR
 
     ThisIsAHackStreamObserver(SimpleRequest request,
                               Histogram histogram,
-                              HistogramFuture future,
+                              SettableFuture<Histogram> future,
                               long endTime) {
       this.request = request;
       this.histogram = histogram;
@@ -252,7 +228,7 @@ public void onNext(SimpleResponse value) {
       histogram.recordValue((now - lastCall) / 1000);
       lastCall = now;
 
-      if (endTime > now) {
+      if (endTime - now > 0) {
         requestObserver.onNext(request);
       } else {
         requestObserver.onCompleted();
@@ -261,16 +237,12 @@ public void onNext(SimpleResponse value) {
 
     @Override
     public void onError(Throwable t) {
-      Status status = Status.fromThrowable(t);
-      System.err.println("Encountered an error in streamingCall. Status is " + status);
-      t.printStackTrace();
-
-      future.cancel(true);
+      future.setException(new RuntimeException("Encountered an error in streamingCall", t));
     }
 
     @Override
     public void onCompleted() {
-      future.done();
+      future.set(histogram);
     }
   }
 
@@ -323,7 +295,7 @@ private static void shutdown(List<ManagedChannel> channels) {
   public static void main(String... args) throws Exception {
     ClientConfiguration.Builder configBuilder = ClientConfiguration.newBuilder(
         ADDRESS, CHANNELS, OUTSTANDING_RPCS, CLIENT_PAYLOAD, SERVER_PAYLOAD,
-        TLS, TESTCA, USE_DEFAULT_CIPHERS, TRANSPORT, DURATION, WARMUP_DURATION, DIRECTEXECUTOR,
+        TLS, TESTCA, TRANSPORT, DURATION, WARMUP_DURATION, DIRECTEXECUTOR,
         SAVE_HISTOGRAM, STREAMING_RPCS, FLOW_CONTROL_WINDOW);
     ClientConfiguration config;
     try {
@@ -336,60 +308,4 @@ public static void main(String... args) throws Exception {
     AsyncClient client = new AsyncClient(config);
     client.run();
   }
-
-  private static class HistogramFuture implements Future<Histogram> {
-    private final Histogram histogram;
-    private boolean canceled;
-    private boolean done;
-
-    HistogramFuture(Histogram histogram) {
-      Preconditions.checkNotNull(histogram, "histogram");
-      this.histogram = histogram;
-    }
-
-    @Override
-    public synchronized boolean cancel(boolean mayInterruptIfRunning) {
-      if (!done && !canceled) {
-        canceled = true;
-        notifyAll();
-        return true;
-      }
-      return false;
-    }
-
-    @Override
-    public synchronized boolean isCancelled() {
-      return canceled;
-    }
-
-    @Override
-    public synchronized boolean isDone() {
-      return done || canceled;
-    }
-
-    @Override
-    public synchronized Histogram get() throws InterruptedException, ExecutionException {
-      while (!isDone() && !isCancelled()) {
-        wait();
-      }
-
-      if (isCancelled()) {
-        throw new CancellationException();
-      }
-
-      return histogram;
-    }
-
-    @Override
-    public Histogram get(long timeout, TimeUnit unit) throws InterruptedException,
-        ExecutionException,
-        TimeoutException {
-      throw new UnsupportedOperationException();
-    }
-
-    private synchronized void done() {
-      done = true;
-      notifyAll();
-    }
-  }
 }
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncServer.java b/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncServer.java
index 95b305b28a7..7f61e15f783 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncServer.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/AsyncServer.java
@@ -1,65 +1,52 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.qps;
 
 import com.google.common.util.concurrent.UncaughtExceptionHandlers;
+import com.google.protobuf.ByteString;
 import io.grpc.Server;
+import io.grpc.Status;
 import io.grpc.benchmarks.Utils;
 import io.grpc.benchmarks.proto.BenchmarkServiceGrpc;
-import io.grpc.benchmarks.proto.Messages.SimpleRequest;
-import io.grpc.benchmarks.proto.Messages.SimpleResponse;
-import io.grpc.netty.GrpcSslContexts;
+import io.grpc.benchmarks.proto.Messages;
 import io.grpc.netty.NettyServerBuilder;
+import io.grpc.stub.ServerCallStreamObserver;
 import io.grpc.stub.StreamObserver;
-import io.grpc.testing.TestUtils;
+import io.grpc.testing.TlsTesting;
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.ServerChannel;
 import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
-import io.netty.handler.ssl.SslContext;
-import io.netty.handler.ssl.SslContextBuilder;
-import io.netty.handler.ssl.SslProvider;
-import java.io.File;
+import io.netty.util.concurrent.DefaultThreadFactory;
 import java.io.IOException;
+import java.io.InputStream;
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory;
 import java.util.concurrent.ForkJoinWorkerThread;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Logger;
 
 /**
  * QPS server using the non-blocking API.
  */
 public class AsyncServer {
+  private static final Logger log = Logger.getLogger(AsyncServer.class.getName());
 
   /**
    * checkstyle complains if there is no javadoc comment here.
@@ -87,46 +74,28 @@ public void run(String[] args) throws Exception {
 
     Runtime.getRuntime().addShutdownHook(new Thread() {
       @Override
+      @SuppressWarnings("CatchAndPrintStackTrace")
       public void run() {
         try {
           System.out.println("QPS Server shutting down");
           server.shutdown();
-          server.awaitTermination(5, TimeUnit.SECONDS);
         } catch (Exception e) {
           e.printStackTrace();
         }
       }
     });
+    server.awaitTermination();
   }
 
   static Server newServer(ServerConfiguration config) throws IOException {
-    SslContext sslContext = null;
-    if (config.tls) {
-      System.out.println("Using fake CA for TLS certificate.\n"
-          + "Run the Java client with --tls --testca");
-
-      File cert = TestUtils.loadCert("server1.pem");
-      File key = TestUtils.loadCert("server1.key");
-      SslContextBuilder sslContextBuilder = GrpcSslContexts.forServer(cert, key);
-      if (config.transport == ServerConfiguration.Transport.NETTY_NIO) {
-        sslContextBuilder = GrpcSslContexts.configure(sslContextBuilder, SslProvider.JDK);
-      } else {
-        // Native transport with OpenSSL
-        sslContextBuilder = GrpcSslContexts.configure(sslContextBuilder, SslProvider.OPENSSL);
-      }
-      if (config.useDefaultCiphers) {
-        sslContextBuilder.ciphers(null);
-      }
-      sslContext = sslContextBuilder.build();
-    }
-
     final EventLoopGroup boss;
     final EventLoopGroup worker;
     final Class<? extends ServerChannel> channelType;
+    ThreadFactory tf = new DefaultThreadFactory("server-elg-", true /*daemon */);
     switch (config.transport) {
       case NETTY_NIO: {
-        boss = new NioEventLoopGroup();
-        worker = new NioEventLoopGroup();
+        boss = new NioEventLoopGroup(1, tf);
+        worker = new NioEventLoopGroup(0, tf);
         channelType = NioServerSocketChannel.class;
         break;
       }
@@ -137,8 +106,16 @@ static Server newServer(ServerConfiguration config) throws IOException {
           @SuppressWarnings("unchecked")
           Class<? extends ServerChannel> channelClass = (Class<? extends ServerChannel>)
               Class.forName("io.netty.channel.epoll.EpollServerSocketChannel");
-          boss = (EventLoopGroup) groupClass.getConstructor().newInstance();
-          worker = (EventLoopGroup) groupClass.getConstructor().newInstance();
+          boss =
+              (EventLoopGroup)
+                  groupClass
+                      .getConstructor(int.class, ThreadFactory.class)
+                      .newInstance(1, tf);
+          worker =
+              (EventLoopGroup)
+                  groupClass
+                      .getConstructor(int.class, ThreadFactory.class)
+                      .newInstance(0, tf);
           channelType = channelClass;
           break;
         } catch (Exception e) {
@@ -152,8 +129,16 @@ static Server newServer(ServerConfiguration config) throws IOException {
           @SuppressWarnings("unchecked")
           Class<? extends ServerChannel> channelClass = (Class<? extends ServerChannel>)
               Class.forName("io.netty.channel.epoll.EpollServerDomainSocketChannel");
-          boss = (EventLoopGroup) groupClass.getConstructor().newInstance();
-          worker = (EventLoopGroup) groupClass.getConstructor().newInstance();
+          boss =
+              (EventLoopGroup)
+                  groupClass
+                      .getConstructor(int.class, ThreadFactory.class)
+                      .newInstance(1, tf);
+          worker =
+              (EventLoopGroup)
+                  groupClass
+                      .getConstructor(int.class, ThreadFactory.class)
+                      .newInstance(0, tf);
           channelType = channelClass;
           break;
         } catch (Exception e) {
@@ -172,8 +157,15 @@ static Server newServer(ServerConfiguration config) throws IOException {
         .workerEventLoopGroup(worker)
         .channelType(channelType)
         .addService(new BenchmarkServiceImpl())
-        .sslContext(sslContext)
         .flowControlWindow(config.flowControlWindow);
+    if (config.tls) {
+      System.out.println("Using fake CA for TLS certificate.\n"
+          + "Run the Java client with --tls --testca");
+
+      InputStream cert = TlsTesting.loadCert("server1.pem");
+      InputStream key = TlsTesting.loadCert("server1.key");
+      builder.useTransportSecurity(cert, key);
+    }
     if (config.directExecutor) {
       builder.directExecutor();
     } else {
@@ -198,36 +190,153 @@ public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
   }
 
   public static class BenchmarkServiceImpl extends BenchmarkServiceGrpc.BenchmarkServiceImplBase {
+    // Always use the same canned response for bidi. This is allowed by the spec.
+    private static final int BIDI_RESPONSE_BYTES = 100;
+    private static final Messages.SimpleResponse BIDI_RESPONSE = Messages.SimpleResponse
+        .newBuilder()
+        .setPayload(Messages.Payload.newBuilder()
+            .setBody(ByteString.copyFrom(new byte[BIDI_RESPONSE_BYTES])).build())
+        .build();
+
+    private final AtomicBoolean shutdown = new AtomicBoolean();
+
+    public BenchmarkServiceImpl() {
+    }
+
+    public void shutdown() {
+      shutdown.set(true);
+    }
 
     @Override
-    public void unaryCall(SimpleRequest request, StreamObserver<SimpleResponse> responseObserver) {
-      SimpleResponse response = Utils.makeResponse(request);
-      responseObserver.onNext(response);
+    public void unaryCall(Messages.SimpleRequest request,
+        StreamObserver<Messages.SimpleResponse> responseObserver) {
+      responseObserver.onNext(Utils.makeResponse(request));
       responseObserver.onCompleted();
     }
 
     @Override
-    public StreamObserver<SimpleRequest> streamingCall(
-        final StreamObserver<SimpleResponse> responseObserver) {
-      return new StreamObserver<SimpleRequest>() {
+    public StreamObserver<Messages.SimpleRequest> streamingCall(
+        final StreamObserver<Messages.SimpleResponse> observer) {
+      final ServerCallStreamObserver<Messages.SimpleResponse> responseObserver =
+          (ServerCallStreamObserver<Messages.SimpleResponse>) observer;
+      // TODO(spencerfang): flow control to stop reading when !responseObserver.isReady
+      return new StreamObserver<Messages.SimpleRequest>() {
         @Override
-        public void onNext(SimpleRequest request) {
-          SimpleResponse response = Utils.makeResponse(request);
-          responseObserver.onNext(response);
+        public void onNext(Messages.SimpleRequest value) {
+          if (shutdown.get()) {
+            responseObserver.onCompleted();
+            return;
+          }
+          responseObserver.onNext(Utils.makeResponse(value));
+        }
+
+        @Override
+        public void onError(Throwable t) {
+          // other side closed with non OK
+          responseObserver.onError(t);
+        }
+
+        @Override
+        public void onCompleted() {
+          // other side closed with OK
+          responseObserver.onCompleted();
+        }
+      };
+    }
+
+    @Override
+    public StreamObserver<Messages.SimpleRequest> streamingFromClient(
+        final StreamObserver<Messages.SimpleResponse> responseObserver) {
+      return new StreamObserver<Messages.SimpleRequest>() {
+        Messages.SimpleRequest lastSeen = null;
+
+        @Override
+        public void onNext(Messages.SimpleRequest value) {
+          if (shutdown.get()) {
+            responseObserver.onCompleted();
+            return;
+          }
+          lastSeen = value;
         }
 
         @Override
         public void onError(Throwable t) {
-          System.out.println("Encountered an error in streamingCall");
-          t.printStackTrace();
+          // other side closed with non OK
+          responseObserver.onError(t);
         }
 
         @Override
         public void onCompleted() {
+          if (lastSeen != null) {
+            responseObserver.onNext(Utils.makeResponse(lastSeen));
+            responseObserver.onCompleted();
+          } else {
+            responseObserver.onError(
+                Status.FAILED_PRECONDITION
+                    .withDescription("never received any requests").asException());
+          }
+        }
+      };
+    }
+
+    @Override
+    public void streamingFromServer(
+        final Messages.SimpleRequest request,
+        final StreamObserver<Messages.SimpleResponse> observer) {
+      // send forever, until the client cancels or we shut down
+      final Messages.SimpleResponse response = Utils.makeResponse(request);
+      final ServerCallStreamObserver<Messages.SimpleResponse> responseObserver =
+          (ServerCallStreamObserver<Messages.SimpleResponse>) observer;
+      Runnable onReady = () -> {
+        if (shutdown.get()) {
           responseObserver.onCompleted();
+          return;
+        }
+        while (responseObserver.isReady() && !responseObserver.isCancelled()) {
+          responseObserver.onNext(response);
         }
       };
+      responseObserver.setOnReadyHandler(onReady);
+      onReady.run();
     }
 
+    @Override
+    public StreamObserver<Messages.SimpleRequest> streamingBothWays(
+        final StreamObserver<Messages.SimpleResponse> observer) {
+      // receive data forever and send data forever until client cancels or we shut down.
+      final ServerCallStreamObserver<Messages.SimpleResponse> responseObserver =
+          (ServerCallStreamObserver<Messages.SimpleResponse>) observer;
+      Runnable onReady = () -> {
+        if (shutdown.get()) {
+          responseObserver.onCompleted();
+          return;
+        }
+        while (responseObserver.isReady() && !responseObserver.isCancelled()) {
+          responseObserver.onNext(BIDI_RESPONSE);
+        }
+      };
+      responseObserver.setOnReadyHandler(onReady);
+      onReady.run();
+      return new StreamObserver<Messages.SimpleRequest>() {
+        @Override
+        public void onNext(final Messages.SimpleRequest request) {
+          // noop
+        }
+
+        @Override
+        public void onError(Throwable t) {
+          // other side cancelled
+        }
+
+        @Override
+        public void onCompleted() {
+          // Should never happen, because clients should cancel this call in order to stop
+          // the operation. Also because copyWithFlowControl hogs the inbound network thread
+          // via the handler for onReady, we would never expect this callback to be able to
+          // run anyways.
+          log.severe("clients should CANCEL the call to stop bidi streaming");
+        }
+      };
+    }
   }
 }
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/qps/ClientConfiguration.java b/benchmarks/src/main/java/io/grpc/benchmarks/qps/ClientConfiguration.java
index 2ef8cb2f8cd..45061ffec49 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/ClientConfiguration.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/ClientConfiguration.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.qps;
@@ -41,13 +26,12 @@
 import io.grpc.benchmarks.proto.Control.RpcType;
 import io.grpc.benchmarks.proto.Messages;
 import io.grpc.benchmarks.proto.Messages.PayloadType;
-import io.grpc.testing.TestUtils;
+import io.grpc.internal.testing.TestUtils;
 import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.net.SocketAddress;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.LinkedHashSet;
+import java.util.Locale;
 import java.util.Set;
 
 /**
@@ -62,7 +46,7 @@ public class ClientConfiguration implements Configuration {
   String authorityOverride = TestUtils.TEST_SERVER_HOST;
   boolean useDefaultCiphers;
   boolean directExecutor;
-  SocketAddress address;
+  String target;
   int channels = 4;
   int outstandingRpcsPerChannel = 10;
   int serverPayload;
@@ -81,8 +65,8 @@ private ClientConfiguration() {
   }
 
   public ManagedChannel newChannel() throws IOException {
-    return Utils.newClientChannel(transport, address, tls, testca, authorityOverride,
-        useDefaultCiphers, flowControlWindow, directExecutor);
+    return Utils.newClientChannel(transport, target, tls, testca, authorityOverride,
+        flowControlWindow, directExecutor);
   }
 
   public Messages.SimpleRequest newRequest() {
@@ -119,20 +103,12 @@ protected ClientConfiguration build0(ClientConfiguration config) {
       if (config.tls) {
         if (!config.transport.tlsSupported) {
           throw new IllegalArgumentException(
-              "Transport " + config.transport.name().toLowerCase() + " does not support TLS.");
-        }
-
-        if (config.transport != Transport.OK_HTTP
-            && config.testca && config.address instanceof InetSocketAddress) {
-          // Override the socket address with the host from the testca.
-          InetSocketAddress address = (InetSocketAddress) config.address;
-          config.address = TestUtils.testServerAddress(address.getHostName(),
-                  address.getPort());
+              "Transport " + config.transport + " does not support TLS.");
         }
       }
 
       // Verify that the address type is correct for the transport type.
-      config.transport.validateSocketAddress(config.address);
+      config.transport.validateSocketAddress(config.target);
 
       return config;
     }
@@ -151,7 +127,7 @@ enum ClientParam implements AbstractConfigurationBuilder.Param {
         + "(unix:///path/to/file), depending on the transport selected.", null, true) {
       @Override
       protected void setClientValue(ClientConfiguration config, String value) {
-        config.address = Utils.parseSocketAddress(value);
+        config.target = value;
       }
     },
     CHANNELS("INT", "Number of Channels.", "" + DEFAULT.channels) {
@@ -191,17 +167,10 @@ protected void setClientValue(ClientConfiguration config, String value) {
         config.testca = parseBoolean(value);
       }
     },
-    USE_DEFAULT_CIPHERS("", "Use the default JDK ciphers for TLS (Used to support Java 7).",
-            "" + DEFAULT.useDefaultCiphers) {
-      @Override
-      protected void setClientValue(ClientConfiguration config, String value) {
-        config.useDefaultCiphers = parseBoolean(value);
-      }
-    },
-    TRANSPORT("STR", Transport.getDescriptionString(), DEFAULT.transport.name().toLowerCase()) {
+    TRANSPORT("STR", Transport.getDescriptionString(), DEFAULT.transport.toString()) {
       @Override
       protected void setClientValue(ClientConfiguration config, String value) {
-        config.transport = Transport.valueOf(value.toUpperCase());
+        config.transport = Transport.valueOf(value.toUpperCase(Locale.ROOT));
       }
     },
     DURATION("SECONDS", "Duration of the benchmark.", "" + DEFAULT.duration) {
@@ -268,7 +237,7 @@ protected void setClientValue(ClientConfiguration config, String value) {
 
     @Override
     public String getName() {
-      return name().toLowerCase();
+      return name().toLowerCase(Locale.ROOT);
     }
 
     @Override
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/qps/Configuration.java b/benchmarks/src/main/java/io/grpc/benchmarks/qps/Configuration.java
index 7f5202fa19f..ce2b643be2c 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/Configuration.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/Configuration.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.qps;
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/qps/OpenLoopClient.java b/benchmarks/src/main/java/io/grpc/benchmarks/qps/OpenLoopClient.java
index b055c3d6290..c44d7b67892 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/OpenLoopClient.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/OpenLoopClient.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.qps;
@@ -45,7 +30,6 @@
 import static io.grpc.benchmarks.qps.ClientConfiguration.ClientParam.TESTCA;
 import static io.grpc.benchmarks.qps.ClientConfiguration.ClientParam.TLS;
 import static io.grpc.benchmarks.qps.ClientConfiguration.ClientParam.TRANSPORT;
-import static io.grpc.benchmarks.qps.ClientConfiguration.ClientParam.USE_DEFAULT_CIPHERS;
 
 import io.grpc.Channel;
 import io.grpc.ManagedChannel;
@@ -81,7 +65,7 @@ public OpenLoopClient(ClientConfiguration config) {
   public static void main(String... args) throws Exception {
     ClientConfiguration.Builder configBuilder = ClientConfiguration.newBuilder(
         ADDRESS, TARGET_QPS, CLIENT_PAYLOAD, SERVER_PAYLOAD, TLS,
-        TESTCA, USE_DEFAULT_CIPHERS, TRANSPORT, DURATION, SAVE_HISTOGRAM, FLOW_CONTROL_WINDOW);
+        TESTCA, TRANSPORT, DURATION, SAVE_HISTOGRAM, FLOW_CONTROL_WINDOW);
     ClientConfiguration config;
     try {
       config = configBuilder.build(args);
@@ -152,7 +136,7 @@ static class LoadGenerationWorker implements Callable<Histogram> {
       stub = BenchmarkServiceGrpc.newStub(checkNotNull(channel, "channel"));
       this.request = checkNotNull(request, "request");
       this.targetQps = targetQps;
-      numRpcs = targetQps * duration;
+      numRpcs = (long) targetQps * duration;
       rnd = new Random();
     }
 
@@ -218,8 +202,8 @@ public void onCompleted() {
 
     private void waitForRpcsToComplete(int duration) {
       long now = System.nanoTime();
-      long end = now + duration * 1000 * 1000 * 1000;
-      while (histogram.getTotalCount() < numRpcs && now < end) {
+      long end = now + duration * 1000L * 1000L * 1000L;
+      while (histogram.getTotalCount() < numRpcs && end - now > 0) {
         now = System.nanoTime();
       }
     }
diff --git a/benchmarks/src/main/java/io/grpc/benchmarks/qps/ServerConfiguration.java b/benchmarks/src/main/java/io/grpc/benchmarks/qps/ServerConfiguration.java
index 43865eed30f..eb0b45c85e0 100644
--- a/benchmarks/src/main/java/io/grpc/benchmarks/qps/ServerConfiguration.java
+++ b/benchmarks/src/main/java/io/grpc/benchmarks/qps/ServerConfiguration.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.qps;
@@ -44,6 +29,7 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 
 /**
  * Configuration options for benchmark servers.
@@ -53,7 +39,6 @@ class ServerConfiguration implements Configuration {
 
   Transport transport = Transport.NETTY_NIO;
   boolean tls;
-  boolean useDefaultCiphers;
   boolean directExecutor;
   SocketAddress address;
   int flowControlWindow = NettyChannelBuilder.DEFAULT_FLOW_CONTROL_WINDOW;
@@ -85,7 +70,7 @@ protected Collection<Param> getParams() {
     protected ServerConfiguration build0(ServerConfiguration config) {
       if (config.tls && !config.transport.tlsSupported) {
         throw new IllegalArgumentException(
-            "TLS unsupported with the " + config.transport.name().toLowerCase() + " transport");
+            "TLS unsupported with the " + config.transport + " transport");
       }
 
       // Verify that the address type is correct for the transport type.
@@ -125,6 +110,11 @@ public enum Transport {
       this.socketAddressValidator = socketAddressValidator;
     }
 
+    @Override
+    public String toString() {
+      return name().toLowerCase(Locale.ROOT);
+    }
+
     /**
      * Validates the given address for this transport.
      *
@@ -144,7 +134,7 @@ static String getDescriptionString() {
         if (!first) {
           builder.append("\n");
         }
-        builder.append(transport.name().toLowerCase());
+        builder.append(transport);
         builder.append(": ");
         builder.append(transport.description);
         first = false;
@@ -158,7 +148,7 @@ enum ServerParam implements AbstractConfigurationBuilder.Param {
         + "(unix:///path/to/file), depending on the transport selected.", null, true) {
       @Override
       protected void setServerValue(ServerConfiguration config, String value) {
-        SocketAddress address = Utils.parseSocketAddress(value);
+        SocketAddress address = Utils.parseServerSocketAddress(value);
         if (address instanceof InetSocketAddress) {
           InetSocketAddress addr = (InetSocketAddress) address;
           int port = addr.getPort() == 0 ? Utils.pickUnusedPort() : addr.getPort();
@@ -174,17 +164,10 @@ protected void setServerValue(ServerConfiguration config, String value) {
         config.tls = parseBoolean(value);
       }
     },
-    USE_DEFAULT_CIPHERS("", "Use the default JDK ciphers for TLS (Used to support Java 7).",
-            "false") {
-      @Override
-      protected void setServerValue(ServerConfiguration config, String value) {
-        config.useDefaultCiphers = parseBoolean(value);
-      }
-    },
-    TRANSPORT("STR", Transport.getDescriptionString(), DEFAULT.transport.name().toLowerCase()) {
+    TRANSPORT("STR", Transport.getDescriptionString(), DEFAULT.transport.toString()) {
       @Override
       protected void setServerValue(ServerConfiguration config, String value) {
-        config.transport = Transport.valueOf(value.toUpperCase());
+        config.transport = Transport.valueOf(value.toUpperCase(Locale.ROOT));
       }
     },
     DIRECTEXECUTOR("", "Don't use a threadpool for RPC calls, instead execute calls directly "
@@ -220,7 +203,7 @@ protected void setServerValue(ServerConfiguration config, String value) {
 
     @Override
     public String getName() {
-      return name().toLowerCase();
+      return name().toLowerCase(Locale.ROOT);
     }
 
     @Override
diff --git a/benchmarks/src/main/proto/control.proto b/benchmarks/src/main/proto/control.proto
deleted file mode 100644
index 372a78629b7..00000000000
--- a/benchmarks/src/main/proto/control.proto
+++ /dev/null
@@ -1,175 +0,0 @@
-// Copyright 2015-2016, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-import "payloads.proto";
-import "stats.proto";
-
-package grpc.testing;
-
-option java_package = "io.grpc.benchmarks.proto";
-option java_outer_classname = "Control";
-
-enum ClientType {
-  SYNC_CLIENT = 0;
-  ASYNC_CLIENT = 1;
-}
-
-enum ServerType {
-  SYNC_SERVER = 0;
-  ASYNC_SERVER = 1;
-  ASYNC_GENERIC_SERVER = 2;
-}
-
-enum RpcType {
-  UNARY = 0;
-  STREAMING = 1;
-}
-
-// Parameters of poisson process distribution, which is a good representation
-// of activity coming in from independent identical stationary sources.
-message PoissonParams {
-  // The rate of arrivals (a.k.a. lambda parameter of the exp distribution).
-  double offered_load = 1;
-}
-
-message UniformParams {
-  double interarrival_lo = 1;
-  double interarrival_hi = 2;
-}
-
-message DeterministicParams { double offered_load = 1; }
-
-message ParetoParams {
-  double interarrival_base = 1;
-  double alpha = 2;
-}
-
-// Once an RPC finishes, immediately start a new one.
-// No configuration parameters needed.
-message ClosedLoopParams {}
-
-message LoadParams {
-  oneof load {
-    ClosedLoopParams closed_loop = 1;
-    PoissonParams poisson = 2;
-    UniformParams uniform = 3;
-    DeterministicParams determ = 4;
-    ParetoParams pareto = 5;
-  };
-}
-
-// presence of SecurityParams implies use of TLS
-message SecurityParams {
-  bool use_test_ca = 1;
-  string server_host_override = 2;
-}
-
-message ClientConfig {
-  // List of targets to connect to. At least one target needs to be specified.
-  repeated string server_targets = 1;
-  ClientType client_type = 2;
-  SecurityParams security_params = 3;
-  // How many concurrent RPCs to start for each channel.
-  // For synchronous client, use a separate thread for each outstanding RPC.
-  int32 outstanding_rpcs_per_channel = 4;
-  // Number of independent client channels to create.
-  // i-th channel will connect to server_target[i % server_targets.size()]
-  int32 client_channels = 5;
-  // Only for async client. Number of threads to use to start/manage RPCs.
-  int32 async_client_threads = 7;
-  RpcType rpc_type = 8;
-  // The requested load for the entire client (aggregated over all the threads).
-  LoadParams load_params = 10;
-  PayloadConfig payload_config = 11;
-  HistogramParams histogram_params = 12;
-
-  // Specify the cores we should run the client on, if desired
-  repeated int32 core_list = 13;
-  int32 core_limit = 14;
-}
-
-message ClientStatus { ClientStats stats = 1; }
-
-// Request current stats
-message Mark {
-  // if true, the stats will be reset after taking their snapshot.
-  bool reset = 1;
-}
-
-message ClientArgs {
-  oneof argtype {
-    ClientConfig setup = 1;
-    Mark mark = 2;
-  }
-}
-
-message ServerConfig {
-  ServerType server_type = 1;
-  SecurityParams security_params = 2;
-  // Port on which to listen. Zero means pick unused port.
-  int32 port = 4;
-  // Only for async server. Number of threads used to serve the requests.
-  int32 async_server_threads = 7;
-  // Specify the number of cores to limit server to, if desired
-  int32 core_limit = 8;
-  // payload config, used in generic server
-  PayloadConfig payload_config = 9;
-
-  // Specify the cores we should run the server on, if desired
-  repeated int32 core_list = 10;
-}
-
-message ServerArgs {
-  oneof argtype {
-    ServerConfig setup = 1;
-    Mark mark = 2;
-  }
-}
-
-message ServerStatus {
-  ServerStats stats = 1;
-  // the port bound by the server
-  int32 port = 2;
-  // Number of cores available to the server
-  int32 cores = 3;
-}
-
-message CoreRequest {
-}
-
-message CoreResponse {
-  // Number of cores available on the server
-  int32 cores = 1;
-}
-
-message Void {
-}
-
diff --git a/benchmarks/src/main/proto/grpc/testing/control.proto b/benchmarks/src/main/proto/grpc/testing/control.proto
new file mode 100644
index 00000000000..403450c83e8
--- /dev/null
+++ b/benchmarks/src/main/proto/grpc/testing/control.proto
@@ -0,0 +1,259 @@
+// Copyright 2015-2016 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.
+syntax = "proto3";
+
+import "grpc/testing/payloads.proto";
+import "grpc/testing/stats.proto";
+
+package grpc.testing;
+
+option java_package = "io.grpc.benchmarks.proto";
+option java_outer_classname = "Control";
+
+enum ClientType {
+  // Many languages support a basic distinction between using
+  // sync or async client, and this allows the specification
+  SYNC_CLIENT = 0;
+  ASYNC_CLIENT = 1;
+  OTHER_CLIENT = 2; // used for some language-specific variants
+}
+
+enum ServerType {
+  SYNC_SERVER = 0;
+  ASYNC_SERVER = 1;
+  ASYNC_GENERIC_SERVER = 2;
+  OTHER_SERVER = 3; // used for some language-specific variants
+}
+
+enum RpcType {
+  UNARY = 0;
+  STREAMING = 1;
+  STREAMING_FROM_CLIENT = 2;
+  STREAMING_FROM_SERVER = 3;
+  STREAMING_BOTH_WAYS = 4;
+}
+
+// Parameters of poisson process distribution, which is a good representation
+// of activity coming in from independent identical stationary sources.
+message PoissonParams {
+  // The rate of arrivals (a.k.a. lambda parameter of the exp distribution).
+  double offered_load = 1;
+}
+
+// Once an RPC finishes, immediately start a new one.
+// No configuration parameters needed.
+message ClosedLoopParams {}
+
+message LoadParams {
+  oneof load {
+    ClosedLoopParams closed_loop = 1;
+    PoissonParams poisson = 2;
+  };
+}
+
+// presence of SecurityParams implies use of TLS
+message SecurityParams {
+  bool use_test_ca = 1;
+  string server_host_override = 2;
+}
+
+message ChannelArg {
+  string name = 1;
+  oneof value {
+    string str_value = 2;
+    int32 int_value = 3;
+  }
+}
+
+message ClientConfig {
+  // List of targets to connect to. At least one target needs to be specified.
+  repeated string server_targets = 1;
+  ClientType client_type = 2;
+  SecurityParams security_params = 3;
+  // How many concurrent RPCs to start for each channel.
+  // For synchronous client, use a separate thread for each outstanding RPC.
+  int32 outstanding_rpcs_per_channel = 4;
+  // Number of independent client channels to create.
+  // i-th channel will connect to server_target[i % server_targets.size()]
+  int32 client_channels = 5;
+  // Only for async client. Number of threads to use to start/manage RPCs.
+  int32 async_client_threads = 7;
+  RpcType rpc_type = 8;
+  // The requested load for the entire client (aggregated over all the threads).
+  LoadParams load_params = 10;
+  PayloadConfig payload_config = 11;
+  HistogramParams histogram_params = 12;
+
+  // Specify the cores we should run the client on, if desired
+  repeated int32 core_list = 13;
+  int32 core_limit = 14;
+
+  // If we use an OTHER_CLIENT client_type, this string gives more detail
+  string other_client_api = 15;
+
+  repeated ChannelArg channel_args = 16;
+
+  // Number of messages on a stream before it gets finished/restarted
+  int32 messages_per_stream = 18;
+}
+
+message ClientStatus { ClientStats stats = 1; }
+
+// Request current stats
+message Mark {
+  // if true, the stats will be reset after taking their snapshot.
+  bool reset = 1;
+}
+
+message ClientArgs {
+  oneof argtype {
+    ClientConfig setup = 1;
+    Mark mark = 2;
+  }
+}
+
+message ServerConfig {
+  ServerType server_type = 1;
+  SecurityParams security_params = 2;
+  // Port on which to listen. Zero means pick unused port.
+  int32 port = 4;
+  // Only for async server. Number of threads used to serve the requests.
+  int32 async_server_threads = 7;
+  // Specify the number of cores to limit server to, if desired
+  int32 core_limit = 8;
+  // payload config, used in generic server.
+  // Note this must NOT be used in proto (non-generic) servers. For proto servers,
+  // 'response sizes' must be configured from the 'response_size' field of the
+  // 'SimpleRequest' objects in RPC requests.
+  PayloadConfig payload_config = 9;
+
+  // Specify the cores we should run the server on, if desired
+  repeated int32 core_list = 10;
+
+  // If we use an OTHER_SERVER client_type, this string gives more detail
+  string other_server_api = 11;
+
+  // c++-only options (for now) --------------------------------
+
+  // Buffer pool size (no buffer pool specified if unset)
+  int32 resource_quota_size = 1001;
+}
+
+message ServerArgs {
+  oneof argtype {
+    ServerConfig setup = 1;
+    Mark mark = 2;
+  }
+}
+
+message ServerStatus {
+  ServerStats stats = 1;
+  // the port bound by the server
+  int32 port = 2;
+  // Number of cores available to the server
+  int32 cores = 3;
+}
+
+message CoreRequest {
+}
+
+message CoreResponse {
+  // Number of cores available on the server
+  int32 cores = 1;
+}
+
+message Void {
+}
+
+// A single performance scenario: input to qps_json_driver
+message Scenario {
+  // Human readable name for this scenario
+  string name = 1;
+  // Client configuration
+  ClientConfig client_config = 2;
+  // Number of clients to start for the test
+  int32 num_clients = 3;
+  // Server configuration
+  ServerConfig server_config = 4;
+  // Number of servers to start for the test
+  int32 num_servers = 5;
+  // Warmup period, in seconds
+  int32 warmup_seconds = 6;
+  // Benchmark time, in seconds
+  int32 benchmark_seconds = 7;
+  // Number of workers to spawn locally (usually zero)
+  int32 spawn_local_worker_count = 8;
+}
+
+// A set of scenarios to be run with qps_json_driver
+message Scenarios {
+  repeated Scenario scenarios = 1;
+}
+
+// Basic summary that can be computed from ClientStats and ServerStats
+// once the scenario has finished.
+message ScenarioResultSummary
+{
+  // Total number of operations per second over all clients.
+  double qps = 1;
+  // QPS per one server core.
+  double qps_per_server_core = 2;
+  // server load based on system_time (0.85 => 85%)
+  double server_system_time = 3;
+  // server load based on user_time (0.85 => 85%)
+  double server_user_time = 4;
+  // client load based on system_time (0.85 => 85%)
+  double client_system_time = 5;
+  // client load based on user_time (0.85 => 85%)
+  double client_user_time = 6;
+
+  // X% latency percentiles (in nanoseconds)
+  double latency_50 = 7;
+  double latency_90 = 8;
+  double latency_95 = 9;
+  double latency_99 = 10;
+  double latency_999 = 11;
+
+  // server cpu usage percentage
+  double server_cpu_usage = 12;
+
+  // Number of requests that succeeded/failed
+  double successful_requests_per_second = 13;
+  double failed_requests_per_second = 14;
+
+  // Number of polls called inside completion queue per request
+  double client_polls_per_request = 15;
+  double server_polls_per_request = 16;
+}
+
+// Results of a single benchmark scenario.
+message ScenarioResult {
+  // Inputs used to run the scenario.
+  Scenario scenario = 1;
+  // Histograms from all clients merged into one histogram.
+  HistogramData latencies = 2;
+  // Client stats for each client
+  repeated ClientStats client_stats = 3;
+  // Server stats for each server
+  repeated ServerStats server_stats = 4;
+  // Number of cores available to each server
+  repeated int32 server_cores = 5;
+  // An after-the-fact computed summary
+  ScenarioResultSummary summary = 6;
+  // Information on success or failure of each worker
+  repeated bool client_success = 7;
+  repeated bool server_success = 8;
+  // Number of failed requests (one row per status code seen)
+  repeated RequestResultCount request_results = 9;
+}
diff --git a/benchmarks/src/main/proto/grpc/testing/messages.proto b/benchmarks/src/main/proto/grpc/testing/messages.proto
new file mode 100644
index 00000000000..ec8c4ffd34d
--- /dev/null
+++ b/benchmarks/src/main/proto/grpc/testing/messages.proto
@@ -0,0 +1,170 @@
+// Copyright 2015 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.
+// Message definitions to be used by integration test service definitions.
+
+syntax = "proto3";
+
+package grpc.testing;
+
+option java_package = "io.grpc.benchmarks.proto";
+option java_outer_classname = "Messages";
+
+// TODO(dgq): Go back to using well-known types once
+// https://github.com/grpc/grpc/issues/6980 has been fixed.
+// import "google/protobuf/wrappers.proto";
+message BoolValue {
+  // The bool value.
+  bool value = 1;
+}
+
+// DEPRECATED, don't use. To be removed shortly.
+// The type of payload that should be returned.
+enum PayloadType {
+  // Compressable text format.
+  COMPRESSABLE = 0;
+}
+
+// A block of data, to simply increase gRPC message size.
+message Payload {
+  // DEPRECATED, don't use. To be removed shortly.
+  // The type of data in body.
+  PayloadType type = 1;
+  // Primary contents of payload.
+  bytes body = 2;
+}
+
+// A protobuf representation for grpc status. This is used by test
+// clients to specify a status that the server should attempt to return.
+message EchoStatus {
+  int32 code = 1;
+  string message = 2;
+}
+
+// Unary request.
+message SimpleRequest {
+  // DEPRECATED, don't use. To be removed shortly.
+  // Desired payload type in the response from the server.
+  // If response_type is RANDOM, server randomly chooses one from other formats.
+  PayloadType response_type = 1;
+
+  // Desired payload size in the response from the server.
+  int32 response_size = 2;
+
+  // Optional input payload sent along with the request.
+  Payload payload = 3;
+
+  // Whether SimpleResponse should include username.
+  bool fill_username = 4;
+
+  // Whether SimpleResponse should include OAuth scope.
+  bool fill_oauth_scope = 5;
+
+  // Whether to request the server to compress the response. This field is
+  // "nullable" in order to interoperate seamlessly with clients not able to
+  // implement the full compression tests by introspecting the call to verify
+  // the response's compression status.
+  BoolValue response_compressed = 6;
+
+  // Whether server should return a given status
+  EchoStatus response_status = 7;
+
+  // Whether the server should expect this request to be compressed.
+  BoolValue expect_compressed = 8;
+}
+
+// Unary response, as configured by the request.
+message SimpleResponse {
+  // Payload to increase message size.
+  Payload payload = 1;
+  // The user the request came from, for verifying authentication was
+  // successful when the client expected it.
+  string username = 2;
+  // OAuth scope.
+  string oauth_scope = 3;
+}
+
+// Client-streaming request.
+message StreamingInputCallRequest {
+  // Optional input payload sent along with the request.
+  Payload payload = 1;
+
+  // Whether the server should expect this request to be compressed. This field
+  // is "nullable" in order to interoperate seamlessly with servers not able to
+  // implement the full compression tests by introspecting the call to verify
+  // the request's compression status.
+  BoolValue expect_compressed = 2;
+
+  // Not expecting any payload from the response.
+}
+
+// Client-streaming response.
+message StreamingInputCallResponse {
+  // Aggregated size of payloads received from the client.
+  int32 aggregated_payload_size = 1;
+}
+
+// Configuration for a particular response.
+message ResponseParameters {
+  // Desired payload sizes in responses from the server.
+  int32 size = 1;
+
+  // Desired interval between consecutive responses in the response stream in
+  // microseconds.
+  int32 interval_us = 2;
+
+  // Whether to request the server to compress the response. This field is
+  // "nullable" in order to interoperate seamlessly with clients not able to
+  // implement the full compression tests by introspecting the call to verify
+  // the response's compression status.
+  BoolValue compressed = 3;
+}
+
+// Server-streaming request.
+message StreamingOutputCallRequest {
+  // DEPRECATED, don't use. To be removed shortly.
+  // Desired payload type in the response from the server.
+  // If response_type is RANDOM, the payload from each response in the stream
+  // might be of different types. This is to simulate a mixed type of payload
+  // stream.
+  PayloadType response_type = 1;
+
+  // Configuration for each expected response message.
+  repeated ResponseParameters response_parameters = 2;
+
+  // Optional input payload sent along with the request.
+  Payload payload = 3;
+
+  // Whether server should return a given status
+  EchoStatus response_status = 7;
+}
+
+// Server-streaming response, as configured by the request and parameters.
+message StreamingOutputCallResponse {
+  // Payload to increase response size.
+  Payload payload = 1;
+}
+
+// For reconnect interop test only.
+// Client tells server what reconnection parameters it used.
+message ReconnectParams {
+  int32 max_reconnect_backoff_ms = 1;
+}
+
+// For reconnect interop test only.
+// Server tells client whether its reconnects are following the spec and the
+// reconnect backoffs it saw.
+message ReconnectInfo {
+  bool passed = 1;
+  repeated int32 backoff_ms = 2;
+}
diff --git a/benchmarks/src/main/proto/grpc/testing/payloads.proto b/benchmarks/src/main/proto/grpc/testing/payloads.proto
new file mode 100644
index 00000000000..6529d11d108
--- /dev/null
+++ b/benchmarks/src/main/proto/grpc/testing/payloads.proto
@@ -0,0 +1,42 @@
+// Copyright 2015 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.
+syntax = "proto3";
+
+package grpc.testing;
+
+option java_package = "io.grpc.benchmarks.proto";
+option java_outer_classname = "Payloads";
+
+message ByteBufferParams {
+  int32 req_size = 1;
+  int32 resp_size = 2;
+}
+
+message SimpleProtoParams {
+  int32 req_size = 1;
+  int32 resp_size = 2;
+}
+
+message ComplexProtoParams {
+  // TODO (vpai): Fill this in once the details of complex, representative
+  //              protos are decided
+}
+
+message PayloadConfig {
+  oneof payload {
+    ByteBufferParams bytebuf_params = 1;
+    SimpleProtoParams simple_params = 2;
+    ComplexProtoParams complex_params = 3;
+  }
+}
diff --git a/benchmarks/src/main/proto/grpc/testing/services.proto b/benchmarks/src/main/proto/grpc/testing/services.proto
new file mode 100644
index 00000000000..543d4e855c6
--- /dev/null
+++ b/benchmarks/src/main/proto/grpc/testing/services.proto
@@ -0,0 +1,76 @@
+// Copyright 2015-2016 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.
+// An integration test service that covers all the method signature permutations
+// of unary/streaming requests/responses.
+syntax = "proto3";
+
+import "grpc/testing/messages.proto";
+import "grpc/testing/control.proto";
+
+package grpc.testing;
+
+option java_package = "io.grpc.benchmarks.proto";
+option java_outer_classname = "Services";
+
+service BenchmarkService {
+  // One request followed by one response.
+  // The server returns the client payload as-is.
+  rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
+
+  // Repeated sequence of one request followed by one response.
+  // Should be called streaming ping-pong
+  // The server returns the client payload as-is on each response
+  rpc StreamingCall(stream SimpleRequest) returns (stream SimpleResponse);
+
+  // Single-sided unbounded streaming from client to server
+  // The server returns the client payload as-is once the client does WritesDone
+  rpc StreamingFromClient(stream SimpleRequest) returns (SimpleResponse);
+
+  // Single-sided unbounded streaming from server to client
+  // The server repeatedly returns the client payload as-is
+  rpc StreamingFromServer(SimpleRequest) returns (stream SimpleResponse);
+
+  // Two-sided unbounded streaming between server to client
+  // Both sides send the content of their own choice to the other
+  rpc StreamingBothWays(stream SimpleRequest) returns (stream SimpleResponse);
+}
+
+service WorkerService {
+  // Start server with specified workload.
+  // First request sent specifies the ServerConfig followed by ServerStatus
+  // response. After that, a "Mark" can be sent anytime to request the latest
+  // stats. Closing the stream will initiate shutdown of the test server
+  // and once the shutdown has finished, the OK status is sent to terminate
+  // this RPC.
+  rpc RunServer(stream ServerArgs) returns (stream ServerStatus);
+
+  // Start client with specified workload.
+  // First request sent specifies the ClientConfig followed by ClientStatus
+  // response. After that, a "Mark" can be sent anytime to request the latest
+  // stats. Closing the stream will initiate shutdown of the test client
+  // and once the shutdown has finished, the OK status is sent to terminate
+  // this RPC.
+  rpc RunClient(stream ClientArgs) returns (stream ClientStatus);
+
+  // Just return the core count - unary call
+  rpc CoreCount(CoreRequest) returns (CoreResponse);
+
+  // Quit this worker
+  rpc QuitWorker(Void) returns (Void);
+}
+
+service ReportQpsScenarioService {
+  // Report results of a QPS test benchmark scenario.
+  rpc ReportScenario(ScenarioResult) returns (Void);
+}
diff --git a/benchmarks/src/main/proto/grpc/testing/stats.proto b/benchmarks/src/main/proto/grpc/testing/stats.proto
new file mode 100644
index 00000000000..5a233aa9026
--- /dev/null
+++ b/benchmarks/src/main/proto/grpc/testing/stats.proto
@@ -0,0 +1,77 @@
+// Copyright 2015 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.
+syntax = "proto3";
+
+package grpc.testing;
+
+option java_package = "io.grpc.benchmarks.proto";
+option java_outer_classname = "Stats";
+
+message ServerStats {
+  // wall clock time change in seconds since last reset
+  double time_elapsed = 1;
+
+  // change in user time (in seconds) used by the server since last reset
+  double time_user = 2;
+
+  // change in server time (in seconds) used by the server process and all
+  // threads since last reset
+  double time_system = 3;
+
+  // change in total cpu time of the server (data from proc/stat)
+  uint64 total_cpu_time = 4;
+
+  // change in idle time of the server (data from proc/stat)
+  uint64 idle_cpu_time = 5;
+
+  // Number of polls called inside completion queue
+  uint64 cq_poll_count = 6;
+}
+
+// Histogram params based on grpc/support/histogram.c
+message HistogramParams {
+  double resolution = 1;   // first bucket is [0, 1 + resolution)
+  double max_possible = 2; // use enough buckets to allow this value
+}
+
+// Histogram data based on grpc/support/histogram.c
+message HistogramData {
+  repeated uint32 bucket = 1;
+  double min_seen = 2;
+  double max_seen = 3;
+  double sum = 4;
+  double sum_of_squares = 5;
+  double count = 6;
+}
+
+message RequestResultCount {
+  int32 status_code = 1;
+  int64 count = 2;
+}
+
+message ClientStats {
+  // Latency histogram. Data points are in nanoseconds.
+  HistogramData latencies = 1;
+
+  // See ServerStats for details.
+  double time_elapsed = 2;
+  double time_user = 3;
+  double time_system = 4;
+
+  // Number of failed requests (one row per status code seen)
+  repeated RequestResultCount request_results = 5;
+
+  // Number of polls called inside completion queue
+  uint64 cq_poll_count = 6;
+}
diff --git a/benchmarks/src/main/proto/messages.proto b/benchmarks/src/main/proto/messages.proto
deleted file mode 100644
index c966ff5d7a3..00000000000
--- a/benchmarks/src/main/proto/messages.proto
+++ /dev/null
@@ -1,170 +0,0 @@
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Message definitions to be used by integration test service definitions.
-
-syntax = "proto3";
-
-package grpc.testing;
-
-option java_package = "io.grpc.benchmarks.proto";
-option java_outer_classname = "Messages";
-
-
-// The type of payload that should be returned.
-enum PayloadType {
-  // Compressable text format.
-  COMPRESSABLE = 0;
-
-  // Uncompressable binary format.
-  UNCOMPRESSABLE = 1;
-
-  // Randomly chosen from all other formats defined in this enum.
-  RANDOM = 2;
-}
-
-// Compression algorithms
-enum CompressionType {
-  // No compression
-  NONE = 0;
-  GZIP = 1;
-  DEFLATE = 2;
-}
-
-// A block of data, to simply increase gRPC message size.
-message Payload {
-  // The type of data in body.
-  PayloadType type = 1;
-  // Primary contents of payload.
-  bytes body = 2;
-}
-
-// A protobuf representation for grpc status. This is used by test
-// clients to specify a status that the server should attempt to return.
-message EchoStatus {
-  int32 code = 1;
-  string message = 2;
-}
-
-// Unary request.
-message SimpleRequest {
-  // Desired payload type in the response from the server.
-  // If response_type is RANDOM, server randomly chooses one from other formats.
-  PayloadType response_type = 1;
-
-  // Desired payload size in the response from the server.
-  // If response_type is COMPRESSABLE, this denotes the size before compression.
-  int32 response_size = 2;
-
-  // Optional input payload sent along with the request.
-  Payload payload = 3;
-
-  // Whether SimpleResponse should include username.
-  bool fill_username = 4;
-
-  // Whether SimpleResponse should include OAuth scope.
-  bool fill_oauth_scope = 5;
-
-  // Compression algorithm to be used by the server for the response (stream)
-  CompressionType response_compression = 6;
-
-  // Whether server should return a given status
-  EchoStatus response_status = 7;
-}
-
-// Unary response, as configured by the request.
-message SimpleResponse {
-  // Payload to increase message size.
-  Payload payload = 1;
-  // The user the request came from, for verifying authentication was
-  // successful when the client expected it.
-  string username = 2;
-  // OAuth scope.
-  string oauth_scope = 3;
-}
-
-// Client-streaming request.
-message StreamingInputCallRequest {
-  // Optional input payload sent along with the request.
-  Payload payload = 1;
-
-  // Not expecting any payload from the response.
-}
-
-// Client-streaming response.
-message StreamingInputCallResponse {
-  // Aggregated size of payloads received from the client.
-  int32 aggregated_payload_size = 1;
-}
-
-// Configuration for a particular response.
-message ResponseParameters {
-  // Desired payload sizes in responses from the server.
-  // If response_type is COMPRESSABLE, this denotes the size before compression.
-  int32 size = 1;
-
-  // Desired interval between consecutive responses in the response stream in
-  // microseconds.
-  int32 interval_us = 2;
-}
-
-// Server-streaming request.
-message StreamingOutputCallRequest {
-  // Desired payload type in the response from the server.
-  // If response_type is RANDOM, the payload from each response in the stream
-  // might be of different types. This is to simulate a mixed type of payload
-  // stream.
-  PayloadType response_type = 1;
-
-  // Configuration for each expected response message.
-  repeated ResponseParameters response_parameters = 2;
-
-  // Optional input payload sent along with the request.
-  Payload payload = 3;
-
-  // Compression algorithm to be used by the server for the response (stream)
-  CompressionType response_compression = 6;
-
-  // Whether server should return a given status
-  EchoStatus response_status = 7;
-}
-
-// Server-streaming response, as configured by the request and parameters.
-message StreamingOutputCallResponse {
-  // Payload to increase response size.
-  Payload payload = 1;
-}
-
-// For reconnect interop test only.
-// Server tells client whether its reconnects are following the spec and the
-// reconnect backoffs it saw.
-message ReconnectInfo {
-  bool passed = 1;
-  repeated int32 backoff_ms = 2;
-}
\ No newline at end of file
diff --git a/benchmarks/src/main/proto/payloads.proto b/benchmarks/src/main/proto/payloads.proto
deleted file mode 100644
index 4af8688603d..00000000000
--- a/benchmarks/src/main/proto/payloads.proto
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package grpc.testing;
-
-option java_package = "io.grpc.benchmarks.proto";
-option java_outer_classname = "Payloads";
-
-message ByteBufferParams {
-  int32 req_size = 1;
-  int32 resp_size = 2;
-}
-
-message SimpleProtoParams {
-  int32 req_size = 1;
-  int32 resp_size = 2;
-}
-
-message ComplexProtoParams {
-  // TODO (vpai): Fill this in once the details of complex, representative
-  //              protos are decided
-}
-
-message PayloadConfig {
-  oneof payload {
-    ByteBufferParams bytebuf_params = 1;
-    SimpleProtoParams simple_params = 2;
-    ComplexProtoParams complex_params = 3;
-  }
-}
\ No newline at end of file
diff --git a/benchmarks/src/main/proto/services.proto b/benchmarks/src/main/proto/services.proto
deleted file mode 100644
index d76c5e02e5d..00000000000
--- a/benchmarks/src/main/proto/services.proto
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2015-2016, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// An integration test service that covers all the method signature permutations
-// of unary/streaming requests/responses.
-syntax = "proto3";
-
-import "messages.proto";
-import "control.proto";
-
-package grpc.testing;
-
-option java_package = "io.grpc.benchmarks.proto";
-option java_outer_classname = "Services";
-
-
-service BenchmarkService {
-  // One request followed by one response.
-  // The server returns the client payload as-is.
-  rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
-
-  // One request followed by one response.
-  // The server returns the client payload as-is.
-  rpc StreamingCall(stream SimpleRequest) returns (stream SimpleResponse);
-}
-
-service WorkerService {
-  // Start server with specified workload.
-  // First request sent specifies the ServerConfig followed by ServerStatus
-  // response. After that, a "Mark" can be sent anytime to request the latest
-  // stats. Closing the stream will initiate shutdown of the test server
-  // and once the shutdown has finished, the OK status is sent to terminate
-  // this RPC.
-  rpc RunServer(stream ServerArgs) returns (stream ServerStatus);
-
-  // Start client with specified workload.
-  // First request sent specifies the ClientConfig followed by ClientStatus
-  // response. After that, a "Mark" can be sent anytime to request the latest
-  // stats. Closing the stream will initiate shutdown of the test client
-  // and once the shutdown has finished, the OK status is sent to terminate
-  // this RPC.
-  rpc RunClient(stream ClientArgs) returns (stream ClientStatus);
-
-  // Just return the core count - unary call
-  rpc CoreCount(CoreRequest) returns (CoreResponse);
-
-  // Quit this worker
-  rpc QuitWorker(Void) returns (Void);
-}
\ No newline at end of file
diff --git a/benchmarks/src/main/proto/stats.proto b/benchmarks/src/main/proto/stats.proto
deleted file mode 100644
index eab9bb230b2..00000000000
--- a/benchmarks/src/main/proto/stats.proto
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package grpc.testing;
-
-option java_package = "io.grpc.benchmarks.proto";
-option java_outer_classname = "Stats";
-
-message ServerStats {
-  // wall clock time change in seconds since last reset
-  double time_elapsed = 1;
-
-  // change in user time (in seconds) used by the server since last reset
-  double time_user = 2;
-
-  // change in server time (in seconds) used by the server process and all
-  // threads since last reset
-  double time_system = 3;
-}
-
-// Histogram params based on grpc/support/histogram.c
-message HistogramParams {
-  double resolution = 1;   // first bucket is [0, 1 + resolution)
-  double max_possible = 2; // use enough buckets to allow this value
-}
-
-// Histogram data based on grpc/support/histogram.c
-message HistogramData {
-  repeated uint32 bucket = 1;
-  double min_seen = 2;
-  double max_seen = 3;
-  double sum = 4;
-  double sum_of_squares = 5;
-  double count = 6;
-}
-
-message ClientStats {
-  // Latency histogram. Data points are in nanoseconds.
-  HistogramData latencies = 1;
-
-  // See ServerStats for details.
-  double time_elapsed = 2;
-  double time_user = 3;
-  double time_system = 4;
-}
\ No newline at end of file
diff --git a/benchmarks/src/test/java/io/grpc/benchmarks/driver/LoadClientTest.java b/benchmarks/src/test/java/io/grpc/benchmarks/driver/LoadClientTest.java
index cb164976477..2ad8668b9fa 100644
--- a/benchmarks/src/test/java/io/grpc/benchmarks/driver/LoadClientTest.java
+++ b/benchmarks/src/test/java/io/grpc/benchmarks/driver/LoadClientTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.driver;
@@ -36,6 +21,7 @@
 
 import io.grpc.benchmarks.proto.Control;
 import io.grpc.benchmarks.proto.Stats;
+import org.junit.After;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -45,6 +31,14 @@
  */
 @RunWith(JUnit4.class)
 public class LoadClientTest {
+  private LoadClient loadClient;
+
+  @After
+  public void tearDown() {
+    if (loadClient != null) {
+      loadClient.shutdownNow();
+    }
+  }
 
   @Test
   public void testHistogramToStatsConversion() throws Exception {
@@ -63,7 +57,7 @@ public void testHistogramToStatsConversion() throws Exception {
     config.getLoadParamsBuilder().getClosedLoopBuilder();
     config.addServerTargets("localhost:9999");
 
-    LoadClient loadClient = new LoadClient(config.build());
+    loadClient = new LoadClient(config.build());
     loadClient.delay(1);
     loadClient.delay(10);
     loadClient.delay(10);
@@ -77,9 +71,9 @@ public void testHistogramToStatsConversion() throws Exception {
 
     Stats.ClientStats stats = loadClient.getStats();
 
-    assertEquals(1.0, stats.getLatencies().getMinSeen());
-    assertEquals(1000.0, stats.getLatencies().getMaxSeen());
-    assertEquals(10.0, stats.getLatencies().getCount());
+    assertEquals(1.0, stats.getLatencies().getMinSeen(), 0.0);
+    assertEquals(1000.0, stats.getLatencies().getMaxSeen(), 0.0);
+    assertEquals(10.0, stats.getLatencies().getCount(), 0.0);
 
     double base = 0;
     double logBase = 1;
diff --git a/benchmarks/src/test/java/io/grpc/benchmarks/driver/LoadWorkerTest.java b/benchmarks/src/test/java/io/grpc/benchmarks/driver/LoadWorkerTest.java
index 429bc1e7a8a..d4669325aac 100644
--- a/benchmarks/src/test/java/io/grpc/benchmarks/driver/LoadWorkerTest.java
+++ b/benchmarks/src/test/java/io/grpc/benchmarks/driver/LoadWorkerTest.java
@@ -1,39 +1,25 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.benchmarks.driver;
 
-import static org.junit.Assert.assertTrue;
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.fail;
 
+import com.google.common.util.concurrent.SettableFuture;
 import io.grpc.ManagedChannel;
 import io.grpc.benchmarks.Utils;
 import io.grpc.benchmarks.proto.Control;
@@ -41,23 +27,22 @@
 import io.grpc.benchmarks.proto.WorkerServiceGrpc;
 import io.grpc.netty.NettyChannelBuilder;
 import io.grpc.stub.StreamObserver;
-import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
 /**
- * Basic tests for {@link io.grpc.benchmarks.driver.LoadWorker}
+ * Basic tests for {@link io.grpc.benchmarks.driver.LoadWorker}.
  */
 @RunWith(JUnit4.class)
 public class LoadWorkerTest {
 
 
-  private static final int TIMEOUT = 5;
+  private static final int TIMEOUT = 20;
   private static final Control.ClientArgs MARK = Control.ClientArgs.newBuilder()
       .setMark(Control.Mark.newBuilder().setReset(true).build())
       .build();
@@ -66,15 +51,28 @@ public class LoadWorkerTest {
   private ManagedChannel channel;
   private WorkerServiceGrpc.WorkerServiceStub workerServiceStub;
   private LinkedBlockingQueue<Stats.ClientStats> marksQueue;
+  private StreamObserver<Control.ServerArgs> serverLifetime;
 
   @Before
   public void setup() throws Exception {
     int port = Utils.pickUnusedPort();
     worker = new LoadWorker(port, 0);
     worker.start();
-    channel = NettyChannelBuilder.forAddress("localhost", port).usePlaintext(true).build();
+    channel = NettyChannelBuilder.forAddress("localhost", port).usePlaintext().build();
     workerServiceStub = WorkerServiceGrpc.newStub(channel);
-    marksQueue = new LinkedBlockingQueue<Stats.ClientStats>();
+    marksQueue = new LinkedBlockingQueue<>();
+  }
+
+  @After
+  public void tearDown() {
+    if (serverLifetime != null) {
+      serverLifetime.onCompleted();
+    }
+    try {
+      WorkerServiceGrpc.newBlockingStub(channel).quitWorker(Control.Void.getDefaultInstance());
+    } finally {
+      channel.shutdownNow();
+    }
   }
 
   @Test
@@ -196,7 +194,7 @@ private void assertWorkOccurred(StreamObserver<Control.ClientArgs> clientObserve
       throws InterruptedException {
 
     Stats.ClientStats stat = null;
-    for (int i = 0; i < 3; i++) {
+    for (int i = 0; i < 30; i++) {
       // Poll until we get some stats
       Thread.sleep(300);
       clientObserver.onNext(MARK);
@@ -209,22 +207,22 @@ private void assertWorkOccurred(StreamObserver<Control.ClientArgs> clientObserve
       }
     }
     clientObserver.onCompleted();
-    assertTrue(stat.hasLatencies());
-    assertTrue(stat.getLatencies().getCount() < stat.getLatencies().getSum());
+    assertThat(stat.hasLatencies()).isTrue();
+    assertThat(stat.getLatencies().getCount()).isLessThan(stat.getLatencies().getSum());
     double mean = stat.getLatencies().getSum() / stat.getLatencies().getCount();
-    System.out.println("Mean " + mean + " us");
-    assertTrue(mean > stat.getLatencies().getMinSeen());
-    assertTrue(mean < stat.getLatencies().getMaxSeen());
+    System.out.println("Mean " + mean + " ns");
+    assertThat(stat.getLatencies().getMinSeen()).isLessThan(mean);
+    assertThat(stat.getLatencies().getMaxSeen()).isGreaterThan(mean);
   }
 
   private StreamObserver<Control.ClientArgs> startClient(Control.ClientArgs clientArgs)
-      throws InterruptedException {
-    final CountDownLatch clientReady = new CountDownLatch(1);
+      throws Exception {
+    final SettableFuture<Void> clientReady = SettableFuture.create();
     StreamObserver<Control.ClientArgs> clientObserver = workerServiceStub.runClient(
         new StreamObserver<Control.ClientStatus>() {
           @Override
           public void onNext(Control.ClientStatus value) {
-            clientReady.countDown();
+            clientReady.set(null);
             if (value.hasStats()) {
               marksQueue.add(value.getStats());
             }
@@ -232,45 +230,43 @@ public void onNext(Control.ClientStatus value) {
 
           @Override
           public void onError(Throwable t) {
+            clientReady.setException(t);
           }
 
           @Override
           public void onCompleted() {
+            clientReady.setException(
+                new RuntimeException("onCompleted() before receiving response"));
           }
         });
 
     // Start the client
     clientObserver.onNext(clientArgs);
-    if (!clientReady.await(TIMEOUT, TimeUnit.SECONDS)) {
-      fail("Client failed to start");
-    }
+    clientReady.get(TIMEOUT, TimeUnit.SECONDS);
     return clientObserver;
   }
 
-  private int startServer(Control.ServerArgs serverArgs) throws InterruptedException {
-    final AtomicInteger serverPort = new AtomicInteger();
-    final CountDownLatch serverReady = new CountDownLatch(1);
-    StreamObserver<Control.ServerArgs> serverObserver =
+  private int startServer(Control.ServerArgs serverArgs) throws Exception {
+    final SettableFuture<Integer> port = SettableFuture.create();
+    serverLifetime =
         workerServiceStub.runServer(new StreamObserver<Control.ServerStatus>() {
           @Override
           public void onNext(Control.ServerStatus value) {
-            serverPort.set(value.getPort());
-            serverReady.countDown();
+            port.set(value.getPort());
           }
 
           @Override
           public void onError(Throwable t) {
+            port.setException(t);
           }
 
           @Override
           public void onCompleted() {
+            port.setException(new RuntimeException("onCompleted() before receiving response"));
           }
         });
     // trigger server startup
-    serverObserver.onNext(serverArgs);
-    if (!serverReady.await(TIMEOUT, TimeUnit.SECONDS)) {
-      fail("Server failed to start");
-    }
-    return serverPort.get();
+    serverLifetime.onNext(serverArgs);
+    return port.get(TIMEOUT, TimeUnit.SECONDS);
   }
 }
diff --git a/binder/build.gradle b/binder/build.gradle
new file mode 100644
index 00000000000..d1302ddfed0
--- /dev/null
+++ b/binder/build.gradle
@@ -0,0 +1,136 @@
+plugins {
+    id "maven-publish"
+    id "com.android.library"
+}
+
+description = 'gRPC BinderChannel'
+
+android {
+    namespace = 'io.grpc.binder'
+    compileSdkVersion 34
+    compileOptions {
+        sourceCompatibility 1.8
+        targetCompatibility 1.8
+    }
+    defaultConfig {
+        minSdkVersion 22
+        targetSdkVersion 33
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        multiDexEnabled = true
+    }
+    lintOptions { abortOnError = false }
+    publishing {
+        singleVariant('release') {
+            withSourcesJar()
+            withJavadocJar()
+        }
+    }
+    testFixtures { enable = true }
+}
+
+repositories {
+    google()
+}
+
+dependencies {
+    api project(':grpc-api')
+
+    implementation project(':grpc-core')
+    implementation libraries.androidx.annotation
+    implementation libraries.androidx.core
+    implementation libraries.androidx.lifecycle.common
+    implementation libraries.guava
+    testImplementation libraries.androidx.core
+    testImplementation libraries.androidx.test.core
+    testImplementation libraries.androidx.lifecycle.common
+    testImplementation libraries.androidx.lifecycle.service
+    testImplementation libraries.junit
+    testImplementation libraries.mockito.core
+    testImplementation libraries.robolectric
+    testImplementation libraries.guava.testlib
+    testImplementation libraries.truth
+    testImplementation project(':grpc-protobuf-lite')
+    testImplementation project(':grpc-testing')
+    testImplementation project(':grpc-inprocess')
+    testImplementation testFixtures(project(':grpc-core'))
+
+    androidTestAnnotationProcessor libraries.auto.value
+    androidTestImplementation project(':grpc-testing')
+    androidTestImplementation project(':grpc-protobuf-lite')
+    androidTestImplementation libraries.auto.value.annotations
+    androidTestImplementation libraries.junit
+    androidTestImplementation libraries.androidx.core
+    androidTestImplementation libraries.androidx.test.core
+    androidTestImplementation libraries.androidx.test.rules
+    androidTestImplementation libraries.androidx.test.ext.junit
+    androidTestImplementation libraries.truth
+    androidTestImplementation libraries.mockito.android
+    androidTestImplementation libraries.androidx.lifecycle.service
+    androidTestImplementation libraries.guava.testlib
+    androidTestImplementation testFixtures(project(':grpc-core'))
+
+    testFixturesImplementation libraries.guava.testlib
+    testFixturesImplementation testFixtures(project(':grpc-core'))
+}
+
+import net.ltgt.gradle.errorprone.CheckSeverity
+
+tasks.withType(JavaCompile).configureEach {
+    options.compilerArgs += [
+            "-Xlint:-cast",
+            // For junit-1.15-api & org.robolectric/shadows-framework/4.11.1
+            "-Xlint:-classfile",
+            // Unclaimed annotations. TODO(jdcormie): Fix?
+            "-Xlint:-processing",
+    ]
+    appendToProperty(it.options.errorprone.excludedPaths, ".*/R.java", "|")
+}
+
+tasks.register("javadocs", Javadoc) {
+    source = android.sourceSets.main.java.srcDirs
+    exclude 'io/grpc/binder/internal/**'
+    exclude 'io/grpc/binder/Internal*'
+    classpath += files(android.getBootClasspath())
+    classpath += files({
+        android.libraryVariants.collect { variant ->
+            variant.javaCompileProvider.get().classpath
+        }
+    })
+    options {
+        // Disable JavaDoc doclint on Java 8.
+        if (JavaVersion.current().isJava8Compatible()) {
+            addStringOption('Xdoclint:none', '-quiet')
+        }
+    }
+    // This is to enable moving to Java 11. An existing problem with javadoc
+    // produces a warning under Java 8, but with Java 11 it fails the build.
+    failOnError false
+}
+
+tasks.register("javadocJar", Jar) {
+    dependsOn javadocs
+    archiveClassifier = 'javadoc'
+    from javadocs.destinationDir
+}
+
+tasks.register("sourcesJar", Jar) {
+    archiveClassifier = 'sources'
+    from android.sourceSets.main.java.srcDirs
+}
+
+publishing {
+    publications {
+        maven {
+            afterEvaluate {
+                from components.release
+            }
+        }
+    }
+}
+
+afterEvaluate {
+    components.release.withVariantsFromConfiguration(configurations.releaseTestFixturesVariantReleaseApiPublication) { skip() }
+    components.release.withVariantsFromConfiguration(configurations.releaseTestFixturesVariantReleaseRuntimePublication) { skip() }
+}
diff --git a/binder/src/androidTest/AndroidManifest.xml b/binder/src/androidTest/AndroidManifest.xml
new file mode 100644
index 00000000000..44f21e104d9
--- /dev/null
+++ b/binder/src/androidTest/AndroidManifest.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" >
+
+  <instrumentation
+      android:name="androidx.test.runner.AndroidJUnitRunner"
+      android:targetPackage="io.grpc.binder" />
+
+  <application android:debuggable="true">
+    <uses-library android:name="android.test.runner" />
+
+    <service android:name="io.grpc.binder.HostServices$HostService1" android:exported="false">
+      <intent-filter>
+        <action android:name="action1"/>
+        <data android:scheme="scheme" android:host="authority" android:path="/path"/>
+      </intent-filter>
+    </service>
+    <service android:name="io.grpc.binder.HostServices$HostService2" android:exported="false">
+      <intent-filter>
+        <action android:name="action2"/>
+        <data android:scheme="scheme" android:host="authority" android:path="/path"/>
+      </intent-filter>
+    </service>
+  </application>
+</manifest>
diff --git a/binder/src/androidTest/java/io/grpc/binder/BinderChannelSmokeTest.java b/binder/src/androidTest/java/io/grpc/binder/BinderChannelSmokeTest.java
new file mode 100644
index 00000000000..4e3cfcf0d05
--- /dev/null
+++ b/binder/src/androidTest/java/io/grpc/binder/BinderChannelSmokeTest.java
@@ -0,0 +1,424 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static java.util.concurrent.TimeUnit.MINUTES;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.common.io.ByteStreams;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientInterceptors;
+import io.grpc.ConnectivityState;
+import io.grpc.ForwardingServerCall.SimpleForwardingServerCall;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCall;
+import io.grpc.ServerCall.Listener;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerInterceptors;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status.Code;
+import io.grpc.StatusRuntimeException;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.stub.ClientCalls;
+import io.grpc.stub.MetadataUtils;
+import io.grpc.stub.ServerCalls;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.TestUtils;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * Basic tests for Binder Channel, covering some of the edge cases not exercised by
+ * AbstractTransportTest.
+ */
+@RunWith(AndroidJUnit4.class)
+public final class BinderChannelSmokeTest {
+  private final Context appContext = ApplicationProvider.getApplicationContext();
+
+  private static final int SLIGHTLY_MORE_THAN_ONE_BLOCK = 16 * 1024 + 100;
+  private static final String MSG = "Some text which will be repeated many many times";
+  private static final Metadata.Key<PoisonParcelable> POISON_KEY =
+      ParcelableUtils.metadataKey("poison-bin", PoisonParcelable.CREATOR);
+
+  final MethodDescriptor<String, String> method =
+      MethodDescriptor.newBuilder(StringMarshaller.INSTANCE, StringMarshaller.INSTANCE)
+          .setFullMethodName("test/method")
+          .setType(MethodDescriptor.MethodType.UNARY)
+          .build();
+
+  final MethodDescriptor<String, String> singleLargeResultMethod =
+      MethodDescriptor.newBuilder(StringMarshaller.INSTANCE, StringMarshaller.INSTANCE)
+          .setFullMethodName("test/noResultMethod")
+          .setType(MethodDescriptor.MethodType.SERVER_STREAMING)
+          .build();
+
+  final MethodDescriptor<String, String> bidiMethod =
+      MethodDescriptor.newBuilder(StringMarshaller.INSTANCE, StringMarshaller.INSTANCE)
+          .setFullMethodName("test/bidiMethod")
+          .setType(MethodDescriptor.MethodType.BIDI_STREAMING)
+          .build();
+
+  AndroidComponentAddress serverAddress;
+  ManagedChannel channel;
+  AtomicReference<Metadata> headersCapture = new AtomicReference<>();
+  AtomicReference<PeerUid> clientUidCapture = new AtomicReference<>();
+  PoisonParcelable parcelableForResponseHeaders;
+
+  @Before
+  public void setUp() throws Exception {
+    ServerCallHandler<String, String> callHandler =
+        ServerCalls.asyncUnaryCall(
+            (req, respObserver) -> {
+              clientUidCapture.set(PeerUids.REMOTE_PEER.get());
+              respObserver.onNext(req);
+              respObserver.onCompleted();
+            });
+
+    ServerCallHandler<String, String> singleLargeResultCallHandler =
+        ServerCalls.asyncUnaryCall(
+            (req, respObserver) -> {
+              clientUidCapture.set(PeerUids.REMOTE_PEER.get());
+              respObserver.onNext(createLargeString(SLIGHTLY_MORE_THAN_ONE_BLOCK));
+              respObserver.onCompleted();
+            });
+
+    ServerCallHandler<String, String> bidiCallHandler =
+        ServerCalls.asyncBidiStreamingCall(ForwardingStreamObserver::new); // Echo it all back.
+
+    ServerServiceDefinition serviceDef =
+        ServerInterceptors.intercept(
+            ServerServiceDefinition.builder("test")
+                .addMethod(method, callHandler)
+                .addMethod(singleLargeResultMethod, singleLargeResultCallHandler)
+                .addMethod(bidiMethod, bidiCallHandler)
+                .build(),
+            new AddParcelableServerInterceptor(),
+            TestUtils.recordRequestHeadersInterceptor(headersCapture),
+            PeerUids.newPeerIdentifyingServerInterceptor());
+
+    serverAddress = HostServices.allocateService(appContext);
+    HostServices.configureService(
+        serverAddress,
+        HostServices.serviceParamsBuilder()
+            .setServerFactory(
+                (service, receiver) ->
+                    BinderServerBuilder.forAddress(serverAddress, receiver)
+                        .inboundParcelablePolicy(
+                            InboundParcelablePolicy.newBuilder()
+                                .setAcceptParcelableMetadataValues(true)
+                                .build())
+                        .addService(serviceDef)
+                        .build())
+            .build());
+
+    channel = newBinderChannelBuilder().build();
+  }
+
+  BinderChannelBuilder newBinderChannelBuilder() {
+    return BinderChannelBuilder.forAddress(serverAddress, appContext)
+            .inboundParcelablePolicy(
+                    InboundParcelablePolicy.newBuilder()
+                            .setAcceptParcelableMetadataValues(true)
+                            .build());
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    channel.shutdownNow();
+    HostServices.awaitServiceShutdown();
+  }
+
+  private ListenableFuture<String> doCall(String request) {
+    return doCall(method, request);
+  }
+
+  private ListenableFuture<String> doCall(
+      MethodDescriptor<String, String> methodDesc, String request) {
+    return doCall(methodDesc, request, CallOptions.DEFAULT);
+  }
+
+  private ListenableFuture<String> doCall(
+      MethodDescriptor<String, String> methodDesc, String request, CallOptions callOptions) {
+    ListenableFuture<String> future =
+        ClientCalls.futureUnaryCall(channel.newCall(methodDesc, callOptions), request);
+    return withTestTimeout(future);
+  }
+
+  @Test
+  public void testBasicCall() throws Exception {
+    assertThat(doCall("Hello").get()).isEqualTo("Hello");
+  }
+
+  @Test
+  public void testBasicCallWithLegacyAuthStrategy() throws Exception {
+    channel = newBinderChannelBuilder().useLegacyAuthStrategy().build();
+    assertThat(doCall("Hello").get()).isEqualTo("Hello");
+  }
+
+  @Test
+  public void testBasicCallWithV2AuthStrategy() throws Exception {
+    channel = newBinderChannelBuilder().useV2AuthStrategy().build();
+    assertThat(doCall("Hello").get()).isEqualTo("Hello");
+  }
+
+  @Test
+  public void testPeerUidIsRecorded() throws Exception {
+    assertThat(doCall("Hello").get()).isEqualTo("Hello");
+    assertThat(clientUidCapture.get()).isEqualTo(PeerUid.forCurrentProcess());
+  }
+
+  @Test
+  public void testEmptyMessage() throws Exception {
+    assertThat(doCall("").get()).isEmpty();
+  }
+
+  @Test
+  public void test100kString() throws Exception {
+    String fullMsg = createLargeString(100000);
+    assertThat(doCall(fullMsg).get()).isEqualTo(fullMsg);
+  }
+
+  @Test
+  public void testSingleLargeResultCall() throws Exception {
+    String res = doCall(singleLargeResultMethod, "hello").get();
+    assertThat(res.length()).isEqualTo(SLIGHTLY_MORE_THAN_ONE_BLOCK);
+  }
+
+  @Test
+  public void testSingleRequestCallOptionHeaders() throws Exception {
+    CallOptions callOptions = CallOptions.DEFAULT.withDeadlineAfter(1234, MINUTES);
+    assertThat(doCall(method, "Hello", callOptions).get()).isEqualTo("Hello");
+    assertThat(headersCapture.get().get(GrpcUtil.TIMEOUT_KEY)).isGreaterThan(0);
+  }
+
+  @Test
+  public void testStreamingCallOptionHeaders() throws Exception {
+    CallOptions callOptions = CallOptions.DEFAULT.withDeadlineAfter(1234, MINUTES);
+    QueueingStreamObserver<String> responseStreamObserver = new QueueingStreamObserver<>();
+    StreamObserver<String> streamObserver =
+        ClientCalls.asyncBidiStreamingCall(
+            channel.newCall(bidiMethod, callOptions), responseStreamObserver);
+    streamObserver.onCompleted();
+    assertThat(withTestTimeout(responseStreamObserver.getAllStreamElements()).get()).isEmpty();
+    assertThat(headersCapture.get().get(GrpcUtil.TIMEOUT_KEY)).isGreaterThan(0);
+  }
+
+  @Test
+  public void testConnectViaTargetUri() throws Exception {
+    // Compare with the <intent-filter> mapping in AndroidManifest.xml.
+    channel =
+        BinderChannelBuilder.forTarget(
+                "intent://authority/path#Intent;action=action1;scheme=scheme;end;", appContext)
+            .build();
+    assertThat(doCall("Hello").get()).isEqualTo("Hello");
+  }
+
+  @Test
+  public void testConnectViaIntentFilter() throws Exception {
+    // Compare with the <intent-filter> mapping in AndroidManifest.xml.
+    channel =
+        BinderChannelBuilder.forAddress(
+                AndroidComponentAddress.forBindIntent(
+                    new Intent()
+                        .setAction("action1")
+                        .setData(Uri.parse("scheme://authority/path"))
+                        .setPackage(appContext.getPackageName())),
+                appContext)
+            .build();
+    assertThat(doCall("Hello").get()).isEqualTo("Hello");
+  }
+
+  @Test
+  public void testUncaughtServerException() throws Exception {
+    // Use a poison parcelable to cause an unexpected Exception in the server's onTransact().
+    PoisonParcelable bad = new PoisonParcelable();
+    Metadata extraHeadersToSend = new Metadata();
+    extraHeadersToSend.put(POISON_KEY, bad);
+    Channel interceptedChannel =
+        ClientInterceptors.intercept(
+            channel, MetadataUtils.newAttachHeadersInterceptor(extraHeadersToSend));
+    CallOptions callOptions = CallOptions.DEFAULT.withDeadlineAfter(5, SECONDS);
+    try {
+      ClientCalls.blockingUnaryCall(interceptedChannel, method, callOptions, "hello");
+      Assert.fail();
+    } catch (StatusRuntimeException e) {
+      // We don't care how *our* RPC failed, but make sure we didn't have to rely on the deadline.
+      assertThat(e.getStatus().getCode()).isNotEqualTo(Code.DEADLINE_EXCEEDED);
+      assertThat(channel.getState(false)).isEqualTo(ConnectivityState.IDLE);
+    }
+  }
+
+  @Test
+  public void testUncaughtClientException() throws Exception {
+    // Use a poison parcelable to cause an unexpected Exception in the client's onTransact().
+    parcelableForResponseHeaders = new PoisonParcelable();
+    CallOptions callOptions = CallOptions.DEFAULT.withDeadlineAfter(5, SECONDS);
+    try {
+      ClientCalls.blockingUnaryCall(channel, method, callOptions, "hello");
+      Assert.fail();
+    } catch (StatusRuntimeException e) {
+      // We don't care *how* our RPC failed, but make sure we didn't have to rely on the deadline.
+      assertThat(e.getStatus().getCode()).isNotEqualTo(Code.DEADLINE_EXCEEDED);
+      assertThat(channel.getState(false)).isEqualTo(ConnectivityState.IDLE);
+    }
+  }
+
+  private static String createLargeString(int size) {
+    StringBuilder sb = new StringBuilder();
+    while (sb.length() < size) {
+      sb.append(MSG);
+    }
+    sb.setLength(size);
+    return sb.toString();
+  }
+
+  private static <V> ListenableFuture<V> withTestTimeout(ListenableFuture<V> future) {
+    return Futures.withTimeout(future, 5L, SECONDS, Executors.newSingleThreadScheduledExecutor());
+  }
+
+  private static class StringMarshaller implements MethodDescriptor.Marshaller<String> {
+    public static final StringMarshaller INSTANCE = new StringMarshaller();
+
+    @Override
+    public InputStream stream(String value) {
+      return new ByteArrayInputStream(value.getBytes(UTF_8));
+    }
+
+    @Override
+    public String parse(InputStream stream) {
+      try {
+        return new String(ByteStreams.toByteArray(stream), UTF_8);
+      } catch (IOException ex) {
+        throw new RuntimeException(ex);
+      }
+    }
+  }
+
+  private static class QueueingStreamObserver<V> implements StreamObserver<V> {
+    private final ArrayList<V> elements = new ArrayList<>();
+    private final SettableFuture<Iterable<V>> result = SettableFuture.create();
+
+    public ListenableFuture<Iterable<V>> getAllStreamElements() {
+      return result;
+    }
+
+    @Override
+    public void onNext(V value) {
+      elements.add(value);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+      result.setException(t);
+    }
+
+    @Override
+    public void onCompleted() {
+      result.set(elements);
+    }
+  }
+
+  private static class ForwardingStreamObserver<V> implements StreamObserver<V> {
+    private final StreamObserver<V> delegate;
+
+    ForwardingStreamObserver(StreamObserver<V> delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    public void onNext(V value) {
+      delegate.onNext(value);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+      delegate.onError(t);
+    }
+
+    @Override
+    public void onCompleted() {
+      delegate.onCompleted();
+    }
+  }
+
+  class AddParcelableServerInterceptor implements ServerInterceptor {
+    @Override
+    public <ReqT, RespT> Listener<ReqT> interceptCall(
+        ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+      return next.startCall(
+          new SimpleForwardingServerCall<ReqT, RespT>(call) {
+            @Override
+            public void sendHeaders(Metadata headers) {
+              if (parcelableForResponseHeaders != null) {
+                headers.put(POISON_KEY, parcelableForResponseHeaders);
+              }
+              super.sendHeaders(headers);
+            }
+          },
+          headers);
+    }
+  }
+
+  static class PoisonParcelable implements Parcelable {
+
+    public static final Creator<PoisonParcelable> CREATOR =
+        new Parcelable.Creator<PoisonParcelable>() {
+          @Override
+          public PoisonParcelable createFromParcel(Parcel parcel) {
+            throw new RuntimeException("ouch");
+          }
+
+          @Override
+          public PoisonParcelable[] newArray(int n) {
+            return new PoisonParcelable[n];
+          }
+        };
+
+    @Override
+    public int describeContents() {
+      return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel parcel, int flags) {}
+  }
+}
diff --git a/binder/src/androidTest/java/io/grpc/binder/BinderSecurityTest.java b/binder/src/androidTest/java/io/grpc/binder/BinderSecurityTest.java
new file mode 100644
index 00000000000..35ed379556e
--- /dev/null
+++ b/binder/src/androidTest/java/io/grpc/binder/BinderSecurityTest.java
@@ -0,0 +1,351 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import android.content.Context;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.common.base.Function;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.protobuf.Empty;
+import io.grpc.CallOptions;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Server;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.protobuf.lite.ProtoLiteUtils;
+import io.grpc.stub.ClientCalls;
+import io.grpc.stub.ServerCalls;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public final class BinderSecurityTest {
+  private final Context appContext = ApplicationProvider.getApplicationContext();
+
+  String[] serviceNames = new String[] {"foo", "bar", "baz"};
+  List<ServerServiceDefinition> serviceDefinitions = new ArrayList<>();
+
+  @Nullable ManagedChannel channel;
+  Map<String, MethodDescriptor<Empty, Empty>> methods = new HashMap<>();
+  List<MethodDescriptor<Empty, Empty>> calls = new ArrayList<>();
+  CountingServerInterceptor countingServerInterceptor;
+
+  @Before
+  public void setupServiceDefinitionsAndMethods() {
+    MethodDescriptor.Marshaller<Empty> marshaller =
+        ProtoLiteUtils.marshaller(Empty.getDefaultInstance());
+    for (String serviceName : serviceNames) {
+      ServerServiceDefinition.Builder builder = ServerServiceDefinition.builder(serviceName);
+      for (int i = 0; i < 2; i++) {
+        // Add two methods to the service.
+        String name = serviceName + "/method" + i;
+        MethodDescriptor<Empty, Empty> method =
+            MethodDescriptor.newBuilder(marshaller, marshaller)
+                .setFullMethodName(name)
+                .setType(MethodDescriptor.MethodType.UNARY)
+                .setSampledToLocalTracing(true)
+                .build();
+        ServerCallHandler<Empty, Empty> callHandler =
+            ServerCalls.asyncUnaryCall(
+                (req, respObserver) -> {
+                  calls.add(method);
+                  respObserver.onNext(req);
+                  respObserver.onCompleted();
+                });
+        builder.addMethod(method, callHandler);
+        methods.put(name, method);
+      }
+      serviceDefinitions.add(builder.build());
+    }
+    countingServerInterceptor = new CountingServerInterceptor();
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    if (channel != null) {
+      channel.shutdownNow();
+    }
+    HostServices.awaitServiceShutdown();
+  }
+
+  private void createChannel() throws Exception {
+    createChannel(SecurityPolicies.serverInternalOnly(), SecurityPolicies.internalOnly());
+  }
+
+  private void createChannel(ServerSecurityPolicy serverPolicy, SecurityPolicy channelPolicy)
+      throws Exception {
+    AndroidComponentAddress addr = HostServices.allocateService(appContext);
+    HostServices.configureService(
+        addr,
+        HostServices.serviceParamsBuilder()
+            .setServerFactory((service, receiver) -> buildServer(addr, receiver, serverPolicy))
+            .build());
+
+    channel =
+        BinderChannelBuilder.forAddress(addr, appContext).securityPolicy(channelPolicy).build();
+  }
+
+  private Server buildServer(
+      AndroidComponentAddress listenAddr,
+      IBinderReceiver receiver,
+      ServerSecurityPolicy serverPolicy) {
+    BinderServerBuilder serverBuilder = BinderServerBuilder.forAddress(listenAddr, receiver);
+    serverBuilder.securityPolicy(serverPolicy);
+    serverBuilder.intercept(countingServerInterceptor);
+
+    for (ServerServiceDefinition serviceDefinition : serviceDefinitions) {
+      serverBuilder.addService(serviceDefinition);
+    }
+    return serverBuilder.build();
+  }
+
+  private void assertCallSuccess(MethodDescriptor<Empty, Empty> method) {
+    assertThat(
+            ClientCalls.blockingUnaryCall(
+                channel, method, CallOptions.DEFAULT, Empty.getDefaultInstance()))
+        .isNotNull();
+  }
+
+  @CanIgnoreReturnValue
+  private StatusRuntimeException assertCallFailure(
+      MethodDescriptor<Empty, Empty> method, Status status) {
+    try {
+      ClientCalls.blockingUnaryCall(channel, method, CallOptions.DEFAULT, null);
+      fail("Expected call to " + method.getFullMethodName() + " to fail but it succeeded.");
+      throw new AssertionError(); // impossible
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre.getStatus().getCode()).isEqualTo(status.getCode());
+      return sre;
+    }
+  }
+
+  @Test
+  public void testAllowedCall() throws Exception {
+    createChannel();
+    assertThat(methods).isNotEmpty();
+    for (MethodDescriptor<Empty, Empty> method : methods.values()) {
+      assertCallSuccess(method);
+    }
+  }
+
+  @Test
+  public void testServerDisallowsCalls() throws Exception {
+    createChannel(
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy("foo", policy((uid) -> false))
+            .servicePolicy("bar", policy((uid) -> false))
+            .servicePolicy("baz", policy((uid) -> false))
+            .build(),
+        SecurityPolicies.internalOnly());
+    assertThat(methods).isNotEmpty();
+    for (MethodDescriptor<Empty, Empty> method : methods.values()) {
+      assertCallFailure(method, Status.PERMISSION_DENIED);
+    }
+  }
+
+  @Test
+  public void testFailedFuturesPropagateOriginalException() throws Exception {
+    String errorMessage = "something went wrong";
+    IllegalStateException originalException = new IllegalStateException(errorMessage);
+    createChannel(
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy(
+                "foo",
+                new AsyncSecurityPolicy() {
+                  @Override
+                  public ListenableFuture<Status> checkAuthorizationAsync(int uid) {
+                    return Futures.immediateFailedFuture(originalException);
+                  }
+                })
+            .build(),
+        SecurityPolicies.internalOnly());
+    MethodDescriptor<Empty, Empty> method = methods.get("foo/method0");
+
+    StatusRuntimeException sre = assertCallFailure(method, Status.INTERNAL);
+    assertThat(sre.getStatus().getDescription()).contains(errorMessage);
+  }
+
+  @Test
+  public void testFailedFuturesAreNotCachedPermanently() throws Exception {
+    AtomicReference<Boolean> firstAttempt = new AtomicReference<>(true);
+    createChannel(
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy(
+                "foo",
+                new AsyncSecurityPolicy() {
+                  @Override
+                  public ListenableFuture<Status> checkAuthorizationAsync(int uid) {
+                    if (firstAttempt.getAndSet(false)) {
+                      return Futures.immediateFailedFuture(new IllegalStateException());
+                    }
+                    return Futures.immediateFuture(Status.OK);
+                  }
+                })
+            .build(),
+        SecurityPolicies.internalOnly());
+    MethodDescriptor<Empty, Empty> method = methods.get("foo/method0");
+
+    assertCallFailure(method, Status.INTERNAL);
+    assertCallSuccess(method);
+  }
+
+  @Test
+  public void testCancelledFuturesAreNotCachedPermanently() throws Exception {
+    AtomicReference<Boolean> firstAttempt = new AtomicReference<>(true);
+    createChannel(
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy(
+                "foo",
+                new AsyncSecurityPolicy() {
+                  @Override
+                  public ListenableFuture<Status> checkAuthorizationAsync(int uid) {
+                    if (firstAttempt.getAndSet(false)) {
+                      return Futures.immediateCancelledFuture();
+                    }
+                    return Futures.immediateFuture(Status.OK);
+                  }
+                })
+            .build(),
+        SecurityPolicies.internalOnly());
+    MethodDescriptor<Empty, Empty> method = methods.get("foo/method0");
+
+    assertCallFailure(method, Status.INTERNAL);
+    assertCallSuccess(method);
+  }
+
+  @Test
+  public void testClientDoesntTrustServer() throws Exception {
+    createChannel(SecurityPolicies.serverInternalOnly(), policy((uid) -> false));
+    assertThat(methods).isNotEmpty();
+    for (MethodDescriptor<Empty, Empty> method : methods.values()) {
+      assertCallFailure(method, Status.PERMISSION_DENIED);
+    }
+  }
+
+  @Test
+  public void testPerServicePolicy() throws Exception {
+    createChannel(
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy("foo", policy((uid) -> true))
+            .servicePolicy("bar", policy((uid) -> false))
+            .build(),
+        SecurityPolicies.internalOnly());
+
+    assertThat(methods).isNotEmpty();
+    for (MethodDescriptor<Empty, Empty> method : methods.values()) {
+      if (method.getServiceName().equals("bar")) {
+        assertCallFailure(method, Status.PERMISSION_DENIED);
+      } else {
+        assertCallSuccess(method);
+      }
+    }
+  }
+
+  @Test
+  public void testPerServicePolicyAsync() throws Exception {
+    createChannel(
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy("foo", asyncPolicy((uid) -> Futures.immediateFuture(true)))
+            .servicePolicy("bar", asyncPolicy((uid) -> Futures.immediateFuture(false)))
+            .build(),
+        SecurityPolicies.internalOnly());
+
+    assertThat(methods).isNotEmpty();
+    for (MethodDescriptor<Empty, Empty> method : methods.values()) {
+      if (method.getServiceName().equals("bar")) {
+        assertCallFailure(method, Status.PERMISSION_DENIED);
+      } else {
+        assertCallSuccess(method);
+      }
+    }
+  }
+
+  @Test
+  public void testSecurityInterceptorIsClosestToTransport() throws Exception {
+    createChannel(
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy("foo", policy((uid) -> true))
+            .servicePolicy("bar", policy((uid) -> false))
+            .servicePolicy("baz", policy((uid) -> false))
+            .build(),
+        SecurityPolicies.internalOnly());
+    assertThat(countingServerInterceptor.numInterceptedCalls).isEqualTo(0);
+    for (MethodDescriptor<Empty, Empty> method : methods.values()) {
+      try {
+        ClientCalls.blockingUnaryCall(channel, method, CallOptions.DEFAULT, null);
+      } catch (StatusRuntimeException sre) {
+        // Ignore.
+      }
+    }
+    // Only the foo calls should have made it to the user interceptor.
+    assertThat(countingServerInterceptor.numInterceptedCalls).isEqualTo(2);
+  }
+
+  private static SecurityPolicy policy(Function<Integer, Boolean> func) {
+    return new SecurityPolicy() {
+      @Override
+      public Status checkAuthorization(int uid) {
+        return func.apply(uid) ? Status.OK : Status.PERMISSION_DENIED;
+      }
+    };
+  }
+
+  private static AsyncSecurityPolicy asyncPolicy(
+      Function<Integer, ListenableFuture<Boolean>> func) {
+    return new AsyncSecurityPolicy() {
+      @Override
+      public ListenableFuture<Status> checkAuthorizationAsync(int uid) {
+        return Futures.transform(
+            func.apply(uid),
+            allowed -> allowed ? Status.OK : Status.PERMISSION_DENIED,
+            MoreExecutors.directExecutor());
+      }
+    };
+  }
+
+  private final class CountingServerInterceptor implements ServerInterceptor {
+    int numInterceptedCalls;
+
+    @Override
+    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+        ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+      numInterceptedCalls += 1;
+      return next.startCall(call, headers);
+    }
+  }
+}
diff --git a/binder/src/androidTest/java/io/grpc/binder/HostServices.java b/binder/src/androidTest/java/io/grpc/binder/HostServices.java
new file mode 100644
index 00000000000..5d4a06a27fe
--- /dev/null
+++ b/binder/src/androidTest/java/io/grpc/binder/HostServices.java
@@ -0,0 +1,285 @@
+/*
+ * 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;
+
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.os.RemoteException;
+import androidx.lifecycle.LifecycleService;
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Supplier;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Server;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executor;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * A test helper class for creating android services to host gRPC servers.
+ *
+ * <p>Currently only supports two servers at a time. If more are required, define a new class, add
+ * it to the manifest, and the hostServiceClasses array.
+ */
+public final class HostServices {
+
+  private static final Logger logger = Logger.getLogger(HostServices.class.getName());
+
+  private static final Class<?>[] hostServiceClasses =
+      new Class<?>[] {
+        HostService1.class, HostService2.class,
+      };
+
+  public interface ServerFactory {
+    Server createServer(Service service, IBinderReceiver receiver);
+  }
+
+  @AutoValue
+  public abstract static class ServiceParams {
+    @Nullable
+    abstract Executor transactionExecutor();
+
+    @Nullable
+    abstract Supplier<IBinder> rawBinderSupplier();
+
+    @Nullable
+    abstract ServerFactory serverFactory();
+
+    public abstract Builder toBuilder();
+
+    public static Builder builder() {
+      return new AutoValue_HostServices_ServiceParams.Builder();
+    }
+
+    @AutoValue.Builder
+    public abstract static class Builder {
+      public abstract Builder setRawBinderSupplier(Supplier<IBinder> binderSupplier);
+
+      public abstract Builder setServerFactory(ServerFactory serverFactory);
+
+      /**
+       * If set, this executor will be used to pass any inbound transactions to the server. This can
+       * be used to simulate delayed, re-ordered, or dropped packets.
+       */
+      public abstract Builder setTransactionExecutor(Executor transactionExecutor);
+
+      public abstract ServiceParams build();
+    }
+  }
+
+  @GuardedBy("HostServices.class")
+  private static final Map<Class<?>, AndroidComponentAddress> serviceAddresses = new HashMap<>();
+
+  @GuardedBy("HostServices.class")
+  private static final Map<Class<?>, ServiceParams> serviceParams = new HashMap<>();
+
+  @GuardedBy("HostServices.class")
+  private static final Map<Class<?>, HostService> activeServices = new HashMap<>();
+
+  @Nullable
+  @GuardedBy("HostServices.class")
+  private static CountDownLatch serviceShutdownLatch;
+
+  private HostServices() {}
+
+  /** Create a new {@link ServiceParams} builder. */
+  public static ServiceParams.Builder serviceParamsBuilder() {
+    return ServiceParams.builder();
+  }
+
+  /**
+   * Wait for all services to shutdown. This should be called from a test's tearDown method, to
+   * ensure the next test is able to use this class again (since Android itself is in control of the
+   * services).
+   */
+  public static void awaitServiceShutdown() throws InterruptedException {
+    CountDownLatch latch = null;
+    synchronized (HostServices.class) {
+      if (serviceShutdownLatch == null && !activeServices.isEmpty()) {
+        latch = new CountDownLatch(activeServices.size());
+        serviceShutdownLatch = latch;
+      }
+      serviceParams.clear();
+      serviceAddresses.clear();
+    }
+    if (latch != null) {
+      if (!latch.await(10, SECONDS)) {
+        throw new AssertionError("Failed to shut down services");
+      }
+    }
+    synchronized (HostServices.class) {
+      checkState(activeServices.isEmpty());
+      checkState(serviceParams.isEmpty());
+      checkState(serviceAddresses.isEmpty());
+      serviceShutdownLatch = null;
+    }
+  }
+
+  /** Create the address for a host-service. */
+  private static AndroidComponentAddress hostServiceAddress(Context appContext, Class<?> cls) {
+    // NOTE: Even though we have a context object, we intentionally don't use a "local",
+    // address, since doing so would mark the address with our UID for security purposes,
+    // and that would limit the effectiveness of tests.
+    // Using this API forces us to rely on Binder.getCallingUid.
+    return AndroidComponentAddress.forRemoteComponent(appContext.getPackageName(), cls.getName());
+  }
+
+  /**
+   * Allocate a new host service.
+   *
+   * @param appContext The application context.
+   * @return The AndroidComponentAddress of the service.
+   */
+  public static synchronized AndroidComponentAddress allocateService(Context appContext) {
+    for (Class<?> cls : hostServiceClasses) {
+      if (!serviceAddresses.containsKey(cls)) {
+        AndroidComponentAddress address = hostServiceAddress(appContext, cls);
+        serviceAddresses.put(cls, address);
+        return address;
+      }
+    }
+    throw new AssertionError("This test helper only supports two services at a time.");
+  }
+
+  /**
+   * Configure an allocated hosting service.
+   *
+   * @param androidComponentAddress The address of the service.
+   * @param params The parameters used to build the service.
+   */
+  public static synchronized void configureService(
+      AndroidComponentAddress androidComponentAddress, ServiceParams params) {
+    for (Class<?> cls : hostServiceClasses) {
+      if (serviceAddresses.get(cls).equals(androidComponentAddress)) {
+        checkState(!serviceParams.containsKey(cls));
+        serviceParams.put(cls, params);
+        return;
+      }
+    }
+    throw new AssertionError("Unable to find service for address " + androidComponentAddress);
+  }
+
+  /** An Android Service to host each gRPC server. */
+  private abstract static class HostService extends LifecycleService {
+
+    @Nullable private ServiceParams params;
+    @Nullable private Supplier<IBinder> binderSupplier;
+    @Nullable private Server server;
+
+    @Override
+    public final void onCreate() {
+      super.onCreate();
+      Class<?> cls = getClass();
+      synchronized (HostServices.class) {
+        checkState(!activeServices.containsKey(cls));
+        activeServices.put(cls, this);
+        checkState(serviceParams.containsKey(cls));
+        params = serviceParams.get(cls);
+        ServerFactory factory = params.serverFactory();
+        if (factory != null) {
+          IBinderReceiver receiver = new IBinderReceiver();
+          server = factory.createServer(this, receiver);
+          try {
+            server.start();
+          } catch (IOException ioe) {
+            throw new AssertionError("Failed to start server", ioe);
+          }
+          binderSupplier = () -> receiver.get();
+        } else {
+          binderSupplier = params.rawBinderSupplier();
+          if (binderSupplier == null) {
+            throw new AssertionError("Insufficient params for host service");
+          }
+        }
+      }
+    }
+
+    @Override
+    public final IBinder onBind(Intent intent) {
+      // Calling super here is a little weird (it returns null), but there's a @CallSuper
+      // annotation.
+      super.onBind(intent);
+      synchronized (HostServices.class) {
+        Executor executor = params.transactionExecutor();
+        if (executor != null) {
+          return new ProxyBinder(binderSupplier.get(), executor);
+        } else {
+          return binderSupplier.get();
+        }
+      }
+    }
+
+    @Override
+    public final void onDestroy() {
+      synchronized (HostServices.class) {
+        if (server != null) {
+          server.shutdown();
+          server = null;
+        }
+        HostService removed = activeServices.remove(getClass());
+        checkState(removed == this);
+        serviceAddresses.remove(getClass());
+        serviceParams.remove(getClass());
+        if (serviceShutdownLatch != null) {
+          serviceShutdownLatch.countDown();
+        }
+      }
+      super.onDestroy();
+    }
+  }
+
+  /** The first concrete host service */
+  public static final class HostService1 extends HostService {}
+
+  /** The second concrete host service */
+  public static final class HostService2 extends HostService {}
+
+  /** Wraps an IBinder to send incoming transactions to a different thread. */
+  private static class ProxyBinder extends Binder {
+    private final IBinder delegate;
+    private final Executor executor;
+
+    ProxyBinder(IBinder delegate, Executor executor) {
+      this.delegate = delegate;
+      this.executor = executor;
+    }
+
+    @Override
+    protected boolean onTransact(int code, Parcel parcel, Parcel reply, int flags) {
+      executor.execute(
+          () -> {
+            try {
+              delegate.transact(code, parcel, reply, flags);
+            } catch (RemoteException re) {
+              logger.log(Level.WARNING, "Exception in proxybinder", re);
+            }
+          });
+      return true;
+    }
+  }
+}
diff --git a/binder/src/androidTest/java/io/grpc/binder/internal/BinderClientTransportTest.java b/binder/src/androidTest/java/io/grpc/binder/internal/BinderClientTransportTest.java
new file mode 100644
index 00000000000..aa3fb573ab5
--- /dev/null
+++ b/binder/src/androidTest/java/io/grpc/binder/internal/BinderClientTransportTest.java
@@ -0,0 +1,678 @@
+/*
+ * 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 static java.util.concurrent.TimeUnit.SECONDS;
+
+import android.content.Context;
+import android.os.DeadObjectException;
+import android.os.Parcel;
+import android.os.RemoteException;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import com.google.protobuf.Empty;
+import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.binder.AndroidComponentAddress;
+import io.grpc.binder.BinderServerBuilder;
+import io.grpc.binder.HostServices;
+import io.grpc.binder.SecurityPolicy;
+import io.grpc.binder.internal.FakeDeadBinder;
+import io.grpc.binder.internal.OneWayBinderProxies.BlackHoleOneWayBinderProxy;
+import io.grpc.binder.internal.OneWayBinderProxies.BlockingBinderDecorator;
+import io.grpc.binder.internal.OneWayBinderProxies.ThrowingOneWayBinderProxy;
+import io.grpc.binder.internal.SettableAsyncSecurityPolicy.AuthRequest;
+import io.grpc.internal.ClientStream;
+import io.grpc.internal.ClientStreamListener;
+import io.grpc.internal.ClientTransportFactory.ClientTransportOptions;
+import io.grpc.internal.DisconnectError;
+import io.grpc.internal.FixedObjectPool;
+import io.grpc.internal.ManagedClientTransport;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.StreamListener;
+import io.grpc.protobuf.lite.ProtoLiteUtils;
+import io.grpc.stub.ServerCalls;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ScheduledExecutorService;
+import javax.annotation.Nullable;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * Client-side transport tests for binder channel. Like BinderChannelSmokeTest, this covers edge
+ * cases not exercised by AbstractTransportTest, but in this case we're dealing with rare ordering
+ * issues at the transport level, so we use a BinderTransport.BinderClientTransport directly, rather
+ * than a channel.
+ */
+@RunWith(AndroidJUnit4.class)
+public final class BinderClientTransportTest {
+  private static final long TIMEOUT_SECONDS = 5;
+
+  private static final ClientStreamTracer[] tracers =
+      new ClientStreamTracer[] {new ClientStreamTracer() {}};
+
+  private final Context appContext = ApplicationProvider.getApplicationContext();
+
+  MethodDescriptor.Marshaller<Empty> marshaller =
+      ProtoLiteUtils.marshaller(Empty.getDefaultInstance());
+
+  MethodDescriptor<Empty, Empty> methodDesc =
+      MethodDescriptor.newBuilder(marshaller, marshaller)
+          .setFullMethodName("test/method")
+          .setType(MethodDescriptor.MethodType.UNARY)
+          .build();
+
+  MethodDescriptor<Empty, Empty> streamingMethodDesc =
+      MethodDescriptor.newBuilder(marshaller, marshaller)
+          .setFullMethodName("test/methodServerStreaming")
+          .setType(MethodDescriptor.MethodType.SERVER_STREAMING)
+          .build();
+
+  AndroidComponentAddress serverAddress;
+  BinderClientTransport transport;
+  BlockingSecurityPolicy blockingSecurityPolicy = new BlockingSecurityPolicy();
+
+  private final ObjectPool<ScheduledExecutorService> executorServicePool =
+      new FixedObjectPool<>(Executors.newScheduledThreadPool(1));
+  private final ObjectPool<ScheduledExecutorService> offloadServicePool =
+      new FixedObjectPool<>(Executors.newScheduledThreadPool(1));
+  private final TestTransportListener transportListener = new TestTransportListener();
+  private final TestStreamListener streamListener = new TestStreamListener();
+
+  @Before
+  public void setUp() throws Exception {
+    ServerCallHandler<Empty, Empty> callHandler =
+        ServerCalls.asyncUnaryCall(
+            (req, respObserver) -> {
+              respObserver.onNext(req);
+              respObserver.onCompleted();
+            });
+
+    ServerCallHandler<Empty, Empty> streamingCallHandler =
+        ServerCalls.asyncServerStreamingCall(
+            (req, respObserver) -> {
+              for (int i = 0; i < 100; i++) {
+                respObserver.onNext(req);
+              }
+              respObserver.onCompleted();
+            });
+
+    ServerServiceDefinition serviceDef =
+        ServerServiceDefinition.builder("test")
+            .addMethod(methodDesc, callHandler)
+            .addMethod(streamingMethodDesc, streamingCallHandler)
+            .build();
+
+    serverAddress = HostServices.allocateService(appContext);
+    HostServices.configureService(
+        serverAddress,
+        HostServices.serviceParamsBuilder()
+            .setServerFactory(
+                (service, receiver) ->
+                    BinderServerBuilder.forAddress(serverAddress, receiver)
+                        .addService(serviceDef)
+                        .build())
+            .build());
+  }
+
+  private class BinderClientTransportBuilder {
+    final BinderClientTransportFactory.Builder factoryBuilder =
+        new BinderClientTransportFactory.Builder()
+            .setSourceContext(appContext)
+            .setScheduledExecutorPool(executorServicePool)
+            .setOffloadExecutorPool(offloadServicePool);
+
+    @CanIgnoreReturnValue
+    public BinderClientTransportBuilder setSecurityPolicy(SecurityPolicy securityPolicy) {
+      factoryBuilder.setSecurityPolicy(securityPolicy);
+      return this;
+    }
+
+    @CanIgnoreReturnValue
+    public BinderClientTransportBuilder setBinderDecorator(
+        OneWayBinderProxy.Decorator binderDecorator) {
+      factoryBuilder.setBinderDecorator(binderDecorator);
+      return this;
+    }
+
+    @CanIgnoreReturnValue
+    public BinderClientTransportBuilder setReadyTimeoutMillis(int timeoutMillis) {
+      factoryBuilder.setReadyTimeoutMillis(timeoutMillis);
+      return this;
+    }
+
+    @CanIgnoreReturnValue
+    public BinderClientTransportBuilder setPreAuthorizeServer(boolean preAuthorizeServer) {
+      factoryBuilder.setPreAuthorizeServers(preAuthorizeServer);
+      return this;
+    }
+
+    public BinderClientTransport build() {
+      return factoryBuilder
+          .buildClientTransportFactory()
+          .newClientTransport(serverAddress, new ClientTransportOptions(), null);
+    }
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    blockingSecurityPolicy.provideNextCheckAuthorizationResult(Status.ABORTED);
+    transport.shutdownNow(Status.OK);
+    HostServices.awaitServiceShutdown();
+    shutdownAndTerminate(executorServicePool.getObject());
+    shutdownAndTerminate(offloadServicePool.getObject());
+  }
+
+  private static void shutdownAndTerminate(ExecutorService executorService)
+      throws InterruptedException {
+    executorService.shutdownNow();
+    if (!executorService.awaitTermination(TIMEOUT_SECONDS, SECONDS)) {
+      throw new AssertionError("executor failed to terminate promptly");
+    }
+  }
+
+  @Test
+  public void testShutdownBeforeStreamStart_b153326034() throws Exception {
+    transport = new BinderClientTransportBuilder().build();
+    startAndAwaitReady(transport, transportListener);
+    ClientStream stream =
+        transport.newStream(methodDesc, new Metadata(), CallOptions.DEFAULT, tracers);
+    transport.shutdownNow(Status.UNKNOWN.withDescription("reasons"));
+
+    // This shouldn't throw an exception.
+    stream.start(streamListener);
+  }
+
+  @Test
+  public void testRequestWhileStreamIsWaitingOnCall_b154088869() throws Exception {
+    transport = new BinderClientTransportBuilder().build();
+    startAndAwaitReady(transport, transportListener);
+    ClientStream stream =
+        transport.newStream(streamingMethodDesc, new Metadata(), CallOptions.DEFAULT, tracers);
+
+    stream.start(streamListener);
+    stream.writeMessage(marshaller.stream(Empty.getDefaultInstance()));
+    stream.halfClose();
+    stream.request(3);
+
+    streamListener.readAndDiscardMessages(2);
+
+    // Without the fix, this loops forever.
+    stream.request(2);
+  }
+
+  @Test
+  public void testTransactionForDiscardedCall_b155244043() throws Exception {
+    transport = new BinderClientTransportBuilder().build();
+    startAndAwaitReady(transport, transportListener);
+    ClientStream stream =
+        transport.newStream(streamingMethodDesc, new Metadata(), CallOptions.DEFAULT, tracers);
+
+    stream.start(streamListener);
+    stream.writeMessage(marshaller.stream(Empty.getDefaultInstance()));
+
+    assertThat(transport.getOngoingCalls()).hasSize(1);
+    int callId = transport.getOngoingCalls().keySet().iterator().next();
+    stream.cancel(Status.UNKNOWN);
+
+    // Send a transaction to the no-longer present call ID. It should be silently ignored.
+    Parcel p = Parcel.obtain();
+    transport.handleTransaction(callId, p);
+    p.recycle();
+  }
+
+  @Test
+  public void testBadTransactionStreamThroughput_b163053382() throws Exception {
+    transport = new BinderClientTransportBuilder().build();
+    startAndAwaitReady(transport, transportListener);
+    ClientStream stream =
+        transport.newStream(streamingMethodDesc, new Metadata(), CallOptions.DEFAULT, tracers);
+
+    stream.start(streamListener);
+    stream.writeMessage(marshaller.stream(Empty.getDefaultInstance()));
+    stream.halfClose();
+    stream.request(1000);
+
+    // We should eventually see all messages despite receiving no more transactions from the server.
+    streamListener.readAndDiscardMessages(100);
+  }
+
+  @Test
+  public void testMessageProducerClosedAfterStream_b169313545() throws Exception {
+    transport = new BinderClientTransportBuilder().build();
+    startAndAwaitReady(transport, transportListener);
+    ClientStream stream =
+        transport.newStream(methodDesc, new Metadata(), CallOptions.DEFAULT, tracers);
+
+    stream.start(streamListener);
+    stream.writeMessage(marshaller.stream(Empty.getDefaultInstance()));
+    stream.halfClose();
+    stream.request(2);
+
+    // Wait until we receive the first message.
+    streamListener.awaitMessages();
+
+    // Now cancel the stream, forcing it to close.
+    stream.cancel(Status.CANCELLED);
+
+    // The message producer shouldn't throw an exception if we drain it now.
+    streamListener.drainMessages();
+  }
+
+  @Test
+  public void testNewStreamBeforeTransportReadyFails() throws Exception {
+    // Use a special SecurityPolicy that lets us act before the transport is setup/ready.
+    transport =
+        new BinderClientTransportBuilder().setSecurityPolicy(blockingSecurityPolicy).build();
+    transport.start(transportListener).run();
+    ClientStream stream =
+        transport.newStream(streamingMethodDesc, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream.start(streamListener);
+    assertThat(streamListener.awaitClose().getCode()).isEqualTo(Code.INTERNAL);
+
+    // Unblock the SETUP_TRANSPORT handshake and make sure it becomes ready in the usual way.
+    blockingSecurityPolicy.provideNextCheckAuthorizationResult(Status.OK);
+    transportListener.awaitReady();
+  }
+
+  @Test
+  public void testTxnFailureDuringSetup() throws Exception {
+    BlockingBinderDecorator<ThrowingOneWayBinderProxy> decorator = new BlockingBinderDecorator<>();
+    transport = new BinderClientTransportBuilder().setBinderDecorator(decorator).build();
+    transport.start(transportListener).run();
+    ThrowingOneWayBinderProxy endpointBinder =
+        new ThrowingOneWayBinderProxy(decorator.takeNextRequest());
+    DeadObjectException doe = new DeadObjectException("ouch");
+    endpointBinder.setRemoteException(doe);
+    decorator.putNextResult(endpointBinder);
+
+    Status shutdownStatus = transportListener.awaitShutdown();
+    assertThat(shutdownStatus.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(shutdownStatus.getCause()).isInstanceOf(RemoteException.class);
+    transportListener.awaitTermination();
+
+    ClientStream stream =
+        transport.newStream(streamingMethodDesc, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream.start(streamListener);
+
+    Status streamStatus = streamListener.awaitClose();
+    assertThat(streamStatus.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(streamStatus.getCause()).isSameInstanceAs(doe);
+  }
+
+  @Test
+  public void testTxnFailurePostSetup() throws Exception {
+    BlockingBinderDecorator<ThrowingOneWayBinderProxy> decorator = new BlockingBinderDecorator<>();
+    transport = new BinderClientTransportBuilder().setBinderDecorator(decorator).build();
+    transport.start(transportListener).run();
+    ThrowingOneWayBinderProxy endpointBinder =
+        new ThrowingOneWayBinderProxy(decorator.takeNextRequest());
+    decorator.putNextResult(endpointBinder);
+    ThrowingOneWayBinderProxy serverBinder =
+        new ThrowingOneWayBinderProxy(decorator.takeNextRequest());
+    DeadObjectException doe = new DeadObjectException("ouch");
+    serverBinder.setRemoteException(doe);
+    decorator.putNextResult(serverBinder);
+    transportListener.awaitReady();
+
+    ClientStream stream =
+        transport.newStream(streamingMethodDesc, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream.start(streamListener);
+    stream.writeMessage(marshaller.stream(Empty.getDefaultInstance()));
+    stream.halfClose();
+    stream.request(1);
+
+    Status streamStatus = streamListener.awaitClose();
+    assertThat(streamStatus.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(streamStatus.getCause()).isSameInstanceAs(doe);
+  }
+
+  @Test
+  public void testServerBinderDeadOnArrival() throws Exception {
+    BlockingBinderDecorator<OneWayBinderProxy> decorator = new BlockingBinderDecorator<>();
+    transport = new BinderClientTransportBuilder().setBinderDecorator(decorator).build();
+    transport.start(transportListener).run();
+    decorator.putNextResult(decorator.takeNextRequest());  // Server's "Endpoint" Binder.
+    OneWayBinderProxy unusedServerBinder = decorator.takeNextRequest();
+    decorator.putNextResult(
+        OneWayBinderProxy.wrap(new FakeDeadBinder(), offloadServicePool.getObject()));
+    Status clientStatus = transportListener.awaitShutdown();
+    assertThat(clientStatus.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(clientStatus.getDescription()).contains("Failed to observe outgoing binder");
+  }
+
+  @Test
+  public void testBlackHoleEndpointConnectTimeout() throws Exception {
+    BlockingBinderDecorator<BlackHoleOneWayBinderProxy> decorator = new BlockingBinderDecorator<>();
+    transport =
+        new BinderClientTransportBuilder()
+            .setBinderDecorator(decorator)
+            .setReadyTimeoutMillis(1_234)
+            .build();
+    transport.start(transportListener).run();
+    BlackHoleOneWayBinderProxy endpointBinder =
+        new BlackHoleOneWayBinderProxy(decorator.takeNextRequest());
+    endpointBinder.dropAllTransactions(true);
+    decorator.putNextResult(endpointBinder);
+    Status transportStatus = transportListener.awaitShutdown();
+    assertThat(transportStatus.getCode()).isEqualTo(Code.DEADLINE_EXCEEDED);
+    assertThat(transportStatus.getDescription()).contains("1234");
+    transportListener.awaitTermination();
+  }
+
+  @Test
+  public void testBlackHoleSecurityPolicyAuthTimeout() throws Exception {
+    SettableAsyncSecurityPolicy securityPolicy = new SettableAsyncSecurityPolicy();
+    transport =
+        new BinderClientTransportBuilder()
+            .setSecurityPolicy(securityPolicy)
+            .setPreAuthorizeServer(false)
+            .setReadyTimeoutMillis(1_234)
+            .build();
+    transport.start(transportListener).run();
+    // Take the next authRequest but don't respond to it, in order to trigger the ready timeout.
+    AuthRequest authRequest = securityPolicy.takeNextAuthRequest(TIMEOUT_SECONDS, SECONDS);
+
+    Status transportStatus = transportListener.awaitShutdown();
+    assertThat(transportStatus.getCode()).isEqualTo(Code.DEADLINE_EXCEEDED);
+    assertThat(transportStatus.getDescription()).contains("1234");
+    transportListener.awaitTermination();
+    // If the transport gave up waiting on auth, it should cancel its request.
+    assertThat(authRequest.isCancelled()).isTrue();
+  }
+
+  @Test
+  public void testBlackHoleSecurityPolicyPreAuthTimeout() throws Exception {
+    SettableAsyncSecurityPolicy securityPolicy = new SettableAsyncSecurityPolicy();
+    transport =
+        new BinderClientTransportBuilder()
+            .setSecurityPolicy(securityPolicy)
+            .setPreAuthorizeServer(true)
+            .setReadyTimeoutMillis(1_234)
+            .build();
+    transport.start(transportListener).run();
+    // Take the next authRequest but don't respond to it, in order to trigger the ready timeout.
+    AuthRequest preAuthRequest = securityPolicy.takeNextAuthRequest(TIMEOUT_SECONDS, SECONDS);
+
+    Status transportStatus = transportListener.awaitShutdown();
+    assertThat(transportStatus.getCode()).isEqualTo(Code.DEADLINE_EXCEEDED);
+    assertThat(transportStatus.getDescription()).contains("1234");
+    transportListener.awaitTermination();
+    // If the transport gave up waiting on auth, it should cancel its request.
+    assertThat(preAuthRequest.isCancelled()).isTrue();
+  }
+
+  @Test
+  public void testAsyncSecurityPolicyAuthFailure() throws Exception {
+    SettableAsyncSecurityPolicy securityPolicy = new SettableAsyncSecurityPolicy();
+    transport =
+        new BinderClientTransportBuilder()
+            .setPreAuthorizeServer(false)
+            .setSecurityPolicy(securityPolicy)
+            .build();
+    RuntimeException exception = new NullPointerException();
+    transport.start(transportListener).run();
+    securityPolicy.takeNextAuthRequest(TIMEOUT_SECONDS, SECONDS).setResult(exception);
+    Status transportStatus = transportListener.awaitShutdown();
+    assertThat(transportStatus.getCode()).isEqualTo(Code.INTERNAL);
+    assertThat(transportStatus.getCause()).isEqualTo(exception);
+    transportListener.awaitTermination();
+  }
+
+  @Test
+  public void testAsyncSecurityPolicyPreAuthFailure() throws Exception {
+    SettableAsyncSecurityPolicy securityPolicy = new SettableAsyncSecurityPolicy();
+    transport =
+        new BinderClientTransportBuilder()
+            .setPreAuthorizeServer(true)
+            .setSecurityPolicy(securityPolicy)
+            .build();
+    RuntimeException exception = new NullPointerException();
+    transport.start(transportListener).run();
+    securityPolicy.takeNextAuthRequest(TIMEOUT_SECONDS, SECONDS).setResult(exception);
+    Status transportStatus = transportListener.awaitShutdown();
+    assertThat(transportStatus.getCode()).isEqualTo(Code.INTERNAL);
+    assertThat(transportStatus.getCause()).isEqualTo(exception);
+    transportListener.awaitTermination();
+  }
+
+  @Test
+  public void testAsyncSecurityPolicyAuthSuccess() throws Exception {
+    SettableAsyncSecurityPolicy securityPolicy = new SettableAsyncSecurityPolicy();
+    transport =
+        new BinderClientTransportBuilder()
+            .setPreAuthorizeServer(false)
+            .setSecurityPolicy(securityPolicy)
+            .build();
+    transport.start(transportListener).run();
+    securityPolicy
+        .takeNextAuthRequest(TIMEOUT_SECONDS, SECONDS)
+        .setResult(Status.PERMISSION_DENIED.withDescription("xyzzy"));
+    Status transportStatus = transportListener.awaitShutdown();
+    assertThat(transportStatus.getCode()).isEqualTo(Code.PERMISSION_DENIED);
+    assertThat(transportStatus.getDescription()).contains("xyzzy");
+    transportListener.awaitTermination();
+  }
+
+  @Test
+  public void testAsyncSecurityPolicyPreAuthSuccess() throws Exception {
+    SettableAsyncSecurityPolicy securityPolicy = new SettableAsyncSecurityPolicy();
+    transport =
+        new BinderClientTransportBuilder()
+            .setPreAuthorizeServer(true)
+            .setSecurityPolicy(securityPolicy)
+            .build();
+    transport.start(transportListener).run();
+    securityPolicy
+        .takeNextAuthRequest(TIMEOUT_SECONDS, SECONDS)
+        .setResult(Status.PERMISSION_DENIED.withDescription("xyzzy"));
+    Status transportStatus = transportListener.awaitShutdown();
+    assertThat(transportStatus.getCode()).isEqualTo(Code.PERMISSION_DENIED);
+    assertThat(transportStatus.getDescription()).contains("xyzzy");
+    transportListener.awaitTermination();
+  }
+
+  @Test
+  public void testAsyncSecurityPolicyCancelledUponExternalTermination() throws Exception {
+    SettableAsyncSecurityPolicy securityPolicy = new SettableAsyncSecurityPolicy();
+    transport = new BinderClientTransportBuilder().setSecurityPolicy(securityPolicy).build();
+    transport.start(transportListener).run();
+    AuthRequest authRequest = securityPolicy.takeNextAuthRequest(TIMEOUT_SECONDS, SECONDS);
+    transport.shutdownNow(Status.UNAVAILABLE); // 'authRequest' remains unanswered!
+    transportListener.awaitShutdown();
+    transportListener.awaitTermination();
+    assertThat(authRequest.isCancelled()).isTrue();
+  }
+
+  private static void startAndAwaitReady(
+      BinderClientTransport transport, TestTransportListener transportListener) throws Exception {
+    transport.start(transportListener).run();
+    transportListener.awaitReady();
+  }
+
+  private static final class TestTransportListener implements ManagedClientTransport.Listener {
+    public boolean inUse;
+    private final SettableFuture<Boolean> isReady = SettableFuture.create();
+    private final SettableFuture<Status> shutdownStatus = SettableFuture.create();
+    private final SettableFuture<Boolean> isTerminated = SettableFuture.create();
+
+    @Override
+    public void transportShutdown(Status shutdownStatus, DisconnectError disconnectError) {
+      if (!this.shutdownStatus.set(shutdownStatus)) {
+        throw new IllegalStateException("transportShutdown() already called");
+      }
+    }
+
+    public Status awaitShutdown() throws Exception {
+      return shutdownStatus.get(TIMEOUT_SECONDS, SECONDS);
+    }
+
+    @Override
+    public void transportTerminated() {
+      if (!isTerminated.set(true)) {
+        throw new IllegalStateException("isTerminated() already called");
+      }
+    }
+
+    public void awaitTermination() throws Exception {
+      isTerminated.get(TIMEOUT_SECONDS, SECONDS);
+    }
+
+    @Override
+    public void transportReady() {
+      if (!isReady.set(true)) {
+        throw new IllegalStateException("isTerminated() already called");
+      }
+    }
+
+    public void awaitReady() throws Exception {
+      isReady.get(TIMEOUT_SECONDS, SECONDS);
+    }
+
+    @Override
+    public void transportInUse(boolean inUse) {
+      this.inUse = inUse;
+    }
+  }
+
+  private static final class TestStreamListener implements ClientStreamListener {
+
+    public boolean ready;
+    public Metadata headers;
+
+    @GuardedBy("this")
+    private final Deque<MessageProducer> messageProducers = new ArrayDeque<>();
+
+    @GuardedBy("this")
+    @Nullable
+    private Status closedStatus;
+
+    @Override
+    public synchronized void messagesAvailable(StreamListener.MessageProducer messageProducer) {
+      messageProducers.add(messageProducer);
+      notifyAll();
+    }
+
+    /** Blocks until at least one MessageProducer has been provided for reading. */
+    public synchronized void awaitMessages() throws InterruptedException {
+      while (messageProducers.isEmpty()) {
+        wait();
+      }
+    }
+
+    /** Blocks until {@code n} messages can be produced (and discarded). */
+    public synchronized void readAndDiscardMessages(int n)
+        throws InterruptedException, IOException {
+      while (n > 0) {
+        while (closedStatus == null && messageProducers.isEmpty()) {
+          wait();
+        }
+        if (closedStatus != null) {
+          throw closedStatus.withDescription("premature close").asRuntimeException();
+        }
+        try (InputStream message = messageProducers.peek().next()) {
+          if (message == null) {
+            messageProducers.remove();
+            continue;
+          }
+          n -= 1;
+        }
+      }
+    }
+
+    public synchronized Status awaitClose() {
+      while (closedStatus == null) {
+        try {
+          wait();
+        } catch (InterruptedException inte) {
+          throw new AssertionError("Interrupted waiting for close");
+        }
+      }
+      return closedStatus;
+    }
+
+    /** Discards any messages available on the stream without reading them. Does not block. */
+    public synchronized int drainMessages() throws IOException {
+      int n = 0;
+      while (!messageProducers.isEmpty()) {
+        try (InputStream message = messageProducers.peek().next()) {
+          if (message == null) {
+            messageProducers.remove();
+            continue;
+          }
+          n += 1;
+        }
+      }
+      return n;
+    }
+
+    @Override
+    public void onReady() {
+      ready = true;
+    }
+
+    @Override
+    public void headersRead(Metadata headers) {
+      this.headers = headers;
+    }
+
+    @Override
+    public synchronized void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {
+      this.closedStatus = status;
+      notifyAll();
+    }
+  }
+
+  /**
+   * A SecurityPolicy that blocks the transport authorization check until a test sets the outcome.
+   */
+  static class BlockingSecurityPolicy extends SecurityPolicy {
+    private final BlockingQueue<Status> results = new LinkedBlockingQueue<>();
+
+    public void provideNextCheckAuthorizationResult(Status status) {
+      results.add(status);
+    }
+
+    @Override
+    public Status checkAuthorization(int uid) {
+      try {
+        return results.take();
+      } catch (InterruptedException e) {
+        return Status.fromThrowable(e);
+      }
+    }
+  }
+}
diff --git a/binder/src/androidTest/java/io/grpc/binder/internal/BinderTransportTest.java b/binder/src/androidTest/java/io/grpc/binder/internal/BinderTransportTest.java
new file mode 100644
index 00000000000..7932cabde89
--- /dev/null
+++ b/binder/src/androidTest/java/io/grpc/binder/internal/BinderTransportTest.java
@@ -0,0 +1,140 @@
+/*
+ * 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.content.Context;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import io.grpc.ServerStreamTracer;
+import io.grpc.binder.AndroidComponentAddress;
+import io.grpc.binder.HostServices;
+import io.grpc.internal.AbstractTransportTest;
+import io.grpc.internal.ClientTransportFactory.ClientTransportOptions;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ManagedClientTransport;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourcePool;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import org.junit.After;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * A test for the Android binder based transport.
+ *
+ * <p>This class really just sets up the test environment. All of the actual tests are defined in
+ * AbstractTransportTest.
+ */
+@RunWith(AndroidJUnit4.class)
+public final class BinderTransportTest extends AbstractTransportTest {
+
+  private final Context appContext = ApplicationProvider.getApplicationContext();
+  private final ObjectPool<ScheduledExecutorService> executorServicePool =
+      SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE);
+  private final ObjectPool<Executor> offloadExecutorPool =
+      SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR);
+  private final ObjectPool<Executor> serverExecutorPool =
+      SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR);
+
+  @Override
+  @After
+  public void tearDown() throws InterruptedException {
+    super.tearDown();
+    HostServices.awaitServiceShutdown();
+  }
+
+  @Override
+  protected InternalServer newServer(List<ServerStreamTracer.Factory> streamTracerFactories) {
+    AndroidComponentAddress addr = HostServices.allocateService(appContext);
+
+    BinderServer binderServer =
+        new BinderServer.Builder()
+            .setListenAddress(addr)
+            .setExecutorPool(serverExecutorPool)
+            .setExecutorServicePool(executorServicePool)
+            .setStreamTracerFactories(streamTracerFactories)
+            .build();
+
+    HostServices.configureService(
+        addr,
+        HostServices.serviceParamsBuilder()
+            .setRawBinderSupplier(() -> binderServer.getHostBinder())
+            .build());
+
+    return binderServer;
+  }
+
+  @Override
+  protected InternalServer newServer(
+      int port, List<ServerStreamTracer.Factory> streamTracerFactories) {
+    return newServer(streamTracerFactories);
+  }
+
+  @Override
+  protected String testAuthority(InternalServer server) {
+    return ((AndroidComponentAddress) server.getListenSocketAddress()).getAuthority();
+  }
+
+  @Override
+  protected ManagedClientTransport newClientTransport(InternalServer server) {
+    AndroidComponentAddress addr = (AndroidComponentAddress) server.getListenSocketAddress();
+    BinderClientTransportFactory.Builder builder =
+        new BinderClientTransportFactory.Builder()
+            .setSourceContext(appContext)
+            .setScheduledExecutorPool(executorServicePool)
+            .setOffloadExecutorPool(offloadExecutorPool);
+
+    ClientTransportOptions options = new ClientTransportOptions();
+    options.setEagAttributes(eagAttrs());
+    options.setChannelLogger(transportLogger());
+
+    return new BinderClientTransport(builder.buildClientTransportFactory(), addr, options);
+  }
+
+  @Test
+  @Ignore("BinderTransport doesn't report socket stats yet.")
+  @Override
+  public void socketStats() throws Exception {}
+
+  @Test
+  @Ignore("BinderTransport doesn't do message-level flow control yet.")
+  @Override
+  public void flowControlPushBack() throws Exception {}
+
+  @Test
+  @Ignore("This test isn't appropriate for BinderTransport.")
+  @Override
+  public void serverAlreadyListening() throws Exception {
+    // This test asserts that two Servers can't listen on the same SocketAddress. For a regular
+    // network server, that address refers to a network port, and for a BinderServer it
+    // refers to an Android Service class declared in an applications manifest.
+    //
+    // However, unlike a regular network server, which is responsible for listening on its port, a
+    // BinderServer is not responsible for the creation of its host Service. The opposite is
+    // the case, with the host Android Service (itself created by the Android platform in
+    // response to a connection) building the gRPC server.
+    //
+    // Passing this test would require us to manually check that two Server instances aren't,
+    // created with the same Android Service class, but due to the "inversion of control" described
+    // above, we would actually be testing (and making assumptions about) the precise lifecycle of
+    // Android Services, which is arguably not our concern.
+  }
+}
diff --git a/binder/src/androidTest/java/io/grpc/binder/internal/LeakSafeOneWayBinderTest.java b/binder/src/androidTest/java/io/grpc/binder/internal/LeakSafeOneWayBinderTest.java
new file mode 100644
index 00000000000..835c73bee50
--- /dev/null
+++ b/binder/src/androidTest/java/io/grpc/binder/internal/LeakSafeOneWayBinderTest.java
@@ -0,0 +1,121 @@
+/*
+ * 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 android.os.IBinder.FLAG_ONEWAY;
+import static com.google.common.truth.Truth.assertThat;
+
+import android.os.Parcel;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import io.grpc.binder.internal.LeakSafeOneWayBinder.TransactionHandler;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public final class LeakSafeOneWayBinderTest {
+
+  private LeakSafeOneWayBinder binder;
+  private final FakeHandler handler = new FakeHandler();
+
+  static class FakeHandler implements TransactionHandler {
+    int transactionsHandled;
+    int lastCode;
+    Parcel lastParcel;
+
+    @Override
+    public boolean handleTransaction(int code, Parcel parcel) {
+      transactionsHandled++;
+      lastCode = code;
+      lastParcel = parcel;
+      return true;
+    }
+  }
+
+  @Before
+  public void setUp() {
+    binder = new LeakSafeOneWayBinder(handler);
+  }
+
+  @Test
+  public void testTransaction() {
+    Parcel p = Parcel.obtain();
+    assertThat(binder.onTransact(123, p, null, FLAG_ONEWAY)).isTrue();
+    assertThat(handler.transactionsHandled).isEqualTo(1);
+    assertThat(handler.lastCode).isEqualTo(123);
+    assertThat(handler.lastParcel).isSameInstanceAs(p);
+    p.recycle();
+  }
+
+  @Test
+  public void testDropsTwoWayTransactions() {
+    Parcel p = Parcel.obtain();
+    Parcel reply = Parcel.obtain();
+    assertThat(binder.onTransact(123, p, reply, 0)).isFalse();
+    assertThat(handler.transactionsHandled).isEqualTo(0);
+    p.recycle();
+    reply.recycle();
+  }
+
+  @Test
+  public void testDetach() {
+    Parcel p = Parcel.obtain();
+    binder.detach();
+    assertThat(binder.onTransact(456, p, null, FLAG_ONEWAY)).isFalse();
+
+    // The transaction shouldn't have been processed.
+    assertThat(handler.transactionsHandled).isEqualTo(0);
+
+    p.recycle();
+  }
+
+  @Test
+  public void testReplace() {
+    binder = new LeakSafeOneWayBinder(handler);
+    Parcel p = Parcel.obtain();
+    FakeHandler handler2 = new FakeHandler();
+    binder.setHandler(handler2);
+    assertThat(binder.onTransact(456, p, null, FLAG_ONEWAY)).isTrue();
+
+    assertThat(handler.transactionsHandled).isEqualTo(0);
+    assertThat(handler2.transactionsHandled).isEqualTo(1);
+
+    p.recycle();
+  }
+
+  @Test
+  public void testMultipleTransactions() {
+    Parcel p = Parcel.obtain();
+    assertThat(binder.onTransact(123, p, null, FLAG_ONEWAY)).isTrue();
+    assertThat(binder.onTransact(456, p, null, FLAG_ONEWAY)).isTrue();
+    assertThat(handler.transactionsHandled).isEqualTo(2);
+    assertThat(handler.lastCode).isEqualTo(456);
+    assertThat(handler.lastParcel).isSameInstanceAs(p);
+    p.recycle();
+  }
+
+  @Test
+  public void testPing() {
+    assertThat(binder.pingBinder()).isTrue();
+  }
+
+  @Test
+  public void testPing_Detached() {
+    binder.detach();
+    assertThat(binder.pingBinder()).isFalse();
+  }
+}
diff --git a/binder/src/androidTest/java/io/grpc/binder/internal/OneWayBinderProxies.java b/binder/src/androidTest/java/io/grpc/binder/internal/OneWayBinderProxies.java
new file mode 100644
index 00000000000..4abdb2c03dd
--- /dev/null
+++ b/binder/src/androidTest/java/io/grpc/binder/internal/OneWayBinderProxies.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2024 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.RemoteException;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import javax.annotation.Nullable;
+
+/** A collection of {@link OneWayBinderProxy}-related test helpers. */
+public final class OneWayBinderProxies {
+  /**
+   * A {@link OneWayBinderProxy.Decorator} that blocks calling threads while an (external) test
+   * provides the actual decoration.
+   */
+  public static final class BlockingBinderDecorator<T extends OneWayBinderProxy>
+      implements OneWayBinderProxy.Decorator {
+    private final BlockingQueue<OneWayBinderProxy> requests = new LinkedBlockingQueue<>();
+    private final BlockingQueue<T> results = new LinkedBlockingQueue<>();
+
+    /**
+     * Returns the next {@link OneWayBinderProxy} that needs decorating, blocking if it hasn't yet
+     * been provided to {@link #decorate}.
+     *
+     * <p>Follow this with a call to {@link #putNextResult(OneWayBinderProxy)} to provide the result
+     * of {@link #decorate} and unblock the waiting caller.
+     */
+    public OneWayBinderProxy takeNextRequest() throws InterruptedException {
+      return requests.take();
+    }
+
+    /** Provides the next value to return from {@link #decorate}. */
+    public void putNextResult(T next) throws InterruptedException {
+      results.put(next);
+    }
+
+    @Override
+    public OneWayBinderProxy decorate(OneWayBinderProxy in) {
+      try {
+        requests.put(in);
+        return results.take();
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  /** A {@link OneWayBinderProxy} decorator whose transact method can artificially throw. */
+  public static final class ThrowingOneWayBinderProxy extends OneWayBinderProxy {
+    private final OneWayBinderProxy wrapped;
+    @Nullable private RemoteException remoteException;
+
+    ThrowingOneWayBinderProxy(OneWayBinderProxy wrapped) {
+      super(wrapped.getDelegate());
+      this.wrapped = wrapped;
+    }
+
+    /**
+     * Causes all future invocations of transact to throw `remoteException`.
+     *
+     * <p>Users are responsible for ensuring their calls "happen-before" the relevant calls to
+     * {@link #transact(int, ParcelHolder)}.
+     */
+    public void setRemoteException(RemoteException remoteException) {
+      this.remoteException = remoteException;
+    }
+
+    @Override
+    public void transact(int code, ParcelHolder data) throws RemoteException {
+      if (remoteException != null) {
+        throw remoteException;
+      }
+      wrapped.transact(code, data);
+    }
+  }
+
+  /**
+   * A {@link OneWayBinderProxy} decorator whose transact method can be configured to silently drop.
+   */
+  public static final class BlackHoleOneWayBinderProxy extends OneWayBinderProxy {
+
+    private final OneWayBinderProxy wrapped;
+    private boolean dropAllTransactions;
+
+    BlackHoleOneWayBinderProxy(OneWayBinderProxy wrapped) {
+      super(wrapped.getDelegate());
+      this.wrapped = wrapped;
+    }
+
+    /**
+     * Causes all future invocations of transact to be silently dropped.
+     *
+     * <p>Users are responsible for ensuring their calls "happen-before" the relevant calls to
+     * {@link #transact(int, ParcelHolder)}.
+     */
+    public void dropAllTransactions(boolean dropAllTransactions) {
+      this.dropAllTransactions = dropAllTransactions;
+    }
+
+    @Override
+    public void transact(int code, ParcelHolder data) throws RemoteException {
+      if (!dropAllTransactions) {
+        wrapped.transact(code, data);
+      }
+    }
+  }
+
+  // Cannot be instantiated.
+  private OneWayBinderProxies() {}
+  ;
+}
diff --git a/binder/src/main/AndroidManifest.xml b/binder/src/main/AndroidManifest.xml
new file mode 100644
index 00000000000..239c3b39b38
--- /dev/null
+++ b/binder/src/main/AndroidManifest.xml
@@ -0,0 +1,11 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <queries>
+
+        <intent>
+            <action android:name="android.intent.action.VIEW" />
+        </intent>
+
+    </queries>
+
+</manifest>
\ No newline at end of file
diff --git a/binder/src/main/java/io/grpc/binder/AndroidComponentAddress.java b/binder/src/main/java/io/grpc/binder/AndroidComponentAddress.java
new file mode 100644
index 00000000000..b390c1f0ccd
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/AndroidComponentAddress.java
@@ -0,0 +1,282 @@
+/*
+ * 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;
+
+import static android.content.Intent.URI_ANDROID_APP_SCHEME;
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.os.UserHandle;
+import com.google.common.base.Objects;
+import io.grpc.ExperimentalApi;
+import java.net.SocketAddress;
+import javax.annotation.Nullable;
+
+/**
+ * The target of an Android {@link android.app.Service} binding.
+ *
+ * <p>Consists of an explicit {@link Intent} that identifies an {@link android.os.IBinder} returned
+ * by some Service's {@link android.app.Service#onBind(Intent)} method. You can specify that Service
+ * by {@link ComponentName} or let Android resolve it using the Intent's other fields (package,
+ * action, data URI, type and category set). See <a
+ * href="https://developer.android.com/guide/components/bound-services">Bound Services Overview</a>
+ * and <a href="https://developer.android.com/guide/components/intents-filters">Intents and Intent
+ * Filters</a> for more.
+ *
+ * <p>For convenience in the common case where a {@link android.app.Service} exposes just one {@link
+ * android.os.IBinder} IPC interface, we provide default values for the binding {@link Intent}
+ * fields, namely, an action of {@link ApiConstants#ACTION_BIND}, an empty category set and null
+ * type and data URI.
+ *
+ * <p>Optionally contains a {@link UserHandle} that must be considered wherever the {@link Intent}
+ * is evaluated.
+ *
+ * <p>{@link #equals(Object)} uses {@link Intent#filterEquals(Intent)} semantics to compare Intents.
+ */
+public final class AndroidComponentAddress extends SocketAddress {
+  private static final long serialVersionUID = 0L;
+
+  private final Intent bindIntent; // "Explicit", having either a component or package restriction.
+
+  @Nullable
+  private final UserHandle targetUser; // null means the same user that hosts this process.
+
+  private AndroidComponentAddress(Intent bindIntent, @Nullable UserHandle targetUser) {
+    checkArgument(
+        bindIntent.getComponent() != null || bindIntent.getPackage() != null,
+        "'bindIntent' must be explicit. Specify either a package or ComponentName.");
+    this.bindIntent = bindIntent;
+    this.targetUser = targetUser;
+  }
+
+  /**
+   * Creates an address for the given {@link android.app.Service} instance with the default binding
+   * {@link Intent}.
+   */
+  public static AndroidComponentAddress forContext(Context context) {
+    return forLocalComponent(context, context.getClass());
+  }
+
+  /**
+   * Creates an address referencing a {@link android.app.Service} hosted by this application and
+   * using the default binding {@link Intent}.
+   */
+  public static AndroidComponentAddress forLocalComponent(Context context, Class<?> cls) {
+    return forComponent(new ComponentName(context, cls));
+  }
+
+  /**
+   * Creates an address referencing a {@link android.app.Service} in another application and using
+   * the default binding {@link Intent}.
+   *
+   * @param applicationPackage The package name of the application containing the server.
+   * @param serviceClassName The full class name of the Android Service to bind to.
+   */
+  public static AndroidComponentAddress forRemoteComponent(
+      String applicationPackage, String serviceClassName) {
+    return forComponent(new ComponentName(applicationPackage, serviceClassName));
+  }
+
+  /**
+   * Creates a new address that uses the "filter matching" fields of <code>intent</code> as the
+   * binding {@link Intent}.
+   *
+   * <p><code>intent</code> must be "explicit", i.e. having either a target component ({@link
+   * Intent#getComponent()}) or package restriction ({@link Intent#getPackage()}). See <a
+   * href="https://developer.android.com/guide/components/intents-filters">Intents and Intent
+   * Filters</a> for more.
+   *
+   * <p>A multi-tenant {@link android.app.Service} can call this from its {@link
+   * android.app.Service#onBind(Intent)} method to locate an appropriate {@link io.grpc.Server} by
+   * listening address.
+   *
+   * @throws IllegalArgumentException if 'intent' isn't "explicit"
+   */
+  public static AndroidComponentAddress forBindIntent(Intent intent) {
+    return new AndroidComponentAddress(intent.cloneFilter(), null);
+  }
+
+  /**
+   * Creates an address referencing the specified {@link android.app.Service} component and using
+   * the default binding {@link Intent}.
+   */
+  public static AndroidComponentAddress forComponent(ComponentName component) {
+    return new AndroidComponentAddress(
+        new Intent(ApiConstants.ACTION_BIND).setComponent(component), null);
+  }
+
+  /**
+   * Returns the Authority which is the package name of the target app.
+   *
+   * <p>See {@link android.content.ComponentName} and {@link Intent#getPackage()}.
+   */
+  public String getAuthority() {
+    return getPackage();
+  }
+
+  /**
+   * Returns the package target of the wrapped {@link Intent}, either from its package restriction
+   * or, if not present, its fully qualified {@link ComponentName}.
+   */
+  public String getPackage() {
+    if (bindIntent.getPackage() != null) {
+      return bindIntent.getPackage();
+    } else {
+      return bindIntent.getComponent().getPackageName();
+    }
+  }
+
+  /** Returns the {@link ComponentName} of this binding {@link Intent}, or null if one isn't set. */
+  @Nullable
+  public ComponentName getComponent() {
+    return bindIntent.getComponent();
+  }
+
+  /**
+   * Returns this address as an explicit {@link Intent} suitable for passing to {@link
+   * Context#bindService}.
+   *
+   * <p>NB: The returned Intent does not specify a target Android user. If {@link #getTargetUser()}
+   * is non-null, {@link Context#bindServiceAsUser} should be called instead.
+   */
+  public Intent asBindIntent() {
+    return bindIntent.cloneFilter(); // Intent is mutable so return a copy.
+  }
+
+  /**
+   * Returns this address as an "android-app://" uri.
+   *
+   * <p>See {@link Intent#URI_ANDROID_APP_SCHEME} for details.
+   */
+  public String asAndroidAppUri() {
+    Intent intentForUri = bindIntent;
+    if (intentForUri.getPackage() == null) {
+      // URI_ANDROID_APP_SCHEME requires an "explicit package name" which isn't set by any of our
+      // factory methods. Oddly, a ComponentName is not enough.
+      intentForUri = intentForUri.cloneFilter().setPackage(getComponent().getPackageName());
+    }
+    return intentForUri.toUri(URI_ANDROID_APP_SCHEME);
+  }
+
+  @Override
+  public int hashCode() {
+    Intent intentForHashCode = bindIntent;
+    // Clear a (usually redundant) package filter to work around an Android >= 31 bug where certain
+    // Intents compare filterEquals() but have different filterHashCode() values. It's always safe
+    // to include fewer fields in the hashCode() computation.
+    if (intentForHashCode.getPackage() != null) {
+      intentForHashCode = intentForHashCode.cloneFilter().setPackage(null);
+    }
+    return intentForHashCode.filterHashCode();
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (obj instanceof AndroidComponentAddress) {
+      AndroidComponentAddress that = (AndroidComponentAddress) obj;
+      return bindIntent.filterEquals(that.bindIntent)
+          && Objects.equal(this.targetUser, that.targetUser);
+    }
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder builder = new StringBuilder("AndroidComponentAddress[");
+    if (targetUser != null) {
+      builder.append(targetUser);
+      builder.append("@");
+    }
+    builder.append(bindIntent);
+    builder.append("]");
+    return builder.toString();
+  }
+
+  /**
+   * Identifies the Android user in which the bind Intent will be evaluated.
+   *
+   * <p>Returns the {@link UserHandle}, or null which means that the Android user hosting the
+   * current process will be used.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10173")
+  @Nullable
+  public UserHandle getTargetUser() {
+    return targetUser;
+  }
+
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  /** Fluently builds instances of {@link AndroidComponentAddress}. */
+  public static class Builder {
+    Intent bindIntent;
+    UserHandle targetUser;
+
+    /**
+     * Sets the binding {@link Intent} to one having the "filter matching" fields of 'intent'.
+     *
+     * <p>'intent' must be "explicit", i.e. having either a target component ({@link
+     * Intent#getComponent()}) or package restriction ({@link Intent#getPackage()}).
+     */
+    public Builder setBindIntent(Intent intent) {
+      this.bindIntent = intent.cloneFilter();
+      return this;
+    }
+
+    /**
+     * Sets the binding {@link Intent} to one with the specified 'component' and default values for
+     * all other fields, for convenience.
+     */
+    public Builder setBindIntentFromComponent(ComponentName component) {
+      this.bindIntent = new Intent(ApiConstants.ACTION_BIND).setComponent(component);
+      return this;
+    }
+
+    /**
+     * Specifies the Android user in which the built Address' bind Intent will be evaluated.
+     *
+     * <p>Connecting to a server in a different Android user is uncommon and requires the client app
+     * have runtime visibility of &#064;SystemApi's and hold certain &#064;SystemApi permissions.
+     * The device must also be running Android SDK version 30 or higher.
+     *
+     * <p>See https://developer.android.com/guide/app-compatibility/restrictions-non-sdk-interfaces
+     * for details on which apps can call the underlying &#064;SystemApi's needed to make this type
+     * of connection.
+     *
+     * <p>One of the "android.permission.INTERACT_ACROSS_XXX" permissions is required. The exact one
+     * depends on the calling user's relationship to the target user, whether client and server are
+     * in the same or different apps, and the version of Android in use. See {@link
+     * Context#bindServiceAsUser}, the essential underlying Android API, for details.
+     */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10173")
+    public Builder setTargetUser(@Nullable UserHandle targetUser) {
+      this.targetUser = targetUser;
+      return this;
+    }
+
+    public AndroidComponentAddress build() {
+      // We clone any incoming mutable intent in the setter, not here. AndroidComponentAddress
+      // itself is immutable so multiple instances built from here can safely share 'bindIntent'.
+      checkState(bindIntent != null, "Required property 'bindIntent' unset");
+      return new AndroidComponentAddress(bindIntent, targetUser);
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/ApiConstants.java b/binder/src/main/java/io/grpc/binder/ApiConstants.java
new file mode 100644
index 00000000000..fbf4be6b7ce
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/ApiConstants.java
@@ -0,0 +1,75 @@
+/*
+ * 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;
+
+import android.content.Intent;
+import android.os.UserHandle;
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.ExperimentalApi;
+import io.grpc.NameResolver;
+
+/** Constant parts of the gRPC binder transport public API. */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+public final class ApiConstants {
+  private ApiConstants() {}
+
+  /**
+   * The "action" part of the binding {@link Intent} that gRPC clients use by default to identify
+   * themselves in a {@link android.app.Service#onBind(Intent)} call.
+   */
+  public static final String ACTION_BIND = "grpc.io.action.BIND";
+
+  /**
+   * Gives a {@link NameResolver} access to its Channel's "source" {@link android.content.Context},
+   * the entry point to almost every other Android API.
+   *
+   * <p>This argument is set automatically by {@link BinderChannelBuilder}. Any value passed to
+   * {@link io.grpc.ManagedChannelBuilder#setNameResolverArg} will be ignored.
+   *
+   * <p>See {@link BinderChannelBuilder#forTarget(String, android.content.Context)} for more.
+   */
+  public static final NameResolver.Args.Key<android.content.Context> SOURCE_ANDROID_CONTEXT =
+      NameResolver.Args.Key.create("source-android-context");
+
+  /**
+   * Specifies the Android user in which target URIs should be resolved.
+   *
+   * <p>{@link UserHandle} can't reasonably be encoded in a target URI string. Instead, all {@link
+   * io.grpc.NameResolverProvider}s producing {@link AndroidComponentAddress}es should let clients
+   * address servers in another Android user using this argument.
+   *
+   * <p>Connecting to a server in a different Android user is uncommon and can only be done by a
+   * "system app" client with special permissions. See {@link
+   * AndroidComponentAddress.Builder#setTargetUser(UserHandle)} for details.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10173")
+  public static final NameResolver.Args.Key<UserHandle> TARGET_ANDROID_USER =
+      NameResolver.Args.Key.create("target-android-user");
+
+  /**
+   * Lets you override a Channel's pre-auth configuration (see {@link
+   * BinderChannelBuilder#preAuthorizeServers(boolean)}) for a given {@link EquivalentAddressGroup}.
+   *
+   * <p>A {@link NameResolver} that discovers servers from an untrusted source like PackageManager
+   * can use this to force server pre-auth and prevent abuse.
+   */
+  @EquivalentAddressGroup.Attr
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12191")
+  public static final Attributes.Key<Boolean> PRE_AUTH_SERVER_OVERRIDE =
+      Attributes.Key.create("pre-auth-server-override");
+}
diff --git a/binder/src/main/java/io/grpc/binder/AsyncSecurityPolicy.java b/binder/src/main/java/io/grpc/binder/AsyncSecurityPolicy.java
new file mode 100644
index 00000000000..9594c644e0c
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/AsyncSecurityPolicy.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2023 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;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.ExperimentalApi;
+import io.grpc.Status;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+
+/**
+ * Decides whether a given Android UID is authorized to access some resource.
+ *
+ * <p>This class provides the asynchronous version of {@link SecurityPolicy}, allowing
+ * implementations of authorization logic that involves slow or asynchronous calls without
+ * necessarily blocking the calling thread.
+ *
+ * @see SecurityPolicy
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/10566")
+@CheckReturnValue
+public abstract class AsyncSecurityPolicy extends SecurityPolicy {
+
+  /**
+   * @deprecated Prefer {@link #checkAuthorizationAsync(int)} for async or slow calls or subclass
+   *     {@link SecurityPolicy} directly for quick, synchronous implementations.
+   */
+  @Override
+  @Deprecated
+  public final Status checkAuthorization(int uid) {
+    try {
+      return checkAuthorizationAsync(uid).get();
+    } catch (ExecutionException e) {
+      return Status.fromThrowable(e);
+    } catch (CancellationException e) {
+      return Status.CANCELLED.withCause(e);
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt(); // re-set the current thread's interruption state
+      return Status.CANCELLED.withCause(e);
+    }
+  }
+
+  /**
+   * Decides whether the given Android UID is authorized. (Validity is implementation dependent).
+   *
+   * <p>As long as any given UID has active processes, this method should return the same value for
+   * that UID. In order words, policy changes which occur while a transport instance is active, will
+   * have no effect on that transport instance.
+   *
+   * @param uid The Android UID to authenticate.
+   * @return A {@link ListenableFuture} for a gRPC {@link Status} object, with OK indicating
+   *     authorized.
+   */
+  public abstract ListenableFuture<Status> checkAuthorizationAsync(int uid);
+
+  /**
+   * Decides whether the given Android UID is authorized, without providing its raw integer value.
+   *
+   * <p>Calling this is equivalent to calling {@link SecurityPolicy#checkAuthorization(int)}, except
+   * the caller provides a {@link PeerUid} wrapper instead of the raw integer uid (known only to the
+   * transport). This allows a server to check additional application-layer security policy for
+   * itself *after* the call itself is authorized by the transport layer. Cross cutting application-
+   * layer checks could be done from a {@link io.grpc.ServerInterceptor}. Checks based on the
+   * substance of a request message could be done by the individual RPC method implementations
+   * themselves.
+   *
+   * <p>See #checkAuthorizationAsync(int) for details on the semantics. See {@link
+   * PeerUids#newPeerIdentifyingServerInterceptor()} for how to get a {@link PeerUid}.
+   *
+   * @param uid The Android UID to authenticate.
+   * @return A gRPC {@link Status} object, with OK indicating authorized.
+   */
+  public final ListenableFuture<Status> checkAuthorizationAsync(PeerUid uid) {
+    return checkAuthorizationAsync(uid.getUid());
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/BindServiceFlags.java b/binder/src/main/java/io/grpc/binder/BindServiceFlags.java
new file mode 100644
index 00000000000..2e01cd3ab1f
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/BindServiceFlags.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright 2021 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;
+
+import static android.content.Context.BIND_ABOVE_CLIENT;
+import static android.content.Context.BIND_ADJUST_WITH_ACTIVITY;
+import static android.content.Context.BIND_ALLOW_ACTIVITY_STARTS;
+import static android.content.Context.BIND_ALLOW_OOM_MANAGEMENT;
+import static android.content.Context.BIND_AUTO_CREATE;
+import static android.content.Context.BIND_IMPORTANT;
+import static android.content.Context.BIND_INCLUDE_CAPABILITIES;
+import static android.content.Context.BIND_NOT_FOREGROUND;
+import static android.content.Context.BIND_NOT_PERCEPTIBLE;
+import static android.content.Context.BIND_WAIVE_PRIORITY;
+import static java.lang.Integer.toHexString;
+
+import android.os.Build;
+import androidx.annotation.RequiresApi;
+
+/**
+ * An immutable set of flags affecting the behavior of {@link android.content.Context#bindService}.
+ *
+ * <p>Only flags suitable for use with gRPC/binderchannel are available to manipulate here. The
+ * javadoc for each setter discusses each supported flag's semantics at the gRPC layer.
+ */
+public final class BindServiceFlags {
+  /**
+   * A set of default flags suitable for most applications.
+   *
+   * <p>The {@link Builder#setAutoCreate} flag is guaranteed to be set.
+   */
+  public static final BindServiceFlags DEFAULTS = newBuilder().setAutoCreate(true).build();
+
+  private final int flags;
+
+  private BindServiceFlags(int flags) {
+    this.flags = flags;
+  }
+
+  /**
+   * Returns the sum of all set flags as an int suitable for passing to ({@link
+   * android.content.Context#bindService}.
+   */
+  public int toInteger() {
+    return flags;
+  }
+
+  /**
+   * Returns a new instance of {@link Builder} with *no* flags set.
+   *
+   * <p>Callers should start with {@code DEFAULTS.toBuilder()} instead.
+   */
+  static Builder newBuilder() {
+    return new Builder(0);
+  }
+
+  /** Returns a new instance of {@link Builder} with the same set of flags as {@code this}. */
+  public Builder toBuilder() {
+    return new Builder(flags);
+  }
+
+  /** Builds an instance of {@link BindServiceFlags}. */
+  public static final class Builder {
+    private int flags;
+
+    private Builder(int flags) {
+      this.flags = flags;
+    }
+
+    /**
+     * Sets or clears the {@link android.content.Context#BIND_ABOVE_CLIENT} flag.
+     *
+     * <p>This flag has no additional meaning at the gRPC layer. See the Android docs for more.
+     *
+     * @return this, for fluent construction
+     */
+    public Builder setAboveClient(boolean newValue) {
+      return setFlag(BIND_ABOVE_CLIENT, newValue);
+    }
+
+    /**
+     * Sets or clears the {@link android.content.Context#BIND_ADJUST_WITH_ACTIVITY} flag.
+     *
+     * <p>This flag has no additional meaning at the gRPC layer. See the Android docs for more.
+     *
+     * @return this, for fluent construction
+     */
+    public Builder setAdjustWithActivity(boolean newValue) {
+      return setFlag(BIND_ADJUST_WITH_ACTIVITY, newValue);
+    }
+
+    /**
+     * Sets or clears the {@code android.content.Context#BIND_ALLOW_ACTIVITY_STARTS} flag.
+     *
+     * <p>This flag has no additional meaning at the gRPC layer. See the Android docs for more.
+     *
+     * @return this, for fluent construction
+     */
+    @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+    public Builder setAllowActivityStarts(boolean newValue) {
+      return setFlag(BIND_ALLOW_ACTIVITY_STARTS, newValue);
+    }
+
+    /**
+     * Sets or clears the {@link android.content.Context#BIND_ALLOW_OOM_MANAGEMENT} flag.
+     *
+     * <p>This flag has no additional meaning at the gRPC layer. See the Android docs for more.
+     *
+     * @return this, for fluent construction
+     */
+    public Builder setAllowOomManagement(boolean newValue) {
+      return setFlag(BIND_ALLOW_OOM_MANAGEMENT, newValue);
+    }
+
+    /**
+     * Controls whether sending a call over the associated {@link io.grpc.Channel} will cause the
+     * target {@link android.app.Service} to be created and whether in-flight calls will keep it in
+     * existence absent any other binding in the system.
+     *
+     * <p>If false, RPCs will not succeed until the remote Service comes into existence for some
+     * other reason (if ever). See also {@link io.grpc.CallOptions#withWaitForReady()}.
+     *
+     * <p>See {@link android.content.Context#BIND_AUTO_CREATE} for more.
+     *
+     * @return this, for fluent construction
+     */
+    public Builder setAutoCreate(boolean newValue) {
+      return setFlag(BIND_AUTO_CREATE, newValue);
+    }
+
+    /**
+     * Sets or clears the {@link android.content.Context#BIND_IMPORTANT} flag.
+     *
+     * <p>This flag has no additional meaning at the gRPC layer. See the Android docs for more.
+     *
+     * @return this, for fluent construction
+     */
+    public Builder setImportant(boolean newValue) {
+      return setFlag(BIND_IMPORTANT, newValue);
+    }
+
+    /**
+     * Sets or clears the {@link android.content.Context#BIND_INCLUDE_CAPABILITIES} flag.
+     *
+     * <p>This flag has no additional meaning at the gRPC layer. See the Android docs for more.
+     *
+     * @return this, for fluent construction
+     */
+    @RequiresApi(api = 29)
+    public Builder setIncludeCapabilities(boolean newValue) {
+      return setFlag(BIND_INCLUDE_CAPABILITIES, newValue);
+    }
+
+    /**
+     * Sets or clears the {@link android.content.Context#BIND_NOT_FOREGROUND} flag.
+     *
+     * <p>This flag has no additional meaning at the gRPC layer. See the Android docs for more.
+     *
+     * @return this, for fluent construction
+     */
+    public Builder setNotForeground(boolean newValue) {
+      return setFlag(BIND_NOT_FOREGROUND, newValue);
+    }
+
+    /**
+     * Sets or clears the {@link android.content.Context#BIND_NOT_PERCEPTIBLE} flag.
+     *
+     * <p>This flag has no additional meaning at the gRPC layer. See the Android docs for more.
+     *
+     * @return this, for fluent construction
+     */
+    @RequiresApi(api = 29)
+    public Builder setNotPerceptible(boolean newValue) {
+      return setFlag(BIND_NOT_PERCEPTIBLE, newValue);
+    }
+
+    /**
+     * Sets or clears the {@link android.content.Context#BIND_WAIVE_PRIORITY} flag.
+     *
+     * <p>This flag has no additional meaning at the gRPC layer. See the Android docs for more.
+     *
+     * @return this, for fluent construction
+     */
+    public Builder setWaivePriority(boolean newValue) {
+      return setFlag(BIND_WAIVE_PRIORITY, newValue);
+    }
+
+    /**
+     * Returns a new instance of {@link BindServiceFlags} that reflects the state of this builder.
+     */
+    public BindServiceFlags build() {
+      return new BindServiceFlags(flags);
+    }
+
+    private Builder setFlag(int flag, boolean newValue) {
+      if (newValue) {
+        flags |= flag;
+      } else {
+        flags &= ~flag;
+      }
+      return this;
+    }
+  }
+
+  @Override
+  public String toString() {
+    return "BindServiceFlags{" + toHexString(flags) + "}";
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+
+    BindServiceFlags that = (BindServiceFlags) o;
+    return flags == that.flags;
+  }
+
+  @Override
+  public int hashCode() {
+    return flags;
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/BinderChannelBuilder.java b/binder/src/main/java/io/grpc/binder/BinderChannelBuilder.java
new file mode 100644
index 00000000000..a241634dd22
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/BinderChannelBuilder.java
@@ -0,0 +1,361 @@
+/*
+ * 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import android.content.Context;
+import com.google.errorprone.annotations.DoNotCall;
+import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingChannelBuilder;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.binder.internal.BinderClientTransportFactory;
+import io.grpc.internal.FixedObjectPool;
+import io.grpc.internal.ManagedChannelImplBuilder;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * Builder for a gRPC channel which communicates with an Android bound service.
+ *
+ * @see <a href="https://developer.android.com/guide/components/bound-services.html">Bound
+ *     Services</a>
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+public final class BinderChannelBuilder extends ForwardingChannelBuilder<BinderChannelBuilder> {
+
+  /**
+   * Creates a channel builder that will bind to a remote Android service.
+   *
+   * <p>The underlying Android binding will be torn down when the channel becomes idle. This happens
+   * after 30 minutes without use by default but can be configured via {@link
+   * ManagedChannelBuilder#idleTimeout(long, TimeUnit)} or triggered manually with {@link
+   * ManagedChannel#enterIdle()}.
+   *
+   * <p>You the caller are responsible for managing the lifecycle of any channels built by the
+   * resulting builder. They will not be shut down automatically.
+   *
+   * @param directAddress the {@link AndroidComponentAddress} referencing the service to bind to.
+   * @param sourceContext the context to bind from (e.g. The current Activity or Application).
+   * @return a new builder
+   */
+  public static BinderChannelBuilder forAddress(
+      AndroidComponentAddress directAddress, Context sourceContext) {
+    return new BinderChannelBuilder(
+        checkNotNull(directAddress, "directAddress"),
+        null,
+        sourceContext,
+        BinderChannelCredentials.forDefault());
+  }
+
+  /**
+   * Creates a channel builder that will bind to a remote Android service with provided
+   * BinderChannelCredentials.
+   *
+   * <p>The underlying Android binding will be torn down when the channel becomes idle. This happens
+   * after 30 minutes without use by default but can be configured via {@link
+   * ManagedChannelBuilder#idleTimeout(long, TimeUnit)} or triggered manually with {@link
+   * ManagedChannel#enterIdle()}.
+   *
+   * <p>You the caller are responsible for managing the lifecycle of any channels built by the
+   * resulting builder. They will not be shut down automatically.
+   *
+   * @param directAddress the {@link AndroidComponentAddress} referencing the service to bind to.
+   * @param sourceContext the context to bind from (e.g. The current Activity or Application).
+   * @param channelCredentials the arbitrary binder specific channel credentials to be used to
+   *     establish a binder connection.
+   * @return a new builder
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10173")
+  public static BinderChannelBuilder forAddress(
+      AndroidComponentAddress directAddress,
+      Context sourceContext,
+      BinderChannelCredentials channelCredentials) {
+    return new BinderChannelBuilder(
+        checkNotNull(directAddress, "directAddress"), null, sourceContext, channelCredentials);
+  }
+
+  /**
+   * Creates a channel builder that will bind to a remote Android service, via a string target name
+   * which will be resolved.
+   *
+   * <p>The underlying Android binding will be torn down when the channel becomes idle. This happens
+   * after 30 minutes without use by default but can be configured via {@link
+   * ManagedChannelBuilder#idleTimeout(long, TimeUnit)} or triggered manually with {@link
+   * ManagedChannel#enterIdle()}.
+   *
+   * <p>You the caller are responsible for managing the lifecycle of any channels built by the
+   * resulting builder. They will not be shut down automatically.
+   *
+   * @param target A target uri which should resolve into an {@link AndroidComponentAddress}
+   *     referencing the service to bind to.
+   * @param sourceContext the context to bind from (e.g. The current Activity or Application).
+   * @return a new builder
+   */
+  public static BinderChannelBuilder forTarget(String target, Context sourceContext) {
+    return new BinderChannelBuilder(
+        null, checkNotNull(target, "target"), sourceContext, BinderChannelCredentials.forDefault());
+  }
+
+  /**
+   * Creates a channel builder that will bind to a remote Android service, via a string target name
+   * which will be resolved.
+   *
+   * <p>The underlying Android binding will be torn down when the channel becomes idle. This happens
+   * after 30 minutes without use by default but can be configured via {@link
+   * ManagedChannelBuilder#idleTimeout(long, TimeUnit)} or triggered manually with {@link
+   * ManagedChannel#enterIdle()}.
+   *
+   * <p>You the caller are responsible for managing the lifecycle of any channels built by the
+   * resulting builder. They will not be shut down automatically.
+   *
+   * @param target A target uri which should resolve into an {@link AndroidComponentAddress}
+   *     referencing the service to bind to.
+   * @param sourceContext the context to bind from (e.g. The current Activity or Application).
+   * @param channelCredentials the arbitrary binder specific channel credentials to be used to
+   *     establish a binder connection.
+   * @return a new builder
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10173")
+  public static BinderChannelBuilder forTarget(
+      String target, Context sourceContext, BinderChannelCredentials channelCredentials) {
+    return new BinderChannelBuilder(
+        null, checkNotNull(target, "target"), sourceContext, channelCredentials);
+  }
+
+  /** Always fails. Call {@link #forAddress(AndroidComponentAddress, Context)} instead. */
+  @DoNotCall("Unsupported. Use forAddress(AndroidComponentAddress, Context) instead")
+  public static BinderChannelBuilder forAddress(String name, int port) {
+    throw new UnsupportedOperationException(
+        "call forAddress(AndroidComponentAddress, Context) instead");
+  }
+
+  /** Always fails. Call {@link #forAddress(AndroidComponentAddress, Context)} instead. */
+  @DoNotCall("Unsupported. Use forTarget(String, Context) instead")
+  public static BinderChannelBuilder forTarget(String target) {
+    throw new UnsupportedOperationException(
+        "call forAddress(AndroidComponentAddress, Context) instead");
+  }
+
+  private final ManagedChannelImplBuilder managedChannelImplBuilder;
+  private final BinderClientTransportFactory.Builder transportFactoryBuilder;
+
+  private boolean strictLifecycleManagement;
+
+  private BinderChannelBuilder(
+      @Nullable AndroidComponentAddress directAddress,
+      @Nullable String target,
+      Context sourceContext,
+      BinderChannelCredentials channelCredentials) {
+    transportFactoryBuilder =
+        new BinderClientTransportFactory.Builder()
+            .setSourceContext(sourceContext)
+            .setChannelCredentials(channelCredentials);
+
+    if (directAddress != null) {
+      managedChannelImplBuilder =
+          new ManagedChannelImplBuilder(
+              directAddress, directAddress.getAuthority(), transportFactoryBuilder, null);
+    } else {
+      managedChannelImplBuilder =
+          new ManagedChannelImplBuilder(target, transportFactoryBuilder, null);
+    }
+    idleTimeout(60, TimeUnit.SECONDS);
+  }
+
+  @Override
+  @SuppressWarnings("deprecation") // Not extending ForwardingChannelBuilder2 to preserve ABI.
+  protected ManagedChannelBuilder<?> delegate() {
+    return managedChannelImplBuilder;
+  }
+
+  /** Specifies certain optional aspects of the underlying Android Service binding. */
+  public BinderChannelBuilder setBindServiceFlags(BindServiceFlags bindServiceFlags) {
+    transportFactoryBuilder.setBindServiceFlags(bindServiceFlags);
+    return this;
+  }
+
+  /**
+   * Provides a custom scheduled executor service.
+   *
+   * <p>This is an optional parameter. If the user has not provided a scheduled executor service
+   * when the channel is built, the builder will use a static cached thread pool.
+   *
+   * @return this
+   */
+  public BinderChannelBuilder scheduledExecutorService(
+      ScheduledExecutorService scheduledExecutorService) {
+    transportFactoryBuilder.setScheduledExecutorPool(
+        new FixedObjectPool<>(checkNotNull(scheduledExecutorService, "scheduledExecutorService")));
+    return this;
+  }
+
+  /**
+   * Provides a custom {@link Executor} for accessing this application's main thread.
+   *
+   * <p>Optional. A default implementation will be used if no custom Executor is provided.
+   *
+   * @return this
+   */
+  public BinderChannelBuilder mainThreadExecutor(Executor mainThreadExecutor) {
+    transportFactoryBuilder.setMainThreadExecutor(mainThreadExecutor);
+    return this;
+  }
+
+  /**
+   * Provides a custom security policy.
+   *
+   * <p>This is optional. If the user has not provided a security policy, this channel will only
+   * communicate with the same application UID.
+   *
+   * @return this
+   */
+  public BinderChannelBuilder securityPolicy(SecurityPolicy securityPolicy) {
+    transportFactoryBuilder.setSecurityPolicy(securityPolicy);
+    return this;
+  }
+
+  /** Sets the policy for inbound parcelable objects. */
+  public BinderChannelBuilder inboundParcelablePolicy(
+      InboundParcelablePolicy inboundParcelablePolicy) {
+    transportFactoryBuilder.setInboundParcelablePolicy(inboundParcelablePolicy);
+    return this;
+  }
+
+  /**
+   * Disables the channel idle timeout and prevents it from being enabled. This allows a centralized
+   * application method to configure the channel builder and return it, without worrying about
+   * another part of the application accidentally enabling the idle timeout.
+   */
+  public BinderChannelBuilder strictLifecycleManagement() {
+    strictLifecycleManagement = true;
+    super.idleTimeout(1000, TimeUnit.DAYS); // >30 days disables timeouts entirely.
+    return this;
+  }
+
+  /**
+   * Checks servers against this Channel's {@link SecurityPolicy} *before* binding.
+   *
+   * <p>Android users can be tricked into installing a malicious app with the same package name as a
+   * legitimate server. That's why we don't send calls to a server until it has been authorized by
+   * an appropriate {@link SecurityPolicy}. But merely binding to a malicious server can enable
+   * "keep-alive" and "background activity launch" abuse, even if it's ultimately unauthorized.
+   * Pre-authorization mitigates these threats by performing a preliminary {@link SecurityPolicy}
+   * check against a server app's PackageManager-registered identity without actually creating an
+   * instance of it. This is especially important for security when the server's direct address
+   * isn't known in advance but rather resolved via target URI or discovered by other means.
+   *
+   * <p>Note that, unlike ordinary authorization, pre-authorization is performed against the server
+   * app's UID, not the UID of the process hosting the bound Service. These can be different, most
+   * commonly due to services that set `android:isolatedProcess=true`.
+   *
+   * <p>Pre-authorization is strongly recommended but it remains optional for now because of this
+   * behavior change and the small performance cost.
+   *
+   * <p>The default value of this property is false but it will become true in a future release.
+   * Clients that require a particular behavior should configure it explicitly using this method
+   * rather than relying on the default.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12191")
+  public BinderChannelBuilder preAuthorizeServers(boolean preAuthorize) {
+    transportFactoryBuilder.setPreAuthorizeServers(preAuthorize);
+    return this;
+  }
+
+  /**
+   * Specifies how and when to authorize a server against this Channel's {@link SecurityPolicy}.
+   *
+   * <p>This method selects the original "legacy" authorization strategy, which is no longer
+   * preferred for two reasons: First, the legacy strategy considers the UID of the server *process*
+   * we connect to. This is problematic for services using the `android:isolatedProcess` attribute,
+   * which runs them under a different "ephemeral" UID. This UID lacks all the privileges of the
+   * hosting app -- any non-trivial SecurityPolicy would fail to authorize it. Second, the legacy
+   * authorization strategy performs SecurityPolicy checks later in the connection handshake, which
+   * means the calling UID must be rechecked on every subsequent RPC. For these reasons, prefer
+   * {@link #useV2AuthStrategy} instead.
+   *
+   * <p>The server does not know which authorization strategy a client is using. Both strategies
+   * work with all versions of the grpc-binder server.
+   *
+   * <p>Callers need not specify an authorization strategy, but the default is unspecified and will
+   * eventually become {@link #useV2AuthStrategy()}. Clients that require the legacy strategy should
+   * configure it explicitly using this method. Eventually, however, legacy support will be
+   * deprecated and removed.
+   *
+   * @return this
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12397")
+  public BinderChannelBuilder useLegacyAuthStrategy() {
+    transportFactoryBuilder.setUseLegacyAuthStrategy(true);
+    return this;
+  }
+
+  /**
+   * Specifies how and when to authorize a server against this Channel's {@link SecurityPolicy}.
+   *
+   * <p>This method selects the v2 authorization strategy. It improves on the original strategy
+   * ({@link #useLegacyAuthStrategy}), by considering the UID of the server *app* we connect to,
+   * rather than the server *process*. This allows clients to connect to services configured with
+   * the `android:isolatedProcess` attribute, which run with the same authority as the hosting app,
+   * but under a different "ephemeral" UID that any non-trivial SecurityPolicy would fail to
+   * authorize.
+   *
+   * <p>Furthermore, the v2 authorization strategy performs SecurityPolicy checks earlier in the
+   * connection handshake, which allows subsequent RPCs over that connection to proceed securely
+   * without further UID checks. For these reasons, clients should prefer the v2 strategy.
+   *
+   * <p>The server does not know which authorization strategy a client is using. Both strategies
+   * work with all versions of the grpc-binder server.
+   *
+   * <p>Callers need not specify an authorization strategy, but the default is unspecified and can
+   * change over time. Clients that require the v2 strategy should configure it explicitly using
+   * this method. Eventually, this strategy will become the default and legacy support will be
+   * removed.
+   *
+   * <p>If moving to the new authorization strategy causes a robolectric test to fail, ensure your
+   * fake Service component is registered with `ShadowPackageManager` using `addOrUpdateService()`.
+   *
+   * @return this
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12397")
+  public BinderChannelBuilder useV2AuthStrategy() {
+    transportFactoryBuilder.setUseLegacyAuthStrategy(false);
+    return this;
+  }
+
+  @Override
+  public BinderChannelBuilder idleTimeout(long value, TimeUnit unit) {
+    checkState(
+        !strictLifecycleManagement,
+        "Idle timeouts are not supported when strict lifecycle management is enabled");
+    super.idleTimeout(value, unit);
+    return this;
+  }
+
+  @Override
+  public ManagedChannel build() {
+    transportFactoryBuilder.setOffloadExecutorPool(
+        managedChannelImplBuilder.getOffloadExecutorPool());
+    setNameResolverArg(
+        ApiConstants.SOURCE_ANDROID_CONTEXT, transportFactoryBuilder.getSourceContext());
+    return super.build();
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/BinderChannelCredentials.java b/binder/src/main/java/io/grpc/binder/BinderChannelCredentials.java
new file mode 100644
index 00000000000..f6e6f666494
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/BinderChannelCredentials.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2022 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;
+
+import android.content.ComponentName;
+import androidx.annotation.RequiresApi;
+import io.grpc.ChannelCredentials;
+import io.grpc.ExperimentalApi;
+import javax.annotation.Nullable;
+
+/** Additional arbitrary arguments to establish a Android binder connection channel. */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/10173")
+public final class BinderChannelCredentials extends ChannelCredentials {
+
+  /**
+   * Creates the default BinderChannelCredentials.
+   *
+   * @return a BinderChannelCredentials
+   */
+  public static BinderChannelCredentials forDefault() {
+    return new BinderChannelCredentials(null);
+  }
+
+  /**
+   * Creates a BinderChannelCredentials to be used with DevicePolicyManager API.
+   *
+   * @param devicePolicyAdminComponentName the admin component to be specified with
+   *     DevicePolicyManager.bindDeviceAdminServiceAsUser API.
+   * @return a BinderChannelCredentials
+   */
+  @RequiresApi(26)
+  public static BinderChannelCredentials forDevicePolicyAdmin(
+      ComponentName devicePolicyAdminComponentName) {
+    return new BinderChannelCredentials(devicePolicyAdminComponentName);
+  }
+
+  @Nullable private final ComponentName devicePolicyAdminComponentName;
+
+  private BinderChannelCredentials(@Nullable ComponentName devicePolicyAdminComponentName) {
+    this.devicePolicyAdminComponentName = devicePolicyAdminComponentName;
+  }
+
+  @Override
+  public ChannelCredentials withoutBearerTokens() {
+    return this;
+  }
+
+  /**
+   * Returns the admin component to be specified with DevicePolicyManager
+   * bindDeviceAdminServiceAsUser API.
+   */
+  @Nullable
+  public ComponentName getDevicePolicyAdminComponentName() {
+    return devicePolicyAdminComponentName;
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/BinderInternal.java b/binder/src/main/java/io/grpc/binder/BinderInternal.java
new file mode 100644
index 00000000000..5ed24a07901
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/BinderInternal.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2022 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;
+
+import android.os.IBinder;
+import io.grpc.Internal;
+import io.grpc.binder.internal.BinderTransportSecurity;
+
+/** Helper class to expose IBinderReceiver methods for legacy internal builders. */
+@Internal
+public class BinderInternal {
+
+  /** Sets the receiver's {@link IBinder} using {@link IBinderReceiver#set(IBinder)}. */
+  public static void setIBinder(IBinderReceiver receiver, IBinder binder) {
+    receiver.set(binder);
+  }
+
+  /**
+   * Creates a {@link BinderTransportSecurity.ServerPolicyChecker} from a {@link
+   * ServerSecurityPolicy}. This exposes to callers an interface to check security policies without
+   * causing hard dependencies on a specific class.
+   */
+  public static BinderTransportSecurity.ServerPolicyChecker createPolicyChecker(
+      ServerSecurityPolicy securityPolicy) {
+    return securityPolicy::checkAuthorizationForServiceAsync;
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/BinderServerBuilder.java b/binder/src/main/java/io/grpc/binder/BinderServerBuilder.java
new file mode 100644
index 00000000000..c926c853472
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/BinderServerBuilder.java
@@ -0,0 +1,161 @@
+/*
+ * 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import android.app.Service;
+import android.os.IBinder;
+import com.google.errorprone.annotations.DoNotCall;
+import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingServerBuilder;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.binder.internal.BinderServer;
+import io.grpc.binder.internal.BinderTransportSecurity;
+import io.grpc.internal.FixedObjectPool;
+import io.grpc.internal.ServerImplBuilder;
+import java.io.File;
+import java.util.concurrent.ScheduledExecutorService;
+
+/** Builder for a server that services requests from an Android Service. */
+public final class BinderServerBuilder extends ForwardingServerBuilder<BinderServerBuilder> {
+
+  /**
+   * Creates a server builder that will listen for bindings to the specified address.
+   *
+   * <p>The listening {@link IBinder} associated with new {@link Server}s will be stored in {@code
+   * binderReceiver} upon {@link #build()}. Callers should return it from {@link
+   * Service#onBind(Intent)} when the binding intent matches {@code listenAddress}.
+   *
+   * @param listenAddress an Android Service and binding Intent associated with this server.
+   * @param receiver an "out param" for the new {@link Server}'s listening {@link IBinder}
+   * @return a new builder
+   */
+  public static BinderServerBuilder forAddress(
+      AndroidComponentAddress listenAddress, IBinderReceiver receiver) {
+    return new BinderServerBuilder(listenAddress, receiver);
+  }
+
+  /** Always fails. Call {@link #forAddress(AndroidComponentAddress, IBinderReceiver)} instead. */
+  @DoNotCall("Unsupported. Use forAddress() instead")
+  public static BinderServerBuilder forPort(int port) {
+    throw new UnsupportedOperationException("call forAddress() instead");
+  }
+
+  private final ServerImplBuilder serverImplBuilder;
+  private final BinderServer.Builder internalBuilder = new BinderServer.Builder();
+  private boolean isBuilt;
+
+  private BinderServerBuilder(
+      AndroidComponentAddress listenAddress, IBinderReceiver binderReceiver) {
+    internalBuilder.setListenAddress(listenAddress);
+
+    serverImplBuilder =
+        new ServerImplBuilder(
+            streamTracerFactories -> {
+              internalBuilder.setStreamTracerFactories(streamTracerFactories);
+              BinderServer server = internalBuilder.build();
+              BinderInternal.setIBinder(binderReceiver, server.getHostBinder());
+              return server;
+            });
+
+    // Disable stats and tracing by default.
+    serverImplBuilder.setStatsEnabled(false);
+    serverImplBuilder.setTracingEnabled(false);
+  }
+
+  @Override
+  protected ServerBuilder<?> delegate() {
+    return serverImplBuilder;
+  }
+
+  /** Enable stats collection using census. */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+  public BinderServerBuilder enableStats() {
+    serverImplBuilder.setStatsEnabled(true);
+    return this;
+  }
+
+  /** Enable tracing using census. */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+  public BinderServerBuilder enableTracing() {
+    serverImplBuilder.setTracingEnabled(true);
+    return this;
+  }
+
+  /**
+   * Provides a custom scheduled executor service.
+   *
+   * <p>It's an optional parameter. If the user has not provided a scheduled executor service when
+   * the channel is built, the builder will use a static cached thread pool.
+   *
+   * @return this
+   */
+  public BinderServerBuilder scheduledExecutorService(
+      ScheduledExecutorService scheduledExecutorService) {
+    internalBuilder.setExecutorServicePool(
+        new FixedObjectPool<>(checkNotNull(scheduledExecutorService, "scheduledExecutorService")));
+    return this;
+  }
+
+  /**
+   * Provides a custom security policy.
+   *
+   * <p>This is optional. If the user has not provided a security policy, the server will default to
+   * only accepting calls from the same application UID.
+   *
+   * @return this
+   */
+  public BinderServerBuilder securityPolicy(ServerSecurityPolicy securityPolicy) {
+    internalBuilder.setServerSecurityPolicy(securityPolicy);
+    return this;
+  }
+
+  /** Sets the policy for inbound parcelable objects. */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+  public BinderServerBuilder inboundParcelablePolicy(
+      InboundParcelablePolicy inboundParcelablePolicy) {
+    internalBuilder.setInboundParcelablePolicy(inboundParcelablePolicy);
+    return this;
+  }
+
+  /** Always fails. TLS is not supported in BinderServer. */
+  @Override
+  public BinderServerBuilder useTransportSecurity(File certChain, File privateKey) {
+    throw new UnsupportedOperationException("TLS not supported in BinderServer");
+  }
+
+  /**
+   * Builds a {@link Server} according to this builder's parameters and stores its listening {@link
+   * IBinder} in the {@link IBinderReceiver} passed to {@link #forAddress(AndroidComponentAddress,
+   * IBinderReceiver)}.
+   *
+   * @return the new Server
+   */
+  @Override
+  public Server build() {
+    // Since we install a final interceptor here, we need to ensure we're only built once.
+    checkState(!isBuilt, "BinderServerBuilder can only be used to build one server instance.");
+    isBuilt = true;
+    // We install the security interceptor last, so it's closest to the transport.
+    BinderTransportSecurity.installAuthInterceptor(this);
+    internalBuilder.setExecutorPool(serverImplBuilder.getExecutorPool());
+    return super.build();
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/IBinderReceiver.java b/binder/src/main/java/io/grpc/binder/IBinderReceiver.java
new file mode 100644
index 00000000000..adf4a0d3d8e
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/IBinderReceiver.java
@@ -0,0 +1,38 @@
+/*
+ * 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;
+
+import android.os.IBinder;
+import javax.annotation.Nullable;
+
+/** A container for at most one instance of {@link IBinder}, useful as an "out parameter". */
+public final class IBinderReceiver {
+  @Nullable private volatile IBinder value;
+
+  /** Constructs a new, initially empty, container. */
+  public IBinderReceiver() {}
+
+  /** Returns the contents of this container or null if it is empty. */
+  @Nullable
+  public IBinder get() {
+    return value;
+  }
+
+  protected void set(IBinder value) {
+    this.value = value;
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/InboundParcelablePolicy.java b/binder/src/main/java/io/grpc/binder/InboundParcelablePolicy.java
new file mode 100644
index 00000000000..23470829d74
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/InboundParcelablePolicy.java
@@ -0,0 +1,107 @@
+/*
+ * 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;
+
+import com.google.common.base.Preconditions;
+import io.grpc.ExperimentalApi;
+
+/**
+ * Contains the policy for accepting inbound parcelable objects.
+ *
+ * <p>Since parcelables are generally error prone and parsing a parcelable can have unspecified
+ * side-effects, their use is generally discouraged. Some use cases require them though (E.g. when
+ * dealing with some platform-defined objects), so this policy allows them to be supported.
+ *
+ * <p>Parcelables can arrive as RPC messages, or as metadata values (in headers or footers). The
+ * default is to reject both cases, failing the RPC with a PERMISSION_DENED status code. This policy
+ * can be updated to accept one or both cases.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+public final class InboundParcelablePolicy {
+
+  /** The maximum allowed total size of Parcelables in metadata. */
+  public static final int MAX_PARCELABLE_METADATA_SIZE = 32 * 1024;
+
+  public static final InboundParcelablePolicy DEFAULT =
+      new InboundParcelablePolicy(false, false, MAX_PARCELABLE_METADATA_SIZE);
+
+  private final boolean acceptParcelableMetadataValues;
+  private final boolean acceptParcelableMessages;
+  private final int maxParcelableMetadataSize;
+
+  private InboundParcelablePolicy(
+      boolean acceptParcelableMetadataValues,
+      boolean acceptParcelableMessages,
+      int maxParcelableMetadataSize) {
+    this.acceptParcelableMetadataValues = acceptParcelableMetadataValues;
+    this.acceptParcelableMessages = acceptParcelableMessages;
+    this.maxParcelableMetadataSize = maxParcelableMetadataSize;
+  }
+
+  public boolean shouldAcceptParcelableMetadataValues() {
+    return acceptParcelableMetadataValues;
+  }
+
+  public boolean shouldAcceptParcelableMessages() {
+    return acceptParcelableMessages;
+  }
+
+  public int getMaxParcelableMetadataSize() {
+    return maxParcelableMetadataSize;
+  }
+
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  /** A builder for InboundParcelablePolicy. */
+  public static final class Builder {
+    private boolean acceptParcelableMetadataValues = DEFAULT.acceptParcelableMetadataValues;
+    private boolean acceptParcelableMessages = DEFAULT.acceptParcelableMessages;
+    private int maxParcelableMetadataSize = DEFAULT.maxParcelableMetadataSize;
+
+    /** Sets whether the policy should accept parcelable metadata values. */
+    public Builder setAcceptParcelableMetadataValues(boolean acceptParcelableMetadataValues) {
+      this.acceptParcelableMetadataValues = acceptParcelableMetadataValues;
+      return this;
+    }
+
+    /** Sets whether the policy should accept parcelable messages. */
+    public Builder setAcceptParcelableMessages(boolean acceptParcelableMessages) {
+      this.acceptParcelableMessages = acceptParcelableMessages;
+      return this;
+    }
+
+    /**
+     * Sets the maximum allowed total size of parcelables in metadata.
+     *
+     * @param maxParcelableMetadataSize must not exceed {@link #MAX_PARCELABLE_METADATA_SIZE}
+     */
+    public Builder setMaxParcelableMetadataSize(int maxParcelableMetadataSize) {
+      Preconditions.checkArgument(
+          maxParcelableMetadataSize <= MAX_PARCELABLE_METADATA_SIZE,
+          "Parcelable metadata size can't exceed MAX_PARCELABLE_METADATA_SIZE.");
+      this.maxParcelableMetadataSize = maxParcelableMetadataSize;
+      return this;
+    }
+
+    public InboundParcelablePolicy build() {
+      return new InboundParcelablePolicy(
+          acceptParcelableMetadataValues, acceptParcelableMessages, maxParcelableMetadataSize);
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/LifecycleOnDestroyHelper.java b/binder/src/main/java/io/grpc/binder/LifecycleOnDestroyHelper.java
new file mode 100644
index 00000000000..8631bac0df3
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/LifecycleOnDestroyHelper.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2021 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;
+
+import androidx.annotation.MainThread;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.Lifecycle.State;
+import androidx.lifecycle.LifecycleEventObserver;
+import androidx.lifecycle.LifecycleObserver;
+import androidx.lifecycle.LifecycleOwner;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+
+/**
+ * Helps work around certain quirks of {@link Lifecycle#addObserver} and {@link State#DESTROYED}.
+ *
+ * <p>In particular, calls to {@link Lifecycle#addObserver(LifecycleObserver)} are silently ignored
+ * if the owner is already destroyed.
+ */
+public final class LifecycleOnDestroyHelper {
+
+  private LifecycleOnDestroyHelper() {}
+
+  /**
+   * Arranges for {@link ManagedChannel#shutdownNow()} to be called on {@code channel} just before
+   * {@code lifecycle} is destroyed, or immediately if {@code lifecycle} is already destroyed.
+   *
+   * <p>Must only be called on the application's main thread.
+   */
+  @MainThread
+  public static void shutdownUponDestruction(Lifecycle lifecycle, ManagedChannel channel) {
+    if (lifecycle.getCurrentState() == State.DESTROYED) {
+      channel.shutdownNow();
+    } else {
+      lifecycle.addObserver(
+          new LifecycleEventObserver() {
+            @Override
+            public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
+              if (event == Lifecycle.Event.ON_DESTROY) {
+                source.getLifecycle().removeObserver(this);
+                channel.shutdownNow();
+              }
+            }
+          });
+    }
+  }
+
+  /**
+   * Arranges for {@link Server#shutdownNow()} to be called on {@code server} just before {@code
+   * lifecycle} is destroyed, or immediately if {@code lifecycle} is already destroyed.
+   *
+   * <p>Must only be called on the application's main thread.
+   */
+  @MainThread
+  public static void shutdownUponDestruction(Lifecycle lifecycle, Server server) {
+    if (lifecycle.getCurrentState() == State.DESTROYED) {
+      server.shutdownNow();
+    } else {
+      lifecycle.addObserver(
+          new LifecycleEventObserver() {
+            @Override
+            public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
+              if (event == Lifecycle.Event.ON_DESTROY) {
+                source.getLifecycle().removeObserver(this);
+                server.shutdownNow();
+              }
+            }
+          });
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/ParcelableUtils.java b/binder/src/main/java/io/grpc/binder/ParcelableUtils.java
new file mode 100644
index 00000000000..0082d33aff5
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/ParcelableUtils.java
@@ -0,0 +1,55 @@
+/*
+ * 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;
+
+import android.os.Parcelable;
+import io.grpc.Metadata;
+import io.grpc.binder.internal.MetadataHelper;
+
+/**
+ * Utility methods for using Android Parcelable objects with gRPC.
+ *
+ * <p>This class models the same pattern as the {@code ProtoLiteUtils} class.
+ */
+public final class ParcelableUtils {
+
+  private ParcelableUtils() {}
+
+  /**
+   * Create a {@link Metadata.Key} for passing a Parcelable object in the metadata of an RPC,
+   * treating instances as mutable.
+   *
+   * <p><b>Note:<b/>Parcelables can only be sent across in-process and binder channels.
+   */
+  public static <P extends Parcelable> Metadata.Key<P> metadataKey(
+      String name, Parcelable.Creator<P> creator) {
+    return Metadata.Key.of(
+        name, new MetadataHelper.ParcelableMetadataMarshaller<P>(creator, false));
+  }
+
+  /**
+   * Create a {@link Metadata.Key} for passing a Parcelable object in the metadata of an RPC,
+   * treating instances as immutable. Immutability may be used for optimization purposes (e.g. Not
+   * copying for in-process calls).
+   *
+   * <p><b>Note:<b/>Parcelables can only be sent across in-process and binder channels.
+   */
+  public static <P extends Parcelable> Metadata.Key<P> metadataKeyForImmutableType(
+      String name, Parcelable.Creator<P> creator) {
+    return Metadata.Key.of(name, new MetadataHelper.ParcelableMetadataMarshaller<P>(creator, true));
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/PeerUid.java b/binder/src/main/java/io/grpc/binder/PeerUid.java
new file mode 100644
index 00000000000..87ff6763378
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/PeerUid.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2023 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;
+
+import io.grpc.ExperimentalApi;
+
+/**
+ * Identifies a gRPC/binder client or server by Android/Linux UID
+ * (https://source.android.com/security/app-sandbox).
+ *
+ * <p>Use {@link PeerUids#REMOTE_PEER} to obtain the client's {@link PeerUid} from the server's
+ * {@link io.grpc.Context}
+ *
+ * <p>The actual integer uid is intentionally not exposed to prevent misuse. If you want the uid for
+ * access control, consider one of the existing {@link SecurityPolicies} instead (or propose a new
+ * one). If you want the uid to pass to some other Android API, consider one of the static wrapper
+ * methods of {@link PeerUids} instead (or propose a new one).
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+public final class PeerUid {
+
+  private final int uid;
+
+  /** Constructs a new instance. Intentionally non-public to prevent misuse. */
+  PeerUid(int uid) {
+    this.uid = uid;
+  }
+
+  /** Returns an identifier for the current process. */
+  public static PeerUid forCurrentProcess() {
+    return new PeerUid(android.os.Process.myUid());
+  }
+
+  /**
+   * Returns this peer's Android/Linux uid.
+   *
+   * <p>Intentionally non-public to prevent misuse.
+   */
+  int getUid() {
+    return uid;
+  }
+
+  @Override
+  public boolean equals(Object otherObj) {
+    if (this == otherObj) {
+      return true;
+    }
+    if (otherObj == null || getClass() != otherObj.getClass()) {
+      return false;
+    }
+    PeerUid otherPeerUid = (PeerUid) otherObj;
+    return uid == otherPeerUid.uid;
+  }
+
+  @Override
+  public int hashCode() {
+    return Integer.valueOf(uid).hashCode();
+  }
+
+  @Override
+  public String toString() {
+    return "PeerUid{" + uid + '}';
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/PeerUids.java b/binder/src/main/java/io/grpc/binder/PeerUids.java
new file mode 100644
index 00000000000..4c4143166a1
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/PeerUids.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2023 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import android.content.pm.PackageManager;
+import android.os.Build.VERSION_CODES;
+import android.os.UserHandle;
+import androidx.annotation.RequiresApi;
+import io.grpc.Context;
+import io.grpc.Contexts;
+import io.grpc.ExperimentalApi;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.binder.internal.BinderTransport;
+import javax.annotation.Nullable;
+
+/** Static methods that operate on {@link PeerUid}. */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+public final class PeerUids {
+  /**
+   * The client's authentic identity will be stored under this key in the server {@link Context}.
+   *
+   * <p>In order for this key to be populated, the interceptor returned by {@link
+   * #newPeerIdentifyingServerInterceptor} must be attached to the service. Note that the Context
+   * must be propagated correctly across threads for this key to be populated when read from other
+   * threads.
+   */
+  public static final Context.Key<PeerUid> REMOTE_PEER = Context.key("remote-peer");
+
+  /**
+   * Returns package names associated with the given peer's uid according to {@link
+   * PackageManager#getPackagesForUid(int)}.
+   *
+   * <p><em>WARNING</em>: Apps installed from untrusted sources can set any package name they want.
+   * Don't depend on package names for security -- use {@link SecurityPolicies} instead.
+   */
+  public static String[] getInsecurePackagesForUid(PackageManager packageManager, PeerUid who) {
+    return packageManager.getPackagesForUid(who.getUid());
+  }
+
+  /**
+   * Retrieves the "official name" associated with this uid, as specified by {@link
+   * PackageManager#getNameForUid(int)}.
+   */
+  @Nullable
+  public static String getNameForUid(PackageManager packageManager, PeerUid who) {
+    return packageManager.getNameForUid(who.getUid());
+  }
+
+  /**
+   * Retrieves the {@link UserHandle} associated with this uid according to {@link
+   * UserHandle#getUserHandleForUid}.
+   */
+  @RequiresApi(api = VERSION_CODES.N)
+  public static UserHandle getUserHandleForUid(PeerUid who) {
+    return UserHandle.getUserHandleForUid(who.getUid());
+  }
+
+  /**
+   * Creates an interceptor that exposes the client's identity in the {@link Context} under {@link
+   * #REMOTE_PEER}.
+   *
+   * <p>The returned interceptor only works with the Android Binder transport. If installed
+   * elsewhere, all intercepted requests will fail without ever reaching application-layer
+   * processing.
+   */
+  public static ServerInterceptor newPeerIdentifyingServerInterceptor() {
+    return new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+          ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+        Context context = Context.current();
+        PeerUid client =
+            new PeerUid(
+                checkNotNull(
+                    call.getAttributes().get(BinderTransport.REMOTE_UID),
+                    "Expected BinderTransport attribute REMOTE_UID was missing. Is this "
+                        + "interceptor installed on an unsupported type of Server?"));
+        return Contexts.interceptCall(context.withValue(REMOTE_PEER, client), call, headers, next);
+      }
+    };
+  }
+
+  private PeerUids() {}
+}
diff --git a/binder/src/main/java/io/grpc/binder/SecurityPolicies.java b/binder/src/main/java/io/grpc/binder/SecurityPolicies.java
new file mode 100644
index 00000000000..c0f6fe81989
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/SecurityPolicies.java
@@ -0,0 +1,519 @@
+/*
+ * 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;
+
+import android.annotation.SuppressLint;
+import android.app.admin.DevicePolicyManager;
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.pm.Signature;
+import android.os.Build;
+import android.os.Build.VERSION;
+import android.os.Process;
+import androidx.annotation.RequiresApi;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.hash.Hashing;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.ExperimentalApi;
+import io.grpc.Status;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+/** Static factory methods for creating standard security policies. */
+@CheckReturnValue
+public final class SecurityPolicies {
+
+  private static final int MY_UID = Process.myUid();
+  private static final int SHA_256_BYTES_LENGTH = 32;
+
+  private SecurityPolicies() {}
+
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+  public static ServerSecurityPolicy serverInternalOnly() {
+    return new ServerSecurityPolicy();
+  }
+
+  /**
+   * Creates a default {@link SecurityPolicy} that allows access only to callers with the same UID
+   * as the current process.
+   */
+  public static SecurityPolicy internalOnly() {
+    return new SecurityPolicy() {
+      @Override
+      public Status checkAuthorization(int uid) {
+        return uid == MY_UID
+            ? Status.OK
+            : Status.PERMISSION_DENIED.withDescription(
+                "Rejected by (internal-only) security policy");
+      }
+    };
+  }
+
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+  public static SecurityPolicy permissionDenied(String description) {
+    Status denied = Status.PERMISSION_DENIED.withDescription(description);
+    return new SecurityPolicy() {
+      @Override
+      public Status checkAuthorization(int uid) {
+        return denied;
+      }
+    };
+  }
+
+  /**
+   * Creates a {@link SecurityPolicy} which checks if the package signature matches {@code
+   * requiredSignature}.
+   *
+   * @param packageName the package name of the allowed package.
+   * @param requiredSignature the allowed signature of the allowed package.
+   * @throws NullPointerException if any of the inputs are {@code null}.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+  public static SecurityPolicy hasSignature(
+      PackageManager packageManager, String packageName, Signature requiredSignature) {
+    return oneOfSignatures(packageManager, packageName, ImmutableList.of(requiredSignature));
+  }
+
+  /**
+   * Creates {@link SecurityPolicy} which checks if the SHA-256 hash of the package signature
+   * matches {@code requiredSignatureSha256Hash}.
+   *
+   * @param packageName the package name of the allowed package.
+   * @param requiredSignatureSha256Hash the SHA-256 digest of the signature of the allowed package.
+   * @throws NullPointerException if any of the inputs are {@code null}.
+   * @throws IllegalArgumentException if {@code requiredSignatureSha256Hash} is not of length 32.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+  public static SecurityPolicy hasSignatureSha256Hash(
+      PackageManager packageManager, String packageName, byte[] requiredSignatureSha256Hash) {
+    return oneOfSignatureSha256Hash(
+        packageManager, packageName, ImmutableList.of(requiredSignatureSha256Hash));
+  }
+
+  /**
+   * Creates a {@link SecurityPolicy} which checks if the package signature matches any of {@code
+   * requiredSignatures}.
+   *
+   * @param packageName the package name of the allowed package.
+   * @param requiredSignatures the allowed signatures of the allowed package.
+   * @throws NullPointerException if any of the inputs are {@code null}.
+   * @throws IllegalArgumentException if {@code requiredSignatures} is empty.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+  public static SecurityPolicy oneOfSignatures(
+      PackageManager packageManager, String packageName, Collection<Signature> requiredSignatures) {
+    Preconditions.checkNotNull(packageManager, "packageManager");
+    Preconditions.checkNotNull(packageName, "packageName");
+    Preconditions.checkNotNull(requiredSignatures, "requiredSignatures");
+    Preconditions.checkArgument(!requiredSignatures.isEmpty(), "requiredSignatures");
+    ImmutableList<Signature> requiredSignaturesImmutable = ImmutableList.copyOf(requiredSignatures);
+
+    for (Signature requiredSignature : requiredSignaturesImmutable) {
+      Preconditions.checkNotNull(requiredSignature);
+    }
+
+    return new SecurityPolicy() {
+      @Override
+      public Status checkAuthorization(int uid) {
+        return checkUidSignature(packageManager, uid, packageName, requiredSignaturesImmutable);
+      }
+    };
+  }
+
+  /**
+   * Creates {@link SecurityPolicy} which checks if the SHA-256 hash of the package signature
+   * matches any of {@code requiredSignatureSha256Hashes}.
+   *
+   * @param packageName the package name of the allowed package.
+   * @param requiredSignatureSha256Hashes the SHA-256 digests of the signatures of the allowed
+   *     package.
+   * @throws NullPointerException if any of the inputs are {@code null}.
+   * @throws IllegalArgumentException if {@code requiredSignatureSha256Hashes} is empty, or if any
+   *     of the {@code requiredSignatureSha256Hashes} are not of length 32.
+   */
+  public static SecurityPolicy oneOfSignatureSha256Hash(
+      PackageManager packageManager,
+      String packageName,
+      List<byte[]> requiredSignatureSha256Hashes) {
+    Preconditions.checkNotNull(packageManager);
+    Preconditions.checkNotNull(packageName);
+    Preconditions.checkNotNull(requiredSignatureSha256Hashes);
+    Preconditions.checkArgument(!requiredSignatureSha256Hashes.isEmpty());
+
+    ImmutableList.Builder<byte[]> immutableListBuilder = ImmutableList.builder();
+    for (byte[] requiredSignatureSha256Hash : requiredSignatureSha256Hashes) {
+      Preconditions.checkNotNull(requiredSignatureSha256Hash);
+      Preconditions.checkArgument(requiredSignatureSha256Hash.length == SHA_256_BYTES_LENGTH);
+      immutableListBuilder.add(
+          Arrays.copyOf(requiredSignatureSha256Hash, requiredSignatureSha256Hash.length));
+    }
+    ImmutableList<byte[]> requiredSignaturesHashesImmutable = immutableListBuilder.build();
+
+    return new SecurityPolicy() {
+      @Override
+      public Status checkAuthorization(int uid) {
+        return checkUidSha256Signature(
+            packageManager, uid, packageName, requiredSignaturesHashesImmutable);
+      }
+    };
+  }
+
+  /**
+   * Creates {@link SecurityPolicy} which checks if the app is a device owner app. See {@link
+   * DevicePolicyManager}.
+   */
+  public static io.grpc.binder.SecurityPolicy isDeviceOwner(Context applicationContext) {
+    DevicePolicyManager devicePolicyManager =
+        (DevicePolicyManager) applicationContext.getSystemService(Context.DEVICE_POLICY_SERVICE);
+    return anyPackageWithUidSatisfies(
+        applicationContext,
+        pkg -> devicePolicyManager.isDeviceOwnerApp(pkg),
+        "Rejected by device owner policy. No packages found for UID.",
+        "Rejected by device owner policy");
+  }
+
+  /**
+   * Creates {@link SecurityPolicy} which checks if the app is a profile owner app. See {@link
+   * DevicePolicyManager}.
+   */
+  public static SecurityPolicy isProfileOwner(Context applicationContext) {
+    DevicePolicyManager devicePolicyManager =
+        (DevicePolicyManager) applicationContext.getSystemService(Context.DEVICE_POLICY_SERVICE);
+    return anyPackageWithUidSatisfies(
+        applicationContext,
+        pkg -> devicePolicyManager.isProfileOwnerApp(pkg),
+        "Rejected by profile owner policy. No packages found for UID.",
+        "Rejected by profile owner policy");
+  }
+
+  /**
+   * Creates {@link SecurityPolicy} which checks if the app is a profile owner app on an
+   * organization-owned device. See {@link DevicePolicyManager}.
+   */
+  public static SecurityPolicy isProfileOwnerOnOrganizationOwnedDevice(Context applicationContext) {
+    DevicePolicyManager devicePolicyManager =
+        (DevicePolicyManager) applicationContext.getSystemService(Context.DEVICE_POLICY_SERVICE);
+    return anyPackageWithUidSatisfies(
+        applicationContext,
+        pkg ->
+            VERSION.SDK_INT >= 30
+                && devicePolicyManager.isProfileOwnerApp(pkg)
+                && devicePolicyManager.isOrganizationOwnedDeviceWithManagedProfile(),
+        "Rejected by profile owner on organization-owned device policy. No packages found for UID.",
+        "Rejected by profile owner on organization-owned device policy");
+  }
+
+  private static Status checkUidSignature(
+      PackageManager packageManager,
+      int uid,
+      String packageName,
+      ImmutableList<Signature> requiredSignatures) {
+    String[] packages = packageManager.getPackagesForUid(uid);
+    if (packages == null) {
+      return Status.UNAUTHENTICATED.withDescription("Rejected by signature check security policy");
+    }
+    boolean packageNameMatched = false;
+    for (String pkg : packages) {
+      if (!packageName.equals(pkg)) {
+        continue;
+      }
+      packageNameMatched = true;
+      if (checkPackageSignature(packageManager, pkg, requiredSignatures::contains)) {
+        return Status.OK;
+      }
+    }
+    return Status.PERMISSION_DENIED.withDescription(
+        "Rejected by signature check security policy. Package name matched: " + packageNameMatched);
+  }
+
+  private static Status checkUidSha256Signature(
+      PackageManager packageManager,
+      int uid,
+      String packageName,
+      ImmutableList<byte[]> requiredSignatureSha256Hashes) {
+    String[] packages = packageManager.getPackagesForUid(uid);
+    if (packages == null) {
+      return Status.UNAUTHENTICATED.withDescription(
+          "Rejected by (SHA-256 hash signature check) security policy");
+    }
+    boolean packageNameMatched = false;
+    for (String pkg : packages) {
+      if (!packageName.equals(pkg)) {
+        continue;
+      }
+      packageNameMatched = true;
+      if (checkPackageSignature(
+          packageManager,
+          pkg,
+          (signature) ->
+              checkSignatureSha256HashesMatch(signature, requiredSignatureSha256Hashes))) {
+        return Status.OK;
+      }
+    }
+    return Status.PERMISSION_DENIED.withDescription(
+        "Rejected by (SHA-256 hash signature check) security policy. Package name matched: "
+            + packageNameMatched);
+  }
+
+  /**
+   * Checks if the signature of {@code packageName} matches one of the given signatures.
+   *
+   * @param packageName the package to be checked
+   * @param signatureCheckFunction {@link Predicate} that takes a signature and verifies if it
+   *     satisfies any signature constraints return {@code true} if {@code packageName} has a
+   *     signature that satisfies {@code signatureCheckFunction}.
+   */
+  @SuppressWarnings("deprecation") // For PackageInfo.signatures
+  @SuppressLint("PackageManagerGetSignatures") // We only allow 1 signature.
+  private static boolean checkPackageSignature(
+      PackageManager packageManager,
+      String packageName,
+      Predicate<Signature> signatureCheckFunction) {
+    PackageInfo packageInfo;
+    try {
+      if (Build.VERSION.SDK_INT >= 28) {
+        packageInfo =
+            packageManager.getPackageInfo(packageName, PackageManager.GET_SIGNING_CERTIFICATES);
+        if (packageInfo.signingInfo == null) {
+          return false;
+        }
+        Signature[] signatures =
+            packageInfo.signingInfo.hasMultipleSigners()
+                ? packageInfo.signingInfo.getApkContentsSigners()
+                : packageInfo.signingInfo.getSigningCertificateHistory();
+
+        for (Signature signature : signatures) {
+          if (signatureCheckFunction.apply(signature)) {
+            return true;
+          }
+        }
+      } else {
+        packageInfo = packageManager.getPackageInfo(packageName, PackageManager.GET_SIGNATURES);
+        if (packageInfo.signatures == null || packageInfo.signatures.length != 1) {
+          // Reject multiply-signed apks because of b/13678484
+          // (See PackageManagerGetSignatures suppression above).
+          return false;
+        }
+
+        if (signatureCheckFunction.apply(packageInfo.signatures[0])) {
+          return true;
+        }
+      }
+    } catch (NameNotFoundException nnfe) {
+      return false;
+    }
+    return false;
+  }
+
+  /**
+   * Creates a {@link SecurityPolicy} that allows access if and only if *all* of the specified
+   * {@code securityPolicies} allow access.
+   *
+   * @param securityPolicies the security policies that all must allow access.
+   * @throws NullPointerException if any of the inputs are {@code null}.
+   * @throws IllegalArgumentException if {@code securityPolicies} is empty.
+   */
+  public static SecurityPolicy allOf(SecurityPolicy... securityPolicies) {
+    Preconditions.checkNotNull(securityPolicies, "securityPolicies");
+    Preconditions.checkArgument(securityPolicies.length > 0, "securityPolicies must not be empty");
+
+    return allOfSecurityPolicy(securityPolicies);
+  }
+
+  private static SecurityPolicy allOfSecurityPolicy(SecurityPolicy... securityPolicies) {
+    return new SecurityPolicy() {
+      @Override
+      public Status checkAuthorization(int uid) {
+        for (SecurityPolicy policy : securityPolicies) {
+          Status checkAuth = policy.checkAuthorization(uid);
+          if (!checkAuth.isOk()) {
+            return checkAuth;
+          }
+        }
+
+        return Status.OK;
+      }
+    };
+  }
+
+  /**
+   * Creates a {@link SecurityPolicy} that allows access if *any* of the specified {@code
+   * securityPolicies} allow access.
+   *
+   * <p>Policies will be checked in the order that they are passed. If a policy allows access,
+   * subsequent policies will not be checked.
+   *
+   * <p>If all policies deny access, the {@link io.grpc.Status} returned by {@code
+   * checkAuthorization} will included the concatenated descriptions of the failed policies and
+   * attach any additional causes as suppressed throwables. The status code will be that of the
+   * first failed policy.
+   *
+   * @param securityPolicies the security policies that will be checked.
+   * @throws NullPointerException if any of the inputs are {@code null}.
+   * @throws IllegalArgumentException if {@code securityPolicies} is empty.
+   */
+  public static SecurityPolicy anyOf(SecurityPolicy... securityPolicies) {
+    Preconditions.checkNotNull(securityPolicies, "securityPolicies");
+    Preconditions.checkArgument(securityPolicies.length > 0, "securityPolicies must not be empty");
+
+    return anyOfSecurityPolicy(securityPolicies);
+  }
+
+  private static SecurityPolicy anyOfSecurityPolicy(SecurityPolicy... securityPolicies) {
+    return new SecurityPolicy() {
+      @Override
+      public Status checkAuthorization(int uid) {
+        List<Status> failed = new ArrayList<>();
+        for (SecurityPolicy policy : securityPolicies) {
+          Status checkAuth = policy.checkAuthorization(uid);
+          if (checkAuth.isOk()) {
+            return checkAuth;
+          }
+          failed.add(checkAuth);
+        }
+
+        Iterator<Status> iter = failed.iterator();
+        Status toReturn = iter.next();
+        while (iter.hasNext()) {
+          Status append = iter.next();
+          toReturn = toReturn.augmentDescription(append.getDescription());
+          if (append.getCause() != null) {
+            if (toReturn.getCause() != null) {
+              toReturn.getCause().addSuppressed(append.getCause());
+            } else {
+              toReturn = toReturn.withCause(append.getCause());
+            }
+          }
+        }
+        return toReturn;
+      }
+    };
+  }
+
+  /**
+   * Creates a {@link SecurityPolicy} which checks if the caller has all of the given permissions
+   * from {@code permissions}.
+   *
+   * <p>The gRPC framework assumes that a {@link SecurityPolicy}'s verdict for a given peer UID will
+   * not change over the lifetime of any process with that UID. But Android runtime permissions can
+   * be granted or revoked by the user at any time and so using the {@link #hasPermissions} {@link
+   * SecurityPolicy} comes with certain special responsibilities.
+   *
+   * <p>In particular, callers must ensure that the *subjects* of the returned {@link
+   * SecurityPolicy} hold all required {@code permissions} *before* making use of it. Android kills
+   * an app's processes when it loses any permission but the same isn't true when a permission is
+   * granted. And so without special care, a {@link #hasPermissions} denial could incorrectly
+   * persist even if the subject is later granted all required {@code permissions}.
+   *
+   * <p>A server using {@link #hasPermissions} must, as part of its RPC API contract, require
+   * clients to request and receive all {@code permissions} before making a call. This is in line
+   * with official Android guidance to request and confirm receipt of runtime permissions before
+   * using them.
+   *
+   * <p>A client, on the other hand, should only use {@link #hasPermissions} policies that require
+   * install-time permissions which cannot change.
+   *
+   * @param permissions all permissions that the calling package needs to have
+   * @throws NullPointerException if any of the inputs are {@code null}
+   * @throws IllegalArgumentException if {@code permissions} is empty
+   */
+  public static SecurityPolicy hasPermissions(
+      PackageManager packageManager, ImmutableSet<String> permissions) {
+    Preconditions.checkNotNull(packageManager, "packageManager");
+    Preconditions.checkNotNull(permissions, "permissions");
+    Preconditions.checkArgument(!permissions.isEmpty(), "permissions");
+    return new SecurityPolicy() {
+      @Override
+      public Status checkAuthorization(int uid) {
+        return checkPermissions(uid, packageManager, permissions);
+      }
+    };
+  }
+
+  private static Status checkPermissions(
+      int uid, PackageManager packageManager, ImmutableSet<String> permissions) {
+    String[] packages = packageManager.getPackagesForUid(uid);
+    if (packages == null || packages.length == 0) {
+      return Status.UNAUTHENTICATED.withDescription(
+          "Rejected by permission check security policy. No packages found for uid");
+    }
+    for (String pkg : packages) {
+      for (String permission : permissions) {
+        if (packageManager.checkPermission(permission, pkg) != PackageManager.PERMISSION_GRANTED) {
+          return Status.PERMISSION_DENIED.withDescription(
+              "Rejected by permission check security policy. "
+                  + pkg
+                  + " does not have permission "
+                  + permission);
+        }
+      }
+    }
+
+    return Status.OK;
+  }
+
+  private static SecurityPolicy anyPackageWithUidSatisfies(
+      Context applicationContext,
+      Predicate<String> condition,
+      String errorMessageForNoPackages,
+      String errorMessageForDenied) {
+    return new SecurityPolicy() {
+      @Override
+      public Status checkAuthorization(int uid) {
+        String[] packages = applicationContext.getPackageManager().getPackagesForUid(uid);
+        if (packages == null || packages.length == 0) {
+          return Status.UNAUTHENTICATED.withDescription(errorMessageForNoPackages);
+        }
+
+        for (String pkg : packages) {
+          if (condition.apply(pkg)) {
+            return Status.OK;
+          }
+        }
+        return Status.PERMISSION_DENIED.withDescription(errorMessageForDenied);
+      }
+    };
+  }
+
+  /**
+   * Checks if the SHA-256 hash of the {@code signature} matches one of the {@code
+   * expectedSignatureSha256Hashes}.
+   */
+  private static boolean checkSignatureSha256HashesMatch(
+      Signature signature, List<byte[]> expectedSignatureSha256Hashes) {
+    byte[] signatureHash = getSha256Hash(signature);
+    for (byte[] hash : expectedSignatureSha256Hashes) {
+      if (Arrays.equals(hash, signatureHash)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /** Returns SHA-256 hash of the provided signature. */
+  private static byte[] getSha256Hash(Signature signature) {
+    return Hashing.sha256().hashBytes(signature.toByteArray()).asBytes();
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/SecurityPolicy.java b/binder/src/main/java/io/grpc/binder/SecurityPolicy.java
new file mode 100644
index 00000000000..3ad8903407f
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/SecurityPolicy.java
@@ -0,0 +1,77 @@
+/*
+ * 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;
+
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.Status;
+
+/**
+ * Decides whether a given Android UID is authorized to access some resource.
+ *
+ * <p>While it's possible to extend this class to define your own policy, it's strongly recommended
+ * that you only use the policies provided by the {@link SecurityPolicies} or {@link
+ * UntrustedSecurityPolicies} classes. Implementing your own security policy requires significant
+ * care, and an understanding of the details and pitfalls of Android security.
+ *
+ * <p><b>IMPORTANT</b> For any concrete extensions of this class, it's assumed that the
+ * authorization status of a given UID will <b>not</b> change as long as a process with that UID is
+ * alive.
+ *
+ * <p>In order words, we expect the security policy for a given transport to remain constant for the
+ * lifetime of that transport. This is considered acceptable because no transport will survive the
+ * re-installation of the applications involved.
+ */
+@CheckReturnValue
+public abstract class SecurityPolicy {
+
+  protected SecurityPolicy() {}
+
+  /**
+   * Decides whether the given Android UID is authorized. (Validity is implementation dependent).
+   *
+   * <p><b>IMPORTANT</b>: This method may block for extended periods of time.
+   *
+   * <p>As long as any given UID has active processes, this method should return the same value for
+   * that UID. In order words, policy changes which occur while a transport instance is active, will
+   * have no effect on that transport instance.
+   *
+   * @param uid The Android UID to authenticate.
+   * @return A gRPC {@link Status} object, with OK indicating authorized.
+   */
+  public abstract Status checkAuthorization(int uid);
+
+  /**
+   * Decides whether the given Android UID is authorized, without providing its raw integer value.
+   *
+   * <p>Calling this is equivalent to calling {@link SecurityPolicy#checkAuthorization(int)}, except
+   * the caller provides a {@link PeerUid} wrapper instead of the raw integer uid (known only to the
+   * transport). This allows a server to check additional application-layer security policy for
+   * itself *after* the call itself is authorized by the transport layer. Cross cutting application-
+   * layer checks could be done from a {@link io.grpc.ServerInterceptor}. Checks based on the
+   * substance of a request message could be done by the individual RPC method implementations
+   * themselves.
+   *
+   * <p>See #checkAuthorizationAsync(int) for details on the semantics. See {@link
+   * PeerUids#newPeerIdentifyingServerInterceptor()} for how to get a {@link PeerUid}.
+   *
+   * @param uid The Android UID to authenticate.
+   * @return A gRPC {@link Status} object, with OK indicating authorized.
+   */
+  public final Status checkAuthorization(PeerUid uid) {
+    return checkAuthorization(uid.getUid());
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/ServerSecurityPolicy.java b/binder/src/main/java/io/grpc/binder/ServerSecurityPolicy.java
new file mode 100644
index 00000000000..4786a5e6cc4
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/ServerSecurityPolicy.java
@@ -0,0 +1,114 @@
+/*
+ * 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;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.Status;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A security policy for a gRPC server.
+ *
+ * <p>Contains a default policy, and optional policies for each server.
+ */
+public final class ServerSecurityPolicy {
+
+  private final SecurityPolicy defaultPolicy;
+  private final ImmutableMap<String, SecurityPolicy> perServicePolicies;
+
+  ServerSecurityPolicy() {
+    this(ImmutableMap.of());
+  }
+
+  private ServerSecurityPolicy(ImmutableMap<String, SecurityPolicy> perServicePolicies) {
+    this.defaultPolicy = SecurityPolicies.internalOnly();
+    this.perServicePolicies = perServicePolicies;
+  }
+
+  /**
+   * Returns whether the given Android UID is authorized to access a particular service.
+   *
+   * <p><b>IMPORTANT</b>: This method may block for extended periods of time.
+   *
+   * @param uid The Android UID to authenticate.
+   * @param serviceName The name of the gRPC service being called.
+   * @deprecated Application code should not need to call this method.
+   */
+  @CheckReturnValue
+  @Deprecated
+  public Status checkAuthorizationForService(int uid, String serviceName) {
+    return perServicePolicies.getOrDefault(serviceName, defaultPolicy).checkAuthorization(uid);
+  }
+
+  /**
+   * Returns whether the given Android UID is authorized to access a particular service.
+   *
+   * <p>This method never throws an exception. If the execution of the security policy check fails,
+   * a failed future with such exception is returned.
+   *
+   * @param uid The Android UID to authenticate.
+   * @param serviceName The name of the gRPC service being called.
+   * @return a future with the result of the authorization check. A failed future represents a
+   *     failure to perform the authorization check, not that the access is denied.
+   */
+  @CheckReturnValue
+  ListenableFuture<Status> checkAuthorizationForServiceAsync(int uid, String serviceName) {
+    SecurityPolicy securityPolicy = perServicePolicies.getOrDefault(serviceName, defaultPolicy);
+    if (securityPolicy instanceof AsyncSecurityPolicy) {
+      return ((AsyncSecurityPolicy) securityPolicy).checkAuthorizationAsync(uid);
+    }
+
+    try {
+      Status status = securityPolicy.checkAuthorization(uid);
+      return Futures.immediateFuture(status);
+    } catch (Exception e) {
+      return Futures.immediateFailedFuture(e);
+    }
+  }
+
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  /** Builder for an AndroidServiceSecurityPolicy. */
+  public static final class Builder {
+    private final Map<String, SecurityPolicy> grpcServicePolicies;
+
+    private Builder() {
+      grpcServicePolicies = new HashMap<>();
+    }
+
+    /**
+     * Specify a policy specific to a particular gRPC service.
+     *
+     * @param serviceName The fully qualified name of the gRPC service (from the proto).
+     * @param policy The security policy to apply to the service.
+     */
+    public Builder servicePolicy(String serviceName, SecurityPolicy policy) {
+      grpcServicePolicies.put(serviceName, policy);
+      return this;
+    }
+
+    public ServerSecurityPolicy build() {
+      return new ServerSecurityPolicy(ImmutableMap.copyOf(grpcServicePolicies));
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/UntrustedSecurityPolicies.java b/binder/src/main/java/io/grpc/binder/UntrustedSecurityPolicies.java
new file mode 100644
index 00000000000..44612a82109
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/UntrustedSecurityPolicies.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2021 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;
+
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.ExperimentalApi;
+import io.grpc.Status;
+
+/** Static factory methods for creating untrusted security policies. */
+@CheckReturnValue
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/8022")
+public final class UntrustedSecurityPolicies {
+
+  private UntrustedSecurityPolicies() {}
+
+  /**
+   * Return a security policy which allows any peer on device. Servers should only use this policy
+   * if they intend to expose a service to all applications on device. Clients should only use this
+   * policy if they don't need to trust the application they're connecting to.
+   */
+  public static SecurityPolicy untrustedPublic() {
+    return new SecurityPolicy() {
+      @Override
+      public Status checkAuthorization(int uid) {
+        return Status.OK;
+      }
+    };
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/ActiveTransportTracker.java b/binder/src/main/java/io/grpc/binder/internal/ActiveTransportTracker.java
new file mode 100644
index 00000000000..01505bfd509
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/ActiveTransportTracker.java
@@ -0,0 +1,110 @@
+package io.grpc.binder.internal;
+
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.Metadata;
+import io.grpc.internal.ServerListener;
+import io.grpc.internal.ServerStream;
+import io.grpc.internal.ServerTransport;
+import io.grpc.internal.ServerTransportListener;
+
+/**
+ * Tracks which {@link BinderServerTransport} are currently active and allows invoking a {@link
+ * Runnable} only once all transports are terminated.
+ */
+final class ActiveTransportTracker implements ServerListener {
+  private final ServerListener delegate;
+  private final Runnable terminationListener;
+
+  @GuardedBy("this")
+  private boolean shutdown = false;
+
+  @GuardedBy("this")
+  private int activeTransportCount = 0;
+
+  /**
+   * @param delegate the original server listener that this object decorates. Usually passed to
+   *     {@link BinderServer#start(ServerListener)}.
+   * @param terminationListener invoked only once the server has started shutdown ({@link
+   *     #serverShutdown()} AND the last active transport is terminated.
+   */
+  ActiveTransportTracker(ServerListener delegate, Runnable terminationListener) {
+    this.delegate = delegate;
+    this.terminationListener = terminationListener;
+  }
+
+  @Override
+  public ServerTransportListener transportCreated(ServerTransport transport) {
+    synchronized (this) {
+      checkState(!shutdown, "Illegal transportCreated() after serverShutdown()");
+      activeTransportCount++;
+    }
+    ServerTransportListener originalListener = delegate.transportCreated(transport);
+    return new TrackedTransportListener(originalListener);
+  }
+
+  private void untrack() {
+    Runnable maybeTerminationListener;
+    synchronized (this) {
+      activeTransportCount--;
+      maybeTerminationListener = getListenerIfTerminated();
+    }
+    // Prefer running the listener outside of the synchronization lock to release it sooner, since
+    // we don't know how the callback is implemented nor how long it will take. This should
+    // minimize the possibility of deadlocks.
+    if (maybeTerminationListener != null) {
+      maybeTerminationListener.run();
+    }
+  }
+
+  @Override
+  public void serverShutdown() {
+    delegate.serverShutdown();
+    Runnable maybeTerminationListener;
+    synchronized (this) {
+      shutdown = true;
+      maybeTerminationListener = getListenerIfTerminated();
+    }
+    // We may be able to shutdown immediately if there are no active transports.
+    //
+    // Executed outside of the lock. See "untrack()" above.
+    if (maybeTerminationListener != null) {
+      maybeTerminationListener.run();
+    }
+  }
+
+  @GuardedBy("this")
+  private Runnable getListenerIfTerminated() {
+    return (shutdown && activeTransportCount == 0) ? terminationListener : null;
+  }
+
+  /**
+   * Wraps a {@link ServerTransportListener}, unregistering it from the parent tracker once the
+   * transport terminates.
+   */
+  private final class TrackedTransportListener implements ServerTransportListener {
+    private final ServerTransportListener delegate;
+
+    TrackedTransportListener(ServerTransportListener delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    public void streamCreated(ServerStream stream, String method, Metadata headers) {
+      delegate.streamCreated(stream, method, headers);
+    }
+
+    @Override
+    public Attributes transportReady(Attributes attributes) {
+      return delegate.transportReady(attributes);
+    }
+
+    @Override
+    public void transportTerminated() {
+      delegate.transportTerminated();
+      untrack();
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/Bindable.java b/binder/src/main/java/io/grpc/binder/internal/Bindable.java
new file mode 100644
index 00000000000..59a2502de2b
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/Bindable.java
@@ -0,0 +1,98 @@
+/*
+ * 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.content.pm.ServiceInfo;
+import android.os.IBinder;
+import androidx.annotation.AnyThread;
+import androidx.annotation.MainThread;
+import io.grpc.Status;
+import io.grpc.StatusException;
+
+/** An interface for managing a {@code Binder} connection. */
+interface Bindable {
+
+  /**
+   * Callbacks from this class.
+   *
+   * <p>Methods will be called at most once, and always on the application's main thread.
+   */
+  interface Observer {
+
+    /** We're now bound to the service. Only called once, and only if the binding succeeded. */
+    @MainThread
+    void onBound(IBinder binder);
+
+    /**
+     * We've disconnected from (or failed to bind to) the service. This will only be called once,
+     * after which no other calls will be made (but see note on threading above).
+     *
+     * @param reason why the connection failed or couldn't be established in the first place
+     */
+    @MainThread
+    void onUnbound(Status reason);
+  }
+
+  /**
+   * Fetches details about the remote Service from PackageManager without binding to it.
+   *
+   * <p>Resolving an untrusted address before binding to it lets you screen out problematic servers
+   * before giving them a chance to run. However, note that the identity/existence of the resolved
+   * Service can change between the time this method returns and the time you actually bind/connect
+   * to it. For example, suppose the target package gets uninstalled or upgraded right after this
+   * method returns.
+   *
+   * <p>Compare with {@link #getConnectedServiceInfo()}, which can only be called after {@link
+   * Observer#onBound(IBinder)} but can be used to learn about the service you actually connected
+   * to.
+   */
+  @AnyThread
+  ServiceInfo resolve() throws StatusException;
+
+  /**
+   * Attempt to bind with the remote service.
+   *
+   * <p>Calling this multiple times or after {@link #unbind()} has no effect.
+   */
+  @AnyThread
+  void bind();
+
+  /**
+   * Asks PackageManager for details about the remote Service we *actually* connected to.
+   *
+   * <p>Can only be called after {@link Observer#onBound}.
+   *
+   * <p>Compare with {@link #resolve()}, which reports which service would be selected as of now but
+   * *without* connecting.
+   *
+   * @throws StatusException UNIMPLEMENTED if the connected service isn't found (an {@link
+   *     Observer#onUnbound} callback has likely already happened or is on its way!)
+   * @throws IllegalStateException if {@link Observer#onBound} has not "happened-before" this call
+   */
+  @AnyThread
+  ServiceInfo getConnectedServiceInfo() throws StatusException;
+
+  /**
+   * Unbind from the remote service if connected.
+   *
+   * <p>Observers will be notified with reason code {@code CANCELLED}.
+   *
+   * <p>Subsequent calls to {@link #bind()} (or this method) will have no effect.
+   */
+  @AnyThread
+  void unbind();
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/BinderClientTransport.java b/binder/src/main/java/io/grpc/binder/internal/BinderClientTransport.java
new file mode 100644
index 00000000000..bef1eefd43e
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/BinderClientTransport.java
@@ -0,0 +1,547 @@
+/*
+ * 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.base.Preconditions.checkNotNull;
+import static io.grpc.binder.ApiConstants.PRE_AUTH_SERVER_OVERRIDE;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import android.content.Context;
+import android.content.pm.ServiceInfo;
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.os.Process;
+import androidx.annotation.BinderThread;
+import androidx.annotation.MainThread;
+import com.google.common.base.Ticker;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.errorprone.annotations.CheckReturnValue;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Grpc;
+import io.grpc.Internal;
+import io.grpc.InternalLogId;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.SecurityLevel;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.binder.AndroidComponentAddress;
+import io.grpc.binder.AsyncSecurityPolicy;
+import io.grpc.binder.InboundParcelablePolicy;
+import io.grpc.binder.SecurityPolicy;
+import io.grpc.internal.ClientStream;
+import io.grpc.internal.ClientTransportFactory.ClientTransportOptions;
+import io.grpc.internal.ConnectionClientTransport;
+import io.grpc.internal.FailingClientStream;
+import io.grpc.internal.GrpcAttributes;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.ManagedClientTransport;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SimpleDisconnectError;
+import io.grpc.internal.StatsTraceContext;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/** Concrete client-side transport implementation. */
+@ThreadSafe
+@Internal
+public final class BinderClientTransport extends BinderTransport
+    implements ConnectionClientTransport, Bindable.Observer {
+
+  private final ObjectPool<? extends Executor> offloadExecutorPool;
+  private final Executor offloadExecutor;
+  private final SecurityPolicy securityPolicy;
+  private final Bindable serviceBinding;
+
+  @GuardedBy("this")
+  private final ClientHandshake handshake;
+
+  /** Number of ongoing calls which keep this transport "in-use". */
+  private final AtomicInteger numInUseStreams;
+
+  private final long readyTimeoutMillis;
+  private final PingTracker pingTracker;
+  private final boolean preAuthorizeServer;
+
+  @Nullable private ManagedClientTransport.Listener clientTransportListener;
+
+  @GuardedBy("this")
+  private int latestCallId = FIRST_CALL_ID;
+
+  @GuardedBy("this")
+  private ScheduledFuture<?> readyTimeoutFuture; // != null iff timeout scheduled.
+
+  /**
+   * Constructs a new transport instance.
+   *
+   * @param factory parameters common to all a Channel's transports
+   * @param targetAddress the fully resolved and load-balanced server address
+   * @param options other parameters that can vary as transports come and go within a Channel
+   */
+  public BinderClientTransport(
+      BinderClientTransportFactory factory,
+      AndroidComponentAddress targetAddress,
+      ClientTransportOptions options) {
+    super(
+        factory.scheduledExecutorPool,
+        buildClientAttributes(
+            options.getEagAttributes(),
+            factory.sourceContext,
+            targetAddress,
+            factory.inboundParcelablePolicy),
+        factory.binderDecorator,
+        buildLogId(factory.sourceContext, targetAddress));
+    this.offloadExecutorPool = factory.offloadExecutorPool;
+    this.securityPolicy = factory.securityPolicy;
+    this.offloadExecutor = offloadExecutorPool.getObject();
+    this.readyTimeoutMillis = factory.readyTimeoutMillis;
+    Boolean preAuthServerOverride = options.getEagAttributes().get(PRE_AUTH_SERVER_OVERRIDE);
+    this.preAuthorizeServer =
+        preAuthServerOverride != null ? preAuthServerOverride : factory.preAuthorizeServers;
+    this.handshake =
+        factory.useLegacyAuthStrategy ? new LegacyClientHandshake() : new V2ClientHandshake();
+    numInUseStreams = new AtomicInteger();
+    pingTracker = new PingTracker(Ticker.systemTicker(), (id) -> sendPing(id));
+    serviceBinding =
+        new ServiceBinding(
+            factory.mainThreadExecutor,
+            factory.sourceContext,
+            factory.channelCredentials,
+            targetAddress.asBindIntent(),
+            targetAddress.getTargetUser(),
+            factory.bindServiceFlags.toInteger(),
+            this);
+  }
+
+  @Override
+  void releaseExecutors() {
+    super.releaseExecutors();
+    offloadExecutorPool.returnObject(offloadExecutor);
+  }
+
+  @Override
+  public synchronized void onBound(IBinder binder) {
+    handshake.onBound(binderDecorator.decorate(OneWayBinderProxy.wrap(binder, offloadExecutor)));
+  }
+
+  @Override
+  public synchronized void onUnbound(Status reason) {
+    shutdownInternal(reason, true);
+  }
+
+  @CheckReturnValue
+  @Override
+  public synchronized Runnable start(Listener clientTransportListener) {
+    this.clientTransportListener = checkNotNull(clientTransportListener);
+    return this::postStartRunnable;
+  }
+
+  private synchronized void postStartRunnable() {
+    if (!inState(TransportState.NOT_STARTED)) {
+      return;
+    }
+
+    setState(TransportState.SETUP);
+
+    try {
+      if (preAuthorizeServer) {
+        preAuthorize(serviceBinding.resolve());
+      } else {
+        serviceBinding.bind();
+      }
+    } catch (StatusException e) {
+      shutdownInternal(e.getStatus(), true);
+      return;
+    }
+
+    if (readyTimeoutMillis >= 0) {
+      readyTimeoutFuture =
+          getScheduledExecutorService()
+              .schedule(
+                  BinderClientTransport.this::onReadyTimeout, readyTimeoutMillis, MILLISECONDS);
+    }
+  }
+
+  @GuardedBy("this")
+  private void preAuthorize(ServiceInfo serviceInfo) {
+    // It's unlikely, but the identity/existence of this Service could change by the time we
+    // actually connect. It doesn't matter though, because:
+    // - If pre-auth fails (but would succeed against the server's new state), the grpc-core layer
+    // will eventually retry using a new transport instance that will see the Service's new state.
+    // - If pre-auth succeeds (but would fail against the server's new state), we might give an
+    // unauthorized server a chance to run, but the connection will still fail by SecurityPolicy
+    // check later in handshake. Pre-auth remains effective at mitigating abuse because malware
+    // can't typically control the exact timing of its installation.
+    ListenableFuture<Status> preAuthResultFuture =
+        register(checkServerAuthorizationAsync(serviceInfo.applicationInfo.uid));
+    Futures.addCallback(
+        preAuthResultFuture,
+        new FutureCallback<Status>() {
+          @Override
+          public void onSuccess(Status result) {
+            handlePreAuthResult(result);
+          }
+
+          @Override
+          public void onFailure(Throwable t) {
+            handleAuthResult(t);
+          }
+        },
+        offloadExecutor);
+  }
+
+  private synchronized void handlePreAuthResult(Status authorization) {
+    if (!inState(TransportState.SETUP)) {
+      return;
+    }
+
+    if (!authorization.isOk()) {
+      shutdownInternal(authorization, true);
+      return;
+    }
+
+    serviceBinding.bind();
+  }
+
+  private synchronized void onReadyTimeout() {
+    if (inState(TransportState.SETUP)) {
+      readyTimeoutFuture = null;
+      shutdownInternal(
+          Status.DEADLINE_EXCEEDED.withDescription(
+              "Connect timeout " + readyTimeoutMillis + "ms lapsed"),
+          true);
+    }
+  }
+
+  @Override
+  public synchronized ClientStream newStream(
+      final MethodDescriptor<?, ?> method,
+      final Metadata headers,
+      final CallOptions callOptions,
+      ClientStreamTracer[] tracers) {
+    if (!inState(TransportState.READY)) {
+      return newFailingClientStream(
+          isShutdown()
+              ? shutdownStatus
+              : Status.INTERNAL.withDescription("newStream() before transportReady()"),
+          attributes,
+          headers,
+          tracers);
+    }
+
+    int callId = latestCallId++;
+    if (latestCallId == LAST_CALL_ID) {
+      latestCallId = FIRST_CALL_ID;
+    }
+    StatsTraceContext statsTraceContext =
+        StatsTraceContext.newClientContext(tracers, attributes, headers);
+    Inbound.ClientInbound inbound =
+        new Inbound.ClientInbound(
+            this, attributes, callId, GrpcUtil.shouldBeCountedForInUse(callOptions));
+    if (ongoingCalls.putIfAbsent(callId, inbound) != null) {
+      Status failure = Status.INTERNAL.withDescription("Clashing call IDs");
+      shutdownInternal(failure, true);
+      return newFailingClientStream(failure, attributes, headers, tracers);
+    }
+
+    if (inbound.countsForInUse() && numInUseStreams.getAndIncrement() == 0) {
+      clientTransportListener.transportInUse(true);
+    }
+    Outbound.ClientOutbound outbound =
+        new Outbound.ClientOutbound(this, callId, method, headers, statsTraceContext);
+    if (method.getType().clientSendsOneMessage()) {
+      return new SingleMessageClientStream(inbound, outbound, attributes);
+    } else {
+      return new MultiMessageClientStream(inbound, outbound, attributes);
+    }
+  }
+
+  @Override
+  protected void unregisterInbound(Inbound<?> inbound) {
+    if (inbound.countsForInUse() && numInUseStreams.decrementAndGet() == 0) {
+      clientTransportListener.transportInUse(false);
+    }
+    super.unregisterInbound(inbound);
+  }
+
+  @Override
+  public void ping(final PingCallback callback, Executor executor) {
+    pingTracker.startPing(callback, executor);
+  }
+
+  @Override
+  public synchronized void shutdown(Status reason) {
+    checkNotNull(reason, "reason");
+    shutdownInternal(reason, false);
+  }
+
+  @Override
+  public synchronized void shutdownNow(Status reason) {
+    checkNotNull(reason, "reason");
+    shutdownInternal(reason, true);
+  }
+
+  @Override
+  @GuardedBy("this")
+  void notifyShutdown(Status status) {
+    clientTransportListener.transportShutdown(status, SimpleDisconnectError.UNKNOWN);
+  }
+
+  @Override
+  @GuardedBy("this")
+  void notifyTerminated() {
+    if (numInUseStreams.getAndSet(0) > 0) {
+      clientTransportListener.transportInUse(false);
+    }
+    if (readyTimeoutFuture != null) {
+      readyTimeoutFuture.cancel(false);
+      readyTimeoutFuture = null;
+    }
+    serviceBinding.unbind();
+    clientTransportListener.transportTerminated();
+  }
+
+  @Override
+  @GuardedBy("this")
+  protected void handleSetupTransport(Parcel parcel) {
+    if (!inState(TransportState.SETUP)) {
+      return;
+    }
+
+    int version = parcel.readInt();
+    if (version != WIRE_FORMAT_VERSION) {
+      shutdownInternal(Status.UNAVAILABLE.withDescription("Wire format version mismatch"), true);
+      return;
+    }
+
+    IBinder binder = parcel.readStrongBinder();
+    if (binder == null) {
+      shutdownInternal(Status.UNAVAILABLE.withDescription("Malformed SETUP_TRANSPORT data"), true);
+      return;
+    }
+
+    if (!setOutgoingBinder(OneWayBinderProxy.wrap(binder, offloadExecutor))) {
+      shutdownInternal(
+          Status.UNAVAILABLE.withDescription("Failed to observe outgoing binder"), true);
+      return;
+    }
+    handshake.handleSetupTransport();
+  }
+
+  @GuardedBy("this")
+  private void checkServerAuthorization(int remoteUid) {
+    ListenableFuture<Status> authResultFuture = register(checkServerAuthorizationAsync(remoteUid));
+    Futures.addCallback(
+        authResultFuture,
+        new FutureCallback<Status>() {
+          @Override
+          public void onSuccess(Status result) {
+            handleAuthResult(result);
+          }
+
+          @Override
+          public void onFailure(Throwable t) {
+            handleAuthResult(t);
+          }
+        },
+        offloadExecutor);
+  }
+
+  private ListenableFuture<Status> checkServerAuthorizationAsync(int remoteUid) {
+    return (securityPolicy instanceof AsyncSecurityPolicy)
+        ? ((AsyncSecurityPolicy) securityPolicy).checkAuthorizationAsync(remoteUid)
+        : Futures.submit(() -> securityPolicy.checkAuthorization(remoteUid), offloadExecutor);
+  }
+
+  private synchronized void handleAuthResult(Status authorization) {
+    if (!inState(TransportState.SETUP)) {
+      return;
+    }
+
+    if (!authorization.isOk()) {
+      shutdownInternal(authorization, true);
+      return;
+    }
+    handshake.onServerAuthorizationOk();
+  }
+
+  private final class V2ClientHandshake implements ClientHandshake {
+
+    private OneWayBinderProxy endpointBinder;
+
+    @Override
+    @GuardedBy("BinderClientTransport.this") // By way of @GuardedBy("this") `handshake` member.
+    public void onBound(OneWayBinderProxy endpointBinder) {
+      this.endpointBinder = endpointBinder;
+      Futures.addCallback(
+          Futures.submit(serviceBinding::getConnectedServiceInfo, offloadExecutor),
+          new FutureCallback<ServiceInfo>() {
+            @Override
+            public void onSuccess(ServiceInfo result) {
+              synchronized (BinderClientTransport.this) {
+                onConnectedServiceInfo(result);
+              }
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+              synchronized (BinderClientTransport.this) {
+                shutdownInternal(Status.fromThrowable(t), true);
+              }
+            }
+          },
+          offloadExecutor);
+    }
+
+    @GuardedBy("BinderClientTransport.this")
+    private void onConnectedServiceInfo(ServiceInfo serviceInfo) {
+      if (!inState(TransportState.SETUP)) {
+        return;
+      }
+      attributes = setSecurityAttrs(attributes, serviceInfo.applicationInfo.uid);
+      checkServerAuthorization(serviceInfo.applicationInfo.uid);
+    }
+
+    @Override
+    @GuardedBy("BinderClientTransport.this")
+    public void onServerAuthorizationOk() {
+      sendSetupTransaction(endpointBinder);
+    }
+
+    @Override
+    @GuardedBy("BinderClientTransport.this") // By way of @GuardedBy("this") `handshake` member.
+    public void handleSetupTransport() {
+      onHandshakeComplete();
+    }
+  }
+
+  @GuardedBy("this")
+  private void onHandshakeComplete() {
+    setState(TransportState.READY);
+    attributes = clientTransportListener.filterTransport(attributes);
+    clientTransportListener.transportReady();
+    if (readyTimeoutFuture != null) {
+      readyTimeoutFuture.cancel(false);
+      readyTimeoutFuture = null;
+    }
+  }
+
+  private synchronized void handleAuthResult(Throwable t) {
+    shutdownInternal(
+        Status.INTERNAL.withDescription("Could not evaluate SecurityPolicy").withCause(t), true);
+  }
+
+  @GuardedBy("this")
+  @Override
+  protected void handlePingResponse(Parcel parcel) {
+    pingTracker.onPingResponse(parcel.readInt());
+  }
+
+  /**
+   * An abstract implementation of the client's connection handshake.
+   *
+   * <p>Supports a clean migration away from the legacy approach, one client at a time.
+   */
+  private interface ClientHandshake {
+    /**
+     * Notifies the implementation that the binding has succeeded and we are now connected to the
+     * server's "endpoint" which can be reached at 'endpointBinder'.
+     */
+    @MainThread
+    void onBound(OneWayBinderProxy endpointBinder);
+
+    /** Notifies the implementation that we've received a valid SETUP_TRANSPORT transaction. */
+    @BinderThread
+    void handleSetupTransport();
+
+    /** Notifies the implementation that the SecurityPolicy check of the server succeeded. */
+    void onServerAuthorizationOk();
+  }
+
+  private final class LegacyClientHandshake implements ClientHandshake {
+    @Override
+    @MainThread
+    @GuardedBy("BinderClientTransport.this") // By way of @GuardedBy("this") `handshake` member.
+    public void onBound(OneWayBinderProxy binder) {
+      sendSetupTransaction(binder);
+    }
+
+    @Override
+    @BinderThread
+    @GuardedBy("BinderClientTransport.this") // By way of @GuardedBy("this") `handshake` member.
+    public void handleSetupTransport() {
+      int remoteUid = Binder.getCallingUid();
+      restrictIncomingBinderToCallsFrom(remoteUid);
+      attributes = setSecurityAttrs(attributes, remoteUid);
+      checkServerAuthorization(remoteUid);
+    }
+
+    @Override
+    @GuardedBy("BinderClientTransport.this") // By way of @GuardedBy("this") `handshake` member.
+    public void onServerAuthorizationOk() {
+      onHandshakeComplete();
+    }
+  }
+
+  private static ClientStream newFailingClientStream(
+      Status failure, Attributes attributes, Metadata headers, ClientStreamTracer[] tracers) {
+    StatsTraceContext statsTraceContext =
+        StatsTraceContext.newClientContext(tracers, attributes, headers);
+    statsTraceContext.clientOutboundHeaders();
+    return new FailingClientStream(failure, tracers);
+  }
+
+  private static InternalLogId buildLogId(
+      Context sourceContext, AndroidComponentAddress targetAddress) {
+    return InternalLogId.allocate(
+        BinderClientTransport.class,
+        sourceContext.getClass().getSimpleName() + "->" + targetAddress);
+  }
+
+  private static Attributes buildClientAttributes(
+      Attributes eagAttrs,
+      Context sourceContext,
+      AndroidComponentAddress targetAddress,
+      InboundParcelablePolicy inboundParcelablePolicy) {
+    return Attributes.newBuilder()
+        .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.NONE) // Trust noone for now.
+        .set(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS, eagAttrs)
+        .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, AndroidComponentAddress.forContext(sourceContext))
+        .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, targetAddress)
+        .set(INBOUND_PARCELABLE_POLICY, inboundParcelablePolicy)
+        .build();
+  }
+
+  private static Attributes setSecurityAttrs(Attributes attributes, int uid) {
+    return attributes.toBuilder()
+        .set(REMOTE_UID, uid)
+        .set(
+            GrpcAttributes.ATTR_SECURITY_LEVEL,
+            uid == Process.myUid()
+                ? SecurityLevel.PRIVACY_AND_INTEGRITY
+                : SecurityLevel.INTEGRITY) // TODO: Have the SecrityPolicy decide this.
+        .build();
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/BinderClientTransportFactory.java b/binder/src/main/java/io/grpc/binder/internal/BinderClientTransportFactory.java
new file mode 100644
index 00000000000..459e064ad9b
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/BinderClientTransportFactory.java
@@ -0,0 +1,232 @@
+/*
+ * Copyright 2024 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.base.Preconditions.checkNotNull;
+
+import android.content.Context;
+import androidx.core.content.ContextCompat;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.Internal;
+import io.grpc.binder.AndroidComponentAddress;
+import io.grpc.binder.BindServiceFlags;
+import io.grpc.binder.BinderChannelCredentials;
+import io.grpc.binder.InboundParcelablePolicy;
+import io.grpc.binder.SecurityPolicies;
+import io.grpc.binder.SecurityPolicy;
+import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.ManagedChannelImplBuilder.ClientTransportFactoryBuilder;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourcePool;
+import java.net.SocketAddress;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+
+/** Creates new binder transports. */
+@Internal
+public final class BinderClientTransportFactory implements ClientTransportFactory {
+  final Context sourceContext;
+  final BinderChannelCredentials channelCredentials;
+  final Executor mainThreadExecutor;
+  final ObjectPool<ScheduledExecutorService> scheduledExecutorPool;
+  final ObjectPool<? extends Executor> offloadExecutorPool;
+  final SecurityPolicy securityPolicy;
+  final BindServiceFlags bindServiceFlags;
+  final InboundParcelablePolicy inboundParcelablePolicy;
+  final OneWayBinderProxy.Decorator binderDecorator;
+  final long readyTimeoutMillis;
+  final boolean preAuthorizeServers; // TODO(jdcormie): Default to true.
+  final boolean useLegacyAuthStrategy;
+
+  ScheduledExecutorService executorService;
+  Executor offloadExecutor;
+  private boolean closed;
+
+  private BinderClientTransportFactory(Builder builder) {
+    sourceContext = checkNotNull(builder.sourceContext);
+    channelCredentials = checkNotNull(builder.channelCredentials);
+    mainThreadExecutor =
+        builder.mainThreadExecutor != null
+            ? builder.mainThreadExecutor
+            : ContextCompat.getMainExecutor(sourceContext);
+    scheduledExecutorPool = checkNotNull(builder.scheduledExecutorPool);
+    offloadExecutorPool = checkNotNull(builder.offloadExecutorPool);
+    securityPolicy = checkNotNull(builder.securityPolicy);
+    bindServiceFlags = checkNotNull(builder.bindServiceFlags);
+    inboundParcelablePolicy = checkNotNull(builder.inboundParcelablePolicy);
+    binderDecorator = checkNotNull(builder.binderDecorator);
+    readyTimeoutMillis = builder.readyTimeoutMillis;
+    preAuthorizeServers = builder.preAuthorizeServers;
+    useLegacyAuthStrategy = builder.useLegacyAuthStrategy;
+
+    executorService = scheduledExecutorPool.getObject();
+    offloadExecutor = offloadExecutorPool.getObject();
+  }
+
+  @Override
+  public BinderClientTransport newClientTransport(
+      SocketAddress addr, ClientTransportOptions options, ChannelLogger channelLogger) {
+    if (closed) {
+      throw new IllegalStateException("The transport factory is closed.");
+    }
+    return new BinderClientTransport(this, (AndroidComponentAddress) addr, options);
+  }
+
+  @Override
+  public ScheduledExecutorService getScheduledExecutorService() {
+    return executorService;
+  }
+
+  @Override
+  public SwapChannelCredentialsResult swapChannelCredentials(ChannelCredentials channelCreds) {
+    return null;
+  }
+
+  @Override
+  public void close() {
+    closed = true;
+    executorService = scheduledExecutorPool.returnObject(executorService);
+    offloadExecutor = offloadExecutorPool.returnObject(offloadExecutor);
+  }
+
+  @Override
+  public Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+    return Collections.singleton(AndroidComponentAddress.class);
+  }
+
+  /** Allows fluent construction of ClientTransportFactory. */
+  public static final class Builder implements ClientTransportFactoryBuilder {
+    // Required.
+    Context sourceContext;
+    ObjectPool<? extends Executor> offloadExecutorPool;
+
+    // Optional.
+    BinderChannelCredentials channelCredentials = BinderChannelCredentials.forDefault();
+    Executor mainThreadExecutor; // Default filled-in at build time once sourceContext is decided.
+    ObjectPool<ScheduledExecutorService> scheduledExecutorPool =
+        SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE);
+    SecurityPolicy securityPolicy = SecurityPolicies.internalOnly();
+    BindServiceFlags bindServiceFlags = BindServiceFlags.DEFAULTS;
+    InboundParcelablePolicy inboundParcelablePolicy = InboundParcelablePolicy.DEFAULT;
+    OneWayBinderProxy.Decorator binderDecorator = OneWayBinderProxy.IDENTITY_DECORATOR;
+    long readyTimeoutMillis = 60_000;
+    boolean preAuthorizeServers;
+    boolean useLegacyAuthStrategy = true; // TODO(jdcormie): Default to false.
+
+    @Override
+    public BinderClientTransportFactory buildClientTransportFactory() {
+      return new BinderClientTransportFactory(this);
+    }
+
+    public Builder setSourceContext(Context sourceContext) {
+      this.sourceContext = checkNotNull(sourceContext);
+      return this;
+    }
+
+    public Context getSourceContext() {
+      return sourceContext;
+    }
+
+    public Builder setOffloadExecutorPool(ObjectPool<? extends Executor> offloadExecutorPool) {
+      this.offloadExecutorPool = checkNotNull(offloadExecutorPool, "offloadExecutorPool");
+      return this;
+    }
+
+    public Builder setChannelCredentials(BinderChannelCredentials channelCredentials) {
+      this.channelCredentials = checkNotNull(channelCredentials, "channelCredentials");
+      return this;
+    }
+
+    public Builder setMainThreadExecutor(Executor mainThreadExecutor) {
+      this.mainThreadExecutor = checkNotNull(mainThreadExecutor, "mainThreadExecutor");
+      return this;
+    }
+
+    public Builder setScheduledExecutorPool(
+        ObjectPool<ScheduledExecutorService> scheduledExecutorPool) {
+      this.scheduledExecutorPool = checkNotNull(scheduledExecutorPool, "scheduledExecutorPool");
+      return this;
+    }
+
+    public Builder setSecurityPolicy(SecurityPolicy securityPolicy) {
+      this.securityPolicy = checkNotNull(securityPolicy, "securityPolicy");
+      return this;
+    }
+
+    public Builder setBindServiceFlags(BindServiceFlags bindServiceFlags) {
+      this.bindServiceFlags = checkNotNull(bindServiceFlags, "bindServiceFlags");
+      return this;
+    }
+
+    public Builder setInboundParcelablePolicy(InboundParcelablePolicy inboundParcelablePolicy) {
+      this.inboundParcelablePolicy =
+          checkNotNull(inboundParcelablePolicy, "inboundParcelablePolicy");
+      return this;
+    }
+
+    /**
+     * Decorates both the "endpoint" and "server" binders, for fault injection.
+     *
+     * <p>Optional. If absent, these objects will go undecorated.
+     */
+    public Builder setBinderDecorator(OneWayBinderProxy.Decorator binderDecorator) {
+      this.binderDecorator = checkNotNull(binderDecorator, "binderDecorator");
+      return this;
+    }
+
+    /**
+     * Limits how long it can take to for a new transport to become ready after being started.
+     *
+     * <p>This process currently includes:
+     *
+     * <ul>
+     *   <li>Creating an Android binding.
+     *   <li>Waiting for Android to create the server process.
+     *   <li>Waiting for the remote Service to be created and handle onBind().
+     *   <li>Exchanging handshake transactions according to the wire protocol.
+     *   <li>Evaluating a {@link SecurityPolicy} on both sides.
+     * </ul>
+     *
+     * <p>This setting doesn't change the need for deadlines at the call level. It merely ensures
+     * that gRPC features like <a
+     * href="https://github.com/grpc/grpc/blob/master/doc/load-balancing.md">load balancing</a> and
+     * <a href="https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md">fail-fast</a> work
+     * as expected despite certain edge cases that could otherwise stall the transport indefinitely.
+     *
+     * <p>Optional but enabled by default. Use a negative value to wait indefinitely.
+     */
+    public Builder setReadyTimeoutMillis(long readyTimeoutMillis) {
+      this.readyTimeoutMillis = readyTimeoutMillis;
+      return this;
+    }
+
+    /** Whether to check server addresses against the SecurityPolicy *before* binding to them. */
+    public Builder setPreAuthorizeServers(boolean preAuthorizeServers) {
+      this.preAuthorizeServers = preAuthorizeServers;
+      return this;
+    }
+
+    /** Specifies which version of the client handshake to use. */
+    public Builder setUseLegacyAuthStrategy(boolean useLegacyAuthStrategy) {
+      this.useLegacyAuthStrategy = useLegacyAuthStrategy;
+      return this;
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/BinderServer.java b/binder/src/main/java/io/grpc/binder/internal/BinderServer.java
new file mode 100644
index 00000000000..96685a2f8bd
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/BinderServer.java
@@ -0,0 +1,299 @@
+/*
+ * 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 android.os.IBinder.FLAG_ONEWAY;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.binder.internal.BinderTransport.SHUTDOWN_TRANSPORT;
+
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.os.RemoteException;
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.Grpc;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.ServerStreamTracer;
+import io.grpc.binder.AndroidComponentAddress;
+import io.grpc.binder.BinderInternal;
+import io.grpc.binder.InboundParcelablePolicy;
+import io.grpc.binder.SecurityPolicies;
+import io.grpc.binder.ServerSecurityPolicy;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.ServerListener;
+import io.grpc.internal.SharedResourcePool;
+import java.io.IOException;
+import java.net.SocketAddress;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A gRPC InternalServer which accepts connections via a host AndroidService.
+ *
+ * <p>Multiple incoming connections transports may be active at a time.
+ *
+ * <p><b>IMPORTANT</b>: This implementation must comply with this published wire format.
+ * https://github.com/grpc/proposal/blob/master/L73-java-binderchannel/wireformat.md
+ */
+@ThreadSafe
+public final class BinderServer implements InternalServer, LeakSafeOneWayBinder.TransactionHandler {
+  private static final Logger logger = Logger.getLogger(BinderServer.class.getName());
+
+  private final ObjectPool<ScheduledExecutorService> executorServicePool;
+  private final ObjectPool<? extends Executor> executorPool;
+  private final ImmutableList<ServerStreamTracer.Factory> streamTracerFactories;
+  private final AndroidComponentAddress listenAddress;
+  private final LeakSafeOneWayBinder hostServiceBinder;
+  private final BinderTransportSecurity.ServerPolicyChecker serverPolicyChecker;
+  private final InboundParcelablePolicy inboundParcelablePolicy;
+
+  @GuardedBy("this")
+  private ServerListener listener;
+
+  @GuardedBy("this")
+  private ScheduledExecutorService executorService;
+
+  @Nullable // Before start() and after termination.
+  @GuardedBy("this")
+  private Executor executor;
+
+  @GuardedBy("this")
+  private boolean shutdown;
+
+  private BinderServer(Builder builder) {
+    this.listenAddress = checkNotNull(builder.listenAddress);
+    this.executorPool = checkNotNull(builder.executorPool);
+    this.executorServicePool = builder.executorServicePool;
+    this.streamTracerFactories =
+        ImmutableList.copyOf(checkNotNull(builder.streamTracerFactories, "streamTracerFactories"));
+    this.serverPolicyChecker = BinderInternal.createPolicyChecker(builder.serverSecurityPolicy);
+    this.inboundParcelablePolicy = builder.inboundParcelablePolicy;
+    hostServiceBinder = new LeakSafeOneWayBinder(this);
+  }
+
+  /** Return the binder we're listening on. */
+  public IBinder getHostBinder() {
+    return hostServiceBinder;
+  }
+
+  @Override
+  public synchronized void start(ServerListener serverListener) throws IOException {
+    listener = new ActiveTransportTracker(serverListener, this::onTerminated);
+    executorService = executorServicePool.getObject();
+    executor = executorPool.getObject();
+  }
+
+  @Override
+  public SocketAddress getListenSocketAddress() {
+    return listenAddress;
+  }
+
+  @Override
+  public List<? extends SocketAddress> getListenSocketAddresses() {
+    return ImmutableList.of(listenAddress);
+  }
+
+  @Override
+  public InternalInstrumented<SocketStats> getListenSocketStats() {
+    return null;
+  }
+
+  @Override
+  @Nullable
+  public List<InternalInstrumented<SocketStats>> getListenSocketStatsList() {
+    return null;
+  }
+
+  @Override
+  public synchronized void shutdown() {
+    if (!shutdown) {
+      shutdown = true;
+      // Break the connection to the binder. We'll receive no more transactions.
+      hostServiceBinder.setHandler(GoAwayHandler.INSTANCE);
+      listener.serverShutdown();
+      // TODO(jdcormie): Shouldn't this happen in onTerminated()? Is this even used anywhere?
+      executorService = executorServicePool.returnObject(executorService);
+    }
+  }
+
+  private synchronized void onTerminated() {
+    executor = executorPool.returnObject(executor);
+  }
+
+  @Override
+  public String toString() {
+    return "BinderServer[" + listenAddress + "]";
+  }
+
+  @Override
+  public synchronized boolean handleTransaction(int code, Parcel parcel) {
+    if (code == BinderTransport.SETUP_TRANSPORT) {
+      if (shutdown) {
+        // An incoming SETUP_TRANSPORT transaction may have already been in-flight when we removed
+        // ourself as TransactionHandler in #shutdown(). So we must check for shutdown again here.
+        return GoAwayHandler.INSTANCE.handleTransaction(code, parcel);
+      }
+
+      int version = parcel.readInt();
+      // If the client-provided version is more recent, we accept the connection,
+      // but specify the older version which we support.
+      if (version >= BinderTransport.EARLIEST_SUPPORTED_WIRE_FORMAT_VERSION) {
+        IBinder callbackBinder = parcel.readStrongBinder();
+        if (callbackBinder != null) {
+          int callingUid = Binder.getCallingUid();
+          Attributes.Builder attrsBuilder =
+              Attributes.newBuilder()
+                  .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, listenAddress)
+                  .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, new BoundClientAddress(callingUid))
+                  .set(BinderTransport.REMOTE_UID, callingUid)
+                  .set(BinderTransport.SERVER_AUTHORITY, listenAddress.getAuthority())
+                  .set(BinderTransport.INBOUND_PARCELABLE_POLICY, inboundParcelablePolicy);
+          BinderTransportSecurity.attachAuthAttrs(
+              attrsBuilder,
+              callingUid,
+              serverPolicyChecker,
+              checkNotNull(executor, "Not started?"));
+          // Create a new transport and let our listener know about it.
+          BinderServerTransport transport =
+              BinderServerTransport.create(
+                  executorServicePool,
+                  attrsBuilder.build(),
+                  streamTracerFactories,
+                  OneWayBinderProxy.IDENTITY_DECORATOR,
+                  callbackBinder);
+          transport.start(listener.transportCreated(transport));
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  static final class GoAwayHandler implements LeakSafeOneWayBinder.TransactionHandler {
+    static final GoAwayHandler INSTANCE = new GoAwayHandler();
+
+    @Override
+    public boolean handleTransaction(int code, Parcel parcel) {
+      if (code == BinderTransport.SETUP_TRANSPORT) {
+        int version = parcel.readInt();
+        if (version >= BinderTransport.EARLIEST_SUPPORTED_WIRE_FORMAT_VERSION) {
+          IBinder callbackBinder = parcel.readStrongBinder();
+          try (ParcelHolder goAwayReply = ParcelHolder.obtain()) {
+            // Send empty flags to avoid a memory leak linked to empty parcels (b/207778694).
+            goAwayReply.get().writeInt(0);
+            callbackBinder.transact(SHUTDOWN_TRANSPORT, goAwayReply.get(), null, FLAG_ONEWAY);
+          } catch (RemoteException re) {
+            logger.log(Level.WARNING, "Couldn't reply to post-shutdown() SETUP_TRANSPORT.", re);
+          }
+        }
+      }
+      return false;
+    }
+  }
+
+  /** Fluent builder of {@link BinderServer} instances. */
+  public static class Builder {
+    @Nullable AndroidComponentAddress listenAddress;
+    @Nullable List<? extends ServerStreamTracer.Factory> streamTracerFactories;
+    @Nullable ObjectPool<? extends Executor> executorPool;
+
+    ObjectPool<ScheduledExecutorService> executorServicePool =
+        SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE);
+    ServerSecurityPolicy serverSecurityPolicy = SecurityPolicies.serverInternalOnly();
+    InboundParcelablePolicy inboundParcelablePolicy = InboundParcelablePolicy.DEFAULT;
+
+    public BinderServer build() {
+      return new BinderServer(this);
+    }
+
+    /**
+     * Sets the "listen" address for this server.
+     *
+     * <p>This is somewhat of a grpc-java formality. Binder servers don't really listen, rather,
+     * Android creates and destroys them according to client needs.
+     *
+     * <p>Required.
+     */
+    public Builder setListenAddress(AndroidComponentAddress listenAddress) {
+      this.listenAddress = listenAddress;
+      return this;
+    }
+
+    /**
+     * Sets the source for {@link ServerStreamTracer}s that will be installed on all new streams.
+     *
+     * <p>Required.
+     */
+    public Builder setStreamTracerFactories(
+        List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+      this.streamTracerFactories = streamTracerFactories;
+      return this;
+    }
+
+    /**
+     * Sets the executor to be used for calling into the application.
+     *
+     * <p>Required.
+     */
+    public Builder setExecutorPool(ObjectPool<? extends Executor> executorPool) {
+      this.executorPool = executorPool;
+      return this;
+    }
+
+    /**
+     * Sets the executor to be used for scheduling channel timers.
+     *
+     * <p>Optional. A process-wide default executor will be used if unset.
+     */
+    public Builder setExecutorServicePool(
+        ObjectPool<ScheduledExecutorService> executorServicePool) {
+      this.executorServicePool = checkNotNull(executorServicePool, "executorServicePool");
+      return this;
+    }
+
+    /**
+     * Sets the {@link ServerSecurityPolicy} to be used for built servers.
+     *
+     * <p>Optional, {@link SecurityPolicies#serverInternalOnly()} is the default.
+     */
+    public Builder setServerSecurityPolicy(ServerSecurityPolicy serverSecurityPolicy) {
+      this.serverSecurityPolicy = checkNotNull(serverSecurityPolicy, "serverSecurityPolicy");
+      return this;
+    }
+
+    /**
+     * Sets the {@link InboundParcelablePolicy} to be used for built servers.
+     *
+     * <p>Optional, {@link InboundParcelablePolicy#DEFAULT} is the default.
+     */
+    public Builder setInboundParcelablePolicy(InboundParcelablePolicy inboundParcelablePolicy) {
+      this.inboundParcelablePolicy =
+          checkNotNull(inboundParcelablePolicy, "inboundParcelablePolicy");
+      return this;
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/BinderServerTransport.java b/binder/src/main/java/io/grpc/binder/internal/BinderServerTransport.java
new file mode 100644
index 00000000000..b8ab5e9f843
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/BinderServerTransport.java
@@ -0,0 +1,157 @@
+/*
+ * 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.IBinder;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.Grpc;
+import io.grpc.Internal;
+import io.grpc.InternalLogId;
+import io.grpc.Metadata;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.ServerStream;
+import io.grpc.internal.ServerTransport;
+import io.grpc.internal.ServerTransportListener;
+import io.grpc.internal.StatsTraceContext;
+import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
+import javax.annotation.Nullable;
+
+/** Concrete server-side transport implementation. */
+@Internal
+public final class BinderServerTransport extends BinderTransport implements ServerTransport {
+
+  private final List<ServerStreamTracer.Factory> streamTracerFactories;
+
+  @GuardedBy("this")
+  private final SimplePromise<ServerTransportListener> listenerPromise = new SimplePromise<>();
+
+  private BinderServerTransport(
+      ObjectPool<ScheduledExecutorService> executorServicePool,
+      Attributes attributes,
+      List<ServerStreamTracer.Factory> streamTracerFactories,
+      OneWayBinderProxy.Decorator binderDecorator) {
+    super(executorServicePool, attributes, binderDecorator, buildLogId(attributes));
+    this.streamTracerFactories = streamTracerFactories;
+  }
+
+  /**
+   * Constructs a new transport instance.
+   *
+   * @param binderDecorator used to decorate 'callbackBinder', for fault injection.
+   */
+  public static BinderServerTransport create(
+      ObjectPool<ScheduledExecutorService> executorServicePool,
+      Attributes attributes,
+      List<ServerStreamTracer.Factory> streamTracerFactories,
+      OneWayBinderProxy.Decorator binderDecorator,
+      IBinder callbackBinder) {
+    BinderServerTransport transport =
+        new BinderServerTransport(
+            executorServicePool, attributes, streamTracerFactories, binderDecorator);
+    // TODO(jdcormie): Plumb in the Server's executor() and use it here instead.
+    // No need to handle failure here because if 'callbackBinder' is already dead, we'll notice it
+    // again in start() when we send the first transaction.
+    synchronized (transport) {
+      transport.setOutgoingBinder(
+          OneWayBinderProxy.wrap(callbackBinder, transport.getScheduledExecutorService()));
+    }
+    return transport;
+  }
+
+  /**
+   * Initializes this transport instance.
+   *
+   * <p>Must be called exactly once, even if {@link #shutdown} or {@link #shutdownNow} was called
+   * first.
+   *
+   * @param serverTransportListener where this transport will report events
+   */
+  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;
+    }
+
+    sendSetupTransaction();
+
+    // Check we're not shutdown again, since a failure inside sendSetupTransaction (or a callback
+    // it triggers), could have shut us down.
+    if (isShutdown()) {
+      return;
+    }
+
+    setState(TransportState.READY);
+    attributes = serverTransportListener.transportReady(attributes);
+  }
+
+  StatsTraceContext createStatsTraceContext(String methodName, Metadata headers) {
+    return StatsTraceContext.newServerContext(streamTracerFactories, methodName, headers);
+  }
+
+  /**
+   * Reports a new ServerStream requested by the remote client.
+   *
+   * <p>Precondition: {@link #start(ServerTransportListener)} must already have been called.
+   */
+  synchronized Status startStream(ServerStream stream, String methodName, Metadata headers) {
+    if (isShutdown()) {
+      return Status.UNAVAILABLE.withDescription("transport is shutdown");
+    }
+
+    listenerPromise.get().streamCreated(stream, methodName, headers);
+    return Status.OK;
+  }
+
+  @Override
+  @GuardedBy("this")
+  void notifyShutdown(Status status) {
+    // Nothing to do.
+  }
+
+  @Override
+  @GuardedBy("this")
+  void notifyTerminated() {
+    listenerPromise.runWhenSet(ServerTransportListener::transportTerminated);
+  }
+
+  @Override
+  public synchronized void shutdown() {
+    shutdownInternal(Status.OK, false);
+  }
+
+  @Override
+  public synchronized void shutdownNow(Status reason) {
+    shutdownInternal(reason, true);
+  }
+
+  @Override
+  @Nullable
+  @GuardedBy("this")
+  protected Inbound<?> createInbound(int callId) {
+    return new Inbound.ServerInbound(this, attributes, callId);
+  }
+
+  private static InternalLogId buildLogId(Attributes attributes) {
+    return InternalLogId.allocate(
+        BinderServerTransport.class, "from " + attributes.get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR));
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/BinderTransport.java b/binder/src/main/java/io/grpc/binder/internal/BinderTransport.java
new file mode 100644
index 00000000000..1592f6977df
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/BinderTransport.java
@@ -0,0 +1,618 @@
+/*
+ * 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.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.util.concurrent.Futures.immediateFuture;
+import static io.grpc.binder.internal.TransactionUtils.newCallerFilteringHandler;
+
+import android.os.DeadObjectException;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.os.RemoteException;
+import android.os.TransactionTooLargeException;
+import androidx.annotation.BinderThread;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Verify;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.Grpc;
+import io.grpc.Internal;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalLogId;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.binder.InboundParcelablePolicy;
+import io.grpc.binder.internal.LeakSafeOneWayBinder.TransactionHandler;
+import io.grpc.internal.ObjectPool;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Base class for binder-based gRPC transport.
+ *
+ * <p>This is used on both the client and service sides of the transport.
+ *
+ * <p>A note on synchronization. The nature of this class's interaction with each stream
+ * (bi-directional communication between gRPC calls and binder transactions) means that acquiring
+ * multiple locks in two different orders can happen easily. E.g. binder transactions will arrive in
+ * this class, and need to passed to a stream instance, whereas gRPC calls on a stream instance will
+ * need to call into this class to send a transaction (possibly waiting for the transport to become
+ * ready).
+ *
+ * <p>The split between Outbound &amp; Inbound helps reduce this risk, but not entirely remove it.
+ *
+ * <p>For this reason, while most state within this class is guarded by this instance, methods
+ * exposed to individual stream instances need to use atomic or volatile types, since those calls
+ * will already be synchronized on the individual RPC objects.
+ *
+ * <p><b>IMPORTANT</b>: This implementation must comply with this published wire format.
+ * https://github.com/grpc/proposal/blob/master/L73-java-binderchannel/wireformat.md
+ */
+@ThreadSafe
+public abstract class BinderTransport implements IBinder.DeathRecipient {
+
+  private static final Logger logger = Logger.getLogger(BinderTransport.class.getName());
+
+  /**
+   * Attribute used to store the Android UID of the remote app. This is guaranteed to be set on any
+   * active transport.
+   */
+  @Internal
+  public static final Attributes.Key<Integer> REMOTE_UID =
+      Attributes.Key.create("internal:remote-uid");
+
+  /** The authority of the server. */
+  @Internal
+  public static final Attributes.Key<String> SERVER_AUTHORITY =
+      Attributes.Key.create("internal:server-authority");
+
+  /** A transport attribute to hold the {@link InboundParcelablePolicy}. */
+  @Internal
+  public static final Attributes.Key<InboundParcelablePolicy> INBOUND_PARCELABLE_POLICY =
+      Attributes.Key.create("internal:inbound-parcelable-policy");
+
+  /**
+   * Version code for this wire format.
+   *
+   * <p>Should this change, we should still endeavor to support earlier wire-format versions. If
+   * that's not possible, {@link EARLIEST_SUPPORTED_WIRE_FORMAT_VERSION} should be updated below.
+   */
+  @Internal public static final int WIRE_FORMAT_VERSION = 1;
+
+  /** The version code of the earliest wire format we support. */
+  @Internal public static final int EARLIEST_SUPPORTED_WIRE_FORMAT_VERSION = 1;
+
+  /** The max number of "in-flight" bytes before we start buffering transactions. */
+  private static final int TRANSACTION_BYTES_WINDOW = 128 * 1024;
+
+  /** The number of in-flight bytes we should receive between sendings acks to our peer. */
+  private static final int TRANSACTION_BYTES_WINDOW_FORCE_ACK = 16 * 1024;
+
+  /**
+   * Sent from the client to host service binder to initiate a new transport, and from the host to
+   * the binder. and from the host s Followed by: int wire_protocol_version IBinder
+   * client_transports_callback_binder
+   */
+  @Internal public static final int SETUP_TRANSPORT = IBinder.FIRST_CALL_TRANSACTION;
+
+  /** Send to shutdown the transport from either end. */
+  @Internal public static final int SHUTDOWN_TRANSPORT = IBinder.FIRST_CALL_TRANSACTION + 1;
+
+  /** Send to acknowledge receipt of rpc bytes, for flow control. */
+  static final int ACKNOWLEDGE_BYTES = IBinder.FIRST_CALL_TRANSACTION + 2;
+
+  /** A ping request. */
+  private static final int PING = IBinder.FIRST_CALL_TRANSACTION + 3;
+
+  /** A response to a ping. */
+  private static final int PING_RESPONSE = IBinder.FIRST_CALL_TRANSACTION + 4;
+
+  /** Reserved transaction IDs for any special events we might need. */
+  private static final int RESERVED_TRANSACTIONS = 1000;
+
+  /** The first call ID we can use. */
+  static final int FIRST_CALL_ID = IBinder.FIRST_CALL_TRANSACTION + RESERVED_TRANSACTIONS;
+
+  /** The last call ID we can use. */
+  static final int LAST_CALL_ID = IBinder.LAST_CALL_TRANSACTION;
+
+  /** The states of this transport. */
+  protected enum TransportState {
+    NOT_STARTED, // We haven't been started yet.
+    SETUP, // We're setting up the connection.
+    READY, // The transport is ready.
+    SHUTDOWN, // We've been shutdown and won't accept any additional calls (thought existing calls
+    // may continue).
+    SHUTDOWN_TERMINATED // We've been shutdown completely (or we failed to start). We can't send or
+    // receive any data.
+  }
+
+  private final ObjectPool<ScheduledExecutorService> executorServicePool;
+  private final ScheduledExecutorService scheduledExecutorService;
+  private final InternalLogId logId;
+
+  @GuardedBy("this")
+  private final LeakSafeOneWayBinder incomingBinder;
+
+  protected final ConcurrentHashMap<Integer, Inbound<?>> ongoingCalls;
+  protected final OneWayBinderProxy.Decorator binderDecorator;
+
+  @GuardedBy("this")
+  private final LinkedHashSet<Integer> callIdsToNotifyWhenReady = new LinkedHashSet<>();
+
+  @GuardedBy("this")
+  private final List<Future<?>> ownedFutures = new ArrayList<>(); // To cancel upon terminate.
+
+  @GuardedBy("this")
+  protected Attributes attributes;
+
+  @GuardedBy("this")
+  private TransportState transportState = TransportState.NOT_STARTED;
+
+  @GuardedBy("this")
+  @Nullable
+  protected Status shutdownStatus;
+
+  @Nullable private OneWayBinderProxy outgoingBinder;
+
+  private final FlowController flowController;
+
+  /** The number of incoming bytes we've received. */
+  // Only read/written on @BinderThread.
+  private long numIncomingBytes;
+
+  /** The number of incoming bytes we've told our peer we've received. */
+  // Only read/written on @BinderThread.
+  private long acknowledgedIncomingBytes;
+
+  protected BinderTransport(
+      ObjectPool<ScheduledExecutorService> executorServicePool,
+      Attributes attributes,
+      OneWayBinderProxy.Decorator binderDecorator,
+      InternalLogId logId) {
+    this.binderDecorator = binderDecorator;
+    this.executorServicePool = executorServicePool;
+    this.attributes = attributes;
+    this.logId = logId;
+    scheduledExecutorService = executorServicePool.getObject();
+    incomingBinder = new LeakSafeOneWayBinder(this::handleTransaction);
+    ongoingCalls = new ConcurrentHashMap<>();
+    flowController = new FlowController(TRANSACTION_BYTES_WINDOW);
+  }
+
+  // Override in child class.
+  public final ScheduledExecutorService getScheduledExecutorService() {
+    return scheduledExecutorService;
+  }
+
+  // Override in child class.
+  public final ListenableFuture<SocketStats> getStats() {
+    Attributes attributes = getAttributes();
+    return immediateFuture(
+        new InternalChannelz.SocketStats(
+            /* data= */ null, // TODO: Keep track of these stats with TransportTracer or similar.
+            /* local= */ attributes.get(Grpc.TRANSPORT_ATTR_LOCAL_ADDR),
+            /* remote= */ attributes.get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR),
+            // TODO: SocketOptions are meaningless for binder but we're still forced to provide one.
+            new InternalChannelz.SocketOptions.Builder().build(),
+            /* security= */ null));
+  }
+
+  // Override in child class.
+  public final InternalLogId getLogId() {
+    return logId;
+  }
+
+  // Override in child class.
+  public final synchronized Attributes getAttributes() {
+    return attributes;
+  }
+
+  /**
+   * Returns whether this transport is able to send rpc transactions. Intentionally unsynchronized
+   * since this will be called while Outbound is held.
+   */
+  final boolean isReady() {
+    return !flowController.isTransmitWindowFull();
+  }
+
+  @GuardedBy("this")
+  abstract void notifyShutdown(Status shutdownStatus);
+
+  @GuardedBy("this")
+  abstract void notifyTerminated();
+
+  void releaseExecutors() {
+    executorServicePool.returnObject(scheduledExecutorService);
+  }
+
+  // Registers the specified future for eventual safe cancellation upon shutdown/terminate.
+  @GuardedBy("this")
+  protected final <T extends Future<?>> T register(T future) {
+    ownedFutures.add(future);
+    return future;
+  }
+
+  @GuardedBy("this")
+  boolean inState(TransportState transportState) {
+    return this.transportState == transportState;
+  }
+
+  @GuardedBy("this")
+  boolean isShutdown() {
+    return inState(TransportState.SHUTDOWN) || inState(TransportState.SHUTDOWN_TERMINATED);
+  }
+
+  @GuardedBy("this")
+  final void setState(TransportState newState) {
+    checkTransition(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 but not from a constructor.
+   *
+   * <p>Returns true for success, false if the process hosting 'binder' is already dead. Callers are
+   * responsible for handling this.
+   */
+  @GuardedBy("this")
+  protected boolean setOutgoingBinder(OneWayBinderProxy binder) {
+    binder = binderDecorator.decorate(binder);
+    this.outgoingBinder = binder;
+    try {
+      binder.getDelegate().linkToDeath(this, 0);
+      return true;
+    } catch (RemoteException re) {
+      return false;
+    }
+  }
+
+  @Override
+  public synchronized void binderDied() {
+    shutdownInternal(
+        Status.UNAVAILABLE.withDescription(
+            "Peer process crashed, exited or was killed (binderDied)"),
+        true);
+  }
+
+  @GuardedBy("this")
+  final void shutdownInternal(Status shutdownStatus, boolean forceTerminate) {
+    if (!isShutdown()) {
+      this.shutdownStatus = shutdownStatus;
+      setState(TransportState.SHUTDOWN);
+      notifyShutdown(shutdownStatus);
+    }
+    if (!inState(TransportState.SHUTDOWN_TERMINATED)
+        && (forceTerminate || ongoingCalls.isEmpty())) {
+      incomingBinder.detach();
+      setState(TransportState.SHUTDOWN_TERMINATED);
+      sendShutdownTransaction();
+      ArrayList<Inbound<?>> calls = new ArrayList<>(ongoingCalls.values());
+      ongoingCalls.clear();
+      ArrayList<Future<?>> futuresToCancel = new ArrayList<>(ownedFutures);
+      ownedFutures.clear();
+      scheduledExecutorService.execute(
+          () -> {
+            for (Inbound<?> inbound : calls) {
+              synchronized (inbound) {
+                inbound.closeAbnormal(shutdownStatus);
+              }
+            }
+
+            for (Future<?> future : futuresToCancel) {
+              // Not holding any locks here just in case some listener runs on a direct Executor.
+              future.cancel(false); // No effect if already isDone().
+            }
+
+            synchronized (this) {
+              notifyTerminated();
+            }
+            releaseExecutors();
+          });
+    }
+  }
+
+  @GuardedBy("this")
+  final void sendSetupTransaction() {
+    sendSetupTransaction(checkNotNull(outgoingBinder));
+  }
+
+  @GuardedBy("this")
+  final void sendSetupTransaction(OneWayBinderProxy iBinder) {
+    try (ParcelHolder parcel = ParcelHolder.obtain()) {
+      parcel.get().writeInt(WIRE_FORMAT_VERSION);
+      parcel.get().writeStrongBinder(incomingBinder);
+      iBinder.transact(SETUP_TRANSPORT, parcel);
+    } catch (RemoteException re) {
+      shutdownInternal(statusFromRemoteException(re), true);
+    }
+  }
+
+  @GuardedBy("this")
+  private final void sendShutdownTransaction() {
+    if (outgoingBinder != null) {
+      try {
+        outgoingBinder.getDelegate().unlinkToDeath(this, 0);
+      } catch (NoSuchElementException e) {
+        // Ignore.
+      }
+      try (ParcelHolder parcel = ParcelHolder.obtain()) {
+        // Send empty flags to avoid a memory leak linked to empty parcels (b/207778694).
+        parcel.get().writeInt(0);
+        outgoingBinder.transact(SHUTDOWN_TRANSPORT, parcel);
+      } catch (RemoteException re) {
+        // Ignore.
+      }
+    }
+  }
+
+  protected synchronized void sendPing(int id) throws StatusException {
+    if (inState(TransportState.SHUTDOWN_TERMINATED)) {
+      throw shutdownStatus.asException();
+    } else if (outgoingBinder == null) {
+      throw Status.FAILED_PRECONDITION.withDescription("Transport not ready.").asException();
+    } else {
+      try (ParcelHolder parcel = ParcelHolder.obtain()) {
+        parcel.get().writeInt(id);
+        outgoingBinder.transact(PING, parcel);
+      } catch (RemoteException re) {
+        throw statusFromRemoteException(re).asException();
+      }
+    }
+  }
+
+  protected void unregisterInbound(Inbound<?> inbound) {
+    unregisterCall(inbound.callId);
+  }
+
+  final void unregisterCall(int callId) {
+    boolean removed = (ongoingCalls.remove(callId) != null);
+    if (removed && ongoingCalls.isEmpty()) {
+      // Possibly shutdown (not synchronously, since inbound is held).
+      scheduledExecutorService.execute(
+          () -> {
+            synchronized (this) {
+              if (inState(TransportState.SHUTDOWN)) {
+                // No more ongoing calls, and we're shutdown. Finish the shutdown.
+                shutdownInternal(shutdownStatus, true);
+              }
+            }
+          });
+    }
+  }
+
+  final void sendTransaction(int callId, ParcelHolder parcel) throws StatusException {
+    int dataSize = parcel.get().dataSize();
+    try {
+      outgoingBinder.transact(callId, parcel);
+    } catch (RemoteException re) {
+      throw statusFromRemoteException(re).asException();
+    }
+    if (flowController.notifyBytesSent(dataSize)) {
+      logger.log(Level.FINE, "transmit window now full " + this);
+    }
+  }
+
+  final void sendOutOfBandClose(int callId, Status status) {
+    try (ParcelHolder parcel = ParcelHolder.obtain()) {
+      parcel.get().writeInt(0); // Placeholder for flags. Will be filled in below.
+      int flags = TransactionUtils.writeStatus(parcel.get(), status);
+      TransactionUtils.fillInFlags(parcel.get(), flags | TransactionUtils.FLAG_OUT_OF_BAND_CLOSE);
+      sendTransaction(callId, parcel);
+    } catch (StatusException e) {
+      logger.log(Level.FINER, "Failed sending oob close transaction", e);
+    }
+  }
+
+  @BinderThread
+  @VisibleForTesting
+  final boolean handleTransaction(int code, Parcel parcel) {
+    try {
+      return handleTransactionInternal(code, parcel);
+    } catch (RuntimeException e) {
+      logger.log(
+          Level.SEVERE, "Terminating transport for uncaught Exception in transaction " + code, e);
+      synchronized (this) {
+        // This unhandled exception may have put us in an inconsistent state. Force terminate the
+        // whole transport so our peer knows something is wrong and so that clients can retry with
+        // a fresh transport instance on both sides.
+        shutdownInternal(Status.INTERNAL.withCause(e), true);
+        return false;
+      }
+    }
+  }
+
+  @BinderThread
+  private boolean handleTransactionInternal(int code, Parcel parcel) {
+    if (code < FIRST_CALL_ID) {
+      synchronized (this) {
+        switch (code) {
+          case ACKNOWLEDGE_BYTES:
+            handleAcknowledgedBytes(parcel.readLong());
+            break;
+          case SHUTDOWN_TRANSPORT:
+            shutdownInternal(
+                Status.UNAVAILABLE.withDescription("transport shutdown by peer"), true);
+            break;
+          case SETUP_TRANSPORT:
+            handleSetupTransport(parcel);
+            break;
+          case PING:
+            handlePing(parcel);
+            break;
+          case PING_RESPONSE:
+            handlePingResponse(parcel);
+            break;
+          default:
+            return false;
+        }
+        return true;
+      }
+    } else {
+      int size = parcel.dataSize();
+      Inbound<?> inbound = ongoingCalls.get(code);
+      if (inbound == null) {
+        synchronized (this) {
+          if (!isShutdown()) {
+            inbound = createInbound(code);
+            if (inbound != null) {
+              Inbound<?> existing = ongoingCalls.put(code, inbound);
+              // Can't happen as only one invocation of handleTransaction() is running at a time.
+              Verify.verify(existing == null, "impossible appearance of %s", existing);
+            }
+          }
+        }
+      }
+      if (inbound != null) {
+        inbound.handleTransaction(parcel);
+      }
+      numIncomingBytes += size;
+      if ((numIncomingBytes - acknowledgedIncomingBytes) > TRANSACTION_BYTES_WINDOW_FORCE_ACK) {
+        synchronized (this) {
+          sendAcknowledgeBytes(checkNotNull(outgoingBinder), numIncomingBytes);
+        }
+        acknowledgedIncomingBytes = numIncomingBytes;
+      }
+      return true;
+    }
+  }
+
+  @BinderThread
+  @GuardedBy("this")
+  protected void restrictIncomingBinderToCallsFrom(int allowedCallingUid) {
+    TransactionHandler currentHandler = incomingBinder.getHandler();
+    if (currentHandler != null) {
+      incomingBinder.setHandler(newCallerFilteringHandler(allowedCallingUid, currentHandler));
+    }
+  }
+
+  @Nullable
+  @GuardedBy("this")
+  protected Inbound<?> createInbound(int callId) {
+    return null;
+  }
+
+  @GuardedBy("this")
+  protected void handleSetupTransport(Parcel parcel) {}
+
+  @GuardedBy("this")
+  private final void handlePing(Parcel requestParcel) {
+    int id = requestParcel.readInt();
+    if (transportState == TransportState.READY) {
+      try (ParcelHolder replyParcel = ParcelHolder.obtain()) {
+        replyParcel.get().writeInt(id);
+        outgoingBinder.transact(PING_RESPONSE, replyParcel);
+      } catch (RemoteException re) {
+        // Ignore.
+      }
+    }
+  }
+
+  @GuardedBy("this")
+  protected void handlePingResponse(Parcel parcel) {}
+
+  @GuardedBy("this")
+  private void sendAcknowledgeBytes(OneWayBinderProxy iBinder, long n) {
+    // Send a transaction to acknowledge reception of incoming data.
+    try (ParcelHolder parcel = ParcelHolder.obtain()) {
+      parcel.get().writeLong(n);
+      iBinder.transact(ACKNOWLEDGE_BYTES, parcel);
+    } catch (RemoteException re) {
+      shutdownInternal(statusFromRemoteException(re), true);
+    }
+  }
+
+  @GuardedBy("this")
+  final void handleAcknowledgedBytes(long numBytes) {
+    if (flowController.handleAcknowledgedBytes(numBytes)) {
+      logger.log(
+          Level.FINE,
+          "handleAcknowledgedBytes: Transmit Window No-Longer Full. Unblock calls: " + this);
+
+      // The LinkedHashSet contract guarantees that an id already present in this collection will
+      // not lose its priority if we re-insert it here.
+      callIdsToNotifyWhenReady.addAll(ongoingCalls.keySet());
+
+      Iterator<Integer> i = callIdsToNotifyWhenReady.iterator();
+      while (isReady() && i.hasNext()) {
+        Inbound<?> inbound = ongoingCalls.get(i.next());
+        i.remove();
+        if (inbound != null) { // Calls can be removed out from under us.
+          inbound.onTransportReady();
+        }
+      }
+    }
+  }
+
+  private static void checkTransition(TransportState current, TransportState next) {
+    switch (next) {
+      case SETUP:
+        checkState(current == TransportState.NOT_STARTED);
+        break;
+      case READY:
+        checkState(current == TransportState.NOT_STARTED || current == TransportState.SETUP);
+        break;
+      case SHUTDOWN:
+        checkState(
+            current == TransportState.NOT_STARTED
+                || current == TransportState.SETUP
+                || current == TransportState.READY);
+        break;
+      case SHUTDOWN_TERMINATED:
+        checkState(current == TransportState.SHUTDOWN);
+        break;
+      default:
+        throw new AssertionError();
+    }
+  }
+
+  @VisibleForTesting
+  Map<Integer, Inbound<?>> getOngoingCalls() {
+    return ongoingCalls;
+  }
+
+  @VisibleForTesting
+  synchronized LeakSafeOneWayBinder getIncomingBinderForTesting() {
+    return this.incomingBinder;
+  }
+
+  private static Status statusFromRemoteException(RemoteException e) {
+    if (e instanceof DeadObjectException || e instanceof TransactionTooLargeException) {
+      // These are to be expected from time to time and can simply be retried.
+      return Status.UNAVAILABLE.withCause(e);
+    }
+    // Otherwise, this exception from transact is unexpected.
+    return Status.INTERNAL.withCause(e);
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/BinderTransportSecurity.java b/binder/src/main/java/io/grpc/binder/internal/BinderTransportSecurity.java
new file mode 100644
index 00000000000..6f95ef8a83c
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/BinderTransportSecurity.java
@@ -0,0 +1,248 @@
+/*
+ * 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 com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.Attributes;
+import io.grpc.Internal;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.SecurityLevel;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.Status;
+import io.grpc.internal.GrpcAttributes;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import javax.annotation.Nullable;
+
+/**
+ * Manages security for an Android Service hosted gRPC server.
+ *
+ * <p>Attaches authorization state to a newly-created transport, and contains a ServerInterceptor
+ * which ensures calls are authorized before allowing them to proceed.
+ */
+public final class BinderTransportSecurity {
+
+  private static final Attributes.Key<TransportAuthorizationState> TRANSPORT_AUTHORIZATION_STATE =
+      Attributes.Key.create("internal:transport-authorization-state");
+
+  private BinderTransportSecurity() {}
+
+  /**
+   * Install a security policy on an about-to-be created server.
+   *
+   * @param serverBuilder The ServerBuilder being used to create the server.
+   */
+  @Internal
+  public static void installAuthInterceptor(ServerBuilder<?> serverBuilder) {
+    serverBuilder.intercept(new ServerAuthInterceptor());
+  }
+
+  /**
+   * Attach the given security policy to the transport attributes being built. Will be used by the
+   * auth interceptor to confirm accept or reject calls.
+   *
+   * @param builder The {@link Attributes.Builder} for the transport being created.
+   * @param remoteUid The remote UID of the transport.
+   * @param serverPolicyChecker The policy checker for this transport.
+   * @param executor used for calling into the application. Must outlive the transport.
+   */
+  @Internal
+  public static void attachAuthAttrs(
+      Attributes.Builder builder,
+      int remoteUid,
+      ServerPolicyChecker serverPolicyChecker,
+      Executor executor) {
+    builder
+        .set(
+            TRANSPORT_AUTHORIZATION_STATE,
+            new TransportAuthorizationState(remoteUid, serverPolicyChecker, executor))
+        .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.PRIVACY_AND_INTEGRITY);
+  }
+
+  /**
+   * Intercepts server calls and ensures they're authorized before allowing them to proceed.
+   * Authentication state is fetched from the call attributes, inherited from the transport.
+   */
+  private static final class ServerAuthInterceptor implements ServerInterceptor {
+
+    @Override
+    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+        ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+      TransportAuthorizationState transportAuthState =
+          call.getAttributes().get(TRANSPORT_AUTHORIZATION_STATE);
+      ListenableFuture<Status> authStatusFuture =
+          transportAuthState.checkAuthorization(call.getMethodDescriptor());
+
+      // Most SecurityPolicy will have synchronous implementations that provide an
+      // immediately-resolved Future. In that case, short-circuit to avoid unnecessary allocations
+      // and asynchronous code if the authorization result is already present.
+      if (!authStatusFuture.isDone()) {
+        return newServerCallListenerForPendingAuthResult(
+            authStatusFuture, transportAuthState.executor, call, headers, next);
+      }
+
+      Status authStatus;
+      try {
+        authStatus = Futures.getDone(authStatusFuture);
+      } catch (ExecutionException | CancellationException e) {
+        // Failed futures are treated as an internal error rather than a security rejection.
+        authStatus = Status.INTERNAL.withCause(e);
+        @Nullable String message = e.getMessage();
+        if (message != null) {
+          authStatus = authStatus.withDescription(message);
+        }
+      }
+
+      if (authStatus.isOk()) {
+        return next.startCall(call, headers);
+      } else {
+        call.close(authStatus, new Metadata());
+        return new ServerCall.Listener<ReqT>() {};
+      }
+    }
+
+    private <ReqT, RespT> ServerCall.Listener<ReqT> newServerCallListenerForPendingAuthResult(
+        ListenableFuture<Status> authStatusFuture,
+        Executor executor,
+        ServerCall<ReqT, RespT> call,
+        Metadata headers,
+        ServerCallHandler<ReqT, RespT> next) {
+      PendingAuthListener<ReqT, RespT> listener = new PendingAuthListener<>();
+      Futures.addCallback(
+          authStatusFuture,
+          new FutureCallback<Status>() {
+            @Override
+            public void onSuccess(Status authStatus) {
+              if (!authStatus.isOk()) {
+                call.close(authStatus, new Metadata());
+                return;
+              }
+
+              listener.startCall(call, headers, next);
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+              call.close(
+                  Status.INTERNAL.withCause(t).withDescription("Authorization future failed"),
+                  new Metadata());
+            }
+          },
+          executor);
+      return listener;
+    }
+  }
+
+  /**
+   * Maintains the authorization state for a single transport instance. This class lives for the
+   * lifetime of a single transport.
+   */
+  private static final class TransportAuthorizationState {
+    private final int uid;
+    private final ServerPolicyChecker serverPolicyChecker;
+    private final ConcurrentHashMap<String, ListenableFuture<Status>> serviceAuthorization;
+    private final Executor executor;
+
+    /**
+     * @param executor used for calling into the application. Must outlive the transport.
+     */
+    TransportAuthorizationState(
+        int uid, ServerPolicyChecker serverPolicyChecker, Executor executor) {
+      this.uid = uid;
+      this.serverPolicyChecker = serverPolicyChecker;
+      this.executor = executor;
+      serviceAuthorization = new ConcurrentHashMap<>(8);
+    }
+
+    /** Get whether we're authorized to make this call. */
+    @CheckReturnValue
+    ListenableFuture<Status> checkAuthorization(MethodDescriptor<?, ?> method) {
+      String serviceName = method.getServiceName();
+      // Only cache decisions if the method can be sampled for tracing,
+      // which is true for all generated methods. Otherwise, programmatically
+      // created methods could cause this cache to grow unbounded.
+      boolean useCache = method.isSampledToLocalTracing();
+      if (useCache) {
+        @Nullable ListenableFuture<Status> authorization = serviceAuthorization.get(serviceName);
+        if (authorization != null) {
+          // Authorization check exists and is a pending or successful future (even if for a
+          // failed authorization).
+          return authorization;
+        }
+      }
+      // Under high load, this may trigger a large number of concurrent authorization checks that
+      // perform essentially the same work and have the potential of exhausting the resources they
+      // depend on. This was a non-issue in the past with synchronous policy checks due to the
+      // fixed-size nature of the thread pool this method runs under.
+      //
+      // TODO(10669): evaluate if there should be at most a single pending authorization check per
+      //  (uid, serviceName) pair at any given time.
+      ListenableFuture<Status> authorization =
+          serverPolicyChecker.checkAuthorizationForServiceAsync(uid, serviceName);
+      if (useCache) {
+        serviceAuthorization.putIfAbsent(serviceName, authorization);
+        Futures.addCallback(
+            authorization,
+            new FutureCallback<Status>() {
+              @Override
+              public void onSuccess(Status result) {}
+
+              @Override
+              public void onFailure(Throwable t) {
+                serviceAuthorization.remove(serviceName, authorization);
+              }
+            },
+            MoreExecutors.directExecutor());
+      }
+      return authorization;
+    }
+  }
+
+  /**
+   * Decides whether a given Android UID is authorized to access some resource.
+   *
+   * <p>This class provides the asynchronous version of {@link io.grpc.binder.SecurityPolicy},
+   * allowing implementations of authorization logic that involves slow or asynchronous calls
+   * without necessarily blocking the calling thread.
+   *
+   * @see io.grpc.binder.SecurityPolicy
+   */
+  public interface ServerPolicyChecker {
+    /**
+     * Returns whether the given Android UID is authorized to access a particular service.
+     *
+     * <p>This method never throws an exception. If the execution of the security policy check
+     * fails, a failed future with such exception is returned.
+     *
+     * @param uid The Android UID to authenticate.
+     * @param serviceName The name of the gRPC service being called.
+     * @return a future with the result of the authorization check. A failed future represents a
+     *     failure to perform the authorization check, not that the access is denied.
+     */
+    ListenableFuture<Status> checkAuthorizationForServiceAsync(int uid, String serviceName);
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/BlockInputStream.java b/binder/src/main/java/io/grpc/binder/internal/BlockInputStream.java
new file mode 100644
index 00000000000..ae2a650831c
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/BlockInputStream.java
@@ -0,0 +1,155 @@
+/*
+ * 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 com.google.common.primitives.Ints;
+import io.grpc.Drainable;
+import io.grpc.KnownLength;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.NotThreadSafe;
+
+/**
+ * A simple InputStream from a 2-dimensional byte array.
+ *
+ * <p>Used to provide message data from incoming blocks of data. It is assumed that all byte arrays
+ * passed in the constructor of this this class are owned by the new instance.
+ *
+ * <p>This also assumes byte arrays are created by the BlockPool class, and should be returned to it
+ * when this class is closed.
+ */
+@NotThreadSafe
+final class BlockInputStream extends InputStream implements KnownLength, Drainable {
+
+  @Nullable private byte[][] blocks;
+  @Nullable private byte[] currentBlock;
+  private int blockIndex;
+  private int blockOffset;
+  private int available;
+  private boolean closed;
+
+  /**
+   * Creates a new stream with a single block.
+   *
+   * @param block The single byte array block, ownership of which is passed to this instance.
+   */
+  BlockInputStream(byte[] block) {
+    this.blocks = null;
+    currentBlock = block.length > 0 ? block : null;
+    available = block.length;
+  }
+
+  /**
+   * Creates a new stream from a sequence of blocks.
+   *
+   * @param blocks A two dimensional byte array containing the data. Ownership of all blocks is
+   *     passed to this instance.
+   * @param available The number of bytes available in total. This may be less than (but never more
+   *     than) the total size of all byte arrays in blocks.
+   */
+  BlockInputStream(byte[][] blocks, int available) {
+    this.blocks = blocks;
+    this.available = available;
+    if (blocks.length > 0) {
+      currentBlock = blocks[0];
+    }
+  }
+
+  @Override
+  public int read() throws IOException {
+    if (currentBlock != null) {
+      int res = currentBlock[blockOffset++];
+      available -= 1;
+      if (blockOffset == currentBlock.length) {
+        nextBlock();
+      }
+      return res;
+    }
+    return -1;
+  }
+
+  @Override
+  public int read(byte[] data, int off, int len) throws IOException {
+    int stillToRead = len;
+    while (currentBlock != null) {
+      int n = Ints.min(stillToRead, currentBlock.length - blockOffset, available);
+      System.arraycopy(currentBlock, blockOffset, data, off, n);
+      off += n;
+      stillToRead -= n;
+      available -= n;
+      if (stillToRead == 0) {
+        blockOffset += n;
+        if (blockOffset == currentBlock.length) {
+          nextBlock();
+        }
+        break;
+      } else {
+        nextBlock();
+      }
+    }
+    int bytesRead = len - stillToRead;
+    if (bytesRead > 0 || available > 0) {
+      return bytesRead;
+    }
+    return -1;
+  }
+
+  private void nextBlock() {
+    blockIndex += 1;
+    blockOffset = 0;
+    if (blocks != null && blockIndex < blocks.length) {
+      currentBlock = blocks[blockIndex];
+    } else {
+      currentBlock = null;
+    }
+  }
+
+  @Override
+  public int available() {
+    return available;
+  }
+
+  @Override
+  public int drainTo(OutputStream output) throws IOException {
+    int res = available;
+    while (available > 0) {
+      int n = Math.min(currentBlock.length - blockOffset, available);
+      output.write(currentBlock, blockOffset, n);
+      available -= n;
+      nextBlock();
+    }
+    return res;
+  }
+
+  @Override
+  public void close() {
+    if (!closed) {
+      closed = true;
+      if (blocks != null) {
+        for (byte[] block : blocks) {
+          BlockPool.releaseBlock(block);
+        }
+      } else if (currentBlock != null) {
+        BlockPool.releaseBlock(currentBlock);
+      }
+      currentBlock = null;
+      blocks = null;
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/BlockPool.java b/binder/src/main/java/io/grpc/binder/internal/BlockPool.java
new file mode 100644
index 00000000000..3c58abdd80b
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/BlockPool.java
@@ -0,0 +1,79 @@
+/*
+ * 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 io.grpc.internal.GrpcUtil;
+import java.util.Queue;
+import java.util.concurrent.LinkedBlockingQueue;
+
+/**
+ * Manages a pool of byte-array blocks.
+ *
+ * <p>Unfortunately, the Android Parcel api only allws us to read a block of N bytes when we have a
+ * byte array of size N. This means we can't simply read into a large block and be done with it, we
+ * need to allocate a new buffer specifically. Boo, Android.
+ *
+ * <p>When writing data though, we can use a fixed-size buffer, so when large messages are split
+ * into standard-sized blocks, we only need a byte array allocation to read the last block.
+ *
+ * <p>This class maintains a pool of blocks of standard size, but also provides smaller blocks when
+ * requested. Currently, blocks of standard size are retained in the pool, when released, but we
+ * could chose to change this strategy.
+ */
+final class BlockPool {
+
+  /**
+   * The size of each standard block. (Currently 16k) The block size must be at least as large as
+   * the maximum header list size.
+   */
+  private static final int BLOCK_SIZE = Math.max(16 * 1024, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE);
+
+  /**
+   * Maximum number of blocks to keep around. (Max 128k). This limit is a judgement call. 128k is
+   * small enough that it shouldn't significantly affect the memory usage of a large app, but large
+   * enough that it should to reduce allocation churn while gRPC is in use.
+   */
+  private static final int BLOCK_POOL_SIZE = 128 * 1024 / BLOCK_SIZE;
+
+  /** A pool of byte arrays of standard size. We don't use any blocking methods of this instance. */
+  private static final Queue<byte[]> blockPool = new LinkedBlockingQueue<>(BLOCK_POOL_SIZE);
+
+  private BlockPool() {}
+
+  /** Acquire a block of standard size. */
+  static byte[] acquireBlock() {
+    return acquireBlock(BLOCK_SIZE);
+  }
+
+  /** Acquire a block of the specified size. */
+  static byte[] acquireBlock(int size) {
+    if (size == BLOCK_SIZE) {
+      byte[] block = blockPool.poll();
+      if (block != null) {
+        return block;
+      }
+    }
+    return new byte[size];
+  }
+
+  /** Release a now-unused block. */
+  static void releaseBlock(byte[] block) {
+    if (block.length == BLOCK_SIZE) {
+      blockPool.offer(block);
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/BoundClientAddress.java b/binder/src/main/java/io/grpc/binder/internal/BoundClientAddress.java
new file mode 100644
index 00000000000..edb52fecac6
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/BoundClientAddress.java
@@ -0,0 +1,53 @@
+/*
+ * 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 io.grpc.Internal;
+import java.net.SocketAddress;
+
+/** An address to represent a binding from a remote client. */
+@Internal
+public final class BoundClientAddress extends SocketAddress {
+
+  private static final long serialVersionUID = 0L;
+
+  /** The UID of the address. For incoming binder transactions, this is all the info we have. */
+  private final int uid;
+
+  public BoundClientAddress(int uid) {
+    this.uid = uid;
+  }
+
+  @Override
+  public int hashCode() {
+    return uid;
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (obj instanceof BoundClientAddress) {
+      BoundClientAddress that = (BoundClientAddress) obj;
+      return uid == that.uid;
+    }
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return "BoundClientAddress[" + uid + "]";
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/FlowController.java b/binder/src/main/java/io/grpc/binder/internal/FlowController.java
new file mode 100644
index 00000000000..135f363a01e
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/FlowController.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2021 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 com.google.errorprone.annotations.concurrent.GuardedBy;
+
+/** Keeps track of the number of bytes on the wire in a single direction. */
+final class FlowController {
+  private final int maxUnackedBytes;
+
+  @GuardedBy("this")
+  private long totalBytesSent;
+
+  @GuardedBy("this")
+  private long totalBytesAckedByPeer;
+
+  // @GuardedBy("this") for writes but not reads.
+  private volatile boolean transmitWindowFull;
+
+  /**
+   * Creates a new instance of {@link FlowController}.
+   *
+   * @param maxUnackedBytes a weak limit on the number of bytes sent but not yet acknowledged
+   */
+  public FlowController(int maxUnackedBytes) {
+    this.maxUnackedBytes = maxUnackedBytes;
+  }
+
+  /**
+   * Returns true iff the number of reported bytes sent but not yet acknowledged is greater than or
+   * equal to {@code maxUnackedBytes}.
+   */
+  public boolean isTransmitWindowFull() {
+    return transmitWindowFull;
+  }
+
+  /**
+   * Informs this flow controller that more data has been sent.
+   *
+   * @param numBytesSent a non-negative number of additional bytes sent
+   * @return true iff this report caused {@link #isTransmitWindowFull()} to transition to true
+   */
+  public synchronized boolean notifyBytesSent(long numBytesSent) {
+    totalBytesSent += numBytesSent;
+    if ((totalBytesSent - totalBytesAckedByPeer) >= maxUnackedBytes && !transmitWindowFull) {
+      transmitWindowFull = true;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Processes an acknowledgement from our peer.
+   *
+   * @param numBytesAcked the total number of bytes ever received over this connection modulo 2^64,
+   *     with the most significant bit of this value encoded in this argument's sign bit
+   * @return true iff this report caused {@link #isTransmitWindowFull()} to transition to false
+   */
+  public synchronized boolean handleAcknowledgedBytes(long numBytesAcked) {
+    totalBytesAckedByPeer = wrapAwareMax(totalBytesAckedByPeer, numBytesAcked);
+    if ((totalBytesSent - totalBytesAckedByPeer) < maxUnackedBytes && transmitWindowFull) {
+      transmitWindowFull = false;
+      return true;
+    }
+    return false;
+  }
+
+  private static final long wrapAwareMax(long a, long b) {
+    return a - b < 0 ? b : a;
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/Inbound.java b/binder/src/main/java/io/grpc/binder/internal/Inbound.java
new file mode 100644
index 00000000000..9b9dfeef5ce
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/Inbound.java
@@ -0,0 +1,729 @@
+/*
+ * 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.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import android.os.Parcel;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.binder.InboundParcelablePolicy;
+import io.grpc.internal.ClientStreamListener;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
+import io.grpc.internal.ServerStream;
+import io.grpc.internal.ServerStreamListener;
+import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.StreamListener;
+import java.io.InputStream;
+import java.util.ArrayList;
+import javax.annotation.Nullable;
+
+/**
+ * Handles incoming binder transactions for a single stream, turning those transactions into calls
+ * to the stream listener.
+ *
+ * <p>Out-of-order messages are reassembled into their correct order.
+ */
+abstract class Inbound<L extends StreamListener> implements StreamListener.MessageProducer {
+
+  protected final BinderTransport transport;
+  protected final Attributes attributes;
+  final int callId;
+
+  // ==========================
+  // Values set when we're initialized.
+
+  @Nullable
+  @GuardedBy("this")
+  protected Outbound outbound;
+
+  @Nullable
+  @GuardedBy("this")
+  protected StatsTraceContext statsTraceContext;
+
+  @Nullable
+  @GuardedBy("this")
+  protected L listener;
+
+  // ==========================
+  // State of inbound data.
+
+  @Nullable
+  @GuardedBy("this")
+  private InputStream firstMessage;
+
+  @GuardedBy("this")
+  private int firstQueuedTransactionIndex;
+
+  @GuardedBy("this")
+  private int nextCompleteMessageEnd;
+
+  @Nullable
+  @GuardedBy("this")
+  private ArrayList<TransactionData> queuedTransactionData;
+
+  @GuardedBy("this")
+  private boolean suffixAvailable;
+
+  @GuardedBy("this")
+  private int suffixTransactionIndex;
+
+  @GuardedBy("this")
+  private int inboundDataSize;
+
+  // ==========================
+  // State of what we've delivered to gRPC.
+
+  /**
+   * Each rpc transmits (or receives) a prefix (including headers and possibly a method name), the
+   * data of zero or more request (or response) messages, and a suffix (possibly including a close
+   * status and trailers).
+   *
+   * <p>This enum represents those stages, for both availability (what we've been given), and
+   * delivery what we've sent.
+   */
+  enum State {
+    // We aren't yet connected to a BinderStream instance and listener. Due to potentially
+    // out-of-order messages, a server-side instance can remain in this state for multiple
+    // transactions.
+    UNINITIALIZED,
+
+    // We're attached to a BinderStream instance and we have a listener we can report to.
+    // On the client-side, this happens as soon as the start() method is called (almost
+    // immediately), and on the server side, this happens as soon as we receive the prefix
+    // (so we know which method is being called).
+    INITIALIZED,
+
+    // We've delivered the prefix data to the listener. On the client side, this means we've
+    // delivered the response headers, and on the server side this state is effectively the same
+    // as INITIALIZED (since we initialize only by delivering the prefix).
+    PREFIX_DELIVERED,
+
+    // All messages have been received, and delivered to the listener.
+    ALL_MESSAGES_DELIVERED,
+
+    // We've delivered the suffix.
+    SUFFIX_DELIVERED,
+
+    // The stream is closed.
+    CLOSED
+  }
+
+  /*
+   * Represents which data we've delivered to the gRPC listener.
+   */
+  @GuardedBy("this")
+  private State deliveryState = State.UNINITIALIZED;
+
+  @GuardedBy("this")
+  private int numReceivedMessages;
+
+  @GuardedBy("this")
+  private int numRequestedMessages;
+
+  @GuardedBy("this")
+  private boolean delivering;
+
+  @GuardedBy("this")
+  private boolean producingMessages;
+
+  private Inbound(BinderTransport transport, Attributes attributes, int callId) {
+    this.transport = transport;
+    this.attributes = attributes;
+    this.callId = callId;
+  }
+
+  @GuardedBy("this")
+  final void init(Outbound outbound, L listener) {
+    this.outbound = outbound;
+    this.statsTraceContext = outbound.getStatsTraceContext();
+    this.listener = listener;
+    if (!isClosed()) {
+      onDeliveryState(State.INITIALIZED);
+    }
+  }
+
+  final void unregister() {
+    transport.unregisterInbound(this);
+  }
+
+  boolean countsForInUse() {
+    return false;
+  }
+
+  // =====================
+  // Updates to delivery.
+
+  @GuardedBy("this")
+  protected final void onDeliveryState(State deliveryState) {
+    checkTransition(this.deliveryState, deliveryState);
+    this.deliveryState = deliveryState;
+  }
+
+  @GuardedBy("this")
+  protected final boolean isClosed() {
+    return deliveryState == State.CLOSED;
+  }
+
+  @GuardedBy("this")
+  private final boolean messageAvailable() {
+    return firstMessage != null || nextCompleteMessageEnd > 0;
+  }
+
+  @GuardedBy("this")
+  private boolean receivedAllTransactions() {
+    return suffixAvailable && firstQueuedTransactionIndex >= suffixTransactionIndex;
+  }
+
+  // ===================
+  // Internals.
+
+  @GuardedBy("this")
+  final void deliver() {
+    if (delivering) {
+      // Don't re-enter.
+      return;
+    }
+    delivering = true;
+    while (canDeliver()) {
+      deliverInternal();
+    }
+    delivering = false;
+  }
+
+  @GuardedBy("this")
+  private final boolean canDeliver() {
+    switch (deliveryState) {
+      case PREFIX_DELIVERED:
+        if (listener != null) {
+          if (producingMessages) {
+            // We're waiting for the listener to consume messages. Nothing to do.
+            return false;
+          } else if (messageAvailable()) {
+            // There's a message. We can deliver if we've been asked for messages, and we haven't
+            // already given the listener a MessageProducer.
+            return numRequestedMessages != 0;
+          } else {
+            // There are no messages available. Return true if that's the last of them, because we
+            // can send the suffix.
+            return receivedAllTransactions();
+          }
+        }
+        return false;
+      case ALL_MESSAGES_DELIVERED:
+        return listener != null && suffixAvailable;
+      default:
+        return false;
+    }
+  }
+
+  @GuardedBy("this")
+  @SuppressWarnings("fallthrough")
+  private final void deliverInternal() {
+    switch (deliveryState) {
+      case PREFIX_DELIVERED:
+        if (producingMessages) {
+          break;
+        } else if (messageAvailable()) {
+          producingMessages = true;
+          listener.messagesAvailable(this);
+          break;
+        } else if (!suffixAvailable) {
+          break;
+        }
+        onDeliveryState(State.ALL_MESSAGES_DELIVERED);
+        // Fall-through.
+      case ALL_MESSAGES_DELIVERED:
+        if (suffixAvailable) {
+          onDeliveryState(State.SUFFIX_DELIVERED);
+          deliverSuffix();
+        }
+        break;
+      default:
+        throw new AssertionError();
+    }
+  }
+
+  /** Deliver the suffix to gRPC. */
+  protected abstract void deliverSuffix();
+
+  @GuardedBy("this")
+  final void closeOnCancel(Status status) {
+    closeAbnormal(Status.CANCELLED, status, false);
+  }
+
+  @GuardedBy("this")
+  private final void closeOutOfBand(Status status) {
+    closeAbnormal(status, status, true);
+  }
+
+  @GuardedBy("this")
+  final void closeAbnormal(Status status) {
+    closeAbnormal(status, status, false);
+  }
+
+  @GuardedBy("this")
+  private final void closeAbnormal(
+      Status outboundStatus, Status internalStatus, boolean isOobFromRemote) {
+    if (!isClosed()) {
+      boolean wasInitialized = (deliveryState != State.UNINITIALIZED);
+      onDeliveryState(State.CLOSED);
+      if (wasInitialized) {
+        statsTraceContext.streamClosed(internalStatus);
+      }
+      if (!isOobFromRemote) {
+        transport.sendOutOfBandClose(callId, outboundStatus);
+      }
+      if (wasInitialized) {
+        deliverCloseAbnormal(internalStatus);
+      }
+      unregister();
+    }
+  }
+
+  @GuardedBy("this")
+  protected abstract void deliverCloseAbnormal(Status status);
+
+  final void onTransportReady() {
+    // Report transport readiness to the listener, and the outbound data.
+    Outbound outbound = null;
+    StreamListener listener = null;
+    synchronized (this) {
+      outbound = this.outbound;
+      listener = this.listener;
+    }
+    if (listener != null) {
+      listener.onReady();
+    }
+    if (outbound != null) {
+      try {
+        synchronized (outbound) {
+          outbound.onTransportReady();
+        }
+      } catch (StatusException se) {
+        synchronized (this) {
+          closeAbnormal(se.getStatus());
+        }
+      }
+    }
+  }
+
+  @GuardedBy("this")
+  public void requestMessages(int num) {
+    numRequestedMessages += num;
+    deliver();
+  }
+
+  final synchronized void handleTransaction(Parcel parcel) {
+    if (isClosed()) {
+      return;
+    }
+    try {
+      int flags = parcel.readInt();
+      if (TransactionUtils.hasFlag(flags, TransactionUtils.FLAG_OUT_OF_BAND_CLOSE)) {
+        closeOutOfBand(TransactionUtils.readStatus(flags, parcel));
+        return;
+      }
+      int index = parcel.readInt();
+      boolean hasPrefix = TransactionUtils.hasFlag(flags, TransactionUtils.FLAG_PREFIX);
+      boolean hasMessageData = TransactionUtils.hasFlag(flags, TransactionUtils.FLAG_MESSAGE_DATA);
+      boolean hasSuffix = TransactionUtils.hasFlag(flags, TransactionUtils.FLAG_SUFFIX);
+      if (hasPrefix) {
+        handlePrefix(flags, parcel);
+        onDeliveryState(State.PREFIX_DELIVERED);
+      }
+      if (hasMessageData) {
+        handleMessageData(flags, index, parcel);
+      }
+      if (hasSuffix) {
+        handleSuffix(flags, parcel);
+        suffixTransactionIndex = index;
+        suffixAvailable = true;
+      }
+      if (index == firstQueuedTransactionIndex) {
+        if (queuedTransactionData == null) {
+          // This message was in order, and we haven't needed to queue anything yet.
+          firstQueuedTransactionIndex += 1;
+        } else if (!hasMessageData && !hasSuffix) {
+          // The first transaction arrived, but it contained no message data.
+          queuedTransactionData.remove(0);
+          firstQueuedTransactionIndex += 1;
+        }
+      }
+      reportInboundSize(parcel.dataSize());
+      deliver();
+    } catch (StatusException se) {
+      closeAbnormal(se.getStatus());
+    }
+  }
+
+  @GuardedBy("this")
+  abstract void handlePrefix(int flags, Parcel parcel) throws StatusException;
+
+  @GuardedBy("this")
+  abstract void handleSuffix(int flags, Parcel parcel) throws StatusException;
+
+  @GuardedBy("this")
+  private void handleMessageData(int flags, int index, Parcel parcel) throws StatusException {
+    InputStream stream = null;
+    byte[] block = null;
+    boolean lastBlockOfMessage = true;
+    int numBytes = 0;
+    if ((flags & TransactionUtils.FLAG_MESSAGE_DATA_IS_PARCELABLE) != 0) {
+      InboundParcelablePolicy policy = attributes.get(BinderTransport.INBOUND_PARCELABLE_POLICY);
+      if (policy == null || !policy.shouldAcceptParcelableMessages()) {
+        throw Status.PERMISSION_DENIED
+            .withDescription("Parcelable messages not allowed")
+            .asException();
+      }
+      int startPos = parcel.dataPosition();
+      stream = ParcelableInputStream.readFromParcel(parcel, getClass().getClassLoader());
+      numBytes = parcel.dataPosition() - startPos;
+    } else {
+      numBytes = parcel.readInt();
+      block = BlockPool.acquireBlock(numBytes);
+      if (numBytes > 0) {
+        parcel.readByteArray(block);
+      }
+      if ((flags & TransactionUtils.FLAG_MESSAGE_DATA_IS_PARTIAL) != 0) {
+        // Partial message. Ensure we have a message assembler.
+        lastBlockOfMessage = false;
+      }
+    }
+    if (queuedTransactionData == null) {
+      if (numReceivedMessages == 0 && lastBlockOfMessage && index == firstQueuedTransactionIndex) {
+        // Shortcut for when we receive a single message in one transaction.
+        checkState(firstMessage == null);
+        firstMessage = (stream != null) ? stream : new BlockInputStream(block);
+        reportInboundMessage(numBytes);
+        return;
+      }
+      queuedTransactionData = new ArrayList<>(16);
+    }
+    enqueueTransactionData(index, new TransactionData(stream, block, numBytes, lastBlockOfMessage));
+  }
+
+  @GuardedBy("this")
+  private void enqueueTransactionData(int index, TransactionData data) {
+    int offset = index - firstQueuedTransactionIndex;
+    if (offset < queuedTransactionData.size()) {
+      queuedTransactionData.set(offset, data);
+      lookForCompleteMessage();
+    } else if (offset > queuedTransactionData.size()) {
+      do {
+        queuedTransactionData.add(null);
+      } while (offset > queuedTransactionData.size());
+      queuedTransactionData.add(data);
+    } else {
+      queuedTransactionData.add(data);
+      lookForCompleteMessage();
+    }
+  }
+
+  @GuardedBy("this")
+  private void lookForCompleteMessage() {
+    int numBytes = 0;
+    if (nextCompleteMessageEnd == 0) {
+      for (int i = 0; i < queuedTransactionData.size(); i++) {
+        TransactionData data = queuedTransactionData.get(i);
+        if (data == null) {
+          // Missing block.
+          return;
+        } else {
+          numBytes += data.numBytes;
+          if (data.lastBlockOfMessage) {
+            // Found a complete message.
+            nextCompleteMessageEnd = i + 1;
+            reportInboundMessage(numBytes);
+            return;
+          }
+        }
+      }
+    }
+  }
+
+  @Override
+  @Nullable
+  public final synchronized InputStream next() {
+    InputStream stream = null;
+    if (firstMessage != null) {
+      stream = firstMessage;
+      firstMessage = null;
+    } else if (numRequestedMessages > 0 && messageAvailable()) {
+      stream = assembleNextMessage();
+    }
+    if (stream != null) {
+      numRequestedMessages -= 1;
+    } else {
+      producingMessages = false;
+      if (receivedAllTransactions()) {
+        // That's the last of the messages delivered.
+        if (!isClosed()) {
+          onDeliveryState(State.ALL_MESSAGES_DELIVERED);
+          deliver();
+        }
+      }
+    }
+    return stream;
+  }
+
+  @GuardedBy("this")
+  private InputStream assembleNextMessage() {
+    InputStream message;
+    int numBlocks = nextCompleteMessageEnd;
+    nextCompleteMessageEnd = 0;
+    int numBytes = 0;
+    if (numBlocks == 1) {
+      // Single block.
+      TransactionData data = queuedTransactionData.remove(0);
+      numBytes = data.numBytes;
+      if (data.stream != null) {
+        message = data.stream;
+      } else {
+        message = new BlockInputStream(data.block);
+      }
+    } else {
+      byte[][] blocks = new byte[numBlocks][];
+      for (int i = 0; i < numBlocks; i++) {
+        TransactionData data = queuedTransactionData.remove(0);
+        blocks[i] = checkNotNull(data.block);
+        numBytes += blocks[i].length;
+      }
+      message = new BlockInputStream(blocks, numBytes);
+    }
+    firstQueuedTransactionIndex += numBlocks;
+    lookForCompleteMessage();
+    return message;
+  }
+
+  // ------------------------------------
+  // stats collection.
+
+  @GuardedBy("this")
+  private void reportInboundSize(int size) {
+    inboundDataSize += size;
+    if (statsTraceContext != null && inboundDataSize != 0) {
+      statsTraceContext.inboundWireSize(inboundDataSize);
+      statsTraceContext.inboundUncompressedSize(inboundDataSize);
+      inboundDataSize = 0;
+    }
+  }
+
+  @GuardedBy("this")
+  private void reportInboundMessage(int numBytes) {
+    checkNotNull(statsTraceContext);
+    statsTraceContext.inboundMessage(numReceivedMessages);
+    statsTraceContext.inboundMessageRead(numReceivedMessages, numBytes, numBytes);
+    numReceivedMessages += 1;
+  }
+
+  @Override
+  public synchronized String toString() {
+    return getClass().getSimpleName()
+        + "[SfxA="
+        + suffixAvailable
+        + "/De="
+        + deliveryState
+        + "/Msg="
+        + messageAvailable()
+        + "/Lis="
+        + (listener != null)
+        + "]";
+  }
+
+  // ======================================
+  // Client-side inbound transactions.
+  static final class ClientInbound extends Inbound<ClientStreamListener> {
+
+    private final boolean countsForInUse;
+
+    @Nullable
+    @GuardedBy("this")
+    private Status closeStatus;
+
+    @Nullable
+    @GuardedBy("this")
+    private Metadata trailers;
+
+    ClientInbound(
+        BinderTransport transport, Attributes attributes, int callId, boolean countsForInUse) {
+      super(transport, attributes, callId);
+      this.countsForInUse = countsForInUse;
+    }
+
+    @Override
+    boolean countsForInUse() {
+      return countsForInUse;
+    }
+
+    @Override
+    @GuardedBy("this")
+    protected void handlePrefix(int flags, Parcel parcel) throws StatusException {
+      Metadata headers = MetadataHelper.readMetadata(parcel, attributes);
+      statsTraceContext.clientInboundHeaders(headers);
+      listener.headersRead(headers);
+    }
+
+    @Override
+    @GuardedBy("this")
+    protected void handleSuffix(int flags, Parcel parcel) throws StatusException {
+      closeStatus = TransactionUtils.readStatus(flags, parcel);
+      trailers = MetadataHelper.readMetadata(parcel, attributes);
+    }
+
+    @Override
+    @GuardedBy("this")
+    protected void deliverSuffix() {
+      statsTraceContext.clientInboundTrailers(trailers);
+      statsTraceContext.streamClosed(closeStatus);
+      onDeliveryState(State.CLOSED);
+      listener.closed(closeStatus, RpcProgress.PROCESSED, trailers);
+      unregister();
+    }
+
+    @Override
+    @GuardedBy("this")
+    protected void deliverCloseAbnormal(Status status) {
+      listener.closed(status, RpcProgress.PROCESSED, new Metadata());
+    }
+  }
+
+  // ======================================
+  // Server-side inbound transactions.
+  static final class ServerInbound extends Inbound<ServerStreamListener> {
+
+    private final BinderServerTransport serverTransport;
+
+    ServerInbound(BinderServerTransport transport, Attributes attributes, int callId) {
+      super(transport, attributes, callId);
+      this.serverTransport = transport;
+    }
+
+    @GuardedBy("this")
+    @Override
+    protected void handlePrefix(int flags, Parcel parcel) throws StatusException {
+      String methodName = parcel.readString();
+      Metadata headers = MetadataHelper.readMetadata(parcel, attributes);
+
+      StatsTraceContext statsTraceContext =
+          serverTransport.createStatsTraceContext(methodName, headers);
+      Outbound.ServerOutbound outbound =
+          new Outbound.ServerOutbound(serverTransport, callId, statsTraceContext);
+      ServerStream stream;
+      if ((flags & TransactionUtils.FLAG_EXPECT_SINGLE_MESSAGE) != 0) {
+        stream = new SingleMessageServerStream(this, outbound, attributes);
+      } else {
+        stream = new MultiMessageServerStream(this, outbound, attributes);
+      }
+      Status status = serverTransport.startStream(stream, methodName, headers);
+      if (status.isOk()) {
+        checkNotNull(listener); // Is it ok to assume this will happen synchronously?
+        if (transport.isReady()) {
+          listener.onReady();
+        }
+      } else {
+        closeAbnormal(status);
+      }
+    }
+
+    @GuardedBy("this")
+    @Override
+    protected void handleSuffix(int flags, Parcel parcel) {
+      // Nothing to read.
+    }
+
+    @Override
+    @GuardedBy("this")
+    protected void deliverSuffix() {
+      listener.halfClosed();
+    }
+
+    @Override
+    @GuardedBy("this")
+    protected void deliverCloseAbnormal(Status status) {
+      listener.closed(status);
+    }
+
+    @GuardedBy("this")
+    void onCloseSent(Status status) {
+      if (!isClosed()) {
+        onDeliveryState(State.CLOSED);
+        statsTraceContext.streamClosed(status);
+        listener.closed(Status.OK);
+      }
+    }
+  }
+
+  // ======================================
+  // Helper methods.
+
+  private static void checkTransition(State current, State next) {
+    switch (next) {
+      case INITIALIZED:
+        checkState(current == State.UNINITIALIZED, "%s -> %s", current, next);
+        break;
+      case PREFIX_DELIVERED:
+        checkState(
+            current == State.INITIALIZED || current == State.UNINITIALIZED,
+            "%s -> %s",
+            current,
+            next);
+        break;
+      case ALL_MESSAGES_DELIVERED:
+        checkState(current == State.PREFIX_DELIVERED, "%s -> %s", current, next);
+        break;
+      case SUFFIX_DELIVERED:
+        checkState(current == State.ALL_MESSAGES_DELIVERED, "%s -> %s", current, next);
+        break;
+      case CLOSED:
+        break;
+      default:
+        throw new AssertionError();
+    }
+  }
+
+  // ======================================
+  // Message reassembly.
+
+  /** Part of an unconsumed message. */
+  private static final class TransactionData {
+    @Nullable final InputStream stream;
+    @Nullable final byte[] block;
+    final int numBytes;
+    final boolean lastBlockOfMessage;
+
+    TransactionData(InputStream stream, byte[] block, int numBytes, boolean lastBlockOfMessage) {
+      this.stream = stream;
+      this.block = block;
+      this.numBytes = numBytes;
+      this.lastBlockOfMessage = lastBlockOfMessage;
+    }
+
+    @Override
+    public String toString() {
+      return "TransactionData["
+          + numBytes
+          + "b "
+          + (stream != null ? "stream" : "array")
+          + (lastBlockOfMessage ? "(last)]" : "]");
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/IntentNameResolver.java b/binder/src/main/java/io/grpc/binder/internal/IntentNameResolver.java
new file mode 100644
index 00000000000..ce3e2a96a42
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/IntentNameResolver.java
@@ -0,0 +1,299 @@
+/*
+ * Copyright 2025 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.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.binder.internal.SystemApis.createContextAsUser;
+
+import android.annotation.SuppressLint;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.os.Build;
+import android.os.UserHandle;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.StatusOr;
+import io.grpc.SynchronizationContext;
+import io.grpc.binder.AndroidComponentAddress;
+import io.grpc.binder.ApiConstants;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Executor;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link NameResolver} that resolves Android-standard "intent:" target URIs to the list of {@link
+ * AndroidComponentAddress} that match it by manifest intent filter.
+ */
+final class IntentNameResolver extends NameResolver {
+  private final Intent targetIntent; // Never mutated.
+  @Nullable private final UserHandle targetUser; // null means same user that hosts this process.
+  private final Context targetUserContext;
+  private final Executor offloadExecutor;
+  private final Executor sequentialExecutor;
+  private final SynchronizationContext syncContext;
+  private final ServiceConfigParser serviceConfigParser;
+
+  // Accessed only on `sequentialExecutor`
+  @Nullable private PackageChangeReceiver receiver; // != null when registered
+
+  // Accessed only on 'syncContext'.
+  private boolean shutdown;
+  private boolean queryNeeded;
+  @Nullable private Listener2 listener; // != null after start().
+  @Nullable private ListenableFuture<ResolutionResult> queryResultFuture; // != null when querying.
+
+  @EquivalentAddressGroup.Attr
+  private static final Attributes CONSTANT_EAG_ATTRS =
+      Attributes.newBuilder()
+          // Servers discovered in PackageManager are especially untrusted. After all, any app can
+          // declare any intent filter it wants! Require pre-authorization so that unauthorized apps
+          // don't even get a chance to run onCreate()/onBind().
+          .set(ApiConstants.PRE_AUTH_SERVER_OVERRIDE, true)
+          .build();
+
+  IntentNameResolver(Intent targetIntent, Args args) {
+    this.targetIntent = targetIntent;
+    this.targetUser = args.getArg(ApiConstants.TARGET_ANDROID_USER);
+    Context context =
+        checkNotNull(args.getArg(ApiConstants.SOURCE_ANDROID_CONTEXT), "SOURCE_ANDROID_CONTEXT")
+            .getApplicationContext();
+    this.targetUserContext =
+        targetUser != null ? createContextForTargetUserOrThrow(context, targetUser) : context;
+    // This Executor is nominally optional but all grpc-java Channels provide it since 1.25.
+    this.offloadExecutor =
+        checkNotNull(args.getOffloadExecutor(), "NameResolver.Args.getOffloadExecutor()");
+    // Ensures start()'s work runs before resolve()'s' work, and both run before shutdown()'s.
+    this.sequentialExecutor = MoreExecutors.newSequentialExecutor(offloadExecutor);
+    this.syncContext = args.getSynchronizationContext();
+    this.serviceConfigParser = args.getServiceConfigParser();
+  }
+
+  private static Context createContextForTargetUserOrThrow(Context context, UserHandle targetUser) {
+    try {
+      return createContextAsUser(context, targetUser, /* flags= */ 0); // @SystemApi since R.
+    } catch (ReflectiveOperationException e) {
+      throw new IllegalArgumentException(
+          "TARGET_ANDROID_USER NameResolver.Arg requires SDK_INT >= R and @SystemApi visibility");
+    }
+  }
+
+  @Override
+  public void start(Listener2 listener) {
+    checkState(this.listener == null, "Already started!");
+    checkState(!shutdown, "Resolver is shutdown");
+    this.listener = checkNotNull(listener);
+    sequentialExecutor.execute(this::registerReceiver);
+    resolve();
+  }
+
+  @Override
+  public void refresh() {
+    checkState(listener != null, "Not started!");
+    resolve();
+  }
+
+  private void resolve() {
+    syncContext.throwIfNotInThisSynchronizationContext();
+
+    if (shutdown) {
+      return;
+    }
+
+    // We can't block here in 'syncContext' so we offload PackageManager queries to an Executor.
+    // But offloading complicates things a bit because other calls can arrive while we wait for the
+    // results. We keep 'listener' up-to-date with the latest state in PackageManager by doing:
+    // 1. Only one query-and-report-to-listener operation at a time.
+    // 2. At least one query-and-report-to-listener AFTER every PackageManager state change.
+    if (queryResultFuture == null) {
+      queryResultFuture = Futures.submit(this::queryPackageManager, sequentialExecutor);
+      queryResultFuture.addListener(this::onQueryComplete, syncContext);
+    } else {
+      // There's already a query in-flight but (2) says we need at least one more. Our sequential
+      // Executor would be enough to ensure (1) but we also don't want a backlog of work to build up
+      // if things change rapidly. Just make a note to start a new query when this one finishes.
+      queryNeeded = true;
+    }
+  }
+
+  private void onQueryComplete() {
+    syncContext.throwIfNotInThisSynchronizationContext();
+    checkState(queryResultFuture != null);
+    checkState(queryResultFuture.isDone());
+
+    // Capture non-final `listener` here while we're on 'syncContext'.
+    Listener2 listener = checkNotNull(this.listener);
+    Futures.addCallback(
+        queryResultFuture, // Already isDone() so this execute()s immediately.
+        new FutureCallback<ResolutionResult>() {
+          @Override
+          public void onSuccess(ResolutionResult result) {
+            listener.onResult2(result);
+          }
+
+          @Override
+          public void onFailure(Throwable t) {
+            listener.onResult2(
+                ResolutionResult.newBuilder()
+                    .setAddressesOrError(StatusOr.fromStatus(Status.fromThrowable(t)))
+                    .build());
+          }
+        },
+        syncContext); // Already on 'syncContext' but addCallback() is faster than try/get/catch.
+    queryResultFuture = null;
+
+    if (queryNeeded) {
+      // One or more resolve() requests arrived while we were working on the last one. Just one
+      // follow-on query can subsume all of them.
+      queryNeeded = false;
+      resolve();
+    }
+  }
+
+  @Override
+  public String getServiceAuthority() {
+    return "localhost";
+  }
+
+  @Override
+  public void shutdown() {
+    syncContext.throwIfNotInThisSynchronizationContext();
+    if (!shutdown) {
+      shutdown = true;
+      sequentialExecutor.execute(this::maybeUnregisterReceiver);
+    }
+  }
+
+  private ResolutionResult queryPackageManager() throws StatusException {
+    List<ResolveInfo> queryResults = queryIntentServices(targetIntent);
+
+    // Avoid a spurious UnsafeIntentLaunchViolation later. Since S, Android's StrictMode is very
+    // conservative, marking any Intent parsed from a string as suspicious and complaining when you
+    // bind to it. But all this is pointless with grpc-binder, which already goes even further by
+    // not trusting addresses at all! Instead, we rely on SecurityPolicy, which won't allow a
+    // connection to an unauthorized server UID no matter how you got there.
+    Intent prototypeBindIntent = sanitize(targetIntent);
+
+    // Model each matching android.app.Service as an EAG (server) with a single address.
+    List<EquivalentAddressGroup> addresses = new ArrayList<>();
+    for (ResolveInfo resolveInfo : queryResults) {
+      prototypeBindIntent.setComponent(
+          new ComponentName(resolveInfo.serviceInfo.packageName, resolveInfo.serviceInfo.name));
+      addresses.add(
+          new EquivalentAddressGroup(
+              AndroidComponentAddress.newBuilder()
+                  .setBindIntent(prototypeBindIntent) // Makes a copy.
+                  .setTargetUser(targetUser)
+                  .build(),
+              CONSTANT_EAG_ATTRS));
+    }
+
+    return ResolutionResult.newBuilder()
+        .setAddressesOrError(StatusOr.fromValue(addresses))
+        // Empty service config means we get the default 'pick_first' load balancing policy.
+        .setServiceConfig(serviceConfigParser.parseServiceConfig(ImmutableMap.of()))
+        .build();
+  }
+
+  private List<ResolveInfo> queryIntentServices(Intent intent) throws StatusException {
+    int flags = 0;
+    if (Build.VERSION.SDK_INT >= 29) {
+      // Don't match direct-boot-unaware Services that can't presently be created. We'll query again
+      // after the user is unlocked. The MATCH_DIRECT_BOOT_AUTO behavior is actually the default but
+      // being explicit here avoids an android.os.strictmode.ImplicitDirectBootViolation.
+      flags |= PackageManager.MATCH_DIRECT_BOOT_AUTO;
+    }
+
+    List<ResolveInfo> intentServices =
+        targetUserContext.getPackageManager().queryIntentServices(intent, flags);
+    if (intentServices == null || intentServices.isEmpty()) {
+      // Must be the same as when ServiceBinding's call to bindService() returns false.
+      throw Status.UNIMPLEMENTED
+          .withDescription("Service not found for intent " + intent)
+          .asException();
+    }
+    return intentServices;
+  }
+
+  // Returns a new Intent with the same action, data and categories as 'input'.
+  private static Intent sanitize(Intent input) {
+    Intent output = new Intent();
+    output.setAction(input.getAction());
+    output.setData(input.getData());
+
+    Set<String> categories = input.getCategories();
+    if (categories != null) {
+      for (String category : categories) {
+        output.addCategory(category);
+      }
+    }
+    // Don't bother copying extras and flags since AndroidComponentAddress (rightly) ignores them.
+    // Don't bother copying package or ComponentName either, since we're about to set that.
+    return output;
+  }
+
+  final class PackageChangeReceiver extends BroadcastReceiver {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+      // Get off the main thread and into the correct SynchronizationContext.
+      syncContext.executeLater(IntentNameResolver.this::resolve);
+      offloadExecutor.execute(syncContext::drain);
+    }
+  }
+
+  @SuppressLint("UnprotectedReceiver") // All of these are protected system broadcasts.
+  private void registerReceiver() {
+    checkState(receiver == null, "Already registered!");
+    receiver = new PackageChangeReceiver();
+    IntentFilter filter = new IntentFilter();
+    filter.addDataScheme("package");
+    filter.addAction(Intent.ACTION_PACKAGE_ADDED);
+    filter.addAction(Intent.ACTION_PACKAGE_CHANGED);
+    filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
+    filter.addAction(Intent.ACTION_PACKAGE_REPLACED);
+
+    targetUserContext.registerReceiver(receiver, filter);
+
+    if (Build.VERSION.SDK_INT >= 24) {
+      // Clients running in direct boot mode must refresh() when the user is unlocked because
+      // that's when `directBootAware=false` services become visible in queryIntentServices()
+      // results. ACTION_BOOT_COMPLETED would work too but it's delivered with lower priority.
+      targetUserContext.registerReceiver(receiver, new IntentFilter(Intent.ACTION_USER_UNLOCKED));
+    }
+  }
+
+  private void maybeUnregisterReceiver() {
+    if (receiver != null) { // NameResolver API contract appears to allow shutdown without start().
+      targetUserContext.unregisterReceiver(receiver);
+      receiver = null;
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/IntentNameResolverProvider.java b/binder/src/main/java/io/grpc/binder/internal/IntentNameResolverProvider.java
new file mode 100644
index 00000000000..5a3c9fcc986
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/IntentNameResolverProvider.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2025 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 android.content.Intent.URI_INTENT_SCHEME;
+
+import android.content.Intent;
+import com.google.common.collect.ImmutableSet;
+import io.grpc.NameResolver;
+import io.grpc.Uri;
+import io.grpc.NameResolver.Args;
+import io.grpc.NameResolverProvider;
+import io.grpc.binder.AndroidComponentAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Objects;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link NameResolverProvider} that handles Android-standard "intent:" target URIs, resolving
+ * them to the list of {@link AndroidComponentAddress} that match by manifest intent filter.
+ */
+public final class IntentNameResolverProvider extends NameResolverProvider {
+
+  static final String ANDROID_INTENT_SCHEME = "intent";
+
+  @Override
+  public String getDefaultScheme() {
+    return ANDROID_INTENT_SCHEME;
+  }
+
+  @Nullable
+  @Override
+  public NameResolver newNameResolver(URI targetUri, final Args args) {
+    if (Objects.equals(targetUri.getScheme(), ANDROID_INTENT_SCHEME)) {
+      return new IntentNameResolver(parseUriArg(targetUri.toString()), args);
+    } else {
+      return null;
+    }
+  }
+
+  @Nullable
+  @Override
+  public NameResolver newNameResolver(Uri targetUri, final Args args) {
+    if (Objects.equals(targetUri.getScheme(), ANDROID_INTENT_SCHEME)) {
+      return new IntentNameResolver(parseUriArg(targetUri.toString()), args);
+    } else {
+      return null;
+    }
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int priority() {
+    return 3; // Lower than DNS so we don't accidentally become the default scheme for a registry.
+  }
+
+  @Override
+  public ImmutableSet<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+    return ImmutableSet.of(AndroidComponentAddress.class);
+  }
+
+  private static Intent parseUriArg(String targetUri) {
+    try {
+      return Intent.parseUri(targetUri, URI_INTENT_SCHEME);
+    } catch (URISyntaxException e) {
+      throw new IllegalArgumentException(e);
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/LeakSafeOneWayBinder.java b/binder/src/main/java/io/grpc/binder/internal/LeakSafeOneWayBinder.java
new file mode 100644
index 00000000000..c36bc7d5bd3
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/LeakSafeOneWayBinder.java
@@ -0,0 +1,118 @@
+/*
+ * 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.IBinder;
+import android.os.Parcel;
+import androidx.annotation.BinderThread;
+import io.grpc.Internal;
+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.
+ */
+@Internal
+public final class LeakSafeOneWayBinder extends Binder {
+
+  private static final Logger logger = Logger.getLogger(LeakSafeOneWayBinder.class.getName());
+
+  @Internal
+  public interface TransactionHandler {
+    /**
+     * Delivers a binder transaction to this handler.
+     *
+     * <p>Implementations need not be thread-safe. Each invocation "happens-before" the next in the
+     * same order that transactions were sent ("oneway" semantics). However implementations must not
+     * be thread-hostile as different calls can come in on different threads.
+     *
+     * <p>{@code parcel} is only valid for the duration of this call. Ownership is retained by the
+     * caller.
+     *
+     * @param code the transaction code originally passed to {@link IBinder#transact}
+     * @param code a copy of the parcel originally passed to {@link IBinder#transact}.
+     * @return the value to return from {@link Binder#onTransact}. NB: "oneway" semantics mean this
+     *     result will not delivered to the caller of {@link IBinder#transact}
+     */
+    @BinderThread
+    boolean handleTransaction(int code, Parcel data);
+  }
+
+  @Nullable private TransactionHandler handler;
+
+  public LeakSafeOneWayBinder(TransactionHandler handler) {
+    this.handler = handler;
+  }
+
+  public void detach() {
+    setHandler(null);
+  }
+
+  /** Returns the current {@link TransactionHandler} or null if already detached. */
+  public @Nullable TransactionHandler getHandler() {
+    return handler;
+  }
+
+  /**
+   * Replaces the current {@link TransactionHandler} with `handler`.
+   *
+   * <p>{@link TransactionHandler} mutations race against incoming transactions except in the
+   * special case where the caller is already handling an incoming transaction on this same {@link
+   * LeakSafeOneWayBinder} instance. In that case, mutations are safe and the provided 'handler' is
+   * guaranteed to be used for the very next transaction. This follows from the one-at-a-time
+   * property of one-way Binder transactions as explained by {@link
+   * TransactionHandler#handleTransaction}.
+   */
+  public void setHandler(@Nullable TransactionHandler handler) {
+    this.handler = handler;
+  }
+
+  @Override
+  protected boolean onTransact(int code, Parcel parcel, Parcel reply, int flags) {
+    TransactionHandler handler = this.handler;
+    if (handler != null) {
+      try {
+        if ((flags & IBinder.FLAG_ONEWAY) == 0) {
+          logger.log(Level.WARNING, "ignoring non-oneway transaction. flags=" + flags);
+          return false;
+        }
+        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;
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/MetadataHelper.java b/binder/src/main/java/io/grpc/binder/internal/MetadataHelper.java
new file mode 100644
index 00000000000..7a8368d0b49
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/MetadataHelper.java
@@ -0,0 +1,228 @@
+/*
+ * 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.Parcel;
+import android.os.Parcelable;
+import android.util.AndroidRuntimeException;
+import io.grpc.Attributes;
+import io.grpc.InternalMetadata;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.binder.InboundParcelablePolicy;
+import io.grpc.internal.GrpcUtil;
+import java.io.IOException;
+import java.io.InputStream;
+import javax.annotation.Nullable;
+
+/**
+ * Helper class for reading &amp; writing metadata to parcels.
+ *
+ * <p>Metadata is written to a parcel as a single int for the number of name/value pairs, followed
+ * by the following pattern for each pair.
+ *
+ * <ol>
+ *   <li>name length (int)
+ *   <li>name (byte[])
+ *   <li>value length OR sentinel (int)
+ *   <li>value (byte[] OR Parcelable)
+ * </ol>
+ *
+ * The sentinel int at the start of a value may indicate bad metadata. When this happens, no more
+ * data follows the sentinel.
+ */
+public final class MetadataHelper {
+
+  /** The generic metadata marshaller we use for reading parcelables from the transport. */
+  private static final Metadata.BinaryStreamMarshaller<Parcelable> TRANSPORT_INBOUND_MARSHALLER =
+      new ParcelableMetadataMarshaller<>(null, true);
+
+  /** Indicates the following value is a parcelable. */
+  private static final int PARCELABLE_SENTINEL = -1;
+
+  private MetadataHelper() {}
+
+  /**
+   * Write a Metadata instance to a Parcel.
+   *
+   * @param parcel The {@link Parcel} to write to.
+   * @param metadata The {@link Metadata} to write.
+   */
+  public static void writeMetadata(Parcel parcel, @Nullable Metadata metadata)
+      throws StatusException, IOException {
+    int n = metadata != null ? InternalMetadata.headerCount(metadata) : 0;
+    if (n == 0) {
+      parcel.writeInt(0);
+      return;
+    }
+    Object[] serialized = InternalMetadata.serializePartial(metadata);
+    parcel.writeInt(n);
+    for (int i = 0; i < n; i++) {
+      byte[] name = (byte[]) serialized[i * 2];
+      parcel.writeInt(name.length);
+      parcel.writeByteArray(name);
+      Object value = serialized[i * 2 + 1];
+      if (value instanceof byte[]) {
+        byte[] valueBytes = (byte[]) value;
+        parcel.writeInt(valueBytes.length);
+        parcel.writeByteArray(valueBytes);
+      } else if (value instanceof ParcelableInputStream) {
+        parcel.writeInt(PARCELABLE_SENTINEL);
+        ((ParcelableInputStream) value).writeToParcel(parcel);
+      } else {
+        // An InputStream which wasn't created by ParcelableUtils, which means there's another use
+        // of Metadata.BinaryStreamMarshaller. Just read the bytes.
+        //
+        // We know that BlockPool will give us a buffer at least as large as the max space for all
+        // names and values so it'll certainly be large enough (and the limit is only 8k so this
+        // is fine).
+        byte[] buffer = BlockPool.acquireBlock();
+        try {
+          InputStream stream = (InputStream) value;
+          int total = 0;
+          while (total < buffer.length) {
+            int read = stream.read(buffer, total, buffer.length - total);
+            if (read == -1) {
+              break;
+            }
+            total += read;
+          }
+          if (total == buffer.length) {
+            throw Status.RESOURCE_EXHAUSTED
+                .withDescription("Metadata value too large")
+                .asException();
+          }
+          parcel.writeInt(total);
+          if (total > 0) {
+            parcel.writeByteArray(buffer, 0, total);
+          }
+        } finally {
+          BlockPool.releaseBlock(buffer);
+        }
+      }
+    }
+  }
+
+  /**
+   * Read a Metadata instance from a Parcel.
+   *
+   * @param parcel The {@link Parcel} to read from.
+   */
+  public static Metadata readMetadata(Parcel parcel, Attributes attributes) throws StatusException {
+    int n = parcel.readInt();
+    if (n == 0) {
+      return new Metadata();
+    }
+    // For enforcing the header-size limit. Doesn't include parcelable data.
+    int bytesRead = 0;
+    // For enforcing the maximum allowed parcelable data (see InboundParcelablePolicy).
+    int parcelableBytesRead = 0;
+    Object[] serialized = new Object[n * 2];
+    for (int i = 0; i < n; i++) {
+      int numNameBytes = parcel.readInt();
+      bytesRead += 4;
+      byte[] name = readBytesChecked(parcel, numNameBytes, bytesRead);
+      bytesRead += numNameBytes;
+      serialized[i * 2] = name;
+      int numValueBytes = parcel.readInt();
+      bytesRead += 4;
+      if (numValueBytes == PARCELABLE_SENTINEL) {
+        InboundParcelablePolicy policy = attributes.get(BinderTransport.INBOUND_PARCELABLE_POLICY);
+        if (!policy.shouldAcceptParcelableMetadataValues()) {
+          throw Status.PERMISSION_DENIED
+              .withDescription("Parcelable metadata values not allowed")
+              .asException();
+        }
+        int parcelableStartPos = parcel.dataPosition();
+        try {
+          // readParcelable(Classloader, Class<>) requires SDK 33 and at this layer we can't know
+          // value's type anyway.
+          @SuppressWarnings("deprecation")
+          Parcelable value = parcel.readParcelable(MetadataHelper.class.getClassLoader());
+          if (value == null) {
+            throw Status.INTERNAL.withDescription("Read null parcelable in metadata").asException();
+          }
+          serialized[i * 2 + 1] = InternalMetadata.parsedValue(TRANSPORT_INBOUND_MARSHALLER, value);
+        } catch (AndroidRuntimeException are) {
+          throw Status.INTERNAL
+              .withCause(are)
+              .withDescription("Failure reading parcelable in metadata")
+              .asException();
+        }
+        int parcelableSize = parcel.dataPosition() - parcelableStartPos;
+        parcelableBytesRead += parcelableSize;
+        if (parcelableBytesRead > policy.getMaxParcelableMetadataSize()) {
+          throw Status.RESOURCE_EXHAUSTED
+              .withDescription(
+                  "Inbound Parcelables too large according to policy (see InboundParcelablePolicy)")
+              .asException();
+        }
+      } else if (numValueBytes < 0) {
+        throw Status.INTERNAL.withDescription("Unrecognized metadata sentinel").asException();
+      } else {
+        byte[] value = readBytesChecked(parcel, numValueBytes, bytesRead);
+        bytesRead += numValueBytes;
+        serialized[i * 2 + 1] = value;
+      }
+    }
+    return InternalMetadata.newMetadataWithParsedValues(n, serialized);
+  }
+
+  /** Read a byte array checking that we're not reading too much. */
+  private static byte[] readBytesChecked(Parcel parcel, int numBytes, int bytesRead)
+      throws StatusException {
+    if (bytesRead + numBytes > GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE) {
+      throw Status.RESOURCE_EXHAUSTED.withDescription("Metadata too large").asException();
+    }
+    byte[] res = new byte[numBytes];
+    if (numBytes > 0) {
+      parcel.readByteArray(res);
+    }
+    return res;
+  }
+
+  /** A marshaller for passing parcelables in gRPC {@link Metadata} */
+  public static final class ParcelableMetadataMarshaller<P extends Parcelable>
+      implements Metadata.BinaryStreamMarshaller<P> {
+
+    @Nullable private final Parcelable.Creator<P> creator;
+    private final boolean immutableType;
+
+    public ParcelableMetadataMarshaller(
+        @Nullable Parcelable.Creator<P> creator, boolean immutableType) {
+      this.creator = creator;
+      this.immutableType = immutableType;
+    }
+
+    @Override
+    public InputStream toStream(P value) {
+      return new ParcelableInputStream<>(creator, value, immutableType);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public P parseStream(InputStream stream) {
+      if (stream instanceof ParcelableInputStream) {
+        return ((ParcelableInputStream<P>) stream).getParcelable();
+      } else {
+        throw new UnsupportedOperationException(
+            "Can't unmarshall a parcelable from a regular byte stream");
+      }
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/MultiMessageClientStream.java b/binder/src/main/java/io/grpc/binder/internal/MultiMessageClientStream.java
new file mode 100644
index 00000000000..9873adcb447
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/MultiMessageClientStream.java
@@ -0,0 +1,196 @@
+/*
+ * 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 io.grpc.Attributes;
+import io.grpc.Compressor;
+import io.grpc.Deadline;
+import io.grpc.DecompressorRegistry;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.internal.ClientStream;
+import io.grpc.internal.ClientStreamListener;
+import io.grpc.internal.InsightBuilder;
+import java.io.InputStream;
+import javax.annotation.Nonnull;
+
+/**
+ * The client side of a single RPC, which sends a stream of request messages.
+ *
+ * <p>An instance of this class is effectively a go-between, receiving messages from the gRPC
+ * ClientCall instance (via calls on the ClientStream interface we implement), and sending them out
+ * on the transport, as well as receiving messages from the transport, and passing the resultant
+ * data back to the gRPC ClientCall instance (via calls on the ClientStreamListener instance we're
+ * given).
+ *
+ * <p>These two communication directions are largely independent of each other, with the {@link
+ * Outbound} handling the gRPC to transport direction, and the {@link Inbound} class handling
+ * transport to gRPC direction.
+ *
+ * <p>Since the Inbound and Outbound halves are largely independent, their state is also
+ * synchronized independently.
+ */
+final class MultiMessageClientStream implements ClientStream {
+
+  private final Inbound.ClientInbound inbound;
+  private final Outbound.ClientOutbound outbound;
+  private final Attributes attributes;
+
+  MultiMessageClientStream(
+      Inbound.ClientInbound inbound, Outbound.ClientOutbound outbound, Attributes attributes) {
+    this.inbound = inbound;
+    this.outbound = outbound;
+    this.attributes = attributes;
+  }
+
+  @Override
+  public void start(ClientStreamListener listener) {
+    synchronized (inbound) {
+      inbound.init(outbound, listener);
+    }
+    if (outbound.isReady()) {
+      listener.onReady();
+    }
+    try {
+      synchronized (outbound) {
+        // The ClientStream contract promises no more header changes after start().
+        outbound.onPrefixReady();
+        outbound.send();
+      }
+    } catch (StatusException se) {
+      synchronized (inbound) {
+        inbound.closeAbnormal(se.getStatus());
+      }
+    }
+  }
+
+  @Override
+  public void request(int numMessages) {
+    synchronized (inbound) {
+      inbound.requestMessages(numMessages);
+    }
+  }
+
+  @Override
+  public boolean isReady() {
+    return outbound.isReady();
+  }
+
+  @Override
+  public void writeMessage(InputStream message) {
+    try {
+      synchronized (outbound) {
+        outbound.addMessage(message);
+        outbound.send();
+      }
+    } catch (StatusException se) {
+      synchronized (inbound) {
+        inbound.closeAbnormal(se.getStatus());
+      }
+    }
+  }
+
+  @Override
+  public void halfClose() {
+    try {
+      synchronized (outbound) {
+        outbound.sendHalfClose();
+      }
+    } catch (StatusException se) {
+      synchronized (inbound) {
+        inbound.closeAbnormal(se.getStatus());
+      }
+    }
+  }
+
+  @Override
+  public void cancel(Status status) {
+    synchronized (inbound) {
+      inbound.closeOnCancel(status);
+    }
+  }
+
+  @Override
+  public void setDeadline(@Nonnull Deadline deadline) {
+    synchronized (outbound) {
+      outbound.setDeadline(deadline);
+    }
+  }
+
+  @Override
+  public Attributes getAttributes() {
+    return attributes;
+  }
+
+  @Override
+  public final String toString() {
+    return "MultiMessageClientStream[" + inbound + "/" + outbound + "]";
+  }
+
+  // =====================
+  // Misc stubbed & unsupported methods.
+
+  @Override
+  public final void flush() {
+    // Ignore.
+  }
+
+  @Override
+  public final void setCompressor(Compressor compressor) {
+    // Ignore.
+  }
+
+  @Override
+  public final void setMessageCompression(boolean enable) {
+    // Ignore.
+  }
+
+  @Override
+  public void setAuthority(String authority) {
+    // Ignore.
+  }
+
+  @Override
+  public void setMaxInboundMessageSize(int maxSize) {
+    // Ignore.
+  }
+
+  @Override
+  public void setMaxOutboundMessageSize(int maxSize) {
+    // Ignore.
+  }
+
+  @Override
+  public void appendTimeoutInsight(InsightBuilder insight) {
+    // Ignore
+  }
+
+  @Override
+  public void setFullStreamDecompression(boolean fullStreamDecompression) {
+    // Ignore.
+  }
+
+  @Override
+  public void setDecompressorRegistry(DecompressorRegistry decompressorRegistry) {
+    // Ignore.
+  }
+
+  @Override
+  public void optimizeForDirectExecutor() {
+    // Ignore.
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/MultiMessageServerStream.java b/binder/src/main/java/io/grpc/binder/internal/MultiMessageServerStream.java
new file mode 100644
index 00000000000..f54769caefa
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/MultiMessageServerStream.java
@@ -0,0 +1,187 @@
+/*
+ * 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 io.grpc.Attributes;
+import io.grpc.Compressor;
+import io.grpc.Decompressor;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.internal.ServerStream;
+import io.grpc.internal.ServerStreamListener;
+import io.grpc.internal.StatsTraceContext;
+import java.io.InputStream;
+import javax.annotation.Nullable;
+
+/**
+ * The server side of a single RPC, which sends a stream of response messages.
+ *
+ * <p>An instance of this class is effectively a go-between, receiving messages from the gRPC
+ * ServerCall instance (via calls on the ServerStream interface we implement), and sending them out
+ * on the transport, as well as receiving messages from the transport, and passing the resultant
+ * data back to the gRPC ServerCall instance (via calls on the ServerStreamListener instance we're
+ * given).
+ *
+ * <p>These two communication directions are largely independent of each other, with the {@link
+ * Outbound} handling the gRPC to transport direction, and the {@link Inbound} class handling
+ * transport to gRPC direction.
+ *
+ * <p>Since the Inbound and Outbound halves are largely independent, their state is also
+ * synchronized independently.
+ */
+final class MultiMessageServerStream implements ServerStream {
+
+  private final Inbound.ServerInbound inbound;
+  private final Outbound.ServerOutbound outbound;
+  private final Attributes attributes;
+
+  MultiMessageServerStream(
+      Inbound.ServerInbound inbound, Outbound.ServerOutbound outbound, Attributes attributes) {
+    this.inbound = inbound;
+    this.outbound = outbound;
+    this.attributes = attributes;
+  }
+
+  @Override
+  public void setListener(ServerStreamListener listener) {
+    synchronized (inbound) {
+      inbound.init(outbound, listener);
+    }
+  }
+
+  @Override
+  public void setOnReadyThreshold(int numBytes) {
+    // No-op
+  }
+
+  @Override
+  public boolean isReady() {
+    return outbound.isReady();
+  }
+
+  @Override
+  public void request(int numMessages) {
+    synchronized (inbound) {
+      inbound.requestMessages(numMessages);
+    }
+  }
+
+  @Override
+  public void writeHeaders(Metadata headers, boolean flush) {
+    try {
+      synchronized (outbound) {
+        outbound.sendHeaders(headers);
+      }
+    } catch (StatusException se) {
+      synchronized (inbound) {
+        inbound.closeAbnormal(se.getStatus());
+      }
+    }
+  }
+
+  @Override
+  public void writeMessage(InputStream message) {
+    try {
+      synchronized (outbound) {
+        outbound.addMessage(message);
+        outbound.send();
+      }
+    } catch (StatusException se) {
+      synchronized (inbound) {
+        inbound.closeAbnormal(se.getStatus());
+      }
+    }
+  }
+
+  @Override
+  public void close(Status status, Metadata trailers) {
+    try {
+      synchronized (outbound) {
+        outbound.sendClose(status, trailers);
+      }
+      synchronized (inbound) {
+        inbound.onCloseSent(status);
+      }
+    } catch (StatusException se) {
+      synchronized (inbound) {
+        inbound.closeAbnormal(se.getStatus());
+      }
+    }
+  }
+
+  @Override
+  public void cancel(Status status) {
+    synchronized (inbound) {
+      inbound.closeOnCancel(status);
+    }
+  }
+
+  @Override
+  public StatsTraceContext statsTraceContext() {
+    return outbound.getStatsTraceContext();
+  }
+
+  @Override
+  public Attributes getAttributes() {
+    return attributes;
+  }
+
+  @Nullable
+  @Override
+  public String getAuthority() {
+    return attributes.get(BinderTransport.SERVER_AUTHORITY);
+  }
+
+  @Override
+  public String toString() {
+    return "MultiMessageServerStream[" + inbound + "/" + outbound + "]";
+  }
+
+  // =====================
+  // Misc stubbed & unsupported methods.
+
+  @Override
+  public final void flush() {
+    // Ignore.
+  }
+
+  @Override
+  public final void setCompressor(Compressor compressor) {
+    // Ignore.
+  }
+
+  @Override
+  public final void setMessageCompression(boolean enable) {
+    // Ignore.
+  }
+
+  @Override
+  public void setDecompressor(Decompressor decompressor) {
+    // Ignore.
+  }
+
+  @Override
+  public void optimizeForDirectExecutor() {
+    // Ignore.
+  }
+
+  @Override
+  public int streamId() {
+    return -1;
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/OneWayBinderProxy.java b/binder/src/main/java/io/grpc/binder/internal/OneWayBinderProxy.java
new file mode 100644
index 00000000000..fd883ca3b62
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/OneWayBinderProxy.java
@@ -0,0 +1,158 @@
+package io.grpc.binder.internal;
+
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.os.RemoteException;
+import io.grpc.internal.SerializingExecutor;
+import java.util.concurrent.Executor;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Wraps an {@link IBinder} with a safe and uniformly asynchronous transaction API.
+ *
+ * <p>When the target of your bindService() call is hosted in a different process, Android supplies
+ * you with an {@link IBinder} that proxies your transactions to the remote {@link
+ * android.os.Binder} instance. But when the target Service is hosted in the same process, Android
+ * supplies you with that local instance of {@link android.os.Binder} directly. This in-process
+ * implementation of {@link IBinder} is problematic for clients that want "oneway" transaction
+ * semantics because its transact() method simply invokes onTransact() on the caller's thread, even
+ * when the {@link IBinder#FLAG_ONEWAY} flag is set. Even though this behavior is documented, its
+ * consequences with respect to reentrancy, locking, and transaction dispatch order can be
+ * surprising and dangerous.
+ *
+ * <p>Wrap your {@link IBinder}s with an instance of this class to ensure the following
+ * out-of-process "oneway" semantics are always in effect:
+ *
+ * <ul>
+ *   <li>transact() merely enqueues the transaction for processing. It doesn't wait for onTransact()
+ *       to complete.
+ *   <li>transact() may fail for programming errors or transport-layer errors that are immediately
+ *       obvious on the caller's side, but never for an Exception or false return value from
+ *       onTransact().
+ *   <li>onTransact() runs without holding any of the locks held by the thread calling transact().
+ *   <li>onTransact() calls are dispatched one at a time in the same happens-before order as the
+ *       corresponding calls to transact().
+ * </ul>
+ *
+ * <p>NB: One difference that this class can't conceal is that calls to onTransact() are serialized
+ * per {@link OneWayBinderProxy} instance, not per instance of the wrapped {@link IBinder}. An
+ * android.os.Binder with in-process callers could still receive concurrent calls to onTransact() on
+ * different threads if callers used different {@link OneWayBinderProxy} instances or if that Binder
+ * also had out-of-process callers.
+ */
+public abstract class OneWayBinderProxy {
+  private static final Logger logger = Logger.getLogger(OneWayBinderProxy.class.getName());
+  protected final IBinder delegate;
+
+  protected OneWayBinderProxy(IBinder iBinder) {
+    this.delegate = iBinder;
+  }
+
+  /**
+   * Returns a new instance of {@link OneWayBinderProxy} that wraps {@code iBinder}.
+   *
+   * @param iBinder the binder to wrap
+   * @param inProcessThreadHopExecutor a non-direct Executor used to dispatch calls to onTransact(),
+   *     if necessary
+   * @return a new instance of {@link OneWayBinderProxy}
+   */
+  public static OneWayBinderProxy wrap(IBinder iBinder, Executor inProcessThreadHopExecutor) {
+    return (iBinder instanceof Binder)
+        ? new InProcessImpl(iBinder, inProcessThreadHopExecutor)
+        : new OutOfProcessImpl(iBinder);
+  }
+
+  /**
+   * An abstract function that decorates instances of {@link OneWayBinderProxy}.
+   *
+   * <p>See https://en.wikipedia.org/wiki/Decorator_pattern.
+   */
+  public interface Decorator {
+    /**
+     * Returns an instance of {@link OneWayBinderProxy} that decorates {@code input} with some new
+     * behavior.
+     */
+    OneWayBinderProxy decorate(OneWayBinderProxy input);
+  }
+
+  /** A {@link Decorator} that does nothing. */
+  public static final Decorator IDENTITY_DECORATOR = (x) -> x;
+
+  /**
+   * Enqueues a transaction for the wrapped {@link IBinder} with guaranteed "oneway" semantics.
+   *
+   * <p>NB: Unlike {@link IBinder#transact}, implementations of this method take ownership of the
+   * {@code data} Parcel. When this method returns, {@code data} will normally be empty, but callers
+   * should still unconditionally {@link ParcelHolder#close()} it to avoid a leak in case they or
+   * the implementation throws before ownership is transferred.
+   *
+   * @param code identifies the type of this transaction
+   * @param data a non-empty container of the Parcel to be sent
+   * @throws RemoteException if the transaction could not even be queued for dispatch on the server.
+   *     Failures from {@link Binder#onTransact} are *never* reported this way.
+   */
+  public abstract void transact(int code, ParcelHolder data) throws RemoteException;
+
+  /**
+   * Returns the wrapped {@link IBinder} for the purpose of calling methods other than {@link
+   * IBinder#transact(int, Parcel, Parcel, int)}.
+   */
+  public IBinder getDelegate() {
+    return delegate;
+  }
+
+  static class OutOfProcessImpl extends OneWayBinderProxy {
+    OutOfProcessImpl(IBinder iBinder) {
+      super(iBinder);
+    }
+
+    @Override
+    public void transact(int code, ParcelHolder data) throws RemoteException {
+      if (!transactAndRecycleParcel(code, data.release())) {
+        // This cannot happen (see g/android-binder/c/jM4NvS234Rw) but, just in case, let the caller
+        // handle it along with all the other possible transport-layer errors.
+        throw new RemoteException("BinderProxy#transact(" + code + ", FLAG_ONEWAY) returned false");
+      }
+    }
+  }
+
+  protected boolean transactAndRecycleParcel(int code, Parcel data) throws RemoteException {
+    try {
+      return delegate.transact(code, data, null, IBinder.FLAG_ONEWAY);
+    } finally {
+      data.recycle();
+    }
+  }
+
+  static class InProcessImpl extends OneWayBinderProxy {
+    private final SerializingExecutor executor;
+
+    InProcessImpl(IBinder binder, Executor executor) {
+      super(binder);
+      this.executor = new SerializingExecutor(executor);
+    }
+
+    @Override
+    public void transact(int code, ParcelHolder wrappedParcel) {
+      // Transfer ownership, taking care to handle any RuntimeException from execute().
+      Parcel parcel = wrappedParcel.get();
+      executor.execute(
+          () -> {
+            try {
+              if (!transactAndRecycleParcel(code, parcel)) {
+                // onTransact() in our same process returned this. Ignore it, just like Android
+                // would have if the android.os.Binder was in another process.
+                logger.log(Level.FINEST, "A oneway transaction was not understood - ignoring");
+              }
+            } catch (Exception e) {
+              // onTransact() in our same process threw this. Ignore it, just like Android would
+              // have if the android.os.Binder was in another process.
+              logger.log(Level.FINEST, "A oneway transaction threw - ignoring", e);
+            }
+          });
+      wrappedParcel.release();
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/Outbound.java b/binder/src/main/java/io/grpc/binder/internal/Outbound.java
new file mode 100644
index 00000000000..7db5bf0fbe4
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/Outbound.java
@@ -0,0 +1,503 @@
+/*
+ * 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.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.internal.GrpcUtil.TIMEOUT_KEY;
+
+import android.os.Parcel;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Deadline;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.internal.StatsTraceContext;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * Sends the set of outbound transactions for a single BinderStream (rpc).
+ *
+ * <p>Handles buffering internally for flow control, and splitting large messages into multiple
+ * transactions where necessary.
+ *
+ * <p>Also handles reporting to the {@link StatsTraceContext}.
+ *
+ * <p>A note on threading: All calls into this class are expected to hold this object as a lock.
+ * However, since calls from gRPC are serialized already, the only reason we need to care about
+ * threading is the onTransportReady() call (when flow-control unblocks us).
+ *
+ * <p>To reduce the cost of locking, BinderStream endeavors to make only a single call to this class
+ * for single-message calls (the most common).
+ *
+ * <p><b>IMPORTANT:</b> To avoid potential deadlocks, this class may only call unsynchronized
+ * methods of the BinderTransport class.
+ */
+abstract class Outbound {
+
+  private final BinderTransport transport;
+  private final int callId;
+  private final StatsTraceContext statsTraceContext;
+
+  enum State {
+    INITIAL,
+    PREFIX_SENT,
+    ALL_MESSAGES_SENT,
+    SUFFIX_SENT,
+    CLOSED,
+  }
+
+  /*
+   * Represents the state of data we've sent in binder transactions.
+   */
+  @GuardedBy("this")
+  private State outboundState = State.INITIAL; // Represents what we've delivered.
+
+  // ----------------------------------
+  // For reporting to StatsTraceContext.
+  /** Indicates we're ready to send the prefix. */
+  private boolean prefixReady;
+
+  @Nullable private InputStream firstMessage;
+
+  @Nullable private Queue<InputStream> messageQueue;
+
+  /**
+   * Indicates we have everything ready to send the suffix. This implies we have all outgoing
+   * messages, and any additional data which needs to be send after the last message. (e.g.
+   * trailers).
+   */
+  private boolean suffixReady;
+
+  /**
+   * The index of the next transaction we'll send, allowing the receiver to re-assemble out-of-order
+   * messages.
+   */
+  @GuardedBy("this")
+  private int transactionIndex;
+
+  // ----------------------------------
+  // For reporting to StatsTraceContext.
+  private int numDeliveredMessages;
+  private int messageSize;
+
+  private Outbound(BinderTransport transport, int callId, StatsTraceContext statsTraceContext) {
+    this.transport = transport;
+    this.callId = callId;
+    this.statsTraceContext = statsTraceContext;
+  }
+
+  final StatsTraceContext getStatsTraceContext() {
+    return statsTraceContext;
+  }
+
+  /** Call to add a message to be delivered. Implies onPrefixReady(). */
+  @GuardedBy("this")
+  final void addMessage(InputStream message) throws StatusException {
+    onPrefixReady(); // This is implied.
+    if (messageQueue != null) {
+      messageQueue.add(message);
+    } else if (firstMessage == null) {
+      firstMessage = message;
+    } else {
+      messageQueue = new ConcurrentLinkedQueue<>();
+      messageQueue.add(message);
+    }
+  }
+
+  @GuardedBy("this")
+  protected final void onPrefixReady() {
+    this.prefixReady = true;
+  }
+
+  @GuardedBy("this")
+  protected final void onSuffixReady() {
+    this.suffixReady = true;
+  }
+
+  // =====================
+  // Updates to delivery.
+  @GuardedBy("this")
+  private void onOutboundState(State outboundState) {
+    checkTransition(this.outboundState, outboundState);
+    this.outboundState = outboundState;
+  }
+
+  // ===================
+  // Internals.
+  @GuardedBy("this")
+  protected final boolean messageAvailable() {
+    if (messageQueue != null) {
+      return !messageQueue.isEmpty();
+    } else if (firstMessage != null) {
+      return numDeliveredMessages == 0;
+    } else {
+      return false;
+    }
+  }
+
+  @Nullable
+  @GuardedBy("this")
+  private final InputStream peekNextMessage() {
+    if (numDeliveredMessages == 0) {
+      return firstMessage;
+    } else if (messageQueue != null) {
+      return messageQueue.peek();
+    }
+    return null;
+  }
+
+  @GuardedBy("this")
+  private final boolean canSend() {
+    switch (outboundState) {
+      case INITIAL:
+        if (!prefixReady) {
+          return false;
+        }
+        break;
+      case PREFIX_SENT:
+        // We can only send something if we have messages or the suffix.
+        // Note that if we have the suffix but no messages in this state, it means we've been closed
+        // early.
+        if (!messageAvailable() && !suffixReady) {
+          return false;
+        }
+        break;
+      case ALL_MESSAGES_SENT:
+        if (!suffixReady) {
+          return false;
+        }
+        break;
+      default:
+        return false;
+    }
+    return isReady();
+  }
+
+  final boolean isReady() {
+    return transport.isReady();
+  }
+
+  @GuardedBy("this")
+  final void onTransportReady() throws StatusException {
+    // The transport has become ready, attempt sending.
+    send();
+  }
+
+  @GuardedBy("this")
+  final void send() throws StatusException {
+    while (canSend()) {
+      try {
+        sendInternal();
+      } catch (StatusException se) {
+        // Ensure we don't send anything else and rethrow.
+        onOutboundState(State.CLOSED);
+        throw se;
+      }
+    }
+  }
+
+  @GuardedBy("this")
+  @SuppressWarnings("fallthrough")
+  protected final void sendInternal() throws StatusException {
+    try (ParcelHolder parcel = ParcelHolder.obtain()) {
+      int flags = 0;
+      parcel.get().writeInt(0); // Placeholder for flags. Will be filled in below.
+      parcel.get().writeInt(transactionIndex++);
+      switch (outboundState) {
+        case INITIAL:
+          flags |= TransactionUtils.FLAG_PREFIX;
+          flags |= writePrefix(parcel.get());
+          onOutboundState(State.PREFIX_SENT);
+          if (!messageAvailable() && !suffixReady) {
+            break;
+          }
+          // Fall-through.
+        case PREFIX_SENT:
+          InputStream messageStream = peekNextMessage();
+          if (messageStream != null) {
+            flags |= TransactionUtils.FLAG_MESSAGE_DATA;
+            flags |= writeMessageData(parcel.get(), messageStream);
+          } else {
+            checkState(suffixReady);
+          }
+          if (suffixReady && !messageAvailable()) {
+            onOutboundState(State.ALL_MESSAGES_SENT);
+          } else {
+            // There's still more message data to deliver, break out.
+            break;
+          }
+          // Fall-through.
+        case ALL_MESSAGES_SENT:
+          flags |= TransactionUtils.FLAG_SUFFIX;
+          flags |= writeSuffix(parcel.get());
+          onOutboundState(State.SUFFIX_SENT);
+          break;
+        default:
+          throw new AssertionError();
+      }
+      TransactionUtils.fillInFlags(parcel.get(), flags);
+      int dataSize = parcel.get().dataSize();
+      transport.sendTransaction(callId, parcel);
+      statsTraceContext.outboundWireSize(dataSize);
+      statsTraceContext.outboundUncompressedSize(dataSize);
+    } catch (IOException e) {
+      throw Status.INTERNAL.withCause(e).asException();
+    }
+  }
+
+  protected final void unregister() {
+    transport.unregisterCall(callId);
+  }
+
+  @Override
+  public synchronized String toString() {
+    return getClass().getSimpleName()
+        + "[S="
+        + outboundState
+        + "/NDM="
+        + numDeliveredMessages
+        + "]";
+  }
+
+  /**
+   * Write prefix data to the given {@link Parcel}.
+   *
+   * @param parcel the transaction parcel to write to.
+   * @return any additional flags to be set on the transaction.
+   */
+  @GuardedBy("this")
+  protected abstract int writePrefix(Parcel parcel) throws IOException, StatusException;
+
+  /**
+   * Write suffix data to the given {@link Parcel}.
+   *
+   * @param parcel the transaction parcel to write to.
+   * @return any additional flags to be set on the transaction.
+   */
+  @GuardedBy("this")
+  protected abstract int writeSuffix(Parcel parcel) throws IOException, StatusException;
+
+  @GuardedBy("this")
+  private final int writeMessageData(Parcel parcel, InputStream stream) throws IOException {
+    int flags = 0;
+    boolean dataRemaining = false;
+    if (stream instanceof ParcelableInputStream) {
+      flags |= TransactionUtils.FLAG_MESSAGE_DATA_IS_PARCELABLE;
+      messageSize = ((ParcelableInputStream) stream).writeToParcel(parcel);
+    } else {
+      byte[] block = BlockPool.acquireBlock();
+      try {
+        int size = stream.read(block);
+        if (size <= 0) {
+          parcel.writeInt(0);
+        } else {
+          parcel.writeInt(size);
+          parcel.writeByteArray(block, 0, size);
+          messageSize += size;
+          if (size == block.length) {
+            flags |= TransactionUtils.FLAG_MESSAGE_DATA_IS_PARTIAL;
+            dataRemaining = true;
+          }
+        }
+      } finally {
+        BlockPool.releaseBlock(block);
+      }
+    }
+    if (!dataRemaining) {
+      stream.close();
+      int index = numDeliveredMessages++;
+      if (index > 0) {
+        checkNotNull(messageQueue).poll();
+      }
+      statsTraceContext.outboundMessage(index);
+      statsTraceContext.outboundMessageSent(index, messageSize, messageSize);
+      messageSize = 0;
+    }
+    return flags;
+  }
+
+  // ======================================
+  // Client-side outbound transactions.
+  static final class ClientOutbound extends Outbound {
+
+    private final MethodDescriptor<?, ?> method;
+    private final Metadata headers;
+    private final StatsTraceContext statsTraceContext;
+
+    ClientOutbound(
+        BinderTransport transport,
+        int callId,
+        MethodDescriptor<?, ?> method,
+        Metadata headers,
+        StatsTraceContext statsTraceContext) {
+      super(transport, callId, statsTraceContext);
+      this.method = method;
+      this.headers = headers;
+      this.statsTraceContext = statsTraceContext;
+    }
+
+    @Override
+    @GuardedBy("this")
+    protected int writePrefix(Parcel parcel) throws IOException, StatusException {
+      parcel.writeString(method.getFullMethodName());
+      MetadataHelper.writeMetadata(parcel, headers);
+      statsTraceContext.clientOutboundHeaders();
+      if (method.getType().serverSendsOneMessage()) {
+        return TransactionUtils.FLAG_EXPECT_SINGLE_MESSAGE;
+      }
+      return 0;
+    }
+
+    // Implies onPrefixReady() and onSuffixReady().
+    @GuardedBy("this")
+    void sendSingleMessageAndHalfClose(@Nullable InputStream singleMessage) throws StatusException {
+      if (singleMessage != null) {
+        addMessage(singleMessage);
+      }
+      onSuffixReady();
+      send();
+    }
+
+    @GuardedBy("this")
+    void sendHalfClose() throws StatusException {
+      onSuffixReady();
+      send();
+    }
+
+    @Override
+    @GuardedBy("this")
+    protected int writeSuffix(Parcel parcel) throws IOException {
+      // Client doesn't include anything in the suffix.
+      return 0;
+    }
+
+    // Must not be called after onPrefixReady() (explicitly or via another method that implies it).
+    @GuardedBy("this")
+    void setDeadline(Deadline deadline) {
+      headers.discardAll(TIMEOUT_KEY);
+      headers.put(TIMEOUT_KEY, deadline.timeRemaining(TimeUnit.NANOSECONDS));
+    }
+  }
+
+  // ======================================
+  // Server-side outbound transactions.
+  static final class ServerOutbound extends Outbound {
+    @GuardedBy("this")
+    @Nullable
+    private Metadata headers;
+
+    @GuardedBy("this")
+    @Nullable
+    private Status closeStatus;
+
+    @GuardedBy("this")
+    @Nullable
+    private Metadata trailers;
+
+    ServerOutbound(BinderTransport transport, int callId, StatsTraceContext statsTraceContext) {
+      super(transport, callId, statsTraceContext);
+    }
+
+    @GuardedBy("this")
+    void sendHeaders(Metadata headers) throws StatusException {
+      this.headers = headers;
+      onPrefixReady();
+      send();
+    }
+
+    @Override
+    @GuardedBy("this")
+    protected int writePrefix(Parcel parcel) throws IOException, StatusException {
+      MetadataHelper.writeMetadata(parcel, headers);
+      return 0;
+    }
+
+    @GuardedBy("this")
+    void sendSingleMessageAndClose(
+        @Nullable Metadata pendingHeaders,
+        @Nullable InputStream pendingSingleMessage,
+        Status closeStatus,
+        Metadata trailers)
+        throws StatusException {
+      if (this.closeStatus != null) {
+        return;
+      }
+      if (pendingHeaders != null) {
+        this.headers = pendingHeaders;
+      }
+      onPrefixReady();
+      if (pendingSingleMessage != null) {
+        addMessage(pendingSingleMessage);
+      }
+      checkState(this.trailers == null);
+      this.closeStatus = closeStatus;
+      this.trailers = trailers;
+      onSuffixReady();
+      send();
+    }
+
+    @GuardedBy("this")
+    void sendClose(Status closeStatus, Metadata trailers) throws StatusException {
+      if (this.closeStatus != null) {
+        return;
+      }
+      checkState(this.trailers == null);
+      this.closeStatus = closeStatus;
+      this.trailers = trailers;
+      onPrefixReady();
+      onSuffixReady();
+      send();
+    }
+
+    @Override
+    @GuardedBy("this")
+    protected int writeSuffix(Parcel parcel) throws IOException, StatusException {
+      int flags = TransactionUtils.writeStatus(parcel, closeStatus);
+      MetadataHelper.writeMetadata(parcel, trailers);
+      // TODO: This is an ugly place for this side-effect.
+      unregister();
+      return flags;
+    }
+  }
+
+  // ======================================
+  // Helper methods.
+  private static void checkTransition(State current, State next) {
+    switch (next) {
+      case PREFIX_SENT:
+        checkState(current == State.INITIAL);
+        break;
+      case ALL_MESSAGES_SENT:
+        checkState(current == State.PREFIX_SENT);
+        break;
+      case SUFFIX_SENT:
+        checkState(current == State.ALL_MESSAGES_SENT);
+        break;
+      case CLOSED: // hah.
+        break;
+      default:
+        throw new AssertionError();
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/ParcelHolder.java b/binder/src/main/java/io/grpc/binder/internal/ParcelHolder.java
new file mode 100644
index 00000000000..cad8da9712f
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/ParcelHolder.java
@@ -0,0 +1,76 @@
+package io.grpc.binder.internal;
+
+import static com.google.common.base.Preconditions.checkState;
+
+import android.os.Parcel;
+import com.google.common.annotations.VisibleForTesting;
+import java.io.Closeable;
+import javax.annotation.Nullable;
+
+/**
+ * Wraps a {@link Parcel} from the static {@link Parcel#obtain()} pool with methods that make it
+ * easy to eventually {@link Parcel#recycle()} it.
+ */
+class ParcelHolder implements Closeable {
+
+  @Nullable private Parcel parcel;
+
+  /**
+   * Creates a new instance that owns a {@link Parcel} newly obtained from Android's object pool.
+   */
+  public static ParcelHolder obtain() {
+    return new ParcelHolder(Parcel.obtain());
+  }
+
+  /** Creates a new instance taking ownership of the specified {@code parcel}. */
+  public ParcelHolder(Parcel parcel) {
+    this.parcel = parcel;
+  }
+
+  /**
+   * Returns the wrapped {@link Parcel} if we still own it.
+   *
+   * @throws IllegalStateException if ownership has already been given up by {@link #release()}
+   */
+  public Parcel get() {
+    checkState(parcel != null, "get() after close()/release()");
+    return parcel;
+  }
+
+  /**
+   * Returns the wrapped {@link Parcel} and releases ownership of it.
+   *
+   * @throws IllegalStateException if ownership has already been given up by {@link #release()}
+   */
+  public Parcel release() {
+    Parcel result = get();
+    this.parcel = null;
+    return result;
+  }
+
+  /**
+   * Recycles the wrapped {@link Parcel} to Android's object pool, if we still own it.
+   *
+   * <p>Otherwise, this method has no effect.
+   */
+  @Override
+  public void close() {
+    if (parcel != null) {
+      parcel.recycle();
+      parcel = null;
+    }
+  }
+
+  /**
+   * Returns true iff this container no longer owns a {@link Parcel}.
+   *
+   * <p>{@link #isEmpty()} is true after all call to {@link #close()} or {@link #release()}.
+   *
+   * <p>Typically only used for debugging or testing since Parcel-owning code should be calling
+   * {@link #close()} unconditionally.
+   */
+  @VisibleForTesting
+  public boolean isEmpty() {
+    return parcel == null;
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/ParcelableInputStream.java b/binder/src/main/java/io/grpc/binder/internal/ParcelableInputStream.java
new file mode 100644
index 00000000000..5f1132de54f
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/ParcelableInputStream.java
@@ -0,0 +1,212 @@
+/*
+ * 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.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import javax.annotation.Nullable;
+
+/**
+ * An inputstream to serialize a single Android Parcelable object for gRPC calls, with support for
+ * serializing to a native Android Parcel, and for when a Parcelable is sent in-process.
+ *
+ * <p><b>Important:</b> It's not actually possible to marshall a parcelable to raw bytes without
+ * losing data, since a parcelable may contain file descriptors. While this class <i>does</i>
+ * support marshalling into bytes, this is only supported for the purposes of debugging/logging, and
+ * we intentionally don't support unmarshalling back to a parcelable.
+ *
+ * <p>This class really just wraps a Parcelable instance and masquerardes as an inputstream. See
+ * {@code ProtoLiteUtils} for a similar example of this pattern.
+ *
+ * <p>An instance of this class maybe be created from two sources.
+ *
+ * <ul>
+ *   <li>To wrap a Parcelable instance we plan to send.
+ *   <li>To wrap a Parcelable instance we've just received (and read from a Parcel).
+ * </ul>
+ *
+ * <p>In the first case, we expect to serialize to a {@link Parcel}, with a call to {@link
+ * #writeToParcel}.
+ *
+ * <p>In the second case, we only expect the Parcelable to be fetched (and not re-serialized).
+ *
+ * <p>For in-process gRPC calls, the same InputStream used to send the Parcelable (the first case),
+ * will also be used to parse the parcelable from the stream, in which case we shortcut serializing
+ * internally (possibly skipping it entirely if the instance is immutable).
+ */
+final class ParcelableInputStream<P extends Parcelable> extends InputStream {
+  @Nullable private final Parcelable.Creator<P> creator;
+  private final boolean safeToReturnValue;
+  private final P value;
+
+  @Nullable InputStream delegateStream;
+
+  @Nullable P sharableValue;
+
+  ParcelableInputStream(
+      @Nullable Parcelable.Creator<P> creator, P value, boolean safeToReturnValue) {
+    this.creator = creator;
+    this.value = value;
+    this.safeToReturnValue = safeToReturnValue;
+    // If we're not given a creator, the value must be safe to return unchanged.
+    checkArgument(creator != null || safeToReturnValue);
+  }
+
+  /**
+   * Create a stream from a {@link Parcel} object. Note that this immediately reads the Parcelable
+   * object, allowing the Parcel to be recycled after calling this method.
+   */
+  @SuppressWarnings("unchecked")
+  static <P extends Parcelable> ParcelableInputStream<P> readFromParcel(
+      Parcel parcel, ClassLoader classLoader) {
+    // readParcelable(Classloader, Class<P>) requires SDK 33 and this class isn't typesafe anyway.
+    @SuppressWarnings("deprecation")
+    P value = (P) parcel.readParcelable(classLoader);
+    return new ParcelableInputStream<>(null, value, true);
+  }
+
+  /** Create a stream for a Parcelable object. */
+  static <P extends Parcelable> ParcelableInputStream<P> forInstance(
+      P value, Parcelable.Creator<P> creator) {
+    return new ParcelableInputStream<>(creator, value, false);
+  }
+
+  /** Create a stream for a Parcelable object, treating the object as immutable. */
+  static <P extends Parcelable> ParcelableInputStream<P> forImmutableInstance(
+      P value, Parcelable.Creator<P> creator) {
+    return new ParcelableInputStream<>(creator, value, true);
+  }
+
+  private InputStream getDelegateStream() {
+    if (delegateStream == null) {
+      Parcel parcel = Parcel.obtain();
+      parcel.writeParcelable(value, 0);
+      byte[] res = parcel.marshall();
+      parcel.recycle();
+      delegateStream = new ByteArrayInputStream(res);
+    }
+    return delegateStream;
+  }
+
+  @Override
+  public int read() throws IOException {
+    return getDelegateStream().read();
+  }
+
+  @Override
+  public int read(byte[] b, int off, int len) throws IOException {
+    return getDelegateStream().read(b, off, len);
+  }
+
+  @Override
+  public long skip(long n) throws IOException {
+    if (n <= 0) {
+      return 0;
+    }
+    return getDelegateStream().skip(n);
+  }
+
+  @Override
+  public int available() throws IOException {
+    return getDelegateStream().available();
+  }
+
+  @Override
+  public void close() throws IOException {
+    if (delegateStream != null) {
+      delegateStream.close();
+    }
+  }
+
+  @Override
+  public void mark(int readLimit) {
+    // If there's no delegate stream yet, the current position is 0. That's the same
+    // as the default mark position, so there's nothing to do.
+    if (delegateStream != null) {
+      delegateStream.mark(readLimit);
+    }
+  }
+
+  @Override
+  public void reset() throws IOException {
+    if (delegateStream != null) {
+      delegateStream.reset();
+    }
+  }
+
+  @Override
+  public boolean markSupported() {
+    // We know our delegate (ByteArrayInputStream) supports mark/reset.
+    return true;
+  }
+
+  /**
+   * Write the {@link Parcelable} this stream wraps to the given {@link Parcel}.
+   *
+   * <p>This will retain any android-specific data (e.g. file descriptors) which can't simply be
+   * serialized to bytes.
+   *
+   * @return The number of bytes written to the parcel.
+   */
+  int writeToParcel(Parcel parcel) {
+    int startPos = parcel.dataPosition();
+    parcel.writeParcelable(value, value.describeContents());
+    return parcel.dataPosition() - startPos;
+  }
+
+  /**
+   * Get the parcelable as if it had been serialized/de-serialized.
+   *
+   * <p>If the parcelable is immutable, or it was already de-serialized from a Parcel (I.e. this
+   * instance was created with #readFromParcel), the value will be returned directly.
+   */
+  P getParcelable() {
+    if (safeToReturnValue) {
+      // We can just return the value directly.
+      return value;
+    } else {
+      // We need to serialize/de-serialize to a parcel internally.
+      if (sharableValue == null) {
+        sharableValue = marshallUnmarshall(value, checkNotNull(creator));
+      }
+      return sharableValue;
+    }
+  }
+
+  private static <P extends Parcelable> P marshallUnmarshall(
+      P value, Parcelable.Creator<P> creator) {
+    // Serialize/de-serialize the object directly instead of using Parcel.writeParcelable,
+    // since there's no need to write out the class name.
+    Parcel parcel = Parcel.obtain();
+    value.writeToParcel(parcel, 0);
+    parcel.setDataPosition(0);
+    P result = creator.createFromParcel(parcel);
+    parcel.recycle();
+    return result;
+  }
+
+  @Override
+  public String toString() {
+    return "ParcelableInputStream[V: " + value + "]";
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/PendingAuthListener.java b/binder/src/main/java/io/grpc/binder/internal/PendingAuthListener.java
new file mode 100644
index 00000000000..ad993b8c93b
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/PendingAuthListener.java
@@ -0,0 +1,98 @@
+package io.grpc.binder.internal;
+
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.Status;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link ServerCall.Listener} that can be returned by a {@link io.grpc.ServerInterceptor} to
+ * asynchronously advance the gRPC pending resolving a possibly asynchronous security policy check.
+ */
+final class PendingAuthListener<ReqT, RespT> extends ServerCall.Listener<ReqT> {
+
+  private final ConcurrentLinkedQueue<ListenerConsumer<ReqT>> pendingSteps =
+      new ConcurrentLinkedQueue<>();
+  private final AtomicReference<ServerCall.Listener<ReqT>> delegateRef =
+      new AtomicReference<>(null);
+
+  PendingAuthListener() {}
+
+  void startCall(
+      ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+    ServerCall.Listener<ReqT> delegate;
+    try {
+      delegate = next.startCall(call, headers);
+    } catch (RuntimeException e) {
+      call.close(
+          Status.INTERNAL
+              .withCause(e)
+              .withDescription("Failed to start server call after authorization check"),
+          new Metadata());
+      return;
+    }
+    delegateRef.set(delegate);
+    maybeRunPendingSteps();
+  }
+
+  /**
+   * Runs any enqueued step in this ServerCall listener as long as the authorization check is
+   * complete. Otherwise, no-op and returns immediately.
+   */
+  private void maybeRunPendingSteps() {
+    @Nullable ServerCall.Listener<ReqT> delegate = delegateRef.get();
+    if (delegate == null) {
+      return;
+    }
+
+    // This section is synchronized so that no 2 threads may attempt to retrieve elements from the
+    // queue in order but end up executing the steps out of order.
+    synchronized (this) {
+      ListenerConsumer<ReqT> nextStep;
+      while ((nextStep = pendingSteps.poll()) != null) {
+        nextStep.accept(delegate);
+      }
+    }
+  }
+
+  @Override
+  public void onCancel() {
+    pendingSteps.offer(ServerCall.Listener::onCancel);
+    maybeRunPendingSteps();
+  }
+
+  @Override
+  public void onComplete() {
+    pendingSteps.offer(ServerCall.Listener::onComplete);
+    maybeRunPendingSteps();
+  }
+
+  @Override
+  public void onHalfClose() {
+    pendingSteps.offer(ServerCall.Listener::onHalfClose);
+    maybeRunPendingSteps();
+  }
+
+  @Override
+  public void onMessage(ReqT message) {
+    pendingSteps.offer(delegate -> delegate.onMessage(message));
+    maybeRunPendingSteps();
+  }
+
+  @Override
+  public void onReady() {
+    pendingSteps.offer(ServerCall.Listener::onReady);
+    maybeRunPendingSteps();
+  }
+
+  /**
+   * Similar to Java8's {@link java.util.function.Consumer}, but redeclared in order to support
+   * Android SDK 21.
+   */
+  private interface ListenerConsumer<ReqT> {
+    void accept(ServerCall.Listener<ReqT> listener);
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/PingTracker.java b/binder/src/main/java/io/grpc/binder/internal/PingTracker.java
new file mode 100644
index 00000000000..5a4300443ba
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/PingTracker.java
@@ -0,0 +1,113 @@
+/*
+ * 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 com.google.common.base.Ticker;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.internal.ClientTransport.PingCallback;
+import java.util.concurrent.Executor;
+import javax.annotation.Nullable;
+
+/**
+ * Tracks an ongoing ping request for a client-side binder transport. We only handle a single active
+ * ping at a time, since that's all gRPC appears to need.
+ */
+final class PingTracker {
+
+  interface PingSender {
+    /**
+     * Send a ping to the remote endpoint. We expect a subsequent call to {@link #onPingResponse}
+     * with the same ID (assuming the ping succeeds).
+     */
+    void sendPing(int id) throws StatusException;
+  }
+
+  private final Ticker ticker;
+  private final PingSender pingSender;
+
+  @GuardedBy("this")
+  @Nullable
+  private Ping pendingPing;
+
+  @GuardedBy("this")
+  private int nextPingId;
+
+  PingTracker(Ticker ticker, PingSender pingSender) {
+    this.ticker = ticker;
+    this.pingSender = pingSender;
+  }
+
+  /**
+   * Start a ping.
+   *
+   * <p>See also {@link ClientTransport#ping}.
+   *
+   * @param callback The callback to report the ping result on.
+   * @param executor An executor to call callbacks on.
+   *     <p>Note that only one ping callback will be active at a time.
+   */
+  synchronized void startPing(PingCallback callback, Executor executor) {
+    pendingPing = new Ping(callback, executor, nextPingId++);
+    try {
+      pingSender.sendPing(pendingPing.id);
+    } catch (StatusException se) {
+      pendingPing.fail(se.getStatus());
+      pendingPing = null;
+    }
+  }
+
+  /** Callback when a ping response with the given ID is received. */
+  synchronized void onPingResponse(int id) {
+    if (pendingPing != null && pendingPing.id == id) {
+      pendingPing.success();
+      pendingPing = null;
+    }
+  }
+
+  private final class Ping {
+    private final PingCallback callback;
+    private final Executor executor;
+    private final int id;
+    private final long startTimeNanos;
+
+    @GuardedBy("this")
+    private boolean done;
+
+    Ping(PingCallback callback, Executor executor, int id) {
+      this.callback = callback;
+      this.executor = executor;
+      this.id = id;
+      this.startTimeNanos = ticker.read();
+    }
+
+    private synchronized void fail(Status status) {
+      if (!done) {
+        done = true;
+        executor.execute(() -> callback.onFailure(status));
+      }
+    }
+
+    private synchronized void success() {
+      if (!done) {
+        done = true;
+        executor.execute(() -> callback.onSuccess(ticker.read() - startTimeNanos));
+      }
+    }
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/ServiceBinding.java b/binder/src/main/java/io/grpc/binder/internal/ServiceBinding.java
new file mode 100644
index 00000000000..4b6bf7d06fb
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/ServiceBinding.java
@@ -0,0 +1,384 @@
+/*
+ * 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.base.Preconditions.checkState;
+import static io.grpc.binder.internal.SystemApis.createContextAsUser;
+
+import android.app.admin.DevicePolicyManager;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.content.pm.ServiceInfo;
+import android.os.Build;
+import android.os.IBinder;
+import android.os.UserHandle;
+import androidx.annotation.AnyThread;
+import androidx.annotation.MainThread;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.binder.BinderChannelCredentials;
+import java.util.concurrent.Executor;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Manages an Android binding that's restricted to at most one connection to the remote Service.
+ *
+ * <p>A note on synchronization & locking in this class. Clients of this class are likely to manage
+ * their own internal state via synchronization. In order to avoid deadlocks, we must not hold any
+ * locks while calling observer callbacks.
+ *
+ * <p>For this reason, while internal consistency is handled with synchronization (the state field),
+ * consistency on our observer callbacks is ensured by doing everything on the application's main
+ * thread.
+ */
+@ThreadSafe
+final class ServiceBinding implements Bindable, ServiceConnection {
+
+  private static final Logger logger = Logger.getLogger(ServiceBinding.class.getName());
+
+  // States can only ever transition in one direction.
+  private enum State {
+    NOT_BINDING,
+    BINDING,
+    BOUND,
+    UNBOUND,
+  }
+
+  // Type of the method used when binding the service.
+  private enum BindMethodType {
+    BIND_SERVICE("bindService"),
+    BIND_SERVICE_AS_USER("bindServiceAsUser"),
+    DEVICE_POLICY_BIND_SEVICE_ADMIN("DevicePolicyManager.bindDeviceAdminServiceAsUser");
+
+    private final String methodName;
+
+    BindMethodType(String methodName) {
+      this.methodName = methodName;
+    }
+
+    public String methodName() {
+      return methodName;
+    }
+  }
+
+  private final BinderChannelCredentials channelCredentials;
+  private final Intent bindIntent;
+  @Nullable private final UserHandle targetUserHandle;
+  private final int bindFlags;
+  private final Observer observer;
+  private final Executor mainThreadExecutor;
+
+  @GuardedBy("this")
+  private State state;
+
+  // The following fields are intentionally not guarded, since (aside from the constructor),
+  // they're only modified in the main thread. The constructor contains a synchronized block
+  // to ensure there's a write barrier when these fields are first written.
+
+  @Nullable private Context sourceContext; // Only null in the unbound state.
+
+  private State reportedState; // Only used on the main thread.
+
+  @GuardedBy("this")
+  private ComponentName connectedServiceName;
+
+  @AnyThread
+  ServiceBinding(
+      Executor mainThreadExecutor,
+      Context sourceContext,
+      BinderChannelCredentials channelCredentials,
+      Intent bindIntent,
+      @Nullable UserHandle targetUserHandle,
+      int bindFlags,
+      Observer observer) {
+    // We need to synchronize here ensure other threads see all
+    // non-final fields initialized after the constructor.
+    synchronized (this) {
+      this.bindIntent = bindIntent;
+      this.bindFlags = bindFlags;
+      this.observer = observer;
+      this.sourceContext = sourceContext;
+      this.mainThreadExecutor = mainThreadExecutor;
+      this.channelCredentials = channelCredentials;
+      this.targetUserHandle = targetUserHandle;
+      state = State.NOT_BINDING;
+      reportedState = State.NOT_BINDING;
+    }
+  }
+
+  @MainThread
+  private void notifyBound(IBinder binder) {
+    if (reportedState == State.NOT_BINDING) {
+      reportedState = State.BOUND;
+      logger.log(Level.FINEST, "notify bound - notifying");
+      observer.onBound(binder);
+    }
+  }
+
+  @MainThread
+  private void notifyUnbound(Status reason) {
+    logger.log(Level.FINEST, "notify unbound ", reason);
+    clearReferences();
+    if (reportedState != State.UNBOUND) {
+      reportedState = State.UNBOUND;
+      logger.log(Level.FINEST, "notify unbound - notifying");
+      observer.onUnbound(reason);
+    }
+  }
+
+  @AnyThread
+  @Override
+  public synchronized void bind() {
+    if (state == State.NOT_BINDING) {
+      state = State.BINDING;
+      Status bindResult =
+          bindInternal(
+              sourceContext, bindIntent, this, bindFlags, channelCredentials, targetUserHandle);
+      if (!bindResult.isOk()) {
+        handleBindServiceFailure(sourceContext, this);
+        state = State.UNBOUND;
+        mainThreadExecutor.execute(() -> notifyUnbound(bindResult));
+      }
+    }
+  }
+
+  private static Status bindInternal(
+      Context context,
+      Intent bindIntent,
+      ServiceConnection conn,
+      int flags,
+      BinderChannelCredentials channelCredentials,
+      @Nullable UserHandle targetUserHandle) {
+    BindMethodType bindMethodType = BindMethodType.BIND_SERVICE;
+    try {
+      if (targetUserHandle == null) {
+        checkState(
+            channelCredentials.getDevicePolicyAdminComponentName() == null,
+            "BindingChannelCredentials is expected to have null devicePolicyAdmin when"
+                + " targetUserHandle is not set");
+      } else {
+        if (channelCredentials.getDevicePolicyAdminComponentName() != null) {
+          bindMethodType = BindMethodType.DEVICE_POLICY_BIND_SEVICE_ADMIN;
+        } else {
+          bindMethodType = BindMethodType.BIND_SERVICE_AS_USER;
+        }
+      }
+      boolean bindResult = false;
+      switch (bindMethodType) {
+        case BIND_SERVICE:
+          bindResult = context.bindService(bindIntent, conn, flags);
+          break;
+        case BIND_SERVICE_AS_USER:
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            // We don't need SystemApis because bindServiceAsUser() is simply public in R+.
+            bindResult = context.bindServiceAsUser(bindIntent, conn, flags, targetUserHandle);
+          } else {
+            // TODO(#12279): Use SystemApis to make this work pre-R.
+            return Status.INTERNAL.withDescription("Cross user Channel requires Android R+");
+          }
+          break;
+        case DEVICE_POLICY_BIND_SEVICE_ADMIN:
+          DevicePolicyManager devicePolicyManager =
+              (DevicePolicyManager) context.getSystemService(Context.DEVICE_POLICY_SERVICE);
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            bindResult =
+                devicePolicyManager.bindDeviceAdminServiceAsUser(
+                    channelCredentials.getDevicePolicyAdminComponentName(),
+                    bindIntent,
+                    conn,
+                    flags,
+                    targetUserHandle);
+          } else {
+            return Status.INTERNAL.withDescription(
+                "Device policy admin binding requires Android R+");
+          }
+          break;
+      }
+      if (!bindResult) {
+        return Status.UNIMPLEMENTED.withDescription(
+            bindMethodType.methodName() + "(" + bindIntent + ") returned false");
+      }
+      return Status.OK;
+    } catch (SecurityException e) {
+      return Status.PERMISSION_DENIED
+          .withCause(e)
+          .withDescription("SecurityException from " + bindMethodType.methodName());
+    } catch (RuntimeException e) {
+      return Status.INTERNAL
+          .withCause(e)
+          .withDescription("RuntimeException from " + bindMethodType.methodName());
+    }
+  }
+
+  // Over the years, the API contract for Context#bindService() has been inconsistent on the subject
+  // of error handling. But inspecting recent AOSP implementations shows that, internally,
+  // bindService() retains a reference to the ServiceConnection when it throws certain Exceptions
+  // and even when it returns false. To avoid leaks, we *always* call unbindService() in case of
+  // error and simply ignore any "Service not registered" IAE and other RuntimeExceptions.
+  private static void handleBindServiceFailure(Context context, ServiceConnection conn) {
+    try {
+      context.unbindService(conn);
+    } catch (RuntimeException e) {
+      logger.log(Level.FINE, "Could not clean up after bindService() failure.", e);
+    }
+  }
+
+  @Override
+  @AnyThread
+  public void unbind() {
+    unbindInternal(Status.CANCELLED);
+  }
+
+  @AnyThread
+  void unbindInternal(Status reason) {
+    Context unbindFrom = null;
+    synchronized (this) {
+      if (state == State.BINDING || state == State.BOUND) {
+        unbindFrom = sourceContext;
+      }
+      state = State.UNBOUND;
+    }
+    mainThreadExecutor.execute(() -> notifyUnbound(reason));
+    if (unbindFrom != null) {
+      unbindFrom.unbindService(this);
+    }
+  }
+
+  @AnyThread
+  @Override
+  public ServiceInfo resolve() throws StatusException {
+    int flags = 0;
+    if (Build.VERSION.SDK_INT >= 29) {
+      // Filter out non-'directBootAware' <service>s when 'targetUserHandle' is locked. Here's why:
+      // Callers want 'bindIntent' to #resolve() to the same thing a follow-up call to #bind() will.
+      // But bindService() *always* ignores services that can't presently be created for lack of
+      // 'directBootAware'-ness. This flag explicitly tells resolveService() to act the same way.
+      flags |= PackageManager.MATCH_DIRECT_BOOT_AUTO;
+    }
+    ResolveInfo resolveInfo =
+        getContextForTargetUser("Cross-user pre-auth")
+            .getPackageManager()
+            .resolveService(bindIntent, flags);
+    if (resolveInfo == null) {
+      throw Status.UNIMPLEMENTED // Same status code as when bindService() returns false.
+          .withDescription("resolveService(" + bindIntent + " / " + targetUserHandle + ") was null")
+          .asException();
+    }
+    return resolveInfo.serviceInfo;
+  }
+
+  private Context getContextForTargetUser(String purpose) throws StatusException {
+    checkState(sourceContext != null, "Already unbound!");
+    try {
+      return targetUserHandle == null
+          ? sourceContext
+          : createContextAsUser(sourceContext, targetUserHandle, /* flags= */ 0);
+    } catch (ReflectiveOperationException e) {
+      throw Status.INTERNAL
+          .withDescription(purpose + " requires SDK_INT >= R and @SystemApi visibility")
+          .asException();
+    }
+  }
+
+  @MainThread
+  private void clearReferences() {
+    sourceContext = null;
+  }
+
+  @AnyThread
+  @Override
+  public ServiceInfo getConnectedServiceInfo() throws StatusException {
+    try {
+      return getContextForTargetUser("cross-user v2 handshake")
+          .getPackageManager()
+          .getServiceInfo(getConnectedServiceName(), /* flags= */ 0);
+    } catch (PackageManager.NameNotFoundException e) {
+      throw Status.UNIMPLEMENTED
+          .withCause(e)
+          .withDescription("connected remote service was uninstalled/disabled during handshake")
+          .asException();
+    }
+  }
+
+  private synchronized ComponentName getConnectedServiceName() {
+    checkState(connectedServiceName != null, "onBound() not yet called!");
+    return connectedServiceName;
+  }
+
+  @Override
+  @MainThread
+  public void onServiceConnected(ComponentName className, IBinder binder) {
+    boolean bound = false;
+    synchronized (this) {
+      if (state == State.BINDING) {
+        state = State.BOUND;
+        connectedServiceName = className;
+        bound = true;
+      }
+    }
+    if (bound) {
+      // We call notify directly because we know we're on the main thread already.
+      // (every millisecond counts in this path).
+      notifyBound(binder);
+    }
+  }
+
+  @Override
+  @MainThread
+  public void onServiceDisconnected(ComponentName name) {
+    unbindInternal(
+        Status.UNAVAILABLE.withDescription(
+            "Server process crashed, exited or was killed (onServiceDisconnected): " + name));
+  }
+
+  @Override
+  @MainThread
+  public void onNullBinding(ComponentName name) {
+    unbindInternal(
+        Status.UNIMPLEMENTED.withDescription(
+            "Remote Service returned null from onBind() for "
+                + bindIntent
+                + " (onNullBinding): "
+                + name));
+  }
+
+  @Override
+  @MainThread
+  public void onBindingDied(ComponentName name) {
+    unbindInternal(
+        Status.UNAVAILABLE.withDescription(
+            "Remote Service component "
+                + name.getClassName()
+                + " was disabled, or its package "
+                + name.getPackageName()
+                + " was disabled, force-stopped, replaced or uninstalled (onBindingDied)."));
+  }
+
+  @VisibleForTesting
+  synchronized boolean isSourceContextCleared() {
+    return sourceContext == null;
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/SimplePromise.java b/binder/src/main/java/io/grpc/binder/internal/SimplePromise.java
new file mode 100644
index 00000000000..c7d227fbf64
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/SimplePromise.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2025 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.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Placeholder for an object that will be provided later.
+ *
+ * <p>Similar to {@link com.google.common.util.concurrent.SettableFuture}, except it cannot fail or
+ * be cancelled. Most importantly, this class guarantees that {@link Listener}s run one-at-a-time
+ * and in the same order that they were scheduled. This conveniently matches the expectations of
+ * most listener interfaces in the io.grpc universe.
+ *
+ * <p>Not safe for concurrent use by multiple threads. Thread-compatible for callers that provide
+ * synchronization externally.
+ */
+public class SimplePromise<T> {
+  private T value;
+  private List<Listener<T>> pendingListeners; // Allocated lazily in the hopes it's never needed.
+
+  /**
+   * Provides the promised object and runs any pending listeners.
+   *
+   * @throws IllegalStateException if this method has already been called
+   * @throws RuntimeException if some pending listener threw when we tried to run it
+   */
+  public void set(T value) {
+    checkNotNull(value, "value");
+    checkState(this.value == null, "Already set!");
+    this.value = value;
+    if (pendingListeners != null) {
+      for (Listener<T> listener : pendingListeners) {
+        listener.notify(value);
+      }
+      pendingListeners = null;
+    }
+  }
+
+  /**
+   * Returns the promised object, under the assumption that it's already been set.
+   *
+   * <p>Compared to {@link #runWhenSet(Listener)}, this method may be a more efficient way to access
+   * the promised value in the case where you somehow know externally that {@link #set(T)} has
+   * "happened-before" this call.
+   *
+   * @throws IllegalStateException if {@link #set(T)} has not yet been called
+   */
+  public T get() {
+    checkState(value != null, "Not yet set!");
+    return value;
+  }
+
+  /**
+   * Runs the given listener when this promise is fulfilled, or immediately if already fulfilled.
+   *
+   * @throws RuntimeException if already fulfilled and 'listener' threw when we tried to run it
+   */
+  public void runWhenSet(Listener<T> listener) {
+    if (value != null) {
+      listener.notify(value);
+    } else {
+      if (pendingListeners == null) {
+        pendingListeners = new ArrayList<>();
+      }
+      pendingListeners.add(listener);
+    }
+  }
+
+  /**
+   * An object that wants to get notified when a SimplePromise has been fulfilled.
+   */
+  public interface Listener<T> {
+    /**
+     * Indicates that the associated SimplePromise has been fulfilled with the given `value`.
+     */
+    void notify(T value);
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/SingleMessageClientStream.java b/binder/src/main/java/io/grpc/binder/internal/SingleMessageClientStream.java
new file mode 100644
index 00000000000..8a899d621a2
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/SingleMessageClientStream.java
@@ -0,0 +1,188 @@
+/*
+ * 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 io.grpc.Attributes;
+import io.grpc.Compressor;
+import io.grpc.Deadline;
+import io.grpc.DecompressorRegistry;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.internal.ClientStream;
+import io.grpc.internal.ClientStreamListener;
+import io.grpc.internal.InsightBuilder;
+import java.io.InputStream;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * The client side of a single RPC, which sends a single request message.
+ *
+ * <p>An instance of this class is effectively a go-between, receiving messages from the gRPC
+ * ClientCall instance (via calls on the ClientStream interface we implement), and sending them out
+ * on the transport, as well as receiving messages from the transport, and passing the resultant
+ * data back to the gRPC ClientCall instance (via calls on the ClientStreamListener instance we're
+ * given).
+ *
+ * <p>These two communication directions are largely independent of each other, with the {@link
+ * Outbound} handling the gRPC to transport direction, and the {@link Inbound} class handling
+ * transport to gRPC direction.
+ *
+ * <p>Since the Inbound and Outbound halves are largely independent, their state is also
+ * synchronized independently.
+ */
+final class SingleMessageClientStream implements ClientStream {
+
+  private final Inbound.ClientInbound inbound;
+  private final Outbound.ClientOutbound outbound;
+  private final Attributes attributes;
+
+  @Nullable private InputStream pendingSingleMessage;
+  @Nullable private Deadline pendingDeadline;
+
+  SingleMessageClientStream(
+      Inbound.ClientInbound inbound, Outbound.ClientOutbound outbound, Attributes attributes) {
+    this.inbound = inbound;
+    this.outbound = outbound;
+    this.attributes = attributes;
+  }
+
+  @Override
+  public void start(ClientStreamListener listener) {
+    synchronized (inbound) {
+      inbound.init(outbound, listener);
+    }
+    if (outbound.isReady()) {
+      listener.onReady();
+    }
+  }
+
+  @Override
+  public boolean isReady() {
+    return outbound.isReady();
+  }
+
+  @Override
+  public void request(int numMessages) {
+    synchronized (inbound) {
+      inbound.requestMessages(numMessages);
+    }
+  }
+
+  @Override
+  public void writeMessage(InputStream message) {
+    if (pendingSingleMessage != null) {
+      synchronized (inbound) {
+        inbound.closeAbnormal(Status.INTERNAL.withDescription("too many messages"));
+      }
+    } else {
+      pendingSingleMessage = message;
+    }
+  }
+
+  @Override
+  public void halfClose() {
+    try {
+      synchronized (outbound) {
+        if (pendingDeadline != null) {
+          outbound.setDeadline(pendingDeadline);
+        }
+        outbound.onPrefixReady();
+        outbound.sendSingleMessageAndHalfClose(pendingSingleMessage);
+      }
+    } catch (StatusException se) {
+      synchronized (inbound) {
+        inbound.closeAbnormal(se.getStatus());
+      }
+    }
+  }
+
+  @Override
+  public void cancel(Status status) {
+    synchronized (inbound) {
+      inbound.closeOnCancel(status);
+    }
+  }
+
+  @Override
+  public void setDeadline(@Nonnull Deadline deadline) {
+    this.pendingDeadline = deadline;
+  }
+
+  @Override
+  public Attributes getAttributes() {
+    return attributes;
+  }
+
+  @Override
+  public final String toString() {
+    return "SingleMessageClientStream[" + inbound + "/" + outbound + "]";
+  }
+
+  // =====================
+  // Misc stubbed & unsupported methods.
+
+  @Override
+  public final void flush() {
+    // Ignore.
+  }
+
+  @Override
+  public final void setCompressor(Compressor compressor) {
+    // Ignore.
+  }
+
+  @Override
+  public final void setMessageCompression(boolean enable) {
+    // Ignore.
+  }
+
+  @Override
+  public void setAuthority(String authority) {
+    // Ignore.
+  }
+
+  @Override
+  public void setMaxInboundMessageSize(int maxSize) {
+    // Ignore.
+  }
+
+  @Override
+  public void setMaxOutboundMessageSize(int maxSize) {
+    // Ignore.
+  }
+
+  @Override
+  public void appendTimeoutInsight(InsightBuilder insight) {
+    // Ignore
+  }
+
+  @Override
+  public void setFullStreamDecompression(boolean fullStreamDecompression) {
+    // Ignore.
+  }
+
+  @Override
+  public void setDecompressorRegistry(DecompressorRegistry decompressorRegistry) {
+    // Ignore.
+  }
+
+  @Override
+  public void optimizeForDirectExecutor() {
+    // Ignore.
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/SingleMessageServerStream.java b/binder/src/main/java/io/grpc/binder/internal/SingleMessageServerStream.java
new file mode 100644
index 00000000000..383bd7a2593
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/SingleMessageServerStream.java
@@ -0,0 +1,179 @@
+/*
+ * 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 io.grpc.Attributes;
+import io.grpc.Compressor;
+import io.grpc.Decompressor;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.internal.ServerStream;
+import io.grpc.internal.ServerStreamListener;
+import io.grpc.internal.StatsTraceContext;
+import java.io.InputStream;
+import javax.annotation.Nullable;
+
+/**
+ * The server side of a single RPC, which sends a single response message.
+ *
+ * <p>An instance of this class is effectively a go-between, receiving messages from the gRPC
+ * ServerCall instance (via calls on the ServerStream interface we implement), and sending them out
+ * on the transport, as well as receiving messages from the transport, and passing the resultant
+ * data back to the gRPC ServerCall instance (via calls on the ServerStreamListener instance we're
+ * given).
+ *
+ * <p>These two communication directions are largely independent of each other, with the {@link
+ * Outbound} handling the gRPC to transport direction, and the {@link Inbound} class handling
+ * transport to gRPC direction.
+ *
+ * <p>Since the Inbound and Outbound halves are largely independent, their state is also
+ * synchronized independently.
+ */
+final class SingleMessageServerStream implements ServerStream {
+
+  private final Inbound.ServerInbound inbound;
+  private final Outbound.ServerOutbound outbound;
+  private final Attributes attributes;
+
+  @Nullable private Metadata pendingHeaders;
+  @Nullable private InputStream pendingSingleMessage;
+
+  SingleMessageServerStream(
+      Inbound.ServerInbound inbound, Outbound.ServerOutbound outbound, Attributes attributes) {
+    this.inbound = inbound;
+    this.outbound = outbound;
+    this.attributes = attributes;
+  }
+
+  @Override
+  public void setListener(ServerStreamListener listener) {
+    synchronized (inbound) {
+      inbound.init(outbound, listener);
+    }
+  }
+
+  @Override
+  public void setOnReadyThreshold(int numBytes) {
+    // No-op
+  }
+
+  @Override
+  public boolean isReady() {
+    return outbound.isReady();
+  }
+
+  @Override
+  public void request(int numMessages) {
+    synchronized (inbound) {
+      inbound.requestMessages(numMessages);
+    }
+  }
+
+  @Override
+  public void writeHeaders(Metadata headers, boolean flush) {
+    pendingHeaders = headers;
+  }
+
+  @Override
+  public void writeMessage(InputStream message) {
+    if (pendingSingleMessage != null) {
+      synchronized (inbound) {
+        inbound.closeAbnormal(Status.INTERNAL.withDescription("too many messages"));
+      }
+    } else {
+      pendingSingleMessage = message;
+    }
+  }
+
+  @Override
+  public void close(Status status, Metadata trailers) {
+    try {
+      synchronized (outbound) {
+        outbound.sendSingleMessageAndClose(pendingHeaders, pendingSingleMessage, status, trailers);
+      }
+      synchronized (inbound) {
+        inbound.onCloseSent(status);
+      }
+    } catch (StatusException se) {
+      synchronized (inbound) {
+        inbound.closeAbnormal(se.getStatus());
+      }
+    }
+  }
+
+  @Override
+  public void cancel(Status status) {
+    synchronized (inbound) {
+      inbound.closeOnCancel(status);
+    }
+  }
+
+  @Override
+  public StatsTraceContext statsTraceContext() {
+    return outbound.getStatsTraceContext();
+  }
+
+  @Override
+  public Attributes getAttributes() {
+    return attributes;
+  }
+
+  @Nullable
+  @Override
+  public String getAuthority() {
+    return attributes.get(BinderTransport.SERVER_AUTHORITY);
+  }
+
+  @Override
+  public String toString() {
+    return "SingleMessageServerStream[" + inbound + "/" + outbound + "]";
+  }
+
+  // =====================
+  // Misc stubbed & unsupported methods.
+
+  @Override
+  public final void flush() {
+    // Ignore.
+  }
+
+  @Override
+  public final void setCompressor(Compressor compressor) {
+    // Ignore.
+  }
+
+  @Override
+  public final void setMessageCompression(boolean enable) {
+    // Ignore.
+  }
+
+  @Override
+  public void setDecompressor(Decompressor decompressor) {
+    // Ignore.
+  }
+
+  @Override
+  public void optimizeForDirectExecutor() {
+    // Ignore.
+  }
+
+  @Override
+  public int streamId() {
+    return -1;
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/SystemApis.java b/binder/src/main/java/io/grpc/binder/internal/SystemApis.java
new file mode 100644
index 00000000000..a4feec86a11
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/SystemApis.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2025 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.content.Context;
+import android.os.UserHandle;
+import java.lang.reflect.Method;
+
+/**
+ * A collection of static methods that wrap hidden Android "System APIs."
+ *
+ * <p>grpc-java can't call Android methods marked @SystemApi directly, even though many of our users
+ * are "system apps" entitled to do so. Being a library built outside the Android source tree, these
+ * "non-SDK" elements simply don't exist from our compiler's perspective. Instead we resort to
+ * reflection but use the static wrappers found here to keep call sites readable and type safe.
+ *
+ * <p>Modern Android's JRE also limits the visibility of these methods at *runtime*. Only certain
+ * privileged apps installed on the system image app can call them, even using reflection, and this
+ * wrapper doesn't change that. Callers are responsible for ensuring that the host app actually has
+ * the ability to call @SystemApis and all methods throw {@link ReflectiveOperationException} as a
+ * reminder to do that. See
+ * https://developer.android.com/guide/app-compatibility/restrictions-non-sdk-interfaces for more.
+ */
+final class SystemApis {
+  private static volatile Method createContextAsUserMethod;
+
+  // Not to be instantiated.
+  private SystemApis() {}
+
+  /**
+   * Returns a new Context object whose methods act as if they were running in the given user.
+   *
+   * @throws ReflectiveOperationException if SDK_INT < R or host app lacks @SystemApi visibility
+   */
+  public static Context createContextAsUser(Context context, UserHandle userHandle, int flags)
+      throws ReflectiveOperationException {
+    if (createContextAsUserMethod == null) {
+      synchronized (SystemApis.class) {
+        if (createContextAsUserMethod == null) {
+          createContextAsUserMethod =
+              Context.class.getMethod("createContextAsUser", UserHandle.class, int.class);
+        }
+      }
+    }
+    return (Context) createContextAsUserMethod.invoke(context, userHandle, flags);
+  }
+}
diff --git a/binder/src/main/java/io/grpc/binder/internal/TransactionUtils.java b/binder/src/main/java/io/grpc/binder/internal/TransactionUtils.java
new file mode 100644
index 00000000000..2777a78d4ac
--- /dev/null
+++ b/binder/src/main/java/io/grpc/binder/internal/TransactionUtils.java
@@ -0,0 +1,126 @@
+/*
+ * 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 io.grpc.MethodDescriptor.MethodType;
+import io.grpc.Status;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import io.grpc.binder.internal.LeakSafeOneWayBinder.TransactionHandler;
+import javax.annotation.Nullable;
+
+/** Constants and helpers for managing inbound / outbound transactions. */
+final class TransactionUtils {
+  /** Set when the transaction contains rpc prefix data. */
+  static final int FLAG_PREFIX = 0x1;
+
+  /** Set when the transaction contains some message data. */
+  static final int FLAG_MESSAGE_DATA = 0x2;
+
+  /** Set when the transaction contains rpc suffix data. */
+  static final int FLAG_SUFFIX = 0x4;
+
+  /** Set when the transaction is an out-of-band close event. */
+  static final int FLAG_OUT_OF_BAND_CLOSE = 0x8;
+
+  /**
+   * When a transaction contains client prefix data, this will be set if the rpc being made is
+   * expected to return a single message. (I.e the method type is either {@link MethodType#UNARY},
+   * or {@link MethodType#CLIENT_STREAMING}).
+   */
+  static final int FLAG_EXPECT_SINGLE_MESSAGE = 0x10;
+
+  /** Set when the included status data includes a description string. */
+  static final int FLAG_STATUS_DESCRIPTION = 0x20;
+
+  /** When a transaction contains message data, this will be set if the message is a parcelable. */
+  static final int FLAG_MESSAGE_DATA_IS_PARCELABLE = 0x40;
+
+  /**
+   * When a transaction contains message data, this will be set if the message is only partial, and
+   * further transactions are required.
+   */
+  static final int FLAG_MESSAGE_DATA_IS_PARTIAL = 0x80;
+
+  static final int STATUS_CODE_SHIFT = 16;
+  static final int STATUS_CODE_MASK = 0xff0000;
+
+  /** The maximum string length for a status description. */
+  private static final int MAX_STATUS_DESCRIPTION_LENGTH = 1000;
+
+  private TransactionUtils() {}
+
+  static boolean hasFlag(int flags, int flag) {
+    return (flags & flag) != 0;
+  }
+
+  @Nullable
+  private static String getTruncatedDescription(Status status) {
+    String desc = status.getDescription();
+    if (desc != null && desc.length() > MAX_STATUS_DESCRIPTION_LENGTH) {
+      desc = desc.substring(0, MAX_STATUS_DESCRIPTION_LENGTH);
+    }
+    return desc;
+  }
+
+  static Status readStatus(int flags, Parcel parcel) {
+    Status status = Status.fromCodeValue((flags & STATUS_CODE_MASK) >> STATUS_CODE_SHIFT);
+    if ((flags & FLAG_STATUS_DESCRIPTION) != 0) {
+      status = status.withDescription(parcel.readString());
+    }
+    return status;
+  }
+
+  static int writeStatus(Parcel parcel, Status status) {
+    int flags = status.getCode().value() << STATUS_CODE_SHIFT;
+    String desc = getTruncatedDescription(status);
+    if (desc != null) {
+      flags |= FLAG_STATUS_DESCRIPTION;
+      parcel.writeString(desc);
+    }
+    return flags;
+  }
+
+  static void fillInFlags(Parcel parcel, int flags) {
+    int pos = parcel.dataPosition();
+    parcel.setDataPosition(0);
+    parcel.writeInt(flags);
+    parcel.setDataPosition(pos);
+  }
+
+  /**
+   * Decorates the given {@link TransactionHandler} with a wrapper that only forwards transactions
+   * from the given `allowedCallingUid`.
+   */
+  static TransactionHandler newCallerFilteringHandler(
+      int allowedCallingUid, TransactionHandler wrapped) {
+    final Logger logger = Logger.getLogger(TransactionUtils.class.getName());
+    return new TransactionHandler() {
+      @Override
+      public boolean handleTransaction(int code, Parcel data) {
+        int callingUid = Binder.getCallingUid();
+        if (callingUid != allowedCallingUid) {
+          logger.log(Level.WARNING, "dropped txn from " + callingUid + " !=" + allowedCallingUid);
+          return false;
+        }
+        return wrapped.handleTransaction(code, data);
+      }
+    };
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/AndroidComponentAddressTest.java b/binder/src/test/java/io/grpc/binder/AndroidComponentAddressTest.java
new file mode 100644
index 00000000000..d7d77d7feb1
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/AndroidComponentAddressTest.java
@@ -0,0 +1,239 @@
+/*
+ * 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;
+
+import static android.content.Intent.URI_ANDROID_APP_SCHEME;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Parcel;
+import android.os.UserHandle;
+import androidx.test.core.app.ApplicationProvider;
+import com.google.common.testing.EqualsTester;
+import java.net.URISyntaxException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+public final class AndroidComponentAddressTest {
+
+  private final Context appContext = ApplicationProvider.getApplicationContext();
+  private final ComponentName hostComponent = new ComponentName(appContext, appContext.getClass());
+
+  @Test
+  public void testAuthority() {
+    AndroidComponentAddress addr = AndroidComponentAddress.forContext(appContext);
+    assertThat(addr.getAuthority()).isEqualTo(appContext.getPackageName());
+  }
+
+  @Test
+  public void testComponent() {
+    AndroidComponentAddress addr = AndroidComponentAddress.forComponent(hostComponent);
+    assertThat(addr.getComponent()).isSameInstanceAs(hostComponent);
+  }
+
+  @Test
+  public void testTargetPackageNullComponentName() {
+    AndroidComponentAddress addr =
+        AndroidComponentAddress.forBindIntent(
+            new Intent().setPackage("com.foo").setAction(ApiConstants.ACTION_BIND));
+    assertThat(addr.getPackage()).isEqualTo("com.foo");
+    assertThat(addr.getComponent()).isNull();
+  }
+
+  @Test
+  public void testTargetPackageNonNullComponentName() {
+    AndroidComponentAddress addr =
+        AndroidComponentAddress.forBindIntent(
+            new Intent()
+                .setComponent(new ComponentName("com.foo", "com.foo.BarService"))
+                .setPackage("com.foo")
+                .setAction(ApiConstants.ACTION_BIND));
+    assertThat(addr.getPackage()).isEqualTo("com.foo");
+  }
+
+  @Test
+  public void testAsBindIntent() {
+    Intent bindIntent =
+        new Intent()
+            .setAction("foo")
+            .setComponent(new ComponentName("pkg", "cls"))
+            .setData(Uri.EMPTY)
+            .setType("sometype")
+            .addCategory("some-category")
+            .addCategory("another-category");
+    AndroidComponentAddress addr = AndroidComponentAddress.forBindIntent(bindIntent);
+    assertThat(addr.asBindIntent().filterEquals(bindIntent)).isTrue();
+  }
+
+  @Test
+  public void testPostCreateIntentMutation() {
+    Intent bindIntent = new Intent().setAction("foo-action").setComponent(hostComponent);
+    AndroidComponentAddress addr = AndroidComponentAddress.forBindIntent(bindIntent);
+    bindIntent.setAction("bar-action");
+    assertThat(addr.asBindIntent().getAction()).isEqualTo("foo-action");
+  }
+
+  @Test
+  public void testPostBuildIntentMutation() {
+    Intent bindIntent = new Intent().setAction("foo-action").setComponent(hostComponent);
+    AndroidComponentAddress addr =
+        AndroidComponentAddress.newBuilder().setBindIntent(bindIntent).build();
+    bindIntent.setAction("bar-action");
+    assertThat(addr.asBindIntent().getAction()).isEqualTo("foo-action");
+  }
+
+  @Test
+  public void testBuilderMissingRequired() {
+    IllegalStateException ise =
+        assertThrows(
+            IllegalStateException.class,
+            () -> AndroidComponentAddress.newBuilder().setTargetUser(newUserHandle(123)).build());
+    assertThat(ise.getMessage()).contains("bindIntent");
+  }
+
+  @Test
+  @Config(sdk = 30)
+  public void testAsAndroidAppUriSdk30() throws URISyntaxException {
+    AndroidComponentAddress addr =
+        AndroidComponentAddress.forRemoteComponent("com.foo", "com.foo.Service");
+    AndroidComponentAddress addrClone =
+        AndroidComponentAddress.forBindIntent(
+            Intent.parseUri(addr.asAndroidAppUri(), URI_ANDROID_APP_SCHEME));
+    assertThat(addr).isEqualTo(addrClone);
+  }
+
+  @Test
+  @Config(sdk = 29)
+  public void testAsAndroidAppUriSdk29() throws URISyntaxException {
+    AndroidComponentAddress addr =
+        AndroidComponentAddress.forRemoteComponent("com.foo", "com.foo.Service");
+    AndroidComponentAddress addrClone =
+        AndroidComponentAddress.forBindIntent(
+            Intent.parseUri(addr.asAndroidAppUri(), URI_ANDROID_APP_SCHEME));
+    // Can't test for equality because URI_ANDROID_APP_SCHEME adds a (redundant) package filter.
+    assertThat(addr.getComponent()).isEqualTo(addrClone.getComponent());
+    assertThat(addr.getAuthority()).isEqualTo(addrClone.getAuthority());
+  }
+
+  @Test
+  public void testEquality() {
+    new EqualsTester()
+        .addEqualityGroup(
+            AndroidComponentAddress.forBindIntent(
+                new Intent(ApiConstants.ACTION_BIND).setComponent(hostComponent)),
+            AndroidComponentAddress.forComponent(hostComponent),
+            AndroidComponentAddress.forContext(appContext),
+            AndroidComponentAddress.forLocalComponent(appContext, appContext.getClass()),
+            AndroidComponentAddress.forRemoteComponent(
+                appContext.getPackageName(), appContext.getClass().getName()),
+            AndroidComponentAddress.newBuilder()
+                .setBindIntentFromComponent(hostComponent)
+                .setTargetUser(null)
+                .build())
+        .addEqualityGroup(
+            AndroidComponentAddress.forRemoteComponent("appy.mcappface", ".McActivity"))
+        .addEqualityGroup(AndroidComponentAddress.forLocalComponent(appContext, getClass()))
+        .addEqualityGroup(
+            AndroidComponentAddress.forBindIntent(
+                new Intent().setAction("custom-action").setComponent(hostComponent)),
+            AndroidComponentAddress.newBuilder()
+                .setBindIntent(new Intent().setAction("custom-action").setComponent(hostComponent))
+                .setTargetUser(null)
+                .build())
+        .addEqualityGroup(
+            AndroidComponentAddress.forBindIntent(
+                new Intent()
+                    .setAction("custom-action")
+                    .setType("some-type")
+                    .setComponent(hostComponent)))
+        .testEquals();
+  }
+
+  @Test
+  public void testUnequalTargetUsers() {
+    new EqualsTester()
+        .addEqualityGroup(
+            AndroidComponentAddress.newBuilder()
+                .setBindIntentFromComponent(hostComponent)
+                .setTargetUser(newUserHandle(10))
+                .build(),
+            AndroidComponentAddress.newBuilder()
+                .setBindIntentFromComponent(hostComponent)
+                .setTargetUser(newUserHandle(10))
+                .build())
+        .addEqualityGroup(
+            AndroidComponentAddress.newBuilder()
+                .setBindIntentFromComponent(hostComponent)
+                .setTargetUser(newUserHandle(11))
+                .build())
+        .addEqualityGroup(
+            AndroidComponentAddress.newBuilder()
+                .setBindIntentFromComponent(hostComponent)
+                .setTargetUser(null)
+                .build())
+        .testEquals();
+  }
+
+  @Test
+  @Config(sdk = 30)
+  public void testPackageFilterEquality30AndUp() {
+    new EqualsTester()
+        .addEqualityGroup(
+            AndroidComponentAddress.forBindIntent(
+                new Intent().setAction("action").setComponent(new ComponentName("pkg", "cls"))),
+            AndroidComponentAddress.forBindIntent(
+                new Intent()
+                    .setAction("action")
+                    .setPackage("pkg")
+                    .setComponent(new ComponentName("pkg", "cls"))))
+        .testEquals();
+  }
+
+  @Test
+  @Config(sdk = 29)
+  public void testPackageFilterEqualityPre30() {
+    new EqualsTester()
+        .addEqualityGroup(
+            AndroidComponentAddress.forBindIntent(
+                new Intent().setAction("action").setComponent(new ComponentName("pkg", "cls"))))
+        .addEqualityGroup(
+            AndroidComponentAddress.forBindIntent(
+                new Intent()
+                    .setAction("action")
+                    .setPackage("pkg")
+                    .setComponent(new ComponentName("pkg", "cls"))))
+        .testEquals();
+  }
+
+  private static UserHandle newUserHandle(int userId) {
+    Parcel parcel = Parcel.obtain();
+    try {
+      parcel.writeInt(userId);
+      parcel.setDataPosition(0);
+      return new UserHandle(parcel);
+    } finally {
+      parcel.recycle();
+    }
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/BindServiceFlagsTest.java b/binder/src/test/java/io/grpc/binder/BindServiceFlagsTest.java
new file mode 100644
index 00000000000..4b34148fa49
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/BindServiceFlagsTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2021 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;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.Context;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class BindServiceFlagsTest {
+
+  @Test
+  public void shouldAutoCreateByDefault() {
+    assertThat(BindServiceFlags.DEFAULTS.toInteger() & Context.BIND_AUTO_CREATE).isNotEqualTo(0);
+  }
+
+  @Test
+  public void shouldCheckForInequality() {
+    assertThat(BindServiceFlags.newBuilder().setAutoCreate(true).build())
+        .isNotEqualTo(BindServiceFlags.newBuilder().build());
+  }
+
+  @Test
+  public void shouldCheckForEquality() {
+    assertThat(BindServiceFlags.DEFAULTS).isEqualTo(BindServiceFlags.DEFAULTS.toBuilder().build());
+  }
+
+  @Test
+  public void shouldReflectResetFlags() {
+    assertThat(
+            BindServiceFlags.newBuilder()
+                .setAutoCreate(true)
+                .setAutoCreate(false)
+                .setAutoCreate(true)
+                .build()
+                .toInteger())
+        .isEqualTo(Context.BIND_AUTO_CREATE);
+  }
+
+  @Test
+  public void shouldReflectReclearedFlags() {
+    assertThat(
+            BindServiceFlags.newBuilder()
+                .setAutoCreate(false)
+                .setAutoCreate(true)
+                .setAutoCreate(false)
+                .build()
+                .toInteger())
+        .isEqualTo(0);
+  }
+
+  @Test
+  public void shouldReflectSetFlags() {
+    assertThat(
+            BindServiceFlags.newBuilder()
+                .setAutoCreate(true)
+                .setAdjustWithActivity(true)
+                .setAboveClient(true)
+                .setAllowActivityStarts(true)
+                .setAllowOomManagement(true)
+                .setImportant(true)
+                .setIncludeCapabilities(true)
+                .setNotForeground(true)
+                .setNotPerceptible(true)
+                .setWaivePriority(true)
+                .build()
+                .toInteger())
+        .isEqualTo(
+            Context.BIND_AUTO_CREATE
+                | Context.BIND_ADJUST_WITH_ACTIVITY
+                | Context.BIND_ABOVE_CLIENT
+                | Context.BIND_ALLOW_OOM_MANAGEMENT
+                | Context.BIND_IMPORTANT
+                | Context.BIND_INCLUDE_CAPABILITIES
+                | Context.BIND_NOT_FOREGROUND
+                | Context.BIND_NOT_PERCEPTIBLE
+                | Context.BIND_WAIVE_PRIORITY
+                | Context.BIND_ALLOW_ACTIVITY_STARTS);
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/BinderChannelBuilderTest.java b/binder/src/test/java/io/grpc/binder/BinderChannelBuilderTest.java
new file mode 100644
index 00000000000..5dd7e13107e
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/BinderChannelBuilderTest.java
@@ -0,0 +1,44 @@
+/*
+ * 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;
+
+import static org.junit.Assert.fail;
+
+import android.content.Context;
+import androidx.test.core.app.ApplicationProvider;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public final class BinderChannelBuilderTest {
+  private final Context appContext = ApplicationProvider.getApplicationContext();
+  private final AndroidComponentAddress addr = AndroidComponentAddress.forContext(appContext);
+
+  @Test
+  public void strictLifecycleManagementForbidsIdleTimers() {
+    BinderChannelBuilder builder = BinderChannelBuilder.forAddress(addr, appContext);
+    builder.strictLifecycleManagement();
+    try {
+      builder.idleTimeout(10, TimeUnit.SECONDS);
+      fail();
+    } catch (IllegalStateException ise) {
+      // Expected.
+    }
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/BinderChannelCredentialsTest.java b/binder/src/test/java/io/grpc/binder/BinderChannelCredentialsTest.java
new file mode 100644
index 00000000000..f4e1a57e127
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/BinderChannelCredentialsTest.java
@@ -0,0 +1,32 @@
+package io.grpc.binder;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.ComponentName;
+import android.content.Context;
+import androidx.test.core.app.ApplicationProvider;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public class BinderChannelCredentialsTest {
+  private final Context appContext = ApplicationProvider.getApplicationContext();
+
+  @Test
+  public void defaultBinderChannelCredentials() {
+    BinderChannelCredentials channelCredentials = BinderChannelCredentials.forDefault();
+    assertThat(channelCredentials.getDevicePolicyAdminComponentName()).isNull();
+  }
+
+  @Test
+  public void binderChannelCredentialsForDevicePolicyAdmin() {
+    String deviceAdminClassName = "DevicePolicyAdmin";
+    BinderChannelCredentials channelCredentials =
+        BinderChannelCredentials.forDevicePolicyAdmin(
+            new ComponentName(appContext, deviceAdminClassName));
+    assertThat(channelCredentials.getDevicePolicyAdminComponentName()).isNotNull();
+    assertThat(channelCredentials.getDevicePolicyAdminComponentName().getClassName())
+        .isEqualTo(deviceAdminClassName);
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/BinderServerBuilderTest.java b/binder/src/test/java/io/grpc/binder/BinderServerBuilderTest.java
new file mode 100644
index 00000000000..64762d6407e
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/BinderServerBuilderTest.java
@@ -0,0 +1,75 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.app.Service;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.os.IBinder;
+import androidx.annotation.Nullable;
+import io.grpc.Server;
+import java.io.IOException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.Robolectric;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.android.controller.ServiceController;
+
+@RunWith(RobolectricTestRunner.class)
+public final class BinderServerBuilderTest {
+
+  private final IBinderReceiver binderReceiver = new IBinderReceiver();
+
+  @Test
+  public void shouldExposeListeningBinderUponBuild() {
+    ServiceController<SomeService> controller = Robolectric.buildService(SomeService.class);
+    SomeService service = controller.create().get();
+
+    AndroidComponentAddress listenAddress = AndroidComponentAddress.forContext(service);
+    Server server = BinderServerBuilder.forAddress(listenAddress, binderReceiver).build();
+    try {
+      assertThat(binderReceiver.get()).isNotNull();
+    } finally {
+      server.shutdownNow();
+    }
+  }
+
+  @Test
+  public void shouldExposeSpecifiedListeningAddressUponBuild() throws IOException {
+    AndroidComponentAddress listenAddress =
+        AndroidComponentAddress.forBindIntent(
+            new Intent()
+                .setAction("some-action")
+                .setComponent(new ComponentName("com.foo", "com.foo.SomeService")));
+    Server server = BinderServerBuilder.forAddress(listenAddress, binderReceiver).build().start();
+    try {
+      assertThat(server.getListenSockets()).containsExactly(listenAddress);
+    } finally {
+      server.shutdownNow();
+    }
+  }
+
+  private static class SomeService extends Service {
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent) {
+      return null;
+    }
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/LifecycleOnDestroyHelperTest.java b/binder/src/test/java/io/grpc/binder/LifecycleOnDestroyHelperTest.java
new file mode 100644
index 00000000000..48365204f73
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/LifecycleOnDestroyHelperTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2021 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;
+
+import static android.os.Looper.getMainLooper;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.robolectric.Shadows.shadowOf;
+
+import androidx.lifecycle.LifecycleService;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.Robolectric;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.android.controller.ServiceController;
+
+@RunWith(RobolectricTestRunner.class)
+public final class LifecycleOnDestroyHelperTest {
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private ServiceController<MyService> sourceController;
+  private MyService sourceService;
+
+  @Mock ManagedChannel mockChannel;
+  @Mock Server mockServer;
+
+  @Before
+  public void setup() {
+    sourceController = Robolectric.buildService(MyService.class);
+    sourceService = sourceController.create().get();
+  }
+
+  @Test
+  public void shouldShutdownChannelUponSourceDestruction() {
+    LifecycleOnDestroyHelper.shutdownUponDestruction(sourceService.getLifecycle(), mockChannel);
+    shadowOf(getMainLooper()).idle();
+    verifyNoInteractions(mockChannel);
+
+    sourceController.destroy();
+    shadowOf(getMainLooper()).idle();
+    verify(mockChannel).shutdownNow();
+  }
+
+  @Test
+  public void shouldShutdownChannelForInitiallyDestroyedSource() {
+    sourceController.destroy();
+    shadowOf(getMainLooper()).idle();
+
+    LifecycleOnDestroyHelper.shutdownUponDestruction(sourceService.getLifecycle(), mockChannel);
+    verify(mockChannel).shutdownNow();
+  }
+
+  @Test
+  public void shouldShutdownServerUponServiceDestruction() {
+    LifecycleOnDestroyHelper.shutdownUponDestruction(sourceService.getLifecycle(), mockServer);
+    shadowOf(getMainLooper()).idle();
+    verifyNoInteractions(mockServer);
+
+    sourceController.destroy();
+    shadowOf(getMainLooper()).idle();
+    verify(mockServer).shutdownNow();
+  }
+
+  @Test
+  public void shouldShutdownServerForInitiallyDestroyedSource() {
+    sourceController.destroy();
+    shadowOf(getMainLooper()).idle();
+
+    LifecycleOnDestroyHelper.shutdownUponDestruction(sourceService.getLifecycle(), mockServer);
+    verify(mockServer).shutdownNow();
+  }
+
+  private static class MyService extends LifecycleService {}
+}
diff --git a/binder/src/test/java/io/grpc/binder/PeerUidTest.java b/binder/src/test/java/io/grpc/binder/PeerUidTest.java
new file mode 100644
index 00000000000..5c7c9f2ba5a
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/PeerUidTest.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2023 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;
+
+import com.google.common.testing.EqualsTester;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class PeerUidTest {
+
+  @Test
+  public void shouldImplementEqualsAndHashCode() {
+    new EqualsTester()
+        .addEqualityGroup(new PeerUid(123), new PeerUid(123))
+        .addEqualityGroup(new PeerUid(456))
+        .testEquals();
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/PeerUidTestHelperTest.java b/binder/src/test/java/io/grpc/binder/PeerUidTestHelperTest.java
new file mode 100644
index 00000000000..c9e055b9fe0
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/PeerUidTestHelperTest.java
@@ -0,0 +1,122 @@
+package io.grpc.binder;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientInterceptors;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerInterceptors;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.stub.ClientCalls;
+import io.grpc.stub.MetadataUtils;
+import io.grpc.stub.ServerCalls;
+import io.grpc.testing.GrpcCleanupRule;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class PeerUidTestHelperTest {
+
+  @Rule public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+  private static final int FAKE_UID = 12345;
+
+  private final AtomicReference<PeerUid> clientUidCapture = new AtomicReference<>();
+
+  @Test
+  public void keyPopulatedWithInterceptorAndHeader() throws Exception {
+    makeServiceCall(/* includeInterceptor= */ true, /* includeUidInHeader= */ true, FAKE_UID);
+    assertThat(clientUidCapture.get()).isEqualTo(new PeerUid(FAKE_UID));
+  }
+
+  @Test
+  public void keyNotPopulatedWithInterceptorAndNoHeader() throws Exception {
+    makeServiceCall(/* includeInterceptor= */ true, /* includeUidInHeader= */ false, /* uid= */ -1);
+    assertThat(clientUidCapture.get()).isNull();
+  }
+
+  @Test
+  public void keyNotPopulatedWithoutInterceptorAndWithHeader() throws Exception {
+    makeServiceCall(
+        /* includeInterceptor= */ false, /* includeUidInHeader= */ true, /* uid= */ FAKE_UID);
+    assertThat(clientUidCapture.get()).isNull();
+  }
+
+  private final MethodDescriptor<String, String> method =
+      MethodDescriptor.newBuilder(StringMarshaller.INSTANCE, StringMarshaller.INSTANCE)
+          .setFullMethodName("test/method")
+          .setType(MethodDescriptor.MethodType.UNARY)
+          .build();
+
+  private void makeServiceCall(boolean includeInterceptor, boolean includeUidInHeader, int uid)
+      throws Exception {
+    ServerCallHandler<String, String> callHandler =
+        ServerCalls.asyncUnaryCall(
+            (req, respObserver) -> {
+              clientUidCapture.set(PeerUids.REMOTE_PEER.get());
+              respObserver.onNext(req);
+              respObserver.onCompleted();
+            });
+    ImmutableList<ServerInterceptor> interceptors;
+    if (includeInterceptor) {
+      interceptors = ImmutableList.of(PeerUidTestHelper.newTestPeerIdentifyingServerInterceptor());
+    } else {
+      interceptors = ImmutableList.of();
+    }
+    ServerServiceDefinition serviceDef =
+        ServerInterceptors.intercept(
+            ServerServiceDefinition.builder("test").addMethod(method, callHandler).build(),
+            interceptors);
+
+    InProcessServerBuilder server =
+        InProcessServerBuilder.forName("test").directExecutor().addService(serviceDef);
+
+    grpcCleanup.register(server.build().start());
+
+    Channel channel = InProcessChannelBuilder.forName("test").directExecutor().build();
+    grpcCleanup.register((ManagedChannel) channel);
+
+    if (includeUidInHeader) {
+      Metadata header = new Metadata();
+      header.put(PeerUidTestHelper.UID_KEY, uid);
+      channel =
+          ClientInterceptors.intercept(channel, MetadataUtils.newAttachHeadersInterceptor(header));
+    }
+
+    ClientCalls.blockingUnaryCall(channel, method, CallOptions.DEFAULT, "hello");
+  }
+
+  private static class StringMarshaller implements MethodDescriptor.Marshaller<String> {
+
+    public static final StringMarshaller INSTANCE = new StringMarshaller();
+
+    @Override
+    public InputStream stream(String value) {
+      return new ByteArrayInputStream(value.getBytes(UTF_8));
+    }
+
+    @Override
+    public String parse(InputStream stream) {
+      try {
+        return new String(stream.readAllBytes(), UTF_8);
+      } catch (IOException ex) {
+        throw new RuntimeException(ex);
+      }
+    }
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/PeerUidsTest.java b/binder/src/test/java/io/grpc/binder/PeerUidsTest.java
new file mode 100644
index 00000000000..f87f7bd56f1
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/PeerUidsTest.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2023 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertThrows;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.ByteStreams;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ManagedChannel;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerInterceptors;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.ServerTransportFilter;
+import io.grpc.StatusRuntimeException;
+import io.grpc.binder.internal.BinderTransport;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.stub.ClientCalls;
+import io.grpc.stub.ServerCalls;
+import io.grpc.testing.GrpcCleanupRule;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class PeerUidsTest {
+  @Rule public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+  private static final int FAKE_UID = 12345;
+
+  private final MethodDescriptor<String, String> method =
+      MethodDescriptor.newBuilder(StringMarshaller.INSTANCE, StringMarshaller.INSTANCE)
+          .setFullMethodName("test/method")
+          .setType(MethodDescriptor.MethodType.UNARY)
+          .build();
+
+  private final AtomicReference<PeerUid> clientUidCapture = new AtomicReference<>();
+
+  @Test
+  public void keyPopulatedWithInterceptor() throws Exception {
+    makeServiceCall(/* populateUid= */ true, /* includeInterceptor= */ true);
+    assertThat(clientUidCapture.get()).isEqualTo(new PeerUid(FAKE_UID));
+  }
+
+  @Test
+  public void keyNotPopulatedWithoutInterceptor() throws Exception {
+    makeServiceCall(/* populateUid= */ true, /* includeInterceptor= */ false);
+    assertThat(clientUidCapture.get()).isNull();
+  }
+
+  @Test
+  public void exceptionThrownWithoutUid() throws Exception {
+    assertThrows(
+        StatusRuntimeException.class,
+        () -> makeServiceCall(/* populateUid= */ false, /* includeInterceptor= */ true));
+  }
+
+  private void makeServiceCall(boolean populateUid, boolean includeInterceptor) throws Exception {
+    ServerCallHandler<String, String> callHandler =
+        ServerCalls.asyncUnaryCall(
+            (req, respObserver) -> {
+              clientUidCapture.set(PeerUids.REMOTE_PEER.get());
+              respObserver.onNext(req);
+              respObserver.onCompleted();
+            });
+    ImmutableList<ServerInterceptor> interceptors;
+    if (includeInterceptor) {
+      interceptors = ImmutableList.of(PeerUids.newPeerIdentifyingServerInterceptor());
+    } else {
+      interceptors = ImmutableList.of();
+    }
+    ServerServiceDefinition serviceDef =
+        ServerInterceptors.intercept(
+            ServerServiceDefinition.builder("test").addMethod(method, callHandler).build(),
+            interceptors);
+
+    InProcessServerBuilder server =
+        InProcessServerBuilder.forName("test").directExecutor().addService(serviceDef);
+    if (populateUid) {
+      server.addTransportFilter(
+          new ServerTransportFilter() {
+            @Override
+            public Attributes transportReady(Attributes attributes) {
+              return attributes.toBuilder().set(BinderTransport.REMOTE_UID, FAKE_UID).build();
+            }
+          });
+    }
+    grpcCleanup.register(server.build().start());
+    ManagedChannel channel = InProcessChannelBuilder.forName("test").directExecutor().build();
+
+    ClientCalls.blockingUnaryCall(channel, method, CallOptions.DEFAULT, "hello");
+  }
+
+  private static class StringMarshaller implements MethodDescriptor.Marshaller<String> {
+    public static final StringMarshaller INSTANCE = new StringMarshaller();
+
+    @Override
+    public InputStream stream(String value) {
+      return new ByteArrayInputStream(value.getBytes(UTF_8));
+    }
+
+    @Override
+    public String parse(InputStream stream) {
+      try {
+        return new String(ByteStreams.toByteArray(stream), UTF_8);
+      } catch (IOException ex) {
+        throw new RuntimeException(ex);
+      }
+    }
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/RobolectricBinderSecurityTest.java b/binder/src/test/java/io/grpc/binder/RobolectricBinderSecurityTest.java
new file mode 100644
index 00000000000..ffd1d89e69c
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/RobolectricBinderSecurityTest.java
@@ -0,0 +1,200 @@
+/*
+ * 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;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
+import static org.robolectric.Shadows.shadowOf;
+
+import android.app.Application;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.ServiceInfo;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.core.content.pm.ApplicationInfoBuilder;
+import androidx.test.core.content.pm.PackageInfoBuilder;
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.protobuf.Empty;
+import io.grpc.CallOptions;
+import io.grpc.ClientCall;
+import io.grpc.ManagedChannel;
+import io.grpc.MethodDescriptor;
+import io.grpc.Server;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerMethodDefinition;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.protobuf.lite.ProtoLiteUtils;
+import io.grpc.stub.ClientCalls;
+import io.grpc.stub.ServerCalls;
+import java.io.IOException;
+import java.util.concurrent.ArrayBlockingQueue;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.ParameterizedRobolectricTestRunner;
+import org.robolectric.ParameterizedRobolectricTestRunner.Parameter;
+import org.robolectric.ParameterizedRobolectricTestRunner.Parameters;
+import org.robolectric.annotation.LooperMode;
+import org.robolectric.annotation.LooperMode.Mode;
+
+@RunWith(ParameterizedRobolectricTestRunner.class)
+@LooperMode(Mode.INSTRUMENTATION_TEST)
+public final class RobolectricBinderSecurityTest {
+
+  private static final String SERVICE_NAME = "fake_service";
+  private static final String FULL_METHOD_NAME = "fake_service/fake_method";
+  private final Application context = ApplicationProvider.getApplicationContext();
+  private final ArrayBlockingQueue<SettableFuture<Status>> statusesToSet =
+      new ArrayBlockingQueue<>(128);
+  private ManagedChannel channel;
+  private Server server;
+
+  @Parameter public boolean preAuthServersParam;
+
+  @Parameters(name = "preAuthServersParam={0}")
+  public static ImmutableList<Boolean> data() {
+    return ImmutableList.of(true, false);
+  }
+
+  @Before
+  public void setUp() {
+    ApplicationInfo serverAppInfo =
+        ApplicationInfoBuilder.newBuilder().setPackageName(context.getPackageName()).build();
+    serverAppInfo.uid = android.os.Process.myUid();
+    PackageInfo serverPkgInfo =
+        PackageInfoBuilder.newBuilder()
+            .setPackageName(serverAppInfo.packageName)
+            .setApplicationInfo(serverAppInfo)
+            .build();
+    shadowOf(context.getPackageManager()).installPackage(serverPkgInfo);
+
+    ServiceInfo serviceInfo = new ServiceInfo();
+    serviceInfo.name = "SomeService";
+    serviceInfo.packageName = serverAppInfo.packageName;
+    serviceInfo.applicationInfo = serverAppInfo;
+    shadowOf(context.getPackageManager()).addOrUpdateService(serviceInfo);
+
+    AndroidComponentAddress listenAddress =
+        AndroidComponentAddress.forRemoteComponent(serviceInfo.packageName, serviceInfo.name);
+
+    MethodDescriptor<Empty, Empty> methodDesc = getMethodDescriptor();
+    ServerCallHandler<Empty, Empty> callHandler =
+        ServerCalls.asyncUnaryCall(
+            (req, respObserver) -> {
+              respObserver.onNext(req);
+              respObserver.onCompleted();
+            });
+    ServerMethodDefinition<Empty, Empty> methodDef =
+        ServerMethodDefinition.create(methodDesc, callHandler);
+    ServerServiceDefinition def =
+        ServerServiceDefinition.builder(SERVICE_NAME).addMethod(methodDef).build();
+
+    IBinderReceiver binderReceiver = new IBinderReceiver();
+    server =
+        BinderServerBuilder.forAddress(listenAddress, binderReceiver)
+            .addService(def)
+            .securityPolicy(
+                ServerSecurityPolicy.newBuilder()
+                    .servicePolicy(
+                        SERVICE_NAME,
+                        new AsyncSecurityPolicy() {
+                          @Override
+                          public ListenableFuture<Status> checkAuthorizationAsync(int uid) {
+                            SettableFuture<Status> status = SettableFuture.create();
+                            statusesToSet.add(status);
+                            return status;
+                          }
+                        })
+                    .build())
+            .build();
+    try {
+      server.start();
+    } catch (IOException e) {
+      throw new IllegalStateException(e);
+    }
+
+    shadowOf(context)
+        .setComponentNameAndServiceForBindServiceForIntent(
+            listenAddress.asBindIntent(),
+            listenAddress.getComponent(),
+            checkNotNull(binderReceiver.get()));
+    channel =
+        BinderChannelBuilder.forAddress(listenAddress, context)
+            .preAuthorizeServers(preAuthServersParam)
+            .build();
+  }
+
+  @After
+  public void tearDown() {
+    channel.shutdownNow();
+    server.shutdownNow();
+  }
+
+  @Test
+  public void testAsyncServerSecurityPolicy_failed_returnsFailureStatus() throws Exception {
+    ListenableFuture<Status> status = makeCall();
+    statusesToSet.take().set(Status.ALREADY_EXISTS);
+
+    assertThat(status.get().getCode()).isEqualTo(Status.Code.ALREADY_EXISTS);
+  }
+
+  @Test
+  public void testAsyncServerSecurityPolicy_failedFuture_failsWithCodeInternal() throws Exception {
+    ListenableFuture<Status> status = makeCall();
+    statusesToSet.take().setException(new IllegalStateException("oops"));
+
+    assertThat(status.get().getCode()).isEqualTo(Status.Code.INTERNAL);
+  }
+
+  @Test
+  public void testAsyncServerSecurityPolicy_allowed_returnsOkStatus() throws Exception {
+    ListenableFuture<Status> status = makeCall();
+    statusesToSet.take().set(Status.OK);
+
+    assertThat(status.get().getCode()).isEqualTo(Status.Code.OK);
+  }
+
+  private ListenableFuture<Status> makeCall() {
+    ClientCall<Empty, Empty> call = channel.newCall(getMethodDescriptor(), CallOptions.DEFAULT);
+    ListenableFuture<Empty> responseFuture =
+        ClientCalls.futureUnaryCall(call, Empty.getDefaultInstance());
+
+    return Futures.catching(
+        Futures.transform(responseFuture, unused -> Status.OK, directExecutor()),
+        StatusRuntimeException.class,
+        StatusRuntimeException::getStatus,
+        directExecutor());
+  }
+
+  private static MethodDescriptor<Empty, Empty> getMethodDescriptor() {
+    MethodDescriptor.Marshaller<Empty> marshaller =
+        ProtoLiteUtils.marshaller(Empty.getDefaultInstance());
+
+    return MethodDescriptor.newBuilder(marshaller, marshaller)
+        .setFullMethodName(FULL_METHOD_NAME)
+        .setType(MethodDescriptor.MethodType.UNARY)
+        .setSampledToLocalTracing(true)
+        .build();
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/SecurityPoliciesTest.java b/binder/src/test/java/io/grpc/binder/SecurityPoliciesTest.java
new file mode 100644
index 00000000000..71180ed43c5
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/SecurityPoliciesTest.java
@@ -0,0 +1,706 @@
+/*
+ * 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;
+
+import static android.Manifest.permission.ACCESS_COARSE_LOCATION;
+import static android.Manifest.permission.ACCESS_FINE_LOCATION;
+import static android.Manifest.permission.WRITE_EXTERNAL_STORAGE;
+import static android.content.pm.PackageInfo.REQUESTED_PERMISSION_GRANTED;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.truth.Truth.assertThat;
+import static org.robolectric.Shadows.shadowOf;
+
+import android.app.admin.DevicePolicyManager;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.content.pm.Signature;
+import android.os.Process;
+import androidx.test.core.app.ApplicationProvider;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.hash.Hashing;
+import io.grpc.Status;
+import java.util.HashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+public final class SecurityPoliciesTest {
+
+  private static final int MY_UID = Process.myUid();
+  private static final int OTHER_UID = MY_UID + 1;
+  private static final int OTHER_UID_SAME_SIGNATURE = MY_UID + 2;
+  private static final int OTHER_UID_UNKNOWN = MY_UID + 4;
+
+  private static final String PERMISSION_DENIED_REASONS = "some reasons";
+
+  private static final Signature SIG1 = new Signature("1234");
+  private static final Signature SIG2 = new Signature("4321");
+
+  private static final String OTHER_UID_PACKAGE_NAME = "other.package";
+  private static final String OTHER_UID_SAME_SIGNATURE_PACKAGE_NAME = "other.package.samesignature";
+
+  private Context appContext;
+  private PackageManager packageManager;
+  private DevicePolicyManager devicePolicyManager;
+
+  private SecurityPolicy policy;
+
+  @Before
+  public void setUp() {
+    appContext = ApplicationProvider.getApplicationContext();
+    packageManager = appContext.getPackageManager();
+    devicePolicyManager =
+        (DevicePolicyManager) appContext.getSystemService(Context.DEVICE_POLICY_SERVICE);
+  }
+
+  @SuppressWarnings("deprecation")
+  private void installPackages(int uid, PackageInfo... packageInfo) {
+    String[] packageNames = new String[packageInfo.length];
+    for (int i = 0; i < packageInfo.length; i++) {
+      shadowOf(packageManager).installPackage(packageInfo[i]);
+      packageNames[i] = packageInfo[i].packageName;
+    }
+    shadowOf(packageManager).setPackagesForUid(uid, packageNames);
+  }
+
+  @Test
+  public void testInternalOnly() throws Exception {
+    policy = SecurityPolicies.internalOnly();
+
+    assertThat(policy.checkAuthorization(MY_UID).getCode()).isEqualTo(Status.OK.getCode());
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  public void testPermissionDenied() throws Exception {
+    policy = SecurityPolicies.permissionDenied(PERMISSION_DENIED_REASONS);
+    assertThat(policy.checkAuthorization(MY_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(policy.checkAuthorization(MY_UID).getDescription())
+        .isEqualTo(PERMISSION_DENIED_REASONS);
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(policy.checkAuthorization(OTHER_UID).getDescription())
+        .isEqualTo(PERMISSION_DENIED_REASONS);
+  }
+
+  @Test
+  public void testHasSignature_succeedsIfPackageNameAndSignaturesMatch() throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+
+    installPackages(OTHER_UID, info);
+
+    policy = SecurityPolicies.hasSignature(packageManager, OTHER_UID_PACKAGE_NAME, SIG2);
+
+    // THEN UID for package that has SIG2 will be authorized
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode()).isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  public void testHasSignature_failsIfPackageNameDoesNotMatch() throws Exception {
+    PackageInfo info =
+        newBuilder()
+            .setPackageName(OTHER_UID_SAME_SIGNATURE_PACKAGE_NAME)
+            .setSignatures(SIG1)
+            .build();
+
+    installPackages(OTHER_UID_SAME_SIGNATURE, info);
+
+    policy = SecurityPolicies.hasSignature(packageManager, appContext.getPackageName(), SIG1);
+
+    // THEN UID for package that has SIG1 but different package name will not be authorized
+    assertThat(policy.checkAuthorization(OTHER_UID_SAME_SIGNATURE).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  public void testHasSignature_failsIfSignatureDoesNotMatch() throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+
+    installPackages(OTHER_UID, info);
+
+    policy = SecurityPolicies.hasSignature(packageManager, OTHER_UID_PACKAGE_NAME, SIG1);
+
+    // THEN UID for package that doesn't have SIG1 will not be authorized
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  public void testOneOfSignatures_succeedsIfPackageNameAndSignaturesMatch() throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+
+    installPackages(OTHER_UID, info);
+
+    policy =
+        SecurityPolicies.oneOfSignatures(
+            packageManager, OTHER_UID_PACKAGE_NAME, ImmutableList.of(SIG2));
+
+    // THEN UID for package that has SIG2 will be authorized
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode()).isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  public void testOneOfSignature_failsIfAllSignaturesDoNotMatch() throws Exception {
+    PackageInfo info =
+        newBuilder()
+            .setPackageName(OTHER_UID_SAME_SIGNATURE_PACKAGE_NAME)
+            .setSignatures(SIG1)
+            .build();
+
+    installPackages(OTHER_UID_SAME_SIGNATURE, info);
+
+    policy =
+        SecurityPolicies.oneOfSignatures(
+            packageManager,
+            appContext.getPackageName(),
+            ImmutableList.of(SIG1, new Signature("1314")));
+
+    // THEN UID for package that has SIG1 but different package name will not be authorized
+    assertThat(policy.checkAuthorization(OTHER_UID_SAME_SIGNATURE).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  public void testOneOfSignature_succeedsIfPackageNameAndOneOfSignaturesMatch() throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+
+    installPackages(OTHER_UID, info);
+
+    policy =
+        SecurityPolicies.oneOfSignatures(
+            packageManager, OTHER_UID_PACKAGE_NAME, ImmutableList.of(SIG1, SIG2));
+
+    // THEN UID for package that has SIG2 will be authorized
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode()).isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  public void testHasSignature_failsIfUidUnknown() throws Exception {
+    policy = SecurityPolicies.hasSignature(packageManager, appContext.getPackageName(), SIG1);
+
+    assertThat(policy.checkAuthorization(OTHER_UID_UNKNOWN).getCode())
+        .isEqualTo(Status.UNAUTHENTICATED.getCode());
+  }
+
+  @Test
+  public void testHasPermissions_sharedUserId_succeedsIfAllPackageHavePermissions()
+      throws Exception {
+    PackageInfo info =
+        newBuilder()
+            .setPackageName(OTHER_UID_PACKAGE_NAME)
+            .setPermission(ACCESS_FINE_LOCATION, REQUESTED_PERMISSION_GRANTED)
+            .setPermission(ACCESS_COARSE_LOCATION, REQUESTED_PERMISSION_GRANTED)
+            .build();
+
+    PackageInfo infoSamePerms =
+        newBuilder()
+            .setPackageName(OTHER_UID_SAME_SIGNATURE_PACKAGE_NAME)
+            .setPermission(ACCESS_FINE_LOCATION, REQUESTED_PERMISSION_GRANTED)
+            .setPermission(ACCESS_COARSE_LOCATION, REQUESTED_PERMISSION_GRANTED)
+            .build();
+
+    installPackages(OTHER_UID, info, infoSamePerms);
+
+    policy =
+        SecurityPolicies.hasPermissions(
+            packageManager, ImmutableSet.of(ACCESS_FINE_LOCATION, ACCESS_COARSE_LOCATION));
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode()).isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  public void testHasPermissions_sharedUserId_failsIfOnePackageHasNoPermissions() throws Exception {
+    PackageInfo info =
+        newBuilder()
+            .setPackageName(OTHER_UID_PACKAGE_NAME)
+            .setPermission(ACCESS_FINE_LOCATION, REQUESTED_PERMISSION_GRANTED)
+            .build();
+
+    PackageInfo infoNoPerms =
+        newBuilder()
+            .setPackageName(OTHER_UID_SAME_SIGNATURE_PACKAGE_NAME)
+            .setPermission(ACCESS_FINE_LOCATION, 0)
+            .build();
+
+    installPackages(OTHER_UID, info, infoNoPerms);
+
+    policy = SecurityPolicies.hasPermissions(packageManager, ImmutableSet.of(ACCESS_FINE_LOCATION));
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(policy.checkAuthorization(OTHER_UID).getDescription())
+        .contains(ACCESS_FINE_LOCATION);
+    assertThat(policy.checkAuthorization(OTHER_UID).getDescription())
+        .contains(OTHER_UID_SAME_SIGNATURE_PACKAGE_NAME);
+  }
+
+  @Test
+  public void testHasPermissions_succeedsIfPackageHasPermissions() throws Exception {
+    PackageInfo info =
+        newBuilder()
+            .setPackageName(OTHER_UID_PACKAGE_NAME)
+            .setPermission(ACCESS_FINE_LOCATION, REQUESTED_PERMISSION_GRANTED)
+            .setPermission(ACCESS_COARSE_LOCATION, REQUESTED_PERMISSION_GRANTED)
+            .setPermission(WRITE_EXTERNAL_STORAGE, 0)
+            .build();
+
+    installPackages(OTHER_UID, info);
+
+    policy =
+        SecurityPolicies.hasPermissions(
+            packageManager, ImmutableSet.of(ACCESS_FINE_LOCATION, ACCESS_COARSE_LOCATION));
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode()).isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  public void testHasPermissions_failsIfPackageDoesNotHaveOnePermission() throws Exception {
+    PackageInfo info =
+        newBuilder()
+            .setPackageName(OTHER_UID_PACKAGE_NAME)
+            .setPermission(ACCESS_FINE_LOCATION, REQUESTED_PERMISSION_GRANTED)
+            .setPermission(ACCESS_COARSE_LOCATION, REQUESTED_PERMISSION_GRANTED)
+            .setPermission(WRITE_EXTERNAL_STORAGE, 0)
+            .build();
+
+    installPackages(OTHER_UID, info);
+
+    policy =
+        SecurityPolicies.hasPermissions(
+            packageManager, ImmutableSet.of(ACCESS_FINE_LOCATION, WRITE_EXTERNAL_STORAGE));
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(policy.checkAuthorization(OTHER_UID).getDescription())
+        .contains(WRITE_EXTERNAL_STORAGE);
+    assertThat(policy.checkAuthorization(OTHER_UID).getDescription())
+        .contains(OTHER_UID_PACKAGE_NAME);
+  }
+
+  @Test
+  public void testHasPermissions_failsIfPackageDoesNotHavePermissions() throws Exception {
+    PackageInfo info =
+        newBuilder()
+            .setPackageName(OTHER_UID_PACKAGE_NAME)
+            .setPermission(ACCESS_FINE_LOCATION, REQUESTED_PERMISSION_GRANTED)
+            .setPermission(ACCESS_COARSE_LOCATION, REQUESTED_PERMISSION_GRANTED)
+            .setPermission(WRITE_EXTERNAL_STORAGE, 0)
+            .build();
+
+    installPackages(OTHER_UID, info);
+
+    policy =
+        SecurityPolicies.hasPermissions(packageManager, ImmutableSet.of(WRITE_EXTERNAL_STORAGE));
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(policy.checkAuthorization(OTHER_UID).getDescription())
+        .contains(WRITE_EXTERNAL_STORAGE);
+    assertThat(policy.checkAuthorization(OTHER_UID).getDescription())
+        .contains(OTHER_UID_PACKAGE_NAME);
+  }
+
+  @Test
+  public void testIsDeviceOwner_succeedsForDeviceOwner() throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+
+    installPackages(OTHER_UID, info);
+    shadowOf(devicePolicyManager).setDeviceOwner(new ComponentName(OTHER_UID_PACKAGE_NAME, "foo"));
+
+    policy = SecurityPolicies.isDeviceOwner(appContext);
+
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode()).isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  public void testIsDeviceOwner_failsForNotDeviceOwner() throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+
+    installPackages(OTHER_UID, info);
+
+    policy = SecurityPolicies.isDeviceOwner(appContext);
+
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  public void testIsDeviceOwner_failsWhenNoPackagesForUid() throws Exception {
+    policy = SecurityPolicies.isDeviceOwner(appContext);
+
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.UNAUTHENTICATED.getCode());
+  }
+
+  @Test
+  @Config(sdk = Config.OLDEST_SDK)
+  public void testIsProfileOwner_succeedsForProfileOwner() throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+
+    installPackages(OTHER_UID, info);
+    shadowOf(devicePolicyManager).setProfileOwner(new ComponentName(OTHER_UID_PACKAGE_NAME, "foo"));
+
+    policy = SecurityPolicies.isProfileOwner(appContext);
+
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode()).isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  @Config(sdk = Config.OLDEST_SDK)
+  public void testIsProfileOwner_failsForNotProfileOwner() throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+
+    installPackages(OTHER_UID, info);
+
+    policy = SecurityPolicies.isProfileOwner(appContext);
+
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  @Config(sdk = Config.OLDEST_SDK)
+  public void testIsProfileOwner_failsWhenNoPackagesForUid() throws Exception {
+    policy = SecurityPolicies.isProfileOwner(appContext);
+
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.UNAUTHENTICATED.getCode());
+  }
+
+  @Test
+  @Config(sdk = 30)
+  public void testIsProfileOwnerOnOrgOwned_succeedsForProfileOwnerOnOrgOwned() throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+
+    installPackages(OTHER_UID, info);
+    shadowOf(devicePolicyManager).setProfileOwner(new ComponentName(OTHER_UID_PACKAGE_NAME, "foo"));
+    shadowOf(devicePolicyManager).setOrganizationOwnedDeviceWithManagedProfile(true);
+
+    policy = SecurityPolicies.isProfileOwnerOnOrganizationOwnedDevice(appContext);
+
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode()).isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  @Config(sdk = 30)
+  public void testIsProfileOwnerOnOrgOwned_failsForProfileOwnerOnNonOrgOwned() throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+
+    installPackages(OTHER_UID, info);
+    shadowOf(devicePolicyManager).setProfileOwner(new ComponentName(OTHER_UID_PACKAGE_NAME, "foo"));
+    shadowOf(devicePolicyManager).setOrganizationOwnedDeviceWithManagedProfile(false);
+
+    policy = SecurityPolicies.isProfileOwnerOnOrganizationOwnedDevice(appContext);
+
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  @Config(sdk = Config.OLDEST_SDK)
+  public void testIsProfileOwnerOnOrgOwned_failsForNotProfileOwner() throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+
+    installPackages(OTHER_UID, info);
+
+    policy = SecurityPolicies.isProfileOwnerOnOrganizationOwnedDevice(appContext);
+
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  @Config(sdk = Config.OLDEST_SDK)
+  public void testIsProfileOwnerOnOrgOwned_failsWhenNoPackagesForUid() throws Exception {
+    policy = SecurityPolicies.isProfileOwnerOnOrganizationOwnedDevice(appContext);
+
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.UNAUTHENTICATED.getCode());
+  }
+
+  @Test
+  @Config(sdk = 29)
+  public void testIsProfileOwnerOnOrgOwned_failsForSdkLevelTooLow() throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+
+    installPackages(OTHER_UID, info);
+
+    policy = SecurityPolicies.isProfileOwner(appContext);
+
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  private static PackageInfoBuilder newBuilder() {
+    return new PackageInfoBuilder();
+  }
+
+  private static class PackageInfoBuilder {
+    private String packageName;
+    private Signature[] signatures;
+    private final HashMap<String, Integer> permissions = new HashMap<>();
+
+    public PackageInfoBuilder setPackageName(String packageName) {
+      this.packageName = packageName;
+      return this;
+    }
+
+    public PackageInfoBuilder setPermission(String permissionName, int permissionFlag) {
+      this.permissions.put(permissionName, permissionFlag);
+      return this;
+    }
+
+    public PackageInfoBuilder setSignatures(Signature... signatures) {
+      this.signatures = signatures;
+      return this;
+    }
+
+    @SuppressWarnings("deprecation") // 'signatures': We don't yet support signing cert rotation.
+    public PackageInfo build() {
+      checkState(this.packageName != null, "packageName is a mandatory field");
+
+      PackageInfo packageInfo = new PackageInfo();
+
+      packageInfo.packageName = this.packageName;
+
+      if (this.signatures != null) {
+        packageInfo.signatures = this.signatures;
+      }
+
+      if (!this.permissions.isEmpty()) {
+        String[] requestedPermissions =
+            this.permissions.keySet().toArray(new String[this.permissions.size()]);
+        int[] requestedPermissionsFlags = new int[requestedPermissions.length];
+
+        for (int i = 0; i < requestedPermissions.length; i++) {
+          requestedPermissionsFlags[i] = this.permissions.get(requestedPermissions[i]);
+        }
+
+        packageInfo.requestedPermissions = requestedPermissions;
+        packageInfo.requestedPermissionsFlags = requestedPermissionsFlags;
+      }
+
+      return packageInfo;
+    }
+  }
+
+  @Test
+  public void testAllOf_succeedsIfAllSecurityPoliciesAllowed() throws Exception {
+    policy = SecurityPolicies.allOf(SecurityPolicies.internalOnly());
+
+    assertThat(policy.checkAuthorization(MY_UID).getCode()).isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  public void testAllOf_failsIfOneSecurityPoliciesNotAllowed() throws Exception {
+    policy =
+        SecurityPolicies.allOf(
+            SecurityPolicies.internalOnly(),
+            SecurityPolicies.permissionDenied("Not allowed SecurityPolicy"));
+
+    assertThat(policy.checkAuthorization(MY_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(policy.checkAuthorization(MY_UID).getDescription())
+        .contains("Not allowed SecurityPolicy");
+  }
+
+  @Test
+  public void testAnyOf_succeedsIfAnySecurityPoliciesAllowed() throws Exception {
+    RecordingPolicy recordingPolicy = new RecordingPolicy();
+    policy = SecurityPolicies.anyOf(SecurityPolicies.internalOnly(), recordingPolicy);
+
+    assertThat(policy.checkAuthorization(MY_UID).getCode()).isEqualTo(Status.OK.getCode());
+    assertThat(recordingPolicy.numCalls.get()).isEqualTo(0);
+  }
+
+  @Test
+  public void testAnyOf_failsIfNoSecurityPolicyIsAllowed() throws Exception {
+    policy =
+        SecurityPolicies.anyOf(
+            new SecurityPolicy() {
+              @Override
+              public Status checkAuthorization(int uid) {
+                return Status.PERMISSION_DENIED.withDescription("Not allowed: first");
+              }
+            },
+            new SecurityPolicy() {
+              @Override
+              public Status checkAuthorization(int uid) {
+                return Status.UNAUTHENTICATED.withDescription("Not allowed: second");
+              }
+            });
+
+    assertThat(policy.checkAuthorization(MY_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(policy.checkAuthorization(MY_UID).getDescription()).contains("Not allowed: first");
+    assertThat(policy.checkAuthorization(MY_UID).getDescription()).contains("Not allowed: second");
+  }
+
+  private static final class RecordingPolicy extends SecurityPolicy {
+    private final AtomicInteger numCalls = new AtomicInteger(0);
+
+    @Override
+    public Status checkAuthorization(int uid) {
+      numCalls.incrementAndGet();
+      return Status.OK;
+    }
+  }
+
+  @Test
+  public void testHasSignatureSha256Hash_succeedsIfPackageNameAndSignatureHashMatch()
+      throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+    installPackages(OTHER_UID, info);
+
+    policy =
+        SecurityPolicies.hasSignatureSha256Hash(
+            packageManager, OTHER_UID_PACKAGE_NAME, getSha256Hash(SIG2));
+
+    // THEN UID for package that has SIG2 will be authorized
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode()).isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  public void testHasSignatureSha256Hash_failsIfPackageNameDoesNotMatch() throws Exception {
+    PackageInfo info1 =
+        newBuilder().setPackageName(appContext.getPackageName()).setSignatures(SIG1).build();
+    installPackages(MY_UID, info1);
+
+    PackageInfo info2 =
+        newBuilder()
+            .setPackageName(OTHER_UID_SAME_SIGNATURE_PACKAGE_NAME)
+            .setSignatures(SIG1)
+            .build();
+    installPackages(OTHER_UID_SAME_SIGNATURE, info2);
+
+    policy =
+        SecurityPolicies.hasSignatureSha256Hash(
+            packageManager, appContext.getPackageName(), getSha256Hash(SIG1));
+
+    // THEN UID for package that has SIG1 but different package name will not be authorized
+    assertThat(policy.checkAuthorization(OTHER_UID_SAME_SIGNATURE).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  public void testHasSignatureSha256Hash_failsIfSignatureHashDoesNotMatch() throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+    installPackages(OTHER_UID, info);
+
+    policy =
+        SecurityPolicies.hasSignatureSha256Hash(
+            packageManager, OTHER_UID_PACKAGE_NAME, getSha256Hash(SIG1));
+
+    // THEN UID for package that doesn't have SIG1 will not be authorized
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  public void testOneOfSignatureSha256Hash_succeedsIfPackageNameAndSignatureHashMatch()
+      throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+    installPackages(OTHER_UID, info);
+
+    policy =
+        SecurityPolicies.oneOfSignatureSha256Hash(
+            packageManager, OTHER_UID_PACKAGE_NAME, ImmutableList.of(getSha256Hash(SIG2)));
+
+    // THEN UID for package that has SIG2 will be authorized
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode()).isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  public void testOneOfSignatureSha256Hash_succeedsIfPackageNameAndOneOfSignatureHashesMatch()
+      throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+    installPackages(OTHER_UID, info);
+
+    policy =
+        SecurityPolicies.oneOfSignatureSha256Hash(
+            packageManager,
+            OTHER_UID_PACKAGE_NAME,
+            ImmutableList.of(getSha256Hash(SIG1), getSha256Hash(SIG2)));
+
+    // THEN UID for package that has SIG2 will be authorized
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode()).isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  public void
+      testOneOfSignatureSha256Hash_failsIfPackageNameDoNotMatchAndOneOfSignatureHashesMatch()
+          throws Exception {
+    PackageInfo info =
+        newBuilder().setPackageName(OTHER_UID_PACKAGE_NAME).setSignatures(SIG2).build();
+    installPackages(OTHER_UID, info);
+
+    policy =
+        SecurityPolicies.oneOfSignatureSha256Hash(
+            packageManager,
+            appContext.getPackageName(),
+            ImmutableList.of(getSha256Hash(SIG1), getSha256Hash(SIG2)));
+
+    // THEN UID for package that has SIG2 but different package name will not be authorized
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  public void testOneOfSignatureSha256Hash_failsIfPackageNameMatchAndOneOfSignatureHashesNotMatch()
+      throws Exception {
+    PackageInfo info =
+        newBuilder()
+            .setPackageName(OTHER_UID_PACKAGE_NAME)
+            .setSignatures(new Signature("1234"))
+            .build();
+    installPackages(OTHER_UID, info);
+
+    policy =
+        SecurityPolicies.oneOfSignatureSha256Hash(
+            packageManager,
+            appContext.getPackageName(),
+            ImmutableList.of(getSha256Hash(SIG1), getSha256Hash(SIG2)));
+
+    // THEN UID for package that doesn't have SIG1 or SIG2 will not be authorized
+    assertThat(policy.checkAuthorization(OTHER_UID).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  private static byte[] getSha256Hash(Signature signature) {
+    return Hashing.sha256().hashBytes(signature.toByteArray()).asBytes();
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/ServerSecurityPolicyTest.java b/binder/src/test/java/io/grpc/binder/ServerSecurityPolicyTest.java
new file mode 100644
index 00000000000..eedc3f590cd
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/ServerSecurityPolicyTest.java
@@ -0,0 +1,375 @@
+/*
+ * 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;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.fail;
+
+import android.os.Process;
+import com.google.common.base.Function;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.Uninterruptibles;
+import io.grpc.Status;
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public final class ServerSecurityPolicyTest {
+
+  private static final String SERVICE1 = "service_one";
+  private static final String SERVICE2 = "service_two";
+  private static final String SERVICE3 = "service_three";
+
+  private static final int MY_UID = Process.myUid();
+  private static final int OTHER_UID = MY_UID + 1;
+
+  ServerSecurityPolicy policy;
+
+  @Test
+  public void testDefaultInternalOnly() throws Exception {
+    policy = new ServerSecurityPolicy();
+    assertThat(checkAuthorizationForServiceAsync(policy, MY_UID, SERVICE1))
+        .isEqualTo(Status.OK.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, MY_UID, SERVICE2))
+        .isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  @Deprecated
+  public void testDefaultInternalOnly_legacyApi() {
+    policy = new ServerSecurityPolicy();
+    assertThat(policy.checkAuthorizationForService(MY_UID, SERVICE1).getCode())
+        .isEqualTo(Status.OK.getCode());
+    assertThat(policy.checkAuthorizationForService(MY_UID, SERVICE2).getCode())
+        .isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  public void testInternalOnly_AnotherUid() throws Exception {
+    policy = new ServerSecurityPolicy();
+    assertThat(checkAuthorizationForServiceAsync(policy, OTHER_UID, SERVICE1))
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, OTHER_UID, SERVICE2))
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  @Deprecated
+  public void testInternalOnly_AnotherUid_legacyApi() {
+    policy = new ServerSecurityPolicy();
+    assertThat(policy.checkAuthorizationForService(OTHER_UID, SERVICE1).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(policy.checkAuthorizationForService(OTHER_UID, SERVICE2).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  public void testBuilderDefault() throws Exception {
+    policy = ServerSecurityPolicy.newBuilder().build();
+    assertThat(checkAuthorizationForServiceAsync(policy, MY_UID, SERVICE1))
+        .isEqualTo(Status.OK.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, OTHER_UID, SERVICE1))
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  @Deprecated
+  public void testBuilderDefault_legacyApi() {
+    policy = ServerSecurityPolicy.newBuilder().build();
+    assertThat(policy.checkAuthorizationForService(MY_UID, SERVICE1).getCode())
+        .isEqualTo(Status.OK.getCode());
+    assertThat(policy.checkAuthorizationForService(OTHER_UID, SERVICE1).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  public void testPerService() throws Exception {
+    policy =
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy(SERVICE2, policy((uid) -> Status.OK))
+            .build();
+
+    assertThat(checkAuthorizationForServiceAsync(policy, MY_UID, SERVICE1))
+        .isEqualTo(Status.OK.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, OTHER_UID, SERVICE1))
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, MY_UID, SERVICE2))
+        .isEqualTo(Status.OK.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, OTHER_UID, SERVICE2))
+        .isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  @Deprecated
+  public void testPerService_legacyApi() {
+    policy =
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy(SERVICE2, policy((uid) -> Status.OK))
+            .build();
+
+    assertThat(policy.checkAuthorizationForService(MY_UID, SERVICE1).getCode())
+        .isEqualTo(Status.OK.getCode());
+    assertThat(policy.checkAuthorizationForService(OTHER_UID, SERVICE1).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(policy.checkAuthorizationForService(MY_UID, SERVICE2).getCode())
+        .isEqualTo(Status.OK.getCode());
+    assertThat(policy.checkAuthorizationForService(OTHER_UID, SERVICE2).getCode())
+        .isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  public void testPerServiceAsync() throws Exception {
+    policy =
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy(
+                SERVICE2,
+                asyncPolicy(
+                    uid -> {
+                      // Add some extra future transformation to confirm that a chain
+                      // of futures gets properly handled.
+                      ListenableFuture<Void> dependency = Futures.immediateVoidFuture();
+                      return Futures.transform(
+                          dependency, unused -> Status.OK, MoreExecutors.directExecutor());
+                    }))
+            .build();
+
+    assertThat(checkAuthorizationForServiceAsync(policy, MY_UID, SERVICE1))
+        .isEqualTo(Status.OK.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, OTHER_UID, SERVICE1))
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, MY_UID, SERVICE2))
+        .isEqualTo(Status.OK.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, OTHER_UID, SERVICE2))
+        .isEqualTo(Status.OK.getCode());
+  }
+
+  @Test
+  public void testPerService_failedSecurityPolicyFuture_returnsAFailedFuture() {
+    policy =
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy(
+                SERVICE1,
+                asyncPolicy(
+                    uid ->
+                        Futures.immediateFailedFuture(
+                            new IllegalStateException("something went wrong"))))
+            .build();
+
+    ListenableFuture<Status> statusFuture =
+        policy.checkAuthorizationForServiceAsync(MY_UID, SERVICE1);
+
+    assertThrows(ExecutionException.class, statusFuture::get);
+  }
+
+  @Test
+  public void testPerServiceAsync_cancelledFuture_propagatesStatus() {
+    policy =
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy(SERVICE1, asyncPolicy(unused -> Futures.immediateCancelledFuture()))
+            .build();
+
+    ListenableFuture<Status> statusFuture =
+        policy.checkAuthorizationForServiceAsync(MY_UID, SERVICE1);
+
+    assertThrows(CancellationException.class, statusFuture::get);
+  }
+
+  @Test
+  public void testPerServiceAsync_interrupted_cancelledFuture() {
+    ListeningExecutorService listeningExecutorService =
+        MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());
+    CountDownLatch unsatisfiedLatch = new CountDownLatch(1);
+    ListenableFuture<Status> toBeInterruptedFuture =
+        listeningExecutorService.submit(
+            () -> {
+              unsatisfiedLatch.await(); // waits forever
+              return null;
+            });
+
+    CyclicBarrier barrier = new CyclicBarrier(2);
+    Thread testThread = Thread.currentThread();
+    new Thread(
+            () -> {
+              awaitOrFail(barrier);
+              testThread.interrupt();
+            })
+        .start();
+
+    policy =
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy(
+                SERVICE1,
+                asyncPolicy(
+                    unused -> {
+                      awaitOrFail(barrier);
+                      return toBeInterruptedFuture;
+                    }))
+            .build();
+    ListenableFuture<Status> statusFuture =
+        policy.checkAuthorizationForServiceAsync(MY_UID, SERVICE1);
+
+    assertThrows(InterruptedException.class, statusFuture::get);
+    listeningExecutorService.shutdownNow();
+  }
+
+  @Test
+  public void testPerServiceNoDefault() throws Exception {
+    policy =
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy(SERVICE1, policy((uid) -> Status.INTERNAL))
+            .servicePolicy(
+                SERVICE2, policy((uid) -> uid == OTHER_UID ? Status.OK : Status.PERMISSION_DENIED))
+            .build();
+
+    // Uses the specified policy for service1.
+    assertThat(checkAuthorizationForServiceAsync(policy, MY_UID, SERVICE1))
+        .isEqualTo(Status.INTERNAL.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, OTHER_UID, SERVICE1))
+        .isEqualTo(Status.INTERNAL.getCode());
+
+    // Uses the specified policy for service2.
+    assertThat(checkAuthorizationForServiceAsync(policy, MY_UID, SERVICE2))
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, OTHER_UID, SERVICE2))
+        .isEqualTo(Status.OK.getCode());
+
+    // Falls back to the default.
+    assertThat(checkAuthorizationForServiceAsync(policy, MY_UID, SERVICE3))
+        .isEqualTo(Status.OK.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, OTHER_UID, SERVICE3))
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  @Deprecated
+  public void testPerServiceNoDefault_legacyApi() {
+    policy =
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy(SERVICE1, policy((uid) -> Status.INTERNAL))
+            .servicePolicy(
+                SERVICE2, policy((uid) -> uid == OTHER_UID ? Status.OK : Status.PERMISSION_DENIED))
+            .build();
+
+    // Uses the specified policy for service1.
+    assertThat(policy.checkAuthorizationForService(MY_UID, SERVICE1).getCode())
+        .isEqualTo(Status.INTERNAL.getCode());
+    assertThat(policy.checkAuthorizationForService(OTHER_UID, SERVICE1).getCode())
+        .isEqualTo(Status.INTERNAL.getCode());
+
+    // Uses the specified policy for service2.
+    assertThat(policy.checkAuthorizationForService(MY_UID, SERVICE2).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(policy.checkAuthorizationForService(OTHER_UID, SERVICE2).getCode())
+        .isEqualTo(Status.OK.getCode());
+
+    // Falls back to the default.
+    assertThat(policy.checkAuthorizationForService(MY_UID, SERVICE3).getCode())
+        .isEqualTo(Status.OK.getCode());
+    assertThat(policy.checkAuthorizationForService(OTHER_UID, SERVICE3).getCode())
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  @Test
+  public void testPerServiceNoDefaultAsync() throws Exception {
+    policy =
+        ServerSecurityPolicy.newBuilder()
+            .servicePolicy(SERVICE1, asyncPolicy((uid) -> Futures.immediateFuture(Status.INTERNAL)))
+            .servicePolicy(
+                SERVICE2,
+                asyncPolicy(
+                    (uid) -> {
+                      // Add some extra future transformation to confirm that a chain
+                      // of futures gets properly handled.
+                      ListenableFuture<Boolean> anotherUidFuture =
+                          Futures.immediateFuture(uid == OTHER_UID);
+                      return Futures.transform(
+                          anotherUidFuture,
+                          anotherUid -> anotherUid ? Status.OK : Status.PERMISSION_DENIED,
+                          MoreExecutors.directExecutor());
+                    }))
+            .build();
+
+    // Uses the specified policy for service1.
+    assertThat(checkAuthorizationForServiceAsync(policy, MY_UID, SERVICE1))
+        .isEqualTo(Status.INTERNAL.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, OTHER_UID, SERVICE1))
+        .isEqualTo(Status.INTERNAL.getCode());
+
+    // Uses the specified policy for service2.
+    assertThat(checkAuthorizationForServiceAsync(policy, MY_UID, SERVICE2))
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, OTHER_UID, SERVICE2))
+        .isEqualTo(Status.OK.getCode());
+
+    // Falls back to the default.
+    assertThat(checkAuthorizationForServiceAsync(policy, MY_UID, SERVICE3))
+        .isEqualTo(Status.OK.getCode());
+    assertThat(checkAuthorizationForServiceAsync(policy, OTHER_UID, SERVICE3))
+        .isEqualTo(Status.PERMISSION_DENIED.getCode());
+  }
+
+  /**
+   * Shortcut for invoking {@link ServerSecurityPolicy#checkAuthorizationForServiceAsync} without
+   * dealing with concurrency details. Returns a {link @Status.Code} for convenience.
+   */
+  private static Status.Code checkAuthorizationForServiceAsync(
+      ServerSecurityPolicy policy, int callerUid, String service) throws ExecutionException {
+    ListenableFuture<Status> statusFuture =
+        policy.checkAuthorizationForServiceAsync(callerUid, service);
+    return Uninterruptibles.getUninterruptibly(statusFuture).getCode();
+  }
+
+  private static SecurityPolicy policy(Function<Integer, Status> func) {
+    return new SecurityPolicy() {
+      @Override
+      public Status checkAuthorization(int uid) {
+        return func.apply(uid);
+      }
+    };
+  }
+
+  private static AsyncSecurityPolicy asyncPolicy(Function<Integer, ListenableFuture<Status>> func) {
+    return new AsyncSecurityPolicy() {
+      @Override
+      public ListenableFuture<Status> checkAuthorizationAsync(int uid) {
+        return func.apply(uid);
+      }
+    };
+  }
+
+  private static void awaitOrFail(CyclicBarrier barrier) {
+    try {
+      barrier.await();
+    } catch (BrokenBarrierException e) {
+      fail(e.getMessage());
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      fail(e.getMessage());
+    }
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/ActiveTransportTrackerTest.java b/binder/src/test/java/io/grpc/binder/internal/ActiveTransportTrackerTest.java
new file mode 100644
index 00000000000..099756075f1
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/ActiveTransportTrackerTest.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2024 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 org.junit.Assert.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+import io.grpc.internal.ServerListener;
+import io.grpc.internal.ServerTransport;
+import io.grpc.internal.ServerTransportListener;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public final class ActiveTransportTrackerTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private ActiveTransportTracker tracker;
+
+  @Mock Runnable mockShutdownListener;
+  @Mock ServerListener mockServerListener;
+  @Mock ServerTransportListener mockServerTransportListener;
+  @Mock ServerTransport mockServerTransport;
+
+  @Before
+  public void setUp() {
+    when(mockServerListener.transportCreated(any())).thenReturn(mockServerTransportListener);
+    tracker = new ActiveTransportTracker(mockServerListener, mockShutdownListener);
+  }
+
+  @Test
+  public void testServerShutdown_onlyNotifiesAfterAllTransportAreTerminated() {
+    ServerTransportListener wrapperListener1 = registerNewTransport();
+    ServerTransportListener wrapperListener2 = registerNewTransport();
+
+    tracker.serverShutdown();
+    // 2 active transports, notification scheduled
+    verifyNoInteractions(mockShutdownListener);
+
+    wrapperListener1.transportTerminated();
+    // 1 active transport remaining, notification still pending
+    verifyNoInteractions(mockShutdownListener);
+
+    wrapperListener2.transportTerminated();
+    // No more active transports, shutdown notified
+    verify(mockShutdownListener).run();
+  }
+
+  @Test
+  public void testServerShutdown_noActiveTransport_notifiesTerminationImmediately() {
+    verifyNoInteractions(mockShutdownListener);
+
+    tracker.serverShutdown();
+
+    verify(mockShutdownListener).run();
+  }
+
+  @Test
+  public void testLastTransportTerminated_serverNotShutdownYet_doesNotNotify() {
+    ServerTransportListener wrapperListener = registerNewTransport();
+    verifyNoInteractions(mockShutdownListener);
+
+    wrapperListener.transportTerminated();
+
+    verifyNoInteractions(mockShutdownListener);
+  }
+
+  @Test
+  public void testTransportCreation_afterServerShutdown_throws() {
+    tracker.serverShutdown();
+
+    assertThrows(IllegalStateException.class, this::registerNewTransport);
+  }
+
+  @Test
+  public void testServerListenerCallbacks_invokesDelegates() {
+    ServerTransportListener listener = tracker.transportCreated(mockServerTransport);
+    verify(mockServerListener).transportCreated(mockServerTransport);
+
+    listener.transportTerminated();
+    verify(mockServerTransportListener).transportTerminated();
+
+    tracker.serverShutdown();
+    verify(mockServerListener).serverShutdown();
+  }
+
+  private ServerTransportListener registerNewTransport() {
+    return tracker.transportCreated(mockServerTransport);
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/BinderServerTransportTest.java b/binder/src/test/java/io/grpc/binder/internal/BinderServerTransportTest.java
new file mode 100644
index 00000000000..d261ce43c8c
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/BinderServerTransportTest.java
@@ -0,0 +1,169 @@
+/*
+ * 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 static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doThrow;
+import static org.robolectric.Shadows.shadowOf;
+
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.Parcel;
+import android.os.RemoteException;
+import com.google.common.collect.ImmutableList;
+import io.grpc.Attributes;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.internal.FixedObjectPool;
+import io.grpc.internal.MockServerTransportListener;
+import io.grpc.internal.ObjectPool;
+import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.RobolectricTestRunner;
+
+/**
+ * Low-level server-side transport tests for binder channel. Like BinderChannelSmokeTest, this
+ * convers edge cases not exercised by AbstractTransportTest, but it deals with the
+ * binderTransport.BinderServerTransport directly.
+ */
+@RunWith(RobolectricTestRunner.class)
+public final class BinderServerTransportTest {
+
+  @Rule public MockitoRule mocks = MockitoJUnit.rule();
+
+  private final ScheduledExecutorService executorService = new MainThreadScheduledExecutorService();
+  private MockServerTransportListener transportListener;
+
+  @Mock IBinder mockBinder;
+
+  BinderServerTransport transport;
+
+  @Before
+  public void setUp() throws Exception {
+    transportListener = new MockServerTransportListener(transport);
+  }
+
+  // Provide defaults so that we can "include only relevant details in tests."
+  BinderServerTransportBuilder newBinderServerTransportBuilder() {
+    return new BinderServerTransportBuilder()
+        .setExecutorServicePool(new FixedObjectPool<>(executorService))
+        .setAttributes(Attributes.EMPTY)
+        .setStreamTracerFactories(ImmutableList.of())
+        .setBinderDecorator(OneWayBinderProxy.IDENTITY_DECORATOR)
+        .setCallbackBinder(mockBinder);
+  }
+
+  @Test
+  public void testSetupTransactionFailureReportsMultipleTerminations_b153460678() throws Exception {
+    // Make the binder fail the setup transaction.
+    doThrow(new RemoteException())
+        .when(mockBinder)
+        .transact(anyInt(), any(Parcel.class), isNull(), anyInt());
+    transport = newBinderServerTransportBuilder().setCallbackBinder(mockBinder).build();
+    shadowOf(Looper.getMainLooper()).idle();
+    transport.start(transportListener);
+
+    // Now shut it down externally *before* executing Runnables scheduled on the executor.
+    transport.shutdownNow(Status.UNKNOWN.withDescription("reasons"));
+    shadowOf(Looper.getMainLooper()).idle();
+
+    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();
+    transport.shutdownNow(Status.UNKNOWN.withDescription("reasons"));
+    shadowOf(Looper.getMainLooper()).idle();
+    transport.start(transportListener);
+    shadowOf(Looper.getMainLooper()).idle();
+
+    assertThat(transportListener.isTerminated()).isTrue();
+  }
+
+  @Test
+  public void testStartAfterShutdownNoIdle() throws Exception {
+    transport = newBinderServerTransportBuilder().build();
+    transport.shutdownNow(Status.UNKNOWN.withDescription("reasons"));
+    transport.start(transportListener);
+    shadowOf(Looper.getMainLooper()).idle();
+
+    assertThat(transportListener.isTerminated()).isTrue();
+  }
+
+  static class BinderServerTransportBuilder {
+    ObjectPool<ScheduledExecutorService> executorServicePool;
+    Attributes attributes;
+    List<ServerStreamTracer.Factory> streamTracerFactories;
+    OneWayBinderProxy.Decorator binderDecorator;
+    IBinder callbackBinder;
+
+    public BinderServerTransport build() {
+      return BinderServerTransport.create(
+          executorServicePool, attributes, streamTracerFactories, binderDecorator, callbackBinder);
+    }
+
+    public BinderServerTransportBuilder setExecutorServicePool(
+        ObjectPool<ScheduledExecutorService> executorServicePool) {
+      this.executorServicePool = executorServicePool;
+      return this;
+    }
+
+    public BinderServerTransportBuilder setAttributes(Attributes attributes) {
+      this.attributes = attributes;
+      return this;
+    }
+
+    public BinderServerTransportBuilder setStreamTracerFactories(
+        List<ServerStreamTracer.Factory> streamTracerFactories) {
+      this.streamTracerFactories = streamTracerFactories;
+      return this;
+    }
+
+    public BinderServerTransportBuilder setBinderDecorator(
+        OneWayBinderProxy.Decorator binderDecorator) {
+      this.binderDecorator = binderDecorator;
+      return this;
+    }
+
+    public BinderServerTransportBuilder setCallbackBinder(IBinder callbackBinder) {
+      this.callbackBinder = callbackBinder;
+      return this;
+    }
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/BlockInputStreamTest.java b/binder/src/test/java/io/grpc/binder/internal/BlockInputStreamTest.java
new file mode 100644
index 00000000000..d78a26cf9b9
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/BlockInputStreamTest.java
@@ -0,0 +1,126 @@
+/*
+ * 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 java.io.ByteArrayOutputStream;
+import java.util.Arrays;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class BlockInputStreamTest {
+
+  private final byte[] buff = new byte[1024];
+
+  @Test
+  public void testNoBytes() throws Exception {
+    try (BlockInputStream bis = new BlockInputStream(new byte[0])) {
+      assertThat(bis.read()).isEqualTo(-1);
+    }
+  }
+
+  @Test
+  public void testNoBlocks() throws Exception {
+    try (BlockInputStream bis = new BlockInputStream(new byte[0][], 0)) {
+      assertThat(bis.read()).isEqualTo(-1);
+    }
+  }
+
+  @Test
+  public void testSingleBlock() throws Exception {
+    BlockInputStream bis = new BlockInputStream(new byte[][] {getBytes(10, 1)}, 10);
+    assertThat(bis.read(buff, 0, 20)).isEqualTo(10);
+    assertBytes(buff, 0, 10, 1);
+  }
+
+  @Test
+  public void testMultipleBlocks() throws Exception {
+    BlockInputStream bis =
+        new BlockInputStream(new byte[][] {getBytes(10, 1), getBytes(10, 2)}, 20);
+    assertThat(bis.read(buff, 0, 20)).isEqualTo(20);
+    assertBytes(buff, 0, 10, 1);
+    assertBytes(buff, 10, 10, 2);
+  }
+
+  @Test
+  public void testMultipleBlocks_drain() throws Exception {
+    BlockInputStream bis =
+        new BlockInputStream(new byte[][] {getBytes(10, 1), getBytes(10, 2)}, 20);
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    bis.drainTo(baos);
+    byte[] data = baos.toByteArray();
+    assertThat(data).hasLength(20);
+    assertBytes(data, 0, 10, 1);
+    assertBytes(data, 10, 10, 2);
+  }
+
+  @Test
+  public void testMultipleBlocksLessData() throws Exception {
+    BlockInputStream bis =
+        new BlockInputStream(new byte[][] {getBytes(10, 1), getBytes(10, 2)}, 15);
+    assertThat(bis.read(buff, 0, 20)).isEqualTo(15);
+    assertBytes(buff, 0, 10, 1);
+    assertBytes(buff, 10, 5, 2);
+  }
+
+  @Test
+  public void testMultipleBlocksLessData_drain() throws Exception {
+    BlockInputStream bis =
+        new BlockInputStream(new byte[][] {getBytes(10, 1), getBytes(10, 2)}, 15);
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    bis.drainTo(baos);
+    byte[] data = baos.toByteArray();
+    assertThat(data).hasLength(15);
+    assertBytes(data, 0, 10, 1);
+    assertBytes(data, 10, 5, 2);
+  }
+
+  @Test
+  public void testMultipleBlocksEmptyFinalBlock() throws Exception {
+    BlockInputStream bis = new BlockInputStream(new byte[][] {getBytes(10, 1), getBytes(0, 0)}, 10);
+
+    assertThat(bis.read(buff, 0, 20)).isEqualTo(10);
+    assertBytes(buff, 0, 10, 1);
+    assertThat(bis.read(buff, 0, 20)).isEqualTo(-1);
+    assertThat(bis.read()).isEqualTo(-1);
+  }
+
+  @Test
+  public void testMultipleBlocksEmptyFinalBlock_drain() throws Exception {
+    BlockInputStream bis = new BlockInputStream(new byte[][] {getBytes(10, 1), getBytes(0, 0)}, 10);
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    bis.drainTo(baos);
+    byte[] data = baos.toByteArray();
+    assertThat(data).hasLength(10);
+    assertBytes(data, 0, 10, 1);
+  }
+
+  private static byte[] getBytes(int size, int val) {
+    byte[] res = new byte[size];
+    Arrays.fill(res, 0, size, (byte) val);
+    return res;
+  }
+
+  private static void assertBytes(byte[] data, int off, int len, int val) {
+    for (int i = off; i < off + len; i++) {
+      assertThat(data[i]).isEqualTo((byte) val);
+    }
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/BoundClientAddressTest.java b/binder/src/test/java/io/grpc/binder/internal/BoundClientAddressTest.java
new file mode 100644
index 00000000000..9dc6cbc6938
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/BoundClientAddressTest.java
@@ -0,0 +1,39 @@
+/*
+ * 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 com.google.common.testing.EqualsTester;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public final class BoundClientAddressTest {
+
+  private static final int MY_UID = 1234;
+  private static final int OTHER_UID = 1235;
+  private static final int OTHER_UID_2 = 1236;
+
+  @Test
+  public void testEquality() {
+    new EqualsTester()
+        .addEqualityGroup(new BoundClientAddress(MY_UID), new BoundClientAddress(MY_UID))
+        .addEqualityGroup(new BoundClientAddress(OTHER_UID))
+        .addEqualityGroup(new BoundClientAddress(OTHER_UID_2))
+        .testEquals();
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/FlowControllerTest.java b/binder/src/test/java/io/grpc/binder/internal/FlowControllerTest.java
new file mode 100644
index 00000000000..f2ba83d9bc1
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/FlowControllerTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2021 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 org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class FlowControllerTest {
+
+  @Test
+  public void shouldReportTransmitWindowInitiallyNonFull() {
+    FlowController flowController = new FlowController(100);
+    assertThat(flowController.isTransmitWindowFull()).isFalse();
+  }
+
+  @Test
+  public void shouldReportTransmitWindowFull() {
+    FlowController flowController = new FlowController(100);
+    boolean transition = flowController.notifyBytesSent(99);
+    assertThat(transition).isFalse();
+    assertThat(flowController.isTransmitWindowFull()).isFalse();
+    transition = flowController.notifyBytesSent(1);
+    assertThat(transition).isTrue();
+    assertThat(flowController.isTransmitWindowFull()).isTrue();
+  }
+
+  @Test
+  public void shouldHandleAck() {
+    FlowController flowController = new FlowController(100);
+    assertThat(flowController.isTransmitWindowFull()).isFalse();
+    flowController.notifyBytesSent(1);
+    flowController.notifyBytesSent(100);
+    assertThat(flowController.isTransmitWindowFull()).isTrue();
+    boolean transition = flowController.handleAcknowledgedBytes(100);
+    assertThat(transition).isTrue();
+    assertThat(flowController.isTransmitWindowFull()).isFalse();
+    transition = flowController.handleAcknowledgedBytes(1);
+    assertThat(transition).isFalse();
+  }
+
+  @Test
+  public void shouldHandleAcksOutOfOrder() {
+    FlowController flowController = new FlowController(100);
+    flowController.notifyBytesSent(49);
+    flowController.notifyBytesSent(51);
+    assertThat(flowController.isTransmitWindowFull()).isTrue();
+    flowController.handleAcknowledgedBytes(100);
+    assertThat(flowController.isTransmitWindowFull()).isFalse();
+    flowController.handleAcknowledgedBytes(49);
+    assertThat(flowController.isTransmitWindowFull()).isFalse();
+  }
+
+  @Test
+  public void shouldHandleAckOverflow() {
+    FlowController flowController = new FlowController(2);
+
+    // Signed long overflow
+    flowController.notifyBytesSent(Long.MAX_VALUE); // totalBytesSent = 0b011..1
+    flowController.handleAcknowledgedBytes(Long.MAX_VALUE); // totalBytesAckedByPeer = 0b011..1
+    assertThat(flowController.isTransmitWindowFull()).isFalse();
+    flowController.notifyBytesSent(1); // totalBytesSent = 0b100..00
+    assertThat(flowController.isTransmitWindowFull()).isFalse();
+    flowController.notifyBytesSent(1); // totalBytesSent = 0b100..01
+    assertThat(flowController.isTransmitWindowFull()).isTrue();
+
+    // Unsigned long overflow.
+    flowController.notifyBytesSent(Long.MAX_VALUE - 1); // totalBytesSent = 0b111..11
+    flowController.handleAcknowledgedBytes(-1); // totalBytesAckedByPeer = 0b111..1
+    assertThat(flowController.isTransmitWindowFull()).isFalse();
+    flowController.notifyBytesSent(1); // totalBytesSent = 0
+    assertThat(flowController.isTransmitWindowFull()).isFalse();
+    flowController.notifyBytesSent(1); // totalBytesSent = 1
+    assertThat(flowController.isTransmitWindowFull()).isTrue();
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/IntentNameResolverProviderTest.java b/binder/src/test/java/io/grpc/binder/internal/IntentNameResolverProviderTest.java
new file mode 100644
index 00000000000..2809a72fee1
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/IntentNameResolverProviderTest.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2025 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 android.os.Looper.getMainLooper;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.robolectric.Shadows.shadowOf;
+
+import android.app.Application;
+import androidx.core.content.ContextCompat;
+import androidx.test.core.app.ApplicationProvider;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ResolutionResult;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.NameResolverProvider;
+import io.grpc.SynchronizationContext;
+import io.grpc.Uri;
+import io.grpc.binder.ApiConstants;
+import java.net.URI;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoTestRule;
+import org.robolectric.RobolectricTestRunner;
+
+/** A test for IntentNameResolverProvider. */
+@RunWith(RobolectricTestRunner.class)
+public final class IntentNameResolverProviderTest {
+
+  private final Application appContext = ApplicationProvider.getApplicationContext();
+  private final SynchronizationContext syncContext = newSynchronizationContext();
+  private final NameResolver.Args args = newNameResolverArgs();
+
+  private NameResolverProvider provider;
+
+  @Rule public MockitoTestRule mockitoTestRule = MockitoJUnit.testRule(this);
+  @Mock public NameResolver.Listener2 mockListener;
+  @Captor public ArgumentCaptor<ResolutionResult> resultCaptor;
+
+  @Before
+  public void setUp() {
+    provider = new IntentNameResolverProvider();
+  }
+
+  @Test
+  public void testProviderScheme_returnsIntentScheme() throws Exception {
+    assertThat(provider.getDefaultScheme())
+        .isEqualTo(IntentNameResolverProvider.ANDROID_INTENT_SCHEME);
+  }
+
+  @Test
+  public void testNoResolverForUnknownScheme_returnsNull() throws Exception {
+    assertThat(provider.newNameResolver(Uri.create("random://uri"), args)).isNull();
+  }
+
+  @Test
+  public void testResolutionWithBadUri_throwsIllegalArg() throws Exception {
+    assertThrows(
+        IllegalArgumentException.class,
+        () -> provider.newNameResolver(Uri.create("intent:xxx#Intent;e.x=1;end;"), args));
+  }
+
+  @Test
+  public void testResolverForIntentScheme_returnsResolver() throws Exception {
+    Uri uri = Uri.create("intent:#Intent;action=action;end");
+    NameResolver resolver = provider.newNameResolver(uri, args);
+    assertThat(resolver).isNotNull();
+    assertThat(resolver.getServiceAuthority()).isEqualTo("localhost");
+    syncContext.execute(() -> resolver.start(mockListener));
+    shadowOf(getMainLooper()).idle();
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertThat(resultCaptor.getValue().getAddressesOrError()).isNotNull();
+    syncContext.execute(resolver::shutdown);
+    shadowOf(getMainLooper()).idle();
+  }
+
+  @Test
+  public void testResolverForIntentScheme_returnsResolver_javaNetUri() throws Exception {
+    URI uri = new URI("intent://authority/path#Intent;action=action;scheme=scheme;end");
+    NameResolver resolver = provider.newNameResolver(uri, args);
+    assertThat(resolver).isNotNull();
+    assertThat(resolver.getServiceAuthority()).isEqualTo("localhost");
+    syncContext.execute(() -> resolver.start(mockListener));
+    shadowOf(getMainLooper()).idle();
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertThat(resultCaptor.getValue().getAddressesOrError()).isNotNull();
+    syncContext.execute(resolver::shutdown);
+    shadowOf(getMainLooper()).idle();
+  }
+
+  /** Returns a new test-specific {@link NameResolver.Args} instance. */
+  private NameResolver.Args newNameResolverArgs() {
+    return NameResolver.Args.newBuilder()
+        .setDefaultPort(-1)
+        .setProxyDetector((target) -> null) // No proxies here.
+        .setSynchronizationContext(syncContext)
+        .setOffloadExecutor(ContextCompat.getMainExecutor(appContext))
+        .setServiceConfigParser(mock(ServiceConfigParser.class))
+        .setArg(ApiConstants.SOURCE_ANDROID_CONTEXT, appContext)
+        .build();
+  }
+
+  private static SynchronizationContext newSynchronizationContext() {
+    return new SynchronizationContext(
+        (thread, exception) -> {
+          throw new AssertionError(exception);
+        });
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/IntentNameResolverTest.java b/binder/src/test/java/io/grpc/binder/internal/IntentNameResolverTest.java
new file mode 100644
index 00000000000..b1bfcd4fd56
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/IntentNameResolverTest.java
@@ -0,0 +1,531 @@
+/*
+ * Copyright 2025 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 android.content.Intent.ACTION_PACKAGE_ADDED;
+import static android.content.Intent.ACTION_PACKAGE_REPLACED;
+import static android.os.Looper.getMainLooper;
+import static android.os.Process.myUserHandle;
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.robolectric.Shadows.shadowOf;
+
+import android.app.Application;
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.ServiceInfo;
+import android.net.Uri;
+import android.os.UserHandle;
+import android.os.UserManager;
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
+import androidx.test.core.app.ApplicationProvider;
+import com.google.common.collect.ImmutableList;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ResolutionResult;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.SynchronizationContext;
+import io.grpc.binder.AndroidComponentAddress;
+import io.grpc.binder.ApiConstants;
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoTestRule;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowPackageManager;
+
+/** A test for IntentNameResolverProvider. */
+@RunWith(RobolectricTestRunner.class)
+public final class IntentNameResolverTest {
+
+  private static final ComponentName SOME_COMPONENT_NAME =
+      new ComponentName("com.foo.bar", "SomeComponent");
+  private static final ComponentName ANOTHER_COMPONENT_NAME =
+      new ComponentName("org.blah", "AnotherComponent");
+  private final Application appContext = ApplicationProvider.getApplicationContext();
+  private final SynchronizationContext syncContext = newSynchronizationContext();
+  private final NameResolver.Args args = newNameResolverArgs().build();
+
+  private final ShadowPackageManager shadowPackageManager =
+      shadowOf(appContext.getPackageManager());
+
+  @Rule public MockitoTestRule mockitoTestRule = MockitoJUnit.testRule(this);
+  @Mock public NameResolver.Listener2 mockListener;
+  @Captor public ArgumentCaptor<ResolutionResult> resultCaptor;
+
+  @Test
+  public void testResolverForIntentScheme_returnsResolverWithLocalHostAuthority() throws Exception {
+    NameResolver resolver = newNameResolver(newIntent());
+    assertThat(resolver).isNotNull();
+    assertThat(resolver.getServiceAuthority()).isEqualTo("localhost");
+  }
+
+  @Test
+  public void testResolutionWithoutServicesAvailable_returnsUnimplemented() throws Exception {
+    NameResolver nameResolver = newNameResolver(newIntent());
+    syncContext.execute(() -> nameResolver.start(mockListener));
+    shadowOf(getMainLooper()).idle();
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertThat(resultCaptor.getValue().getAddressesOrError().getStatus().getCode())
+        .isEqualTo(Status.UNIMPLEMENTED.getCode());
+  }
+
+  @Test
+  public void testResolutionWithMultipleServicesAvailable_returnsAndroidComponentAddresses()
+      throws Exception {
+    Intent intent = newIntent();
+    IntentFilter serviceIntentFilter = newFilterMatching(intent);
+
+    shadowPackageManager.addServiceIfNotPresent(SOME_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(SOME_COMPONENT_NAME, serviceIntentFilter);
+
+    // Adds another valid Service
+    shadowPackageManager.addServiceIfNotPresent(ANOTHER_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(ANOTHER_COMPONENT_NAME, serviceIntentFilter);
+
+    NameResolver nameResolver = newNameResolver(intent);
+    syncContext.execute(() -> nameResolver.start(mockListener));
+    shadowOf(getMainLooper()).idle();
+
+    verify(mockListener, never()).onError(any());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertThat(getAddressesOrThrow(resultCaptor.getValue()))
+        .containsExactly(
+            toAddressList(intent.cloneFilter().setComponent(SOME_COMPONENT_NAME)),
+            toAddressList(intent.cloneFilter().setComponent(ANOTHER_COMPONENT_NAME)));
+
+    syncContext.execute(nameResolver::shutdown);
+    shadowOf(getMainLooper()).idle();
+  }
+
+  @Test
+  public void testExplicitResolutionByComponent_returnsRestrictedResults() throws Exception {
+    Intent intent = newIntent();
+    IntentFilter serviceIntentFilter = newFilterMatching(intent);
+
+    shadowPackageManager.addServiceIfNotPresent(SOME_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(SOME_COMPONENT_NAME, serviceIntentFilter);
+    shadowPackageManager.addServiceIfNotPresent(ANOTHER_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(ANOTHER_COMPONENT_NAME, serviceIntentFilter);
+
+    NameResolver nameResolver =
+        newNameResolver(intent.cloneFilter().setComponent(ANOTHER_COMPONENT_NAME));
+    syncContext.execute(() -> nameResolver.start(mockListener));
+    shadowOf(getMainLooper()).idle();
+
+    verify(mockListener, never()).onError(any());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertThat(getAddressesOrThrow(resultCaptor.getValue()))
+        .containsExactly(toAddressList(intent.cloneFilter().setComponent(ANOTHER_COMPONENT_NAME)));
+
+    syncContext.execute(nameResolver::shutdown);
+    shadowOf(getMainLooper()).idle();
+  }
+
+  @Test
+  public void testExplicitResolutionByPackage_returnsRestrictedResults() throws Exception {
+    Intent intent = newIntent();
+    IntentFilter serviceIntentFilter = newFilterMatching(intent);
+
+    shadowPackageManager.addServiceIfNotPresent(SOME_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(SOME_COMPONENT_NAME, serviceIntentFilter);
+    shadowPackageManager.addServiceIfNotPresent(ANOTHER_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(ANOTHER_COMPONENT_NAME, serviceIntentFilter);
+
+    NameResolver nameResolver =
+        newNameResolver(intent.cloneFilter().setPackage(ANOTHER_COMPONENT_NAME.getPackageName()));
+    syncContext.execute(() -> nameResolver.start(mockListener));
+    shadowOf(getMainLooper()).idle();
+
+    verify(mockListener, never()).onError(any());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertThat(getAddressesOrThrow(resultCaptor.getValue()))
+        .containsExactly(toAddressList(intent.cloneFilter().setComponent(ANOTHER_COMPONENT_NAME)));
+
+    syncContext.execute(nameResolver::shutdown);
+    shadowOf(getMainLooper()).idle();
+  }
+
+  @Test
+  public void testResolution_setsPreAuthEagAttribute() throws Exception {
+    Intent intent = newIntent();
+    IntentFilter serviceIntentFilter = newFilterMatching(intent);
+
+    shadowPackageManager.addServiceIfNotPresent(SOME_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(SOME_COMPONENT_NAME, serviceIntentFilter);
+
+    NameResolver nameResolver = newNameResolver(intent);
+    syncContext.execute(() -> nameResolver.start(mockListener));
+    shadowOf(getMainLooper()).idle();
+
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertThat(getAddressesOrThrow(resultCaptor.getValue()))
+        .containsExactly(toAddressList(intent.cloneFilter().setComponent(SOME_COMPONENT_NAME)));
+    assertThat(
+            getEagsOrThrow(resultCaptor.getValue()).stream()
+                .map(EquivalentAddressGroup::getAttributes)
+                .collect(toImmutableList())
+                .get(0)
+                .get(ApiConstants.PRE_AUTH_SERVER_OVERRIDE))
+        .isTrue();
+
+    syncContext.execute(nameResolver::shutdown);
+    shadowOf(getMainLooper()).idle();
+  }
+
+  @Test
+  public void testServiceRemoved_pushesUpdatedAndroidComponentAddresses() throws Exception {
+    Intent intent = newIntent();
+    IntentFilter serviceIntentFilter = newFilterMatching(intent);
+
+    shadowPackageManager.addServiceIfNotPresent(SOME_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(SOME_COMPONENT_NAME, serviceIntentFilter);
+    shadowPackageManager.addServiceIfNotPresent(ANOTHER_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(ANOTHER_COMPONENT_NAME, serviceIntentFilter);
+
+    NameResolver nameResolver = newNameResolver(intent);
+    syncContext.execute(() -> nameResolver.start(mockListener));
+    shadowOf(getMainLooper()).idle();
+
+    verify(mockListener, never()).onError(any());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertThat(getAddressesOrThrow(resultCaptor.getValue()))
+        .containsExactly(
+            toAddressList(intent.cloneFilter().setComponent(SOME_COMPONENT_NAME)),
+            toAddressList(intent.cloneFilter().setComponent(ANOTHER_COMPONENT_NAME)));
+
+    shadowPackageManager.removeService(ANOTHER_COMPONENT_NAME);
+    broadcastPackageChange(ACTION_PACKAGE_REPLACED, ANOTHER_COMPONENT_NAME.getPackageName());
+    shadowOf(getMainLooper()).idle();
+
+    verify(mockListener, never()).onError(any());
+    verify(mockListener, times(2)).onResult2(resultCaptor.capture());
+    assertThat(getAddressesOrThrow(resultCaptor.getValue()))
+        .containsExactly(toAddressList(intent.cloneFilter().setComponent(SOME_COMPONENT_NAME)));
+
+    syncContext.execute(nameResolver::shutdown);
+    shadowOf(getMainLooper()).idle();
+
+    verifyNoMoreInteractions(mockListener);
+    assertThat(shadowOf(appContext).getRegisteredReceivers()).isEmpty();
+  }
+
+  @Test
+  @Config(sdk = 30)
+  public void testTargetAndroidUser_pushesUpdatedAddresses() throws Exception {
+    Intent intent = newIntent();
+    IntentFilter serviceIntentFilter = newFilterMatching(intent);
+
+    NameResolver nameResolver =
+        newNameResolver(
+            intent,
+            newNameResolverArgs().setArg(ApiConstants.TARGET_ANDROID_USER, myUserHandle()).build());
+    syncContext.execute(() -> nameResolver.start(mockListener));
+    shadowOf(getMainLooper()).idle();
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertThat(resultCaptor.getValue().getAddressesOrError().getStatus().getCode())
+        .isEqualTo(Status.UNIMPLEMENTED.getCode());
+
+    shadowPackageManager.addServiceIfNotPresent(SOME_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(SOME_COMPONENT_NAME, serviceIntentFilter);
+    broadcastPackageChange(ACTION_PACKAGE_ADDED, SOME_COMPONENT_NAME.getPackageName());
+    shadowOf(getMainLooper()).idle();
+
+    verify(mockListener, never()).onError(any());
+    verify(mockListener, times(2)).onResult2(resultCaptor.capture());
+    assertThat(getAddressesOrThrow(resultCaptor.getValue()))
+        .containsExactly(
+            ImmutableList.of(
+                AndroidComponentAddress.newBuilder()
+                    .setTargetUser(myUserHandle())
+                    .setBindIntent(intent.cloneFilter().setComponent(SOME_COMPONENT_NAME))
+                    .build()));
+
+    syncContext.execute(nameResolver::shutdown);
+    shadowOf(getMainLooper()).idle();
+
+    verifyNoMoreInteractions(mockListener);
+    assertThat(shadowOf(appContext).getRegisteredReceivers()).isEmpty();
+  }
+
+  @Test
+  @Config(sdk = 29)
+  public void testTargetAndroidUser_notSupported_throwsWithHelpfulMessage() throws Exception {
+    NameResolver.Args args =
+        newNameResolverArgs().setArg(ApiConstants.TARGET_ANDROID_USER, myUserHandle()).build();
+    IllegalArgumentException iae =
+        assertThrows(IllegalArgumentException.class, () -> newNameResolver(newIntent(), args));
+    assertThat(iae.getMessage()).contains("TARGET_ANDROID_USER");
+    assertThat(iae.getMessage()).contains("SDK_INT >= R");
+  }
+
+  @Test
+  @Config(sdk = 29)
+  public void testServiceAppearsUponBootComplete_pushesUpdatedAndroidComponentAddresses()
+      throws Exception {
+    Intent intent = newIntent();
+    IntentFilter serviceIntentFilter = newFilterMatching(intent);
+
+    // Suppose this directBootAware=true Service appears in PackageManager before a user unlock.
+    shadowOf(appContext.getSystemService(UserManager.class)).setUserUnlocked(false);
+    ServiceInfo someServiceInfo = shadowPackageManager.addServiceIfNotPresent(SOME_COMPONENT_NAME);
+    someServiceInfo.directBootAware = true;
+    shadowPackageManager.addIntentFilterForService(SOME_COMPONENT_NAME, serviceIntentFilter);
+
+    NameResolver nameResolver = newNameResolver(intent);
+    syncContext.execute(() -> nameResolver.start(mockListener));
+    shadowOf(getMainLooper()).idle();
+
+    verify(mockListener, never()).onError(any());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertThat(getAddressesOrThrow(resultCaptor.getValue()))
+        .containsExactly(toAddressList(intent.cloneFilter().setComponent(SOME_COMPONENT_NAME)));
+
+    // TODO(b/331618070): Robolectric doesn't yet support ServiceInfo.directBootAware filtering.
+    // Simulate support by waiting for a user unlock to add this !directBootAware Service.
+    ServiceInfo anotherServiceInfo =
+        shadowPackageManager.addServiceIfNotPresent(ANOTHER_COMPONENT_NAME);
+    anotherServiceInfo.directBootAware = false;
+    shadowPackageManager.addIntentFilterForService(ANOTHER_COMPONENT_NAME, serviceIntentFilter);
+
+    shadowOf(appContext.getSystemService(UserManager.class)).setUserUnlocked(true);
+    broadcastUserUnlocked(myUserHandle());
+    shadowOf(getMainLooper()).idle();
+
+    verify(mockListener, never()).onError(any());
+    verify(mockListener, times(2)).onResult2(resultCaptor.capture());
+    assertThat(getAddressesOrThrow(resultCaptor.getValue()))
+        .containsExactly(
+            toAddressList(intent.cloneFilter().setComponent(SOME_COMPONENT_NAME)),
+            toAddressList(intent.cloneFilter().setComponent(ANOTHER_COMPONENT_NAME)));
+
+    syncContext.execute(nameResolver::shutdown);
+    shadowOf(getMainLooper()).idle();
+    verifyNoMoreInteractions(mockListener);
+  }
+
+  @Test
+  public void testRefresh_returnsSameAndroidComponentAddresses() throws Exception {
+    Intent intent = newIntent();
+    IntentFilter serviceIntentFilter = newFilterMatching(intent);
+
+    shadowPackageManager.addServiceIfNotPresent(SOME_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(SOME_COMPONENT_NAME, serviceIntentFilter);
+    shadowPackageManager.addServiceIfNotPresent(ANOTHER_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(ANOTHER_COMPONENT_NAME, serviceIntentFilter);
+
+    NameResolver nameResolver = newNameResolver(intent);
+    syncContext.execute(() -> nameResolver.start(mockListener));
+    shadowOf(getMainLooper()).idle();
+
+    verify(mockListener, never()).onError(any());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertThat(getAddressesOrThrow(resultCaptor.getValue()))
+        .containsExactly(
+            toAddressList(intent.cloneFilter().setComponent(SOME_COMPONENT_NAME)),
+            toAddressList(intent.cloneFilter().setComponent(ANOTHER_COMPONENT_NAME)));
+
+    syncContext.execute(nameResolver::refresh);
+    shadowOf(getMainLooper()).idle();
+    verify(mockListener, never()).onError(any());
+    verify(mockListener, times(2)).onResult2(resultCaptor.capture());
+    assertThat(getAddressesOrThrow(resultCaptor.getValue()))
+        .containsExactly(
+            toAddressList(intent.cloneFilter().setComponent(SOME_COMPONENT_NAME)),
+            toAddressList(intent.cloneFilter().setComponent(ANOTHER_COMPONENT_NAME)));
+
+    syncContext.execute(nameResolver::shutdown);
+    shadowOf(getMainLooper()).idle();
+    assertThat(shadowOf(appContext).getRegisteredReceivers()).isEmpty();
+  }
+
+  @Test
+  public void testRefresh_collapsesMultipleRequestsIntoOneLookup() throws Exception {
+    Intent intent = newIntent();
+    IntentFilter serviceIntentFilter = newFilterMatching(intent);
+
+    shadowPackageManager.addServiceIfNotPresent(SOME_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(SOME_COMPONENT_NAME, serviceIntentFilter);
+
+    NameResolver nameResolver = newNameResolver(intent);
+    syncContext.execute(() -> nameResolver.start(mockListener)); // Should kick off the 1st lookup.
+    syncContext.execute(nameResolver::refresh); // Should queue a lookup to run when 1st finishes.
+    syncContext.execute(nameResolver::refresh); // Should be ignored since a lookup is already Q'd.
+    syncContext.execute(nameResolver::refresh); // Also ignored.
+    shadowOf(getMainLooper()).idle();
+
+    verify(mockListener, never()).onError(any());
+    verify(mockListener, times(2)).onResult2(resultCaptor.capture());
+    assertThat(getAddressesOrThrow(resultCaptor.getValue()))
+        .containsExactly(toAddressList(intent.cloneFilter().setComponent(SOME_COMPONENT_NAME)));
+
+    syncContext.execute(nameResolver::shutdown);
+    shadowOf(getMainLooper()).idle();
+  }
+
+  private void broadcastPackageChange(String action, String pkgName) {
+    Intent broadcast = new Intent();
+    broadcast.setAction(action);
+    broadcast.setData(Uri.parse("package:" + pkgName));
+    appContext.sendBroadcast(broadcast);
+  }
+
+  private void broadcastUserUnlocked(UserHandle userHandle) {
+    Intent unlockedBroadcast = new Intent(Intent.ACTION_USER_UNLOCKED);
+    unlockedBroadcast.putExtra(Intent.EXTRA_USER, userHandle);
+    appContext.sendBroadcast(unlockedBroadcast);
+  }
+
+  @Test
+  public void testResolutionOnResultThrows_onErrorNotCalled() throws Exception {
+    RetainingUncaughtExceptionHandler exceptionHandler = new RetainingUncaughtExceptionHandler();
+    SynchronizationContext syncContext = new SynchronizationContext(exceptionHandler);
+    Intent intent = newIntent();
+    shadowPackageManager.addServiceIfNotPresent(SOME_COMPONENT_NAME);
+    shadowPackageManager.addIntentFilterForService(SOME_COMPONENT_NAME, newFilterMatching(intent));
+
+    @SuppressWarnings("serial")
+    class SomeRuntimeException extends RuntimeException {}
+    doThrow(SomeRuntimeException.class).when(mockListener).onResult2(any());
+
+    NameResolver nameResolver =
+        newNameResolver(
+            intent, newNameResolverArgs().setSynchronizationContext(syncContext).build());
+    syncContext.execute(() -> nameResolver.start(mockListener));
+    shadowOf(getMainLooper()).idle();
+
+    verify(mockListener).onResult2(any());
+    verify(mockListener, never()).onError(any());
+    assertThat(exceptionHandler.uncaught).hasSize(1);
+    assertThat(exceptionHandler.uncaught.get(0)).isInstanceOf(SomeRuntimeException.class);
+  }
+
+  private static Intent newIntent() {
+    Intent intent = new Intent();
+    intent.setAction("test.action");
+    intent.setData(Uri.parse("grpc:ServiceName"));
+    return intent;
+  }
+
+  private static IntentFilter newFilterMatching(Intent intent) {
+    IntentFilter filter = new IntentFilter();
+    if (intent.getAction() != null) {
+      filter.addAction(intent.getAction());
+    }
+    Uri data = intent.getData();
+    if (data != null) {
+      if (data.getScheme() != null) {
+        filter.addDataScheme(data.getScheme());
+      }
+      if (data.getSchemeSpecificPart() != null) {
+        filter.addDataSchemeSpecificPart(data.getSchemeSpecificPart(), 0);
+      }
+    }
+    Set<String> categories = intent.getCategories();
+    if (categories != null) {
+      for (String category : categories) {
+        filter.addCategory(category);
+      }
+    }
+    return filter;
+  }
+
+  private static List<EquivalentAddressGroup> getEagsOrThrow(ResolutionResult result) {
+    StatusOr<List<EquivalentAddressGroup>> eags = result.getAddressesOrError();
+    if (!eags.hasValue()) {
+      throw eags.getStatus().asRuntimeException();
+    }
+    return eags.getValue();
+  }
+
+  // Extracts just the addresses from 'result's EquivalentAddressGroups.
+  private static ImmutableList<List<SocketAddress>> getAddressesOrThrow(ResolutionResult result) {
+    return getEagsOrThrow(result).stream()
+        .map(EquivalentAddressGroup::getAddresses)
+        .collect(toImmutableList());
+  }
+
+  // Converts given Intents to a list of ACAs, for convenient comparison with getAddressesOrThrow().
+  private static ImmutableList<AndroidComponentAddress> toAddressList(Intent... bindIntents) {
+    ImmutableList.Builder<AndroidComponentAddress> builder = ImmutableList.builder();
+    for (Intent bindIntent : bindIntents) {
+      builder.add(AndroidComponentAddress.forBindIntent(bindIntent));
+    }
+    return builder.build();
+  }
+
+  private NameResolver newNameResolver(Intent targetIntent) {
+    return newNameResolver(targetIntent, args);
+  }
+
+  private NameResolver newNameResolver(Intent targetIntent, NameResolver.Args args) {
+    return new IntentNameResolver(targetIntent, args);
+  }
+
+  /** Returns a new test-specific {@link NameResolver.Args} instance. */
+  private NameResolver.Args.Builder newNameResolverArgs() {
+    return NameResolver.Args.newBuilder()
+        .setDefaultPort(-1)
+        .setProxyDetector((target) -> null) // No proxies here.
+        .setSynchronizationContext(syncContext)
+        .setOffloadExecutor(ContextCompat.getMainExecutor(appContext))
+        .setArg(ApiConstants.SOURCE_ANDROID_CONTEXT, appContext)
+        .setServiceConfigParser(mock(ServiceConfigParser.class));
+  }
+
+  /**
+   * Returns a test {@link SynchronizationContext}.
+   *
+   * <p>Exceptions will cause the test to fail with {@link AssertionError}.
+   */
+  private static SynchronizationContext newSynchronizationContext() {
+    return new SynchronizationContext(
+        (thread, exception) -> {
+          throw new AssertionError(exception);
+        });
+  }
+
+  static final class RetainingUncaughtExceptionHandler implements UncaughtExceptionHandler {
+    final ArrayList<Throwable> uncaught = new ArrayList<>();
+
+    @Override
+    public void uncaughtException(@NonNull Thread t, @NonNull Throwable e) {
+      uncaught.add(e);
+    }
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/OneWayBinderProxyTest.java b/binder/src/test/java/io/grpc/binder/internal/OneWayBinderProxyTest.java
new file mode 100644
index 00000000000..167e33e29a5
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/OneWayBinderProxyTest.java
@@ -0,0 +1,197 @@
+package io.grpc.binder.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.os.Binder;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.os.RemoteException;
+import io.grpc.binder.internal.OneWayBinderProxy.InProcessImpl;
+import io.grpc.binder.internal.OneWayBinderProxy.OutOfProcessImpl;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Queue;
+import java.util.concurrent.Executor;
+import java.util.concurrent.RejectedExecutionException;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.RobolectricTestRunner;
+
+/** Unit tests for the {@link OneWayBinderProxy} implementations. */
+@RunWith(RobolectricTestRunner.class)
+public class OneWayBinderProxyTest {
+  @Rule public final MockitoRule mockito = MockitoJUnit.rule();
+
+  QueuingExecutor queuingExecutor = new QueuingExecutor();
+
+  @Mock IBinder mockBinder;
+
+  RecordingBinder recordingBinder = new RecordingBinder();
+
+  @Test
+  public void shouldProxyInProcessTransactionsOnExecutor() throws RemoteException {
+    InProcessImpl proxy = new InProcessImpl(recordingBinder, queuingExecutor);
+    try (ParcelHolder parcel = ParcelHolder.obtain()) {
+      parcel.get().writeInt(123);
+      proxy.transact(456, parcel);
+      assertThat(parcel.isEmpty()).isTrue();
+      assertThat(recordingBinder.txnLog).isEmpty();
+      queuingExecutor.runAllQueued();
+      assertThat(recordingBinder.txnLog).hasSize(1);
+      assertThat(recordingBinder.txnLog.get(0).argument).isEqualTo(123);
+      assertThat(recordingBinder.txnLog.get(0).code).isEqualTo(456);
+      assertThat(recordingBinder.txnLog.get(0).flags).isEqualTo(IBinder.FLAG_ONEWAY);
+    }
+  }
+
+  @Test
+  public void shouldNotLeakParcelsInCaseOfRejectedExecution() throws RemoteException {
+    InProcessImpl proxy = new InProcessImpl(recordingBinder, queuingExecutor);
+    queuingExecutor.shutdown();
+    try (ParcelHolder parcel = ParcelHolder.obtain()) {
+      parcel.get().writeInt(123);
+      assertThrows(RejectedExecutionException.class, () -> proxy.transact(123, parcel));
+      assertThat(parcel.isEmpty()).isFalse(); // Parcel didn't leak because we still own it.
+    }
+  }
+
+  @Test
+  public void shouldProxyOutOfProcessTransactionsSynchronously() throws RemoteException {
+    OutOfProcessImpl proxy = new OutOfProcessImpl(recordingBinder);
+    try (ParcelHolder parcel = ParcelHolder.obtain()) {
+      parcel.get().writeInt(123);
+      proxy.transact(456, parcel);
+      assertThat(parcel.isEmpty()).isTrue();
+      assertThat(recordingBinder.txnLog).hasSize(1);
+      assertThat(recordingBinder.txnLog.get(0).argument).isEqualTo(123);
+      assertThat(recordingBinder.txnLog.get(0).code).isEqualTo(456);
+      assertThat(recordingBinder.txnLog.get(0).flags).isEqualTo(IBinder.FLAG_ONEWAY);
+    }
+  }
+
+  @Test
+  public void shouldIgnoreInProcessRemoteExceptions() throws RemoteException {
+    when(mockBinder.transact(anyInt(), any(), any(), anyInt())).thenThrow(RemoteException.class);
+    InProcessImpl proxy = new InProcessImpl(mockBinder, queuingExecutor);
+    try (ParcelHolder parcel = ParcelHolder.obtain()) {
+      proxy.transact(123, parcel); // Doesn't throw.
+      verify(mockBinder, never()).transact(anyInt(), any(), any(), anyInt());
+      queuingExecutor.runAllQueued();
+    }
+  }
+
+  @Test
+  public void shouldExposeOutOfProcessRemoteExceptions() throws RemoteException {
+    when(mockBinder.transact(anyInt(), any(), any(), anyInt())).thenThrow(RemoteException.class);
+    OutOfProcessImpl proxy = new OutOfProcessImpl(mockBinder);
+    try (ParcelHolder parcel = ParcelHolder.obtain()) {
+      assertThrows(RemoteException.class, () -> proxy.transact(123, parcel));
+    }
+  }
+
+  @Test
+  public void shouldIgnoreUnknownTransactionReturnValueInProcess() throws RemoteException {
+    when(mockBinder.transact(anyInt(), any(), any(), anyInt())).thenReturn(false);
+    InProcessImpl proxy = new InProcessImpl(mockBinder, queuingExecutor);
+    try (ParcelHolder parcel = ParcelHolder.obtain()) {
+      proxy.transact(123, parcel); // Doesn't throw.
+      verify(mockBinder, never()).transact(anyInt(), any(), any(), anyInt());
+      queuingExecutor.runAllQueued();
+      verify(mockBinder).transact(eq(123), any(), any(), anyInt());
+    }
+  }
+
+  @Test
+  public void shouldReportImpossibleUnknownTransactionReturnValueOutOfProcess()
+      throws RemoteException {
+    when(mockBinder.transact(anyInt(), any(), any(), anyInt())).thenReturn(false);
+    OutOfProcessImpl proxy = new OutOfProcessImpl(mockBinder);
+    try (ParcelHolder parcel = ParcelHolder.obtain()) {
+      assertThrows(RemoteException.class, () -> proxy.transact(123, parcel));
+      verify(mockBinder).transact(eq(123), any(), any(), anyInt());
+    }
+  }
+
+  /** An Executor that queues up Runnables for later manual execution by a unit test. */
+  static class QueuingExecutor implements Executor {
+    private final Queue<Runnable> runnables = new ArrayDeque<>();
+    private volatile boolean isShutdown;
+
+    @Override
+    public void execute(Runnable r) {
+      if (isShutdown) {
+        throw new RejectedExecutionException();
+      }
+      runnables.add(r);
+    }
+
+    public void runAllQueued() {
+      Runnable next = null;
+      while ((next = runnables.poll()) != null) {
+        next.run();
+      }
+    }
+
+    public void shutdown() {
+      isShutdown = true;
+    }
+  }
+
+  /** An immutable record of a call to {@link IBinder#transact(int, Parcel, Parcel, int)}. */
+  static class TransactionRecord {
+    private final int code;
+    private final int argument;
+    private final int flags;
+
+    private TransactionRecord(int code, int argument, int flags) {
+      this.code = code;
+      this.argument = argument;
+      this.flags = flags;
+    }
+  }
+
+  /** A {@link Binder} that simply records every transaction it receives. */
+  static class RecordingBinder extends Binder {
+    private final ArrayList<TransactionRecord> txnLog = new ArrayList<>();
+
+    @Override
+    protected boolean onTransact(int code, Parcel data, Parcel reply, int flags)
+        throws RemoteException {
+      txnLog.add(new TransactionRecord(code, data.readInt(), flags));
+      return true;
+    }
+  }
+
+  interface ThrowingRunnable {
+    void run() throws Throwable;
+  }
+
+  // TODO(jdcormie): Replace with Assert.assertThrows() once we upgrade to junit 4.13.
+  private static <T extends Throwable> T assertThrows(
+      Class<T> expectedThrowable, ThrowingRunnable runnable) {
+    try {
+      runnable.run();
+    } catch (Throwable actualThrown) {
+      if (expectedThrowable.isInstance(actualThrown)) {
+        @SuppressWarnings("unchecked")
+        T retVal = (T) actualThrown;
+        return retVal;
+      } else {
+        AssertionError assertionError = new AssertionError("Unexpected type thrown");
+        assertionError.initCause(actualThrown);
+        throw assertionError;
+      }
+    }
+    throw new AssertionError("Expected " + expectedThrowable + " but nothing was thrown");
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/ParcelableInputStreamTest.java b/binder/src/test/java/io/grpc/binder/internal/ParcelableInputStreamTest.java
new file mode 100644
index 00000000000..657c6d77db5
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/ParcelableInputStreamTest.java
@@ -0,0 +1,129 @@
+/*
+ * 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 android.os.Parcelable;
+import com.google.common.io.ByteStreams;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public final class ParcelableInputStreamTest {
+
+  private final TestParcelable testParcelable = new TestParcelable("testing");
+  private final TestParcelable testParcelableWithFds =
+      new TestParcelable("testing_with_fds", Parcelable.CONTENTS_FILE_DESCRIPTOR);
+
+  @Test
+  public void testGetParcelable() throws Exception {
+    ParcelableInputStream<TestParcelable> stream =
+        ParcelableInputStream.forInstance(testParcelable, TestParcelable.CREATOR);
+
+    // We should serialize/deserialize the parcelable.
+    TestParcelable parceable = stream.getParcelable();
+    assertThat(parceable).isEqualTo(testParcelable);
+    assertThat(parceable).isNotSameInstanceAs(testParcelable);
+
+    // But just once.
+    assertThat(stream.getParcelable()).isSameInstanceAs(parceable);
+  }
+
+  @Test
+  public void testGetParcelableWithFds() throws Exception {
+    ParcelableInputStream<TestParcelable> stream =
+        ParcelableInputStream.forInstance(testParcelableWithFds, TestParcelable.CREATOR);
+
+    // We should serialize/deserialize the parcelable.
+    TestParcelable parceable = stream.getParcelable();
+    assertThat(parceable).isEqualTo(testParcelableWithFds);
+    assertThat(parceable).isNotSameInstanceAs(testParcelableWithFds);
+
+    // But just once.
+    assertThat(stream.getParcelable()).isSameInstanceAs(parceable);
+  }
+
+  @Test
+  public void testGetParcelableImmutable() throws Exception {
+    ParcelableInputStream<TestParcelable> stream =
+        ParcelableInputStream.forImmutableInstance(testParcelable, TestParcelable.CREATOR);
+
+    // We should return the parcelable directly.
+    TestParcelable parceable = stream.getParcelable();
+    assertThat(parceable).isSameInstanceAs(testParcelable);
+  }
+
+  @Test
+  public void testGetParcelableImmutableWithFds() throws Exception {
+    ParcelableInputStream<TestParcelable> stream =
+        ParcelableInputStream.forImmutableInstance(testParcelableWithFds, TestParcelable.CREATOR);
+
+    // We should return the parcelable directly.
+    TestParcelable parceable = stream.getParcelable();
+    assertThat(parceable).isSameInstanceAs(testParcelableWithFds);
+  }
+
+  @Test
+  public void testWriteToParcel() throws Exception {
+    ParcelableInputStream<TestParcelable> stream =
+        ParcelableInputStream.forImmutableInstance(testParcelable, TestParcelable.CREATOR);
+    Parcel parcel = Parcel.obtain();
+    stream.writeToParcel(parcel);
+
+    parcel.setDataPosition(0);
+    @SuppressWarnings("deprecation") // readParcelable(ClassLoader)'s replacement is only in 33+.
+    TestParcelable clone = parcel.readParcelable(getClass().getClassLoader());
+    assertThat(clone).isEqualTo(testParcelable);
+  }
+
+  @Test
+  public void testCreateFromParcel() throws Exception {
+    Parcel parcel = Parcel.obtain();
+    parcel.writeParcelable(testParcelable, 0);
+    parcel.setDataPosition(0);
+
+    ParcelableInputStream<TestParcelable> stream =
+        ParcelableInputStream.readFromParcel(parcel, getClass().getClassLoader());
+    assertThat(stream.getParcelable()).isEqualTo(testParcelable);
+  }
+
+  @Test
+  public void testAsRegularInputStream() throws Exception {
+    ParcelableInputStream<TestParcelable> stream =
+        ParcelableInputStream.forInstance(testParcelable, TestParcelable.CREATOR);
+    byte[] data = ByteStreams.toByteArray(stream);
+
+    Parcel parcel = Parcel.obtain();
+    parcel.unmarshall(data, 0, data.length);
+    parcel.setDataPosition(0);
+
+    @SuppressWarnings("deprecation") // readParcelable(ClassLoader)'s replacement is only in 33+.
+    TestParcelable clone = parcel.readParcelable(getClass().getClassLoader());
+    assertThat(clone).isEqualTo(testParcelable);
+  }
+
+  @Test
+  public void testAsRegularInputStreamFds() throws Exception {
+    ParcelableInputStream<TestParcelable> stream =
+        ParcelableInputStream.forInstance(testParcelableWithFds, TestParcelable.CREATOR);
+    byte[] data = ByteStreams.toByteArray(stream);
+    assertThat(data.length).isNotEqualTo(0);
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/PendingAuthListenerTest.java b/binder/src/test/java/io/grpc/binder/internal/PendingAuthListenerTest.java
new file mode 100644
index 00000000000..9cdf123033b
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/PendingAuthListenerTest.java
@@ -0,0 +1,101 @@
+package io.grpc.binder.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.Status;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public final class PendingAuthListenerTest {
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock ServerCallHandler<Object, Object> next;
+  @Mock ServerCall<Object, Object> call;
+  @Mock ServerCall.Listener<Object> delegate;
+  @Captor ArgumentCaptor<Status> statusCaptor;
+
+  private final Metadata headers = new Metadata();
+  private final PendingAuthListener<Object, Object> listener = new PendingAuthListener<>();
+
+  @Before
+  public void setUp() {
+    when(next.startCall(call, headers)).thenReturn(delegate);
+  }
+
+  @Test
+  public void onCallbacks_noOpBeforeStartCall() {
+    listener.onReady();
+    listener.onMessage("foo");
+    listener.onHalfClose();
+    listener.onComplete();
+
+    verifyNoInteractions(delegate);
+  }
+
+  @Test
+  public void onCallbacks_runsPendingCallbacksAfterStartCall() {
+    String message = "foo";
+
+    // Act 1
+    listener.onReady();
+    listener.onMessage(message);
+    listener.startCall(call, headers, next);
+
+    // Assert 1
+    InOrder order = Mockito.inOrder(delegate);
+    order.verify(delegate).onReady();
+    order.verify(delegate).onMessage(message);
+
+    // Act 2
+    listener.onHalfClose();
+    listener.onComplete();
+
+    // Assert 2
+    order.verify(delegate).onHalfClose();
+    order.verify(delegate).onComplete();
+  }
+
+  @Test
+  public void onCallbacks_withCancellation_runsPendingCallbacksAfterStartCall() {
+    listener.onReady();
+    listener.onCancel();
+    listener.startCall(call, headers, next);
+
+    InOrder order = Mockito.inOrder(delegate);
+    order.verify(delegate).onReady();
+    order.verify(delegate).onCancel();
+  }
+
+  @Test
+  public void whenStartCallFails_closesTheCallWithInternalStatus() {
+    IllegalStateException exception = new IllegalStateException("oops");
+    when(next.startCall(any(), any())).thenThrow(exception);
+
+    listener.onReady();
+    listener.startCall(call, headers, next);
+
+    verify(call).close(statusCaptor.capture(), any());
+    Status status = statusCaptor.getValue();
+    assertThat(status.getCode()).isEqualTo(Status.Code.INTERNAL);
+    assertThat(status.getCause()).isSameInstanceAs(exception);
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/PingTrackerTest.java b/binder/src/test/java/io/grpc/binder/internal/PingTrackerTest.java
new file mode 100644
index 00000000000..c662cafe5fa
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/PingTrackerTest.java
@@ -0,0 +1,142 @@
+/*
+ * 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 static com.google.common.util.concurrent.MoreExecutors.directExecutor;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.internal.ClientTransport;
+import io.grpc.internal.FakeClock;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+import javax.annotation.Nullable;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class PingTrackerTest {
+
+  private final FakeClock clock = new FakeClock();
+
+  @Nullable private Status pingFailureStatus;
+  private List<Integer> sentPings;
+
+  private TestCallback callback;
+  private PingTracker pingTracker;
+
+  @Before
+  public void setUp() {
+    sentPings = new ArrayList<>();
+    callback = new TestCallback();
+    pingTracker =
+        new PingTracker(
+            clock.getTicker(),
+            (id) -> {
+              sentPings.add(id);
+              if (pingFailureStatus != null) {
+                throw pingFailureStatus.asException();
+              }
+            });
+  }
+
+  @Test
+  public void successfulPing() throws Exception {
+    pingTracker.startPing(callback, directExecutor());
+    assertThat(sentPings).hasSize(1);
+    callback.assertNotCalled();
+    clock.forwardTime(3, SECONDS);
+    pingTracker.onPingResponse(sentPings.get(0));
+    callback.assertSuccess(Duration.ofSeconds(3).toNanos());
+  }
+
+  @Test
+  public void failedPing() throws Exception {
+    pingFailureStatus = Status.INTERNAL.withDescription("Hello");
+    pingTracker.startPing(callback, directExecutor());
+    callback.assertFailure(pingFailureStatus);
+  }
+
+  @Test
+  public void noSuccessAfterFailure() throws Exception {
+    pingFailureStatus = Status.INTERNAL.withDescription("Hello");
+    pingTracker.startPing(callback, directExecutor());
+    pingTracker.onPingResponse(sentPings.get(0));
+    callback.assertFailure(pingFailureStatus);
+  }
+
+  @Test
+  public void noMultiSuccess() throws Exception {
+    pingTracker.startPing(callback, directExecutor());
+    pingTracker.onPingResponse(sentPings.get(0));
+    pingTracker.onPingResponse(sentPings.get(0));
+    callback.assertSuccess(); // Checks we were only called once.
+  }
+
+  private static final class TestCallback implements ClientTransport.PingCallback {
+    private int numCallbacks;
+    private boolean success;
+    private boolean failure;
+    private Status failureStatus;
+    private long roundtripTimeNanos;
+
+    @Override
+    public synchronized void onSuccess(long roundtripTimeNanos) {
+      numCallbacks += 1;
+      success = true;
+      this.roundtripTimeNanos = roundtripTimeNanos;
+    }
+
+    @Override
+    public synchronized void onFailure(Status failureStatus) {
+      numCallbacks += 1;
+      failure = true;
+      this.failureStatus = failureStatus;
+    }
+
+    public void assertNotCalled() {
+      assertThat(numCallbacks).isEqualTo(0);
+    }
+
+    public void assertSuccess() {
+      assertThat(numCallbacks).isEqualTo(1);
+      assertThat(success).isTrue();
+    }
+
+    public void assertSuccess(long expectRoundTripTimeNanos) {
+      assertSuccess();
+      assertThat(roundtripTimeNanos).isEqualTo(expectRoundTripTimeNanos);
+    }
+
+    public void assertFailure(Status status) {
+      assertThat(numCallbacks).isEqualTo(1);
+      assertThat(failure).isTrue();
+      assertThat(failureStatus).isSameInstanceAs(status);
+    }
+
+    public void assertFailure(Status.Code statusCode) {
+      assertThat(numCallbacks).isEqualTo(1);
+      assertThat(failure).isTrue();
+      assertThat(failureStatus.getCode()).isEqualTo(statusCode);
+    }
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/RobolectricBinderTransportTest.java b/binder/src/test/java/io/grpc/binder/internal/RobolectricBinderTransportTest.java
new file mode 100644
index 00000000000..8282f5e1025
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/RobolectricBinderTransportTest.java
@@ -0,0 +1,436 @@
+/*
+ * Copyright 2025 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 android.os.IBinder.FLAG_ONEWAY;
+import static android.os.Process.myUid;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
+import static io.grpc.binder.internal.BinderTransport.REMOTE_UID;
+import static io.grpc.binder.internal.BinderTransport.SETUP_TRANSPORT;
+import static io.grpc.binder.internal.BinderTransport.SHUTDOWN_TRANSPORT;
+import static io.grpc.binder.internal.BinderTransport.WIRE_FORMAT_VERSION;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.verify;
+import static org.robolectric.Shadows.shadowOf;
+
+import android.app.Application;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.ServiceInfo;
+import android.os.Binder;
+import android.os.Parcel;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.core.content.pm.ApplicationInfoBuilder;
+import androidx.test.core.content.pm.PackageInfoBuilder;
+import com.google.common.collect.ImmutableList;
+import com.google.common.truth.TruthJUnit;
+import io.grpc.Attributes;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.binder.AndroidComponentAddress;
+import io.grpc.binder.ApiConstants;
+import io.grpc.binder.AsyncSecurityPolicy;
+import io.grpc.binder.SecurityPolicies;
+import io.grpc.binder.internal.SettableAsyncSecurityPolicy.AuthRequest;
+import io.grpc.internal.AbstractTransportTest;
+import io.grpc.internal.ClientTransport;
+import io.grpc.internal.ClientTransportFactory.ClientTransportOptions;
+import io.grpc.internal.ConnectionClientTransport;
+import io.grpc.internal.DisconnectError;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ManagedClientTransport;
+import io.grpc.internal.MockServerTransportListener;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourcePool;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.ParameterizedRobolectricTestRunner;
+import org.robolectric.ParameterizedRobolectricTestRunner.Parameter;
+import org.robolectric.ParameterizedRobolectricTestRunner.Parameters;
+import org.robolectric.annotation.LooperMode;
+import org.robolectric.annotation.LooperMode.Mode;
+import org.robolectric.shadows.ShadowBinder;
+
+/**
+ * All of the AbstractTransportTest cases applied to {@link BinderTransport} running in a
+ * Robolectric environment.
+ *
+ * <p>Runs much faster than BinderTransportTest and doesn't require an Android device/emulator.
+ * Somewhat less realistic but allows simulating behavior that would be difficult or impossible with
+ * real Android.
+ *
+ * <p>NB: Unlike most robolectric tests, we run in {@link LooperMode.Mode#INSTRUMENTATION_TEST},
+ * meaning test cases don't run on the main thread. This supports the AbstractTransportTest approach
+ * where the test thread frequently blocks waiting for transport state changes to take effect.
+ */
+@RunWith(ParameterizedRobolectricTestRunner.class)
+@LooperMode(Mode.INSTRUMENTATION_TEST)
+public final class RobolectricBinderTransportTest extends AbstractTransportTest {
+
+  static final int SERVER_APP_UID = 11111;
+  static final int EPHEMERAL_SERVER_UID = 22222; // UID of isolated server process.
+
+  private final Application application = ApplicationProvider.getApplicationContext();
+  private final ObjectPool<ScheduledExecutorService> executorServicePool =
+      SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE);
+  private final ObjectPool<Executor> offloadExecutorPool =
+      SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR);
+  private final ObjectPool<Executor> serverExecutorPool =
+      SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR);
+
+  @Rule public MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock AsyncSecurityPolicy mockClientSecurityPolicy;
+
+  @Captor ArgumentCaptor<Status> statusCaptor;
+
+  ApplicationInfo serverAppInfo;
+  PackageInfo serverPkgInfo;
+  ServiceInfo serviceInfo;
+
+  private int nextServerAddress;
+
+  @Parameter(value = 0)
+  public boolean preAuthServersParam;
+
+  @Parameter(value = 1)
+  public boolean useLegacyAuthStrategy;
+
+  @Parameters(name = "preAuthServersParam={0};useLegacyAuthStrategy={1}")
+  public static ImmutableList<Object[]> data() {
+    return ImmutableList.of(
+        new Object[] {false, false},
+        new Object[] {false, true},
+        new Object[] {true, false},
+        new Object[] {true, true});
+  }
+
+  @Override
+  public void setUp() {
+    serverAppInfo =
+        ApplicationInfoBuilder.newBuilder().setPackageName("the.server.package").build();
+    serverAppInfo.uid = myUid();
+    serverPkgInfo =
+        PackageInfoBuilder.newBuilder()
+            .setPackageName(serverAppInfo.packageName)
+            .setApplicationInfo(serverAppInfo)
+            .build();
+    shadowOf(application.getPackageManager()).installPackage(serverPkgInfo);
+
+    serviceInfo = new ServiceInfo();
+    serviceInfo.name = "SomeService";
+    serviceInfo.packageName = serverAppInfo.packageName;
+    serviceInfo.applicationInfo = serverAppInfo;
+    shadowOf(application.getPackageManager()).addOrUpdateService(serviceInfo);
+
+    super.setUp();
+  }
+
+  @Before
+  public void requestRealisticBindServiceBehavior() {
+    shadowOf(application).setBindServiceCallsOnServiceConnectedDirectly(false);
+    shadowOf(application).setUnbindServiceCallsOnServiceDisconnected(false);
+  }
+
+  @Override
+  protected InternalServer newServer(List<ServerStreamTracer.Factory> streamTracerFactories) {
+    AndroidComponentAddress listenAddr =
+        AndroidComponentAddress.forBindIntent(
+            new Intent()
+                .setClassName(serviceInfo.packageName, serviceInfo.name)
+                .setAction("io.grpc.action.BIND." + nextServerAddress++));
+
+    BinderServer binderServer =
+        new BinderServer.Builder()
+            .setListenAddress(listenAddr)
+            .setExecutorPool(serverExecutorPool)
+            .setExecutorServicePool(executorServicePool)
+            .setStreamTracerFactories(streamTracerFactories)
+            .build();
+
+    shadowOf(application.getPackageManager()).addServiceIfNotPresent(listenAddr.getComponent());
+    shadowOf(application)
+        .setComponentNameAndServiceForBindServiceForIntent(
+            listenAddr.asBindIntent(), listenAddr.getComponent(), binderServer.getHostBinder());
+    return binderServer;
+  }
+
+  @Override
+  protected InternalServer newServer(
+      int port, List<ServerStreamTracer.Factory> streamTracerFactories) {
+    if (port > 0) {
+      // TODO: TCP ports have no place in an *abstract* transport test. Replace with SocketAddress.
+      throw new UnsupportedOperationException();
+    }
+    return newServer(streamTracerFactories);
+  }
+
+  BinderClientTransportFactory.Builder newClientTransportFactoryBuilder() {
+    return new BinderClientTransportFactory.Builder()
+        .setPreAuthorizeServers(preAuthServersParam)
+        .setUseLegacyAuthStrategy(useLegacyAuthStrategy)
+        .setSourceContext(application)
+        .setScheduledExecutorPool(executorServicePool)
+        .setOffloadExecutorPool(offloadExecutorPool);
+  }
+
+  BinderClientTransportBuilder newClientTransportBuilder() {
+    return new BinderClientTransportBuilder()
+        .setFactory(newClientTransportFactoryBuilder().buildClientTransportFactory())
+        .setServerAddress(server.getListenSocketAddress());
+  }
+
+  @Override
+  protected ManagedClientTransport newClientTransport(InternalServer server) {
+    ClientTransportOptions options = new ClientTransportOptions();
+    options.setEagAttributes(eagAttrs());
+    options.setChannelLogger(transportLogger());
+
+    return newClientTransportBuilder()
+        .setServerAddress(server.getListenSocketAddress())
+        .setOptions(options)
+        .build();
+  }
+
+  @Override
+  protected String testAuthority(InternalServer server) {
+    return ((AndroidComponentAddress) server.getListenSocketAddress()).getAuthority();
+  }
+
+  @Test
+  public void clientAuthorizesServerUidsInOrder() throws Exception {
+    // TODO(jdcormie): In real Android, Binder#getCallingUid is thread-local but Robolectric only
+    //  lets us fake value this *globally*. So the ShadowBinder#setCallingUid() here unrealistically
+    //  affects the server's view of the client's uid too. For now this doesn't matter because this
+    //  test never exercises server SecurityPolicy.
+    ShadowBinder.setCallingUid(EPHEMERAL_SERVER_UID);
+
+    serverPkgInfo.applicationInfo.uid = SERVER_APP_UID;
+    shadowOf(application.getPackageManager()).installPackage(serverPkgInfo);
+    shadowOf(application.getPackageManager()).addOrUpdateService(serviceInfo);
+    server = newServer(ImmutableList.of());
+    server.start(serverListener);
+
+    SettableAsyncSecurityPolicy securityPolicy = new SettableAsyncSecurityPolicy();
+    client =
+        newClientTransportBuilder()
+            .setFactory(
+                newClientTransportFactoryBuilder()
+                    .setSecurityPolicy(securityPolicy)
+                    .buildClientTransportFactory())
+            .build();
+    runIfNotNull(client.start(mockClientTransportListener));
+
+    if (preAuthServersParam) {
+      AuthRequest preAuthRequest = securityPolicy.takeNextAuthRequest(TIMEOUT_MS, MILLISECONDS);
+      assertThat(preAuthRequest.uid).isEqualTo(SERVER_APP_UID);
+      verify(mockClientTransportListener, never()).transportReady();
+      preAuthRequest.setResult(Status.OK);
+    }
+
+    AuthRequest authRequest = securityPolicy.takeNextAuthRequest(TIMEOUT_MS, MILLISECONDS);
+    if (useLegacyAuthStrategy) {
+      assertThat(authRequest.uid).isEqualTo(EPHEMERAL_SERVER_UID);
+    } else {
+      assertThat(authRequest.uid).isEqualTo(SERVER_APP_UID);
+    }
+    verify(mockClientTransportListener, never()).transportReady();
+    authRequest.setResult(Status.OK);
+
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+  }
+
+  @Test
+  public void eagAttributeCanOverrideChannelPreAuthServerSetting() throws Exception {
+    server.start(serverListener);
+    SettableAsyncSecurityPolicy securityPolicy = new SettableAsyncSecurityPolicy();
+    ClientTransportOptions options = new ClientTransportOptions();
+    options.setEagAttributes(
+        Attributes.newBuilder().set(ApiConstants.PRE_AUTH_SERVER_OVERRIDE, true).build());
+    client =
+        newClientTransportBuilder()
+            .setOptions(options)
+            .setFactory(
+                newClientTransportFactoryBuilder()
+                    .setPreAuthorizeServers(preAuthServersParam) // To be overridden.
+                    .setSecurityPolicy(securityPolicy)
+                    .buildClientTransportFactory())
+            .build();
+    runIfNotNull(client.start(mockClientTransportListener));
+
+    AuthRequest preAuthRequest = securityPolicy.takeNextAuthRequest(TIMEOUT_MS, MILLISECONDS);
+    verify(mockClientTransportListener, never()).transportReady();
+    preAuthRequest.setResult(Status.OK);
+
+    AuthRequest authRequest = securityPolicy.takeNextAuthRequest(TIMEOUT_MS, MILLISECONDS);
+    verify(mockClientTransportListener, never()).transportReady();
+    authRequest.setResult(Status.OK);
+
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+  }
+
+  @Test
+  public void clientIgnoresDuplicateSetupTransaction() throws Exception {
+    server.start(serverListener);
+    client =
+        newClientTransportBuilder()
+            .setFactory(
+                newClientTransportFactoryBuilder()
+                    .setSecurityPolicy(SecurityPolicies.internalOnly())
+                    .buildClientTransportFactory())
+            .build();
+    runIfNotNull(client.start(mockClientTransportListener));
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+
+    assertThat(((ConnectionClientTransport) client).getAttributes().get(REMOTE_UID))
+        .isEqualTo(myUid());
+
+    Parcel setupParcel = Parcel.obtain();
+    try {
+      setupParcel.writeInt(WIRE_FORMAT_VERSION);
+      setupParcel.writeStrongBinder(new Binder());
+      setupParcel.setDataPosition(0);
+      ShadowBinder.setCallingUid(1 + myUid());
+      ((BinderClientTransport) client).handleTransaction(SETUP_TRANSPORT, setupParcel);
+    } finally {
+      ShadowBinder.setCallingUid(myUid());
+      setupParcel.recycle();
+    }
+
+    assertThat(((ConnectionClientTransport) client).getAttributes().get(REMOTE_UID))
+        .isEqualTo(myUid());
+  }
+
+  @Test
+  public void clientIgnoresTransactionFromNonServerUids() throws Exception {
+    server.start(serverListener);
+
+    // This test is not applicable to the new auth strategy which keeps the client Binder a secret.
+    assumeTrue(useLegacyAuthStrategy);
+
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+
+    int serverUid = ((ConnectionClientTransport) client).getAttributes().get(REMOTE_UID);
+    int someOtherUid = 1 + serverUid;
+    sendShutdownTransportTransactionAsUid(client, someOtherUid);
+
+    // Demonstrate that the transport is still working and that shutdown transaction was ignored.
+    ClientTransport.PingCallback mockPingCallback = mock(ClientTransport.PingCallback.class);
+    client.ping(mockPingCallback, directExecutor());
+    verify(mockPingCallback, timeout(TIMEOUT_MS)).onSuccess(anyLong());
+
+    // Try again as the expected uid to demonstrate that this wasn't ignored for some other reason.
+    sendShutdownTransportTransactionAsUid(client, serverUid);
+
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS))
+        .transportShutdown(statusCaptor.capture(), any(DisconnectError.class));
+    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(statusCaptor.getValue().getDescription()).contains("shutdown");
+  }
+
+  static void sendShutdownTransportTransactionAsUid(ClientTransport client, int sendingUid) {
+    int originalUid = Binder.getCallingUid();
+    try {
+      ShadowBinder.setCallingUid(sendingUid);
+      ((BinderClientTransport) client)
+          .getIncomingBinderForTesting()
+          .onTransact(SHUTDOWN_TRANSPORT, null, null, FLAG_ONEWAY);
+    } finally {
+      ShadowBinder.setCallingUid(originalUid);
+    }
+  }
+
+  @Test
+  public void clientReportsAuthzErrorToServer() throws Exception {
+    server.start(serverListener);
+    client =
+        newClientTransportBuilder()
+            .setFactory(
+                newClientTransportFactoryBuilder()
+                    .setSecurityPolicy(SecurityPolicies.permissionDenied("test"))
+                    .buildClientTransportFactory())
+            .build();
+    runIfNotNull(client.start(mockClientTransportListener));
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS))
+        .transportShutdown(statusCaptor.capture(), any(DisconnectError.class));
+    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Status.Code.PERMISSION_DENIED);
+
+    // Client doesn't tell the server in this case by design -- we don't even want to start it!
+    TruthJUnit.assume().that(preAuthServersParam).isFalse();
+    // Similar story here. The client won't send a setup transaction to an unauthorized server.
+    TruthJUnit.assume().that(useLegacyAuthStrategy).isTrue();
+
+    MockServerTransportListener serverTransportListener =
+        serverListener.takeListenerOrFail(TIMEOUT_MS, MILLISECONDS);
+    serverTransportListener.waitForTermination(TIMEOUT_MS, MILLISECONDS);
+    assertThat(serverTransportListener.isTerminated()).isTrue();
+  }
+
+  @Test
+  @Override
+  // We don't quite pass the official/abstract version of this test yet because
+  // today's binder client and server transports have different ideas of each others' address.
+  // TODO(#12347): Remove this @Override once this difference is resolved.
+  public void socketStats() throws Exception {
+    server.start(serverListener);
+    ManagedClientTransport client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+
+    SocketStats clientSocketStats = client.getStats().get();
+    assertThat(clientSocketStats.local).isInstanceOf(AndroidComponentAddress.class);
+    assertThat(((AndroidComponentAddress) clientSocketStats.remote).getPackage())
+        .isEqualTo(((AndroidComponentAddress) server.getListenSocketAddress()).getPackage());
+
+    MockServerTransportListener serverTransportListener =
+        serverListener.takeListenerOrFail(TIMEOUT_MS, MILLISECONDS);
+    SocketStats serverSocketStats = serverTransportListener.transport.getStats().get();
+    assertThat(serverSocketStats.local).isEqualTo(server.getListenSocketAddress());
+    assertThat(serverSocketStats.remote).isEqualTo(new BoundClientAddress(myUid()));
+  }
+
+  @Test
+  @Ignore("See BinderTransportTest#flowControlPushBack")
+  @Override
+  public void flowControlPushBack() {}
+
+  @Test
+  @Ignore("See BinderTransportTest#serverAlreadyListening")
+  @Override
+  public void serverAlreadyListening() {}
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/ServiceBindingTest.java b/binder/src/test/java/io/grpc/binder/internal/ServiceBindingTest.java
new file mode 100644
index 00000000000..0f57b6f8a30
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/ServiceBindingTest.java
@@ -0,0 +1,546 @@
+/*
+ * 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 android.content.Context.BIND_AUTO_CREATE;
+import static android.os.Looper.getMainLooper;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.fail;
+import static org.robolectric.Shadows.shadowOf;
+
+import android.app.Application;
+import android.app.admin.DevicePolicyManager;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ServiceInfo;
+import android.os.Build;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.os.UserHandle;
+import androidx.core.content.ContextCompat;
+import androidx.test.core.app.ApplicationProvider;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.StatusException;
+import io.grpc.binder.BinderChannelCredentials;
+import io.grpc.binder.internal.Bindable.Observer;
+import java.util.Arrays;
+import javax.annotation.Nullable;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowApplication;
+
+@RunWith(RobolectricTestRunner.class)
+public final class ServiceBindingTest {
+
+  @Rule public MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock IBinder mockBinder;
+
+  private Application appContext;
+  private ComponentName serviceComponent;
+  private ServiceInfo serviceInfo = new ServiceInfo();
+  private ShadowApplication shadowApplication;
+  private TestObserver observer;
+  private ServiceBinding binding;
+
+  @Before
+  public void setUp() {
+    appContext = ApplicationProvider.getApplicationContext();
+    serviceComponent = new ComponentName("DUMMY", "SERVICE");
+    serviceInfo.packageName = serviceComponent.getPackageName();
+    serviceInfo.name = serviceComponent.getClassName();
+    observer = new TestObserver();
+
+    shadowApplication = shadowOf(appContext);
+    shadowApplication.setComponentNameAndServiceForBindService(serviceComponent, mockBinder);
+    shadowOf(appContext.getPackageManager()).addOrUpdateService(serviceInfo);
+
+    // Don't call onServiceDisconnected() upon unbindService(), just like the real Android doesn't.
+    shadowApplication.setUnbindServiceCallsOnServiceDisconnected(false);
+    shadowApplication.setBindServiceCallsOnServiceConnectedDirectly(false);
+
+    binding = newBuilder().build();
+    shadowOf(getMainLooper()).idle();
+  }
+
+  private ServiceBindingBuilder newBuilder() {
+    return new ServiceBindingBuilder()
+        .setSourceContext(appContext)
+        .setTargetComponent(serviceComponent)
+        .setFlags(BIND_AUTO_CREATE)
+        .setObserver(observer);
+  }
+
+  @Test
+  public void testInitialState() throws Exception {
+    assertThat(shadowApplication.getBoundServiceConnections()).isEmpty();
+    assertThat(observer.gotBoundEvent).isFalse();
+    assertThat(observer.gotUnboundEvent).isFalse();
+    assertThat(binding.isSourceContextCleared()).isFalse();
+  }
+
+  @Test
+  public void testBind() throws Exception {
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+
+    assertThat(shadowApplication.getBoundServiceConnections()).isNotEmpty();
+    assertThat(observer.gotBoundEvent).isTrue();
+    assertThat(observer.binder).isSameInstanceAs(mockBinder);
+    assertThat(observer.gotUnboundEvent).isFalse();
+    assertThat(binding.isSourceContextCleared()).isFalse();
+  }
+
+  @Test
+  public void testGetConnectedServiceInfo() throws Exception {
+    binding = newBuilder().setTargetComponent(serviceComponent).build();
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+
+    assertThat(observer.gotBoundEvent).isTrue();
+
+    ServiceInfo serviceInfo = binding.getConnectedServiceInfo();
+    assertThat(serviceInfo.name).isEqualTo(serviceComponent.getClassName());
+    assertThat(serviceInfo.packageName).isEqualTo(serviceComponent.getPackageName());
+  }
+
+  @Test
+  public void testGetConnectedServiceInfoThrows() throws Exception {
+    binding = newBuilder().setTargetComponent(serviceComponent).build();
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+
+    assertThat(observer.gotBoundEvent).isTrue();
+    shadowOf(appContext.getPackageManager()).removeService(serviceComponent);
+
+    StatusException se = assertThrows(StatusException.class, binding::getConnectedServiceInfo);
+    assertThat(se.getStatus().getCode()).isEqualTo(Code.UNIMPLEMENTED);
+  }
+
+  @Test
+  public void testBindingIntent() throws Exception {
+    shadowApplication.setComponentNameAndServiceForBindService(null, null);
+    shadowApplication.setComponentNameAndServiceForBindServiceForIntent(
+        new Intent("foo").setComponent(serviceComponent), serviceComponent, mockBinder);
+    binding = newBuilder().setBindingAction("foo").build();
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+
+    assertThat(shadowApplication.getBoundServiceConnections()).isNotEmpty();
+  }
+
+  @Test
+  public void testUnbind() throws Exception {
+    binding.unbind();
+    shadowOf(getMainLooper()).idle();
+
+    assertThat(shadowApplication.getBoundServiceConnections()).isEmpty();
+    assertThat(observer.gotBoundEvent).isFalse();
+    assertThat(observer.gotUnboundEvent).isTrue();
+    assertThat(observer.unboundReason.getCode()).isEqualTo(Code.CANCELLED);
+    assertThat(binding.isSourceContextCleared()).isTrue();
+  }
+
+  @Test
+  public void testBindUnbind() throws Exception {
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+    binding.unbind();
+    shadowOf(getMainLooper()).idle();
+
+    assertThat(shadowApplication.getBoundServiceConnections()).isEmpty();
+    assertThat(observer.gotBoundEvent).isTrue();
+    assertThat(observer.binder).isSameInstanceAs(mockBinder);
+    assertThat(observer.gotUnboundEvent).isTrue();
+    assertThat(observer.unboundReason.getCode()).isEqualTo(Code.CANCELLED);
+    assertThat(binding.isSourceContextCleared()).isTrue();
+    assertThat(shadowApplication.getBoundServiceConnections()).isEmpty();
+  }
+
+  @Test
+  public void testBindUnbindQuickly() throws Exception {
+    binding.bind();
+    binding.unbind();
+    shadowOf(getMainLooper()).idle();
+
+    assertThat(shadowApplication.getBoundServiceConnections()).isEmpty();
+    // Because unbinding happened so quickly, we won't have gotten the bind event.
+    assertThat(observer.gotBoundEvent).isFalse();
+    assertThat(observer.gotUnboundEvent).isTrue();
+    assertThat(observer.unboundReason.getCode()).isEqualTo(Code.CANCELLED);
+    assertThat(binding.isSourceContextCleared()).isTrue();
+  }
+
+  @Test
+  public void testUnbindBind() throws Exception {
+    binding.unbind();
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+    assertThat(shadowApplication.getBoundServiceConnections()).isEmpty();
+    assertThat(observer.gotBoundEvent).isFalse();
+    assertThat(observer.gotUnboundEvent).isTrue();
+    assertThat(observer.unboundReason.getCode()).isEqualTo(Code.CANCELLED);
+    assertThat(binding.isSourceContextCleared()).isTrue();
+  }
+
+  @Test
+  public void testBindFailure() throws Exception {
+    shadowApplication.declareComponentUnbindable(serviceComponent);
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+    assertThat(observer.gotBoundEvent).isFalse();
+    assertThat(observer.gotUnboundEvent).isTrue();
+    assertThat(observer.unboundReason.getCode()).isEqualTo(Code.UNIMPLEMENTED);
+    assertThat(binding.isSourceContextCleared()).isTrue();
+    assertThat(shadowApplication.getBoundServiceConnections()).isEmpty();
+  }
+
+  @Test
+  public void testBindSecurityException() throws Exception {
+    SecurityException securityException = new SecurityException();
+    shadowApplication.setThrowInBindService(securityException);
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+    assertThat(observer.gotBoundEvent).isFalse();
+    assertThat(observer.gotUnboundEvent).isTrue();
+    assertThat(observer.unboundReason.getCode()).isEqualTo(Code.PERMISSION_DENIED);
+    assertThat(observer.unboundReason.getCause()).isEqualTo(securityException);
+    assertThat(binding.isSourceContextCleared()).isTrue();
+    assertThat(shadowApplication.getBoundServiceConnections()).isEmpty();
+  }
+
+  @Test
+  public void testBindDisconnect() throws Exception {
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+    shadowApplication.getBoundServiceConnections().get(0).onServiceDisconnected(serviceComponent);
+    shadowOf(getMainLooper()).idle();
+    assertThat(observer.gotBoundEvent).isTrue();
+    assertThat(observer.gotUnboundEvent).isTrue();
+    assertThat(observer.unboundReason.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(binding.isSourceContextCleared()).isTrue();
+  }
+
+  @Test
+  public void testBindDisconnectQuickly() throws Exception {
+    binding.bind();
+    shadowApplication.getBoundServiceConnections().get(0).onServiceDisconnected(serviceComponent);
+    shadowOf(getMainLooper()).idle();
+    assertThat(observer.gotBoundEvent).isFalse(); // We won't have had time to get the binder.
+    assertThat(observer.gotUnboundEvent).isTrue();
+    assertThat(observer.unboundReason.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(binding.isSourceContextCleared()).isTrue();
+  }
+
+  @Test
+  @Config(sdk = {28}) // For onNullBinding.
+  public void testBindReturnsNull() throws Exception {
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+    shadowApplication.getBoundServiceConnections().get(0).onNullBinding(serviceComponent);
+    shadowOf(getMainLooper()).idle();
+    assertThat(observer.gotBoundEvent).isTrue();
+    assertThat(observer.gotUnboundEvent).isTrue();
+    assertThat(observer.unboundReason.getCode()).isEqualTo(Code.UNIMPLEMENTED);
+    assertThat(binding.isSourceContextCleared()).isTrue();
+  }
+
+  @Test
+  @Config(sdk = {28}) // For onNullBinding.
+  public void testBindReturnsNullQuickly() throws Exception {
+    binding.bind();
+    shadowApplication.getBoundServiceConnections().get(0).onNullBinding(serviceComponent);
+    shadowOf(getMainLooper()).idle();
+    assertThat(observer.gotBoundEvent).isFalse(); // We won't have had a chance to get the binder.
+    assertThat(observer.gotUnboundEvent).isTrue();
+    assertThat(observer.unboundReason.getCode()).isEqualTo(Code.UNIMPLEMENTED);
+    assertThat(binding.isSourceContextCleared()).isTrue();
+  }
+
+  @Test
+  public void testCallsAfterUnbindDontCrash() throws Exception {
+    binding.unbind();
+    shadowOf(getMainLooper()).idle();
+
+    assertThat(binding.isSourceContextCleared()).isTrue();
+
+    // The internal context is cleared. Try using the object to make sure it doesn't NPE.
+    binding.bind();
+    binding.unbind();
+    shadowOf(getMainLooper()).idle();
+  }
+
+  @Test
+  @Config(sdk = 30)
+  public void testBindWithTargetUserHandle() throws Exception {
+    binding = newBuilder().setTargetUserHandle(generateUserHandle(/* userId= */ 0)).build();
+    shadowOf(getMainLooper()).idle();
+
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+
+    assertThat(shadowApplication.getBoundServiceConnections()).isNotEmpty();
+    assertThat(observer.gotBoundEvent).isTrue();
+    assertThat(observer.binder).isSameInstanceAs(mockBinder);
+    assertThat(observer.gotUnboundEvent).isFalse();
+    assertThat(binding.isSourceContextCleared()).isFalse();
+  }
+
+  @Test
+  public void testResolve() throws Exception {
+    serviceInfo.processName = "x"; // ServiceInfo has no equals() so look for one distinctive field.
+    shadowOf(appContext.getPackageManager()).addOrUpdateService(serviceInfo);
+    ServiceInfo resolvedServiceInfo = binding.resolve();
+    assertThat(resolvedServiceInfo.processName).isEqualTo(serviceInfo.processName);
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void testResolveWithTargetUserHandle() throws Exception {
+    serviceInfo.processName = "x"; // ServiceInfo has no equals() so look for one distinctive field.
+    // Robolectric just ignores the user arg to resolveServiceAsUser() so this is all we can do.
+    shadowOf(appContext.getPackageManager()).addOrUpdateService(serviceInfo);
+    binding = newBuilder().setTargetUserHandle(generateUserHandle(/* userId= */ 0)).build();
+    ServiceInfo resolvedServiceInfo = binding.resolve();
+    assertThat(resolvedServiceInfo.processName).isEqualTo(serviceInfo.processName);
+  }
+
+  @Test
+  @Config(sdk = 29)
+  public void testResolveWithUnsupportedTargetUserHandle() throws Exception {
+    binding = newBuilder().setTargetUserHandle(generateUserHandle(/* userId= */ 0)).build();
+    StatusException statusException = assertThrows(StatusException.class, binding::resolve);
+    assertThat(statusException.getStatus().getCode()).isEqualTo(Code.INTERNAL);
+    assertThat(statusException.getStatus().getDescription()).contains("SDK_INT >= R");
+  }
+
+  @Test
+  public void testResolveNonExistentServiceThrows() throws Exception {
+    ComponentName doesNotExistService = new ComponentName("does.not.exist", "NoService");
+    binding = newBuilder().setTargetComponent(doesNotExistService).build();
+    StatusException statusException = assertThrows(StatusException.class, binding::resolve);
+    assertThat(statusException.getStatus().getCode()).isEqualTo(Code.UNIMPLEMENTED);
+    assertThat(statusException.getStatus().getDescription()).contains("does.not.exist");
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void testResolveNonExistentServiceWithTargetUserThrows() throws Exception {
+    ComponentName doesNotExistService = new ComponentName("does.not.exist", "NoService");
+    binding =
+        newBuilder()
+            .setTargetUserHandle(generateUserHandle(/* userId= */ 12345))
+            .setTargetComponent(doesNotExistService)
+            .build();
+    StatusException statusException = assertThrows(StatusException.class, binding::resolve);
+    assertThat(statusException.getStatus().getCode()).isEqualTo(Code.UNIMPLEMENTED);
+    assertThat(statusException.getStatus().getDescription()).contains("does.not.exist");
+    assertThat(statusException.getStatus().getDescription()).contains("12345");
+  }
+
+  @Test
+  @Config(sdk = 30)
+  public void testBindService_doesNotThrowInternalErrorWhenSdkAtLeastR() {
+    UserHandle userHandle = generateUserHandle(/* userId= */ 12345);
+    binding = newBuilder().setTargetUserHandle(userHandle).build();
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+
+    assertThat(Build.VERSION.SDK_INT).isEqualTo(Build.VERSION_CODES.R);
+    assertThat(observer.unboundReason).isNull();
+  }
+
+  @Test
+  @Config(sdk = 28)
+  public void testBindServiceAsUser_returnsErrorWhenSdkBelowR() {
+    UserHandle userHandle = generateUserHandle(/* userId= */ 12345);
+    binding = newBuilder().setTargetUserHandle(userHandle).build();
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+
+    assertThat(observer.unboundReason.getCode()).isEqualTo(Code.INTERNAL);
+    assertThat(observer.unboundReason.getDescription())
+        .isEqualTo("Cross user Channel requires Android R+");
+  }
+
+  @Test
+  @Config(sdk = 28)
+  public void testDevicePolicyBlind_returnsErrorWhenSdkBelowR() {
+    ComponentName adminComponent = new ComponentName(appContext, "DevicePolicyAdmin");
+    UserHandle user10 = generateUserHandle(/* userId= */ 10);
+    allowBindDeviceAdminForUser(appContext, adminComponent, user10);
+    binding =
+        newBuilder()
+            .setTargetUserHandle(user10)
+            .setChannelCredentials(BinderChannelCredentials.forDevicePolicyAdmin(adminComponent))
+            .build();
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+
+    assertThat(observer.unboundReason.getCode()).isEqualTo(Code.INTERNAL);
+    assertThat(observer.unboundReason.getDescription())
+        .isEqualTo("Device policy admin binding requires Android R+");
+  }
+
+  @Test
+  @Config(sdk = 30)
+  public void testBindWithDeviceAdmin() throws Exception {
+    ComponentName adminComponent = new ComponentName(appContext, "DevicePolicyAdmin");
+    UserHandle user0 = generateUserHandle(/* userId= */ 0);
+    allowBindDeviceAdminForUser(appContext, adminComponent, user0);
+    binding =
+        newBuilder()
+            .setTargetUserHandle(user0)
+            .setTargetComponent(serviceComponent)
+            .setChannelCredentials(BinderChannelCredentials.forDevicePolicyAdmin(adminComponent))
+            .build();
+    shadowOf(getMainLooper()).idle();
+
+    binding.bind();
+    shadowOf(getMainLooper()).idle();
+
+    assertThat(shadowApplication.getBoundServiceConnections()).isNotEmpty();
+    assertThat(observer.gotBoundEvent).isTrue();
+    assertThat(observer.binder).isSameInstanceAs(mockBinder);
+    assertThat(observer.gotUnboundEvent).isFalse();
+    assertThat(binding.isSourceContextCleared()).isFalse();
+
+    ServiceInfo serviceInfo = binding.getConnectedServiceInfo();
+    assertThat(serviceInfo.name).isEqualTo(serviceComponent.getClassName());
+    assertThat(serviceInfo.packageName).isEqualTo(serviceComponent.getPackageName());
+  }
+
+  private void assertNoLockHeld() {
+    try {
+      binding.wait(1);
+      fail("Lock held on binding");
+    } catch (IllegalMonitorStateException ime) {
+      // Expected.
+    } catch (InterruptedException inte) {
+      throw new AssertionError(
+          "Interrupted exception when we shouldn't have been able to wait.", inte);
+    }
+  }
+
+  private static void allowBindDeviceAdminForUser(
+      Context context, ComponentName admin, UserHandle user) {
+    DevicePolicyManager devicePolicyManager = context.getSystemService(DevicePolicyManager.class);
+    shadowOf(devicePolicyManager).setBindDeviceAdminTargetUsers(Arrays.asList(user));
+    shadowOf(devicePolicyManager).setDeviceOwner(admin);
+  }
+
+  /** Generate UserHandles the hard way. */
+  private static UserHandle generateUserHandle(int userId) {
+    Parcel userParcel = Parcel.obtain();
+    userParcel.writeInt(userId);
+    userParcel.setDataPosition(0);
+    UserHandle userHandle = new UserHandle(userParcel);
+    userParcel.recycle();
+    return userHandle;
+  }
+
+  private class TestObserver implements Bindable.Observer {
+
+    public boolean gotBoundEvent;
+    public IBinder binder;
+
+    public boolean gotUnboundEvent;
+    public Status unboundReason;
+
+    @Override
+    public void onBound(IBinder binder) {
+      assertThat(gotBoundEvent).isFalse();
+      assertNoLockHeld();
+      gotBoundEvent = true;
+      this.binder = binder;
+    }
+
+    @Override
+    public void onUnbound(Status reason) {
+      assertThat(gotUnboundEvent).isFalse();
+      assertNoLockHeld();
+      gotUnboundEvent = true;
+      unboundReason = reason;
+    }
+  }
+
+  private static class ServiceBindingBuilder {
+    private Context sourceContext;
+    private Observer observer;
+    private Intent bindIntent = new Intent();
+    private int bindServiceFlags;
+    @Nullable private UserHandle targetUserHandle = null;
+    private BinderChannelCredentials channelCredentials = BinderChannelCredentials.forDefault();
+
+    public ServiceBindingBuilder setSourceContext(Context sourceContext) {
+      this.sourceContext = sourceContext;
+      return this;
+    }
+
+    public ServiceBindingBuilder setBindingAction(String bindAction) {
+      this.bindIntent.setAction(bindAction);
+      return this;
+    }
+
+    public ServiceBindingBuilder setFlags(int bindServiceFlags) {
+      this.bindServiceFlags = bindServiceFlags;
+      return this;
+    }
+
+    public ServiceBindingBuilder setTargetComponent(ComponentName targetComponent) {
+      this.bindIntent.setComponent(targetComponent);
+      return this;
+    }
+
+    public ServiceBindingBuilder setObserver(Observer observer) {
+      this.observer = observer;
+      return this;
+    }
+
+    public ServiceBindingBuilder setTargetUserHandle(UserHandle targetUserHandle) {
+      this.targetUserHandle = targetUserHandle;
+      return this;
+    }
+
+    public ServiceBindingBuilder setChannelCredentials(
+        BinderChannelCredentials channelCredentials) {
+      this.channelCredentials = channelCredentials;
+      return this;
+    }
+
+    public ServiceBinding build() {
+      return new ServiceBinding(
+          ContextCompat.getMainExecutor(sourceContext),
+          sourceContext,
+          channelCredentials,
+          bindIntent,
+          targetUserHandle,
+          bindServiceFlags,
+          observer);
+    }
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/SimplePromiseTest.java b/binder/src/test/java/io/grpc/binder/internal/SimplePromiseTest.java
new file mode 100644
index 00000000000..6486ff5e8a1
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/SimplePromiseTest.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2025 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 static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.binder.internal.SimplePromise.Listener;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public final class SimplePromiseTest {
+
+  private static final String FULFILLED_VALUE = "a fulfilled value";
+
+  @Mock private Listener<String> mockListener1;
+  @Mock private Listener<String> mockListener2;
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private SimplePromise<String> promise = new SimplePromise<>();
+
+  @Before
+  public void setUp() {
+  }
+
+  @Test
+  public void get_beforeFulfilled_throws() {
+    IllegalStateException e = assertThrows(IllegalStateException.class, () -> promise.get());
+    assertThat(e).hasMessageThat().isEqualTo("Not yet set!");
+  }
+
+  @Test
+  public void get_afterFulfilled_returnsValue() {
+    promise.set(FULFILLED_VALUE);
+    assertThat(promise.get()).isEqualTo(FULFILLED_VALUE);
+  }
+
+  @Test
+  public void set_withNull_throws() {
+    assertThrows(NullPointerException.class, () -> promise.set(null));
+  }
+
+  @Test
+  public void set_calledTwice_throws() {
+    promise.set(FULFILLED_VALUE);
+    IllegalStateException e =
+        assertThrows(IllegalStateException.class, () -> promise.set("another value"));
+    assertThat(e).hasMessageThat().isEqualTo("Already set!");
+  }
+
+  @Test
+  public void runWhenSet_beforeFulfill_listenerIsNotifiedUponSet() {
+    promise.runWhenSet(mockListener1);
+
+    // Should not have been called yet.
+    verify(mockListener1, never()).notify(FULFILLED_VALUE);
+
+    promise.set(FULFILLED_VALUE);
+
+    // Now it should be called.
+    verify(mockListener1, times(1)).notify(FULFILLED_VALUE);
+  }
+
+  @Test
+  public void runWhenSet_afterSet_listenerIsNotifiedImmediately() {
+    promise.set(FULFILLED_VALUE);
+    promise.runWhenSet(mockListener1);
+
+    // Should have been called immediately.
+    verify(mockListener1, times(1)).notify(FULFILLED_VALUE);
+  }
+
+  @Test
+  public void multipleListeners_addedBeforeSet_allNotifiedInOrder() {
+    promise.runWhenSet(mockListener1);
+    promise.runWhenSet(mockListener2);
+
+    promise.set(FULFILLED_VALUE);
+
+    InOrder inOrder = inOrder(mockListener1, mockListener2);
+    inOrder.verify(mockListener1).notify(FULFILLED_VALUE);
+    inOrder.verify(mockListener2).notify(FULFILLED_VALUE);
+  }
+
+  @Test
+  public void listenerThrows_duringSet_propagatesException() {
+    // A listener that will throw when notified.
+    Listener<String> throwingListener =
+        (value) -> {
+          throw new UnsupportedOperationException("Listener failed");
+        };
+
+    promise.runWhenSet(throwingListener);
+
+    // Fulfilling the promise should now throw the exception from the listener.
+    UnsupportedOperationException e =
+        assertThrows(UnsupportedOperationException.class, () -> promise.set(FULFILLED_VALUE));
+    assertThat(e).hasMessageThat().isEqualTo("Listener failed");
+  }
+
+  @Test
+  public void listenerThrows_whenAddedAfterSet_propagatesException() {
+    promise.set(FULFILLED_VALUE);
+
+    // A listener that will throw when notified.
+    Listener<String> throwingListener =
+        (value) -> {
+          throw new UnsupportedOperationException("Listener failed");
+        };
+
+    // Running the listener should throw immediately because the promise is already fulfilled.
+    UnsupportedOperationException e =
+        assertThrows(
+            UnsupportedOperationException.class, () -> promise.runWhenSet(throwingListener));
+    assertThat(e).hasMessageThat().isEqualTo("Listener failed");
+  }
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/TestParcelable.java b/binder/src/test/java/io/grpc/binder/internal/TestParcelable.java
new file mode 100644
index 00000000000..a44f91162a0
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/TestParcelable.java
@@ -0,0 +1,71 @@
+/*
+ * 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.Parcel;
+import android.os.Parcelable;
+
+/** A parcelable for testing. */
+public class TestParcelable implements Parcelable {
+  private final String msg;
+  private final int contents;
+
+  public TestParcelable(String msg) {
+    this(msg, 0);
+  }
+
+  public TestParcelable(String msg, int contents) {
+    this.msg = msg;
+    this.contents = contents;
+  }
+
+  @Override
+  public int describeContents() {
+    return contents;
+  }
+
+  @Override
+  public void writeToParcel(Parcel parcel, int flags) {
+    parcel.writeString(msg);
+  }
+
+  @Override
+  public int hashCode() {
+    return msg.hashCode();
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (other instanceof TestParcelable) {
+      return msg.equals(((TestParcelable) other).msg);
+    }
+    return false;
+  }
+
+  public static final Parcelable.Creator<TestParcelable> CREATOR =
+      new Parcelable.Creator<TestParcelable>() {
+        @Override
+        public TestParcelable createFromParcel(Parcel parcel) {
+          return new TestParcelable(parcel.readString(), 0);
+        }
+
+        @Override
+        public TestParcelable[] newArray(int size) {
+          return new TestParcelable[size];
+        }
+      };
+}
diff --git a/binder/src/test/java/io/grpc/binder/internal/TransactionUtilsTest.java b/binder/src/test/java/io/grpc/binder/internal/TransactionUtilsTest.java
new file mode 100644
index 00000000000..44a3ce3ef26
--- /dev/null
+++ b/binder/src/test/java/io/grpc/binder/internal/TransactionUtilsTest.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2025 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 static io.grpc.binder.internal.TransactionUtils.newCallerFilteringHandler;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.os.Binder;
+import android.os.Parcel;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.shadows.ShadowBinder;
+
+@RunWith(RobolectricTestRunner.class)
+public final class TransactionUtilsTest {
+
+  @Rule public MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock LeakSafeOneWayBinder.TransactionHandler mockHandler;
+
+  @Test
+  public void shouldIgnoreTransactionFromWrongUid() {
+    Parcel p = Parcel.obtain();
+    int originalUid = Binder.getCallingUid();
+    try {
+      when(mockHandler.handleTransaction(eq(1234), same(p))).thenReturn(true);
+      LeakSafeOneWayBinder.TransactionHandler uid100OnlyHandler =
+          newCallerFilteringHandler(1000, mockHandler);
+
+      ShadowBinder.setCallingUid(9999);
+      boolean result = uid100OnlyHandler.handleTransaction(1234, p);
+      assertThat(result).isFalse();
+      verify(mockHandler, never()).handleTransaction(anyInt(), any());
+
+      ShadowBinder.setCallingUid(1000);
+      result = uid100OnlyHandler.handleTransaction(1234, p);
+      assertThat(result).isTrue();
+      verify(mockHandler).handleTransaction(1234, p);
+    } finally {
+      ShadowBinder.setCallingUid(originalUid);
+      p.recycle();
+    }
+  }
+}
diff --git a/binder/src/testFixtures/java/io/grpc/binder/PeerUidTestHelper.java b/binder/src/testFixtures/java/io/grpc/binder/PeerUidTestHelper.java
new file mode 100644
index 00000000000..ecd9312b02d
--- /dev/null
+++ b/binder/src/testFixtures/java/io/grpc/binder/PeerUidTestHelper.java
@@ -0,0 +1,57 @@
+package io.grpc.binder;
+
+import io.grpc.Context;
+import io.grpc.Contexts;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+
+/** Class which helps set up {@link PeerUids} to be used in tests. */
+public final class PeerUidTestHelper {
+
+  /** The UID of the calling package is set with the value of this key. */
+  public static final Metadata.Key<Integer> UID_KEY =
+      Metadata.Key.of("binder-remote-uid-for-unit-testing", PeerUidTestMarshaller.INSTANCE);
+
+  /**
+   * Creates an interceptor that associates the {@link PeerUids#REMOTE_PEER} key in the request
+   * {@link Context} with a UID provided by the client in the {@link #UID_KEY} request header, if
+   * present.
+   *
+   * <p>The returned interceptor works with any gRPC transport but is meant for in-process unit
+   * testing of gRPC/binder services that depend on {@link PeerUids}.
+   */
+  public static ServerInterceptor newTestPeerIdentifyingServerInterceptor() {
+    return new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+          ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+        if (headers.containsKey(UID_KEY)) {
+          Context context =
+              Context.current().withValue(PeerUids.REMOTE_PEER, new PeerUid(headers.get(UID_KEY)));
+          return Contexts.interceptCall(context, call, headers, next);
+        }
+        return next.startCall(call, headers);
+      }
+    };
+  }
+
+  private PeerUidTestHelper() {}
+
+  private static class PeerUidTestMarshaller implements Metadata.AsciiMarshaller<Integer> {
+
+    public static final PeerUidTestMarshaller INSTANCE = new PeerUidTestMarshaller();
+
+    @Override
+    public String toAsciiString(Integer value) {
+      return value.toString();
+    }
+
+    @Override
+    public Integer parseAsciiString(String serialized) {
+      return Integer.parseInt(serialized);
+    }
+  }
+  ;
+}
diff --git a/binder/src/testFixtures/java/io/grpc/binder/internal/BinderClientTransportBuilder.java b/binder/src/testFixtures/java/io/grpc/binder/internal/BinderClientTransportBuilder.java
new file mode 100644
index 00000000000..f732ff64663
--- /dev/null
+++ b/binder/src/testFixtures/java/io/grpc/binder/internal/BinderClientTransportBuilder.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2025 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.base.Preconditions.checkNotNull;
+
+import io.grpc.ChannelLogger;
+import io.grpc.internal.ClientTransportFactory.ClientTransportOptions;
+import io.grpc.internal.TestUtils.NoopChannelLogger;
+import java.net.SocketAddress;
+
+/**
+ * Helps unit tests create {@link BinderClientTransport} instances without having to mention
+ * irrelevant details (go/tott/719).
+ */
+public class BinderClientTransportBuilder {
+  private BinderClientTransportFactory factory;
+  private SocketAddress serverAddress;
+  private ChannelLogger channelLogger = new NoopChannelLogger();
+  private io.grpc.internal.ClientTransportFactory.ClientTransportOptions options =
+      new ClientTransportOptions();
+
+  public BinderClientTransportBuilder setServerAddress(SocketAddress serverAddress) {
+    this.serverAddress = checkNotNull(serverAddress);
+    return this;
+  }
+
+  public BinderClientTransportBuilder setChannelLogger(ChannelLogger channelLogger) {
+    this.channelLogger = checkNotNull(channelLogger);
+    return this;
+  }
+
+  public BinderClientTransportBuilder setOptions(ClientTransportOptions options) {
+    this.options = checkNotNull(options);
+    return this;
+  }
+
+  public BinderClientTransportBuilder setFactory(BinderClientTransportFactory factory) {
+    this.factory = checkNotNull(factory);
+    return this;
+  }
+
+  public BinderClientTransport build() {
+    return factory.newClientTransport(
+        checkNotNull(serverAddress), checkNotNull(options), checkNotNull(channelLogger));
+  }
+}
diff --git a/binder/src/testFixtures/java/io/grpc/binder/internal/FakeDeadBinder.java b/binder/src/testFixtures/java/io/grpc/binder/internal/FakeDeadBinder.java
new file mode 100644
index 00000000000..5bce7498c4b
--- /dev/null
+++ b/binder/src/testFixtures/java/io/grpc/binder/internal/FakeDeadBinder.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2025 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.DeadObjectException;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Parcel;
+import android.os.RemoteException;
+import java.io.FileDescriptor;
+
+/** An {@link IBinder} that behaves as if its hosting process has died, for testing. */
+public class FakeDeadBinder implements IBinder {
+  @Override
+  public boolean isBinderAlive() {
+    return false;
+  }
+
+  @Override
+  public IInterface queryLocalInterface(String descriptor) {
+    return null;
+  }
+
+  @Override
+  public String getInterfaceDescriptor() throws RemoteException {
+    throw new DeadObjectException();
+  }
+
+  @Override
+  public boolean pingBinder() {
+    return false;
+  }
+
+  @Override
+  public void dump(FileDescriptor fd, String[] args) throws RemoteException {
+    throw new DeadObjectException();
+  }
+
+  @Override
+  public void dumpAsync(FileDescriptor fd, String[] args) throws RemoteException {
+    throw new DeadObjectException();
+  }
+
+  @Override
+  public boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
+    throw new DeadObjectException();
+  }
+
+  @Override
+  public void linkToDeath(DeathRecipient r, int flags) throws RemoteException {
+    throw new DeadObjectException();
+  }
+
+  @Override
+  public boolean unlinkToDeath(DeathRecipient deathRecipient, int flags) {
+    // No need to check whether 'deathRecipient' was ever actually passed to linkToDeath(): Per our
+    // API contract, if "the IBinder has already died" we never throw and always return false.
+    return false;
+  }
+}
diff --git a/binder/src/testFixtures/java/io/grpc/binder/internal/MainThreadScheduledExecutorService.java b/binder/src/testFixtures/java/io/grpc/binder/internal/MainThreadScheduledExecutorService.java
new file mode 100644
index 00000000000..23285b462e6
--- /dev/null
+++ b/binder/src/testFixtures/java/io/grpc/binder/internal/MainThreadScheduledExecutorService.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright 2024 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.Handler;
+import android.os.Looper;
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.SettableFuture;
+import java.time.Duration;
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.AbstractExecutorService;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Delayed;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/**
+ * A {@link ScheduledExecutorService} that queues all work on Android's "main" thread.
+ *
+ * <p>Use {@link org.robolectric.shadows.ShadowLooper#idle()} to run queued work.
+ */
+public class MainThreadScheduledExecutorService extends AbstractExecutorService
+    implements ScheduledExecutorService {
+
+  private final Handler handler = new Handler(Looper.getMainLooper());
+
+  private static Runnable asRunnableFor(HandlerFuture<Void> future, Runnable runnable) {
+    return () -> {
+      try {
+        runnable.run();
+        future.complete(null);
+      } catch (Exception e) {
+        future.setException(e);
+      }
+    };
+  }
+
+  private static <V> Runnable asRunnableFor(HandlerFuture<V> future, Callable<V> callable) {
+    return () -> {
+      try {
+        future.complete(callable.call());
+      } catch (Exception e) {
+        future.setException(e);
+      }
+    };
+  }
+
+  @Override
+  public ScheduledFuture<?> schedule(Runnable runnable, long l, TimeUnit timeUnit) {
+    long millis = timeUnit.toMillis(l);
+    HandlerFuture<Void> result = new HandlerFuture<>(Duration.ofMillis(millis));
+    handler.postDelayed(asRunnableFor(result, runnable), millis);
+    return result;
+  }
+
+  @Override
+  public <V> ScheduledFuture<V> schedule(Callable<V> callable, long l, TimeUnit timeUnit) {
+    long millis = timeUnit.toMillis(l);
+    HandlerFuture<V> result = new HandlerFuture<>(Duration.ofMillis(millis));
+    handler.postDelayed(asRunnableFor(result, callable), millis);
+    return result;
+  }
+
+  @Override
+  public ScheduledFuture<?> scheduleAtFixedRate(
+      Runnable runnable, long delay, long period, TimeUnit timeUnit) {
+    return scheduleWithFixedDelay(runnable, delay, period, timeUnit);
+  }
+
+  @Override
+  public ScheduledFuture<?> scheduleWithFixedDelay(
+      Runnable runnable, long initialDelay, long delay, TimeUnit timeUnit) {
+    long initialDelayMillis = timeUnit.toMillis(initialDelay);
+    long periodMillis = timeUnit.toMillis(delay);
+    HandlerFuture<Void> result = new HandlerFuture<>(Duration.ofMillis(initialDelayMillis));
+
+    Runnable scheduledRunnable =
+        new Runnable() {
+          @Override
+          public void run() {
+            try {
+              runnable.run();
+              handler.postDelayed(this, periodMillis);
+            } catch (Exception e) {
+              result.setException(e);
+            }
+          }
+        };
+
+    handler.postDelayed(scheduledRunnable, initialDelayMillis);
+    return result;
+  }
+
+  @Override
+  public void shutdown() {}
+
+  @Override
+  public List<Runnable> shutdownNow() {
+    return ImmutableList.of();
+  }
+
+  @Override
+  public boolean isShutdown() {
+    return false;
+  }
+
+  @Override
+  public boolean isTerminated() {
+    return false;
+  }
+
+  @Override
+  public boolean awaitTermination(long l, TimeUnit timeUnit) {
+    return true;
+  }
+
+  @Override
+  public void execute(Runnable runnable) {
+    handler.post(runnable);
+  }
+
+  private static class HandlerFuture<V> implements ScheduledFuture<V> {
+
+    private final Duration delay;
+    private final SettableFuture<V> delegate = SettableFuture.create();
+
+    HandlerFuture(Duration delay) {
+      this.delay = delay;
+    }
+
+    @Override
+    public long getDelay(TimeUnit timeUnit) {
+      return timeUnit.convert(delay.toMillis(), TimeUnit.MILLISECONDS);
+    }
+
+    @Override
+    public int compareTo(Delayed other) {
+      return Comparator.comparingLong((Delayed delayed) -> delayed.getDelay(TimeUnit.MILLISECONDS))
+          .compare(this, other);
+    }
+
+    @Override
+    public boolean cancel(boolean mayInterruptIfRunning) {
+      return delegate.cancel(mayInterruptIfRunning);
+    }
+
+    @Override
+    public boolean isCancelled() {
+      return delegate.isCancelled();
+    }
+
+    @Override
+    public boolean isDone() {
+      return delegate.isDone();
+    }
+
+    @Override
+    public V get() throws ExecutionException, InterruptedException {
+      return delegate.get();
+    }
+
+    @Override
+    public V get(long timeout, TimeUnit timeUnit)
+        throws ExecutionException, InterruptedException, TimeoutException {
+      return delegate.get(timeout, timeUnit);
+    }
+
+    void complete(V result) {
+      delegate.set(result);
+    }
+
+    void setException(Exception e) {
+      delegate.setException(e);
+    }
+  }
+}
diff --git a/binder/src/testFixtures/java/io/grpc/binder/internal/SettableAsyncSecurityPolicy.java b/binder/src/testFixtures/java/io/grpc/binder/internal/SettableAsyncSecurityPolicy.java
new file mode 100644
index 00000000000..2cb22c2fdbf
--- /dev/null
+++ b/binder/src/testFixtures/java/io/grpc/binder/internal/SettableAsyncSecurityPolicy.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2025 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.base.Preconditions.checkState;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.Status;
+import io.grpc.binder.AsyncSecurityPolicy;
+import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/**
+ * An {@link AsyncSecurityPolicy} that lets unit tests verify the exact order of authorization
+ * requests and respond to them one at a time.
+ */
+public class SettableAsyncSecurityPolicy extends AsyncSecurityPolicy {
+  private final LinkedBlockingDeque<AuthRequest> pendingRequests = new LinkedBlockingDeque<>();
+
+  @Override
+  public ListenableFuture<Status> checkAuthorizationAsync(int uid) {
+    AuthRequest request = new AuthRequest(uid);
+    pendingRequests.add(request);
+    return request.resultFuture;
+  }
+
+  /**
+   * Waits for the next "check authorization" request to be made and returns it, throwing in case no
+   * request arrives in time.
+   */
+  public AuthRequest takeNextAuthRequest(long timeout, TimeUnit unit)
+      throws InterruptedException, TimeoutException {
+    AuthRequest nextAuthRequest = pendingRequests.poll(timeout, unit);
+    if (nextAuthRequest == null) {
+      throw new TimeoutException();
+    }
+    return nextAuthRequest;
+  }
+
+  /** Represents a single call to {@link AsyncSecurityPolicy#checkAuthorizationAsync(int)}. */
+  public static class AuthRequest {
+
+    /** The argument passed to {@link AsyncSecurityPolicy#checkAuthorizationAsync(int)}. */
+    public final int uid;
+
+    private final SettableFuture<Status> resultFuture = SettableFuture.create();
+
+    private AuthRequest(int uid) {
+      this.uid = uid;
+    }
+
+    /** Provides this SecurityPolicy's response to this authorization request. */
+    public void setResult(Status result) {
+      checkState(resultFuture.set(result));
+    }
+
+    /** Simulates an exceptional response to this authorization request. */
+    public void setResult(Throwable t) {
+      checkState(resultFuture.setException(t));
+    }
+
+    /** Tests if the future returned for this authorization request was cancelled by the caller. */
+    public boolean isCancelled() {
+      return resultFuture.isCancelled();
+    }
+  }
+}
\ No newline at end of file
diff --git a/bom/build.gradle b/bom/build.gradle
new file mode 100644
index 00000000000..f7f3918372f
--- /dev/null
+++ b/bom/build.gradle
@@ -0,0 +1,38 @@
+plugins {
+  id 'java-platform'
+  id "maven-publish"
+}
+
+description = 'gRPC: BOM'
+
+gradle.projectsEvaluated {
+  def projectsToInclude = rootProject.subprojects.findAll {
+    return it.name != 'grpc-compiler'
+        && it.plugins.hasPlugin('java')
+        && it.plugins.hasPlugin('maven-publish')
+        && it.tasks.findByName('publishMavenPublicationToMavenRepository')?.enabled
+  }
+  dependencies {
+    constraints {
+      projectsToInclude.each { api it }
+    }
+  }
+}
+
+publishing {
+  publications {
+    maven(MavenPublication) {
+      from components.javaPlatform
+      pom.withXml {
+        def dependencies = asNode().dependencyManagement.dependencies.last()
+        // add protoc gen (produced by grpc-compiler with different artifact name)
+        // not sure how to express "<type>pom</type>" in gradle, kept in XML
+        def dependencyNode = dependencies.appendNode('dependency')
+        dependencyNode.appendNode('groupId', project.group)
+        dependencyNode.appendNode('artifactId', 'protoc-gen-grpc-java')
+        dependencyNode.appendNode('version', project.version)
+        dependencyNode.appendNode('type', 'pom')
+      }
+    }
+  }
+}
diff --git a/build.gradle b/build.gradle
index def381d746e..10a5c5cbbc2 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,322 +1,537 @@
-buildscript {
-  repositories {
-    mavenCentral()
-    mavenLocal()
-  }
-  dependencies {
-    classpath 'com.google.gradle:osdetector-gradle-plugin:1.4.0'
-    classpath "ru.vyarus:gradle-animalsniffer-plugin:1.2.0"
-  }
+plugins {
+    id 'java' // changes the behavior of TARGET_JVM_VERSION_ATTRIBUTE
+
+    id "com.google.osdetector" apply false
+    id "me.champeau.gradle.japicmp" apply false
+    id "net.ltgt.errorprone" apply false
+    id 'com.google.cloud.tools.jib' apply false
 }
 
+import io.grpc.gradle.CheckForUpdatesTask
+import io.grpc.gradle.RequireUpperBoundDepsMatchTask
+import net.ltgt.gradle.errorprone.CheckSeverity
+
 subprojects {
     apply plugin: "checkstyle"
-    apply plugin: "java"
-    apply plugin: "maven"
     apply plugin: "idea"
     apply plugin: "signing"
     apply plugin: "jacoco"
 
     apply plugin: "com.google.osdetector"
-    // The plugin only has an effect if a signature is specified
-    apply plugin: "ru.vyarus.animalsniffer"
+    apply plugin: "net.ltgt.errorprone"
 
     group = "io.grpc"
-    version = "1.2.0-SNAPSHOT" // CURRENT_GRPC_VERSION
-
-    sourceCompatibility = 1.6
-    targetCompatibility = 1.6
+    version = "1.80.0-SNAPSHOT" // CURRENT_GRPC_VERSION
 
     repositories {
-        mavenCentral()
-        mavenLocal()
+        maven { // The google mirror is less flaky than mavenCentral()
+            url = "https://maven-central.storage-download.googleapis.com/maven2/"
+            metadataSources {
+                mavenPom()
+                ignoreGradleMetadataRedirection()
+            }
+        }
+        mavenCentral() {
+            metadataSources {
+                mavenPom()
+                ignoreGradleMetadataRedirection()
+            }
+        }
+        mavenLocal() {
+            metadataSources {
+                mavenPom()
+                ignoreGradleMetadataRedirection()
+            }
+        }
     }
 
-    [compileJava, compileTestJava].each() {
-        it.options.compilerArgs += ["-Xlint:all", "-Xlint:-options"]
+    tasks.withType(JavaCompile).configureEach {
+        it.options.compilerArgs += [
+            "-Xlint:all",
+            "-Xlint:-options",
+            "-Xlint:-path",
+            "-Xlint:-try"
+        ]
         it.options.encoding = "UTF-8"
+        // Avoid Gradle OOM.
+        // https://docs.gradle.org/current/userguide/performance.html#run_the_compiler_as_a_separate_process
+        it.options.fork = true
         if (rootProject.hasProperty('failOnWarnings') && rootProject.failOnWarnings.toBoolean()) {
             it.options.compilerArgs += ["-Werror"]
         }
     }
 
-    compileTestJava {
-      // serialVersionUID is basically guaranteed to be useless in our tests
-      options.compilerArgs += ["-Xlint:-serial"]
+    tasks.withType(GenerateModuleMetadata).configureEach {
+        // Module metadata, introduced in Gradle 6.0, conflicts with our publishing task for
+        // grpc-alts and grpc-compiler.
+        enabled = false
     }
 
-    jar.manifest {
-        attributes('Implementation-Title': name,
-                'Implementation-Version': version,
-                'Built-By': System.getProperty('user.name'),
-                'Built-JDK': System.getProperty('java.version'),
-                'Source-Compatibility': sourceCompatibility,
-                'Target-Compatibility': targetCompatibility)
-    }
-
-    javadoc.options {
-        encoding = 'UTF-8'
-        links 'https://docs.oracle.com/javase/8/docs/api/'
-    }
+    def isAndroid = project.name in [
+            'grpc-android', 'grpc-android-interop-testing', 'grpc-cronet']
 
     ext {
         def exeSuffix = osdetector.os == 'windows' ? ".exe" : ""
         protocPluginBaseName = 'protoc-gen-grpc-java'
         javaPluginPath = "$rootDir/compiler/build/exe/java_plugin/$protocPluginBaseName$exeSuffix"
 
-        guavaVersion = '20.0'
-        protobufVersion = '3.2.0'
-        protobufNanoVersion = '3.0.0-alpha-5'
-
         configureProtoCompilation = {
-          String generatedSourcePath = "${projectDir}/src/generated"
-          if (rootProject.childProjects.containsKey('grpc-compiler')) {
-            // Only when the codegen is built along with the project, will we be able to recompile
-            // the proto files.
-            project.apply plugin: 'com.google.protobuf'
+            String generatedSourcePath = "${projectDir}/src/generated"
             project.protobuf {
-              protoc {
-                if (project.hasProperty('protoc')) {
-                  path = project.protoc
-                } else {
-                  artifact = "com.google.protobuf:protoc:${protobufVersion}"
-                }
-              }
-              plugins {
-                grpc {
-                  path = javaPluginPath
+                protoc {
+                    if (project.hasProperty('protoc')) {
+                        path = project.protoc
+                    } else {
+                        artifact = libs.protobuf.protoc.get()
+                    }
                 }
-              }
-              generateProtoTasks {
-                all().each { task ->
-                  task.dependsOn ':grpc-compiler:java_pluginExecutable'
-                  // Delete the generated sources first, so that we can be alerted if they are not re-compiled.
-                  task.dependsOn 'deleteGeneratedSource' + task.sourceSet.name
-                  // Recompile protos when the codegen has been changed
-                  task.inputs.file javaPluginPath
-                  // Recompile protos when build.gradle has been changed, because
-                  // it's possible the version of protoc has been changed.
-                  task.inputs.file "${rootProject.projectDir}/build.gradle"
-                  task.plugins {
-                    grpc {
-                      // To generate deprecated interfaces and static bindService method,
-                      // turn the enable_deprecated option to true below:
-                      option 'enable_deprecated=false'
+                generateProtoTasks {
+                    all().each { task ->
+                        if (isAndroid) {
+                            task.builtins {
+                                java { option 'lite' }
+                            }
+                        }
                     }
-                  }
                 }
-              }
-              generatedFilesBaseDir = generatedSourcePath
             }
-
-            sourceSets.each { sourceSet ->
-              task "deleteGeneratedSource${sourceSet.name}" << {
-                project.delete project.fileTree(dir: generatedSourcePath + '/' + sourceSet.name)
-              }
-            }
-          } else {
-            // Otherwise, we just use the checked-in generated code.
-            project.sourceSets {
-              main {
-                java {
-                  srcDir "${generatedSourcePath}/main/java"
-                  srcDir "${generatedSourcePath}/main/javanano"
-                  srcDir "${generatedSourcePath}/main/grpc"
+            if (rootProject.childProjects.containsKey('grpc-compiler')) {
+                // Only when the codegen is built along with the project, will we be able to run
+                // the grpc code generator.
+                def syncGeneratedSources = tasks.register("syncGeneratedSources") { }
+                project.protobuf {
+                    plugins { grpc { path = javaPluginPath } }
+                    generateProtoTasks {
+                        all().each { task ->
+                            String variantOrSourceSet = isAndroid ? task.variant.name : task.sourceSet.name
+                            def syncTask = project.tasks.register("syncGeneratedSources${variantOrSourceSet}", Sync) {
+                                from task
+                                into "$generatedSourcePath/$variantOrSourceSet"
+                                include "grpc/"
+                            }
+                            syncGeneratedSources.configure {
+                                dependsOn syncTask
+                            }
+
+                            task.configure {
+                                dependsOn ':grpc-compiler:java_pluginExecutable'
+                                // Recompile protos when the codegen has been changed
+                                inputs.file javaPluginPath
+                                plugins { grpc { option 'noversion' } }
+                                if (isAndroid) {
+                                    plugins {
+                                        grpc {
+                                            option 'lite'
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
-              }
-              test {
-                java {
-                  srcDir "${generatedSourcePath}/test/java"
-                  srcDir "${generatedSourcePath}/test/javanano"
-                  srcDir "${generatedSourcePath}/test/grpc"
+                // Re-sync as part of a normal build, to avoid forgetting to run the sync
+                tasks.named("assemble").configure {
+                    dependsOn syncGeneratedSources
+                }
+            } else {
+                // Otherwise, we just use the checked-in generated code.
+                if (isAndroid) {
+                    project.android.sourceSets {
+                        debug { java { srcDir "${generatedSourcePath}/debug/grpc" } }
+                        release { java { srcDir "${generatedSourcePath}/release/grpc" } }
+                    }
+                } else {
+                    project.sourceSets.each() { sourceSet ->
+                        sourceSet.java { srcDir "${generatedSourcePath}/${sourceSet.name}/grpc" }
+                    }
                 }
-              }
             }
-          }
-
-          [compileJava, compileTestJava].each() {
-            // Protobuf-generated code produces some warnings.
-            it.options.compilerArgs += ["-Xlint:-cast"]
-          }
-        }
-
-        def epoll_suffix = "";
-        if (osdetector.classifier in ["linux-x86_64"]) {
-            // The native code is only pre-compiled on certain platforms.
-            epoll_suffix = ":" + osdetector.classifier
-        }
-        libraries = [
-                errorprone: "com.google.errorprone:error_prone_annotations:2.0.11",
-                guava: "com.google.guava:guava:${guavaVersion}",
-                hpack: 'com.twitter:hpack:0.10.1',
-                jsr305: 'com.google.code.findbugs:jsr305:3.0.0',
-                oauth_client: 'com.google.auth:google-auth-library-oauth2-http:0.4.0',
-                google_auth_credentials: 'com.google.auth:google-auth-library-credentials:0.4.0',
-                okhttp: 'com.squareup.okhttp:okhttp:2.5.0',
-                okio: 'com.squareup.okio:okio:1.6.0',
-                instrumentation_api: 'com.google.instrumentation:instrumentation-api:0.3.0',
-                protobuf: "com.google.protobuf:protobuf-java:${protobufVersion}",
-                // swap to ${protobufVersion} after versions align again
-                protobuf_lite: "com.google.protobuf:protobuf-lite:3.0.1",
-                // swap to ${protobufVersion} after versions align again
-                protoc_lite: "com.google.protobuf:protoc-gen-javalite:3.0.0",
-                protobuf_nano: "com.google.protobuf.nano:protobuf-javanano:${protobufNanoVersion}",
-                protobuf_plugin: 'com.google.protobuf:protobuf-gradle-plugin:0.8.0',
-                protobuf_util: "com.google.protobuf:protobuf-java-util:${protobufVersion}",
-
-                netty: 'io.netty:netty-codec-http2:[4.1.8.Final]',
-                netty_epoll: 'io.netty:netty-transport-native-epoll:4.1.8.Final' + epoll_suffix,
-                netty_proxy_handler: 'io.netty:netty-handler-proxy:4.1.8.Final',
-                netty_tcnative: 'io.netty:netty-tcnative-boringssl-static:1.1.33.Fork26',
-
-                // Test dependencies.
-                junit: 'junit:junit:4.11',
-                mockito: 'org.mockito:mockito-core:1.9.5',
-                truth: 'com.google.truth:truth:0.28',
-
-                // Benchmark dependencies
-                hdrhistogram: 'org.hdrhistogram:HdrHistogram:2.1.8',
-                math: 'org.apache.commons:commons-math3:3.6',
-
-                // Jetty ALPN dependencies
-                jetty_alpn_agent: 'org.mortbay.jetty.alpn:jetty-alpn-agent:2.0.3'
-        ]
-    }
 
-    // Define a separate configuration for managing the dependency on Jetty ALPN agent.
-    configurations {
-        alpnagent
-        tcnative
-    }
-
-    dependencies {
-        testCompile libraries.junit,
-                    libraries.mockito
-
-        // Configuration for modules that use Jetty ALPN agent
-        alpnagent libraries.jetty_alpn_agent
+            tasks.withType(JavaCompile).configureEach {
+                appendToProperty(
+                    it.options.errorprone.excludedPaths,
+                    ".*/src/generated/[^/]+/java/.*" +
+                        "|.*/build/generated/sources/proto/[^/]+/java/.*",
+                    "|")
+            }
+        }
 
-        // Configuration for modules that use Netty tcnative (for OpenSSL).
-        tcnative libraries.netty_tcnative
-    }
+        libraries = libs
 
-    signing {
-        required false
-        sign configurations.archives
+        appendToProperty = { Property<String> property, String value, String separator ->
+            if (property.present) {
+                property.set(property.get() + separator + value)
+            } else {
+                property.set(value)
+            }
+        }
     }
 
     // Disable JavaDoc doclint on Java 8. It's annoying.
     if (JavaVersion.current().isJava8Compatible()) {
-      allprojects {
-        tasks.withType(Javadoc) {
-          options.addStringOption('Xdoclint:none', '-quiet')
+        allprojects {
+            tasks.withType(Javadoc).configureEach {
+                options.addStringOption('Xdoclint:none', '-quiet')
+            }
         }
-      }
     }
 
     checkstyle {
-        configFile = file("$rootDir/checkstyle.xml")
-        toolVersion = "6.17"
+        configDirectory = file("$rootDir/buildscripts")
+        toolVersion = JavaVersion.current().isJava11Compatible() ? libs.checkstyle.get().version : libs.checkstylejava8.get().version 
+
         ignoreFailures = false
         if (rootProject.hasProperty("checkstyle.ignoreFailures")) {
             ignoreFailures = rootProject.properties["checkstyle.ignoreFailures"].toBoolean()
         }
-        configProperties["rootDir"] = rootDir
     }
 
-    checkstyleMain {
-        source = fileTree(dir: "src/main", include: "**/*.java")
+    if (!project.hasProperty('errorProne') || errorProne.toBoolean()) {
+        dependencies {
+            errorprone JavaVersion.current().isJava11Compatible() ? libs.errorprone.core : libs.errorprone.corejava8
+        }
+    } else {
+        // Disable Error Prone
+        tasks.withType(JavaCompile).configureEach {
+            options.errorprone.enabled = false
+        }
     }
 
-    checkstyleTest {
-        source = fileTree(dir: "src/test", include: "**/*.java")
+    plugins.withId("com.android.base") {
+        android {
+            lint {
+                abortOnError true
+                if (rootProject.hasProperty('failOnWarnings') && rootProject.failOnWarnings.toBoolean()) {
+                    warningsAsErrors true
+                }
+            }
+        }
+        tasks.withType(JavaCompile).configureEach {
+            it.options.compilerArgs += [
+                    "-Xlint:all"
+            ]
+            if (rootProject.hasProperty('failOnWarnings') && rootProject.failOnWarnings.toBoolean()) {
+                it.options.compilerArgs += ["-Werror"]
+            }
+        }
     }
 
-    task javadocJar(type: Jar) {
-        classifier = 'javadoc'
-        from javadoc
+    plugins.withId("java") {
+        dependencies {
+            testImplementation libraries.junit,
+                    libraries.mockito.core,
+                    libraries.truth
+        }
+
+        tasks.named("compileTestJava").configure {
+            // serialVersionUID is basically guaranteed to be useless in our tests
+            options.compilerArgs += [
+                "-Xlint:-serial"
+            ]
+        }
+
+        tasks.named("jar").configure {
+            manifest {
+                attributes('Implementation-Title': name,
+                        'Implementation-Version': project.version)
+            }
+        }
+
+        tasks.named("javadoc").configure {
+            options {
+                encoding = 'UTF-8'
+                use = true
+                linksOffline 'https://docs.oracle.com/javase/8/docs/api/',
+		    "${rootProject.projectDir}/gradle/javadoc/docs.oracle.com-javase-8-docs-api/"
+                source = "8"
+            }
+        }
+
+        tasks.named("checkstyleMain").configure {
+            source = fileTree(dir: "$projectDir/src/main", include: "**/*.java")
+        }
+
+        tasks.named("checkstyleTest").configure {
+            source = fileTree(dir: "$projectDir/src/test", include: "**/*.java")
+        }
+
+        // At a test failure, log the stack trace to the console so that we don't
+        // have to open the HTML in a browser.
+        tasks.withType(Test).configureEach {
+            testLogging {
+                exceptionFormat = 'full'
+                showExceptions = true
+                showCauses = true
+                showStackTraces = true
+            }
+            maxHeapSize = '1500m'
+        }
+
+        if (!project.hasProperty('errorProne') || errorProne.toBoolean()) {
+            dependencies {
+                annotationProcessor libs.guava.betaChecker
+            }
+        }
+
+        tasks.withType(JavaCompile).configureEach {
+            if (JavaVersion.current().isJava9Compatible()) {
+                options.release = 8
+            } else {
+                sourceCompatibility = JavaVersion.VERSION_1_8
+                targetCompatibility = JavaVersion.VERSION_1_8
+            }
+        }
+        tasks.named("compileJava").configure {
+            // This project targets Java 7 (no time.Duration class)
+            options.errorprone.check("PreferJavaTimeOverload", CheckSeverity.OFF)
+            options.errorprone.check("JavaUtilDate", CheckSeverity.OFF)
+            // The warning fails to provide a source location
+            options.errorprone.check("MissingSummary", CheckSeverity.OFF)
+
+            // This check is in libs.errorprone.corejava8 but has been removed
+            // in later versions. It isn't smart enough to realize the field is
+            // actually immutable. And it also doesn't complain about arrays
+            // that are actually mutable.
+            options.errorprone.check("MutableConstantField", CheckSeverity.OFF)
+        }
+        tasks.named("compileTestJava").configure {
+            // LinkedList doesn't hurt much in tests and has lots of usages
+            options.errorprone.check("JdkObsolete", CheckSeverity.OFF)
+            options.errorprone.check("PreferJavaTimeOverload", CheckSeverity.OFF)
+            options.errorprone.check("JavaUtilDate", CheckSeverity.OFF)
+
+            // This check is in libs.errorprone.corejava8 but has been removed
+            // in later versions. It isn't smart enough to realize the field is
+            // actually immutable. And it also doesn't complain about arrays
+            // that are actually mutable.
+            options.errorprone.check("MutableConstantField", CheckSeverity.OFF)
+        }
+
+        plugins.withId("ru.vyarus.animalsniffer") {
+	    // Only available after java plugin has loaded
+            animalsniffer {
+                toolVersion = libs.animalsniffer.asProvider().get().version
+            }
+        }
     }
 
-    task sourcesJar(type: Jar) {
-        classifier = 'sources'
-        from sourceSets.main.allSource
+    plugins.withId("java-library") {
+        // Detect Maven Enforcer's dependencyConvergence failures. We only care
+        // for artifacts used as libraries by others with Maven.
+        tasks.register('checkUpperBoundDeps', RequireUpperBoundDepsMatchTask) {
+            configuration = configurations.getByName('runtimeClasspath')
+        }
+        tasks.named('assemble').configure {
+            dependsOn tasks.named('checkUpperBoundDeps')
+        }
     }
 
-    artifacts {
-        archives javadocJar, sourcesJar
+    plugins.withId("me.champeau.jmh") {
+        // invoke jmh on a single benchmark class like so:
+        //   ./gradlew -PjmhIncludeSingleClass=StatsTraceContextBenchmark clean :grpc-core:jmh
+        tasks.named("jmh").configure {
+            warmupIterations = 10
+            iterations = 10
+            fork = 1
+            // None of our benchmarks need the tests, and we have pseudo-circular
+            // dependencies that break when including them. (context's testCompile
+            // depends on core; core's testCompile depends on testing)
+            includeTests = false
+            if (project.hasProperty('jmhIncludeSingleClass')) {
+                includes = [
+                    project.property('jmhIncludeSingleClass')
+                ]
+            }
+        }
     }
 
-    uploadArchives.repositories.mavenDeployer {
-        beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }
-        String stagingUrl
-        if (rootProject.hasProperty('repositoryId')) {
-          stagingUrl = 'https://oss.sonatype.org/service/local/staging/deployByRepositoryId/' +
-              rootProject.repositoryId
-        } else {
-          stagingUrl = 'https://oss.sonatype.org/service/local/staging/deploy/maven2/'
-        }
-        def configureAuth = {
-          if (rootProject.hasProperty('ossrhUsername') && rootProject.hasProperty('ossrhPassword')) {
-            authentication(userName: rootProject.ossrhUsername, password: rootProject.ossrhPassword)
-          }
-        }
-        repository(url: stagingUrl, configureAuth)
-        snapshotRepository(url: 'https://oss.sonatype.org/content/repositories/snapshots/', configureAuth)
+    plugins.withId("com.gradleup.shadow") {
+        tasks.named("shadowJar").configure {
+            // Do a dance to remove Class-Path. This needs to run after the doFirst() from the
+            // shadow plugin that adds Class-Path and before the core jar action. Using doFirst will
+            // have this run before the shadow plugin, and doLast will run after the core jar
+            // action. See #8606.
+            // The shadow plugin adds another doFirst when application is used for setting
+            // Main-Class. Ordering with it doesn't matter.
+            actions.add(plugins.hasPlugin("application") ? 2 : 1, new Action<Task>() {
+                @Override public void execute(Task task) {
+                    if (!task.manifest.attributes.remove("Class-Path")) {
+                        throw new AssertionError("Did not find Class-Path to remove from manifest")
+                    }
+                }
+            })
+        }
     }
-    uploadArchives.onlyIf { !name.contains("thrift") }
-
-    [
-      install.repositories.mavenInstaller,
-      uploadArchives.repositories.mavenDeployer,
-    ]*.pom*.whenConfigured { pom ->
-        pom.project {
-            name "$project.group:$project.name"
-            description project.description
-            url 'https://github.com/grpc/grpc-java'
-
-            scm {
-                connection 'scm:git:https://github.com/grpc/grpc-java.git'
-                developerConnection 'scm:git:git@github.com:grpc/grpc-java.git'
-                url 'https://github.com/grpc/grpc-java'
-            }
 
-            licenses {
-                license {
-                    name 'BSD 3-Clause'
-                    url 'http://opensource.org/licenses/BSD-3-Clause'
+    plugins.withId("maven-publish") {
+        publishing {
+            publications {
+                // do not use mavenJava, as java plugin will modify it via "magic"
+                maven(MavenPublication) {
+                    pom {
+                        name = project.group + ":" + project.name
+                        url = 'https://github.com/grpc/grpc-java'
+                        afterEvaluate {
+                            // description is not available until evaluated.
+                            description = project.description
+                        }
+
+                        scm {
+                            connection = 'scm:git:https://github.com/grpc/grpc-java.git'
+                            developerConnection = 'scm:git:git@github.com:grpc/grpc-java.git'
+                            url = 'https://github.com/grpc/grpc-java'
+                        }
+
+                        licenses {
+                            license {
+                                name = 'Apache 2.0'
+                                url = 'https://opensource.org/licenses/Apache-2.0'
+                            }
+                        }
+
+                        developers {
+                            developer {
+                                id = "grpc.io"
+                                name = "gRPC Contributors"
+                                email = "grpc-io@googlegroups.com"
+                                url = "https://grpc.io/"
+                                organization = "gRPC Authors"
+                                organizationUrl = "https://www.google.com"
+                            }
+                        }
+                    }
+                }
+            }
+            repositories {
+                maven {
+                    if (rootProject.hasProperty('repositoryDir')) {
+                        url = new File(rootProject.repositoryDir).toURI()
+                    } else {
+                        String stagingUrl
+                        String baseUrl = "https://ossrh-staging-api.central.sonatype.com/service/local"
+                        if (rootProject.hasProperty('repositoryId')) {
+                            stagingUrl = "${baseUrl}/staging/deployByRepositoryId/" + rootProject.repositoryId
+                        } else {
+                            stagingUrl = "${baseUrl}/staging/deploy/maven2/"
+                        }
+                        credentials {
+                            if (rootProject.hasProperty('ossrhUsername') && rootProject.hasProperty('ossrhPassword')) {
+                                username = rootProject.ossrhUsername
+                                password = rootProject.ossrhPassword
+                            }
+                        }
+                        def releaseUrl = stagingUrl
+                        def snapshotUrl = 'https://central.sonatype.com/repository/maven-snapshots/'
+                        url = version.endsWith('SNAPSHOT') ? snapshotUrl : releaseUrl
+                    }
                 }
             }
+        }
+
+        signing {
+            required = false
+            sign publishing.publications.maven
+        }
+
+        plugins.withId("java") {
+            java {
+                withJavadocJar()
+                withSourcesJar()
+            }
 
-            developers {
-                developer {
-                    id "grpc.io"
-                    name "gRPC Contributors"
-                    email "grpc-io@googlegroups.com"
-                    url "http://grpc.io/"
-                    // https://issues.gradle.org/browse/GRADLE-2719
-                    organization = "Google, Inc."
-                    organizationUrl "https://www.google.com"
+            publishing {
+                publications {
+                    maven {
+                        if (project.name != 'grpc-netty-shaded') {
+                            from components.java
+                        }
+                    }
                 }
             }
         }
-        if (!(project.name in
-            ["grpc-stub", "grpc-protobuf", "grpc-protobuf-lite", "grpc-protobuf-nano", "grpc-thrift"])) {
-          def core = pom.dependencies.find {dep -> dep.artifactId == 'grpc-core'}
-          if (core != null) {
-            // Depend on specific version of grpc-core because internal package is unstable
-            core.version = "[" + core.version + "]"
-          }
+    }
+
+    // Run with: ./gradlew japicmp --continue
+    plugins.withId("me.champeau.gradle.japicmp") {
+        def baselineGrpcVersion = '1.6.1'
+
+        // Get the baseline version's jar for this subproject
+        configurations {
+            baselineArtifact
+        }
+        // A necessary hack, the intuitive thing does NOT work:
+        // https://discuss.gradle.org/t/is-the-default-configuration-leaking-into-independent-configurations/2088/6
+        def oldGroup = project.group
+        try {
+            project.group = 'virtual_group_for_japicmp'
+            dependencies {
+                baselineArtifact "io.grpc:${project.name}:${baselineGrpcVersion}@jar"
+            }
+        } finally {
+            project.group = oldGroup
+        }
+
+        // Add a japicmp task that compares the current .jar with baseline .jar
+        tasks.register("japicmp", me.champeau.gradle.japicmp.JapicmpTask) {
+            oldClasspath.from configurations.baselineArtifact
+            newClasspath.from tasks.named("jar")
+            onlyBinaryIncompatibleModified = false
+            // Be quiet about things that did not change
+            onlyModified = true
+            // This task should fail if there are incompatible changes
+            failOnModification = true
+            ignoreMissingClasses = true
+            htmlOutputFile = file("$buildDir/reports/japi.html")
+
+            packageExcludes = ['io.grpc.internal']
+
+            // Also break on source incompatible changes, not just binary.
+            // Eg adding abstract method to public class.
+            failOnSourceIncompatibility = true
+
+            // Ignore any classes or methods marked @ExperimentalApi
+            annotationExcludes = ['@io.grpc.ExperimentalApi']
         }
     }
-    // At a test failure, log the stack trace to the console so that we don't
-    // have to open the HTML in a browser.
-    test {
-        testLogging {
-            exceptionFormat = 'full'
-            showExceptions true
-            showCauses true
-            showStackTraces true
-        }
-        maxHeapSize = '1500m'
+}
+
+repositories {
+    mavenCentral()
+    google()
+}
+
+def isAcceptableVersion(ModuleComponentIdentifier candidate) {
+    String group = candidate.group
+    String module = candidate.module
+    String version = candidate.version
+    if (group == 'com.google.guava')
+        return true
+    if (group == 'io.netty' && version.contains('Final'))
+        return true
+    if (group == 'io.undertow' && version.contains('Final'))
+        return true
+    if (module == 'android-api-level-19')
+        return true
+    if (module == 'opentelemetry-exporter-prometheus')
+        return true
+    if (module == 'opentelemetry-gcp-resources')
+        return true
+    return version ==~ /^[0-9]+(\.[0-9]+)+$/
+}
+
+configurations {
+    checkForUpdates {
+        attributes.attribute(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE, 8)
+        resolutionStrategy {
+            componentSelection {
+                all {
+                    if (!isAcceptableVersion(it.candidate))
+                        it.reject("Not stable version")
+                }
+            }
+        }
     }
 }
+
+tasks.register('checkForUpdates', CheckForUpdatesTask, project.configurations.checkForUpdates, "libs", layout.projectDirectory.file("gradle/libs.versions.toml"))
+
diff --git a/buildSrc/build.gradle b/buildSrc/build.gradle
new file mode 100644
index 00000000000..3f79d30293f
--- /dev/null
+++ b/buildSrc/build.gradle
@@ -0,0 +1,5 @@
+tasks.withType(JavaCompile).configureEach {
+    it.options.compilerArgs += [
+        "-Xlint:all",
+    ]
+}
diff --git a/buildSrc/src/main/java/io/grpc/gradle/CheckForUpdatesTask.java b/buildSrc/src/main/java/io/grpc/gradle/CheckForUpdatesTask.java
new file mode 100644
index 00000000000..b7c28dbbb2d
--- /dev/null
+++ b/buildSrc/src/main/java/io/grpc/gradle/CheckForUpdatesTask.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright 2023 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.gradle;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.inject.Inject;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.artifacts.ModuleVersionIdentifier;
+import org.gradle.api.artifacts.VersionCatalog;
+import org.gradle.api.artifacts.VersionCatalogsExtension;
+import org.gradle.api.artifacts.result.DependencyResult;
+import org.gradle.api.artifacts.result.ResolvedComponentResult;
+import org.gradle.api.artifacts.result.ResolvedDependencyResult;
+import org.gradle.api.artifacts.result.UnresolvedDependencyResult;
+import org.gradle.api.file.RegularFile;
+import org.gradle.api.provider.Provider;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.Nested;
+import org.gradle.api.tasks.TaskAction;
+
+/**
+ * Checks every dependency in the version catalog to see if there is a newer version available. The
+ * passed configuration restricts the versions considered.
+ */
+public abstract class CheckForUpdatesTask extends DefaultTask {
+  private final Set<Library> libraries;
+
+  @Inject
+  public CheckForUpdatesTask(Configuration updateConf, String catalog, RegularFile commentFile)
+      throws IOException {
+    // Check for overrides to the default version selection ('+'), using comments of the form:
+    // # checkForUpdates: library-name:1.2.+
+    List<String> fileComments = Files.lines(commentFile.getAsFile().toPath())
+        .filter(l -> l.matches("# *checkForUpdates:.*"))
+        .map(l -> l.replaceFirst("# *checkForUpdates:", "").trim())
+        .collect(Collectors.toList());
+    Map<String, String> aliasToVersionSelector = new HashMap<>(2*fileComments.size());
+    for (String comment : fileComments) {
+      String[] parts = comment.split(":", 2);
+      String name = parts[0].replaceAll("[_-]", ".");
+      if (aliasToVersionSelector.put(name, parts[1]) != null) {
+        throw new RuntimeException("Duplicate checkForUpdates comment for library: " + name);
+      }
+    }
+
+    updateConf.setVisible(false);
+    updateConf.setTransitive(false);
+    VersionCatalog versionCatalog = getProject().getExtensions().getByType(VersionCatalogsExtension.class).named(catalog);
+    Set<Library> libraries = new LinkedHashSet<Library>();
+    for (String name : versionCatalog.getLibraryAliases()) {
+      org.gradle.api.artifacts.MinimalExternalModuleDependency dep = versionCatalog.findLibrary(name).get().get();
+
+      Configuration oldConf = updateConf.copy();
+      Dependency oldDep = getProject().getDependencies().create(
+          depMap(dep.getGroup(), dep.getName(), dep.getVersionConstraint().toString(), "pom"));
+      oldConf.getDependencies().add(oldDep);
+
+      Configuration newConf = updateConf.copy();
+      String versionSelector = aliasToVersionSelector.remove(name);
+      if (versionSelector == null) {
+        versionSelector = "+";
+      }
+      Dependency newDep = getProject().getDependencies().create(
+          depMap(dep.getGroup(), dep.getName(), versionSelector, "pom"));
+      newConf.getDependencies().add(newDep);
+
+      libraries.add(new Library(
+          name,
+          oldConf.getIncoming().getResolutionResult().getRootComponent(),
+          newConf.getIncoming().getResolutionResult().getRootComponent()));
+    }
+    if (!aliasToVersionSelector.isEmpty()) {
+      throw new RuntimeException(
+          "Unused checkForUpdates comments: " + aliasToVersionSelector.keySet());
+    }
+    this.libraries = Collections.unmodifiableSet(libraries);
+  }
+
+  private static Map<String, String> depMap(
+      String group, String name, String version, String classifier) {
+    Map<String, String> map = new HashMap<>();
+    map.put("group", group);
+    map.put("name", name);
+    map.put("version", version);
+    map.put("classifier", classifier);
+    return map;
+  }
+
+  @Nested
+  protected Set<Library> getLibraries() {
+    return libraries;
+  }
+
+  @TaskAction
+  public void checkForUpdates() {
+    for (Library lib : libraries) {
+      String name = lib.getName();
+      DependencyResult oldResult = lib.getOldResult().get().getDependencies().iterator().next();
+      if (oldResult instanceof UnresolvedDependencyResult) {
+        System.out.println(String.format(
+            "- Current version of libs.%s not resolved", name));
+        continue;
+      }
+      DependencyResult newResult = lib.getNewResult().get().getDependencies().iterator().next();
+      if (newResult instanceof UnresolvedDependencyResult) {
+        System.out.println(String.format(
+            "- New version of libs.%s not resolved", name));
+        continue;
+      }
+      ModuleVersionIdentifier oldId =
+          ((ResolvedDependencyResult) oldResult).getSelected().getModuleVersion();
+      ModuleVersionIdentifier newId =
+          ((ResolvedDependencyResult) newResult).getSelected().getModuleVersion();
+      if (oldId != newId) {
+        System.out.println(String.format(
+            "libs.%s = %s %s -> %s",
+            name, newId.getModule(), oldId.getVersion(), newId.getVersion()));
+      }
+    }
+  }
+
+  public static final class Library {
+    private final String name;
+    private final Provider<ResolvedComponentResult> oldResult;
+    private final Provider<ResolvedComponentResult> newResult;
+
+    public Library(
+        String name, Provider<ResolvedComponentResult> oldResult,
+        Provider<ResolvedComponentResult> newResult) {
+      this.name = name;
+      this.oldResult = oldResult;
+      this.newResult = newResult;
+    }
+
+    @Input
+    public String getName() {
+      return name;
+    }
+
+    @Input
+    public Provider<ResolvedComponentResult> getOldResult() {
+      return oldResult;
+    }
+
+    @Input
+    public Provider<ResolvedComponentResult> getNewResult() {
+      return newResult;
+    }
+  }
+}
diff --git a/buildSrc/src/main/java/io/grpc/gradle/CheckPackageLeakageTask.java b/buildSrc/src/main/java/io/grpc/gradle/CheckPackageLeakageTask.java
new file mode 100644
index 00000000000..1a3cf1fe0b6
--- /dev/null
+++ b/buildSrc/src/main/java/io/grpc/gradle/CheckPackageLeakageTask.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2023 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.gradle;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Enumeration;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.file.ConfigurableFileCollection;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.Classpath;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.TaskAction;
+import org.gradle.api.tasks.TaskExecutionException;
+
+/** Verifies all class files within jar files are in a specified Java package. */
+public abstract class CheckPackageLeakageTask extends DefaultTask {
+  public CheckPackageLeakageTask() {
+    // Fake output for UP-TO-DATE checking
+    getOutputs().file(getProject().getLayout().getBuildDirectory().file("tmp/" + getName()));
+  }
+
+  @Classpath
+  abstract ConfigurableFileCollection getFiles();
+
+  @Input
+  abstract Property<String> getPrefix();
+
+  @TaskAction
+  public void checkLeakage() throws IOException {
+    String jarEntryPrefixName = getPrefix().get().replace('.', '/');
+    boolean packageLeakDetected = false;
+    for (File jar : getFiles()) {
+      try (JarFile jf = new JarFile(jar)) {
+        for (Enumeration<JarEntry> e = jf.entries(); e.hasMoreElements(); ) {
+          JarEntry entry = e.nextElement();
+          if (entry.getName().endsWith(".class")
+              && !entry.getName().startsWith(jarEntryPrefixName)) {
+            packageLeakDetected = true;
+            System.out.println("WARNING: package leaked, may need relocation: " + entry.getName());
+          }
+        }
+      }
+    }
+    if (packageLeakDetected) {
+      throw new TaskExecutionException(this,
+          new IllegalStateException("Resource leakage detected!"));
+    }
+  }
+}
diff --git a/buildSrc/src/main/java/io/grpc/gradle/RequireUpperBoundDepsMatchTask.java b/buildSrc/src/main/java/io/grpc/gradle/RequireUpperBoundDepsMatchTask.java
new file mode 100644
index 00000000000..80d8f7bcb14
--- /dev/null
+++ b/buildSrc/src/main/java/io/grpc/gradle/RequireUpperBoundDepsMatchTask.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright 2023 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.gradle;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Queue;
+import java.util.Set;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.artifacts.ModuleVersionIdentifier;
+import org.gradle.api.artifacts.component.ModuleComponentSelector;
+import org.gradle.api.artifacts.component.ProjectComponentSelector;
+import org.gradle.api.artifacts.result.DependencyResult;
+import org.gradle.api.artifacts.result.ResolvedComponentResult;
+import org.gradle.api.artifacts.result.ResolvedDependencyResult;
+import org.gradle.api.attributes.Attribute;
+import org.gradle.api.attributes.Category;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.TaskAction;
+
+/**
+ * Verifies that Maven would select the same versions as Gradle selected. This is essentially the
+ * same as if we used Maven Enforcer's requireUpperBoundDeps in a Maven build. Gradle selects the
+ * upperBound, so if Maven selects a different version there is a downgrade.
+ */
+public abstract class RequireUpperBoundDepsMatchTask extends DefaultTask {
+  private final String projectPath;
+  private final String projectVersion;
+
+  public RequireUpperBoundDepsMatchTask() {
+    projectPath = getProject().getPath();
+    projectVersion = getProject().getVersion().toString();
+
+    // Fake output for UP-TO-DATE checking
+    getOutputs().file(getProject().getLayout().getBuildDirectory().file("tmp/" + getName()));
+  }
+
+  public void setConfiguration(Configuration conf) {
+    getConfigurationName().set(conf.getName());
+    getRoot().set(conf.getIncoming().getResolutionResult().getRootComponent());
+  }
+
+  @Input
+  abstract Property<String> getConfigurationName();
+
+  @Input
+  abstract Property<ResolvedComponentResult> getRoot();
+
+  @TaskAction
+  public void checkDeps() {
+    // Category.CATEGORY_ATTRIBUTE is the inappropriate Attribute because it is "desugared".
+    // https://github.com/gradle/gradle/issues/8854
+    Attribute<String> category = Attribute.of("org.gradle.category", String.class);
+
+    // Breadth-first search like Maven for dependency resolution. Check and Maven and Gradle would
+    // select the same version.
+    Queue<DepAndParents> queue = new ArrayDeque<>();
+    for (DependencyResult dep : getRoot().get().getDependencies()) {
+      queue.add(new DepAndParents(dep, null, projectPath));
+    }
+    Set<String> found = new HashSet<>();
+    while (!queue.isEmpty()) {
+      DepAndParents depAndParents = queue.remove();
+      ResolvedDependencyResult result = (ResolvedDependencyResult) depAndParents.dep;
+      // Only libraries are "deps" in the typical sense, and non-libraries might not have versions.
+      if (result.getResolvedVariant().getAttributes().getAttribute(category)
+          != Category.LIBRARY)
+        return;
+
+      ModuleVersionIdentifier id = result.getSelected().getModuleVersion();
+      String artifact = id.getGroup() + ":" + id.getName();
+      if (found.contains(artifact))
+        continue;
+      found.add(artifact);
+      String mavenVersion;
+      if (result.getRequested() instanceof ProjectComponentSelector) {
+        // Assume all projects use the same version.
+        mavenVersion = projectVersion;
+      } else {
+        mavenVersion = ((ModuleComponentSelector) result.getRequested()).getVersion();
+      }
+      String gradleVersion = id.getVersion();
+      if (!mavenVersion.equals(gradleVersion) && !mavenVersion.equals("[" + gradleVersion + "]")) {
+        throw new RuntimeException(String.format(
+            "Maven version skew: %s (%s != %s) Bad version dependency path: %s"
+            + " Run './gradlew %s:dependencies --configuration %s' to diagnose",
+            artifact, mavenVersion, gradleVersion, depAndParents.getParents(),
+            projectPath, getConfigurationName().get()));
+      }
+      for (DependencyResult dep : result.getSelected().getDependencies()) {
+        queue.add(new DepAndParents(dep, depAndParents, artifact + ":" + mavenVersion));
+      }
+    }
+  }
+
+  static final class DepAndParents {
+    final DependencyResult dep;
+    final DepAndParents parent;
+    final String parentName;
+
+    public DepAndParents(DependencyResult dep, DepAndParents parent, String parentName) {
+      this.dep = dep;
+      this.parent = parent;
+      this.parentName = parentName;
+    }
+
+    public List<String> getParents() {
+      List<String> parents = new ArrayList<>();
+      DepAndParents element = this;
+      while (element != null) {
+        parents.add(element.parentName);
+        element = element.parent;
+      }
+      Collections.reverse(parents);
+      return parents;
+    }
+  }
+}
diff --git a/buildscripts/build_artifacts_in_docker.sh b/buildscripts/build_artifacts_in_docker.sh
new file mode 100755
index 00000000000..0a872853f06
--- /dev/null
+++ b/buildscripts/build_artifacts_in_docker.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+set -exu -o pipefail
+
+# Runs all the tests and builds mvn artifacts.
+# mvn artifacts are stored in grpc-java/mvn-artifacts/
+ALL_ARTIFACTS=true ARCH=x86_64 "$(dirname $0)"/kokoro/unix.sh
+# Already ran tests the first time, so skip tests this time
+SKIP_TESTS=true ARCH=x86_32 "$(dirname $0)"/kokoro/unix.sh
diff --git a/buildscripts/build_docker.sh b/buildscripts/build_docker.sh
new file mode 100755
index 00000000000..b34f9a6e542
--- /dev/null
+++ b/buildscripts/build_docker.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+set -eu -o pipefail
+
+readonly buildscripts_dir="$(dirname "$(readlink -f "$0")")"
+docker build -t grpc-java-artifacts-x86 "$buildscripts_dir"/grpc-java-artifacts
+docker build -t grpc-java-artifacts-multiarch -f "$buildscripts_dir"/grpc-java-artifacts/Dockerfile.multiarch.base "$buildscripts_dir"/grpc-java-artifacts
+docker build -t grpc-java-artifacts-ubuntu2004 -f "$buildscripts_dir"/grpc-java-artifacts/Dockerfile.ubuntu2004.base "$buildscripts_dir"/grpc-java-artifacts
+
diff --git a/buildscripts/checkstyle.license b/buildscripts/checkstyle.license
new file mode 100644
index 00000000000..cef19a39852
--- /dev/null
+++ b/buildscripts/checkstyle.license
@@ -0,0 +1,16 @@
+/*
+ * Copyright 2015 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.
+ */
+
diff --git a/checkstyle.xml b/buildscripts/checkstyle.xml
similarity index 93%
rename from checkstyle.xml
rename to buildscripts/checkstyle.xml
index 4da20ac87ca..0ec8ecc79ce 100644
--- a/checkstyle.xml
+++ b/buildscripts/checkstyle.xml
@@ -21,7 +21,7 @@
     <property name="severity" value="error"/>
 
     <module name="Header">
-      <property name="headerFile" value="${rootDir}/checkstyle.license"/>
+      <property name="headerFile" value="${config_loc}/checkstyle.license"/>
       <property name="ignoreLines" value="2"/>
       <property name="fileExtensions" value="java"/>
     </module>
@@ -33,6 +33,17 @@
             <property name="eachLine" value="true"/>
         </module>
 
+    <module name="LineLength">
+        <property name="max" value="100"/>
+        <property name="ignorePattern" value="^package.*|^import.*|a href|href|http://|https://|ftp://"/>
+    </module>
+
+    <module name="SuppressionSingleFilter">
+        <!-- Prefer using the same name as in Animal Sniffer -->
+        <property name="checks" value="AbbreviationAsWordInName"/>
+        <property name="files" value="IgnoreJRERequirement.java"/>
+    </module>
+
     <module name="TreeWalker">
         <module name="OuterTypeFilename"/>
         <module name="IllegalTokenText">
@@ -45,10 +56,6 @@
             <property name="allowByTailComment" value="true"/>
             <property name="allowNonPrintableEscapes" value="true"/>
         </module>
-        <module name="LineLength">
-            <property name="max" value="100"/>
-            <property name="ignorePattern" value="^package.*|^import.*|a href|href|http://|https://|ftp://"/>
-        </module>
         <module name="AvoidStarImport"/>
         <!-- TODO(ejona): Upstream? -->
         <module name="UnusedImports"/>
@@ -59,12 +66,8 @@
             <property name="tokens" value="LITERAL_TRY, LITERAL_FINALLY, LITERAL_IF, LITERAL_ELSE, LITERAL_SWITCH"/>
         </module>
         <module name="NeedBraces"/>
-        <module name="LeftCurly">
-            <property name="maxLineLength" value="100"/>
-        </module>
-        <module name="RightCurly"/>
+        <module name="LeftCurly"/>
         <module name="RightCurly">
-            <property name="option" value="alone"/>
             <property name="tokens" value="CLASS_DEF, METHOD_DEF, CTOR_DEF, LITERAL_FOR, LITERAL_WHILE, LITERAL_DO, STATIC_INIT, INSTANCE_INIT"/>
         </module>
         <module name="WhitespaceAround">
@@ -202,15 +205,12 @@
             <property name="target" value="CLASS_DEF, INTERFACE_DEF, ENUM_DEF, METHOD_DEF, CTOR_DEF, VARIABLE_DEF"/>
         </module>
         <module name="JavadocMethod">
-            <property name="scope" value="public"/>
+            <property name="accessModifiers" value="public"/>
             <property name="allowMissingParamTags" value="true"/>
-            <property name="allowMissingThrowsTags" value="true"/>
             <property name="allowMissingReturnTag" value="true"/>
-            <property name="minLineCount" value="2"/>
-            <!-- TOOD(ejona): Too restrictive for tests
+            <!-- TODO(ejona): Too restrictive for tests
             <property name="allowedAnnotations" value="Override, Test"/-->
             <property name="allowedAnnotations" value="Override, Test, Before, After, BeforeClass, AfterClass, Setup, TearDown"/>
-            <property name="allowThrowsTagsForSubclasses" value="true"/>
         </module>
         <module name="MethodName">
             <property name="format" value="^[a-z][a-z0-9][a-zA-Z0-9_]*$"/>
diff --git a/buildscripts/cloudbuild-testing.yaml b/buildscripts/cloudbuild-testing.yaml
new file mode 100644
index 00000000000..623b85b6882
--- /dev/null
+++ b/buildscripts/cloudbuild-testing.yaml
@@ -0,0 +1,64 @@
+substitutions:
+  _GAE_SERVICE_ACCOUNT: appengine-testing-java@grpc-testing.iam.gserviceaccount.com
+options:
+  env:
+  - BUILD_ID=$BUILD_ID
+  - KOKORO_GAE_SERVICE=java-gae-interop-test
+  - DUMMY_DEFAULT_VERSION=dummy-default
+  - GRADLE_OPTS=-Dorg.gradle.jvmargs='-Xmx1g'
+  - GRADLE_FLAGS=-PskipCodegen=true -PskipAndroid=true
+  logging: CLOUD_LOGGING_ONLY
+  machineType: E2_HIGHCPU_8
+
+steps:
+- id: clean-stale-deploys
+  name: gcr.io/cloud-builders/gcloud
+  allowFailure: true
+  script: |
+    #!/usr/bin/env bash
+    set -e
+    echo "Cleaning out stale deploys from previous runs, it is ok if this part fails"
+    # If the test fails, the deployment is leaked.
+    # Delete all versions whose name is not 'dummy-default' and is older than 1 hour.
+    # This expression is an ISO8601 relative date:
+    # https://cloud.google.com/sdk/gcloud/reference/topic/datetimes
+    (gcloud app versions list --format="get(version.id)" \
+        --filter="service=$KOKORO_GAE_SERVICE AND NOT version : '$DUMMY_DEFAULT_VERSION' AND version.createTime<'-p1h'" \
+        | xargs -i gcloud app services delete "$KOKORO_GAE_SERVICE" --version {} --quiet) || true
+
+- name: gcr.io/cloud-builders/docker
+  args: ['build', '-t', 'gae-build', 'buildscripts/gae-build/']
+
+- id: build
+  name: gae-build
+  script: |
+    #!/usr/bin/env bash
+    exec ./gradlew $GRADLE_FLAGS :grpc-gae-interop-testing-jdk8:appengineStage
+
+- id: deploy
+  name: gcr.io/cloud-builders/gcloud
+  args:
+    - app
+    - deploy
+    - gae-interop-testing/gae-jdk8/build/staged-app/app.yaml
+    - --service-account=$_GAE_SERVICE_ACCOUNT
+    - --no-promote
+    - --no-stop-previous-version
+    - --version=cb-$BUILD_ID
+
+- id: runInteropTestRemote
+  name: eclipse-temurin:17-jdk
+  env:
+  - PROJECT_ID=$PROJECT_ID
+  script: |
+    #!/usr/bin/env bash
+    exec ./gradlew $GRADLE_FLAGS --stacktrace -PgaeDeployVersion="cb-$BUILD_ID" \
+        -PgaeProjectId="$PROJECT_ID" :grpc-gae-interop-testing-jdk8:runInteropTestRemote
+
+- id: cleanup
+  name: gcr.io/cloud-builders/gcloud
+  script: |
+    #!/usr/bin/env bash
+    set -e
+    echo "Performing cleanup now."
+    gcloud app services delete "$KOKORO_GAE_SERVICE" --version "cb-$BUILD_ID" --quiet
diff --git a/buildscripts/gae-build/Dockerfile b/buildscripts/gae-build/Dockerfile
new file mode 100644
index 00000000000..7e68b270801
--- /dev/null
+++ b/buildscripts/gae-build/Dockerfile
@@ -0,0 +1,10 @@
+FROM eclipse-temurin:17-jdk
+
+# The AppEngine Gradle plugin downloads and runs its own gcloud to get the .jar
+# to link against, so we need Python even if we use gcloud deploy directly
+# instead of using the plugin.
+RUN export DEBIAN_FRONTEND=noninteractive && \
+    apt-get update && \
+    apt-get upgrade -y && \
+    apt-get install -y --no-install-recommends python3 && \
+    rm -rf /var/lib/apt/lists/*
diff --git a/buildscripts/grpc-java-artifacts/Dockerfile b/buildscripts/grpc-java-artifacts/Dockerfile
new file mode 100644
index 00000000000..54c595cd960
--- /dev/null
+++ b/buildscripts/grpc-java-artifacts/Dockerfile
@@ -0,0 +1,37 @@
+FROM almalinux:8
+
+RUN yum install -y \
+            autoconf \
+            automake \
+            diffutils \
+            gcc-c++ \
+            glibc-devel \
+            glibc-devel.i686 \
+            java-11-openjdk-devel \
+            libstdc++-devel \
+            libstdc++-devel.i686 \
+            libtool \
+            make \
+            tar \
+            unzip \
+            which \
+            && \
+    yum clean all
+
+ENV ANDROID_HOME=/opt/Android/Sdk
+RUN mkdir -p "$ANDROID_HOME/cmdline-tools" && \
+    curl -Ls -o cmdline.zip \
+        "https://dl.google.com/android/repository/commandlinetools-linux-9477386_latest.zip" && \
+    unzip -qd "$ANDROID_HOME/cmdline-tools" cmdline.zip && \
+    rm cmdline.zip && \
+    mv "$ANDROID_HOME/cmdline-tools/cmdline-tools" "$ANDROID_HOME/cmdline-tools/latest" && \
+    yes | "$ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager" --licenses
+
+RUN curl -Ls https://github.com/Kitware/CMake/releases/download/v3.26.3/cmake-3.26.3-linux-x86_64.tar.gz | \
+    tar xz -C /var/local    
+    
+# Install Maven
+RUN curl -Ls https://archive.apache.org/dist/maven/maven-3/3.8.8/binaries/apache-maven-3.8.8-bin.tar.gz | \
+    tar xz -C /var/local
+ENV PATH /var/local/cmake-3.26.3-linux-x86_64/bin:/var/local/apache-maven-3.8.8/bin:$PATH
+
diff --git a/buildscripts/grpc-java-artifacts/Dockerfile.multiarch.base b/buildscripts/grpc-java-artifacts/Dockerfile.multiarch.base
new file mode 100644
index 00000000000..da2c46904ca
--- /dev/null
+++ b/buildscripts/grpc-java-artifacts/Dockerfile.multiarch.base
@@ -0,0 +1,20 @@
+FROM ubuntu:18.04
+
+RUN export DEBIAN_FRONTEND=noninteractive && \
+    apt-get update && \
+    apt-get upgrade -y && \
+    apt-get install -y --no-install-recommends \
+        build-essential \
+        ca-certificates \
+        curl \
+        g++-aarch64-linux-gnu \
+        g++-powerpc64le-linux-gnu \
+        openjdk-8-jdk \
+        pkg-config \
+        && \
+    rm -rf /var/lib/apt/lists/*
+    
+RUN curl -Ls https://github.com/Kitware/CMake/releases/download/v3.26.3/cmake-3.26.3-linux-x86_64.tar.gz | \
+    tar xz -C /var/local
+ENV PATH /var/local/cmake-3.26.3-linux-x86_64/bin:$PATH
+
diff --git a/buildscripts/grpc-java-artifacts/Dockerfile.ubuntu2004.base b/buildscripts/grpc-java-artifacts/Dockerfile.ubuntu2004.base
new file mode 100644
index 00000000000..e987fb3e684
--- /dev/null
+++ b/buildscripts/grpc-java-artifacts/Dockerfile.ubuntu2004.base
@@ -0,0 +1,19 @@
+FROM ubuntu:20.04
+
+RUN export DEBIAN_FRONTEND=noninteractive && \
+    apt-get update && \
+    apt-get upgrade -y && \
+    apt-get install -y --no-install-recommends \
+        build-essential \
+        ca-certificates \
+        curl \
+        g++-s390x-linux-gnu \
+        openjdk-8-jdk \
+        pkg-config \
+        && \
+    rm -rf /var/lib/apt/lists/*
+    
+RUN curl -Ls https://github.com/Kitware/CMake/releases/download/v3.26.3/cmake-3.26.3-linux-x86_64.tar.gz | \
+    tar xz -C /var/local
+ENV PATH /var/local/cmake-3.26.3-linux-x86_64/bin:$PATH
+
diff --git a/buildscripts/jenkins-pre.bat b/buildscripts/jenkins-pre.bat
deleted file mode 100644
index 07354b54f05..00000000000
--- a/buildscripts/jenkins-pre.bat
+++ /dev/null
@@ -1,18 +0,0 @@
-if NOT EXIST grpc-java-helper mkdir grpc-java-helper
-cd grpc-java-helper
-
-REM check if 7za is available
-7za > NUL
-if ERRORLEVEL 1 call gsutil cp gs://grpc-jenkins-helpers/java/7za.exe .
-
-call "%VS120COMNTOOLS%\vsvars32.bat"
-call "%WORKSPACE%\buildscripts\make_dependencies.bat"
-
-cd "%WORKSPACE%"
-
-set ESCWORKSPACE=%WORKSPACE:\=\\%
-
-echo targetArch=x86_32> gradle.properties
-echo failOnWarnings=true>> gradle.properties
-echo vcProtobufLibs=%ESCWORKSPACE%\\grpc-java-helper\\protobuf-%PROTOBUF_VER%\\cmake\\build\\Release>> gradle.properties
-echo vcProtobufInclude=%ESCWORKSPACE%\\grpc-java-helper\\protobuf-%PROTOBUF_VER%\\cmake\\build\\include>> gradle.properties
diff --git a/buildscripts/kokoro/android-interop.cfg b/buildscripts/kokoro/android-interop.cfg
new file mode 100644
index 00000000000..e3992072611
--- /dev/null
+++ b/buildscripts/kokoro/android-interop.cfg
@@ -0,0 +1,5 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/android-interop.sh"
+timeout_mins: 45
diff --git a/buildscripts/kokoro/android-interop.sh b/buildscripts/kokoro/android-interop.sh
new file mode 100755
index 00000000000..877311daca5
--- /dev/null
+++ b/buildscripts/kokoro/android-interop.sh
@@ -0,0 +1,56 @@
+#!/bin/bash
+
+set -exu -o pipefail
+
+cd github/grpc-java
+
+export ANDROID_HOME=/tmp/Android/Sdk
+mkdir -p "${ANDROID_HOME}/cmdline-tools"
+curl -Ls -o cmdline.zip \
+    "https://dl.google.com/android/repository/commandlinetools-linux-9477386_latest.zip"
+unzip -qd "${ANDROID_HOME}/cmdline-tools" cmdline.zip
+rm cmdline.zip
+mv "${ANDROID_HOME}/cmdline-tools/cmdline-tools" "${ANDROID_HOME}/cmdline-tools/latest"
+(yes || true) | "${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager" --licenses
+
+# Build Android with Java 11, this adds it to the PATH
+sudo update-java-alternatives --set java-1.11.0-openjdk-amd64
+# Unset any existing JAVA_HOME env var to stop Gradle from using it
+unset JAVA_HOME
+
+GRADLE_FLAGS="-Pandroid.useAndroidX=true -Dorg.gradle.jvmargs=-Xmx1024m -PskipCodegen=true"
+
+./gradlew $GRADLE_FLAGS :grpc-android-interop-testing:assembleDebug
+./gradlew $GRADLE_FLAGS :grpc-android-interop-testing:assembleDebugAndroidTest
+./gradlew $GRADLE_FLAGS :grpc-binder:assembleDebugAndroidTest
+
+# To see currently-available virtual devices:
+#   gcloud firebase test android models list --filter=form=virtual
+
+# Run interop instrumentation tests on Firebase Test Lab
+gcloud firebase test android run \
+  --type instrumentation \
+  --app android-interop-testing/build/outputs/apk/debug/grpc-android-interop-testing-debug.apk \
+  --test android-interop-testing/build/outputs/apk/androidTest/debug/grpc-android-interop-testing-debug-androidTest.apk \
+  --environment-variables \
+      server_host=grpc-test.sandbox.googleapis.com,server_port=443,test_case=all \
+  --device model=MediumPhone.arm,version=30,locale=en,orientation=portrait \
+  --device model=MediumPhone.arm,version=29,locale=en,orientation=portrait \
+  --device model=MediumPhone.arm,version=28,locale=en,orientation=portrait \
+  --device model=MediumPhone.arm,version=27,locale=en,orientation=portrait \
+  --device model=MediumPhone.arm,version=26,locale=en,orientation=portrait \
+  --device model=Nexus6P,version=25,locale=en,orientation=portrait \
+  --device model=Nexus6P,version=24,locale=en,orientation=portrait \
+
+# Run binderchannel instrumentation tests on Firebase Test Lab
+gcloud firebase test android run \
+  --type instrumentation \
+  --app android-interop-testing/build/outputs/apk/debug/grpc-android-interop-testing-debug.apk \
+  --test binder/build/outputs/apk/androidTest/debug/grpc-binder-debug-androidTest.apk \
+  --device model=MediumPhone.arm,version=30,locale=en,orientation=portrait \
+  --device model=MediumPhone.arm,version=29,locale=en,orientation=portrait \
+  --device model=MediumPhone.arm,version=28,locale=en,orientation=portrait \
+  --device model=MediumPhone.arm,version=27,locale=en,orientation=portrait \
+  --device model=MediumPhone.arm,version=26,locale=en,orientation=portrait \
+  --device model=Nexus6P,version=25,locale=en,orientation=portrait \
+  --device model=Nexus6P,version=24,locale=en,orientation=portrait \
diff --git a/buildscripts/kokoro/android.cfg b/buildscripts/kokoro/android.cfg
new file mode 100644
index 00000000000..7730b90a2b0
--- /dev/null
+++ b/buildscripts/kokoro/android.cfg
@@ -0,0 +1,5 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/android.sh"
+timeout_mins: 45
diff --git a/buildscripts/kokoro/android.sh b/buildscripts/kokoro/android.sh
new file mode 100755
index 00000000000..5af55b2f551
--- /dev/null
+++ b/buildscripts/kokoro/android.sh
@@ -0,0 +1,147 @@
+#!/bin/bash
+
+set -exu -o pipefail
+
+BASE_DIR="$(pwd)"
+
+# Install gRPC and codegen for the Android examples
+# (a composite gradle build can't find protoc-gen-grpc-java)
+
+cd "$BASE_DIR/github/grpc-java"
+
+export OS_NAME=$(uname)
+
+cat <<EOF >> gradle.properties
+# defaults to -Xmx512m -XX:MaxMetaspaceSize=256m
+# https://docs.gradle.org/current/userguide/build_environment.html#sec:configuring_jvm_memory
+# Increased due to java.lang.OutOfMemoryError: Metaspace failures, "JVM heap
+# space is exhausted", and to increase build speed
+org.gradle.jvmargs=-Xmx2048m -XX:MaxMetaspaceSize=1024m
+EOF
+
+export ANDROID_HOME=/tmp/Android/Sdk
+mkdir -p "${ANDROID_HOME}/cmdline-tools"
+curl -Ls -o cmdline.zip \
+    "https://dl.google.com/android/repository/commandlinetools-linux-9477386_latest.zip"
+unzip -qd "${ANDROID_HOME}/cmdline-tools" cmdline.zip
+rm cmdline.zip
+mv "${ANDROID_HOME}/cmdline-tools/cmdline-tools" "${ANDROID_HOME}/cmdline-tools/latest"
+(yes || true) | "${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager" --licenses
+curl -Ls https://github.com/Kitware/CMake/releases/download/v3.26.3/cmake-3.26.3-linux-x86_64.tar.gz | \
+    tar xz -C /tmp
+export PATH=/tmp/cmake-3.26.3-linux-x86_64/bin:$PATH
+    
+# Proto deps
+buildscripts/make_dependencies.sh
+
+sudo apt-get update && sudo apt-get install pkg-config
+export LDFLAGS="$(PKG_CONFIG_PATH=/tmp/protobuf/lib/pkgconfig pkg-config --libs protobuf)"
+export CXXFLAGS="$(PKG_CONFIG_PATH=/tmp/protobuf/lib/pkgconfig pkg-config --cflags protobuf)"
+export LD_LIBRARY_PATH=/tmp/protobuf/lib
+
+# Build Android with Java 11, this adds it to the PATH
+sudo update-java-alternatives --set java-1.11.0-openjdk-amd64
+# Unset any existing JAVA_HOME env var to stop Gradle from using it
+unset JAVA_HOME
+
+GRADLE_FLAGS="-Pandroid.useAndroidX=true"
+
+./gradlew \
+    :grpc-android-interop-testing:build \
+    :grpc-android:build \
+    :grpc-cronet:build \
+    :grpc-binder:build \
+    assembleAndroidTest \
+    publishToMavenLocal \
+    $GRADLE_FLAGS
+
+if [[ ! -z $(git status --porcelain) ]]; then
+  git status
+  echo "Error Working directory is not clean. Forget to commit generated files?"
+  exit 1
+fi
+
+# Build examples
+
+cd ./examples/android/clientcache
+../../gradlew build $GRADLE_FLAGS
+cd ../routeguide
+../../gradlew build $GRADLE_FLAGS
+cd ../helloworld
+../../gradlew build $GRADLE_FLAGS
+cd ../strictmode
+../../gradlew build $GRADLE_FLAGS
+
+# Skip APK size and dex count comparisons for non-PR builds
+
+if [[ -z "${KOKORO_GITHUB_PULL_REQUEST_COMMIT:-}" ]]; then
+    echo "Skipping APK size and dex count"
+    exit 0
+fi
+
+# Collect APK size and dex count stats for the helloworld example
+HELLO_WORLD_OUTPUT_DIR="$BASE_DIR/github/grpc-java/examples/android/helloworld/app/build/outputs"
+
+# Install dependencies of apkanalyzer
+"${ANDROID_HOME}/cmdline-tools/latest/bin/sdkmanager" --install "build-tools;35.0.0"
+
+read -r ignored new_dex_count < \
+  <("${ANDROID_HOME}/cmdline-tools/latest/bin/apkanalyzer" dex references \
+  "$HELLO_WORLD_OUTPUT_DIR/apk/release/app-release-unsigned.apk")
+
+set +x
+all_new_methods=`"${ANDROID_HOME}/cmdline-tools/latest/bin/apkanalyzer" dex packages \
+  --proguard-mapping "$HELLO_WORLD_OUTPUT_DIR/mapping/release/mapping.txt" \
+  "$HELLO_WORLD_OUTPUT_DIR/apk/release/app-release-unsigned.apk" | grep ^M | cut -f4 | sort`
+set -x
+
+new_apk_size="$(stat --printf=%s $HELLO_WORLD_OUTPUT_DIR/apk/release/app-release-unsigned.apk)"
+
+
+# Get the APK size and dex count stats using the pull request base commit
+cd $BASE_DIR/github/grpc-java
+./gradlew clean
+git checkout HEAD^
+./gradlew --stop  # use a new daemon to build the previous commit
+GRADLE_FLAGS="${GRADLE_FLAGS} -PskipCodegen=true" # skip codegen for build from previous commit since it wasn't built with --std=c++14 when making this change
+./gradlew publishToMavenLocal $GRADLE_FLAGS
+cd examples/android/helloworld/
+../../gradlew build $GRADLE_FLAGS
+
+read -r ignored old_dex_count < \
+  <("${ANDROID_HOME}/cmdline-tools/latest/bin/apkanalyzer" dex references app/build/outputs/apk/release/app-release-unsigned.apk)
+
+set +x
+all_old_methods=`"${ANDROID_HOME}/cmdline-tools/latest/bin/apkanalyzer" dex packages --proguard-mapping app/build/outputs/mapping/release/mapping.txt app/build/outputs/apk/release/app-release-unsigned.apk | grep ^M | cut -f4 | sort`
+set -x
+
+old_apk_size="$(stat --printf=%s app/build/outputs/apk/release/app-release-unsigned.apk)"
+
+dex_count_delta="$((new_dex_count-old_dex_count))"
+
+apk_size_delta="$((new_apk_size-old_apk_size))"
+
+set +x
+dex_method_diff=`diff -u <(echo "$all_old_methods") <(echo "$all_new_methods") || true`
+set -x
+
+if [[ -n "$dex_method_diff" ]]
+then
+  echo "Method diff: ${dex_method_diff}"
+fi
+
+# Update the statuses with the deltas
+
+gsutil cp gs://grpc-testing-secrets/github_credentials/oauth_token.txt ~/
+
+desc="New DEX reference count: $(printf "%'d" "$new_dex_count") (delta: $(printf "%'d" "$dex_count_delta"))"
+curl -f -s -X POST -H "Content-Type: application/json" \
+    -H "Authorization: token $(cat ~/oauth_token.txt | tr -d '\n')" \
+    -d '{"state": "success", "context": "android/dex_diff", "description": "'"${desc}"'"}' \
+    "https://api.github.com/repos/grpc/grpc-java/statuses/${KOKORO_GITHUB_PULL_REQUEST_COMMIT}"
+
+desc="New APK size in bytes: $(printf "%'d" "$new_apk_size") (delta: $(printf "%'d" "$apk_size_delta"))"
+curl -f -s -X POST -H "Content-Type: application/json" \
+    -H "Authorization: token $(cat ~/oauth_token.txt | tr -d '\n')" \
+    -d '{"state": "success", "context": "android/apk_diff", "description": "'"${desc}"'"}' \
+    "https://api.github.com/repos/grpc/grpc-java/statuses/${KOKORO_GITHUB_PULL_REQUEST_COMMIT}"
diff --git a/buildscripts/kokoro/gae-interop.cfg b/buildscripts/kokoro/gae-interop.cfg
new file mode 100644
index 00000000000..78e14f94e38
--- /dev/null
+++ b/buildscripts/kokoro/gae-interop.cfg
@@ -0,0 +1,5 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/gae-interop.sh"
+timeout_mins: 45
diff --git a/buildscripts/kokoro/kokoro.sh b/buildscripts/kokoro/kokoro.sh
new file mode 100755
index 00000000000..0b3864b5092
--- /dev/null
+++ b/buildscripts/kokoro/kokoro.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+spongify_logs() {
+  local f
+  while read -r f; do
+    mkdir "${f%.xml}"
+    cp "$f" "${f%.xml}/sponge_log.xml"
+  done < <(find "${KOKORO_ARTIFACTS_DIR:-.}" -name 'TEST-*.xml')
+}
diff --git a/buildscripts/kokoro/linux_artifacts.cfg b/buildscripts/kokoro/linux_artifacts.cfg
new file mode 100644
index 00000000000..8691b5ff356
--- /dev/null
+++ b/buildscripts/kokoro/linux_artifacts.cfg
@@ -0,0 +1,13 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/linux_artifacts.sh"
+timeout_mins: 60
+
+action {
+  define_artifacts {
+    regex: "github/grpc-java/**/build/test-results/**/sponge_log.xml"
+    regex: "github/grpc-java/mvn-artifacts/**"
+    regex: "github/grpc-java/artifacts/**"
+  }
+}
diff --git a/buildscripts/kokoro/linux_artifacts.sh b/buildscripts/kokoro/linux_artifacts.sh
new file mode 100755
index 00000000000..49d9932dfa0
--- /dev/null
+++ b/buildscripts/kokoro/linux_artifacts.sh
@@ -0,0 +1,23 @@
+#!/bin/bash
+set -veux -o pipefail
+
+if [[ -f /VERSION ]]; then
+  cat /VERSION
+fi
+
+readonly GRPC_JAVA_DIR="$(cd "$(dirname "$0")"/../.. && pwd)"
+
+. "$GRPC_JAVA_DIR"/buildscripts/kokoro/kokoro.sh
+trap spongify_logs EXIT
+
+"$GRPC_JAVA_DIR"/buildscripts/build_docker.sh
+"$GRPC_JAVA_DIR"/buildscripts/run_in_docker.sh grpc-java-artifacts-x86 /grpc-java/buildscripts/build_artifacts_in_docker.sh
+
+"$GRPC_JAVA_DIR"/buildscripts/run_in_docker.sh grpc-java-artifacts-multiarch env \
+  SKIP_TESTS=true ARCH=aarch_64 /grpc-java/buildscripts/kokoro/unix.sh
+"$GRPC_JAVA_DIR"/buildscripts/run_in_docker.sh grpc-java-artifacts-multiarch env \
+  SKIP_TESTS=true ARCH=ppcle_64 /grpc-java/buildscripts/kokoro/unix.sh
+# Use a newer GCC version. GCC 7 in multiarch has a bug:
+#   internal compiler error: output_operand: invalid %-code
+"$GRPC_JAVA_DIR"/buildscripts/run_in_docker.sh grpc-java-artifacts-ubuntu2004 env \
+  SKIP_TESTS=true ARCH=s390_64 /grpc-java/buildscripts/kokoro/unix.sh
diff --git a/buildscripts/kokoro/macos.cfg b/buildscripts/kokoro/macos.cfg
new file mode 100644
index 00000000000..4c79743692e
--- /dev/null
+++ b/buildscripts/kokoro/macos.cfg
@@ -0,0 +1,13 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/macos.sh"
+timeout_mins: 60
+
+# We always build mvn artifacts.
+action {
+  define_artifacts {
+    regex: "github/grpc-java/**/build/test-results/**/sponge_log.xml"
+    regex: "github/grpc-java/mvn-artifacts/**"
+  }
+}
diff --git a/buildscripts/kokoro/macos.sh b/buildscripts/kokoro/macos.sh
new file mode 100755
index 00000000000..0240c0650f7
--- /dev/null
+++ b/buildscripts/kokoro/macos.sh
@@ -0,0 +1,28 @@
+#!/bin/bash
+set -veux -o pipefail
+CMAKE_VERSION=3.31.10
+
+if [[ -f /VERSION ]]; then
+  cat /VERSION
+fi
+
+readonly GRPC_JAVA_DIR="$(cd "$(dirname "$0")"/../.. && pwd)"
+
+DOWNLOAD_DIR=/tmp/source
+mkdir -p ${DOWNLOAD_DIR}
+curl -Ls https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-macos-universal.tar.gz | tar xz -C ${DOWNLOAD_DIR}
+
+# We had problems with random tests timing out because it took seconds to do
+# trivial (ns) operations. The Kokoro Mac machines have 2 cores with 4 logical
+# threads, so Gradle should be using 4 workers by default.
+export GRADLE_FLAGS="${GRADLE_FLAGS:-} --max-workers=2"
+
+. "$GRPC_JAVA_DIR"/buildscripts/kokoro/kokoro.sh
+trap spongify_logs EXIT
+
+brew install --cask temurin@8
+export PATH="$(/usr/libexec/java_home -v"1.8.0")/bin:${DOWNLOAD_DIR}/cmake-${CMAKE_VERSION}-macos-universal/CMake.app/Contents/bin:${PATH}"
+export JAVA_HOME="$(/usr/libexec/java_home -v"1.8.0")"
+brew install maven
+
+"$GRPC_JAVA_DIR"/buildscripts/kokoro/unix.sh
diff --git a/buildscripts/kokoro/psm-cloud-run.cfg b/buildscripts/kokoro/psm-cloud-run.cfg
new file mode 100644
index 00000000000..1f2d6da208f
--- /dev/null
+++ b/buildscripts/kokoro/psm-cloud-run.cfg
@@ -0,0 +1,17 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/psm-interop-test-java.sh"
+timeout_mins: 240
+
+action {
+  define_artifacts {
+    regex: "artifacts/**/*sponge_log.xml"
+    regex: "artifacts/**/*.log"
+    strip_prefix: "artifacts"
+  }
+}
+env_vars {
+  key: "PSM_TEST_SUITE"
+  value: "cloud_run"
+}
diff --git a/buildscripts/kokoro/psm-csm.cfg b/buildscripts/kokoro/psm-csm.cfg
new file mode 100644
index 00000000000..6f28dec20a0
--- /dev/null
+++ b/buildscripts/kokoro/psm-csm.cfg
@@ -0,0 +1,17 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/psm-interop-test-java.sh"
+timeout_mins: 120
+
+action {
+  define_artifacts {
+    regex: "artifacts/**/*sponge_log.xml"
+    regex: "artifacts/**/*.log"
+    strip_prefix: "artifacts"
+  }
+}
+env_vars {
+  key: "PSM_TEST_SUITE"
+  value: "csm"
+}
diff --git a/buildscripts/kokoro/psm-dualstack.cfg b/buildscripts/kokoro/psm-dualstack.cfg
new file mode 100644
index 00000000000..a55d91a95b0
--- /dev/null
+++ b/buildscripts/kokoro/psm-dualstack.cfg
@@ -0,0 +1,17 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/psm-interop-test-java.sh"
+timeout_mins: 240
+
+action {
+  define_artifacts {
+    regex: "artifacts/**/*sponge_log.xml"
+    regex: "artifacts/**/*.log"
+    strip_prefix: "artifacts"
+  }
+}
+env_vars {
+  key: "PSM_TEST_SUITE"
+  value: "dualstack"
+}
diff --git a/buildscripts/kokoro/psm-interop-build-java.sh b/buildscripts/kokoro/psm-interop-build-java.sh
new file mode 100755
index 00000000000..8c7a970ef23
--- /dev/null
+++ b/buildscripts/kokoro/psm-interop-build-java.sh
@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# Copyright 2024 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.
+set -eo pipefail
+
+# This file defines psm::lang::build_docker_images, which is directly called
+# from psm_interop_kokoro_lib.sh.
+
+# Used locally.
+readonly BUILD_APP_PATH="interop-testing/build/install/grpc-interop-testing"
+
+#######################################
+# Builds the test app using gradle and smoke-checks its binaries
+# Globals:
+#   SRC_DIR Absolute path to the source repo.
+#   BUILD_APP_PATH
+# Arguments:
+#   None
+# Outputs:
+#   Writes the output of xds-test-client and xds-test-server --help to stderr
+#######################################
+_build_java_test_app() {
+  psm::tools::log "Building Java test app"
+  cd "${SRC_DIR}"
+
+  set -x
+  GRADLE_OPTS="-Dorg.gradle.jvmargs='-Xmx1g'" \
+  ./gradlew --no-daemon grpc-interop-testing:installDist -x test \
+    -PskipCodegen=true -PskipAndroid=true --console=plain
+  set +x
+
+  psm::tools::log "Test-run grpc-java PSM interop binaries"
+  psm::tools::run_ignore_exit_code "${SRC_DIR}/${BUILD_APP_PATH}/bin/xds-test-client" --help
+  psm::tools::run_ignore_exit_code "${SRC_DIR}/${BUILD_APP_PATH}/bin/xds-test-server" --help
+}
+
+#######################################
+# Builds test app Docker images and pushes them to GCR
+# Globals:
+#   BUILD_APP_PATH
+#   SERVER_IMAGE_NAME: Test server Docker image name
+#   CLIENT_IMAGE_NAME: Test client Docker image name
+#   GIT_COMMIT: SHA-1 of git commit being built
+#   TESTING_VERSION: version branch under test, f.e. v1.42.x, master
+# Arguments:
+#   None
+# Outputs:
+#   Writes the output of `gcloud builds submit` to stdout, stderr
+#######################################
+psm::lang::build_docker_images() {
+  local java_build_log="${BUILD_LOGS_ROOT}/build-lang-java.log"
+  _build_java_test_app |& tee "${java_build_log}"
+
+  psm::tools::log "Building Java xDS interop test app Docker images"
+  local docker_dir="${SRC_DIR}/buildscripts/xds-k8s"
+  local build_dir
+  build_dir="$(mktemp -d)"
+
+  # Copy Docker files, log properties, and the test app to the build dir
+  {
+    cp -v "${docker_dir}/"*.Dockerfile "${build_dir}"
+    cp -v "${docker_dir}/"*.properties "${build_dir}"
+    cp -rv "${SRC_DIR}/${BUILD_APP_PATH}" "${build_dir}"
+  } >> "${java_build_log}"
+
+
+  # cloudbuild.yaml substitution variables
+  local substitutions=""
+  substitutions+="_SERVER_IMAGE_NAME=${SERVER_IMAGE_NAME},"
+  substitutions+="_CLIENT_IMAGE_NAME=${CLIENT_IMAGE_NAME},"
+  substitutions+="COMMIT_SHA=${GIT_COMMIT},"
+  substitutions+="BRANCH_NAME=${TESTING_VERSION},"
+
+  # Run Google Cloud Build
+  gcloud builds submit "${build_dir}" \
+    --config="${docker_dir}/cloudbuild.yaml" \
+    --substitutions="${substitutions}" \
+    | tee -a "${java_build_log}"
+}
diff --git a/buildscripts/kokoro/psm-interop-test-java.sh b/buildscripts/kokoro/psm-interop-test-java.sh
new file mode 100755
index 00000000000..f249d579d82
--- /dev/null
+++ b/buildscripts/kokoro/psm-interop-test-java.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+# Input parameters to psm:: methods of the install script.
+readonly GRPC_LANGUAGE="java"
+readonly BUILD_SCRIPT_DIR="$(dirname "$0")"
+
+# Used locally.
+readonly TEST_DRIVER_INSTALL_SCRIPT_URL="https://raw.githubusercontent.com/${TEST_DRIVER_REPO_OWNER:-grpc}/psm-interop/${TEST_DRIVER_BRANCH:-main}/.kokoro/psm_interop_kokoro_lib.sh"
+
+psm::lang::source_install_lib() {
+  echo "Sourcing test driver install script from: ${TEST_DRIVER_INSTALL_SCRIPT_URL}"
+  local install_lib
+  # Download to a tmp file.
+  install_lib="$(mktemp -d)/psm_interop_kokoro_lib.sh"
+  curl -s --retry-connrefused --retry 5 -o "${install_lib}" "${TEST_DRIVER_INSTALL_SCRIPT_URL}"
+  # Checksum.
+  if command -v sha256sum &> /dev/null; then
+    echo "Install script checksum:"
+    sha256sum "${install_lib}"
+  fi
+  source "${install_lib}"
+}
+
+psm::lang::source_install_lib
+source "${BUILD_SCRIPT_DIR}/psm-interop-build-${GRPC_LANGUAGE}.sh"
+psm::run "${PSM_TEST_SUITE}"
diff --git a/buildscripts/kokoro/psm-light.cfg b/buildscripts/kokoro/psm-light.cfg
new file mode 100644
index 00000000000..decd179efa3
--- /dev/null
+++ b/buildscripts/kokoro/psm-light.cfg
@@ -0,0 +1,17 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/psm-interop-test-java.sh"
+timeout_mins: 120
+
+action {
+  define_artifacts {
+    regex: "artifacts/**/*sponge_log.xml"
+    regex: "artifacts/**/*.log"
+    strip_prefix: "artifacts"
+  }
+}
+env_vars {
+  key: "PSM_TEST_SUITE"
+  value: "light"
+}
diff --git a/buildscripts/kokoro/psm-security.cfg b/buildscripts/kokoro/psm-security.cfg
new file mode 100644
index 00000000000..76d2c578597
--- /dev/null
+++ b/buildscripts/kokoro/psm-security.cfg
@@ -0,0 +1,17 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/psm-interop-test-java.sh"
+timeout_mins: 240
+
+action {
+  define_artifacts {
+    regex: "artifacts/**/*sponge_log.xml"
+    regex: "artifacts/**/*.log"
+    strip_prefix: "artifacts"
+  }
+}
+env_vars {
+  key: "PSM_TEST_SUITE"
+  value: "security"
+}
diff --git a/buildscripts/kokoro/psm-spiffe.cfg b/buildscripts/kokoro/psm-spiffe.cfg
new file mode 100644
index 00000000000..b04d715fca1
--- /dev/null
+++ b/buildscripts/kokoro/psm-spiffe.cfg
@@ -0,0 +1,17 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/psm-interop-test-java.sh"
+timeout_mins: 240
+
+action {
+  define_artifacts {
+    regex: "artifacts/**/*sponge_log.xml"
+    regex: "artifacts/**/*.log"
+    strip_prefix: "artifacts"
+  }
+}
+env_vars {
+  key: "PSM_TEST_SUITE"
+  value: "spiffe"
+}
diff --git a/buildscripts/kokoro/release_artifacts.cfg b/buildscripts/kokoro/release_artifacts.cfg
new file mode 100644
index 00000000000..518e8f1ea8d
--- /dev/null
+++ b/buildscripts/kokoro/release_artifacts.cfg
@@ -0,0 +1,5 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/release_artifacts.sh"
+timeout_mins: 60
diff --git a/buildscripts/kokoro/release_artifacts.sh b/buildscripts/kokoro/release_artifacts.sh
new file mode 100755
index 00000000000..ebd72f62370
--- /dev/null
+++ b/buildscripts/kokoro/release_artifacts.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+set -veux -o pipefail
+
+if [[ -f /VERSION ]]; then
+  cat /VERSION
+fi
+
+readonly GRPC_JAVA_DIR=$(cd $(dirname $0)/../.. && pwd)
+
+# A place holder at the moment
diff --git a/buildscripts/kokoro/unix.sh b/buildscripts/kokoro/unix.sh
new file mode 100755
index 00000000000..693768a0270
--- /dev/null
+++ b/buildscripts/kokoro/unix.sh
@@ -0,0 +1,121 @@
+#!/bin/bash
+
+# This file is used for both Linux and MacOS builds.
+# For Linux, this script is called inside a docker container with
+# the correct environment for releases.
+# To run locally:
+#  ./buildscripts/kokoro/unix.sh
+# For x86 32 arch:
+#  ARCH=x86_32 ./buildscripts/kokoro/unix.sh
+# For aarch64 arch:
+#  ARCH=aarch_64 ./buildscripts/kokoro/unix.sh
+# For ppc64le arch:
+#  ARCH=ppcle_64 ./buildscripts/kokoro/unix.sh
+# For s390x arch:
+#  ARCH=s390_64 ./buildscripts/kokoro/unix.sh
+
+# This script assumes `set -e`. Removing it may lead to undefined behavior.
+set -exu -o pipefail
+
+# It would be nicer to use 'readlink -f' here but osx does not support it.
+readonly GRPC_JAVA_DIR="$(cd "$(dirname "$0")"/../.. && pwd)"
+
+# cd to the root dir of grpc-java
+cd $(dirname $0)/../..
+
+# ARCH is x86_64 unless otherwise specified.
+ARCH="${ARCH:-x86_64}"
+
+cat <<EOF >> gradle.properties
+# defaults to -Xmx512m -XX:MaxMetaspaceSize=256m
+# https://docs.gradle.org/current/userguide/build_environment.html#sec:configuring_jvm_memory
+# Increased due to java.lang.OutOfMemoryError: Metaspace failures, "JVM heap
+# space is exhausted", and to increase build speed
+org.gradle.jvmargs=-Xmx2048m -XX:MaxMetaspaceSize=1024m
+EOF
+
+ARCH="$ARCH" buildscripts/make_dependencies.sh
+
+# Set properties via flags, do not pollute gradle.properties
+GRADLE_FLAGS="${GRADLE_FLAGS:-}"
+GRADLE_FLAGS+=" --stacktrace"
+GRADLE_FLAGS+=" -PtargetArch=$ARCH"
+
+# For universal binaries on macOS, signal Gradle to use universal flags.
+if [[ "$(uname -s)" == "Darwin" ]]; then
+  GRADLE_FLAGS+=" -PbuildUniversal=true"
+fi
+GRADLE_FLAGS+=" -Pcheckstyle.ignoreFailures=false"
+GRADLE_FLAGS+=" -PfailOnWarnings=true"
+GRADLE_FLAGS+=" -PerrorProne=true"
+GRADLE_FLAGS+=" -Dorg.gradle.parallel=true"
+if [[ -z "${ALL_ARTIFACTS:-}" ]]; then
+  GRADLE_FLAGS+=" -PskipAndroid=true"
+else
+  GRADLE_FLAGS+=" -Pandroid.useAndroidX=true"
+fi
+export GRADLE_OPTS="-Dorg.gradle.jvmargs='-Xmx1g'"
+
+# Make protobuf discoverable by :grpc-compiler
+export LDFLAGS="$(PKG_CONFIG_PATH=/tmp/protobuf/lib/pkgconfig pkg-config --libs protobuf)"
+export CXXFLAGS="$(PKG_CONFIG_PATH=/tmp/protobuf/lib/pkgconfig pkg-config --cflags protobuf)"
+export LIBRARY_PATH=/tmp/protobuf/lib
+
+./gradlew grpc-compiler:clean $GRADLE_FLAGS
+
+if [[ -z "${SKIP_TESTS:-}" ]]; then
+  # Ensure all *.proto changes include *.java generated code
+  ./gradlew assemble generateTestProto publishToMavenLocal $GRADLE_FLAGS
+
+  if [[ -z "${SKIP_CLEAN_CHECK:-}" && ! -z $(git status --porcelain) ]]; then
+    git status
+    echo "Error Working directory is not clean. Forget to commit generated files?"
+    exit 1
+  fi
+  # Run tests
+  ./gradlew build :grpc-all:jacocoTestReport $GRADLE_FLAGS
+  pushd examples
+  ./gradlew build $GRADLE_FLAGS
+  # --batch-mode reduces log spam
+  mvn verify --batch-mode
+  popd
+  for f in examples/example-*
+  do
+     pushd "$f"
+     ../gradlew build $GRADLE_FLAGS
+     if [ -f "pom.xml" ]; then
+       # --batch-mode reduces log spam
+       mvn verify --batch-mode
+     fi
+     popd
+  done
+  # TODO(zpencer): also build the GAE examples
+fi
+
+LOCAL_MVN_TEMP=$(mktemp -d)
+# Note that this disables parallel=true from GRADLE_FLAGS
+if [[ -z "${ALL_ARTIFACTS:-}" ]]; then
+  if [[ "$ARCH" = "aarch_64" || "$ARCH" = "ppcle_64" || "$ARCH" = "s390_64" ]]; then
+    GRADLE_FLAGS+=" -x grpc-compiler:generateTestProto -x grpc-compiler:generateTestLiteProto"
+    GRADLE_FLAGS+=" -x grpc-compiler:testGolden -x grpc-compiler:testLiteGolden"
+    GRADLE_FLAGS+=" -x grpc-compiler:testDeprecatedGolden -x grpc-compiler:testDeprecatedLiteGolden"
+  fi
+  ./gradlew grpc-compiler:build grpc-compiler:publish $GRADLE_FLAGS \
+    -Dorg.gradle.parallel=false -PrepositoryDir=$LOCAL_MVN_TEMP
+else
+  ./gradlew publish :grpc-core:versionFile $GRADLE_FLAGS \
+    -Dorg.gradle.parallel=false -PrepositoryDir=$LOCAL_MVN_TEMP
+  pushd examples/example-hostname
+  ../gradlew jibBuildTar $GRADLE_FLAGS
+  popd
+
+  readonly OTHER_ARTIFACT_DIR="${OTHER_ARTIFACT_DIR:-$GRPC_JAVA_DIR/artifacts}"
+  mkdir -p "$OTHER_ARTIFACT_DIR"
+  cp core/build/version "$OTHER_ARTIFACT_DIR"/
+  cp examples/example-hostname/build/example-hostname.* "$OTHER_ARTIFACT_DIR"/
+fi
+
+readonly MVN_ARTIFACT_DIR="${MVN_ARTIFACT_DIR:-$GRPC_JAVA_DIR/mvn-artifacts}"
+
+mkdir -p "$MVN_ARTIFACT_DIR"
+cp -r "$LOCAL_MVN_TEMP"/* "$MVN_ARTIFACT_DIR"/
diff --git a/buildscripts/kokoro/upload_artifacts.cfg b/buildscripts/kokoro/upload_artifacts.cfg
new file mode 100644
index 00000000000..38ee2f38aea
--- /dev/null
+++ b/buildscripts/kokoro/upload_artifacts.cfg
@@ -0,0 +1,5 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/upload_artifacts.sh"
+timeout_mins: 60
diff --git a/buildscripts/kokoro/upload_artifacts.sh b/buildscripts/kokoro/upload_artifacts.sh
new file mode 100644
index 00000000000..39e27eff522
--- /dev/null
+++ b/buildscripts/kokoro/upload_artifacts.sh
@@ -0,0 +1,98 @@
+#!/bin/bash
+set -veux -o pipefail
+
+if [[ -f /VERSION ]]; then
+  cat /VERSION
+fi
+
+readonly GRPC_JAVA_DIR="$(cd "$(dirname "$0")"/../.. && pwd)"
+
+echo "Verifying that all artifacts are here..."
+find "$KOKORO_GFILE_DIR"
+
+# The output from all the jobs are coalesced into a single dir
+LOCAL_MVN_ARTIFACTS="$KOKORO_GFILE_DIR"/github/grpc-java/mvn-artifacts/
+LOCAL_OTHER_ARTIFACTS="$KOKORO_GFILE_DIR"/github/grpc-java/artifacts/
+
+# verify that files from all 3 grouped jobs are present.
+# platform independent artifacts, from linux job:
+[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'grpc-core-*.jar' | wc -l)" != '0' ]]
+
+# android artifact from linux job:
+[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'grpc-android-*.aar' | wc -l)" != '0' ]]
+
+# cronet artifact from linux job:
+[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'grpc-cronet-*.aar' | wc -l)" != '0' ]]
+
+# binder artifact from linux job:
+[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'grpc-binder-*.aar' | wc -l)" != '0' ]]
+
+# from linux job:
+[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-linux-x86_64.exe' | wc -l)" != '0' ]]
+[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-linux-x86_32.exe' | wc -l)" != '0' ]]
+
+# for linux aarch64 platform
+[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-linux-aarch_64.exe' | wc -l)" != '0' ]]
+
+# for linux ppc64le platform
+[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-linux-ppcle_64.exe' | wc -l)" != '0' ]]
+
+# for linux s390x platform
+[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-linux-s390_64.exe' | wc -l)" != '0' ]]
+
+# from macos job:
+[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-osx-x86_64.exe' | wc -l)" != '0' ]]
+# copy all x86 artifacts to aarch until native artifacts are built
+find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-osx-x86_64.exe*' -exec bash -c 'cp "${0}" "${0/x86/aarch}"' {} \;
+
+# from windows job:
+[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-windows-x86_64.exe' | wc -l)" != '0' ]]
+[[ "$(find "$LOCAL_MVN_ARTIFACTS" -type f -iname 'protoc-gen-grpc-java-*-windows-x86_32.exe' | wc -l)" != '0' ]]
+
+
+mkdir -p ~/.config/
+gsutil cp gs://grpc-testing-secrets/sonatype_credentials/sonatype-upload ~/.config/sonatype-upload
+
+mkdir -p ~/java_signing/
+gsutil cp -r gs://grpc-testing-secrets/java_signing/ ~/
+gpg --batch  --import ~/java_signing/grpc-java-team-sonatype.asc
+
+gsutil cat gs://grpc-testing-secrets/dockerhub_credentials/grpcpackages.password \
+  | docker login --username grpcpackages --password-stdin
+
+# gpg commands changed between v1 and v2 are different.
+gpg --version
+
+# This is the version found on kokoro.
+if gpg --version | grep 'gpg (GnuPG) 1.'; then
+  # This command was tested on 1.4.16
+  find "$LOCAL_MVN_ARTIFACTS" -type f \
+    -not -name "maven-metadata.xml*" -not -name "*.sha*" -not -name "*.md5" -exec \
+    bash -c 'cat ~/java_signing/passphrase | gpg --batch --passphrase-fd 0 --detach-sign -a {}' \;
+fi
+
+# This is the version found on corp workstations. Maybe kokoro will be updated to gpg2 some day.
+if gpg --version | grep 'gpg (GnuPG) 2.'; then
+  # This command was tested on 2.2.2
+  find "$LOCAL_MVN_ARTIFACTS" -type f \
+    -not -name "maven-metadata.xml*" -not -name "*.sha*" -not -name "*.md5" -exec \
+    gpg --batch --passphrase-file ~/java_signing/passphrase --pinentry-mode loopback \
+    --detach-sign -a {} \;
+fi
+
+# Just the numbers; does not include leading 'v'
+VERSION="$(cat $LOCAL_OTHER_ARTIFACTS/version)"
+EXAMPLE_HOSTNAME_ID="$(cat "$LOCAL_OTHER_ARTIFACTS/example-hostname.id")"
+docker load --input "$LOCAL_OTHER_ARTIFACTS/example-hostname.tar"
+LATEST_VERSION="$((echo "v$VERSION"; git ls-remote -t --refs https://github.com/grpc/grpc-java.git | cut -f 2 | sed s#refs/tags/##) | sort -V | tail -n 1)"
+
+
+STAGING_REPO=a93898609ef848
+"$GRPC_JAVA_DIR"/buildscripts/sonatype-upload.sh "$STAGING_REPO" "$LOCAL_MVN_ARTIFACTS"
+
+docker tag "$EXAMPLE_HOSTNAME_ID" "grpc/java-example-hostname:${VERSION}"
+docker push "grpc/java-example-hostname:${VERSION}"
+if [[ "v$VERSION" = "$LATEST_VERSION" ]]; then
+  docker tag "$EXAMPLE_HOSTNAME_ID" grpc/java-example-hostname:latest
+  docker push grpc/java-example-hostname:latest
+fi
diff --git a/buildscripts/kokoro/windows.bat b/buildscripts/kokoro/windows.bat
new file mode 100644
index 00000000000..b5852cdd971
--- /dev/null
+++ b/buildscripts/kokoro/windows.bat
@@ -0,0 +1,22 @@
+@rem ##########################################################################
+@rem
+@rem Script to set up Kokoro worker and run Windows tests
+@rem
+@rem ##########################################################################
+
+type c:\VERSION
+
+@rem Enter repo root
+cd /d %~dp0\..\..
+
+set WORKSPACE=T:\src\github\grpc-java
+set ESCWORKSPACE=%WORKSPACE:\=\\%
+@rem vswhere is too old, so it crashes gradle. https://github.com/gradle/gradle/issues/21993
+rename "C:\Program Files (x86)\Microsoft Visual Studio\Installer\vswhere.exe" vswhere-disabled.exe
+
+
+cmd.exe /C "%WORKSPACE%\buildscripts\kokoro\windows32.bat" || exit /b 1
+cmd.exe /C "%WORKSPACE%\buildscripts\kokoro\windows64.bat" || exit /b 1
+
+mkdir mvn-artifacts
+move artifacts\io mvn-artifacts
diff --git a/buildscripts/kokoro/windows.cfg b/buildscripts/kokoro/windows.cfg
new file mode 100644
index 00000000000..ec0a3c9ae34
--- /dev/null
+++ b/buildscripts/kokoro/windows.cfg
@@ -0,0 +1,13 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/windows.bat"
+timeout_mins: 90 
+
+# We always build mvn artifacts.
+action {
+  define_artifacts {
+    regex: "github/grpc-java/**/build/test-results/**/sponge_log.xml"
+    regex: "github/grpc-java/mvn-artifacts/**"
+  }
+}
diff --git a/buildscripts/kokoro/windows32.bat b/buildscripts/kokoro/windows32.bat
new file mode 100644
index 00000000000..d51beba82f9
--- /dev/null
+++ b/buildscripts/kokoro/windows32.bat
@@ -0,0 +1,85 @@
+@rem ##########################################################################
+@rem
+@rem Runs tests and then builds artifacts to %WORKSPACE%\artifacts\
+@rem
+@rem ##########################################################################
+
+type c:\VERSION
+
+@rem Enter repo root
+cd /d %~dp0\..\..
+
+set WORKSPACE=T:\src\github\grpc-java
+set ESCWORKSPACE=%WORKSPACE:\=\\%
+
+
+@rem Clear JAVA_HOME to prevent a different Java version from being used
+set JAVA_HOME=
+
+mkdir grpc-java-helper32
+cd grpc-java-helper32
+call "%VS170COMNTOOLS%\..\..\VC\Auxiliary\Build\vcvars32.bat" || exit /b 1
+call "%WORKSPACE%\buildscripts\make_dependencies.bat" || exit /b 1
+
+cd "%WORKSPACE%"
+
+SET TARGET_ARCH=x86_32
+SET FAIL_ON_WARNINGS=true
+SET PROTOBUF_VER=33.4
+SET PKG_CONFIG_PATH=%ESCWORKSPACE%\\grpc-java-helper32\\protobuf-%PROTOBUF_VER%\\build\\protobuf-%PROTOBUF_VER%\\lib\\pkgconfig
+SET VC_PROTOBUF_LIBS=/LIBPATH:%ESCWORKSPACE%\\grpc-java-helper32\\protobuf-%PROTOBUF_VER%\\build\\protobuf-%PROTOBUF_VER%\\lib
+SET VC_PROTOBUF_INCLUDE=%ESCWORKSPACE%\\grpc-java-helper32\\protobuf-%PROTOBUF_VER%\\build\\protobuf-%PROTOBUF_VER%\\include
+call :Get_Libs
+SET GRADLE_FLAGS=-PtargetArch=%TARGET_ARCH% -PfailOnWarnings=%FAIL_ON_WARNINGS% -PvcProtobufLibs=%VC_PROTOBUF_LIBS% -PvcProtobufInclude=%VC_PROTOBUF_INCLUDE% -PskipAndroid=true
+SET GRADLE_OPTS="-Dorg.gradle.jvmargs='-Xmx1g'"
+
+cmd.exe /C "%WORKSPACE%\gradlew.bat %GRADLE_FLAGS% build"
+set GRADLEEXIT=%ERRORLEVEL%
+
+@rem Rename test results .xml files to format parsable by Kokoro
+@echo off
+for /r %%F in (TEST-*.xml) do (
+  mkdir "%%~dpnF"
+  move "%%F" "%%~dpnF\sponge_log.xml" >NUL
+)
+@echo on
+
+IF NOT %GRADLEEXIT% == 0 (
+  exit /b %GRADLEEXIT%
+)
+
+@rem make sure no daemons have any files open
+cmd.exe /C "%WORKSPACE%\gradlew.bat --stop"
+
+cmd.exe /C "%WORKSPACE%\gradlew.bat  %GRADLE_FLAGS% -Dorg.gradle.parallel=false -PrepositoryDir=%WORKSPACE%\artifacts clean grpc-compiler:build grpc-compiler:publish" || exit /b 1
+
+goto :eof
+:Get_Libs
+SetLocal EnableDelayedExpansion
+set "libs_list="
+for /f "tokens=*" %%a in ('pkg-config --libs protobuf') do (
+  for %%b in (%%a) do (
+    set lib=%%b
+    set libfirst2char=!lib:~0,2!
+    if !libfirst2char!==-l (
+      @rem remove the leading -l
+      set lib=!lib:~2!
+      @rem remove spaces
+      set lib=!lib: =!
+      set libprefix=!lib:~0,4!
+      if !libprefix!==absl (
+        set lib=!lib!.lib
+      ) else (
+        set lib=lib!lib!.lib
+      )
+      if "!libs_list!"=="" (
+        set libs_list=!lib!
+      ) else (
+        set libs_list=!libs_list!,!lib!
+      )
+    )
+  )
+)
+EndLocal & set "VC_PROTOBUF_LIBS=%VC_PROTOBUF_LIBS%,%libs_list%" 
+exit /b 0
+
diff --git a/buildscripts/kokoro/windows64.bat b/buildscripts/kokoro/windows64.bat
new file mode 100644
index 00000000000..180025d5e82
--- /dev/null
+++ b/buildscripts/kokoro/windows64.bat
@@ -0,0 +1,69 @@
+@rem ##########################################################################
+@rem
+@rem Builds artifacts for x86_64 into %WORKSPACE%\artifacts\
+@rem
+@rem ##########################################################################
+
+type c:\VERSION
+
+@rem Enter repo root
+cd /d %~dp0\..\..
+
+set WORKSPACE=T:\src\github\grpc-java
+set ESCWORKSPACE=%WORKSPACE:\=\\%
+
+@rem Clear JAVA_HOME to prevent a different Java version from being used
+set JAVA_HOME=
+
+mkdir grpc-java-helper64
+cd grpc-java-helper64
+call "%VS170COMNTOOLS%\..\..\VC\Auxiliary\Build\vcvars64.bat" || exit /b 1
+call "%WORKSPACE%\buildscripts\make_dependencies.bat" || exit /b 1
+
+cd "%WORKSPACE%"
+
+SET TARGET_ARCH=x86_64
+SET FAIL_ON_WARNINGS=true
+SET PROTOBUF_VER=33.4
+SET PKG_CONFIG_PATH=%ESCWORKSPACE%\\grpc-java-helper64\\protobuf-%PROTOBUF_VER%\\build\\protobuf-%PROTOBUF_VER%\\lib\\pkgconfig
+SET VC_PROTOBUF_LIBS=/LIBPATH:%ESCWORKSPACE%\\grpc-java-helper64\\protobuf-%PROTOBUF_VER%\\build\\protobuf-%PROTOBUF_VER%\\lib
+SET VC_PROTOBUF_INCLUDE=%ESCWORKSPACE%\\grpc-java-helper64\\protobuf-%PROTOBUF_VER%\\build\\protobuf-%PROTOBUF_VER%\\include
+call :Get_Libs
+SET GRADLE_FLAGS=-PtargetArch=%TARGET_ARCH% -PfailOnWarnings=%FAIL_ON_WARNINGS% -PvcProtobufLibs=%VC_PROTOBUF_LIBS% -PvcProtobufInclude=%VC_PROTOBUF_INCLUDE% -PskipAndroid=true
+SET GRADLE_OPTS="-Dorg.gradle.jvmargs='-Xmx1g'"
+
+@rem make sure no daemons have any files open
+cmd.exe /C "%WORKSPACE%\gradlew.bat --stop"
+
+cmd.exe /C "%WORKSPACE%\gradlew.bat  %GRADLE_FLAGS% -Dorg.gradle.parallel=false -PrepositoryDir=%WORKSPACE%\artifacts grpc-compiler:clean grpc-compiler:build grpc-compiler:publish" || exit /b 1
+
+goto :eof
+:Get_Libs
+SetLocal EnableDelayedExpansion
+set "libs_list="
+for /f "tokens=*" %%a in ('pkg-config --libs protobuf') do (
+  for %%b in (%%a) do (
+    set lib=%%b
+    set libfirst2char=!lib:~0,2!
+    if !libfirst2char!==-l (
+      @rem remove the leading -l
+      set lib=!lib:~2!
+      @rem remove spaces
+      set lib=!lib: =!
+      set libprefix=!lib:~0,4!
+      if !libprefix!==absl (
+        set lib=!lib!.lib
+      ) else (
+        set lib=lib!lib!.lib
+      )
+      if "!libs_list!"=="" (
+        set libs_list=!lib!
+      ) else (
+        set libs_list=!libs_list!,!lib!
+      )
+    )
+  )
+)
+EndLocal & set "VC_PROTOBUF_LIBS=%VC_PROTOBUF_LIBS%,%libs_list%" 
+exit /b 0
+
diff --git a/buildscripts/kokoro/xds_k8s_lb.cfg b/buildscripts/kokoro/xds_k8s_lb.cfg
new file mode 100644
index 00000000000..4dab80bf76e
--- /dev/null
+++ b/buildscripts/kokoro/xds_k8s_lb.cfg
@@ -0,0 +1,17 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/psm-interop-test-java.sh"
+timeout_mins: 300
+
+action {
+  define_artifacts {
+    regex: "artifacts/**/*sponge_log.xml"
+    regex: "artifacts/**/*.log"
+    strip_prefix: "artifacts"
+  }
+}
+env_vars {
+  key: "PSM_TEST_SUITE"
+  value: "lb"
+}
diff --git a/buildscripts/kokoro/xds_url_map.cfg b/buildscripts/kokoro/xds_url_map.cfg
new file mode 100644
index 00000000000..3e27164fe26
--- /dev/null
+++ b/buildscripts/kokoro/xds_url_map.cfg
@@ -0,0 +1,17 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/psm-interop-test-java.sh"
+timeout_mins: 90
+
+action {
+  define_artifacts {
+    regex: "artifacts/**/*sponge_log.xml"
+    regex: "artifacts/**/*.log"
+    strip_prefix: "artifacts"
+  }
+}
+env_vars {
+  key: "PSM_TEST_SUITE"
+  value: "url_map"
+}
diff --git a/buildscripts/kokoro/xds_v3.cfg b/buildscripts/kokoro/xds_v3.cfg
new file mode 100644
index 00000000000..fc2fe34e064
--- /dev/null
+++ b/buildscripts/kokoro/xds_v3.cfg
@@ -0,0 +1,11 @@
+# Config file for internal CI
+
+# Location of the continuous shell script in repository.
+build_file: "grpc-java/buildscripts/kokoro/xds_v3.sh"
+timeout_mins: 360
+action {
+  define_artifacts {
+    regex: "**/*sponge_log.*"
+    regex: "github/grpc/reports/**"
+  }
+}
diff --git a/buildscripts/kokoro/xds_v3.sh b/buildscripts/kokoro/xds_v3.sh
new file mode 100755
index 00000000000..8c879e1095b
--- /dev/null
+++ b/buildscripts/kokoro/xds_v3.sh
@@ -0,0 +1,34 @@
+#!/bin/bash
+
+set -exu -o pipefail
+if [[ -f /VERSION ]]; then
+  cat /VERSION
+fi
+
+cd github
+
+pushd grpc-java/interop-testing
+GRADLE_OPTS="-Dorg.gradle.jvmargs='-Xmx1g'" \
+  ../gradlew installDist -x test -PskipCodegen=true -PskipAndroid=true
+popd
+
+git clone -b master --single-branch --depth=1 https://github.com/grpc/grpc.git
+
+grpc/tools/run_tests/helper_scripts/prep_xds.sh
+
+JAVA_OPTS=-Djava.util.logging.config.file=grpc-java/buildscripts/xds_logging.properties \
+  python3 grpc/tools/run_tests/run_xds_tests.py \
+    --test_case="ping_pong,circuit_breaking" \
+    --project_id=grpc-testing \
+    --project_num=830293263384 \
+    --source_image=projects/grpc-testing/global/images/xds-test-server-5 \
+    --path_to_server_binary=/java_server/grpc-java/interop-testing/build/install/grpc-interop-testing/bin/xds-test-server \
+    --gcp_suffix=$(date '+%s') \
+    --verbose \
+    --xds_v3_support \
+    --client_cmd="grpc-java/interop-testing/build/install/grpc-interop-testing/bin/xds-test-client \
+      --server=xds:///{server_uri} \
+      --stats_port={stats_port} \
+      --qps={qps} \
+      {rpcs_to_send} \
+      {metadata_to_send}"
diff --git a/buildscripts/make_dependencies.bat b/buildscripts/make_dependencies.bat
index 7ba394a95d1..a11f84d998e 100644
--- a/buildscripts/make_dependencies.bat
+++ b/buildscripts/make_dependencies.bat
@@ -1,43 +1,65 @@
-REM installer http://www.7-zip.org/a/7z1507-x64.exe
-REM 7za is in http://www.7-zip.org/a/7z1507-extra.7z
+choco install -y pkgconfiglite
+choco install -y openjdk --version=17.0
+set PATH=%PATH%;"c:\Program Files\OpenJDK\jdk-17\bin"
+set PROTOBUF_VER=33.4
+set ABSL_VERSION=20250127.1
+set CMAKE_NAME=cmake-3.26.3-windows-x86_64
 
-REM Prerequisite:
-REM   7za.exe in current directory or PATH
-
-set PROTOBUF_VER=3.2.0
-set CMAKE_NAME=cmake-3.3.2-win32-x86
-
-if not exist "protobuf-%PROTOBUF_VER%\cmake\build\Release\" (
-  call :installProto
+if not exist "protobuf-%PROTOBUF_VER%\build\Release\" (
+  call :installProto || exit /b 1
 )
 
 echo Compile gRPC-Java with something like:
-echo -PtargetArch=x86_32 -PvcProtobufLibs=%cd%\protobuf-%PROTOBUF_VER%\cmake\build\Release -PvcProtobufInclude=%cd%\protobuf-%PROTOBUF_VER%\cmake\build\include
+echo -PtargetArch=x86_32 -PvcProtobufLibPath=%cd%\protobuf-%PROTOBUF_VER%\build\protobuf-%PROTOBUF_VER%\lib -PvcProtobufInclude=%cd%\protobuf-%PROTOBUF_VER%\build\protobuf-%PROTOBUF_VER%\include -PvcProtobufLibs=insert-list-of-libs-from-pkg-config-output-here
 goto :eof
 
 
 :installProto
 
+where /q cmake
+if not ERRORLEVEL 1 goto :hasCmake
 if not exist "%CMAKE_NAME%" (
-  call :installCmake
+  call :installCmake || exit /b 1
 )
 set PATH=%PATH%;%cd%\%CMAKE_NAME%\bin
-powershell -command "& { iwr https://github.com/google/protobuf/archive/v%PROTOBUF_VER%.zip -OutFile protobuf.zip }"
-7za X protobuf.zip
+:hasCmake
+@rem GitHub requires TLSv1.2, and for whatever reason our powershell doesn't have it enabled
+powershell -command "$ProgressPreference = 'SilentlyContinue'; $ErrorActionPreference = 'stop'; & { [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12 ; iwr https://github.com/google/protobuf/releases/download/v%PROTOBUF_VER%/protobuf-%PROTOBUF_VER%.zip -OutFile protobuf.zip }" || exit /b 1
+powershell -command "$ErrorActionPreference = 'stop'; & { Add-Type -AssemblyName System.IO.Compression.FileSystem; [System.IO.Compression.ZipFile]::ExtractToDirectory('protobuf.zip', '.') }" || exit /b 1
 del protobuf.zip
-pushd protobuf-%PROTOBUF_VER%\cmake
-mkdir build
-cd build
-cmake -Dprotobuf_BUILD_TESTS=OFF -G "Visual Studio %VisualStudioVersion:~0,2%" ..
-msbuild /maxcpucount /p:Configuration=Release libprotoc.vcxproj
-call extract_includes.bat
+powershell -command "$ProgressPreference = 'SilentlyContinue'; $ErrorActionPreference = 'stop'; & { [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12 ; iwr https://github.com/abseil/abseil-cpp/archive/refs/tags/%ABSL_VERSION%.zip -OutFile absl.zip }" || exit /b 1
+powershell -command "$ErrorActionPreference = 'stop'; & { Add-Type -AssemblyName System.IO.Compression.FileSystem; [System.IO.Compression.ZipFile]::ExtractToDirectory('absl.zip', '.') }" || exit /b 1
+del absl.zip
+move abseil-cpp-%ABSL_VERSION% protobuf-%PROTOBUF_VER%\third_party\abseil-cpp
+mkdir protobuf-%PROTOBUF_VER%\build
+pushd protobuf-%PROTOBUF_VER%\build
+
+@rem cmake does not detect x86_64 from the vcvars64.bat variables.
+@rem If vcvars64.bat has set PLATFORM to X64, then inform cmake to use the Win64 version of VS, likewise for x32
+if "%PLATFORM%" == "x64" (
+  SET CMAKE_VSARCH=-A x64
+) else if "%PLATFORM%" == "x86" (
+  @rem -A x86 doesn't work: https://github.com/microsoft/vcpkg/issues/15465
+  SET CMAKE_VSARCH=-DCMAKE_GENERATOR_PLATFORM=WIN32
+) else (
+  SET CMAKE_VSARCH=
+)
+for /f "tokens=4 delims=\" %%a in ("%VCINSTALLDIR%") do (
+  SET VC_YEAR=%%a
+)
+for /f "tokens=1 delims=." %%a in ("%VisualStudioVersion%") do (
+  SET visual_studio_major_version=%%a
+)
+cmake -DCMAKE_CXX_STANDARD=17 -DABSL_MSVC_STATIC_RUNTIME=ON -Dprotobuf_BUILD_TESTS=OFF -DCMAKE_INSTALL_PREFIX=%cd%\protobuf-%PROTOBUF_VER% -DCMAKE_PREFIX_PATH=%cd%\protobuf-%PROTOBUF_VER% -G "Visual Studio %visual_studio_major_version% %VC_YEAR%" %CMAKE_VSARCH% .. || exit /b 1
+cmake --build . --config Release --target install || exit /b 1
 popd
 goto :eof
 
 
 :installCmake
 
-powershell -command "& { iwr https://cmake.org/files/v3.3/%CMAKE_NAME%.zip -OutFile cmake.zip }"
-7za X cmake.zip
+powershell -command "$ErrorActionPreference = 'stop'; & { iwr https://cmake.org/files/v3.3/%CMAKE_NAME%.zip -OutFile cmake.zip }" || exit /b 1
+powershell -command "$ErrorActionPreference = 'stop'; & { Add-Type -AssemblyName System.IO.Compression.FileSystem; [System.IO.Compression.ZipFile]::ExtractToDirectory('cmake.zip', '.') }" || exit /b 1
 del cmake.zip
 goto :eof
+
diff --git a/buildscripts/make_dependencies.sh b/buildscripts/make_dependencies.sh
index 659980795da..8cbefddd2eb 100755
--- a/buildscripts/make_dependencies.sh
+++ b/buildscripts/make_dependencies.sh
@@ -1,11 +1,75 @@
 #!/bin/bash
 #
 # Build protoc
-set -ev
+set -evux -o pipefail
 
+PROTOBUF_VERSION=33.4
+ABSL_VERSION=20250127.1
+
+# ARCH is x86_64 bit unless otherwise specified.
+ARCH="${ARCH:-x86_64}"
 DOWNLOAD_DIR=/tmp/source
-INSTALL_DIR="/tmp/protobuf-$PROTOBUF_VERSION/$(uname -s)-$(uname -p)"
+INSTALL_DIR="/tmp/protobuf-cache/$PROTOBUF_VERSION/$(uname -s)-$ARCH"
+BUILDSCRIPTS_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+function build_and_install() {
+  if [[ "$1" == "abseil" ]]; then
+    TESTS_OFF_ARG=ABSL_BUILD_TEST_HELPERS
+  else
+    TESTS_OFF_ARG=protobuf_BUILD_TESTS  
+  fi
+  if [[ "$(uname -s)" == "Darwin" ]]; then
+    cmake .. \
+      -DCMAKE_CXX_STANDARD=17 -D${TESTS_OFF_ARG}=OFF -DBUILD_SHARED_LIBS=OFF \
+      -DCMAKE_INSTALL_PREFIX="$INSTALL_DIR" \
+      -DCMAKE_PREFIX_PATH="$INSTALL_DIR" \
+      -DCMAKE_OSX_ARCHITECTURES="arm64;x86_64" \
+      -B. || exit 1
+  elif [[ "$ARCH" == x86* ]]; then
+    CFLAGS=-m${ARCH#*_} CXXFLAGS=-m${ARCH#*_} cmake .. \
+      -DCMAKE_CXX_STANDARD=17 -D${TESTS_OFF_ARG}=OFF -DBUILD_SHARED_LIBS=OFF \
+      -DCMAKE_INSTALL_PREFIX="$INSTALL_DIR" \
+      -DCMAKE_PREFIX_PATH="$INSTALL_DIR" \
+      -B. || exit 1
+  else
+    if [[ "$ARCH" == aarch_64 ]]; then
+      GCC_ARCH=aarch64-linux-gnu
+    elif [[ "$ARCH" == ppcle_64 ]]; then
+      GCC_ARCH=powerpc64le-linux-gnu
+    elif [[ "$ARCH" == s390_64 ]]; then
+      GCC_ARCH=s390x-linux-gnu
+    elif [[ "$ARCH" == loongarch_64 ]]; then
+      GCC_ARCH=loongarch64-unknown-linux-gnu
+    else
+      echo "Unknown architecture: $ARCH"
+      exit 1
+    fi
+    cmake .. \
+      -DCMAKE_CXX_STANDARD=17 -D${TESTS_OFF_ARG}=OFF -DBUILD_SHARED_LIBS=OFF \
+      -DCMAKE_INSTALL_PREFIX="$INSTALL_DIR" \
+      -DCMAKE_PREFIX_PATH="$INSTALL_DIR" \
+      -Dcrosscompile_ARCH="$GCC_ARCH" \
+      -DCMAKE_TOOLCHAIN_FILE=$BUILDSCRIPTS_DIR/toolchain.cmake \
+      -B. || exit 1
+  fi
+  export CMAKE_BUILD_PARALLEL_LEVEL="$NUM_CPU"
+  cmake --build . || exit 1
+  # install here so we don't need sudo
+  cmake --install . || exit 1
+}
+
 mkdir -p $DOWNLOAD_DIR
+cd "$DOWNLOAD_DIR"
+
+# Start with a sane default
+NUM_CPU=4
+if [[ $(uname) == 'Linux' ]]; then
+    NUM_CPU=$(nproc)
+fi
+if [[ $(uname) == 'Darwin' ]]; then
+    NUM_CPU=$(sysctl -n hw.ncpu)
+fi
+export CMAKE_BUILD_PARALLEL_LEVEL="$NUM_CPU"
 
 # Make protoc
 # Can't check for presence of directory as cache auto-creates it.
@@ -13,13 +77,39 @@ if [ -f ${INSTALL_DIR}/bin/protoc ]; then
   echo "Not building protobuf. Already built"
 # TODO(ejona): swap to `brew install --devel protobuf` once it is up-to-date
 else
-  wget -O - https://github.com/google/protobuf/archive/v${PROTOBUF_VERSION}.tar.gz | tar xz -C $DOWNLOAD_DIR
-  pushd $DOWNLOAD_DIR/protobuf-${PROTOBUF_VERSION}
-  ./autogen.sh
-  # install here so we don't need sudo
-  ./configure --prefix="$INSTALL_DIR"
-  make -j$(nproc)
-  make install
+  if [[ ! -d "protobuf-${PROTOBUF_VERSION}" ]]; then
+    curl -Ls "https://github.com/google/protobuf/releases/download/v${PROTOBUF_VERSION}/protobuf-${PROTOBUF_VERSION}.tar.gz" | tar xz
+    curl -Ls "https://github.com/abseil/abseil-cpp/archive/refs/tags/${ABSL_VERSION}.tar.gz" | tar xz
+  fi
+  # the same source dir is used for 32 and 64 bit builds, so we need to clean stale data first
+  rm -rf "$DOWNLOAD_DIR/abseil-cpp-${ABSL_VERSION}/build"
+  mkdir "$DOWNLOAD_DIR/abseil-cpp-${ABSL_VERSION}/build"
+  pushd "$DOWNLOAD_DIR/abseil-cpp-${ABSL_VERSION}/build"
+  build_and_install "abseil"
+  popd 
+  
+  rm -rf "$DOWNLOAD_DIR/protobuf-${PROTOBUF_VERSION}/build"
+  mkdir "$DOWNLOAD_DIR/protobuf-${PROTOBUF_VERSION}/build"
+  pushd "$DOWNLOAD_DIR/protobuf-${PROTOBUF_VERSION}/build"
+  build_and_install "protobuf"
   popd
+  
+  [ -d "$INSTALL_DIR/lib64" ] && mv "$INSTALL_DIR/lib64" "$INSTALL_DIR/lib"  
+fi
+
+# If /tmp/protobuf exists then we just assume it's a symlink created by us.
+# It may be that it points to the wrong arch, so we idempotently set it now.
+if [[ -L /tmp/protobuf ]]; then
+  rm /tmp/protobuf
 fi
+ln -s "$INSTALL_DIR" /tmp/protobuf
+
+cat <<EOF
+To compile with the build dependencies:
+
+export LDFLAGS="$(PKG_CONFIG_PATH=/tmp/protobuf/lib/pkgconfig pkg-config --libs protobuf)"
+export CXXFLAGS="$(PKG_CONFIG_PATH=/tmp/protobuf/lib/pkgconfig pkg-config --cflags protobuf)"
+export LIBRARY_PATH=/tmp/protobuf/lib
+export LD_LIBRARY_PATH=/tmp/protobuf/lib
+EOF
 
diff --git a/buildscripts/observability-test/Dockerfile b/buildscripts/observability-test/Dockerfile
new file mode 100644
index 00000000000..82d21f78263
--- /dev/null
+++ b/buildscripts/observability-test/Dockerfile
@@ -0,0 +1,51 @@
+# Copyright 2023 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.
+
+
+#
+# Stage 1: Build the interop test client and server
+#
+
+FROM eclipse-temurin:11-jdk AS build
+
+WORKDIR /grpc-java
+COPY . .
+
+RUN ./gradlew :grpc-gcp-observability:interop:installDist -PskipCodegen=true -PskipAndroid=true
+
+
+#
+# Stage 2:
+#
+# - Copy only the necessary files to reduce Docker image size.
+# - Have an ENTRYPOINT script which will launch the interop test client or server
+#   with the given parameters.
+#
+
+FROM eclipse-temurin:11-jre
+
+WORKDIR /grpc-java/
+COPY --from=build /grpc-java/gcp-observability/interop/build/install/interop/. .
+
+WORKDIR /grpc-java/buildscripts/observability-test
+COPY --from=build /grpc-java/buildscripts/observability-test/run.sh .
+
+# Intentionally after the app COPY to force the update on each build.
+# Update Ubuntu system packages:
+RUN apt-get update \
+    && apt-get -y upgrade \
+    && apt-get -y autoremove \
+    && rm -rf /var/lib/apt/lists/*
+
+ENTRYPOINT ["/grpc-java/buildscripts/observability-test/run.sh"]
diff --git a/buildscripts/observability-test/build_docker.sh b/buildscripts/observability-test/build_docker.sh
new file mode 100755
index 00000000000..66a63386c3d
--- /dev/null
+++ b/buildscripts/observability-test/build_docker.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+# Copyright 2023 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.
+
+set -ex
+cd "$(dirname "$0")"/../..
+
+# Environment Variables:
+#
+# TAG_NAME: the docker image tag name
+#
+
+echo Building ${TAG_NAME}
+
+docker build --no-cache -t ${TAG_NAME} -f ./buildscripts/observability-test/Dockerfile .
diff --git a/buildscripts/observability-test/run.sh b/buildscripts/observability-test/run.sh
new file mode 100755
index 00000000000..efbd29c1a1e
--- /dev/null
+++ b/buildscripts/observability-test/run.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+# Copyright 2023 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.
+
+set -ex
+cd "$(dirname "$0")"/../..
+
+if [ "$1" = "server" ] ; then
+  /grpc-java/bin/gcp-observability-interop server --use_tls=false "${@:2}"
+
+elif [ "$1" = "client" ] ; then
+  /grpc-java/bin/gcp-observability-interop client --use_tls=false "${@:2}"
+
+else
+  echo "Invalid action: $1. Usage:"
+  echo "  $ .../run.sh [server|client] --server_host=<hostname> --server_port=<port> ..."
+  exit 1
+fi
diff --git a/buildscripts/run_in_docker.sh b/buildscripts/run_in_docker.sh
new file mode 100755
index 00000000000..60af68f3bec
--- /dev/null
+++ b/buildscripts/run_in_docker.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+set -eu -o pipefail
+
+quote() {
+  local arg
+  for arg in "$@"; do
+    printf "'"
+    printf "%s" "$arg" | sed -e "s/'/'\\\\''/g"
+    printf "' "
+  done
+}
+
+readonly docker_image=$1; shift
+
+readonly grpc_java_dir="$(dirname "$(readlink -f "$0")")/.."
+if [[ -t 0 ]]; then
+  DOCKER_ARGS="-it"
+else
+  # The input device on kokoro is not a TTY, so -it does not work.
+  DOCKER_ARGS=
+fi
+# Use a trap function to fix file permissions upon exit, without affecting
+# the original exit code. $DOCKER_ARGS can not be quoted, otherwise it becomes a '' which confuses
+# docker.
+exec docker run $DOCKER_ARGS --rm=true -v "${grpc_java_dir}":/grpc-java -w /grpc-java \
+  $docker_image \
+  bash -c "function fixFiles() { chown -R $(id -u):$(id -g) /grpc-java; }; trap fixFiles EXIT; $(quote "$@")"
diff --git a/buildscripts/sign-local-repo.sh b/buildscripts/sign-local-repo.sh
new file mode 100755
index 00000000000..e2377c49ab8
--- /dev/null
+++ b/buildscripts/sign-local-repo.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+# Copyright 2017 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.
+
+set -e
+
+if [ $# -ne 1 ]; then
+  cat <<EOF
+Usage: $0 DIR
+  DIR Local repository with files needing to be signed
+EOF
+  exit 1
+fi
+
+find "$1" -type f | egrep -v '\.(md5|sha1)$' | grep -v maven-metadata.xml | xargs gpg -ab
diff --git a/buildscripts/sonatype-upload.sh b/buildscripts/sonatype-upload.sh
new file mode 100755
index 00000000000..4baa4e46ca0
--- /dev/null
+++ b/buildscripts/sonatype-upload.sh
@@ -0,0 +1,125 @@
+#!/bin/bash
+# Copyright 2017 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.
+
+set -eu -o pipefail
+
+if [ $# -ne 2 ]; then
+  cat <<EOF
+Usage: $0 PROFILEID DIR
+  PROFILEID The Sonatype profile to use for staging repository
+            Obtain profile ID from https://oss.sonatype.org:
+             * Build Promotion > Staging Profiles
+             * Select profile based on name (e.g., 'io.grpc')
+             * Copy hex identifier from URL after "#stagingProfiles;"
+  DIR       Directory to upload to Sonatype as a new staging repository
+
+~/.config/sonatype-upload: Configuration file for Sonatype username and password
+  USERNAME=yourusername
+  PASSWORD=yourpass
+
+Sonatype provides a "user token" that is a randomly generated username/password.
+It does allow access to your account, however. You can create one via:
+ * Log in to https://oss.sonatype.org
+ * Click your username at the top right and click to Profile
+ * Change the drop-down from "Summary" to "User Token"
+ * Click "Access User Token"
+EOF
+  exit 1
+fi
+
+PROFILE_ID="$1"
+DIR="$2"
+if [ -z "$DIR" ]; then
+  echo "Must specify non-empty directory name"
+  exit 1
+fi
+
+CONF="$HOME/.config/sonatype-upload"
+[ -f "$CONF" ] && . "$CONF"
+
+USERNAME="${USERNAME:-}"
+PASSWORD="${PASSWORD:-}"
+
+if [ -z "$USERNAME" -o -z "$PASSWORD" ]; then
+  # TODO(ejona86): if people would use it, could prompt for values to avoid
+  # having passwords in plain-text.
+  echo "You must create '$CONF' with keys USERNAME and PASSWORD" >&2
+  exit 1
+fi
+
+STAGING_URL="https://ossrh-staging-api.central.sonatype.com/service/local/staging"
+
+# We go through the effort of using deloyByRepositoryId/ because it is
+# _substantially_ faster to upload files than deploy/maven2/. When using
+# deploy/maven2/ a repository is implicitly created, but the response doesn't
+# provide its name.
+
+USERPASS="$USERNAME:$PASSWORD"
+
+# https://oss.sonatype.org/nexus-staging-plugin/default/docs/index.html
+#
+# Example returned data:
+#   <promoteResponse>
+#     <data>
+#       <stagedRepositoryId>iogrpc-1082</stagedRepositoryId>
+#       <description>Release upload</description>
+#     </data>
+#   </promoteResponse>
+echo "Creating staging repo"
+REPOID="$(
+  XML="
+  <promoteRequest>
+    <data>
+      <description>Release upload</description>
+    </data>
+  </promoteRequest>"
+  curl -f -s -X POST -d "$XML" -u "$USERPASS" -H "Content-Type: application/xml" \
+    "$STAGING_URL/profiles/$PROFILE_ID/start" |
+  grep stagedRepositoryId |
+  sed 's/.*<stagedRepositoryId>\(.*\)<\/stagedRepositoryId>.*/\1/'
+  )"
+echo "Repository id: $REPOID"
+
+for X in $(cd "$DIR" && find -type f | cut -b 3-); do
+  echo "Uploading $X"
+  curl --fail-with-body -T "$DIR/$X" -u "$USERPASS" -H "Content-Type: application/octet-stream" \
+    "$STAGING_URL/deployByRepositoryId/$REPOID/$X"
+done
+
+echo "Closing staging repo"
+XML="
+<promoteRequest>
+  <data>
+    <stagedRepositoryId>$REPOID</stagedRepositoryId>
+    <description>Auto-close via upload script</description>
+  </data>
+</promoteRequest>"
+curl --fail-with-body -X POST -d "$XML" -u "$USERPASS" -H "Content-Type: application/xml" \
+  "$STAGING_URL/profiles/$PROFILE_ID/finish"
+
+# TODO (okshiva): After 2-3 releases make it automatic.
+# After closing the repository on the staging API, we must manually trigger
+# its upload to the main Central Publisher Portal. We set publishing_type=automatic
+# to have it release automatically upon passing validation.
+# echo "Triggering release of repository ${REPOID} to the Central Portal"
+
+# MANUAL_API_URL="https://ossrh-staging-api.central.sonatype.com/service/local/manual"
+
+#curl --fail-with-body -X POST \
+#  -H "Authorization: Bearer ${USERPASS}" \
+#  -H "Content-Type: application/json" \
+#  "${MANUAL_API_URL}/upload/repository/${REPOID}?publishing_type=automatic"
+
+# echo "Release triggered. Monitor progress at https://central.sonatype.com/publishing/deployments"
diff --git a/buildscripts/sync-protos.sh b/buildscripts/sync-protos.sh
new file mode 100755
index 00000000000..5f01be2e5c9
--- /dev/null
+++ b/buildscripts/sync-protos.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+set -e
+
+cd "$(dirname "$0")/.."
+
+tmpdir="$(mktemp -d)"
+curl -Ls https://github.com/grpc/grpc-proto/archive/master.tar.gz | tar xz -C "$tmpdir"
+base="$tmpdir/grpc-proto-master"
+
+# Copy protos in 'src/main/proto' from grpc-proto for these projects
+for project in alts grpclb services rls interop-testing; do
+  while read -r proto; do
+    [ -f "$base/$proto" ] && cp "$base/$proto" "$project/src/main/proto/$proto"
+    echo "$proto"
+  done < <(cd "$project/src/main/proto" && find . -name "*.proto")
+done | sort > "$tmpdir/grpc-java.lst"
+
+(cd "$base" && find . -name "*.proto") | sort > "$tmpdir/base.lst"
+echo "Files synced:"
+comm -12 "$tmpdir/grpc-java.lst" "$tmpdir/base.lst"
+
+echo
+echo "Files in grpc-proto not synced:"
+comm -13 "$tmpdir/grpc-java.lst" "$tmpdir/base.lst"
+
+echo
+echo "Files in grpc-java not synced:"
+comm -23 "$tmpdir/grpc-java.lst" "$tmpdir/base.lst"
+
+rm -r "$tmpdir"
diff --git a/buildscripts/toolchain.cmake b/buildscripts/toolchain.cmake
new file mode 100644
index 00000000000..b71515cebda
--- /dev/null
+++ b/buildscripts/toolchain.cmake
@@ -0,0 +1,9 @@
+set(CMAKE_SYSTEM_NAME Linux)
+
+set(CMAKE_C_COMPILER   "${crosscompile_ARCH}-gcc")
+set(CMAKE_CXX_COMPILER "${crosscompile_ARCH}-g++")
+set(CMAKE_FIND_ROOT_PATH "/usr/${crosscompile_ARCH}/")
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
diff --git a/buildscripts/xds-k8s/cloudbuild.yaml b/buildscripts/xds-k8s/cloudbuild.yaml
new file mode 100644
index 00000000000..ad4e8049e22
--- /dev/null
+++ b/buildscripts/xds-k8s/cloudbuild.yaml
@@ -0,0 +1,26 @@
+steps:
+- name: 'gcr.io/cloud-builders/docker'
+  args:
+    - 'build'
+    - '--tag=${_SERVER_IMAGE_NAME}:${COMMIT_SHA}'
+    - '--tag=${_SERVER_IMAGE_NAME}:${BRANCH_NAME}'
+    - '--file=test-server.Dockerfile'
+    - '.'
+
+- name: 'gcr.io/cloud-builders/docker'
+  args:
+    - 'build'
+    - '--tag=${_CLIENT_IMAGE_NAME}:${COMMIT_SHA}'
+    - '--tag=${_CLIENT_IMAGE_NAME}:${BRANCH_NAME}'
+    - '--file=test-client.Dockerfile'
+    - '.'
+
+substitutions:
+  _SERVER_IMAGE_NAME: us-docker.pkg.dev/grpc-testing/psm-interop/java-server
+  _CLIENT_IMAGE_NAME: us-docker.pkg.dev/grpc-testing/psm-interop/java-client
+
+images:
+  - '${_SERVER_IMAGE_NAME}:${COMMIT_SHA}'
+  - '${_SERVER_IMAGE_NAME}:${BRANCH_NAME}'
+  - '${_CLIENT_IMAGE_NAME}:${COMMIT_SHA}'
+  - '${_CLIENT_IMAGE_NAME}:${BRANCH_NAME}'
diff --git a/buildscripts/xds-k8s/logging-debug.properties b/buildscripts/xds-k8s/logging-debug.properties
new file mode 100644
index 00000000000..8b0e3276d07
--- /dev/null
+++ b/buildscripts/xds-k8s/logging-debug.properties
@@ -0,0 +1,7 @@
+handlers=java.util.logging.ConsoleHandler
+io.grpc.ChannelLogger.level=FINEST
+io.grpc.level=FINEST
+io.netty.level=FINEST
+java.util.logging.ConsoleHandler.level=ALL
+java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
+java.util.logging.SimpleFormatter.format=[%1$tF %1$tT.%1$tL %1tZ] [%4$-7s] [%3$s] %5$s %6$s %n
diff --git a/buildscripts/xds-k8s/logging-json.properties b/buildscripts/xds-k8s/logging-json.properties
new file mode 100644
index 00000000000..62ca9551667
--- /dev/null
+++ b/buildscripts/xds-k8s/logging-json.properties
@@ -0,0 +1,8 @@
+handlers=java.util.logging.ConsoleHandler
+java.util.logging.ConsoleHandler.level=FINEST
+java.util.logging.ConsoleHandler.formatter=io.github.devatherock.json.formatter.JSONFormatter
+io.github.devatherock.json.formatter.JSONFormatter.key_timestamp=time
+io.github.devatherock.json.formatter.JSONFormatter.key_log_level=severity
+io.github.devatherock.json.formatter.JSONFormatter.use_slf4j_level_names=true
+io.grpc.ChannelLogger.level=FINEST
+io.grpc.xds.level=FINEST
diff --git a/buildscripts/xds-k8s/logging.properties b/buildscripts/xds-k8s/logging.properties
new file mode 100644
index 00000000000..d7759dc60bf
--- /dev/null
+++ b/buildscripts/xds-k8s/logging.properties
@@ -0,0 +1,6 @@
+handlers=java.util.logging.ConsoleHandler
+io.grpc.ChannelLogger.level=FINEST
+io.grpc.xds.level=FINEST
+java.util.logging.ConsoleHandler.level=FINEST
+java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
+java.util.logging.SimpleFormatter.format=[%1$tF %1$tT.%1$tL %1tZ] [%4$-7s] [%3$s] %5$s %6$s %n
diff --git a/buildscripts/xds-k8s/test-client.Dockerfile b/buildscripts/xds-k8s/test-client.Dockerfile
new file mode 100644
index 00000000000..67fadb1302a
--- /dev/null
+++ b/buildscripts/xds-k8s/test-client.Dockerfile
@@ -0,0 +1,22 @@
+# Build runtime image.
+FROM eclipse-temurin:11-jre
+
+ENV APP_DIR=/usr/src/app
+WORKDIR $APP_DIR
+
+# Install the app
+COPY grpc-interop-testing/ $APP_DIR/
+
+# Copy all logging profiles, use json logging by default
+COPY logging*.properties $APP_DIR/
+ENV JAVA_OPTS="-Djava.util.logging.config.file=$APP_DIR/logging-json.properties"
+
+# Intentionally after the app COPY to force the update on each build.
+# Update Ubuntu system packages:
+RUN apt-get update \
+    && apt-get -y upgrade \
+    && apt-get -y autoremove \
+    && rm -rf /var/lib/apt/lists/*
+
+# Client
+ENTRYPOINT ["bin/xds-test-client"]
diff --git a/buildscripts/xds-k8s/test-server.Dockerfile b/buildscripts/xds-k8s/test-server.Dockerfile
new file mode 100644
index 00000000000..e717b7dc526
--- /dev/null
+++ b/buildscripts/xds-k8s/test-server.Dockerfile
@@ -0,0 +1,22 @@
+# Build runtime image.
+FROM eclipse-temurin:11-jre
+
+ENV APP_DIR=/usr/src/app
+WORKDIR $APP_DIR
+
+# Install the app
+COPY grpc-interop-testing/ $APP_DIR/
+
+# Copy all logging profiles, use json logging by default
+COPY logging*.properties $APP_DIR/
+ENV JAVA_OPTS="-Djava.util.logging.config.file=$APP_DIR/logging-json.properties"
+
+# Intentionally after the app COPY to force the update on each build.
+# Update Ubuntu system packages:
+RUN apt-get update \
+    && apt-get -y upgrade \
+    && apt-get -y autoremove \
+    && rm -rf /var/lib/apt/lists/*
+
+# Server
+ENTRYPOINT ["bin/xds-test-server"]
diff --git a/buildscripts/xds_logging.properties b/buildscripts/xds_logging.properties
new file mode 100644
index 00000000000..3d06a62c567
--- /dev/null
+++ b/buildscripts/xds_logging.properties
@@ -0,0 +1,5 @@
+handlers=java.util.logging.ConsoleHandler
+io.grpc.ChannelLogger.level=FINEST
+io.grpc.xds.level=FINEST
+java.util.logging.ConsoleHandler.level=FINEST
+java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
diff --git a/census/BUILD.bazel b/census/BUILD.bazel
new file mode 100644
index 00000000000..f017eeaf8bd
--- /dev/null
+++ b/census/BUILD.bazel
@@ -0,0 +1,19 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "census",
+    srcs = glob([
+        "src/main/java/**/*.java",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api",
+        "//context",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+        artifact("io.opencensus:opencensus-api"),
+        artifact("io.opencensus:opencensus-contrib-grpc-metrics"),
+    ],
+)
diff --git a/census/build.gradle b/census/build.gradle
new file mode 100644
index 00000000000..c7cb02c15a0
--- /dev/null
+++ b/census/build.gradle
@@ -0,0 +1,46 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "ru.vyarus.animalsniffer"
+}
+
+description = 'gRPC: Census'
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.census')
+    }
+}
+
+dependencies {
+    api project(':grpc-api')
+    // force dependent jars to depend on latest grpc-context
+    runtimeOnly project(":grpc-context")
+    implementation libraries.guava,
+            project(":grpc-context"), // Override opencensus dependency with our newer version
+            libraries.opencensus.api,
+            libraries.opencensus.contrib.grpc.metrics
+
+    testImplementation testFixtures(project(':grpc-api')),
+            testFixtures(project(':grpc-core')),
+            project(':grpc-testing'),
+            libraries.opencensus.impl
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+tasks.named("javadoc").configure {
+    failOnError = false  // no public or protected classes found to document
+    exclude 'io/grpc/census/internal/**'
+    exclude 'io/grpc/census/Internal*'
+}
diff --git a/census/src/main/java/io/grpc/census/CensusStatsModule.java b/census/src/main/java/io/grpc/census/CensusStatsModule.java
new file mode 100644
index 00000000000..8f571ceb627
--- /dev/null
+++ b/census/src/main/java/io/grpc/census/CensusStatsModule.java
@@ -0,0 +1,822 @@
+/*
+ * Copyright 2016 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.census;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.census.internal.ObservabilityCensusConstants.API_LATENCY_PER_CALL;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ClientStreamTracer.StreamInfo;
+import io.grpc.Context;
+import io.grpc.Deadline;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.StreamTracer;
+import io.grpc.census.internal.DeprecatedCensusConstants;
+import io.opencensus.contrib.grpc.metrics.RpcMeasureConstants;
+import io.opencensus.stats.Measure;
+import io.opencensus.stats.Measure.MeasureDouble;
+import io.opencensus.stats.Measure.MeasureLong;
+import io.opencensus.stats.MeasureMap;
+import io.opencensus.stats.Stats;
+import io.opencensus.stats.StatsRecorder;
+import io.opencensus.tags.TagContext;
+import io.opencensus.tags.TagValue;
+import io.opencensus.tags.Tagger;
+import io.opencensus.tags.Tags;
+import io.opencensus.tags.propagation.TagContextBinarySerializer;
+import io.opencensus.tags.propagation.TagContextSerializationException;
+import io.opencensus.tags.unsafe.ContextUtils;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicLongFieldUpdater;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * Provides factories for {@link StreamTracer} that records stats to Census.
+ *
+ * <p>On the client-side, a factory is created for each call, and the factory creates a stream
+ * tracer for each attempt. If there is no stream created when the call is ended, we still create a
+ * tracer. It's the tracer that reports per-attempt stats, and the factory that reports the stats
+ * of the overall RPC, such as RETRIES_PER_CALL, to Census.
+ *
+ * <p>On the server-side, there is only one ServerStream per each ServerCall, and ServerStream
+ * starts earlier than the ServerCall.  Therefore, only one tracer is created per stream/call and
+ * it's the tracer that reports the summary to Census.
+ */
+final class CensusStatsModule {
+  private static final Logger logger = Logger.getLogger(CensusStatsModule.class.getName());
+  private static final double NANOS_PER_MILLI = TimeUnit.MILLISECONDS.toNanos(1);
+
+  private final Tagger tagger;
+  private final StatsRecorder statsRecorder;
+  private final Supplier<Stopwatch> stopwatchSupplier;
+  @VisibleForTesting
+  final Metadata.Key<TagContext> statsHeader;
+  private final boolean propagateTags;
+  private final boolean recordStartedRpcs;
+  private final boolean recordFinishedRpcs;
+  private final boolean recordRealTimeMetrics;
+  private final boolean recordRetryMetrics;
+
+  /**
+   * Creates a {@link CensusStatsModule} with the default OpenCensus implementation.
+   */
+  CensusStatsModule(Supplier<Stopwatch> stopwatchSupplier,
+      boolean propagateTags, boolean recordStartedRpcs, boolean recordFinishedRpcs,
+      boolean recordRealTimeMetrics, boolean recordRetryMetrics) {
+    this(
+        Tags.getTagger(),
+        Tags.getTagPropagationComponent().getBinarySerializer(),
+        Stats.getStatsRecorder(),
+        stopwatchSupplier,
+        propagateTags, recordStartedRpcs, recordFinishedRpcs, recordRealTimeMetrics,
+        recordRetryMetrics);
+  }
+
+  /**
+   * Creates a {@link CensusStatsModule} with the given OpenCensus implementation.
+   */
+  CensusStatsModule(
+      final Tagger tagger,
+      final TagContextBinarySerializer tagCtxSerializer,
+      StatsRecorder statsRecorder, Supplier<Stopwatch> stopwatchSupplier,
+      boolean propagateTags, boolean recordStartedRpcs, boolean recordFinishedRpcs,
+      boolean recordRealTimeMetrics, boolean recordRetryMetrics) {
+    this.tagger = checkNotNull(tagger, "tagger");
+    this.statsRecorder = checkNotNull(statsRecorder, "statsRecorder");
+    checkNotNull(tagCtxSerializer, "tagCtxSerializer");
+    this.stopwatchSupplier = checkNotNull(stopwatchSupplier, "stopwatchSupplier");
+    this.propagateTags = propagateTags;
+    this.recordStartedRpcs = recordStartedRpcs;
+    this.recordFinishedRpcs = recordFinishedRpcs;
+    this.recordRealTimeMetrics = recordRealTimeMetrics;
+    this.recordRetryMetrics = recordRetryMetrics;
+    this.statsHeader =
+        Metadata.Key.of("grpc-tags-bin", new Metadata.BinaryMarshaller<TagContext>() {
+            @Override
+            public byte[] toBytes(TagContext context) {
+              // TODO(carl-mastrangelo): currently we only make sure the correctness. We may need to
+              // optimize out the allocation and copy in the future.
+              try {
+                return tagCtxSerializer.toByteArray(context);
+              } catch (TagContextSerializationException e) {
+                throw new RuntimeException(e);
+              }
+            }
+
+            @Override
+            public TagContext parseBytes(byte[] serialized) {
+              try {
+                return tagCtxSerializer.fromByteArray(serialized);
+              } catch (Exception e) {
+                logger.log(Level.FINE, "Failed to parse stats header", e);
+                return tagger.empty();
+              }
+            }
+          });
+  }
+
+  /**
+   * Returns the server tracer factory.
+   */
+  ServerStreamTracer.Factory getServerTracerFactory() {
+    return new ServerTracerFactory();
+  }
+
+  /**
+   * Returns the client interceptor that facilitates Census-based stats reporting.
+   */
+  ClientInterceptor getClientInterceptor() {
+    return new StatsClientInterceptor();
+  }
+
+  private void recordRealTimeMetric(TagContext ctx, MeasureDouble measure, double value) {
+    if (recordRealTimeMetrics) {
+      MeasureMap measureMap = statsRecorder.newMeasureMap().put(measure, value);
+      measureMap.record(ctx);
+    }
+  }
+
+  private void recordRealTimeMetric(TagContext ctx, MeasureLong measure, long value) {
+    if (recordRealTimeMetrics) {
+      MeasureMap measureMap = statsRecorder.newMeasureMap().put(measure, value);
+      measureMap.record(ctx);
+    }
+  }
+
+  private static final class ClientTracer extends ClientStreamTracer {
+    @Nullable private static final AtomicLongFieldUpdater<ClientTracer> outboundMessageCountUpdater;
+    @Nullable private static final AtomicLongFieldUpdater<ClientTracer> inboundMessageCountUpdater;
+    @Nullable private static final AtomicLongFieldUpdater<ClientTracer> outboundWireSizeUpdater;
+    @Nullable private static final AtomicLongFieldUpdater<ClientTracer> inboundWireSizeUpdater;
+
+    @Nullable
+    private static final AtomicLongFieldUpdater<ClientTracer> outboundUncompressedSizeUpdater;
+
+    @Nullable
+    private static final AtomicLongFieldUpdater<ClientTracer> inboundUncompressedSizeUpdater;
+
+    /*
+     * When using Atomic*FieldUpdater, some Samsung Android 5.0.x devices encounter a bug in their
+     * JDK reflection API that triggers a NoSuchFieldException. When this occurs, we fallback to
+     * (potentially racy) direct updates of the volatile variables.
+     */
+    static {
+      AtomicLongFieldUpdater<ClientTracer> tmpOutboundMessageCountUpdater;
+      AtomicLongFieldUpdater<ClientTracer> tmpInboundMessageCountUpdater;
+      AtomicLongFieldUpdater<ClientTracer> tmpOutboundWireSizeUpdater;
+      AtomicLongFieldUpdater<ClientTracer> tmpInboundWireSizeUpdater;
+      AtomicLongFieldUpdater<ClientTracer> tmpOutboundUncompressedSizeUpdater;
+      AtomicLongFieldUpdater<ClientTracer> tmpInboundUncompressedSizeUpdater;
+      try {
+        tmpOutboundMessageCountUpdater =
+            AtomicLongFieldUpdater.newUpdater(ClientTracer.class, "outboundMessageCount");
+        tmpInboundMessageCountUpdater =
+            AtomicLongFieldUpdater.newUpdater(ClientTracer.class, "inboundMessageCount");
+        tmpOutboundWireSizeUpdater =
+            AtomicLongFieldUpdater.newUpdater(ClientTracer.class, "outboundWireSize");
+        tmpInboundWireSizeUpdater =
+            AtomicLongFieldUpdater.newUpdater(ClientTracer.class, "inboundWireSize");
+        tmpOutboundUncompressedSizeUpdater =
+            AtomicLongFieldUpdater.newUpdater(ClientTracer.class, "outboundUncompressedSize");
+        tmpInboundUncompressedSizeUpdater =
+            AtomicLongFieldUpdater.newUpdater(ClientTracer.class, "inboundUncompressedSize");
+      } catch (Throwable t) {
+        logger.log(Level.SEVERE, "Creating atomic field updaters failed", t);
+        tmpOutboundMessageCountUpdater = null;
+        tmpInboundMessageCountUpdater = null;
+        tmpOutboundWireSizeUpdater = null;
+        tmpInboundWireSizeUpdater = null;
+        tmpOutboundUncompressedSizeUpdater = null;
+        tmpInboundUncompressedSizeUpdater = null;
+      }
+      outboundMessageCountUpdater = tmpOutboundMessageCountUpdater;
+      inboundMessageCountUpdater = tmpInboundMessageCountUpdater;
+      outboundWireSizeUpdater = tmpOutboundWireSizeUpdater;
+      inboundWireSizeUpdater = tmpInboundWireSizeUpdater;
+      outboundUncompressedSizeUpdater = tmpOutboundUncompressedSizeUpdater;
+      inboundUncompressedSizeUpdater = tmpInboundUncompressedSizeUpdater;
+    }
+
+    final Stopwatch stopwatch;
+    final CallAttemptsTracerFactory attemptsState;
+    final AtomicBoolean inboundReceivedOrClosed = new AtomicBoolean();
+    final CensusStatsModule module;
+    final TagContext parentCtx;
+    final TagContext startCtx;
+    final StreamInfo info;
+    volatile long outboundMessageCount;
+    volatile long inboundMessageCount;
+    volatile long outboundWireSize;
+    volatile long inboundWireSize;
+    volatile long outboundUncompressedSize;
+    volatile long inboundUncompressedSize;
+    long roundtripNanos;
+    Code statusCode;
+
+    ClientTracer(
+        CallAttemptsTracerFactory attemptsState, CensusStatsModule module, TagContext parentCtx,
+        TagContext startCtx, StreamInfo info) {
+      this.attemptsState = attemptsState;
+      this.module = module;
+      this.parentCtx = parentCtx;
+      this.startCtx = startCtx;
+      this.info = info;
+      this.stopwatch = module.stopwatchSupplier.get().start();
+    }
+
+    @Override
+    public void streamCreated(Attributes transportAttrs, Metadata headers) {
+      if (module.propagateTags) {
+        headers.discardAll(module.statsHeader);
+        if (!module.tagger.empty().equals(parentCtx)) {
+          headers.put(module.statsHeader, parentCtx);
+        }
+      }
+    }
+
+    @Override
+    @SuppressWarnings({"NonAtomicVolatileUpdate", "NonAtomicOperationOnVolatileField"})
+    public void outboundWireSize(long bytes) {
+      if (outboundWireSizeUpdater != null) {
+        outboundWireSizeUpdater.getAndAdd(this, bytes);
+      } else {
+        outboundWireSize += bytes;
+      }
+      module.recordRealTimeMetric(
+          startCtx, RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_METHOD, (double) bytes);
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void inboundWireSize(long bytes) {
+      if (inboundWireSizeUpdater != null) {
+        inboundWireSizeUpdater.getAndAdd(this, bytes);
+      } else {
+        inboundWireSize += bytes;
+      }
+      module.recordRealTimeMetric(
+          startCtx, RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_METHOD, (double) bytes);
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void outboundUncompressedSize(long bytes) {
+      if (outboundUncompressedSizeUpdater != null) {
+        outboundUncompressedSizeUpdater.getAndAdd(this, bytes);
+      } else {
+        outboundUncompressedSize += bytes;
+      }
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void inboundUncompressedSize(long bytes) {
+      if (inboundUncompressedSizeUpdater != null) {
+        inboundUncompressedSizeUpdater.getAndAdd(this, bytes);
+      } else {
+        inboundUncompressedSize += bytes;
+      }
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void inboundMessage(int seqNo) {
+      if (inboundReceivedOrClosed.compareAndSet(false, true)) {
+        // Because inboundUncompressedSize() might be called after streamClosed(),
+        // we will report stats in callEnded(). Note that this attempt is already committed.
+        attemptsState.inboundMetricTracer = this;
+      }
+      if (inboundMessageCountUpdater != null) {
+        inboundMessageCountUpdater.getAndIncrement(this);
+      } else {
+        inboundMessageCount++;
+      }
+      module.recordRealTimeMetric(
+          startCtx, RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_METHOD, 1);
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void outboundMessage(int seqNo) {
+      if (outboundMessageCountUpdater != null) {
+        outboundMessageCountUpdater.getAndIncrement(this);
+      } else {
+        outboundMessageCount++;
+      }
+      module.recordRealTimeMetric(
+          startCtx, RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_METHOD, 1);
+    }
+
+    @Override
+    public void streamClosed(Status status) {
+      stopwatch.stop();
+      roundtripNanos = stopwatch.elapsed(TimeUnit.NANOSECONDS);
+      Deadline deadline = info.getCallOptions().getDeadline();
+      statusCode = status.getCode();
+      if (statusCode == Status.Code.CANCELLED && deadline != null) {
+        // When the server's deadline expires, it can only reset the stream with CANCEL and no
+        // description. Since our timer may be delayed in firing, we double-check the deadline and
+        // turn the failure into the likely more helpful DEADLINE_EXCEEDED status.
+        if (deadline.isExpired()) {
+          statusCode = Code.DEADLINE_EXCEEDED;
+        }
+      }
+      attemptsState.attemptEnded();
+      if (inboundReceivedOrClosed.compareAndSet(false, true)) {
+        if (module.recordFinishedRpcs) {
+          // Stream is closed early. So no need to record metrics for any inbound events after this
+          // point.
+          recordFinishedAttempt();
+        }
+      } // Otherwise will report stats in callEnded() to guarantee all inbound metrics are recorded.
+    }
+
+    void recordFinishedAttempt() {
+      MeasureMap measureMap =
+          module
+              .statsRecorder
+              .newMeasureMap()
+              // TODO(songya): remove the deprecated measure constants once they are completed
+              // removed.
+              .put(DeprecatedCensusConstants.RPC_CLIENT_FINISHED_COUNT, 1)
+              // The latency is double value
+              .put(
+                  RpcMeasureConstants.GRPC_CLIENT_ROUNDTRIP_LATENCY,
+                  roundtripNanos / NANOS_PER_MILLI)
+              .put(RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_RPC, outboundMessageCount)
+              .put(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_RPC, inboundMessageCount)
+              .put(RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC, (double) outboundWireSize)
+              .put(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_RPC, (double) inboundWireSize)
+              .put(
+                  DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES,
+                  (double) outboundUncompressedSize)
+              .put(
+                  DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES,
+                  (double) inboundUncompressedSize);
+      if (statusCode != Code.OK) {
+        measureMap.put(DeprecatedCensusConstants.RPC_CLIENT_ERROR_COUNT, 1);
+      }
+      TagValue statusTag = TagValue.create(statusCode.toString());
+      measureMap.record(
+          module
+              .tagger
+              .toBuilder(startCtx)
+              .putLocal(RpcMeasureConstants.GRPC_CLIENT_STATUS, statusTag)
+              .build());
+    }
+  }
+
+  @VisibleForTesting
+  static final class CallAttemptsTracerFactory extends
+      ClientStreamTracer.Factory {
+    static final MeasureLong RETRIES_PER_CALL =
+        Measure.MeasureLong.create(
+            "grpc.io/client/retries_per_call", "Number of retries per call", "1");
+    static final MeasureLong TRANSPARENT_RETRIES_PER_CALL =
+        Measure.MeasureLong.create(
+            "grpc.io/client/transparent_retries_per_call", "Transparent retries per call", "1");
+    static final MeasureDouble RETRY_DELAY_PER_CALL =
+        Measure.MeasureDouble.create(
+            "grpc.io/client/retry_delay_per_call", "Retry delay per call", "ms");
+
+    ClientTracer inboundMetricTracer;
+    private final CensusStatsModule module;
+    private final Stopwatch stopwatch;
+    private final Stopwatch callStopwatch;
+    @GuardedBy("lock")
+    private boolean callEnded;
+    private final TagContext parentCtx;
+    private final TagContext startCtx;
+    private final String fullMethodName;
+
+    // TODO(zdapeng): optimize memory allocation using AtomicFieldUpdater.
+    private final AtomicLong attemptsPerCall = new AtomicLong();
+    private final AtomicLong transparentRetriesPerCall = new AtomicLong();
+    // write happens before read
+    private Status status;
+    private final Object lock = new Object();
+    // write @GuardedBy("lock") and happens before read
+    private long retryDelayNanos;
+    private long callLatencyNanos;
+    @GuardedBy("lock")
+    private int activeStreams;
+    @GuardedBy("lock")
+    private boolean finishedCallToBeRecorded;
+
+    CallAttemptsTracerFactory(
+        CensusStatsModule module, TagContext parentCtx, String fullMethodName) {
+      this.module = checkNotNull(module, "module");
+      this.parentCtx = checkNotNull(parentCtx, "parentCtx");
+      this.fullMethodName = checkNotNull(fullMethodName, "fullMethodName");
+      this.stopwatch = module.stopwatchSupplier.get();
+      this.callStopwatch = module.stopwatchSupplier.get().start();
+      TagValue methodTag = TagValue.create(fullMethodName);
+      startCtx = module.tagger.toBuilder(parentCtx)
+          .putLocal(RpcMeasureConstants.GRPC_CLIENT_METHOD, methodTag)
+          .build();
+      if (module.recordStartedRpcs) {
+        // Record here in case newClientStreamTracer() would never be called.
+        module.statsRecorder.newMeasureMap()
+            .put(RpcMeasureConstants.GRPC_CLIENT_STARTED_RPCS, 1)
+            .record(startCtx);
+      }
+    }
+
+    @Override
+    public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata metadata) {
+      synchronized (lock) {
+        if (finishedCallToBeRecorded) {
+          // This can be the case when the called is cancelled but a retry attempt is created.
+          return new ClientStreamTracer() {};
+        }
+        if (++activeStreams == 1 && stopwatch.isRunning()) {
+          stopwatch.stop();
+          retryDelayNanos = stopwatch.elapsed(TimeUnit.NANOSECONDS);
+        }
+      }
+      if (module.recordStartedRpcs && attemptsPerCall.get() > 0) {
+        module.statsRecorder.newMeasureMap()
+            .put(RpcMeasureConstants.GRPC_CLIENT_STARTED_RPCS, 1)
+            .record(startCtx);
+      }
+      if (info.isTransparentRetry()) {
+        transparentRetriesPerCall.incrementAndGet();
+      } else {
+        attemptsPerCall.incrementAndGet();
+      }
+      return new ClientTracer(this, module, parentCtx, startCtx, info);
+    }
+
+    // Called whenever each attempt is ended.
+    void attemptEnded() {
+      if (!module.recordFinishedRpcs) {
+        return;
+      }
+      boolean shouldRecordFinishedCall = false;
+      synchronized (lock) {
+        if (--activeStreams == 0) {
+          stopwatch.start();
+          if (callEnded && !finishedCallToBeRecorded) {
+            shouldRecordFinishedCall = true;
+            finishedCallToBeRecorded = true;
+          }
+        }
+      }
+      if (shouldRecordFinishedCall) {
+        recordFinishedCall();
+      }
+    }
+
+    void callEnded(Status status) {
+      if (!module.recordFinishedRpcs) {
+        return;
+      }
+      callStopwatch.stop();
+      this.status = status;
+      boolean shouldRecordFinishedCall = false;
+      synchronized (lock) {
+        if (callEnded) {
+          // TODO(https://github.com/grpc/grpc-java/issues/7921): this shouldn't happen
+          return;
+        }
+        callEnded = true;
+        if (activeStreams == 0 && !finishedCallToBeRecorded) {
+          shouldRecordFinishedCall = true;
+          finishedCallToBeRecorded = true;
+        }
+      }
+      if (shouldRecordFinishedCall) {
+        recordFinishedCall();
+      }
+    }
+
+    void recordFinishedCall() {
+      if (attemptsPerCall.get() == 0) {
+        ClientTracer tracer = new ClientTracer(this, module, parentCtx, startCtx, null);
+        tracer.roundtripNanos = stopwatch.elapsed(TimeUnit.NANOSECONDS);
+        tracer.statusCode = status.getCode();
+        tracer.recordFinishedAttempt();
+      } else if (inboundMetricTracer != null) {
+        // activeStreams has been decremented to 0 by attemptEnded(),
+        // so inboundMetricTracer.statusCode is guaranteed to be assigned already.
+        inboundMetricTracer.recordFinishedAttempt();
+      }
+      if (!module.recordRetryMetrics) {
+        return;
+      }
+      long retriesPerCall = 0;
+      long attempts = attemptsPerCall.get();
+      if (attempts > 0) {
+        retriesPerCall = attempts - 1;
+      }
+      callLatencyNanos = callStopwatch.elapsed(TimeUnit.NANOSECONDS);
+      MeasureMap measureMap = module.statsRecorder.newMeasureMap()
+          .put(RETRIES_PER_CALL, retriesPerCall)
+          .put(TRANSPARENT_RETRIES_PER_CALL, transparentRetriesPerCall.get())
+          .put(RETRY_DELAY_PER_CALL, retryDelayNanos / NANOS_PER_MILLI)
+          .put(API_LATENCY_PER_CALL, callLatencyNanos / NANOS_PER_MILLI);
+      TagValue methodTag = TagValue.create(fullMethodName);
+      TagValue statusTag = TagValue.create(status.getCode().toString());
+      measureMap.record(
+          module.tagger
+              .toBuilder(parentCtx)
+              .putLocal(RpcMeasureConstants.GRPC_CLIENT_METHOD, methodTag)
+              .putLocal(RpcMeasureConstants.GRPC_CLIENT_STATUS, statusTag)
+              .build());
+    }
+  }
+
+  private static final class ServerTracer extends ServerStreamTracer {
+    @Nullable private static final AtomicIntegerFieldUpdater<ServerTracer> streamClosedUpdater;
+    @Nullable private static final AtomicLongFieldUpdater<ServerTracer> outboundMessageCountUpdater;
+    @Nullable private static final AtomicLongFieldUpdater<ServerTracer> inboundMessageCountUpdater;
+    @Nullable private static final AtomicLongFieldUpdater<ServerTracer> outboundWireSizeUpdater;
+    @Nullable private static final AtomicLongFieldUpdater<ServerTracer> inboundWireSizeUpdater;
+
+    @Nullable
+    private static final AtomicLongFieldUpdater<ServerTracer> outboundUncompressedSizeUpdater;
+
+    @Nullable
+    private static final AtomicLongFieldUpdater<ServerTracer> inboundUncompressedSizeUpdater;
+
+    /*
+     * When using Atomic*FieldUpdater, some Samsung Android 5.0.x devices encounter a bug in their
+     * JDK reflection API that triggers a NoSuchFieldException. When this occurs, we fallback to
+     * (potentially racy) direct updates of the volatile variables.
+     */
+    static {
+      AtomicIntegerFieldUpdater<ServerTracer> tmpStreamClosedUpdater;
+      AtomicLongFieldUpdater<ServerTracer> tmpOutboundMessageCountUpdater;
+      AtomicLongFieldUpdater<ServerTracer> tmpInboundMessageCountUpdater;
+      AtomicLongFieldUpdater<ServerTracer> tmpOutboundWireSizeUpdater;
+      AtomicLongFieldUpdater<ServerTracer> tmpInboundWireSizeUpdater;
+      AtomicLongFieldUpdater<ServerTracer> tmpOutboundUncompressedSizeUpdater;
+      AtomicLongFieldUpdater<ServerTracer> tmpInboundUncompressedSizeUpdater;
+      try {
+        tmpStreamClosedUpdater =
+            AtomicIntegerFieldUpdater.newUpdater(ServerTracer.class, "streamClosed");
+        tmpOutboundMessageCountUpdater =
+            AtomicLongFieldUpdater.newUpdater(ServerTracer.class, "outboundMessageCount");
+        tmpInboundMessageCountUpdater =
+            AtomicLongFieldUpdater.newUpdater(ServerTracer.class, "inboundMessageCount");
+        tmpOutboundWireSizeUpdater =
+            AtomicLongFieldUpdater.newUpdater(ServerTracer.class, "outboundWireSize");
+        tmpInboundWireSizeUpdater =
+            AtomicLongFieldUpdater.newUpdater(ServerTracer.class, "inboundWireSize");
+        tmpOutboundUncompressedSizeUpdater =
+            AtomicLongFieldUpdater.newUpdater(ServerTracer.class, "outboundUncompressedSize");
+        tmpInboundUncompressedSizeUpdater =
+            AtomicLongFieldUpdater.newUpdater(ServerTracer.class, "inboundUncompressedSize");
+      } catch (Throwable t) {
+        logger.log(Level.SEVERE, "Creating atomic field updaters failed", t);
+        tmpStreamClosedUpdater = null;
+        tmpOutboundMessageCountUpdater = null;
+        tmpInboundMessageCountUpdater = null;
+        tmpOutboundWireSizeUpdater = null;
+        tmpInboundWireSizeUpdater = null;
+        tmpOutboundUncompressedSizeUpdater = null;
+        tmpInboundUncompressedSizeUpdater = null;
+      }
+      streamClosedUpdater = tmpStreamClosedUpdater;
+      outboundMessageCountUpdater = tmpOutboundMessageCountUpdater;
+      inboundMessageCountUpdater = tmpInboundMessageCountUpdater;
+      outboundWireSizeUpdater = tmpOutboundWireSizeUpdater;
+      inboundWireSizeUpdater = tmpInboundWireSizeUpdater;
+      outboundUncompressedSizeUpdater = tmpOutboundUncompressedSizeUpdater;
+      inboundUncompressedSizeUpdater = tmpInboundUncompressedSizeUpdater;
+    }
+
+    private final CensusStatsModule module;
+    private final TagContext parentCtx;
+    private volatile int streamClosed;
+    private final Stopwatch stopwatch;
+    private volatile long outboundMessageCount;
+    private volatile long inboundMessageCount;
+    private volatile long outboundWireSize;
+    private volatile long inboundWireSize;
+    private volatile long outboundUncompressedSize;
+    private volatile long inboundUncompressedSize;
+
+    ServerTracer(
+        CensusStatsModule module,
+        TagContext parentCtx) {
+      this.module = checkNotNull(module, "module");
+      this.parentCtx = checkNotNull(parentCtx, "parentCtx");
+      this.stopwatch = module.stopwatchSupplier.get().start();
+      if (module.recordStartedRpcs) {
+        module.statsRecorder.newMeasureMap()
+            .put(RpcMeasureConstants.GRPC_SERVER_STARTED_RPCS, 1)
+            .record(parentCtx);
+      }
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void outboundWireSize(long bytes) {
+      if (outboundWireSizeUpdater != null) {
+        outboundWireSizeUpdater.getAndAdd(this, bytes);
+      } else {
+        outboundWireSize += bytes;
+      }
+      module.recordRealTimeMetric(
+          parentCtx, RpcMeasureConstants.GRPC_SERVER_SENT_BYTES_PER_METHOD, (double) bytes);
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void inboundWireSize(long bytes) {
+      if (inboundWireSizeUpdater != null) {
+        inboundWireSizeUpdater.getAndAdd(this, bytes);
+      } else {
+        inboundWireSize += bytes;
+      }
+      module.recordRealTimeMetric(
+          parentCtx, RpcMeasureConstants.GRPC_SERVER_RECEIVED_BYTES_PER_METHOD, (double) bytes);
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void outboundUncompressedSize(long bytes) {
+      if (outboundUncompressedSizeUpdater != null) {
+        outboundUncompressedSizeUpdater.getAndAdd(this, bytes);
+      } else {
+        outboundUncompressedSize += bytes;
+      }
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void inboundUncompressedSize(long bytes) {
+      if (inboundUncompressedSizeUpdater != null) {
+        inboundUncompressedSizeUpdater.getAndAdd(this, bytes);
+      } else {
+        inboundUncompressedSize += bytes;
+      }
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void inboundMessage(int seqNo) {
+      if (inboundMessageCountUpdater != null) {
+        inboundMessageCountUpdater.getAndIncrement(this);
+      } else {
+        inboundMessageCount++;
+      }
+      module.recordRealTimeMetric(
+          parentCtx, RpcMeasureConstants.GRPC_SERVER_RECEIVED_MESSAGES_PER_METHOD, 1);
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void outboundMessage(int seqNo) {
+      if (outboundMessageCountUpdater != null) {
+        outboundMessageCountUpdater.getAndIncrement(this);
+      } else {
+        outboundMessageCount++;
+      }
+      module.recordRealTimeMetric(
+          parentCtx, RpcMeasureConstants.GRPC_SERVER_SENT_MESSAGES_PER_METHOD, 1);
+    }
+
+    /**
+     * Record a finished stream and mark the current time as the end time.
+     *
+     * <p>Can be called from any thread without synchronization.  Calling it the second time or more
+     * is a no-op.
+     */
+    @Override
+    public void streamClosed(Status status) {
+      if (streamClosedUpdater != null) {
+        if (streamClosedUpdater.getAndSet(this, 1) != 0) {
+          return;
+        }
+      } else {
+        if (streamClosed != 0) {
+          return;
+        }
+        streamClosed = 1;
+      }
+      if (!module.recordFinishedRpcs) {
+        return;
+      }
+      stopwatch.stop();
+      long elapsedTimeNanos = stopwatch.elapsed(TimeUnit.NANOSECONDS);
+      MeasureMap measureMap =
+          module
+              .statsRecorder
+              .newMeasureMap()
+              // TODO(songya): remove the deprecated measure constants once they are completed
+              // removed.
+              .put(DeprecatedCensusConstants.RPC_SERVER_FINISHED_COUNT, 1)
+              // The latency is double value
+              .put(
+                  RpcMeasureConstants.GRPC_SERVER_SERVER_LATENCY,
+                  elapsedTimeNanos / NANOS_PER_MILLI)
+              .put(RpcMeasureConstants.GRPC_SERVER_SENT_MESSAGES_PER_RPC, outboundMessageCount)
+              .put(RpcMeasureConstants.GRPC_SERVER_RECEIVED_MESSAGES_PER_RPC, inboundMessageCount)
+              .put(RpcMeasureConstants.GRPC_SERVER_SENT_BYTES_PER_RPC, (double) outboundWireSize)
+              .put(RpcMeasureConstants.GRPC_SERVER_RECEIVED_BYTES_PER_RPC, (double) inboundWireSize)
+              .put(
+                  DeprecatedCensusConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES,
+                  (double) outboundUncompressedSize)
+              .put(
+                  DeprecatedCensusConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES,
+                  (double) inboundUncompressedSize);
+      if (!status.isOk()) {
+        measureMap.put(DeprecatedCensusConstants.RPC_SERVER_ERROR_COUNT, 1);
+      }
+      TagValue statusTag = TagValue.create(status.getCode().toString());
+      measureMap.record(
+          module
+              .tagger
+              .toBuilder(parentCtx)
+              .putLocal(RpcMeasureConstants.GRPC_SERVER_STATUS, statusTag)
+              .build());
+    }
+
+    @Override
+    public Context filterContext(Context context) {
+      return ContextUtils.withValue(context, parentCtx);
+    }
+  }
+
+  @VisibleForTesting
+  final class ServerTracerFactory extends ServerStreamTracer.Factory {
+    @Override
+    public ServerStreamTracer newServerStreamTracer(String fullMethodName, Metadata headers) {
+      TagContext parentCtx = headers.get(statsHeader);
+      if (parentCtx == null) {
+        parentCtx = tagger.empty();
+      }
+      TagValue methodTag = TagValue.create(fullMethodName);
+      parentCtx =
+          tagger
+              .toBuilder(parentCtx)
+              .putLocal(RpcMeasureConstants.GRPC_SERVER_METHOD, methodTag)
+              .build();
+      return new ServerTracer(CensusStatsModule.this, parentCtx);
+    }
+  }
+
+  @VisibleForTesting
+  final class StatsClientInterceptor implements ClientInterceptor {
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+      // New RPCs on client-side inherit the tag context from the current Context.
+      TagContext parentCtx = tagger.getCurrentTagContext();
+      final CallAttemptsTracerFactory tracerFactory = new CallAttemptsTracerFactory(
+          CensusStatsModule.this, parentCtx, method.getFullMethodName());
+      ClientCall<ReqT, RespT> call =
+          next.newCall(method, callOptions.withStreamTracerFactory(tracerFactory));
+      return new SimpleForwardingClientCall<ReqT, RespT>(call) {
+        @Override
+        public void start(Listener<RespT> responseListener, Metadata headers) {
+          delegate().start(
+              new SimpleForwardingClientCallListener<RespT>(responseListener) {
+                @Override
+                public void onClose(Status status, Metadata trailers) {
+                  tracerFactory.callEnded(status);
+                  super.onClose(status, trailers);
+                }
+              },
+              headers);
+        }
+      };
+    }
+  }
+}
diff --git a/census/src/main/java/io/grpc/census/CensusTracingModule.java b/census/src/main/java/io/grpc/census/CensusTracingModule.java
new file mode 100644
index 00000000000..68ec8b61eda
--- /dev/null
+++ b/census/src/main/java/io/grpc/census/CensusTracingModule.java
@@ -0,0 +1,517 @@
+/*
+ * Copyright 2016 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.census;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.ClientStreamTracer.NAME_RESOLUTION_DELAYED;
+import static io.grpc.census.internal.ObservabilityCensusConstants.CLIENT_TRACE_SPAN_CONTEXT_KEY;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Context;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerStreamTracer;
+import io.grpc.StreamTracer;
+import io.opencensus.trace.AttributeValue;
+import io.opencensus.trace.BlankSpan;
+import io.opencensus.trace.EndSpanOptions;
+import io.opencensus.trace.MessageEvent;
+import io.opencensus.trace.Span;
+import io.opencensus.trace.SpanContext;
+import io.opencensus.trace.Status;
+import io.opencensus.trace.Tracer;
+import io.opencensus.trace.propagation.BinaryFormat;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * Provides factories for {@link StreamTracer} that records traces to Census.
+ *
+ * <p>On the client-side, a factory is created for each call, because ClientCall starts earlier than
+ * the ClientStream, and in some cases may even not create a ClientStream at all.  Therefore, it's
+ * the factory that reports the summary to Census.
+ *
+ * <p>On the server-side, there is only one ServerStream per each ServerCall, and ServerStream
+ * starts earlier than the ServerCall.  Therefore, only one tracer is created per stream/call and
+ * it's the tracer that reports the summary to Census.
+ */
+final class CensusTracingModule {
+  private static final Logger logger = Logger.getLogger(CensusTracingModule.class.getName());
+
+  @Nullable
+  private static final AtomicIntegerFieldUpdater<CallAttemptsTracerFactory> callEndedUpdater;
+
+  @Nullable private static final AtomicIntegerFieldUpdater<ServerTracer> streamClosedUpdater;
+
+  /*
+   * When using Atomic*FieldUpdater, some Samsung Android 5.0.x devices encounter a bug in their JDK
+   * reflection API that triggers a NoSuchFieldException. When this occurs, we fallback to
+   * (potentially racy) direct updates of the volatile variables.
+   */
+  static {
+    AtomicIntegerFieldUpdater<CallAttemptsTracerFactory> tmpCallEndedUpdater;
+    AtomicIntegerFieldUpdater<ServerTracer> tmpStreamClosedUpdater;
+    try {
+      tmpCallEndedUpdater =
+          AtomicIntegerFieldUpdater.newUpdater(CallAttemptsTracerFactory.class, "callEnded");
+      tmpStreamClosedUpdater =
+          AtomicIntegerFieldUpdater.newUpdater(ServerTracer.class, "streamClosed");
+    } catch (Throwable t) {
+      logger.log(Level.SEVERE, "Creating atomic field updaters failed", t);
+      tmpCallEndedUpdater = null;
+      tmpStreamClosedUpdater = null;
+    }
+    callEndedUpdater = tmpCallEndedUpdater;
+    streamClosedUpdater = tmpStreamClosedUpdater;
+  }
+
+  private final Tracer censusTracer;
+  @VisibleForTesting
+  final Metadata.Key<SpanContext> tracingHeader;
+  private final TracingClientInterceptor clientInterceptor = new TracingClientInterceptor();
+  private final ServerTracerFactory serverTracerFactory = new ServerTracerFactory();
+
+  CensusTracingModule(
+      Tracer censusTracer, final BinaryFormat censusPropagationBinaryFormat) {
+    this.censusTracer = checkNotNull(censusTracer, "censusTracer");
+    checkNotNull(censusPropagationBinaryFormat, "censusPropagationBinaryFormat");
+    this.tracingHeader =
+        Metadata.Key.of("grpc-trace-bin", new Metadata.BinaryMarshaller<SpanContext>() {
+            @Override
+            public byte[] toBytes(SpanContext context) {
+              return censusPropagationBinaryFormat.toByteArray(context);
+            }
+
+            @Override
+            public SpanContext parseBytes(byte[] serialized) {
+              try {
+                return censusPropagationBinaryFormat.fromByteArray(serialized);
+              } catch (Exception e) {
+                logger.log(Level.FINE, "Failed to parse tracing header", e);
+                return SpanContext.INVALID;
+              }
+            }
+          });
+  }
+
+  /**
+   * Creates a {@link CallAttemptsTracerFactory} for a new call.
+   */
+  @VisibleForTesting
+  CallAttemptsTracerFactory newClientCallTracer(
+      @Nullable Span clientSpan, MethodDescriptor<?, ?> method) {
+    return new CallAttemptsTracerFactory(clientSpan, method);
+  }
+
+  /**
+   * Returns the server tracer factory.
+   */
+  ServerStreamTracer.Factory getServerTracerFactory() {
+    return serverTracerFactory;
+  }
+
+  /**
+   * Returns the client interceptor that facilitates Census-based stats reporting.
+   */
+  ClientInterceptor getClientInterceptor() {
+    return clientInterceptor;
+  }
+
+  @VisibleForTesting
+  static Status convertStatus(io.grpc.Status grpcStatus) {
+    Status status;
+    switch (grpcStatus.getCode()) {
+      case OK:
+        status = Status.OK;
+        break;
+      case CANCELLED:
+        status = Status.CANCELLED;
+        break;
+      case UNKNOWN:
+        status = Status.UNKNOWN;
+        break;
+      case INVALID_ARGUMENT:
+        status = Status.INVALID_ARGUMENT;
+        break;
+      case DEADLINE_EXCEEDED:
+        status = Status.DEADLINE_EXCEEDED;
+        break;
+      case NOT_FOUND:
+        status = Status.NOT_FOUND;
+        break;
+      case ALREADY_EXISTS:
+        status = Status.ALREADY_EXISTS;
+        break;
+      case PERMISSION_DENIED:
+        status = Status.PERMISSION_DENIED;
+        break;
+      case RESOURCE_EXHAUSTED:
+        status = Status.RESOURCE_EXHAUSTED;
+        break;
+      case FAILED_PRECONDITION:
+        status = Status.FAILED_PRECONDITION;
+        break;
+      case ABORTED:
+        status = Status.ABORTED;
+        break;
+      case OUT_OF_RANGE:
+        status = Status.OUT_OF_RANGE;
+        break;
+      case UNIMPLEMENTED:
+        status = Status.UNIMPLEMENTED;
+        break;
+      case INTERNAL:
+        status = Status.INTERNAL;
+        break;
+      case UNAVAILABLE:
+        status = Status.UNAVAILABLE;
+        break;
+      case DATA_LOSS:
+        status = Status.DATA_LOSS;
+        break;
+      case UNAUTHENTICATED:
+        status = Status.UNAUTHENTICATED;
+        break;
+      default:
+        throw new AssertionError("Unhandled status code " + grpcStatus.getCode());
+    }
+    if (grpcStatus.getDescription() != null) {
+      status = status.withDescription(grpcStatus.getDescription());
+    }
+    return status;
+  }
+
+  private static EndSpanOptions createEndSpanOptions(
+      io.grpc.Status status, boolean sampledToLocalTracing) {
+    return EndSpanOptions.builder()
+        .setStatus(convertStatus(status))
+        .setSampleToLocalSpanStore(sampledToLocalTracing)
+        .build();
+  }
+
+  private void recordMessageEvent(
+      Span span, MessageEvent.Type type,
+      int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+    MessageEvent.Builder eventBuilder = MessageEvent.builder(type, seqNo);
+    if (optionalUncompressedSize != -1) {
+      eventBuilder.setUncompressedMessageSize(optionalUncompressedSize);
+    }
+    if (optionalWireSize != -1) {
+      eventBuilder.setCompressedMessageSize(optionalWireSize);
+    }
+    span.addMessageEvent(eventBuilder.build());
+  }
+
+  private void recordAnnotation(
+      Span span, MessageEvent.Type type, int seqNo, boolean isCompressed, long size) {
+    String messageType = isCompressed ? "compressed" : "uncompressed";
+    Map<String, AttributeValue> attributes = new HashMap<>();
+    attributes.put("id", AttributeValue.longAttributeValue(seqNo));
+    attributes.put("type", AttributeValue.stringAttributeValue(messageType));
+
+    String messageDirection = type == MessageEvent.Type.SENT ? "↗ " : "↘ ";
+    String inlineDescription =
+        messageDirection + size + " bytes " + type.name().toLowerCase(Locale.US);
+    span.addAnnotation(inlineDescription, attributes);
+  }
+
+  @VisibleForTesting
+  final class CallAttemptsTracerFactory extends ClientStreamTracer.Factory {
+    volatile int callEnded;
+
+    private final boolean isSampledToLocalTracing;
+    private final Span span;
+    private final String fullMethodName;
+
+    CallAttemptsTracerFactory(@Nullable Span clientSpan, MethodDescriptor<?, ?> method) {
+      checkNotNull(method, "method");
+      this.isSampledToLocalTracing = method.isSampledToLocalTracing();
+      this.fullMethodName = method.getFullMethodName();
+      this.span = clientSpan;
+    }
+
+    @Override
+    public ClientStreamTracer newClientStreamTracer(
+        ClientStreamTracer.StreamInfo info, Metadata headers) {
+      Span attemptSpan = censusTracer
+          .spanBuilderWithExplicitParent(
+              "Attempt." + fullMethodName.replace('/', '.'),
+              span)
+          .setRecordEvents(true)
+          .startSpan();
+      attemptSpan.putAttribute(
+          "previous-rpc-attempts", AttributeValue.longAttributeValue(info.getPreviousAttempts()));
+      attemptSpan.putAttribute(
+          "transparent-retry", AttributeValue.booleanAttributeValue(info.isTransparentRetry()));
+      if (info.getCallOptions().getOption(NAME_RESOLUTION_DELAYED) != null) {
+        span.addAnnotation("Delayed name resolution complete");
+      }
+      return new ClientTracer(attemptSpan, span, tracingHeader, isSampledToLocalTracing);
+    }
+
+    /**
+     * Record a finished call and mark the current time as the end time.
+     *
+     * <p>Can be called from any thread without synchronization.  Calling it the second time or more
+     * is a no-op.
+     */
+    void callEnded(io.grpc.Status status) {
+      if (callEndedUpdater != null) {
+        if (callEndedUpdater.getAndSet(this, 1) != 0) {
+          return;
+        }
+      } else {
+        if (callEnded != 0) {
+          return;
+        }
+        callEnded = 1;
+      }
+      span.end(createEndSpanOptions(status, isSampledToLocalTracing));
+    }
+  }
+
+  private final class ClientTracer extends ClientStreamTracer {
+    private final Span span;
+    private final Span parentSpan;
+    final Metadata.Key<SpanContext> tracingHeader;
+    final boolean isSampledToLocalTracing;
+    volatile int seqNo;
+    boolean isPendingStream;
+
+    ClientTracer(
+        Span span, Span parentSpan, Metadata.Key<SpanContext> tracingHeader,
+        boolean isSampledToLocalTracing) {
+      this.span = checkNotNull(span, "span");
+      this.parentSpan = checkNotNull(parentSpan, "parent span");
+      this.tracingHeader = tracingHeader;
+      this.isSampledToLocalTracing = isSampledToLocalTracing;
+    }
+
+    @Override
+    public void streamCreated(Attributes transportAtts, Metadata headers) {
+      if (span != BlankSpan.INSTANCE) {
+        headers.discardAll(tracingHeader);
+        headers.put(tracingHeader, span.getContext());
+      }
+      if (isPendingStream) {
+        span.addAnnotation("Delayed LB pick complete");
+      }
+    }
+
+    @Override
+    public void createPendingStream() {
+      isPendingStream = true;
+    }
+
+    @Override
+    public void outboundMessageSent(
+        int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+      recordMessageEvent(
+          span, MessageEvent.Type.SENT, seqNo, optionalWireSize, optionalUncompressedSize);
+    }
+
+    @Override
+    public void inboundMessageRead(
+        int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+      recordAnnotation(
+          span, MessageEvent.Type.RECEIVED, seqNo, true, optionalWireSize);
+    }
+
+    @Override
+    public void inboundMessage(int seqNo) {
+      this.seqNo = seqNo;
+    }
+
+    @Override
+    public void inboundUncompressedSize(long bytes) {
+      recordAnnotation(
+          parentSpan, MessageEvent.Type.RECEIVED, seqNo, false, bytes);
+    }
+
+    @Override
+    public void streamClosed(io.grpc.Status status) {
+      span.end(createEndSpanOptions(status, isSampledToLocalTracing));
+    }
+  }
+
+
+  private final class ServerTracer extends ServerStreamTracer {
+    private final Span span;
+    volatile boolean isSampledToLocalTracing;
+    volatile int streamClosed;
+    private int seqNo;
+
+    ServerTracer(String fullMethodName, @Nullable SpanContext remoteSpan) {
+      checkNotNull(fullMethodName, "fullMethodName");
+      this.span =
+          censusTracer
+              .spanBuilderWithRemoteParent(
+                  generateTraceSpanName(true, fullMethodName),
+                  remoteSpan)
+              .setRecordEvents(true)
+              .startSpan();
+    }
+
+    @Override
+    public void serverCallStarted(ServerCallInfo<?, ?> callInfo) {
+      isSampledToLocalTracing = callInfo.getMethodDescriptor().isSampledToLocalTracing();
+    }
+
+    /**
+     * Record a finished stream and mark the current time as the end time.
+     *
+     * <p>Can be called from any thread without synchronization.  Calling it the second time or more
+     * is a no-op.
+     */
+    @Override
+    public void streamClosed(io.grpc.Status status) {
+      if (streamClosedUpdater != null) {
+        if (streamClosedUpdater.getAndSet(this, 1) != 0) {
+          return;
+        }
+      } else {
+        if (streamClosed != 0) {
+          return;
+        }
+        streamClosed = 1;
+      }
+      span.end(createEndSpanOptions(status, isSampledToLocalTracing));
+    }
+
+    /*
+     TODO(dnvindhya): Replace deprecated ContextUtils usage with ContextHandleUtils to interact
+     with io.grpc.Context as described in {@link io.opencensus.trace.unsafeContextUtils} to remove
+     SuppressWarnings annotation.
+    */
+    @SuppressWarnings("deprecation")
+    @Override
+    public Context filterContext(Context context) {
+      // Access directly the unsafe trace API to create the new Context. This is a safe usage
+      // because gRPC always creates a new Context for each of the server calls and does not
+      // inherit from the parent Context.
+      return io.opencensus.trace.unsafe.ContextUtils.withValue(context, span);
+    }
+
+    @Override
+    public void outboundMessageSent(
+        int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+      recordMessageEvent(
+          span, MessageEvent.Type.SENT, seqNo, optionalWireSize, optionalUncompressedSize);
+    }
+
+    @Override
+    public void inboundMessageRead(
+        int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+      recordAnnotation(
+          span, MessageEvent.Type.RECEIVED, seqNo, true, optionalWireSize);
+    }
+
+    @Override
+    public void inboundMessage(int seqNo) {
+      this.seqNo = seqNo;
+    }
+
+    @Override
+    public void inboundUncompressedSize(long bytes) {
+      recordAnnotation(
+          span, MessageEvent.Type.RECEIVED, seqNo, false, bytes);
+    }
+  }
+
+  @VisibleForTesting
+  final class ServerTracerFactory extends ServerStreamTracer.Factory {
+    @SuppressWarnings("ReferenceEquality")
+    @Override
+    public ServerStreamTracer newServerStreamTracer(String fullMethodName, Metadata headers) {
+      SpanContext remoteSpan = headers.get(tracingHeader);
+      if (remoteSpan == SpanContext.INVALID) {
+        remoteSpan = null;
+      }
+      return new ServerTracer(fullMethodName, remoteSpan);
+    }
+  }
+
+  @VisibleForTesting
+  final class TracingClientInterceptor implements ClientInterceptor {
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+      // New RPCs on client-side inherit the tracing context from the current Context.
+      // Safe usage of the unsafe trace API because CONTEXT_SPAN_KEY.get() returns the same value
+      // as Tracer.getCurrentSpan() except when no value available when the return value is null
+      // for the direct access and BlankSpan when Tracer API is used.
+      Span parentSpan = io.opencensus.trace.unsafe.ContextUtils.getValue(Context.current());
+      Span clientSpan = censusTracer
+          .spanBuilderWithExplicitParent(
+              generateTraceSpanName(false, method.getFullMethodName()),
+              parentSpan)
+          .setRecordEvents(true)
+          .startSpan();
+
+      final CallAttemptsTracerFactory tracerFactory = newClientCallTracer(clientSpan, method);
+      ClientCall<ReqT, RespT> call =
+          next.newCall(
+              method,
+              callOptions.withStreamTracerFactory(tracerFactory)
+                  .withOption(CLIENT_TRACE_SPAN_CONTEXT_KEY, clientSpan.getContext()));
+      return new SimpleForwardingClientCall<ReqT, RespT>(call) {
+        @Override
+        public void start(Listener<RespT> responseListener, Metadata headers) {
+          delegate().start(
+              new SimpleForwardingClientCallListener<RespT>(responseListener) {
+                @Override
+                public void onClose(io.grpc.Status status, Metadata trailers) {
+                  tracerFactory.callEnded(status);
+                  super.onClose(status, trailers);
+                }
+              },
+              headers);
+        }
+      };
+    }
+  }
+
+  /**
+   * Convert a full method name to a tracing span name.
+   *
+   * @param isServer {@code false} if the span is on the client-side, {@code true} if on the
+   *                 server-side
+   * @param fullMethodName the method name as returned by
+   *        {@link MethodDescriptor#getFullMethodName}.
+   */
+  @VisibleForTesting
+  static String generateTraceSpanName(boolean isServer, String fullMethodName) {
+    String prefix = isServer ? "Recv" : "Sent";
+    return prefix + "." + fullMethodName.replace('/', '.');
+  }
+
+}
diff --git a/census/src/main/java/io/grpc/census/GrpcCensus.java b/census/src/main/java/io/grpc/census/GrpcCensus.java
new file mode 100644
index 00000000000..c564c349ae4
--- /dev/null
+++ b/census/src/main/java/io/grpc/census/GrpcCensus.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright 2025 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.census;
+
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import io.grpc.ClientInterceptor;
+import io.grpc.ExperimentalApi;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerStreamTracer;
+import io.opencensus.trace.Tracing;
+
+/**
+ *  The entrypoint for OpenCensus instrumentation functionality in gRPC.
+ *
+ *  <p>GrpcCensus uses {@link io.opencensus.api.OpenCensus} APIs for instrumentation.
+ *
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/12178")
+public final class GrpcCensus {
+
+  private final boolean statsEnabled;
+  private final boolean tracingEnabled;
+
+  private GrpcCensus(Builder builder) {
+    this.statsEnabled = builder.statsEnabled;
+    this.tracingEnabled = builder.tracingEnabled;
+  }
+
+  /**
+   * Creates a new builder for {@link GrpcCensus}.
+   */
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  private static final Supplier<Stopwatch> STOPWATCH_SUPPLIER = new Supplier<Stopwatch>() {
+    @Override
+    public Stopwatch get() {
+      return Stopwatch.createUnstarted();
+    }
+  };
+
+  /**
+   * Configures a {@link ServerBuilder} to enable census stats and tracing.
+   *
+   * @param serverBuilder The server builder to configure.
+   * @return The configured server builder.
+   */
+  public <T extends ServerBuilder<T>> T configureServerBuilder(T serverBuilder) {
+    if (statsEnabled) {
+      serverBuilder.addStreamTracerFactory(newServerStatsStreamTracerFactory());
+    }
+    if (tracingEnabled) {
+      serverBuilder.addStreamTracerFactory(newServerTracingStreamTracerFactory());
+    }
+    return serverBuilder;
+  }
+
+  /**
+   * Configures a {@link ManagedChannelBuilder} to enable census stats and tracing.
+   *
+   * @param channelBuilder The channel builder to configure.
+   * @return The configured channel builder.
+   */
+  public <T extends ManagedChannelBuilder<T>> T configureChannelBuilder(T channelBuilder) {
+    if (statsEnabled) {
+      channelBuilder.intercept(newClientStatsInterceptor());
+    }
+    if (tracingEnabled) {
+      channelBuilder.intercept(newClientTracingInterceptor());
+    }
+    return channelBuilder;
+  }
+
+  /**
+   * Returns a {@link ClientInterceptor} with default stats implementation.
+   */
+  private static ClientInterceptor newClientStatsInterceptor() {
+    CensusStatsModule censusStats =
+        new CensusStatsModule(
+            STOPWATCH_SUPPLIER,
+            true,
+            true,
+            true,
+            false,
+            true);
+    return censusStats.getClientInterceptor();
+  }
+
+  /**
+   * Returns a {@link ClientInterceptor} with default tracing implementation.
+   */
+  private static ClientInterceptor newClientTracingInterceptor() {
+    CensusTracingModule censusTracing =
+        new CensusTracingModule(
+            Tracing.getTracer(),
+            Tracing.getPropagationComponent().getBinaryFormat());
+    return censusTracing.getClientInterceptor();
+  }
+
+  /**
+   * Returns a {@link ServerStreamTracer.Factory} with default stats implementation.
+   */
+  private static ServerStreamTracer.Factory newServerStatsStreamTracerFactory() {
+    CensusStatsModule censusStats =
+        new CensusStatsModule(
+            STOPWATCH_SUPPLIER,
+            true,
+            true,
+            true,
+            false,
+            true);
+    return censusStats.getServerTracerFactory();
+  }
+
+  /**
+   * Returns a {@link ServerStreamTracer.Factory} with default tracing implementation.
+   */
+  private static ServerStreamTracer.Factory newServerTracingStreamTracerFactory() {
+    CensusTracingModule censusTracing =
+        new CensusTracingModule(
+            Tracing.getTracer(),
+            Tracing.getPropagationComponent().getBinaryFormat());
+    return censusTracing.getServerTracerFactory();
+  }
+
+  /**
+   * Builder for {@link GrpcCensus}.
+   */
+  public static final class Builder {
+    private boolean statsEnabled = true;
+    private boolean tracingEnabled = true;
+
+    private Builder() {
+    }
+
+    /**
+     * Disables stats collection.
+     */
+    public Builder disableStats() {
+      this.statsEnabled = false;
+      return this;
+    }
+
+    /**
+     * Disables tracing.
+     */
+    public Builder disableTracing() {
+      this.tracingEnabled = false;
+      return this;
+    }
+
+    /**
+     * Builds a new {@link GrpcCensus}.
+     */
+    public GrpcCensus build() {
+      return new GrpcCensus(this);
+    }
+  }
+}
diff --git a/census/src/main/java/io/grpc/census/InternalCensusStatsAccessor.java b/census/src/main/java/io/grpc/census/InternalCensusStatsAccessor.java
new file mode 100644
index 00000000000..3bbbb7dd0e0
--- /dev/null
+++ b/census/src/main/java/io/grpc/census/InternalCensusStatsAccessor.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2019 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.census;
+
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import io.grpc.ClientInterceptor;
+import io.grpc.Internal;
+import io.grpc.ServerStreamTracer;
+import io.opencensus.stats.StatsRecorder;
+import io.opencensus.tags.Tagger;
+import io.opencensus.tags.propagation.TagContextBinarySerializer;
+
+/**
+ * Accessor for getting {@link ClientInterceptor} or {@link ServerStreamTracer.Factory} with
+ * default Census stats implementation.
+ */
+@Internal
+public final class InternalCensusStatsAccessor {
+
+  private static final Supplier<Stopwatch> STOPWATCH_SUPPLIER = new Supplier<Stopwatch>() {
+    @Override
+    public Stopwatch get() {
+      return Stopwatch.createUnstarted();
+    }
+  };
+
+  // Prevent instantiation.
+  private InternalCensusStatsAccessor() {
+  }
+
+  /**
+   * Returns a {@link ClientInterceptor} with default stats implementation.
+   */
+  public static ClientInterceptor getClientInterceptor(
+      boolean recordStartedRpcs,
+      boolean recordFinishedRpcs,
+      boolean recordRealTimeMetrics,
+      boolean recordRetryMetrics) {
+    CensusStatsModule censusStats =
+        new CensusStatsModule(
+            STOPWATCH_SUPPLIER,
+            true, /* propagateTags */
+            recordStartedRpcs,
+            recordFinishedRpcs,
+            recordRealTimeMetrics,
+            recordRetryMetrics);
+    return censusStats.getClientInterceptor();
+  }
+
+  /**
+   * Returns a {@link ClientInterceptor} with custom stats implementation.
+   */
+  public static ClientInterceptor getClientInterceptor(
+      Tagger tagger,
+      TagContextBinarySerializer tagCtxSerializer,
+      StatsRecorder statsRecorder,
+      Supplier<Stopwatch> stopwatchSupplier,
+      boolean propagateTags,
+      boolean recordStartedRpcs,
+      boolean recordFinishedRpcs,
+      boolean recordRealTimeMetrics,
+      boolean recordRetryMetrics) {
+    CensusStatsModule censusStats =
+        new CensusStatsModule(
+            tagger, tagCtxSerializer, statsRecorder, stopwatchSupplier,
+            propagateTags, recordStartedRpcs, recordFinishedRpcs, recordRealTimeMetrics,
+            recordRetryMetrics);
+    return censusStats.getClientInterceptor();
+  }
+
+  /**
+   * Returns a {@link ServerStreamTracer.Factory} with default stats implementation.
+   */
+  public static ServerStreamTracer.Factory getServerStreamTracerFactory(
+      boolean recordStartedRpcs,
+      boolean recordFinishedRpcs,
+      boolean recordRealTimeMetrics) {
+    CensusStatsModule censusStats =
+        new CensusStatsModule(
+            STOPWATCH_SUPPLIER,
+            true, /* propagateTags */
+            recordStartedRpcs,
+            recordFinishedRpcs,
+            recordRealTimeMetrics,
+            false);
+    return censusStats.getServerTracerFactory();
+  }
+
+  /**
+   * Returns a {@link ServerStreamTracer.Factory} with custom stats implementation.
+   */
+  public static ServerStreamTracer.Factory getServerStreamTracerFactory(
+      Tagger tagger,
+      TagContextBinarySerializer tagCtxSerializer,
+      StatsRecorder statsRecorder,
+      Supplier<Stopwatch> stopwatchSupplier,
+      boolean propagateTags,
+      boolean recordStartedRpcs,
+      boolean recordFinishedRpcs,
+      boolean recordRealTimeMetrics) {
+    CensusStatsModule censusStats =
+        new CensusStatsModule(
+            tagger, tagCtxSerializer, statsRecorder, stopwatchSupplier,
+            propagateTags, recordStartedRpcs, recordFinishedRpcs, recordRealTimeMetrics, false);
+    return censusStats.getServerTracerFactory();
+  }
+}
diff --git a/census/src/main/java/io/grpc/census/InternalCensusTracingAccessor.java b/census/src/main/java/io/grpc/census/InternalCensusTracingAccessor.java
new file mode 100644
index 00000000000..3a4c8bfd196
--- /dev/null
+++ b/census/src/main/java/io/grpc/census/InternalCensusTracingAccessor.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2019 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.census;
+
+import io.grpc.ClientInterceptor;
+import io.grpc.Internal;
+import io.grpc.ServerStreamTracer;
+import io.opencensus.trace.Tracing;
+
+/**
+ * Accessor for getting {@link ClientInterceptor} or {@link ServerStreamTracer.Factory} with
+ * default Census tracing implementation.
+ */
+@Internal
+public final class InternalCensusTracingAccessor {
+
+  // Prevent instantiation.
+  private InternalCensusTracingAccessor() {
+  }
+
+  /**
+   * Returns a {@link ClientInterceptor} with default tracing implementation.
+   */
+  public static ClientInterceptor getClientInterceptor() {
+    CensusTracingModule censusTracing =
+        new CensusTracingModule(
+            Tracing.getTracer(),
+            Tracing.getPropagationComponent().getBinaryFormat());
+    return censusTracing.getClientInterceptor();
+  }
+
+  /**
+   * Returns a {@link ServerStreamTracer.Factory} with default tracing implementation.
+   */
+  public static ServerStreamTracer.Factory getServerStreamTracerFactory() {
+    CensusTracingModule censusTracing =
+        new CensusTracingModule(
+            Tracing.getTracer(),
+            Tracing.getPropagationComponent().getBinaryFormat());
+    return censusTracing.getServerTracerFactory();
+  }
+}
diff --git a/census/src/main/java/io/grpc/census/internal/DeprecatedCensusConstants.java b/census/src/main/java/io/grpc/census/internal/DeprecatedCensusConstants.java
new file mode 100644
index 00000000000..7470bc81b15
--- /dev/null
+++ b/census/src/main/java/io/grpc/census/internal/DeprecatedCensusConstants.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2018 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.census.internal;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.opencensus.contrib.grpc.metrics.RpcMeasureConstants;
+import io.opencensus.stats.Measure.MeasureDouble;
+import io.opencensus.stats.Measure.MeasureLong;
+
+/** Holder class for the deprecated OpenCensus constants. */
+@SuppressWarnings("deprecation")
+@VisibleForTesting
+public final class DeprecatedCensusConstants {
+  public static final MeasureLong RPC_CLIENT_ERROR_COUNT =
+      RpcMeasureConstants.RPC_CLIENT_ERROR_COUNT;
+  public static final MeasureDouble RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES =
+      RpcMeasureConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES;
+  public static final MeasureDouble RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES =
+      RpcMeasureConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES;
+  public static final MeasureLong RPC_CLIENT_FINISHED_COUNT =
+      RpcMeasureConstants.RPC_CLIENT_FINISHED_COUNT;
+
+  public static final MeasureLong RPC_SERVER_ERROR_COUNT =
+      RpcMeasureConstants.RPC_SERVER_ERROR_COUNT;
+  public static final MeasureDouble RPC_SERVER_SERVER_ELAPSED_TIME =
+      RpcMeasureConstants.RPC_SERVER_SERVER_ELAPSED_TIME;
+  public static final MeasureDouble RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES =
+      RpcMeasureConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES;
+  public static final MeasureDouble RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES =
+      RpcMeasureConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES;
+  public static final MeasureLong RPC_SERVER_FINISHED_COUNT =
+      RpcMeasureConstants.RPC_SERVER_FINISHED_COUNT;
+
+  private DeprecatedCensusConstants() {}
+}
diff --git a/census/src/main/java/io/grpc/census/internal/ObservabilityCensusConstants.java b/census/src/main/java/io/grpc/census/internal/ObservabilityCensusConstants.java
new file mode 100644
index 00000000000..8dd0bc30b30
--- /dev/null
+++ b/census/src/main/java/io/grpc/census/internal/ObservabilityCensusConstants.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2023 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.census.internal;
+
+import static io.opencensus.contrib.grpc.metrics.RpcMeasureConstants.GRPC_CLIENT_METHOD;
+import static io.opencensus.contrib.grpc.metrics.RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_RPC;
+import static io.opencensus.contrib.grpc.metrics.RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC;
+import static io.opencensus.contrib.grpc.metrics.RpcMeasureConstants.GRPC_CLIENT_STATUS;
+import static io.opencensus.contrib.grpc.metrics.RpcMeasureConstants.GRPC_SERVER_METHOD;
+import static io.opencensus.contrib.grpc.metrics.RpcMeasureConstants.GRPC_SERVER_RECEIVED_BYTES_PER_RPC;
+import static io.opencensus.contrib.grpc.metrics.RpcMeasureConstants.GRPC_SERVER_SENT_BYTES_PER_RPC;
+import static io.opencensus.contrib.grpc.metrics.RpcMeasureConstants.GRPC_SERVER_STATUS;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.CallOptions;
+import io.opencensus.contrib.grpc.metrics.RpcViewConstants;
+import io.opencensus.stats.Aggregation;
+import io.opencensus.stats.Measure;
+import io.opencensus.stats.Measure.MeasureDouble;
+import io.opencensus.stats.View;
+import io.opencensus.trace.SpanContext;
+import java.util.Arrays;
+
+// TODO(dnvindhya): Remove metric and view definitions from this class once it is moved to
+// OpenCensus library.
+/**
+ * Temporary holder class for the observability specific OpenCensus constants. The class will be
+ * removed once the new views are added in OpenCensus library.
+ */
+@VisibleForTesting
+public final class ObservabilityCensusConstants {
+
+  public static CallOptions.Key<SpanContext> CLIENT_TRACE_SPAN_CONTEXT_KEY
+      = CallOptions.Key.createWithDefault("Client span context for tracing", SpanContext.INVALID);
+
+  static final Aggregation AGGREGATION_WITH_BYTES_HISTOGRAM =
+      RpcViewConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC_VIEW.getAggregation();
+
+  static final Aggregation AGGREGATION_WITH_MILLIS_HISTOGRAM =
+      RpcViewConstants.GRPC_CLIENT_ROUNDTRIP_LATENCY_VIEW.getAggregation();
+
+  public static final MeasureDouble API_LATENCY_PER_CALL =
+      Measure.MeasureDouble.create(
+          "grpc.io/client/api_latency",
+          "Time taken by gRPC to complete an RPC from application's perspective",
+          "ms");
+
+  public static final View GRPC_CLIENT_API_LATENCY_VIEW =
+      View.create(
+          View.Name.create("grpc.io/client/api_latency"),
+          "Time taken by gRPC to complete an RPC from application's perspective",
+          API_LATENCY_PER_CALL,
+          AGGREGATION_WITH_MILLIS_HISTOGRAM,
+          Arrays.asList(GRPC_CLIENT_METHOD, GRPC_CLIENT_STATUS));
+
+  public static final View GRPC_CLIENT_SENT_COMPRESSED_MESSAGE_BYTES_PER_RPC_VIEW =
+      View.create(
+          View.Name.create("grpc.io/client/sent_compressed_message_bytes_per_rpc"),
+          "Compressed message bytes sent per client RPC attempt",
+          GRPC_CLIENT_SENT_BYTES_PER_RPC,
+          AGGREGATION_WITH_BYTES_HISTOGRAM,
+          Arrays.asList(GRPC_CLIENT_METHOD, GRPC_CLIENT_STATUS));
+
+  public static final View GRPC_CLIENT_RECEIVED_COMPRESSED_MESSAGE_BYTES_PER_RPC_VIEW =
+      View.create(
+          View.Name.create("grpc.io/client/received_compressed_message_bytes_per_rpc"),
+          "Compressed message bytes received per client RPC attempt",
+          GRPC_CLIENT_RECEIVED_BYTES_PER_RPC,
+          AGGREGATION_WITH_BYTES_HISTOGRAM,
+          Arrays.asList(GRPC_CLIENT_METHOD, GRPC_CLIENT_STATUS));
+
+  public static final View GRPC_SERVER_SENT_COMPRESSED_MESSAGE_BYTES_PER_RPC_VIEW =
+      View.create(
+          View.Name.create("grpc.io/server/sent_compressed_message_bytes_per_rpc"),
+          "Compressed message bytes sent per server RPC",
+          GRPC_SERVER_SENT_BYTES_PER_RPC,
+          AGGREGATION_WITH_BYTES_HISTOGRAM,
+          Arrays.asList(GRPC_SERVER_METHOD, GRPC_SERVER_STATUS));
+
+  public static final View GRPC_SERVER_RECEIVED_COMPRESSED_MESSAGE_BYTES_PER_RPC_VIEW =
+      View.create(
+          View.Name.create("grpc.io/server/received_compressed_message_bytes_per_rpc"),
+          "Compressed message bytes received per server RPC",
+          GRPC_SERVER_RECEIVED_BYTES_PER_RPC,
+          AGGREGATION_WITH_BYTES_HISTOGRAM,
+          Arrays.asList(GRPC_SERVER_METHOD, GRPC_SERVER_STATUS));
+
+  private ObservabilityCensusConstants() {}
+}
diff --git a/census/src/test/java/io/grpc/census/CensusModulesTest.java b/census/src/test/java/io/grpc/census/CensusModulesTest.java
new file mode 100644
index 00000000000..9e0b4d935d3
--- /dev/null
+++ b/census/src/test/java/io/grpc/census/CensusModulesTest.java
@@ -0,0 +1,1640 @@
+/*
+ * Copyright 2017 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.census;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static io.grpc.ClientStreamTracer.NAME_RESOLUTION_DELAYED;
+import static io.grpc.census.CensusStatsModule.CallAttemptsTracerFactory.RETRIES_PER_CALL;
+import static io.grpc.census.CensusStatsModule.CallAttemptsTracerFactory.RETRY_DELAY_PER_CALL;
+import static io.grpc.census.CensusStatsModule.CallAttemptsTracerFactory.TRANSPARENT_RETRIES_PER_CALL;
+import static io.grpc.census.internal.ObservabilityCensusConstants.API_LATENCY_PER_CALL;
+import static io.grpc.census.internal.ObservabilityCensusConstants.CLIENT_TRACE_SPAN_CONTEXT_KEY;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientInterceptors;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Context;
+import io.grpc.KnownLength;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.ServerStreamTracer;
+import io.grpc.ServerStreamTracer.ServerCallInfo;
+import io.grpc.Status;
+import io.grpc.census.CensusTracingModule.CallAttemptsTracerFactory;
+import io.grpc.census.internal.DeprecatedCensusConstants;
+import io.grpc.census.internal.ObservabilityCensusConstants;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.testing.StatsTestUtils;
+import io.grpc.internal.testing.StatsTestUtils.FakeStatsRecorder;
+import io.grpc.internal.testing.StatsTestUtils.FakeTagContextBinarySerializer;
+import io.grpc.internal.testing.StatsTestUtils.FakeTagger;
+import io.grpc.internal.testing.StatsTestUtils.MockableSpan;
+import io.grpc.testing.GrpcServerRule;
+import io.opencensus.common.Function;
+import io.opencensus.common.Functions;
+import io.opencensus.contrib.grpc.metrics.RpcMeasureConstants;
+import io.opencensus.contrib.grpc.metrics.RpcViewConstants;
+import io.opencensus.impl.stats.StatsComponentImpl;
+import io.opencensus.stats.AggregationData;
+import io.opencensus.stats.AggregationData.CountData;
+import io.opencensus.stats.AggregationData.LastValueDataDouble;
+import io.opencensus.stats.AggregationData.LastValueDataLong;
+import io.opencensus.stats.AggregationData.SumDataDouble;
+import io.opencensus.stats.Measure;
+import io.opencensus.stats.StatsComponent;
+import io.opencensus.stats.View;
+import io.opencensus.tags.TagContext;
+import io.opencensus.tags.TagValue;
+import io.opencensus.trace.AttributeValue;
+import io.opencensus.trace.BlankSpan;
+import io.opencensus.trace.EndSpanOptions;
+import io.opencensus.trace.MessageEvent;
+import io.opencensus.trace.Span;
+import io.opencensus.trace.SpanBuilder;
+import io.opencensus.trace.SpanContext;
+import io.opencensus.trace.Tracer;
+import io.opencensus.trace.propagation.BinaryFormat;
+import io.opencensus.trace.propagation.SpanContextParseException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Test for {@link CensusStatsModule} and {@link CensusTracingModule}.
+ */
+@RunWith(JUnit4.class)
+public class CensusModulesTest {
+
+  private static final double TOLERANCE = 1e-6;
+  private static final CallOptions.Key<String> CUSTOM_OPTION =
+      CallOptions.Key.createWithDefault("option1", "default");
+  private static final CallOptions CALL_OPTIONS =
+      CallOptions.DEFAULT.withOption(CUSTOM_OPTION, "customvalue");
+  private static final ClientStreamTracer.StreamInfo STREAM_INFO =
+      ClientStreamTracer.StreamInfo.newBuilder()
+          .setCallOptions(CallOptions.DEFAULT.withOption(NAME_RESOLUTION_DELAYED, 10L)).build();
+
+  private static class StringInputStream extends InputStream implements KnownLength {
+    final String string;
+
+    StringInputStream(String string) {
+      this.string = string;
+    }
+
+    @Override
+    public int read() {
+      // InProcessTransport doesn't actually read bytes from the InputStream.  The InputStream is
+      // passed to the InProcess server and consumed by MARSHALLER.parse().
+      throw new UnsupportedOperationException("Should not be called");
+    }
+
+    @Override
+    public int available() throws IOException {
+      return string == null ? 0 : string.length();
+    }
+  }
+
+  private static final MethodDescriptor.Marshaller<String> MARSHALLER =
+      new MethodDescriptor.Marshaller<String>() {
+        @Override
+        public InputStream stream(String value) {
+          return new StringInputStream(value);
+        }
+
+        @Override
+        public String parse(InputStream stream) {
+          return ((StringInputStream) stream).string;
+        }
+      };
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private final MethodDescriptor<String, String> method =
+      MethodDescriptor.<String, String>newBuilder()
+          .setType(MethodDescriptor.MethodType.UNKNOWN)
+          .setRequestMarshaller(MARSHALLER)
+          .setResponseMarshaller(MARSHALLER)
+          .setFullMethodName("package1.service2/method3")
+          .build();
+  private final MethodDescriptor<String, String> sampledMethod =
+      method.toBuilder().setSampledToLocalTracing(true).build();
+
+  private final FakeClock fakeClock = new FakeClock();
+  private final FakeTagger tagger = new FakeTagger();
+  private final FakeTagContextBinarySerializer tagCtxSerializer =
+      new FakeTagContextBinarySerializer();
+  private final FakeStatsRecorder statsRecorder = new FakeStatsRecorder();
+  private final Random random = new Random(1234);
+  private final Span fakeClientParentSpan = MockableSpan.generateRandomSpan(random);
+  private final Span spyClientSpan = spy(MockableSpan.generateRandomSpan(random));
+  private final Span spyAttemptSpan = spy(MockableSpan.generateRandomSpan(random));
+  private final SpanContext fakeAttemptSpanContext = spyAttemptSpan.getContext();
+  private final Span spyServerSpan = spy(MockableSpan.generateRandomSpan(random));
+  private final byte[] binarySpanContext = new byte[]{3, 1, 5};
+  private final SpanBuilder spyClientSpanBuilder = spy(new MockableSpan.Builder());
+  private final SpanBuilder spyAttemptSpanBuilder = spy(new MockableSpan.Builder());
+  private final SpanBuilder spyServerSpanBuilder = spy(new MockableSpan.Builder());
+
+  @Rule
+  public final GrpcServerRule grpcServerRule = new GrpcServerRule().directExecutor();
+
+  @Mock
+  private Tracer tracer;
+  @Mock
+  private BinaryFormat mockTracingPropagationHandler;
+  @Mock
+  private ClientCall.Listener<String> mockClientCallListener;
+  @Mock
+  private ServerCall.Listener<String> mockServerCallListener;
+  @Captor
+  private ArgumentCaptor<Status> statusCaptor;
+  @Captor
+  private ArgumentCaptor<MessageEvent> messageEventCaptor;
+  @Captor
+  private ArgumentCaptor<Map<String, AttributeValue>> annotationAttributesCaptor;
+
+  private CensusStatsModule censusStats;
+  private CensusTracingModule censusTracing;
+
+  @Before
+  public void setUp() throws Exception {
+    when(spyClientSpanBuilder.startSpan()).thenReturn(spyClientSpan);
+    when(spyAttemptSpanBuilder.startSpan()).thenReturn(spyAttemptSpan);
+    when(tracer.spanBuilderWithExplicitParent(
+            eq("Sent.package1.service2.method3"), ArgumentMatchers.<Span>any()))
+        .thenReturn(spyClientSpanBuilder);
+    when(tracer.spanBuilderWithExplicitParent(
+            eq("Attempt.package1.service2.method3"), ArgumentMatchers.<Span>any()))
+        .thenReturn(spyAttemptSpanBuilder);
+    when(spyServerSpanBuilder.startSpan()).thenReturn(spyServerSpan);
+    when(tracer.spanBuilderWithRemoteParent(anyString(), ArgumentMatchers.<SpanContext>any()))
+        .thenReturn(spyServerSpanBuilder);
+    when(mockTracingPropagationHandler.toByteArray(any(SpanContext.class)))
+        .thenReturn(binarySpanContext);
+    when(mockTracingPropagationHandler.fromByteArray(any(byte[].class)))
+        .thenReturn(fakeAttemptSpanContext);
+    censusStats =
+        new CensusStatsModule(
+            tagger, tagCtxSerializer, statsRecorder, fakeClock.getStopwatchSupplier(),
+            true, true, true, false /* real-time */, true);
+    censusTracing = new CensusTracingModule(tracer, mockTracingPropagationHandler);
+  }
+
+  @After
+  public void wrapUp() {
+    assertNull(statsRecorder.pollRecord());
+  }
+
+  @Test
+  public void clientInterceptorNoCustomTag() {
+    testClientInterceptors(false);
+  }
+
+  @Test
+  public void clientInterceptorCustomTag() {
+    testClientInterceptors(true);
+  }
+
+  // Test that Census ClientInterceptors uses the TagContext and Span out of the current Context
+  // to create the ClientCallTracer, and that it intercepts ClientCall.Listener.onClose() to call
+  // ClientCallTracer.callEnded().
+  @SuppressWarnings("deprecation")
+  private void testClientInterceptors(boolean nonDefaultContext) {
+    grpcServerRule.getServiceRegistry().addService(
+        ServerServiceDefinition.builder("package1.service2").addMethod(
+            method, new ServerCallHandler<String, String>() {
+                @Override
+                public ServerCall.Listener<String> startCall(
+                    ServerCall<String, String> call, Metadata headers) {
+                  call.sendHeaders(new Metadata());
+                  call.sendMessage("Hello");
+                  call.close(
+                      Status.PERMISSION_DENIED.withDescription("No you don't"), new Metadata());
+                  return mockServerCallListener;
+                }
+              }).build());
+
+    final AtomicReference<CallOptions> capturedCallOptions = new AtomicReference<>();
+    ClientInterceptor callOptionsCaptureInterceptor = new ClientInterceptor() {
+        @Override
+        public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+            MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+          capturedCallOptions.set(callOptions);
+          return next.newCall(method, callOptions);
+        }
+      };
+    Channel interceptedChannel =
+        ClientInterceptors.intercept(
+            grpcServerRule.getChannel(), callOptionsCaptureInterceptor,
+            censusStats.getClientInterceptor(), censusTracing.getClientInterceptor());
+    ClientCall<String, String> call;
+    if (nonDefaultContext) {
+      Context ctx =
+          io.opencensus.tags.unsafe.ContextUtils.withValue(
+              Context.ROOT,
+              tagger
+                  .emptyBuilder()
+                  .putLocal(StatsTestUtils.EXTRA_TAG, TagValue.create("extra value"))
+                  .build());
+      ctx =  io.opencensus.trace.unsafe.ContextUtils.withValue(ctx, fakeClientParentSpan);
+      Context origCtx = ctx.attach();
+      try {
+        call = interceptedChannel.newCall(method, CALL_OPTIONS);
+      } finally {
+        ctx.detach(origCtx);
+      }
+    } else {
+      assertEquals(
+          io.opencensus.tags.unsafe.ContextUtils.getValue(Context.ROOT),
+          io.opencensus.tags.unsafe.ContextUtils.getValue(Context.current()));
+      assertEquals(io.opencensus.trace.unsafe.ContextUtils.getValue(Context.current()),
+          BlankSpan.INSTANCE);
+      call = interceptedChannel.newCall(method, CALL_OPTIONS);
+    }
+
+    // The interceptor adds tracer factory to CallOptions
+    assertEquals("customvalue", capturedCallOptions.get().getOption(CUSTOM_OPTION));
+    assertEquals(2, capturedCallOptions.get().getStreamTracerFactories().size());
+    assertTrue(
+        capturedCallOptions.get().getStreamTracerFactories().get(0)
+        instanceof CallAttemptsTracerFactory);
+    assertTrue(
+        capturedCallOptions.get().getStreamTracerFactories().get(1)
+        instanceof CensusStatsModule.CallAttemptsTracerFactory);
+
+    // The interceptor adds client SpanContext to CallOptions
+    assertTrue(capturedCallOptions.get().getOption(CLIENT_TRACE_SPAN_CONTEXT_KEY).isValid());
+    assertTrue(capturedCallOptions.get().getOption(CLIENT_TRACE_SPAN_CONTEXT_KEY) != null);
+
+    // Make the call
+    Metadata headers = new Metadata();
+    call.start(mockClientCallListener, headers);
+
+    StatsTestUtils.MetricsRecord record = statsRecorder.pollRecord();
+    assertNotNull(record);
+    TagValue methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+    assertEquals(method.getFullMethodName(), methodTag.asString());
+    if (nonDefaultContext) {
+      TagValue extraTag = record.tags.get(StatsTestUtils.EXTRA_TAG);
+      assertEquals("extra value", extraTag.asString());
+      assertEquals(2, record.tags.size());
+    } else {
+      assertNull(record.tags.get(StatsTestUtils.EXTRA_TAG));
+      assertEquals(1, record.tags.size());
+    }
+
+    if (nonDefaultContext) {
+      verify(tracer).spanBuilderWithExplicitParent(
+          eq("Sent.package1.service2.method3"), same(fakeClientParentSpan));
+      verify(spyClientSpanBuilder).setRecordEvents(eq(true));
+    } else {
+      verify(tracer).spanBuilderWithExplicitParent(
+          eq("Sent.package1.service2.method3"), ArgumentMatchers.<Span>isNotNull());
+      verify(spyClientSpanBuilder).setRecordEvents(eq(true));
+    }
+    verify(spyClientSpan, never()).end(any(EndSpanOptions.class));
+
+    // End the call
+    call.halfClose();
+    call.request(1);
+
+    verify(mockClientCallListener).onClose(statusCaptor.capture(), any(Metadata.class));
+    Status status = statusCaptor.getValue();
+    assertEquals(Status.Code.PERMISSION_DENIED, status.getCode());
+    assertEquals("No you don't", status.getDescription());
+
+    // The intercepting listener calls callEnded() on ClientCallTracer, which records to Census.
+    record = statsRecorder.pollRecord();
+    assertNotNull(record);
+    methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+    assertEquals(method.getFullMethodName(), methodTag.asString());
+    TagValue statusTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_STATUS);
+    assertEquals(Status.Code.PERMISSION_DENIED.toString(), statusTag.asString());
+    if (nonDefaultContext) {
+      TagValue extraTag = record.tags.get(StatsTestUtils.EXTRA_TAG);
+      assertEquals("extra value", extraTag.asString());
+    } else {
+      assertNull(record.tags.get(StatsTestUtils.EXTRA_TAG));
+    }
+    verify(spyClientSpan).end(
+        EndSpanOptions.builder()
+            .setStatus(
+                io.opencensus.trace.Status.PERMISSION_DENIED
+                    .withDescription("No you don't"))
+            .setSampleToLocalSpanStore(false)
+            .build());
+    verify(spyClientSpan, never()).end();
+    assertPerCallMetrics(0D);
+  }
+
+  @Test
+  public void clientBasicStatsDefaultContext_starts_finishes_noRealTime() {
+    subtestClientBasicStatsDefaultContext(true, true, false);
+  }
+
+  @Test
+  public void clientBasicStatsDefaultContext_starts_noFinishes_noRealTime() {
+    subtestClientBasicStatsDefaultContext(true, false, false);
+  }
+
+  @Test
+  public void clientBasicStatsDefaultContext_noStarts_finishes_noRealTime() {
+    subtestClientBasicStatsDefaultContext(false, true, false);
+  }
+
+  @Test
+  public void clientBasicStatsDefaultContext_noStarts_noFinishes_noRealTime() {
+    subtestClientBasicStatsDefaultContext(false, false, false);
+  }
+
+  @Test
+  public void clientBasicStatsDefaultContext_starts_finishes_realTime() {
+    subtestClientBasicStatsDefaultContext(true, true, true);
+  }
+
+  private void subtestClientBasicStatsDefaultContext(
+      boolean recordStarts, boolean recordFinishes, boolean recordRealTime) {
+    CensusStatsModule localCensusStats =
+        new CensusStatsModule(
+            tagger, tagCtxSerializer, statsRecorder, fakeClock.getStopwatchSupplier(),
+            true, recordStarts, recordFinishes, recordRealTime, true);
+    CensusStatsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CensusStatsModule.CallAttemptsTracerFactory(
+            localCensusStats, tagger.empty(), method.getFullMethodName());
+    Metadata headers = new Metadata();
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, headers);
+
+    if (recordStarts) {
+      StatsTestUtils.MetricsRecord record = statsRecorder.pollRecord();
+      assertNotNull(record);
+      assertNoServerContent(record);
+      assertEquals(1, record.tags.size());
+      TagValue methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+      assertEquals(method.getFullMethodName(), methodTag.asString());
+      assertEquals(1, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_STARTED_RPCS));
+    } else {
+      assertNull(statsRecorder.pollRecord());
+    }
+
+    fakeClock.forwardTime(30, MILLISECONDS);
+    tracer.outboundHeaders();
+
+    fakeClock.forwardTime(100, MILLISECONDS);
+
+    tracer.outboundMessage(0);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_METHOD, 1, recordRealTime, true);
+
+    tracer.outboundWireSize(1028);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_METHOD, 1028, recordRealTime, true);
+
+    tracer.outboundUncompressedSize(1128);
+
+    fakeClock.forwardTime(16, MILLISECONDS);
+
+    tracer.inboundMessage(0);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_METHOD, 1, recordRealTime, true);
+
+    tracer.inboundWireSize(33);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_METHOD, 33, recordRealTime, true);
+
+    tracer.inboundUncompressedSize(67);
+
+    tracer.outboundMessage(1);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_METHOD, 1, recordRealTime, true);
+
+    tracer.outboundWireSize(99);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_METHOD, 99, recordRealTime, true);
+
+    tracer.outboundUncompressedSize(865);
+
+    fakeClock.forwardTime(24, MILLISECONDS);
+    tracer.inboundMessage(1);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_METHOD, 1, recordRealTime, true);
+
+    tracer.inboundWireSize(154);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_METHOD, 154, recordRealTime, true);
+
+    tracer.inboundUncompressedSize(552);
+    tracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK);
+
+    if (recordFinishes) {
+      StatsTestUtils.MetricsRecord record = statsRecorder.pollRecord();
+      assertNotNull(record);
+      assertNoServerContent(record);
+      TagValue methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+      assertEquals(method.getFullMethodName(), methodTag.asString());
+      TagValue statusTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_STATUS);
+      assertEquals(Status.Code.OK.toString(), statusTag.asString());
+      assertEquals(
+          1, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_FINISHED_COUNT));
+      assertNull(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_ERROR_COUNT));
+      assertEquals(
+          2, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_RPC));
+      assertEquals(
+          1028 + 99,
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC));
+      assertEquals(
+          1128 + 865,
+          record.getMetricAsLongOrFail(
+              DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
+      assertEquals(
+          2,
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_RPC));
+      assertEquals(
+          33 + 154,
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_RPC));
+      assertEquals(
+          67 + 552,
+          record.getMetricAsLongOrFail(
+              DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
+      assertEquals(30 + 100 + 16 + 24,
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_ROUNDTRIP_LATENCY));
+      assertPerCallMetrics(30D + 100 + 16 + 24);
+    } else {
+      assertNull(statsRecorder.pollRecord());
+    }
+  }
+
+  // This test is only unit-testing the stat recording logic. The retry behavior is faked.
+  @Test
+  public void recordRetryStats() {
+    CensusStatsModule localCensusStats =
+        new CensusStatsModule(
+            tagger, tagCtxSerializer, statsRecorder, fakeClock.getStopwatchSupplier(),
+            true, true, true, true, true);
+    CensusStatsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CensusStatsModule.CallAttemptsTracerFactory(
+            localCensusStats, tagger.empty(), method.getFullMethodName());
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO,  new Metadata());
+
+    StatsTestUtils.MetricsRecord record = statsRecorder.pollRecord();
+    assertEquals(1, record.tags.size());
+    TagValue methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+    assertEquals(method.getFullMethodName(), methodTag.asString());
+    assertEquals(1, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_STARTED_RPCS));
+
+    fakeClock.forwardTime(30, MILLISECONDS);
+    tracer.outboundHeaders();
+    fakeClock.forwardTime(100, MILLISECONDS);
+    tracer.outboundMessage(0);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_METHOD, 1, true, true);
+    tracer.outboundMessage(1);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_METHOD, 1, true, true);
+    tracer.outboundWireSize(1028);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_METHOD, 1028, true, true);
+    tracer.outboundUncompressedSize(1128);
+    fakeClock.forwardTime(24, MILLISECONDS);
+    tracer.streamClosed(Status.UNAVAILABLE);
+    record = statsRecorder.pollRecord();
+    methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+    assertEquals(method.getFullMethodName(), methodTag.asString());
+    TagValue statusTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_STATUS);
+    assertEquals(Status.Code.UNAVAILABLE.toString(), statusTag.asString());
+    assertEquals(
+        1, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_FINISHED_COUNT));
+    assertEquals(1, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_ERROR_COUNT));
+    assertEquals(
+        2, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_RPC));
+    assertEquals(
+        1028, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC));
+    assertEquals(
+        1128,
+        record.getMetricAsLongOrFail(
+            DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
+    assertEquals(
+        30 + 100 + 24,
+        record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_ROUNDTRIP_LATENCY));
+
+    // faking retry
+    fakeClock.forwardTime(1000, MILLISECONDS);
+    tracer = callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+    record = statsRecorder.pollRecord();
+    assertEquals(1, record.tags.size());
+    methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+    assertEquals(method.getFullMethodName(), methodTag.asString());
+    assertEquals(1, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_STARTED_RPCS));
+    tracer.outboundHeaders();
+    tracer.outboundMessage(0);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_METHOD, 1, true, true);
+    tracer.outboundMessage(1);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_METHOD, 1, true, true);
+    tracer.outboundWireSize(1028);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_METHOD, 1028, true, true);
+    tracer.outboundUncompressedSize(1128);
+    fakeClock.forwardTime(100, MILLISECONDS);
+    tracer.streamClosed(Status.NOT_FOUND);
+    record = statsRecorder.pollRecord();
+    methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+    assertEquals(method.getFullMethodName(), methodTag.asString());
+    statusTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_STATUS);
+    assertEquals(Status.Code.NOT_FOUND.toString(), statusTag.asString());
+    assertEquals(
+        1, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_FINISHED_COUNT));
+    assertEquals(1, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_ERROR_COUNT));
+    assertEquals(
+        2, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_RPC));
+    assertEquals(
+        1028, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC));
+    assertEquals(
+        1128,
+        record.getMetricAsLongOrFail(
+            DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
+    assertEquals(
+        100 ,
+        record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_ROUNDTRIP_LATENCY));
+
+    // fake transparent retry
+    fakeClock.forwardTime(10, MILLISECONDS);
+    tracer = callAttemptsTracerFactory.newClientStreamTracer(
+        STREAM_INFO.toBuilder().setIsTransparentRetry(true).build(), new Metadata());
+    record = statsRecorder.pollRecord();
+    assertEquals(1, record.tags.size());
+    methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+    assertEquals(method.getFullMethodName(), methodTag.asString());
+    assertEquals(1, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_STARTED_RPCS));
+    tracer.streamClosed(Status.UNAVAILABLE);
+    record = statsRecorder.pollRecord();
+    statusTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_STATUS);
+    assertEquals(Status.Code.UNAVAILABLE.toString(), statusTag.asString());
+    assertEquals(
+        1, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_FINISHED_COUNT));
+    assertEquals(1, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_ERROR_COUNT));
+    assertEquals(
+        0, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_RPC));
+    assertEquals(
+        0, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC));
+
+    // fake another transparent retry
+    fakeClock.forwardTime(10, MILLISECONDS);
+    tracer = callAttemptsTracerFactory.newClientStreamTracer(
+        STREAM_INFO.toBuilder().setIsTransparentRetry(true).build(), new Metadata());
+    record = statsRecorder.pollRecord();
+    assertEquals(1, record.tags.size());
+    assertEquals(1, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_STARTED_RPCS));
+    tracer.outboundHeaders();
+    tracer.outboundMessage(0);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_METHOD, 1, true, true);
+    tracer.outboundMessage(1);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_METHOD, 1, true, true);
+    tracer.outboundWireSize(1028);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_METHOD, 1028, true, true);
+    tracer.outboundUncompressedSize(1128);
+    fakeClock.forwardTime(16, MILLISECONDS);
+    tracer.inboundMessage(0);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_METHOD, 1, true, true);
+    tracer.inboundWireSize(33);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_METHOD, 33, true, true);
+    tracer.inboundUncompressedSize(67);
+    fakeClock.forwardTime(24, MILLISECONDS);
+    // RPC succeeded
+    tracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK);
+
+    record = statsRecorder.pollRecord();
+    statusTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_STATUS);
+    assertEquals(Status.Code.OK.toString(), statusTag.asString());
+    assertEquals(
+        1, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_FINISHED_COUNT));
+    assertThat(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_ERROR_COUNT)).isNull();
+    assertEquals(
+        2, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_RPC));
+    assertEquals(
+        1028, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC));
+    assertEquals(
+        1128,
+        record.getMetricAsLongOrFail(
+            DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
+    assertEquals(
+        1, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_RPC));
+    assertEquals(
+        33,
+        record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_RPC));
+    assertEquals(
+        67,
+        record.getMetricAsLongOrFail(
+            DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
+    assertEquals(
+        16 + 24 ,
+        record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_ROUNDTRIP_LATENCY));
+
+    record = statsRecorder.pollRecord();
+    methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+    assertEquals(method.getFullMethodName(), methodTag.asString());
+    statusTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_STATUS);
+    assertEquals(Status.Code.OK.toString(), statusTag.asString());
+    assertThat(record.getMetric(RETRIES_PER_CALL)).isEqualTo(1);
+    assertThat(record.getMetric(TRANSPARENT_RETRIES_PER_CALL)).isEqualTo(2);
+    assertThat(record.getMetric(RETRY_DELAY_PER_CALL)).isEqualTo(1000D + 10 + 10);
+    assertThat(record.getMetric(API_LATENCY_PER_CALL))
+        .isEqualTo(30D + 100 + 24 + 1000 + 100 + 10 + 10 + 16 + 24);
+  }
+
+  private void assertRealTimeMetric(
+      Measure measure, long expectedValue, boolean recordRealTimeMetrics, boolean clientSide) {
+    StatsTestUtils.MetricsRecord record = statsRecorder.pollRecord();
+    if (!recordRealTimeMetrics) {
+      assertNull(record);
+      return;
+    }
+    assertNotNull(record);
+    if (clientSide) {
+      assertNoServerContent(record);
+
+      TagValue methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+      assertEquals(method.getFullMethodName(), methodTag.asString());
+    } else {
+      assertNoClientContent(record);
+
+      TagValue methodTag = record.tags.get(RpcMeasureConstants.GRPC_SERVER_METHOD);
+      assertEquals(method.getFullMethodName(), methodTag.asString());
+    }
+
+    assertEquals(expectedValue, record.getMetricAsLongOrFail(measure));
+  }
+
+  private void assertPerCallMetrics(double expectedLatencyValue) {
+    StatsTestUtils.MetricsRecord record = statsRecorder.pollRecord();
+    TagValue methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+    assertEquals(method.getFullMethodName(), methodTag.asString());
+    assertThat(record.getMetric(RETRIES_PER_CALL)).isEqualTo(0);
+    assertThat(record.getMetric(TRANSPARENT_RETRIES_PER_CALL)).isEqualTo(0);
+    assertThat(record.getMetric(RETRY_DELAY_PER_CALL)).isEqualTo(0D);
+    assertThat(record.getMetric(API_LATENCY_PER_CALL)).isEqualTo(expectedLatencyValue);
+  }
+
+  @Test
+  public void clientBasicTracingDefaultSpan() {
+    CallAttemptsTracerFactory callTracer =
+        censusTracing.newClientCallTracer(spyClientSpan, method);
+    Metadata headers = new Metadata();
+    ClientStreamTracer clientStreamTracer = callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    clientStreamTracer.createPendingStream();
+    clientStreamTracer.streamCreated(Attributes.EMPTY, headers);
+    verify(tracer).spanBuilderWithExplicitParent(
+        eq("Attempt.package1.service2.method3"), eq(spyClientSpan));
+    verify(spyClientSpan, never()).end(any(EndSpanOptions.class));
+    verify(spyAttemptSpan, never()).end(any(EndSpanOptions.class));
+
+    clientStreamTracer.outboundMessage(0);
+    clientStreamTracer.outboundMessageSent(0, 882, -1);
+    clientStreamTracer.inboundMessage(0);
+    clientStreamTracer.outboundMessage(1);
+    clientStreamTracer.outboundMessageSent(1, -1, 27);
+    clientStreamTracer.inboundMessageRead(0, 255, 90);
+
+    clientStreamTracer.streamClosed(Status.OK);
+    callTracer.callEnded(Status.OK);
+
+    InOrder inOrder = inOrder(spyClientSpan, spyAttemptSpan);
+    inOrder.verify(spyAttemptSpan)
+        .putAttribute("previous-rpc-attempts", AttributeValue.longAttributeValue(0));
+    inOrder.verify(spyAttemptSpan)
+        .putAttribute("transparent-retry", AttributeValue.booleanAttributeValue(false));
+    inOrder.verify(spyClientSpan).addAnnotation("Delayed name resolution complete");
+    inOrder.verify(spyAttemptSpan).addAnnotation("Delayed LB pick complete");
+    inOrder.verify(spyAttemptSpan, times(2)).addMessageEvent(messageEventCaptor.capture());
+    List<MessageEvent> events = messageEventCaptor.getAllValues();
+    assertEquals(
+        MessageEvent.builder(MessageEvent.Type.SENT, 0).setCompressedMessageSize(882).build(),
+        events.get(0));
+    assertEquals(
+        MessageEvent.builder(MessageEvent.Type.SENT, 1).setUncompressedMessageSize(27).build(),
+        events.get(1));
+    ArgumentCaptor<String> stringCaptor = ArgumentCaptor.forClass(String.class);
+    inOrder.verify(spyAttemptSpan, times(1))
+        .addAnnotation(stringCaptor.capture(), annotationAttributesCaptor.capture());
+    assertEquals("↘ 255 bytes received", stringCaptor.getValue());
+    assertThat(annotationAttributesCaptor.getValue().get("id"))
+        .isEqualTo(AttributeValue.longAttributeValue(0));
+    assertThat(annotationAttributesCaptor.getValue().get("type"))
+        .isEqualTo(AttributeValue.stringAttributeValue("compressed"));
+    inOrder.verify(spyAttemptSpan).end(
+        EndSpanOptions.builder()
+            .setStatus(io.opencensus.trace.Status.OK)
+            .setSampleToLocalSpanStore(false)
+            .build());
+    inOrder.verify(spyClientSpan).end(
+        EndSpanOptions.builder()
+            .setStatus(io.opencensus.trace.Status.OK)
+            .setSampleToLocalSpanStore(false)
+            .build());
+    inOrder.verifyNoMoreInteractions();
+    verifyNoMoreInteractions(tracer);
+  }
+
+  @Test
+  public void clientTracingSampledToLocalSpanStore() {
+    CallAttemptsTracerFactory callTracer =
+        censusTracing.newClientCallTracer(spyClientSpan, sampledMethod);
+    callTracer.callEnded(Status.OK);
+
+    verify(spyClientSpan).end(
+        EndSpanOptions.builder()
+            .setStatus(io.opencensus.trace.Status.OK)
+            .setSampleToLocalSpanStore(true)
+            .build());
+  }
+
+  @Test
+  public void clientStreamNeverCreatedStillRecordStats() {
+    CensusStatsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CensusStatsModule.CallAttemptsTracerFactory(
+            censusStats, tagger.empty(), method.getFullMethodName());
+    ClientStreamTracer streamTracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+    fakeClock.forwardTime(3000, MILLISECONDS);
+    Status status = Status.DEADLINE_EXCEEDED.withDescription("3 seconds");
+    streamTracer.streamClosed(status);
+    callAttemptsTracerFactory.callEnded(status);
+
+    // Upstart record
+    StatsTestUtils.MetricsRecord record = statsRecorder.pollRecord();
+    assertNotNull(record);
+    assertNoServerContent(record);
+    assertEquals(1, record.tags.size());
+    TagValue methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+    assertEquals(method.getFullMethodName(), methodTag.asString());
+    assertEquals(1, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_STARTED_RPCS));
+
+    // Completion record
+    record = statsRecorder.pollRecord();
+    assertNotNull(record);
+    assertNoServerContent(record);
+    methodTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+    assertEquals(method.getFullMethodName(), methodTag.asString());
+    TagValue statusTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_STATUS);
+    assertEquals(Status.Code.DEADLINE_EXCEEDED.toString(), statusTag.asString());
+    assertEquals(
+        1,
+        record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_FINISHED_COUNT));
+    assertEquals(
+        1,
+        record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_ERROR_COUNT));
+    assertEquals(
+        0, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_RPC));
+    assertEquals(
+        0, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC));
+    assertEquals(
+        0,
+        record.getMetricAsLongOrFail(
+            DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
+    assertEquals(
+        0, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_RPC));
+    assertEquals(
+        0, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_RPC));
+    assertEquals(0,
+        record.getMetricAsLongOrFail(
+            DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
+    assertEquals(
+        3000,
+        record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_ROUNDTRIP_LATENCY));
+    assertNull(record.getMetric(RpcMeasureConstants.GRPC_CLIENT_SERVER_LATENCY));
+    assertPerCallMetrics(3000D);
+  }
+
+  @Test
+  public void clientStreamNeverCreatedStillRecordTracing() {
+    CallAttemptsTracerFactory callTracer =
+        censusTracing.newClientCallTracer(spyClientSpan, method);
+
+    callTracer.callEnded(Status.DEADLINE_EXCEEDED.withDescription("3 seconds"));
+    verify(spyClientSpan).end(
+        EndSpanOptions.builder()
+            .setStatus(
+                io.opencensus.trace.Status.DEADLINE_EXCEEDED
+                    .withDescription("3 seconds"))
+            .setSampleToLocalSpanStore(false)
+            .build());
+    verifyNoMoreInteractions(spyClientSpan);
+  }
+
+  @Test
+  public void statsHeadersPropagateTags_record() {
+    subtestStatsHeadersPropagateTags(true, true);
+  }
+
+  @Test
+  public void statsHeadersPropagateTags_notRecord() {
+    subtestStatsHeadersPropagateTags(true, false);
+  }
+
+  @Test
+  public void statsHeadersNotPropagateTags_record() {
+    subtestStatsHeadersPropagateTags(false, true);
+  }
+
+  @Test
+  public void statsHeadersNotPropagateTags_notRecord() {
+    subtestStatsHeadersPropagateTags(false, false);
+  }
+
+  private void subtestStatsHeadersPropagateTags(boolean propagate, boolean recordStats) {
+    // EXTRA_TAG is propagated by the FakeStatsContextFactory. Note that not all tags are
+    // propagated.  The StatsContextFactory decides which tags are to propagated.  gRPC facilitates
+    // the propagation by putting them in the headers.
+    TagContext clientCtx = tagger.emptyBuilder().putLocal(
+        StatsTestUtils.EXTRA_TAG, TagValue.create("extra-tag-value-897")).build();
+    CensusStatsModule census =
+        new CensusStatsModule(
+            tagger,
+            tagCtxSerializer,
+            statsRecorder,
+            fakeClock.getStopwatchSupplier(),
+            propagate, recordStats, recordStats, recordStats, recordStats);
+    Metadata headers = new Metadata();
+    CensusStatsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CensusStatsModule.CallAttemptsTracerFactory(
+            census, clientCtx, method.getFullMethodName());
+    // This propagates clientCtx to headers if propagates==true
+    ClientStreamTracer streamTracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, headers);
+    streamTracer.streamCreated(Attributes.EMPTY, headers);
+    if (recordStats) {
+      // Client upstart record
+      StatsTestUtils.MetricsRecord clientRecord = statsRecorder.pollRecord();
+      assertNotNull(clientRecord);
+      assertNoServerContent(clientRecord);
+      assertEquals(2, clientRecord.tags.size());
+      TagValue clientMethodTag = clientRecord.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+      assertEquals(method.getFullMethodName(), clientMethodTag.asString());
+      TagValue clientPropagatedTag = clientRecord.tags.get(StatsTestUtils.EXTRA_TAG);
+      assertEquals("extra-tag-value-897", clientPropagatedTag.asString());
+    }
+
+    if (propagate) {
+      assertTrue(headers.containsKey(census.statsHeader));
+    } else {
+      assertFalse(headers.containsKey(census.statsHeader));
+      return;
+    }
+
+    ServerStreamTracer serverTracer =
+        census.getServerTracerFactory().newServerStreamTracer(method.getFullMethodName(), headers);
+    // Server tracer deserializes clientCtx from the headers, so that it records stats with the
+    // propagated tags.
+    Context serverContext = serverTracer.filterContext(Context.ROOT);
+    // It also put clientCtx in the Context seen by the call handler
+    assertEquals(
+        tagger.toBuilder(clientCtx)
+            .putLocal(
+                RpcMeasureConstants.GRPC_SERVER_METHOD,
+                TagValue.create(method.getFullMethodName()))
+            .build(),
+        io.opencensus.tags.unsafe.ContextUtils.getValue(serverContext));
+
+    // Verifies that the server tracer records the status with the propagated tag
+    serverTracer.streamClosed(Status.OK);
+
+    if (recordStats) {
+      // Server upstart record
+      StatsTestUtils.MetricsRecord serverRecord = statsRecorder.pollRecord();
+      assertNotNull(serverRecord);
+      assertNoClientContent(serverRecord);
+      assertEquals(2, serverRecord.tags.size());
+      TagValue serverMethodTag = serverRecord.tags.get(RpcMeasureConstants.GRPC_SERVER_METHOD);
+      assertEquals(method.getFullMethodName(), serverMethodTag.asString());
+      TagValue serverPropagatedTag = serverRecord.tags.get(StatsTestUtils.EXTRA_TAG);
+      assertEquals("extra-tag-value-897", serverPropagatedTag.asString());
+
+      // Server completion record
+      serverRecord = statsRecorder.pollRecord();
+      assertNotNull(serverRecord);
+      assertNoClientContent(serverRecord);
+      serverMethodTag = serverRecord.tags.get(RpcMeasureConstants.GRPC_SERVER_METHOD);
+      assertEquals(method.getFullMethodName(), serverMethodTag.asString());
+      TagValue serverStatusTag = serverRecord.tags.get(RpcMeasureConstants.GRPC_SERVER_STATUS);
+      assertEquals(Status.Code.OK.toString(), serverStatusTag.asString());
+      assertNull(serverRecord.getMetric(DeprecatedCensusConstants.RPC_SERVER_ERROR_COUNT));
+      serverPropagatedTag = serverRecord.tags.get(StatsTestUtils.EXTRA_TAG);
+      assertEquals("extra-tag-value-897", serverPropagatedTag.asString());
+    }
+
+    // Verifies that the client tracer factory uses clientCtx, which includes the custom tags, to
+    // record stats.
+    streamTracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK);
+
+    if (recordStats) {
+      // Client completion record
+      StatsTestUtils.MetricsRecord clientRecord = statsRecorder.pollRecord();
+      assertNotNull(clientRecord);
+      assertNoServerContent(clientRecord);
+      TagValue clientMethodTag = clientRecord.tags.get(RpcMeasureConstants.GRPC_CLIENT_METHOD);
+      assertEquals(method.getFullMethodName(), clientMethodTag.asString());
+      TagValue clientStatusTag = clientRecord.tags.get(RpcMeasureConstants.GRPC_CLIENT_STATUS);
+      assertEquals(Status.Code.OK.toString(), clientStatusTag.asString());
+      assertNull(clientRecord.getMetric(DeprecatedCensusConstants.RPC_CLIENT_ERROR_COUNT));
+      TagValue clientPropagatedTag = clientRecord.tags.get(StatsTestUtils.EXTRA_TAG);
+      assertEquals("extra-tag-value-897", clientPropagatedTag.asString());
+      assertPerCallMetrics(0D);
+    }
+
+    if (!recordStats) {
+      assertNull(statsRecorder.pollRecord());
+    }
+  }
+
+  @Test
+  public void statsHeadersNotPropagateDefaultContext() {
+    CensusStatsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CensusStatsModule.CallAttemptsTracerFactory(
+            censusStats, tagger.empty(), method.getFullMethodName());
+    Metadata headers = new Metadata();
+    callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, headers)
+        .streamCreated(Attributes.EMPTY, headers);
+    assertFalse(headers.containsKey(censusStats.statsHeader));
+    // Clear recorded stats to satisfy the assertions in wrapUp()
+    statsRecorder.rolloverRecords();
+  }
+
+  @Test
+  public void statsHeaderMalformed() {
+    // Construct a malformed header and make sure parsing it will throw
+    byte[] statsHeaderValue = new byte[]{1};
+    Metadata.Key<byte[]> arbitraryStatsHeader =
+        Metadata.Key.of("grpc-tags-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    try {
+      tagCtxSerializer.fromByteArray(statsHeaderValue);
+      fail("Should have thrown");
+    } catch (Exception e) {
+      // Expected
+    }
+
+    // But the header key will return a default context for it
+    Metadata headers = new Metadata();
+    assertNull(headers.get(censusStats.statsHeader));
+    headers.put(arbitraryStatsHeader, statsHeaderValue);
+    assertSame(tagger.empty(), headers.get(censusStats.statsHeader));
+  }
+
+  @SuppressWarnings("deprecation")
+  @Test
+  public void traceHeadersPropagateSpanContext() throws Exception {
+    CallAttemptsTracerFactory callTracer =
+        censusTracing.newClientCallTracer(spyClientSpan, method);
+    Metadata headers = new Metadata();
+    ClientStreamTracer streamTracer = callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    streamTracer.streamCreated(Attributes.EMPTY, headers);
+
+    verify(mockTracingPropagationHandler).toByteArray(same(fakeAttemptSpanContext));
+    verifyNoMoreInteractions(mockTracingPropagationHandler);
+    verify(tracer).spanBuilderWithExplicitParent(
+        eq("Attempt.package1.service2.method3"), same(spyClientSpan));
+    verifyNoMoreInteractions(tracer);
+    assertTrue(headers.containsKey(censusTracing.tracingHeader));
+
+    ServerStreamTracer serverTracer =
+        censusTracing.getServerTracerFactory().newServerStreamTracer(
+            method.getFullMethodName(), headers);
+    verify(mockTracingPropagationHandler).fromByteArray(same(binarySpanContext));
+    verify(tracer).spanBuilderWithRemoteParent(
+        eq("Recv.package1.service2.method3"), same(spyAttemptSpan.getContext()));
+    verify(spyServerSpanBuilder).setRecordEvents(eq(true));
+
+    Context filteredContext = serverTracer.filterContext(Context.ROOT);
+    assertSame(spyServerSpan, io.opencensus.trace.unsafe.ContextUtils.getValue(filteredContext));
+  }
+
+  @Test
+  public void traceHeaders_propagateSpanContext() throws Exception {
+    CallAttemptsTracerFactory callTracer =
+        censusTracing.newClientCallTracer(fakeClientParentSpan, method);
+    Metadata headers = new Metadata();
+
+    ClientStreamTracer streamTracer = callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    streamTracer.streamCreated(Attributes.EMPTY, headers);
+
+    assertThat(headers.keys()).isNotEmpty();
+  }
+
+  @Test
+  public void traceHeaders_missingCensusImpl_notPropagateSpanContext()
+      throws Exception {
+    reset(spyClientSpanBuilder);
+    reset(spyAttemptSpanBuilder);
+    when(spyClientSpanBuilder.startSpan()).thenReturn(BlankSpan.INSTANCE);
+    when(spyAttemptSpanBuilder.startSpan()).thenReturn(BlankSpan.INSTANCE);
+    Metadata headers = new Metadata();
+
+    CallAttemptsTracerFactory callTracer =
+        censusTracing.newClientCallTracer(BlankSpan.INSTANCE, method);
+    callTracer.newClientStreamTracer(STREAM_INFO, headers).streamCreated(Attributes.EMPTY, headers);
+
+    assertThat(headers.keys()).isEmpty();
+  }
+
+  @Test
+  public void traceHeaders_clientMissingCensusImpl_preservingHeaders() throws Exception {
+    reset(spyClientSpanBuilder);
+    reset(spyAttemptSpanBuilder);
+    when(spyClientSpanBuilder.startSpan()).thenReturn(BlankSpan.INSTANCE);
+    when(spyAttemptSpanBuilder.startSpan()).thenReturn(BlankSpan.INSTANCE);
+    Metadata headers = new Metadata();
+    headers.put(
+        Metadata.Key.of("never-used-key-bin", Metadata.BINARY_BYTE_MARSHALLER),
+        new byte[] {});
+    Set<String> originalHeaderKeys = new HashSet<>(headers.keys());
+
+    CallAttemptsTracerFactory callTracer =
+        censusTracing.newClientCallTracer(BlankSpan.INSTANCE, method);
+    callTracer.newClientStreamTracer(STREAM_INFO, headers).streamCreated(Attributes.EMPTY, headers);
+
+    assertThat(headers.keys()).containsExactlyElementsIn(originalHeaderKeys);
+  }
+
+  @Test
+  public void traceHeaderMalformed() throws Exception {
+    // As comparison, normal header parsing
+    Metadata headers = new Metadata();
+    headers.put(censusTracing.tracingHeader, fakeAttemptSpanContext);
+    // mockTracingPropagationHandler was stubbed to always return fakeServerParentSpanContext
+    assertSame(spyAttemptSpan.getContext(), headers.get(censusTracing.tracingHeader));
+
+    // Make BinaryPropagationHandler always throw when parsing the header
+    when(mockTracingPropagationHandler.fromByteArray(any(byte[].class)))
+        .thenThrow(new SpanContextParseException("Malformed header"));
+
+    headers = new Metadata();
+    assertNull(headers.get(censusTracing.tracingHeader));
+    headers.put(censusTracing.tracingHeader, fakeAttemptSpanContext);
+    assertSame(SpanContext.INVALID, headers.get(censusTracing.tracingHeader));
+    assertNotSame(spyClientSpan.getContext(), SpanContext.INVALID);
+
+    // A null Span is used as the parent in this case
+    censusTracing.getServerTracerFactory().newServerStreamTracer(
+        method.getFullMethodName(), headers);
+    verify(tracer).spanBuilderWithRemoteParent(
+        eq("Recv.package1.service2.method3"), ArgumentMatchers.<SpanContext>isNull());
+    verify(spyServerSpanBuilder).setRecordEvents(eq(true));
+  }
+
+  @Test
+  public void serverBasicStatsNoHeaders_starts_finishes_noRealTime() {
+    subtestServerBasicStatsNoHeaders(true, true, false);
+  }
+
+  @Test
+  public void serverBasicStatsNoHeaders_starts_noFinishes_noRealTime() {
+    subtestServerBasicStatsNoHeaders(true, false, false);
+  }
+
+  @Test
+  public void serverBasicStatsNoHeaders_noStarts_finishes_noRealTime() {
+    subtestServerBasicStatsNoHeaders(false, true, false);
+  }
+
+  @Test
+  public void serverBasicStatsNoHeaders_noStarts_noFinishes_noRealTime() {
+    subtestServerBasicStatsNoHeaders(false, false, false);
+  }
+
+  @Test
+  public void serverBasicStatsNoHeaders_starts_finishes_realTime() {
+    subtestServerBasicStatsNoHeaders(true, true, true);
+  }
+
+  private void subtestServerBasicStatsNoHeaders(
+      boolean recordStarts, boolean recordFinishes, boolean recordRealTime) {
+    CensusStatsModule localCensusStats =
+        new CensusStatsModule(
+            tagger, tagCtxSerializer, statsRecorder, fakeClock.getStopwatchSupplier(),
+            true, recordStarts, recordFinishes, recordRealTime, true);
+    ServerStreamTracer.Factory tracerFactory = localCensusStats.getServerTracerFactory();
+    ServerStreamTracer tracer =
+        tracerFactory.newServerStreamTracer(method.getFullMethodName(), new Metadata());
+
+    if (recordStarts) {
+      StatsTestUtils.MetricsRecord record = statsRecorder.pollRecord();
+      assertNotNull(record);
+      assertNoClientContent(record);
+      assertEquals(1, record.tags.size());
+      TagValue methodTag = record.tags.get(RpcMeasureConstants.GRPC_SERVER_METHOD);
+      assertEquals(method.getFullMethodName(), methodTag.asString());
+      assertEquals(1, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_STARTED_RPCS));
+    } else {
+      assertNull(statsRecorder.pollRecord());
+    }
+
+    Context filteredContext = tracer.filterContext(Context.ROOT);
+    TagContext statsCtx = io.opencensus.tags.unsafe.ContextUtils.getValue(filteredContext);
+    assertEquals(
+        tagger
+            .emptyBuilder()
+            .putLocal(
+                RpcMeasureConstants.GRPC_SERVER_METHOD,
+                TagValue.create(method.getFullMethodName()))
+            .build(),
+        statsCtx);
+
+    tracer.inboundMessage(0);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_SERVER_RECEIVED_MESSAGES_PER_METHOD, 1, recordRealTime, false);
+
+    tracer.inboundWireSize(34);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_SERVER_RECEIVED_BYTES_PER_METHOD, 34, recordRealTime, false);
+
+    tracer.inboundUncompressedSize(67);
+
+    fakeClock.forwardTime(100, MILLISECONDS);
+    tracer.outboundMessage(0);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_SERVER_SENT_MESSAGES_PER_METHOD, 1, recordRealTime, false);
+
+    tracer.outboundWireSize(1028);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_SERVER_SENT_BYTES_PER_METHOD, 1028, recordRealTime, false);
+
+    tracer.outboundUncompressedSize(1128);
+
+    fakeClock.forwardTime(16, MILLISECONDS);
+    tracer.inboundMessage(1);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_SERVER_RECEIVED_MESSAGES_PER_METHOD, 1, recordRealTime, false);
+
+    tracer.inboundWireSize(154);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_SERVER_RECEIVED_BYTES_PER_METHOD, 154, recordRealTime, false);
+
+    tracer.inboundUncompressedSize(552);
+    tracer.outboundMessage(1);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_SERVER_SENT_MESSAGES_PER_METHOD, 1, recordRealTime, false);
+
+    tracer.outboundWireSize(99);
+    assertRealTimeMetric(
+        RpcMeasureConstants.GRPC_SERVER_SENT_BYTES_PER_METHOD, 99, recordRealTime, false);
+
+    tracer.outboundUncompressedSize(865);
+
+    fakeClock.forwardTime(24, MILLISECONDS);
+
+    tracer.streamClosed(Status.CANCELLED);
+
+    if (recordFinishes) {
+      StatsTestUtils.MetricsRecord record = statsRecorder.pollRecord();
+      assertNotNull(record);
+      assertNoClientContent(record);
+      TagValue methodTag = record.tags.get(RpcMeasureConstants.GRPC_SERVER_METHOD);
+      assertEquals(method.getFullMethodName(), methodTag.asString());
+      TagValue statusTag = record.tags.get(RpcMeasureConstants.GRPC_SERVER_STATUS);
+      assertEquals(Status.Code.CANCELLED.toString(), statusTag.asString());
+      assertEquals(
+          1, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_SERVER_FINISHED_COUNT));
+      assertEquals(
+          1, record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_SERVER_ERROR_COUNT));
+      assertEquals(
+          2, record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_SENT_MESSAGES_PER_RPC));
+      assertEquals(
+          1028 + 99,
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_SENT_BYTES_PER_RPC));
+      assertEquals(
+          1128 + 865,
+          record.getMetricAsLongOrFail(
+              DeprecatedCensusConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES));
+      assertEquals(
+          2,
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_RECEIVED_MESSAGES_PER_RPC));
+      assertEquals(
+          34 + 154,
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_RECEIVED_BYTES_PER_RPC));
+      assertEquals(67 + 552,
+          record.getMetricAsLongOrFail(
+              DeprecatedCensusConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES));
+      assertEquals(100 + 16 + 24,
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_SERVER_LATENCY));
+    } else {
+      assertNull(statsRecorder.pollRecord());
+    }
+  }
+
+  @SuppressWarnings("deprecation")
+  @Test
+  public void serverBasicTracingNoHeaders() {
+    ServerStreamTracer.Factory tracerFactory = censusTracing.getServerTracerFactory();
+    ServerStreamTracer serverStreamTracer =
+        tracerFactory.newServerStreamTracer(method.getFullMethodName(), new Metadata());
+    verifyNoInteractions(mockTracingPropagationHandler);
+    verify(tracer).spanBuilderWithRemoteParent(
+        eq("Recv.package1.service2.method3"), ArgumentMatchers.<SpanContext>isNull());
+    verify(spyServerSpanBuilder).setRecordEvents(eq(true));
+
+    Context filteredContext = serverStreamTracer.filterContext(Context.ROOT);
+    assertSame(spyServerSpan, io.opencensus.trace.unsafe.ContextUtils.getValue(filteredContext));
+
+    serverStreamTracer.serverCallStarted(
+        new CallInfo<>(method, Attributes.EMPTY, null));
+
+    verify(spyServerSpan, never()).end(any(EndSpanOptions.class));
+
+    serverStreamTracer.outboundMessage(0);
+    serverStreamTracer.outboundMessageSent(0, 882, -1);
+    serverStreamTracer.inboundMessage(0);
+    serverStreamTracer.outboundMessage(1);
+    serverStreamTracer.outboundMessageSent(1, -1, 27);
+    serverStreamTracer.inboundMessageRead(0, 255, 90);
+
+    serverStreamTracer.streamClosed(Status.CANCELLED);
+
+    InOrder inOrder = inOrder(spyServerSpan);
+    inOrder.verify(spyServerSpan, times(2)).addMessageEvent(messageEventCaptor.capture());
+    List<MessageEvent> events = messageEventCaptor.getAllValues();
+    assertEquals(
+        MessageEvent.builder(MessageEvent.Type.SENT, 0).setCompressedMessageSize(882).build(),
+        events.get(0));
+    assertEquals(
+        MessageEvent.builder(MessageEvent.Type.SENT, 1).setUncompressedMessageSize(27).build(),
+        events.get(1));
+
+    ArgumentCaptor<String> stringCaptor = ArgumentCaptor.forClass(String.class);
+    inOrder.verify(spyServerSpan, times(1))
+        .addAnnotation(stringCaptor.capture(), annotationAttributesCaptor.capture());
+    assertEquals("↘ 255 bytes received", stringCaptor.getValue());
+    assertThat(annotationAttributesCaptor.getValue().get("id"))
+        .isEqualTo(AttributeValue.longAttributeValue(0));
+    assertThat(annotationAttributesCaptor.getValue().get("type"))
+        .isEqualTo(AttributeValue.stringAttributeValue("compressed"));
+
+    inOrder.verify(spyServerSpan).end(
+        EndSpanOptions.builder()
+            .setStatus(io.opencensus.trace.Status.CANCELLED)
+            .setSampleToLocalSpanStore(false)
+            .build());
+    verifyNoMoreInteractions(spyServerSpan);
+  }
+
+  @Test
+  public void serverTracingSampledToLocalSpanStore() {
+    ServerStreamTracer.Factory tracerFactory = censusTracing.getServerTracerFactory();
+    ServerStreamTracer serverStreamTracer =
+        tracerFactory.newServerStreamTracer(sampledMethod.getFullMethodName(), new Metadata());
+
+    serverStreamTracer.filterContext(Context.ROOT);
+
+    serverStreamTracer.serverCallStarted(
+        new CallInfo<>(sampledMethod, Attributes.EMPTY, null));
+
+    serverStreamTracer.streamClosed(Status.CANCELLED);
+
+    verify(spyServerSpan).end(
+        EndSpanOptions.builder()
+            .setStatus(io.opencensus.trace.Status.CANCELLED)
+            .setSampleToLocalSpanStore(true)
+            .build());
+  }
+
+  @Test
+  public void serverTracingNotSampledToLocalSpanStore_whenServerCallNotCreated() {
+    ServerStreamTracer.Factory tracerFactory = censusTracing.getServerTracerFactory();
+    ServerStreamTracer serverStreamTracer =
+        tracerFactory.newServerStreamTracer(sampledMethod.getFullMethodName(), new Metadata());
+
+    serverStreamTracer.streamClosed(Status.CANCELLED);
+
+    verify(spyServerSpan).end(
+        EndSpanOptions.builder()
+            .setStatus(io.opencensus.trace.Status.CANCELLED)
+            .setSampleToLocalSpanStore(false)
+            .build());
+  }
+
+  @Test
+  public void convertToTracingStatus() {
+    // Without description
+    for (Status.Code grpcCode : Status.Code.values()) {
+      Status grpcStatus = Status.fromCode(grpcCode);
+      io.opencensus.trace.Status tracingStatus =
+          CensusTracingModule.convertStatus(grpcStatus);
+      assertEquals(grpcCode.toString(), tracingStatus.getCanonicalCode().toString());
+      assertNull(tracingStatus.getDescription());
+    }
+
+    // With description
+    for (Status.Code grpcCode : Status.Code.values()) {
+      Status grpcStatus = Status.fromCode(grpcCode).withDescription("This is my description");
+      io.opencensus.trace.Status tracingStatus =
+          CensusTracingModule.convertStatus(grpcStatus);
+      assertEquals(grpcCode.toString(), tracingStatus.getCanonicalCode().toString());
+      assertEquals(grpcStatus.getDescription(), tracingStatus.getDescription());
+    }
+  }
+
+
+  @Test
+  public void generateTraceSpanName() {
+    assertEquals(
+        "Sent.io.grpc.Foo", CensusTracingModule.generateTraceSpanName(false, "io.grpc/Foo"));
+    assertEquals(
+        "Recv.io.grpc.Bar", CensusTracingModule.generateTraceSpanName(true, "io.grpc/Bar"));
+  }
+
+  private static void assertNoServerContent(StatsTestUtils.MetricsRecord record) {
+    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_SERVER_ERROR_COUNT));
+    assertNull(record.getMetric(RpcMeasureConstants.GRPC_SERVER_RECEIVED_MESSAGES_PER_RPC));
+    assertNull(record.getMetric(RpcMeasureConstants.GRPC_SERVER_SENT_MESSAGES_PER_RPC));
+    assertNull(record.getMetric(RpcMeasureConstants.GRPC_SERVER_RECEIVED_BYTES_PER_RPC));
+    assertNull(record.getMetric(RpcMeasureConstants.GRPC_SERVER_SENT_BYTES_PER_RPC));
+    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_SERVER_SERVER_ELAPSED_TIME));
+    assertNull(record.getMetric(RpcMeasureConstants.GRPC_SERVER_SERVER_LATENCY));
+    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES));
+    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES));
+  }
+
+  private static void assertNoClientContent(StatsTestUtils.MetricsRecord record) {
+    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_ERROR_COUNT));
+    assertNull(record.getMetric(RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_RPC));
+    assertNull(record.getMetric(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_RPC));
+    assertNull(record.getMetric(RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC));
+    assertNull(record.getMetric(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_RPC));
+    assertNull(record.getMetric(RpcMeasureConstants.GRPC_CLIENT_ROUNDTRIP_LATENCY));
+    assertNull(record.getMetric(RpcMeasureConstants.GRPC_CLIENT_SERVER_LATENCY));
+    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
+    assertNull(record.getMetric(DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
+  }
+
+  @Deprecated
+  @Test
+  public void newTagsPopulateOldViews() throws InterruptedException {
+    StatsComponent localStats = new StatsComponentImpl();
+
+    // Test views that contain both of the remap tags: method & status.
+    localStats.getViewManager().registerView(RpcViewConstants.RPC_CLIENT_ERROR_COUNT_VIEW);
+    localStats.getViewManager().registerView(RpcViewConstants.GRPC_CLIENT_COMPLETED_RPC_VIEW);
+
+    CensusStatsModule localCensusStats = new CensusStatsModule(
+        tagger, tagCtxSerializer, localStats.getStatsRecorder(), fakeClock.getStopwatchSupplier(),
+        false, false, true, false /* real-time */, true);
+
+    CensusStatsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CensusStatsModule.CallAttemptsTracerFactory(
+            localCensusStats, tagger.empty(), method.getFullMethodName());
+
+    Metadata headers = new Metadata();
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, headers);
+    tracer.streamCreated(Attributes.EMPTY, headers);
+    fakeClock.forwardTime(30, MILLISECONDS);
+    Status status = Status.PERMISSION_DENIED.withDescription("No you don't");
+    tracer.streamClosed(status);
+    callAttemptsTracerFactory.callEnded(status);
+
+    // Give OpenCensus a chance to update the views asynchronously.
+    Thread.sleep(100);
+
+    assertWithMessage("Legacy error count view had unexpected count")
+        .that(
+          getAggregationValueAsLong(
+              localStats,
+              RpcViewConstants.RPC_CLIENT_ERROR_COUNT_VIEW,
+              ImmutableList.of(
+                  TagValue.create("PERMISSION_DENIED"),
+                  TagValue.create(method.getFullMethodName()))))
+        .isEqualTo(1);
+
+    assertWithMessage("New error count view had unexpected count")
+        .that(
+          getAggregationValueAsLong(
+              localStats,
+              RpcViewConstants.GRPC_CLIENT_COMPLETED_RPC_VIEW,
+              ImmutableList.of(
+                  TagValue.create(method.getFullMethodName()),
+                  TagValue.create("PERMISSION_DENIED"))))
+        .isEqualTo(1);
+  }
+
+  @Deprecated
+  private long getAggregationValueAsLong(StatsComponent localStats, View view,
+      List<TagValue> dimension) {
+    AggregationData aggregationData = localStats.getViewManager()
+        .getView(view.getName())
+        .getAggregationMap()
+        .get(dimension);
+
+    return aggregationData.match(
+        new Function<SumDataDouble, Long>() {
+          @Override
+          public Long apply(SumDataDouble arg) {
+            return (long) arg.getSum();
+          }
+        },
+        Functions.<Long>throwAssertionError(),
+        new Function<CountData, Long>() {
+          @Override
+          public Long apply(CountData arg) {
+            return arg.getCount();
+          }
+        },
+        Functions.<Long>throwAssertionError(),
+        new Function<LastValueDataDouble, Long>() {
+          @Override
+          public Long apply(LastValueDataDouble arg) {
+            return (long) arg.getLastValue();
+          }
+        },
+        new Function<LastValueDataLong, Long>() {
+          @Override
+          public Long apply(LastValueDataLong arg) {
+            return arg.getLastValue();
+          }
+        },
+        new Function<AggregationData, Long>() {
+          @Override
+          public Long apply(AggregationData arg) {
+            return ((AggregationData.MeanData) arg).getCount();
+          }
+        });
+  }
+
+  @Test
+  public void callLatencyView() throws InterruptedException {
+    StatsComponent localStats = new StatsComponentImpl();
+
+    localStats
+        .getViewManager()
+        .registerView(ObservabilityCensusConstants.GRPC_CLIENT_API_LATENCY_VIEW);
+
+    CensusStatsModule localCensusStats = new CensusStatsModule(
+        tagger, tagCtxSerializer, localStats.getStatsRecorder(), fakeClock.getStopwatchSupplier(),
+        false, false, true, false /* real-time */, true);
+
+    CensusStatsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CensusStatsModule.CallAttemptsTracerFactory(
+            localCensusStats, tagger.empty(), method.getFullMethodName());
+
+    Metadata headers = new Metadata();
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, headers);
+    tracer.streamCreated(Attributes.EMPTY, headers);
+    fakeClock.forwardTime(50, MILLISECONDS);
+    Status status = Status.OK.withDescription("Success");
+    tracer.streamClosed(status);
+    callAttemptsTracerFactory.callEnded(status);
+
+    // Give OpenCensus a chance to update the views asynchronously.
+    Thread.sleep(100);
+
+    assertDistributionData(
+        localStats,
+        ObservabilityCensusConstants.GRPC_CLIENT_API_LATENCY_VIEW,
+        ImmutableList.of(TagValue.create(method.getFullMethodName()), TagValue.create("OK")),
+        50.0, 1, 0.0,
+        ImmutableList.of(
+            0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 1L,
+            0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L));
+  }
+
+  private void assertDistributionData(StatsComponent localStats, View view,
+      List<TagValue> dimension, double mean, long count, double sumOfSquaredDeviations,
+      List<Long> expectedBucketCounts) {
+    AggregationData aggregationData = localStats.getViewManager()
+        .getView(view.getName())
+        .getAggregationMap()
+        .get(dimension);
+
+    aggregationData.match(
+        Functions.</*@Nullable*/ Void>throwAssertionError(),
+        Functions.</*@Nullable*/ Void>throwAssertionError(),
+        Functions.</*@Nullable*/ Void>throwAssertionError(),
+        /* p3= */ new Function<AggregationData.DistributionData, Void>() {
+          @Override
+          public Void apply(AggregationData.DistributionData arg) {
+            assertThat(arg.getMean()).isWithin(TOLERANCE).of(mean);
+            assertThat(arg.getCount()).isEqualTo(count);
+            assertThat(arg.getSumOfSquaredDeviations())
+                .isWithin(TOLERANCE)
+                .of(sumOfSquaredDeviations);
+            assertThat(arg.getBucketCounts())
+                .containsExactlyElementsIn(expectedBucketCounts)
+                .inOrder();
+            return null;
+          }
+        },
+        Functions.</*@Nullable*/ Void>throwAssertionError(),
+        Functions.</*@Nullable*/ Void>throwAssertionError(),
+        new Function<AggregationData, Void>() {
+          @Override
+          public Void apply(AggregationData arg) {
+            assertThat(((AggregationData.DistributionData) arg).getCount()).isEqualTo(count);
+            return null;
+          }
+        });
+  }
+
+  static class CallInfo<ReqT, RespT> extends ServerCallInfo<ReqT, RespT> {
+    private final MethodDescriptor<ReqT, RespT> methodDescriptor;
+    private final Attributes attributes;
+    private final String authority;
+
+    CallInfo(
+        MethodDescriptor<ReqT, RespT> methodDescriptor,
+        Attributes attributes,
+        @Nullable String authority) {
+      this.methodDescriptor = methodDescriptor;
+      this.attributes = attributes;
+      this.authority = authority;
+    }
+
+    @Override
+    public MethodDescriptor<ReqT, RespT> getMethodDescriptor() {
+      return methodDescriptor;
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return attributes;
+    }
+
+    @Nullable
+    @Override
+    public String getAuthority() {
+      return authority;
+    }
+  }
+}
diff --git a/census/src/test/java/io/grpc/census/CensusTracingAnnotationEventTest.java b/census/src/test/java/io/grpc/census/CensusTracingAnnotationEventTest.java
new file mode 100644
index 00000000000..8d7d2b2b7c3
--- /dev/null
+++ b/census/src/test/java/io/grpc/census/CensusTracingAnnotationEventTest.java
@@ -0,0 +1,283 @@
+/*
+ * Copyright 2022 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.census;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.when;
+
+import io.grpc.Attributes;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.census.CensusTracingModule.CallAttemptsTracerFactory;
+import io.grpc.internal.testing.StatsTestUtils.FakeStatsRecorder;
+import io.grpc.internal.testing.StatsTestUtils.MockableSpan;
+import io.grpc.testing.GrpcServerRule;
+import io.opencensus.trace.AttributeValue;
+import io.opencensus.trace.MessageEvent;
+import io.opencensus.trace.Span;
+import io.opencensus.trace.SpanBuilder;
+import io.opencensus.trace.SpanContext;
+import io.opencensus.trace.Tracer;
+import io.opencensus.trace.propagation.BinaryFormat;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Test for {@link CensusTracingModule}.
+ */
+@RunWith(JUnit4.class)
+public class CensusTracingAnnotationEventTest {
+  private static final ClientStreamTracer.StreamInfo STREAM_INFO =
+      ClientStreamTracer.StreamInfo.newBuilder().build();
+
+  private static class StringInputStream extends InputStream {
+    final String string;
+
+    StringInputStream(String string) {
+      this.string = string;
+    }
+
+    @Override
+    public int read() {
+      // InProcessTransport doesn't actually read bytes from the InputStream.  The InputStream is
+      // passed to the InProcess server and consumed by MARSHALLER.parse().
+      throw new UnsupportedOperationException("Should not be called");
+    }
+  }
+
+  private static final MethodDescriptor.Marshaller<String> MARSHALLER =
+      new MethodDescriptor.Marshaller<String>() {
+        @Override
+        public InputStream stream(String value) {
+          return new StringInputStream(value);
+        }
+
+        @Override
+        public String parse(InputStream stream) {
+          return ((StringInputStream) stream).string;
+        }
+      };
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private final MethodDescriptor<String, String> method =
+      MethodDescriptor.<String, String>newBuilder()
+          .setType(MethodDescriptor.MethodType.UNKNOWN)
+          .setRequestMarshaller(MARSHALLER)
+          .setResponseMarshaller(MARSHALLER)
+          .setFullMethodName("package1.service2/method3")
+          .build();
+
+  private final FakeStatsRecorder statsRecorder = new FakeStatsRecorder();
+  private final Random random = new Random(1234);
+  private final Span spyClientSpan = spy(MockableSpan.generateRandomSpan(random));
+  private final Span spyAttemptSpan = spy(MockableSpan.generateRandomSpan(random));
+  private final SpanContext fakeAttemptSpanContext = spyAttemptSpan.getContext();
+  private final Span spyServerSpan = spy(MockableSpan.generateRandomSpan(random));
+  private final byte[] binarySpanContext = new byte[]{3, 1, 5};
+  private final SpanBuilder spyClientSpanBuilder = spy(new MockableSpan.Builder());
+  private final SpanBuilder spyAttemptSpanBuilder = spy(new MockableSpan.Builder());
+  private final SpanBuilder spyServerSpanBuilder = spy(new MockableSpan.Builder());
+
+  @Rule
+  public final GrpcServerRule grpcServerRule = new GrpcServerRule().directExecutor();
+
+  @Mock
+  private Tracer tracer;
+  @Mock
+  private BinaryFormat mockTracingPropagationHandler;
+
+  @Captor
+  private ArgumentCaptor<MessageEvent> messageEventCaptor;
+  @Captor
+  private ArgumentCaptor<Map<String, AttributeValue>> annotationAttributesCaptor;
+  private ArgumentCaptor<String> stringCaptor;
+
+  private CensusTracingModule censusTracing;
+
+  @Before
+  public void setUp() throws Exception {
+    when(spyClientSpanBuilder.startSpan()).thenReturn(spyClientSpan);
+    when(spyAttemptSpanBuilder.startSpan()).thenReturn(spyAttemptSpan);
+    when(tracer.spanBuilderWithExplicitParent(
+            eq("Sent.package1.service2.method3"), ArgumentMatchers.<Span>any()))
+        .thenReturn(spyClientSpanBuilder);
+    when(tracer.spanBuilderWithExplicitParent(
+            eq("Attempt.package1.service2.method3"), ArgumentMatchers.<Span>any()))
+        .thenReturn(spyAttemptSpanBuilder);
+    when(spyServerSpanBuilder.startSpan()).thenReturn(spyServerSpan);
+    when(tracer.spanBuilderWithRemoteParent(anyString(), ArgumentMatchers.<SpanContext>any()))
+        .thenReturn(spyServerSpanBuilder);
+    when(mockTracingPropagationHandler.toByteArray(any(SpanContext.class)))
+        .thenReturn(binarySpanContext);
+    when(mockTracingPropagationHandler.fromByteArray(any(byte[].class)))
+        .thenReturn(fakeAttemptSpanContext);
+    stringCaptor = ArgumentCaptor.forClass(String.class);
+
+    censusTracing = new CensusTracingModule(tracer, mockTracingPropagationHandler);
+  }
+
+  @After
+  public void wrapUp() {
+    assertNull(statsRecorder.pollRecord());
+  }
+
+  @Test
+  public void clientBasicTracingUncompressedSizeAnnotation() {
+    CallAttemptsTracerFactory callTracer =
+        censusTracing.newClientCallTracer(spyClientSpan, method);
+    Metadata headers = new Metadata();
+    ClientStreamTracer clientStreamTracer = callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    clientStreamTracer.streamCreated(Attributes.EMPTY, headers);
+
+    clientStreamTracer.outboundMessage(0);
+    clientStreamTracer.outboundMessageSent(0, 882, -1);
+    clientStreamTracer.inboundMessage(0);
+    clientStreamTracer.outboundMessage(1);
+    clientStreamTracer.outboundMessageSent(1, -1, 27);
+    clientStreamTracer.inboundMessageRead(0, 255, 90);
+    clientStreamTracer.inboundUncompressedSize(90);
+    clientStreamTracer.inboundMessage(1);
+    clientStreamTracer.inboundMessageRead(1, 128, 60);
+    clientStreamTracer.inboundUncompressedSize(60);
+
+    clientStreamTracer.streamClosed(Status.OK);
+    callTracer.callEnded(Status.OK);
+
+    InOrder inOrder = inOrder(spyClientSpan, spyAttemptSpan);
+    inOrder.verify(spyAttemptSpan, times(2)).addMessageEvent(messageEventCaptor.capture());
+    List<MessageEvent> events = messageEventCaptor.getAllValues();
+    assertEquals(
+        MessageEvent.builder(MessageEvent.Type.SENT, 0).setCompressedMessageSize(882).build(),
+        events.get(0));
+    assertEquals(
+        MessageEvent.builder(MessageEvent.Type.SENT, 1).setUncompressedMessageSize(27).build(),
+        events.get(1));
+
+    inOrder
+        .verify(spyAttemptSpan, times(1))
+        .addAnnotation(stringCaptor.capture(), annotationAttributesCaptor.capture());
+    assertEquals("↘ 255 bytes received", stringCaptor.getValue());
+    assertThat(annotationAttributesCaptor.getValue().get("id"))
+        .isEqualTo(AttributeValue.longAttributeValue(0));
+    assertThat(annotationAttributesCaptor.getValue().get("type"))
+        .isEqualTo(AttributeValue.stringAttributeValue("compressed"));
+
+    inOrder
+        .verify(spyClientSpan, times(1))
+        .addAnnotation(stringCaptor.capture(), annotationAttributesCaptor.capture());
+    assertEquals("↘ 90 bytes received", stringCaptor.getValue());
+    assertThat(annotationAttributesCaptor.getValue().get("id"))
+        .isEqualTo(AttributeValue.longAttributeValue(0));
+    assertThat(annotationAttributesCaptor.getValue().get("type"))
+        .isEqualTo(AttributeValue.stringAttributeValue("uncompressed"));
+
+    inOrder
+        .verify(spyAttemptSpan, times(1))
+        .addAnnotation(stringCaptor.capture(), annotationAttributesCaptor.capture());
+    assertEquals("↘ 128 bytes received", stringCaptor.getValue());
+    assertThat(annotationAttributesCaptor.getValue().get("id"))
+        .isEqualTo(AttributeValue.longAttributeValue(1));
+    assertThat(annotationAttributesCaptor.getValue().get("type"))
+        .isEqualTo(AttributeValue.stringAttributeValue("compressed"));
+
+    inOrder
+        .verify(spyClientSpan, times(1))
+        .addAnnotation(stringCaptor.capture(), annotationAttributesCaptor.capture());
+    assertEquals("↘ 60 bytes received", stringCaptor.getValue());
+    assertThat(annotationAttributesCaptor.getValue().get("id"))
+        .isEqualTo(AttributeValue.longAttributeValue(1));
+    assertThat(annotationAttributesCaptor.getValue().get("type"))
+        .isEqualTo(AttributeValue.stringAttributeValue("uncompressed"));
+  }
+
+  @Test
+  public void serverBasicTracingUncompressedSizeAnnotation() {
+    ServerStreamTracer.Factory tracerFactory = censusTracing.getServerTracerFactory();
+    ServerStreamTracer serverStreamTracer =
+        tracerFactory.newServerStreamTracer(method.getFullMethodName(), new Metadata());
+
+    serverStreamTracer.serverCallStarted(
+        new CensusModulesTest.CallInfo<>(method, Attributes.EMPTY, null));
+
+    serverStreamTracer.outboundMessage(0);
+    serverStreamTracer.outboundMessageSent(0, 882, -1);
+    serverStreamTracer.inboundMessage(0);
+    serverStreamTracer.outboundMessage(1);
+    serverStreamTracer.outboundMessageSent(1, -1, 27);
+    serverStreamTracer.inboundMessageRead(0, 255, 90);
+    serverStreamTracer.inboundUncompressedSize(90);
+
+    serverStreamTracer.streamClosed(Status.CANCELLED);
+
+    InOrder inOrder = inOrder(spyServerSpan);
+    inOrder.verify(spyServerSpan, times(2)).addMessageEvent(messageEventCaptor.capture());
+    List<MessageEvent> events = messageEventCaptor.getAllValues();
+    assertEquals(
+        MessageEvent.builder(MessageEvent.Type.SENT, 0).setCompressedMessageSize(882).build(),
+        events.get(0));
+    assertEquals(
+        MessageEvent.builder(MessageEvent.Type.SENT, 1).setUncompressedMessageSize(27).build(),
+        events.get(1));
+
+    inOrder
+        .verify(spyServerSpan, times(2))
+        .addAnnotation(stringCaptor.capture(), annotationAttributesCaptor.capture());
+    List<String> annotationDescriptions = stringCaptor.getAllValues();
+    List<Map<String, AttributeValue>> annotationAttributes =
+        annotationAttributesCaptor.getAllValues();
+
+    assertEquals("↘ 255 bytes received", annotationDescriptions.get(0));
+    assertThat(annotationAttributes.get(0).get("id"))
+        .isEqualTo(AttributeValue.longAttributeValue(0));
+    assertThat(annotationAttributes.get(0).get("type"))
+        .isEqualTo(AttributeValue.stringAttributeValue("compressed"));
+
+    assertEquals("↘ 90 bytes received", annotationDescriptions.get(1));
+    assertThat(annotationAttributes.get(1).get("id"))
+        .isEqualTo(AttributeValue.longAttributeValue(0));
+    assertThat(annotationAttributes.get(1).get("type"))
+        .isEqualTo(AttributeValue.stringAttributeValue("uncompressed"));
+  }
+}
diff --git a/checkstyle.license b/checkstyle.license
deleted file mode 100644
index 5e307e1ecbc..00000000000
--- a/checkstyle.license
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
diff --git a/compiler/BUILD.bazel b/compiler/BUILD.bazel
new file mode 100644
index 00000000000..e8a0571e134
--- /dev/null
+++ b/compiler/BUILD.bazel
@@ -0,0 +1,57 @@
+load("@rules_cc//cc:defs.bzl", "cc_binary")
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+load("//:java_grpc_library.bzl", "java_rpc_toolchain")
+
+# This should not generally be referenced. Users should use java_grpc_library
+cc_binary(
+    name = "grpc_java_plugin",
+    srcs = [
+        "src/java_plugin/cpp/java_generator.cpp",
+        "src/java_plugin/cpp/java_generator.h",
+        "src/java_plugin/cpp/java_plugin.cpp",
+    ],
+    visibility = ["//visibility:public"],
+    deps = [
+        "@com_google_protobuf//:protoc_lib",
+    ],
+)
+
+java_library(
+    name = "java_grpc_library_deps__do_not_reference",
+    visibility = ["//xds:__pkg__"],
+    exports = [
+        "//api",
+        "//protobuf",
+        "//stub",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
+        "@com_google_protobuf//:protobuf_java",
+    ],
+)
+
+java_library(
+    name = "java_lite_grpc_library_deps__do_not_reference",
+    exports = [
+        "//api",
+        "//protobuf-lite",
+        "//stub",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
+    ],
+)
+
+java_rpc_toolchain(
+    name = "java_grpc_library_toolchain",
+    plugin = "//compiler:grpc_java_plugin",
+    runtime = [":java_grpc_library_deps__do_not_reference"],
+    visibility = ["//visibility:public"],
+)
+
+java_rpc_toolchain(
+    name = "java_lite_grpc_library_toolchain",
+    plugin = "//compiler:grpc_java_plugin",
+    plugin_arg = "lite",
+    runtime = [":java_lite_grpc_library_deps__do_not_reference"],
+    visibility = ["//visibility:public"],
+)
diff --git a/compiler/Dockerfile b/compiler/Dockerfile
deleted file mode 100644
index 6d1b5273fff..00000000000
--- a/compiler/Dockerfile
+++ /dev/null
@@ -1,20 +0,0 @@
-FROM protoc-artifacts:latest
-
-RUN scl enable devtoolset-1.1 'bash -c "cd /protobuf && \
-    git fetch && \
-    git checkout v3.2.0 && \
-    ./autogen.sh && \
-    CXXFLAGS=-m32 ./configure --disable-shared --prefix=/protobuf-32 && \
-    make clean && make -j$(nproc) && make -j$(nproc) install"'
-
-RUN scl enable devtoolset-1.1 'bash -c "cd /protobuf && \
-    CXXFLAGS=-m64 ./configure --disable-shared --prefix=/protobuf-64 && \
-    make clean && make -j$(nproc) && make -j$(nproc) install"'
-
-ENV CXXFLAGS=-I/protobuf-32/include \
-    LDFLAGS="-L/protobuf-32/lib -L/protobuf-64/lib"
-
-RUN git clone --depth 1 https://github.com/grpc/grpc-java.git
-
-# Start in devtoolset environment that uses GCC 4.7
-CMD ["scl", "enable", "devtoolset-1.1", "bash"]
diff --git a/compiler/README.md b/compiler/README.md
index 2cd1aee0d49..25e557d82eb 100644
--- a/compiler/README.md
+++ b/compiler/README.md
@@ -5,18 +5,20 @@ This generates the Java interfaces out of the service definition from a
 `.proto` file. It works with the Protobuf Compiler (``protoc``).
 
 Normally you don't need to compile the codegen by yourself, since pre-compiled
-binaries for common platforms are available on Maven Central. However, if the
-pre-compiled binaries are not compatible with your system, you may want to
-build your own codegen.
+binaries for common platforms are available on Maven Central:
 
-## System requirement
+1. Navigate to https://mvnrepository.com/artifact/io.grpc/protoc-gen-grpc-java
+2. Click into a version
+3. Click "Files"
 
-* Linux, Mac OS X with Clang, or Windows with MSYS2
-* Java 7 or up
-* [Protobuf](https://github.com/google/protobuf) 3.0.0-beta-3 or up
+However, if the pre-compiled binaries are not compatible with your system,
+you may want to build your own codegen.
 
 ## Compiling and testing the codegen
-Change to the `compiler` directory:
+
+Set up your system as described in [COMPILING.md](../COMPILING.md).
+
+Then change to the `compiler` directory:
 ```
 $ cd $GRPC_JAVA_ROOT/compiler
 ```
@@ -34,28 +36,23 @@ You will see a `PASS` if the test succeeds.
 
 To compile a proto file and generate Java interfaces out of the service definitions:
 ```
-$ protoc --plugin=protoc-gen-grpc-java=build/binaries/java_pluginExecutable/protoc-gen-grpc-java \
+$ protoc --plugin=protoc-gen-grpc-java=build/exe/java_plugin/protoc-gen-grpc-java \
   --grpc-java_out="$OUTPUT_FILE" --proto_path="$DIR_OF_PROTO_FILE" "$PROTO_FILE"
 ```
 To generate Java interfaces with protobuf lite:
 ```
-$ protoc --plugin=protoc-gen-grpc-java=build/binaries/java_pluginExecutable/protoc-gen-grpc-java \
+$ protoc --plugin=protoc-gen-grpc-java=build/exe/java_plugin/protoc-gen-grpc-java \
   --grpc-java_out=lite:"$OUTPUT_FILE" --proto_path="$DIR_OF_PROTO_FILE" "$PROTO_FILE"
 ```
-To generate Java interfaces with protobuf nano:
-```
-$ protoc --plugin=protoc-gen-grpc-java=build/binaries/java_pluginExecutable/protoc-gen-grpc-java \
-  --grpc-java_out=nano:"$OUTPUT_FILE" --proto_path="$DIR_OF_PROTO_FILE" "$PROTO_FILE"
-```
 
 ## Installing the codegen to Maven local repository
 This will compile a codegen and put it under your ``~/.m2/repository``. This
 will make it available to any build tool that pulls codegens from Maven
-repostiories.
+repositories.
 ```
-$ ../gradlew install
+$ ../gradlew publishToMavenLocal
 ```
 
-## Creating a release of GRPC Java
+## Creating a release of gRPC Java
 Please follow the instructions in ``RELEASING.md`` under the root directory for
 details on how to create a new release.
diff --git a/compiler/build.gradle b/compiler/build.gradle
index e52aaa23042..f970f629e19 100644
--- a/compiler/build.gradle
+++ b/compiler/build.gradle
@@ -1,26 +1,21 @@
-apply plugin: "cpp"
-apply plugin: "com.google.protobuf"
+plugins {
+    id "cpp"
+    id "java"
+    id "maven-publish"
 
-description = 'The protoc plugin for gRPC Java'
-
-buildscript {
-    repositories {
-        mavenCentral()
-        mavenLocal()
-    }
-    dependencies {
-        classpath libraries.protobuf_plugin
-    }
+    id "com.google.protobuf"
 }
 
+description = 'The protoc plugin for gRPC Java'
+
 def artifactStagingPath = "$buildDir/artifacts" as File
 // Adds space-delimited arguments from the environment variable env to the
 // argList.
 def addEnvArgs = { env, argList ->
-  def value = System.getenv(env)
-  if (value != null) {
-    value.split(' +').each() { it -> argList.add(it) }
-  }
+    def value = System.getenv(env)
+    if (value != null) {
+        value.split(' +').each() { it -> argList.add(it) }
+    }
 }
 
 // Adds corresponding "-l" option to the argList if libName is not found in
@@ -29,265 +24,312 @@ def addEnvArgs = { env, argList ->
 // order to get statically linked, otherwise we add the libraries through "-l"
 // so that they can be searched for in default search paths.
 def addLibraryIfNotLinked = { libName, argList ->
-  def ldflags = System.env.LDFLAGS
-  if (ldflags == null || !ldflags.contains('lib' + libName + '.a')) {
-    argList.add('-l' + libName)
-  }
+    def ldflags = System.env.LDFLAGS
+    if (ldflags == null || !ldflags.contains('lib' + libName + '.a')) {
+        argList.add('-l' + libName)
+    }
 }
 
 def String arch = rootProject.hasProperty('targetArch') ? rootProject.targetArch : osdetector.arch
 def boolean vcDisable = rootProject.hasProperty('vcDisable') ? rootProject.vcDisable : false
+def boolean usingVisualCpp // Whether VisualCpp is actually available and selected
 
 model {
-  toolChains {
-    // If you have both VC and Gcc installed, VC will be selected, unless you
-    // set 'vcDisable=true'
-    if (!vcDisable) {
-      visualCpp(VisualCpp) {
-      }
-    }
-    gcc(Gcc) {
-      target("ppcle_64")
-    }
-    clang(Clang) {
+    toolChains {
+        // If you have both VC and Gcc installed, VC will be selected, unless you
+        // set 'vcDisable=true'
+        if (!vcDisable) {
+            visualCpp(VisualCpp) {
+                // Prefer vcvars-provided environment over registry-discovered environment
+                def String vsDir = System.getenv("VSINSTALLDIR")
+                def String winDir = System.getenv("WindowsSdkDir")
+                if (vsDir != null && winDir != null) {
+                    installDir = vsDir
+                    windowsSdkDir = winDir
+                }
+            }
+        }
+        gcc(Gcc) {
+            target("ppcle_64") {
+                cppCompiler.executable = 'powerpc64le-linux-gnu-g++'
+                linker.executable = 'powerpc64le-linux-gnu-g++'
+            }
+            target("aarch_64") {
+                cppCompiler.executable = 'aarch64-linux-gnu-g++'
+                linker.executable = 'aarch64-linux-gnu-g++'
+            }
+            target("s390_64") {
+                cppCompiler.executable = 's390x-linux-gnu-g++'
+                linker.executable = 's390x-linux-gnu-g++'
+            }
+            target("loongarch_64")
+        }
+        clang(Clang) {
+            target("aarch_64") {}
+        }
     }
-  }
 
-  platforms {
-    x86_32 {
-      architecture "x86"
+    platforms {
+        x86_32 { architecture "x86" }
+        x86_64 { architecture "x86_64" }
+        ppcle_64 { architecture "ppcle_64" }
+        aarch_64 { architecture "aarch_64" }
+        s390_64 { architecture "s390_64" }
+        loongarch_64 { architecture "loongarch_64" }
+        riscv_64 { architecture "riscv_64" }
     }
-    x86_64 {
-      architecture "x86_64"
-    }
-    ppcle_64 {
-      architecture "ppcle_64"
-    }
-  }
 
-  components {
-    java_plugin(NativeExecutableSpec) {
-      if (arch in ['x86_32', 'x86_64', 'ppcle_64']) {
-        // If arch is not within the defined platforms, we do not specify the
-        // targetPlatform so that Gradle will choose what is appropriate.
-        targetPlatform arch
-      }
-      baseName "$protocPluginBaseName"
+    components {
+        java_plugin(NativeExecutableSpec) {
+            if (arch in [
+                'x86_32',
+                'x86_64',
+                'ppcle_64',
+                'riscv_64',
+                'aarch_64',
+                's390_64',
+                'loongarch_64'
+            ]) {
+                // If arch is not within the defined platforms, we do not specify the
+                // targetPlatform so that Gradle will choose what is appropriate.
+                targetPlatform arch
+            }
+            baseName "$protocPluginBaseName"
+        }
     }
-  }
 
-  binaries {
-    all {
-      if (toolChain in Gcc || toolChain in Clang) {
-        cppCompiler.define("GRPC_VERSION", version)
-        cppCompiler.args "--std=c++0x"
-        addEnvArgs("CXXFLAGS", cppCompiler.args)
-        addEnvArgs("CPPFLAGS", cppCompiler.args)
-        if (osdetector.os == "osx") {
-          cppCompiler.args "-mmacosx-version-min=10.7", "-stdlib=libc++"
-          addLibraryIfNotLinked('protoc', linker.args)
-          addLibraryIfNotLinked('protobuf', linker.args)
-        } else if (osdetector.os == "windows") {
-          linker.args "-static", "-lprotoc", "-lprotobuf", "-static-libgcc", "-static-libstdc++",
-                      "-s"
-        } else {
-          // Link protoc, protobuf, libgcc and libstdc++ statically.
-          // Link other (system) libraries dynamically.
-          // Clang under OSX doesn't support these options.
-          linker.args "-Wl,-Bstatic", "-lprotoc", "-lprotobuf", "-static-libgcc",
-                      "-static-libstdc++",
-                      "-Wl,-Bdynamic", "-lpthread", "-s"
+    binaries {
+        all {
+            if (toolChain in Gcc || toolChain in Clang) {
+                cppCompiler.define("GRPC_VERSION", version)
+                cppCompiler.args "--std=c++17"
+                addEnvArgs("CXXFLAGS", cppCompiler.args)
+                addEnvArgs("CPPFLAGS", cppCompiler.args)
+                if (project.hasProperty('buildUniversal') &&
+                        project.getProperty('buildUniversal').toBoolean() &&
+                        osdetector.os == "osx") {
+                    cppCompiler.args "-arch", "arm64", "-arch", "x86_64"
+                    linker.args "-arch", "arm64", "-arch", "x86_64"
+                }
+                if (osdetector.os == "osx") {
+                    cppCompiler.args "-mmacosx-version-min=10.7", "-stdlib=libc++"
+                    linker.args "-framework", "CoreFoundation"
+                    addLibraryIfNotLinked('protoc', linker.args)
+                    addLibraryIfNotLinked('protobuf', linker.args)
+                } else if (osdetector.os == "windows") {
+                    linker.args "-static", "-lprotoc", "-lprotobuf", "-static-libgcc", "-static-libstdc++",
+                            "-s"
+                } else if (osdetector.arch == "ppcle_64") {
+                    linker.args "-Wl,-Bstatic", "-lprotoc", "-lprotobuf", "-Wl,-Bdynamic", "-lpthread", "-s"
+                } else {
+                    // Link protoc, protobuf, libgcc and libstdc++ statically.
+                    // Link other (system) libraries dynamically.
+                    // Clang under OSX doesn't support these options.
+                    linker.args "-Wl,-Bstatic", "-lprotoc", "-lprotobuf", "-static-libgcc",
+                            "-Wl,-Bdynamic", "-lpthread", "-s"
+                }
+                addEnvArgs("LDFLAGS", linker.args)
+            } else if (toolChain in VisualCpp) {
+                usingVisualCpp = true
+                cppCompiler.define("GRPC_VERSION", version)
+                cppCompiler.args "/EHsc", "/MT", "/std:c++17"
+                if (rootProject.hasProperty('vcProtobufInclude')) {
+                    cppCompiler.args "/I${rootProject.vcProtobufInclude}"
+                } 
+                linker.args.add("libprotoc.lib")
+                linker.args.add("libprotobuf.lib")
+                if (rootProject.hasProperty('vcProtobufLibs')) {
+                    String libsList = rootProject.property('vcProtobufLibs') as String
+                    libsList.split(',').each() { lib -> linker.args.add(lib) }
+                }
+            }
         }
-        addEnvArgs("LDFLAGS", linker.args)
-      } else if (toolChain in VisualCpp) {
-        cppCompiler.define("GRPC_VERSION", version)
-        cppCompiler.args "/EHsc", "/MT"
-        if (rootProject.hasProperty('vcProtobufInclude')) {
-          cppCompiler.args "/I${rootProject.vcProtobufInclude}"
-        }
-        linker.args "libprotobuf.lib", "libprotoc.lib"
-        if (rootProject.hasProperty('vcProtobufLibs')) {
-          linker.args "/LIBPATH:${rootProject.vcProtobufLibs}"
-        }
-      }
     }
-  }
 }
 
-configurations {
-  testLiteCompile
-  testNanoCompile
+sourceSets {
+    testLite {
+        proto { setSrcDirs(['src/test/proto']) }
+    }
 }
 
 dependencies {
-  testCompile project(':grpc-protobuf'),
-              project(':grpc-stub')
-  testLiteCompile project(':grpc-protobuf-lite'),
-                  project(':grpc-stub')
-  testNanoCompile project(':grpc-protobuf-nano'),
-                  project(':grpc-stub')
-}
-
-sourceSets {
-  testLite {
-    proto {
-      setSrcDirs(['src/test/proto'])
-    }
-  }
-  testNano {
-    proto {
-      setSrcDirs(['src/test/proto'])
-    }
-  }
+    testImplementation project(':grpc-protobuf'),
+            project(':grpc-stub')
+    testLiteImplementation project(':grpc-protobuf-lite'),
+            project(':grpc-stub')
 }
 
-compileTestJava {
-  options.compilerArgs += ["-Xlint:-cast"]
+tasks.named("compileTestJava").configure {
+    options.errorprone.excludedPaths = ".*/build/generated/sources/proto/.*"
 }
 
-compileTestLiteJava {
-  // Protobuf-generated Lite produces quite a few warnings.
-  options.compilerArgs += ["-Xlint:-rawtypes", "-Xlint:-unchecked"]
+tasks.named("compileTestLiteJava").configure {
+    options.compilerArgs = compileTestJava.options.compilerArgs
+    options.compilerArgs += [
+        "-Xlint:-cast"
+    ]
+    options.errorprone.excludedPaths = ".*/build/generated/sources/proto/.*"
 }
 
-compileTestNanoJava {
-  options.compilerArgs = compileTestJava.options.compilerArgs
+tasks.named("checkstyleTestLite").configure {
+    enabled = false
 }
 
 protobuf {
-  protoc {
-    if (project.hasProperty('protoc')) {
-      path = project.protoc
-    } else {
-      artifact = "com.google.protobuf:protoc:${protobufVersion}"
-    }
-  }
-  plugins {
-    javalite {
-      if (project.hasProperty('protoc-gen-javalite')) {
-        path = project['protoc-gen-javalite']
-      } else {
-        artifact = libraries.protoc_lite
-      }
-    }
-    grpc {
-      path = javaPluginPath
-    }
-  }
-  generateProtoTasks {
-    all().each { task ->
-      task.dependsOn 'java_pluginExecutable'
-      task.inputs.file javaPluginPath
+    protoc {
+        if (project.hasProperty('protoc')) {
+            path = project.protoc
+        } else {
+            artifact = libs.protobuf.protoc.get()
+        }
     }
-    ofSourceSet('test')*.plugins {
-      grpc {}
+    plugins {
+        grpc { path = javaPluginPath }
     }
-    ofSourceSet('testLite')*.each { task ->
-      task.builtins {
-        remove java
-      }
-      task.plugins {
-        javalite {}
-        grpc {
-          option 'lite'
+    generateProtoTasks {
+        all().configureEach {
+            dependsOn 'java_pluginExecutable'
+            inputs.file javaPluginPath
         }
-      }
-    }
-    ofSourceSet('testNano').each { task ->
-      task.builtins {
-        remove java
-        javanano {
-          option 'ignore_services=true'
+        ofSourceSet('test').configureEach {
+            plugins {
+                grpc {
+                    option '@generated=javax'
+                }
+            }
         }
-      }
-      task.plugins {
-        grpc {
-          option 'nano'
+        ofSourceSet('testLite').configureEach {
+            builtins {
+                java { option 'lite' }
+            }
+            plugins {
+                grpc {
+                    option 'lite'
+                }
+            }
         }
-      }
     }
-  }
 }
 
-checkstyleTestNano {
-  source = fileTree(dir: "src/testNano", include: "**/*.java")
-}
-
-println "*** Building codegen requires Protobuf version ${protobufVersion}"
+println "*** Building codegen requires Protobuf"
 println "*** Please refer to https://github.com/grpc/grpc-java/blob/master/COMPILING.md#how-to-build-code-generation-plugin"
 
-task buildArtifacts(type: Copy) {
-  dependsOn 'java_pluginExecutable'
-  from("$buildDir/exe") {
-    if (osdetector.os != 'windows') {
-      rename 'protoc-gen-grpc-java', '$0.exe'
+tasks.register("buildArtifacts", Copy) {
+    dependsOn 'java_pluginExecutable'
+    from("$buildDir/exe") {
+        if (osdetector.os != 'windows') {
+            rename 'protoc-gen-grpc-java', '$0.exe'
+        }
     }
-  }
-  into artifactStagingPath
+    into artifactStagingPath
 }
 
-archivesBaseName = "$protocPluginBaseName"
+base {
+    archivesName = "$protocPluginBaseName"
+}
 
-artifacts {
-  archives("$artifactStagingPath/java_plugin/${protocPluginBaseName}.exe" as File) {
-    classifier osdetector.os + "-" + arch
-    type "exe"
-    extension "exe"
-    builtBy buildArtifacts
-  }
+def checkArtifacts = tasks.register("checkArtifacts") {
+    dependsOn buildArtifacts
+    doLast {
+        if (!usingVisualCpp) {
+            def ret = exec {
+                executable 'bash'
+                args 'check-artifact.sh', osdetector.os, arch
+            }
+            if (ret.exitValue != 0) {
+                throw new GradleException("check-artifact.sh exited with " + ret.exitValue)
+            }
+        } else {
+            def exeName = "$artifactStagingPath/java_plugin/${protocPluginBaseName}.exe"
+            def os = new ByteArrayOutputStream()
+            def ret = exec {
+                executable 'dumpbin'
+                args '/nologo', '/dependents', exeName
+                standardOutput = os
+            }
+            if (ret.exitValue != 0) {
+                throw new GradleException("dumpbin exited with " + ret.exitValue)
+            }
+            def dlls_match_results = os.toString() =~ /Image has the following dependencies:([\S\s]*)Summary/
+            def dlls =  dlls_match_results[0][1].trim().split("\\s+").sort()
+            if (dlls != ["KERNEL32.dll", "dbghelp.dll"]) {
+                throw new Exception("unexpected dll deps: " + dlls);
+            }
+            os.reset()
+            ret = exec {
+                executable 'dumpbin'
+                args '/nologo', '/headers', exeName
+                standardOutput = os
+            }
+            if (ret.exitValue != 0) {
+                throw new GradleException("dumpbin exited with " + ret.exitValue)
+            }
+            def machine = os.toString() =~ / machine \(([^)]+)\)/
+            def expectedArch = [x86_32: "x86", x86_64: "x64"][arch]
+            if (machine[0][1] != expectedArch) {
+                throw new Exception("unexpected architecture: " + machine[0][1]);
+            }
+        }
+    }
 }
 
 // Exe files are skipped by Maven by default. Override it.
 // Also skip jar files that is generated by the java plugin.
-[
-  install.repositories.mavenInstaller,
-  uploadArchives.repositories.mavenDeployer,
-]*.setFilter {artifact, file ->
-  ! (file.getName().endsWith('jar') || file.getName().endsWith('jar.asc'))
+publishing {
+    publications {
+        maven(MavenPublication) {
+            // Removes all artifacts since grpc-compiler doesn't generates any Jar
+            artifacts = []
+            artifactId 'protoc-gen-grpc-java'
+            artifact("$artifactStagingPath/java_plugin/${protocPluginBaseName}.exe" as File) {
+                classifier osdetector.os + "-" + arch
+                extension "exe"
+                builtBy checkArtifacts
+            }
+            pom.withXml {
+                // This isn't any sort of Java archive artifact, and OSSRH doesn't enforce
+                // javadoc for 'pom' packages. 'exe' would be a more appropriate packaging
+                // value, but it isn't clear how that will be interpreted. In addition,
+                // 'pom' is typically the value used when building an exe with Maven.
+                asNode().project.packaging*.value = 'pom'
+            }
+        }
+    }
 }
 
-[
-  uploadArchives.repositories.mavenDeployer,
-]*.beforeDeployment {
-  def ret = exec {
-    executable 'bash'
-    args 'check-artifact.sh', osdetector.os, arch
-  }
-  if (ret.exitValue != 0) {
-    throw new GradleException("check-artifact.sh exited with " + ret.exitValue)
-  }
+def configureTestTask(Task task, String dep, String serviceName) {
+    def genDir = files(tasks.named("generateTest${dep}Proto")).singleFile
+    def genFile = "${genDir}/grpc/io/grpc/testing/compiler/${serviceName}Grpc.java"
+    task.dependsOn "generateTest${dep}Proto"
+    task.inputs.file genFile
+    if (osdetector.os != 'windows') {
+        task.executable "diff"
+        task.args "-u"
+    } else {
+        task.executable "fc"
+    }
+    task.args layout.projectDirectory.file("src/test${dep}/golden/${serviceName}.java.txt")
+    task.args genFile
+    // Register an output to allow up-to-date checking
+    task.outputs.file(layout.buildDirectory.file(task.name))
 }
 
-[
-  install.repositories.mavenInstaller,
-  uploadArchives.repositories.mavenDeployer,
-]*.pom*.whenConfigured { pom ->
-  pom.project {
-    // This isn't any sort of Java archive artifact, and OSSRH doesn't enforce
-    // javadoc for 'pom' packages. 'exe' would be a more appropriate packaging
-    // value, but it isn't clear how that will be interpreted. In addition,
-    // 'pom' is typically the value used when building an exe with Maven.
-    packaging = "pom"
-  }
+def testGolden = tasks.register("testGolden", Exec) {
+    configureTestTask(it, '', 'TestService')
 }
-
-def configureTestTask(Task task, String dep, String extraPackage) {
-  test.dependsOn task
-  task.dependsOn "generateTest${dep}Proto"
-  if (osdetector.os != 'windows') {
-    task.executable "diff"
-  } else {
-    task.executable "fc"
-  }
-  // File isn't found on Windows if last slash is forward-slash
-  def slash = System.getProperty("file.separator")
-  task.args "$buildDir/generated/source/proto/test${dep}/grpc/io/grpc/testing/integration${extraPackage}${slash}TestServiceGrpc.java",
-       "$projectDir/src/test${dep}/golden/TestService.java.txt"
+def testLiteGolden = tasks.register("testLiteGolden", Exec) {
+    configureTestTask(it, 'Lite', 'TestService')
+}
+def testDeprecatedGolden = tasks.register("testDeprecatedGolden", Exec) {
+    configureTestTask(it, '', 'TestDeprecatedService')
+}
+def testDeprecatedLiteGolden = tasks.register("testDeprecatedLiteGolden", Exec) {
+    configureTestTask(it, 'Lite', 'TestDeprecatedService')
+}
+tasks.named("test").configure {
+    dependsOn testGolden
+    dependsOn testLiteGolden
+    dependsOn testDeprecatedGolden
+    dependsOn testDeprecatedLiteGolden
 }
-
-task testGolden(type: Exec)
-task testLiteGolden(type: Exec)
-task testNanoGolden(type: Exec)
-configureTestTask(testGolden, '', '')
-configureTestTask(testLiteGolden, 'Lite', '')
-configureTestTask(testNanoGolden, 'Nano', '/nano')
diff --git a/compiler/check-artifact.sh b/compiler/check-artifact.sh
index af318611c96..83b41f50282 100755
--- a/compiler/check-artifact.sh
+++ b/compiler/check-artifact.sh
@@ -56,32 +56,47 @@ checkArch ()
     echo Format=$format
     if [[ "$OS" == linux ]]; then
       if [[ "$ARCH" == x86_32 ]]; then
-        assertEq $format "elf32-i386" $LINENO
+        assertEq "$format" "elf32-i386" $LINENO
       elif [[ "$ARCH" == x86_64 ]]; then
-        assertEq $format "elf64-x86-64" $LINENO
+        assertEq "$format" "elf64-x86-64" $LINENO
+      elif [[ "$ARCH" == aarch_64 ]]; then
+        assertEq "$format" "elf64-little" $LINENO
+      elif [[ "$ARCH" == loongarch_64 ]]; then
+        echo $format
+	assertEq "$format" "elf64-loongarch" $LINENO
+      elif [[ "$ARCH" == ppcle_64 ]]; then
+        format="$(powerpc64le-linux-gnu-objdump -f "$1" | grep -o "file format .*$" | grep -o "[^ ]*$")"
+        echo Format=$format
+        assertEq "$format" "elf64-powerpcle" $LINENO
+      elif [[ "$ARCH" == s390_64 ]]; then
+        format="$(s390x-linux-gnu-objdump -f "$1" | grep -o "file format .*$" | grep -o "[^ ]*$")"
+        echo Format=$format
+        assertEq "$format" "elf64-s390" $LINENO
       else
         fail "Unsupported arch: $ARCH"
       fi
     else
       # $OS == windows
       if [[ "$ARCH" == x86_32 ]]; then
-        assertEq $format "pei-i386" $LINENO
+        assertEq "$format" "pei-i386" $LINENO
       elif [[ "$ARCH" == x86_64 ]]; then
-        assertEq $format "pei-x86-64" $LINENO
+        assertEq "$format" "pei-x86-64" $LINENO
       else
         fail "Unsupported arch: $ARCH"
       fi
     fi
   elif [[ "$OS" == osx ]]; then
-    format="$(file -b "$1" | grep -o "[^ ]*$")"
-    echo Format=$format
-    if [[ "$ARCH" == x86_32 ]]; then
-      assertEq $format "i386" $LINENO
-    elif [[ "$ARCH" == x86_64 ]]; then
-      assertEq $format "x86_64" $LINENO
-    else
-      fail "Unsupported arch: $ARCH"
+    # For macOS, we now build a universal binary. We check that both
+    # required architectures are present.
+    format="$(lipo -archs "$1")"
+    echo "Architectures found: $format"
+    if ! echo "$format" | grep -q "x86_64"; then
+      fail "Universal binary is missing x86_64 architecture."
+    fi
+    if ! echo "$format" | grep -q "arm64"; then
+      fail "Universal binary is missing arm64 architecture."
     fi
+    echo "Universal binary check successful."
   else
     fail "Unsupported system: $OS"
   fi
@@ -98,11 +113,14 @@ checkDependencies ()
     dump_cmd='objdump -x '"$1"' | fgrep "DLL Name"'
     white_list="KERNEL32\.dll\|msvcrt\.dll\|USER32\.dll"
   elif [[ "$OS" == linux ]]; then
-    dump_cmd='ldd '"$1"
+    dump_cmd='objdump -x '"$1"' | grep "NEEDED"'
+    white_list="libpthread\.so\.0\|libstdc++\.so\.6\|libc\.so\.6\|librt\.so\.1\|libm\.so\.6"
     if [[ "$ARCH" == x86_32 ]]; then
-      white_list="linux-gate\.so\.1\|libpthread\.so\.0\|libm\.so\.6\|libc\.so\.6\|ld-linux\.so\.2"
+      white_list="${white_list}\|libm\.so\.6"
     elif [[ "$ARCH" == x86_64 ]]; then
-      white_list="linux-vdso\.so\.1\|libpthread\.so\.0\|libm\.so\.6\|libc\.so\.6\|ld-linux-x86-64\.so\.2"
+      white_list="${white_list}\|libm\.so\.6"
+    elif [[ "$ARCH" == aarch_64 ]]; then
+      white_list="${white_list}\|ld-linux-aarch64\.so\.1"
     fi
   elif [[ "$OS" == osx ]]; then
     dump_cmd='otool -L '"$1"' | fgrep dylib'
diff --git a/compiler/src/java_plugin/cpp/java_generator.cpp b/compiler/src/java_plugin/cpp/java_generator.cpp
index 8c9e39fb291..659d7ccca47 100644
--- a/compiler/src/java_plugin/cpp/java_generator.cpp
+++ b/compiler/src/java_plugin/cpp/java_generator.cpp
@@ -1,13 +1,63 @@
+/*
+ * Copyright 2019 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.
+ */
+
+// gRPC Java code generation
+//
+// The generated code should be very light-weight in terms of size. Although
+// less of a scaling problem than for protobuf messages, additions here are
+// multiplied many times and could easily bloat binaries if added to without
+// consideration. This is generally achieved by putting logic in io.grpc.stub
+// and limiting the generated code to API surface and inputs.
+//
+// gRPC is compatible with old versions of the generated code. New versions of
+// generated code are free to use new APIs, and thus require new gRPC versions.
+// But this isn't a special rule and is more just that the generated code is
+// best viewed as a library that depends on gRPC (as it may be used within a
+// library), and it should adhere to the normal rules of such. Notably, it can
+// only use stable API. Using experimental API, even if only exposing its own
+// experimental API, is not safe as libraries do not get to choose the version
+// of gRPC being used. The rule here is more "everything should behave like
+// normal to users" or "we don't require users to generate code for their
+// transitive dependency tree because OSS build tools don't support that."
+//
+// Java lite is designed for tools like Proguard to strip unused code. Be
+// careful not to add new references to methods that would retain them even when
+// unneeded. In particular, we want uncalled RPC methods to have their
+// descriptors and code pruned.
+
 #include "java_generator.h"
 
 #include <algorithm>
 #include <iostream>
+#include <iterator>
 #include <map>
+#include <set>
 #include <vector>
-#include <google/protobuf/compiler/java/java_names.h>
 #include <google/protobuf/descriptor.h>
+#include <google/protobuf/descriptor.pb.h>
 #include <google/protobuf/io/printer.h>
 #include <google/protobuf/io/zero_copy_stream.h>
+#include <google/protobuf/stubs/common.h>
+
+// Protobuf 3.21 changed the name of this file.
+#if GOOGLE_PROTOBUF_VERSION >= 3021000
+  #include <google/protobuf/compiler/java/names.h>
+#else
+  #include <google/protobuf/compiler/java/java_names.h>
+#endif
 
 // Stringify helpers used solely to cast GRPC_VERSION
 #ifndef STR
@@ -18,25 +68,100 @@
 #define XSTR(s) STR(s)
 #endif
 
-#ifndef FALLTHROUGH_INTENDED
-#define FALLTHROUGH_INTENDED
+#ifdef ABSL_FALLTHROUGH_INTENDED
+#define FALLTHROUGH ABSL_FALLTHROUGH_INTENDED
+#else
+#define FALLTHROUGH
 #endif
 
 namespace java_grpc_generator {
 
-using google::protobuf::FileDescriptor;
-using google::protobuf::ServiceDescriptor;
-using google::protobuf::MethodDescriptor;
-using google::protobuf::Descriptor;
-using google::protobuf::io::Printer;
-using google::protobuf::SourceLocation;
+namespace protobuf = google::protobuf;
+
+using protobuf::Descriptor;
+using protobuf::FileDescriptor;
+using protobuf::MethodDescriptor;
+using protobuf::ServiceDescriptor;
+using protobuf::SourceLocation;
+using protobuf::io::Printer;
 using std::to_string;
 
+// java keywords from: https://docs.oracle.com/javase/specs/jls/se8/html/jls-3.html#jls-3.9
+static std::set<std::string> java_keywords = {
+  "abstract",
+  "assert",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "default",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "extends",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "goto",
+  "if",
+  "implements",
+  "import",
+  "instanceof",
+  "int",
+  "interface",
+  "long",
+  "native",
+  "new",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "short",
+  "static",
+  "strictfp",
+  "super",
+  "switch",
+  "synchronized",
+  "this",
+  "throw",
+  "throws",
+  "transient",
+  "try",
+  "void",
+  "volatile",
+  "while",
+  // additional ones added by us
+  "true",
+  "false",
+};
+
+// Methods on java.lang.Object that take no arguments.
+static std::set<std::string> java_object_methods = {
+    "clone",
+    "finalize",
+    "getClass",
+    "hashCode",
+    "notify",
+    "notifyAll",
+    "toString",
+    "wait",
+};
+
 // Adjust a method name prefix identifier to follow the JavaBean spec:
 //   - decapitalize the first letter
 //   - remove embedded underscores & capitalize the following letter
-static string MixedLower(const string& word) {
-  string w;
+//  Finally, if the result is a reserved java keyword or an Object method,
+// append an underscore.
+static std::string MixedLower(std::string word, bool mangle_object_methods = false) {
+  std::string w;
   w += tolower(word[0]);
   bool after_underscore = false;
   for (size_t i = 1; i < word.length(); ++i) {
@@ -47,6 +172,11 @@ static string MixedLower(const string& word) {
       after_underscore = false;
     }
   }
+  if (java_keywords.find(w) != java_keywords.end() ||
+      (mangle_object_methods &&
+       java_object_methods.find(w) != java_object_methods.end())) {
+    return w + "_";
+  }
   return w;
 }
 
@@ -54,8 +184,8 @@ static string MixedLower(const string& word) {
 //   - An underscore is inserted where a lower case letter is followed by an
 //     upper case letter.
 //   - All letters are converted to upper case
-static string ToAllUpperCase(const string& word) {
-  string w;
+static std::string ToAllUpperCase(std::string word) {
+  std::string w;
   for (size_t i = 0; i < word.length(); ++i) {
     w += toupper(word[i]);
     if ((i < word.length() - 1) && islower(word[i]) && isupper(word[i + 1])) {
@@ -65,39 +195,30 @@ static string ToAllUpperCase(const string& word) {
   return w;
 }
 
-static inline string LowerMethodName(const MethodDescriptor* method) {
-  return MixedLower(method->name());
+static inline std::string LowerMethodName(const MethodDescriptor* method,
+                                          bool mangle_object_methods = false) {
+  return MixedLower(std::string(method->name()), mangle_object_methods);
 }
 
-static inline string MethodPropertiesFieldName(const MethodDescriptor* method) {
-  return "METHOD_" + ToAllUpperCase(method->name());
+static inline std::string MethodPropertiesFieldName(const MethodDescriptor* method) {
+  return "METHOD_" + ToAllUpperCase(std::string(method->name()));
 }
 
-static inline string MethodIdFieldName(const MethodDescriptor* method) {
-  return "METHODID_" + ToAllUpperCase(method->name());
+static inline std::string MethodPropertiesGetterName(const MethodDescriptor* method) {
+  return MixedLower("get_" + std::string(method->name()) + "_method");
 }
 
-static inline string MessageFullJavaName(bool nano, const Descriptor* desc) {
-  string name = google::protobuf::compiler::java::ClassName(desc);
-  if (nano) {
-    // XXX: Add "nano" to the original package
-    // (https://github.com/grpc/grpc-java/issues/900)
-    if (isupper(name[0])) {
-      // No java package specified.
-      return "nano." + name;
-    }
-    for (int i = 0; i < name.size(); ++i) {
-      if ((name[i] == '.') && (i < (name.size() - 1)) && isupper(name[i + 1])) {
-        return name.substr(0, i + 1) + "nano." + name.substr(i + 1);
-      }
-    }
-  }
-  return name;
+static inline std::string MethodIdFieldName(const MethodDescriptor* method) {
+  return "METHODID_" + ToAllUpperCase(std::string(method->name()));
+}
+
+static inline std::string MessageFullJavaName(const Descriptor* desc) {
+  return protobuf::compiler::java::ClassName(desc);
 }
 
 // TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
 template <typename ITR>
-static void GrpcSplitStringToIteratorUsing(const string& full,
+static void GrpcSplitStringToIteratorUsing(const std::string& full,
                                        const char* delim,
                                        ITR& result) {
   // Optimize the common case where delim is a single character.
@@ -111,17 +232,17 @@ static void GrpcSplitStringToIteratorUsing(const string& full,
       } else {
         const char* start = p;
         while (++p != end && *p != c);
-        *result++ = string(start, p - start);
+        *result++ = std::string(start, p - start);
       }
     }
     return;
   }
 
-  string::size_type begin_index, end_index;
+  std::string::size_type begin_index, end_index;
   begin_index = full.find_first_not_of(delim);
-  while (begin_index != string::npos) {
+  while (begin_index != std::string::npos) {
     end_index = full.find_first_of(delim, begin_index);
-    if (end_index == string::npos) {
+    if (end_index == std::string::npos) {
       *result++ = full.substr(begin_index);
       return;
     }
@@ -131,28 +252,28 @@ static void GrpcSplitStringToIteratorUsing(const string& full,
 }
 
 // TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
-static void GrpcSplitStringUsing(const string& full,
+static void GrpcSplitStringUsing(const std::string& full,
                              const char* delim,
-                             std::vector<string>* result) {
-  std::back_insert_iterator< std::vector<string> > it(*result);
+                             std::vector<std::string>* result) {
+  std::back_insert_iterator< std::vector<std::string> > it(*result);
   GrpcSplitStringToIteratorUsing(full, delim, it);
 }
 
 // TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
-static std::vector<string> GrpcSplit(const string& full, const char* delim) {
-  std::vector<string> result;
+static std::vector<std::string> GrpcSplit(const std::string& full, const char* delim) {
+  std::vector<std::string> result;
   GrpcSplitStringUsing(full, delim, &result);
   return result;
 }
 
 // TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
-static string GrpcEscapeJavadoc(const string& input) {
-  string result;
+static std::string GrpcEscapeJavadoc(const std::string& input) {
+  std::string result;
   result.reserve(input.size() * 2);
 
   char prev = '*';
 
-  for (string::size_type i = 0; i < input.size(); i++) {
+  for (std::string::size_type i = 0; i < input.size(); i++) {
     char c = input[i];
     switch (c) {
       case '*':
@@ -206,17 +327,17 @@ static string GrpcEscapeJavadoc(const string& input) {
 
 // TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
 template <typename DescriptorType>
-static string GrpcGetCommentsForDescriptor(const DescriptorType* descriptor) {
+static std::string GrpcGetCommentsForDescriptor(const DescriptorType* descriptor) {
   SourceLocation location;
   if (descriptor->GetSourceLocation(&location)) {
     return location.leading_comments.empty() ?
       location.trailing_comments : location.leading_comments;
   }
-  return string();
+  return std::string();
 }
 
 // TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
-static std::vector<string> GrpcGetDocLines(const string& comments) {
+static std::vector<std::string> GrpcGetDocLines(const std::string& comments) {
   if (!comments.empty()) {
     // TODO(kenton):  Ideally we should parse the comment text as Markdown and
     //   write it back as HTML, but this requires a Markdown parser.  For now
@@ -224,33 +345,53 @@ static std::vector<string> GrpcGetDocLines(const string& comments) {
 
     // If the comment itself contains block comment start or end markers,
     // HTML-escape them so that they don't accidentally close the doc comment.
-    string escapedComments = GrpcEscapeJavadoc(comments);
+    std::string escapedComments = GrpcEscapeJavadoc(comments);
 
-    std::vector<string> lines = GrpcSplit(escapedComments, "\n");
+    std::vector<std::string> lines = GrpcSplit(escapedComments, "\n");
     while (!lines.empty() && lines.back().empty()) {
       lines.pop_back();
     }
     return lines;
   }
-  return std::vector<string>();
+  return std::vector<std::string>();
 }
 
 // TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
 template <typename DescriptorType>
-static std::vector<string> GrpcGetDocLinesForDescriptor(const DescriptorType* descriptor) {
+static std::vector<std::string> GrpcGetDocLinesForDescriptor(const DescriptorType* descriptor) {
   return GrpcGetDocLines(GrpcGetCommentsForDescriptor(descriptor));
 }
 
+enum StubType {
+  ASYNC_INTERFACE = 0,
+  BLOCKING_CLIENT_INTERFACE = 1,
+  FUTURE_CLIENT_INTERFACE = 2,
+  BLOCKING_SERVER_INTERFACE = 3,
+  ASYNC_CLIENT_IMPL = 4,
+  BLOCKING_CLIENT_IMPL = 5,
+  FUTURE_CLIENT_IMPL = 6,
+  ABSTRACT_CLASS = 7,
+  BLOCKING_V2_CLIENT_IMPL = 8,
+  NONE = 999,
+};
+
+enum CallType {
+  ASYNC_CALL = 0,
+  BLOCKING_CALL = 1,
+  FUTURE_CALL = 2,
+  BLOCKING_V2_CALL = 3,
+};
+
 // TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
 static void GrpcWriteDocCommentBody(Printer* printer,
-                                    const std::vector<string>& lines,
+                                    const std::vector<std::string>& lines,
                                     bool surroundWithPreTag) {
   if (!lines.empty()) {
     if (surroundWithPreTag) {
       printer->Print(" * <pre>\n");
     }
 
-    for (int i = 0; i < lines.size(); i++) {
+    for (size_t i = 0; i < lines.size(); i++) {
       // Most lines should start with a space.  Watch out for lines that start
       // with a /, since putting that right after the leading asterisk will
       // close the comment.
@@ -268,20 +409,41 @@ static void GrpcWriteDocCommentBody(Printer* printer,
 }
 
 // TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
-static void GrpcWriteDocComment(Printer* printer, const string& comments) {
+static void GrpcWriteDocComment(Printer* printer, const std::string& comments) {
   printer->Print("/**\n");
-  std::vector<string> lines = GrpcGetDocLines(comments);
+  std::vector<std::string> lines = GrpcGetDocLines(comments);
   GrpcWriteDocCommentBody(printer, lines, false);
   printer->Print(" */\n");
 }
 
-// TODO(nmittler): Remove once protobuf includes javadoc methods in distribution.
+// For the non-interface classes add a description of use before the description from proto
 static void GrpcWriteServiceDocComment(Printer* printer,
-                                       const ServiceDescriptor* service) {
-  // Deviating from protobuf to avoid extraneous docs
-  // (see https://github.com/google/protobuf/issues/1406);
+                                       const ServiceDescriptor* service,
+                                       StubType type) {
   printer->Print("/**\n");
-  std::vector<string> lines = GrpcGetDocLinesForDescriptor(service);
+
+  std::map<std::string, std::string> vars = {{"service", std::string(service->name())}};
+  switch (type) {
+    case ASYNC_CLIENT_IMPL:
+      printer->Print(vars, " * A stub to allow clients to do asynchronous rpc calls to service $service$.\n");
+      break;
+    case BLOCKING_CLIENT_IMPL:
+      printer->Print(vars, " * A stub to allow clients to do limited synchronous rpc calls to service $service$.\n");
+      break;
+    case BLOCKING_V2_CLIENT_IMPL:
+      printer->Print(vars, " * A stub to allow clients to do synchronous rpc calls to service $service$.\n");
+      break;
+    case FUTURE_CLIENT_IMPL:
+      printer->Print(vars, " * A stub to allow clients to do ListenableFuture-style rpc calls to service $service$.\n");
+      break;
+    case ABSTRACT_CLASS:
+      printer->Print(vars, " * Base class for the server implementation of the service $service$.\n");
+      break;
+    default: ;
+      // No extra description
+  }
+
+  std::vector<std::string> lines = GrpcGetDocLinesForDescriptor(service);
   GrpcWriteDocCommentBody(printer, lines, true);
   printer->Print(" */\n");
 }
@@ -292,13 +454,13 @@ void GrpcWriteMethodDocComment(Printer* printer,
   // Deviating from protobuf to avoid extraneous docs
   // (see https://github.com/google/protobuf/issues/1406);
   printer->Print("/**\n");
-  std::vector<string> lines = GrpcGetDocLinesForDescriptor(method);
+  std::vector<std::string> lines = GrpcGetDocLinesForDescriptor(method);
   GrpcWriteDocCommentBody(printer, lines, true);
   printer->Print(" */\n");
 }
 
 static void PrintMethodFields(
-    const ServiceDescriptor* service, std::map<string, string>* vars,
+    const ServiceDescriptor* service, std::map<std::string, std::string>* vars,
     Printer* p, ProtoFlavor flavor) {
   p->Print("// Static method descriptors that strictly reflect the proto.\n");
   (*vars)["service_name"] = service->name();
@@ -307,11 +469,11 @@ static void PrintMethodFields(
     (*vars)["arg_in_id"] = to_string(2 * i);
     (*vars)["arg_out_id"] = to_string(2 * i + 1);
     (*vars)["method_name"] = method->name();
-    (*vars)["input_type"] = MessageFullJavaName(flavor == ProtoFlavor::NANO,
-                                                method->input_type());
-    (*vars)["output_type"] = MessageFullJavaName(flavor == ProtoFlavor::NANO,
-                                                 method->output_type());
+    (*vars)["input_type"] = MessageFullJavaName(method->input_type());
+    (*vars)["output_type"] = MessageFullJavaName(method->output_type());
     (*vars)["method_field_name"] = MethodPropertiesFieldName(method);
+    (*vars)["method_new_field_name"] = MethodPropertiesGetterName(method);
+    (*vars)["method_method_name"] = MethodPropertiesGetterName(method);
     bool client_streaming = method->client_streaming();
     bool server_streaming = method->server_streaming();
     if (client_streaming) {
@@ -328,243 +490,185 @@ static void PrintMethodFields(
       }
     }
 
-    if (flavor == ProtoFlavor::NANO) {
-      // TODO(zsurocking): we're creating two NanoFactories for each method right now.
-      // We could instead create static NanoFactories and reuse them if some methods
-      // share the same request or response messages.
-      p->Print(
-          *vars,
-          "private static final int ARG_IN_$method_field_name$ = $arg_in_id$;\n"
-          "private static final int ARG_OUT_$method_field_name$ = $arg_out_id$;\n"
-          "@$ExperimentalApi$(\"https://github.com/grpc/grpc-java/issues/1901\")\n"
-          "public static final $MethodDescriptor$<$input_type$,\n"
-          "    $output_type$> $method_field_name$ =\n"
-          "    $MethodDescriptor$.create(\n"
-          "        $MethodType$.$method_type$,\n"
-          "        generateFullMethodName(\n"
-          "            \"$Package$$service_name$\", \"$method_name$\"),\n"
-          "        $NanoUtils$.<$input_type$>marshaller(\n"
-          "            new NanoFactory<$input_type$>(ARG_IN_$method_field_name$)),\n"
-          "        $NanoUtils$.<$output_type$>marshaller(\n"
-          "            new NanoFactory<$output_type$>(ARG_OUT_$method_field_name$))\n"
-          "        );\n");
+    if (flavor == ProtoFlavor::LITE) {
+      (*vars)["ProtoUtils"] = "io.grpc.protobuf.lite.ProtoLiteUtils";
     } else {
-      if (flavor == ProtoFlavor::LITE) {
-        (*vars)["ProtoUtils"] = "io.grpc.protobuf.lite.ProtoLiteUtils";
-      } else {
-        (*vars)["ProtoUtils"] = "io.grpc.protobuf.ProtoUtils";
-      }
-      p->Print(
-          *vars,
-          "@$ExperimentalApi$(\"https://github.com/grpc/grpc-java/issues/1901\")\n"
-          "public static final $MethodDescriptor$<$input_type$,\n"
-          "    $output_type$> $method_field_name$ =\n"
-          "    $MethodDescriptor$.create(\n"
-          "        $MethodType$.$method_type$,\n"
-          "        generateFullMethodName(\n"
-          "            \"$Package$$service_name$\", \"$method_name$\"),\n"
-          "        $ProtoUtils$.marshaller($input_type$.getDefaultInstance()),\n"
-          "        $ProtoUtils$.marshaller($output_type$.getDefaultInstance()));\n");
+      (*vars)["ProtoUtils"] = "io.grpc.protobuf.ProtoUtils";
     }
-  }
-  p->Print("\n");
-
-  if (flavor == ProtoFlavor::NANO) {
     p->Print(
         *vars,
-        "private static final class NanoFactory<T extends com.google.protobuf.nano.MessageNano>\n"
-        "    implements io.grpc.protobuf.nano.MessageNanoFactory<T> {\n"
-        "  private final int id;\n"
+        "private static volatile $MethodDescriptor$<$input_type$,\n"
+        "    $output_type$> $method_new_field_name$;\n"
         "\n"
-        "  NanoFactory(int id) {\n"
-        "    this.id = id;\n"
-        "  }\n"
-        "\n"
-        "  @$Override$\n"
-        "  public T newInstance() {\n"
-        "    Object o;\n"
-        "    switch (id) {\n");
-    bool generate_nano = true;
-    for (int i = 0; i < service->method_count(); ++i) {
-      const MethodDescriptor* method = service->method(i);
-      (*vars)["input_type"] = MessageFullJavaName(generate_nano,
-                                                  method->input_type());
-      (*vars)["output_type"] = MessageFullJavaName(generate_nano,
-                                                   method->output_type());
-      (*vars)["method_field_name"] = MethodPropertiesFieldName(method);
+        "@$RpcMethod$(\n"
+        "    fullMethodName = SERVICE_NAME + '/' + \"$method_name$\",\n"
+        "    requestType = $input_type$.class,\n"
+        "    responseType = $output_type$.class,\n"
+        "    methodType = $MethodType$.$method_type$)\n"
+        "public static $MethodDescriptor$<$input_type$,\n"
+        "    $output_type$> $method_method_name$() {\n"
+        "  $MethodDescriptor$<$input_type$, $output_type$> $method_new_field_name$;\n"
+        "  if (($method_new_field_name$ = $service_class_name$.$method_new_field_name$) == null) {\n"
+        "    synchronized ($service_class_name$.class) {\n"
+        "      if (($method_new_field_name$ = $service_class_name$.$method_new_field_name$) == null) {\n"
+        "        $service_class_name$.$method_new_field_name$ = $method_new_field_name$ =\n"
+        "            $MethodDescriptor$.<$input_type$, $output_type$>newBuilder()\n"
+        "            .setType($MethodType$.$method_type$)\n"
+        "            .setFullMethodName(generateFullMethodName(SERVICE_NAME, \"$method_name$\"))\n");
+        
+    bool safe = method->options().idempotency_level()
+        == protobuf::MethodOptions_IdempotencyLevel_NO_SIDE_EFFECTS;
+    if (safe) {
+      p->Print(*vars, "            .setSafe(true)\n");
+    } else {
+      bool idempotent = method->options().idempotency_level()
+          == protobuf::MethodOptions_IdempotencyLevel_IDEMPOTENT;
+      if (idempotent) {
+        p->Print(*vars, "            .setIdempotent(true)\n");
+      }
+    }
+        
+    p->Print(
+        *vars,
+        "            .setSampledToLocalTracing(true)\n"
+        "            .setRequestMarshaller($ProtoUtils$.marshaller(\n"
+        "                $input_type$.getDefaultInstance()))\n"
+        "            .setResponseMarshaller($ProtoUtils$.marshaller(\n"
+        "                $output_type$.getDefaultInstance()))\n");
+
+    (*vars)["proto_method_descriptor_supplier"]
+        = std::string(service->name()) + "MethodDescriptorSupplier";
+    if (flavor == ProtoFlavor::NORMAL) {
       p->Print(
           *vars,
-          "    case ARG_IN_$method_field_name$:\n"
-          "      o = new $input_type$();\n"
-          "      break;\n"
-          "    case ARG_OUT_$method_field_name$:\n"
-          "      o = new $output_type$();\n"
-          "      break;\n");
+        "            .setSchemaDescriptor(new $proto_method_descriptor_supplier$(\"$method_name$\"))\n");
     }
+
     p->Print(
-        "    default:\n"
-        "      throw new AssertionError();\n"
+        *vars,
+        "            .build();\n");
+    p->Print(*vars,
+        "      }\n"
         "    }\n"
-        "    @java.lang.SuppressWarnings(\"unchecked\")\n"
-        "    T t = (T) o;\n"
-        "    return t;\n"
         "  }\n"
+        "  return $method_new_field_name$;\n"
         "}\n"
         "\n");
   }
 }
 
-enum StubType {
-  ASYNC_INTERFACE = 0,
-  BLOCKING_CLIENT_INTERFACE = 1,
-  FUTURE_CLIENT_INTERFACE = 2,
-  BLOCKING_SERVER_INTERFACE = 3,
-  ASYNC_CLIENT_IMPL = 4,
-  BLOCKING_CLIENT_IMPL = 5,
-  FUTURE_CLIENT_IMPL = 6,
-  ABSTRACT_CLASS = 7,
-};
-
-enum CallType {
-  ASYNC_CALL = 0,
-  BLOCKING_CALL = 1,
-  FUTURE_CALL = 2
-};
-
-static void PrintBindServiceMethodBody(const ServiceDescriptor* service,
-                                   std::map<string, string>* vars,
-                                   Printer* p,
-                                   bool generate_nano);
+static void PrintBindServiceMethod(const ServiceDescriptor* service,
+                                   std::map<std::string, std::string>* vars,
+                                   Printer* p);
 
-static void PrintDeprecatedDocComment(const ServiceDescriptor* service,
-                                      std::map<string, string>* vars,
-                                      Printer* p) {
+// Prints a StubFactory for given service / stub type.
+static void PrintStubFactory(
+    const ServiceDescriptor* service,
+    std::map<std::string, std::string>* vars,
+    Printer* p, StubType type) {
+  std::string stub_type_name;
+  switch (type) {
+    case ASYNC_CLIENT_IMPL:
+      stub_type_name = "";
+      break;
+    case FUTURE_CLIENT_IMPL:
+      stub_type_name = "Future";
+      break;
+    case BLOCKING_CLIENT_IMPL:
+      stub_type_name = "Blocking";
+      break;
+    case BLOCKING_V2_CLIENT_IMPL:
+      stub_type_name = "BlockingV2";
+      break;
+    default:
+      GRPC_CODEGEN_FAIL << "Cannot generate StubFactory for StubType: " << type;
+  }
+  (*vars)["stub_full_name"] = (*vars)["service_name"] + stub_type_name + "Stub";
   p->Print(
-      *vars,
-      "/**\n"
-      " * This will be removed in the next release.\n"
-      " * If your code has been using gRPC-java v0.15.0 or higher already,\n"
-      " * the following changes to your code are suggested:\n"
-      " * <ul>\n"
-      " *   <li> replace {@code extends/implements $service_name$}"
-      " with {@code extends $service_name$ImplBase} for server side;</li>\n"
-      " *   <li> replace {@code $service_name$} with {@code $service_name$Stub} for client side;"
-      "</li>\n"
-      " *   <li> replace usage of {@code $service_name$} with {@code $service_name$ImplBase};"
-      "</li>\n"
-      " *   <li> replace usage of {@code Abstract$service_name$}"
-      " with {@link $service_name$ImplBase};</li>\n"
-      " *   <li> replace"
-      " {@code serverBuilder.addService($service_class_name$.bindService(serviceImpl))}\n"
-      " *        with {@code serverBuilder.addService(serviceImpl)};</li>\n"
-      " *   <li> if you are mocking stubs using mockito, please do not mock them.\n"
-      " *        See the documentation on testing with gRPC-java;</li>\n"
-      " *   <li> replace {@code $service_name$BlockingClient}"
-      " with {@link $service_name$BlockingStub};</li>\n"
-      " *   <li> replace {@code $service_name$FutureClient}"
-      " with {@link $service_name$FutureStub}.</li>\n"
-      " * </ul>\n"
-      " */\n");
+    *vars,
+    "$StubFactory$<$stub_full_name$> factory =\n"
+    "  new $StubFactory$<$stub_full_name$>() {\n"
+    "    @$Override$\n"
+    "    public $stub_full_name$ newStub($Channel$ channel, $CallOptions$ callOptions) {\n"
+    "      return new $stub_full_name$(channel, callOptions);\n"
+    "    }\n"
+    "  };\n");
 }
 
 // Prints a client interface or implementation class, or a server interface.
 static void PrintStub(
     const ServiceDescriptor* service,
-    std::map<string, string>* vars,
-    Printer* p, StubType type, bool generate_nano,
-    bool enable_deprecated) {
-  const string service_name = service->name();
+    std::map<std::string, std::string>* vars,
+    Printer* p, StubType type) {
+  std::string service_name = std::string(service->name());
   (*vars)["service_name"] = service_name;
-  (*vars)["abstract_name"] = service_name + "ImplBase";
-  string stub_name = service_name;
-  string client_name = service_name;
+  std::string stub_name = service_name;
+  std::string stub_base_class_name = "AbstractStub";
   CallType call_type;
-  bool impl_base = false;
   bool interface = false;
   switch (type) {
-    case ABSTRACT_CLASS:
+    case ASYNC_INTERFACE:
       call_type = ASYNC_CALL;
-      impl_base = true;
+      interface = true;
+      stub_name ="AsyncService";
       break;
     case ASYNC_CLIENT_IMPL:
       call_type = ASYNC_CALL;
       stub_name += "Stub";
+      stub_base_class_name = "AbstractAsyncStub";
       break;
-    case BLOCKING_CLIENT_INTERFACE:
-      interface = true;
-      FALLTHROUGH_INTENDED;
     case BLOCKING_CLIENT_IMPL:
       call_type = BLOCKING_CALL;
       stub_name += "BlockingStub";
-      client_name += "BlockingClient";
+      stub_base_class_name = "AbstractBlockingStub";
+      break;
+    case BLOCKING_V2_CLIENT_IMPL:
+      call_type = BLOCKING_V2_CALL;
+      stub_name += "BlockingV2Stub";
+      stub_base_class_name = "AbstractBlockingStub";
       break;
-    case FUTURE_CLIENT_INTERFACE:
-      interface = true;
-      FALLTHROUGH_INTENDED;
     case FUTURE_CLIENT_IMPL:
       call_type = FUTURE_CALL;
       stub_name += "FutureStub";
-      client_name += "FutureClient";
-      break;
-    case ASYNC_INTERFACE:
-      call_type = ASYNC_CALL;
-      interface = true;
+      stub_base_class_name = "AbstractFutureStub";
       break;
+    case BLOCKING_CLIENT_INTERFACE:
+    case FUTURE_CLIENT_INTERFACE:
+      GRPC_CODEGEN_FAIL << "Intentionally not creating StubType: " << type;
+    case ABSTRACT_CLASS:
+      GRPC_CODEGEN_FAIL << "Call PrintAbstractClassStub for ABSTRACT_CLASS";
     default:
       GRPC_CODEGEN_FAIL << "Cannot determine class name for StubType: " << type;
   }
   (*vars)["stub_name"] = stub_name;
-  (*vars)["client_name"] = client_name;
+  (*vars)["stub_base_class_name"] = (*vars)[stub_base_class_name];
 
   // Class head
-  if (!interface) {
-    GrpcWriteServiceDocComment(p, service);
+  GrpcWriteServiceDocComment(p, service, type);
+
+  if (service->options().deprecated()) {
+    p->Print(*vars, "@$Deprecated$\n");
   }
-  if (impl_base) {
-    if (enable_deprecated) {
-      p->Print(
-          *vars,
-          "public static abstract class $abstract_name$ implements $BindableService$, "
-          "$service_name$ {\n");
-    }
-    else {
-      p->Print(
-          *vars,
-          "public static abstract class $abstract_name$ implements $BindableService$ {\n");
-    }
+
+  if (interface) {
+    p->Print(
+        *vars,
+        "public interface $stub_name$ {\n");
   } else {
-    if (enable_deprecated) {
-      if (interface) {
-        p->Print(
-            *vars,
-            "@$Deprecated$ public static interface $client_name$ {\n");
-      } else {
-        p->Print(
-            *vars,
-            "public static class $stub_name$ extends $AbstractStub$<$stub_name$>\n"
-            "    implements $client_name$ {\n");
-      }
-    } else {
-      p->Print(
-          *vars,
-          "public static final class $stub_name$ extends $AbstractStub$<$stub_name$> {\n");
-    }
+    p->Print(
+        *vars,
+        "public static final class $stub_name$\n"
+        "    extends $stub_base_class_name$<$stub_name$> {\n");
   }
   p->Indent();
 
   // Constructor and build() method
-  if (!impl_base && !interface) {
-    p->Print(
-        *vars,
-        "private $stub_name$($Channel$ channel) {\n");
-    p->Indent();
-    p->Print("super(channel);\n");
-    p->Outdent();
-    p->Print("}\n\n");
+  if (!interface) {
     p->Print(
         *vars,
-        "private $stub_name$($Channel$ channel,\n"
-        "    $CallOptions$ callOptions) {\n");
+        "private $stub_name$(\n"
+        "    $Channel$ channel, $CallOptions$ callOptions) {"
+        "\n");
     p->Indent();
     p->Print("super(channel, callOptions);\n");
     p->Outdent();
@@ -572,8 +676,9 @@ static void PrintStub(
     p->Print(
         *vars,
         "@$Override$\n"
-        "protected $stub_name$ build($Channel$ channel,\n"
-        "    $CallOptions$ callOptions) {\n");
+        "protected $stub_name$ build(\n"
+        "    $Channel$ channel, $CallOptions$ callOptions) {"
+        "\n");
     p->Indent();
     p->Print(
         *vars,
@@ -585,14 +690,14 @@ static void PrintStub(
   // RPC methods
   for (int i = 0; i < service->method_count(); ++i) {
     const MethodDescriptor* method = service->method(i);
-    (*vars)["input_type"] = MessageFullJavaName(generate_nano,
-                                                method->input_type());
-    (*vars)["output_type"] = MessageFullJavaName(generate_nano,
-                                                 method->output_type());
-    (*vars)["lower_method_name"] = LowerMethodName(method);
-    (*vars)["method_field_name"] = MethodPropertiesFieldName(method);
+    (*vars)["input_type"] = MessageFullJavaName(method->input_type());
+    (*vars)["output_type"] = MessageFullJavaName(method->output_type());
     bool client_streaming = method->client_streaming();
     bool server_streaming = method->server_streaming();
+    bool mangle_object_methods = (call_type == BLOCKING_V2_CALL && client_streaming)
+      || (call_type == BLOCKING_CALL && client_streaming && server_streaming);
+    (*vars)["lower_method_name"] = LowerMethodName(method, mangle_object_methods);
+    (*vars)["method_method_name"] = MethodPropertiesGetterName(method);
 
     if (call_type == BLOCKING_CALL && client_streaming) {
       // Blocking client interface with client streaming is not available
@@ -606,21 +711,32 @@ static void PrintStub(
 
     // Method signature
     p->Print("\n");
-    // TODO(nmittler): Replace with WriteMethodDocComment once included by the protobuf distro.
+    GrpcWriteMethodDocComment(p, method);
+
+    if (method->options().deprecated()) {
+      p->Print(*vars, "@$Deprecated$\n");
+    }
+
+    if ((call_type == BLOCKING_CALL && client_streaming && server_streaming)
+       || (call_type == BLOCKING_V2_CALL && (client_streaming || server_streaming))) {
+      p->Print(*vars, "@io.grpc.ExperimentalApi(\"https://github.com/grpc/grpc-java/issues/10918\")\n");
+    }
+
     if (!interface) {
-      GrpcWriteMethodDocComment(p, method);
-      if (enable_deprecated) {
-        p->Print(
-            *vars,
-            "@$Override$\n");
-      }
+      p->Print("public ");
+    } else {
+      p->Print("default ");
     }
-    p->Print("public ");
     switch (call_type) {
       case BLOCKING_CALL:
         GRPC_CODEGEN_CHECK(!client_streaming)
             << "Blocking client interface with client streaming is unavailable";
-        if (server_streaming) {
+        if (client_streaming && server_streaming) {
+          p->Print(
+              *vars,
+              "$BlockingClientCall$<$input_type$, $output_type$>\n"
+               "    $lower_method_name$()");
+        } else if (server_streaming) {
           // Server streaming
           p->Print(
               *vars,
@@ -633,6 +749,26 @@ static void PrintStub(
               "$output_type$ $lower_method_name$($input_type$ request)");
         }
         break;
+      case BLOCKING_V2_CALL:
+        if (client_streaming) { // Both Bidi and Client Streaming
+          p->Print(
+              *vars,
+              "$BlockingClientCall$<$input_type$, $output_type$>\n"
+               "    $lower_method_name$()");
+        } else if (server_streaming) {
+          // Server streaming
+          p->Print(
+              *vars,
+              "$BlockingClientCall$<?, $output_type$>\n"
+              "    $lower_method_name$($input_type$ request)");
+       } else {
+          // Simple RPC
+          (*vars)["throws_decl"] = " throws io.grpc.StatusException";
+          p->Print(
+              *vars,
+              "$output_type$ $lower_method_name$($input_type$ request)$throws_decl$");
+       }
+       break;
       case ASYNC_CALL:
         if (client_streaming) {
           // Bidirectional streaming or client streaming
@@ -660,63 +796,81 @@ static void PrintStub(
         break;
     }
 
-    if (interface) {
-      p->Print(";\n");
-      continue;
-    }
     // Method body.
     p->Print(" {\n");
     p->Indent();
-    if (impl_base) {
-      switch (call_type) {
-        // NB: Skipping validation of service methods. If something is wrong, we wouldn't get to
-        // this point as compiler would return errors when generating service interface.
-        case ASYNC_CALL:
-          if (client_streaming) {
-            p->Print(
-                *vars,
-                "return asyncUnimplementedStreamingCall($method_field_name$, responseObserver);\n");
-          } else {
-            p->Print(
-                *vars,
-                "asyncUnimplementedUnaryCall($method_field_name$, responseObserver);\n");
-          }
-          break;
-        default:
-          break;
+    if (interface && call_type == ASYNC_CALL) {
+      // NB: Skipping validation of service methods. If something is wrong, we wouldn't get to
+      // this point as compiler would return errors when generating service interface.
+      if (client_streaming) {
+        p->Print(
+            *vars,
+            "return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall("
+            "$method_method_name$(), responseObserver);\n");
+      } else {
+        p->Print(
+            *vars,
+            "io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall("
+            "$method_method_name$(), responseObserver);\n");
       }
     } else if (!interface) {
-      switch (call_type) {
+        switch (call_type) {
         case BLOCKING_CALL:
           GRPC_CODEGEN_CHECK(!client_streaming)
-              << "Blocking client streaming interface is not available";
-          if (server_streaming) {
-            (*vars)["calls_method"] = "blockingServerStreamingCall";
-            (*vars)["params"] = "request";
-          } else {
-            (*vars)["calls_method"] = "blockingUnaryCall";
-            (*vars)["params"] = "request";
+              << "Blocking client and bidi streaming interface are not available";
+            if (server_streaming) {
+              (*vars)["calls_method"] = "io.grpc.stub.ClientCalls.blockingServerStreamingCall";
+              (*vars)["params"] = "request";
+            } else {
+              (*vars)["calls_method"] = "io.grpc.stub.ClientCalls.blockingUnaryCall";
+              (*vars)["params"] = "request";
+            }
+            p->Print(
+                *vars,
+                "return $calls_method$(\n"
+                "    getChannel(), $method_method_name$(), getCallOptions(), $params$);\n");
+          break;
+        case BLOCKING_V2_CALL:
+          if (client_streaming) { // client and bidi streaming
+                if (server_streaming) {
+                    (*vars)["calls_method"] = "io.grpc.stub.ClientCalls.blockingBidiStreamingCall";
+                 } else {
+                   (*vars)["calls_method"] = "io.grpc.stub.ClientCalls.blockingClientStreamingCall";
+                 }
+           p->Print(
+                *vars,
+                "return $calls_method$(\n"
+                "    getChannel(), $method_method_name$(), getCallOptions());\n");
+          } else { // server streaming and unary
+               (*vars)["params"] = "request";
+               if (server_streaming) {
+                   (*vars)["calls_method"] = "io.grpc.stub.ClientCalls.blockingV2ServerStreamingCall";
+                } else {
+                  (*vars)["calls_method"] = "io.grpc.stub.ClientCalls.blockingV2UnaryCall";
+                  (*vars)["throws_decl"] = " throws io.grpc.StatusException";
+                }
+
+            p->Print(
+                *vars,
+                "return $calls_method$(\n"
+                "    getChannel(), $method_method_name$(), getCallOptions(), $params$);\n");
           }
-          p->Print(
-              *vars,
-              "return $calls_method$(\n"
-              "    getChannel(), $method_field_name$, getCallOptions(), $params$);\n");
           break;
         case ASYNC_CALL:
           if (server_streaming) {
             if (client_streaming) {
-              (*vars)["calls_method"] = "asyncBidiStreamingCall";
+              (*vars)["calls_method"] = "io.grpc.stub.ClientCalls.asyncBidiStreamingCall";
               (*vars)["params"] = "responseObserver";
             } else {
-              (*vars)["calls_method"] = "asyncServerStreamingCall";
+              (*vars)["calls_method"] = "io.grpc.stub.ClientCalls.asyncServerStreamingCall";
               (*vars)["params"] = "request, responseObserver";
             }
           } else {
             if (client_streaming) {
-              (*vars)["calls_method"] = "asyncClientStreamingCall";
+              (*vars)["calls_method"] = "io.grpc.stub.ClientCalls.asyncClientStreamingCall";
               (*vars)["params"] = "responseObserver";
             } else {
-              (*vars)["calls_method"] = "asyncUnaryCall";
+              (*vars)["calls_method"] = "io.grpc.stub.ClientCalls.asyncUnaryCall";
               (*vars)["params"] = "request, responseObserver";
             }
           }
@@ -724,39 +878,53 @@ static void PrintStub(
           p->Print(
               *vars,
               "$last_line_prefix$$calls_method$(\n"
-              "    getChannel().newCall($method_field_name$, getCallOptions()), $params$);\n");
+              "    getChannel().newCall($method_method_name$(), getCallOptions()), $params$);\n");
           break;
         case FUTURE_CALL:
           GRPC_CODEGEN_CHECK(!client_streaming && !server_streaming)
               << "Future interface doesn't support streaming. "
               << "client_streaming=" << client_streaming << ", "
               << "server_streaming=" << server_streaming;
-          (*vars)["calls_method"] = "futureUnaryCall";
+          (*vars)["calls_method"] = "io.grpc.stub.ClientCalls.futureUnaryCall";
           p->Print(
               *vars,
               "return $calls_method$(\n"
-              "    getChannel().newCall($method_field_name$, getCallOptions()), request);\n");
+              "    getChannel().newCall($method_method_name$(), getCallOptions()), request);\n");
           break;
-      }
+        }
+    } else {
+      GRPC_CODEGEN_FAIL << "Do not create Stub interfaces";
     }
     p->Outdent();
     p->Print("}\n");
   }
 
-  if (impl_base) {
-    p->Print("\n");
-    p->Print(
-        *vars,
-        "@$Override$ public final $ServerServiceDefinition$ bindService() {\n");
-    (*vars)["instance"] = "this";
-    PrintBindServiceMethodBody(service, vars, p, generate_nano);
-    p->Print("}\n");
-  }
-
   p->Outdent();
   p->Print("}\n\n");
 }
 
+
+static void PrintAbstractClassStub(
+    const ServiceDescriptor* service,
+    std::map<std::string, std::string>* vars,
+    Printer* p) {
+  (*vars)["service_name"] = service->name();
+
+  GrpcWriteServiceDocComment(p, service, ABSTRACT_CLASS);
+  if (service->options().deprecated()) {
+    p->Print(*vars, "@$Deprecated$\n");
+  }
+  p->Print(
+      *vars,
+      "public static abstract class $service_name$ImplBase\n"
+      "    implements $BindableService$, AsyncService {\n"
+      "\n"
+      "  @$Override$ public final $ServerServiceDefinition$ bindService() {\n"
+      "    return $service_class_name$.bindService(this);\n"
+      "  }\n"
+      "}\n\n");
+}
+
 static bool CompareMethodClientStreaming(const MethodDescriptor* method1,
                                          const MethodDescriptor* method2)
 {
@@ -766,10 +934,8 @@ static bool CompareMethodClientStreaming(const MethodDescriptor* method1,
 // Place all method invocations into a single class to reduce memory footprint
 // on Android.
 static void PrintMethodHandlerClass(const ServiceDescriptor* service,
-                                   std::map<string, string>* vars,
-                                   Printer* p,
-                                   bool generate_nano,
-                                   bool enable_deprecated) {
+                                   std::map<std::string, std::string>* vars,
+                                   Printer* p) {
   // Sort method ids based on client_streaming() so switch tables are compact.
   std::vector<const MethodDescriptor*> sorted_methods(service->method_count());
   for (int i = 0; i < service->method_count(); ++i) {
@@ -777,7 +943,7 @@ static void PrintMethodHandlerClass(const ServiceDescriptor* service,
   }
   stable_sort(sorted_methods.begin(), sorted_methods.end(),
               CompareMethodClientStreaming);
-  for (int i = 0; i < sorted_methods.size(); i++) {
+  for (size_t i = 0; i < sorted_methods.size(); i++) {
     const MethodDescriptor* method = sorted_methods[i];
     (*vars)["method_id"] = to_string(i);
     (*vars)["method_id_name"] = MethodIdFieldName(method);
@@ -786,11 +952,6 @@ static void PrintMethodHandlerClass(const ServiceDescriptor* service,
         "private static final int $method_id_name$ = $method_id$;\n");
   }
   p->Print("\n");
-  if (enable_deprecated) {
-    (*vars)["service_name"] = service->name();
-  } else {
-    (*vars)["service_name"] = service->name() + "ImplBase";
-  }
   p->Print(
       *vars,
       "private static final class MethodHandlers<Req, Resp> implements\n"
@@ -798,10 +959,10 @@ static void PrintMethodHandlerClass(const ServiceDescriptor* service,
       "    io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,\n"
       "    io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,\n"
       "    io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {\n"
-      "  private final $service_name$ serviceImpl;\n"
+      "  private final AsyncService serviceImpl;\n"
       "  private final int methodId;\n"
       "\n"
-      "  MethodHandlers($service_name$ serviceImpl, int methodId) {\n"
+      "  MethodHandlers(AsyncService serviceImpl, int methodId) {\n"
       "    this.serviceImpl = serviceImpl;\n"
       "    this.methodId = methodId;\n"
       "  }\n\n");
@@ -822,10 +983,8 @@ static void PrintMethodHandlerClass(const ServiceDescriptor* service,
     }
     (*vars)["method_id_name"] = MethodIdFieldName(method);
     (*vars)["lower_method_name"] = LowerMethodName(method);
-    (*vars)["input_type"] = MessageFullJavaName(generate_nano,
-                                                method->input_type());
-    (*vars)["output_type"] = MessageFullJavaName(generate_nano,
-                                                 method->output_type());
+    (*vars)["input_type"] = MessageFullJavaName(method->input_type());
+    (*vars)["output_type"] = MessageFullJavaName(method->output_type());
     p->Print(
         *vars,
         "case $method_id_name$:\n"
@@ -858,10 +1017,8 @@ static void PrintMethodHandlerClass(const ServiceDescriptor* service,
     }
     (*vars)["method_id_name"] = MethodIdFieldName(method);
     (*vars)["lower_method_name"] = LowerMethodName(method);
-    (*vars)["input_type"] = MessageFullJavaName(generate_nano,
-                                                method->input_type());
-    (*vars)["output_type"] = MessageFullJavaName(generate_nano,
-                                                 method->output_type());
+    (*vars)["input_type"] = MessageFullJavaName(method->input_type());
+    (*vars)["output_type"] = MessageFullJavaName(method->output_type());
     p->Print(
         *vars,
         "case $method_id_name$:\n"
@@ -882,29 +1039,54 @@ static void PrintMethodHandlerClass(const ServiceDescriptor* service,
 }
 
 static void PrintGetServiceDescriptorMethod(const ServiceDescriptor* service,
-                                   std::map<string, string>* vars,
+                                   std::map<std::string, std::string>* vars,
                                    Printer* p,
                                    ProtoFlavor flavor) {
-  (*vars)["service_name"] = service->name();
+  std::string service_name = std::string(service->name());
+  (*vars)["service_name"] = service_name;
 
 
   if (flavor == ProtoFlavor::NORMAL) {
-    (*vars)["proto_descriptor_supplier"] = service->name() + "DescriptorSupplier";
-    (*vars)["proto_class_name"] = google::protobuf::compiler::java::ClassName(service->file());
+    (*vars)["proto_base_descriptor_supplier"] = service_name + "BaseDescriptorSupplier";
+    (*vars)["proto_file_descriptor_supplier"] = service_name + "FileDescriptorSupplier";
+    (*vars)["proto_method_descriptor_supplier"] = service_name + "MethodDescriptorSupplier";
+    (*vars)["proto_class_name"] = protobuf::compiler::java::ClassName(service->file());
     p->Print(
         *vars,
-        "private static final class $proto_descriptor_supplier$ implements $ProtoFileDescriptorSupplier$ {\n");
-    p->Indent();
-    p->Print(*vars, "@$Override$\n");
-    p->Print(
-        *vars,
-        "public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {\n");
-    p->Indent();
-    p->Print(*vars, "return $proto_class_name$.getDescriptor();\n");
-    p->Outdent();
-    p->Print(*vars, "}\n");
-    p->Outdent();
-    p->Print(*vars, "}\n\n");
+        "private static abstract class $proto_base_descriptor_supplier$\n"
+        "    implements $ProtoFileDescriptorSupplier$, $ProtoServiceDescriptorSupplier$ {\n"
+        "  $proto_base_descriptor_supplier$() {}\n"
+        "\n"
+        "  @$Override$\n"
+        "  public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {\n"
+        "    return $proto_class_name$.getDescriptor();\n"
+        "  }\n"
+        "\n"
+        "  @$Override$\n"
+        "  public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {\n"
+        "    return getFileDescriptor().findServiceByName(\"$service_name$\");\n"
+        "  }\n"
+        "}\n"
+        "\n"
+        "private static final class $proto_file_descriptor_supplier$\n"
+        "    extends $proto_base_descriptor_supplier$ {\n"
+        "  $proto_file_descriptor_supplier$() {}\n"
+        "}\n"
+        "\n"
+        "private static final class $proto_method_descriptor_supplier$\n"
+        "    extends $proto_base_descriptor_supplier$\n"
+        "    implements $ProtoMethodDescriptorSupplier$ {\n"
+        "  private final $String$ methodName;\n"
+        "\n"
+        "  $proto_method_descriptor_supplier$($String$ methodName) {\n"
+        "    this.methodName = methodName;\n"
+        "  }\n"
+        "\n"
+        "  @$Override$\n"
+        "  public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {\n"
+        "    return getServiceDescriptor().findMethodByName(methodName);\n"
+        "  }\n"
+        "}\n\n");
   }
 
   p->Print(
@@ -936,12 +1118,12 @@ static void PrintGetServiceDescriptorMethod(const ServiceDescriptor* service,
   if (flavor == ProtoFlavor::NORMAL) {
     p->Print(
         *vars,
-        "\n.setSchemaDescriptor(new $proto_descriptor_supplier$())");
+        "\n.setSchemaDescriptor(new $proto_file_descriptor_supplier$())");
   }
   for (int i = 0; i < service->method_count(); ++i) {
     const MethodDescriptor* method = service->method(i);
-    (*vars)["method_field_name"] = MethodPropertiesFieldName(method);
-    p->Print(*vars, "\n.addMethod($method_field_name$)");
+    (*vars)["method_method_name"] = MethodPropertiesGetterName(method);
+    p->Print(*vars, "\n.addMethod($method_method_name$())");
   }
   p->Print("\n.build();\n");
   p->Outdent();
@@ -958,11 +1140,14 @@ static void PrintGetServiceDescriptorMethod(const ServiceDescriptor* service,
   p->Print("}\n");
 }
 
-static void PrintBindServiceMethodBody(const ServiceDescriptor* service,
-                                   std::map<string, string>* vars,
-                                   Printer* p,
-                                   bool generate_nano) {
+static void PrintBindServiceMethod(const ServiceDescriptor* service,
+                                   std::map<std::string, std::string>* vars,
+                                   Printer* p) {
   (*vars)["service_name"] = service->name();
+  p->Print(*vars,
+           "public static final io.grpc.ServerServiceDefinition "
+           "bindService(AsyncService service) {\n");
+
   p->Indent();
   p->Print(*vars,
            "return "
@@ -972,32 +1157,30 @@ static void PrintBindServiceMethodBody(const ServiceDescriptor* service,
   for (int i = 0; i < service->method_count(); ++i) {
     const MethodDescriptor* method = service->method(i);
     (*vars)["lower_method_name"] = LowerMethodName(method);
-    (*vars)["method_field_name"] = MethodPropertiesFieldName(method);
-    (*vars)["input_type"] = MessageFullJavaName(generate_nano,
-                                                method->input_type());
-    (*vars)["output_type"] = MessageFullJavaName(generate_nano,
-                                                 method->output_type());
+    (*vars)["method_method_name"] = MethodPropertiesGetterName(method);
+    (*vars)["input_type"] = MessageFullJavaName(method->input_type());
+    (*vars)["output_type"] = MessageFullJavaName(method->output_type());
     (*vars)["method_id_name"] = MethodIdFieldName(method);
     bool client_streaming = method->client_streaming();
     bool server_streaming = method->server_streaming();
     if (client_streaming) {
       if (server_streaming) {
-        (*vars)["calls_method"] = "asyncBidiStreamingCall";
+        (*vars)["calls_method"] = "io.grpc.stub.ServerCalls.asyncBidiStreamingCall";
       } else {
-        (*vars)["calls_method"] = "asyncClientStreamingCall";
+        (*vars)["calls_method"] = "io.grpc.stub.ServerCalls.asyncClientStreamingCall";
       }
     } else {
       if (server_streaming) {
-        (*vars)["calls_method"] = "asyncServerStreamingCall";
+        (*vars)["calls_method"] = "io.grpc.stub.ServerCalls.asyncServerStreamingCall";
       } else {
-        (*vars)["calls_method"] = "asyncUnaryCall";
+        (*vars)["calls_method"] = "io.grpc.stub.ServerCalls.asyncUnaryCall";
       }
     }
     p->Print(*vars, ".addMethod(\n");
     p->Indent();
     p->Print(
         *vars,
-        "$method_field_name$,\n"
+        "$method_method_name$(),\n"
         "$calls_method$(\n");
     p->Indent();
     p->Print(
@@ -1005,7 +1188,7 @@ static void PrintBindServiceMethodBody(const ServiceDescriptor* service,
         "new MethodHandlers<\n"
         "  $input_type$,\n"
         "  $output_type$>(\n"
-        "    $instance$, $method_id_name$)))\n");
+        "    service, $method_id_name$)))\n");
     p->Outdent();
     p->Outdent();
   }
@@ -1013,28 +1196,46 @@ static void PrintBindServiceMethodBody(const ServiceDescriptor* service,
   p->Outdent();
   p->Outdent();
   p->Outdent();
+  p->Print("}\n\n");
 }
 
 static void PrintService(const ServiceDescriptor* service,
-                         std::map<string, string>* vars,
+                         std::map<std::string, std::string>* vars,
                          Printer* p,
                          ProtoFlavor flavor,
-                         bool enable_deprecated) {
+                         bool disable_version,
+                         GeneratedAnnotation generated_annotation) {
   (*vars)["service_name"] = service->name();
   (*vars)["file_name"] = service->file()->name();
   (*vars)["service_class_name"] = ServiceClassName(service);
+  (*vars)["grpc_version"] = "";
   #ifdef GRPC_VERSION
+  if (!disable_version) {
     (*vars)["grpc_version"] = " (version " XSTR(GRPC_VERSION) ")";
-  #else
-    (*vars)["grpc_version"] = "";
+  }
   #endif
   // TODO(nmittler): Replace with WriteServiceDocComment once included by protobuf distro.
-  GrpcWriteServiceDocComment(p, service);
+  GrpcWriteServiceDocComment(p, service, NONE);
+
+  if (generated_annotation == GeneratedAnnotation::JAVAX) {
+    p->Print(
+        *vars,
+        "@javax.annotation.Generated(\n"
+        "    value = \"by gRPC proto compiler$grpc_version$\",\n"
+        "    comments = \"Source: $file_name$\")\n"
+        "@$GrpcGenerated$\n");
+  } else { // GeneratedAnnotation::OMIT
+    p->Print(
+        *vars,
+        "@$GrpcGenerated$\n");
+  }
+
+  if (service->options().deprecated()) {
+    p->Print(*vars, "@$Deprecated$\n");
+  }
+
   p->Print(
       *vars,
-      "@$Generated$(\n"
-      "    value = \"by gRPC proto compiler$grpc_version$\",\n"
-      "    comments = \"Source: $file_name$\")\n"
       "public final class $service_class_name$ {\n\n");
   p->Indent();
   p->Print(
@@ -1043,7 +1244,7 @@ static void PrintService(const ServiceDescriptor* service,
 
   p->Print(
       *vars,
-      "public static final String SERVICE_NAME = "
+      "public static final $String$ SERVICE_NAME = "
       "\"$Package$$service_name$\";\n\n");
 
   PrintMethodFields(service, vars, p, flavor);
@@ -1054,9 +1255,23 @@ static void PrintService(const ServiceDescriptor* service,
       *vars,
       "public static $service_name$Stub newStub($Channel$ channel) {\n");
   p->Indent();
+  PrintStubFactory(service, vars, p, ASYNC_CLIENT_IMPL);
+  p->Print(*vars, "return $service_name$Stub.newStub(factory, channel);\n");
+  p->Outdent();
+  p->Print("}\n\n");
+
+  // TODO(nmittler): Replace with WriteDocComment once included by protobuf distro.
+  GrpcWriteDocComment(p, " Creates a new blocking-style stub that supports all types of calls "
+                         "on the service");
+  p->Print(
+      *vars,
+      "public static $service_name$BlockingV2Stub newBlockingV2Stub(\n"
+      "    $Channel$ channel) {\n");
+  p->Indent();
+  PrintStubFactory(service, vars, p, BLOCKING_V2_CLIENT_IMPL);
   p->Print(
       *vars,
-      "return new $service_name$Stub(channel);\n");
+      "return $service_name$BlockingV2Stub.newStub(factory, channel);\n");
   p->Outdent();
   p->Print("}\n\n");
 
@@ -1068,109 +1283,59 @@ static void PrintService(const ServiceDescriptor* service,
       "public static $service_name$BlockingStub newBlockingStub(\n"
       "    $Channel$ channel) {\n");
   p->Indent();
+  PrintStubFactory(service, vars, p, BLOCKING_CLIENT_IMPL);
   p->Print(
       *vars,
-      "return new $service_name$BlockingStub(channel);\n");
+      "return $service_name$BlockingStub.newStub(factory, channel);\n");
   p->Outdent();
   p->Print("}\n\n");
 
   // TODO(nmittler): Replace with WriteDocComment once included by protobuf distro.
-  GrpcWriteDocComment(p, " Creates a new ListenableFuture-style stub that supports unary and "
-                         "streaming output calls on the service");
+  GrpcWriteDocComment(p, " Creates a new ListenableFuture-style stub that supports unary calls "
+                         "on the service");
   p->Print(
       *vars,
       "public static $service_name$FutureStub newFutureStub(\n"
       "    $Channel$ channel) {\n");
   p->Indent();
+  PrintStubFactory(service, vars, p, FUTURE_CLIENT_IMPL);
   p->Print(
       *vars,
-      "return new $service_name$FutureStub(channel);\n");
+      "return $service_name$FutureStub.newStub(factory, channel);\n");
   p->Outdent();
   p->Print("}\n\n");
 
-  bool generate_nano = flavor == ProtoFlavor::NANO;
-  PrintStub(service, vars, p, ABSTRACT_CLASS, generate_nano, enable_deprecated);
-  PrintStub(service, vars, p, ASYNC_CLIENT_IMPL, generate_nano, enable_deprecated);
-  PrintStub(service, vars, p, BLOCKING_CLIENT_IMPL, generate_nano, enable_deprecated);
-  PrintStub(service, vars, p, FUTURE_CLIENT_IMPL, generate_nano, enable_deprecated);
-
-  if (enable_deprecated) {
-    PrintDeprecatedDocComment(service, vars, p);
-    PrintStub(service, vars, p, ASYNC_INTERFACE, generate_nano, true);
-    PrintDeprecatedDocComment(service, vars, p);
-    PrintStub(service, vars, p, BLOCKING_CLIENT_INTERFACE, generate_nano, true);
-    PrintDeprecatedDocComment(service, vars, p);
-    PrintStub(service, vars, p, FUTURE_CLIENT_INTERFACE, generate_nano, true);
-
-    PrintDeprecatedDocComment(service, vars, p);
-    p->Print(
-        *vars,
-        "@$Deprecated$ public static abstract class Abstract$service_name$"
-        " extends $service_name$ImplBase {}\n\n");
+  PrintStub(service, vars, p, ASYNC_INTERFACE);
+  PrintAbstractClassStub(service, vars, p);
+  PrintStub(service, vars, p, ASYNC_CLIENT_IMPL);
+  PrintStub(service, vars, p, BLOCKING_V2_CLIENT_IMPL);
+  PrintStub(service, vars, p, BLOCKING_CLIENT_IMPL);
+  PrintStub(service, vars, p, FUTURE_CLIENT_IMPL);
 
-    // static bindService method
-    PrintDeprecatedDocComment(service, vars, p);
-    p->Print(
-        *vars,
-        "@$Deprecated$ public static $ServerServiceDefinition$ bindService("
-        "final $service_name$ serviceImpl) {\n");
-    (*vars)["instance"] = "serviceImpl";
-    PrintBindServiceMethodBody(service, vars, p, generate_nano);
-    p->Print(
-        *vars,
-        "}\n\n");
-  }
-  PrintMethodHandlerClass(service, vars, p, generate_nano, enable_deprecated);
+  PrintMethodHandlerClass(service, vars, p);
+  PrintBindServiceMethod(service, vars, p);
   PrintGetServiceDescriptorMethod(service, vars, p, flavor);
   p->Outdent();
   p->Print("}\n");
 }
 
-void PrintImports(Printer* p, bool generate_nano) {
+void PrintImports(Printer* p) {
   p->Print(
       "import static "
-      "io.grpc.stub.ClientCalls.asyncUnaryCall;\n"
-      "import static "
-      "io.grpc.stub.ClientCalls.asyncServerStreamingCall;\n"
-      "import static "
-      "io.grpc.stub.ClientCalls.asyncClientStreamingCall;\n"
-      "import static "
-      "io.grpc.stub.ClientCalls.asyncBidiStreamingCall;\n"
-      "import static "
-      "io.grpc.stub.ClientCalls.blockingUnaryCall;\n"
-      "import static "
-      "io.grpc.stub.ClientCalls.blockingServerStreamingCall;\n"
-      "import static "
-      "io.grpc.stub.ClientCalls.futureUnaryCall;\n"
-      "import static "
-      "io.grpc.MethodDescriptor.generateFullMethodName;\n"
-      "import static "
-      "io.grpc.stub.ServerCalls.asyncUnaryCall;\n"
-      "import static "
-      "io.grpc.stub.ServerCalls.asyncServerStreamingCall;\n"
-      "import static "
-      "io.grpc.stub.ServerCalls.asyncClientStreamingCall;\n"
-      "import static "
-      "io.grpc.stub.ServerCalls.asyncBidiStreamingCall;\n"
-      "import static "
-      "io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;\n"
-      "import static "
-      "io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;\n\n");
-  if (generate_nano) {
-    p->Print("import java.io.IOException;\n\n");
-  }
+      "io.grpc.MethodDescriptor.generateFullMethodName;\n\n");
 }
 
 void GenerateService(const ServiceDescriptor* service,
-                     google::protobuf::io::ZeroCopyOutputStream* out,
+                     protobuf::io::ZeroCopyOutputStream* out,
                      ProtoFlavor flavor,
-                     bool enable_deprecated) {
+                     bool disable_version,
+                     GeneratedAnnotation generated_annotation) {
   // All non-generated classes must be referred by fully qualified names to
   // avoid collision with generated classes.
-  std::map<string, string> vars;
+  std::map<std::string, std::string> vars;
   vars["String"] = "java.lang.String";
-  vars["Override"] = "java.lang.Override";
   vars["Deprecated"] = "java.lang.Deprecated";
+  vars["Override"] = "java.lang.Override";
   vars["Channel"] = "io.grpc.Channel";
   vars["CallOptions"] = "io.grpc.CallOptions";
   vars["MethodType"] = "io.grpc.MethodDescriptor.MethodType";
@@ -1183,53 +1348,54 @@ void GenerateService(const ServiceDescriptor* service,
       "io.grpc.ServiceDescriptor";
   vars["ProtoFileDescriptorSupplier"] =
       "io.grpc.protobuf.ProtoFileDescriptorSupplier";
+  vars["ProtoServiceDescriptorSupplier"] =
+      "io.grpc.protobuf.ProtoServiceDescriptorSupplier";
+  vars["ProtoMethodDescriptorSupplier"] =
+      "io.grpc.protobuf.ProtoMethodDescriptorSupplier";
   vars["AbstractStub"] = "io.grpc.stub.AbstractStub";
+  vars["AbstractAsyncStub"] = "io.grpc.stub.AbstractAsyncStub";
+  vars["AbstractFutureStub"] = "io.grpc.stub.AbstractFutureStub";
+  vars["AbstractBlockingStub"] = "io.grpc.stub.AbstractBlockingStub";
+  vars["StubFactory"] = "io.grpc.stub.AbstractStub.StubFactory";
+  vars["RpcMethod"] = "io.grpc.stub.annotations.RpcMethod";
   vars["MethodDescriptor"] = "io.grpc.MethodDescriptor";
-  vars["NanoUtils"] = "io.grpc.protobuf.nano.NanoUtils";
   vars["StreamObserver"] = "io.grpc.stub.StreamObserver";
+  vars["BlockingClientCall"] = "io.grpc.stub.BlockingClientCall";
   vars["Iterator"] = "java.util.Iterator";
-  vars["Generated"] = "javax.annotation.Generated";
+  vars["GrpcGenerated"] = "io.grpc.stub.annotations.GrpcGenerated";
   vars["ListenableFuture"] =
       "com.google.common.util.concurrent.ListenableFuture";
-  vars["ExperimentalApi"] = "io.grpc.ExperimentalApi";
 
   Printer printer(out, '$');
-  string package_name = ServiceJavaPackage(service->file(),
-                                           flavor == ProtoFlavor::NANO);
+  std::string package_name = ServiceJavaPackage(service->file());
   if (!package_name.empty()) {
     printer.Print(
         "package $package_name$;\n\n",
         "package_name", package_name);
   }
-  PrintImports(&printer, flavor == ProtoFlavor::NANO);
+  PrintImports(&printer);
 
   // Package string is used to fully qualify method names.
   vars["Package"] = service->file()->package();
   if (!vars["Package"].empty()) {
     vars["Package"].append(".");
   }
-  PrintService(service, &vars, &printer, flavor, enable_deprecated);
+  PrintService(service, &vars, &printer, flavor, disable_version, generated_annotation);
 }
 
-string ServiceJavaPackage(const FileDescriptor* file, bool nano) {
-  string result = google::protobuf::compiler::java::ClassName(file);
+std::string ServiceJavaPackage(const FileDescriptor* file) {
+  std::string result = protobuf::compiler::java::ClassName(file);
   size_t last_dot_pos = result.find_last_of('.');
-  if (last_dot_pos != string::npos) {
+  if (last_dot_pos != std::string::npos) {
     result.resize(last_dot_pos);
   } else {
     result = "";
   }
-  if (nano) {
-    if (!result.empty()) {
-      result += ".";
-    }
-    result += "nano";
-  }
   return result;
 }
 
-string ServiceClassName(const google::protobuf::ServiceDescriptor* service) {
-  return service->name() + "Grpc";
+std::string ServiceClassName(const ServiceDescriptor* service) {
+  return std::string(service->name()) + "Grpc";
 }
 
 }  // namespace java_grpc_generator
diff --git a/compiler/src/java_plugin/cpp/java_generator.h b/compiler/src/java_plugin/cpp/java_generator.h
index 6754249ec32..857fcab31d0 100644
--- a/compiler/src/java_plugin/cpp/java_generator.h
+++ b/compiler/src/java_plugin/cpp/java_generator.h
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2019 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.
+ */
+
 #ifndef NET_GRPC_COMPILER_JAVA_GENERATOR_H_
 #define NET_GRPC_COMPILER_JAVA_GENERATOR_H_
 
@@ -10,50 +26,54 @@
 
 class LogHelper {
   std::ostream* os;
-  bool abort;
 
  public:
-  LogHelper(std::ostream* os, bool abort) : os(os), abort(abort) {}
-  ~LogHelper() {
+  LogHelper(std::ostream* os) : os(os) {}
+  [[ noreturn ]] ~LogHelper() {
     *os << std::endl;
-    if (abort) {
-      ::abort();
-    }
+    ::abort();
   }
   std::ostream& get_os() {
     return *os;
   }
 };
 
-// Abort the program after logging the mesage if the given condition is not
+// Abort the program after logging the message if the given condition is not
 // true. Otherwise, do nothing.
-#define GRPC_CODEGEN_CHECK(x) !(x) && LogHelper(&std::cerr, true).get_os() \
+#define GRPC_CODEGEN_CHECK(x) !(x) && LogHelper(&std::cerr).get_os() \
                              << "CHECK FAILED: " << __FILE__ << ":" \
                              << __LINE__ << ": "
 
-// Abort the program after logging the mesage.
+// Abort the program after logging the message.
 #define GRPC_CODEGEN_FAIL GRPC_CODEGEN_CHECK(false)
 
-using namespace std;
-
 namespace java_grpc_generator {
 
+namespace impl {
+namespace protobuf = google::protobuf;
+} // namespace impl
+
 enum ProtoFlavor {
-  NORMAL, LITE, NANO
+  NORMAL, LITE
+};
+
+enum GeneratedAnnotation {
+  OMIT, JAVAX
 };
 
 // Returns the package name of the gRPC services defined in the given file.
-string ServiceJavaPackage(const google::protobuf::FileDescriptor* file, bool nano);
+std::string ServiceJavaPackage(const impl::protobuf::FileDescriptor* file);
 
 // Returns the name of the outer class that wraps in all the generated code for
 // the given service.
-string ServiceClassName(const google::protobuf::ServiceDescriptor* service);
+std::string ServiceClassName(const impl::protobuf::ServiceDescriptor* service);
 
 // Writes the generated service interface into the given ZeroCopyOutputStream
-void GenerateService(const google::protobuf::ServiceDescriptor* service,
-                     google::protobuf::io::ZeroCopyOutputStream* out,
+void GenerateService(const impl::protobuf::ServiceDescriptor* service,
+                     impl::protobuf::io::ZeroCopyOutputStream* out,
                      ProtoFlavor flavor,
-                     bool enable_deprecated);
+                     bool disable_version,
+                     GeneratedAnnotation generated_annotation);
 
 }  // namespace java_grpc_generator
 
diff --git a/compiler/src/java_plugin/cpp/java_plugin.cpp b/compiler/src/java_plugin/cpp/java_plugin.cpp
index 72ead378417..4b02d6e9884 100644
--- a/compiler/src/java_plugin/cpp/java_plugin.cpp
+++ b/compiler/src/java_plugin/cpp/java_plugin.cpp
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2019 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.
+ */
+
 // Generates Java gRPC service interface out of Protobuf IDL.
 //
 // This is a Proto2 compiler plugin.  See net/proto2/compiler/proto/plugin.proto
@@ -7,12 +23,17 @@
 
 #include "java_generator.h"
 #include <google/protobuf/compiler/code_generator.h>
+#if GOOGLE_PROTOBUF_VERSION >= 5027000
+#include <google/protobuf/compiler/java/java_features.pb.h>
+#endif
 #include <google/protobuf/compiler/plugin.h>
 #include <google/protobuf/descriptor.h>
 #include <google/protobuf/io/zero_copy_stream.h>
 
-static string JavaPackageToDir(const string& package_name) {
-  string package_dir = package_name;
+namespace protobuf = google::protobuf;
+
+static std::string JavaPackageToDir(const std::string& package_name) {
+  std::string package_dir = package_name;
   for (size_t i = 0; i < package_dir.size(); ++i) {
     if (package_dir[i] == '.') {
       package_dir[i] = '/';
@@ -22,42 +43,74 @@ static string JavaPackageToDir(const string& package_name) {
   return package_dir;
 }
 
-class JavaGrpcGenerator : public google::protobuf::compiler::CodeGenerator {
+class JavaGrpcGenerator : public protobuf::compiler::CodeGenerator {
  public:
   JavaGrpcGenerator() {}
   virtual ~JavaGrpcGenerator() {}
 
-  virtual bool Generate(const google::protobuf::FileDescriptor* file,
-                        const string& parameter,
-                        google::protobuf::compiler::GeneratorContext* context,
-                        string* error) const {
-    std::vector<std::pair<string, string> > options;
-    google::protobuf::compiler::ParseGeneratorParameter(parameter, &options);
+// Protobuf 5.27 released edition 2023.
+#if GOOGLE_PROTOBUF_VERSION >= 5027000
+  uint64_t GetSupportedFeatures() const override {
+    return Feature::FEATURE_PROTO3_OPTIONAL |
+           Feature::FEATURE_SUPPORTS_EDITIONS;
+  }
+  protobuf::Edition GetMinimumEdition() const override {
+    return protobuf::Edition::EDITION_PROTO2;
+  }
+  protobuf::Edition GetMaximumEdition() const override {
+#if GOOGLE_PROTOBUF_VERSION >= 6032000
+    return protobuf::Edition::EDITION_2024;
+#else
+    return protobuf::Edition::EDITION_2023;
+#endif
+  }
+  std::vector<const protobuf::FieldDescriptor*> GetFeatureExtensions()
+      const override {
+    return {GetExtensionReflection(pb::java)};
+  }
+#else
+  uint64_t GetSupportedFeatures() const override {
+    return Feature::FEATURE_PROTO3_OPTIONAL;
+  }
+#endif
+
+  virtual bool Generate(const protobuf::FileDescriptor* file,
+                        const std::string& parameter,
+                        protobuf::compiler::GeneratorContext* context,
+                        std::string* error) const override {
+    std::vector<std::pair<std::string, std::string> > options;
+    protobuf::compiler::ParseGeneratorParameter(parameter, &options);
 
     java_grpc_generator::ProtoFlavor flavor =
         java_grpc_generator::ProtoFlavor::NORMAL;
+    java_grpc_generator::GeneratedAnnotation generated_annotation =
+        java_grpc_generator::GeneratedAnnotation::OMIT;
 
-    bool enable_deprecated = false;
-    for (int i = 0; i < options.size(); i++) {
-      if (options[i].first == "nano") {
-        flavor = java_grpc_generator::ProtoFlavor::NANO;
-      } else if (options[i].first == "lite") {
+    bool disable_version = false;
+    for (size_t i = 0; i < options.size(); i++) {
+      if (options[i].first == "lite") {
         flavor = java_grpc_generator::ProtoFlavor::LITE;
-      } else if (options[i].first == "enable_deprecated") {
-        enable_deprecated = options[i].second == "true";
+      } else if (options[i].first == "noversion") {
+        disable_version = true;
+      } else if (options[i].first == "@generated") {
+         if (options[i].second == "omit") {
+           generated_annotation = java_grpc_generator::GeneratedAnnotation::OMIT;
+         } else if (options[i].second == "javax") {
+           generated_annotation = java_grpc_generator::GeneratedAnnotation::JAVAX;
+         }
       }
     }
 
-    string package_name = java_grpc_generator::ServiceJavaPackage(
-        file, flavor == java_grpc_generator::ProtoFlavor::NANO);
-    string package_filename = JavaPackageToDir(package_name);
+    std::string package_name = java_grpc_generator::ServiceJavaPackage(file);
+    std::string package_filename = JavaPackageToDir(package_name);
     for (int i = 0; i < file->service_count(); ++i) {
-      const google::protobuf::ServiceDescriptor* service = file->service(i);
-      string filename = package_filename
+      const protobuf::ServiceDescriptor* service = file->service(i);
+      std::string filename = package_filename
           + java_grpc_generator::ServiceClassName(service) + ".java";
-      std::unique_ptr<google::protobuf::io::ZeroCopyOutputStream> output(
+      std::unique_ptr<protobuf::io::ZeroCopyOutputStream> output(
           context->Open(filename));
-      java_grpc_generator::GenerateService(service, output.get(), flavor, enable_deprecated);
+      java_grpc_generator::GenerateService(
+          service, output.get(), flavor, disable_version, generated_annotation);
     }
     return true;
   }
@@ -65,5 +118,5 @@ class JavaGrpcGenerator : public google::protobuf::compiler::CodeGenerator {
 
 int main(int argc, char* argv[]) {
   JavaGrpcGenerator generator;
-  return google::protobuf::compiler::PluginMain(argc, argv, &generator);
+  return protobuf::compiler::PluginMain(argc, argv, &generator);
 }
diff --git a/compiler/src/test/golden/TestDeprecatedService.java.txt b/compiler/src/test/golden/TestDeprecatedService.java.txt
new file mode 100644
index 00000000000..ed2eab9a696
--- /dev/null
+++ b/compiler/src/test/golden/TestDeprecatedService.java.txt
@@ -0,0 +1,380 @@
+package io.grpc.testing.compiler;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+ * </pre>
+ */
+@javax.annotation.Generated(
+    value = "by gRPC proto compiler (version 1.80.0-SNAPSHOT)",
+    comments = "Source: grpc/testing/compiler/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
+@java.lang.Deprecated
+public final class TestDeprecatedServiceGrpc {
+
+  private TestDeprecatedServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.compiler.TestDeprecatedService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getDeprecatedMethodMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "DeprecatedMethod",
+      requestType = io.grpc.testing.compiler.Test.SimpleRequest.class,
+      responseType = io.grpc.testing.compiler.Test.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getDeprecatedMethodMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse> getDeprecatedMethodMethod;
+    if ((getDeprecatedMethodMethod = TestDeprecatedServiceGrpc.getDeprecatedMethodMethod) == null) {
+      synchronized (TestDeprecatedServiceGrpc.class) {
+        if ((getDeprecatedMethodMethod = TestDeprecatedServiceGrpc.getDeprecatedMethodMethod) == null) {
+          TestDeprecatedServiceGrpc.getDeprecatedMethodMethod = getDeprecatedMethodMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeprecatedMethod"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestDeprecatedServiceMethodDescriptorSupplier("DeprecatedMethod"))
+              .build();
+        }
+      }
+    }
+    return getDeprecatedMethodMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static TestDeprecatedServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceStub>() {
+        @java.lang.Override
+        public TestDeprecatedServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestDeprecatedServiceStub(channel, callOptions);
+        }
+      };
+    return TestDeprecatedServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static TestDeprecatedServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public TestDeprecatedServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestDeprecatedServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return TestDeprecatedServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static TestDeprecatedServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceBlockingStub>() {
+        @java.lang.Override
+        public TestDeprecatedServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestDeprecatedServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return TestDeprecatedServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static TestDeprecatedServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceFutureStub>() {
+        @java.lang.Override
+        public TestDeprecatedServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestDeprecatedServiceFutureStub(channel, callOptions);
+        }
+      };
+    return TestDeprecatedServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+   * </pre>
+   */
+  @java.lang.Deprecated
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * An RPC method that has been deprecated and should generate with Java's &#64;Deprecated annotation
+     * </pre>
+     */
+    @java.lang.Deprecated
+    default void deprecatedMethod(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeprecatedMethodMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service TestDeprecatedService.
+   * <pre>
+   * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+   * </pre>
+   */
+  @java.lang.Deprecated
+  public static abstract class TestDeprecatedServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return TestDeprecatedServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service TestDeprecatedService.
+   * <pre>
+   * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+   * </pre>
+   */
+  @java.lang.Deprecated
+  public static final class TestDeprecatedServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestDeprecatedServiceStub> {
+    private TestDeprecatedServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestDeprecatedServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestDeprecatedServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * An RPC method that has been deprecated and should generate with Java's &#64;Deprecated annotation
+     * </pre>
+     */
+    @java.lang.Deprecated
+    public void deprecatedMethod(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getDeprecatedMethodMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service TestDeprecatedService.
+   * <pre>
+   * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+   * </pre>
+   */
+  @java.lang.Deprecated
+  public static final class TestDeprecatedServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<TestDeprecatedServiceBlockingV2Stub> {
+    private TestDeprecatedServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestDeprecatedServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestDeprecatedServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * An RPC method that has been deprecated and should generate with Java's &#64;Deprecated annotation
+     * </pre>
+     */
+    @java.lang.Deprecated
+    public io.grpc.testing.compiler.Test.SimpleResponse deprecatedMethod(io.grpc.testing.compiler.Test.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getDeprecatedMethodMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service TestDeprecatedService.
+   * <pre>
+   * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+   * </pre>
+   */
+  @java.lang.Deprecated
+  public static final class TestDeprecatedServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<TestDeprecatedServiceBlockingStub> {
+    private TestDeprecatedServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestDeprecatedServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestDeprecatedServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * An RPC method that has been deprecated and should generate with Java's &#64;Deprecated annotation
+     * </pre>
+     */
+    @java.lang.Deprecated
+    public io.grpc.testing.compiler.Test.SimpleResponse deprecatedMethod(io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getDeprecatedMethodMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service TestDeprecatedService.
+   * <pre>
+   * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+   * </pre>
+   */
+  @java.lang.Deprecated
+  public static final class TestDeprecatedServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestDeprecatedServiceFutureStub> {
+    private TestDeprecatedServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestDeprecatedServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestDeprecatedServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * An RPC method that has been deprecated and should generate with Java's &#64;Deprecated annotation
+     * </pre>
+     */
+    @java.lang.Deprecated
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.compiler.Test.SimpleResponse> deprecatedMethod(
+        io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getDeprecatedMethodMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_DEPRECATED_METHOD = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_DEPRECATED_METHOD:
+          serviceImpl.deprecatedMethod((io.grpc.testing.compiler.Test.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getDeprecatedMethodMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.SimpleRequest,
+              io.grpc.testing.compiler.Test.SimpleResponse>(
+                service, METHODID_DEPRECATED_METHOD)))
+        .build();
+  }
+
+  private static abstract class TestDeprecatedServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    TestDeprecatedServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.testing.compiler.Test.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("TestDeprecatedService");
+    }
+  }
+
+  private static final class TestDeprecatedServiceFileDescriptorSupplier
+      extends TestDeprecatedServiceBaseDescriptorSupplier {
+    TestDeprecatedServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class TestDeprecatedServiceMethodDescriptorSupplier
+      extends TestDeprecatedServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    TestDeprecatedServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (TestDeprecatedServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new TestDeprecatedServiceFileDescriptorSupplier())
+              .addMethod(getDeprecatedMethodMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/compiler/src/test/golden/TestService.java.txt b/compiler/src/test/golden/TestService.java.txt
index 11b45170ed0..2afdfdbf206 100644
--- a/compiler/src/test/golden/TestService.java.txt
+++ b/compiler/src/test/golden/TestService.java.txt
@@ -1,19 +1,6 @@
-package io.grpc.testing.integration;
-
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
+package io.grpc.testing.compiler;
+
 import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
 
 /**
  * <pre>
@@ -21,66 +8,293 @@ import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
  * </pre>
  */
 @javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: test.proto")
+    value = "by gRPC proto compiler (version 1.80.0-SNAPSHOT)",
+    comments = "Source: grpc/testing/compiler/test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class TestServiceGrpc {
 
   private TestServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.TestService";
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.compiler.TestService";
 
   // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Test.SimpleRequest,
-      io.grpc.testing.integration.Test.SimpleResponse> METHOD_UNARY_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.testing.TestService", "UnaryCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Test.SimpleRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Test.SimpleResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Test.StreamingOutputCallRequest,
-      io.grpc.testing.integration.Test.StreamingOutputCallResponse> METHOD_STREAMING_OUTPUT_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "StreamingOutputCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Test.StreamingInputCallRequest,
-      io.grpc.testing.integration.Test.StreamingInputCallResponse> METHOD_STREAMING_INPUT_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "StreamingInputCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Test.StreamingInputCallRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Test.StreamingInputCallResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Test.StreamingOutputCallRequest,
-      io.grpc.testing.integration.Test.StreamingOutputCallResponse> METHOD_FULL_BIDI_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "FullBidiCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Test.StreamingOutputCallRequest,
-      io.grpc.testing.integration.Test.StreamingOutputCallResponse> METHOD_HALF_BIDI_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "HalfBidiCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallResponse.getDefaultInstance()));
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getUnaryCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UnaryCall",
+      requestType = io.grpc.testing.compiler.Test.SimpleRequest.class,
+      responseType = io.grpc.testing.compiler.Test.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getUnaryCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse> getUnaryCallMethod;
+    if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) {
+          TestServiceGrpc.getUnaryCallMethod = getUnaryCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnaryCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("UnaryCall"))
+              .build();
+        }
+      }
+    }
+    return getUnaryCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getStreamingOutputCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingOutputCall",
+      requestType = io.grpc.testing.compiler.Test.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.compiler.Test.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getStreamingOutputCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getStreamingOutputCallMethod;
+    if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) {
+          TestServiceGrpc.getStreamingOutputCallMethod = getStreamingOutputCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingOutputCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingOutputCallResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("StreamingOutputCall"))
+              .build();
+        }
+      }
+    }
+    return getStreamingOutputCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingInputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingInputCallResponse> getStreamingInputCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingInputCall",
+      requestType = io.grpc.testing.compiler.Test.StreamingInputCallRequest.class,
+      responseType = io.grpc.testing.compiler.Test.StreamingInputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingInputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingInputCallResponse> getStreamingInputCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingInputCallRequest, io.grpc.testing.compiler.Test.StreamingInputCallResponse> getStreamingInputCallMethod;
+    if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) {
+          TestServiceGrpc.getStreamingInputCallMethod = getStreamingInputCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.StreamingInputCallRequest, io.grpc.testing.compiler.Test.StreamingInputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingInputCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingInputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingInputCallResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("StreamingInputCall"))
+              .build();
+        }
+      }
+    }
+    return getStreamingInputCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getFullBidiCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "FullBidiCall",
+      requestType = io.grpc.testing.compiler.Test.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.compiler.Test.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getFullBidiCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getFullBidiCallMethod;
+    if ((getFullBidiCallMethod = TestServiceGrpc.getFullBidiCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getFullBidiCallMethod = TestServiceGrpc.getFullBidiCallMethod) == null) {
+          TestServiceGrpc.getFullBidiCallMethod = getFullBidiCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FullBidiCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingOutputCallResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("FullBidiCall"))
+              .build();
+        }
+      }
+    }
+    return getFullBidiCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getHalfBidiCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "HalfBidiCall",
+      requestType = io.grpc.testing.compiler.Test.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.compiler.Test.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getHalfBidiCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getHalfBidiCallMethod;
+    if ((getHalfBidiCallMethod = TestServiceGrpc.getHalfBidiCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getHalfBidiCallMethod = TestServiceGrpc.getHalfBidiCallMethod) == null) {
+          TestServiceGrpc.getHalfBidiCallMethod = getHalfBidiCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "HalfBidiCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingOutputCallResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("HalfBidiCall"))
+              .build();
+        }
+      }
+    }
+    return getHalfBidiCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingInputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingInputCallResponse> getImportMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Import",
+      requestType = io.grpc.testing.compiler.Test.StreamingInputCallRequest.class,
+      responseType = io.grpc.testing.compiler.Test.StreamingInputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingInputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingInputCallResponse> getImportMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingInputCallRequest, io.grpc.testing.compiler.Test.StreamingInputCallResponse> getImportMethod;
+    if ((getImportMethod = TestServiceGrpc.getImportMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getImportMethod = TestServiceGrpc.getImportMethod) == null) {
+          TestServiceGrpc.getImportMethod = getImportMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.StreamingInputCallRequest, io.grpc.testing.compiler.Test.StreamingInputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Import"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingInputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingInputCallResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("Import"))
+              .build();
+        }
+      }
+    }
+    return getImportMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getSafeCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "SafeCall",
+      requestType = io.grpc.testing.compiler.Test.SimpleRequest.class,
+      responseType = io.grpc.testing.compiler.Test.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getSafeCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse> getSafeCallMethod;
+    if ((getSafeCallMethod = TestServiceGrpc.getSafeCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getSafeCallMethod = TestServiceGrpc.getSafeCallMethod) == null) {
+          TestServiceGrpc.getSafeCallMethod = getSafeCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SafeCall"))
+              .setSafe(true)
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("SafeCall"))
+              .build();
+        }
+      }
+    }
+    return getSafeCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getIdempotentCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "IdempotentCall",
+      requestType = io.grpc.testing.compiler.Test.SimpleRequest.class,
+      responseType = io.grpc.testing.compiler.Test.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getIdempotentCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse> getIdempotentCallMethod;
+    if ((getIdempotentCallMethod = TestServiceGrpc.getIdempotentCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getIdempotentCallMethod = TestServiceGrpc.getIdempotentCallMethod) == null) {
+          TestServiceGrpc.getIdempotentCallMethod = getIdempotentCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "IdempotentCall"))
+              .setIdempotent(true)
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("IdempotentCall"))
+              .build();
+        }
+      }
+    }
+    return getIdempotentCallMethod;
+  }
 
   /**
    * Creates a new async stub that supports all call types for the service
    */
   public static TestServiceStub newStub(io.grpc.Channel channel) {
-    return new TestServiceStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceStub>() {
+        @java.lang.Override
+        public TestServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceStub(channel, callOptions);
+        }
+      };
+    return TestServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static TestServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public TestServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return TestServiceBlockingV2Stub.newStub(factory, channel);
   }
 
   /**
@@ -88,15 +302,29 @@ public final class TestServiceGrpc {
    */
   public static TestServiceBlockingStub newBlockingStub(
       io.grpc.Channel channel) {
-    return new TestServiceBlockingStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingStub>() {
+        @java.lang.Override
+        public TestServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return TestServiceBlockingStub.newStub(factory, channel);
   }
 
   /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
    */
   public static TestServiceFutureStub newFutureStub(
       io.grpc.Channel channel) {
-    return new TestServiceFutureStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceFutureStub>() {
+        @java.lang.Override
+        public TestServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceFutureStub(channel, callOptions);
+        }
+      };
+    return TestServiceFutureStub.newStub(factory, channel);
   }
 
   /**
@@ -104,7 +332,7 @@ public final class TestServiceGrpc {
    * Test service that supports all call types.
    * </pre>
    */
-  public static abstract class TestServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -112,9 +340,9 @@ public final class TestServiceGrpc {
      * The server returns the client payload as-is.
      * </pre>
      */
-    public void unaryCall(io.grpc.testing.integration.Test.SimpleRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.SimpleResponse> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_UNARY_CALL, responseObserver);
+    default void unaryCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnaryCallMethod(), responseObserver);
     }
 
     /**
@@ -123,9 +351,9 @@ public final class TestServiceGrpc {
      * The server returns the payload with client desired type and sizes.
      * </pre>
      */
-    public void streamingOutputCall(io.grpc.testing.integration.Test.StreamingOutputCallRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_STREAMING_OUTPUT_CALL, responseObserver);
+    default void streamingOutputCall(io.grpc.testing.compiler.Test.StreamingOutputCallRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStreamingOutputCallMethod(), responseObserver);
     }
 
     /**
@@ -134,9 +362,9 @@ public final class TestServiceGrpc {
      * The server returns the aggregated size of client payload as the result.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallRequest> streamingInputCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_STREAMING_INPUT_CALL, responseObserver);
+    default io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallRequest> streamingInputCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamingInputCallMethod(), responseObserver);
     }
 
     /**
@@ -146,9 +374,9 @@ public final class TestServiceGrpc {
      * demonstrates the idea of full bidirectionality.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallRequest> fullBidiCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_FULL_BIDI_CALL, responseObserver);
+    default io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallRequest> fullBidiCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getFullBidiCallMethod(), responseObserver);
     }
 
     /**
@@ -159,70 +387,73 @@ public final class TestServiceGrpc {
      * first request.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallRequest> halfBidiCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_HALF_BIDI_CALL, responseObserver);
+    default io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallRequest> halfBidiCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getHalfBidiCallMethod(), responseObserver);
     }
 
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_UNARY_CALL,
-            asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Test.SimpleRequest,
-                io.grpc.testing.integration.Test.SimpleResponse>(
-                  this, METHODID_UNARY_CALL)))
-          .addMethod(
-            METHOD_STREAMING_OUTPUT_CALL,
-            asyncServerStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Test.StreamingOutputCallRequest,
-                io.grpc.testing.integration.Test.StreamingOutputCallResponse>(
-                  this, METHODID_STREAMING_OUTPUT_CALL)))
-          .addMethod(
-            METHOD_STREAMING_INPUT_CALL,
-            asyncClientStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Test.StreamingInputCallRequest,
-                io.grpc.testing.integration.Test.StreamingInputCallResponse>(
-                  this, METHODID_STREAMING_INPUT_CALL)))
-          .addMethod(
-            METHOD_FULL_BIDI_CALL,
-            asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Test.StreamingOutputCallRequest,
-                io.grpc.testing.integration.Test.StreamingOutputCallResponse>(
-                  this, METHODID_FULL_BIDI_CALL)))
-          .addMethod(
-            METHOD_HALF_BIDI_CALL,
-            asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Test.StreamingOutputCallRequest,
-                io.grpc.testing.integration.Test.StreamingOutputCallResponse>(
-                  this, METHODID_HALF_BIDI_CALL)))
-          .build();
+    /**
+     * <pre>
+     * An RPC method whose Java name collides with a keyword, and whose generated
+     * method should have a '_' appended.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallRequest> import_(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getImportMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Safe.
+     * </pre>
+     */
+    default void safeCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSafeCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Idempotent.
+     * </pre>
+     */
+    default void idempotentCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getIdempotentCallMethod(), responseObserver);
     }
   }
 
   /**
+   * Base class for the server implementation of the service TestService.
    * <pre>
    * Test service that supports all call types.
    * </pre>
    */
-  public static final class TestServiceStub extends io.grpc.stub.AbstractStub<TestServiceStub> {
-    private TestServiceStub(io.grpc.Channel channel) {
-      super(channel);
+  public static abstract class TestServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return TestServiceGrpc.bindService(this);
     }
+  }
 
-    private TestServiceStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service TestService.
+   * <pre>
+   * Test service that supports all call types.
+   * </pre>
+   */
+  public static final class TestServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestServiceStub> {
+    private TestServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected TestServiceStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected TestServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new TestServiceStub(channel, callOptions);
     }
 
@@ -232,10 +463,10 @@ public final class TestServiceGrpc {
      * The server returns the client payload as-is.
      * </pre>
      */
-    public void unaryCall(io.grpc.testing.integration.Test.SimpleRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.SimpleResponse> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_UNARY_CALL, getCallOptions()), request, responseObserver);
+    public void unaryCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request, responseObserver);
     }
 
     /**
@@ -244,10 +475,10 @@ public final class TestServiceGrpc {
      * The server returns the payload with client desired type and sizes.
      * </pre>
      */
-    public void streamingOutputCall(io.grpc.testing.integration.Test.StreamingOutputCallRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver) {
-      asyncServerStreamingCall(
-          getChannel().newCall(METHOD_STREAMING_OUTPUT_CALL, getCallOptions()), request, responseObserver);
+    public void streamingOutputCall(io.grpc.testing.compiler.Test.StreamingOutputCallRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getStreamingOutputCallMethod(), getCallOptions()), request, responseObserver);
     }
 
     /**
@@ -256,10 +487,10 @@ public final class TestServiceGrpc {
      * The server returns the aggregated size of client payload as the result.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallRequest> streamingInputCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallResponse> responseObserver) {
-      return asyncClientStreamingCall(
-          getChannel().newCall(METHOD_STREAMING_INPUT_CALL, getCallOptions()), responseObserver);
+    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallRequest> streamingInputCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncClientStreamingCall(
+          getChannel().newCall(getStreamingInputCallMethod(), getCallOptions()), responseObserver);
     }
 
     /**
@@ -269,10 +500,10 @@ public final class TestServiceGrpc {
      * demonstrates the idea of full bidirectionality.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallRequest> fullBidiCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver) {
-      return asyncBidiStreamingCall(
-          getChannel().newCall(METHOD_FULL_BIDI_CALL, getCallOptions()), responseObserver);
+    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallRequest> fullBidiCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getFullBidiCallMethod(), getCallOptions()), responseObserver);
     }
 
     /**
@@ -283,31 +514,182 @@ public final class TestServiceGrpc {
      * first request.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallRequest> halfBidiCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver) {
-      return asyncBidiStreamingCall(
-          getChannel().newCall(METHOD_HALF_BIDI_CALL, getCallOptions()), responseObserver);
+    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallRequest> halfBidiCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getHalfBidiCallMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * An RPC method whose Java name collides with a keyword, and whose generated
+     * method should have a '_' appended.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallRequest> import_(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getImportMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Safe.
+     * </pre>
+     */
+    public void safeCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getSafeCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Idempotent.
+     * </pre>
+     */
+    public void idempotentCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getIdempotentCallMethod(), getCallOptions()), request, responseObserver);
     }
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service TestService.
    * <pre>
    * Test service that supports all call types.
    * </pre>
    */
-  public static final class TestServiceBlockingStub extends io.grpc.stub.AbstractStub<TestServiceBlockingStub> {
-    private TestServiceBlockingStub(io.grpc.Channel channel) {
-      super(channel);
+  public static final class TestServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingV2Stub> {
+    private TestServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * The server returns the client payload as-is.
+     * </pre>
+     */
+    public io.grpc.testing.compiler.Test.SimpleResponse unaryCall(io.grpc.testing.compiler.Test.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<?, io.grpc.testing.compiler.Test.StreamingOutputCallResponse>
+        streamingOutputCall(io.grpc.testing.compiler.Test.StreamingOutputCallRequest request) {
+      return io.grpc.stub.ClientCalls.blockingV2ServerStreamingCall(
+          getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.compiler.Test.StreamingInputCallRequest, io.grpc.testing.compiler.Test.StreamingInputCallResponse>
+        streamingInputCall() {
+      return io.grpc.stub.ClientCalls.blockingClientStreamingCall(
+          getChannel(), getStreamingInputCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full bidirectionality.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse>
+        fullBidiCall() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getFullBidiCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse>
+        halfBidiCall() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getHalfBidiCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * An RPC method whose Java name collides with a keyword, and whose generated
+     * method should have a '_' appended.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.compiler.Test.StreamingInputCallRequest, io.grpc.testing.compiler.Test.StreamingInputCallResponse>
+        import_() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getImportMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Safe.
+     * </pre>
+     */
+    public io.grpc.testing.compiler.Test.SimpleResponse safeCall(io.grpc.testing.compiler.Test.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getSafeCallMethod(), getCallOptions(), request);
     }
 
-    private TestServiceBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    /**
+     * <pre>
+     * A unary call that is Idempotent.
+     * </pre>
+     */
+    public io.grpc.testing.compiler.Test.SimpleResponse idempotentCall(io.grpc.testing.compiler.Test.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getIdempotentCallMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service TestService.
+   * <pre>
+   * Test service that supports all call types.
+   * </pre>
+   */
+  public static final class TestServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingStub> {
+    private TestServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected TestServiceBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected TestServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new TestServiceBlockingStub(channel, callOptions);
     }
 
@@ -317,9 +699,9 @@ public final class TestServiceGrpc {
      * The server returns the client payload as-is.
      * </pre>
      */
-    public io.grpc.testing.integration.Test.SimpleResponse unaryCall(io.grpc.testing.integration.Test.SimpleRequest request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_UNARY_CALL, getCallOptions(), request);
+    public io.grpc.testing.compiler.Test.SimpleResponse unaryCall(io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUnaryCallMethod(), getCallOptions(), request);
     }
 
     /**
@@ -328,31 +710,49 @@ public final class TestServiceGrpc {
      * The server returns the payload with client desired type and sizes.
      * </pre>
      */
-    public java.util.Iterator<io.grpc.testing.integration.Test.StreamingOutputCallResponse> streamingOutputCall(
-        io.grpc.testing.integration.Test.StreamingOutputCallRequest request) {
-      return blockingServerStreamingCall(
-          getChannel(), METHOD_STREAMING_OUTPUT_CALL, getCallOptions(), request);
+    public java.util.Iterator<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> streamingOutputCall(
+        io.grpc.testing.compiler.Test.StreamingOutputCallRequest request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Safe.
+     * </pre>
+     */
+    public io.grpc.testing.compiler.Test.SimpleResponse safeCall(io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getSafeCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Idempotent.
+     * </pre>
+     */
+    public io.grpc.testing.compiler.Test.SimpleResponse idempotentCall(io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getIdempotentCallMethod(), getCallOptions(), request);
     }
   }
 
   /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service TestService.
    * <pre>
    * Test service that supports all call types.
    * </pre>
    */
-  public static final class TestServiceFutureStub extends io.grpc.stub.AbstractStub<TestServiceFutureStub> {
-    private TestServiceFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private TestServiceFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class TestServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestServiceFutureStub> {
+    private TestServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected TestServiceFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected TestServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new TestServiceFutureStub(channel, callOptions);
     }
 
@@ -362,28 +762,53 @@ public final class TestServiceGrpc {
      * The server returns the client payload as-is.
      * </pre>
      */
-    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Test.SimpleResponse> unaryCall(
-        io.grpc.testing.integration.Test.SimpleRequest request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_UNARY_CALL, getCallOptions()), request);
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.compiler.Test.SimpleResponse> unaryCall(
+        io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Safe.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.compiler.Test.SimpleResponse> safeCall(
+        io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getSafeCallMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Idempotent.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.compiler.Test.SimpleResponse> idempotentCall(
+        io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getIdempotentCallMethod(), getCallOptions()), request);
     }
   }
 
   private static final int METHODID_UNARY_CALL = 0;
   private static final int METHODID_STREAMING_OUTPUT_CALL = 1;
-  private static final int METHODID_STREAMING_INPUT_CALL = 2;
-  private static final int METHODID_FULL_BIDI_CALL = 3;
-  private static final int METHODID_HALF_BIDI_CALL = 4;
+  private static final int METHODID_SAFE_CALL = 2;
+  private static final int METHODID_IDEMPOTENT_CALL = 3;
+  private static final int METHODID_STREAMING_INPUT_CALL = 4;
+  private static final int METHODID_FULL_BIDI_CALL = 5;
+  private static final int METHODID_HALF_BIDI_CALL = 6;
+  private static final int METHODID_IMPORT = 7;
 
   private static final class MethodHandlers<Req, Resp> implements
       io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final TestServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(TestServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -393,12 +818,20 @@ public final class TestServiceGrpc {
     public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
       switch (methodId) {
         case METHODID_UNARY_CALL:
-          serviceImpl.unaryCall((io.grpc.testing.integration.Test.SimpleRequest) request,
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.SimpleResponse>) responseObserver);
+          serviceImpl.unaryCall((io.grpc.testing.compiler.Test.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse>) responseObserver);
           break;
         case METHODID_STREAMING_OUTPUT_CALL:
-          serviceImpl.streamingOutputCall((io.grpc.testing.integration.Test.StreamingOutputCallRequest) request,
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse>) responseObserver);
+          serviceImpl.streamingOutputCall((io.grpc.testing.compiler.Test.StreamingOutputCallRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse>) responseObserver);
+          break;
+        case METHODID_SAFE_CALL:
+          serviceImpl.safeCall((io.grpc.testing.compiler.Test.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse>) responseObserver);
+          break;
+        case METHODID_IDEMPOTENT_CALL:
+          serviceImpl.idempotentCall((io.grpc.testing.compiler.Test.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse>) responseObserver);
           break;
         default:
           throw new AssertionError();
@@ -412,23 +845,115 @@ public final class TestServiceGrpc {
       switch (methodId) {
         case METHODID_STREAMING_INPUT_CALL:
           return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamingInputCall(
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallResponse>) responseObserver);
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallResponse>) responseObserver);
         case METHODID_FULL_BIDI_CALL:
           return (io.grpc.stub.StreamObserver<Req>) serviceImpl.fullBidiCall(
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse>) responseObserver);
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse>) responseObserver);
         case METHODID_HALF_BIDI_CALL:
           return (io.grpc.stub.StreamObserver<Req>) serviceImpl.halfBidiCall(
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse>) responseObserver);
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse>) responseObserver);
+        case METHODID_IMPORT:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.import_(
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallResponse>) responseObserver);
         default:
           throw new AssertionError();
       }
     }
   }
 
-  private static final class TestServiceDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getUnaryCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.SimpleRequest,
+              io.grpc.testing.compiler.Test.SimpleResponse>(
+                service, METHODID_UNARY_CALL)))
+        .addMethod(
+          getStreamingOutputCallMethod(),
+          io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+              io.grpc.testing.compiler.Test.StreamingOutputCallResponse>(
+                service, METHODID_STREAMING_OUTPUT_CALL)))
+        .addMethod(
+          getStreamingInputCallMethod(),
+          io.grpc.stub.ServerCalls.asyncClientStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.StreamingInputCallRequest,
+              io.grpc.testing.compiler.Test.StreamingInputCallResponse>(
+                service, METHODID_STREAMING_INPUT_CALL)))
+        .addMethod(
+          getFullBidiCallMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+              io.grpc.testing.compiler.Test.StreamingOutputCallResponse>(
+                service, METHODID_FULL_BIDI_CALL)))
+        .addMethod(
+          getHalfBidiCallMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+              io.grpc.testing.compiler.Test.StreamingOutputCallResponse>(
+                service, METHODID_HALF_BIDI_CALL)))
+        .addMethod(
+          getImportMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.StreamingInputCallRequest,
+              io.grpc.testing.compiler.Test.StreamingInputCallResponse>(
+                service, METHODID_IMPORT)))
+        .addMethod(
+          getSafeCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.SimpleRequest,
+              io.grpc.testing.compiler.Test.SimpleResponse>(
+                service, METHODID_SAFE_CALL)))
+        .addMethod(
+          getIdempotentCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.SimpleRequest,
+              io.grpc.testing.compiler.Test.SimpleResponse>(
+                service, METHODID_IDEMPOTENT_CALL)))
+        .build();
+  }
+
+  private static abstract class TestServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    TestServiceBaseDescriptorSupplier() {}
+
     @java.lang.Override
     public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return io.grpc.testing.integration.Test.getDescriptor();
+      return io.grpc.testing.compiler.Test.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("TestService");
+    }
+  }
+
+  private static final class TestServiceFileDescriptorSupplier
+      extends TestServiceBaseDescriptorSupplier {
+    TestServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class TestServiceMethodDescriptorSupplier
+      extends TestServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    TestServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
     }
   }
 
@@ -441,12 +966,15 @@ public final class TestServiceGrpc {
         result = serviceDescriptor;
         if (result == null) {
           serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new TestServiceDescriptorSupplier())
-              .addMethod(METHOD_UNARY_CALL)
-              .addMethod(METHOD_STREAMING_OUTPUT_CALL)
-              .addMethod(METHOD_STREAMING_INPUT_CALL)
-              .addMethod(METHOD_FULL_BIDI_CALL)
-              .addMethod(METHOD_HALF_BIDI_CALL)
+              .setSchemaDescriptor(new TestServiceFileDescriptorSupplier())
+              .addMethod(getUnaryCallMethod())
+              .addMethod(getStreamingOutputCallMethod())
+              .addMethod(getStreamingInputCallMethod())
+              .addMethod(getFullBidiCallMethod())
+              .addMethod(getHalfBidiCallMethod())
+              .addMethod(getImportMethod())
+              .addMethod(getSafeCallMethod())
+              .addMethod(getIdempotentCallMethod())
               .build();
         }
       }
diff --git a/compiler/src/test/proto/grpc/testing/compiler/test.proto b/compiler/src/test/proto/grpc/testing/compiler/test.proto
new file mode 100644
index 00000000000..c1cb5572166
--- /dev/null
+++ b/compiler/src/test/proto/grpc/testing/compiler/test.proto
@@ -0,0 +1,93 @@
+// Copyright 2015 The gRPC Authors
+// All rights reserved.
+//
+// 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.
+
+// A simple service definition for testing the protoc plugin.
+syntax = "proto3";
+
+package grpc.testing.compiler;
+
+option java_package = "io.grpc.testing.compiler";
+
+message SimpleRequest {
+}
+
+message SimpleResponse {
+}
+
+message StreamingInputCallRequest {
+}
+
+message StreamingInputCallResponse {
+}
+
+message StreamingOutputCallRequest {
+}
+
+message StreamingOutputCallResponse {
+}
+
+// Test service that supports all call types.
+service TestService {
+  // One request followed by one response.
+  // The server returns the client payload as-is.
+  rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
+
+  // One request followed by a sequence of responses (streamed download).
+  // The server returns the payload with client desired type and sizes.
+  rpc StreamingOutputCall(StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+
+  // A sequence of requests followed by one response (streamed upload).
+  // The server returns the aggregated size of client payload as the result.
+  rpc StreamingInputCall(stream StreamingInputCallRequest)
+      returns (StreamingInputCallResponse);
+
+  // A sequence of requests with each request served by the server immediately.
+  // As one request could lead to multiple responses, this interface
+  // demonstrates the idea of full bidirectionality.
+  rpc FullBidiCall(stream StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+
+  // A sequence of requests followed by a sequence of responses.
+  // The server buffers all the client requests and then serves them in order. A
+  // stream of responses are returned to the client when the server starts with
+  // first request.
+  rpc HalfBidiCall(stream StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+
+  // An RPC method whose Java name collides with a keyword, and whose generated
+  // method should have a '_' appended.
+  rpc Import(stream StreamingInputCallRequest) returns (stream StreamingInputCallResponse);
+
+  // A unary call that is Safe.
+  rpc SafeCall(SimpleRequest) returns (SimpleResponse) {
+      option idempotency_level = NO_SIDE_EFFECTS;
+  }
+
+  // A unary call that is Idempotent.
+  rpc IdempotentCall(SimpleRequest) returns (SimpleResponse) {
+      option idempotency_level = IDEMPOTENT;
+  }
+}
+
+// Test service that has been deprecated and should generate with Java's @Deprecated annotation
+service TestDeprecatedService {
+  option deprecated = true;
+
+  // An RPC method that has been deprecated and should generate with Java's @Deprecated annotation
+  rpc DeprecatedMethod(SimpleRequest) returns (SimpleResponse) {
+    option deprecated = true;
+  }
+}
diff --git a/compiler/src/test/proto/test.proto b/compiler/src/test/proto/test.proto
deleted file mode 100644
index dfaaed571ce..00000000000
--- a/compiler/src/test/proto/test.proto
+++ /dev/null
@@ -1,54 +0,0 @@
-// A simple service definition for testing the protoc plugin.
-syntax = "proto3";
-
-package grpc.testing;
-
-option java_package = "io.grpc.testing.integration";
-
-message SimpleRequest {
-}
-
-message SimpleResponse {
-}
-
-message StreamingInputCallRequest {
-}
-
-message StreamingInputCallResponse {
-}
-
-message StreamingOutputCallRequest {
-}
-
-message StreamingOutputCallResponse {
-}
-
-// Test service that supports all call types.
-service TestService {
-  // One request followed by one response.
-  // The server returns the client payload as-is.
-  rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
-
-  // One request followed by a sequence of responses (streamed download).
-  // The server returns the payload with client desired type and sizes.
-  rpc StreamingOutputCall(StreamingOutputCallRequest)
-      returns (stream StreamingOutputCallResponse);
-
-  // A sequence of requests followed by one response (streamed upload).
-  // The server returns the aggregated size of client payload as the result.
-  rpc StreamingInputCall(stream StreamingInputCallRequest)
-      returns (StreamingInputCallResponse);
-
-  // A sequence of requests with each request served by the server immediately.
-  // As one request could lead to multiple responses, this interface
-  // demonstrates the idea of full bidirectionality.
-  rpc FullBidiCall(stream StreamingOutputCallRequest)
-      returns (stream StreamingOutputCallResponse);
-
-  // A sequence of requests followed by a sequence of responses.
-  // The server buffers all the client requests and then serves them in order. A
-  // stream of responses are returned to the client when the server starts with
-  // first request.
-  rpc HalfBidiCall(stream StreamingOutputCallRequest)
-      returns (stream StreamingOutputCallResponse);
-}
diff --git a/compiler/src/testLite/golden/TestDeprecatedService.java.txt b/compiler/src/testLite/golden/TestDeprecatedService.java.txt
new file mode 100644
index 00000000000..89ea2e698bf
--- /dev/null
+++ b/compiler/src/testLite/golden/TestDeprecatedService.java.txt
@@ -0,0 +1,340 @@
+package io.grpc.testing.compiler;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+@java.lang.Deprecated
+public final class TestDeprecatedServiceGrpc {
+
+  private TestDeprecatedServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.compiler.TestDeprecatedService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getDeprecatedMethodMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "DeprecatedMethod",
+      requestType = io.grpc.testing.compiler.Test.SimpleRequest.class,
+      responseType = io.grpc.testing.compiler.Test.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getDeprecatedMethodMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse> getDeprecatedMethodMethod;
+    if ((getDeprecatedMethodMethod = TestDeprecatedServiceGrpc.getDeprecatedMethodMethod) == null) {
+      synchronized (TestDeprecatedServiceGrpc.class) {
+        if ((getDeprecatedMethodMethod = TestDeprecatedServiceGrpc.getDeprecatedMethodMethod) == null) {
+          TestDeprecatedServiceGrpc.getDeprecatedMethodMethod = getDeprecatedMethodMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeprecatedMethod"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getDeprecatedMethodMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static TestDeprecatedServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceStub>() {
+        @java.lang.Override
+        public TestDeprecatedServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestDeprecatedServiceStub(channel, callOptions);
+        }
+      };
+    return TestDeprecatedServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static TestDeprecatedServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public TestDeprecatedServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestDeprecatedServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return TestDeprecatedServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static TestDeprecatedServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceBlockingStub>() {
+        @java.lang.Override
+        public TestDeprecatedServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestDeprecatedServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return TestDeprecatedServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static TestDeprecatedServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestDeprecatedServiceFutureStub>() {
+        @java.lang.Override
+        public TestDeprecatedServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestDeprecatedServiceFutureStub(channel, callOptions);
+        }
+      };
+    return TestDeprecatedServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+   * </pre>
+   */
+  @java.lang.Deprecated
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * An RPC method that has been deprecated and should generate with Java's &#64;Deprecated annotation
+     * </pre>
+     */
+    @java.lang.Deprecated
+    default void deprecatedMethod(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeprecatedMethodMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service TestDeprecatedService.
+   * <pre>
+   * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+   * </pre>
+   */
+  @java.lang.Deprecated
+  public static abstract class TestDeprecatedServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return TestDeprecatedServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service TestDeprecatedService.
+   * <pre>
+   * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+   * </pre>
+   */
+  @java.lang.Deprecated
+  public static final class TestDeprecatedServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestDeprecatedServiceStub> {
+    private TestDeprecatedServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestDeprecatedServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestDeprecatedServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * An RPC method that has been deprecated and should generate with Java's &#64;Deprecated annotation
+     * </pre>
+     */
+    @java.lang.Deprecated
+    public void deprecatedMethod(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getDeprecatedMethodMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service TestDeprecatedService.
+   * <pre>
+   * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+   * </pre>
+   */
+  @java.lang.Deprecated
+  public static final class TestDeprecatedServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<TestDeprecatedServiceBlockingV2Stub> {
+    private TestDeprecatedServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestDeprecatedServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestDeprecatedServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * An RPC method that has been deprecated and should generate with Java's &#64;Deprecated annotation
+     * </pre>
+     */
+    @java.lang.Deprecated
+    public io.grpc.testing.compiler.Test.SimpleResponse deprecatedMethod(io.grpc.testing.compiler.Test.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getDeprecatedMethodMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service TestDeprecatedService.
+   * <pre>
+   * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+   * </pre>
+   */
+  @java.lang.Deprecated
+  public static final class TestDeprecatedServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<TestDeprecatedServiceBlockingStub> {
+    private TestDeprecatedServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestDeprecatedServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestDeprecatedServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * An RPC method that has been deprecated and should generate with Java's &#64;Deprecated annotation
+     * </pre>
+     */
+    @java.lang.Deprecated
+    public io.grpc.testing.compiler.Test.SimpleResponse deprecatedMethod(io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getDeprecatedMethodMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service TestDeprecatedService.
+   * <pre>
+   * Test service that has been deprecated and should generate with Java's &#64;Deprecated annotation
+   * </pre>
+   */
+  @java.lang.Deprecated
+  public static final class TestDeprecatedServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestDeprecatedServiceFutureStub> {
+    private TestDeprecatedServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestDeprecatedServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestDeprecatedServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * An RPC method that has been deprecated and should generate with Java's &#64;Deprecated annotation
+     * </pre>
+     */
+    @java.lang.Deprecated
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.compiler.Test.SimpleResponse> deprecatedMethod(
+        io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getDeprecatedMethodMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_DEPRECATED_METHOD = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_DEPRECATED_METHOD:
+          serviceImpl.deprecatedMethod((io.grpc.testing.compiler.Test.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getDeprecatedMethodMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.SimpleRequest,
+              io.grpc.testing.compiler.Test.SimpleResponse>(
+                service, METHODID_DEPRECATED_METHOD)))
+        .build();
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (TestDeprecatedServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .addMethod(getDeprecatedMethodMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/compiler/src/testLite/golden/TestService.java.txt b/compiler/src/testLite/golden/TestService.java.txt
index 9be98afa13c..4e9dfb8d682 100644
--- a/compiler/src/testLite/golden/TestService.java.txt
+++ b/compiler/src/testLite/golden/TestService.java.txt
@@ -1,86 +1,289 @@
-package io.grpc.testing.integration;
-
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
+package io.grpc.testing.compiler;
+
 import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
 
 /**
  * <pre>
  * Test service that supports all call types.
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class TestServiceGrpc {
 
   private TestServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.testing.TestService";
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.compiler.TestService";
 
   // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Test.SimpleRequest,
-      io.grpc.testing.integration.Test.SimpleResponse> METHOD_UNARY_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.testing.TestService", "UnaryCall"),
-          io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(io.grpc.testing.integration.Test.SimpleRequest.getDefaultInstance()),
-          io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(io.grpc.testing.integration.Test.SimpleResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Test.StreamingOutputCallRequest,
-      io.grpc.testing.integration.Test.StreamingOutputCallResponse> METHOD_STREAMING_OUTPUT_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "StreamingOutputCall"),
-          io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallRequest.getDefaultInstance()),
-          io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Test.StreamingInputCallRequest,
-      io.grpc.testing.integration.Test.StreamingInputCallResponse> METHOD_STREAMING_INPUT_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "StreamingInputCall"),
-          io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(io.grpc.testing.integration.Test.StreamingInputCallRequest.getDefaultInstance()),
-          io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(io.grpc.testing.integration.Test.StreamingInputCallResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Test.StreamingOutputCallRequest,
-      io.grpc.testing.integration.Test.StreamingOutputCallResponse> METHOD_FULL_BIDI_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "FullBidiCall"),
-          io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallRequest.getDefaultInstance()),
-          io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Test.StreamingOutputCallRequest,
-      io.grpc.testing.integration.Test.StreamingOutputCallResponse> METHOD_HALF_BIDI_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "HalfBidiCall"),
-          io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallRequest.getDefaultInstance()),
-          io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(io.grpc.testing.integration.Test.StreamingOutputCallResponse.getDefaultInstance()));
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getUnaryCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UnaryCall",
+      requestType = io.grpc.testing.compiler.Test.SimpleRequest.class,
+      responseType = io.grpc.testing.compiler.Test.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getUnaryCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse> getUnaryCallMethod;
+    if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) {
+          TestServiceGrpc.getUnaryCallMethod = getUnaryCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnaryCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getUnaryCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getStreamingOutputCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingOutputCall",
+      requestType = io.grpc.testing.compiler.Test.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.compiler.Test.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getStreamingOutputCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getStreamingOutputCallMethod;
+    if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) {
+          TestServiceGrpc.getStreamingOutputCallMethod = getStreamingOutputCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingOutputCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingOutputCallResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getStreamingOutputCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingInputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingInputCallResponse> getStreamingInputCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingInputCall",
+      requestType = io.grpc.testing.compiler.Test.StreamingInputCallRequest.class,
+      responseType = io.grpc.testing.compiler.Test.StreamingInputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingInputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingInputCallResponse> getStreamingInputCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingInputCallRequest, io.grpc.testing.compiler.Test.StreamingInputCallResponse> getStreamingInputCallMethod;
+    if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) {
+          TestServiceGrpc.getStreamingInputCallMethod = getStreamingInputCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.StreamingInputCallRequest, io.grpc.testing.compiler.Test.StreamingInputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingInputCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingInputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingInputCallResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getStreamingInputCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getFullBidiCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "FullBidiCall",
+      requestType = io.grpc.testing.compiler.Test.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.compiler.Test.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getFullBidiCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getFullBidiCallMethod;
+    if ((getFullBidiCallMethod = TestServiceGrpc.getFullBidiCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getFullBidiCallMethod = TestServiceGrpc.getFullBidiCallMethod) == null) {
+          TestServiceGrpc.getFullBidiCallMethod = getFullBidiCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FullBidiCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingOutputCallResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getFullBidiCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getHalfBidiCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "HalfBidiCall",
+      requestType = io.grpc.testing.compiler.Test.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.compiler.Test.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getHalfBidiCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse> getHalfBidiCallMethod;
+    if ((getHalfBidiCallMethod = TestServiceGrpc.getHalfBidiCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getHalfBidiCallMethod = TestServiceGrpc.getHalfBidiCallMethod) == null) {
+          TestServiceGrpc.getHalfBidiCallMethod = getHalfBidiCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "HalfBidiCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingOutputCallResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getHalfBidiCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingInputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingInputCallResponse> getImportMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Import",
+      requestType = io.grpc.testing.compiler.Test.StreamingInputCallRequest.class,
+      responseType = io.grpc.testing.compiler.Test.StreamingInputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingInputCallRequest,
+      io.grpc.testing.compiler.Test.StreamingInputCallResponse> getImportMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.StreamingInputCallRequest, io.grpc.testing.compiler.Test.StreamingInputCallResponse> getImportMethod;
+    if ((getImportMethod = TestServiceGrpc.getImportMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getImportMethod = TestServiceGrpc.getImportMethod) == null) {
+          TestServiceGrpc.getImportMethod = getImportMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.StreamingInputCallRequest, io.grpc.testing.compiler.Test.StreamingInputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Import"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingInputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.StreamingInputCallResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getImportMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getSafeCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "SafeCall",
+      requestType = io.grpc.testing.compiler.Test.SimpleRequest.class,
+      responseType = io.grpc.testing.compiler.Test.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getSafeCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse> getSafeCallMethod;
+    if ((getSafeCallMethod = TestServiceGrpc.getSafeCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getSafeCallMethod = TestServiceGrpc.getSafeCallMethod) == null) {
+          TestServiceGrpc.getSafeCallMethod = getSafeCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SafeCall"))
+              .setSafe(true)
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getSafeCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getIdempotentCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "IdempotentCall",
+      requestType = io.grpc.testing.compiler.Test.SimpleRequest.class,
+      responseType = io.grpc.testing.compiler.Test.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest,
+      io.grpc.testing.compiler.Test.SimpleResponse> getIdempotentCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse> getIdempotentCallMethod;
+    if ((getIdempotentCallMethod = TestServiceGrpc.getIdempotentCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getIdempotentCallMethod = TestServiceGrpc.getIdempotentCallMethod) == null) {
+          TestServiceGrpc.getIdempotentCallMethod = getIdempotentCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.compiler.Test.SimpleRequest, io.grpc.testing.compiler.Test.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "IdempotentCall"))
+              .setIdempotent(true)
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.lite.ProtoLiteUtils.marshaller(
+                  io.grpc.testing.compiler.Test.SimpleResponse.getDefaultInstance()))
+              .build();
+        }
+      }
+    }
+    return getIdempotentCallMethod;
+  }
 
   /**
    * Creates a new async stub that supports all call types for the service
    */
   public static TestServiceStub newStub(io.grpc.Channel channel) {
-    return new TestServiceStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceStub>() {
+        @java.lang.Override
+        public TestServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceStub(channel, callOptions);
+        }
+      };
+    return TestServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static TestServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public TestServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return TestServiceBlockingV2Stub.newStub(factory, channel);
   }
 
   /**
@@ -88,15 +291,29 @@ public final class TestServiceGrpc {
    */
   public static TestServiceBlockingStub newBlockingStub(
       io.grpc.Channel channel) {
-    return new TestServiceBlockingStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingStub>() {
+        @java.lang.Override
+        public TestServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return TestServiceBlockingStub.newStub(factory, channel);
   }
 
   /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
    */
   public static TestServiceFutureStub newFutureStub(
       io.grpc.Channel channel) {
-    return new TestServiceFutureStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceFutureStub>() {
+        @java.lang.Override
+        public TestServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceFutureStub(channel, callOptions);
+        }
+      };
+    return TestServiceFutureStub.newStub(factory, channel);
   }
 
   /**
@@ -104,7 +321,7 @@ public final class TestServiceGrpc {
    * Test service that supports all call types.
    * </pre>
    */
-  public static abstract class TestServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -112,9 +329,9 @@ public final class TestServiceGrpc {
      * The server returns the client payload as-is.
      * </pre>
      */
-    public void unaryCall(io.grpc.testing.integration.Test.SimpleRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.SimpleResponse> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_UNARY_CALL, responseObserver);
+    default void unaryCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnaryCallMethod(), responseObserver);
     }
 
     /**
@@ -123,9 +340,9 @@ public final class TestServiceGrpc {
      * The server returns the payload with client desired type and sizes.
      * </pre>
      */
-    public void streamingOutputCall(io.grpc.testing.integration.Test.StreamingOutputCallRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_STREAMING_OUTPUT_CALL, responseObserver);
+    default void streamingOutputCall(io.grpc.testing.compiler.Test.StreamingOutputCallRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStreamingOutputCallMethod(), responseObserver);
     }
 
     /**
@@ -134,9 +351,9 @@ public final class TestServiceGrpc {
      * The server returns the aggregated size of client payload as the result.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallRequest> streamingInputCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_STREAMING_INPUT_CALL, responseObserver);
+    default io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallRequest> streamingInputCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamingInputCallMethod(), responseObserver);
     }
 
     /**
@@ -146,9 +363,9 @@ public final class TestServiceGrpc {
      * demonstrates the idea of full bidirectionality.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallRequest> fullBidiCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_FULL_BIDI_CALL, responseObserver);
+    default io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallRequest> fullBidiCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getFullBidiCallMethod(), responseObserver);
     }
 
     /**
@@ -159,70 +376,73 @@ public final class TestServiceGrpc {
      * first request.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallRequest> halfBidiCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_HALF_BIDI_CALL, responseObserver);
+    default io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallRequest> halfBidiCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getHalfBidiCallMethod(), responseObserver);
     }
 
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_UNARY_CALL,
-            asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Test.SimpleRequest,
-                io.grpc.testing.integration.Test.SimpleResponse>(
-                  this, METHODID_UNARY_CALL)))
-          .addMethod(
-            METHOD_STREAMING_OUTPUT_CALL,
-            asyncServerStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Test.StreamingOutputCallRequest,
-                io.grpc.testing.integration.Test.StreamingOutputCallResponse>(
-                  this, METHODID_STREAMING_OUTPUT_CALL)))
-          .addMethod(
-            METHOD_STREAMING_INPUT_CALL,
-            asyncClientStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Test.StreamingInputCallRequest,
-                io.grpc.testing.integration.Test.StreamingInputCallResponse>(
-                  this, METHODID_STREAMING_INPUT_CALL)))
-          .addMethod(
-            METHOD_FULL_BIDI_CALL,
-            asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Test.StreamingOutputCallRequest,
-                io.grpc.testing.integration.Test.StreamingOutputCallResponse>(
-                  this, METHODID_FULL_BIDI_CALL)))
-          .addMethod(
-            METHOD_HALF_BIDI_CALL,
-            asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Test.StreamingOutputCallRequest,
-                io.grpc.testing.integration.Test.StreamingOutputCallResponse>(
-                  this, METHODID_HALF_BIDI_CALL)))
-          .build();
+    /**
+     * <pre>
+     * An RPC method whose Java name collides with a keyword, and whose generated
+     * method should have a '_' appended.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallRequest> import_(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getImportMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Safe.
+     * </pre>
+     */
+    default void safeCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSafeCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Idempotent.
+     * </pre>
+     */
+    default void idempotentCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getIdempotentCallMethod(), responseObserver);
     }
   }
 
   /**
+   * Base class for the server implementation of the service TestService.
    * <pre>
    * Test service that supports all call types.
    * </pre>
    */
-  public static final class TestServiceStub extends io.grpc.stub.AbstractStub<TestServiceStub> {
-    private TestServiceStub(io.grpc.Channel channel) {
-      super(channel);
+  public static abstract class TestServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return TestServiceGrpc.bindService(this);
     }
+  }
 
-    private TestServiceStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service TestService.
+   * <pre>
+   * Test service that supports all call types.
+   * </pre>
+   */
+  public static final class TestServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestServiceStub> {
+    private TestServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected TestServiceStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected TestServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new TestServiceStub(channel, callOptions);
     }
 
@@ -232,10 +452,10 @@ public final class TestServiceGrpc {
      * The server returns the client payload as-is.
      * </pre>
      */
-    public void unaryCall(io.grpc.testing.integration.Test.SimpleRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.SimpleResponse> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_UNARY_CALL, getCallOptions()), request, responseObserver);
+    public void unaryCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request, responseObserver);
     }
 
     /**
@@ -244,10 +464,10 @@ public final class TestServiceGrpc {
      * The server returns the payload with client desired type and sizes.
      * </pre>
      */
-    public void streamingOutputCall(io.grpc.testing.integration.Test.StreamingOutputCallRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver) {
-      asyncServerStreamingCall(
-          getChannel().newCall(METHOD_STREAMING_OUTPUT_CALL, getCallOptions()), request, responseObserver);
+    public void streamingOutputCall(io.grpc.testing.compiler.Test.StreamingOutputCallRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getStreamingOutputCallMethod(), getCallOptions()), request, responseObserver);
     }
 
     /**
@@ -256,10 +476,10 @@ public final class TestServiceGrpc {
      * The server returns the aggregated size of client payload as the result.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallRequest> streamingInputCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallResponse> responseObserver) {
-      return asyncClientStreamingCall(
-          getChannel().newCall(METHOD_STREAMING_INPUT_CALL, getCallOptions()), responseObserver);
+    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallRequest> streamingInputCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncClientStreamingCall(
+          getChannel().newCall(getStreamingInputCallMethod(), getCallOptions()), responseObserver);
     }
 
     /**
@@ -269,10 +489,10 @@ public final class TestServiceGrpc {
      * demonstrates the idea of full bidirectionality.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallRequest> fullBidiCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver) {
-      return asyncBidiStreamingCall(
-          getChannel().newCall(METHOD_FULL_BIDI_CALL, getCallOptions()), responseObserver);
+    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallRequest> fullBidiCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getFullBidiCallMethod(), getCallOptions()), responseObserver);
     }
 
     /**
@@ -283,31 +503,182 @@ public final class TestServiceGrpc {
      * first request.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallRequest> halfBidiCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse> responseObserver) {
-      return asyncBidiStreamingCall(
-          getChannel().newCall(METHOD_HALF_BIDI_CALL, getCallOptions()), responseObserver);
+    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallRequest> halfBidiCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getHalfBidiCallMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * An RPC method whose Java name collides with a keyword, and whose generated
+     * method should have a '_' appended.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallRequest> import_(
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getImportMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Safe.
+     * </pre>
+     */
+    public void safeCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getSafeCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Idempotent.
+     * </pre>
+     */
+    public void idempotentCall(io.grpc.testing.compiler.Test.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getIdempotentCallMethod(), getCallOptions()), request, responseObserver);
     }
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service TestService.
    * <pre>
    * Test service that supports all call types.
    * </pre>
    */
-  public static final class TestServiceBlockingStub extends io.grpc.stub.AbstractStub<TestServiceBlockingStub> {
-    private TestServiceBlockingStub(io.grpc.Channel channel) {
-      super(channel);
+  public static final class TestServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingV2Stub> {
+    private TestServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * The server returns the client payload as-is.
+     * </pre>
+     */
+    public io.grpc.testing.compiler.Test.SimpleResponse unaryCall(io.grpc.testing.compiler.Test.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<?, io.grpc.testing.compiler.Test.StreamingOutputCallResponse>
+        streamingOutputCall(io.grpc.testing.compiler.Test.StreamingOutputCallRequest request) {
+      return io.grpc.stub.ClientCalls.blockingV2ServerStreamingCall(
+          getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.compiler.Test.StreamingInputCallRequest, io.grpc.testing.compiler.Test.StreamingInputCallResponse>
+        streamingInputCall() {
+      return io.grpc.stub.ClientCalls.blockingClientStreamingCall(
+          getChannel(), getStreamingInputCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full bidirectionality.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse>
+        fullBidiCall() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getFullBidiCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.compiler.Test.StreamingOutputCallRequest, io.grpc.testing.compiler.Test.StreamingOutputCallResponse>
+        halfBidiCall() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getHalfBidiCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * An RPC method whose Java name collides with a keyword, and whose generated
+     * method should have a '_' appended.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.compiler.Test.StreamingInputCallRequest, io.grpc.testing.compiler.Test.StreamingInputCallResponse>
+        import_() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getImportMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Safe.
+     * </pre>
+     */
+    public io.grpc.testing.compiler.Test.SimpleResponse safeCall(io.grpc.testing.compiler.Test.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getSafeCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Idempotent.
+     * </pre>
+     */
+    public io.grpc.testing.compiler.Test.SimpleResponse idempotentCall(io.grpc.testing.compiler.Test.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getIdempotentCallMethod(), getCallOptions(), request);
     }
+  }
 
-    private TestServiceBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service TestService.
+   * <pre>
+   * Test service that supports all call types.
+   * </pre>
+   */
+  public static final class TestServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingStub> {
+    private TestServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected TestServiceBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected TestServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new TestServiceBlockingStub(channel, callOptions);
     }
 
@@ -317,9 +688,9 @@ public final class TestServiceGrpc {
      * The server returns the client payload as-is.
      * </pre>
      */
-    public io.grpc.testing.integration.Test.SimpleResponse unaryCall(io.grpc.testing.integration.Test.SimpleRequest request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_UNARY_CALL, getCallOptions(), request);
+    public io.grpc.testing.compiler.Test.SimpleResponse unaryCall(io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUnaryCallMethod(), getCallOptions(), request);
     }
 
     /**
@@ -328,31 +699,49 @@ public final class TestServiceGrpc {
      * The server returns the payload with client desired type and sizes.
      * </pre>
      */
-    public java.util.Iterator<io.grpc.testing.integration.Test.StreamingOutputCallResponse> streamingOutputCall(
-        io.grpc.testing.integration.Test.StreamingOutputCallRequest request) {
-      return blockingServerStreamingCall(
-          getChannel(), METHOD_STREAMING_OUTPUT_CALL, getCallOptions(), request);
+    public java.util.Iterator<io.grpc.testing.compiler.Test.StreamingOutputCallResponse> streamingOutputCall(
+        io.grpc.testing.compiler.Test.StreamingOutputCallRequest request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Safe.
+     * </pre>
+     */
+    public io.grpc.testing.compiler.Test.SimpleResponse safeCall(io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getSafeCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Idempotent.
+     * </pre>
+     */
+    public io.grpc.testing.compiler.Test.SimpleResponse idempotentCall(io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getIdempotentCallMethod(), getCallOptions(), request);
     }
   }
 
   /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service TestService.
    * <pre>
    * Test service that supports all call types.
    * </pre>
    */
-  public static final class TestServiceFutureStub extends io.grpc.stub.AbstractStub<TestServiceFutureStub> {
-    private TestServiceFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private TestServiceFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class TestServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestServiceFutureStub> {
+    private TestServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected TestServiceFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected TestServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new TestServiceFutureStub(channel, callOptions);
     }
 
@@ -362,28 +751,53 @@ public final class TestServiceGrpc {
      * The server returns the client payload as-is.
      * </pre>
      */
-    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Test.SimpleResponse> unaryCall(
-        io.grpc.testing.integration.Test.SimpleRequest request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_UNARY_CALL, getCallOptions()), request);
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.compiler.Test.SimpleResponse> unaryCall(
+        io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Safe.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.compiler.Test.SimpleResponse> safeCall(
+        io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getSafeCallMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * A unary call that is Idempotent.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.compiler.Test.SimpleResponse> idempotentCall(
+        io.grpc.testing.compiler.Test.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getIdempotentCallMethod(), getCallOptions()), request);
     }
   }
 
   private static final int METHODID_UNARY_CALL = 0;
   private static final int METHODID_STREAMING_OUTPUT_CALL = 1;
-  private static final int METHODID_STREAMING_INPUT_CALL = 2;
-  private static final int METHODID_FULL_BIDI_CALL = 3;
-  private static final int METHODID_HALF_BIDI_CALL = 4;
+  private static final int METHODID_SAFE_CALL = 2;
+  private static final int METHODID_IDEMPOTENT_CALL = 3;
+  private static final int METHODID_STREAMING_INPUT_CALL = 4;
+  private static final int METHODID_FULL_BIDI_CALL = 5;
+  private static final int METHODID_HALF_BIDI_CALL = 6;
+  private static final int METHODID_IMPORT = 7;
 
   private static final class MethodHandlers<Req, Resp> implements
       io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final TestServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(TestServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -393,12 +807,20 @@ public final class TestServiceGrpc {
     public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
       switch (methodId) {
         case METHODID_UNARY_CALL:
-          serviceImpl.unaryCall((io.grpc.testing.integration.Test.SimpleRequest) request,
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.SimpleResponse>) responseObserver);
+          serviceImpl.unaryCall((io.grpc.testing.compiler.Test.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse>) responseObserver);
           break;
         case METHODID_STREAMING_OUTPUT_CALL:
-          serviceImpl.streamingOutputCall((io.grpc.testing.integration.Test.StreamingOutputCallRequest) request,
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse>) responseObserver);
+          serviceImpl.streamingOutputCall((io.grpc.testing.compiler.Test.StreamingOutputCallRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse>) responseObserver);
+          break;
+        case METHODID_SAFE_CALL:
+          serviceImpl.safeCall((io.grpc.testing.compiler.Test.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse>) responseObserver);
+          break;
+        case METHODID_IDEMPOTENT_CALL:
+          serviceImpl.idempotentCall((io.grpc.testing.compiler.Test.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.SimpleResponse>) responseObserver);
           break;
         default:
           throw new AssertionError();
@@ -412,19 +834,83 @@ public final class TestServiceGrpc {
       switch (methodId) {
         case METHODID_STREAMING_INPUT_CALL:
           return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamingInputCall(
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingInputCallResponse>) responseObserver);
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallResponse>) responseObserver);
         case METHODID_FULL_BIDI_CALL:
           return (io.grpc.stub.StreamObserver<Req>) serviceImpl.fullBidiCall(
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse>) responseObserver);
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse>) responseObserver);
         case METHODID_HALF_BIDI_CALL:
           return (io.grpc.stub.StreamObserver<Req>) serviceImpl.halfBidiCall(
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Test.StreamingOutputCallResponse>) responseObserver);
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingOutputCallResponse>) responseObserver);
+        case METHODID_IMPORT:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.import_(
+              (io.grpc.stub.StreamObserver<io.grpc.testing.compiler.Test.StreamingInputCallResponse>) responseObserver);
         default:
           throw new AssertionError();
       }
     }
   }
 
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getUnaryCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.SimpleRequest,
+              io.grpc.testing.compiler.Test.SimpleResponse>(
+                service, METHODID_UNARY_CALL)))
+        .addMethod(
+          getStreamingOutputCallMethod(),
+          io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+              io.grpc.testing.compiler.Test.StreamingOutputCallResponse>(
+                service, METHODID_STREAMING_OUTPUT_CALL)))
+        .addMethod(
+          getStreamingInputCallMethod(),
+          io.grpc.stub.ServerCalls.asyncClientStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.StreamingInputCallRequest,
+              io.grpc.testing.compiler.Test.StreamingInputCallResponse>(
+                service, METHODID_STREAMING_INPUT_CALL)))
+        .addMethod(
+          getFullBidiCallMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+              io.grpc.testing.compiler.Test.StreamingOutputCallResponse>(
+                service, METHODID_FULL_BIDI_CALL)))
+        .addMethod(
+          getHalfBidiCallMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.StreamingOutputCallRequest,
+              io.grpc.testing.compiler.Test.StreamingOutputCallResponse>(
+                service, METHODID_HALF_BIDI_CALL)))
+        .addMethod(
+          getImportMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.StreamingInputCallRequest,
+              io.grpc.testing.compiler.Test.StreamingInputCallResponse>(
+                service, METHODID_IMPORT)))
+        .addMethod(
+          getSafeCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.SimpleRequest,
+              io.grpc.testing.compiler.Test.SimpleResponse>(
+                service, METHODID_SAFE_CALL)))
+        .addMethod(
+          getIdempotentCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.compiler.Test.SimpleRequest,
+              io.grpc.testing.compiler.Test.SimpleResponse>(
+                service, METHODID_IDEMPOTENT_CALL)))
+        .build();
+  }
+
   private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
 
   public static io.grpc.ServiceDescriptor getServiceDescriptor() {
@@ -434,11 +920,14 @@ public final class TestServiceGrpc {
         result = serviceDescriptor;
         if (result == null) {
           serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .addMethod(METHOD_UNARY_CALL)
-              .addMethod(METHOD_STREAMING_OUTPUT_CALL)
-              .addMethod(METHOD_STREAMING_INPUT_CALL)
-              .addMethod(METHOD_FULL_BIDI_CALL)
-              .addMethod(METHOD_HALF_BIDI_CALL)
+              .addMethod(getUnaryCallMethod())
+              .addMethod(getStreamingOutputCallMethod())
+              .addMethod(getStreamingInputCallMethod())
+              .addMethod(getFullBidiCallMethod())
+              .addMethod(getHalfBidiCallMethod())
+              .addMethod(getImportMethod())
+              .addMethod(getSafeCallMethod())
+              .addMethod(getIdempotentCallMethod())
               .build();
         }
       }
diff --git a/compiler/src/testNano/golden/TestService.java.txt b/compiler/src/testNano/golden/TestService.java.txt
deleted file mode 100644
index 8e0d37a4973..00000000000
--- a/compiler/src/testNano/golden/TestService.java.txt
+++ /dev/null
@@ -1,526 +0,0 @@
-package io.grpc.testing.integration.nano;
-
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
-
-import java.io.IOException;
-
-/**
- * <pre>
- * Test service that supports all call types.
- * </pre>
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: test.proto")
-public final class TestServiceGrpc {
-
-  private TestServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "grpc.testing.TestService";
-
-  // Static method descriptors that strictly reflect the proto.
-  private static final int ARG_IN_METHOD_UNARY_CALL = 0;
-  private static final int ARG_OUT_METHOD_UNARY_CALL = 1;
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.nano.Test.SimpleRequest,
-      io.grpc.testing.integration.nano.Test.SimpleResponse> METHOD_UNARY_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.testing.TestService", "UnaryCall"),
-          io.grpc.protobuf.nano.NanoUtils.<io.grpc.testing.integration.nano.Test.SimpleRequest>marshaller(
-              new NanoFactory<io.grpc.testing.integration.nano.Test.SimpleRequest>(ARG_IN_METHOD_UNARY_CALL)),
-          io.grpc.protobuf.nano.NanoUtils.<io.grpc.testing.integration.nano.Test.SimpleResponse>marshaller(
-              new NanoFactory<io.grpc.testing.integration.nano.Test.SimpleResponse>(ARG_OUT_METHOD_UNARY_CALL))
-          );
-  private static final int ARG_IN_METHOD_STREAMING_OUTPUT_CALL = 2;
-  private static final int ARG_OUT_METHOD_STREAMING_OUTPUT_CALL = 3;
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest,
-      io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> METHOD_STREAMING_OUTPUT_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "StreamingOutputCall"),
-          io.grpc.protobuf.nano.NanoUtils.<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest>marshaller(
-              new NanoFactory<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest>(ARG_IN_METHOD_STREAMING_OUTPUT_CALL)),
-          io.grpc.protobuf.nano.NanoUtils.<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse>marshaller(
-              new NanoFactory<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse>(ARG_OUT_METHOD_STREAMING_OUTPUT_CALL))
-          );
-  private static final int ARG_IN_METHOD_STREAMING_INPUT_CALL = 4;
-  private static final int ARG_OUT_METHOD_STREAMING_INPUT_CALL = 5;
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.nano.Test.StreamingInputCallRequest,
-      io.grpc.testing.integration.nano.Test.StreamingInputCallResponse> METHOD_STREAMING_INPUT_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "StreamingInputCall"),
-          io.grpc.protobuf.nano.NanoUtils.<io.grpc.testing.integration.nano.Test.StreamingInputCallRequest>marshaller(
-              new NanoFactory<io.grpc.testing.integration.nano.Test.StreamingInputCallRequest>(ARG_IN_METHOD_STREAMING_INPUT_CALL)),
-          io.grpc.protobuf.nano.NanoUtils.<io.grpc.testing.integration.nano.Test.StreamingInputCallResponse>marshaller(
-              new NanoFactory<io.grpc.testing.integration.nano.Test.StreamingInputCallResponse>(ARG_OUT_METHOD_STREAMING_INPUT_CALL))
-          );
-  private static final int ARG_IN_METHOD_FULL_BIDI_CALL = 6;
-  private static final int ARG_OUT_METHOD_FULL_BIDI_CALL = 7;
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest,
-      io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> METHOD_FULL_BIDI_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "FullBidiCall"),
-          io.grpc.protobuf.nano.NanoUtils.<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest>marshaller(
-              new NanoFactory<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest>(ARG_IN_METHOD_FULL_BIDI_CALL)),
-          io.grpc.protobuf.nano.NanoUtils.<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse>marshaller(
-              new NanoFactory<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse>(ARG_OUT_METHOD_FULL_BIDI_CALL))
-          );
-  private static final int ARG_IN_METHOD_HALF_BIDI_CALL = 8;
-  private static final int ARG_OUT_METHOD_HALF_BIDI_CALL = 9;
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest,
-      io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> METHOD_HALF_BIDI_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "HalfBidiCall"),
-          io.grpc.protobuf.nano.NanoUtils.<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest>marshaller(
-              new NanoFactory<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest>(ARG_IN_METHOD_HALF_BIDI_CALL)),
-          io.grpc.protobuf.nano.NanoUtils.<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse>marshaller(
-              new NanoFactory<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse>(ARG_OUT_METHOD_HALF_BIDI_CALL))
-          );
-
-  private static final class NanoFactory<T extends com.google.protobuf.nano.MessageNano>
-      implements io.grpc.protobuf.nano.MessageNanoFactory<T> {
-    private final int id;
-
-    NanoFactory(int id) {
-      this.id = id;
-    }
-
-    @java.lang.Override
-    public T newInstance() {
-      Object o;
-      switch (id) {
-      case ARG_IN_METHOD_UNARY_CALL:
-        o = new io.grpc.testing.integration.nano.Test.SimpleRequest();
-        break;
-      case ARG_OUT_METHOD_UNARY_CALL:
-        o = new io.grpc.testing.integration.nano.Test.SimpleResponse();
-        break;
-      case ARG_IN_METHOD_STREAMING_OUTPUT_CALL:
-        o = new io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest();
-        break;
-      case ARG_OUT_METHOD_STREAMING_OUTPUT_CALL:
-        o = new io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse();
-        break;
-      case ARG_IN_METHOD_STREAMING_INPUT_CALL:
-        o = new io.grpc.testing.integration.nano.Test.StreamingInputCallRequest();
-        break;
-      case ARG_OUT_METHOD_STREAMING_INPUT_CALL:
-        o = new io.grpc.testing.integration.nano.Test.StreamingInputCallResponse();
-        break;
-      case ARG_IN_METHOD_FULL_BIDI_CALL:
-        o = new io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest();
-        break;
-      case ARG_OUT_METHOD_FULL_BIDI_CALL:
-        o = new io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse();
-        break;
-      case ARG_IN_METHOD_HALF_BIDI_CALL:
-        o = new io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest();
-        break;
-      case ARG_OUT_METHOD_HALF_BIDI_CALL:
-        o = new io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse();
-        break;
-      default:
-        throw new AssertionError();
-      }
-      @java.lang.SuppressWarnings("unchecked")
-      T t = (T) o;
-      return t;
-    }
-  }
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static TestServiceStub newStub(io.grpc.Channel channel) {
-    return new TestServiceStub(channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static TestServiceBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    return new TestServiceBlockingStub(channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
-   */
-  public static TestServiceFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    return new TestServiceFutureStub(channel);
-  }
-
-  /**
-   * <pre>
-   * Test service that supports all call types.
-   * </pre>
-   */
-  public static abstract class TestServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     * <pre>
-     * One request followed by one response.
-     * The server returns the client payload as-is.
-     * </pre>
-     */
-    public void unaryCall(io.grpc.testing.integration.nano.Test.SimpleRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.SimpleResponse> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_UNARY_CALL, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * One request followed by a sequence of responses (streamed download).
-     * The server returns the payload with client desired type and sizes.
-     * </pre>
-     */
-    public void streamingOutputCall(io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_STREAMING_OUTPUT_CALL, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * A sequence of requests followed by one response (streamed upload).
-     * The server returns the aggregated size of client payload as the result.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingInputCallRequest> streamingInputCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingInputCallResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_STREAMING_INPUT_CALL, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * A sequence of requests with each request served by the server immediately.
-     * As one request could lead to multiple responses, this interface
-     * demonstrates the idea of full bidirectionality.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest> fullBidiCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_FULL_BIDI_CALL, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * A sequence of requests followed by a sequence of responses.
-     * The server buffers all the client requests and then serves them in order. A
-     * stream of responses are returned to the client when the server starts with
-     * first request.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest> halfBidiCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_HALF_BIDI_CALL, responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_UNARY_CALL,
-            asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.nano.Test.SimpleRequest,
-                io.grpc.testing.integration.nano.Test.SimpleResponse>(
-                  this, METHODID_UNARY_CALL)))
-          .addMethod(
-            METHOD_STREAMING_OUTPUT_CALL,
-            asyncServerStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest,
-                io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse>(
-                  this, METHODID_STREAMING_OUTPUT_CALL)))
-          .addMethod(
-            METHOD_STREAMING_INPUT_CALL,
-            asyncClientStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.nano.Test.StreamingInputCallRequest,
-                io.grpc.testing.integration.nano.Test.StreamingInputCallResponse>(
-                  this, METHODID_STREAMING_INPUT_CALL)))
-          .addMethod(
-            METHOD_FULL_BIDI_CALL,
-            asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest,
-                io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse>(
-                  this, METHODID_FULL_BIDI_CALL)))
-          .addMethod(
-            METHOD_HALF_BIDI_CALL,
-            asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest,
-                io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse>(
-                  this, METHODID_HALF_BIDI_CALL)))
-          .build();
-    }
-  }
-
-  /**
-   * <pre>
-   * Test service that supports all call types.
-   * </pre>
-   */
-  public static final class TestServiceStub extends io.grpc.stub.AbstractStub<TestServiceStub> {
-    private TestServiceStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private TestServiceStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected TestServiceStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new TestServiceStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * One request followed by one response.
-     * The server returns the client payload as-is.
-     * </pre>
-     */
-    public void unaryCall(io.grpc.testing.integration.nano.Test.SimpleRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.SimpleResponse> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_UNARY_CALL, getCallOptions()), request, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * One request followed by a sequence of responses (streamed download).
-     * The server returns the payload with client desired type and sizes.
-     * </pre>
-     */
-    public void streamingOutputCall(io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> responseObserver) {
-      asyncServerStreamingCall(
-          getChannel().newCall(METHOD_STREAMING_OUTPUT_CALL, getCallOptions()), request, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * A sequence of requests followed by one response (streamed upload).
-     * The server returns the aggregated size of client payload as the result.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingInputCallRequest> streamingInputCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingInputCallResponse> responseObserver) {
-      return asyncClientStreamingCall(
-          getChannel().newCall(METHOD_STREAMING_INPUT_CALL, getCallOptions()), responseObserver);
-    }
-
-    /**
-     * <pre>
-     * A sequence of requests with each request served by the server immediately.
-     * As one request could lead to multiple responses, this interface
-     * demonstrates the idea of full bidirectionality.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest> fullBidiCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> responseObserver) {
-      return asyncBidiStreamingCall(
-          getChannel().newCall(METHOD_FULL_BIDI_CALL, getCallOptions()), responseObserver);
-    }
-
-    /**
-     * <pre>
-     * A sequence of requests followed by a sequence of responses.
-     * The server buffers all the client requests and then serves them in order. A
-     * stream of responses are returned to the client when the server starts with
-     * first request.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest> halfBidiCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> responseObserver) {
-      return asyncBidiStreamingCall(
-          getChannel().newCall(METHOD_HALF_BIDI_CALL, getCallOptions()), responseObserver);
-    }
-  }
-
-  /**
-   * <pre>
-   * Test service that supports all call types.
-   * </pre>
-   */
-  public static final class TestServiceBlockingStub extends io.grpc.stub.AbstractStub<TestServiceBlockingStub> {
-    private TestServiceBlockingStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private TestServiceBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected TestServiceBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new TestServiceBlockingStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * One request followed by one response.
-     * The server returns the client payload as-is.
-     * </pre>
-     */
-    public io.grpc.testing.integration.nano.Test.SimpleResponse unaryCall(io.grpc.testing.integration.nano.Test.SimpleRequest request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_UNARY_CALL, getCallOptions(), request);
-    }
-
-    /**
-     * <pre>
-     * One request followed by a sequence of responses (streamed download).
-     * The server returns the payload with client desired type and sizes.
-     * </pre>
-     */
-    public java.util.Iterator<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse> streamingOutputCall(
-        io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest request) {
-      return blockingServerStreamingCall(
-          getChannel(), METHOD_STREAMING_OUTPUT_CALL, getCallOptions(), request);
-    }
-  }
-
-  /**
-   * <pre>
-   * Test service that supports all call types.
-   * </pre>
-   */
-  public static final class TestServiceFutureStub extends io.grpc.stub.AbstractStub<TestServiceFutureStub> {
-    private TestServiceFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private TestServiceFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected TestServiceFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new TestServiceFutureStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * One request followed by one response.
-     * The server returns the client payload as-is.
-     * </pre>
-     */
-    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.nano.Test.SimpleResponse> unaryCall(
-        io.grpc.testing.integration.nano.Test.SimpleRequest request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_UNARY_CALL, getCallOptions()), request);
-    }
-  }
-
-  private static final int METHODID_UNARY_CALL = 0;
-  private static final int METHODID_STREAMING_OUTPUT_CALL = 1;
-  private static final int METHODID_STREAMING_INPUT_CALL = 2;
-  private static final int METHODID_FULL_BIDI_CALL = 3;
-  private static final int METHODID_HALF_BIDI_CALL = 4;
-
-  private static final class MethodHandlers<Req, Resp> implements
-      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final TestServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(TestServiceImplBase serviceImpl, int methodId) {
-      this.serviceImpl = serviceImpl;
-      this.methodId = methodId;
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        case METHODID_UNARY_CALL:
-          serviceImpl.unaryCall((io.grpc.testing.integration.nano.Test.SimpleRequest) request,
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.SimpleResponse>) responseObserver);
-          break;
-        case METHODID_STREAMING_OUTPUT_CALL:
-          serviceImpl.streamingOutputCall((io.grpc.testing.integration.nano.Test.StreamingOutputCallRequest) request,
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse>) responseObserver);
-          break;
-        default:
-          throw new AssertionError();
-      }
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public io.grpc.stub.StreamObserver<Req> invoke(
-        io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        case METHODID_STREAMING_INPUT_CALL:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamingInputCall(
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingInputCallResponse>) responseObserver);
-        case METHODID_FULL_BIDI_CALL:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.fullBidiCall(
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse>) responseObserver);
-        case METHODID_HALF_BIDI_CALL:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.halfBidiCall(
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.nano.Test.StreamingOutputCallResponse>) responseObserver);
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
-
-  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
-    io.grpc.ServiceDescriptor result = serviceDescriptor;
-    if (result == null) {
-      synchronized (TestServiceGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .addMethod(METHOD_UNARY_CALL)
-              .addMethod(METHOD_STREAMING_OUTPUT_CALL)
-              .addMethod(METHOD_STREAMING_INPUT_CALL)
-              .addMethod(METHOD_FULL_BIDI_CALL)
-              .addMethod(METHOD_HALF_BIDI_CALL)
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/context/BUILD.bazel b/context/BUILD.bazel
new file mode 100644
index 00000000000..0a51dca24a9
--- /dev/null
+++ b/context/BUILD.bazel
@@ -0,0 +1,7 @@
+load("@rules_java//java:defs.bzl", "java_library")
+
+java_library(
+    name = "context",
+    visibility = ["//visibility:public"],
+    exports = ["//api"],
+)
diff --git a/context/build.gradle b/context/build.gradle
index 3532760a373..46d3d852f43 100644
--- a/context/build.gradle
+++ b/context/build.gradle
@@ -1,6 +1,14 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+}
+
 description = 'gRPC: Context'
 
 dependencies {
-    testCompile project(':grpc-testing')
-    signature "org.codehaus.mojo.signature:java16:+@signature"
+    runtimeOnly (project(":grpc-api")) {
+        exclude group: "com.google.guava", module: "guava"
+        exclude group: "com.google.code.findbugs", module: "jsr305"
+        exclude group: "com.google.errorprone", module: "error_prone_annotations"
+    }
 }
diff --git a/context/src/main/java/io/grpc/Context.java b/context/src/main/java/io/grpc/Context.java
deleted file mode 100644
index a9bcea6e591..00000000000
--- a/context/src/main/java/io/grpc/Context.java
+++ /dev/null
@@ -1,935 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.util.ArrayList;
-import java.util.concurrent.Callable;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-/**
- * A context propagation mechanism which can carry scoped-values across API boundaries and between
- * threads. Examples of state propagated via context include:
- * <ul>
- *   <li>Security principals and credentials.</li>
- *   <li>Local and distributed tracing information.</li>
- * </ul>
- *
- * <p>A Context object can be {@link #attach attached} to the {@link Storage}, which effectively
- * forms a <b>scope</b> for the context.  The scope is bound to the current thread.  Within a scope,
- * its Context is accessible even across API boundaries, through {@link #current}.  The scope is
- * later exited by {@link #detach detaching} the Context.
- *
- * <p>Context objects are immutable and inherit state from their parent. To add or overwrite the
- * current state a new context object must be created and then attached, replacing the previously
- * bound context. For example:
- *
- * <pre>
- *   Context withCredential = Context.current().withValue(CRED_KEY, cred);
- *   executorService.execute(withCredential.wrap(new Runnable() {
- *     public void run() {
- *        readUserRecords(userId, CRED_KEY.get());
- *     }
- *   }));
- * </pre>
- *
- * <p>Contexts are also used to represent a scoped unit of work. When the unit of work is done the
- * context can be cancelled. This cancellation will also cascade to all descendant contexts. You can
- * add a {@link CancellationListener} to a context to be notified when it or one of its ancestors
- * has been cancelled. Cancellation does not release the state stored by a context and it's
- * perfectly valid to {@link #attach()} an already cancelled context to make it current. To cancel a
- * context (and its descendants) you first create a {@link CancellableContext} and when you need to
- * signal cancellation call {@link CancellableContext#cancel} or {@link
- * CancellableContext#detachAndCancel}. For example:
- * <pre>
- *   CancellableContext withCancellation = Context.current().withCancellation();
- *   try {
- *     executorService.execute(withCancellation.wrap(new Runnable() {
- *       public void run() {
- *         while (waitingForData() &amp;&amp; !Context.current().isCancelled()) {}
- *       }
- *     });
- *     doSomeWork();
- *   } catch (Throwable t) {
- *      withCancellation.cancel(t);
- *   }
- * </pre>
- *
- * <p>Contexts can also be created with a timeout relative to the system nano clock which will
- * cause it to automatically cancel at the desired time.
- *
- *
- * <p>Notes and cautions on use:
- * <ul>
- *    <li>While Context objects are immutable they do not place such a restriction on the state
- * they store.</li>
- *    <li>Context is not intended for passing optional parameters to an API and developers should
- * take care to avoid excessive dependence on context when designing an API.</li>
- *    <li>If Context is being used in an environment that needs to support class unloading it is the
- * responsibility of the application to ensure that all contexts are properly cancelled.</li>
- * </ul>
- */
-public class Context {
-
-  private static final Logger log = Logger.getLogger(Context.class.getName());
-
-  private static final Object[][] EMPTY_ENTRIES = new Object[0][2];
-
-  private static final Key<Deadline> DEADLINE_KEY = new Key<Deadline>("deadline");
-
-  /**
-   * The logical root context which is the ultimate ancestor of all contexts. This context
-   * is not cancellable and so will not cascade cancellation or retain listeners.
-   *
-   * <p>Never assume this is the default context for new threads, because {@link Storage} may define
-   * a default context that is different from ROOT.
-   */
-  public static final Context ROOT = new Context(null);
-
-  // One and only one of them is non-null
-  private static final Storage storage;
-  private static final Exception storageInitError;
-
-  static {
-    Storage newStorage = null;
-    Exception error = null;
-    try {
-      Class<?> clazz = Class.forName("io.grpc.override.ContextStorageOverride");
-      newStorage = (Storage) clazz.getConstructor().newInstance();
-    } catch (ClassNotFoundException e) {
-      if (log.isLoggable(Level.FINE)) {
-        // Avoid writing to logger because custom log handlers may try to use Context, which is
-        // problemantic (e.g., NullPointerException) because the Context class has not done loading
-        // at this point.  The caveat is that in environments stderr may be disabled, thus this
-        // message would go nowhere.
-        System.err.println("io.grpc.Context: Storage override doesn't exist. Using default.");
-        e.printStackTrace();
-      }
-      newStorage = new ThreadLocalContextStorage();
-    } catch (Exception e) {
-      error = e;
-    }
-    storage = newStorage;
-    storageInitError = error;
-  }
-
-  // For testing
-  static Storage storage() {
-    if (storage == null) {
-      throw new RuntimeException("Storage override had failed to initialize", storageInitError);
-    }
-    return storage;
-  }
-
-  /**
-   * Create a {@link Key} with the given debug name. Multiple different keys may have the same name;
-   * the name is intended for debugging purposes and does not impact behavior.
-   */
-  public static <T> Key<T> key(String name) {
-    return new Key<T>(name);
-  }
-
-  /**
-   * Create a {@link Key} with the given debug name and default value. Multiple different keys may
-   * have the same name; the name is intended for debugging purposes and does not impact behavior.
-   */
-  public static <T> Key<T> keyWithDefault(String name, T defaultValue) {
-    return new Key<T>(name, defaultValue);
-  }
-
-  /**
-   * Return the context associated with the current scope, will never return {@code null}.
-   *
-   * <p>Will never return {@link CancellableContext} even if one is attached, instead a
-   * {@link Context} is returned with the same properties and lifetime. This is to avoid
-   * code stealing the ability to cancel arbitrarily.
-   */
-  public static Context current() {
-    Context current = storage().current();
-    if (current == null) {
-      return ROOT;
-    }
-    return current;
-  }
-
-  private final Context parent;
-  private final Object[][] keyValueEntries;
-  private final boolean cascadesCancellation;
-  private ArrayList<ExecutableListener> listeners;
-  private CancellationListener parentListener = new ParentListener();
-  private final boolean canBeCancelled;
-
-  /**
-   * Construct a context that cannot be cancelled and will not cascade cancellation from its parent.
-   */
-  private Context(Context parent) {
-    this.parent = parent;
-    // Not inheriting cancellation implies not inheriting a deadline too.
-    keyValueEntries = new Object[][]{{DEADLINE_KEY, null}};
-    cascadesCancellation = false;
-    canBeCancelled = false;
-  }
-
-  /**
-   * Construct a context that cannot be cancelled but will cascade cancellation from its parent if
-   * it is cancellable.
-   */
-  private Context(Context parent, Object[][] keyValueEntries) {
-    this.parent = parent;
-    this.keyValueEntries = keyValueEntries;
-    cascadesCancellation = true;
-    canBeCancelled = this.parent != null && this.parent.canBeCancelled;
-  }
-
-  /**
-   * Construct a context that can be cancelled and will cascade cancellation from its parent if
-   * it is cancellable.
-   */
-  private Context(Context parent, Object[][] keyValueEntries, boolean isCancellable) {
-    this.parent = parent;
-    this.keyValueEntries = keyValueEntries;
-    cascadesCancellation = true;
-    canBeCancelled = isCancellable;
-  }
-
-  /**
-   * Create a new context which is independently cancellable and also cascades cancellation from
-   * its parent. Callers should ensure that either {@link CancellableContext#cancel(Throwable)}
-   * or {@link CancellableContext#detachAndCancel(Context, Throwable)} are called to notify
-   * listeners and release the resources associated with them.
-   *
-   * <p>Sample usage:
-   * <pre>
-   *   Context.CancellableContext withCancellation = Context.current().withCancellation();
-   *   try {
-   *     executorService.execute(withCancellation.wrap(new Runnable() {
-   *       public void run() {
-   *         Context current = Context.current();
-   *         while (!current.isCancelled()) {
-   *           keepWorking();
-   *         }
-   *       }
-   *     });
-   *     doSomethingRelatedWork();
-   *   } catch (Throwable t) {
-   *     withCancellation.cancel(t);
-   *   }
-   * </pre>
-   */
-  public CancellableContext withCancellation() {
-    return new CancellableContext(this);
-  }
-
-  /**
-   * Create a new context which will cancel itself after the given {@code duration} from now.
-   * The returned context will cascade cancellation of its parent. Callers may explicitly cancel
-   * the returned context prior to the deadline just as for {@link #withCancellation()},
-   *
-   * <p>Sample usage:
-   * <pre>
-   *   Context.CancellableContext withDeadline = Context.current().withDeadlineAfter(5,
-   *       TimeUnit.SECONDS, scheduler);
-   *   executorService.execute(withDeadline.wrap(new Runnable() {
-   *     public void run() {
-   *       Context current = Context.current();
-   *       while (!current.isCancelled()) {
-   *         keepWorking();
-   *       }
-   *     }
-   *   });
-   * </pre>
-   */
-  public CancellableContext withDeadlineAfter(long duration, TimeUnit unit,
-                                              ScheduledExecutorService scheduler) {
-    return withDeadline(Deadline.after(duration, unit), scheduler);
-  }
-
-  /**
-   * Create a new context which will cancel itself at the given {@link Deadline}.
-   * The returned context will cascade cancellation of its parent. Callers may explicitly cancel
-   * the returned context prior to the deadline just as for {@link #withCancellation()},
-   *
-   * <p>Sample usage:
-   * <pre>
-   *   Context.CancellableContext withDeadline = Context.current()
-   *      .withDeadline(someReceivedDeadline);
-   *   executorService.execute(withDeadline.wrap(new Runnable() {
-   *     public void run() {
-   *       Context current = Context.current();
-   *       while (!current.isCancelled()) {
-   *         keepWorking();
-   *       }
-   *     }
-   *   });
-   * </pre>
-   */
-  public CancellableContext withDeadline(Deadline deadline,
-      ScheduledExecutorService scheduler) {
-    checkNotNull(deadline, "deadline");
-    checkNotNull(scheduler, "scheduler");
-    return new CancellableContext(this, deadline, scheduler);
-  }
-
-  /**
-   * Create a new context with the given key value set. The new context will cascade cancellation
-   * from its parent.
-   *
-   <pre>
-   *   Context withCredential = Context.current().withValue(CRED_KEY, cred);
-   *   executorService.execute(withCredential.wrap(new Runnable() {
-   *     public void run() {
-   *        readUserRecords(userId, CRED_KEY.get());
-   *     }
-   *   }));
-   * </pre>
-   *
-   */
-  public <V> Context withValue(Key<V> k1, V v1) {
-    return new Context(this, new Object[][]{{k1, v1}});
-  }
-
-  /**
-   * Create a new context with the given key value set. The new context will cascade cancellation
-   * from its parent.
-   */
-  public <V1, V2> Context withValues(Key<V1> k1, V1 v1, Key<V2> k2, V2 v2) {
-    return new Context(this, new Object[][]{{k1, v1}, {k2, v2}});
-  }
-
-  /**
-   * Create a new context with the given key value set. The new context will cascade cancellation
-   * from its parent.
-   */
-  public <V1, V2, V3> Context withValues(Key<V1> k1, V1 v1, Key<V2> k2, V2 v2, Key<V3> k3, V3 v3) {
-    return new Context(this, new Object[][]{{k1, v1}, {k2, v2}, {k3, v3}});
-  }
-
-  /**
-   * Create a new context with the given key value set. The new context will cascade cancellation
-   * from its parent.
-   */
-  public <V1, V2, V3, V4> Context withValues(Key<V1> k1, V1 v1, Key<V2> k2, V2 v2,
-      Key<V3> k3, V3 v3, Key<V4> k4, V4 v4) {
-    return new Context(this, new Object[][]{{k1, v1}, {k2, v2}, {k3, v3}, {k4, v4}});
-  }
-
-  /**
-   * Create a new context which propagates the values of this context but does not cascade its
-   * cancellation.
-   */
-  public Context fork() {
-    return new Context(this);
-  }
-
-  boolean canBeCancelled() {
-    // A context is cancellable if it cascades from its parent and its parent is
-    // cancellable or is itself directly cancellable..
-    return canBeCancelled;
-  }
-
-  /**
-   * Attach this context, thus enter a new scope within which this context is {@link #current}.  The
-   * previously current context is returned. It is allowed to attach contexts where {@link
-   * #isCancelled()} is {@code true}.
-   *
-   * <p>Instead of using {@link #attach()} & {@link #detach(Context)} most use-cases are better
-   * served by using the {@link #run(Runnable)} or {@link #call(java.util.concurrent.Callable)} to
-   * execute work immediately within a context's scope. If work needs to be done in other threads it
-   * is recommended to use the 'wrap' methods or to use a propagating executor.
-   */
-  public Context attach() {
-    Context previous = current();
-    storage().attach(this);
-    return previous;
-  }
-
-  /**
-   * Detach the current context and attach the provided replacement which should be the context of
-   * the outer scope, thus exit the current scope.
-   *
-   * <p>This context should be the same context that was previously {@link #attach attached}.  The
-   * provided replacement should be what was returned by the same {@link #attach attach()} call.  If
-   * an {@code attach()} and a {@code detach()} meet above requirements, they match.
-   *
-   * <p>It is expected that between any pair of matching {@code attach()} and {@code detach()}, all
-   * {@code attach()}es and {@code detach()}es are called in matching pairs.  If this method finds
-   * that this context is not {@link #current current}, either you or some code in-between are not
-   * detaching correctly, and a SEVERE message will be logged but the context to attach will still
-   * be bound.  <strong>Never</strong> use {@code Context.current().detach()}, as this will
-   * compromise this error-detecting mechanism.
-   */
-  public void detach(Context toAttach) {
-    checkNotNull(toAttach, "toAttach");
-    storage().detach(this, toAttach);
-  }
-
-  // Visible for testing
-  boolean isCurrent() {
-    return current() == this;
-  }
-
-  /**
-   * Is this context cancelled.
-   */
-  public boolean isCancelled() {
-    if (parent == null || !cascadesCancellation) {
-      return false;
-    } else {
-      return parent.isCancelled();
-    }
-  }
-
-  /**
-   * If a context {@link #isCancelled()} then return the cause of the cancellation or
-   * {@code null} if context was cancelled without a cause. If the context is not yet cancelled
-   * will always return {@code null}.
-   *
-   * <p>The cancellation cause is provided for informational purposes only and implementations
-   * should generally assume that it has already been handled and logged properly.
-   */
-  public Throwable cancellationCause() {
-    if (parent == null || !cascadesCancellation) {
-      return null;
-    } else {
-      return parent.cancellationCause();
-    }
-  }
-
-  /**
-   * A context may have an associated {@link Deadline} at which it will be automatically cancelled.
-   * @return A {@link io.grpc.Deadline} or {@code null} if no deadline is set.
-   */
-  public Deadline getDeadline() {
-    return DEADLINE_KEY.get(this);
-  }
-
-  /**
-   * Add a listener that will be notified when the context becomes cancelled.
-   */
-  public void addListener(final CancellationListener cancellationListener,
-                          final Executor executor) {
-    checkNotNull(cancellationListener, "cancellationListener");
-    checkNotNull(executor, "executor");
-    if (canBeCancelled) {
-      ExecutableListener executableListener =
-          new ExecutableListener(executor, cancellationListener);
-      synchronized (this) {
-        if (isCancelled()) {
-          executableListener.deliver();
-        } else {
-          if (listeners == null) {
-            // Now that we have a listener we need to listen to our parent so
-            // we can cascade listener notification.
-            listeners = new ArrayList<ExecutableListener>();
-            listeners.add(executableListener);
-            parent.addListener(parentListener, DirectExecutor.INSTANCE);
-          } else {
-            listeners.add(executableListener);
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * Remove a {@link CancellationListener}.
-   */
-  public void removeListener(CancellationListener cancellationListener) {
-    if (!canBeCancelled) {
-      return;
-    }
-    synchronized (this) {
-      if (listeners != null) {
-        for (int i = listeners.size() - 1; i >= 0; i--) {
-          if (listeners.get(i).listener == cancellationListener) {
-            listeners.remove(i);
-            // Just remove the first matching listener, given that we allow duplicate
-            // adds we should allow for duplicates after remove.
-            break;
-          }
-        }
-        // We have no listeners so no need to listen to our parent
-        if (listeners.isEmpty()) {
-          parent.removeListener(parentListener);
-          listeners = null;
-        }
-      }
-    }
-  }
-
-  /**
-   * Notify all listeners that this context has been cancelled and immediately release
-   * any reference to them so that they may be garbage collected.
-   */
-  void notifyAndClearListeners() {
-    if (!canBeCancelled) {
-      return;
-    }
-    ArrayList<ExecutableListener> tmpListeners;
-    synchronized (this) {
-      if (listeners == null) {
-        return;
-      }
-      tmpListeners = listeners;
-      listeners = null;
-    }
-    // Deliver events to non-child context listeners before we notify child contexts. We do this
-    // to cancel higher level units of work before child units. This allows for a better error
-    // handling paradigm where the higher level unit of work knows it is cancelled and so can
-    // ignore errors that bubble up as a result of cancellation of lower level units.
-    for (int i = 0; i < tmpListeners.size(); i++) {
-      if (!(tmpListeners.get(i).listener instanceof ParentListener)) {
-        tmpListeners.get(i).deliver();
-      }
-    }
-    for (int i = 0; i < tmpListeners.size(); i++) {
-      if (tmpListeners.get(i).listener instanceof ParentListener) {
-        tmpListeners.get(i).deliver();
-      }
-    }
-    parent.removeListener(parentListener);
-  }
-
-  // Used in tests to ensure that listeners are defined and released when cancellation cascades.
-  // It's very important to ensure that we do not accidentally retain listeners.
-  int listenerCount() {
-    synchronized (this) {
-      return listeners == null ? 0 : listeners.size();
-    }
-  }
-
-  /**
-   * Immediately run a {@link Runnable} with this context as the {@link #current} context.
-   * @param r {@link Runnable} to run.
-   */
-  public void run(Runnable r) {
-    Context previous = attach();
-    try {
-      r.run();
-    } finally {
-      detach(previous);
-    }
-  }
-
-  /**
-   * Immediately call a {@link Callable} with this context as the {@link #current} context.
-   * @param c {@link Callable} to call.
-   * @return result of call.
-   */
-  public <V> V call(Callable<V> c) throws Exception {
-    Context previous = attach();
-    try {
-      return c.call();
-    } finally {
-      detach(previous);
-    }
-  }
-
-  /**
-   * Wrap a {@link Runnable} so that it executes with this context as the {@link #current} context.
-   */
-  public Runnable wrap(final Runnable r) {
-    return new Runnable() {
-      @Override
-      public void run() {
-        Context previous = attach();
-        try {
-          r.run();
-        } finally {
-          detach(previous);
-        }
-      }
-    };
-  }
-
-  /**
-   * Wrap a {@link Callable} so that it executes with this context as the {@link #current} context.
-   */
-  public <C> Callable<C> wrap(final Callable<C> c) {
-    return new Callable<C>() {
-      @Override
-      public C call() throws Exception {
-        Context previous = attach();
-        try {
-          return c.call();
-        } finally {
-          detach(previous);
-        }
-      }
-    };
-  }
-
-  /**
-   * Wrap an {@link Executor} so that it always executes with this context as the {@link #current}
-   * context. It is generally expected that {@link #currentContextExecutor(Executor)} would be
-   * used more commonly than this method.
-   *
-   * <p>One scenario in which this executor may be useful is when a single thread is sharding work
-   * to multiple threads.
-   *
-   * @see #currentContextExecutor(Executor)
-   */
-  public Executor fixedContextExecutor(final Executor e) {
-    class FixedContextExecutor implements Executor {
-      @Override
-      public void execute(Runnable r) {
-        e.execute(wrap(r));
-      }
-    }
-
-    return new FixedContextExecutor();
-  }
-
-  /**
-   * Create an executor that propagates the {@link #current} context when {@link Executor#execute}
-   * is called as the {@link #current} context of the {@code Runnable} scheduled. <em>Note that this
-   * is a static method.</em>
-   *
-   * @see #fixedContextExecutor(Executor)
-   */
-  public static Executor currentContextExecutor(final Executor e) {
-    class CurrentContextExecutor implements Executor {
-      @Override
-      public void execute(Runnable r) {
-        e.execute(Context.current().wrap(r));
-      }
-    }
-
-    return new CurrentContextExecutor();
-  }
-
-  /**
-   * Lookup the value for a key in the context inheritance chain.
-   */
-  private Object lookup(Key<?> key) {
-    for (int i = 0; i < keyValueEntries.length; i++) {
-      if (key.equals(keyValueEntries[i][0])) {
-        return keyValueEntries[i][1];
-      }
-    }
-    if (parent == null) {
-      return null;
-    }
-    return parent.lookup(key);
-  }
-
-  /**
-   * A context which inherits cancellation from its parent but which can also be independently
-   * cancelled and which will propagate cancellation to its descendants.
-   */
-  public static final class CancellableContext extends Context {
-
-    private boolean cancelled;
-    private Throwable cancellationCause;
-    private final Context uncancellableSurrogate;
-    private ScheduledFuture<?> pendingDeadline;
-
-    /**
-     * If the parent deadline is before the given deadline there is no need to install the value
-     * or listen for its expiration as the parent context will already be listening for it.
-     */
-    private static Object[][] deriveDeadline(Context parent, Deadline deadline) {
-      Deadline parentDeadline = DEADLINE_KEY.get(parent);
-      return parentDeadline == null || deadline.isBefore(parentDeadline)
-          ? new Object[][]{{ DEADLINE_KEY, deadline}} :
-          EMPTY_ENTRIES;
-    }
-
-    /**
-     * Create a cancellable context that does not have a deadline.
-     */
-    private CancellableContext(Context parent) {
-      super(parent, EMPTY_ENTRIES, true);
-      // Create a surrogate that inherits from this to attach so that you cannot retrieve a
-      // cancellable context from Context.current()
-      uncancellableSurrogate = new Context(this, EMPTY_ENTRIES);
-    }
-
-    /**
-     * Create a cancellable context that has a deadline.
-     */
-    private CancellableContext(Context parent, Deadline deadline,
-        ScheduledExecutorService scheduler) {
-      super(parent, deriveDeadline(parent, deadline), true);
-      if (DEADLINE_KEY.get(this) == deadline) {
-        final TimeoutException cause = new TimeoutException("context timed out");
-        if (!deadline.isExpired()) {
-          // The parent deadline was after the new deadline so we need to install a listener
-          // on the new earlier deadline to trigger expiration for this context.
-          pendingDeadline = deadline.runOnExpiration(new Runnable() {
-            @Override
-            public void run() {
-              try {
-                cancel(cause);
-              } catch (Throwable t) {
-                log.log(Level.SEVERE, "Cancel threw an exception, which should not happen", t);
-              }
-            }
-          }, scheduler);
-        } else {
-          // Cancel immediately if the deadline is already expired.
-          cancel(cause);
-        }
-      }
-      uncancellableSurrogate = new Context(this, EMPTY_ENTRIES);
-    }
-
-
-    @Override
-    public Context attach() {
-      return uncancellableSurrogate.attach();
-    }
-
-    @Override
-    public void detach(Context toAttach) {
-      uncancellableSurrogate.detach(toAttach);
-    }
-
-    @Override
-    public boolean isCurrent() {
-      return uncancellableSurrogate.isCurrent();
-    }
-
-    /**
-     * Cancel this context and optionally provide a cause (can be {@code null}) for the
-     * cancellation. This will trigger notification of listeners.
-     *
-     * @return {@code true} if this context cancelled the context and notified listeners,
-     *    {@code false} if the context was already cancelled.
-     */
-    public boolean cancel(Throwable cause) {
-      boolean triggeredCancel = false;
-      synchronized (this) {
-        if (!cancelled) {
-          cancelled = true;
-          if (pendingDeadline != null) {
-            // If we have a scheduled cancellation pending attempt to cancel it.
-            pendingDeadline.cancel(false);
-            pendingDeadline = null;
-          }
-          this.cancellationCause = cause;
-          triggeredCancel = true;
-        }
-      }
-      if (triggeredCancel) {
-        notifyAndClearListeners();
-      }
-      return triggeredCancel;
-    }
-
-    /**
-     * Cancel this context and detach it as the current context.
-     *
-     * @param toAttach context to make current.
-     * @param cause of cancellation, can be {@code null}.
-     */
-    public void detachAndCancel(Context toAttach, Throwable cause) {
-      try {
-        detach(toAttach);
-      } finally {
-        cancel(cause);
-      }
-    }
-
-    @Override
-    public boolean isCancelled() {
-      synchronized (this) {
-        if (cancelled) {
-          return true;
-        }
-      }
-      // Detect cancellation of parent in the case where we have no listeners and
-      // record it.
-      if (super.isCancelled()) {
-        cancel(super.cancellationCause());
-        return true;
-      }
-      return false;
-    }
-
-    @Override
-    public Throwable cancellationCause() {
-      if (isCancelled()) {
-        return cancellationCause;
-      }
-      return null;
-    }
-  }
-
-  /**
-   * A listener notified on context cancellation.
-   */
-  public interface CancellationListener {
-    /**
-     * @param context the newly cancelled context.
-     */
-    public void cancelled(Context context);
-  }
-
-  /**
-   * Key for indexing values stored in a context.
-   */
-  public static class Key<T> {
-
-    private final String name;
-    private final T defaultValue;
-
-    Key(String name) {
-      this(name, null);
-    }
-
-    Key(String name, T defaultValue) {
-      this.name = checkNotNull(name, "name");
-      this.defaultValue = defaultValue;
-    }
-
-    /**
-     * Get the value from the {@link #current()} context for this key.
-     */
-    @SuppressWarnings("unchecked")
-    public T get() {
-      return get(Context.current());
-    }
-
-    /**
-     * Get the value from the specified context for this key.
-     */
-    @SuppressWarnings("unchecked")
-    public T get(Context context) {
-      T value = (T) context.lookup(this);
-      return value == null ? defaultValue : value;
-    }
-
-    @Override
-    public String toString() {
-      return name;
-    }
-  }
-
-  /**
-   * Defines the mechanisms for attaching and detaching the "current" context.
-   *
-   * <p>The default implementation will put the current context in a {@link ThreadLocal}.  If an
-   * alternative implementation named {@code io.grpc.override.ContextStorageOverride} exists in the
-   * classpath, it will be used instead of the default implementation.
-   *
-   * <p>This API is <a href="https://github.com/grpc/grpc-java/issues/2462">experimental</a> and
-   * subject to change.
-   */
-  public abstract static class Storage {
-    /**
-     * Implements {@link io.grpc.Context#attach}.
-     *
-     * @param toAttach the context to be attached
-     */
-    public abstract void attach(Context toAttach);
-
-    /**
-     * Implements {@link io.grpc.Context#detach}
-     *
-     * @param toDetach the context to be detached. Should be, or be equivalent to, the current
-     *        context of the current scope
-     * @param toRestore the context to be the current.  Should be, or be equivalent to, the context
-     *        of the outer scope
-     */
-    public abstract void detach(Context toDetach, Context toRestore);
-
-    /**
-     * Implements {@link io.grpc.Context#current}.  Returns the context of the current scope.
-     */
-    public abstract Context current();
-  }
-
-  /**
-   * Stores listener and executor pair.
-   */
-  private class ExecutableListener implements Runnable {
-    private final Executor executor;
-    private final CancellationListener listener;
-
-    private ExecutableListener(Executor executor, CancellationListener listener) {
-      this.executor = executor;
-      this.listener = listener;
-    }
-
-    private void deliver() {
-      try {
-        executor.execute(this);
-      } catch (Throwable t) {
-        log.log(Level.INFO, "Exception notifying context listener", t);
-      }
-    }
-
-    @Override
-    public void run() {
-      listener.cancelled(Context.this);
-    }
-  }
-
-  private class ParentListener implements CancellationListener {
-    @Override
-    public void cancelled(Context context) {
-      if (Context.this instanceof CancellableContext) {
-        // Record cancellation with its cancellationCause.
-        ((CancellableContext) Context.this).cancel(context.cancellationCause());
-      } else {
-        notifyAndClearListeners();
-      }
-    }
-  }
-
-  private static <T> T checkNotNull(T reference, Object errorMessage) {
-    if (reference == null) {
-      throw new NullPointerException(String.valueOf(errorMessage));
-    }
-    return reference;
-  }
-
-  private enum DirectExecutor implements Executor {
-    INSTANCE;
-
-    @Override
-    public void execute(Runnable command) {
-      command.run();
-    }
-
-    @Override
-    public String toString() {
-      return "Context.DirectExecutor";
-    }
-  }
-}
diff --git a/context/src/main/java/io/grpc/Deadline.java b/context/src/main/java/io/grpc/Deadline.java
deleted file mode 100644
index c3ab53e3291..00000000000
--- a/context/src/main/java/io/grpc/Deadline.java
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-
-/**
- * An absolute deadline in system time.
- */
-public final class Deadline implements Comparable<Deadline> {
-  private static final SystemTicker SYSTEM_TICKER = new SystemTicker();
-  // nanoTime has a range of just under 300 years. Only allow up to 100 years in the past or future
-  // to prevent wraparound as long as process runs for less than ~100 years.
-  private static final long MAX_OFFSET = TimeUnit.DAYS.toNanos(100 * 365);
-  private static final long MIN_OFFSET = -MAX_OFFSET;
-
-  /**
-   * Create a deadline that will expire at the specified offset from the current system clock.
-   * @param duration A non-negative duration.
-   * @param units The time unit for the duration.
-   * @return A new deadline.
-   */
-  public static Deadline after(long duration, TimeUnit units) {
-    return after(duration, units, SYSTEM_TICKER);
-  }
-
-  // For testing
-  static Deadline after(long duration, TimeUnit units, Ticker ticker) {
-    checkNotNull(units, "units");
-    return new Deadline(ticker, units.toNanos(duration), true);
-  }
-
-  private final Ticker ticker;
-  private final long deadlineNanos;
-  private volatile boolean expired;
-
-  private Deadline(Ticker ticker, long offset, boolean baseInstantAlreadyExpired) {
-    this(ticker, ticker.read(), offset, baseInstantAlreadyExpired);
-  }
-
-  private Deadline(Ticker ticker, long baseInstant, long offset,
-      boolean baseInstantAlreadyExpired) {
-    this.ticker = ticker;
-    // Clamp to range [MIN_OFFSET, MAX_OFFSET]
-    offset = Math.min(MAX_OFFSET, Math.max(MIN_OFFSET, offset));
-    deadlineNanos = baseInstant + offset;
-    expired = baseInstantAlreadyExpired && offset <= 0;
-  }
-
-  /**
-   * Has this deadline expired
-   * @return {@code true} if it has, otherwise {@code false}.
-   */
-  public boolean isExpired() {
-    if (!expired) {
-      if (deadlineNanos - ticker.read() <= 0) {
-        expired = true;
-      } else {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  /**
-   * Is {@code this} deadline before another.
-   */
-  public boolean isBefore(Deadline other) {
-    return this.deadlineNanos - other.deadlineNanos < 0;
-  }
-
-  /**
-   * Return the minimum deadline of {@code this} or an other deadline.
-   * @param other deadline to compare with {@code this}.
-   */
-  public Deadline minimum(Deadline other) {
-    return isBefore(other) ? this : other;
-  }
-
-  /**
-   * Create a new deadline that is offset from {@code this}.
-   */
-  // TODO(ejona): This method can cause deadlines to grow too far apart. For example:
-  // Deadline.after(100 * 365, DAYS).offset(100 * 365, DAYS) would be less than
-  // Deadline.after(-100 * 365, DAYS)
-  public Deadline offset(long offset, TimeUnit units) {
-    // May already be expired
-    if (offset == 0) {
-      return this;
-    }
-    return new Deadline(ticker, deadlineNanos, units.toNanos(offset), isExpired());
-  }
-
-  /**
-   * How much time is remaining in the specified time unit. Internal units are maintained as
-   * nanoseconds and conversions are subject to the constraints documented for
-   * {@link TimeUnit#convert}. If there is no time remaining, the returned duration is how
-   * long ago the deadline expired.
-   */
-  public long timeRemaining(TimeUnit unit) {
-    final long nowNanos = ticker.read();
-    if (!expired && deadlineNanos - nowNanos <= 0) {
-      expired = true;
-    }
-    return unit.convert(deadlineNanos - nowNanos, TimeUnit.NANOSECONDS);
-  }
-
-  /**
-   * Schedule a task to be run when the deadline expires.
-   * @param task to run on expiration
-   * @param scheduler used to execute the task
-   * @return {@link ScheduledFuture} which can be used to cancel execution of the task
-   */
-  public ScheduledFuture<?> runOnExpiration(Runnable task, ScheduledExecutorService scheduler) {
-    checkNotNull(task, "task");
-    checkNotNull(scheduler, "scheduler");
-    return scheduler.schedule(task, deadlineNanos - ticker.read(), TimeUnit.NANOSECONDS);
-  }
-
-  @Override
-  public String toString() {
-    return timeRemaining(TimeUnit.NANOSECONDS) + " ns from now";
-  }
-
-  @Override
-  public int compareTo(Deadline that) {
-    long diff = this.deadlineNanos - that.deadlineNanos;
-    if (diff < 0) {
-      return -1;
-    } else if (diff > 0) {
-      return 1;
-    }
-    return 0;
-  }
-
-  /** Time source representing nanoseconds since fixed but arbitrary point in time. */
-  abstract static class Ticker {
-    /** Returns the number of nanoseconds since this source's epoch. */
-    public abstract long read();
-  }
-
-  private static class SystemTicker extends Ticker {
-    @Override
-    public long read() {
-      return System.nanoTime();
-    }
-  }
-
-  private static <T> T checkNotNull(T reference, Object errorMessage) {
-    if (reference == null) {
-      throw new NullPointerException(String.valueOf(errorMessage));
-    }
-    return reference;
-  }
-}
diff --git a/context/src/main/java/io/grpc/ThreadLocalContextStorage.java b/context/src/main/java/io/grpc/ThreadLocalContextStorage.java
deleted file mode 100644
index f04c5849658..00000000000
--- a/context/src/main/java/io/grpc/ThreadLocalContextStorage.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-/**
- * A {@link ThreadLocal}-based context storage implementation.  Used by default.
- */
-final class ThreadLocalContextStorage extends Context.Storage {
-  private static final Logger log = Logger.getLogger(ThreadLocalContextStorage.class.getName());
-
-  /**
-   * Currently bound context.
-   */
-  private static final ThreadLocal<Context> localContext = new ThreadLocal<Context>();
-
-  @Override
-  public void attach(Context toAttach) {
-    localContext.set(toAttach);
-  }
-
-  @Override
-  public void detach(Context toDetach, Context toRestore) {
-    if (current() != toDetach) {
-      // Log a severe message instead of throwing an exception as the context to attach is assumed
-      // to be the correct one and the unbalanced state represents a coding mistake in a lower
-      // layer in the stack that cannot be recovered from here.
-      log.log(Level.SEVERE, "Context was not attached when detaching",
-          new Throwable().fillInStackTrace());
-    }
-    attach(toRestore);
-  }
-
-  @Override
-  public Context current() {
-    return localContext.get();
-  }
-}
diff --git a/context/src/test/java/io/grpc/ContextTest.java b/context/src/test/java/io/grpc/ContextTest.java
deleted file mode 100644
index cd1c405936e..00000000000
--- a/context/src/test/java/io/grpc/ContextTest.java
+++ /dev/null
@@ -1,760 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.hamcrest.core.IsInstanceOf.instanceOf;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-import com.google.common.util.concurrent.MoreExecutors;
-import com.google.common.util.concurrent.SettableFuture;
-import java.util.ArrayDeque;
-import java.util.Queue;
-import java.util.concurrent.Callable;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.Executor;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.logging.Handler;
-import java.util.logging.Level;
-import java.util.logging.LogRecord;
-import java.util.logging.Logger;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Tests for {@link Context}.
- */
-@RunWith(JUnit4.class)
-public class ContextTest {
-
-  private static final Context.Key<String> PET = Context.key("pet");
-  private static final Context.Key<String> FOOD = Context.keyWithDefault("food", "lasagna");
-  private static final Context.Key<String> COLOR = Context.key("color");
-  private static final Context.Key<Object> FAVORITE = Context.key("favorite");
-  private static final Context.Key<Integer> LUCKY = Context.key("lucky");
-
-  private Context listenerNotifedContext;
-  private CountDownLatch deadlineLatch = new CountDownLatch(1);
-  private Context.CancellationListener cancellationListener = new Context.CancellationListener() {
-    @Override
-    public void cancelled(Context context) {
-      listenerNotifedContext = context;
-      deadlineLatch.countDown();
-    }
-  };
-
-  private Context observed;
-  private Runnable runner = new Runnable() {
-    @Override
-    public void run() {
-      observed = Context.current();
-    }
-  };
-  private ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
-
-  @Before
-  public void setUp() throws Exception {
-    Context.ROOT.attach();
-  }
-
-  @After
-  public void tearDown() throws Exception {
-    scheduler.shutdown();
-  }
-
-  @Test
-  public void defaultContext() throws Exception {
-    final SettableFuture<Context> contextOfNewThread = SettableFuture.create();
-    Context contextOfThisThread = Context.ROOT.withValue(PET, "dog");
-    contextOfThisThread.attach();
-    new Thread(new Runnable() {
-      @Override
-      public void run() {
-        contextOfNewThread.set(Context.current());
-      }
-      }).start();
-    assertNotNull(contextOfNewThread.get(5, TimeUnit.SECONDS));
-    assertNotSame(contextOfThisThread, contextOfNewThread.get());
-    assertSame(contextOfThisThread, Context.current());
-  }
-
-  @Test
-  public void rootCanBeAttached() {
-    Context fork = Context.ROOT.fork();
-    fork.attach();
-    Context.ROOT.attach();
-    assertTrue(Context.ROOT.isCurrent());
-    fork.attach();
-    assertTrue(fork.isCurrent());
-  }
-
-  @Test
-  public void rootCanNeverHaveAListener() {
-    Context root = Context.current();
-    root.addListener(cancellationListener, MoreExecutors.directExecutor());
-    assertEquals(0, root.listenerCount());
-  }
-
-  @Test
-  public void rootIsNotCancelled() {
-    assertFalse(Context.ROOT.isCancelled());
-    assertNull(Context.ROOT.cancellationCause());
-  }
-
-  @Test
-  public void attachedCancellableContextCannotBeCastFromCurrent() {
-    Context initial = Context.current();
-    Context.CancellableContext base = initial.withCancellation();
-    base.attach();
-    assertFalse(Context.current() instanceof Context.CancellableContext);
-    assertNotSame(base, Context.current());
-    assertNotSame(initial, Context.current());
-    base.detachAndCancel(initial, null);
-    assertSame(initial, Context.current());
-  }
-
-  @Test
-  public void attachingNonCurrentReturnsCurrent() {
-    Context initial = Context.current();
-    Context base = initial.withValue(PET, "dog");
-    assertSame(initial, base.attach());
-    assertSame(base, initial.attach());
-  }
-
-  @Test
-  public void detachingNonCurrentLogsSevereMessage() {
-    final AtomicReference<LogRecord> logRef = new AtomicReference<LogRecord>();
-    Handler handler = new Handler() {
-      @Override
-      public void publish(LogRecord record) {
-        logRef.set(record);
-      }
-
-      @Override
-      public void flush() {
-      }
-
-      @Override
-      public void close() throws SecurityException {
-      }
-    };
-    Logger logger = Logger.getLogger(Context.storage().getClass().getName());
-    try {
-      logger.addHandler(handler);
-      Context initial = Context.current();
-      Context base = initial.withValue(PET, "dog");
-      // Base is not attached
-      base.detach(initial);
-      assertSame(initial, Context.current());
-      assertNotNull(logRef.get());
-      assertEquals(Level.SEVERE, logRef.get().getLevel());
-    } finally {
-      logger.removeHandler(handler);
-    }
-  }
-
-  @Test
-  public void valuesAndOverrides() {
-    Context base = Context.current().withValue(PET, "dog");
-    Context child = base.withValues(PET, null, FOOD, "cheese");
-
-    base.attach();
-
-    assertEquals("dog", PET.get());
-    assertEquals("lasagna", FOOD.get());
-    assertNull(COLOR.get());
-
-    child.attach();
-
-    assertNull(PET.get());
-    assertEquals("cheese", FOOD.get());
-    assertNull(COLOR.get());
-
-    child.detach(base);
-
-    // Should have values from base
-    assertEquals("dog", PET.get());
-    assertEquals("lasagna", FOOD.get());
-    assertNull(COLOR.get());
-
-    base.detach(Context.ROOT);
-
-    assertNull(PET.get());
-    assertEquals("lasagna", FOOD.get());
-    assertNull(COLOR.get());
-  }
-
-  @Test
-  public void withValuesThree() {
-    Object fav = new Object();
-    Context base = Context.current().withValues(PET, "dog", COLOR, "blue");
-    Context child = base.withValues(PET, "cat", FOOD, "cheese", FAVORITE, fav);
-
-    child.attach();
-
-    assertEquals("cat", PET.get());
-    assertEquals("cheese", FOOD.get());
-    assertEquals("blue", COLOR.get());
-    assertEquals(fav, FAVORITE.get());
-
-    base.attach();
-  }
-
-  @Test
-  public void withValuesFour() {
-    Object fav = new Object();
-    Context base = Context.current().withValues(PET, "dog", COLOR, "blue");
-    Context child = base.withValues(PET, "cat", FOOD, "cheese", FAVORITE, fav, LUCKY, 7);
-
-    child.attach();
-
-    assertEquals("cat", PET.get());
-    assertEquals("cheese", FOOD.get());
-    assertEquals("blue", COLOR.get());
-    assertEquals(fav, FAVORITE.get());
-    assertEquals(7, (int) LUCKY.get());
-
-    base.attach();
-  }
-
-  @Test
-  public void cancelReturnsFalseIfAlreadyCancelled() {
-    Context.CancellableContext base = Context.current().withCancellation();
-    assertTrue(base.cancel(null));
-    assertTrue(base.isCancelled());
-    assertFalse(base.cancel(null));
-  }
-
-  @Test
-  public void notifyListenersOnCancel() {
-    class SetContextCancellationListener implements Context.CancellationListener {
-      private final AtomicReference<Context> observed;
-
-      public SetContextCancellationListener(AtomicReference<Context> observed) {
-        this.observed = observed;
-      }
-
-      @Override
-      public void cancelled(Context context) {
-        observed.set(context);
-      }
-    }
-
-    Context.CancellableContext base = Context.current().withCancellation();
-    final AtomicReference<Context> observed1 = new AtomicReference<Context>();
-    base.addListener(new SetContextCancellationListener(observed1), MoreExecutors.directExecutor());
-    final AtomicReference<Context> observed2 = new AtomicReference<Context>();
-    base.addListener(new SetContextCancellationListener(observed2), MoreExecutors.directExecutor());
-    assertNull(observed1.get());
-    assertNull(observed2.get());
-    base.cancel(null);
-    assertSame(base, observed1.get());
-    assertSame(base, observed2.get());
-
-    final AtomicReference<Context> observed3 = new AtomicReference<Context>();
-    base.addListener(new SetContextCancellationListener(observed3), MoreExecutors.directExecutor());
-    assertSame(base, observed3.get());
-  }
-
-  @Test
-  public void exceptionOfExecutorDoesntThrow() {
-    final AtomicReference<Throwable> loggedThrowable = new AtomicReference<Throwable>();
-    Handler logHandler = new Handler() {
-      @Override
-      public void publish(LogRecord record) {
-        Throwable thrown = record.getThrown();
-        if (thrown != null) {
-          if (loggedThrowable.get() == null) {
-            loggedThrowable.set(thrown);
-          } else {
-            loggedThrowable.set(new RuntimeException("Too many exceptions", thrown));
-          }
-        }
-      }
-
-      @Override
-      public void close() {}
-
-      @Override
-      public void flush() {}
-    };
-    Logger logger = Logger.getLogger(Context.class.getName());
-    logger.addHandler(logHandler);
-    try {
-      Context.CancellableContext base = Context.current().withCancellation();
-      final AtomicReference<Runnable> observed1 = new AtomicReference<Runnable>();
-      final Error err = new Error();
-      base.addListener(cancellationListener, new Executor() {
-        @Override
-        public void execute(Runnable runnable) {
-          observed1.set(runnable);
-          throw err;
-        }
-      });
-      assertNull(observed1.get());
-      assertNull(loggedThrowable.get());
-      base.cancel(null);
-      assertNotNull(observed1.get());
-      assertSame(err, loggedThrowable.get());
-
-      final Error err2 = new Error();
-      loggedThrowable.set(null);
-      final AtomicReference<Runnable> observed2 = new AtomicReference<Runnable>();
-      base.addListener(cancellationListener, new Executor() {
-        @Override
-        public void execute(Runnable runnable) {
-          observed2.set(runnable);
-          throw err2;
-        }
-      });
-      assertNotNull(observed2.get());
-      assertSame(err2, loggedThrowable.get());
-    } finally {
-      logger.removeHandler(logHandler);
-    }
-  }
-
-  @Test
-  public void cascadingCancellationNotifiesChild() {
-    // Root is not cancellable so we can't cascade from it
-    Context.CancellableContext base = Context.current().withCancellation();
-    assertEquals(0, base.listenerCount());
-    Context child = base.withValue(FOOD, "lasagna");
-    assertEquals(0, child.listenerCount());
-    child.addListener(cancellationListener, MoreExecutors.directExecutor());
-    assertEquals(1, child.listenerCount());
-    assertEquals(1, base.listenerCount()); // child is now listening to base
-    assertFalse(base.isCancelled());
-    assertFalse(child.isCancelled());
-    IllegalStateException cause = new IllegalStateException();
-    base.cancel(cause);
-    assertTrue(base.isCancelled());
-    assertSame(cause, base.cancellationCause());
-    assertSame(child, listenerNotifedContext);
-    assertTrue(child.isCancelled());
-    assertSame(cause, child.cancellationCause());
-    assertEquals(0, base.listenerCount());
-    assertEquals(0, child.listenerCount());
-  }
-
-  @Test
-  public void cascadingCancellationWithoutListener() {
-    Context.CancellableContext base = Context.current().withCancellation();
-    Context child = base.withCancellation();
-    Throwable t = new Throwable();
-    base.cancel(t);
-    assertTrue(child.isCancelled());
-    assertSame(t, child.cancellationCause());
-  }
-
-  @Test
-  public void cancellableContextIsAttached() {
-    Context.CancellableContext base = Context.current().withValue(FOOD, "fish").withCancellation();
-    assertFalse(base.isCurrent());
-    base.attach();
-
-    Context attached = Context.current();
-    assertSame("fish", FOOD.get());
-    assertFalse(attached.isCancelled());
-    assertNull(attached.cancellationCause());
-    assertTrue(attached.canBeCancelled());
-    assertTrue(attached.isCurrent());
-    assertTrue(base.isCurrent());
-
-    attached.addListener(cancellationListener, MoreExecutors.directExecutor());
-    Throwable t = new Throwable();
-    base.cancel(t);
-    assertTrue(attached.isCancelled());
-    assertSame(t, attached.cancellationCause());
-    assertSame(attached, listenerNotifedContext);
-
-    Context.ROOT.attach();
-  }
-
-  @Test
-  public void cancellableContextCascadesFromCancellableParent() {
-    // Root is not cancellable so we can't cascade from it
-    Context.CancellableContext base = Context.current().withCancellation();
-    Context child = base.withCancellation();
-    child.addListener(cancellationListener, MoreExecutors.directExecutor());
-    assertFalse(base.isCancelled());
-    assertFalse(child.isCancelled());
-    IllegalStateException cause = new IllegalStateException();
-    base.cancel(cause);
-    assertTrue(base.isCancelled());
-    assertSame(cause, base.cancellationCause());
-    assertSame(child, listenerNotifedContext);
-    assertTrue(child.isCancelled());
-    assertSame(cause, child.cancellationCause());
-    assertEquals(0, base.listenerCount());
-    assertEquals(0, child.listenerCount());
-  }
-
-  @Test
-  public void nonCascadingCancellationDoesNotNotifyForked() {
-    Context.CancellableContext base = Context.current().withCancellation();
-    Context fork = base.fork();
-    fork.addListener(cancellationListener, MoreExecutors.directExecutor());
-    assertEquals(0, base.listenerCount());
-    assertEquals(0, fork.listenerCount());
-    assertTrue(base.cancel(new Throwable()));
-    assertNull(listenerNotifedContext);
-    assertFalse(fork.isCancelled());
-    assertNull(fork.cancellationCause());
-  }
-
-  @Test
-  public void testWrapRunnable() throws Exception {
-    Context base = Context.current().withValue(PET, "cat");
-    Context current = Context.current().withValue(PET, "fish");
-    current.attach();
-
-    base.wrap(runner).run();
-    assertSame(base, observed);
-    assertSame(current, Context.current());
-
-    current.wrap(runner).run();
-    assertSame(current, observed);
-    assertSame(current, Context.current());
-
-    final Error err = new Error();
-    try {
-      base.wrap(new Runnable() {
-        @Override
-        public void run() {
-          throw err;
-        }
-      }).run();
-      fail("Expected exception");
-    } catch (Error ex) {
-      assertSame(err, ex);
-    }
-    assertSame(current, Context.current());
-
-    current.detach(Context.ROOT);
-  }
-
-  @Test
-  public void testWrapCallable() throws Exception {
-    Context base = Context.current().withValue(PET, "cat");
-    Context current = Context.current().withValue(PET, "fish");
-    current.attach();
-
-    final Object ret = new Object();
-    Callable<Object> callable = new Callable<Object>() {
-      @Override
-      public Object call() {
-        runner.run();
-        return ret;
-      }
-    };
-
-    assertSame(ret, base.wrap(callable).call());
-    assertSame(base, observed);
-    assertSame(current, Context.current());
-
-    assertSame(ret, current.wrap(callable).call());
-    assertSame(current, observed);
-    assertSame(current, Context.current());
-
-    final Error err = new Error();
-    try {
-      base.wrap(new Callable<Object>() {
-        @Override
-        public Object call() {
-          throw err;
-        }
-      }).call();
-      fail("Excepted exception");
-    } catch (Error ex) {
-      assertSame(err, ex);
-    }
-    assertSame(current, Context.current());
-
-    current.detach(Context.ROOT);
-  }
-
-  @Test
-  public void currentContextExecutor() throws Exception {
-    QueuedExecutor queuedExecutor = new QueuedExecutor();
-    Executor executor = Context.currentContextExecutor(queuedExecutor);
-    Context base = Context.current().withValue(PET, "cat");
-    Context previous = base.attach();
-    try {
-      executor.execute(runner);
-    } finally {
-      base.detach(previous);
-    }
-    assertEquals(1, queuedExecutor.runnables.size());
-    queuedExecutor.runnables.remove().run();
-    assertSame(base, observed);
-  }
-
-  @Test
-  public void fixedContextExecutor() throws Exception {
-    Context base = Context.current().withValue(PET, "cat");
-    QueuedExecutor queuedExecutor = new QueuedExecutor();
-    base.fixedContextExecutor(queuedExecutor).execute(runner);
-    assertEquals(1, queuedExecutor.runnables.size());
-    queuedExecutor.runnables.remove().run();
-    assertSame(base, observed);
-  }
-
-  @Test
-  public void typicalTryFinallyHandling() throws Exception {
-    Context base = Context.current().withValue(COLOR, "blue");
-    Context previous = base.attach();
-    try {
-      assertTrue(base.isCurrent());
-      // Do something
-    } finally {
-      base.detach(previous);
-    }
-    assertFalse(base.isCurrent());
-  }
-
-  @Test
-  public void typicalCancellableTryCatchFinallyHandling() throws Exception {
-    Context.CancellableContext base = Context.current().withCancellation();
-    Context previous = base.attach();
-    try {
-      // Do something
-      throw new IllegalStateException("Argh");
-    } catch (IllegalStateException ise) {
-      base.cancel(ise);
-    } finally {
-      base.detachAndCancel(previous, null);
-    }
-    assertTrue(base.isCancelled());
-    assertNotNull(base.cancellationCause());
-  }
-
-  @Test
-  public void rootHasNoDeadline() {
-    assertNull(Context.ROOT.getDeadline());
-  }
-
-  @Test
-  public void contextWithDeadlineHasDeadline() {
-    Context.CancellableContext cancellableContext =
-        Context.ROOT.withDeadlineAfter(1, TimeUnit.SECONDS, scheduler);
-    assertNotNull(cancellableContext.getDeadline());
-  }
-
-  @Test
-  public void earlierParentDeadlineTakesPrecedenceOverLaterChildDeadline() throws Exception {
-    final Deadline sooner = Deadline.after(100, TimeUnit.MILLISECONDS);
-    final Deadline later = Deadline.after(1, TimeUnit.MINUTES);
-    Context.CancellableContext parent = Context.ROOT.withDeadline(sooner, scheduler);
-    Context.CancellableContext child = parent.withDeadline(later, scheduler);
-    assertSame(parent.getDeadline(), sooner);
-    assertSame(child.getDeadline(), sooner);
-    final CountDownLatch latch = new CountDownLatch(1);
-    final AtomicReference<Exception> error = new AtomicReference<Exception>();
-    child.addListener(new Context.CancellationListener() {
-      @Override
-      public void cancelled(Context context) {
-        try {
-          assertTrue(sooner.isExpired());
-          assertFalse(later.isExpired());
-        } catch (Exception e) {
-          error.set(e);
-        }
-        latch.countDown();
-      }
-    }, MoreExecutors.directExecutor());
-    latch.await(3, TimeUnit.SECONDS);
-    if (error.get() != null) {
-      throw error.get();
-    }
-  }
-
-  @Test
-  public void earlierChldDeadlineTakesPrecedenceOverLaterParentDeadline() {
-    Deadline sooner = Deadline.after(1, TimeUnit.HOURS);
-    Deadline later = Deadline.after(1, TimeUnit.DAYS);
-    Context.CancellableContext parent = Context.ROOT.withDeadline(later, scheduler);
-    Context.CancellableContext child = parent.withDeadline(sooner, scheduler);
-    assertSame(parent.getDeadline(), later);
-    assertSame(child.getDeadline(), sooner);
-  }
-
-  @Test
-  public void forkingContextDoesNotCarryDeadline() {
-    Deadline deadline = Deadline.after(1, TimeUnit.HOURS);
-    Context.CancellableContext parent = Context.ROOT.withDeadline(deadline, scheduler);
-    Context fork = parent.fork();
-    assertNull(fork.getDeadline());
-  }
-
-  @Test
-  public void cancellationDoesNotExpireDeadline() {
-    Deadline deadline = Deadline.after(1, TimeUnit.HOURS);
-    Context.CancellableContext parent = Context.ROOT.withDeadline(deadline, scheduler);
-    parent.cancel(null);
-    assertFalse(deadline.isExpired());
-  }
-
-  @Test
-  public void absoluteDeadlineTriggersAndPropagates() throws Exception {
-    Context base = Context.current().withDeadline(Deadline.after(1, TimeUnit.SECONDS), scheduler);
-    Context child = base.withValue(FOOD, "lasagna");
-    child.addListener(cancellationListener, MoreExecutors.directExecutor());
-    assertFalse(base.isCancelled());
-    assertFalse(child.isCancelled());
-    assertTrue(deadlineLatch.await(2, TimeUnit.SECONDS));
-    assertTrue(base.isCancelled());
-    assertTrue(base.cancellationCause() instanceof TimeoutException);
-    assertSame(child, listenerNotifedContext);
-    assertTrue(child.isCancelled());
-    assertSame(base.cancellationCause(), child.cancellationCause());
-  }
-
-  @Test
-  public void relativeDeadlineTriggersAndPropagates() throws Exception {
-    Context base = Context.current().withDeadline(Deadline.after(1, TimeUnit.SECONDS), scheduler);
-    Context child = base.withValue(FOOD, "lasagna");
-    child.addListener(cancellationListener, MoreExecutors.directExecutor());
-    assertFalse(base.isCancelled());
-    assertFalse(child.isCancelled());
-    assertTrue(deadlineLatch.await(2, TimeUnit.SECONDS));
-    assertTrue(base.isCancelled());
-    assertTrue(base.cancellationCause() instanceof TimeoutException);
-    assertSame(child, listenerNotifedContext);
-    assertTrue(child.isCancelled());
-    assertSame(base.cancellationCause(), child.cancellationCause());
-  }
-
-  @Test
-  public void innerDeadlineCompletesBeforeOuter() throws Exception {
-    Context base = Context.current().withDeadline(Deadline.after(2, TimeUnit.SECONDS), scheduler);
-    Context child = base.withDeadline(Deadline.after(1, TimeUnit.SECONDS), scheduler);
-    child.addListener(cancellationListener, MoreExecutors.directExecutor());
-    assertFalse(base.isCancelled());
-    assertFalse(child.isCancelled());
-    assertTrue(deadlineLatch.await(2, TimeUnit.SECONDS));
-    assertFalse(base.isCancelled());
-    assertSame(child, listenerNotifedContext);
-    assertTrue(child.isCancelled());
-    assertTrue(child.cancellationCause() instanceof TimeoutException);
-
-    deadlineLatch = new CountDownLatch(1);
-    base.addListener(cancellationListener, MoreExecutors.directExecutor());
-    assertTrue(deadlineLatch.await(2, TimeUnit.SECONDS));
-    assertTrue(base.isCancelled());
-    assertTrue(base.cancellationCause() instanceof TimeoutException);
-    assertNotSame(base.cancellationCause(), child.cancellationCause());
-  }
-
-  @Test
-  public void cancellationCancelsScheduledTask() {
-    ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
-    try {
-      assertEquals(0, executor.getQueue().size());
-      Context.CancellableContext base
-          = Context.current().withDeadline(Deadline.after(1, TimeUnit.DAYS), executor);
-      assertEquals(1, executor.getQueue().size());
-      base.cancel(null);
-      executor.purge();
-      assertEquals(0, executor.getQueue().size());
-    } finally {
-      executor.shutdown();
-    }
-  }
-
-  private static class QueuedExecutor implements Executor {
-    private final Queue<Runnable> runnables = new ArrayDeque<Runnable>();
-
-    @Override
-    public void execute(Runnable r) {
-      runnables.add(r);
-    }
-  }
-
-  @Test
-  public void childContextListenerNotifiedAfterParentListener() {
-    Context.CancellableContext parent = Context.current().withCancellation();
-    Context child = parent.withValue(COLOR, "red");
-    final AtomicBoolean childAfterParent = new AtomicBoolean();
-    final AtomicBoolean parentCalled = new AtomicBoolean();
-    child.addListener(new Context.CancellationListener() {
-      @Override
-      public void cancelled(Context context) {
-        if (parentCalled.get()) {
-          childAfterParent.set(true);
-        }
-      }
-    }, MoreExecutors.directExecutor());
-    parent.addListener(new Context.CancellationListener() {
-      @Override
-      public void cancelled(Context context) {
-        parentCalled.set(true);
-      }
-    }, MoreExecutors.directExecutor());
-    parent.cancel(null);
-    assertTrue(parentCalled.get());
-    assertTrue(childAfterParent.get());
-  }
-
-  @Test
-  public void expiredDeadlineShouldCancelContextImmediately() {
-    Context parent = Context.current();
-    assertFalse(parent.isCancelled());
-
-    Context.CancellableContext context = parent.withDeadlineAfter(0, TimeUnit.SECONDS, scheduler);
-    assertTrue(context.isCancelled());
-    assertThat(context.cancellationCause(), instanceOf(TimeoutException.class));
-
-    assertFalse(parent.isCancelled());
-    Deadline deadline = Deadline.after(-10, TimeUnit.SECONDS);
-    assertTrue(deadline.isExpired());
-    context = parent.withDeadline(deadline, scheduler);
-    assertTrue(context.isCancelled());
-    assertThat(context.cancellationCause(), instanceOf(TimeoutException.class));
-  }
-}
diff --git a/context/src/test/java/io/grpc/DeadlineTest.java b/context/src/test/java/io/grpc/DeadlineTest.java
deleted file mode 100644
index e363cbe7da8..00000000000
--- a/context/src/test/java/io/grpc/DeadlineTest.java
+++ /dev/null
@@ -1,286 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.truth.Truth.assertAbout;
-import static io.grpc.testing.DeadlineSubject.deadline;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-import com.google.common.truth.Truth;
-import java.util.Arrays;
-import java.util.concurrent.Future;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-import org.mockito.ArgumentCaptor;
-
-/**
- * Tests for {@link Context}.
- */
-@RunWith(Parameterized.class)
-public class DeadlineTest {
-  /** Ticker epochs to vary testing. */
-  @Parameters
-  public static Iterable<Object[]> data() {
-    return Arrays.asList(new Object[][] {
-      // MAX_VALUE / 2 is important because the signs are generally the same for past and future
-      // deadlines.
-      {Long.MAX_VALUE / 2}, {0}, {Long.MAX_VALUE}, {Long.MIN_VALUE}
-    });
-  }
-
-  private FakeTicker ticker = new FakeTicker();
-
-  public DeadlineTest(long epoch) {
-    ticker.reset(epoch);
-  }
-
-  @Test
-  public void defaultTickerIsSystemTicker() {
-    Deadline d = Deadline.after(0, TimeUnit.SECONDS);
-    ticker.reset(System.nanoTime());
-    Deadline reference = Deadline.after(0, TimeUnit.SECONDS, ticker);
-    // Allow inaccuracy to account for system time advancing during test.
-    assertAbout(deadline()).that(d).isWithin(1, TimeUnit.SECONDS).of(reference);
-  }
-
-  @Test
-  public void timeCanOverflow() {
-    ticker.reset(Long.MAX_VALUE);
-    Deadline d = Deadline.after(10, TimeUnit.DAYS, ticker);
-    assertEquals(10, d.timeRemaining(TimeUnit.DAYS));
-    assertTrue(Deadline.after(0, TimeUnit.DAYS, ticker).isBefore(d));
-    assertFalse(d.isExpired());
-
-    ticker.increment(10, TimeUnit.DAYS);
-    assertTrue(d.isExpired());
-  }
-
-  @Test
-  public void timeCanUnderflow() {
-    ticker.reset(Long.MIN_VALUE);
-    Deadline d = Deadline.after(-10, TimeUnit.DAYS, ticker);
-    assertEquals(-10, d.timeRemaining(TimeUnit.DAYS));
-    assertTrue(d.isBefore(Deadline.after(0, TimeUnit.DAYS, ticker)));
-    assertTrue(d.isExpired());
-  }
-
-  @Test
-  public void deadlineClamps() {
-    Deadline d = Deadline.after(-300 * 365, TimeUnit.DAYS, ticker);
-    Deadline d2 = Deadline.after(300 * 365, TimeUnit.DAYS, ticker);
-    assertTrue(d.isBefore(d2));
-
-    Deadline d3 = Deadline.after(-200 * 365, TimeUnit.DAYS, ticker);
-    // d and d3 are equal
-    assertFalse(d.isBefore(d3));
-    assertFalse(d3.isBefore(d));
-  }
-
-  @Test
-  public void immediateDeadlineIsExpired() {
-    Deadline deadline = Deadline.after(0, TimeUnit.SECONDS, ticker);
-    assertTrue(deadline.isExpired());
-  }
-
-  @Test
-  public void shortDeadlineEventuallyExpires() throws Exception {
-    Deadline d = Deadline.after(100, TimeUnit.MILLISECONDS, ticker);
-    assertTrue(d.timeRemaining(TimeUnit.NANOSECONDS) > 0);
-    assertFalse(d.isExpired());
-    ticker.increment(101, TimeUnit.MILLISECONDS);
-
-    assertTrue(d.isExpired());
-    assertEquals(-1, d.timeRemaining(TimeUnit.MILLISECONDS));
-  }
-
-  @Test
-  public void deadlineMatchesLongValue() {
-    assertEquals(10, Deadline.after(10, TimeUnit.MINUTES, ticker).timeRemaining(TimeUnit.MINUTES));
-  }
-
-  @Test
-  public void pastDeadlineIsExpired() {
-    Deadline d = Deadline.after(-1, TimeUnit.SECONDS, ticker);
-    assertTrue(d.isExpired());
-    assertEquals(-1000, d.timeRemaining(TimeUnit.MILLISECONDS));
-  }
-
-  @Test
-  public void deadlineDoesNotOverflowOrUnderflow() {
-    Deadline after = Deadline.after(Long.MAX_VALUE, TimeUnit.NANOSECONDS, ticker);
-    assertFalse(after.isExpired());
-
-    Deadline before = Deadline.after(-Long.MAX_VALUE, TimeUnit.NANOSECONDS, ticker);
-    assertTrue(before.isExpired());
-
-    assertTrue(before.isBefore(after));
-  }
-
-  @Test
-  public void beforeExpiredDeadlineIsExpired() {
-    Deadline base = Deadline.after(0, TimeUnit.SECONDS, ticker);
-    assertTrue(base.isExpired());
-    assertTrue(base.offset(-1, TimeUnit.SECONDS).isExpired());
-  }
-
-  @Test
-  public void beforeNotExpiredDeadlineMayBeExpired() {
-    Deadline base = Deadline.after(10, TimeUnit.SECONDS, ticker);
-    assertFalse(base.isExpired());
-    assertFalse(base.offset(-1, TimeUnit.SECONDS).isExpired());
-    assertTrue(base.offset(-11, TimeUnit.SECONDS).isExpired());
-  }
-
-  @Test
-  public void afterExpiredDeadlineMayBeExpired() {
-    Deadline base = Deadline.after(-10, TimeUnit.SECONDS, ticker);
-    assertTrue(base.isExpired());
-    assertTrue(base.offset(1, TimeUnit.SECONDS).isExpired());
-    assertFalse(base.offset(11, TimeUnit.SECONDS).isExpired());
-  }
-
-  @Test
-  public void zeroOffsetIsSameDeadline() {
-    Deadline base = Deadline.after(0, TimeUnit.SECONDS, ticker);
-    assertSame(base, base.offset(0, TimeUnit.SECONDS));
-  }
-
-  @Test
-  public void runOnEventualExpirationIsExecuted() throws Exception {
-    Deadline base = Deadline.after(50, TimeUnit.MICROSECONDS, ticker);
-    ScheduledExecutorService mockScheduler = mock(ScheduledExecutorService.class);
-    final AtomicBoolean executed = new AtomicBoolean();
-    Future<?> unused = base.runOnExpiration(
-        new Runnable() {
-          @Override
-          public void run() {
-            executed.set(true);
-          }
-        }, mockScheduler);
-    assertFalse(executed.get());
-    ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(mockScheduler).schedule(runnableCaptor.capture(), eq(50000L), eq(TimeUnit.NANOSECONDS));
-    runnableCaptor.getValue().run();
-    assertTrue(executed.get());
-  }
-
-  @Test
-  public void runOnAlreadyExpiredIsExecutedOnExecutor() throws Exception {
-    Deadline base = Deadline.after(0, TimeUnit.MICROSECONDS, ticker);
-    ScheduledExecutorService mockScheduler = mock(ScheduledExecutorService.class);
-    final AtomicBoolean executed = new AtomicBoolean();
-    Future<?> unused = base.runOnExpiration(
-        new Runnable() {
-          @Override
-          public void run() {
-            executed.set(true);
-          }
-        }, mockScheduler);
-    assertFalse(executed.get());
-    ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(mockScheduler).schedule(runnableCaptor.capture(), eq(0L), eq(TimeUnit.NANOSECONDS));
-    runnableCaptor.getValue().run();
-    assertTrue(executed.get());
-  }
-
-  @Test
-  public void toString_exact() {
-    Deadline d = Deadline.after(0, TimeUnit.MILLISECONDS, ticker);
-    assertEquals("0 ns from now", d.toString());
-  }
-
-  @Test
-  public void toString_after() {
-    Deadline d = Deadline.after(-1, TimeUnit.MINUTES, ticker);
-    assertEquals("-60000000000 ns from now", d.toString());
-  }
-
-  @Test
-  public void compareTo_greater() {
-    Deadline d1 = Deadline.after(10, TimeUnit.SECONDS, ticker);
-    ticker.increment(1, TimeUnit.NANOSECONDS);
-    Deadline d2 = Deadline.after(10, TimeUnit.SECONDS, ticker);
-    Truth.assertThat(d2).isGreaterThan(d1);
-  }
-
-  @Test
-  public void compareTo_less() {
-    Deadline d1 = Deadline.after(10, TimeUnit.SECONDS, ticker);
-    ticker.increment(1, TimeUnit.NANOSECONDS);
-    Deadline d2 = Deadline.after(10, TimeUnit.SECONDS, ticker);
-    Truth.assertThat(d1).isLessThan(d2);
-  }
-
-  @Test
-  public void compareTo_same() {
-    Deadline d1 = Deadline.after(10, TimeUnit.SECONDS, ticker);
-    Deadline d2 = Deadline.after(10, TimeUnit.SECONDS, ticker);
-    Truth.assertThat(d1).isEquivalentAccordingToCompareTo(d2);
-  }
-
-  @Test
-  public void toString_before() {
-    Deadline d = Deadline.after(12, TimeUnit.MICROSECONDS, ticker);
-    assertEquals("12000 ns from now", d.toString());
-  }
-
-  private static class FakeTicker extends Deadline.Ticker {
-    private long time;
-
-    @Override
-    public long read() {
-      return time;
-    }
-
-    public void reset(long time) {
-      this.time = time;
-    }
-
-    public void increment(long period, TimeUnit unit) {
-      if (period < 0) {
-        throw new IllegalArgumentException();
-      }
-      this.time += unit.toNanos(period);
-    }
-  }
-}
diff --git a/contextstorage/build.gradle b/contextstorage/build.gradle
new file mode 100644
index 00000000000..b1e78ea0e17
--- /dev/null
+++ b/contextstorage/build.gradle
@@ -0,0 +1,35 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "ru.vyarus.animalsniffer"
+}
+
+description = 'gRPC: ContextStorageOverride'
+
+dependencies {
+    api project(':grpc-api')
+    implementation libraries.opentelemetry.api
+
+    testImplementation libraries.junit,
+            libraries.opentelemetry.sdk.testing,
+            libraries.assertj.core
+    testImplementation 'junit:junit:4.13.1'// opentelemetry.sdk.testing uses compileOnly for assertj
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.override')
+    }
+}
diff --git a/contextstorage/src/main/java/io/grpc/override/ContextStorageOverride.java b/contextstorage/src/main/java/io/grpc/override/ContextStorageOverride.java
new file mode 100644
index 00000000000..41b24765de0
--- /dev/null
+++ b/contextstorage/src/main/java/io/grpc/override/ContextStorageOverride.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2024 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.override;
+
+import io.grpc.Context;
+
+/**
+ * Including this class in your dependencies will override the default gRPC context storage using
+ * reflection. It is a bridge between {@link io.grpc.Context} and
+ * {@link io.opentelemetry.context.Context}, i.e. propagating io.grpc.context.Context also
+ * propagates io.opentelemetry.context, and propagating io.opentelemetry.context will also propagate
+ * io.grpc.context.
+ */
+public final class ContextStorageOverride extends Context.Storage {
+
+  private final Context.Storage delegate = new OpenTelemetryContextStorage();
+
+  @Override
+  public Context doAttach(Context toAttach) {
+    return delegate.doAttach(toAttach);
+  }
+
+  @Override
+  public void detach(Context toDetach, Context toRestore) {
+    delegate.detach(toDetach, toRestore);
+  }
+
+  @Override
+  public Context current() {
+    return delegate.current();
+  }
+}
diff --git a/contextstorage/src/main/java/io/grpc/override/OpenTelemetryContextStorage.java b/contextstorage/src/main/java/io/grpc/override/OpenTelemetryContextStorage.java
new file mode 100644
index 00000000000..01356e9f406
--- /dev/null
+++ b/contextstorage/src/main/java/io/grpc/override/OpenTelemetryContextStorage.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2024 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.override;
+
+import io.grpc.Context;
+import io.opentelemetry.context.ContextKey;
+import io.opentelemetry.context.Scope;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A Context.Storage implementation that attaches io.grpc.context to OpenTelemetry's context and
+ * io.opentelemetry.context is also saved in the io.grpc.context.
+ * Bridge between {@link io.grpc.Context} and {@link io.opentelemetry.context.Context}.
+ */
+final class OpenTelemetryContextStorage extends Context.Storage {
+  private static final Logger logger = Logger.getLogger(
+      OpenTelemetryContextStorage.class.getName());
+
+  private static final io.grpc.Context.Key<io.opentelemetry.context.Context> OTEL_CONTEXT_OVER_GRPC
+      = io.grpc.Context.key("otel-context-over-grpc");
+  private static final Context.Key<Scope> OTEL_SCOPE = Context.key("otel-scope");
+  private static final ContextKey<io.grpc.Context> GRPC_CONTEXT_OVER_OTEL =
+      ContextKey.named("grpc-context-over-otel");
+
+  @Override
+  @SuppressWarnings("MustBeClosedChecker")
+  public Context doAttach(Context toAttach) {
+    io.grpc.Context previous = current();
+    io.opentelemetry.context.Context otelContext = OTEL_CONTEXT_OVER_GRPC.get(toAttach);
+    if (otelContext == null) {
+      otelContext = io.opentelemetry.context.Context.current();
+    }
+    Scope scope = otelContext.with(GRPC_CONTEXT_OVER_OTEL, toAttach).makeCurrent();
+    return previous.withValue(OTEL_SCOPE, scope);
+  }
+
+  @Override
+  public void detach(Context toDetach, Context toRestore) {
+    Scope scope = OTEL_SCOPE.get(toRestore);
+    if (scope == null) {
+      logger.log(
+          Level.SEVERE, "Detaching context which was not attached.");
+    } else {
+      scope.close();
+    }
+  }
+
+  @Override
+  public Context current() {
+    io.opentelemetry.context.Context otelCurrent = io.opentelemetry.context.Context.current();
+    io.grpc.Context grpcCurrent = otelCurrent.get(GRPC_CONTEXT_OVER_OTEL);
+    if (grpcCurrent == null) {
+      grpcCurrent = Context.ROOT;
+    }
+    return grpcCurrent.withValue(OTEL_CONTEXT_OVER_GRPC, otelCurrent);
+  }
+}
diff --git a/contextstorage/src/test/java/io/grpc/override/OpenTelemetryContextStorageTest.java b/contextstorage/src/test/java/io/grpc/override/OpenTelemetryContextStorageTest.java
new file mode 100644
index 00000000000..3c628964342
--- /dev/null
+++ b/contextstorage/src/test/java/io/grpc/override/OpenTelemetryContextStorageTest.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2024 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.override;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import com.google.common.util.concurrent.SettableFuture;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.Tracer;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.ContextKey;
+import io.opentelemetry.context.Scope;
+import io.opentelemetry.sdk.testing.junit4.OpenTelemetryRule;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class OpenTelemetryContextStorageTest {
+  @Rule
+  public final OpenTelemetryRule openTelemetryRule = OpenTelemetryRule.create();
+  private Tracer tracerRule = openTelemetryRule.getOpenTelemetry().getTracer(
+      "context-storage-test");
+  private final io.grpc.Context.Key<String> username = io.grpc.Context.key("username");
+  private final ContextKey<String> password = ContextKey.named("password");
+
+  @Test
+  public void grpcContextPropagation() throws Exception {
+    final Span parentSpan = tracerRule.spanBuilder("test-context").startSpan();
+    final SettableFuture<Span> spanPropagated = SettableFuture.create();
+    final SettableFuture<String> grpcContextPropagated = SettableFuture.create();
+    final SettableFuture<Span> spanDetached = SettableFuture.create();
+    final SettableFuture<String> grpcContextDetached = SettableFuture.create();
+
+    io.grpc.Context grpcContext;
+    try (Scope scope = Context.current().with(parentSpan).makeCurrent()) {
+      grpcContext = io.grpc.Context.current().withValue(username, "jeff");
+    }
+    new Thread(new Runnable() {
+      @Override
+      public void run() {
+        io.grpc.Context previous = grpcContext.attach();
+        try {
+          grpcContextPropagated.set(username.get(io.grpc.Context.current()));
+          spanPropagated.set(Span.fromContext(io.opentelemetry.context.Context.current()));
+        } finally {
+          grpcContext.detach(previous);
+          spanDetached.set(Span.fromContext(io.opentelemetry.context.Context.current()));
+          grpcContextDetached.set(username.get(io.grpc.Context.current()));
+        }
+      }
+    }).start();
+    Assert.assertEquals(spanPropagated.get(5, TimeUnit.SECONDS), parentSpan);
+    Assert.assertEquals(grpcContextPropagated.get(5, TimeUnit.SECONDS), "jeff");
+    Assert.assertEquals(spanDetached.get(5, TimeUnit.SECONDS), Span.getInvalid());
+    Assert.assertNull(grpcContextDetached.get(5, TimeUnit.SECONDS));
+  }
+
+  @Test
+  public void otelContextPropagation() throws Exception {
+    final SettableFuture<String> grpcPropagated = SettableFuture.create();
+    final AtomicReference<String> otelPropagation = new AtomicReference<>();
+
+    io.grpc.Context grpcContext = io.grpc.Context.current().withValue(username, "jeff");
+    io.grpc.Context previous = grpcContext.attach();
+    Context original = Context.current().with(password, "valentine");
+    try {
+      new Thread(
+          () -> {
+            try (Scope scope = original.makeCurrent()) {
+              otelPropagation.set(Context.current().get(password));
+              grpcPropagated.set(username.get(io.grpc.Context.current()));
+            }
+          }
+      ).start();
+    } finally {
+      grpcContext.detach(previous);
+    }
+    Assert.assertEquals(grpcPropagated.get(5, TimeUnit.SECONDS), "jeff");
+    Assert.assertEquals(otelPropagation.get(), "valentine");
+  }
+
+  @Test
+  public void grpcOtelMix() {
+    io.grpc.Context grpcContext = io.grpc.Context.current().withValue(username, "jeff");
+    Context otelContext = Context.current().with(password, "valentine");
+    Assert.assertNull(username.get(io.grpc.Context.current()));
+    Assert.assertNull(Context.current().get(password));
+    io.grpc.Context previous = grpcContext.attach();
+    try {
+      assertEquals(username.get(io.grpc.Context.current()), "jeff");
+      try (Scope scope = otelContext.makeCurrent()) {
+        Assert.assertEquals(Context.current().get(password), "valentine");
+        assertNull(username.get(io.grpc.Context.current()));
+
+        io.grpc.Context grpcContext2 = io.grpc.Context.current().withValue(username, "frank");
+        io.grpc.Context previous2 = grpcContext2.attach();
+        try {
+          assertEquals(username.get(io.grpc.Context.current()), "frank");
+          Assert.assertEquals(Context.current().get(password), "valentine");
+        } finally {
+          grpcContext2.detach(previous2);
+        }
+        assertNull(username.get(io.grpc.Context.current()));
+        Assert.assertEquals(Context.current().get(password), "valentine");
+      }
+    } finally {
+      grpcContext.detach(previous);
+    }
+    Assert.assertNull(username.get(io.grpc.Context.current()));
+    Assert.assertNull(Context.current().get(password));
+  }
+
+  @Test
+  public void grpcContextDetachError() {
+    io.grpc.Context grpcContext = io.grpc.Context.current().withValue(username, "jeff");
+    io.grpc.Context previous = grpcContext.attach();
+    try {
+      previous.detach(grpcContext);
+      assertEquals(username.get(io.grpc.Context.current()), "jeff");
+    } finally {
+      grpcContext.detach(previous);
+    }
+  }
+}
diff --git a/core/BUILD.bazel b/core/BUILD.bazel
new file mode 100644
index 00000000000..1a743ff9eda
--- /dev/null
+++ b/core/BUILD.bazel
@@ -0,0 +1,55 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "core",
+    visibility = ["//visibility:public"],
+    exports = ["//api"],
+)
+
+java_library(
+    name = "inprocess",
+    visibility = ["//visibility:public"],
+    exports = ["//inprocess"],
+)
+
+java_library(
+    name = "internal",
+    srcs = glob([
+        "src/main/java/io/grpc/internal/*.java",
+    ]),
+    resources = glob([
+        "src/bazel-internal/resources/**",
+    ]),
+    visibility = ["//:__subpackages__"],
+    deps = [
+        "//api",
+        "//context",
+        artifact("com.google.code.gson:gson"),
+        artifact("com.google.android:annotations"),
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+        artifact("io.perfmark:perfmark-api"),
+        artifact("org.codehaus.mojo:animal-sniffer-annotations"),
+    ],
+)
+
+java_library(
+    name = "util",
+    visibility = ["//visibility:public"],
+    exports = ["//util"],
+)
+
+# Mirrors the dependencies included in the artifact on Maven Central for usage
+# with maven_install's override_targets. Should only be used as a dep for
+# pre-compiled binaries on Maven Central.
+java_library(
+    name = "core_maven",
+    visibility = ["//visibility:public"],
+    exports = [
+        ":internal",
+        "//api",
+        "//util",
+    ],
+)
diff --git a/core/build.gradle b/core/build.gradle
index b833db032da..b320f326b41 100644
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -1,13 +1,82 @@
+buildscript {
+    dependencies {
+        classpath 'com.google.guava:guava:33.4.8-android'
+    }
+}
+
+plugins {
+    id "java-library"
+    id "java-test-fixtures"
+    id "maven-publish"
+
+    id "me.champeau.gradle.japicmp"
+    id "me.champeau.jmh"
+    id "ru.vyarus.animalsniffer"
+}
+
 description = 'gRPC: Core'
 
 dependencies {
-    compile libraries.guava,
-            libraries.errorprone,
-            libraries.jsr305,
-            project(':grpc-context'),
-            libraries.instrumentation_api
-    testCompile project(':grpc-testing')
-    signature "org.codehaus.mojo.signature:java16:+@signature"
+    api project(':grpc-api')
+    // force dependent jars to depend on latest grpc-context
+    runtimeOnly project(":grpc-context")
+    implementation libraries.gson,
+            libraries.android.annotations,
+            libraries.animalsniffer.annotations,
+            libraries.errorprone.annotations,
+            libraries.guava,
+            libraries.perfmark.api
+    testFixturesApi libraries.junit
+    testFixturesImplementation libraries.guava,
+            libraries.mockito.core,
+            libraries.truth,
+            project(':grpc-testing')
+    testImplementation testFixtures(project(':grpc-api')),
+            project(':grpc-testing')
+    testImplementation libraries.guava.testlib
+
+    testRuntimeOnly project(':grpc-census')
+
+    jmh project(':grpc-testing')
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
-javadoc.exclude 'io/grpc/internal/**'
+tasks.named("javadoc").configure {
+    exclude 'io/grpc/internal/**'
+    exclude 'io/grpc/inprocess/Internal*'
+    // Disabled until kinda stable.
+    exclude 'io/grpc/perfmark/**'
+}
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.internal')
+    }
+}
+
+animalsniffer {
+    // Don't check sourceSets.jmh
+    sourceSets = [
+        sourceSets.main,
+        sourceSets.test
+    ]
+}
+
+components.java.withVariantsFromConfiguration(configurations.testFixturesApiElements) { skip() }
+components.java.withVariantsFromConfiguration(configurations.testFixturesRuntimeElements) { skip() }
+
+tasks.register("versionFile") {
+    doLast {
+        new File(buildDir, "version").write("${project.version}\n")
+    }
+}
diff --git a/core/src/bazel-internal/resources/META-INF/services/io.grpc.LoadBalancerProvider b/core/src/bazel-internal/resources/META-INF/services/io.grpc.LoadBalancerProvider
new file mode 100644
index 00000000000..bbc367f8fc5
--- /dev/null
+++ b/core/src/bazel-internal/resources/META-INF/services/io.grpc.LoadBalancerProvider
@@ -0,0 +1 @@
+io.grpc.internal.PickFirstLoadBalancerProvider
diff --git a/core/src/bazel-internal/resources/META-INF/services/io.grpc.NameResolverProvider b/core/src/bazel-internal/resources/META-INF/services/io.grpc.NameResolverProvider
new file mode 100644
index 00000000000..ba850091aa4
--- /dev/null
+++ b/core/src/bazel-internal/resources/META-INF/services/io.grpc.NameResolverProvider
@@ -0,0 +1 @@
+io.grpc.internal.DnsNameResolverProvider
diff --git a/core/src/jmh/java/io/grpc/internal/ChannelzBenchmark.java b/core/src/jmh/java/io/grpc/internal/ChannelzBenchmark.java
new file mode 100644
index 00000000000..cae4c4e63c8
--- /dev/null
+++ b/core/src/jmh/java/io/grpc/internal/ChannelzBenchmark.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2018 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.internal;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.ServerStats;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.InternalLogId;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+
+/**
+ * Javadoc.
+ */
+@State(Scope.Benchmark)
+public class ChannelzBenchmark {
+  // Number of items already present
+  @Param({"10", "100", "1000", "10000"})
+  public int preexisting;
+
+  public InternalChannelz channelz = new InternalChannelz();
+
+  public InternalInstrumented<ServerStats> serverToRemove;
+
+  public InternalInstrumented<ServerStats> serverToAdd;
+
+  public InternalInstrumented<ServerStats> serverForServerSocket;
+  public InternalInstrumented<SocketStats> serverSocketToAdd;
+  public InternalInstrumented<SocketStats> serverSocketToRemove;
+
+  /**
+   * Javadoc.
+   */
+  @Setup
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  public void setUp() {
+    serverToRemove = create();
+    channelz.addServer(serverToRemove);
+
+    serverForServerSocket = create();
+    channelz.addServer(serverForServerSocket);
+
+    serverSocketToRemove = create();
+    channelz.addClientSocket(serverSocketToRemove);
+    channelz.addServerSocket(serverForServerSocket, serverSocketToRemove);
+
+    populate(preexisting);
+
+    serverToAdd = create();
+    serverSocketToAdd = create();
+  }
+
+  private void populate(int count) {
+    for (int i = 0; i < count; i++) {
+      // for addNavigable / removeNavigable
+      InternalInstrumented<ServerStats> srv = create();
+      channelz.addServer(srv);
+
+      // for add / remove
+      InternalInstrumented<SocketStats> sock = create();
+      channelz.addClientSocket(sock);
+
+      // for addServerSocket / removeServerSocket
+      channelz.addServerSocket(serverForServerSocket, sock);
+    }
+  }
+
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public void addNavigable() {
+    channelz.addServer(serverToAdd);
+  }
+
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public void add() {
+    channelz.addClientSocket(serverSocketToAdd);
+  }
+
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public void addServerSocket() {
+    channelz.addServerSocket(serverForServerSocket, serverSocketToAdd);
+  }
+
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public void removeNavigable() {
+    channelz.removeServer(serverToRemove);
+  }
+
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public void remove() {
+    channelz.removeClientSocket(serverSocketToRemove);
+  }
+
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public void removeServerSocket() {
+    channelz.removeServerSocket(serverForServerSocket, serverSocketToRemove);
+  }
+
+  private static <T> InternalInstrumented<T> create() {
+    return new InternalInstrumented<T>() {
+      final InternalLogId id = InternalLogId.allocate(getClass(), "fake-tag");
+
+      @Override
+      public ListenableFuture<T> getStats() {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override
+      public InternalLogId getLogId() {
+        return id;
+      }
+    };
+  }
+}
diff --git a/core/src/jmh/java/io/grpc/internal/SerializingExecutorBenchmark.java b/core/src/jmh/java/io/grpc/internal/SerializingExecutorBenchmark.java
new file mode 100644
index 00000000000..d37c634b929
--- /dev/null
+++ b/core/src/jmh/java/io/grpc/internal/SerializingExecutorBenchmark.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2017 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.internal;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Phaser;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.TearDown;
+
+/**
+ * SerializingExecutor benchmark.
+ *
+ * <p>Since this is a microbenchmark, don't actually believe the numbers in a strict sense. Instead,
+ * it is a gauge that the code is behaving roughly as expected, to increase confidence that our
+ * understanding of the code is correct (and will behave as expected in other cases). Even more
+ * helpfully it pushes the implementation, which should weed out many multithreading bugs.
+ */
+@State(Scope.Thread)
+public class SerializingExecutorBenchmark {
+
+  private ExecutorService executorService = Executors.newSingleThreadExecutor();
+  private Executor executor = new SerializingExecutor(executorService);
+
+  private static class IncrRunnable implements Runnable {
+    int val;
+
+    @Override
+    public void run() {
+      val++;
+    }
+  }
+
+  private final IncrRunnable incrRunnable = new IncrRunnable();
+
+  private final Phaser phaser = new Phaser(2);
+  private final Runnable phaserRunnable = new Runnable() {
+    @Override
+    public void run() {
+      phaser.arrive();
+    }
+  };
+
+  @TearDown
+  public void tearDown() throws Exception {
+    executorService.shutdownNow();
+    if (!executorService.awaitTermination(1, TimeUnit.SECONDS)) {
+      throw new RuntimeException("executor failed to shut down in a timely fashion");
+    }
+  }
+
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public void oneRunnableLatency() throws Exception {
+    executor.execute(phaserRunnable);
+    phaser.arriveAndAwaitAdvance();
+  }
+
+  /**
+   * Queue many runnables, to better see queuing/consumption cost instead of just context switch.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public void manyRunnables() throws Exception {
+    incrRunnable.val = 0;
+    for (int i = 0; i < 500; i++) {
+      executor.execute(incrRunnable);
+    }
+    executor.execute(phaserRunnable);
+    phaser.arriveAndAwaitAdvance();
+    if (incrRunnable.val != 500) {
+      throw new AssertionError();
+    }
+  }
+}
diff --git a/core/src/jmh/java/io/grpc/internal/StatsTraceContextBenchmark.java b/core/src/jmh/java/io/grpc/internal/StatsTraceContextBenchmark.java
new file mode 100644
index 00000000000..4d4349eef1b
--- /dev/null
+++ b/core/src/jmh/java/io/grpc/internal/StatsTraceContextBenchmark.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2017 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.internal;
+
+import io.grpc.Attributes;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerStreamTracer;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+
+/**
+ * Benchmark for {@link StatsTraceContext}.
+ */
+@State(Scope.Benchmark)
+public class StatsTraceContextBenchmark {
+
+  private final String methodName = MethodDescriptor.generateFullMethodName("service", "method");
+
+  private final Metadata emptyMetadata = new Metadata();
+  private final List<ServerStreamTracer.Factory> serverStreamTracerFactories =
+      Collections.emptyList();
+
+  /**
+   * Javadoc comment.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public StatsTraceContext newClientContext() {
+    return StatsTraceContext.newClientContext(
+        new ClientStreamTracer[] { new ClientStreamTracer() {} }, Attributes.EMPTY, emptyMetadata);
+  }
+
+  /**
+   * Javadoc comment.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public StatsTraceContext newServerContext_empty() {
+    return StatsTraceContext.newServerContext(
+        serverStreamTracerFactories, methodName, emptyMetadata);
+  }
+}
diff --git a/core/src/main/java/io/grpc/Attributes.java b/core/src/main/java/io/grpc/Attributes.java
deleted file mode 100644
index b31a442fdc4..00000000000
--- a/core/src/main/java/io/grpc/Attributes.java
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.common.base.Objects;
-import com.google.common.base.Preconditions;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Set;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.Immutable;
-
-/**
- * An immutable type-safe container of attributes.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1764")
-@Immutable
-public final class Attributes {
-
-  private final HashMap<Key<?>, Object> data = new HashMap<Key<?>, Object>();
-
-  public static final Attributes EMPTY = new Attributes();
-
-  private Attributes() {
-  }
-
-  /**
-   * Gets the value for the key, or {@code null} if it's not present.
-   */
-  @SuppressWarnings("unchecked")
-  @Nullable
-  public <T> T get(Key<T> key) {
-    return (T) data.get(key);
-  }
-
-  /**
-   * Returns set of keys stored in container.
-   *
-   * @return Set of Key objects.
-   */
-  public Set<Key<?>> keys() {
-    return Collections.unmodifiableSet(data.keySet());
-  }
-
-  /**
-   * Create a new builder that is pre-populated with the content from a given container.
-   */
-  public static Builder newBuilder(Attributes base) {
-    return newBuilder().setAll(base);
-  }
-
-  /**
-   * Create a new builder.
-   */
-  public static Builder newBuilder() {
-    return new Builder();
-  }
-
-  public static final class Key<T> {
-    private final String name;
-
-    private Key(String name) {
-      this.name = name;
-    }
-
-    @Override
-    public String toString() {
-      return name;
-    }
-
-    /**
-     * Factory method for creating instances of {@link Key}.
-     *
-     * @param name the name of Key. Name collision, won't cause key collision.
-     * @param <T> Key type
-     * @return Key object
-     */
-    public static <T> Key<T> of(String name) {
-      return new Key<T>(name);
-    }
-  }
-
-  @Override
-  public String toString() {
-    return data.toString();
-  }
-
-  /**
-   * Returns true if the given object is also a {@link Attributes} with an equal attribute values.
-   *
-   * <p>Note that if a stored values are mutable, it is possible for two objects to be considered
-   * equal at one point in time and not equal at another (due to concurrent mutation of attribute
-   * values).
-   *
-   * @param o an object.
-   * @return true if the given object is a {@link Attributes} equal attributes.
-   */
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) {
-      return true;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    Attributes that = (Attributes) o;
-    return Objects.equal(data, that.data);
-  }
-
-  /**
-   * Returns a hash code for the attributes.
-   *
-   * <p>Note that if a stored values are mutable, it is possible for two objects to be considered
-   * equal at one point in time and not equal at another (due to concurrent mutation of attribute
-   * values).
-   *
-   * @return a hash code for the attributes map.
-   */
-  @Override
-  public int hashCode() {
-    return data.hashCode();
-  }
-
-  public static final class Builder {
-    private Attributes product;
-
-    private Builder() {
-      this.product = new Attributes();
-    }
-
-    public <T> Builder set(Key<T> key, T value) {
-      product.data.put(key, value);
-      return this;
-    }
-
-    public <T> Builder setAll(Attributes other) {
-      product.data.putAll(other.data);
-      return this;
-    }
-
-    /**
-     * Build the attributes. Can only be called once.
-     */
-    public Attributes build() {
-      Preconditions.checkState(product != null, "Already built");
-      Attributes result = product;
-      product = null;
-      return result;
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/BindableService.java b/core/src/main/java/io/grpc/BindableService.java
deleted file mode 100644
index 91e30241080..00000000000
--- a/core/src/main/java/io/grpc/BindableService.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-/**
- * Provides a way to bind instance of service implementation to server.
- *
- * <p>It is used by service's abstract class generated by compiler (eg.:
- * RouteGuideGrpc.RouteGuideImplBase for RouteGuide service) and lets implementation classes to be
- * bind to server.
- *
- * <pre><code>
- * class RouteGuideService extends RouteGuideGrpc.RouteGuideImplBase {
- *   // ...
- * }
- *
- * Server server = ServerBuilder.forPort(1234).addService(new RouteGuideService()).build();
- * </code></pre></p>
- */
-public interface BindableService {
-  /**
-   * Creates {@link ServerServiceDefinition} object for current instance of service implementation.
-   *
-   * @return ServerServiceDefinition object.
-   */
-  ServerServiceDefinition bindService();
-}
diff --git a/core/src/main/java/io/grpc/CallCredentials.java b/core/src/main/java/io/grpc/CallCredentials.java
deleted file mode 100644
index 1b649dc3ec9..00000000000
--- a/core/src/main/java/io/grpc/CallCredentials.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import io.grpc.Attributes.Key;
-import java.util.concurrent.Executor;
-
-/**
- * Carries credential data that will be propagated to the server via request metadata for each RPC.
- *
- * <p>This is used by {@link CallOptions#withCallCredentials} and {@code withCallCredentials()} on
- * the generated stub, for example:
- * <pre>
- * FooGrpc.FooStub stub = FooGrpc.newStub(channel);
- * response = stub.withCallCredentials(creds).bar(request);
- * </pre>
- */
-@ExperimentalApi("https//github.com/grpc/grpc-java/issues/1914")
-public interface CallCredentials {
-  /**
-   * The security level of the transport. It is guaranteed to be present in the {@code attrs} passed
-   * to {@link #applyRequestMetadata}. It is by default {@link SecurityLevel#NONE} but can be
-   * overridden by the transport.
-   */
-  public static final Key<SecurityLevel> ATTR_SECURITY_LEVEL =
-      Key.of("io.grpc.CallCredentials.securityLevel");
-
-  /**
-   * The authority string used to authenticate the server. Usually it's the server's host name. It
-   * is guaranteed to be present in the {@code attrs} passed to {@link #applyRequestMetadata}. It is
-   * by default from the channel, but can be overridden by the transport and {@link
-   * io.grpc.CallOptions} with increasing precedence.
-   */
-  public static final Key<String> ATTR_AUTHORITY = Key.of("io.grpc.CallCredentials.authority");
-
-  /**
-   * Pass the credential data to the given {@link MetadataApplier}, which will propagate it to
-   * the request metadata.
-   *
-   * <p>It is called for each individual RPC, within the {@link Context} of the call, before the
-   * stream is about to be created on a transport. Implementations should not block in this
-   * method. If metadata is not immediately available, e.g., needs to be fetched from network, the
-   * implementation may give the {@code applier} to an asynchronous task which will eventually call
-   * the {@code applier}. The RPC proceeds only after the {@code applier} is called.
-   *
-   * @param method The method descriptor of this RPC
-   * @param attrs Additional attributes from the transport, along with the keys defined in this
-   *        interface (i.e. the {@code ATTR_*} fields) which are guaranteed to be present.
-   * @param appExecutor The application thread-pool. It is provided to the implementation in case it
-   *        needs to perform blocking operations.
-   * @param applier The outlet of the produced headers. It can be called either before or after this
-   *        method returns.
-   */
-  void applyRequestMetadata(
-      MethodDescriptor<?, ?> method, Attributes attrs,
-      Executor appExecutor, MetadataApplier applier);
-
-  /**
-   * The outlet of the produced headers. Not thread-safe.
-   *
-   * <p>Exactly one of its methods must be called to make the RPC proceed.
-   */
-  public interface MetadataApplier {
-    /**
-     * Called when headers are successfully generated. They will be merged into the original
-     * headers.
-     */
-    void apply(Metadata headers);
-
-    /**
-     * Called when there has been an error when preparing the headers. This will fail the RPC.
-     */
-    void fail(Status status);
-  }
-}
diff --git a/core/src/main/java/io/grpc/CallOptions.java b/core/src/main/java/io/grpc/CallOptions.java
deleted file mode 100644
index b6b668b3794..00000000000
--- a/core/src/main/java/io/grpc/CallOptions.java
+++ /dev/null
@@ -1,407 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.common.base.MoreObjects;
-import com.google.common.base.Preconditions;
-import java.util.Arrays;
-import java.util.concurrent.Executor;
-import java.util.concurrent.TimeUnit;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.Immutable;
-
-/**
- * The collection of runtime options for a new RPC call.
- *
- * <p>A field that is not set is {@code null}.
- */
-@Immutable
-public final class CallOptions {
-  /**
-   * A blank {@code CallOptions} that all fields are not set.
-   */
-  public static final CallOptions DEFAULT = new CallOptions();
-
-  // Although {@code CallOptions} is immutable, its fields are not final, so that we can initialize
-  // them outside of constructor. Otherwise the constructor will have a potentially long list of
-  // unnamed arguments, which is undesirable.
-  private Deadline deadline;
-  private Executor executor;
-
-  @Nullable
-  private String authority;
-
-  @Nullable
-  private CallCredentials credentials;
-
-  private Attributes affinity = Attributes.EMPTY;
-
-  @Nullable
-  private String compressorName;
-
-  private Object[][] customOptions = new Object[0][2];
-
-  /**
-   * Opposite to fail fast.
-   */
-  private boolean waitForReady;
-
-  @Nullable
-  private Integer maxInboundMessageSize;
-  @Nullable
-  private Integer maxOutboundMessageSize;
-
-
-  /**
-   * Override the HTTP/2 authority the channel claims to be connecting to. <em>This is not
-   * generally safe.</em> Overriding allows advanced users to re-use a single Channel for multiple
-   * services, even if those services are hosted on different domain names. That assumes the
-   * server is virtually hosting multiple domains and is guaranteed to continue doing so. It is
-   * rare for a service provider to make such a guarantee. <em>At this time, there is no security
-   * verification of the overridden value, such as making sure the authority matches the server's
-   * TLS certificate.</em>
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1767")
-  public CallOptions withAuthority(@Nullable String authority) {
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.authority = authority;
-    return newOptions;
-  }
-
-  /**
-   * Returns a new {@code CallOptions} with the given call credentials.
-   */
-  @ExperimentalApi("https//github.com/grpc/grpc-java/issues/1914")
-  public CallOptions withCallCredentials(@Nullable CallCredentials credentials) {
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.credentials = credentials;
-    return newOptions;
-  }
-
-  /**
-   * Sets the compression to use for the call.  The compressor must be a valid name known in the
-   * {@link CompressorRegistry}.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-  public CallOptions withCompression(@Nullable String compressorName) {
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.compressorName = compressorName;
-    return newOptions;
-  }
-
-  /**
-   * Returns a new {@code CallOptions} with the given absolute deadline.
-   *
-   * <p>This is mostly used for propagating an existing deadline. {@link #withDeadlineAfter} is the
-   * recommended way of setting a new deadline,
-   *
-   * @param deadline the deadline or {@code null} for unsetting the deadline.
-   */
-  public CallOptions withDeadline(@Nullable Deadline deadline) {
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.deadline = deadline;
-    return newOptions;
-  }
-
-  /**
-   * Returns a new {@code CallOptions} with a deadline that is after the given {@code duration} from
-   * now.
-   */
-  public CallOptions withDeadlineAfter(long duration, TimeUnit unit) {
-    return withDeadline(Deadline.after(duration, unit));
-  }
-
-  /**
-   * Returns the deadline or {@code null} if the deadline is not set.
-   */
-  @Nullable
-  public Deadline getDeadline() {
-    return deadline;
-  }
-
-  /**
-   * Returns a new {@code CallOptions} with attributes for affinity-based routing.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1766")
-  public CallOptions withAffinity(Attributes affinity) {
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.affinity = Preconditions.checkNotNull(affinity, "affinity");
-    return newOptions;
-  }
-
-  /**
-   * Enables 'wait for ready' feature for the call.
-   * <a href="https://github.com/grpc/grpc/blob/master/doc/fail_fast.md">'Fail fast'</a>
-   * is the default option for gRPC calls and 'wait for ready' is the opposite to it.
-   */
-  public CallOptions withWaitForReady() {
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.waitForReady = true;
-    return newOptions;
-  }
-
-  /**
-   * Disables 'wait for ready' feature for the call.
-   * This method should be rarely used because the default is without 'wait for ready'.
-   */
-  public CallOptions withoutWaitForReady() {
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.waitForReady = false;
-    return newOptions;
-  }
-
-  /**
-   * Returns the attributes for affinity-based routing.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1766")
-  public Attributes getAffinity() {
-    return affinity;
-  }
-
-  /**
-   * Returns the compressor's name.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-  @Nullable
-  public String getCompressor() {
-    return compressorName;
-  }
-
-  /**
-   * Override the HTTP/2 authority the channel claims to be connecting to. <em>This is not
-   * generally safe.</em> Overriding allows advanced users to re-use a single Channel for multiple
-   * services, even if those services are hosted on different domain names. That assumes the
-   * server is virtually hosting multiple domains and is guaranteed to continue doing so. It is
-   * rare for a service provider to make such a guarantee. <em>At this time, there is no security
-   * verification of the overridden value, such as making sure the authority matches the server's
-   * TLS certificate.</em>
-   */
-  @Nullable
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1767")
-  public String getAuthority() {
-    return authority;
-  }
-
-  /**
-   * Returns the call credentials.
-   */
-  @ExperimentalApi("https//github.com/grpc/grpc-java/issues/1914")
-  @Nullable
-  public CallCredentials getCredentials() {
-    return credentials;
-  }
-
-  /**
-   * Returns a new {@code CallOptions} with {@code executor} to be used instead of the default
-   * executor specified with {@link ManagedChannelBuilder#executor}.
-   */
-  public CallOptions withExecutor(Executor executor) {
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.executor = executor;
-    return newOptions;
-  }
-
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1869")
-  public static final class Key<T> {
-    private final String name;
-    private final T defaultValue;
-
-    private Key(String name, T defaultValue) {
-      this.name = name;
-      this.defaultValue = defaultValue;
-    }
-
-    public T getDefault() {
-      return defaultValue;
-    }
-
-    @Override
-    public String toString() {
-      return name;
-    }
-
-    /**
-     * Factory method for creating instances of {@link Key}.
-     *
-     * @param name the name of Key.
-     * @param defaultValue default value to return when value for key not set
-     * @param <T> Key type
-     * @return Key object
-     */
-    public static <T> Key<T> of(String name, T defaultValue) {
-      Preconditions.checkNotNull(name, "name");
-      return new Key<T>(name, defaultValue);
-    }
-  }
-
-  /**
-   * Sets a custom option. Any existing value for the key is overwritten.
-   *
-   * @param key The option key
-   * @param value The option value.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1869")
-  public <T> CallOptions withOption(Key<T> key, T value) {
-    Preconditions.checkNotNull(key, "key");
-    Preconditions.checkNotNull(value, "value");
-
-    CallOptions newOptions = new CallOptions(this);
-    int existingIdx = -1;
-    for (int i = 0; i < customOptions.length; i++) {
-      if (key.equals(customOptions[i][0])) {
-        existingIdx = i;
-        break;
-      }
-    }
-
-    newOptions.customOptions = new Object[customOptions.length + (existingIdx == -1 ? 1 : 0)][2];
-    System.arraycopy(customOptions, 0, newOptions.customOptions, 0, customOptions.length);
-
-    if (existingIdx == -1) {
-      // Add a new option
-      newOptions.customOptions[customOptions.length] = new Object[] {key, value};
-    } else {
-      // Replace an existing option
-      newOptions.customOptions[existingIdx][1] = value;
-    }
-
-    return newOptions;
-  }
-
-  /**
-   * Get the value for a custom option or its inherent default.
-   * @param key Key identifying option
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1869")
-  @SuppressWarnings("unchecked")
-  public <T> T getOption(Key<T> key) {
-    Preconditions.checkNotNull(key, "key");
-    for (int i = 0; i < customOptions.length; i++) {
-      if (key.equals(customOptions[i][0])) {
-        return (T) customOptions[i][1];
-      }
-    }
-    return key.defaultValue;
-  }
-
-  @Nullable
-  public Executor getExecutor() {
-    return executor;
-  }
-
-  private CallOptions() {
-  }
-
-  /**
-   * Returns whether 'wait for ready' option is enabled for the call.
-   * <a href="https://github.com/grpc/grpc/blob/master/doc/fail_fast.md">'Fail fast'</a>
-   * is the default option for gRPC calls and 'wait for ready' is the opposite to it.
-   */
-  public boolean isWaitForReady() {
-    return waitForReady;
-  }
-
-  /**
-   * Sets the maximum allowed message size acceptable from the remote peer.  If unset, this will
-   * default to the value set on the {@link ManagedChannelBuilder#maxInboundMessageSize(int)}.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2563")
-  public CallOptions withMaxInboundMessageSize(int maxSize) {
-    checkArgument(maxSize >= 0, "invalid maxsize %s", maxSize);
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.maxInboundMessageSize = maxSize;
-    return newOptions;
-  }
-
-  /**
-   * Sets the maximum allowed message size acceptable sent to the remote peer.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2563")
-  public CallOptions withMaxOutboundMessageSize(int maxSize) {
-    checkArgument(maxSize >= 0, "invalid maxsize %s", maxSize);
-    CallOptions newOptions = new CallOptions(this);
-    newOptions.maxOutboundMessageSize = maxSize;
-    return newOptions;
-  }
-
-  /**
-   * Gets the maximum allowed message size acceptable from the remote peer.
-   */
-  @Nullable
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2563")
-  public Integer getMaxInboundMessageSize() {
-    return maxInboundMessageSize;
-  }
-
-  /**
-   * Gets the maximum allowed message size acceptable to send the remote peer.
-   */
-  @Nullable
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2563")
-  public Integer getMaxOutboundMessageSize() {
-    return maxOutboundMessageSize;
-  }
-
-  /**
-   * Copy constructor.
-   */
-  private CallOptions(CallOptions other) {
-    deadline = other.deadline;
-    authority = other.authority;
-    credentials = other.credentials;
-    affinity = other.affinity;
-    executor = other.executor;
-    compressorName = other.compressorName;
-    customOptions = other.customOptions;
-    waitForReady = other.waitForReady;
-    maxInboundMessageSize = other.maxInboundMessageSize;
-    maxOutboundMessageSize = other.maxOutboundMessageSize;
-  }
-
-  @Override
-  public String toString() {
-    return MoreObjects.toStringHelper(this)
-        .add("deadline", deadline)
-        .add("authority", authority)
-        .add("callCredentials", credentials)
-        .add("affinity", affinity)
-        .add("executor", executor != null ? executor.getClass() : null)
-        .add("compressorName", compressorName)
-        .add("customOptions", Arrays.deepToString(customOptions))
-        .add("waitForReady", isWaitForReady())
-        .add("maxInboundMessageSize", maxInboundMessageSize)
-        .add("maxOutboundMessageSize", maxOutboundMessageSize)
-        .toString();
-  }
-}
diff --git a/core/src/main/java/io/grpc/Channel.java b/core/src/main/java/io/grpc/Channel.java
deleted file mode 100644
index e5333442aff..00000000000
--- a/core/src/main/java/io/grpc/Channel.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * A Channel provides an abstraction over the transport layer that is designed to be consumed
- * by stub implementations. Channel and its associated types {@link ClientCall} and
- * {@link ClientCall.Listener} exchange parsed request and response objects whereas the
- * transport layer only works with serialized data.
- *
- * <p>Applications can add common cross-cutting behaviors to stubs by decorating Channel
- * implementations using {@link ClientInterceptor}. It is expected that most application
- * code will not use this class directly but rather work with stubs that have been bound to a
- * Channel that was decorated during application initialization,
- */
-@ThreadSafe
-public abstract class Channel {
-  /**
-   * Create a {@link ClientCall} to the remote operation specified by the given
-   * {@link MethodDescriptor}. The returned {@link ClientCall} does not trigger any remote
-   * behavior until {@link ClientCall#start(ClientCall.Listener, Metadata)} is
-   * invoked.
-   *
-   * @param methodDescriptor describes the name and parameter types of the operation to call.
-   * @param callOptions runtime options to be applied to this call.
-   * @return a {@link ClientCall} bound to the specified method.
-   *
-   */
-  public abstract <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
-      MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions);
-
-  /**
-   * The authority of the destination this channel connects to. Typically this is in the format
-   * {@code host:port}.
-   */
-  public abstract String authority();
-}
diff --git a/core/src/main/java/io/grpc/ClientCall.java b/core/src/main/java/io/grpc/ClientCall.java
deleted file mode 100644
index d05def4a603..00000000000
--- a/core/src/main/java/io/grpc/ClientCall.java
+++ /dev/null
@@ -1,269 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.errorprone.annotations.DoNotMock;
-import javax.annotation.Nullable;
-
-/**
- * An instance of a call to a remote method. A call will send zero or more
- * request messages to the server and receive zero or more response messages back.
- *
- * <p>Instances are created
- * by a {@link Channel} and used by stubs to invoke their remote behavior.
- *
- * <p>More advanced usages may consume this interface directly as opposed to using a stub. Common
- * reasons for doing so would be the need to interact with flow-control or when acting as a generic
- * proxy for arbitrary operations.
- *
- * <p>{@link #start} must be called prior to calling any other methods, with the exception of
- * {@link #cancel}. Whereas {@link #cancel} must not be followed by any other methods,
- * but can be called more than once, while only the first one has effect.
- *
- * <p>No generic method for determining message receipt or providing acknowledgement is provided.
- * Applications are expected to utilize normal payload messages for such signals, as a response
- * naturally acknowledges its request.
- *
- * <p>Methods are guaranteed to be non-blocking. Implementations are not required to be thread-safe.
- *
- * <p>There is no interaction between the states on the {@link Listener Listener} and {@link
- * ClientCall}, i.e., if {@link Listener#onClose Listener.onClose()} is called, it has no bearing on
- * the permitted operations on {@code ClientCall} (but it may impact whether they do anything).
- *
- * <p>There is a race between {@link #cancel} and the completion/failure of the RPC in other ways.
- * If {@link #cancel} won the race, {@link Listener#onClose Listener.onClose()} is called with
- * {@link Status#CANCELLED CANCELLED}. Otherwise, {@link Listener#onClose Listener.onClose()} is
- * called with whatever status the RPC was finished. We ensure that at most one is called.
- *
- * <h3>Usage examples</h3>
- * <h4>Simple Unary (1 request, 1 response) RPC</h4>
- * <pre>
- *   call = channel.newCall(unaryMethod, callOptions);
- *   call.start(listener, headers);
- *   call.sendMessage(message);
- *   call.halfClose();
- *   call.request(1);
- *   // wait for listener.onMessage()
- * </pre>
- *
- * <h4>Flow-control in Streaming RPC</h4>
- *
- * <p>The following snippet demonstrates a bi-directional streaming case, where the client sends
- * requests produced by a fictional <code>makeNextRequest()</code> in a flow-control-compliant
- * manner, and notifies gRPC library to receive additional response after one is consumed by
- * a fictional <code>processResponse()</code>.
- *
- * <p><pre>
- *   call = channel.newCall(bidiStreamingMethod, callOptions);
- *   listener = new ClientCall.Listener&lt;FooResponse&gt;() {
- *     &#64;Override
- *     public void onMessage(FooResponse response) {
- *       processResponse(response);
- *       // Notify gRPC to receive one additional response.
- *       call.request(1);
- *     }
- *
- *     &#64;Override
- *     public void onReady() {
- *       while (call.isReady()) {
- *         FooRequest nextRequest = makeNextRequest();
- *         if (nextRequest == null) {  // No more requests to send
- *           call.halfClose();
- *           return;
- *         }
- *         call.sendMessage(nextRequest);
- *       }
- *     }
- *   }
- *   call.start(listener, headers);
- *   // Notify gRPC to receive one response. Without this line, onMessage() would never be called.
- *   call.request(1);
- * </pre>
- *
- * @param <ReqT> type of message sent one or more times to the server.
- * @param <RespT> type of message received one or more times from the server.
- */
-@DoNotMock("Use InProcessTransport and make a fake server instead")
-public abstract class ClientCall<ReqT, RespT> {
-  /**
-   * Callbacks for receiving metadata, response messages and completion status from the server.
-   *
-   * <p>Implementations are free to block for extended periods of time. Implementations are not
-   * required to be thread-safe.
-   */
-  public abstract static class Listener<T> {
-
-    /**
-     * The response headers have been received. Headers always precede messages.
-     *
-     * @param headers containing metadata sent by the server at the start of the response.
-     */
-    public void onHeaders(Metadata headers) {}
-
-    /**
-     * A response message has been received. May be called zero or more times depending on whether
-     * the call response is empty, a single message or a stream of messages.
-     *
-     * @param message returned by the server
-     */
-    public void onMessage(T message) {}
-
-    /**
-     * The ClientCall has been closed. Any additional calls to the {@code ClientCall} will not be
-     * processed by the server. No further receiving will occur and no further notifications will be
-     * made.
-     *
-     * <p>If {@code status} returns false for {@link Status#isOk()}, then the call failed.
-     * An additional block of trailer metadata may be received at the end of the call from the
-     * server. An empty {@link Metadata} object is passed if no trailers are received.
-     *
-     * @param status the result of the remote call.
-     * @param trailers metadata provided at call completion.
-     */
-    public void onClose(Status status, Metadata trailers) {}
-
-    /**
-     * This indicates that the ClientCall is now capable of sending additional messages (via
-     * {@link #sendMessage}) without requiring excessive buffering internally. This event is
-     * just a suggestion and the application is free to ignore it, however doing so may
-     * result in excessive buffering within the ClientCall.
-     */
-    public void onReady() {}
-  }
-
-  /**
-   * Start a call, using {@code responseListener} for processing response messages.
-   *
-   * <p>It must be called prior to any other method on this class, except for {@link #cancel} which
-   * may be called at any time. Since {@link Metadata} is not thread-safe, the caller must not
-   * access {@code headers} after this point.
-   *
-   * @param responseListener receives response messages
-   * @param headers which can contain extra call metadata, e.g. authentication credentials.
-   * @throws IllegalStateException if a method (including {@code start()}) on this class has been
-   *                               called.
-   */
-  public abstract void start(Listener<RespT> responseListener, Metadata headers);
-
-  /**
-   * Requests up to the given number of messages from the call to be delivered to
-   * {@link Listener#onMessage(Object)}. No additional messages will be delivered.
-   *
-   * <p>Message delivery is guaranteed to be sequential in the order received. In addition, the
-   * listener methods will not be accessed concurrently. While it is not guaranteed that the same
-   * thread will always be used, it is guaranteed that only a single thread will access the listener
-   * at a time.
-   *
-   * <p>If it is desired to bypass inbound flow control, a very large number of messages can be
-   * specified (e.g. {@link Integer#MAX_VALUE}).
-   *
-   * <p>If called multiple times, the number of messages able to delivered will be the sum of the
-   * calls.
-   *
-   * <p>This method is safe to call from multiple threads without external synchronizaton.
-   *
-   * @param numMessages the requested number of messages to be delivered to the listener. Must be
-   *                    non-negative.
-   */
-  public abstract void request(int numMessages);
-
-  /**
-   * Prevent any further processing for this {@code ClientCall}. No further messages may be sent or
-   * will be received. The server is informed of cancellations, but may not stop processing the
-   * call. Cancellation is permitted if previously {@link #halfClose}d. Cancelling an already {@code
-   * cancel()}ed {@code ClientCall} has no effect.
-   *
-   * <p>No other methods on this class can be called after this method has been called.
-   *
-   * <p>It is recommended that at least one of the arguments to be non-{@code null}, to provide
-   * useful debug information. Both argument being null may log warnings and result in suboptimal
-   * performance. Also note that the provided information will not be sent to the server.
-   *
-   * @param message if not {@code null}, will appear as the description of the CANCELLED status
-   * @param cause if not {@code null}, will appear as the cause of the CANCELLED status
-   */
-  public abstract void cancel(@Nullable String message, @Nullable Throwable cause);
-
-  /**
-   * Close the call for request message sending. Incoming response messages are unaffected.  This
-   * should be called when no more messages will be sent from the client.
-   *
-   * @throws IllegalStateException if call is already {@code halfClose()}d or {@link #cancel}ed
-   */
-  public abstract void halfClose();
-
-  /**
-   * Send a request message to the server. May be called zero or more times depending on how many
-   * messages the server is willing to accept for the operation.
-   *
-   * @param message message to be sent to the server.
-   * @throws IllegalStateException if call is {@link #halfClose}d or explicitly {@link #cancel}ed
-   */
-  public abstract void sendMessage(ReqT message);
-
-  /**
-   * If {@code true}, indicates that the call is capable of sending additional messages
-   * without requiring excessive buffering internally. This event is
-   * just a suggestion and the application is free to ignore it, however doing so may
-   * result in excessive buffering within the call.
-   *
-   * <p>This implementation always returns {@code true}.
-   */
-  public boolean isReady() {
-    return true;
-  }
-
-  /**
-   * Enables per-message compression, if an encoding type has been negotiated.  If no message
-   * encoding has been negotiated, this is a no-op. By default per-message compression is enabled,
-   * but may not have any effect if compression is not enabled on the call.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1703")
-  public void setMessageCompression(boolean enabled) {
-    // noop
-  }
-
-  /**
-   * Returns additional properties of the call. May only be called after {@link Listener#onHeaders}
-   * or {@link Listener#onClose}. If called prematurely, the implementation may throw {@code
-   * IllegalStateException} or return abitrary {@code Attributes}.
-   *
-   * <p>{@link Grpc} defines commonly used attributes, but they are not guaranteed to be present.
-   *
-   * @return non-{@code null} attributes
-   * @throws IllegalStateException (optional) if called before permitted
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2607")
-  public Attributes getAttributes() {
-    return Attributes.EMPTY;
-  }
-}
diff --git a/core/src/main/java/io/grpc/ClientInterceptor.java b/core/src/main/java/io/grpc/ClientInterceptor.java
deleted file mode 100644
index f8350d776ad..00000000000
--- a/core/src/main/java/io/grpc/ClientInterceptor.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * Interface for intercepting outgoing calls before they are dispatched by a {@link Channel}.
- *
- * <p>Implementers use this mechanism to add cross-cutting behavior to {@link Channel} and
- * stub implementations. Common examples of such behavior include:
- * <ul>
- * <li>Adding credentials to header metadata</li>
- * <li>Logging and monitoring call behavior</li>
- * <li>Request and response rewriting</li>
- * </ul>
- */
-@ThreadSafe
-public interface ClientInterceptor {
-  /**
-   * Intercept {@link ClientCall} creation by the {@code next} {@link Channel}.
-   *
-   * <p>Many variations of interception are possible. Complex implementations may return a wrapper
-   * around the result of {@code next.newCall()}, whereas a simpler implementation may just modify
-   * the header metadata prior to returning the result of {@code next.newCall()}.
-   *
-   * @param method the remote method to be called.
-   * @param callOptions the runtime options to be applied to this call.
-   * @param next the channel which is being intercepted.
-   * @return the call object for the remote operation, never {@code null}.
-   */
-  <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
-      MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next);
-}
diff --git a/core/src/main/java/io/grpc/ClientInterceptors.java b/core/src/main/java/io/grpc/ClientInterceptors.java
deleted file mode 100644
index 01cff324cab..00000000000
--- a/core/src/main/java/io/grpc/ClientInterceptors.java
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.common.base.Preconditions;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * Utility methods for working with {@link ClientInterceptor}s.
- */
-public class ClientInterceptors {
-
-  // Prevent instantiation
-  private ClientInterceptors() {}
-
-  /**
-   * Create a new {@link Channel} that will call {@code interceptors} before starting a call on the
-   * given channel. The first interceptor will have its {@link ClientInterceptor#interceptCall}
-   * called first.
-   *
-   * @param channel the underlying channel to intercept.
-   * @param interceptors array of interceptors to bind to {@code channel}.
-   * @return a new channel instance with the interceptors applied.
-   */
-  public static Channel interceptForward(Channel channel, ClientInterceptor... interceptors) {
-    return interceptForward(channel, Arrays.asList(interceptors));
-  }
-
-  /**
-   * Create a new {@link Channel} that will call {@code interceptors} before starting a call on the
-   * given channel. The first interceptor will have its {@link ClientInterceptor#interceptCall}
-   * called first.
-   *
-   * @param channel the underlying channel to intercept.
-   * @param interceptors a list of interceptors to bind to {@code channel}.
-   * @return a new channel instance with the interceptors applied.
-   */
-  public static Channel interceptForward(Channel channel,
-                                         List<? extends ClientInterceptor> interceptors) {
-    List<? extends ClientInterceptor> copy = new ArrayList<ClientInterceptor>(interceptors);
-    Collections.reverse(copy);
-    return intercept(channel, copy);
-  }
-
-  /**
-   * Create a new {@link Channel} that will call {@code interceptors} before starting a call on the
-   * given channel. The last interceptor will have its {@link ClientInterceptor#interceptCall}
-   * called first.
-   *
-   * @param channel the underlying channel to intercept.
-   * @param interceptors array of interceptors to bind to {@code channel}.
-   * @return a new channel instance with the interceptors applied.
-   */
-  public static Channel intercept(Channel channel, ClientInterceptor... interceptors) {
-    return intercept(channel, Arrays.asList(interceptors));
-  }
-
-  /**
-   * Create a new {@link Channel} that will call {@code interceptors} before starting a call on the
-   * given channel. The last interceptor will have its {@link ClientInterceptor#interceptCall}
-   * called first.
-   *
-   * @param channel the underlying channel to intercept.
-   * @param interceptors a list of interceptors to bind to {@code channel}.
-   * @return a new channel instance with the interceptors applied.
-   */
-  public static Channel intercept(Channel channel, List<? extends ClientInterceptor> interceptors) {
-    Preconditions.checkNotNull(channel, "channel");
-    for (ClientInterceptor interceptor : interceptors) {
-      channel = new InterceptorChannel(channel, interceptor);
-    }
-    return channel;
-  }
-
-  private static class InterceptorChannel extends Channel {
-    private final Channel channel;
-    private final ClientInterceptor interceptor;
-
-    private InterceptorChannel(Channel channel, ClientInterceptor interceptor) {
-      this.channel = channel;
-      this.interceptor = Preconditions.checkNotNull(interceptor, "interceptor");
-    }
-
-    @Override
-    public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(
-        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions) {
-      return interceptor.interceptCall(method, callOptions, channel);
-    }
-
-    @Override
-    public String authority() {
-      return channel.authority();
-    }
-  }
-
-  private static final ClientCall<Object, Object> NOOP_CALL = new ClientCall<Object, Object>() {
-    @Override
-    public void start(Listener<Object> responseListener, Metadata headers) {}
-
-    @Override
-    public void request(int numMessages) {}
-
-    @Override
-    public void cancel(String message, Throwable cause) {}
-
-    @Override
-    public void halfClose() {}
-
-    @Override
-    public void sendMessage(Object message) {}
-
-    /**
-     * Always returns {@code false}, since this is only used when the startup of the {@link
-     * ClientCall} fails (i.e. the {@link ClientCall} is closed).
-     */
-    @Override
-    public boolean isReady() {
-      return false;
-    }
-  };
-
-  /**
-   * A {@link io.grpc.ForwardingClientCall} that delivers exceptions from its start logic to the
-   * call listener.
-   *
-   * <p>{@link ClientCall#start(ClientCall.Listener, Metadata)} should not throw any
-   * exception other than those caused by misuse, e.g., {@link IllegalStateException}.  {@code
-   * CheckedForwardingClientCall} provides {@code checkedStart()} in which throwing exceptions is
-   * allowed.
-   */
-  public abstract static class CheckedForwardingClientCall<ReqT, RespT>
-      extends io.grpc.ForwardingClientCall<ReqT, RespT> {
-
-    private ClientCall<ReqT, RespT> delegate;
-
-    /**
-     * Subclasses implement the start logic here that would normally belong to {@code start()}.
-     *
-     * <p>Implementation should call {@code this.delegate().start()} in the normal path. Exceptions
-     * may safely be thrown prior to calling {@code this.delegate().start()}. Such exceptions will
-     * be handled by {@code CheckedForwardingClientCall} and be delivered to {@code
-     * responseListener}.  Exceptions <em>must not</em> be thrown after calling {@code
-     * this.delegate().start()}, as this can result in {@link ClientCall.Listener#onClose} being
-     * called multiple times.
-     */
-    protected abstract void checkedStart(Listener<RespT> responseListener, Metadata headers)
-        throws Exception;
-
-    protected CheckedForwardingClientCall(ClientCall<ReqT, RespT> delegate) {
-      this.delegate = delegate;
-    }
-
-    @Override
-    protected final ClientCall<ReqT, RespT> delegate() {
-      return delegate;
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public final void start(Listener<RespT> responseListener, Metadata headers) {
-      try {
-        checkedStart(responseListener, headers);
-      } catch (Exception e) {
-        // Because start() doesn't throw, the caller may still try to call other methods on this
-        // call object. Passing these invocations to the original delegate will cause
-        // IllegalStateException because delegate().start() was not called. We switch the delegate
-        // to a NO-OP one to prevent the IllegalStateException. The user will finally get notified
-        // about the error through the listener.
-        delegate = (ClientCall<ReqT, RespT>) NOOP_CALL;
-        responseListener.onClose(Status.fromThrowable(e), new Metadata());
-      }
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/Codec.java b/core/src/main/java/io/grpc/Codec.java
deleted file mode 100644
index 4fb30845924..00000000000
--- a/core/src/main/java/io/grpc/Codec.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.util.zip.GZIPInputStream;
-import java.util.zip.GZIPOutputStream;
-
-/**
- * Encloses classes related to the compression and decompression of messages.
- *
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-public interface Codec extends Compressor, Decompressor {
-  /**
-   * A gzip compressor and decompressor.  In the future this will likely support other
-   * compression methods, such as compression level.
-   */
-  public static final class Gzip implements Codec {
-    @Override
-    public String getMessageEncoding() {
-      return "gzip";
-    }
-
-    @Override
-    public OutputStream compress(OutputStream os) throws IOException {
-      return new GZIPOutputStream(os);
-    }
-
-    @Override
-    public InputStream decompress(InputStream is) throws IOException {
-      return new GZIPInputStream(is);
-    }
-  }
-
-  /**
-   * The "identity", or "none" codec.  This codec is special in that it can be used to explicitly
-   * disable Call compression on a Channel that by default compresses.
-   */
-  public static final class Identity implements Codec {
-    /**
-     * Special sentinel codec indicating that no compression should be used.  Users should use
-     * reference equality to see if compression is disabled.
-     */
-    public static final Codec NONE = new Identity();
-
-    @Override
-    public InputStream decompress(InputStream is) throws IOException {
-      return is;
-    }
-
-    @Override
-    public String getMessageEncoding() {
-      return "identity";
-    }
-
-    @Override
-    public OutputStream compress(OutputStream os) throws IOException {
-      return os;
-    }
-
-    private Identity() {}
-  }
-}
diff --git a/core/src/main/java/io/grpc/Compressor.java b/core/src/main/java/io/grpc/Compressor.java
deleted file mode 100644
index 85fe97b885f..00000000000
--- a/core/src/main/java/io/grpc/Compressor.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.io.IOException;
-import java.io.OutputStream;
-
-/**
- * Represents a message compressor.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-public interface Compressor {
-  /**
-   * Returns the message encoding that this compressor uses.
-   *
-   * <p>This can be values such as "gzip", "deflate", "snappy", etc.
-   */
-  String getMessageEncoding();
-
-  /**
-   * Wraps an existing output stream with a compressing output stream.
-   * @param os The output stream of uncompressed data
-   * @return An output stream that compresses
-   */
-  OutputStream compress(OutputStream os) throws IOException;
-}
-
diff --git a/core/src/main/java/io/grpc/CompressorRegistry.java b/core/src/main/java/io/grpc/CompressorRegistry.java
deleted file mode 100644
index 9412a8bf8f1..00000000000
--- a/core/src/main/java/io/grpc/CompressorRegistry.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.common.annotations.VisibleForTesting;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * Encloses classes related to the compression and decompression of messages.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-@ThreadSafe
-public final class CompressorRegistry {
-  private static final CompressorRegistry DEFAULT_INSTANCE = new CompressorRegistry(
-      new Codec.Gzip(),
-      Codec.Identity.NONE);
-
-  public static CompressorRegistry getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  public static CompressorRegistry newEmptyInstance() {
-    return new CompressorRegistry();
-  }
-
-  private final ConcurrentMap<String, Compressor> compressors;
-
-  @VisibleForTesting
-  CompressorRegistry(Compressor ...cs) {
-    compressors = new ConcurrentHashMap<String, Compressor>();
-    for (Compressor c : cs) {
-      compressors.put(c.getMessageEncoding(), c);
-    }
-  }
-
-  @Nullable
-  public Compressor lookupCompressor(String compressorName) {
-    return compressors.get(compressorName);
-  }
-
-  /**
-   * Registers a compressor for both decompression and message encoding negotiation.
-   *
-   * @param c The compressor to register
-   */
-  public void register(Compressor c) {
-    String encoding = c.getMessageEncoding();
-    checkArgument(!encoding.contains(","), "Comma is currently not allowed in message encoding");
-    compressors.put(encoding, c);
-  }
-}
diff --git a/core/src/main/java/io/grpc/ConnectivityState.java b/core/src/main/java/io/grpc/ConnectivityState.java
deleted file mode 100644
index 419d01013e6..00000000000
--- a/core/src/main/java/io/grpc/ConnectivityState.java
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-/**
- * The connectivity states.
- *
- * @see <a href="https://github.com/grpc/grpc/blob/master/doc/connectivity-semantics-and-api.md">
- * more information</a>
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/28")
-public enum ConnectivityState {
-  /**
-   * The channel is trying to establish a connection and is waiting to make progress on one of the
-   * steps involved in name resolution, TCP connection establishment or TLS handshake. This may be
-   * used as the initial state for channels upon creation.
-   */
-  CONNECTING,
-
-  /**
-   * The channel has successfully established a connection all the way through TLS handshake (or
-   * equivalent) and all subsequent attempt to communicate have succeeded (or are pending without
-   * any known failure ).
-   */
-  READY,
-
-  /**
-   * There has been some transient failure (such as a TCP 3-way handshake timing out or a socket
-   * error). Channels in this state will eventually switch to the CONNECTING state and try to
-   * establish a connection again. Since retries are done with exponential backoff, channels that
-   * fail to connect will start out spending very little time in this state but as the attempts
-   * fail repeatedly, the channel will spend increasingly large amounts of time in this state. For
-   * many non-fatal failures (e.g., TCP connection attempts timing out because the server is not
-   * yet available), the channel may spend increasingly large amounts of time in this state.
-   */
-  TRANSIENT_FAILURE,
-
-  /**
-   * This is the state where the channel is not even trying to create a connection because of a
-   * lack of new or pending RPCs. New RPCs MAY be created in this state. Any attempt to start an
-   * RPC on the channel will push the channel out of this state to connecting. When there has been
-   * no RPC activity on a channel for a configurable IDLE_TIMEOUT, i.e., no new or pending (active)
-   * RPCs for this period, channels that are READY or CONNECTING switch to IDLE. Additionaly,
-   * channels that receive a GOAWAY when there are no active or pending RPCs should also switch to
-   * IDLE to avoid connection overload at servers that are attempting to shed connections.
-   */
-  IDLE,
-
-  /**
-   * This channel has started shutting down. Any new RPCs should fail immediately. Pending RPCs
-   * may continue running till the application cancels them. Channels may enter this state either
-   * because the application explicitly requested a shutdown or if a non-recoverable error has
-   * happened during attempts to connect communicate . (As of 6/12/2015, there are no known errors
-   * (while connecting or communicating) that are classified as non-recoverable) Channels that
-   * enter this state never leave this state.
-   */
-  SHUTDOWN
-}
diff --git a/core/src/main/java/io/grpc/ConnectivityStateInfo.java b/core/src/main/java/io/grpc/ConnectivityStateInfo.java
deleted file mode 100644
index 8b813fced8f..00000000000
--- a/core/src/main/java/io/grpc/ConnectivityStateInfo.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.common.base.Preconditions;
-
-/**
- * A tuple of a {@link ConnectivityState} and its associated {@link Status}.
- *
- * <p>If the state is {@code TRANSIENT_FAILURE}, the status is never {@code OK}.  For other states,
- * the status is always {@code OK}.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
-public final class ConnectivityStateInfo {
-  private final ConnectivityState state;
-  private final Status status;
-
-  /**
-   * Returns an instance for a state that is not {@code TRANSIENT_FAILURE}.
-   *
-   * @throws IllegalArgumentException if {@code state} is {@code TRANSIENT_FAILURE}.
-   */
-  public static ConnectivityStateInfo forNonError(ConnectivityState state) {
-    Preconditions.checkArgument(state != ConnectivityState.TRANSIENT_FAILURE,
-        "state is TRANSIENT_ERROR. Use forError() instead");
-    return new ConnectivityStateInfo(state, Status.OK);
-  }
-
-  /**
-   * Returns an instance for {@code TRANSIENT_FAILURE}, associated with an error status.
-   */
-  public static ConnectivityStateInfo forTransientFailure(Status error) {
-    Preconditions.checkArgument(!error.isOk(), "The error status must not be OK");
-    return new ConnectivityStateInfo(ConnectivityState.TRANSIENT_FAILURE, error);
-  }
-
-  /**
-   * Returns the state.
-   */
-  public ConnectivityState getState() {
-    return state;
-  }
-
-  /**
-   * Returns the status associated with the state.
-   *
-   * <p>If the state is {@code TRANSIENT_FAILURE}, the status is never {@code OK}.  For other
-   * states, the status is always {@code OK}.
-   */
-  public Status getStatus() {
-    return status;
-  }
-
-  @Override
-  public boolean equals(Object other) {
-    if (!(other instanceof ConnectivityStateInfo)) {
-      return false;
-    }
-    ConnectivityStateInfo o = (ConnectivityStateInfo) other;
-    return state.equals(o.state) && status.equals(o.status);
-  }
-
-  @Override
-  public int hashCode() {
-    return state.hashCode() ^ status.hashCode();
-  }
-
-  @Override
-  public String toString() {
-    if (status.isOk()) {
-      return state.toString();
-    }
-    return state + "(" + status + ")";
-  }
-
-  private ConnectivityStateInfo(ConnectivityState state, Status status) {
-    this.state = Preconditions.checkNotNull(state, "state is null");
-    this.status = Preconditions.checkNotNull(status, "status is null");
-  }
-}
diff --git a/core/src/main/java/io/grpc/Contexts.java b/core/src/main/java/io/grpc/Contexts.java
deleted file mode 100644
index f71ea2497e4..00000000000
--- a/core/src/main/java/io/grpc/Contexts.java
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.common.base.Preconditions;
-import java.util.concurrent.TimeoutException;
-
-/**
- * Utility methods for working with {@link Context}s in GRPC.
- */
-public final class Contexts {
-
-  private Contexts() {
-  }
-
-  /**
-   * Make the provided {@link Context} {@link Context#current()} for the creation of a listener
-   * to a received call and for all events received by that listener.
-   *
-   * <p>This utility is expected to be used by {@link ServerInterceptor} implementations that need
-   * to augment the {@link Context} in which the application does work when receiving events from
-   * the client.
-   *
-   * @param context to make {@link Context#current()}.
-   * @param call used to send responses to client.
-   * @param headers received from client.
-   * @param next handler used to create the listener to be wrapped.
-   * @return listener that will receive events in the scope of the provided context.
-   */
-  public static <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
-        Context context,
-        ServerCall<ReqT, RespT> call,
-        Metadata headers,
-        ServerCallHandler<ReqT, RespT> next) {
-    Context previous = context.attach();
-    try {
-      return new ContextualizedServerCallListener<ReqT>(
-          next.startCall(call, headers),
-          context);
-    } finally {
-      context.detach(previous);
-    }
-  }
-
-  /**
-   * Implementation of {@link io.grpc.ForwardingServerCallListener} that attaches a context before
-   * dispatching calls to the delegate and detaches them after the call completes.
-   */
-  private static class ContextualizedServerCallListener<ReqT> extends
-      ForwardingServerCallListener.SimpleForwardingServerCallListener<ReqT> {
-    private final Context context;
-
-    public ContextualizedServerCallListener(ServerCall.Listener<ReqT> delegate, Context context) {
-      super(delegate);
-      this.context = context;
-    }
-
-    @Override
-    public void onMessage(ReqT message) {
-      Context previous = context.attach();
-      try {
-        super.onMessage(message);
-      } finally {
-        context.detach(previous);
-      }
-    }
-
-    @Override
-    public void onHalfClose() {
-      Context previous = context.attach();
-      try {
-        super.onHalfClose();
-      } finally {
-        context.detach(previous);
-      }
-    }
-
-    @Override
-    public void onCancel() {
-      Context previous = context.attach();
-      try {
-        super.onCancel();
-      } finally {
-        context.detach(previous);
-      }
-    }
-
-    @Override
-    public void onComplete() {
-      Context previous = context.attach();
-      try {
-        super.onComplete();
-      } finally {
-        context.detach(previous);
-      }
-    }
-
-    @Override
-    public void onReady() {
-      Context previous = context.attach();
-      try {
-        super.onReady();
-      } finally {
-        context.detach(previous);
-      }
-    }
-  }
-
-  /**
-   * Returns the {@link Status} of a cancelled context or {@code null} if the context
-   * is not cancelled.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1975")
-  public static Status statusFromCancelled(Context context) {
-    Preconditions.checkNotNull(context, "context must not be null");
-    if (!context.isCancelled()) {
-      return null;
-    }
-
-    Throwable cancellationCause = context.cancellationCause();
-    if (cancellationCause == null) {
-      return Status.CANCELLED;
-    }
-    if (cancellationCause instanceof TimeoutException) {
-      return Status.DEADLINE_EXCEEDED
-          .withDescription(cancellationCause.getMessage())
-          .withCause(cancellationCause);
-    }
-    Status status = Status.fromThrowable(cancellationCause);
-    if (Status.Code.UNKNOWN.equals(status.getCode())
-        && status.getCause() == cancellationCause) {
-      // If fromThrowable could not determine a status, then
-      // just return CANCELLED.
-      return Status.CANCELLED.withCause(cancellationCause);
-    }
-    return status.withCause(cancellationCause);
-  }
-}
diff --git a/core/src/main/java/io/grpc/Decompressor.java b/core/src/main/java/io/grpc/Decompressor.java
deleted file mode 100644
index 108c3515bd4..00000000000
--- a/core/src/main/java/io/grpc/Decompressor.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.io.IOException;
-import java.io.InputStream;
-
-/**
- * Represents a message decompressor.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-public interface Decompressor {
-  /**
-   * Returns the message encoding that this compressor uses.
-   *
-   * <p>This can be values such as "gzip", "deflate", "snappy", etc.
-   */
-  String getMessageEncoding();
-
-  /**
-   * Wraps an existing input stream with a decompressing input stream.
-   * @param is The input stream of uncompressed data
-   * @return An input stream that decompresses
-   */
-  InputStream decompress(InputStream is) throws IOException;
-}
-
diff --git a/core/src/main/java/io/grpc/DecompressorRegistry.java b/core/src/main/java/io/grpc/DecompressorRegistry.java
deleted file mode 100644
index 606c4b611d3..00000000000
--- a/core/src/main/java/io/grpc/DecompressorRegistry.java
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.base.Joiner;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * Encloses classes related to the compression and decompression of messages.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-@ThreadSafe
-public final class DecompressorRegistry {
-  static final Joiner ACCEPT_ENCODING_JOINER = Joiner.on(',');
-
-  public static DecompressorRegistry emptyInstance() {
-    return new DecompressorRegistry();
-  }
-
-  private static final DecompressorRegistry DEFAULT_INSTANCE =
-      emptyInstance()
-      .with(new Codec.Gzip(), true)
-      .with(Codec.Identity.NONE, false);
-
-  public static DecompressorRegistry getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private final Map<String, DecompressorInfo> decompressors;
-  private final String advertisedDecompressors;
-
-  /**
-   * Registers a decompressor for both decompression and message encoding negotiation.  Returns a
-   * new registry.
-   *
-   * @param d The decompressor to register
-   * @param advertised If true, the message encoding will be listed in the Accept-Encoding header.
-   */
-  public DecompressorRegistry with(Decompressor d, boolean advertised) {
-    return new DecompressorRegistry(d, advertised, this);
-  }
-
-  private DecompressorRegistry(Decompressor d, boolean advertised, DecompressorRegistry parent) {
-    String encoding = d.getMessageEncoding();
-    checkArgument(!encoding.contains(","), "Comma is currently not allowed in message encoding");
-
-    int newSize = parent.decompressors.size();
-    if (!parent.decompressors.containsKey(d.getMessageEncoding())) {
-      newSize++;
-    }
-    Map<String, DecompressorInfo> newDecompressors =
-        new LinkedHashMap<String, DecompressorInfo>(newSize);
-    for (DecompressorInfo di : parent.decompressors.values()) {
-      String previousEncoding = di.decompressor.getMessageEncoding();
-      if (!previousEncoding.equals(encoding)) {
-        newDecompressors.put(
-            previousEncoding, new DecompressorInfo(di.decompressor, di.advertised));
-      }
-    }
-    newDecompressors.put(encoding, new DecompressorInfo(d, advertised));
-
-    decompressors = Collections.unmodifiableMap(newDecompressors);
-    advertisedDecompressors = ACCEPT_ENCODING_JOINER.join(getAdvertisedMessageEncodings());
-  }
-
-  private DecompressorRegistry() {
-    decompressors = new LinkedHashMap<String, DecompressorInfo>(0);
-    advertisedDecompressors = "";
-  }
-
-  /**
-   * Provides a list of all message encodings that have decompressors available.
-   */
-  public Set<String> getKnownMessageEncodings() {
-    return decompressors.keySet();
-  }
-
-  public String getRawAdvertisedMessageEncodings() {
-    return advertisedDecompressors;
-  }
-
-  /**
-   * Provides a list of all message encodings that have decompressors available and should be
-   * advertised.
-   *
-   * <p>The specification doesn't say anything about ordering, or preference, so the returned codes
-   * can be arbitrary.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-  public Set<String> getAdvertisedMessageEncodings() {
-    Set<String> advertisedDecompressors = new HashSet<String>(decompressors.size());
-    for (Entry<String, DecompressorInfo> entry : decompressors.entrySet()) {
-      if (entry.getValue().advertised) {
-        advertisedDecompressors.add(entry.getKey());
-      }
-    }
-    return Collections.unmodifiableSet(advertisedDecompressors);
-  }
-
-  /**
-   * Returns a decompressor for the given message encoding, or {@code null} if none has been
-   * registered.
-   *
-   * <p>This ignores whether the compressor is advertised.  According to the spec, if we know how
-   * to process this encoding, we attempt to, regardless of whether or not it is part of the
-   * encodings sent to the remote host.
-   */
-  @Nullable
-  public Decompressor lookupDecompressor(String messageEncoding) {
-    DecompressorInfo info = decompressors.get(messageEncoding);
-    return info != null ? info.decompressor : null;
-  }
-
-  /**
-   * Information about a decompressor.
-   */
-  private static final class DecompressorInfo {
-    final Decompressor decompressor;
-    final boolean advertised;
-
-    DecompressorInfo(Decompressor decompressor, boolean advertised) {
-      this.decompressor = checkNotNull(decompressor, "decompressor");
-      this.advertised = advertised;
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/Drainable.java b/core/src/main/java/io/grpc/Drainable.java
deleted file mode 100644
index 11bec3c3588..00000000000
--- a/core/src/main/java/io/grpc/Drainable.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.io.IOException;
-import java.io.OutputStream;
-
-/**
- * Extension to an {@link java.io.InputStream} or alike by adding a method that transfers all
- * content to an {@link OutputStream}.
- *
- * <p>This can be used for optimizing for the case where the content of the input stream will be
- * written to an {@link OutputStream} eventually. Instead of copying the content to a byte array
- * through {@code read()}, then writing the the {@code OutputStream}, the implementation can write
- * the content directly to the {@code OutputStream}.
- */
-public interface Drainable {
-
-  /**
-   * Transfers the entire contents of this stream to the specified target.
-   *
-   * @param target to write to.
-   * @return number of bytes written.
-   */
-  int drainTo(OutputStream target) throws IOException;
-}
diff --git a/core/src/main/java/io/grpc/EquivalentAddressGroup.java b/core/src/main/java/io/grpc/EquivalentAddressGroup.java
deleted file mode 100644
index d398bbef373..00000000000
--- a/core/src/main/java/io/grpc/EquivalentAddressGroup.java
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.common.base.Preconditions;
-import java.net.SocketAddress;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * A group of {@link SocketAddress}es that are considered equivalent when channel makes connections.
- *
- * <p>Usually the addresses are addresses resolved from the same host name, and connecting to any of
- * them is equally sufficient. They do have order. An address appears earlier on the list is likely
- * to be tried earlier.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
-public final class EquivalentAddressGroup {
-
-  private final List<SocketAddress> addrs;
-
-  /**
-   * {@link SocketAddress} docs say that the addresses are immutable, so we cache the hashCode.
-   */
-  private final int hashCode;
-
-  /**
-   * List constructor.
-   */
-  public EquivalentAddressGroup(List<SocketAddress> addrs) {
-    Preconditions.checkArgument(!addrs.isEmpty(), "addrs is empty");
-    this.addrs = Collections.unmodifiableList(new ArrayList<SocketAddress>(addrs));
-    hashCode = this.addrs.hashCode();
-  }
-
-  /**
-   * Singleton constructor.
-   */
-  public EquivalentAddressGroup(SocketAddress addr) {
-    this.addrs = Collections.singletonList(addr);
-    hashCode = addrs.hashCode();
-  }
-
-  /**
-   * Returns an immutable list of the addresses.
-   */
-  public List<SocketAddress> getAddresses() {
-    return addrs;
-  }
-
-  @Override
-  public String toString() {
-    return addrs.toString();
-  }
-
-  @Override
-  public int hashCode() {
-    // Avoids creating an iterator on the underlying array list.
-    return hashCode;
-  }
-
-  @Override
-  public boolean equals(Object other) {
-    if (!(other instanceof EquivalentAddressGroup)) {
-      return false;
-    }
-    EquivalentAddressGroup that = (EquivalentAddressGroup) other;
-    if (addrs.size() != that.addrs.size()) {
-      return false;
-    }
-    // Avoids creating an iterator on the underlying array list.
-    for (int i = 0; i < addrs.size(); i++) {
-      if (!addrs.get(i).equals(that.addrs.get(i))) {
-        return false;
-      }
-    }
-    return true;
-  }
-}
diff --git a/core/src/main/java/io/grpc/ExperimentalApi.java b/core/src/main/java/io/grpc/ExperimentalApi.java
deleted file mode 100644
index 4a57ee8179b..00000000000
--- a/core/src/main/java/io/grpc/ExperimentalApi.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Indicates a public API that can change at any time, and has no guarantee of API stability and
- * backward-compatibility.
- *
- * <p>Usage guidelines:
- * <ol>
- * <li>This annotation is used only on public API. Internal interfaces should not use it.</li>
- * <li>After gRPC has gained API stability, this annotation can only be added to new API. Adding it
- * to an existing API is considered API-breaking.</li>
- * <li>Removing this annotation from an API gives it stable status.</li>
- * </ol>
- */
-@Internal
-@Retention(RetentionPolicy.SOURCE)
-@Target({
-    ElementType.ANNOTATION_TYPE,
-    ElementType.CONSTRUCTOR,
-    ElementType.FIELD,
-    ElementType.METHOD,
-    ElementType.PACKAGE,
-    ElementType.TYPE})
-@Documented
-public @interface ExperimentalApi {
-  /**
-   * Context information such as links to discussion thread, tracking issue etc.
-   */
-  String value() default "";
-}
diff --git a/core/src/main/java/io/grpc/ForwardingClientCall.java b/core/src/main/java/io/grpc/ForwardingClientCall.java
deleted file mode 100644
index c1c993baee8..00000000000
--- a/core/src/main/java/io/grpc/ForwardingClientCall.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import javax.annotation.Nullable;
-
-/**
- * A {@link ClientCall} which forwards all of it's methods to another {@link ClientCall}.
- */
-public abstract class ForwardingClientCall<ReqT, RespT> extends ClientCall<ReqT, RespT> {
-  /**
-   * Returns the delegated {@code ClientCall}.
-   */
-  protected abstract ClientCall<ReqT, RespT> delegate();
-
-  @Override
-  public void start(Listener<RespT> responseListener, Metadata headers) {
-    delegate().start(responseListener, headers);
-  }
-
-  @Override
-  public void request(int numMessages) {
-    delegate().request(numMessages);
-  }
-
-  @Override
-  public void cancel(@Nullable String message, @Nullable Throwable cause) {
-    delegate().cancel(message, cause);
-  }
-
-  @Override
-  public void halfClose() {
-    delegate().halfClose();
-  }
-
-  @Override
-  public void sendMessage(ReqT message) {
-    delegate().sendMessage(message);
-  }
-
-  @Override
-  public void setMessageCompression(boolean enabled) {
-    delegate().setMessageCompression(enabled);
-  }
-
-  @Override
-  public boolean isReady() {
-    return delegate().isReady();
-  }
-
-  @Override
-  public Attributes getAttributes() {
-    return delegate().getAttributes();
-  }
-
-  /**
-   * A simplified version of {@link ForwardingClientCall} where subclasses can pass in a {@link
-   * ClientCall} as the delegate.
-   */
-  public abstract static class SimpleForwardingClientCall<ReqT, RespT>
-      extends ForwardingClientCall<ReqT, RespT> {
-    private final ClientCall<ReqT, RespT> delegate;
-
-    protected SimpleForwardingClientCall(ClientCall<ReqT, RespT> delegate) {
-      this.delegate = delegate;
-    }
-
-    @Override
-    protected ClientCall<ReqT, RespT> delegate() {
-      return delegate;
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/ForwardingClientCallListener.java b/core/src/main/java/io/grpc/ForwardingClientCallListener.java
deleted file mode 100644
index 36f6414d48e..00000000000
--- a/core/src/main/java/io/grpc/ForwardingClientCallListener.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-/**
- * A {@link ClientCall.Listener} which forwards all of its methods to another {@link
- * ClientCall.Listener}.
- */
-public abstract class ForwardingClientCallListener<RespT> extends ClientCall.Listener<RespT> {
-  /**
-   * Returns the delegated {@code ClientCall.Listener}.
-   */
-  protected abstract ClientCall.Listener<RespT> delegate();
-
-  @Override
-  public void onHeaders(Metadata headers) {
-    delegate().onHeaders(headers);
-  }
-
-  @Override
-  public void onMessage(RespT message) {
-    delegate().onMessage(message);
-  }
-
-  @Override
-  public void onClose(Status status, Metadata trailers) {
-    delegate().onClose(status, trailers);
-  }
-
-  @Override
-  public void onReady() {
-    delegate().onReady();
-  }
-
-  /**
-   * A simplified version of {@link ForwardingClientCallListener} where subclasses can pass in a
-   * {@link ClientCall.Listener} as the delegate.
-   */
-  public abstract static class SimpleForwardingClientCallListener<RespT>
-      extends ForwardingClientCallListener<RespT> {
-
-    private final ClientCall.Listener<RespT> delegate;
-
-    protected SimpleForwardingClientCallListener(ClientCall.Listener<RespT> delegate) {
-      this.delegate = delegate;
-    }
-
-    @Override
-    protected ClientCall.Listener<RespT> delegate() {
-      return delegate;
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/ForwardingServerCall.java b/core/src/main/java/io/grpc/ForwardingServerCall.java
deleted file mode 100644
index 578a9a1b4ba..00000000000
--- a/core/src/main/java/io/grpc/ForwardingServerCall.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-/**
- * A {@link ServerCall} which forwards all of it's methods to another {@link ServerCall}.
- */
-public abstract class ForwardingServerCall<ReqT, RespT>
-    extends PartialForwardingServerCall<ReqT, RespT> {
-  /**
-   * Returns the delegated {@code ServerCall}.
-   */
-  @Override
-  protected abstract ServerCall<ReqT, RespT> delegate();
-
-  @Override
-  public void sendMessage(RespT message) {
-    delegate().sendMessage(message);
-  }
-
-  /**
-   * A simplified version of {@link ForwardingServerCall} where subclasses can pass in a {@link
-   * ServerCall} as the delegate.
-   */
-  public abstract static class SimpleForwardingServerCall<ReqT, RespT>
-      extends ForwardingServerCall<ReqT, RespT> {
-
-    private final ServerCall<ReqT, RespT> delegate;
-
-    protected SimpleForwardingServerCall(ServerCall<ReqT, RespT> delegate) {
-      this.delegate = delegate;
-    }
-
-    @Override
-    protected ServerCall<ReqT, RespT> delegate() {
-      return delegate;
-    }
-
-    @Override
-    public MethodDescriptor<ReqT, RespT> getMethodDescriptor() {
-      return delegate.getMethodDescriptor();
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/ForwardingServerCallListener.java b/core/src/main/java/io/grpc/ForwardingServerCallListener.java
deleted file mode 100644
index 19e32bb5ecc..00000000000
--- a/core/src/main/java/io/grpc/ForwardingServerCallListener.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-/**
- * A {@link ServerCall.Listener} which forwards all of its methods to another {@link
- * ServerCall.Listener} of matching parameterized types.
- */
-public abstract class ForwardingServerCallListener<ReqT>
-    extends PartialForwardingServerCallListener<ReqT> {
-  /**
-   * Returns the delegated {@code ServerCall.Listener}.
-   */
-  @Override
-  protected abstract ServerCall.Listener<ReqT> delegate();
-
-  @Override
-  public void onMessage(ReqT message) {
-    delegate().onMessage(message);
-  }
-
-  /**
-   * A simplified version of {@link ForwardingServerCallListener} where subclasses can pass in a
-   * {@link ServerCall.Listener} as the delegate.
-   */
-  public abstract static class SimpleForwardingServerCallListener<ReqT>
-      extends ForwardingServerCallListener<ReqT> {
-
-    private final ServerCall.Listener<ReqT> delegate;
-
-    protected SimpleForwardingServerCallListener(ServerCall.Listener<ReqT> delegate) {
-      this.delegate = delegate;
-    }
-
-    @Override
-    protected ServerCall.Listener<ReqT> delegate() {
-      return delegate;
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/Grpc.java b/core/src/main/java/io/grpc/Grpc.java
deleted file mode 100644
index fc614d4f390..00000000000
--- a/core/src/main/java/io/grpc/Grpc.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.net.SocketAddress;
-import javax.net.ssl.SSLSession;
-
-/**
- * Stuff that are part of the public API but are not bound to particular classes, e.g., static
- * methods, constants, attribute and context keys.
- */
-public final class Grpc {
-  private Grpc() {
-  }
-
-  /**
-   * Attribute key for the remote address of a transport.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1710")
-  public static final Attributes.Key<SocketAddress> TRANSPORT_ATTR_REMOTE_ADDR =
-          Attributes.Key.of("remote-addr");
-
-  /**
-   * Attribute key for SSL session of a transport.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1710")
-  public static final Attributes.Key<SSLSession> TRANSPORT_ATTR_SSL_SESSION =
-          Attributes.Key.of("ssl-session");
-}
diff --git a/core/src/main/java/io/grpc/HandlerRegistry.java b/core/src/main/java/io/grpc/HandlerRegistry.java
deleted file mode 100644
index 6c68538e6d6..00000000000
--- a/core/src/main/java/io/grpc/HandlerRegistry.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.util.Collections;
-import java.util.List;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * Registry of services and their methods used by servers to dispatching incoming calls.
- */
-@ThreadSafe
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/933")
-public abstract class HandlerRegistry {
-
-  /**
-   * Returns the {@link ServerServiceDefinition}s provided by the registry, or an empty list if not
-   * supported by the implementation.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
-  public List<ServerServiceDefinition> getServices() {
-    return Collections.emptyList();
-  }
-
-  /**
-   * Lookup a {@link ServerMethodDefinition} by its fully-qualified name.
-   *
-   * @param methodName to lookup {@link ServerMethodDefinition} for.
-   * @param authority the authority for the desired method (to do virtual hosting). If {@code null}
-   *        the first matching method will be returned.
-   * @return the resolved method or {@code null} if no method for that name exists.
-   */
-  @Nullable
-  public abstract ServerMethodDefinition<?, ?> lookupMethod(
-      String methodName, @Nullable String authority);
-
-  /**
-   * Lookup a {@link ServerMethodDefinition} by its fully-qualified name.
-   *
-   * @param methodName to lookup {@link ServerMethodDefinition} for.
-   * @return the resolved method or {@code null} if no method for that name exists.
-   */
-  @Nullable
-  public final ServerMethodDefinition<?, ?> lookupMethod(String methodName) {
-    return lookupMethod(methodName, null);
-  }
-
-}
diff --git a/core/src/main/java/io/grpc/Internal.java b/core/src/main/java/io/grpc/Internal.java
deleted file mode 100644
index 479c1b16df6..00000000000
--- a/core/src/main/java/io/grpc/Internal.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * Annotates a program element (class, method, package etc) which is internal to gRPC, not part of
- * the public API, and should not be used by users of gRPC.
- *
- * <p>However, if you want to implement a custom {@link LoadBalancer}, an alternative transport, or
- * anything else that will be wired into gRPC library, you may use the internal parts.  Please
- * consult the gRPC team first, because internal APIs don't have the same API stability guarantee as
- * the public APIs do.
- */
-@Internal
-@Retention(RetentionPolicy.SOURCE)
-@Target({
-    ElementType.ANNOTATION_TYPE,
-    ElementType.CONSTRUCTOR,
-    ElementType.FIELD,
-    ElementType.METHOD,
-    ElementType.PACKAGE,
-    ElementType.TYPE})
-@Documented
-public @interface Internal {
-}
diff --git a/core/src/main/java/io/grpc/InternalKnownTransport.java b/core/src/main/java/io/grpc/InternalKnownTransport.java
deleted file mode 100644
index d49a09bfdbc..00000000000
--- a/core/src/main/java/io/grpc/InternalKnownTransport.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-/**
- * All known transports.
- *
- * <p>Make sure to update MethodDescriptor.rawMethodNames if this is changed.
- */
-@Internal
-public enum InternalKnownTransport {
-  NETTY,
-  ;
-}
-
diff --git a/core/src/main/java/io/grpc/InternalMetadata.java b/core/src/main/java/io/grpc/InternalMetadata.java
deleted file mode 100644
index d027d2dc43f..00000000000
--- a/core/src/main/java/io/grpc/InternalMetadata.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import io.grpc.Metadata.Key;
-import java.nio.charset.Charset;
-
-/**
- * Internal {@link Metadata} accessor. This is intended for use by io.grpc.internal, and the
- * specifically supported transport packages. If you *really* think you need to use this, contact
- * the gRPC team first.
- */
-@Internal
-public final class InternalMetadata {
-
-  /**
-   * A specialized plain ASCII marshaller. Both input and output are assumed to be valid header
-   * ASCII.
-   *
-   * <p>Extended here to break the dependency.
-   */
-  @Internal
-  public interface TrustedAsciiMarshaller<T> extends Metadata.TrustedAsciiMarshaller<T> {}
-
-  /**
-   * Copy of StandardCharsets, which is only available on Java 1.7 and above.
-   */
-  @Internal
-  public static final Charset US_ASCII = Charset.forName("US-ASCII");
-
-  @Internal
-  public static <T> Key<T> keyOf(String name, TrustedAsciiMarshaller<T> marshaller) {
-    return Metadata.Key.of(name, marshaller);
-  }
-
-  @Internal
-  public static Metadata newMetadata(byte[]... binaryValues) {
-    return new Metadata(binaryValues);
-  }
-
-  @Internal
-  public static Metadata newMetadata(int usedNames, byte[]... binaryValues) {
-    return new Metadata(usedNames, binaryValues);
-  }
-
-  @Internal
-  public static byte[][] serialize(Metadata md) {
-    return md.serialize();
-  }
-}
diff --git a/core/src/main/java/io/grpc/InternalMethodDescriptor.java b/core/src/main/java/io/grpc/InternalMethodDescriptor.java
deleted file mode 100644
index 0622c6f44d8..00000000000
--- a/core/src/main/java/io/grpc/InternalMethodDescriptor.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-/**
- * Accesses internal data.  Do not use this.
- */
-@Internal
-public final class InternalMethodDescriptor {
-  private final InternalKnownTransport transport;
-
-  public InternalMethodDescriptor(InternalKnownTransport transport) {
-    // TODO(carl-mastrangelo): maybe restrict access to this.
-    this.transport = checkNotNull(transport, "transport");
-  }
-
-  public Object geRawMethodName(MethodDescriptor<?, ?> md) {
-    return md.getRawMethodName(transport.ordinal());
-  }
-
-  public void setRawMethodName(MethodDescriptor<?, ?> md, Object o) {
-    md.setRawMethodName(transport.ordinal(), o);
-  }
-}
diff --git a/core/src/main/java/io/grpc/InternalNotifyOnServerBuild.java b/core/src/main/java/io/grpc/InternalNotifyOnServerBuild.java
deleted file mode 100644
index a25ea08f617..00000000000
--- a/core/src/main/java/io/grpc/InternalNotifyOnServerBuild.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-/**
- * Provides a callback method for a service to receive a reference to its server. The contract with
- * {@link ServerBuilder} is that this method will be called on all registered services implementing
- * the interface after build() has been called and before the {@link Server} instance is returned.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
-public interface InternalNotifyOnServerBuild {
-  /** Notifies the service that the server has been built. */
-  void notifyOnBuild(Server server);
-}
diff --git a/core/src/main/java/io/grpc/KnownLength.java b/core/src/main/java/io/grpc/KnownLength.java
deleted file mode 100644
index e1f487b89be..00000000000
--- a/core/src/main/java/io/grpc/KnownLength.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.io.IOException;
-
-/**
- * An {@link java.io.InputStream} or alike whose total number of bytes that can be read is known
- * upfront.
- *
- * <p>Usually it's a {@link java.io.InputStream} that also implements this interface, in which case
- * {@link java.io.InputStream#available()} has a stronger semantic by returning an accurate number
- * instead of an estimation.
- */
-public interface KnownLength {
-  /**
-   * Returns the total number of bytes that can be read (or skipped over) from this object until all
-   * bytes have been read out.
-   */
-  int available() throws IOException;
-}
diff --git a/core/src/main/java/io/grpc/LoadBalancer.java b/core/src/main/java/io/grpc/LoadBalancer.java
deleted file mode 100644
index 550e24c9b33..00000000000
--- a/core/src/main/java/io/grpc/LoadBalancer.java
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.util.List;
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * A pluggable component that receives resolved addresses from {@link NameResolver} and provides the
- * channel a usable transport when asked.
- *
- * <p>Note to implementations: all methods are expected to return quickly. Any work that may block
- * should be done asynchronously.
- *
- * @param <T> the transport type to balance
- */
-// TODO(zhangkun83): since it's also used for non-loadbalancing cases like pick-first,
-// "RequestRouter" might be a better name.
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
-@ThreadSafe
-public abstract class LoadBalancer<T> {
-  /**
-   * Pick a transport that Channel will use for next RPC.
-   *
-   * <p>If called after {@link #shutdown} has been called, this method will return
-   * a transport that would fail all requests.
-   *
-   * @param affinity for affinity-based routing
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1766")
-  public abstract T pickTransport(Attributes affinity);
-
-  /**
-   * Shuts down this {@code LoadBalancer}.
-   */
-  public void shutdown() { }
-
-  /**
-   * Handles newly resolved server groups and metadata attributes from name resolution system.
-   * {@code servers} contained in {@link ResolvedServerInfoGroup} should be considered equivalent
-   * but may be flattened into a single list if needed.
-   *
-   * <p>Implementations should not modify the given {@code servers}.
-   *
-   * @param servers the resolved server addresses, never empty.
-   * @param attributes extra metadata from naming system.
-   */
-  public void handleResolvedAddresses(List<ResolvedServerInfoGroup> servers,
-      Attributes attributes) { }
-
-  /**
-   * Handles an error from the name resolution system.
-   *
-   * @param error a non-OK status
-   */
-  public void handleNameResolutionError(Status error) { }
-
-  /**
-   * Called when a transport is fully connected and ready to accept traffic.
-   */
-  public void handleTransportReady(EquivalentAddressGroup addressGroup) { }
-
-  /**
-   * Called when a transport is shutting down.
-   */
-  public void handleTransportShutdown(EquivalentAddressGroup addressGroup, Status s) { }
-
-  public abstract static class Factory {
-    /**
-     * Creates a {@link LoadBalancer} that will be used inside a channel.
-     *
-     * @param serviceName the DNS-style service name, which is also the authority
-     * @param tm the interface where an {@code LoadBalancer} implementation gets connected
-     *               transports from
-     */
-    public abstract <T> LoadBalancer<T> newLoadBalancer(String serviceName, TransportManager<T> tm);
-  }
-}
diff --git a/core/src/main/java/io/grpc/LoadBalancer2.java b/core/src/main/java/io/grpc/LoadBalancer2.java
deleted file mode 100644
index 2230106e331..00000000000
--- a/core/src/main/java/io/grpc/LoadBalancer2.java
+++ /dev/null
@@ -1,420 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.common.base.Preconditions;
-import java.util.List;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.Immutable;
-import javax.annotation.concurrent.NotThreadSafe;
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * A pluggable component that receives resolved addresses from {@link NameResolver} and provides the
- * channel a usable subchannel when asked.  This is the new interface that will replace {@link
- * LoadBalancer}.
- *
- * <p><strong>IMPORTANT NOTICE FOR IMPLEMENTORS: </strong>The name of this class is temporary.  It
- * will be renamed to {@code LoadBalancer} eventually.  Make sure you have read through <a
- * href="https://github.com/grpc/grpc-java/issues/2656" target="_blank">#2656</a> to understand the
- * transition path.
- *
- * <h3>Overview</h3>
- *
- * <p>A LoadBalancer typically implements three interfaces:
- * <ol>
- *   <li>{@link LoadBalancer2} is the main interface.  All methods on it are invoked sequentially
- *       from the Channel Executor.  It receives the results from the {@link NameResolver}, updates
- *       of subchannels' connectivity states, and the channel's request for the LoadBalancer to
- *       shutdown.</li>
- *   <li>{@link SubchannelPicker SubchannelPicker} does the actual load-balancing work.  It selects
- *       a {@link Subchannel Subchannel} for each new RPC.</li>
- *   <li>{@link Factory Factory} creates a new {@link LoadBalancer2} instance.
- * </ol>
- *
- * <p>{@link Helper Helper} is implemented by gRPC library and provided to {@link Factory
- * Factory}. It provides functionalities that a {@code LoadBalancer2} implementation would typically
- * need.
- *
- * <h3>Channel Executor</h3>
- *
- * <p>Channel Executor is an internal executor of the channel, which is used to serialize all the
- * callback methods on the {@link LoadBalancer2} interface, thus the balancer implementation doesn't
- * need to worry about synchronization among them.  However, the actual thread of the Channel
- * Executor is typically the network thread, thus the following rules must be followed to prevent
- * blocking or even dead-locking in a network
- *
- * <ol>
- *
- *   <li><strong>Never block in Channel Executor</strong>.  The callback methods must return
- *   quickly.  Examples or work that must be avoided: CPU-intensive calculation, waiting on
- *   synchronization primitives, blocking I/O, blocking RPCs, etc.</li>
- *
- *   <li><strong>Avoid calling into other components with lock held</strong>.  Channel Executor may
- *   run callbacks under a lock, e.g., the transport lock of OkHttp.  If your LoadBalancer has a
- *   lock, holds the lock in a callback method (e.g., {@link #handleSubchannelState
- *   handleSubchannelState()}) while calling into another class that may involve locks, be cautious
- *   of deadlock.  Generally you wouldn't need any locking in the LoadBalancer.</li>
- *
- * </ol>
- *
- * <p>{@link Helper#runSerialized Helper.runSerialized()} allows you to schedule a task to be run in
- * the Channel Executor.
- *
- * <h3>The canonical implementation pattern</h3>
- *
- * <p>A {@link LoadBalancer2} keeps states like the latest addresses from NameResolver, the
- * Subchannel(s) and their latest connectivity states.  These states are mutated within the Channel
- * Executor.
- *
- * <p>A typical {@link SubchannelPicker SubchannelPicker} holds a snapshot of these states.  It may
- * have its own states, e.g., a picker from a round-robin load-balancer may keep a pointer to the
- * next Subchannel, which are typically mutated by multiple threads.  The picker should only mutate
- * its own state, and should not mutate or re-acquire the states of the LoadBalancer.  This way the
- * picker only needs to synchronize its own states, which is typically trivial to implement.
- *
- * <p>When the LoadBalancer states changes, e.g., Subchannels has become or stopped being READY, and
- * we want subsequent RPCs to use the latest list of READY Subchannels, LoadBalancer would create
- * a new picker, which holds a snapshot of the latest Subchannel list.  Refer to the javadoc of
- * {@link #handleSubchannelState handleSubchannelState()} how to do this properly.
- *
- * <p>No synchronization should be necessary between LoadBalancer and its pickers if you follow
- * the pattern above.  It may be possible to implement in a different way, but that would usually
- * result in more complicated threading.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
-@NotThreadSafe
-public abstract class LoadBalancer2 {
-  /**
-   * Handles newly resolved server groups and metadata attributes from name resolution system.
-   * {@code servers} contained in {@link ResolvedServerInfoGroup} should be considered equivalent
-   * but may be flattened into a single list if needed.
-   *
-   * <p>Implementations should not modify the given {@code servers}.
-   *
-   * @param servers the resolved server addresses, never empty.
-   * @param attributes extra metadata from naming system.
-   */
-  public abstract void handleResolvedAddresses(
-      List<ResolvedServerInfoGroup> servers, Attributes attributes);
-
-  /**
-   * Handles an error from the name resolution system.
-   *
-   * @param error a non-OK status
-   */
-  public abstract void handleNameResolutionError(Status error);
-
-  /**
-   * Handles a state change on a Subchannel.
-   *
-   * <p>The initial state of a Subchannel is IDLE. You won't get a notification for the initial IDLE
-   * state.
-   *
-   * <p>If the new state is not SHUTDOWN, this method should create a new picker and call {@link
-   * Helper#updatePicker Helper.updatePicker()}.  Failing to do so may result in unnecessary delays
-   * of RPCs. Please refer to {@link PickResult#withSubchannel PickResult.withSubchannel()}'s
-   * javadoc for more information.
-   *
-   * <p>SHUTDOWN can only happen in two cases.  One is that LoadBalancer called {@link
-   * Subchannel#shutdown} earlier, thus it should have already discarded this Subchannel.  The other
-   * is that Channel is doing a {@link ManagedChannel#shutdownNow forced shutdown} or has already
-   * terminated, thus there won't be further requests to LoadBalancer.  Therefore, SHUTDOWN can be
-   * safely ignored.
-   *
-   * @param subchannel the involved Subchannel
-   * @param stateInfo the new state
-   */
-  public abstract void handleSubchannelState(
-      Subchannel subchannel, ConnectivityStateInfo stateInfo);
-
-  /**
-   * The channel asks the load-balancer to shutdown.  No more callbacks will be called after this
-   * method.  The implementation should shutdown all Subchannels and OOB channels, and do any other
-   * cleanup as necessary.
-   */
-  public abstract void shutdown();
-
-  /**
-   * The main balancing logic.  It <strong>must be thread-safe</strong>. Typically it should only
-   * synchronize on its own state, and avoid synchronizing with the LoadBalancer's state.
-   */
-  @ThreadSafe
-  public abstract static class SubchannelPicker {
-    /**
-     * Make a balancing decision for a new RPC.
-     *
-     * @param affinity the affinity attributes provided via {@link CallOptions#withAffinity}
-     * @param headers the headers container of the RPC. It can be mutated within this method.
-     */
-    public abstract PickResult pickSubchannel(Attributes affinity, Metadata headers);
-  }
-
-  /**
-   * A balancing decision made by {@link SubchannelPicker SubchannelPicker} for an RPC.
-   *
-   * <p>The outcome of the decision will be one of the following:
-   * <ul>
-   *   <li>Proceed: if a Subchannel is provided via {@link #withSubchannel withSubchannel()}, and is
-   *       in READY state when the RPC tries to start on it, the RPC will proceed on that
-   *       Subchannel.</li>
-   *   <li>Error: if an error is provided via {@link #withError withError()}, and the RPC is not
-   *       wait-for-ready (i.e., {@link CallOptions#withWaitForReady} was not called), the RPC will
-   *       fail immediately with the given error.</li>
-   *   <li>Buffer: in all other cases, the RPC will be buffered in the Channel, until the next
-   *       picker is provided via {@link Helper#updatePicker Helper.updatePicker()}, when the RPC
-   *       will go through the same picking process again.</li>
-   * </ul>
-   */
-  @Immutable
-  public static final class PickResult {
-    private static final PickResult NO_RESULT = new PickResult(null, Status.OK);
-
-    @Nullable private final Subchannel subchannel;
-    // An error to be propagated to the application if subchannel == null
-    // Or OK if there is no error.
-    // subchannel being null and error being OK means RPC needs to wait
-    private final Status status;
-
-    private PickResult(Subchannel subchannel, Status status) {
-      this.subchannel = subchannel;
-      this.status = Preconditions.checkNotNull(status, "status");
-    }
-
-    /**
-     * A decision to proceed the RPC on a Subchannel.
-     *
-     * <p>Only Subchannels returned by {@link Helper#createSubchannel Helper.createSubchannel()}
-     * will work.  DO NOT try to use your own implementations of Subchannels, as they won't work.
-     *
-     * <p>When the RPC tries to use the return Subchannel, which is briefly after this method
-     * returns, the state of the Subchannel will decide where the RPC would go:
-     *
-     * <ul>
-     *   <li>READY: the RPC will proceed on this Subchannel.</li>
-     *   <li>IDLE: the RPC will be buffered.  Subchannel will attempt to create connection.</li>
-     *   <li>All other states: the RPC will be buffered.</li>
-     * </ul>
-     *
-     * <p><strong>All buffered RPCs will stay buffered</strong> until the next call of {@link
-     * Helper#updatePicker Helper.updatePicker()}, which will trigger a new picking process.
-     *
-     * <p>Note that Subchannel's state may change at the same time the picker is making the
-     * decision, which means the decision may be made with (to-be) outdated information.  For
-     * example, a picker may return a Subchannel known to be READY, but it has become IDLE when is
-     * about to be used by the RPC, which makes the RPC to be buffered.  The LoadBalancer will soon
-     * learn about the Subchannels' transition from READY to IDLE, create a new picker and allow the
-     * RPC to use another READY transport if there is any.
-     *
-     * <p>You will want to avoid running into a situation where there are READY Subchannels out
-     * there but some RPCs are still buffered for longer than a brief time.
-     * <ul>
-     *   <li>This can happen if you return Subchannels with states other than READY and IDLE.  For
-     *       example, suppose you round-robin on 2 Subchannels, in READY and CONNECTING states
-     *       respectively.  If the picker ignores the state and pick them equally, 50% of RPCs will
-     *       be stuck in buffered state until both Subchannels are READY.</li>
-     *   <li>This can also happen if you don't create a new picker at key state changes of
-     *       Subchannels.  Take the above round-robin example again.  Suppose you do pick only READY
-     *       and IDLE Subchannels, and initially both Subchannels are READY.  Now one becomes IDLE,
-     *       then CONNECTING and stays CONNECTING for a long time.  If you don't create a new picker
-     *       in response to the CONNECTING state to exclude that Subchannel, 50% of RPCs will hit it
-     *       and be buffered even though the other Subchannel is READY.</li>
-     * </ul>
-     *
-     * <p>In order to prevent unnecessary delay of RPCs, the rules of thumb are:
-     * <ol>
-     *   <li>The picker should only pick Subchannels that are known as READY or IDLE.  Whether to
-     *       pick IDLE Subchannels depends on whether you want Subchannels to connect on-demand or
-     *       actively:
-     *       <ul>
-     *         <li>If you want connect-on-demand, include IDLE Subchannels in your pick results,
-     *             because when an RPC tries to use an IDLE Subchannel, the Subchannel will try to
-     *             connect.</li>
-     *         <li>If you want Subchannels to be always connected even when there is no RPC, you
-     *             would call {@link Subchannel#requestConnection Subchannel.requestConnection()}
-     *             whenever the Subchannel has transitioned to IDLE, then you don't need to include
-     *             IDLE Subchannels in your pick results.</li>
-     *       </ul></li>
-     *   <li>Always create a new picker and call {@link Helper#updatePicker Helper.updatePicker()}
-     *       whenever {@link #handleSubchannelState handleSubchannelState()} is called, unless the
-     *       new state is SHUTDOWN. See {@code handleSubchannelState}'s javadoc for more
-     *       details.</li>
-     * </ol>
-     */
-    public static PickResult withSubchannel(Subchannel subchannel) {
-      return new PickResult(Preconditions.checkNotNull(subchannel, "subchannel"), Status.OK);
-    }
-
-    /**
-     * A decision to report a connectivity error to the RPC.  If the RPC is {@link
-     * CallOptions#withWaitForReady wait-for-ready}, it will stay buffered.  Otherwise, it will fail
-     * with the given error.
-     *
-     * @param error the error status.  Must not be OK.
-     */
-    public static PickResult withError(Status error) {
-      Preconditions.checkArgument(!error.isOk(), "error status shouldn't be OK");
-      return new PickResult(null, error);
-    }
-
-    /**
-     * No decision could be made.  The RPC will stay buffered.
-     */
-    public static PickResult withNoResult() {
-      return NO_RESULT;
-    }
-
-    /**
-     * The Subchannel if this result was created by {@link #withSubchannel withSubchannel()}, or
-     * null otherwise.
-     */
-    @Nullable
-    public Subchannel getSubchannel() {
-      return subchannel;
-    }
-
-    /**
-     * The status associated with this result.  Non-{@code OK} if created with {@link #withError
-     * withError}, or {@code OK} otherwise.
-     */
-    public Status getStatus() {
-      return status;
-    }
-
-    @Override
-    public String toString() {
-      return "[subchannel=" + subchannel + " status=" + status + "]";
-    }
-  }
-
-  /**
-   * Provides essentials for LoadBalancer implementations.
-   */
-  @ThreadSafe
-  public abstract static class Helper {
-    /**
-     * Creates a Subchannel, which is a logical connection to the given group of addresses which are
-     * considered equivalent.  The {@code attrs} are custom attributes associated with this
-     * Subchannel, and can be accessed later through {@link Subchannel#getAttributes
-     * Subchannel.getAttributes()}.
-     *
-     * <p>The LoadBalancer is responsible for closing unused Subchannels, and closing all
-     * Subchannels within {@link #shutdown}.
-     */
-    public abstract Subchannel createSubchannel(EquivalentAddressGroup addrs, Attributes attrs);
-
-    /**
-     * Out-of-band channel for LoadBalancer’s own RPC needs, e.g., talking to an external
-     * load-balancer service.
-     *
-     * <p>The LoadBalancer is responsible for closing unused OOB channels, and closing all OOB
-     * channels within {@link #shutdown}.
-     */
-    public abstract ManagedChannel createOobChannel(
-        EquivalentAddressGroup eag, String authority);
-
-    /**
-     * Set a new picker to the channel.
-     *
-     * <p>When a new picker is provided via {@code updatePicker()}, the channel will apply the
-     * picker on all buffered RPCs, by calling {@link SubchannelPicker#pickSubchannel
-     * SubchannelPicker.pickSubchannel()}.
-     *
-     * <p>The channel will hold the picker and use it for all RPCs, until {@code updatePicker()} is
-     * called again and a new picker replaces the old one.  If {@code updatePicker()} has never been
-     * called, the channel will buffer all RPCs until a picker is provided.
-     */
-    public abstract void updatePicker(SubchannelPicker picker);
-
-    /**
-     * Schedule a task to be run in the Channel Executor, which serializes the task with the
-     * callback methods on the {@link LoadBalancer2} interface.
-     */
-    public abstract void runSerialized(Runnable task);
-
-    /**
-     * Returns the NameResolver of the channel.
-     */
-    public abstract NameResolver.Factory getNameResolverFactory();
-
-    /**
-     * Returns the authority string of the channel, which is derived from the DNS-style target name.
-     */
-    public abstract String getAuthority();
-  }
-
-  /**
-   * A logical connection to a server, or a group of equivalent servers represented by an {@link 
-   * EquivalentAddressGroup}.
-   *
-   * <p>It maintains at most one physical connection (aka transport) for sending new RPCs, while
-   * also keeps track of previous transports that has been shut down but not terminated yet.
-   *
-   * <p>If there isn't an active transport yet, and an RPC is assigned to the Subchannel, it will
-   * create a new transport.  It won't actively create transports otherwise.  {@link
-   * #requestConnection requestConnection()} can be used to ask Subchannel to create a transport if
-   * there isn't any.
-   */
-  @ThreadSafe
-  public abstract static class Subchannel {
-    /**
-     * Shuts down the Subchannel.  After this method is called, this Subchannel should no longer
-     * be returned by the latest {@link SubchannelPicker picker}, and can be safely discarded.
-     */
-    public abstract void shutdown();
-
-    /**
-     * Asks the Subchannel to create a connection (aka transport), if there isn't an active one.
-     */
-    public abstract void requestConnection();
-
-    /**
-     * Returns the addresses that this Subchannel is bound to.
-     */
-    public abstract EquivalentAddressGroup getAddresses();
-
-    /**
-     * The same attributes passed to {@link Helper#createSubchannel Helper.createSubchannel()}.
-     * LoadBalancer can use it to attach additional information here, e.g., the shard this
-     * Subchannel belongs to.
-     */
-    public abstract Attributes getAttributes();
-  }
-
-  @ThreadSafe
-  public abstract static class Factory {
-    /**
-     * Creates a {@link LoadBalancer2} that will be used inside a channel.
-     */
-    public abstract LoadBalancer2 newLoadBalancer(Helper helper);
-  }
-}
diff --git a/core/src/main/java/io/grpc/ManagedChannel.java b/core/src/main/java/io/grpc/ManagedChannel.java
deleted file mode 100644
index c44faea04a6..00000000000
--- a/core/src/main/java/io/grpc/ManagedChannel.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.util.concurrent.TimeUnit;
-
-/**
- * A {@link Channel} that provides lifecycle management.
- */
-public abstract class ManagedChannel extends Channel {
-  /**
-   * Initiates an orderly shutdown in which preexisting calls continue but new calls are immediately
-   * cancelled.
-   */
-  public abstract ManagedChannel shutdown();
-
-  /**
-   * Returns whether the channel is shutdown. Shutdown channels immediately cancel any new calls,
-   * but may still have some calls being processed.
-   *
-   * @see #shutdown()
-   * @see #isTerminated()
-   */
-  public abstract boolean isShutdown();
-
-  /**
-   * Returns whether the channel is terminated. Terminated channels have no running calls and
-   * relevant resources released (like TCP connections).
-   *
-   * @see #isShutdown()
-   */
-  public abstract boolean isTerminated();
-
-  /**
-   * Initiates a forceful shutdown in which preexisting and new calls are cancelled. Although
-   * forceful, the shutdown process is still not instantaneous; {@link #isTerminated()} will likely
-   * return {@code false} immediately after this method returns.
-   */
-  public abstract ManagedChannel shutdownNow();
-
-  /**
-   * Waits for the channel to become terminated, giving up if the timeout is reached.
-   *
-   * @return whether the channel is terminated, as would be done by {@link #isTerminated()}.
-   */
-  public abstract boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
-
-  /**
-   * Gets the current connectivity state. Note the result may soon become outdated.
-   *
-   * @param requestConnection if {@code true}, the channel will try to make a connection if it is
-   *        currently IDLE
-   *
-   * @throws UnsupportedOperationException if not supported by implementation
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/28")
-  public ConnectivityState getState(boolean requestConnection) {
-    throw new UnsupportedOperationException("Not implemented");
-  }
-
-  /**
-   * Registers a one-off callback that will be run if the connectivity state of the channel diverges
-   * from the given {@code source}, which is typically what has just been returned by {@link
-   * #getState}.  If the states are already different, the callback will be called immediately.  The
-   * callback is run in the same executor that runs Call listeners.
-   *
-   * @param source the assumed current state, typically just returned by {@link #getState}
-   * @param callback the one-off callback
-   *
-   * @throws UnsupportedOperationException if not supported by implementation
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/28")
-  public void notifyWhenStateChanged(ConnectivityState source, Runnable callback) {
-    throw new UnsupportedOperationException("Not implemented");
-  }
-}
diff --git a/core/src/main/java/io/grpc/ManagedChannelBuilder.java b/core/src/main/java/io/grpc/ManagedChannelBuilder.java
deleted file mode 100644
index d24012dd1cc..00000000000
--- a/core/src/main/java/io/grpc/ManagedChannelBuilder.java
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.util.List;
-import java.util.concurrent.Executor;
-import java.util.concurrent.TimeUnit;
-
-/**
- * A builder for {@link ManagedChannel} instances.
- *
- * @param <T> The concrete type of this builder.
- */
-public abstract class ManagedChannelBuilder<T extends ManagedChannelBuilder<T>> {
-  public static ManagedChannelBuilder<?> forAddress(String name, int port) {
-    return ManagedChannelProvider.provider().builderForAddress(name, port);
-  }
-
-  /**
-   * Creates a channel with a target string, which can be either a valid {@link
-   * NameResolver}-compliant URI, or an authority string.
-   *
-   * <p>A {@code NameResolver}-compliant URI is an absolute hierarchical URI as defined by {@link
-   * java.net.URI}. Example URIs:
-   * <ul>
-   *   <li>{@code "dns:///foo.googleapis.com:8080"}</li>
-   *   <li>{@code "dns:///foo.googleapis.com"}</li>
-   *   <li>{@code "dns:///%5B2001:db8:85a3:8d3:1319:8a2e:370:7348%5D:443"}</li>
-   *   <li>{@code "dns://8.8.8.8/foo.googleapis.com:8080"}</li>
-   *   <li>{@code "dns://8.8.8.8/foo.googleapis.com"}</li>
-   *   <li>{@code "zookeeper://zk.example.com:9900/example_service"}</li>
-   * </ul>
-   *
-   * <p>An authority string will be converted to a {@code NameResolver}-compliant URI, which has
-   * {@code "dns"} as the scheme, no authority, and the original authority string as its path after
-   * properly escaped. Example authority strings:
-   * <ul>
-   *   <li>{@code "localhost"}</li>
-   *   <li>{@code "127.0.0.1"}</li>
-   *   <li>{@code "localhost:8080"}</li>
-   *   <li>{@code "foo.googleapis.com:8080"}</li>
-   *   <li>{@code "127.0.0.1:8080"}</li>
-   *   <li>{@code "[2001:db8:85a3:8d3:1319:8a2e:370:7348]"}</li>
-   *   <li>{@code "[2001:db8:85a3:8d3:1319:8a2e:370:7348]:443"}</li>
-   * </ul>
-   */
-  public static ManagedChannelBuilder<?> forTarget(String target) {
-    return ManagedChannelProvider.provider().builderForTarget(target);
-  }
-
-  /**
-   * Execute application code directly in the transport thread.
-   *
-   * <p>Depending on the underlying transport, using a direct executor may lead to substantial
-   * performance improvements. However, it also requires the application to not block under
-   * any circumstances.
-   *
-   * <p>Calling this method is semantically equivalent to calling {@link #executor(Executor)} and
-   * passing in a direct executor. However, this is the preferred way as it may allow the transport
-   * to perform special optimizations.
-   */
-  public abstract T directExecutor();
-
-  /**
-   * Provides a custom executor.
-   *
-   * <p>It's an optional parameter. If the user has not provided an executor when the channel is
-   * built, the builder will use a static cached thread pool.
-   *
-   * <p>The channel won't take ownership of the given executor. It's caller's responsibility to
-   * shut down the executor when it's desired.
-   */
-  public abstract T executor(Executor executor);
-
-  /**
-   * Adds interceptors that will be called before the channel performs its real work. This is
-   * functionally equivalent to using {@link ClientInterceptors#intercept(Channel, List)}, but while
-   * still having access to the original {@code ManagedChannel}.
-   */
-  public abstract T intercept(List<ClientInterceptor> interceptors);
-
-  /**
-   * Adds interceptors that will be called before the channel performs its real work. This is
-   * functionally equivalent to using {@link ClientInterceptors#intercept(Channel,
-   * ClientInterceptor...)}, but while still having access to the original {@code ManagedChannel}.
-   */
-  public abstract T intercept(ClientInterceptor... interceptors);
-
-  /**
-   * Provides a custom {@code User-Agent} for the application.
-   *
-   * <p>It's an optional parameter. If provided, the given agent will be prepended by the
-   * grpc {@code User-Agent}.
-   */
-  public abstract T userAgent(String userAgent);
-
-  /**
-   * Overrides the authority used with TLS and HTTP virtual hosting. It does not change what host is
-   * actually connected to. Is commonly in the form {@code host:port}.
-   *
-   * <p>Should only used by tests.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1767")
-  public abstract T overrideAuthority(String authority);
-
-  /*
-   * Use of a plaintext connection to the server. By default a secure connection mechanism
-   * such as TLS will be used.
-   *
-   * <p>Should only be used for testing or for APIs where the use of such API or the data
-   * exchanged is not sensitive.
-   *
-   * @param skipNegotiation @{code true} if there is a priori knowledge that the endpoint supports
-   *                        plaintext, {@code false} if plaintext use must be negotiated.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1772")
-  public abstract T usePlaintext(boolean skipNegotiation);
-
-  /*
-   * Provides a custom {@link NameResolver.Factory} for the channel.
-   *
-   * <p>If this method is not called, the builder will try the providers listed by {@link
-   * NameResolverProvider#providers()} for the given target.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
-  public abstract T nameResolverFactory(NameResolver.Factory resolverFactory);
-
-  /**
-   * Provides a custom {@link LoadBalancer.Factory} for the channel.
-   *
-   * <p>If this method is not called, the builder will use {@link PickFirstBalancerFactory}
-   * for the channel.
-   *
-   * <p>This overrides what was set by {@link #loadBalancerFactory(LoadBalancer2.Factory)}.
-   *
-   * <p>Calling this will revert the channel back to the original (LBv1) implementation.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
-  public abstract T loadBalancerFactory(LoadBalancer.Factory loadBalancerFactory);
-
-  /**
-   * Provides a custom {@link LoadBalancer2.Factory} for the channel.
-   *
-   * <p>If this method is not called, the builder will use {@link PickFirstBalancerFactory}
-   * for the channel.
-   *
-   * <p>This overrides what was set by {@link #loadBalancerFactory(LoadBalancer.Factory)}.
-   *
-   * <p>Calling this will make the channel to run the LBv2 code path. See <a
-   * href="https://github.com/grpc/grpc-java/issues/2656" target="_blank">#2656</a> for more
-   * information.
-   *
-   * <p>This method is implemented by all stock channel builders that
-   * are shipped with gRPC, but may not be implemented by custom channel builders, in which case
-   * this method will throw.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
-  public T loadBalancerFactory(LoadBalancer2.Factory loadBalancerFactory) {
-    throw new UnsupportedOperationException("Not implemented by " + this.getClass().getName());
-  }
-
-  /**
-   * Set the decompression registry for use in the channel.  This is an advanced API call and
-   * shouldn't be used unless you are using custom message encoding.   The default supported
-   * decompressors are in {@code DecompressorRegistry.getDefaultInstance}.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-  public abstract T decompressorRegistry(DecompressorRegistry registry);
-
-  /**
-   * Set the compression registry for use in the channel.  This is an advanced API call and
-   * shouldn't be used unless you are using custom message encoding.   The default supported
-   * compressors are in {@code CompressorRegistry.getDefaultInstance}.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-  public abstract T compressorRegistry(CompressorRegistry registry);
-
-  /**
-   * Set the duration without ongoing RPCs before going to idle mode.
-   *
-   * <p>In idle mode the channel shuts down all connections, the NameResolver and the
-   * LoadBalancer. A new RPC would take the channel out of idle mode. A channel starts in idle mode.
-   *
-   * <p>By default the channel will never go to idle mode after it leaves the initial idle
-   * mode.
-   *
-   * <p>This is an advisory option. Do not rely on any specific behavior related to this option.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2022")
-  public abstract T idleTimeout(long value, TimeUnit unit);
-
-  /**
-   * Sets the maximum message size allowed to be received on the channel. If not called,
-   * defaults to 4 MiB. The default provides protection to clients who haven't considered the
-   * possibility of receiving large messages while trying to be large enough to not be hit in normal
-   * usage.
-   *
-   * <p>This method is advisory, and implementations may decide to not enforce this.  Currently,
-   * the only known transport to not enforce this is {@code InProcessTransport}.
-   *
-   * @param max the maximum number of bytes a single message can be.
-   *
-   * @throws IllegalArgumentException if max is negative.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2307")
-  public T maxInboundMessageSize(int max) {
-    // intentional nop
-    return thisT();
-  }
-
-  /**
-   * Builds a channel using the given parameters.
-   */
-  public abstract ManagedChannel build();
-
-  /**
-   * Returns the correctly typed version of the builder.
-   */
-  private T thisT() {
-    @SuppressWarnings("unchecked")
-    T thisT = (T) this;
-    return thisT;
-  }
-}
diff --git a/core/src/main/java/io/grpc/ManagedChannelProvider.java b/core/src/main/java/io/grpc/ManagedChannelProvider.java
deleted file mode 100644
index 8ba786e8633..00000000000
--- a/core/src/main/java/io/grpc/ManagedChannelProvider.java
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.common.annotations.VisibleForTesting;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.ServiceConfigurationError;
-import java.util.ServiceLoader;
-
-/**
- * Provider of managed channels for transport agnostic consumption.
- *
- * <p>Implementations <em>should not</em> throw. If they do, it may interrupt class loading. If
- * exceptions may reasonably occur for implementation-specific reasons, implementations should
- * generally handle the exception gracefully and return {@code false} from {@link #isAvailable()}.
- */
-@Internal
-public abstract class ManagedChannelProvider {
-  private static final ManagedChannelProvider provider
-      = load(getCorrectClassLoader());
-
-  @VisibleForTesting
-  static ManagedChannelProvider load(ClassLoader classLoader) {
-    Iterable<ManagedChannelProvider> candidates;
-    if (isAndroid()) {
-      candidates = getCandidatesViaHardCoded(classLoader);
-    } else {
-      candidates = getCandidatesViaServiceLoader(classLoader);
-    }
-    List<ManagedChannelProvider> list = new ArrayList<ManagedChannelProvider>();
-    for (ManagedChannelProvider current : candidates) {
-      if (!current.isAvailable()) {
-        continue;
-      }
-      list.add(current);
-    }
-    if (list.isEmpty()) {
-      return null;
-    } else {
-      return Collections.max(list, new Comparator<ManagedChannelProvider>() {
-        @Override
-        public int compare(ManagedChannelProvider f1, ManagedChannelProvider f2) {
-          return f1.priority() - f2.priority();
-        }
-      });
-    }
-  }
-
-  @VisibleForTesting
-  public static Iterable<ManagedChannelProvider> getCandidatesViaServiceLoader(
-      ClassLoader classLoader) {
-    return ServiceLoader.load(ManagedChannelProvider.class, classLoader);
-  }
-
-  /**
-   * Load providers from a hard-coded list. This avoids using getResource(), which has performance
-   * problems on Android (see https://github.com/grpc/grpc-java/issues/2037). Any provider that may
-   * be used on Android is free to be added here.
-   */
-  @VisibleForTesting
-  public static Iterable<ManagedChannelProvider> getCandidatesViaHardCoded(
-      ClassLoader classLoader) {
-    List<ManagedChannelProvider> list = new ArrayList<ManagedChannelProvider>();
-    try {
-      list.add(create(Class.forName("io.grpc.okhttp.OkHttpChannelProvider", true, classLoader)));
-    } catch (ClassNotFoundException ex) {
-      // ignore
-    }
-    try {
-      list.add(create(Class.forName("io.grpc.netty.NettyChannelProvider", true, classLoader)));
-    } catch (ClassNotFoundException ex) {
-      // ignore
-    }
-    return list;
-  }
-
-  @VisibleForTesting
-  static ManagedChannelProvider create(Class<?> rawClass) {
-    try {
-      return rawClass.asSubclass(ManagedChannelProvider.class).getConstructor().newInstance();
-    } catch (Throwable t) {
-      throw new ServiceConfigurationError(
-          "Provider " + rawClass.getName() + " could not be instantiated: " + t, t);
-    }
-  }
-
-  /**
-   * Returns the ClassLoader-wide default channel.
-   *
-   * @throws ProviderNotFoundException if no provider is available
-   */
-  public static ManagedChannelProvider provider() {
-    if (provider == null) {
-      throw new ProviderNotFoundException("No functional channel service provider found. "
-          + "Try adding a dependency on the grpc-okhttp or grpc-netty artifact");
-    }
-    return provider;
-  }
-
-  private static ClassLoader getCorrectClassLoader() {
-    if (isAndroid()) {
-      // When android:sharedUserId or android:process is used, Android will setup a dummy
-      // ClassLoader for the thread context (http://stackoverflow.com/questions/13407006),
-      // instead of letting users to manually set context class loader, we choose the
-      // correct class loader here.
-      return ManagedChannelProvider.class.getClassLoader();
-    }
-    return Thread.currentThread().getContextClassLoader();
-  }
-
-  protected static boolean isAndroid() {
-    try {
-      Class.forName("android.app.Application", /*initialize=*/ false, null);
-      return true;
-    } catch (Exception e) {
-      // If Application isn't loaded, it might as well not be Android.
-      return false;
-    }
-  }
-
-  /**
-   * Whether this provider is available for use, taking the current environment into consideration.
-   * If {@code false}, no other methods are safe to be called.
-   */
-  protected abstract boolean isAvailable();
-
-  /**
-   * A priority, from 0 to 10 that this provider should be used, taking the current environment into
-   * consideration. 5 should be considered the default, and then tweaked based on environment
-   * detection. A priority of 0 does not imply that the provider wouldn't work; just that it should
-   * be last in line.
-   */
-  protected abstract int priority();
-
-  /**
-   * Creates a new builder with the given host and port.
-   */
-  protected abstract ManagedChannelBuilder<?> builderForAddress(String name, int port);
-
-  /**
-   * Creates a new builder with the given target URI.
-   */
-  protected abstract ManagedChannelBuilder<?> builderForTarget(String target);
-
-  public static final class ProviderNotFoundException extends RuntimeException {
-    private static final long serialVersionUID = 1;
-
-    public ProviderNotFoundException(String msg) {
-      super(msg);
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/Metadata.java b/core/src/main/java/io/grpc/Metadata.java
deleted file mode 100644
index e133ca2450f..00000000000
--- a/core/src/main/java/io/grpc/Metadata.java
+++ /dev/null
@@ -1,809 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.base.Charsets.US_ASCII;
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
-import com.google.common.io.BaseEncoding;
-import java.nio.ByteBuffer;
-import java.util.Arrays;
-import java.util.BitSet;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.Set;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.NotThreadSafe;
-
-/**
- * Provides access to read and write metadata values to be exchanged during a call.
- *
- * <p>This class is not thread safe, implementations should ensure that header reads and writes do
- * not occur in multiple threads concurrently.
- */
-@NotThreadSafe
-public final class Metadata {
-
-  /**
-   * All binary headers should have this suffix in their names. Vice versa.
-   *
-   * <p>Its value is {@code "-bin"}. An ASCII header's name must not end with this.
-   */
-  public static final String BINARY_HEADER_SUFFIX = "-bin";
-
-  /**
-   * Simple metadata marshaller that encodes bytes as is.
-   *
-   * <p>This should be used when raw bytes are favored over un-serialized version of object. Can be
-   * helpful in situations where more processing to bytes is needed on application side, avoids
-   * double encoding/decoding.
-   *
-   * <p>Both {@link BinaryMarshaller#toBytes} and {@link BinaryMarshaller#parseBytes} methods do not
-   * return a copy of the byte array. Do _not_ modify the byte arrays of either the arguments or
-   * return values.
-   */
-  public static final BinaryMarshaller<byte[]> BINARY_BYTE_MARSHALLER =
-      new BinaryMarshaller<byte[]>() {
-
-        @Override
-        public byte[] toBytes(byte[] value) {
-          return value;
-        }
-
-        @Override
-        public byte[] parseBytes(byte[] serialized) {
-          return serialized;
-        }
-      };
-
-  /**
-   * Simple metadata marshaller that encodes strings as is.
-   *
-   * <p>This should be used with ASCII strings that only contain the characters listed in the class
-   * comment of {@link AsciiMarshaller}. Otherwise the output may be considered invalid and
-   * discarded by the transport, or the call may fail.
-   */
-  public static final AsciiMarshaller<String> ASCII_STRING_MARSHALLER =
-      new AsciiMarshaller<String>() {
-
-        @Override
-        public String toAsciiString(String value) {
-          return value;
-        }
-
-        @Override
-        public String parseAsciiString(String serialized) {
-          return serialized;
-        }
-      };
-
-  /** Simple metadata marshaller that encodes an integer as a signed decimal string. */
-  static final AsciiMarshaller<Integer> INTEGER_MARSHALLER =
-      new AsciiMarshaller<Integer>() {
-
-        @Override
-        public String toAsciiString(Integer value) {
-          return value.toString();
-        }
-
-        @Override
-        public Integer parseAsciiString(String serialized) {
-          return Integer.parseInt(serialized);
-        }
-      };
-
-  /**
-   * Constructor called by the transport layer when it receives binary metadata. Metadata will
-   * mutate the passed in array.
-   */
-  Metadata(byte[]... binaryValues) {
-    this(binaryValues.length / 2, binaryValues);
-  }
-
-  /**
-   * Constructor called by the transport layer when it receives binary metadata. Metadata will
-   * mutate the passed in array.
-   *
-   * @param usedNames the number of
-   */
-  Metadata(int usedNames, byte[]... binaryValues) {
-    assert (binaryValues.length & 1) == 0 : "Odd number of key-value pairs " + binaryValues.length;
-    size = usedNames;
-    namesAndValues = binaryValues;
-  }
-
-  private byte[][] namesAndValues;
-  // The unscaled number of headers present.
-  private int size;
-
-  private byte[] name(int i) {
-    return namesAndValues[i * 2];
-  }
-
-  private void name(int i, byte[] name) {
-    namesAndValues[i * 2] = name;
-  }
-
-  private byte[] value(int i) {
-    return namesAndValues[i * 2 + 1];
-  }
-
-  private void value(int i, byte[] value) {
-    namesAndValues[i * 2 + 1] = value;
-  }
-
-  private int cap() {
-    return namesAndValues != null ? namesAndValues.length : 0;
-  }
-
-  // The scaled version of size.
-  private int len() {
-    return size * 2;
-  }
-
-  private boolean isEmpty() {
-    /** checks when {@link #namesAndValues} is null or has no elements */
-    return size == 0;
-  }
-
-  /** Constructor called by the application layer when it wants to send metadata. */
-  public Metadata() {}
-
-  /** Returns the total number of key-value headers in this metadata, including duplicates. */
-  @Internal
-  public int headerCount() {
-    return size;
-  }
-
-  /** Returns true if a value is defined for the given key. */
-  public boolean containsKey(Key<?> key) {
-    for (int i = 0; i < size; i++) {
-      if (bytesEqual(key.asciiName(), name(i))) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Returns the last metadata entry added with the name 'name' parsed as T.
-   *
-   * @return the parsed metadata entry or null if there are none.
-   */
-  @Nullable
-  public <T> T get(Key<T> key) {
-    for (int i = size - 1; i >= 0; i--) {
-      if (bytesEqual(key.asciiName(), name(i))) {
-        return key.parseBytes(value(i));
-      }
-    }
-    return null;
-  }
-
-  private final class IterableAt<T> implements Iterable<T> {
-    private final Key<T> key;
-    private int startIdx;
-
-    private IterableAt(Key<T> key, int startIdx) {
-      this.key = key;
-      this.startIdx = startIdx;
-    }
-
-    @Override
-    public Iterator<T> iterator() {
-      return new Iterator<T>() {
-        private boolean hasNext = true;
-        private int idx = startIdx;
-
-        @Override
-        public boolean hasNext() {
-          if (hasNext) {
-            return true;
-          }
-          for (; idx < size; idx++) {
-            if (bytesEqual(key.asciiName(), name(idx))) {
-              hasNext = true;
-              return hasNext;
-            }
-          }
-          return false;
-        }
-
-        @Override
-        public T next() {
-          if (hasNext()) {
-            hasNext = false;
-            return key.parseBytes(value(idx++));
-          }
-          throw new NoSuchElementException();
-        }
-
-        @Override
-        public void remove() {
-          throw new UnsupportedOperationException();
-        }
-      };
-    }
-  }
-
-  /**
-   * Returns all the metadata entries named 'name', in the order they were received, parsed as T or
-   * null if there are none. The iterator is not guaranteed to be "live." It may or may not be
-   * accurate if Metadata is mutated.
-   */
-  public <T> Iterable<T> getAll(final Key<T> key) {
-    for (int i = 0; i < size; i++) {
-      if (bytesEqual(key.asciiName(), name(i))) {
-        return new IterableAt<T>(key, i);
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Returns set of all keys in store.
-   *
-   * @return unmodifiable Set of keys
-   */
-  @SuppressWarnings("deprecation") // The String ctor is deprecated, but fast.
-  public Set<String> keys() {
-    if (isEmpty()) {
-      return Collections.emptySet();
-    }
-    Set<String> ks = new HashSet<String>(size);
-    for (int i = 0; i < size; i++) {
-      ks.add(new String(name(i), 0 /* hibyte */));
-    }
-    // immutable in case we decide to change the implementation later.
-    return Collections.unmodifiableSet(ks);
-  }
-
-  /**
-   * Adds the {@code key, value} pair. If {@code key} already has values, {@code value} is added to
-   * the end. Duplicate values for the same key are permitted.
-   *
-   * @throws NullPointerException if key or value is null
-   */
-  public <T> void put(Key<T> key, T value) {
-    Preconditions.checkNotNull(key, "key");
-    Preconditions.checkNotNull(value, "value");
-    maybeExpand();
-    name(size, key.asciiName());
-    value(size, key.toBytes(value));
-    size++;
-  }
-
-  private void maybeExpand() {
-    if (len() == 0 || len() == cap()) {
-      expand(Math.max(len() * 2, 8));
-    }
-  }
-
-  // Expands to exactly the desired capacity.
-  private void expand(int newCapacity) {
-    byte[][] newNamesAndValues = new byte[newCapacity][];
-    if (!isEmpty()) {
-      System.arraycopy(namesAndValues, 0, newNamesAndValues, 0, len());
-    }
-    namesAndValues = newNamesAndValues;
-  }
-
-  /**
-   * Removes the first occurrence of {@code value} for {@code key}.
-   *
-   * @param key key for value
-   * @param value value
-   * @return {@code true} if {@code value} removed; {@code false} if {@code value} was not present
-   * @throws NullPointerException if {@code key} or {@code value} is null
-   */
-  public <T> boolean remove(Key<T> key, T value) {
-    Preconditions.checkNotNull(key, "key");
-    Preconditions.checkNotNull(value, "value");
-    for (int i = 0; i < size; i++) {
-      if (!bytesEqual(key.asciiName(), name(i))) {
-        continue;
-      }
-      @SuppressWarnings("unchecked")
-      T stored = key.parseBytes(value(i));
-      if (!value.equals(stored)) {
-        continue;
-      }
-      int writeIdx = i * 2;
-      int readIdx = (i + 1) * 2;
-      int readLen = len() - readIdx;
-      System.arraycopy(namesAndValues, readIdx, namesAndValues, writeIdx, readLen);
-      size -= 1;
-      name(size, null);
-      value(size, null);
-      return true;
-    }
-    return false;
-  }
-
-  /** Remove all values for the given key. If there were no values, {@code null} is returned. */
-  public <T> Iterable<T> removeAll(Key<T> key) {
-    if (isEmpty()) {
-      return null;
-    }
-    int writeIdx = 0;
-    int readIdx = 0;
-    List<T> ret = null;
-    for (; readIdx < size; readIdx++) {
-      if (bytesEqual(key.asciiName(), name(readIdx))) {
-        ret = ret != null ? ret : new LinkedList<T>();
-        ret.add(key.parseBytes(value(readIdx)));
-        continue;
-      }
-      name(writeIdx, name(readIdx));
-      value(writeIdx, value(readIdx));
-      writeIdx++;
-    }
-    int newSize = writeIdx;
-    // Multiply by two since namesAndValues is interleaved.
-    Arrays.fill(namesAndValues, writeIdx * 2, len(), null);
-    size = newSize;
-    return ret;
-  }
-
-  /**
-   * Remove all values for the given key without returning them. This is a minor performance
-   * optimization if you do not need the previous values.
-   */
-  @ExperimentalApi
-  public <T> void discardAll(Key<T> key) {
-    if (isEmpty()) {
-      return;
-    }
-    int writeIdx = 0;
-    int readIdx = 0;
-    for (; readIdx < size; readIdx++) {
-      if (bytesEqual(key.asciiName(), name(readIdx))) {
-        continue;
-      }
-      name(writeIdx, name(readIdx));
-      value(writeIdx, value(readIdx));
-      writeIdx++;
-    }
-    int newSize = writeIdx;
-    // Multiply by two since namesAndValues is interleaved.
-    Arrays.fill(namesAndValues, writeIdx * 2, len(), null);
-    size = newSize;
-  }
-
-  /**
-   * Serialize all the metadata entries.
-   *
-   * <p>It produces serialized names and values interleaved. result[i*2] are names, while
-   * result[i*2+1] are values.
-   *
-   * <p>Names are ASCII string bytes that contains only the characters listed in the class comment
-   * of {@link Key}. If the name ends with {@code "-bin"}, the value can be raw binary. Otherwise,
-   * the value must contain only characters listed in the class comments of {@link AsciiMarshaller}
-   *
-   * <p>The returned individual byte arrays <em>must not</em> be modified. However, the top level
-   * array may be modified.
-   *
-   * <p>This method is intended for transport use only.
-   */
-  @Nullable
-  byte[][] serialize() {
-    if (len() == cap()) {
-      return namesAndValues;
-    }
-    byte[][] serialized = new byte[len()][];
-    System.arraycopy(namesAndValues, 0, serialized, 0, len());
-    return serialized;
-  }
-
-  /** Perform a simple merge of two sets of metadata. */
-  public void merge(Metadata other) {
-    if (other.isEmpty()) {
-      return;
-    }
-    int remaining = cap() - len();
-    if (isEmpty() || remaining < other.len()) {
-      expand(len() + other.len());
-    }
-    System.arraycopy(other.namesAndValues, 0, namesAndValues, len(), other.len());
-    size += other.size;
-  }
-
-  /** Merge values for the given set of keys into this set of metadata. */
-  public void merge(Metadata other, Set<Key<?>> keys) {
-    Preconditions.checkNotNull(other, "other");
-    // Use ByteBuffer for equals and hashCode.
-    Map<ByteBuffer, Key<?>> asciiKeys = new HashMap<ByteBuffer, Key<?>>(keys.size());
-    for (Key<?> key : keys) {
-      asciiKeys.put(ByteBuffer.wrap(key.asciiName()), key);
-    }
-    for (int i = 0; i < other.size; i++) {
-      ByteBuffer wrappedNamed = ByteBuffer.wrap(other.name(i));
-      if (asciiKeys.containsKey(wrappedNamed)) {
-        maybeExpand();
-        name(size, other.name(i));
-        value(size, other.value(i));
-        size++;
-      }
-    }
-  }
-
-  @Override
-  public String toString() {
-    StringBuilder sb = new StringBuilder("Metadata(");
-    for (int i = 0; i < size; i++) {
-      if (i != 0) {
-        sb.append(',');
-      }
-      String headerName = new String(name(i), US_ASCII);
-      sb.append(headerName).append('=');
-      if (headerName.endsWith(BINARY_HEADER_SUFFIX)) {
-        sb.append(BaseEncoding.base64().encode(value(i)));
-      } else {
-        String headerValue = new String(value(i), US_ASCII);
-        sb.append(headerValue);
-      }
-    }
-    return sb.append(')').toString();
-  }
-
-  private boolean bytesEqual(byte[] left, byte[] right) {
-    return Arrays.equals(left, right);
-  }
-
-  /** Marshaller for metadata values that are serialized into raw binary. */
-  public interface BinaryMarshaller<T> {
-    /**
-     * Serialize a metadata value to bytes.
-     *
-     * @param value to serialize
-     * @return serialized version of value
-     */
-    byte[] toBytes(T value);
-
-    /**
-     * Parse a serialized metadata value from bytes.
-     *
-     * @param serialized value of metadata to parse
-     * @return a parsed instance of type T
-     */
-    T parseBytes(byte[] serialized);
-  }
-
-  /**
-   * Marshaller for metadata values that are serialized into ASCII strings that contain only
-   * following characters:
-   *
-   * <ul>
-   * <li>Space: {@code 0x20}, but must not be at the beginning or at the end of the value. Leading
-   *     or trailing whitespace may not be preserved.
-   * <li>ASCII visible characters ({@code 0x21-0x7E}).
-   * </ul>
-   *
-   * <p>Note this has to be the subset of valid characters in {@code field-content} from RFC 7230
-   * Section 3.2.
-   */
-  public interface AsciiMarshaller<T> {
-    /**
-     * Serialize a metadata value to a ASCII string that contains only the characters listed in the
-     * class comment of {@link AsciiMarshaller}. Otherwise the output may be considered invalid and
-     * discarded by the transport, or the call may fail.
-     *
-     * @param value to serialize
-     * @return serialized version of value, or null if value cannot be transmitted.
-     */
-    String toAsciiString(T value);
-
-    /**
-     * Parse a serialized metadata value from an ASCII string.
-     *
-     * @param serialized value of metadata to parse
-     * @return a parsed instance of type T
-     */
-    T parseAsciiString(String serialized);
-  }
-
-  /**
-   * Key for metadata entries. Allows for parsing and serialization of metadata.
-   *
-   * <h3>Valid characters in key names</h3>
-   *
-   * <p>Only the following ASCII characters are allowed in the names of keys:
-   *
-   * <ul>
-   * <li>digits: {@code 0-9}
-   * <li>uppercase letters: {@code A-Z} (normalized to lower)
-   * <li>lowercase letters: {@code a-z}
-   * <li>special characters: {@code -_.}
-   * </ul>
-   *
-   * <p>This is a a strict subset of the HTTP field-name rules. Applications may not send or receive
-   * metadata with invalid key names. However, the gRPC library may preserve any metadata received
-   * even if it does not conform to the above limitations. Additionally, if metadata contains non
-   * conforming field names, they will still be sent. In this way, unknown metadata fields are
-   * parsed, serialized and preserved, but never interpreted. They are similar to protobuf unknown
-   * fields.
-   *
-   * <p>Note this has to be the subset of valid HTTP/2 token characters as defined in RFC7230
-   * Section 3.2.6 and RFC5234 Section B.1
-   *
-   * @see <a href="https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md">Wire Spec</a>
-   * @see <a href="https://tools.ietf.org/html/rfc7230#section-3.2.6">RFC7230</a>
-   * @see <a href="https://tools.ietf.org/html/rfc5234#appendix-B.1">RFC5234</a>
-   */
-  public abstract static class Key<T> {
-
-    /** Valid characters for field names as defined in RFC7230 and RFC5234. */
-    private static final BitSet VALID_T_CHARS = generateValidTChars();
-
-    /**
-     * Creates a key for a binary header.
-     *
-     * @param name Must contain only the valid key characters as defined in the class comment. Must
-     *     end with {@link #BINARY_HEADER_SUFFIX}.
-     */
-    public static <T> Key<T> of(String name, BinaryMarshaller<T> marshaller) {
-      return new BinaryKey<T>(name, marshaller);
-    }
-
-    /**
-     * Creates a key for an ASCII header.
-     *
-     * @param name Must contain only the valid key characters as defined in the class comment. Must
-     *     <b>not</b> end with {@link #BINARY_HEADER_SUFFIX}
-     */
-    public static <T> Key<T> of(String name, AsciiMarshaller<T> marshaller) {
-      return new AsciiKey<T>(name, marshaller);
-    }
-
-    static <T> Key<T> of(String name, TrustedAsciiMarshaller<T> marshaller) {
-      return new TrustedAsciiKey<T>(name, marshaller);
-    }
-
-    private final String originalName;
-
-    private final String name;
-    private final byte[] nameBytes;
-
-    private static BitSet generateValidTChars() {
-      BitSet valid = new BitSet(0x7f);
-      valid.set('-');
-      valid.set('_');
-      valid.set('.');
-      for (char c = '0'; c <= '9'; c++) {
-        valid.set(c);
-      }
-      // Only validates after normalization, so we exclude uppercase.
-      for (char c = 'a'; c <= 'z'; c++) {
-        valid.set(c);
-      }
-      return valid;
-    }
-
-    private static String validateName(String n) {
-      checkNotNull(n, "name");
-      checkArgument(n.length() != 0, "token must have at least 1 tchar");
-      for (int i = 0; i < n.length(); i++) {
-        char tChar = n.charAt(i);
-        // TODO(notcarl): remove this hack once pseudo headers are properly handled
-        if (tChar == ':' && i == 0) {
-          continue;
-        }
-
-        checkArgument(
-            VALID_T_CHARS.get(tChar), "Invalid character '%s' in key name '%s'", tChar, n);
-      }
-      return n;
-    }
-
-    private Key(String name) {
-      this.originalName = checkNotNull(name, "name");
-      // Intern the result for faster string identity checking.
-      this.name = validateName(this.originalName.toLowerCase(Locale.ROOT)).intern();
-      this.nameBytes = this.name.getBytes(US_ASCII);
-    }
-
-    /**
-     * @return The original name used to create this key.
-     */
-    public final String originalName() {
-      return originalName;
-    }
-
-    /**
-     * @return The normalized name for this key.
-     */
-    public final String name() {
-      return name;
-    }
-
-    /**
-     * Get the name as bytes using ASCII-encoding.
-     *
-     * <p>The returned byte arrays <em>must not</em> be modified.
-     *
-     * <p>This method is intended for transport use only.
-     */
-    // TODO (louiscryan): Migrate to ByteString
-    @VisibleForTesting
-    byte[] asciiName() {
-      return nameBytes;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      Key<?> key = (Key<?>) o;
-      return name.equals(key.name);
-    }
-
-    @Override
-    public int hashCode() {
-      return name.hashCode();
-    }
-
-    @Override
-    public String toString() {
-      return "Key{name='" + name + "'}";
-    }
-
-    /**
-     * Serialize a metadata value to bytes.
-     *
-     * @param value to serialize
-     * @return serialized version of value
-     */
-    abstract byte[] toBytes(T value);
-
-    /**
-     * Parse a serialized metadata value from bytes.
-     *
-     * @param serialized value of metadata to parse
-     * @return a parsed instance of type T
-     */
-    abstract T parseBytes(byte[] serialized);
-  }
-
-  private static class BinaryKey<T> extends Key<T> {
-    private final BinaryMarshaller<T> marshaller;
-
-    /** Keys have a name and a binary marshaller used for serialization. */
-    private BinaryKey(String name, BinaryMarshaller<T> marshaller) {
-      super(name);
-      checkArgument(
-          name.endsWith(BINARY_HEADER_SUFFIX),
-          "Binary header is named %s. It must end with %s",
-          name,
-          BINARY_HEADER_SUFFIX);
-      checkArgument(name.length() > BINARY_HEADER_SUFFIX.length(), "empty key name");
-      this.marshaller = checkNotNull(marshaller, "marshaller is null");
-    }
-
-    @Override
-    byte[] toBytes(T value) {
-      return marshaller.toBytes(value);
-    }
-
-    @Override
-    T parseBytes(byte[] serialized) {
-      return marshaller.parseBytes(serialized);
-    }
-  }
-
-  private static class AsciiKey<T> extends Key<T> {
-    private final AsciiMarshaller<T> marshaller;
-
-    /** Keys have a name and an ASCII marshaller used for serialization. */
-    private AsciiKey(String name, AsciiMarshaller<T> marshaller) {
-      super(name);
-      Preconditions.checkArgument(
-          !name.endsWith(BINARY_HEADER_SUFFIX),
-          "ASCII header is named %s.  Only binary headers may end with %s",
-          name,
-          BINARY_HEADER_SUFFIX);
-      this.marshaller = Preconditions.checkNotNull(marshaller, "marshaller");
-    }
-
-    @Override
-    byte[] toBytes(T value) {
-      return marshaller.toAsciiString(value).getBytes(US_ASCII);
-    }
-
-    @Override
-    T parseBytes(byte[] serialized) {
-      return marshaller.parseAsciiString(new String(serialized, US_ASCII));
-    }
-  }
-
-  private static final class TrustedAsciiKey<T> extends Key<T> {
-    private final TrustedAsciiMarshaller<T> marshaller;
-
-    /** Keys have a name and an ASCII marshaller used for serialization. */
-    private TrustedAsciiKey(String name, TrustedAsciiMarshaller<T> marshaller) {
-      super(name);
-      Preconditions.checkArgument(
-          !name.endsWith(BINARY_HEADER_SUFFIX),
-          "ASCII header is named %s.  Only binary headers may end with %s",
-          name,
-          BINARY_HEADER_SUFFIX);
-      this.marshaller = Preconditions.checkNotNull(marshaller, "marshaller");
-    }
-
-    @Override
-    byte[] toBytes(T value) {
-      return marshaller.toAsciiString(value);
-    }
-
-    @Override
-    T parseBytes(byte[] serialized) {
-      return marshaller.parseAsciiString(serialized);
-    }
-  }
-
-  /**
-   * A specialized plain ASCII marshaller. Both input and output are assumed to be valid header
-   * ASCII.
-   */
-  interface TrustedAsciiMarshaller<T> {
-    /**
-     * Serialize a metadata value to a ASCII string that contains only the characters listed in the
-     * class comment of {@link io.grpc.Metadata.AsciiMarshaller}. Otherwise the output may be
-     * considered invalid and discarded by the transport, or the call may fail.
-     *
-     * @param value to serialize
-     * @return serialized version of value, or null if value cannot be transmitted.
-     */
-    byte[] toAsciiString(T value);
-
-    /**
-     * Parse a serialized metadata value from an ASCII string.
-     *
-     * @param serialized value of metadata to parse
-     * @return a parsed instance of type T
-     */
-    T parseAsciiString(byte[] serialized);
-  }
-}
diff --git a/core/src/main/java/io/grpc/MethodDescriptor.java b/core/src/main/java/io/grpc/MethodDescriptor.java
deleted file mode 100644
index 380c8928a78..00000000000
--- a/core/src/main/java/io/grpc/MethodDescriptor.java
+++ /dev/null
@@ -1,471 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.base.Preconditions;
-import java.io.InputStream;
-import java.util.concurrent.atomic.AtomicReferenceArray;
-import javax.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.Immutable;
-
-/**
- * Description of a remote method used by {@link Channel} to initiate a call.
- *
- * <p>Provides the name of the operation to execute as well as {@link Marshaller} instances
- * used to parse and serialize request and response messages.
- *
- * <p>Can be constructed manually but will often be generated by stub code generators.
- */
-@Immutable
-public final class MethodDescriptor<ReqT, RespT> {
-
-  private final MethodType type;
-  private final String fullMethodName;
-  private final Marshaller<ReqT> requestMarshaller;
-  private final Marshaller<RespT> responseMarshaller;
-  private final boolean idempotent;
-  private final boolean safe;
-
-  // Must be set to InternalKnownTransport.values().length
-  // Not referenced to break the dependency.
-  private final AtomicReferenceArray<Object> rawMethodNames = new AtomicReferenceArray<Object>(1);
-
-  /**
-   * Gets the cached "raw" method name for this Method Descriptor.  The raw name is transport
-   * specific, and should be set using {@link #setRawMethodName} by the transport.
-   *
-   * @param transportOrdinal the unique ID of the transport, given by
-   *        {@link InternalKnownTransport#ordinal}.
-   * @return a transport specific representation of the method name.
-   */
-  final Object getRawMethodName(int transportOrdinal) {
-    return rawMethodNames.get(transportOrdinal);
-  }
-
-  /**
-   * Safely, but weakly, sets the raw method name for this Method Descriptor.  This should only be
-   * called by the transport.  See {@link #getRawMethodName} for more detail.
-   */
-  final void setRawMethodName(int transportOrdinal, Object o) {
-    rawMethodNames.lazySet(transportOrdinal, o);
-  }
-
-  /**
-   * The call type of a method.
-   */
-  public enum MethodType {
-    /**
-     * One request message followed by one response message.
-     */
-    UNARY,
-
-    /**
-     * Zero or more request messages followed by one response message.
-     */
-    CLIENT_STREAMING,
-
-    /**
-     * One request message followed by zero or more response messages.
-     */
-    SERVER_STREAMING,
-
-    /**
-     * Zero or more request and response messages arbitrarily interleaved in time.
-     */
-    BIDI_STREAMING,
-
-    /**
-     * Cardinality and temporal relationships are not known. Implementations should not make
-     * buffering assumptions and should largely treat the same as {@link #BIDI_STREAMING}.
-     */
-    UNKNOWN;
-
-    /**
-     * Returns {@code true} if the client will immediately send one request message to the server
-     * after calling {@link ClientCall#start(io.grpc.ClientCall.Listener, io.grpc.Metadata)}
-     * and then immediately half-close the stream by calling {@link io.grpc.ClientCall#halfClose()}.
-     */
-    public final boolean clientSendsOneMessage() {
-      return this == UNARY || this == SERVER_STREAMING;
-    }
-
-    /**
-     * Returns {@code true} if the server will immediately send one response message to the client
-     * upon receipt of {@link io.grpc.ServerCall.Listener#onHalfClose()} and then immediately
-     * close the stream by calling {@link ServerCall#close(Status, io.grpc.Metadata)}.
-     */
-    public final boolean serverSendsOneMessage() {
-      return this == UNARY || this == CLIENT_STREAMING;
-    }
-  }
-
-  /**
-   * A typed abstraction over message serialization and deserialization, a.k.a. marshalling and
-   * unmarshalling.
-   *
-   * <p>Stub implementations will define implementations of this interface for each of the request
-   * and response messages provided by a service.
-   *
-   * @param <T> type of serializable message
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1777")
-  public interface Marshaller<T> {
-    /**
-     * Given a message, produce an {@link InputStream} for it so that it can be written to the wire.
-     * Where possible implementations should produce streams that are {@link io.grpc.KnownLength}
-     * to improve transport efficiency.
-     *
-     * @param value to serialize.
-     * @return serialized value as stream of bytes.
-     */
-    public InputStream stream(T value);
-
-    /**
-     * Given an {@link InputStream} parse it into an instance of the declared type so that it can be
-     * passed to application code.
-     *
-     * @param stream of bytes for serialized value
-     * @return parsed value
-     */
-    public T parse(InputStream stream);
-  }
-
-  /** A marshaller that supports retrieving it's type parameter {@code T} at runtime. */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
-  public interface ReflectableMarshaller<T> extends Marshaller<T> {
-    /**
-     * Returns the {@code Class} that this marshaller serializes and deserializes. If inheritance is
-     * allowed, this is the base class or interface for all supported classes.
-     *
-     * @return non-{@code null} base class for all objects produced and consumed by this marshaller
-     */
-    public Class<T> getMessageClass();
-  }
-
-  /** A marshaller that uses a fixed instance of the type it produces. */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
-  public interface PrototypeMarshaller<T> extends ReflectableMarshaller<T> {
-    /**
-     * An instance of the expected message type, typically used as a schema and helper for producing
-     * other message instances. The {@code null} value may be a special value for the marshaller
-     * (like the equivalent of {@link Void}), so it is a valid return value. {@code null} does
-     * <em>not</em> mean "unsupported" or "unknown".
-     *
-     * <p>It is generally expected this would return the same instance each invocation, but it is
-     * not a requirement.
-     */
-    @Nullable
-    public T getMessagePrototype();
-  }
-
-  /**
-   * Creates a new {@code MethodDescriptor}.
-   *
-   * @param type the call type of this method
-   * @param fullMethodName the fully qualified name of this method
-   * @param requestMarshaller the marshaller used to encode and decode requests
-   * @param responseMarshaller the marshaller used to encode and decode responses
-   */
-  public static <RequestT, ResponseT> MethodDescriptor<RequestT, ResponseT> create(
-      MethodType type, String fullMethodName,
-      Marshaller<RequestT> requestMarshaller,
-      Marshaller<ResponseT> responseMarshaller) {
-    return new MethodDescriptor<RequestT, ResponseT>(
-        type, fullMethodName, requestMarshaller, responseMarshaller, false, false);
-  }
-
-  private MethodDescriptor(
-      MethodType type,
-      String fullMethodName,
-      Marshaller<ReqT> requestMarshaller,
-      Marshaller<RespT> responseMarshaller,
-      boolean idempotent,
-      boolean safe) {
-
-    this.type = Preconditions.checkNotNull(type, "type");
-    this.fullMethodName = Preconditions.checkNotNull(fullMethodName, "fullMethodName");
-    this.requestMarshaller = Preconditions.checkNotNull(requestMarshaller, "requestMarshaller");
-    this.responseMarshaller = Preconditions.checkNotNull(responseMarshaller, "responseMarshaller");
-    this.idempotent = idempotent;
-    this.safe = safe;
-    Preconditions.checkArgument(!safe || type == MethodType.UNARY,
-        "Only unary methods can be specified safe");
-  }
-
-  /**
-   * The call type of the method.
-   */
-  public MethodType getType() {
-    return type;
-  }
-
-  /**
-   * The fully qualified name of the method.
-   */
-  public String getFullMethodName() {
-    return fullMethodName;
-  }
-
-  /**
-   * Parse a response payload from the given {@link InputStream}.
-   *
-   * @param input stream containing response message to parse.
-   * @return parsed response message object.
-   */
-  public RespT parseResponse(InputStream input) {
-    return responseMarshaller.parse(input);
-  }
-
-  /**
-   * Convert a request message to an {@link InputStream}.
-   *
-   * @param requestMessage to serialize using the request {@link Marshaller}.
-   * @return serialized request message.
-   */
-  public InputStream streamRequest(ReqT requestMessage) {
-    return requestMarshaller.stream(requestMessage);
-  }
-
-  /**
-   * Parse an incoming request message.
-   *
-   * @param input the serialized message as a byte stream.
-   * @return a parsed instance of the message.
-   */
-  public ReqT parseRequest(InputStream input) {
-    return requestMarshaller.parse(input);
-  }
-
-  /**
-   * Serialize an outgoing response message.
-   *
-   * @param response the response message to serialize.
-   * @return the serialized message as a byte stream.
-   */
-  public InputStream streamResponse(RespT response) {
-    return responseMarshaller.stream(response);
-  }
-
-  /**
-   * Returns the marshaller for the request type. Allows introspection of the request marshaller.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2592")
-  public Marshaller<ReqT> getRequestMarshaller() {
-    return requestMarshaller;
-  }
-
-  /**
-   * Returns the marshaller for the response type. Allows introspection of the response marshaller.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2592")
-  public Marshaller<RespT> getResponseMarshaller() {
-    return responseMarshaller;
-  }
-
-  /**
-   * Returns whether this method is idempotent.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1775")
-  public boolean isIdempotent() {
-    return idempotent;
-  }
-
-  /**
-   * Returns whether this method is safe.
-   *
-   * <p>A safe request does nothing except retrieval so it has no side effects on the server side.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1775")
-  public boolean isSafe() {
-    return safe;
-  }
-
-  /**
-   * Generate the fully qualified method name.
-   *
-   * @param fullServiceName the fully qualified service name that is prefixed with the package name
-   * @param methodName the short method name
-   */
-  public static String generateFullMethodName(String fullServiceName, String methodName) {
-    return checkNotNull(fullServiceName, "fullServiceName")
-        + "/"
-        + checkNotNull(methodName, "methodName");
-  }
-
-  /**
-   * Extract the fully qualified service name out of a fully qualified method name. May return
-   * {@code null} if the input is malformed, but you cannot rely on it for the validity of the
-   * input.
-   */
-  @Nullable
-  public static String extractFullServiceName(String fullMethodName) {
-    int index = checkNotNull(fullMethodName, "fullMethodName").lastIndexOf('/');
-    if (index == -1) {
-      return null;
-    }
-    return fullMethodName.substring(0, index);
-  }
-
-  /**
-   * Creates a new builder for a {@link MethodDescriptor}.
-   */
-  @CheckReturnValue
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2641")
-  public static <ReqT, RespT> Builder<ReqT, RespT> newBuilder() {
-    return newBuilder(null, null);
-  }
-
-  /**
-   * Creates a new builder for a {@link MethodDescriptor}.
-   */
-  @CheckReturnValue
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2641")
-  public static <ReqT, RespT> Builder<ReqT, RespT> newBuilder(
-      Marshaller<ReqT> requestMarshaller, Marshaller<RespT> responseMarshaller) {
-    return new Builder<ReqT, RespT>()
-        .setRequestMarshaller(requestMarshaller)
-        .setResponseMarshaller(responseMarshaller);
-  }
-
-  /**
-   * Turns this descriptor into a builder.
-   */
-  @CheckReturnValue
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2641")
-  public Builder<ReqT, RespT> toBuilder() {
-    return toBuilder(requestMarshaller, responseMarshaller);
-  }
-
-  /**
-   * Turns this descriptor into a builder, replacing the request and response marshallers.
-   */
-  @CheckReturnValue
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2641")
-  public <NewReqT, NewRespT> Builder<NewReqT, NewRespT> toBuilder(
-      Marshaller<NewReqT> requestMarshaller, Marshaller<NewRespT> responseMarshaller) {
-    return MethodDescriptor.<NewReqT, NewRespT>newBuilder()
-        .setRequestMarshaller(requestMarshaller)
-        .setResponseMarshaller(responseMarshaller)
-        .setType(type)
-        .setFullMethodName(fullMethodName)
-        .setIdempotent(idempotent)
-        .setSafe(safe);
-  }
-
-  /**
-   * A builder for a {@link MethodDescriptor}.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2641")
-  public static final class Builder<ReqT, RespT> {
-
-    private Marshaller<ReqT> requestMarshaller;
-    private Marshaller<RespT> responseMarshaller;
-    private MethodType type;
-    private String fullMethodName;
-    private boolean idempotent;
-    private boolean safe;
-
-    private Builder() {}
-
-    /**
-     * Sets the request marshaller.
-     * @param requestMarshaller the marshaller to use.
-     */
-    public Builder<ReqT, RespT> setRequestMarshaller(Marshaller<ReqT> requestMarshaller) {
-      this.requestMarshaller = requestMarshaller;
-      return this;
-    }
-
-    /**
-     * Sets the response marshaller.
-     * @param responseMarshaller the marshaller to use.
-     */
-    @SuppressWarnings("unchecked")
-    public Builder<ReqT, RespT> setResponseMarshaller(Marshaller<RespT> responseMarshaller) {
-      this.responseMarshaller = responseMarshaller;
-      return this;
-    }
-
-    /**
-     * Sets the method type.
-     * @param type the type of the method.
-     */
-    public Builder<ReqT, RespT> setType(MethodType type) {
-      this.type = type;
-      return this;
-    }
-
-    /**
-     * Sets the fully qualified (service and method) method name.
-     * @see MethodDescriptor#generateFullMethodName
-     */
-    public Builder<ReqT, RespT> setFullMethodName(String fullMethodName) {
-      this.fullMethodName = fullMethodName;
-      return this;
-    }
-
-    /**
-     * Sets whether the method is idempotent.  If true, calling this method more than once doesn't
-     * have additional side effects.
-     */
-    public Builder<ReqT, RespT> setIdempotent(boolean idempotent) {
-      this.idempotent = idempotent;
-      return this;
-    }
-
-    /**
-     * Sets whether this method is safe.  If true, calling this method any number of times doesn't
-     * have side effects.
-     */
-    public Builder<ReqT, RespT> setSafe(boolean safe) {
-      this.safe = safe;
-      return this;
-    }
-
-    /**
-     * Builds the method descriptor.
-     */
-    @CheckReturnValue
-    public MethodDescriptor<ReqT, RespT> build() {
-      return new MethodDescriptor<ReqT, RespT>(
-          type,
-          fullMethodName,
-          requestMarshaller,
-          responseMarshaller,
-          idempotent,
-          safe);
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/NameResolver.java b/core/src/main/java/io/grpc/NameResolver.java
deleted file mode 100644
index 1217fbd6d87..00000000000
--- a/core/src/main/java/io/grpc/NameResolver.java
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.net.URI;
-import java.util.List;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * A pluggable component that resolves a target {@link URI} and return addresses to the caller.
- *
- * <p>A {@code NameResolver} uses the URI's scheme to determine whether it can resolve it, and uses
- * the components after the scheme for actual resolution.
- *
- * <p>The addresses and attributes of a target may be changed over time, thus the caller registers a
- * {@link Listener} to receive continuous updates.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
-@ThreadSafe
-public abstract class NameResolver {
-  /**
-   * Returns the authority used to authenticate connections to servers.  It <strong>must</strong> be
-   * from a trusted source, because if the authority is tampered with, RPCs may be sent to the
-   * attackers which may leak sensitive user data.
-   *
-   * <p>An implementation must generate it without blocking, typically in line, and
-   * <strong>must</strong> keep it unchanged. {@code NameResolver}s created from the same factory
-   * with the same argument must return the same authority.
-   */
-  public abstract String getServiceAuthority();
-
-  /**
-   * Starts the resolution.
-   *
-   * @param listener used to receive updates on the target
-   */
-  public abstract void start(Listener listener);
-
-  /**
-   * Stops the resolution. Updates to the Listener will stop.
-   */
-  public abstract void shutdown();
-
-  /**
-   * Re-resolve the name.
-   *
-   * <p>Can only be called after {@link #start} has been called.
-   *
-   * <p>This is only a hint. Implementation takes it as a signal but may not start resolution
-   * immediately. It should never throw.
-   *
-   * <p>The default implementation is no-op.
-   */
-  public void refresh() {}
-
-  public abstract static class Factory {
-    /**
-     * The port number used in case the target or the underlying naming system doesn't provide a
-     * port number.
-     */
-    public static final Attributes.Key<Integer> PARAMS_DEFAULT_PORT =
-        Attributes.Key.of("params-default-port");
-
-    /**
-     * Creates a {@link NameResolver} for the given target URI, or {@code null} if the given URI
-     * cannot be resolved by this factory. The decision should be solely based on the scheme of the
-     * URI.
-     *
-     * @param targetUri the target URI to be resolved, whose scheme must not be {@code null}
-     * @param params optional parameters. Canonical keys are defined as {@code PARAMS_*} fields in
-     *               {@link Factory}.
-     */
-    @Nullable
-    public abstract NameResolver newNameResolver(URI targetUri, Attributes params);
-
-    /**
-     * Returns the default scheme, which will be used to construct a URI when {@link
-     * ManagedChannelBuilder#forTarget(String)} is given an authority string instead of a compliant
-     * URI.
-     */
-    public abstract String getDefaultScheme();
-  }
-
-  /**
-   * Receives address updates.
-   *
-   * <p>All methods are expected to return quickly.
-   */
-  @ThreadSafe
-  public interface Listener {
-    /**
-     * Handles updates on resolved addresses and attributes.
-     *
-     * <p>Implementations will not modify the given {@code servers}.
-     *
-     * @param servers the resolved server groups, containing {@link ResolvedServerInfo} objects. An
-     *                empty list will trigger {@link #onError}
-     * @param attributes extra metadata from naming system
-     */
-    void onUpdate(List<ResolvedServerInfoGroup> servers, Attributes attributes);
-
-    /**
-     * Handles an error from the resolver.
-     *
-     * @param error a non-OK status
-     */
-    void onError(Status error);
-  }
-}
diff --git a/core/src/main/java/io/grpc/NameResolverProvider.java b/core/src/main/java/io/grpc/NameResolverProvider.java
deleted file mode 100644
index 5b572ff4fe7..00000000000
--- a/core/src/main/java/io/grpc/NameResolverProvider.java
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
-import java.net.URI;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.ServiceConfigurationError;
-import java.util.ServiceLoader;
-
-/**
- * Provider of name resolvers for name agnostic consumption.
- *
- * <p>Implementations <em>should not</em> throw. If they do, it may interrupt class loading. If
- * exceptions may reasonably occur for implementation-specific reasons, implementations should
- * generally handle the exception gracefully and return {@code false} from {@link #isAvailable()}.
- */
-@Internal
-public abstract class NameResolverProvider extends NameResolver.Factory {
-  /**
-   * The port number used in case the target or the underlying naming system doesn't provide a
-   * port number.
-   */
-  public static final Attributes.Key<Integer> PARAMS_DEFAULT_PORT =
-      NameResolver.Factory.PARAMS_DEFAULT_PORT;
-
-  private static final List<NameResolverProvider> providers
-      = load(getCorrectClassLoader());
-  private static final NameResolver.Factory factory = new NameResolverFactory(providers);
-
-  @VisibleForTesting
-  static List<NameResolverProvider> load(ClassLoader classLoader) {
-    Iterable<NameResolverProvider> candidates;
-    if (isAndroid()) {
-      candidates = getCandidatesViaHardCoded(classLoader);
-    } else {
-      candidates = getCandidatesViaServiceLoader(classLoader);
-    }
-    List<NameResolverProvider> list = new ArrayList<NameResolverProvider>();
-    for (NameResolverProvider current : candidates) {
-      if (!current.isAvailable()) {
-        continue;
-      }
-      list.add(current);
-    }
-    // Sort descending based on priority.
-    Collections.sort(list, Collections.reverseOrder(new Comparator<NameResolverProvider>() {
-      @Override
-      public int compare(NameResolverProvider f1, NameResolverProvider f2) {
-        return f1.priority() - f2.priority();
-      }
-    }));
-    return Collections.unmodifiableList(list);
-  }
-
-  @VisibleForTesting
-  public static Iterable<NameResolverProvider> getCandidatesViaServiceLoader(
-      ClassLoader classLoader) {
-    return ServiceLoader.load(NameResolverProvider.class, classLoader);
-  }
-
-  /**
-   * Load providers from a hard-coded list. This avoids using getResource(), which has performance
-   * problems on Android (see https://github.com/grpc/grpc-java/issues/2037). Any provider that may
-   * be used on Android is free to be added here.
-   */
-  @VisibleForTesting
-  public static Iterable<NameResolverProvider> getCandidatesViaHardCoded(ClassLoader classLoader) {
-    List<NameResolverProvider> list = new ArrayList<NameResolverProvider>();
-    try {
-      list.add(create(
-          Class.forName("io.grpc.internal.DnsNameResolverProvider", true, classLoader)));
-    } catch (ClassNotFoundException ex) {
-      // ignore
-    }
-    return list;
-  }
-
-  @VisibleForTesting
-  static NameResolverProvider create(Class<?> rawClass) {
-    try {
-      return rawClass.asSubclass(NameResolverProvider.class).getConstructor().newInstance();
-    } catch (Throwable t) {
-      throw new ServiceConfigurationError(
-          "Provider " + rawClass.getName() + " could not be instantiated: " + t, t);
-    }
-  }
-
-  /**
-   * Returns non-{@code null} ClassLoader-wide providers, in preference order.
-   */
-  public static List<NameResolverProvider> providers() {
-    return providers;
-  }
-
-  public static NameResolver.Factory asFactory() {
-    return factory;
-  }
-
-  @VisibleForTesting
-  static NameResolver.Factory asFactory(List<NameResolverProvider> providers) {
-    return new NameResolverFactory(providers);
-  }
-
-  private static ClassLoader getCorrectClassLoader() {
-    if (isAndroid()) {
-      // When android:sharedUserId or android:process is used, Android will setup a dummy
-      // ClassLoader for the thread context (http://stackoverflow.com/questions/13407006),
-      // instead of letting users to manually set context class loader, we choose the
-      // correct class loader here.
-      return NameResolverProvider.class.getClassLoader();
-    }
-    return Thread.currentThread().getContextClassLoader();
-  }
-
-  private static boolean isAndroid() {
-    try {
-      Class.forName("android.app.Application", /*initialize=*/ false, null);
-      return true;
-    } catch (Exception e) {
-      // If Application isn't loaded, it might as well not be Android.
-      return false;
-    }
-  }
-
-  /**
-   * Whether this provider is available for use, taking the current environment into consideration.
-   * If {@code false}, no other methods are safe to be called.
-   */
-  protected abstract boolean isAvailable();
-
-  /**
-   * A priority, from 0 to 10 that this provider should be used, taking the current environment into
-   * consideration. 5 should be considered the default, and then tweaked based on environment
-   * detection. A priority of 0 does not imply that the provider wouldn't work; just that it should
-   * be last in line.
-   */
-  protected abstract int priority();
-
-  private static class NameResolverFactory extends NameResolver.Factory {
-    private final List<NameResolverProvider> providers;
-
-    public NameResolverFactory(List<NameResolverProvider> providers) {
-      this.providers = providers;
-    }
-
-    @Override
-    public NameResolver newNameResolver(URI targetUri, Attributes params) {
-      checkForProviders();
-      for (NameResolverProvider provider : providers) {
-        NameResolver resolver = provider.newNameResolver(targetUri, params);
-        if (resolver != null) {
-          return resolver;
-        }
-      }
-      return null;
-    }
-
-    @Override
-    public String getDefaultScheme() {
-      checkForProviders();
-      return providers.get(0).getDefaultScheme();
-    }
-
-    private void checkForProviders() {
-      Preconditions.checkState(!providers.isEmpty(),
-          "No NameResolverProviders found via ServiceLoader, including for DNS. "
-          + "This is probably due to a broken build. If using ProGuard, check your configuration");
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/PartialForwardingServerCall.java b/core/src/main/java/io/grpc/PartialForwardingServerCall.java
deleted file mode 100644
index 0bde4157cce..00000000000
--- a/core/src/main/java/io/grpc/PartialForwardingServerCall.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-/**
- * A {@link ServerCall} which forwards all of it's methods to another {@link ServerCall} which
- * may have a different onMessage() message type.
- */
-abstract class PartialForwardingServerCall<ReqT, RespT> extends ServerCall<ReqT, RespT> {
-  /**
-   * Returns the delegated {@code ServerCall}.
-   */
-  protected abstract ServerCall<?, ?> delegate();
-
-  @Override
-  public void request(int numMessages) {
-    delegate().request(numMessages);
-  }
-
-  @Override
-  public void sendHeaders(Metadata headers) {
-    delegate().sendHeaders(headers);
-  }
-
-  @Override
-  public boolean isReady() {
-    return delegate().isReady();
-  }
-
-  @Override
-  public void close(Status status, Metadata trailers) {
-    delegate().close(status, trailers);
-  }
-
-  @Override
-  public boolean isCancelled() {
-    return delegate().isCancelled();
-  }
-
-  @Override
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1703")
-  public void setMessageCompression(boolean enabled) {
-    delegate().setMessageCompression(enabled);
-  }
-
-  @Override
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-  public void setCompression(String compressor) {
-    delegate().setCompression(compressor);
-  }
-
-  @Override
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1779")
-  public Attributes getAttributes() {
-    return delegate().getAttributes();
-  }
-}
diff --git a/core/src/main/java/io/grpc/PartialForwardingServerCallListener.java b/core/src/main/java/io/grpc/PartialForwardingServerCallListener.java
deleted file mode 100644
index 43a7c8acc05..00000000000
--- a/core/src/main/java/io/grpc/PartialForwardingServerCallListener.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-/**
- * A {@link ServerCall.Listener} which forwards all of its methods to another {@link
- * ServerCall.Listener} which may have a different parameterized type than the
- * onMessage() message type.
- */
-abstract class PartialForwardingServerCallListener<ReqT>
-    extends ServerCall.Listener<ReqT> {
-  /**
-   * Returns the delegated {@code ServerCall.Listener}.
-   */
-  protected abstract ServerCall.Listener<?> delegate();
-
-  @Override
-  public void onHalfClose() {
-    delegate().onHalfClose();
-  }
-
-  @Override
-  public void onCancel() {
-    delegate().onCancel();
-  }
-
-  @Override
-  public void onComplete() {
-    delegate().onComplete();
-  }
-
-  @Override
-  public void onReady() {
-    delegate().onReady();
-  }
-}
diff --git a/core/src/main/java/io/grpc/PickFirstBalancerFactory.java b/core/src/main/java/io/grpc/PickFirstBalancerFactory.java
deleted file mode 100644
index b125b03c1d8..00000000000
--- a/core/src/main/java/io/grpc/PickFirstBalancerFactory.java
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.common.base.Supplier;
-import io.grpc.TransportManager.InterimTransport;
-import java.net.SocketAddress;
-import java.util.ArrayList;
-import java.util.List;
-import javax.annotation.concurrent.GuardedBy;
-
-/**
- * A {@link LoadBalancer} that provides no load balancing mechanism over the
- * addresses from the {@link NameResolver}.  The channel's default behavior
- * (currently pick-first) is used for all addresses found.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
-public final class PickFirstBalancerFactory extends LoadBalancer.Factory {
-
-  private static final PickFirstBalancerFactory instance = new PickFirstBalancerFactory();
-
-  private PickFirstBalancerFactory() {
-  }
-
-  public static PickFirstBalancerFactory getInstance() {
-    return instance;
-  }
-
-  @Override
-  public <T> LoadBalancer<T> newLoadBalancer(String serviceName, TransportManager<T> tm) {
-    return new PickFirstBalancer<T>(tm);
-  }
-
-  private static class PickFirstBalancer<T> extends LoadBalancer<T> {
-    private static final Status SHUTDOWN_STATUS =
-        Status.UNAVAILABLE.augmentDescription("PickFirstBalancer has shut down");
-
-    private final Object lock = new Object();
-
-    /** "lock" must be held when mutating. */
-    private volatile EquivalentAddressGroup addresses;
-    @GuardedBy("lock")
-    private InterimTransport<T> interimTransport;
-    @GuardedBy("lock")
-    private Status nameResolutionError;
-    @GuardedBy("lock")
-    private boolean closed;
-
-    private final TransportManager<T> tm;
-
-    private PickFirstBalancer(TransportManager<T> tm) {
-      this.tm = tm;
-    }
-
-    @Override
-    public T pickTransport(Attributes affinity) {
-      EquivalentAddressGroup addressesCopy = addresses;
-      if (addressesCopy != null) {
-        return tm.getTransport(addressesCopy);
-      }
-      synchronized (lock) {
-        if (closed) {
-          return tm.createFailingTransport(SHUTDOWN_STATUS);
-        }
-        addressesCopy = addresses;
-        if (addressesCopy == null) {
-          if (nameResolutionError != null) {
-            return tm.createFailingTransport(nameResolutionError);
-          }
-          if (interimTransport == null) {
-            interimTransport = tm.createInterimTransport();
-          }
-          return interimTransport.transport();
-        }
-      }
-      return tm.getTransport(addressesCopy);
-    }
-
-    @Override
-    public void handleResolvedAddresses(List<ResolvedServerInfoGroup> updatedServers,
-        Attributes attributes) {
-      InterimTransport<T> savedInterimTransport;
-      final EquivalentAddressGroup newAddresses;
-      synchronized (lock) {
-        if (closed) {
-          return;
-        }
-        newAddresses = resolvedServerInfoGroupsToEquivalentAddressGroup(updatedServers);
-        if (newAddresses.equals(addresses)) {
-          return;
-        }
-        addresses = newAddresses;
-        nameResolutionError = null;
-        savedInterimTransport = interimTransport;
-        interimTransport = null;
-      }
-      if (savedInterimTransport != null) {
-        savedInterimTransport.closeWithRealTransports(new Supplier<T>() {
-            @Override public T get() {
-              return tm.getTransport(newAddresses);
-            }
-          });
-      }
-    }
-
-    @Override
-    public void handleNameResolutionError(Status error) {
-      InterimTransport<T> savedInterimTransport;
-      synchronized (lock) {
-        if (closed) {
-          return;
-        }
-        error = error.augmentDescription("Name resolution failed");
-        savedInterimTransport = interimTransport;
-        interimTransport = null;
-        nameResolutionError = error;
-      }
-      if (savedInterimTransport != null) {
-        savedInterimTransport.closeWithError(error);
-      }
-    }
-
-    @Override
-    public void shutdown() {
-      InterimTransport<T> savedInterimTransport;
-      synchronized (lock) {
-        if (closed) {
-          return;
-        }
-        closed = true;
-        addresses = null;
-        savedInterimTransport = interimTransport;
-        interimTransport = null;
-      }
-      if (savedInterimTransport != null) {
-        savedInterimTransport.closeWithError(SHUTDOWN_STATUS);
-      }
-    }
-
-    /**
-     * Converts list of ResolvedServerInfoGroup objects into one EquivalentAddressGroup object.
-     */
-    private static EquivalentAddressGroup resolvedServerInfoGroupsToEquivalentAddressGroup(
-        List<ResolvedServerInfoGroup> groupList) {
-      List<SocketAddress> addrs = new ArrayList<SocketAddress>(groupList.size());
-      for (ResolvedServerInfoGroup group : groupList) {
-        for (ResolvedServerInfo srv : group.getResolvedServerInfoList()) {
-          addrs.add(srv.getAddress());
-        }
-      }
-      return new EquivalentAddressGroup(addrs);
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/PickFirstBalancerFactory2.java b/core/src/main/java/io/grpc/PickFirstBalancerFactory2.java
deleted file mode 100644
index 2ef0d44020f..00000000000
--- a/core/src/main/java/io/grpc/PickFirstBalancerFactory2.java
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static io.grpc.ConnectivityState.SHUTDOWN;
-
-import com.google.common.annotations.VisibleForTesting;
-import java.net.SocketAddress;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * A {@link LoadBalancer2} that provides no load balancing mechanism over the
- * addresses from the {@link NameResolver}.  The channel's default behavior
- * (currently pick-first) is used for all addresses found.
- *
- * <p><strong>TECHNICAL PREVIEW: </strong>The name of this class is temporary. It will be renamed to
- * {@code PickFirstBalancerFactory} during <a href="https://github.com/grpc/grpc-java/issues/2656"
- * target="_blank">the transition to LBv2</a>. You should use it only if you want to experiment the
- * LBv2 code path.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
-public final class PickFirstBalancerFactory2 extends LoadBalancer2.Factory {
-
-  private static final PickFirstBalancerFactory2 INSTANCE = new PickFirstBalancerFactory2();
-
-  private PickFirstBalancerFactory2() {
-  }
-
-  public static PickFirstBalancerFactory2 getInstance() {
-    return INSTANCE;
-  }
-
-  @Override
-  public LoadBalancer2 newLoadBalancer(LoadBalancer2.Helper helper) {
-    return new PickFirstBalancer(helper);
-  }
-
-  @VisibleForTesting
-  static class PickFirstBalancer extends LoadBalancer2 {
-    private final Helper helper;
-    private Subchannel subchannel;
-
-    public PickFirstBalancer(Helper helper) {
-      this.helper = helper;
-    }
-
-    @Override
-    public void handleResolvedAddresses(List<ResolvedServerInfoGroup> servers,
-        Attributes attributes) {
-      // Flatten servers list received from name resolver into single address group. This means that
-      // as far as load balancer is concerned, there's virtually one single server with multiple
-      // addresses so the connection will be created only for the first address (pick first).
-      EquivalentAddressGroup newEag =
-          flattenResolvedServerInfoGroupsIntoEquivalentAddressGroup(servers);
-      if (subchannel == null || !newEag.equals(subchannel.getAddresses())) {
-        if (subchannel != null) {
-          subchannel.shutdown();
-        }
-
-        subchannel = helper.createSubchannel(newEag, Attributes.EMPTY);
-        helper.updatePicker(new Picker(PickResult.withSubchannel(subchannel)));
-      }
-    }
-
-    @Override
-    public void handleNameResolutionError(Status error) {
-      if (subchannel != null) {
-        subchannel.shutdown();
-        subchannel = null;
-      }
-      // NB(lukaszx0) Whether we should propagate the error unconditionally is arguable. It's fine
-      // for time being.
-      helper.updatePicker(new Picker(PickResult.withError(error)));
-    }
-
-    @Override
-    public void handleSubchannelState(Subchannel subchannel, ConnectivityStateInfo stateInfo) {
-      ConnectivityState currentState = stateInfo.getState();
-      if (subchannel != this.subchannel || currentState == SHUTDOWN) {
-        return;
-      }
-
-      PickResult pickResult;
-      switch (currentState) {
-        case CONNECTING:
-          pickResult = PickResult.withNoResult();
-          break;
-        case READY:
-        case IDLE:
-          pickResult = PickResult.withSubchannel(subchannel);
-          break;
-        case TRANSIENT_FAILURE:
-          pickResult = PickResult.withError(stateInfo.getStatus());
-          break;
-        default:
-          throw new IllegalStateException();
-      }
-
-      helper.updatePicker(new Picker(pickResult));
-    }
-
-    @Override
-    public void shutdown() {
-      if (subchannel != null) {
-        subchannel.shutdown();
-      }
-    }
-
-    /**
-     * Flattens list of ResolvedServerInfoGroup objects into one EquivalentAddressGroup object.
-     */
-    private static EquivalentAddressGroup flattenResolvedServerInfoGroupsIntoEquivalentAddressGroup(
-        List<ResolvedServerInfoGroup> groupList) {
-      List<SocketAddress> addrs = new ArrayList<SocketAddress>();
-      for (ResolvedServerInfoGroup group : groupList) {
-        for (ResolvedServerInfo srv : group.getResolvedServerInfoList()) {
-          addrs.add(srv.getAddress());
-        }
-      }
-      return new EquivalentAddressGroup(addrs);
-    }
-
-  }
-
-  /**
-   * No-op picker which doesn't add any custom picking logic. It just passes already known result
-   * received in constructor.
-   */
-  @VisibleForTesting
-  static class Picker extends LoadBalancer2.SubchannelPicker {
-    private final LoadBalancer2.PickResult result;
-
-    Picker(LoadBalancer2.PickResult result) {
-      this.result = result;
-    }
-
-    @Override
-    public LoadBalancer2.PickResult pickSubchannel(Attributes affinity, Metadata headers) {
-      return result;
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/ResolvedServerInfo.java b/core/src/main/java/io/grpc/ResolvedServerInfo.java
deleted file mode 100644
index 5607eab92df..00000000000
--- a/core/src/main/java/io/grpc/ResolvedServerInfo.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.base.Objects;
-import java.net.SocketAddress;
-import javax.annotation.concurrent.Immutable;
-
-/**
- * The information about a server from a {@link NameResolver}.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
-@Immutable
-public final class ResolvedServerInfo {
-  private final SocketAddress address;
-  private final Attributes attributes;
-
-  /**
-   * Constructs a new resolved server without attributes.
-   *
-   * @param address the address of the server
-   */
-  public ResolvedServerInfo(SocketAddress address) {
-    this(address, Attributes.EMPTY);
-  }
-
-  /**
-   * Constructs a new resolved server with attributes.
-   *
-   * @param address the address of the server
-   * @param attributes attributes associated with this address.
-   */
-  public ResolvedServerInfo(SocketAddress address, Attributes attributes) {
-    this.address = checkNotNull(address);
-    this.attributes = checkNotNull(attributes);
-  }
-
-  /**
-   * Returns the address.
-   */
-  public SocketAddress getAddress() {
-    return address;
-  }
-
-  /**
-   * Returns the associated attributes.
-   */
-  public Attributes getAttributes() {
-    return attributes;
-  }
-
-  @Override
-  public String toString() {
-    return "[address=" + address + ", attrs=" + attributes + "]";
-  }
-
-  /**
-   * Returns true if the given object is also a {@link ResolvedServerInfo} with an equal address
-   * and equal attribute values.
-   *
-   * <p>Note that if a resolver includes mutable values in the attributes, it is possible for two
-   * objects to be considered equal at one point in time and not equal at another (due to concurrent
-   * mutation of attribute values).
-   *
-   * @param o an object.
-   * @return true if the given object is a {@link ResolvedServerInfo} with an equal address and
-   *     equal attributes.
-   */
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) {
-      return true;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    ResolvedServerInfo that = (ResolvedServerInfo) o;
-    return Objects.equal(address, that.address) && Objects.equal(attributes, that.attributes);
-  }
-
-  /**
-   * Returns a hash code for the server info.
-   *
-   * <p>Note that if a resolver includes mutable values in the attributes, this object's hash code
-   * could change over time. So care must be used when putting these objects into a set or using
-   * them as keys for a map.
-   *
-   * @return a hash code for the server info, computed as described above.
-   */
-  @Override
-  public int hashCode() {
-    return Objects.hashCode(address, attributes);
-  }
-}
diff --git a/core/src/main/java/io/grpc/ResolvedServerInfoGroup.java b/core/src/main/java/io/grpc/ResolvedServerInfoGroup.java
deleted file mode 100644
index 86cec3cfbe0..00000000000
--- a/core/src/main/java/io/grpc/ResolvedServerInfoGroup.java
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.base.Objects;
-import java.net.SocketAddress;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import javax.annotation.concurrent.Immutable;
-
-/**
- * A group of {@link ResolvedServerInfo}s that is returned from a {@link NameResolver}.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1770")
-@Immutable
-public final class ResolvedServerInfoGroup {
-  private final List<ResolvedServerInfo> resolvedServerInfoList;
-  private final Attributes attributes;
-
-  /**
-   * Constructs a new resolved server info group from {@link ResolvedServerInfo} list,
-   * with custom {@link Attributes} attached to it.
-   *
-   * @param resolvedServerInfoList list of resolved server info objects.
-   * @param attributes custom attributes for a given group.
-   */
-  private ResolvedServerInfoGroup(List<ResolvedServerInfo> resolvedServerInfoList,
-      Attributes attributes) {
-    checkArgument(!resolvedServerInfoList.isEmpty(), "empty server list");
-    this.resolvedServerInfoList =
-        Collections.unmodifiableList(new ArrayList<ResolvedServerInfo>(resolvedServerInfoList));
-    this.attributes = checkNotNull(attributes, "attributes");
-  }
-
-  /**
-   * Returns immutable list of {@link ResolvedServerInfo} objects for this group.
-   */
-  public List<ResolvedServerInfo> getResolvedServerInfoList() {
-    return resolvedServerInfoList;
-  }
-
-  /**
-   * Returns {@link Attributes} for this group.
-   */
-  public Attributes getAttributes() {
-    return attributes;
-  }
-
-  /**
-   * Converts this group to {@link EquivalentAddressGroup} object.
-   */
-  public EquivalentAddressGroup toEquivalentAddressGroup() {
-    List<SocketAddress> addrs = new ArrayList<SocketAddress>(resolvedServerInfoList.size());
-    for (ResolvedServerInfo resolvedServerInfo : resolvedServerInfoList) {
-      addrs.add(resolvedServerInfo.getAddress());
-    }
-    return new EquivalentAddressGroup(addrs);
-  }
-
-  /**
-   * Creates a new builder.
-   */
-  public static Builder builder() {
-    return new Builder();
-  }
-
-  /**
-   * Creates a new builder for a group with extra attributes.
-   */
-  public static Builder builder(Attributes attributes) {
-    return new Builder(attributes);
-  }
-
-  /**
-   * Returns true if the given object is also a {@link ResolvedServerInfoGroup} with an equal
-   * attributes and list of {@link ResolvedServerInfo} objects.
-   *
-   * @param o an object.
-   * @return true if the given object is a {@link ResolvedServerInfoGroup} with an equal attributes
-   *     and server info list.
-   */
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) {
-      return true;
-    }
-    if (o == null || getClass() != o.getClass()) {
-      return false;
-    }
-    ResolvedServerInfoGroup that = (ResolvedServerInfoGroup) o;
-    return Objects.equal(resolvedServerInfoList, that.resolvedServerInfoList)
-        && Objects.equal(attributes, that.attributes);
-  }
-
-  /**
-   * Returns a hash code for the resolved server info group.
-   *
-   * <p>Note that if a resolver includes mutable values in the attributes, this object's hash code
-   * could change over time. So care must be used when putting these objects into a set or using
-   * them as keys for a map.
-   *
-   * @return a hash code for the server info group.
-   */
-  @Override
-  public int hashCode() {
-    return Objects.hashCode(resolvedServerInfoList, attributes);
-  }
-
-  @Override
-  public String toString() {
-    return "[servers=" + resolvedServerInfoList + ", attrs=" + attributes + "]";
-  }
-
-  /**
-   * Builder for a {@link ResolvedServerInfo}.
-   */
-  public static final class Builder {
-    private final List<ResolvedServerInfo> group = new ArrayList<ResolvedServerInfo>();
-    private final Attributes attributes;
-
-    public Builder(Attributes attributes) {
-      this.attributes = attributes;
-    }
-
-    public Builder() {
-      this(Attributes.EMPTY);
-    }
-
-    public Builder add(ResolvedServerInfo resolvedServerInfo) {
-      group.add(resolvedServerInfo);
-      return this;
-    }
-
-    public Builder addAll(Collection<ResolvedServerInfo> resolvedServerInfo) {
-      group.addAll(resolvedServerInfo);
-      return this;
-    }
-
-    public ResolvedServerInfoGroup build() {
-      return new ResolvedServerInfoGroup(group, attributes);
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/SecurityLevel.java b/core/src/main/java/io/grpc/SecurityLevel.java
deleted file mode 100644
index f662723e3b5..00000000000
--- a/core/src/main/java/io/grpc/SecurityLevel.java
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-/**
- * The level of security guarantee in communications.
- */
-@ExperimentalApi
-public enum SecurityLevel {
-  /**
-   * No security guarantee.
-   */
-  NONE,
-
-  /**
-   * The other party is authenticated and the data is not tampered with.
-   */
-  INTEGRITY,
-
-  /**
-   * In addition to {@code INTEGRITY}, the data is only visible to the intended communication
-   * parties.
-   */
-  PRIVACY_AND_INTEGRITY
-}
diff --git a/core/src/main/java/io/grpc/Server.java b/core/src/main/java/io/grpc/Server.java
deleted file mode 100644
index c214a38aaff..00000000000
--- a/core/src/main/java/io/grpc/Server.java
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.io.IOException;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * Server for listening for and dispatching incoming calls. It is not expected to be implemented by
- * application code or interceptors.
- */
-@ThreadSafe
-public abstract class Server {
-  /**
-   * Bind and start the server.
-   *
-   * @return {@code this} object
-   * @throws IllegalStateException if already started
-   * @throws IOException if unable to bind
-   */
-  public abstract Server start() throws IOException;
-
-  /**
-   * Returns the port number the server is listening on.  This can return -1 if there is no actual
-   * port or the result otherwise does not make sense.  Result is undefined after the server is
-   * terminated.
-   *
-   * @throws IllegalStateException if the server has not yet been started.
-   */
-  public int getPort() {
-    return -1;
-  }
-
-  /**
-   * Returns all services registered with the server, or an empty list if not supported by the
-   * implementation.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
-  public List<ServerServiceDefinition> getServices() {
-    return Collections.emptyList();
-  }
-
-  /**
-   * Returns immutable services registered with the server, or an empty list if not supported by the
-   * implementation.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
-  public List<ServerServiceDefinition> getImmutableServices() {
-    return Collections.emptyList();
-  }
-
-
-  /**
-   * Returns mutable services registered with the server, or an empty list if not supported by the
-   * implementation.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
-  public List<ServerServiceDefinition> getMutableServices() {
-    return Collections.emptyList();
-  }
-
-  /**
-   * Initiates an orderly shutdown in which preexisting calls continue but new calls are rejected.
-   */
-  public abstract Server shutdown();
-
-  /**
-   * Initiates a forceful shutdown in which preexisting and new calls are rejected. Although
-   * forceful, the shutdown process is still not instantaneous; {@link #isTerminated()} will likely
-   * return {@code false} immediately after this method returns.
-   */
-  public abstract Server shutdownNow();
-
-  /**
-   * Returns whether the server is shutdown. Shutdown servers reject any new calls, but may still
-   * have some calls being processed.
-   *
-   * @see #shutdown()
-   * @see #isTerminated()
-   */
-  public abstract boolean isShutdown();
-
-  /**
-   * Returns whether the server is terminated. Terminated servers have no running calls and
-   * relevant resources released (like TCP connections).
-   *
-   * @see #isShutdown()
-   */
-  public abstract boolean isTerminated();
-
-  /**
-   * Waits for the server to become terminated, giving up if the timeout is reached.
-   *
-   * @return whether the server is terminated, as would be done by {@link #isTerminated()}.
-   */
-  public abstract boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
-
-  /**
-   * Waits for the server to become terminated.
-   */
-  public abstract void awaitTermination() throws InterruptedException;
-}
diff --git a/core/src/main/java/io/grpc/ServerBuilder.java b/core/src/main/java/io/grpc/ServerBuilder.java
deleted file mode 100644
index efdae35be0c..00000000000
--- a/core/src/main/java/io/grpc/ServerBuilder.java
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.io.File;
-import java.util.concurrent.Executor;
-import javax.annotation.Nullable;
-
-/**
- * A builder for {@link Server} instances.
- *
- * @param <T> The concrete type of this builder.
- */
-public abstract class ServerBuilder<T extends ServerBuilder<T>> {
-
-  public static ServerBuilder<?> forPort(int port) {
-    return ServerProvider.provider().builderForPort(port);
-  }
-
-  /**
-   * Execute application code directly in the transport thread.
-   *
-   * <p>Depending on the underlying transport, using a direct executor may lead to substantial
-   * performance improvements. However, it also requires the application to not block under
-   * any circumstances.
-   *
-   * <p>Calling this method is semantically equivalent to calling {@link #executor(Executor)} and
-   * passing in a direct executor. However, this is the preferred way as it may allow the transport
-   * to perform special optimizations.
-   */
-  public abstract T directExecutor();
-
-  /**
-   * Provides a custom executor.
-   *
-   * <p>It's an optional parameter. If the user has not provided an executor when the server is
-   * built, the builder will use a static cached thread pool.
-   *
-   * <p>The server won't take ownership of the given executor. It's caller's responsibility to
-   * shut down the executor when it's desired.
-   */
-  public abstract T executor(@Nullable Executor executor);
-
-  /**
-   * Adds a service implementation to the handler registry.
-   *
-   * @param service ServerServiceDefinition object
-   */
-  public abstract T addService(ServerServiceDefinition service);
-
-  /**
-   * Adds a service implementation to the handler registry. If bindableService implements
-   * {@link InternalNotifyOnServerBuild}, the service will receive a reference to the generated
-   * server instance upon build().
-   *
-   * @param bindableService BindableService object
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
-  public abstract T addService(BindableService bindableService);
-
-  /**
-   * Adds a {@link ServerTransportFilter}. The order of filters being added is the order they will
-   * be executed.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2132")
-  public T addTransportFilter(ServerTransportFilter filter) {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * Sets a fallback handler registry that will be looked up in if a method is not found in the
-   * primary registry.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/933")
-  public abstract T fallbackHandlerRegistry(@Nullable HandlerRegistry fallbackRegistry);
-
-  /**
-   * Makes the server use TLS.
-   *
-   * @param certChain file containing the full certificate chain
-   * @param privateKey file containing the private key
-   */
-  public abstract T useTransportSecurity(File certChain, File privateKey);
-
-  /**
-   * Set the decompression registry for use in the channel.  This is an advanced API call and
-   * shouldn't be used unless you are using custom message encoding.   The default supported
-   * decompressors are in {@code DecompressorRegistry.getDefaultInstance}.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-  public abstract T decompressorRegistry(@Nullable DecompressorRegistry registry);
-
-  /**
-   * Set the compression registry for use in the channel.  This is an advanced API call and
-   * shouldn't be used unless you are using custom message encoding.   The default supported
-   * compressors are in {@code CompressorRegistry.getDefaultInstance}.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-  public abstract T compressorRegistry(@Nullable CompressorRegistry registry);
-
-  /**
-   * Builds a server using the given parameters.
-   *
-   * <p>The returned service will not been started or be bound a port. You will need to start it
-   * with {@link Server#start()}.
-   */
-  public abstract Server build();
-}
diff --git a/core/src/main/java/io/grpc/ServerCall.java b/core/src/main/java/io/grpc/ServerCall.java
deleted file mode 100644
index 02bd72640bf..00000000000
--- a/core/src/main/java/io/grpc/ServerCall.java
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.errorprone.annotations.DoNotMock;
-
-/**
- * Encapsulates a single call received from a remote client. Calls may not simply be unary
- * request-response even though this is the most common pattern. Calls may stream any number of
- * requests and responses. This API is generally intended for use by generated handlers,
- * but applications may use it directly if they need to.
- *
- * <p>Headers must be sent before any messages, which must be sent before closing.
- *
- * <p>No generic method for determining message receipt or providing acknowledgement is provided.
- * Applications are expected to utilize normal messages for such signals, as a response
- * naturally acknowledges its request.
- *
- * <p>Methods are guaranteed to be non-blocking. Implementations are not required to be thread-safe.
- *
- * @param <ReqT> parsed type of request message.
- * @param <RespT> parsed type of response message.
- */
-@DoNotMock("Use InProcessTransport and make a fake server instead")
-public abstract class ServerCall<ReqT, RespT> {
-
-  /**
-   * Callbacks for consuming incoming RPC messages.
-   *
-   * <p>Any contexts are guaranteed to arrive before any messages, which are guaranteed before half
-   * close, which is guaranteed before completion.
-   *
-   * <p>Implementations are free to block for extended periods of time. Implementations are not
-   * required to be thread-safe.
-   */
-  // TODO(ejona86): We need to decide what to do in the case of server closing with non-cancellation
-  // before client half closes. It may be that we treat such a case as an error. If we permit such
-  // a case then we either get to generate a half close or purposefully omit it.
-  public abstract static class Listener<ReqT> {
-    /**
-     * A request message has been received. For streaming calls, there may be zero or more request
-     * messages.
-     *
-     * @param message a received request message.
-     */
-    public void onMessage(ReqT message) {}
-
-    /**
-     * The client completed all message sending. However, the call may still be cancelled.
-     */
-    public void onHalfClose() {}
-
-    /**
-     * The call was cancelled and the server is encouraged to abort processing to save resources,
-     * since the client will not process any further messages. Cancellations can be caused by
-     * timeouts, explicit cancellation by the client, network errors, etc.
-     *
-     * <p>There will be no further callbacks for the call.
-     */
-    public void onCancel() {}
-
-    /**
-     * The call is considered complete and {@link #onCancel} is guaranteed not to be called.
-     * However, the client is not guaranteed to have received all messages.
-     *
-     * <p>There will be no further callbacks for the call.
-     */
-    public void onComplete() {}
-
-    /**
-     * This indicates that the call is now capable of sending additional messages (via
-     * {@link #sendMessage}) without requiring excessive buffering internally. This event is
-     * just a suggestion and the application is free to ignore it, however doing so may
-     * result in excessive buffering within the call.
-     */
-    public void onReady() {}
-  }
-
-  /**
-   * Requests up to the given number of messages from the call to be delivered to
-   * {@link Listener#onMessage(Object)}. Once {@code numMessages} have been delivered
-   * no further request messages will be delivered until more messages are requested by
-   * calling this method again.
-   *
-   * <p>Servers use this mechanism to provide back-pressure to the client for flow-control.
-   *
-   * <p>This method is safe to call from multiple threads without external synchronizaton.
-   *
-   * @param numMessages the requested number of messages to be delivered to the listener.
-   */
-  public abstract void request(int numMessages);
-
-  /**
-   * Send response header metadata prior to sending a response message. This method may
-   * only be called once and cannot be called after calls to {@link #sendMessage} or {@link #close}.
-   *
-   * <p>Since {@link Metadata} is not thread-safe, the caller must not access {@code headers} after
-   * this point.
-   *
-   * @param headers metadata to send prior to any response body.
-   * @throws IllegalStateException if {@code close} has been called, a message has been sent, or
-   *     headers have already been sent
-   */
-  public abstract void sendHeaders(Metadata headers);
-
-  /**
-   * Send a response message. Messages are the primary form of communication associated with
-   * RPCs. Multiple response messages may exist for streaming calls.
-   *
-   * @param message response message.
-   * @throws IllegalStateException if headers not sent or call is {@link #close}d
-   */
-  public abstract void sendMessage(RespT message);
-
-  /**
-   * If {@code true}, indicates that the call is capable of sending additional messages
-   * without requiring excessive buffering internally. This event is
-   * just a suggestion and the application is free to ignore it, however doing so may
-   * result in excessive buffering within the call.
-   *
-   * <p>This implementation always returns {@code true}.
-   */
-  public boolean isReady() {
-    return true;
-  }
-
-  /**
-   * Close the call with the provided status. No further sending or receiving will occur. If {@link
-   * Status#isOk} is {@code false}, then the call is said to have failed.
-   *
-   * <p>If no errors or cancellations are known to have occurred, then a {@link Listener#onComplete}
-   * notification should be expected, independent of {@code status}. Otherwise {@link
-   * Listener#onCancel} has been or will be called.
-   *
-   * <p>Since {@link Metadata} is not thread-safe, the caller must not access {@code trailers} after
-   * this point.
-   *
-   * @throws IllegalStateException if call is already {@code close}d
-   */
-  public abstract void close(Status status, Metadata trailers);
-
-  /**
-   * Returns {@code true} when the call is cancelled and the server is encouraged to abort
-   * processing to save resources, since the client will not be processing any further methods.
-   * Cancellations can be caused by timeouts, explicit cancel by client, network errors, and
-   * similar.
-   *
-   * <p>This method may safely be called concurrently from multiple threads.
-   */
-  public abstract boolean isCancelled();
-
-  /**
-   * Enables per-message compression, if an encoding type has been negotiated.  If no message
-   * encoding has been negotiated, this is a no-op. By default per-message compression is enabled,
-   * but may not have any effect if compression is not enabled on the call.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-  public void setMessageCompression(boolean enabled) {
-    // noop
-  }
-
-  /**
-   * Sets the compression algorithm for this call.  If the server does not support the compression
-   * algorithm, the call will fail.  This method may only be called before {@link #sendHeaders}.
-   * The compressor to use will be looked up in the {@link CompressorRegistry}.  Default gRPC
-   * servers support the "gzip" compressor.
-   *
-   * @param compressor the name of the compressor to use.
-   * @throws IllegalArgumentException if the compressor name can not be found.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
-  public void setCompression(String compressor) {
-    // noop
-  }
-
-  /**
-   * Returns properties of a single call.
-   *
-   * <p>Attributes originate from the transport and can be altered by {@link ServerTransportFilter}.
-   * {@link Grpc} defines commonly used attributes, but they are not guaranteed to be present.
-   *
-   * @return non-{@code null} Attributes container
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1779")
-  public Attributes getAttributes() {
-    return Attributes.EMPTY;
-  }
-
-  /**
-   * The {@link MethodDescriptor} for the call.
-   */
-  public abstract MethodDescriptor<ReqT, RespT> getMethodDescriptor();
-}
diff --git a/core/src/main/java/io/grpc/ServerCallHandler.java b/core/src/main/java/io/grpc/ServerCallHandler.java
deleted file mode 100644
index 8c98774c518..00000000000
--- a/core/src/main/java/io/grpc/ServerCallHandler.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * Interface to initiate processing of incoming remote calls. Advanced applications and generated
- * code will implement this interface to allows {@link Server}s to invoke service methods.
- */
-@ThreadSafe
-public interface ServerCallHandler<RequestT, ResponseT> {
-  /**
-   * Produce a non-{@code null} listener for the incoming call. Implementations are free to call
-   * methods on {@code call} before this method has returned.
-   *
-   * <p>If the implementation throws an exception, {@code call} will be closed with an error.
-   * Implementations must not throw an exception if they started processing that may use {@code
-   * call} on another thread.
-   *
-   * @param call object for responding to the remote client.
-   * @return listener for processing incoming request messages for {@code call}
-   */
-  ServerCall.Listener<RequestT> startCall(
-      ServerCall<RequestT, ResponseT> call,
-      Metadata headers);
-}
diff --git a/core/src/main/java/io/grpc/ServerInterceptor.java b/core/src/main/java/io/grpc/ServerInterceptor.java
deleted file mode 100644
index d4ccf14dc45..00000000000
--- a/core/src/main/java/io/grpc/ServerInterceptor.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * Interface for intercepting incoming calls before that are dispatched by
- * {@link ServerCallHandler}.
- *
- * <p>Implementers use this mechanism to add cross-cutting behavior to server-side calls. Common
- * example of such behavior include:
- * <ul>
- * <li>Enforcing valid authentication credentials</li>
- * <li>Logging and monitoring call behavior</li>
- * <li>Delegating calls to other servers</li>
- * </ul>
- */
-@ThreadSafe
-public interface ServerInterceptor {
-  /**
-   * Intercept {@link ServerCall} dispatch by the {@code next} {@link ServerCallHandler}. General
-   * semantics of {@link ServerCallHandler#startCall} apply and the returned
-   * {@link io.grpc.ServerCall.Listener} must not be {@code null}.
-   *
-   * <p>If the implementation throws an exception, {@code call} will be closed with an error.
-   * Implementations must not throw an exception if they started processing that may use {@code
-   * call} on another thread.
-   *
-   * @param call object to receive response messages
-   * @param next next processor in the interceptor chain
-   * @return listener for processing incoming messages for {@code call}, never {@code null}.
-   */
-  <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
-      ServerCall<ReqT, RespT> call,
-      Metadata headers,
-      ServerCallHandler<ReqT, RespT> next);
-}
diff --git a/core/src/main/java/io/grpc/ServerInterceptors.java b/core/src/main/java/io/grpc/ServerInterceptors.java
deleted file mode 100644
index f1587dcee04..00000000000
--- a/core/src/main/java/io/grpc/ServerInterceptors.java
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.common.base.Preconditions;
-import java.io.BufferedInputStream;
-import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * Utility methods for working with {@link ServerInterceptor}s.
- */
-public final class ServerInterceptors {
-  // Prevent instantiation
-  private ServerInterceptors() {}
-
-  /**
-   * Create a new {@code ServerServiceDefinition} whose {@link ServerCallHandler}s will call
-   * {@code interceptors} before calling the pre-existing {@code ServerCallHandler}. The first
-   * interceptor will have its {@link ServerInterceptor#interceptCall} called first.
-   *
-   * @param serviceDef   the service definition for which to intercept all its methods.
-   * @param interceptors array of interceptors to apply to the service.
-   * @return a wrapped version of {@code serviceDef} with the interceptors applied.
-   */
-  public static ServerServiceDefinition interceptForward(ServerServiceDefinition serviceDef,
-                                                         ServerInterceptor... interceptors) {
-    return interceptForward(serviceDef, Arrays.asList(interceptors));
-  }
-
-  public static ServerServiceDefinition interceptForward(BindableService bindableService,
-      ServerInterceptor... interceptors) {
-    return interceptForward(bindableService.bindService(), Arrays.asList(interceptors));
-  }
-
-  /**
-   * Create a new {@code ServerServiceDefinition} whose {@link ServerCallHandler}s will call
-   * {@code interceptors} before calling the pre-existing {@code ServerCallHandler}. The first
-   * interceptor will have its {@link ServerInterceptor#interceptCall} called first.
-   *
-   * @param serviceDef   the service definition for which to intercept all its methods.
-   * @param interceptors list of interceptors to apply to the service.
-   * @return a wrapped version of {@code serviceDef} with the interceptors applied.
-   */
-  public static ServerServiceDefinition interceptForward(
-      ServerServiceDefinition serviceDef,
-      List<? extends ServerInterceptor> interceptors) {
-    List<? extends ServerInterceptor> copy = new ArrayList<ServerInterceptor>(interceptors);
-    Collections.reverse(copy);
-    return intercept(serviceDef, copy);
-  }
-
-  public static ServerServiceDefinition interceptForward(
-      BindableService bindableService,
-      List<? extends ServerInterceptor> interceptors) {
-    return interceptForward(bindableService.bindService(), interceptors);
-  }
-
-  /**
-   * Create a new {@code ServerServiceDefinition} whose {@link ServerCallHandler}s will call
-   * {@code interceptors} before calling the pre-existing {@code ServerCallHandler}. The last
-   * interceptor will have its {@link ServerInterceptor#interceptCall} called first.
-   *
-   * @param serviceDef   the service definition for which to intercept all its methods.
-   * @param interceptors array of interceptors to apply to the service.
-   * @return a wrapped version of {@code serviceDef} with the interceptors applied.
-   */
-  public static ServerServiceDefinition intercept(ServerServiceDefinition serviceDef,
-                                                  ServerInterceptor... interceptors) {
-    return intercept(serviceDef, Arrays.asList(interceptors));
-  }
-
-  public static ServerServiceDefinition intercept(BindableService bindableService,
-      ServerInterceptor... interceptors) {
-    Preconditions.checkNotNull(bindableService, "bindableService");
-    return intercept(bindableService.bindService(), Arrays.asList(interceptors));
-  }
-
-  /**
-   * Create a new {@code ServerServiceDefinition} whose {@link ServerCallHandler}s will call
-   * {@code interceptors} before calling the pre-existing {@code ServerCallHandler}. The last
-   * interceptor will have its {@link ServerInterceptor#interceptCall} called first.
-   *
-   * @param serviceDef   the service definition for which to intercept all its methods.
-   * @param interceptors list of interceptors to apply to the service.
-   * @return a wrapped version of {@code serviceDef} with the interceptors applied.
-   */
-  public static ServerServiceDefinition intercept(ServerServiceDefinition serviceDef,
-                                                  List<? extends ServerInterceptor> interceptors) {
-    Preconditions.checkNotNull(serviceDef, "serviceDef");
-    if (interceptors.isEmpty()) {
-      return serviceDef;
-    }
-    ServerServiceDefinition.Builder serviceDefBuilder
-        = ServerServiceDefinition.builder(serviceDef.getServiceDescriptor());
-    for (ServerMethodDefinition<?, ?> method : serviceDef.getMethods()) {
-      wrapAndAddMethod(serviceDefBuilder, method, interceptors);
-    }
-    return serviceDefBuilder.build();
-  }
-
-  public static ServerServiceDefinition intercept(BindableService bindableService,
-      List<? extends ServerInterceptor> interceptors) {
-    Preconditions.checkNotNull(bindableService, "bindableService");
-    return intercept(bindableService.bindService(), interceptors);
-  }
-
-  /**
-   * Create a new {@code ServerServiceDefinition} whose {@link MethodDescriptor} serializes to
-   * and from InputStream for all methods.  The InputStream is guaranteed return true for
-   * markSupported().  The {@code ServerCallHandler} created will automatically
-   * convert back to the original types for request and response before calling the existing
-   * {@code ServerCallHandler}.  Calling this method combined with the intercept methods will
-   * allow the developer to choose whether to intercept messages of InputStream, or the modeled
-   * types of their application.
-   *
-   * @param serviceDef the service definition to convert messages to InputStream
-   * @return a wrapped version of {@code serviceDef} with the InputStream conversion applied.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1712")
-  public static ServerServiceDefinition useInputStreamMessages(
-      final ServerServiceDefinition serviceDef) {
-    final MethodDescriptor.Marshaller<InputStream> marshaller =
-        new MethodDescriptor.Marshaller<InputStream>() {
-      @Override
-      public InputStream stream(final InputStream value) {
-        return value;
-      }
-
-      @Override
-      public InputStream parse(final InputStream stream) {
-        if (stream.markSupported()) {
-          return stream;
-        } else {
-          return new BufferedInputStream(stream);
-        }
-      }
-    };
-
-    return useMarshalledMessages(serviceDef, marshaller);
-  }
-
-  /**
-   * Create a new {@code ServerServiceDefinition} whose {@link MethodDescriptor} serializes to
-   * and from T for all methods.  The {@code ServerCallHandler} created will automatically
-   * convert back to the original types for request and response before calling the existing
-   * {@code ServerCallHandler}.  Calling this method combined with the intercept methods will
-   * allow the developer to choose whether to intercept messages of T, or the modeled types
-   * of their application.  This can also be chained to allow for interceptors to handle messages
-   * as multiple different T types within the chain if the added cost of serialization is not
-   * a concern.
-   *
-   * @param serviceDef the service definition to convert messages to T
-   * @return a wrapped version of {@code serviceDef} with the T conversion applied.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1712")
-  public static <T> ServerServiceDefinition useMarshalledMessages(
-      final ServerServiceDefinition serviceDef,
-      final MethodDescriptor.Marshaller<T> marshaller) {
-    List<ServerMethodDefinition<?, ?>> wrappedMethods =
-        new ArrayList<ServerMethodDefinition<?, ?>>();
-    List<MethodDescriptor<?, ?>> wrappedDescriptors =
-        new ArrayList<MethodDescriptor<?, ?>>();
-    // Wrap the descriptors
-    for (final ServerMethodDefinition<?, ?> definition : serviceDef.getMethods()) {
-      final MethodDescriptor<?, ?> originalMethodDescriptor = definition.getMethodDescriptor();
-      final MethodDescriptor<T, T> wrappedMethodDescriptor =
-          originalMethodDescriptor.toBuilder(marshaller, marshaller).build();
-      wrappedDescriptors.add(wrappedMethodDescriptor);
-      wrappedMethods.add(wrapMethod(definition, wrappedMethodDescriptor));
-    }
-    // Build the new service descriptor
-    final ServerServiceDefinition.Builder serviceBuilder = ServerServiceDefinition
-        .builder(new ServiceDescriptor(serviceDef.getServiceDescriptor().getName(),
-            wrappedDescriptors));
-    // Create the new service definiton.
-    for (ServerMethodDefinition<?, ?> definition : wrappedMethods) {
-      serviceBuilder.addMethod(definition);
-    }
-    return serviceBuilder.build();
-  }
-
-  private static <ReqT, RespT> void wrapAndAddMethod(
-      ServerServiceDefinition.Builder serviceDefBuilder, ServerMethodDefinition<ReqT, RespT> method,
-      List<? extends ServerInterceptor> interceptors) {
-    ServerCallHandler<ReqT, RespT> callHandler = method.getServerCallHandler();
-    for (ServerInterceptor interceptor : interceptors) {
-      callHandler = InterceptCallHandler.create(interceptor, callHandler);
-    }
-    serviceDefBuilder.addMethod(method.withServerCallHandler(callHandler));
-  }
-
-  private static class InterceptCallHandler<ReqT, RespT> implements ServerCallHandler<ReqT, RespT> {
-    public static <ReqT, RespT> InterceptCallHandler<ReqT, RespT> create(
-        ServerInterceptor interceptor, ServerCallHandler<ReqT, RespT> callHandler) {
-      return new InterceptCallHandler<ReqT, RespT>(interceptor, callHandler);
-    }
-
-    private final ServerInterceptor interceptor;
-    private final ServerCallHandler<ReqT, RespT> callHandler;
-
-    private InterceptCallHandler(ServerInterceptor interceptor,
-                                 ServerCallHandler<ReqT, RespT> callHandler) {
-      this.interceptor = Preconditions.checkNotNull(interceptor, "interceptor");
-      this.callHandler = callHandler;
-    }
-
-    @Override
-    public ServerCall.Listener<ReqT> startCall(
-        ServerCall<ReqT, RespT> call,
-        Metadata headers) {
-      return interceptor.interceptCall(call, headers, callHandler);
-    }
-  }
-
-  private static <OReqT, ORespT, WReqT, WRespT> ServerMethodDefinition<WReqT, WRespT> wrapMethod(
-      final ServerMethodDefinition<OReqT, ORespT> definition,
-      final MethodDescriptor<WReqT, WRespT> wrappedMethod) {
-    final ServerCallHandler<WReqT, WRespT> wrappedHandler = wrapHandler(
-        definition.getServerCallHandler(),
-        definition.getMethodDescriptor(),
-        wrappedMethod);
-    return ServerMethodDefinition.create(wrappedMethod, wrappedHandler);
-  }
-
-  private static <OReqT, ORespT, WReqT, WRespT> ServerCallHandler<WReqT, WRespT> wrapHandler(
-      final ServerCallHandler<OReqT, ORespT> originalHandler,
-      final MethodDescriptor<OReqT, ORespT> originalMethod,
-      final MethodDescriptor<WReqT, WRespT> wrappedMethod) {
-    return new ServerCallHandler<WReqT, WRespT>() {
-      @Override
-      public ServerCall.Listener<WReqT> startCall(
-          final ServerCall<WReqT, WRespT> call,
-          final Metadata headers) {
-        final ServerCall<OReqT, ORespT> unwrappedCall =
-            new PartialForwardingServerCall<OReqT, ORespT>() {
-          @Override
-          protected ServerCall<WReqT, WRespT> delegate() {
-            return call;
-          }
-
-          @Override
-          public void sendMessage(ORespT message) {
-            final InputStream is = originalMethod.streamResponse(message);
-            final WRespT wrappedMessage = wrappedMethod.parseResponse(is);
-            delegate().sendMessage(wrappedMessage);
-          }
-
-          @Override
-          public MethodDescriptor<OReqT, ORespT> getMethodDescriptor() {
-            return originalMethod;
-          }
-        };
-
-        final ServerCall.Listener<OReqT> originalListener = originalHandler
-            .startCall(unwrappedCall, headers);
-
-        return new PartialForwardingServerCallListener<WReqT>() {
-          @Override
-          protected ServerCall.Listener<OReqT> delegate() {
-            return originalListener;
-          }
-
-          @Override
-          public void onMessage(WReqT message) {
-            final InputStream is = wrappedMethod.streamRequest(message);
-            final OReqT originalMessage = originalMethod.parseRequest(is);
-            delegate().onMessage(originalMessage);
-          }
-        };
-      }
-    };
-  }
-}
diff --git a/core/src/main/java/io/grpc/ServerMethodDefinition.java b/core/src/main/java/io/grpc/ServerMethodDefinition.java
deleted file mode 100644
index e1ccfc6edaa..00000000000
--- a/core/src/main/java/io/grpc/ServerMethodDefinition.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-/**
- * Definition of a method exposed by a {@link Server}.
- *
- * @see ServerServiceDefinition
- */
-public final class ServerMethodDefinition<ReqT, RespT> {
-  private final MethodDescriptor<ReqT, RespT> method;
-  private final ServerCallHandler<ReqT, RespT> handler;
-
-  private ServerMethodDefinition(MethodDescriptor<ReqT, RespT> method,
-      ServerCallHandler<ReqT, RespT> handler) {
-    this.method = method;
-    this.handler = handler;
-  }
-
-  /**
-   * Create a new instance.
-   *
-   * @param method the {@link MethodDescriptor} for this method.
-   * @param handler to dispatch calls to.
-   * @return a new instance.
-   */
-  public static <ReqT, RespT> ServerMethodDefinition<ReqT, RespT> create(
-      MethodDescriptor<ReqT, RespT> method,
-      ServerCallHandler<ReqT, RespT> handler) {
-    return new ServerMethodDefinition<ReqT, RespT>(method, handler);
-  }
-
-  /** The {@code MethodDescriptor} for this method. */
-  public MethodDescriptor<ReqT, RespT> getMethodDescriptor() {
-    return method;
-  }
-
-  /** Handler for incoming calls. */
-  public ServerCallHandler<ReqT, RespT> getServerCallHandler() {
-    return handler;
-  }
-
-  /**
-   * Create a new method definition with a different call handler.
-   *
-   * @param handler to bind to a cloned instance of this.
-   * @return a cloned instance of this with the new handler bound.
-   */
-  public ServerMethodDefinition<ReqT, RespT> withServerCallHandler(
-      ServerCallHandler<ReqT, RespT> handler) {
-    return new ServerMethodDefinition<ReqT, RespT>(method, handler);
-  }
-}
diff --git a/core/src/main/java/io/grpc/ServerProvider.java b/core/src/main/java/io/grpc/ServerProvider.java
deleted file mode 100644
index a1314fffa36..00000000000
--- a/core/src/main/java/io/grpc/ServerProvider.java
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.common.annotations.VisibleForTesting;
-import io.grpc.ManagedChannelProvider.ProviderNotFoundException;
-import java.util.ServiceLoader;
-
-/**
- * Provider of servers for transport agnostic consumption.
- *
- * <p>Implementations <em>should not</em> throw. If they do, it may interrupt class loading. If
- * exceptions may reasonably occur for implementation-specific reasons, implementations should
- * generally handle the exception gracefully and return {@code false} from {@link #isAvailable()}.
- */
-@Internal
-public abstract class ServerProvider {
-  private static final ServerProvider provider =
-      load(Thread.currentThread().getContextClassLoader());
-
-  @VisibleForTesting
-  static final ServerProvider load(ClassLoader cl) {
-    ServiceLoader<ServerProvider> providers = ServiceLoader.load(ServerProvider.class, cl);
-    ServerProvider best = null;
-
-    for (ServerProvider current : providers) {
-      if (!current.isAvailable()) {
-        continue;
-      } else if (best == null) {
-        best = current;
-      } else if (current.priority() > best.priority()) {
-        best = current;
-      }
-    }
-    return best;
-  }
-
-  /**
-   * Returns the ClassLoader-wide default server.
-   *
-   * @throws ProviderNotFoundException if no provider is available
-   */
-  public static ServerProvider provider() {
-    if (provider == null) {
-      throw new ProviderNotFoundException("No functional server found. "
-          + "Try adding a dependency on the grpc-netty artifact");
-    }
-    return provider;
-  }
-
-  /**
-   * Whether this provider is available for use, taking the current environment into consideration.
-   * If {@code false}, no other methods are safe to be called.
-   */
-  protected abstract boolean isAvailable();
-
-  /**
-   * A priority, from 0 to 10 that this provider should be used, taking the current environment into
-   * consideration. 5 should be considered the default, and then tweaked based on environment
-   * detection. A priority of 0 does not imply that the provider wouldn't work; just that it should
-   * be last in line.
-   */
-  protected abstract int priority();
-
-  /**
-   * Creates a new builder with the given port.
-   */
-  protected abstract ServerBuilder<?> builderForPort(int port);
-}
-
diff --git a/core/src/main/java/io/grpc/ServerServiceDefinition.java b/core/src/main/java/io/grpc/ServerServiceDefinition.java
deleted file mode 100644
index ab76cfb5828..00000000000
--- a/core/src/main/java/io/grpc/ServerServiceDefinition.java
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/** Definition of a service to be exposed via a Server. */
-public final class ServerServiceDefinition {
-  /** Convenience that constructs a {@link ServiceDescriptor} simultaneously. */
-  public static Builder builder(String serviceName) {
-    return new Builder(serviceName);
-  }
-
-  public static Builder builder(ServiceDescriptor serviceDescriptor) {
-    return new Builder(serviceDescriptor);
-  }
-
-  private final ServiceDescriptor serviceDescriptor;
-  private final Map<String, ServerMethodDefinition<?, ?>> methods;
-
-  private ServerServiceDefinition(
-      ServiceDescriptor serviceDescriptor, Map<String, ServerMethodDefinition<?, ?>> methods) {
-    this.serviceDescriptor = checkNotNull(serviceDescriptor, "serviceDescriptor");
-    this.methods =
-        Collections.unmodifiableMap(new HashMap<String, ServerMethodDefinition<?, ?>>(methods));
-  }
-
-  /**
-   * The descriptor for the service.
-   */
-  public ServiceDescriptor getServiceDescriptor() {
-    return serviceDescriptor;
-  }
-
-  public Collection<ServerMethodDefinition<?, ?>> getMethods() {
-    return methods.values();
-  }
-
-  /**
-   * Look up a method by its fully qualified name.
-   *
-   * @param methodName the fully qualified name without leading slash. E.g., "com.foo.Foo/Bar"
-   */
-  @Internal
-  public ServerMethodDefinition<?, ?> getMethod(String methodName) {
-    return methods.get(methodName);
-  }
-
-  /**
-   * Builder for constructing Service instances.
-   */
-  public static final class Builder {
-    private final String serviceName;
-    private final ServiceDescriptor serviceDescriptor;
-    private final Map<String, ServerMethodDefinition<?, ?>> methods =
-        new HashMap<String, ServerMethodDefinition<?, ?>>();
-
-    private Builder(String serviceName) {
-      this.serviceName = checkNotNull(serviceName, "serviceName");
-      this.serviceDescriptor = null;
-    }
-
-    private Builder(ServiceDescriptor serviceDescriptor) {
-      this.serviceDescriptor = checkNotNull(serviceDescriptor, "serviceDescriptor");
-      this.serviceName = serviceDescriptor.getName();
-    }
-
-    /**
-     * Add a method to be supported by the service.
-     *
-     * @param method the {@link MethodDescriptor} of this method.
-     * @param handler handler for incoming calls
-     */
-    public <ReqT, RespT> Builder addMethod(
-        MethodDescriptor<ReqT, RespT> method, ServerCallHandler<ReqT, RespT> handler) {
-      return addMethod(ServerMethodDefinition.create(
-          checkNotNull(method, "method must not be null"),
-          checkNotNull(handler, "handler must not be null")));
-    }
-
-    /** Add a method to be supported by the service. */
-    public <ReqT, RespT> Builder addMethod(ServerMethodDefinition<ReqT, RespT> def) {
-      MethodDescriptor<ReqT, RespT> method = def.getMethodDescriptor();
-      checkArgument(
-          serviceName.equals(MethodDescriptor.extractFullServiceName(method.getFullMethodName())),
-          "Method name should be prefixed with service name and separated with '/'. "
-                  + "Expected service name: '%s'. Actual fully qualifed method name: '%s'.",
-          serviceName, method.getFullMethodName());
-      String name = method.getFullMethodName();
-      checkState(!methods.containsKey(name), "Method by same name already registered: %s", name);
-      methods.put(name, def);
-      return this;
-    }
-
-    /**
-     * Construct new ServerServiceDefinition.
-     */
-    public ServerServiceDefinition build() {
-      ServiceDescriptor serviceDescriptor = this.serviceDescriptor;
-      if (serviceDescriptor == null) {
-        List<MethodDescriptor<?, ?>> methodDescriptors
-            = new ArrayList<MethodDescriptor<?, ?>>(methods.size());
-        for (ServerMethodDefinition<?, ?> serverMethod : methods.values()) {
-          methodDescriptors.add(serverMethod.getMethodDescriptor());
-        }
-        serviceDescriptor = new ServiceDescriptor(serviceName, methodDescriptors);
-      }
-      Map<String, ServerMethodDefinition<?, ?>> tmpMethods =
-          new HashMap<String, ServerMethodDefinition<?, ?>>(methods);
-      for (MethodDescriptor<?, ?> descriptorMethod : serviceDescriptor.getMethods()) {
-        ServerMethodDefinition<?, ?> removed = tmpMethods.remove(
-            descriptorMethod.getFullMethodName());
-        if (removed == null) {
-          throw new IllegalStateException(
-              "No method bound for descriptor entry " + descriptorMethod.getFullMethodName());
-        }
-        if (removed.getMethodDescriptor() != descriptorMethod) {
-          throw new IllegalStateException(
-              "Bound method for " + descriptorMethod.getFullMethodName()
-                  + " not same instance as method in service descriptor");
-        }
-      }
-      if (tmpMethods.size() > 0) {
-        throw new IllegalStateException(
-            "No entry in descriptor matching bound method "
-                + tmpMethods.values().iterator().next().getMethodDescriptor().getFullMethodName());
-      }
-      return new ServerServiceDefinition(serviceDescriptor, methods);
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/ServerTransportFilter.java b/core/src/main/java/io/grpc/ServerTransportFilter.java
deleted file mode 100644
index 35d6d989daf..00000000000
--- a/core/src/main/java/io/grpc/ServerTransportFilter.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-/**
- * Listens on server transport life-cycle events, with the capability to read and/or change
- * transport attributes.  Attributes returned by this filter will be merged into {@link
- * ServerCall#getAttributes}.
- *
- * <p>Multiple filters maybe registered to a server, in which case the output of a filter is the
- * input of the next filter.  For example, what returned by {@link #transportReady} of a filter is
- * passed to the same method of the next filter, and the last filter's return value is the effective
- * transport attributes.  A filter should modify the passed-in attributes instead of creating one
- * from scratch.
- *
- * <p>{@link Grpc} defines commonly used attributes.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2132")
-public abstract class ServerTransportFilter {
-  /**
-   * Called when a transport is ready to process streams.  All necessary handshakes, e.g., TLS
-   * handshake, are done at this point.
-   *
-   * <p>Note the implementation should always inherit the passed-in attributes using {@code
-   * Attributes.newBuilder(transportAttrs)}, instead of creating one from scratch.
-   *
-   * @param transportAttrs current transport attributes
-   *
-   * @return new transport attributes. Default implementation returns the passed-in attributes
-   *         intact.
-   */
-  public Attributes transportReady(Attributes transportAttrs) {
-    return transportAttrs;
-  }
-
-  /**
-   * Called when a transport is terminated.  Default implementation is no-op.
-   *
-   * @param transportAttrs the effective transport attributes, which is what returned by {@link
-   * #transportReady} of the last executed filter.
-   */
-  public void transportTerminated(Attributes transportAttrs) {
-  }
-}
diff --git a/core/src/main/java/io/grpc/ServiceDescriptor.java b/core/src/main/java/io/grpc/ServiceDescriptor.java
deleted file mode 100644
index a75bb48b2e8..00000000000
--- a/core/src/main/java/io/grpc/ServiceDescriptor.java
+++ /dev/null
@@ -1,222 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import javax.annotation.Nullable;
-
-/**
- * Descriptor for a service.
- *
- * @since 1.0.0
- */
-public final class ServiceDescriptor {
-
-  private final String name;
-  private final Collection<MethodDescriptor<?, ?>> methods;
-  private final Object schemaDescriptor;
-
-  /**
-   * Constructs a new Service Descriptor.  Users are encouraged to use {@link #newBuilder}
-   * instead.
-   *
-   * @param name The name of the service
-   * @param methods The methods that are part of the service
-   * @since 1.0.0
-   */
-  public ServiceDescriptor(String name, MethodDescriptor<?, ?>... methods) {
-    this(name, Arrays.asList(methods));
-  }
-
-  /**
-   * Constructs a new Service Descriptor.  Users are encouraged to use {@link #newBuilder}
-   * instead.
-   *
-   * @param name The name of the service
-   * @param methods The methods that are part of the service
-   * @since 1.0.0
-   */
-  public ServiceDescriptor(String name, Collection<MethodDescriptor<?, ?>> methods) {
-    this(newBuilder(name).addAllMethods(checkNotNull(methods, "methods")));
-  }
-
-  private ServiceDescriptor(Builder b) {
-    this.name = b.name;
-    validateMethodNames(name, b.methods);
-    this.methods = Collections.unmodifiableList(new ArrayList<MethodDescriptor<?, ?>>(b.methods));
-    this.schemaDescriptor = b.schemaDescriptor;
-  }
-
-  /**
-   * Simple name of the service. It is not an absolute path.
-   *
-   * @since 1.0.0
-   */
-  public String getName() {
-    return name;
-  }
-
-  /**
-   * A collection of {@link MethodDescriptor} instances describing the methods exposed by the
-   * service.
-   *
-   * @since 1.0.0
-   */
-  public Collection<MethodDescriptor<?, ?>> getMethods() {
-    return methods;
-  }
-
-  /**
-   * Returns the schema descriptor for this service.  A schema descriptor is an object that is not
-   * used by gRPC core but includes information related to the service.  The type of the object
-   * is specific to the consumer, so both the code setting the schema descriptor and the code
-   * calling {@link #getSchemaDescriptor()} must coordinate.  For example, protobuf generated code
-   * sets this value, in order to be consumed by the server reflection service.  See also:
-   * {@code io.grpc.protobuf.ProtoFileDescriptorSupplier}.
-   *
-   * @since 1.1.0
-   */
-  @Nullable
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2666")
-  public Object getSchemaDescriptor() {
-    return schemaDescriptor;
-  }
-
-  static void validateMethodNames(String serviceName, Collection<MethodDescriptor<?, ?>> methods) {
-    Set<String> allNames = new HashSet<String>(methods.size());
-    for (MethodDescriptor<?, ?> method : methods) {
-      checkNotNull(method, "method");
-      String methodServiceName =
-          MethodDescriptor.extractFullServiceName(method.getFullMethodName());
-      checkArgument(serviceName.equals(methodServiceName),
-          "service names %s != %s", methodServiceName, serviceName);
-      checkArgument(allNames.add(method.getFullMethodName()),
-          "duplicate name %s", method.getFullMethodName());
-    }
-  }
-
-  /**
-   * Creates a new builder for a {@link ServiceDescriptor}.
-   *
-   * @since 1.1.0
-   */
-  public static Builder newBuilder(String name) {
-    return new Builder(name);
-  }
-
-  /**
-   * A builder for a {@link ServiceDescriptor}.
-   *
-   * @since 1.1.0
-   */
-  public static final class Builder {
-    private Builder(String name) {
-      setName(name);
-    }
-
-    private String name;
-    private List<MethodDescriptor<?, ?>> methods = new ArrayList<MethodDescriptor<?, ?>>();
-    private Object schemaDescriptor;
-
-    /**
-     * Sets the name.  This should be non-{@code null}.
-     *
-     * @param name The name of the service.
-     * @return this builder.
-     * @since 1.1.0
-     */
-    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2666")
-    public Builder setName(String name) {
-      this.name = checkNotNull(name, "name");
-      return this;
-    }
-
-    /**
-     * Adds a method to this service.  This should be non-{@code null}.
-     *
-     * @param method the method to add to the descriptor.
-     * @return this builder.
-     * @since 1.1.0
-     */
-    public Builder addMethod(MethodDescriptor<?, ?> method) {
-      methods.add(checkNotNull(method, "method"));
-      return this;
-    }
-
-    /**
-     * Currently not exposed.  Bulk adds methods to this builder.
-     *
-     * @param methods the methods to add.
-     * @return this builder.
-     */
-    private Builder addAllMethods(Collection<MethodDescriptor<?, ?>> methods) {
-      this.methods.addAll(methods);
-      return this;
-    }
-
-    /**
-     * Sets the schema descriptor for this builder.  A schema descriptor is an object that is not
-     * used by gRPC core but includes information related to the service.  The type of the object
-     * is specific to the consumer, so both the code calling this and the code calling
-     * {@link ServiceDescriptor#getSchemaDescriptor()} must coordinate.  For example, protobuf
-     * generated code sets this value, in order to be consumed by the server reflection service.
-     *
-     * @param schemaDescriptor an object that describes the service structure.  Should be immutable.
-     * @return this builder.
-     * @since 1.1.0
-     */
-    public Builder setSchemaDescriptor(@Nullable Object schemaDescriptor) {
-      this.schemaDescriptor = schemaDescriptor;
-      return this;
-    }
-
-    /**
-     * Constructs a new {@link ServiceDescriptor}.  {@link #setName} should have been called with a
-     * non-{@code null} value before calling this.
-     *
-     * @return a new ServiceDescriptor
-     * @since 1.1.0
-     */
-    public ServiceDescriptor build() {
-      return new ServiceDescriptor(this);
-    }
-  }
-}
\ No newline at end of file
diff --git a/core/src/main/java/io/grpc/StatusException.java b/core/src/main/java/io/grpc/StatusException.java
deleted file mode 100644
index fe62fe62348..00000000000
--- a/core/src/main/java/io/grpc/StatusException.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import javax.annotation.Nullable;
-
-/**
- * {@link Status} in Exception form, for propagating Status information via exceptions. This is
- * semantically equivalent to {@link StatusRuntimeException}, except for usage in APIs that promote
- * checked exceptions. gRPC's stubs favor {@code StatusRuntimeException}.
- */
-public class StatusException extends Exception {
-  private static final long serialVersionUID = -660954903976144640L;
-  private final Status status;
-  private final Metadata trailers;
-
-  public StatusException(Status status) {
-    this(status, null);
-  }
-
-  /**
-   * Constructs an exception with both a status and trailers.
-   */
-  @ExperimentalApi
-  public StatusException(Status status, @Nullable Metadata trailers) {
-    super(Status.formatThrowableMessage(status), status.getCause());
-    this.status = status;
-    this.trailers = trailers;
-  }
-
-  public final Status getStatus() {
-    return status;
-  }
-
-  @ExperimentalApi
-  public final Metadata getTrailers() {
-    return trailers;
-  }
-}
diff --git a/core/src/main/java/io/grpc/StatusRuntimeException.java b/core/src/main/java/io/grpc/StatusRuntimeException.java
deleted file mode 100644
index d6e9c897afb..00000000000
--- a/core/src/main/java/io/grpc/StatusRuntimeException.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import javax.annotation.Nullable;
-
-/**
- * {@link Status} in RuntimeException form, for propagating Status information via exceptions.
- *
- * @see StatusException
- */
-public class StatusRuntimeException extends RuntimeException {
-
-  private static final long serialVersionUID = 1950934672280720624L;
-  private final Status status;
-  private final Metadata trailers;
-
-  public StatusRuntimeException(Status status) {
-    this(status, null);
-  }
-
-  /**
-   * Constructs the exception with both a status and trailers.
-   */
-  @ExperimentalApi
-  public StatusRuntimeException(Status status, @Nullable Metadata trailers) {
-    super(Status.formatThrowableMessage(status), status.getCause());
-    this.status = status;
-    this.trailers = trailers;
-  }
-
-  public final Status getStatus() {
-    return status;
-  }
-
-  @ExperimentalApi
-  public final Metadata getTrailers() {
-    return trailers;
-  }
-}
diff --git a/core/src/main/java/io/grpc/TransportManager.java b/core/src/main/java/io/grpc/TransportManager.java
deleted file mode 100644
index 648ad9cffd4..00000000000
--- a/core/src/main/java/io/grpc/TransportManager.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import com.google.common.base.Supplier;
-import java.util.Collection;
-
-/**
- * Manages transport life-cycles and provide ready-to-use transports.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1781")
-public abstract class TransportManager<T> {
-  /**
-   * Advises this {@code TransportManager} to retain transports only to these servers, for warming
-   * up connections and discarding unused connections.
-   */
-  public abstract void updateRetainedTransports(Collection<EquivalentAddressGroup> addrs);
-
-  /**
-   * Returns a transport for any of the addresses from the given address group.
-   *
-   * <p>Never returns {@code null}
-   */
-  public abstract T getTransport(EquivalentAddressGroup addressGroup);
-
-  /**
-   * Creates a transport that would fail all RPCs with the given error.
-   */
-  public abstract T createFailingTransport(Status error);
-
-  /**
-   * Returns a transport that is not associated with any address. It holds RPCs until it's closed,
-   * at which moment all held RPCs are transferred to actual transports.
-   *
-   * <p>This method is typically used in lieu of {@link #getTransport} before server addresses are
-   * known.
-   *
-   * <p>The returned interim transport is tracked by this {@link TransportManager}. You must call
-   * {@link InterimTransport#closeWithRealTransports} or {@link InterimTransport#closeWithError}
-   * when it's no longer used, so that {@link TransportManager} can get rid of it.
-   */
-  public abstract InterimTransport<T> createInterimTransport();
-
-  /**
-   * Creates an {@link OobTransportProvider} with a specific authority.
-   */
-  public abstract OobTransportProvider<T> createOobTransportProvider(
-      EquivalentAddressGroup addressGroup, String authority);
-
-  /**
-   * Returns a channel that uses {@code transport}; useful for issuing RPCs on a transport.
-   */
-  public abstract Channel makeChannel(T transport);
-
-  /**
-   * A transport provided as a temporary holder of new requests, which will be eventually
-   * transferred to real transports or fail.
-   *
-   * @see #createInterimTransport
-   */
-  public interface InterimTransport<T> {
-    /**
-     * Returns the transport object.
-     *
-     * @throws IllegalStateException if {@link #closeWithRealTransports} or {@link #closeWithError}
-     *     has been called
-     */
-    T transport();
-
-    /**
-     * Closes the interim transport by transferring pending RPCs to the given real transports.
-     *
-     * <p>Each pending RPC will result in an invocation to {@link Supplier#get} once.
-     */
-    void closeWithRealTransports(Supplier<T> realTransports);
-
-    /**
-     * Closes the interim transport by failing all pending RPCs with the given error.
-     */
-    void closeWithError(Status error);
-  }
-
-  /**
-   * A provider for out-of-band transports, usually used by a load-balancer that needs to
-   * communicate with an external load-balancing service which is under an authority different from
-   * what the channel is associated with.
-   */
-  public interface OobTransportProvider<T> {
-    /**
-     * Returns an OOB transport.
-     */
-    T get();
-
-    /**
-     * Closes the provider and shuts down all associated transports.
-     */
-    void close();
-  }
-}
diff --git a/core/src/main/java/io/grpc/inprocess/InProcessChannelBuilder.java b/core/src/main/java/io/grpc/inprocess/InProcessChannelBuilder.java
deleted file mode 100644
index ec9077c5099..00000000000
--- a/core/src/main/java/io/grpc/inprocess/InProcessChannelBuilder.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.inprocess;
-
-import com.google.common.base.Preconditions;
-import com.google.instrumentation.stats.StatsContextFactory;
-import io.grpc.ExperimentalApi;
-import io.grpc.Internal;
-import io.grpc.internal.AbstractManagedChannelImplBuilder;
-import io.grpc.internal.ClientTransportFactory;
-import io.grpc.internal.ConnectionClientTransport;
-import io.grpc.internal.NoopStatsContextFactory;
-import java.net.SocketAddress;
-
-/**
- * Builder for a channel that issues in-process requests. Clients identify the in-process server by
- * its name.
- *
- * <p>The channel is intended to be fully-featured, high performance, and useful in testing.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1783")
-public class InProcessChannelBuilder extends
-        AbstractManagedChannelImplBuilder<InProcessChannelBuilder> {
-  /**
-   * Create a channel builder that will connect to the server with the given name.
-   *
-   * @param name the identity of the server to connect to
-   * @return a new builder
-   */
-  public static InProcessChannelBuilder forName(String name) {
-    return new InProcessChannelBuilder(name);
-  }
-
-  private final String name;
-
-  private InProcessChannelBuilder(String name) {
-    super(new InProcessSocketAddress(name), "localhost");
-    this.name = Preconditions.checkNotNull(name, "name");
-    // TODO(zhangkun83): InProcessTransport by-passes framer and deframer, thus message sizses are
-    // not counted.  Therefore, we disable stats for now.
-    // (https://github.com/grpc/grpc-java/issues/2284)
-    super.statsContextFactory(NoopStatsContextFactory.INSTANCE);
-  }
-
-  @Override
-  public final InProcessChannelBuilder maxInboundMessageSize(int max) {
-    // TODO(carl-mastrangelo): maybe throw an exception since this not enforced?
-    return super.maxInboundMessageSize(max);
-  }
-
-  /**
-   * Does nothing.
-   */
-  @Override
-  public InProcessChannelBuilder usePlaintext(boolean skipNegotiation) {
-    return this;
-  }
-
-  @Override
-  protected ClientTransportFactory buildTransportFactory() {
-    return new InProcessClientTransportFactory(name);
-  }
-
-  @Internal
-  @Override
-  public InProcessChannelBuilder statsContextFactory(StatsContextFactory statsFactory) {
-    // TODO(zhangkun83): InProcessTransport by-passes framer and deframer, thus message sizses are
-    // not counted.  Stats is disabled by using a NOOP stats factory in the constructor, and here
-    // we prevent the user from overriding it.
-    // (https://github.com/grpc/grpc-java/issues/2284)
-    return this;
-  }
-
-  /**
-   * Creates InProcess transports. Exposed for internal use, as it should be private.
-   */
-  @Internal
-  static final class InProcessClientTransportFactory implements ClientTransportFactory {
-    private final String name;
-
-    private boolean closed;
-
-    private InProcessClientTransportFactory(String name) {
-      this.name = name;
-    }
-
-    @Override
-    public ConnectionClientTransport newClientTransport(
-        SocketAddress addr, String authority, String userAgent) {
-      if (closed) {
-        throw new IllegalStateException("The transport factory is closed.");
-      }
-      return new InProcessTransport(name, authority);
-    }
-
-    @Override
-    public void close() {
-      closed = true;
-      // Do nothing.
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/inprocess/InProcessServer.java b/core/src/main/java/io/grpc/inprocess/InProcessServer.java
deleted file mode 100644
index 9613f292d75..00000000000
--- a/core/src/main/java/io/grpc/inprocess/InProcessServer.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.inprocess;
-
-import io.grpc.internal.InternalServer;
-import io.grpc.internal.ServerListener;
-import io.grpc.internal.ServerTransportListener;
-import java.io.IOException;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import javax.annotation.concurrent.ThreadSafe;
-
-@ThreadSafe
-class InProcessServer implements InternalServer {
-  private static final ConcurrentMap<String, InProcessServer> registry
-      = new ConcurrentHashMap<String, InProcessServer>();
-
-  static InProcessServer findServer(String name) {
-    return registry.get(name);
-  }
-
-  private final String name;
-  private ServerListener listener;
-  private boolean shutdown;
-
-  InProcessServer(String name) {
-    this.name = name;
-  }
-
-  @Override
-  public void start(ServerListener serverListener) throws IOException {
-    this.listener = serverListener;
-    // Must be last, as channels can start connecting after this point.
-    if (registry.putIfAbsent(name, this) != null) {
-      throw new IOException("name already registered: " + name);
-    }
-  }
-
-  @Override
-  public int getPort() {
-    return -1;
-  }
-
-  @Override
-  public void shutdown() {
-    if (!registry.remove(name, this)) {
-      throw new AssertionError();
-    }
-    synchronized (this) {
-      shutdown = true;
-      listener.serverShutdown();
-    }
-  }
-
-  synchronized ServerTransportListener register(InProcessTransport transport) {
-    if (shutdown) {
-      return null;
-    }
-    return listener.transportCreated(transport);
-  }
-}
diff --git a/core/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java b/core/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java
deleted file mode 100644
index a1f05d2f8b1..00000000000
--- a/core/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.inprocess;
-
-import com.google.common.base.Preconditions;
-import com.google.instrumentation.stats.StatsContextFactory;
-import io.grpc.ExperimentalApi;
-import io.grpc.Internal;
-import io.grpc.internal.AbstractServerImplBuilder;
-import io.grpc.internal.NoopStatsContextFactory;
-import java.io.File;
-
-/**
- * Builder for a server that services in-process requests. Clients identify the in-process server by
- * its name.
- *
- * <p>The server is intended to be fully-featured, high performance, and useful in testing.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1783")
-public final class InProcessServerBuilder
-        extends AbstractServerImplBuilder<InProcessServerBuilder> {
-  /**
-   * Create a server builder that will bind with the given name.
-   *
-   * @param name the identity of the server for clients to connect to
-   * @return a new builder
-   */
-  public static InProcessServerBuilder forName(String name) {
-    return new InProcessServerBuilder(name);
-  }
-
-  private final String name;
-
-  private InProcessServerBuilder(String name) {
-    this.name = Preconditions.checkNotNull(name, "name");
-    // TODO(zhangkun83): InProcessTransport by-passes framer and deframer, thus message sizses are
-    // not counted.  Therefore, we disable stats for now.
-    // (https://github.com/grpc/grpc-java/issues/2284)
-    super.statsContextFactory(NoopStatsContextFactory.INSTANCE);
-  }
-
-  @Override
-  protected InProcessServer buildTransportServer() {
-    return new InProcessServer(name);
-  }
-
-  @Override
-  public InProcessServerBuilder useTransportSecurity(File certChain, File privateKey) {
-    throw new UnsupportedOperationException("TLS not supported in InProcessServer");
-  }
-
-  @Internal
-  @Override
-  public InProcessServerBuilder statsContextFactory(StatsContextFactory statsFactory) {
-    // TODO(zhangkun83): InProcessTransport by-passes framer and deframer, thus message sizses are
-    // not counted.  Stats is disabled by using a NOOP stats factory in the constructor, and here
-    // we prevent the user from overriding it.
-    // (https://github.com/grpc/grpc-java/issues/2284)
-    return this;
-  }
-}
diff --git a/core/src/main/java/io/grpc/inprocess/InProcessSocketAddress.java b/core/src/main/java/io/grpc/inprocess/InProcessSocketAddress.java
deleted file mode 100644
index dc7ab3b1ce4..00000000000
--- a/core/src/main/java/io/grpc/inprocess/InProcessSocketAddress.java
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.inprocess;
-
-import java.net.SocketAddress;
-
-/**
- * Custom SocketAddress class for {@link InProcessTransport}.
- */
-public class InProcessSocketAddress extends SocketAddress {
-  private static final long serialVersionUID = -2803441206326023474L;
-
-  private final String name;
-
-  public InProcessSocketAddress(String name) {
-    this.name = name;
-  }
-
-  public String getName() {
-    return name;
-  }
-}
diff --git a/core/src/main/java/io/grpc/inprocess/InProcessTransport.java b/core/src/main/java/io/grpc/inprocess/InProcessTransport.java
deleted file mode 100644
index 5821e09d8ad..00000000000
--- a/core/src/main/java/io/grpc/inprocess/InProcessTransport.java
+++ /dev/null
@@ -1,616 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.inprocess;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import io.grpc.Attributes;
-import io.grpc.CallOptions;
-import io.grpc.Compressor;
-import io.grpc.Decompressor;
-import io.grpc.Grpc;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.Status;
-import io.grpc.internal.ClientStream;
-import io.grpc.internal.ClientStreamListener;
-import io.grpc.internal.ConnectionClientTransport;
-import io.grpc.internal.LogId;
-import io.grpc.internal.ManagedClientTransport;
-import io.grpc.internal.NoopClientStream;
-import io.grpc.internal.ServerStream;
-import io.grpc.internal.ServerStreamListener;
-import io.grpc.internal.ServerTransport;
-import io.grpc.internal.ServerTransportListener;
-import io.grpc.internal.StatsTraceContext;
-import java.io.InputStream;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.Executor;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import javax.annotation.CheckReturnValue;
-import javax.annotation.concurrent.GuardedBy;
-import javax.annotation.concurrent.ThreadSafe;
-
-@ThreadSafe
-class InProcessTransport implements ServerTransport, ConnectionClientTransport {
-  private static final Logger log = Logger.getLogger(InProcessTransport.class.getName());
-
-  private final LogId logId = LogId.allocate(getClass().getName());
-  private final String name;
-  private final String authority;
-  private ServerTransportListener serverTransportListener;
-  private Attributes serverStreamAttributes;
-  private ManagedClientTransport.Listener clientTransportListener;
-  @GuardedBy("this")
-  private boolean shutdown;
-  @GuardedBy("this")
-  private boolean terminated;
-  @GuardedBy("this")
-  private Status shutdownStatus;
-  @GuardedBy("this")
-  private Set<InProcessStream> streams = new HashSet<InProcessStream>();
-
-  public InProcessTransport(String name) {
-    this(name, null);
-  }
-
-  public InProcessTransport(String name, String authority) {
-    this.name = name;
-    this.authority = authority;
-  }
-
-  @CheckReturnValue
-  @Override
-  public synchronized Runnable start(ManagedClientTransport.Listener listener) {
-    this.clientTransportListener = listener;
-    InProcessServer server = InProcessServer.findServer(name);
-    if (server != null) {
-      serverTransportListener = server.register(this);
-    }
-    if (serverTransportListener == null) {
-      shutdownStatus = Status.UNAVAILABLE.withDescription("Could not find server: " + name);
-      final Status localShutdownStatus = shutdownStatus;
-      return new Runnable() {
-        @Override
-        public void run() {
-          synchronized (InProcessTransport.this) {
-            notifyShutdown(localShutdownStatus);
-            notifyTerminated();
-          }
-        }
-      };
-    }
-    return new Runnable() {
-      @Override
-      @SuppressWarnings("deprecation")
-      public void run() {
-        synchronized (InProcessTransport.this) {
-          Attributes serverTransportAttrs = Attributes.newBuilder()
-              .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, new InProcessSocketAddress(name))
-              .build();
-          serverStreamAttributes = serverTransportListener.transportReady(serverTransportAttrs);
-          clientTransportListener.transportReady();
-        }
-      }
-    };
-  }
-
-  @Override
-  public synchronized ClientStream newStream(
-      final MethodDescriptor<?, ?> method, final Metadata headers, final CallOptions callOptions,
-      StatsTraceContext clientStatsTraceContext) {
-    if (shutdownStatus != null) {
-      final Status capturedStatus = shutdownStatus;
-      return new NoopClientStream() {
-        @Override
-        public void start(ClientStreamListener listener) {
-          listener.closed(capturedStatus, new Metadata());
-        }
-      };
-    }
-    StatsTraceContext serverStatsTraceContext = serverTransportListener.methodDetermined(
-        method.getFullMethodName(), headers);
-    return new InProcessStream(method, headers, serverStatsTraceContext, authority).clientStream;
-  }
-
-  @Override
-  public synchronized ClientStream newStream(
-      final MethodDescriptor<?, ?> method, final Metadata headers) {
-    return newStream(method, headers, CallOptions.DEFAULT, StatsTraceContext.NOOP);
-  }
-
-  @Override
-  public synchronized void ping(final PingCallback callback, Executor executor) {
-    if (terminated) {
-      final Status shutdownStatus = this.shutdownStatus;
-      executor.execute(new Runnable() {
-        @Override
-        public void run() {
-          callback.onFailure(shutdownStatus.asRuntimeException());
-        }
-      });
-    } else {
-      executor.execute(new Runnable() {
-        @Override
-        public void run() {
-          callback.onSuccess(0);
-        }
-      });
-    }
-  }
-
-  @Override
-  public synchronized void shutdown() {
-    // Can be called multiple times: once for ManagedClientTransport, once for ServerTransport.
-    if (shutdown) {
-      return;
-    }
-    shutdownStatus = Status.UNAVAILABLE.withDescription("transport was requested to shut down");
-    notifyShutdown(shutdownStatus);
-    if (streams.isEmpty()) {
-      notifyTerminated();
-    }
-  }
-
-  @Override
-  public void shutdownNow(Status reason) {
-    checkNotNull(reason, "reason");
-    List<InProcessStream> streamsCopy;
-    synchronized (this) {
-      shutdown();
-      if (terminated) {
-        return;
-      }
-      streamsCopy = new ArrayList<InProcessStream>(streams);
-    }
-    for (InProcessStream stream : streamsCopy) {
-      stream.clientStream.cancel(reason);
-    }
-  }
-
-  @Override
-  public String toString() {
-    return getLogId() + "(" + name + ")";
-  }
-
-  @Override
-  public LogId getLogId() {
-    return logId;
-  }
-
-  @Override
-  public Attributes getAttributes() {
-    return Attributes.EMPTY;
-  }
-
-  private synchronized void notifyShutdown(Status s) {
-    if (shutdown) {
-      return;
-    }
-    shutdown = true;
-    clientTransportListener.transportShutdown(s);
-  }
-
-  private synchronized void notifyTerminated() {
-    if (terminated) {
-      return;
-    }
-    terminated = true;
-    clientTransportListener.transportTerminated();
-    if (serverTransportListener != null) {
-      serverTransportListener.transportTerminated();
-    }
-  }
-
-  private class InProcessStream {
-    private final InProcessServerStream serverStream = new InProcessServerStream();
-    private final InProcessClientStream clientStream = new InProcessClientStream();
-    private final StatsTraceContext serverStatsTraceContext;
-    private final Metadata headers;
-    private final MethodDescriptor<?, ?> method;
-    private volatile String authority;
-
-    private InProcessStream(MethodDescriptor<?, ?> method, Metadata headers,
-        StatsTraceContext serverStatsTraceContext, String authority) {
-      this.method = checkNotNull(method, "method");
-      this.headers = checkNotNull(headers, "headers");
-      this.serverStatsTraceContext =
-          checkNotNull(serverStatsTraceContext, "serverStatsTraceContext");
-      this.authority = authority;
-    }
-
-    // Can be called multiple times due to races on both client and server closing at same time.
-    private void streamClosed() {
-      synchronized (InProcessTransport.this) {
-        boolean justRemovedAnElement = streams.remove(this);
-        if (streams.isEmpty() && justRemovedAnElement) {
-          clientTransportListener.transportInUse(false);
-          if (shutdown) {
-            notifyTerminated();
-          }
-        }
-      }
-    }
-
-    private class InProcessServerStream implements ServerStream {
-      @GuardedBy("this")
-      private ClientStreamListener clientStreamListener;
-      @GuardedBy("this")
-      private int clientRequested;
-      @GuardedBy("this")
-      private ArrayDeque<InputStream> clientReceiveQueue = new ArrayDeque<InputStream>();
-      @GuardedBy("this")
-      private Status clientNotifyStatus;
-      @GuardedBy("this")
-      private Metadata clientNotifyTrailers;
-      // Only is intended to prevent double-close when client cancels.
-      @GuardedBy("this")
-      private boolean closed;
-
-      private synchronized void setListener(ClientStreamListener listener) {
-        clientStreamListener = listener;
-      }
-
-      @Override
-      public void setListener(ServerStreamListener serverStreamListener) {
-        clientStream.setListener(serverStreamListener);
-      }
-
-      @Override
-      public void request(int numMessages) {
-        boolean onReady = clientStream.serverRequested(numMessages);
-        if (onReady) {
-          synchronized (this) {
-            if (!closed) {
-              clientStreamListener.onReady();
-            }
-          }
-        }
-      }
-
-      // This method is the only reason we have to synchronize field accesses.
-      /**
-       * Client requested more messages.
-       *
-       * @return whether onReady should be called on the server
-       */
-      private synchronized boolean clientRequested(int numMessages) {
-        if (closed) {
-          return false;
-        }
-        boolean previouslyReady = clientRequested > 0;
-        clientRequested += numMessages;
-        while (clientRequested > 0 && !clientReceiveQueue.isEmpty()) {
-          clientRequested--;
-          clientStreamListener.messageRead(clientReceiveQueue.poll());
-        }
-        // Attempt being reentrant-safe
-        if (closed) {
-          return false;
-        }
-        if (clientReceiveQueue.isEmpty() && clientNotifyStatus != null) {
-          closed = true;
-          clientStreamListener.closed(clientNotifyStatus, clientNotifyTrailers);
-        }
-        boolean nowReady = clientRequested > 0;
-        return !previouslyReady && nowReady;
-      }
-
-      private void clientCancelled(Status status) {
-        internalCancel(status);
-      }
-
-      @Override
-      public synchronized void writeMessage(InputStream message) {
-        if (closed) {
-          return;
-        }
-        if (clientRequested > 0) {
-          clientRequested--;
-          clientStreamListener.messageRead(message);
-        } else {
-          clientReceiveQueue.add(message);
-        }
-      }
-
-      @Override
-      public void flush() {}
-
-      @Override
-      public synchronized boolean isReady() {
-        if (closed) {
-          return false;
-        }
-        return clientRequested > 0;
-      }
-
-      @Override
-      public synchronized void writeHeaders(Metadata headers) {
-        if (closed) {
-          return;
-        }
-        clientStreamListener.headersRead(headers);
-      }
-
-      @Override
-      public void close(Status status, Metadata trailers) {
-        status = stripCause(status);
-        synchronized (this) {
-          if (closed) {
-            return;
-          }
-          if (clientReceiveQueue.isEmpty()) {
-            closed = true;
-            clientStreamListener.closed(status, trailers);
-          } else {
-            clientNotifyStatus = status;
-            clientNotifyTrailers = trailers;
-          }
-        }
-
-        clientStream.serverClosed(Status.OK);
-        streamClosed();
-      }
-
-      @Override
-      public void cancel(Status status) {
-        if (!internalCancel(Status.CANCELLED.withDescription("server cancelled stream"))) {
-          return;
-        }
-        clientStream.serverClosed(status);
-        streamClosed();
-      }
-
-      private synchronized boolean internalCancel(Status status) {
-        if (closed) {
-          return false;
-        }
-        closed = true;
-        InputStream stream;
-        while ((stream = clientReceiveQueue.poll()) != null) {
-          try {
-            stream.close();
-          } catch (Throwable t) {
-            log.log(Level.WARNING, "Exception closing stream", t);
-          }
-        }
-        clientStreamListener.closed(status, new Metadata());
-        return true;
-      }
-
-      @Override
-      public void setMessageCompression(boolean enable) {
-         // noop
-      }
-
-      @Override
-      public void setCompressor(Compressor compressor) {}
-
-      @Override
-      public void setDecompressor(Decompressor decompressor) {}
-
-      @Override public Attributes getAttributes() {
-        return serverStreamAttributes;
-      }
-
-      @Override
-      public String getAuthority() {
-        return InProcessStream.this.authority;
-      }
-
-      @Override
-      public StatsTraceContext statsTraceContext() {
-        return serverStatsTraceContext;
-      }
-    }
-
-    private class InProcessClientStream implements ClientStream {
-      @GuardedBy("this")
-      private ServerStreamListener serverStreamListener;
-      @GuardedBy("this")
-      private int serverRequested;
-      @GuardedBy("this")
-      private ArrayDeque<InputStream> serverReceiveQueue = new ArrayDeque<InputStream>();
-      @GuardedBy("this")
-      private boolean serverNotifyHalfClose;
-      // Only is intended to prevent double-close when server closes.
-      @GuardedBy("this")
-      private boolean closed;
-
-      private synchronized void setListener(ServerStreamListener listener) {
-        this.serverStreamListener = listener;
-      }
-
-      @Override
-      public void request(int numMessages) {
-        boolean onReady = serverStream.clientRequested(numMessages);
-        if (onReady) {
-          synchronized (this) {
-            if (!closed) {
-              serverStreamListener.onReady();
-            }
-          }
-        }
-      }
-
-      // This method is the only reason we have to synchronize field accesses.
-      /**
-       * Client requested more messages.
-       *
-       * @return whether onReady should be called on the server
-       */
-      private synchronized boolean serverRequested(int numMessages) {
-        if (closed) {
-          return false;
-        }
-        boolean previouslyReady = serverRequested > 0;
-        serverRequested += numMessages;
-        while (serverRequested > 0 && !serverReceiveQueue.isEmpty()) {
-          serverRequested--;
-          serverStreamListener.messageRead(serverReceiveQueue.poll());
-        }
-        if (serverReceiveQueue.isEmpty() && serverNotifyHalfClose) {
-          serverNotifyHalfClose = false;
-          serverStreamListener.halfClosed();
-        }
-        boolean nowReady = serverRequested > 0;
-        return !previouslyReady && nowReady;
-      }
-
-      private void serverClosed(Status status) {
-        internalCancel(status);
-      }
-
-      @Override
-      public synchronized void writeMessage(InputStream message) {
-        if (closed) {
-          return;
-        }
-        if (serverRequested > 0) {
-          serverRequested--;
-          serverStreamListener.messageRead(message);
-        } else {
-          serverReceiveQueue.add(message);
-        }
-      }
-
-      @Override
-      public void flush() {}
-
-      @Override
-      public synchronized boolean isReady() {
-        if (closed) {
-          return false;
-        }
-        return serverRequested > 0;
-      }
-
-      // Must be thread-safe for shutdownNow()
-      @Override
-      public void cancel(Status reason) {
-        if (!internalCancel(stripCause(reason))) {
-          return;
-        }
-        serverStream.clientCancelled(reason);
-        streamClosed();
-      }
-
-      private synchronized boolean internalCancel(Status reason) {
-        if (closed) {
-          return false;
-        }
-        closed = true;
-        InputStream stream;
-        while ((stream = serverReceiveQueue.poll()) != null) {
-          try {
-            stream.close();
-          } catch (Throwable t) {
-            log.log(Level.WARNING, "Exception closing stream", t);
-          }
-        }
-        serverStreamListener.closed(reason);
-        return true;
-      }
-
-      @Override
-      public synchronized void halfClose() {
-        if (closed) {
-          return;
-        }
-        if (serverReceiveQueue.isEmpty()) {
-          serverStreamListener.halfClosed();
-        } else {
-          serverNotifyHalfClose = true;
-        }
-      }
-
-      @Override
-      public void setMessageCompression(boolean enable) {}
-
-      @Override
-      public void setAuthority(String string) {
-        InProcessStream.this.authority = string;
-      }
-
-      @Override
-      public void start(ClientStreamListener listener) {
-        serverStream.setListener(listener);
-
-        synchronized (InProcessTransport.this) {
-          streams.add(InProcessTransport.InProcessStream.this);
-          if (streams.size() == 1) {
-            clientTransportListener.transportInUse(true);
-          }
-          serverTransportListener.streamCreated(serverStream, method.getFullMethodName(), headers);
-        }
-      }
-
-      @Override
-      public Attributes getAttributes() {
-        return Attributes.EMPTY;
-      }
-
-      @Override
-      public void setCompressor(Compressor compressor) {}
-
-      @Override
-      public void setDecompressor(Decompressor decompressor) {}
-
-      @Override
-      public void setMaxInboundMessageSize(int maxSize) {}
-
-      @Override
-      public void setMaxOutboundMessageSize(int maxSize) {}
-    }
-  }
-
-  /**
-   * Returns a new status with the same code and description, but stripped of any other information
-   * (i.e. cause).
-   *
-   * <p>This is, so that the InProcess transport behaves in the same way as the other transports,
-   * when exchanging statuses between client and server and vice versa.
-   */
-  private static Status stripCause(Status status) {
-    if (status == null) {
-      return null;
-    }
-    return Status
-        .fromCodeValue(status.getCode().value())
-        .withDescription(status.getDescription());
-  }
-}
diff --git a/core/src/main/java/io/grpc/inprocess/package-info.java b/core/src/main/java/io/grpc/inprocess/package-info.java
deleted file mode 100644
index 7deb8e5b36b..00000000000
--- a/core/src/main/java/io/grpc/inprocess/package-info.java
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/**
- * The in-process transport which is for when a server is in the same process as the client.
- */
-package io.grpc.inprocess;
diff --git a/core/src/main/java/io/grpc/internal/AbstractClientStream.java b/core/src/main/java/io/grpc/internal/AbstractClientStream.java
index 56949609a0f..bce1820b482 100644
--- a/core/src/main/java/io/grpc/internal/AbstractClientStream.java
+++ b/core/src/main/java/io/grpc/internal/AbstractClientStream.java
@@ -1,333 +1,546 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
-import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.internal.GrpcUtil.CONTENT_ENCODING_KEY;
+import static io.grpc.internal.GrpcUtil.MESSAGE_ENCODING_KEY;
+import static io.grpc.internal.GrpcUtil.TIMEOUT_KEY;
 
-import com.google.common.base.MoreObjects;
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
+import com.google.common.io.ByteStreams;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Codec;
+import io.grpc.Compressor;
+import io.grpc.Deadline;
+import io.grpc.Decompressor;
+import io.grpc.DecompressorRegistry;
+import io.grpc.Grpc;
 import io.grpc.Metadata;
 import io.grpc.Status;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
 import java.io.InputStream;
+import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import javax.annotation.Nullable;
 
 /**
  * The abstract base class for {@link ClientStream} implementations.
+ *
+ * <p>Must only be called from the sending application thread.
  */
 public abstract class AbstractClientStream extends AbstractStream
-    implements ClientStream {
+    implements ClientStream, MessageFramer.Sink {
 
   private static final Logger log = Logger.getLogger(AbstractClientStream.class.getName());
 
-  private ClientStreamListener listener;
-  private boolean listenerClosed;
+  /**
+   * A sink for outbound operations, separated from the stream simply to avoid name
+   * collisions/confusion. Only called from application thread.
+   */
+  protected interface Sink {
+    /** 
+     * Sends the request headers to the remote end point.
+     *
+     * @param metadata the metadata to be sent
+     * @param payload the payload needs to be sent in the headers if not null. Should only be used
+     *     when sending an unary GET request
+     */
+    void writeHeaders(Metadata metadata, @Nullable byte[] payload);
+
+    /**
+     * Sends an outbound frame to the remote end point.
+     *
+     * @param frame a buffer containing the chunk of data to be sent, or {@code null} if {@code
+     *     endOfStream} with no data to send
+     * @param endOfStream {@code true} if this is the last frame; {@code flush} is guaranteed to be
+     *     {@code true} if this is {@code true}
+     * @param flush {@code true} if more data may not be arriving soon
+     * @param numMessages the number of messages this series of frames represents, must be >= 0.
+     */
+    void writeFrame(
+        @Nullable WritableBuffer frame, boolean endOfStream, boolean flush, int numMessages);
+
+    /**
+     * Tears down the stream, typically in the event of a timeout. This method may be called
+     * multiple times and from any thread.
+     *
+     * <p>This is a clone of {@link ClientStream#cancel(Status)};
+     * {@link AbstractClientStream#cancel} delegates to this method.
+     */
+    void cancel(Status status);
+  }
 
-  // Stored status & trailers to report when deframer completes or
-  // transportReportStatus is directly called.
-  private Status status;
-  private Metadata trailers;
-  private Runnable closeListenerTask;
+  private final TransportTracer transportTracer;
+  private final Framer framer;
+  private final boolean shouldBeCountedForInUse;
+  private final boolean useGet;
+  private Metadata headers;
+  /**
+   * Whether cancel() has been called. This is not strictly necessary, but removes the delay between
+   * cancel() being called and isReady() beginning to return false, since cancel is commonly
+   * processed asynchronously.
+   */
   private volatile boolean cancelled;
 
-  protected AbstractClientStream(WritableBufferAllocator bufferAllocator, int maxMessageSize,
-      StatsTraceContext statsTraceCtx) {
-    super(bufferAllocator, maxMessageSize, statsTraceCtx);
+  @SuppressWarnings("this-escape")
+  protected AbstractClientStream(
+      WritableBufferAllocator bufferAllocator,
+      StatsTraceContext statsTraceCtx,
+      TransportTracer transportTracer,
+      Metadata headers,
+      CallOptions callOptions,
+      boolean useGet) {
+    checkNotNull(headers, "headers");
+    this.transportTracer = checkNotNull(transportTracer, "transportTracer");
+    this.shouldBeCountedForInUse = GrpcUtil.shouldBeCountedForInUse(callOptions);
+    this.useGet = useGet;
+    if (!useGet) {
+      this.framer = new MessageFramer(this, bufferAllocator, statsTraceCtx);
+      this.headers = headers;
+    } else {
+      framer = new GetFramer(headers, statsTraceCtx);
+    }
   }
 
   @Override
-  public void setMaxInboundMessageSize(int maxSize) {
-    setMaxInboundMessageSizeProtected(maxSize);
+  public void setDeadline(Deadline deadline) {
+    headers.discardAll(TIMEOUT_KEY);
+    headers.put(TIMEOUT_KEY, deadline.timeRemaining(TimeUnit.NANOSECONDS));
   }
 
   @Override
   public void setMaxOutboundMessageSize(int maxSize) {
-    setMaxOutboundMessageSizeProtected(maxSize);
+    framer.setMaxOutboundMessageSize(maxSize);
   }
 
   @Override
-  protected final ClientStreamListener listener() {
-    return listener;
+  public void setMaxInboundMessageSize(int maxSize) {
+    transportState().setMaxInboundMessageSize(maxSize);
   }
 
-  /**
-   * Indicates that the stream may proceed to do traffic.  Sub classes should override and invoke
-   * this method after they have been created.
-   */
   @Override
-  public void start(ClientStreamListener listener) {
-    checkState(this.listener == null, "stream already started");
-    this.listener = checkNotNull(listener, "listener");
+  public final void setFullStreamDecompression(boolean fullStreamDecompression) {
+    transportState().setFullStreamDecompression(fullStreamDecompression);
   }
 
   @Override
-  protected void receiveMessage(InputStream is) {
-    if (!listenerClosed) {
-      checkState(listener != null, "stream not started");
-      listener.messageRead(is);
-    }
+  public final void setDecompressorRegistry(DecompressorRegistry decompressorRegistry) {
+    transportState().setDecompressorRegistry(decompressorRegistry);
   }
 
-  /**
-   * The transport implementation has detected a protocol error on the stream. Transports are
-   * responsible for properly closing streams when protocol errors occur.
-   *
-   * @param errorStatus the error to report
-   * @param metadata any metadata received
-   */
-  protected void inboundTransportError(Status errorStatus, Metadata metadata) {
-    Preconditions.checkNotNull(metadata, "metadata");
-    if (inboundPhase() == Phase.STATUS) {
-      log.log(Level.INFO, "Received transport error on closed stream {0} {1}",
-          new Object[]{id(), errorStatus});
-      return;
+  /** {@inheritDoc} */
+  @Override
+  protected abstract TransportState transportState();
+
+  @Override
+  public final void start(ClientStreamListener listener) {
+    transportState().setListener(listener);
+    if (!useGet) {
+      abstractClientStreamSink().writeHeaders(headers, null);
+      headers = null;
     }
-    // For transport errors we immediately report status to the application layer
-    // and do not wait for additional payloads.
-    transportReportStatus(errorStatus, false, metadata);
   }
 
   /**
-   * Called by transport implementations when they receive headers.
-   *
-   * @param headers the parsed headers
+   * Sink for transport to be called to perform outbound operations. Each stream must have its own
+   * unique sink.
    */
-  protected void inboundHeadersReceived(Metadata headers) {
-    checkState(listener != null, "stream not started");
-    if (inboundPhase() == Phase.STATUS) {
-      log.log(Level.INFO, "Received headers on closed stream {0} {1}",
-          new Object[]{id(), headers});
-    }
+  protected abstract Sink abstractClientStreamSink();
 
-    inboundPhase(Phase.MESSAGE);
-    listener.headersRead(headers);
+  @Override
+  protected final Framer framer() {
+    return framer;
   }
 
   /**
-   * Processes the contents of a received data frame from the server.
-   *
-   * @param frame the received data frame. Its ownership is transferred to this method.
+   * Returns true if this stream should be counted when determining the in-use state of the
+   * transport.
    */
-  protected void inboundDataReceived(ReadableBuffer frame) {
-    Preconditions.checkNotNull(frame, "frame");
-    boolean needToCloseFrame = true;
-    try {
-      if (inboundPhase() == Phase.STATUS) {
-        return;
-      }
-      if (inboundPhase() == Phase.HEADERS) {
-        // Have not received headers yet so error
-        inboundTransportError(Status.INTERNAL
-            .withDescription("headers not received before payload"), new Metadata());
-        return;
-      }
-      inboundPhase(Phase.MESSAGE);
-
-      needToCloseFrame = false;
-      deframe(frame, false);
-    } finally {
-      if (needToCloseFrame) {
-        frame.close();
-      }
-    }
+  public final boolean shouldBeCountedForInUse() {
+    return shouldBeCountedForInUse;
   }
 
   @Override
-  protected void inboundDeliveryPaused() {
-    runCloseListenerTask();
+  public final void deliverFrame(
+      WritableBuffer frame, boolean endOfStream, boolean flush, int numMessages) {
+    Preconditions.checkArgument(frame != null || endOfStream, "null frame before EOS");
+    abstractClientStreamSink().writeFrame(frame, endOfStream, flush, numMessages);
   }
 
   @Override
-  protected final void deframeFailed(Throwable cause) {
-    cancel(Status.INTERNAL.withDescription("Exception deframing message").withCause(cause));
+  public final void halfClose() {
+    if (!transportState().isOutboundClosed()) {
+      transportState().setOutboundClosed();
+      endOfMessages();
+    }
   }
 
-  /**
-   * Processes the trailers and status from the server.
-   *
-   * @param trailers the received trailers
-   * @param status the status extracted from the trailers
-   */
-  protected void inboundTrailersReceived(Metadata trailers, Status status) {
-    Preconditions.checkNotNull(trailers, "trailers");
-    if (inboundPhase() == Phase.STATUS) {
-      log.log(Level.INFO, "Received trailers on closed stream {0}\n {1}\n {2}",
-          new Object[]{id(), status, trailers});
-    }
-    // Stash the status & trailers so they can be delivered by the deframer calls
-    // remoteEndClosed
-    this.status = status;
-    this.trailers = trailers;
-    deframe(ReadableBuffers.empty(), true);
+  @Override
+  public final void cancel(Status reason) {
+    Preconditions.checkArgument(!reason.isOk(), "Should not cancel with OK status");
+    cancelled = true;
+    abstractClientStreamSink().cancel(reason);
   }
 
   @Override
-  protected void remoteEndClosed() {
-    transportReportStatus(status, true, trailers);
+  public final boolean isReady() {
+    return super.isReady() && !cancelled;
   }
 
   @Override
-  protected final void internalSendFrame(WritableBuffer frame, boolean endOfStream, boolean flush) {
-    Preconditions.checkArgument(frame != null || endOfStream, "null frame before EOS");
-    sendFrame(frame, endOfStream, flush);
+  public final void appendTimeoutInsight(InsightBuilder insight) {
+    Attributes attrs = getAttributes();
+    insight.appendKeyValue("remote_addr", attrs.get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR));
   }
 
-  /**
-   * Sends an outbound frame to the remote end point.
-   *
-   * @param frame a buffer containing the chunk of data to be sent or {@code null} if the framer is
-   *              closing and has no data to send.
-   * @param endOfStream if {@code true} indicates that no more data will be sent on the stream by
-   *        this endpoint.
-   * @param flush {@code true} if more data may not be arriving soon
-   */
-  protected abstract void sendFrame(WritableBuffer frame, boolean endOfStream, boolean flush);
+  protected TransportTracer getTransportTracer() {
+    return transportTracer;
+  }
 
-  /**
-   * Report stream closure with status to the application layer if not already reported. This method
-   * must be called from the transport thread.
-   *
-   * @param newStatus the new status to set
-   * @param stopDelivery if {@code true}, interrupts any further delivery of inbound messages that
-   *        may already be queued up in the deframer. If {@code false}, the listener will be
-   *        notified immediately after all currently completed messages in the deframer have been
-   *        delivered to the application.
-   * @param trailers new instance of {@code Trailers}, either empty or those returned by the server
-   */
-  public void transportReportStatus(final Status newStatus, boolean stopDelivery,
-      final Metadata trailers) {
-    Preconditions.checkNotNull(newStatus, "newStatus");
-
-    boolean closingLater = closeListenerTask != null && !stopDelivery;
-    if (listenerClosed || closingLater) {
-      // We already closed (or are about to close) the listener.
-      return;
+  /** This should only be called from the transport thread. */
+  protected abstract static class TransportState extends AbstractStream.TransportState {
+    /** Whether listener.closed() has been called. */
+    private final StatsTraceContext statsTraceCtx;
+    private boolean listenerClosed;
+    private ClientStreamListener listener;
+    private boolean fullStreamDecompression;
+    private DecompressorRegistry decompressorRegistry = DecompressorRegistry.getDefaultInstance();
+
+    private boolean deframerClosed = false;
+    private Runnable deframerClosedTask;
+
+    /** Whether the client has half-closed the stream. */
+    private volatile boolean outboundClosed;
+
+    /**
+     * Whether the stream is closed from the transport's perspective. This can differ from {@link
+     * #listenerClosed} because there may still be messages buffered to deliver to the application.
+     */
+    private boolean statusReported;
+    /** True if the status reported (set via {@link #transportReportStatus}) is OK. */
+    private boolean statusReportedIsOk;
+
+    protected TransportState(
+        int maxMessageSize,
+        StatsTraceContext statsTraceCtx,
+        TransportTracer transportTracer,
+        CallOptions options) {
+      super(maxMessageSize, statsTraceCtx, transportTracer);
+      this.statsTraceCtx = checkNotNull(statsTraceCtx, "statsTraceCtx");
+      if (options.getOnReadyThreshold() != null) {
+        this.setOnReadyThreshold(options.getOnReadyThreshold());
+      }
     }
 
-    inboundPhase(Phase.STATUS);
-    status = newStatus;
-    closeListenerTask = null;
+    private void setFullStreamDecompression(boolean fullStreamDecompression) {
+      this.fullStreamDecompression = fullStreamDecompression;
+    }
 
-    // Determine if the deframer is stalled (i.e. currently has no complete messages to deliver).
-    boolean deliveryStalled = isDeframerStalled();
+    private void setDecompressorRegistry(DecompressorRegistry decompressorRegistry) {
+      checkState(this.listener == null, "Already called start");
+      this.decompressorRegistry =
+          checkNotNull(decompressorRegistry, "decompressorRegistry");
+    }
 
-    if (stopDelivery || deliveryStalled) {
-      // Close the listener immediately.
-      closeListener(newStatus, trailers);
-    } else {
-      // Delay close until inboundDeliveryStalled()
-      closeListenerTask = newCloseListenerTask(newStatus, trailers);
+    @VisibleForTesting
+    public final void setListener(ClientStreamListener listener) {
+      checkState(this.listener == null, "Already called setListener");
+      this.listener = checkNotNull(listener, "listener");
     }
-  }
 
-  /**
-   * Creates a new {@link Runnable} to close the listener with the given status/trailers.
-   */
-  private Runnable newCloseListenerTask(final Status status, final Metadata trailers) {
-    return new Runnable() {
-      @Override
-      public void run() {
-        closeListener(status, trailers);
+    @Override
+    public void deframerClosed(boolean hasPartialMessage) {
+      checkState(statusReported, "status should have been reported on deframer closed");
+      deframerClosed = true;
+      if (statusReportedIsOk && hasPartialMessage) {
+        transportReportStatus(
+            Status.INTERNAL.withDescription("Encountered end-of-stream mid-frame"),
+            true,
+            new Metadata());
       }
-    };
-  }
+      if (deframerClosedTask != null) {
+        deframerClosedTask.run();
+        deframerClosedTask = null;
+      }
+    }
 
-  /**
-   * Closes the listener if not previously closed.
-   *
-   * @throws IllegalStateException if the call has not yet been started.
-   */
-  private void closeListener(Status newStatus, Metadata trailers) {
-    checkState(listener != null, "stream not started");
-    if (!listenerClosed) {
-      listenerClosed = true;
-      closeDeframer();
-      listener.closed(newStatus, trailers);
+    @Override
+    protected final ClientStreamListener listener() {
+      return listener;
     }
-  }
 
-  /**
-   * Executes the pending listener close task, if one exists.
-   */
-  private void runCloseListenerTask() {
-    if (closeListenerTask != null) {
-      closeListenerTask.run();
-      closeListenerTask = null;
+    private final void setOutboundClosed() {
+      outboundClosed = true;
     }
-  }
 
-  @Override
-  public final void halfClose() {
-    if (outboundPhase(Phase.STATUS) != Phase.STATUS) {
-      closeFramer();
+    protected final boolean isOutboundClosed() {
+      return outboundClosed;
     }
-  }
 
-  /**
-   * Cancel the stream. Called by the application layer, never called by the transport.
-   */
-  @Override
-  public final void cancel(Status reason) {
-    checkArgument(!reason.isOk(), "Should not cancel with OK status");
-    cancelled = true;
-    sendCancel(reason);
-    dispose();
-  }
+    /**
+     * Called by transport implementations when they receive headers.
+     *
+     * @param headers the parsed headers
+     */
+    protected void inboundHeadersReceived(Metadata headers) {
+      checkState(!statusReported, "Received headers on closed stream");
+      statsTraceCtx.clientInboundHeaders(headers);
+
+      boolean compressedStream = false;
+      String streamEncoding = headers.get(CONTENT_ENCODING_KEY);
+      if (fullStreamDecompression && streamEncoding != null) {
+        if (streamEncoding.equalsIgnoreCase("gzip")) {
+          setFullStreamDecompressor(new GzipInflatingBuffer());
+          compressedStream = true;
+        } else if (!streamEncoding.equalsIgnoreCase("identity")) {
+          deframeFailed(
+              Status.INTERNAL
+                  .withDescription(
+                      String.format("Can't find full stream decompressor for %s", streamEncoding))
+                  .asRuntimeException());
+          return;
+        }
+      }
 
-  @Override
-  public final boolean isReady() {
-    return !cancelled && super.isReady();
-  }
+      String messageEncoding = headers.get(MESSAGE_ENCODING_KEY);
+      if (messageEncoding != null) {
+        Decompressor decompressor = decompressorRegistry.lookupDecompressor(messageEncoding);
+        if (decompressor == null) {
+          deframeFailed(
+              Status.INTERNAL
+                  .withDescription(String.format("Can't find decompressor for %s", messageEncoding))
+                  .asRuntimeException());
+          return;
+        } else if (decompressor != Codec.Identity.NONE) {
+          if (compressedStream) {
+            deframeFailed(
+                Status.INTERNAL
+                    .withDescription("Full stream and gRPC message encoding cannot both be set")
+                    .asRuntimeException());
+            return;
+          }
+          setDecompressor(decompressor);
+        }
+      }
 
-  /**
-   * Cancel the stream and send a stream cancellation message to the remote server, if necessary.
-   * Can be called by either the application or transport layers. This method is safe to be called
-   * at any time and multiple times.
-   */
-  protected abstract void sendCancel(Status reason);
+      listener().headersRead(headers);
+    }
 
-  @Override
-  protected MoreObjects.ToStringHelper toStringHelper() {
-    MoreObjects.ToStringHelper toStringHelper = super.toStringHelper();
-    if (status != null) {
-      toStringHelper.add("status", status);
+    /**
+     * Processes the contents of a received data frame from the server.
+     *
+     * @param frame the received data frame. Its ownership is transferred to this method.
+     */
+    protected void inboundDataReceived(ReadableBuffer frame) {
+      checkNotNull(frame, "frame");
+      boolean needToCloseFrame = true;
+      try {
+        if (statusReported) {
+          log.log(Level.INFO, "Received data on closed stream");
+          return;
+        }
+
+        needToCloseFrame = false;
+        deframe(frame);
+      } finally {
+        if (needToCloseFrame) {
+          frame.close();
+        }
+      }
+    }
+
+    /**
+     * Processes the trailers and status from the server.
+     *
+     * @param trailers the received trailers
+     * @param status the status extracted from the trailers
+     */
+    protected void inboundTrailersReceived(Metadata trailers, Status status) {
+      checkNotNull(status, "status");
+      checkNotNull(trailers, "trailers");
+      if (statusReported) {
+        log.log(Level.INFO, "Received trailers on closed stream:\n {1}\n {2}",
+            new Object[]{status, trailers});
+        return;
+      }
+      statsTraceCtx.clientInboundTrailers(trailers);
+      transportReportStatus(status, false, trailers);
+    }
+
+    /**
+     * Report stream closure with status to the application layer if not already reported. This
+     * method must be called from the transport thread.
+     *
+     * @param status the new status to set
+     * @param stopDelivery if {@code true}, interrupts any further delivery of inbound messages that
+     *        may already be queued up in the deframer. If {@code false}, the listener will be
+     *        notified immediately after all currently completed messages in the deframer have been
+     *        delivered to the application.
+     * @param trailers new instance of {@code Trailers}, either empty or those returned by the
+     *        server
+     */
+    public final void transportReportStatus(final Status status, boolean stopDelivery,
+        final Metadata trailers) {
+      transportReportStatus(status, RpcProgress.PROCESSED, stopDelivery, trailers);
+    }
+
+    /**
+     * Report stream closure with status to the application layer if not already reported. This
+     * method must be called from the transport thread.
+     *
+     * @param status the new status to set
+     * @param rpcProgress RPC progress that the
+     *        {@link ClientStreamListener#closed(Status, RpcProgress, Metadata)}
+     *        will receive
+     * @param stopDelivery if {@code true}, interrupts any further delivery of inbound messages that
+     *        may already be queued up in the deframer and overrides any previously queued status.
+     *        If {@code false}, the listener will be notified immediately after all currently
+     *        completed messages in the deframer have been delivered to the application.
+     * @param trailers new instance of {@code Trailers}, either empty or those returned by the
+     *        server
+     */
+    public final void transportReportStatus(
+        final Status status,
+        final RpcProgress rpcProgress,
+        boolean stopDelivery,
+        final Metadata trailers) {
+      checkNotNull(status, "status");
+      checkNotNull(trailers, "trailers");
+      // If stopDelivery, we continue in case previous invocation is waiting for stall
+      if (statusReported && !stopDelivery) {
+        return;
+      }
+      statusReported = true;
+      statusReportedIsOk = status.isOk();
+      onStreamDeallocated();
+
+      if (deframerClosed) {
+        deframerClosedTask = null;
+        closeListener(status, rpcProgress, trailers);
+      } else {
+        deframerClosedTask =
+            new Runnable() {
+              @Override
+              public void run() {
+                closeListener(status, rpcProgress, trailers);
+              }
+            };
+        closeDeframer(stopDelivery);
+      }
+    }
+
+    /**
+     * Closes the listener if not previously closed.
+     *
+     * @throws IllegalStateException if the call has not yet been started.
+     */
+    private void closeListener(
+        Status status, RpcProgress rpcProgress, Metadata trailers) {
+      if (!listenerClosed) {
+        listenerClosed = true;
+        statsTraceCtx.streamClosed(status);
+        if (getTransportTracer() != null) {
+          getTransportTracer().reportStreamClosed(status.isOk());
+        }
+        listener().closed(status, rpcProgress, trailers);
+      }
     }
-    return toStringHelper;
   }
 
-  @Override
-  public boolean isClosed() {
-    return super.isClosed() || listenerClosed;
+  private class GetFramer implements Framer {
+    private Metadata headers;
+    private boolean closed;
+    private final StatsTraceContext statsTraceCtx;
+    private byte[] payload;
+
+    public GetFramer(Metadata headers, StatsTraceContext statsTraceCtx) {
+      this.headers = checkNotNull(headers, "headers");
+      this.statsTraceCtx = checkNotNull(statsTraceCtx, "statsTraceCtx");
+    }
+
+    @SuppressWarnings("BetaApi") // ByteStreams is not Beta in v27
+    @Override
+    public void writePayload(InputStream message) {
+      checkState(payload == null, "writePayload should not be called multiple times");
+      try {
+        payload = ByteStreams.toByteArray(message);
+      } catch (java.io.IOException ex) {
+        throw new RuntimeException(ex);
+      }
+      statsTraceCtx.outboundMessage(0);
+      statsTraceCtx.outboundMessageSent(0, payload.length, payload.length);
+      statsTraceCtx.outboundUncompressedSize(payload.length);
+      // NB(zhangkun83): this is not accurate, because the underlying transport will probably encode
+      // it using e.g., base64.  However, we are not supposed to know such detail here.
+      //
+      // We don't want to move this line to where the encoding happens either, because we'd better
+      // contain the message stats reporting in Framer as suggested in StatsTraceContext.
+      // Scattering the reporting sites increases the risk of mis-counting or double-counting.
+      //
+      // Because the payload is usually very small, people shouldn't care about the size difference
+      // caused by encoding.
+      statsTraceCtx.outboundWireSize(payload.length);
+    }
+
+    @Override
+    public void flush() {}
+
+    @Override
+    public boolean isClosed() {
+      return closed;
+    }
+
+    /** Closes, with flush. */
+    @Override
+    public void close() {
+      closed = true;
+      checkState(payload != null,
+          "Lack of request message. GET request is only supported for unary requests");
+      abstractClientStreamSink().writeHeaders(headers, payload);
+      payload = null;
+      headers = null;
+    }
+
+    /** Closes, without flush. */
+    @Override
+    public void dispose() {
+      closed = true;
+      payload = null;
+      headers = null;
+    }
+
+    // Compression is not supported for GET encoding.
+    @Override
+    public Framer setMessageCompression(boolean enable) {
+      return this;
+    }
+
+    @Override
+    public Framer setCompressor(Compressor compressor) {
+      return this;
+    }
+
+    // TODO(zsurocking): support this
+    @Override
+    public void setMaxOutboundMessageSize(int maxSize) {}
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/AbstractClientStream2.java b/core/src/main/java/io/grpc/internal/AbstractClientStream2.java
deleted file mode 100644
index b0c408ebd3f..00000000000
--- a/core/src/main/java/io/grpc/internal/AbstractClientStream2.java
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
-import io.grpc.Metadata;
-import io.grpc.Status;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import javax.annotation.Nullable;
-
-/**
- * The abstract base class for {@link ClientStream} implementations. Extending classes only need to
- * implement {@link #transportState()} and {@link #abstractClientStreamSink()}. Must only be called
- * from the sending application thread.
- */
-public abstract class AbstractClientStream2 extends AbstractStream2
-    implements ClientStream, MessageFramer.Sink {
-
-  private static final Logger log = Logger.getLogger(AbstractClientStream2.class.getName());
-
-  /**
-   * A sink for outbound operations, separated from the stream simply to avoid name
-   * collisions/confusion. Only called from application thread.
-   */
-  protected interface Sink {
-    /**
-     * Sends an outbound frame to the remote end point.
-     *
-     * @param frame a buffer containing the chunk of data to be sent, or {@code null} if {@code
-     *     endOfStream} with no data to send
-     * @param endOfStream {@code true} if this is the last frame; {@code flush} is guaranteed to be
-     *     {@code true} if this is {@code true}
-     * @param flush {@code true} if more data may not be arriving soon
-     */
-    void writeFrame(@Nullable WritableBuffer frame, boolean endOfStream, boolean flush);
-
-    /**
-     * Requests up to the given number of messages from the call to be delivered to the client. This
-     * should end up triggering {@link TransportState#requestMessagesFromDeframer(int)} on the
-     * transport thread.
-     */
-    void request(int numMessages);
-
-    /**
-     * Tears down the stream, typically in the event of a timeout. This method may be called
-     * multiple times and from any thread.
-     *
-     * <p>This is a clone of {@link ClientStream#cancel()}; {@link AbstractClientStream2#cancel}
-     * delegates to this method.
-     */
-    void cancel(Status status);
-  }
-
-  private final MessageFramer framer;
-  private boolean outboundClosed;
-  /**
-   * Whether cancel() has been called. This is not strictly necessary, but removes the delay between
-   * cancel() being called and isReady() beginning to return false, since cancel is commonly
-   * processed asynchronously.
-   */
-  private volatile boolean cancelled;
-
-  protected AbstractClientStream2(WritableBufferAllocator bufferAllocator,
-      StatsTraceContext statsTraceCtx) {
-    framer = new MessageFramer(this, bufferAllocator, statsTraceCtx);
-  }
-
-  @Override
-  public void setMaxOutboundMessageSize(int maxSize) {
-    framer.setMaxOutboundMessageSize(maxSize);
-  }
-
-  @Override
-  public void setMaxInboundMessageSize(int maxSize) {
-    transportState().setMaxInboundMessageSize(maxSize);
-  }
-
-  /** {@inheritDoc} */
-  @Override
-  protected abstract TransportState transportState();
-
-  @Override
-  public void start(ClientStreamListener listener) {
-    transportState().setListener(listener);
-  }
-
-  /**
-   * Sink for transport to be called to perform outbound operations. Each stream must have its own
-   * unique sink.
-   */
-  protected abstract Sink abstractClientStreamSink();
-
-  @Override
-  protected final MessageFramer framer() {
-    return framer;
-  }
-
-  @Override
-  public final void request(int numMessages) {
-    abstractClientStreamSink().request(numMessages);
-  }
-
-  @Override
-  public final void deliverFrame(WritableBuffer frame, boolean endOfStream, boolean flush) {
-    Preconditions.checkArgument(frame != null || endOfStream, "null frame before EOS");
-    abstractClientStreamSink().writeFrame(frame, endOfStream, flush);
-  }
-
-  @Override
-  public final void halfClose() {
-    if (!outboundClosed) {
-      outboundClosed = true;
-      endOfMessages();
-    }
-  }
-
-  @Override
-  public final void cancel(Status reason) {
-    Preconditions.checkArgument(!reason.isOk(), "Should not cancel with OK status");
-    cancelled = true;
-    abstractClientStreamSink().cancel(reason);
-  }
-
-  @Override
-  public final boolean isReady() {
-    return super.isReady() && !cancelled;
-  }
-
-  /** This should only called from the transport thread. */
-  protected abstract static class TransportState extends AbstractStream2.TransportState {
-    /** Whether listener.closed() has been called. */
-    private boolean listenerClosed;
-    private ClientStreamListener listener;
-
-    private Runnable deliveryStalledTask;
-
-    private boolean headersReceived;
-    /**
-     * Whether the stream is closed from the transport's perspective. This can differ from {@link
-     * #listenerClosed} because there may still be messages buffered to deliver to the application.
-     */
-    private boolean statusReported;
-
-    protected TransportState(int maxMessageSize, StatsTraceContext statsTraceCtx) {
-      super(maxMessageSize, statsTraceCtx);
-    }
-
-    @VisibleForTesting
-    public final void setListener(ClientStreamListener listener) {
-      Preconditions.checkState(this.listener == null, "Already called setListener");
-      this.listener = Preconditions.checkNotNull(listener, "listener");
-    }
-
-    @Override
-    public final void deliveryStalled() {
-      if (deliveryStalledTask != null) {
-        deliveryStalledTask.run();
-        deliveryStalledTask = null;
-      }
-    }
-
-    @Override
-    public final void endOfStream() {
-      deliveryStalled();
-    }
-
-    @Override
-    protected final ClientStreamListener listener() {
-      return listener;
-    }
-
-    /**
-     * Called by transport implementations when they receive headers.
-     *
-     * @param headers the parsed headers
-     */
-    protected void inboundHeadersReceived(Metadata headers) {
-      Preconditions.checkState(!statusReported, "Received headers on closed stream");
-      headersReceived = true;
-      listener().headersRead(headers);
-    }
-
-    /**
-     * Processes the contents of a received data frame from the server.
-     *
-     * @param frame the received data frame. Its ownership is transferred to this method.
-     */
-    protected void inboundDataReceived(ReadableBuffer frame) {
-      Preconditions.checkNotNull(frame, "frame");
-      boolean needToCloseFrame = true;
-      try {
-        if (statusReported) {
-          log.log(Level.INFO, "Received data on closed stream");
-          return;
-        }
-        if (!headersReceived) {
-          transportReportStatus(
-              Status.INTERNAL.withDescription("headers not received before payload"),
-              false, new Metadata());
-          return;
-        }
-
-        needToCloseFrame = false;
-        deframe(frame, false);
-      } finally {
-        if (needToCloseFrame) {
-          frame.close();
-        }
-      }
-    }
-
-    /**
-     * Processes the trailers and status from the server.
-     *
-     * @param trailers the received trailers
-     * @param status the status extracted from the trailers
-     */
-    protected void inboundTrailersReceived(Metadata trailers, Status status) {
-      Preconditions.checkNotNull(status, "status");
-      Preconditions.checkNotNull(trailers, "trailers");
-      if (statusReported) {
-        log.log(Level.INFO, "Received trailers on closed stream:\n {1}\n {2}",
-            new Object[]{status, trailers});
-        return;
-      }
-      transportReportStatus(status, false, trailers);
-    }
-
-    /**
-     * Report stream closure with status to the application layer if not already reported. This
-     * method must be called from the transport thread.
-     *
-     * @param status the new status to set
-     * @param stopDelivery if {@code true}, interrupts any further delivery of inbound messages that
-     *        may already be queued up in the deframer. If {@code false}, the listener will be
-     *        notified immediately after all currently completed messages in the deframer have been
-     *        delivered to the application.
-     * @param trailers new instance of {@code Trailers}, either empty or those returned by the
-     *        server
-     */
-    public final void transportReportStatus(final Status status, boolean stopDelivery,
-        final Metadata trailers) {
-      Preconditions.checkNotNull(status, "status");
-      Preconditions.checkNotNull(trailers, "trailers");
-      // If stopDelivery, we continue in case previous invocation is waiting for stall
-      if (statusReported && !stopDelivery) {
-        return;
-      }
-      statusReported = true;
-      onStreamDeallocated();
-
-      // If not stopping delivery, then we must wait until the deframer is stalled (i.e., it has no
-      // complete messages to deliver).
-      if (stopDelivery || isDeframerStalled()) {
-        deliveryStalledTask = null;
-        closeListener(status, trailers);
-      } else {
-        deliveryStalledTask = new Runnable() {
-          @Override
-          public void run() {
-            closeListener(status, trailers);
-          }
-        };
-      }
-    }
-
-    /**
-     * Closes the listener if not previously closed.
-     *
-     * @throws IllegalStateException if the call has not yet been started.
-     */
-    private void closeListener(Status status, Metadata trailers) {
-      if (!listenerClosed) {
-        listenerClosed = true;
-        closeDeframer();
-        listener().closed(status, trailers);
-      }
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/AbstractManagedChannelImplBuilder.java b/core/src/main/java/io/grpc/internal/AbstractManagedChannelImplBuilder.java
deleted file mode 100644
index 5fa64493b59..00000000000
--- a/core/src/main/java/io/grpc/internal/AbstractManagedChannelImplBuilder.java
+++ /dev/null
@@ -1,441 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static com.google.common.base.MoreObjects.firstNonNull;
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.google.instrumentation.stats.Stats;
-import com.google.instrumentation.stats.StatsContextFactory;
-import io.grpc.Attributes;
-import io.grpc.ClientInterceptor;
-import io.grpc.CompressorRegistry;
-import io.grpc.DecompressorRegistry;
-import io.grpc.LoadBalancer;
-import io.grpc.LoadBalancer2;
-import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
-import io.grpc.NameResolver;
-import io.grpc.NameResolverProvider;
-import io.grpc.PickFirstBalancerFactory2;
-import io.grpc.ResolvedServerInfo;
-import io.grpc.ResolvedServerInfoGroup;
-import java.net.SocketAddress;
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.Executor;
-import java.util.concurrent.TimeUnit;
-import javax.annotation.Nullable;
-
-/**
- * The base class for channel builders.
- *
- * @param <T> The concrete type of this builder.
- */
-public abstract class AbstractManagedChannelImplBuilder
-        <T extends AbstractManagedChannelImplBuilder<T>> extends ManagedChannelBuilder<T> {
-  private static final String DIRECT_ADDRESS_SCHEME = "directaddress";
-
-  /**
-   * An idle timeout larger than this would disable idle mode.
-   */
-  @VisibleForTesting
-  static final long IDLE_MODE_MAX_TIMEOUT_DAYS = 30;
-
-  /**
-   * The default idle timeout.
-   */
-  @VisibleForTesting
-  static final long IDLE_MODE_DEFAULT_TIMEOUT_MILLIS = TimeUnit.MINUTES.toMillis(30);
-
-  /**
-   * An idle timeout smaller than this would be capped to it.
-   */
-  @VisibleForTesting
-  static final long IDLE_MODE_MIN_TIMEOUT_MILLIS = TimeUnit.SECONDS.toMillis(1);
-
-  @Nullable
-  private Executor executor;
-
-  private final List<ClientInterceptor> interceptors = new ArrayList<ClientInterceptor>();
-
-  private final String target;
-
-  @Nullable
-  private final SocketAddress directServerAddress;
-
-  @Nullable
-  private String userAgent;
-
-  @Nullable
-  private String authorityOverride;
-
-  @Nullable
-  private NameResolver.Factory nameResolverFactory;
-
-  private LoadBalancer2.Factory loadBalancerFactory;
-
-  @Nullable
-  private ChannelFactory channelFactory;
-
-  @Nullable
-  private DecompressorRegistry decompressorRegistry;
-
-  @Nullable
-  private CompressorRegistry compressorRegistry;
-
-  private long idleTimeoutMillis = IDLE_MODE_DEFAULT_TIMEOUT_MILLIS;
-
-  private int maxInboundMessageSize = GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
-
-  // Can be overriden by subclasses.
-  @Override
-  public T maxInboundMessageSize(int max) {
-    checkArgument(max >= 0, "negative max");
-    maxInboundMessageSize = max;
-    return thisT();
-  }
-
-  protected final int maxInboundMessageSize() {
-    return maxInboundMessageSize;
-  }
-
-  @Nullable
-  private StatsContextFactory statsFactory;
-
-  protected AbstractManagedChannelImplBuilder(String target) {
-    this.target = Preconditions.checkNotNull(target, "target");
-    this.directServerAddress = null;
-  }
-
-  /**
-   * Returns a target string for the SocketAddress. It is only used as a placeholder, because
-   * DirectAddressNameResolverFactory will not actually try to use it. However, it must be a valid
-   * URI.
-   */
-  @VisibleForTesting
-  static String makeTargetStringForDirectAddress(SocketAddress address) {
-    try {
-      return new URI(DIRECT_ADDRESS_SCHEME, "", "/" + address, null).toString();
-    } catch (URISyntaxException e) {
-      // It should not happen.
-      throw new RuntimeException(e);
-    }
-  }
-
-  protected AbstractManagedChannelImplBuilder(SocketAddress directServerAddress, String authority) {
-    this.target = makeTargetStringForDirectAddress(directServerAddress);
-    this.directServerAddress = directServerAddress;
-    this.nameResolverFactory = new DirectAddressNameResolverFactory(directServerAddress, authority);
-  }
-
-  @Override
-  public final T directExecutor() {
-    return executor(MoreExecutors.directExecutor());
-  }
-
-  @Override
-  public final T executor(Executor executor) {
-    this.executor = executor;
-    return thisT();
-  }
-
-  @Override
-  public final T intercept(List<ClientInterceptor> interceptors) {
-    this.interceptors.addAll(interceptors);
-    return thisT();
-  }
-
-  @Override
-  public final T intercept(ClientInterceptor... interceptors) {
-    return intercept(Arrays.asList(interceptors));
-  }
-
-  @Override
-  public final T nameResolverFactory(NameResolver.Factory resolverFactory) {
-    Preconditions.checkState(directServerAddress == null,
-        "directServerAddress is set (%s), which forbids the use of NameResolverFactory",
-        directServerAddress);
-    this.nameResolverFactory = resolverFactory;
-    return thisT();
-  }
-
-  @Override
-  public final T loadBalancerFactory(LoadBalancer2.Factory loadBalancerFactory) {
-    Preconditions.checkState(directServerAddress == null,
-        "directServerAddress is set (%s), which forbids the use of LoadBalancerFactory",
-        directServerAddress);
-    this.loadBalancerFactory = loadBalancerFactory;
-    this.channelFactory = null;
-    return thisT();
-  }
-
-  @Override
-  public final T loadBalancerFactory(final LoadBalancer.Factory loadBalancerFactory) {
-    Preconditions.checkState(directServerAddress == null,
-        "directServerAddress is set (%s), which forbids the use of LoadBalancerFactory",
-        directServerAddress);
-    this.channelFactory = new ChannelFactory() {
-        @Override
-        public ManagedChannel create(ClientTransportFactory transportFactory) {
-          return new ManagedChannelImpl(
-              target,
-              // TODO(carl-mastrangelo): Allow clients to pass this in
-              new ExponentialBackoffPolicy.Provider(),
-              nameResolverFactory,
-              getNameResolverParams(),
-              loadBalancerFactory,
-              transportFactory,
-              firstNonNull(decompressorRegistry, DecompressorRegistry.getDefaultInstance()),
-              firstNonNull(compressorRegistry, CompressorRegistry.getDefaultInstance()),
-              GrpcUtil.TIMER_SERVICE, GrpcUtil.STOPWATCH_SUPPLIER, idleTimeoutMillis,
-              executor, userAgent, interceptors,
-              firstNonNull(statsFactory,
-                  firstNonNull(Stats.getStatsContextFactory(), NoopStatsContextFactory.INSTANCE)));
-        }
-      };
-    return thisT();
-  }
-
-  @Override
-  public final T decompressorRegistry(DecompressorRegistry registry) {
-    this.decompressorRegistry = registry;
-    return thisT();
-  }
-
-  @Override
-  public final T compressorRegistry(CompressorRegistry registry) {
-    this.compressorRegistry = registry;
-    return thisT();
-  }
-
-  @Override
-  public final T userAgent(@Nullable String userAgent) {
-    this.userAgent = userAgent;
-    return thisT();
-  }
-
-  @Override
-  public final T overrideAuthority(String authority) {
-    this.authorityOverride = checkAuthority(authority);
-    return thisT();
-  }
-
-  @Override
-  public final T idleTimeout(long value, TimeUnit unit) {
-    checkArgument(value > 0, "idle timeout is %s, but must be positive", value);
-    // We convert to the largest unit to avoid overflow
-    if (unit.toDays(value) >= IDLE_MODE_MAX_TIMEOUT_DAYS) {
-      // This disables idle mode
-      this.idleTimeoutMillis = ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE;
-    } else {
-      this.idleTimeoutMillis = Math.max(unit.toMillis(value), IDLE_MODE_MIN_TIMEOUT_MILLIS);
-    }
-    return thisT();
-  }
-
-  /**
-   * Override the default stats implementation.
-   */
-  @VisibleForTesting
-  protected T statsContextFactory(StatsContextFactory statsFactory) {
-    this.statsFactory = statsFactory;
-    return thisT();
-  }
-
-  @VisibleForTesting
-  final long getIdleTimeoutMillis() {
-    return idleTimeoutMillis;
-  }
-
-  /**
-   * Verifies the authority is valid.  This method exists as an escape hatch for putting in an
-   * authority that is valid, but would fail the default validation provided by this
-   * implementation.
-   */
-  protected String checkAuthority(String authority) {
-    return GrpcUtil.checkAuthority(authority);
-  }
-
-  @Override
-  public ManagedChannel build() {
-    ClientTransportFactory transportFactory = buildTransportFactory();
-    if (authorityOverride != null) {
-      transportFactory = new AuthorityOverridingTransportFactory(
-        transportFactory, authorityOverride);
-    }
-    NameResolver.Factory nameResolverFactory = this.nameResolverFactory;
-    if (nameResolverFactory == null) {
-      // Avoid loading the provider unless necessary, as a way to workaround a possibly-costly
-      // and poorly optimized getResource() call on Android. If any other piece of code calls
-      // getResource(), then this shouldn't be a problem unless called on the UI thread.
-      nameResolverFactory = NameResolverProvider.asFactory();
-    }
-    if (channelFactory != null) {
-      return channelFactory.create(transportFactory);
-    } else {
-      return new ManagedChannelImpl2(
-          target,
-          // TODO(carl-mastrangelo): Allow clients to pass this in
-          new ExponentialBackoffPolicy.Provider(),
-          nameResolverFactory,
-          getNameResolverParams(),
-          firstNonNull(loadBalancerFactory, PickFirstBalancerFactory2.getInstance()),
-          transportFactory,
-          firstNonNull(decompressorRegistry, DecompressorRegistry.getDefaultInstance()),
-          firstNonNull(compressorRegistry, CompressorRegistry.getDefaultInstance()),
-          SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE),
-          getExecutorPool(executor),
-          SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR),
-          GrpcUtil.STOPWATCH_SUPPLIER, idleTimeoutMillis,
-          userAgent, interceptors, firstNonNull(statsFactory,
-              firstNonNull(Stats.getStatsContextFactory(), NoopStatsContextFactory.INSTANCE)));
-    }
-  }
-
-  /**
-   * Subclasses should override this method to provide the {@link ClientTransportFactory}
-   * appropriate for this channel. This method is meant for Transport implementors and should not
-   * be used by normal users.
-   */
-  protected abstract ClientTransportFactory buildTransportFactory();
-
-  /**
-   * Subclasses can override this method to provide additional parameters to {@link
-   * NameResolver.Factory#newNameResolver}. The default implementation returns {@link
-   * Attributes#EMPTY}.
-   */
-  protected Attributes getNameResolverParams() {
-    return Attributes.EMPTY;
-  }
-
-  private static ObjectPool<? extends Executor> getExecutorPool(final @Nullable Executor executor) {
-    if (executor != null) {
-      return new ObjectPool<Executor>() {
-        @Override
-        public Executor getObject() {
-          return executor;
-        }
-
-        @Override
-        public Executor returnObject(Object returned) {
-          return null;
-        }
-      };
-    } else {
-      return SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR);
-    }
-  }
-
-  private static class AuthorityOverridingTransportFactory implements ClientTransportFactory {
-    final ClientTransportFactory factory;
-    final String authorityOverride;
-
-    AuthorityOverridingTransportFactory(
-        ClientTransportFactory factory, String authorityOverride) {
-      this.factory = Preconditions.checkNotNull(factory, "factory should not be null");
-      this.authorityOverride = Preconditions.checkNotNull(
-        authorityOverride, "authorityOverride should not be null");
-    }
-
-    @Override
-    public ConnectionClientTransport newClientTransport(SocketAddress serverAddress,
-        String authority, @Nullable String userAgent) {
-      return factory.newClientTransport(serverAddress, authorityOverride, userAgent);
-    }
-
-    @Override
-    public void close() {
-      factory.close();
-    }
-  }
-
-  private static class DirectAddressNameResolverFactory extends NameResolver.Factory {
-    final SocketAddress address;
-    final String authority;
-
-    DirectAddressNameResolverFactory(SocketAddress address, String authority) {
-      this.address = address;
-      this.authority = authority;
-    }
-
-    @Override
-    public NameResolver newNameResolver(URI notUsedUri, Attributes params) {
-      return new NameResolver() {
-        @Override
-        public String getServiceAuthority() {
-          return authority;
-        }
-
-        @Override
-        public void start(final Listener listener) {
-          listener.onUpdate(Collections.singletonList(
-              ResolvedServerInfoGroup.builder().add(new ResolvedServerInfo(address)).build()),
-              Attributes.EMPTY);
-        }
-
-        @Override
-        public void shutdown() {}
-      };
-    }
-
-    @Override
-    public String getDefaultScheme() {
-      return DIRECT_ADDRESS_SCHEME;
-    }
-  }
-
-  /**
-   * Returns the correctly typed version of the builder.
-   */
-  private T thisT() {
-    @SuppressWarnings("unchecked")
-    T thisT = (T) this;
-    return thisT;
-  }
-
-  /**
-   * A temporary solution to contain the reference to ManagedChannelImpl in the v1 LoadBalancer
-   * setter, so that on Android ManagedChannelImpl can be stripped out by ProGuard since the v1
-   * setter will not be called.  This should be deleted along with v1 ManagedChannelImpl.
-   */
-  private interface ChannelFactory {
-    ManagedChannel create(ClientTransportFactory transportFactory);
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/AbstractReadableBuffer.java b/core/src/main/java/io/grpc/internal/AbstractReadableBuffer.java
index 308a51fee1e..16c046dfc36 100644
--- a/core/src/main/java/io/grpc/internal/AbstractReadableBuffer.java
+++ b/core/src/main/java/io/grpc/internal/AbstractReadableBuffer.java
@@ -1,59 +1,27 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import java.nio.ByteBuffer;
+
 /**
  * Abstract base class for {@link ReadableBuffer} implementations.
  */
 public abstract class AbstractReadableBuffer implements ReadableBuffer {
-
-  @Override
-  public final int readUnsignedMedium() {
-    checkReadable(3);
-    int b1 = readUnsignedByte();
-    int b2 = readUnsignedByte();
-    int b3 = readUnsignedByte();
-    return b1 << 16 | b2 << 8 | b3;
-  }
-
-
-  @Override
-  public final int readUnsignedShort() {
-    checkReadable(2);
-    int b1 = readUnsignedByte();
-    int b2 = readUnsignedByte();
-    return b1 << 8 | b2;
-  }
-
   @Override
   public final int readInt() {
     checkReadable(4);
@@ -79,6 +47,29 @@ public int arrayOffset() {
     throw new UnsupportedOperationException();
   }
 
+  @Override
+  public boolean markSupported() {
+    return false;
+  }
+
+  @Override
+  public void mark() {}
+
+  @Override
+  public void reset() {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public boolean byteBufferSupported() {
+    return false;
+  }
+
+  @Override
+  public ByteBuffer getByteBuffer() {
+    throw new UnsupportedOperationException();
+  }
+
   @Override
   public void close() {}
 
diff --git a/core/src/main/java/io/grpc/internal/AbstractServerImplBuilder.java b/core/src/main/java/io/grpc/internal/AbstractServerImplBuilder.java
deleted file mode 100644
index 751a3878c25..00000000000
--- a/core/src/main/java/io/grpc/internal/AbstractServerImplBuilder.java
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static com.google.common.base.MoreObjects.firstNonNull;
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.google.instrumentation.stats.Stats;
-import com.google.instrumentation.stats.StatsContextFactory;
-import io.grpc.BindableService;
-import io.grpc.CompressorRegistry;
-import io.grpc.Context;
-import io.grpc.DecompressorRegistry;
-import io.grpc.HandlerRegistry;
-import io.grpc.Internal;
-import io.grpc.InternalNotifyOnServerBuild;
-import io.grpc.ServerBuilder;
-import io.grpc.ServerMethodDefinition;
-import io.grpc.ServerServiceDefinition;
-import io.grpc.ServerTransportFilter;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.Executor;
-import javax.annotation.Nullable;
-
-/**
- * The base class for server builders.
- *
- * @param <T> The concrete type for this builder.
- */
-public abstract class AbstractServerImplBuilder<T extends AbstractServerImplBuilder<T>>
-        extends ServerBuilder<T> {
-
-  private static final HandlerRegistry EMPTY_FALLBACK_REGISTRY = new HandlerRegistry() {
-      @Override
-      public List<ServerServiceDefinition> getServices() {
-        return Collections.emptyList();
-      }
-
-      @Override
-      public ServerMethodDefinition<?, ?> lookupMethod(String methodName,
-          @Nullable String authority) {
-        return null;
-      }
-    };
-
-  private final InternalHandlerRegistry.Builder registryBuilder =
-      new InternalHandlerRegistry.Builder();
-
-  private final ArrayList<ServerTransportFilter> transportFilters =
-      new ArrayList<ServerTransportFilter>();
-
-  private final List<InternalNotifyOnServerBuild> notifyOnBuildList =
-      new ArrayList<InternalNotifyOnServerBuild>();
-
-  @Nullable
-  private HandlerRegistry fallbackRegistry;
-
-  @Nullable
-  private Executor executor;
-
-  @Nullable
-  private DecompressorRegistry decompressorRegistry;
-
-  @Nullable
-  private CompressorRegistry compressorRegistry;
-
-  @Nullable
-  private StatsContextFactory statsFactory;
-
-  @Override
-  public final T directExecutor() {
-    return executor(MoreExecutors.directExecutor());
-  }
-
-  @Override
-  public final T executor(@Nullable Executor executor) {
-    this.executor = executor;
-    return thisT();
-  }
-
-  @Override
-  public final T addService(ServerServiceDefinition service) {
-    registryBuilder.addService(service);
-    return thisT();
-  }
-
-  @Override
-  public final T addService(BindableService bindableService) {
-    if (bindableService instanceof InternalNotifyOnServerBuild) {
-      notifyOnBuildList.add((InternalNotifyOnServerBuild) bindableService);
-    }
-    return addService(bindableService.bindService());
-  }
-
-  @Override
-  public final T addTransportFilter(ServerTransportFilter filter) {
-    transportFilters.add(checkNotNull(filter, "filter"));
-    return thisT();
-  }
-
-  @Override
-  public final T fallbackHandlerRegistry(HandlerRegistry registry) {
-    this.fallbackRegistry = registry;
-    return thisT();
-  }
-
-  @Override
-  public final T decompressorRegistry(DecompressorRegistry registry) {
-    decompressorRegistry = registry;
-    return thisT();
-  }
-
-  @Override
-  public final T compressorRegistry(CompressorRegistry registry) {
-    compressorRegistry = registry;
-    return thisT();
-  }
-
-  /**
-   * Override the default stats implementation.
-   */
-  @VisibleForTesting
-  protected T statsContextFactory(StatsContextFactory statsFactory) {
-    this.statsFactory = statsFactory;
-    return thisT();
-  }
-
-  @Override
-  public ServerImpl build() {
-    io.grpc.internal.InternalServer transportServer = buildTransportServer();
-    ServerImpl server = new ServerImpl(getExecutorPool(),
-        SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE), registryBuilder.build(),
-        firstNonNull(fallbackRegistry, EMPTY_FALLBACK_REGISTRY), transportServer,
-        Context.ROOT, firstNonNull(decompressorRegistry, DecompressorRegistry.getDefaultInstance()),
-        firstNonNull(compressorRegistry, CompressorRegistry.getDefaultInstance()),
-        transportFilters,
-        firstNonNull(statsFactory,
-            firstNonNull(Stats.getStatsContextFactory(), NoopStatsContextFactory.INSTANCE)),
-        GrpcUtil.STOPWATCH_SUPPLIER);
-    for (InternalNotifyOnServerBuild notifyTarget : notifyOnBuildList) {
-      notifyTarget.notifyOnBuild(server);
-    }
-    return server;
-  }
-
-  private ObjectPool<? extends Executor> getExecutorPool() {
-    final Executor savedExecutor = executor;
-    if (savedExecutor == null) {
-      return SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR);
-    }
-    return new ObjectPool<Executor>() {
-      @Override
-      public Executor getObject() {
-        return savedExecutor;
-      }
-
-      @Override
-      public Executor returnObject(Object object) {
-        return null;
-      }
-    };
-  }
-
-  /**
-   * Children of AbstractServerBuilder should override this method to provide transport specific
-   * information for the server.  This method is mean for Transport implementors and should not be
-   * used by normal users.
-   */
-  @Internal
-  protected abstract io.grpc.internal.InternalServer buildTransportServer();
-
-  private T thisT() {
-    @SuppressWarnings("unchecked")
-    T thisT = (T) this;
-    return thisT;
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/AbstractServerStream.java b/core/src/main/java/io/grpc/internal/AbstractServerStream.java
index 99cd1ce3462..c468cba978a 100644
--- a/core/src/main/java/io/grpc/internal/AbstractServerStream.java
+++ b/core/src/main/java/io/grpc/internal/AbstractServerStream.java
@@ -1,38 +1,25 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import com.google.common.base.Preconditions;
 import io.grpc.Attributes;
+import io.grpc.Decompressor;
+import io.grpc.InternalStatus;
 import io.grpc.Metadata;
 import io.grpc.Status;
 import javax.annotation.Nullable;
@@ -42,7 +29,7 @@
  * implement {@link #transportState()} and {@link #abstractServerStreamSink()}. Must only be called
  * from the sending application thread.
  */
-public abstract class AbstractServerStream extends AbstractStream2
+public abstract class AbstractServerStream extends AbstractStream
     implements ServerStream, MessageFramer.Sink {
   /**
    * A sink for outbound operations, separated from the stream simply to avoid name
@@ -54,29 +41,25 @@ protected interface Sink {
      *
      * @param headers the headers to be sent to client.
      */
-    void writeHeaders(Metadata headers);
+    void writeHeaders(Metadata headers, boolean flush);
 
     /**
      * Sends an outbound frame to the remote end point.
      *
      * @param frame a buffer containing the chunk of data to be sent.
      * @param flush {@code true} if more data may not be arriving soon
+     * @param numMessages the number of messages this frame represents
      */
-    void writeFrame(@Nullable WritableBuffer frame, boolean flush);
+    void writeFrame(WritableBuffer frame, boolean flush, int numMessages);
 
     /**
      * Sends trailers to the remote end point. This call implies end of stream.
      *
      * @param trailers metadata to be sent to the end point
      * @param headersSent {@code true} if response headers have already been sent.
+     * @param status the status that the call ended with
      */
-    void writeTrailers(Metadata trailers, boolean headersSent);
-
-    /**
-     * Requests up to the given number of messages from the call to be delivered. This should end up
-     * triggering {@link TransportState#requestMessagesFromDeframer(int)} on the transport thread.
-     */
-    void request(int numMessages);
+    void writeTrailers(Metadata trailers, boolean headersSent, Status status);
 
     /**
      * Tears down the stream, typically in the event of a timeout. This method may be called
@@ -92,10 +75,11 @@ protected interface Sink {
   private boolean outboundClosed;
   private boolean headersSent;
 
-  protected AbstractServerStream(WritableBufferAllocator bufferAllocator,
-      StatsTraceContext statsTraceCtx) {
+  @SuppressWarnings("this-escape")
+  protected AbstractServerStream(
+      WritableBufferAllocator bufferAllocator, StatsTraceContext statsTraceCtx) {
     this.statsTraceCtx = Preconditions.checkNotNull(statsTraceCtx, "statsTraceCtx");
-    framer = new MessageFramer(this, bufferAllocator, statsTraceCtx);
+    this.framer = new MessageFramer(this, bufferAllocator, statsTraceCtx);
   }
 
   @Override
@@ -113,23 +97,26 @@ protected final MessageFramer framer() {
   }
 
   @Override
-  public final void request(int numMessages) {
-    abstractServerStreamSink().request(numMessages);
-  }
-
-  @Override
-  public final void writeHeaders(Metadata headers) {
+  public final void writeHeaders(Metadata headers, boolean flush) {
     Preconditions.checkNotNull(headers, "headers");
 
     headersSent = true;
-    abstractServerStreamSink().writeHeaders(headers);
+    abstractServerStreamSink().writeHeaders(headers, flush);
   }
 
   @Override
-  public final void deliverFrame(WritableBuffer frame, boolean endOfStream, boolean flush) {
+  public final void deliverFrame(
+      WritableBuffer frame, boolean endOfStream, boolean flush, int numMessages) {
     // Since endOfStream is triggered by the sending of trailers, avoid flush here and just flush
     // after the trailers.
-    abstractServerStreamSink().writeFrame(frame, endOfStream ? false : flush);
+    if (frame == null) {
+      assert endOfStream;
+      return;
+    }
+    if (endOfStream) {
+      flush = false;
+    }
+    abstractServerStreamSink().writeFrame(frame, flush, numMessages);
   }
 
   @Override
@@ -140,16 +127,20 @@ public final void close(Status status, Metadata trailers) {
       outboundClosed = true;
       endOfMessages();
       addStatusToTrailers(trailers, status);
-      abstractServerStreamSink().writeTrailers(trailers, headersSent);
+      // Safe to set without synchronization because access is tightly controlled.
+      // closedStatus is only set from here, and is read from a place that has happen-after
+      // guarantees with respect to here.
+      transportState().setClosedStatus(status);
+      abstractServerStreamSink().writeTrailers(trailers, headersSent, status);
     }
   }
 
   private void addStatusToTrailers(Metadata trailers, Status status) {
-    trailers.discardAll(Status.CODE_KEY);
-    trailers.discardAll(Status.MESSAGE_KEY);
-    trailers.put(Status.CODE_KEY, status);
+    trailers.discardAll(InternalStatus.CODE_KEY);
+    trailers.discardAll(InternalStatus.MESSAGE_KEY);
+    trailers.put(InternalStatus.CODE_KEY, status);
     if (status.getDescription() != null) {
-      trailers.put(Status.MESSAGE_KEY, status.getDescription());
+      trailers.put(InternalStatus.MESSAGE_KEY, status.getDescription());
     }
   }
 
@@ -163,6 +154,11 @@ public final boolean isReady() {
     return super.isReady();
   }
 
+  @Override
+  public final void setDecompressor(Decompressor decompressor) {
+    transportState().setDecompressor(Preconditions.checkNotNull(decompressor, "decompressor"));
+  }
+
   @Override public Attributes getAttributes() {
     return Attributes.EMPTY;
   }
@@ -182,14 +178,46 @@ public StatsTraceContext statsTraceContext() {
     return statsTraceCtx;
   }
 
-  /** This should only called from the transport thread. */
-  protected abstract static class TransportState extends AbstractStream2.TransportState {
+  /**
+   * A hint to the stream that specifies how many bytes must be queued before
+   * {@link #isReady()} will return false. A stream may ignore this property
+   * if unsupported. This may only be set before any messages are sent.
+   *
+   * @param numBytes The number of bytes that must be queued. Must be a
+   *                 positive integer.
+   */
+  @Override
+  public void setOnReadyThreshold(int numBytes) {
+    super.setOnReadyThreshold(numBytes);
+  }
+
+  /**
+   * This should only be called from the transport thread (except for private interactions with
+   * {@code AbstractServerStream}).
+   */
+  protected abstract static class TransportState extends AbstractStream.TransportState {
     /** Whether listener.closed() has been called. */
     private boolean listenerClosed;
     private ServerStreamListener listener;
-
-    protected TransportState(int maxMessageSize, StatsTraceContext statsTraceCtx) {
-      super(maxMessageSize, statsTraceCtx);
+    private final StatsTraceContext statsTraceCtx;
+
+    private boolean endOfStream = false;
+    private boolean deframerClosed = false;
+    private boolean immediateCloseRequested = false;
+    private Runnable deframerClosedTask;
+    /** The status that the application used to close this stream. */
+    @Nullable
+    private Status closedStatus;
+
+    protected TransportState(
+        int maxMessageSize,
+        StatsTraceContext statsTraceCtx,
+        TransportTracer transportTracer) {
+      super(
+          maxMessageSize,
+          statsTraceCtx,
+          Preconditions.checkNotNull(transportTracer, "transportTracer"));
+      this.statsTraceCtx = Preconditions.checkNotNull(statsTraceCtx, "statsTraceCtx");
     }
 
     /**
@@ -204,17 +232,33 @@ public final void setListener(ServerStreamListener listener) {
     @Override
     public final void onStreamAllocated() {
       super.onStreamAllocated();
+      getTransportTracer().reportRemoteStreamStarted();
     }
 
     @Override
-    public void deliveryStalled() {}
-
-    @Override
-    public void endOfStream() {
-      closeDeframer();
-      listener().halfClosed();
+    public void deframerClosed(boolean hasPartialMessage) {
+      deframerClosed = true;
+      if (endOfStream && !immediateCloseRequested) {
+        if (hasPartialMessage) {
+          // We've received the entire stream and have data available but we don't have
+          // enough to read the next frame ... this is bad.
+          deframeFailed(
+              Status.INTERNAL
+                  .withDescription("Encountered end-of-stream mid-frame")
+                  .asRuntimeException());
+          deframerClosedTask = null;
+          return;
+        }
+        listener.halfClosed();
+      }
+      if (deframerClosedTask != null) {
+        deframerClosedTask.run();
+        deframerClosedTask = null;
+      }
     }
 
+
+
     @Override
     protected ServerStreamListener listener() {
       return listener;
@@ -229,8 +273,13 @@ protected ServerStreamListener listener() {
      * @param endOfStream {@code true} if no more data will be received on the stream.
      */
     public void inboundDataReceived(ReadableBuffer frame, boolean endOfStream) {
+      Preconditions.checkState(!this.endOfStream, "Past end of stream");
       // Deframe the message. If a failure occurs, deframeFailed will be called.
-      deframe(frame, endOfStream);
+      deframe(frame);
+      if (endOfStream) {
+        this.endOfStream = true;
+        closeDeframer(false);
+      }
     }
 
     /**
@@ -243,9 +292,23 @@ public void inboundDataReceived(ReadableBuffer frame, boolean endOfStream) {
      *
      * @param status the error status. Must not be {@link Status#OK}.
      */
-    public final void transportReportStatus(Status status) {
+    public final void transportReportStatus(final Status status) {
       Preconditions.checkArgument(!status.isOk(), "status must not be OK");
-      closeListener(status);
+      onStreamDeallocated();
+      if (deframerClosed) {
+        deframerClosedTask = null;
+        closeListener(status);
+      } else {
+        deframerClosedTask =
+            new Runnable() {
+              @Override
+              public void run() {
+                closeListener(status);
+              }
+            };
+        immediateCloseRequested = true;
+        closeDeframer(true);
+      }
     }
 
     /**
@@ -254,19 +317,52 @@ public final void transportReportStatus(Status status) {
      * #transportReportStatus}.
      */
     public void complete() {
-      closeListener(Status.OK);
+      onStreamDeallocated();
+      if (deframerClosed) {
+        deframerClosedTask = null;
+        closeListener(Status.OK);
+      } else {
+        deframerClosedTask =
+            new Runnable() {
+              @Override
+              public void run() {
+                closeListener(Status.OK);
+              }
+            };
+        immediateCloseRequested = true;
+        closeDeframer(true);
+      }
     }
 
     /**
-     * Closes the listener if not previously closed and frees resources.
+     * Closes the listener if not previously closed and frees resources. {@code newStatus} is a
+     * status generated by gRPC. It is <b>not</b> the status the stream closed with.
      */
     private void closeListener(Status newStatus) {
+      // If newStatus is OK, the application must have already called AbstractServerStream.close()
+      // and the status passed in there was the actual status of the RPC.
+      // If newStatus non-OK, then the RPC ended some other way and the server application did
+      // not initiate the termination.
+      Preconditions.checkState(!newStatus.isOk() || closedStatus != null);
       if (!listenerClosed) {
+        if (!newStatus.isOk()) {
+          statsTraceCtx.streamClosed(newStatus);
+          getTransportTracer().reportStreamClosed(false);
+        } else {
+          statsTraceCtx.streamClosed(closedStatus);
+          getTransportTracer().reportStreamClosed(closedStatus.isOk());
+        }
         listenerClosed = true;
-        onStreamDeallocated();
-        closeDeframer();
         listener().closed(newStatus);
       }
     }
+
+    /**
+     * Stores the {@code Status} that the application used to close this stream.
+     */
+    private void setClosedStatus(Status closeStatus) {
+      Preconditions.checkState(closedStatus == null, "closedStatus can only be set once");
+      closedStatus = closeStatus;
+    }
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/AbstractStream.java b/core/src/main/java/io/grpc/internal/AbstractStream.java
index 4a5f7338467..9f5fb035dab 100644
--- a/core/src/main/java/io/grpc/internal/AbstractStream.java
+++ b/core/src/main/java/io/grpc/internal/AbstractStream.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -35,299 +20,96 @@
 import static com.google.common.base.Preconditions.checkState;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
 import io.grpc.Codec;
 import io.grpc.Compressor;
 import io.grpc.Decompressor;
+import io.perfmark.Link;
+import io.perfmark.PerfMark;
+import io.perfmark.TaskCloseable;
 import java.io.InputStream;
-import javax.annotation.concurrent.GuardedBy;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 /**
- * Abstract base class for {@link Stream} implementations.
- *
- * @param <IdT> type of the unique identifier of this stream.
+ * The stream and stream state as used by the application. Must only be called from the sending
+ * application thread.
  */
 public abstract class AbstractStream implements Stream {
-  /**
-   * The default number of queued bytes for a given stream, below which
-   * {@link StreamListener#onReady()} will be called.
-   */
-  public static final int DEFAULT_ONREADY_THRESHOLD = 32 * 1024;
-
-  public static final int ABSENT_ID = -1;
-
-  /**
-   * Indicates the phase of the GRPC stream in one direction.
-   */
-  protected enum Phase {
-    HEADERS, MESSAGE, STATUS
-  }
-
-  private final MessageFramer framer;
-  private final MessageDeframer deframer;
-
-  /**
-   * Inbound phase is exclusively written to by the transport thread.
-   */
-  private Phase inboundPhase = Phase.HEADERS;
-
-  /**
-   * Outbound phase is exclusively written to by the application thread.
-   */
-  private Phase outboundPhase = Phase.HEADERS;
-
-  /**
-   * The number of queued bytes for a given stream, below which {@link StreamListener#onReady()}
-   * will be called.
-   */
-  private int onReadyThreshold = DEFAULT_ONREADY_THRESHOLD;
+  private static final Logger log = Logger.getLogger(AbstractStream.class.getName());
 
-  /**
-   * The number of bytes currently queued, waiting to be sent. When this falls below
-   * onReadyThreshold, {@link StreamListener#onReady()} will be called.
-   */
-  private int numSentBytesQueued;
+  /** The framer to use for sending messages. */
+  protected abstract Framer framer();
 
   /**
-   * Indicates the stream has been created on the connection. This implies that the stream is no
-   * longer limited by MAX_CONCURRENT_STREAMS.
+   * Obtain the transport state corresponding to this stream. Each stream must have its own unique
+   * transport state.
    */
-  @GuardedBy("onReadyLock")
-  private boolean allocated;
-
-  private final Object onReadyLock = new Object();
-
-  @VisibleForTesting
-  class FramerSink implements MessageFramer.Sink {
-    @Override
-    public void deliverFrame(WritableBuffer frame, boolean endOfStream, boolean flush) {
-      internalSendFrame(frame, endOfStream, flush);
-    }
-  }
-
-  @VisibleForTesting
-  class DeframerListener implements MessageDeframer.Listener {
-    @Override
-    public void bytesRead(int numBytes) {
-      returnProcessedBytes(numBytes);
-    }
-
-    @Override
-    public void messageRead(InputStream input) {
-      receiveMessage(input);
-    }
-
-    @Override
-    public void deliveryStalled() {
-      inboundDeliveryPaused();
-    }
-
-    @Override
-    public void endOfStream() {
-      remoteEndClosed();
-    }
-  }
-
-  AbstractStream(WritableBufferAllocator bufferAllocator, int maxMessageSize,
-      StatsTraceContext statsTraceCtx) {
-    framer = new MessageFramer(new FramerSink(), bufferAllocator, statsTraceCtx);
-    deframer = new MessageDeframer(new DeframerListener(), Codec.Identity.NONE, maxMessageSize,
-        statsTraceCtx, getClass().getName());
-  }
-
-  protected final void setMaxInboundMessageSizeProtected(int maxSize) {
-    deframer.setMaxInboundMessageSize(maxSize);
-  }
-
-  protected final void setMaxOutboundMessageSizeProtected(int maxSize) {
-    framer.setMaxOutboundMessageSize(maxSize);
-  }
-
-  @VisibleForTesting
-  AbstractStream(MessageFramer framer, MessageDeframer deframer) {
-    this.framer = framer;
-    this.deframer = deframer;
-  }
-
-  /**
-   * Override this method to provide a stream listener.
-   */
-  protected abstract StreamListener listener();
-
-  /**
-   * Returns the internal ID for this stream. Note that ID can be {@link #ABSENT_ID} for client
-   * streams as the transport may defer creating the stream to the remote side until it has a
-   * payload or metadata to send.
-   */
-  public abstract int id();
-
-  /**
-   * The number of queued bytes for a given stream, below which {@link StreamListener#onReady()}
-   * will be called. Defaults to {@link #DEFAULT_ONREADY_THRESHOLD}.
-   */
-  public int getOnReadyThreshold() {
-    synchronized (onReadyLock) {
-      return onReadyThreshold;
-    }
-  }
+  protected abstract TransportState transportState();
 
   @Override
-  public void writeMessage(InputStream message) {
-    checkNotNull(message, "message");
-    outboundPhase(Phase.MESSAGE);
-    if (!framer.isClosed()) {
-      framer.writePayload(message);
-    }
+  public void optimizeForDirectExecutor() {
+    transportState().optimizeForDirectExecutor();
   }
 
   @Override
   public final void setMessageCompression(boolean enable) {
-    framer.setMessageCompression(enable);
+    framer().setMessageCompression(enable);
   }
 
   @Override
-  public final void flush() {
-    if (!framer.isClosed()) {
-      framer.flush();
-    }
+  public final void request(int numMessages) {
+    transportState().requestMessagesFromDeframer(numMessages);
   }
 
   @Override
-  public boolean isReady() {
-    if (listener() != null && outboundPhase() != Phase.STATUS) {
-      synchronized (onReadyLock) {
-        return allocated && numSentBytesQueued < onReadyThreshold;
+  public final void writeMessage(InputStream message) {
+    checkNotNull(message, "message");
+    try {
+      if (!framer().isClosed()) {
+        framer().writePayload(message);
       }
+    } finally {
+      GrpcUtil.closeQuietly(message);
     }
-    return false;
   }
 
-  /**
-   * Closes the underlying framer.
-   *
-   * <p>No-op if the framer has already been closed.
-   */
-  final void closeFramer() {
-    if (!framer.isClosed()) {
-      framer.close();
+  @Override
+  public final void flush() {
+    if (!framer().isClosed()) {
+      framer().flush();
     }
   }
 
   /**
-   * Frees any resources associated with this stream. Subclass implementations must call this
-   * version.
+   * A hint to the stream that specifies how many bytes must be queued before
+   * {@link #isReady()} will return false. A stream may ignore this property if
+   * unsupported. This may only be set during stream initialization before
+   * any messages are set.
    *
-   * <p>NOTE: Can be called by both the transport thread and the application thread. Transport
-   * threads need to dispose when the remote side has terminated the stream. Application threads
-   * will dispose when the application decides to close the stream as part of normal processing.
+   * @param numBytes The number of bytes that must be queued. Must be a
+   *                 positive integer.
    */
-  public void dispose() {
-    framer.dispose();
+  protected void setOnReadyThreshold(int numBytes) {
+    transportState().setOnReadyThreshold(numBytes);
   }
 
   /**
-   * Sends an outbound frame to the remote end point.
-   *
-   * @param frame a buffer containing the chunk of data to be sent.
-   * @param endOfStream if {@code true} indicates that no more data will be sent on the stream by
-   *        this endpoint.
-   * @param flush {@code true} if more data may not be arriving soon
+   * Closes the underlying framer. Should be called when the outgoing stream is gracefully closed
+   * (half closure on client; closure on server).
    */
-  protected abstract void internalSendFrame(WritableBuffer frame, boolean endOfStream,
-      boolean flush);
-
-  /**
-   * Handles a message that was just deframed.
-   *
-   * @param is the stream containing the message
-   */
-  protected abstract void receiveMessage(InputStream is);
-
-  /**
-   * Handles the event that the deframer has no pending deliveries.
-   */
-  protected abstract void inboundDeliveryPaused();
-
-  /**
-   * Handles the event that the deframer has reached end of stream.
-   */
-  protected abstract void remoteEndClosed();
-
-  /**
-   * Returns the given number of processed bytes back to inbound flow control to enable receipt of
-   * more data.
-   */
-  protected abstract void returnProcessedBytes(int processedBytes);
-
-  /**
-   * Called when a {@link #deframe(ReadableBuffer, boolean)} operation failed.
-   *
-   * @param cause the actual failure
-   */
-  protected abstract void deframeFailed(Throwable cause);
-
-  /**
-   * Closes this deframer and frees any resources. After this method is called, additional calls
-   * will have no effect.
-   */
-  protected final void closeDeframer() {
-    deframer.close();
-  }
-
-  /**
-   * Called to parse a received frame and attempt delivery of any completed
-   * messages. Must be called from the transport thread.
-   */
-  protected final void deframe(ReadableBuffer frame, boolean endOfStream) {
-    try {
-      deframer.deframe(frame, endOfStream);
-    } catch (Throwable t) {
-      deframeFailed(t);
-    }
-  }
-
-  /**
-   * Indicates whether delivery is currently stalled, pending receipt of more data.
-   */
-  protected final boolean isDeframerStalled() {
-    return deframer.isStalled();
-  }
-
-  /**
-   * Called to request the given number of messages from the deframer. Must be called
-   * from the transport thread.
-   */
-  protected final void requestMessagesFromDeframer(int numMessages) {
-    try {
-      deframer.request(numMessages);
-    } catch (Throwable t) {
-      deframeFailed(t);
-    }
+  protected final void endOfMessages() {
+    framer().close();
   }
 
   @Override
   public final void setCompressor(Compressor compressor) {
-    framer.setCompressor(checkNotNull(compressor, "compressor"));
+    framer().setCompressor(checkNotNull(compressor, "compressor"));
   }
 
   @Override
-  public final void setDecompressor(Decompressor decompressor) {
-    deframer.setDecompressor(checkNotNull(decompressor, "decompressor"));
-  }
-
-  /**
-   * Event handler to be called by the subclass when the stream's headers have passed any connection
-   * flow control (i.e., MAX_CONCURRENT_STREAMS). It may call the listener's {@link
-   * StreamListener#onReady()} handler if appropriate. This must be called from the transport
-   * thread, since the listener may be called back directly.
-   */
-  protected final void onStreamAllocated() {
-    checkState(listener() != null);
-    synchronized (onReadyLock) {
-      checkState(!allocated, "Already allocated");
-      allocated = true;
-    }
-    notifyIfReady();
+  public boolean isReady() {
+    return transportState().isReady();
   }
 
   /**
@@ -337,114 +119,273 @@ protected final void onStreamAllocated() {
    * @param numBytes the number of bytes being sent.
    */
   protected final void onSendingBytes(int numBytes) {
-    synchronized (onReadyLock) {
-      numSentBytesQueued += numBytes;
-    }
+    transportState().onSendingBytes(numBytes);
   }
 
   /**
-   * Event handler to be called by the subclass when a number of bytes has been sent to the remote
-   * endpoint. May call back the listener's {@link StreamListener#onReady()} handler if appropriate.
-   * This must be called from the transport thread, since the listener may be called back directly.
-   *
-   * @param numBytes the number of bytes that were sent.
+   * Stream state as used by the transport. This should only be called from the transport thread
+   * (except for private interactions with {@code AbstractStream}).
    */
-  protected final void onSentBytes(int numBytes) {
-    boolean doNotify;
-    synchronized (onReadyLock) {
-      boolean belowThresholdBefore = numSentBytesQueued < onReadyThreshold;
-      numSentBytesQueued -= numBytes;
-      boolean belowThresholdAfter = numSentBytesQueued < onReadyThreshold;
-      doNotify = !belowThresholdBefore && belowThresholdAfter;
+  public abstract static class TransportState
+      implements ApplicationThreadDeframer.TransportExecutor, MessageDeframer.Listener {
+    /**
+     * The default number of queued bytes for a given stream, below which
+     * {@link StreamListener#onReady()} will be called.
+     */
+    @VisibleForTesting
+    public static final int DEFAULT_ONREADY_THRESHOLD = 32 * 1024;
+
+    private Deframer deframer;
+    private final Object onReadyLock = new Object();
+    private final StatsTraceContext statsTraceCtx;
+    private final TransportTracer transportTracer;
+    private final MessageDeframer rawDeframer;
+
+    /**
+     * The number of bytes currently queued, waiting to be sent. When this falls below
+     * DEFAULT_ONREADY_THRESHOLD, {@link StreamListener#onReady()} will be called.
+     */
+    @GuardedBy("onReadyLock")
+    private int numSentBytesQueued;
+    /**
+     * Indicates the stream has been created on the connection. This implies that the stream is no
+     * longer limited by MAX_CONCURRENT_STREAMS.
+     */
+    @GuardedBy("onReadyLock")
+    private boolean allocated;
+    /**
+     * Indicates that the stream no longer exists for the transport. Implies that the application
+     * should be discouraged from sending, because doing so would have no effect.
+     */
+    @GuardedBy("onReadyLock")
+    private boolean deallocated;
+
+    @GuardedBy("onReadyLock")
+    private int onReadyThreshold;
+
+    @SuppressWarnings("this-escape")
+    protected TransportState(
+        int maxMessageSize,
+        StatsTraceContext statsTraceCtx,
+        TransportTracer transportTracer) {
+      this.statsTraceCtx = checkNotNull(statsTraceCtx, "statsTraceCtx");
+      this.transportTracer = checkNotNull(transportTracer, "transportTracer");
+      this.rawDeframer = new MessageDeframer(
+          this,
+          Codec.Identity.NONE,
+          maxMessageSize,
+          statsTraceCtx,
+          transportTracer);
+      // TODO(#7168): use MigratingThreadDeframer when enabling retry doesn't break.
+      deframer = this.rawDeframer;
+      onReadyThreshold = DEFAULT_ONREADY_THRESHOLD;
     }
-    if (doNotify) {
-      notifyIfReady();
+
+    final void optimizeForDirectExecutor() {
+      rawDeframer.setListener(this);
+      deframer = rawDeframer;
     }
-  }
 
-  @VisibleForTesting
-  final void notifyIfReady() {
-    boolean doNotify = false;
-    synchronized (onReadyLock) {
-      doNotify = isReady();
+    protected void setFullStreamDecompressor(GzipInflatingBuffer fullStreamDecompressor) {
+      rawDeframer.setFullStreamDecompressor(fullStreamDecompressor);
+      deframer = new ApplicationThreadDeframer(this, this, rawDeframer);
     }
-    if (doNotify) {
-      listener().onReady();
+
+    final void setMaxInboundMessageSize(int maxSize) {
+      deframer.setMaxInboundMessageSize(maxSize);
     }
-  }
 
-  final Phase inboundPhase() {
-    return inboundPhase;
-  }
+    /**
+     * Override this method to provide a stream listener.
+     */
+    protected abstract StreamListener listener();
+
+    /**
+     * A hint to the stream that specifies how many bytes must be queued before
+     * {@link #isReady()} will return false. A stream may ignore this property if
+     * unsupported. This may only be set before any messages are sent.
+     *
+     * @param numBytes The number of bytes that must be queued. Must be a
+     *                 positive integer.
+     */
+    void setOnReadyThreshold(int numBytes) {
+      synchronized (onReadyLock) {
+        this.onReadyThreshold = numBytes;
+      }
+    }
 
-  /**
-   * Transitions the inbound phase to the given phase and returns the previous phase.
-   *
-   * @throws IllegalStateException if the transition is disallowed
-   */
-  final Phase inboundPhase(Phase nextPhase) {
-    Phase tmp = inboundPhase;
-    inboundPhase = verifyNextPhase(inboundPhase, nextPhase);
-    return tmp;
-  }
+    @Override
+    public void messagesAvailable(StreamListener.MessageProducer producer) {
+      listener().messagesAvailable(producer);
+    }
 
-  final Phase outboundPhase() {
-    return outboundPhase;
-  }
+    /**
+     * Closes the deframer and frees any resources. After this method is called, additional calls
+     * will have no effect.
+     *
+     * <p>When {@code stopDelivery} is false, the deframer will wait to close until any already
+     * queued messages have been delivered.
+     *
+     * <p>The deframer will invoke {@link #deframerClosed(boolean)} upon closing.
+     *
+     * @param stopDelivery interrupt pending deliveries and close immediately
+     */
+    protected final void closeDeframer(boolean stopDelivery) {
+      if (stopDelivery) {
+        deframer.close();
+      } else {
+        deframer.closeWhenComplete();
+      }
+    }
 
-  /**
-   * Transitions the outbound phase to the given phase and returns the previous phase.
-   *
-   * @throws IllegalStateException if the transition is disallowed
-   */
-  final Phase outboundPhase(Phase nextPhase) {
-    Phase tmp = outboundPhase;
-    outboundPhase = verifyNextPhase(outboundPhase, nextPhase);
-    return tmp;
-  }
+    /**
+     * Called to parse a received frame and attempt delivery of any completed messages. Must be
+     * called from the transport thread.
+     */
+    protected final void deframe(final ReadableBuffer frame) {
+      try {
+        deframer.deframe(frame);
+      } catch (Throwable t) {
+        deframeFailed(t);
+      }
+    }
+
+    /**
+     * Called to request the given number of messages from the deframer. May be called from any
+     * thread.
+     */
+    private void requestMessagesFromDeframer(final int numMessages) {
+      if (deframer instanceof ThreadOptimizedDeframer) {
+        try (TaskCloseable ignore = PerfMark.traceTask("AbstractStream.request")) {
+          deframer.request(numMessages);
+        }
+        return;
+      }
+      final Link link = PerfMark.linkOut();
+      class RequestRunnable implements Runnable {
+        @Override public void run() {
+          try (TaskCloseable ignore = PerfMark.traceTask("AbstractStream.request")) {
+            PerfMark.linkIn(link);
+            deframer.request(numMessages);
+          } catch (Throwable t) {
+            deframeFailed(t);
+          }
+        }
+      }
 
-  @VisibleForTesting
-  Phase verifyNextPhase(Phase currentPhase, Phase nextPhase) {
-    if (nextPhase.ordinal() < currentPhase.ordinal()) {
-      throw new IllegalStateException(
-          String.format("Cannot transition phase from %s to %s", currentPhase, nextPhase));
+      runOnTransportThread(new RequestRunnable());
     }
-    return nextPhase;
-  }
 
-  /**
-   * Returns {@code true} if the stream can receive data from its remote peer.
-   */
-  public boolean canReceive() {
-    return inboundPhase() != Phase.STATUS;
-  }
+    /**
+     * Very rarely used. Prefer stream.request() instead of this; this method is only necessary if
+     * a stream is not available.
+     */
+    @VisibleForTesting
+    public final void requestMessagesFromDeframerForTesting(int numMessages) {
+      requestMessagesFromDeframer(numMessages);
+    }
 
-  /**
-   * Returns {@code true} if the stream can send data to its remote peer.
-   */
-  public boolean canSend() {
-    return outboundPhase() != Phase.STATUS;
-  }
+    public final StatsTraceContext getStatsTraceContext() {
+      return statsTraceCtx;
+    }
 
-  /**
-   * Whether the stream is fully closed. Note that this method is not thread-safe as {@code
-   * inboundPhase} and {@code outboundPhase} are mutated in different threads. Tests must account
-   * for thread coordination when calling.
-   */
-  @VisibleForTesting
-  public boolean isClosed() {
-    return inboundPhase() == Phase.STATUS && outboundPhase() == Phase.STATUS;
-  }
+    protected final void setDecompressor(Decompressor decompressor) {
+      deframer.setDecompressor(decompressor);
+    }
 
-  @Override
-  public String toString() {
-    return toStringHelper().toString();
-  }
+    private boolean isReady() {
+      synchronized (onReadyLock) {
+        return allocated && numSentBytesQueued < onReadyThreshold && !deallocated;
+      }
+    }
+
+    /**
+     * Event handler to be called by the subclass when the stream's headers have passed any
+     * connection flow control (i.e., MAX_CONCURRENT_STREAMS). It may call the listener's {@link
+     * StreamListener#onReady()} handler if appropriate. This must be called from the transport
+     * thread, since the listener may be called back directly.
+     */
+    protected void onStreamAllocated() {
+      checkState(listener() != null);
+      synchronized (onReadyLock) {
+        checkState(!allocated, "Already allocated");
+        allocated = true;
+      }
+      notifyIfReady();
+    }
 
-  protected MoreObjects.ToStringHelper toStringHelper() {
-    return MoreObjects.toStringHelper(this)
-        .add("id", id())
-        .add("inboundPhase", inboundPhase().name())
-        .add("outboundPhase", outboundPhase().name());
+    /**
+     * Notify that the stream does not exist in a usable state any longer. This causes {@link
+     * AbstractStream#isReady()} to return {@code false} from this point forward.
+     *
+     * <p>This does not generally need to be called explicitly by the transport, as it is handled
+     * implicitly by {@link AbstractClientStream} and {@link AbstractServerStream}.
+     */
+    protected final void onStreamDeallocated() {
+      synchronized (onReadyLock) {
+        deallocated = true;
+      }
+    }
+
+    protected boolean isStreamDeallocated() {
+      synchronized (onReadyLock) {
+        return deallocated;
+      }
+    }
+
+    /**
+     * Event handler to be called by the subclass when a number of bytes are being queued for
+     * sending to the remote endpoint.
+     *
+     * @param numBytes the number of bytes being sent.
+     */
+    private void onSendingBytes(int numBytes) {
+      synchronized (onReadyLock) {
+        numSentBytesQueued += numBytes;
+      }
+    }
+
+    /**
+     * Event handler to be called by the subclass when a number of bytes has been sent to the remote
+     * endpoint. May call back the listener's {@link StreamListener#onReady()} handler if
+     * appropriate.  This must be called from the transport thread, since the listener may be called
+     * back directly.
+     *
+     * @param numBytes the number of bytes that were sent.
+     */
+    public final void onSentBytes(int numBytes) {
+      boolean doNotify;
+      synchronized (onReadyLock) {
+        checkState(allocated,
+            "onStreamAllocated was not called, but it seems the stream is active");
+        boolean belowThresholdBefore = numSentBytesQueued < onReadyThreshold;
+        numSentBytesQueued -= numBytes;
+        boolean belowThresholdAfter = numSentBytesQueued < onReadyThreshold;
+        doNotify = !belowThresholdBefore && belowThresholdAfter;
+      }
+      if (doNotify) {
+        notifyIfReady();
+      }
+    }
+
+    protected TransportTracer getTransportTracer() {
+      return transportTracer;
+    }
+
+    private void notifyIfReady() {
+      boolean doNotify;
+      synchronized (onReadyLock) {
+        doNotify = isReady();
+        if (!doNotify && log.isLoggable(Level.FINEST)) {
+          log.log(Level.FINEST,
+              "Stream not ready so skip notifying listener.\n"
+                  + "details: allocated/deallocated:{0}/{3}, sent queued: {1}, ready thresh: {2}",
+              new Object[] {allocated, numSentBytesQueued, onReadyThreshold, deallocated});
+        }
+      }
+      if (doNotify) {
+        listener().onReady();
+      }
+    }
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/AbstractStream2.java b/core/src/main/java/io/grpc/internal/AbstractStream2.java
deleted file mode 100644
index 28d8a890349..00000000000
--- a/core/src/main/java/io/grpc/internal/AbstractStream2.java
+++ /dev/null
@@ -1,309 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-
-import io.grpc.Codec;
-import io.grpc.Compressor;
-import io.grpc.Decompressor;
-import java.io.InputStream;
-import javax.annotation.concurrent.GuardedBy;
-
-/**
- * The stream and stream state as used by the application. Must only be called from the sending
- * application thread.
- */
-public abstract class AbstractStream2 implements Stream {
-  /** The framer to use for sending messages. */
-  protected abstract MessageFramer framer();
-
-  /**
-   * Obtain the transport state corresponding to this stream. Each stream must have its own unique
-   * transport state.
-   */
-  protected abstract TransportState transportState();
-
-  @Override
-  public final void setMessageCompression(boolean enable) {
-    framer().setMessageCompression(enable);
-  }
-
-  @Override
-  public final void writeMessage(InputStream message) {
-    checkNotNull(message, "message");
-    if (!framer().isClosed()) {
-      framer().writePayload(message);
-    }
-  }
-
-  @Override
-  public final void flush() {
-    if (!framer().isClosed()) {
-      framer().flush();
-    }
-  }
-
-  /**
-   * Closes the underlying framer. Should be called when the outgoing stream is gracefully closed
-   * (half closure on client; closure on server).
-   */
-  protected final void endOfMessages() {
-    framer().close();
-  }
-
-  @Override
-  public final void setCompressor(Compressor compressor) {
-    framer().setCompressor(checkNotNull(compressor, "compressor"));
-  }
-
-  @Override
-  public final void setDecompressor(Decompressor decompressor) {
-    transportState().setDecompressor(checkNotNull(decompressor, "decompressor"));
-  }
-
-  @Override
-  public boolean isReady() {
-    if (framer().isClosed()) {
-      return false;
-    }
-    return transportState().isReady();
-  }
-
-  /**
-   * Event handler to be called by the subclass when a number of bytes are being queued for sending
-   * to the remote endpoint.
-   *
-   * @param numBytes the number of bytes being sent.
-   */
-  protected final void onSendingBytes(int numBytes) {
-    transportState().onSendingBytes(numBytes);
-  }
-
-  /**
-   * Stream state as used by the transport. This should only called from the transport thread
-   * (except for private interactions with {@code AbstractStream2}).
-   */
-  public abstract static class TransportState implements MessageDeframer.Listener {
-    /**
-     * The default number of queued bytes for a given stream, below which
-     * {@link StreamListener#onReady()} will be called.
-     */
-    private static final int DEFAULT_ONREADY_THRESHOLD = 32 * 1024;
-
-    private final MessageDeframer deframer;
-    private final Object onReadyLock = new Object();
-    private final StatsTraceContext statsTraceCtx;
-    /**
-     * The number of bytes currently queued, waiting to be sent. When this falls below
-     * DEFAULT_ONREADY_THRESHOLD, {@link StreamListener#onReady()} will be called.
-     */
-    @GuardedBy("onReadyLock")
-    private int numSentBytesQueued;
-    /**
-     * Indicates the stream has been created on the connection. This implies that the stream is no
-     * longer limited by MAX_CONCURRENT_STREAMS.
-     */
-    @GuardedBy("onReadyLock")
-    private boolean allocated;
-    /**
-     * Indicates that the stream no longer exists for the transport. Implies that the application
-     * should be discouraged from sending, because doing so would have no effect.
-     */
-    @GuardedBy("onReadyLock")
-    private boolean deallocated;
-
-    protected TransportState(int maxMessageSize, StatsTraceContext statsTraceCtx) {
-      this.statsTraceCtx = checkNotNull(statsTraceCtx, "statsTraceCtx");
-      deframer = new MessageDeframer(
-          this, Codec.Identity.NONE, maxMessageSize, statsTraceCtx, getClass().getName());
-    }
-
-    final void setMaxInboundMessageSize(int maxSize) {
-      deframer.setMaxInboundMessageSize(maxSize);
-    }
-
-    /**
-     * Override this method to provide a stream listener.
-     */
-    protected abstract StreamListener listener();
-
-    @Override
-    public void messageRead(InputStream is) {
-      listener().messageRead(is);
-    }
-
-    /**
-     * Called when a {@link #deframe(ReadableBuffer, boolean)} operation failed.
-     *
-     * @param cause the actual failure
-     */
-    protected abstract void deframeFailed(Throwable cause);
-
-    /**
-     * Closes this deframer and frees any resources. After this method is called, additional calls
-     * will have no effect.
-     */
-    protected final void closeDeframer() {
-      deframer.close();
-    }
-
-    /**
-     * Indicates whether delivery is currently stalled, pending receipt of more data.
-     */
-    protected final boolean isDeframerStalled() {
-      return deframer.isStalled();
-    }
-
-    /**
-     * Called to parse a received frame and attempt delivery of any completed
-     * messages. Must be called from the transport thread.
-     */
-    protected final void deframe(ReadableBuffer frame, boolean endOfStream) {
-      if (deframer.isClosed()) {
-        frame.close();
-        return;
-      }
-      try {
-        deframer.deframe(frame, endOfStream);
-      } catch (Throwable t) {
-        deframeFailed(t);
-      }
-    }
-
-    /**
-     * Called to request the given number of messages from the deframer. Must be called
-     * from the transport thread.
-     */
-    public final void requestMessagesFromDeframer(int numMessages) {
-      if (deframer.isClosed()) {
-        return;
-      }
-      try {
-        deframer.request(numMessages);
-      } catch (Throwable t) {
-        deframeFailed(t);
-      }
-    }
-
-    public final StatsTraceContext getStatsTraceContext() {
-      return statsTraceCtx;
-    }
-
-    private void setDecompressor(Decompressor decompressor) {
-      if (deframer.isClosed()) {
-        return;
-      }
-      deframer.setDecompressor(decompressor);
-    }
-
-    private boolean isReady() {
-      synchronized (onReadyLock) {
-        return allocated && numSentBytesQueued < DEFAULT_ONREADY_THRESHOLD && !deallocated;
-      }
-    }
-
-    /**
-     * Event handler to be called by the subclass when the stream's headers have passed any
-     * connection flow control (i.e., MAX_CONCURRENT_STREAMS). It may call the listener's {@link
-     * StreamListener#onReady()} handler if appropriate. This must be called from the transport
-     * thread, since the listener may be called back directly.
-     */
-    protected void onStreamAllocated() {
-      checkState(listener() != null);
-      synchronized (onReadyLock) {
-        checkState(!allocated, "Already allocated");
-        allocated = true;
-      }
-      notifyIfReady();
-    }
-
-    /**
-     * Notify that the stream does not exist in a usable state any longer. This causes {@link
-     * AbstractStream2#isReady()} to return {@code false} from this point forward.
-     *
-     * <p>This does not generally need to be called explicitly by the transport, as it is handled
-     * implicitly by {@link AbstractClientStream2} and {@link AbstractServerStream}.
-     */
-    protected final void onStreamDeallocated() {
-      synchronized (onReadyLock) {
-        deallocated = true;
-      }
-    }
-
-    /**
-     * Event handler to be called by the subclass when a number of bytes are being queued for
-     * sending to the remote endpoint.
-     *
-     * @param numBytes the number of bytes being sent.
-     */
-    private void onSendingBytes(int numBytes) {
-      synchronized (onReadyLock) {
-        numSentBytesQueued += numBytes;
-      }
-    }
-
-    /**
-     * Event handler to be called by the subclass when a number of bytes has been sent to the remote
-     * endpoint. May call back the listener's {@link StreamListener#onReady()} handler if
-     * appropriate.  This must be called from the transport thread, since the listener may be called
-     * back directly.
-     *
-     * @param numBytes the number of bytes that were sent.
-     */
-    public final void onSentBytes(int numBytes) {
-      boolean doNotify;
-      synchronized (onReadyLock) {
-        checkState(allocated,
-            "onStreamAllocated was not called, but it seems the stream is active");
-        boolean belowThresholdBefore = numSentBytesQueued < DEFAULT_ONREADY_THRESHOLD;
-        numSentBytesQueued -= numBytes;
-        boolean belowThresholdAfter = numSentBytesQueued < DEFAULT_ONREADY_THRESHOLD;
-        doNotify = !belowThresholdBefore && belowThresholdAfter;
-      }
-      if (doNotify) {
-        notifyIfReady();
-      }
-    }
-
-    private void notifyIfReady() {
-      boolean doNotify;
-      synchronized (onReadyLock) {
-        doNotify = isReady();
-      }
-      if (doNotify) {
-        listener().onReady();
-      }
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/AbstractSubchannel.java b/core/src/main/java/io/grpc/internal/AbstractSubchannel.java
new file mode 100644
index 00000000000..cc4b3d9fb2c
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/AbstractSubchannel.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2016 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.internal;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.InternalChannelz.ChannelStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.LoadBalancer;
+
+/**
+ * The base interface of the Subchannels returned by {@link
+ * io.grpc.LoadBalancer.Helper#createSubchannel}.
+ */
+abstract class AbstractSubchannel extends LoadBalancer.Subchannel {
+
+  /**
+   * Returns the InternalSubchannel as an {@code Instrumented<T>} for the sole purpose of channelz
+   * unit tests.
+   */
+  @VisibleForTesting
+  abstract InternalInstrumented<ChannelStats> getInstrumentedInternalSubchannel();
+}
diff --git a/core/src/main/java/io/grpc/internal/ApplicationThreadDeframer.java b/core/src/main/java/io/grpc/internal/ApplicationThreadDeframer.java
new file mode 100644
index 00000000000..f53e1cda0ef
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ApplicationThreadDeframer.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Decompressor;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import javax.annotation.Nullable;
+
+/**
+ * Sits between {@link AbstractStream.TransportState} and {@link MessageDeframer} to deframe in the
+ * client thread. Calls from the transport to the deframer are wrapped into an {@link
+ * InitializingMessageProducer} and given back to the transport, where they will be run on the
+ * client thread. Calls from the deframer back to the transport use {@link
+ * TransportExecutor#runOnTransportThread} to run on the transport thread.
+ */
+public class ApplicationThreadDeframer implements Deframer {
+  interface TransportExecutor extends ApplicationThreadDeframerListener.TransportExecutor {}
+
+  private final MessageDeframer.Listener storedListener;
+  private final ApplicationThreadDeframerListener appListener;
+  private final MessageDeframer deframer;
+
+  ApplicationThreadDeframer(
+      MessageDeframer.Listener listener,
+      TransportExecutor transportExecutor,
+      MessageDeframer deframer) {
+    this.storedListener =
+        new SquelchLateMessagesAvailableDeframerListener(checkNotNull(listener, "listener"));
+    this.appListener = new ApplicationThreadDeframerListener(storedListener, transportExecutor);
+    deframer.setListener(appListener);
+    this.deframer = deframer;
+  }
+
+  @Override
+  public void setMaxInboundMessageSize(int messageSize) {
+    deframer.setMaxInboundMessageSize(messageSize);
+  }
+
+  @Override
+  public void setDecompressor(Decompressor decompressor) {
+    deframer.setDecompressor(decompressor);
+  }
+
+  @Override
+  public void setFullStreamDecompressor(GzipInflatingBuffer fullStreamDecompressor) {
+    deframer.setFullStreamDecompressor(fullStreamDecompressor);
+  }
+
+  @Override
+  public void request(final int numMessages) {
+    storedListener.messagesAvailable(
+        new InitializingMessageProducer(
+            new Runnable() {
+              @Override
+              public void run() {
+                if (deframer.isClosed()) {
+                  return;
+                }
+                try {
+                  deframer.request(numMessages);
+                } catch (Throwable t) {
+                  appListener.deframeFailed(t);
+                  deframer.close(); // unrecoverable state
+                }
+              }
+            }));
+  }
+
+  @Override
+  public void deframe(final ReadableBuffer data) {
+    storedListener.messagesAvailable(
+        new CloseableInitializingMessageProducer(
+            new Runnable() {
+              @Override
+              public void run() {
+                try {
+                  deframer.deframe(data);
+                } catch (Throwable t) {
+                  appListener.deframeFailed(t);
+                  deframer.close(); // unrecoverable state
+                }
+              }
+            },
+            new Closeable() {
+              @Override
+              public void close() {
+                data.close();
+              }
+            }));
+  }
+
+  @Override
+  public void closeWhenComplete() {
+    storedListener.messagesAvailable(
+        new InitializingMessageProducer(
+            new Runnable() {
+              @Override
+              public void run() {
+                deframer.closeWhenComplete();
+              }
+            }));
+  }
+
+  @Override
+  public void close() {
+    deframer.stopDelivery();
+    storedListener.messagesAvailable(
+        new InitializingMessageProducer(
+            new Runnable() {
+              @Override
+              public void run() {
+                deframer.close();
+              }
+            }));
+  }
+
+  @VisibleForTesting
+  MessageDeframer.Listener getAppListener() {
+    return appListener;
+  }
+
+  private class InitializingMessageProducer implements StreamListener.MessageProducer {
+    private final Runnable runnable;
+    private boolean initialized = false;
+
+    private InitializingMessageProducer(Runnable runnable) {
+      this.runnable = runnable;
+    }
+
+    private void initialize() {
+      if (!initialized) {
+        runnable.run();
+        initialized = true;
+      }
+    }
+
+    @Nullable
+    @Override
+    public InputStream next() {
+      initialize();
+      return appListener.messageReadQueuePoll();
+    }
+  }
+
+  private class CloseableInitializingMessageProducer extends InitializingMessageProducer
+      implements Closeable {
+    private final Closeable closeable;
+
+    public CloseableInitializingMessageProducer(Runnable runnable, Closeable closeable) {
+      super(runnable);
+      this.closeable = closeable;
+    }
+
+    @Override
+    public void close() throws IOException {
+      closeable.close();
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ApplicationThreadDeframerListener.java b/core/src/main/java/io/grpc/internal/ApplicationThreadDeframerListener.java
new file mode 100644
index 00000000000..48cb8d913e4
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ApplicationThreadDeframerListener.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2019 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.io.InputStream;
+import java.util.ArrayDeque;
+import java.util.Queue;
+
+/**
+ * Listener for when deframing on the application thread, which calls the real listener on the
+ * transport thread. May only be called on the application thread.
+ *
+ * <p>Does not call the delegate's {@code messagesAvailable()}. It's expected that
+ * {@code messageReadQueuePoll()} is called on the application thread from within a message producer
+ * managed elsewhere.
+ */
+final class ApplicationThreadDeframerListener implements MessageDeframer.Listener {
+  public interface TransportExecutor {
+    void runOnTransportThread(Runnable r);
+  }
+
+  private final TransportExecutor transportExecutor;
+  private final MessageDeframer.Listener storedListener;
+  /** Queue for messages returned by the deframer when deframing in the application thread. */
+  private final Queue<InputStream> messageReadQueue = new ArrayDeque<>();
+
+  public ApplicationThreadDeframerListener(
+      MessageDeframer.Listener listener, TransportExecutor transportExecutor) {
+    this.storedListener = checkNotNull(listener, "listener");
+    this.transportExecutor = checkNotNull(transportExecutor, "transportExecutor");
+  }
+
+  @Override
+  public void bytesRead(final int numBytes) {
+    transportExecutor.runOnTransportThread(
+        new Runnable() {
+          @Override
+          public void run() {
+            storedListener.bytesRead(numBytes);
+          }
+        });
+  }
+
+  @Override
+  public void messagesAvailable(StreamListener.MessageProducer producer) {
+    InputStream message;
+    while ((message = producer.next()) != null) {
+      messageReadQueue.add(message);
+    }
+  }
+
+  @Override
+  public void deframerClosed(final boolean hasPartialMessage) {
+    transportExecutor.runOnTransportThread(
+        new Runnable() {
+          @Override
+          public void run() {
+            storedListener.deframerClosed(hasPartialMessage);
+          }
+        });
+  }
+
+  @Override
+  public void deframeFailed(final Throwable cause) {
+    transportExecutor.runOnTransportThread(
+        new Runnable() {
+          @Override
+          public void run() {
+            storedListener.deframeFailed(cause);
+          }
+        });
+  }
+
+  public InputStream messageReadQueuePoll() {
+    return messageReadQueue.poll();
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/AtomicBackoff.java b/core/src/main/java/io/grpc/internal/AtomicBackoff.java
new file mode 100644
index 00000000000..68ba9bece0c
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/AtomicBackoff.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2017 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.internal;
+
+import com.google.common.base.Preconditions;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A {@code long} atomically updated due to errors caused by the value being too small.
+ */
+@ThreadSafe
+public final class AtomicBackoff {
+  private static final Logger log = Logger.getLogger(AtomicBackoff.class.getName());
+
+  private final String name;
+  private final AtomicLong value = new AtomicLong();
+
+  /** Construct an atomic with initial value {@code value}. {@code name} is used for logging. */
+  public AtomicBackoff(String name, long value) {
+    Preconditions.checkArgument(value > 0, "value must be positive");
+    this.name = name;
+    this.value.set(value);
+  }
+
+  /** Returns the current state. The state instance's value does not change of time. */
+  public State getState() {
+    return new State(value.get());
+  }
+
+  @ThreadSafe
+  public final class State {
+    private final long savedValue;
+
+    private State(long value) {
+      this.savedValue = value;
+    }
+
+    public long get() {
+      return savedValue;
+    }
+
+    /**
+     * Causes future invocations of {@link AtomicBackoff#getState} to have a value at least double
+     * this state's value. Subsequent calls to this method will not increase the value further.
+     */
+    public void backoff() {
+      // Use max to handle overflow
+      long newValue = Math.max(savedValue * 2, savedValue);
+      boolean swapped = value.compareAndSet(savedValue, newValue);
+      // Even if swapped is false, the current value should be at least as large as newValue
+      assert value.get() >= newValue;
+      if (swapped) {
+        log.log(Level.WARNING, "Increased {0} to {1}", new Object[] {name, newValue});
+      }
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/AtomicLongCounter.java b/core/src/main/java/io/grpc/internal/AtomicLongCounter.java
new file mode 100644
index 00000000000..6fab7930a06
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/AtomicLongCounter.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2017 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.internal;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * An implementation of {@link LongCounter} that is just an {@link AtomicLong}.
+ */
+final class AtomicLongCounter implements LongCounter {
+  private final AtomicLong counter = new AtomicLong();
+
+  /**
+   * Creates an {@link AtomicLongCounter}.
+   */
+  AtomicLongCounter() {
+  }
+
+  @Override
+  public void add(long delta) {
+    counter.getAndAdd(delta);
+  }
+
+  @Override
+  public long value() {
+    return counter.get();
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/AuthorityVerifier.java b/core/src/main/java/io/grpc/internal/AuthorityVerifier.java
new file mode 100644
index 00000000000..e6164a7dc4d
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/AuthorityVerifier.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright 2025 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.internal;
+
+import io.grpc.Status;
+
+/** Verifier for the outgoing authority pseudo-header against peer cert. */
+public interface AuthorityVerifier {
+  Status verifyAuthority(String authority);
+}
diff --git a/core/src/main/java/io/grpc/internal/AutoConfiguredLoadBalancerFactory.java b/core/src/main/java/io/grpc/internal/AutoConfiguredLoadBalancerFactory.java
new file mode 100644
index 00000000000..dcefa8f8351
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/AutoConfiguredLoadBalancerFactory.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.FixedResultPicker;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.ServiceConfigUtil.LbConfig;
+import io.grpc.internal.ServiceConfigUtil.PolicySelection;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+public final class AutoConfiguredLoadBalancerFactory extends LoadBalancerProvider {
+
+  private final LoadBalancerRegistry registry;
+  private final LoadBalancerProvider defaultProvider;
+
+  public AutoConfiguredLoadBalancerFactory(String defaultPolicy) {
+    this(LoadBalancerRegistry.getDefaultRegistry(), defaultPolicy);
+  }
+
+  @VisibleForTesting
+  AutoConfiguredLoadBalancerFactory(LoadBalancerRegistry registry, String defaultPolicy) {
+    this.registry = checkNotNull(registry, "registry");
+    LoadBalancerProvider provider =
+        registry.getProvider(checkNotNull(defaultPolicy, "defaultPolicy"));
+    if (provider == null) {
+      Status status = Status.INTERNAL.withDescription("Could not find policy '" + defaultPolicy
+          + "'. Make sure its implementation is either registered to LoadBalancerRegistry or"
+          + " included in META-INF/services/io.grpc.LoadBalancerProvider from your jar files.");
+      provider = new FixedPickerLoadBalancerProvider(
+          ConnectivityState.TRANSIENT_FAILURE,
+          new LoadBalancer.FixedResultPicker(PickResult.withError(status)),
+          status);
+    }
+    this.defaultProvider = provider;
+  }
+
+  @Override
+  public AutoConfiguredLoadBalancer newLoadBalancer(Helper helper) {
+    return new AutoConfiguredLoadBalancer(helper);
+  }
+
+  @VisibleForTesting
+  public final class AutoConfiguredLoadBalancer extends LoadBalancer {
+    private final Helper helper;
+    private LoadBalancer delegate;
+    private LoadBalancerProvider delegateProvider;
+
+    AutoConfiguredLoadBalancer(Helper helper) {
+      this.helper = helper;
+      this.delegateProvider = defaultProvider;
+      delegate = delegateProvider.newLoadBalancer(helper);
+    }
+
+    /**
+     * Returns non-OK status if the delegate rejects the resolvedAddresses (e.g. if it does not
+     * support an empty list).
+     */
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      PolicySelection policySelection =
+          (PolicySelection) resolvedAddresses.getLoadBalancingPolicyConfig();
+
+      if (policySelection == null) {
+        policySelection =
+            new PolicySelection(defaultProvider, /* config= */ null);
+      }
+
+      if (delegateProvider == null
+          || !policySelection.provider.getPolicyName().equals(delegateProvider.getPolicyName())) {
+        helper.updateBalancingState(
+            ConnectivityState.CONNECTING, new FixedResultPicker(PickResult.withNoResult()));
+        delegate.shutdown();
+        delegateProvider = policySelection.provider;
+        LoadBalancer old = delegate;
+        delegate = delegateProvider.newLoadBalancer(helper);
+        helper.getChannelLogger().log(
+            ChannelLogLevel.INFO, "Load balancer changed from {0} to {1}",
+            old.getClass().getSimpleName(), delegate.getClass().getSimpleName());
+      }
+      Object lbConfig = policySelection.config;
+      if (lbConfig != null) {
+        helper.getChannelLogger().log(
+            ChannelLogLevel.DEBUG, "Load-balancing config: {0}", policySelection.config);
+      }
+
+      return getDelegate().acceptResolvedAddresses(
+          ResolvedAddresses.newBuilder()
+              .setAddresses(resolvedAddresses.getAddresses())
+              .setAttributes(resolvedAddresses.getAttributes())
+              .setLoadBalancingPolicyConfig(lbConfig)
+              .build());
+    }
+
+    @Override
+    public void handleNameResolutionError(Status error) {
+      getDelegate().handleNameResolutionError(error);
+    }
+
+    @Override
+    @Deprecated
+    public void handleSubchannelState(Subchannel subchannel, ConnectivityStateInfo stateInfo) {
+      getDelegate().handleSubchannelState(subchannel, stateInfo);
+    }
+
+    @Override
+    public void requestConnection() {
+      getDelegate().requestConnection();
+    }
+
+    @Override
+    public void shutdown() {
+      delegate.shutdown();
+      delegate = null;
+    }
+
+    @VisibleForTesting
+    public LoadBalancer getDelegate() {
+      return delegate;
+    }
+
+    @VisibleForTesting
+    void setDelegate(LoadBalancer lb) {
+      delegate = lb;
+    }
+
+    @VisibleForTesting
+    LoadBalancerProvider getDelegateProvider() {
+      return delegateProvider;
+    }
+  }
+
+  /**
+   * Parses first available LoadBalancer policy from service config. Available LoadBalancer should
+   * be registered to {@link LoadBalancerRegistry}. If the first available LoadBalancer policy is
+   * invalid, it doesn't fall-back to next available policy, instead it returns error. This also
+   * means, it ignores LoadBalancer policies after the first available one even if any of them are
+   * invalid.
+   *
+   * <p>Order of policy preference:
+   *
+   * <ol>
+   *    <li>Policy from "loadBalancingConfig" if present</li>
+   *    <li>The policy from deprecated "loadBalancingPolicy" if present</li>
+   * </ol>
+   * </p>
+   *
+   * <p>Unlike a normal {@link LoadBalancer.Factory}, this accepts a full service config rather than
+   * the LoadBalancingConfig.
+   *
+   * @return the parsed {@link PolicySelection}, or {@code null} if no selection could be made.
+   */
+  // TODO(ejona): The Provider API doesn't allow null, but ScParser can handle this and it will need
+  // tweaking to ManagedChannelImpl.defaultServiceConfig to fix.
+  @Nullable
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> serviceConfig) {
+    try {
+      List<LbConfig> loadBalancerConfigs = null;
+      if (serviceConfig != null) {
+        List<Map<String, ?>> rawLbConfigs =
+            ServiceConfigUtil.getLoadBalancingConfigsFromServiceConfig(serviceConfig);
+        loadBalancerConfigs = ServiceConfigUtil.unwrapLoadBalancingConfigList(rawLbConfigs);
+      }
+      if (loadBalancerConfigs != null && !loadBalancerConfigs.isEmpty()) {
+        return ServiceConfigUtil.selectLbPolicyFromList(loadBalancerConfigs, registry);
+      }
+      return null;
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError(
+          Status.UNKNOWN.withDescription("can't parse load balancer configuration").withCause(e));
+    }
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return "auto_configured_internal";
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/BackoffPolicy.java b/core/src/main/java/io/grpc/internal/BackoffPolicy.java
index 1a2bc375ea7..c80ef9e1f9d 100644
--- a/core/src/main/java/io/grpc/internal/BackoffPolicy.java
+++ b/core/src/main/java/io/grpc/internal/BackoffPolicy.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -34,14 +19,14 @@
 /**
  * Determines how long to wait before doing some action (typically a retry, or a reconnect).
  */
-interface BackoffPolicy {
+public interface BackoffPolicy {
   interface Provider {
     BackoffPolicy get();
   }
 
   /**
-   * @return The number of milliseconds to wait.
+   * Returns the number of nanoseconds to wait.
    */
-  long nextBackoffMillis();
+  long nextBackoffNanos();
 }
 
diff --git a/core/src/main/java/io/grpc/internal/BackoffPolicyRetryScheduler.java b/core/src/main/java/io/grpc/internal/BackoffPolicyRetryScheduler.java
new file mode 100644
index 00000000000..e5a66205364
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/BackoffPolicyRetryScheduler.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2023 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.internal;
+
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Schedules a retry operation according to a {@link BackoffPolicy}. The retry is run within a
+ * {@link SynchronizationContext}. At most one retry is scheduled at a time.
+ */
+final class BackoffPolicyRetryScheduler implements RetryScheduler {
+  private final ScheduledExecutorService scheduledExecutorService;
+  private final SynchronizationContext syncContext;
+  private final BackoffPolicy.Provider policyProvider;
+
+  private BackoffPolicy policy;
+  private ScheduledHandle scheduledHandle;
+
+  private static final Logger logger = Logger.getLogger(
+      BackoffPolicyRetryScheduler.class.getName());
+
+  BackoffPolicyRetryScheduler(BackoffPolicy.Provider policyProvider,
+      ScheduledExecutorService scheduledExecutorService,
+      SynchronizationContext syncContext) {
+    this.policyProvider = policyProvider;
+    this.scheduledExecutorService = scheduledExecutorService;
+    this.syncContext = syncContext;
+  }
+
+  /**
+   * Schedules a future retry operation. Only allows one retry to be scheduled at any given time.
+   */
+  @Override
+  public void schedule(Runnable retryOperation) {
+    syncContext.throwIfNotInThisSynchronizationContext();
+
+    if (policy == null) {
+      policy = policyProvider.get();
+    }
+    // If a retry is already scheduled, take no further action.
+    if (scheduledHandle != null && scheduledHandle.isPending()) {
+      return;
+    }
+    long delayNanos = policy.nextBackoffNanos();
+    scheduledHandle = syncContext.schedule(retryOperation, delayNanos, TimeUnit.NANOSECONDS,
+        scheduledExecutorService);
+    logger.log(Level.FINE, "Scheduling DNS resolution backoff for {0}ns", delayNanos);
+  }
+
+  /**
+   * Resets the {@link BackoffPolicyRetryScheduler} and cancels any pending retry task. The policy
+   * will be cleared thus also resetting any state associated with it (e.g. a backoff multiplier).
+   */
+  @Override
+  public void reset() {
+    syncContext.throwIfNotInThisSynchronizationContext();
+
+    syncContext.execute(() -> {
+      if (scheduledHandle != null && scheduledHandle.isPending()) {
+        scheduledHandle.cancel();
+      }
+      policy = null;
+    });
+  }
+
+}
diff --git a/core/src/main/java/io/grpc/internal/CallCredentialsApplyingTransportFactory.java b/core/src/main/java/io/grpc/internal/CallCredentialsApplyingTransportFactory.java
index 14b9ddb3095..97a74bda97e 100644
--- a/core/src/main/java/io/grpc/internal/CallCredentialsApplyingTransportFactory.java
+++ b/core/src/main/java/io/grpc/internal/CallCredentialsApplyingTransportFactory.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016,2022 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -34,31 +19,55 @@
 import static com.google.common.base.MoreObjects.firstNonNull;
 import static com.google.common.base.Preconditions.checkNotNull;
 
+import com.google.errorprone.annotations.concurrent.GuardedBy;
 import io.grpc.Attributes;
 import io.grpc.CallCredentials;
+import io.grpc.CallCredentials.RequestInfo;
 import io.grpc.CallOptions;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.ClientStreamTracer;
+import io.grpc.CompositeCallCredentials;
+import io.grpc.InternalMayRequireSpecificExecutor;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.SecurityLevel;
+import io.grpc.Status;
+import io.grpc.internal.MetadataApplierImpl.MetadataApplierListener;
 import java.net.SocketAddress;
+import java.util.Collection;
 import java.util.concurrent.Executor;
-import javax.annotation.Nullable;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.atomic.AtomicInteger;
 
 final class CallCredentialsApplyingTransportFactory implements ClientTransportFactory {
   private final ClientTransportFactory delegate;
+  private final CallCredentials channelCallCredentials;
   private final Executor appExecutor;
 
   CallCredentialsApplyingTransportFactory(
-      ClientTransportFactory delegate, Executor appExecutor) {
+      ClientTransportFactory delegate, CallCredentials channelCallCredentials,
+      Executor appExecutor) {
     this.delegate = checkNotNull(delegate, "delegate");
+    this.channelCallCredentials = channelCallCredentials;
     this.appExecutor = checkNotNull(appExecutor, "appExecutor");
   }
 
   @Override
   public ConnectionClientTransport newClientTransport(
-      SocketAddress serverAddress, String authority, @Nullable String userAgent) {
+      SocketAddress serverAddress, ClientTransportOptions options, ChannelLogger channelLogger) {
     return new CallCredentialsApplyingTransport(
-        delegate.newClientTransport(serverAddress, authority, userAgent), authority);
+        delegate.newClientTransport(serverAddress, options, channelLogger), options.getAuthority());
+  }
+
+  @Override
+  public ScheduledExecutorService getScheduledExecutorService() {
+    return delegate.getScheduledExecutorService();
+  }
+
+  @Override
+  public SwapChannelCredentialsResult swapChannelCredentials(ChannelCredentials channelCreds) {
+    throw new UnsupportedOperationException();
   }
 
   @Override
@@ -66,9 +75,29 @@ public void close() {
     delegate.close();
   }
 
+  @Override
+  public Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+    return delegate.getSupportedSocketAddressTypes();
+  }
+
   private class CallCredentialsApplyingTransport extends ForwardingConnectionClientTransport {
     private final ConnectionClientTransport delegate;
     private final String authority;
+    // Negative value means transport active, non-negative value indicates shutdown invoked.
+    private final AtomicInteger pendingApplier = new AtomicInteger(Integer.MIN_VALUE + 1);
+    private volatile Status shutdownStatus;
+    @GuardedBy("this")
+    private Status savedShutdownStatus;
+    @GuardedBy("this")
+    private Status savedShutdownNowStatus;
+    private final MetadataApplierListener applierListener = new MetadataApplierListener() {
+      @Override
+      public void onComplete() {
+        if (pendingApplier.decrementAndGet() == 0) {
+          maybeShutdown();
+        }
+      }
+    };
 
     CallCredentialsApplyingTransport(ConnectionClientTransport delegate, String authority) {
       this.delegate = checkNotNull(delegate, "delegate");
@@ -81,25 +110,136 @@ protected ConnectionClientTransport delegate() {
     }
 
     @Override
+    @SuppressWarnings("deprecation")
     public ClientStream newStream(
-        MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
-        StatsTraceContext statsTraceCtx) {
+        final MethodDescriptor<?, ?> method, Metadata headers, final CallOptions callOptions,
+        ClientStreamTracer[] tracers) {
       CallCredentials creds = callOptions.getCredentials();
+      if (creds == null) {
+        creds = channelCallCredentials;
+      } else if (channelCallCredentials != null) {
+        creds = new CompositeCallCredentials(channelCallCredentials, creds);
+      }
       if (creds != null) {
         MetadataApplierImpl applier = new MetadataApplierImpl(
-            delegate, method, headers, callOptions, statsTraceCtx);
-        Attributes.Builder effectiveAttrsBuilder = Attributes.newBuilder()
-            .set(CallCredentials.ATTR_AUTHORITY, authority)
-            .set(CallCredentials.ATTR_SECURITY_LEVEL, SecurityLevel.NONE)
-            .setAll(delegate.getAttributes());
-        if (callOptions.getAuthority() != null) {
-          effectiveAttrsBuilder.set(CallCredentials.ATTR_AUTHORITY, callOptions.getAuthority());
+            delegate, method, headers, callOptions, applierListener, tracers);
+        if (pendingApplier.incrementAndGet() > 0) {
+          applierListener.onComplete();
+          return new FailingClientStream(shutdownStatus, tracers);
+        }
+        RequestInfo requestInfo = new RequestInfo() {
+            @Override
+            public MethodDescriptor<?, ?> getMethodDescriptor() {
+              return method;
+            }
+
+            @Override
+            public CallOptions getCallOptions() {
+              return callOptions;
+            }
+
+            @Override
+            public SecurityLevel getSecurityLevel() {
+              return firstNonNull(
+                  delegate.getAttributes().get(GrpcAttributes.ATTR_SECURITY_LEVEL),
+                  SecurityLevel.NONE);
+            }
+
+            @Override
+            public String getAuthority() {
+              return firstNonNull(callOptions.getAuthority(), authority);
+            }
+
+            @Override
+            public Attributes getTransportAttrs() {
+              return delegate.getAttributes();
+            }
+          };
+        try {
+          // Hack to allow appengine to work when using AppEngineCredentials (b/244209681)
+          // since processing must happen on a specific thread.
+          //
+          // Ideally would always use appExecutor and we could eliminate the interface
+          // InternalMayRequireSpecificExecutor
+          Executor executor;
+          if (creds instanceof InternalMayRequireSpecificExecutor
+              && ((InternalMayRequireSpecificExecutor)creds).isSpecificExecutorRequired()
+              && callOptions.getExecutor() != null) {
+            executor = callOptions.getExecutor();
+          } else {
+            executor = appExecutor;
+          }
+
+          creds.applyRequestMetadata(requestInfo, executor, applier);
+        } catch (Throwable t) {
+          applier.fail(Status.UNAUTHENTICATED
+              .withDescription("Credentials should use fail() instead of throwing exceptions")
+              .withCause(t));
         }
-        creds.applyRequestMetadata(method, effectiveAttrsBuilder.build(),
-            firstNonNull(callOptions.getExecutor(), appExecutor), applier);
         return applier.returnStream();
       } else {
-        return delegate.newStream(method, headers, callOptions, statsTraceCtx);
+        if (pendingApplier.get() >= 0) {
+          return new FailingClientStream(shutdownStatus, tracers);
+        }
+        return delegate.newStream(method, headers, callOptions, tracers);
+      }
+    }
+
+    @Override
+    public void shutdown(Status status) {
+      checkNotNull(status, "status");
+      synchronized (this) {
+        if (pendingApplier.get() < 0) {
+          shutdownStatus = status;
+          pendingApplier.addAndGet(Integer.MAX_VALUE);
+        } else {
+          return;
+        }
+        if (pendingApplier.get() != 0) {
+          savedShutdownStatus = status;
+          return;
+        }
+      }
+      super.shutdown(status);
+    }
+
+    // TODO(zivy): cancel pending applier here.
+    @Override
+    public void shutdownNow(Status status) {
+      checkNotNull(status, "status");
+      synchronized (this) {
+        if (pendingApplier.get() < 0) {
+          shutdownStatus = status;
+          pendingApplier.addAndGet(Integer.MAX_VALUE);
+        } else if (savedShutdownNowStatus != null) {
+          return;
+        }
+        if (pendingApplier.get() != 0) {
+          savedShutdownNowStatus = status;
+          // TODO(zivy): propagate shutdownNow to the delegate immediately.
+          return;
+        }
+      }
+      super.shutdownNow(status);
+    }
+
+    private void maybeShutdown() {
+      Status maybeShutdown;
+      Status maybeShutdownNow;
+      synchronized (this) {
+        if (pendingApplier.get() != 0) {
+          return;
+        }
+        maybeShutdown = savedShutdownStatus;
+        maybeShutdownNow = savedShutdownNowStatus;
+        savedShutdownStatus = null;
+        savedShutdownNowStatus = null;
+      }
+      if (maybeShutdown != null) {
+        super.shutdown(maybeShutdown);
+      }
+      if (maybeShutdownNow != null) {
+        super.shutdownNow(maybeShutdownNow);
       }
     }
   }
diff --git a/core/src/main/java/io/grpc/internal/CallTracer.java b/core/src/main/java/io/grpc/internal/CallTracer.java
new file mode 100644
index 00000000000..330323d1ba0
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/CallTracer.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static io.grpc.internal.TimeProvider.SYSTEM_TIME_PROVIDER;
+
+import io.grpc.InternalChannelz.ChannelStats;
+import io.grpc.InternalChannelz.ServerStats;
+
+/**
+ * A collection of call stats for channelz.
+ */
+final class CallTracer {
+  private final TimeProvider timeProvider;
+  private final LongCounter callsStarted = LongCounterFactory.create();
+  private final LongCounter callsSucceeded = LongCounterFactory.create();
+  private final LongCounter callsFailed = LongCounterFactory.create();
+  private volatile long lastCallStartedNanos;
+
+  CallTracer(TimeProvider timeProvider) {
+    this.timeProvider = timeProvider;
+  }
+
+  public void reportCallStarted() {
+    callsStarted.add(1);
+    lastCallStartedNanos = timeProvider.currentTimeNanos();
+  }
+
+  public void reportCallEnded(boolean success) {
+    if (success) {
+      callsSucceeded.add(1);
+    } else {
+      callsFailed.add(1);
+    }
+  }
+
+  void updateBuilder(ChannelStats.Builder builder) {
+    builder
+        .setCallsStarted(callsStarted.value())
+        .setCallsSucceeded(callsSucceeded.value())
+        .setCallsFailed(callsFailed.value())
+        .setLastCallStartedNanos(lastCallStartedNanos);
+  }
+
+  void updateBuilder(ServerStats.Builder builder) {
+    builder
+        .setCallsStarted(callsStarted.value())
+        .setCallsSucceeded(callsSucceeded.value())
+        .setCallsFailed(callsFailed.value())
+        .setLastCallStartedNanos(lastCallStartedNanos);
+  }
+
+  public interface Factory {
+    CallTracer create();
+  }
+
+  static final Factory DEFAULT_FACTORY = new Factory() {
+    @Override
+    public CallTracer create() {
+      return new CallTracer(SYSTEM_TIME_PROVIDER);
+    }
+  };
+
+  public static Factory getDefaultFactory() {
+    return DEFAULT_FACTORY;
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/CertificateUtils.java b/core/src/main/java/io/grpc/internal/CertificateUtils.java
new file mode 100644
index 00000000000..130a435bb1a
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/CertificateUtils.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2024 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.internal;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.util.Collection;
+import java.util.List;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+import javax.security.auth.x500.X500Principal;
+
+/**
+ * Contains certificate/key PEM file utility method(s) for internal usage.
+ */
+public final class CertificateUtils {
+  private static final Class<?> x509ExtendedTrustManagerClass;
+
+  static {
+    Class<?> x509ExtendedTrustManagerClass1;
+    try {
+      x509ExtendedTrustManagerClass1 = Class.forName("javax.net.ssl.X509ExtendedTrustManager");
+    } catch (ClassNotFoundException e) {
+      x509ExtendedTrustManagerClass1 = null;
+      // Will disallow per-rpc authority override via call option.
+    }
+    x509ExtendedTrustManagerClass = x509ExtendedTrustManagerClass1;
+  }
+
+  /**
+   * Creates X509TrustManagers using the provided CA certs.
+   */
+  public static TrustManager[] createTrustManager(byte[] rootCerts)
+      throws GeneralSecurityException {
+    InputStream rootCertsStream = new ByteArrayInputStream(rootCerts);
+    try {
+      return CertificateUtils.createTrustManager(rootCertsStream);
+    } finally {
+      GrpcUtil.closeQuietly(rootCertsStream);
+    }
+  }
+
+  /**
+   * Creates X509TrustManagers using the provided input stream of CA certs.
+   */
+  public static TrustManager[] createTrustManager(InputStream rootCerts)
+          throws GeneralSecurityException {
+    KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
+    try {
+      ks.load(null, null);
+    } catch (IOException ex) {
+      // Shouldn't really happen, as we're not loading any data.
+      throw new GeneralSecurityException(ex);
+    }
+    X509Certificate[] certs = CertificateUtils.getX509Certificates(rootCerts);
+    for (X509Certificate cert : certs) {
+      X500Principal principal = cert.getSubjectX500Principal();
+      ks.setCertificateEntry(principal.getName("RFC2253"), cert);
+    }
+
+    TrustManagerFactory trustManagerFactory =
+            TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+    trustManagerFactory.init(ks);
+    return trustManagerFactory.getTrustManagers();
+  }
+
+  public static X509TrustManager getX509ExtendedTrustManager(List<TrustManager> trustManagers) {
+    if (x509ExtendedTrustManagerClass != null) {
+      for (TrustManager trustManager : trustManagers) {
+        if (x509ExtendedTrustManagerClass.isInstance(trustManager)) {
+          return (X509TrustManager) trustManager;
+        }
+      }
+    }
+    return null;
+  }
+
+  private static X509Certificate[] getX509Certificates(InputStream inputStream)
+          throws CertificateException {
+    CertificateFactory factory = CertificateFactory.getInstance("X.509");
+    Collection<? extends Certificate> certs = factory.generateCertificates(inputStream);
+    return certs.toArray(new X509Certificate[0]);
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ChannelExecutor.java b/core/src/main/java/io/grpc/internal/ChannelExecutor.java
deleted file mode 100644
index 3bf549d9108..00000000000
--- a/core/src/main/java/io/grpc/internal/ChannelExecutor.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.annotations.VisibleForTesting;
-import java.util.LinkedList;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import javax.annotation.concurrent.GuardedBy;
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * The thread-less Channel Executor used to run the state mutation logic in {@link
- * ManagedChannelImpl}, {@link InternalSubchannel} and {@link io.grpc.LoadBalancer2}s.
- *
- * <p>Tasks are queued until {@link #drain} is called.  Tasks are guaranteed to be run in the same
- * order as they are submitted.
- */
-@ThreadSafe
-final class ChannelExecutor {
-  private static final Logger log = Logger.getLogger(ChannelExecutor.class.getName());
-
-  private final Object lock = new Object();
-
-  @GuardedBy("lock")
-  private final LinkedList<Runnable> queue = new LinkedList<Runnable>();
-  @GuardedBy("lock")
-  private boolean draining;
-
-  /**
-   * Run all tasks in the queue in the current thread, if no other thread is in this method.
-   * Otherwise do nothing.
-   *
-   * <p>Upon returning, it guarantees that all tasks submitted by {@code executeLater()} before it
-   * have been or will eventually be run, while not requiring any more calls to {@code drain()}.
-   */
-  void drain() {
-    boolean drainLeaseAcquired = false;
-    while (true) {
-      Runnable runnable;
-      synchronized (lock) {
-        if (!drainLeaseAcquired) {
-          if (draining) {
-            return;
-          }
-          draining = true;
-          drainLeaseAcquired = true;
-        }
-        runnable = queue.poll();
-        if (runnable == null) {
-          draining = false;
-          break;
-        }
-      }
-      try {
-        runnable.run();
-      } catch (Throwable t) {
-        log.log(Level.WARNING, "Runnable threw exception in ChannelExecutor", t);
-      }
-    }
-  }
-
-  /**
-   * Enqueues a task that will be run when {@link #drain} is called.
-   *
-   * @return this ChannelExecutor
-   */
-  ChannelExecutor executeLater(Runnable runnable) {
-    synchronized (lock) {
-      queue.add(checkNotNull(runnable, "runnable is null"));
-    }
-    return this;
-  }
-
-  @VisibleForTesting
-  int numPendingTasks() {
-    synchronized (lock) {
-      return queue.size();
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/ChannelLoggerImpl.java b/core/src/main/java/io/grpc/internal/ChannelLoggerImpl.java
new file mode 100644
index 00000000000..e8504498cdb
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ChannelLoggerImpl.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.ChannelLogger;
+import io.grpc.InternalChannelz.ChannelTrace.Event;
+import io.grpc.InternalChannelz.ChannelTrace.Event.Severity;
+import io.grpc.InternalLogId;
+import java.text.MessageFormat;
+import java.util.logging.Level;
+
+final class ChannelLoggerImpl extends ChannelLogger {
+  private final ChannelTracer tracer;
+  private final TimeProvider time;
+
+  ChannelLoggerImpl(ChannelTracer tracer, TimeProvider time) {
+    this.tracer = checkNotNull(tracer, "tracer");
+    this.time = checkNotNull(time, "time");
+  }
+
+  @Override
+  public void log(ChannelLogLevel level, String msg) {
+    logOnly(tracer.getLogId(), level, msg);
+    if (isTraceable(level)) {
+      trace(level, msg);
+    }
+  }
+
+  @Override
+  public void log(ChannelLogLevel level, String messageFormat, Object... args) {
+    String msg = null;
+    Level javaLogLevel = toJavaLogLevel(level);
+    if (isTraceable(level) || ChannelTracer.logger.isLoggable(javaLogLevel)) {
+      msg = MessageFormat.format(messageFormat, args);
+    }
+    log(level, msg);
+  }
+
+  static void logOnly(InternalLogId logId, ChannelLogLevel level, String msg) {
+    Level javaLogLevel = toJavaLogLevel(level);
+    if (ChannelTracer.logger.isLoggable(javaLogLevel)) {
+      ChannelTracer.logOnly(logId, javaLogLevel, msg);
+    }
+  }
+
+  static void logOnly(
+      InternalLogId logId, ChannelLogLevel level, String messageFormat, Object... args) {
+    Level javaLogLevel = toJavaLogLevel(level);
+    if (ChannelTracer.logger.isLoggable(javaLogLevel)) {
+      String msg = MessageFormat.format(messageFormat, args);
+      ChannelTracer.logOnly(logId, javaLogLevel, msg);
+    }
+  }
+
+  private boolean isTraceable(ChannelLogLevel level) {
+    return level != ChannelLogLevel.DEBUG && tracer.isTraceEnabled();
+  }
+
+  private void trace(ChannelLogLevel level, String msg) {
+    if (level == ChannelLogLevel.DEBUG) {
+      return;
+    }
+    tracer.traceOnly(new Event.Builder()
+        .setDescription(msg)
+        .setSeverity(toTracerSeverity(level))
+        .setTimestampNanos(time.currentTimeNanos())
+        .build());
+  }
+
+  private static Severity toTracerSeverity(ChannelLogLevel level) {
+    switch (level) {
+      case ERROR:
+        return Severity.CT_ERROR;
+      case WARNING:
+        return Severity.CT_WARNING;
+      default:
+        return Severity.CT_INFO;
+    }
+  }
+
+  private static Level toJavaLogLevel(ChannelLogLevel level) {
+    switch (level) {
+      case ERROR:
+      case WARNING:
+        return Level.FINE;
+      case INFO:
+        return Level.FINER;
+      default:
+        return Level.FINEST;
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ChannelTracer.java b/core/src/main/java/io/grpc/internal/ChannelTracer.java
new file mode 100644
index 00000000000..a9730a365cc
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ChannelTracer.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.ChannelLogger;
+import io.grpc.InternalChannelz.ChannelStats;
+import io.grpc.InternalChannelz.ChannelTrace;
+import io.grpc.InternalChannelz.ChannelTrace.Event;
+import io.grpc.InternalLogId;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * Tracks a collections of channel tracing events for a channel/subchannel.
+ */
+final class ChannelTracer {
+  // The logs go to ChannelLogger's logger so that user can control the logging level on that public
+  // class rather than on this internal class.
+  static final Logger logger = Logger.getLogger(ChannelLogger.class.getName());
+  private final Object lock = new Object();
+  private final InternalLogId logId;
+  @GuardedBy("lock")
+  @Nullable
+  private final Collection<Event> events;
+  private final long channelCreationTimeNanos;
+
+  @GuardedBy("lock")
+  private int eventsLogged;
+
+  /**
+   * Creates a channel tracer and log the creation event of the underlying channel.
+   *
+   * @param logId logId will be prepended to the logs logged to Java logger
+   * @param maxEvents maximum number of events that are retained in memory.  If not a positive
+   *        number no events will be retained, but they will still be sent to the Java logger.
+   * @param channelCreationTimeNanos the creation time of the entity being traced
+   * @param description a description of the entity being traced
+   */
+  ChannelTracer(
+      InternalLogId logId, final int maxEvents, long channelCreationTimeNanos, String description) {
+    checkNotNull(description, "description");
+    this.logId = checkNotNull(logId, "logId");
+    if (maxEvents > 0) {
+      events = new ArrayDeque<Event>() {
+          @GuardedBy("lock")
+          @Override
+          public boolean add(Event event) {
+            if (size() == maxEvents) {
+              removeFirst();
+            }
+            eventsLogged++;
+            return super.add(event);
+          }
+        };
+    } else {
+      events = null;
+    }
+    this.channelCreationTimeNanos = channelCreationTimeNanos;
+
+    reportEvent(new ChannelTrace.Event.Builder()
+        .setDescription(description + " created")
+        .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+        // passing the timestamp in as a parameter instead of computing it right here because when
+        // parent channel and subchannel both report the same event of the subchannel (e.g. creation
+        // event of the subchannel) we want the timestamps to be exactly the same.
+        .setTimestampNanos(channelCreationTimeNanos)
+        .build());
+  }
+
+  void reportEvent(Event event) {
+    Level logLevel;
+    switch (event.severity) {
+      case CT_ERROR:
+        logLevel = Level.FINE;
+        break;
+      case CT_WARNING:
+        logLevel = Level.FINER;
+        break;
+      default:
+        logLevel = Level.FINEST;
+    }
+    traceOnly(event);
+    logOnly(logId, logLevel, event.description);
+  }
+
+  boolean isTraceEnabled() {
+    synchronized (lock) {
+      return events != null;
+    }
+  }
+
+  void traceOnly(Event event) {
+    synchronized (lock) {
+      if (events != null) {
+        events.add(event);
+      }
+    }
+  }
+
+  static void logOnly(InternalLogId logId, Level logLevel, String msg) {
+    if (logger.isLoggable(logLevel)) {
+      LogRecord lr = new LogRecord(logLevel, "[" + logId + "] " + msg);
+      // No resource bundle as gRPC is not localized.
+      lr.setLoggerName(logger.getName());
+      lr.setSourceClassName(logger.getName());
+      // Both logger methods are called log in ChannelLogger.
+      lr.setSourceMethodName("log");
+      logger.log(lr);
+    }
+  }
+
+  InternalLogId getLogId() {
+    return logId;
+  }
+
+  void updateBuilder(ChannelStats.Builder builder) {
+    List<Event> eventsSnapshot;
+    int eventsLoggedSnapshot;
+    synchronized (lock) {
+      if (events == null) {
+        return;
+      }
+      eventsLoggedSnapshot = eventsLogged;
+      eventsSnapshot = new ArrayList<>(events);
+    }
+    builder.setChannelTrace(new ChannelTrace.Builder()
+        .setNumEventsLogged(eventsLoggedSnapshot)
+        .setCreationTimeNanos(channelCreationTimeNanos)
+        .setEvents(eventsSnapshot)
+        .build());
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ClientCallImpl.java b/core/src/main/java/io/grpc/internal/ClientCallImpl.java
index c1fda5361c6..4b24b1eae3d 100644
--- a/core/src/main/java/io/grpc/internal/ClientCallImpl.java
+++ b/core/src/main/java/io/grpc/internal/ClientCallImpl.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -35,35 +20,48 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
 import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
+import static io.grpc.ClientStreamTracer.NAME_RESOLUTION_DELAYED;
 import static io.grpc.Contexts.statusFromCancelled;
 import static io.grpc.Status.DEADLINE_EXCEEDED;
+import static io.grpc.internal.GrpcUtil.CONTENT_ACCEPT_ENCODING_KEY;
+import static io.grpc.internal.GrpcUtil.CONTENT_ENCODING_KEY;
+import static io.grpc.internal.GrpcUtil.CONTENT_LENGTH_KEY;
 import static io.grpc.internal.GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY;
 import static io.grpc.internal.GrpcUtil.MESSAGE_ENCODING_KEY;
-import static io.grpc.internal.GrpcUtil.TIMEOUT_KEY;
-import static java.lang.Math.max;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
+import com.google.common.base.MoreObjects;
 import io.grpc.Attributes;
 import io.grpc.CallOptions;
 import io.grpc.ClientCall;
+import io.grpc.ClientStreamTracer;
 import io.grpc.Codec;
 import io.grpc.Compressor;
 import io.grpc.CompressorRegistry;
 import io.grpc.Context;
+import io.grpc.Context.CancellationListener;
 import io.grpc.Deadline;
-import io.grpc.Decompressor;
 import io.grpc.DecompressorRegistry;
+import io.grpc.InternalConfigSelector;
+import io.grpc.InternalDecompressorRegistry;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.MethodType;
 import io.grpc.Status;
+import io.grpc.internal.ManagedChannelServiceConfig.MethodInfo;
+import io.perfmark.Link;
+import io.perfmark.PerfMark;
+import io.perfmark.Tag;
+import io.perfmark.TaskCloseable;
 import java.io.InputStream;
+import java.nio.charset.Charset;
+import java.util.Locale;
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
@@ -71,61 +69,76 @@
 /**
  * Implementation of {@link ClientCall}.
  */
-final class ClientCallImpl<ReqT, RespT> extends ClientCall<ReqT, RespT>
-    implements Context.CancellationListener {
+final class ClientCallImpl<ReqT, RespT> extends ClientCall<ReqT, RespT> {
 
   private static final Logger log = Logger.getLogger(ClientCallImpl.class.getName());
+  private static final byte[] FULL_STREAM_DECOMPRESSION_ENCODINGS
+      = "gzip".getBytes(Charset.forName("US-ASCII"));
+  private static final double NANO_TO_SECS = 1.0 * TimeUnit.SECONDS.toNanos(1);
 
   private final MethodDescriptor<ReqT, RespT> method;
+  private final Tag tag;
   private final Executor callExecutor;
+  private final boolean callExecutorIsDirect;
+  private final CallTracer channelCallsTracer;
   private final Context context;
-  private volatile ScheduledFuture<?> deadlineCancellationFuture;
+  private CancellationHandler cancellationHandler;
   private final boolean unaryRequest;
-  private final CallOptions callOptions;
-  private final StatsTraceContext statsTraceCtx;
+  private CallOptions callOptions;
   private ClientStream stream;
-  private volatile boolean cancelListenersShouldBeRemoved;
   private boolean cancelCalled;
   private boolean halfCloseCalled;
-  private final ClientTransportProvider clientTransportProvider;
-  private ScheduledExecutorService deadlineCancellationExecutor;
+  private final ClientStreamProvider clientStreamProvider;
+  private final ScheduledExecutorService deadlineCancellationExecutor;
+  private boolean fullStreamDecompression;
   private DecompressorRegistry decompressorRegistry = DecompressorRegistry.getDefaultInstance();
   private CompressorRegistry compressorRegistry = CompressorRegistry.getDefaultInstance();
 
-  ClientCallImpl(MethodDescriptor<ReqT, RespT> method, Executor executor,
-      CallOptions callOptions, StatsTraceContext statsTraceCtx,
-      ClientTransportProvider clientTransportProvider,
-      ScheduledExecutorService deadlineCancellationExecutor) {
+  ClientCallImpl(
+      MethodDescriptor<ReqT, RespT> method, Executor executor, CallOptions callOptions,
+      ClientStreamProvider clientStreamProvider,
+      ScheduledExecutorService deadlineCancellationExecutor,
+      CallTracer channelCallsTracer,
+      // TODO(zdapeng): remove this arg
+      @Nullable InternalConfigSelector configSelector) {
     this.method = method;
+    // TODO(carl-mastrangelo): consider moving this construction to ManagedChannelImpl.
+    this.tag = PerfMark.createTag(method.getFullMethodName(), System.identityHashCode(this));
     // If we know that the executor is a direct executor, we don't need to wrap it with a
     // SerializingExecutor. This is purely for performance reasons.
     // See https://github.com/grpc/grpc-java/issues/368
-    this.callExecutor = executor == directExecutor()
-        ? new SerializeReentrantCallsDirectExecutor()
-        : new SerializingExecutor(executor);
+    if (executor == directExecutor()) {
+      this.callExecutor = new SerializeReentrantCallsDirectExecutor();
+      callExecutorIsDirect = true;
+    } else {
+      this.callExecutor = new SerializingExecutor(executor);
+      callExecutorIsDirect = false;
+    }
+    this.channelCallsTracer = channelCallsTracer;
     // Propagate the context from the thread which initiated the call to all callbacks.
     this.context = Context.current();
-    this.statsTraceCtx = Preconditions.checkNotNull(statsTraceCtx, "statsTraceCtx");
     this.unaryRequest = method.getType() == MethodType.UNARY
         || method.getType() == MethodType.SERVER_STREAMING;
     this.callOptions = callOptions;
-    this.clientTransportProvider = clientTransportProvider;
+    this.clientStreamProvider = clientStreamProvider;
     this.deadlineCancellationExecutor = deadlineCancellationExecutor;
-  }
-
-  @Override
-  public void cancelled(Context context) {
-    stream.cancel(statusFromCancelled(context));
+    PerfMark.event("ClientCall.<init>", tag);
   }
 
   /**
-   * Provider of {@link ClientTransport}s.
+   * Provider of {@link ClientStream}s.
    */
-  interface ClientTransportProvider {
-    /**
-     * Returns a transport for a new call.
-     */
-    ClientTransport get(CallOptions callOptions, Metadata headers);
+  interface ClientStreamProvider {
+    ClientStream newStream(
+        MethodDescriptor<?, ?> method,
+        CallOptions callOptions,
+        Metadata headers,
+        Context context);
+  }
+
+  ClientCallImpl<ReqT, RespT> setFullStreamDecompression(boolean fullStreamDecompression) {
+    this.fullStreamDecompression = fullStreamDecompression;
+    return this;
   }
 
   ClientCallImpl<ReqT, RespT> setDecompressorRegistry(DecompressorRegistry decompressorRegistry) {
@@ -139,24 +152,42 @@ ClientCallImpl<ReqT, RespT> setCompressorRegistry(CompressorRegistry compressorR
   }
 
   @VisibleForTesting
-  static void prepareHeaders(Metadata headers, DecompressorRegistry decompressorRegistry,
-      Compressor compressor, StatsTraceContext statsTraceCtx) {
+  static void prepareHeaders(
+      Metadata headers,
+      DecompressorRegistry decompressorRegistry,
+      Compressor compressor,
+      boolean fullStreamDecompression) {
+    headers.discardAll(CONTENT_LENGTH_KEY);
     headers.discardAll(MESSAGE_ENCODING_KEY);
     if (compressor != Codec.Identity.NONE) {
       headers.put(MESSAGE_ENCODING_KEY, compressor.getMessageEncoding());
     }
 
     headers.discardAll(MESSAGE_ACCEPT_ENCODING_KEY);
-    String advertisedEncodings = decompressorRegistry.getRawAdvertisedMessageEncodings();
-    if (!advertisedEncodings.isEmpty()) {
+    byte[] advertisedEncodings =
+        InternalDecompressorRegistry.getRawAdvertisedMessageEncodings(decompressorRegistry);
+    if (advertisedEncodings.length != 0) {
       headers.put(MESSAGE_ACCEPT_ENCODING_KEY, advertisedEncodings);
     }
-    statsTraceCtx.propagateToHeaders(headers);
+
+    headers.discardAll(CONTENT_ENCODING_KEY);
+    headers.discardAll(CONTENT_ACCEPT_ENCODING_KEY);
+    if (fullStreamDecompression) {
+      headers.put(CONTENT_ACCEPT_ENCODING_KEY, FULL_STREAM_DECOMPRESSION_ENCODINGS);
+    }
   }
 
   @Override
-  public void start(final Listener<RespT> observer, Metadata headers) {
+  public void start(Listener<RespT> observer, Metadata headers) {
+    try (TaskCloseable ignore = PerfMark.traceTask("ClientCall.start")) {
+      PerfMark.attachTag(tag);
+      startInternal(observer, headers);
+    }
+  }
+
+  private void startInternal(Listener<RespT> observer, Metadata headers) {
     checkState(stream == null, "Already started");
+    checkState(!cancelCalled, "call was cancelled");
     checkNotNull(observer, "observer");
     checkNotNull(headers, "headers");
 
@@ -164,6 +195,7 @@ public void start(final Listener<RespT> observer, Metadata headers) {
       // Context is already cancelled so no need to create a real stream, just notify the observer
       // of cancellation via callback on the executor
       stream = NoopClientStream.INSTANCE;
+      final Listener<RespT> finalObserver = observer;
       class ClosedByContext extends ContextRunnable {
         ClosedByContext() {
           super(context);
@@ -171,19 +203,21 @@ class ClosedByContext extends ContextRunnable {
 
         @Override
         public void runInContext() {
-          closeObserver(observer, statusFromCancelled(context), new Metadata());
+          closeObserver(finalObserver, statusFromCancelled(context), new Metadata());
         }
       }
 
       callExecutor.execute(new ClosedByContext());
       return;
     }
+    applyMethodConfig();
     final String compressorName = callOptions.getCompressor();
-    Compressor compressor = null;
+    Compressor compressor;
     if (compressorName != null) {
       compressor = compressorRegistry.lookupCompressor(compressorName);
       if (compressor == null) {
         stream = NoopClientStream.INSTANCE;
+        final Listener<RespT> finalObserver = observer;
         class ClosedByNotFoundCompressor extends ContextRunnable {
           ClosedByNotFoundCompressor() {
             super(context);
@@ -192,7 +226,7 @@ class ClosedByNotFoundCompressor extends ContextRunnable {
           @Override
           public void runInContext() {
             closeObserver(
-                observer,
+                finalObserver,
                 Status.INTERNAL.withDescription(
                     String.format("Unable to find compressor by name %s", compressorName)),
                 new Metadata());
@@ -205,25 +239,32 @@ public void runInContext() {
     } else {
       compressor = Codec.Identity.NONE;
     }
-
-    prepareHeaders(headers, decompressorRegistry, compressor, statsTraceCtx);
+    prepareHeaders(headers, decompressorRegistry, compressor, fullStreamDecompression);
 
     Deadline effectiveDeadline = effectiveDeadline();
-    boolean deadlineExceeded = effectiveDeadline != null && effectiveDeadline.isExpired();
+    boolean contextIsDeadlineSource = effectiveDeadline != null
+        && effectiveDeadline.equals(context.getDeadline());
+    cancellationHandler = new CancellationHandler(effectiveDeadline, contextIsDeadlineSource);
+    boolean deadlineExceeded = effectiveDeadline != null && cancellationHandler.remainingNanos <= 0;
     if (!deadlineExceeded) {
-      updateTimeoutHeaders(effectiveDeadline, callOptions.getDeadline(),
-          context.getDeadline(), headers);
-      ClientTransport transport = clientTransportProvider.get(callOptions, headers);
-      Context origContext = context.attach();
-      try {
-        stream = transport.newStream(method, headers, callOptions, statsTraceCtx);
-      } finally {
-        context.detach(origContext);
-      }
+      stream = clientStreamProvider.newStream(method, callOptions, headers, context);
     } else {
-      stream = new FailingClientStream(DEADLINE_EXCEEDED);
+      ClientStreamTracer[] tracers =
+          GrpcUtil.getClientStreamTracers(callOptions, headers, 0,
+              false, false);
+      String deadlineName = contextIsDeadlineSource ? "Context" : "CallOptions";
+      Long nameResolutionDelay = callOptions.getOption(NAME_RESOLUTION_DELAYED);
+      String description = String.format(
+          "ClientCall started after %s deadline was exceeded %.9f seconds ago. "
+              + "Name resolution delay %.9f seconds.", deadlineName,
+          cancellationHandler.remainingNanos / NANO_TO_SECS,
+          nameResolutionDelay == null ? 0 : nameResolutionDelay / NANO_TO_SECS);
+      stream = new FailingClientStream(DEADLINE_EXCEEDED.withDescription(description), tracers);
     }
 
+    if (callExecutorIsDirect) {
+      stream.optimizeForDirectExecutor();
+    }
     if (callOptions.getAuthority() != null) {
       stream.setAuthority(callOptions.getAuthority());
     }
@@ -233,89 +274,153 @@ public void runInContext() {
     if (callOptions.getMaxOutboundMessageSize() != null) {
       stream.setMaxOutboundMessageSize(callOptions.getMaxOutboundMessageSize());
     }
+    if (effectiveDeadline != null) {
+      stream.setDeadline(effectiveDeadline);
+    }
     stream.setCompressor(compressor);
+    if (fullStreamDecompression) {
+      stream.setFullStreamDecompression(fullStreamDecompression);
+    }
+    stream.setDecompressorRegistry(decompressorRegistry);
+    channelCallsTracer.reportCallStarted();
     stream.start(new ClientStreamListenerImpl(observer));
 
     // Delay any sources of cancellation after start(), because most of the transports are broken if
     // they receive cancel before start. Issue #1343 has more details
 
     // Propagate later Context cancellation to the remote side.
-    context.addListener(this, directExecutor());
-    if (effectiveDeadline != null
-        // If the context has the effective deadline, we don't need to schedule an extra task.
-        && context.getDeadline() != effectiveDeadline) {
-      deadlineCancellationFuture = startDeadlineTimer(effectiveDeadline);
-    }
-    if (cancelListenersShouldBeRemoved) {
-      // Race detected! ClientStreamListener.closed may have been called before
-      // deadlineCancellationFuture was set / context listener added, thereby preventing the future
-      // and listener from being cancelled. Go ahead and cancel again, just to be sure it
-      // was cancelled.
-      removeContextListenerAndCancelDeadlineFuture();
-    }
+    cancellationHandler.setUp();
   }
 
-  /**
-   * Based on the deadline, calculate and set the timeout to the given headers.
-   */
-  private static void updateTimeoutHeaders(@Nullable Deadline effectiveDeadline,
-      @Nullable Deadline callDeadline, @Nullable Deadline outerCallDeadline, Metadata headers) {
-    headers.discardAll(TIMEOUT_KEY);
-
-    if (effectiveDeadline == null) {
+  private void applyMethodConfig() {
+    MethodInfo info = callOptions.getOption(MethodInfo.KEY);
+    if (info == null) {
       return;
     }
-
-    long effectiveTimeout = max(0, effectiveDeadline.timeRemaining(TimeUnit.NANOSECONDS));
-    headers.put(TIMEOUT_KEY, effectiveTimeout);
-
-    logIfContextNarrowedTimeout(effectiveTimeout, effectiveDeadline, outerCallDeadline,
-        callDeadline);
+    if (info.timeoutNanos != null) {
+      Deadline newDeadline = Deadline.after(info.timeoutNanos, TimeUnit.NANOSECONDS);
+      Deadline existingDeadline = callOptions.getDeadline();
+      // If the new deadline is sooner than the existing deadline, swap them.
+      if (existingDeadline == null || newDeadline.compareTo(existingDeadline) < 0) {
+        callOptions = callOptions.withDeadline(newDeadline);
+      }
+    }
+    if (info.waitForReady != null) {
+      callOptions =
+          info.waitForReady ? callOptions.withWaitForReady() : callOptions.withoutWaitForReady();
+    }
+    if (info.maxInboundMessageSize != null) {
+      Integer existingLimit = callOptions.getMaxInboundMessageSize();
+      if (existingLimit != null) {
+        callOptions =
+            callOptions.withMaxInboundMessageSize(
+                Math.min(existingLimit, info.maxInboundMessageSize));
+      } else {
+        callOptions = callOptions.withMaxInboundMessageSize(info.maxInboundMessageSize);
+      }
+    }
+    if (info.maxOutboundMessageSize != null) {
+      Integer existingLimit = callOptions.getMaxOutboundMessageSize();
+      if (existingLimit != null) {
+        callOptions =
+            callOptions.withMaxOutboundMessageSize(
+                Math.min(existingLimit, info.maxOutboundMessageSize));
+      } else {
+        callOptions = callOptions.withMaxOutboundMessageSize(info.maxOutboundMessageSize);
+      }
+    }
   }
 
-  private static void logIfContextNarrowedTimeout(long effectiveTimeout,
-      Deadline effectiveDeadline, @Nullable Deadline outerCallDeadline,
-      @Nullable Deadline callDeadline) {
-    if (!log.isLoggable(Level.INFO) || outerCallDeadline != effectiveDeadline) {
-      return;
+  private final class CancellationHandler implements Runnable, CancellationListener {
+    private final boolean contextIsDeadlineSource;
+    private final boolean hasDeadline;
+    private final long remainingNanos;
+    private volatile ScheduledFuture<?> deadlineCancellationFuture;
+    private volatile boolean tearDownCalled;
+
+    CancellationHandler(Deadline deadline, boolean contextIsDeadlineSource) {
+      this.contextIsDeadlineSource = contextIsDeadlineSource;
+      if (deadline == null) {
+        hasDeadline = false;
+        remainingNanos = 0;
+      } else {
+        hasDeadline = true;
+        remainingNanos = deadline.timeRemaining(TimeUnit.NANOSECONDS);
+      }
     }
 
-    StringBuilder builder = new StringBuilder();
-    builder.append(String.format("Call timeout set to '%d' ns, due to context deadline.",
-        effectiveTimeout));
-    if (callDeadline == null) {
-      builder.append(" Explicit call timeout was not set.");
-    } else {
-      long callTimeout = callDeadline.timeRemaining(TimeUnit.NANOSECONDS);
-      builder.append(String.format(" Explicit call timeout was '%d' ns.", callTimeout));
+    void setUp() {
+      if (tearDownCalled) {
+        return;
+      }
+      if (hasDeadline
+          // If the context has the effective deadline, we don't need to schedule an extra task.
+          && !contextIsDeadlineSource
+          // If the channel has been terminated, we don't need to schedule an extra task.
+          && deadlineCancellationExecutor != null) {
+        deadlineCancellationFuture = deadlineCancellationExecutor.schedule(
+            new LogExceptionRunnable(this), remainingNanos, TimeUnit.NANOSECONDS);
+      }
+      context.addListener(this, directExecutor());
+      if (tearDownCalled) {
+        // Race detected! Re-run to make sure the future is cancelled and context listener removed
+        tearDown();
+      }
     }
 
-    log.info(builder.toString());
-  }
+    // May be called multiple times, and race with setUp()
+    void tearDown() {
+      tearDownCalled = true;
+      ScheduledFuture<?> deadlineCancellationFuture = this.deadlineCancellationFuture;
+      if (deadlineCancellationFuture != null) {
+        deadlineCancellationFuture.cancel(false);
+      }
+      context.removeListener(this);
+    }
 
-  private void removeContextListenerAndCancelDeadlineFuture() {
-    context.removeListener(this);
-    ScheduledFuture<?> f = deadlineCancellationFuture;
-    if (f != null) {
-      f.cancel(false);
+    @Override
+    public void cancelled(Context context) {
+      if (hasDeadline && contextIsDeadlineSource
+          && context.cancellationCause() instanceof TimeoutException) {
+        stream.cancel(formatDeadlineExceededStatus());
+        return;
+      }
+      stream.cancel(statusFromCancelled(context));
     }
-  }
 
-  private class DeadlineTimer implements Runnable {
     @Override
     public void run() {
+      stream.cancel(formatDeadlineExceededStatus());
+    }
+
+    Status formatDeadlineExceededStatus() {
       // DelayedStream.cancel() is safe to call from a thread that is different from where the
       // stream is created.
-      stream.cancel(DEADLINE_EXCEEDED);
+      long seconds = Math.abs(remainingNanos) / TimeUnit.SECONDS.toNanos(1);
+      long nanos = Math.abs(remainingNanos) % TimeUnit.SECONDS.toNanos(1);
+
+      StringBuilder buf = new StringBuilder();
+      buf.append(contextIsDeadlineSource ? "Context" : "CallOptions");
+      buf.append(" deadline exceeded after ");
+      if (remainingNanos < 0) {
+        buf.append('-');
+      }
+      buf.append(seconds);
+      buf.append(String.format(Locale.US, ".%09d", nanos));
+      buf.append("s. ");
+      Long nsDelay = callOptions.getOption(NAME_RESOLUTION_DELAYED);
+      buf.append(String.format(Locale.US, "Name resolution delay %.9f seconds.",
+          nsDelay == null ? 0 : nsDelay / NANO_TO_SECS));
+      if (stream != null) {
+        InsightBuilder insight = new InsightBuilder();
+        stream.appendTimeoutInsight(insight);
+        buf.append(" ");
+        buf.append(insight);
+      }
+      return DEADLINE_EXCEEDED.withDescription(buf.toString());
     }
   }
 
-  private ScheduledFuture<?> startDeadlineTimer(Deadline deadline) {
-    return deadlineCancellationExecutor.schedule(
-        new LogExceptionRunnable(new DeadlineTimer()), deadline.timeRemaining(TimeUnit.NANOSECONDS),
-        TimeUnit.NANOSECONDS);
-  }
-
   @Nullable
   private Deadline effectiveDeadline() {
     // Call options and context are immutable, so we don't need to cache the deadline.
@@ -335,13 +440,23 @@ private static Deadline min(@Nullable Deadline deadline0, @Nullable Deadline dea
 
   @Override
   public void request(int numMessages) {
-    Preconditions.checkState(stream != null, "Not started");
-    checkArgument(numMessages >= 0, "Number requested must be non-negative");
-    stream.request(numMessages);
+    try (TaskCloseable ignore = PerfMark.traceTask("ClientCall.request")) {
+      PerfMark.attachTag(tag);
+      checkState(stream != null, "Not started");
+      checkArgument(numMessages >= 0, "Number requested must be non-negative");
+      stream.request(numMessages);
+    }
   }
 
   @Override
   public void cancel(@Nullable String message, @Nullable Throwable cause) {
+    try (TaskCloseable ignore = PerfMark.traceTask("ClientCall.cancel")) {
+      PerfMark.attachTag(tag);
+      cancelInternal(message, cause);
+    }
+  }
+
+  private void cancelInternal(@Nullable String message, @Nullable Throwable cause) {
     if (message == null && cause == null) {
       cause = new CancellationException("Cancelled without a message or cause");
       log.log(Level.WARNING, "Cancelling without a message or cause is suboptimal", cause);
@@ -357,6 +472,8 @@ public void cancel(@Nullable String message, @Nullable Throwable cause) {
         Status status = Status.CANCELLED;
         if (message != null) {
           status = status.withDescription(message);
+        } else {
+          status = status.withDescription("Call cancelled without message");
         }
         if (cause != null) {
           status = status.withCause(cause);
@@ -364,31 +481,55 @@ public void cancel(@Nullable String message, @Nullable Throwable cause) {
         stream.cancel(status);
       }
     } finally {
-      removeContextListenerAndCancelDeadlineFuture();
+      // start() might not have been called
+      if (cancellationHandler != null) {
+        cancellationHandler.tearDown();
+      }
     }
   }
 
   @Override
   public void halfClose() {
-    Preconditions.checkState(stream != null, "Not started");
-    Preconditions.checkState(!cancelCalled, "call was cancelled");
-    Preconditions.checkState(!halfCloseCalled, "call already half-closed");
+    try (TaskCloseable ignore = PerfMark.traceTask("ClientCall.halfClose")) {
+      PerfMark.attachTag(tag);
+      halfCloseInternal();
+    }
+  }
+
+  private void halfCloseInternal() {
+    checkState(stream != null, "Not started");
+    checkState(!cancelCalled, "call was cancelled");
+    checkState(!halfCloseCalled, "call already half-closed");
     halfCloseCalled = true;
     stream.halfClose();
   }
 
   @Override
   public void sendMessage(ReqT message) {
-    Preconditions.checkState(stream != null, "Not started");
-    Preconditions.checkState(!cancelCalled, "call was cancelled");
-    Preconditions.checkState(!halfCloseCalled, "call was half-closed");
+    try (TaskCloseable ignore = PerfMark.traceTask("ClientCall.sendMessage")) {
+      PerfMark.attachTag(tag);
+      sendMessageInternal(message);
+    }
+  }
+
+  private void sendMessageInternal(ReqT message) {
+    checkState(stream != null, "Not started");
+    checkState(!cancelCalled, "call was cancelled");
+    checkState(!halfCloseCalled, "call was half-closed");
     try {
-      // TODO(notcarl): Find out if messageIs needs to be closed.
-      InputStream messageIs = method.streamRequest(message);
-      stream.writeMessage(messageIs);
-    } catch (Throwable e) {
+      if (stream instanceof RetriableStream) {
+        @SuppressWarnings("unchecked")
+        RetriableStream<ReqT> retriableStream = (RetriableStream<ReqT>) stream;
+        retriableStream.sendMessage(message);
+      } else {
+        stream.writeMessage(method.streamRequest(message));
+      }
+    } catch (RuntimeException e) {
       stream.cancel(Status.CANCELLED.withCause(e).withDescription("Failed to stream message"));
       return;
+    } catch (Error e) {
+      stream.cancel(Status.CANCELLED.withDescription("Client sendMessage() failed with Error"));
+      throw e;
     }
     // For unary requests, we don't flush since we know that halfClose should be coming soon. This
     // allows us to piggy-back the END_STREAM=true on the last message frame without opening the
@@ -406,6 +547,9 @@ public void setMessageCompression(boolean enabled) {
 
   @Override
   public boolean isReady() {
+    if (halfCloseCalled) {
+      return false;
+    }
     return stream.isReady();
   }
 
@@ -418,126 +562,179 @@ public Attributes getAttributes() {
   }
 
   private void closeObserver(Listener<RespT> observer, Status status, Metadata trailers) {
-    statsTraceCtx.callEnded(status);
-    observer.onClose(status, trailers);
+    try {
+      observer.onClose(status, trailers);
+    } catch (RuntimeException ex) {
+      log.log(Level.WARNING, "Exception thrown by onClose() in ClientCall", ex);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("method", method).toString();
   }
 
   private class ClientStreamListenerImpl implements ClientStreamListener {
     private final Listener<RespT> observer;
-    private boolean closed;
+    private Status exceptionStatus;
 
     public ClientStreamListenerImpl(Listener<RespT> observer) {
-      this.observer = Preconditions.checkNotNull(observer, "observer");
+      this.observer = checkNotNull(observer, "observer");
+    }
+
+    /**
+     * Cancels call and schedules onClose() notification. May only be called from the application
+     * thread.
+     */
+    private void exceptionThrown(Status status) {
+      // Since each RPC can have its own executor, we can only call onClose() when we are sure there
+      // will be no further callbacks. We set the status here and overwrite the onClose() details
+      // when it arrives.
+      exceptionStatus = status;
+      stream.cancel(status);
     }
 
     @Override
     public void headersRead(final Metadata headers) {
-      Decompressor decompressor = Codec.Identity.NONE;
-      if (headers.containsKey(MESSAGE_ENCODING_KEY)) {
-        String encoding = headers.get(MESSAGE_ENCODING_KEY);
-        decompressor = decompressorRegistry.lookupDecompressor(encoding);
-        if (decompressor == null) {
-          stream.cancel(Status.INTERNAL.withDescription(
-              String.format("Can't find decompressor for %s", encoding)));
-          return;
-        }
-      }
-      stream.setDecompressor(decompressor);
+      try (TaskCloseable ignore = PerfMark.traceTask("ClientStreamListener.headersRead")) {
+        PerfMark.attachTag(tag);
+        final Link link = PerfMark.linkOut();
+        final class HeadersRead extends ContextRunnable {
+          HeadersRead() {
+            super(context);
+          }
 
-      class HeadersRead extends ContextRunnable {
-        HeadersRead() {
-          super(context);
-        }
+          @Override
+          public void runInContext() {
+            try (TaskCloseable ignore = PerfMark.traceTask("ClientCall$Listener.headersRead")) {
+              PerfMark.attachTag(tag);
+              PerfMark.linkIn(link);
+              runInternal();
+            }
+          }
 
-        @Override
-        public final void runInContext() {
-          try {
-            if (closed) {
+          private void runInternal() {
+            if (exceptionStatus != null) {
               return;
             }
-            observer.onHeaders(headers);
-          } catch (Throwable t) {
-            Status status =
-                Status.CANCELLED.withCause(t).withDescription("Failed to read headers");
-            stream.cancel(status);
-            close(status, new Metadata());
+            try {
+              observer.onHeaders(headers);
+            } catch (Throwable t) {
+              exceptionThrown(
+                  Status.CANCELLED.withCause(t).withDescription("Failed to read headers"));
+            }
           }
         }
-      }
 
-      callExecutor.execute(new HeadersRead());
+        callExecutor.execute(new HeadersRead());
+      }
     }
 
     @Override
-    public void messageRead(final InputStream message) {
-      class MessageRead extends ContextRunnable {
-        MessageRead() {
-          super(context);
-        }
+    public void messagesAvailable(final MessageProducer producer) {
+      try (TaskCloseable ignore = PerfMark.traceTask("ClientStreamListener.messagesAvailable")) {
+        PerfMark.attachTag(tag);
+        final Link link = PerfMark.linkOut();
+        final class MessagesAvailable extends ContextRunnable {
+          MessagesAvailable() {
+            super(context);
+          }
 
-        @Override
-        public final void runInContext() {
-          try {
-            if (closed) {
+          @Override
+          public void runInContext() {
+            try (TaskCloseable ignore =
+                     PerfMark.traceTask("ClientCall$Listener.messagesAvailable")) {
+              PerfMark.attachTag(tag);
+              PerfMark.linkIn(link);
+              runInternal();
+            }
+          }
+
+          private void runInternal() {
+            if (exceptionStatus != null) {
+              GrpcUtil.closeQuietly(producer);
               return;
             }
             try {
-              observer.onMessage(method.parseResponse(message));
-            } finally {
-              message.close();
+              InputStream message;
+              while ((message = producer.next()) != null) {
+                try {
+                  observer.onMessage(method.parseResponse(message));
+                } catch (Throwable t) {
+                  GrpcUtil.closeQuietly(message);
+                  throw t;
+                }
+                message.close();
+              }
+            } catch (Throwable t) {
+              GrpcUtil.closeQuietly(producer);
+              exceptionThrown(
+                  Status.CANCELLED.withCause(t).withDescription("Failed to read message."));
             }
-          } catch (Throwable t) {
-            Status status =
-                Status.CANCELLED.withCause(t).withDescription("Failed to read message.");
-            stream.cancel(status);
-            close(status, new Metadata());
           }
         }
-      }
 
-      callExecutor.execute(new MessageRead());
+        callExecutor.execute(new MessagesAvailable());
+      }
     }
 
-    /**
-     * Must be called from application thread.
-     */
-    private void close(Status status, Metadata trailers) {
-      closed = true;
-      cancelListenersShouldBeRemoved = true;
-      try {
-        closeObserver(observer, status, trailers);
-      } finally {
-        removeContextListenerAndCancelDeadlineFuture();
+    @Override
+    public void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {
+      try (TaskCloseable ignore = PerfMark.traceTask("ClientStreamListener.closed")) {
+        PerfMark.attachTag(tag);
+        closedInternal(status, rpcProgress, trailers);
       }
     }
 
-    @Override
-    public void closed(Status status, Metadata trailers) {
+    private void closedInternal(
+        Status status, @SuppressWarnings("unused") RpcProgress rpcProgress, Metadata trailers) {
       Deadline deadline = effectiveDeadline();
       if (status.getCode() == Status.Code.CANCELLED && deadline != null) {
         // When the server's deadline expires, it can only reset the stream with CANCEL and no
         // description. Since our timer may be delayed in firing, we double-check the deadline and
         // turn the failure into the likely more helpful DEADLINE_EXCEEDED status.
         if (deadline.isExpired()) {
-          status = DEADLINE_EXCEEDED;
+          status = cancellationHandler.formatDeadlineExceededStatus();
           // Replace trailers to prevent mixing sources of status and trailers.
           trailers = new Metadata();
         }
       }
       final Status savedStatus = status;
       final Metadata savedTrailers = trailers;
-      class StreamClosed extends ContextRunnable {
+      final Link link = PerfMark.linkOut();
+      final class StreamClosed extends ContextRunnable {
         StreamClosed() {
           super(context);
         }
 
         @Override
-        public final void runInContext() {
-          if (closed) {
-            // We intentionally don't keep the status or metadata from the server.
-            return;
+        public void runInContext() {
+          try (TaskCloseable ignore = PerfMark.traceTask("ClientCall$Listener.onClose")) {
+            PerfMark.attachTag(tag);
+            PerfMark.linkIn(link);
+            runInternal();
+          }
+        }
+
+        private void runInternal() {
+          cancellationHandler.tearDown();
+          Status status = savedStatus;
+          Metadata trailers = savedTrailers;
+          if (exceptionStatus != null) {
+            // Ideally exceptionStatus == savedStatus, as exceptionStatus was passed to cancel().
+            // However the cancel is racy and this closed() may have already been queued when the
+            // cancellation occurred. Since other calls like onMessage() will throw away data if
+            // exceptionStatus != null, it is semantically essential that we _not_ use a status
+            // provided by the server.
+            status = exceptionStatus;
+            // Replace trailers to prevent mixing sources of status and trailers.
+            trailers = new Metadata();
+          }
+          try {
+            closeObserver(observer, status, trailers);
+          } finally {
+            channelCallsTracer.reportCallEnded(status.isOk());
           }
-          close(savedStatus, savedTrailers);
         }
       }
 
@@ -546,25 +743,42 @@ public final void runInContext() {
 
     @Override
     public void onReady() {
-      class StreamOnReady extends ContextRunnable {
-        StreamOnReady() {
-          super(context);
-        }
+      if (method.getType().clientSendsOneMessage()) {
+        return;
+      }
+      try (TaskCloseable ignore = PerfMark.traceTask("ClientStreamListener.onReady")) {
+        PerfMark.attachTag(tag);
+        final Link link = PerfMark.linkOut();
 
-        @Override
-        public final void runInContext() {
-          try {
-            observer.onReady();
-          } catch (Throwable t) {
-            Status status =
-                Status.CANCELLED.withCause(t).withDescription("Failed to call onReady.");
-            stream.cancel(status);
-            close(status, new Metadata());
+        final class StreamOnReady extends ContextRunnable {
+          StreamOnReady() {
+            super(context);
+          }
+
+          @Override
+          public void runInContext() {
+            try (TaskCloseable ignore = PerfMark.traceTask("ClientCall$Listener.onReady")) {
+              PerfMark.attachTag(tag);
+              PerfMark.linkIn(link);
+              runInternal();
+            }
+          }
+
+          private void runInternal() {
+            if (exceptionStatus != null) {
+              return;
+            }
+            try {
+              observer.onReady();
+            } catch (Throwable t) {
+              exceptionThrown(
+                  Status.CANCELLED.withCause(t).withDescription("Failed to call onReady."));
+            }
           }
         }
-      }
 
-      callExecutor.execute(new StreamOnReady());
+        callExecutor.execute(new StreamOnReady());
+      }
     }
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/ClientStream.java b/core/src/main/java/io/grpc/internal/ClientStream.java
index 033dbaa9a6e..7dba4d70871 100644
--- a/core/src/main/java/io/grpc/internal/ClientStream.java
+++ b/core/src/main/java/io/grpc/internal/ClientStream.java
@@ -1,38 +1,26 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import io.grpc.Attributes;
+import io.grpc.Deadline;
+import io.grpc.DecompressorRegistry;
 import io.grpc.Status;
+import javax.annotation.Nonnull;
 
 /**
  * Extension of {@link Stream} to support client-side termination semantics.
@@ -66,6 +54,20 @@ public interface ClientStream extends Stream {
    */
   void setAuthority(String authority);
 
+  /**
+   * Enables full-stream decompression, allowing the client stream to use {@link
+   * GzipInflatingBuffer} to decode inbound GZIP compressed streams.
+   */
+  void setFullStreamDecompression(boolean fullStreamDecompression);
+
+  /**
+   * Sets the registry to find a decompressor for the framer. May only be called before {@link
+   * #start}. If the transport does not support compression, this may do nothing.
+   *
+   * @param decompressorRegistry the registry of decompressors for decoding responses
+   */
+  void setDecompressorRegistry(DecompressorRegistry decompressorRegistry);
+
   /**
    * Starts stream. This method may only be called once.  It is safe to do latent initialization of
    * the stream up until {@link #start} is called.
@@ -87,7 +89,20 @@ public interface ClientStream extends Stream {
   void setMaxOutboundMessageSize(int maxSize);
 
   /**
-   * Attributes that the stream holds at the current moment.
+   * Sets the effective deadline of the RPC.
+   */
+  void setDeadline(@Nonnull Deadline deadline);
+
+  /**
+   * Attributes that the stream holds at the current moment.  Thread-safe and can be called at any
+   * time, although some attributes are there only after a certain point.
    */
   Attributes getAttributes();
+
+  /**
+   * Append information that will be included in the locally generated DEADLINE_EXCEEDED errors to
+   * the given {@link InsightBuilder}, in order to tell the user about the state of the stream so
+   * that they can better diagnose the cause of the error.
+   */
+  void appendTimeoutInsight(InsightBuilder insight);
 }
diff --git a/core/src/main/java/io/grpc/internal/ClientStreamListener.java b/core/src/main/java/io/grpc/internal/ClientStreamListener.java
index efb5407b512..85a0626d426 100644
--- a/core/src/main/java/io/grpc/internal/ClientStreamListener.java
+++ b/core/src/main/java/io/grpc/internal/ClientStreamListener.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -40,7 +25,7 @@ public interface ClientStreamListener extends StreamListener {
    * Called upon receiving all header information from the remote end-point. Note that transports
    * are not required to call this method if no header information is received, this would occur
    * when a stream immediately terminates with an error and only
-   * {@link #closed(io.grpc.Status, Metadata)} is called.
+   * {@link #closed(io.grpc.Status, RpcProgress, Metadata)} is called.
    *
    * <p>This method should return quickly, as the same thread may be used to process other streams.
    *
@@ -58,7 +43,31 @@ public interface ClientStreamListener extends StreamListener {
    * <p>This method should return quickly, as the same thread may be used to process other streams.
    *
    * @param status details about the remote closure
+   * @param rpcProgress RPC progress when client stream listener is closed
    * @param trailers trailing metadata
    */
-  void closed(Status status, Metadata trailers);
+  void closed(Status status, RpcProgress rpcProgress, Metadata trailers);
+
+  /**
+   * The progress of the RPC when client stream listener is closed.
+   */
+  enum RpcProgress {
+    /**
+     * The RPC may have been processed by the server.
+     */
+    PROCESSED,
+    /**
+     * Some part of the RPC may have been sent, but the server has guaranteed it didn't process any
+     * part of the RPC.
+     */
+    REFUSED,
+    /**
+     * The RPC is dropped (by load balancer).
+     */
+    DROPPED,
+    /**
+     * The stream is closed even before anything leaves the client.
+     */
+    MISCARRIED
+  }
 }
diff --git a/core/src/main/java/io/grpc/internal/ClientTransport.java b/core/src/main/java/io/grpc/internal/ClientTransport.java
index 17f3729e7c3..fd0f30b8bf1 100644
--- a/core/src/main/java/io/grpc/internal/ClientTransport.java
+++ b/core/src/main/java/io/grpc/internal/ClientTransport.java
@@ -1,39 +1,28 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
+import io.grpc.Status;
 import java.util.concurrent.Executor;
 import javax.annotation.concurrent.ThreadSafe;
 
@@ -44,7 +33,7 @@
  * are expected to execute quickly.
  */
 @ThreadSafe
-public interface ClientTransport {
+public interface ClientTransport extends InternalInstrumented<SocketStats> {
 
   /**
    * Creates a new stream for sending messages to a remote end-point.
@@ -59,21 +48,21 @@ public interface ClientTransport {
    * @param method the descriptor of the remote method to be called for this stream.
    * @param headers to send at the beginning of the call
    * @param callOptions runtime options of the call
-   * @param statsTraceCtx carries stats and tracing information
+   * @param tracers a non-empty array of tracers. The last element in it is reserved to be set by
+   *        the load balancer's pick result and otherwise is a no-op tracer.
    * @return the newly created stream.
    */
   // TODO(nmittler): Consider also throwing for stopping.
-  ClientStream newStream(MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
-      StatsTraceContext statsTraceCtx);
-
-  // TODO(zdapeng): Remove two-argument version in favor of four-argument overload.
-  ClientStream newStream(MethodDescriptor<?, ?> method, Metadata headers);
+  ClientStream newStream(
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+      // Using array for tracers instead of a list or composition for better performance.
+      ClientStreamTracer[] tracers);
 
   /**
    * Pings a remote endpoint. When an acknowledgement is received, the given callback will be
    * invoked using the given executor.
    *
-   * <p>Pings are not necessarily sent to the same endpont, thus a successful ping only means at
+   * <p>Pings are not necessarily sent to the same endpoint, thus a successful ping only means at
    * least one endpoint responded, but doesn't imply the availability of other endpoints (if there
    * is any).
    *
@@ -102,6 +91,6 @@ interface PingCallback {
      *
      * @param cause the cause of the ping failure
      */
-    void onFailure(Throwable cause);
+    void onFailure(Status cause);
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/ClientTransportFactory.java b/core/src/main/java/io/grpc/internal/ClientTransportFactory.java
index 75c22e3b7db..6c10ced4652 100644
--- a/core/src/main/java/io/grpc/internal/ClientTransportFactory.java
+++ b/core/src/main/java/io/grpc/internal/ClientTransportFactory.java
@@ -1,50 +1,69 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import com.google.common.base.Objects;
+import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.Attributes;
+import io.grpc.CallCredentials;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.HttpConnectProxiedSocketAddress;
 import java.io.Closeable;
 import java.net.SocketAddress;
+import java.util.Collection;
+import java.util.concurrent.ScheduledExecutorService;
 import javax.annotation.Nullable;
 
 /** Pre-configured factory for creating {@link ConnectionClientTransport} instances. */
 public interface ClientTransportFactory extends Closeable {
   /**
-   * Creates an unstarted transport for exclusive use.
+   * Creates an unstarted transport for exclusive use. Ownership of {@code options} is passed to the
+   * callee; the caller should not reuse or read from the options after this method is called.
    *
    * @param serverAddress the address that the transport is connected to
-   * @param authority the HTTP/2 authority of the server
+   * @param options additional configuration
+   * @param channelLogger logger for the transport.
+   */
+  ConnectionClientTransport newClientTransport(
+      SocketAddress serverAddress,
+      ClientTransportOptions options,
+      ChannelLogger channelLogger);
+
+  /**
+   * Returns an executor for scheduling provided by the transport. The service should be configured
+   * to allow cancelled scheduled runnables to be GCed.
+   *
+   * <p>The executor should not be used after the factory has been closed. The caller should ensure
+   * any outstanding tasks are cancelled before the factory is closed. However, it is a
+   * <a href="https://github.com/grpc/grpc-java/issues/1981">known issue</a> that ClientCallImpl may
+   * use this executor after close, so implementations should not go out of their way to prevent
+   * usage.
+   */
+  ScheduledExecutorService getScheduledExecutorService();
+
+  /**
+   * Swaps to a new ChannelCredentials with all other settings unchanged. Returns null if the
+   * ChannelCredentials is not supported by the current ClientTransportFactory settings.
    */
-  ConnectionClientTransport newClientTransport(SocketAddress serverAddress, String authority,
-      @Nullable String userAgent);
+  @CheckReturnValue
+  @Nullable
+  SwapChannelCredentialsResult swapChannelCredentials(ChannelCredentials channelCreds);
 
   /**
    * Releases any resources.
@@ -54,4 +73,102 @@ ConnectionClientTransport newClientTransport(SocketAddress serverAddress, String
    */
   @Override
   void close();
+
+  /**
+   * Returns the {@link SocketAddress} types this transport supports.
+   */
+  Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes();
+
+  /**
+   * Options passed to {@link #newClientTransport}. Although it is safe to save this object if
+   * received, it is generally expected that the useful fields are copied and then the options
+   * object is discarded. This allows using {@code final} for those fields as well as avoids
+   * retaining unused objects contained in the options.
+   */
+  final class ClientTransportOptions {
+    private ChannelLogger channelLogger;
+    private String authority = "unknown-authority";
+    private Attributes eagAttributes = Attributes.EMPTY;
+    @Nullable private String userAgent;
+    @Nullable private HttpConnectProxiedSocketAddress connectProxiedSocketAddr;
+
+    public ChannelLogger getChannelLogger() {
+      return channelLogger;
+    }
+
+    public ClientTransportOptions setChannelLogger(ChannelLogger channelLogger) {
+      this.channelLogger = channelLogger;
+      return this;
+    }
+
+    public String getAuthority() {
+      return authority;
+    }
+
+    /** Sets the non-null authority. */
+    public ClientTransportOptions setAuthority(String authority) {
+      this.authority = Preconditions.checkNotNull(authority, "authority");
+      return this;
+    }
+
+    public Attributes getEagAttributes() {
+      return eagAttributes;
+    }
+
+    /** Sets the non-null EquivalentAddressGroup's attributes. */
+    public ClientTransportOptions setEagAttributes(Attributes eagAttributes) {
+      Preconditions.checkNotNull(eagAttributes, "eagAttributes");
+      this.eagAttributes = eagAttributes;
+      return this;
+    }
+
+    @Nullable
+    public String getUserAgent() {
+      return userAgent;
+    }
+
+    public ClientTransportOptions setUserAgent(@Nullable String userAgent) {
+      this.userAgent = userAgent;
+      return this;
+    }
+
+    @Nullable
+    public HttpConnectProxiedSocketAddress getHttpConnectProxiedSocketAddress() {
+      return connectProxiedSocketAddr;
+    }
+
+    public ClientTransportOptions setHttpConnectProxiedSocketAddress(
+        @Nullable HttpConnectProxiedSocketAddress connectProxiedSocketAddr) {
+      this.connectProxiedSocketAddr = connectProxiedSocketAddr;
+      return this;
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(authority, eagAttributes, userAgent, connectProxiedSocketAddr);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (!(o instanceof ClientTransportOptions)) {
+        return false;
+      }
+      ClientTransportOptions that = (ClientTransportOptions) o;
+      return this.authority.equals(that.authority)
+          && this.eagAttributes.equals(that.eagAttributes)
+          && Objects.equal(this.userAgent, that.userAgent)
+          && Objects.equal(this.connectProxiedSocketAddr, that.connectProxiedSocketAddr);
+    }
+  }
+
+  final class SwapChannelCredentialsResult {
+    final ClientTransportFactory transportFactory;
+    @Nullable final CallCredentials callCredentials;
+
+    public SwapChannelCredentialsResult(
+        ClientTransportFactory transportFactory, @Nullable CallCredentials callCredentials) {
+      this.transportFactory = Preconditions.checkNotNull(transportFactory, "transportFactory");
+      this.callCredentials = callCredentials;
+    }
+  }
 }
diff --git a/core/src/main/java/io/grpc/internal/CompositeReadableBuffer.java b/core/src/main/java/io/grpc/internal/CompositeReadableBuffer.java
index 8e5bf061634..6cedb2caee9 100644
--- a/core/src/main/java/io/grpc/internal/CompositeReadableBuffer.java
+++ b/core/src/main/java/io/grpc/internal/CompositeReadableBuffer.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -34,8 +19,10 @@
 import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.ByteBuffer;
+import java.nio.InvalidMarkException;
 import java.util.ArrayDeque;
-import java.util.Queue;
+import java.util.Deque;
+import javax.annotation.Nullable;
 
 /**
  * A {@link ReadableBuffer} that is composed of 0 or more {@link ReadableBuffer}s. This provides a
@@ -47,8 +34,18 @@
  */
 public class CompositeReadableBuffer extends AbstractReadableBuffer {
 
+  private final Deque<ReadableBuffer> readableBuffers;
+  private Deque<ReadableBuffer> rewindableBuffers;
   private int readableBytes;
-  private final Queue<ReadableBuffer> buffers = new ArrayDeque<ReadableBuffer>();
+  private boolean marked;
+
+  public CompositeReadableBuffer(int initialCapacity) {
+    readableBuffers = new ArrayDeque<>(initialCapacity);
+  }
+
+  public CompositeReadableBuffer() {
+    readableBuffers = new ArrayDeque<>();
+  }
 
   /**
    * Adds a new {@link ReadableBuffer} at the end of the buffer list. After a buffer is added, it is
@@ -57,16 +54,24 @@ public class CompositeReadableBuffer extends AbstractReadableBuffer {
    * this {@code CompositeBuffer}.
    */
   public void addBuffer(ReadableBuffer buffer) {
+    boolean markHead = marked && readableBuffers.isEmpty();
+    enqueueBuffer(buffer);
+    if (markHead) {
+      readableBuffers.peek().mark();
+    }
+  }
+
+  private void enqueueBuffer(ReadableBuffer buffer) {
     if (!(buffer instanceof CompositeReadableBuffer)) {
-      buffers.add(buffer);
+      readableBuffers.add(buffer);
       readableBytes += buffer.readableBytes();
       return;
     }
 
     CompositeReadableBuffer compositeBuffer = (CompositeReadableBuffer) buffer;
-    while (!compositeBuffer.buffers.isEmpty()) {
-      ReadableBuffer subBuffer = compositeBuffer.buffers.remove();
-      buffers.add(subBuffer);
+    while (!compositeBuffer.readableBuffers.isEmpty()) {
+      ReadableBuffer subBuffer = compositeBuffer.readableBuffers.remove();
+      readableBuffers.add(subBuffer);
     }
     readableBytes += compositeBuffer.readableBytes;
     compositeBuffer.readableBytes = 0;
@@ -78,99 +83,174 @@ public int readableBytes() {
     return readableBytes;
   }
 
+  private static final NoThrowReadOperation<Void> UBYTE_OP =
+      new NoThrowReadOperation<Void>() {
+        @Override
+        public int read(ReadableBuffer buffer, int length, Void unused, int value) {
+          return buffer.readUnsignedByte();
+        }
+      };
+
   @Override
   public int readUnsignedByte() {
-    ReadOperation op = new ReadOperation() {
-      @Override
-      int readInternal(ReadableBuffer buffer, int length) {
-        return buffer.readUnsignedByte();
-      }
-    };
-    execute(op, 1);
-    return op.value;
+    return executeNoThrow(UBYTE_OP, 1, null, 0);
   }
 
+  private static final NoThrowReadOperation<Void> SKIP_OP =
+      new NoThrowReadOperation<Void>() {
+        @Override
+        public int read(ReadableBuffer buffer, int length, Void unused, int unused2) {
+          buffer.skipBytes(length);
+          return 0;
+        }
+      };
+
   @Override
   public void skipBytes(int length) {
-    execute(new ReadOperation() {
-      @Override
-      public int readInternal(ReadableBuffer buffer, int length) {
-        buffer.skipBytes(length);
-        return 0;
-      }
-    }, length);
+    executeNoThrow(SKIP_OP, length, null, 0);
   }
 
+  private static final NoThrowReadOperation<byte[]> BYTE_ARRAY_OP =
+      new NoThrowReadOperation<byte[]>() {
+        @Override
+        public int read(ReadableBuffer buffer, int length, byte[] dest, int offset) {
+          buffer.readBytes(dest, offset, length);
+          return offset + length;
+        }
+      };
+
+  private static final ReadOperation<OutputStream> STREAM_OP =
+      new ReadOperation<OutputStream>() {
+        @Override
+        public int read(ReadableBuffer buffer, int length, OutputStream dest, int unused)
+            throws IOException {
+          buffer.readBytes(dest, length);
+          return 0;
+        }
+      };
+
   @Override
-  public void readBytes(final byte[] dest, final int destOffset, int length) {
-    execute(new ReadOperation() {
-      int currentOffset = destOffset;
-      @Override
-      public int readInternal(ReadableBuffer buffer, int length) {
-        buffer.readBytes(dest, currentOffset, length);
-        currentOffset += length;
-        return 0;
-      }
-    }, length);
+  public void readBytes(byte[] dest, int destOffset, int length) {
+    executeNoThrow(BYTE_ARRAY_OP, length, dest, destOffset);
+  }
+
+  @Override
+  public void readBytes(OutputStream dest, int length) throws IOException {
+    execute(STREAM_OP, length, dest, 0);
   }
 
   @Override
-  public void readBytes(final ByteBuffer dest) {
-    execute(new ReadOperation() {
-      @Override
-      public int readInternal(ReadableBuffer buffer, int length) {
-        // Change the limit so that only lengthToCopy bytes are available.
-        int prevLimit = dest.limit();
-        dest.limit(dest.position() + length);
-
-        // Write the bytes and restore the original limit.
-        buffer.readBytes(dest);
-        dest.limit(prevLimit);
-        return 0;
+  public ReadableBuffer readBytes(int length) {
+    if (length <= 0) {
+      return ReadableBuffers.empty();
+    }
+    checkReadable(length);
+    readableBytes -= length;
+
+    ReadableBuffer newBuffer = null;
+    CompositeReadableBuffer newComposite = null;
+    do {
+      ReadableBuffer buffer = readableBuffers.peek();
+      int readable = buffer.readableBytes();
+      ReadableBuffer readBuffer;
+      if (readable > length) {
+        readBuffer = buffer.readBytes(length);
+        length = 0;
+      } else {
+        if (marked) {
+          readBuffer = buffer.readBytes(readable);
+          advanceBuffer();
+        } else {
+          readBuffer = readableBuffers.poll();
+        }
+        length -= readable;
+      }
+      if (newBuffer == null) {
+        newBuffer = readBuffer;
+      } else {
+        if (newComposite == null) {
+          newComposite = new CompositeReadableBuffer(
+              length == 0 ? 2 : Math.min(readableBuffers.size() + 2, 16));
+          newComposite.addBuffer(newBuffer);
+          newBuffer = newComposite;
+        }
+        newComposite.addBuffer(readBuffer);
       }
-    }, dest.remaining());
+    } while (length > 0);
+    return newBuffer;
   }
 
   @Override
-  public void readBytes(final OutputStream dest, int length) throws IOException {
-    ReadOperation op = new ReadOperation() {
-      @Override
-      public int readInternal(ReadableBuffer buffer, int length) throws IOException {
-        buffer.readBytes(dest, length);
-        return 0;
+  public boolean markSupported() {
+    for (ReadableBuffer buffer : readableBuffers) {
+      if (!buffer.markSupported()) {
+        return false;
       }
-    };
-    execute(op, length);
+    }
+    return true;
+  }
 
-    // If an exception occurred, throw it.
-    if (op.isError()) {
-      throw op.ex;
+  @Override
+  public void mark() {
+    if (rewindableBuffers == null) {
+      rewindableBuffers = new ArrayDeque<>(Math.min(readableBuffers.size(), 16));
+    }
+    while (!rewindableBuffers.isEmpty()) {
+      rewindableBuffers.remove().close();
+    }
+    marked = true;
+    ReadableBuffer buffer = readableBuffers.peek();
+    if (buffer != null) {
+      buffer.mark();
     }
   }
 
   @Override
-  public CompositeReadableBuffer readBytes(int length) {
-    checkReadable(length);
-    readableBytes -= length;
+  public void reset() {
+    if (!marked) {
+      throw new InvalidMarkException();
+    }
+    ReadableBuffer buffer;
+    if ((buffer = readableBuffers.peek()) != null) {
+      int currentRemain = buffer.readableBytes();
+      buffer.reset();
+      readableBytes += (buffer.readableBytes() - currentRemain);
+    }
+    while ((buffer = rewindableBuffers.pollLast()) != null) {
+      buffer.reset();
+      readableBuffers.addFirst(buffer);
+      readableBytes += buffer.readableBytes();
+    }
+  }
 
-    CompositeReadableBuffer newBuffer = new CompositeReadableBuffer();
-    while (length > 0) {
-      ReadableBuffer buffer = buffers.peek();
-      if (buffer.readableBytes() > length) {
-        newBuffer.addBuffer(buffer.readBytes(length));
-        length = 0;
-      } else {
-        newBuffer.addBuffer(buffers.poll());
-        length -= buffer.readableBytes();
+  @Override
+  public boolean byteBufferSupported() {
+    for (ReadableBuffer buffer : readableBuffers) {
+      if (!buffer.byteBufferSupported()) {
+        return false;
       }
     }
-    return newBuffer;
+    return true;
+  }
+
+  @Nullable
+  @Override
+  public ByteBuffer getByteBuffer() {
+    if (readableBuffers.isEmpty()) {
+      return null;
+    }
+    return readableBuffers.peek().getByteBuffer();
   }
 
   @Override
   public void close() {
-    while (!buffers.isEmpty()) {
-      buffers.remove().close();
+    while (!readableBuffers.isEmpty()) {
+      readableBuffers.remove().close();
+    }
+    if (rewindableBuffers != null) {
+      while (!rewindableBuffers.isEmpty()) {
+        rewindableBuffers.remove().close();
+      }
     }
   }
 
@@ -178,18 +258,19 @@ public void close() {
    * Executes the given {@link ReadOperation} against the {@link ReadableBuffer}s required to
    * satisfy the requested {@code length}.
    */
-  private void execute(ReadOperation op, int length) {
+  private <T> int execute(ReadOperation<T> op, int length, T dest, int value) throws IOException {
     checkReadable(length);
 
-    for (; length > 0 && !buffers.isEmpty(); advanceBufferIfNecessary()) {
-      ReadableBuffer buffer = buffers.peek();
+    if (!readableBuffers.isEmpty()) {
+      advanceBufferIfNecessary();
+    }
+
+    for (; length > 0 && !readableBuffers.isEmpty(); advanceBufferIfNecessary()) {
+      ReadableBuffer buffer = readableBuffers.peek();
       int lengthToCopy = Math.min(length, buffer.readableBytes());
 
       // Perform the read operation for this buffer.
-      op.read(buffer, lengthToCopy);
-      if (op.isError()) {
-        return;
-      }
+      value = op.read(buffer, lengthToCopy, dest, value);
 
       length -= lengthToCopy;
       readableBytes -= lengthToCopy;
@@ -199,45 +280,61 @@ private void execute(ReadOperation op, int length) {
       // Should never get here.
       throw new AssertionError("Failed executing read operation");
     }
+
+    return value;
+  }
+
+  private <T> int executeNoThrow(NoThrowReadOperation<T> op, int length, T dest, int value) {
+    try {
+      return execute(op, length, dest, value);
+    } catch (IOException e) {
+      throw new AssertionError(e); // shouldn't happen
+    }
   }
 
   /**
    * If the current buffer is exhausted, removes and closes it.
    */
   private void advanceBufferIfNecessary() {
-    ReadableBuffer buffer = buffers.peek();
+    ReadableBuffer buffer = readableBuffers.peek();
     if (buffer.readableBytes() == 0) {
-      buffers.remove().close();
+      advanceBuffer();
     }
   }
 
   /**
-   * A simple read operation to perform on a single {@link ReadableBuffer}. All state management for
-   * the buffers is done by {@link CompositeReadableBuffer#execute(ReadOperation, int)}.
+   * Removes one buffer from the front and closes it.
    */
-  private abstract static class ReadOperation {
-    /**
-     * Only used by {@link CompositeReadableBuffer#readUnsignedByte()}.
-     */
-    int value;
-
-    /**
-     * Only used by {@link CompositeReadableBuffer#readBytes(OutputStream, int)}.
-     */
-    IOException ex;
-
-    final void read(ReadableBuffer buffer, int length) {
-      try {
-        value = readInternal(buffer, length);
-      } catch (IOException e) {
-        ex = e;
+  private void advanceBuffer() {
+    if (marked) {
+      rewindableBuffers.add(readableBuffers.remove());
+      ReadableBuffer next = readableBuffers.peek();
+      if (next != null) {
+        next.mark();
       }
+    } else {
+      readableBuffers.remove().close();
     }
+  }
 
-    final boolean isError() {
-      return ex != null;
-    }
+  /**
+   * A simple read operation to perform on a single {@link ReadableBuffer}.
+   * All state management for the buffers is done by
+   * {@link CompositeReadableBuffer#execute(ReadOperation, int, Object, int)}.
+   */
+  private interface ReadOperation<T> {
+    /**
+     * This method can also be used to simultaneously perform operation-specific int-valued
+     * aggregation over the sequence of buffers in a {@link CompositeReadableBuffer}.
+     * {@code value} is the return value from the prior buffer, or the "initial" value passed
+     * to {@code execute()} in the case of the first buffer. {@code execute()} returns the value
+     * returned by the operation called on the last buffer.
+     */
+    int read(ReadableBuffer buffer, int length, T dest, int value) throws IOException;
+  }
 
-    abstract int readInternal(ReadableBuffer buffer, int length) throws IOException;
+  private interface NoThrowReadOperation<T> extends ReadOperation<T> {
+    @Override
+    int read(ReadableBuffer buffer, int length, T dest, int value);
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/ConcurrentTimeProvider.java b/core/src/main/java/io/grpc/internal/ConcurrentTimeProvider.java
new file mode 100644
index 00000000000..c82a68222b4
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ConcurrentTimeProvider.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2024 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.internal;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * {@link ConcurrentTimeProvider} resolves ConcurrentTimeProvider which implements
+ * {@link TimeProvider}.
+ */
+
+final class ConcurrentTimeProvider implements TimeProvider {
+
+  @Override
+  public long currentTimeNanos() {
+    return TimeUnit.MILLISECONDS.toNanos(System.currentTimeMillis());
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ConnectionClientTransport.java b/core/src/main/java/io/grpc/internal/ConnectionClientTransport.java
index eccb3ce6743..8385316d608 100644
--- a/core/src/main/java/io/grpc/internal/ConnectionClientTransport.java
+++ b/core/src/main/java/io/grpc/internal/ConnectionClientTransport.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
diff --git a/core/src/main/java/io/grpc/internal/ConnectivityStateManager.java b/core/src/main/java/io/grpc/internal/ConnectivityStateManager.java
index 29065a95eef..c67c5e76a67 100644
--- a/core/src/main/java/io/grpc/internal/ConnectivityStateManager.java
+++ b/core/src/main/java/io/grpc/internal/ConnectivityStateManager.java
@@ -1,96 +1,97 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
 import io.grpc.ConnectivityState;
+import io.grpc.ManagedChannel;
 import java.util.ArrayList;
 import java.util.concurrent.Executor;
+import javax.annotation.Nonnull;
 import javax.annotation.concurrent.NotThreadSafe;
 
 /**
- * Book-keeps the connectivity state and callbacks.
+ * Manages connectivity states of the channel. Used for {@link ManagedChannel#getState} to read the
+ * current state of the channel, for {@link ManagedChannel#notifyWhenStateChanged} to add
+ * listeners to state change events, and for {@link io.grpc.LoadBalancer.Helper#updateBalancingState
+ * LoadBalancer.Helper#updateBalancingState} to update the state and run the {@link #gotoState}s.
  */
 @NotThreadSafe
-class ConnectivityStateManager {
-  private ArrayList<StateCallbackEntry> callbacks;
+final class ConnectivityStateManager {
+  private ArrayList<Listener> listeners = new ArrayList<>();
 
-  private ConnectivityState state;
-
-  ConnectivityStateManager(ConnectivityState initialState) {
-    state = initialState;
-  }
+  private volatile ConnectivityState state = ConnectivityState.IDLE;
 
+  /**
+   * Adds a listener for state change event.
+   *
+   * <p>The {@code executor} must be one that can run RPC call listeners.
+   */
   void notifyWhenStateChanged(Runnable callback, Executor executor, ConnectivityState source) {
-    StateCallbackEntry callbackEntry = new StateCallbackEntry(callback, executor);
+    checkNotNull(callback, "callback");
+    checkNotNull(executor, "executor");
+    checkNotNull(source, "source");
+
+    Listener stateChangeListener = new Listener(callback, executor);
     if (state != source) {
-      callbackEntry.runInExecutor();
+      stateChangeListener.runInExecutor();
     } else {
-      if (callbacks == null) {
-        callbacks = new ArrayList<StateCallbackEntry>();
-      }
-      callbacks.add(callbackEntry);
+      listeners.add(stateChangeListener);
     }
   }
 
-  // TODO(zhangkun83): return a runnable in order to escape transport set lock, in case direct
-  // executor is used?
-  void gotoState(ConnectivityState newState) {
-    if (state != newState) {
-      if (state == ConnectivityState.SHUTDOWN) {
-        throw new IllegalStateException("Cannot transition out of SHUTDOWN to " + newState);
-      }
+  /**
+   * Connectivity state is changed to the specified value. Will trigger some notifications that have
+   * been registered earlier by {@link ManagedChannel#notifyWhenStateChanged}.
+   */
+  void gotoState(@Nonnull ConnectivityState newState) {
+    checkNotNull(newState, "newState");
+    if (state != newState && state != ConnectivityState.SHUTDOWN) {
       state = newState;
-      if (callbacks == null) {
+      if (listeners.isEmpty()) {
         return;
       }
       // Swap out callback list before calling them, because a callback may register new callbacks,
       // if run in direct executor, can cause ConcurrentModificationException.
-      ArrayList<StateCallbackEntry> savedCallbacks = callbacks;
-      callbacks = null;
-      for (StateCallbackEntry callback : savedCallbacks) {
-        callback.runInExecutor();
+      ArrayList<Listener> savedListeners = listeners;
+      listeners = new ArrayList<>();
+      for (Listener listener : savedListeners) {
+        listener.runInExecutor();
       }
     }
   }
 
+  /**
+   * Gets the current connectivity state of the channel. This method is threadsafe.
+   */
   ConnectivityState getState() {
-    return state;
+    ConnectivityState stateCopy = state;
+    if (stateCopy == null) {
+      throw new UnsupportedOperationException("Channel state API is not implemented");
+    }
+    return stateCopy;
   }
 
-  private static class StateCallbackEntry {
+  private static final class Listener {
     final Runnable callback;
     final Executor executor;
 
-    StateCallbackEntry(Runnable callback, Executor executor) {
+    Listener(Runnable callback, Executor executor) {
       this.callback = callback;
       this.executor = executor;
     }
diff --git a/core/src/main/java/io/grpc/internal/ConscryptLoader.java b/core/src/main/java/io/grpc/internal/ConscryptLoader.java
new file mode 100644
index 00000000000..2a0d9e47cee
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ConscryptLoader.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2019 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.internal;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.security.Provider;
+
+/**
+ * Utility to load dynamically Conscrypt when it is available.
+ */
+public final class ConscryptLoader {
+  private static final Method NEW_PROVIDER_METHOD;
+  private static final Method IS_CONSCRYPT_METHOD;
+
+  static {
+    Method newProvider;
+    Method isConscrypt;
+    try {
+      Class<?> conscryptClass = Class.forName("org.conscrypt.Conscrypt");
+      newProvider = conscryptClass.getMethod("newProvider");
+      isConscrypt = conscryptClass.getMethod("isConscrypt", Provider.class);
+    } catch (ClassNotFoundException ex) {
+      newProvider = null;
+      isConscrypt = null;
+    } catch (NoSuchMethodException ex) {
+      throw new AssertionError(ex);
+    }
+    NEW_PROVIDER_METHOD = newProvider;
+    IS_CONSCRYPT_METHOD = isConscrypt;
+  }
+
+  /**
+   * Returns {@code true} when the Conscrypt Java classes are available. Does not imply it actually
+   * works on this platform.
+   */
+  public static boolean isPresent() {
+    return NEW_PROVIDER_METHOD != null;
+  }
+
+  /** Same as {@code Conscrypt.isConscrypt(Provider)}. */
+  public static boolean isConscrypt(Provider provider) {
+    if (!isPresent()) {
+      return false;
+    }
+    try {
+      return (Boolean) IS_CONSCRYPT_METHOD.invoke(null, provider);
+    } catch (IllegalAccessException ex) {
+      throw new AssertionError(ex);
+    } catch (InvocationTargetException ex) {
+      throw new AssertionError(ex);
+    }
+  }
+
+  /** Same as {@code Conscrypt.newProvider()}. */
+  public static Provider newProvider() throws Throwable {
+    if (!isPresent()) {
+      Class.forName("org.conscrypt.Conscrypt");
+      throw new AssertionError("Unexpected failure referencing Conscrypt class");
+    }
+    // Exceptions here probably mean something's wrong with the JNI loading. Maybe the platform is
+    // not supported. It's an error, but it may occur in some environments as part of normal
+    // operation. It's too hard to distinguish "normal" from "abnormal" failures here.
+    return (Provider) NEW_PROVIDER_METHOD.invoke(null);
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ContextRunnable.java b/core/src/main/java/io/grpc/internal/ContextRunnable.java
index 939dabc4480..b4c16a3249f 100644
--- a/core/src/main/java/io/grpc/internal/ContextRunnable.java
+++ b/core/src/main/java/io/grpc/internal/ContextRunnable.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -41,7 +26,7 @@ abstract class ContextRunnable implements Runnable {
 
   private final Context context;
 
-  public ContextRunnable(Context context) {
+  protected ContextRunnable(Context context) {
     this.context = context;
   }
 
diff --git a/core/src/main/java/io/grpc/internal/Deframer.java b/core/src/main/java/io/grpc/internal/Deframer.java
new file mode 100644
index 00000000000..c85537f97a8
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/Deframer.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2017 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.internal;
+
+import io.grpc.Decompressor;
+
+/** Interface for deframing gRPC messages. */
+public interface Deframer {
+
+  void setMaxInboundMessageSize(int messageSize);
+
+  /**
+   * Sets the decompressor available to use. The message encoding for the stream comes later in
+   * time, and thus will not be available at the time of construction. This should only be set once,
+   * since the compression codec cannot change after the headers have been sent.
+   *
+   * @param decompressor the decompressing wrapper.
+   */
+  void setDecompressor(Decompressor decompressor);
+
+  /**
+   * Sets the decompressor used for full-stream decompression. Full-stream decompression disables
+   * any per-message decompressor set by {@link #setDecompressor}.
+   *
+   * @param fullStreamDecompressor the decompressing wrapper
+   */
+  void setFullStreamDecompressor(GzipInflatingBuffer fullStreamDecompressor);
+
+  /**
+   * Requests up to the given number of messages from the call. No additional messages will be
+   * delivered.
+   *
+   * <p>If {@link #close()} has been called, this method will have no effect.
+   *
+   * @param numMessages the requested number of messages to be delivered to the listener.
+   */
+  void request(int numMessages);
+
+  /**
+   * Adds the given data to this deframer and attempts delivery to the listener.
+   *
+   * @param data the raw data read from the remote endpoint. Must be non-null.
+   */
+  void deframe(ReadableBuffer data);
+
+  /** Close when any messages currently queued have been requested and delivered. */
+  void closeWhenComplete();
+
+  /**
+   * Closes this deframer and frees any resources. After this method is called, additional calls
+   * will have no effect.
+   */
+  void close();
+}
diff --git a/core/src/main/java/io/grpc/internal/DelayedClientCall.java b/core/src/main/java/io/grpc/internal/DelayedClientCall.java
new file mode 100644
index 00000000000..b568bb12c46
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/DelayedClientCall.java
@@ -0,0 +1,568 @@
+/*
+ * 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.ClientCall;
+import io.grpc.Context;
+import io.grpc.Deadline;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * A call that queues requests before a real call is ready to be delegated to.
+ *
+ * <p>{@code ClientCall} itself doesn't require thread-safety. However, the state of {@code
+ * DelayedCall} may be internally altered by different threads, thus internal synchronization is
+ * necessary.
+ */
+public class DelayedClientCall<ReqT, RespT> extends ClientCall<ReqT, RespT> {
+  private static final Logger logger = Logger.getLogger(DelayedClientCall.class.getName());
+  /**
+   * A timer to monitor the initial deadline. The timer must be cancelled on transition to the real
+   * call.
+   */
+  @Nullable
+  private final ScheduledFuture<?> initialDeadlineMonitor;
+  private final Executor callExecutor;
+  private final Context context;
+  /** {@code true} once realCall is valid and all pending calls have been drained. */
+  private volatile boolean passThrough;
+  /**
+   * Non-{@code null} iff start has been called. Used to assert methods are called in appropriate
+   * order, but also used if an error occurs before {@code realCall} is set.
+   */
+  private Listener<RespT> listener;
+  // No need to synchronize; start() synchronization provides a happens-before
+  private Metadata startHeaders;
+  // Must hold {@code this} lock when setting.
+  private ClientCall<ReqT, RespT> realCall;
+  @GuardedBy("this")
+  private Status error;
+  @GuardedBy("this")
+  private List<Runnable> pendingRunnables = new ArrayList<>();
+  @GuardedBy("this")
+  private DelayedListener<RespT> delayedListener;
+
+  protected DelayedClientCall(
+      Executor callExecutor, ScheduledExecutorService scheduler, @Nullable Deadline deadline) {
+    this.callExecutor = checkNotNull(callExecutor, "callExecutor");
+    checkNotNull(scheduler, "scheduler");
+    context = Context.current();
+    initialDeadlineMonitor = scheduleDeadlineIfNeeded(scheduler, deadline);
+  }
+
+  // If one argument is null, consider the other the "Before"
+  private boolean isAbeforeB(@Nullable Deadline a, @Nullable Deadline b) {
+    if (b == null) {
+      return true;
+    } else if (a == null) {
+      return false;
+    }
+
+    return a.isBefore(b);
+  }
+
+  @Nullable
+  private ScheduledFuture<?> scheduleDeadlineIfNeeded(
+      ScheduledExecutorService scheduler, @Nullable Deadline deadline) {
+    Deadline contextDeadline = context.getDeadline();
+    String deadlineName;
+    long remainingNanos;
+    if (deadline != null && isAbeforeB(deadline, contextDeadline)) {
+      deadlineName = "CallOptions";
+      remainingNanos = deadline.timeRemaining(NANOSECONDS);
+    } else if (contextDeadline != null) {
+      deadlineName = "Context";
+      remainingNanos = contextDeadline.timeRemaining(NANOSECONDS);
+      if (logger.isLoggable(Level.FINE)) {
+        StringBuilder builder =
+            new StringBuilder(
+                String.format(
+                    Locale.US,
+                    "Call timeout set to '%d' ns, due to context deadline.", remainingNanos));
+        if (deadline == null) {
+          builder.append(" Explicit call timeout was not set.");
+        } else {
+          long callTimeout = deadline.timeRemaining(TimeUnit.NANOSECONDS);
+          builder.append(String.format(
+              Locale.US, " Explicit call timeout was '%d' ns.", callTimeout));
+        }
+        logger.fine(builder.toString());
+      }
+    } else {
+      return null;
+    }
+
+    /* Cancels the call if deadline exceeded prior to the real call being set. */
+    class DeadlineExceededRunnable implements Runnable {
+      @Override
+      public void run() {
+        long seconds = Math.abs(remainingNanos) / TimeUnit.SECONDS.toNanos(1);
+        long nanos = Math.abs(remainingNanos) % TimeUnit.SECONDS.toNanos(1);
+        StringBuilder buf = new StringBuilder();
+        if (remainingNanos < 0) {
+          buf.append("ClientCall started after ");
+          buf.append(deadlineName);
+          buf.append(" deadline was exceeded. Deadline has been exceeded for ");
+        } else {
+          buf.append("Deadline ");
+          buf.append(deadlineName);
+          buf.append(" was exceeded after ");
+        }
+        buf.append(seconds);
+        buf.append(String.format(Locale.US, ".%09d", nanos));
+        buf.append("s");
+        cancel(
+            Status.DEADLINE_EXCEEDED.withDescription(buf.toString()),
+            // We should not cancel the call if the realCall is set because there could be a
+            // race between cancel() and realCall.start(). The realCall will handle deadline by
+            // itself.
+            /* onlyCancelPendingCall= */ true);
+      }
+    }
+
+    return scheduler.schedule(new DeadlineExceededRunnable(), remainingNanos, NANOSECONDS);
+  }
+
+  /**
+   * Transfers all pending and future requests and mutations to the given call.
+   *
+   * <p>No-op if either this method or {@link #cancel} have already been called.
+   */
+  // When this method returns, passThrough is guaranteed to be true
+  public final Runnable setCall(ClientCall<ReqT, RespT> call) {
+    Listener<RespT> savedDelayedListener;
+    synchronized (this) {
+      // If realCall != null, then either setCall() or cancel() has been called.
+      if (realCall != null) {
+        return null;
+      }
+      setRealCall(checkNotNull(call, "call"));
+      // start() not yet called
+      if (delayedListener == null) {
+        assert pendingRunnables.isEmpty();
+        pendingRunnables = null;
+        passThrough = true;
+        return null;
+      }
+      savedDelayedListener = this.delayedListener;
+    }
+    internalStart(savedDelayedListener);
+    return new ContextRunnable(context) {
+      @Override
+      public void runInContext() {
+        drainPendingCalls();
+      }
+    };
+  }
+
+  private void internalStart(Listener<RespT> listener) {
+    Metadata savedStartHeaders = this.startHeaders;
+    this.startHeaders = null;
+    context.run(() -> realCall.start(listener, savedStartHeaders));
+  }
+
+  @Override
+  public final void start(Listener<RespT> listener, final Metadata headers) {
+    checkNotNull(headers, "headers");
+    checkState(this.listener == null, "already started");
+    Status savedError;
+    boolean savedPassThrough;
+    synchronized (this) {
+      this.listener = checkNotNull(listener, "listener");
+      // If error != null, then cancel() has been called and was unable to close the listener
+      savedError = error;
+      savedPassThrough = passThrough;
+      if (!savedPassThrough) {
+        listener = delayedListener = new DelayedListener<>(listener);
+        startHeaders = headers;
+      }
+    }
+    if (savedError != null) {
+      callExecutor.execute(new CloseListenerRunnable(listener, savedError));
+      return;
+    }
+    if (savedPassThrough) {
+      realCall.start(listener, headers);
+    } // else realCall.start() will be called by setCall
+  }
+
+  // When this method returns, passThrough is guaranteed to be true
+  @Override
+  public final void cancel(@Nullable final String message, @Nullable final Throwable cause) {
+    Status status = Status.CANCELLED;
+    if (message != null) {
+      status = status.withDescription(message);
+    } else {
+      status = status.withDescription("Call cancelled without message");
+    }
+    if (cause != null) {
+      status = status.withCause(cause);
+    }
+    cancel(status, false);
+  }
+
+  /**
+   * Cancels the call unless {@code realCall} is set and {@code onlyCancelPendingCall} is true.
+   */
+  private void cancel(final Status status, boolean onlyCancelPendingCall) {
+    boolean delegateToRealCall = true;
+    Listener<RespT> listenerToClose = null;
+    synchronized (this) {
+      // If realCall != null, then either setCall() or cancel() has been called
+      if (realCall == null) {
+        @SuppressWarnings("unchecked")
+        ClientCall<ReqT, RespT> noopCall = (ClientCall<ReqT, RespT>) NOOP_CALL;
+        setRealCall(noopCall);
+        delegateToRealCall = false;
+        // If listener == null, then start() will later call listener with 'error'
+        listenerToClose = listener;
+        error = status;
+      } else if (onlyCancelPendingCall) {
+        return;
+      }
+    }
+    if (delegateToRealCall) {
+      delayOrExecute(new Runnable() {
+        @Override
+        public void run() {
+          realCall.cancel(status.getDescription(), status.getCause());
+        }
+      });
+    } else {
+      if (listenerToClose != null) {
+        callExecutor.execute(new CloseListenerRunnable(listenerToClose, status));
+      }
+      internalStart(listenerToClose); // listener instance doesn't matter
+      drainPendingCalls();
+    }
+    callCancelled();
+  }
+
+  protected void callCancelled() {
+  }
+
+  private void delayOrExecute(Runnable runnable) {
+    synchronized (this) {
+      if (!passThrough) {
+        pendingRunnables.add(runnable);
+        return;
+      }
+    }
+    runnable.run();
+  }
+
+  /**
+   * Called to transition {@code passThrough} to {@code true}. This method is not safe to be called
+   * multiple times; the caller must ensure it will only be called once, ever. {@code this} lock
+   * should not be held when calling this method.
+   */
+  private void drainPendingCalls() {
+    assert realCall != null;
+    assert !passThrough;
+    List<Runnable> toRun = new ArrayList<>();
+    DelayedListener<RespT> delayedListener ;
+    while (true) {
+      synchronized (this) {
+        if (pendingRunnables.isEmpty()) {
+          pendingRunnables = null;
+          passThrough = true;
+          delayedListener = this.delayedListener;
+          break;
+        }
+        // Since there were pendingCalls, we need to process them. To maintain ordering we can't set
+        // passThrough=true until we run all pendingCalls, but new Runnables may be added after we
+        // drop the lock. So we will have to re-check pendingCalls.
+        List<Runnable> tmp = toRun;
+        toRun = pendingRunnables;
+        pendingRunnables = tmp;
+      }
+      for (Runnable runnable : toRun) {
+        // Must not call transport while lock is held to prevent deadlocks.
+        // TODO(ejona): exception handling
+        runnable.run();
+      }
+      toRun.clear();
+    }
+    if (delayedListener != null) {
+      final DelayedListener<RespT> listener = delayedListener;
+      class DrainListenerRunnable extends ContextRunnable {
+        DrainListenerRunnable() {
+          super(context);
+        }
+
+        @Override
+        public void runInContext() {
+          listener.drainPendingCallbacks();
+        }
+      }
+
+      callExecutor.execute(new DrainListenerRunnable());
+    }
+  }
+
+  @GuardedBy("this")
+  private void setRealCall(ClientCall<ReqT, RespT> realCall) {
+    checkState(this.realCall == null, "realCall already set to %s", this.realCall);
+    if (initialDeadlineMonitor != null) {
+      initialDeadlineMonitor.cancel(false);
+    }
+    this.realCall = realCall;
+  }
+
+  @VisibleForTesting
+  final ClientCall<ReqT, RespT> getRealCall() {
+    return realCall;
+  }
+
+  @Override
+  public final void sendMessage(final ReqT message) {
+    if (passThrough) {
+      realCall.sendMessage(message);
+    } else {
+      delayOrExecute(new Runnable() {
+        @Override
+        public void run() {
+          realCall.sendMessage(message);
+        }
+      });
+    }
+  }
+
+  @Override
+  public final void setMessageCompression(final boolean enable) {
+    if (passThrough) {
+      realCall.setMessageCompression(enable);
+    } else {
+      delayOrExecute(new Runnable() {
+        @Override
+        public void run() {
+          realCall.setMessageCompression(enable);
+        }
+      });
+    }
+  }
+
+  @Override
+  public final void request(final int numMessages) {
+    if (passThrough) {
+      realCall.request(numMessages);
+    } else {
+      delayOrExecute(new Runnable() {
+        @Override
+        public void run() {
+          realCall.request(numMessages);
+        }
+      });
+    }
+  }
+
+  @Override
+  public final void halfClose() {
+    delayOrExecute(new Runnable() {
+      @Override
+      public void run() {
+        realCall.halfClose();
+      }
+    });
+  }
+
+  @Override
+  public final boolean isReady() {
+    if (passThrough) {
+      return realCall.isReady();
+    } else {
+      return false;
+    }
+  }
+
+  @Override
+  public final Attributes getAttributes() {
+    ClientCall<ReqT, RespT> savedRealCall;
+    synchronized (this) {
+      savedRealCall = realCall;
+    }
+    if (savedRealCall != null) {
+      return savedRealCall.getAttributes();
+    } else {
+      return Attributes.EMPTY;
+    }
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("realCall", realCall)
+        .toString();
+  }
+
+  private final class CloseListenerRunnable extends ContextRunnable {
+    final Listener<RespT> listener;
+    final Status status;
+
+    CloseListenerRunnable(Listener<RespT> listener, Status status) {
+      super(context);
+      this.listener = listener;
+      this.status = status;
+    }
+
+    @Override
+    public void runInContext() {
+      listener.onClose(status, new Metadata());
+    }
+  }
+
+  private static final class DelayedListener<RespT> extends Listener<RespT> {
+    private final Listener<RespT> realListener;
+    private volatile boolean passThrough;
+    @GuardedBy("this")
+    private List<Runnable> pendingCallbacks = new ArrayList<>();
+
+    public DelayedListener(Listener<RespT> listener) {
+      this.realListener = listener;
+    }
+
+    private void delayOrExecute(Runnable runnable) {
+      synchronized (this) {
+        if (!passThrough) {
+          pendingCallbacks.add(runnable);
+          return;
+        }
+      }
+      runnable.run();
+    }
+
+    @Override
+    public void onHeaders(final Metadata headers) {
+      if (passThrough) {
+        realListener.onHeaders(headers);
+      } else {
+        delayOrExecute(new Runnable() {
+          @Override
+          public void run() {
+            realListener.onHeaders(headers);
+          }
+        });
+      }
+    }
+
+    @Override
+    public void onMessage(final RespT message) {
+      if (passThrough) {
+        realListener.onMessage(message);
+      } else {
+        delayOrExecute(new Runnable() {
+          @Override
+          public void run() {
+            realListener.onMessage(message);
+          }
+        });
+      }
+    }
+
+    @Override
+    public void onClose(final Status status, final Metadata trailers) {
+      delayOrExecute(new Runnable() {
+        @Override
+        public void run() {
+          realListener.onClose(status, trailers);
+        }
+      });
+    }
+
+    @Override
+    public void onReady() {
+      if (passThrough) {
+        realListener.onReady();
+      } else {
+        delayOrExecute(new Runnable() {
+          @Override
+          public void run() {
+            realListener.onReady();
+          }
+        });
+      }
+    }
+
+    void drainPendingCallbacks() {
+      assert !passThrough;
+      List<Runnable> toRun = new ArrayList<>();
+      while (true) {
+        synchronized (this) {
+          if (pendingCallbacks.isEmpty()) {
+            pendingCallbacks = null;
+            passThrough = true;
+            break;
+          }
+          // Since there were pendingCallbacks, we need to process them. To maintain ordering we
+          // can't set passThrough=true until we run all pendingCallbacks, but new Runnables may be
+          // added after we drop the lock. So we will have to re-check pendingCallbacks.
+          List<Runnable> tmp = toRun;
+          toRun = pendingCallbacks;
+          pendingCallbacks = tmp;
+        }
+        for (Runnable runnable : toRun) {
+          // Avoid calling listener while lock is held to prevent deadlocks.
+          // TODO(ejona): exception handling
+          runnable.run();
+        }
+        toRun.clear();
+      }
+    }
+  }
+
+  private static final ClientCall<Object, Object> NOOP_CALL = new ClientCall<Object, Object>() {
+    @Override
+    public void start(Listener<Object> responseListener, Metadata headers) {}
+
+    @Override
+    public void request(int numMessages) {}
+
+    @Override
+    public void cancel(String message, Throwable cause) {}
+
+    @Override
+    public void halfClose() {}
+
+    @Override
+    public void sendMessage(Object message) {}
+
+    // Always returns {@code false}, since this is only used when the startup of the call fails.
+    @Override
+    public boolean isReady() {
+      return false;
+    }
+  };
+}
diff --git a/core/src/main/java/io/grpc/internal/DelayedClientTransport.java b/core/src/main/java/io/grpc/internal/DelayedClientTransport.java
index 803c3c5ac1e..5569e1eecf8 100644
--- a/core/src/main/java/io/grpc/internal/DelayedClientTransport.java
+++ b/core/src/main/java/io/grpc/internal/DelayedClientTransport.java
@@ -1,202 +1,229 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Supplier;
-import com.google.common.base.Suppliers;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
 import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
 import io.grpc.Context;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.Subchannel;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalLogId;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.SubchannelPicker;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Iterator;
+import java.util.Collections;
 import java.util.LinkedHashSet;
 import java.util.concurrent.Executor;
+import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
- * A client transport that queues requests before a real transport is available. When a backing
- * transport supplier is later provided, this class delegates to the transports from it.
+ * A client transport that queues requests before a real transport is available. When {@link
+ * #reprocess} is called, this class applies the provided {@link SubchannelPicker} to pick a
+ * transport for each pending stream.
  *
- * <p>This transport owns the streams that it has created before {@link #setTransport} is
- * called. When {@link #setTransport} is called, the ownership of pending streams and subsequent new
- * streams are transferred to the given transport, thus this transport won't own any stream.
+ * <p>This transport owns every stream that it has created until a real transport has been picked
+ * for that stream, at which point the ownership of the stream is transferred to the real transport,
+ * thus the delayed transport stops owning the stream.
  */
-class DelayedClientTransport implements ManagedClientTransport {
-
-  private final LogId lodId = LogId.allocate(getClass().getName());
+final class DelayedClientTransport implements ManagedClientTransport {
+  // lazily allocated, since it is infrequently used.
+  private final InternalLogId logId =
+      InternalLogId.allocate(DelayedClientTransport.class, /*details=*/ null);
 
   private final Object lock = new Object();
 
-  private final Executor streamCreationExecutor;
+  private final Executor defaultAppExecutor;
+  private final SynchronizationContext syncContext;
 
+  private Runnable reportTransportInUse;
+  private Runnable reportTransportNotInUse;
+  private Runnable reportTransportTerminated;
   private Listener listener;
-  /** 'lock' must be held when assigning to transportSupplier. */
-  private volatile Supplier<ClientTransport> transportSupplier;
-
-  @GuardedBy("lock")
-  private Collection<PendingStream> pendingStreams = new LinkedHashSet<PendingStream>();
 
-  // TODO(zhangkun83): remove it once LBv2 refactor is done.  In practice ping() is only called on
-  // real transports.
+  @Nonnull
   @GuardedBy("lock")
-  private Collection<PendingPing> pendingPings = new ArrayList<PendingPing>();
+  private Collection<PendingStream> pendingStreams = new LinkedHashSet<>();
 
-  /**
-   * When shutdown == true and pendingStreams == null, then the transport is considered terminated.
-   */
-  @GuardedBy("lock")
-  private boolean shutdown;
+  /** Immutable state needed for picking. 'lock' must be held for writing. */
+  private volatile PickerState pickerState = new PickerState(null, null);
 
   /**
-   * The delayed client transport will come into a back-off interval if it fails to establish a real
-   * transport for all addresses, namely the channel is in TRANSIENT_FAILURE. When in a back-off
-   * interval, {@code backoffStatus != null}.
+   * Creates a new delayed transport.
    *
-   * <p>If the transport is in a back-off interval, then all fail fast streams (including the
-   * pending as well as new ones) will fail immediately. New non-fail fast streams can be created as
-   * {@link PendingStream} and will keep pending during this back-off period.
+   * @param defaultAppExecutor pending streams will create real streams and run buffered operations
+   *        in an application executor, which will be this executor, unless there is on provided in
+   *        {@link CallOptions}.
+   * @param syncContext all listener callbacks of the delayed transport will be run from this
+   *        SynchronizationContext.
    */
-  @GuardedBy("lock")
-  @Nullable
-  private Status backoffStatus;
-
-  DelayedClientTransport(Executor streamCreationExecutor) {
-    this.streamCreationExecutor = streamCreationExecutor;
+  DelayedClientTransport(Executor defaultAppExecutor, SynchronizationContext syncContext) {
+    this.defaultAppExecutor = defaultAppExecutor;
+    this.syncContext = syncContext;
   }
 
   @Override
-  public final Runnable start(Listener listener) {
-    this.listener = Preconditions.checkNotNull(listener, "listener");
+  public final Runnable start(final Listener listener) {
+    this.listener = listener;
+    reportTransportInUse = new Runnable() {
+        @Override
+        public void run() {
+          listener.transportInUse(true);
+        }
+      };
+    reportTransportNotInUse = new Runnable() {
+        @Override
+        public void run() {
+          listener.transportInUse(false);
+        }
+      };
+    reportTransportTerminated = new Runnable() {
+        @Override
+        public void run() {
+          listener.transportTerminated();
+        }
+      };
     return null;
   }
 
   /**
-   * If the transport has acquired a transport {@link Supplier}, then returned stream is delegated
-   * from its supplier.
-   *
-   * <p>If the new stream to be created is with fail fast call option and the delayed transport is
-   * in a back-off interval, then a {@link FailingClientStream} is returned.
+   * If a {@link SubchannelPicker} is being, or has been provided via {@link #reprocess}, the last
+   * picker will be consulted.
    *
-   * <p>If it is not the above cases and the delayed transport is not shutdown, then a
-   * {@link PendingStream} is returned; if the transport is shutdown, then a
-   * {@link FailingClientStream} is returned.
+   * <p>Otherwise, if the delayed transport is not shutdown, then a {@link PendingStream} is
+   * returned; if the transport is shutdown, then a {@link FailingClientStream} is returned.
    */
   @Override
-  public final ClientStream newStream(MethodDescriptor<?, ?> method, Metadata headers,
-      CallOptions callOptions, StatsTraceContext statsTraceCtx) {
-    Supplier<ClientTransport> supplier = transportSupplier;
-    if (supplier == null) {
-      synchronized (lock) {
-        // Check again, since it may have changed while waiting for lock
-        supplier = transportSupplier;
-        if (supplier == null && !shutdown) {
-          if (backoffStatus != null && !callOptions.isWaitForReady()) {
-            return new FailingClientStream(backoffStatus);
+  public final ClientStream newStream(
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+      ClientStreamTracer[] tracers) {
+    try {
+      PickSubchannelArgs args = new PickSubchannelArgsImpl(
+          method, headers, callOptions, new PickDetailsConsumerImpl(tracers));
+      PickerState state = pickerState;
+      while (true) {
+        if (state.shutdownStatus != null) {
+          return new FailingClientStream(state.shutdownStatus, tracers);
+        }
+        PickResult pickResult = null;
+        if (state.lastPicker != null) {
+          pickResult = state.lastPicker.pickSubchannel(args);
+          callOptions = args.getCallOptions();
+          // User code provided authority takes precedence over the LB provided one.
+          if (callOptions.getAuthority() == null
+              && pickResult.getAuthorityOverride() != null) {
+            callOptions = callOptions.withAuthority(pickResult.getAuthorityOverride());
           }
-          PendingStream pendingStream = new PendingStream(method, headers, callOptions,
-              statsTraceCtx);
-          pendingStreams.add(pendingStream);
-          if (pendingStreams.size() == 1) {
-            listener.transportInUse(true);
+          ClientTransport transport = GrpcUtil.getTransportFromPickResult(pickResult,
+              callOptions.isWaitForReady());
+          if (transport != null) {
+            ClientStream stream = transport.newStream(
+                args.getMethodDescriptor(), args.getHeaders(), callOptions,
+                tracers);
+            // User code provided authority takes precedence over the LB provided one; this will be
+            // overwritten by ClientCallImpl if the application sets an authority override
+            if (pickResult.getAuthorityOverride() != null) {
+              stream.setAuthority(pickResult.getAuthorityOverride());
+            }
+            return stream;
+          }
+        }
+        // This picker's conclusion is "buffer".  If there hasn't been a newer picker set (possible
+        // race with reprocess()), we will buffer the RPC.  Otherwise, will try with the new picker.
+        synchronized (lock) {
+          PickerState newerState = pickerState;
+          if (state == newerState) {
+            return createPendingStream(args, tracers, pickResult);
           }
-          return pendingStream;
+          state = newerState;
         }
       }
+    } finally {
+      syncContext.drain();
     }
-    if (supplier != null) {
-      return supplier.get().newStream(method, headers, callOptions, statsTraceCtx);
+  }
+
+  /**
+   * Caller must call {@code syncContext.drain()} outside of lock because this method may
+   * schedule tasks on syncContext.
+   */
+  @GuardedBy("lock")
+  private PendingStream createPendingStream(PickSubchannelArgs args, ClientStreamTracer[] tracers,
+      PickResult pickResult) {
+    PendingStream pendingStream = new PendingStream(args, tracers);
+    if (args.getCallOptions().isWaitForReady() && pickResult != null && pickResult.hasResult()) {
+      pendingStream.lastPickStatus = pickResult.getStatus();
     }
-    return new FailingClientStream(Status.UNAVAILABLE.withDescription("transport shutdown"));
+    pendingStreams.add(pendingStream);
+    if (getPendingStreamsCount() == 1) {
+      syncContext.executeLater(reportTransportInUse);
+    }
+    for (ClientStreamTracer streamTracer : tracers) {
+      streamTracer.createPendingStream();
+    }
+    return pendingStream;
   }
 
   @Override
-  public final ClientStream newStream(MethodDescriptor<?, ?> method, Metadata headers) {
-    return newStream(method, headers, CallOptions.DEFAULT, StatsTraceContext.NOOP);
+  public final void ping(final PingCallback callback, Executor executor) {
+    throw new UnsupportedOperationException("This method is not expected to be called");
   }
 
   @Override
-  public final void ping(final PingCallback callback, Executor executor) {
-    Supplier<ClientTransport> supplier = transportSupplier;
-    if (supplier == null) {
-      synchronized (lock) {
-        // Check again, since it may have changed while waiting for lock
-        supplier = transportSupplier;
-        if (supplier == null && !shutdown) {
-          PendingPing pendingPing = new PendingPing(callback, executor);
-          pendingPings.add(pendingPing);
-          return;
-        }
-      }
-    }
-    if (supplier != null) {
-      supplier.get().ping(callback, executor);
-      return;
-    }
-    executor.execute(new Runnable() {
-        @Override public void run() {
-          callback.onFailure(
-              Status.UNAVAILABLE.withDescription("transport shutdown").asException());
-        }
-      });
+  public ListenableFuture<SocketStats> getStats() {
+    SettableFuture<SocketStats> ret = SettableFuture.create();
+    ret.set(null);
+    return ret;
   }
 
   /**
-   * Prevents creating any new streams until {@link #setTransport} is called. Buffered streams are
-   * not failed, so if {@link #shutdown} is called when {@link #setTransport} has not been called,
-   * you still need to call {@link #setTransport} to make this transport terminated.
+   * Prevents creating any new streams. Buffered streams are not failed and may still proceed
+   * when {@link #reprocess} is called. The delayed transport will be terminated when there is no
+   * more buffered streams.
    */
   @Override
-  public final void shutdown() {
+  public final void shutdown(final Status status) {
     synchronized (lock) {
-      if (shutdown) {
+      if (pickerState.shutdownStatus != null) {
         return;
       }
-      shutdown = true;
-      listener.transportShutdown(
-          Status.UNAVAILABLE.withDescription("Channel requested transport to shut down"));
-      if (pendingStreams == null || pendingStreams.isEmpty()) {
-        pendingStreams = null;
-        listener.transportTerminated();
+      pickerState = pickerState.withShutdownStatus(status);
+      syncContext.executeLater(new Runnable() {
+          @Override
+          public void run() {
+            listener.transportShutdown(status, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+          }
+        });
+      if (!hasPendingStreams() && reportTransportTerminated != null) {
+        syncContext.executeLater(reportTransportTerminated);
+        reportTransportTerminated = null;
       }
     }
+    syncContext.drain();
   }
 
   /**
@@ -205,333 +232,226 @@ public final void shutdown() {
    */
   @Override
   public final void shutdownNow(Status status) {
-    shutdown();
-    Collection<PendingStream> savedPendingStreams = null;
+    shutdown(status);
+    Collection<PendingStream> savedPendingStreams;
+    Runnable savedReportTransportTerminated;
     synchronized (lock) {
-      if (pendingStreams != null) {
-        savedPendingStreams = pendingStreams;
-        pendingStreams = null;
+      savedPendingStreams = pendingStreams;
+      savedReportTransportTerminated = reportTransportTerminated;
+      reportTransportTerminated = null;
+      if (!pendingStreams.isEmpty()) {
+        pendingStreams = Collections.emptyList();
       }
     }
-    if (savedPendingStreams != null) {
+    if (savedReportTransportTerminated != null) {
       for (PendingStream stream : savedPendingStreams) {
-        stream.cancel(status);
-      }
-      listener.transportTerminated();
-    }
-    // If savedPendingStreams == null, transportTerminated() has already been called in shutdown().
-  }
-
-  /**
-   * Transfers all the pending and future streams and pings to the given transport.
-   *
-   * <p>May only be called after {@link #start(Listener)}.
-   *
-   * <p>{@code transport} will be used for all future calls to {@link #newStream}, even if this
-   * transport is {@link #shutdown}.
-   */
-  public final void setTransport(ClientTransport transport) {
-    Preconditions.checkArgument(this != transport,
-        "delayed transport calling setTransport on itself");
-    setTransportSupplier(Suppliers.ofInstance(transport));
-  }
-
-  /**
-   * Transfers all the pending and future streams and pings to the transports from the given {@link
-   * Supplier}.
-   *
-   * <p>May only be called after {@link #start}. No effect if already called.
-   *
-   * <p>Each stream or ping will result in an invocation to {@link Supplier#get} once. The supplier
-   * will be used for all future calls to {@link #newStream}, even if this transport is {@link
-   * #shutdown}.
-   */
-  public final void setTransportSupplier(final Supplier<ClientTransport> supplier) {
-    synchronized (lock) {
-      if (transportSupplier != null) {
-        return;
-      }
-      Preconditions.checkState(listener != null, "start() not called");
-      transportSupplier = Preconditions.checkNotNull(supplier, "supplier");
-      for (PendingPing ping : pendingPings) {
-        ping.createRealPing(supplier.get());
-      }
-      pendingPings = null;
-      if (shutdown && pendingStreams != null) {
-        listener.transportTerminated();
-      }
-      if (pendingStreams != null && !pendingStreams.isEmpty()) {
-        final Collection<PendingStream> savedPendingStreams = pendingStreams;
-        // createRealStream may be expensive. It will start real streams on the transport. If there
-        // are pending requests, they will be serialized too, which may be expensive. Since we are
-        // now on transport thread, we need to offload the work to an executor.
-        streamCreationExecutor.execute(new Runnable() {
-            @Override public void run() {
-              for (final PendingStream stream : savedPendingStreams) {
-                stream.createRealStream(supplier.get());
-              }
-              // TODO(zhangkun83): some transports (e.g., netty) may have a short delay between
-              // stream.start() and transportInUse(true). If netty's transportInUse(true) is called
-              // after the delayed transport's transportInUse(false), the channel may have a brief
-              // period where all transports are not in-use, and may go to IDLE mode unexpectedly if
-              // the IDLE timeout is shorter (e.g., 0) than that brief period. Maybe we should
-              // have a minimum IDLE timeout?
-              synchronized (lock) {
-                listener.transportInUse(false);
-              }
-            }
-        });
-      }
-      pendingStreams = null;
-      if (!shutdown) {
-        listener.transportReady();
+        Runnable runnable = stream.setStream(
+            new FailingClientStream(status, RpcProgress.REFUSED, stream.tracers));
+        if (runnable != null) {
+          // Drain in-line instead of using an executor as failing stream just throws everything
+          // away. This is essentially the same behavior as DelayedStream.cancel() but can be done
+          // before stream.start().
+          runnable.run();
+        }
       }
+      syncContext.execute(savedReportTransportTerminated);
     }
+    // If savedReportTransportTerminated == null, transportTerminated() has already been called in
+    // shutdown().
   }
 
   public final boolean hasPendingStreams() {
     synchronized (lock) {
-      return pendingStreams != null && !pendingStreams.isEmpty();
+      return !pendingStreams.isEmpty();
     }
   }
 
   @VisibleForTesting
   final int getPendingStreamsCount() {
     synchronized (lock) {
-      return pendingStreams == null ? 0 : pendingStreams.size();
+      return pendingStreams.size();
     }
   }
 
   /**
-   * True return value indicates that the delayed transport is in a back-off interval (in
-   * TRANSIENT_FAILURE), that all fail fast streams (including pending as well as new ones) should
-   * fail immediately, and that non-fail fast streams can be created as {@link PendingStream} and
-   * should keep pending during this back-off period.
-   */
-  // TODO(zhangkun83): remove it once the LBv2 refactor is done.
-  @VisibleForTesting
-  final boolean isInBackoffPeriod() {
-    synchronized (lock) {
-      return backoffStatus != null;
-    }
-  }
-
-  /**
-   * Is only called at the beginning of {@link TransportSet#scheduleBackoff}.
-   *
-   * <p>Does jobs at the beginning of the back-off:
+   * Use the picker to try picking a transport for every pending stream, proceed the stream if the
+   * pick is successful, otherwise keep it pending.
    *
-   * <p>sets {@link #backoffStatus};
+   * <p>This method may be called concurrently with {@code newStream()}, and it's safe.  All pending
+   * streams will be served by the latest picker (if a same picker is given more than once, they are
+   * considered different pickers) as soon as possible.
    *
-   * <p>sets all pending streams with a fail fast call option of the delayed transport as
-   * {@link FailingClientStream}s, and removes them from the list of pending streams of the
-   * transport.
-   *
-   * @param status the causal status for triggering back-off.
+   * <p>This method <strong>must not</strong> be called concurrently with itself.
    */
-  // TODO(zhangkun83): remove it once the LBv2 refactor is done.
-  final void startBackoff(final Status status) {
-    synchronized (lock) {
-      if (shutdown) {
-        return;
-      }
-      Preconditions.checkState(backoffStatus == null,
-          "Error when calling startBackoff: transport is already in backoff period");
-      backoffStatus = Status.UNAVAILABLE.withDescription("Channel in TRANSIENT_FAILURE state")
-          .withCause(status.asRuntimeException());
-      final ArrayList<PendingStream> failFastPendingStreams = new ArrayList<PendingStream>();
-      if (pendingStreams != null && !pendingStreams.isEmpty()) {
-        final Iterator<PendingStream> it = pendingStreams.iterator();
-        while (it.hasNext()) {
-          PendingStream stream = it.next();
-          if (!stream.callOptions.isWaitForReady()) {
-            failFastPendingStreams.add(stream);
-            it.remove();
-          }
-        }
-
-        class FailTheFailFastPendingStreams implements Runnable {
-          @Override
-          public void run() {
-            for (PendingStream stream : failFastPendingStreams) {
-              stream.setStream(new FailingClientStream(status));
-            }
-          }
-        }
-
-        streamCreationExecutor.execute(new FailTheFailFastPendingStreams());
-      }
-    }
-  }
-
-  /**
-   * Is only called at the beginning of the callback function of {@code endOfCurrentBackoff} in the
-   * {@link TransportSet#scheduleBackoff} method.
-   */
-  // TODO(zhangkun83): remove it once the LBv2 refactor is done.
-  final void endBackoff() {
-    synchronized (lock) {
-      Preconditions.checkState(backoffStatus != null,
-          "Error when calling endBackoff: transport is not in backoff period");
-      backoffStatus = null;
-    }
-  }
-
-  /**
-   * Use the picker to try picking a transport for every pending stream and pending ping, proceed
-   * the stream or ping if the pick is successful, otherwise keep it pending.
-   *
-   * <p>If new pending streams are created while reprocess() is in progress, there is no guarantee
-   * that the pending streams will or will not be processed by this picker.
-   *
-   * <p>This method <strong>must not</strong> be called concurrently, either with itself or with
-   * {@link #setTransportSupplier}/{@link #setTransport}.
-   */
-  final void reprocess(LoadBalancer2.SubchannelPicker picker) {
+  final void reprocess(@Nullable SubchannelPicker picker) {
     ArrayList<PendingStream> toProcess;
-    ArrayList<PendingStream> toRemove = new ArrayList<PendingStream>();
     synchronized (lock) {
-      if (pendingStreams == null || pendingStreams.isEmpty()) {
+      pickerState = pickerState.withPicker(picker);
+      if (picker == null || !hasPendingStreams()) {
         return;
       }
-      toProcess = new ArrayList<PendingStream>(pendingStreams);
+      toProcess = new ArrayList<>(pendingStreams);
     }
+    ArrayList<PendingStream> toRemove = new ArrayList<>();
 
     for (final PendingStream stream : toProcess) {
-      PickResult pickResult = picker.pickSubchannel(
-          stream.callOptions.getAffinity(), stream.headers);
-      final ClientTransport realTransport;
-      Subchannel subchannel = pickResult.getSubchannel();
-      if (subchannel != null) {
-        realTransport = ((SubchannelImpl) subchannel).obtainActiveTransport();
-      } else {
-        realTransport = null;
+      PickResult pickResult = picker.pickSubchannel(stream.args);
+      CallOptions callOptions = stream.args.getCallOptions();
+      if (callOptions.isWaitForReady() && pickResult.hasResult()) {
+        stream.lastPickStatus = pickResult.getStatus();
       }
-      if (realTransport != null) {
-        Executor executor = streamCreationExecutor;
+      final ClientTransport transport = GrpcUtil.getTransportFromPickResult(pickResult,
+          callOptions.isWaitForReady());
+      if (transport != null) {
+        Executor executor = defaultAppExecutor;
         // createRealStream may be expensive. It will start real streams on the transport. If
         // there are pending requests, they will be serialized too, which may be expensive. Since
         // we are now on transport thread, we need to offload the work to an executor.
-        if (stream.callOptions.getExecutor() != null) {
-          executor = stream.callOptions.getExecutor();
+        if (callOptions.getExecutor() != null) {
+          executor = callOptions.getExecutor();
+        }
+        Runnable runnable = stream.createRealStream(transport, pickResult.getAuthorityOverride());
+        if (runnable != null) {
+          executor.execute(runnable);
         }
-        executor.execute(new Runnable() {
-            @Override
-            public void run() {
-              stream.createRealStream(realTransport);
-            }
-          });
-        toRemove.add(stream);
-      } else if (!pickResult.getStatus().isOk() && !stream.callOptions.isWaitForReady()) {
-        stream.setStream(new FailingClientStream(pickResult.getStatus()));
         toRemove.add(stream);
-      }  // other cases: stay pending
+      }  // else: stay pending
     }
 
     synchronized (lock) {
       // Between this synchronized and the previous one:
       //   - Streams may have been cancelled, which may turn pendingStreams into emptiness.
       //   - shutdown() may be called, which may turn pendingStreams into null.
-      if (pendingStreams == null || pendingStreams.isEmpty()) {
+      if (!hasPendingStreams()) {
         return;
       }
-      pendingStreams.removeAll(toRemove);
+      // Avoid pendingStreams.removeAll() as it can degrade to calling toRemove.contains() for each
+      // element in pendingStreams.
+      for (PendingStream stream : toRemove) {
+        pendingStreams.remove(stream);
+      }
+      // Because delayed transport is long-lived, we take this opportunity to down-size the
+      // hashmap.
       if (pendingStreams.isEmpty()) {
+        pendingStreams = new LinkedHashSet<>();
+      }
+      if (!hasPendingStreams()) {
         // There may be a brief gap between delayed transport clearing in-use state, and first real
         // transport starting streams and setting in-use state.  During the gap the whole channel's
         // in-use state may be false. However, it shouldn't cause spurious switching to idleness
         // (which would shutdown the transports and LoadBalancer) because the gap should be shorter
         // than IDLE_MODE_DEFAULT_TIMEOUT_MILLIS (1 second).
-        listener.transportInUse(false);
-        if (shutdown) {
-          pendingStreams = null;
-          listener.transportTerminated();
-        } else {
-          // Because delayed transport is long-lived, we take this opportunity to down-size the
-          // hashmap.
-          pendingStreams = new LinkedHashSet<PendingStream>();
+        syncContext.executeLater(reportTransportNotInUse);
+        if (pickerState.shutdownStatus != null && reportTransportTerminated != null) {
+          syncContext.executeLater(reportTransportTerminated);
+          reportTransportTerminated = null;
         }
       }
     }
+    syncContext.drain();
   }
 
-  // TODO(carl-mastrangelo): remove this once the Subchannel change is in.
   @Override
-  public LogId getLogId() {
-    return lodId;
-  }
-
-  @VisibleForTesting
-  @Nullable
-  final Supplier<ClientTransport> getTransportSupplier() {
-    return transportSupplier;
+  public InternalLogId getLogId() {
+    return logId;
   }
 
   private class PendingStream extends DelayedStream {
-    private final MethodDescriptor<?, ?> method;
-    private final Metadata headers;
-    private final CallOptions callOptions;
-    private final Context context;
-    private final StatsTraceContext statsTraceCtx;
-
-    private PendingStream(MethodDescriptor<?, ?> method, Metadata headers,
-        CallOptions callOptions, StatsTraceContext statsTraceCtx) {
-      this.method = method;
-      this.headers = headers;
-      this.callOptions = callOptions;
-      this.context = Context.current();
-      this.statsTraceCtx = statsTraceCtx;
+    private final PickSubchannelArgs args;
+    private final Context context = Context.current();
+    private final ClientStreamTracer[] tracers;
+    private volatile Status lastPickStatus;
+
+    private PendingStream(PickSubchannelArgs args, ClientStreamTracer[] tracers) {
+      super("connecting_and_lb");
+      this.args = args;
+      this.tracers = tracers;
     }
 
-    private void createRealStream(ClientTransport transport) {
+    /** Runnable may be null. */
+    private Runnable createRealStream(ClientTransport transport, String authorityOverride) {
       ClientStream realStream;
       Context origContext = context.attach();
       try {
-        realStream = transport.newStream(method, headers, callOptions, statsTraceCtx);
+        realStream = transport.newStream(
+            args.getMethodDescriptor(), args.getHeaders(), args.getCallOptions(),
+            tracers);
       } finally {
         context.detach(origContext);
       }
-      setStream(realStream);
+      if (authorityOverride != null) {
+        // User code provided authority takes precedence over the LB provided one; this will be
+        // overwritten by an enqueud call from ClientCallImpl if the application sets an authority
+        // override. We must call the real stream directly because stream.start() has likely already
+        // been called on the delayed stream.
+        realStream.setAuthority(authorityOverride);
+      }
+      return setStream(realStream);
     }
 
     @Override
     public void cancel(Status reason) {
       super.cancel(reason);
       synchronized (lock) {
-        if (pendingStreams != null) {
+        if (reportTransportTerminated != null) {
           boolean justRemovedAnElement = pendingStreams.remove(this);
-          if (pendingStreams.isEmpty() && justRemovedAnElement) {
-            listener.transportInUse(false);
-            if (shutdown) {
-              pendingStreams = null;
-              listener.transportTerminated();
+          if (!hasPendingStreams() && justRemovedAnElement) {
+            syncContext.executeLater(reportTransportNotInUse);
+            if (pickerState.shutdownStatus != null) {
+              syncContext.executeLater(reportTransportTerminated);
+              reportTransportTerminated = null;
             }
           }
         }
       }
+      syncContext.drain();
+    }
+
+    @Override
+    protected void onEarlyCancellation(Status reason) {
+      for (ClientStreamTracer tracer : tracers) {
+        tracer.streamClosed(reason);
+      }
+    }
+
+    @Override
+    public void appendTimeoutInsight(InsightBuilder insight) {
+      if (args.getCallOptions().isWaitForReady()) {
+        insight.append("wait_for_ready");
+        Status status = lastPickStatus;
+        if (status != null && !status.isOk()) {
+          insight.appendKeyValue("Last Pick Failure", status);
+        }
+      }
+      super.appendTimeoutInsight(insight);
     }
   }
 
-  private static class PendingPing {
-    private final PingCallback callback;
-    private final Executor executor;
+  static final class PickerState {
+    /**
+     * The last picker that {@link #reprocess} has used. May be set to null when the channel has
+     * moved to idle.
+     */
+    @Nullable
+    final SubchannelPicker lastPicker;
+    /**
+     * When {@code shutdownStatus != null && !hasPendingStreams()}, then the transport is considered
+     * terminated.
+     */
+    @Nullable
+    final Status shutdownStatus;
+
+    private PickerState(SubchannelPicker lastPicker, Status shutdownStatus) {
+      this.lastPicker = lastPicker;
+      this.shutdownStatus = shutdownStatus;
+    }
 
-    public PendingPing(PingCallback callback, Executor executor) {
-      this.callback = callback;
-      this.executor = executor;
+    public PickerState withPicker(SubchannelPicker newPicker) {
+      return new PickerState(newPicker, this.shutdownStatus);
     }
 
-    public void createRealPing(ClientTransport transport) {
-      try {
-        transport.ping(callback, executor);
-      } catch (final UnsupportedOperationException ex) {
-        executor.execute(new Runnable() {
-          @Override
-          public void run() {
-            callback.onFailure(ex);
-          }
-        });
-      }
+    public PickerState withShutdownStatus(Status newShutdownStatus) {
+      return new PickerState(this.lastPicker, newShutdownStatus);
     }
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/DelayedClientTransport2.java b/core/src/main/java/io/grpc/internal/DelayedClientTransport2.java
deleted file mode 100644
index 3318db861c6..00000000000
--- a/core/src/main/java/io/grpc/internal/DelayedClientTransport2.java
+++ /dev/null
@@ -1,391 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import com.google.common.annotations.VisibleForTesting;
-import io.grpc.CallOptions;
-import io.grpc.Context;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.SubchannelPicker;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.Status;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.LinkedHashSet;
-import java.util.concurrent.Executor;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
-
-/**
- * A client transport that queues requests before a real transport is available. When {@link
- * #reprocess} is called, this class applies the provided {@link SubchannelPicker} to pick a
- * transport for each pending stream.
- *
- * <p>This transport owns every stream that it has created until a real transport has been picked
- * for that stream, at which point the ownership of the stream is transferred to the real transport,
- * thus the delayed transport stops owning the stream.
- */
-final class DelayedClientTransport2 implements ManagedClientTransport {
-  private final LogId lodId = LogId.allocate(getClass().getName());
-
-  private final Object lock = new Object();
-
-  private final Executor defaultAppExecutor;
-  private final ChannelExecutor channelExecutor;
-
-  private Runnable reportTransportInUse;
-  private Runnable reportTransportNotInUse;
-  private Runnable reportTransportShutdown;
-  private Runnable reportTransportTerminated;
-
-  @GuardedBy("lock")
-  private Collection<PendingStream> pendingStreams = new LinkedHashSet<PendingStream>();
-
-  /**
-   * When shutdown == true and pendingStreams == null, then the transport is considered terminated.
-   */
-  @GuardedBy("lock")
-  private boolean shutdown;
-
-  /**
-   * The last picker that {@link #reprocess} has used.
-   */
-  @GuardedBy("lock")
-  @Nullable
-  private SubchannelPicker lastPicker;
-
-  @GuardedBy("lock")
-  private long lastPickerVersion;
-
-  /**
-   * Creates a new delayed transport.
-   *
-   * @param defaultAppExecutor pending streams will create real streams and run bufferred operations
-   *        in an application executor, which will be this executor, unless there is on provided in
-   *        {@link CallOptions}.
-   * @param channelExecutor all listener callbacks of the delayed transport will be run from this
-   *        ChannelExecutor.
-   */
-  DelayedClientTransport2(Executor defaultAppExecutor, ChannelExecutor channelExecutor) {
-    this.defaultAppExecutor = defaultAppExecutor;
-    this.channelExecutor = channelExecutor;
-  }
-
-  @Override
-  public final Runnable start(final Listener listener) {
-    reportTransportInUse = new Runnable() {
-        @Override
-        public void run() {
-          listener.transportInUse(true);
-        }
-      };
-    reportTransportNotInUse = new Runnable() {
-        @Override
-        public void run() {
-          listener.transportInUse(false);
-        }
-      };
-    reportTransportShutdown = new Runnable() {
-        @Override
-        public void run() {
-          listener.transportShutdown(
-              Status.UNAVAILABLE.withDescription("Channel requested transport to shut down"));
-        }
-      };
-    reportTransportTerminated = new Runnable() {
-        @Override
-        public void run() {
-          listener.transportTerminated();
-        }
-      };
-    return null;
-  }
-
-  /**
-   * If a {@link SubchannelPicker} is being, or has been provided via {@link #reprocess}, the last
-   * picker will be consulted.
-   *
-   * <p>Otherwise, if the delayed transport is not shutdown, then a {@link PendingStream} is
-   * returned; if the transport is shutdown, then a {@link FailingClientStream} is returned.
-   */
-  @Override
-  public final ClientStream newStream(MethodDescriptor<?, ?> method, Metadata headers,
-      CallOptions callOptions, StatsTraceContext statsTraceCtx) {
-    try {
-      SubchannelPicker picker = null;
-      long pickerVersion = -1;
-      synchronized (lock) {
-        if (!shutdown) {
-          if (lastPicker == null) {
-            return createPendingStream(method, headers, callOptions, statsTraceCtx);
-          }
-          picker = lastPicker;
-          pickerVersion = lastPickerVersion;
-        }
-      }
-      if (picker != null) {
-        while (true) {
-          PickResult pickResult = picker.pickSubchannel(callOptions.getAffinity(), headers);
-          ClientTransport transport = GrpcUtil.getTransportFromPickResult(
-              pickResult, callOptions.isWaitForReady());
-          if (transport != null) {
-            return transport.newStream(method, headers, callOptions, statsTraceCtx);
-          }
-          // This picker's conclusion is "buffer".  If there hasn't been a newer picker set
-          // (possible race with reprocess()), we will buffer it.  Otherwise, will try with the new
-          // picker.
-          synchronized (lock) {
-            if (shutdown) {
-              break;
-            }
-            if (pickerVersion == lastPickerVersion) {
-              return createPendingStream(method, headers, callOptions, statsTraceCtx);
-            }
-            picker = lastPicker;
-            pickerVersion = lastPickerVersion;
-          }
-        }
-      }
-      return new FailingClientStream(Status.UNAVAILABLE.withDescription(
-              "Channel has shutdown (reported by delayed transport)"));
-    } finally {
-      channelExecutor.drain();
-    }
-  }
-
-  @Override
-  public final ClientStream newStream(MethodDescriptor<?, ?> method, Metadata headers) {
-    return newStream(method, headers, CallOptions.DEFAULT, StatsTraceContext.NOOP);
-  }
-
-  // Caller must call channelExecutor.drain() outside of lock because this method may schedule
-  // tasks on channelExecutor
-  @GuardedBy("lock")
-  private PendingStream createPendingStream(MethodDescriptor<?, ?> method, Metadata headers,
-      CallOptions callOptions, StatsTraceContext statsTraceCtx) {
-    PendingStream pendingStream = new PendingStream(method, headers, callOptions,
-        statsTraceCtx);
-    pendingStreams.add(pendingStream);
-    if (pendingStreams.size() == 1) {
-      channelExecutor.executeLater(reportTransportInUse);
-    }
-    return pendingStream;
-  }
-
-  @Override
-  public final void ping(final PingCallback callback, Executor executor) {
-    throw new UnsupportedOperationException("This method is not expected to be called");
-  }
-
-  /**
-   * Prevents creating any new streams.  Buffered streams are not failed and may still proceed
-   * when {@link #reprocess} is called.  The delayed transport will be terminated when there is no
-   * more buffered streams.
-   */
-  @Override
-  public final void shutdown() {
-    synchronized (lock) {
-      if (shutdown) {
-        return;
-      }
-      shutdown = true;
-      channelExecutor.executeLater(reportTransportShutdown);
-      if (pendingStreams == null || pendingStreams.isEmpty()) {
-        pendingStreams = null;
-        channelExecutor.executeLater(reportTransportTerminated);
-      }
-    }
-    channelExecutor.drain();
-  }
-
-  /**
-   * Shuts down this transport and cancels all streams that it owns, hence immediately terminates
-   * this transport.
-   */
-  @Override
-  public final void shutdownNow(Status status) {
-    shutdown();
-    Collection<PendingStream> savedPendingStreams = null;
-    synchronized (lock) {
-      if (pendingStreams != null) {
-        savedPendingStreams = pendingStreams;
-        pendingStreams = null;
-      }
-    }
-    if (savedPendingStreams != null) {
-      for (PendingStream stream : savedPendingStreams) {
-        stream.cancel(status);
-      }
-      channelExecutor.executeLater(reportTransportTerminated).drain();
-    }
-    // If savedPendingStreams == null, transportTerminated() has already been called in shutdown().
-  }
-
-  public final boolean hasPendingStreams() {
-    synchronized (lock) {
-      return pendingStreams != null && !pendingStreams.isEmpty();
-    }
-  }
-
-  @VisibleForTesting
-  final int getPendingStreamsCount() {
-    synchronized (lock) {
-      return pendingStreams == null ? 0 : pendingStreams.size();
-    }
-  }
-
-  /**
-   * Use the picker to try picking a transport for every pending stream, proceed the stream if the
-   * pick is successful, otherwise keep it pending.
-   *
-   * <p>This method may be called concurrently with {@code newStream()}, and it's safe.  All pending
-   * streams will be served by the latest picker (if a same picker is given more than once, they are
-   * considered different pickers) as soon as possible.
-   *
-   * <p>This method <strong>must not</strong> be called concurrently with itself.
-   */
-  final void reprocess(SubchannelPicker picker) {
-    ArrayList<PendingStream> toProcess;
-    ArrayList<PendingStream> toRemove = new ArrayList<PendingStream>();
-    synchronized (lock) {
-      lastPicker = picker;
-      lastPickerVersion++;
-      if (pendingStreams == null || pendingStreams.isEmpty()) {
-        return;
-      }
-      toProcess = new ArrayList<PendingStream>(pendingStreams);
-    }
-
-    for (final PendingStream stream : toProcess) {
-      PickResult pickResult = picker.pickSubchannel(
-          stream.callOptions.getAffinity(), stream.headers);
-      final ClientTransport transport = GrpcUtil.getTransportFromPickResult(
-          pickResult, stream.callOptions.isWaitForReady());
-      if (transport != null) {
-        Executor executor = defaultAppExecutor;
-        // createRealStream may be expensive. It will start real streams on the transport. If
-        // there are pending requests, they will be serialized too, which may be expensive. Since
-        // we are now on transport thread, we need to offload the work to an executor.
-        if (stream.callOptions.getExecutor() != null) {
-          executor = stream.callOptions.getExecutor();
-        }
-        executor.execute(new Runnable() {
-            @Override
-            public void run() {
-              stream.createRealStream(transport);
-            }
-          });
-        toRemove.add(stream);
-      }  // else: stay pending
-    }
-
-    synchronized (lock) {
-      // Between this synchronized and the previous one:
-      //   - Streams may have been cancelled, which may turn pendingStreams into emptiness.
-      //   - shutdown() may be called, which may turn pendingStreams into null.
-      if (pendingStreams == null || pendingStreams.isEmpty()) {
-        return;
-      }
-      pendingStreams.removeAll(toRemove);
-      if (pendingStreams.isEmpty()) {
-        // There may be a brief gap between delayed transport clearing in-use state, and first real
-        // transport starting streams and setting in-use state.  During the gap the whole channel's
-        // in-use state may be false. However, it shouldn't cause spurious switching to idleness
-        // (which would shutdown the transports and LoadBalancer) because the gap should be shorter
-        // than IDLE_MODE_DEFAULT_TIMEOUT_MILLIS (1 second).
-        channelExecutor.executeLater(reportTransportNotInUse);
-        if (shutdown) {
-          pendingStreams = null;
-          channelExecutor.executeLater(reportTransportTerminated);
-        } else {
-          // Because delayed transport is long-lived, we take this opportunity to down-size the
-          // hashmap.
-          pendingStreams = new LinkedHashSet<PendingStream>();
-        }
-      }
-    }
-    channelExecutor.drain();
-  }
-
-  // TODO(carl-mastrangelo): remove this once the Subchannel change is in.
-  @Override
-  public LogId getLogId() {
-    return lodId;
-  }
-
-  private class PendingStream extends DelayedStream {
-    private final MethodDescriptor<?, ?> method;
-    private final Metadata headers;
-    private final CallOptions callOptions;
-    private final Context context;
-    private final StatsTraceContext statsTraceCtx;
-
-    private PendingStream(MethodDescriptor<?, ?> method, Metadata headers,
-        CallOptions callOptions, StatsTraceContext statsTraceCtx) {
-      this.method = method;
-      this.headers = headers;
-      this.callOptions = callOptions;
-      this.context = Context.current();
-      this.statsTraceCtx = statsTraceCtx;
-    }
-
-    private void createRealStream(ClientTransport transport) {
-      ClientStream realStream;
-      Context origContext = context.attach();
-      try {
-        realStream = transport.newStream(method, headers, callOptions, statsTraceCtx);
-      } finally {
-        context.detach(origContext);
-      }
-      setStream(realStream);
-    }
-
-    @Override
-    public void cancel(Status reason) {
-      super.cancel(reason);
-      synchronized (lock) {
-        if (pendingStreams != null) {
-          boolean justRemovedAnElement = pendingStreams.remove(this);
-          if (pendingStreams.isEmpty() && justRemovedAnElement) {
-            channelExecutor.executeLater(reportTransportNotInUse);
-            if (shutdown) {
-              pendingStreams = null;
-              channelExecutor.executeLater(reportTransportTerminated);
-            }
-          }
-        }
-      }
-      channelExecutor.drain();
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/DelayedStream.java b/core/src/main/java/io/grpc/internal/DelayedStream.java
index a5fc69980c1..a2b1e963ac5 100644
--- a/core/src/main/java/io/grpc/internal/DelayedStream.java
+++ b/core/src/main/java/io/grpc/internal/DelayedStream.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -35,15 +20,18 @@
 import static com.google.common.base.Preconditions.checkState;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.errorprone.annotations.CheckReturnValue;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
 import io.grpc.Attributes;
 import io.grpc.Compressor;
-import io.grpc.Decompressor;
+import io.grpc.Deadline;
+import io.grpc.DecompressorRegistry;
 import io.grpc.Metadata;
 import io.grpc.Status;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * A stream that queues requests before the transport is available, and delegates to a real stream
@@ -54,11 +42,12 @@
  * necessary.
  */
 class DelayedStream implements ClientStream {
+  private final String bufferContext;
   /** {@code true} once realStream is valid and all pending calls have been drained. */
   private volatile boolean passThrough;
   /**
    * Non-{@code null} iff start has been called. Used to assert methods are called in appropriate
-   * order, but also used if an error occurrs before {@code realStream} is set.
+   * order, but also used if an error occurs before {@code realStream} is set.
    */
   private ClientStreamListener listener;
   /** Must hold {@code this} lock when setting. */
@@ -66,54 +55,111 @@ class DelayedStream implements ClientStream {
   @GuardedBy("this")
   private Status error;
   @GuardedBy("this")
-  private List<Runnable> pendingCalls = new ArrayList<Runnable>();
+  private List<Runnable> pendingCalls = new ArrayList<>();
   @GuardedBy("this")
   private DelayedStreamListener delayedListener;
+  @GuardedBy("this")
+  private long startTimeNanos;
+  @GuardedBy("this")
+  private long streamSetTimeNanos;
+  // No need to synchronize; start() synchronization provides a happens-before
+  private List<Runnable> preStartPendingCalls = new ArrayList<>();
+
+  /**
+   * Create a delayed stream with debug context {@code bufferContext}. The context is what this
+   * stream is delayed by (e.g., "connecting", "call_credentials").
+   */
+  public DelayedStream(String bufferContext) {
+    this.bufferContext = checkNotNull(bufferContext, "bufferContext");
+  }
 
   @Override
   public void setMaxInboundMessageSize(final int maxSize) {
-    if (passThrough) {
-      realStream.setMaxInboundMessageSize(maxSize);
-    } else {
-      delayOrExecute(new Runnable() {
-        @Override
-        public void run() {
-          realStream.setMaxInboundMessageSize(maxSize);
-        }
-      });
-    }
+    checkState(listener == null, "May only be called before start");
+    preStartPendingCalls.add(new Runnable() {
+      @Override
+      public void run() {
+        realStream.setMaxInboundMessageSize(maxSize);
+      }
+    });
   }
 
   @Override
   public void setMaxOutboundMessageSize(final int maxSize) {
-    if (passThrough) {
-      realStream.setMaxOutboundMessageSize(maxSize);
-    } else {
-      delayOrExecute(new Runnable() {
-        @Override
-        public void run() {
-          realStream.setMaxOutboundMessageSize(maxSize);
-        }
-      });
+    checkState(listener == null, "May only be called before start");
+    preStartPendingCalls.add(new Runnable() {
+      @Override
+      public void run() {
+        realStream.setMaxOutboundMessageSize(maxSize);
+      }
+    });
+  }
+
+  @Override
+  public void setDeadline(final Deadline deadline) {
+    checkState(listener == null, "May only be called before start");
+    preStartPendingCalls.add(new Runnable() {
+      @Override
+      public void run() {
+        realStream.setDeadline(deadline);
+      }
+    });
+  }
+
+  @Override
+  public void appendTimeoutInsight(InsightBuilder insight) {
+    synchronized (this) {
+      if (listener == null) {
+        return;
+      }
+      if (realStream != null) {
+        insight.appendKeyValue(
+            bufferContext + "_delay", "" + (streamSetTimeNanos - startTimeNanos) + "ns");
+        realStream.appendTimeoutInsight(insight);
+      } else {
+        insight.appendKeyValue(
+            bufferContext + "_delay", "" + (System.nanoTime() - startTimeNanos) + "ns");
+        insight.append("was_still_waiting");
+      }
     }
   }
 
   /**
-   * Transfers all pending and future requests and mutations to the given stream.
+   * Transfers all pending and future requests and mutations to the given stream. Method will return
+   * quickly, but if the returned Runnable is non-null it must be called to complete the process.
+   * The Runnable may take a while to execute.
    *
    * <p>No-op if either this method or {@link #cancel} have already been called.
    */
-  // When this method returns, passThrough is guaranteed to be true
-  final void setStream(ClientStream stream) {
+  // When this method returns, start() has been called on realStream or passThrough is guaranteed to
+  // be true
+  @CheckReturnValue
+  final Runnable setStream(ClientStream stream) {
+    ClientStreamListener savedListener;
     synchronized (this) {
       // If realStream != null, then either setStream() or cancel() has been called.
       if (realStream != null) {
-        return;
+        return null;
+      }
+      setRealStream(checkNotNull(stream, "stream"));
+      savedListener = listener;
+      if (savedListener == null) {
+        assert pendingCalls.isEmpty();
+        pendingCalls = null;
+        passThrough = true;
       }
-      realStream = checkNotNull(stream, "stream");
     }
-
-    drainPendingCalls();
+    if (savedListener == null) {
+      return null;
+    } else {
+      internalStart(savedListener);
+      return new Runnable() {
+        @Override
+        public void run() {
+          drainPendingCalls();
+        }
+      };
+    }
   }
 
   /**
@@ -124,7 +170,7 @@ final void setStream(ClientStream stream) {
   private void drainPendingCalls() {
     assert realStream != null;
     assert !passThrough;
-    List<Runnable> toRun = new ArrayList<Runnable>();
+    List<Runnable> toRun = new ArrayList<>();
     DelayedStreamListener delayedListener = null;
     while (true) {
       synchronized (this) {
@@ -161,6 +207,7 @@ private void drainPendingCalls() {
    * only if {@code runnable} is thread-safe.
    */
   private void delayOrExecute(Runnable runnable) {
+    checkState(listener != null, "May only be called after start");
     synchronized (this) {
       if (!passThrough) {
         pendingCalls.add(runnable);
@@ -172,9 +219,8 @@ private void delayOrExecute(Runnable runnable) {
 
   @Override
   public void setAuthority(final String authority) {
-    checkState(listener == null, "May only be called before start");
     checkNotNull(authority, "authority");
-    delayOrExecute(new Runnable() {
+    preStartPendingCalls.add(new Runnable() {
       @Override
       public void run() {
         realStream.setAuthority(authority);
@@ -184,45 +230,59 @@ public void run() {
 
   @Override
   public void start(ClientStreamListener listener) {
+    checkNotNull(listener, "listener");
     checkState(this.listener == null, "already started");
 
     Status savedError;
     boolean savedPassThrough;
     synchronized (this) {
-      this.listener = checkNotNull(listener, "listener");
       // If error != null, then cancel() has been called and was unable to close the listener
       savedError = error;
       savedPassThrough = passThrough;
       if (!savedPassThrough) {
         listener = delayedListener = new DelayedStreamListener(listener);
       }
+      this.listener = listener;
+      startTimeNanos = System.nanoTime();
     }
     if (savedError != null) {
-      listener.closed(savedError, new Metadata());
+      listener.closed(savedError, RpcProgress.PROCESSED, new Metadata());
       return;
     }
 
     if (savedPassThrough) {
-      realStream.start(listener);
-    } else {
-      final ClientStreamListener finalListener = listener;
-      delayOrExecute(new Runnable() {
-        @Override
-        public void run() {
-          realStream.start(finalListener);
-        }
-      });
+      internalStart(listener);
+    } // else internalStart() will be called by setStream
+  }
+
+  /**
+   * Starts stream without synchronization. {@code listener} should be same instance as {@link
+   * #listener}.
+   */
+  private void internalStart(ClientStreamListener listener) {
+    for (Runnable runnable : preStartPendingCalls) {
+      runnable.run();
     }
+    preStartPendingCalls = null;
+    realStream.start(listener);
   }
 
   @Override
   public Attributes getAttributes() {
-    checkState(passThrough, "Called getAttributes before attributes are ready");
-    return realStream.getAttributes();
+    ClientStream savedRealStream;
+    synchronized (this) {
+      savedRealStream = realStream;
+    }
+    if (savedRealStream != null) {
+      return savedRealStream.getAttributes();
+    } else {
+      return Attributes.EMPTY;
+    }
   }
 
   @Override
   public void writeMessage(final InputStream message) {
+    checkState(listener != null, "May only be called after start");
     checkNotNull(message, "message");
     if (passThrough) {
       realStream.writeMessage(message);
@@ -238,6 +298,7 @@ public void run() {
 
   @Override
   public void flush() {
+    checkState(listener != null, "May only be called after start");
     if (passThrough) {
       realStream.flush();
     } else {
@@ -253,17 +314,14 @@ public void run() {
   // When this method returns, passThrough is guaranteed to be true
   @Override
   public void cancel(final Status reason) {
+    checkState(listener != null, "May only be called after start");
     checkNotNull(reason, "reason");
     boolean delegateToRealStream = true;
-    ClientStreamListener listenerToClose = null;
     synchronized (this) {
       // If realStream != null, then either setStream() or cancel() has been called
       if (realStream == null) {
-        realStream = NoopClientStream.INSTANCE;
+        setRealStream(NoopClientStream.INSTANCE);
         delegateToRealStream = false;
-
-        // If listener == null, then start() will later call listener with 'error'
-        listenerToClose = listener;
         error = reason;
       }
     }
@@ -275,15 +333,26 @@ public void run() {
         }
       });
     } else {
-      if (listenerToClose != null) {
-        listenerToClose.closed(reason, new Metadata());
-      }
       drainPendingCalls();
+      onEarlyCancellation(reason);
+      // Note that listener is a DelayedStreamListener
+      listener.closed(reason, RpcProgress.PROCESSED, new Metadata());
     }
   }
 
+  protected void onEarlyCancellation(Status reason) {
+  }
+
+  @GuardedBy("this")
+  private void setRealStream(ClientStream realStream) {
+    checkState(this.realStream == null, "realStream already set to %s", this.realStream);
+    this.realStream = realStream;
+    streamSetTimeNanos = System.nanoTime();
+  }
+
   @Override
   public void halfClose() {
+    checkState(listener != null, "May only be called after start");
     delayOrExecute(new Runnable() {
       @Override
       public void run() {
@@ -294,6 +363,7 @@ public void run() {
 
   @Override
   public void request(final int numMessages) {
+    checkState(listener != null, "May only be called after start");
     if (passThrough) {
       realStream.request(numMessages);
     } else {
@@ -306,10 +376,22 @@ public void run() {
     }
   }
 
+  @Override
+  public void optimizeForDirectExecutor() {
+    checkState(listener == null, "May only be called before start");
+    preStartPendingCalls.add(new Runnable() {
+      @Override
+      public void run() {
+        realStream.optimizeForDirectExecutor();
+      }
+    });
+  }
+
   @Override
   public void setCompressor(final Compressor compressor) {
+    checkState(listener == null, "May only be called before start");
     checkNotNull(compressor, "compressor");
-    delayOrExecute(new Runnable() {
+    preStartPendingCalls.add(new Runnable() {
       @Override
       public void run() {
         realStream.setCompressor(compressor);
@@ -318,16 +400,27 @@ public void run() {
   }
 
   @Override
-  public void setDecompressor(Decompressor decompressor) {
-    checkNotNull(decompressor, "decompressor");
-    // This method being called only makes sense after setStream() has been called (but not
-    // necessarily returned), but there is not necessarily a happens-before relationship. This
-    // synchronized block creates one.
-    synchronized (this) { }
-    checkState(realStream != null, "How did we receive a reply before the request is sent?");
-    // ClientStreamListenerImpl (in ClientCallImpl) requires setDecompressor to be set immediately,
-    // since messages may be processed immediately after this method returns.
-    realStream.setDecompressor(decompressor);
+  public void setFullStreamDecompression(final boolean fullStreamDecompression) {
+    checkState(listener == null, "May only be called before start");
+    preStartPendingCalls.add(
+        new Runnable() {
+          @Override
+          public void run() {
+            realStream.setFullStreamDecompression(fullStreamDecompression);
+          }
+        });
+  }
+
+  @Override
+  public void setDecompressorRegistry(final DecompressorRegistry decompressorRegistry) {
+    checkState(listener == null, "May only be called before start");
+    checkNotNull(decompressorRegistry, "decompressorRegistry");
+    preStartPendingCalls.add(new Runnable() {
+      @Override
+      public void run() {
+        realStream.setDecompressorRegistry(decompressorRegistry);
+      }
+    });
   }
 
   @Override
@@ -341,6 +434,7 @@ public boolean isReady() {
 
   @Override
   public void setMessageCompression(final boolean enable) {
+    checkState(listener != null, "May only be called after start");
     if (passThrough) {
       realStream.setMessageCompression(enable);
     } else {
@@ -362,7 +456,7 @@ private static class DelayedStreamListener implements ClientStreamListener {
     private final ClientStreamListener realListener;
     private volatile boolean passThrough;
     @GuardedBy("this")
-    private List<Runnable> pendingCallbacks = new ArrayList<Runnable>();
+    private List<Runnable> pendingCallbacks = new ArrayList<>();
 
     public DelayedStreamListener(ClientStreamListener listener) {
       this.realListener = listener;
@@ -379,14 +473,14 @@ private void delayOrExecute(Runnable runnable) {
     }
 
     @Override
-    public void messageRead(final InputStream message) {
+    public void messagesAvailable(final MessageProducer producer) {
       if (passThrough) {
-        realListener.messageRead(message);
+        realListener.messagesAvailable(producer);
       } else {
         delayOrExecute(new Runnable() {
           @Override
           public void run() {
-            realListener.messageRead(message);
+            realListener.messagesAvailable(producer);
           }
         });
       }
@@ -417,18 +511,20 @@ public void run() {
     }
 
     @Override
-    public void closed(final Status status, final Metadata trailers) {
+    public void closed(
+        final Status status, final RpcProgress rpcProgress,
+        final Metadata trailers) {
       delayOrExecute(new Runnable() {
         @Override
         public void run() {
-          realListener.closed(status, trailers);
+          realListener.closed(status, rpcProgress, trailers);
         }
       });
     }
 
     public void drainPendingCallbacks() {
       assert !passThrough;
-      List<Runnable> toRun = new ArrayList<Runnable>();
+      List<Runnable> toRun = new ArrayList<>();
       while (true) {
         synchronized (this) {
           if (pendingCallbacks.isEmpty()) {
diff --git a/core/src/main/java/io/grpc/internal/DisconnectError.java b/core/src/main/java/io/grpc/internal/DisconnectError.java
new file mode 100644
index 00000000000..771024f106e
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/DisconnectError.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2025 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.internal;
+
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * Represents the reason for a subchannel disconnection.
+ * Implementations are either the SimpleDisconnectError enum or the GoAwayDisconnectError class for
+ * dynamic ones.
+ */
+@Immutable
+public interface DisconnectError {
+  /**
+   * Returns the string representation suitable for use as an error tag.
+   *
+   * @return The formatted error tag string.
+   */
+  String toErrorString();
+}
diff --git a/core/src/main/java/io/grpc/internal/DnsNameResolver.java b/core/src/main/java/io/grpc/internal/DnsNameResolver.java
index c2dfa41e41c..dacbe291b6b 100644
--- a/core/src/main/java/io/grpc/internal/DnsNameResolver.java
+++ b/core/src/main/java/io/grpc/internal/DnsNameResolver.java
@@ -1,228 +1,739 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
 import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Verify;
+import com.google.common.base.VerifyException;
 import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
 import io.grpc.NameResolver;
-import io.grpc.ResolvedServerInfo;
-import io.grpc.ResolvedServerInfoGroup;
+import io.grpc.ProxiedSocketAddress;
+import io.grpc.ProxyDetector;
 import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.SynchronizationContext;
 import io.grpc.internal.SharedResourceHolder.Resource;
+import java.io.IOException;
+import java.lang.reflect.Constructor;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.URI;
 import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * A DNS-based {@link NameResolver}.
  *
- * @see DnsNameResolverFactory
+ * <p>Each {@code A} or {@code AAAA} record emits an {@link EquivalentAddressGroup} in the list
+ * passed to {@link NameResolver.Listener2#onResult2(ResolutionResult)}.
+ *
+ * @see DnsNameResolverProvider
  */
-class DnsNameResolver extends NameResolver {
+public class DnsNameResolver extends NameResolver {
+
+  private static final Logger logger = Logger.getLogger(DnsNameResolver.class.getName());
+
+  private static final String SERVICE_CONFIG_CHOICE_CLIENT_LANGUAGE_KEY = "clientLanguage";
+  private static final String SERVICE_CONFIG_CHOICE_PERCENTAGE_KEY = "percentage";
+  private static final String SERVICE_CONFIG_CHOICE_CLIENT_HOSTNAME_KEY = "clientHostname";
+  private static final String SERVICE_CONFIG_CHOICE_SERVICE_CONFIG_KEY = "serviceConfig";
+
+  // From https://github.com/grpc/proposal/blob/master/A2-service-configs-in-dns.md
+  static final String SERVICE_CONFIG_PREFIX = "grpc_config=";
+  private static final Set<String> SERVICE_CONFIG_CHOICE_KEYS =
+      Collections.unmodifiableSet(
+          new HashSet<>(
+              Arrays.asList(
+                  SERVICE_CONFIG_CHOICE_CLIENT_LANGUAGE_KEY,
+                  SERVICE_CONFIG_CHOICE_PERCENTAGE_KEY,
+                  SERVICE_CONFIG_CHOICE_CLIENT_HOSTNAME_KEY,
+                  SERVICE_CONFIG_CHOICE_SERVICE_CONFIG_KEY)));
+
+  // From https://github.com/grpc/proposal/blob/master/A2-service-configs-in-dns.md
+  private static final String SERVICE_CONFIG_NAME_PREFIX = "_grpc_config.";
+
+  private static final String JNDI_PROPERTY =
+      System.getProperty("io.grpc.internal.DnsNameResolverProvider.enable_jndi", "true");
+  private static final String JNDI_LOCALHOST_PROPERTY =
+      System.getProperty("io.grpc.internal.DnsNameResolverProvider.enable_jndi_localhost", "false");
+  private static final String JNDI_TXT_PROPERTY =
+      System.getProperty("io.grpc.internal.DnsNameResolverProvider.enable_service_config", "false");
+
+  /**
+   * Java networking system properties name for caching DNS result.
+   *
+   * <p>Default value is -1 (cache forever) if security manager is installed. If security manager is
+   * not installed, the ttl value is {@code null} which falls back to {@link
+   * #DEFAULT_NETWORK_CACHE_TTL_SECONDS gRPC default value}.
+   *
+   * <p>For android, gRPC doesn't attempt to cache; this property value will be ignored.
+   */
+  @VisibleForTesting
+  static final String NETWORKADDRESS_CACHE_TTL_PROPERTY = "networkaddress.cache.ttl";
+  /** Default DNS cache duration if network cache ttl value is not specified ({@code null}). */
+  @VisibleForTesting
+  static final long DEFAULT_NETWORK_CACHE_TTL_SECONDS = 30;
+
+  @VisibleForTesting
+  static boolean enableJndi = Boolean.parseBoolean(JNDI_PROPERTY);
+  @VisibleForTesting
+  static boolean enableJndiLocalhost = Boolean.parseBoolean(JNDI_LOCALHOST_PROPERTY);
+  @VisibleForTesting
+  protected static boolean enableTxt = Boolean.parseBoolean(JNDI_TXT_PROPERTY);
+
+  private static final ResourceResolverFactory resourceResolverFactory =
+      getResourceResolverFactory(DnsNameResolver.class.getClassLoader());
+
+  @VisibleForTesting
+  final ProxyDetector proxyDetector;
+
+  /** Access through {@link #getLocalHostname}. */
+  private static String localHostname;
+
+  private final Random random = new Random();
+
+  protected volatile AddressResolver addressResolver = JdkAddressResolver.INSTANCE;
+  private final AtomicReference<ResourceResolver> resourceResolver = new AtomicReference<>();
+
   private final String authority;
   private final String host;
   private final int port;
-  private final Resource<ScheduledExecutorService> timerServiceResource;
-  private final Resource<ExecutorService> executorResource;
-  @GuardedBy("this")
+
+  private final ObjectPool<Executor> executorPool;
+  private final long cacheTtlNanos;
+  private final SynchronizationContext syncContext;
+  private final ServiceConfigParser serviceConfigParser;
+
+  // Following fields must be accessed from syncContext
+  private final Stopwatch stopwatch;
+  protected boolean resolved;
   private boolean shutdown;
-  @GuardedBy("this")
-  private ScheduledExecutorService timerService;
-  @GuardedBy("this")
-  private ExecutorService executor;
-  @GuardedBy("this")
-  private ScheduledFuture<?> resolutionTask;
-  @GuardedBy("this")
+  private Executor executor;
+
   private boolean resolving;
-  @GuardedBy("this")
-  private Listener listener;
 
-  DnsNameResolver(@Nullable String nsAuthority, String name, Attributes params,
-      Resource<ScheduledExecutorService> timerServiceResource,
-      Resource<ExecutorService> executorResource) {
+  // The field must be accessed from syncContext, although the methods on an Listener2 can be called
+  // from any thread.
+  private NameResolver.Listener2 listener;
+
+  protected DnsNameResolver(
+      @Nullable String nsAuthority,
+      String name,
+      Args args,
+      Resource<Executor> executorResource,
+      Stopwatch stopwatch,
+      boolean isAndroid) {
+    checkNotNull(args, "args");
     // TODO: if a DNS server is provided as nsAuthority, use it.
     // https://www.captechconsulting.com/blogs/accessing-the-dusty-corners-of-dns-with-java
 
-    this.timerServiceResource = timerServiceResource;
-    this.executorResource = executorResource;
     // Must prepend a "//" to the name when constructing a URI, otherwise it will be treated as an
     // opaque URI, thus the authority and host of the resulted URI would be null.
-    URI nameUri = URI.create("//" + name);
+    URI nameUri = URI.create("//" + checkNotNull(name, "name"));
+    Preconditions.checkArgument(nameUri.getHost() != null, "Invalid DNS name: %s", name);
     authority = Preconditions.checkNotNull(nameUri.getAuthority(),
         "nameUri (%s) doesn't have an authority", nameUri);
-    host = Preconditions.checkNotNull(nameUri.getHost(), "host");
+    host = nameUri.getHost();
     if (nameUri.getPort() == -1) {
-      Integer defaultPort = params.get(NameResolver.Factory.PARAMS_DEFAULT_PORT);
-      if (defaultPort != null) {
-        port = defaultPort;
-      } else {
-        throw new IllegalArgumentException(
-            "name '" + name + "' doesn't contain a port, and default port is not set in params");
-      }
+      port = args.getDefaultPort();
     } else {
       port = nameUri.getPort();
     }
+    this.proxyDetector = checkNotNull(args.getProxyDetector(), "proxyDetector");
+    Executor offloadExecutor = args.getOffloadExecutor();
+    if (offloadExecutor != null) {
+      this.executorPool = new FixedObjectPool<>(offloadExecutor);
+    } else {
+      this.executorPool = SharedResourcePool.forResource(executorResource);
+    }
+    this.cacheTtlNanos = getNetworkAddressCacheTtlNanos(isAndroid);
+    this.stopwatch = checkNotNull(stopwatch, "stopwatch");
+    this.syncContext = checkNotNull(args.getSynchronizationContext(), "syncContext");
+    this.serviceConfigParser = checkNotNull(args.getServiceConfigParser(), "serviceConfigParser");
   }
 
   @Override
-  public final String getServiceAuthority() {
+  public String getServiceAuthority() {
     return authority;
   }
 
+  @VisibleForTesting
+  protected String getHost() {
+    return host;
+  }
+
   @Override
-  public final synchronized void start(Listener listener) {
+  public void start(Listener2 listener) {
     Preconditions.checkState(this.listener == null, "already started");
-    timerService = SharedResourceHolder.get(timerServiceResource);
-    executor = SharedResourceHolder.get(executorResource);
-    this.listener = Preconditions.checkNotNull(listener, "listener");
+    executor = executorPool.getObject();
+    this.listener = checkNotNull(listener, "listener");
     resolve();
   }
 
   @Override
-  public final synchronized void refresh() {
+  public void refresh() {
     Preconditions.checkState(listener != null, "not started");
     resolve();
   }
 
-  private final Runnable resolutionRunnable = new Runnable() {
-      @Override
-      public void run() {
-        InetAddress[] inetAddrs;
-        Listener savedListener;
-        synchronized (DnsNameResolver.this) {
-          // If this task is started by refresh(), there might already be a scheduled task.
-          if (resolutionTask != null) {
-            resolutionTask.cancel(false);
-            resolutionTask = null;
+  private List<EquivalentAddressGroup> resolveAddresses() throws Exception {
+    List<? extends InetAddress> addresses = addressResolver.resolveAddress(host);
+    // Each address forms an EAG
+    List<EquivalentAddressGroup> servers = new ArrayList<>(addresses.size());
+    for (InetAddress inetAddr : addresses) {
+      servers.add(new EquivalentAddressGroup(new InetSocketAddress(inetAddr, port)));
+    }
+    return Collections.unmodifiableList(servers);
+  }
+
+  @Nullable
+  private ConfigOrError resolveServiceConfig() {
+    List<String> txtRecords = Collections.emptyList();
+    ResourceResolver resourceResolver = getResourceResolver();
+    if (resourceResolver != null) {
+      try {
+        txtRecords = resourceResolver.resolveTxt(SERVICE_CONFIG_NAME_PREFIX + host);
+      } catch (Exception e) {
+        logger.log(Level.FINE, "ServiceConfig resolution failure", e);
+      }
+    }
+    if (!txtRecords.isEmpty()) {
+      ConfigOrError rawServiceConfig = parseServiceConfig(txtRecords, random, getLocalHostname());
+      if (rawServiceConfig != null) {
+        if (rawServiceConfig.getError() != null) {
+          return ConfigOrError.fromError(rawServiceConfig.getError());
+        }
+
+        @SuppressWarnings("unchecked")
+        Map<String, ?> verifiedRawServiceConfig = (Map<String, ?>) rawServiceConfig.getConfig();
+        return serviceConfigParser.parseServiceConfig(verifiedRawServiceConfig);
+      }
+    } else {
+      logger.log(Level.FINE, "No TXT records found for {0}", new Object[]{host});
+    }
+    return null;
+  }
+
+  @Nullable
+  private EquivalentAddressGroup detectProxy() throws IOException {
+    InetSocketAddress destination =
+        InetSocketAddress.createUnresolved(host, port);
+    ProxiedSocketAddress proxiedAddr = proxyDetector.proxyFor(destination);
+    if (proxiedAddr != null) {
+      return new EquivalentAddressGroup(proxiedAddr);
+    }
+    return null;
+  }
+
+  /**
+   * Main logic of name resolution.
+   */
+  protected InternalResolutionResult doResolve(boolean forceTxt) {
+    InternalResolutionResult result = new InternalResolutionResult();
+    try {
+      result.addresses = resolveAddresses();
+    } catch (Exception e) {
+      logger.log(Level.FINE, "Address resolution failure", e);
+      if (!forceTxt) {
+        result.error =
+            Status.UNAVAILABLE.withDescription("Unable to resolve host " + host).withCause(e);
+        return result;
+      }
+    }
+    if (enableTxt) {
+      result.config = resolveServiceConfig();
+    }
+    return result;
+  }
+
+  private final class Resolve implements Runnable {
+    private final Listener2 savedListener;
+
+    Resolve(Listener2 savedListener) {
+      this.savedListener = checkNotNull(savedListener, "savedListener");
+    }
+
+    @Override
+    public void run() {
+      if (logger.isLoggable(Level.FINER)) {
+        logger.finer("Attempting DNS resolution of " + host);
+      }
+      InternalResolutionResult result = null;
+      try {
+        EquivalentAddressGroup proxiedAddr = detectProxy();
+        ResolutionResult.Builder resolutionResultBuilder = ResolutionResult.newBuilder();
+        if (proxiedAddr != null) {
+          if (logger.isLoggable(Level.FINER)) {
+            logger.finer("Using proxy address " + proxiedAddr);
           }
-          if (shutdown) {
+          resolutionResultBuilder.setAddressesOrError(
+              StatusOr.fromValue(Collections.singletonList(proxiedAddr)));
+        } else {
+          result = doResolve(false);
+          if (result.error != null) {
+            InternalResolutionResult finalResult = result;
+            syncContext.execute(() ->
+                savedListener.onResult2(ResolutionResult.newBuilder()
+                    .setAddressesOrError(StatusOr.fromStatus(finalResult.error))
+                    .build()));
             return;
           }
-          savedListener = listener;
-          resolving = true;
-        }
-        try {
-          if (System.getenv("GRPC_PROXY_EXP") != null) {
-            ResolvedServerInfoGroup servers = ResolvedServerInfoGroup.builder()
-                .add(new ResolvedServerInfo(
-                    InetSocketAddress.createUnresolved(host, port), Attributes.EMPTY))
-                .build();
-            savedListener.onUpdate(Collections.singletonList(servers), Attributes.EMPTY);
-            return;
+          if (result.addresses != null) {
+            resolutionResultBuilder.setAddressesOrError(StatusOr.fromValue(result.addresses));
           }
-
-          try {
-            inetAddrs = getAllByName(host);
-          } catch (UnknownHostException e) {
-            synchronized (DnsNameResolver.this) {
-              if (shutdown) {
-                return;
-              }
-              // Because timerService is the single-threaded GrpcUtil.TIMER_SERVICE in production,
-              // we need to delegate the blocking work to the executor
-              resolutionTask =
-                  timerService.schedule(new LogExceptionRunnable(resolutionRunnableOnExecutor),
-                      1, TimeUnit.MINUTES);
-            }
-            savedListener.onError(Status.UNAVAILABLE.withCause(e));
-            return;
+          if (result.config != null) {
+            resolutionResultBuilder.setServiceConfig(result.config);
           }
-          ResolvedServerInfoGroup.Builder servers = ResolvedServerInfoGroup.builder();
-          for (int i = 0; i < inetAddrs.length; i++) {
-            InetAddress inetAddr = inetAddrs[i];
-            servers.add(
-                new ResolvedServerInfo(new InetSocketAddress(inetAddr, port), Attributes.EMPTY));
+          if (result.attributes != null) {
+            resolutionResultBuilder.setAttributes(result.attributes);
           }
-          savedListener.onUpdate(Collections.singletonList(servers.build()), Attributes.EMPTY);
-        } finally {
-          synchronized (DnsNameResolver.this) {
+        }
+        syncContext.execute(() -> {
+          savedListener.onResult2(resolutionResultBuilder.build());
+        });
+      } catch (IOException e) {
+        syncContext.execute(() ->
+            savedListener.onResult2(ResolutionResult.newBuilder()
+                .setAddressesOrError(
+                    StatusOr.fromStatus(
+                        Status.UNAVAILABLE.withDescription(
+                            "Unable to resolve host " + host).withCause(e))).build()));
+      } finally {
+        final boolean succeed = result != null && result.error == null;
+        syncContext.execute(new Runnable() {
+          @Override
+          public void run() {
+            if (succeed) {
+              resolved = true;
+              if (cacheTtlNanos > 0) {
+                stopwatch.reset().start();
+              }
+            }
             resolving = false;
           }
-        }
+        });
       }
-    };
+    }
+  }
 
-  private final Runnable resolutionRunnableOnExecutor = new Runnable() {
-      @Override
-      public void run() {
-        synchronized (DnsNameResolver.this) {
-          if (!shutdown) {
-            executor.execute(resolutionRunnable);
-          }
-        }
+  @Nullable
+  static ConfigOrError parseServiceConfig(
+      List<String> rawTxtRecords, Random random, String localHostname) {
+    List<Map<String, ?>> possibleServiceConfigChoices;
+    try {
+      possibleServiceConfigChoices = parseTxtResults(rawTxtRecords);
+    } catch (IOException | RuntimeException e) {
+      return ConfigOrError.fromError(
+          Status.UNKNOWN.withDescription("failed to parse TXT records").withCause(e));
+    }
+    Map<String, ?> possibleServiceConfig = null;
+    for (Map<String, ?> possibleServiceConfigChoice : possibleServiceConfigChoices) {
+      try {
+        possibleServiceConfig =
+            maybeChooseServiceConfig(possibleServiceConfigChoice, random, localHostname);
+      } catch (RuntimeException e) {
+        return ConfigOrError.fromError(
+            Status.UNKNOWN.withDescription("failed to pick service config choice").withCause(e));
       }
-    };
-
-  // To be mocked out in tests
-  @VisibleForTesting
-  InetAddress[] getAllByName(String host) throws UnknownHostException {
-    return InetAddress.getAllByName(host);
+      if (possibleServiceConfig != null) {
+        break;
+      }
+    }
+    if (possibleServiceConfig == null) {
+      return null;
+    }
+    return ConfigOrError.fromConfig(possibleServiceConfig);
   }
 
-  @GuardedBy("this")
   private void resolve() {
-    if (resolving || shutdown) {
+    if (resolving || shutdown || !cacheRefreshRequired()) {
       return;
     }
-    executor.execute(resolutionRunnable);
+    resolving = true;
+    executor.execute(new Resolve(listener));
+  }
+
+  private boolean cacheRefreshRequired() {
+    return !resolved
+        || cacheTtlNanos == 0
+        || (cacheTtlNanos > 0 && stopwatch.elapsed(TimeUnit.NANOSECONDS) > cacheTtlNanos);
   }
 
   @Override
-  public final synchronized void shutdown() {
+  public void shutdown() {
     if (shutdown) {
       return;
     }
     shutdown = true;
-    if (resolutionTask != null) {
-      resolutionTask.cancel(false);
-    }
-    if (timerService != null) {
-      timerService = SharedResourceHolder.release(timerServiceResource, timerService);
-    }
     if (executor != null) {
-      executor = SharedResourceHolder.release(executorResource, executor);
+      executor = executorPool.returnObject(executor);
     }
   }
 
   final int getPort() {
     return port;
   }
+
+  /**
+   * Parse TXT service config records as JSON.
+   *
+   * @throws IOException if one of the txt records contains improperly formatted JSON.
+   */
+  @VisibleForTesting
+  static List<Map<String, ?>> parseTxtResults(List<String> txtRecords) throws IOException {
+    List<Map<String, ?>> possibleServiceConfigChoices = new ArrayList<>();
+    for (String txtRecord : txtRecords) {
+      if (!txtRecord.startsWith(SERVICE_CONFIG_PREFIX)) {
+        logger.log(Level.FINE, "Ignoring non service config {0}", new Object[]{txtRecord});
+        continue;
+      }
+      Object rawChoices = JsonParser.parse(txtRecord.substring(SERVICE_CONFIG_PREFIX.length()));
+      if (!(rawChoices instanceof List)) {
+        throw new ClassCastException("wrong type " + rawChoices);
+      }
+      List<?> listChoices = (List<?>) rawChoices;
+      possibleServiceConfigChoices.addAll(JsonUtil.checkObjectList(listChoices));
+    }
+    return possibleServiceConfigChoices;
+  }
+
+  @Nullable
+  private static final Double getPercentageFromChoice(Map<String, ?> serviceConfigChoice) {
+    return JsonUtil.getNumberAsDouble(serviceConfigChoice, SERVICE_CONFIG_CHOICE_PERCENTAGE_KEY);
+  }
+
+  @Nullable
+  private static final List<String> getClientLanguagesFromChoice(
+      Map<String, ?> serviceConfigChoice) {
+    return JsonUtil.getListOfStrings(
+        serviceConfigChoice, SERVICE_CONFIG_CHOICE_CLIENT_LANGUAGE_KEY);
+  }
+
+  @Nullable
+  private static final List<String> getHostnamesFromChoice(Map<String, ?> serviceConfigChoice) {
+    return JsonUtil.getListOfStrings(
+        serviceConfigChoice, SERVICE_CONFIG_CHOICE_CLIENT_HOSTNAME_KEY);
+  }
+
+  /**
+   * Returns value of network address cache ttl property if not Android environment. For android,
+   * DnsNameResolver does not cache the dns lookup result.
+   */
+  private static long getNetworkAddressCacheTtlNanos(boolean isAndroid) {
+    if (isAndroid) {
+      // on Android, ignore dns cache.
+      return 0;
+    }
+
+    String cacheTtlPropertyValue = System.getProperty(NETWORKADDRESS_CACHE_TTL_PROPERTY);
+    long cacheTtl = DEFAULT_NETWORK_CACHE_TTL_SECONDS;
+    if (cacheTtlPropertyValue != null) {
+      try {
+        cacheTtl = Long.parseLong(cacheTtlPropertyValue);
+      } catch (NumberFormatException e) {
+        logger.log(
+            Level.WARNING,
+            "Property({0}) valid is not valid number format({1}), fall back to default({2})",
+            new Object[] {NETWORKADDRESS_CACHE_TTL_PROPERTY, cacheTtlPropertyValue, cacheTtl});
+      }
+    }
+    return cacheTtl > 0 ? TimeUnit.SECONDS.toNanos(cacheTtl) : cacheTtl;
+  }
+
+  /**
+   * Determines if a given Service Config choice applies, and if so, returns it.
+   *
+   * @see <a href="https://github.com/grpc/proposal/blob/master/A2-service-configs-in-dns.md">
+   *     Service Config in DNS</a>
+   * @param choice The service config choice.
+   * @return The service config object or {@code null} if this choice does not apply.
+   */
+  @Nullable
+  @VisibleForTesting
+  static Map<String, ?> maybeChooseServiceConfig(
+      Map<String, ?> choice, Random random, String hostname) {
+    for (Map.Entry<String, ?> entry : choice.entrySet()) {
+      Verify.verify(SERVICE_CONFIG_CHOICE_KEYS.contains(entry.getKey()), "Bad key: %s", entry);
+    }
+
+    List<String> clientLanguages = getClientLanguagesFromChoice(choice);
+    if (clientLanguages != null && !clientLanguages.isEmpty()) {
+      boolean javaPresent = false;
+      for (String lang : clientLanguages) {
+        if ("java".equalsIgnoreCase(lang)) {
+          javaPresent = true;
+          break;
+        }
+      }
+      if (!javaPresent) {
+        return null;
+      }
+    }
+    Double percentage = getPercentageFromChoice(choice);
+    if (percentage != null) {
+      int pct = percentage.intValue();
+      Verify.verify(pct >= 0 && pct <= 100, "Bad percentage: %s", percentage);
+      if (random.nextInt(100) >= pct) {
+        return null;
+      }
+    }
+    List<String> clientHostnames = getHostnamesFromChoice(choice);
+    if (clientHostnames != null && !clientHostnames.isEmpty()) {
+      boolean hostnamePresent = false;
+      for (String clientHostname : clientHostnames) {
+        if (clientHostname.equals(hostname)) {
+          hostnamePresent = true;
+          break;
+        }
+      }
+      if (!hostnamePresent) {
+        return null;
+      }
+    }
+    Map<String, ?> sc =
+        JsonUtil.getObject(choice, SERVICE_CONFIG_CHOICE_SERVICE_CONFIG_KEY);
+    if (sc == null) {
+      throw new VerifyException(String.format(
+          "key '%s' missing in '%s'", choice, SERVICE_CONFIG_CHOICE_SERVICE_CONFIG_KEY));
+    }
+    return sc;
+  }
+
+  /**
+   * Used as a DNS-based name resolver's internal representation of resolution result.
+   */
+  protected static final class InternalResolutionResult {
+    private Status error;
+    private List<EquivalentAddressGroup> addresses;
+    private ConfigOrError config;
+    public Attributes attributes;
+
+    private InternalResolutionResult() {}
+  }
+
+  /**
+   * Describes a parsed SRV record.
+   */
+  @VisibleForTesting
+  public static final class SrvRecord {
+    public final String host;
+    public final int port;
+
+    public SrvRecord(String host, int port) {
+      this.host = host;
+      this.port = port;
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(host, port);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (this == obj) {
+        return true;
+      }
+      if (obj == null || getClass() != obj.getClass()) {
+        return false;
+      }
+      SrvRecord that = (SrvRecord) obj;
+      return port == that.port && host.equals(that.host);
+    }
+
+    @Override
+    public String toString() {
+      return
+          MoreObjects.toStringHelper(this)
+              .add("host", host)
+              .add("port", port)
+              .toString();
+    }
+  }
+
+  @VisibleForTesting
+  protected void setAddressResolver(AddressResolver addressResolver) {
+    this.addressResolver = addressResolver;
+  }
+
+  @VisibleForTesting
+  protected void setResourceResolver(ResourceResolver resourceResolver) {
+    this.resourceResolver.set(resourceResolver);
+  }
+
+  /**
+   * {@link ResourceResolverFactory} is a factory for making resource resolvers.  It supports
+   * optionally checking if the factory is available.
+   */
+  interface ResourceResolverFactory {
+
+    /**
+     * Creates a new resource resolver.  The return value is {@code null} iff
+     * {@link #unavailabilityCause()} is not null;
+     */
+    @Nullable ResourceResolver newResourceResolver();
+
+    /**
+     * Returns the reason why the resource resolver cannot be created.  The return value is
+     * {@code null} if {@link #newResourceResolver()} is suitable for use.
+     */
+    @Nullable Throwable unavailabilityCause();
+  }
+
+  /**
+   * AddressResolver resolves a hostname into a list of addresses.
+   */
+  @VisibleForTesting
+  public interface AddressResolver {
+    List<InetAddress> resolveAddress(String host) throws Exception;
+  }
+
+  private enum JdkAddressResolver implements AddressResolver {
+    INSTANCE;
+
+    @Override
+    public List<InetAddress> resolveAddress(String host) throws UnknownHostException {
+      return Collections.unmodifiableList(Arrays.asList(InetAddress.getAllByName(host)));
+    }
+  }
+
+  /**
+   * {@link ResourceResolver} is a Dns ResourceRecord resolver.
+   */
+  @VisibleForTesting
+  public interface ResourceResolver {
+    List<String> resolveTxt(String host) throws Exception;
+
+    List<SrvRecord> resolveSrv(String host) throws Exception;
+  }
+
+  @Nullable
+  protected ResourceResolver getResourceResolver() {
+    if (!shouldUseJndi(enableJndi, enableJndiLocalhost, host)) {
+      return null;
+    }
+    ResourceResolver rr;
+    if ((rr = resourceResolver.get()) == null) {
+      if (resourceResolverFactory != null) {
+        assert resourceResolverFactory.unavailabilityCause() == null;
+        rr = resourceResolverFactory.newResourceResolver();
+      }
+    }
+    return rr;
+  }
+
+  @Nullable
+  @VisibleForTesting
+  static ResourceResolverFactory getResourceResolverFactory(ClassLoader loader) {
+    Class<? extends ResourceResolverFactory> jndiClazz;
+    try {
+      jndiClazz =
+          Class.forName("io.grpc.internal.JndiResourceResolverFactory", true, loader)
+              .asSubclass(ResourceResolverFactory.class);
+    } catch (ClassNotFoundException e) {
+      logger.log(Level.FINE, "Unable to find JndiResourceResolverFactory, skipping.", e);
+      return null;
+    } catch (ClassCastException e) {
+      // This can happen if JndiResourceResolverFactory was removed by something like Proguard
+      // combined with a broken ClassLoader that prefers classes from the child over the parent
+      // while also not properly filtering dependencies in the parent that should be hidden. If the
+      // class loader prefers loading from the parent then ResourceresolverFactory would have also
+      // been loaded from the parent. If the class loader filtered deps, then
+      // JndiResourceResolverFactory wouldn't have been found.
+      logger.log(Level.FINE, "Unable to cast JndiResourceResolverFactory, skipping.", e);
+      return null;
+    }
+    Constructor<? extends ResourceResolverFactory> jndiCtor;
+    try {
+      jndiCtor = jndiClazz.getConstructor();
+    } catch (Exception e) {
+      logger.log(Level.FINE, "Can't find JndiResourceResolverFactory ctor, skipping.", e);
+      return null;
+    }
+    ResourceResolverFactory rrf;
+    try {
+      rrf = jndiCtor.newInstance();
+    } catch (Exception e) {
+      logger.log(Level.FINE, "Can't construct JndiResourceResolverFactory, skipping.", e);
+      return null;
+    }
+    if (rrf.unavailabilityCause() != null) {
+      logger.log(
+          Level.FINE,
+          "JndiResourceResolverFactory not available, skipping.",
+          rrf.unavailabilityCause());
+      return null;
+    }
+    return rrf;
+  }
+
+  private static String getLocalHostname() {
+    if (localHostname == null) {
+      try {
+        localHostname = InetAddress.getLocalHost().getHostName();
+      } catch (UnknownHostException e) {
+        throw new RuntimeException(e);
+      }
+    }
+    return localHostname;
+  }
+
+  @VisibleForTesting
+  protected static boolean shouldUseJndi(
+      boolean jndiEnabled, boolean jndiLocalhostEnabled, String target) {
+    if (!jndiEnabled) {
+      return false;
+    }
+    if ("localhost".equalsIgnoreCase(target)) {
+      return jndiLocalhostEnabled;
+    }
+    // Check if this name looks like IPv6
+    if (target.contains(":")) {
+      return false;
+    }
+    // Check if this might be IPv4.  Such addresses have no alphabetic characters.  This also
+    // checks the target is empty.
+    boolean alldigits = true;
+    for (int i = 0; i < target.length(); i++) {
+      char c = target.charAt(i);
+      if (c != '.') {
+        alldigits &= (c >= '0' && c <= '9');
+      }
+    }
+    return !alldigits;
+  }
 }
diff --git a/core/src/main/java/io/grpc/internal/DnsNameResolverProvider.java b/core/src/main/java/io/grpc/internal/DnsNameResolverProvider.java
index 35f96354f9b..14b56f1a12a 100644
--- a/core/src/main/java/io/grpc/internal/DnsNameResolverProvider.java
+++ b/core/src/main/java/io/grpc/internal/DnsNameResolverProvider.java
@@ -1,69 +1,94 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import com.google.common.base.Preconditions;
-import io.grpc.Attributes;
+import com.google.common.base.Stopwatch;
+import io.grpc.InternalServiceProviders;
+import io.grpc.NameResolver;
 import io.grpc.NameResolverProvider;
+import io.grpc.Uri;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
 import java.net.URI;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
 
 /**
  * A provider for {@link DnsNameResolver}.
  *
  * <p>It resolves a target URI whose scheme is {@code "dns"}. The (optional) authority of the target
- * URI is reserved for the address of alternative DNS server (not implemented yet). The path of the
- * target URI, excluding the leading slash {@code '/'}, is treated as the host name and the optional
- * port to be resolved by DNS. Example target URIs:
+ * URI is reserved for the address of alternative DNS server (not implemented yet). The target URI
+ * must be hierarchical and have exactly one path segment which will be interpreted as an RFC 2396
+ * "server-based" authority and used as the "service authority" of the resulting {@link
+ * NameResolver}. The "host" part of this authority is the name to be resolved by DNS. The "port"
+ * part of this authority (if present) will become the port number for all {@link InetSocketAddress}
+ * produced by this resolver. For example:
  *
  * <ul>
  *   <li>{@code "dns:///foo.googleapis.com:8080"} (using default DNS)</li>
  *   <li>{@code "dns://8.8.8.8/foo.googleapis.com:8080"} (using alternative DNS (not implemented
  *   yet))</li>
- *   <li>{@code "dns:///foo.googleapis.com"} (without port)</li>
+ *   <li>{@code "dns:///foo.googleapis.com"} (output addresses will have port {@link
+ *       NameResolver.Args#getDefaultPort()})</li>
  * </ul>
  */
 public final class DnsNameResolverProvider extends NameResolverProvider {
 
   private static final String SCHEME = "dns";
 
+  private static final boolean IS_ANDROID = InternalServiceProviders
+      .isAndroid(DnsNameResolverProvider.class.getClassLoader());
+
   @Override
-  public DnsNameResolver newNameResolver(URI targetUri, Attributes params) {
+  public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+    // TODO(jdcormie): Remove once RFC 3986 migration is complete.
     if (SCHEME.equals(targetUri.getScheme())) {
       String targetPath = Preconditions.checkNotNull(targetUri.getPath(), "targetPath");
       Preconditions.checkArgument(targetPath.startsWith("/"),
           "the path component (%s) of the target (%s) must start with '/'", targetPath, targetUri);
       String name = targetPath.substring(1);
-      return new DnsNameResolver(targetUri.getAuthority(), name, params, GrpcUtil.TIMER_SERVICE,
-          GrpcUtil.SHARED_CHANNEL_EXECUTOR);
+      return new DnsNameResolver(
+          targetUri.getAuthority(),
+          name,
+          args,
+          GrpcUtil.SHARED_CHANNEL_EXECUTOR,
+          Stopwatch.createUnstarted(),
+          IS_ANDROID);
+    } else {
+      return null;
+    }
+  }
+
+  @Override
+  public NameResolver newNameResolver(Uri targetUri, final NameResolver.Args args) {
+    if (SCHEME.equals(targetUri.getScheme())) {
+      List<String> pathSegments = targetUri.getPathSegments();
+      Preconditions.checkArgument(!pathSegments.isEmpty(),
+          "expected 1 path segment in target %s but found %s", targetUri, pathSegments);
+      String domainNameToResolve = pathSegments.get(0);
+      return new DnsNameResolver(
+          targetUri.getAuthority(),
+          domainNameToResolve,
+          args,
+          GrpcUtil.SHARED_CHANNEL_EXECUTOR,
+          Stopwatch.createUnstarted(),
+          IS_ANDROID);
     } else {
       return null;
     }
@@ -80,7 +105,12 @@ protected boolean isAvailable() {
   }
 
   @Override
-  protected int priority() {
+  public int priority() {
     return 5;
   }
+
+  @Override
+  public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+    return Collections.singleton(InetSocketAddress.class);
+  }
 }
diff --git a/core/src/main/java/io/grpc/internal/ExponentialBackoffPolicy.java b/core/src/main/java/io/grpc/internal/ExponentialBackoffPolicy.java
index 0ba320938c1..686fe859cdc 100644
--- a/core/src/main/java/io/grpc/internal/ExponentialBackoffPolicy.java
+++ b/core/src/main/java/io/grpc/internal/ExponentialBackoffPolicy.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -43,8 +28,8 @@
  *
  * <p>TODO(carl-mastrangelo): add unit tests for this class
  */
-final class ExponentialBackoffPolicy implements BackoffPolicy {
-  static final class Provider implements BackoffPolicy.Provider {
+public final class ExponentialBackoffPolicy implements BackoffPolicy {
+  public static final class Provider implements BackoffPolicy.Provider {
     @Override
     public BackoffPolicy get() {
       return new ExponentialBackoffPolicy();
@@ -52,19 +37,19 @@ public BackoffPolicy get() {
   }
 
   private Random random = new Random();
-  private long initialBackoffMillis = TimeUnit.SECONDS.toMillis(1);
-  private long maxBackoffMillis = TimeUnit.MINUTES.toMillis(2);
+  private long initialBackoffNanos = TimeUnit.SECONDS.toNanos(1);
+  private long maxBackoffNanos = TimeUnit.MINUTES.toNanos(2);
   private double multiplier = 1.6;
   private double jitter = .2;
 
-  private long nextBackoffMillis = initialBackoffMillis;
+  private long nextBackoffNanos = initialBackoffNanos;
 
   @Override
-  public long nextBackoffMillis() {
-    long currentBackoffMillis = nextBackoffMillis;
-    nextBackoffMillis = Math.min((long) (currentBackoffMillis * multiplier), maxBackoffMillis);
-    return currentBackoffMillis
-        + uniformRandom(-jitter * currentBackoffMillis, jitter * currentBackoffMillis);
+  public long nextBackoffNanos() {
+    long currentBackoffNanos = nextBackoffNanos;
+    nextBackoffNanos = Math.min((long) (currentBackoffNanos * multiplier), maxBackoffNanos);
+    return currentBackoffNanos
+        + uniformRandom(-jitter * currentBackoffNanos, jitter * currentBackoffNanos);
   }
 
   private long uniformRandom(double low, double high) {
@@ -85,14 +70,14 @@ ExponentialBackoffPolicy setRandom(Random random) {
   }
 
   @VisibleForTesting
-  ExponentialBackoffPolicy setInitialBackoffMillis(long initialBackoffMillis) {
-    this.initialBackoffMillis = initialBackoffMillis;
+  ExponentialBackoffPolicy setInitialBackoffNanos(long initialBackoffNanos) {
+    this.initialBackoffNanos = initialBackoffNanos;
     return this;
   }
 
   @VisibleForTesting
-  ExponentialBackoffPolicy setMaxBackoffMillis(long maxBackoffMillis) {
-    this.maxBackoffMillis = maxBackoffMillis;
+  ExponentialBackoffPolicy setMaxBackoffNanos(long maxBackoffNanos) {
+    this.maxBackoffNanos = maxBackoffNanos;
     return this;
   }
 
diff --git a/core/src/main/java/io/grpc/internal/FailingClientStream.java b/core/src/main/java/io/grpc/internal/FailingClientStream.java
index a076987d1b7..6388ef8b6ee 100644
--- a/core/src/main/java/io/grpc/internal/FailingClientStream.java
+++ b/core/src/main/java/io/grpc/internal/FailingClientStream.java
@@ -1,64 +1,73 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
+import io.grpc.ClientStreamTracer;
 import io.grpc.Metadata;
 import io.grpc.Status;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
 
 /**
  * An implementation of {@link ClientStream} that fails (by calling {@link
  * ClientStreamListener#closed}) when started, and silently does nothing for the other operations.
  */
-class FailingClientStream extends NoopClientStream {
+public final class FailingClientStream extends NoopClientStream {
   private boolean started;
   private final Status error;
+  private final RpcProgress rpcProgress;
+  private final ClientStreamTracer[] tracers;
 
   /**
    * Creates a {@code FailingClientStream} that would fail with the given error.
    */
-  public FailingClientStream(Status error) {
+  public FailingClientStream(Status error, ClientStreamTracer[] tracers) {
+    this(error, RpcProgress.PROCESSED, tracers);
+  }
+
+  /**
+   * Creates a {@code FailingClientStream} that would fail with the given error.
+   */
+  public FailingClientStream(
+      Status error, RpcProgress rpcProgress, ClientStreamTracer[] tracers) {
     Preconditions.checkArgument(!error.isOk(), "error must not be OK");
     this.error = error;
+    this.rpcProgress = rpcProgress;
+    this.tracers = tracers;
   }
 
   @Override
   public void start(ClientStreamListener listener) {
     Preconditions.checkState(!started, "already started");
     started = true;
-    listener.closed(error, new Metadata());
+    for (ClientStreamTracer tracer : tracers) {
+      tracer.streamClosed(error);
+    }
+    listener.closed(error, rpcProgress, new Metadata());
   }
 
+  @VisibleForTesting
   Status getError() {
     return error;
   }
+
+  @Override
+  public void appendTimeoutInsight(InsightBuilder insight) {
+    insight.appendKeyValue("error", error).appendKeyValue("progress", rpcProgress);
+  }
 }
diff --git a/core/src/main/java/io/grpc/internal/FailingClientTransport.java b/core/src/main/java/io/grpc/internal/FailingClientTransport.java
index e1d46d42cc4..37194c46a29 100644
--- a/core/src/main/java/io/grpc/internal/FailingClientTransport.java
+++ b/core/src/main/java/io/grpc/internal/FailingClientTransport.java
@@ -1,74 +1,74 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
 import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalLogId;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.Status;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
 import java.util.concurrent.Executor;
 
 /**
  * A client transport that creates streams that will immediately fail when started.
  */
 class FailingClientTransport implements ClientTransport {
-
   @VisibleForTesting
   final Status error;
+  private final RpcProgress rpcProgress;
 
-  FailingClientTransport(Status error) {
+  FailingClientTransport(Status error, RpcProgress rpcProgress) {
     Preconditions.checkArgument(!error.isOk(), "error must not be OK");
     this.error = error;
+    this.rpcProgress = rpcProgress;
   }
 
   @Override
-  public ClientStream newStream(MethodDescriptor<?, ?> method, Metadata headers,
-      CallOptions callOptions, StatsTraceContext statsTraceCtx) {
-    return new FailingClientStream(error);
-  }
-
-  @Override
-  public ClientStream newStream(MethodDescriptor<?, ?> method, Metadata headers) {
-    return newStream(method, headers, CallOptions.DEFAULT, StatsTraceContext.NOOP);
+  public ClientStream newStream(
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+      ClientStreamTracer[] tracers) {
+    return new FailingClientStream(error, rpcProgress, tracers);
   }
 
   @Override
   public void ping(final PingCallback callback, Executor executor) {
     executor.execute(new Runnable() {
         @Override public void run() {
-          callback.onFailure(error.asException());
+          callback.onFailure(error);
         }
       });
   }
+
+  @Override
+  public ListenableFuture<SocketStats> getStats() {
+    SettableFuture<SocketStats> ret = SettableFuture.create();
+    ret.set(null);
+    return ret;
+  }
+
+  @Override
+  public InternalLogId getLogId() {
+    throw new UnsupportedOperationException("Not a real transport");
+  }
 }
diff --git a/core/src/main/java/io/grpc/internal/FixedObjectPool.java b/core/src/main/java/io/grpc/internal/FixedObjectPool.java
new file mode 100644
index 00000000000..7ad6d46a50a
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/FixedObjectPool.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2017 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.internal;
+
+import com.google.common.base.Preconditions;
+
+/**
+ * An object pool that always returns the same instance and does nothing when returning the object.
+ */
+public final class FixedObjectPool<T> implements ObjectPool<T> {
+  private final T object;
+
+  public FixedObjectPool(T object) {
+    this.object = Preconditions.checkNotNull(object, "object");
+  }
+
+  @Override
+  public T getObject() {
+    return object;
+  }
+
+  @Override
+  public T returnObject(Object returned) {
+    return null;
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/FixedPickerLoadBalancerProvider.java b/core/src/main/java/io/grpc/internal/FixedPickerLoadBalancerProvider.java
new file mode 100644
index 00000000000..a632948bdb9
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/FixedPickerLoadBalancerProvider.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2026 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.internal;
+
+import static java.util.Objects.requireNonNull;
+
+import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.Status;
+
+/** A LB provider whose LB always uses the same picker. */
+final class FixedPickerLoadBalancerProvider extends LoadBalancerProvider {
+  private final ConnectivityState state;
+  private final LoadBalancer.SubchannelPicker picker;
+  private final Status acceptAddressesStatus;
+
+  public FixedPickerLoadBalancerProvider(
+      ConnectivityState state, LoadBalancer.SubchannelPicker picker, Status acceptAddressesStatus) {
+    this.state = requireNonNull(state, "state");
+    this.picker = requireNonNull(picker, "picker");
+    this.acceptAddressesStatus = requireNonNull(acceptAddressesStatus, "acceptAddressesStatus");
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return "fixed_picker_lb_internal";
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+    return new FixedPickerLoadBalancer(helper);
+  }
+
+  private final class FixedPickerLoadBalancer extends LoadBalancer {
+    private final Helper helper;
+
+    public FixedPickerLoadBalancer(Helper helper) {
+      this.helper = requireNonNull(helper, "helper");
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      helper.updateBalancingState(state, picker);
+      return acceptAddressesStatus;
+    }
+
+    @Override
+    public void handleNameResolutionError(Status error) {
+      helper.updateBalancingState(state, picker);
+    }
+
+    @Override
+    public void shutdown() {}
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ForwardingClientStream.java b/core/src/main/java/io/grpc/internal/ForwardingClientStream.java
new file mode 100644
index 00000000000..22719c9b341
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ForwardingClientStream.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2018 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.internal;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.Attributes;
+import io.grpc.Compressor;
+import io.grpc.Deadline;
+import io.grpc.DecompressorRegistry;
+import io.grpc.Status;
+import java.io.InputStream;
+
+abstract class ForwardingClientStream implements ClientStream {
+  protected abstract ClientStream delegate();
+
+  @Override
+  public void request(int numMessages) {
+    delegate().request(numMessages);
+  }
+
+  @Override
+  public void writeMessage(InputStream message) {
+    delegate().writeMessage(message);
+  }
+
+  @Override
+  public void flush() {
+    delegate().flush();
+  }
+
+  @Override
+  public boolean isReady() {
+    return delegate().isReady();
+  }
+
+  @Override
+  public void optimizeForDirectExecutor() {
+    delegate().optimizeForDirectExecutor();
+  }
+
+  @Override
+  public void setCompressor(Compressor compressor) {
+    delegate().setCompressor(compressor);
+  }
+
+  @Override
+  public void setMessageCompression(boolean enable) {
+    delegate().setMessageCompression(enable);
+  }
+
+  @Override
+  public void cancel(Status reason) {
+    delegate().cancel(reason);
+  }
+
+  @Override
+  public void halfClose() {
+    delegate().halfClose();
+  }
+
+  @Override
+  public void setAuthority(String authority) {
+    delegate().setAuthority(authority);
+  }
+
+  @Override
+  public void setFullStreamDecompression(boolean fullStreamDecompression) {
+    delegate().setFullStreamDecompression(fullStreamDecompression);
+  }
+
+  @Override
+  public void setDecompressorRegistry(DecompressorRegistry decompressorRegistry) {
+    delegate().setDecompressorRegistry(decompressorRegistry);
+  }
+
+  @Override
+  public void start(ClientStreamListener listener) {
+    delegate().start(listener);
+  }
+
+  @Override
+  public void setMaxInboundMessageSize(int maxSize) {
+    delegate().setMaxInboundMessageSize(maxSize);
+  }
+
+  @Override
+  public void setMaxOutboundMessageSize(int maxSize) {
+    delegate().setMaxOutboundMessageSize(maxSize);
+  }
+
+  @Override
+  public void setDeadline(Deadline deadline) {
+    delegate().setDeadline(deadline);
+  }
+
+  @Override
+  public Attributes getAttributes() {
+    return delegate().getAttributes();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+
+  @Override
+  public void appendTimeoutInsight(InsightBuilder insight) {
+    delegate().appendTimeoutInsight(insight);
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ForwardingClientStreamListener.java b/core/src/main/java/io/grpc/internal/ForwardingClientStreamListener.java
new file mode 100644
index 00000000000..904293b5bed
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ForwardingClientStreamListener.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2018 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.internal;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.Metadata;
+import io.grpc.Status;
+
+abstract class ForwardingClientStreamListener implements ClientStreamListener {
+
+  protected abstract ClientStreamListener delegate();
+
+  @Override
+  public void headersRead(Metadata headers) {
+    delegate().headersRead(headers);
+  }
+
+  @Override
+  public void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {
+    delegate().closed(status, rpcProgress, trailers);
+  }
+
+  @Override
+  public void messagesAvailable(MessageProducer producer) {
+    delegate().messagesAvailable(producer);
+  }
+
+  @Override
+  public void onReady() {
+    delegate().onReady();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ForwardingClientStreamTracer.java b/core/src/main/java/io/grpc/internal/ForwardingClientStreamTracer.java
new file mode 100644
index 00000000000..e7679ea14cc
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ForwardingClientStreamTracer.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2021 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.internal;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.Attributes;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Metadata;
+import io.grpc.Status;
+
+public abstract class ForwardingClientStreamTracer extends ClientStreamTracer {
+
+  /**
+   * Returns the underlying {@code ClientStreamTracer}.
+   */
+  protected abstract ClientStreamTracer delegate();
+
+  @Override
+  public void streamCreated(Attributes transportAttrs, Metadata headers) {
+    delegate().streamCreated(transportAttrs, headers);
+  }
+
+  @Override
+  public void createPendingStream() {
+    delegate().createPendingStream();
+  }
+
+  @Override
+  public void outboundHeaders() {
+    delegate().outboundHeaders();
+  }
+
+  @Override
+  public void inboundHeaders() {
+    delegate().inboundHeaders();
+  }
+
+  @Override
+  public void inboundHeaders(Metadata headers) {
+    delegate().inboundHeaders(headers);
+  }
+
+  @Override
+  public void inboundTrailers(Metadata trailers) {
+    delegate().inboundTrailers(trailers);
+  }
+
+  @Override
+  public void addOptionalLabel(String key, String value) {
+    delegate().addOptionalLabel(key, value);
+  }
+
+  @Override
+  public void streamClosed(Status status) {
+    delegate().streamClosed(status);
+  }
+
+  @Override
+  public void outboundMessage(int seqNo) {
+    delegate().outboundMessage(seqNo);
+  }
+
+  @Override
+  public void inboundMessage(int seqNo) {
+    delegate().inboundMessage(seqNo);
+  }
+
+  @Override
+  public void outboundMessageSent(int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+    delegate().outboundMessageSent(seqNo, optionalWireSize, optionalUncompressedSize);
+  }
+
+  @Override
+  public void inboundMessageRead(int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+    delegate().inboundMessageRead(seqNo, optionalWireSize, optionalUncompressedSize);
+  }
+
+  @Override
+  public void outboundWireSize(long bytes) {
+    delegate().outboundWireSize(bytes);
+  }
+
+  @Override
+  public void outboundUncompressedSize(long bytes) {
+    delegate().outboundUncompressedSize(bytes);
+  }
+
+  @Override
+  public void inboundWireSize(long bytes) {
+    delegate().inboundWireSize(bytes);
+  }
+
+  @Override
+  public void inboundUncompressedSize(long bytes) {
+    delegate().inboundUncompressedSize(bytes);
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ForwardingConnectionClientTransport.java b/core/src/main/java/io/grpc/internal/ForwardingConnectionClientTransport.java
index ab52e055636..bfdccbe5d6a 100644
--- a/core/src/main/java/io/grpc/internal/ForwardingConnectionClientTransport.java
+++ b/core/src/main/java/io/grpc/internal/ForwardingConnectionClientTransport.java
@@ -1,38 +1,28 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import com.google.common.base.MoreObjects;
+import com.google.common.util.concurrent.ListenableFuture;
 import io.grpc.Attributes;
 import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalLogId;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.Status;
@@ -45,8 +35,8 @@ public Runnable start(Listener listener) {
   }
 
   @Override
-  public void shutdown() {
-    delegate().shutdown();
+  public void shutdown(Status status) {
+    delegate().shutdown(status);
   }
 
   @Override
@@ -57,13 +47,8 @@ public void shutdownNow(Status status) {
   @Override
   public ClientStream newStream(
       MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
-      StatsTraceContext statsTraceCtx) {
-    return delegate().newStream(method, headers, callOptions, statsTraceCtx);
-  }
-
-  @Override
-  public ClientStream newStream(MethodDescriptor<?, ?> method, Metadata headers) {
-    return delegate().newStream(method, headers);
+      ClientStreamTracer[] tracers) {
+    return delegate().newStream(method, headers, callOptions, tracers);
   }
 
   @Override
@@ -72,7 +57,7 @@ public void ping(PingCallback callback, Executor executor) {
   }
 
   @Override
-  public LogId getLogId() {
+  public InternalLogId getLogId() {
     return delegate().getLogId();
   }
 
@@ -83,7 +68,12 @@ public Attributes getAttributes() {
 
   @Override
   public String toString() {
-    return getClass().getSimpleName() + "[" + delegate().toString() + "]";
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+
+  @Override
+  public ListenableFuture<SocketStats> getStats() {
+    return delegate().getStats();
   }
 
   protected abstract ConnectionClientTransport delegate();
diff --git a/core/src/main/java/io/grpc/internal/ForwardingDeframerListener.java b/core/src/main/java/io/grpc/internal/ForwardingDeframerListener.java
new file mode 100644
index 00000000000..5b67818ebc9
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ForwardingDeframerListener.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2019 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.internal;
+
+/**
+ * Forwards listener callbacks to a delegate.
+ */
+abstract class ForwardingDeframerListener implements MessageDeframer.Listener {
+  protected abstract MessageDeframer.Listener delegate();
+
+  @Override
+  public void bytesRead(int numBytes) {
+    delegate().bytesRead(numBytes);
+  }
+
+  @Override
+  public void messagesAvailable(StreamListener.MessageProducer producer) {
+    delegate().messagesAvailable(producer);
+  }
+
+  @Override
+  public void deframerClosed(boolean hasPartialMessage) {
+    delegate().deframerClosed(hasPartialMessage);
+  }
+
+  @Override
+  public void deframeFailed(Throwable cause) {
+    delegate().deframeFailed(cause);
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ForwardingManagedChannel.java b/core/src/main/java/io/grpc/internal/ForwardingManagedChannel.java
new file mode 100644
index 00000000000..7ef4ce42e97
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ForwardingManagedChannel.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2018 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.internal;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.CallOptions;
+import io.grpc.ClientCall;
+import io.grpc.ConnectivityState;
+import io.grpc.ManagedChannel;
+import io.grpc.MethodDescriptor;
+import java.util.concurrent.TimeUnit;
+
+abstract class ForwardingManagedChannel extends ManagedChannel {
+
+  private final ManagedChannel delegate;
+
+  ForwardingManagedChannel(ManagedChannel delegate) {
+    this.delegate = delegate;
+  }
+
+  @Override
+  public ManagedChannel shutdown() {
+    return delegate.shutdown();
+  }
+
+  @Override
+  public boolean isShutdown() {
+    return delegate.isShutdown();
+  }
+
+  @Override
+  public boolean isTerminated() {
+    return delegate.isTerminated();
+  }
+
+  @Override
+  public ManagedChannel shutdownNow() {
+    return delegate.shutdownNow();
+  }
+
+  @Override
+  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+    return delegate.awaitTermination(timeout, unit);
+  }
+
+  @Override
+  public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+      MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+    return delegate.newCall(methodDescriptor, callOptions);
+  }
+
+  @Override
+  public String authority() {
+    return delegate.authority();
+  }
+
+  @Override
+  public ConnectivityState getState(boolean requestConnection) {
+    return delegate.getState(requestConnection);
+  }
+
+  @Override
+  public void notifyWhenStateChanged(ConnectivityState source, Runnable callback) {
+    delegate.notifyWhenStateChanged(source, callback);
+  }
+
+  @Override
+  public void resetConnectBackoff() {
+    delegate.resetConnectBackoff();
+  }
+
+  @Override
+  public void enterIdle() {
+    delegate.enterIdle();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate).toString();
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ForwardingNameResolver.java b/core/src/main/java/io/grpc/internal/ForwardingNameResolver.java
new file mode 100644
index 00000000000..19cf05d9037
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ForwardingNameResolver.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.NameResolver;
+
+/**
+* A forwarding class to ensure non overridden methods are forwarded to the delegate.
+ */
+abstract class ForwardingNameResolver extends NameResolver {
+  private final NameResolver delegate;
+
+  ForwardingNameResolver(NameResolver delegate) {
+    checkNotNull(delegate, "delegate can not be null");
+    this.delegate = delegate;
+  }
+
+  @Override
+  public String getServiceAuthority() {
+    return delegate.getServiceAuthority();
+  }
+
+  @Override
+  @Deprecated
+  public void start(Listener listener) {
+    delegate.start(listener);
+  }
+
+  @Override
+  public void start(Listener2 listener) {
+    delegate.start(listener);
+  }
+
+  @Override
+  public void shutdown() {
+    delegate.shutdown();
+  }
+
+  @Override
+  public void refresh() {
+    delegate.refresh();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate).toString();
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ForwardingReadableBuffer.java b/core/src/main/java/io/grpc/internal/ForwardingReadableBuffer.java
index 338890017b8..7e690309647 100644
--- a/core/src/main/java/io/grpc/internal/ForwardingReadableBuffer.java
+++ b/core/src/main/java/io/grpc/internal/ForwardingReadableBuffer.java
@@ -1,40 +1,27 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import com.google.common.base.MoreObjects;
 import com.google.common.base.Preconditions;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.ByteBuffer;
+import javax.annotation.Nullable;
 
 /**
  * Base class for a wrapper around another {@link ReadableBuffer}.
@@ -51,7 +38,7 @@ public abstract class ForwardingReadableBuffer implements ReadableBuffer {
    *
    * @param buf the underlying buffer
    */
-  public ForwardingReadableBuffer(ReadableBuffer buf) {
+  protected ForwardingReadableBuffer(ReadableBuffer buf) {
     this.buf = Preconditions.checkNotNull(buf, "buf");
   }
 
@@ -65,16 +52,6 @@ public int readUnsignedByte() {
     return buf.readUnsignedByte();
   }
 
-  @Override
-  public int readUnsignedMedium() {
-    return buf.readUnsignedMedium();
-  }
-
-  @Override
-  public int readUnsignedShort() {
-    return buf.readUnsignedShort();
-  }
-
   @Override
   public int readInt() {
     return buf.readInt();
@@ -90,11 +67,6 @@ public void readBytes(byte[] dest, int destOffset, int length) {
     buf.readBytes(dest, destOffset, length);
   }
 
-  @Override
-  public void readBytes(ByteBuffer dest) {
-    buf.readBytes(dest);
-  }
-
   @Override
   public void readBytes(OutputStream dest, int length) throws IOException {
     buf.readBytes(dest, length);
@@ -120,8 +92,44 @@ public int arrayOffset() {
     return buf.arrayOffset();
   }
 
+  @Override
+  public void touch() {
+    buf.touch();
+  }
+
+  @Override
+  public boolean markSupported() {
+    return buf.markSupported();
+  }
+
+  @Override
+  public void mark() {
+    buf.mark();
+  }
+
+  @Override
+  public void reset() {
+    buf.reset();
+  }
+
+  @Override
+  public boolean byteBufferSupported() {
+    return buf.byteBufferSupported();
+  }
+
+  @Nullable
+  @Override
+  public ByteBuffer getByteBuffer() {
+    return buf.getByteBuffer();
+  }
+
   @Override
   public void close() {
     buf.close();
   }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", buf).toString();
+  }
 }
diff --git a/core/src/main/java/io/grpc/internal/Framer.java b/core/src/main/java/io/grpc/internal/Framer.java
new file mode 100644
index 00000000000..3cb341e42e3
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/Framer.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2017 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.internal;
+
+import io.grpc.Compressor;
+import java.io.InputStream;
+
+/** Interface for framing gRPC messages. */
+public interface Framer {
+  /**
+   * Writes out a payload message.
+   *
+   * @param message contains the message to be written out. It will be completely consumed.
+   */
+  void writePayload(InputStream message);
+
+  /** Flush the buffered payload. */
+  void flush();
+
+  /** Returns whether the framer is closed. */
+  boolean isClosed();
+
+  /** Closes, with flush. */
+  void close();
+
+  /** Closes, without flush. */
+  void dispose();
+
+  /** Enable or disable compression. */
+  Framer setMessageCompression(boolean enable);
+
+  /** Set the compressor used for compression. */
+  Framer setCompressor(Compressor compressor);
+
+  /** Set a size limit for each outbound message. */ 
+  void setMaxOutboundMessageSize(int maxSize);
+}
diff --git a/core/src/main/java/io/grpc/internal/GoAwayDisconnectError.java b/core/src/main/java/io/grpc/internal/GoAwayDisconnectError.java
new file mode 100644
index 00000000000..20c8c709932
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/GoAwayDisconnectError.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2025 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.internal;
+
+
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * Represents a dynamic disconnection due to an HTTP/2 GOAWAY frame.
+ * This class is immutable and holds the specific error code from the frame.
+ */
+@Immutable
+public final class GoAwayDisconnectError implements DisconnectError {
+  private static final String ERROR_TAG = "GOAWAY";
+  private final GrpcUtil.Http2Error errorCode;
+
+  /**
+   * Creates a GoAway reason.
+   *
+   * @param errorCode The specific, non-null HTTP/2 error code (e.g., "NO_ERROR").
+   */
+  public GoAwayDisconnectError(GrpcUtil.Http2Error errorCode) {
+    if (errorCode == null) {
+      throw new NullPointerException("Http2Error cannot be null for GOAWAY");
+    }
+    this.errorCode = errorCode;
+  }
+
+  @Override
+  public String toErrorString() {
+    return ERROR_TAG + " " + errorCode.name();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    GoAwayDisconnectError goAwayDisconnectError = (GoAwayDisconnectError) o;
+    return errorCode == goAwayDisconnectError.errorCode;
+  }
+
+  @Override
+  public int hashCode() {
+    return errorCode.hashCode();
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/GrpcAttributes.java b/core/src/main/java/io/grpc/internal/GrpcAttributes.java
new file mode 100644
index 00000000000..f95f9b9dab8
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/GrpcAttributes.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2017 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.internal;
+
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.Grpc;
+import io.grpc.SecurityLevel;
+
+/**
+ * Special attributes that are only useful to gRPC.
+ */
+public final class GrpcAttributes {
+  /**
+   * The security level of the transport.  If it's not present, {@link SecurityLevel#NONE} should be
+   * assumed.
+   */
+  @Grpc.TransportAttr
+  public static final Attributes.Key<SecurityLevel> ATTR_SECURITY_LEVEL =
+      Attributes.Key.create("io.grpc.internal.GrpcAttributes.securityLevel");
+
+  /**
+   * Attribute key for the attributes of the {@link EquivalentAddressGroup} ({@link
+   * EquivalentAddressGroup#getAttributes}) that the transport's server address is from.  This is a
+   * client-side-only transport attribute, and available right after the transport is started.
+   */
+  @Grpc.TransportAttr
+  public static final Attributes.Key<Attributes> ATTR_CLIENT_EAG_ATTRS =
+      Attributes.Key.create("io.grpc.internal.GrpcAttributes.clientEagAttrs");
+
+  public static final Attributes.Key<AuthorityVerifier> ATTR_AUTHORITY_VERIFIER =
+          Attributes.Key.create("io.grpc.internal.GrpcAttributes.authorityVerifier");
+
+  private GrpcAttributes() {}
+}
diff --git a/core/src/main/java/io/grpc/internal/GrpcUtil.java b/core/src/main/java/io/grpc/internal/GrpcUtil.java
index c078f17ca17..d8d0c1b2dc5 100644
--- a/core/src/main/java/io/grpc/internal/GrpcUtil.java
+++ b/core/src/main/java/io/grpc/internal/GrpcUtil.java
@@ -1,71 +1,97 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Objects;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Splitter;
 import com.google.common.base.Stopwatch;
+import com.google.common.base.Strings;
 import com.google.common.base.Supplier;
-import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.Subchannel;
+import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ClientStreamTracer.StreamInfo;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalLogId;
+import io.grpc.InternalMetadata;
+import io.grpc.InternalMetadata.TrustedAsciiMarshaller;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.Subchannel;
 import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ProxiedSocketAddress;
+import io.grpc.ProxyDetector;
 import io.grpc.Status;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
 import io.grpc.internal.SharedResourceHolder.Resource;
+import io.grpc.internal.StreamListener.MessageProducer;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
 import java.lang.reflect.Method;
 import java.net.HttpURLConnection;
+import java.net.SocketAddress;
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
 
 /**
  * Common utilities for GRPC.
  */
 public final class GrpcUtil {
 
-  // Certain production AppEngine runtimes have constraints on threading and socket handling
-  // that need to be accommodated.
-  public static final boolean IS_RESTRICTED_APPENGINE =
-      "Production".equals(System.getProperty("com.google.appengine.runtime.environment"))
-          && "1.7".equals(System.getProperty("java.specification.version"));
+  private static final Logger log = Logger.getLogger(GrpcUtil.class.getName());
+
+  private static final Set<Status.Code> INAPPROPRIATE_CONTROL_PLANE_STATUS
+      = Collections.unmodifiableSet(EnumSet.of(
+          Status.Code.OK,
+          Status.Code.INVALID_ARGUMENT,
+          Status.Code.NOT_FOUND,
+          Status.Code.ALREADY_EXISTS,
+          Status.Code.FAILED_PRECONDITION,
+          Status.Code.ABORTED,
+          Status.Code.OUT_OF_RANGE,
+          Status.Code.DATA_LOSS));
+
+  public static final Charset US_ASCII = Charset.forName("US-ASCII");
 
   /**
    * {@link io.grpc.Metadata.Key} for the timeout header.
@@ -82,8 +108,35 @@ public final class GrpcUtil {
   /**
    * {@link io.grpc.Metadata.Key} for the accepted message encodings header.
    */
-  public static final Metadata.Key<String> MESSAGE_ACCEPT_ENCODING_KEY =
-          Metadata.Key.of(GrpcUtil.MESSAGE_ACCEPT_ENCODING, Metadata.ASCII_STRING_MARSHALLER);
+  public static final Metadata.Key<byte[]> MESSAGE_ACCEPT_ENCODING_KEY =
+      InternalMetadata.keyOf(GrpcUtil.MESSAGE_ACCEPT_ENCODING, new AcceptEncodingMarshaller());
+
+  /**
+   * {@link io.grpc.Metadata.Key} for the stream's content encoding header.
+   */
+  public static final Metadata.Key<String> CONTENT_ENCODING_KEY =
+      Metadata.Key.of(GrpcUtil.CONTENT_ENCODING, Metadata.ASCII_STRING_MARSHALLER);
+
+  /**
+   * {@link io.grpc.Metadata.Key} for the stream's accepted content encoding header.
+   */
+  public static final Metadata.Key<byte[]> CONTENT_ACCEPT_ENCODING_KEY =
+      InternalMetadata.keyOf(GrpcUtil.CONTENT_ACCEPT_ENCODING, new AcceptEncodingMarshaller());
+
+  static final Metadata.Key<String> CONTENT_LENGTH_KEY =
+      Metadata.Key.of("content-length", Metadata.ASCII_STRING_MARSHALLER);
+
+  private static final class AcceptEncodingMarshaller implements TrustedAsciiMarshaller<byte[]> {
+    @Override
+    public byte[] toAsciiString(byte[] value) {
+      return value;
+    }
+
+    @Override
+    public byte[] parseAsciiString(byte[] serialized) {
+      return serialized;
+    }
+  }
 
   /**
    * {@link io.grpc.Metadata.Key} for the Content-Type request/response header.
@@ -91,6 +144,12 @@ public final class GrpcUtil {
   public static final Metadata.Key<String> CONTENT_TYPE_KEY =
           Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER);
 
+  /**
+   * {@link io.grpc.Metadata.Key} for the Transfer encoding.
+   */
+  public static final Metadata.Key<String> TE_HEADER =
+      Metadata.Key.of("te", Metadata.ASCII_STRING_MARSHALLER);
+
   /**
    * {@link io.grpc.Metadata.Key} for the Content-Type request/response header.
    */
@@ -137,6 +196,16 @@ public final class GrpcUtil {
    */
   public static final String MESSAGE_ACCEPT_ENCODING = "grpc-accept-encoding";
 
+  /**
+   * The content-encoding used to compress the full gRPC stream.
+   */
+  public static final String CONTENT_ENCODING = "content-encoding";
+
+  /**
+   * The accepted content-encodings that can be used to compress the full gRPC stream.
+   */
+  public static final String CONTENT_ACCEPT_ENCODING = "accept-encoding";
+
   /**
    * The default maximum uncompressed size (in bytes) for inbound messages. Defaults to 4 MiB.
    */
@@ -145,21 +214,76 @@ public final class GrpcUtil {
   /**
    * The default maximum size (in bytes) for inbound header/trailer.
    */
+  // Update documentation in public-facing Builders when changing this value.
   public static final int DEFAULT_MAX_HEADER_LIST_SIZE = 8192;
 
   public static final Splitter ACCEPT_ENCODING_SPLITTER = Splitter.on(',').trimResults();
 
-  private static final String IMPLEMENTATION_VERSION = getImplementationVersion();
+  public static final String IMPLEMENTATION_VERSION = "1.80.0-SNAPSHOT"; // CURRENT_GRPC_VERSION
 
   /**
-   * The default delay in nanos before we send a keepalive.
+   * The default timeout in nanos for a keepalive ping request.
    */
-  public static final long DEFAULT_KEEPALIVE_DELAY_NANOS = TimeUnit.MINUTES.toNanos(1);
+  public static final long DEFAULT_KEEPALIVE_TIMEOUT_NANOS = TimeUnit.SECONDS.toNanos(20L);
 
   /**
-   * The default timeout in nanos for a keepalive ping request.
+   * The magic keepalive time value that disables client keepalive.
    */
-  public static final long DEFAULT_KEEPALIVE_TIMEOUT_NANOS = TimeUnit.MINUTES.toNanos(2);
+  public static final long KEEPALIVE_TIME_NANOS_DISABLED = Long.MAX_VALUE;
+
+  /**
+   * The default delay in nanos for server keepalive.
+   */
+  public static final long DEFAULT_SERVER_KEEPALIVE_TIME_NANOS = TimeUnit.HOURS.toNanos(2L);
+
+  /**
+   * The default timeout in nanos for a server keepalive ping request.
+   */
+  public static final long DEFAULT_SERVER_KEEPALIVE_TIMEOUT_NANOS = TimeUnit.SECONDS.toNanos(20L);
+
+  /**
+   * The magic keepalive time value that disables keepalive.
+   */
+  public static final long SERVER_KEEPALIVE_TIME_NANOS_DISABLED = Long.MAX_VALUE;
+
+  /**
+   * The default proxy detector.
+   */
+  public static final ProxyDetector DEFAULT_PROXY_DETECTOR = new ProxyDetectorImpl();
+
+  /**
+   * A proxy detector that always claims no proxy is needed.
+   */
+  public static final ProxyDetector NOOP_PROXY_DETECTOR = new ProxyDetector() {
+    @Nullable
+    @Override
+    public ProxiedSocketAddress proxyFor(SocketAddress targetServerAddress) {
+      return null;
+    }
+  };
+
+  /**
+   * The very default load-balancing policy.
+   */
+  public static final String DEFAULT_LB_POLICY = "pick_first";
+
+  /**
+   * RPCs created on the Channel returned by {@link io.grpc.LoadBalancer.Subchannel#asChannel}
+   * will have this option with value {@code true}.  They will be treated differently from
+   * the ones created by application.
+   */
+  public static final CallOptions.Key<Boolean> CALL_OPTIONS_RPC_OWNED_BY_BALANCER =
+      CallOptions.Key.create("io.grpc.internal.CALL_OPTIONS_RPC_OWNED_BY_BALANCER");
+
+  private static final ClientStreamTracer NOOP_TRACER = new ClientStreamTracer() {};
+
+  /**
+   * Returns true if an RPC with the given properties should be counted when calculating the
+   * in-use state of a transport.
+   */
+  public static boolean shouldBeCountedForInUse(CallOptions callOptions) {
+    return !Boolean.TRUE.equals(callOptions.getOption(CALL_OPTIONS_RPC_OWNED_BY_BALANCER));
+  }
 
   /**
    * Maps HTTP error response status codes to transport codes, as defined in <a
@@ -238,11 +362,18 @@ private static Http2Error[] buildHttp2CodeMap() {
     }
 
     private final int code;
+    // Status is not guaranteed to be deeply immutable. Don't care though, since that's only true
+    // when there are exceptions in the Status, which is not true here.
+    @SuppressWarnings("ImmutableEnumChecker")
     private final Status status;
 
     Http2Error(int code, Status status) {
       this.code = code;
-      this.status = status.augmentDescription("HTTP/2 error code: " + this.name());
+      String description = "HTTP/2 error code: " + this.name();
+      if (status.getDescription() != null) {
+        description += " (" + status.getDescription() + ")";
+      }
+      this.status = status.withDescription(description);
     }
 
     /**
@@ -307,7 +438,7 @@ public static boolean isGrpcContentType(String contentType) {
       return false;
     }
 
-    contentType = contentType.toLowerCase();
+    contentType = contentType.toLowerCase(Locale.US);
     if (!contentType.startsWith(CONTENT_TYPE_GRPC)) {
       // Not a gRPC content-type.
       return false;
@@ -337,10 +468,43 @@ public static String getGrpcUserAgent(
     }
     builder.append("grpc-java-");
     builder.append(transportName);
+    builder.append('/');
     builder.append(IMPLEMENTATION_VERSION);
     return builder.toString();
   }
 
+  @Immutable
+  public static final class GrpcBuildVersion {
+    private final String userAgent;
+    private final String implementationVersion;
+
+    private GrpcBuildVersion(String userAgent, String implementationVersion) {
+      this.userAgent = Preconditions.checkNotNull(userAgent, "userAgentName");
+      this.implementationVersion =
+          Preconditions.checkNotNull(implementationVersion, "implementationVersion");
+    }
+
+    public String getUserAgent() {
+      return userAgent;
+    }
+
+    public String getImplementationVersion() {
+      return implementationVersion;
+    }
+
+    @Override
+    public String toString() {
+      return userAgent + " " + implementationVersion;
+    }
+  }
+
+  /**
+   * Returns the build version of gRPC.
+   */
+  public static GrpcBuildVersion getGrpcBuildVersion() {
+    return new GrpcBuildVersion("gRPC Java", IMPLEMENTATION_VERSION);
+  }
+
   /**
    * Parse an authority into a URI for retrieving the host and port.
    */
@@ -363,8 +527,8 @@ public static URI authorityToUri(String authority) {
    */
   public static String checkAuthority(String authority) {
     URI uri = authorityToUri(authority);
-    checkArgument(uri.getHost() != null, "No host in authority '%s'", authority);
-    checkArgument(uri.getUserInfo() == null,
+    // Verify that the user Info is not provided.
+    checkArgument(uri.getAuthority().indexOf('@') == -1,
         "Userinfo must not be present on authority: '%s'", authority);
     return authority;
   }
@@ -372,6 +536,7 @@ public static String checkAuthority(String authority) {
   /**
    * Combine a host and port into an authority string.
    */
+  // There is a copy of this method in io.grpc.Grpc
   public static String authorityFromHostAndPort(String host, int port) {
     try {
       return new URI(null, null, host, port, null, null, null).getAuthority();
@@ -383,17 +548,17 @@ public static String authorityFromHostAndPort(String host, int port) {
   /**
    * Shared executor for channels.
    */
-  public static final Resource<ExecutorService> SHARED_CHANNEL_EXECUTOR =
-      new Resource<ExecutorService>() {
+  public static final Resource<Executor> SHARED_CHANNEL_EXECUTOR =
+      new Resource<Executor>() {
         private static final String NAME = "grpc-default-executor";
         @Override
-        public ExecutorService create() {
+        public Executor create() {
           return Executors.newCachedThreadPool(getThreadFactory(NAME + "-%d", true));
         }
 
         @Override
-        public void close(ExecutorService instance) {
-          instance.shutdown();
+        public void close(Executor instance) {
+          ((ExecutorService) instance).shutdown();
         }
 
         @Override
@@ -431,7 +596,7 @@ public ScheduledExecutorService create() {
             throw new RuntimeException(e);
           }
 
-          return service;
+          return Executors.unconfigurableScheduledExecutorService(service);
         }
 
         @Override
@@ -449,16 +614,10 @@ public void close(ScheduledExecutorService instance) {
    * @return a {@link ThreadFactory}.
    */
   public static ThreadFactory getThreadFactory(String nameFormat, boolean daemon) {
-    ThreadFactory threadFactory = MoreExecutors.platformThreadFactory();
-    if (IS_RESTRICTED_APPENGINE) {
-      return threadFactory;
-    } else {
-      return new ThreadFactoryBuilder()
-          .setThreadFactory(threadFactory)
-          .setDaemon(daemon)
-          .setNameFormat(nameFormat)
-          .build();
-    }
+    return new ThreadFactoryBuilder()
+        .setDaemon(daemon)
+        .setNameFormat(nameFormat)
+        .build();
   }
 
   /**
@@ -474,7 +633,7 @@ public Stopwatch get() {
   /**
    * Marshals a nanoseconds representation of the timeout to and from a string representation,
    * consisting of an ASCII decimal representation of a number with at most 8 digits, followed by a
-   * unit:
+   * unit. Available units:
    * n = nanoseconds
    * u = microseconds
    * m = milliseconds
@@ -492,22 +651,25 @@ public Stopwatch get() {
   static class TimeoutMarshaller implements Metadata.AsciiMarshaller<Long> {
 
     @Override
-    public String toAsciiString(Long timeoutNanos) {
+    public String toAsciiString(Long timeoutNanosObject) {
       long cutoff = 100000000;
-      if (timeoutNanos < 0) {
-        throw new IllegalArgumentException("Timeout too small");
-      } else if (timeoutNanos < cutoff) {
-        return TimeUnit.NANOSECONDS.toNanos(timeoutNanos) + "n";
+      // Timeout checking is inherently racy. RPCs with timeouts in the past ideally don't even get
+      // here, but if the timeout is expired assume that happened recently and adjust it to the
+      // smallest allowed timeout
+      long timeoutNanos = Math.max(1, timeoutNanosObject);
+      TimeUnit unit = TimeUnit.NANOSECONDS;
+      if (timeoutNanos < cutoff) {
+        return timeoutNanos + "n";
       } else if (timeoutNanos < cutoff * 1000L) {
-        return TimeUnit.NANOSECONDS.toMicros(timeoutNanos) + "u";
+        return unit.toMicros(timeoutNanos) + "u";
       } else if (timeoutNanos < cutoff * 1000L * 1000L) {
-        return TimeUnit.NANOSECONDS.toMillis(timeoutNanos) + "m";
+        return unit.toMillis(timeoutNanos) + "m";
       } else if (timeoutNanos < cutoff * 1000L * 1000L * 1000L) {
-        return TimeUnit.NANOSECONDS.toSeconds(timeoutNanos) + "S";
+        return unit.toSeconds(timeoutNanos) + "S";
       } else if (timeoutNanos < cutoff * 1000L * 1000L * 1000L * 60L) {
-        return TimeUnit.NANOSECONDS.toMinutes(timeoutNanos) + "M";
+        return unit.toMinutes(timeoutNanos) + "M";
       } else {
-        return TimeUnit.NANOSECONDS.toHours(timeoutNanos) + "H";
+        return unit.toHours(timeoutNanos) + "H";
       }
     }
 
@@ -519,7 +681,7 @@ public Long parseAsciiString(String serialized) {
       char unit = serialized.charAt(serialized.length() - 1);
       switch (unit) {
         case 'n':
-          return TimeUnit.NANOSECONDS.toNanos(value);
+          return value;
         case 'u':
           return TimeUnit.MICROSECONDS.toNanos(value);
         case 'm':
@@ -541,29 +703,276 @@ public Long parseAsciiString(String serialized) {
    */
   @Nullable
   static ClientTransport getTransportFromPickResult(PickResult result, boolean isWaitForReady) {
-    ClientTransport transport;
+    final ClientTransport transport;
     Subchannel subchannel = result.getSubchannel();
     if (subchannel != null) {
-      transport = ((SubchannelImpl) subchannel).obtainActiveTransport();
+      transport = ((TransportProvider) subchannel.getInternalSubchannel()).obtainActiveTransport();
     } else {
       transport = null;
     }
     if (transport != null) {
-      return transport;
+      final ClientStreamTracer.Factory streamTracerFactory = result.getStreamTracerFactory();
+      if (streamTracerFactory == null) {
+        return transport;
+      }
+      return new ClientTransport() {
+        @Override
+        public ClientStream newStream(
+            MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+            ClientStreamTracer[] tracers) {
+          StreamInfo info = StreamInfo.newBuilder().setCallOptions(callOptions).build();
+          ClientStreamTracer streamTracer =
+              streamTracerFactory.newClientStreamTracer(info, headers);
+          checkState(tracers[tracers.length - 1] == NOOP_TRACER, "lb tracer already assigned");
+          tracers[tracers.length - 1] = streamTracer;
+          return transport.newStream(method, headers, callOptions, tracers);
+        }
+
+        @Override
+        public void ping(PingCallback callback, Executor executor) {
+          transport.ping(callback, executor);
+        }
+
+        @Override
+        public InternalLogId getLogId() {
+          return transport.getLogId();
+        }
+
+        @Override
+        public ListenableFuture<SocketStats> getStats() {
+          return transport.getStats();
+        }
+      };
     }
-    if (!result.getStatus().isOk() && !isWaitForReady) {
-      return new FailingClientTransport(result.getStatus());
+    if (!result.getStatus().isOk()) {
+      if (result.isDrop()) {
+        return new FailingClientTransport(
+            replaceInappropriateControlPlaneStatus(result.getStatus()), RpcProgress.DROPPED);
+      }
+      if (!isWaitForReady) {
+        return new FailingClientTransport(
+            replaceInappropriateControlPlaneStatus(result.getStatus()), RpcProgress.PROCESSED);
+      }
     }
     return null;
   }
 
-  private GrpcUtil() {}
+  /** Gets stream tracers based on CallOptions. */
+  public static ClientStreamTracer[] getClientStreamTracers(
+      CallOptions callOptions, Metadata headers, int previousAttempts, boolean isTransparentRetry,
+      boolean isHedging) {
+    List<ClientStreamTracer.Factory> factories = callOptions.getStreamTracerFactories();
+    ClientStreamTracer[] tracers = new ClientStreamTracer[factories.size() + 1];
+    StreamInfo streamInfo = StreamInfo.newBuilder()
+        .setCallOptions(callOptions)
+        .setPreviousAttempts(previousAttempts)
+        .setIsTransparentRetry(isTransparentRetry)
+        .setIsHedging(isHedging)
+        .build();
+    for (int i = 0; i < factories.size(); i++) {
+      tracers[i] = factories.get(i).newClientStreamTracer(streamInfo, headers);
+    }
+    // Reserved to be set later by the lb as per the API contract of ClientTransport.newStream().
+    // See also GrpcUtil.getTransportFromPickResult()
+    tracers[tracers.length - 1] = NOOP_TRACER;
+    return tracers;
+  }
 
-  private static String getImplementationVersion() {
-    String version = GrpcUtil.class.getPackage().getImplementationVersion();
-    if (version != null) {
-      return "/" + version;
+  /** Quietly closes all messages in MessageProducer. */
+  static void closeQuietly(MessageProducer producer) {
+    InputStream message;
+    while ((message = producer.next()) != null) {
+      closeQuietly(message);
     }
-    return "";
   }
+
+  /**
+   * Closes a Closeable, ignoring IOExceptions.
+   * This method exists because Guava's {@code Closeables.closeQuietly()} is beta.
+   */
+  public static void closeQuietly(@Nullable Closeable message) {
+    if (message == null) {
+      return;
+    }
+    try {
+      message.close();
+    } catch (IOException ioException) {
+      // do nothing except log
+      log.log(Level.WARNING, "exception caught in closeQuietly", ioException);
+    }
+  }
+
+  /** Reads {@code in} until end of stream. */
+  public static void exhaust(InputStream in) throws IOException {
+    byte[] buf = new byte[256];
+    while (in.read(buf) != -1) {}
+  }
+
+  /**
+   * Some status codes from the control plane are not appropritate to use in the data plane. If one
+   * is given it will be replaced with INTERNAL, indicating a bug in the control plane
+   * implementation.
+   */
+  public static Status replaceInappropriateControlPlaneStatus(Status status) {
+    checkArgument(status != null);
+    return INAPPROPRIATE_CONTROL_PLANE_STATUS.contains(status.getCode())
+        ? Status.INTERNAL.withDescription(
+        "Inappropriate status code from control plane: " + status.getCode() + " "
+            + status.getDescription()).withCause(status.getCause()) : status;
+  }
+
+  /**
+   * Returns a "clean" representation of a status code and description (not cause) like
+   * "UNAVAILABLE: The description". Should be similar to Status.formatThrowableMessage().
+   */
+  public static String statusToPrettyString(Status status) {
+    if (status.getDescription() == null) {
+      return status.getCode().toString();
+    } else {
+      return status.getCode() + ": " + status.getDescription();
+    }
+  }
+
+  /**
+   * Create a status with contextual information, propagating details from a non-null status that
+   * contributed to the failure. For example, if UNAVAILABLE, "Couldn't load bar", and status
+   * "FAILED_PRECONDITION: Foo missing" were passed as arguments, then this method would produce the
+   * status "UNAVAILABLE: Couldn't load bar: FAILED_PRECONDITION: Foo missing" with a cause if the
+   * passed status had a cause.
+   */
+  public static Status statusWithDetails(Status.Code code, String description, Status causeStatus) {
+    return code.toStatus()
+        .withDescription(description + ": " + statusToPrettyString(causeStatus))
+        .withCause(causeStatus.getCause());
+  }
+
+  /**
+   * Checks whether the given item exists in the iterable.  This is copied from Guava Collect's
+   * {@code Iterables.contains()} because Guava Collect is not Android-friendly thus core can't
+   * depend on it.
+   */
+  static <T> boolean iterableContains(Iterable<T> iterable, T item) {
+    if (iterable instanceof Collection) {
+      Collection<?> collection = (Collection<?>) iterable;
+      try {
+        return collection.contains(item);
+      } catch (NullPointerException e) {
+        return false;
+      } catch (ClassCastException e) {
+        return false;
+      }
+    }
+    for (T i : iterable) {
+      if (Objects.equal(i, item)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Percent encode the {@code authority} based on
+   * https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.
+   *
+   * <p>When escaping a String, the following rules apply:
+   *
+   * <ul>
+   *   <li>The alphanumeric characters "a" through "z", "A" through "Z" and "0" through "9" remain
+   *       the same.
+   *   <li>The unreserved characters ".", "-", "~", and "_" remain the same.
+   *   <li>The general delimiters for authority, "[", "]", "@" and ":" remain the same.
+   *   <li>The subdelimiters "!", "$", "&amp;", "'", "(", ")", "*", "+", ",", ";", and "=" remain
+   *       the same.
+   *   <li>The space character " " is converted into %20.
+   *   <li>All other characters are converted into one or more bytes using UTF-8 encoding and each
+   *       byte is then represented by the 3-character string "%XY", where "XY" is the two-digit,
+   *       uppercase, hexadecimal representation of the byte value.
+   * </ul>
+   * 
+   * <p>This section does not use URLEscapers from Guava Net as its not Android-friendly thus core
+   *    can't depend on it.
+   */
+  public static class AuthorityEscaper {
+    // Escapers should output upper case hex digits.
+    private static final char[] UPPER_HEX_DIGITS = "0123456789ABCDEF".toCharArray();
+    private static final Set<Character> UNRESERVED_CHARACTERS = Collections
+        .unmodifiableSet(new HashSet<>(Arrays.asList('-', '_', '.', '~')));
+    private static final Set<Character> SUB_DELIMS = Collections
+        .unmodifiableSet(new HashSet<>(
+            Arrays.asList('!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=')));
+    private static final Set<Character> AUTHORITY_DELIMS = Collections
+        .unmodifiableSet(new HashSet<>(Arrays.asList(':', '[', ']', '@')));
+
+    private static boolean shouldEscape(char c) {
+      // Only encode ASCII.
+      if (c > 127) {
+        return false;
+      }
+      // Letters don't need an escape.
+      if (((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'))) {
+        return false;
+      }
+      // Numbers don't need to be escaped.
+      if ((c >= '0' && c <= '9'))  {
+        return false;
+      }
+      // Don't escape allowed characters.
+      if (UNRESERVED_CHARACTERS.contains(c)
+          || SUB_DELIMS.contains(c)
+          || AUTHORITY_DELIMS.contains(c)) {
+        return false;
+      }
+      return true;
+    }
+
+    public static String encodeAuthority(String authority) {
+      Preconditions.checkNotNull(authority, "authority");
+      int authorityLength = authority.length();
+      int hexCount = 0;
+      // Calculate how many characters actually need escaping.
+      for (int index = 0; index < authorityLength; index++) {
+        char c = authority.charAt(index);
+        if (shouldEscape(c)) {
+          hexCount++;
+        }
+      }
+      // If no char need escaping, just return the original string back.
+      if (hexCount == 0) {
+        return authority;
+      }
+
+      // Allocate enough space as encoded characters need 2 extra chars.
+      StringBuilder encoded_authority = new StringBuilder((2 * hexCount) + authorityLength);
+      for (int index = 0; index < authorityLength; index++) {
+        char c = authority.charAt(index);
+        if (shouldEscape(c)) {
+          encoded_authority.append('%');
+          encoded_authority.append(UPPER_HEX_DIGITS[c >>> 4]);
+          encoded_authority.append(UPPER_HEX_DIGITS[c & 0xF]);
+        } else {
+          encoded_authority.append(c);
+        }
+      }
+      return encoded_authority.toString();
+    }
+  }
+
+  public static boolean getFlag(String envVarName, boolean enableByDefault) {
+    String envVar = System.getenv(envVarName);
+    if (envVar == null) {
+      envVar = System.getProperty(envVarName);
+    }
+    if (envVar != null) {
+      envVar = envVar.trim();
+    }
+    if (enableByDefault) {
+      return Strings.isNullOrEmpty(envVar) || Boolean.parseBoolean(envVar);
+    } else {
+      return !Strings.isNullOrEmpty(envVar) && Boolean.parseBoolean(envVar);
+    }
+  }
+
+
+
+  private GrpcUtil() {}
 }
diff --git a/core/src/main/java/io/grpc/internal/GzipInflatingBuffer.java b/core/src/main/java/io/grpc/internal/GzipInflatingBuffer.java
new file mode 100644
index 00000000000..99945977f32
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/GzipInflatingBuffer.java
@@ -0,0 +1,474 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static com.google.common.base.Preconditions.checkState;
+
+import java.io.Closeable;
+import java.util.zip.CRC32;
+import java.util.zip.DataFormatException;
+import java.util.zip.Inflater;
+import java.util.zip.ZipException;
+import javax.annotation.concurrent.NotThreadSafe;
+
+/**
+ * Processes gzip streams, delegating to {@link Inflater} to perform on-demand inflation of the
+ * deflated blocks. Like {@link java.util.zip.GZIPInputStream}, this handles concatenated gzip
+ * streams. Unlike {@link java.util.zip.GZIPInputStream}, this allows for incremental processing of
+ * gzip streams, allowing data to be inflated as it arrives over the wire.
+ *
+ * <p>This also frees the inflate context when the end of a gzip stream is reached without another
+ * concatenated stream available to inflate.
+ */
+@NotThreadSafe
+class GzipInflatingBuffer implements Closeable {
+
+  private static final int INFLATE_BUFFER_SIZE = 512;
+  private static final int UNSIGNED_SHORT_SIZE = 2;
+
+  private static final int GZIP_MAGIC = 0x8b1f;
+
+  private static final int GZIP_HEADER_MIN_SIZE = 10;
+  private static final int GZIP_TRAILER_SIZE = 8;
+
+  private static final int HEADER_CRC_FLAG = 2;
+  private static final int HEADER_EXTRA_FLAG = 4;
+  private static final int HEADER_NAME_FLAG = 8;
+  private static final int HEADER_COMMENT_FLAG = 16;
+
+  /**
+   * Reads gzip header and trailer bytes from the inflater's buffer (if bytes beyond the inflate
+   * block were given to the inflater) and then from {@code gzippedData}, and handles updating the
+   * CRC and the count of gzipped bytes consumed.
+   */
+  private class GzipMetadataReader {
+
+    /**
+     * Returns the next unsigned byte, adding it the CRC and incrementing {@code bytesConsumed}.
+     *
+     * <p>It is the responsibility of the caller to verify and reset the CRC as needed, as well as
+     * caching the current CRC value when necessary before invoking this method.
+     */
+    private int readUnsignedByte() {
+      int bytesRemainingInInflaterInput = inflaterInputEnd - inflaterInputStart;
+      int b;
+      if (bytesRemainingInInflaterInput > 0) {
+        b = inflaterInput[inflaterInputStart] & 0xFF;
+        inflaterInputStart += 1;
+      } else {
+        b = gzippedData.readUnsignedByte();
+      }
+      crc.update(b);
+      bytesConsumed += 1;
+      return b;
+    }
+
+    /**
+     * Skips {@code length} bytes, adding them to the CRC and adding {@code length} to {@code
+     * bytesConsumed}.
+     *
+     * <p>It is the responsibility of the caller to verify and reset the CRC as needed, as well as
+     * caching the current CRC value when necessary before invoking this method.
+     */
+    private void skipBytes(int length) {
+      int bytesToSkip = length;
+      int bytesRemainingInInflaterInput = inflaterInputEnd - inflaterInputStart;
+
+      if (bytesRemainingInInflaterInput > 0) {
+        int bytesToGetFromInflaterInput = Math.min(bytesRemainingInInflaterInput, bytesToSkip);
+        crc.update(inflaterInput, inflaterInputStart, bytesToGetFromInflaterInput);
+        inflaterInputStart += bytesToGetFromInflaterInput;
+        bytesToSkip -= bytesToGetFromInflaterInput;
+      }
+
+      if (bytesToSkip > 0) {
+        byte[] buf = new byte[512];
+        int total = 0;
+        while (total < bytesToSkip) {
+          int toRead = Math.min(bytesToSkip - total, buf.length);
+          gzippedData.readBytes(buf, 0, toRead);
+          crc.update(buf, 0, toRead);
+          total += toRead;
+        }
+      }
+
+      bytesConsumed += length;
+    }
+
+    private int readableBytes() {
+      return (inflaterInputEnd - inflaterInputStart) + gzippedData.readableBytes();
+    }
+
+    /** Skip over a zero-terminated byte sequence. Returns true when the zero byte is read. */
+    private boolean readBytesUntilZero() {
+      while (readableBytes() > 0) {
+        if (readUnsignedByte() == 0) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    /** Reads unsigned short in Little-Endian byte order. */
+    private int readUnsignedShort() {
+      return readUnsignedByte() | (readUnsignedByte() << 8);
+    }
+
+    /** Reads unsigned integer in Little-Endian byte order. */
+    private long readUnsignedInt() {
+      long s = readUnsignedShort();
+      return ((long) readUnsignedShort() << 16) | s;
+    }
+  }
+
+  private enum State {
+    HEADER,
+    HEADER_EXTRA_LEN,
+    HEADER_EXTRA,
+    HEADER_NAME,
+    HEADER_COMMENT,
+    HEADER_CRC,
+    INITIALIZE_INFLATER,
+    INFLATING,
+    INFLATER_NEEDS_INPUT,
+    TRAILER
+  }
+
+  /**
+   * This buffer holds all input gzipped data, consisting of blocks of deflated data and the
+   * surrounding gzip headers and trailers. All access to the Gzip headers and trailers must be made
+   * via {@link GzipMetadataReader}.
+   */
+  private final CompositeReadableBuffer gzippedData = new CompositeReadableBuffer();
+
+  private final CRC32 crc = new CRC32();
+
+  private final GzipMetadataReader gzipMetadataReader = new GzipMetadataReader();
+  private final byte[] inflaterInput = new byte[INFLATE_BUFFER_SIZE];
+  private int inflaterInputStart;
+  private int inflaterInputEnd;
+  private Inflater inflater;
+  private State state = State.HEADER;
+  private boolean closed = false;
+
+  /** Extra state variables for parsing gzip header flags. */
+  private int gzipHeaderFlag;
+  private int headerExtraToRead;
+
+  /* Number of inflated bytes per gzip stream, used to validate the gzip trailer. */
+  private long expectedGzipTrailerIsize;
+
+  /**
+   * Tracks gzipped bytes (including gzip metadata and deflated blocks) consumed during {@link
+   * #inflateBytes} calls.
+   */
+  private int bytesConsumed = 0;
+
+  /** Tracks deflated bytes (excluding gzip metadata) consumed by the inflater. */
+  private int deflatedBytesConsumed = 0;
+
+  private boolean isStalled = true;
+
+  /**
+   * Returns true when more bytes must be added via {@link #addGzippedBytes} to enable additional
+   * calls to {@link #inflateBytes} to make progress.
+   */
+  boolean isStalled() {
+    checkState(!closed, "GzipInflatingBuffer is closed");
+    return isStalled;
+  }
+
+  /**
+   * Returns true when there is gzippedData that has not been input to the inflater or the inflater
+   * has not consumed all of its input, or all data has been consumed but we are at not at the
+   * boundary between gzip streams.
+   */
+  boolean hasPartialData() {
+    checkState(!closed, "GzipInflatingBuffer is closed");
+    return gzipMetadataReader.readableBytes() != 0 || state != State.HEADER;
+  }
+
+  /**
+   * Adds more gzipped data, which will be consumed only when needed to fulfill requests made via
+   * {@link #inflateBytes}.
+   */
+  void addGzippedBytes(ReadableBuffer buffer) {
+    checkState(!closed, "GzipInflatingBuffer is closed");
+    gzippedData.addBuffer(buffer);
+    isStalled = false;
+  }
+
+  @Override
+  public void close() {
+    if (!closed) {
+      closed = true;
+      gzippedData.close();
+      if (inflater != null) {
+        inflater.end();
+        inflater = null;
+      }
+    }
+  }
+
+  /**
+   * Reports bytes consumed by calls to {@link #inflateBytes} since the last invocation of this
+   * method, then resets the count to zero.
+   */
+  int getAndResetBytesConsumed() {
+    int savedBytesConsumed = bytesConsumed;
+    bytesConsumed = 0;
+    return savedBytesConsumed;
+  }
+
+  /**
+   * Reports bytes consumed by the inflater since the last invocation of this method, then resets
+   * the count to zero.
+   */
+  int getAndResetDeflatedBytesConsumed() {
+    int savedDeflatedBytesConsumed = deflatedBytesConsumed;
+    deflatedBytesConsumed = 0;
+    return savedDeflatedBytesConsumed;
+  }
+
+  /**
+   * Attempts to inflate {@code length} bytes of data into {@code b}.
+   *
+   * <p>Any gzipped bytes consumed by this method will be added to the counter returned by {@link
+   * #getAndResetBytesConsumed()}. This method may consume gzipped bytes without writing any data to
+   * {@code b}, and may also write data to {@code b} without consuming additional gzipped bytes (if
+   * the inflater on an earlier call consumed the bytes necessary to produce output).
+   *
+   * @param b the destination array to receive the bytes.
+   * @param offset the starting offset in the destination array.
+   * @param length the number of bytes to be copied.
+   * @throws IndexOutOfBoundsException if {@code b} is too small to hold the requested bytes.
+   */
+  int inflateBytes(byte[] b, int offset, int length) throws DataFormatException, ZipException {
+    checkState(!closed, "GzipInflatingBuffer is closed");
+
+    int bytesRead = 0;
+    int missingBytes;
+    boolean madeProgress = true;
+    while (madeProgress && (missingBytes = length - bytesRead) > 0) {
+      switch (state) {
+        case HEADER:
+          madeProgress = processHeader();
+          break;
+        case HEADER_EXTRA_LEN:
+          madeProgress = processHeaderExtraLen();
+          break;
+        case HEADER_EXTRA:
+          madeProgress = processHeaderExtra();
+          break;
+        case HEADER_NAME:
+          madeProgress = processHeaderName();
+          break;
+        case HEADER_COMMENT:
+          madeProgress = processHeaderComment();
+          break;
+        case HEADER_CRC:
+          madeProgress = processHeaderCrc();
+          break;
+        case INITIALIZE_INFLATER:
+          madeProgress = initializeInflater();
+          break;
+        case INFLATING:
+          bytesRead += inflate(b, offset + bytesRead, missingBytes);
+          if (state == State.TRAILER) {
+            // Eagerly process trailer, if available, to validate CRC.
+            madeProgress = processTrailer();
+          } else {
+            // Continue in INFLATING until we have the required bytes or we transition to
+            // INFLATER_NEEDS_INPUT
+            madeProgress = true;
+          }
+          break;
+        case INFLATER_NEEDS_INPUT:
+          madeProgress = fill();
+          break;
+        case TRAILER:
+          madeProgress = processTrailer();
+          break;
+        default:
+          throw new AssertionError("Invalid state: " + state);
+      }
+    }
+    // If we finished a gzip block, check if we have enough bytes to read another header
+    isStalled =
+        !madeProgress
+            || (state == State.HEADER && gzipMetadataReader.readableBytes() < GZIP_HEADER_MIN_SIZE);
+
+    return bytesRead;
+  }
+
+  private boolean processHeader() throws ZipException {
+    if (gzipMetadataReader.readableBytes() < GZIP_HEADER_MIN_SIZE) {
+      return false;
+    }
+    if (gzipMetadataReader.readUnsignedShort() != GZIP_MAGIC) {
+      throw new ZipException("Not in GZIP format");
+    }
+    if (gzipMetadataReader.readUnsignedByte() != 8) {
+      throw new ZipException("Unsupported compression method");
+    }
+    gzipHeaderFlag = gzipMetadataReader.readUnsignedByte();
+    gzipMetadataReader.skipBytes(6 /* remaining header bytes */);
+    state = State.HEADER_EXTRA_LEN;
+    return true;
+  }
+
+  private boolean processHeaderExtraLen() {
+    if ((gzipHeaderFlag & HEADER_EXTRA_FLAG) != HEADER_EXTRA_FLAG) {
+      state = State.HEADER_NAME;
+      return true;
+    }
+    if (gzipMetadataReader.readableBytes() < UNSIGNED_SHORT_SIZE) {
+      return false;
+    }
+    headerExtraToRead = gzipMetadataReader.readUnsignedShort();
+    state = State.HEADER_EXTRA;
+    return true;
+  }
+
+  private boolean processHeaderExtra() {
+    if (gzipMetadataReader.readableBytes() < headerExtraToRead) {
+      return false;
+    }
+    gzipMetadataReader.skipBytes(headerExtraToRead);
+    state = State.HEADER_NAME;
+    return true;
+  }
+
+  private boolean processHeaderName() {
+    if ((gzipHeaderFlag & HEADER_NAME_FLAG) != HEADER_NAME_FLAG) {
+      state = State.HEADER_COMMENT;
+      return true;
+    }
+    if (!gzipMetadataReader.readBytesUntilZero()) {
+      return false;
+    }
+    state = State.HEADER_COMMENT;
+    return true;
+  }
+
+  private boolean processHeaderComment() {
+    if ((gzipHeaderFlag & HEADER_COMMENT_FLAG) != HEADER_COMMENT_FLAG) {
+      state = State.HEADER_CRC;
+      return true;
+    }
+    if (!gzipMetadataReader.readBytesUntilZero()) {
+      return false;
+    }
+    state = State.HEADER_CRC;
+    return true;
+  }
+
+  private boolean processHeaderCrc() throws ZipException {
+    if ((gzipHeaderFlag & HEADER_CRC_FLAG) != HEADER_CRC_FLAG) {
+      state = State.INITIALIZE_INFLATER;
+      return true;
+    }
+    if (gzipMetadataReader.readableBytes() < UNSIGNED_SHORT_SIZE) {
+      return false;
+    }
+    int desiredCrc16 = (int) crc.getValue() & 0xffff;
+    if (desiredCrc16 != gzipMetadataReader.readUnsignedShort()) {
+      throw new ZipException("Corrupt GZIP header");
+    }
+    state = State.INITIALIZE_INFLATER;
+    return true;
+  }
+
+  private boolean initializeInflater() {
+    if (inflater == null) {
+      inflater = new Inflater(true);
+    } else {
+      inflater.reset();
+    }
+    crc.reset();
+    int bytesRemainingInInflaterInput = inflaterInputEnd - inflaterInputStart;
+    if (bytesRemainingInInflaterInput > 0) {
+      inflater.setInput(inflaterInput, inflaterInputStart, bytesRemainingInInflaterInput);
+      state = State.INFLATING;
+    } else {
+      state = State.INFLATER_NEEDS_INPUT;
+    }
+    return true;
+  }
+
+  private int inflate(byte[] b, int off, int len) throws DataFormatException, ZipException {
+    checkState(inflater != null, "inflater is null");
+
+    try {
+      int inflaterTotalIn = inflater.getTotalIn();
+      int n = inflater.inflate(b, off, len);
+      int bytesConsumedDelta = inflater.getTotalIn() - inflaterTotalIn;
+      bytesConsumed += bytesConsumedDelta;
+      deflatedBytesConsumed += bytesConsumedDelta;
+      inflaterInputStart += bytesConsumedDelta;
+      crc.update(b, off, n);
+
+      if (inflater.finished()) {
+        // Save bytes written to check against the trailer ISIZE
+        expectedGzipTrailerIsize = (inflater.getBytesWritten() & 0xffffffffL);
+
+        state = State.TRAILER;
+      } else if (inflater.needsInput()) {
+        state = State.INFLATER_NEEDS_INPUT;
+      }
+
+      return n;
+    } catch (DataFormatException e) {
+      // Wrap the exception so tests can check for a specific prefix
+      throw new DataFormatException("Inflater data format exception: " + e.getMessage());
+    }
+  }
+
+  private boolean fill() {
+    checkState(inflater != null, "inflater is null");
+    checkState(inflaterInputStart == inflaterInputEnd, "inflaterInput has unconsumed bytes");
+    int bytesToAdd = Math.min(gzippedData.readableBytes(), INFLATE_BUFFER_SIZE);
+    if (bytesToAdd == 0) {
+      return false;
+    }
+    inflaterInputStart = 0;
+    inflaterInputEnd = bytesToAdd;
+    gzippedData.readBytes(inflaterInput, inflaterInputStart, bytesToAdd);
+    inflater.setInput(inflaterInput, inflaterInputStart, bytesToAdd);
+    state = State.INFLATING;
+    return true;
+  }
+
+  private boolean processTrailer() throws ZipException {
+    if (inflater != null
+        && gzipMetadataReader.readableBytes() <= GZIP_HEADER_MIN_SIZE + GZIP_TRAILER_SIZE) {
+      // We don't have enough bytes to begin inflating a concatenated gzip stream, drop context
+      inflater.end();
+      inflater = null;
+    }
+    if (gzipMetadataReader.readableBytes() < GZIP_TRAILER_SIZE) {
+      return false;
+    }
+    if (crc.getValue() != gzipMetadataReader.readUnsignedInt()
+        || expectedGzipTrailerIsize != gzipMetadataReader.readUnsignedInt()) {
+      throw new ZipException("Corrupt GZIP trailer");
+    }
+    crc.reset();
+    state = State.HEADER;
+    return true;
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/HedgingPolicy.java b/core/src/main/java/io/grpc/internal/HedgingPolicy.java
new file mode 100644
index 00000000000..1b192141643
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/HedgingPolicy.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2018 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.internal;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import com.google.common.collect.ImmutableSet;
+import io.grpc.Status.Code;
+import java.util.Set;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * Hedging policy data object.
+ */
+@Immutable
+final class HedgingPolicy {
+  final int maxAttempts;
+  final long hedgingDelayNanos;
+  final Set<Code> nonFatalStatusCodes;
+
+  /**
+   * The caller is supposed to have validated the arguments and handled throwing exception or
+   * logging warnings already, so we avoid repeating args check here.
+   */
+  HedgingPolicy(int maxAttempts, long hedgingDelayNanos, Set<Code> nonFatalStatusCodes) {
+    this.maxAttempts = maxAttempts;
+    this.hedgingDelayNanos = hedgingDelayNanos;
+    this.nonFatalStatusCodes = ImmutableSet.copyOf(nonFatalStatusCodes);
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (this == other) {
+      return true;
+    }
+    if (other == null || getClass() != other.getClass()) {
+      return false;
+    }
+    HedgingPolicy that = (HedgingPolicy) other;
+    return maxAttempts == that.maxAttempts
+        && hedgingDelayNanos == that.hedgingDelayNanos
+        && Objects.equal(nonFatalStatusCodes, that.nonFatalStatusCodes);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(maxAttempts, hedgingDelayNanos, nonFatalStatusCodes);
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("maxAttempts", maxAttempts)
+        .add("hedgingDelayNanos", hedgingDelayNanos)
+        .add("nonFatalStatusCodes", nonFatalStatusCodes)
+        .toString();
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/Http2ClientStream.java b/core/src/main/java/io/grpc/internal/Http2ClientStream.java
deleted file mode 100644
index e68dbdf3f99..00000000000
--- a/core/src/main/java/io/grpc/internal/Http2ClientStream.java
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import com.google.common.base.Charsets;
-import com.google.common.base.Preconditions;
-import io.grpc.InternalMetadata;
-import io.grpc.Metadata;
-import io.grpc.Status;
-import java.nio.charset.Charset;
-import javax.annotation.Nullable;
-
-/**
- * Base implementation for client streams using HTTP2 as the transport.
- */
-public abstract class Http2ClientStream extends AbstractClientStream {
-
-  /**
-   * Metadata marshaller for HTTP status lines.
-   */
-  private static final InternalMetadata.TrustedAsciiMarshaller<Integer> HTTP_STATUS_MARSHALLER =
-      new InternalMetadata.TrustedAsciiMarshaller<Integer>() {
-        @Override
-        public byte[] toAsciiString(Integer value) {
-          throw new UnsupportedOperationException();
-        }
-
-        /**
-         * RFC 7231 says status codes are 3 digits long.
-         *
-         * @see: <a href="https://tools.ietf.org/html/rfc7231#section-6">RFC 7231</a>
-         */
-        @Override
-        public Integer parseAsciiString(byte[] serialized) {
-          if (serialized.length >= 3) {
-            return (serialized[0] - '0') * 100 + (serialized[1] - '0') * 10 + (serialized[2] - '0');
-          }
-          throw new NumberFormatException(
-              "Malformed status code " + new String(serialized, InternalMetadata.US_ASCII));
-        }
-      };
-
-  private static final Metadata.Key<Integer> HTTP2_STATUS = InternalMetadata.keyOf(":status",
-      HTTP_STATUS_MARSHALLER);
-
-  /** When non-{@code null}, {@link #transportErrorMetadata} must also be non-{@code null}. */
-  private Status transportError;
-  private Metadata transportErrorMetadata;
-  private Charset errorCharset = Charsets.UTF_8;
-  private boolean headersReceived;
-
-  protected Http2ClientStream(WritableBufferAllocator bufferAllocator, int maxMessageSize,
-      StatsTraceContext statsTraceCtx) {
-    super(bufferAllocator, maxMessageSize, statsTraceCtx);
-  }
-
-  /**
-   * Called by subclasses whenever {@code Headers} are received from the transport.
-   *
-   * @param headers the received headers
-   */
-  protected void transportHeadersReceived(Metadata headers) {
-    Preconditions.checkNotNull(headers, "headers");
-    if (transportError != null) {
-      // Already received a transport error so just augment it. Something is really, really strange.
-      transportError = transportError.augmentDescription("headers: " + headers);
-      return;
-    }
-    try {
-      if (headersReceived) {
-        transportError = Status.INTERNAL.withDescription("Received headers twice");
-        return;
-      }
-      Integer httpStatus = headers.get(HTTP2_STATUS);
-      if (httpStatus != null && httpStatus >= 100 && httpStatus < 200) {
-        // Ignore the headers. See RFC 7540 §8.1
-        return;
-      }
-      headersReceived = true;
-
-      transportError = validateInitialMetadata(headers);
-      if (transportError != null) {
-        return;
-      }
-
-      stripTransportDetails(headers);
-      inboundHeadersReceived(headers);
-    } finally {
-      if (transportError != null) {
-        // Note we don't immediately report the transport error, instead we wait for more data on
-        // the stream so we can accumulate more detail into the error before reporting it.
-        transportError = transportError.augmentDescription("headers: " + headers);
-        transportErrorMetadata = headers;
-        errorCharset = extractCharset(headers);
-      }
-    }
-  }
-
-  /**
-   * Called by subclasses whenever a data frame is received from the transport.
-   *
-   * @param frame the received data frame
-   * @param endOfStream {@code true} if there will be no more data received for this stream
-   */
-  protected void transportDataReceived(ReadableBuffer frame, boolean endOfStream) {
-    if (transportError == null && inboundPhase() == Phase.HEADERS) {
-      // Must receive headers prior to receiving any payload as we use headers to check for
-      // protocol correctness.
-      transportError = Status.INTERNAL.withDescription("no headers received prior to data");
-      transportErrorMetadata = new Metadata();
-    }
-    if (transportError != null) {
-      // We've already detected a transport error and now we're just accumulating more detail
-      // for it.
-      transportError = transportError.augmentDescription("DATA-----------------------------\n"
-          + ReadableBuffers.readAsString(frame, errorCharset));
-      frame.close();
-      if (transportError.getDescription().length() > 1000 || endOfStream) {
-        inboundTransportError(transportError, transportErrorMetadata);
-        // We have enough error detail so lets cancel.
-        sendCancel(Status.CANCELLED);
-      }
-    } else {
-      inboundDataReceived(frame);
-      if (endOfStream) {
-        // This is a protocol violation as we expect to receive trailers.
-        transportError =
-            Status.INTERNAL.withDescription("Received unexpected EOS on DATA frame from server.");
-        transportErrorMetadata = new Metadata();
-        inboundTransportError(transportError, transportErrorMetadata);
-      }
-    }
-  }
-
-  /**
-   * Called by subclasses for the terminal trailer metadata on a stream.
-   *
-   * @param trailers the received terminal trailer metadata
-   */
-  protected void transportTrailersReceived(Metadata trailers) {
-    Preconditions.checkNotNull(trailers, "trailers");
-    if (transportError == null && !headersReceived) {
-      transportError = validateInitialMetadata(trailers);
-      if (transportError != null) {
-        transportErrorMetadata = trailers;
-      }
-    }
-    if (transportError != null) {
-      transportError = transportError.augmentDescription("trailers: " + trailers);
-      inboundTransportError(transportError, transportErrorMetadata);
-      sendCancel(Status.CANCELLED);
-    } else {
-      Status status = statusFromTrailers(trailers);
-      stripTransportDetails(trailers);
-      inboundTrailersReceived(trailers, status);
-    }
-  }
-
-  /**
-   * Extract the response status from trailers.
-   */
-  private Status statusFromTrailers(Metadata trailers) {
-    Status status = trailers.get(Status.CODE_KEY);
-    if (status != null) {
-      return status.withDescription(trailers.get(Status.MESSAGE_KEY));
-    }
-    // No status; something is broken. Try to provide a resonanable error.
-    if (headersReceived) {
-      return Status.UNKNOWN.withDescription("missing GRPC status in response");
-    }
-    Integer httpStatus = trailers.get(HTTP2_STATUS);
-    if (httpStatus != null) {
-      status = GrpcUtil.httpStatusToGrpcStatus(httpStatus);
-    } else {
-      status = Status.INTERNAL.withDescription("missing HTTP status code");
-    }
-    return status.augmentDescription(
-        "missing GRPC status, inferred error from HTTP status code");
-  }
-
-  /**
-   * Inspect initial headers to make sure they conform to HTTP and gRPC, returning a {@code Status}
-   * on failure.
-   *
-   * @return status with description of failure, or {@code null} when valid
-   */
-  @Nullable
-  private Status validateInitialMetadata(Metadata headers) {
-    Integer httpStatus = headers.get(HTTP2_STATUS);
-    if (httpStatus == null) {
-      return Status.INTERNAL.withDescription("Missing HTTP status code");
-    }
-    String contentType = headers.get(GrpcUtil.CONTENT_TYPE_KEY);
-    if (!GrpcUtil.isGrpcContentType(contentType)) {
-      return GrpcUtil.httpStatusToGrpcStatus(httpStatus)
-          .augmentDescription("invalid content-type: " + contentType);
-    }
-    return null;
-  }
-
-  /**
-   * Inspect the raw metadata and figure out what charset is being used.
-   */
-  private static Charset extractCharset(Metadata headers) {
-    String contentType = headers.get(GrpcUtil.CONTENT_TYPE_KEY);
-    if (contentType != null) {
-      String[] split = contentType.split("charset=");
-      try {
-        return Charset.forName(split[split.length - 1].trim());
-      } catch (Exception t) {
-        // Ignore and assume UTF-8
-      }
-    }
-    return Charsets.UTF_8;
-  }
-
-  /**
-   * Strip HTTP transport implementation details so they don't leak via metadata into
-   * the application layer.
-   */
-  private static void stripTransportDetails(Metadata metadata) {
-    metadata.discardAll(HTTP2_STATUS);
-    metadata.discardAll(Status.CODE_KEY);
-    metadata.discardAll(Status.MESSAGE_KEY);
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/Http2ClientStreamTransportState.java b/core/src/main/java/io/grpc/internal/Http2ClientStreamTransportState.java
index cfab5f3a995..5560a1abb6d 100644
--- a/core/src/main/java/io/grpc/internal/Http2ClientStreamTransportState.java
+++ b/core/src/main/java/io/grpc/internal/Http2ClientStreamTransportState.java
@@ -1,48 +1,35 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
-import com.google.common.base.Charsets;
 import com.google.common.base.Preconditions;
+import io.grpc.CallOptions;
 import io.grpc.InternalMetadata;
+import io.grpc.InternalStatus;
 import io.grpc.Metadata;
 import io.grpc.Status;
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import javax.annotation.Nullable;
 
 /**
  * Base implementation for client streams using HTTP2 as the transport.
  */
-public abstract class Http2ClientStreamTransportState extends AbstractClientStream2.TransportState {
+public abstract class Http2ClientStreamTransportState extends AbstractClientStream.TransportState {
 
   /**
    * Metadata marshaller for HTTP status lines.
@@ -57,7 +44,7 @@ public byte[] toAsciiString(Integer value) {
         /**
          * RFC 7231 says status codes are 3 digits long.
          *
-         * @see: <a href="https://tools.ietf.org/html/rfc7231#section-6">RFC 7231</a>
+         * @see <a href="https://tools.ietf.org/html/rfc7231#section-6">RFC 7231</a>
          */
         @Override
         public Integer parseAsciiString(byte[] serialized) {
@@ -75,18 +62,23 @@ public Integer parseAsciiString(byte[] serialized) {
   /** When non-{@code null}, {@link #transportErrorMetadata} must also be non-{@code null}. */
   private Status transportError;
   private Metadata transportErrorMetadata;
-  private Charset errorCharset = Charsets.UTF_8;
+  private Charset errorCharset = StandardCharsets.UTF_8;
   private boolean headersReceived;
 
-  protected Http2ClientStreamTransportState(int maxMessageSize, StatsTraceContext statsTraceCtx) {
-    super(maxMessageSize, statsTraceCtx);
+  protected Http2ClientStreamTransportState(
+      int maxMessageSize,
+      StatsTraceContext statsTraceCtx,
+      TransportTracer transportTracer,
+      CallOptions options) {
+    super(maxMessageSize, statsTraceCtx, transportTracer, options);
   }
 
   /**
    * Called to process a failure in HTTP/2 processing. It should notify the transport to cancel the
    * stream and call {@code transportReportStatus()}.
    */
-  protected abstract void http2ProcessingFailed(Status status, Metadata trailers);
+  protected abstract void http2ProcessingFailed(
+      Status status, boolean stopDelivery, Metadata trailers);
 
   /**
    * Called by subclasses whenever {@code Headers} are received from the transport.
@@ -144,14 +136,28 @@ protected void transportDataReceived(ReadableBuffer frame, boolean endOfStream)
           + ReadableBuffers.readAsString(frame, errorCharset));
       frame.close();
       if (transportError.getDescription().length() > 1000 || endOfStream) {
-        http2ProcessingFailed(transportError, transportErrorMetadata);
+        http2ProcessingFailed(transportError, false, transportErrorMetadata);
       }
     } else {
+      if (!headersReceived) {
+        frame.close();
+        http2ProcessingFailed(
+            Status.INTERNAL.withDescription("headers not received before payload"),
+            false,
+            new Metadata());
+        return;
+      }
+      int frameSize = frame.readableBytes();
       inboundDataReceived(frame);
       if (endOfStream) {
         // This is a protocol violation as we expect to receive trailers.
-        transportError =
-            Status.INTERNAL.withDescription("Received unexpected EOS on DATA frame from server.");
+        if (frameSize > 0) {
+          transportError = Status.INTERNAL
+              .withDescription("Received unexpected EOS on non-empty DATA frame from server");
+        } else {
+          transportError = Status.INTERNAL
+              .withDescription("Received unexpected EOS on empty DATA frame from server");
+        }
         transportErrorMetadata = new Metadata();
         transportReportStatus(transportError, false, transportErrorMetadata);
       }
@@ -173,7 +179,7 @@ protected void transportTrailersReceived(Metadata trailers) {
     }
     if (transportError != null) {
       transportError = transportError.augmentDescription("trailers: " + trailers);
-      http2ProcessingFailed(transportError, transportErrorMetadata);
+      http2ProcessingFailed(transportError, false, transportErrorMetadata);
     } else {
       Status status = statusFromTrailers(trailers);
       stripTransportDetails(trailers);
@@ -185,9 +191,9 @@ protected void transportTrailersReceived(Metadata trailers) {
    * Extract the response status from trailers.
    */
   private Status statusFromTrailers(Metadata trailers) {
-    Status status = trailers.get(Status.CODE_KEY);
+    Status status = trailers.get(InternalStatus.CODE_KEY);
     if (status != null) {
-      return status.withDescription(trailers.get(Status.MESSAGE_KEY));
+      return status.withDescription(trailers.get(InternalStatus.MESSAGE_KEY));
     }
     // No status; something is broken. Try to provide a resonanable error.
     if (headersReceived) {
@@ -229,14 +235,14 @@ private Status validateInitialMetadata(Metadata headers) {
   private static Charset extractCharset(Metadata headers) {
     String contentType = headers.get(GrpcUtil.CONTENT_TYPE_KEY);
     if (contentType != null) {
-      String[] split = contentType.split("charset=");
+      String[] split = contentType.split("charset=", 2);
       try {
         return Charset.forName(split[split.length - 1].trim());
       } catch (Exception t) {
         // Ignore and assume UTF-8
       }
     }
-    return Charsets.UTF_8;
+    return StandardCharsets.UTF_8;
   }
 
   /**
@@ -245,7 +251,7 @@ private static Charset extractCharset(Metadata headers) {
    */
   private static void stripTransportDetails(Metadata metadata) {
     metadata.discardAll(HTTP2_STATUS);
-    metadata.discardAll(Status.CODE_KEY);
-    metadata.discardAll(Status.MESSAGE_KEY);
+    metadata.discardAll(InternalStatus.CODE_KEY);
+    metadata.discardAll(InternalStatus.MESSAGE_KEY);
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/Http2Ping.java b/core/src/main/java/io/grpc/internal/Http2Ping.java
index 51a149cb220..e3520295625 100644
--- a/core/src/main/java/io/grpc/internal/Http2Ping.java
+++ b/core/src/main/java/io/grpc/internal/Http2Ping.java
@@ -1,37 +1,24 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import com.google.common.base.Stopwatch;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Status;
 import io.grpc.internal.ClientTransport.PingCallback;
 import java.util.LinkedHashMap;
 import java.util.Map;
@@ -39,7 +26,6 @@
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * Represents an outstanding PING operation on an HTTP/2 channel. This can be used by HTTP/2-based
@@ -66,7 +52,7 @@ public class Http2Ping {
    * The registered callbacks and the executor used to invoke them.
    */
   @GuardedBy("this") private Map<PingCallback, Executor> callbacks
-      = new LinkedHashMap<PingCallback, Executor>();
+      = new LinkedHashMap<>();
 
   /**
    * False until the operation completes, either successfully (other side sent acknowledgement) or
@@ -77,7 +63,7 @@ public class Http2Ping {
   /**
    * If non-null, indicates the ping failed.
    */
-  @GuardedBy("this") private Throwable failureCause;
+  @GuardedBy("this") private Status failureCause;
 
   /**
    * The round-trip time for the ping, in nanoseconds. This value is only meaningful when
@@ -159,7 +145,7 @@ public boolean complete() {
    *
    * @param failureCause the cause of failure
    */
-  public void failed(Throwable failureCause) {
+  public void failed(Status failureCause) {
     Map<ClientTransport.PingCallback, Executor> callbacks;
     synchronized (this) {
       if (completed) {
@@ -182,7 +168,7 @@ public void failed(Throwable failureCause) {
    * @param executor the executor used to invoke the callback
    * @param cause the cause of failure
    */
-  public static void notifyFailed(PingCallback callback, Executor executor, Throwable cause) {
+  public static void notifyFailed(PingCallback callback, Executor executor, Status cause) {
     doExecute(executor, asRunnable(callback, cause));
   }
 
@@ -218,7 +204,7 @@ public void run() {
    * failure.
    */
   private static Runnable asRunnable(final ClientTransport.PingCallback callback,
-                                     final Throwable failureCause) {
+                                     final Status failureCause) {
     return new Runnable() {
       @Override
       public void run() {
diff --git a/core/src/main/java/io/grpc/internal/InUseStateAggregator.java b/core/src/main/java/io/grpc/internal/InUseStateAggregator.java
index dc8a927078d..f3d870e8797 100644
--- a/core/src/main/java/io/grpc/internal/InUseStateAggregator.java
+++ b/core/src/main/java/io/grpc/internal/InUseStateAggregator.java
@@ -1,96 +1,81 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
-import java.util.HashSet;
-import javax.annotation.CheckReturnValue;
-import javax.annotation.concurrent.GuardedBy;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.Set;
+import javax.annotation.concurrent.NotThreadSafe;
 
 /**
  * Aggregates the in-use state of a set of objects.
  */
-abstract class InUseStateAggregator<T> {
+@NotThreadSafe
+public abstract class InUseStateAggregator<T> {
 
-  @GuardedBy("getLock()")
-  private final HashSet<T> inUseObjects = new HashSet<T>();
+  private final Set<T> inUseObjects = Collections.newSetFromMap(new IdentityHashMap<T,Boolean>());
 
   /**
-   * Update the in-use state of an object. Initially no object is in use. When the return value is
-   * non-{@code null}, the caller should execute the runnable after releasing locks.
+   * Update the in-use state of an object. Initially no object is in use.
+   *
+   * <p>This may call into {@link #handleInUse} or {@link #handleNotInUse} when appropriate.
    */
-  @CheckReturnValue
-  final Runnable updateObjectInUse(T object, boolean inUse) {
-    Runnable runnable = null;
-    synchronized (getLock()) {
-      int origSize = inUseObjects.size();
-      if (inUse) {
-        inUseObjects.add(object);
-        if (origSize == 0) {
-          runnable = handleInUse();
-        }
-      } else {
-        boolean removed = inUseObjects.remove(object);
-        if (removed && origSize == 1) {
-          handleNotInUse();
-        }
+  public final void updateObjectInUse(T object, boolean inUse) {
+    int origSize = inUseObjects.size();
+    if (inUse) {
+      inUseObjects.add(object);
+      if (origSize == 0) {
+        handleInUse();
+      }
+    } else {
+      boolean removed = inUseObjects.remove(object);
+      if (removed && origSize == 1) {
+        handleNotInUse();
       }
     }
-    return runnable;
   }
 
-  @CheckReturnValue
-  final boolean isInUse() {
-    synchronized (getLock()) {
-      return !inUseObjects.isEmpty();
-    }
+  public final boolean isInUse() {
+    return !inUseObjects.isEmpty();
   }
 
-  abstract Object getLock();
+  /**
+   * Returns {@code true} if any of the given objects are in use.
+   *
+   * @param objects The objects to consider.
+   * @return {@code true} if any of the given objects are in use.
+   */
+  public final boolean anyObjectInUse(Object... objects) {
+    for (Object object : objects) {
+      if (inUseObjects.contains(object)) {
+        return true;
+      }
+    }
+    return false;
+  }
 
   /**
    * Called when the aggregated in-use state has changed to true, which means at least one object is
-   * in use. When the return value is non-{@code null}, then the runnable will be executed by the
-   * caller of {@link #updateObjectInUse} after releasing locks.
-   *
-   * <p>This method is called under the lock returned by {@link #getLock}.
+   * in use.
    */
-  @GuardedBy("getLock()")
-  abstract Runnable handleInUse();
+  protected abstract void handleInUse();
 
   /**
    * Called when the aggregated in-use state has changed to false, which means no object is in use.
-   *
-   * <p>This method is called under the lock returned by {@link #getLock}.
    */
-  @GuardedBy("getLock()")
-  abstract void handleNotInUse();
+  protected abstract void handleNotInUse();
 }
diff --git a/core/src/main/java/io/grpc/internal/InUseStateAggregator2.java b/core/src/main/java/io/grpc/internal/InUseStateAggregator2.java
deleted file mode 100644
index 6333f360973..00000000000
--- a/core/src/main/java/io/grpc/internal/InUseStateAggregator2.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import java.util.HashSet;
-import javax.annotation.concurrent.NotThreadSafe;
-
-/**
- * Aggregates the in-use state of a set of objects.
- */
-@NotThreadSafe
-abstract class InUseStateAggregator2<T> {
-
-  private final HashSet<T> inUseObjects = new HashSet<T>();
-
-  /**
-   * Update the in-use state of an object. Initially no object is in use.
-   *
-   * <p>This may call into {@link #handleInUse} or {@link #handleNotInUse} when appropriate.
-   */
-  final void updateObjectInUse(T object, boolean inUse) {
-    int origSize = inUseObjects.size();
-    if (inUse) {
-      inUseObjects.add(object);
-      if (origSize == 0) {
-        handleInUse();
-      }
-    } else {
-      boolean removed = inUseObjects.remove(object);
-      if (removed && origSize == 1) {
-        handleNotInUse();
-      }
-    }
-  }
-
-  final boolean isInUse() {
-    return !inUseObjects.isEmpty();
-  }
-
-  /**
-   * Called when the aggregated in-use state has changed to true, which means at least one object is
-   * in use.
-   */
-  abstract void handleInUse();
-
-  /**
-   * Called when the aggregated in-use state has changed to false, which means no object is in use.
-   */
-  abstract void handleNotInUse();
-}
diff --git a/core/src/main/java/io/grpc/internal/InsightBuilder.java b/core/src/main/java/io/grpc/internal/InsightBuilder.java
new file mode 100644
index 00000000000..2d4fc3e021e
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/InsightBuilder.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2019 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.internal;
+
+import java.util.ArrayList;
+import javax.annotation.Nullable;
+
+/**
+ * Builds a concise and readable string that gives insight of the concerned part of the system.  The
+ * resulted string is made up of a list of short strings, each of which gives out a piece of
+ * information.
+ */
+public final class InsightBuilder {
+  private final ArrayList<String> buffer = new ArrayList<>();
+
+  /**
+   * Appends a piece of information which is a plain string.  The given object is immediately
+   * converted to string and recorded.
+   */
+  public InsightBuilder append(@Nullable Object insight) {
+    buffer.add(String.valueOf(insight));
+    return this;
+  }
+
+  /**
+   * Appends a piece of information which is a key-value , which will be formatted into {@code
+   * "key=value"}.  Value's {@code toString()} or {@code null} is immediately recorded.
+   */
+  public InsightBuilder appendKeyValue(String key, @Nullable Object value) {
+    buffer.add(key + "=" + value);
+    return this;
+  }
+
+  /**
+   * Get the resulting string.
+   */
+  @Override
+  public String toString() {
+    return buffer.toString();
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/InstantTimeProvider.java b/core/src/main/java/io/grpc/internal/InstantTimeProvider.java
new file mode 100644
index 00000000000..12996163753
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/InstantTimeProvider.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 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.internal;
+
+import static com.google.common.math.LongMath.saturatedAdd;
+
+import java.time.Instant;
+import java.util.concurrent.TimeUnit;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+
+/**
+ * {@link InstantTimeProvider} resolves InstantTimeProvider which implements {@link TimeProvider}.
+ */
+final class InstantTimeProvider implements TimeProvider {
+  @Override
+  @IgnoreJRERequirement
+  public long currentTimeNanos() {
+    Instant now = Instant.now();
+    long epochSeconds = now.getEpochSecond();
+    return saturatedAdd(TimeUnit.SECONDS.toNanos(epochSeconds), now.getNano());
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/InternalHandlerRegistry.java b/core/src/main/java/io/grpc/internal/InternalHandlerRegistry.java
index bf99d1860db..db81d113937 100644
--- a/core/src/main/java/io/grpc/internal/InternalHandlerRegistry.java
+++ b/core/src/main/java/io/grpc/internal/InternalHandlerRegistry.java
@@ -1,36 +1,22 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import io.grpc.HandlerRegistry;
 import io.grpc.ServerMethodDefinition;
 import io.grpc.ServerServiceDefinition;
 import java.util.ArrayList;
@@ -41,7 +27,7 @@
 import java.util.Map;
 import javax.annotation.Nullable;
 
-final class InternalHandlerRegistry {
+final class InternalHandlerRegistry extends HandlerRegistry {
 
   private final List<ServerServiceDefinition> services;
   private final Map<String, ServerMethodDefinition<?, ?>> methods;
@@ -55,20 +41,23 @@ private InternalHandlerRegistry(
   /**
    * Returns the service definitions in this registry.
    */
+  @Override
   public List<ServerServiceDefinition> getServices() {
     return services;
   }
 
   @Nullable
-  ServerMethodDefinition<?, ?> lookupMethod(String methodName) {
+  @Override
+  public ServerMethodDefinition<?, ?> lookupMethod(String methodName, @Nullable String authority) {
+    // TODO (carl-mastrangelo): honor authority header.
     return methods.get(methodName);
   }
 
-  static class Builder {
+  static final class Builder {
 
     // Store per-service first, to make sure services are added/replaced atomically.
     private final HashMap<String, ServerServiceDefinition> services =
-        new LinkedHashMap<String, ServerServiceDefinition>();
+        new LinkedHashMap<>();
 
     Builder addService(ServerServiceDefinition service) {
       services.put(service.getServiceDescriptor().getName(), service);
@@ -77,14 +66,14 @@ Builder addService(ServerServiceDefinition service) {
 
     InternalHandlerRegistry build() {
       Map<String, ServerMethodDefinition<?, ?>> map =
-          new HashMap<String, ServerMethodDefinition<?, ?>>();
+          new HashMap<>();
       for (ServerServiceDefinition service : services.values()) {
         for (ServerMethodDefinition<?, ?> method : service.getMethods()) {
           map.put(method.getMethodDescriptor().getFullMethodName(), method);
         }
       }
       return new InternalHandlerRegistry(
-          Collections.unmodifiableList(new ArrayList<ServerServiceDefinition>(services.values())),
+          Collections.unmodifiableList(new ArrayList<>(services.values())),
           Collections.unmodifiableMap(map));
     }
   }
diff --git a/core/src/main/java/io/grpc/internal/InternalServer.java b/core/src/main/java/io/grpc/internal/InternalServer.java
index ad0903a24c3..a6079081233 100644
--- a/core/src/main/java/io/grpc/internal/InternalServer.java
+++ b/core/src/main/java/io/grpc/internal/InternalServer.java
@@ -1,42 +1,32 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
 import java.io.IOException;
+import java.net.SocketAddress;
+import java.util.List;
+import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
- * An object that accepts new incoming connections. This would commonly encapsulate a bound socket
- * that {@code accept()}s new connections.
+ * An object that accepts new incoming connections on one or more listening socket addresses.
+ * This would commonly encapsulate a bound socket that {@code accept()}s new connections.
  */
 @ThreadSafe
 public interface InternalServer {
@@ -53,13 +43,32 @@ public interface InternalServer {
   /**
    * Initiates an orderly shutdown of the server. Existing transports continue, but new transports
    * will not be created (once {@link ServerListener#serverShutdown()} callback is called). This
-   * method may only be called once.
+   * method may only be called once.  Blocks until the listening socket(s) have been closed.  If
+   * interrupted, this method will not wait for the close to complete, but it will happen
+   * asynchronously.
    */
   void shutdown();
 
   /**
-   * Returns what underlying port the server is listening on, or -1 if the port number is not
-   * available or does not make sense.
+   * Returns the first listening socket address.  May change after {@link #start(ServerListener)} is
+   * called.
+   */
+  SocketAddress getListenSocketAddress();
+
+  /**
+   * Returns the first listen socket stats of this server. May return {@code null}.
    */
-  int getPort();
+  @Nullable InternalInstrumented<SocketStats> getListenSocketStats();
+
+  /**
+   * Returns a list of listening socket addresses.  May change after {@link #start(ServerListener)}
+   * is called.
+   */
+  List<? extends SocketAddress> getListenSocketAddresses();
+
+  /**
+   * Returns a list of listen socket stats of this server. May return {@code null}.
+   */
+  @Nullable List<InternalInstrumented<SocketStats>> getListenSocketStatsList();
+
 }
diff --git a/core/src/main/java/io/grpc/internal/InternalSubchannel.java b/core/src/main/java/io/grpc/internal/InternalSubchannel.java
index d221803c930..7a48bf642fe 100644
--- a/core/src/main/java/io/grpc/internal/InternalSubchannel.java
+++ b/core/src/main/java/io/grpc/internal/InternalSubchannel.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -35,98 +20,128 @@
 import static io.grpc.ConnectivityState.IDLE;
 import static io.grpc.ConnectivityState.READY;
 import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Stopwatch;
 import com.google.common.base.Supplier;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
 import com.google.errorprone.annotations.ForOverride;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ClientTransportFilter;
 import io.grpc.ConnectivityState;
 import io.grpc.ConnectivityStateInfo;
 import io.grpc.EquivalentAddressGroup;
+import io.grpc.HttpConnectProxiedSocketAddress;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.ChannelStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.InternalLogId;
+import io.grpc.InternalWithLogId;
+import io.grpc.LoadBalancer;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MetricRecorder;
+import io.grpc.NameResolver;
+import io.grpc.SecurityLevel;
 import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
 import java.net.SocketAddress;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
 import javax.annotation.concurrent.ThreadSafe;
 
 /**
  * Transports for a single {@link SocketAddress}.
- *
- * <p>This is the next version of {@link TransportSet} in development.
  */
 @ThreadSafe
-final class InternalSubchannel implements WithLogId {
-  private static final Logger log = Logger.getLogger(InternalSubchannel.class.getName());
+final class InternalSubchannel implements InternalInstrumented<ChannelStats>, TransportProvider {
 
-  private final LogId logId = LogId.allocate(getClass().getName());
-  private final EquivalentAddressGroup addressGroup;
+  private final InternalLogId logId;
   private final String authority;
   private final String userAgent;
   private final BackoffPolicy.Provider backoffPolicyProvider;
   private final Callback callback;
   private final ClientTransportFactory transportFactory;
   private final ScheduledExecutorService scheduledExecutor;
+  private final InternalChannelz channelz;
+  private final CallTracer callsTracer;
+  private final ChannelTracer channelTracer;
+  private final ChannelLogger channelLogger;
+  private final boolean reconnectDisabled;
 
-  // File-specific convention: methods without GuardedBy("lock") MUST NOT be called under the lock.
-  private final Object lock = new Object();
+  private final List<ClientTransportFilter> transportFilters;
 
-  // File-specific convention:
-  //
-  // 1. In a method without GuardedBy("lock"), executeLater() MUST be followed by a drain() later in
-  // the same method.
-  //
-  // 2. drain() MUST NOT be called under "lock".
-  //
-  // 3. Every synchronized("lock") must be inside a try-finally which calls drain() in "finally".
-  private final ChannelExecutor channelExecutor;
+  /**
+   * All field must be mutated in the syncContext.
+   */
+  private final SynchronizationContext syncContext;
+
+  /**
+   * The index of the address corresponding to pendingTransport/activeTransport, or at beginning if
+   * both are null.
+   *
+   * <p>Note: any {@link Index#updateAddresses(List)} should also update {@link #addressGroups}.
+   */
+  private final Index addressIndex;
 
-  @GuardedBy("lock")
-  private int nextAddressIndex;
+  /**
+   * A volatile accessor to {@link Index#getAddressGroups()}. There are few methods ({@link
+   * #getAddressGroups()} and {@link #toString()} access this value where they supposed to access
+   * in the {@link #syncContext}. Ideally {@link Index#getAddressGroups()} can be volatile, so we
+   * don't need to maintain this volatile accessor. Although, having this accessor can reduce
+   * unnecessary volatile reads while it delivers clearer intention of why .
+   */
+  private volatile List<EquivalentAddressGroup> addressGroups;
 
   /**
-   * The policy to control back off between reconnects. Non-{@code null} when last connect failed.
+   * The policy to control back off between reconnects. Non-{@code null} when a reconnect task is
+   * scheduled.
    */
-  @GuardedBy("lock")
   private BackoffPolicy reconnectPolicy;
 
   /**
    * Timer monitoring duration since entering CONNECTING state.
    */
-  @GuardedBy("lock")
   private final Stopwatch connectingTimer;
 
-  @GuardedBy("lock")
   @Nullable
-  private ScheduledFuture<?> reconnectTask;
+  private ScheduledHandle reconnectTask;
+  @Nullable
+  private ScheduledHandle shutdownDueToUpdateTask;
+  @Nullable
+  private ManagedClientTransport shutdownDueToUpdateTransport;
 
   /**
    * All transports that are not terminated. At the very least the value of {@link #activeTransport}
    * will be present, but previously used transports that still have streams or are stopping may
    * also be present.
    */
-  @GuardedBy("lock")
-  private final Collection<ConnectionClientTransport> transports =
-      new ArrayList<ConnectionClientTransport>();
+  private final Collection<ConnectionClientTransport> transports = new ArrayList<>();
 
-  // Must only be used from channelExecutor
-  private final InUseStateAggregator2<ConnectionClientTransport> inUseStateAggregator =
-      new InUseStateAggregator2<ConnectionClientTransport>() {
+  // Must only be used from syncContext
+  private final InUseStateAggregator<ConnectionClientTransport> inUseStateAggregator =
+      new InUseStateAggregator<ConnectionClientTransport>() {
         @Override
-        void handleInUse() {
+        protected void handleInUse() {
           callback.onInUse(InternalSubchannel.this);
         }
 
         @Override
-        void handleNotInUse() {
+        protected void handleNotInUse() {
           callback.onNotInUse(InternalSubchannel.this);
         }
       };
@@ -134,89 +149,139 @@ void handleNotInUse() {
   /**
    * The to-be active transport, which is not ready yet.
    */
-  @GuardedBy("lock")
   @Nullable
   private ConnectionClientTransport pendingTransport;
 
   /**
-   * The transport for new outgoing requests. 'lock' must be held when assigning to it. Non-null
-   * only in READY state.
+   * The transport for new outgoing requests. Non-null only in READY state.
    */
   @Nullable
   private volatile ManagedClientTransport activeTransport;
 
-  @GuardedBy("lock")
-  private ConnectivityStateInfo state = ConnectivityStateInfo.forNonError(IDLE);
-
-  InternalSubchannel(EquivalentAddressGroup addressGroup, String authority, String userAgent,
-      BackoffPolicy.Provider backoffPolicyProvider,
-      ClientTransportFactory transportFactory, ScheduledExecutorService scheduledExecutor,
-      Supplier<Stopwatch> stopwatchSupplier, ChannelExecutor channelExecutor, Callback callback) {
-    this.addressGroup = Preconditions.checkNotNull(addressGroup, "addressGroup");
+  private volatile ConnectivityStateInfo state = ConnectivityStateInfo.forNonError(IDLE);
+
+  private Status shutdownReason;
+
+  private volatile Attributes connectedAddressAttributes;
+  private final SubchannelMetrics subchannelMetrics;
+  private final String target;
+
+  InternalSubchannel(LoadBalancer.CreateSubchannelArgs args, String authority, String userAgent,
+                     BackoffPolicy.Provider backoffPolicyProvider,
+                     ClientTransportFactory transportFactory,
+                     ScheduledExecutorService scheduledExecutor,
+                     Supplier<Stopwatch> stopwatchSupplier, SynchronizationContext syncContext,
+                     Callback callback, InternalChannelz channelz, CallTracer callsTracer,
+                     ChannelTracer channelTracer, InternalLogId logId,
+                     ChannelLogger channelLogger, List<ClientTransportFilter> transportFilters,
+                     String target,
+                     MetricRecorder metricRecorder) {
+    List<EquivalentAddressGroup> addressGroups = args.getAddresses();
+    Preconditions.checkNotNull(addressGroups, "addressGroups");
+    Preconditions.checkArgument(!addressGroups.isEmpty(), "addressGroups is empty");
+    checkListHasNoNulls(addressGroups, "addressGroups contains null entry");
+    List<EquivalentAddressGroup> unmodifiableAddressGroups =
+        Collections.unmodifiableList(new ArrayList<>(addressGroups));
+    this.addressGroups = unmodifiableAddressGroups;
+    this.addressIndex = new Index(unmodifiableAddressGroups);
     this.authority = authority;
     this.userAgent = userAgent;
     this.backoffPolicyProvider = backoffPolicyProvider;
     this.transportFactory = transportFactory;
     this.scheduledExecutor = scheduledExecutor;
     this.connectingTimer = stopwatchSupplier.get();
-    this.channelExecutor = channelExecutor;
+    this.syncContext = syncContext;
     this.callback = callback;
+    this.channelz = channelz;
+    this.callsTracer = callsTracer;
+    this.channelTracer = Preconditions.checkNotNull(channelTracer, "channelTracer");
+    this.logId = Preconditions.checkNotNull(logId, "logId");
+    this.channelLogger = Preconditions.checkNotNull(channelLogger, "channelLogger");
+    this.transportFilters = transportFilters;
+    this.reconnectDisabled = args.getOption(LoadBalancer.DISABLE_SUBCHANNEL_RECONNECT_KEY);
+    this.target = target;
+    this.subchannelMetrics = new SubchannelMetrics(metricRecorder);
   }
 
-  /**
-   * Returns a READY transport that will be used to create new streams.
-   *
-   * <p>Returns {@code null} if the state is not READY.  Will try to connect if state is IDLE.
-   */
-  @Nullable
-  ClientTransport obtainActiveTransport() {
+  ChannelLogger getChannelLogger() {
+    return channelLogger;
+  }
+
+  @Override
+  public ClientTransport obtainActiveTransport() {
     ClientTransport savedTransport = activeTransport;
     if (savedTransport != null) {
       return savedTransport;
     }
-    try {
-      synchronized (lock) {
-        savedTransport = activeTransport;
-        // Check again, since it could have changed before acquiring the lock
-        if (savedTransport != null) {
-          return savedTransport;
-        }
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
         if (state.getState() == IDLE) {
+          channelLogger.log(ChannelLogLevel.INFO, "CONNECTING as requested");
           gotoNonErrorState(CONNECTING);
           startNewTransport();
         }
       }
-    } finally {
-      channelExecutor.drain();
-    }
+    });
     return null;
   }
 
-  @GuardedBy("lock")
+  /**
+   * Returns a READY transport if there is any, without trying to connect.
+   */
+  @Nullable
+  ClientTransport getTransport() {
+    return activeTransport;
+  }
+
+  /**
+   * Returns the authority string associated with this Subchannel.
+   */
+  String getAuthority() {
+    return authority;
+  }
+
   private void startNewTransport() {
+    syncContext.throwIfNotInThisSynchronizationContext();
+
     Preconditions.checkState(reconnectTask == null, "Should have no reconnectTask scheduled");
 
-    if (nextAddressIndex == 0) {
+    if (addressIndex.isAtBeginning()) {
       connectingTimer.reset().start();
     }
-    List<SocketAddress> addrs = addressGroup.getAddresses();
-    final SocketAddress address = addrs.get(nextAddressIndex++);
-    if (nextAddressIndex >= addrs.size()) {
-      nextAddressIndex = 0;
+    SocketAddress address = addressIndex.getCurrentAddress();
+
+    HttpConnectProxiedSocketAddress proxiedAddr = null;
+    if (address instanceof HttpConnectProxiedSocketAddress) {
+      proxiedAddr = (HttpConnectProxiedSocketAddress) address;
+      address = proxiedAddr.getTargetAddress();
     }
 
+    Attributes currentEagAttributes = addressIndex.getCurrentEagAttributes();
+    String eagChannelAuthority = currentEagAttributes
+            .get(EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE);
+    ClientTransportFactory.ClientTransportOptions options =
+        new ClientTransportFactory.ClientTransportOptions()
+          .setAuthority(eagChannelAuthority != null ? eagChannelAuthority : authority)
+          .setEagAttributes(currentEagAttributes)
+          .setUserAgent(userAgent)
+          .setHttpConnectProxiedSocketAddress(proxiedAddr);
+    TransportLogger transportLogger = new TransportLogger();
+    // In case the transport logs in the constructor, use the subchannel logId
+    transportLogger.logId = getLogId();
     ConnectionClientTransport transport =
-        transportFactory.newClientTransport(address, authority, userAgent);
-    if (log.isLoggable(Level.FINE)) {
-      log.log(Level.FINE, "[{0}] Created {1} for {2}",
-          new Object[] {logId, transport.getLogId(), address});
-    }
+        new CallTracingTransport(
+            transportFactory
+                .newClientTransport(address, options, transportLogger), callsTracer);
+    transportLogger.logId = transport.getLogId();
+    channelz.addClientSocket(transport);
     pendingTransport = transport;
     transports.add(transport);
-    Runnable runnable = transport.start(new TransportListener(transport, address));
+    Runnable runnable = transport.start(new TransportListener(transport));
     if (runnable != null) {
-      channelExecutor.executeLater(runnable);
+      syncContext.executeLater(runnable);
     }
+    channelLogger.log(ChannelLogLevel.INFO, "Started transport {0}", transportLogger.logId);
   }
 
   /**
@@ -224,199 +289,329 @@ private void startNewTransport() {
    * @param status the causal status when the channel begins transition to
    *     TRANSIENT_FAILURE.
    */
-  @GuardedBy("lock")
   private void scheduleBackoff(final Status status) {
+    syncContext.throwIfNotInThisSynchronizationContext();
+
     class EndOfCurrentBackoff implements Runnable {
       @Override
       public void run() {
-        try {
-          synchronized (lock) {
-            reconnectTask = null;
-            if (state.getState() == SHUTDOWN) {
-              // Even though shutdown() will cancel this task, the task may have already started
-              // when it's being cancelled.
-              return;
-            }
-            gotoNonErrorState(CONNECTING);
-            startNewTransport();
-          }
-        } catch (Throwable t) {
-          log.log(Level.WARNING, "Exception handling end of backoff", t);
-        } finally {
-          channelExecutor.drain();
-        }
+        reconnectTask = null;
+        channelLogger.log(ChannelLogLevel.INFO, "CONNECTING after backoff");
+        gotoNonErrorState(CONNECTING);
+        startNewTransport();
       }
     }
 
     gotoState(ConnectivityStateInfo.forTransientFailure(status));
+
+    if (reconnectDisabled) {
+      return;
+    }
+
     if (reconnectPolicy == null) {
       reconnectPolicy = backoffPolicyProvider.get();
     }
-    long delayMillis =
-        reconnectPolicy.nextBackoffMillis() - connectingTimer.elapsed(TimeUnit.MILLISECONDS);
-    if (log.isLoggable(Level.FINE)) {
-      log.log(Level.FINE, "[{0}] Scheduling backoff for {1} ms", new Object[]{logId, delayMillis});
-    }
+    long delayNanos =
+        reconnectPolicy.nextBackoffNanos() - connectingTimer.elapsed(TimeUnit.NANOSECONDS);
+    channelLogger.log(
+        ChannelLogLevel.INFO,
+        "TRANSIENT_FAILURE ({0}). Will reconnect after {1} ns",
+        printShortStatus(status), delayNanos);
     Preconditions.checkState(reconnectTask == null, "previous reconnectTask is not done");
-    reconnectTask = scheduledExecutor.schedule(
-        new LogExceptionRunnable(new EndOfCurrentBackoff()),
-        delayMillis,
-        TimeUnit.MILLISECONDS);
+    reconnectTask = syncContext.schedule(
+        new EndOfCurrentBackoff(),
+        delayNanos,
+        TimeUnit.NANOSECONDS,
+        scheduledExecutor);
+  }
+
+  /**
+   * Immediately attempt to reconnect if the current state is TRANSIENT_FAILURE. Otherwise, this
+   * method has no effect.
+   */
+  void resetConnectBackoff() {
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        if (state.getState() != TRANSIENT_FAILURE) {
+          return;
+        }
+        cancelReconnectTask();
+        channelLogger.log(ChannelLogLevel.INFO, "CONNECTING; backoff interrupted");
+        gotoNonErrorState(CONNECTING);
+        startNewTransport();
+      }
+    });
   }
 
-  @GuardedBy("lock")
-  private void gotoNonErrorState(ConnectivityState newState) {
+  private void gotoNonErrorState(final ConnectivityState newState) {
+    syncContext.throwIfNotInThisSynchronizationContext();
+
     gotoState(ConnectivityStateInfo.forNonError(newState));
   }
 
-  @GuardedBy("lock")
   private void gotoState(final ConnectivityStateInfo newState) {
+    syncContext.throwIfNotInThisSynchronizationContext();
+
     if (state.getState() != newState.getState()) {
       Preconditions.checkState(state.getState() != SHUTDOWN,
-          "Cannot transition out of SHUTDOWN to " + newState);
-      state = newState;
-      channelExecutor.executeLater(new Runnable() {
-          @Override
-          public void run() {
-            callback.onStateChange(InternalSubchannel.this, newState);
-          }
-        });
+          "Cannot transition out of SHUTDOWN to %s", newState.getState());
+      if (reconnectDisabled && newState.getState() == TRANSIENT_FAILURE) {
+        state = ConnectivityStateInfo.forNonError(IDLE);
+      } else {
+        state = newState;
+      }
+      callback.onStateChange(InternalSubchannel.this, newState);
     }
   }
 
-  public void shutdown() {
-    ManagedClientTransport savedActiveTransport;
-    ConnectionClientTransport savedPendingTransport;
-    try {
-      synchronized (lock) {
+  /** Replaces the existing addresses, avoiding unnecessary reconnects. */
+  public void updateAddresses(final List<EquivalentAddressGroup> newAddressGroups) {
+    Preconditions.checkNotNull(newAddressGroups, "newAddressGroups");
+    checkListHasNoNulls(newAddressGroups, "newAddressGroups contains null entry");
+    Preconditions.checkArgument(!newAddressGroups.isEmpty(), "newAddressGroups is empty");
+    final List<EquivalentAddressGroup> newImmutableAddressGroups =
+        Collections.unmodifiableList(new ArrayList<>(newAddressGroups));
+
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        ManagedClientTransport savedTransport = null;
+        SocketAddress previousAddress = addressIndex.getCurrentAddress();
+        addressIndex.updateGroups(newImmutableAddressGroups);
+        addressGroups = newImmutableAddressGroups;
+        if (state.getState() == READY || state.getState() == CONNECTING) {
+          if (!addressIndex.seekTo(previousAddress)) {
+            // Forced to drop the connection
+            if (state.getState() == READY) {
+              savedTransport = activeTransport;
+              activeTransport = null;
+              addressIndex.reset();
+              gotoNonErrorState(IDLE);
+            } else {
+              pendingTransport.shutdown(
+                  Status.UNAVAILABLE.withDescription(
+                    "InternalSubchannel closed pending transport due to address change"));
+              pendingTransport = null;
+              addressIndex.reset();
+              startNewTransport();
+            }
+          }
+        }
+        if (savedTransport != null) {
+          if (shutdownDueToUpdateTask != null) {
+            // Keeping track of multiple shutdown tasks adds complexity, and shouldn't generally be
+            // necessary. This transport has probably already had plenty of time.
+            shutdownDueToUpdateTransport.shutdown(
+                Status.UNAVAILABLE.withDescription(
+                    "InternalSubchannel closed transport early due to address change"));
+            shutdownDueToUpdateTask.cancel();
+            shutdownDueToUpdateTask = null;
+            shutdownDueToUpdateTransport = null;
+          }
+          // Avoid needless RPC failures by delaying the shutdown. See
+          // https://github.com/grpc/grpc-java/issues/2562
+          shutdownDueToUpdateTransport = savedTransport;
+          shutdownDueToUpdateTask = syncContext.schedule(
+              new Runnable() {
+                @Override public void run() {
+                  ManagedClientTransport transport = shutdownDueToUpdateTransport;
+                  shutdownDueToUpdateTask = null;
+                  shutdownDueToUpdateTransport = null;
+                  transport.shutdown(
+                      Status.UNAVAILABLE.withDescription(
+                          "InternalSubchannel closed transport due to address change"));
+                }
+              },
+              ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS,
+              TimeUnit.SECONDS,
+              scheduledExecutor);
+        }
+      }
+    });
+  }
+
+  public void shutdown(final Status reason) {
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        ManagedClientTransport savedActiveTransport;
+        ConnectionClientTransport savedPendingTransport;
         if (state.getState() == SHUTDOWN) {
           return;
         }
-        gotoNonErrorState(SHUTDOWN);
+        shutdownReason = reason;
         savedActiveTransport = activeTransport;
         savedPendingTransport = pendingTransport;
         activeTransport = null;
         pendingTransport = null;
+        gotoNonErrorState(SHUTDOWN);
+        addressIndex.reset();
         if (transports.isEmpty()) {
           handleTermination();
-          if (log.isLoggable(Level.FINE)) {
-            log.log(Level.FINE, "[{0}] Terminated in shutdown()", logId);
-          }
         }  // else: the callback will be run once all transports have been terminated
         cancelReconnectTask();
+        if (shutdownDueToUpdateTask != null) {
+          shutdownDueToUpdateTask.cancel();
+          shutdownDueToUpdateTransport.shutdown(reason);
+          shutdownDueToUpdateTask = null;
+          shutdownDueToUpdateTransport = null;
+        }
+        if (savedActiveTransport != null) {
+          savedActiveTransport.shutdown(reason);
+        }
+        if (savedPendingTransport != null) {
+          savedPendingTransport.shutdown(reason);
+        }
       }
-    } finally {
-      channelExecutor.drain();
-    }
-    if (savedActiveTransport != null) {
-      savedActiveTransport.shutdown();
-    }
-    if (savedPendingTransport != null) {
-      savedPendingTransport.shutdown();
-    }
+    });
+  }
+
+  @Override
+  public String toString() {
+    // addressGroupsCopy being a little stale is fine, just avoid calling toString with the lock
+    // since there may be many addresses.
+    return MoreObjects.toStringHelper(this)
+        .add("logId", logId.getId())
+        .add("addressGroups", addressGroups)
+        .toString();
   }
 
-  @GuardedBy("lock")
   private void handleTermination() {
-    channelExecutor.executeLater(new Runnable() {
-        @Override
-        public void run() {
-          callback.onTerminated(InternalSubchannel.this);
-        }
-      });
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        channelLogger.log(ChannelLogLevel.INFO, "Terminated");
+        callback.onTerminated(InternalSubchannel.this);
+      }
+    });
   }
 
   private void handleTransportInUseState(
       final ConnectionClientTransport transport, final boolean inUse) {
-    channelExecutor.executeLater(new Runnable() {
-        @Override
-        public void run() {
-          inUseStateAggregator.updateObjectInUse(transport, inUse);
-        }
-      }).drain();
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        inUseStateAggregator.updateObjectInUse(transport, inUse);
+      }
+    });
   }
 
-  void shutdownNow(Status reason) {
-    shutdown();
-    Collection<ManagedClientTransport> transportsCopy;
-    try {
-      synchronized (lock) {
-        transportsCopy = new ArrayList<ManagedClientTransport>(transports);
+  void shutdownNow(final Status reason) {
+    shutdown(reason);
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        Collection<ManagedClientTransport> transportsCopy =
+            new ArrayList<ManagedClientTransport>(transports);
+
+        for (ManagedClientTransport transport : transportsCopy) {
+          transport.shutdownNow(reason);
+        }
       }
-    } finally {
-      channelExecutor.drain();
-    }
-    for (ManagedClientTransport transport : transportsCopy) {
-      transport.shutdownNow(reason);
-    }
+    });
   }
 
-  EquivalentAddressGroup getAddressGroup() {
-    return addressGroup;
+  List<EquivalentAddressGroup> getAddressGroups() {
+    return addressGroups;
   }
 
-  @GuardedBy("lock")
   private void cancelReconnectTask() {
+    syncContext.throwIfNotInThisSynchronizationContext();
+
     if (reconnectTask != null) {
-      reconnectTask.cancel(false);
+      reconnectTask.cancel();
       reconnectTask = null;
+      reconnectPolicy = null;
     }
   }
 
   @Override
-  public LogId getLogId() {
+  public InternalLogId getLogId() {
     return logId;
   }
 
-  @VisibleForTesting
-  ConnectivityState getState() {
-    try {
-      synchronized (lock) {
-        return state.getState();
+  @Override
+  public ListenableFuture<ChannelStats> getStats() {
+    final SettableFuture<ChannelStats> channelStatsFuture = SettableFuture.create();
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        ChannelStats.Builder builder = new ChannelStats.Builder();
+        List<EquivalentAddressGroup> addressGroupsSnapshot = addressIndex.getGroups();
+        List<InternalWithLogId> transportsSnapshot = new ArrayList<InternalWithLogId>(transports);
+        builder.setTarget(addressGroupsSnapshot.toString()).setState(getState());
+        builder.setSockets(transportsSnapshot);
+        callsTracer.updateBuilder(builder);
+        channelTracer.updateBuilder(builder);
+        channelStatsFuture.set(builder.build());
       }
-    } finally {
-      channelExecutor.drain();
+    });
+    return channelStatsFuture;
+  }
+
+  /**
+   * Return attributes for server address connected by sub channel.
+   */
+  public Attributes getConnectedAddressAttributes() {
+    return connectedAddressAttributes;
+  }
+
+  ConnectivityState getState() {
+    return state.getState();
+  }
+
+  private static void checkListHasNoNulls(List<?> list, String msg) {
+    for (Object item : list) {
+      Preconditions.checkNotNull(item, msg);
     }
   }
 
   /** Listener for real transports. */
   private class TransportListener implements ManagedClientTransport.Listener {
     final ConnectionClientTransport transport;
-    final SocketAddress address;
+    boolean shutdownInitiated = false;
 
-    TransportListener(ConnectionClientTransport transport, SocketAddress address) {
+    TransportListener(ConnectionClientTransport transport) {
       this.transport = transport;
-      this.address = address;
     }
 
     @Override
-    public void transportReady() {
-      if (log.isLoggable(Level.FINE)) {
-        log.log(Level.FINE, "[{0}] {1} for {2} is ready",
-            new Object[] {logId, transport.getLogId(), address});
+    public Attributes filterTransport(Attributes attributes) {
+      for (ClientTransportFilter filter : transportFilters) {
+        attributes = Preconditions.checkNotNull(filter.transportReady(attributes),
+            "Filter %s returned null", filter);
       }
-      ConnectivityState savedState;
-      try {
-        synchronized (lock) {
-          savedState = state.getState();
+      return attributes;
+    }
+
+    @Override
+    public void transportReady() {
+      channelLogger.log(ChannelLogLevel.INFO, "READY");
+      syncContext.execute(new Runnable() {
+        @Override
+        public void run() {
           reconnectPolicy = null;
-          nextAddressIndex = 0;
-          if (savedState == SHUTDOWN) {
+          if (shutdownReason != null) {
             // activeTransport should have already been set to null by shutdown(). We keep it null.
             Preconditions.checkState(activeTransport == null,
                 "Unexpected non-null activeTransport");
+            transport.shutdown(shutdownReason);
           } else if (pendingTransport == transport) {
-            gotoNonErrorState(READY);
             activeTransport = transport;
             pendingTransport = null;
+            connectedAddressAttributes = addressIndex.getCurrentEagAttributes();
+            gotoNonErrorState(READY);
+            subchannelMetrics.recordConnectionAttemptSucceeded(/* target= */ target,
+                /* backendService= */ getAttributeOrDefault(
+                    addressIndex.getCurrentEagAttributes(), NameResolver.ATTR_BACKEND_SERVICE),
+                /* locality= */ getAttributeOrDefault(addressIndex.getCurrentEagAttributes(),
+                    EquivalentAddressGroup.ATTR_LOCALITY_NAME),
+                /* securityLevel= */ extractSecurityLevel(addressIndex.getCurrentEagAttributes()
+                    .get(GrpcAttributes.ATTR_SECURITY_LEVEL)));
           }
         }
-      } finally {
-        channelExecutor.drain();
-      }
-      if (savedState == SHUTDOWN) {
-        transport.shutdown();
-      }
+      });
     }
 
     @Override
@@ -425,24 +620,41 @@ public void transportInUse(boolean inUse) {
     }
 
     @Override
-    public void transportShutdown(Status s) {
-      if (log.isLoggable(Level.FINE)) {
-        log.log(Level.FINE, "[{0}] {1} for {2} is being shutdown with status {3}",
-            new Object[] {logId, transport.getLogId(), address, s});
-      }
-      try {
-        synchronized (lock) {
+    public void transportShutdown(final Status s, final DisconnectError disconnectError) {
+      channelLogger.log(
+          ChannelLogLevel.INFO, "{0} SHUTDOWN with {1}", transport.getLogId(), printShortStatus(s));
+      shutdownInitiated = true;
+      syncContext.execute(new Runnable() {
+        @Override
+        public void run() {
           if (state.getState() == SHUTDOWN) {
             return;
           }
           if (activeTransport == transport) {
-            gotoNonErrorState(IDLE);
             activeTransport = null;
+            addressIndex.reset();
+            gotoNonErrorState(IDLE);
+            subchannelMetrics.recordDisconnection(/* target= */ target,
+                /* backendService= */ getAttributeOrDefault(addressIndex.getCurrentEagAttributes(),
+                    NameResolver.ATTR_BACKEND_SERVICE),
+                /* locality= */ getAttributeOrDefault(addressIndex.getCurrentEagAttributes(),
+                    EquivalentAddressGroup.ATTR_LOCALITY_NAME),
+                /* disconnectError= */ disconnectError.toErrorString(),
+                /* securityLevel= */ extractSecurityLevel(addressIndex.getCurrentEagAttributes()
+                    .get(GrpcAttributes.ATTR_SECURITY_LEVEL)));
           } else if (pendingTransport == transport) {
+            subchannelMetrics.recordConnectionAttemptFailed(/* target= */ target,
+                /* backendService= */getAttributeOrDefault(addressIndex.getCurrentEagAttributes(),
+                    NameResolver.ATTR_BACKEND_SERVICE),
+                /* locality= */ getAttributeOrDefault(addressIndex.getCurrentEagAttributes(),
+                    EquivalentAddressGroup.ATTR_LOCALITY_NAME));
             Preconditions.checkState(state.getState() == CONNECTING,
                 "Expected state is CONNECTING, actual state is %s", state.getState());
-            // Continue reconnect if there are still addresses to try.
-            if (nextAddressIndex == 0) {
+            addressIndex.increment();
+            // Continue to reconnect if there are still addresses to try.
+            if (!addressIndex.isValid()) {
+              pendingTransport = null;
+              addressIndex.reset();
               // Initiate backoff
               // Transition to TRANSIENT_FAILURE
               scheduleBackoff(s);
@@ -451,38 +663,54 @@ public void transportShutdown(Status s) {
             }
           }
         }
-      } finally {
-        channelExecutor.drain();
-      }
+      });
     }
 
     @Override
     public void transportTerminated() {
-      if (log.isLoggable(Level.FINE)) {
-        log.log(Level.FINE, "[{0}] {1} for {2} is terminated",
-            new Object[] {logId, transport.getLogId(), address});
-      }
+      Preconditions.checkState(
+          shutdownInitiated, "transportShutdown() must be called before transportTerminated().");
+
+      channelLogger.log(ChannelLogLevel.INFO, "{0} Terminated", transport.getLogId());
+      channelz.removeClientSocket(transport);
       handleTransportInUseState(transport, false);
-      try {
-        synchronized (lock) {
+      for (ClientTransportFilter filter : transportFilters) {
+        filter.transportTerminated(transport.getAttributes());
+      }
+      syncContext.execute(new Runnable() {
+        @Override
+        public void run() {
           transports.remove(transport);
           if (state.getState() == SHUTDOWN && transports.isEmpty()) {
-            if (log.isLoggable(Level.FINE)) {
-              log.log(Level.FINE, "[{0}] Terminated in transportTerminated()", logId);
-            }
             handleTermination();
           }
         }
-      } finally {
-        channelExecutor.drain();
+      });
+    }
+
+    private String extractSecurityLevel(SecurityLevel securityLevel) {
+      if (securityLevel == null) {
+        return "none";
+      }
+      switch (securityLevel) {
+        case NONE:
+          return "none";
+        case INTEGRITY:
+          return "integrity_only";
+        case PRIVACY_AND_INTEGRITY:
+          return "privacy_and_integrity";
+        default:
+          throw new IllegalArgumentException("Unknown SecurityLevel: " + securityLevel);
       }
-      Preconditions.checkState(activeTransport != transport,
-          "activeTransport still points to this transport. "
-          + "Seems transportShutdown() was not called.");
+    }
+
+    private String getAttributeOrDefault(Attributes attributes, Attributes.Key<String> key) {
+      String value = attributes.get(key);
+      return value == null ? "" : value;
     }
   }
 
-  // All methods are called in channelExecutor, which is a serializing executor.
+  // All methods are called in syncContext
   abstract static class Callback {
     /**
      * Called when the subchannel is terminated, which means it's shut down and all transports
@@ -511,4 +739,147 @@ void onInUse(InternalSubchannel is) { }
     @ForOverride
     void onNotInUse(InternalSubchannel is) { }
   }
+
+  @VisibleForTesting
+  static final class CallTracingTransport extends ForwardingConnectionClientTransport {
+    private final ConnectionClientTransport delegate;
+    private final CallTracer callTracer;
+
+    private CallTracingTransport(ConnectionClientTransport delegate, CallTracer callTracer) {
+      this.delegate = delegate;
+      this.callTracer = callTracer;
+    }
+
+    @Override
+    protected ConnectionClientTransport delegate() {
+      return delegate;
+    }
+
+    @Override
+    public ClientStream newStream(
+        MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+        ClientStreamTracer[] tracers) {
+      final ClientStream streamDelegate = super.newStream(method, headers, callOptions, tracers);
+      return new ForwardingClientStream() {
+        @Override
+        protected ClientStream delegate() {
+          return streamDelegate;
+        }
+
+        @Override
+        public void start(final ClientStreamListener listener) {
+          callTracer.reportCallStarted();
+          super.start(new ForwardingClientStreamListener() {
+            @Override
+            protected ClientStreamListener delegate() {
+              return listener;
+            }
+
+            @Override
+            public void closed(
+                Status status, RpcProgress rpcProgress, Metadata trailers) {
+              callTracer.reportCallEnded(status.isOk());
+              super.closed(status, rpcProgress, trailers);
+            }
+          });
+        }
+      };
+    }
+  }
+
+  /** Index as in 'i', the pointer to an entry. Not a "search index." */
+  @VisibleForTesting
+  static final class Index {
+    private List<EquivalentAddressGroup> addressGroups;
+    private int groupIndex;
+    private int addressIndex;
+
+    public Index(List<EquivalentAddressGroup> groups) {
+      this.addressGroups = groups;
+    }
+
+    public boolean isValid() {
+      // addressIndex will never be invalid
+      return groupIndex < addressGroups.size();
+    }
+
+    public boolean isAtBeginning() {
+      return groupIndex == 0 && addressIndex == 0;
+    }
+
+    public void increment() {
+      EquivalentAddressGroup group = addressGroups.get(groupIndex);
+      addressIndex++;
+      if (addressIndex >= group.getAddresses().size()) {
+        groupIndex++;
+        addressIndex = 0;
+      }
+    }
+
+    public void reset() {
+      groupIndex = 0;
+      addressIndex = 0;
+    }
+
+    public SocketAddress getCurrentAddress() {
+      return addressGroups.get(groupIndex).getAddresses().get(addressIndex);
+    }
+
+    public Attributes getCurrentEagAttributes() {
+      return addressGroups.get(groupIndex).getAttributes();
+    }
+
+    public List<EquivalentAddressGroup> getGroups() {
+      return addressGroups;
+    }
+
+    /** Update to new groups, resetting the current index. */
+    public void updateGroups(List<EquivalentAddressGroup> newGroups) {
+      addressGroups = newGroups;
+      reset();
+    }
+
+    /** Returns false if the needle was not found and the current index was left unchanged. */
+    public boolean seekTo(SocketAddress needle) {
+      for (int i = 0; i < addressGroups.size(); i++) {
+        EquivalentAddressGroup group = addressGroups.get(i);
+        int j = group.getAddresses().indexOf(needle);
+        if (j == -1) {
+          continue;
+        }
+        this.groupIndex = i;
+        this.addressIndex = j;
+        return true;
+      }
+      return false;
+    }
+  }
+
+  private String printShortStatus(Status status) {
+    StringBuilder buffer = new StringBuilder();
+    buffer.append(status.getCode());
+    if (status.getDescription() != null) {
+      buffer.append("(").append(status.getDescription()).append(")");
+    }
+    if (status.getCause() != null) {
+      buffer.append("[").append(status.getCause()).append("]");
+    }
+    return buffer.toString();
+  }
+
+  @VisibleForTesting
+  static final class TransportLogger extends ChannelLogger {
+    // Changed just after construction to break a cyclic dependency.
+    InternalLogId logId;
+
+    @Override
+    public void log(ChannelLogLevel level, String message) {
+      ChannelLoggerImpl.logOnly(logId, level, message);
+    }
+
+    @Override
+    public void log(ChannelLogLevel level, String messageFormat, Object... args) {
+      ChannelLoggerImpl.logOnly(logId, level, messageFormat, args);
+    }
+  }
 }
diff --git a/core/src/main/java/io/grpc/internal/IoUtils.java b/core/src/main/java/io/grpc/internal/IoUtils.java
deleted file mode 100644
index 5178c2f4b80..00000000000
--- a/core/src/main/java/io/grpc/internal/IoUtils.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-
-/** Common IoUtils for thrift and nanopb to convert inputstream to bytes. */
-public final class IoUtils {
-
-  /** maximum buffer to be read is 16 KB. */
-  private static final int MAX_BUFFER_LENGTH = 16384; 
-  
-  /** Returns the byte array. */
-  public static byte[] toByteArray(InputStream is) throws IOException {
-    ByteArrayOutputStream buffer = new ByteArrayOutputStream();
-    int nRead;
-    byte[] bytes = new byte[MAX_BUFFER_LENGTH];
-
-    while ((nRead = is.read(bytes, 0, bytes.length)) != -1) {
-      buffer.write(bytes, 0, nRead);
-    }
-
-    buffer.flush();
-    return buffer.toByteArray();
-  }
-}
\ No newline at end of file
diff --git a/core/src/main/java/io/grpc/internal/JndiResourceResolverFactory.java b/core/src/main/java/io/grpc/internal/JndiResourceResolverFactory.java
new file mode 100644
index 00000000000..d9eca2be800
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/JndiResourceResolverFactory.java
@@ -0,0 +1,271 @@
+/*
+ * Copyright 2018 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.internal;
+
+import android.annotation.SuppressLint;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Verify;
+import io.grpc.internal.DnsNameResolver.ResourceResolver;
+import io.grpc.internal.DnsNameResolver.SrvRecord;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Pattern;
+import javax.annotation.Nullable;
+import javax.naming.NamingEnumeration;
+import javax.naming.NamingException;
+import javax.naming.directory.Attribute;
+import javax.naming.directory.DirContext;
+import javax.naming.directory.InitialDirContext;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+
+/**
+ * {@link JndiResourceResolverFactory} resolves additional records for the DnsNameResolver.
+ */
+final class JndiResourceResolverFactory implements DnsNameResolver.ResourceResolverFactory {
+
+  @Nullable
+  @SuppressWarnings("StaticAssignmentOfThrowable")
+  private static final Throwable JNDI_UNAVAILABILITY_CAUSE = initJndi();
+
+  // @UsedReflectively
+  public JndiResourceResolverFactory() {}
+
+  /**
+   * Returns whether the JNDI DNS resolver is available.  This is accomplished by looking up a
+   * particular class.  It is believed to be the default (only?) DNS resolver that will actually be
+   * used.  It is provided by the OpenJDK, but unlikely Android.  Actual resolution will be done by
+   * using a service provider when a hostname query is present, so the {@code DnsContextFactory}
+   * may not actually be used to perform the query.  This is believed to be "okay."
+   */
+  @Nullable
+  private static Throwable initJndi() {
+    try {
+      Class.forName("javax.naming.directory.InitialDirContext");
+      Class.forName("com.sun.jndi.dns.DnsContextFactory");
+    } catch (ClassNotFoundException e) {
+      return e;
+    } catch (RuntimeException e) {
+      return e;
+    } catch (Error e) {
+      return e;
+    }
+    return null;
+  }
+
+  @Nullable
+  @Override
+  public ResourceResolver newResourceResolver() {
+    if (unavailabilityCause() != null) {
+      return null;
+    }
+    return new JndiResourceResolver(new JndiRecordFetcher());
+  }
+
+  @Nullable
+  @Override
+  public Throwable unavailabilityCause() {
+    return JNDI_UNAVAILABILITY_CAUSE;
+  }
+
+  @VisibleForTesting
+  interface RecordFetcher {
+    List<String> getAllRecords(String recordType, String name) throws NamingException;
+  }
+
+  @VisibleForTesting
+  static final class JndiResourceResolver implements DnsNameResolver.ResourceResolver {
+    private static final Logger logger =
+        Logger.getLogger(JndiResourceResolver.class.getName());
+
+    private static final Pattern whitespace = Pattern.compile("\\s+");
+
+    private final RecordFetcher recordFetcher;
+
+    public JndiResourceResolver(RecordFetcher recordFetcher) {
+      this.recordFetcher = recordFetcher;
+    }
+
+    @Override
+    public List<String> resolveTxt(String serviceConfigHostname) throws NamingException {
+      if (logger.isLoggable(Level.FINER)) {
+        logger.log(
+            Level.FINER, "About to query TXT records for {0}", new Object[]{serviceConfigHostname});
+      }
+      List<String> serviceConfigRawTxtRecords =
+          recordFetcher.getAllRecords("TXT", "dns:///" + serviceConfigHostname);
+      if (logger.isLoggable(Level.FINER)) {
+        logger.log(
+            Level.FINER, "Found {0} TXT records", new Object[]{serviceConfigRawTxtRecords.size()});
+      }
+      List<String> serviceConfigTxtRecords =
+          new ArrayList<>(serviceConfigRawTxtRecords.size());
+      for (String serviceConfigRawTxtRecord : serviceConfigRawTxtRecords) {
+        serviceConfigTxtRecords.add(unquote(serviceConfigRawTxtRecord));
+      }
+      return Collections.unmodifiableList(serviceConfigTxtRecords);
+    }
+
+    @Override
+    public List<SrvRecord> resolveSrv(String host) throws Exception {
+      if (logger.isLoggable(Level.FINER)) {
+        logger.log(
+            Level.FINER, "About to query SRV records for {0}", new Object[]{host});
+      }
+      List<String> rawSrvRecords =
+          recordFetcher.getAllRecords("SRV", "dns:///" + host);
+      if (logger.isLoggable(Level.FINER)) {
+        logger.log(
+            Level.FINER, "Found {0} SRV records", new Object[]{rawSrvRecords.size()});
+      }
+      List<SrvRecord> srvRecords = new ArrayList<>(rawSrvRecords.size());
+      Exception first = null;
+      Level level = Level.WARNING;
+      for (String rawSrv : rawSrvRecords) {
+        try {
+          String[] parts = whitespace.split(rawSrv, 5);
+          Verify.verify(parts.length == 4, "Bad SRV Record: %s", rawSrv);
+          // SRV requires the host name to be absolute
+          if (!parts[3].endsWith(".")) {
+            throw new RuntimeException("Returned SRV host does not end in period: " + parts[3]);
+          }
+          srvRecords.add(new SrvRecord(parts[3], Integer.parseInt(parts[2])));
+        } catch (RuntimeException e) {
+          logger.log(level, "Failed to construct SRV record " + rawSrv, e);
+          if (first == null) {
+            first = e;
+            level = Level.FINE;
+          }
+        }
+      }
+      if (srvRecords.isEmpty() && first != null) {
+        throw first;
+      }
+      return Collections.unmodifiableList(srvRecords);
+    }
+
+    /**
+     * Undo the quoting done in {@link com.sun.jndi.dns.ResourceRecord#decodeTxt}.
+     */
+    @VisibleForTesting
+    static String unquote(String txtRecord) {
+      StringBuilder sb = new StringBuilder(txtRecord.length());
+      boolean inquote = false;
+      for (int i = 0; i < txtRecord.length(); i++) {
+        char c = txtRecord.charAt(i);
+        if (!inquote) {
+          if (c == ' ') {
+            continue;
+          } else if (c == '"') {
+            inquote = true;
+            continue;
+          }
+        } else {
+          if (c == '"') {
+            inquote = false;
+            continue;
+          } else if (c == '\\') {
+            c = txtRecord.charAt(++i);
+            assert c == '"' || c == '\\';
+          }
+        }
+        sb.append(c);
+      }
+      return sb.toString();
+    }
+  }
+
+  @VisibleForTesting
+  @IgnoreJRERequirement
+  @SuppressWarnings({"JdkObsolete", "BanJNDI"})
+  // javax.naming.* is only loaded reflectively and is never loaded for Android
+  // The lint issue id is supposed to be "InvalidPackage" but it doesn't work, don't know why.
+  // Use "all" as the lint issue id to suppress all types of lint error.
+  @SuppressLint("all")
+  static final class JndiRecordFetcher implements RecordFetcher {
+    @Override
+    public List<String> getAllRecords(String recordType, String name) throws NamingException {
+      checkAvailable();
+      String[] rrType = new String[]{recordType};
+      List<String> records = new ArrayList<>();
+
+      Hashtable<String, String> env = new Hashtable<>();
+      env.put("com.sun.jndi.ldap.connect.timeout", "5000");
+      env.put("com.sun.jndi.ldap.read.timeout", "5000");
+      DirContext dirContext = new InitialDirContext(env);
+
+      try {
+        javax.naming.directory.Attributes attrs = dirContext.getAttributes(name, rrType);
+        NamingEnumeration<? extends Attribute> rrGroups = attrs.getAll();
+
+        try {
+          while (rrGroups.hasMore()) {
+            Attribute rrEntry = rrGroups.next();
+            assert Arrays.asList(rrType).contains(rrEntry.getID());
+            NamingEnumeration<?> rrValues = rrEntry.getAll();
+            try {
+              while (rrValues.hasMore()) {
+                records.add(String.valueOf(rrValues.next()));
+              }
+            } catch (NamingException ne) {
+              closeThenThrow(rrValues, ne);
+            }
+            rrValues.close();
+          }
+        } catch (NamingException ne) {
+          closeThenThrow(rrGroups, ne);
+        }
+        rrGroups.close();
+      } catch (NamingException ne) {
+        closeThenThrow(dirContext, ne);
+      }
+      dirContext.close();
+
+      return records;
+    }
+
+    private static void closeThenThrow(NamingEnumeration<?> namingEnumeration, NamingException e)
+        throws NamingException {
+      try {
+        namingEnumeration.close();
+      } catch (NamingException ignored) {
+        // ignore
+      }
+      throw e;
+    }
+
+    private static void closeThenThrow(DirContext ctx, NamingException e) throws NamingException {
+      try {
+        ctx.close();
+      } catch (NamingException ignored) {
+        // ignore
+      }
+      throw e;
+    }
+
+    private static void checkAvailable() {
+      if (JNDI_UNAVAILABILITY_CAUSE != null) {
+        throw new UnsupportedOperationException(
+            "JNDI is not currently available", JNDI_UNAVAILABILITY_CAUSE);
+      }
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/JsonParser.java b/core/src/main/java/io/grpc/internal/JsonParser.java
new file mode 100644
index 00000000000..14f78c09e72
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/JsonParser.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Parses JSON with as few preconceived notions as possible.
+ */
+public final class JsonParser {
+
+  private static final Logger logger = Logger.getLogger(JsonParser.class.getName());
+
+  private JsonParser() {}
+
+  /**
+   * Parses a json string, returning either a {@code Map<String, ?>}, {@code List<?>},
+   * {@code String}, {@code Double}, {@code Boolean}, or {@code null}. Fails if duplicate names
+   * found.
+   */
+  public static Object parse(String raw) throws IOException {
+    JsonReader jr = new JsonReader(new StringReader(raw));
+    try {
+      return parseRecursive(jr);
+    } finally {
+      try {
+        jr.close();
+      } catch (IOException e) {
+        logger.log(Level.WARNING, "Failed to close", e);
+      }
+    }
+  }
+
+  private static Object parseRecursive(JsonReader jr) throws IOException {
+    checkState(jr.hasNext(), "unexpected end of JSON");
+    switch (jr.peek()) {
+      case BEGIN_ARRAY:
+        return parseJsonArray(jr);
+      case BEGIN_OBJECT:
+        return parseJsonObject(jr);
+      case STRING:
+        return jr.nextString();
+      case NUMBER:
+        return jr.nextDouble();
+      case BOOLEAN:
+        return jr.nextBoolean();
+      case NULL:
+        return parseJsonNull(jr);
+      default:
+        throw new IllegalStateException("Bad token: " + jr.getPath());
+    }
+  }
+
+  private static Map<String, ?> parseJsonObject(JsonReader jr) throws IOException {
+    jr.beginObject();
+    Map<String, Object> obj = new LinkedHashMap<>();
+    while (jr.hasNext()) {
+      String name = jr.nextName();
+      checkArgument(!obj.containsKey(name), "Duplicate key found: %s", name);
+      Object value = parseRecursive(jr);
+      obj.put(name, value);
+    }
+    checkState(jr.peek() == JsonToken.END_OBJECT, "Bad token: " + jr.getPath());
+    jr.endObject();
+    return Collections.unmodifiableMap(obj);
+  }
+
+  private static List<?> parseJsonArray(JsonReader jr) throws IOException {
+    jr.beginArray();
+    List<Object> array = new ArrayList<>();
+    while (jr.hasNext()) {
+      Object value = parseRecursive(jr);
+      array.add(value);
+    }
+    checkState(jr.peek() == JsonToken.END_ARRAY, "Bad token: " + jr.getPath());
+    jr.endArray();
+    return Collections.unmodifiableList(array);
+  }
+
+  private static Void parseJsonNull(JsonReader jr) throws IOException {
+    jr.nextNull();
+    return null;
+  }
+}
\ No newline at end of file
diff --git a/core/src/main/java/io/grpc/internal/JsonUtil.java b/core/src/main/java/io/grpc/internal/JsonUtil.java
new file mode 100644
index 00000000000..6c9274702b6
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/JsonUtil.java
@@ -0,0 +1,433 @@
+/*
+ * Copyright 2019 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.internal;
+
+import static com.google.common.math.LongMath.checkedAdd;
+
+import java.text.ParseException;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * Helper utility to work with JSON values in Java types. Includes the JSON dialect used by
+ * Protocol Buffers.
+ */
+public class JsonUtil {
+  /**
+   * Gets a list from an object for the given key.  If the key is not present, this returns null.
+   * If the value is not a List, throws an exception.
+   */
+  @Nullable
+  public static List<?> getList(Map<String, ?> obj, String key) {
+    assert key != null;
+    if (!obj.containsKey(key)) {
+      return null;
+    }
+    Object value = obj.get(key);
+    if (!(value instanceof List)) {
+      throw new ClassCastException(
+          String.format("value '%s' for key '%s' in '%s' is not List", value, key, obj));
+    }
+    return (List<?>) value;
+  }
+
+  /**
+   * Gets a list from an object for the given key, and verifies all entries are objects.  If the key
+   * is not present, this returns null.  If the value is not a List or an entry is not an object,
+   * throws an exception.
+   */
+  @Nullable
+  public static List<Map<String, ?>> getListOfObjects(Map<String, ?> obj, String key) {
+    List<?> list = getList(obj, key);
+    if (list == null) {
+      return null;
+    }
+    return checkObjectList(list);
+  }
+
+  /**
+   * Gets a list from an object for the given key, and verifies all entries are strings.  If the key
+   * is not present, this returns null.  If the value is not a List or an entry is not a string,
+   * throws an exception.
+   */
+  @Nullable
+  public static List<String> getListOfStrings(Map<String, ?> obj, String key) {
+    List<?> list = getList(obj, key);
+    if (list == null) {
+      return null;
+    }
+    return checkStringList(list);
+  }
+
+  /**
+   * Gets an object from an object for the given key.  If the key is not present, this returns null.
+   * If the value is not a Map, throws an exception.
+   */
+  @SuppressWarnings("unchecked")
+  @Nullable
+  public static Map<String, ?> getObject(Map<String, ?> obj, String key) {
+    assert key != null;
+    if (!obj.containsKey(key)) {
+      return null;
+    }
+    Object value = obj.get(key);
+    if (!(value instanceof Map)) {
+      throw new ClassCastException(
+          String.format("value '%s' for key '%s' in '%s' is not object", value, key, obj));
+    }
+    return (Map<String, ?>) value;
+  }
+
+  /**
+   * Gets a number from an object for the given key.  If the key is not present, this returns null.
+   * If the value does not represent a double, throws an exception.
+   */
+  @Nullable
+  public static Double getNumberAsDouble(Map<String, ?> obj, String key) {
+    assert key != null;
+    if (!obj.containsKey(key)) {
+      return null;
+    }
+    Object value = obj.get(key);
+    if (value instanceof Double) {
+      return (Double) value;
+    }
+    if (value instanceof String) {
+      try {
+        return Double.parseDouble((String) value);
+      } catch (NumberFormatException e) {
+        throw new IllegalArgumentException(
+            String.format("value '%s' for key '%s' is not a double", value, key));
+      }
+    }
+    throw new IllegalArgumentException(
+        String.format("value '%s' for key '%s' in '%s' is not a number", value, key, obj));
+  }
+
+  /**
+   * Gets a number from an object for the given key.  If the key is not present, this returns null.
+   * If the value does not represent a float, throws an exception.
+   */
+  @Nullable
+  public static Float getNumberAsFloat(Map<String, ?> obj, String key) {
+    assert key != null;
+    if (!obj.containsKey(key)) {
+      return null;
+    }
+    Object value = obj.get(key);
+    if (value instanceof Float) {
+      return (Float) value;
+    }
+    if (value instanceof String) {
+      try {
+        return Float.parseFloat((String) value);
+      } catch (NumberFormatException e) {
+        throw new IllegalArgumentException(
+            String.format("string value '%s' for key '%s' cannot be parsed as a float", value,
+                key));
+      }
+    }
+    throw new IllegalArgumentException(
+        String.format("value %s for key '%s' is not a float", value, key));
+  }
+
+  /**
+   * Gets a number from an object for the given key, casted to an integer.  If the key is not
+   * present, this returns null.  If the value does not represent an integer, throws an exception.
+   */
+  @Nullable
+  public static Integer getNumberAsInteger(Map<String, ?> obj, String key) {
+    assert key != null;
+    if (!obj.containsKey(key)) {
+      return null;
+    }
+    Object value = obj.get(key);
+    if (value instanceof Double) {
+      Double d = (Double) value;
+      int i = d.intValue();
+      if (i != d) {
+        throw new ClassCastException("Number expected to be integer: " + d);
+      }
+      return i;
+    }
+    if (value instanceof String) {
+      try {
+        return Integer.parseInt((String) value);
+      } catch (NumberFormatException e) {
+        throw new IllegalArgumentException(
+            String.format("value '%s' for key '%s' is not an integer", value, key));
+      }
+    }
+    throw new IllegalArgumentException(
+        String.format("value '%s' for key '%s' is not an integer", value, key));
+  }
+
+  /**
+   * Gets a number from an object for the given key, casted to an long.  If the key is not
+   * present, this returns null.  If the value does not represent a long integer, throws an
+   * exception.
+   */
+  public static Long getNumberAsLong(Map<String, ?> obj, String key) {
+    assert key != null;
+    if (!obj.containsKey(key)) {
+      return null;
+    }
+    Object value = obj.get(key);
+    if (value instanceof Double) {
+      Double d = (Double) value;
+      long l = d.longValue();
+      if (l != d) {
+        throw new ClassCastException("Number expected to be long: " + d);
+      }
+      return l;
+    }
+    if (value instanceof String) {
+      try {
+        return Long.parseLong((String) value);
+      } catch (NumberFormatException e) {
+        throw new IllegalArgumentException(
+            String.format("value '%s' for key '%s' is not a long integer", value, key));
+      }
+    }
+    throw new IllegalArgumentException(
+        String.format("value '%s' for key '%s' is not a long integer", value, key));
+  }
+
+  /**
+   * Gets a string from an object for the given key.  If the key is not present, this returns null.
+   * If the value is not a String, throws an exception.
+   */
+  @Nullable
+  public static String getString(Map<String, ?> obj, String key) {
+    assert key != null;
+    if (!obj.containsKey(key)) {
+      return null;
+    }
+    Object value = obj.get(key);
+    if (!(value instanceof String)) {
+      throw new ClassCastException(
+          String.format("value '%s' for key '%s' in '%s' is not String", value, key, obj));
+    }
+    return (String) value;
+  }
+
+  /**
+   * Gets a string from an object for the given key, parsed as a duration (defined by protobuf).  If
+   * the key is not present, this returns null.  If the value is not a String or not properly
+   * formatted, throws an exception.
+   */
+  public static Long getStringAsDuration(Map<String, ?> obj, String key) {
+    String value = getString(obj, key);
+    if (value == null) {
+      return null;
+    }
+    try {
+      return parseDuration(value);
+    } catch (ParseException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * Gets a boolean from an object for the given key.  If the key is not present, this returns null.
+   * If the value is not a Boolean, throws an exception.
+   */
+  @Nullable
+  public static Boolean getBoolean(Map<String, ?> obj, String key) {
+    assert key != null;
+    if (!obj.containsKey(key)) {
+      return null;
+    }
+    Object value = obj.get(key);
+    if (!(value instanceof Boolean)) {
+      throw new ClassCastException(
+          String.format("value '%s' for key '%s' in '%s' is not Boolean", value, key, obj));
+    }
+    return (Boolean) value;
+  }
+
+  /**
+   * Casts a list of unchecked JSON values to a list of checked objects in Java type.
+   * If the given list contains a value that is not a Map, throws an exception.
+   */
+  @SuppressWarnings("unchecked")
+  public static List<Map<String, ?>> checkObjectList(List<?> rawList) {
+    for (int i = 0; i < rawList.size(); i++) {
+      if (!(rawList.get(i) instanceof Map)) {
+        throw new ClassCastException(
+            String.format(
+                Locale.US, "value %s for idx %d in %s is not object", rawList.get(i), i, rawList));
+      }
+    }
+    return (List<Map<String, ?>>) rawList;
+  }
+
+  /**
+   * Casts a list of unchecked JSON values to a list of String. If the given list
+   * contains a value that is not a String, throws an exception.
+   */
+  @SuppressWarnings("unchecked")
+  public static List<String> checkStringList(List<?> rawList) {
+    for (int i = 0; i < rawList.size(); i++) {
+      if (!(rawList.get(i) instanceof String)) {
+        throw new ClassCastException(
+            String.format(
+                Locale.US,
+                "value '%s' for idx %d in '%s' is not string", rawList.get(i), i, rawList));
+      }
+    }
+    return (List<String>) rawList;
+  }
+
+  private static final long DURATION_SECONDS_MIN = -315576000000L;
+  private static final long DURATION_SECONDS_MAX = 315576000000L;
+
+  /**
+   * Parse from a string to produce a duration.  Copy of
+   * {@link com.google.protobuf.util.Durations#parse}.
+   *
+   * @return A Duration parsed from the string.
+   * @throws ParseException if parsing fails.
+   */
+  private static long parseDuration(String value) throws ParseException {
+    // Must ended with "s".
+    if (value.isEmpty() || value.charAt(value.length() - 1) != 's') {
+      throw new ParseException("Invalid duration string: " + value, 0);
+    }
+    boolean negative = false;
+    if (value.charAt(0) == '-') {
+      negative = true;
+      value = value.substring(1);
+    }
+    String secondValue = value.substring(0, value.length() - 1);
+    String nanoValue = "";
+    int pointPosition = secondValue.indexOf('.');
+    if (pointPosition != -1) {
+      nanoValue = secondValue.substring(pointPosition + 1);
+      secondValue = secondValue.substring(0, pointPosition);
+    }
+    long seconds = Long.parseLong(secondValue);
+    int nanos = nanoValue.isEmpty() ? 0 : parseNanos(nanoValue);
+    if (seconds < 0) {
+      throw new ParseException("Invalid duration string: " + value, 0);
+    }
+    if (negative) {
+      seconds = -seconds;
+      nanos = -nanos;
+    }
+    try {
+      return normalizedDuration(seconds, nanos);
+    } catch (IllegalArgumentException e) {
+      throw new ParseException("Duration value is out of range.", 0);
+    }
+  }
+
+  /**
+   * Copy of {@link com.google.protobuf.util.Timestamps#parseNanos}.
+   */
+  private static int parseNanos(String value) throws ParseException {
+    int result = 0;
+    for (int i = 0; i < 9; ++i) {
+      result = result * 10;
+      if (i < value.length()) {
+        if (value.charAt(i) < '0' || value.charAt(i) > '9') {
+          throw new ParseException("Invalid nanoseconds.", 0);
+        }
+        result += value.charAt(i) - '0';
+      }
+    }
+    return result;
+  }
+
+  private static final int NANOS_PER_SECOND = 1_000_000_000;
+
+  /**
+   * Copy of {@link com.google.protobuf.util.Durations#normalizedDuration}.
+   */
+  // Math.addExact() requires Android API level 24
+  @SuppressWarnings({"NarrowingCompoundAssignment", "InlineMeInliner"})
+  private static long normalizedDuration(long seconds, int nanos) {
+    if (nanos <= -NANOS_PER_SECOND || nanos >= NANOS_PER_SECOND) {
+      seconds = checkedAdd(seconds, nanos / NANOS_PER_SECOND);
+      nanos %= NANOS_PER_SECOND;
+    }
+    if (seconds > 0 && nanos < 0) {
+      nanos += NANOS_PER_SECOND; // no overflow— nanos is negative (and we're adding)
+      seconds--; // no overflow since seconds is positive (and we're decrementing)
+    }
+    if (seconds < 0 && nanos > 0) {
+      nanos -= NANOS_PER_SECOND; // no overflow— nanos is positive (and we're subtracting)
+      seconds++; // no overflow since seconds is negative (and we're incrementing)
+    }
+    if (!durationIsValid(seconds, nanos)) {
+      throw new IllegalArgumentException(String.format(
+          "Duration is not valid. See proto definition for valid values. "
+              + "Seconds (%s) must be in range [-315,576,000,000, +315,576,000,000]. "
+              + "Nanos (%s) must be in range [-999,999,999, +999,999,999]. "
+              + "Nanos must have the same sign as seconds", seconds, nanos));
+    }
+    return saturatedAdd(TimeUnit.SECONDS.toNanos(seconds), nanos);
+  }
+
+  /**
+   * Returns true if the given number of seconds and nanos is a valid {@code Duration}. The {@code
+   * seconds} value must be in the range [-315,576,000,000, +315,576,000,000]. The {@code nanos}
+   * value must be in the range [-999,999,999, +999,999,999].
+   *
+   * <p><b>Note:</b> Durations less than one second are represented with a 0 {@code seconds} field
+   * and a positive or negative {@code nanos} field. For durations of one second or more, a non-zero
+   * value for the {@code nanos} field must be of the same sign as the {@code seconds} field.
+   *
+   * <p>Copy of {@link com.google.protobuf.util.Duration#isValid}.</p>
+   */
+  private static boolean durationIsValid(long seconds, int nanos) {
+    if (seconds < DURATION_SECONDS_MIN || seconds > DURATION_SECONDS_MAX) {
+      return false;
+    }
+    if (nanos < -999999999L || nanos >= NANOS_PER_SECOND) {
+      return false;
+    }
+    if (seconds < 0 || nanos < 0) {
+      if (seconds > 0 || nanos > 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Returns the sum of {@code a} and {@code b} unless it would overflow or underflow in which case
+   * {@code Long.MAX_VALUE} or {@code Long.MIN_VALUE} is returned, respectively.
+   *
+   * <p>Copy of {@link com.google.common.math.LongMath#saturatedAdd}.</p>
+   *
+   */
+  @SuppressWarnings("ShortCircuitBoolean")
+  private static long saturatedAdd(long a, long b) {
+    long naiveSum = a + b;
+    if ((a ^ b) < 0 | (a ^ naiveSum) >= 0) {
+      // If a and b have different signs or a has the same sign as the result then there was no
+      // overflow, return.
+      return naiveSum;
+    }
+    // we did over/under flow, if the sign is negative we should return MAX otherwise MIN
+    return Long.MAX_VALUE + ((naiveSum >>> (Long.SIZE - 1)) ^ 1);
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/KeepAliveEnforcer.java b/core/src/main/java/io/grpc/internal/KeepAliveEnforcer.java
new file mode 100644
index 00000000000..6480336470c
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/KeepAliveEnforcer.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2017 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.internal;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.CheckReturnValue;
+import java.util.concurrent.TimeUnit;
+
+/** Monitors the client's PING usage to make sure the rate is permitted. */
+public final class KeepAliveEnforcer {
+  @VisibleForTesting
+  public static final int MAX_PING_STRIKES = 2;
+  @VisibleForTesting
+  public static final long IMPLICIT_PERMIT_TIME_NANOS = TimeUnit.HOURS.toNanos(2);
+
+  private final boolean permitWithoutCalls;
+  private final long minTimeNanos;
+  private final Ticker ticker;
+  private final long epoch;
+
+  private long lastValidPingTime;
+  private boolean hasOutstandingCalls;
+  private int pingStrikes;
+
+  public KeepAliveEnforcer(boolean permitWithoutCalls, long minTime, TimeUnit unit) {
+    this(permitWithoutCalls, minTime, unit, SystemTicker.INSTANCE);
+  }
+
+  @VisibleForTesting
+  KeepAliveEnforcer(boolean permitWithoutCalls, long minTime, TimeUnit unit, Ticker ticker) {
+    Preconditions.checkArgument(minTime >= 0, "minTime must be non-negative: %s", minTime);
+
+    this.permitWithoutCalls = permitWithoutCalls;
+    this.minTimeNanos = Math.min(unit.toNanos(minTime), IMPLICIT_PERMIT_TIME_NANOS);
+    this.ticker = ticker;
+    this.epoch = ticker.nanoTime();
+    lastValidPingTime = epoch;
+  }
+
+  /** Returns {@code false} when client is misbehaving and should be disconnected. */
+  @CheckReturnValue
+  public boolean pingAcceptable() {
+    long now = ticker.nanoTime();
+    boolean valid;
+    if (!hasOutstandingCalls && !permitWithoutCalls) {
+      valid = compareNanos(lastValidPingTime + IMPLICIT_PERMIT_TIME_NANOS, now) <= 0;
+    } else {
+      valid = compareNanos(lastValidPingTime + minTimeNanos, now) <= 0;
+    }
+    if (!valid) {
+      pingStrikes++;
+      return pingStrikes <= MAX_PING_STRIKES;
+    } else {
+      lastValidPingTime = now;
+      return true;
+    }
+  }
+
+  /**
+   * Reset any counters because PINGs are allowed in response to something sent. Typically called
+   * when sending HEADERS and DATA frames.
+   */
+  public void resetCounters() {
+    lastValidPingTime = epoch;
+    pingStrikes = 0;
+  }
+
+  /** There are outstanding RPCs on the transport. */
+  public void onTransportActive() {
+    hasOutstandingCalls = true;
+  }
+
+  /** There are no outstanding RPCs on the transport. */
+  public void onTransportIdle() {
+    hasOutstandingCalls = false;
+  }
+
+  /**
+   * Positive when time1 is greater; negative when time2 is greater; 0 when equal. It is important
+   * to use something like this instead of directly comparing nano times. See {@link
+   * System#nanoTime}.
+   */
+  private static long compareNanos(long time1, long time2) {
+    // Possibility of overflow/underflow is on purpose and necessary for correctness
+    return time1 - time2;
+  }
+
+  @VisibleForTesting
+  interface Ticker {
+    long nanoTime();
+  }
+
+  @VisibleForTesting
+  static class SystemTicker implements Ticker {
+    public static final SystemTicker INSTANCE = new SystemTicker();
+
+    @Override
+    public long nanoTime() {
+      return System.nanoTime();
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/KeepAliveManager.java b/core/src/main/java/io/grpc/internal/KeepAliveManager.java
index d8376b7b0f1..535b3a82524 100644
--- a/core/src/main/java/io/grpc/internal/KeepAliveManager.java
+++ b/core/src/main/java/io/grpc/internal/KeepAliveManager.java
@@ -1,59 +1,53 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
 import com.google.common.util.concurrent.MoreExecutors;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
 import io.grpc.Status;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import javax.annotation.concurrent.ThreadSafe;
 
 /**
  * Manages keepalive pings.
  */
 public class KeepAliveManager {
-  private static final SystemTicker SYSTEM_TICKER = new SystemTicker();
-  private static final long MIN_KEEPALIVE_DELAY_NANOS = TimeUnit.MINUTES.toNanos(1);
+  private static final long MIN_KEEPALIVE_TIME_NANOS = TimeUnit.SECONDS.toNanos(10);
+  private static final long MIN_KEEPALIVE_TIMEOUT_NANOS = TimeUnit.MILLISECONDS.toNanos(10L);
 
   private final ScheduledExecutorService scheduler;
-  private final ManagedClientTransport transport;
-  private final Ticker ticker;
+  @GuardedBy("this")
+  private final Stopwatch stopwatch;
+  private final KeepAlivePinger keepAlivePinger;
+  private final boolean keepAliveDuringTransportIdle;
+  @GuardedBy("this")
   private State state = State.IDLE;
-  private long nextKeepaliveTime;
+  @GuardedBy("this")
   private ScheduledFuture<?> shutdownFuture;
+  @GuardedBy("this")
   private ScheduledFuture<?> pingFuture;
-  private final Runnable shutdown = new Runnable() {
+  private final Runnable shutdown = new LogExceptionRunnable(new Runnable() {
     @Override
     public void run() {
       boolean shouldShutdown = false;
@@ -66,16 +60,16 @@ public void run() {
         }
       }
       if (shouldShutdown) {
-        transport.shutdownNow(Status.UNAVAILABLE.withDescription(
-            "Keepalive failed. The connection is likely gone"));
+        keepAlivePinger.onPingTimeout();
       }
     }
-  };
-  private final Runnable sendPing = new Runnable() {
+  });
+  private final Runnable sendPing = new LogExceptionRunnable(new Runnable() {
     @Override
     public void run() {
       boolean shouldSendPing = false;
       synchronized (KeepAliveManager.this) {
+        pingFuture = null;
         if (state == State.PING_SCHEDULED) {
           shouldSendPing = true;
           state = State.PING_SENT;
@@ -84,24 +78,27 @@ public void run() {
               TimeUnit.NANOSECONDS);
         } else if (state == State.PING_DELAYED) {
           // We have received some data. Reschedule the ping with the new time.
-          pingFuture = scheduler.schedule(sendPing, nextKeepaliveTime - ticker.read(),
+          pingFuture = scheduler.schedule(
+              sendPing,
+              keepAliveTimeInNanos - stopwatch.elapsed(TimeUnit.NANOSECONDS),
               TimeUnit.NANOSECONDS);
           state = State.PING_SCHEDULED;
         }
       }
       if (shouldSendPing) {
         // Send the ping.
-        transport.ping(pingCallback, MoreExecutors.directExecutor());
+        keepAlivePinger.ping();
       }
     }
-  };
-  private final KeepAlivePingCallback pingCallback = new KeepAlivePingCallback();
-  private long keepAliveDelayInNanos;
-  private long keepAliveTimeoutInNanos;
+  });
+
+  private final long keepAliveTimeInNanos;
+  private final long keepAliveTimeoutInNanos;
 
   private enum State {
     /*
-     * Transport has no active rpcs. We don't need to do any keepalives.
+     * We don't need to do any keepalives. This means the transport has no active rpcs and
+     * keepAliveDuringTransportIdle == false.
      */
     IDLE,
     /*
@@ -130,38 +127,59 @@ private enum State {
   /**
    * Creates a KeepAliverManager.
    */
-  public KeepAliveManager(ManagedClientTransport transport, ScheduledExecutorService scheduler,
-                          long keepAliveDelayInNanos, long keepAliveTimeoutInNanos) {
-    this.transport = Preconditions.checkNotNull(transport, "transport");
-    this.scheduler = Preconditions.checkNotNull(scheduler, "scheduler");
-    this.ticker = SYSTEM_TICKER;
-    // Set a minimum cap on keepalive dealy.
-    this.keepAliveDelayInNanos = Math.max(MIN_KEEPALIVE_DELAY_NANOS, keepAliveDelayInNanos);
-    this.keepAliveTimeoutInNanos = keepAliveTimeoutInNanos;
-    nextKeepaliveTime = ticker.read() + keepAliveDelayInNanos;
+  public KeepAliveManager(KeepAlivePinger keepAlivePinger, ScheduledExecutorService scheduler,
+                          long keepAliveTimeInNanos, long keepAliveTimeoutInNanos,
+                          boolean keepAliveDuringTransportIdle) {
+    this(keepAlivePinger, scheduler, Stopwatch.createUnstarted(), keepAliveTimeInNanos,
+        keepAliveTimeoutInNanos,
+        keepAliveDuringTransportIdle);
   }
 
   @VisibleForTesting
-  KeepAliveManager(ManagedClientTransport transport, ScheduledExecutorService scheduler,
-                   Ticker ticker, long keepAliveDelayInNanos, long keepAliveTimeoutInNanos) {
-    this.transport = Preconditions.checkNotNull(transport, "transport");
-    this.scheduler = Preconditions.checkNotNull(scheduler, "scheduler");
-    this.ticker = Preconditions.checkNotNull(ticker, "ticker");
-    this.keepAliveDelayInNanos = keepAliveDelayInNanos;
+  KeepAliveManager(KeepAlivePinger keepAlivePinger, ScheduledExecutorService scheduler,
+      Stopwatch stopwatch, long keepAliveTimeInNanos, long keepAliveTimeoutInNanos,
+                   boolean keepAliveDuringTransportIdle) {
+    this.keepAlivePinger = checkNotNull(keepAlivePinger, "keepAlivePinger");
+    this.scheduler = checkNotNull(scheduler, "scheduler");
+    this.stopwatch = checkNotNull(stopwatch, "stopwatch");
+    this.keepAliveTimeInNanos = keepAliveTimeInNanos;
     this.keepAliveTimeoutInNanos = keepAliveTimeoutInNanos;
-    nextKeepaliveTime = ticker.read() + keepAliveDelayInNanos;
+    this.keepAliveDuringTransportIdle = keepAliveDuringTransportIdle;
+    stopwatch.reset().start();
+  }
+
+  /** Start keepalive monitoring. */
+  public synchronized void onTransportStarted() {
+    if (keepAliveDuringTransportIdle) {
+      onTransportActive();
+    }
   }
 
   /**
    * Transport has received some data so that we can delay sending keepalives.
    */
   public synchronized void onDataReceived() {
-    nextKeepaliveTime = ticker.read() + keepAliveDelayInNanos;
+    stopwatch.reset().start();
     // We do not cancel the ping future here. This avoids constantly scheduling and cancellation in
     // a busy transport. Instead, we update the status here and reschedule later. So we actually
     // keep one sendPing task always in flight when there're active rpcs.
     if (state == State.PING_SCHEDULED) {
       state = State.PING_DELAYED;
+    } else if (state == State.PING_SENT || state == State.IDLE_AND_PING_SENT) {
+      // Ping acked or effectively ping acked. Cancel shutdown, and then if not idle,
+      // schedule a new keep-alive ping.
+      if (shutdownFuture != null) {
+        shutdownFuture.cancel(false);
+      }
+      if (state == State.IDLE_AND_PING_SENT) {
+        // not to schedule new pings until onTransportActive
+        state = State.IDLE;
+        return;
+      }
+      // schedule a new ping
+      state = State.PING_SCHEDULED;
+      checkState(pingFuture == null, "There should be no outstanding pingFuture");
+      pingFuture = scheduler.schedule(sendPing, keepAliveTimeInNanos, TimeUnit.NANOSECONDS);
     }
   }
 
@@ -171,17 +189,26 @@ public synchronized void onDataReceived() {
   public synchronized void onTransportActive() {
     if (state == State.IDLE) {
       // When the transport goes active, we do not reset the nextKeepaliveTime. This allows us to
-      // quickly check whether the conneciton is still working.
+      // quickly check whether the connection is still working.
       state = State.PING_SCHEDULED;
-      pingFuture = scheduler.schedule(sendPing, nextKeepaliveTime - ticker.read(),
-          TimeUnit.NANOSECONDS);
-    }
+      if (pingFuture == null) {
+        pingFuture = scheduler.schedule(
+            sendPing,
+            keepAliveTimeInNanos - stopwatch.elapsed(TimeUnit.NANOSECONDS),
+            TimeUnit.NANOSECONDS);
+      }
+    } else if (state == State.IDLE_AND_PING_SENT) {
+      state = State.PING_SENT;
+    } // Other states are possible when keepAliveDuringTransportIdle == true
   }
 
   /**
    * Transport has finished all streams.
    */
   public synchronized void onTransportIdle() {
+    if (keepAliveDuringTransportIdle) {
+      return;
+    }
     if (state == State.PING_SCHEDULED || state == State.PING_DELAYED) {
       state = State.IDLE;
     }
@@ -191,9 +218,9 @@ public synchronized void onTransportIdle() {
   }
 
   /**
-   * Transport is shutting down. We no longer need to do keepalives.
+   * Transport is being terminated. We no longer need to do keepalives.
    */
-  public synchronized void onTransportShutdown() {
+  public synchronized void onTransportTermination() {
     if (state != State.DISCONNECTED) {
       state = State.DISCONNECTED;
       if (shutdownFuture != null) {
@@ -201,56 +228,84 @@ public synchronized void onTransportShutdown() {
       }
       if (pingFuture != null) {
         pingFuture.cancel(false);
+        pingFuture = null;
       }
     }
   }
 
-  private class KeepAlivePingCallback implements ClientTransport.PingCallback {
+  /**
+   * Bumps keepalive time to 10 seconds if the specified value was smaller than that.
+   */
+  public static long clampKeepAliveTimeInNanos(long keepAliveTimeInNanos) {
+    return Math.max(keepAliveTimeInNanos, MIN_KEEPALIVE_TIME_NANOS);
+  }
 
-    @Override
-    public void onSuccess(long roundTripTimeNanos) {
-      synchronized (KeepAliveManager.this) {
-        shutdownFuture.cancel(false);
-        nextKeepaliveTime = ticker.read() + keepAliveDelayInNanos;
-        if (state == State.PING_SENT) {
-          // We have received the ping response so there's no need to shutdown the transport.
-          // Schedule a new keepalive ping.
-          pingFuture = scheduler.schedule(sendPing, keepAliveDelayInNanos, TimeUnit.NANOSECONDS);
-          state = State.PING_SCHEDULED;
-        }
-        if (state == State.IDLE_AND_PING_SENT) {
-          // Transport went idle after we had sent out the ping. We don't need to schedule a new
-          // ping.
-          state = State.IDLE;
-        }
-      }
+  /**
+   * Bumps keepalive timeout to 10 milliseconds if the specified value was smaller than that.
+   */
+  public static long clampKeepAliveTimeoutInNanos(long keepAliveTimeoutInNanos) {
+    return Math.max(keepAliveTimeoutInNanos, MIN_KEEPALIVE_TIMEOUT_NANOS);
+  }
+
+  public interface KeepAlivePinger {
+    /**
+     * Sends out a keep-alive ping.
+     */
+    void ping();
+
+    /**
+     * Callback when Ping Ack was not received in KEEPALIVE_TIMEOUT. Should shutdown the transport.
+     */
+    void onPingTimeout();
+  }
+
+  /**
+   * Default client side {@link KeepAlivePinger}.
+   */
+  public static final class ClientKeepAlivePinger implements KeepAlivePinger {
+
+
+    /**
+     * A {@link ClientTransport} that has life-cycle management.
+     *
+     */
+    @ThreadSafe
+    public interface TransportWithDisconnectReason extends ClientTransport {
+
+      /**
+       * Initiates a forceful shutdown in which preexisting and new calls are closed. Existing calls
+       * should be closed with the provided {@code reason} and {@code disconnectError}.
+       */
+      void shutdownNow(Status reason, DisconnectError disconnectError);
     }
 
-    @Override
-    public void onFailure(Throwable cause) {
-      // Keepalive ping has failed. Shutdown the transport now.
-      synchronized (KeepAliveManager.this) {
-        shutdownFuture.cancel(false);
-      }
-      shutdown.run();
+    private final TransportWithDisconnectReason transport;
+
+    public ClientKeepAlivePinger(TransportWithDisconnectReason transport) {
+      this.transport = transport;
     }
-  }
 
-  // TODO(zsurocking): Classes below are copied from Deadline.java. We should consider share the
-  // code.
+    @Override
+    public void ping() {
+      transport.ping(new ClientTransport.PingCallback() {
+        @Override
+        public void onSuccess(long roundTripTimeNanos) {}
 
-  /** Time source representing nanoseconds since fixed but arbitrary point in time. */
-  abstract static class Ticker {
-    /** Returns the number of nanoseconds since this source's epoch. */
-    public abstract long read();
-  }
+        @Override
+        public void onFailure(Status cause) {
+          transport.shutdownNow(Status.UNAVAILABLE.withDescription(
+                  "Keepalive failed. The connection is likely gone"),
+              SimpleDisconnectError.CONNECTION_TIMED_OUT);
+        }
+      }, MoreExecutors.directExecutor());
+    }
 
-  private static class SystemTicker extends Ticker {
     @Override
-    public long read() {
-      return System.nanoTime();
+    public void onPingTimeout() {
+      transport.shutdownNow(Status.UNAVAILABLE.withDescription(
+              "Keepalive failed. The connection is likely gone"),
+          SimpleDisconnectError.CONNECTION_TIMED_OUT);
     }
   }
-
 }
 
diff --git a/core/src/main/java/io/grpc/internal/LogExceptionRunnable.java b/core/src/main/java/io/grpc/internal/LogExceptionRunnable.java
index 5bf192b86bd..f4c6f2fc8ef 100644
--- a/core/src/main/java/io/grpc/internal/LogExceptionRunnable.java
+++ b/core/src/main/java/io/grpc/internal/LogExceptionRunnable.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
diff --git a/core/src/main/java/io/grpc/internal/LogId.java b/core/src/main/java/io/grpc/internal/LogId.java
deleted file mode 100644
index c9cff26c0d3..00000000000
--- a/core/src/main/java/io/grpc/internal/LogId.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import java.util.concurrent.atomic.AtomicLong;
-
-/**
- * A loggable ID, unique for the duration of the program.
- */
-public final class LogId {
-  private static final AtomicLong idAlloc = new AtomicLong();
-
-  /**
-   * @param tag a loggable tag associated with this ID.
-   */
-  public static LogId allocate(String tag) {
-    return new LogId(tag, idAlloc.incrementAndGet());
-  }
-
-  private final String tag;
-  private final long id;
-
-  private LogId(String tag, long id) {
-    this.tag = tag;
-    this.id = id;
-  }
-
-  public long getId() {
-    return id;
-  }
-
-  public String getTag() {
-    return tag;
-  }
-
-  @Override
-  public String toString() {
-    return tag + "-" + id;
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/LongCounter.java b/core/src/main/java/io/grpc/internal/LongCounter.java
new file mode 100644
index 00000000000..a88930b7d30
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/LongCounter.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2017 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.internal;
+
+/**
+ * An interface for a long base counter.
+ */
+public interface LongCounter {
+  /** Adds the delta to this counter. */
+  void add(long delta);
+
+  /** Returns the value of this counter. */
+  long value();
+}
diff --git a/core/src/main/java/io/grpc/internal/LongCounterFactory.java b/core/src/main/java/io/grpc/internal/LongCounterFactory.java
new file mode 100644
index 00000000000..0942139aaff
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/LongCounterFactory.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2017 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.internal;
+
+/**
+ * A factory for creating {@link LongCounter} objects. The concrete implementation returned may
+ * be platform dependent.
+ */
+final class LongCounterFactory {
+  /**
+   * Creates a LongCounter.
+   */
+  public static LongCounter create() {
+    if (ReflectionLongAdderCounter.isAvailable()) {
+      return new ReflectionLongAdderCounter();
+    } else {
+      return new AtomicLongCounter();
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ManagedChannelImpl.java b/core/src/main/java/io/grpc/internal/ManagedChannelImpl.java
index 80f7a0c060c..e423220e3ad 100644
--- a/core/src/main/java/io/grpc/internal/ManagedChannelImpl.java
+++ b/core/src/main/java/io/grpc/internal/ManagedChannelImpl.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -34,448 +19,686 @@
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.ClientStreamTracer.NAME_RESOLUTION_DELAYED;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static io.grpc.EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
 import com.google.common.base.Stopwatch;
 import com.google.common.base.Supplier;
-import com.google.instrumentation.stats.StatsContextFactory;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
 import io.grpc.Attributes;
+import io.grpc.CallCredentials;
 import io.grpc.CallOptions;
 import io.grpc.Channel;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
 import io.grpc.ClientCall;
 import io.grpc.ClientInterceptor;
 import io.grpc.ClientInterceptors;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ClientTransportFilter;
 import io.grpc.CompressorRegistry;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.Context;
+import io.grpc.Deadline;
 import io.grpc.DecompressorRegistry;
 import io.grpc.EquivalentAddressGroup;
+import io.grpc.ForwardingChannelBuilder2;
+import io.grpc.ForwardingClientCall;
+import io.grpc.Grpc;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.ChannelStats;
+import io.grpc.InternalChannelz.ChannelTrace;
+import io.grpc.InternalConfigSelector;
+import io.grpc.InternalInstrumented;
+import io.grpc.InternalLogId;
+import io.grpc.InternalWithLogId;
 import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.LoadBalancerProvider;
 import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
+import io.grpc.MetricInstrumentRegistry;
+import io.grpc.MetricRecorder;
 import io.grpc.NameResolver;
-import io.grpc.ResolvedServerInfoGroup;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.NameResolver.ResolutionResult;
+import io.grpc.NameResolverProvider;
+import io.grpc.NameResolverRegistry;
+import io.grpc.ProxyDetector;
 import io.grpc.Status;
-import io.grpc.TransportManager;
-import io.grpc.TransportManager.InterimTransport;
-import io.grpc.TransportManager.OobTransportProvider;
-import io.grpc.internal.ClientCallImpl.ClientTransportProvider;
+import io.grpc.StatusOr;
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import io.grpc.internal.ClientCallImpl.ClientStreamProvider;
+import io.grpc.internal.ClientTransportFactory.SwapChannelCredentialsResult;
+import io.grpc.internal.ManagedChannelImplBuilder.ClientTransportFactoryBuilder;
+import io.grpc.internal.ManagedChannelImplBuilder.FixedPortProvider;
+import io.grpc.internal.ManagedChannelServiceConfig.MethodInfo;
+import io.grpc.internal.ManagedChannelServiceConfig.ServiceConfigConvertedSelector;
+import io.grpc.internal.RetriableStream.ChannelBufferMeter;
+import io.grpc.internal.RetriableStream.Throttle;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.List;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
-import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import java.util.regex.Pattern;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
 import javax.annotation.concurrent.ThreadSafe;
 
 /** A communication channel for making outgoing RPCs. */
 @ThreadSafe
-public final class ManagedChannelImpl extends ManagedChannel implements WithLogId {
-  private static final Logger log = Logger.getLogger(ManagedChannelImpl.class.getName());
-
-  // Matching this pattern means the target string is a URI target or at least intended to be one.
-  // A URI target must be an absolute hierarchical URI.
-  // From RFC 2396: scheme = alpha *( alpha | digit | "+" | "-" | "." )
+final class ManagedChannelImpl extends ManagedChannel implements
+    InternalInstrumented<ChannelStats> {
   @VisibleForTesting
-  static final Pattern URI_PATTERN = Pattern.compile("[a-zA-Z][a-zA-Z0-9+.-]*:/.*");
+  static final Logger logger = Logger.getLogger(ManagedChannelImpl.class.getName());
 
   static final long IDLE_TIMEOUT_MILLIS_DISABLE = -1;
 
-  /**
-   * The time after idleTimeoutMillis expires before idleness takes effect. The time before
-   * idleTimeoutMillis expires is part of a fast path for acquiring the load balancer. After
-   * idleTimeoutMillis expires a slow path takes effect with extra synchronization.
-   *
-   * <p>Transports having open streams prevents entering idle mode. However, this creates an
-   * inherent race between acquiring a transport, which can't be done in idle mode, and the RPC
-   * actually being created on that transport, which inhibits idle mode. Thus we reset the idle
-   * timer when acquiring a transport, and impose a minimum idle time (IDLE_MODE_MIN_TIMEOUT_MILLIS)
-   * to make the chances of racing very small. If we do race, then the RPC will spuriously fail
-   * because the transport chosen was shut down.
-   *
-   * <p>For heavy users, resetting the idle timer each RPC becomes highly contended. We instead only
-   * need to reset the timer when it is close to expiring. We do the equivalent by having two
-   * periods: a reduced regular idle time period and the extra time as a grace period. We ignore the
-   * race during the regular idle time period, but any acquisition during the grace period must
-   * reset the timer.
-   */
+  static final long SUBCHANNEL_SHUTDOWN_DELAY_SECONDS = 5;
+
   @VisibleForTesting
-  static final long IDLE_GRACE_PERIOD_MILLIS = TimeUnit.SECONDS.toMillis(1);
+  static final Status SHUTDOWN_NOW_STATUS =
+      Status.UNAVAILABLE.withDescription("Channel shutdownNow invoked");
 
-  private static final ClientTransport SHUTDOWN_TRANSPORT =
-      new FailingClientTransport(Status.UNAVAILABLE.withDescription("Channel is shutdown"));
+  @VisibleForTesting
+  static final Status SHUTDOWN_STATUS =
+      Status.UNAVAILABLE.withDescription("Channel shutdown invoked");
 
   @VisibleForTesting
-  static final ClientTransport IDLE_MODE_TRANSPORT =
-      new FailingClientTransport(Status.INTERNAL.withDescription("Channel is in idle mode"));
+  static final Status SUBCHANNEL_SHUTDOWN_STATUS =
+      Status.UNAVAILABLE.withDescription("Subchannel shutdown invoked");
 
+  private static final ManagedChannelServiceConfig EMPTY_SERVICE_CONFIG =
+      ManagedChannelServiceConfig.empty();
+  private static final InternalConfigSelector INITIAL_PENDING_SELECTOR =
+      new InternalConfigSelector() {
+        @Override
+        public Result selectConfig(PickSubchannelArgs args) {
+          throw new IllegalStateException("Resolution is pending");
+        }
+      };
+  private static final LoadBalancer.PickDetailsConsumer NOOP_PICK_DETAILS_CONSUMER =
+      new LoadBalancer.PickDetailsConsumer() {};
+
+  private final InternalLogId logId;
   private final String target;
-  private final NameResolver.Factory nameResolverFactory;
-  private final Attributes nameResolverParams;
-  private final LoadBalancer.Factory loadBalancerFactory;
+  @Nullable
+  private final String authorityOverride;
+  private final NameResolverRegistry nameResolverRegistry;
+  private final UriWrapper targetUri;
+  private final NameResolverProvider nameResolverProvider;
+  private final NameResolver.Args nameResolverArgs;
+  private final LoadBalancerProvider loadBalancerFactory;
+  private final ClientTransportFactory originalTransportFactory;
+  @Nullable
+  private final ChannelCredentials originalChannelCreds;
   private final ClientTransportFactory transportFactory;
+  private final RestrictedScheduledExecutor scheduledExecutor;
   private final Executor executor;
-  private final boolean usingSharedExecutor;
-  private final Object lock = new Object();
-  private final LogId logId = LogId.allocate(getClass().getName());
+  private final ObjectPool<? extends Executor> executorPool;
+  private final ExecutorHolder balancerRpcExecutorHolder;
+  private final ExecutorHolder offloadExecutorHolder;
+  private final TimeProvider timeProvider;
+  private final int maxTraceEvents;
+
+  @VisibleForTesting
+  final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          logger.log(
+              Level.SEVERE,
+              "[" + getLogId() + "] Uncaught exception in the SynchronizationContext. Panic!",
+              e);
+          try {
+            panic(e);
+          } catch (Throwable anotherT) {
+            logger.log(
+                Level.SEVERE, "[" + getLogId() + "] Uncaught exception while panicking", anotherT);
+          }
+        }
+      });
+
+  private boolean fullStreamDecompression;
 
   private final DecompressorRegistry decompressorRegistry;
   private final CompressorRegistry compressorRegistry;
 
-  private final SharedResourceHolder.Resource<ScheduledExecutorService> timerService;
   private final Supplier<Stopwatch> stopwatchSupplier;
-  /** The timout before entering idle mode, less {@link #IDLE_GRACE_PERIOD_MILLIS}. */
+  /** The timeout before entering idle mode. */
   private final long idleTimeoutMillis;
-  private final StatsContextFactory statsFactory;
-
-  /**
-   * Executor that runs deadline timers for requests.
-   */
-  private ScheduledExecutorService scheduledExecutor;
 
+  private final ConnectivityStateManager channelStateManager = new ConnectivityStateManager();
   private final BackoffPolicy.Provider backoffPolicyProvider;
 
   /**
    * We delegate to this channel, so that we can have interceptors as necessary. If there aren't
-   * any interceptors this will just be {@link RealChannel}.
+   * any interceptors and the {@link io.grpc.BinaryLog} is {@code null} then this will just be a
+   * {@link RealChannel}.
    */
   private final Channel interceptorChannel;
+
+  private final List<ClientTransportFilter> transportFilters;
   @Nullable private final String userAgent;
 
-  // Never be null. Must be modified under lock.
+  // Only null after channel is terminated. Must be assigned from the syncContext.
   private NameResolver nameResolver;
 
-  /** {@code null} when idle or when in grace idle period. "lock" must be held when modifying. */
+  // Must be accessed from the syncContext.
+  private boolean nameResolverStarted;
+
+  // null when channel is in idle mode.  Must be assigned from syncContext.
   @Nullable
-  private volatile LoadBalancer<ClientTransport> loadBalancer;
+  private LbHelperImpl lbHelper;
+
+  // Must be accessed from the syncContext
+  private boolean panicMode;
 
-  /** non-{code null} iff channel is in grace idle period. */
-  @GuardedBy("lock")
+  // Must be mutated from syncContext
+  // If any monitoring hook to be added later needs to get a snapshot of this Set, we could
+  // switch to a ConcurrentHashMap.
+  private final Set<InternalSubchannel> subchannels = new HashSet<>(16, .75f);
+
+  // Must be accessed from syncContext
   @Nullable
-  private LoadBalancer<ClientTransport> graceLoadBalancer;
+  private Collection<RealChannel.PendingCall<?, ?>> pendingCalls;
+  private final Object pendingCallsInUseObject = new Object();
 
-  /**
-   * Maps EquivalentAddressGroups to transports for that server. "lock" must be held when mutating.
-   */
-  // Even though we set a concurrency level of 1, this is better than Collections.synchronizedMap
-  // because it doesn't need to acquire a lock for reads.
-  private final ConcurrentMap<EquivalentAddressGroup, TransportSet> transports =
-      new ConcurrentHashMap<EquivalentAddressGroup, TransportSet>(16, .75f, 1);
+  // reprocess() must be run from syncContext
+  private final DelayedClientTransport delayedTransport;
+  private final UncommittedRetriableStreamsRegistry uncommittedRetriableStreamsRegistry
+      = new UncommittedRetriableStreamsRegistry();
 
-  /**
-   * TransportSets that are shutdown (but not yet terminated) due to channel idleness or channel
-   * shut down.
-   */
-  @GuardedBy("lock")
-  private final HashSet<TransportSet> decommissionedTransports = new HashSet<TransportSet>();
+  // Shutdown states.
+  //
+  // Channel's shutdown process:
+  // 1. shutdown(): stop accepting new calls from applications
+  //   1a shutdown <- true
+  //   1b delayedTransport.shutdown()
+  // 2. delayedTransport terminated: stop stream-creation functionality
+  //   2a terminating <- true
+  //   2b loadBalancer.shutdown()
+  //     * LoadBalancer will shutdown subchannels and OOB channels
+  //   2c loadBalancer <- null
+  //   2d nameResolver.shutdown()
+  //   2e nameResolver <- null
+  // 3. All subchannels and OOB channels terminated: Channel considered terminated
+
+  private final AtomicBoolean shutdown = new AtomicBoolean(false);
+  // Must only be mutated and read from syncContext
+  private boolean shutdownNowed;
+  // Must only be mutated from syncContext
+  private boolean terminating;
+  // Must be mutated from syncContext
+  private volatile boolean terminated;
+  private final CountDownLatch terminatedLatch = new CountDownLatch(1);
+
+  private final CallTracer.Factory callTracerFactory;
+  private final CallTracer channelCallTracer;
+  private final ChannelTracer channelTracer;
+  private final ChannelLogger channelLogger;
+  private final InternalChannelz channelz;
+  private final RealChannel realChannel;
+  // Must be mutated and read from syncContext
+  // a flag for doing channel tracing when flipped
+  private ResolutionState lastResolutionState = ResolutionState.NO_RESOLUTION;
+  // Must be mutated and read from constructor or syncContext
+  // used for channel tracing when value changed
+  private ManagedChannelServiceConfig lastServiceConfig = EMPTY_SERVICE_CONFIG;
+
+  @Nullable
+  private final ManagedChannelServiceConfig defaultServiceConfig;
+  // Must be mutated and read from constructor or syncContext
+  private boolean serviceConfigUpdated = false;
+  private final boolean lookUpServiceConfig;
+
+  // One instance per channel.
+  private final ChannelBufferMeter channelBufferUsed = new ChannelBufferMeter();
+
+  private final long perRpcBufferLimit;
+  private final long channelBufferLimit;
+
+  // Temporary false flag that can skip the retry code path.
+  private final boolean retryEnabled;
+
+  private final Deadline.Ticker ticker = Deadline.getSystemTicker();
+
+  // Called from syncContext
+  private final ManagedClientTransport.Listener delayedTransportListener =
+      new DelayedTransportListener();
 
-  @GuardedBy("lock")
-  private final HashSet<DelayedClientTransport> delayedTransports =
-      new HashSet<DelayedClientTransport>();
+  // Must be called from syncContext
+  private void maybeShutdownNowSubchannels() {
+    if (shutdownNowed) {
+      for (InternalSubchannel subchannel : subchannels) {
+        subchannel.shutdownNow(SHUTDOWN_NOW_STATUS);
+      }
+    }
+  }
 
+  // Must be accessed from syncContext
   @VisibleForTesting
-  final InUseStateAggregator<Object> inUseStateAggregator =
-      new InUseStateAggregator<Object>() {
-        @Override
-        Object getLock() {
-          return lock;
-        }
+  final InUseStateAggregator<Object> inUseStateAggregator = new IdleModeStateAggregator();
 
-        @Override
-        @GuardedBy("lock")
-        Runnable handleInUse() {
-          return exitIdleMode();
-        }
+  @Override
+  public ListenableFuture<ChannelStats> getStats() {
+    final SettableFuture<ChannelStats> ret = SettableFuture.create();
+    final class StatsFetcher implements Runnable {
+      @Override
+      public void run() {
+        ChannelStats.Builder builder = new InternalChannelz.ChannelStats.Builder();
+        channelCallTracer.updateBuilder(builder);
+        channelTracer.updateBuilder(builder);
+        builder.setTarget(target).setState(channelStateManager.getState());
+        List<InternalWithLogId> children = new ArrayList<>();
+        children.addAll(subchannels);
+        builder.setSubchannels(children);
+        ret.set(builder.build());
+      }
+    }
 
-        @GuardedBy("lock")
-        @Override
-        void handleNotInUse() {
-          if (shutdown) {
-            return;
-          }
-          rescheduleIdleTimer();
-        }
-      };
+    // subchannels and oobchannels can only be accessed from syncContext
+    syncContext.execute(new StatsFetcher());
+    return ret;
+  }
+
+  @Override
+  public InternalLogId getLogId() {
+    return logId;
+  }
 
+  // Run from syncContext
   private class IdleModeTimer implements Runnable {
-    @GuardedBy("lock")
-    boolean cancelled;
 
     @Override
     public void run() {
-      ArrayList<TransportSet> transportsCopy = new ArrayList<TransportSet>();
-      LoadBalancer<ClientTransport> savedBalancer;
-      NameResolver oldResolver;
-      synchronized (lock) {
-        if (cancelled) {
-          // Race detected: this task started before cancelIdleTimer() could cancel it.
-          return;
-        }
-        if (loadBalancer != null) {
-          // Enter grace period.
-          graceLoadBalancer = loadBalancer;
-          loadBalancer = null;
-          assert idleModeTimer == this;
-          idleModeTimerFuture = scheduledExecutor.schedule(new LogExceptionRunnable(idleModeTimer),
-              IDLE_GRACE_PERIOD_MILLIS, TimeUnit.MILLISECONDS);
-          return;
-        }
-        log.log(Level.FINE, "[{0}] Entering idle mode", getLogId());
-        // Enter idle mode
-        savedBalancer = graceLoadBalancer;
-        graceLoadBalancer = null;
-        oldResolver = nameResolver;
-        nameResolver = getNameResolver(target, nameResolverFactory, nameResolverParams);
-        transportsCopy.addAll(transports.values());
-        transports.clear();
-        decommissionedTransports.addAll(transportsCopy);
-      }
-      for (TransportSet ts : transportsCopy) {
-        ts.shutdown();
+      // Workaround timer scheduled while in idle mode. This can happen from handleNotInUse() after
+      // an explicit enterIdleMode() by the user. Protecting here as other locations are a bit too
+      // subtle to change rapidly to resolve the channel panic. See #8714
+      if (lbHelper == null) {
+        return;
       }
-      savedBalancer.shutdown();
-      oldResolver.shutdown();
+      enterIdleMode();
     }
   }
 
-  @GuardedBy("lock")
-  @Nullable
-  private ScheduledFuture<?> idleModeTimerFuture;
-  @GuardedBy("lock")
-  @Nullable
-  private IdleModeTimer idleModeTimer;
-
-  /**
-   * Make the channel exit idle mode, if it's in it. Return a LoadBalancer that can be used for
-   * making new requests. Return null if the channel is shutdown.
-   */
-  @VisibleForTesting
-  LoadBalancer<ClientTransport> exitIdleModeAndGetLb() {
-    Runnable runnable;
-    LoadBalancer<ClientTransport> balancer;
-    synchronized (lock) {
-      runnable = exitIdleMode();
-      balancer = loadBalancer;
+  // Must be called from syncContext
+  private void shutdownNameResolverAndLoadBalancer(boolean channelIsActive) {
+    syncContext.throwIfNotInThisSynchronizationContext();
+    if (channelIsActive) {
+      checkState(nameResolverStarted, "nameResolver is not started");
+      checkState(lbHelper != null, "lbHelper is null");
+    }
+    if (nameResolver != null) {
+      nameResolver.shutdown();
+      nameResolverStarted = false;
+      if (channelIsActive) {
+        nameResolver = getNameResolver(
+            targetUri, authorityOverride, nameResolverProvider, nameResolverArgs);
+      } else {
+        nameResolver = null;
+      }
     }
-    if (runnable != null) {
-      runnable.run();
+    if (lbHelper != null) {
+      lbHelper.lb.shutdown();
+      lbHelper = null;
     }
-    return balancer;
   }
 
   /**
-   * Make the channel exit idle mode, if it's in it. If the returned runnable is non-{@code null},
-   * then it should be executed by the caller after releasing {@code lock}.
+   * Make the channel exit idle mode, if it's in it.
+   *
+   * <p>Must be called from syncContext
    */
-  @GuardedBy("lock")
-  private Runnable exitIdleMode() {
-    final LoadBalancer<ClientTransport> balancer;
-    final NameResolver resolver;
-    if (shutdown) {
-      return null;
+  @VisibleForTesting
+  void exitIdleMode() {
+    syncContext.throwIfNotInThisSynchronizationContext();
+    if (shutdown.get() || panicMode) {
+      return;
     }
     if (inUseStateAggregator.isInUse()) {
-      cancelIdleTimer();
+      // Cancel the timer now, so that a racing due timer will not put Channel on idleness
+      // when the caller of exitIdleMode() is about to use the returned loadBalancer.
+      cancelIdleTimer(false);
     } else {
-      // exitIdleMode() may be called outside of inUseStateAggregator, which may still in
-      // "not-in-use" state. If it's the case, we start the timer which will be soon cancelled if
-      // the aggregator receives actual uses.
+      // exitIdleMode() may be called outside of inUseStateAggregator.handleNotInUse() while
+      // isInUse() == false, in which case we still need to schedule the timer.
       rescheduleIdleTimer();
     }
-    if (graceLoadBalancer != null) {
-      // Exit grace period; timer already rescheduled above.
-      loadBalancer = graceLoadBalancer;
-      graceLoadBalancer = null;
-    }
-    if (loadBalancer != null) {
-      return null;
-    }
-    log.log(Level.FINE, "[{0}] Exiting idle mode", getLogId());
-    balancer = loadBalancerFactory.newLoadBalancer(nameResolver.getServiceAuthority(), tm);
-    this.loadBalancer = balancer;
-    resolver = this.nameResolver;
-    class NameResolverStartTask implements Runnable {
-      @Override
-      public void run() {
-        NameResolverListenerImpl listener = new NameResolverListenerImpl(balancer);
-        // This may trigger quite a few non-trivial work in LoadBalancer and NameResolver,
-        // we don't want to do it in the lock.
-        try {
-          resolver.start(listener);
-        } catch (Throwable t) {
-          listener.onError(Status.fromThrowable(t));
-        }
-      }
+    if (lbHelper != null) {
+      return;
     }
-
-    return new NameResolverStartTask();
+    channelLogger.log(ChannelLogLevel.INFO, "Exiting idle mode");
+    LbHelperImpl lbHelper = new LbHelperImpl();
+    lbHelper.lb = loadBalancerFactory.newLoadBalancer(lbHelper);
+    // Delay setting lbHelper until fully initialized, since loadBalancerFactory is user code and
+    // may throw. We don't want to confuse our state, even if we enter panic mode.
+    this.lbHelper = lbHelper;
+
+    channelStateManager.gotoState(CONNECTING);
+    NameResolverListener listener = new NameResolverListener(lbHelper, nameResolver);
+    nameResolver.start(listener);
+    nameResolverStarted = true;
   }
 
-  @VisibleForTesting
-  boolean isInIdleGracePeriod() {
-    synchronized (lock) {
-      return graceLoadBalancer != null;
+  // Must be run from syncContext
+  private void enterIdleMode() {
+    // nameResolver and loadBalancer are guaranteed to be non-null.  If any of them were null,
+    // either the idleModeTimer ran twice without exiting the idle mode, or the task in shutdown()
+    // did not cancel idleModeTimer, or enterIdle() ran while shutdown or in idle, all of
+    // which are bugs.
+    shutdownNameResolverAndLoadBalancer(true);
+    delayedTransport.reprocess(null);
+    channelLogger.log(ChannelLogLevel.INFO, "Entering IDLE state");
+    channelStateManager.gotoState(IDLE);
+    // If the inUseStateAggregator still considers pending calls to be queued up or the delayed
+    // transport to be holding some we need to exit idle mode to give these calls a chance to
+    // be processed.
+    if (inUseStateAggregator.anyObjectInUse(pendingCallsInUseObject, delayedTransport)) {
+      exitIdleMode();
     }
   }
 
-  // ErrorProne's GuardedByChecker can't figure out that the idleModeTimer is a nested instance of
-  // this particular instance. It is worried about something like:
-  // ManagedChannelImpl a = ...;
-  // ManagedChannelImpl b = ...;
-  // a.idleModeTimer = b.idleModeTimer;
-  // a.cancelIdleTimer(); // access of b.idleModeTimer is guarded by a.lock, not b.lock
-  //
-  // _We_ know that isn't happening, so we suppress the warning.
-  @SuppressWarnings("GuardedByChecker")
-  @GuardedBy("lock")
-  private void cancelIdleTimer() {
-    if (idleModeTimerFuture != null) {
-      idleModeTimerFuture.cancel(false);
-      idleModeTimer.cancelled = true;
-      idleModeTimerFuture = null;
-      idleModeTimer = null;
-    }
+  // Must be run from syncContext
+  private void cancelIdleTimer(boolean permanent) {
+    idleTimer.cancel(permanent);
   }
 
-  @GuardedBy("lock")
+  // Always run from syncContext
   private void rescheduleIdleTimer() {
     if (idleTimeoutMillis == IDLE_TIMEOUT_MILLIS_DISABLE) {
       return;
     }
-    cancelIdleTimer();
-    idleModeTimer = new IdleModeTimer();
-    idleModeTimerFuture = scheduledExecutor.schedule(new LogExceptionRunnable(idleModeTimer),
-        idleTimeoutMillis, TimeUnit.MILLISECONDS);
+    idleTimer.reschedule(idleTimeoutMillis, TimeUnit.MILLISECONDS);
   }
 
-  @GuardedBy("lock")
-  private final HashSet<OobTransportProviderImpl> oobTransports =
-      new HashSet<OobTransportProviderImpl>();
+  /**
+   * Force name resolution refresh to happen immediately. Must be run
+   * from syncContext.
+   */
+  private void refreshNameResolution() {
+    syncContext.throwIfNotInThisSynchronizationContext();
+    if (nameResolverStarted) {
+      nameResolver.refresh();
+    }
+  }
 
-  @GuardedBy("lock")
-  private boolean shutdown;
-  @GuardedBy("lock")
-  private boolean shutdownNowed;
-  @GuardedBy("lock")
-  private boolean terminated;
+  private final class ChannelStreamProvider implements ClientStreamProvider {
+    volatile Throttle throttle;
 
-  private final ClientTransportProvider transportProvider = new ClientTransportProvider() {
     @Override
-    public ClientTransport get(CallOptions callOptions, Metadata headers) {
-      LoadBalancer<ClientTransport> balancer = loadBalancer;
-      if (balancer == null) {
-        // Current state is either idle or in grace period
-        balancer = exitIdleModeAndGetLb();
-      }
-      if (balancer == null) {
-        return SHUTDOWN_TRANSPORT;
+    public ClientStream newStream(
+        final MethodDescriptor<?, ?> method,
+        final CallOptions callOptions,
+        final Metadata headers,
+        final Context context) {
+      // There is no need to reschedule the idle timer here. If the channel isn't shut down, either
+      // the delayed transport or a real transport will go in-use and cancel the idle timer.
+      if (!retryEnabled) {
+        ClientStreamTracer[] tracers = GrpcUtil.getClientStreamTracers(
+            callOptions, headers, 0, /* isTransparentRetry= */ false,
+            /* isHedging= */false);
+        Context origContext = context.attach();
+        try {
+          return delayedTransport.newStream(method, headers, callOptions, tracers);
+        } finally {
+          context.detach(origContext);
+        }
+      } else {
+        MethodInfo methodInfo = callOptions.getOption(MethodInfo.KEY);
+        final RetryPolicy retryPolicy = methodInfo == null ? null : methodInfo.retryPolicy;
+        final HedgingPolicy hedgingPolicy = methodInfo == null ? null : methodInfo.hedgingPolicy;
+        final class RetryStream<ReqT> extends RetriableStream<ReqT> {
+          @SuppressWarnings("unchecked")
+          RetryStream() {
+            super(
+                (MethodDescriptor<ReqT, ?>) method,
+                headers,
+                channelBufferUsed,
+                perRpcBufferLimit,
+                channelBufferLimit,
+                getCallExecutor(callOptions),
+                transportFactory.getScheduledExecutorService(),
+                retryPolicy,
+                hedgingPolicy,
+                throttle);
+          }
+
+          @Override
+          Status prestart() {
+            return uncommittedRetriableStreamsRegistry.add(this);
+          }
+
+          @Override
+          void postCommit() {
+            uncommittedRetriableStreamsRegistry.remove(this);
+          }
+
+          @Override
+          ClientStream newSubstream(
+              Metadata newHeaders, ClientStreamTracer.Factory factory, int previousAttempts,
+              boolean isTransparentRetry, boolean isHedgedStream) {
+            CallOptions newOptions = callOptions.withStreamTracerFactory(factory);
+            ClientStreamTracer[] tracers = GrpcUtil.getClientStreamTracers(
+                newOptions, newHeaders, previousAttempts, isTransparentRetry, isHedgedStream);
+            Context origContext = context.attach();
+            try {
+              return delayedTransport.newStream(method, newHeaders, newOptions, tracers);
+            } finally {
+              context.detach(origContext);
+            }
+          }
+        }
+
+        return new RetryStream<>();
       }
-      return balancer.pickTransport(callOptions.getAffinity());
     }
-  };
+  }
 
-  ManagedChannelImpl(String target, BackoffPolicy.Provider backoffPolicyProvider,
-      NameResolver.Factory nameResolverFactory, Attributes nameResolverParams,
-      LoadBalancer.Factory loadBalancerFactory, ClientTransportFactory transportFactory,
-      DecompressorRegistry decompressorRegistry, CompressorRegistry compressorRegistry,
-      SharedResourceHolder.Resource<ScheduledExecutorService> timerService,
-      Supplier<Stopwatch> stopwatchSupplier, long idleTimeoutMillis,
-      @Nullable Executor executor, @Nullable String userAgent,
-      List<ClientInterceptor> interceptors, StatsContextFactory statsFactory) {
-    this.target = checkNotNull(target, "target");
-    this.nameResolverFactory = checkNotNull(nameResolverFactory, "nameResolverFactory");
-    this.nameResolverParams = checkNotNull(nameResolverParams, "nameResolverParams");
-    this.nameResolver = getNameResolver(target, nameResolverFactory, nameResolverParams);
-    this.loadBalancerFactory = checkNotNull(loadBalancerFactory, "loadBalancerFactory");
-    if (executor == null) {
-      usingSharedExecutor = true;
-      this.executor = SharedResourceHolder.get(GrpcUtil.SHARED_CHANNEL_EXECUTOR);
+  private final ChannelStreamProvider transportProvider = new ChannelStreamProvider();
+
+  private final Rescheduler idleTimer;
+  private final MetricRecorder metricRecorder;
+
+  ManagedChannelImpl(
+      ManagedChannelImplBuilder builder,
+      ClientTransportFactory clientTransportFactory,
+      UriWrapper targetUri,
+      NameResolverProvider nameResolverProvider,
+      BackoffPolicy.Provider backoffPolicyProvider,
+      ObjectPool<? extends Executor> balancerRpcExecutorPool,
+      Supplier<Stopwatch> stopwatchSupplier,
+      List<ClientInterceptor> interceptors,
+      final TimeProvider timeProvider) {
+    this.target = checkNotNull(builder.target, "target");
+    this.logId = InternalLogId.allocate("Channel", target);
+    this.timeProvider = checkNotNull(timeProvider, "timeProvider");
+    this.executorPool = checkNotNull(builder.executorPool, "executorPool");
+    this.executor = checkNotNull(executorPool.getObject(), "executor");
+    this.originalChannelCreds = builder.channelCredentials;
+    this.originalTransportFactory = clientTransportFactory;
+    this.offloadExecutorHolder =
+        new ExecutorHolder(checkNotNull(builder.offloadExecutorPool, "offloadExecutorPool"));
+    this.transportFactory = new CallCredentialsApplyingTransportFactory(
+        clientTransportFactory, builder.callCredentials, this.offloadExecutorHolder);
+    this.scheduledExecutor =
+        new RestrictedScheduledExecutor(transportFactory.getScheduledExecutorService());
+    maxTraceEvents = builder.maxTraceEvents;
+    channelTracer = new ChannelTracer(
+        logId, builder.maxTraceEvents, timeProvider.currentTimeNanos(),
+        "Channel for '" + target + "'");
+    channelLogger = new ChannelLoggerImpl(channelTracer, timeProvider);
+    ProxyDetector proxyDetector =
+        builder.proxyDetector != null ? builder.proxyDetector : GrpcUtil.DEFAULT_PROXY_DETECTOR;
+    this.retryEnabled = builder.retryEnabled;
+    this.loadBalancerFactory = new AutoConfiguredLoadBalancerFactory(builder.defaultLbPolicy);
+    this.nameResolverRegistry = builder.nameResolverRegistry;
+    this.targetUri = checkNotNull(targetUri, "targetUri");
+    this.nameResolverProvider = checkNotNull(nameResolverProvider, "nameResolverProvider");
+    ScParser serviceConfigParser =
+        new ScParser(
+            retryEnabled,
+            builder.maxRetryAttempts,
+            builder.maxHedgedAttempts,
+            loadBalancerFactory);
+    this.authorityOverride = builder.authorityOverride;
+    this.metricRecorder = new MetricRecorderImpl(builder.metricSinks,
+        MetricInstrumentRegistry.getDefaultRegistry());
+    NameResolver.Args.Builder nameResolverArgsBuilder = NameResolver.Args.newBuilder()
+            .setDefaultPort(builder.getDefaultPort())
+            .setProxyDetector(proxyDetector)
+            .setSynchronizationContext(syncContext)
+            .setScheduledExecutorService(scheduledExecutor)
+            .setServiceConfigParser(serviceConfigParser)
+            .setChannelLogger(channelLogger)
+            .setOffloadExecutor(this.offloadExecutorHolder)
+            .setOverrideAuthority(this.authorityOverride)
+            .setMetricRecorder(this.metricRecorder)
+            .setNameResolverRegistry(builder.nameResolverRegistry);
+    builder.copyAllNameResolverCustomArgsTo(nameResolverArgsBuilder);
+    this.nameResolverArgs = nameResolverArgsBuilder.build();
+    this.nameResolver = getNameResolver(
+        targetUri, authorityOverride, nameResolverProvider, nameResolverArgs);
+    this.balancerRpcExecutorHolder = new ExecutorHolder(
+        checkNotNull(balancerRpcExecutorPool, "balancerRpcExecutorPool"));
+    this.delayedTransport = new DelayedClientTransport(this.executor, this.syncContext);
+    this.delayedTransport.start(delayedTransportListener);
+    this.backoffPolicyProvider = backoffPolicyProvider;
+
+    if (builder.defaultServiceConfig != null) {
+      ConfigOrError parsedDefaultServiceConfig =
+          serviceConfigParser.parseServiceConfig(builder.defaultServiceConfig);
+      checkState(
+          parsedDefaultServiceConfig.getError() == null,
+          "Default config is invalid: %s",
+          parsedDefaultServiceConfig.getError());
+      this.defaultServiceConfig =
+          (ManagedChannelServiceConfig) parsedDefaultServiceConfig.getConfig();
+      this.transportProvider.throttle = this.defaultServiceConfig.getRetryThrottling();
     } else {
-      usingSharedExecutor = false;
-      this.executor = executor;
+      this.defaultServiceConfig = null;
     }
-    this.backoffPolicyProvider = backoffPolicyProvider;
-    this.transportFactory =
-        new CallCredentialsApplyingTransportFactory(transportFactory, this.executor);
-    this.interceptorChannel = ClientInterceptors.intercept(new RealChannel(), interceptors);
-    this.timerService = timerService;
-    this.scheduledExecutor = SharedResourceHolder.get(timerService);
+    this.lookUpServiceConfig = builder.lookUpServiceConfig;
+    realChannel = new RealChannel(nameResolver.getServiceAuthority());
+    Channel channel = realChannel;
+    if (builder.binlog != null) {
+      channel = builder.binlog.wrapChannel(channel);
+    }
+    this.interceptorChannel = ClientInterceptors.intercept(channel, interceptors);
+    this.transportFilters = new ArrayList<>(builder.transportFilters);
     this.stopwatchSupplier = checkNotNull(stopwatchSupplier, "stopwatchSupplier");
-    if (idleTimeoutMillis == IDLE_TIMEOUT_MILLIS_DISABLE) {
-      this.idleTimeoutMillis = idleTimeoutMillis;
+    if (builder.idleTimeoutMillis == IDLE_TIMEOUT_MILLIS_DISABLE) {
+      this.idleTimeoutMillis = builder.idleTimeoutMillis;
     } else {
-      assert IDLE_GRACE_PERIOD_MILLIS
-          <= AbstractManagedChannelImplBuilder.IDLE_MODE_MIN_TIMEOUT_MILLIS;
-      checkArgument(idleTimeoutMillis >= IDLE_GRACE_PERIOD_MILLIS,
-          "invalid idleTimeoutMillis %s", idleTimeoutMillis);
-      this.idleTimeoutMillis = idleTimeoutMillis - IDLE_GRACE_PERIOD_MILLIS;
+      checkArgument(
+          builder.idleTimeoutMillis
+              >= ManagedChannelImplBuilder.IDLE_MODE_MIN_TIMEOUT_MILLIS,
+          "invalid idleTimeoutMillis %s", builder.idleTimeoutMillis);
+      this.idleTimeoutMillis = builder.idleTimeoutMillis;
+    }
+
+    idleTimer = new Rescheduler(
+        new IdleModeTimer(),
+        syncContext,
+        transportFactory.getScheduledExecutorService(),
+        stopwatchSupplier.get());
+    this.fullStreamDecompression = builder.fullStreamDecompression;
+    this.decompressorRegistry = checkNotNull(builder.decompressorRegistry, "decompressorRegistry");
+    this.compressorRegistry = checkNotNull(builder.compressorRegistry, "compressorRegistry");
+    this.userAgent = builder.userAgent;
+
+    this.channelBufferLimit = builder.retryBufferSize;
+    this.perRpcBufferLimit = builder.perRpcBufferLimit;
+    final class ChannelCallTracerFactory implements CallTracer.Factory {
+      @Override
+      public CallTracer create() {
+        return new CallTracer(timeProvider);
+      }
     }
-    this.decompressorRegistry = decompressorRegistry;
-    this.compressorRegistry = compressorRegistry;
-    this.userAgent = userAgent;
-    this.statsFactory = checkNotNull(statsFactory, "statsFactory");
 
-    if (log.isLoggable(Level.INFO)) {
-      log.log(Level.INFO, "[{0}] Created with target {1}", new Object[] {getLogId(), target});
+    this.callTracerFactory = new ChannelCallTracerFactory();
+    channelCallTracer = callTracerFactory.create();
+    this.channelz = checkNotNull(builder.channelz);
+    channelz.addRootChannel(this);
+
+    if (!lookUpServiceConfig) {
+      if (defaultServiceConfig != null) {
+        channelLogger.log(
+            ChannelLogLevel.INFO, "Service config look-up disabled, using default service config");
+      }
+      serviceConfigUpdated = true;
     }
   }
 
   @VisibleForTesting
-  static NameResolver getNameResolver(String target, NameResolver.Factory nameResolverFactory,
-      Attributes nameResolverParams) {
-    // Finding a NameResolver. Try using the target string as the URI. If that fails, try prepending
-    // "dns:///".
-    URI targetUri = null;
-    StringBuilder uriSyntaxErrors = new StringBuilder();
-    try {
-      targetUri = new URI(target);
-      // For "localhost:8080" this would likely cause newNameResolver to return null, because
-      // "localhost" is parsed as the scheme. Will fall into the next branch and try
-      // "dns:///localhost:8080".
-    } catch (URISyntaxException e) {
-      // Can happen with ip addresses like "[::1]:1234" or 127.0.0.1:1234.
-      uriSyntaxErrors.append(e.getMessage());
-    }
-    if (targetUri != null) {
-      NameResolver resolver = nameResolverFactory.newNameResolver(targetUri, nameResolverParams);
-      if (resolver != null) {
-        return resolver;
-      }
-      // "foo.googleapis.com:8080" cause resolver to be null, because "foo.googleapis.com" is an
-      // unmapped scheme. Just fall through and will try "dns:///foo.googleapis.com:8080"
-    }
-
-    // If we reached here, the targetUri couldn't be used.
-    if (!URI_PATTERN.matcher(target).matches()) {
-      // It doesn't look like a URI target. Maybe it's an authority string. Try with the default
-      // scheme from the factory.
-      try {
-        targetUri = new URI(nameResolverFactory.getDefaultScheme(), "", "/" + target, null);
-      } catch (URISyntaxException e) {
-        // Should not be possible.
-        throw new IllegalArgumentException(e);
-      }
-      if (targetUri != null) {
-        NameResolver resolver = nameResolverFactory.newNameResolver(targetUri, nameResolverParams);
-        if (resolver != null) {
-          return resolver;
-        }
-      }
+  static NameResolver getNameResolver(
+      UriWrapper targetUri, @Nullable final String overrideAuthority,
+      NameResolverProvider provider, NameResolver.Args nameResolverArgs) {
+    NameResolver resolver = targetUri.newNameResolver(provider, nameResolverArgs);
+    if (resolver == null) {
+      throw new IllegalArgumentException("cannot create a NameResolver for " + targetUri);
     }
-    throw new IllegalArgumentException(String.format(
-        "cannot find a NameResolver for %s%s",
-        target, uriSyntaxErrors.length() > 0 ? " (" + uriSyntaxErrors + ")" : ""));
+
+    // We wrap the name resolver in a RetryingNameResolver to give it the ability to retry failures.
+    // TODO: After a transition period, all NameResolver implementations that need retry should use
+    //       RetryingNameResolver directly and this step can be removed.
+    NameResolver usedNameResolver = RetryingNameResolver.wrap(resolver, nameResolverArgs);
+
+    if (overrideAuthority == null) {
+      return usedNameResolver;
+    }
+
+    return new ForwardingNameResolver(usedNameResolver) {
+      @Override
+      public String getServiceAuthority() {
+        return overrideAuthority;
+      }
+    };
+  }
+
+  @VisibleForTesting
+  InternalConfigSelector getConfigSelector() {
+    return realChannel.configSelector.get();
+  }
+  
+  @VisibleForTesting
+  boolean hasThrottle() {
+    return this.transportProvider.throttle != null;
   }
 
   /**
@@ -484,50 +707,28 @@ static NameResolver getNameResolver(String target, NameResolver.Factory nameReso
    */
   @Override
   public ManagedChannelImpl shutdown() {
-    log.log(Level.FINE, "[{0}] shutdown() called", getLogId());
-    ArrayList<TransportSet> transportsCopy = new ArrayList<TransportSet>();
-    ArrayList<DelayedClientTransport> delayedTransportsCopy =
-        new ArrayList<DelayedClientTransport>();
-    ArrayList<OobTransportProviderImpl> oobTransportsCopy =
-        new ArrayList<OobTransportProviderImpl>();
-    LoadBalancer<ClientTransport> balancer;
-    NameResolver resolver;
-    synchronized (lock) {
-      if (shutdown) {
-        return this;
-      }
-      log.log(Level.FINE, "[{0}] Shutting down", getLogId());
-      shutdown = true;
-      // After shutdown there are no new calls, so no new cancellation tasks are needed
-      scheduledExecutor = SharedResourceHolder.release(timerService, scheduledExecutor);
-      maybeTerminateChannel();
-      if (!terminated) {
-        transportsCopy.addAll(transports.values());
-        transports.clear();
-        decommissionedTransports.addAll(transportsCopy);
-        delayedTransportsCopy.addAll(delayedTransports);
-        oobTransportsCopy.addAll(oobTransports);
-      }
-      balancer = getCurrentLoadBalancer();
-      resolver = nameResolver;
-      cancelIdleTimer();
+    channelLogger.log(ChannelLogLevel.DEBUG, "shutdown() called");
+    if (!shutdown.compareAndSet(false, true)) {
+      return this;
     }
-    if (balancer != null) {
-      balancer.shutdown();
-    }
-    resolver.shutdown();
-    for (TransportSet ts : transportsCopy) {
-      ts.shutdown();
-    }
-    for (DelayedClientTransport transport : delayedTransportsCopy) {
-      transport.shutdown();
-    }
-    for (OobTransportProviderImpl provider : oobTransportsCopy) {
-      provider.close();
+    final class Shutdown implements Runnable {
+      @Override
+      public void run() {
+        channelLogger.log(ChannelLogLevel.INFO, "Entering SHUTDOWN state");
+        channelStateManager.gotoState(SHUTDOWN);
+      }
     }
-    if (log.isLoggable(Level.FINE)) {
-      log.log(Level.FINE, "[{0}] Shutting down", getLogId());
+
+    syncContext.execute(new Shutdown());
+    realChannel.shutdown();
+    final class CancelIdleTimer implements Runnable {
+      @Override
+      public void run() {
+        cancelIdleTimer(/* permanent= */ true);
+      }
     }
+
+    syncContext.execute(new CancelIdleTimer());
     return this;
   }
 
@@ -538,65 +739,67 @@ public ManagedChannelImpl shutdown() {
    */
   @Override
   public ManagedChannelImpl shutdownNow() {
-    log.log(Level.FINE, "[{0}] shutdownNow() called", getLogId());
-    synchronized (lock) {
-      // Short-circuiting not strictly necessary, but prevents transports from needing to handle
-      // multiple shutdownNow invocations.
-      if (shutdownNowed) {
-        return this;
-      }
-      shutdownNowed = true;
-    }
+    channelLogger.log(ChannelLogLevel.DEBUG, "shutdownNow() called");
     shutdown();
-    List<TransportSet> transportsCopy;
-    List<DelayedClientTransport> delayedTransportsCopy;
-    List<OobTransportProviderImpl> oobTransportsCopy;
-    synchronized (lock) {
-      transportsCopy = new ArrayList<TransportSet>(transports.values());
-      transportsCopy.addAll(decommissionedTransports);
-      delayedTransportsCopy = new ArrayList<DelayedClientTransport>(delayedTransports);
-      oobTransportsCopy = new ArrayList<OobTransportProviderImpl>(oobTransports);
-    }
-    if (log.isLoggable(Level.FINE)) {
-      log.log(Level.FINE, "[{0}] Shutting down now", getLogId());
-    }
-    Status nowStatus = Status.UNAVAILABLE.withDescription("Channel shutdownNow invoked");
-    for (TransportSet ts : transportsCopy) {
-      ts.shutdownNow(nowStatus);
+    realChannel.shutdownNow();
+    final class ShutdownNow implements Runnable {
+      @Override
+      public void run() {
+        if (shutdownNowed) {
+          return;
+        }
+        shutdownNowed = true;
+        maybeShutdownNowSubchannels();
+      }
     }
-    for (DelayedClientTransport transport : delayedTransportsCopy) {
-      transport.shutdownNow(nowStatus);
+
+    syncContext.execute(new ShutdownNow());
+    return this;
+  }
+
+  // Called from syncContext
+  @VisibleForTesting
+  void panic(final Throwable t) {
+    if (panicMode) {
+      // Preserve the first panic information
+      return;
     }
-    for (OobTransportProviderImpl provider : oobTransportsCopy) {
-      provider.shutdownNow(nowStatus);
+    panicMode = true;
+    try {
+      cancelIdleTimer(/* permanent= */ true);
+      shutdownNameResolverAndLoadBalancer(false);
+    } finally {
+      updateSubchannelPicker(new LoadBalancer.FixedResultPicker(PickResult.withDrop(
+          Status.INTERNAL.withDescription("Panic! This is a bug!").withCause(t))));
+      realChannel.updateConfigSelector(null);
+      channelLogger.log(ChannelLogLevel.ERROR, "PANIC! Entering TRANSIENT_FAILURE");
+      channelStateManager.gotoState(TRANSIENT_FAILURE);
     }
-    return this;
+  }
+
+  @VisibleForTesting
+  boolean isInPanicMode() {
+    return panicMode;
+  }
+
+  // Called from syncContext
+  private void updateSubchannelPicker(SubchannelPicker newPicker) {
+    delayedTransport.reprocess(newPicker);
   }
 
   @Override
   public boolean isShutdown() {
-    synchronized (lock) {
-      return shutdown;
-    }
+    return shutdown.get();
   }
 
   @Override
   public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
-    synchronized (lock) {
-      long timeoutNanos = unit.toNanos(timeout);
-      long endTimeNanos = System.nanoTime() + timeoutNanos;
-      while (!terminated && (timeoutNanos = endTimeNanos - System.nanoTime()) > 0) {
-        TimeUnit.NANOSECONDS.timedWait(lock, timeoutNanos);
-      }
-      return terminated;
-    }
+    return terminatedLatch.await(timeout, unit);
   }
 
   @Override
   public boolean isTerminated() {
-    synchronized (lock) {
-      return terminated;
-    }
+    return terminated;
   }
 
   /*
@@ -613,302 +816,1382 @@ public String authority() {
     return interceptorChannel.authority();
   }
 
-  /** Returns {@code null} iff channel is in idle state. */
-  @GuardedBy("lock")
-  private LoadBalancer<ClientTransport> getCurrentLoadBalancer() {
-    if (loadBalancer != null) {
-      return loadBalancer;
+  private Executor getCallExecutor(CallOptions callOptions) {
+    Executor executor = callOptions.getExecutor();
+    if (executor == null) {
+      executor = this.executor;
     }
-    return graceLoadBalancer;
+    return executor;
   }
 
   private class RealChannel extends Channel {
-    @Override
-    public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(MethodDescriptor<ReqT, RespT> method,
-        CallOptions callOptions) {
-      Executor executor = callOptions.getExecutor();
-      if (executor == null) {
-        executor = ManagedChannelImpl.this.executor;
+    // Reference to null if no config selector is available from resolution result
+    // Reference must be set() from syncContext
+    private final AtomicReference<InternalConfigSelector> configSelector =
+        new AtomicReference<>(INITIAL_PENDING_SELECTOR);
+    // Set when the NameResolver is initially created. When we create a new NameResolver for the
+    // same target, the new instance must have the same value.
+    private final String authority;
+
+    private final Channel clientCallImplChannel = new Channel() {
+      @Override
+      public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+          MethodDescriptor<RequestT, ResponseT> method, CallOptions callOptions) {
+        return new ClientCallImpl<>(
+            method,
+            getCallExecutor(callOptions),
+            callOptions,
+            transportProvider,
+            terminated ? null : transportFactory.getScheduledExecutorService(),
+            channelCallTracer,
+            null)
+            .setFullStreamDecompression(fullStreamDecompression)
+            .setDecompressorRegistry(decompressorRegistry)
+            .setCompressorRegistry(compressorRegistry);
       }
-      StatsTraceContext statsTraceCtx = StatsTraceContext.newClientContext(
-          method.getFullMethodName(), statsFactory, stopwatchSupplier);
-      return new ClientCallImpl<ReqT, RespT>(
-          method,
-          executor,
-          callOptions,
-          statsTraceCtx,
-          transportProvider,
-          scheduledExecutor)
-              .setDecompressorRegistry(decompressorRegistry)
-              .setCompressorRegistry(compressorRegistry);
-    }
 
-    @Override
-    public String authority() {
-      String authority = nameResolver.getServiceAuthority();
-      return checkNotNull(authority, "authority");
-    }
-  }
-
-  /**
-   * Terminate the channel if termination conditions are met.
-   */
-  @GuardedBy("lock")
-  private void maybeTerminateChannel() {
-    if (terminated) {
-      return;
-    }
-    if (shutdown && transports.isEmpty() && decommissionedTransports.isEmpty()
-        && delayedTransports.isEmpty() && oobTransports.isEmpty()) {
-      if (log.isLoggable(Level.INFO)) {
-        log.log(Level.INFO, "[{0}] Terminated", getLogId());
-      }
-      terminated = true;
-      lock.notifyAll();
-      if (usingSharedExecutor) {
-        SharedResourceHolder.release(GrpcUtil.SHARED_CHANNEL_EXECUTOR, (ExecutorService) executor);
+      @Override
+      public String authority() {
+        return authority;
       }
-      // Release the transport factory so that it can deallocate any resources.
-      transportFactory.close();
-    }
-  }
+    };
 
-  @VisibleForTesting
-  final TransportManager<ClientTransport> tm = new TransportManager<ClientTransport>() {
-    @Override
-    public void updateRetainedTransports(Collection<EquivalentAddressGroup> addrs) {
-      // TODO(zhangkun83): warm-up new servers and discard removed servers.
+    private RealChannel(String authority) {
+      this.authority =  checkNotNull(authority, "authority");
     }
 
     @Override
-    public ClientTransport getTransport(final EquivalentAddressGroup addressGroup) {
-      checkNotNull(addressGroup, "addressGroup");
-      TransportSet ts = transports.get(addressGroup);
-      if (ts != null) {
-        return ts.obtainActiveTransport();
+    public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions) {
+      if (configSelector.get() != INITIAL_PENDING_SELECTOR) {
+        return newClientCall(method, callOptions);
       }
-      synchronized (lock) {
-        if (shutdown) {
-          return SHUTDOWN_TRANSPORT;
-        }
-        if (getCurrentLoadBalancer() == null) {
-          return IDLE_MODE_TRANSPORT;
+      syncContext.execute(new Runnable() {
+        @Override
+        public void run() {
+          exitIdleMode();
         }
-        ts = transports.get(addressGroup);
-        if (ts == null) {
-          ts = new TransportSet(addressGroup, authority(), userAgent, getCurrentLoadBalancer(),
-              backoffPolicyProvider, transportFactory, scheduledExecutor, stopwatchSupplier,
-              executor, new TransportSet.Callback() {
-                @Override
-                public void onTerminated(TransportSet ts) {
-                  synchronized (lock) {
-                    transports.remove(addressGroup);
-                    decommissionedTransports.remove(ts);
-                    maybeTerminateChannel();
-                  }
-                }
+      });
+      if (configSelector.get() != INITIAL_PENDING_SELECTOR) {
+        // This is an optimization for the case (typically with InProcessTransport) when name
+        // resolution result is immediately available at this point. Otherwise, some users'
+        // tests might observe slight behavior difference from earlier grpc versions.
+        return newClientCall(method, callOptions);
+      }
+      if (shutdown.get()) {
+        // Return a failing ClientCall.
+        return new ClientCall<ReqT, RespT>() {
+          @Override
+          public void start(Listener<RespT> responseListener, Metadata headers) {
+            responseListener.onClose(SHUTDOWN_STATUS, new Metadata());
+          }
 
-                @Override
-                public void onAllAddressesFailed() {
-                  nameResolver.refresh();
-                }
+          @Override public void request(int numMessages) {}
 
-                @Override
-                public void onConnectionClosedByServer(Status status) {
-                  nameResolver.refresh();
-                }
+          @Override public void cancel(@Nullable String message, @Nullable Throwable cause) {}
 
-                @Override
-                public Runnable onInUse(TransportSet ts) {
-                  return inUseStateAggregator.updateObjectInUse(ts, true);
-                }
+          @Override public void halfClose() {}
 
-                @Override
-                public void onNotInUse(TransportSet ts) {
-                  Runnable r = inUseStateAggregator.updateObjectInUse(ts, false);
-                  assert r == null;
-                }
-              });
-          if (log.isLoggable(Level.FINE)) {
-            log.log(Level.FINE, "[{0}] {1} created for {2}",
-                new Object[] {getLogId(), ts.getLogId(), addressGroup});
+          @Override public void sendMessage(ReqT message) {}
+        };
+      }
+      Context context = Context.current();
+      final PendingCall<ReqT, RespT> pendingCall = new PendingCall<>(context, method, callOptions);
+      syncContext.execute(new Runnable() {
+        @Override
+        public void run() {
+          if (configSelector.get() == INITIAL_PENDING_SELECTOR) {
+            if (pendingCalls == null) {
+              pendingCalls = new LinkedHashSet<>();
+              inUseStateAggregator.updateObjectInUse(pendingCallsInUseObject, true);
+            }
+            pendingCalls.add(pendingCall);
+          } else {
+            pendingCall.reprocess();
           }
-          transports.put(addressGroup, ts);
+        }
+      });
+      return pendingCall;
+    }
+
+    // Must run in SynchronizationContext.
+    void updateConfigSelector(@Nullable InternalConfigSelector config) {
+      InternalConfigSelector prevConfig = configSelector.get();
+      configSelector.set(config);
+      if (prevConfig == INITIAL_PENDING_SELECTOR && pendingCalls != null) {
+        for (RealChannel.PendingCall<?, ?> pendingCall : pendingCalls) {
+          pendingCall.reprocess();
         }
       }
-      return ts.obtainActiveTransport();
     }
 
-    @Override
-    public Channel makeChannel(ClientTransport transport) {
-      return new SingleTransportChannel(
-          statsFactory, transport, executor, scheduledExecutor, authority(), stopwatchSupplier);
+    // Must run in SynchronizationContext.
+    void onConfigError() {
+      if (configSelector.get() == INITIAL_PENDING_SELECTOR) {
+        // Apply Default Service Config if initial name resolution fails.
+        if (defaultServiceConfig != null) {
+          updateConfigSelector(defaultServiceConfig.getDefaultConfigSelector());
+          lastServiceConfig = defaultServiceConfig;
+          channelLogger.log(ChannelLogLevel.ERROR,
+              "Initial Name Resolution error, using default service config");
+        } else {
+          updateConfigSelector(null);
+        }
+      }
     }
 
-    @Override
-    public ClientTransport createFailingTransport(Status error) {
-      return new FailingClientTransport(error);
+    void shutdown() {
+      final class RealChannelShutdown implements Runnable {
+        @Override
+        public void run() {
+          if (pendingCalls == null) {
+            if (configSelector.get() == INITIAL_PENDING_SELECTOR) {
+              configSelector.set(null);
+            }
+            uncommittedRetriableStreamsRegistry.onShutdown(SHUTDOWN_STATUS);
+          }
+        }
+      }
+
+      syncContext.execute(new RealChannelShutdown());
     }
 
-    @Override
-    public InterimTransport<ClientTransport> createInterimTransport() {
-      return new InterimTransportImpl();
+    void shutdownNow() {
+      final class RealChannelShutdownNow implements Runnable {
+        @Override
+        public void run() {
+          if (configSelector.get() == INITIAL_PENDING_SELECTOR) {
+            configSelector.set(null);
+          }
+          if (pendingCalls != null) {
+            for (RealChannel.PendingCall<?, ?> pendingCall : pendingCalls) {
+              pendingCall.cancel("Channel is forcefully shutdown", null);
+            }
+          }
+          uncommittedRetriableStreamsRegistry.onShutdownNow(SHUTDOWN_NOW_STATUS);
+        }
+      }
+
+      syncContext.execute(new RealChannelShutdownNow());
     }
 
     @Override
-    public OobTransportProvider<ClientTransport> createOobTransportProvider(
-        EquivalentAddressGroup addressGroup, String authority) {
-      return new OobTransportProviderImpl(addressGroup, authority);
+    public String authority() {
+      return authority;
     }
-  };
 
-  @Override
-  public LogId getLogId() {
-    return logId;
+    private final class PendingCall<ReqT, RespT> extends DelayedClientCall<ReqT, RespT> {
+      final Context context;
+      final MethodDescriptor<ReqT, RespT> method;
+      final CallOptions callOptions;
+      private final long callCreationTime;
+
+      PendingCall(
+          Context context, MethodDescriptor<ReqT, RespT> method, CallOptions callOptions) {
+        super(getCallExecutor(callOptions), scheduledExecutor, callOptions.getDeadline());
+        this.context = context;
+        this.method = method;
+        this.callOptions = callOptions;
+        this.callCreationTime = ticker.nanoTime();
+      }
+
+      /** Called when it's ready to create a real call and reprocess the pending call. */
+      void reprocess() {
+        ClientCall<ReqT, RespT> realCall;
+        Context previous = context.attach();
+        try {
+          CallOptions delayResolutionOption = callOptions.withOption(NAME_RESOLUTION_DELAYED,
+              ticker.nanoTime() - callCreationTime);
+          realCall = newClientCall(method, delayResolutionOption);
+        } finally {
+          context.detach(previous);
+        }
+        Runnable toRun = setCall(realCall);
+        if (toRun == null) {
+          syncContext.execute(new PendingCallRemoval());
+        } else {
+          getCallExecutor(callOptions).execute(new Runnable() {
+            @Override
+            public void run() {
+              toRun.run();
+              syncContext.execute(new PendingCallRemoval());
+            }
+          });
+        }
+      }
+
+      @Override
+      protected void callCancelled() {
+        super.callCancelled();
+        syncContext.execute(new PendingCallRemoval());
+      }
+
+      final class PendingCallRemoval implements Runnable {
+        @Override
+        public void run() {
+          if (pendingCalls != null) {
+            pendingCalls.remove(PendingCall.this);
+            if (pendingCalls.isEmpty()) {
+              inUseStateAggregator.updateObjectInUse(pendingCallsInUseObject, false);
+              pendingCalls = null;
+              if (shutdown.get()) {
+                uncommittedRetriableStreamsRegistry.onShutdown(SHUTDOWN_STATUS);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    private <ReqT, RespT> ClientCall<ReqT, RespT> newClientCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions) {
+      InternalConfigSelector selector = configSelector.get();
+      if (selector == null) {
+        return clientCallImplChannel.newCall(method, callOptions);
+      }
+      if (selector instanceof ServiceConfigConvertedSelector) {
+        MethodInfo methodInfo =
+            ((ServiceConfigConvertedSelector) selector).config.getMethodConfig(method);
+        if (methodInfo != null) {
+          callOptions = callOptions.withOption(MethodInfo.KEY, methodInfo);
+        }
+        return clientCallImplChannel.newCall(method, callOptions);
+      }
+      return new ConfigSelectingClientCall<>(
+          selector, clientCallImplChannel, executor, method, callOptions);
+    }
   }
 
-  private class NameResolverListenerImpl implements NameResolver.Listener {
-    final LoadBalancer<ClientTransport> balancer;
+  /**
+   * A client call for a given channel that applies a given config selector when it starts.
+   */
+  static final class ConfigSelectingClientCall<ReqT, RespT>
+      extends ForwardingClientCall<ReqT, RespT> {
+
+    private final InternalConfigSelector configSelector;
+    private final Channel channel;
+    private final Executor callExecutor;
+    private final MethodDescriptor<ReqT, RespT> method;
+    private final Context context;
+    private CallOptions callOptions;
+
+    private ClientCall<ReqT, RespT> delegate;
 
-    NameResolverListenerImpl(LoadBalancer<ClientTransport> balancer) {
-      this.balancer = balancer;
+    ConfigSelectingClientCall(
+        InternalConfigSelector configSelector, Channel channel, Executor channelExecutor,
+        MethodDescriptor<ReqT, RespT> method,
+        CallOptions callOptions) {
+      this.configSelector = configSelector;
+      this.channel = channel;
+      this.method = method;
+      this.callExecutor =
+          callOptions.getExecutor() == null ? channelExecutor : callOptions.getExecutor();
+      this.callOptions = callOptions.withExecutor(callExecutor);
+      this.context = Context.current();
+    }
+
+    @Override
+    protected ClientCall<ReqT, RespT> delegate() {
+      return delegate;
     }
 
+    @SuppressWarnings("unchecked")
     @Override
-    public void onUpdate(List<ResolvedServerInfoGroup> servers, Attributes config) {
-      if (servers.isEmpty()) {
-        onError(Status.UNAVAILABLE.withDescription("NameResolver returned an empty list"));
+    public void start(Listener<RespT> observer, Metadata headers) {
+      PickSubchannelArgs args =
+          new PickSubchannelArgsImpl(method, headers, callOptions, NOOP_PICK_DETAILS_CONSUMER);
+      InternalConfigSelector.Result result = configSelector.selectConfig(args);
+      Status status = result.getStatus();
+      if (!status.isOk()) {
+        executeCloseObserverInContext(observer,
+            GrpcUtil.replaceInappropriateControlPlaneStatus(status));
+        delegate = (ClientCall<ReqT, RespT>) NOOP_CALL;
         return;
       }
-      log.log(Level.FINE, "[{0}] resolved address: {1}, config={2}",
-          new Object[] {getLogId(), servers, config});
+      ClientInterceptor interceptor = result.getInterceptor();
+      ManagedChannelServiceConfig config = (ManagedChannelServiceConfig) result.getConfig();
+      MethodInfo methodInfo = config.getMethodConfig(method);
+      if (methodInfo != null) {
+        callOptions = callOptions.withOption(MethodInfo.KEY, methodInfo);
+      }
+      if (interceptor != null) {
+        delegate = interceptor.interceptCall(method, callOptions, channel);
+      } else {
+        delegate = channel.newCall(method, callOptions);
+      }
+      delegate.start(observer, headers);
+    }
 
-      try {
-        balancer.handleResolvedAddresses(servers, config);
-      } catch (Throwable e) {
-        log.log(Level.WARNING, "[" + getLogId() + "] Unexpected exception from LoadBalancer", e);
-        // It must be a bug! Push the exception back to LoadBalancer in the hope that it may be
-        // propagated to the application.
-        balancer.handleNameResolutionError(Status.INTERNAL.withCause(e)
-            .withDescription("Thrown from handleResolvedAddresses(): " + e));
+    private void executeCloseObserverInContext(
+        final Listener<RespT> observer, final Status status) {
+      class CloseInContext extends ContextRunnable {
+        CloseInContext() {
+          super(context);
+        }
+
+        @Override
+        public void runInContext() {
+          observer.onClose(status, new Metadata());
+        }
       }
+
+      callExecutor.execute(new CloseInContext());
     }
 
     @Override
-    public void onError(Status error) {
-      checkArgument(!error.isOk(), "the error status must not be OK");
-      log.log(Level.WARNING, "[{0}] Failed to resolve name. status={1}",
-          new Object[] {getLogId(), error});
-      balancer.handleNameResolutionError(error);
+    public void cancel(@Nullable String message, @Nullable Throwable cause) {
+      if (delegate != null) {
+        delegate.cancel(message, cause);
+      }
     }
   }
 
-  private class InterimTransportImpl implements InterimTransport<ClientTransport> {
-    private final DelayedClientTransport delayedTransport;
-    private boolean closed;
+  private static final ClientCall<Object, Object> NOOP_CALL = new ClientCall<Object, Object>() {
+    @Override
+    public void start(Listener<Object> responseListener, Metadata headers) {}
 
-    InterimTransportImpl() {
-      delayedTransport = new DelayedClientTransport(executor);
-      delayedTransport.start(new ManagedClientTransport.Listener() {
-          @Override public void transportShutdown(Status status) {}
+    @Override
+    public void request(int numMessages) {}
 
-          @Override public void transportTerminated() {
-            synchronized (lock) {
-              delayedTransports.remove(delayedTransport);
-              maybeTerminateChannel();
-            }
-            Runnable r = inUseStateAggregator.updateObjectInUse(delayedTransport, false);
-            assert r == null;
+    @Override
+    public void cancel(String message, Throwable cause) {}
+
+    @Override
+    public void halfClose() {}
+
+    @Override
+    public void sendMessage(Object message) {}
+
+    // Always returns {@code false}, since this is only used when the startup of the call fails.
+    @Override
+    public boolean isReady() {
+      return false;
+    }
+  };
+
+  /**
+   * Terminate the channel if termination conditions are met.
+   */
+  // Must be run from syncContext
+  private void maybeTerminateChannel() {
+    if (terminated) {
+      return;
+    }
+    if (shutdown.get() && subchannels.isEmpty()) {
+      channelLogger.log(ChannelLogLevel.INFO, "Terminated");
+      channelz.removeRootChannel(this);
+      executorPool.returnObject(executor);
+      balancerRpcExecutorHolder.release();
+      offloadExecutorHolder.release();
+      // Release the transport factory so that it can deallocate any resources.
+      transportFactory.close();
+
+      terminated = true;
+      terminatedLatch.countDown();
+    }
+  }
+
+  @Override
+  public ConnectivityState getState(boolean requestConnection) {
+    ConnectivityState savedChannelState = channelStateManager.getState();
+    if (requestConnection && savedChannelState == IDLE) {
+      final class RequestConnection implements Runnable {
+        @Override
+        public void run() {
+          exitIdleMode();
+          if (lbHelper != null) {
+            lbHelper.lb.requestConnection();
           }
+        }
+      }
+
+      syncContext.execute(new RequestConnection());
+    }
+    return savedChannelState;
+  }
+
+  @Override
+  public void notifyWhenStateChanged(final ConnectivityState source, final Runnable callback) {
+    final class NotifyStateChanged implements Runnable {
+      @Override
+      public void run() {
+        channelStateManager.notifyWhenStateChanged(callback, executor, source);
+      }
+    }
+
+    syncContext.execute(new NotifyStateChanged());
+  }
+
+  @Override
+  public void resetConnectBackoff() {
+    final class ResetConnectBackoff implements Runnable {
+      @Override
+      public void run() {
+        if (shutdown.get()) {
+          return;
+        }
+        if (nameResolverStarted) {
+          refreshNameResolution();
+        }
+        for (InternalSubchannel subchannel : subchannels) {
+          subchannel.resetConnectBackoff();
+        }
+      }
+    }
+
+    syncContext.execute(new ResetConnectBackoff());
+  }
+
+  @Override
+  public void enterIdle() {
+    final class PrepareToLoseNetworkRunnable implements Runnable {
+      @Override
+      public void run() {
+        if (shutdown.get() || lbHelper == null) {
+          return;
+        }
+        cancelIdleTimer(/* permanent= */ false);
+        enterIdleMode();
+      }
+    }
+
+    syncContext.execute(new PrepareToLoseNetworkRunnable());
+  }
 
-          @Override public void transportReady() {}
+  /**
+   * A registry that prevents channel shutdown from killing existing retry attempts that are in
+   * backoff.
+   */
+  private final class UncommittedRetriableStreamsRegistry {
+    // TODO(zdapeng): This means we would acquire a lock for each new retry-able stream,
+    // it's worthwhile to look for a lock-free approach.
+    final Object lock = new Object();
+
+    @GuardedBy("lock")
+    Collection<ClientStream> uncommittedRetriableStreams = new HashSet<>();
+
+    @GuardedBy("lock")
+    Status shutdownStatus;
+
+    void onShutdown(Status reason) {
+      boolean shouldShutdownDelayedTransport = false;
+      synchronized (lock) {
+        if (shutdownStatus != null) {
+          return;
+        }
+        shutdownStatus = reason;
+        // Keep the delayedTransport open until there is no more uncommitted streams, b/c those
+        // retriable streams, which may be in backoff and not using any transport, are already
+        // started RPCs.
+        if (uncommittedRetriableStreams.isEmpty()) {
+          shouldShutdownDelayedTransport = true;
+        }
+      }
+
+      if (shouldShutdownDelayedTransport) {
+        delayedTransport.shutdown(reason);
+      }
+    }
+
+    void onShutdownNow(Status reason) {
+      onShutdown(reason);
+      Collection<ClientStream> streams;
+
+      synchronized (lock) {
+        streams = new ArrayList<>(uncommittedRetriableStreams);
+      }
+
+      for (ClientStream stream : streams) {
+        stream.cancel(reason);
+      }
+      delayedTransport.shutdownNow(reason);
+    }
+
+    /**
+     * Registers a RetriableStream and return null if not shutdown, otherwise just returns the
+     * shutdown Status.
+     */
+    @Nullable
+    Status add(RetriableStream<?> retriableStream) {
+      synchronized (lock) {
+        if (shutdownStatus != null) {
+          return shutdownStatus;
+        }
+        uncommittedRetriableStreams.add(retriableStream);
+        return null;
+      }
+    }
+
+    void remove(RetriableStream<?> retriableStream) {
+      Status shutdownStatusCopy = null;
 
-          @Override public void transportInUse(boolean inUse) {
-            Runnable r = inUseStateAggregator.updateObjectInUse(delayedTransport, inUse);
-            if (r != null) {
-              r.run();
+      synchronized (lock) {
+        uncommittedRetriableStreams.remove(retriableStream);
+        if (uncommittedRetriableStreams.isEmpty()) {
+          shutdownStatusCopy = shutdownStatus;
+          // Because retriable transport is long-lived, we take this opportunity to down-size the
+          // hashmap.
+          uncommittedRetriableStreams = new HashSet<>();
+        }
+      }
+
+      if (shutdownStatusCopy != null) {
+        delayedTransport.shutdown(shutdownStatusCopy);
+      }
+    }
+  }
+
+  private final class LbHelperImpl extends LoadBalancer.Helper {
+    LoadBalancer lb;
+
+    @Override
+    public AbstractSubchannel createSubchannel(CreateSubchannelArgs args) {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      // No new subchannel should be created after load balancer has been shutdown.
+      checkState(!terminating, "Channel is being terminated");
+      return new SubchannelImpl(args);
+    }
+
+    @Override
+    public void updateBalancingState(
+        final ConnectivityState newState, final SubchannelPicker newPicker) {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      checkNotNull(newState, "newState");
+      checkNotNull(newPicker, "newPicker");
+
+      if (LbHelperImpl.this != lbHelper || panicMode) {
+        return;
+      }
+      updateSubchannelPicker(newPicker);
+      // It's not appropriate to report SHUTDOWN state from lb.
+      // Ignore the case of newState == SHUTDOWN for now.
+      if (newState != SHUTDOWN) {
+        channelLogger.log(
+            ChannelLogLevel.INFO, "Entering {0} state with picker: {1}", newState, newPicker);
+        channelStateManager.gotoState(newState);
+      }
+    }
+
+    @Override
+    public void refreshNameResolution() {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      final class LoadBalancerRefreshNameResolution implements Runnable {
+        @Override
+        public void run() {
+          ManagedChannelImpl.this.refreshNameResolution();
+        }
+      }
+
+      syncContext.execute(new LoadBalancerRefreshNameResolution());
+    }
+
+    @Override
+    public ManagedChannel createOobChannel(EquivalentAddressGroup addressGroup, String authority) {
+      return createOobChannel(Collections.singletonList(addressGroup), authority);
+    }
+
+    @Override
+    public ManagedChannel createOobChannel(List<EquivalentAddressGroup> addressGroup,
+        String authority) {
+      NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
+      OobNameResolverProvider resolverProvider =
+          new OobNameResolverProvider(authority, addressGroup, syncContext);
+      nameResolverRegistry.register(resolverProvider);
+      // We could use a hard-coded target, as the name resolver won't actually use this string.
+      // However, that would make debugging less clear, as we use the target to identify the
+      // channel.
+      String target;
+      try {
+        target = new URI("oob", "", "/" + authority, null, null).toString();
+      } catch (URISyntaxException ex) {
+        // Any special characters in the path will be percent encoded. So this should be impossible.
+        throw new AssertionError(ex);
+      }
+      ManagedChannel delegate = createResolvingOobChannelBuilder(
+          target, new DefaultChannelCreds(), nameResolverRegistry)
+          // TODO(zdapeng): executors should not outlive the parent channel.
+          .executor(balancerRpcExecutorHolder.getExecutor())
+          .idleTimeout(Integer.MAX_VALUE, TimeUnit.SECONDS)
+          .disableRetry()
+          .build();
+      return new OobChannel(delegate, resolverProvider);
+    }
+
+    @Deprecated
+    @Override
+    public ManagedChannelBuilder<?> createResolvingOobChannelBuilder(String target) {
+      return createResolvingOobChannelBuilder(target, new DefaultChannelCreds())
+          // Override authority to keep the old behavior.
+          // createResolvingOobChannelBuilder(String target) will be deleted soon.
+          .overrideAuthority(getAuthority());
+    }
+
+    @Override
+    public ManagedChannelBuilder<?> createResolvingOobChannelBuilder(
+        final String target, final ChannelCredentials channelCreds) {
+      return createResolvingOobChannelBuilder(target, channelCreds, nameResolverRegistry);
+    }
+
+    // TODO(creamsoup) prevent main channel to shutdown if oob channel is not terminated
+    // TODO(zdapeng) register the channel as a subchannel of the parent channel in channelz.
+    private ManagedChannelBuilder<?> createResolvingOobChannelBuilder(
+        final String target, final ChannelCredentials channelCreds,
+        NameResolverRegistry nameResolverRegistry) {
+      checkNotNull(channelCreds, "channelCreds");
+
+      final class ResolvingOobChannelBuilder
+          extends ForwardingChannelBuilder2<ResolvingOobChannelBuilder> {
+        final ManagedChannelBuilder<?> delegate;
+
+        ResolvingOobChannelBuilder() {
+          final ClientTransportFactory transportFactory;
+          CallCredentials callCredentials;
+          if (channelCreds instanceof DefaultChannelCreds) {
+            transportFactory = originalTransportFactory;
+            callCredentials = null;
+          } else {
+            SwapChannelCredentialsResult swapResult =
+                originalTransportFactory.swapChannelCredentials(channelCreds);
+            if (swapResult == null) {
+              delegate = Grpc.newChannelBuilder(target, channelCreds);
+              return;
+            } else {
+              transportFactory = swapResult.transportFactory;
+              callCredentials = swapResult.callCredentials;
             }
           }
-        });
-      boolean savedShutdown;
-      synchronized (lock) {
-        delayedTransports.add(delayedTransport);
-        savedShutdown = shutdown;
+          ClientTransportFactoryBuilder transportFactoryBuilder =
+              new ClientTransportFactoryBuilder() {
+                @Override
+                public ClientTransportFactory buildClientTransportFactory() {
+                  return transportFactory;
+                }
+              };
+          delegate = new ManagedChannelImplBuilder(
+              target,
+              channelCreds,
+              callCredentials,
+              transportFactoryBuilder,
+              new FixedPortProvider(nameResolverArgs.getDefaultPort()))
+              .nameResolverRegistry(nameResolverRegistry);
+        }
+
+        @Override
+        protected ManagedChannelBuilder<?> delegate() {
+          return delegate;
+        }
       }
-      if (savedShutdown) {
-        delayedTransport.setTransport(SHUTDOWN_TRANSPORT);
-        delayedTransport.shutdown();
+
+      checkState(!terminated, "Channel is terminated");
+
+      ResolvingOobChannelBuilder builder = new ResolvingOobChannelBuilder();
+
+      return builder
+          // TODO(zdapeng): executors should not outlive the parent channel.
+          .executor(executor)
+          .offloadExecutor(offloadExecutorHolder.getExecutor())
+          .maxTraceEvents(maxTraceEvents)
+          .proxyDetector(nameResolverArgs.getProxyDetector())
+          .userAgent(userAgent);
+    }
+
+    @Override
+    public ChannelCredentials getUnsafeChannelCredentials() {
+      if (originalChannelCreds == null) {
+        return new DefaultChannelCreds();
       }
+      return originalChannelCreds;
+    }
+
+    @Override
+    public void updateOobChannelAddresses(ManagedChannel channel, EquivalentAddressGroup eag) {
+      updateOobChannelAddresses(channel, Collections.singletonList(eag));
+    }
+
+    @Override
+    public void updateOobChannelAddresses(ManagedChannel channel,
+        List<EquivalentAddressGroup> eag) {
+      checkArgument(channel instanceof OobChannel,
+          "channel must have been returned from createOobChannel");
+      ((OobChannel) channel).updateAddresses(eag);
+    }
+
+    @Override
+    public String getAuthority() {
+      return ManagedChannelImpl.this.authority();
+    }
+
+    @Override
+    public String getChannelTarget() {
+      return targetUri.toString();
+    }
+
+    @Override
+    public SynchronizationContext getSynchronizationContext() {
+      return syncContext;
     }
 
     @Override
-    public ClientTransport transport() {
-      checkState(!closed, "already closed");
-      return delayedTransport;
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return scheduledExecutor;
     }
 
     @Override
-    public void closeWithRealTransports(Supplier<ClientTransport> realTransports) {
-      delayedTransport.setTransportSupplier(realTransports);
-      delayedTransport.shutdown();
+    public ChannelLogger getChannelLogger() {
+      return channelLogger;
     }
 
     @Override
-    public void closeWithError(Status error) {
-      delayedTransport.shutdownNow(error);
+    public NameResolver.Args getNameResolverArgs() {
+      return nameResolverArgs;
+    }
+
+    @Override
+    public NameResolverRegistry getNameResolverRegistry() {
+      return nameResolverRegistry;
+    }
+
+    @Override
+    public MetricRecorder getMetricRecorder() {
+      return metricRecorder;
+    }
+
+    /**
+     * A placeholder for channel creds if user did not specify channel creds for the channel.
+     */
+    // TODO(zdapeng): get rid of this class and let all ChannelBuilders always provide a non-null
+    //     channel creds.
+    final class DefaultChannelCreds extends ChannelCredentials {
+      @Override
+      public ChannelCredentials withoutBearerTokens() {
+        return this;
+      }
     }
   }
 
-  private class OobTransportProviderImpl implements OobTransportProvider<ClientTransport> {
-    private final TransportSet transportSet;
-    private final ClientTransport transport;
+  static final class OobChannel extends ForwardingManagedChannel {
+    private final OobNameResolverProvider resolverProvider;
 
-    OobTransportProviderImpl(EquivalentAddressGroup addressGroup, String authority) {
-      synchronized (lock) {
-        if (shutdown) {
-          transportSet = null;
-          transport = SHUTDOWN_TRANSPORT;
-        } else if (getCurrentLoadBalancer() == null) {
-          transportSet = null;
-          transport = IDLE_MODE_TRANSPORT;
+    public OobChannel(ManagedChannel delegate, OobNameResolverProvider resolverProvider) {
+      super(delegate);
+      this.resolverProvider = checkNotNull(resolverProvider, "resolverProvider");
+    }
+
+    public void updateAddresses(List<EquivalentAddressGroup> eags) {
+      resolverProvider.updateAddresses(eags);
+    }
+  }
+
+  final class NameResolverListener extends NameResolver.Listener2 {
+    final LbHelperImpl helper;
+    final NameResolver resolver;
+
+    NameResolverListener(LbHelperImpl helperImpl, NameResolver resolver) {
+      this.helper = checkNotNull(helperImpl, "helperImpl");
+      this.resolver = checkNotNull(resolver, "resolver");
+    }
+
+    @Override
+    public void onResult(final ResolutionResult resolutionResult) {
+      syncContext.execute(() -> onResult2(resolutionResult));
+    }
+
+    @SuppressWarnings("ReferenceEquality")
+    @Override
+    public Status onResult2(final ResolutionResult resolutionResult) {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      if (ManagedChannelImpl.this.nameResolver != resolver) {
+        return Status.OK;
+      }
+
+      StatusOr<List<EquivalentAddressGroup>> serversOrError =
+          resolutionResult.getAddressesOrError();
+      if (!serversOrError.hasValue()) {
+        handleErrorInSyncContext(serversOrError.getStatus());
+        return serversOrError.getStatus();
+      }
+      List<EquivalentAddressGroup> servers = serversOrError.getValue();
+      channelLogger.log(
+          ChannelLogLevel.DEBUG,
+          "Resolved address: {0}, config={1}",
+          servers,
+          resolutionResult.getAttributes());
+
+      if (lastResolutionState != ResolutionState.SUCCESS) {
+        channelLogger.log(ChannelLogLevel.INFO, "Address resolved: {0}",
+            servers);
+        lastResolutionState = ResolutionState.SUCCESS;
+      }
+      ConfigOrError configOrError = resolutionResult.getServiceConfig();
+      InternalConfigSelector resolvedConfigSelector =
+          resolutionResult.getAttributes().get(InternalConfigSelector.KEY);
+      ManagedChannelServiceConfig validServiceConfig =
+          configOrError != null && configOrError.getConfig() != null
+              ? (ManagedChannelServiceConfig) configOrError.getConfig()
+              : null;
+      Status serviceConfigError = configOrError != null ? configOrError.getError() : null;
+
+      ManagedChannelServiceConfig effectiveServiceConfig;
+      if (!lookUpServiceConfig) {
+        if (validServiceConfig != null) {
+          channelLogger.log(
+              ChannelLogLevel.INFO,
+              "Service config from name resolver discarded by channel settings");
+        }
+        effectiveServiceConfig =
+            defaultServiceConfig == null ? EMPTY_SERVICE_CONFIG : defaultServiceConfig;
+        if (resolvedConfigSelector != null) {
+          channelLogger.log(
+              ChannelLogLevel.INFO,
+              "Config selector from name resolver discarded by channel settings");
+        }
+        realChannel.updateConfigSelector(effectiveServiceConfig.getDefaultConfigSelector());
+      } else {
+        // Try to use config if returned from name resolver
+        // Otherwise, try to use the default config if available
+        if (validServiceConfig != null) {
+          effectiveServiceConfig = validServiceConfig;
+          if (resolvedConfigSelector != null) {
+            realChannel.updateConfigSelector(resolvedConfigSelector);
+            if (effectiveServiceConfig.getDefaultConfigSelector() != null) {
+              channelLogger.log(
+                  ChannelLogLevel.DEBUG,
+                  "Method configs in service config will be discarded due to presence of"
+                      + "config-selector");
+            }
+          } else {
+            realChannel.updateConfigSelector(effectiveServiceConfig.getDefaultConfigSelector());
+          }
+        } else if (defaultServiceConfig != null) {
+          effectiveServiceConfig = defaultServiceConfig;
+          realChannel.updateConfigSelector(effectiveServiceConfig.getDefaultConfigSelector());
+          channelLogger.log(
+              ChannelLogLevel.INFO,
+              "Received no service config, using default service config");
+        } else if (serviceConfigError != null) {
+          if (!serviceConfigUpdated) {
+            // First DNS lookup has invalid service config, and cannot fall back to default
+            channelLogger.log(
+                ChannelLogLevel.INFO,
+                "Fallback to error due to invalid first service config without default config");
+            // This error could be an "inappropriate" control plane error that should not bleed
+            // through to client code using gRPC. We let them flow through here to the LB as
+            // we later check for these error codes when investigating pick results in
+            // GrpcUtil.getTransportFromPickResult().
+            onError(configOrError.getError());
+            return configOrError.getError();
+          } else {
+            effectiveServiceConfig = lastServiceConfig;
+          }
         } else {
-          transport = null;
-          transportSet = new TransportSet(addressGroup, authority, userAgent,
-              getCurrentLoadBalancer(), backoffPolicyProvider, transportFactory, scheduledExecutor,
-              stopwatchSupplier, executor, new TransportSet.Callback() {
-                @Override
-                public void onTerminated(TransportSet ts) {
-                  synchronized (lock) {
-                    oobTransports.remove(OobTransportProviderImpl.this);
-                    maybeTerminateChannel();
-                  }
-                }
-              });
-          oobTransports.add(this);
+          effectiveServiceConfig = EMPTY_SERVICE_CONFIG;
+          realChannel.updateConfigSelector(null);
+        }
+        if (!effectiveServiceConfig.equals(lastServiceConfig)) {
+          channelLogger.log(
+              ChannelLogLevel.INFO,
+              "Service config changed{0}",
+              effectiveServiceConfig == EMPTY_SERVICE_CONFIG ? " to empty" : "");
+          lastServiceConfig = effectiveServiceConfig;
+          transportProvider.throttle = effectiveServiceConfig.getRetryThrottling();
+        }
+
+        try {
+          // TODO(creamsoup): when `serversOrError` is empty and lastResolutionStateCopy == SUCCESS
+          //  and lbNeedAddress, it shouldn't call the handleServiceConfigUpdate. But,
+          //  lbNeedAddress is not deterministic
+          serviceConfigUpdated = true;
+        } catch (RuntimeException re) {
+          logger.log(
+              Level.WARNING,
+              "[" + getLogId() + "] Unexpected exception from parsing service config",
+              re);
         }
       }
+
+      Attributes effectiveAttrs = resolutionResult.getAttributes();
+      // Call LB only if it's not shutdown.  If LB is shutdown, lbHelper won't match.
+      if (NameResolverListener.this.helper == ManagedChannelImpl.this.lbHelper) {
+        Attributes.Builder attrBuilder =
+            effectiveAttrs.toBuilder().discard(InternalConfigSelector.KEY);
+        Map<String, ?> healthCheckingConfig =
+            effectiveServiceConfig.getHealthCheckingConfig();
+        if (healthCheckingConfig != null) {
+          attrBuilder
+              .set(LoadBalancer.ATTR_HEALTH_CHECKING_CONFIG, healthCheckingConfig)
+              .build();
+        }
+        Attributes attributes = attrBuilder.build();
+
+        ResolvedAddresses.Builder resolvedAddresses = ResolvedAddresses.newBuilder()
+            .setAddresses(serversOrError.getValue())
+            .setAttributes(attributes)
+            .setLoadBalancingPolicyConfig(effectiveServiceConfig.getLoadBalancingConfig());
+        Status addressAcceptanceStatus = helper.lb.acceptResolvedAddresses(
+            resolvedAddresses.build());
+        return addressAcceptanceStatus;
+      }
+      return Status.OK;
     }
 
     @Override
-    public ClientTransport get() {
-      if (transport != null) {
-        return transport;
+    public void onError(final Status error) {
+      checkArgument(!error.isOk(), "the error status must not be OK");
+      final class NameResolverErrorHandler implements Runnable {
+        @Override
+        public void run() {
+          handleErrorInSyncContext(error);
+        }
+      }
+
+      syncContext.execute(new NameResolverErrorHandler());
+    }
+
+    private void handleErrorInSyncContext(Status error) {
+      logger.log(Level.WARNING, "[{0}] Failed to resolve name. status={1}",
+          new Object[] {getLogId(), error});
+      realChannel.onConfigError();
+      if (lastResolutionState != ResolutionState.ERROR) {
+        channelLogger.log(ChannelLogLevel.WARNING, "Failed to resolve name: {0}", error);
+        lastResolutionState = ResolutionState.ERROR;
+      }
+      // Call LB only if it's not shutdown.  If LB is shutdown, lbHelper won't match.
+      if (NameResolverListener.this.helper != ManagedChannelImpl.this.lbHelper) {
+        return;
+      }
+
+      helper.lb.handleNameResolutionError(error);
+    }
+  }
+
+  private final class SubchannelImpl extends AbstractSubchannel {
+    final CreateSubchannelArgs args;
+    final InternalLogId subchannelLogId;
+    final ChannelLoggerImpl subchannelLogger;
+    final ChannelTracer subchannelTracer;
+    List<EquivalentAddressGroup> addressGroups;
+    InternalSubchannel subchannel;
+    boolean started;
+    boolean shutdown;
+    ScheduledHandle delayedShutdownTask;
+
+    SubchannelImpl(CreateSubchannelArgs args) {
+      checkNotNull(args, "args");
+      addressGroups = args.getAddresses();
+      if (authorityOverride != null) {
+        List<EquivalentAddressGroup> eagsWithoutOverrideAttr =
+            stripOverrideAuthorityAttributes(args.getAddresses());
+        args = args.toBuilder().setAddresses(eagsWithoutOverrideAttr).build();
+      }
+      this.args = args;
+      subchannelLogId = InternalLogId.allocate("Subchannel", /*details=*/ authority());
+      subchannelTracer = new ChannelTracer(
+          subchannelLogId, maxTraceEvents, timeProvider.currentTimeNanos(),
+          "Subchannel for " + args.getAddresses());
+      subchannelLogger = new ChannelLoggerImpl(subchannelTracer, timeProvider);
+    }
+
+    @Override
+    public void start(final SubchannelStateListener listener) {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      checkState(!started, "already started");
+      checkState(!shutdown, "already shutdown");
+      checkState(!terminating, "Channel is being terminated");
+      started = true;
+      final class ManagedInternalSubchannelCallback extends InternalSubchannel.Callback {
+        // All callbacks are run in syncContext
+        @Override
+        void onTerminated(InternalSubchannel is) {
+          subchannels.remove(is);
+          channelz.removeSubchannel(is);
+          maybeTerminateChannel();
+        }
+
+        @Override
+        void onStateChange(InternalSubchannel is, ConnectivityStateInfo newState) {
+          checkState(listener != null, "listener is null");
+          listener.onSubchannelState(newState);
+        }
+
+        @Override
+        void onInUse(InternalSubchannel is) {
+          inUseStateAggregator.updateObjectInUse(is, true);
+        }
+
+        @Override
+        void onNotInUse(InternalSubchannel is) {
+          inUseStateAggregator.updateObjectInUse(is, false);
+        }
+      }
+
+      final InternalSubchannel internalSubchannel = new InternalSubchannel(
+          args,
+          authority(),
+          userAgent,
+          backoffPolicyProvider,
+          transportFactory,
+          transportFactory.getScheduledExecutorService(),
+          stopwatchSupplier,
+          syncContext,
+          new ManagedInternalSubchannelCallback(),
+          channelz,
+          callTracerFactory.create(),
+          subchannelTracer,
+          subchannelLogId,
+          subchannelLogger,
+          transportFilters, target,
+          lbHelper.getMetricRecorder());
+
+      channelTracer.reportEvent(new ChannelTrace.Event.Builder()
+          .setDescription("Child Subchannel started")
+          .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+          .setTimestampNanos(timeProvider.currentTimeNanos())
+          .setSubchannelRef(internalSubchannel)
+          .build());
+
+      this.subchannel = internalSubchannel;
+      channelz.addSubchannel(internalSubchannel);
+      subchannels.add(internalSubchannel);
+    }
+
+    @Override
+    InternalInstrumented<ChannelStats> getInstrumentedInternalSubchannel() {
+      checkState(started, "not started");
+      return subchannel;
+    }
+
+    @Override
+    public void shutdown() {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      if (subchannel == null) {
+        // start() was not successful
+        shutdown = true;
+        return;
+      }
+      if (shutdown) {
+        if (terminating && delayedShutdownTask != null) {
+          // shutdown() was previously called when terminating == false, thus a delayed shutdown()
+          // was scheduled.  Now since terminating == true, We should expedite the shutdown.
+          delayedShutdownTask.cancel();
+          delayedShutdownTask = null;
+          // Will fall through to the subchannel.shutdown() at the end.
+        } else {
+          return;
+        }
       } else {
-        return transportSet.obtainActiveTransport();
+        shutdown = true;
+      }
+      // Add a delay to shutdown to deal with the race between 1) a transport being picked and
+      // newStream() being called on it, and 2) its Subchannel is shut down by LoadBalancer (e.g.,
+      // because of address change, or because LoadBalancer is shutdown by Channel entering idle
+      // mode). If (2) wins, the app will see a spurious error. We work around this by delaying
+      // shutdown of Subchannel for a few seconds here.
+      //
+      // TODO(zhangkun83): consider a better approach
+      // (https://github.com/grpc/grpc-java/issues/2562).
+      if (!terminating) {
+        final class ShutdownSubchannel implements Runnable {
+          @Override
+          public void run() {
+            subchannel.shutdown(SUBCHANNEL_SHUTDOWN_STATUS);
+          }
+        }
+
+        delayedShutdownTask = syncContext.schedule(
+            new LogExceptionRunnable(new ShutdownSubchannel()),
+            SUBCHANNEL_SHUTDOWN_DELAY_SECONDS, TimeUnit.SECONDS,
+            transportFactory.getScheduledExecutorService());
+        return;
+      }
+      // When terminating == true, no more real streams will be created. It's safe and also
+      // desirable to shutdown timely.
+      subchannel.shutdown(SHUTDOWN_STATUS);
+    }
+
+    @Override
+    public void requestConnection() {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      checkState(started, "not started");
+      if (shutdown) {
+        return;
+      }
+      subchannel.obtainActiveTransport();
+    }
+
+    @Override
+    public List<EquivalentAddressGroup> getAllAddresses() {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      checkState(started, "not started");
+      return addressGroups;
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return args.getAttributes();
+    }
+
+    @Override
+    public String toString() {
+      return subchannelLogId.toString();
+    }
+
+    @Override
+    public Channel asChannel() {
+      checkState(started, "not started");
+      return new SubchannelChannel(
+          subchannel, balancerRpcExecutorHolder.getExecutor(),
+          transportFactory.getScheduledExecutorService(),
+          callTracerFactory.create(),
+          new AtomicReference<InternalConfigSelector>(null));
+    }
+
+    @Override
+    public Object getInternalSubchannel() {
+      checkState(started, "Subchannel is not started");
+      return subchannel;
+    }
+
+    @Override
+    public ChannelLogger getChannelLogger() {
+      return subchannelLogger;
+    }
+
+    @Override
+    public void updateAddresses(List<EquivalentAddressGroup> addrs) {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      addressGroups = addrs;
+      if (authorityOverride != null) {
+        addrs = stripOverrideAuthorityAttributes(addrs);
+      }
+      subchannel.updateAddresses(addrs);
+    }
+
+    @Override
+    public Attributes getConnectedAddressAttributes() {
+      return subchannel.getConnectedAddressAttributes();
+    }
+
+    private List<EquivalentAddressGroup> stripOverrideAuthorityAttributes(
+        List<EquivalentAddressGroup> eags) {
+      List<EquivalentAddressGroup> eagsWithoutOverrideAttr = new ArrayList<>();
+      for (EquivalentAddressGroup eag : eags) {
+        EquivalentAddressGroup eagWithoutOverrideAttr = new EquivalentAddressGroup(
+            eag.getAddresses(),
+            eag.getAttributes().toBuilder().discard(ATTR_AUTHORITY_OVERRIDE).build());
+        eagsWithoutOverrideAttr.add(eagWithoutOverrideAttr);
       }
+      return Collections.unmodifiableList(eagsWithoutOverrideAttr);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("logId", logId.getId())
+        .add("target", target)
+        .toString();
+  }
+
+  /**
+   * Called from syncContext.
+   */
+  private final class DelayedTransportListener implements ManagedClientTransport.Listener {
+    @Override
+    public void transportShutdown(Status s, DisconnectError e) {
+      checkState(shutdown.get(), "Channel must have been shut down");
     }
 
     @Override
-    public void close() {
-      if (transportSet != null) {
-        transportSet.shutdown();
+    public void transportReady() {
+      // Don't care
+    }
+
+    @Override
+    public Attributes filterTransport(Attributes attributes) {
+      return attributes;
+    }
+
+    @Override
+    public void transportInUse(final boolean inUse) {
+      inUseStateAggregator.updateObjectInUse(delayedTransport, inUse);
+      if (inUse) {
+        // It's possible to be in idle mode while inUseStateAggregator is in-use, if one of the
+        // subchannels is in use. But we should never be in idle mode when delayed transport is in
+        // use.
+        exitIdleMode();
       }
     }
 
-    void shutdownNow(Status reason) {
-      if (transportSet != null) {
-        transportSet.shutdownNow(reason);
+    @Override
+    public void transportTerminated() {
+      checkState(shutdown.get(), "Channel must have been shut down");
+      terminating = true;
+      shutdownNameResolverAndLoadBalancer(false);
+      // No need to call channelStateManager since we are already in SHUTDOWN state.
+      // Until LoadBalancer is shutdown, it may still create new subchannels.  We catch them
+      // here.
+      maybeShutdownNowSubchannels();
+      maybeTerminateChannel();
+    }
+  }
+
+  /**
+   * Must be accessed from syncContext.
+   */
+  private final class IdleModeStateAggregator extends InUseStateAggregator<Object> {
+    @Override
+    protected void handleInUse() {
+      exitIdleMode();
+    }
+
+    @Override
+    protected void handleNotInUse() {
+      if (shutdown.get()) {
+        return;
       }
+      rescheduleIdleTimer();
+    }
+  }
+
+  /**
+   * Lazily request for Executor from an executor pool.
+   * Also act as an Executor directly to simply run a cmd
+   */
+  @VisibleForTesting
+  static final class ExecutorHolder implements Executor {
+    private final ObjectPool<? extends Executor> pool;
+    private Executor executor;
+
+    ExecutorHolder(ObjectPool<? extends Executor> executorPool) {
+      this.pool = checkNotNull(executorPool, "executorPool");
     }
+
+    synchronized Executor getExecutor() {
+      if (executor == null) {
+        executor = checkNotNull(pool.getObject(), "%s.getObject()", executor);
+      }
+      return executor;
+    }
+
+    synchronized void release() {
+      if (executor != null) {
+        executor = pool.returnObject(executor);
+      }
+    }
+
+    @Override
+    public void execute(Runnable command) {
+      getExecutor().execute(command);
+    }
+  }
+
+  private static final class RestrictedScheduledExecutor implements ScheduledExecutorService {
+    final ScheduledExecutorService delegate;
+
+    private RestrictedScheduledExecutor(ScheduledExecutorService delegate) {
+      this.delegate = checkNotNull(delegate, "delegate");
+    }
+
+    @Override
+    public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
+      return delegate.schedule(callable, delay, unit);
+    }
+
+    @Override
+    public ScheduledFuture<?> schedule(Runnable cmd, long delay, TimeUnit unit) {
+      return delegate.schedule(cmd, delay, unit);
+    }
+
+    @Override
+    public ScheduledFuture<?> scheduleAtFixedRate(
+        Runnable command, long initialDelay, long period, TimeUnit unit) {
+      return delegate.scheduleAtFixedRate(command, initialDelay, period, unit);
+    }
+
+    @Override
+    public ScheduledFuture<?> scheduleWithFixedDelay(
+        Runnable command, long initialDelay, long delay, TimeUnit unit) {
+      return delegate.scheduleWithFixedDelay(command, initialDelay, delay, unit);
+    }
+
+    @Override
+    public boolean awaitTermination(long timeout, TimeUnit unit)
+        throws InterruptedException {
+      return delegate.awaitTermination(timeout, unit);
+    }
+
+    @Override
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
+        throws InterruptedException {
+      return delegate.invokeAll(tasks);
+    }
+
+    @Override
+    public <T> List<Future<T>> invokeAll(
+        Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+        throws InterruptedException {
+      return delegate.invokeAll(tasks, timeout, unit);
+    }
+
+    @Override
+    public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
+        throws InterruptedException, ExecutionException {
+      return delegate.invokeAny(tasks);
+    }
+
+    @Override
+    public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
+        throws InterruptedException, ExecutionException, TimeoutException {
+      return delegate.invokeAny(tasks, timeout, unit);
+    }
+
+    @Override
+    public boolean isShutdown() {
+      return delegate.isShutdown();
+    }
+
+    @Override
+    public boolean isTerminated() {
+      return delegate.isTerminated();
+    }
+
+    @Override
+    public void shutdown() {
+      throw new UnsupportedOperationException("Restricted: shutdown() is not allowed");
+    }
+
+    @Override
+    public List<Runnable> shutdownNow() {
+      throw new UnsupportedOperationException("Restricted: shutdownNow() is not allowed");
+    }
+
+    @Override
+    public <T> Future<T> submit(Callable<T> task) {
+      return delegate.submit(task);
+    }
+
+    @Override
+    public Future<?> submit(Runnable task) {
+      return delegate.submit(task);
+    }
+
+    @Override
+    public <T> Future<T> submit(Runnable task, T result) {
+      return delegate.submit(task, result);
+    }
+
+    @Override
+    public void execute(Runnable command) {
+      delegate.execute(command);
+    }
+  }
+
+  /**
+   * A ResolutionState indicates the status of last name resolution.
+   */
+  enum ResolutionState {
+    NO_RESOLUTION,
+    SUCCESS,
+    ERROR
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/ManagedChannelImpl2.java b/core/src/main/java/io/grpc/internal/ManagedChannelImpl2.java
deleted file mode 100644
index 04b7474190d..00000000000
--- a/core/src/main/java/io/grpc/internal/ManagedChannelImpl2.java
+++ /dev/null
@@ -1,871 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-import static io.grpc.ConnectivityState.IDLE;
-import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Stopwatch;
-import com.google.common.base.Supplier;
-import com.google.instrumentation.stats.StatsContextFactory;
-import io.grpc.Attributes;
-import io.grpc.CallOptions;
-import io.grpc.Channel;
-import io.grpc.ClientCall;
-import io.grpc.ClientInterceptor;
-import io.grpc.ClientInterceptors;
-import io.grpc.CompressorRegistry;
-import io.grpc.ConnectivityStateInfo;
-import io.grpc.DecompressorRegistry;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.SubchannelPicker;
-import io.grpc.ManagedChannel;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.NameResolver;
-import io.grpc.ResolvedServerInfoGroup;
-import io.grpc.Status;
-import io.grpc.internal.ClientCallImpl.ClientTransportProvider;
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import java.util.regex.Pattern;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
-import javax.annotation.concurrent.ThreadSafe;
-
-/** A communication channel for making outgoing RPCs. */
-@ThreadSafe
-public final class ManagedChannelImpl2 extends ManagedChannel implements WithLogId {
-  private static final Logger log = Logger.getLogger(ManagedChannelImpl2.class.getName());
-
-  // Matching this pattern means the target string is a URI target or at least intended to be one.
-  // A URI target must be an absolute hierarchical URI.
-  // From RFC 2396: scheme = alpha *( alpha | digit | "+" | "-" | "." )
-  @VisibleForTesting
-  static final Pattern URI_PATTERN = Pattern.compile("[a-zA-Z][a-zA-Z0-9+.-]*:/.*");
-
-  static final long IDLE_TIMEOUT_MILLIS_DISABLE = -1;
-
-  @VisibleForTesting
-  static final long SUBCHANNEL_SHUTDOWN_DELAY_SECONDS = 5;
-
-  @VisibleForTesting
-  static final Status SHUTDOWN_NOW_STATUS =
-      Status.UNAVAILABLE.withDescription("Channel shutdownNow invoked");
-
-  private final String target;
-  private final NameResolver.Factory nameResolverFactory;
-  private final Attributes nameResolverParams;
-  private final LoadBalancer2.Factory loadBalancerFactory;
-  private final ClientTransportFactory transportFactory;
-  private final Executor executor;
-  private final ObjectPool<? extends Executor> executorPool;
-  private final ObjectPool<? extends Executor> oobExecutorPool;
-  private final LogId logId = LogId.allocate(getClass().getName());
-
-  private final ChannelExecutor channelExecutor = new ChannelExecutor();
-
-  private final DecompressorRegistry decompressorRegistry;
-  private final CompressorRegistry compressorRegistry;
-
-  private final ObjectPool<ScheduledExecutorService> timerServicePool;
-  private final Supplier<Stopwatch> stopwatchSupplier;
-  /** The timout before entering idle mode. */
-  private final long idleTimeoutMillis;
-  private final StatsContextFactory statsFactory;
-
-  /**
-   * Executor that runs deadline timers for requests.
-   */
-  // Must be assigned from channelExecutor
-  private volatile ScheduledExecutorService scheduledExecutor;
-
-  private final BackoffPolicy.Provider backoffPolicyProvider;
-
-  /**
-   * We delegate to this channel, so that we can have interceptors as necessary. If there aren't
-   * any interceptors this will just be {@link RealChannel}.
-   */
-  private final Channel interceptorChannel;
-  @Nullable private final String userAgent;
-
-  // Only null after channel is terminated. Must be assigned from the channelExecutor.
-  private NameResolver nameResolver;
-
-  // null when channel is in idle mode.  Must be assigned from channelExecutor.
-  @Nullable
-  private LoadBalancer2 loadBalancer;
-
-  // Must be assigned from channelExecutor.  null if channel is in idle mode.
-  @Nullable
-  private volatile SubchannelPicker subchannelPicker;
-
-  // Must be mutated from channelExecutor
-  // If any monitoring hook to be added later needs to get a snapshot of this Set, we could
-  // switch to a ConcurrentHashMap.
-  private final Set<InternalSubchannel> subchannels = new HashSet<InternalSubchannel>(16, .75f);
-
-  // Must be mutated from channelExecutor
-  private final Set<InternalSubchannel> oobChannels = new HashSet<InternalSubchannel>(1, .75f);
-
-  // reprocess() must be run from channelExecutor
-  private final DelayedClientTransport2 delayedTransport;
-
-  // Shutdown states.
-  //
-  // Channel's shutdown process:
-  // 1. shutdown(): stop accepting new calls from applications
-  //   1a shutdown <- true
-  //   1b subchannelPicker <- null
-  //   1c delayedTransport.shutdown()
-  // 2. delayedTransport terminated: stop stream-creation functionality
-  //   2a terminating <- true
-  //   2b loadBalancer.shutdown()
-  //     * LoadBalancer will shutdown subchannels and OOB channels
-  //   2c loadBalancer <- null
-  //   2d nameResolver.shutdown()
-  //   2e nameResolver <- null
-  // 3. All subchannels and OOB channels terminated: Channel considered terminated
-
-  private final AtomicBoolean shutdown = new AtomicBoolean(false);
-  // Must only be mutated and read from channelExecutor
-  private boolean shutdownNowed;
-  // Must be mutated from channelExecutor
-  private volatile boolean terminating;
-  // Must be mutated from channelExecutor
-  private volatile boolean terminated;
-  private final CountDownLatch terminatedLatch = new CountDownLatch(1);
-
-  // Called from channelExecutor
-  private final ManagedClientTransport.Listener delayedTransportListener =
-      new ManagedClientTransport.Listener() {
-        @Override
-        public void transportShutdown(Status s) {
-          checkState(shutdown.get(), "Channel must have been shut down");
-        }
-
-        @Override
-        public void transportReady() {
-          // Don't care
-        }
-
-        @Override
-        public void transportInUse(final boolean inUse) {
-          inUseStateAggregator.updateObjectInUse(delayedTransport, inUse);
-        }
-
-        @Override
-        public void transportTerminated() {
-          checkState(shutdown.get(), "Channel must have been shut down");
-          terminating = true;
-          if (loadBalancer != null) {
-            loadBalancer.shutdown();
-            loadBalancer = null;
-          }
-          if (nameResolver != null) {
-            nameResolver.shutdown();
-            nameResolver = null;
-          }
-
-          // Until LoadBalancer is shutdown, it may still create new subchannels.  We catch them
-          // here.
-          maybeShutdownNowSubchannels();
-          maybeTerminateChannel();
-        }
-      };
-
-  // Must be called from channelExecutor
-  private void maybeShutdownNowSubchannels() {
-    if (shutdownNowed) {
-      for (InternalSubchannel subchannel : subchannels) {
-        subchannel.shutdownNow(SHUTDOWN_NOW_STATUS);
-      }
-      for (InternalSubchannel oobChannel : oobChannels) {
-        oobChannel.shutdownNow(SHUTDOWN_NOW_STATUS);
-      }
-    }
-  }
-
-  // Must be accessed from channelExecutor
-  @VisibleForTesting
-  final InUseStateAggregator2<Object> inUseStateAggregator =
-      new InUseStateAggregator2<Object>() {
-        @Override
-        void handleInUse() {
-          exitIdleMode();
-        }
-
-        @Override
-        void handleNotInUse() {
-          if (shutdown.get()) {
-            return;
-          }
-          rescheduleIdleTimer();
-        }
-      };
-
-  // Run from channelExecutor
-  private class IdleModeTimer implements Runnable {
-    // Only mutated from channelExecutor
-    boolean cancelled;
-
-    @Override
-    public void run() {
-      if (cancelled) {
-        // Race detected: this task was scheduled on channelExecutor before cancelIdleTimer()
-        // could cancel the timer.
-        return;
-      }
-      log.log(Level.FINE, "[{0}] Entering idle mode", getLogId());
-      // nameResolver and loadBalancer are guaranteed to be non-null.  If any of them were null,
-      // either the idleModeTimer ran twice without exiting the idle mode, or the task in shutdown()
-      // did not cancel idleModeTimer, both of which are bugs.
-      nameResolver.shutdown();
-      nameResolver = getNameResolver(target, nameResolverFactory, nameResolverParams);
-      loadBalancer.shutdown();
-      loadBalancer = null;
-      subchannelPicker = null;
-    }
-  }
-
-  // Must be used from channelExecutor
-  @Nullable
-  private ScheduledFuture<?> idleModeTimerFuture;
-  // Must be used from channelExecutor
-  @Nullable
-  private IdleModeTimer idleModeTimer;
-
-  /**
-   * Make the channel exit idle mode, if it's in it.
-   *
-   * <p>Must be called from channelExecutor
-   */
-  @VisibleForTesting
-  void exitIdleMode() {
-    if (shutdown.get()) {
-      return;
-    }
-    if (inUseStateAggregator.isInUse()) {
-      // Cancel the timer now, so that a racing due timer will not put Channel on idleness
-      // when the caller of exitIdleMode() is about to use the returned loadBalancer.
-      cancelIdleTimer();
-    } else {
-      // exitIdleMode() may be called outside of inUseStateAggregator.handleNotInUse() while
-      // isInUse() == false, in which case we still need to schedule the timer.
-      rescheduleIdleTimer();
-    }
-    if (loadBalancer != null) {
-      return;
-    }
-    log.log(Level.FINE, "[{0}] Exiting idle mode", getLogId());
-    LbHelperImpl helper = new LbHelperImpl(nameResolver);
-    helper.lb = loadBalancerFactory.newLoadBalancer(helper);
-    this.loadBalancer = helper.lb;
-
-    NameResolverListenerImpl listener = new NameResolverListenerImpl(helper);
-    try {
-      nameResolver.start(listener);
-    } catch (Throwable t) {
-      listener.onError(Status.fromThrowable(t));
-    }
-  }
-
-  // Must be run from channelExecutor
-  private void cancelIdleTimer() {
-    if (idleModeTimerFuture != null) {
-      idleModeTimerFuture.cancel(false);
-      idleModeTimer.cancelled = true;
-      idleModeTimerFuture = null;
-      idleModeTimer = null;
-    }
-  }
-
-  // Always run from channelExecutor
-  private void rescheduleIdleTimer() {
-    if (idleTimeoutMillis == IDLE_TIMEOUT_MILLIS_DISABLE) {
-      return;
-    }
-    cancelIdleTimer();
-    idleModeTimer = new IdleModeTimer();
-    idleModeTimerFuture = scheduledExecutor.schedule(
-        new LogExceptionRunnable(new Runnable() {
-            @Override
-            public void run() {
-              channelExecutor.executeLater(idleModeTimer).drain();
-            }
-          }),
-        idleTimeoutMillis, TimeUnit.MILLISECONDS);
-  }
-
-  private final ClientTransportProvider transportProvider = new ClientTransportProvider() {
-    @Override
-    public ClientTransport get(CallOptions callOptions, Metadata headers) {
-      SubchannelPicker pickerCopy = subchannelPicker;
-      if (shutdown.get()) {
-        // If channel is shut down, delayedTransport is also shut down which will fail the stream
-        // properly.
-        return delayedTransport;
-      }
-      if (pickerCopy == null) {
-        channelExecutor.executeLater(new Runnable() {
-            @Override
-            public void run() {
-              exitIdleMode();
-            }
-          }).drain();
-        return delayedTransport;
-      }
-      // There is no need to reschedule the idle timer here.
-      //
-      // pickerCopy != null, which means idle timer has not expired when this method starts.
-      // Even if idle timer expires right after we grab pickerCopy, and it shuts down LoadBalancer
-      // which calls Subchannel.shutdown(), the InternalSubchannel will be actually shutdown after
-      // SUBCHANNEL_SHUTDOWN_DELAY_SECONDS, which gives the caller time to start RPC on it.
-      //
-      // In most cases the idle timer is scheduled to fire after the transport has created the
-      // stream, which would have reported in-use state to the channel that would have cancelled
-      // the idle timer.
-      PickResult pickResult = pickerCopy.pickSubchannel(callOptions.getAffinity(), headers);
-      ClientTransport transport = GrpcUtil.getTransportFromPickResult(
-          pickResult, callOptions.isWaitForReady());
-      if (transport != null) {
-        return transport;
-      }
-      return delayedTransport;
-    }
-  };
-
-  ManagedChannelImpl2(String target, BackoffPolicy.Provider backoffPolicyProvider,
-      NameResolver.Factory nameResolverFactory, Attributes nameResolverParams,
-      LoadBalancer2.Factory loadBalancerFactory, ClientTransportFactory transportFactory,
-      DecompressorRegistry decompressorRegistry, CompressorRegistry compressorRegistry,
-      ObjectPool<ScheduledExecutorService> timerServicePool,
-      ObjectPool<? extends Executor> executorPool, ObjectPool<? extends Executor> oobExecutorPool,
-      Supplier<Stopwatch> stopwatchSupplier, long idleTimeoutMillis,
-      @Nullable String userAgent,
-      List<ClientInterceptor> interceptors, StatsContextFactory statsFactory) {
-    this.target = checkNotNull(target, "target");
-    this.nameResolverFactory = checkNotNull(nameResolverFactory, "nameResolverFactory");
-    this.nameResolverParams = checkNotNull(nameResolverParams, "nameResolverParams");
-    this.nameResolver = getNameResolver(target, nameResolverFactory, nameResolverParams);
-    this.loadBalancerFactory = checkNotNull(loadBalancerFactory, "loadBalancerFactory");
-    this.executorPool = checkNotNull(executorPool, "executorPool");
-    this.oobExecutorPool = checkNotNull(oobExecutorPool, "oobExecutorPool");
-    this.executor = checkNotNull(executorPool.getObject(), "executor");
-    this.delayedTransport = new DelayedClientTransport2(this.executor, this.channelExecutor);
-    this.delayedTransport.start(delayedTransportListener);
-    this.backoffPolicyProvider = backoffPolicyProvider;
-    this.transportFactory =
-        new CallCredentialsApplyingTransportFactory(transportFactory, this.executor);
-    this.interceptorChannel = ClientInterceptors.intercept(new RealChannel(), interceptors);
-    this.timerServicePool = checkNotNull(timerServicePool, "timerServicePool");
-    this.scheduledExecutor = checkNotNull(timerServicePool.getObject(), "timerService");
-    this.stopwatchSupplier = checkNotNull(stopwatchSupplier, "stopwatchSupplier");
-    if (idleTimeoutMillis == IDLE_TIMEOUT_MILLIS_DISABLE) {
-      this.idleTimeoutMillis = idleTimeoutMillis;
-    } else {
-      checkArgument(
-          idleTimeoutMillis >= AbstractManagedChannelImplBuilder.IDLE_MODE_MIN_TIMEOUT_MILLIS,
-          "invalid idleTimeoutMillis %s", idleTimeoutMillis);
-      this.idleTimeoutMillis = idleTimeoutMillis;
-    }
-    this.decompressorRegistry = checkNotNull(decompressorRegistry, "decompressorRegistry");
-    this.compressorRegistry = checkNotNull(compressorRegistry, "compressorRegistry");
-    this.userAgent = userAgent;
-    this.statsFactory = checkNotNull(statsFactory, "statsFactory");
-
-    log.log(Level.FINE, "[{0}] Created with target {1}", new Object[] {getLogId(), target});
-  }
-
-  @VisibleForTesting
-  static NameResolver getNameResolver(String target, NameResolver.Factory nameResolverFactory,
-      Attributes nameResolverParams) {
-    // Finding a NameResolver. Try using the target string as the URI. If that fails, try prepending
-    // "dns:///".
-    URI targetUri = null;
-    StringBuilder uriSyntaxErrors = new StringBuilder();
-    try {
-      targetUri = new URI(target);
-      // For "localhost:8080" this would likely cause newNameResolver to return null, because
-      // "localhost" is parsed as the scheme. Will fall into the next branch and try
-      // "dns:///localhost:8080".
-    } catch (URISyntaxException e) {
-      // Can happen with ip addresses like "[::1]:1234" or 127.0.0.1:1234.
-      uriSyntaxErrors.append(e.getMessage());
-    }
-    if (targetUri != null) {
-      NameResolver resolver = nameResolverFactory.newNameResolver(targetUri, nameResolverParams);
-      if (resolver != null) {
-        return resolver;
-      }
-      // "foo.googleapis.com:8080" cause resolver to be null, because "foo.googleapis.com" is an
-      // unmapped scheme. Just fall through and will try "dns:///foo.googleapis.com:8080"
-    }
-
-    // If we reached here, the targetUri couldn't be used.
-    if (!URI_PATTERN.matcher(target).matches()) {
-      // It doesn't look like a URI target. Maybe it's an authority string. Try with the default
-      // scheme from the factory.
-      try {
-        targetUri = new URI(nameResolverFactory.getDefaultScheme(), "", "/" + target, null);
-      } catch (URISyntaxException e) {
-        // Should not be possible.
-        throw new IllegalArgumentException(e);
-      }
-      NameResolver resolver = nameResolverFactory.newNameResolver(targetUri, nameResolverParams);
-      if (resolver != null) {
-        return resolver;
-      }
-    }
-    throw new IllegalArgumentException(String.format(
-        "cannot find a NameResolver for %s%s",
-        target, uriSyntaxErrors.length() > 0 ? " (" + uriSyntaxErrors + ")" : ""));
-  }
-
-  /**
-   * Initiates an orderly shutdown in which preexisting calls continue but new calls are immediately
-   * cancelled.
-   */
-  @Override
-  public ManagedChannelImpl2 shutdown() {
-    log.log(Level.FINE, "[{0}] shutdown() called", getLogId());
-    if (!shutdown.compareAndSet(false, true)) {
-      return this;
-    }
-    delayedTransport.shutdown();
-    channelExecutor.executeLater(new Runnable() {
-        @Override
-        public void run() {
-          cancelIdleTimer();
-        }
-      }).drain();
-    log.log(Level.FINE, "[{0}] Shutting down", getLogId());
-    return this;
-  }
-
-  /**
-   * Initiates a forceful shutdown in which preexisting and new calls are cancelled. Although
-   * forceful, the shutdown process is still not instantaneous; {@link #isTerminated()} will likely
-   * return {@code false} immediately after this method returns.
-   */
-  @Override
-  public ManagedChannelImpl2 shutdownNow() {
-    log.log(Level.FINE, "[{0}] shutdownNow() called", getLogId());
-    shutdown();
-    delayedTransport.shutdownNow(SHUTDOWN_NOW_STATUS);
-    channelExecutor.executeLater(new Runnable() {
-        @Override
-        public void run() {
-          if (shutdownNowed) {
-            return;
-          }
-          shutdownNowed = true;
-          maybeShutdownNowSubchannels();
-        }
-      }).drain();
-    return this;
-  }
-
-  @Override
-  public boolean isShutdown() {
-    return shutdown.get();
-  }
-
-  @Override
-  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
-    return terminatedLatch.await(timeout, unit);
-  }
-
-  @Override
-  public boolean isTerminated() {
-    return terminated;
-  }
-
-  /*
-   * Creates a new outgoing call on the channel.
-   */
-  @Override
-  public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(MethodDescriptor<ReqT, RespT> method,
-      CallOptions callOptions) {
-    return interceptorChannel.newCall(method, callOptions);
-  }
-
-  @Override
-  public String authority() {
-    return interceptorChannel.authority();
-  }
-
-  private class RealChannel extends Channel {
-    @Override
-    public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(MethodDescriptor<ReqT, RespT> method,
-        CallOptions callOptions) {
-      Executor executor = callOptions.getExecutor();
-      if (executor == null) {
-        executor = ManagedChannelImpl2.this.executor;
-      }
-      StatsTraceContext statsTraceCtx = StatsTraceContext.newClientContext(
-          method.getFullMethodName(), statsFactory, stopwatchSupplier);
-      return new ClientCallImpl<ReqT, RespT>(
-          method,
-          executor,
-          callOptions,
-          statsTraceCtx,
-          transportProvider,
-          scheduledExecutor)
-              .setDecompressorRegistry(decompressorRegistry)
-              .setCompressorRegistry(compressorRegistry);
-    }
-
-    @Override
-    public String authority() {
-      String authority = nameResolver.getServiceAuthority();
-      return checkNotNull(authority, "authority");
-    }
-  }
-
-  /**
-   * Terminate the channel if termination conditions are met.
-   */
-  // Must be run from channelExecutor
-  private void maybeTerminateChannel() {
-    if (terminated) {
-      return;
-    }
-    if (shutdown.get() && subchannels.isEmpty() && oobChannels.isEmpty()) {
-      log.log(Level.FINE, "[{0}] Terminated", getLogId());
-      terminated = true;
-      terminatedLatch.countDown();
-      executorPool.returnObject(executor);
-      scheduledExecutor = timerServicePool.returnObject(scheduledExecutor);
-      // Release the transport factory so that it can deallocate any resources.
-      transportFactory.close();
-    }
-  }
-
-  private class LbHelperImpl extends LoadBalancer2.Helper {
-    LoadBalancer2 lb;
-    final NameResolver nr;
-
-    LbHelperImpl(NameResolver nr) {
-      this.nr = checkNotNull(nr, "NameResolver");
-    }
-
-    @Override
-    public SubchannelImpl createSubchannel(EquivalentAddressGroup addressGroup, Attributes attrs) {
-      checkNotNull(addressGroup, "addressGroup");
-      checkNotNull(attrs, "attrs");
-      ScheduledExecutorService scheduledExecutorCopy = scheduledExecutor;
-      checkState(scheduledExecutorCopy != null,
-          "scheduledExecutor is already cleared. Looks like you are calling this method after "
-          + "you've already shut down");
-      final SubchannelImplImpl subchannel = new SubchannelImplImpl(attrs);
-      final InternalSubchannel internalSubchannel = new InternalSubchannel(
-            addressGroup, authority(), userAgent, backoffPolicyProvider, transportFactory,
-            scheduledExecutorCopy, stopwatchSupplier, channelExecutor,
-            new InternalSubchannel.Callback() {
-              // All callbacks are run in channelExecutor
-              @Override
-              void onTerminated(InternalSubchannel is) {
-                subchannels.remove(is);
-                maybeTerminateChannel();
-              }
-
-              @Override
-              void onStateChange(InternalSubchannel is, ConnectivityStateInfo newState) {
-                if ((newState.getState() == TRANSIENT_FAILURE || newState.getState() == IDLE)) {
-                  nr.refresh();
-                }
-                lb.handleSubchannelState(subchannel, newState);
-              }
-
-              @Override
-              void onInUse(InternalSubchannel is) {
-                inUseStateAggregator.updateObjectInUse(is, true);
-              }
-
-              @Override
-              void onNotInUse(InternalSubchannel is) {
-                inUseStateAggregator.updateObjectInUse(is, false);
-              }
-            });
-      subchannel.subchannel = internalSubchannel;
-      log.log(Level.FINE, "[{0}] {1} created for {2}",
-          new Object[] {getLogId(), internalSubchannel.getLogId(), addressGroup});
-      runSerialized(new Runnable() {
-          @Override
-          public void run() {
-            if (terminating) {
-              // Because runSerialized() doesn't guarantee the runnable has been executed upon when
-              // returning, the subchannel may still be returned to the balancer without being
-              // shutdown even if "terminating" is already true.  The subchannel will not be used in
-              // this case, because delayed transport has terminated when "terminating" becomes
-              // true, and no more requests will be sent to balancer beyond this point.
-              internalSubchannel.shutdown();
-            }
-            if (!terminated) {
-              // If channel has not terminated, it will track the subchannel and block termination
-              // for it.
-              subchannels.add(internalSubchannel);
-            }
-          }
-        });
-      return subchannel;
-    }
-
-    @Override
-    public ManagedChannel createOobChannel(EquivalentAddressGroup addressGroup, String authority) {
-      ScheduledExecutorService scheduledExecutorCopy = scheduledExecutor;
-      checkState(scheduledExecutorCopy != null,
-          "scheduledExecutor is already cleared. Looks like you are calling this method after "
-          + "you've already shut down");
-      final OobChannel oobChannel = new OobChannel(statsFactory, authority,
-          oobExecutorPool, scheduledExecutorCopy, stopwatchSupplier, channelExecutor);
-      final InternalSubchannel internalSubchannel = new InternalSubchannel(
-          addressGroup, authority, userAgent, backoffPolicyProvider, transportFactory,
-          scheduledExecutorCopy, stopwatchSupplier, channelExecutor,
-          // All callback methods are run from channelExecutor
-          new InternalSubchannel.Callback() {
-            @Override
-            void onTerminated(InternalSubchannel is) {
-              oobChannels.remove(is);
-              oobChannel.handleSubchannelTerminated();
-              maybeTerminateChannel();
-            }
-
-            @Override
-            void onStateChange(InternalSubchannel is, ConnectivityStateInfo newState) {
-              oobChannel.handleSubchannelStateChange(newState);
-            }
-          });
-      oobChannel.setSubchannel(internalSubchannel);
-      runSerialized(new Runnable() {
-          @Override
-          public void run() {
-            if (terminating) {
-              oobChannel.shutdown();
-            }
-            if (!terminated) {
-              // If channel has not terminated, it will track the subchannel and block termination
-              // for it.
-              oobChannels.add(internalSubchannel);
-            }
-          }
-        });
-      return oobChannel;
-    }
-
-    @Override
-    public String getAuthority() {
-      return ManagedChannelImpl2.this.authority();
-    }
-
-    @Override
-    public NameResolver.Factory getNameResolverFactory() {
-      return nameResolverFactory;
-    }
-
-    @Override
-    public void runSerialized(Runnable task) {
-      channelExecutor.executeLater(task).drain();
-    }
-
-    @Override
-    public void updatePicker(final SubchannelPicker picker) {
-      runSerialized(new Runnable() {
-          @Override
-          public void run() {
-            subchannelPicker = picker;
-            delayedTransport.reprocess(picker);
-          }
-        });
-    }
-  }
-
-  @Override
-  public LogId getLogId() {
-    return logId;
-  }
-
-  private class NameResolverListenerImpl implements NameResolver.Listener {
-    final LoadBalancer2 balancer;
-    final LoadBalancer2.Helper helper;
-
-    NameResolverListenerImpl(LbHelperImpl helperImpl) {
-      this.balancer = helperImpl.lb;
-      this.helper = helperImpl;
-    }
-
-    @Override
-    public void onUpdate(final List<ResolvedServerInfoGroup> servers, final Attributes config) {
-      if (servers.isEmpty()) {
-        onError(Status.UNAVAILABLE.withDescription("NameResolver returned an empty list"));
-        return;
-      }
-      log.log(Level.FINE, "[{0}] resolved address: {1}, config={2}",
-          new Object[] {getLogId(), servers, config});
-      helper.runSerialized(new Runnable() {
-          @Override
-          public void run() {
-            if (terminated) {
-              return;
-            }
-            try {
-              balancer.handleResolvedAddresses(servers, config);
-            } catch (Throwable e) {
-              log.log(
-                  Level.WARNING, "[" + getLogId() + "] Unexpected exception from LoadBalancer", e);
-              // It must be a bug! Push the exception back to LoadBalancer in the hope that it may
-              // be propagated to the application.
-              balancer.handleNameResolutionError(Status.INTERNAL.withCause(e)
-                  .withDescription("Thrown from handleResolvedAddresses(): " + e));
-            }
-          }
-        });
-    }
-
-    @Override
-    public void onError(final Status error) {
-      checkArgument(!error.isOk(), "the error status must not be OK");
-      log.log(Level.WARNING, "[{0}] Failed to resolve name. status={1}",
-          new Object[] {getLogId(), error});
-      channelExecutor.executeLater(new Runnable() {
-          @Override
-          public void run() {
-            if (terminated) {
-              return;
-            }
-            balancer.handleNameResolutionError(error);
-          }
-        }).drain();
-    }
-  }
-
-  private final class SubchannelImplImpl extends SubchannelImpl {
-    // Set right after SubchannelImplImpl is created.
-    InternalSubchannel subchannel;
-    final Object shutdownLock = new Object();
-    final Attributes attrs;
-
-    @GuardedBy("shutdownLock")
-    boolean shutdownRequested;
-    @GuardedBy("shutdownLock")
-    ScheduledFuture<?> delayedShutdownTask;
-
-    SubchannelImplImpl(Attributes attrs) {
-      this.attrs = checkNotNull(attrs, "attrs");
-    }
-
-    @Override
-    ClientTransport obtainActiveTransport() {
-      return subchannel.obtainActiveTransport();
-    }
-
-    @Override
-    public void shutdown() {
-      synchronized (shutdownLock) {
-        if (shutdownRequested) {
-          if (terminating && delayedShutdownTask != null) {
-            // shutdown() was previously called when terminating == false, thus a delayed shutdown()
-            // was scheduled.  Now since terminating == true, We should expedite the shutdown.
-            delayedShutdownTask.cancel(false);
-            delayedShutdownTask = null;
-            // Will fall through to the subchannel.shutdown() at the end.
-          } else {
-            return;
-          }
-        } else {
-          shutdownRequested = true;
-        }
-        ScheduledExecutorService scheduledExecutorCopy = scheduledExecutor;
-        // Add a delay to shutdown to deal with the race between 1) a transport being picked and
-        // newStream() being called on it, and 2) its Subchannel is shut down by LoadBalancer (e.g.,
-        // because of address change, or because LoadBalancer is shutdown by Channel entering idle
-        // mode). If (2) wins, the app will see a spurious error. We work around this by delaying
-        // shutdown of Subchannel for a few seconds here.
-        //
-        // TODO(zhangkun83): consider a better approach
-        // (https://github.com/grpc/grpc-java/issues/2562).
-        if (!terminating && scheduledExecutorCopy != null) {
-          delayedShutdownTask = scheduledExecutorCopy.schedule(
-              new LogExceptionRunnable(
-                  new Runnable() {
-                    @Override
-                    public void run() {
-                      subchannel.shutdown();
-                    }
-                  }), SUBCHANNEL_SHUTDOWN_DELAY_SECONDS, TimeUnit.SECONDS);
-          return;
-        }
-      }
-      // Two possible ways to get here:
-      //
-      // 1. terminating == true: no more real streams will be created, it's safe and also desirable
-      // to shutdown timely.
-      //
-      // 2. scheduledExecutor == null: possible only when Channel has already been terminated.
-      // Though may not be necessary, we'll do it anyway.
-      subchannel.shutdown();
-    }
-
-    @Override
-    public void requestConnection() {
-      subchannel.obtainActiveTransport();
-    }
-
-    @Override
-    public EquivalentAddressGroup getAddresses() {
-      return subchannel.getAddressGroup();
-    }
-
-    @Override
-    public Attributes getAttributes() {
-      return attrs;
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/ManagedChannelImplBuilder.java b/core/src/main/java/io/grpc/internal/ManagedChannelImplBuilder.java
new file mode 100644
index 00000000000..628224b826e
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ManagedChannelImplBuilder.java
@@ -0,0 +1,1015 @@
+/*
+ * 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.internal;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.internal.UriWrapper.wrap;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.errorprone.annotations.DoNotCall;
+import io.grpc.Attributes;
+import io.grpc.BinaryLog;
+import io.grpc.CallCredentials;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ChannelCredentials;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientTransportFilter;
+import io.grpc.CompressorRegistry;
+import io.grpc.DecompressorRegistry;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalConfiguratorRegistry;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.MethodDescriptor;
+import io.grpc.MetricSink;
+import io.grpc.NameResolver;
+import io.grpc.NameResolverProvider;
+import io.grpc.NameResolverRegistry;
+import io.grpc.ProxyDetector;
+import io.grpc.StatusOr;
+import io.grpc.Uri;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Pattern;
+import javax.annotation.Nullable;
+
+/**
+ * Default managed channel builder, for usage in Transport implementations.
+ */
+public final class ManagedChannelImplBuilder
+    extends ManagedChannelBuilder<ManagedChannelImplBuilder> {
+  private static final String DIRECT_ADDRESS_SCHEME = "directaddress";
+
+  private static final Logger log = Logger.getLogger(ManagedChannelImplBuilder.class.getName());
+
+  @DoNotCall("ClientTransportFactoryBuilder is required, use a constructor")
+  public static ManagedChannelBuilder<?> forAddress(String name, int port) {
+    throw new UnsupportedOperationException(
+        "ClientTransportFactoryBuilder is required, use a constructor");
+  }
+
+  @DoNotCall("ClientTransportFactoryBuilder is required, use a constructor")
+  public static ManagedChannelBuilder<?> forTarget(String target) {
+    throw new UnsupportedOperationException(
+        "ClientTransportFactoryBuilder is required, use a constructor");
+  }
+
+  /**
+   * An idle timeout larger than this would disable idle mode.
+   */
+  @VisibleForTesting
+  static final long IDLE_MODE_MAX_TIMEOUT_DAYS = 30;
+
+  /**
+   * The default idle timeout.
+   */
+  @VisibleForTesting
+  static final long IDLE_MODE_DEFAULT_TIMEOUT_MILLIS = TimeUnit.MINUTES.toMillis(30);
+
+  /**
+   * An idle timeout smaller than this would be capped to it.
+   */
+  static final long IDLE_MODE_MIN_TIMEOUT_MILLIS = TimeUnit.SECONDS.toMillis(1);
+
+  private static boolean enableRfc3986Uris = GrpcUtil.getFlag("GRPC_ENABLE_RFC3986_URIS", false);
+
+  /** Whether to parse targets as RFC 3986 URIs (true), or use {@link java.net.URI} (false). */
+  @VisibleForTesting
+  static boolean setRfc3986UrisEnabled(boolean value) {
+    boolean prevValue = ManagedChannelImplBuilder.enableRfc3986Uris;
+    ManagedChannelImplBuilder.enableRfc3986Uris = value;
+    return prevValue;
+  }
+
+  private static final ObjectPool<? extends Executor> DEFAULT_EXECUTOR_POOL =
+      SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR);
+
+  private static final DecompressorRegistry DEFAULT_DECOMPRESSOR_REGISTRY =
+      DecompressorRegistry.getDefaultInstance();
+
+  private static final CompressorRegistry DEFAULT_COMPRESSOR_REGISTRY =
+      CompressorRegistry.getDefaultInstance();
+
+  private static final long DEFAULT_RETRY_BUFFER_SIZE_IN_BYTES = 1L << 24;  // 16M
+  private static final long DEFAULT_PER_RPC_BUFFER_LIMIT_IN_BYTES = 1L << 20; // 1M
+
+  // Matching this pattern means the target string is a URI target or at least intended to be one.
+  // A URI target must be an absolute hierarchical URI.
+  // From RFC 2396: scheme = alpha *( alpha | digit | "+" | "-" | "." )
+  @VisibleForTesting
+  static final Pattern URI_PATTERN = Pattern.compile("[a-zA-Z][a-zA-Z0-9+.-]*:/.*");
+
+  private static final Method GET_CLIENT_INTERCEPTOR_METHOD;
+
+  static {
+    Method getClientInterceptorMethod = null;
+    try {
+      Class<?> censusStatsAccessor =
+          Class.forName("io.grpc.census.InternalCensusStatsAccessor");
+      getClientInterceptorMethod =
+          censusStatsAccessor.getDeclaredMethod(
+              "getClientInterceptor",
+              boolean.class,
+              boolean.class,
+              boolean.class,
+              boolean.class);
+    } catch (ClassNotFoundException e) {
+      // Replace these separate catch statements with multicatch when Android min-API >= 19
+      log.log(Level.FINE, "Unable to apply census stats", e);
+    } catch (NoSuchMethodException e) {
+      log.log(Level.FINE, "Unable to apply census stats", e);
+    }
+    GET_CLIENT_INTERCEPTOR_METHOD = getClientInterceptorMethod;
+  }
+
+
+  ObjectPool<? extends Executor> executorPool = DEFAULT_EXECUTOR_POOL;
+
+  ObjectPool<? extends Executor> offloadExecutorPool = DEFAULT_EXECUTOR_POOL;
+
+  private final List<ClientInterceptor> interceptors = new ArrayList<>();
+  NameResolverRegistry nameResolverRegistry = NameResolverRegistry.getDefaultRegistry();
+
+  final List<ClientTransportFilter> transportFilters = new ArrayList<>();
+
+  final String target;
+  @Nullable
+  final ChannelCredentials channelCredentials;
+  @Nullable
+  final CallCredentials callCredentials;
+  @Nullable
+  IdentityHashMap<NameResolver.Args.Key<?>, Object> nameResolverCustomArgs;
+
+  @Nullable
+  private final SocketAddress directServerAddress;
+
+  @Nullable
+  String userAgent;
+
+  @Nullable
+  String authorityOverride;
+
+  String defaultLbPolicy = GrpcUtil.DEFAULT_LB_POLICY;
+
+  boolean fullStreamDecompression;
+
+  DecompressorRegistry decompressorRegistry = DEFAULT_DECOMPRESSOR_REGISTRY;
+
+  CompressorRegistry compressorRegistry = DEFAULT_COMPRESSOR_REGISTRY;
+
+  long idleTimeoutMillis = IDLE_MODE_DEFAULT_TIMEOUT_MILLIS;
+
+  int maxRetryAttempts = 5;
+  int maxHedgedAttempts = 5;
+  long retryBufferSize = DEFAULT_RETRY_BUFFER_SIZE_IN_BYTES;
+  long perRpcBufferLimit = DEFAULT_PER_RPC_BUFFER_LIMIT_IN_BYTES;
+  boolean retryEnabled = true;
+
+  InternalChannelz channelz = InternalChannelz.instance();
+  int maxTraceEvents;
+
+  @Nullable
+  Map<String, ?> defaultServiceConfig;
+  boolean lookUpServiceConfig = true;
+
+  @Nullable
+  BinaryLog binlog;
+
+  @Nullable
+  ProxyDetector proxyDetector;
+
+  private boolean authorityCheckerDisabled;
+  private boolean statsEnabled = true;
+  private boolean recordStartedRpcs = true;
+  private boolean recordFinishedRpcs = true;
+  private boolean recordRealTimeMetrics = false;
+  private boolean recordRetryMetrics = true;
+  private boolean tracingEnabled = true;
+  List<MetricSink> metricSinks = new ArrayList<>();
+
+  /**
+   * An interface for Transport implementors to provide the {@link ClientTransportFactory}
+   * appropriate for the channel.
+   */
+  public interface ClientTransportFactoryBuilder {
+    ClientTransportFactory buildClientTransportFactory();
+  }
+
+  /**
+   * Convenience ClientTransportFactoryBuilder, throws UnsupportedOperationException().
+   */
+  public static class UnsupportedClientTransportFactoryBuilder implements
+      ClientTransportFactoryBuilder {
+    @Override
+    public ClientTransportFactory buildClientTransportFactory() {
+      throw new UnsupportedOperationException();
+    }
+  }
+
+  /**
+   * An interface for Transport implementors to provide a default port to {@link
+   * io.grpc.NameResolver} for use in cases where the target string doesn't include a port. The
+   * default implementation returns {@link GrpcUtil#DEFAULT_PORT_SSL}.
+   */
+  public interface ChannelBuilderDefaultPortProvider {
+    int getDefaultPort();
+  }
+
+  /**
+   * Default implementation of {@link ChannelBuilderDefaultPortProvider} that returns a fixed port.
+   */
+  public static final class FixedPortProvider implements ChannelBuilderDefaultPortProvider {
+    private final int port;
+
+    public FixedPortProvider(int port) {
+      this.port = port;
+    }
+
+    @Override
+    public int getDefaultPort() {
+      return port;
+    }
+  }
+
+  private static final class ManagedChannelDefaultPortProvider implements
+      ChannelBuilderDefaultPortProvider {
+    @Override
+    public int getDefaultPort() {
+      return GrpcUtil.DEFAULT_PORT_SSL;
+    }
+  }
+
+  private final ClientTransportFactoryBuilder clientTransportFactoryBuilder;
+  private final ChannelBuilderDefaultPortProvider channelBuilderDefaultPortProvider;
+
+  /**
+   * Creates a new managed channel builder with a target string, which can be either a valid {@link
+   * io.grpc.NameResolver}-compliant URI, or an authority string. Transport implementors must
+   * provide client transport factory builder, and may set custom channel default port provider.
+   */
+  public ManagedChannelImplBuilder(String target,
+      ClientTransportFactoryBuilder clientTransportFactoryBuilder,
+      @Nullable ChannelBuilderDefaultPortProvider channelBuilderDefaultPortProvider) {
+    this(target, null, null, clientTransportFactoryBuilder, channelBuilderDefaultPortProvider);
+  }
+
+  /**
+   * Creates a new managed channel builder with a target string, which can be either a valid {@link
+   * io.grpc.NameResolver}-compliant URI, or an authority string. Transport implementors must
+   * provide client transport factory builder, and may set custom channel default port provider.
+   *
+   * @param channelCreds The ChannelCredentials provided by the user. These may be used when
+   *     creating derivative channels.
+   */
+  public ManagedChannelImplBuilder(
+      String target, @Nullable ChannelCredentials channelCreds, @Nullable CallCredentials callCreds,
+      ClientTransportFactoryBuilder clientTransportFactoryBuilder,
+      @Nullable ChannelBuilderDefaultPortProvider channelBuilderDefaultPortProvider) {
+    this.target = checkNotNull(target, "target");
+    this.channelCredentials = channelCreds;
+    this.callCredentials = callCreds;
+    this.clientTransportFactoryBuilder = checkNotNull(clientTransportFactoryBuilder,
+        "clientTransportFactoryBuilder");
+    this.directServerAddress = null;
+
+    if (channelBuilderDefaultPortProvider != null) {
+      this.channelBuilderDefaultPortProvider = channelBuilderDefaultPortProvider;
+    } else {
+      this.channelBuilderDefaultPortProvider = new ManagedChannelDefaultPortProvider();
+    }
+    // TODO(dnvindhya): Move configurator to all the individual builders
+    InternalConfiguratorRegistry.configureChannelBuilder(this);
+  }
+
+  /**
+   * Returns a target string for the SocketAddress. It is only used as a placeholder, because
+   * DirectAddressNameResolverProvider will not actually try to use it. However, it must be a valid
+   * URI.
+   */
+  @VisibleForTesting
+  static String makeTargetStringForDirectAddress(SocketAddress address) {
+    try {
+      return new URI(DIRECT_ADDRESS_SCHEME, "", "/" + address, null).toString();
+    } catch (URISyntaxException e) {
+      // It should not happen.
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * Creates a new managed channel builder with the given server address, authority string of the
+   * channel. Transport implementors must provide client transport factory builder, and may set
+   * custom channel default port provider.
+   */
+  public ManagedChannelImplBuilder(SocketAddress directServerAddress, String authority,
+      ClientTransportFactoryBuilder clientTransportFactoryBuilder,
+      @Nullable ChannelBuilderDefaultPortProvider channelBuilderDefaultPortProvider) {
+    this(directServerAddress, authority, null, null, clientTransportFactoryBuilder,
+        channelBuilderDefaultPortProvider);
+  }
+
+  /**
+   * Creates a new managed channel builder with the given server address, authority string of the
+   * channel. Transport implementors must provide client transport factory builder, and may set
+   * custom channel default port provider.
+   * 
+   * @param channelCreds The ChannelCredentials provided by the user. These may be used when
+   *     creating derivative channels.
+   */
+  public ManagedChannelImplBuilder(SocketAddress directServerAddress, String authority,
+      @Nullable ChannelCredentials channelCreds, @Nullable CallCredentials callCreds,
+      ClientTransportFactoryBuilder clientTransportFactoryBuilder,
+      @Nullable ChannelBuilderDefaultPortProvider channelBuilderDefaultPortProvider) {
+    this.target = makeTargetStringForDirectAddress(directServerAddress);
+    this.channelCredentials = channelCreds;
+    this.callCredentials = callCreds;
+    this.clientTransportFactoryBuilder = checkNotNull(clientTransportFactoryBuilder,
+        "clientTransportFactoryBuilder");
+    this.directServerAddress = directServerAddress;
+    NameResolverRegistry reg = new NameResolverRegistry();
+    reg.register(new DirectAddressNameResolverProvider(directServerAddress,
+        authority));
+    this.nameResolverRegistry = reg;
+
+    if (channelBuilderDefaultPortProvider != null) {
+      this.channelBuilderDefaultPortProvider = channelBuilderDefaultPortProvider;
+    } else {
+      this.channelBuilderDefaultPortProvider = new ManagedChannelDefaultPortProvider();
+    }
+    // TODO(dnvindhya): Move configurator to all the individual builders
+    InternalConfiguratorRegistry.configureChannelBuilder(this);
+  }
+
+  @Override
+  public ManagedChannelImplBuilder directExecutor() {
+    return executor(MoreExecutors.directExecutor());
+  }
+
+  @Override
+  public ManagedChannelImplBuilder executor(Executor executor) {
+    if (executor != null) {
+      this.executorPool = new FixedObjectPool<>(executor);
+    } else {
+      this.executorPool = DEFAULT_EXECUTOR_POOL;
+    }
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder offloadExecutor(Executor executor) {
+    if (executor != null) {
+      this.offloadExecutorPool = new FixedObjectPool<>(executor);
+    } else {
+      this.offloadExecutorPool = DEFAULT_EXECUTOR_POOL;
+    }
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder intercept(List<ClientInterceptor> interceptors) {
+    this.interceptors.addAll(interceptors);
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder intercept(ClientInterceptor... interceptors) {
+    return intercept(Arrays.asList(interceptors));
+  }
+
+  @Override
+  protected ManagedChannelImplBuilder interceptWithTarget(InterceptorFactory factory) {
+    // Add a placeholder instance to the interceptor list, and replace it with a real instance
+    // during build().
+    this.interceptors.add(new InterceptorFactoryWrapper(factory));
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder addTransportFilter(ClientTransportFilter hook) {
+    transportFilters.add(checkNotNull(hook, "transport filter"));
+    return this;
+  }
+
+  @Deprecated
+  @Override
+  public ManagedChannelImplBuilder nameResolverFactory(NameResolver.Factory resolverFactory) {
+    Preconditions.checkState(directServerAddress == null,
+        "directServerAddress is set (%s), which forbids the use of NameResolverFactory",
+        directServerAddress);
+    if (resolverFactory != null) {
+      NameResolverRegistry reg = new NameResolverRegistry();
+      if (resolverFactory instanceof NameResolverProvider) {
+        reg.register((NameResolverProvider) resolverFactory);
+      } else {
+        reg.register(new NameResolverFactoryToProviderFacade(resolverFactory));
+      }
+      this.nameResolverRegistry = reg;
+    } else {
+      this.nameResolverRegistry = NameResolverRegistry.getDefaultRegistry();
+    }
+    return this;
+  }
+
+  ManagedChannelImplBuilder nameResolverRegistry(NameResolverRegistry resolverRegistry) {
+    this.nameResolverRegistry = resolverRegistry;
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder defaultLoadBalancingPolicy(String policy) {
+    Preconditions.checkState(directServerAddress == null,
+        "directServerAddress is set (%s), which forbids the use of load-balancing policy",
+        directServerAddress);
+    Preconditions.checkArgument(policy != null, "policy cannot be null");
+    this.defaultLbPolicy = policy;
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder decompressorRegistry(DecompressorRegistry registry) {
+    if (registry != null) {
+      this.decompressorRegistry = registry;
+    } else {
+      this.decompressorRegistry = DEFAULT_DECOMPRESSOR_REGISTRY;
+    }
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder compressorRegistry(CompressorRegistry registry) {
+    if (registry != null) {
+      this.compressorRegistry = registry;
+    } else {
+      this.compressorRegistry = DEFAULT_COMPRESSOR_REGISTRY;
+    }
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder userAgent(@Nullable String userAgent) {
+    this.userAgent = userAgent;
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder overrideAuthority(String authority) {
+    this.authorityOverride = checkAuthority(authority);
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder idleTimeout(long value, TimeUnit unit) {
+    checkArgument(value > 0, "idle timeout is %s, but must be positive", value);
+    // We convert to the largest unit to avoid overflow
+    if (unit.toDays(value) >= IDLE_MODE_MAX_TIMEOUT_DAYS) {
+      // This disables idle mode
+      this.idleTimeoutMillis = ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE;
+    } else {
+      this.idleTimeoutMillis = Math.max(unit.toMillis(value), IDLE_MODE_MIN_TIMEOUT_MILLIS);
+    }
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder maxRetryAttempts(int maxRetryAttempts) {
+    this.maxRetryAttempts = maxRetryAttempts;
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder maxHedgedAttempts(int maxHedgedAttempts) {
+    this.maxHedgedAttempts = maxHedgedAttempts;
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder retryBufferSize(long bytes) {
+    checkArgument(bytes > 0L, "retry buffer size must be positive");
+    retryBufferSize = bytes;
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder perRpcBufferLimit(long bytes) {
+    checkArgument(bytes > 0L, "per RPC buffer limit must be positive");
+    perRpcBufferLimit = bytes;
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder disableRetry() {
+    retryEnabled = false;
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder enableRetry() {
+    retryEnabled = true;
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder setBinaryLog(BinaryLog binlog) {
+    this.binlog = binlog;
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder maxTraceEvents(int maxTraceEvents) {
+    checkArgument(maxTraceEvents >= 0, "maxTraceEvents must be non-negative");
+    this.maxTraceEvents = maxTraceEvents;
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder proxyDetector(@Nullable ProxyDetector proxyDetector) {
+    this.proxyDetector = proxyDetector;
+    return this;
+  }
+
+  @Override
+  public ManagedChannelImplBuilder defaultServiceConfig(@Nullable Map<String, ?> serviceConfig) {
+    // TODO(notcarl): use real parsing
+    defaultServiceConfig = checkMapEntryTypes(serviceConfig);
+    return this;
+  }
+
+  @Nullable
+  private static Map<String, ?> checkMapEntryTypes(@Nullable Map<?, ?> map) {
+    if (map == null) {
+      return null;
+    }
+    // Not using ImmutableMap.Builder because of extra guava dependency for Android.
+    Map<String, Object> parsedMap = new LinkedHashMap<>();
+    for (Map.Entry<?, ?> entry : map.entrySet()) {
+      checkArgument(
+          entry.getKey() instanceof String,
+          "The key of the entry '%s' is not of String type", entry);
+
+      String key = (String) entry.getKey();
+      Object value = entry.getValue();
+      if (value == null) {
+        parsedMap.put(key, null);
+      } else if (value instanceof Map) {
+        parsedMap.put(key, checkMapEntryTypes((Map<?, ?>) value));
+      } else if (value instanceof List) {
+        parsedMap.put(key, checkListEntryTypes((List<?>) value));
+      } else if (value instanceof String) {
+        parsedMap.put(key, value);
+      } else if (value instanceof Double) {
+        parsedMap.put(key, value);
+      } else if (value instanceof Boolean) {
+        parsedMap.put(key, value);
+      } else {
+        throw new IllegalArgumentException(
+            "The value of the map entry '" + entry + "' is of type '" + value.getClass()
+                + "', which is not supported");
+      }
+    }
+    return Collections.unmodifiableMap(parsedMap);
+  }
+
+  private static List<?> checkListEntryTypes(List<?> list) {
+    List<Object> parsedList = new ArrayList<>(list.size());
+    for (Object value : list) {
+      if (value == null) {
+        parsedList.add(null);
+      } else if (value instanceof Map) {
+        parsedList.add(checkMapEntryTypes((Map<?, ?>) value));
+      } else if (value instanceof List) {
+        parsedList.add(checkListEntryTypes((List<?>) value));
+      } else if (value instanceof String) {
+        parsedList.add(value);
+      } else if (value instanceof Double) {
+        parsedList.add(value);
+      } else if (value instanceof Boolean) {
+        parsedList.add(value);
+      } else {
+        throw new IllegalArgumentException(
+            "The entry '" + value + "' is of type '" + value.getClass()
+                + "', which is not supported");
+      }
+    }
+    return Collections.unmodifiableList(parsedList);
+  }
+
+  @Override
+  public <X> ManagedChannelImplBuilder setNameResolverArg(NameResolver.Args.Key<X> key, X value) {
+    if (nameResolverCustomArgs == null) {
+      nameResolverCustomArgs = new IdentityHashMap<>();
+    }
+    nameResolverCustomArgs.put(checkNotNull(key, "key"), checkNotNull(value, "value"));
+    return this;
+  }
+
+  @SuppressWarnings("unchecked") // This cast is safe because of setNameResolverArg()'s signature.
+  void copyAllNameResolverCustomArgsTo(NameResolver.Args.Builder dest) {
+    if (nameResolverCustomArgs != null) {
+      for (Map.Entry<NameResolver.Args.Key<?>, Object> entry : nameResolverCustomArgs.entrySet()) {
+        dest.setArg((NameResolver.Args.Key<Object>) entry.getKey(), entry.getValue());
+      }
+    }
+  }
+
+  @Override
+  public ManagedChannelImplBuilder disableServiceConfigLookUp() {
+    this.lookUpServiceConfig = false;
+    return this;
+  }
+
+  /**
+   * Disable or enable stats features. Enabled by default.
+   *
+   * <p>For the current release, calling {@code setStatsEnabled(true)} may have a side effect that
+   * disables retry.
+   */
+  public void setStatsEnabled(boolean value) {
+    statsEnabled = value;
+  }
+
+  /**
+   * Disable or enable stats recording for RPC upstarts.  Effective only if {@link
+   * #setStatsEnabled} is set to true.  Enabled by default.
+   */
+  public void setStatsRecordStartedRpcs(boolean value) {
+    recordStartedRpcs = value;
+  }
+
+  /**
+   * Disable or enable stats recording for RPC completions.  Effective only if {@link
+   * #setStatsEnabled} is set to true.  Enabled by default.
+   */
+  public void setStatsRecordFinishedRpcs(boolean value) {
+    recordFinishedRpcs = value;
+  }
+
+  /**
+   * Disable or enable real-time metrics recording.  Effective only if {@link #setStatsEnabled} is
+   * set to true.  Disabled by default.
+   */
+  public void setStatsRecordRealTimeMetrics(boolean value) {
+    recordRealTimeMetrics = value;
+  }
+  
+  public void setStatsRecordRetryMetrics(boolean value) {
+    recordRetryMetrics = value;
+  }
+
+  /**
+   * Disable or enable tracing features.  Enabled by default.
+   */
+  public void setTracingEnabled(boolean value) {
+    tracingEnabled = value;
+  }
+
+  /**
+   * Verifies the authority is valid.
+   */
+  @VisibleForTesting
+  String checkAuthority(String authority) {
+    if (authorityCheckerDisabled) {
+      return authority;
+    }
+    return GrpcUtil.checkAuthority(authority);
+  }
+
+  /** Disable the check whether the authority is valid. */
+  public ManagedChannelImplBuilder disableCheckAuthority() {
+    authorityCheckerDisabled = true;
+    return this;
+  }
+
+  /** Enable previously disabled authority check. */
+  public ManagedChannelImplBuilder enableCheckAuthority() {
+    authorityCheckerDisabled = false;
+    return this;
+  }
+
+  @Override
+  protected ManagedChannelImplBuilder addMetricSink(MetricSink metricSink) {
+    metricSinks.add(checkNotNull(metricSink, "metric sink"));
+    return this;
+  }
+
+  @Override
+  public ManagedChannel build() {
+    ClientTransportFactory clientTransportFactory =
+        clientTransportFactoryBuilder.buildClientTransportFactory();
+    ResolvedNameResolver resolvedResolver =
+        enableRfc3986Uris
+            ? getNameResolverProviderRfc3986(target, nameResolverRegistry)
+            : getNameResolverProvider(target, nameResolverRegistry);
+    resolvedResolver.checkAddressTypes(clientTransportFactory.getSupportedSocketAddressTypes());
+    return new ManagedChannelOrphanWrapper(new ManagedChannelImpl(
+        this,
+        clientTransportFactory,
+        resolvedResolver.targetUri,
+        resolvedResolver.provider,
+        new ExponentialBackoffPolicy.Provider(),
+        SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR),
+        GrpcUtil.STOPWATCH_SUPPLIER,
+        getEffectiveInterceptors(resolvedResolver.targetUri.toString()),
+        TimeProvider.SYSTEM_TIME_PROVIDER));
+  }
+
+  // Temporarily disable retry when stats or tracing is enabled to avoid breakage, until we know
+  // what should be the desired behavior for retry + stats/tracing.
+  // TODO(zdapeng): FIX IT
+  @VisibleForTesting
+  List<ClientInterceptor> getEffectiveInterceptors(String computedTarget) {
+    List<ClientInterceptor> effectiveInterceptors = new ArrayList<>(this.interceptors.size());
+    for (ClientInterceptor interceptor : this.interceptors) {
+      if (interceptor instanceof InterceptorFactoryWrapper) {
+        InterceptorFactory factory = ((InterceptorFactoryWrapper) interceptor).factory;
+        interceptor = factory.newInterceptor(computedTarget);
+        if (interceptor == null) {
+          throw new NullPointerException("Factory returned null interceptor: " + factory);
+        }
+      }
+      effectiveInterceptors.add(interceptor);
+    }
+
+    boolean disableImplicitCensus = InternalConfiguratorRegistry.wasSetConfiguratorsCalled();
+    if (disableImplicitCensus) {
+      return effectiveInterceptors;
+    }
+    if (statsEnabled) {
+      ClientInterceptor statsInterceptor = null;
+
+      if (GET_CLIENT_INTERCEPTOR_METHOD != null) {
+        try {
+          statsInterceptor =
+              (ClientInterceptor) GET_CLIENT_INTERCEPTOR_METHOD
+              .invoke(
+                null,
+                recordStartedRpcs,
+                recordFinishedRpcs,
+                recordRealTimeMetrics,
+                recordRetryMetrics);
+        } catch (IllegalAccessException e) {
+          log.log(Level.FINE, "Unable to apply census stats", e);
+        } catch (InvocationTargetException e) {
+          log.log(Level.FINE, "Unable to apply census stats", e);
+        }
+      }
+
+      if (statsInterceptor != null) {
+        // First interceptor runs last (see ClientInterceptors.intercept()), so that no
+        // other interceptor can override the tracer factory we set in CallOptions.
+        effectiveInterceptors.add(0, statsInterceptor);
+      }
+    }
+    if (tracingEnabled) {
+      ClientInterceptor tracingInterceptor = null;
+      try {
+        Class<?> censusTracingAccessor =
+            Class.forName("io.grpc.census.InternalCensusTracingAccessor");
+        Method getClientInterceptroMethod =
+            censusTracingAccessor.getDeclaredMethod("getClientInterceptor");
+        tracingInterceptor = (ClientInterceptor) getClientInterceptroMethod.invoke(null);
+      } catch (ClassNotFoundException e) {
+        // Replace these separate catch statements with multicatch when Android min-API >= 19
+        log.log(Level.FINE, "Unable to apply census stats", e);
+      } catch (NoSuchMethodException e) {
+        log.log(Level.FINE, "Unable to apply census stats", e);
+      } catch (IllegalAccessException e) {
+        log.log(Level.FINE, "Unable to apply census stats", e);
+      } catch (InvocationTargetException e) {
+        log.log(Level.FINE, "Unable to apply census stats", e);
+      }
+      if (tracingInterceptor != null) {
+        effectiveInterceptors.add(0, tracingInterceptor);
+      }
+    }
+    return effectiveInterceptors;
+  }
+
+  /**
+   * Returns a default port to {@link NameResolver} for use in cases where the target string doesn't
+   * include a port. The default implementation returns {@link GrpcUtil#DEFAULT_PORT_SSL}.
+   */
+  int getDefaultPort() {
+    return channelBuilderDefaultPortProvider.getDefaultPort();
+  }
+
+  @VisibleForTesting
+  static class ResolvedNameResolver {
+    public final UriWrapper targetUri;
+    public final NameResolverProvider provider;
+
+    public ResolvedNameResolver(UriWrapper targetUri, NameResolverProvider provider) {
+      this.targetUri = checkNotNull(targetUri, "targetUri");
+      this.provider = checkNotNull(provider, "provider");
+    }
+
+    void checkAddressTypes(
+        Collection<Class<? extends SocketAddress>> channelTransportSocketAddressTypes) {
+      if (channelTransportSocketAddressTypes != null) {
+        Collection<Class<? extends SocketAddress>> nameResolverSocketAddressTypes =
+            provider.getProducedSocketAddressTypes();
+        if (!channelTransportSocketAddressTypes.containsAll(nameResolverSocketAddressTypes)) {
+          throw new IllegalArgumentException(
+              String.format(
+                  "Address types of NameResolver '%s' for '%s' not supported by transport",
+                  provider.getDefaultScheme(), targetUri));
+        }
+      }
+    }
+  }
+
+  @VisibleForTesting
+  static ResolvedNameResolver getNameResolverProvider(
+      String target, NameResolverRegistry nameResolverRegistry) {
+    // Finding a NameResolver. Try using the target string as the URI. If that fails, try prepending
+    // "dns:///".
+    NameResolverProvider provider = null;
+    URI targetUri = null;
+    StringBuilder uriSyntaxErrors = new StringBuilder();
+    try {
+      targetUri = new URI(target);
+    } catch (URISyntaxException e) {
+      // Can happen with ip addresses like "[::1]:1234" or 127.0.0.1:1234.
+      uriSyntaxErrors.append(e.getMessage());
+    }
+    if (targetUri != null) {
+      // For "localhost:8080" this would likely cause provider to be null, because "localhost" is
+      // parsed as the scheme. Will hit the next case and try "dns:///localhost:8080".
+      provider = nameResolverRegistry.getProviderForScheme(targetUri.getScheme());
+    }
+
+    if (provider == null && !URI_PATTERN.matcher(target).matches()) {
+      // It doesn't look like a URI target. Maybe it's an authority string. Try with the default
+      // scheme from the registry.
+      try {
+        targetUri = new URI(nameResolverRegistry.getDefaultScheme(), "", "/" + target, null);
+      } catch (URISyntaxException e) {
+        // Should not be possible.
+        throw new IllegalArgumentException(e);
+      }
+      provider = nameResolverRegistry.getProviderForScheme(targetUri.getScheme());
+    }
+
+    if (provider == null) {
+      throw new IllegalArgumentException(String.format(
+          "Could not find a NameResolverProvider for %s%s",
+          target, uriSyntaxErrors.length() > 0 ? " (" + uriSyntaxErrors + ")" : ""));
+    }
+
+    return new ResolvedNameResolver(wrap(targetUri), provider);
+  }
+
+  @VisibleForTesting
+  static ResolvedNameResolver getNameResolverProviderRfc3986(
+      String target, NameResolverRegistry nameResolverRegistry) {
+    // Finding a NameResolver. Try using the target string as the URI. If that fails, try prepending
+    // "dns:///".
+    NameResolverProvider provider = null;
+    Uri targetUri = null;
+    StringBuilder uriSyntaxErrors = new StringBuilder();
+    try {
+      targetUri = Uri.parse(target);
+    } catch (URISyntaxException e) {
+      // Can happen with ip addresses like "[::1]:1234" or 127.0.0.1:1234.
+      uriSyntaxErrors.append(e.getMessage());
+    }
+    if (targetUri != null) {
+      // For "localhost:8080" this would likely cause provider to be null, because "localhost" is
+      // parsed as the scheme. Will hit the next case and try "dns:///localhost:8080".
+      provider = nameResolverRegistry.getProviderForScheme(targetUri.getScheme());
+    }
+
+    if (provider == null && !URI_PATTERN.matcher(target).matches()) {
+      // It doesn't look like a URI target. Maybe it's an authority string. Try with the default
+      // scheme from the registry.
+      targetUri =
+          Uri.newBuilder()
+              .setScheme(nameResolverRegistry.getDefaultScheme())
+              .setHost("")
+              .setPath("/" + target)
+              .build();
+      provider = nameResolverRegistry.getProviderForScheme(targetUri.getScheme());
+    }
+
+    if (provider == null) {
+      throw new IllegalArgumentException(
+          String.format(
+              "Could not find a NameResolverProvider for %s%s",
+              target, uriSyntaxErrors.length() > 0 ? " (" + uriSyntaxErrors + ")" : ""));
+    }
+
+    return new ResolvedNameResolver(wrap(targetUri), provider);
+  }
+
+  private static class DirectAddressNameResolverProvider extends NameResolverProvider {
+    final SocketAddress address;
+    final String authority;
+    final Collection<Class<? extends SocketAddress>> producedSocketAddressTypes;
+
+    DirectAddressNameResolverProvider(SocketAddress address, String authority) {
+      this.address = address;
+      this.authority = authority;
+      this.producedSocketAddressTypes
+          = Collections.singleton(address.getClass());
+    }
+
+    @Override
+    public NameResolver newNameResolver(URI notUsedUri, NameResolver.Args args) {
+      return new NameResolver() {
+        @Override
+        public String getServiceAuthority() {
+          return authority;
+        }
+
+        @Override
+        public void start(Listener2 listener) {
+          listener.onResult2(
+              ResolutionResult.newBuilder()
+                  .setAddressesOrError(
+                      StatusOr.fromValue(
+                          Collections.singletonList(new EquivalentAddressGroup(address))))
+                  .setAttributes(Attributes.EMPTY)
+                  .build());
+        }
+
+        @Override
+        public void shutdown() {}
+      };
+    }
+
+    @Override
+    public String getDefaultScheme() {
+      return DIRECT_ADDRESS_SCHEME;
+    }
+
+    @Override
+    protected boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    protected int priority() {
+      return 5;
+    }
+
+    @Override
+    public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+      return producedSocketAddressTypes;
+    }
+  }
+
+  private static final class InterceptorFactoryWrapper implements ClientInterceptor {
+    final InterceptorFactory factory;
+
+    public InterceptorFactoryWrapper(InterceptorFactory factory) {
+      this.factory = checkNotNull(factory, "factory");
+    }
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+      throw new AssertionError("Should have been replaced with real instance");
+    }
+  }
+
+  /**
+   * Returns the internal offload executor pool for offloading tasks.
+   */
+  public ObjectPool<? extends Executor> getOffloadExecutorPool() {
+    return this.offloadExecutorPool;
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ManagedChannelOrphanWrapper.java b/core/src/main/java/io/grpc/internal/ManagedChannelOrphanWrapper.java
new file mode 100644
index 00000000000..eac9b64d9db
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ManagedChannelOrphanWrapper.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright 2018 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.internal;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.ManagedChannel;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+import java.lang.ref.WeakReference;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+
+/**
+ *  Best effort detecting channels that has not been properly cleaned up.
+ *  Use {@link WeakReference} to avoid keeping the channel alive and retaining too much memory.
+ *  Check lost references only on new channel creation and log message to indicate
+ *  the previous channel (id and target) that has not been shutdown. This is done to avoid Object
+ *  finalizers.
+ */
+final class ManagedChannelOrphanWrapper extends ForwardingManagedChannel {
+  private static final ReferenceQueue<ManagedChannelOrphanWrapper> refqueue =
+      new ReferenceQueue<>();
+  // Retain the References so they don't get GC'd
+  private static final ConcurrentMap<ManagedChannelReference, ManagedChannelReference> refs =
+      new ConcurrentHashMap<>();
+  private static final Logger logger =
+      Logger.getLogger(ManagedChannelOrphanWrapper.class.getName());
+
+  private final ManagedChannelReference phantom;
+
+  ManagedChannelOrphanWrapper(ManagedChannel delegate) {
+    this(delegate, refqueue, refs);
+  }
+
+  @VisibleForTesting
+  ManagedChannelOrphanWrapper(
+      ManagedChannel delegate,
+      ReferenceQueue<ManagedChannelOrphanWrapper> refqueue,
+      ConcurrentMap<ManagedChannelReference, ManagedChannelReference> refs) {
+    super(delegate);
+    phantom = new ManagedChannelReference(this, delegate, refqueue, refs);
+  }
+
+  @Override
+  public ManagedChannel shutdown() {
+    phantom.clearSafely();
+    return super.shutdown();
+  }
+
+  @Override
+  public ManagedChannel shutdownNow() {
+    phantom.clearSafely();
+    return super.shutdownNow();
+  }
+
+  @VisibleForTesting
+  static final class ManagedChannelReference extends WeakReference<ManagedChannelOrphanWrapper> {
+
+    private static final String ALLOCATION_SITE_PROPERTY_NAME =
+        "io.grpc.ManagedChannel.enableAllocationTracking";
+
+    private static final boolean ENABLE_ALLOCATION_TRACKING =
+        Boolean.parseBoolean(System.getProperty(ALLOCATION_SITE_PROPERTY_NAME, "true"));
+
+    @SuppressWarnings("StaticAssignmentOfThrowable")
+    private static final RuntimeException missingCallSite = missingCallSite();
+
+    private final ReferenceQueue<ManagedChannelOrphanWrapper> refqueue;
+    private final ConcurrentMap<ManagedChannelReference, ManagedChannelReference> refs;
+
+    private final String channelStr;
+    private final Reference<RuntimeException> allocationSite;
+    private final AtomicBoolean shutdown = new AtomicBoolean();
+
+    ManagedChannelReference(
+        ManagedChannelOrphanWrapper orphanable,
+        ManagedChannel channel,
+        ReferenceQueue<ManagedChannelOrphanWrapper> refqueue,
+        ConcurrentMap<ManagedChannelReference, ManagedChannelReference> refs) {
+      super(orphanable, refqueue);
+      allocationSite = new SoftReference<>(
+          ENABLE_ALLOCATION_TRACKING
+              ? new RuntimeException("ManagedChannel allocation site")
+              : missingCallSite);
+      this.channelStr = channel.toString();
+      this.refqueue = refqueue;
+      this.refs = refs;
+      this.refs.put(this, this);
+      cleanQueue(refqueue);
+    }
+
+    /**
+     * This clear() is *not* called automatically by the JVM.  As this is a weak ref, the reference
+     * will be cleared automatically by the JVM, but will not be removed from {@link #refs}.
+     * We do it here to avoid this ending up on the reference queue.
+     */
+    @Override
+    public void clear() {
+      clearInternal();
+      // We run this here to periodically clean up the queue if at least some of the channels are
+      // being shutdown properly.
+      cleanQueue(refqueue);
+    }
+
+    /**
+     * Safe to call concurrently.
+     */
+    private void clearSafely() {
+      if (!shutdown.getAndSet(true)) {
+        clear();
+      }
+    }
+
+    // avoid reentrancy
+    private void clearInternal() {
+      super.clear();
+      refs.remove(this);
+      allocationSite.clear();
+    }
+
+    private static RuntimeException missingCallSite() {
+      RuntimeException e = new RuntimeException(
+          "ManagedChannel allocation site not recorded.  Set -D"
+              + ALLOCATION_SITE_PROPERTY_NAME + "=true to enable it");
+      e.setStackTrace(new StackTraceElement[0]);
+      return e;
+    }
+
+    @VisibleForTesting
+    static int cleanQueue(ReferenceQueue<ManagedChannelOrphanWrapper> refqueue) {
+      ManagedChannelReference ref;
+      int orphanedChannels = 0;
+      while ((ref = (ManagedChannelReference) refqueue.poll()) != null) {
+        RuntimeException maybeAllocationSite = ref.allocationSite.get();
+        ref.clearInternal(); // technically the reference is gone already.
+        if (!ref.shutdown.get()) {
+          orphanedChannels++;
+          Level level = Level.SEVERE;
+          if (logger.isLoggable(level)) {
+            String fmt =
+                "*~*~*~ Previous channel {0} was garbage collected without being shut down! ~*~*~*"
+                    + System.getProperty("line.separator")
+                    + "    Make sure to call shutdown()/shutdownNow()";
+            LogRecord lr = new LogRecord(level, fmt);
+            lr.setLoggerName(logger.getName());
+            lr.setParameters(new Object[] {ref.channelStr});
+            lr.setThrown(maybeAllocationSite);
+            logger.log(lr);
+          }
+        }
+      }
+      return orphanedChannels;
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ManagedChannelServiceConfig.java b/core/src/main/java/io/grpc/internal/ManagedChannelServiceConfig.java
new file mode 100644
index 00000000000..e5512dc8df4
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ManagedChannelServiceConfig.java
@@ -0,0 +1,416 @@
+/*
+ * Copyright 2019 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.internal;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import com.google.common.base.Strings;
+import io.grpc.CallOptions;
+import io.grpc.InternalConfigSelector;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status.Code;
+import io.grpc.internal.RetriableStream.Throttle;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.Nullable;
+
+/**
+ * {@link ManagedChannelServiceConfig} is a fully parsed and validated representation of service
+ * configuration data.
+ */
+final class ManagedChannelServiceConfig {
+
+  @Nullable
+  private final MethodInfo defaultMethodConfig;
+  private final Map<String, MethodInfo> serviceMethodMap;
+  private final Map<String, MethodInfo> serviceMap;
+  @Nullable
+  private final Throttle retryThrottling;
+  @Nullable
+  private final Object loadBalancingConfig;
+  @Nullable
+  private final Map<String, ?> healthCheckingConfig;
+
+  ManagedChannelServiceConfig(
+      @Nullable MethodInfo defaultMethodConfig,
+      Map<String, MethodInfo> serviceMethodMap,
+      Map<String, MethodInfo> serviceMap,
+      @Nullable Throttle retryThrottling,
+      @Nullable Object loadBalancingConfig,
+      @Nullable Map<String, ?> healthCheckingConfig) {
+    this.defaultMethodConfig = defaultMethodConfig;
+    this.serviceMethodMap = Collections.unmodifiableMap(new HashMap<>(serviceMethodMap));
+    this.serviceMap = Collections.unmodifiableMap(new HashMap<>(serviceMap));
+    this.retryThrottling = retryThrottling;
+    this.loadBalancingConfig = loadBalancingConfig;
+    this.healthCheckingConfig =
+        healthCheckingConfig != null
+            ? Collections.unmodifiableMap(new HashMap<>(healthCheckingConfig))
+            : null;
+  }
+
+  /** Returns an empty {@link ManagedChannelServiceConfig}. */
+  static ManagedChannelServiceConfig empty() {
+    return
+        new ManagedChannelServiceConfig(
+            null,
+            new HashMap<String, MethodInfo>(),
+            new HashMap<String, MethodInfo>(),
+            /* retryThrottling= */ null,
+            /* loadBalancingConfig= */ null,
+            /* healthCheckingConfig= */ null);
+  }
+
+  /**
+   * Parses the Channel level config values (e.g. excludes load balancing)
+   */
+  static ManagedChannelServiceConfig fromServiceConfig(
+      Map<String, ?> serviceConfig,
+      boolean retryEnabled,
+      int maxRetryAttemptsLimit,
+      int maxHedgedAttemptsLimit,
+      @Nullable Object loadBalancingConfig) {
+    Throttle retryThrottling = null;
+    if (retryEnabled) {
+      retryThrottling = ServiceConfigUtil.getThrottlePolicy(serviceConfig);
+    }
+    Map<String, MethodInfo> serviceMethodMap = new HashMap<>();
+    Map<String, MethodInfo> serviceMap = new HashMap<>();
+    Map<String, ?> healthCheckingConfig =
+        ServiceConfigUtil.getHealthCheckedService(serviceConfig);
+
+    // Try and do as much validation here before we swap out the existing configuration.  In case
+    // the input is invalid, we don't want to lose the existing configuration.
+    List<Map<String, ?>> methodConfigs =
+        ServiceConfigUtil.getMethodConfigFromServiceConfig(serviceConfig);
+
+    if (methodConfigs == null) {
+      // this is surprising, but possible.
+      return
+          new ManagedChannelServiceConfig(
+              null,
+              serviceMethodMap,
+              serviceMap,
+              retryThrottling,
+              loadBalancingConfig,
+              healthCheckingConfig);
+    }
+
+    MethodInfo defaultMethodConfig = null;
+    for (Map<String, ?> methodConfig : methodConfigs) {
+      MethodInfo info = new MethodInfo(
+          methodConfig, retryEnabled, maxRetryAttemptsLimit, maxHedgedAttemptsLimit);
+
+      List<Map<String, ?>> nameList =
+          ServiceConfigUtil.getNameListFromMethodConfig(methodConfig);
+
+      if (nameList == null || nameList.isEmpty()) {
+        continue;
+      }
+      for (Map<String, ?> name : nameList) {
+        String serviceName = ServiceConfigUtil.getServiceFromName(name);
+        String methodName = ServiceConfigUtil.getMethodFromName(name);
+        if (Strings.isNullOrEmpty(serviceName)) {
+          checkArgument(
+              Strings.isNullOrEmpty(methodName), "missing service name for method %s", methodName);
+          checkArgument(
+              defaultMethodConfig == null,
+              "Duplicate default method config in service config %s",
+              serviceConfig);
+          defaultMethodConfig = info;
+        } else if (Strings.isNullOrEmpty(methodName)) {
+          // Service scoped config
+          checkArgument(
+              !serviceMap.containsKey(serviceName), "Duplicate service %s", serviceName);
+          serviceMap.put(serviceName, info);
+        } else {
+          // Method scoped config
+          String fullMethodName = MethodDescriptor.generateFullMethodName(serviceName, methodName);
+          checkArgument(
+              !serviceMethodMap.containsKey(fullMethodName),
+              "Duplicate method name %s",
+              fullMethodName);
+          serviceMethodMap.put(fullMethodName, info);
+        }
+      }
+    }
+
+    return
+        new ManagedChannelServiceConfig(
+            defaultMethodConfig,
+            serviceMethodMap,
+            serviceMap,
+            retryThrottling,
+            loadBalancingConfig,
+            healthCheckingConfig);
+  }
+
+  @Nullable
+  Map<String, ?> getHealthCheckingConfig() {
+    return healthCheckingConfig;
+  }
+
+  /**
+   * Used as a fallback per-RPC config supplier when the attributes value of {@link
+   * InternalConfigSelector#KEY} is not available. Returns {@code null} if there is no method
+   * config in this service config.
+   */
+  @Nullable
+  InternalConfigSelector getDefaultConfigSelector() {
+    if (serviceMap.isEmpty() && serviceMethodMap.isEmpty() && defaultMethodConfig == null) {
+      return null;
+    }
+    return new ServiceConfigConvertedSelector(this);
+  }
+
+  @VisibleForTesting
+  @Nullable
+  Object getLoadBalancingConfig() {
+    return loadBalancingConfig;
+  }
+
+  @Nullable
+  Throttle getRetryThrottling() {
+    return retryThrottling;
+  }
+
+  @Nullable
+  MethodInfo getMethodConfig(MethodDescriptor<?, ?> method) {
+    MethodInfo methodInfo = serviceMethodMap.get(method.getFullMethodName());
+    if (methodInfo == null) {
+      String serviceName = method.getServiceName();
+      methodInfo = serviceMap.get(serviceName);
+    }
+    if (methodInfo == null) {
+      methodInfo = defaultMethodConfig;
+    }
+    return methodInfo;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    ManagedChannelServiceConfig that = (ManagedChannelServiceConfig) o;
+    return Objects.equal(defaultMethodConfig, that.defaultMethodConfig)
+        && Objects.equal(serviceMethodMap, that.serviceMethodMap)
+        && Objects.equal(serviceMap, that.serviceMap)
+        && Objects.equal(retryThrottling, that.retryThrottling)
+        && Objects.equal(loadBalancingConfig, that.loadBalancingConfig);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(
+        defaultMethodConfig, serviceMethodMap, serviceMap, retryThrottling, loadBalancingConfig);
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("defaultMethodConfig", defaultMethodConfig)
+        .add("serviceMethodMap", serviceMethodMap)
+        .add("serviceMap", serviceMap)
+        .add("retryThrottling", retryThrottling)
+        .add("loadBalancingConfig", loadBalancingConfig)
+        .toString();
+  }
+
+  /**
+   * Equivalent of MethodConfig from a ServiceConfig with restrictions from Channel setting.
+   */
+  static final class MethodInfo {
+    static final CallOptions.Key<MethodInfo> KEY =
+        CallOptions.Key.create("io.grpc.internal.ManagedChannelServiceConfig.MethodInfo");
+
+    // TODO(carl-mastrangelo): add getters for these fields and make them private.
+    final Long timeoutNanos;
+    final Boolean waitForReady;
+    final Integer maxInboundMessageSize;
+    final Integer maxOutboundMessageSize;
+    final RetryPolicy retryPolicy;
+    final HedgingPolicy hedgingPolicy;
+
+    /**
+     * Constructor.
+     *
+     * @param retryEnabled when false, the argument maxRetryAttemptsLimit will have no effect.
+     */
+    MethodInfo(
+        Map<String, ?> methodConfig, boolean retryEnabled, int maxRetryAttemptsLimit,
+        int maxHedgedAttemptsLimit) {
+      timeoutNanos = ServiceConfigUtil.getTimeoutFromMethodConfig(methodConfig);
+      waitForReady = ServiceConfigUtil.getWaitForReadyFromMethodConfig(methodConfig);
+      maxInboundMessageSize =
+          ServiceConfigUtil.getMaxResponseMessageBytesFromMethodConfig(methodConfig);
+      if (maxInboundMessageSize != null) {
+        checkArgument(
+            maxInboundMessageSize >= 0,
+            "maxInboundMessageSize %s exceeds bounds", maxInboundMessageSize);
+      }
+      maxOutboundMessageSize =
+          ServiceConfigUtil.getMaxRequestMessageBytesFromMethodConfig(methodConfig);
+      if (maxOutboundMessageSize != null) {
+        checkArgument(
+            maxOutboundMessageSize >= 0,
+            "maxOutboundMessageSize %s exceeds bounds", maxOutboundMessageSize);
+      }
+
+      Map<String, ?> retryPolicyMap =
+          retryEnabled ? ServiceConfigUtil.getRetryPolicyFromMethodConfig(methodConfig) : null;
+      retryPolicy = retryPolicyMap == null
+          ? null : retryPolicy(retryPolicyMap, maxRetryAttemptsLimit);
+
+      Map<String, ?> hedgingPolicyMap =
+          retryEnabled ? ServiceConfigUtil.getHedgingPolicyFromMethodConfig(methodConfig) : null;
+      hedgingPolicy = hedgingPolicyMap == null
+          ? null : hedgingPolicy(hedgingPolicyMap, maxHedgedAttemptsLimit);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(
+          timeoutNanos,
+          waitForReady,
+          maxInboundMessageSize,
+          maxOutboundMessageSize,
+          retryPolicy,
+          hedgingPolicy);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+      if (!(other instanceof MethodInfo)) {
+        return false;
+      }
+      MethodInfo that = (MethodInfo) other;
+      return Objects.equal(this.timeoutNanos, that.timeoutNanos)
+          && Objects.equal(this.waitForReady, that.waitForReady)
+          && Objects.equal(this.maxInboundMessageSize, that.maxInboundMessageSize)
+          && Objects.equal(this.maxOutboundMessageSize, that.maxOutboundMessageSize)
+          && Objects.equal(this.retryPolicy, that.retryPolicy)
+          && Objects.equal(this.hedgingPolicy, that.hedgingPolicy);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("timeoutNanos", timeoutNanos)
+          .add("waitForReady", waitForReady)
+          .add("maxInboundMessageSize", maxInboundMessageSize)
+          .add("maxOutboundMessageSize", maxOutboundMessageSize)
+          .add("retryPolicy", retryPolicy)
+          .add("hedgingPolicy", hedgingPolicy)
+          .toString();
+    }
+
+    private static RetryPolicy retryPolicy(Map<String, ?> retryPolicy, int maxAttemptsLimit) {
+      int maxAttempts = checkNotNull(
+          ServiceConfigUtil.getMaxAttemptsFromRetryPolicy(retryPolicy),
+          "maxAttempts cannot be empty");
+      checkArgument(maxAttempts >= 2, "maxAttempts must be greater than 1: %s", maxAttempts);
+      maxAttempts = Math.min(maxAttempts, maxAttemptsLimit);
+
+      long initialBackoffNanos = checkNotNull(
+          ServiceConfigUtil.getInitialBackoffNanosFromRetryPolicy(retryPolicy),
+          "initialBackoff cannot be empty");
+      checkArgument(
+          initialBackoffNanos > 0,
+          "initialBackoffNanos must be greater than 0: %s",
+          initialBackoffNanos);
+
+      long maxBackoffNanos = checkNotNull(
+          ServiceConfigUtil.getMaxBackoffNanosFromRetryPolicy(retryPolicy),
+          "maxBackoff cannot be empty");
+      checkArgument(
+          maxBackoffNanos > 0, "maxBackoff must be greater than 0: %s", maxBackoffNanos);
+
+      double backoffMultiplier = checkNotNull(
+          ServiceConfigUtil.getBackoffMultiplierFromRetryPolicy(retryPolicy),
+          "backoffMultiplier cannot be empty");
+      checkArgument(
+          backoffMultiplier > 0,
+          "backoffMultiplier must be greater than 0: %s",
+          backoffMultiplier);
+
+      Long perAttemptRecvTimeout =
+          ServiceConfigUtil.getPerAttemptRecvTimeoutNanosFromRetryPolicy(retryPolicy);
+      checkArgument(
+          perAttemptRecvTimeout == null || perAttemptRecvTimeout >= 0,
+          "perAttemptRecvTimeout cannot be negative: %s",
+          perAttemptRecvTimeout);
+
+      Set<Code> retryableCodes =
+          ServiceConfigUtil.getRetryableStatusCodesFromRetryPolicy(retryPolicy);
+      checkArgument(
+          perAttemptRecvTimeout != null || !retryableCodes.isEmpty(),
+          "retryableStatusCodes cannot be empty without perAttemptRecvTimeout");
+
+      return new RetryPolicy(
+          maxAttempts, initialBackoffNanos, maxBackoffNanos, backoffMultiplier,
+          perAttemptRecvTimeout, retryableCodes);
+    }
+
+    private static HedgingPolicy hedgingPolicy(
+        Map<String, ?> hedgingPolicy, int maxAttemptsLimit) {
+      int maxAttempts = checkNotNull(
+          ServiceConfigUtil.getMaxAttemptsFromHedgingPolicy(hedgingPolicy),
+          "maxAttempts cannot be empty");
+      checkArgument(maxAttempts >= 2, "maxAttempts must be greater than 1: %s", maxAttempts);
+      maxAttempts = Math.min(maxAttempts, maxAttemptsLimit);
+
+      long hedgingDelayNanos = checkNotNull(
+          ServiceConfigUtil.getHedgingDelayNanosFromHedgingPolicy(hedgingPolicy),
+          "hedgingDelay cannot be empty");
+      checkArgument(
+          hedgingDelayNanos >= 0, "hedgingDelay must not be negative: %s", hedgingDelayNanos);
+
+      return new HedgingPolicy(
+          maxAttempts, hedgingDelayNanos,
+          ServiceConfigUtil.getNonFatalStatusCodesFromHedgingPolicy(hedgingPolicy));
+    }
+  }
+
+  static final class ServiceConfigConvertedSelector extends InternalConfigSelector {
+
+    final ManagedChannelServiceConfig config;
+
+    /** Converts the service config to config selector. */
+    private ServiceConfigConvertedSelector(ManagedChannelServiceConfig config) {
+      this.config = config;
+    }
+
+    @Override
+    public Result selectConfig(PickSubchannelArgs args) {
+      return Result.newBuilder()
+          .setConfig(config)
+          .build();
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ManagedClientTransport.java b/core/src/main/java/io/grpc/internal/ManagedClientTransport.java
index 2b2c646393e..8350a005409 100644
--- a/core/src/main/java/io/grpc/internal/ManagedClientTransport.java
+++ b/core/src/main/java/io/grpc/internal/ManagedClientTransport.java
@@ -1,38 +1,24 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.Attributes;
 import io.grpc.Status;
-import javax.annotation.CheckReturnValue;
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
 
@@ -48,14 +34,12 @@
  * {@link Listener#transportTerminated}.
  */
 @ThreadSafe
-public interface ManagedClientTransport extends ClientTransport, WithLogId {
+public interface ManagedClientTransport extends ClientTransport {
 
   /**
    * Starts transport. This method may only be called once.
    *
-   * <p>Implementations must not call {@code listener} from within {@link #start}; implementations
-   * are expected to notify listener on a separate thread or when the returned {@link Runnable} is
-   * run. This method and the returned {@code Runnable} should not throw any exceptions.
+   * <p>This method and the returned {@code Runnable} should not throw any exceptions.
    *
    * @param listener non-{@code null} listener of transport events
    * @return a {@link Runnable} that is executed after-the-fact by the original caller, typically
@@ -71,7 +55,7 @@ public interface ManagedClientTransport extends ClientTransport, WithLogId {
    * {@link Listener#transportShutdown} callback called), or be transferred off this transport (in
    * which case they may succeed).  This method may only be called once.
    */
-  void shutdown();
+  void shutdown(Status reason);
 
   /**
    * Initiates a forceful shutdown in which preexisting and new calls are closed. Existing calls
@@ -93,8 +77,9 @@ interface Listener {
      * <p>This is called exactly once, and must be called prior to {@link #transportTerminated}.
      *
      * @param s the reason for the shutdown.
+     * @param e the disconnect error.
      */
-    void transportShutdown(Status s);
+    void transportShutdown(Status s, DisconnectError e);
 
     /**
      * The transport completed shutting down. All resources have been released. All streams have
@@ -109,6 +94,8 @@ interface Listener {
     /**
      * The transport is ready to accept traffic, because the connection is established.  This is
      * called at most once.
+     *
+     * <p>Streams created before this milestone are not guaranteed to function.
      */
     void transportReady();
 
@@ -117,5 +104,13 @@ interface Listener {
      * at least one stream.
      */
     void transportInUse(boolean inUse);
+
+    /**
+     * Called just before {@link #transportReady} to allow direct modification of transport
+     * Attributes.
+     */
+    default Attributes filterTransport(Attributes attributes) {
+      return attributes;
+    }
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/MaxConnectionIdleManager.java b/core/src/main/java/io/grpc/internal/MaxConnectionIdleManager.java
new file mode 100644
index 00000000000..4d4a36dda01
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/MaxConnectionIdleManager.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2017 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.internal;
+
+import com.google.common.annotations.VisibleForTesting;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.CheckForNull;
+
+/**
+ * Monitors connection idle time; shutdowns the connection if the max connection idle is reached.
+ */
+public final class MaxConnectionIdleManager {
+  private static final Ticker systemTicker = new Ticker() {
+    @Override
+    public long nanoTime() {
+      return System.nanoTime();
+    }
+  };
+
+  private final long maxConnectionIdleInNanos;
+  private final Ticker ticker;
+
+  @CheckForNull
+  private ScheduledFuture<?> shutdownFuture;
+  private Runnable shutdownTask;
+  private ScheduledExecutorService scheduler;
+  private long nextIdleMonitorTime;
+  private boolean shutdownDelayed;
+  private boolean isActive;
+
+  public MaxConnectionIdleManager(long maxConnectionIdleInNanos) {
+    this(maxConnectionIdleInNanos, systemTicker);
+  }
+
+  @VisibleForTesting
+  public MaxConnectionIdleManager(long maxConnectionIdleInNanos, Ticker ticker) {
+    this.maxConnectionIdleInNanos = maxConnectionIdleInNanos;
+    this.ticker = ticker;
+  }
+
+  /**
+   * Start the initial scheduled shutdown given the transport status reaches max connection idle.
+   *
+   * @param closeJob Closes the connection by sending GO_AWAY with status code NO_ERROR and ASCII
+   *     debug data max_idle and then doing the graceful connection termination.
+   */
+  public void start(final Runnable closeJob, final ScheduledExecutorService scheduler) {
+    this.scheduler = scheduler;
+    nextIdleMonitorTime = ticker.nanoTime() + maxConnectionIdleInNanos;
+
+    shutdownTask = new LogExceptionRunnable(new Runnable() {
+      @Override
+      public void run() {
+        if (shutdownDelayed) {
+          if (!isActive) {
+            // delay shutdown
+            shutdownFuture = scheduler.schedule(
+                shutdownTask, nextIdleMonitorTime - ticker.nanoTime(), TimeUnit.NANOSECONDS);
+            shutdownDelayed = false;
+          }
+          // if isActive, exit. Will schedule a new shutdownFuture once onTransportIdle
+        } else {
+          closeJob.run();
+          shutdownFuture = null;
+        }
+      }
+    });
+
+    shutdownFuture =
+        scheduler.schedule(shutdownTask, maxConnectionIdleInNanos, TimeUnit.NANOSECONDS);
+  }
+
+
+  /** There are outstanding RPCs on the transport. */
+  public void onTransportActive() {
+    isActive = true;
+    shutdownDelayed = true;
+  }
+
+  /** There are no outstanding RPCs on the transport. */
+  public void onTransportIdle() {
+    isActive = false;
+    if (shutdownFuture == null) {
+      return;
+    }
+    if (shutdownFuture.isDone()) {
+      shutdownDelayed = false;
+      shutdownFuture = scheduler
+          .schedule(shutdownTask, maxConnectionIdleInNanos, TimeUnit.NANOSECONDS);
+    } else {
+      nextIdleMonitorTime = ticker.nanoTime() + maxConnectionIdleInNanos;
+    }
+  }
+
+  /** Transport is being terminated. */
+  public void onTransportTermination() {
+    if (shutdownFuture != null) {
+      shutdownFuture.cancel(false);
+      shutdownFuture = null;
+    }
+  }
+
+  @VisibleForTesting
+  public interface Ticker {
+    long nanoTime();
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/MessageDeframer.java b/core/src/main/java/io/grpc/internal/MessageDeframer.java
index 654acbd02e1..13a01efec0a 100644
--- a/core/src/main/java/io/grpc/internal/MessageDeframer.java
+++ b/core/src/main/java/io/grpc/internal/MessageDeframer.java
@@ -1,40 +1,26 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
 import io.grpc.Codec;
 import io.grpc.Decompressor;
 import io.grpc.Status;
@@ -42,22 +28,26 @@
 import java.io.FilterInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.Locale;
+import java.util.zip.DataFormatException;
+import javax.annotation.Nullable;
 import javax.annotation.concurrent.NotThreadSafe;
 
 /**
  * Deframer for GRPC frames.
  *
- * <p>This class is not thread-safe. All calls to public methods should be made in the transport
- * thread.
+ * <p>This class is not thread-safe. Unless otherwise stated, all calls to public methods should be
+ * made in the deframing thread.
  */
 @NotThreadSafe
-public class MessageDeframer implements Closeable {
+public class MessageDeframer implements Closeable, Deframer {
   private static final int HEADER_LENGTH = 5;
   private static final int COMPRESSED_FLAG_MASK = 1;
   private static final int RESERVED_MASK = 0xFE;
+  private static final int MAX_BUFFER_SIZE = 1024 * 1024 * 2;
 
   /**
-   * A listener of deframing events.
+   * A listener of deframing events. These methods will be invoked from the deframing thread.
    */
   public interface Listener {
 
@@ -73,84 +63,98 @@ public interface Listener {
     /**
      * Called to deliver the next complete message.
      *
-     * @param is stream containing the message.
+     * @param producer single message producer wrapping the message.
      */
-    void messageRead(InputStream is);
+    void messagesAvailable(StreamListener.MessageProducer producer);
 
     /**
-     * Called when end-of-stream has not yet been reached but there are no complete messages
-     * remaining to be delivered.
+     * Called when the deframer closes.
+     *
+     * @param hasPartialMessage whether the deframer contained an incomplete message at closing.
      */
-    void deliveryStalled();
+    void deframerClosed(boolean hasPartialMessage);
 
     /**
-     * Called when the stream is complete and all messages have been successfully delivered.
+     * Called when a {@link #deframe(ReadableBuffer)} operation failed.
+     *
+     * @param cause the actual failure
      */
-    void endOfStream();
+    void deframeFailed(Throwable cause);
   }
 
   private enum State {
     HEADER, BODY
   }
 
-  private final Listener listener;
+  private Listener listener;
   private int maxInboundMessageSize;
   private final StatsTraceContext statsTraceCtx;
-  private final String debugString;
+  private final TransportTracer transportTracer;
   private Decompressor decompressor;
+  private GzipInflatingBuffer fullStreamDecompressor;
+  private byte[] inflatedBuffer;
+  private int inflatedIndex;
   private State state = State.HEADER;
   private int requiredLength = HEADER_LENGTH;
   private boolean compressedFlag;
-  private boolean endOfStream;
   private CompositeReadableBuffer nextFrame;
   private CompositeReadableBuffer unprocessed = new CompositeReadableBuffer();
   private long pendingDeliveries;
-  private boolean deliveryStalled = true;
   private boolean inDelivery = false;
+  private int currentMessageSeqNo = -1;
+  private int inboundBodyWireSize;
+
+  private boolean closeWhenComplete = false;
+  private volatile boolean stopDelivery = false;
 
   /**
    * Create a deframer.
    *
    * @param listener listener for deframer events.
    * @param decompressor the compression used if a compressed frame is encountered, with
-   *  {@code NONE} meaning unsupported
+   *                     {@code NONE} meaning unsupported
    * @param maxMessageSize the maximum allowed size for received messages.
-   * @param debugString a string that will appear on errors statuses
    */
-  public MessageDeframer(Listener listener, Decompressor decompressor, int maxMessageSize,
-      StatsTraceContext statsTraceCtx, String debugString) {
-    this.listener = Preconditions.checkNotNull(listener, "sink");
-    this.decompressor = Preconditions.checkNotNull(decompressor, "decompressor");
+  public MessageDeframer(
+      Listener listener,
+      Decompressor decompressor,
+      int maxMessageSize,
+      StatsTraceContext statsTraceCtx,
+      TransportTracer transportTracer) {
+    this.listener = checkNotNull(listener, "sink");
+    this.decompressor = checkNotNull(decompressor, "decompressor");
     this.maxInboundMessageSize = maxMessageSize;
     this.statsTraceCtx = checkNotNull(statsTraceCtx, "statsTraceCtx");
-    this.debugString = debugString;
+    this.transportTracer = checkNotNull(transportTracer, "transportTracer");
   }
 
-  void setMaxInboundMessageSize(int messageSize) {
+  void setListener(Listener listener) {
+    this.listener = listener;
+  }
+
+  @Override
+  public void setMaxInboundMessageSize(int messageSize) {
     maxInboundMessageSize = messageSize;
   }
 
-  /**
-   * Sets the decompressor available to use.  The message encoding for the stream comes later in
-   * time, and thus will not be available at the time of construction.  This should only be set
-   * once, since the compression codec cannot change after the headers have been sent.
-   *
-   * @param decompressor the decompressing wrapper.
-   */
+  @Override
   public void setDecompressor(Decompressor decompressor) {
+    checkState(fullStreamDecompressor == null, "Already set full stream decompressor");
     this.decompressor = checkNotNull(decompressor, "Can't pass an empty decompressor");
   }
 
-  /**
-   * Requests up to the given number of messages from the call to be delivered to
-   * {@link Listener#messageRead(InputStream)}. No additional messages will be delivered.
-   *
-   * <p>If {@link #close()} has been called, this method will have no effect.
-   *
-   * @param numMessages the requested number of messages to be delivered to the listener.
-   */
+  @Override
+  public void setFullStreamDecompressor(GzipInflatingBuffer fullStreamDecompressor) {
+    checkState(decompressor == Codec.Identity.NONE, "per-message decompressor already set");
+    checkState(this.fullStreamDecompressor == null, "full stream decompressor already set");
+    this.fullStreamDecompressor =
+        checkNotNull(fullStreamDecompressor, "Can't pass a null full stream decompressor");
+    unprocessed = null;
+  }
+
+  @Override
   public void request(int numMessages) {
-    Preconditions.checkArgument(numMessages > 0, "numMessages must be > 0");
+    checkArgument(numMessages > 0, "numMessages must be > 0");
     if (isClosed()) {
       return;
     }
@@ -158,29 +162,21 @@ public void request(int numMessages) {
     deliver();
   }
 
-  /**
-   * Adds the given data to this deframer and attempts delivery to the listener.
-   *
-   * @param data the raw data read from the remote endpoint. Must be non-null.
-   * @param endOfStream if {@code true}, indicates that {@code data} is the end of the stream from
-   *        the remote endpoint.  End of stream should not be used in the event of a transport
-   *        error, such as a stream reset.
-   * @throws IllegalStateException if {@link #close()} has been called previously or if
-   *         this method has previously been called with {@code endOfStream=true}.
-   */
-  public void deframe(ReadableBuffer data, boolean endOfStream) {
-    Preconditions.checkNotNull(data, "data");
+  @Override
+  public void deframe(ReadableBuffer data) {
+    checkNotNull(data, "data");
     boolean needToCloseData = true;
     try {
-      checkNotClosed();
-      Preconditions.checkState(!this.endOfStream, "Past end of stream");
-
-      unprocessed.addBuffer(data);
-      needToCloseData = false;
+      if (!isClosedOrScheduledToClose()) {
+        if (fullStreamDecompressor != null) {
+          fullStreamDecompressor.addGzippedBytes(data);
+        } else {
+          unprocessed.addBuffer(data);
+        }
+        needToCloseData = false;
 
-      // Indicate that all of the data for this stream has been received.
-      this.endOfStream = endOfStream;
-      deliver();
+        deliver();
+      }
     } finally {
       if (needToCloseData) {
         data.close();
@@ -188,21 +184,42 @@ public void deframe(ReadableBuffer data, boolean endOfStream) {
     }
   }
 
-  /**
-   * Indicates whether delivery is currently stalled, pending receipt of more data.  This means
-   * that no additional data can be delivered to the application.
-   */
-  public boolean isStalled() {
-    return deliveryStalled;
+  @Override
+  public void closeWhenComplete() {
+    if (isClosed()) {
+      return;
+    } else if (isStalled()) {
+      close();
+    } else {
+      closeWhenComplete = true;
+    }
   }
 
   /**
-   * Closes this deframer and frees any resources. After this method is called, additional
-   * calls will have no effect.
+   * Sets a flag to interrupt delivery of any currently queued messages. This may be invoked outside
+   * of the deframing thread, and must be followed by a call to {@link #close()} in the deframing
+   * thread. Without a subsequent call to {@link #close()}, the deframer may hang waiting for
+   * additional messages before noticing that the {@code stopDelivery} flag has been set.
    */
+  void stopDelivery() {
+    stopDelivery = true;
+  }
+
+  boolean hasPendingDeliveries() {
+    return pendingDeliveries != 0;
+  }
+
   @Override
   public void close() {
+    if (isClosed()) {
+      return;
+    }
+    boolean hasPartialMessage = nextFrame != null && nextFrame.readableBytes() > 0;
     try {
+      if (fullStreamDecompressor != null) {
+        hasPartialMessage = hasPartialMessage || fullStreamDecompressor.hasPartialData();
+        fullStreamDecompressor.close();
+      }
       if (unprocessed != null) {
         unprocessed.close();
       }
@@ -210,23 +227,31 @@ public void close() {
         nextFrame.close();
       }
     } finally {
+      fullStreamDecompressor = null;
       unprocessed = null;
       nextFrame = null;
     }
+    listener.deframerClosed(hasPartialMessage);
   }
 
   /**
    * Indicates whether or not this deframer has been closed.
    */
   public boolean isClosed() {
-    return unprocessed == null;
+    return unprocessed == null && fullStreamDecompressor == null;
   }
 
-  /**
-   * Throws if this deframer has already been closed.
-   */
-  private void checkNotClosed() {
-    Preconditions.checkState(!isClosed(), "MessageDeframer is already closed");
+  /** Returns true if this deframer has already been closed or scheduled to close. */
+  private boolean isClosedOrScheduledToClose() {
+    return isClosed() || closeWhenComplete;
+  }
+
+  private boolean isStalled() {
+    if (fullStreamDecompressor != null) {
+      return fullStreamDecompressor.isStalled();
+    } else {
+      return unprocessed.readableBytes() == 0;
+    }
   }
 
   /**
@@ -241,7 +266,7 @@ private void deliver() {
     inDelivery = true;
     try {
       // Process the uncompressed bytes.
-      while (pendingDeliveries > 0 && readRequiredBytes()) {
+      while (!stopDelivery && pendingDeliveries > 0 && readRequiredBytes()) {
         switch (state) {
           case HEADER:
             processHeader();
@@ -259,6 +284,11 @@ private void deliver() {
         }
       }
 
+      if (stopDelivery) {
+        close();
+        return;
+      }
+
       /*
        * We are stalled when there are no more bytes to process. This allows delivering errors as
        * soon as the buffered input has been consumed, independent of whether the application
@@ -267,27 +297,8 @@ private void deliver() {
        * frame and not in unprocessed.  If there is extra data but no pending deliveries, it will
        * be in unprocessed.
        */
-      boolean stalled = unprocessed.readableBytes() == 0;
-
-      if (endOfStream && stalled) {
-        boolean havePartialMessage = nextFrame != null && nextFrame.readableBytes() > 0;
-        if (!havePartialMessage) {
-          listener.endOfStream();
-          deliveryStalled = false;
-          return;
-        } else {
-          // We've received the entire stream and have data available but we don't have
-          // enough to read the next frame ... this is bad.
-          throw Status.INTERNAL.withDescription(
-              debugString + ": Encountered end-of-stream mid-frame").asRuntimeException();
-        }
-      }
-
-      // If we're transitioning to the stalled state, notify the listener.
-      boolean previouslyStalled = deliveryStalled;
-      deliveryStalled = stalled;
-      if (stalled && !previouslyStalled) {
-        listener.deliveryStalled();
+      if (closeWhenComplete && isStalled()) {
+        close();
       }
     } finally {
       inDelivery = false;
@@ -301,6 +312,7 @@ private void deliver() {
    */
   private boolean readRequiredBytes() {
     int totalBytesRead = 0;
+    int deflatedBytesRead = 0;
     try {
       if (nextFrame == null) {
         nextFrame = new CompositeReadableBuffer();
@@ -309,20 +321,50 @@ private boolean readRequiredBytes() {
       // Read until the buffer contains all the required bytes.
       int missingBytes;
       while ((missingBytes = requiredLength - nextFrame.readableBytes()) > 0) {
-        if (unprocessed.readableBytes() == 0) {
-          // No more data is available.
-          return false;
+        if (fullStreamDecompressor != null) {
+          try {
+            if (inflatedBuffer == null || inflatedIndex == inflatedBuffer.length) {
+              inflatedBuffer = new byte[Math.min(missingBytes, MAX_BUFFER_SIZE)];
+              inflatedIndex = 0;
+            }
+            int bytesToRead = Math.min(missingBytes, inflatedBuffer.length - inflatedIndex);
+            int n = fullStreamDecompressor.inflateBytes(inflatedBuffer, inflatedIndex, bytesToRead);
+            totalBytesRead += fullStreamDecompressor.getAndResetBytesConsumed();
+            deflatedBytesRead += fullStreamDecompressor.getAndResetDeflatedBytesConsumed();
+            if (n == 0) {
+              // No more inflated data is available.
+              return false;
+            }
+            nextFrame.addBuffer(ReadableBuffers.wrap(inflatedBuffer, inflatedIndex, n));
+            inflatedIndex += n;
+          } catch (IOException e) {
+            throw new RuntimeException(e);
+          } catch (DataFormatException e) {
+            throw new RuntimeException(e);
+          }
+        } else {
+          if (unprocessed.readableBytes() == 0) {
+            // No more data is available.
+            return false;
+          }
+          int toRead = Math.min(missingBytes, unprocessed.readableBytes());
+          totalBytesRead += toRead;
+          nextFrame.addBuffer(unprocessed.readBytes(toRead));
         }
-        int toRead = Math.min(missingBytes, unprocessed.readableBytes());
-        totalBytesRead += toRead;
-        nextFrame.addBuffer(unprocessed.readBytes(toRead));
       }
       return true;
     } finally {
       if (totalBytesRead > 0) {
         listener.bytesRead(totalBytesRead);
         if (state == State.BODY) {
-          statsTraceCtx.wireBytesReceived(totalBytesRead);
+          if (fullStreamDecompressor != null) {
+            // With compressed streams, totalBytesRead can include gzip header and trailer metadata
+            statsTraceCtx.inboundWireSize(deflatedBytesRead);
+            inboundBodyWireSize += deflatedBytesRead;
+          } else {
+            statsTraceCtx.inboundWireSize(totalBytesRead);
+            inboundBodyWireSize += totalBytesRead;
+          }
         }
       }
     }
@@ -336,7 +378,7 @@ private void processHeader() {
     int type = nextFrame.readUnsignedByte();
     if ((type & RESERVED_MASK) != 0) {
       throw Status.INTERNAL.withDescription(
-          debugString + ": Frame header malformed: reserved bits not zero")
+          "gRPC frame header malformed: reserved bits not zero")
           .asRuntimeException();
     }
     compressedFlag = (type & COMPRESSED_FLAG_MASK) != 0;
@@ -344,22 +386,33 @@ private void processHeader() {
     // Update the required length to include the length of the frame.
     requiredLength = nextFrame.readInt();
     if (requiredLength < 0 || requiredLength > maxInboundMessageSize) {
-      throw Status.INTERNAL.withDescription(String.format("%s: Frame size %d exceeds maximum: %d. ",
-              debugString, requiredLength, maxInboundMessageSize)).asRuntimeException();
+      throw Status.RESOURCE_EXHAUSTED.withDescription(
+          String.format(Locale.US, "gRPC message exceeds maximum size %d: %d",
+              maxInboundMessageSize, requiredLength))
+          .asRuntimeException();
     }
 
+    currentMessageSeqNo++;
+    statsTraceCtx.inboundMessage(currentMessageSeqNo);
+    transportTracer.reportMessageReceived();
     // Continue reading the frame body.
     state = State.BODY;
   }
 
   /**
-   * Processes the body of the GRPC compression frame. A single compression frame may contain
-   * several GRPC messages within it.
+   * Processes the GRPC message body, which depending on frame header flags may be compressed.
    */
   private void processBody() {
+    // There is no reliable way to get the uncompressed size per message when it's compressed,
+    // because the uncompressed bytes are provided through an InputStream whose total size is
+    // unknown until all bytes are read, and we don't know when it happens.
+    statsTraceCtx.inboundMessageRead(currentMessageSeqNo, inboundBodyWireSize,
+        (compressedFlag || fullStreamDecompressor != null) ? -1 : inboundBodyWireSize);
+    inboundBodyWireSize = 0;
     InputStream stream = compressedFlag ? getCompressedBody() : getUncompressedBody();
+    nextFrame.touch();
     nextFrame = null;
-    listener.messageRead(stream);
+    listener.messagesAvailable(new SingleMessageProducer(stream));
 
     // Done with this frame, begin processing the next header.
     state = State.HEADER;
@@ -367,14 +420,14 @@ private void processBody() {
   }
 
   private InputStream getUncompressedBody() {
-    statsTraceCtx.uncompressedBytesReceived(nextFrame.readableBytes());
+    statsTraceCtx.inboundUncompressedSize(nextFrame.readableBytes());
     return ReadableBuffers.openStream(nextFrame, true);
   }
 
   private InputStream getCompressedBody() {
     if (decompressor == Codec.Identity.NONE) {
       throw Status.INTERNAL.withDescription(
-          debugString + ": Can't decode compressed frame as compression not configured.")
+          "Can't decode compressed gRPC message as compression not configured")
           .asRuntimeException();
     }
 
@@ -383,7 +436,7 @@ private InputStream getCompressedBody() {
       InputStream unlimitedStream =
           decompressor.decompress(ReadableBuffers.openStream(nextFrame, true));
       return new SizeEnforcingInputStream(
-          unlimitedStream, maxInboundMessageSize, statsTraceCtx, debugString);
+          unlimitedStream, maxInboundMessageSize, statsTraceCtx);
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
@@ -396,17 +449,14 @@ private InputStream getCompressedBody() {
   static final class SizeEnforcingInputStream extends FilterInputStream {
     private final int maxMessageSize;
     private final StatsTraceContext statsTraceCtx;
-    private final String debugString;
     private long maxCount;
     private long count;
     private long mark = -1;
 
-    SizeEnforcingInputStream(InputStream in, int maxMessageSize, StatsTraceContext statsTraceCtx,
-        String debugString) {
+    SizeEnforcingInputStream(InputStream in, int maxMessageSize, StatsTraceContext statsTraceCtx) {
       super(in);
       this.maxMessageSize = maxMessageSize;
       this.statsTraceCtx = statsTraceCtx;
-      this.debugString = debugString;
     }
 
     @Override
@@ -462,17 +512,33 @@ public synchronized void reset() throws IOException {
 
     private void reportCount() {
       if (count > maxCount) {
-        statsTraceCtx.uncompressedBytesReceived(count - maxCount);
+        statsTraceCtx.inboundUncompressedSize(count - maxCount);
         maxCount = count;
       }
     }
 
     private void verifySize() {
       if (count > maxMessageSize) {
-        throw Status.INTERNAL.withDescription(String.format(
-                "%s: Compressed frame exceeds maximum frame size: %d. Bytes read: %d. ",
-                debugString, maxMessageSize, count)).asRuntimeException();
+        throw Status.RESOURCE_EXHAUSTED
+            .withDescription("Decompressed gRPC message exceeds maximum size " + maxMessageSize)
+            .asRuntimeException();
       }
     }
   }
+
+  private static class SingleMessageProducer implements StreamListener.MessageProducer {
+    private InputStream message;
+
+    private SingleMessageProducer(InputStream message) {
+      this.message = message;
+    }
+
+    @Nullable
+    @Override
+    public InputStream next() {
+      InputStream messageToReturn = message;
+      message = null;
+      return messageToReturn;
+    }
+  }
 }
diff --git a/core/src/main/java/io/grpc/internal/MessageFramer.java b/core/src/main/java/io/grpc/internal/MessageFramer.java
index 3bf64c38273..8b5ccb864a4 100644
--- a/core/src/main/java/io/grpc/internal/MessageFramer.java
+++ b/core/src/main/java/io/grpc/internal/MessageFramer.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -42,6 +27,7 @@
 import io.grpc.Drainable;
 import io.grpc.KnownLength;
 import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -49,13 +35,14 @@
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
 import javax.annotation.Nullable;
 
 /**
  * Encodes gRPC messages to be delivered via the transport layer which implements {@link
  * MessageFramer.Sink}.
  */
-public class MessageFramer {
+public class MessageFramer implements Framer {
 
   private static final int NO_MAX_OUTBOUND_MESSAGE_SIZE = -1;
 
@@ -71,8 +58,13 @@ public interface Sink {
      *              closed and there is no data to deliver.
      * @param endOfStream whether the frame is the last one for the GRPC stream
      * @param flush {@code true} if more data may not be arriving soon
+     * @param numMessages the number of messages that this series of frames represents
      */
-    void deliverFrame(@Nullable WritableBuffer frame, boolean endOfStream, boolean flush);
+    void deliverFrame(
+        @Nullable WritableBuffer frame,
+        boolean endOfStream,
+        boolean flush,
+        int numMessages);
   }
 
   private static final int HEADER_LENGTH = 5;
@@ -83,38 +75,51 @@ public interface Sink {
   // effectively final.  Can only be set once.
   private int maxOutboundMessageSize = NO_MAX_OUTBOUND_MESSAGE_SIZE;
   private WritableBuffer buffer;
+  /**
+   * if &gt; 0 - the number of bytes to allocate for the current known-length message.
+   */
+  private int knownLengthPendingAllocation;
   private Compressor compressor = Codec.Identity.NONE;
   private boolean messageCompression = true;
   private final OutputStreamAdapter outputStreamAdapter = new OutputStreamAdapter();
-  private final byte[] headerScratch = new byte[HEADER_LENGTH];
+  private final ByteBuffer headerScratch = ByteBuffer.allocate(HEADER_LENGTH);
   private final WritableBufferAllocator bufferAllocator;
   private final StatsTraceContext statsTraceCtx;
+  // transportTracer is nullable until it is integrated with client transports
   private boolean closed;
 
+  // Tracing and stats-related states
+  private int messagesBuffered;
+  private int currentMessageSeqNo = -1;
+  private long currentMessageWireSize;
+
   /**
    * Creates a {@code MessageFramer}.
    *
    * @param sink the sink used to deliver frames to the transport
    * @param bufferAllocator allocates buffers that the transport can commit to the wire.
    */
-  public MessageFramer(Sink sink, WritableBufferAllocator bufferAllocator,
-      StatsTraceContext statsTraceCtx) {
+  public MessageFramer(
+      Sink sink, WritableBufferAllocator bufferAllocator, StatsTraceContext statsTraceCtx) {
     this.sink = checkNotNull(sink, "sink");
     this.bufferAllocator = checkNotNull(bufferAllocator, "bufferAllocator");
     this.statsTraceCtx = checkNotNull(statsTraceCtx, "statsTraceCtx");
   }
 
-  MessageFramer setCompressor(Compressor compressor) {
+  @Override
+  public MessageFramer setCompressor(Compressor compressor) {
     this.compressor = checkNotNull(compressor, "Can't pass an empty compressor");
     return this;
   }
 
-  MessageFramer setMessageCompression(boolean enable) {
+  @Override
+  public MessageFramer setMessageCompression(boolean enable) {
     messageCompression = enable;
     return this;
   }
 
-  void setMaxOutboundMessageSize(int maxSize) {
+  @Override
+  public void setMaxOutboundMessageSize(int maxSize) {
     checkState(maxOutboundMessageSize == NO_MAX_OUTBOUND_MESSAGE_SIZE, "max size already set");
     maxOutboundMessageSize = maxSize;
   }
@@ -124,8 +129,13 @@ void setMaxOutboundMessageSize(int maxSize) {
    *
    * @param message contains the message to be written out. It will be completely consumed.
    */
+  @Override
   public void writePayload(InputStream message) {
     verifyNotClosed();
+    messagesBuffered++;
+    currentMessageSeqNo++;
+    currentMessageWireSize = 0;
+    statsTraceCtx.outboundMessage(currentMessageSeqNo);
     boolean compressed = messageCompression && compressor != Codec.Identity.NONE;
     int written = -1;
     int messageLength = -2;
@@ -142,6 +152,8 @@ public void writePayload(InputStream message) {
           .withDescription("Failed to frame message")
           .withCause(e)
           .asRuntimeException();
+    } catch (StatusRuntimeException e) {
+      throw e;
     } catch (RuntimeException e) {
       throw Status.INTERNAL
           .withDescription("Failed to frame message")
@@ -153,27 +165,23 @@ public void writePayload(InputStream message) {
       String err = String.format("Message length inaccurate %s != %s", written, messageLength);
       throw Status.INTERNAL.withDescription(err).asRuntimeException();
     }
-    statsTraceCtx.uncompressedBytesSent(written);
+    statsTraceCtx.outboundUncompressedSize(written);
+    statsTraceCtx.outboundWireSize(currentMessageWireSize);
+    statsTraceCtx.outboundMessageSent(currentMessageSeqNo, currentMessageWireSize, written);
   }
 
   private int writeUncompressed(InputStream message, int messageLength) throws IOException {
     if (messageLength != -1) {
-      statsTraceCtx.wireBytesSent(messageLength);
+      currentMessageWireSize = messageLength;
       return writeKnownLengthUncompressed(message, messageLength);
     }
     BufferChainOutputStream bufferChain = new BufferChainOutputStream();
     int written = writeToOutputStream(message, bufferChain);
-    if (maxOutboundMessageSize >= 0 && written > maxOutboundMessageSize) {
-      throw Status.INTERNAL
-          .withDescription(
-              String.format("message too large %d > %d", written , maxOutboundMessageSize))
-          .asRuntimeException();
-    }
     writeBufferChain(bufferChain, false);
     return written;
   }
 
-  private int writeCompressed(InputStream message, int messageLength) throws IOException {
+  private int writeCompressed(InputStream message, int unusedMessageLength) throws IOException {
     BufferChainOutputStream bufferChain = new BufferChainOutputStream();
 
     OutputStream compressingStream = compressor.compress(bufferChain);
@@ -184,9 +192,10 @@ private int writeCompressed(InputStream message, int messageLength) throws IOExc
       compressingStream.close();
     }
     if (maxOutboundMessageSize >= 0 && written > maxOutboundMessageSize) {
-      throw Status.CANCELLED
+      throw Status.RESOURCE_EXHAUSTED
           .withDescription(
-              String.format("message too large %d > %d", written , maxOutboundMessageSize))
+              String.format(
+                  Locale.US, "message too large %d > %d", written , maxOutboundMessageSize))
           .asRuntimeException();
     }
 
@@ -207,20 +216,18 @@ private int getKnownLength(InputStream inputStream) throws IOException {
   private int writeKnownLengthUncompressed(InputStream message, int messageLength)
       throws IOException {
     if (maxOutboundMessageSize >= 0 && messageLength > maxOutboundMessageSize) {
-      throw Status.CANCELLED
+      throw Status.RESOURCE_EXHAUSTED
           .withDescription(
-              String.format("message too large %d > %d", messageLength , maxOutboundMessageSize))
+              String.format(
+                  Locale.US, "message too large %d > %d", messageLength , maxOutboundMessageSize))
           .asRuntimeException();
     }
-    ByteBuffer header = ByteBuffer.wrap(headerScratch);
-    header.put(UNCOMPRESSED);
-    header.putInt(messageLength);
+    headerScratch.clear();
+    headerScratch.put(UNCOMPRESSED).putInt(messageLength);
     // Allocate the initial buffer chunk based on frame header + payload length.
     // Note that the allocator may allocate a buffer larger or smaller than this length
-    if (buffer == null) {
-      buffer = bufferAllocator.allocate(header.position() + messageLength);
-    }
-    writeRaw(headerScratch, 0, header.position());
+    knownLengthPendingAllocation = HEADER_LENGTH + messageLength;
+    writeRaw(headerScratch.array(), 0, headerScratch.position());
     return writeToOutputStream(message, outputStreamAdapter);
   }
 
@@ -228,12 +235,18 @@ private int writeKnownLengthUncompressed(InputStream message, int messageLength)
    * Write a message that has been serialized to a sequence of buffers.
    */
   private void writeBufferChain(BufferChainOutputStream bufferChain, boolean compressed) {
-    ByteBuffer header = ByteBuffer.wrap(headerScratch);
-    header.put(compressed ? COMPRESSED : UNCOMPRESSED);
     int messageLength = bufferChain.readableBytes();
-    header.putInt(messageLength);
+    if (maxOutboundMessageSize >= 0 && messageLength > maxOutboundMessageSize) {
+      throw Status.RESOURCE_EXHAUSTED
+          .withDescription(
+              String.format(
+                  Locale.US, "message too large %d > %d", messageLength , maxOutboundMessageSize))
+          .asRuntimeException();
+    }
+    headerScratch.clear();
+    headerScratch.put(compressed ? COMPRESSED : UNCOMPRESSED).putInt(messageLength);
     WritableBuffer writeableHeader = bufferAllocator.allocate(HEADER_LENGTH);
-    writeableHeader.write(headerScratch, 0, header.position());
+    writeableHeader.write(headerScratch.array(), 0, headerScratch.position());
     if (messageLength == 0) {
       // the payload had 0 length so make the header the current buffer.
       buffer = writeableHeader;
@@ -242,16 +255,19 @@ private void writeBufferChain(BufferChainOutputStream bufferChain, boolean compr
     // Note that we are always delivering a small message to the transport here which
     // may incur transport framing overhead as it may be sent separately to the contents
     // of the GRPC frame.
-    sink.deliverFrame(writeableHeader, false, false);
+    // The final message may not be completely written because we do not flush the last buffer.
+    // Do not report the last message as sent.
+    sink.deliverFrame(writeableHeader, false, false, messagesBuffered - 1);
+    messagesBuffered = 1;
     // Commit all except the last buffer to the sink
     List<WritableBuffer> bufferList = bufferChain.bufferList;
     for (int i = 0; i < bufferList.size() - 1; i++) {
-      sink.deliverFrame(bufferList.get(i), false, false);
+      sink.deliverFrame(bufferList.get(i), false, false, 0);
     }
     // Assign the current buffer to the last in the chain so it can be used
     // for future writes or written with end-of-stream=true on close.
     buffer = bufferList.get(bufferList.size() - 1);
-    statsTraceCtx.wireBytesSent(messageLength);
+    currentMessageWireSize = messageLength;
   }
 
   private static int writeToOutputStream(InputStream message, OutputStream outputStream)
@@ -260,7 +276,8 @@ private static int writeToOutputStream(InputStream message, OutputStream outputS
       return ((Drainable) message).drainTo(outputStream);
     } else {
       // This makes an unnecessary copy of the bytes when bytebuf supports array(). However, we
-      // expect performance-critical code to support flushTo().
+      // expect performance-critical code to support drainTo().
+      @SuppressWarnings("BetaApi") // ByteStreams is not Beta in v27
       long written = ByteStreams.copy(message, outputStream);
       checkArgument(written <= Integer.MAX_VALUE, "Message size overflow: %s", written);
       return (int) written;
@@ -273,8 +290,9 @@ private void writeRaw(byte[] b, int off, int len) {
         commitToSink(false, false);
       }
       if (buffer == null) {
-        // Request a buffer allocation using the message length as a hint.
-        buffer = bufferAllocator.allocate(len);
+        checkState(knownLengthPendingAllocation > 0, "knownLengthPendingAllocation reached 0");
+        buffer = bufferAllocator.allocate(knownLengthPendingAllocation);
+        knownLengthPendingAllocation -= min(knownLengthPendingAllocation, buffer.writableBytes());
       }
       int toWrite = min(len, buffer.writableBytes());
       buffer.write(b, off, toWrite);
@@ -286,6 +304,7 @@ private void writeRaw(byte[] b, int off, int len) {
   /**
    * Flushes any buffered data in the framer to the sink.
    */
+  @Override
   public void flush() {
     if (buffer != null && buffer.readableBytes() > 0) {
       commitToSink(false, true);
@@ -296,6 +315,7 @@ public void flush() {
    * Indicates whether or not this framer has been closed via a call to either
    * {@link #close()} or {@link #dispose()}.
    */
+  @Override
   public boolean isClosed() {
     return closed;
   }
@@ -304,6 +324,7 @@ public boolean isClosed() {
    * Flushes and closes the framer and releases any buffers. After the framer is closed or
    * disposed, additional calls to this method will have no affect.
    */
+  @Override
   public void close() {
     if (!isClosed()) {
       closed = true;
@@ -320,6 +341,7 @@ public void close() {
    * Closes the framer and releases any buffers, but does not flush. After the framer is
    * closed or disposed, additional calls to this method will have no affect.
    */
+  @Override
   public void dispose() {
     closed = true;
     releaseBuffer();
@@ -335,7 +357,8 @@ private void releaseBuffer() {
   private void commitToSink(boolean endOfStream, boolean flush) {
     WritableBuffer buf = buffer;
     buffer = null;
-    sink.deliverFrame(buf, endOfStream, flush);
+    sink.deliverFrame(buf, endOfStream, flush, messagesBuffered);
+    messagesBuffered = 0;
   }
 
   private void verifyNotClosed() {
@@ -368,7 +391,9 @@ public void write(byte[] b, int off, int len) {
    * {@link OutputStream}.
    */
   private final class BufferChainOutputStream extends OutputStream {
-    private final List<WritableBuffer> bufferList = new ArrayList<WritableBuffer>();
+    private static final int FIRST_BUFFER_SIZE = 4096;
+
+    private final List<WritableBuffer> bufferList = new ArrayList<>();
     private WritableBuffer current;
 
     /**
@@ -377,7 +402,7 @@ private final class BufferChainOutputStream extends OutputStream {
      * {@link #write(byte[], int, int)}.
      */
     @Override
-    public void write(int b) throws IOException {
+    public void write(int b) {
       if (current != null && current.writableBytes() > 0) {
         current.write((byte)b);
         return;
@@ -390,7 +415,7 @@ public void write(int b) throws IOException {
     public void write(byte[] b, int off, int len) {
       if (current == null) {
         // Request len bytes initially from the allocator, it may give us more.
-        current = bufferAllocator.allocate(len);
+        current = bufferAllocator.allocate(Math.max(FIRST_BUFFER_SIZE, len));
         bufferList.add(current);
       }
       while (len > 0) {
diff --git a/core/src/main/java/io/grpc/internal/MetadataApplierImpl.java b/core/src/main/java/io/grpc/internal/MetadataApplierImpl.java
index f2157053178..166f97b78f5 100644
--- a/core/src/main/java/io/grpc/internal/MetadataApplierImpl.java
+++ b/core/src/main/java/io/grpc/internal/MetadataApplierImpl.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -35,23 +20,24 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
 
+import com.google.errorprone.annotations.concurrent.GuardedBy;
 import io.grpc.CallCredentials.MetadataApplier;
 import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
 import io.grpc.Context;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.Status;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
 
-final class MetadataApplierImpl implements MetadataApplier {
+final class MetadataApplierImpl extends MetadataApplier {
   private final ClientTransport transport;
   private final MethodDescriptor<?, ?> method;
   private final Metadata origHeaders;
   private final CallOptions callOptions;
   private final Context ctx;
-  private final StatsTraceContext statsTraceCtx;
-
+  private final MetadataApplierListener listener;
+  private final ClientStreamTracer[] tracers;
   private final Object lock = new Object();
 
   // null if neither apply() or returnStream() are called.
@@ -65,14 +51,16 @@ final class MetadataApplierImpl implements MetadataApplier {
   // not null if returnStream() was called before apply()
   DelayedStream delayedStream;
 
-  MetadataApplierImpl(ClientTransport transport, MethodDescriptor<?, ?> method,
-      Metadata origHeaders, CallOptions callOptions, StatsTraceContext statsTraceCtx) {
+  MetadataApplierImpl(
+      ClientTransport transport, MethodDescriptor<?, ?> method, Metadata origHeaders,
+      CallOptions callOptions, MetadataApplierListener listener, ClientStreamTracer[] tracers) {
     this.transport = transport;
     this.method = method;
     this.origHeaders = origHeaders;
     this.callOptions = callOptions;
     this.ctx = Context.current();
-    this.statsTraceCtx = statsTraceCtx;
+    this.listener = listener;
+    this.tracers = tracers;
   }
 
   @Override
@@ -83,7 +71,7 @@ public void apply(Metadata headers) {
     ClientStream realStream;
     Context origCtx = ctx.attach();
     try {
-      realStream = transport.newStream(method, origHeaders, callOptions, statsTraceCtx);
+      realStream = transport.newStream(method, origHeaders, callOptions, tracers);
     } finally {
       ctx.detach(origCtx);
     }
@@ -94,24 +82,35 @@ public void apply(Metadata headers) {
   public void fail(Status status) {
     checkArgument(!status.isOk(), "Cannot fail with OK status");
     checkState(!finalized, "apply() or fail() already called");
-    finalizeWith(new FailingClientStream(status));
+    finalizeWith(
+        new FailingClientStream(GrpcUtil.replaceInappropriateControlPlaneStatus(status), tracers));
   }
 
   private void finalizeWith(ClientStream stream) {
     checkState(!finalized, "already finalized");
     finalized = true;
+    boolean directStream = false;
     synchronized (lock) {
       if (returnedStream == null) {
         // Fast path: returnStream() hasn't been called, the call will use the
         // real stream directly.
         returnedStream = stream;
-        return;
+        directStream = true;
       }
     }
+    if (directStream) {
+      listener.onComplete();
+      return;
+    }
     // returnStream() has been called before me, thus delayedStream must have been
     // created.
     checkState(delayedStream != null, "delayedStream is null");
-    delayedStream.setStream(stream);
+    Runnable slow = delayedStream.setStream(stream);
+    if (slow != null) {
+      // TODO(ejona): run this on a separate thread
+      slow.run();
+    }
+    listener.onComplete();
   }
 
   /**
@@ -121,11 +120,18 @@ ClientStream returnStream() {
     synchronized (lock) {
       if (returnedStream == null) {
         // apply() has not been called, needs to buffer the requests.
-        delayedStream = new DelayedStream();
+        delayedStream = new DelayedStream("call_credentials");
         return returnedStream = delayedStream;
       } else {
         return returnedStream;
       }
     }
   }
+
+  public interface MetadataApplierListener {
+    /**
+     * Notify that the metadata has been successfully applied, or failed.
+     * */
+    void onComplete();
+  }
 }
diff --git a/core/src/main/java/io/grpc/internal/MetricRecorderImpl.java b/core/src/main/java/io/grpc/internal/MetricRecorderImpl.java
new file mode 100644
index 00000000000..ded9d5ce589
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/MetricRecorderImpl.java
@@ -0,0 +1,234 @@
+/*
+ * Copyright 2024 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.internal;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.CallbackMetricInstrument;
+import io.grpc.DoubleCounterMetricInstrument;
+import io.grpc.DoubleHistogramMetricInstrument;
+import io.grpc.LongCounterMetricInstrument;
+import io.grpc.LongGaugeMetricInstrument;
+import io.grpc.LongHistogramMetricInstrument;
+import io.grpc.LongUpDownCounterMetricInstrument;
+import io.grpc.MetricInstrument;
+import io.grpc.MetricInstrumentRegistry;
+import io.grpc.MetricRecorder;
+import io.grpc.MetricSink;
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.List;
+
+/**
+ * Provides a central point  for gRPC components to record metric values. Metrics can be exported to
+ * monitoring systems by configuring one or more {@link MetricSink}s.
+ *
+ * <p>This class encapsulates the interaction with metric sinks, including updating them with
+ * the latest set of {@link MetricInstrument}s provided by the {@link MetricInstrumentRegistry}.
+ */
+final class MetricRecorderImpl implements MetricRecorder {
+
+  private final List<MetricSink> metricSinks;
+  private final MetricInstrumentRegistry registry;
+
+  @VisibleForTesting
+  MetricRecorderImpl(List<MetricSink> metricSinks, MetricInstrumentRegistry registry) {
+    this.metricSinks = metricSinks;
+    this.registry = registry;
+  }
+
+  /**
+   * Records a double counter value.
+   *
+   * @param metricInstrument the {@link DoubleCounterMetricInstrument} to record.
+   * @param value the value to record.
+   * @param requiredLabelValues the required label values for the metric.
+   * @param optionalLabelValues the optional label values for the metric.
+   */
+  @Override
+  public void addDoubleCounter(DoubleCounterMetricInstrument metricInstrument, double value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+    MetricRecorder.super.addDoubleCounter(metricInstrument, value, requiredLabelValues,
+        optionalLabelValues);
+    for (MetricSink sink : metricSinks) {
+      // TODO(dnvindhya): Move updating measures logic from sink to here
+      int measuresSize = sink.getMeasuresSize();
+      if (measuresSize <= metricInstrument.getIndex()) {
+        // Measures may need updating in two cases:
+        // 1. When the sink is initially created with an empty list of measures.
+        // 2. When new metric instruments are registered, requiring the sink to accommodate them.
+        sink.updateMeasures(registry.getMetricInstruments());
+      }
+      sink.addDoubleCounter(metricInstrument, value, requiredLabelValues, optionalLabelValues);
+    }
+  }
+
+  /**
+   * Records a long counter value.
+   *
+   * @param metricInstrument the {@link LongCounterMetricInstrument} to record.
+   * @param value the value to record. Must be non-negative.
+   * @param requiredLabelValues the required label values for the metric.
+   * @param optionalLabelValues the optional label values for the metric.
+   */
+  @Override
+  public void addLongCounter(LongCounterMetricInstrument metricInstrument, long value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+    MetricRecorder.super.addLongCounter(metricInstrument, value, requiredLabelValues,
+        optionalLabelValues);
+    for (MetricSink sink : metricSinks) {
+      int measuresSize = sink.getMeasuresSize();
+      if (measuresSize <= metricInstrument.getIndex()) {
+        // Measures may need updating in two cases:
+        // 1. When the sink is initially created with an empty list of measures.
+        // 2. When new metric instruments are registered, requiring the sink to accommodate them.
+        sink.updateMeasures(registry.getMetricInstruments());
+      }
+      sink.addLongCounter(metricInstrument, value, requiredLabelValues, optionalLabelValues);
+    }
+  }
+
+  /**
+   * Adds a long up down counter value.
+   *
+   * @param metricInstrument    the {@link io.grpc.LongUpDownCounterMetricInstrument} to record.
+   * @param value               the value to record. May be positive, negative or zero.
+   * @param requiredLabelValues the required label values for the metric.
+   * @param optionalLabelValues the optional label values for the metric.
+   */
+  @Override
+  public void addLongUpDownCounter(LongUpDownCounterMetricInstrument metricInstrument, long value,
+                                   List<String> requiredLabelValues,
+                                   List<String> optionalLabelValues) {
+    MetricRecorder.super.addLongUpDownCounter(metricInstrument, value, requiredLabelValues,
+        optionalLabelValues);
+    for (MetricSink sink : metricSinks) {
+      int measuresSize = sink.getMeasuresSize();
+      if (measuresSize <= metricInstrument.getIndex()) {
+        // Measures may need updating in two cases:
+        // 1. When the sink is initially created with an empty list of measures.
+        // 2. When new metric instruments are registered, requiring the sink to accommodate them.
+        sink.updateMeasures(registry.getMetricInstruments());
+      }
+      sink.addLongUpDownCounter(metricInstrument, value, requiredLabelValues, optionalLabelValues);
+    }
+  }
+
+  /**
+   * Records a double histogram value.
+   *
+   * @param metricInstrument the {@link DoubleHistogramMetricInstrument} to record.
+   * @param value the value to record.
+   * @param requiredLabelValues the required label values for the metric.
+   * @param optionalLabelValues the optional label values for the metric.
+   */
+  @Override
+  public void recordDoubleHistogram(DoubleHistogramMetricInstrument metricInstrument, double value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+    MetricRecorder.super.recordDoubleHistogram(metricInstrument, value, requiredLabelValues,
+        optionalLabelValues);
+    for (MetricSink sink : metricSinks) {
+      int measuresSize = sink.getMeasuresSize();
+      if (measuresSize <= metricInstrument.getIndex()) {
+        // Measures may need updating in two cases:
+        // 1. When the sink is initially created with an empty list of measures.
+        // 2. When new metric instruments are registered, requiring the sink to accommodate them.
+        sink.updateMeasures(registry.getMetricInstruments());
+      }
+      sink.recordDoubleHistogram(metricInstrument, value, requiredLabelValues, optionalLabelValues);
+    }
+  }
+
+  /**
+   * Records a long histogram value.
+   *
+   * @param metricInstrument the {@link LongHistogramMetricInstrument} to record.
+   * @param value the value to record.
+   * @param requiredLabelValues the required label values for the metric.
+   * @param optionalLabelValues the optional label values for the metric.
+   */
+  @Override
+  public void recordLongHistogram(LongHistogramMetricInstrument metricInstrument, long value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+    MetricRecorder.super.recordLongHistogram(metricInstrument, value, requiredLabelValues,
+        optionalLabelValues);
+    for (MetricSink sink : metricSinks) {
+      int measuresSize = sink.getMeasuresSize();
+      if (measuresSize <= metricInstrument.getIndex()) {
+        // Measures may need updating in two cases:
+        // 1. When the sink is initially created with an empty list of measures.
+        // 2. When new metric instruments are registered, requiring the sink to accommodate them.
+        sink.updateMeasures(registry.getMetricInstruments());
+      }
+      sink.recordLongHistogram(metricInstrument, value, requiredLabelValues, optionalLabelValues);
+    }
+  }
+
+  @Override
+  public Registration registerBatchCallback(BatchCallback callback,
+      CallbackMetricInstrument... metricInstruments) {
+    long largestMetricInstrumentIndex = -1;
+    BitSet allowedInstruments = new BitSet();
+    for (CallbackMetricInstrument metricInstrument : metricInstruments) {
+      largestMetricInstrumentIndex =
+          Math.max(largestMetricInstrumentIndex, metricInstrument.getIndex());
+      allowedInstruments.set(metricInstrument.getIndex());
+    }
+    List<MetricSink.Registration> registrations = new ArrayList<>();
+    for (MetricSink sink : metricSinks) {
+      int measuresSize = sink.getMeasuresSize();
+      if (measuresSize <= largestMetricInstrumentIndex) {
+        // Measures may need updating in two cases:
+        // 1. When the sink is initially created with an empty list of measures.
+        // 2. When new metric instruments are registered, requiring the sink to accommodate them.
+        sink.updateMeasures(registry.getMetricInstruments());
+      }
+      BatchRecorder singleSinkRecorder = new BatchRecorderImpl(sink, allowedInstruments);
+      registrations.add(sink.registerBatchCallback(
+          () -> callback.accept(singleSinkRecorder), metricInstruments));
+    }
+    return () -> {
+      for (MetricSink.Registration registration : registrations) {
+        registration.close();
+      }
+    };
+  }
+
+  /** Recorder for instrument values produced by a batch callback. */
+  static class BatchRecorderImpl implements BatchRecorder {
+    private final MetricSink sink;
+    private final BitSet allowedInstruments;
+
+    BatchRecorderImpl(MetricSink sink, BitSet allowedInstruments) {
+      this.sink = checkNotNull(sink, "sink");
+      this.allowedInstruments = checkNotNull(allowedInstruments, "allowedInstruments");
+    }
+
+    @Override
+    public void recordLongGauge(LongGaugeMetricInstrument metricInstrument, long value,
+        List<String> requiredLabelValues, List<String> optionalLabelValues) {
+      BatchRecorder.super.recordLongGauge(metricInstrument, value, requiredLabelValues,
+          optionalLabelValues);
+      checkArgument(allowedInstruments.get(metricInstrument.getIndex()),
+          "Instrument was not listed when registering callback: %s", metricInstrument);
+      // Registering the callback checked that the instruments were be present in sink.
+      sink.recordLongGauge(metricInstrument, value, requiredLabelValues, optionalLabelValues);
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/MigratingThreadDeframer.java b/core/src/main/java/io/grpc/internal/MigratingThreadDeframer.java
new file mode 100644
index 00000000000..e4f499ab483
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/MigratingThreadDeframer.java
@@ -0,0 +1,305 @@
+/*
+ * Copyright 2019 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Decompressor;
+import io.perfmark.Link;
+import io.perfmark.PerfMark;
+import io.perfmark.TaskCloseable;
+import java.io.Closeable;
+import java.io.InputStream;
+import java.util.ArrayDeque;
+import java.util.Queue;
+
+/**
+ * A deframer that moves decoding between the transport and app threads based on which is more
+ * efficient at that moment.
+ */
+final class MigratingThreadDeframer implements ThreadOptimizedDeframer {
+  private interface Op {
+    void run(boolean isDeframerOnTransportThread);
+  }
+
+  private final MessageDeframer.Listener transportListener;
+  private final ApplicationThreadDeframerListener appListener;
+  private final MigratingDeframerListener migratingListener;
+  private final ApplicationThreadDeframerListener.TransportExecutor transportExecutor;
+  private final MessageDeframer deframer;
+  private final DeframeMessageProducer messageProducer = new DeframeMessageProducer();
+
+  private final Object lock = new Object();
+  /**
+   * {@code true} means decoding on transport thread.
+   *
+   * <p>Invariant: if there are outstanding requests, then deframerOnTransportThread=true. Otherwise
+   * deframerOnTransportThread=false.
+   */
+  @GuardedBy("lock")
+  private boolean deframerOnTransportThread;
+  @GuardedBy("lock")
+  private final Queue<Op> opQueue = new ArrayDeque<>();
+  @GuardedBy("lock")
+  private boolean messageProducerEnqueued;
+
+  public MigratingThreadDeframer(
+      MessageDeframer.Listener listener,
+      ApplicationThreadDeframerListener.TransportExecutor transportExecutor,
+      MessageDeframer deframer) {
+    this.transportListener =
+        new SquelchLateMessagesAvailableDeframerListener(checkNotNull(listener, "listener"));
+    this.transportExecutor = checkNotNull(transportExecutor, "transportExecutor");
+    this.appListener = new ApplicationThreadDeframerListener(transportListener, transportExecutor);
+    // Starts on app thread
+    this.migratingListener = new MigratingDeframerListener(appListener);
+    deframer.setListener(migratingListener);
+    this.deframer = deframer;
+  }
+
+  @Override
+  public void setMaxInboundMessageSize(int messageSize) {
+    deframer.setMaxInboundMessageSize(messageSize);
+  }
+
+  @Override
+  public void setDecompressor(Decompressor decompressor) {
+    deframer.setDecompressor(decompressor);
+  }
+
+  @Override
+  public void setFullStreamDecompressor(GzipInflatingBuffer fullStreamDecompressor) {
+    deframer.setFullStreamDecompressor(fullStreamDecompressor);
+  }
+
+  private boolean runWhereAppropriate(Op op) {
+    return runWhereAppropriate(op, true);
+  }
+
+  private boolean runWhereAppropriate(Op op, boolean currentThreadIsTransportThread) {
+    boolean deframerOnTransportThreadCopy;
+    boolean alreadyEnqueued;
+    synchronized (lock) {
+      deframerOnTransportThreadCopy = deframerOnTransportThread;
+      alreadyEnqueued = messageProducerEnqueued;
+      if (!deframerOnTransportThreadCopy) {
+        opQueue.offer(op);
+        messageProducerEnqueued = true;
+      }
+    }
+    if (deframerOnTransportThreadCopy) {
+      op.run(/*isDeframerOnTransportThread=*/true);
+      return true;
+    } else {
+      if (!alreadyEnqueued) {
+        if (currentThreadIsTransportThread) {
+          try (TaskCloseable ignore =
+                   PerfMark.traceTask("MigratingThreadDeframer.messageAvailable")) {
+            transportListener.messagesAvailable(messageProducer);
+          }
+        } else {
+          final Link link = PerfMark.linkOut();
+          // SLOW path. This is the "normal" thread-hopping approach for request() when _not_ using
+          // MigratingThreadDeframer
+          transportExecutor.runOnTransportThread(new Runnable() {
+            @Override public void run() {
+              try (TaskCloseable ignore =
+                       PerfMark.traceTask("MigratingThreadDeframer.messageAvailable")) {
+                PerfMark.linkIn(link);
+                transportListener.messagesAvailable(messageProducer);
+              }
+            }
+          });
+        }
+      }
+      return false;
+    }
+  }
+
+  // May be called from an arbitrary thread
+  @Override
+  public void request(final int numMessages) {
+    class RequestOp implements Op {
+      @Override public void run(boolean isDeframerOnTransportThread) {
+        if (isDeframerOnTransportThread) {
+          final Link link = PerfMark.linkOut();
+          // We may not be currently on the transport thread, so jump over to it and then do the
+          // necessary processing
+          transportExecutor.runOnTransportThread(new Runnable() {
+            @Override public void run() {
+              try (TaskCloseable ignore = PerfMark.traceTask("MigratingThreadDeframer.request")) {
+                PerfMark.linkIn(link);
+                // Since processing continues from transport thread while this runnable was
+                // enqueued, the state may have changed since we ran runOnTransportThread. So we
+                // must make sure deframerOnTransportThread==true
+                requestFromTransportThread(numMessages);
+              }
+            }
+          });
+          return;
+        }
+        try (TaskCloseable ignore = PerfMark.traceTask("MigratingThreadDeframer.request")) {
+          deframer.request(numMessages);
+        } catch (Throwable t) {
+          appListener.deframeFailed(t);
+          deframer.close(); // unrecoverable state
+        }
+      }
+    }
+
+    runWhereAppropriate(new RequestOp(), false);
+  }
+
+  private void requestFromTransportThread(final int numMessages) {
+    class RequestAgainOp implements Op {
+      @Override public void run(boolean isDeframerOnTransportThread) {
+        if (!isDeframerOnTransportThread) {
+          // State changed. Go back and try again
+          request(numMessages);
+          return;
+        }
+        try {
+          deframer.request(numMessages);
+        } catch (Throwable t) {
+          appListener.deframeFailed(t);
+          deframer.close(); // unrecoverable state
+        }
+        if (!deframer.hasPendingDeliveries()) {
+          synchronized (lock) {
+            PerfMark.event("MigratingThreadDeframer.deframerOnApplicationThread");
+            migratingListener.setDelegate(appListener);
+            deframerOnTransportThread = false;
+          }
+        }
+      }
+    }
+
+    runWhereAppropriate(new RequestAgainOp());
+  }
+
+  @Override
+  public void deframe(final ReadableBuffer data) {
+    class DeframeOp implements Op, Closeable {
+      @Override public void run(boolean isDeframerOnTransportThread) {
+        try (TaskCloseable ignore = PerfMark.traceTask("MigratingThreadDeframer.deframe")) {
+          if (isDeframerOnTransportThread) {
+            deframer.deframe(data);
+            return;
+          }
+
+          try {
+            deframer.deframe(data);
+          } catch (Throwable t) {
+            appListener.deframeFailed(t);
+            deframer.close(); // unrecoverable state
+          }
+        }
+      }
+
+      @Override public void close() {
+        data.close();
+      }
+    }
+
+    runWhereAppropriate(new DeframeOp());
+  }
+
+  @Override
+  public void closeWhenComplete() {
+    class CloseWhenCompleteOp implements Op {
+      @Override public void run(boolean isDeframerOnTransportThread) {
+        deframer.closeWhenComplete();
+      }
+    }
+
+    runWhereAppropriate(new CloseWhenCompleteOp());
+  }
+
+  @Override
+  public void close() {
+    class CloseOp implements Op {
+      @Override public void run(boolean isDeframerOnTransportThread) {
+        deframer.close();
+      }
+    }
+
+    if (!runWhereAppropriate(new CloseOp())) {
+      deframer.stopDelivery();
+    }
+  }
+
+  class DeframeMessageProducer implements StreamListener.MessageProducer, Closeable {
+    @Override
+    public InputStream next() {
+      while (true) {
+        InputStream is = appListener.messageReadQueuePoll();
+        if (is != null) {
+          return is;
+        }
+        Op op;
+        synchronized (lock) {
+          op = opQueue.poll();
+          if (op == null) {
+            if (deframer.hasPendingDeliveries()) {
+              PerfMark.event("MigratingThreadDeframer.deframerOnTransportThread");
+              migratingListener.setDelegate(transportListener);
+              deframerOnTransportThread = true;
+            }
+            messageProducerEnqueued = false;
+            return null;
+          }
+        }
+        op.run(/*isDeframerOnTransportThread=*/false);
+      }
+    }
+
+    @Override
+    public void close() {
+      while (true) {
+        Op op;
+        synchronized (lock) {
+          do {
+            op = opQueue.poll();
+          } while (!(op == null || op instanceof Closeable));
+          if (op == null) {
+            messageProducerEnqueued = false;
+            return;
+          }
+        }
+        GrpcUtil.closeQuietly((Closeable) op);
+      }
+    }
+  }
+
+  static class MigratingDeframerListener extends ForwardingDeframerListener {
+    private MessageDeframer.Listener delegate;
+
+    public MigratingDeframerListener(MessageDeframer.Listener delegate) {
+      setDelegate(delegate);
+    }
+
+    @Override
+    protected MessageDeframer.Listener delegate() {
+      return delegate;
+    }
+
+    public void setDelegate(MessageDeframer.Listener delegate) {
+      this.delegate = checkNotNull(delegate, "delegate");
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/NameResolverFactoryToProviderFacade.java b/core/src/main/java/io/grpc/internal/NameResolverFactoryToProviderFacade.java
new file mode 100644
index 00000000000..31c20f6e499
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/NameResolverFactoryToProviderFacade.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2023 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.internal;
+
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.Args;
+import io.grpc.NameResolverProvider;
+import java.net.URI;
+
+public class NameResolverFactoryToProviderFacade extends NameResolverProvider {
+
+  private NameResolver.Factory factory;
+
+  NameResolverFactoryToProviderFacade(NameResolver.Factory factory) {
+    this.factory = factory;
+  }
+
+  @Override
+  public NameResolver newNameResolver(URI targetUri, Args args) {
+    return factory.newNameResolver(targetUri, args);
+  }
+
+  @Override
+  public String getDefaultScheme() {
+    return factory.getDefaultScheme();
+  }
+
+  @Override
+  protected boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  protected int priority() {
+    return 5;
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/NoopClientStream.java b/core/src/main/java/io/grpc/internal/NoopClientStream.java
index dc27143bde3..d44170f69fa 100644
--- a/core/src/main/java/io/grpc/internal/NoopClientStream.java
+++ b/core/src/main/java/io/grpc/internal/NoopClientStream.java
@@ -1,41 +1,28 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import io.grpc.Attributes;
 import io.grpc.Compressor;
-import io.grpc.Decompressor;
+import io.grpc.Deadline;
+import io.grpc.DecompressorRegistry;
 import io.grpc.Status;
 import java.io.InputStream;
+import javax.annotation.Nonnull;
 
 /**
  * An implementation of {@link ClientStream} that silently does nothing for the operations.
@@ -79,15 +66,29 @@ public void setMessageCompression(boolean enable) {
     // noop
   }
 
+  @Override
+  public void optimizeForDirectExecutor() {}
+
   @Override
   public void setCompressor(Compressor compressor) {}
 
   @Override
-  public void setDecompressor(Decompressor decompressor) {}
+  public void setFullStreamDecompression(boolean fullStreamDecompression) {}
+
+  @Override
+  public void setDecompressorRegistry(DecompressorRegistry decompressorRegistry) {}
 
   @Override
   public void setMaxInboundMessageSize(int maxSize) {}
 
   @Override
   public void setMaxOutboundMessageSize(int maxSize) {}
+
+  @Override
+  public void setDeadline(@Nonnull Deadline deadline) {}
+
+  @Override
+  public void appendTimeoutInsight(InsightBuilder insight) {
+    insight.append("noop");
+  }
 }
diff --git a/core/src/main/java/io/grpc/internal/NoopSslSession.java b/core/src/main/java/io/grpc/internal/NoopSslSession.java
new file mode 100644
index 00000000000..9a79d281ad5
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/NoopSslSession.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2024 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.internal;
+
+import java.security.Principal;
+import java.security.cert.Certificate;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSessionContext;
+
+/** A no-op ssl session, to facilitate overriding only the required methods in specific
+ * implementations.
+ */
+public class NoopSslSession implements SSLSession {
+  @Override
+  public byte[] getId() {
+    return new byte[0];
+  }
+
+  @Override
+  public SSLSessionContext getSessionContext() {
+    return null;
+  }
+
+  @Override
+  @SuppressWarnings("deprecation")
+  public javax.security.cert.X509Certificate[] getPeerCertificateChain() {
+    throw new UnsupportedOperationException("This method is deprecated and marked for removal. "
+            + "Use the getPeerCertificates() method instead.");
+  }
+
+  @Override
+  public long getCreationTime() {
+    return 0;
+  }
+
+  @Override
+  public long getLastAccessedTime() {
+    return 0;
+  }
+
+  @Override
+  public void invalidate() {
+  }
+
+  @Override
+  public boolean isValid() {
+    return false;
+  }
+
+  @Override
+  public void putValue(String s, Object o) {
+  }
+
+  @Override
+  public Object getValue(String s) {
+    return null;
+  }
+
+  @Override
+  public void removeValue(String s) {
+  }
+
+  @Override
+  public String[] getValueNames() {
+    return new String[0];
+  }
+
+  @Override
+  public Certificate[] getPeerCertificates() throws SSLPeerUnverifiedException {
+    return new Certificate[0];
+  }
+
+  @Override
+  public Certificate[] getLocalCertificates() {
+    return new Certificate[0];
+  }
+
+  @Override
+  public Principal getPeerPrincipal() throws SSLPeerUnverifiedException {
+    return null;
+  }
+
+  @Override
+  public Principal getLocalPrincipal() {
+    return null;
+  }
+
+  @Override
+  public String getCipherSuite() {
+    return null;
+  }
+
+  @Override
+  public String getProtocol() {
+    return null;
+  }
+
+  @Override
+  public String getPeerHost() {
+    return null;
+  }
+
+  @Override
+  public int getPeerPort() {
+    return 0;
+  }
+
+  @Override
+  public int getPacketBufferSize() {
+    return 0;
+  }
+
+  @Override
+  public int getApplicationBufferSize() {
+    return 0;
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/NoopStatsContextFactory.java b/core/src/main/java/io/grpc/internal/NoopStatsContextFactory.java
deleted file mode 100644
index 3716a8b6938..00000000000
--- a/core/src/main/java/io/grpc/internal/NoopStatsContextFactory.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import com.google.instrumentation.stats.MeasurementMap;
-import com.google.instrumentation.stats.StatsContext;
-import com.google.instrumentation.stats.StatsContextFactory;
-import com.google.instrumentation.stats.TagKey;
-import com.google.instrumentation.stats.TagValue;
-import java.io.InputStream;
-import java.io.OutputStream;
-
-public final class NoopStatsContextFactory extends StatsContextFactory {
-  private static final StatsContext DEFAULT_CONTEXT = new NoopStatsContext();
-  private static final StatsContext.Builder BUILDER = new NoopContextBuilder();
-
-  public static final StatsContextFactory INSTANCE = new NoopStatsContextFactory();
-
-  private NoopStatsContextFactory() {
-  }
-
-  @Override
-  public StatsContext deserialize(InputStream is) {
-    return DEFAULT_CONTEXT;
-  }
-
-  @Override
-  public StatsContext getDefault() {
-    return DEFAULT_CONTEXT;
-  }
-
-  private static class NoopStatsContext extends StatsContext {
-    @Override
-    public Builder builder() {
-      return BUILDER;
-    }
-
-    @Override
-    public StatsContext record(MeasurementMap metrics) {
-      return DEFAULT_CONTEXT;
-    }
-
-    @Override
-    public void serialize(OutputStream os) {
-      return;
-    }
-  }
-
-  private static class NoopContextBuilder extends StatsContext.Builder {
-    @Override
-    public StatsContext.Builder set(TagKey key, TagValue value) {
-      return this;
-    }
-
-    @Override
-    public StatsContext build() {
-      return DEFAULT_CONTEXT;
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/ObjectPool.java b/core/src/main/java/io/grpc/internal/ObjectPool.java
index 1742507670a..13547bc274a 100644
--- a/core/src/main/java/io/grpc/internal/ObjectPool.java
+++ b/core/src/main/java/io/grpc/internal/ObjectPool.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
diff --git a/core/src/main/java/io/grpc/internal/OobChannel.java b/core/src/main/java/io/grpc/internal/OobChannel.java
deleted file mode 100644
index 0dfdfedbef6..00000000000
--- a/core/src/main/java/io/grpc/internal/OobChannel.java
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import com.google.common.base.Stopwatch;
-import com.google.common.base.Supplier;
-import com.google.instrumentation.stats.StatsContextFactory;
-import io.grpc.Attributes;
-import io.grpc.CallOptions;
-import io.grpc.ClientCall;
-import io.grpc.ConnectivityStateInfo;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.SubchannelPicker;
-import io.grpc.ManagedChannel;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.Status;
-import io.grpc.internal.ClientCallImpl.ClientTransportProvider;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * A ManagedChannel backed by a single {@link InternalSubchannel} and used for {@link LoadBalancer2}
- * to its own RPC needs.
- */
-@ThreadSafe
-final class OobChannel extends ManagedChannel implements WithLogId {
-  private static final Logger log = Logger.getLogger(OobChannel.class.getName());
-
-  private SubchannelImpl subchannelImpl;
-  private SubchannelPicker subchannelPicker;
-
-  private final LogId logId = LogId.allocate(getClass().getName());
-  private final StatsContextFactory statsFactory;
-  private final String authority;
-  private final DelayedClientTransport2 delayedTransport;
-  private final ObjectPool<? extends Executor> executorPool;
-  private final Executor executor;
-  private final ScheduledExecutorService deadlineCancellationExecutor;
-  private final Supplier<Stopwatch> stopwatchSupplier;
-  private final CountDownLatch terminatedLatch = new CountDownLatch(1);
-  private volatile boolean shutdown;
-
-  private final ClientTransportProvider transportProvider = new ClientTransportProvider() {
-    @Override
-    public ClientTransport get(CallOptions callOptions, Metadata headers) {
-      // delayed transport's newStream() always acquires a lock, but concurrent performance doesn't
-      // matter here because OOB communication should be sparse, and it's not on application RPC's
-      // critical path.
-      return delayedTransport;
-    }
-  };
-
-  OobChannel(StatsContextFactory statsFactory, String authority,
-      ObjectPool<? extends Executor> executorPool,
-      ScheduledExecutorService deadlineCancellationExecutor, Supplier<Stopwatch> stopwatchSupplier,
-      ChannelExecutor channelExecutor) {
-    this.statsFactory = checkNotNull(statsFactory, "statsFactory");
-    this.authority = checkNotNull(authority, "authority");
-    this.executorPool = checkNotNull(executorPool, "executorPool");
-    this.executor = checkNotNull(executorPool.getObject(), "executor");
-    this.deadlineCancellationExecutor = checkNotNull(
-        deadlineCancellationExecutor, "deadlineCancellationExecutor");
-    this.stopwatchSupplier = checkNotNull(stopwatchSupplier, "stopwatchSupplier");
-    this.delayedTransport = new DelayedClientTransport2(executor, channelExecutor);
-    this.delayedTransport.start(new ManagedClientTransport.Listener() {
-        @Override
-        public void transportShutdown(Status s) {
-          // Don't care
-        }
-
-        @Override
-        public void transportTerminated() {
-          subchannelImpl.shutdown();
-        }
-
-        @Override
-        public void transportReady() {
-          // Don't care
-        }
-
-        @Override
-        public void transportInUse(boolean inUse) {
-          // Don't care
-        }
-      });
-  }
-
-  // Must be called only once, right after the OobChannel is created.
-  void setSubchannel(final InternalSubchannel subchannel) {
-    log.log(Level.FINE, "[{0}] Created with [{1}]", new Object[] {this, subchannel});
-    subchannelImpl = new SubchannelImpl() {
-        @Override
-        public void shutdown() {
-          subchannel.shutdown();
-        }
-
-        @Override
-        ClientTransport obtainActiveTransport() {
-          return subchannel.obtainActiveTransport();
-        }
-
-        @Override
-        public void requestConnection() {
-          subchannel.obtainActiveTransport();
-        }
-
-        @Override
-        public EquivalentAddressGroup getAddresses() {
-          return subchannel.getAddressGroup();
-        }
-
-        @Override
-        public Attributes getAttributes() {
-          return Attributes.EMPTY;
-        }
-      };
-
-    subchannelPicker = new SubchannelPicker() {
-        final PickResult result = PickResult.withSubchannel(subchannelImpl);
-
-        @Override
-        public PickResult pickSubchannel(Attributes affinity, Metadata headers) {
-          return result;
-        }
-      };
-    delayedTransport.reprocess(subchannelPicker);
-  }
-
-  @Override
-  public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
-      MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
-    StatsTraceContext statsTraceCtx = StatsTraceContext.newClientContext(
-        methodDescriptor.getFullMethodName(), statsFactory, stopwatchSupplier);
-    return new ClientCallImpl<RequestT, ResponseT>(methodDescriptor,
-        callOptions.getExecutor() == null ? executor : callOptions.getExecutor(),
-        callOptions, statsTraceCtx, transportProvider,
-        deadlineCancellationExecutor);
-  }
-
-  @Override
-  public String authority() {
-    return authority;
-  }
-
-  @Override
-  public LogId getLogId() {
-    return logId;
-  }
-
-  @Override
-  public boolean isTerminated() {
-    return terminatedLatch.getCount() == 0;
-  }
-
-  @Override
-  public boolean awaitTermination(long time, TimeUnit unit) throws InterruptedException {
-    return terminatedLatch.await(time, unit);
-  }
-
-  @Override
-  public ManagedChannel shutdown() {
-    shutdown = true;
-    delayedTransport.shutdown();
-    return this;
-  }
-
-  @Override
-  public boolean isShutdown() {
-    return shutdown;
-  }
-
-  @Override
-  public ManagedChannel shutdownNow() {
-    shutdown = true;
-    delayedTransport.shutdownNow(
-        Status.UNAVAILABLE.withDescription("OobChannel.shutdownNow() called"));
-    return this;
-  }
-
-  void handleSubchannelStateChange(final ConnectivityStateInfo newState) {
-    switch (newState.getState()) {
-      case READY:
-      case IDLE:
-        delayedTransport.reprocess(subchannelPicker);
-        break;
-      case TRANSIENT_FAILURE:
-        delayedTransport.reprocess(new SubchannelPicker() {
-            final PickResult errorResult = PickResult.withError(newState.getStatus());
-
-            @Override
-            public PickResult pickSubchannel(Attributes affinity, Metadata headers) {
-              return errorResult;
-            }
-          });
-        break;
-      default:
-        // Do nothing
-    }
-  }
-
-  void handleSubchannelTerminated() {
-    // When delayedTransport is terminated, it shuts down subchannel.  Therefore, at this point
-    // both delayedTransport and subchannel have terminated.
-    executorPool.returnObject(executor);
-    terminatedLatch.countDown();
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/OobNameResolverProvider.java b/core/src/main/java/io/grpc/internal/OobNameResolverProvider.java
new file mode 100644
index 00000000000..408b92e0c84
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/OobNameResolverProvider.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2025 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.internal;
+
+import static java.util.Objects.requireNonNull;
+
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.NameResolverProvider;
+import io.grpc.StatusOr;
+import io.grpc.SynchronizationContext;
+import java.net.URI;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * A provider that is passed addresses and relays those addresses to its created resolvers.
+ */
+final class OobNameResolverProvider extends NameResolverProvider {
+  private final String authority;
+  private final SynchronizationContext parentSyncContext;
+  // Only accessed from parentSyncContext
+  @SuppressWarnings("JdkObsolete") // LinkedList uses O(n) memory, including after deletions
+  private final Collection<OobNameResolver> resolvers = new LinkedList<>();
+  // Only accessed from parentSyncContext
+  private List<EquivalentAddressGroup> lastEags;
+
+  public OobNameResolverProvider(
+      String authority, List<EquivalentAddressGroup> eags, SynchronizationContext syncContext) {
+    this.authority = requireNonNull(authority, "authority");
+    this.lastEags = requireNonNull(eags, "eags");
+    this.parentSyncContext = requireNonNull(syncContext, "syncContext");
+  }
+
+  @Override
+  public String getDefaultScheme() {
+    return "oob";
+  }
+
+  @Override
+  protected boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  protected int priority() {
+    return 5; // Doesn't matter, as we expect only one provider in the registry
+  }
+
+  public void updateAddresses(List<EquivalentAddressGroup> eags) {
+    requireNonNull(eags, "eags");
+    parentSyncContext.execute(() -> {
+      this.lastEags = eags;
+      for (OobNameResolver resolver : resolvers) {
+        resolver.updateAddresses(eags);
+      }
+    });
+  }
+
+  @Override
+  public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+    return new OobNameResolver(args.getSynchronizationContext());
+  }
+
+  final class OobNameResolver extends NameResolver {
+    private final SynchronizationContext syncContext;
+    // Null before started, and after shutdown. Only accessed from syncContext
+    private Listener2 listener;
+
+    public OobNameResolver(SynchronizationContext syncContext) {
+      this.syncContext = requireNonNull(syncContext, "syncContext");
+    }
+
+    @Override
+    public String getServiceAuthority() {
+      return authority;
+    }
+
+    @Override
+    public void start(Listener2 listener) {
+      this.listener = requireNonNull(listener, "listener");
+      parentSyncContext.execute(() -> {
+        resolvers.add(this);
+        updateAddresses(lastEags);
+      });
+    }
+
+    void updateAddresses(List<EquivalentAddressGroup> eags) {
+      parentSyncContext.throwIfNotInThisSynchronizationContext();
+      syncContext.execute(() -> {
+        if (listener == null) {
+          return;
+        }
+        listener.onResult2(ResolutionResult.newBuilder()
+            .setAddressesOrError(StatusOr.fromValue(lastEags))
+            .build());
+      });
+    }
+
+    @Override
+    public void shutdown() {
+      this.listener = null;
+      parentSyncContext.execute(() -> resolvers.remove(this));
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/PickDetailsConsumerImpl.java b/core/src/main/java/io/grpc/internal/PickDetailsConsumerImpl.java
new file mode 100644
index 00000000000..5c69757afbf
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/PickDetailsConsumerImpl.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2024 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.internal;
+
+import com.google.common.base.Preconditions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.LoadBalancer.PickDetailsConsumer;
+
+/**
+ * Adapter for tracers into details consumers.
+ */
+final class PickDetailsConsumerImpl implements PickDetailsConsumer {
+  private final ClientStreamTracer[] tracers;
+
+  /** Construct a consumer with unchanging tracers array. */
+  public PickDetailsConsumerImpl(ClientStreamTracer[] tracers) {
+    this.tracers = Preconditions.checkNotNull(tracers, "tracers");
+  }
+
+  @Override
+  public void addOptionalLabel(String key, String value) {
+    Preconditions.checkNotNull(key, "key");
+    Preconditions.checkNotNull(value, "value");
+    for (ClientStreamTracer tracer : tracers) {
+      tracer.addOptionalLabel(key, value);
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/PickFirstLeafLoadBalancer.java b/core/src/main/java/io/grpc/internal/PickFirstLeafLoadBalancer.java
new file mode 100644
index 00000000000..935214a94fd
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/PickFirstLeafLoadBalancer.java
@@ -0,0 +1,856 @@
+/*
+ * Copyright 2023 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import io.grpc.Attributes;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import java.net.Inet4Address;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link LoadBalancer} that provides no load-balancing over the addresses from the {@link
+ * io.grpc.NameResolver}. The channel's default behavior is used, which is walking down the address
+ * list and sticking to the first that works.
+ */
+final class PickFirstLeafLoadBalancer extends LoadBalancer {
+  private static final Logger log = Logger.getLogger(PickFirstLeafLoadBalancer.class.getName());
+  @VisibleForTesting
+  static final int CONNECTION_DELAY_INTERVAL_MS = 250;
+  private final boolean enableHappyEyeballs = !isSerializingRetries()
+      && PickFirstLoadBalancerProvider.isEnabledHappyEyeballs();
+  private final Helper helper;
+  private final Map<SocketAddress, SubchannelData> subchannels = new HashMap<>();
+  private final Index addressIndex = new Index(ImmutableList.of(), this.enableHappyEyeballs);
+  private int numTf = 0;
+  private boolean firstPass = true;
+  @Nullable
+  private ScheduledHandle scheduleConnectionTask = null;
+  private ConnectivityState rawConnectivityState = IDLE;
+  private ConnectivityState concludedState = IDLE;
+  private boolean notAPetiolePolicy = true; // means not under a petiole policy
+  private final BackoffPolicy.Provider bkoffPolProvider = new ExponentialBackoffPolicy.Provider();
+  private BackoffPolicy reconnectPolicy;
+  @Nullable
+  private ScheduledHandle reconnectTask = null;
+  private final boolean serializingRetries = isSerializingRetries();
+
+  PickFirstLeafLoadBalancer(Helper helper) {
+    this.helper = checkNotNull(helper, "helper");
+  }
+
+  static boolean isSerializingRetries() {
+    return GrpcUtil.getFlag("GRPC_SERIALIZE_RETRIES", false);
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    if (rawConnectivityState == SHUTDOWN) {
+      return Status.FAILED_PRECONDITION.withDescription("Already shut down");
+    }
+
+    // Check whether this is a petiole policy, which is based off of an address attribute
+    Boolean isPetiolePolicy = resolvedAddresses.getAttributes().get(IS_PETIOLE_POLICY);
+    this.notAPetiolePolicy = isPetiolePolicy == null || !isPetiolePolicy;
+
+    List<EquivalentAddressGroup> servers = resolvedAddresses.getAddresses();
+
+    // Validate the address list
+    if (servers.isEmpty()) {
+      Status unavailableStatus = Status.UNAVAILABLE.withDescription(
+              "NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+                      + ", attrs=" + resolvedAddresses.getAttributes());
+      handleNameResolutionError(unavailableStatus);
+      return unavailableStatus;
+    }
+    for (EquivalentAddressGroup eag : servers) {
+      if (eag == null) {
+        Status unavailableStatus = Status.UNAVAILABLE.withDescription(
+            "NameResolver returned address list with null endpoint. addrs="
+                + resolvedAddresses.getAddresses() + ", attrs="
+                + resolvedAddresses.getAttributes());
+        handleNameResolutionError(unavailableStatus);
+        return unavailableStatus;
+      }
+    }
+
+    // Since we have a new set of addresses, we are again at first pass
+    firstPass = true;
+
+    List<EquivalentAddressGroup> cleanServers = deDupAddresses(servers);
+
+    // We can optionally be configured to shuffle the address list. This can help better distribute
+    // the load.
+    if (resolvedAddresses.getLoadBalancingPolicyConfig()
+        instanceof PickFirstLeafLoadBalancerConfig) {
+      PickFirstLeafLoadBalancerConfig config
+          = (PickFirstLeafLoadBalancerConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+      if (config.shuffleAddressList != null && config.shuffleAddressList) {
+        Collections.shuffle(cleanServers,
+            config.randomSeed != null ? new Random(config.randomSeed) : new Random());
+      }
+    }
+
+    final ImmutableList<EquivalentAddressGroup> newImmutableAddressGroups =
+        ImmutableList.<EquivalentAddressGroup>builder().addAll(cleanServers).build();
+
+    if (rawConnectivityState == READY
+        || (rawConnectivityState == CONNECTING
+          && (!enableHappyEyeballs || addressIndex.isValid()))) {
+      // If the previous ready (or connecting) subchannel exists in new address list,
+      // keep this connection and don't create new subchannels. Happy Eyeballs is excluded when
+      // connecting, because it allows multiple attempts simultaneously, thus is fine to start at
+      // the beginning.
+      SocketAddress previousAddress = addressIndex.getCurrentAddress();
+      addressIndex.updateGroups(newImmutableAddressGroups);
+      if (addressIndex.seekTo(previousAddress)) {
+        SubchannelData subchannelData = subchannels.get(previousAddress);
+        subchannelData.getSubchannel().updateAddresses(addressIndex.getCurrentEagAsList());
+        shutdownRemovedAddresses(newImmutableAddressGroups);
+        return Status.OK;
+      }
+      // Previous ready subchannel not in the new list of addresses
+    } else {
+      addressIndex.updateGroups(newImmutableAddressGroups);
+    }
+
+    // No old addresses means first time through, so we will do an explicit move to CONNECTING
+    // which is what we implicitly started with
+    boolean noOldAddrs = shutdownRemovedAddresses(newImmutableAddressGroups);
+
+    if (noOldAddrs) {
+      // Make tests happy; they don't properly assume starting in CONNECTING
+      rawConnectivityState = CONNECTING;
+      updateBalancingState(CONNECTING, new FixedResultPicker(PickResult.withNoResult()));
+    }
+
+    if (rawConnectivityState == READY) {
+      // connect from beginning when prompted
+      rawConnectivityState = IDLE;
+      updateBalancingState(IDLE, new RequestConnectionPicker(this));
+
+    } else if (rawConnectivityState == CONNECTING || rawConnectivityState == TRANSIENT_FAILURE) {
+      // start connection attempt at first address
+      cancelScheduleTask();
+      requestConnection();
+    }
+
+    return Status.OK;
+  }
+
+  /**
+   * Compute the difference between the flattened new addresses and the old addresses that had been
+   * made into subchannels and then shutdown the matching subchannels.
+   * @return true if there were no old addresses
+   */
+  private boolean shutdownRemovedAddresses(
+      ImmutableList<EquivalentAddressGroup> newImmutableAddressGroups) {
+
+    Set<SocketAddress> oldAddrs = new HashSet<>(subchannels.keySet());
+
+    // Flatten the new EAGs addresses
+    Set<SocketAddress> newAddrs = new HashSet<>();
+    for (EquivalentAddressGroup endpoint : newImmutableAddressGroups) {
+      newAddrs.addAll(endpoint.getAddresses());
+    }
+
+    // Shut them down and remove them
+    for (SocketAddress oldAddr : oldAddrs) {
+      if (!newAddrs.contains(oldAddr)) {
+        subchannels.remove(oldAddr).getSubchannel().shutdown();
+      }
+    }
+    return oldAddrs.isEmpty();
+  }
+
+  private static List<EquivalentAddressGroup> deDupAddresses(List<EquivalentAddressGroup> groups) {
+    Set<SocketAddress> seenAddresses = new HashSet<>();
+    List<EquivalentAddressGroup> newGroups = new ArrayList<>();
+
+    for (EquivalentAddressGroup group : groups) {
+      List<SocketAddress> addrs = new ArrayList<>();
+      for (SocketAddress addr : group.getAddresses()) {
+        if (seenAddresses.add(addr)) {
+          addrs.add(addr);
+        }
+      }
+      if (!addrs.isEmpty()) {
+        newGroups.add(new EquivalentAddressGroup(addrs, group.getAttributes()));
+      }
+    }
+
+    return newGroups;
+  }
+
+  @Override
+  public void handleNameResolutionError(Status error) {
+    if (rawConnectivityState == SHUTDOWN) {
+      return;
+    }
+
+    for (SubchannelData subchannelData : subchannels.values()) {
+      subchannelData.getSubchannel().shutdown();
+    }
+    subchannels.clear();
+    addressIndex.updateGroups(ImmutableList.of());
+    rawConnectivityState = TRANSIENT_FAILURE;
+    updateBalancingState(TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
+  }
+
+  void processSubchannelState(SubchannelData subchannelData, ConnectivityStateInfo stateInfo) {
+    ConnectivityState newState = stateInfo.getState();
+
+    // Shutdown channels/previously relevant subchannels can still callback with state updates.
+    // To prevent pickers from returning these obsolete subchannels, this logic
+    // is included to check if the current list of active subchannels includes this subchannel.
+    if (subchannelData != subchannels.get(getAddress(subchannelData.subchannel))) {
+      return;
+    }
+
+    if (newState == SHUTDOWN) {
+      return;
+    }
+
+    if (newState == IDLE && subchannelData.state == READY) {
+      helper.refreshNameResolution();
+    }
+
+    // If we are transitioning from a TRANSIENT_FAILURE to CONNECTING or IDLE we ignore this state
+    // transition and still keep the LB in TRANSIENT_FAILURE state. This is referred to as "sticky
+    // transient failure". Only a subchannel state change to READY will get the LB out of
+    // TRANSIENT_FAILURE. If the state is IDLE we additionally request a new connection so that we
+    // keep retrying for a connection.
+
+    // With the new pick first implementation, individual subchannels will have their own backoff
+    // on a per-address basis. Thus, iterative requests for connections will not be requested
+    // once the first pass through is complete.
+    // However, every time there is an address update, we will perform a pass through for the new
+    // addresses in the updated list.
+    subchannelData.updateState(newState);
+    if (rawConnectivityState == TRANSIENT_FAILURE || concludedState == TRANSIENT_FAILURE)  {
+      if (newState == CONNECTING) {
+        // each subchannel is responsible for its own backoff
+        return;
+      } else if (newState == IDLE) {
+        requestConnection();
+        return;
+      }
+    }
+
+    switch (newState) {
+      case IDLE:
+        // Shutdown when ready: connect from beginning when prompted
+        addressIndex.reset();
+        rawConnectivityState = IDLE;
+        updateBalancingState(IDLE, new RequestConnectionPicker(this));
+        break;
+
+      case CONNECTING:
+        rawConnectivityState = CONNECTING;
+        updateBalancingState(CONNECTING, new FixedResultPicker(PickResult.withNoResult()));
+        break;
+
+      case READY:
+        shutdownRemaining(subchannelData);
+        addressIndex.seekTo(getAddress(subchannelData.subchannel));
+        rawConnectivityState = READY;
+        updateHealthCheckedState(subchannelData);
+        break;
+
+      case TRANSIENT_FAILURE:
+        // If we are looking at current channel, request a connection if possible
+        if (addressIndex.isValid()
+            && subchannels.get(addressIndex.getCurrentAddress()) == subchannelData) {
+          if (addressIndex.increment()) {
+            cancelScheduleTask();
+            requestConnection(); // is recursive so might hit the end of the addresses
+          } else {
+            if (subchannels.size() >= addressIndex.size()) {
+              scheduleBackoff();
+            } else {
+              // We must have done a seek to the middle of the list lets start over from the
+              // beginning
+              addressIndex.reset();
+              requestConnection();
+            }
+          }
+        }
+
+        if (isPassComplete()) {
+          rawConnectivityState = TRANSIENT_FAILURE;
+          updateBalancingState(TRANSIENT_FAILURE,
+              new FixedResultPicker(PickResult.withError(stateInfo.getStatus())));
+
+          // Refresh Name Resolution, but only when all 3 conditions are met
+          // * We are at the end of addressIndex
+          // * have had status reported for all subchannels.
+          // * And one of the following conditions:
+          //    * Have had enough TF reported since we completed first pass
+          //    * Just completed the first pass
+          if (++numTf >= addressIndex.size() || firstPass) {
+            firstPass = false;
+            numTf = 0;
+            helper.refreshNameResolution();
+          }
+        }
+        break;
+
+      default:
+        throw new IllegalArgumentException("Unsupported state:" + newState);
+    }
+  }
+
+  /**
+   * Only called after all addresses attempted and failed (TRANSIENT_FAILURE).
+   */
+  private void scheduleBackoff() {
+    if (!serializingRetries) {
+      return;
+    }
+
+    class EndOfCurrentBackoff implements Runnable {
+      @Override
+      public void run() {
+        reconnectTask = null;
+        addressIndex.reset();
+        requestConnection();
+      }
+    }
+
+    // Just allow the previous one to trigger when ready if we're already in backoff
+    if (reconnectTask != null) {
+      return;
+    }
+
+    if (reconnectPolicy == null) {
+      reconnectPolicy = bkoffPolProvider.get();
+    }
+    long delayNanos = reconnectPolicy.nextBackoffNanos();
+    reconnectTask = helper.getSynchronizationContext().schedule(
+        new EndOfCurrentBackoff(),
+        delayNanos,
+        TimeUnit.NANOSECONDS,
+        helper.getScheduledExecutorService());
+  }
+
+  private void updateHealthCheckedState(SubchannelData subchannelData) {
+    if (subchannelData.state != READY) {
+      return;
+    }
+
+    if (notAPetiolePolicy || subchannelData.getHealthState() == READY) {
+      updateBalancingState(READY,
+          new FixedResultPicker(PickResult.withSubchannel(subchannelData.subchannel)));
+    } else if (subchannelData.getHealthState() == TRANSIENT_FAILURE) {
+      updateBalancingState(TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(
+          subchannelData.healthStateInfo.getStatus())));
+    } else if (concludedState != TRANSIENT_FAILURE) {
+      updateBalancingState(subchannelData.getHealthState(),
+          new FixedResultPicker(PickResult.withNoResult()));
+    }
+  }
+
+  private void updateBalancingState(ConnectivityState state, SubchannelPicker picker) {
+    // an optimization: de-dup IDLE or CONNECTING notification.
+    if (state == concludedState && (state == IDLE || state == CONNECTING)) {
+      return;
+    }
+    concludedState = state;
+    helper.updateBalancingState(state, picker);
+  }
+
+  @Override
+  public void shutdown() {
+    log.log(Level.FINE,
+        "Shutting down, currently have {} subchannels created", subchannels.size());
+    rawConnectivityState = SHUTDOWN;
+    concludedState = SHUTDOWN;
+    cancelScheduleTask();
+    if (reconnectTask != null) {
+      reconnectTask.cancel();
+      reconnectTask = null;
+    }
+    reconnectPolicy = null;
+
+    for (SubchannelData subchannelData : subchannels.values()) {
+      subchannelData.getSubchannel().shutdown();
+    }
+
+    subchannels.clear();
+  }
+
+  /**
+  * Shuts down remaining subchannels. Called when a subchannel becomes ready, which means
+  * that all other subchannels must be shutdown.
+  */
+  private void shutdownRemaining(SubchannelData activeSubchannelData) {
+    if (reconnectTask != null) {
+      reconnectTask.cancel();
+      reconnectTask = null;
+    }
+    reconnectPolicy = null;
+
+    cancelScheduleTask();
+    for (SubchannelData subchannelData : subchannels.values()) {
+      if (!subchannelData.getSubchannel().equals(activeSubchannelData.subchannel)) {
+        subchannelData.getSubchannel().shutdown();
+      }
+    }
+    subchannels.clear();
+    activeSubchannelData.updateState(READY);
+    subchannels.put(getAddress(activeSubchannelData.subchannel), activeSubchannelData);
+  }
+
+  /**
+   * Requests a connection to the next applicable address' subchannel, creating one if necessary.
+   * Schedules a connection to next address in list as well.
+   * If the current channel has already attempted a connection, we attempt a connection
+   * to the next address/subchannel in our list.  We assume that createNewSubchannel will never
+   * return null.
+   */
+  @Override
+  public void requestConnection() {
+    if (!addressIndex.isValid() || rawConnectivityState == SHUTDOWN) {
+      return;
+    }
+
+    SocketAddress currentAddress = addressIndex.getCurrentAddress();
+    SubchannelData subchannelData = subchannels.get(currentAddress);
+    if (subchannelData == null) {
+      subchannelData = createNewSubchannel(currentAddress, addressIndex.getCurrentEagAttributes());
+    }
+
+    ConnectivityState subchannelState = subchannelData.getState();
+    switch (subchannelState) {
+      case IDLE:
+        subchannelData.subchannel.requestConnection();
+        subchannelData.updateState(CONNECTING);
+        scheduleNextConnection();
+        break;
+      case CONNECTING:
+        scheduleNextConnection();
+        break;
+      case TRANSIENT_FAILURE:
+        if (!serializingRetries) {
+          addressIndex.increment();
+          requestConnection();
+        } else {
+          if (!addressIndex.isValid()) {
+            scheduleBackoff();
+          } else {
+            subchannelData.subchannel.requestConnection();
+            subchannelData.updateState(CONNECTING);
+          }
+        }
+        break;
+      default:
+        // Wait for current subchannel to change state
+    }
+  }
+
+
+  /**
+  * Happy Eyeballs
+  * Schedules connection attempt to happen after a delay to the next available address.
+  */
+  private void scheduleNextConnection() {
+    if (!enableHappyEyeballs
+        || (scheduleConnectionTask != null && scheduleConnectionTask.isPending())) {
+      return;
+    }
+
+    class StartNextConnection implements Runnable {
+      @Override
+      public void run() {
+        scheduleConnectionTask = null;
+        if (addressIndex.increment()) {
+          requestConnection();
+        }
+      }
+    }
+
+    scheduleConnectionTask = helper.getSynchronizationContext().schedule(
+        new StartNextConnection(),
+        CONNECTION_DELAY_INTERVAL_MS,
+        TimeUnit.MILLISECONDS,
+        helper.getScheduledExecutorService());
+  }
+
+  private void cancelScheduleTask() {
+    if (scheduleConnectionTask != null) {
+      scheduleConnectionTask.cancel();
+      scheduleConnectionTask = null;
+    }
+  }
+
+  private SubchannelData createNewSubchannel(SocketAddress addr, Attributes attrs) {
+    HealthListener hcListener = new HealthListener();
+    final Subchannel subchannel = helper.createSubchannel(
+        CreateSubchannelArgs.newBuilder()
+            .setAddresses(Lists.newArrayList(
+                new EquivalentAddressGroup(addr, attrs)))
+            .addOption(HEALTH_CONSUMER_LISTENER_ARG_KEY, hcListener)
+            .addOption(LoadBalancer.DISABLE_SUBCHANNEL_RECONNECT_KEY, serializingRetries)
+            .build());
+    if (subchannel == null) {
+      log.warning("Was not able to create subchannel for " + addr);
+      throw new IllegalStateException("Can't create subchannel");
+    }
+    SubchannelData subchannelData = new SubchannelData(subchannel, IDLE);
+    hcListener.subchannelData = subchannelData;
+    subchannels.put(addr, subchannelData);
+    Attributes scAttrs = subchannel.getAttributes();
+    if (notAPetiolePolicy || scAttrs.get(LoadBalancer.HAS_HEALTH_PRODUCER_LISTENER_KEY) == null) {
+      subchannelData.healthStateInfo = ConnectivityStateInfo.forNonError(READY);
+    }
+    subchannel.start(stateInfo -> processSubchannelState(subchannelData, stateInfo));
+    return subchannelData;
+  }
+
+  private boolean isPassComplete() {
+    if (subchannels.size() < addressIndex.size()) {
+      return false;
+    }
+    for (SubchannelData sc : subchannels.values()) {
+      if (!sc.isCompletedConnectivityAttempt() ) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private final class HealthListener implements SubchannelStateListener {
+    private SubchannelData subchannelData;
+
+    @Override
+    public void onSubchannelState(ConnectivityStateInfo newState) {
+      if (notAPetiolePolicy) {
+        log.log(Level.WARNING,
+            "Ignoring health status {0} for subchannel {1} as this is not under a petiole policy",
+            new Object[]{newState, subchannelData.subchannel});
+        return;
+      }
+
+      log.log(Level.FINE, "Received health status {0} for subchannel {1}",
+          new Object[]{newState, subchannelData.subchannel});
+      subchannelData.healthStateInfo = newState;
+      if (addressIndex.isValid()
+          && subchannelData == subchannels.get(addressIndex.getCurrentAddress())) {
+        updateHealthCheckedState(subchannelData);
+      }
+    }
+  }
+
+  private SocketAddress getAddress(Subchannel subchannel) {
+    return subchannel.getAddresses().getAddresses().get(0);
+  }
+
+  @VisibleForTesting
+  ConnectivityState getConcludedConnectivityState() {
+    return this.concludedState;
+  }
+
+  /**
+   * Picker that requests connection during the first pick, and returns noResult.
+   */
+  private final class RequestConnectionPicker extends SubchannelPicker {
+    private final PickFirstLeafLoadBalancer pickFirstLeafLoadBalancer;
+    private final AtomicBoolean connectionRequested = new AtomicBoolean(false);
+
+    RequestConnectionPicker(PickFirstLeafLoadBalancer pickFirstLeafLoadBalancer) {
+      this.pickFirstLeafLoadBalancer =
+          checkNotNull(pickFirstLeafLoadBalancer, "pickFirstLeafLoadBalancer");
+    }
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      if (connectionRequested.compareAndSet(false, true)) {
+        helper.getSynchronizationContext().execute(pickFirstLeafLoadBalancer::requestConnection);
+      }
+      return PickResult.withNoResult();
+    }
+  }
+
+  /**
+   * This contains both an ordered list of addresses and a pointer(i.e. index) to the current entry.
+   * All updates should be done in a synchronization context.
+   */
+  @VisibleForTesting
+  static final class Index {
+    private List<UnwrappedEag> orderedAddresses;
+    private int activeElement = 0;
+    private boolean enableHappyEyeballs;
+
+    Index(List<EquivalentAddressGroup> groups, boolean enableHappyEyeballs) {
+      this.enableHappyEyeballs = enableHappyEyeballs;
+      updateGroups(groups);
+    }
+
+    public boolean isValid() {
+      return activeElement < orderedAddresses.size();
+    }
+
+    public boolean isAtBeginning() {
+      return activeElement == 0;
+    }
+
+    /**
+     * Move to next address in group.  If last address in group move to first address of next group.
+     * @return false if went off end of the list, otherwise true
+     */
+    public boolean increment() {
+      if (!isValid()) {
+        return false;
+      }
+
+      activeElement++;
+
+      return isValid();
+    }
+
+    public void reset() {
+      activeElement = 0;
+    }
+
+    public SocketAddress getCurrentAddress() {
+      if (!isValid()) {
+        throw new IllegalStateException("Index is past the end of the address group list");
+      }
+      return orderedAddresses.get(activeElement).address;
+    }
+
+    public Attributes getCurrentEagAttributes() {
+      if (!isValid()) {
+        throw new IllegalStateException("Index is off the end of the address group list");
+      }
+      return orderedAddresses.get(activeElement).attributes;
+    }
+
+    public List<EquivalentAddressGroup> getCurrentEagAsList() {
+      return Collections.singletonList(getCurrentEag());
+    }
+
+    private EquivalentAddressGroup getCurrentEag() {
+      if (!isValid()) {
+        throw new IllegalStateException("Index is past the end of the address group list");
+      }
+      return orderedAddresses.get(activeElement).asEag();
+    }
+
+    /**
+     * Update to new groups, resetting the current index.
+     */
+    public void updateGroups(List<EquivalentAddressGroup> newGroups) {
+      checkNotNull(newGroups, "newGroups");
+      orderedAddresses = enableHappyEyeballs
+                             ? updateGroupsHE(newGroups)
+                             : updateGroupsNonHE(newGroups);
+      reset();
+    }
+
+    /**
+     * Returns false if the needle was not found and the current index was left unchanged.
+     */
+    public boolean seekTo(SocketAddress needle) {
+      checkNotNull(needle, "needle");
+      for (int i = 0; i < orderedAddresses.size(); i++) {
+        if (orderedAddresses.get(i).address.equals(needle)) {
+          this.activeElement = i;
+          return true;
+        }
+      }
+      return false;
+    }
+
+    public int size() {
+      return orderedAddresses.size();
+    }
+
+    private List<UnwrappedEag> updateGroupsNonHE(List<EquivalentAddressGroup> newGroups) {
+      List<UnwrappedEag> entries = new ArrayList<>();
+      for (int g = 0; g < newGroups.size(); g++) {
+        EquivalentAddressGroup eag = newGroups.get(g);
+        for (int a = 0; a < eag.getAddresses().size(); a++) {
+          SocketAddress addr = eag.getAddresses().get(a);
+          entries.add(new UnwrappedEag(eag.getAttributes(), addr));
+        }
+      }
+
+      return entries;
+    }
+
+    private List<UnwrappedEag> updateGroupsHE(List<EquivalentAddressGroup> newGroups) {
+      Boolean firstIsV6 = null;
+      List<UnwrappedEag> v4Entries = new ArrayList<>();
+      List<UnwrappedEag> v6Entries = new ArrayList<>();
+      for (int g = 0; g <  newGroups.size(); g++) {
+        EquivalentAddressGroup eag = newGroups.get(g);
+        for (int a = 0; a < eag.getAddresses().size(); a++) {
+          SocketAddress addr = eag.getAddresses().get(a);
+          boolean isIpV4 = addr instanceof InetSocketAddress
+              && ((InetSocketAddress) addr).getAddress() instanceof Inet4Address;
+          if (isIpV4) {
+            if (firstIsV6 == null) {
+              firstIsV6 = false;
+            }
+            v4Entries.add(new UnwrappedEag(eag.getAttributes(), addr));
+          } else {
+            if (firstIsV6 == null) {
+              firstIsV6 = true;
+            }
+            v6Entries.add(new UnwrappedEag(eag.getAttributes(), addr));
+          }
+        }
+      }
+
+      return firstIsV6 != null && firstIsV6
+          ? interleave(v6Entries, v4Entries)
+          : interleave(v4Entries, v6Entries);
+    }
+
+    private List<UnwrappedEag> interleave(List<UnwrappedEag> firstFamily,
+                                          List<UnwrappedEag> secondFamily) {
+      if (firstFamily.isEmpty()) {
+        return secondFamily;
+      }
+      if (secondFamily.isEmpty()) {
+        return firstFamily;
+      }
+
+      List<UnwrappedEag> result = new ArrayList<>(firstFamily.size() + secondFamily.size());
+      for (int i = 0; i < Math.max(firstFamily.size(), secondFamily.size()); i++) {
+        if (i < firstFamily.size()) {
+          result.add(firstFamily.get(i));
+        }
+        if (i < secondFamily.size()) {
+          result.add(secondFamily.get(i));
+        }
+      }
+      return result;
+    }
+
+    private static final class UnwrappedEag {
+      private final Attributes attributes;
+      private final SocketAddress address;
+
+      public UnwrappedEag(Attributes attributes, SocketAddress address) {
+        this.attributes = attributes;
+        this.address = address;
+      }
+
+      private EquivalentAddressGroup asEag() {
+        return new EquivalentAddressGroup(address, attributes);
+      }
+    }
+  }
+
+  @VisibleForTesting
+  int getIndexLocation() {
+    return addressIndex.activeElement;
+  }
+
+  @VisibleForTesting
+  boolean isIndexValid() {
+    return addressIndex.isValid();
+  }
+
+  private static final class SubchannelData {
+    private final Subchannel subchannel;
+    private ConnectivityState state;
+    private boolean completedConnectivityAttempt = false;
+    private ConnectivityStateInfo healthStateInfo = ConnectivityStateInfo.forNonError(IDLE);
+
+    public SubchannelData(Subchannel subchannel, ConnectivityState state) {
+      this.subchannel = subchannel;
+      this.state = state;
+    }
+
+    public Subchannel getSubchannel() {
+      return this.subchannel;
+    }
+
+    public ConnectivityState getState() {
+      return this.state;
+    }
+
+    public boolean isCompletedConnectivityAttempt() {
+      return completedConnectivityAttempt;
+    }
+
+    private void updateState(ConnectivityState newState) {
+      this.state = newState;
+      if (newState == READY || newState == TRANSIENT_FAILURE) {
+        completedConnectivityAttempt = true;
+      } else if (newState == IDLE) {
+        completedConnectivityAttempt = false;
+      }
+    }
+
+    private ConnectivityState getHealthState() {
+      return healthStateInfo.getState();
+    }
+  }
+
+  public static final class PickFirstLeafLoadBalancerConfig {
+
+    @Nullable
+    public final Boolean shuffleAddressList;
+
+    // For testing purposes only, not meant to be parsed from a real config.
+    @Nullable
+    final Long randomSeed;
+
+    public PickFirstLeafLoadBalancerConfig(@Nullable Boolean shuffleAddressList) {
+      this(shuffleAddressList, null);
+    }
+
+    PickFirstLeafLoadBalancerConfig(@Nullable Boolean shuffleAddressList,
+        @Nullable Long randomSeed) {
+      this.shuffleAddressList = shuffleAddressList;
+      this.randomSeed = randomSeed;
+    }
+  }
+
+}
diff --git a/core/src/main/java/io/grpc/internal/PickFirstLoadBalancer.java b/core/src/main/java/io/grpc/internal/PickFirstLoadBalancer.java
new file mode 100644
index 00000000000..aa8b5a7e9a9
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/PickFirstLoadBalancer.java
@@ -0,0 +1,205 @@
+/*
+ * Copyright 2015 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.Status;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicBoolean;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link LoadBalancer} that provides no load-balancing over the addresses from the {@link
+ * io.grpc.NameResolver}.  The channel's default behavior is used, which is walking down the address
+ * list and sticking to the first that works.
+ */
+final class PickFirstLoadBalancer extends LoadBalancer {
+  private final Helper helper;
+  private Subchannel subchannel;
+  private ConnectivityState currentState = IDLE;
+
+  PickFirstLoadBalancer(Helper helper) {
+    this.helper = checkNotNull(helper, "helper");
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    List<EquivalentAddressGroup> servers = resolvedAddresses.getAddresses();
+    if (servers.isEmpty()) {
+      Status unavailableStatus = Status.UNAVAILABLE.withDescription(
+              "NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+                      + ", attrs=" + resolvedAddresses.getAttributes());
+      handleNameResolutionError(unavailableStatus);
+      return unavailableStatus;
+    }
+
+    // We can optionally be configured to shuffle the address list. This can help better distribute
+    // the load.
+    if (resolvedAddresses.getLoadBalancingPolicyConfig() instanceof PickFirstLoadBalancerConfig) {
+      PickFirstLoadBalancerConfig config
+          = (PickFirstLoadBalancerConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+      if (config.shuffleAddressList != null && config.shuffleAddressList) {
+        servers = new ArrayList<EquivalentAddressGroup>(servers);
+        Collections.shuffle(servers,
+            config.randomSeed != null ? new Random(config.randomSeed) : new Random());
+      }
+    }
+
+    if (subchannel == null) {
+      final Subchannel subchannel = helper.createSubchannel(
+          CreateSubchannelArgs.newBuilder()
+              .setAddresses(servers)
+              .build());
+      subchannel.start(new SubchannelStateListener() {
+          @Override
+          public void onSubchannelState(ConnectivityStateInfo stateInfo) {
+            processSubchannelState(subchannel, stateInfo);
+          }
+        });
+      this.subchannel = subchannel;
+
+      // The channel state does not get updated when doing name resolving today, so for the moment
+      // let LB report CONNECTION and call subchannel.requestConnection() immediately.
+      updateBalancingState(CONNECTING, new FixedResultPicker(PickResult.withNoResult()));
+      subchannel.requestConnection();
+    } else {
+      subchannel.updateAddresses(servers);
+    }
+
+    return Status.OK;
+  }
+
+  @Override
+  public void handleNameResolutionError(Status error) {
+    if (subchannel != null) {
+      subchannel.shutdown();
+      subchannel = null;
+    }
+
+    // NB(lukaszx0) Whether we should propagate the error unconditionally is arguable. It's fine
+    // for time being.
+    updateBalancingState(TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
+  }
+
+  private void processSubchannelState(Subchannel subchannel, ConnectivityStateInfo stateInfo) {
+    ConnectivityState newState = stateInfo.getState();
+    if (newState == SHUTDOWN) {
+      return;
+    }
+    if (newState == TRANSIENT_FAILURE || newState == IDLE) {
+      helper.refreshNameResolution();
+    }
+
+    // If we are transitioning from a TRANSIENT_FAILURE to CONNECTING or IDLE we ignore this state
+    // transition and still keep the LB in TRANSIENT_FAILURE state. This is referred to as "sticky
+    // transient failure". Only a subchannel state change to READY will get the LB out of
+    // TRANSIENT_FAILURE. If the state is IDLE we additionally request a new connection so that we
+    // keep retrying for a connection.
+    if (currentState == TRANSIENT_FAILURE) {
+      if (newState == CONNECTING) {
+        return;
+      } else if (newState == IDLE) {
+        requestConnection();
+        return;
+      }
+    }
+
+    SubchannelPicker picker;
+    switch (newState) {
+      case IDLE:
+        picker = new RequestConnectionPicker();
+        break;
+      case CONNECTING:
+        // It's safe to use RequestConnectionPicker here, so when coming from IDLE we could leave
+        // the current picker in-place. But ignoring the potential optimization is simpler.
+        picker = new FixedResultPicker(PickResult.withNoResult());
+        break;
+      case READY:
+        picker = new FixedResultPicker(PickResult.withSubchannel(subchannel));
+        break;
+      case TRANSIENT_FAILURE:
+        picker = new FixedResultPicker(PickResult.withError(stateInfo.getStatus()));
+        break;
+      default:
+        throw new IllegalArgumentException("Unsupported state:" + newState);
+    }
+
+    updateBalancingState(newState, picker);
+  }
+
+  private void updateBalancingState(ConnectivityState state, SubchannelPicker picker) {
+    currentState = state;
+    helper.updateBalancingState(state, picker);
+  }
+
+  @Override
+  public void shutdown() {
+    if (subchannel != null) {
+      subchannel.shutdown();
+    }
+  }
+
+  @Override
+  public void requestConnection() {
+    if (subchannel != null) {
+      subchannel.requestConnection();
+    }
+  }
+
+  /** Picker that requests connection during the first pick, and returns noResult. */
+  private final class RequestConnectionPicker extends SubchannelPicker {
+    private final AtomicBoolean connectionRequested = new AtomicBoolean(false);
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      if (connectionRequested.compareAndSet(false, true)) {
+        helper.getSynchronizationContext().execute(PickFirstLoadBalancer.this::requestConnection);
+      }
+      return PickResult.withNoResult();
+    }
+  }
+
+  public static final class PickFirstLoadBalancerConfig {
+
+    @Nullable
+    public final Boolean shuffleAddressList;
+
+    // For testing purposes only, not meant to be parsed from a real config.
+    @Nullable final Long randomSeed;
+
+    public PickFirstLoadBalancerConfig(@Nullable Boolean shuffleAddressList) {
+      this(shuffleAddressList, null);
+    }
+
+    PickFirstLoadBalancerConfig(@Nullable Boolean shuffleAddressList, @Nullable Long randomSeed) {
+      this.shuffleAddressList = shuffleAddressList;
+      this.randomSeed = randomSeed;
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/PickFirstLoadBalancerProvider.java b/core/src/main/java/io/grpc/internal/PickFirstLoadBalancerProvider.java
new file mode 100644
index 00000000000..83b3fb7d8e6
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/PickFirstLoadBalancerProvider.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2018 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.internal;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.PickFirstLeafLoadBalancer.PickFirstLeafLoadBalancerConfig;
+import io.grpc.internal.PickFirstLoadBalancer.PickFirstLoadBalancerConfig;
+import java.util.Map;
+
+/**
+ * Provider for the "pick_first" balancing policy.
+ *
+ * <p>This provides no load-balancing over the addresses from the {@link NameResolver}.  It walks
+ * down the address list and sticks to the first that works.
+ */
+public final class PickFirstLoadBalancerProvider extends LoadBalancerProvider {
+  public static final String GRPC_PF_USE_HAPPY_EYEBALLS = "GRPC_PF_USE_HAPPY_EYEBALLS";
+  private static final String SHUFFLE_ADDRESS_LIST_KEY = "shuffleAddressList";
+
+  static boolean enableNewPickFirst =
+      GrpcUtil.getFlag("GRPC_EXPERIMENTAL_ENABLE_NEW_PICK_FIRST", false);
+
+  public static boolean isEnabledHappyEyeballs() {
+
+    return GrpcUtil.getFlag(GRPC_PF_USE_HAPPY_EYEBALLS, false);
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return "pick_first";
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+    if (enableNewPickFirst) {
+      return new PickFirstLeafLoadBalancer(helper);
+    } else {
+      return new PickFirstLoadBalancer(helper);
+    }
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawLbPolicyConfig) {
+    try {
+      Object config = getLbPolicyConfig(rawLbPolicyConfig);
+      return ConfigOrError.fromConfig(config);
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError(
+          Status.UNAVAILABLE.withCause(e).withDescription(
+              "Failed parsing configuration for " + getPolicyName()));
+    }
+  }
+
+  private static Object getLbPolicyConfig(Map<String, ?> rawLbPolicyConfig) {
+    Boolean shuffleAddressList = JsonUtil.getBoolean(rawLbPolicyConfig, SHUFFLE_ADDRESS_LIST_KEY);
+    if (enableNewPickFirst) {
+      return new PickFirstLeafLoadBalancerConfig(shuffleAddressList);
+    } else {
+      return new PickFirstLoadBalancerConfig(shuffleAddressList);
+    }
+  }
+
+  @VisibleForTesting
+  public static boolean isEnabledNewPickFirst() {
+    return enableNewPickFirst;
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/PickSubchannelArgsImpl.java b/core/src/main/java/io/grpc/internal/PickSubchannelArgsImpl.java
new file mode 100644
index 00000000000..c61fcac6f69
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/PickSubchannelArgsImpl.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2016 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Objects;
+import io.grpc.CallOptions;
+import io.grpc.LoadBalancer.PickDetailsConsumer;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+
+/** Implementation of {@link PickSubchannelArgs}. */
+public final class PickSubchannelArgsImpl extends PickSubchannelArgs {
+  private final CallOptions callOptions;
+  private final Metadata headers;
+  private final MethodDescriptor<?, ?> method;
+  private final PickDetailsConsumer pickDetailsConsumer;
+
+  /**
+   * Creates call args object for given method with its call options, metadata.
+   */
+  public PickSubchannelArgsImpl(
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+      PickDetailsConsumer pickDetailsConsumer) {
+    this.method = checkNotNull(method, "method");
+    this.headers = checkNotNull(headers, "headers");
+    this.callOptions = checkNotNull(callOptions, "callOptions");
+    this.pickDetailsConsumer = checkNotNull(pickDetailsConsumer, "pickDetailsConsumer");
+  }
+
+  @Override
+  public Metadata getHeaders() {
+    return headers;
+  }
+
+  @Override
+  public CallOptions getCallOptions() {
+    return callOptions;
+  }
+
+  @Override
+  public MethodDescriptor<?, ?> getMethodDescriptor() {
+    return method;
+  }
+
+  @Override
+  public PickDetailsConsumer getPickDetailsConsumer() {
+    return pickDetailsConsumer;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    PickSubchannelArgsImpl that = (PickSubchannelArgsImpl) o;
+    return Objects.equal(callOptions, that.callOptions)
+        && Objects.equal(headers, that.headers)
+        && Objects.equal(method, that.method)
+        && Objects.equal(pickDetailsConsumer, that.pickDetailsConsumer);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(callOptions, headers, method, pickDetailsConsumer);
+  }
+
+  @Override
+  public final String toString() {
+    return "[method=" + method + " headers=" + headers + " callOptions=" + callOptions + "]";
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ProxyDetectorImpl.java b/core/src/main/java/io/grpc/internal/ProxyDetectorImpl.java
new file mode 100644
index 00000000000..58c7803346f
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ProxyDetectorImpl.java
@@ -0,0 +1,266 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Supplier;
+import io.grpc.HttpConnectProxiedSocketAddress;
+import io.grpc.ProxiedSocketAddress;
+import io.grpc.ProxyDetector;
+import java.io.IOException;
+import java.net.Authenticator;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.MalformedURLException;
+import java.net.PasswordAuthentication;
+import java.net.Proxy;
+import java.net.ProxySelector;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * A utility class that detects proxies using {@link ProxySelector} and detects authentication
+ * credentials using {@link Authenticator}.
+ *
+ */
+class ProxyDetectorImpl implements ProxyDetector {
+  // To validate this code: set up a local squid proxy instance, and
+  // try to communicate with grpc-test.sandbox.googleapis.com:443.
+  // The endpoint runs an instance of TestServiceGrpc, see
+  // AbstractInteropTest for an example how to run a
+  // TestService.EmptyCall RPC.
+  //
+  // The instructions below assume Squid 3.5.23 and a recent
+  // version of Debian.
+  //
+  // Set the contents of /etc/squid/squid.conf to be:
+  // WARNING: THESE CONFIGS HAVE NOT BEEN REVIEWED FOR SECURITY, DO
+  // NOT USE OUTSIDE OF TESTING. COMMENT OUT THIS WARNING TO
+  // UNBREAK THE CONFIG FILE.
+  // acl SSL_ports port 443
+  // acl Safe_ports port 80
+  // acl Safe_ports port 21
+  // acl Safe_ports port 443
+  // acl Safe_ports port 70
+  // acl Safe_ports port 210
+  // acl Safe_ports port 1025-65535
+  // acl Safe_ports port 280
+  // acl Safe_ports port 488
+  // acl Safe_ports port 591
+  // acl Safe_ports port 777
+  // acl CONNECT method CONNECT
+  // http_access deny !Safe_ports
+  // http_access deny CONNECT !SSL_ports
+  // http_access allow localhost manager
+  // http_access deny manager
+  // http_access allow localhost
+  // http_access deny all
+  // http_port 3128
+  // coredump_dir /var/spool/squid
+  // refresh_pattern ^ftp: 1440 20% 10080
+  // refresh_pattern ^gopher: 1440 0% 1440
+  // refresh_pattern -i (/cgi-bin/|\?) 0 0% 0
+  // refresh_pattern . 0 20% 4320
+  //
+  // Restart squid:
+  // $ sudo /etc/init.d/squid restart
+  //
+  // To test with passwords:
+  //
+  // Run this command and follow the instructions to set up a user/pass:
+  // $ sudo htpasswd -c /etc/squid/passwd myuser1
+  //
+  // Make the file readable to squid:
+  // $ sudo chmod 644 /etc/squid/passwd
+  //
+  // Validate the username and password, you should see OK printed:
+  // $ /usr/lib/squid3/basic_ncsa_auth /etc/squid/passwd
+  // myuser1 <your password here>
+  //
+  // Add these additional lines to the beginning of squid.conf (the ordering matters):
+  // auth_param basic program /usr/lib/squid3/basic_ncsa_auth /etc/squid/passwd
+  // auth_param basic children 5
+  // auth_param basic realm Squid proxy-caching web server
+  // auth_param basic credentialsttl 2 hours
+  // acl ncsa_users proxy_auth REQUIRED
+  // http_access allow ncsa_users
+  //
+  // Restart squid:
+  // $ sudo /etc/init.d/squid restart
+  //
+  // In both cases, start the JVM with -Dhttps.proxyHost=127.0.0.1 -Dhttps.proxyPort=3128 to
+  // configure the proxy. For passwords, use java.net.Authenticator.setDefault().
+  //
+  // Testing with curl, no password:
+  // $ curl -U myuser1:pass1 -x http://localhost:3128 -L grpc.io
+  // Testing with curl, with password:
+  // $ curl -U myuser1:pass1 -x http://localhost:3128 -L grpc.io
+  //
+  // It may be helpful to monitor the squid access logs:
+  // $ sudo tail -f /var/log/squid/access.log
+
+  private static final Logger log = Logger.getLogger(ProxyDetectorImpl.class.getName());
+  private static final AuthenticationProvider DEFAULT_AUTHENTICATOR = new AuthenticationProvider() {
+    @Override
+    public PasswordAuthentication requestPasswordAuthentication(
+        String host, InetAddress addr, int port, String protocol, String prompt, String scheme) {
+      URL url = null;
+      try {
+        url = new URL(protocol, host, port, "");
+      } catch (MalformedURLException e) {
+        // let url be null
+        log.log(
+            Level.WARNING,
+            "failed to create URL for Authenticator: {0} {1}", new Object[] {protocol, host});
+      }
+      return Authenticator.requestPasswordAuthentication(
+          host, addr, port, protocol, prompt, scheme, url, Authenticator.RequestorType.PROXY);
+    }
+  };
+  private static final Supplier<ProxySelector> DEFAULT_PROXY_SELECTOR =
+      new Supplier<ProxySelector>() {
+        @Override
+        public ProxySelector get() {
+          return ProxySelector.getDefault();
+        }
+      };
+
+  // Do not hard code a ProxySelector because the global default ProxySelector can change
+  private final Supplier<ProxySelector> proxySelector;
+  private final AuthenticationProvider authenticationProvider;
+
+  // We want an HTTPS proxy, which operates on the entire data stream (See IETF rfc2817).
+  static final String PROXY_SCHEME = "https";
+
+  /**
+   * A proxy selector that uses the global {@link ProxySelector#getDefault()} and
+   * {@link ProxyDetectorImpl.AuthenticationProvider} to detect proxy parameters.
+   */
+  public ProxyDetectorImpl() {
+    this(DEFAULT_PROXY_SELECTOR, DEFAULT_AUTHENTICATOR);
+  }
+
+  @VisibleForTesting
+  ProxyDetectorImpl(
+      Supplier<ProxySelector> proxySelector,
+      AuthenticationProvider authenticationProvider) {
+    this.proxySelector = checkNotNull(proxySelector);
+    this.authenticationProvider = checkNotNull(authenticationProvider);
+  }
+
+  @Nullable
+  @Override
+  public ProxiedSocketAddress proxyFor(SocketAddress targetServerAddress) throws IOException {
+    if (!(targetServerAddress instanceof InetSocketAddress)) {
+      return null;
+    }
+    return detectProxy((InetSocketAddress) targetServerAddress);
+  }
+
+  private ProxiedSocketAddress detectProxy(InetSocketAddress targetAddr) throws IOException {
+    URI uri;
+    String host = targetAddr.getHostString();
+    try {
+      uri =
+          new URI(
+              PROXY_SCHEME,
+              null, /* userInfo */
+              host,
+              targetAddr.getPort(),
+              null, /* path */
+              null, /* query */
+              null /* fragment */);
+    } catch (final URISyntaxException e) {
+      log.log(
+          Level.WARNING,
+          "Failed to construct URI for proxy lookup, proceeding without proxy",
+          e);
+      return null;
+    }
+
+    ProxySelector proxySelector = this.proxySelector.get();
+    if (proxySelector == null) {
+      log.log(Level.FINE, "proxy selector is null, so continuing without proxy lookup");
+      return null;
+    }
+
+    List<Proxy> proxies = proxySelector.select(uri);
+    if (proxies.size() > 1) {
+      log.warning("More than 1 proxy detected, gRPC will select the first one");
+    }
+    Proxy proxy = proxies.get(0);
+
+    if (proxy.type() == Proxy.Type.DIRECT) {
+      return null;
+    }
+    InetSocketAddress proxyAddr = (InetSocketAddress) proxy.address();
+    // The prompt string should be the realm as returned by the server.
+    // We don't have it because we are avoiding the full handshake.
+    String promptString = "";
+    PasswordAuthentication auth =
+        authenticationProvider.requestPasswordAuthentication(
+            proxyAddr.getHostString(),
+            proxyAddr.getAddress(),
+            proxyAddr.getPort(),
+            PROXY_SCHEME,
+            promptString,
+            null);
+
+    final InetSocketAddress resolvedProxyAddr;
+    if (proxyAddr.isUnresolved()) {
+      InetAddress resolvedAddress = InetAddress.getByName(proxyAddr.getHostName());
+      resolvedProxyAddr = new InetSocketAddress(resolvedAddress, proxyAddr.getPort());
+    } else {
+      resolvedProxyAddr = proxyAddr;
+    }
+
+    HttpConnectProxiedSocketAddress.Builder builder =
+        HttpConnectProxiedSocketAddress.newBuilder()
+        .setTargetAddress(targetAddr)
+        .setProxyAddress(resolvedProxyAddr);
+
+    if (auth == null) {
+      return builder.build();
+    }
+
+    return builder
+        .setUsername(auth.getUserName())
+        .setPassword(auth.getPassword() == null ? null : new String(auth.getPassword()))
+        .build();
+  }
+
+  /**
+   * This interface makes unit testing easier by avoiding direct calls to static methods.
+   */
+  interface AuthenticationProvider {
+    PasswordAuthentication requestPasswordAuthentication(
+        String host,
+        InetAddress addr,
+        int port,
+        String protocol,
+        String prompt,
+        String scheme);
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ReadableBuffer.java b/core/src/main/java/io/grpc/internal/ReadableBuffer.java
index 02e268e39a0..20f64719875 100644
--- a/core/src/main/java/io/grpc/internal/ReadableBuffer.java
+++ b/core/src/main/java/io/grpc/internal/ReadableBuffer.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -35,6 +20,7 @@
 import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.ByteBuffer;
+import javax.annotation.Nullable;
 
 /**
  * Interface for an abstract byte buffer. Buffers are intended to be a read-only, except for the
@@ -58,22 +44,6 @@ public interface ReadableBuffer extends Closeable {
    */
   int readUnsignedByte();
 
-  /**
-   * Reads a 3-byte unsigned integer from this buffer using big-endian byte ordering. Increments the
-   * read position by 3.
-   *
-   * @throws IndexOutOfBoundsException if required bytes are not readable
-   */
-  int readUnsignedMedium();
-
-  /**
-   * Reads a 2-byte unsigned integer from this buffer using big-endian byte ordering. Increments the
-   * read position by 2.
-   *
-   * @throws IndexOutOfBoundsException if required bytes are not readable
-   */
-  int readUnsignedShort();
-
   /**
    * Reads a 4-byte signed integer from this buffer using big-endian byte ordering. Increments the
    * read position by 4.
@@ -101,15 +71,6 @@ public interface ReadableBuffer extends Closeable {
    */
   void readBytes(byte[] dest, int destOffset, int length);
 
-  /**
-   * Reads from this buffer until the destination's position reaches its limit, and increases the
-   * read position by the number of the transferred bytes.
-   *
-   * @param dest the destination buffer to receive the bytes.
-   * @throws IndexOutOfBoundsException if required bytes are not readable
-   */
-  void readBytes(ByteBuffer dest);
-
   /**
    * Reads {@code length} bytes from this buffer and writes them to the destination stream.
    * Increments the read position by {@code length}. If the required bytes are not readable, throws
@@ -154,6 +115,52 @@ public interface ReadableBuffer extends Closeable {
    */
   int arrayOffset();
 
+  /**
+   * Note that the current callsite has access to this buffer, or do nothing. This is only useful
+   * when the buffer has leak detection and intrumentation to record usages before the buffer was
+   * leaked. That can make it much easier to track down where the buffer was leaked. If this isn't
+   * such a buffer, the method does nothing.
+   */
+  default void touch() {}
+
+  /**
+   * Indicates whether or not {@link #mark} operation is supported for this buffer.
+   */
+  boolean markSupported();
+
+  /**
+   * Marks the current position in this buffer. A subsequent call to the {@link #reset} method
+   * repositions this stream at the last marked position so that subsequent reads re-read the same
+   * bytes.
+   */
+  void mark();
+
+  /**
+   * Repositions this buffer to the position at the time {@link #mark} was last called on this
+   * buffer.
+   */
+  void reset();
+
+  /**
+   * Indicates whether or not {@link #getByteBuffer} operation is supported for this buffer.
+   */
+  boolean byteBufferSupported();
+
+  /**
+   * Gets a {@link ByteBuffer} that contains some bytes of the content next to be read, or {@code
+   * null} if this buffer has been exhausted. The number of bytes contained in the returned buffer
+   * is implementation specific. The position of this buffer is unchanged after calling this
+   * method. The returned buffer's content should not be modified, but the position, limit, and
+   * mark may be changed. Operations for changing the position, limit, and mark of the returned
+   * buffer does not affect the position, limit, and mark of this buffer. Buffers returned by this
+   * method have independent position, limit and mark. This is an optional method, so callers
+   * should first check {@link #byteBufferSupported}.
+   *
+   * @throws UnsupportedOperationException the buffer does not support this method.
+   */
+  @Nullable
+  ByteBuffer getByteBuffer();
+
   /**
    * Closes this buffer and releases any resources.
    */
diff --git a/core/src/main/java/io/grpc/internal/ReadableBuffers.java b/core/src/main/java/io/grpc/internal/ReadableBuffers.java
index 38a29069b7e..439745e29b2 100644
--- a/core/src/main/java/io/grpc/internal/ReadableBuffers.java
+++ b/core/src/main/java/io/grpc/internal/ReadableBuffers.java
@@ -1,45 +1,35 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
-import static com.google.common.base.Charsets.UTF_8;
+import static java.nio.charset.StandardCharsets.UTF_8;
 
 import com.google.common.base.Preconditions;
+import io.grpc.Detachable;
+import io.grpc.HasByteBuffer;
 import io.grpc.KnownLength;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.nio.Buffer;
 import java.nio.ByteBuffer;
+import java.nio.InvalidMarkException;
 import java.nio.charset.Charset;
+import javax.annotation.Nullable;
 
 /**
  * Utility methods for creating {@link ReadableBuffer} instances.
@@ -142,6 +132,7 @@ private static class ByteArrayWrapper extends AbstractReadableBuffer {
     int offset;
     final int end;
     final byte[] bytes;
+    int mark = -1;
 
     ByteArrayWrapper(byte[] bytes) {
       this(bytes, 0, bytes.length);
@@ -180,15 +171,6 @@ public void readBytes(byte[] dest, int destIndex, int length) {
       offset += length;
     }
 
-    @Override
-    public void readBytes(ByteBuffer dest) {
-      Preconditions.checkNotNull(dest, "dest");
-      int length = dest.remaining();
-      checkReadable(length);
-      dest.put(bytes, offset, length);
-      offset += length;
-    }
-
     @Override
     public void readBytes(OutputStream dest, int length) throws IOException {
       checkReadable(length);
@@ -218,6 +200,24 @@ public byte[] array() {
     public int arrayOffset() {
       return offset;
     }
+
+    @Override
+    public boolean markSupported() {
+      return true;
+    }
+
+    @Override
+    public void mark() {
+      mark = offset;
+    }
+
+    @Override
+    public void reset() {
+      if (mark == -1) {
+        throw new InvalidMarkException();
+      }
+      offset = mark;
+    }
   }
 
   /**
@@ -244,7 +244,7 @@ public int readUnsignedByte() {
     @Override
     public void skipBytes(int length) {
       checkReadable(length);
-      bytes.position(bytes.position() + length);
+      ((Buffer) bytes).position(bytes.position() + length);
     }
 
     @Override
@@ -253,27 +253,12 @@ public void readBytes(byte[] dest, int destOffset, int length) {
       bytes.get(dest, destOffset, length);
     }
 
-    @Override
-    public void readBytes(ByteBuffer dest) {
-      Preconditions.checkNotNull(dest, "dest");
-      int length = dest.remaining();
-      checkReadable(length);
-
-      // Change the limit so that only length bytes are available.
-      int prevLimit = bytes.limit();
-      bytes.limit(bytes.position() + length);
-
-      // Write the bytes and restore the original limit.
-      dest.put(bytes);
-      bytes.limit(prevLimit);
-    }
-
     @Override
     public void readBytes(OutputStream dest, int length) throws IOException {
       checkReadable(length);
       if (hasArray()) {
         dest.write(array(), arrayOffset(), length);
-        bytes.position(bytes.position() + length);
+        ((Buffer) bytes).position(bytes.position() + length);
       } else {
         // The buffer doesn't support array(). Copy the data to an intermediate buffer.
         byte[] array = new byte[length];
@@ -286,8 +271,8 @@ public void readBytes(OutputStream dest, int length) throws IOException {
     public ByteReadableBufferWrapper readBytes(int length) {
       checkReadable(length);
       ByteBuffer buffer = bytes.duplicate();
-      buffer.limit(bytes.position() + length);
-      bytes.position(bytes.position() + length);
+      ((Buffer) buffer).limit(bytes.position() + length);
+      ((Buffer) bytes).position(bytes.position() + length);
       return new ByteReadableBufferWrapper(buffer);
     }
 
@@ -305,13 +290,39 @@ public byte[] array() {
     public int arrayOffset() {
       return bytes.arrayOffset() + bytes.position();
     }
+
+    @Override
+    public boolean markSupported() {
+      return true;
+    }
+
+    @Override
+    public void mark() {
+      bytes.mark();
+    }
+
+    @Override
+    public void reset() {
+      bytes.reset();
+    }
+
+    @Override
+    public boolean byteBufferSupported() {
+      return true;
+    }
+
+    @Override
+    public ByteBuffer getByteBuffer() {
+      return bytes.slice();
+    }
   }
 
   /**
    * An {@link InputStream} that is backed by a {@link ReadableBuffer}.
    */
-  private static final class BufferInputStream extends InputStream implements KnownLength {
-    final ReadableBuffer buffer;
+  private static final class BufferInputStream extends InputStream
+      implements KnownLength, HasByteBuffer, Detachable {
+    private ReadableBuffer buffer;
 
     public BufferInputStream(ReadableBuffer buffer) {
       this.buffer = Preconditions.checkNotNull(buffer, "buffer");
@@ -342,6 +353,52 @@ public int read(byte[] dest, int destOffset, int length) throws IOException {
       buffer.readBytes(dest, destOffset, length);
       return length;
     }
+
+    @Override
+    public long skip(long n) throws IOException {
+      int length = (int) Math.min(buffer.readableBytes(), n);
+      buffer.skipBytes(length);
+      return length;
+    }
+
+    @Override
+    public void mark(int readlimit) {
+      buffer.mark();
+    }
+
+    @Override
+    public void reset() throws IOException {
+      buffer.reset();
+    }
+
+    @Override
+    public boolean markSupported() {
+      return buffer.markSupported();
+    }
+
+    @Override
+    public boolean byteBufferSupported() {
+      return buffer.byteBufferSupported();
+    }
+
+    @Nullable
+    @Override
+    public ByteBuffer getByteBuffer() {
+      return buffer.getByteBuffer();
+    }
+
+    @Override
+    public InputStream detach() {
+      ReadableBuffer detachedBuffer = buffer;
+      buffer = buffer.readBytes(0);
+      detachedBuffer.touch();
+      return new BufferInputStream(detachedBuffer);
+    }
+
+    @Override
+    public void close() throws IOException {
+      buffer.close();
+    }
   }
 
   private ReadableBuffers() {}
diff --git a/core/src/main/java/io/grpc/internal/ReflectionLongAdderCounter.java b/core/src/main/java/io/grpc/internal/ReflectionLongAdderCounter.java
new file mode 100644
index 00000000000..fddeee82c14
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ReflectionLongAdderCounter.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2017 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.internal;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A {@link LongCounter} that is implemented with a JDK8 {@link LongAdder}. Instantiates the object
+ * and invokes methods reflectively to avoid a compile time dependency on LongAdder.
+ */
+public final class ReflectionLongAdderCounter implements LongCounter {
+  private static final Logger logger = Logger.getLogger(ReflectionLongAdderCounter.class.getName());
+  private static final Constructor<?> defaultConstructor;
+  private static final Method addMethod;
+  private static final Method sumMethod;
+  private static final RuntimeException initializationException;
+
+  private final Object instance;
+
+  static {
+    Class<?> klass = null;
+    Constructor<?> defaultConstructorLookup = null;
+    Method addMethodLookup = null;
+    Method sumMethodLookup = null;
+    Throwable caught = null;
+    try {
+      klass = Class.forName("java.util.concurrent.atomic.LongAdder");
+
+      addMethodLookup = klass.getMethod("add", Long.TYPE);
+      sumMethodLookup = klass.getMethod("sum");
+
+      Constructor<?>[] constructors = klass.getConstructors();
+      for (Constructor<?> ctor : constructors) {
+        if (ctor.getParameterTypes().length == 0) {
+          defaultConstructorLookup = ctor;
+          break;
+        }
+      }
+    } catch (Throwable e) {
+      logger.log(
+          Level.FINE,
+          "LongAdder can not be found via reflection, this is normal for JDK7 and below",
+          e);
+      caught = e;
+    }
+
+    if (caught == null && defaultConstructorLookup != null) {
+      defaultConstructor = defaultConstructorLookup;
+      addMethod = addMethodLookup;
+      sumMethod = sumMethodLookup;
+      initializationException = null;
+    } else {
+      defaultConstructor = null;
+      addMethod = null;
+      sumMethod = null;
+      initializationException = new RuntimeException(caught);
+    }
+  }
+
+  ReflectionLongAdderCounter() {
+    if (initializationException != null) {
+      throw initializationException;
+    }
+    try {
+      instance = defaultConstructor.newInstance();
+    } catch (InstantiationException e) {
+      throw new RuntimeException(e);
+    } catch (IllegalAccessException e) {
+      throw new RuntimeException(e);
+    } catch (InvocationTargetException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * Returns true if the environment supports LongAdder. In other words, we are running in >= JDK8.
+   */
+  static boolean isAvailable() {
+    return initializationException == null;
+  }
+
+  private static final Object[] one = new Object[] { 1L };
+
+  @Override
+  public void add(long delta) {
+    try {
+      addMethod.invoke(instance, delta == 1L ? one : new Object[] { delta });
+    } catch (IllegalAccessException e) {
+      throw new RuntimeException(e);
+    } catch (InvocationTargetException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Override
+  public long value() {
+    try {
+      return (Long) sumMethod.invoke(instance);
+    } catch (IllegalAccessException e) {
+      throw new RuntimeException();
+    } catch (InvocationTargetException e) {
+      throw new RuntimeException();
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/Rescheduler.java b/core/src/main/java/io/grpc/internal/Rescheduler.java
new file mode 100644
index 00000000000..75a106e895f
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/Rescheduler.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2018 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.internal;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Stopwatch;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Reschedules a runnable lazily.
+ */
+final class Rescheduler {
+
+  // deps
+  private final ScheduledExecutorService scheduler;
+  private final Executor serializingExecutor;
+  private final Runnable runnable;
+
+  // state
+  private final Stopwatch stopwatch;
+  private long runAtNanos;
+  private boolean enabled;
+  private ScheduledFuture<?> wakeUp;
+
+  Rescheduler(
+      Runnable r,
+      Executor serializingExecutor,
+      ScheduledExecutorService scheduler,
+      Stopwatch stopwatch) {
+    this.runnable = r;
+    this.serializingExecutor = serializingExecutor;
+    this.scheduler = scheduler;
+    this.stopwatch = stopwatch;
+    stopwatch.start();
+  }
+
+  /* must be called from the {@link #serializingExecutor} originally passed in. */
+  void reschedule(long delay, TimeUnit timeUnit) {
+    long delayNanos = timeUnit.toNanos(delay);
+    long newRunAtNanos = nanoTime() + delayNanos;
+    enabled = true;
+    if (newRunAtNanos - runAtNanos < 0 || wakeUp == null) {
+      if (wakeUp != null) {
+        wakeUp.cancel(false);
+      }
+      wakeUp = scheduler.schedule(new FutureRunnable(), delayNanos, TimeUnit.NANOSECONDS);
+    }
+    runAtNanos = newRunAtNanos;
+  }
+
+  // must be called from channel executor
+  void cancel(boolean permanent) {
+    enabled = false;
+    if (permanent && wakeUp != null) {
+      wakeUp.cancel(false);
+      wakeUp = null;
+    }
+  }
+
+  private final class FutureRunnable implements Runnable {
+    @Override
+    public void run() {
+      Rescheduler.this.serializingExecutor.execute(new ChannelFutureRunnable());
+    }
+
+    private boolean isEnabled() {
+      return Rescheduler.this.enabled;
+    }
+  }
+
+  private final class ChannelFutureRunnable implements Runnable {
+
+    @Override
+    public void run() {
+      if (!enabled) {
+        wakeUp = null;
+        return;
+      }
+      long now = nanoTime();
+      if (runAtNanos - now > 0) {
+        wakeUp = scheduler.schedule(
+            new FutureRunnable(), runAtNanos - now,  TimeUnit.NANOSECONDS);
+      } else {
+        enabled = false;
+        wakeUp = null;
+        runnable.run();
+      }
+    }
+  }
+
+  @VisibleForTesting
+  static boolean isEnabled(Runnable r) {
+    return ((FutureRunnable) r).isEnabled();
+  }
+
+  private long nanoTime() {
+    return stopwatch.elapsed(TimeUnit.NANOSECONDS);
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/RetriableStream.java b/core/src/main/java/io/grpc/internal/RetriableStream.java
new file mode 100644
index 00000000000..96816eb6f15
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/RetriableStream.java
@@ -0,0 +1,1615 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Objects;
+import com.google.errorprone.annotations.CheckReturnValue;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Compressor;
+import io.grpc.Deadline;
+import io.grpc.DecompressorRegistry;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
+import java.io.InputStream;
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+
+/** A logical {@link ClientStream} that is retriable. */
+abstract class RetriableStream<ReqT> implements ClientStream {
+  @VisibleForTesting
+  static final Metadata.Key<String> GRPC_PREVIOUS_RPC_ATTEMPTS =
+      Metadata.Key.of("grpc-previous-rpc-attempts", Metadata.ASCII_STRING_MARSHALLER);
+
+  @VisibleForTesting
+  static final Metadata.Key<String> GRPC_RETRY_PUSHBACK_MS =
+      Metadata.Key.of("grpc-retry-pushback-ms", Metadata.ASCII_STRING_MARSHALLER);
+
+  private static final Status CANCELLED_BECAUSE_COMMITTED =
+      Status.CANCELLED.withDescription("Stream thrown away because RetriableStream committed");
+
+  private final MethodDescriptor<ReqT, ?> method;
+  private final Executor callExecutor;
+  private final Executor listenerSerializeExecutor = new SynchronizationContext(
+      new UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw Status.fromThrowable(e)
+              .withDescription("Uncaught exception in the SynchronizationContext. Re-thrown.")
+              .asRuntimeException();
+        }
+      }
+  );
+  private final ScheduledExecutorService scheduledExecutorService;
+  // Must not modify it.
+  private final Metadata headers;
+  @Nullable
+  private final RetryPolicy retryPolicy;
+  @Nullable
+  private final HedgingPolicy hedgingPolicy;
+  private final boolean isHedging;
+
+  /** Must be held when updating state, accessing state.buffer, or certain substream attributes. */
+  private final Object lock = new Object();
+
+  private final ChannelBufferMeter channelBufferUsed;
+  private final long perRpcBufferLimit;
+  private final long channelBufferLimit;
+  @Nullable
+  private final Throttle throttle;
+  @GuardedBy("lock")
+  private final InsightBuilder closedSubstreamsInsight = new InsightBuilder();
+
+  private volatile State state = new State(
+      new ArrayList<BufferEntry>(8), Collections.<Substream>emptyList(), null, null, false, false,
+      false, 0);
+
+  /**
+   * Either non-local transparent retry happened or reached server's application logic.
+   *
+   * <p>Note that local-only transparent retries are unlimited.
+   */
+  private final AtomicBoolean noMoreTransparentRetry = new AtomicBoolean();
+  private final AtomicInteger localOnlyTransparentRetries = new AtomicInteger();
+  private final AtomicInteger inFlightSubStreams = new AtomicInteger();
+  private SavedCloseMasterListenerReason savedCloseMasterListenerReason;
+
+  // Used for recording the share of buffer used for the current call out of the channel buffer.
+  // This field would not be necessary if there is no channel buffer limit.
+  @GuardedBy("lock")
+  private long perRpcBufferUsed;
+
+  private ClientStreamListener masterListener;
+  @GuardedBy("lock")
+  private FutureCanceller scheduledRetry;
+  @GuardedBy("lock")
+  private FutureCanceller scheduledHedging;
+  private long nextBackoffIntervalNanos;
+  private Status cancellationStatus;
+  private boolean isClosed;
+
+  RetriableStream(
+      MethodDescriptor<ReqT, ?> method, Metadata headers,
+      ChannelBufferMeter channelBufferUsed, long perRpcBufferLimit, long channelBufferLimit,
+      Executor callExecutor, ScheduledExecutorService scheduledExecutorService,
+      @Nullable RetryPolicy retryPolicy, @Nullable HedgingPolicy hedgingPolicy,
+      @Nullable Throttle throttle) {
+    this.method = method;
+    this.channelBufferUsed = channelBufferUsed;
+    this.perRpcBufferLimit = perRpcBufferLimit;
+    this.channelBufferLimit = channelBufferLimit;
+    this.callExecutor = callExecutor;
+    this.scheduledExecutorService = scheduledExecutorService;
+    this.headers = headers;
+    this.retryPolicy = retryPolicy;
+    if (retryPolicy != null) {
+      this.nextBackoffIntervalNanos = retryPolicy.initialBackoffNanos;
+    }
+    this.hedgingPolicy = hedgingPolicy;
+    checkArgument(
+        retryPolicy == null || hedgingPolicy == null,
+        "Should not provide both retryPolicy and hedgingPolicy");
+    this.isHedging = hedgingPolicy != null;
+    this.throttle = throttle;
+  }
+
+  @SuppressWarnings("GuardedBy")  // TODO(b/145386688) this.lock==ScheduledCancellor.lock so ok
+  @Nullable // null if already committed
+  @CheckReturnValue
+  private Runnable commit(final Substream winningSubstream) {
+    synchronized (lock) {
+      if (state.winningSubstream != null) {
+        return null;
+      }
+      final Collection<Substream> savedDrainedSubstreams = state.drainedSubstreams;
+
+      state = state.committed(winningSubstream);
+
+      // subtract the share of this RPC from channelBufferUsed.
+      channelBufferUsed.addAndGet(-perRpcBufferUsed);
+
+      final boolean wasCancelled = (scheduledRetry != null) ? scheduledRetry.isCancelled() : false;
+      final Future<?> retryFuture;
+      if (scheduledRetry != null) {
+        retryFuture = scheduledRetry.markCancelled();
+        scheduledRetry = null;
+      } else {
+        retryFuture = null;
+      }
+      // cancel the scheduled hedging if it is scheduled prior to the commitment
+      final Future<?> hedgingFuture;
+      if (scheduledHedging != null) {
+        hedgingFuture = scheduledHedging.markCancelled();
+        scheduledHedging = null;
+      } else {
+        hedgingFuture = null;
+      }
+
+      class CommitTask implements Runnable {
+        @Override
+        public void run() {
+          // For hedging only, not needed for normal retry
+          for (Substream substream : savedDrainedSubstreams) {
+            if (substream != winningSubstream) {
+              substream.stream.cancel(CANCELLED_BECAUSE_COMMITTED);
+            }
+          }
+          if (retryFuture != null) {
+            retryFuture.cancel(false);
+            if (!wasCancelled && inFlightSubStreams.decrementAndGet() == Integer.MIN_VALUE) {
+              assert savedCloseMasterListenerReason != null;
+              listenerSerializeExecutor.execute(
+                  new Runnable() {
+                    @Override
+                    public void run() {
+                      isClosed = true;
+                      masterListener.closed(savedCloseMasterListenerReason.status,
+                          savedCloseMasterListenerReason.progress,
+                          savedCloseMasterListenerReason.metadata);
+                    }
+                  });
+            }
+          }
+
+          if (hedgingFuture != null) {
+            hedgingFuture.cancel(false);
+          }
+
+          postCommit();
+        }
+      }
+
+      return new CommitTask();
+    }
+  }
+
+  abstract void postCommit();
+
+  /**
+   * Calls commit() and if successful runs the post commit task. Post commit task will be non-null
+   * for only once. The post commit task cancels other non-winning streams on separate transport
+   * threads, thus it must be run on the callExecutor to prevent deadlocks between multiple stream
+   * transports.(issues/10314)
+   * This method should be called only in subListener callbacks. This guarantees callExecutor
+   * schedules tasks before master listener closes, which is protected by the inFlightSubStreams
+   * decorative. That is because:
+   * For a successful winning stream, other streams won't attempt to close master listener.
+   * For a cancelled winning stream (noop), other stream won't attempt to close master listener.
+   * For a failed/closed winning stream, the last closed stream closes the master listener, and
+   * callExecutor scheduling happens-before that.
+   */
+  private void commitAndRun(Substream winningSubstream) {
+    Runnable postCommitTask = commit(winningSubstream);
+
+    if (postCommitTask != null) {
+      callExecutor.execute(postCommitTask);
+    }
+  }
+
+  // returns null means we should not create new sub streams, e.g. cancelled or
+  // other close condition is met for retriableStream.
+  @Nullable
+  private Substream createSubstream(int previousAttemptCount, boolean isTransparentRetry,
+                                    boolean isHedgedStream) {
+    int inFlight;
+    do {
+      inFlight = inFlightSubStreams.get();
+      if (inFlight < 0) {
+        return null;
+      }
+    } while (!inFlightSubStreams.compareAndSet(inFlight, inFlight + 1));
+    Substream sub = new Substream(previousAttemptCount);
+    // one tracer per substream
+    final ClientStreamTracer bufferSizeTracer = new BufferSizeTracer(sub);
+    ClientStreamTracer.Factory tracerFactory = new ClientStreamTracer.Factory() {
+      @Override
+      public ClientStreamTracer newClientStreamTracer(
+          ClientStreamTracer.StreamInfo info, Metadata headers) {
+        return bufferSizeTracer;
+      }
+    };
+
+    Metadata newHeaders = updateHeaders(headers, previousAttemptCount);
+    // NOTICE: This set _must_ be done before stream.start() and it actually is.
+    sub.stream = newSubstream(newHeaders, tracerFactory, previousAttemptCount, isTransparentRetry,
+        isHedgedStream);
+    return sub;
+  }
+
+  /**
+   * Creates a new physical ClientStream that represents a retry/hedging attempt. The returned
+   * Client stream is not yet started.
+   */
+  abstract ClientStream newSubstream(
+      Metadata headers, ClientStreamTracer.Factory tracerFactory, int previousAttempts,
+      boolean isTransparentRetry, boolean isHedgedStream);
+
+  /** Adds grpc-previous-rpc-attempts in the headers of a retry/hedging RPC. */
+  @VisibleForTesting
+  final Metadata updateHeaders(
+      Metadata originalHeaders, int previousAttemptCount) {
+    Metadata newHeaders = new Metadata();
+    newHeaders.merge(originalHeaders);
+    if (previousAttemptCount > 0) {
+      newHeaders.put(GRPC_PREVIOUS_RPC_ATTEMPTS, String.valueOf(previousAttemptCount));
+    }
+    return newHeaders;
+  }
+
+  private void drain(Substream substream) {
+    int index = 0;
+    int chunk = 0x80;
+    List<BufferEntry> list = null;
+    boolean streamStarted = false;
+    Runnable onReadyRunnable = null;
+
+    while (true) {
+      State savedState;
+
+      synchronized (lock) {
+        savedState = state;
+        if (savedState.winningSubstream != null && savedState.winningSubstream != substream) {
+          // committed but not me, to be cancelled
+          break;
+        }
+        if (savedState.cancelled) {
+          break;
+        }
+        if (index == savedState.buffer.size()) { // I'm drained
+          state = savedState.substreamDrained(substream);
+          if (!isReady()) {
+            return;
+          }
+          onReadyRunnable = new Runnable() {
+            @Override
+            public void run() {
+              if (!isClosed) {
+                masterListener.onReady();
+              }
+            }
+          };
+          break;
+        }
+
+        if (substream.closed) {
+          return;
+        }
+
+        int stop = Math.min(index + chunk, savedState.buffer.size());
+        if (list == null) {
+          list = new ArrayList<>(savedState.buffer.subList(index, stop));
+        } else {
+          list.clear();
+          list.addAll(savedState.buffer.subList(index, stop));
+        }
+        index = stop;
+      }
+
+      for (BufferEntry bufferEntry : list) {
+        bufferEntry.runWith(substream);
+        if (bufferEntry instanceof RetriableStream.StartEntry) {
+          streamStarted = true;
+        }
+        savedState = state;
+        if (savedState.winningSubstream != null && savedState.winningSubstream != substream) {
+          // committed but not me, to be cancelled
+          break;
+        }
+        if (savedState.cancelled) {
+          break;
+        }
+      }
+    }
+
+    if (onReadyRunnable != null) {
+      listenerSerializeExecutor.execute(onReadyRunnable);
+      return;
+    }
+
+    if (!streamStarted) {
+      // Start stream so inFlightSubStreams is decremented in Sublistener.closed()
+      substream.stream.start(new Sublistener(substream));
+    }
+    substream.stream.cancel(
+        state.winningSubstream == substream ? cancellationStatus : CANCELLED_BECAUSE_COMMITTED);
+  }
+
+  /**
+   * Runs pre-start tasks. Returns the Status of shutdown if the channel is shutdown.
+   */
+  @CheckReturnValue
+  @Nullable
+  abstract Status prestart();
+
+  class StartEntry implements BufferEntry {
+    @Override
+    public void runWith(Substream substream) {
+      substream.stream.start(new Sublistener(substream));
+    }
+  }
+
+  /** Starts the first RPC attempt. */
+  @Override
+  public final void start(ClientStreamListener listener) {
+    masterListener = listener;
+
+    Status shutdownStatus = prestart();
+
+    if (shutdownStatus != null) {
+      cancel(shutdownStatus);
+      return;
+    }
+
+    synchronized (lock) {
+      state.buffer.add(new StartEntry());
+    }
+
+    Substream substream = createSubstream(0, false, false);
+    if (substream == null) {
+      return;
+    }
+    if (isHedging) {
+      FutureCanceller scheduledHedgingRef = null;
+
+      synchronized (lock) {
+        state = state.addActiveHedge(substream);
+        if (hasPotentialHedging(state)
+            && (throttle == null || throttle.isAboveThreshold())) {
+          scheduledHedging = scheduledHedgingRef = new FutureCanceller(lock);
+        }
+      }
+
+      if (scheduledHedgingRef != null) {
+        scheduledHedgingRef.setFuture(
+            scheduledExecutorService.schedule(
+                new HedgingRunnable(scheduledHedgingRef),
+                hedgingPolicy.hedgingDelayNanos,
+                TimeUnit.NANOSECONDS));
+      }
+    }
+
+    drain(substream);
+  }
+
+  @SuppressWarnings("GuardedBy")  // TODO(b/145386688) this.lock==ScheduledCancellor.lock so ok
+  private void pushbackHedging(@Nullable Integer delayMillis) {
+    if (delayMillis == null) {
+      return;
+    }
+    if (delayMillis < 0) {
+      freezeHedging();
+      return;
+    }
+
+    // Cancels the current scheduledHedging and reschedules a new one.
+    FutureCanceller future;
+    Future<?> futureToBeCancelled;
+
+    synchronized (lock) {
+      if (scheduledHedging == null) {
+        return;
+      }
+
+      futureToBeCancelled = scheduledHedging.markCancelled();
+      scheduledHedging = future = new FutureCanceller(lock);
+    }
+
+    if (futureToBeCancelled != null) {
+      futureToBeCancelled.cancel(false);
+    }
+    future.setFuture(scheduledExecutorService.schedule(
+        new HedgingRunnable(future), delayMillis, TimeUnit.MILLISECONDS));
+  }
+
+  private final class HedgingRunnable implements Runnable {
+
+    // Need to hold a ref to the FutureCanceller in case RetriableStrea.scheduledHedging is renewed
+    // by a positive push-back just after newSubstream is instantiated, so that we can double check.
+    final FutureCanceller scheduledHedgingRef;
+
+    HedgingRunnable(FutureCanceller scheduledHedging) {
+      scheduledHedgingRef = scheduledHedging;
+    }
+
+    @Override
+    public void run() {
+      // It's safe to read state.hedgingAttemptCount here.
+      // If this run is not cancelled, the value of state.hedgingAttemptCount won't change
+      // until state.addActiveHedge() is called subsequently, even the state could possibly
+      // change.
+      Substream newSubstream = createSubstream(state.hedgingAttemptCount, false, true);
+      if (newSubstream == null) {
+        return;
+      }
+      callExecutor.execute(
+          new Runnable() {
+            @SuppressWarnings("GuardedBy")  //TODO(b/145386688) lock==ScheduledCancellor.lock so ok
+            @Override
+            public void run() {
+              boolean cancelled = false;
+              FutureCanceller future = null;
+
+              synchronized (lock) {
+                if (scheduledHedgingRef.isCancelled()) {
+                  cancelled = true;
+                } else {
+                  state = state.addActiveHedge(newSubstream);
+                  if (hasPotentialHedging(state)
+                      && (throttle == null || throttle.isAboveThreshold())) {
+                    scheduledHedging = future = new FutureCanceller(lock);
+                  } else {
+                    state = state.freezeHedging();
+                    scheduledHedging = null;
+                  }
+                }
+              }
+
+              if (cancelled) {
+                // Start stream so inFlightSubStreams is decremented in Sublistener.closed()
+                newSubstream.stream.start(new Sublistener(newSubstream));
+                newSubstream.stream.cancel(Status.CANCELLED.withDescription("Unneeded hedging"));
+                return;
+              }
+              if (future != null) {
+                future.setFuture(
+                    scheduledExecutorService.schedule(
+                        new HedgingRunnable(future),
+                        hedgingPolicy.hedgingDelayNanos,
+                        TimeUnit.NANOSECONDS));
+              }
+              drain(newSubstream);
+            }
+          });
+    }
+  }
+
+  @Override
+  public final void cancel(final Status reason) {
+    Substream noopSubstream = new Substream(0 /* previousAttempts doesn't matter here */);
+    noopSubstream.stream = new NoopClientStream();
+    Runnable runnable = commit(noopSubstream);
+
+    if (runnable != null) {
+      synchronized (lock) {
+        state = state.substreamDrained(noopSubstream);
+      }
+      runnable.run();
+      safeCloseMasterListener(reason, RpcProgress.PROCESSED, new Metadata());
+      return;
+    }
+
+    Substream winningSubstreamToCancel = null;
+    synchronized (lock) {
+      if (state.drainedSubstreams.contains(state.winningSubstream)) {
+        winningSubstreamToCancel = state.winningSubstream;
+      } else { // the winningSubstream will be cancelled while draining
+        cancellationStatus = reason;
+      }
+      state = state.cancelled();
+    }
+    if (winningSubstreamToCancel != null) {
+      winningSubstreamToCancel.stream.cancel(reason);
+    }
+  }
+
+  private void delayOrExecute(BufferEntry bufferEntry) {
+    Collection<Substream> savedDrainedSubstreams;
+    synchronized (lock) {
+      if (!state.passThrough) {
+        state.buffer.add(bufferEntry);
+      }
+      savedDrainedSubstreams = state.drainedSubstreams;
+    }
+
+    for (Substream substream : savedDrainedSubstreams) {
+      bufferEntry.runWith(substream);
+    }
+  }
+
+  /**
+   * Do not use it directly. Use {@link #sendMessage(Object)} instead because we don't use
+   * InputStream for buffering.
+   */
+  @Override
+  public final void writeMessage(InputStream message) {
+    throw new IllegalStateException("RetriableStream.writeMessage() should not be called directly");
+  }
+
+  final void sendMessage(final ReqT message) {
+    State savedState = state;
+    if (savedState.passThrough) {
+      savedState.winningSubstream.stream.writeMessage(method.streamRequest(message));
+      return;
+    }
+
+    class SendMessageEntry implements BufferEntry {
+      @Override
+      public void runWith(Substream substream) {
+        substream.stream.writeMessage(method.streamRequest(message));
+        // TODO(ejona): Workaround Netty memory leak. Message writes always need to be followed by
+        // flushes (or half close), but retry appears to have a code path that the flushes may
+        // not happen. The code needs to be fixed and this removed. See #9340.
+        substream.stream.flush();
+      }
+    }
+
+    delayOrExecute(new SendMessageEntry());
+  }
+
+  @Override
+  public final void request(final int numMessages) {
+    State savedState = state;
+    if (savedState.passThrough) {
+      savedState.winningSubstream.stream.request(numMessages);
+      return;
+    }
+
+    class RequestEntry implements BufferEntry {
+      @Override
+      public void runWith(Substream substream) {
+        substream.stream.request(numMessages);
+      }
+    }
+
+    delayOrExecute(new RequestEntry());
+  }
+
+  @Override
+  public final void flush() {
+    State savedState = state;
+    if (savedState.passThrough) {
+      savedState.winningSubstream.stream.flush();
+      return;
+    }
+
+    class FlushEntry implements BufferEntry {
+      @Override
+      public void runWith(Substream substream) {
+        substream.stream.flush();
+      }
+    }
+
+    delayOrExecute(new FlushEntry());
+  }
+
+  @Override
+  public final boolean isReady() {
+    for (Substream substream : state.drainedSubstreams) {
+      if (substream.stream.isReady()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @Override
+  public void optimizeForDirectExecutor() {
+    class OptimizeDirectEntry implements BufferEntry {
+      @Override
+      public void runWith(Substream substream) {
+        substream.stream.optimizeForDirectExecutor();
+      }
+    }
+
+    delayOrExecute(new OptimizeDirectEntry());
+  }
+
+  @Override
+  public final void setCompressor(final Compressor compressor) {
+    class CompressorEntry implements BufferEntry {
+      @Override
+      public void runWith(Substream substream) {
+        substream.stream.setCompressor(compressor);
+      }
+    }
+
+    delayOrExecute(new CompressorEntry());
+  }
+
+  @Override
+  public final void setFullStreamDecompression(final boolean fullStreamDecompression) {
+    class FullStreamDecompressionEntry implements BufferEntry {
+      @Override
+      public void runWith(Substream substream) {
+        substream.stream.setFullStreamDecompression(fullStreamDecompression);
+      }
+    }
+
+    delayOrExecute(new FullStreamDecompressionEntry());
+  }
+
+  @Override
+  public final void setMessageCompression(final boolean enable) {
+    class MessageCompressionEntry implements BufferEntry {
+      @Override
+      public void runWith(Substream substream) {
+        substream.stream.setMessageCompression(enable);
+      }
+    }
+
+    delayOrExecute(new MessageCompressionEntry());
+  }
+
+  @Override
+  public final void halfClose() {
+    class HalfCloseEntry implements BufferEntry {
+      @Override
+      public void runWith(Substream substream) {
+        substream.stream.halfClose();
+      }
+    }
+
+    delayOrExecute(new HalfCloseEntry());
+  }
+
+  @Override
+  public final void setAuthority(final String authority) {
+    class AuthorityEntry implements BufferEntry {
+      @Override
+      public void runWith(Substream substream) {
+        substream.stream.setAuthority(authority);
+      }
+    }
+
+    delayOrExecute(new AuthorityEntry());
+  }
+
+  @Override
+  public final void setDecompressorRegistry(final DecompressorRegistry decompressorRegistry) {
+    class DecompressorRegistryEntry implements BufferEntry {
+      @Override
+      public void runWith(Substream substream) {
+        substream.stream.setDecompressorRegistry(decompressorRegistry);
+      }
+    }
+
+    delayOrExecute(new DecompressorRegistryEntry());
+  }
+
+  @Override
+  public final void setMaxInboundMessageSize(final int maxSize) {
+    class MaxInboundMessageSizeEntry implements BufferEntry {
+      @Override
+      public void runWith(Substream substream) {
+        substream.stream.setMaxInboundMessageSize(maxSize);
+      }
+    }
+
+    delayOrExecute(new MaxInboundMessageSizeEntry());
+  }
+
+  @Override
+  public final void setMaxOutboundMessageSize(final int maxSize) {
+    class MaxOutboundMessageSizeEntry implements BufferEntry {
+      @Override
+      public void runWith(Substream substream) {
+        substream.stream.setMaxOutboundMessageSize(maxSize);
+      }
+    }
+
+    delayOrExecute(new MaxOutboundMessageSizeEntry());
+  }
+
+  @Override
+  public final void setDeadline(final Deadline deadline) {
+    class DeadlineEntry implements BufferEntry {
+      @Override
+      public void runWith(Substream substream) {
+        substream.stream.setDeadline(deadline);
+      }
+    }
+
+    delayOrExecute(new DeadlineEntry());
+  }
+
+  @Override
+  public final Attributes getAttributes() {
+    if (state.winningSubstream != null) {
+      return state.winningSubstream.stream.getAttributes();
+    }
+    return Attributes.EMPTY;
+  }
+
+  @Override
+  public void appendTimeoutInsight(InsightBuilder insight) {
+    State currentState;
+    synchronized (lock) {
+      insight.appendKeyValue("closed", closedSubstreamsInsight);
+      currentState = state;
+    }
+    if (currentState.winningSubstream != null) {
+      // TODO(zhangkun83): in this case while other drained substreams have been cancelled in favor
+      // of the winning substream, they may not have received closed() notifications yet, thus they
+      // may be missing from closedSubstreamsInsight.  This may be a little confusing to the user.
+      // We need to figure out how to include them.
+      InsightBuilder substreamInsight = new InsightBuilder();
+      currentState.winningSubstream.stream.appendTimeoutInsight(substreamInsight);
+      insight.appendKeyValue("committed", substreamInsight);
+    } else {
+      InsightBuilder openSubstreamsInsight = new InsightBuilder();
+      // drainedSubstreams doesn't include all open substreams.  Those which have just been created
+      // and are still catching up with buffered requests (in other words, still draining) will not
+      // show up.  We think this is benign, because the draining should be typically fast, and it'd
+      // be indistinguishable from the case where those streams are to be created a little late due
+      // to delays in the timer.
+      for (Substream sub : currentState.drainedSubstreams) {
+        InsightBuilder substreamInsight = new InsightBuilder();
+        sub.stream.appendTimeoutInsight(substreamInsight);
+        openSubstreamsInsight.append(substreamInsight);
+      }
+      insight.appendKeyValue("open", openSubstreamsInsight);
+    }
+  }
+
+  private static Random random = new Random();
+
+  @VisibleForTesting
+  static void setRandom(Random random) {
+    RetriableStream.random = random;
+  }
+
+  /**
+   * Whether there is any potential hedge at the moment. A false return value implies there is
+   * absolutely no potential hedge. At least one of the hedges will observe a false return value
+   * when calling this method, unless otherwise the rpc is committed.
+   */
+  // only called when isHedging is true
+  @GuardedBy("lock")
+  private boolean hasPotentialHedging(State state) {
+    return state.winningSubstream == null
+        && state.hedgingAttemptCount < hedgingPolicy.maxAttempts
+        && !state.hedgingFrozen;
+  }
+
+  @SuppressWarnings("GuardedBy")  // TODO(b/145386688) this.lock==ScheduledCancellor.lock so ok
+  private void freezeHedging() {
+    Future<?> futureToBeCancelled = null;
+    synchronized (lock) {
+      if (scheduledHedging != null) {
+        futureToBeCancelled = scheduledHedging.markCancelled();
+        scheduledHedging = null;
+      }
+      state = state.freezeHedging();
+    }
+
+    if (futureToBeCancelled != null) {
+      futureToBeCancelled.cancel(false);
+    }
+  }
+
+  private void safeCloseMasterListener(Status status, RpcProgress progress, Metadata metadata) {
+    savedCloseMasterListenerReason = new SavedCloseMasterListenerReason(status, progress,
+        metadata);
+    if (inFlightSubStreams.addAndGet(Integer.MIN_VALUE) == Integer.MIN_VALUE) {
+      listenerSerializeExecutor.execute(
+          new Runnable() {
+            @Override
+            public void run() {
+              isClosed = true;
+              masterListener.closed(status, progress, metadata);
+            }
+          });
+    }
+  }
+
+  private static final boolean isExperimentalRetryJitterEnabled = GrpcUtil
+          .getFlag("GRPC_EXPERIMENTAL_XDS_RLS_LB", true);
+
+  public static long intervalWithJitter(long intervalNanos) {
+    double inverseJitterFactor = isExperimentalRetryJitterEnabled
+            ? 0.8 * random.nextDouble() + 0.4 : random.nextDouble();
+    return (long) (intervalNanos * inverseJitterFactor);
+  }
+
+  private static final class SavedCloseMasterListenerReason {
+    private final Status status;
+    private final RpcProgress progress;
+    private final Metadata metadata;
+
+    SavedCloseMasterListenerReason(Status status, RpcProgress progress, Metadata metadata) {
+      this.status = status;
+      this.progress = progress;
+      this.metadata = metadata;
+    }
+  }
+
+  private interface BufferEntry {
+    /** Replays the buffer entry with the given stream. */
+    void runWith(Substream substream);
+  }
+
+  private final class Sublistener implements ClientStreamListener {
+    final Substream substream;
+
+    Sublistener(Substream substream) {
+      this.substream = substream;
+    }
+
+    @Override
+    public void headersRead(final Metadata headers) {
+      if (substream.previousAttemptCount > 0) {
+        headers.discardAll(GRPC_PREVIOUS_RPC_ATTEMPTS);
+        headers.put(GRPC_PREVIOUS_RPC_ATTEMPTS, String.valueOf(substream.previousAttemptCount));
+      }
+      commitAndRun(substream);
+      if (state.winningSubstream == substream) {
+        if (throttle != null) {
+          throttle.onSuccess();
+        }
+        listenerSerializeExecutor.execute(
+            new Runnable() {
+              @Override
+              public void run() {
+                masterListener.headersRead(headers);
+              }
+            });
+      }
+    }
+
+    @Override
+    public void closed(
+        final Status status, final RpcProgress rpcProgress, final Metadata trailers) {
+      synchronized (lock) {
+        state = state.substreamClosed(substream);
+        closedSubstreamsInsight.append(status.getCode());
+      }
+
+      if (inFlightSubStreams.decrementAndGet() == Integer.MIN_VALUE) {
+        assert savedCloseMasterListenerReason != null;
+        listenerSerializeExecutor.execute(
+            new Runnable() {
+              @Override
+              public void run() {
+                isClosed = true;
+                masterListener.closed(savedCloseMasterListenerReason.status,
+                    savedCloseMasterListenerReason.progress,
+                    savedCloseMasterListenerReason.metadata);
+              }
+            });
+        return;
+      }
+
+      // handle a race between buffer limit exceeded and closed, when setting
+      // substream.bufferLimitExceeded = true happens before state.substreamClosed(substream).
+      if (substream.bufferLimitExceeded) {
+        commitAndRun(substream);
+        if (state.winningSubstream == substream) {
+          safeCloseMasterListener(status, rpcProgress, trailers);
+        }
+        return;
+      }
+      if (rpcProgress == RpcProgress.MISCARRIED
+          && localOnlyTransparentRetries.incrementAndGet() > 1_000) {
+        commitAndRun(substream);
+        if (state.winningSubstream == substream) {
+          Status tooManyTransparentRetries = GrpcUtil.statusWithDetails(
+              Status.Code.INTERNAL, "Too many transparent retries. Might be a bug in gRPC", status);
+          safeCloseMasterListener(tooManyTransparentRetries, rpcProgress, trailers);
+        }
+        return;
+      }
+
+      if (state.winningSubstream == null) {
+        if (rpcProgress == RpcProgress.MISCARRIED
+            || (rpcProgress == RpcProgress.REFUSED
+                && noMoreTransparentRetry.compareAndSet(false, true))) {
+          // transparent retry
+          final Substream newSubstream = createSubstream(substream.previousAttemptCount,
+              true, false);
+          if (newSubstream == null) {
+            return;
+          }
+          if (isHedging) {
+            synchronized (lock) {
+              // Although this operation is not done atomically with
+              // noMoreTransparentRetry.compareAndSet(false, true), it does not change the size() of
+              // activeHedges, so neither does it affect the commitment decision of other threads,
+              // nor do the commitment decision making threads affect itself.
+              state = state.replaceActiveHedge(substream, newSubstream);
+            }
+          }
+
+          callExecutor.execute(new Runnable() {
+            @Override
+            public void run() {
+              drain(newSubstream);
+            }
+          });
+          return;
+        } else if (rpcProgress == RpcProgress.DROPPED) {
+          // For normal retry, nothing need be done here, will just commit.
+          // For hedging, cancel scheduled hedge that is scheduled prior to the drop
+          if (isHedging) {
+            freezeHedging();
+          }
+        } else {
+          noMoreTransparentRetry.set(true);
+
+          if (isHedging) {
+            HedgingPlan hedgingPlan = makeHedgingDecision(status, trailers);
+            if (hedgingPlan.isHedgeable) {
+              pushbackHedging(hedgingPlan.hedgingPushbackMillis);
+            }
+            synchronized (lock) {
+              state = state.removeActiveHedge(substream);
+              // The invariant is whether or not #(Potential Hedge + active hedges) > 0.
+              // Once hasPotentialHedging(state) is false, it will always be false, and then
+              // #(state.activeHedges) will be decreasing. This guarantees that even there may be
+              // multiple concurrent hedges, one of the hedges will end up committed.
+              if (hedgingPlan.isHedgeable) {
+                if (hasPotentialHedging(state) || !state.activeHedges.isEmpty()) {
+                  return;
+                }
+                // else, no activeHedges, no new hedges possible, try to commit
+              } // else, isHedgeable is false, try to commit
+            }
+          } else {
+            RetryPlan retryPlan = makeRetryDecision(status, trailers);
+            if (retryPlan.shouldRetry) {
+              // retry
+              Substream newSubstream = createSubstream(substream.previousAttemptCount + 1,
+                  false, false);
+              if (newSubstream == null) {
+                return;
+              }
+              // The check state.winningSubstream == null, checking if is not already committed, is
+              // racy, but is still safe b/c the retry will also handle committed/cancellation
+              FutureCanceller scheduledRetryCopy;
+              synchronized (lock) {
+                scheduledRetry = scheduledRetryCopy = new FutureCanceller(lock);
+              }
+
+              class RetryBackoffRunnable implements Runnable {
+                @Override
+                @SuppressWarnings("FutureReturnValueIgnored")
+                public void run() {
+                  synchronized (scheduledRetryCopy.lock) {
+                    if (scheduledRetryCopy.isCancelled()) {
+                      return;
+                    } else {
+                      scheduledRetryCopy.markCancelled();
+                    }
+                  }
+
+                  callExecutor.execute(
+                      new Runnable() {
+                        @Override
+                        public void run() {
+                          drain(newSubstream);
+                        }
+                      });
+                }
+              }
+
+              scheduledRetryCopy.setFuture(
+                  scheduledExecutorService.schedule(
+                      new RetryBackoffRunnable(),
+                      retryPlan.backoffNanos,
+                      TimeUnit.NANOSECONDS));
+              return;
+            }
+          }
+        }
+      }
+
+      commitAndRun(substream);
+      if (state.winningSubstream == substream) {
+        safeCloseMasterListener(status, rpcProgress, trailers);
+      }
+    }
+
+    /**
+     * Decides in current situation whether or not the RPC should retry and if it should retry how
+     * long the backoff should be. The decision does not take the commitment status into account, so
+     * caller should check it separately. It also updates the throttle. It does not change state.
+     */
+    private RetryPlan makeRetryDecision(Status status, Metadata trailer) {
+      if (retryPolicy == null) {
+        return new RetryPlan(false, 0);
+      }
+      boolean shouldRetry = false;
+      long backoffNanos = 0L;
+      boolean isRetryableStatusCode = retryPolicy.retryableStatusCodes.contains(status.getCode());
+      Integer pushbackMillis = getPushbackMills(trailer);
+      boolean isThrottled = false;
+      if (throttle != null) {
+        if (isRetryableStatusCode || (pushbackMillis != null && pushbackMillis < 0)) {
+          isThrottled = !throttle.onQualifiedFailureThenCheckIsAboveThreshold();
+        }
+      }
+
+      if (retryPolicy.maxAttempts > substream.previousAttemptCount + 1 && !isThrottled) {
+        if (pushbackMillis == null) {
+          if (isRetryableStatusCode) {
+            shouldRetry = true;
+            backoffNanos = intervalWithJitter(nextBackoffIntervalNanos);
+            nextBackoffIntervalNanos = Math.min(
+                (long) (nextBackoffIntervalNanos * retryPolicy.backoffMultiplier),
+                retryPolicy.maxBackoffNanos);
+          } // else no retry
+        } else if (pushbackMillis >= 0) {
+          shouldRetry = true;
+          backoffNanos = TimeUnit.MILLISECONDS.toNanos(pushbackMillis);
+          nextBackoffIntervalNanos = retryPolicy.initialBackoffNanos;
+        } // else no retry
+      } // else no retry
+
+      return new RetryPlan(shouldRetry, backoffNanos);
+    }
+
+    private HedgingPlan makeHedgingDecision(Status status, Metadata trailer) {
+      Integer pushbackMillis = getPushbackMills(trailer);
+      boolean isFatal = !hedgingPolicy.nonFatalStatusCodes.contains(status.getCode());
+      boolean isThrottled = false;
+      if (throttle != null) {
+        if (!isFatal || (pushbackMillis != null && pushbackMillis < 0)) {
+          isThrottled = !throttle.onQualifiedFailureThenCheckIsAboveThreshold();
+        }
+      }
+      if (!isFatal && !isThrottled && !status.isOk()
+          && (pushbackMillis != null && pushbackMillis > 0)) {
+        pushbackMillis = 0; // We want the retry after a nonfatal error to be immediate
+      }
+      return new HedgingPlan(!isFatal && !isThrottled, pushbackMillis);
+    }
+
+    @Nullable
+    private Integer getPushbackMills(Metadata trailer) {
+      String pushbackStr = trailer.get(GRPC_RETRY_PUSHBACK_MS);
+      Integer pushbackMillis = null;
+      if (pushbackStr != null) {
+        try {
+          pushbackMillis = Integer.valueOf(pushbackStr);
+        } catch (NumberFormatException e) {
+          pushbackMillis = -1;
+        }
+      }
+      return pushbackMillis;
+    }
+
+    @Override
+    public void messagesAvailable(final MessageProducer producer) {
+      State savedState = state;
+      checkState(
+          savedState.winningSubstream != null, "Headers should be received prior to messages.");
+      if (savedState.winningSubstream != substream) {
+        GrpcUtil.closeQuietly(producer);
+        return;
+      }
+      listenerSerializeExecutor.execute(
+          new Runnable() {
+            @Override
+            public void run() {
+              masterListener.messagesAvailable(producer);
+            }
+          });
+    }
+
+    @Override
+    public void onReady() {
+      // FIXME(#7089): hedging case is broken.
+      if (!isReady()) {
+        return;
+      }
+      listenerSerializeExecutor.execute(
+          new Runnable() {
+            @Override
+            public void run() {
+              if (!isClosed) {
+                masterListener.onReady();
+              }
+            }
+          });
+    }
+  }
+
+  private static final class State {
+    /** Committed and the winning substream drained. */
+    final boolean passThrough;
+
+    /** A list of buffered ClientStream runnables. Set to Null once passThrough. */
+    @Nullable final List<BufferEntry> buffer;
+
+    /**
+     * Unmodifiable collection of all the open substreams that are drained. Singleton once
+     * passThrough; Empty if committed but not passTrough.
+     */
+    final Collection<Substream> drainedSubstreams;
+
+    /**
+     * Unmodifiable collection of all the active hedging substreams.
+     *
+     * <p>A substream even with the attribute substream.closed being true may be considered still
+     * "active" at the moment as long as it is in this collection.
+     */
+    final Collection<Substream> activeHedges; // not null once isHedging = true
+
+    final int hedgingAttemptCount;
+
+    /** Null until committed. */
+    @Nullable final Substream winningSubstream;
+
+    /** Not required to set to true when cancelled, but can short-circuit the draining process. */
+    final boolean cancelled;
+
+    /** No more hedging due to events like drop or pushback. */
+    final boolean hedgingFrozen;
+
+    State(
+        @Nullable List<BufferEntry> buffer,
+        Collection<Substream> drainedSubstreams,
+        Collection<Substream> activeHedges,
+        @Nullable Substream winningSubstream,
+        boolean cancelled,
+        boolean passThrough,
+        boolean hedgingFrozen,
+        int hedgingAttemptCount) {
+      this.buffer = buffer;
+      this.drainedSubstreams =
+          checkNotNull(drainedSubstreams, "drainedSubstreams");
+      this.winningSubstream = winningSubstream;
+      this.activeHedges = activeHedges;
+      this.cancelled = cancelled;
+      this.passThrough = passThrough;
+      this.hedgingFrozen = hedgingFrozen;
+      this.hedgingAttemptCount = hedgingAttemptCount;
+
+      checkState(!passThrough || buffer == null, "passThrough should imply buffer is null");
+      checkState(
+          !passThrough || winningSubstream != null,
+          "passThrough should imply winningSubstream != null");
+      checkState(
+          !passThrough
+              || (drainedSubstreams.size() == 1 && drainedSubstreams.contains(winningSubstream))
+              || (drainedSubstreams.size() == 0 && winningSubstream.closed),
+          "passThrough should imply winningSubstream is drained");
+      checkState(!cancelled || winningSubstream != null, "cancelled should imply committed");
+    }
+
+    @CheckReturnValue
+    // GuardedBy RetriableStream.lock
+    State cancelled() {
+      return new State(
+          buffer, drainedSubstreams, activeHedges, winningSubstream, true, passThrough,
+          hedgingFrozen, hedgingAttemptCount);
+    }
+
+    /** The given substream is drained. */
+    @CheckReturnValue
+    // GuardedBy RetriableStream.lock
+    State substreamDrained(Substream substream) {
+      checkState(!passThrough, "Already passThrough");
+
+      Collection<Substream> drainedSubstreams;
+      
+      if (substream.closed) {
+        drainedSubstreams = this.drainedSubstreams;
+      } else if (this.drainedSubstreams.isEmpty()) {
+        // optimize for 0-retry, which is most of the cases.
+        drainedSubstreams = Collections.singletonList(substream);
+      } else {
+        drainedSubstreams = new ArrayList<>(this.drainedSubstreams);
+        drainedSubstreams.add(substream);
+        drainedSubstreams = Collections.unmodifiableCollection(drainedSubstreams);
+      }
+
+      boolean passThrough = winningSubstream != null;
+
+      List<BufferEntry> buffer = this.buffer;
+      if (passThrough) {
+        checkState(
+            winningSubstream == substream, "Another RPC attempt has already committed");
+        buffer = null;
+      }
+
+      return new State(
+          buffer, drainedSubstreams, activeHedges, winningSubstream, cancelled, passThrough,
+          hedgingFrozen, hedgingAttemptCount);
+    }
+
+    /** The given substream is closed. */
+    @CheckReturnValue
+    // GuardedBy RetriableStream.lock
+    State substreamClosed(Substream substream) {
+      substream.closed = true;
+      if (this.drainedSubstreams.contains(substream)) {
+        Collection<Substream> drainedSubstreams = new ArrayList<>(this.drainedSubstreams);
+        drainedSubstreams.remove(substream);
+        drainedSubstreams = Collections.unmodifiableCollection(drainedSubstreams);
+        return new State(
+            buffer, drainedSubstreams, activeHedges, winningSubstream, cancelled, passThrough,
+            hedgingFrozen, hedgingAttemptCount);
+      } else {
+        return this;
+      }
+    }
+
+    @CheckReturnValue
+    // GuardedBy RetriableStream.lock
+    State committed(Substream winningSubstream) {
+      checkState(this.winningSubstream == null, "Already committed");
+
+      boolean passThrough = false;
+      List<BufferEntry> buffer = this.buffer;
+      Collection<Substream> drainedSubstreams;
+
+      if (this.drainedSubstreams.contains(winningSubstream)) {
+        passThrough = true;
+        buffer = null;
+        drainedSubstreams = Collections.singleton(winningSubstream);
+      } else {
+        drainedSubstreams = Collections.emptyList();
+      }
+
+      return new State(
+          buffer, drainedSubstreams, activeHedges, winningSubstream, cancelled, passThrough,
+          hedgingFrozen, hedgingAttemptCount);
+    }
+
+    @CheckReturnValue
+    // GuardedBy RetriableStream.lock
+    State freezeHedging() {
+      if (hedgingFrozen) {
+        return this;
+      }
+      return new State(
+          buffer, drainedSubstreams, activeHedges, winningSubstream, cancelled, passThrough,
+          true, hedgingAttemptCount);
+    }
+
+    @CheckReturnValue
+    // GuardedBy RetriableStream.lock
+    // state.hedgingAttemptCount is modified only here.
+    // The method is only called in RetriableStream.start() and HedgingRunnable.run()
+    State addActiveHedge(Substream substream) {
+      // hasPotentialHedging must be true
+      checkState(!hedgingFrozen, "hedging frozen");
+      checkState(winningSubstream == null, "already committed");
+
+      Collection<Substream> activeHedges;
+      if (this.activeHedges == null) {
+        activeHedges = Collections.singleton(substream);
+      } else {
+        activeHedges = new ArrayList<>(this.activeHedges);
+        activeHedges.add(substream);
+        activeHedges = Collections.unmodifiableCollection(activeHedges);
+      }
+
+      int hedgingAttemptCount = this.hedgingAttemptCount + 1;
+      return new State(
+          buffer, drainedSubstreams, activeHedges, winningSubstream, cancelled, passThrough,
+          hedgingFrozen, hedgingAttemptCount);
+    }
+
+    @CheckReturnValue
+    // GuardedBy RetriableStream.lock
+    // The method is only called in Sublistener.closed()
+    State removeActiveHedge(Substream substream) {
+      Collection<Substream> activeHedges = new ArrayList<>(this.activeHedges);
+      activeHedges.remove(substream);
+      activeHedges = Collections.unmodifiableCollection(activeHedges);
+
+      return new State(
+          buffer, drainedSubstreams, activeHedges, winningSubstream, cancelled, passThrough,
+          hedgingFrozen, hedgingAttemptCount);
+    }
+
+    @CheckReturnValue
+    // GuardedBy RetriableStream.lock
+    // The method is only called for transparent retry.
+    State replaceActiveHedge(Substream oldOne, Substream newOne) {
+      Collection<Substream> activeHedges = new ArrayList<>(this.activeHedges);
+      activeHedges.remove(oldOne);
+      activeHedges.add(newOne);
+      activeHedges = Collections.unmodifiableCollection(activeHedges);
+
+      return new State(
+          buffer, drainedSubstreams, activeHedges, winningSubstream, cancelled, passThrough,
+          hedgingFrozen, hedgingAttemptCount);
+    }
+  }
+
+  /**
+   * A wrapper of a physical stream of a retry/hedging attempt, that comes with some useful
+   *  attributes.
+   */
+  private static final class Substream {
+    ClientStream stream;
+
+    // GuardedBy RetriableStream.lock
+    boolean closed;
+
+    // setting to true must be GuardedBy RetriableStream.lock
+    boolean bufferLimitExceeded;
+
+    final int previousAttemptCount;
+
+    Substream(int previousAttemptCount) {
+      this.previousAttemptCount = previousAttemptCount;
+    }
+  }
+
+
+  /**
+   * Traces the buffer used by a substream.
+   */
+  class BufferSizeTracer extends ClientStreamTracer {
+    // Each buffer size tracer is dedicated to one specific substream.
+    private final Substream substream;
+
+    @GuardedBy("lock")
+    long bufferNeeded;
+
+    BufferSizeTracer(Substream substream) {
+      this.substream = substream;
+    }
+
+    /**
+     * A message is sent to the wire, so its reference would be released if no retry or
+     * hedging were involved. So at this point we have to hold the reference of the message longer
+     * for retry, and we need to increment {@code substream.bufferNeeded}.
+     */
+    @Override
+    public void outboundWireSize(long bytes) {
+      if (state.winningSubstream != null) {
+        return;
+      }
+
+      Runnable postCommitTask = null;
+
+      // TODO(zdapeng): avoid using the same lock for both in-bound and out-bound.
+      synchronized (lock) {
+        if (state.winningSubstream != null || substream.closed) {
+          return;
+        }
+        bufferNeeded += bytes;
+        if (bufferNeeded <= perRpcBufferUsed) {
+          return;
+        }
+
+        if (bufferNeeded > perRpcBufferLimit) {
+          substream.bufferLimitExceeded = true;
+        } else {
+          // Only update channelBufferUsed when perRpcBufferUsed is not exceeding perRpcBufferLimit.
+          long savedChannelBufferUsed =
+              channelBufferUsed.addAndGet(bufferNeeded - perRpcBufferUsed);
+          perRpcBufferUsed = bufferNeeded;
+
+          if (savedChannelBufferUsed > channelBufferLimit) {
+            substream.bufferLimitExceeded = true;
+          }
+        }
+
+        if (substream.bufferLimitExceeded) {
+          postCommitTask = commit(substream);
+        }
+      }
+
+      if (postCommitTask != null) {
+        postCommitTask.run();
+      }
+    }
+  }
+
+  /**
+   *  Used to keep track of the total amount of memory used to buffer retryable or hedged RPCs for
+   *  the Channel. There should be a single instance of it for each channel.
+   */
+  static final class ChannelBufferMeter {
+    private final AtomicLong bufferUsed = new AtomicLong();
+
+    @VisibleForTesting
+    long addAndGet(long newBytesUsed) {
+      return bufferUsed.addAndGet(newBytesUsed);
+    }
+  }
+
+  /**
+   * Used for retry throttling.
+   */
+  static final class Throttle {
+
+    private static final int THREE_DECIMAL_PLACES_SCALE_UP = 1000;
+
+    /**
+     * 1000 times the maxTokens field of the retryThrottling policy in service config.
+     * The number of tokens starts at maxTokens. The token_count will always be between 0 and
+     * maxTokens.
+     */
+    final int maxTokens;
+
+    /**
+     * Half of {@code maxTokens}.
+     */
+    final int threshold;
+
+    /**
+     * 1000 times the tokenRatio field of the retryThrottling policy in service config.
+     */
+    final int tokenRatio;
+
+    final AtomicInteger tokenCount = new AtomicInteger();
+
+    Throttle(float maxTokens, float tokenRatio) {
+      // tokenRatio is up to 3 decimal places
+      this.tokenRatio = (int) (tokenRatio * THREE_DECIMAL_PLACES_SCALE_UP);
+      this.maxTokens = (int) (maxTokens * THREE_DECIMAL_PLACES_SCALE_UP);
+      this.threshold = this.maxTokens / 2;
+      tokenCount.set(this.maxTokens);
+    }
+
+    @VisibleForTesting
+    boolean isAboveThreshold() {
+      return tokenCount.get() > threshold;
+    }
+
+    /**
+     * Counts down the token on qualified failure and checks if it is above the threshold
+     * atomically. Qualified failure is a failure with a retryable or non-fatal status code or with
+     * a not-to-retry pushback.
+     */
+    @VisibleForTesting
+    boolean onQualifiedFailureThenCheckIsAboveThreshold() {
+      while (true) {
+        int currentCount = tokenCount.get();
+        if (currentCount == 0) {
+          return false;
+        }
+        int decremented = currentCount - (1 * THREE_DECIMAL_PLACES_SCALE_UP);
+        boolean updated = tokenCount.compareAndSet(currentCount, Math.max(decremented, 0));
+        if (updated) {
+          return decremented > threshold;
+        }
+      }
+    }
+
+    @VisibleForTesting
+    void onSuccess() {
+      while (true) {
+        int currentCount = tokenCount.get();
+        if (currentCount == maxTokens) {
+          break;
+        }
+        int incremented = currentCount + tokenRatio;
+        boolean updated = tokenCount.compareAndSet(currentCount, Math.min(incremented, maxTokens));
+        if (updated) {
+          break;
+        }
+      }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (!(o instanceof Throttle)) {
+        return false;
+      }
+      Throttle that = (Throttle) o;
+      return maxTokens == that.maxTokens && tokenRatio == that.tokenRatio;
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(maxTokens, tokenRatio);
+    }
+  }
+
+  private static final class RetryPlan {
+    final boolean shouldRetry;
+    final long backoffNanos;
+
+    RetryPlan(boolean shouldRetry, long backoffNanos) {
+      this.shouldRetry = shouldRetry;
+      this.backoffNanos = backoffNanos;
+    }
+  }
+
+  private static final class HedgingPlan {
+    final boolean isHedgeable;
+    @Nullable
+    final Integer hedgingPushbackMillis;
+
+    public HedgingPlan(
+        boolean isHedgeable, @Nullable Integer hedgingPushbackMillis) {
+      this.isHedgeable = isHedgeable;
+      this.hedgingPushbackMillis = hedgingPushbackMillis;
+    }
+  }
+
+  /** Allows cancelling a Future without racing with setting the future. */
+  private static final class FutureCanceller {
+
+    final Object lock;
+    @GuardedBy("lock")
+    Future<?> future;
+    @GuardedBy("lock")
+    boolean cancelled;
+
+    FutureCanceller(Object lock) {
+      this.lock = lock;
+    }
+
+    void setFuture(Future<?> future) {
+      boolean wasCancelled;
+      synchronized (lock) {
+        wasCancelled = cancelled;
+        if (!wasCancelled) {
+          this.future = future;
+        }
+      }
+      if (wasCancelled) {
+        future.cancel(false);
+      }
+    }
+
+    @GuardedBy("lock")
+    @CheckForNull // Must cancel the returned future if not null.
+    Future<?> markCancelled() {
+      cancelled = true;
+      return future;
+    }
+
+    @GuardedBy("lock")
+    boolean isCancelled() {
+      return cancelled;
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/RetryPolicy.java b/core/src/main/java/io/grpc/internal/RetryPolicy.java
new file mode 100644
index 00000000000..84267bee433
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/RetryPolicy.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2018 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.internal;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import com.google.common.collect.ImmutableSet;
+import io.grpc.Status.Code;
+import java.util.Set;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * Retry policy data object.
+ */
+@Immutable
+final class RetryPolicy {
+  final int maxAttempts;
+  final long initialBackoffNanos;
+  final long maxBackoffNanos;
+  final double backoffMultiplier;
+  @Nullable
+  final Long perAttemptRecvTimeoutNanos;
+  final Set<Code> retryableStatusCodes;
+
+  /**
+   * The caller is supposed to have validated the arguments and handled throwing exception or
+   * logging warnings already, so we avoid repeating args check here.
+   */
+  RetryPolicy(
+      int maxAttempts,
+      long initialBackoffNanos,
+      long maxBackoffNanos,
+      double backoffMultiplier,
+      @Nullable Long perAttemptRecvTimeoutNanos,
+      @Nonnull Set<Code> retryableStatusCodes) {
+    this.maxAttempts = maxAttempts;
+    this.initialBackoffNanos = initialBackoffNanos;
+    this.maxBackoffNanos = maxBackoffNanos;
+    this.backoffMultiplier = backoffMultiplier;
+    this.perAttemptRecvTimeoutNanos = perAttemptRecvTimeoutNanos;
+    this.retryableStatusCodes = ImmutableSet.copyOf(retryableStatusCodes);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(
+        maxAttempts,
+        initialBackoffNanos,
+        maxBackoffNanos,
+        backoffMultiplier,
+        perAttemptRecvTimeoutNanos,
+        retryableStatusCodes);
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (!(other instanceof RetryPolicy)) {
+      return false;
+    }
+    RetryPolicy that = (RetryPolicy) other;
+    return this.maxAttempts == that.maxAttempts
+        && this.initialBackoffNanos == that.initialBackoffNanos
+        && this.maxBackoffNanos == that.maxBackoffNanos
+        && Double.compare(this.backoffMultiplier, that.backoffMultiplier) == 0
+        && Objects.equal(this.perAttemptRecvTimeoutNanos, that.perAttemptRecvTimeoutNanos)
+        && Objects.equal(this.retryableStatusCodes, that.retryableStatusCodes);
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("maxAttempts", maxAttempts)
+        .add("initialBackoffNanos", initialBackoffNanos)
+        .add("maxBackoffNanos", maxBackoffNanos)
+        .add("backoffMultiplier", backoffMultiplier)
+        .add("perAttemptRecvTimeoutNanos", perAttemptRecvTimeoutNanos)
+        .add("retryableStatusCodes", retryableStatusCodes)
+        .toString();
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/RetryScheduler.java b/core/src/main/java/io/grpc/internal/RetryScheduler.java
new file mode 100644
index 00000000000..d2877e3ac0a
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/RetryScheduler.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2023 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.internal;
+
+/**
+ * This interface is used to schedule future retry attempts for a failed operation. The retry delay
+ * and the number of attempt is defined by implementing classes. Implementations should assure
+ * that only one future retry operation is ever scheduled at a time.
+ */
+public interface RetryScheduler {
+
+  /**
+   * A request to schedule a future retry (or retries) for a failed operation. Noop if an operation
+   * has already been scheduled.
+   */
+  void schedule(Runnable retryOperation);
+
+  /**
+   * Resets the scheduler, effectively cancelling any future retry operation.
+   */
+  void reset();
+}
diff --git a/core/src/main/java/io/grpc/internal/RetryingNameResolver.java b/core/src/main/java/io/grpc/internal/RetryingNameResolver.java
new file mode 100644
index 00000000000..90827fa8acb
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/RetryingNameResolver.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2023 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.internal;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.NameResolver;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+
+/**
+ * This wrapper class can add retry capability to any polling {@link NameResolver} implementation
+ * that supports calling {@link ResolutionResultListener}s with the outcome of each resolution.
+ *
+ * <p>The {@link NameResolver} used with this
+ */
+public final class RetryingNameResolver extends ForwardingNameResolver {
+  public static NameResolver wrap(NameResolver retriedNameResolver, Args args) {
+    // For migration, this might become conditional
+    return new RetryingNameResolver(
+        retriedNameResolver,
+        new BackoffPolicyRetryScheduler(
+            new ExponentialBackoffPolicy.Provider(),
+            args.getScheduledExecutorService(),
+            args.getSynchronizationContext()),
+        args.getSynchronizationContext());
+  }
+
+  private final NameResolver retriedNameResolver;
+  private final RetryScheduler retryScheduler;
+  private final SynchronizationContext syncContext;
+
+  /**
+   * Creates a new {@link RetryingNameResolver}.
+   *
+   * @param retriedNameResolver A {@link NameResolver} that will have failed attempt retried.
+   * @param retryScheduler Used to schedule the retry attempts.
+   */
+  RetryingNameResolver(NameResolver retriedNameResolver, RetryScheduler retryScheduler,
+      SynchronizationContext syncContext) {
+    super(retriedNameResolver);
+    this.retriedNameResolver = retriedNameResolver;
+    this.retryScheduler = retryScheduler;
+    this.syncContext = syncContext;
+  }
+
+  @Override
+  public void start(Listener2 listener) {
+    super.start(new RetryingListener(listener));
+  }
+
+  @Override
+  public void shutdown() {
+    super.shutdown();
+    retryScheduler.reset();
+  }
+
+  /**
+   * Used to get the underlying {@link NameResolver} that is getting its failed attempts retried.
+   */
+  @VisibleForTesting
+  NameResolver getRetriedNameResolver() {
+    return retriedNameResolver;
+  }
+
+  @VisibleForTesting
+  class DelayedNameResolverRefresh implements Runnable {
+    @Override
+    public void run() {
+      refresh();
+    }
+  }
+
+  private class RetryingListener extends Listener2 {
+    private Listener2 delegateListener;
+
+    RetryingListener(Listener2 delegateListener) {
+      this.delegateListener = delegateListener;
+    }
+
+    @Override
+    public void onResult(ResolutionResult resolutionResult) {
+      syncContext.execute(() -> onResult2(resolutionResult));
+    }
+
+    @Override
+    public Status onResult2(ResolutionResult resolutionResult) {
+      Status status = delegateListener.onResult2(resolutionResult);
+      if (status.isOk()) {
+        retryScheduler.reset();
+      } else {
+        retryScheduler.schedule(new DelayedNameResolverRefresh());
+      }
+      return status;
+    }
+
+    @Override
+    public void onError(Status error) {
+      delegateListener.onError(error);
+      syncContext.execute(() -> retryScheduler.schedule(new DelayedNameResolverRefresh()));
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/RoundRobinServerList.java b/core/src/main/java/io/grpc/internal/RoundRobinServerList.java
deleted file mode 100644
index c45790a9068..00000000000
--- a/core/src/main/java/io/grpc/internal/RoundRobinServerList.java
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import com.google.common.annotations.VisibleForTesting;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.Status;
-import io.grpc.TransportManager;
-import java.net.SocketAddress;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-import java.util.NoSuchElementException;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.NotThreadSafe;
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * Manages a list of server addresses to round-robin on.
- */
-@ThreadSafe
-public class RoundRobinServerList<T> {
-  private final TransportManager<T> tm;
-  private final List<EquivalentAddressGroup> list;
-  private final Iterator<EquivalentAddressGroup> cyclingIter;
-  private final T requestDroppingTransport;
-
-  private RoundRobinServerList(TransportManager<T> tm, List<EquivalentAddressGroup> list) {
-    this.tm = tm;
-    this.list = list;
-    this.cyclingIter = new CycleIterator<EquivalentAddressGroup>(list);
-    this.requestDroppingTransport =
-      tm.createFailingTransport(Status.UNAVAILABLE.withDescription("Throttled by LB"));
-  }
-
-  /**
-   * Returns the next transport in the list of servers.
-   *
-   * @return the next transport
-   */
-  public T getTransportForNextServer() {
-    EquivalentAddressGroup currentServer;
-    synchronized (cyclingIter) {
-      // TODO(zhangkun83): receive transportShutdown and transportReady events, then skip addresses
-      // that have been failing.
-      currentServer = cyclingIter.next();
-    }
-    if (currentServer == null) {
-      return requestDroppingTransport;
-    }
-    return tm.getTransport(currentServer);
-  }
-
-  @VisibleForTesting
-  public List<EquivalentAddressGroup> getList() {
-    return list;
-  }
-
-  public int size() {
-    return list.size();
-  }
-
-  @NotThreadSafe
-  public static class Builder<T> {
-    private final List<EquivalentAddressGroup> list = new ArrayList<EquivalentAddressGroup>();
-    private final TransportManager<T> tm;
-
-    public Builder(TransportManager<T> tm) {
-      this.tm = tm;
-    }
-
-    /**
-     * Adds a server to the list, or {@code null} for a drop entry.
-     */
-    public Builder<T> addSocketAddress(@Nullable SocketAddress address) {
-      list.add(new EquivalentAddressGroup(address));
-      return this;
-    }
-
-    /**
-     * Adds a address group to the list.
-     *
-     * @param addresses the addresses to add
-     */
-    public Builder<T> add(EquivalentAddressGroup addresses) {
-      list.add(addresses);
-      return this;
-    }
-
-    /**
-     * Adds a list of address groups.
-     *
-     * @param addresses the list of addresses group.
-     */
-    public Builder<T> addAll(Collection<EquivalentAddressGroup> addresses) {
-      list.addAll(addresses);
-      return this;
-    }
-
-    public RoundRobinServerList<T> build() {
-      return new RoundRobinServerList<T>(tm,
-          Collections.unmodifiableList(new ArrayList<EquivalentAddressGroup>(list)));
-    }
-  }
-
-  private static final class CycleIterator<T> implements Iterator<T> {
-    private final List<T> list;
-    private int index;
-
-    public CycleIterator(List<T> list) {
-      this.list = list;
-    }
-
-    @Override
-    public boolean hasNext() {
-      return !list.isEmpty();
-    }
-
-    @Override
-    public T next() {
-      if (!hasNext()) {
-        throw new NoSuchElementException();
-      }
-      T val = list.get(index);
-      index++;
-      if (index >= list.size()) {
-        index -= list.size();
-      }
-      return val;
-    }
-
-    @Override
-    public void remove() {
-      throw new UnsupportedOperationException();
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/ScParser.java b/core/src/main/java/io/grpc/internal/ScParser.java
new file mode 100644
index 00000000000..71d6d33877f
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ScParser.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2019 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import java.util.Map;
+
+/** The library built-in implementation of service config parser. */
+@VisibleForTesting
+public final class ScParser extends NameResolver.ServiceConfigParser {
+
+  private final boolean retryEnabled;
+  private final int maxRetryAttemptsLimit;
+  private final int maxHedgedAttemptsLimit;
+  private final LoadBalancerProvider parser;
+
+  /** Creates a parse with global retry settings and an auto configured lb factory. */
+  public ScParser(
+      boolean retryEnabled,
+      int maxRetryAttemptsLimit,
+      int maxHedgedAttemptsLimit,
+      LoadBalancerProvider parser) {
+    this.retryEnabled = retryEnabled;
+    this.maxRetryAttemptsLimit = maxRetryAttemptsLimit;
+    this.maxHedgedAttemptsLimit = maxHedgedAttemptsLimit;
+    this.parser = checkNotNull(parser, "parser");
+  }
+
+  @Override
+  public ConfigOrError parseServiceConfig(Map<String, ?> rawServiceConfig) {
+    try {
+      Object loadBalancingPolicySelection;
+      ConfigOrError choiceFromLoadBalancer =
+          parser.parseLoadBalancingPolicyConfig(rawServiceConfig);
+      // TODO(ejona): The Provider API doesn't allow null, but AutoConfiguredLoadBalancerFactory can
+      // return null and it will need tweaking to ManagedChannelImpl.defaultServiceConfig to fix.
+      if (choiceFromLoadBalancer == null) {
+        loadBalancingPolicySelection = null;
+      } else if (choiceFromLoadBalancer.getError() != null) {
+        return ConfigOrError.fromError(choiceFromLoadBalancer.getError());
+      } else {
+        loadBalancingPolicySelection = choiceFromLoadBalancer.getConfig();
+      }
+      return ConfigOrError.fromConfig(
+          ManagedChannelServiceConfig.fromServiceConfig(
+              rawServiceConfig,
+              retryEnabled,
+              maxRetryAttemptsLimit,
+              maxHedgedAttemptsLimit,
+              loadBalancingPolicySelection));
+    } catch (RuntimeException e) {
+      // TODO(ejona): We really don't want parsers throwing exceptions; they should return an error.
+      // However, right now ManagedChannelServiceConfig itself uses exceptions like
+      // ClassCastException. We should handle those with a graceful return within
+      // ManagedChannelServiceConfig and then get rid of this case. Then all exceptions are
+      // "unexpected" and the INTERNAL status code makes it clear a bug needs to be fixed.
+      return ConfigOrError.fromError(
+          Status.UNKNOWN.withDescription("failed to parse service config").withCause(e));
+    } catch (Throwable t) {
+      // Even catch Errors, since broken config parsing could trigger AssertionError,
+      // StackOverflowError, and other errors we can reasonably safely recover. Since the config
+      // could be untrusted, we want to error on the side of recovering.
+      return ConfigOrError.fromError(
+          Status.INTERNAL.withDescription("Unexpected error parsing service config").withCause(t));
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/SerializeReentrantCallsDirectExecutor.java b/core/src/main/java/io/grpc/internal/SerializeReentrantCallsDirectExecutor.java
index 7f2b36365ca..85ce5137e89 100644
--- a/core/src/main/java/io/grpc/internal/SerializeReentrantCallsDirectExecutor.java
+++ b/core/src/main/java/io/grpc/internal/SerializeReentrantCallsDirectExecutor.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -89,7 +74,7 @@ private void completeQueuedTasks() {
 
   private void enqueue(Runnable r) {
     if (taskQueue == null) {
-      taskQueue = new ArrayDeque<Runnable>(4);
+      taskQueue = new ArrayDeque<>(4);
     }
     taskQueue.add(r);
   }
diff --git a/core/src/main/java/io/grpc/internal/SerializingExecutor.java b/core/src/main/java/io/grpc/internal/SerializingExecutor.java
index 0355aa38579..7044b4e17fc 100644
--- a/core/src/main/java/io/grpc/internal/SerializingExecutor.java
+++ b/core/src/main/java/io/grpc/internal/SerializingExecutor.java
@@ -1,43 +1,31 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
 import com.google.common.base.Preconditions;
-import java.util.ArrayDeque;
 import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import javax.annotation.concurrent.GuardedBy;
+import javax.annotation.Nullable;
 
 /**
  * Executor ensuring that all {@link Runnable} tasks submitted are executed in order
@@ -45,32 +33,38 @@
  * running at the same time.
  */
 // TODO(madongfly): figure out a way to not expose it or move it to transport package.
-public final class SerializingExecutor implements Executor {
+public final class SerializingExecutor implements Executor, Runnable {
   private static final Logger log =
       Logger.getLogger(SerializingExecutor.class.getName());
 
+  // When using Atomic*FieldUpdater, some Samsung Android 5.0.x devices encounter a bug in their JDK
+  // reflection API that triggers a NoSuchFieldException. When this occurs, fallback to a
+  // synchronized implementation.
+  private static final AtomicHelper atomicHelper = getAtomicHelper();
+
+  private static AtomicHelper getAtomicHelper() {
+    AtomicHelper helper;
+    try {
+      helper =
+          new FieldUpdaterAtomicHelper(
+              AtomicIntegerFieldUpdater.newUpdater(SerializingExecutor.class, "runState"));
+    } catch (Throwable t) {
+      log.log(Level.SEVERE, "FieldUpdaterAtomicHelper failed", t);
+      helper = new SynchronizedAtomicHelper();
+    }
+    return helper;
+  }
+
+  private static final int STOPPED = 0;
+  private static final int RUNNING = -1;
+
   /** Underlying executor that all submitted Runnable objects are run on. */
-  private final Executor executor;
+  private Executor executor;
 
   /** A list of Runnables to be run in order. */
-  // Initial size set to 4 because it is a nice number and at least the size necessary for handling
-  // a unary response: onHeaders + onPayload + onClose
-  @GuardedBy("internalLock")
-  private final Queue<Runnable> waitQueue = new ArrayDeque<Runnable>(4);
+  private final Queue<Runnable> runQueue = new ConcurrentLinkedQueue<>();
 
-  /**
-   * We explicitly keep track of if the TaskRunner is currently scheduled to
-   * run.  If it isn't, we start it.  We can't just use
-   * waitQueue.isEmpty() as a proxy because we need to ensure that only one
-   * Runnable submitted is running at a time so even if waitQueue is empty
-   * the isThreadScheduled isn't set to false until after the Runnable is
-   * finished.
-   */
-  @GuardedBy("internalLock")
-  private boolean isThreadScheduled = false;
-
-  /** The object that actually runs the Runnables submitted, reused. */
-  private final TaskRunner taskRunner = new TaskRunner();
+  private volatile int runState = STOPPED;
 
   /**
    * Creates a SerializingExecutor, running tasks using {@code executor}.
@@ -82,11 +76,14 @@ public SerializingExecutor(Executor executor) {
     this.executor = executor;
   }
 
-  private final Object internalLock = new Object() {
-    @Override public String toString() {
-      return "SerializingExecutor lock: " + super.toString();
-    }
-  };
+  /**
+   * Only call this from this SerializingExecutor Runnable, so that the executor is immediately
+   * visible to this SerializingExecutor executor.
+   * */
+  public void setExecutor(Executor executor) {
+    Preconditions.checkNotNull(executor, "'executor' must not be null.");
+    this.executor = executor;
+  }
 
   /**
    * Runs the given runnable strictly after all Runnables that were submitted
@@ -94,77 +91,101 @@ public SerializingExecutor(Executor executor) {
    */
   @Override
   public void execute(Runnable r) {
-    Preconditions.checkNotNull(r, "'r' must not be null.");
-    boolean scheduleTaskRunner = false;
-    synchronized (internalLock) {
-      waitQueue.add(r);
-
-      if (!isThreadScheduled) {
-        isThreadScheduled = true;
-        scheduleTaskRunner = true;
-      }
-    }
-    if (scheduleTaskRunner) {
-      boolean threw = true;
+    runQueue.add(checkNotNull(r, "'r' must not be null."));
+    schedule(r);
+  }
+
+  private void schedule(@Nullable Runnable removable) {
+    if (atomicHelper.runStateCompareAndSet(this, STOPPED, RUNNING)) {
+      boolean success = false;
       try {
-        executor.execute(taskRunner);
-        threw = false;
+        executor.execute(this);
+        success = true;
       } finally {
-        if (threw) {
-          synchronized (internalLock) {
-            // It is possible that at this point that there are still tasks in
-            // the queue, it would be nice to keep trying but the error may not
-            // be recoverable.  So we update our state and propogate so that if
-            // our caller deems it recoverable we won't be stuck.
-            isThreadScheduled = false;
+        // It is possible that at this point that there are still tasks in
+        // the queue, it would be nice to keep trying but the error may not
+        // be recoverable.  So we update our state and propagate so that if
+        // our caller deems it recoverable we won't be stuck.
+        if (!success) {
+          if (removable != null) {
+            // This case can only be reached if 'this' was not currently running, and we failed to
+            // reschedule.  The item should still be in the queue for removal.
+            // ConcurrentLinkedQueue claims that null elements are not allowed, but seems to not
+            // throw if the item to remove is null.  If removable is present in the queue twice,
+            // the wrong one may be removed.  It doesn't seem possible for this case to exist today.
+            // This is important to run in case of RejectedExecutionException, so that future calls
+            // to execute don't succeed and accidentally run a previous runnable.
+            runQueue.remove(removable);
           }
+          atomicHelper.runStateSet(this, STOPPED);
         }
       }
     }
   }
 
-  /**
-   * Task that actually runs the Runnables.  It takes the Runnables off of the
-   * queue one by one and runs them.  After it is done with all Runnables and
-   * there are no more to run, puts the SerializingExecutor in the state where
-   * isThreadScheduled = false and returns.  This allows the current worker
-   * thread to return to the original pool.
-   */
-  private class TaskRunner implements Runnable {
+  @Override
+  public void run() {
+    Runnable r;
+    try {
+      Executor oldExecutor = executor;
+      while (oldExecutor == executor && (r = runQueue.poll()) != null ) {
+        try {
+          r.run();
+        } catch (RuntimeException e) {
+          // Log it and keep going.
+          log.log(Level.SEVERE, "Exception while executing runnable " + r, e);
+        }
+      }
+    } finally {
+      atomicHelper.runStateSet(this, STOPPED);
+    }
+    if (!runQueue.isEmpty()) {
+      // we didn't enqueue anything but someone else did.
+      schedule(null);
+    }
+  }
+
+  private abstract static class AtomicHelper {
+    public abstract boolean runStateCompareAndSet(SerializingExecutor obj, int expect, int update);
+
+    public abstract void runStateSet(SerializingExecutor obj, int newValue);
+  }
+
+  private static final class FieldUpdaterAtomicHelper extends AtomicHelper {
+    private final AtomicIntegerFieldUpdater<SerializingExecutor> runStateUpdater;
+
+    private FieldUpdaterAtomicHelper(
+        AtomicIntegerFieldUpdater<SerializingExecutor> runStateUpdater) {
+      this.runStateUpdater = runStateUpdater;
+    }
+
     @Override
-    public void run() {
-      boolean stillRunning = true;
-      try {
-        while (true) {
-          Runnable nextToRun;
-          synchronized (internalLock) {
-            Preconditions.checkState(isThreadScheduled);
-            nextToRun = waitQueue.poll();
-            if (nextToRun == null) {
-              isThreadScheduled = false;
-              stillRunning = false;
-              break;
-            }
-          }
+    public boolean runStateCompareAndSet(SerializingExecutor obj, int expect, int update) {
+      return runStateUpdater.compareAndSet(obj, expect, update);
+    }
 
-          // Always run while not holding the lock, to avoid deadlocks.
-          try {
-            nextToRun.run();
-          } catch (RuntimeException e) {
-            // Log it and keep going.
-            log.log(Level.SEVERE, "Exception while executing runnable "
-                + nextToRun, e);
-          }
-        }
-      } finally {
-        if (stillRunning) {
-          // An Error is bubbling up, we should mark ourselves as no longer
-          // running, that way if anyone tries to keep using us we won't be
-          // corrupted.
-          synchronized (internalLock) {
-            isThreadScheduled = false;
-          }
+    @Override
+    public void runStateSet(SerializingExecutor obj, int newValue) {
+      runStateUpdater.set(obj, newValue);
+    }
+  }
+
+  private static final class SynchronizedAtomicHelper extends AtomicHelper {
+    @Override
+    public boolean runStateCompareAndSet(SerializingExecutor obj, int expect, int update) {
+      synchronized (obj) {
+        if (obj.runState == expect) {
+          obj.runState = update;
+          return true;
         }
+        return false;
+      }
+    }
+
+    @Override
+    public void runStateSet(SerializingExecutor obj, int newValue) {
+      synchronized (obj) {
+        obj.runState = newValue;
       }
     }
   }
diff --git a/core/src/main/java/io/grpc/internal/ServerCallImpl.java b/core/src/main/java/io/grpc/internal/ServerCallImpl.java
index 2318738a1c6..e224384ce8f 100644
--- a/core/src/main/java/io/grpc/internal/ServerCallImpl.java
+++ b/core/src/main/java/io/grpc/internal/ServerCallImpl.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -34,84 +19,106 @@
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.internal.GrpcAttributes.ATTR_SECURITY_LEVEL;
 import static io.grpc.internal.GrpcUtil.ACCEPT_ENCODING_SPLITTER;
+import static io.grpc.internal.GrpcUtil.CONTENT_LENGTH_KEY;
 import static io.grpc.internal.GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY;
 import static io.grpc.internal.GrpcUtil.MESSAGE_ENCODING_KEY;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Throwables;
+import com.google.common.util.concurrent.MoreExecutors;
 import io.grpc.Attributes;
 import io.grpc.Codec;
 import io.grpc.Compressor;
 import io.grpc.CompressorRegistry;
 import io.grpc.Context;
-import io.grpc.Decompressor;
 import io.grpc.DecompressorRegistry;
+import io.grpc.InternalDecompressorRegistry;
+import io.grpc.InternalStatus;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
-import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.SecurityLevel;
 import io.grpc.ServerCall;
 import io.grpc.Status;
-import java.io.IOException;
+import io.grpc.StatusRuntimeException;
+import io.perfmark.PerfMark;
+import io.perfmark.Tag;
+import io.perfmark.TaskCloseable;
 import java.io.InputStream;
-import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 final class ServerCallImpl<ReqT, RespT> extends ServerCall<ReqT, RespT> {
+
+  private static final Logger log = Logger.getLogger(ServerCallImpl.class.getName());
+
+  @VisibleForTesting
+  static final String TOO_MANY_RESPONSES = "Too many responses";
+  @VisibleForTesting
+  static final String MISSING_RESPONSE = "Completed without a response";
+
   private final ServerStream stream;
   private final MethodDescriptor<ReqT, RespT> method;
+  private final Tag tag;
   private final Context.CancellableContext context;
-  private final String messageAcceptEncoding;
+  private final byte[] messageAcceptEncoding;
   private final DecompressorRegistry decompressorRegistry;
   private final CompressorRegistry compressorRegistry;
-  private final StatsTraceContext statsTraceCtx;
+  private CallTracer serverCallTracer;
 
   // state
   private volatile boolean cancelled;
   private boolean sendHeadersCalled;
   private boolean closeCalled;
   private Compressor compressor;
+  private boolean messageSent;
 
   ServerCallImpl(ServerStream stream, MethodDescriptor<ReqT, RespT> method,
-      Metadata inboundHeaders, Context.CancellableContext context, StatsTraceContext statsTraceCtx,
-      DecompressorRegistry decompressorRegistry, CompressorRegistry compressorRegistry) {
+      Metadata inboundHeaders, Context.CancellableContext context,
+      DecompressorRegistry decompressorRegistry, CompressorRegistry compressorRegistry,
+      CallTracer serverCallTracer, Tag tag) {
     this.stream = stream;
     this.method = method;
     this.context = context;
     this.messageAcceptEncoding = inboundHeaders.get(MESSAGE_ACCEPT_ENCODING_KEY);
     this.decompressorRegistry = decompressorRegistry;
     this.compressorRegistry = compressorRegistry;
-    this.statsTraceCtx = checkNotNull(statsTraceCtx, "statsTraceCtx");
-
-    if (inboundHeaders.containsKey(MESSAGE_ENCODING_KEY)) {
-      String encoding = inboundHeaders.get(MESSAGE_ENCODING_KEY);
-      Decompressor decompressor = decompressorRegistry.lookupDecompressor(encoding);
-      if (decompressor == null) {
-        throw Status.UNIMPLEMENTED
-            .withDescription(String.format("Can't find decompressor for %s", encoding))
-            .asRuntimeException();
-      }
-      stream.setDecompressor(decompressor);
-    }
+    this.serverCallTracer = serverCallTracer;
+    this.serverCallTracer.reportCallStarted();
+    this.tag = tag;
   }
 
   @Override
   public void request(int numMessages) {
-    stream.request(numMessages);
+    try (TaskCloseable ignore = PerfMark.traceTask("ServerCall.request")) {
+      PerfMark.attachTag(tag);
+      stream.request(numMessages);
+    }
   }
 
   @Override
   public void sendHeaders(Metadata headers) {
+    try (TaskCloseable ignore = PerfMark.traceTask("ServerCall.sendHeaders")) {
+      PerfMark.attachTag(tag);
+      sendHeadersInternal(headers);
+    }
+  }
+
+  private void sendHeadersInternal(Metadata headers) {
     checkState(!sendHeadersCalled, "sendHeaders has already been called");
     checkState(!closeCalled, "call is closed");
 
+    headers.discardAll(CONTENT_LENGTH_KEY);
     headers.discardAll(MESSAGE_ENCODING_KEY);
     if (compressor == null) {
       compressor = Codec.Identity.NONE;
     } else {
       if (messageAcceptEncoding != null) {
-        List<String> acceptedEncodingsList =
-            ACCEPT_ENCODING_SPLITTER.splitToList(messageAcceptEncoding);
-        if (!acceptedEncodingsList.contains(compressor.getMessageEncoding())) {
+        // TODO(carl-mastrangelo): remove the string allocation.
+        if (!GrpcUtil.iterableContains(
+            ACCEPT_ENCODING_SPLITTER.split(new String(messageAcceptEncoding, GrpcUtil.US_ASCII)),
+            compressor.getMessageEncoding())) {
           // resort to using no compression.
           compressor = Codec.Identity.NONE;
         }
@@ -126,31 +133,49 @@ public void sendHeaders(Metadata headers) {
     stream.setCompressor(compressor);
 
     headers.discardAll(MESSAGE_ACCEPT_ENCODING_KEY);
-    String advertisedEncodings = decompressorRegistry.getRawAdvertisedMessageEncodings();
-    if (!advertisedEncodings.isEmpty()) {
+    byte[] advertisedEncodings =
+        InternalDecompressorRegistry.getRawAdvertisedMessageEncodings(decompressorRegistry);
+    if (advertisedEncodings.length != 0) {
       headers.put(MESSAGE_ACCEPT_ENCODING_KEY, advertisedEncodings);
     }
 
     // Don't check if sendMessage has been called, since it requires that sendHeaders was already
     // called.
     sendHeadersCalled = true;
-    stream.writeHeaders(headers);
+    stream.writeHeaders(headers, !getMethodDescriptor().getType().serverSendsOneMessage());
   }
 
   @Override
   public void sendMessage(RespT message) {
+    try (TaskCloseable ignore = PerfMark.traceTask("ServerCall.sendMessage")) {
+      PerfMark.attachTag(tag);
+      sendMessageInternal(message);
+    }
+  }
+
+  private void sendMessageInternal(RespT message) {
     checkState(sendHeadersCalled, "sendHeaders has not been called");
     checkState(!closeCalled, "call is closed");
+
+    if (method.getType().serverSendsOneMessage() && messageSent) {
+      handleInternalError(Status.INTERNAL.withDescription(TOO_MANY_RESPONSES).asRuntimeException());
+      return;
+    }
+
+    messageSent = true;
     try {
       InputStream resp = method.streamResponse(message);
       stream.writeMessage(resp);
-      stream.flush();
+      if (!getMethodDescriptor().getType().serverSendsOneMessage()) {
+        stream.flush();
+      }
     } catch (RuntimeException e) {
-      close(Status.fromThrowable(e), new Metadata());
+      handleInternalError(e);
+    } catch (Error e) {
+      close(
+          Status.CANCELLED.withDescription("Server sendMessage() failed with Error"),
+          new Metadata());
       throw e;
-    } catch (Throwable t) {
-      close(Status.fromThrowable(t), new Metadata());
-      throw new RuntimeException(t);
     }
   }
 
@@ -159,6 +184,11 @@ public void setMessageCompression(boolean enable) {
     stream.setMessageCompression(enable);
   }
 
+  @Override
+  public void setOnReadyThreshold(int numBytes) {
+    stream.setOnReadyThreshold(numBytes);
+  }
+
   @Override
   public void setCompression(String compressorName) {
     // Added here to give a better error message.
@@ -170,14 +200,34 @@ public void setCompression(String compressorName) {
 
   @Override
   public boolean isReady() {
+    if (closeCalled) {
+      return false;
+    }
     return stream.isReady();
   }
 
   @Override
   public void close(Status status, Metadata trailers) {
+    try (TaskCloseable ignore = PerfMark.traceTask("ServerCall.close")) {
+      PerfMark.attachTag(tag);
+      closeInternal(status, trailers);
+    }
+  }
+
+  private void closeInternal(Status status, Metadata trailers) {
     checkState(!closeCalled, "call already closed");
-    closeCalled = true;
-    stream.close(status, trailers);
+    try {
+      closeCalled = true;
+
+      if (status.isOk() && method.getType().serverSendsOneMessage() && !messageSent) {
+        handleInternalError(Status.INTERNAL.withDescription(MISSING_RESPONSE).asRuntimeException());
+        return;
+      }
+
+      stream.close(status, trailers);
+    } finally {
+      serverCallTracer.reportCallEnded(status.isOk());
+    }
   }
 
   @Override
@@ -186,7 +236,7 @@ public boolean isCancelled() {
   }
 
   ServerStreamListener newServerStreamListener(ServerCall.Listener<ReqT> listener) {
-    return new ServerStreamListenerImpl<ReqT>(this, listener, context, statsTraceCtx);
+    return new ServerStreamListenerImpl<>(this, listener, context);
   }
 
   @Override
@@ -194,11 +244,41 @@ public Attributes getAttributes() {
     return stream.getAttributes();
   }
 
+  @Override
+  public String getAuthority() {
+    return stream.getAuthority();
+  }
+
   @Override
   public MethodDescriptor<ReqT, RespT> getMethodDescriptor() {
     return method;
   }
 
+  @Override
+  public SecurityLevel getSecurityLevel() {
+    final Attributes attributes = getAttributes();
+    if (attributes == null) {
+      return super.getSecurityLevel();
+    }
+    final SecurityLevel securityLevel = attributes.get(ATTR_SECURITY_LEVEL);
+    return securityLevel == null ? super.getSecurityLevel() : securityLevel;
+  }
+
+  /**
+   * Close the {@link ServerStream} because an internal error occurred. Allow the application to
+   * run until completion, but silently ignore interactions with the {@link ServerStream} from now
+   * on.
+   */
+  private void handleInternalError(Throwable internalError) {
+    log.log(Level.WARNING, "Cancelling the stream because of internal error", internalError);
+    Status status = (internalError instanceof StatusRuntimeException)
+        ? ((StatusRuntimeException) internalError).getStatus()
+        : Status.INTERNAL.withCause(internalError)
+            .withDescription("Internal error so cancelling stream.");
+    stream.cancel(status);
+    serverCallTracer.reportCallEnded(false); // error so always false
+  }
+
   /**
    * All of these callbacks are assumed to called on an application thread, and the caller is
    * responsible for handling thrown exceptions.
@@ -208,84 +288,112 @@ static final class ServerStreamListenerImpl<ReqT> implements ServerStreamListene
     private final ServerCallImpl<ReqT, ?> call;
     private final ServerCall.Listener<ReqT> listener;
     private final Context.CancellableContext context;
-    private final StatsTraceContext statsTraceCtx;
-    private boolean messageReceived;
 
     public ServerStreamListenerImpl(
         ServerCallImpl<ReqT, ?> call, ServerCall.Listener<ReqT> listener,
-        Context.CancellableContext context, StatsTraceContext statsTraceCtx) {
+        Context.CancellableContext context) {
       this.call = checkNotNull(call, "call");
       this.listener = checkNotNull(listener, "listener must not be null");
       this.context = checkNotNull(context, "context");
-      this.statsTraceCtx = checkNotNull(statsTraceCtx, "statsTraceCtx");
+      // Wire ourselves up so that if the context is cancelled, our flag call.cancelled also
+      // reflects the new state. Use a DirectExecutor so that it happens in the same thread
+      // as the caller of {@link Context#cancel}.
+      this.context.addListener(
+          new Context.CancellationListener() {
+            @Override
+            public void cancelled(Context context) {
+              // If the context has a cancellation cause then something exceptional happened
+              // and we should also mark the call as cancelled.
+              if (context.cancellationCause() != null) {
+                ServerStreamListenerImpl.this.call.cancelled = true;
+              }
+            }
+          },
+          MoreExecutors.directExecutor());
     }
 
     @Override
-    public void messageRead(final InputStream message) {
-      Throwable t = null;
-      try {
-        if (call.cancelled) {
-          return;
-        }
-        // Special case for unary calls.
-        if (messageReceived && call.method.getType() == MethodType.UNARY) {
-          call.stream.close(Status.INTERNAL.withDescription(
-                  "More than one request messages for unary call or server streaming call"),
-              new Metadata());
-          return;
-        }
-        messageReceived = true;
+    public void messagesAvailable(MessageProducer producer) {
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.messagesAvailable")) {
+        PerfMark.attachTag(call.tag);
+        messagesAvailableInternal(producer);
+      }
+    }
 
-        listener.onMessage(call.method.parseRequest(message));
-      } catch (Throwable e) {
-        t = e;
-      } finally {
-        try {
-          message.close();
-        } catch (IOException e) {
-          throw new RuntimeException(e);
-        } finally {
-          if (t != null) {
-            // TODO(carl-mastrangelo): Maybe log e here.
-            Throwables.throwIfUnchecked(t);
-            throw new RuntimeException(t);
+    @SuppressWarnings("Finally") // The code avoids suppressing the exception thrown from try
+    private void messagesAvailableInternal(final MessageProducer producer) {
+      if (call.cancelled) {
+        GrpcUtil.closeQuietly(producer);
+        return;
+      }
+
+      InputStream message;
+      try {
+        while ((message = producer.next()) != null) {
+          try {
+            listener.onMessage(call.method.parseRequest(message));
+          } catch (Throwable t) {
+            GrpcUtil.closeQuietly(message);
+            throw t;
           }
+          message.close();
         }
+      } catch (Throwable t) {
+        GrpcUtil.closeQuietly(producer);
+        Throwables.throwIfUnchecked(t);
+        throw new RuntimeException(t);
       }
     }
 
     @Override
     public void halfClosed() {
-      if (call.cancelled) {
-        return;
-      }
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.halfClosed")) {
+        PerfMark.attachTag(call.tag);
+        if (call.cancelled) {
+          return;
+        }
 
-      listener.onHalfClose();
+        listener.onHalfClose();
+      }
     }
 
     @Override
     public void closed(Status status) {
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.closed")) {
+        PerfMark.attachTag(call.tag);
+        closedInternal(status);
+      }
+    }
+
+    private void closedInternal(Status status) {
+      Throwable cancelCause = null;
       try {
-        statsTraceCtx.callEnded(status);
         if (status.isOk()) {
           listener.onComplete();
         } else {
           call.cancelled = true;
           listener.onCancel();
+          // The status will not have a cause in all failure scenarios, but we want to make sure
+          // we always cancel the context with one to keep the context cancelled state consistent.
+          cancelCause = InternalStatus.asRuntimeExceptionWithoutStacktrace(
+              Status.CANCELLED.withDescription("RPC cancelled"), null);
         }
       } finally {
         // Cancel context after delivering RPC closure notification to allow the application to
         // clean up and update any state based on whether onComplete or onCancel was called.
-        context.cancel(null);
+        context.cancel(cancelCause);
       }
     }
 
     @Override
     public void onReady() {
-      if (call.cancelled) {
-        return;
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.onReady")) {
+        PerfMark.attachTag(call.tag);
+        if (call.cancelled) {
+          return;
+        }
+        listener.onReady();
       }
-      listener.onReady();
     }
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/ServerCallInfoImpl.java b/core/src/main/java/io/grpc/internal/ServerCallInfoImpl.java
new file mode 100644
index 00000000000..0e8b899306c
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ServerCallInfoImpl.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2018 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.internal;
+
+import com.google.common.base.Objects;
+import io.grpc.Attributes;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerStreamTracer.ServerCallInfo;
+import javax.annotation.Nullable;
+
+/**
+ * An implementation of {@link ServerCallInfo}.
+ */
+final class ServerCallInfoImpl<ReqT, RespT> extends ServerCallInfo<ReqT, RespT> {
+  private final MethodDescriptor<ReqT, RespT> methodDescriptor;
+  private final Attributes attributes;
+  private final String authority;
+
+  ServerCallInfoImpl(
+      MethodDescriptor<ReqT, RespT> methodDescriptor,
+      Attributes attributes,
+      @Nullable String authority) {
+    this.methodDescriptor = methodDescriptor;
+    this.attributes = attributes;
+    this.authority = authority;
+  }
+
+  @Override
+  public MethodDescriptor<ReqT, RespT> getMethodDescriptor() {
+    return methodDescriptor;
+  }
+
+  @Override
+  public Attributes getAttributes() {
+    return attributes;
+  }
+
+  @Override
+  @Nullable
+  public String getAuthority() {
+    return authority;
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (!(other instanceof ServerCallInfoImpl)) {
+      return false;
+    }
+    ServerCallInfoImpl<?, ?> that = (ServerCallInfoImpl) other;
+    return Objects.equal(methodDescriptor, that.methodDescriptor)
+        && Objects.equal(attributes, that.attributes)
+        && Objects.equal(authority, that.authority);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(methodDescriptor, attributes, authority);
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ServerImpl.java b/core/src/main/java/io/grpc/internal/ServerImpl.java
index aee47e926dd..dc0709e1fb8 100644
--- a/core/src/main/java/io/grpc/internal/ServerImpl.java
+++ b/core/src/main/java/io/grpc/internal/ServerImpl.java
@@ -1,70 +1,81 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
 import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
 import static io.grpc.Contexts.statusFromCancelled;
 import static io.grpc.Status.DEADLINE_EXCEEDED;
+import static io.grpc.internal.GrpcUtil.MESSAGE_ENCODING_KEY;
 import static io.grpc.internal.GrpcUtil.TIMEOUT_KEY;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
 import com.google.common.base.Preconditions;
-import com.google.common.base.Stopwatch;
-import com.google.common.base.Supplier;
-import com.google.instrumentation.stats.StatsContextFactory;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
 import io.grpc.Attributes;
+import io.grpc.BinaryLog;
 import io.grpc.CompressorRegistry;
 import io.grpc.Context;
+import io.grpc.Deadline;
+import io.grpc.Decompressor;
 import io.grpc.DecompressorRegistry;
 import io.grpc.HandlerRegistry;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.ServerStats;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.InternalLogId;
+import io.grpc.InternalServerInterceptors;
+import io.grpc.InternalStatus;
 import io.grpc.Metadata;
 import io.grpc.ServerCall;
+import io.grpc.ServerCallExecutorSupplier;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
 import io.grpc.ServerMethodDefinition;
 import io.grpc.ServerServiceDefinition;
 import io.grpc.ServerTransportFilter;
 import io.grpc.Status;
+import io.perfmark.Link;
+import io.perfmark.PerfMark;
+import io.perfmark.Tag;
+import io.perfmark.TaskCloseable;
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 import java.util.concurrent.Executor;
-import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
 import java.util.concurrent.TimeUnit;
-import javax.annotation.concurrent.GuardedBy;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 /**
  * Default implementation of {@link io.grpc.Server}, for creation by transports.
@@ -80,17 +91,21 @@
  * <p>Starting the server starts the underlying transport for servicing requests. Stopping the
  * server stops servicing new requests and waits for all connections to terminate.
  */
-public final class ServerImpl extends io.grpc.Server implements WithLogId {
+public final class ServerImpl extends io.grpc.Server implements InternalInstrumented<ServerStats> {
+  private static final Logger log = Logger.getLogger(ServerImpl.class.getName());
   private static final ServerStreamListener NOOP_LISTENER = new NoopListener();
 
-  private final LogId logId = LogId.allocate(getClass().getName());
+  private final InternalLogId logId;
   private final ObjectPool<? extends Executor> executorPool;
   /** Executor for application processing. Safe to read after {@link #start()}. */
   private Executor executor;
-  private final InternalHandlerRegistry registry;
+  private final HandlerRegistry registry;
   private final HandlerRegistry fallbackRegistry;
   private final List<ServerTransportFilter> transportFilters;
-  private final StatsContextFactory statsFactory;
+  // This is iterated on a per-call basis.  Use an array instead of a Collection to avoid iterator
+  // creations.
+  private final ServerInterceptor[] interceptors;
+  private final long handshakeTimeoutMillis;
   @GuardedBy("lock") private boolean started;
   @GuardedBy("lock") private boolean shutdown;
   /** non-{@code null} if immediate shutdown has been requested. */
@@ -101,48 +116,55 @@ public final class ServerImpl extends io.grpc.Server implements WithLogId {
   /** Service encapsulating something similar to an accept() socket. */
   private final InternalServer transportServer;
   private final Object lock = new Object();
-  @GuardedBy("lock") private boolean transportServerTerminated;
+  @GuardedBy("lock") private boolean transportServersTerminated;
   /** {@code transportServer} and services encapsulating something similar to a TCP connection. */
-  @GuardedBy("lock") private final Collection<ServerTransport> transports =
-      new HashSet<ServerTransport>();
+  @GuardedBy("lock") private final Set<ServerTransport> transports = new HashSet<>();
 
-  private final ObjectPool<ScheduledExecutorService> timeoutServicePool;
-  private ScheduledExecutorService timeoutService;
   private final Context rootContext;
 
   private final DecompressorRegistry decompressorRegistry;
   private final CompressorRegistry compressorRegistry;
-  private final Supplier<Stopwatch> stopwatchSupplier;
+  private final BinaryLog binlog;
+
+  private final InternalChannelz channelz;
+  private final CallTracer serverCallTracer;
+  private final Deadline.Ticker ticker;
+  private final ServerCallExecutorSupplier executorSupplier;
 
   /**
    * Construct a server.
    *
-   * @param registry the primary method registry
-   * @param fallbackRegistry the secondary method registry, used only if the primary registry
-   *        doesn't have the method
-   * @param executor to call methods on behalf of remote clients
+   * @param builder builder with configuration for server
+   * @param transportServer transport servers that will create new incoming transports
+   * @param rootContext context that callbacks for new RPCs should be derived from
    */
-  ServerImpl(ObjectPool<? extends Executor> executorPool,
-      ObjectPool<ScheduledExecutorService> timeoutServicePool,
-      InternalHandlerRegistry registry, HandlerRegistry fallbackRegistry,
-      InternalServer transportServer, Context rootContext,
-      DecompressorRegistry decompressorRegistry, CompressorRegistry compressorRegistry,
-      List<ServerTransportFilter> transportFilters, StatsContextFactory statsFactory,
-      Supplier<Stopwatch> stopwatchSupplier) {
-    this.executorPool = Preconditions.checkNotNull(executorPool, "executorPool");
-    this.timeoutServicePool = Preconditions.checkNotNull(timeoutServicePool, "timeoutServicePool");
-    this.registry = Preconditions.checkNotNull(registry, "registry");
-    this.fallbackRegistry = Preconditions.checkNotNull(fallbackRegistry, "fallbackRegistry");
+  ServerImpl(
+      ServerImplBuilder builder,
+      InternalServer transportServer,
+      Context rootContext) {
+    this.executorPool = Preconditions.checkNotNull(builder.executorPool, "executorPool");
+    this.registry = Preconditions.checkNotNull(builder.registryBuilder.build(), "registryBuilder");
+    this.fallbackRegistry =
+        Preconditions.checkNotNull(builder.fallbackRegistry, "fallbackRegistry");
     this.transportServer = Preconditions.checkNotNull(transportServer, "transportServer");
+    this.logId =
+        InternalLogId.allocate("Server", String.valueOf(getListenSocketsIgnoringLifecycle()));
     // Fork from the passed in context so that it does not propagate cancellation, it only
     // inherits values.
     this.rootContext = Preconditions.checkNotNull(rootContext, "rootContext").fork();
-    this.decompressorRegistry = decompressorRegistry;
-    this.compressorRegistry = compressorRegistry;
+    this.decompressorRegistry = builder.decompressorRegistry;
+    this.compressorRegistry = builder.compressorRegistry;
     this.transportFilters = Collections.unmodifiableList(
-        new ArrayList<ServerTransportFilter>(transportFilters));
-    this.statsFactory = Preconditions.checkNotNull(statsFactory, "statsFactory");
-    this.stopwatchSupplier = Preconditions.checkNotNull(stopwatchSupplier, "stopwatchSupplier");
+        new ArrayList<>(builder.transportFilters));
+    this.interceptors =
+        builder.interceptors.toArray(new ServerInterceptor[builder.interceptors.size()]);
+    this.handshakeTimeoutMillis = builder.handshakeTimeoutMillis;
+    this.binlog = builder.binlog;
+    this.channelz = builder.channelz;
+    this.serverCallTracer = builder.callTracerFactory.create();
+    this.ticker = checkNotNull(builder.ticker, "ticker");
+    channelz.addServer(this);
+    this.executorSupplier = builder.executorSupplier;
   }
 
   /**
@@ -157,21 +179,43 @@ public ServerImpl start() throws IOException {
     synchronized (lock) {
       checkState(!started, "Already started");
       checkState(!shutdown, "Shutting down");
-      // Start and wait for any port to actually be bound.
-      transportServer.start(new ServerListenerImpl());
-      timeoutService = Preconditions.checkNotNull(timeoutServicePool.getObject(), "timeoutService");
+      // Start and wait for any ports to actually be bound.
+
+      ServerListenerImpl listener = new ServerListenerImpl();
+      transportServer.start(listener);
       executor = Preconditions.checkNotNull(executorPool.getObject(), "executor");
       started = true;
       return this;
     }
   }
 
+
   @Override
   public int getPort() {
     synchronized (lock) {
       checkState(started, "Not started");
       checkState(!terminated, "Already terminated");
-      return transportServer.getPort();
+      for (SocketAddress addr: transportServer.getListenSocketAddresses()) {
+        if (addr instanceof InetSocketAddress) {
+          return ((InetSocketAddress) addr).getPort();
+        }
+      }
+      return -1;
+    }
+  }
+
+  @Override
+  public List<SocketAddress> getListenSockets() {
+    synchronized (lock) {
+      checkState(started, "Not started");
+      checkState(!terminated, "Already terminated");
+      return getListenSocketsIgnoringLifecycle();
+    }
+  }
+
+  private List<SocketAddress> getListenSocketsIgnoringLifecycle() {
+    synchronized (lock) {
+      return Collections.unmodifiableList(transportServer.getListenSocketAddresses());
     }
   }
 
@@ -184,7 +228,7 @@ public List<ServerServiceDefinition> getServices() {
       List<ServerServiceDefinition> registryServices = registry.getServices();
       int servicesCount = registryServices.size() + fallbackServices.size();
       List<ServerServiceDefinition> services =
-          new ArrayList<ServerServiceDefinition>(servicesCount);
+          new ArrayList<>(servicesCount);
       services.addAll(registryServices);
       services.addAll(fallbackServices);
       return Collections.unmodifiableList(services);
@@ -206,19 +250,19 @@ public List<ServerServiceDefinition> getMutableServices() {
    */
   @Override
   public ServerImpl shutdown() {
-    boolean shutdownTransportServer;
+    boolean shutdownTransportServers;
     synchronized (lock) {
       if (shutdown) {
         return this;
       }
       shutdown = true;
-      shutdownTransportServer = started;
-      if (!shutdownTransportServer) {
-        transportServerTerminated = true;
+      shutdownTransportServers = started;
+      if (!shutdownTransportServers) {
+        transportServersTerminated = true;
         checkForTermination();
       }
     }
-    if (shutdownTransportServer) {
+    if (shutdownTransportServers) {
       transportServer.shutdown();
     }
     return this;
@@ -237,7 +281,7 @@ public ServerImpl shutdownNow() {
         return this;
       }
       shutdownNowStatus = nowStatus;
-      transportsCopy = new ArrayList<ServerTransport>(transports);
+      transportsCopy = new ArrayList<>(transports);
       savedServerShutdownCallbackInvoked = serverShutdownCallbackInvoked;
     }
     // Short-circuiting not strictly necessary, but prevents transports from needing to handle
@@ -298,6 +342,7 @@ private void transportClosed(ServerTransport transport) {
       if (!transports.remove(transport)) {
         throw new AssertionError("Transport already removed");
       }
+      channelz.removeServerSocket(ServerImpl.this, transport);
       checkForTermination();
     }
   }
@@ -305,30 +350,30 @@ private void transportClosed(ServerTransport transport) {
   /** Notify of complete shutdown if necessary. */
   private void checkForTermination() {
     synchronized (lock) {
-      if (shutdown && transports.isEmpty() && transportServerTerminated) {
+      if (shutdown && transports.isEmpty() && transportServersTerminated) {
         if (terminated) {
           throw new AssertionError("Server already terminated");
         }
         terminated = true;
-        if (timeoutService != null) {
-          timeoutService = timeoutServicePool.returnObject(timeoutService);
-        }
+        channelz.removeServer(this);
         if (executor != null) {
           executor = executorPool.returnObject(executor);
         }
-        // TODO(carl-mastrangelo): move this outside the synchronized block.
         lock.notifyAll();
       }
     }
   }
 
-  private class ServerListenerImpl implements ServerListener {
+  private final class ServerListenerImpl implements ServerListener {
+
     @Override
     public ServerTransportListener transportCreated(ServerTransport transport) {
       synchronized (lock) {
         transports.add(transport);
       }
-      return new ServerTransportListenerImpl(transport);
+      ServerTransportListenerImpl stli = new ServerTransportListenerImpl(transport);
+      stli.init();
+      return stli;
     }
 
     @Override
@@ -336,9 +381,13 @@ public void serverShutdown() {
       ArrayList<ServerTransport> copiedTransports;
       Status shutdownNowStatusCopy;
       synchronized (lock) {
+        if (serverShutdownCallbackInvoked) {
+          return;
+        }
+
         // transports collection can be modified during shutdown(), even if we hold the lock, due
         // to reentrancy.
-        copiedTransports = new ArrayList<ServerTransport>(transports);
+        copiedTransports = new ArrayList<>(transports);
         shutdownNowStatusCopy = shutdownNowStatus;
         serverShutdownCallbackInvoked = true;
       }
@@ -350,22 +399,45 @@ public void serverShutdown() {
         }
       }
       synchronized (lock) {
-        transportServerTerminated = true;
+        transportServersTerminated = true;
         checkForTermination();
       }
     }
   }
 
-  private class ServerTransportListenerImpl implements ServerTransportListener {
+  private final class ServerTransportListenerImpl implements ServerTransportListener {
     private final ServerTransport transport;
+    private Future<?> handshakeTimeoutFuture;
     private Attributes attributes;
 
-    public ServerTransportListenerImpl(ServerTransport transport) {
+    ServerTransportListenerImpl(ServerTransport transport) {
       this.transport = transport;
     }
 
+    public void init() {
+      class TransportShutdownNow implements Runnable {
+        @Override public void run() {
+          transport.shutdownNow(Status.CANCELLED.withDescription("Handshake timeout exceeded"));
+        }
+      }
+
+      if (handshakeTimeoutMillis != Long.MAX_VALUE) {
+        handshakeTimeoutFuture = transport.getScheduledExecutorService()
+            .schedule(new TransportShutdownNow(), handshakeTimeoutMillis, TimeUnit.MILLISECONDS);
+      } else {
+        // Noop, to avoid triggering Thread creation in InProcessServer
+        handshakeTimeoutFuture = new FutureTask<Void>(new Runnable() {
+          @Override public void run() {}
+        }, null);
+      }
+      channelz.addServerSocket(ServerImpl.this, transport);
+    }
+
     @Override
     public Attributes transportReady(Attributes attributes) {
+      handshakeTimeoutFuture.cancel(false);
+      handshakeTimeoutFuture = null;
+
       for (ServerTransportFilter filter : transportFilters) {
         attributes = Preconditions.checkNotNull(filter.transportReady(attributes),
             "Filter %s returned null", filter);
@@ -376,135 +448,310 @@ public Attributes transportReady(Attributes attributes) {
 
     @Override
     public void transportTerminated() {
+      if (handshakeTimeoutFuture != null) {
+        handshakeTimeoutFuture.cancel(false);
+        handshakeTimeoutFuture = null;
+      }
       for (ServerTransportFilter filter : transportFilters) {
         filter.transportTerminated(attributes);
       }
       transportClosed(transport);
     }
 
-    @Override
-    public StatsTraceContext methodDetermined(String methodName, Metadata headers) {
-      return StatsTraceContext.newServerContext(
-          methodName, statsFactory, headers, stopwatchSupplier);
-    }
 
     @Override
-    public void streamCreated(
-        final ServerStream stream, final String methodName, final Metadata headers) {
-
-      final StatsTraceContext statsTraceCtx = Preconditions.checkNotNull(
-          stream.statsTraceContext(), "statsTraceCtx not present from stream");
+    public void streamCreated(ServerStream stream, String methodName, Metadata headers) {
+      Tag tag = PerfMark.createTag(methodName, stream.streamId());
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerTransportListener.streamCreated")) {
+        PerfMark.attachTag(tag);
+        streamCreatedInternal(stream, methodName, headers, tag);
+      }
+    }
 
-      final Context.CancellableContext context = createContext(stream, headers);
+    private void streamCreatedInternal(
+        final ServerStream stream, final String methodName, final Metadata headers, final Tag tag) {
       final Executor wrappedExecutor;
       // This is a performance optimization that avoids the synchronization and queuing overhead
       // that comes with SerializingExecutor.
-      if (executor == directExecutor()) {
-        wrappedExecutor = new SerializeReentrantCallsDirectExecutor();
-      } else {
+      if (executorSupplier != null || executor != directExecutor()) {
         wrappedExecutor = new SerializingExecutor(executor);
+      } else {
+        wrappedExecutor = new SerializeReentrantCallsDirectExecutor();
+        stream.optimizeForDirectExecutor();
+      }
+
+      if (headers.containsKey(MESSAGE_ENCODING_KEY)) {
+        String encoding = headers.get(MESSAGE_ENCODING_KEY);
+        Decompressor decompressor = decompressorRegistry.lookupDecompressor(encoding);
+        if (decompressor == null) {
+          stream.setListener(NOOP_LISTENER);
+          stream.close(
+              Status.UNIMPLEMENTED.withDescription(
+                  String.format("Can't find decompressor for %s", encoding)),
+              new Metadata());
+          return;
+        }
+        stream.setDecompressor(decompressor);
       }
 
+      final StatsTraceContext statsTraceCtx = Preconditions.checkNotNull(
+          stream.statsTraceContext(), "statsTraceCtx not present from stream");
+
+      final Context.CancellableContext context = createContext(headers, statsTraceCtx);
+
+      final Link link = PerfMark.linkOut();
+
       final JumpToApplicationThreadServerStreamListener jumpListener
-          = new JumpToApplicationThreadServerStreamListener(wrappedExecutor, stream, context);
+          = new JumpToApplicationThreadServerStreamListener(
+                  wrappedExecutor, executor, stream, context, tag);
       stream.setListener(jumpListener);
-      // Run in wrappedExecutor so jumpListener.setListener() is called before any callbacks
-      // are delivered, including any errors. Callbacks can still be triggered, but they will be
-      // queued.
-      wrappedExecutor.execute(new ContextRunnable(context) {
-          @Override
-          public void runInContext() {
-            ServerStreamListener listener = NOOP_LISTENER;
-            try {
-              ServerMethodDefinition<?, ?> method = registry.lookupMethod(methodName);
-              if (method == null) {
-                method = fallbackRegistry.lookupMethod(methodName, stream.getAuthority());
-              }
-              if (method == null) {
-                Status status = Status.UNIMPLEMENTED.withDescription(
-                    "Method not found: " + methodName);
-                stream.close(status, new Metadata());
-                // TODO(zhangkun83): this would allow a misbehaving client to blow up the server
-                // in-memory stats storage by sending large number of distinct unimplemented method
-                // names. (https://github.com/grpc/grpc-java/issues/2285)
-                statsTraceCtx.callEnded(status);
-                context.cancel(null);
-                return;
-              }
-              listener = startCall(stream, methodName, method, headers, context);
-            } catch (RuntimeException e) {
-              stream.close(Status.fromThrowable(e), new Metadata());
-              context.cancel(null);
-              throw e;
-            } catch (Error e) {
-              stream.close(Status.fromThrowable(e), new Metadata());
+      final SettableFuture<ServerCallParameters<?,?>> future = SettableFuture.create();
+      // Run in serializing executor so jumpListener.setListener() is called before any callbacks
+      // are delivered, including any errors. MethodLookup() and HandleServerCall() are proactively
+      // queued before any callbacks are queued at serializing executor.
+      // MethodLookup() runs on the default executor.
+      // When executorSupplier is enabled, MethodLookup() may set/change the executor in the
+      // SerializingExecutor before it finishes running.
+      // Then HandleServerCall() and callbacks would switch to the executorSupplier executor.
+      // Otherwise, they all run on the default executor.
+
+      final class MethodLookup extends ContextRunnable {
+        MethodLookup() {
+          super(context);
+        }
+
+        @Override
+        public void runInContext() {
+          try (TaskCloseable ignore =
+                   PerfMark.traceTask("ServerTransportListener$MethodLookup.startCall")) {
+            PerfMark.attachTag(tag);
+            PerfMark.linkIn(link);
+            runInternal();
+          }
+        }
+
+        private void runInternal() {
+          ServerMethodDefinition<?, ?> wrapMethod;
+          ServerCallParameters<?, ?> callParams;
+          try {
+            ServerMethodDefinition<?, ?> method = registry.lookupMethod(methodName);
+            if (method == null) {
+              method = fallbackRegistry.lookupMethod(methodName, stream.getAuthority());
+            }
+            if (method == null) {
+              Status status = Status.UNIMPLEMENTED.withDescription(
+                      "Method not found: " + methodName);
+              // TODO(zhangkun83): this error may be recorded by the tracer, and if it's kept in
+              // memory as a map whose key is the method name, this would allow a misbehaving
+              // client to blow up the server in-memory stats storage by sending large number of
+              // distinct unimplemented method
+              // names. (https://github.com/grpc/grpc-java/issues/2285)
+              jumpListener.setListener(NOOP_LISTENER);
+              stream.close(status, new Metadata());
               context.cancel(null);
-              throw e;
-            } finally {
-              jumpListener.setListener(listener);
+              future.cancel(false);
+              return;
+            }
+            wrapMethod = wrapMethod(stream, method, statsTraceCtx);
+            callParams = maySwitchExecutor(wrapMethod, stream, headers, context, tag);
+            future.set(callParams);
+          } catch (Throwable t) {
+            jumpListener.setListener(NOOP_LISTENER);
+            stream.close(Status.fromThrowable(t), new Metadata());
+            context.cancel(null);
+            future.cancel(false);
+            throw t;
+          }
+        }
+
+        private <ReqT, RespT> ServerCallParameters<ReqT, RespT> maySwitchExecutor(
+            final ServerMethodDefinition<ReqT, RespT> methodDef,
+            final ServerStream stream,
+            final Metadata headers,
+            final Context.CancellableContext context,
+            final Tag tag) {
+          final ServerCallImpl<ReqT, RespT> call = new ServerCallImpl<>(
+                  stream,
+                  methodDef.getMethodDescriptor(),
+                  headers,
+                  context,
+                  decompressorRegistry,
+                  compressorRegistry,
+                  serverCallTracer,
+                  tag);
+          if (executorSupplier != null) {
+            Executor switchingExecutor = executorSupplier.getExecutor(call, headers);
+            if (switchingExecutor != null) {
+              ((SerializingExecutor)wrappedExecutor).setExecutor(switchingExecutor);
+            }
+          }
+          return new ServerCallParameters<>(call, methodDef.getServerCallHandler());
+        }
+      }
+
+      final class HandleServerCall extends ContextRunnable {
+        HandleServerCall() {
+          super(context);
+        }
+
+        @Override
+        public void runInContext() {
+          try (TaskCloseable ignore =
+                   PerfMark.traceTask("ServerTransportListener$HandleServerCall.startCall")) {
+            PerfMark.linkIn(link);
+            PerfMark.attachTag(tag);
+            runInternal();
+          }
+        }
+
+        private void runInternal() {
+          ServerStreamListener listener = NOOP_LISTENER;
+          if (future.isCancelled()) {
+            return;
+          }
+          try {
+            listener = startWrappedCall(methodName, Futures.getDone(future), headers);
+          } catch (Throwable ex) {
+            stream.close(Status.fromThrowable(ex), new Metadata());
+            context.cancel(null);
+            throw new IllegalStateException(ex);
+          } finally {
+            jumpListener.setListener(listener);
+          }
+
+          // An extremely short deadline may expire before stream.setListener(jumpListener).
+          // This causes NPE as in issue: https://github.com/grpc/grpc-java/issues/6300
+          // Delay of setting cancellationListener to context will fix the issue.
+          final class ServerStreamCancellationListener implements Context.CancellationListener {
+            @Override
+            public void cancelled(Context context) {
+              Status status = statusFromCancelled(context);
+              if (DEADLINE_EXCEEDED.getCode().equals(status.getCode())) {
+                // This should rarely get run, since the client will likely cancel the stream
+                // before the timeout is reached.
+                stream.cancel(status);
+              }
             }
           }
-        });
+
+          context.addListener(new ServerStreamCancellationListener(), directExecutor());
+        }
+      }
+
+      wrappedExecutor.execute(new MethodLookup());
+      wrappedExecutor.execute(new HandleServerCall());
     }
 
     private Context.CancellableContext createContext(
-        final ServerStream stream, Metadata headers) {
+        Metadata headers, StatsTraceContext statsTraceCtx) {
       Long timeoutNanos = headers.get(TIMEOUT_KEY);
 
-      // TODO(zhangkun83): attach the StatsContext from StatsTraceContext to baseContext
-      Context baseContext = rootContext;
+      Context baseContext =
+          statsTraceCtx
+              .serverFilterContext(rootContext)
+              .withValue(io.grpc.InternalServer.SERVER_CONTEXT_KEY, ServerImpl.this);
 
       if (timeoutNanos == null) {
         return baseContext.withCancellation();
       }
 
       Context.CancellableContext context =
-          baseContext.withDeadlineAfter(timeoutNanos, NANOSECONDS, timeoutService);
-      context.addListener(new Context.CancellationListener() {
-        @Override
-        public void cancelled(Context context) {
-          Status status = statusFromCancelled(context);
-          if (DEADLINE_EXCEEDED.getCode().equals(status.getCode())) {
-            // This should rarely get run, since the client will likely cancel the stream before
-            // the timeout is reached.
-            stream.cancel(status);
-          }
-        }
-      }, directExecutor());
+          baseContext.withDeadline(
+              Deadline.after(timeoutNanos, NANOSECONDS, ticker),
+              transport.getScheduledExecutorService());
 
       return context;
     }
 
     /** Never returns {@code null}. */
-    private <ReqT, RespT> ServerStreamListener startCall(ServerStream stream, String fullMethodName,
-        ServerMethodDefinition<ReqT, RespT> methodDef, Metadata headers,
-        Context.CancellableContext context) {
+    private <ReqT, RespT> ServerMethodDefinition<?,?> wrapMethod(ServerStream stream,
+        ServerMethodDefinition<ReqT, RespT> methodDef, StatsTraceContext statsTraceCtx) {
       // TODO(ejona86): should we update fullMethodName to have the canonical path of the method?
-      ServerCallImpl<ReqT, RespT> call = new ServerCallImpl<ReqT, RespT>(
-          stream, methodDef.getMethodDescriptor(), headers, context, stream.statsTraceContext(),
-          decompressorRegistry, compressorRegistry);
-      ServerCall.Listener<ReqT> listener =
-          methodDef.getServerCallHandler().startCall(call, headers);
-      if (listener == null) {
+      statsTraceCtx.serverCallStarted(
+          new ServerCallInfoImpl<>(
+              methodDef.getMethodDescriptor(), // notify with original method descriptor
+              stream.getAttributes(),
+              stream.getAuthority()));
+      ServerCallHandler<ReqT, RespT> handler = methodDef.getServerCallHandler();
+      for (ServerInterceptor interceptor : interceptors) {
+        handler = InternalServerInterceptors.interceptCallHandlerCreate(interceptor, handler);
+      }
+      ServerMethodDefinition<ReqT, RespT> interceptedDef = methodDef.withServerCallHandler(handler);
+      ServerMethodDefinition<?, ?> wMethodDef = binlog == null
+          ? interceptedDef : binlog.wrapMethodDefinition(interceptedDef);
+      return wMethodDef;
+    }
+
+    private final class ServerCallParameters<ReqT, RespT> {
+      ServerCallImpl<ReqT, RespT> call;
+      ServerCallHandler<ReqT, RespT> callHandler;
+
+      public ServerCallParameters(ServerCallImpl<ReqT, RespT> call,
+                                  ServerCallHandler<ReqT, RespT> callHandler) {
+        this.call = call;
+        this.callHandler = callHandler;
+      }
+    }
+
+    private <WReqT, WRespT> ServerStreamListener startWrappedCall(
+        String fullMethodName,
+        ServerCallParameters<WReqT, WRespT> params,
+        Metadata headers) {
+      ServerCall.Listener<WReqT> callListener =
+              params.callHandler.startCall(params.call, headers);
+      if (callListener == null) {
         throw new NullPointerException(
-            "startCall() returned a null listener for method " + fullMethodName);
+                "startCall() returned a null listener for method " + fullMethodName);
       }
-      return call.newServerStreamListener(listener);
+      return params.call.newServerStreamListener(callListener);
     }
   }
 
   @Override
-  public LogId getLogId() {
+  public InternalLogId getLogId() {
     return logId;
   }
 
-  private static class NoopListener implements ServerStreamListener {
+  @Override
+  public ListenableFuture<ServerStats> getStats() {
+    ServerStats.Builder builder = new ServerStats.Builder();
+    List<InternalInstrumented<SocketStats>> stats = transportServer.getListenSocketStatsList();
+    if (stats != null ) {
+      builder.addListenSockets(stats);
+    }
+    serverCallTracer.updateBuilder(builder);
+    SettableFuture<ServerStats> ret = SettableFuture.create();
+    ret.set(builder.build());
+    return ret;
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("logId", logId.getId())
+        .add("transportServer", transportServer)
+        .toString();
+  }
+
+  private static final class NoopListener implements ServerStreamListener {
     @Override
-    public void messageRead(InputStream value) {
-      try {
-        value.close();
-      } catch (IOException e) {
-        throw new RuntimeException(e);
+    public void messagesAvailable(MessageProducer producer) {
+      InputStream message;
+      while ((message = producer.next()) != null) {
+        try {
+          message.close();
+        } catch (IOException e) {
+          // Close any remaining messages
+          while ((message = producer.next()) != null) {
+            try {
+              message.close();
+            } catch (IOException ioException) {
+              // just log additional exceptions as we are already going to throw
+              log.log(Level.WARNING, "Exception closing stream", ioException);
+            }
+          }
+          throw new RuntimeException(e);
+        }
       }
     }
 
@@ -523,20 +770,27 @@ public void onReady() {}
    * exceptions.
    */
   @VisibleForTesting
-  static class JumpToApplicationThreadServerStreamListener implements ServerStreamListener {
+  static final class JumpToApplicationThreadServerStreamListener implements ServerStreamListener {
     private final Executor callExecutor;
+    private final Executor cancelExecutor;
     private final Context.CancellableContext context;
     private final ServerStream stream;
+    private final Tag tag;
     // Only accessed from callExecutor.
     private ServerStreamListener listener;
 
     public JumpToApplicationThreadServerStreamListener(Executor executor,
-        ServerStream stream, Context.CancellableContext context) {
+        Executor cancelExecutor, ServerStream stream, Context.CancellableContext context, Tag tag) {
       this.callExecutor = executor;
+      this.cancelExecutor = cancelExecutor;
       this.stream = stream;
       this.context = context;
+      this.tag = tag;
     }
 
+    /**
+     * This call MUST be serialized on callExecutor to avoid races.
+     */
     private ServerStreamListener getListener() {
       if (listener == null) {
         throw new IllegalStateException("listener unset");
@@ -554,79 +808,155 @@ void setListener(ServerStreamListener listener) {
     /**
      * Like {@link ServerCall#close(Status, Metadata)}, but thread-safe for internal use.
      */
-    private void internalClose(Status status, Metadata trailers) {
+    private void internalClose(Throwable t) {
       // TODO(ejona86): this is not thread-safe :)
-      stream.close(status, trailers);
+      String description = "Application error processing RPC";
+      stream.close(Status.UNKNOWN.withDescription(description).withCause(t), new Metadata());
     }
 
     @Override
-    public void messageRead(final InputStream message) {
-      callExecutor.execute(new ContextRunnable(context) {
-        @Override
-        public void runInContext() {
-          try {
-            getListener().messageRead(message);
-          } catch (RuntimeException e) {
-            internalClose(Status.fromThrowable(e), new Metadata());
-            throw e;
-          } catch (Error e) {
-            internalClose(Status.fromThrowable(e), new Metadata());
-            throw e;
+    public void messagesAvailable(final MessageProducer producer) {
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.messagesAvailable")) {
+        PerfMark.attachTag(tag);
+        final Link link = PerfMark.linkOut();
+        final class MessagesAvailable extends ContextRunnable {
+
+          MessagesAvailable() {
+            super(context);
+          }
+
+          @Override
+          public void runInContext() {
+            try (TaskCloseable ignore =
+                     PerfMark.traceTask("ServerCallListener(app).messagesAvailable")) {
+              PerfMark.attachTag(tag);
+              PerfMark.linkIn(link);
+              getListener().messagesAvailable(producer);
+            } catch (Throwable t) {
+              internalClose(t);
+              throw t;
+            }
           }
         }
-      });
+
+        callExecutor.execute(new MessagesAvailable());
+      }
     }
 
     @Override
     public void halfClosed() {
-      callExecutor.execute(new ContextRunnable(context) {
-        @Override
-        public void runInContext() {
-          try {
-            getListener().halfClosed();
-          } catch (RuntimeException e) {
-            internalClose(Status.fromThrowable(e), new Metadata());
-            throw e;
-          } catch (Error e) {
-            internalClose(Status.fromThrowable(e), new Metadata());
-            throw e;
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.halfClosed")) {
+        PerfMark.attachTag(tag);
+        final Link link = PerfMark.linkOut();
+        final class HalfClosed extends ContextRunnable {
+          HalfClosed() {
+            super(context);
+          }
+
+          @Override
+          public void runInContext() {
+            try (TaskCloseable ignore = PerfMark.traceTask("ServerCallListener(app).halfClosed")) {
+              PerfMark.attachTag(tag);
+              PerfMark.linkIn(link);
+              getListener().halfClosed();
+            } catch (Throwable t) {
+              internalClose(t);
+              throw t;
+            }
           }
         }
-      });
+
+        callExecutor.execute(new HalfClosed());
+      }
     }
 
     @Override
     public void closed(final Status status) {
-      callExecutor.execute(new ContextRunnable(context) {
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.closed")) {
+        PerfMark.attachTag(tag);
+        closedInternal(status);
+      }
+    }
+
+    private void closedInternal(final Status status) {
+      // For cancellations, promptly inform any users of the context that their work should be
+      // aborted. Otherwise, we can wait until pending work is done.
+      if (!status.isOk()) {
+        // Since status was not OK we know that the call did not complete and got cancelled. To
+        // reflect this on the context we need to close it with a cause exception. Since not every
+        // failed status has an exception we will create one here if needed.
+        Throwable cancelCause = status.getCause();
+        if (cancelCause == null) {
+          cancelCause = InternalStatus.asRuntimeExceptionWithoutStacktrace(
+              Status.CANCELLED.withDescription("RPC cancelled"), null);
+        }
+
+        // The callExecutor might be busy doing user work. To avoid waiting, use an executor that
+        // is not serializing.
+        cancelExecutor.execute(new ContextCloser(context, cancelCause));
+      }
+      final Link link = PerfMark.linkOut();
+
+      final class Closed extends ContextRunnable {
+        Closed() {
+          super(context);
+        }
+
         @Override
         public void runInContext() {
-          try {
+          try (TaskCloseable ignore = PerfMark.traceTask("ServerCallListener(app).closed")) {
+            PerfMark.attachTag(tag);
+            PerfMark.linkIn(link);
             getListener().closed(status);
-          } finally {
-            // Regardless of the status code we cancel the context so that listeners
-            // are aware that the call is done.
-            context.cancel(status.getCause());
           }
         }
-      });
+      }
+
+      callExecutor.execute(new Closed());
     }
 
     @Override
     public void onReady() {
-      callExecutor.execute(new ContextRunnable(context) {
-        @Override
-        public void runInContext() {
-          try {
-            getListener().onReady();
-          } catch (RuntimeException e) {
-            internalClose(Status.fromThrowable(e), new Metadata());
-            throw e;
-          } catch (Error e) {
-            internalClose(Status.fromThrowable(e), new Metadata());
-            throw e;
+      try (TaskCloseable ignore = PerfMark.traceTask("ServerStreamListener.onReady")) {
+        PerfMark.attachTag(tag);
+        final Link link = PerfMark.linkOut();
+
+        final class OnReady extends ContextRunnable {
+          OnReady() {
+            super(context);
+          }
+
+          @Override
+          public void runInContext() {
+            try (TaskCloseable ignore = PerfMark.traceTask("ServerCallListener(app).onReady")) {
+              PerfMark.attachTag(tag);
+              PerfMark.linkIn(link);
+              getListener().onReady();
+            } catch (Throwable t) {
+              internalClose(t);
+              throw t;
+            }
           }
         }
-      });
+
+        callExecutor.execute(new OnReady());
+      }
+    }
+  }
+
+  @VisibleForTesting
+  static final class ContextCloser implements Runnable {
+    private final Context.CancellableContext context;
+    private final Throwable cause;
+
+    ContextCloser(Context.CancellableContext context, Throwable cause) {
+      this.context = context;
+      this.cause = cause;
+    }
+
+    @Override
+    public void run() {
+      context.cancel(cause);
     }
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/ServerImplBuilder.java b/core/src/main/java/io/grpc/internal/ServerImplBuilder.java
new file mode 100644
index 00000000000..f6566e067db
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ServerImplBuilder.java
@@ -0,0 +1,345 @@
+/*
+ * 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.internal;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.errorprone.annotations.DoNotCall;
+import io.grpc.BinaryLog;
+import io.grpc.BindableService;
+import io.grpc.CompressorRegistry;
+import io.grpc.Context;
+import io.grpc.Deadline;
+import io.grpc.DecompressorRegistry;
+import io.grpc.HandlerRegistry;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalConfiguratorRegistry;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCallExecutorSupplier;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerMethodDefinition;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.ServerStreamTracer;
+import io.grpc.ServerTransportFilter;
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * Default builder for {@link io.grpc.Server} instances, for usage in Transport implementations.
+ */
+public final class ServerImplBuilder extends ServerBuilder<ServerImplBuilder> {
+
+  private static final Logger log = Logger.getLogger(ServerImplBuilder.class.getName());
+
+  @DoNotCall("ClientTransportServersBuilder is required, use a constructor")
+  public static ServerBuilder<?> forPort(int port) {
+    throw new UnsupportedOperationException(
+        "ClientTransportServersBuilder is required, use a constructor");
+  }
+
+  // defaults
+  private static final ObjectPool<? extends Executor> DEFAULT_EXECUTOR_POOL =
+      SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR);
+  private static final HandlerRegistry DEFAULT_FALLBACK_REGISTRY = new DefaultFallbackRegistry();
+  private static final DecompressorRegistry DEFAULT_DECOMPRESSOR_REGISTRY =
+      DecompressorRegistry.getDefaultInstance();
+  private static final CompressorRegistry DEFAULT_COMPRESSOR_REGISTRY =
+      CompressorRegistry.getDefaultInstance();
+  private static final long DEFAULT_HANDSHAKE_TIMEOUT_MILLIS = TimeUnit.SECONDS.toMillis(120);
+
+  // mutable state
+  final InternalHandlerRegistry.Builder registryBuilder =
+      new InternalHandlerRegistry.Builder();
+  final List<ServerTransportFilter> transportFilters = new ArrayList<>();
+  final List<ServerInterceptor> interceptors = new ArrayList<>();
+  private final List<ServerStreamTracer.Factory> streamTracerFactories = new ArrayList<>();
+  private final ClientTransportServersBuilder clientTransportServersBuilder;
+  HandlerRegistry fallbackRegistry = DEFAULT_FALLBACK_REGISTRY;
+  ObjectPool<? extends Executor> executorPool = DEFAULT_EXECUTOR_POOL;
+  DecompressorRegistry decompressorRegistry = DEFAULT_DECOMPRESSOR_REGISTRY;
+  CompressorRegistry compressorRegistry = DEFAULT_COMPRESSOR_REGISTRY;
+  long handshakeTimeoutMillis = DEFAULT_HANDSHAKE_TIMEOUT_MILLIS;
+  Deadline.Ticker ticker = Deadline.getSystemTicker();
+  private boolean statsEnabled = true;
+  private boolean recordStartedRpcs = true;
+  private boolean recordFinishedRpcs = true;
+  private boolean recordRealTimeMetrics = false;
+  private boolean tracingEnabled = true;
+  @Nullable BinaryLog binlog;
+  InternalChannelz channelz = InternalChannelz.instance();
+  CallTracer.Factory callTracerFactory = CallTracer.getDefaultFactory();
+  @Nullable
+  ServerCallExecutorSupplier executorSupplier;
+
+  /**
+   * An interface to provide transport specific information for the server. This method
+   * is meant for Transport implementors and should not be used by normal users.
+   */
+  public interface ClientTransportServersBuilder {
+    InternalServer buildClientTransportServers(
+        List<? extends ServerStreamTracer.Factory> streamTracerFactories);
+  }
+
+  /**
+   * Creates a new server builder with given transport servers provider.
+   */
+  public ServerImplBuilder(ClientTransportServersBuilder clientTransportServersBuilder) {
+    this.clientTransportServersBuilder = checkNotNull(clientTransportServersBuilder,
+        "clientTransportServersBuilder");
+    // TODO(dnvindhya): Move configurator to all the individual builders
+    InternalConfiguratorRegistry.configureServerBuilder(this);
+  }
+
+  @Override
+  public ServerImplBuilder directExecutor() {
+    return executor(MoreExecutors.directExecutor());
+  }
+
+  @Override
+  public ServerImplBuilder executor(@Nullable Executor executor) {
+    this.executorPool = executor != null ? new FixedObjectPool<>(executor) : DEFAULT_EXECUTOR_POOL;
+    return this;
+  }
+
+  @Override
+  public ServerImplBuilder callExecutor(ServerCallExecutorSupplier executorSupplier) {
+    this.executorSupplier = checkNotNull(executorSupplier);
+    return this;
+  }
+
+  @Override
+  public ServerImplBuilder addService(ServerServiceDefinition service) {
+    registryBuilder.addService(checkNotNull(service, "service"));
+    return this;
+  }
+
+  @Override
+  public ServerImplBuilder addService(BindableService bindableService) {
+    return addService(checkNotNull(bindableService, "bindableService").bindService());
+  }
+
+  @Override
+  public ServerImplBuilder addTransportFilter(ServerTransportFilter filter) {
+    transportFilters.add(checkNotNull(filter, "filter"));
+    return this;
+  }
+
+  @Override
+  public ServerImplBuilder intercept(ServerInterceptor interceptor) {
+    interceptors.add(checkNotNull(interceptor, "interceptor"));
+    return this;
+  }
+
+  @Override
+  public ServerImplBuilder addStreamTracerFactory(ServerStreamTracer.Factory factory) {
+    streamTracerFactories.add(checkNotNull(factory, "factory"));
+    return this;
+  }
+
+  @Override
+  public ServerImplBuilder fallbackHandlerRegistry(@Nullable HandlerRegistry registry) {
+    this.fallbackRegistry = registry != null ? registry : DEFAULT_FALLBACK_REGISTRY;
+    return this;
+  }
+
+  @Override
+  public ServerImplBuilder decompressorRegistry(@Nullable DecompressorRegistry registry) {
+    this.decompressorRegistry = registry != null ? registry : DEFAULT_DECOMPRESSOR_REGISTRY;
+    return this;
+  }
+
+  @Override
+  public ServerImplBuilder compressorRegistry(@Nullable CompressorRegistry registry) {
+    this.compressorRegistry = registry != null ? registry : DEFAULT_COMPRESSOR_REGISTRY;
+    return this;
+  }
+
+  @Override
+  public ServerImplBuilder handshakeTimeout(long timeout, TimeUnit unit) {
+    checkArgument(timeout > 0, "handshake timeout is %s, but must be positive", timeout);
+    this.handshakeTimeoutMillis = checkNotNull(unit, "unit").toMillis(timeout);
+    return this;
+  }
+
+  @Override
+  public ServerImplBuilder setBinaryLog(@Nullable BinaryLog binaryLog) {
+    this.binlog = binaryLog;
+    return this;
+  }
+
+  /**
+   * Disable or enable stats features.  Enabled by default.
+   */
+  public void setStatsEnabled(boolean value) {
+    this.statsEnabled = value;
+  }
+
+  /**
+   * Disable or enable stats recording for RPC upstarts.  Effective only if {@link
+   * #setStatsEnabled} is set to true.  Enabled by default.
+   */
+  public void setStatsRecordStartedRpcs(boolean value) {
+    recordStartedRpcs = value;
+  }
+
+  /**
+   * Disable or enable stats recording for RPC completions.  Effective only if {@link
+   * #setStatsEnabled} is set to true.  Enabled by default.
+   */
+  public void setStatsRecordFinishedRpcs(boolean value) {
+    recordFinishedRpcs = value;
+  }
+
+  /**
+   * Disable or enable real-time metrics recording.  Effective only if {@link #setStatsEnabled} is
+   * set to true.  Disabled by default.
+   */
+  public void setStatsRecordRealTimeMetrics(boolean value) {
+    recordRealTimeMetrics = value;
+  }
+
+  /**
+   * Disable or enable tracing features.  Enabled by default.
+   */
+  public void setTracingEnabled(boolean value) {
+    tracingEnabled = value;
+  }
+
+  /**
+   * Sets a custom deadline ticker.  This should only be called from InProcessServerBuilder.
+   */
+  public void setDeadlineTicker(Deadline.Ticker ticker) {
+    this.ticker = checkNotNull(ticker, "ticker");
+  }
+
+  @Override
+  public Server build() {
+    return new ServerImpl(this,
+        clientTransportServersBuilder.buildClientTransportServers(getTracerFactories()),
+        Context.ROOT);
+  }
+
+  @VisibleForTesting
+  List<? extends ServerStreamTracer.Factory> getTracerFactories() {
+    boolean disableImplicitCensus = InternalConfiguratorRegistry.wasSetConfiguratorsCalled();
+    if (disableImplicitCensus) {
+      return streamTracerFactories;
+    }
+    ArrayList<ServerStreamTracer.Factory> tracerFactories = new ArrayList<>();
+    if (statsEnabled) {
+      ServerStreamTracer.Factory censusStatsTracerFactory = null;
+      try {
+        Class<?> censusStatsAccessor =
+            Class.forName("io.grpc.census.InternalCensusStatsAccessor");
+        Method getServerStreamTracerFactoryMethod =
+            censusStatsAccessor.getDeclaredMethod(
+                "getServerStreamTracerFactory",
+                boolean.class,
+                boolean.class,
+                boolean.class);
+        censusStatsTracerFactory =
+            (ServerStreamTracer.Factory) getServerStreamTracerFactoryMethod
+                .invoke(
+                    null,
+                    recordStartedRpcs,
+                    recordFinishedRpcs,
+                    recordRealTimeMetrics);
+      } catch (ClassNotFoundException e) {
+        // Replace these separate catch statements with multicatch when Android min-API >= 19
+        log.log(Level.FINE, "Unable to apply census stats", e);
+      } catch (NoSuchMethodException e) {
+        log.log(Level.FINE, "Unable to apply census stats", e);
+      } catch (IllegalAccessException e) {
+        log.log(Level.FINE, "Unable to apply census stats", e);
+      } catch (InvocationTargetException e) {
+        log.log(Level.FINE, "Unable to apply census stats", e);
+      }
+      if (censusStatsTracerFactory != null) {
+        tracerFactories.add(censusStatsTracerFactory);
+      }
+    }
+    if (tracingEnabled) {
+      ServerStreamTracer.Factory tracingStreamTracerFactory = null;
+      try {
+        Class<?> censusTracingAccessor =
+            Class.forName("io.grpc.census.InternalCensusTracingAccessor");
+        Method getServerStreamTracerFactoryMethod =
+            censusTracingAccessor.getDeclaredMethod("getServerStreamTracerFactory");
+        tracingStreamTracerFactory =
+            (ServerStreamTracer.Factory) getServerStreamTracerFactoryMethod.invoke(null);
+      } catch (ClassNotFoundException e) {
+        // Replace these separate catch statements with multicatch when Android min-API >= 19
+        log.log(Level.FINE, "Unable to apply census stats", e);
+      } catch (NoSuchMethodException e) {
+        log.log(Level.FINE, "Unable to apply census stats", e);
+      } catch (IllegalAccessException e) {
+        log.log(Level.FINE, "Unable to apply census stats", e);
+      } catch (InvocationTargetException e) {
+        log.log(Level.FINE, "Unable to apply census stats", e);
+      }
+      if (tracingStreamTracerFactory != null) {
+        tracerFactories.add(tracingStreamTracerFactory);
+      }
+    }
+    tracerFactories.addAll(streamTracerFactories);
+    tracerFactories.trimToSize();
+    return Collections.unmodifiableList(tracerFactories);
+  }
+
+  public InternalChannelz getChannelz() {
+    return channelz;
+  }
+
+  private static final class DefaultFallbackRegistry extends HandlerRegistry {
+    @Override
+    public List<ServerServiceDefinition> getServices() {
+      return Collections.emptyList();
+    }
+
+    @Nullable
+    @Override
+    public ServerMethodDefinition<?, ?> lookupMethod(
+        String methodName, @Nullable String authority) {
+      return null;
+    }
+  }
+
+  /**
+   * Returns the internal ExecutorPool for offloading tasks.
+   */
+  public ObjectPool<? extends Executor> getExecutorPool() {
+    return this.executorPool;
+  }
+
+  @Override
+  public ServerImplBuilder useTransportSecurity(File certChain, File privateKey) {
+    throw new UnsupportedOperationException("TLS not supported in ServerImplBuilder");
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ServerListener.java b/core/src/main/java/io/grpc/internal/ServerListener.java
index 450bf732b35..abe296faaef 100644
--- a/core/src/main/java/io/grpc/internal/ServerListener.java
+++ b/core/src/main/java/io/grpc/internal/ServerListener.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
diff --git a/core/src/main/java/io/grpc/internal/ServerStream.java b/core/src/main/java/io/grpc/internal/ServerStream.java
index 79e5739e0e3..aa5ba10329c 100644
--- a/core/src/main/java/io/grpc/internal/ServerStream.java
+++ b/core/src/main/java/io/grpc/internal/ServerStream.java
@@ -1,39 +1,26 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import io.grpc.Attributes;
+import io.grpc.Decompressor;
 import io.grpc.Metadata;
 import io.grpc.Status;
+import javax.annotation.Nullable;
 
 /**
  * Extension of {@link Stream} to support server-side termination semantics.
@@ -49,13 +36,17 @@ public interface ServerStream extends Stream {
    *
    * @param headers to send to client.
    */
-  void writeHeaders(Metadata headers);
+  void writeHeaders(Metadata headers, boolean flush);
 
   /**
    * Closes the stream for both reading and writing. A status code of
    * {@link io.grpc.Status.Code#OK} implies normal termination of the
    * stream. Any other value implies abnormal termination.
    *
+   * <p>Attempts to read from or write to the stream after closing
+   * should be ignored by implementations, and should not throw
+   * exceptions.
+   *
    * @param status details of the closure
    * @param trailers an additional block of metadata to pass to the client on stream closure.
    */
@@ -68,6 +59,14 @@ public interface ServerStream extends Stream {
    */
   void cancel(Status status);
 
+  /**
+   * Sets the decompressor on the deframer. If the transport does not support compression, this may
+   * do nothing.
+   *
+   * @param decompressor the decompressor to use.
+   */
+  void setDecompressor(Decompressor decompressor);
+
   /**
    * Attributes describing stream.  This is inherited from the transport attributes, and used
    * as the basis of {@link io.grpc.ServerCall#getAttributes}.
@@ -78,8 +77,9 @@ public interface ServerStream extends Stream {
 
   /**
    * Gets the authority this stream is addressed to.
-   * @return the authority string.
+   * @return the authority string. {@code null} if not available.
    */
+  @Nullable
   String getAuthority();
 
   /**
@@ -91,4 +91,20 @@ public interface ServerStream extends Stream {
    * The context for recording stats and traces for this stream.
    */
   StatsTraceContext statsTraceContext();
+
+  /**
+   * The HTTP/2 stream id, or {@code -1} if not supported.
+   */
+  int streamId();
+
+  /**
+   * A hint to the stream that specifies how many bytes must be queued before
+   * {@link #isReady()} will return false. A stream may ignore this property if
+   * unsupported. This may only be set during stream initialization before
+   * any messages are set.
+   *
+   * @param numBytes The number of bytes that must be queued. Must be a
+   *                 positive integer.
+   */
+  void setOnReadyThreshold(int numBytes);
 }
diff --git a/core/src/main/java/io/grpc/internal/ServerStreamListener.java b/core/src/main/java/io/grpc/internal/ServerStreamListener.java
index 5f81bb37006..e55217ab422 100644
--- a/core/src/main/java/io/grpc/internal/ServerStreamListener.java
+++ b/core/src/main/java/io/grpc/internal/ServerStreamListener.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
diff --git a/core/src/main/java/io/grpc/internal/ServerTransport.java b/core/src/main/java/io/grpc/internal/ServerTransport.java
index 62a4ed5fbad..1bda2f2b41e 100644
--- a/core/src/main/java/io/grpc/internal/ServerTransport.java
+++ b/core/src/main/java/io/grpc/internal/ServerTransport.java
@@ -1,40 +1,28 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
 import io.grpc.Status;
+import java.util.concurrent.ScheduledExecutorService;
 
 /** An inbound connection. */
-public interface ServerTransport extends WithLogId {
+public interface ServerTransport extends InternalInstrumented<SocketStats> {
   /**
    * Initiates an orderly shutdown of the transport. Existing streams continue, but new streams will
    * eventually begin failing. New streams "eventually" begin failing because shutdown may need to
@@ -47,4 +35,13 @@ public interface ServerTransport extends WithLogId {
    * should be closed with the provided {@code reason}.
    */
   void shutdownNow(Status reason);
+
+  /**
+   * Returns an executor for scheduling provided by the transport. The service should be configured
+   * to allow cancelled scheduled runnables to be GCed.
+   *
+   * <p>The executor may not be used after the transport terminates. The caller should ensure any
+   * outstanding tasks are cancelled when the transport terminates.
+   */
+  ScheduledExecutorService getScheduledExecutorService();
 }
diff --git a/core/src/main/java/io/grpc/internal/ServerTransportListener.java b/core/src/main/java/io/grpc/internal/ServerTransportListener.java
index 70343189e89..740236e377c 100644
--- a/core/src/main/java/io/grpc/internal/ServerTransportListener.java
+++ b/core/src/main/java/io/grpc/internal/ServerTransportListener.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -39,15 +24,6 @@
  * the transport thread.
  */
 public interface ServerTransportListener {
-
-  /**
-   * Called when the method name for a new stream has been determined, which happens before the
-   * stream is actually created and {@link #streamCreated} is called.
-   *
-   * @return a context object for recording stats and tracing for the new stream.
-   */
-  StatsTraceContext methodDetermined(String methodName, Metadata headers);
-
   /**
    * Called when a new stream was created by the remote client.
    *
diff --git a/core/src/main/java/io/grpc/internal/ServiceConfigState.java b/core/src/main/java/io/grpc/internal/ServiceConfigState.java
new file mode 100644
index 00000000000..d916c2d0e9f
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ServiceConfigState.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2019 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.internal;
+
+import static com.google.common.base.Preconditions.checkState;
+
+import io.grpc.NameResolver.ConfigOrError;
+import javax.annotation.Nullable;
+
+/**
+ * {@link ServiceConfigState} holds the state of the current service config.  It must be mutated
+ * and read from {@link ManagedChannelImpl} constructor or the provided syncContext.
+ */
+final class ServiceConfigState {
+  @Nullable private final ConfigOrError defaultServiceConfig;
+  private final boolean lookUpServiceConfig;
+
+  // mutable state
+  @Nullable private ConfigOrError currentServiceConfigOrError;
+  // Has there been at least one update?
+  private boolean updated;
+
+  /**
+   * Construct new instance.
+   *
+   * @param defaultServiceConfig The initial service config, or {@code null} if absent.
+   * @param lookUpServiceConfig {@code true} if service config updates might occur.
+   */
+  ServiceConfigState(
+      @Nullable ManagedChannelServiceConfig defaultServiceConfig,
+      boolean lookUpServiceConfig) {
+    if (defaultServiceConfig == null) {
+      this.defaultServiceConfig = null;
+    } else {
+      this.defaultServiceConfig = ConfigOrError.fromConfig(defaultServiceConfig);
+    }
+    this.lookUpServiceConfig = lookUpServiceConfig;
+    if (!lookUpServiceConfig) {
+      this.currentServiceConfigOrError = this.defaultServiceConfig;
+    }
+  }
+
+  /**
+   * Returns {@code true} if it RPCs should wait on a service config resolution.  This can return
+   * {@code false} if:
+   *
+   * <ul>
+   *   <li>There is a valid service config from the name resolver
+   *   <li>There is a valid default service config and a service config error from the name
+   *       resolver
+   *   <li>No service config from the name resolver, and no intent to lookup a service config.
+   * </ul>
+   *
+   * <p>In the final case, the default service config may be present or absent, and will be the
+   * current service config.
+   */
+  boolean shouldWaitOnServiceConfig() {
+    return !(updated || !expectUpdates());
+  }
+
+  /**
+   * Gets the current service config or error.
+   *
+   * @throws IllegalStateException if the service config has not yet been updated.
+   */
+  @Nullable
+  ConfigOrError getCurrent() {
+    checkState(!shouldWaitOnServiceConfig(), "still waiting on service config");
+    return currentServiceConfigOrError;
+  }
+
+  void update(@Nullable ConfigOrError coe) {
+    checkState(expectUpdates(), "unexpected service config update");
+    boolean firstUpdate = !updated;
+    updated = true;
+    if (firstUpdate) {
+      if (coe == null) {
+        currentServiceConfigOrError = defaultServiceConfig;
+      } else if (coe.getError() != null) {
+        if (defaultServiceConfig != null) {
+          currentServiceConfigOrError = defaultServiceConfig;
+        } else {
+          currentServiceConfigOrError = coe;
+        }
+      } else {
+        assert coe.getConfig() != null;
+        currentServiceConfigOrError = coe;
+      }
+    } else {
+      if (coe == null) {
+        if (defaultServiceConfig != null) {
+          currentServiceConfigOrError = defaultServiceConfig;
+        } else {
+          currentServiceConfigOrError = null;
+        }
+      } else if (coe.getError() != null) {
+        if (currentServiceConfigOrError != null && currentServiceConfigOrError.getError() != null) {
+          currentServiceConfigOrError = coe;
+        } else {
+          // discard
+        }
+      } else {
+        assert coe.getConfig() != null;
+        currentServiceConfigOrError = coe;
+      }
+    }
+  }
+
+  boolean expectUpdates() {
+    return lookUpServiceConfig;
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ServiceConfigUtil.java b/core/src/main/java/io/grpc/internal/ServiceConfigUtil.java
new file mode 100644
index 00000000000..34d44f7f549
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ServiceConfigUtil.java
@@ -0,0 +1,461 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.base.Verify.verify;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import com.google.common.base.VerifyException;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.RetriableStream.Throttle;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * Helper utility to work with service configs.
+ *
+ * <p>This class contains helper methods to parse service config JSON values into Java types.
+ */
+public final class ServiceConfigUtil {
+
+  private ServiceConfigUtil() {}
+
+  /**
+   * Fetches the health-checked service config from service config. {@code null} if can't find one.
+   */
+  @Nullable
+  public static Map<String, ?> getHealthCheckedService(@Nullable  Map<String, ?> serviceConfig) {
+    if (serviceConfig == null) {
+      return null;
+    }
+
+    /* schema as follows
+    {
+      "healthCheckConfig": {
+        // Service name to use in the health-checking request.
+        "serviceName": string
+      }
+    }
+    */
+    return JsonUtil.getObject(serviceConfig, "healthCheckConfig");
+  }
+
+  /**
+   * Fetches the health-checked service name from health-checked service config. {@code null} if
+   * can't find one.
+   */
+  @Nullable
+  public static String getHealthCheckedServiceName(
+      @Nullable Map<String, ?> healthCheckedServiceConfig) {
+    if (healthCheckedServiceConfig == null) {
+      return null;
+    }
+    return JsonUtil.getString(healthCheckedServiceConfig, "serviceName");
+  }
+
+  @Nullable
+  static Throttle getThrottlePolicy(@Nullable Map<String, ?> serviceConfig) {
+    if (serviceConfig == null) {
+      return null;
+    }
+
+    /* schema as follows
+    {
+      "retryThrottling": {
+        // The number of tokens starts at maxTokens. The token_count will always be
+        // between 0 and maxTokens.
+        //
+        // This field is required and must be greater than zero.
+        "maxTokens": number,
+
+        // The amount of tokens to add on each successful RPC. Typically this will
+        // be some number between 0 and 1, e.g., 0.1.
+        //
+        // This field is required and must be greater than zero. Up to 3 decimal
+        // places are supported.
+        "tokenRatio": number
+      }
+    }
+    */
+
+    Map<String, ?> throttling = JsonUtil.getObject(serviceConfig, "retryThrottling");
+    if (throttling == null) {
+      return null;
+    }
+
+    // TODO(dapengzhang0): check if this is null.
+    float maxTokens = JsonUtil.getNumberAsDouble(throttling, "maxTokens").floatValue();
+    float tokenRatio = JsonUtil.getNumberAsDouble(throttling, "tokenRatio").floatValue();
+    checkState(maxTokens > 0f, "maxToken should be greater than zero");
+    checkState(tokenRatio > 0f, "tokenRatio should be greater than zero");
+    return new Throttle(maxTokens, tokenRatio);
+  }
+
+  @Nullable
+  static Integer getMaxAttemptsFromRetryPolicy(Map<String, ?> retryPolicy) {
+    return JsonUtil.getNumberAsInteger(retryPolicy, "maxAttempts");
+  }
+
+  @Nullable
+  static Long getInitialBackoffNanosFromRetryPolicy(Map<String, ?> retryPolicy) {
+    return JsonUtil.getStringAsDuration(retryPolicy, "initialBackoff");
+  }
+
+  @Nullable
+  static Long getMaxBackoffNanosFromRetryPolicy(Map<String, ?> retryPolicy) {
+    return JsonUtil.getStringAsDuration(retryPolicy, "maxBackoff");
+  }
+
+  @Nullable
+  static Double getBackoffMultiplierFromRetryPolicy(Map<String, ?> retryPolicy) {
+    return JsonUtil.getNumberAsDouble(retryPolicy, "backoffMultiplier");
+  }
+
+  @Nullable
+  static Long getPerAttemptRecvTimeoutNanosFromRetryPolicy(Map<String, ?> retryPolicy) {
+    return JsonUtil.getStringAsDuration(retryPolicy, "perAttemptRecvTimeout");
+  }
+
+  private static Set<Status.Code> getListOfStatusCodesAsSet(Map<String, ?> obj, String key) {
+    List<?> statuses = JsonUtil.getList(obj, key);
+    if (statuses == null) {
+      return null;
+    }
+    return getStatusCodesFromList(statuses);
+  }
+
+  private static Set<Status.Code> getStatusCodesFromList(List<?> statuses) {
+    EnumSet<Status.Code> codes = EnumSet.noneOf(Status.Code.class);
+    for (Object status : statuses) {
+      Status.Code code;
+      if (status instanceof Double) {
+        Double statusD = (Double) status;
+        int codeValue = statusD.intValue();
+        verify((double) codeValue == statusD, "Status code %s is not integral", status);
+        code = Status.fromCodeValue(codeValue).getCode();
+        verify(code.value() == statusD.intValue(), "Status code %s is not valid", status);
+      } else if (status instanceof String) {
+        try {
+          code = Status.Code.valueOf((String) status);
+        } catch (IllegalArgumentException iae) {
+          throw new VerifyException("Status code " + status + " is not valid", iae);
+        }
+      } else {
+        throw new VerifyException(
+            "Can not convert status code " + status + " to Status.Code, because its type is "
+                + status.getClass());
+      }
+      codes.add(code);
+    }
+    return Collections.unmodifiableSet(codes);
+  }
+
+  static Set<Status.Code> getRetryableStatusCodesFromRetryPolicy(Map<String, ?> retryPolicy) {
+    String retryableStatusCodesKey = "retryableStatusCodes";
+    Set<Status.Code> codes = getListOfStatusCodesAsSet(retryPolicy, retryableStatusCodesKey);
+    verify(codes != null, "%s is required in retry policy", retryableStatusCodesKey);
+    verify(!codes.contains(Status.Code.OK), "%s must not contain OK", retryableStatusCodesKey);
+    return codes;
+  }
+
+  @Nullable
+  static Integer getMaxAttemptsFromHedgingPolicy(Map<String, ?> hedgingPolicy) {
+    return JsonUtil.getNumberAsInteger(hedgingPolicy, "maxAttempts");
+  }
+
+  @Nullable
+  static Long getHedgingDelayNanosFromHedgingPolicy(Map<String, ?> hedgingPolicy) {
+    return JsonUtil.getStringAsDuration(hedgingPolicy, "hedgingDelay");
+  }
+
+  static Set<Status.Code> getNonFatalStatusCodesFromHedgingPolicy(Map<String, ?> hedgingPolicy) {
+    String nonFatalStatusCodesKey = "nonFatalStatusCodes";
+    Set<Status.Code> codes = getListOfStatusCodesAsSet(hedgingPolicy, nonFatalStatusCodesKey);
+    if (codes == null) {
+      return Collections.unmodifiableSet(EnumSet.noneOf(Status.Code.class));
+    }
+    verify(!codes.contains(Status.Code.OK), "%s must not contain OK", nonFatalStatusCodesKey);
+    return codes;
+  }
+
+  @Nullable
+  static String getServiceFromName(Map<String, ?> name) {
+    return JsonUtil.getString(name, "service");
+  }
+
+  @Nullable
+  static String getMethodFromName(Map<String, ?> name) {
+    return JsonUtil.getString(name, "method");
+  }
+
+  @Nullable
+  static Map<String, ?> getRetryPolicyFromMethodConfig(Map<String, ?> methodConfig) {
+    return JsonUtil.getObject(methodConfig, "retryPolicy");
+  }
+
+  @Nullable
+  static Map<String, ?> getHedgingPolicyFromMethodConfig(Map<String, ?> methodConfig) {
+    return JsonUtil.getObject(methodConfig, "hedgingPolicy");
+  }
+
+  @Nullable
+  static List<Map<String, ?>> getNameListFromMethodConfig(
+      Map<String, ?> methodConfig) {
+    return JsonUtil.getListOfObjects(methodConfig, "name");
+  }
+
+  /**
+   * Returns the number of nanoseconds of timeout for the given method config.
+   *
+   * @return duration nanoseconds, or {@code null} if it isn't present.
+   */
+  @Nullable
+  static Long getTimeoutFromMethodConfig(Map<String, ?> methodConfig) {
+    return JsonUtil.getStringAsDuration(methodConfig, "timeout");
+  }
+
+  @Nullable
+  static Boolean getWaitForReadyFromMethodConfig(Map<String, ?> methodConfig) {
+    return JsonUtil.getBoolean(methodConfig, "waitForReady");
+  }
+
+  @Nullable
+  static Integer getMaxRequestMessageBytesFromMethodConfig(Map<String, ?> methodConfig) {
+    return JsonUtil.getNumberAsInteger(methodConfig, "maxRequestMessageBytes");
+  }
+
+  @Nullable
+  static Integer getMaxResponseMessageBytesFromMethodConfig(Map<String, ?> methodConfig) {
+    return JsonUtil.getNumberAsInteger(methodConfig, "maxResponseMessageBytes");
+  }
+
+  @Nullable
+  static List<Map<String, ?>> getMethodConfigFromServiceConfig(
+      Map<String, ?> serviceConfig) {
+    return JsonUtil.getListOfObjects(serviceConfig, "methodConfig");
+  }
+
+  /**
+   * Extracts load balancing configs from a service config.
+   */
+  @VisibleForTesting
+  public static List<Map<String, ?>> getLoadBalancingConfigsFromServiceConfig(
+      Map<String, ?> serviceConfig) {
+    /* schema as follows
+    {
+      "loadBalancingConfig": [
+        {"xds" :
+          {
+            "childPolicy": [...],
+            "fallbackPolicy": [...],
+          }
+        },
+        {"round_robin": {}}
+      ],
+      "loadBalancingPolicy": "ROUND_ROBIN"  // The deprecated policy key
+    }
+    */
+    List<Map<String, ?>> lbConfigs = new ArrayList<>();
+    String loadBalancingConfigKey = "loadBalancingConfig";
+    if (serviceConfig.containsKey(loadBalancingConfigKey)) {
+      lbConfigs.addAll(JsonUtil.getListOfObjects(
+          serviceConfig, loadBalancingConfigKey));
+    }
+    if (lbConfigs.isEmpty()) {
+      // No LoadBalancingConfig found.  Fall back to the deprecated LoadBalancingPolicy
+      String policy = JsonUtil.getString(serviceConfig, "loadBalancingPolicy");
+      if (policy != null) {
+        // Convert the policy to a config, so that the caller can handle them in the same way.
+        policy = policy.toLowerCase(Locale.ROOT);
+        Map<String, ?> fakeConfig = Collections.singletonMap(policy, Collections.emptyMap());
+        lbConfigs.add(fakeConfig);
+      }
+    }
+    return Collections.unmodifiableList(lbConfigs);
+  }
+
+  /**
+   * Unwrap a LoadBalancingConfig JSON object into a {@link LbConfig}.  The input is a JSON object
+   * (map) with exactly one entry, where the key is the policy name and the value is a config object
+   * for that policy.
+   */
+  public static LbConfig unwrapLoadBalancingConfig(Map<String, ?> lbConfig) {
+    if (lbConfig.size() != 1) {
+      throw new RuntimeException(
+          "There are " + lbConfig.size() + " fields in a LoadBalancingConfig object. Exactly one"
+          + " is expected. Config=" + lbConfig);
+    }
+    String key = lbConfig.entrySet().iterator().next().getKey();
+    return new LbConfig(key, JsonUtil.getObject(lbConfig, key));
+  }
+
+  /**
+   * Given a JSON list of LoadBalancingConfigs, and convert it into a list of LbConfig.
+   */
+  public static List<LbConfig> unwrapLoadBalancingConfigList(List<Map<String, ?>> list) {
+    if (list == null) {
+      return null;
+    }
+    ArrayList<LbConfig> result = new ArrayList<>();
+    for (Map<String, ?> rawChildPolicy : list) {
+      result.add(unwrapLoadBalancingConfig(rawChildPolicy));
+    }
+    return Collections.unmodifiableList(result);
+  }
+
+  /**
+   * Parses and selects a load balancing policy from a non-empty list of raw configs. If selection
+   * is successful, the returned ConfigOrError object will include a {@link
+   * ServiceConfigUtil.PolicySelection} as its config value.
+   */
+  public static ConfigOrError selectLbPolicyFromList(
+      List<LbConfig> lbConfigs, LoadBalancerRegistry lbRegistry) {
+    List<String> policiesTried = new ArrayList<>();
+    for (LbConfig lbConfig : lbConfigs) {
+      String policy = lbConfig.getPolicyName();
+      LoadBalancerProvider provider = lbRegistry.getProvider(policy);
+      if (provider == null) {
+        policiesTried.add(policy);
+      } else {
+        if (!policiesTried.isEmpty()) {
+          Logger.getLogger(ServiceConfigUtil.class.getName()).log(
+              Level.FINEST,
+              "{0} specified by Service Config are not available", policiesTried);
+        }
+        ConfigOrError parsedLbPolicyConfig =
+            provider.parseLoadBalancingPolicyConfig(lbConfig.getRawConfigValue());
+        if (parsedLbPolicyConfig.getError() != null) {
+          return parsedLbPolicyConfig;
+        }
+        return ConfigOrError.fromConfig(
+            new PolicySelection(provider, parsedLbPolicyConfig.getConfig()));
+      }
+    }
+    return ConfigOrError.fromError(
+        Status.UNKNOWN.withDescription(
+            "None of " + policiesTried + " specified by Service Config are available."));
+  }
+
+  /**
+   * A LoadBalancingConfig that includes the policy name (the key) and its raw config value (parsed
+   * JSON).
+   */
+  public static final class LbConfig {
+    private final String policyName;
+    private final Map<String, ?> rawConfigValue;
+
+    public LbConfig(String policyName, Map<String, ?> rawConfigValue) {
+      this.policyName = checkNotNull(policyName, "policyName");
+      this.rawConfigValue = checkNotNull(rawConfigValue, "rawConfigValue");
+    }
+
+    public String getPolicyName() {
+      return policyName;
+    }
+
+    public Map<String, ?> getRawConfigValue() {
+      return rawConfigValue;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (o instanceof LbConfig) {
+        LbConfig other = (LbConfig) o;
+        return policyName.equals(other.policyName)
+            && rawConfigValue.equals(other.rawConfigValue);
+      }
+      return false;
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(policyName, rawConfigValue);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("policyName", policyName)
+          .add("rawConfigValue", rawConfigValue)
+          .toString();
+    }
+  }
+
+  public static final class PolicySelection {
+    final LoadBalancerProvider provider;
+    @Nullable
+    final Object config;
+
+    /** Constructs a PolicySelection with selected LB provider and the deeply parsed LB config. */
+    public PolicySelection(
+        LoadBalancerProvider provider,
+        @Nullable Object config) {
+      this.provider = checkNotNull(provider, "provider");
+      this.config = config;
+    }
+
+    public LoadBalancerProvider getProvider() {
+      return provider;
+    }
+
+    @Nullable
+    public Object getConfig() {
+      return config;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      PolicySelection that = (PolicySelection) o;
+      return Objects.equal(provider, that.provider)
+          && Objects.equal(config, that.config);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(provider, config);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("provider", provider)
+          .add("config", config)
+          .toString();
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/SharedResourceHolder.java b/core/src/main/java/io/grpc/internal/SharedResourceHolder.java
index d8da7702738..1dfa1f90718 100644
--- a/core/src/main/java/io/grpc/internal/SharedResourceHolder.java
+++ b/core/src/main/java/io/grpc/internal/SharedResourceHolder.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -68,7 +53,7 @@ public ScheduledExecutorService createScheduledExecutor() {
       });
 
   private final IdentityHashMap<Resource<?>, Instance> instances =
-      new IdentityHashMap<Resource<?>, Instance>();
+      new IdentityHashMap<>();
 
   private final ScheduledExecutorFactory destroyerFactory;
 
@@ -139,35 +124,28 @@ synchronized <T> T releaseInternal(final Resource<T> resource, final T instance)
     Preconditions.checkState(cached.refcount > 0, "Refcount has already reached zero");
     cached.refcount--;
     if (cached.refcount == 0) {
-      if (GrpcUtil.IS_RESTRICTED_APPENGINE) {
-        // AppEngine must immediately release shared resources, particularly executors
-        // which could retain request-scoped threads which become zombies after the request
-        // completes.
-        resource.close(instance);
-        instances.remove(resource);
-      } else {
-        Preconditions.checkState(cached.destroyTask == null, "Destroy task already scheduled");
-        // Schedule a delayed task to destroy the resource.
-        if (destroyer == null) {
-          destroyer = destroyerFactory.createScheduledExecutor();
-        }
-        cached.destroyTask = destroyer.schedule(new LogExceptionRunnable(new Runnable() {
-          @Override
-          public void run() {
-            synchronized (SharedResourceHolder.this) {
-              // Refcount may have gone up since the task was scheduled. Re-check it.
-              if (cached.refcount == 0) {
-                resource.close(instance);
-                instances.remove(resource);
-                if (instances.isEmpty()) {
-                  destroyer.shutdown();
-                  destroyer = null;
-                }
-              }
+      Preconditions.checkState(cached.destroyTask == null, "Destroy task already scheduled");
+      // Schedule a delayed task to destroy the resource.
+      if (destroyer == null) {
+        destroyer = destroyerFactory.createScheduledExecutor();
+      }
+      cached.destroyTask = destroyer.schedule(new LogExceptionRunnable(new Runnable() {
+        @Override
+        public void run() {
+          synchronized (SharedResourceHolder.this) {
+            // Refcount may have gone up since the task was scheduled. Re-check it.
+            if (cached.refcount != 0) {
+              return;
+            }
+            instances.remove(resource);
+            if (instances.isEmpty()) {
+              destroyer.shutdown();
+              destroyer = null;
             }
           }
-        }), DESTROY_DELAY_SECONDS, TimeUnit.SECONDS);
-      }
+          resource.close(instance);
+        }
+      }), DESTROY_DELAY_SECONDS, TimeUnit.SECONDS);
     }
     // Always returning null
     return null;
diff --git a/core/src/main/java/io/grpc/internal/SharedResourcePool.java b/core/src/main/java/io/grpc/internal/SharedResourcePool.java
index fbcef4343a1..b9b0e2cb3bd 100644
--- a/core/src/main/java/io/grpc/internal/SharedResourcePool.java
+++ b/core/src/main/java/io/grpc/internal/SharedResourcePool.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -42,7 +27,7 @@ private SharedResourcePool(SharedResourceHolder.Resource<T> resource) {
   }
 
   public static <T> SharedResourcePool<T> forResource(SharedResourceHolder.Resource<T> resource) {
-    return new SharedResourcePool<T>(resource);
+    return new SharedResourcePool<>(resource);
   }
 
   @Override
diff --git a/core/src/main/java/io/grpc/internal/SimpleDisconnectError.java b/core/src/main/java/io/grpc/internal/SimpleDisconnectError.java
new file mode 100644
index 00000000000..addbfbe10a3
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/SimpleDisconnectError.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2025 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.internal;
+
+import javax.annotation.concurrent.Immutable;
+
+/**
+ * Represents a fixed, static reason for disconnection.
+ */
+@Immutable
+public enum SimpleDisconnectError implements DisconnectError {
+  /**
+   * The subchannel was shut down for various reasons like parent channel shutdown,
+   * idleness, or load balancing policy changes.
+   */
+  SUBCHANNEL_SHUTDOWN("subchannel shutdown"),
+
+  /**
+   * Connection was reset (e.g., ECONNRESET, WSAECONNERESET).
+   */
+  CONNECTION_RESET("connection reset"),
+
+  /**
+   * Connection timed out (e.g., ETIMEDOUT, WSAETIMEDOUT), including closures
+   * from gRPC keepalives.
+   */
+  CONNECTION_TIMED_OUT("connection timed out"),
+
+  /**
+   * Connection was aborted (e.g., ECONNABORTED, WSAECONNABORTED).
+   */
+  CONNECTION_ABORTED("connection aborted"),
+
+  /**
+   * Any socket error not covered by other specific disconnect errors.
+   */
+  SOCKET_ERROR("socket error"),
+
+  /**
+   * A catch-all for any other unclassified reason.
+   */
+  UNKNOWN("unknown");
+
+  private final String errorTag;
+
+  SimpleDisconnectError(String errorTag) {
+    this.errorTag = errorTag;
+  }
+
+  @Override
+  public String toErrorString() {
+    return this.errorTag;
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/SingleTransportChannel.java b/core/src/main/java/io/grpc/internal/SingleTransportChannel.java
deleted file mode 100644
index 9585d615628..00000000000
--- a/core/src/main/java/io/grpc/internal/SingleTransportChannel.java
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import com.google.common.base.Preconditions;
-import com.google.common.base.Stopwatch;
-import com.google.common.base.Supplier;
-import com.google.instrumentation.stats.StatsContextFactory;
-import io.grpc.CallOptions;
-import io.grpc.Channel;
-import io.grpc.ClientCall;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.internal.ClientCallImpl.ClientTransportProvider;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ScheduledExecutorService;
-
-/**
- * A {@link Channel} that wraps a {@link ClientTransport}.
- */
-final class SingleTransportChannel extends Channel {
-
-  private final StatsContextFactory statsFactory;
-  private final ClientTransport transport;
-  private final Executor executor;
-  private final String authority;
-  private final ScheduledExecutorService deadlineCancellationExecutor;
-  private final Supplier<Stopwatch> stopwatchSupplier;
-
-  private final ClientTransportProvider transportProvider = new ClientTransportProvider() {
-    @Override
-    public ClientTransport get(CallOptions callOptions, Metadata headers) {
-      return transport;
-    }
-  };
-
-  /**
-   * Creates a new channel with a connected transport.
-   */
-  public SingleTransportChannel(StatsContextFactory statsFactory, ClientTransport transport,
-      Executor executor, ScheduledExecutorService deadlineCancellationExecutor, String authority,
-      Supplier<Stopwatch> stopwatchSupplier) {
-    this.statsFactory = Preconditions.checkNotNull(statsFactory, "statsFactory");
-    this.transport = Preconditions.checkNotNull(transport, "transport");
-    this.executor = Preconditions.checkNotNull(executor, "executor");
-    this.deadlineCancellationExecutor = Preconditions.checkNotNull(
-        deadlineCancellationExecutor, "deadlineCancellationExecutor");
-    this.authority = Preconditions.checkNotNull(authority, "authority");
-    this.stopwatchSupplier = Preconditions.checkNotNull(stopwatchSupplier, "stopwatchSupplier");
-  }
-
-  @Override
-  public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
-      MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
-    StatsTraceContext statsTraceCtx = StatsTraceContext.newClientContext(
-        methodDescriptor.getFullMethodName(), statsFactory, stopwatchSupplier);
-    return new ClientCallImpl<RequestT, ResponseT>(methodDescriptor,
-        new SerializingExecutor(executor), callOptions, statsTraceCtx, transportProvider,
-        deadlineCancellationExecutor);
-  }
-
-  @Override
-  public String authority() {
-    return authority;
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/SpiffeUtil.java b/core/src/main/java/io/grpc/internal/SpiffeUtil.java
new file mode 100644
index 00000000000..9eafc9950e2
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/SpiffeUtil.java
@@ -0,0 +1,312 @@
+/*
+ * Copyright 2024 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.internal;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.io.Files;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.security.cert.CertificateParsingException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+/**
+ * Provides utilities to manage SPIFFE bundles, extract SPIFFE IDs from X.509 certificate chains,
+ * and parse SPIFFE IDs.
+ * @see <a href="https://github.com/spiffe/spiffe/blob/master/standards/SPIFFE-ID.md">Standard</a>
+ */
+public final class SpiffeUtil {
+
+  private static final Integer URI_SAN_TYPE = 6;
+  private static final String USE_PARAMETER_VALUE = "x509-svid";
+  private static final ImmutableSet<String> KTY_PARAMETER_VALUES = ImmutableSet.of("RSA", "EC");
+  private static final String CERTIFICATE_PREFIX = "-----BEGIN CERTIFICATE-----\n";
+  private static final String CERTIFICATE_SUFFIX = "-----END CERTIFICATE-----";
+  private static final String PREFIX = "spiffe://";
+
+  private SpiffeUtil() {}
+
+  /**
+   * Parses a URI string, applies validation rules described in SPIFFE standard, and, in case of
+   * success, returns parsed TrustDomain and Path.
+   *
+   * @param uri a String representing a SPIFFE ID
+   */
+  public static SpiffeId parse(String uri) {
+    doInitialUriValidation(uri);
+    checkArgument(uri.toLowerCase(Locale.US).startsWith(PREFIX), "Spiffe Id must start with "
+        + PREFIX);
+    String domainAndPath = uri.substring(PREFIX.length());
+    String trustDomain;
+    String path;
+    if (!domainAndPath.contains("/")) {
+      trustDomain = domainAndPath;
+      path =  "";
+    } else {
+      String[] parts = domainAndPath.split("/", 2);
+      trustDomain = parts[0];
+      path = parts[1];
+      checkArgument(!path.isEmpty(), "Path must not include a trailing '/'");
+    }
+    validateTrustDomain(trustDomain);
+    validatePath(path);
+    if (!path.isEmpty()) {
+      path = "/" + path;
+    }
+    return new SpiffeId(trustDomain, path);
+  }
+
+  private static void doInitialUriValidation(String uri) {
+    checkArgument(checkNotNull(uri, "uri").length() > 0, "Spiffe Id can't be empty");
+    checkArgument(uri.length() <= 2048, "Spiffe Id maximum length is 2048 characters");
+    checkArgument(!uri.contains("#"), "Spiffe Id must not contain query fragments");
+    checkArgument(!uri.contains("?"), "Spiffe Id must not contain query parameters");
+  }
+
+  private static void validateTrustDomain(String trustDomain) {
+    checkArgument(!trustDomain.isEmpty(), "Trust Domain can't be empty");
+    checkArgument(trustDomain.length() < 256, "Trust Domain maximum length is 255 characters");
+    checkArgument(trustDomain.matches("[a-z0-9._-]+"),
+        "Trust Domain must contain only letters, numbers, dots, dashes, and underscores"
+            + " ([a-z0-9.-_])");
+  }
+
+  private static void validatePath(String path) {
+    if (path.isEmpty()) {
+      return;
+    }
+    checkArgument(!path.endsWith("/"), "Path must not include a trailing '/'");
+    for (String segment : Splitter.on("/").split(path)) {
+      validatePathSegment(segment);
+    }
+  }
+
+  private static void validatePathSegment(String pathSegment) {
+    checkArgument(!pathSegment.isEmpty(), "Individual path segments must not be empty");
+    checkArgument(!(pathSegment.equals(".") || pathSegment.equals("..")),
+        "Individual path segments must not be relative path modifiers (i.e. ., ..)");
+    checkArgument(pathSegment.matches("[a-zA-Z0-9._-]+"),
+        "Individual path segments must contain only letters, numbers, dots, dashes, and underscores"
+            + " ([a-zA-Z0-9.-_])");
+  }
+
+  /**
+   * Returns the SPIFFE ID from the leaf certificate, if present.
+   *
+   * @param certChain certificate chain to extract SPIFFE ID from
+   */
+  public static Optional<SpiffeId> extractSpiffeId(X509Certificate[] certChain)
+      throws CertificateParsingException {
+    checkArgument(checkNotNull(certChain, "certChain").length > 0, "certChain can't be empty");
+    Collection<List<?>> subjectAltNames = certChain[0].getSubjectAlternativeNames();
+    if (subjectAltNames == null) {
+      return Optional.absent();
+    }
+    String uri = null;
+    // Search for the unique URI SAN.
+    for (List<?> altName : subjectAltNames) {
+      if (altName.size() < 2 ) {
+        continue;
+      }
+      if (URI_SAN_TYPE.equals(altName.get(0))) {
+        if (uri != null) {
+          throw new IllegalArgumentException("Multiple URI SAN values found in the leaf cert.");
+        }
+        uri = (String) altName.get(1);
+      }
+    }
+    if (uri == null) {
+      return Optional.absent();
+    }
+    return Optional.of(parse(uri));
+  }
+
+  /**
+   * Loads a SPIFFE trust bundle from a file, parsing it from the JSON format.
+   * In case of success, returns {@link SpiffeBundle}.
+   * If any element of the JSON content is invalid or unsupported, an
+   * {@link IllegalArgumentException} is thrown and the entire Bundle is considered invalid.
+   *
+   * @param trustBundleFile the file path to the JSON file containing the trust bundle
+   * @see <a href="https://github.com/spiffe/spiffe/blob/main/standards/SPIFFE_Trust_Domain_and_Bundle.md">JSON format</a>
+   * @see <a href="https://github.com/spiffe/spiffe/blob/main/standards/X509-SVID.md#61-publishing-spiffe-bundle-elements">JWK entry format</a>
+   * @see <a href="https://datatracker.ietf.org/doc/html/rfc7517#appendix-B">x5c (certificate) parameter</a>
+   */
+  public static SpiffeBundle loadTrustBundleFromFile(String trustBundleFile) throws IOException {
+    Map<String, ?> trustDomainsNode = readTrustDomainsFromFile(trustBundleFile);
+    Map<String, List<X509Certificate>> trustBundleMap = new HashMap<>();
+    Map<String, Long> sequenceNumbers = new HashMap<>();
+    for (String trustDomainName : trustDomainsNode.keySet()) {
+      Map<String, ?> domainNode = JsonUtil.getObject(trustDomainsNode, trustDomainName);
+      if (domainNode.size() == 0) {
+        trustBundleMap.put(trustDomainName, Collections.emptyList());
+        continue;
+      }
+      Long sequenceNumber = JsonUtil.getNumberAsLong(domainNode, "spiffe_sequence");
+      sequenceNumbers.put(trustDomainName, sequenceNumber == null ? -1L : sequenceNumber);
+      List<Map<String, ?>> keysNode = JsonUtil.getListOfObjects(domainNode, "keys");
+      if (keysNode == null || keysNode.size() == 0) {
+        trustBundleMap.put(trustDomainName, Collections.emptyList());
+        continue;
+      }
+      trustBundleMap.put(trustDomainName, extractCert(keysNode, trustDomainName));
+    }
+    return new SpiffeBundle(sequenceNumbers, trustBundleMap);
+  }
+
+  private static Map<String, ?> readTrustDomainsFromFile(String filePath) throws IOException {
+    File file = new File(checkNotNull(filePath, "trustBundleFile"));
+    String json = new String(Files.toByteArray(file), StandardCharsets.UTF_8);
+    Object jsonObject = JsonParser.parse(json);
+    if (!(jsonObject instanceof Map)) {
+      throw new IllegalArgumentException(
+          "SPIFFE Trust Bundle should be a JSON object. Found: "
+              + (jsonObject == null ? null : jsonObject.getClass()));
+    }
+    @SuppressWarnings("unchecked")
+    Map<String, ?> root = (Map<String, ?>)jsonObject;
+    Map<String, ?> trustDomainsNode = JsonUtil.getObject(root, "trust_domains");
+    checkNotNull(trustDomainsNode, "Mandatory trust_domains element is missing");
+    checkArgument(trustDomainsNode.size() > 0, "Mandatory trust_domains element is missing");
+    return trustDomainsNode;
+  }
+
+  private static void checkJwkEntry(Map<String, ?> jwkNode, String trustDomainName) {
+    String kty = JsonUtil.getString(jwkNode, "kty");
+    if (kty == null || !KTY_PARAMETER_VALUES.contains(kty)) {
+      throw new IllegalArgumentException(
+          String.format(
+              "'kty' parameter must be one of %s but '%s' "
+                  + "found. Certificate loading for trust domain '%s' failed.",
+              KTY_PARAMETER_VALUES, kty, trustDomainName));
+    }
+    if (jwkNode.containsKey("kid")) {
+      throw new IllegalArgumentException(String.format("'kid' parameter must not be set. "
+              + "Certificate loading for trust domain '%s' failed.", trustDomainName));
+    }
+    String use = JsonUtil.getString(jwkNode, "use");
+    if (use == null || !use.equals(USE_PARAMETER_VALUE)) {
+      throw new IllegalArgumentException(String.format("'use' parameter must be '%s' but '%s' "
+              + "found. Certificate loading for trust domain '%s' failed.", USE_PARAMETER_VALUE,
+          use, trustDomainName));
+    }
+  }
+
+  private static List<X509Certificate> extractCert(List<Map<String, ?>> keysNode,
+      String trustDomainName) {
+    List<X509Certificate> result = new ArrayList<>();
+    for (Map<String, ?> keyNode : keysNode) {
+      checkJwkEntry(keyNode, trustDomainName);
+      List<String> rawCerts = JsonUtil.getListOfStrings(keyNode, "x5c");
+      if (rawCerts == null) {
+        break;
+      }
+      if (rawCerts.size() != 1) {
+        throw new IllegalArgumentException(String.format("Exactly 1 certificate is expected, but "
+            + "%s found. Certificate loading for trust domain '%s' failed.", rawCerts.size(),
+            trustDomainName));
+      }
+      InputStream stream = new ByteArrayInputStream((CERTIFICATE_PREFIX + rawCerts.get(0) + "\n"
+          + CERTIFICATE_SUFFIX)
+          .getBytes(StandardCharsets.UTF_8));
+      try {
+        Collection<? extends Certificate> certs = CertificateFactory.getInstance("X509")
+            .generateCertificates(stream);
+        X509Certificate[] certsArray = certs.toArray(new X509Certificate[0]);
+        assert certsArray.length == 1;
+        result.add(certsArray[0]);
+      } catch (CertificateException e) {
+        throw new IllegalArgumentException(String.format("Certificate can't be parsed. Certificate "
+            + "loading for trust domain '%s' failed.", trustDomainName), e);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Represents a SPIFFE ID as defined in the SPIFFE standard.
+   * @see <a href="https://github.com/spiffe/spiffe/blob/master/standards/SPIFFE-ID.md">Standard</a>
+   */
+  public static class SpiffeId {
+
+    private final String trustDomain;
+    private final String path;
+
+    private SpiffeId(String trustDomain, String path) {
+      this.trustDomain = trustDomain;
+      this.path = path;
+    }
+
+    public String getTrustDomain() {
+      return trustDomain;
+    }
+
+    public String getPath() {
+      return path;
+    }
+  }
+
+  /**
+   * Represents a SPIFFE trust bundle; that is, a map from trust domain to set of trusted
+   * certificates. Only trust domain's sequence numbers and x509 certificates are supported.
+   * @see <a href="https://github.com/spiffe/spiffe/blob/main/standards/SPIFFE_Trust_Domain_and_Bundle.md#4-spiffe-bundle-format">Standard</a>
+   */
+  public static final class SpiffeBundle {
+
+    private final ImmutableMap<String, Long> sequenceNumbers;
+
+    private final ImmutableMap<String, ImmutableList<X509Certificate>> bundleMap;
+
+    private SpiffeBundle(Map<String, Long> sequenceNumbers,
+        Map<String, List<X509Certificate>> trustDomainMap) {
+      this.sequenceNumbers = ImmutableMap.copyOf(sequenceNumbers);
+      ImmutableMap.Builder<String, ImmutableList<X509Certificate>> builder = ImmutableMap.builder();
+      for (Map.Entry<String, List<X509Certificate>> entry : trustDomainMap.entrySet()) {
+        builder.put(entry.getKey(), ImmutableList.copyOf(entry.getValue()));
+      }
+      this.bundleMap = builder.build();
+    }
+
+    public ImmutableMap<String, Long> getSequenceNumbers() {
+      return sequenceNumbers;
+    }
+
+    public ImmutableMap<String, ImmutableList<X509Certificate>> getBundleMap() {
+      return bundleMap;
+    }
+  }
+
+}
diff --git a/core/src/main/java/io/grpc/internal/SquelchLateMessagesAvailableDeframerListener.java b/core/src/main/java/io/grpc/internal/SquelchLateMessagesAvailableDeframerListener.java
new file mode 100644
index 00000000000..02ce83367c2
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/SquelchLateMessagesAvailableDeframerListener.java
@@ -0,0 +1,64 @@
+/*
+ * 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.internal;
+
+import java.io.Closeable;
+
+/**
+ * A delegating Listener that throws away notifications of messagesAvailable() after the deframer
+ * has closed or failed. This can be used by deframers that "abuse" the MessageProducer to run work
+ * on the app thread, to avoid breaking the normal invariant that there are no messages after
+ * deframing is complete. Since the producer may not be run, it must not hold resources or
+ * it should implement {@link Closeable}.
+ */
+final class SquelchLateMessagesAvailableDeframerListener extends ForwardingDeframerListener {
+  private final MessageDeframer.Listener delegate;
+  private boolean closed;
+
+  public SquelchLateMessagesAvailableDeframerListener(MessageDeframer.Listener delegate) {
+    this.delegate = delegate;
+  }
+
+  @Override
+  protected MessageDeframer.Listener delegate() {
+    return delegate;
+  }
+
+  @Override
+  public void messagesAvailable(StreamListener.MessageProducer producer) {
+    if (closed) {
+      if (producer instanceof Closeable) {
+        GrpcUtil.closeQuietly((Closeable) producer);
+      }
+      return;
+    }
+    super.messagesAvailable(producer);
+  }
+
+  @Override
+  public void deframerClosed(boolean hasPartialMessage) {
+    closed = true;
+    super.deframerClosed(hasPartialMessage);
+  }
+
+  @Override
+  public void deframeFailed(Throwable cause) {
+    closed = true;
+    super.deframeFailed(cause);
+  }
+}
+
diff --git a/core/src/main/java/io/grpc/internal/StatsTraceContext.java b/core/src/main/java/io/grpc/internal/StatsTraceContext.java
index 43a793da82b..650f0b979ae 100644
--- a/core/src/main/java/io/grpc/internal/StatsTraceContext.java
+++ b/core/src/main/java/io/grpc/internal/StatsTraceContext.java
@@ -1,275 +1,248 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Stopwatch;
-import com.google.common.base.Supplier;
-import com.google.instrumentation.stats.MeasurementDescriptor;
-import com.google.instrumentation.stats.MeasurementMap;
-import com.google.instrumentation.stats.RpcConstants;
-import com.google.instrumentation.stats.StatsContext;
-import com.google.instrumentation.stats.StatsContextFactory;
-import com.google.instrumentation.stats.TagKey;
-import com.google.instrumentation.stats.TagValue;
+import io.grpc.Attributes;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Context;
 import io.grpc.Metadata;
+import io.grpc.ServerStreamTracer;
+import io.grpc.ServerStreamTracer.ServerCallInfo;
 import io.grpc.Status;
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.util.concurrent.TimeUnit;
+import io.grpc.StreamTracer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;
+import javax.annotation.concurrent.ThreadSafe;
 
 /**
- * The stats and tracing information for a call.
- *
- * <p>This class is not thread-safe, in the sense that the updates to each individual metric must be
- * serialized, while multiple threads can update different metrics without any sort of
- * synchronization.  For example, calls to {@link #wireBytesSent} must be synchronized, while {@link
- * #wireBytesReceived} and {@link #wireBytesSent} can be called concurrently.  {@link #callEnded}
- * can be called concurrently with itself and the other methods.
+ * The stats and tracing information for a stream.
  */
-@SuppressWarnings("NonAtomicVolatileUpdate")
+@ThreadSafe
 public final class StatsTraceContext {
-  public static final StatsTraceContext NOOP = StatsTraceContext.newClientContext(
-      "noopservice/noopmethod", NoopStatsContextFactory.INSTANCE,
-      GrpcUtil.STOPWATCH_SUPPLIER);
+  public static final StatsTraceContext NOOP = new StatsTraceContext(new StreamTracer[0]);
 
-  private static final double NANOS_PER_MILLI = 1000 * 1000;
+  private final StreamTracer[] tracers;
+  private final AtomicBoolean closed = new AtomicBoolean(false);
 
-  private enum Side {
-    CLIENT, SERVER
+  /**
+   * Factory method for the client-side.
+   */
+  public static StatsTraceContext newClientContext(
+      ClientStreamTracer[] tracers, Attributes transportAtts, Metadata headers) {
+    StatsTraceContext ctx = new StatsTraceContext(tracers);
+    for (ClientStreamTracer tracer : tracers) {
+      tracer.streamCreated(transportAtts, headers);
+    }
+    return ctx;
   }
 
-  private final StatsContext statsCtx;
-  private final Stopwatch stopwatch;
-  private final Side side;
-  private final Metadata.Key<StatsContext> statsHeader;
-  private volatile long clientPendingNanos = -1;
-  private volatile long wireBytesSent;
-  private volatile long wireBytesReceived;
-  private volatile long uncompressedBytesSent;
-  private volatile long uncompressedBytesReceived;
-  private final AtomicBoolean callEnded = new AtomicBoolean(false);
+  /**
+   * Factory method for the server-side.
+   */
+  public static StatsTraceContext newServerContext(
+      List<? extends ServerStreamTracer.Factory> factories,
+      String fullMethodName,
+      Metadata headers) {
+    if (factories.isEmpty()) {
+      return NOOP;
+    }
+    StreamTracer[] tracers = new StreamTracer[factories.size()];
+    for (int i = 0; i < tracers.length; i++) {
+      tracers[i] = factories.get(i).newServerStreamTracer(fullMethodName, headers);
+    }
+    return new StatsTraceContext(tracers);
+  }
 
-  private StatsTraceContext(Side side, String fullMethodName, StatsContext parentCtx,
-      Supplier<Stopwatch> stopwatchSupplier, Metadata.Key<StatsContext> statsHeader) {
-    this.side = side;
-    TagKey methodTagKey =
-        side == Side.CLIENT ? RpcConstants.RPC_CLIENT_METHOD : RpcConstants.RPC_SERVER_METHOD;
-    // TODO(carl-mastrangelo): maybe cache TagValue in MethodDescriptor
-    this.statsCtx = parentCtx.with(methodTagKey, TagValue.create(fullMethodName));
-    this.stopwatch = stopwatchSupplier.get().start();
-    this.statsHeader = statsHeader;
+  @VisibleForTesting
+  StatsTraceContext(StreamTracer[] tracers) {
+    this.tracers = tracers;
   }
 
   /**
-   * Creates a {@code StatsTraceContext} for an outgoing RPC, using the current StatsContext.
-   *
-   * <p>The current time is used as the start time of the RPC.
+   * Returns a copy of the tracer list.
    */
-  public static StatsTraceContext newClientContext(String methodName,
-      StatsContextFactory statsFactory, Supplier<Stopwatch> stopwatchSupplier) {
-    return new StatsTraceContext(Side.CLIENT, methodName,
-        // TODO(zhangkun83): use the StatsContext out of the current Context
-        statsFactory.getDefault(),
-        stopwatchSupplier, createStatsHeader(statsFactory));
-  }
-
   @VisibleForTesting
-  static StatsTraceContext newClientContextForTesting(String methodName,
-      StatsContextFactory statsFactory, StatsContext parent,
-      Supplier<Stopwatch> stopwatchSupplier) {
-    return new StatsTraceContext(Side.CLIENT, methodName, parent, stopwatchSupplier,
-        createStatsHeader(statsFactory));
+  public List<StreamTracer> getTracersForTest() {
+    return new ArrayList<>(Arrays.asList(tracers));
   }
 
   /**
-   * Creates a {@code StatsTraceContext} for an incoming RPC, using the StatsContext deserialized
-   * from the headers.
+   * See {@link ClientStreamTracer#outboundHeaders}.  For client-side only.
    *
-   * <p>The current time is used as the start time of the RPC.
+   * <p>Transport-specific, thus should be called by transport implementations.
    */
-  public static StatsTraceContext newServerContext(String methodName,
-      StatsContextFactory statsFactory, Metadata headers,
-      Supplier<Stopwatch> stopwatchSupplier) {
-    Metadata.Key<StatsContext> statsHeader = createStatsHeader(statsFactory);
-    StatsContext parentCtx = headers.get(statsHeader);
-    if (parentCtx == null) {
-      parentCtx = statsFactory.getDefault();
+  public void clientOutboundHeaders() {
+    for (StreamTracer tracer : tracers) {
+      ((ClientStreamTracer) tracer).outboundHeaders();
     }
-    return new StatsTraceContext(Side.SERVER, methodName, parentCtx, stopwatchSupplier,
-        statsHeader);
   }
 
   /**
-   * Propagate the context to the outgoing headers.
+   * See {@link ClientStreamTracer#inboundHeaders}.  For client-side only.
+   *
+   * <p>Called from abstract stream implementations.
    */
-  void propagateToHeaders(Metadata headers) {
-    headers.discardAll(statsHeader);
-    headers.put(statsHeader, statsCtx);
+  public void clientInboundHeaders(Metadata headers) {
+    for (StreamTracer tracer : tracers) {
+      ((ClientStreamTracer) tracer).inboundHeaders(headers);
+    }
   }
 
-  Metadata.Key<StatsContext> getStatsHeader() {
-    return statsHeader;
+  /**
+   * See {@link ClientStreamTracer#inboundTrailers}.  For client-side only.
+   *
+   * <p>Called from abstract stream implementations.
+   */
+  public void clientInboundTrailers(Metadata trailers) {
+    for (StreamTracer tracer : tracers) {
+      ((ClientStreamTracer) tracer).inboundTrailers(trailers);
+    }
   }
 
-  @VisibleForTesting
-  StatsContext getStatsContext() {
-    return statsCtx;
+  /**
+   * See {@link ServerStreamTracer#filterContext}. For server-side only.
+   *
+   * <p>Called from {@link io.grpc.internal.ServerImpl}.
+   */
+  @SuppressWarnings("UnusedTypeParameter")
+  public <ReqT, RespT> Context serverFilterContext(Context context) {
+    Context ctx = checkNotNull(context, "context");
+    for (StreamTracer tracer : tracers) {
+      ctx = ((ServerStreamTracer) tracer).filterContext(ctx);
+      checkNotNull(ctx, "%s returns null context", tracer);
+    }
+    return ctx;
   }
 
-  @VisibleForTesting
-  static Metadata.Key<StatsContext> createStatsHeader(final StatsContextFactory statsCtxFactory) {
-    return Metadata.Key.of("grpc-census-bin", new Metadata.BinaryMarshaller<StatsContext>() {
-        @Override
-        public byte[] toBytes(StatsContext context) {
-          // TODO(carl-mastrangelo): currently we only make sure the correctness. We may need to
-          // optimize out the allocation and copy in the future.
-          ByteArrayOutputStream buffer = new ByteArrayOutputStream();
-          try {
-            context.serialize(buffer);
-          } catch (IOException e) {
-            throw new RuntimeException(e);
-          }
-          return buffer.toByteArray();
-        }
-
-        @Override
-        public StatsContext parseBytes(byte[] serialized) {
-          try {
-            return statsCtxFactory.deserialize(new ByteArrayInputStream(serialized));
-          } catch (IOException e) {
-            throw new RuntimeException(e);
-          }
-        }
-      });
+  /**
+   * See {@link ServerStreamTracer#serverCallStarted}.  For server-side only.
+   *
+   * <p>Called from {@link io.grpc.internal.ServerImpl}.
+   */
+  public void serverCallStarted(ServerCallInfo<?, ?> callInfo) {
+    for (StreamTracer tracer : tracers) {
+      ((ServerStreamTracer) tracer).serverCallStarted(callInfo);
+    }
   }
 
   /**
-   * Record the outgoing number of payload bytes as on the wire.
+   * See {@link StreamTracer#streamClosed}. This may be called multiple times, and only the first
+   * value will be taken.
+   *
+   * <p>Called from abstract stream implementations.
    */
-  void wireBytesSent(long bytes) {
-    wireBytesSent += bytes;
+  public void streamClosed(Status status) {
+    if (closed.compareAndSet(false, true)) {
+      for (StreamTracer tracer : tracers) {
+        tracer.streamClosed(status);
+      }
+    }
   }
 
   /**
-   * Record the incoming number of payload bytes as on the wire.
+   * See {@link StreamTracer#outboundMessage(int)}.
+   *
+   * <p>Called from {@link io.grpc.internal.Framer}.
    */
-  void wireBytesReceived(long bytes) {
-    wireBytesReceived += bytes;
+  public void outboundMessage(int seqNo) {
+    for (StreamTracer tracer : tracers) {
+      tracer.outboundMessage(seqNo);
+    }
   }
 
   /**
-   * Record the outgoing number of payload bytes in uncompressed form.
+   * See {@link StreamTracer#inboundMessage(int)}.
    *
-   * <p>The time this method is called is unrelated to the actual time when those byte are sent.
+   * <p>Called from {@link io.grpc.internal.MessageDeframer}.
    */
-  void uncompressedBytesSent(long bytes) {
-    uncompressedBytesSent += bytes;
+  public void inboundMessage(int seqNo) {
+    for (StreamTracer tracer : tracers) {
+      tracer.inboundMessage(seqNo);
+    }
   }
 
   /**
-   * Record the incoming number of payload bytes in uncompressed form.
+   * See {@link StreamTracer#outboundMessageSent}.
    *
-   * <p>The time this method is called is unrelated to the actual time when those byte are received.
+   * <p>Called from {@link io.grpc.internal.Framer}.
    */
-  void uncompressedBytesReceived(long bytes) {
-    uncompressedBytesReceived += bytes;
+  public void outboundMessageSent(int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+    for (StreamTracer tracer : tracers) {
+      tracer.outboundMessageSent(seqNo, optionalWireSize, optionalUncompressedSize);
+    }
   }
 
   /**
-   * Mark the time when the headers, which are the first bytes of the RPC, are sent from the client.
-   * This is specific to transport implementation, thus should be called from transports.  Calling
-   * it the second time or more is a no-op.
+   * See {@link StreamTracer#inboundMessageRead}.
+   *
+   * <p>Called from {@link io.grpc.internal.MessageDeframer}.
    */
-  public void clientHeadersSent() {
-    Preconditions.checkState(side == Side.CLIENT, "Must be called on client-side");
-    if (clientPendingNanos < 0) {
-      clientPendingNanos = stopwatch.elapsed(TimeUnit.NANOSECONDS);
+  public void inboundMessageRead(int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+    for (StreamTracer tracer : tracers) {
+      tracer.inboundMessageRead(seqNo, optionalWireSize, optionalUncompressedSize);
     }
   }
 
   /**
-   * Record a finished all and mark the current time as the end time.
+   * See {@link StreamTracer#outboundUncompressedSize}.
    *
-   * <p>Can be called from any thread without synchronization.  Calling it the second time or more
-   * is a no-op.
+   * <p>Called from {@link io.grpc.internal.Framer}.
    */
-  void callEnded(Status status) {
-    if (!callEnded.compareAndSet(false, true)) {
-      return;
+  public void outboundUncompressedSize(long bytes) {
+    for (StreamTracer tracer : tracers) {
+      tracer.outboundUncompressedSize(bytes);
     }
-    stopwatch.stop();
-    MeasurementDescriptor latencyMetric;
-    MeasurementDescriptor wireBytesSentMetric;
-    MeasurementDescriptor wireBytesReceivedMetric;
-    MeasurementDescriptor uncompressedBytesSentMetric;
-    MeasurementDescriptor uncompressedBytesReceivedMetric;
-    MeasurementDescriptor errorCountMetric;
-    if (side == Side.CLIENT) {
-      latencyMetric = RpcConstants.RPC_CLIENT_ROUNDTRIP_LATENCY;
-      wireBytesSentMetric = RpcConstants.RPC_CLIENT_REQUEST_BYTES;
-      wireBytesReceivedMetric = RpcConstants.RPC_CLIENT_RESPONSE_BYTES;
-      uncompressedBytesSentMetric = RpcConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES;
-      uncompressedBytesReceivedMetric = RpcConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES;
-      errorCountMetric = RpcConstants.RPC_CLIENT_ERROR_COUNT;
-    } else {
-      latencyMetric = RpcConstants.RPC_SERVER_SERVER_LATENCY;
-      wireBytesSentMetric = RpcConstants.RPC_SERVER_RESPONSE_BYTES;
-      wireBytesReceivedMetric = RpcConstants.RPC_SERVER_REQUEST_BYTES;
-      uncompressedBytesSentMetric = RpcConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES;
-      uncompressedBytesReceivedMetric = RpcConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES;
-      errorCountMetric = RpcConstants.RPC_SERVER_ERROR_COUNT;
+  }
+
+  /**
+   * See {@link StreamTracer#outboundWireSize}.
+   *
+   * <p>Called from {@link io.grpc.internal.Framer}.
+   */
+  public void outboundWireSize(long bytes) {
+    for (StreamTracer tracer : tracers) {
+      tracer.outboundWireSize(bytes);
     }
-    long roundtripNanos = stopwatch.elapsed(TimeUnit.NANOSECONDS);
-    MeasurementMap.Builder builder = MeasurementMap.builder()
-        .put(latencyMetric, roundtripNanos / NANOS_PER_MILLI)  // in double
-        .put(wireBytesSentMetric, wireBytesSent)
-        .put(wireBytesReceivedMetric, wireBytesReceived)
-        .put(uncompressedBytesSentMetric, uncompressedBytesSent)
-        .put(uncompressedBytesReceivedMetric, uncompressedBytesReceived);
-    if (!status.isOk()) {
-      builder.put(errorCountMetric, 1.0);
+  }
+
+  /**
+   * See {@link StreamTracer#inboundUncompressedSize}.
+   *
+   * <p>Called from {@link io.grpc.internal.MessageDeframer}.
+   */
+  public void inboundUncompressedSize(long bytes) {
+    for (StreamTracer tracer : tracers) {
+      tracer.inboundUncompressedSize(bytes);
     }
-    if (side == Side.CLIENT) {
-      if (clientPendingNanos >= 0) {
-        builder.put(
-            RpcConstants.RPC_CLIENT_SERVER_ELAPSED_TIME,
-            (roundtripNanos - clientPendingNanos) / NANOS_PER_MILLI);  // in double
-      }
+  }
+
+  /**
+   * See {@link StreamTracer#inboundWireSize}.
+   *
+   * <p>Called from {@link io.grpc.internal.MessageDeframer}.
+   */
+  public void inboundWireSize(long bytes) {
+    for (StreamTracer tracer : tracers) {
+      tracer.inboundWireSize(bytes);
     }
-    statsCtx.with(RpcConstants.RPC_STATUS, TagValue.create(status.getCode().toString()))
-        .record(builder.build());
   }
 }
diff --git a/core/src/main/java/io/grpc/internal/Stream.java b/core/src/main/java/io/grpc/internal/Stream.java
index 7cb1e640713..edd2914e489 100644
--- a/core/src/main/java/io/grpc/internal/Stream.java
+++ b/core/src/main/java/io/grpc/internal/Stream.java
@@ -1,38 +1,22 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import io.grpc.Compressor;
-import io.grpc.Decompressor;
 import java.io.InputStream;
 
 /**
@@ -42,10 +26,10 @@
  */
 public interface Stream {
   /**
-   * Requests up to the given number of messages from the call to be delivered to
-   * {@link StreamListener#messageRead(java.io.InputStream)}. No additional messages will be
-   * delivered.  If the stream has a {@code start()} method, it must be called before requesting
-   * messages.
+   * Requests up to the given number of messages from the call to be delivered via
+   * {@link StreamListener#messagesAvailable(StreamListener.MessageProducer)}. No additional
+   * messages will be delivered.  If the stream has a {@code start()} method, it must be called
+   * before requesting messages.
    *
    * @param numMessages the requested number of messages to be delivered to the listener.
    */
@@ -61,6 +45,9 @@ public interface Stream {
    * <p>It is recommended that the caller consult {@link #isReady()} before calling this method to
    * avoid excessive buffering in the transport.
    *
+   * <p>This method takes ownership of the InputStream, and implementations are responsible for
+   * calling {@link InputStream#close}.
+   *
    * @param message stream containing the serialized message to be sent
    */
   void writeMessage(InputStream message);
@@ -81,18 +68,18 @@ public interface Stream {
   boolean isReady();
 
   /**
-   * Sets the compressor on the framer.
-   *
-   * @param compressor the compressor to use
+   * Provides a hint that directExecutor is being used by the listener for callbacks to the
+   * application. No action is required. There is no requirement that this method actually matches
+   * the executor used.
    */
-  void setCompressor(Compressor compressor);
+  void optimizeForDirectExecutor();
 
   /**
-   * Sets the decompressor on the deframer.
+   * Sets the compressor on the framer.
    *
-   * @param decompressor the decompressor to use.
+   * @param compressor the compressor to use
    */
-  void setDecompressor(Decompressor decompressor);
+  void setCompressor(Compressor compressor);
 
   /**
    * Enables per-message compression, if an encoding type has been negotiated.  If no message
diff --git a/core/src/main/java/io/grpc/internal/StreamListener.java b/core/src/main/java/io/grpc/internal/StreamListener.java
index f18147c51bf..a893a9c84b6 100644
--- a/core/src/main/java/io/grpc/internal/StreamListener.java
+++ b/core/src/main/java/io/grpc/internal/StreamListener.java
@@ -1,37 +1,23 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import java.io.InputStream;
+import javax.annotation.Nullable;
 
 /**
  * An observer of {@link Stream} events. It is guaranteed to only have one concurrent callback at a
@@ -39,16 +25,17 @@
  */
 public interface StreamListener {
   /**
-   * Called upon receiving a message from the remote end-point. The {@link InputStream} is
-   * non-blocking and contains the entire message.
+   * Called upon receiving a message from the remote end-point.
    *
-   * <p>The provided {@code message} {@link InputStream} must be closed by the listener.
+   * <p>Implementations must eventually drain the provided {@code producer} {@link MessageProducer}
+   * completely by invoking {@link MessageProducer#next()} to obtain deframed messages until the
+   * producer returns null.
    *
    * <p>This method should return quickly, as the same thread may be used to process other streams.
    *
-   * @param message the bytes of the message.
+   * @param producer supplier of deframed messages.
    */
-  void messageRead(InputStream message);
+  void messagesAvailable(MessageProducer producer);
 
   /**
    * This indicates that the transport is now capable of sending additional messages
@@ -57,4 +44,21 @@ public interface StreamListener {
    * result in excessive buffering within the transport.
    */
   void onReady();
+
+  /**
+   * A producer for deframed gRPC messages.
+   */
+  interface MessageProducer {
+    /**
+     * Returns the next gRPC message, if the data has been received by the deframer and the
+     * application has requested another message.
+     *
+     * <p>The provided {@code message} {@link InputStream} must be closed by the listener.
+     *
+     * <p>This is intended to be used similar to an iterator, invoking {@code next()} to obtain
+     * messages until the producer returns null, at which point the producer may be discarded.
+     */
+    @Nullable
+    InputStream next();
+  }
 }
diff --git a/core/src/main/java/io/grpc/internal/SubchannelChannel.java b/core/src/main/java/io/grpc/internal/SubchannelChannel.java
new file mode 100644
index 00000000000..ced4272afe3
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/SubchannelChannel.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2016 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Context;
+import io.grpc.InternalConfigSelector;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.grpc.internal.ClientCallImpl.ClientStreamProvider;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.atomic.AtomicReference;
+
+final class SubchannelChannel extends Channel {
+  @VisibleForTesting
+  static final Status NOT_READY_ERROR =
+      Status.UNAVAILABLE.withDescription("Subchannel is NOT READY");
+  @VisibleForTesting
+  static final Status WAIT_FOR_READY_ERROR =
+      Status.UNAVAILABLE.withDescription(
+          "wait-for-ready RPC is not supported on Subchannel.asChannel()");
+  private static final FailingClientTransport notReadyTransport =
+      new FailingClientTransport(NOT_READY_ERROR, RpcProgress.MISCARRIED);
+  private final InternalSubchannel subchannel;
+  private final Executor executor;
+  private final ScheduledExecutorService deadlineCancellationExecutor;
+  private final CallTracer callsTracer;
+  private final AtomicReference<InternalConfigSelector> configSelector;
+
+  private final ClientStreamProvider transportProvider = new ClientStreamProvider() {
+      @Override
+      public ClientStream newStream(MethodDescriptor<?, ?> method,
+          CallOptions callOptions, Metadata headers, Context context) {
+        ClientTransport transport = subchannel.getTransport();
+        if (transport == null) {
+          transport = notReadyTransport;
+        }
+        ClientStreamTracer[] tracers = GrpcUtil.getClientStreamTracers(
+            callOptions, headers, 0, /* isTransparentRetry= */ false,
+            /* isHedging= */ false);
+        Context origContext = context.attach();
+        try {
+          return transport.newStream(method, headers, callOptions, tracers);
+        } finally {
+          context.detach(origContext);
+        }
+      }
+    };
+
+  SubchannelChannel(
+      InternalSubchannel subchannel, Executor executor,
+      ScheduledExecutorService deadlineCancellationExecutor, CallTracer callsTracer,
+      AtomicReference<InternalConfigSelector> configSelector) {
+    this.subchannel = checkNotNull(subchannel, "subchannel");
+    this.executor = checkNotNull(executor, "executor");
+    this.deadlineCancellationExecutor =
+        checkNotNull(deadlineCancellationExecutor, "deadlineCancellationExecutor");
+    this.callsTracer = checkNotNull(callsTracer, "callsTracer");
+    this.configSelector = checkNotNull(configSelector, "configSelector");
+  }
+
+  @Override
+  public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+      MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+    final Executor effectiveExecutor =
+        callOptions.getExecutor() == null ? executor : callOptions.getExecutor();
+    if (callOptions.isWaitForReady()) {
+      return new ClientCall<RequestT, ResponseT>() {
+        @Override
+        public void start(final ClientCall.Listener<ResponseT> listener, Metadata headers) {
+          effectiveExecutor.execute(new Runnable() {
+              @Override
+              public void run() {
+                listener.onClose(WAIT_FOR_READY_ERROR, new Metadata());
+              }
+            });
+        }
+
+        @Override
+        public void request(int numMessages) {}
+
+        @Override
+        public void cancel(String message, Throwable cause) {}
+
+        @Override
+        public void halfClose() {}
+
+        @Override
+        public void sendMessage(RequestT message) {}
+      };
+    }
+    return new ClientCallImpl<>(methodDescriptor,
+        effectiveExecutor,
+        callOptions.withOption(GrpcUtil.CALL_OPTIONS_RPC_OWNED_BY_BALANCER, Boolean.TRUE),
+        transportProvider, deadlineCancellationExecutor, callsTracer, configSelector.get());
+  }
+
+  @Override
+  public String authority() {
+    return subchannel.getAuthority();
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/SubchannelImpl.java b/core/src/main/java/io/grpc/internal/SubchannelImpl.java
deleted file mode 100644
index c35218701f0..00000000000
--- a/core/src/main/java/io/grpc/internal/SubchannelImpl.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import io.grpc.LoadBalancer2;
-import javax.annotation.Nullable;
-
-/**
- * The base interface of the Subchannels returned by {@link
- * io.grpc.LoadBalancer2.Helper#createSubchannel}.
- */
-abstract class SubchannelImpl extends LoadBalancer2.Subchannel {
-  /**
-   * Same as {@link InternalSubchannel#obtainActiveTransport}.
-   */
-  @Nullable
-  abstract ClientTransport obtainActiveTransport();
-}
diff --git a/core/src/main/java/io/grpc/internal/SubchannelMetrics.java b/core/src/main/java/io/grpc/internal/SubchannelMetrics.java
new file mode 100644
index 00000000000..4bc2cf47046
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/SubchannelMetrics.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2025 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.internal;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import io.grpc.LongCounterMetricInstrument;
+import io.grpc.LongUpDownCounterMetricInstrument;
+import io.grpc.MetricInstrumentRegistry;
+import io.grpc.MetricRecorder;
+
+final class SubchannelMetrics {
+
+  private static final LongCounterMetricInstrument disconnections;
+  private static final LongCounterMetricInstrument connectionAttemptsSucceeded;
+  private static final LongCounterMetricInstrument connectionAttemptsFailed;
+  private static final LongUpDownCounterMetricInstrument openConnections;
+  private final MetricRecorder metricRecorder;
+
+  public SubchannelMetrics(MetricRecorder metricRecorder) {
+    this.metricRecorder = metricRecorder;
+  }
+
+  static {
+    MetricInstrumentRegistry metricInstrumentRegistry
+        = MetricInstrumentRegistry.getDefaultRegistry();
+    disconnections = metricInstrumentRegistry.registerLongCounter(
+        "grpc.subchannel.disconnections",
+        "EXPERIMENTAL. Number of times the selected subchannel becomes disconnected",
+        "{disconnection}",
+        Lists.newArrayList("grpc.target"),
+        Lists.newArrayList("grpc.lb.backend_service", "grpc.lb.locality", "grpc.disconnect_error"),
+        false
+    );
+
+    connectionAttemptsSucceeded = metricInstrumentRegistry.registerLongCounter(
+        "grpc.subchannel.connection_attempts_succeeded",
+        "EXPERIMENTAL. Number of successful connection attempts",
+        "{attempt}",
+        Lists.newArrayList("grpc.target"),
+        Lists.newArrayList("grpc.lb.backend_service", "grpc.lb.locality"),
+        false
+    );
+
+    connectionAttemptsFailed = metricInstrumentRegistry.registerLongCounter(
+        "grpc.subchannel.connection_attempts_failed",
+        "EXPERIMENTAL. Number of failed connection attempts",
+        "{attempt}",
+        Lists.newArrayList("grpc.target"),
+        Lists.newArrayList("grpc.lb.backend_service", "grpc.lb.locality"),
+        false
+    );
+
+    openConnections = metricInstrumentRegistry.registerLongUpDownCounter(
+        "grpc.subchannel.open_connections",
+        "EXPERIMENTAL. Number of open connections.",
+        "{connection}",
+        Lists.newArrayList("grpc.target"),
+        Lists.newArrayList("grpc.security_level", "grpc.lb.backend_service", "grpc.lb.locality"),
+        false
+    );
+  }
+
+  public void recordConnectionAttemptSucceeded(String target, String backendService,
+                                               String locality, String securityLevel) {
+    metricRecorder
+        .addLongCounter(connectionAttemptsSucceeded, 1,
+            ImmutableList.of(target),
+            ImmutableList.of(backendService, locality));
+    metricRecorder
+        .addLongUpDownCounter(openConnections, 1,
+            ImmutableList.of(target),
+            ImmutableList.of(securityLevel, backendService, locality));
+  }
+
+  public void recordConnectionAttemptFailed(String target, String backendService, String locality) {
+    metricRecorder
+        .addLongCounter(connectionAttemptsFailed, 1,
+            ImmutableList.of(target),
+            ImmutableList.of(backendService, locality));
+  }
+
+  public void recordDisconnection(String target, String backendService, String locality,
+                                  String disconnectError, String securityLevel) {
+    metricRecorder
+        .addLongCounter(disconnections, 1,
+            ImmutableList.of(target),
+            ImmutableList.of(backendService, locality, disconnectError));
+    metricRecorder
+        .addLongUpDownCounter(openConnections, -1,
+            ImmutableList.of(target),
+            ImmutableList.of(securityLevel, backendService, locality));
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/ThreadOptimizedDeframer.java b/core/src/main/java/io/grpc/internal/ThreadOptimizedDeframer.java
new file mode 100644
index 00000000000..5c130991dba
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/ThreadOptimizedDeframer.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2019 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.internal;
+
+/**
+ * A {@code Deframer} that optimizations by taking over part of the thread safety.
+ */
+public interface ThreadOptimizedDeframer extends Deframer {
+  /**
+   * Behaves like {@link Deframer#request(int)} except it can be called from any thread. Must not
+   * throw exceptions in case of deframer error.
+   */
+  @Override
+  void request(int numMessages);
+}
diff --git a/core/src/main/java/io/grpc/internal/TimeProvider.java b/core/src/main/java/io/grpc/internal/TimeProvider.java
new file mode 100644
index 00000000000..3bd052ab3e0
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/TimeProvider.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2017 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.internal;
+
+/**
+ * Time source representing the current system time in nanos. Used to inject a fake clock
+ * into unit tests.
+ */
+public interface TimeProvider {
+  /** Returns the current nano time. */
+  long currentTimeNanos();
+
+  TimeProvider SYSTEM_TIME_PROVIDER = TimeProviderResolverFactory.resolveTimeProvider();
+}
diff --git a/core/src/main/java/io/grpc/internal/TimeProviderResolverFactory.java b/core/src/main/java/io/grpc/internal/TimeProviderResolverFactory.java
new file mode 100644
index 00000000000..04272034ce9
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/TimeProviderResolverFactory.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2024 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.internal;
+
+/**
+ * {@link TimeProviderResolverFactory} resolves Time providers.
+ */
+
+final class TimeProviderResolverFactory {
+  static TimeProvider resolveTimeProvider() {
+    try {
+      Class.forName("java.time.Instant");
+      return new InstantTimeProvider();
+    } catch (ClassNotFoundException ex) {
+      return new ConcurrentTimeProvider();
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/TransportFrameUtil.java b/core/src/main/java/io/grpc/internal/TransportFrameUtil.java
index ae947996474..3bd7ee72239 100644
--- a/core/src/main/java/io/grpc/internal/TransportFrameUtil.java
+++ b/core/src/main/java/io/grpc/internal/TransportFrameUtil.java
@@ -1,42 +1,30 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
-import static com.google.common.base.Charsets.US_ASCII;
+import static java.nio.charset.StandardCharsets.US_ASCII;
 
 import com.google.common.io.BaseEncoding;
+import com.google.errorprone.annotations.CheckReturnValue;
 import io.grpc.InternalMetadata;
 import io.grpc.Metadata;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 import java.util.logging.Logger;
 
 /**
@@ -72,7 +60,8 @@ public static byte[][] toHttp2Headers(Metadata headers) {
       if (endsWith(key, binaryHeaderSuffixBytes)) {
         // Binary header.
         serializedHeaders[k] = key;
-        serializedHeaders[k + 1] = BaseEncoding.base64().encode(value).getBytes(US_ASCII);
+        serializedHeaders[k + 1]
+            = InternalMetadata.BASE64_ENCODING_OMIT_PADDING.encode(value).getBytes(US_ASCII);
         k += 2;
       } else {
         // Non-binary header.
@@ -98,20 +87,29 @@ public static byte[][] toHttp2Headers(Metadata headers) {
 
   /**
    * Transform HTTP/2-compliant headers to the raw serialized format which can be deserialized by
-   * metadata marshallers. It decodes the Base64-encoded binary headers.  This function modifies
-   * the headers in place.  By modifying the input array.
+   * metadata marshallers. It decodes the Base64-encoded binary headers.
+   *
+   * <p>Warning: This function may partially modify the headers in place by modifying the input
+   * array (but not modifying any single byte), so the input reference {@code http2Headers} can not
+   * be used again.
    *
    * @param http2Headers the interleaved keys and values of HTTP/2-compliant headers
    * @return the interleaved keys and values in the raw serialized format
    */
+  @CheckReturnValue
   public static byte[][] toRawSerializedHeaders(byte[][] http2Headers) {
     for (int i = 0; i < http2Headers.length; i += 2) {
       byte[] key = http2Headers[i];
       byte[] value = http2Headers[i + 1];
-      http2Headers[i] = key;
       if (endsWith(key, binaryHeaderSuffixBytes)) {
         // Binary header
-        http2Headers[i + 1] = BaseEncoding.base64().decode(new String(value, US_ASCII));
+        for (int idx = 0; idx < value.length; idx++) {
+          if (value[idx] == (byte) ',') {
+            return serializeHeadersWithCommasInBin(http2Headers, i);
+          }
+        }
+        byte[] decodedVal = BaseEncoding.base64().decode(new String(value, US_ASCII));
+        http2Headers[i + 1] = decodedVal;
       } else {
         // Non-binary header
         // Nothing to do, the value is already in the right place.
@@ -120,6 +118,35 @@ public static byte[][] toRawSerializedHeaders(byte[][] http2Headers) {
     return http2Headers;
   }
 
+  private static byte[][] serializeHeadersWithCommasInBin(byte[][] http2Headers, int resumeFrom) {
+    List<byte[]> headerList = new ArrayList<>(http2Headers.length + 10);
+    for (int i = 0; i < resumeFrom; i++) {
+      headerList.add(http2Headers[i]);
+    }
+    for (int i = resumeFrom; i < http2Headers.length; i += 2) {
+      byte[] key = http2Headers[i];
+      byte[] value = http2Headers[i + 1];
+      if (!endsWith(key, binaryHeaderSuffixBytes)) {
+        headerList.add(key);
+        headerList.add(value);
+        continue;
+      }
+      // Binary header
+      int prevIdx = 0;
+      for (int idx = 0; idx <= value.length; idx++) {
+        if (idx != value.length && value[idx] != (byte) ',') {
+          continue;
+        }
+        byte[] decodedVal =
+            BaseEncoding.base64().decode(new String(value, prevIdx, idx - prevIdx, US_ASCII));
+        prevIdx = idx + 1;
+        headerList.add(key);
+        headerList.add(decodedVal);
+      }
+    }
+    return headerList.toArray(new byte[0][]);
+  }
+
   /**
    * Returns {@code true} if {@code subject} ends with {@code suffix}.
    */
diff --git a/core/src/main/java/io/grpc/internal/TransportProvider.java b/core/src/main/java/io/grpc/internal/TransportProvider.java
new file mode 100644
index 00000000000..47230443e97
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/TransportProvider.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2019 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.internal;
+
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Provides transports for sending RPCs.
+ */
+@ThreadSafe
+interface TransportProvider {
+  /**
+   * Returns a READY transport that will be used to create new streams.
+   *
+   * <p>Returns {@code null} if the state is not READY.  Will try to connect if state is IDLE.
+   */
+  @Nullable
+  ClientTransport obtainActiveTransport();
+}
diff --git a/core/src/main/java/io/grpc/internal/TransportSet.java b/core/src/main/java/io/grpc/internal/TransportSet.java
deleted file mode 100644
index d42547fb686..00000000000
--- a/core/src/main/java/io/grpc/internal/TransportSet.java
+++ /dev/null
@@ -1,603 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import com.google.common.base.Preconditions;
-import com.google.common.base.Stopwatch;
-import com.google.common.base.Supplier;
-import io.grpc.CallOptions;
-import io.grpc.ClientCall;
-import io.grpc.ConnectivityState;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer;
-import io.grpc.ManagedChannel;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.Status;
-import io.grpc.internal.ClientCallImpl.ClientTransportProvider;
-import java.net.SocketAddress;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import javax.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * Transports for a single {@link SocketAddress}.
- */
-@ThreadSafe
-final class TransportSet extends ManagedChannel implements WithLogId {
-  private static final Logger log = Logger.getLogger(TransportSet.class.getName());
-  private static final ClientTransport SHUTDOWN_TRANSPORT =
-      new FailingClientTransport(Status.UNAVAILABLE.withDescription("TransportSet is shutdown"));
-
-  private final CountDownLatch terminatedLatch = new CountDownLatch(1);
-  private final Object lock = new Object();
-  private final LogId logId = LogId.allocate(getClass().getName());
-  private final EquivalentAddressGroup addressGroup;
-  private final String authority;
-  private final String userAgent;
-  private final BackoffPolicy.Provider backoffPolicyProvider;
-  private final Callback callback;
-  private final ClientTransportFactory transportFactory;
-  private final ScheduledExecutorService scheduledExecutor;
-  private final Executor appExecutor;
-
-  @GuardedBy("lock")
-  private int nextAddressIndex;
-
-  /**
-   * The policy to control back off between reconnects. Non-{@code null} when last connect failed.
-   */
-  @GuardedBy("lock")
-  private BackoffPolicy reconnectPolicy;
-
-  /**
-   * Timer monitoring duration since entering CONNECTING state.
-   */
-  @GuardedBy("lock")
-  private final Stopwatch connectingTimer;
-
-  @GuardedBy("lock")
-  @Nullable
-  private ScheduledFuture<?> reconnectTask;
-
-  /**
-   * All transports that are not terminated. At the very least the value of {@link #activeTransport}
-   * will be present, but previously used transports that still have streams or are stopping may
-   * also be present.
-   */
-  @GuardedBy("lock")
-  private final Collection<ManagedClientTransport> transports =
-      new ArrayList<ManagedClientTransport>();
-
-  private final InUseStateAggregator<ManagedClientTransport> inUseStateAggregator =
-      new InUseStateAggregator<ManagedClientTransport>() {
-        @Override
-        Object getLock() {
-          return lock;
-        }
-
-        @Override
-        Runnable handleInUse() {
-          return callback.onInUse(TransportSet.this);
-        }
-
-        @Override
-        void handleNotInUse() {
-          callback.onNotInUse(TransportSet.this);
-        }
-      };
-
-  /**
-   * The to-be active transport, which is not ready yet.
-   */
-  @GuardedBy("lock")
-  @Nullable
-  private ConnectionClientTransport pendingTransport;
-
-  private final LoadBalancer<ClientTransport> loadBalancer;
-
-  @GuardedBy("lock")
-  private boolean shutdown;
-
-  /**
-   * The transport for new outgoing requests. 'lock' must be held when assigning to it.
-   *
-   * <pre><code>
-   * State             Value
-   * -----             ------
-   * IDLE              null, shutdown == false
-   * CONNECTING        instanceof DelayedTransport, reconnectTask == null
-   * READY             connected transport
-   * TRANSIENT_FAILURE instanceof DelayedTransport, reconnectTask != null
-   * SHUTDOWN          null, shutdown == true
-   * </code></pre>
-   */
-  @Nullable
-  private volatile ManagedClientTransport activeTransport;
-
-  @GuardedBy("lock")
-  private final ConnectivityStateManager stateManager =
-      new ConnectivityStateManager(ConnectivityState.IDLE);
-
-  TransportSet(EquivalentAddressGroup addressGroup, String authority, String userAgent,
-      LoadBalancer<ClientTransport> loadBalancer, BackoffPolicy.Provider backoffPolicyProvider,
-      ClientTransportFactory transportFactory, ScheduledExecutorService scheduledExecutor,
-      Supplier<Stopwatch> stopwatchSupplier, Executor appExecutor, Callback callback) {
-    this.addressGroup = Preconditions.checkNotNull(addressGroup, "addressGroup");
-    this.authority = authority;
-    this.userAgent = userAgent;
-    this.loadBalancer = loadBalancer;
-    this.backoffPolicyProvider = backoffPolicyProvider;
-    this.transportFactory = transportFactory;
-    this.scheduledExecutor = scheduledExecutor;
-    this.connectingTimer = stopwatchSupplier.get();
-    this.appExecutor = appExecutor;
-    this.callback = callback;
-  }
-
-  /**
-   * Returns the active transport that will be used to create new streams.
-   *
-   * <p>Never returns {@code null}.
-   */
-  final ClientTransport obtainActiveTransport() {
-    ClientTransport savedTransport = activeTransport;
-    if (savedTransport != null) {
-      return savedTransport;
-    }
-    Runnable runnable;
-    synchronized (lock) {
-      // Check again, since it could have changed before acquiring the lock
-      savedTransport = activeTransport;
-      if (savedTransport != null) {
-        return savedTransport;
-      }
-      if (shutdown) {
-        return SHUTDOWN_TRANSPORT;
-      }
-      stateManager.gotoState(ConnectivityState.CONNECTING);
-      DelayedClientTransport delayedTransport = new DelayedClientTransport(appExecutor);
-      transports.add(delayedTransport);
-      delayedTransport.start(new BaseTransportListener(delayedTransport));
-      savedTransport = activeTransport = delayedTransport;
-      runnable = startNewTransport(delayedTransport);
-    }
-    if (runnable != null) {
-      runnable.run();
-    }
-    return savedTransport;
-  }
-
-  @CheckReturnValue
-  @GuardedBy("lock")
-  private Runnable startNewTransport(DelayedClientTransport delayedTransport) {
-    Preconditions.checkState(reconnectTask == null, "Should have no reconnectTask scheduled");
-
-    if (nextAddressIndex == 0) {
-      connectingTimer.reset().start();
-    }
-    List<SocketAddress> addrs = addressGroup.getAddresses();
-    final SocketAddress address = addrs.get(nextAddressIndex++);
-    if (nextAddressIndex >= addrs.size()) {
-      nextAddressIndex = 0;
-    }
-
-    ConnectionClientTransport transport =
-        transportFactory.newClientTransport(address, authority, userAgent);
-    if (log.isLoggable(Level.FINE)) {
-      log.log(Level.FINE, "[{0}] Created {1} for {2}",
-          new Object[] {getLogId(), transport.getLogId(), address});
-    }
-    pendingTransport = transport;
-    transports.add(transport);
-    return transport.start(new TransportListener(transport, delayedTransport, address));
-  }
-
-  /**
-   * Only called after all addresses attempted and failed (TRANSIENT_FAILURE).
-   * @param status the causal status when the channel begins transition to
-   *     TRANSIENT_FAILURE.
-   */
-  private void scheduleBackoff(
-      final DelayedClientTransport delayedTransport, final Status status) {
-    // This must be run outside of lock. The TransportSet lock is a channel level lock.
-    // startBackoff() will acquire the delayed transport lock, which is a transport level
-    // lock. Our lock ordering mandates transport lock > channel lock.  Otherwise a deadlock
-    // could happen (https://github.com/grpc/grpc-java/issues/2152).
-    delayedTransport.startBackoff(status);
-
-    class EndOfCurrentBackoff implements Runnable {
-      @Override
-      public void run() {
-        try {
-          delayedTransport.endBackoff();
-          Runnable runnable = null;
-          synchronized (lock) {
-            reconnectTask = null;
-            if (!shutdown) {
-              stateManager.gotoState(ConnectivityState.CONNECTING);
-            }
-            runnable = startNewTransport(delayedTransport);
-          }
-          if (runnable != null) {
-            runnable.run();
-          }
-        } catch (Throwable t) {
-          log.log(Level.WARNING, "Exception handling end of backoff", t);
-        }
-      }
-    }
-
-    synchronized (lock) {
-      if (shutdown) {
-        return;
-      }
-      stateManager.gotoState(ConnectivityState.TRANSIENT_FAILURE);
-      if (reconnectPolicy == null) {
-        reconnectPolicy = backoffPolicyProvider.get();
-      }
-      long delayMillis =
-          reconnectPolicy.nextBackoffMillis() - connectingTimer.elapsed(TimeUnit.MILLISECONDS);
-      if (log.isLoggable(Level.FINE)) {
-        log.log(Level.FINE, "[{0}] Scheduling backoff for {1} ms",
-            new Object[]{getLogId(), delayMillis});
-      }
-      Preconditions.checkState(reconnectTask == null, "previous reconnectTask is not done");
-      reconnectTask = scheduledExecutor.schedule(
-          new LogExceptionRunnable(new EndOfCurrentBackoff()),
-          delayMillis,
-          TimeUnit.MILLISECONDS);
-    }
-  }
-
-  @Override
-  public ManagedChannel shutdown() {
-    ManagedClientTransport savedActiveTransport;
-    ConnectionClientTransport savedPendingTransport;
-    boolean runCallback = false;
-    synchronized (lock) {
-      if (shutdown) {
-        return this;
-      }
-      stateManager.gotoState(ConnectivityState.SHUTDOWN);
-      shutdown = true;
-      savedActiveTransport = activeTransport;
-      savedPendingTransport = pendingTransport;
-      activeTransport = null;
-      if (transports.isEmpty()) {
-        runCallback = true;
-        terminatedLatch.countDown();
-        if (log.isLoggable(Level.FINE)) {
-          log.log(Level.FINE, "[{0}] Terminated in shutdown()", getLogId());
-        }
-        Preconditions.checkState(reconnectTask == null, "Should have no reconnectTask scheduled");
-      }  // else: the callback will be run once all transports have been terminated
-    }
-    if (savedActiveTransport != null) {
-      savedActiveTransport.shutdown();
-    }
-    if (savedPendingTransport != null) {
-      savedPendingTransport.shutdown();
-    }
-    if (runCallback) {
-      callback.onTerminated(this);
-    }
-    return this;
-  }
-
-  void shutdownNow(Status reason) {
-    shutdown();
-    Collection<ManagedClientTransport> transportsCopy;
-    synchronized (lock) {
-      transportsCopy = new ArrayList<ManagedClientTransport>(transports);
-    }
-    for (ManagedClientTransport transport : transportsCopy) {
-      transport.shutdownNow(reason);
-    }
-  }
-
-  @Override
-  public ManagedChannel shutdownNow() {
-    shutdownNow(Status.UNAVAILABLE.withDescription("TransportSet shutdown as ManagedChannel"));
-    return this;
-  }
-
-  @GuardedBy("lock")
-  private void cancelReconnectTask() {
-    if (reconnectTask != null) {
-      reconnectTask.cancel(false);
-      reconnectTask = null;
-    }
-  }
-
-  @Override
-  public LogId getLogId() {
-    return logId;
-  }
-
-  @Override
-  public final <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
-      MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
-    return new ClientCallImpl<RequestT, ResponseT>(methodDescriptor,
-        new SerializingExecutor(appExecutor), callOptions, StatsTraceContext.NOOP,
-        new ClientTransportProvider() {
-          @Override
-          public ClientTransport get(CallOptions callOptions, Metadata headers) {
-            return obtainActiveTransport();
-          }
-        },
-        scheduledExecutor);
-  }
-
-  @Override
-  public boolean isShutdown() {
-    synchronized (lock) {
-      return shutdown;
-    }
-  }
-
-  @Override
-  public boolean isTerminated() {
-    return terminatedLatch.getCount() == 0;
-  }
-
-  @Override
-  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
-    return terminatedLatch.await(timeout, unit);
-  }
-
-  @Override
-  public String authority() {
-    return authority;
-  }
-
-  @Override
-  public ConnectivityState getState(boolean requestConnection) {
-    if (requestConnection) {
-      boolean connect = false;
-      synchronized (lock) {
-        connect = stateManager.getState() == ConnectivityState.IDLE;
-      }
-      if (connect) {
-        obtainActiveTransport();
-      }
-    }
-    synchronized (lock) {
-      return stateManager.getState();
-    }
-  }
-
-  @Override
-  public void notifyWhenStateChanged(ConnectivityState source, Runnable callback) {
-    synchronized (lock) {
-      stateManager.notifyWhenStateChanged(callback, appExecutor, source);
-    }
-  }
-
-  /** Shared base for both delayed and real transports. */
-  private class BaseTransportListener implements ManagedClientTransport.Listener {
-    protected final ManagedClientTransport transport;
-
-    public BaseTransportListener(ManagedClientTransport transport) {
-      this.transport = transport;
-    }
-
-    @Override
-    public void transportReady() {}
-
-    @Override
-    public void transportInUse(boolean inUse) {
-      Runnable r = inUseStateAggregator.updateObjectInUse(transport, inUse);
-      if (r != null) {
-        r.run();
-      }
-    }
-
-    @Override
-    public void transportShutdown(Status status) {}
-
-    @Override
-    public void transportTerminated() {
-      boolean runCallback = false;
-      Runnable r = inUseStateAggregator.updateObjectInUse(transport, false);
-      assert r == null;
-      synchronized (lock) {
-        transports.remove(transport);
-        if (shutdown && transports.isEmpty()) {
-          if (log.isLoggable(Level.FINE)) {
-            log.log(Level.FINE, "[{0}] Terminated in transportTerminated()", getLogId());
-          }
-          terminatedLatch.countDown();
-          runCallback = true;
-          cancelReconnectTask();
-        }
-      }
-      if (runCallback) {
-        callback.onTerminated(TransportSet.this);
-      }
-    }
-  }
-
-  /** Listener for real transports. */
-  private class TransportListener extends BaseTransportListener {
-    private final SocketAddress address;
-    private final DelayedClientTransport delayedTransport;
-
-    public TransportListener(ManagedClientTransport transport,
-        DelayedClientTransport delayedTransport, SocketAddress address) {
-      super(transport);
-      this.address = address;
-      this.delayedTransport = delayedTransport;
-    }
-
-    @Override
-    public void transportReady() {
-      if (log.isLoggable(Level.FINE)) {
-        log.log(Level.FINE, "[{0}] {1} for {2} is ready",
-            new Object[] {getLogId(), transport.getLogId(), address});
-      }
-      super.transportReady();
-      boolean savedShutdown;
-      synchronized (lock) {
-        savedShutdown = shutdown;
-        reconnectPolicy = null;
-        nextAddressIndex = 0;
-        if (shutdown) {
-          // If TransportSet already shutdown, transport is only to take care of pending
-          // streams in delayedTransport, but will not serve new streams, and it will be shutdown
-          // as soon as it's set to the delayedTransport.
-          // activeTransport should have already been set to null by shutdown(). We keep it null.
-          Preconditions.checkState(activeTransport == null,
-              "Unexpected non-null activeTransport");
-        } else if (activeTransport == delayedTransport) {
-          stateManager.gotoState(ConnectivityState.READY);
-          Preconditions.checkState(pendingTransport == transport, "transport mismatch");
-          activeTransport = transport;
-          pendingTransport = null;
-        }
-      }
-      delayedTransport.setTransport(transport);
-      // This delayed transport will terminate and be removed from transports.
-      delayedTransport.shutdown();
-      if (savedShutdown) {
-        // See comments in the synchronized block above on why we shutdown here.
-        transport.shutdown();
-      }
-      loadBalancer.handleTransportReady(addressGroup);
-    }
-
-    @Override
-    public void transportShutdown(Status s) {
-      boolean allAddressesFailed = false;
-      boolean closedByServer = false;
-      if (log.isLoggable(Level.FINE)) {
-        log.log(Level.FINE, "[{0}] {1} for {2} is being shutdown with status {3}",
-            new Object[] {getLogId(), transport.getLogId(), address, s});
-      }
-      super.transportShutdown(s);
-      Runnable runnable = null;
-      synchronized (lock) {
-        if (activeTransport == transport) {
-          // This is true only if the transport was ready.
-          // shutdown() should have set activeTransport to null
-          Preconditions.checkState(!shutdown, "unexpected shutdown state");
-          stateManager.gotoState(ConnectivityState.IDLE);
-          activeTransport = null;
-          closedByServer = true;
-        } else if (activeTransport == delayedTransport) {
-          // shutdown() should have set activeTransport to null
-          Preconditions.checkState(!shutdown, "unexpected shutdown state");
-          // Continue reconnect if there are still addresses to try.
-          if (nextAddressIndex == 0) {
-            allAddressesFailed = true;
-          } else {
-            Preconditions.checkState(stateManager.getState() == ConnectivityState.CONNECTING,
-                "Expected state is CONNECTING, actual state is %s", stateManager.getState());
-            runnable = startNewTransport(delayedTransport);
-          }
-        }
-      }
-      if (allAddressesFailed) {
-        // Initiate backoff
-        // Transition to TRANSIENT_FAILURE
-        scheduleBackoff(delayedTransport, s);
-      }
-      if (runnable != null) {
-        runnable.run();
-      }
-      loadBalancer.handleTransportShutdown(addressGroup, s);
-      if (allAddressesFailed) {
-        callback.onAllAddressesFailed();
-      }
-      if (closedByServer) {
-        callback.onConnectionClosedByServer(s);
-      }
-    }
-
-    @Override
-    public void transportTerminated() {
-      if (log.isLoggable(Level.FINE)) {
-        log.log(Level.FINE, "[{0}] {1} for {2} is terminated",
-            new Object[] {getLogId(), transport.getLogId(), address});
-      }
-      super.transportTerminated();
-      Preconditions.checkState(activeTransport != transport,
-          "activeTransport still points to the delayedTransport. "
-          + "Seems transportShutdown() was not called.");
-    }
-  }
-
-  abstract static class Callback {
-    /**
-     * Called when the TransportSet is terminated, which means it's shut down and all transports
-     * have been terminated.
-     */
-    public void onTerminated(TransportSet ts) { }
-
-    /**
-     * Called when all addresses have failed to connect.
-     */
-    public void onAllAddressesFailed() { }
-
-    /**
-     * Called when a once-live connection is shut down by server-side.
-     */
-    public void onConnectionClosedByServer(Status status) { }
-
-    /**
-     * Called when the TransportSet's in-use state has changed to true, which means at least one
-     * transport is in use. This method is called under a lock thus externally synchronized. If the
-     * return value is non-{@code null}, the runnable will be executed after releasing the lock.
-     */
-    @CheckReturnValue
-    public Runnable onInUse(TransportSet ts) {
-      return null;
-    }
-
-    /**
-     * Called when the TransportSet's in-use state has changed to false, which means no transport is
-     * in use. This method is called under a lock thus externally synchronized.
-     */
-    public void onNotInUse(TransportSet ts) { }
-  }
-}
diff --git a/core/src/main/java/io/grpc/internal/TransportTracer.java b/core/src/main/java/io/grpc/internal/TransportTracer.java
new file mode 100644
index 00000000000..75d56841733
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/TransportTracer.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static io.grpc.internal.TimeProvider.SYSTEM_TIME_PROVIDER;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import io.grpc.InternalChannelz.TransportStats;
+
+/**
+ * A class for gathering statistics about a transport. This is an experimental feature.
+ * Can only be called from the transport thread unless otherwise noted.
+ */
+public final class TransportTracer {
+  private static final Factory DEFAULT_FACTORY = new Factory(SYSTEM_TIME_PROVIDER);
+
+  private final TimeProvider timeProvider;
+  private long streamsStarted;
+  private long lastLocalStreamCreatedTimeNanos;
+  private long lastRemoteStreamCreatedTimeNanos;
+  private long streamsSucceeded;
+  private long streamsFailed;
+  private long keepAlivesSent;
+  private FlowControlReader flowControlWindowReader;
+
+  private long messagesSent;
+  private long lastMessageSentTimeNanos;
+  // deframing happens on the application thread, and there's no easy way to avoid synchronization
+  private final LongCounter messagesReceived = LongCounterFactory.create();
+  private volatile long lastMessageReceivedTimeNanos;
+
+  public TransportTracer() {
+    this.timeProvider = SYSTEM_TIME_PROVIDER;
+  }
+
+  private TransportTracer(TimeProvider timeProvider) {
+    this.timeProvider = timeProvider;
+  }
+
+  /**
+   * Returns a read only set of current stats.
+   */
+  public TransportStats getStats() {
+    long localFlowControlWindow =
+        flowControlWindowReader == null ? -1 : flowControlWindowReader.read().localBytes;
+    long remoteFlowControlWindow =
+        flowControlWindowReader == null ? -1 : flowControlWindowReader.read().remoteBytes;
+    return new TransportStats(
+        streamsStarted,
+        lastLocalStreamCreatedTimeNanos,
+        lastRemoteStreamCreatedTimeNanos,
+        streamsSucceeded,
+        streamsFailed,
+        messagesSent,
+        messagesReceived.value(),
+        keepAlivesSent,
+        lastMessageSentTimeNanos,
+        lastMessageReceivedTimeNanos,
+        localFlowControlWindow,
+        remoteFlowControlWindow);
+  }
+
+  /**
+   * Called by the client to report a stream has started.
+   */
+  public void reportLocalStreamStarted() {
+    streamsStarted++;
+    lastLocalStreamCreatedTimeNanos = timeProvider.currentTimeNanos();
+  }
+
+  /**
+   * Called by the server to report a stream has started.
+   */
+  public void reportRemoteStreamStarted() {
+    streamsStarted++;
+    lastRemoteStreamCreatedTimeNanos = timeProvider.currentTimeNanos();
+  }
+
+  /**
+   * Reports that a stream closed with the specified Status.
+   */
+  public void reportStreamClosed(boolean success) {
+    if (success) {
+      streamsSucceeded++;
+    } else {
+      streamsFailed++;
+    }
+  }
+
+  /**
+   * Reports that some messages were successfully sent. {@code numMessages} must be at least 0.
+   */
+  public void reportMessageSent(int numMessages) {
+    if (numMessages == 0) {
+      return;
+    }
+    messagesSent += numMessages;
+    lastMessageSentTimeNanos = timeProvider.currentTimeNanos();
+  }
+
+  /**
+   * Reports that a message was successfully received. This method is thread safe.
+   */
+  public void reportMessageReceived() {
+    messagesReceived.add(1);
+    lastMessageReceivedTimeNanos = timeProvider.currentTimeNanos();
+  }
+
+  /**
+   * Reports that a keep alive message was sent.
+   */
+  public void reportKeepAliveSent() {
+    keepAlivesSent++;
+  }
+
+  /**
+   * Registers a {@link FlowControlReader} that can be used to read the local and remote flow
+   * control window sizes.
+   */
+  public void setFlowControlWindowReader(FlowControlReader flowControlWindowReader) {
+    this.flowControlWindowReader = Preconditions.checkNotNull(flowControlWindowReader);
+  }
+
+  /**
+   * A container that holds the local and remote flow control window sizes.
+   */
+  public static final class FlowControlWindows {
+    public final long remoteBytes;
+    public final long localBytes;
+
+    public FlowControlWindows(long localBytes, long remoteBytes) {
+      this.localBytes = localBytes;
+      this.remoteBytes = remoteBytes;
+    }
+  }
+
+  /**
+   * An interface for reading the local and remote flow control windows of the transport.
+   */
+  public interface FlowControlReader {
+    FlowControlWindows read();
+  }
+
+  public static final class Factory {
+    private final TimeProvider timeProvider;
+
+    @VisibleForTesting
+    public Factory(TimeProvider timeProvider) {
+      this.timeProvider = timeProvider;
+    }
+
+    public TransportTracer create() {
+      return new TransportTracer(timeProvider);
+    }
+  }
+
+  public static Factory getDefaultFactory() {
+    return DEFAULT_FACTORY;
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/UriWrapper.java b/core/src/main/java/io/grpc/internal/UriWrapper.java
new file mode 100644
index 00000000000..ca5835cabd8
--- /dev/null
+++ b/core/src/main/java/io/grpc/internal/UriWrapper.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2025 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.NameResolver;
+import io.grpc.Uri;
+import java.net.URI;
+import javax.annotation.Nullable;
+
+/** Temporary wrapper for a URI-like object to ease the migration to io.grpc.Uri. */
+interface UriWrapper {
+
+  static UriWrapper wrap(URI uri) {
+    return new JavaNetUriWrapper(uri);
+  }
+
+  static UriWrapper wrap(Uri uri) {
+    return new IoGrpcUriWrapper(uri);
+  }
+
+  /** Uses the given factory and args to create a {@link NameResolver} for this URI. */
+  NameResolver newNameResolver(NameResolver.Factory factory, NameResolver.Args args);
+
+  /** Returns the scheme component of this URI, e.g. "http", "mailto" or "dns". */
+  String getScheme();
+
+  /**
+   * Returns the authority component of this URI, e.g. "google.com", "127.0.0.1:8080", or null if
+   * not present.
+   */
+  @Nullable
+  String getAuthority();
+
+  /** Wraps an instance of java.net.URI. */
+  final class JavaNetUriWrapper implements UriWrapper {
+    private final URI uri;
+
+    private JavaNetUriWrapper(URI uri) {
+      this.uri = checkNotNull(uri);
+    }
+
+    @Override
+    public NameResolver newNameResolver(NameResolver.Factory factory, NameResolver.Args args) {
+      return factory.newNameResolver(uri, args);
+    }
+
+    @Override
+    public String getScheme() {
+      return uri.getScheme();
+    }
+
+    @Override
+    public String getAuthority() {
+      return uri.getAuthority();
+    }
+
+    @Override
+    public String toString() {
+      return uri.toString();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+      if (other == this) {
+        return true;
+      }
+      if (!(other instanceof JavaNetUriWrapper)) {
+        return false;
+      }
+      return uri.equals(((JavaNetUriWrapper) other).uri);
+    }
+
+    @Override
+    public int hashCode() {
+      return uri.hashCode();
+    }
+  }
+
+  /** Wraps an instance of io.grpc.Uri. */
+  final class IoGrpcUriWrapper implements UriWrapper {
+    private final Uri uri;
+
+    private IoGrpcUriWrapper(Uri uri) {
+      this.uri = checkNotNull(uri);
+    }
+
+    @Override
+    public NameResolver newNameResolver(NameResolver.Factory factory, NameResolver.Args args) {
+      return factory.newNameResolver(uri, args);
+    }
+
+    @Override
+    public String getScheme() {
+      return uri.getScheme();
+    }
+
+    @Override
+    public String getAuthority() {
+      return uri.getAuthority();
+    }
+
+    @Override
+    public String toString() {
+      return uri.toString();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+      if (other == this) {
+        return true;
+      }
+      if (!(other instanceof IoGrpcUriWrapper)) {
+        return false;
+      }
+      return uri.equals(((IoGrpcUriWrapper) other).uri);
+    }
+
+    @Override
+    public int hashCode() {
+      return uri.hashCode();
+    }
+  }
+}
diff --git a/core/src/main/java/io/grpc/internal/WithLogId.java b/core/src/main/java/io/grpc/internal/WithLogId.java
deleted file mode 100644
index 98d579d1324..00000000000
--- a/core/src/main/java/io/grpc/internal/WithLogId.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-/**
- * An object that has an ID that is unique within the JVM, primarily for debug logging.
- */
-public interface WithLogId {
-  /**
-   * Returns an ID that is primarily used in debug logs. It usually contains the class name and a
-   * numeric ID that is unique among the instances. {@link GrpcUtil#getLogId} is a canonical
-   * implementation.
-   *
-   * <p>The subclasses of this interface usually want to include the log ID in their {@link
-   * #toString} results.
-   */
-  LogId getLogId();
-}
diff --git a/core/src/main/java/io/grpc/internal/WritableBuffer.java b/core/src/main/java/io/grpc/internal/WritableBuffer.java
index 49eb01a1e85..8cb36abdedd 100644
--- a/core/src/main/java/io/grpc/internal/WritableBuffer.java
+++ b/core/src/main/java/io/grpc/internal/WritableBuffer.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
diff --git a/core/src/main/java/io/grpc/internal/WritableBufferAllocator.java b/core/src/main/java/io/grpc/internal/WritableBufferAllocator.java
index d4d337c1ae3..902b279a556 100644
--- a/core/src/main/java/io/grpc/internal/WritableBufferAllocator.java
+++ b/core/src/main/java/io/grpc/internal/WritableBufferAllocator.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
diff --git a/core/src/main/java/io/grpc/internal/package-info.java b/core/src/main/java/io/grpc/internal/package-info.java
index 17f57db1215..bd8ff8981f2 100644
--- a/core/src/main/java/io/grpc/internal/package-info.java
+++ b/core/src/main/java/io/grpc/internal/package-info.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.
  */
 
 /**
diff --git a/core/src/main/java/io/grpc/package-info.java b/core/src/main/java/io/grpc/package-info.java
deleted file mode 100644
index 93efade4196..00000000000
--- a/core/src/main/java/io/grpc/package-info.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/**
- * The gRPC core public API.
- *
- * <p>gRPC is based on a client-server model of remote procedural calls.  A client creates a
- * channel which is connected to a server.  RPCs are initiated from the client and sent to the
- * server which then responds back to the client.  When the client and server are done sending
- * messages, they half close their respective connections.  The RPC is complete as soon as the
- * server closes.
- *
- * <p>To send an RPC, first create a {@link io.grpc.Channel} using
- * {@link io.grpc.ManagedChannelBuilder#forTarget}.  When using auto generate Protobuf stubs, the
- * stub class will have constructors for wrapping the channel.  These include
- * {@code newBlockingStub}, {@code newStub}, and {@code newFutureStub} which you can use based on
- * your design.  The stub is the primary way a client interacts with a server.
- *
- * <p>To receive RPCs, create a {@link io.grpc.Server} using {@link io.grpc.ServerBuilder#forPort}.
- * The Protobuf stub will contain an abstract class called AbstractFoo, where Foo is the name of
- * your service. Extend this class, and pass an instance of it to
- * {@link io.grpc.ServerBuilder#addService}.  Once your server is built, call
- * {@link io.grpc.Server#start} to begin accepting RPCs.
- *
- * <p>Both Clients and Servers should use a custom {@link java.util.concurrent.Executor}.  The gRPC
- * runtime includes a default executor that eases testing and examples, but is not ideal for use in
- * a production environment.  See the associated documentation in the respective builders.
- *
- * <p>Clients and Servers can also be gracefully shutdown gracefully using the {@code shutdown}
- * method.  The API to conduct an orderly shutdown is modeled from the
- * {@link java.util.concurrent.ExecutorService}.
- *
- * <p>gRPC also includes support for more advanced features, such as name resolution, load
- * balancing, bidirectional streaming, health checking, and more.  See the relative methods in the
- * client and server builders.
- *
- * <p>Development of gRPC is done primary on Github at
- * <a href="https://github.com/grpc/grpc-java">https://github.com/grpc/grpc-java</a>, where the gRPC
- * team welcomes contributions and bug reports.  There is also a mailing list at
- * <a href="https://groups.google.com/forum/#!forum/grpc-io">grpc-io</a> if you have questions
- * about gRPC.
- */
-package io.grpc;
diff --git a/core/src/main/java/io/grpc/util/MutableHandlerRegistry.java b/core/src/main/java/io/grpc/util/MutableHandlerRegistry.java
deleted file mode 100644
index 06a1c06a945..00000000000
--- a/core/src/main/java/io/grpc/util/MutableHandlerRegistry.java
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.util;
-
-import io.grpc.BindableService;
-import io.grpc.ExperimentalApi;
-import io.grpc.HandlerRegistry;
-import io.grpc.MethodDescriptor;
-import io.grpc.ServerMethodDefinition;
-import io.grpc.ServerServiceDefinition;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.ThreadSafe;
-
-/**
- * Default implementation of {@link MutableHandlerRegistry}.
- *
- * <p>Uses {@link ConcurrentHashMap} to avoid service registration excessively
- * blocking method lookup.
- */
-@ThreadSafe
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/933")
-public final class MutableHandlerRegistry extends HandlerRegistry {
-  private final ConcurrentMap<String, ServerServiceDefinition> services
-      = new ConcurrentHashMap<String, ServerServiceDefinition>();
-
-  /**
-   * Registers a service.
-   *
-   * @return the previously registered service with the same service descriptor name if exists,
-   *         otherwise {@code null}.
-   */
-  @Nullable
-  public ServerServiceDefinition addService(ServerServiceDefinition service) {
-    return services.put(service.getServiceDescriptor().getName(), service);
-  }
-
-  /**
-   * Registers a service.
-   *
-   * @return the previously registered service with the same service descriptor name if exists,
-   *         otherwise {@code null}.
-   */
-  @Nullable
-  public ServerServiceDefinition addService(BindableService bindableService) {
-    return addService(bindableService.bindService());
-  }
-
-  public boolean removeService(ServerServiceDefinition service) {
-    return services.remove(service.getServiceDescriptor().getName(), service);
-  }
-
-  /**
-   *  Note: This does not necessarily return a consistent view of the map.
-   */
-  @Override
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
-  public List<ServerServiceDefinition> getServices() {
-    return Collections.unmodifiableList(new ArrayList<ServerServiceDefinition>(services.values()));
-  }
-
-  /**
-   * Note: This does not actually honor the authority provided.  It will, eventually in the future.
-   */
-  @Override
-  @Nullable
-  public ServerMethodDefinition<?, ?> lookupMethod(String methodName, @Nullable String authority) {
-    String serviceName = MethodDescriptor.extractFullServiceName(methodName);
-    if (serviceName == null) {
-      return null;
-    }
-    ServerServiceDefinition service = services.get(serviceName);
-    if (service == null) {
-      return null;
-    }
-    return service.getMethod(methodName);
-  }
-}
diff --git a/core/src/main/java/io/grpc/util/RoundRobinLoadBalancerFactory.java b/core/src/main/java/io/grpc/util/RoundRobinLoadBalancerFactory.java
deleted file mode 100644
index 83516178f1b..00000000000
--- a/core/src/main/java/io/grpc/util/RoundRobinLoadBalancerFactory.java
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.util;
-
-import com.google.common.base.Supplier;
-import io.grpc.Attributes;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.ExperimentalApi;
-import io.grpc.LoadBalancer;
-import io.grpc.NameResolver;
-import io.grpc.ResolvedServerInfoGroup;
-import io.grpc.Status;
-import io.grpc.TransportManager;
-import io.grpc.TransportManager.InterimTransport;
-import io.grpc.internal.RoundRobinServerList;
-import java.util.ArrayList;
-import java.util.List;
-import javax.annotation.concurrent.GuardedBy;
-
-
-/**
- * A {@link LoadBalancer} that provides round-robin load balancing mechanism over the
- * addresses from the {@link NameResolver}.  The sub-lists received from the name resolver
- * are considered to be an {@link EquivalentAddressGroup} and each of these sub-lists is
- * what is then balanced across.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
-public final class RoundRobinLoadBalancerFactory extends LoadBalancer.Factory {
-
-  private static final RoundRobinLoadBalancerFactory instance = new RoundRobinLoadBalancerFactory();
-
-  private RoundRobinLoadBalancerFactory() {
-  }
-
-  public static RoundRobinLoadBalancerFactory getInstance() {
-    return instance;
-  }
-
-  @Override
-  public <T> LoadBalancer<T> newLoadBalancer(String serviceName, TransportManager<T> tm) {
-    return new RoundRobinLoadBalancer<T>(tm);
-  }
-
-  private static class RoundRobinLoadBalancer<T> extends LoadBalancer<T> {
-    private static final Status SHUTDOWN_STATUS =
-        Status.UNAVAILABLE.augmentDescription("RoundRobinLoadBalancer has shut down");
-
-    private final Object lock = new Object();
-
-    @GuardedBy("lock")
-    private RoundRobinServerList<T> addresses;
-    @GuardedBy("lock")
-    private InterimTransport<T> interimTransport;
-    @GuardedBy("lock")
-    private Status nameResolutionError;
-    @GuardedBy("lock")
-    private boolean closed;
-
-    private final TransportManager<T> tm;
-
-    private RoundRobinLoadBalancer(TransportManager<T> tm) {
-      this.tm = tm;
-    }
-
-    @Override
-    public T pickTransport(Attributes affinity) {
-      final RoundRobinServerList<T> addressesCopy;
-      synchronized (lock) {
-        if (closed) {
-          return tm.createFailingTransport(SHUTDOWN_STATUS);
-        }
-        if (addresses == null) {
-          if (nameResolutionError != null) {
-            return tm.createFailingTransport(nameResolutionError);
-          }
-          if (interimTransport == null) {
-            interimTransport = tm.createInterimTransport();
-          }
-          return interimTransport.transport();
-        }
-        addressesCopy = addresses;
-      }
-      return addressesCopy.getTransportForNextServer();
-    }
-
-    @Override
-    public void handleResolvedAddresses(List<ResolvedServerInfoGroup> updatedServers,
-        Attributes attributes) {
-      final InterimTransport<T> savedInterimTransport;
-      final RoundRobinServerList<T> addressesCopy;
-      synchronized (lock) {
-        if (closed) {
-          return;
-        }
-        addresses = new RoundRobinServerList.Builder<T>(tm).addAll(
-            resolvedServerInfoGroupToEquivalentAddressGroup(updatedServers)).build();
-        addressesCopy = addresses;
-        nameResolutionError = null;
-        savedInterimTransport = interimTransport;
-        interimTransport = null;
-      }
-      if (savedInterimTransport != null) {
-        savedInterimTransport.closeWithRealTransports(new Supplier<T>() {
-            @Override public T get() {
-              return addressesCopy.getTransportForNextServer();
-            }
-          });
-      }
-    }
-
-    @Override
-    public void handleNameResolutionError(Status error) {
-      InterimTransport<T> savedInterimTransport;
-      synchronized (lock) {
-        if (closed) {
-          return;
-        }
-        error = error.augmentDescription("Name resolution failed");
-        savedInterimTransport = interimTransport;
-        interimTransport = null;
-        nameResolutionError = error;
-      }
-      if (savedInterimTransport != null) {
-        savedInterimTransport.closeWithError(error);
-      }
-    }
-
-    @Override
-    public void shutdown() {
-      InterimTransport<T> savedInterimTransport;
-      synchronized (lock) {
-        if (closed) {
-          return;
-        }
-        closed = true;
-        savedInterimTransport = interimTransport;
-        interimTransport = null;
-      }
-      if (savedInterimTransport != null) {
-        savedInterimTransport.closeWithError(SHUTDOWN_STATUS);
-      }
-    }
-
-    private static List<EquivalentAddressGroup> resolvedServerInfoGroupToEquivalentAddressGroup(
-        List<ResolvedServerInfoGroup> groupList) {
-      List<EquivalentAddressGroup> addrs = new ArrayList<EquivalentAddressGroup>(groupList.size());
-      for (ResolvedServerInfoGroup group : groupList) {
-        addrs.add(group.toEquivalentAddressGroup());
-      }
-      return addrs;
-    }
-  }
-}
diff --git a/core/src/main/java/io/grpc/util/RoundRobinLoadBalancerFactory2.java b/core/src/main/java/io/grpc/util/RoundRobinLoadBalancerFactory2.java
deleted file mode 100644
index a3d9e6a5b27..00000000000
--- a/core/src/main/java/io/grpc/util/RoundRobinLoadBalancerFactory2.java
+++ /dev/null
@@ -1,292 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.util;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static io.grpc.ConnectivityState.IDLE;
-import static io.grpc.ConnectivityState.READY;
-import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
-
-import com.google.common.annotations.VisibleForTesting;
-import io.grpc.Attributes;
-import io.grpc.ConnectivityStateInfo;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.ExperimentalApi;
-import io.grpc.LoadBalancer;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.Subchannel;
-import io.grpc.LoadBalancer2.SubchannelPicker;
-import io.grpc.Metadata;
-import io.grpc.NameResolver;
-import io.grpc.ResolvedServerInfo;
-import io.grpc.ResolvedServerInfoGroup;
-import io.grpc.Status;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicReference;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
-
-/**
- * A {@link LoadBalancer} that provides round-robin load balancing mechanism over the
- * addresses from the {@link NameResolver}.  The sub-lists received from the name resolver
- * are considered to be an {@link EquivalentAddressGroup} and each of these sub-lists is
- * what is then balanced across.
- *
- * <p><strong>TECHNICAL PREVIEW: </strong>The name of this class is temporary. It will be renamed to
- * {@code RoundRobinLoadBalancerFactory} during the
- * <a href="https://github.com/grpc/grpc-java/issues/2656" target="_blank">transition to LBv2</a>.
- * You should use it only if you want to experiment the LBv2 code path.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
-public class RoundRobinLoadBalancerFactory2 extends LoadBalancer2.Factory {
-  private static final RoundRobinLoadBalancerFactory2 INSTANCE =
-      new RoundRobinLoadBalancerFactory2();
-
-  private RoundRobinLoadBalancerFactory2() {
-  }
-
-  public static RoundRobinLoadBalancerFactory2 getInstance() {
-    return INSTANCE;
-  }
-
-  @Override
-  public LoadBalancer2 newLoadBalancer(LoadBalancer2.Helper helper) {
-    return new RoundRobinLoadBalancer(helper);
-  }
-
-  @VisibleForTesting
-  static class RoundRobinLoadBalancer extends LoadBalancer2 {
-    private final Helper helper;
-    private final Map<EquivalentAddressGroup, Subchannel> subchannels =
-        new HashMap<EquivalentAddressGroup, Subchannel>();
-
-    @VisibleForTesting
-    static final Attributes.Key<AtomicReference<ConnectivityStateInfo>> STATE_INFO =
-        Attributes.Key.of("state-info");
-
-    public RoundRobinLoadBalancer(Helper helper) {
-      this.helper = helper;
-    }
-
-    @Override
-    public void handleResolvedAddresses(List<ResolvedServerInfoGroup> servers,
-        Attributes attributes) {
-      Set<EquivalentAddressGroup> currentAddrs = subchannels.keySet();
-      Set<EquivalentAddressGroup> latestAddrs =
-          resolvedServerInfoGroupToEquivalentAddressGroup(servers);
-      Set<EquivalentAddressGroup> addedAddrs = setsDifference(latestAddrs, currentAddrs);
-      Set<EquivalentAddressGroup> removedAddrs = setsDifference(currentAddrs, latestAddrs);
-
-      // NB(lukaszx0): we don't merge `attributes` with `subchannelAttr` because subchannel doesn't
-      // need them. They're describing the resolved server list but we're not taking any action
-      // based on this information.
-      Attributes subchannelAttrs = Attributes.newBuilder()
-          // NB(lukaszx0): because attributes are immutable we can't set new value for the key
-          // after creation but since we can mutate the values we leverge that and set
-          // AtomicReference which will allow mutating state info for given channel.
-          .set(STATE_INFO, new AtomicReference<ConnectivityStateInfo>(
-              ConnectivityStateInfo.forNonError(IDLE)))
-          .build();
-
-      // Create new subchannels for new addresses.
-      for (EquivalentAddressGroup addressGroup : addedAddrs) {
-        Subchannel subchannel = checkNotNull(helper.createSubchannel(addressGroup, subchannelAttrs),
-            "subchannel");
-        subchannels.put(addressGroup, subchannel);
-        subchannel.requestConnection();
-      }
-
-      // Shutdown subchannels for removed addresses.
-      for (EquivalentAddressGroup addressGroup : removedAddrs) {
-        Subchannel subchannel = subchannels.remove(addressGroup);
-        subchannel.shutdown();
-      }
-
-      updatePicker(getAggregatedError());
-    }
-
-    @Override
-    public void handleNameResolutionError(Status error) {
-      updatePicker(error);
-    }
-
-    @Override
-    public void handleSubchannelState(Subchannel subchannel, ConnectivityStateInfo stateInfo) {
-      if (!subchannels.containsValue(subchannel)) {
-        return;
-      }
-      if (stateInfo.getState() == IDLE) {
-        subchannel.requestConnection();
-      }
-      getSubchannelStateInfoRef(subchannel).set(stateInfo);
-      updatePicker(getAggregatedError());
-    }
-
-    @Override
-    public void shutdown() {
-      for (Subchannel subchannel : getSubchannels()) {
-        subchannel.shutdown();
-      }
-    }
-
-    /**
-     * Updates picker with the list of active subchannels (state == READY).
-     */
-    private void updatePicker(@Nullable Status error) {
-      List<Subchannel> activeList = filterNonFailingSubchannels(getSubchannels());
-      helper.updatePicker(new Picker(activeList, error));
-    }
-
-    /**
-     * Filters out non-ready subchannels.
-     */
-    private static List<Subchannel> filterNonFailingSubchannels(
-        Collection<Subchannel> subchannels) {
-      List<Subchannel> readySubchannels = new ArrayList<Subchannel>(subchannels.size());
-      for (Subchannel subchannel : subchannels) {
-        if (getSubchannelStateInfoRef(subchannel).get().getState() == READY) {
-          readySubchannels.add(subchannel);
-        }
-      }
-      return readySubchannels;
-    }
-
-    /**
-     * Converts list of {@link ResolvedServerInfoGroup} to {@link EquivalentAddressGroup} set.
-     */
-    private static Set<EquivalentAddressGroup> resolvedServerInfoGroupToEquivalentAddressGroup(
-        List<ResolvedServerInfoGroup> groupList) {
-      Set<EquivalentAddressGroup> addrs = new HashSet<EquivalentAddressGroup>();
-      for (ResolvedServerInfoGroup group : groupList) {
-        for (ResolvedServerInfo server : group.getResolvedServerInfoList()) {
-          addrs.add(new EquivalentAddressGroup(server.getAddress()));
-        }
-      }
-      return addrs;
-    }
-
-    /**
-     * If all subchannels are TRANSIENT_FAILURE, return the Status associated with an arbitrary
-     * subchannel otherwise, return null.
-     */
-    @Nullable
-    private Status getAggregatedError() {
-      Status status = null;
-      for (Subchannel subchannel : getSubchannels()) {
-        ConnectivityStateInfo stateInfo = getSubchannelStateInfoRef(subchannel).get();
-        if (stateInfo.getState() != TRANSIENT_FAILURE) {
-          return null;
-        }
-        status = stateInfo.getStatus();
-      }
-      return status;
-    }
-
-    @VisibleForTesting
-    Collection<Subchannel> getSubchannels() {
-      return subchannels.values();
-    }
-
-    private static AtomicReference<ConnectivityStateInfo> getSubchannelStateInfoRef(
-        Subchannel subchannel) {
-      return checkNotNull(subchannel.getAttributes().get(STATE_INFO), "STATE_INFO");
-    }
-
-    private static <T> Set<T> setsDifference(Set<T> a, Set<T> b) {
-      Set<T> aCopy = new HashSet<T>(a);
-      aCopy.removeAll(b);
-      return aCopy;
-    }
-  }
-
-  @VisibleForTesting
-  static class Picker extends SubchannelPicker {
-    @Nullable
-    private final Status status;
-    private final List<Subchannel> list;
-    private final int size;
-    @GuardedBy("this")
-    private int index = 0;
-
-    Picker(List<Subchannel> list, @Nullable Status status) {
-      this.list = Collections.unmodifiableList(list);
-      this.size = list.size();
-      this.status = status;
-    }
-
-    @Override
-    public PickResult pickSubchannel(Attributes affinity, Metadata headers) {
-      if (size > 0) {
-        return PickResult.withSubchannel(nextSubchannel());
-      }
-
-      if (status != null) {
-        return PickResult.withError(status);
-      }
-
-      return PickResult.withNoResult();
-    }
-
-    private Subchannel nextSubchannel() {
-      if (size == 0) {
-        throw new NoSuchElementException();
-      }
-      synchronized (this) {
-        Subchannel val = list.get(index);
-        index++;
-        if (index >= size) {
-          index = 0;
-        }
-        return val;
-      }
-    }
-
-    @VisibleForTesting
-    List<Subchannel> getList() {
-      return list;
-    }
-
-    @VisibleForTesting
-    Status getStatus() {
-      return status;
-    }
-  }
-}
diff --git a/core/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider b/core/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
new file mode 100644
index 00000000000..bbc367f8fc5
--- /dev/null
+++ b/core/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
@@ -0,0 +1 @@
+io.grpc.internal.PickFirstLoadBalancerProvider
diff --git a/core/src/test/java/io/grpc/AttributesTest.java b/core/src/test/java/io/grpc/AttributesTest.java
deleted file mode 100644
index 3f09c5c1c9a..00000000000
--- a/core/src/test/java/io/grpc/AttributesTest.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link Attributes}. */
-@RunWith(JUnit4.class)
-public class AttributesTest {
-  private static Attributes.Key<String> YOLO_KEY = Attributes.Key.of("yolo");
-
-  @Test
-  public void buildAttributes() {
-    Attributes attrs = Attributes.newBuilder().set(YOLO_KEY, "To be, or not to be?").build();
-    assertSame("To be, or not to be?", attrs.get(YOLO_KEY));
-    assertEquals(1, attrs.keys().size());
-  }
-
-  @Test
-  public void duplicates() {
-    Attributes attrs = Attributes.newBuilder()
-            .set(YOLO_KEY, "To be?")
-            .set(YOLO_KEY, "Or not to be?")
-            .set(Attributes.Key.of("yolo"), "I'm not a duplicate")
-            .build();
-    assertSame("Or not to be?", attrs.get(YOLO_KEY));
-    assertEquals(2, attrs.keys().size());
-  }
-
-  @Test
-  public void empty() {
-    assertEquals(0, Attributes.EMPTY.keys().size());
-  }
-}
diff --git a/core/src/test/java/io/grpc/CallOptionsTest.java b/core/src/test/java/io/grpc/CallOptionsTest.java
deleted file mode 100644
index 9544e17269a..00000000000
--- a/core/src/test/java/io/grpc/CallOptionsTest.java
+++ /dev/null
@@ -1,243 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.truth.Truth.assertAbout;
-import static com.google.common.truth.Truth.assertThat;
-import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
-import static io.grpc.testing.DeadlineSubject.deadline;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import static java.util.concurrent.TimeUnit.MINUTES;
-import static java.util.concurrent.TimeUnit.NANOSECONDS;
-import static java.util.concurrent.TimeUnit.SECONDS;
-import static org.mockito.Mockito.mock;
-
-import com.google.common.base.Objects;
-import io.grpc.Attributes.Key;
-import io.grpc.internal.SerializingExecutor;
-import java.util.concurrent.Executor;
-import java.util.concurrent.TimeUnit;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link CallOptions}. */
-@RunWith(JUnit4.class)
-public class CallOptionsTest {
-  private String sampleAuthority = "authority";
-  private String sampleCompressor = "compressor";
-  private Deadline.Ticker ticker = new FakeTicker();
-  private Deadline sampleDeadline = Deadline.after(1, NANOSECONDS, ticker);
-  private Key<String> sampleKey = Attributes.Key.of("sample");
-  private Attributes sampleAffinity = Attributes.newBuilder().set(sampleKey, "blah").build();
-  private CallCredentials sampleCreds = mock(CallCredentials.class);
-  private CallOptions.Key<String> option1 = CallOptions.Key.of("option1", "default");
-  private CallOptions.Key<String> option2 = CallOptions.Key.of("option2", "default");
-  private CallOptions allSet = CallOptions.DEFAULT
-      .withAuthority(sampleAuthority)
-      .withDeadline(sampleDeadline)
-      .withAffinity(sampleAffinity)
-      .withCallCredentials(sampleCreds)
-      .withCompression(sampleCompressor)
-      .withWaitForReady()
-      .withExecutor(directExecutor())
-      .withOption(option1, "value1")
-      .withOption(option2, "value2");
-
-  @Test
-  public void defaultsAreAllNull() {
-    assertThat(CallOptions.DEFAULT.getDeadline()).isNull();
-    assertThat(CallOptions.DEFAULT.getAuthority()).isNull();
-    assertThat(CallOptions.DEFAULT.getAffinity()).isEqualTo(Attributes.EMPTY);
-    assertThat(CallOptions.DEFAULT.getExecutor()).isNull();
-    assertThat(CallOptions.DEFAULT.getCredentials()).isNull();
-    assertThat(CallOptions.DEFAULT.getCompressor()).isNull();
-    assertThat(CallOptions.DEFAULT.isWaitForReady()).isFalse();
-  }
-
-  @Test
-  public void withAndWithoutWaitForReady() {
-    assertThat(CallOptions.DEFAULT.withWaitForReady().isWaitForReady()).isTrue();
-    assertThat(CallOptions.DEFAULT.withWaitForReady().withoutWaitForReady().isWaitForReady())
-        .isFalse();
-  }
-
-  @Test
-  public void allWiths() {
-    assertThat(allSet.getAuthority()).isSameAs(sampleAuthority);
-    assertThat(allSet.getDeadline()).isSameAs(sampleDeadline);
-    assertThat(allSet.getAffinity()).isSameAs(sampleAffinity);
-    assertThat(allSet.getCredentials()).isSameAs(sampleCreds);
-    assertThat(allSet.getCompressor()).isSameAs(sampleCompressor);
-    assertThat(allSet.getExecutor()).isSameAs(directExecutor());
-    assertThat(allSet.getOption(option1)).isSameAs("value1");
-    assertThat(allSet.getOption(option2)).isSameAs("value2");
-    assertThat(allSet.isWaitForReady()).isTrue();
-  }
-
-  @Test
-  public void noStrayModifications() {
-    assertThat(equal(allSet, allSet.withAuthority("blah").withAuthority(sampleAuthority)))
-        .isTrue();
-    assertThat(
-        equal(allSet,
-            allSet.withDeadline(Deadline.after(314, NANOSECONDS)).withDeadline(sampleDeadline)))
-        .isTrue();
-    assertThat(
-        equal(allSet,
-            allSet.withAffinity(Attributes.EMPTY).withAffinity(sampleAffinity)))
-        .isTrue();
-    assertThat(
-        equal(allSet,
-            allSet.withCallCredentials(mock(CallCredentials.class))
-            .withCallCredentials(sampleCreds)))
-        .isTrue();
-  }
-
-  @Test
-  public void mutation() {
-    Deadline deadline = Deadline.after(10, SECONDS);
-    CallOptions options1 = CallOptions.DEFAULT.withDeadline(deadline);
-    assertThat(CallOptions.DEFAULT.getDeadline()).isNull();
-    assertThat(deadline).isSameAs(options1.getDeadline());
-
-    CallOptions options2 = options1.withDeadline(null);
-    assertThat(deadline).isSameAs(options1.getDeadline());
-    assertThat(options2.getDeadline()).isNull();
-  }
-
-  @Test
-  public void mutateExecutor() {
-    Executor executor = directExecutor();
-    CallOptions options1 = CallOptions.DEFAULT.withExecutor(executor);
-    assertThat(CallOptions.DEFAULT.getExecutor()).isNull();
-    assertThat(executor).isSameAs(options1.getExecutor());
-
-    CallOptions options2 = options1.withExecutor(null);
-    assertThat(executor).isSameAs(options1.getExecutor());
-    assertThat(options2.getExecutor()).isNull();
-  }
-
-  @Test
-  public void withDeadlineAfter() {
-    Deadline actual = CallOptions.DEFAULT.withDeadlineAfter(1, MINUTES).getDeadline();
-    Deadline expected = Deadline.after(1, MINUTES);
-
-    assertAbout(deadline()).that(actual).isWithin(10, MILLISECONDS).of(expected);
-  }
-
-  @Test
-  public void toStringMatches_noDeadline_default() {
-    String actual = allSet
-        .withDeadline(null)
-        .withExecutor(new SerializingExecutor(directExecutor()))
-        .withCallCredentials(null)
-        .withMaxInboundMessageSize(44)
-        .withMaxOutboundMessageSize(55)
-        .toString();
-
-    assertThat(actual).contains("deadline=null");
-    assertThat(actual).contains("authority=authority");
-    assertThat(actual).contains("callCredentials=null");
-    assertThat(actual).contains("affinity={sample=blah}");
-    assertThat(actual).contains("executor=class io.grpc.internal.SerializingExecutor");
-    assertThat(actual).contains("compressorName=compressor");
-    assertThat(actual).contains("customOptions=[[option1, value1], [option2, value2]]");
-    assertThat(actual).contains("waitForReady=true");
-    assertThat(actual).contains("maxInboundMessageSize=44");
-    assertThat(actual).contains("maxOutboundMessageSize=55");
-  }
-
-  @Test
-  public void toStringMatches_noDeadline() {
-    String actual = CallOptions.DEFAULT.toString();
-    assertThat(actual).contains("deadline=null");
-  }
-
-  @Test
-  public void toStringMatches_withDeadline() {
-    assertThat(allSet.toString()).contains("1 ns from now");
-  }
-
-  @Test
-  public void withCustomOptionDefault() {
-    CallOptions opts = CallOptions.DEFAULT;
-    assertThat(opts.getOption(option1)).isEqualTo("default");
-  }
-
-  @Test
-  public void withCustomOption() {
-    CallOptions opts = CallOptions.DEFAULT.withOption(option1, "v1");
-    assertThat(opts.getOption(option1)).isEqualTo("v1");
-  }
-
-  @Test
-  public void withCustomOptionLastOneWins() {
-    CallOptions opts = CallOptions.DEFAULT.withOption(option1, "v1").withOption(option1, "v2");
-    assertThat(opts.getOption(option1)).isEqualTo("v2");
-  }
-
-  @Test
-  public void withMultipleCustomOption() {
-    CallOptions opts = CallOptions.DEFAULT.withOption(option1, "v1").withOption(option2, "v2");
-    assertThat(opts.getOption(option1)).isEqualTo("v1");
-    assertThat(opts.getOption(option2)).isEqualTo("v2");
-  }
-
-  // TODO(carl-mastrangelo): consider making a CallOptionsSubject for Truth.
-  private static boolean equal(CallOptions o1, CallOptions o2) {
-    return Objects.equal(o1.getDeadline(), o2.getDeadline())
-        && Objects.equal(o1.getAuthority(), o2.getAuthority())
-        && Objects.equal(o1.getAffinity(), o2.getAffinity())
-        && Objects.equal(o1.getCredentials(), o2.getCredentials());
-  }
-
-  private static class FakeTicker extends Deadline.Ticker {
-    private long time;
-
-    @Override
-    public long read() {
-      return time;
-    }
-
-    public void reset(long time) {
-      this.time = time;
-    }
-
-    public void increment(long period, TimeUnit unit) {
-      if (period < 0) {
-        throw new IllegalArgumentException();
-      }
-      this.time += unit.toNanos(period);
-    }
-  }
-}
diff --git a/core/src/test/java/io/grpc/ConnectivityStateInfoTest.java b/core/src/test/java/io/grpc/ConnectivityStateInfoTest.java
deleted file mode 100644
index 868cf4c6f70..00000000000
--- a/core/src/test/java/io/grpc/ConnectivityStateInfoTest.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotSame;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link ConnectivityStateInfo}. */
-@RunWith(JUnit4.class)
-public class ConnectivityStateInfoTest {
-  @Test
-  public void forNonError() {
-    ConnectivityStateInfo info = ConnectivityStateInfo.forNonError(ConnectivityState.IDLE);
-    assertEquals(ConnectivityState.IDLE, info.getState());
-    assertEquals(Status.OK, info.getStatus());
-  }
-
-  @Test(expected = IllegalArgumentException.class)
-  public void forNonErrorInvalid() {
-    ConnectivityStateInfo.forNonError(ConnectivityState.TRANSIENT_FAILURE);
-  }
-
-  @Test
-  public void forTransientFailure() {
-    ConnectivityStateInfo info = ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, info.getState());
-    assertEquals(Status.UNAVAILABLE, info.getStatus());
-  }
-
-  @Test(expected = IllegalArgumentException.class)
-  public void forTransientFailureInvalid() {
-    ConnectivityStateInfo.forTransientFailure(Status.OK);
-  }
-
-  @Test
-  public void equality() {
-    ConnectivityStateInfo info1 = ConnectivityStateInfo.forNonError(ConnectivityState.IDLE);
-    ConnectivityStateInfo info2 = ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING);
-    ConnectivityStateInfo info3 = ConnectivityStateInfo.forNonError(ConnectivityState.IDLE);
-    ConnectivityStateInfo info4 = ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE);
-    ConnectivityStateInfo info5 = ConnectivityStateInfo.forTransientFailure(Status.INTERNAL);
-    ConnectivityStateInfo info6 = ConnectivityStateInfo.forTransientFailure(Status.INTERNAL);
-
-    assertEquals(info1, info3);
-    assertNotSame(info1, info3);
-    assertEquals(info1.hashCode(), info3.hashCode());
-    assertEquals(info5, info6);
-    assertEquals(info5.hashCode(), info6.hashCode());
-    assertNotSame(info5, info6);
-
-    assertNotEquals(info1, info2);
-    assertNotEquals(info1, info4);
-    assertNotEquals(info4, info6);
-
-    assertFalse(info1.equals(null));
-    assertFalse(info1.equals(this));
-  }
-}
diff --git a/core/src/test/java/io/grpc/DecompressorRegistryTest.java b/core/src/test/java/io/grpc/DecompressorRegistryTest.java
deleted file mode 100644
index 5289aa0e70a..00000000000
--- a/core/src/test/java/io/grpc/DecompressorRegistryTest.java
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.HashSet;
-import java.util.Set;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Tests for {@link DecompressorRegistry}.
- */
-@RunWith(JUnit4.class)
-public class DecompressorRegistryTest {
-
-  private final Dummy dummyDecompressor = new Dummy();
-  private DecompressorRegistry registry = DecompressorRegistry.emptyInstance();
-
-  @Test
-  public void lookupDecompressor_checkDefaultMessageEncodingsExist() {
-    // Explicitly put the names in, rather than link against MessageEncoding
-    assertNotNull("Expected identity to be registered",
-        DecompressorRegistry.getDefaultInstance().lookupDecompressor("identity"));
-    assertNotNull("Expected gzip to be registered",
-        DecompressorRegistry.getDefaultInstance().lookupDecompressor("gzip"));
-  }
-
-  @Test
-  public void getKnownMessageEncodings_checkDefaultMessageEncodingsExist() {
-    Set<String> knownEncodings = new HashSet<String>();
-    knownEncodings.add("identity");
-    knownEncodings.add("gzip");
-
-    assertEquals(knownEncodings,
-        DecompressorRegistry.getDefaultInstance().getKnownMessageEncodings());
-  }
-
-  /*
-   * This test will likely change once encoders are advertised
-   */
-  @Test
-  public void getAdvertisedMessageEncodings_noEncodingsAdvertised() {
-    assertTrue(registry.getAdvertisedMessageEncodings().isEmpty());
-  }
-
-  @Test
-  public void registerDecompressor_advertisedDecompressor() {
-    registry = registry.with(dummyDecompressor, true);
-
-    assertTrue(registry.getAdvertisedMessageEncodings()
-        .contains(dummyDecompressor.getMessageEncoding()));
-  }
-
-  @Test
-  public void registerDecompressor_nonadvertisedDecompressor() {
-    registry = registry.with(dummyDecompressor, false);
-
-    assertFalse(registry.getAdvertisedMessageEncodings()
-        .contains(dummyDecompressor.getMessageEncoding()));
-  }
-
-  private static final class Dummy implements Decompressor {
-    @Override
-    public String getMessageEncoding() {
-      return "dummy";
-    }
-
-    @Override
-    public InputStream decompress(InputStream is) throws IOException {
-      return is;
-    }
-  }
-}
-
diff --git a/core/src/test/java/io/grpc/ForwardingServerCallListenerTest.java b/core/src/test/java/io/grpc/ForwardingServerCallListenerTest.java
deleted file mode 100644
index e8031062ef7..00000000000
--- a/core/src/test/java/io/grpc/ForwardingServerCallListenerTest.java
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.mockito.Mockito.verify;
-
-import io.grpc.ForwardingServerCallListener.SimpleForwardingServerCallListener;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-@RunWith(JUnit4.class)
-public class ForwardingServerCallListenerTest {
-
-  @Mock private ServerCall.Listener<Void> serverCallListener;
-  private ForwardingServerCallListener<Void> forwarder;
-
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    forwarder = new SimpleForwardingServerCallListener<Void>(serverCallListener) {};
-  }
-
-  @Test
-  public void onMessage() {
-    forwarder.onMessage(null);
-
-    verify(serverCallListener).onMessage(null);
-  }
-
-  @Test
-  public void onHalfClose() {
-    forwarder.onHalfClose();
-
-    verify(serverCallListener).onHalfClose();
-  }
-
-  @Test
-  public void onCancel() {
-    forwarder.onCancel();
-
-    verify(serverCallListener).onCancel();
-  }
-
-  @Test
-  public void onComplete() {
-    forwarder.onComplete();
-
-    verify(serverCallListener).onComplete();
-  }
-
-  @Test
-  public void onReady() {
-    forwarder.onReady();
-
-    verify(serverCallListener).onReady();
-  }
-}
-
diff --git a/core/src/test/java/io/grpc/IntegerMarshaller.java b/core/src/test/java/io/grpc/IntegerMarshaller.java
deleted file mode 100644
index b1e428c9914..00000000000
--- a/core/src/test/java/io/grpc/IntegerMarshaller.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.io.InputStream;
-
-/** Marshalls decimal-encoded integers. */
-public class IntegerMarshaller implements MethodDescriptor.Marshaller<Integer> {
-  public static IntegerMarshaller INSTANCE = new IntegerMarshaller();
-
-  @Override
-  public InputStream stream(Integer value) {
-    return StringMarshaller.INSTANCE.stream(value.toString());
-  }
-
-  @Override
-  public Integer parse(InputStream stream) {
-    return Integer.valueOf(StringMarshaller.INSTANCE.parse(stream));
-  }
-}
diff --git a/core/src/test/java/io/grpc/ManagedChannelProviderTest.java b/core/src/test/java/io/grpc/ManagedChannelProviderTest.java
deleted file mode 100644
index 484de1ec89e..00000000000
--- a/core/src/test/java/io/grpc/ManagedChannelProviderTest.java
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-import java.util.ServiceConfigurationError;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link ManagedChannelProvider}. */
-@RunWith(JUnit4.class)
-public class ManagedChannelProviderTest {
-  private final String serviceFile = "META-INF/services/io.grpc.ManagedChannelProvider";
-
-  @Test(expected = ManagedChannelProvider.ProviderNotFoundException.class)
-  public void noProvider() {
-    ManagedChannelProvider.provider();
-  }
-
-  @Test
-  public void multipleProvider() {
-    ClassLoader cl = new ReplacingClassLoader(getClass().getClassLoader(), serviceFile,
-        "io/grpc/ManagedChannelProviderTest-multipleProvider.txt");
-    assertSame(Available7Provider.class, ManagedChannelProvider.load(cl).getClass());
-  }
-
-  @Test
-  public void unavailableProvider() {
-    ClassLoader cl = new ReplacingClassLoader(getClass().getClassLoader(), serviceFile,
-        "io/grpc/ManagedChannelProviderTest-unavailableProvider.txt");
-    assertNull(ManagedChannelProvider.load(cl));
-  }
-
-  @Test
-  public void getCandidatesViaHardCoded_usesProvidedClassLoader() {
-    final RuntimeException toThrow = new RuntimeException();
-    try {
-      ManagedChannelProvider.getCandidatesViaHardCoded(new ClassLoader() {
-        @Override
-        public Class<?> loadClass(String name) {
-          throw toThrow;
-        }
-      });
-      fail("Expected exception");
-    } catch (RuntimeException ex) {
-      assertSame(toThrow, ex);
-    }
-  }
-
-  @Test
-  public void getCandidatesViaHardCoded_ignoresMissingClasses() {
-    Iterable<ManagedChannelProvider> i =
-        ManagedChannelProvider.getCandidatesViaHardCoded(new ClassLoader() {
-          @Override
-          public Class<?> loadClass(String name) throws ClassNotFoundException {
-            throw new ClassNotFoundException();
-          }
-        });
-    assertFalse("Iterator should be empty", i.iterator().hasNext());
-  }
-
-  @Test
-  public void create_throwsErrorOnMisconfiguration() throws Exception {
-    class PrivateClass {}
-
-    try {
-      ManagedChannelProvider.create(PrivateClass.class);
-      fail("Expected exception");
-    } catch (ServiceConfigurationError e) {
-      assertTrue("Expected ClassCastException cause: " + e.getCause(),
-          e.getCause() instanceof ClassCastException);
-    }
-  }
-
-  private static class BaseProvider extends ManagedChannelProvider {
-    private final boolean isAvailable;
-    private final int priority;
-
-    public BaseProvider(boolean isAvailable, int priority) {
-      this.isAvailable = isAvailable;
-      this.priority = priority;
-    }
-
-    @Override
-    protected boolean isAvailable() {
-      return isAvailable;
-    }
-
-    @Override
-    protected int priority() {
-      return priority;
-    }
-
-    @Override
-    protected ManagedChannelBuilder<?> builderForAddress(String host, int port) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override
-    protected ManagedChannelBuilder<?> builderForTarget(String target) {
-      throw new UnsupportedOperationException();
-    }
-  }
-
-  public static class Available0Provider extends BaseProvider {
-    public Available0Provider() {
-      super(true, 0);
-    }
-  }
-
-  public static class Available5Provider extends BaseProvider {
-    public Available5Provider() {
-      super(true, 5);
-    }
-  }
-
-  public static class Available7Provider extends BaseProvider {
-    public Available7Provider() {
-      super(true, 7);
-    }
-  }
-
-  public static class UnavailableProvider extends BaseProvider {
-    public UnavailableProvider() {
-      super(false, 10);
-    }
-
-    @Override
-    protected int priority() {
-      throw new RuntimeException("purposefully broken");
-    }
-  }
-}
diff --git a/core/src/test/java/io/grpc/MetadataTest.java b/core/src/test/java/io/grpc/MetadataTest.java
deleted file mode 100644
index c263e2931c0..00000000000
--- a/core/src/test/java/io/grpc/MetadataTest.java
+++ /dev/null
@@ -1,395 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.base.Charsets.US_ASCII;
-import static com.google.common.base.Charsets.UTF_8;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-import com.google.common.collect.Lists;
-import io.grpc.Metadata.Key;
-import io.grpc.internal.GrpcUtil;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.Locale;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Tests for {@link Metadata}.
- */
-@RunWith(JUnit4.class)
-public class MetadataTest {
-
-  @Rule public final ExpectedException thrown = ExpectedException.none();
-
-  private static final Metadata.BinaryMarshaller<Fish> FISH_MARSHALLER =
-      new Metadata.BinaryMarshaller<Fish>() {
-    @Override
-    public byte[] toBytes(Fish fish) {
-      return fish.name.getBytes(UTF_8);
-    }
-
-    @Override
-    public Fish parseBytes(byte[] serialized) {
-      return new Fish(new String(serialized, UTF_8));
-    }
-  };
-
-  private static final String LANCE = "lance";
-  private static final byte[] LANCE_BYTES = LANCE.getBytes(US_ASCII);
-  private static final Metadata.Key<Fish> KEY = Metadata.Key.of("test-bin", FISH_MARSHALLER);
-
-  @Test
-  public void testMutations() {
-    Fish lance = new Fish(LANCE);
-    Fish cat = new Fish("cat");
-    Metadata metadata = new Metadata();
-
-    assertEquals(null, metadata.get(KEY));
-    metadata.put(KEY, lance);
-    assertEquals(Arrays.asList(lance), Lists.newArrayList(metadata.getAll(KEY)));
-    assertEquals(lance, metadata.get(KEY));
-    metadata.put(KEY, lance);
-    assertEquals(Arrays.asList(lance, lance), Lists.newArrayList(metadata.getAll(KEY)));
-    assertTrue(metadata.remove(KEY, lance));
-    assertEquals(Arrays.asList(lance), Lists.newArrayList(metadata.getAll(KEY)));
-
-    assertFalse(metadata.remove(KEY, cat));
-    metadata.put(KEY, cat);
-    assertEquals(cat, metadata.get(KEY));
-    metadata.put(KEY, lance);
-    assertEquals(Arrays.asList(lance, cat, lance), Lists.newArrayList(metadata.getAll(KEY)));
-    assertEquals(lance, metadata.get(KEY));
-    assertTrue(metadata.remove(KEY, lance));
-    assertEquals(Arrays.asList(cat, lance), Lists.newArrayList(metadata.getAll(KEY)));
-    metadata.put(KEY, lance);
-    assertTrue(metadata.remove(KEY, cat));
-    assertEquals(Arrays.asList(lance, lance), Lists.newArrayList(metadata.getAll(KEY)));
-
-    assertEquals(Arrays.asList(lance, lance), Lists.newArrayList(metadata.removeAll(KEY)));
-    assertEquals(null, metadata.getAll(KEY));
-    assertEquals(null, metadata.get(KEY));
-  }
-
-  @Test
-  public void discardAll() {
-    Fish lance = new Fish(LANCE);
-    Metadata metadata = new Metadata();
-
-    metadata.put(KEY, lance);
-    metadata.discardAll(KEY);
-    assertEquals(null, metadata.getAll(KEY));
-    assertEquals(null, metadata.get(KEY));
-  }
-
-  @Test
-  public void discardAll_empty() {
-    Metadata metadata = new Metadata();
-    metadata.discardAll(KEY);
-    assertEquals(null, metadata.getAll(KEY));
-    assertEquals(null, metadata.get(KEY));
-  }
-
-  @Test
-  public void testGetAllNoRemove() {
-    Fish lance = new Fish(LANCE);
-    Metadata metadata = new Metadata();
-    metadata.put(KEY, lance);
-    Iterator<Fish> i = metadata.getAll(KEY).iterator();
-    assertEquals(lance, i.next());
-
-    thrown.expect(UnsupportedOperationException.class);
-    i.remove();
-  }
-
-  @Test
-  public void testWriteParsed() {
-    Fish lance = new Fish(LANCE);
-    Metadata metadata = new Metadata();
-    metadata.put(KEY, lance);
-    assertEquals(lance, metadata.get(KEY));
-    Iterator<Fish> fishes = metadata.<Fish>getAll(KEY).iterator();
-    assertTrue(fishes.hasNext());
-    assertEquals(fishes.next(), lance);
-    assertFalse(fishes.hasNext());
-    byte[][] serialized = metadata.serialize();
-    assertEquals(2, serialized.length);
-    assertEquals(new String(serialized[0], US_ASCII), "test-bin");
-    assertArrayEquals(LANCE_BYTES, serialized[1]);
-    assertEquals(lance, metadata.get(KEY));
-    assertEquals(serialized[0], metadata.serialize()[0]);
-    assertEquals(serialized[1], metadata.serialize()[1]);
-  }
-
-  @Test
-  public void testWriteRaw() {
-    Metadata raw = new Metadata(KEY.asciiName(), LANCE_BYTES);
-    Fish lance = raw.get(KEY);
-    assertEquals(lance, new Fish(LANCE));
-    // Reading again should return the same parsed instance
-    assertEquals(lance, raw.get(KEY));
-  }
-
-  @Test
-  public void testSerializeRaw() {
-    Metadata raw = new Metadata(KEY.asciiName(), LANCE_BYTES);
-    byte[][] serialized = raw.serialize();
-    assertArrayEquals(serialized[0], KEY.asciiName());
-    assertArrayEquals(serialized[1], LANCE_BYTES);
-  }
-
-  @Test
-  public void testMergeByteConstructed() {
-    Metadata raw = new Metadata(KEY.asciiName(), LANCE_BYTES);
-    Metadata serializable = new Metadata();
-    serializable.merge(raw);
-
-    byte[][] serialized = serializable.serialize();
-    assertArrayEquals(serialized[0], KEY.asciiName());
-    assertArrayEquals(serialized[1], LANCE_BYTES);
-    assertEquals(new Fish(LANCE), serializable.get(KEY));
-  }
-
-  @Test
-  public void headerMergeShouldCopyValues() {
-    Fish lance = new Fish(LANCE);
-    Metadata h1 = new Metadata();
-
-    Metadata h2 = new Metadata();
-    h2.put(KEY, lance);
-
-    h1.merge(h2);
-
-    Iterator<Fish> fishes = h1.<Fish>getAll(KEY).iterator();
-    assertTrue(fishes.hasNext());
-    assertEquals(fishes.next(), lance);
-    assertFalse(fishes.hasNext());
-  }
-
-  @Test
-  public void mergeExpands() {
-    Fish lance = new Fish(LANCE);
-    Metadata h1 = new Metadata();
-    h1.put(KEY, lance);
-
-    Metadata h2 = new Metadata();
-    h2.put(KEY, lance);
-    h2.put(KEY, lance);
-    h2.put(KEY, lance);
-    h2.put(KEY, lance);
-
-    h1.merge(h2);
-  }
-
-  @Test
-  public void integerMarshallerIsDecimal() {
-    assertEquals("12345678", Metadata.INTEGER_MARSHALLER.toAsciiString(12345678));
-  }
-
-  @Test
-  public void roundTripIntegerMarshaller() {
-    roundTripInteger(0);
-    roundTripInteger(1);
-    roundTripInteger(-1);
-    roundTripInteger(0x12345678);
-    roundTripInteger(0x87654321);
-  }
-
-  @Test
-  public void shortBinaryKeyName() {
-    thrown.expect(IllegalArgumentException.class);
-
-    Metadata.Key.of("-bin", FISH_MARSHALLER);
-  }
-
-  @Test
-  public void invalidSuffixBinaryKeyName() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Binary header is named");
-
-    Metadata.Key.of("nonbinary", FISH_MARSHALLER);
-  }
-
-  private void roundTripInteger(Integer i) {
-    assertEquals(i, Metadata.INTEGER_MARSHALLER.parseAsciiString(
-        Metadata.INTEGER_MARSHALLER.toAsciiString(i)));
-  }
-
-  @Test
-  public void verifyToString() {
-    Metadata h = new Metadata();
-    h.put(KEY, new Fish("binary"));
-    h.put(Metadata.Key.of("test", Metadata.ASCII_STRING_MARSHALLER), "ascii");
-    assertEquals("Metadata(test-bin=YmluYXJ5,test=ascii)", h.toString());
-
-    Metadata t = new Metadata();
-    t.put(Metadata.Key.of("test", Metadata.ASCII_STRING_MARSHALLER), "ascii");
-    assertEquals("Metadata(test=ascii)", t.toString());
-
-    t = new Metadata("test".getBytes(US_ASCII), "ascii".getBytes(US_ASCII),
-        "test-bin".getBytes(US_ASCII), "binary".getBytes(US_ASCII));
-    assertEquals("Metadata(test=ascii,test-bin=YmluYXJ5)", t.toString());
-  }
-
-  @Test
-  public void verifyToString_usingBinary() {
-    Metadata h = new Metadata();
-    h.put(KEY, new Fish("binary"));
-    h.put(Metadata.Key.of("test", Metadata.ASCII_STRING_MARSHALLER), "ascii");
-    assertEquals("Metadata(test-bin=YmluYXJ5,test=ascii)", h.toString());
-
-    Metadata t = new Metadata();
-    t.put(Metadata.Key.of("test", Metadata.ASCII_STRING_MARSHALLER), "ascii");
-    assertEquals("Metadata(test=ascii)", t.toString());
-  }
-
-  @Test
-  public void testKeyCaseHandling() {
-    Locale originalLocale = Locale.getDefault();
-    Locale.setDefault(new Locale("tr", "TR"));
-    try {
-      // In Turkish, both I and i (which are in ASCII) change into non-ASCII characters when their
-      // case is changed as ı and İ, respectively.
-      assertEquals("İ", "i".toUpperCase());
-      assertEquals("ı", "I".toLowerCase());
-
-      Metadata.Key<String> keyTitleCase
-          = Metadata.Key.of("If-Modified-Since", Metadata.ASCII_STRING_MARSHALLER);
-      Metadata.Key<String> keyLowerCase
-          = Metadata.Key.of("if-modified-since", Metadata.ASCII_STRING_MARSHALLER);
-      Metadata.Key<String> keyUpperCase
-          = Metadata.Key.of("IF-MODIFIED-SINCE", Metadata.ASCII_STRING_MARSHALLER);
-
-      Metadata metadata = new Metadata();
-      metadata.put(keyTitleCase, "plain string");
-      assertEquals("plain string", metadata.get(keyTitleCase));
-      assertEquals("plain string", metadata.get(keyLowerCase));
-      assertEquals("plain string", metadata.get(keyUpperCase));
-
-      byte[][] bytes = metadata.serialize();
-      assertEquals(2, bytes.length);
-      assertArrayEquals("if-modified-since".getBytes(US_ASCII), bytes[0]);
-      assertArrayEquals("plain string".getBytes(US_ASCII), bytes[1]);
-    } finally {
-      Locale.setDefault(originalLocale);
-    }
-  }
-
-  @Test
-  public void removeIgnoresMissingValue() {
-    Metadata m = new Metadata();
-    // Any key will work.
-    Key<String> key = GrpcUtil.USER_AGENT_KEY;
-
-    boolean success = m.remove(key, "agent");
-    assertFalse(success);
-  }
-
-  @Test
-  public void removeAllIgnoresMissingValue() {
-    Metadata m = new Metadata();
-    // Any key will work.
-    Key<String> key = GrpcUtil.USER_AGENT_KEY;
-
-    Iterable<String> removed = m.removeAll(key);
-    assertNull(removed);
-  }
-
-  @Test
-  public void keyEqualsHashNameWorks() {
-    Key<Integer> k1 = Key.of("case", Metadata.INTEGER_MARSHALLER);
-
-    Key<Integer> k2 = Key.of("CASE", Metadata.INTEGER_MARSHALLER);
-    assertEquals(k1, k1);
-    assertNotEquals(k1, null);
-    assertNotEquals(k1, new Object(){});
-    assertEquals(k1, k2);
-
-    assertEquals(k1.hashCode(), k2.hashCode());
-    // Check that the casing is preserved.
-    assertEquals("CASE", k2.originalName());
-    assertEquals("case", k2.name());
-  }
-
-  @Test
-  public void invalidKeyName() {
-    try {
-      Key.of("io.grpc/key1", Metadata.INTEGER_MARSHALLER);
-      fail("Should have thrown");
-    } catch (IllegalArgumentException e) {
-      assertEquals("Invalid character '/' in key name 'io.grpc/key1'", e.getMessage());
-    }
-  }
-
-  private static class Fish {
-    private String name;
-
-    private Fish(String name) {
-      this.name = name;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-      if (this == o) {
-        return true;
-      }
-      if (o == null || getClass() != o.getClass()) {
-        return false;
-      }
-      Fish fish = (Fish) o;
-      if (name != null ? !name.equals(fish.name) : fish.name != null) {
-        return false;
-      }
-      return true;
-    }
-
-    @Override
-    public int hashCode() {
-      return name.hashCode();
-    }
-
-    @Override
-    public String toString() {
-      return "Fish(" + name + ")";
-    }
-  }
-}
diff --git a/core/src/test/java/io/grpc/MethodDescriptorTest.java b/core/src/test/java/io/grpc/MethodDescriptorTest.java
deleted file mode 100644
index 24b864dc4e9..00000000000
--- a/core/src/test/java/io/grpc/MethodDescriptorTest.java
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-import io.grpc.MethodDescriptor.MethodType;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Tests for {@link MethodDescriptor}.
- */
-@RunWith(JUnit4.class)
-public class MethodDescriptorTest {
-  @Test
-  public void createMethodDescriptor() {
-    MethodDescriptor<String, String> descriptor = MethodDescriptor.<String, String>create(
-        MethodType.CLIENT_STREAMING, "/package.service/method", new StringMarshaller(),
-        new StringMarshaller());
-    assertEquals(MethodType.CLIENT_STREAMING, descriptor.getType());
-    assertEquals("/package.service/method", descriptor.getFullMethodName());
-    assertFalse(descriptor.isIdempotent());
-    assertFalse(descriptor.isSafe());
-  }
-
-  @Test
-  public void idempotent() {
-    MethodDescriptor<String, String> descriptor = MethodDescriptor.<String, String>newBuilder()
-        .setType(MethodType.SERVER_STREAMING)
-        .setFullMethodName("/package.service/method")
-        .setRequestMarshaller(new StringMarshaller())
-        .setResponseMarshaller(new StringMarshaller())
-        .build();
-
-    assertFalse(descriptor.isIdempotent());
-
-    // Create a new desriptor by setting idempotent to true
-    MethodDescriptor<String, String> newDescriptor =
-        descriptor.toBuilder().setIdempotent(true).build();
-    assertTrue(newDescriptor.isIdempotent());
-    // All other fields should staty the same
-    assertEquals(MethodType.SERVER_STREAMING, newDescriptor.getType());
-    assertEquals("/package.service/method", newDescriptor.getFullMethodName());
-  }
-
-  @Test
-  public void safe() {
-    MethodDescriptor<String, String> descriptor = MethodDescriptor.<String, String>newBuilder()
-        .setType(MethodType.UNARY)
-        .setFullMethodName("/package.service/method")
-        .setRequestMarshaller(new StringMarshaller())
-        .setResponseMarshaller(new StringMarshaller())
-        .build();
-    assertFalse(descriptor.isSafe());
-
-    // Create a new desriptor by setting safe to true
-    MethodDescriptor<String, String> newDescriptor = descriptor.toBuilder().setSafe(true).build();
-    assertTrue(newDescriptor.isSafe());
-    // All other fields should staty the same
-    assertEquals(MethodType.UNARY, newDescriptor.getType());
-    assertEquals("/package.service/method", newDescriptor.getFullMethodName());
-  }
-
-  @Test(expected = IllegalArgumentException.class)
-  public void safeAndNonUnary() {
-    MethodDescriptor<String, String> descriptor = MethodDescriptor.<String, String>newBuilder()
-        .setType(MethodType.SERVER_STREAMING)
-        .setFullMethodName("/package.service/method")
-        .setRequestMarshaller(new StringMarshaller())
-        .setResponseMarshaller(new StringMarshaller())
-        .build();
-
-
-    MethodDescriptor<String, String> discard = descriptor.toBuilder().setSafe(true).build();
-    // Never reached
-    assert discard == null;
-  }
-}
diff --git a/core/src/test/java/io/grpc/NameResolverProviderTest.java b/core/src/test/java/io/grpc/NameResolverProviderTest.java
deleted file mode 100644
index 9485e4e36ba..00000000000
--- a/core/src/test/java/io/grpc/NameResolverProviderTest.java
+++ /dev/null
@@ -1,244 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-
-import io.grpc.internal.DnsNameResolverProvider;
-import java.net.URI;
-import java.util.Collections;
-import java.util.List;
-import java.util.ServiceConfigurationError;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link NameResolverProvider}. */
-@RunWith(JUnit4.class)
-public class NameResolverProviderTest {
-  private final String serviceFile = "META-INF/services/io.grpc.NameResolverProvider";
-  private final URI uri = URI.create("dns:///localhost");
-  private final Attributes attributes = Attributes.EMPTY;
-
-  @Test
-  public void noProvider() {
-    ClassLoader cl = new ReplacingClassLoader(
-        getClass().getClassLoader(), serviceFile,
-        "io/grpc/NameResolverProviderTest-doesNotExist.txt");
-    List<NameResolverProvider> providers = NameResolverProvider.load(cl);
-    assertEquals(Collections.<NameResolverProvider>emptyList(), providers);
-  }
-
-  @Test
-  public void multipleProvider() {
-    ClassLoader cl = new ReplacingClassLoader(
-        getClass().getClassLoader(), serviceFile,
-        "io/grpc/NameResolverProviderTest-multipleProvider.txt");
-    List<NameResolverProvider> providers = NameResolverProvider.load(cl);
-    assertEquals(3, providers.size());
-    assertSame(Available7Provider.class, providers.get(0).getClass());
-    assertSame(Available5Provider.class, providers.get(1).getClass());
-    assertSame(Available0Provider.class, providers.get(2).getClass());
-    assertEquals("schemeAvailable7Provider",
-        NameResolverProvider.asFactory(providers).getDefaultScheme());
-    assertSame(Available7Provider.nameResolver,
-        NameResolverProvider.asFactory(providers).newNameResolver(uri, attributes));
-  }
-
-  @Test
-  public void unavailableProvider() {
-    ClassLoader cl = new ReplacingClassLoader(
-        getClass().getClassLoader(), serviceFile,
-        "io/grpc/NameResolverProviderTest-unavailableProvider.txt");
-    assertEquals(Collections.<NameResolverProvider>emptyList(), NameResolverProvider.load(cl));
-  }
-
-  @Test
-  public void getDefaultScheme_noProvider() {
-    List<NameResolverProvider> providers = Collections.<NameResolverProvider>emptyList();
-    NameResolver.Factory factory = NameResolverProvider.asFactory(providers);
-    try {
-      factory.getDefaultScheme();
-      fail("Expected exception");
-    } catch (IllegalStateException ex) {
-      assertTrue(ex.toString(), ex.getMessage().contains("No NameResolverProviders found"));
-    }
-  }
-
-  @Test
-  public void newNameResolver_providerReturnsNull() {
-    List<NameResolverProvider> providers = Collections.<NameResolverProvider>singletonList(
-        new BaseProvider(true, 5) {
-          @Override
-          public NameResolver newNameResolver(URI passedUri, Attributes passedAttributes) {
-            assertSame(uri, passedUri);
-            assertSame(attributes, passedAttributes);
-            return null;
-          }
-        });
-    assertNull(NameResolverProvider.asFactory(providers).newNameResolver(uri, attributes));
-  }
-
-  @Test
-  public void newNameResolver_noProvider() {
-    List<NameResolverProvider> providers = Collections.<NameResolverProvider>emptyList();
-    NameResolver.Factory factory = NameResolverProvider.asFactory(providers);
-    try {
-      factory.newNameResolver(uri, attributes);
-      fail("Expected exception");
-    } catch (IllegalStateException ex) {
-      assertTrue(ex.toString(), ex.getMessage().contains("No NameResolverProviders found"));
-    }
-  }
-
-  @Test
-  public void baseProviders() {
-    List<NameResolverProvider> providers = NameResolverProvider.providers();
-    assertEquals(1, providers.size());
-    assertSame(DnsNameResolverProvider.class, providers.get(0).getClass());
-    assertEquals("dns", NameResolverProvider.asFactory().getDefaultScheme());
-  }
-
-  @Test
-  public void getCandidatesViaHardCoded_usesProvidedClassLoader() {
-    final RuntimeException toThrow = new RuntimeException();
-    try {
-      NameResolverProvider.getCandidatesViaHardCoded(new ClassLoader() {
-        @Override
-        public Class<?> loadClass(String name) {
-          throw toThrow;
-        }
-      });
-      fail("Expected exception");
-    } catch (RuntimeException ex) {
-      assertSame(toThrow, ex);
-    }
-  }
-
-  @Test
-  public void getCandidatesViaHardCoded_ignoresMissingClasses() {
-    Iterable<NameResolverProvider> i =
-        NameResolverProvider.getCandidatesViaHardCoded(new ClassLoader() {
-          @Override
-          public Class<?> loadClass(String name) throws ClassNotFoundException {
-            throw new ClassNotFoundException();
-          }
-        });
-    assertFalse("Iterator should be empty", i.iterator().hasNext());
-  }
-
-  @Test
-  public void create_throwsErrorOnMisconfiguration() throws Exception {
-    class PrivateClass {}
-
-    try {
-      NameResolverProvider.create(PrivateClass.class);
-      fail("Expected exception");
-    } catch (ServiceConfigurationError e) {
-      assertTrue("Expected ClassCastException cause: " + e.getCause(),
-          e.getCause() instanceof ClassCastException);
-    }
-  }
-
-  private static class BaseProvider extends NameResolverProvider {
-    private final boolean isAvailable;
-    private final int priority;
-
-    public BaseProvider(boolean isAvailable, int priority) {
-      this.isAvailable = isAvailable;
-      this.priority = priority;
-    }
-
-    @Override
-    protected boolean isAvailable() {
-      return isAvailable;
-    }
-
-    @Override
-    protected int priority() {
-      return priority;
-    }
-
-    @Override
-    public NameResolver newNameResolver(URI targetUri, Attributes params) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public String getDefaultScheme() {
-      return "scheme" + getClass().getSimpleName();
-    }
-  }
-
-  public static class Available0Provider extends BaseProvider {
-    public Available0Provider() {
-      super(true, 0);
-    }
-  }
-
-  public static class Available5Provider extends BaseProvider {
-    public Available5Provider() {
-      super(true, 5);
-    }
-  }
-
-  public static class Available7Provider extends BaseProvider {
-    public static final NameResolver nameResolver = mock(NameResolver.class);
-
-    public Available7Provider() {
-      super(true, 7);
-    }
-
-    @Override
-    public NameResolver newNameResolver(URI targetUri, Attributes params) {
-      return nameResolver;
-    }
-  }
-
-  public static class UnavailableProvider extends BaseProvider {
-    public UnavailableProvider() {
-      super(false, 10);
-    }
-
-    @Override
-    protected int priority() {
-      throw new RuntimeException("purposefully broken");
-    }
-  }
-}
-
diff --git a/core/src/test/java/io/grpc/PickFirstBalancerTest.java b/core/src/test/java/io/grpc/PickFirstBalancerTest.java
deleted file mode 100644
index 5ae2de6b1ca..00000000000
--- a/core/src/test/java/io/grpc/PickFirstBalancerTest.java
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.junit.Assert.assertSame;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-import com.google.common.base.Supplier;
-import com.google.common.collect.Lists;
-import io.grpc.TransportManager.InterimTransport;
-import java.net.SocketAddress;
-import java.util.List;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-/** Unit test for {@link PickFirstBalancerFactory}. */
-@RunWith(JUnit4.class)
-public class PickFirstBalancerTest {
-  private LoadBalancer<Transport> loadBalancer;
-
-  private List<ResolvedServerInfoGroup> servers;
-  private EquivalentAddressGroup addressGroup;
-
-  @Mock private TransportManager<Transport> mockTransportManager;
-  @Mock private Transport mockTransport;
-  @Mock private InterimTransport<Transport> mockInterimTransport;
-  @Mock private Transport mockInterimTransportAsTransport;
-  @Captor private ArgumentCaptor<Supplier<Transport>> transportSupplierCaptor;
-
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    loadBalancer = PickFirstBalancerFactory.getInstance().newLoadBalancer(
-        "fakeservice", mockTransportManager);
-    servers = Lists.newArrayList();
-    List<ResolvedServerInfo> resolvedServerInfoList = Lists.newArrayList();
-    for (int i = 0; i < 3; i++) {
-      resolvedServerInfoList.add(new ResolvedServerInfo(new FakeSocketAddress("server" + i)));
-    }
-    ResolvedServerInfoGroup resolvedServerInfoGroup = ResolvedServerInfoGroup.builder().addAll(
-        resolvedServerInfoList).build();
-    servers.add(resolvedServerInfoGroup);
-    addressGroup = resolvedServerInfoGroup.toEquivalentAddressGroup();
-    when(mockTransportManager.getTransport(eq(addressGroup))).thenReturn(mockTransport);
-    when(mockTransportManager.createInterimTransport()).thenReturn(mockInterimTransport);
-    when(mockInterimTransport.transport()).thenReturn(mockInterimTransportAsTransport);
-  }
-
-  @Test
-  public void pickBeforeResolved() throws Exception {
-    Transport t1 = loadBalancer.pickTransport(null);
-    Transport t2 = loadBalancer.pickTransport(null);
-    assertSame(mockInterimTransportAsTransport, t1);
-    assertSame(mockInterimTransportAsTransport, t2);
-    verify(mockTransportManager).createInterimTransport();
-    verify(mockTransportManager, never()).getTransport(any(EquivalentAddressGroup.class));
-    verify(mockInterimTransport, times(2)).transport();
-
-    loadBalancer.handleResolvedAddresses(servers, Attributes.EMPTY);
-    verify(mockInterimTransport).closeWithRealTransports(transportSupplierCaptor.capture());
-    for (int i = 0; i < 2; i++) {
-      assertSame(mockTransport, transportSupplierCaptor.getValue().get());
-    }
-    verify(mockTransportManager, times(2)).getTransport(eq(addressGroup));
-    verifyNoMoreInteractions(mockTransportManager);
-    verifyNoMoreInteractions(mockInterimTransport);
-  }
-
-  @Test
-  public void pickBeforeNameResolutionError() {
-    Transport t1 = loadBalancer.pickTransport(null);
-    Transport t2 = loadBalancer.pickTransport(null);
-    assertSame(mockInterimTransportAsTransport, t1);
-    assertSame(mockInterimTransportAsTransport, t2);
-    verify(mockTransportManager).createInterimTransport();
-    verify(mockTransportManager, never()).getTransport(any(EquivalentAddressGroup.class));
-    verify(mockInterimTransport, times(2)).transport();
-
-    loadBalancer.handleNameResolutionError(Status.UNAVAILABLE);
-    verify(mockInterimTransport).closeWithError(any(Status.class));
-    // Ensure a shutdown after error closes without incident
-    loadBalancer.shutdown();
-    // Ensure a name resolution error after shutdown does nothing
-    loadBalancer.handleNameResolutionError(Status.UNAVAILABLE);
-    verifyNoMoreInteractions(mockInterimTransport);
-  }
-
-  @Test
-  public void pickBeforeShutdown() {
-    Transport t1 = loadBalancer.pickTransport(null);
-    Transport t2 = loadBalancer.pickTransport(null);
-    assertSame(mockInterimTransportAsTransport, t1);
-    assertSame(mockInterimTransportAsTransport, t2);
-    verify(mockTransportManager).createInterimTransport();
-    verify(mockTransportManager, never()).getTransport(any(EquivalentAddressGroup.class));
-    verify(mockInterimTransport, times(2)).transport();
-
-    loadBalancer.shutdown();
-    verify(mockInterimTransport).closeWithError(any(Status.class));
-    // Ensure double shutdown just returns immediately without closing again.
-    loadBalancer.shutdown();
-    verifyNoMoreInteractions(mockInterimTransport);
-  }
-
-  @Test
-  public void pickAfterResolved() throws Exception {
-    loadBalancer.handleResolvedAddresses(servers, Attributes.EMPTY);
-    Transport t = loadBalancer.pickTransport(null);
-    assertSame(mockTransport, t);
-    verify(mockTransportManager).getTransport(addressGroup);
-    verifyNoMoreInteractions(mockTransportManager);
-  }
-
-  private static class FakeSocketAddress extends SocketAddress {
-    final String name;
-
-    FakeSocketAddress(String name) {
-      this.name = name;
-    }
-
-    @Override
-    public String toString() {
-      return "FakeSocketAddress-" + name;
-    }
-  }
-
-  private static class Transport {}
-}
diff --git a/core/src/test/java/io/grpc/PickFirstLoadBalancer2Test.java b/core/src/test/java/io/grpc/PickFirstLoadBalancer2Test.java
deleted file mode 100644
index 541f6da4560..00000000000
--- a/core/src/test/java/io/grpc/PickFirstLoadBalancer2Test.java
+++ /dev/null
@@ -1,285 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-import com.google.common.collect.Lists;
-import io.grpc.LoadBalancer2.Helper;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.Subchannel;
-import io.grpc.PickFirstBalancerFactory2.PickFirstBalancer;
-import io.grpc.PickFirstBalancerFactory2.Picker;
-import java.net.SocketAddress;
-import java.util.List;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-
-/** Unit test for {@link PickFirstBalancerFactory2}. */
-@RunWith(JUnit4.class)
-public class PickFirstLoadBalancer2Test {
-  private PickFirstBalancer loadBalancer;
-  private List<ResolvedServerInfoGroup> servers = Lists.newArrayList();
-  private List<SocketAddress> socketAddresses = Lists.newArrayList();
-
-  private static final Attributes.Key<String> FOO = Attributes.Key.of("foo");
-  private Attributes affinity = Attributes.newBuilder().set(FOO, "bar").build();
-
-  @Captor
-  private ArgumentCaptor<EquivalentAddressGroup> eagCaptor;
-  @Captor
-  private ArgumentCaptor<Picker> pickerCaptor;
-  @Captor
-  private ArgumentCaptor<Attributes> attrsCaptor;
-  @Mock
-  private Helper mockHelper;
-  @Mock
-  private Subchannel mockSubchannel;
-
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    for (int i = 0; i < 3; i++) {
-      SocketAddress addr = new FakeSocketAddress("server" + i);
-      servers.add(ResolvedServerInfoGroup.builder().add(new ResolvedServerInfo(addr)).build());
-      socketAddresses.add(addr);
-    }
-
-    when(mockSubchannel.getAddresses()).thenReturn(new EquivalentAddressGroup(socketAddresses));
-    when(mockHelper.createSubchannel(any(EquivalentAddressGroup.class), any(Attributes.class)))
-        .thenReturn(mockSubchannel);
-
-    loadBalancer = (PickFirstBalancer) PickFirstBalancerFactory2.getInstance().newLoadBalancer(
-        mockHelper);
-  }
-
-  @Test
-  public void pickAfterResolved() throws Exception {
-    loadBalancer.handleResolvedAddresses(servers, affinity);
-
-    verify(mockHelper).createSubchannel(eagCaptor.capture(), attrsCaptor.capture());
-    verify(mockHelper).updatePicker(pickerCaptor.capture());
-
-    assertEquals(new EquivalentAddressGroup(socketAddresses), eagCaptor.getValue());
-    assertEquals(pickerCaptor.getValue().pickSubchannel(affinity, new Metadata()),
-        pickerCaptor.getValue().pickSubchannel(affinity, new Metadata()));
-
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void pickAfterResolvedAndUnchanged() throws Exception {
-    loadBalancer.handleResolvedAddresses(servers, affinity);
-    loadBalancer.handleResolvedAddresses(servers, affinity);
-
-    verify(mockHelper).createSubchannel(any(EquivalentAddressGroup.class),
-        any(Attributes.class));
-    verify(mockHelper).updatePicker(isA(Picker.class));
-
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void pickAfterResolvedAndChanged() throws Exception {
-    SocketAddress socketAddr = new FakeSocketAddress("newserver");
-    List<SocketAddress> newSocketAddresses = Lists.newArrayList(socketAddr);
-    List<ResolvedServerInfoGroup> newServers = Lists.newArrayList(
-        ResolvedServerInfoGroup.builder().add(new ResolvedServerInfo(socketAddr)).build());
-
-    final Subchannel oldSubchannel = mock(Subchannel.class);
-    final EquivalentAddressGroup oldEag = new EquivalentAddressGroup(socketAddresses);
-    when(oldSubchannel.getAddresses()).thenReturn(oldEag);
-
-    final Subchannel newSubchannel = mock(Subchannel.class);
-    final EquivalentAddressGroup newEag = new EquivalentAddressGroup(newSocketAddresses);
-    when(newSubchannel.getAddresses()).thenReturn(newEag);
-
-    when(mockHelper.createSubchannel(eq(oldEag), any(Attributes.class))).thenReturn(oldSubchannel);
-    when(mockHelper.createSubchannel(eq(newEag), any(Attributes.class))).thenReturn(newSubchannel);
-
-    InOrder inOrder = inOrder(mockHelper);
-
-    loadBalancer.handleResolvedAddresses(servers, affinity);
-    inOrder.verify(mockHelper).createSubchannel(eagCaptor.capture(), any(Attributes.class));
-    inOrder.verify(mockHelper).updatePicker(pickerCaptor.capture());
-    assertEquals(socketAddresses, eagCaptor.getValue().getAddresses());
-
-    loadBalancer.handleResolvedAddresses(newServers, affinity);
-    inOrder.verify(mockHelper).createSubchannel(eagCaptor.capture(), any(Attributes.class));
-    inOrder.verify(mockHelper).updatePicker(pickerCaptor.capture());
-    assertEquals(newSocketAddresses, eagCaptor.getValue().getAddresses());
-
-    Subchannel subchannel = pickerCaptor.getAllValues().get(0).pickSubchannel(
-        affinity, new Metadata()).getSubchannel();
-    assertEquals(oldSubchannel, subchannel);
-
-    Subchannel subchannel2 = pickerCaptor.getAllValues().get(1).pickSubchannel(affinity,
-        new Metadata()).getSubchannel();
-    assertEquals(newSubchannel, subchannel2);
-    verify(subchannel2, never()).shutdown();
-
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void stateChangeBeforeResolution() throws Exception {
-    loadBalancer.handleSubchannelState(mockSubchannel,
-        ConnectivityStateInfo.forNonError(ConnectivityState.READY));
-
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void pickAfterStateChangeAfterResolution() throws Exception {
-    loadBalancer.handleResolvedAddresses(servers, affinity);
-    verify(mockHelper).updatePicker(pickerCaptor.capture());
-    Subchannel subchannel = pickerCaptor.getValue().pickSubchannel(affinity,
-        new Metadata()).getSubchannel();
-    reset(mockHelper);
-
-    InOrder inOrder = inOrder(mockHelper);
-
-    Status error = Status.UNAVAILABLE.withDescription("boom!");
-    loadBalancer.handleSubchannelState(subchannel,
-        ConnectivityStateInfo.forTransientFailure(error));
-    inOrder.verify(mockHelper).updatePicker(pickerCaptor.capture());
-    assertEquals(error, pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
-            new Metadata()).getStatus());
-
-    loadBalancer.handleSubchannelState(subchannel,
-        ConnectivityStateInfo.forNonError(ConnectivityState.IDLE));
-    inOrder.verify(mockHelper).updatePicker(pickerCaptor.capture());
-    assertEquals(Status.OK, pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
-        new Metadata()).getStatus());
-
-    loadBalancer.handleSubchannelState(subchannel,
-        ConnectivityStateInfo.forNonError(ConnectivityState.READY));
-    inOrder.verify(mockHelper).updatePicker(pickerCaptor.capture());
-    assertEquals(subchannel,
-        pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY, new Metadata()).getSubchannel());
-
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void nameResolutionError() throws Exception {
-    Status error = Status.NOT_FOUND.withDescription("nameResolutionError");
-    loadBalancer.handleNameResolutionError(error);
-    verify(mockHelper).updatePicker(pickerCaptor.capture());
-    PickResult pickResult = pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
-        new Metadata());
-    assertEquals(null, pickResult.getSubchannel());
-    assertEquals(error, pickResult.getStatus());
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void nameResolutionSuccessAfterError() throws Exception {
-    InOrder inOrder = inOrder(mockHelper);
-
-    loadBalancer.handleNameResolutionError(Status.NOT_FOUND.withDescription("nameResolutionError"));
-    inOrder.verify(mockHelper).updatePicker(any(Picker.class));
-
-    loadBalancer.handleResolvedAddresses(servers, affinity);
-    inOrder.verify(mockHelper).createSubchannel(eq(new EquivalentAddressGroup(socketAddresses)),
-        eq(Attributes.EMPTY));
-    inOrder.verify(mockHelper).updatePicker(pickerCaptor.capture());
-
-    assertEquals(mockSubchannel,
-        pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY, new Metadata()).getSubchannel());
-
-    assertEquals(pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY, new Metadata()),
-        pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY, new Metadata()));
-
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void nameResolutionErrorWithStateChanges() throws Exception {
-    InOrder inOrder = inOrder(mockHelper);
-
-    loadBalancer.handleSubchannelState(mockSubchannel,
-        ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
-    Status error = Status.NOT_FOUND.withDescription("nameResolutionError");
-    loadBalancer.handleNameResolutionError(error);
-    inOrder.verify(mockHelper).updatePicker(pickerCaptor.capture());
-
-    PickResult pickResult = pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
-        new Metadata());
-    assertEquals(null, pickResult.getSubchannel());
-    assertEquals(error, pickResult.getStatus());
-
-    loadBalancer.handleSubchannelState(mockSubchannel,
-        ConnectivityStateInfo.forNonError(ConnectivityState.READY));
-    Status error2 = Status.NOT_FOUND.withDescription("nameResolutionError2");
-    loadBalancer.handleNameResolutionError(error2);
-    inOrder.verify(mockHelper).updatePicker(pickerCaptor.capture());
-
-    pickResult = pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
-        new Metadata());
-    assertEquals(null, pickResult.getSubchannel());
-    assertEquals(error2, pickResult.getStatus());
-
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  private static class FakeSocketAddress extends SocketAddress {
-    final String name;
-
-    FakeSocketAddress(String name) {
-      this.name = name;
-    }
-
-    @Override
-    public String toString() {
-      return "FakeSocketAddress-" + name;
-    }
-  }
-}
diff --git a/core/src/test/java/io/grpc/ReplacingClassLoader.java b/core/src/test/java/io/grpc/ReplacingClassLoader.java
deleted file mode 100644
index 88980fcd5c2..00000000000
--- a/core/src/test/java/io/grpc/ReplacingClassLoader.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import java.io.IOException;
-import java.net.URL;
-import java.util.Enumeration;
-
-/**
- * A ClassLoader to help test service providers.
- */
-public class ReplacingClassLoader extends ClassLoader {
-  private final String resource;
-  private final String replacement;
-
-  /**
-   * Construct an instance where {@code replacement} is loaded instead of {@code resource}.
-   */
-  public ReplacingClassLoader(ClassLoader parent, String resource, String replacement) {
-    super(parent);
-    this.resource = resource;
-    this.replacement = replacement;
-  }
-
-  @Override
-  public URL getResource(String name) {
-    if (resource.equals(name)) {
-      return getParent().getResource(replacement);
-    }
-    return super.getResource(name);
-  }
-
-  @Override
-  public Enumeration<URL> getResources(String name) throws IOException {
-    if (resource.equals(name)) {
-      return getParent().getResources(replacement);
-    }
-    return super.getResources(name);
-  }
-}
-
diff --git a/core/src/test/java/io/grpc/ResolvedServerInfoTest.java b/core/src/test/java/io/grpc/ResolvedServerInfoTest.java
deleted file mode 100644
index ed328a706f5..00000000000
--- a/core/src/test/java/io/grpc/ResolvedServerInfoTest.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.fail;
-
-import java.net.InetSocketAddress;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-@RunWith(JUnit4.class)
-public class ResolvedServerInfoTest {
-  private static final Attributes.Key<String> FOO = Attributes.Key.of("foo");
-  private static final Attributes ATTRS = Attributes.newBuilder().set(FOO, "bar").build();
-
-  @Test
-  public void accessors() {
-    InetSocketAddress addr = InetSocketAddress.createUnresolved("foo", 123);
-
-    ResolvedServerInfo server = new ResolvedServerInfo(addr, ATTRS);
-    assertEquals(addr, server.getAddress());
-    assertEquals(ATTRS, server.getAttributes());
-
-    // unspecified attributes treated as empty
-    server = new ResolvedServerInfo(addr);
-    assertEquals(addr, server.getAddress());
-    assertEquals(Attributes.EMPTY, server.getAttributes());
-  }
-
-  @Test public void cannotUseNullAddress() {
-    try {
-      new ResolvedServerInfo(null, ATTRS);
-      fail("Should not have been allowd to create info with null address");
-    } catch (NullPointerException e) {
-      // expected
-    }
-  }
-
-  @Test public void equals_true() {
-    ResolvedServerInfo server1 = new ResolvedServerInfo(
-        InetSocketAddress.createUnresolved("foo", 123),
-        Attributes.newBuilder().set(FOO, "bar").build());
-    ResolvedServerInfo server2 = new ResolvedServerInfo(
-        InetSocketAddress.createUnresolved("foo", 123),
-        Attributes.newBuilder().set(FOO, "bar").build());
-
-    // sanity checks that they're not same instances
-    assertNotSame(server1.getAddress(), server2.getAddress());
-    assertNotSame(server1.getAttributes(), server2.getAttributes());
-
-    assertEquals(server1, server2);
-    assertEquals(server1.hashCode(), server2.hashCode()); // hash code must be consistent
-
-    // empty attributes
-    server1 = new ResolvedServerInfo(InetSocketAddress.createUnresolved("foo", 123));
-    server2 = new ResolvedServerInfo(
-        InetSocketAddress.createUnresolved("foo", 123), Attributes.EMPTY);
-    assertEquals(server1, server2);
-    assertEquals(server1.hashCode(), server2.hashCode());
-  }
-
-  @Test public void equals_falseDifferentAddresses() {
-    ResolvedServerInfo server1 = new ResolvedServerInfo(
-        InetSocketAddress.createUnresolved("foo", 123),
-        Attributes.newBuilder().set(FOO, "bar").build());
-    ResolvedServerInfo server2 = new ResolvedServerInfo(
-        InetSocketAddress.createUnresolved("foo", 456),
-        Attributes.newBuilder().set(FOO, "bar").build());
-
-    assertNotEquals(server1, server2);
-    // hash code could collide, but this assertion is safe because, in this example, they do not
-    assertNotEquals(server1.hashCode(), server2.hashCode());
-  }
-
-  @Test public void equals_falseDifferentAttributes() {
-    ResolvedServerInfo server1 = new ResolvedServerInfo(
-        InetSocketAddress.createUnresolved("foo", 123),
-        Attributes.newBuilder().set(FOO, "bar").build());
-    ResolvedServerInfo server2 = new ResolvedServerInfo(
-        InetSocketAddress.createUnresolved("foo", 123),
-        Attributes.newBuilder().set(FOO, "baz").build());
-
-    assertNotEquals(server1, server2);
-    // hash code could collide, but these assertions are safe because, in these examples, they don't
-    assertNotEquals(server1.hashCode(), server2.hashCode());
-
-    // same values but extra key? still not equal
-    server2 = new ResolvedServerInfo(
-        InetSocketAddress.createUnresolved("foo", 456),
-        Attributes.newBuilder()
-            .set(FOO, "bar")
-            .set(Attributes.Key.of("fiz"), "buz")
-            .build());
-
-    assertNotEquals(server1, server2);
-    assertNotEquals(server1.hashCode(), server2.hashCode());
-  }
-}
diff --git a/core/src/test/java/io/grpc/ServerProviderTest.java b/core/src/test/java/io/grpc/ServerProviderTest.java
deleted file mode 100644
index 85a4a23be28..00000000000
--- a/core/src/test/java/io/grpc/ServerProviderTest.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link ServerProvider}. */
-@RunWith(JUnit4.class)
-public class ServerProviderTest {
-  private final String serviceFile = "META-INF/services/io.grpc.ServerProvider";
-
-  @Test(expected = ManagedChannelProvider.ProviderNotFoundException.class)
-  public void noProvider() {
-    ServerProvider.provider();
-  }
-
-  @Test
-  public void multipleProvider() {
-    ClassLoader cl = new ReplacingClassLoader(
-        getClass().getClassLoader(), serviceFile,
-        "io/grpc/ServerProviderTest-multipleProvider.txt");
-    assertSame(Available7Provider.class, ServerProvider.load(cl).getClass());
-  }
-
-  @Test
-  public void unavailableProvider() {
-    ClassLoader cl = new ReplacingClassLoader(
-        getClass().getClassLoader(), serviceFile,
-        "io/grpc/ServerProviderTest-unavailableProvider.txt");
-    assertNull(ServerProvider.load(cl));
-  }
-
-  private static class BaseProvider extends ServerProvider {
-    private final boolean isAvailable;
-    private final int priority;
-
-    public BaseProvider(boolean isAvailable, int priority) {
-      this.isAvailable = isAvailable;
-      this.priority = priority;
-    }
-
-    @Override
-    protected boolean isAvailable() {
-      return isAvailable;
-    }
-
-    @Override
-    protected int priority() {
-      return priority;
-    }
-
-    @Override
-    protected ServerBuilder<?> builderForPort(int port) {
-      throw new UnsupportedOperationException();
-    }
-  }
-
-  public static class Available0Provider extends BaseProvider {
-    public Available0Provider() {
-      super(true, 0);
-    }
-  }
-
-  public static class Available5Provider extends BaseProvider {
-    public Available5Provider() {
-      super(true, 5);
-    }
-  }
-
-  public static class Available7Provider extends BaseProvider {
-    public Available7Provider() {
-      super(true, 7);
-    }
-  }
-
-  public static class UnavailableProvider extends BaseProvider {
-    public UnavailableProvider() {
-      super(false, 10);
-    }
-
-    @Override
-    protected int priority() {
-      throw new RuntimeException("purposefully broken");
-    }
-  }
-}
-
diff --git a/core/src/test/java/io/grpc/ServerServiceDefinitionTest.java b/core/src/test/java/io/grpc/ServerServiceDefinitionTest.java
deleted file mode 100644
index 491716c4eed..00000000000
--- a/core/src/test/java/io/grpc/ServerServiceDefinitionTest.java
+++ /dev/null
@@ -1,176 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.fail;
-
-import java.util.Collections;
-import java.util.HashSet;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link ServerServiceDefinition}. */
-@RunWith(JUnit4.class)
-public class ServerServiceDefinitionTest {
-  private String serviceName = "com.example.service";
-  private MethodDescriptor<String, Integer> method1 = MethodDescriptor.<String, Integer>newBuilder()
-      .setType(MethodDescriptor.MethodType.UNKNOWN)
-      .setFullMethodName(MethodDescriptor.generateFullMethodName(serviceName, "method1"))
-      .setRequestMarshaller(StringMarshaller.INSTANCE)
-      .setResponseMarshaller(IntegerMarshaller.INSTANCE)
-      .build();
-  private MethodDescriptor<String, Integer> diffMethod1 =
-      method1.toBuilder().setIdempotent(true).build();
-  private MethodDescriptor<String, Integer> method2 = method1.toBuilder()
-      .setFullMethodName(MethodDescriptor.generateFullMethodName(serviceName, "method2"))
-      .build();
-  private ServerCallHandler<String, Integer> methodHandler1
-      = new NoopServerCallHandler<String, Integer>();
-  private ServerCallHandler<String, Integer> methodHandler2
-      = new NoopServerCallHandler<String, Integer>();
-  private ServerMethodDefinition<String, Integer> methodDef1
-        = ServerMethodDefinition.create(method1, methodHandler1);
-  private ServerMethodDefinition<String, Integer> methodDef2
-        = ServerMethodDefinition.create(method2, methodHandler2);
-  @Rule
-  public ExpectedException thrown = ExpectedException.none();
-
-  @Test
-  public void noMethods() {
-    ServiceDescriptor sd = new ServiceDescriptor(serviceName);
-    ServerServiceDefinition ssd = ServerServiceDefinition.builder(sd)
-        .build();
-    assertSame(sd, ssd.getServiceDescriptor());
-    assertEquals(Collections.<MethodDescriptor<?, ?>>emptyList(),
-        ssd.getServiceDescriptor().getMethods());
-  }
-
-  @Test
-  public void addMethod_twoArg() {
-    ServiceDescriptor sd = new ServiceDescriptor(serviceName, method1, method2);
-    ServerServiceDefinition ssd = ServerServiceDefinition.builder(sd)
-        .addMethod(method1, methodHandler1)
-        .addMethod(method2, methodHandler2)
-        .build();
-    assertSame(sd, ssd.getServiceDescriptor());
-    for (ServerMethodDefinition<?, ?> serverMethod : ssd.getMethods()) {
-      MethodDescriptor<?, ?> method = serverMethod.getMethodDescriptor();
-      if (method1.equals(method)) {
-        assertSame(methodHandler1, serverMethod.getServerCallHandler());
-      } else if (method2.equals(method)) {
-        assertSame(methodHandler2, serverMethod.getServerCallHandler());
-      } else {
-        fail("Unexpected method descriptor: " + method.getFullMethodName());
-      }
-    }
-  }
-
-  @Test
-  public void addMethod_duplicateName() {
-    ServiceDescriptor sd = new ServiceDescriptor(serviceName, method1);
-    ServerServiceDefinition.Builder ssd = ServerServiceDefinition.builder(sd)
-        .addMethod(method1, methodHandler1);
-    thrown.expect(IllegalStateException.class);
-    ssd.addMethod(diffMethod1, methodHandler2)
-        .build();
-  }
-
-  @Test
-  public void buildMisaligned_extraMethod() {
-    ServiceDescriptor sd = new ServiceDescriptor(serviceName);
-    ServerServiceDefinition.Builder ssd = ServerServiceDefinition.builder(sd)
-        .addMethod(methodDef1);
-    thrown.expect(IllegalStateException.class);
-    ssd.build();
-  }
-
-  @Test
-  public void buildMisaligned_diffMethodInstance() {
-    ServiceDescriptor sd = new ServiceDescriptor(serviceName, method1);
-    ServerServiceDefinition.Builder ssd = ServerServiceDefinition.builder(sd)
-        .addMethod(diffMethod1, methodHandler1);
-    thrown.expect(IllegalStateException.class);
-    ssd.build();
-  }
-
-  @Test
-  public void buildMisaligned_missingMethod() {
-    ServiceDescriptor sd = new ServiceDescriptor(serviceName, method1);
-    ServerServiceDefinition.Builder ssd = ServerServiceDefinition.builder(sd);
-    thrown.expect(IllegalStateException.class);
-    ssd.build();
-  }
-
-  @Test
-  public void builderWithServiceName() {
-    ServerServiceDefinition ssd = ServerServiceDefinition.builder(serviceName)
-        .addMethod(methodDef1)
-        .addMethod(methodDef2)
-        .build();
-    assertEquals(serviceName, ssd.getServiceDescriptor().getName());
-
-    HashSet<MethodDescriptor<?, ?>> goldenMethods = new HashSet<MethodDescriptor<?, ?>>();
-    goldenMethods.add(method1);
-    goldenMethods.add(method2);
-    assertEquals(goldenMethods,
-        new HashSet<MethodDescriptor<?, ?>>(ssd.getServiceDescriptor().getMethods()));
-
-    HashSet<ServerMethodDefinition<?, ?>> goldenMethodDefs
-        = new HashSet<ServerMethodDefinition<?, ?>>();
-    goldenMethodDefs.add(methodDef1);
-    goldenMethodDefs.add(methodDef2);
-    assertEquals(goldenMethodDefs, new HashSet<ServerMethodDefinition<?, ?>>(ssd.getMethods()));
-  }
-
-  @Test
-  public void builderWithServiceName_noMethods() {
-    ServerServiceDefinition ssd = ServerServiceDefinition.builder(serviceName)
-        .build();
-    assertEquals(Collections.<MethodDescriptor<?, ?>>emptyList(),
-        ssd.getServiceDescriptor().getMethods());
-    assertEquals(Collections.<ServerMethodDefinition<?, ?>>emptySet(),
-        new HashSet<ServerMethodDefinition<?, ?>>(ssd.getMethods()));
-  }
-
-  private static class NoopServerCallHandler<ReqT, RespT>
-      implements ServerCallHandler<ReqT, RespT> {
-    @Override
-    public ServerCall.Listener<ReqT> startCall(ServerCall<ReqT, RespT> call, Metadata headers) {
-      throw new UnsupportedOperationException();
-    }
-  }
-}
diff --git a/core/src/test/java/io/grpc/ServiceDescriptorTest.java b/core/src/test/java/io/grpc/ServiceDescriptorTest.java
deleted file mode 100644
index 861f34af8e8..00000000000
--- a/core/src/test/java/io/grpc/ServiceDescriptorTest.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright 2017, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import io.grpc.MethodDescriptor.MethodType;
-import io.grpc.testing.TestMethodDescriptors;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Tests for {@link ServiceDescriptor}.
- */
-@RunWith(JUnit4.class)
-public class ServiceDescriptorTest {
-
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
-
-  @Test
-  public void failsOnNullName() {
-    thrown.expect(NullPointerException.class);
-    thrown.expectMessage("name");
-
-    new ServiceDescriptor(null, Collections.<MethodDescriptor<?, ?>>emptyList());
-  }
-
-  @Test
-  public void failsOnNullMethods() {
-    thrown.expect(NullPointerException.class);
-    thrown.expectMessage("methods");
-
-    new ServiceDescriptor("name", (Collection<MethodDescriptor<?, ?>>) null);
-  }
-
-  @Test
-  public void failsOnNullMethod() {
-    thrown.expect(NullPointerException.class);
-    thrown.expectMessage("method");
-
-    new ServiceDescriptor("name", (Collections.<MethodDescriptor<?, ?>>singletonList(null)));
-  }
-
-  @Test
-  public void failsOnNonMatchingNames() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("service names");
-
-    new ServiceDescriptor("name", Collections.<MethodDescriptor<?, ?>>singletonList(
-        MethodDescriptor.create(
-            MethodType.UNARY,
-            MethodDescriptor.generateFullMethodName("wrongservice", "method"),
-            TestMethodDescriptors.voidMarshaller(),
-            TestMethodDescriptors.voidMarshaller())));
-  }
-
-  @Test
-  public void failsOnNonDuplicateNames() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("duplicate");
-
-    new ServiceDescriptor("name", Arrays.<MethodDescriptor<?, ?>>asList(
-        MethodDescriptor.create(
-            MethodType.UNARY,
-            MethodDescriptor.generateFullMethodName("name", "method"),
-            TestMethodDescriptors.voidMarshaller(),
-            TestMethodDescriptors.voidMarshaller()),
-        MethodDescriptor.create(
-            MethodType.UNARY,
-            MethodDescriptor.generateFullMethodName("name", "method"),
-            TestMethodDescriptors.voidMarshaller(),
-            TestMethodDescriptors.voidMarshaller())));
-  }
-}
diff --git a/core/src/test/java/io/grpc/StatusTest.java b/core/src/test/java/io/grpc/StatusTest.java
deleted file mode 100644
index bd86b70055b..00000000000
--- a/core/src/test/java/io/grpc/StatusTest.java
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
-
-import io.grpc.Status.Code;
-import java.nio.charset.Charset;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link Status}. */
-@RunWith(JUnit4.class)
-public class StatusTest {
-  private final Charset ascii = Charset.forName("US-ASCII");
-
-  @Test
-  public void verifyExceptionMessage() {
-    assertEquals("UNKNOWN", Status.UNKNOWN.asRuntimeException().getMessage());
-    assertEquals("CANCELLED: This is a test",
-        Status.CANCELLED.withDescription("This is a test").asRuntimeException().getMessage());
-    assertEquals("UNKNOWN", Status.UNKNOWN.asException().getMessage());
-    assertEquals("CANCELLED: This is a test",
-        Status.CANCELLED.withDescription("This is a test").asException().getMessage());
-  }
-
-  @Test
-  public void impossibleCodeValue() {
-    assertEquals(Code.UNKNOWN, Status.fromCodeValue(-1).getCode());
-  }
-
-  @Test
-  public void sameCauseReturnsSelf() {
-    assertSame(Status.CANCELLED, Status.CANCELLED.withCause(null));
-  }
-
-  @Test
-  public void sameDescriptionReturnsSelf() {
-    assertSame(Status.CANCELLED, Status.CANCELLED.withDescription(null));
-    assertSame(Status.CANCELLED, Status.CANCELLED.augmentDescription(null));
-  }
-
-  @Test
-  public void useObjectHashCode() {
-    assertEquals(Status.CANCELLED.hashCode(), System.identityHashCode(Status.CANCELLED));
-  }
-
-  @Test
-  public void metadataEncode_lowAscii() {
-    byte[] b = Status.MESSAGE_KEY.toBytes("my favorite character is \u0000");
-    assertEquals("my favorite character is %00", new String(b, ascii));
-  }
-
-  @Test
-  public void metadataEncode_percent() {
-    byte[] b = Status.MESSAGE_KEY.toBytes("my favorite character is %");
-    assertEquals("my favorite character is %25", new String(b, ascii));
-  }
-
-  @Test
-  public void metadataEncode_surrogatePair() {
-    byte[] b = Status.MESSAGE_KEY.toBytes("my favorite character is 𐀁");
-    assertEquals("my favorite character is %F0%90%80%81", new String(b, ascii));
-  }
-
-  @Test
-  public void metadataEncode_unmatchedHighSurrogate() {
-    byte[] b = Status.MESSAGE_KEY.toBytes("my favorite character is " + ((char) 0xD801));
-    assertEquals("my favorite character is ?", new String(b, ascii));
-  }
-
-  @Test
-  public void metadataEncode_unmatchedLowSurrogate() {
-    byte[] b = Status.MESSAGE_KEY.toBytes("my favorite character is " + ((char)0xDC37));
-    assertEquals("my favorite character is ?", new String(b, ascii));
-  }
-
-  @Test
-  public void metadataEncode_maxSurrogatePair() {
-    byte[] b = Status.MESSAGE_KEY.toBytes(
-        "my favorite character is " + ((char)0xDBFF) + ((char)0xDFFF));
-    assertEquals("my favorite character is %F4%8F%BF%BF", new String(b, ascii));
-  }
-
-  @Test
-  public void metadataDecode_ascii() {
-    String s = Status.MESSAGE_KEY.parseBytes(new byte[]{'H', 'e', 'l', 'l', 'o'});
-    assertEquals("Hello", s);
-  }
-
-  @Test
-  public void metadataDecode_percent() {
-    String s = Status.MESSAGE_KEY.parseBytes(new byte[]{'H', '%', '6', '1', 'o'});
-    assertEquals("Hao", s);
-  }
-
-  @Test
-  public void metadataDecode_percentUnderflow() {
-    String s = Status.MESSAGE_KEY.parseBytes(new byte[]{'H', '%', '6'});
-    assertEquals("H%6", s);
-  }
-
-  @Test
-  public void metadataDecode_surrogate() {
-    String s = Status.MESSAGE_KEY.parseBytes(
-        new byte[]{'%', 'F', '0', '%', '9', '0', '%', '8', '0', '%', '8', '1'});
-    assertEquals("𐀁", s);
-  }
-
-  @Test
-  public void metadataDecode_badEncoding() {
-    String s = Status.MESSAGE_KEY.parseBytes(new byte[]{'%', 'G', '0'});
-    assertEquals("%G0", s);
-  }
-}
diff --git a/core/src/test/java/io/grpc/StringMarshaller.java b/core/src/test/java/io/grpc/StringMarshaller.java
deleted file mode 100644
index c9129f2e63e..00000000000
--- a/core/src/test/java/io/grpc/StringMarshaller.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc;
-
-import static com.google.common.base.Charsets.UTF_8;
-
-import com.google.common.io.ByteStreams;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-
-/** Marshalls UTF-8 encoded strings. */
-public class StringMarshaller implements MethodDescriptor.Marshaller<String> {
-  public static StringMarshaller INSTANCE = new StringMarshaller();
-
-  @Override
-  public InputStream stream(String value) {
-    return new ByteArrayInputStream(value.getBytes(UTF_8));
-  }
-
-  @Override
-  public String parse(InputStream stream) {
-    try {
-      return new String(ByteStreams.toByteArray(stream), UTF_8);
-    } catch (IOException ex) {
-      throw new RuntimeException(ex);
-    }
-  }
-}
diff --git a/core/src/test/java/io/grpc/inprocess/InProcessClientTransportFactoryTest.java b/core/src/test/java/io/grpc/inprocess/InProcessClientTransportFactoryTest.java
deleted file mode 100644
index 7c880e75b90..00000000000
--- a/core/src/test/java/io/grpc/inprocess/InProcessClientTransportFactoryTest.java
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.inprocess;
-
-import io.grpc.internal.ClientTransportFactory;
-import io.grpc.internal.testing.AbstractClientTransportFactoryTest;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-@RunWith(JUnit4.class)
-public class InProcessClientTransportFactoryTest extends AbstractClientTransportFactoryTest {
-
-  @Override
-  protected ClientTransportFactory newClientTransportFactory() {
-    return InProcessChannelBuilder.forName("test-transport").buildTransportFactory();
-  }
-}
diff --git a/core/src/test/java/io/grpc/inprocess/InProcessServerTest.java b/core/src/test/java/io/grpc/inprocess/InProcessServerTest.java
deleted file mode 100644
index 2060a89a9cb..00000000000
--- a/core/src/test/java/io/grpc/inprocess/InProcessServerTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.inprocess;
-
-import com.google.common.truth.Truth;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-@RunWith(JUnit4.class)
-public class InProcessServerTest {
-
-  @Test
-  public void getPort_notStarted() throws Exception {
-    InProcessServer s = new InProcessServer("name");
-
-    Truth.assertThat(s.getPort()).isEqualTo(-1);
-  }
-}
-
diff --git a/core/src/test/java/io/grpc/inprocess/InProcessTransportTest.java b/core/src/test/java/io/grpc/inprocess/InProcessTransportTest.java
deleted file mode 100644
index 68276ac5630..00000000000
--- a/core/src/test/java/io/grpc/inprocess/InProcessTransportTest.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.inprocess;
-
-import io.grpc.internal.InternalServer;
-import io.grpc.internal.ManagedClientTransport;
-import io.grpc.internal.testing.AbstractTransportTest;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link InProcessTransport}. */
-@RunWith(JUnit4.class)
-public class InProcessTransportTest extends AbstractTransportTest {
-  private static final String transportName = "perfect-for-testing";
-  private static final String authority = "a-testing-authority";
-
-  @Override
-  protected InternalServer newServer() {
-    return new InProcessServer(transportName);
-  }
-
-  @Override
-  protected InternalServer newServer(InternalServer server) {
-    return newServer();
-  }
-
-  @Override
-  protected String testAuthority(InternalServer server) {
-    return authority;
-  }
-
-  @Override
-  protected ManagedClientTransport newClientTransport(InternalServer server) {
-    return new InProcessTransport(transportName, testAuthority(server));
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/AbstractClientStream2Test.java b/core/src/test/java/io/grpc/internal/AbstractClientStream2Test.java
deleted file mode 100644
index 3ab1aad2cdf..00000000000
--- a/core/src/test/java/io/grpc/internal/AbstractClientStream2Test.java
+++ /dev/null
@@ -1,292 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.verify;
-
-import io.grpc.Attributes;
-import io.grpc.Codec;
-import io.grpc.Metadata;
-import io.grpc.Status;
-import io.grpc.Status.Code;
-import io.grpc.internal.MessageFramerTest.ByteWritableBuffer;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-/**
- * Test for {@link AbstractClientStream2}.  This class tries to test functionality in
- * AbstractClientStream2, but not in any super classes.
- */
-@RunWith(JUnit4.class)
-public class AbstractClientStream2Test {
-
-  @Rule public final ExpectedException thrown = ExpectedException.none();
-
-  private final StatsTraceContext statsTraceCtx = StatsTraceContext.NOOP;
-  @Mock private ClientStreamListener mockListener;
-  @Captor private ArgumentCaptor<Status> statusCaptor;
-
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-  }
-
-  private final WritableBufferAllocator allocator = new WritableBufferAllocator() {
-    @Override
-    public WritableBuffer allocate(int capacityHint) {
-      return new ByteWritableBuffer(capacityHint);
-    }
-  };
-
-  @Test
-  public void cancel_doNotAcceptOk() {
-    for (Code code : Code.values()) {
-      ClientStreamListener listener = new NoopClientStreamListener();
-      AbstractClientStream2 stream = new BaseAbstractClientStream(allocator, statsTraceCtx);
-      stream.start(listener);
-      if (code != Code.OK) {
-        stream.cancel(Status.fromCodeValue(code.value()));
-      } else {
-        try {
-          stream.cancel(Status.fromCodeValue(code.value()));
-          fail();
-        } catch (IllegalArgumentException e) {
-          // ignore
-        }
-      }
-    }
-  }
-
-  @Test
-  public void cancel_failsOnNull() {
-    ClientStreamListener listener = new NoopClientStreamListener();
-    AbstractClientStream2 stream = new BaseAbstractClientStream(allocator, statsTraceCtx);
-    stream.start(listener);
-    thrown.expect(NullPointerException.class);
-
-    stream.cancel(null);
-  }
-
-  @Test
-  public void cancel_notifiesOnlyOnce() {
-    final BaseTransportState state = new BaseTransportState(statsTraceCtx);
-    AbstractClientStream2 stream = new BaseAbstractClientStream(allocator, state, new BaseSink() {
-      @Override
-      public void cancel(Status errorStatus) {
-        // Cancel should eventually result in a transportReportStatus on the transport thread
-        state.transportReportStatus(errorStatus, true/*stop delivery*/, new Metadata());
-      }
-      }, statsTraceCtx);
-    stream.start(mockListener);
-
-    stream.cancel(Status.DEADLINE_EXCEEDED);
-    stream.cancel(Status.DEADLINE_EXCEEDED);
-
-    verify(mockListener).closed(any(Status.class), any(Metadata.class));
-  }
-
-  @Test
-  public void startFailsOnNullListener() {
-    AbstractClientStream2 stream = new BaseAbstractClientStream(allocator, statsTraceCtx);
-
-    thrown.expect(NullPointerException.class);
-
-    stream.start(null);
-  }
-
-  @Test
-  public void cantCallStartTwice() {
-    AbstractClientStream2 stream = new BaseAbstractClientStream(allocator, statsTraceCtx);
-    stream.start(mockListener);
-    thrown.expect(IllegalStateException.class);
-
-    stream.start(mockListener);
-  }
-
-  @Test
-  public void inboundDataReceived_failsOnNullFrame() {
-    ClientStreamListener listener = new NoopClientStreamListener();
-    AbstractClientStream2 stream = new BaseAbstractClientStream(allocator, statsTraceCtx);
-    stream.start(listener);
-    thrown.expect(NullPointerException.class);
-
-    stream.transportState().inboundDataReceived(null);
-  }
-
-  @Test
-  public void inboundDataReceived_failsOnNoHeaders() {
-    AbstractClientStream2 stream = new BaseAbstractClientStream(allocator, statsTraceCtx);
-    stream.start(mockListener);
-
-    stream.transportState().inboundDataReceived(ReadableBuffers.empty());
-
-    verify(mockListener).closed(statusCaptor.capture(), any(Metadata.class));
-    assertEquals(Code.INTERNAL, statusCaptor.getValue().getCode());
-  }
-
-  @Test
-  public void inboundHeadersReceived_notifiesListener() {
-    AbstractClientStream2 stream = new BaseAbstractClientStream(allocator, statsTraceCtx);
-    stream.start(mockListener);
-    Metadata headers = new Metadata();
-
-    stream.transportState().inboundHeadersReceived(headers);
-    verify(mockListener).headersRead(headers);
-  }
-
-  @Test
-  public void inboundHeadersReceived_failsIfStatusReported() {
-    AbstractClientStream2 stream = new BaseAbstractClientStream(allocator, statsTraceCtx);
-    stream.start(mockListener);
-    stream.transportState().transportReportStatus(Status.CANCELLED, false, new Metadata());
-
-    thrown.expect(IllegalStateException.class);
-    stream.transportState().inboundHeadersReceived(new Metadata());
-  }
-
-  @Test
-  public void inboundHeadersReceived_acceptsGzipEncoding() {
-    AbstractClientStream2 stream = new BaseAbstractClientStream(allocator, statsTraceCtx);
-    stream.start(mockListener);
-    Metadata headers = new Metadata();
-    headers.put(GrpcUtil.MESSAGE_ENCODING_KEY, new Codec.Gzip().getMessageEncoding());
-
-    stream.transportState().inboundHeadersReceived(headers);
-    verify(mockListener).headersRead(headers);
-  }
-
-  @Test
-  public void inboundHeadersReceived_acceptsIdentityEncoding() {
-    AbstractClientStream2 stream = new BaseAbstractClientStream(allocator, statsTraceCtx);
-    stream.start(mockListener);
-    Metadata headers = new Metadata();
-    headers.put(GrpcUtil.MESSAGE_ENCODING_KEY, Codec.Identity.NONE.getMessageEncoding());
-
-    stream.transportState().inboundHeadersReceived(headers);
-    verify(mockListener).headersRead(headers);
-  }
-
-  @Test
-  public void rstStreamClosesStream() {
-    AbstractClientStream2 stream = new BaseAbstractClientStream(allocator, statsTraceCtx);
-    stream.start(mockListener);
-    // The application will call request when waiting for a message, which will in turn call this
-    // on the transport thread.
-    stream.transportState().requestMessagesFromDeframer(1);
-    // Send first byte of 2 byte message
-    stream.transportState().deframe(ReadableBuffers.wrap(new byte[] {0, 0, 0, 0, 2, 1}), false);
-    Status status = Status.INTERNAL;
-    // Simulate getting a reset
-    stream.transportState().transportReportStatus(status, false /*stop delivery*/, new Metadata());
-
-    verify(mockListener).closed(any(Status.class), any(Metadata.class));
-  }
-
-  /**
-   * No-op base class for testing.
-   */
-  private static class BaseAbstractClientStream extends AbstractClientStream2 {
-    private final TransportState state;
-    private final Sink sink;
-
-    public BaseAbstractClientStream(WritableBufferAllocator allocator,
-        StatsTraceContext statsTraceCtx) {
-      this(allocator, new BaseTransportState(statsTraceCtx), new BaseSink(), statsTraceCtx);
-    }
-
-    public BaseAbstractClientStream(WritableBufferAllocator allocator, TransportState state,
-        Sink sink, StatsTraceContext statsTraceCtx) {
-      super(allocator, statsTraceCtx);
-      this.state = state;
-      this.sink = sink;
-    }
-
-    @Override
-    protected Sink abstractClientStreamSink() {
-      return sink;
-    }
-
-    @Override
-    public TransportState transportState() {
-      return state;
-    }
-
-    @Override
-    public void setAuthority(String authority) {}
-
-    @Override
-    public void setMaxInboundMessageSize(int maxSize) {}
-
-    @Override
-    public void setMaxOutboundMessageSize(int maxSize) {}
-
-    @Override
-    public Attributes getAttributes() {
-      return Attributes.EMPTY;
-    }
-  }
-
-  private static class BaseSink implements AbstractClientStream2.Sink {
-    @Override
-    public void request(int numMessages) {}
-
-    @Override
-    public void writeFrame(WritableBuffer frame, boolean endOfStream, boolean flush) {}
-
-    @Override
-    public void cancel(Status reason) {}
-  }
-
-  private static class BaseTransportState extends AbstractClientStream2.TransportState {
-    public BaseTransportState(StatsTraceContext statsTraceCtx) {
-      super(DEFAULT_MAX_MESSAGE_SIZE, statsTraceCtx);
-    }
-
-    @Override
-    protected void deframeFailed(Throwable cause) {}
-
-    @Override
-    public void bytesRead(int processedBytes) {}
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/AbstractClientStreamTest.java b/core/src/test/java/io/grpc/internal/AbstractClientStreamTest.java
index 029017e0afa..8f14b74035c 100644
--- a/core/src/test/java/io/grpc/internal/AbstractClientStreamTest.java
+++ b/core/src/test/java/io/grpc/internal/AbstractClientStreamTest.java
@@ -1,60 +1,72 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
 import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.isA;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 import io.grpc.Attributes;
+import io.grpc.CallOptions;
 import io.grpc.Codec;
+import io.grpc.Deadline;
+import io.grpc.Grpc;
 import io.grpc.Metadata;
 import io.grpc.Status;
 import io.grpc.Status.Code;
-import io.grpc.internal.AbstractStream.Phase;
+import io.grpc.StreamTracer;
+import io.grpc.internal.AbstractClientStream.TransportState;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
 import io.grpc.internal.MessageFramerTest.ByteWritableBuffer;
+import io.grpc.internal.testing.TestClientStreamTracer;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.SocketAddress;
+import java.util.concurrent.TimeUnit;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
 
 /**
  * Test for {@link AbstractClientStream}.  This class tries to test functionality in
@@ -63,14 +75,30 @@
 @RunWith(JUnit4.class)
 public class AbstractClientStreamTest {
 
-  @Rule public final ExpectedException thrown = ExpectedException.none();
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private final StatsTraceContext statsTraceCtx = StatsTraceContext.NOOP;
+  private final TransportTracer transportTracer = new TransportTracer();
+  private static final SocketAddress SERVER_ADDR = new SocketAddress() {
+      @Override
+      public String toString() {
+        return "fake_server_addr";
+      }
+    };
 
   @Mock private ClientStreamListener mockListener;
-  @Captor private ArgumentCaptor<Status> statusCaptor;
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
+    doAnswer(new Answer<Void>() {
+      @Override
+      public Void answer(InvocationOnMock invocation) throws Throwable {
+        StreamListener.MessageProducer producer =
+            (StreamListener.MessageProducer) invocation.getArguments()[0];
+        while (producer.next() != null) {}
+        return null;
+      }
+    }).when(mockListener).messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
   }
 
   private final WritableBufferAllocator allocator = new WritableBufferAllocator() {
@@ -84,7 +112,8 @@ public WritableBuffer allocate(int capacityHint) {
   public void cancel_doNotAcceptOk() {
     for (Code code : Code.values()) {
       ClientStreamListener listener = new NoopClientStreamListener();
-      AbstractClientStream stream = new BaseAbstractClientStream(allocator);
+      AbstractClientStream stream =
+          new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
       stream.start(listener);
       if (code != Code.OK) {
         stream.cancel(Status.fromCodeValue(code.value()));
@@ -102,187 +131,516 @@ public void cancel_doNotAcceptOk() {
   @Test
   public void cancel_failsOnNull() {
     ClientStreamListener listener = new NoopClientStreamListener();
-    AbstractClientStream stream = new BaseAbstractClientStream(allocator);
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
     stream.start(listener);
-    thrown.expect(NullPointerException.class);
-
-    stream.cancel(null);
+    assertThrows(NullPointerException.class, () -> stream.cancel(null));
   }
 
   @Test
   public void cancel_notifiesOnlyOnce() {
-    AbstractClientStream stream = new BaseAbstractClientStream(allocator) {
+    final BaseTransportState state = new BaseTransportState(statsTraceCtx, transportTracer);
+    AbstractClientStream stream = new BaseAbstractClientStream(allocator, state, new BaseSink() {
       @Override
-      protected void sendCancel(Status errorStatus) {
-        transportReportStatus(errorStatus, true/*stop delivery*/, new Metadata());
+      public void cancel(Status errorStatus) {
+        // Cancel should eventually result in a transportReportStatus on the transport thread
+        state.transportReportStatus(errorStatus, true/*stop delivery*/, new Metadata());
       }
-    };
+    }, statsTraceCtx, transportTracer);
     stream.start(mockListener);
 
+    stream.cancel(Status.DEADLINE_EXCEEDED);
     stream.cancel(Status.DEADLINE_EXCEEDED);
 
-    verify(mockListener).closed(isA(Status.class), isA(Metadata.class));
+    verify(mockListener).closed(any(Status.class), same(PROCESSED), any(Metadata.class));
   }
 
   @Test
   public void startFailsOnNullListener() {
-    AbstractClientStream stream = new BaseAbstractClientStream(allocator);
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
 
-    thrown.expect(NullPointerException.class);
-
-    stream.start(null);
+    assertThrows(NullPointerException.class, () -> stream.start(null));
   }
 
   @Test
   public void cantCallStartTwice() {
-    AbstractClientStream stream = new BaseAbstractClientStream(allocator);
-    stream.start(mockListener);
-    thrown.expect(IllegalStateException.class);
-
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
     stream.start(mockListener);
+    assertThrows(IllegalStateException.class, () -> stream.start(mockListener));
   }
 
   @Test
-  public void deframeFailed_notifiesListener() {
-    AbstractClientStream stream = new BaseAbstractClientStream(allocator) {
-      @Override
-      protected void sendCancel(Status errorStatus) {
-        transportReportStatus(errorStatus, true/*stop delivery*/, new Metadata());
-      }
-    };
-    stream.start(mockListener);
+  public void inboundDataReceived_failsOnNullFrame() {
+    ClientStreamListener listener = new NoopClientStreamListener();
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
+    stream.start(listener);
 
-    stream.deframeFailed(new RuntimeException("something bad"));
+    TransportState state = stream.transportState();
 
-    verify(mockListener).closed(statusCaptor.capture(), isA(Metadata.class));
-    assertEquals(Code.INTERNAL, statusCaptor.getValue().getCode());
+    assertThrows(NullPointerException.class, () -> state.inboundDataReceived(null));
   }
 
   @Test
-  public void inboundDataReceived_failsOnNullFrame() {
-    ClientStreamListener listener = new NoopClientStreamListener();
-    AbstractClientStream stream = new BaseAbstractClientStream(allocator);
-    stream.start(listener);
-    thrown.expect(NullPointerException.class);
+  public void inboundHeadersReceived_notifiesListener() {
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
+    stream.start(mockListener);
+    Metadata headers = new Metadata();
 
-    stream.inboundDataReceived(null);
+    stream.transportState().inboundHeadersReceived(headers);
+    verify(mockListener).headersRead(headers);
   }
 
   @Test
-  public void inboundDataReceived_failsOnNoHeaders() {
-    AbstractClientStream stream = new BaseAbstractClientStream(allocator);
+  public void inboundHeadersReceived_failsIfStatusReported() {
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
     stream.start(mockListener);
-    stream.inboundPhase(Phase.HEADERS);
+    stream.transportState().transportReportStatus(Status.CANCELLED, false, new Metadata());
 
-    stream.inboundDataReceived(ReadableBuffers.empty());
+    TransportState state = stream.transportState();
 
-    verify(mockListener).closed(statusCaptor.capture(), isA(Metadata.class));
-    assertEquals(Code.INTERNAL, statusCaptor.getValue().getCode());
+    Metadata headers = new Metadata();
+    assertThrows(IllegalStateException.class, () -> state.inboundHeadersReceived(headers));
   }
 
   @Test
-  public void inboundHeadersReceived_notifiesListener() {
-    AbstractClientStream stream = new BaseAbstractClientStream(allocator);
+  public void inboundHeadersReceived_acceptsGzipContentEncoding() {
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
     stream.start(mockListener);
     Metadata headers = new Metadata();
+    headers.put(GrpcUtil.CONTENT_ENCODING_KEY, "gzip");
+
+    stream.setFullStreamDecompression(true);
+    stream.transportState().inboundHeadersReceived(headers);
 
-    stream.inboundHeadersReceived(headers);
     verify(mockListener).headersRead(headers);
   }
 
   @Test
-  public void inboundHeadersReceived_failsOnPhaseStatus() {
-    AbstractClientStream stream = new BaseAbstractClientStream(allocator);
+  // https://tools.ietf.org/html/rfc7231#section-3.1.2.1
+  public void inboundHeadersReceived_contentEncodingIsCaseInsensitive() {
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
     stream.start(mockListener);
     Metadata headers = new Metadata();
-    stream.inboundPhase(Phase.STATUS);
+    headers.put(GrpcUtil.CONTENT_ENCODING_KEY, "gZIp");
 
-    thrown.expect(IllegalStateException.class);
+    stream.setFullStreamDecompression(true);
+    stream.transportState().inboundHeadersReceived(headers);
 
-    stream.inboundHeadersReceived(headers);
+    verify(mockListener).headersRead(headers);
   }
 
   @Test
-  public void inboundHeadersReceived_succeedsOnPhaseMessage() {
-    AbstractClientStream stream = new BaseAbstractClientStream(allocator);
+  public void inboundHeadersReceived_failsOnUnrecognizedContentEncoding() {
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
     stream.start(mockListener);
     Metadata headers = new Metadata();
-    stream.inboundPhase(Phase.MESSAGE);
+    headers.put(GrpcUtil.CONTENT_ENCODING_KEY, "not-a-real-compression-method");
+
+    stream.setFullStreamDecompression(true);
+    stream.transportState().inboundHeadersReceived(headers);
+
+    verifyNoMoreInteractions(mockListener);
+    Throwable t = ((BaseTransportState) stream.transportState()).getDeframeFailedCause();
+    assertEquals(Status.INTERNAL.getCode(), Status.fromThrowable(t).getCode());
+    assertTrue(
+        "unexpected deframe failed description",
+        Status.fromThrowable(t)
+            .getDescription()
+            .startsWith("Can't find full stream decompressor for"));
+  }
 
-    stream.inboundHeadersReceived(headers);
+  @Test
+  public void inboundHeadersReceived_disallowsContentAndMessageEncoding() {
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
+    stream.start(mockListener);
+    Metadata headers = new Metadata();
+    headers.put(GrpcUtil.CONTENT_ENCODING_KEY, "gzip");
+    headers.put(GrpcUtil.MESSAGE_ENCODING_KEY, new Codec.Gzip().getMessageEncoding());
 
-    verify(mockListener).headersRead(headers);
+    stream.setFullStreamDecompression(true);
+    stream.transportState().inboundHeadersReceived(headers);
+
+    verifyNoMoreInteractions(mockListener);
+    Throwable t = ((BaseTransportState) stream.transportState()).getDeframeFailedCause();
+    assertEquals(Status.INTERNAL.getCode(), Status.fromThrowable(t).getCode());
+    assertTrue(
+        "unexpected deframe failed description",
+        Status.fromThrowable(t)
+            .getDescription()
+            .equals("Full stream and gRPC message encoding cannot both be set"));
   }
 
   @Test
-  public void inboundHeadersReceived_acceptsGzipEncoding() {
-    AbstractClientStream stream = new BaseAbstractClientStream(allocator);
+  public void inboundHeadersReceived_acceptsGzipMessageEncoding() {
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
     stream.start(mockListener);
     Metadata headers = new Metadata();
     headers.put(GrpcUtil.MESSAGE_ENCODING_KEY, new Codec.Gzip().getMessageEncoding());
 
-    stream.inboundHeadersReceived(headers);
+    stream.transportState().inboundHeadersReceived(headers);
     verify(mockListener).headersRead(headers);
   }
 
   @Test
-  public void inboundHeadersReceived_acceptsIdentityEncoding() {
-    AbstractClientStream stream = new BaseAbstractClientStream(allocator);
+  public void inboundHeadersReceived_acceptsIdentityMessageEncoding() {
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
     stream.start(mockListener);
     Metadata headers = new Metadata();
     headers.put(GrpcUtil.MESSAGE_ENCODING_KEY, Codec.Identity.NONE.getMessageEncoding());
 
-    stream.inboundHeadersReceived(headers);
+    stream.transportState().inboundHeadersReceived(headers);
     verify(mockListener).headersRead(headers);
   }
 
+  @Test
+  public void inboundHeadersReceived_failsOnUnrecognizedMessageEncoding() {
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
+    stream.start(mockListener);
+    Metadata headers = new Metadata();
+    headers.put(GrpcUtil.MESSAGE_ENCODING_KEY, "not-a-real-compression-method");
+
+    stream.transportState().inboundHeadersReceived(headers);
+
+    verifyNoMoreInteractions(mockListener);
+    Throwable t = ((BaseTransportState) stream.transportState()).getDeframeFailedCause();
+    assertEquals(Status.INTERNAL.getCode(), Status.fromThrowable(t).getCode());
+    assertTrue(
+        "unexpected deframe failed description",
+        Status.fromThrowable(t).getDescription().startsWith("Can't find decompressor for"));
+  }
+
   @Test
   public void rstStreamClosesStream() {
-    AbstractClientStream stream = new BaseAbstractClientStream(allocator);
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
     stream.start(mockListener);
-    // The application will call request when waiting for a message, which will in turn call this
-    // on the transport thread.
-    stream.requestMessagesFromDeframer(1);
+    // The application will call request when waiting for a message
+    stream.request(1);
     // Send first byte of 2 byte message
-    stream.deframe(ReadableBuffers.wrap(new byte[] {0, 0, 0, 0, 2, 1}), false);
-    Status status = Status.INTERNAL;
+    stream.transportState().deframe(ReadableBuffers.wrap(new byte[] {0, 0, 0, 0, 2, 1}));
+    Status status = Status.INTERNAL.withDescription("rst___stream");
     // Simulate getting a reset
-    stream.transportReportStatus(status, false /*stop delivery*/, new Metadata());
+    stream.transportState().transportReportStatus(status, false /*stop delivery*/, new Metadata());
 
-    assertTrue(stream.isClosed());
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockListener)
+        .closed(statusCaptor.capture(), any(RpcProgress.class), any(Metadata.class));
+    assertSame(Status.Code.INTERNAL, statusCaptor.getValue().getCode());
+    assertEquals("rst___stream", statusCaptor.getValue().getDescription());
+  }
+
+  @Test
+  public void statusOkFollowedByRstStreamNoError() {
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
+    stream.start(mockListener);
+    stream.transportState().deframe(ReadableBuffers.wrap(new byte[] {0, 0, 0, 0, 1, 1}));
+    stream.transportState().inboundTrailersReceived(new Metadata(), Status.OK);
+    Status status = Status.INTERNAL.withDescription("rst___stream");
+    // Simulate getting a reset
+    stream.transportState().transportReportStatus(status, false /*stop delivery*/, new Metadata());
+    stream.request(1);
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockListener)
+        .closed(statusCaptor.capture(), any(RpcProgress.class), any(Metadata.class));
+    assertTrue(statusCaptor.getValue().isOk());
+  }
+
+  @Test
+  public void trailerOkWithTruncatedMessage() {
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
+    stream.start(mockListener);
+
+    stream.request(1);
+    stream.transportState().deframe(ReadableBuffers.wrap(new byte[] {0, 0, 0, 0, 2, 1}));
+    stream.transportState().inboundTrailersReceived(new Metadata(), Status.OK);
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockListener)
+        .closed(statusCaptor.capture(), any(RpcProgress.class), any(Metadata.class));
+    assertSame(Status.Code.INTERNAL, statusCaptor.getValue().getCode());
+    assertEquals("Encountered end-of-stream mid-frame", statusCaptor.getValue().getDescription());
+  }
+
+  @Test
+  public void trailerNotOkWithTruncatedMessage() {
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
+    stream.start(mockListener);
+
+    stream.request(1);
+    stream.transportState().deframe(ReadableBuffers.wrap(new byte[] {0, 0, 0, 0, 2, 1}));
+    stream.transportState().inboundTrailersReceived(
+        new Metadata(), Status.DATA_LOSS.withDescription("data___loss"));
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockListener)
+        .closed(statusCaptor.capture(), any(RpcProgress.class), any(Metadata.class));
+    assertSame(Status.Code.DATA_LOSS, statusCaptor.getValue().getCode());
+    assertEquals("data___loss", statusCaptor.getValue().getDescription());
+  }
+
+  @Test
+  public void getRequest() {
+    AbstractClientStream.Sink sink = mock(AbstractClientStream.Sink.class);
+    final TestClientStreamTracer tracer = new TestClientStreamTracer();
+    StatsTraceContext statsTraceCtx = new StatsTraceContext(new StreamTracer[]{tracer});
+    AbstractClientStream stream = new BaseAbstractClientStream(
+        allocator,
+        new BaseTransportState(statsTraceCtx, transportTracer),
+        sink,
+        statsTraceCtx,
+        transportTracer,
+        true);
+    stream.start(mockListener);
+    stream.writeMessage(new ByteArrayInputStream(new byte[1]));
+    // writeHeaders will be delayed since we're sending a GET request.
+    verify(sink, never()).writeHeaders(any(Metadata.class), any(byte[].class));
+    // halfClose will trigger writeHeaders.
+    stream.halfClose();
+    ArgumentCaptor<byte[]> payloadCaptor = ArgumentCaptor.forClass(byte[].class);
+    verify(sink).writeHeaders(any(Metadata.class), payloadCaptor.capture());
+    assertTrue(payloadCaptor.getValue() != null);
+    // GET requests don't have BODY.
+    verify(sink, never())
+        .writeFrame(any(WritableBuffer.class), anyBoolean(), anyBoolean(), anyInt());
+    assertThat(tracer.nextOutboundEvent()).isEqualTo("outboundMessage(0)");
+    assertThat(tracer.nextOutboundEvent()).matches("outboundMessageSent\\(0, [0-9]+, [0-9]+\\)");
+    assertNull(tracer.nextOutboundEvent());
+    assertNull(tracer.nextInboundEvent());
+    assertEquals(1, tracer.getOutboundWireSize());
+    assertEquals(1, tracer.getOutboundUncompressedSize());
+  }
+
+  @Test
+  public void writeMessage_closesStream() throws IOException {
+    AbstractClientStream.Sink sink = mock(AbstractClientStream.Sink.class);
+    final TestClientStreamTracer tracer = new TestClientStreamTracer();
+    StatsTraceContext statsTraceCtx = new StatsTraceContext(new StreamTracer[] {tracer});
+    AbstractClientStream stream = new BaseAbstractClientStream(
+        allocator,
+        new BaseTransportState(statsTraceCtx, transportTracer),
+        sink,
+        statsTraceCtx,
+        transportTracer,
+        true);
+    stream.start(mockListener);
+    InputStream input = mock(InputStream.class, delegatesTo(new ByteArrayInputStream(new byte[1])));
+    stream.writeMessage(input);
+    verify(input).close();
+  }
+
+  @Test
+  public void deadlineTimeoutPopulatedToHeaders() {
+    AbstractClientStream.Sink sink = mock(AbstractClientStream.Sink.class);
+    ClientStream stream = new BaseAbstractClientStream(
+        allocator, new BaseTransportState(statsTraceCtx, transportTracer), sink, statsTraceCtx,
+        transportTracer);
+
+    stream.setDeadline(Deadline.after(1, TimeUnit.SECONDS));
+    stream.start(mockListener);
+
+    ArgumentCaptor<Metadata> headersCaptor = ArgumentCaptor.forClass(Metadata.class);
+    verify(sink).writeHeaders(headersCaptor.capture(), ArgumentMatchers.<byte[]>any());
+
+    Metadata headers = headersCaptor.getValue();
+    assertTrue(headers.containsKey(GrpcUtil.TIMEOUT_KEY));
+    assertThat(headers.get(GrpcUtil.TIMEOUT_KEY).longValue())
+        .isLessThan(TimeUnit.SECONDS.toNanos(1));
+    assertThat(headers.get(GrpcUtil.TIMEOUT_KEY).longValue())
+        .isGreaterThan(TimeUnit.MILLISECONDS.toNanos(600));
+  }
+
+  @Test
+  public void setDeadline_thePastBecomesPositive() {
+    AbstractClientStream.Sink sink = mock(AbstractClientStream.Sink.class);
+    ClientStream stream = new BaseAbstractClientStream(
+        allocator, new BaseTransportState(statsTraceCtx, transportTracer), sink, statsTraceCtx,
+        transportTracer);
+
+    stream.setDeadline(Deadline.after(-1, TimeUnit.NANOSECONDS));
+    stream.start(mockListener);
+
+    ArgumentCaptor<Metadata> headersCaptor = ArgumentCaptor.forClass(Metadata.class);
+    verify(sink).writeHeaders(headersCaptor.capture(), ArgumentMatchers.<byte[]>any());
+
+    Metadata headers = headersCaptor.getValue();
+    assertThat(headers.get(Metadata.Key.of("grpc-timeout", Metadata.ASCII_STRING_MARSHALLER)))
+        .isEqualTo("1n");
+  }
+
+  @Test
+  public void appendTimeoutInsight() {
+    InsightBuilder insight = new InsightBuilder();
+    AbstractClientStream stream =
+        new BaseAbstractClientStream(allocator, statsTraceCtx, transportTracer);
+    stream.appendTimeoutInsight(insight);
+    assertThat(insight.toString()).isEqualTo("[remote_addr=fake_server_addr]");
+  }
+
+  @Test
+  public void overrideOnReadyThreshold() {
+    AbstractClientStream.Sink sink = mock(AbstractClientStream.Sink.class);
+    BaseTransportState state = new BaseTransportState(statsTraceCtx, transportTracer);
+    AbstractClientStream stream = new BaseAbstractClientStream(
+        allocator,
+        state,
+        sink,
+        statsTraceCtx,
+        transportTracer,
+        CallOptions.DEFAULT.withOnReadyThreshold(10),
+        true);
+    ClientStreamListener listener = new NoopClientStreamListener();
+    stream.start(listener);
+    state.onStreamAllocated();
+
+    // Stream should be ready. 0 bytes are queued.
+    assertTrue(stream.isReady());
+
+    // Queue some bytes above the custom threshold and check that the stream is not ready.
+    stream.onSendingBytes(100);
+    assertFalse(stream.isReady());
+
+    // Simulate a flush and verify ready now.
+    stream.transportState().onSentBytes(91);
+    assertTrue(stream.isReady());
+  }
+
+  @Test
+  public void resetOnReadyThreshold() {
+    CallOptions options = CallOptions.DEFAULT.withOnReadyThreshold(10);
+    assertEquals(Integer.valueOf(10), options.getOnReadyThreshold());
+    assertNull(options.clearOnReadyThreshold().getOnReadyThreshold());
   }
 
   /**
    * No-op base class for testing.
    */
   private static class BaseAbstractClientStream extends AbstractClientStream {
-    protected BaseAbstractClientStream(WritableBufferAllocator allocator) {
-      super(allocator, DEFAULT_MAX_MESSAGE_SIZE, StatsTraceContext.NOOP);
+    private final TransportState state;
+    private final Sink sink;
+
+    public BaseAbstractClientStream(
+        WritableBufferAllocator allocator,
+        StatsTraceContext statsTraceCtx,
+        TransportTracer transportTracer) {
+      this(
+          allocator,
+          new BaseTransportState(statsTraceCtx, transportTracer),
+          new BaseSink(),
+          statsTraceCtx,
+          transportTracer);
+    }
+
+    public BaseAbstractClientStream(
+        WritableBufferAllocator allocator,
+        TransportState state,
+        Sink sink,
+        StatsTraceContext statsTraceCtx,
+        TransportTracer transportTracer) {
+      this(allocator, state, sink, statsTraceCtx, transportTracer, false);
+    }
+
+    public BaseAbstractClientStream(
+        WritableBufferAllocator allocator,
+        TransportState state,
+        Sink sink,
+        StatsTraceContext statsTraceCtx,
+        TransportTracer transportTracer,
+        boolean useGet) {
+      this(allocator, state, sink, statsTraceCtx, transportTracer, CallOptions.DEFAULT, useGet);
+    }
+
+    public BaseAbstractClientStream(
+        WritableBufferAllocator allocator,
+        TransportState state,
+        Sink sink,
+        StatsTraceContext statsTraceCtx,
+        TransportTracer transportTracer,
+        CallOptions callOptions,
+        boolean useGet) {
+      super(allocator, statsTraceCtx, transportTracer, new Metadata(), callOptions, useGet);
+      this.state = state;
+      this.sink = sink;
+      if (callOptions.getOnReadyThreshold() != null) {
+        this.transportState().setOnReadyThreshold(callOptions.getOnReadyThreshold());
+      }
+    }
+
+    @Override
+    protected Sink abstractClientStreamSink() {
+      return sink;
+    }
+
+    @Override
+    public TransportState transportState() {
+      return state;
     }
 
     @Override
     public void setAuthority(String authority) {}
 
+    @Override
+    public void setMaxInboundMessageSize(int maxSize) {}
+
+    @Override
+    public void setMaxOutboundMessageSize(int maxSize) {}
+
     @Override
     public Attributes getAttributes() {
-      return Attributes.EMPTY;
+      return Attributes.newBuilder().set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, SERVER_ADDR).build();
     }
+  }
 
+  private static class BaseSink implements AbstractClientStream.Sink {
     @Override
-    public void request(int numMessages) {}
+    public void writeHeaders(Metadata headers, byte[] payload) {}
 
     @Override
-    protected void sendFrame(WritableBuffer frame, boolean endOfStream, boolean flush) {}
+    public void writeFrame(
+        WritableBuffer frame, boolean endOfStream, boolean flush, int numMessages) {}
 
     @Override
-    protected void sendCancel(Status reason) {}
+    public void cancel(Status reason) {}
+  }
+
+  private static class BaseTransportState extends AbstractClientStream.TransportState {
+    private Throwable deframeFailedCause;
+
+    private Throwable getDeframeFailedCause() {
+      return deframeFailedCause;
+    }
+
+    public BaseTransportState(StatsTraceContext statsTraceCtx, TransportTracer transportTracer) {
+      super(DEFAULT_MAX_MESSAGE_SIZE, statsTraceCtx, transportTracer, CallOptions.DEFAULT);
+    }
 
     @Override
-    public int id() {
-      return ABSENT_ID;
+    public void deframeFailed(Throwable cause) {
+      assertNull("deframeFailed already called", deframeFailedCause);
+      deframeFailedCause = cause;
     }
 
     @Override
-    protected void returnProcessedBytes(int processedBytes) {}
+    public void bytesRead(int processedBytes) {}
+
+    @Override
+    public void runOnTransportThread(Runnable r) {
+      r.run();
+    }
   }
 }
diff --git a/core/src/test/java/io/grpc/internal/AbstractManagedChannelImplBuilderTest.java b/core/src/test/java/io/grpc/internal/AbstractManagedChannelImplBuilderTest.java
deleted file mode 100644
index 3413e778155..00000000000
--- a/core/src/test/java/io/grpc/internal/AbstractManagedChannelImplBuilderTest.java
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-
-import java.net.InetSocketAddress;
-import java.net.URI;
-import java.util.concurrent.TimeUnit;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link AbstractManagedChannelImplBuilder}. */
-@RunWith(JUnit4.class)
-public class AbstractManagedChannelImplBuilderTest {
-  @Test
-  public void makeTargetStringForDirectAddress_scopedIpv6() throws Exception {
-    InetSocketAddress address = new InetSocketAddress("0:0:0:0:0:0:0:0%0", 10005);
-    assertEquals("/0:0:0:0:0:0:0:0%0:10005", address.toString());
-    String target = AbstractManagedChannelImplBuilder.makeTargetStringForDirectAddress(address);
-    URI uri = new URI(target);
-    assertEquals("directaddress:////0:0:0:0:0:0:0:0%250:10005", target);
-    assertEquals(target, uri.toString());
-  }
-
-  @Test
-  public void idleTimeout() {
-    class Builder extends AbstractManagedChannelImplBuilder<Builder> {
-      Builder() {
-        super("target");
-      }
-
-      @Override
-      protected ClientTransportFactory buildTransportFactory() {
-        throw new UnsupportedOperationException();
-      }
-
-      @Override
-      public Builder usePlaintext(boolean value) {
-        return this;
-      }
-    }
-
-    Builder builder = new Builder();
-
-    assertEquals(AbstractManagedChannelImplBuilder.IDLE_MODE_DEFAULT_TIMEOUT_MILLIS,
-        builder.getIdleTimeoutMillis());
-
-    builder.idleTimeout(Long.MAX_VALUE, TimeUnit.DAYS);
-    assertEquals(ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE, builder.getIdleTimeoutMillis());
-
-    builder.idleTimeout(AbstractManagedChannelImplBuilder.IDLE_MODE_MAX_TIMEOUT_DAYS,
-        TimeUnit.DAYS);
-    assertEquals(ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE, builder.getIdleTimeoutMillis());
-
-    try {
-      builder.idleTimeout(0, TimeUnit.SECONDS);
-      fail("Should throw");
-    } catch (IllegalArgumentException e) {
-      // expected
-    }
-
-    builder.idleTimeout(1, TimeUnit.NANOSECONDS);
-    assertEquals(AbstractManagedChannelImplBuilder.IDLE_MODE_MIN_TIMEOUT_MILLIS,
-        builder.getIdleTimeoutMillis());
-
-    builder.idleTimeout(30, TimeUnit.SECONDS);
-    assertEquals(TimeUnit.SECONDS.toMillis(30), builder.getIdleTimeoutMillis());
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/AbstractReadableBufferTest.java b/core/src/test/java/io/grpc/internal/AbstractReadableBufferTest.java
index 9670c38de0b..e237756286e 100644
--- a/core/src/test/java/io/grpc/internal/AbstractReadableBufferTest.java
+++ b/core/src/test/java/io/grpc/internal/AbstractReadableBufferTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -34,12 +19,13 @@
 import static org.junit.Assert.assertEquals;
 import static org.mockito.Mockito.when;
 
-import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.mockito.stubbing.OngoingStubbing;
 
 /**
@@ -48,26 +34,12 @@
 @RunWith(JUnit4.class)
 public class AbstractReadableBufferTest {
 
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
   @Mock
   private AbstractReadableBuffer buffer;
 
-  @Before
-  public void setup() {
-    MockitoAnnotations.initMocks(this);
-  }
-
-  @Test
-  public void readUnsignedShortShouldSucceed() {
-    mockBytes(0xFF, 0xEE);
-    assertEquals(0xFFEE, buffer.readUnsignedShort());
-  }
-
-  @Test
-  public void readUnsignedMediumShouldSucceed() {
-    mockBytes(0xFF, 0xEE, 0xDD);
-    assertEquals(0xFFEEDD, buffer.readUnsignedMedium());
-  }
-
   @Test
   public void readPositiveIntShouldSucceed() {
     mockBytes(0x7F, 0xEE, 0xDD, 0xCC);
diff --git a/core/src/test/java/io/grpc/internal/AbstractServerStreamTest.java b/core/src/test/java/io/grpc/internal/AbstractServerStreamTest.java
index 1b744a95673..137ba19bfea 100644
--- a/core/src/test/java/io/grpc/internal/AbstractServerStreamTest.java
+++ b/core/src/test/java/io/grpc/internal/AbstractServerStreamTest.java
@@ -1,55 +1,52 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Matchers.same;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.InternalStatus;
 import io.grpc.Metadata;
 import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.internal.AbstractServerStream.TransportState;
 import io.grpc.internal.MessageFramerTest.ByteWritableBuffer;
 import java.io.ByteArrayInputStream;
+import java.io.IOException;
 import java.io.InputStream;
-import org.junit.Rule;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.concurrent.TimeUnit;
+import org.junit.Before;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
@@ -59,10 +56,9 @@
  */
 @RunWith(JUnit4.class)
 public class AbstractServerStreamTest {
+  private static final int TIMEOUT_MS = 1000;
   private static final int MAX_MESSAGE_SIZE = 100;
 
-  @Rule public final ExpectedException thrown = ExpectedException.none();
-
   private final WritableBufferAllocator allocator = new WritableBufferAllocator() {
     @Override
     public WritableBuffer allocate(int capacityHint) {
@@ -71,55 +67,175 @@ public WritableBuffer allocate(int capacityHint) {
   };
 
   private AbstractServerStream.Sink sink = mock(AbstractServerStream.Sink.class);
-  private AbstractServerStreamBase stream = new AbstractServerStreamBase(
-      allocator, sink, new AbstractServerStreamBase.TransportState(MAX_MESSAGE_SIZE));
+  private TransportTracer transportTracer;
+  private AbstractServerStreamBase stream;
   private final ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
 
+  @Before
+  public void setUp() {
+    transportTracer = new TransportTracer();
+    stream = new AbstractServerStreamBase(
+        allocator,
+        sink,
+        new AbstractServerStreamBase.TransportState(MAX_MESSAGE_SIZE, transportTracer));
+  }
+
   /**
-   * Test for issue https://github.com/grpc/grpc-java/issues/1795
+   * Test for issue https://github.com/grpc/grpc-java/issues/1795 .
    */
   @Test
   public void frameShouldBeIgnoredAfterDeframerClosed() {
-    ServerStreamListener streamListener = mock(ServerStreamListener.class);
+    final Queue<InputStream> streamListenerMessageQueue = new LinkedList<>();
+    stream.transportState().setListener(new ServerStreamListenerBase() {
+      @Override
+      public void messagesAvailable(MessageProducer producer) {
+        InputStream message;
+        while ((message = producer.next()) != null) {
+          streamListenerMessageQueue.add(message);
+        }
+      }
+    });
     ReadableBuffer buffer = mock(ReadableBuffer.class);
 
-    stream.transportState().setListener(streamListener);
     // Close the deframer
+    stream.close(Status.OK, new Metadata());
     stream.transportState().complete();
     // Frame received after deframer closed, should be ignored and not trigger an exception
     stream.transportState().inboundDataReceived(buffer, true);
 
     verify(buffer).close();
-    verify(streamListener, times(0)).messageRead(any(InputStream.class));
+    assertNull("no message expected", streamListenerMessageQueue.poll());
+  }
+
+  @Test
+  public void noHalfCloseListenerOnCancellation() throws Exception {
+    final Queue<InputStream> streamListenerMessageQueue = new LinkedList<>();
+    final SettableFuture<Status> closedFuture = SettableFuture.create();
+
+    stream.transportState().setListener(new ServerStreamListenerBase() {
+      @Override
+      public void messagesAvailable(StreamListener.MessageProducer producer) {
+        InputStream message;
+        while ((message = producer.next()) != null) {
+          streamListenerMessageQueue.add(message);
+        }
+      }
+
+      @Override
+      public void halfClosed() {
+        if (streamListenerMessageQueue.isEmpty()) {
+          throw new StatusRuntimeException(Status.INTERNAL.withDescription(
+              "Half close without request"));
+        }
+      }
+
+      @Override
+      public void closed(Status status) {
+        closedFuture.set(status);
+      }
+    });
+
+    ReadableBuffer buffer = mock(ReadableBuffer.class);
+    when(buffer.readableBytes()).thenReturn(1);
+    stream.transportState().inboundDataReceived(buffer, true);
+    Status cancel = Status.CANCELLED.withDescription("DEADLINE EXCEEDED");
+    stream.transportState().transportReportStatus(cancel);
+    assertEquals(cancel, closedFuture.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    verify(buffer).close();
+  }
+
+  @Test
+  public void queuedBytesInDeframerShouldNotBlockComplete() throws Exception {
+    final SettableFuture<Status> closedFuture = SettableFuture.create();
+    stream
+        .transportState()
+        .setListener(
+            new ServerStreamListenerBase() {
+              @Override
+              public void closed(Status status) {
+                closedFuture.set(status);
+              }
+            });
+
+    // Queue bytes in deframer
+    stream.transportState().inboundDataReceived(ReadableBuffers.wrap(new byte[] {1}), false);
+    stream.close(Status.OK, new Metadata());
+    stream.transportState().complete();
+
+    assertEquals(Status.OK, closedFuture.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+  }
+
+  @Test
+  public void queuedBytesInDeframerShouldNotBlockTransportReportStatus() throws Exception {
+    final SettableFuture<Status> closedFuture = SettableFuture.create();
+    stream
+        .transportState()
+        .setListener(
+            new ServerStreamListenerBase() {
+              @Override
+              public void closed(Status status) {
+                closedFuture.set(status);
+              }
+            });
+
+    // Queue bytes in deframer
+    stream.transportState().inboundDataReceived(ReadableBuffers.wrap(new byte[] {1}), false);
+    stream.transportState().transportReportStatus(Status.CANCELLED);
+
+    assertEquals(Status.CANCELLED, closedFuture.get(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+  }
+
+  @Test
+  public void partialMessageAtEndOfStreamShouldFail() throws Exception {
+    final SettableFuture<Status> closedFuture = SettableFuture.create();
+    stream
+        .transportState()
+        .setListener(
+            new ServerStreamListenerBase() {
+              @Override
+              public void closed(Status status) {
+                closedFuture.set(status);
+              }
+            });
+
+    // Queue a partial message in the deframer
+    stream.transportState().inboundDataReceived(ReadableBuffers.wrap(new byte[] {1}), true);
+    stream.request(1);
+
+    Status status = closedFuture.get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertEquals(Status.INTERNAL.getCode(), status.getCode());
+    assertEquals("Encountered end-of-stream mid-frame", status.getDescription());
   }
 
   /**
-   * Test for issue https://github.com/grpc/grpc-java/issues/615
+   * Test for issue https://github.com/grpc/grpc-java/issues/615 .
    */
   @Test
   public void completeWithoutClose() {
     stream.transportState().setListener(new ServerStreamListenerBase());
     // Test that it doesn't throw an exception
+    stream.close(Status.OK, new Metadata());
     stream.transportState().complete();
   }
 
   @Test
   public void setListener_setOnlyOnce() {
-    stream.transportState().setListener(new ServerStreamListenerBase());
-    thrown.expect(IllegalStateException.class);
+    TransportState state = stream.transportState();
+    state.setListener(new ServerStreamListenerBase());
 
-    stream.transportState().setListener(new ServerStreamListenerBase());
+    ServerStreamListenerBase listener2 = new ServerStreamListenerBase();
+    assertThrows(IllegalStateException.class, () -> state.setListener(listener2));
   }
 
   @Test
   public void listenerReady_onlyOnce() {
     stream.transportState().setListener(new ServerStreamListenerBase());
     stream.transportState().onStreamAllocated();
-    thrown.expect(IllegalStateException.class);
 
-    stream.transportState().onStreamAllocated();
-  }
+    TransportState state = stream.transportState();
 
+    assertThrows(IllegalStateException.class, state::onStreamAllocated);
+  }
 
   @Test
   public void listenerReady_readyCalled() {
@@ -132,85 +248,100 @@ public void listenerReady_readyCalled() {
 
   @Test
   public void setListener_failsOnNull() {
-    thrown.expect(NullPointerException.class);
+    TransportState state = stream.transportState();
 
-    stream.transportState().setListener(null);
+    assertThrows(NullPointerException.class, () -> state.setListener(null));
   }
 
+  // TODO(ericgribkoff) This test is only valid if deframeInTransportThread=true, as otherwise the
+  // message is queued.
+  /*
   @Test
   public void messageRead_listenerCalled() {
-    final ServerStreamListener streamListener = mock(ServerStreamListener.class);
-    stream.transportState().setListener(streamListener);
+    final Queue<InputStream> streamListenerMessageQueue = new LinkedList<InputStream>();
+    stream.transportState().setListener(new ServerStreamListenerBase() {
+      @Override
+      public void messagesAvailable(MessageProducer producer) {
+        InputStream message;
+        while ((message = producer.next()) != null) {
+          streamListenerMessageQueue.add(message);
+        }
+      }
+    });
 
     // Normally called by a deframe event.
     stream.transportState().messageRead(new ByteArrayInputStream(new byte[]{}));
 
-    verify(streamListener).messageRead(isA(InputStream.class));
+    assertNotNull(streamListenerMessageQueue.poll());
   }
+  */
 
   @Test
   public void writeHeaders_failsOnNullHeaders() {
-    thrown.expect(NullPointerException.class);
-
-    stream.writeHeaders(null);
+    assertThrows(NullPointerException.class, () -> stream.writeHeaders(null, true));
   }
 
   @Test
   public void writeHeaders() {
     Metadata headers = new Metadata();
-    stream.writeHeaders(headers);
-    verify(sink).writeHeaders(same(headers));
+    stream.writeHeaders(headers, true);
+    verify(sink).writeHeaders(same(headers), eq(true));
   }
 
   @Test
   public void writeMessage_dontWriteDuplicateHeaders() {
-    stream.writeHeaders(new Metadata());
+    stream.writeHeaders(new Metadata(), true);
     stream.writeMessage(new ByteArrayInputStream(new byte[]{}));
 
     // Make sure it wasn't called twice
-    verify(sink).writeHeaders(any(Metadata.class));
+    verify(sink).writeHeaders(any(Metadata.class), eq(true));
   }
 
   @Test
   public void writeMessage_ignoreIfFramerClosed() {
-    stream.writeHeaders(new Metadata());
+    stream.writeHeaders(new Metadata(), true);
     stream.endOfMessages();
     reset(sink);
 
     stream.writeMessage(new ByteArrayInputStream(new byte[]{}));
 
-    verify(sink, never()).writeFrame(any(WritableBuffer.class), any(Boolean.class));
+    verify(sink, never()).writeFrame(any(WritableBuffer.class), anyBoolean(), anyInt());
   }
 
   @Test
   public void writeMessage() {
-    stream.writeHeaders(new Metadata());
+    stream.writeHeaders(new Metadata(), true);
 
     stream.writeMessage(new ByteArrayInputStream(new byte[]{}));
     stream.flush();
 
-    verify(sink).writeFrame(any(WritableBuffer.class), eq(true));
+    verify(sink).writeFrame(any(WritableBuffer.class), eq(true), eq(1));
   }
 
   @Test
-  public void close_failsOnNullStatus() {
-    thrown.expect(NullPointerException.class);
+  public void writeMessage_closesStream() throws Exception {
+    stream.writeHeaders(new Metadata(), true);
+    InputStream input = mock(InputStream.class, delegatesTo(new ByteArrayInputStream(new byte[1])));
+    stream.writeMessage(input);
+    verify(input).close();
+  }
 
-    stream.close(null, new Metadata());
+  @Test
+  public void close_failsOnNullStatus() {
+    Metadata trailers = new Metadata();
+    assertThrows(NullPointerException.class, () -> stream.close(null, trailers));
   }
 
   @Test
   public void close_failsOnNullMetadata() {
-    thrown.expect(NullPointerException.class);
-
-    stream.close(Status.INTERNAL, null);
+    assertThrows(NullPointerException.class, () -> stream.close(Status.INTERNAL, null));
   }
 
   @Test
   public void close_sendsTrailers() {
     Metadata trailers = new Metadata();
     stream.close(Status.INTERNAL, trailers);
-    verify(sink).writeTrailers(any(Metadata.class), eq(false));
+    verify(sink).writeTrailers(any(Metadata.class), eq(false), eq(Status.INTERNAL));
   }
 
   @Test
@@ -218,19 +349,39 @@ public void close_sendTrailersClearsReservedFields() {
     // stream actually mutates trailers, so we can't check that the fields here are the same as
     // the captured ones.
     Metadata trailers = new Metadata();
-    trailers.put(Status.CODE_KEY, Status.OK);
-    trailers.put(Status.MESSAGE_KEY, "Everything's super.");
+    trailers.put(InternalStatus.CODE_KEY, Status.OK);
+    trailers.put(InternalStatus.MESSAGE_KEY, "Everything's super.");
 
-    stream.close(Status.INTERNAL.withDescription("bad"), trailers);
+    Status closeStatus = Status.INTERNAL.withDescription("bad");
+    stream.close(closeStatus, trailers);
+
+    verify(sink).writeTrailers(metadataCaptor.capture(), eq(false), eq(closeStatus));
+    assertEquals(
+        Status.Code.INTERNAL, metadataCaptor.getValue().get(InternalStatus.CODE_KEY).getCode());
+    assertEquals("bad", metadataCaptor.getValue().get(InternalStatus.MESSAGE_KEY));
+  }
 
-    verify(sink).writeTrailers(metadataCaptor.capture(), eq(false));
-    assertEquals(Status.Code.INTERNAL, metadataCaptor.getValue().get(Status.CODE_KEY).getCode());
-    assertEquals("bad", metadataCaptor.getValue().get(Status.MESSAGE_KEY));
+  @Test
+  public void changeOnReadyThreshold() {
+    stream.setListener(new ServerStreamListenerBase());
+    stream.transportState().onStreamAllocated();
+    stream.setOnReadyThreshold(Integer.MAX_VALUE);
+    stream.onSendingBytes(Integer.MAX_VALUE - 1);
+    assertTrue(stream.isReady());
   }
 
   private static class ServerStreamListenerBase implements ServerStreamListener {
     @Override
-    public void messageRead(InputStream message) {}
+    public void messagesAvailable(MessageProducer producer) {
+      InputStream message;
+      while ((message = producer.next()) != null) {
+        try {
+          message.close();
+        } catch (IOException e) {
+          // Continue to close other messages
+        }
+      }
+    }
 
     @Override
     public void onReady() {}
@@ -264,16 +415,28 @@ protected AbstractServerStream.TransportState transportState() {
     }
 
     static class TransportState extends AbstractServerStream.TransportState {
-      protected TransportState(int maxMessageSize) {
-        super(maxMessageSize, StatsTraceContext.NOOP);
+      protected TransportState(int maxMessageSize, TransportTracer transportTracer) {
+        super(maxMessageSize, StatsTraceContext.NOOP, transportTracer);
       }
 
       @Override
-      protected void deframeFailed(Throwable cause) {}
+      public void deframeFailed(Throwable cause) {
+        Status status = Status.fromThrowable(cause);
+        transportReportStatus(status);
+      }
 
       @Override
       public void bytesRead(int processedBytes) {}
+
+      @Override
+      public void runOnTransportThread(Runnable r) {
+        r.run();
+      }
+    }
+
+    @Override
+    public int streamId() {
+      return -1;
     }
   }
 }
-
diff --git a/core/src/test/java/io/grpc/internal/AbstractStreamTest.java b/core/src/test/java/io/grpc/internal/AbstractStreamTest.java
deleted file mode 100644
index 446ede1af05..00000000000
--- a/core/src/test/java/io/grpc/internal/AbstractStreamTest.java
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-
-package io.grpc.internal;
-
-import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.verify;
-
-import com.google.common.collect.ImmutableMultimap;
-import com.google.common.collect.Multimap;
-import io.grpc.internal.AbstractStream.Phase;
-import io.grpc.internal.MessageFramerTest.ByteWritableBuffer;
-import java.io.InputStream;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-@RunWith(JUnit4.class)
-public class AbstractStreamTest {
-  @Mock private StreamListener streamListener;
-
-  @Mock MessageFramer framer;
-  @Mock MessageDeframer deframer;
-
-  private final WritableBufferAllocator allocator = new WritableBufferAllocator() {
-    @Override
-    public WritableBuffer allocate(int capacityHint) {
-      return new ByteWritableBuffer(capacityHint);
-    }
-  };
-
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-  }
-
-  @Test
-  public void onStreamAllocated_shouldNotifyReady() {
-    AbstractStream stream = new AbstractStreamBase(null);
-
-    stream.onStreamAllocated();
-
-    verify(streamListener).onReady();
-  }
-
-  @Test
-  public void setMessageCompression() {
-    AbstractStream as = new AbstractStreamBase(framer, deframer);
-    as.setMessageCompression(true);
-
-    verify(framer).setMessageCompression(true);
-  }
-
-  @Test
-  public void validPhaseTransitions() {
-    AbstractStream stream = new AbstractStreamBase(null);
-    Multimap<Phase, Phase> validTransitions = ImmutableMultimap.<Phase, Phase>builder()
-        .put(Phase.HEADERS, Phase.HEADERS)
-        .put(Phase.HEADERS, Phase.MESSAGE)
-        .put(Phase.HEADERS, Phase.STATUS)
-        .put(Phase.MESSAGE, Phase.MESSAGE)
-        .put(Phase.MESSAGE, Phase.STATUS)
-        .put(Phase.STATUS, Phase.STATUS)
-        .build();
-
-    for (Phase startPhase : Phase.values()) {
-      for (Phase endPhase : Phase.values()) {
-        if (validTransitions.containsEntry(startPhase, endPhase)) {
-          stream.verifyNextPhase(startPhase, endPhase);
-        } else {
-          try {
-            stream.verifyNextPhase(startPhase, endPhase);
-            fail();
-          } catch (IllegalStateException expected) {
-            // continue
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * Base class for testing.
-   */
-  private class AbstractStreamBase extends AbstractStream {
-    private AbstractStreamBase(WritableBufferAllocator bufferAllocator) {
-      super(allocator, DEFAULT_MAX_MESSAGE_SIZE, StatsTraceContext.NOOP);
-    }
-
-    private AbstractStreamBase(MessageFramer framer, MessageDeframer deframer) {
-      super(framer, deframer);
-    }
-
-    @Override
-    public void request(int numMessages) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public int id() {
-      return ABSENT_ID;
-    }
-
-    @Override
-    protected StreamListener listener() {
-      return streamListener;
-    }
-
-    @Override
-    protected void internalSendFrame(WritableBuffer frame, boolean endOfStream, boolean flush) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override
-    protected void receiveMessage(InputStream is) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override
-    protected void inboundDeliveryPaused() {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override
-    protected void remoteEndClosed() {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override
-    protected void returnProcessedBytes(int processedBytes) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override
-    protected void deframeFailed(Throwable cause) {
-      throw new UnsupportedOperationException();
-    }
-  }
-}
-
diff --git a/core/src/test/java/io/grpc/internal/ApplicationThreadDeframerTest.java b/core/src/test/java/io/grpc/internal/ApplicationThreadDeframerTest.java
new file mode 100644
index 00000000000..764fbed49ed
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ApplicationThreadDeframerTest.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import com.google.common.io.ByteStreams;
+import com.google.common.primitives.Bytes;
+import io.grpc.internal.StreamListener.MessageProducer;
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.util.LinkedList;
+import java.util.Queue;
+import javax.annotation.Nullable;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ApplicationThreadDeframer}. */
+@RunWith(JUnit4.class)
+public class ApplicationThreadDeframerTest {
+  private MessageDeframer mockDeframer = mock(MessageDeframer.class);
+  private DeframerListener listener = new DeframerListener();
+  private TransportExecutor transportExecutor = new TransportExecutor();
+  private ApplicationThreadDeframer applicationThreadDeframer =
+      new ApplicationThreadDeframer(listener, transportExecutor, mockDeframer);
+
+  @Before
+  public void setUp() {
+    // ApplicationThreadDeframer constructor injects itself as the wrapped deframer's listener.
+    verify(mockDeframer).setListener(applicationThreadDeframer.getAppListener());
+  }
+
+  @Test
+  public void requestInvokesMessagesAvailableOnListener() {
+    applicationThreadDeframer.request(1);
+    verifyNoMoreInteractions(mockDeframer);
+    listener.runStoredProducer();
+    verify(mockDeframer).request(1);
+  }
+
+  @Test
+  public void deframeInvokesMessagesAvailableOnListener() {
+    ReadableBuffer frame = ReadableBuffers.wrap(new byte[1]);
+    applicationThreadDeframer.deframe(frame);
+    verifyNoMoreInteractions(mockDeframer);
+    listener.runStoredProducer();
+    verify(mockDeframer).deframe(frame);
+  }
+
+  @Test
+  public void closeWhenCompleteInvokesMessagesAvailableOnListener() {
+    applicationThreadDeframer.closeWhenComplete();
+    verifyNoMoreInteractions(mockDeframer);
+    listener.runStoredProducer();
+    verify(mockDeframer).closeWhenComplete();
+  }
+
+  @Test
+  public void closeInvokesMessagesAvailableOnListener() {
+    applicationThreadDeframer.close();
+    verify(mockDeframer).stopDelivery();
+    verifyNoMoreInteractions(mockDeframer);
+    listener.runStoredProducer();
+    verify(mockDeframer).close();
+  }
+
+  @Test
+  public void bytesReadInvokesTransportExecutor() {
+    applicationThreadDeframer.getAppListener().bytesRead(1);
+    assertEquals(0, listener.bytesRead);
+    transportExecutor.runStoredRunnable();
+    assertEquals(1, listener.bytesRead);
+  }
+
+  @Test
+  public void deframerClosedInvokesTransportExecutor() {
+    applicationThreadDeframer.getAppListener().deframerClosed(true);
+    assertFalse(listener.deframerClosedWithPartialMessage);
+    transportExecutor.runStoredRunnable();
+    assertTrue(listener.deframerClosedWithPartialMessage);
+  }
+
+  @Test
+  public void deframeFailedInvokesTransportExecutor() {
+    Throwable cause = new Throwable("error");
+    applicationThreadDeframer.getAppListener().deframeFailed(cause);
+    assertNull(listener.deframeFailedCause);
+    transportExecutor.runStoredRunnable();
+    assertEquals(cause, listener.deframeFailedCause);
+  }
+
+  @Test
+  public void messagesAvailableDrainsToMessageReadQueue_returnedByInitializingMessageProducer()
+      throws Exception {
+    byte[][] messageBytes = {{1, 2, 3}, {4}, {5, 6}};
+    Queue<InputStream> messages = new LinkedList<>();
+    for (int i = 0; i < messageBytes.length; i++) {
+      messages.add(new ByteArrayInputStream(messageBytes[i]));
+    }
+    MultiMessageProducer messageProducer = new MultiMessageProducer(messages);
+    applicationThreadDeframer.getAppListener().messagesAvailable(messageProducer);
+    applicationThreadDeframer.request(1 /* value is ignored */);
+    for (int i = 0; i < messageBytes.length; i++) {
+      InputStream message = listener.storedProducer.next();
+      assertNotNull(message);
+      assertEquals(Bytes.asList(messageBytes[i]), Bytes.asList(ByteStreams.toByteArray(message)));
+    }
+    assertNull(listener.storedProducer.next());
+  }
+
+  private static class DeframerListener implements MessageDeframer.Listener {
+    private MessageProducer storedProducer;
+    private int bytesRead;
+    private boolean deframerClosedWithPartialMessage;
+    private Throwable deframeFailedCause;
+
+    private void runStoredProducer() {
+      assertNotNull(storedProducer);
+      storedProducer.next();
+    }
+
+    @Override
+    public void bytesRead(int numBytes) {
+      assertEquals(0, bytesRead);
+      bytesRead = numBytes;
+    }
+
+    @Override
+    public void messagesAvailable(MessageProducer producer) {
+      assertNull(storedProducer);
+      storedProducer = producer;
+    }
+
+    @Override
+    public void deframerClosed(boolean hasPartialMessage) {
+      assertFalse(deframerClosedWithPartialMessage);
+      deframerClosedWithPartialMessage = hasPartialMessage;
+    }
+
+    @Override
+    public void deframeFailed(Throwable cause) {
+      assertNull(deframeFailedCause);
+      deframeFailedCause = cause;
+    }
+  }
+
+  private static class TransportExecutor implements ApplicationThreadDeframer.TransportExecutor {
+    private Runnable storedRunnable;
+
+    private void runStoredRunnable() {
+      assertNotNull(storedRunnable);
+      storedRunnable.run();
+    }
+
+    @Override
+    public void runOnTransportThread(Runnable r) {
+      assertNull(storedRunnable);
+      storedRunnable = r;
+    }
+  }
+
+  private static class MultiMessageProducer implements StreamListener.MessageProducer {
+    private final Queue<InputStream> messages;
+
+    private MultiMessageProducer(Queue<InputStream> messages) {
+      this.messages = messages;
+    }
+
+    @Nullable
+    @Override
+    public InputStream next() {
+      return messages.poll();
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/AtomicBackoffTest.java b/core/src/test/java/io/grpc/internal/AtomicBackoffTest.java
new file mode 100644
index 00000000000..3c0277a7c79
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/AtomicBackoffTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AtomicBackoff}. */
+@RunWith(JUnit4.class)
+public class AtomicBackoffTest {
+  @Test
+  public void mustBePositive() {
+    try {
+      new AtomicBackoff("test", 0);
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  @Test
+  public void backoff_doesNotChangeStateGet() {
+    AtomicBackoff backoff = new AtomicBackoff("test", 8);
+    AtomicBackoff.State state = backoff.getState();
+    assertEquals(8, state.get());
+    state.backoff();
+    assertEquals(8, state.get());
+  }
+
+  @Test
+  public void backoff_doubles() {
+    AtomicBackoff backoff = new AtomicBackoff("test", 3);
+    backoff.getState().backoff();
+    assertEquals(6, backoff.getState().get());
+
+    backoff.getState().backoff();
+    assertEquals(12, backoff.getState().get());
+
+    backoff.getState().backoff();
+    assertEquals(24, backoff.getState().get());
+
+    backoff = new AtomicBackoff("test", 13);
+    backoff.getState().backoff();
+    assertEquals(26, backoff.getState().get());
+  }
+
+  @Test
+  public void backoff_oncePerState() {
+    AtomicBackoff backoff = new AtomicBackoff("test", 8);
+    AtomicBackoff.State state = backoff.getState();
+
+    state.backoff();
+    assertEquals(8, state.get());
+    assertEquals(16, backoff.getState().get());
+    state.backoff(); // Nothing happens the second time
+    assertEquals(8, state.get());
+    assertEquals(16, backoff.getState().get());
+  }
+
+  @Test
+  public void backoff_twiceForEquivalentState_noChange() {
+    AtomicBackoff backoff = new AtomicBackoff("test", 8);
+    AtomicBackoff.State state1 = backoff.getState();
+    AtomicBackoff.State state2 = backoff.getState();
+    state1.backoff();
+    state2.backoff();
+    assertEquals(16, backoff.getState().get());
+  }
+
+  @Test
+  public void backoff_delayed() {
+    AtomicBackoff backoff = new AtomicBackoff("test", 8);
+    AtomicBackoff.State state = backoff.getState();
+    backoff.getState().backoff();
+    backoff.getState().backoff();
+    assertEquals(32, backoff.getState().get());
+
+    // Shouldn't decrease value
+    state.backoff();
+    assertEquals(32, backoff.getState().get());
+  }
+
+  @Test
+  public void largeLong() {
+    // Don't use MAX_VALUE because it is easy to check for explicitly
+    long tooLarge = Long.MAX_VALUE - 100;
+    AtomicBackoff backoff = new AtomicBackoff("test", tooLarge);
+    backoff.getState().backoff();
+    // It would also be okay if it became MAX_VALUE
+    assertEquals(tooLarge, backoff.getState().get());
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/AutoConfiguredLoadBalancerFactoryTest.java b/core/src/test/java/io/grpc/internal/AutoConfiguredLoadBalancerFactoryTest.java
new file mode 100644
index 00000000000..07d19d41a86
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/AutoConfiguredLoadBalancerFactoryTest.java
@@ -0,0 +1,813 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Preconditions;
+import io.grpc.Attributes;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.AutoConfiguredLoadBalancerFactory.AutoConfiguredLoadBalancer;
+import io.grpc.internal.PickFirstLeafLoadBalancer.PickFirstLeafLoadBalancerConfig;
+import io.grpc.internal.PickFirstLoadBalancer.PickFirstLoadBalancerConfig;
+import io.grpc.internal.ServiceConfigUtil.PolicySelection;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+
+/**
+ * Unit tests for {@link AutoConfiguredLoadBalancerFactory}.
+ */
+@RunWith(JUnit4.class)
+// TODO(creamsoup) remove backward compatible check when fully migrated
+@SuppressWarnings("deprecation")
+public class AutoConfiguredLoadBalancerFactoryTest {
+  private static final LoadBalancerRegistry defaultRegistry =
+      LoadBalancerRegistry.getDefaultRegistry();
+  private final AutoConfiguredLoadBalancerFactory lbf =
+      new AutoConfiguredLoadBalancerFactory(GrpcUtil.DEFAULT_LB_POLICY);
+
+  private final ChannelLogger channelLogger = mock(ChannelLogger.class);
+  private final LoadBalancer testLbBalancer = mock(LoadBalancer.class);
+  private final LoadBalancer testLbBalancer2 = mock(LoadBalancer.class);
+  private final AtomicReference<ConfigOrError> nextParsedConfigOrError =
+      new AtomicReference<>(ConfigOrError.fromConfig("default"));
+  private final AtomicReference<ConfigOrError> nextParsedConfigOrError2 =
+      new AtomicReference<>(ConfigOrError.fromConfig("default2"));
+  private final FakeLoadBalancerProvider testLbBalancerProvider =
+      mock(FakeLoadBalancerProvider.class,
+          delegatesTo(
+              new FakeLoadBalancerProvider("test_lb", testLbBalancer, nextParsedConfigOrError)));
+  private final FakeLoadBalancerProvider testLbBalancerProvider2 =
+      mock(FakeLoadBalancerProvider.class,
+          delegatesTo(
+              new FakeLoadBalancerProvider("test_lb2", testLbBalancer2, nextParsedConfigOrError2)));
+
+  private final Class<? extends LoadBalancer> pfLbClass =
+      PickFirstLoadBalancerProvider.isEnabledNewPickFirst()
+          ? PickFirstLeafLoadBalancer.class
+          : PickFirstLoadBalancer.class;
+
+  @Before
+  public void setUp() {
+    when(testLbBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(
+        Status.OK);
+    when(testLbBalancer2.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(
+        Status.OK);
+    defaultRegistry.register(testLbBalancerProvider);
+    defaultRegistry.register(testLbBalancerProvider2);
+  }
+
+  @After
+  public void tearDown() {
+    defaultRegistry.deregister(testLbBalancerProvider);
+    defaultRegistry.deregister(testLbBalancerProvider2);
+  }
+
+  @Test
+  public void newLoadBalancer_isAuto() {
+    AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(new TestHelper());
+
+    assertThat(lb).isInstanceOf(AutoConfiguredLoadBalancer.class);
+  }
+
+  @Test
+  public void defaultIsPickFirst() {
+    AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(new TestHelper());
+
+    assertThat(lb.getDelegateProvider()).isInstanceOf(PickFirstLoadBalancerProvider.class);
+    assertThat(lb.getDelegate().getClass().getName()).contains("PickFirst");
+  }
+
+  @Test
+  public void defaultIsConfigurable() {
+    AutoConfiguredLoadBalancer lb = new AutoConfiguredLoadBalancerFactory("test_lb")
+        .newLoadBalancer(new TestHelper());
+
+    assertThat(lb.getDelegateProvider()).isSameInstanceAs(testLbBalancerProvider);
+    assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
+  }
+
+  @SuppressWarnings("deprecation")
+  @Test
+  public void forwardsCalls() {
+    AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(new TestHelper());
+
+    final AtomicInteger calls = new AtomicInteger();
+    TestLoadBalancer testlb = new TestLoadBalancer() {
+
+      @Override
+      public void handleNameResolutionError(Status error) {
+        calls.getAndSet(1);
+      }
+
+      @Override
+      public void handleSubchannelState(Subchannel subchannel, ConnectivityStateInfo stateInfo) {
+        calls.getAndSet(2);
+      }
+
+      @Override
+      public void shutdown() {
+        calls.getAndSet(3);
+      }
+    };
+
+    lb.setDelegate(testlb);
+
+    lb.handleNameResolutionError(Status.RESOURCE_EXHAUSTED);
+    assertThat(calls.getAndSet(0)).isEqualTo(1);
+
+    lb.handleSubchannelState(null, null);
+    assertThat(calls.getAndSet(0)).isEqualTo(2);
+
+    lb.shutdown();
+    assertThat(calls.getAndSet(0)).isEqualTo(3);
+  }
+
+  @Test
+  public void acceptResolvedAddresses_keepOldBalancer() {
+    final List<EquivalentAddressGroup> servers =
+        Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
+    Helper helper = new TestHelper() {
+      @Override
+      public Subchannel createSubchannel(CreateSubchannelArgs args) {
+        assertThat(args.getAddresses()).isEqualTo(servers);
+        return new TestSubchannel(args);
+      }
+    };
+    AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
+    LoadBalancer oldDelegate = lb.getDelegate();
+
+    Status addressAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers)
+            .setAttributes(Attributes.EMPTY)
+            .setLoadBalancingPolicyConfig(null)
+            .build());
+
+    assertThat(addressAcceptanceStatus.isOk()).isTrue();
+    assertThat(lb.getDelegate()).isSameInstanceAs(oldDelegate);
+  }
+
+  @Test
+  public void acceptResolvedAddresses_shutsDownOldBalancer() throws Exception {
+    Map<String, ?> serviceConfig =
+        parseConfig("{\"loadBalancingConfig\": [ {\"round_robin\": { } } ] }");
+    ConfigOrError lbConfigs = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+
+    final List<EquivalentAddressGroup> servers =
+        Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
+    Helper helper = new TestHelper() {
+      @Override
+      public Subchannel createSubchannel(CreateSubchannelArgs args) {
+        assertThat(args.getAddresses()).isEqualTo(servers);
+        return new TestSubchannel(args);
+      }
+    };
+    AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
+    final AtomicBoolean shutdown = new AtomicBoolean();
+    TestLoadBalancer testlb = new TestLoadBalancer() {
+
+      @Override
+      public void handleNameResolutionError(Status error) {
+        // noop
+      }
+
+      @Override
+      public void shutdown() {
+        shutdown.set(true);
+      }
+    };
+    lb.setDelegate(testlb);
+
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers)
+            .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
+            .build());
+
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    assertThat(lb.getDelegateProvider().getClass().getName()).isEqualTo(
+        "io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider");
+    assertTrue(shutdown.get());
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void acceptResolvedAddresses_propagateLbConfigToDelegate() throws Exception {
+    Map<String, ?> rawServiceConfig =
+        parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"high\" } } ] }");
+    ConfigOrError lbConfigs = lbf.parseLoadBalancingPolicyConfig(rawServiceConfig);
+    assertThat(lbConfigs.getConfig()).isNotNull();
+
+    final List<EquivalentAddressGroup> servers =
+        Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
+    Helper helper = new TestHelper();
+    AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
+
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers)
+            .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
+            .build());
+
+    verify(testLbBalancerProvider).newLoadBalancer(same(helper));
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
+    ArgumentCaptor<ResolvedAddresses> resultCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    verify(testLbBalancer).acceptResolvedAddresses(resultCaptor.capture());
+    assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder();
+    ArgumentCaptor<Map<String, ?>> lbConfigCaptor = ArgumentCaptor.forClass(Map.class);
+    verify(testLbBalancerProvider).parseLoadBalancingPolicyConfig(lbConfigCaptor.capture());
+    assertThat(lbConfigCaptor.getValue()).containsExactly("setting1", "high");
+    verifyNoMoreInteractions(testLbBalancer);
+
+    rawServiceConfig =
+        parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"low\" } } ] }");
+    lbConfigs = lbf.parseLoadBalancingPolicyConfig(rawServiceConfig);
+
+    addressesAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers)
+            .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
+            .build());
+
+    resultCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    verify(testLbBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder();
+    verify(testLbBalancerProvider, times(2))
+        .parseLoadBalancingPolicyConfig(lbConfigCaptor.capture());
+    assertThat(lbConfigCaptor.getValue()).containsExactly("setting1", "low");
+    // Service config didn't change policy, thus the delegateLb is not swapped
+    verifyNoMoreInteractions(testLbBalancer);
+    verify(testLbBalancerProvider).newLoadBalancer(any(Helper.class));
+  }
+
+  @Test
+  public void acceptResolvedAddresses_propagateAddrsToDelegate() throws Exception {
+    Map<String, ?> rawServiceConfig =
+        parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"high\" } } ] }");
+    ConfigOrError lbConfigs = lbf.parseLoadBalancingPolicyConfig(rawServiceConfig);
+    assertThat(lbConfigs.getConfig()).isNotNull();
+
+    Helper helper = new TestHelper();
+    AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
+    List<EquivalentAddressGroup> servers =
+        Collections.singletonList(new EquivalentAddressGroup(new InetSocketAddress(8080){}));
+
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers)
+            .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
+            .build());
+
+    verify(testLbBalancerProvider).newLoadBalancer(same(helper));
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
+    ArgumentCaptor<ResolvedAddresses> resultCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    verify(testLbBalancer).acceptResolvedAddresses(resultCaptor.capture());
+    assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder();
+
+    servers =
+        Collections.singletonList(new EquivalentAddressGroup(new InetSocketAddress(9090){}));
+    addressesAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers)
+            .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
+            .build());
+
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    verify(testLbBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture());
+    assertThat(resultCaptor.getValue().getAddresses()).containsExactlyElementsIn(servers).inOrder();
+  }
+
+  @Test
+  public void acceptResolvedAddresses_delegateDoNotAcceptEmptyAddressList_nothing()
+      throws Exception {
+
+    // The test LB will NOT accept the addresses we give them.
+    when(testLbBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(
+        Status.UNAVAILABLE);
+
+    Helper helper = new TestHelper();
+    AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
+
+    Map<String, ?> serviceConfig =
+        parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { \"setting1\": \"high\" } } ] }");
+    ConfigOrError lbConfig = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
+            .setLoadBalancingPolicyConfig(lbConfig.getConfig())
+            .build());
+
+    assertThat(addressesAcceptanceStatus.isOk()).isFalse();
+    assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
+  }
+
+  @Test
+  public void acceptResolvedAddresses_delegateAcceptsEmptyAddressList()
+      throws Exception {
+    Helper helper = new TestHelper();
+    AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
+
+    Map<String, ?> rawServiceConfig =
+        parseConfig("{\"loadBalancingConfig\": [ {\"test_lb2\": { \"setting1\": \"high\" } } ] }");
+    ConfigOrError lbConfigs =
+        lbf.parseLoadBalancingPolicyConfig(rawServiceConfig);
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
+            .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
+            .build());
+
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer2);
+    ArgumentCaptor<ResolvedAddresses> resultCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    verify(testLbBalancer2).acceptResolvedAddresses(resultCaptor.capture());
+    assertThat(resultCaptor.getValue().getAddresses()).isEmpty();
+    assertThat(resultCaptor.getValue().getLoadBalancingPolicyConfig())
+        .isEqualTo(nextParsedConfigOrError2.get().getConfig());
+  }
+
+  @Test
+  public void acceptResolvedAddresses_useSelectedLbPolicy() throws Exception {
+    Map<String, ?> rawServiceConfig =
+        parseConfig("{\"loadBalancingConfig\": [{\"round_robin\": {}}]}");
+    ConfigOrError lbConfigs = lbf.parseLoadBalancingPolicyConfig(rawServiceConfig);
+    assertThat(lbConfigs.getConfig()).isNotNull();
+    assertThat(((PolicySelection) lbConfigs.getConfig()).provider.getClass().getName())
+        .isEqualTo("io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider");
+
+    final List<EquivalentAddressGroup> servers =
+        Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
+    Helper helper = new TestHelper() {
+      @Override
+      public Subchannel createSubchannel(CreateSubchannelArgs args) {
+        assertThat(args.getAddresses()).isEqualTo(servers);
+        return new TestSubchannel(args);
+      }
+    };
+    AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers)
+            .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
+            .build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    assertThat(lb.getDelegate().getClass().getName())
+        .isEqualTo("io.grpc.util.RoundRobinLoadBalancer");
+  }
+
+  @Test
+  public void acceptResolvedAddresses_noLbPolicySelected_defaultToPickFirst() {
+    final List<EquivalentAddressGroup> servers =
+        Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
+    Helper helper = new TestHelper() {
+      @Override
+      public Subchannel createSubchannel(CreateSubchannelArgs args) {
+        assertThat(args.getAddresses()).isEqualTo(servers);
+        return new TestSubchannel(args);
+      }
+    };
+    AutoConfiguredLoadBalancer lb = lbf.newLoadBalancer(helper);
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers)
+            .setLoadBalancingPolicyConfig(null)
+            .build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    assertThat(lb.getDelegate()).isInstanceOf(pfLbClass);
+  }
+
+  @Test
+  public void acceptResolvedAddresses_noLbPolicySelected_defaultToCustomDefault() {
+    AutoConfiguredLoadBalancer lb = new AutoConfiguredLoadBalancerFactory("test_lb")
+        .newLoadBalancer(new TestHelper());
+    List<EquivalentAddressGroup> servers =
+        Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers)
+            .setLoadBalancingPolicyConfig(null)
+            .build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    assertThat(lb.getDelegate()).isSameInstanceAs(testLbBalancer);
+  }
+
+  @Test
+  public void channelTracing_lbPolicyChanged() throws Exception {
+    List<EquivalentAddressGroup> servers =
+        Collections.singletonList(new EquivalentAddressGroup(new SocketAddress(){}));
+    Helper helper = new TestHelper() {
+      @Override
+      public Subchannel createSubchannel(CreateSubchannelArgs args) {
+        return new TestSubchannel(args);
+      }
+    };
+
+    AutoConfiguredLoadBalancer lb =
+        new AutoConfiguredLoadBalancerFactory(GrpcUtil.DEFAULT_LB_POLICY).newLoadBalancer(helper);
+    Status addressesAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers)
+            .setAttributes(Attributes.EMPTY)
+            .build());
+
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    verifyNoMoreInteractions(channelLogger);
+
+    ConfigOrError testLbParsedConfig = ConfigOrError.fromConfig("foo");
+    nextParsedConfigOrError.set(testLbParsedConfig);
+    Map<String, ?> serviceConfig =
+        parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { } } ] }");
+    ConfigOrError lbConfigs = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    addressesAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers)
+            .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
+            .build());
+
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    verify(channelLogger).log(
+        eq(ChannelLogLevel.INFO),
+        eq("Load balancer changed from {0} to {1}"),
+        eq(pfLbClass.getSimpleName()),
+        eq(testLbBalancer.getClass().getSimpleName()));
+
+    verify(channelLogger).log(
+        eq(ChannelLogLevel.DEBUG),
+        eq("Load-balancing config: {0}"),
+        eq(testLbParsedConfig.getConfig()));
+    verifyNoMoreInteractions(channelLogger);
+
+    testLbParsedConfig = ConfigOrError.fromConfig("bar");
+    nextParsedConfigOrError.set(testLbParsedConfig);
+    serviceConfig = parseConfig("{\"loadBalancingConfig\": [ {\"test_lb\": { } } ] }");
+    lbConfigs = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    addressesAcceptanceStatus = lb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers)
+            .setLoadBalancingPolicyConfig(lbConfigs.getConfig())
+            .build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    verify(channelLogger).log(
+        eq(ChannelLogLevel.DEBUG),
+        eq("Load-balancing config: {0}"),
+        eq(testLbParsedConfig.getConfig()));
+    verifyNoMoreInteractions(channelLogger);
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_failedOnUnknown() throws Exception {
+    Map<String, ?> serviceConfig =
+        parseConfig("{\"loadBalancingConfig\": [ {\"magic_balancer\": {} } ] }");
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    assertThat(parsed.getError()).isNotNull();
+    assertThat(parsed.getError().getDescription())
+        .isEqualTo("None of [magic_balancer] specified by Service Config are available.");
+  }
+
+  @Test
+  public void parseLoadBalancingPolicy_failedOnUnknown() throws Exception {
+    Map<String, ?> serviceConfig =
+        parseConfig("{\"loadBalancingPolicy\": \"magic_balancer\"}");
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    assertThat(parsed.getError()).isNotNull();
+    assertThat(parsed.getError().getDescription())
+        .isEqualTo("None of [magic_balancer] specified by Service Config are available.");
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_multipleValidPolicies() throws Exception {
+    Map<String, ?> serviceConfig =
+        parseConfig(
+            "{\"loadBalancingConfig\": ["
+                + "{\"round_robin\": {}},"
+                + "{\"test_lb\": {} } ] }");
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    assertThat(parsed).isNotNull();
+    assertThat(parsed.getError()).isNull();
+    assertThat(parsed.getConfig()).isInstanceOf(PolicySelection.class);
+    assertThat(((PolicySelection) parsed.getConfig()).provider.getClass().getName())
+        .isEqualTo("io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider");
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_policyShouldBeIgnoredIfConfigExists() throws Exception {
+    Map<String, ?> serviceConfig =
+        parseConfig(
+            "{\"loadBalancingConfig\": [{\"round_robin\": {} } ],"
+                + "\"loadBalancingPolicy\": \"pick_first\" }");
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    assertThat(parsed).isNotNull();
+    assertThat(parsed.getError()).isNull();
+    assertThat(parsed.getConfig()).isInstanceOf(PolicySelection.class);
+    assertThat(((PolicySelection) parsed.getConfig()).provider.getClass().getName())
+        .isEqualTo("io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider");
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_policyShouldBeIgnoredEvenIfUnknownPolicyExists()
+      throws Exception {
+    Map<String, ?> serviceConfig =
+        parseConfig(
+            "{\"loadBalancingConfig\": [{\"magic_balancer\": {} } ],"
+                + "\"loadBalancingPolicy\": \"round_robin\" }");
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    assertThat(parsed.getError()).isNotNull();
+    assertThat(parsed.getError().getDescription())
+        .isEqualTo("None of [magic_balancer] specified by Service Config are available.");
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void parseLoadBalancingConfig_firstInvalidPolicy() throws Exception {
+    when(testLbBalancerProvider.parseLoadBalancingPolicyConfig(any(Map.class)))
+        .thenReturn(ConfigOrError.fromError(Status.UNKNOWN));
+    Map<String, ?> serviceConfig =
+        parseConfig(
+            "{\"loadBalancingConfig\": ["
+                + "{\"test_lb\": {}},"
+                + "{\"round_robin\": {} } ] }");
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    assertThat(parsed).isNotNull();
+    assertThat(parsed.getConfig()).isNull();
+    assertThat(parsed.getError()).isEqualTo(Status.UNKNOWN);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void parseLoadBalancingConfig_firstValidSecondInvalidPolicy() throws Exception {
+    when(testLbBalancerProvider.parseLoadBalancingPolicyConfig(any(Map.class)))
+        .thenReturn(ConfigOrError.fromError(Status.UNKNOWN));
+    Map<String, ?> serviceConfig =
+        parseConfig(
+            "{\"loadBalancingConfig\": ["
+                + "{\"round_robin\": {}},"
+                + "{\"test_lb\": {} } ] }");
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    assertThat(parsed).isNotNull();
+    assertThat(parsed.getConfig()).isNotNull();
+    assertThat(((PolicySelection) parsed.getConfig()).config).isNotNull();
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_someProvidesAreNotAvailable() throws Exception {
+    Map<String, ?> serviceConfig =
+        parseConfig("{\"loadBalancingConfig\": [ "
+            + "{\"magic_balancer\": {} },"
+            + "{\"round_robin\": {}} ] }");
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(serviceConfig);
+    assertThat(parsed).isNotNull();
+    assertThat(parsed.getConfig()).isNotNull();
+    assertThat(((PolicySelection) parsed.getConfig()).config).isNotNull();
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_lbConfigPropagated() throws Exception {
+    Map<String, ?> rawServiceConfig =
+        parseConfig(
+            "{\"loadBalancingConfig\": ["
+                + "{\"pick_first\": {\"shuffleAddressList\": true } }"
+                + "] }");
+    ConfigOrError parsed = lbf.parseLoadBalancingPolicyConfig(rawServiceConfig);
+    assertThat(parsed).isNotNull();
+    assertThat(parsed.getConfig()).isNotNull();
+    PolicySelection policySelection = (PolicySelection) parsed.getConfig();
+    assertThat(policySelection.provider).isInstanceOf(PickFirstLoadBalancerProvider.class);
+    if (PickFirstLoadBalancerProvider.isEnabledNewPickFirst()) {
+      assertThat(policySelection.config).isInstanceOf(PickFirstLeafLoadBalancerConfig.class);
+      assertThat(((PickFirstLeafLoadBalancerConfig) policySelection.config).shuffleAddressList)
+          .isTrue();
+    } else {
+      assertThat(policySelection.config).isInstanceOf(PickFirstLoadBalancerConfig.class);
+      assertThat(((PickFirstLoadBalancerConfig) policySelection.config).shuffleAddressList)
+          .isTrue();
+    }
+    verifyNoInteractions(channelLogger);
+  }
+
+  public static class ForwardingLoadBalancer extends LoadBalancer {
+    private final LoadBalancer delegate;
+
+    public ForwardingLoadBalancer(LoadBalancer delegate) {
+      this.delegate = delegate;
+    }
+
+    protected LoadBalancer delegate() {
+      return delegate;
+    }
+
+    @Override
+    @Deprecated
+    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      delegate().acceptResolvedAddresses(resolvedAddresses);
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      return delegate().acceptResolvedAddresses(resolvedAddresses);
+    }
+
+    @Override
+    public void handleNameResolutionError(Status error) {
+      delegate().handleNameResolutionError(error);
+    }
+
+    @Override
+    public void shutdown() {
+      delegate().shutdown();
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, ?> parseConfig(String json) throws Exception {
+    return (Map<String, ?>) JsonParser.parse(json);
+  }
+
+  private static class TestLoadBalancer extends ForwardingLoadBalancer {
+    TestLoadBalancer() {
+      super(null);
+    }
+  }
+
+  private class TestHelper extends ForwardingLoadBalancerHelper {
+    final SynchronizationContext syncContext = new SynchronizationContext(
+        new Thread.UncaughtExceptionHandler() {
+          @Override
+          public void uncaughtException(Thread t, Throwable e) {
+            throw new AssertionError(e);
+          }
+        });
+
+    final FakeClock fakeClock = new FakeClock();
+
+    @Override
+    protected Helper delegate() {
+      return null;
+    }
+
+    @Override
+    public ChannelLogger getChannelLogger() {
+      return channelLogger;
+    }
+
+    @Override
+    public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+      // noop
+    }
+
+    @Override
+    public SynchronizationContext getSynchronizationContext() {
+      return syncContext;
+    }
+
+    @Override
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return fakeClock.getScheduledExecutorService();
+    }
+  }
+
+  private static class TestSubchannel extends Subchannel {
+    TestSubchannel(CreateSubchannelArgs args) {
+      this.addrs = args.getAddresses();
+      this.attrs = args.getAttributes();
+    }
+
+    List<EquivalentAddressGroup> addrs;
+    final Attributes attrs;
+
+    @Override
+    public void start(SubchannelStateListener listener) {
+    }
+
+    @Override
+    public void shutdown() {
+    }
+
+    @Override
+    public void requestConnection() {
+    }
+
+    @Override
+    public List<EquivalentAddressGroup> getAllAddresses() {
+      return addrs;
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return attrs;
+    }
+
+    @Override
+    public void updateAddresses(List<EquivalentAddressGroup> addrs) {
+      Preconditions.checkNotNull(addrs, "addrs");
+      this.addrs = addrs;
+    }
+  }
+
+  private static class FakeLoadBalancerProvider extends LoadBalancerProvider {
+    private final String policyName;
+    private final LoadBalancer balancer;
+    private final AtomicReference<ConfigOrError> nextParsedLbPolicyConfig;
+
+    FakeLoadBalancerProvider(
+        String policyName,
+        LoadBalancer balancer,
+        AtomicReference<ConfigOrError> nextParsedLbPolicyConfig) {
+      this.policyName = policyName;
+      this.balancer = balancer;
+      this.nextParsedLbPolicyConfig = nextParsedLbPolicyConfig;
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 5;
+    }
+
+    @Override
+    public String getPolicyName() {
+      return policyName;
+    }
+
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      return balancer;
+    }
+
+    @Override
+    public ConfigOrError parseLoadBalancingPolicyConfig(
+        Map<String, ?> rawLoadBalancingPolicyConfig) {
+      if (nextParsedLbPolicyConfig == null) {
+        return super.parseLoadBalancingPolicyConfig(rawLoadBalancingPolicyConfig);
+      }
+      return nextParsedLbPolicyConfig.get();
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/BackoffPolicyRetrySchedulerTest.java b/core/src/test/java/io/grpc/internal/BackoffPolicyRetrySchedulerTest.java
new file mode 100644
index 00000000000..0ec7a218087
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/BackoffPolicyRetrySchedulerTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2023 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.SynchronizationContext;
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link BackoffPolicyRetryScheduler}.
+ */
+@RunWith(JUnit4.class)
+public class BackoffPolicyRetrySchedulerTest {
+
+  private final FakeClock fakeClock = new FakeClock();
+
+  private BackoffPolicyRetryScheduler scheduler;
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      mock(UncaughtExceptionHandler.class));
+
+  @Before
+  public void setup() {
+    scheduler = new BackoffPolicyRetryScheduler(new FakeBackoffPolicyProvider(),
+        fakeClock.getScheduledExecutorService(), syncContext);
+  }
+
+  @Test
+  public void schedule() {
+    AtomicInteger retryCount = new AtomicInteger();
+    Runnable retry = retryCount::incrementAndGet;
+    syncContext.execute(() -> scheduler.schedule(retry));
+
+    fakeClock.forwardTime(2, TimeUnit.NANOSECONDS);
+
+    assertThat(retryCount.get()).isEqualTo(1);
+  }
+
+  @Test
+  public void schedule_noMultiple() {
+    AtomicInteger retryCount = new AtomicInteger();
+    Runnable retry = retryCount::incrementAndGet;
+
+    // We schedule multiple retries...
+    syncContext.execute(() -> scheduler.schedule(retry));
+    syncContext.execute(() -> scheduler.schedule(retry));
+
+    fakeClock.forwardTime(2, TimeUnit.NANOSECONDS);
+
+    // But only one of them should have run.
+    assertThat(retryCount.get()).isEqualTo(1);
+  }
+
+  @Test
+  public void reset() {
+    AtomicInteger retryCount = new AtomicInteger();
+    Runnable retry = retryCount::incrementAndGet;
+    Runnable retryTwo = () -> {
+      retryCount.getAndAdd(2);
+    };
+
+    // We schedule one retry.
+    syncContext.execute(() -> scheduler.schedule(retry));
+
+    // But then reset.
+    syncContext.execute(() -> scheduler.reset());
+
+    // And schedule a different retry.
+    syncContext.execute(() -> scheduler.schedule(retryTwo));
+
+    fakeClock.forwardTime(2, TimeUnit.NANOSECONDS);
+
+    // The retry after the reset should have been run.
+    assertThat(retryCount.get()).isEqualTo(2);
+  }
+
+  private static class FakeBackoffPolicyProvider implements BackoffPolicy.Provider {
+    @Override
+    public BackoffPolicy get() {
+      return new BackoffPolicy() {
+        @Override
+        public long nextBackoffNanos() {
+          return 1;
+        }
+      };
+    }
+  }
+}
\ No newline at end of file
diff --git a/core/src/test/java/io/grpc/internal/ByteWritableBufferTest.java b/core/src/test/java/io/grpc/internal/ByteWritableBufferTest.java
index 6d9c16159c9..cb730313a94 100644
--- a/core/src/test/java/io/grpc/internal/ByteWritableBufferTest.java
+++ b/core/src/test/java/io/grpc/internal/ByteWritableBufferTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
diff --git a/core/src/test/java/io/grpc/internal/CallCredentialsApplyingTest.java b/core/src/test/java/io/grpc/internal/CallCredentialsApplyingTest.java
index cfd69721983..bb64bbae188 100644
--- a/core/src/test/java/io/grpc/internal/CallCredentialsApplyingTest.java
+++ b/core/src/test/java/io/grpc/internal/CallCredentialsApplyingTest.java
@@ -1,67 +1,62 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.same;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import io.grpc.Attributes;
 import io.grpc.CallCredentials;
-import io.grpc.CallCredentials.MetadataApplier;
+import io.grpc.CallCredentials.RequestInfo;
 import io.grpc.CallOptions;
+import io.grpc.ChannelLogger;
+import io.grpc.ClientStreamTracer;
 import io.grpc.IntegerMarshaller;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.SecurityLevel;
 import io.grpc.Status;
+import io.grpc.Status.Code;
 import io.grpc.StringMarshaller;
 import java.net.SocketAddress;
 import java.util.concurrent.Executor;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
 import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.mockito.stubbing.Answer;
 
 /**
@@ -70,6 +65,9 @@
  */
 @RunWith(JUnit4.class)
 public class CallCredentialsApplyingTest {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
   @Mock
   private ClientTransportFactory mockTransportFactory;
 
@@ -88,14 +86,21 @@ public class CallCredentialsApplyingTest {
   @Mock
   private SocketAddress address;
 
+  // Noop logger;
+  @Mock
+  private ChannelLogger channelLogger;
+
+  private static final ClientStreamTracer[] tracers = new ClientStreamTracer[] {
+      new ClientStreamTracer() {}
+  };
   private static final String AUTHORITY = "testauthority";
   private static final String USER_AGENT = "testuseragent";
-  private static final Attributes.Key<String> ATTR_KEY = Attributes.Key.of("somekey");
+  private static final Attributes.Key<String> ATTR_KEY = Attributes.Key.create("somekey");
   private static final String ATTR_VALUE = "somevalue";
   private static final MethodDescriptor<String, Integer> method =
       MethodDescriptor.<String, Integer>newBuilder()
           .setType(MethodDescriptor.MethodType.UNKNOWN)
-          .setFullMethodName("/service/method")
+          .setFullMethodName("service/method")
           .setRequestMarshaller(new StringMarshaller())
           .setResponseMarshaller(new IntegerMarshaller())
           .build();
@@ -106,27 +111,29 @@ public class CallCredentialsApplyingTest {
       Metadata.Key.of("test-creds", Metadata.ASCII_STRING_MARSHALLER);
   private static final String CREDS_VALUE = "some credentials";
 
+  private final ClientTransportFactory.ClientTransportOptions clientTransportOptions =
+        new ClientTransportFactory.ClientTransportOptions()
+          .setAuthority(AUTHORITY)
+          .setUserAgent(USER_AGENT);
   private final Metadata origHeaders = new Metadata();
-  private final StatsTraceContext statsTraceCtx = StatsTraceContext.newClientContext(
-      method.getFullMethodName(), NoopStatsContextFactory.INSTANCE, GrpcUtil.STOPWATCH_SUPPLIER);
   private ForwardingConnectionClientTransport transport;
   private CallOptions callOptions;
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
     origHeaders.put(ORIG_HEADER_KEY, ORIG_HEADER_VALUE);
-    when(mockTransportFactory.newClientTransport(address, AUTHORITY, USER_AGENT))
+    when(mockTransportFactory.newClientTransport(address, clientTransportOptions, channelLogger))
         .thenReturn(mockTransport);
-    when(mockTransport.newStream(same(method), any(Metadata.class), any(CallOptions.class),
-            any(StatsTraceContext.class)))
+    when(mockTransport.newStream(
+            same(method), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockStream);
     ClientTransportFactory transportFactory = new CallCredentialsApplyingTransportFactory(
-        mockTransportFactory, mockExecutor);
-    transport = (ForwardingConnectionClientTransport) transportFactory.newClientTransport(
-        address, AUTHORITY, USER_AGENT);
+        mockTransportFactory, null, mockExecutor);
+    transport = (ForwardingConnectionClientTransport)
+        transportFactory.newClientTransport(address, clientTransportOptions, channelLogger);
     callOptions = CallOptions.DEFAULT.withCallCredentials(mockCreds);
-    verify(mockTransportFactory).newClientTransport(address, AUTHORITY, USER_AGENT);
+    verify(mockTransportFactory).newClientTransport(address, clientTransportOptions, channelLogger);
     assertSame(mockTransport, transport.delegate());
   }
 
@@ -135,102 +142,187 @@ public void parameterPropagation_base() {
     Attributes transportAttrs = Attributes.newBuilder().set(ATTR_KEY, ATTR_VALUE).build();
     when(mockTransport.getAttributes()).thenReturn(transportAttrs);
 
-    transport.newStream(method, origHeaders, callOptions, statsTraceCtx);
-
-    ArgumentCaptor<Attributes> attrsCaptor = ArgumentCaptor.forClass(null);
-    verify(mockCreds).applyRequestMetadata(same(method), attrsCaptor.capture(), same(mockExecutor),
-        any(MetadataApplier.class));
-    Attributes attrs = attrsCaptor.getValue();
-    assertSame(ATTR_VALUE, attrs.get(ATTR_KEY));
-    assertSame(AUTHORITY, attrs.get(CallCredentials.ATTR_AUTHORITY));
-    assertSame(SecurityLevel.NONE, attrs.get(CallCredentials.ATTR_SECURITY_LEVEL));
+    transport.newStream(method, origHeaders, callOptions, tracers);
+
+    ArgumentCaptor<RequestInfo> infoCaptor = ArgumentCaptor.forClass(RequestInfo.class);
+    verify(mockCreds).applyRequestMetadata(infoCaptor.capture(), same(mockExecutor),
+        any(CallCredentials.MetadataApplier.class));
+    RequestInfo info = infoCaptor.getValue();
+    assertSame(transportAttrs, info.getTransportAttrs());
+    assertSame(method, info.getMethodDescriptor());
+    assertSame(callOptions, info.getCallOptions());
+    assertSame(AUTHORITY, info.getAuthority());
+    assertSame(SecurityLevel.NONE, info.getSecurityLevel());
   }
 
   @Test
-  public void parameterPropagation_overrideByTransport() {
+  public void parameterPropagation_overrideByCallOptions() {
     Attributes transportAttrs = Attributes.newBuilder()
         .set(ATTR_KEY, ATTR_VALUE)
-        .set(CallCredentials.ATTR_AUTHORITY, "transport-override-authority")
-        .set(CallCredentials.ATTR_SECURITY_LEVEL, SecurityLevel.INTEGRITY)
+        .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.INTEGRITY)
         .build();
     when(mockTransport.getAttributes()).thenReturn(transportAttrs);
+    Executor anotherExecutor = mock(Executor.class);
+
+    transport.newStream(
+        method, origHeaders,
+        callOptions.withAuthority("calloptions-authority").withExecutor(anotherExecutor),
+        tracers);
+
+    ArgumentCaptor<RequestInfo> infoCaptor = ArgumentCaptor.forClass(RequestInfo.class);
+    verify(mockCreds).applyRequestMetadata(infoCaptor.capture(),
+        same(mockExecutor), any(CallCredentials.MetadataApplier.class));
+    RequestInfo info = infoCaptor.getValue();
+    assertSame(transportAttrs, info.getTransportAttrs());
+    assertSame(method, info.getMethodDescriptor());
+    assertEquals("calloptions-authority", info.getAuthority());
+    assertSame(SecurityLevel.INTEGRITY, info.getSecurityLevel());
+  }
 
-    transport.newStream(method, origHeaders, callOptions, statsTraceCtx);
+  @Test
+  public void parameterPropagation_transportSetSecurityLevel() {
+    Attributes transportAttrs = Attributes.newBuilder()
+            .set(ATTR_KEY, ATTR_VALUE)
+            .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.INTEGRITY)
+            .build();
+    when(mockTransport.getAttributes()).thenReturn(transportAttrs);
 
-    ArgumentCaptor<Attributes> attrsCaptor = ArgumentCaptor.forClass(null);
-    verify(mockCreds).applyRequestMetadata(same(method), attrsCaptor.capture(), same(mockExecutor),
-        any(MetadataApplier.class));
-    Attributes attrs = attrsCaptor.getValue();
-    assertSame(ATTR_VALUE, attrs.get(ATTR_KEY));
-    assertEquals("transport-override-authority", attrs.get(CallCredentials.ATTR_AUTHORITY));
-    assertSame(SecurityLevel.INTEGRITY, attrs.get(CallCredentials.ATTR_SECURITY_LEVEL));
+    transport.newStream(method, origHeaders, callOptions, tracers);
+
+    ArgumentCaptor<RequestInfo> infoCaptor = ArgumentCaptor.forClass(RequestInfo.class);
+    verify(mockCreds).applyRequestMetadata(
+            infoCaptor.capture(), same(mockExecutor),
+            any(io.grpc.CallCredentials.MetadataApplier.class));
+    RequestInfo info = infoCaptor.getValue();
+    assertSame(method, info.getMethodDescriptor());
+    assertSame(ATTR_VALUE, info.getTransportAttrs().get(ATTR_KEY));
+    assertSame(AUTHORITY, info.getAuthority());
+    assertSame(SecurityLevel.INTEGRITY, info.getSecurityLevel());
   }
 
   @Test
-  public void parameterPropagation_overrideByCallOptions() {
+  public void parameterPropagation_callOptionsSetAuthority() {
     Attributes transportAttrs = Attributes.newBuilder()
-        .set(ATTR_KEY, ATTR_VALUE)
-        .set(CallCredentials.ATTR_AUTHORITY, "transport-override-authority")
-        .set(CallCredentials.ATTR_SECURITY_LEVEL, SecurityLevel.INTEGRITY)
-        .build();
+            .set(ATTR_KEY, ATTR_VALUE)
+            .build();
     when(mockTransport.getAttributes()).thenReturn(transportAttrs);
     Executor anotherExecutor = mock(Executor.class);
 
-    transport.newStream(method, origHeaders,
-        callOptions.withAuthority("calloptions-authority").withExecutor(anotherExecutor),
-        statsTraceCtx);
-
-    ArgumentCaptor<Attributes> attrsCaptor = ArgumentCaptor.forClass(null);
-    verify(mockCreds).applyRequestMetadata(same(method), attrsCaptor.capture(),
-        same(anotherExecutor), any(MetadataApplier.class));
-    Attributes attrs = attrsCaptor.getValue();
-    assertSame(ATTR_VALUE, attrs.get(ATTR_KEY));
-    assertEquals("calloptions-authority", attrs.get(CallCredentials.ATTR_AUTHORITY));
-    assertSame(SecurityLevel.INTEGRITY, attrs.get(CallCredentials.ATTR_SECURITY_LEVEL));
+    transport.newStream(
+            method, origHeaders,
+            callOptions.withAuthority("calloptions-authority").withExecutor(anotherExecutor),
+            tracers);
+
+    ArgumentCaptor<RequestInfo> infoCaptor = ArgumentCaptor.forClass(RequestInfo.class);
+    verify(mockCreds).applyRequestMetadata(
+            infoCaptor.capture(), same(mockExecutor),
+            any(io.grpc.CallCredentials.MetadataApplier.class));
+    RequestInfo info = infoCaptor.getValue();
+    assertSame(method, info.getMethodDescriptor());
+    assertSame(ATTR_VALUE, info.getTransportAttrs().get(ATTR_KEY));
+    assertEquals("calloptions-authority", info.getAuthority());
+    assertSame(SecurityLevel.NONE, info.getSecurityLevel());
+  }
+
+  @Test
+  public void credentialThrows() {
+    final RuntimeException ex = new RuntimeException();
+    when(mockTransport.getAttributes()).thenReturn(Attributes.EMPTY);
+    doThrow(ex).when(mockCreds).applyRequestMetadata(
+        any(RequestInfo.class), same(mockExecutor),
+        any(CallCredentials.MetadataApplier.class));
+
+    FailingClientStream stream = (FailingClientStream) transport.newStream(
+        method, origHeaders, callOptions, tracers);
+
+    verify(mockTransport, never()).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    assertEquals(Status.Code.UNAUTHENTICATED, stream.getError().getCode());
+    assertSame(ex, stream.getError().getCause());
+
+    transport.shutdown(Status.UNAVAILABLE);
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
+        instanceof FailingClientStream);
+    verify(mockTransport).shutdown(Status.UNAVAILABLE);
   }
 
   @Test
   public void applyMetadata_inline() {
     when(mockTransport.getAttributes()).thenReturn(Attributes.EMPTY);
-    doAnswer(new Answer<Void>() {
-        @Override
-        public Void answer(InvocationOnMock invocation) throws Throwable {
-          MetadataApplier applier = (MetadataApplier) invocation.getArguments()[3];
-          Metadata headers = new Metadata();
-          headers.put(CREDS_KEY, CREDS_VALUE);
-          applier.apply(headers);
-          return null;
-        }
-      }).when(mockCreds).applyRequestMetadata(same(method), any(Attributes.class),
-          same(mockExecutor), any(MetadataApplier.class));
 
-    ClientStream stream = transport.newStream(method, origHeaders, callOptions, statsTraceCtx);
+    callOptions = callOptions.withCallCredentials(new FakeCallCredentials(CREDS_KEY, CREDS_VALUE));
+    ClientStream stream = transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
-    verify(mockTransport).newStream(method, origHeaders, callOptions, statsTraceCtx);
+    verify(mockTransport).newStream(method, origHeaders, callOptions, tracers);
     assertSame(mockStream, stream);
     assertEquals(CREDS_VALUE, origHeaders.get(CREDS_KEY));
     assertEquals(ORIG_HEADER_VALUE, origHeaders.get(ORIG_HEADER_KEY));
+    transport.shutdown(Status.UNAVAILABLE);
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
+        instanceof FailingClientStream);
+    verify(mockTransport).shutdown(Status.UNAVAILABLE);
   }
 
   @Test
   public void fail_inline() {
-    final Status error = Status.FAILED_PRECONDITION.withDescription("channel not secure for creds");
+    final Status error = Status.UNAVAILABLE.withDescription("channel not secure for creds");
     when(mockTransport.getAttributes()).thenReturn(Attributes.EMPTY);
     doAnswer(new Answer<Void>() {
         @Override
         public Void answer(InvocationOnMock invocation) throws Throwable {
-          MetadataApplier applier = (MetadataApplier) invocation.getArguments()[3];
+          CallCredentials.MetadataApplier applier =
+              (CallCredentials.MetadataApplier) invocation.getArguments()[2];
           applier.fail(error);
           return null;
         }
-      }).when(mockCreds).applyRequestMetadata(same(method), any(Attributes.class),
-          same(mockExecutor), any(MetadataApplier.class));
+      }).when(mockCreds).applyRequestMetadata(any(RequestInfo.class),
+          same(mockExecutor), any(CallCredentials.MetadataApplier.class));
 
-    FailingClientStream stream =
-        (FailingClientStream) transport.newStream(method, origHeaders, callOptions, statsTraceCtx);
+    FailingClientStream stream = (FailingClientStream) transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
-    verify(mockTransport, never()).newStream(method, origHeaders, callOptions, statsTraceCtx);
+    verify(mockTransport, never()).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     assertSame(error, stream.getError());
+    transport.shutdownNow(Status.UNAVAILABLE);
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
+        instanceof FailingClientStream);
+    verify(mockTransport).shutdownNow(Status.UNAVAILABLE);
+  }
+
+  // If the creds return an error that is inappropriate to directly propagate from the control plane
+  // to the call, it should be converted to an INTERNAL error.
+  @Test
+  public void fail_inline_inappropriate_error() {
+    final Status error = Status.NOT_FOUND.withDescription("channel not secure for creds");
+    when(mockTransport.getAttributes()).thenReturn(Attributes.EMPTY);
+    doAnswer(new Answer<Void>() {
+      @Override
+      public Void answer(InvocationOnMock invocation) throws Throwable {
+        CallCredentials.MetadataApplier applier =
+            (CallCredentials.MetadataApplier) invocation.getArguments()[2];
+        applier.fail(error);
+        return null;
+      }
+    }).when(mockCreds).applyRequestMetadata(any(RequestInfo.class),
+        same(mockExecutor), any(CallCredentials.MetadataApplier.class));
+
+    FailingClientStream stream = (FailingClientStream) transport.newStream(
+        method, origHeaders, callOptions, tracers);
+
+    verify(mockTransport, never()).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    assertThat(stream.getError().getCode()).isEqualTo(Code.INTERNAL);
+    assertThat(stream.getError().getDescription()).contains("Inappropriate");
+    assertThat(stream.getError().getCause()).isNull();
+    transport.shutdownNow(Status.UNAVAILABLE);
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
+        instanceof FailingClientStream);
+    verify(mockTransport).shutdownNow(Status.UNAVAILABLE);
   }
 
   @Test
@@ -238,22 +330,106 @@ public void applyMetadata_delayed() {
     when(mockTransport.getAttributes()).thenReturn(Attributes.EMPTY);
 
     // Will call applyRequestMetadata(), which is no-op.
-    DelayedStream stream = (DelayedStream) transport.newStream(method, origHeaders, callOptions,
-        statsTraceCtx);
+    DelayedStream stream = (DelayedStream) transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
-    ArgumentCaptor<MetadataApplier> applierCaptor = ArgumentCaptor.forClass(null);
-    verify(mockCreds).applyRequestMetadata(same(method), any(Attributes.class),
+    ArgumentCaptor<CallCredentials.MetadataApplier> applierCaptor =
+        ArgumentCaptor.forClass(CallCredentials.MetadataApplier.class);
+    verify(mockCreds).applyRequestMetadata(any(RequestInfo.class),
         same(mockExecutor), applierCaptor.capture());
-    verify(mockTransport, never()).newStream(method, origHeaders, callOptions, statsTraceCtx);
+    verify(mockTransport, never()).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+
+    transport.shutdown(Status.UNAVAILABLE);
+    verify(mockTransport, never()).shutdown(Status.UNAVAILABLE);
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
+        instanceof FailingClientStream);
 
     Metadata headers = new Metadata();
     headers.put(CREDS_KEY, CREDS_VALUE);
     applierCaptor.getValue().apply(headers);
 
-    verify(mockTransport).newStream(method, origHeaders, callOptions, statsTraceCtx);
+    verify(mockTransport).newStream(method, origHeaders, callOptions, tracers);
     assertSame(mockStream, stream.getRealStream());
     assertEquals(CREDS_VALUE, origHeaders.get(CREDS_KEY));
     assertEquals(ORIG_HEADER_VALUE, origHeaders.get(ORIG_HEADER_KEY));
+    verify(mockTransport).shutdown(Status.UNAVAILABLE);
+  }
+
+  @Test
+  public void delayedShutdown_shutdownShutdownNowThenApply() {
+    transport.newStream(method, origHeaders, callOptions, tracers);
+    ArgumentCaptor<CallCredentials.MetadataApplier> applierCaptor =
+        ArgumentCaptor.forClass(CallCredentials.MetadataApplier.class);
+    verify(mockCreds).applyRequestMetadata(any(RequestInfo.class),
+        same(mockExecutor), applierCaptor.capture());
+    transport.shutdown(Status.UNAVAILABLE);
+    transport.shutdownNow(Status.ABORTED);
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
+        instanceof FailingClientStream);
+    verify(mockTransport, never()).shutdown(any(Status.class));
+    verify(mockTransport, never()).shutdownNow(any(Status.class));
+    Metadata headers = new Metadata();
+    headers.put(CREDS_KEY, CREDS_VALUE);
+    applierCaptor.getValue().apply(headers);
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
+        instanceof FailingClientStream);
+    verify(mockTransport).shutdown(Status.UNAVAILABLE);
+    verify(mockTransport).shutdownNow(Status.ABORTED);
+  }
+
+  @Test
+  public void delayedShutdown_shutdownThenApplyThenShutdownNow() {
+    transport.newStream(method, origHeaders, callOptions, tracers);
+    ArgumentCaptor<CallCredentials.MetadataApplier> applierCaptor =
+        ArgumentCaptor.forClass(CallCredentials.MetadataApplier.class);
+    verify(mockCreds).applyRequestMetadata(any(RequestInfo.class),
+        same(mockExecutor), applierCaptor.capture());
+    transport.shutdown(Status.UNAVAILABLE);
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
+        instanceof FailingClientStream);
+    verify(mockTransport, never()).shutdown(any(Status.class));
+    Metadata headers = new Metadata();
+    headers.put(CREDS_KEY, CREDS_VALUE);
+    applierCaptor.getValue().apply(headers);
+    verify(mockTransport).shutdown(Status.UNAVAILABLE);
+    transport.shutdownNow(Status.ABORTED);
+    verify(mockTransport).shutdownNow(Status.ABORTED);
+
+    transport.shutdown(Status.UNAVAILABLE);
+    verify(mockTransport).shutdown(Status.UNAVAILABLE);
+    transport.shutdownNow(Status.ABORTED);
+    verify(mockTransport, times(2)).shutdownNow(Status.ABORTED);
+  }
+
+  @Test
+  public void delayedShutdown_shutdownMulti() {
+    Metadata headers = new Metadata();
+    headers.put(CREDS_KEY, CREDS_VALUE);
+
+    transport.newStream(method, origHeaders, callOptions, tracers);
+    transport.newStream(method, origHeaders, callOptions, tracers);
+    transport.newStream(method, origHeaders, callOptions, tracers);
+    ArgumentCaptor<CallCredentials.MetadataApplier> applierCaptor =
+        ArgumentCaptor.forClass(CallCredentials.MetadataApplier.class);
+    verify(mockCreds, times(3)).applyRequestMetadata(any(RequestInfo.class),
+        same(mockExecutor), applierCaptor.capture());
+    applierCaptor.getAllValues().get(1).apply(headers);
+    transport.shutdown(Status.UNAVAILABLE);
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
+        instanceof FailingClientStream);
+    verify(mockTransport, never()).shutdown(Status.UNAVAILABLE);
+
+    applierCaptor.getAllValues().get(0).apply(headers);
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
+        instanceof FailingClientStream);
+    verify(mockTransport, never()).shutdown(Status.UNAVAILABLE);
+
+    applierCaptor.getAllValues().get(2).apply(headers);
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
+        instanceof FailingClientStream);
+    verify(mockTransport).shutdown(Status.UNAVAILABLE);
   }
 
   @Test
@@ -261,29 +437,89 @@ public void fail_delayed() {
     when(mockTransport.getAttributes()).thenReturn(Attributes.EMPTY);
 
     // Will call applyRequestMetadata(), which is no-op.
-    DelayedStream stream = (DelayedStream) transport.newStream(method, origHeaders, callOptions,
-        statsTraceCtx);
+    DelayedStream stream = (DelayedStream) transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
-    ArgumentCaptor<MetadataApplier> applierCaptor = ArgumentCaptor.forClass(null);
-    verify(mockCreds).applyRequestMetadata(same(method), any(Attributes.class),
+    ArgumentCaptor<CallCredentials.MetadataApplier> applierCaptor =
+        ArgumentCaptor.forClass(CallCredentials.MetadataApplier.class);
+    verify(mockCreds).applyRequestMetadata(any(RequestInfo.class),
         same(mockExecutor), applierCaptor.capture());
 
-    Status error = Status.FAILED_PRECONDITION.withDescription("channel not secure for creds");
+    Status error = Status.UNAVAILABLE.withDescription("channel not secure for creds");
     applierCaptor.getValue().fail(error);
 
-    verify(mockTransport, never()).newStream(method, origHeaders, callOptions, statsTraceCtx);
+    verify(mockTransport, never()).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     FailingClientStream failingStream = (FailingClientStream) stream.getRealStream();
     assertSame(error, failingStream.getError());
+    transport.shutdown(Status.UNAVAILABLE);
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
+        instanceof FailingClientStream);
+    verify(mockTransport).shutdown(Status.UNAVAILABLE);
   }
 
   @Test
   public void noCreds() {
     callOptions = callOptions.withCallCredentials(null);
-    ClientStream stream = transport.newStream(method, origHeaders, callOptions, statsTraceCtx);
+    ClientStream stream = transport.newStream(
+        method, origHeaders, callOptions, tracers);
 
-    verify(mockTransport).newStream(method, origHeaders, callOptions, statsTraceCtx);
+    verify(mockTransport).newStream(method, origHeaders, callOptions, tracers);
     assertSame(mockStream, stream);
     assertNull(origHeaders.get(CREDS_KEY));
     assertEquals(ORIG_HEADER_VALUE, origHeaders.get(ORIG_HEADER_KEY));
+    transport.shutdown(Status.UNAVAILABLE);
+    assertTrue(transport.newStream(method, origHeaders, callOptions, tracers)
+        instanceof FailingClientStream);
+    verify(mockTransport).shutdown(Status.UNAVAILABLE);
+  }
+
+  @Test
+  public void justCallOptionCreds() {
+    callOptions = callOptions.withCallCredentials(new FakeCallCredentials(CREDS_KEY, CREDS_VALUE));
+
+    ClientStream stream = transport.newStream(
+        method, origHeaders, callOptions, tracers);
+
+    assertSame(mockStream, stream);
+    assertEquals(CREDS_VALUE, origHeaders.get(CREDS_KEY));
+    assertEquals(ORIG_HEADER_VALUE, origHeaders.get(ORIG_HEADER_KEY));
+  }
+
+  @Test
+  public void justChannelCreds() {
+    ClientTransportFactory transportFactory = new CallCredentialsApplyingTransportFactory(
+        mockTransportFactory, new FakeCallCredentials(CREDS_KEY, CREDS_VALUE), mockExecutor);
+    transport = (ForwardingConnectionClientTransport)
+        transportFactory.newClientTransport(address, clientTransportOptions, channelLogger);
+    callOptions = callOptions.withCallCredentials(null);
+
+    ClientStream stream = transport.newStream(
+        method, origHeaders, callOptions, tracers);
+
+    assertSame(mockStream, stream);
+    assertEquals(CREDS_VALUE, origHeaders.get(CREDS_KEY));
+    assertEquals(ORIG_HEADER_VALUE, origHeaders.get(ORIG_HEADER_KEY));
+  }
+
+  @Test
+  public void callOptionAndChanelCreds() {
+    ClientTransportFactory transportFactory = new CallCredentialsApplyingTransportFactory(
+        mockTransportFactory, new FakeCallCredentials(CREDS_KEY, CREDS_VALUE), mockExecutor);
+    transport = (ForwardingConnectionClientTransport)
+        transportFactory.newClientTransport(address, clientTransportOptions, channelLogger);
+    Metadata.Key<String> creds2Key =
+        Metadata.Key.of("test-creds2", Metadata.ASCII_STRING_MARSHALLER);
+    String creds2Value = "some more credentials";
+    callOptions = callOptions.withCallCredentials(new FakeCallCredentials(creds2Key, creds2Value));
+
+    ClientStream stream = transport.newStream(
+        method, origHeaders, callOptions, tracers);
+
+    assertSame(mockStream, stream);
+    assertEquals(CREDS_VALUE, origHeaders.get(CREDS_KEY));
+    assertEquals(creds2Value, origHeaders.get(creds2Key));
+    assertEquals(ORIG_HEADER_VALUE, origHeaders.get(ORIG_HEADER_KEY));
   }
 }
diff --git a/core/src/test/java/io/grpc/internal/ChannelExecutorTest.java b/core/src/test/java/io/grpc/internal/ChannelExecutorTest.java
deleted file mode 100644
index f0c639b78ce..00000000000
--- a/core/src/test/java/io/grpc/internal/ChannelExecutorTest.java
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.inOrder;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-/**
- * Unit tests for {@link ChannelExecutor}.
- */
-@RunWith(JUnit4.class)
-public class ChannelExecutorTest {
-  private final ChannelExecutor executor = new ChannelExecutor();
-
-  @Mock
-  private Runnable task1;
-
-  @Mock
-  private Runnable task2;
-
-  @Mock
-  private Runnable task3;
-
-  @Before public void setUp() {
-    MockitoAnnotations.initMocks(this);
-  }
-
-  @Test
-  public void singleThread() {
-    executor.executeLater(task1);
-    executor.executeLater(task2);
-    InOrder inOrder = inOrder(task1, task2, task3);
-    inOrder.verifyNoMoreInteractions();
-    executor.drain();
-    inOrder.verify(task1).run();
-    inOrder.verify(task2).run();
-
-    executor.executeLater(task3);
-    inOrder.verifyNoMoreInteractions();
-    executor.drain();
-    inOrder.verify(task3).run();
-  }
-
-  @Test
-  public void multiThread() throws Exception {
-    InOrder inOrder = inOrder(task1, task2);
-
-    final CountDownLatch task1Added = new CountDownLatch(1);
-    final CountDownLatch task1Running = new CountDownLatch(1);
-    final CountDownLatch task1Proceed = new CountDownLatch(1);
-    final CountDownLatch sideThreadDone = new CountDownLatch(1);
-    final AtomicReference<Thread> task1Thread = new AtomicReference<Thread>();
-    final AtomicReference<Thread> task2Thread = new AtomicReference<Thread>();
-
-    doAnswer(new Answer<Void>() {
-        @Override
-        public Void answer(InvocationOnMock invocation) {
-          task1Thread.set(Thread.currentThread());
-          task1Running.countDown();
-          try {
-            assertTrue(task1Proceed.await(5, TimeUnit.SECONDS));
-          } catch (InterruptedException e) {
-            throw new RuntimeException(e);
-          }
-          return null;
-        }
-      }).when(task1).run();
-
-    doAnswer(new Answer<Void>() {
-        @Override
-        public Void answer(InvocationOnMock invocation) {
-          task2Thread.set(Thread.currentThread());
-          return null;
-        }
-      }).when(task2).run();
-
-    Thread sideThread = new Thread() {
-        @Override
-        public void run() {
-          executor.executeLater(task1);
-          task1Added.countDown();
-          executor.drain();
-          sideThreadDone.countDown();
-        }
-      };
-    sideThread.start();
-
-    assertTrue(task1Added.await(5, TimeUnit.SECONDS));
-    executor.executeLater(task2);
-    assertTrue(task1Running.await(5, TimeUnit.SECONDS));
-    // This will do nothing because task1 is running until task1Proceed is set
-    executor.drain();
-
-    inOrder.verify(task1).run();
-    inOrder.verifyNoMoreInteractions();
-
-    task1Proceed.countDown();
-    // drain() on the side thread has returned, which runs task2
-    assertTrue(sideThreadDone.await(5, TimeUnit.SECONDS));
-    inOrder.verify(task2).run();
-
-    assertSame(sideThread, task1Thread.get());
-    assertSame(sideThread, task2Thread.get());
-  }
-
-  @Test
-  public void taskThrows() {
-    InOrder inOrder = inOrder(task1, task2, task3);
-    doAnswer(new Answer<Void>() {
-        @Override
-        public Void answer(InvocationOnMock invocation) {
-          throw new RuntimeException("Simulated");
-        }
-      }).when(task2).run();
-    executor.executeLater(task1);
-    executor.executeLater(task2);
-    executor.executeLater(task3);
-    executor.drain();
-    inOrder.verify(task1).run();
-    inOrder.verify(task2).run();
-    inOrder.verify(task3).run();
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/ChannelLoggerImplTest.java b/core/src/test/java/io/grpc/internal/ChannelLoggerImplTest.java
new file mode 100644
index 00000000000..afe8e9828c9
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ChannelLoggerImplTest.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.InternalChannelz.ChannelStats;
+import io.grpc.InternalChannelz.ChannelTrace.Event;
+import io.grpc.InternalChannelz.ChannelTrace.Event.Severity;
+import io.grpc.InternalLogId;
+import java.util.ArrayList;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link ChannelLoggerImpl}.
+ */
+@RunWith(JUnit4.class)
+public class ChannelLoggerImplTest {
+  private static final Logger javaLogger = Logger.getLogger(ChannelLogger.class.getName());
+  private final FakeClock clock = new FakeClock();
+  private final InternalLogId logId = InternalLogId.allocate("test", /*details=*/ null);
+  private final String logPrefix = "[" + logId + "] ";
+  private final ArrayList<String> logs = new ArrayList<>();
+  private final Handler handler = new Handler() {
+      @Override
+      public void publish(LogRecord record) {
+        logs.add(record.getLevel() + ": " + record.getMessage());
+      }
+
+      @Override
+      public void flush() {
+      }
+
+      @Override
+      public void close() throws SecurityException {
+      }
+    };
+
+  @Before
+  public void setUp() {
+    javaLogger.addHandler(handler);
+    javaLogger.setLevel(java.util.logging.Level.ALL);
+  }
+
+  @After
+  public void tearDown() {
+    javaLogger.removeHandler(handler);
+  }
+
+  @Test
+  public void logging() {
+    ChannelTracer tracer = new ChannelTracer(
+        logId, /* maxEvents= */ 1, /* channelCreationTimeNanos= */ 3L, "fooType");
+    ChannelLoggerImpl logger = new ChannelLoggerImpl(tracer, clock.getTimeProvider());
+    ChannelStats.Builder builder = new ChannelStats.Builder();
+    logs.clear();
+
+    clock.forwardNanos(100);
+    logger.log(ChannelLogLevel.ERROR, "Error message");
+    tracer.updateBuilder(builder);
+    ChannelStats stats = builder.build();
+    Event event = new Event.Builder()
+        .setDescription("Error message")
+        .setSeverity(Severity.CT_ERROR)
+        .setTimestampNanos(100)
+        .build();
+    assertThat(stats.channelTrace.events).containsExactly(event);
+    assertThat(logs).contains("FINE: " + logPrefix + "Error message");
+
+    clock.forwardNanos(100);
+    logger.log(ChannelLogLevel.WARNING, "Warning message");
+    tracer.updateBuilder(builder);
+    stats = builder.build();
+    event = new Event.Builder()
+        .setDescription("Warning message")
+        .setSeverity(Severity.CT_WARNING)
+        .setTimestampNanos(200)
+        .build();
+    assertThat(stats.channelTrace.events).containsExactly(event);
+    assertThat(logs).contains("FINE: " + logPrefix + "Warning message");
+
+    clock.forwardNanos(100);
+    logger.log(ChannelLogLevel.INFO, "Info message");
+    tracer.updateBuilder(builder);
+    stats = builder.build();
+    event = new Event.Builder()
+        .setDescription("Info message")
+        .setSeverity(Severity.CT_INFO)
+        .setTimestampNanos(300)
+        .build();
+    assertThat(stats.channelTrace.events).containsExactly(event);
+    assertThat(logs).contains("FINER: " + logPrefix + "Info message");
+
+    clock.forwardNanos(100);
+    logger.log(ChannelLogLevel.DEBUG, "Debug message");
+    tracer.updateBuilder(builder);
+    stats = builder.build();
+    // DEBUG level messages are not logged to channelz, thus channelz still has the
+    // last event.
+    assertThat(stats.channelTrace.events).containsExactly(event);
+    assertThat(logs).contains("FINEST: " + logPrefix + "Debug message");
+  }
+
+  @Test
+  public void formatLogging() {
+    ChannelTracer tracer = new ChannelTracer(
+        logId, /* maxEvents= */ 1, /* channelCreationTimeNanos= */ 3L, "fooType");
+    ChannelLoggerImpl logger = new ChannelLoggerImpl(tracer, clock.getTimeProvider());
+    ChannelStats.Builder builder = new ChannelStats.Builder();
+    logs.clear();
+
+    clock.forwardNanos(100);
+    logger.log(ChannelLogLevel.ERROR, "Error message {0}", "foo");
+    tracer.updateBuilder(builder);
+    ChannelStats stats = builder.build();
+    Event event = new Event.Builder()
+        .setDescription("Error message foo")
+        .setSeverity(Severity.CT_ERROR)
+        .setTimestampNanos(100)
+        .build();
+    assertThat(stats.channelTrace.events).containsExactly(event);
+    assertThat(logs).contains("FINE: " + logPrefix + "Error message foo");
+
+    clock.forwardNanos(100);
+    logger.log(ChannelLogLevel.WARNING, "Warning message {0}, {1}", "foo", "bar");
+    tracer.updateBuilder(builder);
+    stats = builder.build();
+    event = new Event.Builder()
+        .setDescription("Warning message foo, bar")
+        .setSeverity(Severity.CT_WARNING)
+        .setTimestampNanos(200)
+        .build();
+    assertThat(stats.channelTrace.events).containsExactly(event);
+    assertThat(logs).contains("FINE: " + logPrefix + "Warning message foo, bar");
+
+    clock.forwardNanos(100);
+    logger.log(ChannelLogLevel.INFO, "Info message {0}", "bar");
+    tracer.updateBuilder(builder);
+    stats = builder.build();
+    event = new Event.Builder()
+        .setDescription("Info message bar")
+        .setSeverity(Severity.CT_INFO)
+        .setTimestampNanos(300)
+        .build();
+    assertThat(stats.channelTrace.events).containsExactly(event);
+    assertThat(logs).contains("FINER: " + logPrefix + "Info message bar");
+
+    clock.forwardNanos(100);
+    logger.log(ChannelLogLevel.DEBUG, "Debug message {0}", "foo");
+    tracer.updateBuilder(builder);
+    stats = builder.build();
+    // DEBUG level messages are not logged to channelz, thus channelz still has the
+    // last event.
+    assertThat(stats.channelTrace.events).containsExactly(event);
+    assertThat(logs).contains("FINEST: " + logPrefix + "Debug message foo");
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ChannelTracerTest.java b/core/src/test/java/io/grpc/internal/ChannelTracerTest.java
new file mode 100644
index 00000000000..24da7c7ff4a
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ChannelTracerTest.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.ChannelLogger;
+import io.grpc.InternalChannelz.ChannelStats;
+import io.grpc.InternalChannelz.ChannelTrace.Event;
+import io.grpc.InternalChannelz.ChannelTrace.Event.Severity;
+import io.grpc.InternalLogId;
+import java.util.ArrayList;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link ChannelTracer}.
+ */
+@RunWith(JUnit4.class)
+public class ChannelTracerTest {
+  private static final Logger logger = Logger.getLogger(ChannelLogger.class.getName());
+  private final ArrayList<LogRecord> logs = new ArrayList<>();
+  private final Handler handler = new Handler() {
+      @Override
+      public void publish(LogRecord record) {
+        logs.add(record);
+      }
+
+      @Override
+      public void flush() {
+      }
+
+      @Override
+      public void close() throws SecurityException {
+      }
+    };
+
+  private final InternalLogId logId = InternalLogId.allocate("test", /*details=*/ null);
+  private final String logPrefix = "[" + logId + "] ";
+
+  @Before
+  public void setUp() {
+    logger.addHandler(handler);
+    logger.setLevel(Level.ALL);
+  }
+
+  @After
+  public void tearDown() {
+    logger.removeHandler(handler);
+  }
+
+  @Test
+  public void channelTracerWithZeroMaxEvents() {
+    ChannelTracer channelTracer =
+        new ChannelTracer(logId, /* maxEvents= */ 0, /* channelCreationTimeNanos= */ 3L, "fooType");
+    ChannelStats.Builder builder = new ChannelStats.Builder();
+    Event e1 = new Event.Builder()
+        .setDescription("e1").setSeverity(Severity.CT_ERROR).setTimestampNanos(1001).build();
+    channelTracer.reportEvent(e1);
+
+    channelTracer.updateBuilder(builder);
+    ChannelStats stats = builder.build();
+    assertThat(stats.channelTrace).isNull();
+
+    assertThat(logs).hasSize(2);
+    LogRecord log = logs.remove(0);
+    assertThat(log.getMessage()).isEqualTo(logPrefix + "fooType created");
+    assertThat(log.getLevel()).isEqualTo(Level.FINEST);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).isEqualTo(logPrefix + "e1");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+  }
+
+  @Test
+  public void reportEvents() {
+    ChannelTracer channelTracer =
+        new ChannelTracer(logId, /* maxEvents= */ 2, /* channelCreationTimeNanos= */ 3L, "fooType");
+    ChannelStats.Builder builder = new ChannelStats.Builder();
+    Event e1 = new Event.Builder()
+        .setDescription("e1").setSeverity(Severity.CT_ERROR).setTimestampNanos(1001).build();
+    Event e2 = new Event.Builder()
+        .setDescription("e2").setSeverity(Severity.CT_INFO).setTimestampNanos(1002).build();
+    Event e3 = new Event.Builder()
+        .setDescription("e3").setSeverity(Severity.CT_WARNING).setTimestampNanos(1003).build();
+    Event e4 = new Event.Builder()
+        .setDescription("e4").setSeverity(Severity.CT_UNKNOWN).setTimestampNanos(1004).build();
+
+    // Check Channelz
+    channelTracer.updateBuilder(builder);
+    ChannelStats stats = builder.build();
+    assertThat(stats.channelTrace.events).hasSize(1);
+    Event creationEvent = stats.channelTrace.events.get(0);
+    assertThat(stats.channelTrace.numEventsLogged).isEqualTo(1);
+
+
+    channelTracer.reportEvent(e1);
+    channelTracer.updateBuilder(builder);
+    stats = builder.build();
+
+    assertThat(stats.channelTrace.events).containsExactly(creationEvent, e1);
+    assertThat(stats.channelTrace.numEventsLogged).isEqualTo(2);
+
+    channelTracer.reportEvent(e2);
+    channelTracer.updateBuilder(builder);
+    stats = builder.build();
+
+    assertThat(stats.channelTrace.events).containsExactly(e1, e2);
+    assertThat(stats.channelTrace.numEventsLogged).isEqualTo(3);
+
+    channelTracer.reportEvent(e3);
+    channelTracer.updateBuilder(builder);
+    stats = builder.build();
+
+    assertThat(stats.channelTrace.events).containsExactly(e2, e3);
+    assertThat(stats.channelTrace.numEventsLogged).isEqualTo(4);
+
+    channelTracer.reportEvent(e4);
+    channelTracer.updateBuilder(builder);
+    stats = builder.build();
+
+    assertThat(stats.channelTrace.events).containsExactly(e3, e4);
+    assertThat(stats.channelTrace.numEventsLogged).isEqualTo(5);
+
+    // Check logs
+    assertThat(logs).hasSize(5);
+    LogRecord log = logs.remove(0);
+    assertThat(log.getMessage()).isEqualTo(logPrefix + "fooType created");
+    assertThat(log.getLevel()).isEqualTo(Level.FINEST);
+
+    log = logs.remove(0);
+    assertThat(log.getMessage()).isEqualTo(logPrefix + "e1");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    log = logs.remove(0);
+    assertThat(log.getMessage()).isEqualTo(logPrefix + "e2");
+    assertThat(log.getLevel()).isEqualTo(Level.FINEST);
+
+    log = logs.remove(0);
+    assertThat(log.getMessage()).isEqualTo(logPrefix + "e3");
+    assertThat(log.getLevel()).isEqualTo(Level.FINER);
+
+    log = logs.remove(0);
+    assertThat(log.getMessage()).isEqualTo(logPrefix + "e4");
+    assertThat(log.getLevel()).isEqualTo(Level.FINEST);
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ClientCallImplTest.java b/core/src/test/java/io/grpc/internal/ClientCallImplTest.java
index 0875757b5d3..03e613e13d9 100644
--- a/core/src/test/java/io/grpc/internal/ClientCallImplTest.java
+++ b/core/src/test/java/io/grpc/internal/ClientCallImplTest.java
@@ -1,83 +1,74 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ClientStreamTracer.NAME_RESOLUTION_DELAYED;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
 import static io.grpc.internal.GrpcUtil.ACCEPT_ENCODING_SPLITTER;
+import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.common.util.concurrent.SettableFuture;
-import com.google.instrumentation.stats.RpcConstants;
-import com.google.instrumentation.stats.StatsContext;
-import com.google.instrumentation.stats.TagValue;
 import io.grpc.Attributes;
-import io.grpc.Attributes.Key;
 import io.grpc.CallOptions;
 import io.grpc.ClientCall;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ClientStreamTracer.StreamInfo;
 import io.grpc.Codec;
 import io.grpc.Context;
 import io.grpc.Deadline;
 import io.grpc.Decompressor;
 import io.grpc.DecompressorRegistry;
+import io.grpc.InternalConfigSelector;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.NoopClientCall;
 import io.grpc.Status;
-import io.grpc.internal.ClientCallImpl.ClientTransportProvider;
-import io.grpc.internal.testing.StatsTestUtils;
-import io.grpc.internal.testing.StatsTestUtils.FakeStatsContextFactory;
+import io.grpc.internal.ClientCallImpl.ClientStreamProvider;
+import io.grpc.internal.ManagedChannelServiceConfig.MethodInfo;
+import io.grpc.internal.SingleMessageProducer;
 import io.grpc.testing.TestMethodDescriptors;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.CountDownLatch;
@@ -89,14 +80,18 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
-import org.mockito.Matchers;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
 
 /**
  * Test for {@link ClientCallImpl}.
@@ -107,6 +102,7 @@ public class ClientCallImplTest {
   private final FakeClock fakeClock = new FakeClock();
   private final ScheduledExecutorService deadlineCancellationExecutor =
       fakeClock.getScheduledExecutorService();
+  private final CallTracer channelCallTracer = CallTracer.getDefaultFactory().create();
   private final DecompressorRegistry decompressorRegistry =
       DecompressorRegistry.getDefaultInstance().with(new Codec.Gzip(), true);
   private final MethodDescriptor<Void, Void> method = MethodDescriptor.<Void, Void>newBuilder()
@@ -116,27 +112,22 @@ public class ClientCallImplTest {
       .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
       .build();
 
-  private final FakeStatsContextFactory statsCtxFactory = new FakeStatsContextFactory();
-  private final StatsContext parentStatsContext = statsCtxFactory.getDefault().with(
-      StatsTestUtils.EXTRA_TAG, TagValue.create("extra-tag-value"));
-  private final StatsTraceContext statsTraceCtx = StatsTraceContext.newClientContextForTesting(
-      method.getFullMethodName(), statsCtxFactory, parentStatsContext,
-      fakeClock.getStopwatchSupplier());
-  private final StatsContext statsCtx = statsCtxFactory.contexts.poll();
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
 
-  @Mock private ClientStreamListener streamListener;
-  @Mock private ClientTransport clientTransport;
   @Captor private ArgumentCaptor<Status> statusCaptor;
 
   @Mock
-  private ClientTransport transport;
+  private ClientStreamTracer.Factory streamTracerFactory;
 
   @Mock
-  private ClientTransportProvider provider;
+  private ClientStreamProvider clientStreamProvider;
 
   @Mock
   private ClientStream stream;
 
+  private InternalConfigSelector configSelector = null;
+
   @Mock
   private ClientCall.Listener<Void> callListener;
 
@@ -146,60 +137,72 @@ public class ClientCallImplTest {
   @Captor
   private ArgumentCaptor<Status> statusArgumentCaptor;
 
+  private CallOptions baseCallOptions;
+
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    assertNotNull(statsCtx);
-    when(provider.get(any(CallOptions.class), any(Metadata.class))).thenReturn(transport);
-    when(transport.newStream(any(MethodDescriptor.class), any(Metadata.class),
-            any(CallOptions.class), any(StatsTraceContext.class))).thenReturn(stream);
+    when(clientStreamProvider.newStream(
+            (MethodDescriptor<?, ?>) any(MethodDescriptor.class),
+            any(CallOptions.class),
+            any(Metadata.class),
+            any(Context.class)))
+        .thenReturn(stream);
+    when(streamTracerFactory.newClientStreamTracer(any(StreamInfo.class), any(Metadata.class)))
+        .thenReturn(new ClientStreamTracer() {});
+    doAnswer(new Answer<Void>() {
+        @Override
+        public Void answer(InvocationOnMock in) {
+          InsightBuilder insight = (InsightBuilder) in.getArguments()[0];
+          insight.appendKeyValue("remote_addr", "127.0.0.1:443");
+          return null;
+        }
+      }).when(stream).appendTimeoutInsight(any(InsightBuilder.class));
+    baseCallOptions = CallOptions.DEFAULT.withStreamTracerFactory(streamTracerFactory);
   }
 
   @After
   public void tearDown() {
-    Context.ROOT.attach();
+    verifyNoMoreInteractions(streamTracerFactory);
   }
 
   @Test
   public void statusPropagatedFromStreamToCallListener() {
     DelayedExecutor executor = new DelayedExecutor();
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         executor,
-        CallOptions.DEFAULT,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor);
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
     call.start(callListener, new Metadata());
     verify(stream).start(listenerArgumentCaptor.capture());
     final ClientStreamListener streamListener = listenerArgumentCaptor.getValue();
     streamListener.headersRead(new Metadata());
     Status status = Status.RESOURCE_EXHAUSTED.withDescription("simulated");
-    streamListener.closed(status , new Metadata());
+    streamListener.closed(status , PROCESSED, new Metadata());
     executor.release();
 
-    verify(callListener).onClose(statusArgumentCaptor.capture(), Matchers.isA(Metadata.class));
-    assertThat(statusArgumentCaptor.getValue()).isSameAs(status);
-    assertStatusInStats(status.getCode());
+    verify(callListener).onClose(same(status), ArgumentMatchers.isA(Metadata.class));
   }
 
   @Test
   public void exceptionInOnMessageTakesPrecedenceOverServer() {
     DelayedExecutor executor = new DelayedExecutor();
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         executor,
-        CallOptions.DEFAULT,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor);
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
     call.start(callListener, new Metadata());
     verify(stream).start(listenerArgumentCaptor.capture());
     final ClientStreamListener streamListener = listenerArgumentCaptor.getValue();
     streamListener.headersRead(new Metadata());
 
     RuntimeException failure = new RuntimeException("bad");
-    doThrow(failure).when(callListener).onMessage(any(Void.class));
+    doThrow(failure).when(callListener).onMessage(ArgumentMatchers.<Void>any());
 
     /*
      * In unary calls, the server closes the call right after responding, so the onClose call is
@@ -207,27 +210,29 @@ public void exceptionInOnMessageTakesPrecedenceOverServer() {
      * stream.  However, since the server closed it "first" the second exception is lost leading to
      * the call being counted as successful.
      */
-    streamListener.messageRead(new ByteArrayInputStream(new byte[]{}));
-    streamListener.closed(Status.OK, new Metadata());
+    streamListener
+        .messagesAvailable(new SingleMessageProducer(new ByteArrayInputStream(new byte[]{})));
+    streamListener.closed(Status.OK, PROCESSED, new Metadata());
     executor.release();
 
-    verify(callListener).onClose(statusArgumentCaptor.capture(), Matchers.isA(Metadata.class));
-    assertThat(statusArgumentCaptor.getValue().getCode()).isEqualTo(Status.Code.CANCELLED);
-    assertThat(statusArgumentCaptor.getValue().getCause()).isSameAs(failure);
-    verify(stream).cancel(statusArgumentCaptor.getValue());
-    assertStatusInStats(Status.Code.CANCELLED);
+    verify(callListener).onClose(statusArgumentCaptor.capture(),
+        ArgumentMatchers.isA(Metadata.class));
+    Status callListenerStatus = statusArgumentCaptor.getValue();
+    assertThat(callListenerStatus.getCode()).isEqualTo(Status.Code.CANCELLED);
+    assertThat(callListenerStatus.getCause()).isSameInstanceAs(failure);
+    verify(stream).cancel(same(callListenerStatus));
   }
 
   @Test
   public void exceptionInOnHeadersTakesPrecedenceOverServer() {
     DelayedExecutor executor = new DelayedExecutor();
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         executor,
-        CallOptions.DEFAULT,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor);
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
     call.start(callListener, new Metadata());
     verify(stream).start(listenerArgumentCaptor.capture());
     final ClientStreamListener streamListener = listenerArgumentCaptor.getValue();
@@ -242,26 +247,71 @@ public void exceptionInOnHeadersTakesPrecedenceOverServer() {
      * the call being counted as successful.
      */
     streamListener.headersRead(new Metadata());
-    streamListener.closed(Status.OK, new Metadata());
+    streamListener.closed(Status.OK, PROCESSED, new Metadata());
     executor.release();
 
-    verify(callListener).onClose(statusArgumentCaptor.capture(), Matchers.isA(Metadata.class));
-    assertThat(statusArgumentCaptor.getValue().getCode()).isEqualTo(Status.Code.CANCELLED);
-    assertThat(statusArgumentCaptor.getValue().getCause()).isSameAs(failure);
-    verify(stream).cancel(statusArgumentCaptor.getValue());
-    assertStatusInStats(Status.Code.CANCELLED);
+    verify(callListener).onClose(statusArgumentCaptor.capture(),
+        ArgumentMatchers.isA(Metadata.class));
+    Status callListenerStatus = statusArgumentCaptor.getValue();
+    assertThat(callListenerStatus.getCode()).isEqualTo(Status.Code.CANCELLED);
+    assertThat(callListenerStatus.getCause()).isSameInstanceAs(failure);
+    verify(stream).cancel(same(callListenerStatus));
+  }
+
+  @Test
+  public void exceptionInOnHeadersHasOnCloseQueuedLast() {
+    class PointOfNoReturnExecutor implements Executor {
+      boolean rejectNewRunnables;
+
+      @Override public void execute(Runnable command) {
+        assertThat(rejectNewRunnables).isFalse();
+        command.run();
+      }
+    }
+
+    final PointOfNoReturnExecutor executor = new PointOfNoReturnExecutor();
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
+        method,
+        executor,
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
+    callListener = new NoopClientCall.NoopClientCallListener<Void>() {
+      private final RuntimeException failure = new RuntimeException("bad");
+
+      @Override public void onHeaders(Metadata metadata) {
+        throw failure;
+      }
+
+      @Override public void onClose(Status status, Metadata metadata) {
+        verify(stream).cancel(same(status));
+        assertThat(status.getCode()).isEqualTo(Status.Code.CANCELLED);
+        assertThat(status.getCause()).isSameInstanceAs(failure);
+        // At the point onClose() is called the user may shut down the executor, so no further
+        // Runnables may be scheduled. The only thread-safe way of guaranteeing that is for
+        // onClose() to be queued last.
+        executor.rejectNewRunnables = true;
+      }
+    };
+    call.start(callListener, new Metadata());
+    verify(stream).start(listenerArgumentCaptor.capture());
+    final ClientStreamListener streamListener = listenerArgumentCaptor.getValue();
+
+    streamListener.headersRead(new Metadata());
+    streamListener.closed(Status.OK, PROCESSED, new Metadata());
   }
 
   @Test
   public void exceptionInOnReadyTakesPrecedenceOverServer() {
     DelayedExecutor executor = new DelayedExecutor();
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
-        method,
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
+        method.toBuilder().setType(MethodType.UNKNOWN).build(),
         executor,
-        CallOptions.DEFAULT,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor);
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
     call.start(callListener, new Metadata());
     verify(stream).start(listenerArgumentCaptor.capture());
     final ClientStreamListener streamListener = listenerArgumentCaptor.getValue();
@@ -276,48 +326,50 @@ public void exceptionInOnReadyTakesPrecedenceOverServer() {
      * the call being counted as successful.
      */
     streamListener.onReady();
-    streamListener.closed(Status.OK, new Metadata());
+    streamListener.closed(Status.OK, PROCESSED, new Metadata());
     executor.release();
 
-    verify(callListener).onClose(statusArgumentCaptor.capture(), Matchers.isA(Metadata.class));
-    assertThat(statusArgumentCaptor.getValue().getCode()).isEqualTo(Status.Code.CANCELLED);
-    assertThat(statusArgumentCaptor.getValue().getCause()).isSameAs(failure);
-    verify(stream).cancel(statusArgumentCaptor.getValue());
-    assertStatusInStats(Status.Code.CANCELLED);
+    verify(callListener).onClose(statusArgumentCaptor.capture(),
+        ArgumentMatchers.isA(Metadata.class));
+    Status callListenerStatus = statusArgumentCaptor.getValue();
+    assertThat(callListenerStatus.getCode()).isEqualTo(Status.Code.CANCELLED);
+    assertThat(callListenerStatus.getCause()).isSameInstanceAs(failure);
+    verify(stream).cancel(same(callListenerStatus));
   }
 
   @Test
   public void advertisedEncodingsAreSent() {
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
-        CallOptions.DEFAULT,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor)
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector)
             .setDecompressorRegistry(decompressorRegistry);
 
     call.start(callListener, new Metadata());
 
     ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
-    verify(transport).newStream(eq(method), metadataCaptor.capture(), same(CallOptions.DEFAULT),
-        same(statsTraceCtx));
+    verify(clientStreamProvider).newStream(
+        eq(method), same(baseCallOptions), metadataCaptor.capture(), any(Context.class));
     Metadata actual = metadataCaptor.getValue();
 
-    Set<String> acceptedEncodings =
-        ImmutableSet.copyOf(actual.getAll(GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY));
+    // there should only be one.
+    Set<String> acceptedEncodings = ImmutableSet.of(
+        new String(actual.get(GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY), GrpcUtil.US_ASCII));
     assertEquals(decompressorRegistry.getAdvertisedMessageEncodings(), acceptedEncodings);
   }
 
   @Test
   public void authorityPropagatedToStream() {
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
-        CallOptions.DEFAULT.withAuthority("overridden-authority"),
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor)
+        baseCallOptions.withAuthority("overridden-authority"),
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector)
             .setDecompressorRegistry(decompressorRegistry);
 
     call.start(callListener, new Metadata());
@@ -326,33 +378,75 @@ public void authorityPropagatedToStream() {
 
   @Test
   public void callOptionsPropagatedToTransport() {
-    final CallOptions callOptions = CallOptions.DEFAULT.withAuthority("dummy_value");
-    final ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    final CallOptions callOptions = baseCallOptions.withAuthority("dummy_value");
+    final ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
         callOptions,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor)
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector)
         .setDecompressorRegistry(decompressorRegistry);
     final Metadata metadata = new Metadata();
 
     call.start(callListener, metadata);
 
-    verify(transport).newStream(same(method), same(metadata), same(callOptions),
-        same(statsTraceCtx));
+    verify(clientStreamProvider).newStream(
+        same(method), same(callOptions), same(metadata), any(Context.class));
+  }
+
+  @Test
+  public void methodInfoDeadlinePropagatedToStream() {
+    ArgumentCaptor<CallOptions> callOptionsCaptor = ArgumentCaptor.forClass(CallOptions.class);
+    CallOptions callOptions = baseCallOptions.withDeadline(Deadline.after(2000, SECONDS));
+
+    // Case: config Deadline expires later than CallOptions Deadline
+    Map<String, ?> rawMethodConfig = ImmutableMap.of("timeout", "3000s");
+    MethodInfo methodInfo = new MethodInfo(rawMethodConfig, false, 0, 0);
+    callOptions = callOptions.withOption(MethodInfo.KEY, methodInfo);
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
+        method,
+        MoreExecutors.directExecutor(),
+        callOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector)
+        .setDecompressorRegistry(decompressorRegistry);
+    call.start(callListener, new Metadata());
+    verify(clientStreamProvider).newStream(
+        same(method), callOptionsCaptor.capture(), any(Metadata.class), any(Context.class));
+    Deadline actualDeadline = callOptionsCaptor.getValue().getDeadline();
+    assertThat(actualDeadline).isLessThan(Deadline.after(2001, SECONDS));
+
+    // Case: config Deadline expires earlier than CallOptions Deadline
+    rawMethodConfig = ImmutableMap.of("timeout", "1000s");
+    methodInfo = new MethodInfo(rawMethodConfig, false, 0, 0);
+    callOptions = callOptions.withOption(MethodInfo.KEY, methodInfo);
+    call = new ClientCallImpl<>(
+        method,
+        MoreExecutors.directExecutor(),
+        callOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector)
+        .setDecompressorRegistry(decompressorRegistry);
+    call.start(callListener, new Metadata());
+    verify(clientStreamProvider, times(2)).newStream(
+        same(method), callOptionsCaptor.capture(), any(Metadata.class), any(Context.class));
+    actualDeadline = callOptionsCaptor.getValue().getDeadline();
+    assertThat(actualDeadline).isLessThan(Deadline.after(1001, SECONDS));
   }
 
   @Test
   public void authorityNotPropagatedToStream() {
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
         // Don't provide an authority
-        CallOptions.DEFAULT,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor)
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector)
             .setDecompressorRegistry(decompressorRegistry);
 
     call.start(callListener, new Metadata());
@@ -363,7 +457,7 @@ public void authorityNotPropagatedToStream() {
   public void prepareHeaders_userAgentIgnored() {
     Metadata m = new Metadata();
     m.put(GrpcUtil.USER_AGENT_KEY, "batmobile");
-    ClientCallImpl.prepareHeaders(m, decompressorRegistry, Codec.Identity.NONE, statsTraceCtx);
+    ClientCallImpl.prepareHeaders(m, decompressorRegistry, Codec.Identity.NONE, false);
 
     // User Agent is removed and set by the transport
     assertThat(m.get(GrpcUtil.USER_AGENT_KEY)).isNotNull();
@@ -372,13 +466,22 @@ public void prepareHeaders_userAgentIgnored() {
   @Test
   public void prepareHeaders_ignoreIdentityEncoding() {
     Metadata m = new Metadata();
-    ClientCallImpl.prepareHeaders(m, decompressorRegistry, Codec.Identity.NONE, statsTraceCtx);
+    ClientCallImpl.prepareHeaders(m, decompressorRegistry, Codec.Identity.NONE, false);
 
     assertNull(m.get(GrpcUtil.MESSAGE_ENCODING_KEY));
   }
 
   @Test
-  public void prepareHeaders_acceptedEncodingsAdded() {
+  public void prepareHeaders_ignoreContentLength() {
+    Metadata m = new Metadata();
+    m.put(GrpcUtil.CONTENT_LENGTH_KEY, "123");
+    ClientCallImpl.prepareHeaders(m, decompressorRegistry, Codec.Identity.NONE, false);
+
+    assertNull(m.get(GrpcUtil.CONTENT_LENGTH_KEY));
+  }
+
+  @Test
+  public void prepareHeaders_acceptedMessageEncodingsAdded() {
     Metadata m = new Metadata();
     DecompressorRegistry customRegistry = DecompressorRegistry.emptyInstance()
         .with(new Decompressor() {
@@ -415,54 +518,121 @@ public InputStream decompress(InputStream is) throws IOException {
           }
         }, false); // not advertised
 
-    ClientCallImpl.prepareHeaders(m, customRegistry, Codec.Identity.NONE, statsTraceCtx);
+    ClientCallImpl.prepareHeaders(m, customRegistry, Codec.Identity.NONE, false);
 
-    Iterable<String> acceptedEncodings =
-        ACCEPT_ENCODING_SPLITTER.split(m.get(GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY));
+    Iterable<String> acceptedEncodings = ACCEPT_ENCODING_SPLITTER.split(
+        new String(m.get(GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY), GrpcUtil.US_ASCII));
 
     // Order may be different, since decoder priorities have not yet been implemented.
     assertEquals(ImmutableSet.of("b", "a"), ImmutableSet.copyOf(acceptedEncodings));
   }
 
   @Test
-  public void prepareHeaders_removeReservedHeaders() {
+  public void prepareHeaders_noAcceptedContentEncodingsWithoutFullStreamDecompressionEnabled() {
     Metadata m = new Metadata();
-    m.put(GrpcUtil.MESSAGE_ENCODING_KEY, "gzip");
-    m.put(GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY, "gzip");
+    ClientCallImpl.prepareHeaders(m, decompressorRegistry, Codec.Identity.NONE, false);
 
-    ClientCallImpl.prepareHeaders(m, DecompressorRegistry.emptyInstance(), Codec.Identity.NONE,
-        statsTraceCtx);
+    assertNull(m.get(GrpcUtil.CONTENT_ACCEPT_ENCODING_KEY));
+  }
 
-    assertNull(m.get(GrpcUtil.MESSAGE_ENCODING_KEY));
-    assertNull(m.get(GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY));
+  @Test
+  public void prepareHeaders_acceptedMessageAndContentEncodingsAdded() {
+    Metadata m = new Metadata();
+    DecompressorRegistry customRegistry =
+        DecompressorRegistry.emptyInstance()
+            .with(
+                new Decompressor() {
+                  @Override
+                  public String getMessageEncoding() {
+                    return "a";
+                  }
+
+                  @Override
+                  public InputStream decompress(InputStream is) throws IOException {
+                    return null;
+                  }
+                },
+                true)
+            .with(
+                new Decompressor() {
+                  @Override
+                  public String getMessageEncoding() {
+                    return "b";
+                  }
+
+                  @Override
+                  public InputStream decompress(InputStream is) throws IOException {
+                    return null;
+                  }
+                },
+                true)
+            .with(
+                new Decompressor() {
+                  @Override
+                  public String getMessageEncoding() {
+                    return "c";
+                  }
+
+                  @Override
+                  public InputStream decompress(InputStream is) throws IOException {
+                    return null;
+                  }
+                },
+                false); // not advertised
+
+    ClientCallImpl.prepareHeaders(m, customRegistry, Codec.Identity.NONE, true);
+
+    Iterable<String> acceptedMessageEncodings =
+        ACCEPT_ENCODING_SPLITTER.split(
+            new String(m.get(GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY), GrpcUtil.US_ASCII));
+    // Order may be different, since decoder priorities have not yet been implemented.
+    assertEquals(ImmutableSet.of("b", "a"), ImmutableSet.copyOf(acceptedMessageEncodings));
+
+    Iterable<String> acceptedContentEncodings =
+        ACCEPT_ENCODING_SPLITTER.split(
+            new String(m.get(GrpcUtil.CONTENT_ACCEPT_ENCODING_KEY), GrpcUtil.US_ASCII));
+    assertEquals(
+        ImmutableSet.of("gzip"), ImmutableSet.copyOf(acceptedContentEncodings));
   }
 
   @Test
-  public void prepareHeaders_statsCtxAdded() {
+  public void prepareHeaders_removeReservedHeaders() {
     Metadata m = new Metadata();
-    ClientCallImpl.prepareHeaders(m, decompressorRegistry, Codec.Identity.NONE, statsTraceCtx);
-    assertEquals(parentStatsContext, m.get(statsTraceCtx.getStatsHeader()));
+    m.put(GrpcUtil.MESSAGE_ENCODING_KEY, "gzip");
+    m.put(GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY, "gzip".getBytes(GrpcUtil.US_ASCII));
+    m.put(GrpcUtil.CONTENT_ENCODING_KEY, "gzip");
+    m.put(GrpcUtil.CONTENT_ACCEPT_ENCODING_KEY, "gzip".getBytes(GrpcUtil.US_ASCII));
+
+    ClientCallImpl.prepareHeaders(
+        m, DecompressorRegistry.emptyInstance(), Codec.Identity.NONE, false);
+
+    assertNull(m.get(GrpcUtil.MESSAGE_ENCODING_KEY));
+    assertNull(m.get(GrpcUtil.MESSAGE_ACCEPT_ENCODING_KEY));
+    assertNull(m.get(GrpcUtil.CONTENT_ENCODING_KEY));
+    assertNull(m.get(GrpcUtil.CONTENT_ACCEPT_ENCODING_KEY));
   }
 
   @Test
   public void callerContextPropagatedToListener() throws Exception {
     // Attach the context which is recorded when the call is created
     final Context.Key<String> testKey = Context.key("testing");
-    Context.current().withValue(testKey, "testValue").attach();
+    Context context = Context.current().withValue(testKey, "testValue");
+    Context previous = context.attach();
 
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
-        method,
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
+        method.toBuilder().setType(MethodType.UNKNOWN).build(),
         new SerializingExecutor(Executors.newSingleThreadExecutor()),
-        CallOptions.DEFAULT,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor)
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector)
             .setDecompressorRegistry(decompressorRegistry);
 
-    Context.ROOT.attach();
+    context.detach(previous);
 
     // Override the value after creating the call, this should not be seen by callbacks
-    Context.current().withValue(testKey, "badValue").attach();
+    context = Context.current().withValue(testKey, "badValue");
+    previous = context.attach();
 
     final AtomicBoolean onHeadersCalled = new AtomicBoolean();
     final AtomicBoolean onMessageCalled = new AtomicBoolean();
@@ -502,13 +672,15 @@ private void checkContext() {
       }
     }, new Metadata());
 
+    context.detach(previous);
+
     verify(stream).start(listenerArgumentCaptor.capture());
     ClientStreamListener listener = listenerArgumentCaptor.getValue();
     listener.onReady();
     listener.headersRead(new Metadata());
-    listener.messageRead(new ByteArrayInputStream(new byte[0]));
-    listener.messageRead(new ByteArrayInputStream(new byte[0]));
-    listener.closed(Status.OK, new Metadata());
+    listener.messagesAvailable(new SingleMessageProducer(new ByteArrayInputStream(new byte[0])));
+    listener.messagesAvailable(new SingleMessageProducer(new ByteArrayInputStream(new byte[0])));
+    listener.closed(Status.OK, PROCESSED, new Metadata());
 
     assertTrue(latch.await(5, TimeUnit.SECONDS));
 
@@ -524,16 +696,16 @@ public void contextCancellationCancelsStream() throws Exception {
     Context.CancellableContext cancellableContext = Context.current().withCancellation();
     Context previous = cancellableContext.attach();
 
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         new SerializingExecutor(Executors.newSingleThreadExecutor()),
-        CallOptions.DEFAULT,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor)
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector)
             .setDecompressorRegistry(decompressorRegistry);
 
-    previous.attach();
+    cancellableContext.detach(previous);
 
     call.start(callListener, new Metadata());
 
@@ -541,9 +713,8 @@ public void contextCancellationCancelsStream() throws Exception {
     cancellableContext.cancel(t);
 
     verify(stream, times(1)).cancel(statusArgumentCaptor.capture());
-
-    verify(stream, times(1)).cancel(statusCaptor.capture());
-    assertEquals(Status.Code.CANCELLED, statusCaptor.getValue().getCode());
+    Status streamStatus = statusArgumentCaptor.getValue();
+    assertEquals(Status.Code.CANCELLED, streamStatus.getCode());
   }
 
   @Test
@@ -554,16 +725,16 @@ public void contextAlreadyCancelledNotifiesImmediately() throws Exception {
     cancellableContext.cancel(cause);
     Context previous = cancellableContext.attach();
 
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         new SerializingExecutor(Executors.newSingleThreadExecutor()),
-        CallOptions.DEFAULT,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor)
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector)
         .setDecompressorRegistry(decompressorRegistry);
 
-    previous.attach();
+    cancellableContext.detach(previous);
 
     final SettableFuture<Status> statusFuture = SettableFuture.create();
     call.start(new ClientCall.Listener<Void>() {
@@ -577,7 +748,6 @@ public void onClose(Status status, Metadata trailers) {
     Status status = statusFuture.get(5, TimeUnit.SECONDS);
     assertEquals(Status.Code.CANCELLED, status.getCode());
     assertSame(cause, status.getCause());
-    assertStatusInStats(Status.Code.CANCELLED);
 
     // Following operations should be no-op.
     call.request(1);
@@ -585,7 +755,7 @@ public void onClose(Status status, Metadata trailers) {
     call.halfClose();
 
     // Stream should never be created.
-    verifyZeroInteractions(transport);
+    verifyNoInteractions(clientStreamProvider);
 
     try {
       call.sendMessage(null);
@@ -597,167 +767,229 @@ public void onClose(Status status, Metadata trailers) {
 
   @Test
   public void deadlineExceededBeforeCallStarted() {
-    CallOptions callOptions = CallOptions.DEFAULT.withDeadlineAfter(0, TimeUnit.SECONDS);
+    deadlineExeedeed(baseCallOptions.withDeadlineAfter(0, TimeUnit.SECONDS),
+        "Name resolution delay 0.000000000 seconds.");
+  }
+
+  @Test
+  public void deadlineExceededBeforeCallStartedDelayed() {
+    deadlineExeedeed(baseCallOptions.withDeadlineAfter(0, TimeUnit.SECONDS)
+            .withOption(NAME_RESOLUTION_DELAYED, 1200000000L),
+        "Name resolution delay 1.200000000 seconds.");
+  }
+
+  private void deadlineExeedeed(CallOptions callOptions, String descriptionSuffix) {
     fakeClock.forwardTime(System.nanoTime(), TimeUnit.NANOSECONDS);
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         new SerializingExecutor(Executors.newSingleThreadExecutor()),
         callOptions,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor)
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector)
             .setDecompressorRegistry(decompressorRegistry);
     call.start(callListener, new Metadata());
-    verify(transport, times(0)).newStream(any(MethodDescriptor.class), any(Metadata.class));
+    verify(streamTracerFactory).newClientStreamTracer(any(StreamInfo.class), any(Metadata.class));
+    verify(clientStreamProvider, never())
+        .newStream(
+            (MethodDescriptor<?, ?>) any(MethodDescriptor.class),
+            any(CallOptions.class),
+            any(Metadata.class),
+            any(Context.class));
     verify(callListener, timeout(1000)).onClose(statusCaptor.capture(), any(Metadata.class));
     assertEquals(Status.Code.DEADLINE_EXCEEDED, statusCaptor.getValue().getCode());
-    assertStatusInStats(Status.Code.DEADLINE_EXCEEDED);
-    verifyZeroInteractions(provider);
+    String deadlineExceedDescription = statusCaptor.getValue().getDescription();
+    assertThat(deadlineExceedDescription)
+        .startsWith("ClientCall started after CallOptions deadline was exceeded");
+    assertThat(deadlineExceedDescription).endsWith(descriptionSuffix);
+    verifyNoInteractions(clientStreamProvider);
   }
 
   @Test
-  public void contextDeadlineShouldBePropagatedInMetadata() {
-    long deadlineNanos = TimeUnit.SECONDS.toNanos(1);
-    Context context = Context.current().withDeadlineAfter(deadlineNanos, TimeUnit.NANOSECONDS,
-        deadlineCancellationExecutor);
-    context.attach();
+  public void contextDeadlineShouldBePropagatedToStream() {
+    Deadline deadline = Deadline.after(1000, TimeUnit.MILLISECONDS);
+    Context context = Context.current().withDeadline(deadline, deadlineCancellationExecutor);
+    Context origContext = context.attach();
 
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
-        CallOptions.DEFAULT,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor);
-
-    Metadata headers = new Metadata();
-
-    call.start(callListener, headers);
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
+    call.start(callListener, new Metadata());
 
-    assertTrue(headers.containsKey(GrpcUtil.TIMEOUT_KEY));
-    Long timeout = headers.get(GrpcUtil.TIMEOUT_KEY);
-    assertNotNull(timeout);
+    context.detach(origContext);
 
-    long deltaNanos = TimeUnit.MILLISECONDS.toNanos(400);
-    assertTimeoutBetween(timeout, deadlineNanos - deltaNanos, deadlineNanos);
+    verify(stream).setDeadline(eq(deadline));
   }
 
   @Test
-  public void contextDeadlineShouldOverrideLargerMetadataTimeout() {
-    long deadlineNanos = TimeUnit.SECONDS.toNanos(1);
-    Context context = Context.current().withDeadlineAfter(deadlineNanos, TimeUnit.NANOSECONDS,
-        deadlineCancellationExecutor);
-    context.attach();
+  public void contextDeadlineShouldOverrideLargerCallOptionsDeadline() {
+    Deadline deadline = Deadline.after(1000, TimeUnit.MILLISECONDS);
+    Context context = Context.current().withDeadline(deadline, deadlineCancellationExecutor);
+    Context origContext = context.attach();
 
-    CallOptions callOpts = CallOptions.DEFAULT.withDeadlineAfter(2, TimeUnit.SECONDS);
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    CallOptions callOpts = baseCallOptions.withDeadlineAfter(2000, TimeUnit.MILLISECONDS);
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
         callOpts,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor);
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
+    call.start(callListener, new Metadata());
 
-    Metadata headers = new Metadata();
+    context.detach(origContext);
 
-    call.start(callListener, headers);
+    verify(stream).setDeadline(eq(deadline));
+  }
 
-    assertTrue(headers.containsKey(GrpcUtil.TIMEOUT_KEY));
-    Long timeout = headers.get(GrpcUtil.TIMEOUT_KEY);
-    assertNotNull(timeout);
+  @Test
+  public void contextDeadlineShouldNotOverrideSmallerCallOptionsDeadline() {
+    Context context = Context.current()
+        .withDeadlineAfter(2000, TimeUnit.MILLISECONDS, deadlineCancellationExecutor);
+    Deadline deadline = Deadline.after(1000, TimeUnit.MILLISECONDS);
+    Context origContext = context.attach();
+
+    CallOptions callOpts = baseCallOptions.withDeadline(deadline)
+        .withOption(NAME_RESOLUTION_DELAYED, 1200000000L);
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
+        method,
+        MoreExecutors.directExecutor(),
+        callOpts,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
+    call.start(callListener, new Metadata());
 
-    long deltaNanos = TimeUnit.MILLISECONDS.toNanos(400);
-    assertTimeoutBetween(timeout, deadlineNanos - deltaNanos, deadlineNanos);
+    context.detach(origContext);
+
+    verify(stream).setDeadline(eq(deadline));
+
+    fakeClock.forwardNanos(TimeUnit.MILLISECONDS.toNanos(1000));
+    verify(stream, timeout(1000)).cancel(statusCaptor.capture());
+    String deadlineExceedDescription = statusCaptor.getValue().getDescription();
+    assertThat(deadlineExceedDescription)
+        .contains("Name resolution delay 1.200000000 seconds.");
   }
 
   @Test
-  public void contextDeadlineShouldNotOverrideSmallerMetadataTimeout() {
-    long deadlineNanos = TimeUnit.SECONDS.toNanos(2);
-    Context context = Context.current().withDeadlineAfter(deadlineNanos, TimeUnit.NANOSECONDS,
-        deadlineCancellationExecutor);
-    context.attach();
-
-    CallOptions callOpts = CallOptions.DEFAULT.withDeadlineAfter(1, TimeUnit.SECONDS);
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+  public void callOptionsDeadlineShouldBePropagatedToStream() {
+    Deadline deadline = Deadline.after(1000, TimeUnit.MILLISECONDS);
+    CallOptions callOpts = baseCallOptions.withDeadline(deadline);
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
         callOpts,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor);
-
-    Metadata headers = new Metadata();
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
+    call.start(callListener, new Metadata());
 
-    call.start(callListener, headers);
+    verify(stream).setDeadline(eq(deadline));
+  }
 
-    assertTrue(headers.containsKey(GrpcUtil.TIMEOUT_KEY));
-    Long timeout = headers.get(GrpcUtil.TIMEOUT_KEY);
-    assertNotNull(timeout);
+  @Test
+  public void noDeadlineShouldBePropagatedToStream() {
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
+        method,
+        MoreExecutors.directExecutor(),
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
+    call.start(callListener, new Metadata());
 
-    long callOptsNanos = TimeUnit.SECONDS.toNanos(1);
-    long deltaNanos = TimeUnit.MILLISECONDS.toNanos(400);
-    assertTimeoutBetween(timeout, callOptsNanos - deltaNanos, callOptsNanos);
+    verify(stream, never()).setDeadline(any(Deadline.class));
   }
 
   @Test
   public void expiredDeadlineCancelsStream_CallOptions() {
     fakeClock.forwardTime(System.nanoTime(), TimeUnit.NANOSECONDS);
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    // The deadline needs to be a number large enough to get encompass the call to start, otherwise
+    // the scheduled cancellation won't be created, and the call will fail early.
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
-        CallOptions.DEFAULT.withDeadline(Deadline.after(1000, TimeUnit.MILLISECONDS)),
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor);
+        baseCallOptions.withDeadline(
+            Deadline.after(1, TimeUnit.SECONDS, fakeClock.getDeadlineTicker())),
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
 
     call.start(callListener, new Metadata());
 
-    fakeClock.forwardMillis(1001);
+    fakeClock.forwardNanos(TimeUnit.SECONDS.toNanos(1) + 1);
 
     verify(stream, times(1)).cancel(statusCaptor.capture());
     assertEquals(Status.Code.DEADLINE_EXCEEDED, statusCaptor.getValue().getCode());
+    assertThat(statusCaptor.getValue().getDescription())
+        .matches("CallOptions deadline exceeded after [0-9]+\\.[0-9]+s. "
+            + "Name resolution delay 0.000000000 seconds. \\[remote_addr=127\\.0\\.0\\.1:443\\]");
   }
 
   @Test
   public void expiredDeadlineCancelsStream_Context() {
     fakeClock.forwardTime(System.nanoTime(), TimeUnit.NANOSECONDS);
 
-    Context.current()
-        .withDeadlineAfter(1000, TimeUnit.MILLISECONDS, deadlineCancellationExecutor)
-        .attach();
+    Context context = Context.current()
+        .withDeadlineAfter(1, TimeUnit.SECONDS, deadlineCancellationExecutor);
+    Context origContext = context.attach();
 
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
-        CallOptions.DEFAULT,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor);
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
+
+    context.detach(origContext);
 
     call.start(callListener, new Metadata());
 
-    fakeClock.forwardMillis(TimeUnit.SECONDS.toMillis(1001));
+    fakeClock.forwardNanos(TimeUnit.SECONDS.toNanos(1) + 1);
 
     verify(stream, times(1)).cancel(statusCaptor.capture());
     assertEquals(Status.Code.DEADLINE_EXCEEDED, statusCaptor.getValue().getCode());
+    assertThat(statusCaptor.getValue().getDescription())
+        .matches("Context deadline exceeded after [0-9]+\\.[0-9]+s. "
+            + "Name resolution delay 0.000000000 seconds. \\[remote_addr=127\\.0\\.0\\.1:443\\]");
+  }
+
+  @Test
+  public void cancelWithoutStart() {
+    fakeClock.forwardTime(System.nanoTime(), TimeUnit.NANOSECONDS);
+
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
+        method,
+        MoreExecutors.directExecutor(),
+        baseCallOptions.withDeadline(Deadline.after(1, TimeUnit.SECONDS)),
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
+    // Nothing happens as a result, but it shouldn't throw
+    call.cancel("canceled", null);
   }
 
   @Test
   public void streamCancelAbortsDeadlineTimer() {
     fakeClock.forwardTime(System.nanoTime(), TimeUnit.NANOSECONDS);
 
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
-        CallOptions.DEFAULT.withDeadline(Deadline.after(1000, TimeUnit.MILLISECONDS)),
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor);
+        baseCallOptions.withDeadline(Deadline.after(1, TimeUnit.SECONDS)),
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
     call.start(callListener, new Metadata());
     call.cancel("canceled", null);
 
     // Run the deadline timer, which should have been cancelled by the previous call to cancel()
-    fakeClock.forwardMillis(1001);
+    fakeClock.forwardNanos(TimeUnit.SECONDS.toNanos(1) + 1);
 
     verify(stream, times(1)).cancel(statusCaptor.capture());
 
@@ -770,13 +1002,13 @@ public void streamCancelAbortsDeadlineTimer() {
    */
   @Test
   public void timeoutShouldNotBeSet() {
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
-        CallOptions.DEFAULT,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor);
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
 
     Metadata headers = new Metadata();
 
@@ -787,13 +1019,13 @@ public void timeoutShouldNotBeSet() {
 
   @Test
   public void cancelInOnMessageShouldInvokeStreamCancel() throws Exception {
-    final ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+    final ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         MoreExecutors.directExecutor(),
-        CallOptions.DEFAULT,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor);
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
     final Exception cause = new Exception();
     ClientCall.Listener<Void> callListener =
         new ClientCall.Listener<Void>() {
@@ -811,7 +1043,8 @@ public void onMessage(Void message) {
     ClientStreamListener streamListener = listenerArgumentCaptor.getValue();
     streamListener.onReady();
     streamListener.headersRead(new Metadata());
-    streamListener.messageRead(new ByteArrayInputStream(new byte[0]));
+    streamListener
+        .messagesAvailable(new SingleMessageProducer(new ByteArrayInputStream(new byte[0])));
     verify(stream).cancel(statusCaptor.capture());
     Status status = statusCaptor.getValue();
     assertEquals(Status.CANCELLED.getCode(), status.getCode());
@@ -819,17 +1052,35 @@ public void onMessage(Void message) {
     assertSame(cause, status.getCause());
   }
 
+  @Test
+  public void halfClosedShouldNotBeReady() {
+    when(stream.isReady()).thenReturn(true);
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
+        method,
+        MoreExecutors.directExecutor(),
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
+
+    call.start(callListener, new Metadata());
+    assertThat(call.isReady()).isTrue();
+
+    call.halfClose();
+    assertThat(call.isReady()).isFalse();
+  }
+
   @Test
   public void startAddsMaxSize() {
     CallOptions callOptions =
-        CallOptions.DEFAULT.withMaxInboundMessageSize(1).withMaxOutboundMessageSize(2);
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
+        baseCallOptions.withMaxInboundMessageSize(1).withMaxOutboundMessageSize(2);
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
         method,
         new SerializingExecutor(Executors.newSingleThreadExecutor()),
         callOptions,
-        statsTraceCtx,
-        provider,
-        deadlineCancellationExecutor)
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector)
             .setDecompressorRegistry(decompressorRegistry);
 
     call.start(callListener, new Metadata());
@@ -840,11 +1091,11 @@ public void startAddsMaxSize() {
 
   @Test
   public void getAttributes() {
-    ClientCallImpl<Void, Void> call = new ClientCallImpl<Void, Void>(
-        method, MoreExecutors.directExecutor(), CallOptions.DEFAULT, statsTraceCtx, provider,
-        deadlineCancellationExecutor);
-    Attributes attrs =
-        Attributes.newBuilder().set(Key.<String>of("fake key"), "fake value").build();
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
+        method, MoreExecutors.directExecutor(), baseCallOptions, clientStreamProvider,
+        deadlineCancellationExecutor, channelCallTracer, configSelector);
+    Attributes attrs = Attributes.newBuilder().set(
+        Attributes.Key.<String>create("fake key"), "fake value").build();
     when(stream.getAttributes()).thenReturn(attrs);
 
     assertNotEquals(attrs, call.getAttributes());
@@ -854,21 +1105,34 @@ public void getAttributes() {
     assertEquals(attrs, call.getAttributes());
   }
 
-  private void assertStatusInStats(Status.Code statusCode) {
-    StatsTestUtils.MetricsRecord record = statsCtxFactory.pollRecord();
-    assertNotNull(record);
-    TagValue statusTag = record.tags.get(RpcConstants.RPC_STATUS);
-    assertNotNull(statusTag);
-    assertEquals(statusCode.toString(), statusTag.toString());
-  }
+  @Test
+  public void onCloseExceptionCaughtAndLogged() {
+    DelayedExecutor executor = new DelayedExecutor();
+    ClientCallImpl<Void, Void> call = new ClientCallImpl<>(
+        method,
+        executor,
+        baseCallOptions,
+        clientStreamProvider,
+        deadlineCancellationExecutor,
+        channelCallTracer, configSelector);
 
-  private static void assertTimeoutBetween(long timeout, long from, long to) {
-    assertTrue("timeout: " + timeout + " ns", timeout <= to);
-    assertTrue("timeout: " + timeout + " ns", timeout >= from);
+    call.start(callListener, new Metadata());
+    verify(stream).start(listenerArgumentCaptor.capture());
+    final ClientStreamListener streamListener = listenerArgumentCaptor.getValue();
+    streamListener.headersRead(new Metadata());
+
+    doThrow(new RuntimeException("Exception thrown by onClose() in ClientCall")).when(callListener)
+        .onClose(any(Status.class), any(Metadata.class));
+
+    Status status = Status.RESOURCE_EXHAUSTED.withDescription("simulated");
+    streamListener.closed(status, PROCESSED, new Metadata());
+    executor.release();
+
+    verify(callListener).onClose(same(status), any(Metadata.class));
   }
 
   private static final class DelayedExecutor implements Executor {
-    private final BlockingQueue<Runnable> commands = new LinkedBlockingQueue<Runnable>();
+    private final BlockingQueue<Runnable> commands = new LinkedBlockingQueue<>();
 
     @Override
     public void execute(Runnable command) {
@@ -882,4 +1146,3 @@ void release() {
     }
   }
 }
-
diff --git a/core/src/test/java/io/grpc/internal/ClientTransportFactoryTest.java b/core/src/test/java/io/grpc/internal/ClientTransportFactoryTest.java
new file mode 100644
index 00000000000..5ca9b7c62a5
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ClientTransportFactoryTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.testing.EqualsTester;
+import io.grpc.Attributes;
+import io.grpc.HttpConnectProxiedSocketAddress;
+import io.grpc.internal.ClientTransportFactory.ClientTransportOptions;
+import java.net.InetSocketAddress;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class ClientTransportFactoryTest {
+  private String authority = "testing123";
+  private Attributes eagAttributes =
+      Attributes.newBuilder().set(Attributes.Key.create("fake key"), "fake value").build();
+  private String userAgent = "best-ua/3.14";
+  private HttpConnectProxiedSocketAddress proxySocketAddress =
+      HttpConnectProxiedSocketAddress.newBuilder()
+      .setTargetAddress(InetSocketAddress.createUnresolved("localhost", 100))
+      .setProxyAddress(new InetSocketAddress(0))
+      .build();
+
+  @Test
+  public void clientTransportOptions_init_checkNotNulls() {
+    ClientTransportOptions cto = new ClientTransportOptions();
+    assertThat(cto.getAuthority()).isNotNull();
+    assertThat(cto.getEagAttributes()).isEqualTo(Attributes.EMPTY);
+  }
+
+  @Test
+  public void clientTransportOptions_getsMatchSets() {
+    ClientTransportOptions cto = new ClientTransportOptions()
+        .setAuthority(authority)
+        .setEagAttributes(eagAttributes)
+        .setUserAgent(userAgent)
+        .setHttpConnectProxiedSocketAddress(proxySocketAddress);
+    assertThat(cto.getAuthority()).isEqualTo(authority);
+    assertThat(cto.getEagAttributes()).isEqualTo(eagAttributes);
+    assertThat(cto.getUserAgent()).isEqualTo(userAgent);
+    assertThat(cto.getHttpConnectProxiedSocketAddress()).isSameInstanceAs(proxySocketAddress);
+  }
+
+  @Test
+  public void clientTransportOptions_equals() {
+    new EqualsTester()
+        .addEqualityGroup(new ClientTransportOptions())
+        .addEqualityGroup(
+            new ClientTransportOptions()
+              .setAuthority(authority),
+            new ClientTransportOptions()
+              .setAuthority(authority)
+              .setEagAttributes(Attributes.EMPTY))
+        .addEqualityGroup(
+            new ClientTransportOptions()
+              .setAuthority(authority)
+              .setEagAttributes(eagAttributes))
+        .addEqualityGroup(
+            new ClientTransportOptions()
+              .setAuthority(authority)
+              .setEagAttributes(eagAttributes)
+              .setUserAgent(userAgent))
+        .addEqualityGroup(
+            new ClientTransportOptions()
+              .setAuthority(authority)
+              .setEagAttributes(eagAttributes)
+              .setUserAgent(userAgent)
+              .setHttpConnectProxiedSocketAddress(proxySocketAddress),
+            new ClientTransportOptions()
+              .setAuthority(authority)
+              .setEagAttributes(eagAttributes)
+              .setUserAgent(userAgent)
+              .setHttpConnectProxiedSocketAddress(proxySocketAddress))
+        .testEquals();
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/CompositeReadableBufferTest.java b/core/src/test/java/io/grpc/internal/CompositeReadableBufferTest.java
index 3aa6c9b3a4c..749b71d681e 100644
--- a/core/src/test/java/io/grpc/internal/CompositeReadableBufferTest.java
+++ b/core/src/test/java/io/grpc/internal/CompositeReadableBufferTest.java
@@ -1,44 +1,34 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
-import static com.google.common.base.Charsets.UTF_8;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
-import java.nio.ByteBuffer;
+import java.nio.InvalidMarkException;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -83,6 +73,16 @@ public void readUnsignedByteShouldSucceed() {
     assertEquals(0, composite.readableBytes());
   }
 
+  @Test
+  public void readUnsignedByteShouldSkipZeroLengthBuffer() {
+    composite = new CompositeReadableBuffer();
+    composite.addBuffer(ReadableBuffers.wrap(new byte[0]));
+    byte[] in = {1};
+    composite.addBuffer(ReadableBuffers.wrap(in));
+    assertEquals(1, composite.readUnsignedByte());
+    assertEquals(0, composite.readableBytes());
+  }
+
   @Test
   public void skipBytesShouldSucceed() {
     int remaining = EXPECTED_VALUE.length();
@@ -120,42 +120,148 @@ public void readByteArrayShouldSucceed() {
   }
 
   @Test
-  public void readByteBufferShouldSucceed() {
-    ByteBuffer byteBuffer = ByteBuffer.allocate(EXPECTED_VALUE.length());
+  public void readStreamShouldSucceed() throws IOException {
+    ByteArrayOutputStream bos = new ByteArrayOutputStream();
     int remaining = EXPECTED_VALUE.length();
 
-    byteBuffer.limit(1);
-    composite.readBytes(byteBuffer);
+    composite.readBytes(bos, 1);
     remaining--;
     assertEquals(remaining, composite.readableBytes());
 
-    byteBuffer.limit(byteBuffer.limit() + 5);
-    composite.readBytes(byteBuffer);
+    composite.readBytes(bos, 5);
     remaining -= 5;
     assertEquals(remaining, composite.readableBytes());
 
-    byteBuffer.limit(byteBuffer.limit() + remaining);
-    composite.readBytes(byteBuffer);
+    composite.readBytes(bos, remaining);
     assertEquals(0, composite.readableBytes());
-    assertEquals(EXPECTED_VALUE, new String(byteBuffer.array(), UTF_8));
+    assertEquals(EXPECTED_VALUE, new String(bos.toByteArray(), UTF_8));
   }
 
   @Test
-  public void readStreamShouldSucceed() throws IOException {
-    ByteArrayOutputStream bos = new ByteArrayOutputStream();
-    int remaining = EXPECTED_VALUE.length();
+  public void markSupportedOnlyAllComponentsSupportMark() {
+    composite = new CompositeReadableBuffer();
+    ReadableBuffer buffer1 = mock(ReadableBuffer.class);
+    ReadableBuffer buffer2 = mock(ReadableBuffer.class);
+    ReadableBuffer buffer3 = mock(ReadableBuffer.class);
+    when(buffer1.markSupported()).thenReturn(true);
+    when(buffer2.markSupported()).thenReturn(true);
+    when(buffer3.markSupported()).thenReturn(false);
+    composite.addBuffer(buffer1);
+    assertTrue(composite.markSupported());
+    composite.addBuffer(buffer2);
+    assertTrue(composite.markSupported());
+    composite.addBuffer(buffer3);
+    assertFalse(composite.markSupported());
+  }
 
-    composite.readBytes(bos, 1);
-    remaining--;
+  @Test
+  public void resetUnmarkedShouldThrow() {
+    try {
+      composite.reset();
+      fail();
+    } catch (InvalidMarkException expected) {
+    }
+  }
+
+  @Test
+  public void markAndResetWithSkipBytesShouldSucceed() {
+    composite.mark();
+    composite.skipBytes(EXPECTED_VALUE.length() / 2);
+    composite.reset();
+    assertEquals(EXPECTED_VALUE.length(), composite.readableBytes());
+  }
+
+  @Test
+  public void markAndResetWithReadUnsignedByteShouldSucceed() {
+    composite.readUnsignedByte();
+    composite.mark();
+    int b = composite.readUnsignedByte();
+    composite.reset();
+    assertEquals(EXPECTED_VALUE.length() - 1, composite.readableBytes());
+    assertEquals(b, composite.readUnsignedByte());
+  }
+
+  @Test
+  public void markAndResetWithReadByteArrayShouldSucceed() {
+    composite.mark();
+    byte[] first = new byte[EXPECTED_VALUE.length()];
+    composite.readBytes(first, 0, EXPECTED_VALUE.length());
+    composite.reset();
+    assertEquals(EXPECTED_VALUE.length(), composite.readableBytes());
+    byte[] second = new byte[EXPECTED_VALUE.length()];
+    composite.readBytes(second, 0, EXPECTED_VALUE.length());
+    assertArrayEquals(first, second);
+  }
+
+  @Test
+  public void markAndResetWithReadStreamShouldSucceed() throws IOException {
+    ByteArrayOutputStream first = new ByteArrayOutputStream();
+    composite.mark();
+    composite.readBytes(first, EXPECTED_VALUE.length() / 2);
+    composite.reset();
+    assertEquals(EXPECTED_VALUE.length(), composite.readableBytes());
+    ByteArrayOutputStream second = new ByteArrayOutputStream();
+    composite.readBytes(second, EXPECTED_VALUE.length() / 2);
+    assertArrayEquals(first.toByteArray(), second.toByteArray());
+  }
+
+  @Test
+  public void markAndResetWithReadReadableBufferShouldSucceed() {
+    composite.readBytes(EXPECTED_VALUE.length() / 2);
+    int remaining = composite.readableBytes();
+    composite.mark();
+    ReadableBuffer first = composite.readBytes(1);
+    composite.reset();
     assertEquals(remaining, composite.readableBytes());
+    ReadableBuffer second = composite.readBytes(1);
+    assertEquals(first.readUnsignedByte(), second.readUnsignedByte());
+  }
 
-    composite.readBytes(bos, 5);
-    remaining -= 5;
+  @Test
+  public void markAgainShouldOverwritePreviousMark() {
+    composite.mark();
+    composite.skipBytes(EXPECTED_VALUE.length() / 2);
+    int remaining = composite.readableBytes();
+    composite.mark();
+    composite.skipBytes(1);
+    composite.reset();
     assertEquals(remaining, composite.readableBytes());
+  }
 
-    composite.readBytes(bos, remaining);
-    assertEquals(0, composite.readableBytes());
-    assertEquals(EXPECTED_VALUE, new String(bos.toByteArray(), UTF_8));
+  @Test
+  public void bufferAddedAfterMarkedShouldBeIncluded() {
+    composite = new CompositeReadableBuffer();
+    composite.mark();
+    splitAndAdd(EXPECTED_VALUE);
+    composite.skipBytes(EXPECTED_VALUE.length() / 2);
+    composite.reset();
+    assertEquals(EXPECTED_VALUE.length(), composite.readableBytes());
+  }
+
+  @Test
+  public void canUseByteBufferOnlyAllComponentsSupportUsingByteBuffer() {
+    composite = new CompositeReadableBuffer();
+    ReadableBuffer buffer1 = mock(ReadableBuffer.class);
+    ReadableBuffer buffer2 = mock(ReadableBuffer.class);
+    ReadableBuffer buffer3 = mock(ReadableBuffer.class);
+    when(buffer1.byteBufferSupported()).thenReturn(true);
+    when(buffer2.byteBufferSupported()).thenReturn(true);
+    when(buffer3.byteBufferSupported()).thenReturn(false);
+    composite.addBuffer(buffer1);
+    assertTrue(composite.byteBufferSupported());
+    composite.addBuffer(buffer2);
+    assertTrue(composite.byteBufferSupported());
+    composite.addBuffer(buffer3);
+    assertFalse(composite.byteBufferSupported());
+  }
+
+  @Test
+  public void getByteBufferDelegatesToComponents() {
+    composite = new CompositeReadableBuffer();
+    ReadableBuffer buffer = mock(ReadableBuffer.class);
+    composite.addBuffer(buffer);
+    composite.getByteBuffer();
+    verify(buffer).getByteBuffer();
   }
 
   @Test
diff --git a/core/src/test/java/io/grpc/internal/ConcurrentTimeProviderTest.java b/core/src/test/java/io/grpc/internal/ConcurrentTimeProviderTest.java
new file mode 100644
index 00000000000..7983530456c
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ConcurrentTimeProviderTest.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2024 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link ConcurrentTimeProvider}.
+ */
+@RunWith(JUnit4.class)
+public class ConcurrentTimeProviderTest {
+  @Test
+  public void testConcurrentCurrentTimeNanos() {
+
+    ConcurrentTimeProvider concurrentTimeProvider = new ConcurrentTimeProvider();
+    // Get the current time from the ConcurrentTimeProvider
+    long actualTimeNanos = concurrentTimeProvider.currentTimeNanos();
+
+    // Get the current time from System for comparison
+    long expectedTimeNanos = TimeUnit.MILLISECONDS.toNanos(System.currentTimeMillis());
+
+    // Validate the time returned is close to the expected value within a tolerance
+    // (i,e 10 millisecond tolerance in nanoseconds).
+    assertThat(actualTimeNanos).isWithin(10_000_000L).of(expectedTimeNanos);
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ConfigSelectingClientCallTest.java b/core/src/test/java/io/grpc/internal/ConfigSelectingClientCallTest.java
new file mode 100644
index 00000000000..eda265e0ff9
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ConfigSelectingClientCallTest.java
@@ -0,0 +1,194 @@
+/*
+ * 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.InternalConfigSelector;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.NoopClientCall;
+import io.grpc.Status;
+import io.grpc.internal.ManagedChannelImpl.ConfigSelectingClientCall;
+import io.grpc.internal.ManagedChannelServiceConfig.MethodInfo;
+import io.grpc.testing.TestMethodDescriptors;
+import java.util.Map;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Tests for {@link ManagedChannelImpl.ConfigSelectingClientCall}. */
+@RunWith(JUnit4.class)
+public class ConfigSelectingClientCallTest {
+  @Rule
+  public MockitoRule mockitoRule = MockitoJUnit.rule();
+  private final MethodDescriptor<Void, Void> method = TestMethodDescriptors.voidMethod();
+
+  private TestChannel channel = new TestChannel();
+  // The underlying call directly created by the channel.
+  private TestCall<?, ?> call;
+
+  @Mock
+  private ClientCall.Listener<Void> callListener;
+
+  @Test
+  public void configSelectorInterceptsCall() {
+    Map<String, ?> rawMethodConfig = ImmutableMap.of(
+        "retryPolicy",
+        ImmutableMap.of(
+            "maxAttempts", 3.0D,
+            "initialBackoff", "1s",
+            "maxBackoff", "10s",
+            "backoffMultiplier", 1.5D,
+            "retryableStatusCodes", ImmutableList.of("UNAVAILABLE")
+        ));
+    final MethodInfo methodInfo = new MethodInfo(rawMethodConfig, true, 4, 4);
+    final Metadata.Key<String> metadataKey =
+        Metadata.Key.of("test", Metadata.ASCII_STRING_MARSHALLER);
+    final CallOptions.Key<String> callOptionsKey = CallOptions.Key.create("test");
+    InternalConfigSelector configSelector = new InternalConfigSelector() {
+      @Override
+      public Result selectConfig(final PickSubchannelArgs args) {
+        ManagedChannelServiceConfig config = new ManagedChannelServiceConfig(
+            methodInfo,
+            ImmutableMap.<String, MethodInfo>of(),
+            ImmutableMap.<String, MethodInfo>of(),
+            null,
+            null,
+            null);
+        return Result.newBuilder()
+            .setConfig(config)
+            .setInterceptor(
+                // An interceptor that mutates CallOptions based on headers value.
+                new ClientInterceptor() {
+                  String value = args.getHeaders().get(metadataKey);
+                  @Override
+                  public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+                      MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+                    callOptions = callOptions.withOption(callOptionsKey, value);
+                    return next.newCall(method, callOptions);
+                  }
+                })
+            .build();
+      }
+    };
+
+    ClientCall<Void, Void> configSelectingClientCall = new ConfigSelectingClientCall<>(
+        configSelector,
+        channel,
+        MoreExecutors.directExecutor(),
+        method,
+        CallOptions.DEFAULT.withAuthority("bar.authority"));
+    Metadata metadata = new Metadata();
+    metadata.put(metadataKey, "fooValue");
+    configSelectingClientCall.start(callListener, metadata);
+
+    assertThat(call.callOptions.getAuthority()).isEqualTo("bar.authority");
+    assertThat(call.callOptions.getOption(MethodInfo.KEY)).isEqualTo(methodInfo);
+    assertThat(call.callOptions.getOption(callOptionsKey)).isEqualTo("fooValue");
+  }
+
+  @Test
+  public void selectionErrorPropagatedToListener() {
+    InternalConfigSelector configSelector = new InternalConfigSelector() {
+      @Override
+      public Result selectConfig(PickSubchannelArgs args) {
+        return Result.forError(Status.DEADLINE_EXCEEDED);
+      }
+    };
+
+    ClientCall<Void, Void> configSelectingClientCall = new ConfigSelectingClientCall<>(
+        configSelector,
+        channel,
+        MoreExecutors.directExecutor(),
+        method,
+        CallOptions.DEFAULT);
+    configSelectingClientCall.start(callListener, new Metadata());
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(callListener).onClose(statusCaptor.capture(), any(Metadata.class));
+    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Status.Code.DEADLINE_EXCEEDED);
+
+    // The call should not delegate to null and fail methods with NPE.
+    configSelectingClientCall.request(1);
+  }
+
+  @Test
+  public void selectionErrorPropagatedToListener_inappropriateStatus() {
+    InternalConfigSelector configSelector = new InternalConfigSelector() {
+      @Override
+      public Result selectConfig(PickSubchannelArgs args) {
+        // This status code is considered inappropriate to propagate from the control plane...
+        return Result.forError(Status.FAILED_PRECONDITION);
+      }
+    };
+
+    ClientCall<Void, Void> configSelectingClientCall = new ConfigSelectingClientCall<>(
+        configSelector,
+        channel,
+        MoreExecutors.directExecutor(),
+        method,
+        CallOptions.DEFAULT);
+    configSelectingClientCall.start(callListener, new Metadata());
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(callListener).onClose(statusCaptor.capture(), any(Metadata.class));
+    // ... so it should be represented as an internal error to highlight the control plane bug.
+    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Status.Code.INTERNAL);
+
+    // The call should not delegate to null and fail methods with NPE.
+    configSelectingClientCall.request(1);
+  }
+
+  private final class TestChannel extends Channel {
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(
+        MethodDescriptor<ReqT, RespT> methodDescriptor, CallOptions callOptions) {
+      TestCall<ReqT, RespT> clientCall = new TestCall<>(callOptions);
+      call = clientCall;
+      return clientCall;
+    }
+
+    @Override
+    public String authority() {
+      return "foo.authority";
+    }
+  }
+
+  private static final class TestCall<ReqT, RespT> extends NoopClientCall<ReqT, RespT> {
+    // CallOptions actually received from the channel when the call is created.
+    final CallOptions callOptions;
+
+    TestCall(CallOptions callOptions) {
+      this.callOptions = callOptions;
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ConnectivityStateManagerTest.java b/core/src/test/java/io/grpc/internal/ConnectivityStateManagerTest.java
index ce1e8e4454d..dfd6ed56a1e 100644
--- a/core/src/test/java/io/grpc/internal/ConnectivityStateManagerTest.java
+++ b/core/src/test/java/io/grpc/internal/ConnectivityStateManagerTest.java
@@ -1,36 +1,26 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
 import static org.junit.Assert.assertEquals;
 
 import com.google.common.util.concurrent.MoreExecutors;
@@ -47,58 +37,57 @@
 @RunWith(JUnit4.class)
 public class ConnectivityStateManagerTest {
   private final FakeClock executor = new FakeClock();
-  private final ConnectivityStateManager state =
-      new ConnectivityStateManager(ConnectivityState.IDLE);
-  private final LinkedList<ConnectivityState> sink = new LinkedList<ConnectivityState>();
+  private final ConnectivityStateManager state = new ConnectivityStateManager();
+  private final LinkedList<ConnectivityState> sink = new LinkedList<>();
 
   @Test
   public void noCallback() {
-    state.gotoState(ConnectivityState.CONNECTING);
-    assertEquals(ConnectivityState.CONNECTING, state.getState());
-    state.gotoState(ConnectivityState.TRANSIENT_FAILURE);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, state.getState());
+    state.gotoState(CONNECTING);
+    assertEquals(CONNECTING, state.getState());
+    state.gotoState(TRANSIENT_FAILURE);
+    assertEquals(TRANSIENT_FAILURE, state.getState());
   }
 
   @Test
   public void registerCallbackBeforeStateChanged() {
-    state.gotoState(ConnectivityState.CONNECTING);
-    assertEquals(ConnectivityState.CONNECTING, state.getState());
+    state.gotoState(CONNECTING);
+    assertEquals(CONNECTING, state.getState());
 
     state.notifyWhenStateChanged(new Runnable() {
         @Override
         public void run() {
           sink.add(state.getState());
         }
-      }, executor.getScheduledExecutorService(), ConnectivityState.CONNECTING);
+      }, executor.getScheduledExecutorService(), CONNECTING);
 
     assertEquals(0, executor.numPendingTasks());
-    state.gotoState(ConnectivityState.TRANSIENT_FAILURE);
+    state.gotoState(TRANSIENT_FAILURE);
     // Make sure the callback is run in the executor
     assertEquals(0, sink.size());
     assertEquals(1, executor.runDueTasks());
     assertEquals(0, executor.numPendingTasks());
     assertEquals(1, sink.size());
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, sink.poll());
+    assertEquals(TRANSIENT_FAILURE, sink.poll());
   }
-  
+
   @Test
   public void registerCallbackAfterStateChanged() {
-    state.gotoState(ConnectivityState.CONNECTING);
-    assertEquals(ConnectivityState.CONNECTING, state.getState());
+    state.gotoState(CONNECTING);
+    assertEquals(CONNECTING, state.getState());
 
     state.notifyWhenStateChanged(new Runnable() {
         @Override
         public void run() {
           sink.add(state.getState());
         }
-      }, executor.getScheduledExecutorService(), ConnectivityState.IDLE);
+      }, executor.getScheduledExecutorService(), IDLE);
 
     // Make sure the callback is run in the executor
     assertEquals(0, sink.size());
     assertEquals(1, executor.runDueTasks());
     assertEquals(0, executor.numPendingTasks());
     assertEquals(1, sink.size());
-    assertEquals(ConnectivityState.CONNECTING, sink.poll());
+    assertEquals(CONNECTING, sink.poll());
   }
 
   @Test
@@ -108,9 +97,9 @@ public void callbackOnlyCalledOnTransition() {
         public void run() {
           sink.add(state.getState());
         }
-      }, executor.getScheduledExecutorService(), ConnectivityState.IDLE);
+      }, executor.getScheduledExecutorService(), IDLE);
 
-    state.gotoState(ConnectivityState.IDLE);
+    state.gotoState(IDLE);
     assertEquals(0, executor.numPendingTasks());
     assertEquals(0, sink.size());
   }
@@ -124,58 +113,57 @@ public void run() {
         }
       };
 
-    state.notifyWhenStateChanged(callback, executor.getScheduledExecutorService(),
-        ConnectivityState.IDLE);
+    state.notifyWhenStateChanged(callback, executor.getScheduledExecutorService(), IDLE);
     // First transition triggers the callback
-    state.gotoState(ConnectivityState.CONNECTING);
+    state.gotoState(CONNECTING);
     assertEquals(1, executor.runDueTasks());
     assertEquals(1, sink.size());
-    assertEquals(ConnectivityState.CONNECTING, sink.poll());
+    assertEquals(CONNECTING, sink.poll());
     assertEquals(0, executor.numPendingTasks());
 
     // Second transition doesn't trigger the callback
-    state.gotoState(ConnectivityState.TRANSIENT_FAILURE);
+    state.gotoState(TRANSIENT_FAILURE);
     assertEquals(0, sink.size());
     assertEquals(0, executor.numPendingTasks());
 
     // Register another callback
-    state.notifyWhenStateChanged(callback, executor.getScheduledExecutorService(),
-        ConnectivityState.TRANSIENT_FAILURE);
+    state.notifyWhenStateChanged(
+        callback, executor.getScheduledExecutorService(), TRANSIENT_FAILURE);
 
-    state.gotoState(ConnectivityState.READY);
-    state.gotoState(ConnectivityState.IDLE);
+    state.gotoState(READY);
+    state.gotoState(IDLE);
     // Callback loses the race with the second stage change
     assertEquals(1, executor.runDueTasks());
     assertEquals(1, sink.size());
     // It will see the second state
-    assertEquals(ConnectivityState.IDLE, sink.poll());
+    assertEquals(IDLE, sink.poll());
     assertEquals(0, executor.numPendingTasks());
   }
 
   @Test
   public void multipleCallbacks() {
-    final LinkedList<String> callbackRuns = new LinkedList<String>();
+    final LinkedList<String> callbackRuns = new LinkedList<>();
     state.notifyWhenStateChanged(new Runnable() {
         @Override
         public void run() {
           sink.add(state.getState());
           callbackRuns.add("callback1");
         }
-      }, executor.getScheduledExecutorService(), ConnectivityState.IDLE);
+      }, executor.getScheduledExecutorService(), IDLE);
     state.notifyWhenStateChanged(new Runnable() {
         @Override
         public void run() {
           sink.add(state.getState());
           callbackRuns.add("callback2");
         }
-      }, executor.getScheduledExecutorService(), ConnectivityState.IDLE);
+      }, executor.getScheduledExecutorService(), IDLE);
     state.notifyWhenStateChanged(new Runnable() {
         @Override
         public void run() {
           sink.add(state.getState());
           callbackRuns.add("callback3");
         }
-      }, executor.getScheduledExecutorService(), ConnectivityState.READY);
+      }, executor.getScheduledExecutorService(), READY);
 
     // callback3 is run immediately because the source state is already different from the current
     // state.
@@ -183,17 +171,17 @@ public void run() {
     assertEquals(1, callbackRuns.size());
     assertEquals("callback3", callbackRuns.poll());
     assertEquals(1, sink.size());
-    assertEquals(ConnectivityState.IDLE, sink.poll());
+    assertEquals(IDLE, sink.poll());
 
     // Now change the state.
-    state.gotoState(ConnectivityState.CONNECTING);
+    state.gotoState(CONNECTING);
     assertEquals(2, executor.runDueTasks());
     assertEquals(2, callbackRuns.size());
     assertEquals("callback1", callbackRuns.poll());
     assertEquals("callback2", callbackRuns.poll());
     assertEquals(2, sink.size());
-    assertEquals(ConnectivityState.CONNECTING, sink.poll());
-    assertEquals(ConnectivityState.CONNECTING, sink.poll());
+    assertEquals(CONNECTING, sink.poll());
+    assertEquals(CONNECTING, sink.poll());
 
     assertEquals(0, executor.numPendingTasks());
   }
@@ -213,17 +201,17 @@ public void registerCallbackFromCallback() {
     state.notifyWhenStateChanged(newRecursiveCallback(executor.getScheduledExecutorService()),
         executor.getScheduledExecutorService(), state.getState());
 
-    state.gotoState(ConnectivityState.CONNECTING);
+    state.gotoState(CONNECTING);
     assertEquals(1, executor.runDueTasks());
     assertEquals(0, executor.numPendingTasks());
     assertEquals(1, sink.size());
-    assertEquals(ConnectivityState.CONNECTING, sink.poll());
+    assertEquals(CONNECTING, sink.poll());
 
-    state.gotoState(ConnectivityState.READY);
+    state.gotoState(READY);
     assertEquals(1, executor.runDueTasks());
     assertEquals(0, executor.numPendingTasks());
     assertEquals(1, sink.size());
-    assertEquals(ConnectivityState.READY, sink.poll());
+    assertEquals(READY, sink.poll());
   }
 
   @Test
@@ -231,12 +219,21 @@ public void registerCallbackFromCallbackDirectExecutor() {
     state.notifyWhenStateChanged(newRecursiveCallback(MoreExecutors.directExecutor()),
         MoreExecutors.directExecutor(), state.getState());
 
-    state.gotoState(ConnectivityState.CONNECTING);
+    state.gotoState(CONNECTING);
     assertEquals(1, sink.size());
-    assertEquals(ConnectivityState.CONNECTING, sink.poll());
+    assertEquals(CONNECTING, sink.poll());
 
-    state.gotoState(ConnectivityState.READY);
+    state.gotoState(READY);
     assertEquals(1, sink.size());
-    assertEquals(ConnectivityState.READY, sink.poll());
+    assertEquals(READY, sink.poll());
+  }
+
+  @Test
+  public void shutdownThenReady() {
+    state.gotoState(SHUTDOWN);
+    assertEquals(SHUTDOWN, state.getState());
+
+    state.gotoState(READY);
+    assertEquals(SHUTDOWN, state.getState());
   }
 }
diff --git a/core/src/test/java/io/grpc/internal/DelayedClientCallTest.java b/core/src/test/java/io/grpc/internal/DelayedClientCallTest.java
new file mode 100644
index 00000000000..ff131d29975
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/DelayedClientCallTest.java
@@ -0,0 +1,237 @@
+/*
+ * 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.ClientCall;
+import io.grpc.ClientCall.Listener;
+import io.grpc.Context;
+import io.grpc.Deadline;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingTestUtil;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.concurrent.Executor;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Tests for {@link DelayedClientCall}. */
+@RunWith(JUnit4.class)
+public class DelayedClientCallTest {
+  @Rule
+  public final MockitoRule mockitoRule = MockitoJUnit.rule();
+  @Mock
+  private ClientCall<String, Integer> mockRealCall;
+  @Mock
+  private ClientCall.Listener<Integer> listener;
+  @Captor
+  ArgumentCaptor<Status> statusCaptor;
+
+  private final FakeClock fakeClock = new FakeClock();
+  private final Executor callExecutor = MoreExecutors.directExecutor();
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    DelayedClientCall<String, Integer> delayedClientCall =
+        new DelayedClientCall<>(callExecutor, fakeClock.getScheduledExecutorService(), null);
+    callMeMaybe(delayedClientCall.setCall(mockRealCall));
+    ForwardingTestUtil.testMethodsForwarded(
+        ClientCall.class,
+        mockRealCall,
+        delayedClientCall,
+        Arrays.asList(ClientCall.class.getMethod("toString"),
+            ClientCall.class.getMethod("start", Listener.class, Metadata.class)),
+        new ForwardingTestUtil.ArgumentProvider() {
+          @Override
+          public Object get(Method method, int argPos, Class<?> clazz) {
+            if (!Modifier.isFinal(clazz.getModifiers())) {
+              return mock(clazz);
+            }
+            if (clazz.equals(String.class)) {
+              return "message";
+            }
+            return null;
+          }
+        });
+  }
+
+  // Coverage for deadline exceeded before call started is enforced by
+  // AbstractInteropTest.deadlineInPast().
+  @Test
+  public void deadlineExceededWhileCallIsStartedButStillPending() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), Deadline.after(10, SECONDS));
+
+    delayedClientCall.start(listener, new Metadata());
+    fakeClock.forwardTime(10, SECONDS);
+    verify(listener).onClose(statusCaptor.capture(), any(Metadata.class));
+    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Status.Code.DEADLINE_EXCEEDED);
+  }
+
+  @Test
+  public void listenerEventsPropagated() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), Deadline.after(10, SECONDS));
+    delayedClientCall.start(listener, new Metadata());
+    callMeMaybe(delayedClientCall.setCall(mockRealCall));
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<Listener<Integer>> listenerCaptor = ArgumentCaptor.forClass(Listener.class);
+    verify(mockRealCall).start(listenerCaptor.capture(), any(Metadata.class));
+    Listener<Integer> realCallListener = listenerCaptor.getValue();
+    Metadata metadata = new Metadata();
+    metadata.put(Metadata.Key.of("key", Metadata.ASCII_STRING_MARSHALLER), "value");
+    realCallListener.onHeaders(metadata);
+    verify(listener).onHeaders(metadata);
+    realCallListener.onMessage(3);
+    verify(listener).onMessage(3);
+    realCallListener.onReady();
+    verify(listener).onReady();
+    Metadata trailer = new Metadata();
+    trailer.put(Metadata.Key.of("key2", Metadata.ASCII_STRING_MARSHALLER), "value2");
+    realCallListener.onClose(Status.DATA_LOSS, trailer);
+    verify(listener).onClose(statusCaptor.capture(), eq(trailer));
+    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Status.Code.DATA_LOSS);
+  }
+
+  @Test
+  public void setCallThenStart() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), null);
+    callMeMaybe(delayedClientCall.setCall(mockRealCall));
+    delayedClientCall.start(listener, new Metadata());
+    delayedClientCall.request(1);
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<Listener<Integer>> listenerCaptor = ArgumentCaptor.forClass(Listener.class);
+    verify(mockRealCall).start(listenerCaptor.capture(), any(Metadata.class));
+    Listener<Integer> realCallListener = listenerCaptor.getValue();
+    verify(mockRealCall).request(1);
+    realCallListener.onMessage(1);
+    verify(listener).onMessage(1);
+  }
+
+  @Test
+  public void startThenSetCall() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), null);
+    delayedClientCall.start(listener, new Metadata());
+    delayedClientCall.request(1);
+    Runnable r = delayedClientCall.setCall(mockRealCall);
+    assertThat(r).isNotNull();
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<Listener<Integer>> listenerCaptor = ArgumentCaptor.forClass(Listener.class);
+    // start() must be called before setCall() returns (not in runnable), to ensure the in-use
+    // counts keeping the channel alive after shutdown() don't momentarily decrease to zero.
+    verify(mockRealCall).start(listenerCaptor.capture(), any(Metadata.class));
+    r.run();
+    Listener<Integer> realCallListener = listenerCaptor.getValue();
+    verify(mockRealCall).request(1);
+    realCallListener.onMessage(1);
+    verify(listener).onMessage(1);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void cancelThenSetCall() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), null);
+    delayedClientCall.start(listener, new Metadata());
+    delayedClientCall.request(1);
+    delayedClientCall.cancel("cancel", new StatusException(Status.CANCELLED));
+    Runnable r = delayedClientCall.setCall(mockRealCall);
+    assertThat(r).isNull();
+    verify(mockRealCall, never()).start(any(Listener.class), any(Metadata.class));
+    verify(mockRealCall, never()).request(1);
+    verify(mockRealCall, never()).cancel(any(), any());
+    verify(listener).onClose(any(), any());
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void setCallThenCancel() {
+    DelayedClientCall<String, Integer> delayedClientCall = new DelayedClientCall<>(
+        callExecutor, fakeClock.getScheduledExecutorService(), null);
+    delayedClientCall.start(listener, new Metadata());
+    delayedClientCall.request(1);
+    Runnable r = delayedClientCall.setCall(mockRealCall);
+    assertThat(r).isNotNull();
+    r.run();
+    delayedClientCall.cancel("cancel", new StatusException(Status.CANCELLED));
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<Listener<Integer>> listenerCaptor = ArgumentCaptor.forClass(Listener.class);
+    verify(mockRealCall).start(listenerCaptor.capture(), any(Metadata.class));
+    Listener<Integer> realCallListener = listenerCaptor.getValue();
+    verify(mockRealCall).request(1);
+    verify(mockRealCall).cancel(any(), any());
+    realCallListener.onClose(Status.CANCELLED, null);
+    verify(listener).onClose(Status.CANCELLED, null);
+  }
+
+  @Test
+  public void delayedCallsRunUnderContext() throws Exception {
+    Context.Key<Object> contextKey = Context.key("foo");
+    Object goldenValue = new Object();
+    DelayedClientCall<String, Integer> delayedClientCall =
+        Context.current().withValue(contextKey, goldenValue).call(() ->
+            new DelayedClientCall<>(callExecutor, fakeClock.getScheduledExecutorService(), null));
+    AtomicReference<Context> readyContext = new AtomicReference<>();
+    delayedClientCall.start(new ClientCall.Listener<Integer>() {
+      @Override public void onReady() {
+        readyContext.set(Context.current());
+      }
+    }, new Metadata());
+    AtomicReference<Context> startContext = new AtomicReference<>();
+    Runnable r = delayedClientCall.setCall(new SimpleForwardingClientCall<String, Integer>(
+        mockRealCall) {
+      @Override public void start(Listener<Integer> listener, Metadata metadata) {
+        startContext.set(Context.current());
+        listener.onReady(); // Delayed until call finishes draining
+        assertThat(readyContext.get()).isNull();
+        super.start(listener, metadata);
+      }
+    });
+    assertThat(r).isNotNull();
+    r.run();
+    assertThat(contextKey.get(startContext.get())).isEqualTo(goldenValue);
+    assertThat(contextKey.get(readyContext.get())).isEqualTo(goldenValue);
+  }
+
+  private void callMeMaybe(Runnable r) {
+    if (r != null) {
+      r.run();
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/DelayedClientTransport2Test.java b/core/src/test/java/io/grpc/internal/DelayedClientTransport2Test.java
deleted file mode 100644
index a2c503d674d..00000000000
--- a/core/src/test/java/io/grpc/internal/DelayedClientTransport2Test.java
+++ /dev/null
@@ -1,567 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.same;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.timeout;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-import io.grpc.Attributes;
-import io.grpc.CallOptions;
-import io.grpc.IntegerMarshaller;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.SubchannelPicker;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.MethodDescriptor.MethodType;
-import io.grpc.Status;
-import io.grpc.StringMarshaller;
-import java.util.concurrent.CyclicBarrier;
-import java.util.concurrent.Executor;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-/**
- * Unit tests for {@link DelayedClientTransport2}.
- */
-@RunWith(JUnit4.class)
-public class DelayedClientTransport2Test {
-  @Mock private ManagedClientTransport.Listener transportListener;
-  @Mock private SubchannelPicker mockPicker;
-  @Mock private SubchannelImpl mockSubchannel;
-  @Mock private ClientTransport mockRealTransport;
-  @Mock private ClientTransport mockRealTransport2;
-  @Mock private ClientStream mockRealStream;
-  @Mock private ClientStream mockRealStream2;
-  @Mock private ClientStreamListener streamListener;
-  @Mock private Executor mockExecutor;
-  @Captor private ArgumentCaptor<Status> statusCaptor;
-  @Captor private ArgumentCaptor<ClientStreamListener> listenerCaptor;
-
-  private static final Attributes.Key<Integer> SHARD_ID = Attributes.Key.of("shard-id");
-
-  private final MethodDescriptor<String, Integer> method =
-      MethodDescriptor.<String, Integer>newBuilder()
-          .setType(MethodType.UNKNOWN)
-          .setFullMethodName("/service/method")
-          .setRequestMarshaller(new StringMarshaller())
-          .setResponseMarshaller(new IntegerMarshaller())
-          .build();
-  private final MethodDescriptor<String, Integer> method2 =
-      method.toBuilder().setFullMethodName("/service/method").build();
-  private final Metadata headers = new Metadata();
-  private final Metadata headers2 = new Metadata();
-
-  private final CallOptions callOptions = CallOptions.DEFAULT.withAuthority("dummy_value");
-  private final CallOptions callOptions2 = CallOptions.DEFAULT.withAuthority("dummy_value2");
-  private final StatsTraceContext statsTraceCtx = StatsTraceContext.newClientContext(
-      method.getFullMethodName(), NoopStatsContextFactory.INSTANCE,
-      GrpcUtil.STOPWATCH_SUPPLIER);
-  private final StatsTraceContext statsTraceCtx2 = StatsTraceContext.newClientContext(
-      method2.getFullMethodName(), NoopStatsContextFactory.INSTANCE,
-      GrpcUtil.STOPWATCH_SUPPLIER);
-
-  private final FakeClock fakeExecutor = new FakeClock();
-
-  private final DelayedClientTransport2 delayedTransport = new DelayedClientTransport2(
-      fakeExecutor.getScheduledExecutorService(), new ChannelExecutor());
-
-  @Before public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    when(mockPicker.pickSubchannel(any(Attributes.class), any(Metadata.class)))
-        .thenReturn(PickResult.withSubchannel(mockSubchannel));
-    when(mockSubchannel.obtainActiveTransport()).thenReturn(mockRealTransport);
-    when(mockRealTransport.newStream(same(method), same(headers), same(callOptions),
-            same(statsTraceCtx)))
-        .thenReturn(mockRealStream);
-    when(mockRealTransport2.newStream(same(method2), same(headers2), same(callOptions2),
-            same(statsTraceCtx2)))
-        .thenReturn(mockRealStream2);
-    delayedTransport.start(transportListener);
-  }
-
-  @After public void noMorePendingTasks() {
-    assertEquals(0, fakeExecutor.numPendingTasks());
-  }
-
-  @Test public void streamStartThenAssignTransport() {
-    assertFalse(delayedTransport.hasPendingStreams());
-    ClientStream stream = delayedTransport.newStream(method, headers, callOptions, statsTraceCtx);
-    stream.start(streamListener);
-    assertEquals(1, delayedTransport.getPendingStreamsCount());
-    assertTrue(delayedTransport.hasPendingStreams());
-    assertTrue(stream instanceof DelayedStream);
-    assertEquals(0, fakeExecutor.numPendingTasks());
-    delayedTransport.reprocess(mockPicker);
-    assertEquals(0, delayedTransport.getPendingStreamsCount());
-    assertFalse(delayedTransport.hasPendingStreams());
-    assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockRealTransport).newStream(same(method), same(headers), same(callOptions),
-        same(statsTraceCtx));
-    verify(mockRealStream).start(listenerCaptor.capture());
-    verifyNoMoreInteractions(streamListener);
-    listenerCaptor.getValue().onReady();
-    verify(streamListener).onReady();
-    verifyNoMoreInteractions(streamListener);
-  }
-
-  @Test public void newStreamThenAssignTransportThenShutdown() {
-    ClientStream stream = delayedTransport.newStream(method, headers, callOptions, statsTraceCtx);
-    assertEquals(1, delayedTransport.getPendingStreamsCount());
-    assertTrue(stream instanceof DelayedStream);
-    delayedTransport.reprocess(mockPicker);
-    assertEquals(0, delayedTransport.getPendingStreamsCount());
-    delayedTransport.shutdown();
-    verify(transportListener).transportShutdown(any(Status.class));
-    verify(transportListener).transportTerminated();
-    assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockRealTransport).newStream(same(method), same(headers), same(callOptions),
-        same(statsTraceCtx));
-    stream.start(streamListener);
-    verify(mockRealStream).start(same(streamListener));
-  }
-
-  @Test public void transportTerminatedThenAssignTransport() {
-    delayedTransport.shutdown();
-    verify(transportListener).transportShutdown(any(Status.class));
-    verify(transportListener).transportTerminated();
-    delayedTransport.reprocess(mockPicker);
-    verifyNoMoreInteractions(transportListener);
-  }
-
-  @Test public void assignTransportThenShutdownThenNewStream() {
-    delayedTransport.reprocess(mockPicker);
-    delayedTransport.shutdown();
-    verify(transportListener).transportShutdown(any(Status.class));
-    verify(transportListener).transportTerminated();
-    ClientStream stream = delayedTransport.newStream(method, headers, callOptions, statsTraceCtx);
-    assertEquals(0, delayedTransport.getPendingStreamsCount());
-    assertTrue(stream instanceof FailingClientStream);
-    verify(mockRealTransport, never()).newStream(any(MethodDescriptor.class), any(Metadata.class),
-        any(CallOptions.class), any(StatsTraceContext.class));
-  }
-
-  @Test public void assignTransportThenShutdownNowThenNewStream() {
-    delayedTransport.reprocess(mockPicker);
-    delayedTransport.shutdownNow(Status.UNAVAILABLE);
-    verify(transportListener).transportShutdown(any(Status.class));
-    verify(transportListener).transportTerminated();
-    ClientStream stream = delayedTransport.newStream(method, headers, callOptions, statsTraceCtx);
-    assertEquals(0, delayedTransport.getPendingStreamsCount());
-    assertTrue(stream instanceof FailingClientStream);
-    verify(mockRealTransport, never()).newStream(any(MethodDescriptor.class), any(Metadata.class),
-        any(CallOptions.class), any(StatsTraceContext.class));
-  }
-
-  @Test public void cancelStreamWithoutSetTransport() {
-    ClientStream stream = delayedTransport.newStream(method, new Metadata());
-    assertEquals(1, delayedTransport.getPendingStreamsCount());
-    stream.cancel(Status.CANCELLED);
-    assertEquals(0, delayedTransport.getPendingStreamsCount());
-    verifyNoMoreInteractions(mockRealTransport);
-    verifyNoMoreInteractions(mockRealStream);
-  }
-
-  @Test public void startThenCancelStreamWithoutSetTransport() {
-    ClientStream stream = delayedTransport.newStream(method, new Metadata());
-    stream.start(streamListener);
-    assertEquals(1, delayedTransport.getPendingStreamsCount());
-    stream.cancel(Status.CANCELLED);
-    assertEquals(0, delayedTransport.getPendingStreamsCount());
-    verify(streamListener).closed(same(Status.CANCELLED), any(Metadata.class));
-    verifyNoMoreInteractions(mockRealTransport);
-    verifyNoMoreInteractions(mockRealStream);
-  }
-
-  @Test public void newStreamThenShutdownTransportThenAssignTransport() {
-    ClientStream stream = delayedTransport.newStream(method, headers, callOptions, statsTraceCtx);
-    stream.start(streamListener);
-    delayedTransport.shutdown();
-
-    // Stream is still buffered
-    verify(transportListener).transportShutdown(any(Status.class));
-    verify(transportListener, times(0)).transportTerminated();
-    assertEquals(1, delayedTransport.getPendingStreamsCount());
-
-    // ... and will proceed if a real transport is available
-    delayedTransport.reprocess(mockPicker);
-    fakeExecutor.runDueTasks();
-    verify(mockRealTransport).newStream(method, headers, callOptions, statsTraceCtx);
-    verify(mockRealStream).start(any(ClientStreamListener.class));
-
-    // Since no more streams are pending, delayed transport is now terminated
-    assertEquals(0, delayedTransport.getPendingStreamsCount());
-    verify(transportListener).transportTerminated();
-
-    // Further newStream() will return a failing stream
-    stream = delayedTransport.newStream(method, new Metadata());
-    verify(streamListener, never()).closed(any(Status.class), any(Metadata.class));
-    stream.start(streamListener);
-    verify(streamListener).closed(statusCaptor.capture(), any(Metadata.class));
-    assertEquals(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
-
-    assertEquals(0, delayedTransport.getPendingStreamsCount());
-    verifyNoMoreInteractions(mockRealTransport);
-    verifyNoMoreInteractions(mockRealStream);
-  }
-
-  @Test public void newStreamThenShutdownTransportThenCancelStream() {
-    ClientStream stream = delayedTransport.newStream(method, new Metadata());
-    delayedTransport.shutdown();
-    verify(transportListener).transportShutdown(any(Status.class));
-    verify(transportListener, times(0)).transportTerminated();
-    assertEquals(1, delayedTransport.getPendingStreamsCount());
-    stream.cancel(Status.CANCELLED);
-    verify(transportListener).transportTerminated();
-    assertEquals(0, delayedTransport.getPendingStreamsCount());
-    verifyNoMoreInteractions(mockRealTransport);
-    verifyNoMoreInteractions(mockRealStream);
-  }
-
-  @Test public void shutdownThenNewStream() {
-    delayedTransport.shutdown();
-    verify(transportListener).transportShutdown(any(Status.class));
-    verify(transportListener).transportTerminated();
-    ClientStream stream = delayedTransport.newStream(method, new Metadata());
-    stream.start(streamListener);
-    verify(streamListener).closed(statusCaptor.capture(), any(Metadata.class));
-    assertEquals(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
-  }
-
-  @Test public void startStreamThenShutdownNow() {
-    ClientStream stream = delayedTransport.newStream(method, new Metadata());
-    stream.start(streamListener);
-    delayedTransport.shutdownNow(Status.UNAVAILABLE);
-    verify(transportListener).transportShutdown(any(Status.class));
-    verify(transportListener).transportTerminated();
-    verify(streamListener).closed(statusCaptor.capture(), any(Metadata.class));
-    assertEquals(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
-  }
-
-  @Test public void shutdownNowThenNewStream() {
-    delayedTransport.shutdownNow(Status.UNAVAILABLE);
-    verify(transportListener).transportShutdown(any(Status.class));
-    verify(transportListener).transportTerminated();
-    ClientStream stream = delayedTransport.newStream(method, new Metadata());
-    stream.start(streamListener);
-    verify(streamListener).closed(statusCaptor.capture(), any(Metadata.class));
-    assertEquals(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
-  }
-
-  @Test public void reprocessSemantics() {
-    Attributes affinity1 = Attributes.newBuilder().set(SHARD_ID, 1).build();
-    Attributes affinity2 = Attributes.newBuilder().set(SHARD_ID, 2).build();
-    CallOptions failFastCallOptions = CallOptions.DEFAULT.withAffinity(affinity1);
-    CallOptions waitForReadyCallOptions =
-        CallOptions.DEFAULT.withWaitForReady().withAffinity(affinity2);
-
-    SubchannelImpl subchannel1 = mock(SubchannelImpl.class);
-    SubchannelImpl subchannel2 = mock(SubchannelImpl.class);
-    SubchannelImpl subchannel3 = mock(SubchannelImpl.class);
-    when(mockRealTransport.newStream(any(MethodDescriptor.class), any(Metadata.class),
-            any(CallOptions.class), same(statsTraceCtx))).thenReturn(mockRealStream);
-    when(mockRealTransport2.newStream(any(MethodDescriptor.class), any(Metadata.class),
-            any(CallOptions.class), same(statsTraceCtx))).thenReturn(mockRealStream2);
-    when(subchannel1.obtainActiveTransport()).thenReturn(mockRealTransport);
-    when(subchannel2.obtainActiveTransport()).thenReturn(mockRealTransport2);
-    when(subchannel3.obtainActiveTransport()).thenReturn(null);
-
-    // Fail-fast streams
-    DelayedStream ff1 = (DelayedStream) delayedTransport.newStream(
-        method, headers, failFastCallOptions, statsTraceCtx);
-    verify(transportListener).transportInUse(true);
-    DelayedStream ff2 = (DelayedStream) delayedTransport.newStream(
-        method2, headers2, failFastCallOptions, statsTraceCtx);
-    DelayedStream ff3 = (DelayedStream) delayedTransport.newStream(
-        method, headers, failFastCallOptions, statsTraceCtx);
-    DelayedStream ff4 = (DelayedStream) delayedTransport.newStream(
-        method2, headers2, failFastCallOptions, statsTraceCtx);
-
-    // Wait-for-ready streams
-    FakeClock wfr3Executor = new FakeClock();
-    DelayedStream wfr1 = (DelayedStream) delayedTransport.newStream(
-        method, headers, waitForReadyCallOptions, statsTraceCtx);
-    DelayedStream wfr2 = (DelayedStream) delayedTransport.newStream(
-        method2, headers2, waitForReadyCallOptions, statsTraceCtx);
-    DelayedStream wfr3 = (DelayedStream) delayedTransport.newStream(
-        method, headers,
-        waitForReadyCallOptions.withExecutor(wfr3Executor.getScheduledExecutorService()),
-        statsTraceCtx);
-    DelayedStream wfr4 = (DelayedStream) delayedTransport.newStream(
-        method2, headers2, waitForReadyCallOptions, statsTraceCtx);
-    assertEquals(8, delayedTransport.getPendingStreamsCount());
-
-    // First reprocess(). Some will proceed, some will fail and the rest will stay buffered.
-    SubchannelPicker picker = mock(SubchannelPicker.class);
-    when(picker.pickSubchannel(any(Attributes.class), any(Metadata.class))).thenReturn(
-        // For the fail-fast streams
-        PickResult.withSubchannel(subchannel1),    // ff1: proceed
-        PickResult.withError(Status.UNAVAILABLE),  // ff2: fail
-        PickResult.withSubchannel(subchannel3),    // ff3: stay
-        PickResult.withNoResult(),                 // ff4: stay
-        // For the wait-for-ready streams
-        PickResult.withSubchannel(subchannel2),           // wfr1: proceed
-        PickResult.withError(Status.RESOURCE_EXHAUSTED),  // wfr2: stay
-        PickResult.withSubchannel(subchannel3));          // wfr3: stay
-    InOrder inOrder = inOrder(picker);
-    delayedTransport.reprocess(picker);
-
-    assertEquals(5, delayedTransport.getPendingStreamsCount());
-    inOrder.verify(picker).pickSubchannel(affinity1, headers);  // ff1
-    inOrder.verify(picker).pickSubchannel(affinity1, headers2);  // ff2
-    inOrder.verify(picker).pickSubchannel(affinity1, headers);  // ff3
-    inOrder.verify(picker).pickSubchannel(affinity1, headers2);  // ff4
-    inOrder.verify(picker).pickSubchannel(affinity2, headers);  // wfr1
-    inOrder.verify(picker).pickSubchannel(affinity2, headers2);  // wfr2
-    inOrder.verify(picker).pickSubchannel(affinity2, headers);  // wfr3
-    inOrder.verify(picker).pickSubchannel(affinity2, headers2);  // wfr4
-    inOrder.verifyNoMoreInteractions();
-    // Make sure that real transport creates streams in the executor
-    verify(mockRealTransport, never()).newStream(any(MethodDescriptor.class),
-        any(Metadata.class), any(CallOptions.class), any(StatsTraceContext.class));
-    verify(mockRealTransport2, never()).newStream(any(MethodDescriptor.class),
-        any(Metadata.class), any(CallOptions.class), any(StatsTraceContext.class));
-    fakeExecutor.runDueTasks();
-    assertEquals(0, fakeExecutor.numPendingTasks());
-    // ff1 and wfr1 went through
-    verify(mockRealTransport).newStream(method, headers, failFastCallOptions, statsTraceCtx);
-    verify(mockRealTransport2).newStream(method, headers, waitForReadyCallOptions, statsTraceCtx);
-    assertSame(mockRealStream, ff1.getRealStream());
-    assertSame(mockRealStream2, wfr1.getRealStream());
-    // The ff2 has failed due to picker returning an error
-    assertSame(Status.UNAVAILABLE, ((FailingClientStream) ff2.getRealStream()).getError());
-    // Other streams are still buffered
-    assertNull(ff3.getRealStream());
-    assertNull(ff4.getRealStream());
-    assertNull(wfr2.getRealStream());
-    assertNull(wfr3.getRealStream());
-    assertNull(wfr4.getRealStream());
-
-    // Second reprocess(). All existing streams will proceed.
-    picker = mock(SubchannelPicker.class);
-    when(picker.pickSubchannel(any(Attributes.class), any(Metadata.class))).thenReturn(
-        PickResult.withSubchannel(subchannel1),  // ff3
-        PickResult.withSubchannel(subchannel2),  // ff4
-        PickResult.withSubchannel(subchannel2),  // wfr2
-        PickResult.withSubchannel(subchannel1),  // wfr3
-        PickResult.withSubchannel(subchannel2),  // wfr4
-        PickResult.withNoResult());              // wfr5 (not yet created)
-    inOrder = inOrder(picker);
-    assertEquals(0, wfr3Executor.numPendingTasks());
-    verify(transportListener, never()).transportInUse(false);
-
-    delayedTransport.reprocess(picker);
-    assertEquals(0, delayedTransport.getPendingStreamsCount());
-    verify(transportListener).transportInUse(false);
-    inOrder.verify(picker).pickSubchannel(affinity1, headers);  // ff3
-    inOrder.verify(picker).pickSubchannel(affinity1, headers2);  // ff4
-    inOrder.verify(picker).pickSubchannel(affinity2, headers2);  // wfr2
-    inOrder.verify(picker).pickSubchannel(affinity2, headers);  // wfr3
-    inOrder.verify(picker).pickSubchannel(affinity2, headers2);  // wfr4
-    inOrder.verifyNoMoreInteractions();
-    fakeExecutor.runDueTasks();
-    assertEquals(0, fakeExecutor.numPendingTasks());
-    assertSame(mockRealStream, ff3.getRealStream());
-    assertSame(mockRealStream2, ff4.getRealStream());
-    assertSame(mockRealStream2, wfr2.getRealStream());
-    assertSame(mockRealStream2, wfr4.getRealStream());
-
-    // If there is an executor in the CallOptions, it will be used to create the real tream.
-    assertNull(wfr3.getRealStream());
-    wfr3Executor.runDueTasks();
-    assertSame(mockRealStream, wfr3.getRealStream());
-
-    // New streams will use the last picker
-    DelayedStream wfr5 = (DelayedStream) delayedTransport.newStream(
-        method, headers, waitForReadyCallOptions, statsTraceCtx);
-    assertNull(wfr5.getRealStream());
-    inOrder.verify(picker).pickSubchannel(affinity2, headers);
-    inOrder.verifyNoMoreInteractions();
-    assertEquals(1, delayedTransport.getPendingStreamsCount());
-
-    // wfr5 will stop delayed transport from terminating
-    delayedTransport.shutdown();
-    verify(transportListener).transportShutdown(any(Status.class));
-    verify(transportListener, never()).transportTerminated();
-    // ... until it's gone
-    picker = mock(SubchannelPicker.class);
-    when(picker.pickSubchannel(any(Attributes.class), any(Metadata.class))).thenReturn(
-        PickResult.withSubchannel(subchannel1));
-    delayedTransport.reprocess(picker);
-    verify(picker).pickSubchannel(affinity2, headers);
-    fakeExecutor.runDueTasks();
-    assertSame(mockRealStream, wfr5.getRealStream());
-    assertEquals(0, delayedTransport.getPendingStreamsCount());
-    verify(transportListener).transportTerminated();
-  }
-
-  @Test
-  public void reprocess_NoPendingStream() {
-    SubchannelPicker picker = mock(SubchannelPicker.class);
-    SubchannelImpl subchannel = mock(SubchannelImpl.class);
-    when(subchannel.obtainActiveTransport()).thenReturn(mockRealTransport);
-    when(picker.pickSubchannel(any(Attributes.class), any(Metadata.class))).thenReturn(
-        PickResult.withSubchannel(subchannel));
-    when(mockRealTransport.newStream(any(MethodDescriptor.class), any(Metadata.class),
-            any(CallOptions.class), same(statsTraceCtx))).thenReturn(mockRealStream);
-    delayedTransport.reprocess(picker);
-    verifyNoMoreInteractions(picker);
-    verifyNoMoreInteractions(transportListener);
-
-    // Though picker was not originally used, it will be saved and serve future streams.
-    ClientStream stream = delayedTransport.newStream(
-        method, headers, CallOptions.DEFAULT, statsTraceCtx);
-    verify(picker).pickSubchannel(CallOptions.DEFAULT.getAffinity(), headers);
-    verify(subchannel).obtainActiveTransport();
-    assertSame(mockRealStream, stream);
-  }
-
-  @Test
-  public void reprocess_newStreamRacesWithReprocess() throws Exception {
-    final CyclicBarrier barrier = new CyclicBarrier(2);
-    // In both phases, we only expect the first pickSubchannel() call to block on the barrier.
-    final AtomicBoolean nextPickShouldWait = new AtomicBoolean(true);
-    ///////// Phase 1: reprocess() twice with the same picker
-    SubchannelPicker picker = mock(SubchannelPicker.class);
-
-    doAnswer(new Answer<PickResult>() {
-        @Override
-        public PickResult answer(InvocationOnMock invocation) throws Throwable {
-          if (nextPickShouldWait.compareAndSet(true, false)) {
-            try {
-              barrier.await();
-              return PickResult.withNoResult();
-            } catch (Exception e) {
-              e.printStackTrace();
-            }
-          }
-          return PickResult.withNoResult();
-        }
-      }).when(picker).pickSubchannel(any(Attributes.class), any(Metadata.class));
-
-    // Because there is no pending stream yet, it will do nothing but save the picker.
-    delayedTransport.reprocess(picker);
-    verify(picker, never()).pickSubchannel(any(Attributes.class), any(Metadata.class));
-
-    Thread sideThread = new Thread("sideThread") {
-        @Override
-        public void run() {
-          // Will call pickSubchannel and wait on barrier
-          delayedTransport.newStream(method, headers, callOptions, statsTraceCtx);
-        }
-      };
-    sideThread.start();
-
-    // Is called from sideThread
-    verify(picker, timeout(5000)).pickSubchannel(callOptions.getAffinity(), headers);
-
-    // Because stream has not been buffered (it's still stuck in newStream()), this will do nothing,
-    // but incrementing the picker version.
-    delayedTransport.reprocess(picker);
-    verify(picker).pickSubchannel(callOptions.getAffinity(), headers);
-
-    // Now let the stuck newStream() through
-    barrier.await(5, TimeUnit.SECONDS);
-
-    sideThread.join(5000);
-    assertFalse("sideThread should've exited", sideThread.isAlive());
-    // newStream() detects that there has been a new picker while it's stuck, thus will pick again.
-    verify(picker, times(2)).pickSubchannel(callOptions.getAffinity(), headers);
-
-    barrier.reset();
-    nextPickShouldWait.set(true);
-
-    ////////// Phase 2: reprocess() with a different picker
-    // Create the second stream
-    Thread sideThread2 = new Thread("sideThread2") {
-        @Override
-        public void run() {
-          // Will call pickSubchannel and wait on barrier
-          delayedTransport.newStream(method, headers2, callOptions, statsTraceCtx);
-        }
-      };
-    sideThread2.start();
-    // The second stream will see the first picker
-    verify(picker, timeout(5000)).pickSubchannel(callOptions.getAffinity(), headers2);
-    // While the first stream won't use the first picker any more.
-    verify(picker, times(2)).pickSubchannel(callOptions.getAffinity(), headers);
-
-    // Now use a different picker
-    SubchannelPicker picker2 = mock(SubchannelPicker.class);
-    when(picker2.pickSubchannel(any(Attributes.class), any(Metadata.class)))
-        .thenReturn(PickResult.withNoResult());
-    delayedTransport.reprocess(picker2);
-    // The pending first stream uses the new picker
-    verify(picker2).pickSubchannel(callOptions.getAffinity(), headers);
-    // The second stream is still pending in creation, doesn't use the new picker.
-    verify(picker2, never()).pickSubchannel(callOptions.getAffinity(), headers2);
-
-    // Now let the second stream finish creation
-    barrier.await(5, TimeUnit.SECONDS);
-
-    sideThread2.join(5000);
-    assertFalse("sideThread2 should've exited", sideThread2.isAlive());
-    // The second stream should see the new picker
-    verify(picker2, timeout(5000)).pickSubchannel(callOptions.getAffinity(), headers2);
-
-    // Wrapping up
-    verify(picker, times(2)).pickSubchannel(callOptions.getAffinity(), headers);
-    verify(picker).pickSubchannel(callOptions.getAffinity(), headers2);
-    verify(picker2).pickSubchannel(callOptions.getAffinity(), headers);
-    verify(picker2).pickSubchannel(callOptions.getAffinity(), headers2);
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/DelayedClientTransportTest.java b/core/src/test/java/io/grpc/internal/DelayedClientTransportTest.java
index 189f1596723..d7e1d4ca4f6 100644
--- a/core/src/test/java/io/grpc/internal/DelayedClientTransportTest.java
+++ b/core/src/test/java/io/grpc/internal/DelayedClientTransportTest.java
@@ -1,127 +1,142 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.PickSubchannelArgsMatcher.eqPickSubchannelArgs;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
-import com.google.common.base.Supplier;
-import io.grpc.Attributes;
 import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
 import io.grpc.IntegerMarshaller;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.SubchannelPicker;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.SubchannelPicker;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.PickSubchannelArgsMatcher;
 import io.grpc.Status;
 import io.grpc.StringMarshaller;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.concurrent.Executor;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
 import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
 
 /**
  * Unit tests for {@link DelayedClientTransport}.
  */
 @RunWith(JUnit4.class)
 public class DelayedClientTransportTest {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
   @Mock private ManagedClientTransport.Listener transportListener;
+  @Mock private SubchannelPicker mockPicker;
+  @Mock private AbstractSubchannel mockSubchannel;
+  @Mock private TransportProvider mockInternalSubchannel;
   @Mock private ClientTransport mockRealTransport;
   @Mock private ClientTransport mockRealTransport2;
   @Mock private ClientStream mockRealStream;
   @Mock private ClientStream mockRealStream2;
   @Mock private ClientStreamListener streamListener;
-  @Mock private ClientTransport.PingCallback pingCallback;
-  @Mock private Executor mockExecutor;
   @Captor private ArgumentCaptor<Status> statusCaptor;
   @Captor private ArgumentCaptor<ClientStreamListener> listenerCaptor;
 
-  private static final Attributes.Key<Integer> SHARD_ID = Attributes.Key.of("shard-id");
+  private static final CallOptions.Key<Integer> SHARD_ID
+      = CallOptions.Key.createWithDefault("shard-id", -1);
+  private static final Status SHUTDOWN_STATUS =
+      Status.UNAVAILABLE.withDescription("shutdown called");
+  private static final ClientStreamTracer[] tracers = new ClientStreamTracer[] {
+      new ClientStreamTracer() {}
+  };
 
   private final MethodDescriptor<String, Integer> method =
       MethodDescriptor.<String, Integer>newBuilder()
           .setType(MethodType.UNKNOWN)
-          .setFullMethodName("/service/method")
+          .setFullMethodName("service/method")
           .setRequestMarshaller(new StringMarshaller())
           .setResponseMarshaller(new IntegerMarshaller())
           .build();
   private final MethodDescriptor<String, Integer> method2 =
-      method.toBuilder().setFullMethodName("/service/method2").build();
+      method.toBuilder().setFullMethodName("service/method").build();
   private final Metadata headers = new Metadata();
   private final Metadata headers2 = new Metadata();
 
   private final CallOptions callOptions = CallOptions.DEFAULT.withAuthority("dummy_value");
   private final CallOptions callOptions2 = CallOptions.DEFAULT.withAuthority("dummy_value2");
-  private final StatsTraceContext statsTraceCtx = StatsTraceContext.newClientContext(
-      method.getFullMethodName(), NoopStatsContextFactory.INSTANCE,
-      GrpcUtil.STOPWATCH_SUPPLIER);
-  private final StatsTraceContext statsTraceCtx2 = StatsTraceContext.newClientContext(
-      method2.getFullMethodName(), NoopStatsContextFactory.INSTANCE,
-      GrpcUtil.STOPWATCH_SUPPLIER);
 
   private final FakeClock fakeExecutor = new FakeClock();
 
-  private final DelayedClientTransport delayedTransport =
-      new DelayedClientTransport(fakeExecutor.getScheduledExecutorService());
+  private final DelayedClientTransport delayedTransport = new DelayedClientTransport(
+      fakeExecutor.getScheduledExecutorService(),
+      new SynchronizationContext(
+          new Thread.UncaughtExceptionHandler() {
+            @Override
+            public void uncaughtException(Thread t, Throwable e) {
+              throw new AssertionError(e);
+            }
+          }));
 
   @Before public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    when(mockRealTransport.newStream(same(method), same(headers), same(callOptions),
-            same(statsTraceCtx)))
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(mockSubchannel));
+    when(mockSubchannel.getInternalSubchannel()).thenReturn(mockInternalSubchannel);
+    when(mockInternalSubchannel.obtainActiveTransport()).thenReturn(mockRealTransport);
+    when(mockRealTransport.newStream(
+            same(method), same(headers), same(callOptions),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockRealStream);
-    when(mockRealTransport2.newStream(same(method2), same(headers2), same(callOptions2),
-            same(statsTraceCtx2)))
+    when(mockRealTransport2.newStream(
+            same(method2), same(headers2), same(callOptions2),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
         .thenReturn(mockRealStream2);
     delayedTransport.start(transportListener);
   }
@@ -130,39 +145,22 @@ public class DelayedClientTransportTest {
     assertEquals(0, fakeExecutor.numPendingTasks());
   }
 
-  @Test public void transportsAreUsedInOrder() {
-    delayedTransport.newStream(method, headers, callOptions, statsTraceCtx);
-    delayedTransport.newStream(method2, headers2, callOptions2, statsTraceCtx2);
-    assertEquals(0, fakeExecutor.numPendingTasks());
-    delayedTransport.setTransportSupplier(new Supplier<ClientTransport>() {
-        final Iterator<ClientTransport> it =
-            Arrays.asList(mockRealTransport, mockRealTransport2).iterator();
-
-        @Override public ClientTransport get() {
-          return it.next();
-        }
-      });
-    assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockRealTransport).newStream(same(method), same(headers), same(callOptions),
-        same(statsTraceCtx));
-    verify(mockRealTransport2).newStream(same(method2), same(headers2), same(callOptions2),
-        same(statsTraceCtx2));
-  }
-
-  @Test public void streamStartThenSetTransport() {
+  @Test public void streamStartThenAssignTransport() {
     assertFalse(delayedTransport.hasPendingStreams());
-    ClientStream stream = delayedTransport.newStream(method, headers, callOptions, statsTraceCtx);
+    ClientStream stream = delayedTransport.newStream(
+        method, headers, callOptions, tracers);
     stream.start(streamListener);
     assertEquals(1, delayedTransport.getPendingStreamsCount());
     assertTrue(delayedTransport.hasPendingStreams());
     assertTrue(stream instanceof DelayedStream);
     assertEquals(0, fakeExecutor.numPendingTasks());
-    delayedTransport.setTransport(mockRealTransport);
+    delayedTransport.reprocess(mockPicker);
     assertEquals(0, delayedTransport.getPendingStreamsCount());
     assertFalse(delayedTransport.hasPendingStreams());
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockRealTransport).newStream(same(method), same(headers), same(callOptions),
-        same(statsTraceCtx));
+    verify(mockRealTransport).newStream(
+        same(method), same(headers), same(callOptions),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     verify(mockRealStream).start(listenerCaptor.capture());
     verifyNoMoreInteractions(streamListener);
     listenerCaptor.getValue().onReady();
@@ -170,84 +168,123 @@ public class DelayedClientTransportTest {
     verifyNoMoreInteractions(streamListener);
   }
 
-  @Test public void newStreamThenSetTransportThenShutdown() {
-    ClientStream stream = delayedTransport.newStream(method, headers, callOptions, statsTraceCtx);
+  @Test public void newStreamThenAssignTransportThenShutdown() {
+    ClientStream stream = delayedTransport.newStream(method, headers, callOptions, tracers);
     assertEquals(1, delayedTransport.getPendingStreamsCount());
     assertTrue(stream instanceof DelayedStream);
-    delayedTransport.setTransport(mockRealTransport);
+    delayedTransport.reprocess(mockPicker);
     assertEquals(0, delayedTransport.getPendingStreamsCount());
-    delayedTransport.shutdown();
-    verify(transportListener).transportShutdown(any(Status.class));
+    delayedTransport.shutdown(SHUTDOWN_STATUS);
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener).transportTerminated();
-    assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockRealTransport).newStream(same(method), same(headers), same(callOptions),
-        same(statsTraceCtx));
+    assertEquals(0, fakeExecutor.runDueTasks());
+    verify(mockRealTransport).newStream(
+        same(method), same(headers), same(callOptions),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     stream.start(streamListener);
     verify(mockRealStream).start(same(streamListener));
   }
 
-  @Test public void transportTerminatedThenSetTransport() {
-    delayedTransport.shutdown();
-    verify(transportListener).transportShutdown(any(Status.class));
+  @Test public void transportTerminatedThenAssignTransport() {
+    delayedTransport.shutdown(SHUTDOWN_STATUS);
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener).transportTerminated();
-    delayedTransport.setTransport(mockRealTransport);
+    delayedTransport.reprocess(mockPicker);
     verifyNoMoreInteractions(transportListener);
   }
 
-  @Test public void setTransportThenShutdownThenNewStream() {
-    delayedTransport.setTransport(mockRealTransport);
-    delayedTransport.shutdown();
-    verify(transportListener).transportShutdown(any(Status.class));
+  @Test public void assignTransportThenShutdownThenNewStream() {
+    delayedTransport.reprocess(mockPicker);
+    delayedTransport.shutdown(SHUTDOWN_STATUS);
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener).transportTerminated();
-    ClientStream stream = delayedTransport.newStream(method, headers, callOptions, statsTraceCtx);
+    ClientStream stream = delayedTransport.newStream(
+        method, headers, callOptions, tracers);
     assertEquals(0, delayedTransport.getPendingStreamsCount());
-    stream.start(streamListener);
-    assertFalse(stream instanceof DelayedStream);
-    verify(mockRealTransport).newStream(same(method), same(headers), same(callOptions),
-        same(statsTraceCtx));
-    verify(mockRealStream).start(same(streamListener));
+    assertTrue(stream instanceof FailingClientStream);
+    verify(mockRealTransport, never()).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
   }
 
-  @Test public void setTransportThenShutdownNowThenNewStream() {
-    delayedTransport.setTransport(mockRealTransport);
+  @Test public void assignTransportThenShutdownNowThenNewStream() {
+    delayedTransport.reprocess(mockPicker);
     delayedTransport.shutdownNow(Status.UNAVAILABLE);
-    verify(transportListener).transportShutdown(any(Status.class));
+    verify(transportListener).transportShutdown(any(Status.class),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener).transportTerminated();
-    ClientStream stream = delayedTransport.newStream(method, headers, callOptions, statsTraceCtx);
+    ClientStream stream = delayedTransport.newStream(
+        method, headers, callOptions, tracers);
     assertEquals(0, delayedTransport.getPendingStreamsCount());
-    stream.start(streamListener);
-    assertFalse(stream instanceof DelayedStream);
-    verify(mockRealTransport).newStream(same(method), same(headers), same(callOptions),
-        same(statsTraceCtx));
-    verify(mockRealStream).start(same(streamListener));
+    assertTrue(stream instanceof FailingClientStream);
+    verify(mockRealTransport, never()).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
   }
 
-  @Test public void cancelStreamWithoutSetTransport() {
-    ClientStream stream = delayedTransport.newStream(method, new Metadata());
+  @Test public void startThenCancelStreamWithoutSetTransport() {
+    ClientStream stream = delayedTransport.newStream(
+        method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream.start(streamListener);
     assertEquals(1, delayedTransport.getPendingStreamsCount());
     stream.cancel(Status.CANCELLED);
     assertEquals(0, delayedTransport.getPendingStreamsCount());
+    verify(streamListener).closed(
+        same(Status.CANCELLED), same(RpcProgress.PROCESSED), any(Metadata.class));
     verifyNoMoreInteractions(mockRealTransport);
     verifyNoMoreInteractions(mockRealStream);
   }
 
-  @Test public void startThenCancelStreamWithoutSetTransport() {
-    ClientStream stream = delayedTransport.newStream(method, new Metadata());
+  @Test public void newStreamThenShutdownTransportThenAssignTransport() {
+    ClientStream stream = delayedTransport.newStream(
+        method, headers, callOptions, tracers);
     stream.start(streamListener);
+    delayedTransport.shutdown(SHUTDOWN_STATUS);
+
+    // Stream is still buffered
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
+    verify(transportListener, times(0)).transportTerminated();
     assertEquals(1, delayedTransport.getPendingStreamsCount());
-    stream.cancel(Status.CANCELLED);
+
+    // ... and will proceed if a real transport is available
+    delayedTransport.reprocess(mockPicker);
+    fakeExecutor.runDueTasks();
+    verify(mockRealTransport).newStream(
+        method, headers, callOptions, tracers);
+    verify(mockRealStream).start(any(ClientStreamListener.class));
+
+    // Since no more streams are pending, delayed transport is now terminated
+    assertEquals(0, delayedTransport.getPendingStreamsCount());
+    verify(transportListener).transportTerminated();
+
+    // Further newStream() will return a failing stream
+    stream = delayedTransport.newStream(
+        method, new Metadata(), CallOptions.DEFAULT, tracers);
+    verify(streamListener, never()).closed(
+        any(Status.class), any(RpcProgress.class), any(Metadata.class));
+    stream.start(streamListener);
+    verify(streamListener).closed(
+        statusCaptor.capture(), any(RpcProgress.class), any(Metadata.class));
+    assertEquals(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
+
     assertEquals(0, delayedTransport.getPendingStreamsCount());
-    verify(streamListener).closed(same(Status.CANCELLED), any(Metadata.class));
     verifyNoMoreInteractions(mockRealTransport);
     verifyNoMoreInteractions(mockRealStream);
   }
 
   @Test public void newStreamThenShutdownTransportThenCancelStream() {
-    ClientStream stream = delayedTransport.newStream(method, new Metadata());
-    delayedTransport.shutdown();
-    verify(transportListener).transportShutdown(any(Status.class));
+    ClientStream stream = delayedTransport.newStream(
+        method, new Metadata(), CallOptions.DEFAULT, tracers);
+    delayedTransport.shutdown(SHUTDOWN_STATUS);
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener, times(0)).transportTerminated();
     assertEquals(1, delayedTransport.getPendingStreamsCount());
+    stream.start(streamListener);
     stream.cancel(Status.CANCELLED);
     verify(transportListener).transportTerminated();
     assertEquals(0, delayedTransport.getPendingStreamsCount());
@@ -255,157 +292,114 @@ public class DelayedClientTransportTest {
     verifyNoMoreInteractions(mockRealStream);
   }
 
-  @Test public void setTransportThenShutdownThenPing() {
-    delayedTransport.setTransport(mockRealTransport);
-    delayedTransport.shutdown();
-    delayedTransport.ping(pingCallback, mockExecutor);
-    verify(mockRealTransport).ping(same(pingCallback), same(mockExecutor));
-  }
-
-  @Test public void pingThenSetTransport() {
-    delayedTransport.ping(pingCallback, mockExecutor);
-    delayedTransport.setTransport(mockRealTransport);
-    verify(mockRealTransport).ping(same(pingCallback), same(mockExecutor));
-  }
-
-  @Test public void shutdownThenPing() {
-    delayedTransport.shutdown();
-    verify(transportListener).transportShutdown(any(Status.class));
-    verify(transportListener).transportTerminated();
-    delayedTransport.ping(pingCallback, mockExecutor);
-    verifyNoMoreInteractions(pingCallback);
-    ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(mockExecutor).execute(runnableCaptor.capture());
-    runnableCaptor.getValue().run();
-    verify(pingCallback).onFailure(any(Throwable.class));
-  }
-
   @Test public void shutdownThenNewStream() {
-    delayedTransport.shutdown();
-    verify(transportListener).transportShutdown(any(Status.class));
+    delayedTransport.shutdown(SHUTDOWN_STATUS);
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener).transportTerminated();
-    ClientStream stream = delayedTransport.newStream(method, new Metadata());
+    ClientStream stream = delayedTransport.newStream(
+        method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(streamListener);
-    verify(streamListener).closed(statusCaptor.capture(), any(Metadata.class));
+    verify(streamListener).closed(
+        statusCaptor.capture(), any(RpcProgress.class), any(Metadata.class));
     assertEquals(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
   }
 
   @Test public void startStreamThenShutdownNow() {
-    ClientStream stream = delayedTransport.newStream(method, new Metadata());
+    ClientStream stream = delayedTransport.newStream(
+        method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(streamListener);
     delayedTransport.shutdownNow(Status.UNAVAILABLE);
-    verify(transportListener).transportShutdown(any(Status.class));
+    verify(transportListener).transportShutdown(any(Status.class),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener).transportTerminated();
-    verify(streamListener).closed(statusCaptor.capture(), any(Metadata.class));
+    verify(streamListener)
+        .closed(statusCaptor.capture(), eq(RpcProgress.REFUSED), any(Metadata.class));
     assertEquals(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
   }
 
   @Test public void shutdownNowThenNewStream() {
     delayedTransport.shutdownNow(Status.UNAVAILABLE);
-    verify(transportListener).transportShutdown(any(Status.class));
+    verify(transportListener).transportShutdown(any(Status.class),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener).transportTerminated();
-    ClientStream stream = delayedTransport.newStream(method, new Metadata());
+    ClientStream stream = delayedTransport.newStream(
+        method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(streamListener);
-    verify(streamListener).closed(statusCaptor.capture(), any(Metadata.class));
+    verify(streamListener).closed(
+        statusCaptor.capture(), any(RpcProgress.class), any(Metadata.class));
     assertEquals(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
   }
 
-  @Test public void startBackOff_ClearsFailFastPendingStreams() {
-    final Status cause = Status.UNAVAILABLE.withDescription("some error when connecting");
-    final CallOptions failFastCallOptions = CallOptions.DEFAULT;
-    final CallOptions waitForReadyCallOptions = CallOptions.DEFAULT.withWaitForReady();
-    final ClientStream ffStream = delayedTransport.newStream(method, headers, failFastCallOptions,
-        statsTraceCtx);
-    ffStream.start(streamListener);
-    delayedTransport.newStream(method, headers, waitForReadyCallOptions, statsTraceCtx);
-    delayedTransport.newStream(method, headers, failFastCallOptions, statsTraceCtx);
-    assertEquals(3, delayedTransport.getPendingStreamsCount());
-
-    delayedTransport.startBackoff(cause);
-    assertTrue(delayedTransport.isInBackoffPeriod());
-    assertEquals(1, delayedTransport.getPendingStreamsCount());
-
-    // Fail fast stream not failed yet.
-    verify(streamListener, never()).closed(any(Status.class), any(Metadata.class));
-
-    fakeExecutor.runDueTasks();
-    // Now fail fast stream failed.
-    verify(streamListener).closed(same(cause), any(Metadata.class));
-  }
-
-  @Test public void startBackOff_FailsFutureFailFastStreams() {
-    final Status cause = Status.UNAVAILABLE.withDescription("some error when connecting");
-    final CallOptions failFastCallOptions = CallOptions.DEFAULT;
-    final CallOptions waitForReadyCallOptions = CallOptions.DEFAULT.withWaitForReady();
-    delayedTransport.startBackoff(cause);
-    assertTrue(delayedTransport.isInBackoffPeriod());
-
-    final ClientStream ffStream = delayedTransport.newStream(method, headers, failFastCallOptions,
-        statsTraceCtx);
-    ffStream.start(streamListener);
-    assertEquals(0, delayedTransport.getPendingStreamsCount());
-    verify(streamListener).closed(statusCaptor.capture(), any(Metadata.class));
-    assertEquals(cause, Status.fromThrowable(statusCaptor.getValue().getCause()));
-
-    delayedTransport.newStream(method, headers, waitForReadyCallOptions, statsTraceCtx);
-    assertEquals(1, delayedTransport.getPendingStreamsCount());
-  }
-
-  @Test public void startBackoff_DoNothingIfAlreadyShutDown() {
-    delayedTransport.shutdown();
-
-    final Status cause = Status.UNAVAILABLE.withDescription("some error when connecting");
-    delayedTransport.startBackoff(cause);
-
-    assertFalse(delayedTransport.isInBackoffPeriod());
-  }
-
-  @Test public void reprocess() {
-    Attributes affinity1 = Attributes.newBuilder().set(SHARD_ID, 1).build();
-    Attributes affinity2 = Attributes.newBuilder().set(SHARD_ID, 2).build();
-    CallOptions failFastCallOptions = CallOptions.DEFAULT.withAffinity(affinity1);
-    CallOptions waitForReadyCallOptions =
-        CallOptions.DEFAULT.withWaitForReady().withAffinity(affinity2);
-
-    SubchannelImpl subchannel1 = mock(SubchannelImpl.class);
-    SubchannelImpl subchannel2 = mock(SubchannelImpl.class);
-    SubchannelImpl subchannel3 = mock(SubchannelImpl.class);
-    when(mockRealTransport.newStream(any(MethodDescriptor.class), any(Metadata.class),
-            any(CallOptions.class), same(statsTraceCtx))).thenReturn(mockRealStream);
-    when(mockRealTransport2.newStream(any(MethodDescriptor.class), any(Metadata.class),
-            any(CallOptions.class), same(statsTraceCtx))).thenReturn(mockRealStream2);
-    when(subchannel1.obtainActiveTransport()).thenReturn(mockRealTransport);
-    when(subchannel2.obtainActiveTransport()).thenReturn(mockRealTransport2);
-    when(subchannel3.obtainActiveTransport()).thenReturn(null);
+  @Test public void reprocessSemantics() {
+    CallOptions failFastCallOptions = CallOptions.DEFAULT.withOption(SHARD_ID, 1);
+    CallOptions waitForReadyCallOptions = CallOptions.DEFAULT.withOption(SHARD_ID, 2)
+        .withWaitForReady();
+
+    AbstractSubchannel subchannel1 = mock(AbstractSubchannel.class);
+    AbstractSubchannel subchannel2 = mock(AbstractSubchannel.class);
+    AbstractSubchannel subchannel3 = mock(AbstractSubchannel.class);
+    when(mockRealTransport.newStream(
+            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockRealStream);
+    when(mockRealTransport2.newStream(
+            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockRealStream2);
+    when(subchannel1.getInternalSubchannel()).thenReturn(newTransportProvider(mockRealTransport));
+    when(subchannel2.getInternalSubchannel()).thenReturn(newTransportProvider(mockRealTransport2));
+    when(subchannel3.getInternalSubchannel()).thenReturn(newTransportProvider(null));
 
     // Fail-fast streams
     DelayedStream ff1 = (DelayedStream) delayedTransport.newStream(
-        method, headers, failFastCallOptions, statsTraceCtx);
+        method, headers, failFastCallOptions, tracers);
+    ff1.start(mock(ClientStreamListener.class));
+    ff1.halfClose();
+    PickSubchannelArgsMatcher ff1args = new PickSubchannelArgsMatcher(method, headers,
+        failFastCallOptions);
     verify(transportListener).transportInUse(true);
     DelayedStream ff2 = (DelayedStream) delayedTransport.newStream(
-        method2, headers2, failFastCallOptions, statsTraceCtx);
+        method2, headers2, failFastCallOptions, tracers);
+    PickSubchannelArgsMatcher ff2args = new PickSubchannelArgsMatcher(method2, headers2,
+        failFastCallOptions);
     DelayedStream ff3 = (DelayedStream) delayedTransport.newStream(
-        method, headers, failFastCallOptions, statsTraceCtx);
+        method, headers, failFastCallOptions, tracers);
+    PickSubchannelArgsMatcher ff3args = new PickSubchannelArgsMatcher(method, headers,
+        failFastCallOptions);
     DelayedStream ff4 = (DelayedStream) delayedTransport.newStream(
-        method2, headers2, failFastCallOptions, statsTraceCtx);
+        method2, headers2, failFastCallOptions, tracers);
+    PickSubchannelArgsMatcher ff4args = new PickSubchannelArgsMatcher(method2, headers2,
+        failFastCallOptions);
 
     // Wait-for-ready streams
     FakeClock wfr3Executor = new FakeClock();
     DelayedStream wfr1 = (DelayedStream) delayedTransport.newStream(
-        method, headers, waitForReadyCallOptions, statsTraceCtx);
+        method, headers, waitForReadyCallOptions, tracers);
+    PickSubchannelArgsMatcher wfr1args = new PickSubchannelArgsMatcher(method, headers,
+        waitForReadyCallOptions);
     DelayedStream wfr2 = (DelayedStream) delayedTransport.newStream(
-        method2, headers2, waitForReadyCallOptions, statsTraceCtx);
+        method2, headers2, waitForReadyCallOptions, tracers);
+    PickSubchannelArgsMatcher wfr2args = new PickSubchannelArgsMatcher(method2, headers2,
+        waitForReadyCallOptions);
+    CallOptions wfr3callOptions = waitForReadyCallOptions.withExecutor(
+        wfr3Executor.getScheduledExecutorService());
     DelayedStream wfr3 = (DelayedStream) delayedTransport.newStream(
-        method, headers,
-        waitForReadyCallOptions.withExecutor(wfr3Executor.getScheduledExecutorService()),
-        statsTraceCtx);
+        method, headers, wfr3callOptions, tracers);
+    wfr3.start(mock(ClientStreamListener.class));
+    wfr3.halfClose();
+    PickSubchannelArgsMatcher wfr3args = new PickSubchannelArgsMatcher(method, headers,
+        wfr3callOptions);
     DelayedStream wfr4 = (DelayedStream) delayedTransport.newStream(
-        method2, headers2, waitForReadyCallOptions, statsTraceCtx);
+        method2, headers2, waitForReadyCallOptions, tracers);
+    PickSubchannelArgsMatcher wfr4args = new PickSubchannelArgsMatcher(method2, headers2,
+        waitForReadyCallOptions);
+
     assertEquals(8, delayedTransport.getPendingStreamsCount());
 
     // First reprocess(). Some will proceed, some will fail and the rest will stay buffered.
     SubchannelPicker picker = mock(SubchannelPicker.class);
-    when(picker.pickSubchannel(any(Attributes.class), any(Metadata.class))).thenReturn(
+    when(picker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(
         // For the fail-fast streams
         PickResult.withSubchannel(subchannel1),    // ff1: proceed
         PickResult.withError(Status.UNAVAILABLE),  // ff2: fail
@@ -414,33 +408,39 @@ public class DelayedClientTransportTest {
         // For the wait-for-ready streams
         PickResult.withSubchannel(subchannel2),           // wfr1: proceed
         PickResult.withError(Status.RESOURCE_EXHAUSTED),  // wfr2: stay
-        PickResult.withSubchannel(subchannel3),           // wfr3: stay
-        PickResult.withNoResult());                       // wfr4: stay
+        PickResult.withSubchannel(subchannel3));          // wfr3: stay
     InOrder inOrder = inOrder(picker);
     delayedTransport.reprocess(picker);
 
     assertEquals(5, delayedTransport.getPendingStreamsCount());
-    inOrder.verify(picker).pickSubchannel(affinity1, headers);  // ff1
-    inOrder.verify(picker).pickSubchannel(affinity1, headers2);  // ff2
-    inOrder.verify(picker).pickSubchannel(affinity1, headers);  // ff3
-    inOrder.verify(picker).pickSubchannel(affinity1, headers2);  // ff4
-    inOrder.verify(picker).pickSubchannel(affinity2, headers);  // wfr1
-    inOrder.verify(picker).pickSubchannel(affinity2, headers2);  // wfr2
-    inOrder.verify(picker).pickSubchannel(affinity2, headers);  // wfr3
-    inOrder.verify(picker).pickSubchannel(affinity2, headers2);  // wfr4
+    inOrder.verify(picker).pickSubchannel(argThat(ff1args));
+    inOrder.verify(picker).pickSubchannel(argThat(ff2args));
+    inOrder.verify(picker).pickSubchannel(argThat(ff3args));
+    inOrder.verify(picker).pickSubchannel(argThat(ff4args));
+    inOrder.verify(picker).pickSubchannel(argThat(wfr1args));
+    inOrder.verify(picker).pickSubchannel(argThat(wfr2args));
+    inOrder.verify(picker).pickSubchannel(argThat(wfr3args));
+    inOrder.verify(picker).pickSubchannel(argThat(wfr4args));
+
     inOrder.verifyNoMoreInteractions();
-    // Make sure that real transport creates streams in the executor
-    verify(mockRealTransport, never()).newStream(any(MethodDescriptor.class),
-        any(Metadata.class), any(CallOptions.class), any(StatsTraceContext.class));
-    verify(mockRealTransport2, never()).newStream(any(MethodDescriptor.class),
-        any(Metadata.class), any(CallOptions.class), any(StatsTraceContext.class));
-    fakeExecutor.runDueTasks();
-    assertEquals(0, fakeExecutor.numPendingTasks());
+    // Make sure that streams are created and started immediately, not in any executor. This is
+    // necessary during shut down to guarantee that when DelayedClientTransport terminates, all
+    // streams are now owned by a real transport (which should prevent the Channel from
+    // terminating).
     // ff1 and wfr1 went through
-    verify(mockRealTransport).newStream(method, headers, failFastCallOptions, statsTraceCtx);
-    verify(mockRealTransport2).newStream(method, headers, waitForReadyCallOptions, statsTraceCtx);
+    verify(mockRealTransport).newStream(
+        method, headers, failFastCallOptions, tracers);
+    verify(mockRealTransport2).newStream(
+        method, headers, waitForReadyCallOptions, tracers);
     assertSame(mockRealStream, ff1.getRealStream());
     assertSame(mockRealStream2, wfr1.getRealStream());
+    verify(mockRealStream).start(any(ClientStreamListener.class));
+    // But also verify that non-start()-related calls are run within the Executor, since they may be
+    // slow.
+    verify(mockRealStream, never()).halfClose();
+    fakeExecutor.runDueTasks();
+    assertEquals(0, fakeExecutor.numPendingTasks());
+    verify(mockRealStream).halfClose();
     // The ff2 has failed due to picker returning an error
     assertSame(Status.UNAVAILABLE, ((FailingClientStream) ff2.getRealStream()).getError());
     // Other streams are still buffered
@@ -450,14 +450,15 @@ public class DelayedClientTransportTest {
     assertNull(wfr3.getRealStream());
     assertNull(wfr4.getRealStream());
 
-    // Second reprocess(). All will proceed.
+    // Second reprocess(). All existing streams will proceed.
     picker = mock(SubchannelPicker.class);
-    when(picker.pickSubchannel(any(Attributes.class), any(Metadata.class))).thenReturn(
+    when(picker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(
         PickResult.withSubchannel(subchannel1),  // ff3
         PickResult.withSubchannel(subchannel2),  // ff4
         PickResult.withSubchannel(subchannel2),  // wfr2
         PickResult.withSubchannel(subchannel1),  // wfr3
-        PickResult.withSubchannel(subchannel2));  // wfr4
+        PickResult.withSubchannel(subchannel2),  // wfr4
+        PickResult.withNoResult());              // wfr5 (not yet created)
     inOrder = inOrder(picker);
     assertEquals(0, wfr3Executor.numPendingTasks());
     verify(transportListener, never()).transportInUse(false);
@@ -465,11 +466,11 @@ public class DelayedClientTransportTest {
     delayedTransport.reprocess(picker);
     assertEquals(0, delayedTransport.getPendingStreamsCount());
     verify(transportListener).transportInUse(false);
-    inOrder.verify(picker).pickSubchannel(affinity1, headers);  // ff3
-    inOrder.verify(picker).pickSubchannel(affinity1, headers2);  // ff4
-    inOrder.verify(picker).pickSubchannel(affinity2, headers2);  // wfr2
-    inOrder.verify(picker).pickSubchannel(affinity2, headers);  // wfr3
-    inOrder.verify(picker).pickSubchannel(affinity2, headers2);  // wfr4
+    inOrder.verify(picker).pickSubchannel(argThat(ff3args));  // ff3
+    inOrder.verify(picker).pickSubchannel(argThat(ff4args));  // ff4
+    inOrder.verify(picker).pickSubchannel(argThat(wfr2args));  // wfr2
+    inOrder.verify(picker).pickSubchannel(argThat(wfr3args));  // wfr3
+    inOrder.verify(picker).pickSubchannel(argThat(wfr4args));  // wfr4
     inOrder.verifyNoMoreInteractions();
     fakeExecutor.runDueTasks();
     assertEquals(0, fakeExecutor.numPendingTasks());
@@ -478,33 +479,305 @@ public class DelayedClientTransportTest {
     assertSame(mockRealStream2, wfr2.getRealStream());
     assertSame(mockRealStream2, wfr4.getRealStream());
 
-    // If there is an executor in the CallOptions, it will be used to create the real tream.
-    assertNull(wfr3.getRealStream());
-    wfr3Executor.runDueTasks();
     assertSame(mockRealStream, wfr3.getRealStream());
+    // If there is an executor in the CallOptions, it will be used to create the real stream.
+    verify(mockRealStream, times(1)).halfClose(); // 1 for ff1
+    wfr3Executor.runDueTasks();
+    verify(mockRealStream, times(2)).halfClose();
 
-    // Make sure the delayed transport still accepts new streams
+    // New streams will use the last picker
     DelayedStream wfr5 = (DelayedStream) delayedTransport.newStream(
-        method, headers, waitForReadyCallOptions, statsTraceCtx);
+        method, headers, waitForReadyCallOptions, tracers);
     assertNull(wfr5.getRealStream());
+    inOrder.verify(picker).pickSubchannel(
+        eqPickSubchannelArgs(method, headers, waitForReadyCallOptions));
+    inOrder.verifyNoMoreInteractions();
     assertEquals(1, delayedTransport.getPendingStreamsCount());
 
     // wfr5 will stop delayed transport from terminating
-    delayedTransport.shutdown();
-    verify(transportListener).transportShutdown(any(Status.class));
+    delayedTransport.shutdown(SHUTDOWN_STATUS);
+    verify(transportListener).transportShutdown(same(SHUTDOWN_STATUS),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
     verify(transportListener, never()).transportTerminated();
     // ... until it's gone
+    picker = mock(SubchannelPicker.class);
+    when(picker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(
+        PickResult.withSubchannel(subchannel1));
     delayedTransport.reprocess(picker);
+    verify(picker).pickSubchannel(
+        eqPickSubchannelArgs(method, headers, waitForReadyCallOptions));
     fakeExecutor.runDueTasks();
+    assertSame(mockRealStream, wfr5.getRealStream());
     assertEquals(0, delayedTransport.getPendingStreamsCount());
     verify(transportListener).transportTerminated();
   }
 
+  @Test
+  public void reprocess_authorityOverrideFromLb() {
+    InOrder inOrder = inOrder(mockRealStream);
+    DelayedStream delayedStream = (DelayedStream) delayedTransport.newStream(
+        method, headers, callOptions.withAuthority(null), tracers);
+    delayedStream.setAuthority("authority-override-from-calloptions");
+    delayedStream.start(mock(ClientStreamListener.class));
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    PickResult pickResult = PickResult.withSubchannel(
+        mockSubchannel, null, "authority-override-hostname-from-lb");
+    when(picker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(pickResult);
+    when(mockRealTransport.newStream(
+        same(method), same(headers), any(CallOptions.class),
+        ArgumentMatchers.any()))
+        .thenReturn(mockRealStream);
+
+    delayedTransport.reprocess(picker);
+    fakeExecutor.runDueTasks();
+
+    // Must be set before start(), and may be overwritten
+    inOrder.verify(mockRealStream).setAuthority("authority-override-hostname-from-lb");
+    inOrder.verify(mockRealStream).setAuthority("authority-override-from-calloptions");
+    inOrder.verify(mockRealStream).start(any(ClientStreamListener.class));
+  }
+
   @Test
   public void reprocess_NoPendingStream() {
     SubchannelPicker picker = mock(SubchannelPicker.class);
+    AbstractSubchannel subchannel = mock(AbstractSubchannel.class);
+    when(subchannel.getInternalSubchannel()).thenReturn(mockInternalSubchannel);
+    when(picker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(
+        PickResult.withSubchannel(subchannel));
+    when(mockRealTransport.newStream(
+            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockRealStream);
     delayedTransport.reprocess(picker);
     verifyNoMoreInteractions(picker);
     verifyNoMoreInteractions(transportListener);
+
+    // Though picker was not originally used, it will be saved and serve future streams.
+    ClientStream stream = delayedTransport.newStream(
+        method, headers, CallOptions.DEFAULT, tracers);
+    verify(picker).pickSubchannel(eqPickSubchannelArgs(method, headers, CallOptions.DEFAULT));
+    verify(mockInternalSubchannel).obtainActiveTransport();
+    assertSame(mockRealStream, stream);
+  }
+
+  @Test
+  public void newStream_authorityOverrideFromLb() {
+    InOrder inOrder = inOrder(mockRealStream);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    PickResult pickResult = PickResult.withSubchannel(
+        mockSubchannel, null, "authority-override-hostname-from-lb");
+    when(picker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(pickResult);
+    when(mockRealTransport.newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class), any()))
+        .thenReturn(mockRealStream);
+    delayedTransport.reprocess(picker);
+
+    ClientStream stream = delayedTransport.newStream(method, headers, callOptions, tracers);
+    assertThat(stream).isSameInstanceAs(mockRealStream);
+    stream.setAuthority("authority-override-from-calloptions");
+    stream.start(mock(ClientStreamListener.class));
+
+    // Must be set before start(), and may be overwritten
+    inOrder.verify(mockRealStream).setAuthority("authority-override-hostname-from-lb");
+    inOrder.verify(mockRealStream).setAuthority("authority-override-from-calloptions");
+    inOrder.verify(mockRealStream).start(any(ClientStreamListener.class));
+  }
+
+  @Test
+  public void newStream_assignsTransport_authorityFromLB() {
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    AbstractSubchannel subchannel = mock(AbstractSubchannel.class);
+    when(subchannel.getInternalSubchannel()).thenReturn(mockInternalSubchannel);
+    PickResult pickResult = PickResult.withSubchannel(
+        subchannel, null, "authority-override-hostname-from-lb");
+    when(picker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(pickResult);
+    ArgumentCaptor<CallOptions> callOptionsArgumentCaptor =
+        ArgumentCaptor.forClass(CallOptions.class);
+    when(mockRealTransport.newStream(
+        any(MethodDescriptor.class), any(Metadata.class), callOptionsArgumentCaptor.capture(),
+        ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockRealStream);
+    delayedTransport.reprocess(picker);
+    verifyNoMoreInteractions(picker);
+    verifyNoMoreInteractions(transportListener);
+
+    CallOptions callOptions = CallOptions.DEFAULT;
+    delayedTransport.newStream(method, headers, callOptions, tracers);
+    assertThat(callOptionsArgumentCaptor.getValue().getAuthority()).isEqualTo(
+        "authority-override-hostname-from-lb");
+  }
+
+  @Test
+  public void reprocess_newStreamRacesWithReprocess() throws Exception {
+    final CyclicBarrier barrier = new CyclicBarrier(2);
+    // In both phases, we only expect the first pickSubchannel() call to block on the barrier.
+    final AtomicBoolean nextPickShouldWait = new AtomicBoolean(true);
+    ///////// Phase 1: reprocess() twice with the same picker
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+
+    doAnswer(new Answer<PickResult>() {
+        @Override
+        @SuppressWarnings("CatchAndPrintStackTrace")
+        public PickResult answer(InvocationOnMock invocation) throws Throwable {
+          if (nextPickShouldWait.compareAndSet(true, false)) {
+            try {
+              barrier.await();
+              return PickResult.withNoResult();
+            } catch (Exception e) {
+              e.printStackTrace();
+            }
+          }
+          return PickResult.withNoResult();
+        }
+    }).when(picker).pickSubchannel(any(PickSubchannelArgs.class));
+
+    // Because there is no pending stream yet, it will do nothing but save the picker.
+    delayedTransport.reprocess(picker);
+    verify(picker, never()).pickSubchannel(any(PickSubchannelArgs.class));
+
+    Thread sideThread = new Thread("sideThread") {
+        @Override
+        public void run() {
+          // Will call pickSubchannel and wait on barrier
+          delayedTransport.newStream(method, headers, callOptions, tracers);
+        }
+      };
+    sideThread.start();
+
+    PickSubchannelArgsMatcher args = new PickSubchannelArgsMatcher(method, headers, callOptions);
+    PickSubchannelArgsMatcher args2 = new PickSubchannelArgsMatcher(method, headers2, callOptions);
+
+    // Is called from sideThread
+    verify(picker, timeout(5000)).pickSubchannel(argThat(args));
+
+    // Because stream has not been buffered (it's still stuck in newStream()), this will do nothing,
+    // but incrementing the picker version.
+    delayedTransport.reprocess(picker);
+    verify(picker).pickSubchannel(argThat(args));
+
+    // Now let the stuck newStream() through
+    barrier.await(5, TimeUnit.SECONDS);
+
+    sideThread.join(5000);
+    assertFalse("sideThread should've exited", sideThread.isAlive());
+    // newStream() detects that there has been a new picker while it's stuck, thus will pick again.
+    verify(picker, times(2)).pickSubchannel(argThat(args));
+
+    barrier.reset();
+    nextPickShouldWait.set(true);
+
+    ////////// Phase 2: reprocess() with a different picker
+    // Create the second stream
+    Thread sideThread2 = new Thread("sideThread2") {
+        @Override
+        public void run() {
+          // Will call pickSubchannel and wait on barrier
+          delayedTransport.newStream(method, headers2, callOptions, tracers);
+        }
+      };
+    sideThread2.start();
+    // The second stream will see the first picker
+    verify(picker, timeout(5000)).pickSubchannel(argThat(args2));
+    // While the first stream won't use the first picker any more.
+    verify(picker, times(2)).pickSubchannel(argThat(args));
+
+    // Now use a different picker
+    SubchannelPicker picker2 = mock(SubchannelPicker.class);
+    when(picker2.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withNoResult());
+    delayedTransport.reprocess(picker2);
+    // The pending first stream uses the new picker
+    verify(picker2).pickSubchannel(argThat(args));
+    // The second stream is still pending in creation, doesn't use the new picker.
+    verify(picker2, never()).pickSubchannel(argThat(args2));
+
+    // Now let the second stream finish creation
+    barrier.await(5, TimeUnit.SECONDS);
+
+    sideThread2.join(5000);
+    assertFalse("sideThread2 should've exited", sideThread2.isAlive());
+    // The second stream should see the new picker
+    verify(picker2, timeout(5000)).pickSubchannel(argThat(args2));
+
+    // Wrapping up
+    verify(picker, times(2)).pickSubchannel(argThat(args));
+    verify(picker).pickSubchannel(argThat(args2));
+    verify(picker2).pickSubchannel(argThat(args));
+    verify(picker2).pickSubchannel(argThat(args));
+  }
+
+  @Test
+  public void reprocess_addOptionalLabelCallsTracer() throws Exception {
+    delayedTransport.reprocess(new SubchannelPicker() {
+      @Override public PickResult pickSubchannel(PickSubchannelArgs args) {
+        args.getPickDetailsConsumer().addOptionalLabel("routed", "perfectly");
+        return PickResult.withError(Status.UNAVAILABLE.withDescription("expected"));
+      }
+    });
+
+    ClientStreamTracer tracer = mock(ClientStreamTracer.class);
+    ClientStream stream = delayedTransport.newStream(
+        method, headers, callOptions, new ClientStreamTracer[] {tracer});
+    stream.start(streamListener);
+
+    verify(tracer).addOptionalLabel("routed", "perfectly");
+  }
+
+  @Test
+  public void newStream_racesWithReprocessIdleMode() throws Exception {
+    SubchannelPicker picker = new SubchannelPicker() {
+      @Override public PickResult pickSubchannel(PickSubchannelArgs args) {
+        // Assume entering idle mode raced with the pick
+        delayedTransport.reprocess(null);
+        // Act like IDLE LB
+        return PickResult.withNoResult();
+      }
+    };
+
+    // Because there is no pending stream yet, it will do nothing but save the picker.
+    delayedTransport.reprocess(picker);
+
+    ClientStream stream = delayedTransport.newStream(
+        method, headers, callOptions, tracers);
+    stream.start(streamListener);
+    assertTrue(delayedTransport.hasPendingStreams());
+    verify(transportListener).transportInUse(true);
+  }
+
+  @Test
+  public void pendingStream_appendTimeoutInsight_waitForReady() {
+    ClientStream stream = delayedTransport.newStream(
+        method, headers, callOptions.withWaitForReady(), tracers);
+    stream.start(streamListener);
+    InsightBuilder insight = new InsightBuilder();
+    stream.appendTimeoutInsight(insight);
+    assertThat(insight.toString())
+        .matches("\\[wait_for_ready, connecting_and_lb_delay=[0-9]+ns\\, was_still_waiting]");
+  }
+
+  @Test
+  public void pendingStream_appendTimeoutInsight_waitForReady_withLastPickFailure() {
+    ClientStream stream = delayedTransport.newStream(
+        method, headers, callOptions.withWaitForReady(), tracers);
+    stream.start(streamListener);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    when(picker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withError(Status.PERMISSION_DENIED));
+    delayedTransport.reprocess(picker);
+    InsightBuilder insight = new InsightBuilder();
+    stream.appendTimeoutInsight(insight);
+    assertThat(insight.toString())
+        .matches("\\[wait_for_ready, "
+            + "Last Pick Failure=Status\\{code=PERMISSION_DENIED, description=null, cause=null\\},"
+            + " connecting_and_lb_delay=[0-9]+ns, was_still_waiting]");
+  }
+
+  private static TransportProvider newTransportProvider(final ClientTransport transport) {
+    return new TransportProvider() {
+      @Override
+      public ClientTransport obtainActiveTransport() {
+        return transport;
+      }
+    };
   }
 }
diff --git a/core/src/test/java/io/grpc/internal/DelayedStreamTest.java b/core/src/test/java/io/grpc/internal/DelayedStreamTest.java
index 697dd8d6d87..12c32fcf126 100644
--- a/core/src/test/java/io/grpc/internal/DelayedStreamTest.java
+++ b/core/src/test/java/io/grpc/internal/DelayedStreamTest.java
@@ -1,43 +1,31 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -47,13 +35,18 @@
 import static org.mockito.Mockito.when;
 
 import io.grpc.Attributes;
-import io.grpc.Attributes.Key;
 import io.grpc.Codec;
+import io.grpc.Compressor;
+import io.grpc.Deadline;
+import io.grpc.DecompressorRegistry;
 import io.grpc.Metadata;
 import io.grpc.Status;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
+import io.grpc.internal.SingleMessageProducer;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
-import org.junit.Before;
+import java.util.concurrent.TimeUnit;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -61,7 +54,10 @@
 import org.mockito.Captor;
 import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
 
 /**
  * Tests for {@link DelayedStream}.  Most of the state checking is enforced by
@@ -69,49 +65,57 @@
  */
 @RunWith(JUnit4.class)
 public class DelayedStreamTest {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
   @Mock private ClientStreamListener listener;
   @Mock private ClientStream realStream;
   @Captor private ArgumentCaptor<ClientStreamListener> listenerCaptor;
-  private DelayedStream stream = new DelayedStream();
-
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-  }
+  private DelayedStream stream = new DelayedStream("test_op");
 
   @Test
   public void setStream_setAuthority() {
     final String authority = "becauseIsaidSo";
     stream.setAuthority(authority);
     stream.start(listener);
-    stream.setStream(realStream);
+    callMeMaybe(stream.setStream(realStream));
     InOrder inOrder = inOrder(realStream);
     inOrder.verify(realStream).setAuthority(authority);
     inOrder.verify(realStream).start(any(ClientStreamListener.class));
   }
 
   @Test(expected = IllegalStateException.class)
-  public void setAuthority_afterStart() {
+  public void start_afterStart() {
     stream.start(listener);
-    stream.setAuthority("notgonnawork");
+    stream.start(mock(ClientStreamListener.class));
   }
 
   @Test(expected = IllegalStateException.class)
-  public void start_afterStart() {
-    stream.start(listener);
-    stream.start(mock(ClientStreamListener.class));
+  public void writeMessage_beforeStart() {
+    InputStream message = new ByteArrayInputStream(new byte[]{'a'});
+    stream.writeMessage(message);
   }
 
   @Test(expected = IllegalStateException.class)
-  public void setDecompressor_beforeSetStream() {
-    stream.start(listener);
-    stream.setDecompressor(Codec.Identity.NONE);
+  public void flush_beforeStart() {
+    stream.flush();
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void request_beforeStart() {
+    stream.request(1);
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void halfClose_beforeStart() {
+    stream.halfClose();
   }
 
   @Test
   public void setStream_sendsAllMessages() {
-    stream.start(listener);
     stream.setCompressor(Codec.Identity.NONE);
+    stream.setDecompressorRegistry(DecompressorRegistry.getDefaultInstance());
+    stream.start(listener);
 
     stream.setMessageCompression(true);
     InputStream message = new ByteArrayInputStream(new byte[]{'a'});
@@ -119,11 +123,10 @@ public void setStream_sendsAllMessages() {
     stream.setMessageCompression(false);
     stream.writeMessage(message);
 
-    stream.setStream(realStream);
-    stream.setDecompressor(Codec.Identity.NONE);
+    callMeMaybe(stream.setStream(realStream));
 
     verify(realStream).setCompressor(Codec.Identity.NONE);
-    verify(realStream).setDecompressor(Codec.Identity.NONE);
+    verify(realStream).setDecompressorRegistry(DecompressorRegistry.getDefaultInstance());
 
     verify(realStream).setMessageCompression(true);
     verify(realStream).setMessageCompression(false);
@@ -143,7 +146,7 @@ public void setStream_sendsAllMessages() {
   public void setStream_halfClose() {
     stream.start(listener);
     stream.halfClose();
-    stream.setStream(realStream);
+    callMeMaybe(stream.setStream(realStream));
 
     verify(realStream).halfClose();
   }
@@ -152,7 +155,7 @@ public void setStream_halfClose() {
   public void setStream_flush() {
     stream.start(listener);
     stream.flush();
-    stream.setStream(realStream);
+    callMeMaybe(stream.setStream(realStream));
     verify(realStream).flush();
 
     stream.flush();
@@ -164,7 +167,7 @@ public void setStream_flowControl() {
     stream.start(listener);
     stream.request(1);
     stream.request(2);
-    stream.setStream(realStream);
+    callMeMaybe(stream.setStream(realStream));
     verify(realStream).request(1);
     verify(realStream).request(2);
 
@@ -172,11 +175,99 @@ public void setStream_flowControl() {
     verify(realStream).request(3);
   }
 
+  @Test
+  public void setStreamThenStart() {
+    stream.optimizeForDirectExecutor();
+    stream.setCompressor(mock(Compressor.class));
+    stream.setFullStreamDecompression(false);
+    stream.setDecompressorRegistry(DecompressorRegistry.emptyInstance());
+    stream.setDeadline(Deadline.after(1, TimeUnit.MINUTES));
+    stream.setAuthority("auth");
+    stream.setMaxInboundMessageSize(10);
+    stream.setMaxOutboundMessageSize(10);
+
+    assertNull(stream.setStream(realStream));
+    stream.start(listener);
+    stream.request(1);
+
+    InOrder inOrder = inOrder(realStream);
+    inOrder.verify(realStream).optimizeForDirectExecutor();
+    inOrder.verify(realStream).setCompressor(any(Compressor.class));
+    inOrder.verify(realStream).setFullStreamDecompression(false);
+    inOrder.verify(realStream).setDecompressorRegistry(any(DecompressorRegistry.class));
+    inOrder.verify(realStream).setDeadline(any(Deadline.class));
+    inOrder.verify(realStream).setAuthority("auth");
+    inOrder.verify(realStream).setMaxInboundMessageSize(10);
+    inOrder.verify(realStream).setMaxOutboundMessageSize(10);
+    verify(realStream).request(1);
+    verify(realStream).start(same(listener));
+    verifyNoMoreInteractions(realStream);
+  }
+
+  @Test
+  public void startThenSetRealStream() {
+    stream.setAuthority("auth");
+    stream.optimizeForDirectExecutor();
+    stream.setMaxInboundMessageSize(10);
+    stream.setCompressor(mock(Compressor.class));
+    stream.setFullStreamDecompression(false);
+    stream.setDeadline(Deadline.after(1, TimeUnit.MINUTES));
+    stream.setMaxOutboundMessageSize(10);
+    stream.setDecompressorRegistry(DecompressorRegistry.emptyInstance());
+    stream.start(listener);
+    stream.request(1);
+    InputStream message = mock(InputStream.class);
+    stream.writeMessage(message);
+    Runnable runnable = stream.setStream(realStream);
+    assertNotNull(runnable);
+    callMeMaybe(runnable);
+    stream.getAttributes();
+    stream.request(4);
+
+    InOrder inOrder = inOrder(realStream);
+    inOrder.verify(realStream).setAuthority("auth");
+    inOrder.verify(realStream).optimizeForDirectExecutor();
+    inOrder.verify(realStream).setMaxInboundMessageSize(10);
+    inOrder.verify(realStream).setCompressor(any(Compressor.class));
+    inOrder.verify(realStream).setFullStreamDecompression(false);
+    inOrder.verify(realStream).setDeadline(any(Deadline.class));
+    inOrder.verify(realStream).setMaxOutboundMessageSize(10);
+    inOrder.verify(realStream).setDecompressorRegistry(any(DecompressorRegistry.class));
+    inOrder.verify(realStream).start(listenerCaptor.capture());
+    inOrder.verify(realStream).request(1);
+    inOrder.verify(realStream).writeMessage(same(message));
+    inOrder.verify(realStream).getAttributes();
+    verify(realStream).request(4);
+    verifyNoMoreInteractions(realStream);
+    ClientStreamListener delayedListener = listenerCaptor.getValue();
+    delayedListener.onReady();
+    verify(listener).onReady();
+  }
+
+  @Test
+  public void drainPendingCallRacesCancel() {
+    stream.start(listener);
+    InputStream message = mock(InputStream.class);
+    stream.writeMessage(message);
+    stream.flush();
+    Runnable runnable = stream.setStream(realStream);
+    assertNotNull(runnable);
+    stream.cancel(Status.CANCELLED);
+    callMeMaybe(runnable);
+
+    InOrder inOrder = inOrder(realStream);
+    inOrder.verify(realStream).start(any(ClientStreamListener.class));
+    inOrder.verify(realStream).writeMessage(same(message));
+    inOrder.verify(realStream).flush();
+    inOrder.verify(realStream).cancel(Status.CANCELLED);
+    verifyNoMoreInteractions(realStream);
+  }
+
   @Test
   public void setStream_setMessageCompression() {
     stream.start(listener);
     stream.setMessageCompression(false);
-    stream.setStream(realStream);
+    callMeMaybe(stream.setStream(realStream));
     verify(realStream).setMessageCompression(false);
 
     stream.setMessageCompression(true);
@@ -187,7 +278,7 @@ public void setStream_setMessageCompression() {
   public void setStream_isReady() {
     stream.start(listener);
     assertFalse(stream.isReady());
-    stream.setStream(realStream);
+    callMeMaybe(stream.setStream(realStream));
     verify(realStream, never()).isReady();
 
     assertFalse(stream.isReady());
@@ -201,19 +292,14 @@ public void setStream_isReady() {
   @Test
   public void setStream_getAttributes() {
     Attributes attributes =
-        Attributes.newBuilder().set(Key.<String>of("fakeKey"), "fakeValue").build();
+        Attributes.newBuilder().set(Attributes.Key.<String>create("fakeKey"), "fakeValue").build();
     when(realStream.getAttributes()).thenReturn(attributes);
 
     stream.start(listener);
 
-    try {
-      stream.getAttributes(); // expect to throw IllegalStateException, otherwise fail()
-      fail();
-    } catch (IllegalStateException expected) {
-      // ignore
-    }
+    assertEquals(Attributes.EMPTY, stream.getAttributes());
 
-    stream.setStream(realStream);
+    callMeMaybe(stream.setStream(realStream));
     assertEquals(attributes, stream.getAttributes());
   }
 
@@ -221,13 +307,13 @@ public void setStream_getAttributes() {
   public void startThenCancelled() {
     stream.start(listener);
     stream.cancel(Status.CANCELLED);
-    verify(listener).closed(eq(Status.CANCELLED), any(Metadata.class));
+    verify(listener).closed(eq(Status.CANCELLED), any(RpcProgress.class), any(Metadata.class));
   }
 
   @Test
   public void startThenSetStreamThenCancelled() {
     stream.start(listener);
-    stream.setStream(realStream);
+    callMeMaybe(stream.setStream(realStream));
     stream.cancel(Status.CANCELLED);
     verify(realStream).start(any(ClientStreamListener.class));
     verify(realStream).cancel(same(Status.CANCELLED));
@@ -235,52 +321,36 @@ public void startThenSetStreamThenCancelled() {
 
   @Test
   public void setStreamThenStartThenCancelled() {
-    stream.setStream(realStream);
+    callMeMaybe(stream.setStream(realStream));
     stream.start(listener);
     stream.cancel(Status.CANCELLED);
     verify(realStream).start(same(listener));
     verify(realStream).cancel(same(Status.CANCELLED));
   }
 
-  @Test
-  public void setStreamThenCancelled() {
-    stream.setStream(realStream);
-    stream.cancel(Status.CANCELLED);
-    verify(realStream).cancel(same(Status.CANCELLED));
-  }
-
   @Test
   public void setStreamTwice() {
     stream.start(listener);
-    stream.setStream(realStream);
+    callMeMaybe(stream.setStream(realStream));
     verify(realStream).start(any(ClientStreamListener.class));
-    stream.setStream(mock(ClientStream.class));
+    callMeMaybe(stream.setStream(mock(ClientStream.class)));
     stream.flush();
     verify(realStream).flush();
   }
 
   @Test
   public void cancelThenSetStream() {
-    stream.cancel(Status.CANCELLED);
-    stream.setStream(realStream);
     stream.start(listener);
+    stream.cancel(Status.CANCELLED);
+    callMeMaybe(stream.setStream(realStream));
     stream.isReady();
     verifyNoMoreInteractions(realStream);
   }
 
-  @Test
+  @Test(expected = IllegalStateException.class)
   public void cancel_beforeStart() {
     Status status = Status.CANCELLED.withDescription("that was quick");
     stream.cancel(status);
-    stream.start(listener);
-    verify(listener).closed(same(status), any(Metadata.class));
-  }
-
-  @Test
-  public void cancelledThenStart() {
-    stream.cancel(Status.CANCELLED);
-    stream.start(listener);
-    verify(listener).closed(eq(Status.CANCELLED), any(Metadata.class));
   }
 
   @Test
@@ -298,7 +368,7 @@ public void onReady() {
 
     IsReadyListener isReadyListener = new IsReadyListener();
     stream.start(isReadyListener);
-    stream.setStream(new NoopClientStream() {
+    callMeMaybe(stream.setStream(new NoopClientStream() {
       @Override
       public void start(ClientStreamListener listener) {
         // This call to the listener should end up being delayed.
@@ -309,7 +379,7 @@ public void start(ClientStreamListener listener) {
       public boolean isReady() {
         return true;
       }
-    });
+    }));
     assertTrue(isReadyListener.onReadyCalled);
   }
 
@@ -318,51 +388,93 @@ public void listener_allQueued() {
     final Metadata headers = new Metadata();
     final InputStream message1 = mock(InputStream.class);
     final InputStream message2 = mock(InputStream.class);
+    final SingleMessageProducer producer1 = new SingleMessageProducer(message1);
+    final SingleMessageProducer producer2 = new SingleMessageProducer(message2);
     final Metadata trailers = new Metadata();
     final Status status = Status.UNKNOWN.withDescription("unique status");
 
     final InOrder inOrder = inOrder(listener);
     stream.start(listener);
-    stream.setStream(new NoopClientStream() {
+    callMeMaybe(stream.setStream(new NoopClientStream() {
       @Override
       public void start(ClientStreamListener passedListener) {
         passedListener.onReady();
         passedListener.headersRead(headers);
-        passedListener.messageRead(message1);
+        passedListener.messagesAvailable(producer1);
         passedListener.onReady();
-        passedListener.messageRead(message2);
-        passedListener.closed(status, trailers);
+        passedListener.messagesAvailable(producer2);
+        passedListener.closed(status, RpcProgress.PROCESSED, trailers);
 
         verifyNoMoreInteractions(listener);
       }
-    });
+    }));
     inOrder.verify(listener).onReady();
     inOrder.verify(listener).headersRead(headers);
-    inOrder.verify(listener).messageRead(message1);
+    inOrder.verify(listener).messagesAvailable(producer1);
     inOrder.verify(listener).onReady();
-    inOrder.verify(listener).messageRead(message2);
-    inOrder.verify(listener).closed(status, trailers);
+    inOrder.verify(listener).messagesAvailable(producer2);
+    inOrder.verify(listener).closed(status, RpcProgress.PROCESSED, trailers);
   }
 
   @Test
   public void listener_noQueued() {
     final Metadata headers = new Metadata();
     final InputStream message = mock(InputStream.class);
+    final SingleMessageProducer producer = new SingleMessageProducer(message);
     final Metadata trailers = new Metadata();
     final Status status = Status.UNKNOWN.withDescription("unique status");
 
     stream.start(listener);
-    stream.setStream(realStream);
+    callMeMaybe(stream.setStream(realStream));
     verify(realStream).start(listenerCaptor.capture());
     ClientStreamListener delayedListener = listenerCaptor.getValue();
     delayedListener.onReady();
     verify(listener).onReady();
     delayedListener.headersRead(headers);
     verify(listener).headersRead(headers);
-    delayedListener.messageRead(message);
-    verify(listener).messageRead(message);
-    delayedListener.closed(status, trailers);
-    verify(listener).closed(status, trailers);
+    delayedListener.messagesAvailable(producer);
+    verify(listener).messagesAvailable(producer);
+    delayedListener.closed(status, RpcProgress.PROCESSED, trailers);
+    verify(listener).closed(status, RpcProgress.PROCESSED, trailers);
   }
 
+  @Test
+  public void appendTimeoutInsight_notStarted() {
+    InsightBuilder insight = new InsightBuilder();
+    stream.appendTimeoutInsight(insight);
+    assertThat(insight.toString()).isEqualTo("[]");
+  }
+
+  @Test
+  public void appendTimeoutInsight_realStreamNotSet() {
+    InsightBuilder insight = new InsightBuilder();
+    stream.start(listener);
+    stream.appendTimeoutInsight(insight);
+    assertThat(insight.toString()).matches("\\[test_op_delay=[0-9]+ns\\, was_still_waiting]");
+  }
+
+  @Test
+  public void appendTimeoutInsight_realStreamSet() {
+    doAnswer(new Answer<Void>() {
+        @Override
+        public Void answer(InvocationOnMock in) {
+          InsightBuilder insight = (InsightBuilder) in.getArguments()[0];
+          insight.appendKeyValue("remote_addr", "127.0.0.1:443");
+          return null;
+        }
+      }).when(realStream).appendTimeoutInsight(any(InsightBuilder.class));
+    stream.start(listener);
+    callMeMaybe(stream.setStream(realStream));
+
+    InsightBuilder insight = new InsightBuilder();
+    stream.appendTimeoutInsight(insight);
+    assertThat(insight.toString())
+        .matches("\\[test_op_delay=[0-9]+ns, remote_addr=127\\.0\\.0\\.1:443\\]");
+  }
+
+  private void callMeMaybe(Runnable r) {
+    if (r != null) {
+      r.run();
+    }
+  }
 }
diff --git a/core/src/test/java/io/grpc/internal/DnsNameResolverProviderTest.java b/core/src/test/java/io/grpc/internal/DnsNameResolverProviderTest.java
index c0e5fbc9772..75b82df544f 100644
--- a/core/src/test/java/io/grpc/internal/DnsNameResolverProviderTest.java
+++ b/core/src/test/java/io/grpc/internal/DnsNameResolverProviderTest.java
@@ -1,85 +1,145 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.TruthJUnit.assume;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
 
-import io.grpc.Attributes;
-import io.grpc.NameResolverProvider;
+import io.grpc.ChannelLogger;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.SynchronizationContext;
+import io.grpc.Uri;
 import java.net.URI;
+import java.util.Arrays;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
 
 /** Unit tests for {@link DnsNameResolverProvider}. */
-@RunWith(JUnit4.class)
+@RunWith(Parameterized.class)
 public class DnsNameResolverProviderTest {
+  private final FakeClock fakeClock = new FakeClock();
+
+  @Parameters(name = "enableRfc3986UrisParam={0}")
+  public static Iterable<Object[]> data() {
+    return Arrays.asList(new Object[][] {{true}, {false}});
+  }
+
+  @Parameter public boolean enableRfc3986UrisParam;
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final NameResolver.Args args = NameResolver.Args.newBuilder()
+      .setDefaultPort(8080)
+      .setProxyDetector(GrpcUtil.DEFAULT_PROXY_DETECTOR)
+      .setSynchronizationContext(syncContext)
+      .setServiceConfigParser(mock(ServiceConfigParser.class))
+      .setChannelLogger(mock(ChannelLogger.class))
+      .setScheduledExecutorService(fakeClock.getScheduledExecutorService())
+      .build();
+
   private DnsNameResolverProvider provider = new DnsNameResolverProvider();
 
   @Test
-  public void provided() {
-    for (NameResolverProvider current
-        : NameResolverProvider.getCandidatesViaServiceLoader(getClass().getClassLoader())) {
-      if (current instanceof DnsNameResolverProvider) {
-        return;
-      }
-    }
-    fail("DnsNameResolverProvider not registered");
+  public void isAvailable() {
+    assertTrue(provider.isAvailable());
+  }
+
+  @Test
+  public void newNameResolver_acceptsHostAndPort() {
+    NameResolver nameResolver = newNameResolver("dns:///localhost:443", args);
+    assertThat(nameResolver).isNotNull();
+    assertThat(nameResolver.getClass()).isSameInstanceAs(DnsNameResolver.class);
+    assertThat(nameResolver.getServiceAuthority()).isEqualTo("localhost:443");
+    assertThat(((DnsNameResolver) nameResolver).getPort()).isEqualTo(443);
   }
 
   @Test
-  public void providedHardCoded() {
-    for (NameResolverProvider current
-        : NameResolverProvider.getCandidatesViaHardCoded(getClass().getClassLoader())) {
-      if (current instanceof DnsNameResolverProvider) {
-        return;
-      }
-    }
-    fail("DnsNameResolverProvider not registered");
+  public void newNameResolver_acceptsRootless() {
+    assume().that(enableRfc3986UrisParam).isTrue();
+    NameResolver nameResolver = newNameResolver("dns:localhost:443", args);
+    assertThat(nameResolver).isNotNull();
+    assertThat(nameResolver.getClass()).isSameInstanceAs(DnsNameResolver.class);
+    assertThat(nameResolver.getServiceAuthority()).isEqualTo("localhost:443");
   }
 
   @Test
-  public void isAvailable() {
-    assertTrue(provider.isAvailable());
+  public void newNameResolver_rejectsNonDnsScheme() {
+    NameResolver nameResolver = newNameResolver("notdns:///localhost:443", args);
+    assertThat(nameResolver).isNull();
   }
 
   @Test
-  public void newNameResolver() {
-    assertSame(DnsNameResolver.class,
-        provider.newNameResolver(URI.create("dns:///localhost:443"), Attributes.EMPTY).getClass());
-    assertNull(
-        provider.newNameResolver(URI.create("notdns:///localhost:443"), Attributes.EMPTY));
+  public void newNameResolver_validDnsNameWithoutPort_usesDefaultPort() {
+    DnsNameResolver nameResolver =
+        (DnsNameResolver) newNameResolver("dns:/foo.googleapis.com", args);
+    assertThat(nameResolver).isNotNull();
+    assertThat(nameResolver.getServiceAuthority()).isEqualTo("foo.googleapis.com");
+    assertThat(nameResolver.getPort()).isEqualTo(args.getDefaultPort());
+  }
+
+  // TODO(jdcormie): Trailing path segments *should* be forbidden. This test just demonstrates that
+  // both newNameResolver() overloads behave the same with respect to this bug.
+  @Test
+  public void newNameResolver_toleratesTrailingPathSegments() {
+    NameResolver nameResolver = newNameResolver("dns:///foo.googleapis.com/ig/nor/ed", args);
+    assertThat(nameResolver).isNotNull();
+    assertThat(nameResolver.getClass()).isSameInstanceAs(DnsNameResolver.class);
+    assertThat(nameResolver.getServiceAuthority()).isEqualTo("foo.googleapis.com");
+  }
+
+  @Test
+  public void newNameResolver_toleratesAuthority() {
+    NameResolver nameResolver = newNameResolver("dns://8.8.8.8/foo.googleapis.com", args);
+    assertThat(nameResolver).isNotNull();
+    assertThat(nameResolver.getClass()).isSameInstanceAs(DnsNameResolver.class);
+    assertThat(nameResolver.getServiceAuthority()).isEqualTo("foo.googleapis.com");
+  }
+
+  @Test
+  public void newNameResolver_validIpv6Host() {
+    NameResolver nameResolver = newNameResolver("dns:/%5B::1%5D", args);
+    assertThat(nameResolver).isNotNull();
+    assertThat(nameResolver.getClass()).isSameInstanceAs(DnsNameResolver.class);
+    assertThat(nameResolver.getServiceAuthority()).isEqualTo("[::1]");
+  }
+
+  @Test
+  public void newNameResolver_invalidIpv6Host_throws() {
+    IllegalArgumentException e =
+        assertThrows(
+            IllegalArgumentException.class, () -> newNameResolver("dns:/%5Binvalid%5D", args));
+    assertThat(e).hasMessageThat().contains("invalid");
+  }
+
+  private NameResolver newNameResolver(String uriString, NameResolver.Args args) {
+    return enableRfc3986UrisParam
+        ? provider.newNameResolver(Uri.create(uriString), args)
+        : provider.newNameResolver(URI.create(uriString), args);
   }
 }
diff --git a/core/src/test/java/io/grpc/internal/DnsNameResolverTest.java b/core/src/test/java/io/grpc/internal/DnsNameResolverTest.java
index ff5bb94925f..c6067d305b5 100644
--- a/core/src/test/java/io/grpc/internal/DnsNameResolverTest.java
+++ b/core/src/test/java/io/grpc/internal/DnsNameResolverTest.java
@@ -1,323 +1,1276 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.internal.DnsNameResolver.NETWORKADDRESS_CACHE_TTL_PROPERTY;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
 
+import com.google.common.base.Stopwatch;
+import com.google.common.base.VerifyException;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
-import io.grpc.Attributes;
+import com.google.common.net.InetAddresses;
+import com.google.common.testing.FakeTicker;
+import io.grpc.ChannelLogger;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.HttpConnectProxiedSocketAddress;
 import io.grpc.NameResolver;
-import io.grpc.ResolvedServerInfoGroup;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.NameResolver.ResolutionResult;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.ProxyDetector;
+import io.grpc.StaticTestingClassLoader;
 import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.DnsNameResolver.AddressResolver;
+import io.grpc.internal.DnsNameResolver.ResourceResolver;
+import io.grpc.internal.DnsNameResolver.ResourceResolverFactory;
+import io.grpc.internal.JndiResourceResolverFactory.JndiResourceResolver;
+import io.grpc.internal.JndiResourceResolverFactory.RecordFetcher;
 import io.grpc.internal.SharedResourceHolder.Resource;
+import java.io.IOException;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
-import java.net.URI;
+import java.net.SocketAddress;
 import java.net.UnknownHostException;
-import java.util.LinkedList;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.ScheduledExecutorService;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
-import org.junit.After;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Pattern;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.DisableOnDebug;
+import org.junit.rules.TestRule;
+import org.junit.rules.Timeout;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Captor;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /** Unit tests for {@link DnsNameResolver}. */
 @RunWith(JUnit4.class)
 public class DnsNameResolverTest {
-  private static final int DEFAULT_PORT = 887;
-  private static final Attributes NAME_RESOLVER_PARAMS =
-      Attributes.newBuilder().set(NameResolver.Factory.PARAMS_DEFAULT_PORT, DEFAULT_PORT).build();
 
-  private final DnsNameResolverProvider provider = new DnsNameResolverProvider();
-  private final FakeClock fakeClock = new FakeClock();
-  private final FakeClock fakeExecutor = new FakeClock();
-  private final Resource<ScheduledExecutorService> fakeTimerServiceResource =
-      new Resource<ScheduledExecutorService>() {
-        @Override
-        public ScheduledExecutorService create() {
-          return fakeClock.getScheduledExecutorService();
-        }
+  @Rule public final TestRule globalTimeout = new DisableOnDebug(Timeout.seconds(10));
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+  @Rule public final FlagResetRule flagResetRule = new FlagResetRule();
 
-        @Override
-        public void close(ScheduledExecutorService instance) {
-          assertSame(fakeClock, instance);
-        }
-      };
+  private final Map<String, ?> serviceConfig = new LinkedHashMap<>();
 
-  private final Resource<ExecutorService> fakeExecutorResource =
-      new Resource<ExecutorService>() {
+  private static final int DEFAULT_PORT = 887;
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
         @Override
-        public ExecutorService create() {
-          return fakeExecutor.getScheduledExecutorService();
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
         }
+      });
 
+  private final FakeClock fakeClock = new FakeClock();
+  private final FakeClock fakeExecutor = new FakeClock();
+  private static final FakeClock.TaskFilter NAME_RESOLVER_REFRESH_TASK_FILTER =
+      new FakeClock.TaskFilter() {
         @Override
-        public void close(ExecutorService instance) {
-          assertSame(fakeExecutor, instance);
+        public boolean shouldAccept(Runnable command) {
+          return command.toString().contains(
+              RetryingNameResolver.DelayedNameResolverRefresh.class.getName());
         }
       };
 
+  private final FakeExecutorResource fakeExecutorResource = new FakeExecutorResource();
+
+  private final class FakeExecutorResource implements Resource<Executor> {
+    private final AtomicInteger createCount = new AtomicInteger();
+
+    @Override
+    public Executor create() {
+      createCount.incrementAndGet();
+      return fakeExecutor.getScheduledExecutorService();
+    }
+
+    @Override
+    public void close(Executor instance) {}
+  }
+
   @Mock
-  private NameResolver.Listener mockListener;
-  @Captor
-  private ArgumentCaptor<List<ResolvedServerInfoGroup>> resultCaptor;
+  private NameResolver.Listener2 mockListener;
   @Captor
-  private ArgumentCaptor<Status> statusCaptor;
+  private ArgumentCaptor<ResolutionResult> resultCaptor;
+  @Mock
+  private RecordFetcher recordFetcher;
+  @Mock private ProxyDetector mockProxyDetector;
+
+  private RetryingNameResolver newResolver(String name, int defaultPort) {
+    return newResolver(
+        name, defaultPort, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted());
+  }
+
+  private RetryingNameResolver newResolver(String name, int defaultPort, boolean isAndroid) {
+    return newResolver(
+        name, defaultPort, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(),
+        isAndroid);
+  }
+
+
+  private RetryingNameResolver newResolver(
+      String name,
+      int defaultPort,
+      ProxyDetector proxyDetector,
+      Stopwatch stopwatch) {
+    return newResolver(name, defaultPort, proxyDetector, stopwatch, false);
+  }
+
+  private RetryingNameResolver newResolver(
+      String name,
+      final int defaultPort,
+      final ProxyDetector proxyDetector,
+      Stopwatch stopwatch,
+      boolean isAndroid) {
+    NameResolver.Args args =
+        NameResolver.Args.newBuilder()
+            .setDefaultPort(defaultPort)
+            .setProxyDetector(proxyDetector)
+            .setSynchronizationContext(syncContext)
+            .setServiceConfigParser(mock(ServiceConfigParser.class))
+            .setChannelLogger(mock(ChannelLogger.class))
+            .setScheduledExecutorService(fakeExecutor.getScheduledExecutorService())
+            .build();
+    return newResolver(name, stopwatch, isAndroid, args);
+  }
+
+  private RetryingNameResolver newResolver(
+      String name,
+      Stopwatch stopwatch,
+      boolean isAndroid,
+      NameResolver.Args args) {
+    DnsNameResolver dnsResolver = new DnsNameResolver(null, name, args, fakeExecutorResource,
+        stopwatch, isAndroid);
+    // By default, using the mocked ResourceResolver to avoid I/O
+    dnsResolver.setResourceResolver(new JndiResourceResolver(recordFetcher));
+
+    // In practice the DNS name resolver provider always wraps the resolver in a
+    // RetryingNameResolver which adds retry capabilities to it. We use the same setup here.
+    return (RetryingNameResolver) RetryingNameResolver.wrap(dnsResolver, args);
+  }
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
+    DnsNameResolver.enableJndi = true;
+
+    // By default the mock listener processes the result successfully.
+    when(mockListener.onResult2(isA(ResolutionResult.class))).thenReturn(Status.OK);
+  }
+
+  @Test
+  public void nullDnsName() {
+    try {
+      newResolver(null, DEFAULT_PORT);
+      fail("Expected NullPointerException");
+    } catch (NullPointerException e) {
+      // expected
+    }
+  }
+
+  @Test
+  public void invalidDnsName_containsUnderscore() {
+    try {
+      newResolver("host_1", DEFAULT_PORT);
+      fail("Expected IllegalArgumentException");
+    } catch (IllegalArgumentException e) {
+      // expected
+    }
   }
 
-  @After
-  public void noMorePendingTasks() {
+  @Test
+  public void resolve_androidIgnoresPropertyValue() throws Exception {
+    flagResetRule.setSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY, "2");
+    resolveNeverCache(true);
+  }
+
+  @Test
+  public void resolve_androidIgnoresPropertyValueCacheForever() throws Exception {
+    flagResetRule.setSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY, "-1");
+    resolveNeverCache(true);
+  }
+
+  @Test
+  public void resolve_neverCache() throws Exception {
+    flagResetRule.setSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY, "0");
+    resolveNeverCache(false);
+  }
+
+  private void resolveNeverCache(boolean isAndroid) throws Exception {
+    final List<InetAddress> answer1 = createAddressList(2);
+    final List<InetAddress> answer2 = createAddressList(1);
+    String name = "foo.googleapis.com";
+
+    RetryingNameResolver resolver = newResolver(name, 81, isAndroid);
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    AddressResolver mockResolver = mock(AddressResolver.class);
+    when(mockResolver.resolveAddress(anyString())).thenReturn(answer1).thenReturn(answer2);
+    dnsResolver.setAddressResolver(mockResolver);
+
+    resolver.start(mockListener);
+    assertEquals(1, fakeExecutor.runDueTasks());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertAnswerMatches(answer1, 81, resultCaptor.getValue());
+    assertEquals(0, fakeClock.numPendingTasks());
+
+    resolver.refresh();
+    assertEquals(1, fakeExecutor.runDueTasks());
+    verify(mockListener, times(2)).onResult2(resultCaptor.capture());
+    assertAnswerMatches(answer2, 81, resultCaptor.getValue());
     assertEquals(0, fakeClock.numPendingTasks());
     assertEquals(0, fakeExecutor.numPendingTasks());
+
+    syncContext.execute(() -> resolver.shutdown());
+
+    verify(mockResolver, times(2)).resolveAddress(anyString());
   }
 
   @Test
-  public void invalidDnsName() throws Exception {
-    testInvalidUri(new URI("dns", null, "/[invalid]", null));
+  public void testExecutor_default() throws Exception {
+    final List<InetAddress> answer = createAddressList(2);
+
+    RetryingNameResolver resolver = newResolver("foo.googleapis.com", 81);
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    AddressResolver mockResolver = mock(AddressResolver.class);
+    when(mockResolver.resolveAddress(anyString())).thenReturn(answer);
+    dnsResolver.setAddressResolver(mockResolver);
+
+    resolver.start(mockListener);
+    assertEquals(1, fakeExecutor.runDueTasks());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertAnswerMatches(answer, 81, resultCaptor.getValue());
+    assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
+
+    syncContext.execute(() -> resolver.shutdown());
+
+    assertThat(fakeExecutorResource.createCount.get()).isEqualTo(1);
   }
 
   @Test
-  public void validIpv6() throws Exception {
-    testValidUri(new URI("dns", null, "/[::1]", null), "[::1]", DEFAULT_PORT);
+  public void testExecutor_custom() throws Exception {
+    final List<InetAddress> answer = createAddressList(2);
+    final AtomicInteger executions = new AtomicInteger();
+
+    NameResolver.Args args =
+        NameResolver.Args.newBuilder()
+            .setDefaultPort(81)
+            .setProxyDetector(GrpcUtil.NOOP_PROXY_DETECTOR)
+            .setSynchronizationContext(syncContext)
+            .setServiceConfigParser(mock(ServiceConfigParser.class))
+            .setChannelLogger(mock(ChannelLogger.class))
+            .setScheduledExecutorService(fakeExecutor.getScheduledExecutorService())
+            .setOffloadExecutor(
+                new Executor() {
+                  @Override
+                  public void execute(Runnable command) {
+                    executions.incrementAndGet();
+                    command.run();
+                  }
+                })
+            .build();
+
+    RetryingNameResolver resolver = newResolver(
+        "foo.googleapis.com", Stopwatch.createUnstarted(), false, args);
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    AddressResolver mockResolver = mock(AddressResolver.class);
+    when(mockResolver.resolveAddress(anyString())).thenReturn(answer);
+    dnsResolver.setAddressResolver(mockResolver);
+
+    resolver.start(mockListener);
+    assertEquals(0, fakeExecutor.runDueTasks());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertAnswerMatches(answer, 81, resultCaptor.getValue());
+    assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
+
+    syncContext.execute(() -> resolver.shutdown());
+
+    assertThat(fakeExecutorResource.createCount.get()).isEqualTo(0);
+    assertThat(executions.get()).isEqualTo(1);
   }
 
   @Test
-  public void validDnsNameWithoutPort() throws Exception {
-    testValidUri(new URI("dns", null, "/foo.googleapis.com", null),
-        "foo.googleapis.com", DEFAULT_PORT);
+  public void resolve_cacheForever() throws Exception {
+    flagResetRule.setSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY, "-1");
+    final List<InetAddress> answer1 = createAddressList(2);
+    String name = "foo.googleapis.com";
+    FakeTicker fakeTicker = new FakeTicker();
+
+    RetryingNameResolver resolver = newResolver(
+        name, 81, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(fakeTicker));
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    AddressResolver mockResolver = mock(AddressResolver.class);
+    when(mockResolver.resolveAddress(anyString()))
+        .thenReturn(answer1)
+        .thenThrow(new AssertionError("should not called twice"));
+    dnsResolver.setAddressResolver(mockResolver);
+
+    resolver.start(mockListener);
+    assertEquals(1, fakeExecutor.runDueTasks());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertAnswerMatches(answer1, 81, resultCaptor.getValue());
+    assertEquals(0, fakeClock.numPendingTasks());
+
+    fakeTicker.advance(1, TimeUnit.DAYS);
+    resolver.refresh();
+    assertEquals(0, fakeExecutor.runDueTasks());
+    assertEquals(0, fakeClock.numPendingTasks());
+    verifyNoMoreInteractions(mockListener);
+
+    syncContext.execute(() -> resolver.shutdown());
+
+    verify(mockResolver).resolveAddress(anyString());
   }
 
   @Test
-  public void validDnsNameWithPort() throws Exception {
-    testValidUri(new URI("dns", null, "/foo.googleapis.com:456", null),
-        "foo.googleapis.com:456", 456);
+  public void resolve_usingCache() throws Exception {
+    long ttl = 60;
+    flagResetRule.setSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY, Long.toString(ttl));
+    final List<InetAddress> answer = createAddressList(2);
+    String name = "foo.googleapis.com";
+    FakeTicker fakeTicker = new FakeTicker();
+
+    RetryingNameResolver resolver = newResolver(
+        name, 81, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(fakeTicker));
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    AddressResolver mockResolver = mock(AddressResolver.class);
+    when(mockResolver.resolveAddress(anyString()))
+        .thenReturn(answer)
+        .thenThrow(new AssertionError("should not reach here."));
+    dnsResolver.setAddressResolver(mockResolver);
+
+    resolver.start(mockListener);
+    assertEquals(1, fakeExecutor.runDueTasks());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertAnswerMatches(answer, 81, resultCaptor.getValue());
+    assertEquals(0, fakeClock.numPendingTasks());
+
+    // this refresh should return cached result
+    fakeTicker.advance(ttl - 1, TimeUnit.SECONDS);
+    resolver.refresh();
+    assertEquals(0, fakeExecutor.runDueTasks());
+    assertEquals(0, fakeClock.numPendingTasks());
+    verifyNoMoreInteractions(mockListener);
+
+    syncContext.execute(() -> resolver.shutdown());
+
+    verify(mockResolver).resolveAddress(anyString());
   }
 
   @Test
-  public void resolve() throws Exception {
-    InetAddress[] answer1 = createAddressList(2);
-    InetAddress[] answer2 = createAddressList(1);
+  public void resolve_cacheExpired() throws Exception {
+    long ttl = 60;
+    flagResetRule.setSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY, Long.toString(ttl));
+    final List<InetAddress> answer1 = createAddressList(2);
+    final List<InetAddress> answer2 = createAddressList(1);
     String name = "foo.googleapis.com";
-    MockResolver resolver = new MockResolver(name, 81, answer1, answer2);
+    FakeTicker fakeTicker = new FakeTicker();
+
+    RetryingNameResolver resolver = newResolver(
+        name, 81, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(fakeTicker));
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    AddressResolver mockResolver = mock(AddressResolver.class);
+    when(mockResolver.resolveAddress(anyString())).thenReturn(answer1)
+        .thenReturn(answer2);
+    dnsResolver.setAddressResolver(mockResolver);
+
     resolver.start(mockListener);
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener).onUpdate(resultCaptor.capture(), any(Attributes.class));
-    assertEquals(name, resolver.invocations.poll());
-    assertAnswerMatches(answer1, 81, Iterables.getOnlyElement(resultCaptor.getValue()));
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertAnswerMatches(answer1, 81, resultCaptor.getValue());
     assertEquals(0, fakeClock.numPendingTasks());
 
+    fakeTicker.advance(ttl + 1, TimeUnit.SECONDS);
     resolver.refresh();
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener, times(2)).onUpdate(resultCaptor.capture(), any(Attributes.class));
-    assertEquals(name, resolver.invocations.poll());
-    assertAnswerMatches(answer2, 81, Iterables.getOnlyElement(resultCaptor.getValue()));
+    verify(mockListener, times(2)).onResult2(resultCaptor.capture());
+    assertAnswerMatches(answer2, 81, resultCaptor.getValue());
     assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
+
+    syncContext.execute(() -> resolver.shutdown());
+
+    verify(mockResolver, times(2)).resolveAddress(anyString());
+  }
 
-    resolver.shutdown();
+  @Test
+  public void resolve_invalidTtlPropertyValue() throws Exception {
+    flagResetRule.setSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY, "not_a_number");
+    resolveDefaultValue();
   }
 
   @Test
-  public void retry() throws Exception {
+  public void resolve_noPropertyValue() throws Exception {
+    flagResetRule.clearSystemPropertyForTest(NETWORKADDRESS_CACHE_TTL_PROPERTY);
+    resolveDefaultValue();
+  }
+
+  private void resolveDefaultValue() throws Exception {
+    final List<InetAddress> answer1 = createAddressList(2);
+    final List<InetAddress> answer2 = createAddressList(1);
     String name = "foo.googleapis.com";
-    UnknownHostException error = new UnknownHostException(name);
-    InetAddress[] answer = createAddressList(2);
-    MockResolver resolver = new MockResolver(name, 81, error, error, answer);
+    FakeTicker fakeTicker = new FakeTicker();
+
+    RetryingNameResolver resolver = newResolver(
+        name, 81, GrpcUtil.NOOP_PROXY_DETECTOR, Stopwatch.createUnstarted(fakeTicker));
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    AddressResolver mockResolver = mock(AddressResolver.class);
+    when(mockResolver.resolveAddress(anyString())).thenReturn(answer1).thenReturn(answer2);
+    dnsResolver.setAddressResolver(mockResolver);
+
     resolver.start(mockListener);
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener).onError(statusCaptor.capture());
-    assertEquals(name, resolver.invocations.poll());
-    Status status = statusCaptor.getValue();
-    assertEquals(Status.Code.UNAVAILABLE, status.getCode());
-    assertSame(error, status.getCause());
-
-    // First retry scheduled
-    assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardMillis(TimeUnit.MINUTES.toMillis(1) - 1);
-    assertEquals(1, fakeClock.numPendingTasks());
-
-    // First retry
-    fakeClock.forwardMillis(1);
-    assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener, times(2)).onError(statusCaptor.capture());
-    assertEquals(name, resolver.invocations.poll());
-    status = statusCaptor.getValue();
-    assertEquals(Status.Code.UNAVAILABLE, status.getCode());
-    assertSame(error, status.getCause());
-
-    // Second retry scheduled
-    assertEquals(1, fakeClock.numPendingTasks());
-    fakeClock.forwardMillis(TimeUnit.MINUTES.toMillis(1) - 1);
-    assertEquals(1, fakeClock.numPendingTasks());
-
-    // Second retry
-    fakeClock.forwardMillis(1);
+    verify(mockListener).onResult2(resultCaptor.capture());
+    assertAnswerMatches(answer1, 81, resultCaptor.getValue());
     assertEquals(0, fakeClock.numPendingTasks());
+
+    fakeTicker.advance(DnsNameResolver.DEFAULT_NETWORK_CACHE_TTL_SECONDS, TimeUnit.SECONDS);
+    resolver.refresh();
+    assertEquals(0, fakeExecutor.runDueTasks());
+    assertEquals(0, fakeClock.numPendingTasks());
+    verifyNoMoreInteractions(mockListener);
+
+    fakeTicker.advance(1, TimeUnit.SECONDS);
+    resolver.refresh();
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener).onUpdate(resultCaptor.capture(), any(Attributes.class));
-    assertEquals(name, resolver.invocations.poll());
-    assertAnswerMatches(answer, 81, Iterables.getOnlyElement(resultCaptor.getValue()));
+    verify(mockListener, times(2)).onResult2(resultCaptor.capture());
+    assertAnswerMatches(answer2, 81, resultCaptor.getValue());
+    assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
+
+    syncContext.execute(() -> resolver.shutdown());
+
+    verify(mockResolver, times(2)).resolveAddress(anyString());
+  }
+
+  @Test
+  public void resolve_emptyResult() throws Exception {
+    DnsNameResolver.enableTxt = true;
+    RetryingNameResolver resolver = newResolver("dns:///addr.fake:1234", 443);
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    dnsResolver.setAddressResolver(new AddressResolver() {
+      @Override
+      public List<InetAddress> resolveAddress(String host) throws Exception {
+        return Collections.emptyList();
+      }
+    });
+    ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
+    when(mockResourceResolver.resolveTxt(anyString()))
+        .thenReturn(Collections.<String>emptyList());
+
+    dnsResolver.setResourceResolver(mockResourceResolver);
+
+    resolver.start(mockListener);
+    assertThat(fakeExecutor.runDueTasks()).isEqualTo(1);
+
+    ArgumentCaptor<ResolutionResult> ac = ArgumentCaptor.forClass(ResolutionResult.class);
+    verify(mockListener).onResult2(ac.capture());
+    verifyNoMoreInteractions(mockListener);
+    assertThat(ac.getValue().getAddressesOrError().getValue()).isEmpty();
+    assertThat(ac.getValue().getServiceConfig()).isNull();
+    verify(mockResourceResolver, never()).resolveSrv(anyString());
+
+    assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
+  }
+
+  @Test
+  public void resolve_addressResolutionError() throws Exception {
+    DnsNameResolver.enableTxt = true;
+    when(mockProxyDetector.proxyFor(any(SocketAddress.class))).thenThrow(new IOException());
+    RetryingNameResolver resolver = newResolver(
+        "addr.fake:1234", 443, mockProxyDetector, Stopwatch.createUnstarted());
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    dnsResolver.setAddressResolver(new AddressResolver() {
+      @Override
+      public List<InetAddress> resolveAddress(String host) throws Exception {
+        return Collections.emptyList();
+      }
+    });
+    ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
+    when(mockResourceResolver.resolveTxt(anyString()))
+        .thenReturn(Collections.<String>emptyList());
+
+    dnsResolver.setResourceResolver(mockResourceResolver);
+
+    resolver.start(mockListener);
+    assertThat(fakeExecutor.runDueTasks()).isEqualTo(1);
+
+    ArgumentCaptor<ResolutionResult> ac = ArgumentCaptor.forClass(ResolutionResult.class);
+    verify(mockListener).onResult2(ac.capture());
+    verifyNoMoreInteractions(mockListener);
+    assertThat(ac.getValue().getAddressesOrError().getStatus().getCode()).isEqualTo(
+        Status.UNAVAILABLE.getCode());
+    assertThat(ac.getValue().getAddressesOrError().getStatus().getDescription()).isEqualTo(
+        "Unable to resolve host addr.fake");
+    assertThat(ac.getValue().getAddressesOrError().getStatus().getCause())
+        .isInstanceOf(IOException.class);
+  }
+
+  // Load balancer rejects the empty addresses.
+  @Test
+  public void resolve_emptyResult_notAccepted() throws Exception {
+    when(mockListener.onResult2(isA(ResolutionResult.class))).thenReturn(Status.UNAVAILABLE);
+
+    DnsNameResolver.enableTxt = true;
+    RetryingNameResolver resolver = newResolver("dns:///addr.fake:1234", 443);
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    dnsResolver.setAddressResolver(new AddressResolver() {
+      @Override
+      public List<InetAddress> resolveAddress(String host) throws Exception {
+        return Collections.emptyList();
+      }
+    });
+    ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
+    when(mockResourceResolver.resolveTxt(anyString()))
+        .thenReturn(Collections.<String>emptyList());
 
+    dnsResolver.setResourceResolver(mockResourceResolver);
+
+    resolver.start(mockListener);
+    syncContext.execute(() -> assertThat(fakeExecutor.runDueTasks()).isEqualTo(1));
+
+    ArgumentCaptor<ResolutionResult> ac = ArgumentCaptor.forClass(ResolutionResult.class);
+    verify(mockListener).onResult2(ac.capture());
     verifyNoMoreInteractions(mockListener);
+    assertThat(ac.getValue().getAddressesOrError().getValue()).isEmpty();
+    assertThat(ac.getValue().getServiceConfig()).isNull();
+    verify(mockResourceResolver, never()).resolveSrv(anyString());
+
+    assertEquals(0, fakeClock.numPendingTasks());
+    // A retry should be scheduled
+    assertThat(fakeExecutor.numPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER)).isEqualTo(1);
   }
 
   @Test
-  public void refreshCancelsScheduledRetry() throws Exception {
+  public void resolve_nullResourceResolver() throws Exception {
+    DnsNameResolver.enableTxt = true;
+    InetAddress backendAddr = InetAddresses.fromInteger(0x7f000001);
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    when(mockAddressResolver.resolveAddress(anyString()))
+        .thenReturn(Collections.singletonList(backendAddr));
     String name = "foo.googleapis.com";
-    UnknownHostException error = new UnknownHostException(name);
-    InetAddress[] answer = createAddressList(2);
-    MockResolver resolver = new MockResolver(name, 81, error, answer);
+
+    RetryingNameResolver resolver = newResolver(name, 81);
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    dnsResolver.setAddressResolver(mockAddressResolver);
+    dnsResolver.setResourceResolver(null);
     resolver.start(mockListener);
     assertEquals(1, fakeExecutor.runDueTasks());
-    verify(mockListener).onError(statusCaptor.capture());
-    assertEquals(name, resolver.invocations.poll());
-    Status status = statusCaptor.getValue();
-    assertEquals(Status.Code.UNAVAILABLE, status.getCode());
-    assertSame(error, status.getCause());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    ResolutionResult result = resultCaptor.getValue();
+    InetSocketAddress resolvedBackendAddr =
+        (InetSocketAddress) Iterables.getOnlyElement(
+            Iterables.getOnlyElement(result.getAddressesOrError().getValue()).getAddresses());
+    assertThat(resolvedBackendAddr.getAddress()).isEqualTo(backendAddr);
+    verify(mockAddressResolver).resolveAddress(name);
+    assertThat(result.getServiceConfig()).isNull();
 
-    // First retry scheduled
-    assertEquals(1, fakeClock.numPendingTasks());
+    assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
+  }
 
-    resolver.refresh();
+  @Test
+  public void resolve_nullResourceResolver_addressFailure() throws Exception {
+    DnsNameResolver.enableTxt = true;
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    when(mockAddressResolver.resolveAddress(anyString()))
+        .thenThrow(new IOException("no addr"));
+    when(mockListener.onResult2(isA(ResolutionResult.class))).thenReturn(Status.UNAVAILABLE);
+    String name = "foo.googleapis.com";
+
+    RetryingNameResolver resolver = newResolver(name, 81);
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    dnsResolver.setAddressResolver(mockAddressResolver);
+    dnsResolver.setResourceResolver(null);
+    resolver.start(mockListener);
     assertEquals(1, fakeExecutor.runDueTasks());
-    // Refresh cancelled the retry
+    verify(mockListener).onResult2(resultCaptor.capture());
+    Status errorStatus = resultCaptor.getValue().getAddressesOrError().getStatus();
+    assertThat(errorStatus.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(errorStatus.getCause()).hasMessageThat().contains("no addr");
+
     assertEquals(0, fakeClock.numPendingTasks());
-    verify(mockListener).onUpdate(resultCaptor.capture(), any(Attributes.class));
-    assertEquals(name, resolver.invocations.poll());
-    assertAnswerMatches(answer, 81, Iterables.getOnlyElement(resultCaptor.getValue()));
+    // A retry should be scheduled
+    assertThat(fakeExecutor.numPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER)).isEqualTo(1);
+  }
 
-    verifyNoMoreInteractions(mockListener);
+  @Test
+  public void resolve_presentResourceResolver() throws Exception {
+    DnsNameResolver.enableTxt = true;
+    InetAddress backendAddr = InetAddresses.fromInteger(0x7f000001);
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    when(mockAddressResolver.resolveAddress(anyString()))
+        .thenReturn(Collections.singletonList(backendAddr));
+    ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
+    when(mockResourceResolver.resolveTxt(anyString()))
+        .thenReturn(
+            Collections.singletonList(
+                "grpc_config=[{\"clientLanguage\": [\"java\"], \"serviceConfig\": {}}]"));
+    ServiceConfigParser serviceConfigParser = new ServiceConfigParser() {
+      @Override
+      public ConfigOrError parseServiceConfig(Map<String, ?> rawServiceConfig) {
+        return ConfigOrError.fromConfig(rawServiceConfig);
+      }
+    };
+    NameResolver.Args args =
+        NameResolver.Args.newBuilder()
+            .setDefaultPort(DEFAULT_PORT)
+            .setProxyDetector(GrpcUtil.NOOP_PROXY_DETECTOR)
+            .setSynchronizationContext(syncContext)
+            .setServiceConfigParser(serviceConfigParser)
+            .setScheduledExecutorService(fakeClock.getScheduledExecutorService())
+            .build();
+
+    String name = "foo.googleapis.com";
+    RetryingNameResolver resolver = newResolver(name, Stopwatch.createUnstarted(), false, args);
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    dnsResolver.setAddressResolver(mockAddressResolver);
+    dnsResolver.setResourceResolver(mockResourceResolver);
+
+    resolver.start(mockListener);
+    assertEquals(1, fakeExecutor.runDueTasks());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    ResolutionResult result = resultCaptor.getValue();
+    InetSocketAddress resolvedBackendAddr =
+        (InetSocketAddress) Iterables.getOnlyElement(
+            Iterables.getOnlyElement(result.getAddressesOrError().getValue()).getAddresses());
+    assertThat(resolvedBackendAddr.getAddress()).isEqualTo(backendAddr);
+    assertThat(result.getServiceConfig().getConfig()).isNotNull();
+    verify(mockAddressResolver).resolveAddress(name);
+    verify(mockResourceResolver).resolveTxt("_grpc_config." + name);
+
+    assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
   }
 
   @Test
-  public void shutdownCancelsScheduledRetry() throws Exception {
+  public void resolve_addressFailure_neverLookUpServiceConfig() throws Exception {
+    DnsNameResolver.enableTxt = true;
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    when(mockAddressResolver.resolveAddress(anyString()))
+        .thenThrow(new IOException("no addr"));
+    when(mockListener.onResult2(isA(ResolutionResult.class))).thenReturn(Status.UNAVAILABLE);
     String name = "foo.googleapis.com";
-    UnknownHostException error = new UnknownHostException(name);
-    MockResolver resolver = new MockResolver(name, 81, error);
+
+    ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
+    RetryingNameResolver resolver = newResolver(name, 81);
+    DnsNameResolver dnsResolver = (DnsNameResolver)resolver.getRetriedNameResolver();
+    dnsResolver.setAddressResolver(mockAddressResolver);
+    dnsResolver.setResourceResolver(mockResourceResolver);
     resolver.start(mockListener);
     assertEquals(1, fakeExecutor.runDueTasks());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    Status errorStatus = resultCaptor.getValue().getAddressesOrError().getStatus();
+    assertThat(errorStatus.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(errorStatus.getCause()).hasMessageThat().contains("no addr");
+    verify(mockResourceResolver, never()).resolveTxt(anyString());
+
+    assertEquals(0, fakeClock.numPendingTasks());
+    // A retry should be scheduled
+    assertThat(fakeExecutor.numPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER)).isEqualTo(1);
+  }
 
-    verify(mockListener).onError(statusCaptor.capture());
-    assertEquals(name, resolver.invocations.poll());
-    Status status = statusCaptor.getValue();
-    assertEquals(Status.Code.UNAVAILABLE, status.getCode());
-    assertSame(error, status.getCause());
+  @Test
+  public void resolve_serviceConfigLookupFails_nullServiceConfig() throws Exception {
+    DnsNameResolver.enableTxt = true;
+    InetAddress backendAddr = InetAddresses.fromInteger(0x7f000001);
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    when(mockAddressResolver.resolveAddress(anyString()))
+        .thenReturn(Collections.singletonList(backendAddr));
+    String name = "foo.googleapis.com";
+    ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
+    when(mockResourceResolver.resolveTxt(anyString()))
+        .thenThrow(new Exception("something like javax.naming.NamingException"));
 
-    // Retry scheduled
-    assertEquals(1, fakeClock.numPendingTasks());
+    RetryingNameResolver resolver = newResolver(name, 81);
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    dnsResolver.setAddressResolver(mockAddressResolver);
+    dnsResolver.setResourceResolver(mockResourceResolver);
+    resolver.start(mockListener);
+    assertEquals(1, fakeExecutor.runDueTasks());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    ResolutionResult result = resultCaptor.getValue();
+    InetSocketAddress resolvedBackendAddr =
+        (InetSocketAddress) Iterables.getOnlyElement(
+            Iterables.getOnlyElement(result.getAddressesOrError().getValue()).getAddresses());
+    assertThat(resolvedBackendAddr.getAddress()).isEqualTo(backendAddr);
+    verify(mockAddressResolver).resolveAddress(name);
+    assertThat(result.getServiceConfig()).isNull();
+    verify(mockResourceResolver).resolveTxt(anyString());
 
-    // Shutdown cancelled the retry
-    resolver.shutdown();
     assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
+  }
 
-    verifyNoMoreInteractions(mockListener);
+  @Test
+  public void resolve_serviceConfigMalformed_serviceConfigError() throws Exception {
+    DnsNameResolver.enableTxt = true;
+    InetAddress backendAddr = InetAddresses.fromInteger(0x7f000001);
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    when(mockAddressResolver.resolveAddress(anyString()))
+        .thenReturn(Collections.singletonList(backendAddr));
+    String name = "foo.googleapis.com";
+    ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
+    when(mockResourceResolver.resolveTxt(anyString()))
+        .thenReturn(Collections.singletonList("grpc_config=something invalid"));
+
+    RetryingNameResolver resolver = newResolver(name, 81);
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    dnsResolver.setAddressResolver(mockAddressResolver);
+    dnsResolver.setResourceResolver(mockResourceResolver);
+    resolver.start(mockListener);
+    assertEquals(1, fakeExecutor.runDueTasks());
+    verify(mockListener).onResult2(resultCaptor.capture());
+    ResolutionResult result = resultCaptor.getValue();
+    InetSocketAddress resolvedBackendAddr =
+        (InetSocketAddress) Iterables.getOnlyElement(
+            Iterables.getOnlyElement(result.getAddressesOrError().getValue()).getAddresses());
+    assertThat(resolvedBackendAddr.getAddress()).isEqualTo(backendAddr);
+    verify(mockAddressResolver).resolveAddress(name);
+    assertThat(result.getServiceConfig()).isNotNull();
+    assertThat(result.getServiceConfig().getError()).isNotNull();
+    verify(mockResourceResolver).resolveTxt(anyString());
+
+    assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
+  }
+
+  @Test
+  public void skipMissingJndiResolverResolver() throws Exception {
+    ClassLoader cl = new ClassLoader() {
+      @Override
+      protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+        if ("io.grpc.internal.JndiResourceResolverFactory".equals(name)) {
+          throw new ClassNotFoundException();
+        }
+        return super.loadClass(name, resolve);
+      }
+    };
+
+    ResourceResolverFactory factory = DnsNameResolver.getResourceResolverFactory(cl);
+
+    assertThat(factory).isNull();
+  }
+
+  @Test
+  public void skipWrongJndiResolverResolver() throws Exception {
+    ClassLoader cl = new StaticTestingClassLoader(
+        DnsNameResolverTest.class.getClassLoader(),
+        Pattern.compile("io\\.grpc\\..+"));
+
+    ResourceResolverFactory factory = DnsNameResolver.getResourceResolverFactory(cl);
+
+    assertThat(factory).isNull();
+  }
+
+  @Test
+  public void doNotResolveWhenProxyDetected() throws Exception {
+    final String name = "foo.googleapis.com";
+    final int port = 81;
+    final InetSocketAddress proxyAddress =
+        new InetSocketAddress(InetAddress.getByName("10.0.0.1"), 1000);
+    ProxyDetector alwaysDetectProxy = new ProxyDetector() {
+        @Override
+        public HttpConnectProxiedSocketAddress proxyFor(SocketAddress targetAddress) {
+          return HttpConnectProxiedSocketAddress.newBuilder()
+              .setTargetAddress((InetSocketAddress) targetAddress)
+              .setProxyAddress(proxyAddress)
+              .setUsername("username")
+              .setPassword("password").build();
+        }
+      };
+    RetryingNameResolver resolver = newResolver(
+        name, port, alwaysDetectProxy, Stopwatch.createUnstarted());
+    DnsNameResolver dnsResolver = (DnsNameResolver) resolver.getRetriedNameResolver();
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    when(mockAddressResolver.resolveAddress(anyString())).thenThrow(new AssertionError());
+    dnsResolver.setAddressResolver(mockAddressResolver);
+    resolver.start(mockListener);
+    assertEquals(1, fakeExecutor.runDueTasks());
+
+    verify(mockListener).onResult2(resultCaptor.capture());
+    List<EquivalentAddressGroup> result = resultCaptor.getValue().getAddressesOrError().getValue();
+    assertThat(result).hasSize(1);
+    EquivalentAddressGroup eag = result.get(0);
+    assertThat(eag.getAddresses()).hasSize(1);
+
+    HttpConnectProxiedSocketAddress socketAddress =
+        (HttpConnectProxiedSocketAddress) eag.getAddresses().get(0);
+    assertSame(proxyAddress, socketAddress.getProxyAddress());
+    assertEquals("username", socketAddress.getUsername());
+    assertEquals("password", socketAddress.getPassword());
+    assertTrue(socketAddress.getTargetAddress().isUnresolved());
+
+    assertEquals(0, fakeClock.numPendingTasks());
+    assertEquals(0, fakeExecutor.numPendingTasks());
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_failsOnMisspelling() {
+    Map<String, Object> bad = new LinkedHashMap<>();
+    bad.put("parcentage", 1.0);
+    Random random = new Random();
+    VerifyException e = assertThrows(VerifyException.class,
+        () -> DnsNameResolver.maybeChooseServiceConfig(bad, random, "host"));
+    assertThat(e).hasMessageThat().isEqualTo("Bad key: parcentage=1.0");
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_clientLanguageMatchesJava() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    List<String> langs = new ArrayList<>();
+    langs.add("java");
+    choice.put("clientLanguage", langs);
+    choice.put("serviceConfig", serviceConfig);
+
+    assertNotNull(DnsNameResolver.maybeChooseServiceConfig(choice, new Random(), "host"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_clientLanguageDoesntMatchGo() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    List<String> langs = new ArrayList<>();
+    langs.add("go");
+    choice.put("clientLanguage", langs);
+    choice.put("serviceConfig", serviceConfig);
+
+    assertNull(DnsNameResolver.maybeChooseServiceConfig(choice, new Random(), "host"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_clientLanguageCaseInsensitive() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    List<String> langs = new ArrayList<>();
+    langs.add("JAVA");
+    choice.put("clientLanguage", langs);
+    choice.put("serviceConfig", serviceConfig);
+
+    assertNotNull(DnsNameResolver.maybeChooseServiceConfig(choice, new Random(), "host"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_clientLanguageMatchesEmpty() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    List<String> langs = new ArrayList<>();
+    choice.put("clientLanguage", langs);
+    choice.put("serviceConfig", serviceConfig);
+
+    assertNotNull(DnsNameResolver.maybeChooseServiceConfig(choice, new Random(), "host"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_clientLanguageMatchesMulti() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    List<String> langs = new ArrayList<>();
+    langs.add("go");
+    langs.add("java");
+    choice.put("clientLanguage", langs);
+    choice.put("serviceConfig", serviceConfig);
+
+    assertNotNull(DnsNameResolver.maybeChooseServiceConfig(choice, new Random(), "host"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_percentageZeroAlwaysFails() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    choice.put("percentage", 0D);
+    choice.put("serviceConfig", serviceConfig);
+
+    assertNull(DnsNameResolver.maybeChooseServiceConfig(choice, new Random(), "host"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_percentageHundredAlwaysSucceeds() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    choice.put("percentage", 100D);
+    choice.put("serviceConfig", serviceConfig);
+
+    assertNotNull(DnsNameResolver.maybeChooseServiceConfig(choice, new Random(), "host"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_percentageAboveMatches50() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    choice.put("percentage", 50D);
+    choice.put("serviceConfig", serviceConfig);
+
+    Random r = new Random() {
+      @Override
+      public int nextInt(int bound) {
+        return 49;
+      }
+    };
+
+    assertNotNull(DnsNameResolver.maybeChooseServiceConfig(choice, r, "host"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_percentageAtFails50() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    choice.put("percentage", 50D);
+    choice.put("serviceConfig", serviceConfig);
+
+    Random r = new Random() {
+      @Override
+      public int nextInt(int bound) {
+        return 50;
+      }
+    };
+
+    assertNull(DnsNameResolver.maybeChooseServiceConfig(choice, r, "host"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_percentageAboveMatches99() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    choice.put("percentage", 99D);
+    choice.put("serviceConfig", serviceConfig);
+
+    Random r = new Random() {
+      @Override
+      public int nextInt(int bound) {
+        return 98;
+      }
+    };
+
+    assertNotNull(DnsNameResolver.maybeChooseServiceConfig(choice, r, "host"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_percentageAtFails99() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    choice.put("percentage", 99D);
+    choice.put("serviceConfig", serviceConfig);
+
+    Random r = new Random() {
+      @Override
+      public int nextInt(int bound) {
+        return 99;
+      }
+    };
+
+    assertNull(DnsNameResolver.maybeChooseServiceConfig(choice, r, "host"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_percentageAboveMatches1() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    choice.put("percentage", 1D);
+    choice.put("serviceConfig", serviceConfig);
+
+    Random r = new Random() {
+      @Override
+      public int nextInt(int bound) {
+        return 0;
+      }
+    };
+
+    assertNotNull(DnsNameResolver.maybeChooseServiceConfig(choice, r, "host"));
   }
 
-  private void testInvalidUri(URI uri) {
+  @Test
+  public void maybeChooseServiceConfig_percentageAtFails1() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    choice.put("percentage", 1D);
+    choice.put("serviceConfig", serviceConfig);
+
+    Random r = new Random() {
+      @Override
+      public int nextInt(int bound) {
+        return 1;
+      }
+    };
+
+    assertNull(DnsNameResolver.maybeChooseServiceConfig(choice, r, "host"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_hostnameMatches() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    List<String> hosts = new ArrayList<>();
+    hosts.add("localhost");
+    choice.put("clientHostname", hosts);
+    choice.put("serviceConfig", serviceConfig);
+
+    assertNotNull(DnsNameResolver.maybeChooseServiceConfig(choice, new Random(), "localhost"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_hostnameDoesntMatch() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    List<String> hosts = new ArrayList<>();
+    hosts.add("localhorse");
+    choice.put("clientHostname", hosts);
+    choice.put("serviceConfig", serviceConfig);
+
+    assertNull(DnsNameResolver.maybeChooseServiceConfig(choice, new Random(), "localhost"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_clientLanguageCaseSensitive() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    List<String> hosts = new ArrayList<>();
+    hosts.add("LOCALHOST");
+    choice.put("clientHostname", hosts);
+    choice.put("serviceConfig", serviceConfig);
+
+    assertNull(DnsNameResolver.maybeChooseServiceConfig(choice, new Random(), "localhost"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_hostnameMatchesEmpty() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    List<String> hosts = new ArrayList<>();
+    choice.put("clientHostname", hosts);
+    choice.put("serviceConfig", serviceConfig);
+
+    assertNotNull(DnsNameResolver.maybeChooseServiceConfig(choice, new Random(), "host"));
+  }
+
+  @Test
+  public void maybeChooseServiceConfig_hostnameMatchesMulti() {
+    Map<String, Object> choice = new LinkedHashMap<>();
+    List<String> hosts = new ArrayList<>();
+    hosts.add("localhorse");
+    hosts.add("localhost");
+    choice.put("clientHostname", hosts);
+    choice.put("serviceConfig", serviceConfig);
+
+    assertNotNull(DnsNameResolver.maybeChooseServiceConfig(choice, new Random(), "localhost"));
+  }
+
+  @Test
+  public void parseTxtResults_misspelledName() throws Exception {
+    List<String> txtRecords = new ArrayList<>();
+    txtRecords.add("some_record");
+    txtRecords.add("_grpc_config=[]");
+
+    List<? extends Map<String, ?>> results = DnsNameResolver.parseTxtResults(txtRecords);
+
+    assertThat(results).isEmpty();
+  }
+
+  @Test
+  public void parseTxtResults_badTypeFails() {
+    List<String> txtRecords = new ArrayList<>();
+    txtRecords.add("some_record");
+    txtRecords.add("grpc_config={}");
+
+    ClassCastException e = assertThrows(ClassCastException.class,
+        () -> DnsNameResolver.parseTxtResults(txtRecords));
+    assertThat(e).hasMessageThat().isEqualTo("wrong type {}");
+  }
+
+  @Test
+  public void parseTxtResults_badInnerTypeFails() {
+    List<String> txtRecords = new ArrayList<>();
+    txtRecords.add("some_record");
+    txtRecords.add("grpc_config=[\"bogus\"]");
+
+    ClassCastException e = assertThrows(ClassCastException.class,
+        () -> DnsNameResolver.parseTxtResults(txtRecords));
+    assertThat(e).hasMessageThat().isEqualTo("value bogus for idx 0 in [bogus] is not object");
+  }
+
+  @Test
+  public void parseTxtResults_combineAll() throws Exception {
+    Logger logger = Logger.getLogger(DnsNameResolver.class.getName());
+    Level level = logger.getLevel();
+    logger.setLevel(Level.SEVERE);
     try {
-      provider.newNameResolver(uri, NAME_RESOLVER_PARAMS);
-      fail("Should have failed");
-    } catch (IllegalArgumentException e) {
-      // expected
+      List<String> txtRecords = new ArrayList<>();
+      txtRecords.add("some_record");
+      txtRecords.add("grpc_config=[{}, {}]"); // 2 records
+      txtRecords.add("grpc_config=[{\"\":{}}]"); // 1 record
+
+      List<? extends Map<String, ?>> results = DnsNameResolver.parseTxtResults(txtRecords);
+
+      assertThat(results).hasSize(2 + 1);
+    } finally {
+      logger.setLevel(level);
     }
   }
 
-  private void testValidUri(URI uri, String exportedAuthority, int expectedPort) {
-    DnsNameResolver resolver = provider.newNameResolver(uri, NAME_RESOLVER_PARAMS);
-    assertNotNull(resolver);
-    assertEquals(expectedPort, resolver.getPort());
-    assertEquals(exportedAuthority, resolver.getServiceAuthority());
+  @Test
+  public void shouldUseJndi_alwaysFalseIfDisabled() {
+    boolean enableJndi = false;
+    boolean enableJndiLocalhost = true;
+    String host = "seemingly.valid.host";
+
+    assertFalse(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, host));
   }
 
-  private byte lastByte = 0;
+  @Test
+  public void shouldUseJndi_falseIfDisabledForLocalhost() {
+    boolean enableJndi = true;
+    boolean enableJndiLocalhost = false;
 
-  private InetAddress[] createAddressList(int n) throws UnknownHostException {
-    InetAddress[] list = new InetAddress[n];
-    for (int i = 0; i < n; i++) {
-      list[i] = InetAddress.getByAddress(new byte[] {127, 0, 0, ++lastByte});
-    }
-    return list;
+    assertFalse(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, "localhost"));
+    assertFalse(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, "LOCALHOST"));
   }
 
-  private static void assertAnswerMatches(InetAddress[] addrs, int port,
-      ResolvedServerInfoGroup result) {
-    assertEquals(addrs.length, result.getResolvedServerInfoList().size());
-    for (int i = 0; i < addrs.length; i++) {
-      InetSocketAddress socketAddr = (InetSocketAddress) result.getResolvedServerInfoList().get(
-          i).getAddress();
-      assertEquals("Addr " + i, port, socketAddr.getPort());
-      assertEquals("Addr " + i, addrs[i], socketAddr.getAddress());
-    }
+  @Test
+  public void shouldUseJndi_trueIfLocalhostOverridden() {
+    boolean enableJndi = true;
+    boolean enableJndiLocalhost = true;
+    String host = "localhost";
+
+    assertTrue(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, host));
   }
 
-  private class MockResolver extends DnsNameResolver {
-    final LinkedList<Object> answers = new LinkedList<Object>();
-    final LinkedList<String> invocations = new LinkedList<String>();
+  @Test
+  public void shouldUseJndi_falseForIpv6() {
+    boolean enableJndi = true;
+    boolean enableJndiLocalhost = false;
 
-    MockResolver(String name, int defaultPort, Object ... answers) {
-      super(null, name, Attributes.newBuilder().set(
-          NameResolver.Factory.PARAMS_DEFAULT_PORT, defaultPort).build(), fakeTimerServiceResource,
-          fakeExecutorResource);
-      for (Object answer : answers) {
-        this.answers.add(answer);
-      }
+    assertFalse(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, "::"));
+    assertFalse(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, "::1"));
+    assertFalse(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, "2001:db8:1234::"));
+    assertFalse(DnsNameResolver.shouldUseJndi(
+        enableJndi, enableJndiLocalhost, "[2001:db8:1234::]"));
+    assertFalse(DnsNameResolver.shouldUseJndi(
+        enableJndi, enableJndiLocalhost, "2001:db8:1234::%3"));
+  }
+
+  @Test
+  public void shouldUseJndi_falseForIpv4() {
+    boolean enableJndi = true;
+    boolean enableJndiLocalhost = false;
+
+    assertFalse(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, "127.0.0.1"));
+    assertFalse(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, "192.168.0.1"));
+    assertFalse(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, "134744072"));
+  }
+
+  @Test
+  public void shouldUseJndi_falseForEmpty() {
+    boolean enableJndi = true;
+    boolean enableJndiLocalhost = false;
+
+    assertFalse(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, ""));
+  }
+
+  @Test
+  public void shouldUseJndi_trueIfItMightPossiblyBeValid() {
+    boolean enableJndi = true;
+    boolean enableJndiLocalhost = false;
+
+    assertTrue(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, "remotehost"));
+    assertTrue(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, "remotehost.gov"));
+    assertTrue(DnsNameResolver.shouldUseJndi(enableJndi, enableJndiLocalhost, "f.q.d.n."));
+    assertTrue(DnsNameResolver.shouldUseJndi(
+        enableJndi, enableJndiLocalhost, "8.8.8.8.in-addr.arpa."));
+    assertTrue(DnsNameResolver.shouldUseJndi(
+        enableJndi, enableJndiLocalhost, "2001-db8-1234--as3.ipv6-literal.net"));
+  }
+
+  @Test
+  public void parseServiceConfig_capturesParseError() {
+    ConfigOrError result = DnsNameResolver.parseServiceConfig(
+        Arrays.asList("grpc_config=bogus"), new Random(), "localhost");
+
+    assertThat(result).isNotNull();
+    assertThat(result.getError().getCode()).isEqualTo(Status.Code.UNKNOWN);
+    assertThat(result.getError().getDescription()).contains("failed to parse TXT records");
+  }
+
+  @Test
+  public void parseServiceConfig_capturesChoiceError() {
+    ConfigOrError result = DnsNameResolver.parseServiceConfig(
+        Arrays.asList("grpc_config=[{\"hi\":{}}]"), new Random(), "localhost");
+
+    assertThat(result).isNotNull();
+    assertThat(result.getError().getCode()).isEqualTo(Status.Code.UNKNOWN);
+    assertThat(result.getError().getDescription()).contains("failed to pick");
+  }
+
+  @Test
+  public void parseServiceConfig_noChoiceIsNull() {
+    ConfigOrError result = DnsNameResolver.parseServiceConfig(
+        Arrays.asList("grpc_config=[]"), new Random(), "localhost");
+
+    assertThat(result).isNull();
+  }
+
+  @Test
+  public void parseServiceConfig_matches() {
+    ConfigOrError result = DnsNameResolver.parseServiceConfig(
+        Arrays.asList("grpc_config=[{\"serviceConfig\":{}}]"), new Random(), "localhost");
+
+    assertThat(result).isNotNull();
+    assertThat(result.getError()).isNull();
+    assertThat(result.getConfig()).isEqualTo(ImmutableMap.of());
+  }
+
+  private byte lastByte = 0;
+
+  private List<InetAddress> createAddressList(int n) throws UnknownHostException {
+    List<InetAddress> list = new ArrayList<>(n);
+    for (int i = 0; i < n; i++) {
+      list.add(InetAddress.getByAddress(new byte[] {127, 0, 0, ++lastByte}));
     }
+    return list;
+  }
 
-    @Override
-    InetAddress[] getAllByName(String host) throws UnknownHostException {
-      invocations.add(host);
-      Object answer = answers.poll();
-      if (answer instanceof UnknownHostException) {
-        throw (UnknownHostException) answer;
-      }
-      return (InetAddress[]) answer;
+  private static void assertAnswerMatches(
+      List<InetAddress> addrs, int port, ResolutionResult resolutionResult) {
+    assertThat(resolutionResult.getAddressesOrError().getValue()).hasSize(addrs.size());
+    for (int i = 0; i < addrs.size(); i++) {
+      EquivalentAddressGroup addrGroup = resolutionResult.getAddressesOrError().getValue().get(i);
+      InetSocketAddress socketAddr =
+          (InetSocketAddress) Iterables.getOnlyElement(addrGroup.getAddresses());
+      assertEquals("Addr " + i, port, socketAddr.getPort());
+      assertEquals("Addr " + i, addrs.get(i), socketAddr.getAddress());
     }
   }
 }
diff --git a/core/src/test/java/io/grpc/internal/ExponentialBackoffPolicyTest.java b/core/src/test/java/io/grpc/internal/ExponentialBackoffPolicyTest.java
index 5eca3eeb8e8..ca597a82c95 100644
--- a/core/src/test/java/io/grpc/internal/ExponentialBackoffPolicyTest.java
+++ b/core/src/test/java/io/grpc/internal/ExponentialBackoffPolicyTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -54,16 +39,16 @@ public double nextDouble() {
 
   @Test
   public void maxDelayReached() {
-    long maxBackoffMillis = 120 * 1000;
-    policy.setMaxBackoffMillis(maxBackoffMillis)
+    long maxBackoffNanos = 120 * 1000;
+    policy.setMaxBackoffNanos(maxBackoffNanos)
         .setJitter(0)
         .setRandom(notRandom);
     for (int i = 0; i < 50; i++) {
-      if (maxBackoffMillis == policy.nextBackoffMillis()) {
+      if (maxBackoffNanos == policy.nextBackoffNanos()) {
         return; // Success
       }
     }
-    assertEquals("max delay not reached", maxBackoffMillis, policy.nextBackoffMillis());
+    assertEquals("max delay not reached", maxBackoffNanos, policy.nextBackoffNanos());
   }
 
   @Test public void canProvide() {
diff --git a/core/src/test/java/io/grpc/internal/FailingClientStreamTest.java b/core/src/test/java/io/grpc/internal/FailingClientStreamTest.java
new file mode 100644
index 00000000000..c07812577d5
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/FailingClientStreamTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.ClientStreamTracer;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link FailingClientStream}.
+ */
+@RunWith(JUnit4.class)
+public class FailingClientStreamTest {
+  private static final ClientStreamTracer[] tracers = new ClientStreamTracer[] {
+      new ClientStreamTracer() {}
+  };
+
+  @Test
+  public void processedRpcProgressPopulatedToListener() {
+    ClientStreamListener listener = mock(ClientStreamListener.class);
+    Status status = Status.UNAVAILABLE;
+
+    ClientStream stream = new FailingClientStream(status, RpcProgress.PROCESSED, tracers);
+    stream.start(listener);
+    verify(listener).closed(eq(status), eq(RpcProgress.PROCESSED), any(Metadata.class));
+  }
+
+  @Test
+  public void droppedRpcProgressPopulatedToListener() {
+    ClientStreamListener listener = mock(ClientStreamListener.class);
+    Status status = Status.UNAVAILABLE;
+
+    ClientStream stream = new FailingClientStream(status, RpcProgress.DROPPED, tracers);
+    stream.start(listener);
+    verify(listener).closed(eq(status), eq(RpcProgress.DROPPED), any(Metadata.class));
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/FailingClientTransportTest.java b/core/src/test/java/io/grpc/internal/FailingClientTransportTest.java
new file mode 100644
index 00000000000..98749d74910
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/FailingClientTransportTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
+import io.grpc.testing.TestMethodDescriptors;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link FailingClientTransport}.
+ */
+@RunWith(JUnit4.class)
+public class FailingClientTransportTest {
+
+  @Test
+  public void newStreamStart() {
+    Status error = Status.UNAVAILABLE;
+    RpcProgress rpcProgress = RpcProgress.DROPPED;
+    FailingClientTransport transport = new FailingClientTransport(error, rpcProgress);
+    ClientStream stream = transport.newStream(
+        TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT,
+        new ClientStreamTracer[] { new ClientStreamTracer() {} });
+    ClientStreamListener listener = mock(ClientStreamListener.class);
+    stream.start(listener);
+
+    verify(listener).closed(eq(error), eq(rpcProgress), any(Metadata.class));
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/FakeCallCredentials.java b/core/src/test/java/io/grpc/internal/FakeCallCredentials.java
new file mode 100644
index 00000000000..8161aacccdd
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/FakeCallCredentials.java
@@ -0,0 +1,41 @@
+/*
+ * 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.internal;
+
+import io.grpc.CallCredentials;
+import io.grpc.Metadata;
+import java.util.concurrent.Executor;
+
+/**
+ * CallCredentials that provides a single, fixed header.
+ */
+final class FakeCallCredentials extends CallCredentials {
+  private final Metadata headers;
+
+  public <T> FakeCallCredentials(Metadata.Key<T> key, T value) {
+    headers = new Metadata();
+    headers.put(key, value);
+  }
+
+  @Override
+  public void applyRequestMetadata(
+      CallCredentials.RequestInfo requestInfo,
+      Executor appExecutor,
+      CallCredentials.MetadataApplier applier) {
+    applier.apply(headers);
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/FakeClock.java b/core/src/test/java/io/grpc/internal/FakeClock.java
deleted file mode 100644
index 651856beeea..00000000000
--- a/core/src/test/java/io/grpc/internal/FakeClock.java
+++ /dev/null
@@ -1,279 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import com.google.common.base.Stopwatch;
-import com.google.common.base.Supplier;
-import com.google.common.base.Ticker;
-import com.google.common.util.concurrent.AbstractFuture;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.concurrent.Callable;
-import java.util.concurrent.Delayed;
-import java.util.concurrent.Future;
-import java.util.concurrent.PriorityBlockingQueue;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.TimeUnit;
-
-/**
- * A manipulated clock that exports a {@link Ticker} and a {@link ScheduledExecutorService}.
- *
- * <p>To simulate the locking scenario of using real executors, it never runs tasks within {@code
- * schedule()} or {@code execute()}. Instead, you should call {@link #runDueTasks} in your test
- * method to run all due tasks. {@link #forwardTime} and {@link #forwardMillis} call {@link
- * #runDueTasks} automatically.
- */
-public final class FakeClock {
-
-  private final ScheduledExecutorService scheduledExecutorService = new ScheduledExecutorImpl();
-
-  private final PriorityBlockingQueue<ScheduledTask> tasks =
-      new PriorityBlockingQueue<ScheduledTask>();
-
-  private final Ticker ticker =
-      new Ticker() {
-        @Override public long read() {
-          return currentTimeNanos;
-        }
-      };
-
-  private final Supplier<Stopwatch> stopwatchSupplier =
-      new Supplier<Stopwatch>() {
-        @Override public Stopwatch get() {
-          return Stopwatch.createUnstarted(ticker);
-        }
-      };
-
-  private long currentTimeNanos;
-
-  public class ScheduledTask extends AbstractFuture<Void> implements ScheduledFuture<Void> {
-    public final Runnable command;
-    public final long dueTimeNanos;
-
-    ScheduledTask(long dueTimeNanos, Runnable command) {
-      this.dueTimeNanos = dueTimeNanos;
-      this.command = command;
-    }
-
-    @Override public boolean cancel(boolean mayInterruptIfRunning) {
-      tasks.remove(this);
-      return super.cancel(mayInterruptIfRunning);
-    }
-
-    @Override public long getDelay(TimeUnit unit) {
-      return unit.convert(dueTimeNanos - currentTimeNanos, TimeUnit.NANOSECONDS);
-    }
-
-    @Override public int compareTo(Delayed other) {
-      ScheduledTask otherTask = (ScheduledTask) other;
-      if (dueTimeNanos > otherTask.dueTimeNanos) {
-        return 1;
-      } else if (dueTimeNanos < otherTask.dueTimeNanos) {
-        return -1;
-      } else {
-        return 0;
-      }
-    }
-
-    void complete() {
-      set(null);
-    }
-
-    @Override
-    public String toString() {
-      return "[due=" + dueTimeNanos + ", task=" + command + "]";
-    }
-  }
-
-  private class ScheduledExecutorImpl implements ScheduledExecutorService {
-    @Override public <V> ScheduledFuture<V> schedule(
-        Callable<V> callable, long delay, TimeUnit unit) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public ScheduledFuture<?> schedule(Runnable cmd, long delay, TimeUnit unit) {
-      ScheduledTask task = new ScheduledTask(currentTimeNanos + unit.toNanos(delay), cmd);
-      tasks.add(task);
-      return task;
-    }
-
-    @Override public ScheduledFuture<?> scheduleAtFixedRate(
-        Runnable command, long initialDelay, long period, TimeUnit unit) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public ScheduledFuture<?> scheduleWithFixedDelay(
-        Runnable command, long initialDelay, long delay, TimeUnit unit) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public boolean awaitTermination(long timeout, TimeUnit unit) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public <T> List<Future<T>> invokeAll(
-        Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public <T> T invokeAny(Collection<? extends Callable<T>> tasks) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public <T> T invokeAny(
-        Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public boolean isShutdown() {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public boolean isTerminated() {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public void shutdown() {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public List<Runnable> shutdownNow() {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public <T> Future<T> submit(Callable<T> task) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public Future<?> submit(Runnable task) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public <T> Future<T> submit(Runnable task, T result) {
-      throw new UnsupportedOperationException();
-    }
-
-    @Override public void execute(Runnable command) {
-      // Since it is being enqueued immediately, no point in tracing the future for cancellation.
-      Future<?> unused = schedule(command, 0, TimeUnit.NANOSECONDS);
-    }
-  }
-
-  /**
-   * Provides a partially implemented instance of {@link ScheduledExecutorService} that uses the
-   * fake clock ticker for testing.
-   */
-  public ScheduledExecutorService getScheduledExecutorService() {
-    return scheduledExecutorService;
-  }
-
-  /**
-   * Provides a stopwatch instance that uses the fake clock ticker.
-   */
-  public Supplier<Stopwatch> getStopwatchSupplier() {
-    return stopwatchSupplier;
-  }
-
-  /**
-   * Run all due tasks.
-   *
-   * @return the number of tasks run by this call
-   */
-  public int runDueTasks() {
-    int count = 0;
-    while (true) {
-      ScheduledTask task = tasks.peek();
-      if (task == null || task.dueTimeNanos > currentTimeNanos) {
-        break;
-      }
-      if (tasks.remove(task)) {
-        task.command.run();
-        task.complete();
-        count++;
-      }
-    }
-    return count;
-  }
-
-  /**
-   * Return all due tasks.
-   */
-  public Collection<ScheduledTask> getDueTasks() {
-    ArrayList<ScheduledTask> result = new ArrayList<ScheduledTask>();
-    for (ScheduledTask task : tasks) {
-      if (task.dueTimeNanos > currentTimeNanos) {
-        continue;
-      }
-      result.add(task);
-    }
-    return result;
-  }
-
-  /**
-   * Return all unrun tasks.
-   */
-  public Collection<ScheduledTask> getPendingTasks() {
-    return new ArrayList<ScheduledTask>(tasks);
-  }
-
-  /**
-   * Forward the time by the given duration and run all due tasks.
-   *
-   * @return the number of tasks run by this call
-   */
-  public int forwardTime(long value, TimeUnit unit) {
-    currentTimeNanos += unit.toNanos(value);
-    return runDueTasks();
-  }
-
-  /**
-   * Forward the time by the given milliseconds and run all due tasks.
-   *
-   * @return the number of tasks run by this call
-   */
-  public int forwardMillis(long millis) {
-    return forwardTime(millis, TimeUnit.MILLISECONDS);
-  }
-
-  /**
-   * Return the number of queued tasks.
-   */
-  public int numPendingTasks() {
-    return tasks.size();
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/FakeClockTest.java b/core/src/test/java/io/grpc/internal/FakeClockTest.java
index 6b53b0f5cbe..a92cd4926f0 100644
--- a/core/src/test/java/io/grpc/internal/FakeClockTest.java
+++ b/core/src/test/java/io/grpc/internal/FakeClockTest.java
@@ -1,44 +1,31 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
 import com.google.common.base.Stopwatch;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -59,12 +46,12 @@ public void testScheduledExecutorService_sameInstance() {
   public void testScheduledExecutorService_isDone() {
     FakeClock fakeClock = new FakeClock();
     ScheduledFuture<?> future = fakeClock.getScheduledExecutorService()
-        .schedule(newRunnable(), 100L, TimeUnit.MILLISECONDS);
+        .schedule(newRunnable(), 100L, TimeUnit.NANOSECONDS);
 
-    fakeClock.forwardMillis(99L);
+    fakeClock.forwardNanos(99L);
     assertFalse(future.isDone());
 
-    fakeClock.forwardMillis(2L);
+    fakeClock.forwardNanos(2L);
     assertTrue(future.isDone());
   }
 
@@ -72,12 +59,12 @@ public void testScheduledExecutorService_isDone() {
   public void testScheduledExecutorService_cancel() {
     FakeClock fakeClock = new FakeClock();
     ScheduledFuture<?> future = fakeClock.getScheduledExecutorService()
-        .schedule(newRunnable(), 100L, TimeUnit.MILLISECONDS);
+        .schedule(newRunnable(), 100L, TimeUnit.NANOSECONDS);
 
-    fakeClock.forwardMillis(99L);
+    fakeClock.forwardNanos(99L);
     future.cancel(false);
 
-    fakeClock.forwardMillis(2);
+    fakeClock.forwardNanos(2);
     assertTrue(future.isCancelled());
   }
 
@@ -85,10 +72,10 @@ public void testScheduledExecutorService_cancel() {
   public void testScheduledExecutorService_getDelay() {
     FakeClock fakeClock = new FakeClock();
     ScheduledFuture<?> future = fakeClock.getScheduledExecutorService()
-        .schedule(newRunnable(), 100L, TimeUnit.MILLISECONDS);
+        .schedule(newRunnable(), 100L, TimeUnit.NANOSECONDS);
 
-    fakeClock.forwardMillis(90L);
-    assertEquals(10L, future.getDelay(TimeUnit.MILLISECONDS));
+    fakeClock.forwardNanos(90L);
+    assertEquals(10L, future.getDelay(TimeUnit.NANOSECONDS));
   }
 
   @Test
@@ -103,9 +90,9 @@ public void run() {
           }
         },
         100L,
-        TimeUnit.MILLISECONDS);
+        TimeUnit.NANOSECONDS);
 
-    fakeClock.forwardMillis(100L);
+    fakeClock.forwardNanos(100L);
     assertTrue(result[0]);
   }
 
@@ -113,27 +100,27 @@ public void run() {
   public void testStopWatch() {
     FakeClock fakeClock = new FakeClock();
     Stopwatch stopwatch = fakeClock.getStopwatchSupplier().get();
-    long expectedElapsedMillis = 0L;
+    long expectedElapsedNanos = 0L;
 
     stopwatch.start();
 
-    fakeClock.forwardMillis(100L);
-    expectedElapsedMillis += 100L;
-    assertEquals(expectedElapsedMillis, stopwatch.elapsed(TimeUnit.MILLISECONDS));
+    fakeClock.forwardNanos(100L);
+    expectedElapsedNanos += 100L;
+    assertEquals(expectedElapsedNanos, stopwatch.elapsed(TimeUnit.NANOSECONDS));
 
     fakeClock.forwardTime(10L, TimeUnit.MINUTES);
-    expectedElapsedMillis += TimeUnit.MINUTES.toMillis(10L);
-    assertEquals(expectedElapsedMillis, stopwatch.elapsed(TimeUnit.MILLISECONDS));
+    expectedElapsedNanos += TimeUnit.MINUTES.toNanos(10L);
+    assertEquals(expectedElapsedNanos, stopwatch.elapsed(TimeUnit.NANOSECONDS));
 
     stopwatch.stop();
 
-    fakeClock.forwardMillis(1000L);
-    assertEquals(expectedElapsedMillis, stopwatch.elapsed(TimeUnit.MILLISECONDS));
+    fakeClock.forwardNanos(1000L);
+    assertEquals(expectedElapsedNanos, stopwatch.elapsed(TimeUnit.NANOSECONDS));
 
     stopwatch.reset();
 
-    expectedElapsedMillis = 0L;
-    assertEquals(expectedElapsedMillis, stopwatch.elapsed(TimeUnit.MILLISECONDS));
+    expectedElapsedNanos = 0L;
+    assertEquals(expectedElapsedNanos, stopwatch.elapsed(TimeUnit.NANOSECONDS));
   }
 
   @Test
@@ -142,14 +129,14 @@ public void testPendingAndDueTasks() {
     FakeClock fakeClock = new FakeClock();
     ScheduledExecutorService scheduledExecutorService = fakeClock.getScheduledExecutorService();
 
-    scheduledExecutorService.schedule(newRunnable(), 200L, TimeUnit.MILLISECONDS);
+    scheduledExecutorService.schedule(newRunnable(), 200L, TimeUnit.NANOSECONDS);
     scheduledExecutorService.execute(newRunnable());
-    scheduledExecutorService.schedule(newRunnable(), 0L, TimeUnit.MILLISECONDS);
-    scheduledExecutorService.schedule(newRunnable(), 80L, TimeUnit.MILLISECONDS);
-    scheduledExecutorService.schedule(newRunnable(), 90L, TimeUnit.MILLISECONDS);
-    scheduledExecutorService.schedule(newRunnable(), 100L, TimeUnit.MILLISECONDS);
-    scheduledExecutorService.schedule(newRunnable(), 110L, TimeUnit.MILLISECONDS);
-    scheduledExecutorService.schedule(newRunnable(), 120L, TimeUnit.MILLISECONDS);
+    scheduledExecutorService.schedule(newRunnable(), 0L, TimeUnit.NANOSECONDS);
+    scheduledExecutorService.schedule(newRunnable(), 80L, TimeUnit.NANOSECONDS);
+    scheduledExecutorService.schedule(newRunnable(), 90L, TimeUnit.NANOSECONDS);
+    scheduledExecutorService.schedule(newRunnable(), 100L, TimeUnit.NANOSECONDS);
+    scheduledExecutorService.schedule(newRunnable(), 110L, TimeUnit.NANOSECONDS);
+    scheduledExecutorService.schedule(newRunnable(), 120L, TimeUnit.NANOSECONDS);
 
 
     assertEquals(8, fakeClock.numPendingTasks());
@@ -160,17 +147,53 @@ public void testPendingAndDueTasks() {
     assertEquals(6, fakeClock.numPendingTasks());
     assertEquals(0, fakeClock.getDueTasks().size());
 
-    fakeClock.forwardMillis(90L);
+    fakeClock.forwardNanos(90L);
 
     assertEquals(4, fakeClock.numPendingTasks());
     assertEquals(0, fakeClock.getDueTasks().size());
 
-    fakeClock.forwardMillis(20L);
+    fakeClock.forwardNanos(20L);
 
     assertEquals(2, fakeClock.numPendingTasks());
     assertEquals(0, fakeClock.getDueTasks().size());
   }
 
+  @Test
+  public void testTaskFilter() {
+    FakeClock fakeClock = new FakeClock();
+    ScheduledExecutorService scheduledExecutorService = fakeClock.getScheduledExecutorService();
+    final AtomicBoolean selectedDone = new AtomicBoolean();
+    final AtomicBoolean ignoredDone = new AtomicBoolean();
+    final Runnable selectedRunnable = new Runnable() {
+      @Override
+      public void run() {
+        selectedDone.set(true);
+      }
+    };
+    Runnable ignoredRunnable = new Runnable() {
+      @Override
+      public void run() {
+        ignoredDone.set(true);
+      }
+    };
+    FakeClock.TaskFilter filter = new FakeClock.TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable runnable) {
+          return runnable == selectedRunnable;
+        }
+      };
+    scheduledExecutorService.execute(selectedRunnable);
+    scheduledExecutorService.execute(ignoredRunnable);
+    assertEquals(2, fakeClock.numPendingTasks());
+    assertEquals(1, fakeClock.numPendingTasks(filter));
+    assertEquals(2, fakeClock.getPendingTasks().size());
+    assertEquals(1, fakeClock.getPendingTasks(filter).size());
+    assertSame(selectedRunnable, fakeClock.getPendingTasks(filter).iterator().next().command);
+    assertEquals(2, fakeClock.runDueTasks());
+    assertTrue(selectedDone.get());
+    assertTrue(ignoredDone.get());
+  }
+
   private Runnable newRunnable() {
     return new Runnable() {
       @Override
diff --git a/core/src/test/java/io/grpc/internal/ForwardingClientStreamListenerTest.java b/core/src/test/java/io/grpc/internal/ForwardingClientStreamListenerTest.java
new file mode 100644
index 00000000000..fd7b6108c2c
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ForwardingClientStreamListenerTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.ForwardingTestUtil;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
+import io.grpc.internal.StreamListener.MessageProducer;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ForwardingClientStreamListenerTest {
+  private ClientStreamListener mock = mock(ClientStreamListener.class);
+  private ForwardingClientStreamListener forward = new ForwardingClientStreamListener() {
+    @Override
+    protected ClientStreamListener delegate() {
+      return mock;
+    }
+  };
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        ClientStreamListener.class,
+        mock,
+        forward,
+        Collections.<Method>emptyList());
+  }
+
+
+  @Test
+  public void headersReadTest() {
+    Metadata headers = new Metadata();
+    forward.headersRead(headers);
+    verify(mock).headersRead(same(headers));
+  }
+
+  @Test
+  public void closedTest() {
+    Status status = Status.UNKNOWN;
+    Metadata trailers = new Metadata();
+    forward.closed(status, RpcProgress.PROCESSED, trailers);
+    verify(mock).closed(same(status), same(RpcProgress.PROCESSED), same(trailers));
+  }
+
+  @Test
+  public void messagesAvailableTest() {
+    MessageProducer producer = mock(MessageProducer.class);
+    forward.messagesAvailable(producer);
+    verify(mock).messagesAvailable(same(producer));
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ForwardingClientStreamTest.java b/core/src/test/java/io/grpc/internal/ForwardingClientStreamTest.java
new file mode 100644
index 00000000000..7d61a38b4fa
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ForwardingClientStreamTest.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.grpc.Attributes;
+import io.grpc.Compressor;
+import io.grpc.Decompressor;
+import io.grpc.DecompressorRegistry;
+import io.grpc.ForwardingTestUtil;
+import io.grpc.Status;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ForwardingClientStreamTest {
+  private ClientStream mock = mock(ClientStream.class);
+  private ForwardingClientStream forward = new ForwardingClientStream() {
+    @Override
+    protected ClientStream delegate() {
+      return mock;
+    }
+  };
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        ClientStream.class,
+        mock,
+        forward,
+        Collections.<Method>emptyList());
+  }
+
+  @Test
+  public void requestTest() {
+    forward.request(1234);
+    verify(mock).request(1234);
+  }
+
+  @Test
+  public void writeMessageTest() {
+    InputStream is = mock(InputStream.class);
+    forward.writeMessage(is);
+    verify(mock).writeMessage(same(is));
+  }
+
+  @Test
+  public void isReadyTest() {
+    when(mock.isReady()).thenReturn(true);
+    assertEquals(true, forward.isReady());
+  }
+
+  @Test
+  public void setCompressorTest() {
+    Compressor compressor = mock(Compressor.class);
+    forward.setCompressor(compressor);
+    verify(mock).setCompressor(same(compressor));
+  }
+
+  @Test
+  public void setMessageCompressionTest() {
+    forward.setMessageCompression(true);
+    verify(mock).setMessageCompression(true);
+  }
+
+  @Test
+  public void cancelTest() {
+    Status reason = Status.UNKNOWN;
+    forward.cancel(reason);
+    verify(mock).cancel(same(reason));
+  }
+
+  @Test
+  public void setAuthorityTest() {
+    String authority = "authority";
+    forward.setAuthority(authority);
+    verify(mock).setAuthority(authority);
+  }
+
+  @Test
+  public void setFullStreamDecompressionTest() {
+    forward.setFullStreamDecompression(true);
+    verify(mock).setFullStreamDecompression(true);
+  }
+
+  @Test
+  public void setDecompressorRegistryTest() {
+    DecompressorRegistry decompressor =
+        DecompressorRegistry.emptyInstance().with(new Decompressor() {
+          @Override
+          public String getMessageEncoding() {
+            return "some-encoding";
+          }
+
+          @Override
+          public InputStream decompress(InputStream is) throws IOException {
+            return is;
+          }
+        }, true);
+    forward.setDecompressorRegistry(decompressor);
+    verify(mock).setDecompressorRegistry(same(decompressor));
+  }
+
+  @Test
+  public void startTest() {
+    ClientStreamListener listener = mock(ClientStreamListener.class);
+    forward.start(listener);
+    verify(mock).start(same(listener));
+  }
+
+  @Test
+  public void setMaxInboundMessageSizeTest() {
+    int size = 4567;
+    forward.setMaxInboundMessageSize(size);
+    verify(mock).setMaxInboundMessageSize(size);
+  }
+
+  @Test
+  public void setMaxOutboundMessageSizeTest() {
+    int size = 6789;
+    forward.setMaxOutboundMessageSize(size);
+    verify(mock).setMaxOutboundMessageSize(size);
+  }
+
+  @Test
+  public void getAttributesTest() {
+    Attributes attr = Attributes.newBuilder().build();
+    when(mock.getAttributes()).thenReturn(attr);
+    assertSame(attr, forward.getAttributes());
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ForwardingClientStreamTracerTest.java b/core/src/test/java/io/grpc/internal/ForwardingClientStreamTracerTest.java
new file mode 100644
index 00000000000..5eb5b49fa19
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ForwardingClientStreamTracerTest.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2021 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.internal;
+
+import static org.mockito.Mockito.mock;
+
+import io.grpc.ClientStreamTracer;
+import io.grpc.ForwardingTestUtil;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ForwardingClientStreamTracer}. */
+@RunWith(JUnit4.class)
+public class ForwardingClientStreamTracerTest {
+  private final ClientStreamTracer mockDelegate = mock(ClientStreamTracer.class);
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        ClientStreamTracer.class,
+        mockDelegate,
+        new ForwardingClientStreamTracerTest.TestClientStreamTracer(),
+        Collections.<Method>emptyList());
+  }
+
+  private final class TestClientStreamTracer extends ForwardingClientStreamTracer {
+    @Override
+    protected ClientStreamTracer delegate() {
+      return mockDelegate;
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ForwardingManagedChannelTest.java b/core/src/test/java/io/grpc/internal/ForwardingManagedChannelTest.java
new file mode 100644
index 00000000000..b148bd6aeef
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ForwardingManagedChannelTest.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static org.junit.Assert.assertSame;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.grpc.CallOptions;
+import io.grpc.ConnectivityState;
+import io.grpc.ForwardingTestUtil;
+import io.grpc.ManagedChannel;
+import io.grpc.MethodDescriptor;
+import io.grpc.NoopClientCall;
+import io.grpc.testing.TestMethodDescriptors;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class ForwardingManagedChannelTest {
+  private final ManagedChannel mock = mock(ManagedChannel.class);
+  private final ForwardingManagedChannel forward = new ForwardingManagedChannel(mock) {};
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        ManagedChannel.class,
+        mock,
+        forward,
+        Collections.<Method>emptyList());
+  }
+
+  @Test
+  public void shutdown() {
+    ManagedChannel ret = mock(ManagedChannel.class);
+    when(mock.shutdown()).thenReturn(ret);
+    assertSame(ret, forward.shutdown());
+  }
+
+  @Test
+  public void isShutdown() {
+    when(mock.isShutdown()).thenReturn(true);
+    assertSame(true, forward.isShutdown());
+  }
+
+  @Test
+  public void isTerminated() {
+    when(mock.isTerminated()).thenReturn(true);
+    assertSame(true, forward.isTerminated());
+  }
+
+  @Test
+  public void shutdownNow() {
+    ManagedChannel ret = mock(ManagedChannel.class);
+    when(mock.shutdownNow()).thenReturn(ret);
+    assertSame(ret, forward.shutdownNow());
+  }
+
+  @Test
+  public void awaitTermination() throws Exception {
+    long timeout = 1234;
+    TimeUnit unit = TimeUnit.MILLISECONDS;
+    forward.awaitTermination(timeout, unit);
+    verify(mock).awaitTermination(eq(timeout), eq(unit));
+  }
+
+  @Test
+  public void newCall() {
+    NoopClientCall<Void, Void> clientCall = new NoopClientCall<>();
+    CallOptions callOptions = CallOptions.DEFAULT.withoutWaitForReady();
+    MethodDescriptor<Void, Void> method = TestMethodDescriptors.voidMethod();
+    when(mock.newCall(same(method), same(callOptions))).thenReturn(clientCall);
+    assertSame(clientCall, forward.newCall(method, callOptions));
+  }
+
+  @Test
+  public void authority() {
+    String authority = "authority5678";
+    when(mock.authority()).thenReturn(authority);
+    assertSame(authority, forward.authority());
+  }
+
+  @Test
+  public void getState() {
+    when(mock.getState(true)).thenReturn(ConnectivityState.READY);
+    assertSame(ConnectivityState.READY, forward.getState(true));
+  }
+
+  @Test
+  public void notifyWhenStateChanged() {
+    Runnable callback = new Runnable() {
+      @Override
+      public void run() { }
+    };
+    forward.notifyWhenStateChanged(ConnectivityState.READY, callback);
+    verify(mock).notifyWhenStateChanged(same(ConnectivityState.READY), same(callback));
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ForwardingNameResolverTest.java b/core/src/test/java/io/grpc/internal/ForwardingNameResolverTest.java
new file mode 100644
index 00000000000..5da172626bb
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ForwardingNameResolverTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.ForwardingTestUtil;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ResolutionResult;
+import io.grpc.Status;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link ForwardingNameResolver}.
+ */
+@RunWith(JUnit4.class)
+public class ForwardingNameResolverTest {
+  private final NameResolver delegate = mock(NameResolver.class);
+  private final NameResolver forwarder = new ForwardingNameResolver(delegate) {
+  };
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        NameResolver.class,
+        delegate,
+        forwarder,
+        Collections.<Method>emptyList());
+  }
+
+  @Test
+  public void getServiceAuthority() {
+    String auth = "example.com";
+    when(delegate.getServiceAuthority()).thenReturn(auth);
+
+    assertEquals(auth, forwarder.getServiceAuthority());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation") // this will be removed in 1.21.0
+  public void start_listener() {
+    NameResolver.Listener listener = new NameResolver.Listener() {
+      @Override
+      public void onAddresses(List<EquivalentAddressGroup> servers, Attributes attributes) { }
+
+      @Override
+      public void onError(Status error) { }
+    };
+
+    forwarder.start(listener);
+    verify(delegate).start(listener);
+  }
+
+
+  @Test
+  public void start_observer() {
+    NameResolver.Listener2 listener = new NameResolver.Listener2() {
+      @Override
+      public void onResult(ResolutionResult result) {
+      }
+
+      @Override
+      public void onError(Status error) { }
+    };
+
+    forwarder.start(listener);
+    verify(delegate).start(listener);
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ForwardingReadableBufferTest.java b/core/src/test/java/io/grpc/internal/ForwardingReadableBufferTest.java
index 278a89ab251..696fb35e379 100644
--- a/core/src/test/java/io/grpc/internal/ForwardingReadableBufferTest.java
+++ b/core/src/test/java/io/grpc/internal/ForwardingReadableBufferTest.java
@@ -1,63 +1,59 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
 import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import io.grpc.ForwardingTestUtil;
 import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.reflect.Method;
+import java.util.Collections;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
-/**
- * Tests for {@link ForwardingReadableBuffer}.
- */
+/** Tests for {@link ForwardingReadableBuffer}. */
 @RunWith(JUnit4.class)
 public class ForwardingReadableBufferTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
 
   @Mock private ReadableBuffer delegate;
   private ForwardingReadableBuffer buffer;
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
     buffer = new ForwardingReadableBuffer(delegate) {};
   }
 
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        ReadableBuffer.class, delegate, buffer, Collections.<Method>emptyList());
+  }
+
   @Test
   public void readableBytes() {
     when(delegate.readableBytes()).thenReturn(1);
@@ -72,20 +68,6 @@ public void readUnsignedByte() {
     assertEquals(1, buffer.readUnsignedByte());
   }
 
-  @Test
-  public void readUnsignedMedium() {
-    when(delegate.readUnsignedMedium()).thenReturn(1);
-
-    assertEquals(1, buffer.readUnsignedMedium());
-  }
-
-  @Test
-  public void readUnsignedShort() {
-    when(delegate.readUnsignedShort()).thenReturn(1);
-
-    assertEquals(1, buffer.readUnsignedShort());
-  }
-
   @Test
   public void readInt() {
     when(delegate.readInt()).thenReturn(1);
@@ -102,23 +84,18 @@ public void skipBytes() {
 
   @Test
   public void readBytes() {
-    buffer.readBytes(null, 1, 2);
-
-    verify(delegate).readBytes(null, 1, 2);
-  }
-
-  @Test
-  public void readBytes_overload1() {
-    buffer.readBytes(null);
+    byte[] dest = new byte[1];
+    buffer.readBytes(dest, 1, 2);
 
-    verify(delegate).readBytes(null);
+    verify(delegate).readBytes(dest, 1, 2);
   }
 
   @Test
   public void readBytes_overload2() throws IOException {
-    buffer.readBytes(null, 1);
+    OutputStream dest = mock(OutputStream.class);
+    buffer.readBytes(dest, 1);
 
-    verify(delegate).readBytes(null, 1);
+    verify(delegate).readBytes(dest, 1);
   }
 
   @Test
@@ -137,9 +114,10 @@ public void hasArray() {
 
   @Test
   public void array() {
-    when(delegate.array()).thenReturn(null);
+    byte[] array = new byte[1];
+    when(delegate.array()).thenReturn(array);
 
-    assertEquals(null, buffer.array());
+    assertEquals(array, buffer.array());
   }
 
   @Test
diff --git a/core/src/test/java/io/grpc/internal/GrpcUtilTest.java b/core/src/test/java/io/grpc/internal/GrpcUtilTest.java
index 5e78019a9bd..c243790028c 100644
--- a/core/src/test/java/io/grpc/internal/GrpcUtilTest.java
+++ b/core/src/test/java/io/grpc/internal/GrpcUtilTest.java
@@ -1,55 +1,67 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
-
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.Lists;
+import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.Metadata;
 import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
 import io.grpc.internal.GrpcUtil.Http2Error;
+import io.grpc.testing.TestMethodDescriptors;
+import java.util.ArrayList;
 import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /** Unit tests for {@link GrpcUtil}. */
 @RunWith(JUnit4.class)
 public class GrpcUtilTest {
 
-  @Rule public final ExpectedException thrown = ExpectedException.none();
+  private static final ClientStreamTracer[] tracers = new ClientStreamTracer[] {
+      new ClientStreamTracer() {}
+  };
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Captor
+  private ArgumentCaptor<Status> statusCaptor;
+
 
   @Test
   public void http2ErrorForCode() {
@@ -86,8 +98,8 @@ public void timeoutTest() {
     GrpcUtil.TimeoutMarshaller marshaller =
             new GrpcUtil.TimeoutMarshaller();
     // nanos
-    assertEquals("0n", marshaller.toAsciiString(0L));
-    assertEquals(0L, (long) marshaller.parseAsciiString("0n"));
+    assertEquals("1n", marshaller.toAsciiString(1L));
+    assertEquals(1L, (long) marshaller.parseAsciiString("1n"));
 
     assertEquals("99999999n", marshaller.toAsciiString(99999999L));
     assertEquals(99999999L, (long) marshaller.parseAsciiString("99999999n"));
@@ -132,7 +144,7 @@ public void timeoutTest() {
 
   @Test
   public void grpcUserAgent() {
-    assertTrue(GrpcUtil.getGrpcUserAgent("netty", null).startsWith("grpc-java-netty"));
+    assertTrue(GrpcUtil.getGrpcUserAgent("netty", null).startsWith("grpc-java-netty/"));
     assertTrue(GrpcUtil.getGrpcUserAgent("okhttp", "libfoo/1.0")
         .startsWith("libfoo/1.0 grpc-java-okhttp"));
   }
@@ -150,10 +162,44 @@ public void contentTypeShouldNotBeValid() {
   }
 
   @Test
-  public void checkAuthority_failsOnNull() {
-    thrown.expect(NullPointerException.class);
+  public void urlAuthorityEscape_ipv6Address() {
+    assertEquals("[::1]", GrpcUtil.AuthorityEscaper.encodeAuthority("[::1]"));
+  }
+
+  @Test
+  public void urlAuthorityEscape_userInAuthority() {
+    assertEquals("user@host", GrpcUtil.AuthorityEscaper.encodeAuthority("user@host"));
+  }
+
+  @Test
+  public void urlAuthorityEscape_slashesAreEncoded() {
+    assertEquals(
+        "project%2F123%2Fnetwork%2Fabc%2Fservice",
+        GrpcUtil.AuthorityEscaper.encodeAuthority("project/123/network/abc/service"));
+  }
+
+  @Test
+  public void urlAuthorityEscape_allowedCharsAreNotEncoded() {
+    assertEquals(
+        "-._~!$&'()*+,;=@:[]", GrpcUtil.AuthorityEscaper.encodeAuthority("-._~!$&'()*+,;=@:[]"));
+  }
+
+  @Test
+  public void urlAuthorityEscape_allLettersAndNumbers() {
+    assertEquals(
+        "abcdefghijklmnopqrstuvwxyz0123456789",
+        GrpcUtil.AuthorityEscaper.encodeAuthority("abcdefghijklmnopqrstuvwxyz0123456789"));
+  }
 
-    GrpcUtil.checkAuthority(null);
+  @Test
+  public void urlAuthorityEscape_unicodeAreNotEncoded() {
+    assertEquals(
+        "ö®", GrpcUtil.AuthorityEscaper.encodeAuthority("ö®"));
+  }
+
+  @Test
+  public void checkAuthority_failsOnNull() {
+    assertThrows(NullPointerException.class, () -> GrpcUtil.checkAuthority(null));
   }
 
   @Test
@@ -179,26 +225,18 @@ public void checkAuthority_succeedsOnIpV6() {
 
   @Test
   public void checkAuthority_failsOnInvalidAuthority() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid authority");
-
-    GrpcUtil.checkAuthority("[ : : 1]");
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> GrpcUtil.checkAuthority("[ : : 1]"));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid authority: [ : : 1]");
   }
 
-  @Test
-  public void checkAuthority_failsOnInvalidHost() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("No host in authority");
-
-    GrpcUtil.checkAuthority("bad_host");
-  }
 
   @Test
   public void checkAuthority_userInfoNotAllowed() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Userinfo");
-
-    GrpcUtil.checkAuthority("foo@valid");
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> GrpcUtil.checkAuthority("foo@valid"));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Userinfo must not be present on authority: 'foo@valid'");
   }
 
   @Test
@@ -230,4 +268,127 @@ public void httpStatusToGrpcStatus_neverOk() {
       assertFalse(GrpcUtil.httpStatusToGrpcStatus(i).isOk());
     }
   }
+
+  @Test
+  public void getTransportFromPickResult_errorPickResult_waitForReady() {
+    Status status = Status.UNAVAILABLE;
+    PickResult pickResult = PickResult.withError(status);
+    ClientTransport transport = GrpcUtil.getTransportFromPickResult(pickResult, true);
+
+    assertNull(transport);
+  }
+
+  @Test
+  public void getTransportFromPickResult_errorPickResult_failFast() {
+    Status status = Status.UNAVAILABLE;
+    PickResult pickResult = PickResult.withError(status);
+    ClientTransport transport = GrpcUtil.getTransportFromPickResult(pickResult, false);
+
+    assertNotNull(transport);
+
+    ClientStream stream = transport.newStream(
+        TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT,
+        tracers);
+    ClientStreamListener listener = mock(ClientStreamListener.class);
+    stream.start(listener);
+
+    verify(listener).closed(eq(status), eq(RpcProgress.PROCESSED), any(Metadata.class));
+  }
+
+  /* Status codes that a control plane should not be returned get replaced by INTERNAL. */
+  @Test
+  public void getTransportFromPickResult_errorPickResult_noInappropriateControlPlaneStatus() {
+
+    // These are NOT appropriate for a control plane to return.
+    ArrayList<Status> inappropriateStatus = Lists.newArrayList(
+        Status.INVALID_ARGUMENT.withDescription("bad one").withCause(new RuntimeException()),
+        Status.NOT_FOUND.withDescription("not here").withCause(new RuntimeException()),
+        Status.ALREADY_EXISTS.withDescription("not again").withCause(new RuntimeException()),
+        Status.FAILED_PRECONDITION.withDescription("naah").withCause(new RuntimeException()),
+        Status.ABORTED.withDescription("nope").withCause(new RuntimeException()),
+        Status.OUT_OF_RANGE.withDescription("outta range").withCause(new RuntimeException()),
+        Status.DATA_LOSS.withDescription("lost").withCause(new RuntimeException()));
+
+    for (Status status : inappropriateStatus) {
+      PickResult pickResult = PickResult.withError(status);
+      ClientTransport transport = GrpcUtil.getTransportFromPickResult(pickResult, false);
+
+      ClientStream stream = transport.newStream(
+          TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT,
+          tracers);
+      ClientStreamListener listener = mock(ClientStreamListener.class);
+      stream.start(listener);
+
+      verify(listener).closed(statusCaptor.capture(), eq(RpcProgress.PROCESSED),
+          any(Metadata.class));
+      Status usedStatus = statusCaptor.getValue();
+      assertThat(usedStatus.getCode()).isEqualTo(Code.INTERNAL);
+      assertThat(usedStatus.getDescription()).contains("Inappropriate status");
+      assertThat(usedStatus.getCause()).isInstanceOf(RuntimeException.class);
+    }
+  }
+
+  /* Status codes a control plane can return are not replaced. */
+  @Test
+  public void getTransportFromPickResult_errorPickResult_appropriateControlPlaneStatus() {
+
+    // These ARE appropriate for a control plane to return.
+    ArrayList<Status> inappropriateStatus = Lists.newArrayList(
+        Status.CANCELLED,
+        Status.UNKNOWN,
+        Status.DEADLINE_EXCEEDED,
+        Status.PERMISSION_DENIED,
+        Status.RESOURCE_EXHAUSTED,
+        Status.UNIMPLEMENTED,
+        Status.INTERNAL,
+        Status.UNAVAILABLE,
+        Status.UNAUTHENTICATED);
+
+    for (Status status : inappropriateStatus) {
+      PickResult pickResult = PickResult.withError(status);
+      ClientTransport transport = GrpcUtil.getTransportFromPickResult(pickResult, false);
+
+      ClientStream stream = transport.newStream(
+          TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT,
+          tracers);
+      ClientStreamListener listener = mock(ClientStreamListener.class);
+      stream.start(listener);
+
+      verify(listener).closed(eq(status), eq(RpcProgress.PROCESSED), any(Metadata.class));
+    }
+  }
+
+  @Test
+  public void getTransportFromPickResult_dropPickResult_waitForReady() {
+    Status status = Status.UNAVAILABLE;
+    PickResult pickResult = PickResult.withDrop(status);
+    ClientTransport transport = GrpcUtil.getTransportFromPickResult(pickResult, true);
+
+    assertNotNull(transport);
+
+    ClientStream stream = transport.newStream(
+        TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT,
+        tracers);
+    ClientStreamListener listener = mock(ClientStreamListener.class);
+    stream.start(listener);
+
+    verify(listener).closed(eq(status), eq(RpcProgress.DROPPED), any(Metadata.class));
+  }
+
+  @Test
+  public void getTransportFromPickResult_dropPickResult_failFast() {
+    Status status = Status.UNAVAILABLE;
+    PickResult pickResult = PickResult.withDrop(status);
+    ClientTransport transport = GrpcUtil.getTransportFromPickResult(pickResult, false);
+
+    assertNotNull(transport);
+
+    ClientStream stream = transport.newStream(
+        TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT,
+        tracers);
+    ClientStreamListener listener = mock(ClientStreamListener.class);
+    stream.start(listener);
+
+    verify(listener).closed(eq(status), eq(RpcProgress.DROPPED), any(Metadata.class));
+  }
 }
diff --git a/core/src/test/java/io/grpc/internal/GzipInflatingBufferTest.java b/core/src/test/java/io/grpc/internal/GzipInflatingBufferTest.java
new file mode 100644
index 00000000000..06d431dc902
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/GzipInflatingBufferTest.java
@@ -0,0 +1,762 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.io.ByteStreams;
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+import java.util.zip.CRC32;
+import java.util.zip.DataFormatException;
+import java.util.zip.GZIPOutputStream;
+import java.util.zip.ZipException;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link GzipInflatingBuffer}. */
+@RunWith(JUnit4.class)
+public class GzipInflatingBufferTest {
+  private static final String UNCOMPRESSABLE_FILE = "/io/grpc/internal/uncompressable.bin";
+
+  private static final int GZIP_HEADER_MIN_SIZE = 10;
+  private static final int GZIP_TRAILER_SIZE = 8;
+  private static final int GZIP_HEADER_FLAG_INDEX = 3;
+
+  public static final int GZIP_MAGIC = 0x8b1f;
+
+  private static final int FTEXT = 1;
+  private static final int FHCRC = 2;
+  private static final int FEXTRA = 4;
+  private static final int FNAME = 8;
+  private static final int FCOMMENT = 16;
+
+  private static final int TRUNCATED_DATA_SIZE = 10;
+
+  private byte[] originalData;
+  private byte[] gzippedData;
+  private byte[] gzipHeader;
+  private byte[] deflatedBytes;
+  private byte[] gzipTrailer;
+  private byte[] truncatedData;
+  private byte[] gzippedTruncatedData;
+
+  private GzipInflatingBuffer gzipInflatingBuffer;
+
+  @Before
+  public void setUp() {
+    gzipInflatingBuffer = new GzipInflatingBuffer();
+    try {
+      originalData = ByteStreams.toByteArray(getClass().getResourceAsStream(UNCOMPRESSABLE_FILE));
+      truncatedData = Arrays.copyOf(originalData, TRUNCATED_DATA_SIZE);
+
+      ByteArrayOutputStream gzippedOutputStream = new ByteArrayOutputStream();
+      OutputStream gzippingOutputStream = new GZIPOutputStream(gzippedOutputStream);
+      gzippingOutputStream.write(originalData);
+      gzippingOutputStream.close();
+      gzippedData = gzippedOutputStream.toByteArray();
+      gzippedOutputStream.close();
+
+      gzipHeader = Arrays.copyOf(gzippedData, GZIP_HEADER_MIN_SIZE);
+      deflatedBytes =
+          Arrays.copyOfRange(
+              gzippedData, GZIP_HEADER_MIN_SIZE, gzippedData.length - GZIP_TRAILER_SIZE);
+      gzipTrailer =
+          Arrays.copyOfRange(
+              gzippedData, gzippedData.length - GZIP_TRAILER_SIZE, gzippedData.length);
+
+      ByteArrayOutputStream truncatedGzippedOutputStream = new ByteArrayOutputStream();
+      OutputStream smallerGzipCompressingStream =
+          new GZIPOutputStream(truncatedGzippedOutputStream);
+      smallerGzipCompressingStream.write(truncatedData);
+      smallerGzipCompressingStream.close();
+      gzippedTruncatedData = truncatedGzippedOutputStream.toByteArray();
+      truncatedGzippedOutputStream.close();
+    } catch (Exception e) {
+      throw new RuntimeException("Failed to set up compressed data", e);
+    }
+  }
+
+  @After
+  public void tearDown() {
+    gzipInflatingBuffer.close();
+  }
+
+  @Test
+  public void gzipInflateWorks() throws Exception {
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedData));
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertEquals(gzippedData.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+  }
+
+  @Test
+  public void splitGzipStreamWorks() throws Exception {
+    int initialBytes = 100;
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedData, 0, initialBytes));
+
+    byte[] b = new byte[originalData.length];
+    int n = gzipInflatingBuffer.inflateBytes(b, 0, originalData.length);
+    assertTrue("inflated bytes expected", n > 0);
+    assertTrue("gzipInflatingBuffer is not stalled", gzipInflatingBuffer.isStalled());
+    assertEquals(initialBytes, gzipInflatingBuffer.getAndResetBytesConsumed());
+
+    gzipInflatingBuffer.addGzippedBytes(
+        ReadableBuffers.wrap(gzippedData, initialBytes, gzippedData.length - initialBytes));
+    int bytesRemaining = originalData.length - n;
+    assertEquals(bytesRemaining, gzipInflatingBuffer.inflateBytes(b, n, bytesRemaining));
+    assertEquals(gzippedData.length - initialBytes, gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+  }
+
+  @Test
+  public void inflateBytesObeysOffsetAndLength() throws Exception {
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedData));
+
+    int offset = 10;
+    int length = 100;
+    byte[] b = new byte[offset + length + offset];
+    assertEquals(length, gzipInflatingBuffer.inflateBytes(b, offset, length));
+    assertTrue(
+        "bytes written before offset",
+        Arrays.equals(new byte[offset], Arrays.copyOfRange(b, 0, offset)));
+    assertTrue(
+        "inflated data does not match",
+        Arrays.equals(
+            Arrays.copyOfRange(originalData, 0, length),
+            Arrays.copyOfRange(b, offset, offset + length)));
+    assertTrue(
+        "bytes written beyond length",
+        Arrays.equals(
+            new byte[offset], Arrays.copyOfRange(b, offset + length, offset + length + offset)));
+  }
+
+  @Test
+  public void concatenatedStreamsWorks() throws Exception {
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedData));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedTruncatedData));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedData));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedTruncatedData));
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertEquals(gzippedData.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+
+    assertEquals(
+        truncatedData.length, gzipInflatingBuffer.inflateBytes(b, 0, truncatedData.length));
+    assertEquals(gzippedTruncatedData.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertEquals(gzippedData.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+
+    assertEquals(
+        truncatedData.length, gzipInflatingBuffer.inflateBytes(b, 0, truncatedData.length));
+    assertEquals(gzippedTruncatedData.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+  }
+
+  @Test
+  public void requestingTooManyBytesStillReturnsEndOfBlock() throws Exception {
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedData));
+
+    int len = 2 * originalData.length;
+    byte[] b = new byte[len];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, len));
+    assertEquals(gzippedData.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue(gzipInflatingBuffer.isStalled());
+    assertTrue(
+        "inflated data does not match",
+        Arrays.equals(originalData, Arrays.copyOf(b, originalData.length)));
+  }
+
+  @Test
+  public void closeStopsDecompression() throws Exception {
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedData));
+
+    byte[] b = new byte[1];
+    gzipInflatingBuffer.inflateBytes(b, 0, 1);
+    gzipInflatingBuffer.close();
+    try {
+      gzipInflatingBuffer.inflateBytes(b, 0, 1);
+      fail("Expected IllegalStateException");
+    } catch (IllegalStateException expectedException) {
+      assertEquals("GzipInflatingBuffer is closed", expectedException.getMessage());
+    }
+  }
+
+  @Test
+  public void isStalledReturnsTrueAtEndOfStream() throws Exception {
+    int bytesToWithhold = 10;
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedData));
+
+    byte[] b = new byte[originalData.length];
+    gzipInflatingBuffer.inflateBytes(b, 0, originalData.length - bytesToWithhold);
+    assertFalse("gzipInflatingBuffer is stalled", gzipInflatingBuffer.isStalled());
+
+    gzipInflatingBuffer.inflateBytes(b, originalData.length - bytesToWithhold, bytesToWithhold);
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+    assertTrue("gzipInflatingBuffer is not stalled", gzipInflatingBuffer.isStalled());
+  }
+
+  @Test
+  public void isStalledReturnsFalseBetweenStreams() throws Exception {
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedData));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedData));
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+    assertFalse("gzipInflatingBuffer is stalled", gzipInflatingBuffer.isStalled());
+
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+    assertTrue("gzipInflatingBuffer is not stalled", gzipInflatingBuffer.isStalled());
+  }
+
+  @Test
+  public void isStalledReturnsFalseBetweenSmallStreams() throws Exception {
+    // Use small streams to make sure that they all fit in the inflater buffer
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedTruncatedData));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedTruncatedData));
+
+    byte[] b = new byte[truncatedData.length];
+    assertEquals(
+        truncatedData.length, gzipInflatingBuffer.inflateBytes(b, 0, truncatedData.length));
+    assertTrue("inflated data does not match", Arrays.equals(truncatedData, b));
+    assertFalse("gzipInflatingBuffer is stalled", gzipInflatingBuffer.isStalled());
+
+    assertEquals(
+        truncatedData.length, gzipInflatingBuffer.inflateBytes(b, 0, truncatedData.length));
+    assertTrue("inflated data does not match", Arrays.equals(truncatedData, b));
+    assertTrue("gzipInflatingBuffer is not stalled", gzipInflatingBuffer.isStalled());
+  }
+
+  @Test
+  public void isStalledReturnsTrueWithPartialNextHeaderAvailable() throws Exception {
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedTruncatedData));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(new byte[1]));
+
+    byte[] b = new byte[truncatedData.length];
+    assertEquals(
+        truncatedData.length, gzipInflatingBuffer.inflateBytes(b, 0, truncatedData.length));
+    assertTrue("inflated data does not match", Arrays.equals(truncatedData, b));
+    assertTrue("gzipInflatingBuffer is not stalled", gzipInflatingBuffer.isStalled());
+    assertTrue("partial data expected", gzipInflatingBuffer.hasPartialData());
+  }
+
+  @Test
+  public void isStalledWorksWithAllHeaderFlags() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] =
+        (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FTEXT | FHCRC | FEXTRA | FNAME | FCOMMENT);
+    int len = 1025;
+    byte[] fExtraLen = {(byte) len, (byte) (len >> 8)};
+    byte[] fExtra = new byte[len];
+    byte[] zeroTerminatedBytes = new byte[len];
+    for (int i = 0; i < len - 1; i++) {
+      zeroTerminatedBytes[i] = 1;
+    }
+    ByteArrayOutputStream newHeader = new ByteArrayOutputStream();
+    newHeader.write(gzipHeader);
+    newHeader.write(fExtraLen);
+    newHeader.write(fExtra);
+    newHeader.write(zeroTerminatedBytes); // FNAME
+    newHeader.write(zeroTerminatedBytes); // FCOMMENT
+    byte[] headerCrc16 = getHeaderCrc16Bytes(newHeader.toByteArray());
+
+    assertTrue("gzipInflatingBuffer is not stalled", gzipInflatingBuffer.isStalled());
+
+    addInTwoChunksAndVerifyIsStalled(gzipHeader);
+    addInTwoChunksAndVerifyIsStalled(fExtraLen);
+    addInTwoChunksAndVerifyIsStalled(fExtra);
+    addInTwoChunksAndVerifyIsStalled(zeroTerminatedBytes);
+    addInTwoChunksAndVerifyIsStalled(zeroTerminatedBytes);
+    addInTwoChunksAndVerifyIsStalled(headerCrc16);
+
+    byte[] b = new byte[originalData.length];
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+
+    addInTwoChunksAndVerifyIsStalled(gzipTrailer);
+  }
+
+  @Test
+  public void hasPartialData() throws Exception {
+    assertFalse("no partial data expected", gzipInflatingBuffer.hasPartialData());
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedData));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(new byte[1]));
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+    assertTrue("partial data expected", gzipInflatingBuffer.hasPartialData());
+  }
+
+  @Test
+  public void hasPartialDataWithoutGzipTrailer() throws Exception {
+    assertFalse("no partial data expected", gzipInflatingBuffer.hasPartialData());
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+    assertTrue("partial data expected", gzipInflatingBuffer.hasPartialData());
+  }
+
+  @Test
+  public void inflatingCompleteGzipStreamConsumesTrailer() throws Exception {
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedData));
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+    assertFalse("no partial data expected", gzipInflatingBuffer.hasPartialData());
+  }
+
+  @Test
+  public void bytesConsumedForPartiallyInflatedBlock() throws Exception {
+    int bytesToWithhold = 1;
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedTruncatedData));
+
+    byte[] b = new byte[truncatedData.length];
+    assertEquals(
+        truncatedData.length - bytesToWithhold,
+        gzipInflatingBuffer.inflateBytes(b, 0, truncatedData.length - bytesToWithhold));
+    assertEquals(
+        gzippedTruncatedData.length - bytesToWithhold - GZIP_TRAILER_SIZE,
+        gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertEquals(
+        bytesToWithhold,
+        gzipInflatingBuffer.inflateBytes(
+            b, truncatedData.length - bytesToWithhold, bytesToWithhold));
+    assertEquals(
+        bytesToWithhold + GZIP_TRAILER_SIZE, gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue("inflated data does not match", Arrays.equals(truncatedData, b));
+  }
+
+  @Test
+  public void getAndResetCompressedBytesConsumedReportsHeaderFlagBytes() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] =
+        (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FTEXT | FHCRC | FEXTRA | FNAME | FCOMMENT);
+    int len = 1025;
+    byte[] fExtraLen = {(byte) len, (byte) (len >> 8)};
+    byte[] fExtra = new byte[len];
+    byte[] zeroTerminatedBytes = new byte[len];
+    for (int i = 0; i < len - 1; i++) {
+      zeroTerminatedBytes[i] = 1;
+    }
+    ByteArrayOutputStream newHeader = new ByteArrayOutputStream();
+    newHeader.write(gzipHeader);
+    newHeader.write(fExtraLen);
+    newHeader.write(fExtra);
+    newHeader.write(zeroTerminatedBytes); // FNAME
+    newHeader.write(zeroTerminatedBytes); // FCOMMENT
+    byte[] headerCrc16 = getHeaderCrc16Bytes(newHeader.toByteArray());
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(0, gzipInflatingBuffer.inflateBytes(b, 0, 1));
+    assertEquals(0, gzipInflatingBuffer.getAndResetBytesConsumed());
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    assertEquals(0, gzipInflatingBuffer.inflateBytes(b, 0, 1));
+    assertEquals(gzipHeader.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(fExtraLen));
+    assertEquals(0, gzipInflatingBuffer.inflateBytes(b, 0, 1));
+    assertEquals(fExtraLen.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(fExtra));
+    assertEquals(0, gzipInflatingBuffer.inflateBytes(b, 0, 1));
+    assertEquals(fExtra.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(zeroTerminatedBytes));
+    assertEquals(0, gzipInflatingBuffer.inflateBytes(b, 0, 1));
+    assertEquals(zeroTerminatedBytes.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(zeroTerminatedBytes));
+    assertEquals(0, gzipInflatingBuffer.inflateBytes(b, 0, 1));
+    assertEquals(zeroTerminatedBytes.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(headerCrc16));
+    assertEquals(0, gzipInflatingBuffer.inflateBytes(b, 0, 1));
+    assertEquals(headerCrc16.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertEquals(deflatedBytes.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+    assertEquals(0, gzipInflatingBuffer.inflateBytes(b, 0, 1));
+    assertEquals(gzipTrailer.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+  }
+
+  @Test
+  public void getAndResetDeflatedBytesConsumedExcludesGzipMetadata() throws Exception {
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzippedData));
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertEquals(
+        gzippedData.length - GZIP_HEADER_MIN_SIZE - GZIP_TRAILER_SIZE,
+        gzipInflatingBuffer.getAndResetDeflatedBytesConsumed());
+  }
+
+  @Test
+  public void wrongHeaderMagicShouldFail() throws Exception {
+    gzipHeader[1] = (byte) ~(GZIP_MAGIC >> 8);
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    try {
+      byte[] b = new byte[1];
+      gzipInflatingBuffer.inflateBytes(b, 0, 1);
+      fail("Expected ZipException");
+    } catch (ZipException expectedException) {
+      assertEquals("Not in GZIP format", expectedException.getMessage());
+    }
+  }
+
+  @Test
+  public void wrongHeaderCompressionMethodShouldFail() throws Exception {
+    gzipHeader[2] = 7; // Should be 8
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    try {
+      byte[] b = new byte[1];
+      gzipInflatingBuffer.inflateBytes(b, 0, 1);
+      fail("Expected ZipException");
+    } catch (ZipException expectedException) {
+      assertEquals("Unsupported compression method", expectedException.getMessage());
+    }
+  }
+
+  @Test
+  public void allHeaderFlagsWork() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] =
+        (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FTEXT | FHCRC | FEXTRA | FNAME | FCOMMENT);
+    int len = 1025;
+    byte[] fExtraLen = {(byte) len, (byte) (len >> 8)};
+    byte[] fExtra = new byte[len];
+    byte[] zeroTerminatedBytes = new byte[len];
+    for (int i = 0; i < len - 1; i++) {
+      zeroTerminatedBytes[i] = 1;
+    }
+    ByteArrayOutputStream newHeader = new ByteArrayOutputStream();
+    newHeader.write(gzipHeader);
+    newHeader.write(fExtraLen);
+    newHeader.write(fExtra);
+    newHeader.write(zeroTerminatedBytes); // FNAME
+    newHeader.write(zeroTerminatedBytes); // FCOMMENT
+    byte[] headerCrc16 = getHeaderCrc16Bytes(newHeader.toByteArray());
+    newHeader.write(headerCrc16);
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(newHeader.toByteArray()));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+
+    byte[] b = new byte[originalData.length];
+    gzipInflatingBuffer.inflateBytes(b, 0, originalData.length);
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+  }
+
+  @Test
+  public void headerFTextFlagIsIgnored() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] = (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FTEXT);
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertEquals(gzippedData.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+  }
+
+  @Test
+  public void headerFhcrcFlagWorks() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] = (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FHCRC);
+
+    byte[] headerCrc16 = getHeaderCrc16Bytes(gzipHeader);
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(headerCrc16));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertEquals(
+        gzippedData.length + headerCrc16.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+  }
+
+  @Test
+  public void headerInvalidFhcrcFlagFails() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] = (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FHCRC);
+
+    byte[] headerCrc16 = getHeaderCrc16Bytes(gzipHeader);
+    headerCrc16[0] = (byte) ~headerCrc16[0];
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(headerCrc16));
+    try {
+      byte[] b = new byte[1];
+      gzipInflatingBuffer.inflateBytes(b, 0, 1);
+      fail("Expected ZipException");
+    } catch (ZipException expectedException) {
+      assertEquals("Corrupt GZIP header", expectedException.getMessage());
+    }
+  }
+
+  @Test
+  public void headerFExtraFlagWorks() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] = (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FEXTRA);
+
+    int len = 1025;
+    byte[] fExtraLen = {(byte) len, (byte) (len >> 8)};
+    byte[] fExtra = new byte[len];
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(fExtraLen));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(fExtra));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertEquals(
+        gzippedData.length + fExtraLen.length + fExtra.length,
+        gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+  }
+
+  @Test
+  public void headerFExtraFlagWithZeroLenWorks() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] = (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FEXTRA);
+    byte[] fExtraLen = new byte[2];
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(fExtraLen));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertEquals(
+        gzippedData.length + fExtraLen.length, gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+  }
+
+  @Test
+  public void headerFExtraFlagWithMissingExtraLenFails() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] = (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FEXTRA);
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+
+    try {
+      byte[] b = new byte[originalData.length];
+      gzipInflatingBuffer.inflateBytes(b, 0, originalData.length);
+      fail("Expected DataFormatException");
+    } catch (DataFormatException expectedException) {
+      assertTrue(
+          "wrong exception message",
+          expectedException.getMessage().startsWith("Inflater data format exception:"));
+    }
+  }
+
+  @Test
+  public void headerFExtraFlagWithMissingExtraBytesFails() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] = (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FEXTRA);
+
+    int len = 5;
+    byte[] fExtraLen = {(byte) len, (byte) (len >> 8)};
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(fExtraLen));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+
+    try {
+      byte[] b = new byte[originalData.length];
+      gzipInflatingBuffer.inflateBytes(b, 0, originalData.length);
+      fail("Expected DataFormatException");
+    } catch (DataFormatException expectedException) {
+      assertTrue(
+          "wrong exception message",
+          expectedException.getMessage().startsWith("Inflater data format exception:"));
+    }
+  }
+
+  @Test
+  public void headerFNameFlagWorks() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] = (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FNAME);
+    int len = 1025;
+    byte[] zeroTerminatedBytes = new byte[len];
+    for (int i = 0; i < len - 1; i++) {
+      zeroTerminatedBytes[i] = 1;
+    }
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(zeroTerminatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertEquals(gzippedData.length + len, gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+  }
+
+  @Test
+  public void headerFNameFlagWithMissingBytesFail() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] = (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FNAME);
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+
+    try {
+      byte[] b = new byte[originalData.length];
+      gzipInflatingBuffer.inflateBytes(b, 0, originalData.length);
+      fail("Expected DataFormatException");
+    } catch (DataFormatException expectedException) {
+      assertTrue(
+          "wrong exception message",
+          expectedException.getMessage().startsWith("Inflater data format exception:"));
+    }
+  }
+
+  @Test
+  public void headerFCommentFlagWorks() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] = (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FCOMMENT);
+    int len = 1025;
+    byte[] zeroTerminatedBytes = new byte[len];
+    for (int i = 0; i < len - 1; i++) {
+      zeroTerminatedBytes[i] = 1;
+    }
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(zeroTerminatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+
+    byte[] b = new byte[originalData.length];
+    assertEquals(originalData.length, gzipInflatingBuffer.inflateBytes(b, 0, originalData.length));
+    assertEquals(gzippedData.length + len, gzipInflatingBuffer.getAndResetBytesConsumed());
+    assertTrue("inflated data does not match", Arrays.equals(originalData, b));
+  }
+
+  @Test
+  public void headerFCommentFlagWithMissingBytesFail() throws Exception {
+    gzipHeader[GZIP_HEADER_FLAG_INDEX] = (byte) (gzipHeader[GZIP_HEADER_FLAG_INDEX] | FCOMMENT);
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+    try {
+      byte[] b = new byte[originalData.length];
+      gzipInflatingBuffer.inflateBytes(b, 0, originalData.length);
+      fail("Expected DataFormatException");
+    } catch (DataFormatException expectedException) {
+      assertTrue(
+          "wrong exception message",
+          expectedException.getMessage().startsWith("Inflater data format exception:"));
+    }
+  }
+
+  @Test
+  public void wrongTrailerCrcShouldFail() throws Exception {
+    gzipTrailer[0] = (byte) ~gzipTrailer[0];
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+
+    try {
+      byte[] b = new byte[originalData.length];
+      gzipInflatingBuffer.inflateBytes(b, 0, originalData.length);
+      fail("Expected ZipException");
+    } catch (ZipException expectedException) {
+      assertEquals("Corrupt GZIP trailer", expectedException.getMessage());
+    }
+  }
+
+  @Test
+  public void wrongTrailerISizeShouldFail() throws Exception {
+    gzipTrailer[GZIP_TRAILER_SIZE - 1] = (byte) ~gzipTrailer[GZIP_TRAILER_SIZE - 1];
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(deflatedBytes));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipTrailer));
+
+    try {
+      byte[] b = new byte[originalData.length];
+      gzipInflatingBuffer.inflateBytes(b, 0, originalData.length);
+      fail("Expected ZipException");
+    } catch (ZipException expectedException) {
+      assertEquals("Corrupt GZIP trailer", expectedException.getMessage());
+    }
+  }
+
+  @Test
+  public void invalidDeflateBlockShouldFail() throws Exception {
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(gzipHeader));
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(new byte[10]));
+
+    try {
+      byte[] b = new byte[originalData.length];
+      gzipInflatingBuffer.inflateBytes(b, 0, originalData.length);
+      fail("Expected DataFormatException");
+    } catch (DataFormatException expectedException) {
+      assertTrue(
+          "wrong exception message",
+          expectedException.getMessage().startsWith("Inflater data format exception:"));
+    }
+  }
+
+  private void addInTwoChunksAndVerifyIsStalled(byte[] input) throws Exception {
+    byte[] b = new byte[1];
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(input, 0, input.length - 1));
+    assertFalse("gzipInflatingBuffer is stalled", gzipInflatingBuffer.isStalled());
+
+    assertEquals(0, gzipInflatingBuffer.inflateBytes(b, 0, 1));
+    assertTrue("gzipInflatingBuffer is not stalled", gzipInflatingBuffer.isStalled());
+
+    gzipInflatingBuffer.addGzippedBytes(ReadableBuffers.wrap(input, input.length - 1, 1));
+    assertFalse("gzipInflatingBuffer is stalled", gzipInflatingBuffer.isStalled());
+
+    assertEquals(0, gzipInflatingBuffer.inflateBytes(b, 0, 1));
+    assertTrue("gzipInflatingBuffer is not stalled", gzipInflatingBuffer.isStalled());
+  }
+
+  private byte[] getHeaderCrc16Bytes(byte[] headerBytes) {
+    CRC32 crc = new CRC32();
+    crc.update(headerBytes);
+    byte[] headerCrc16 = {(byte) crc.getValue(), (byte) (crc.getValue() >> 8)};
+    return headerCrc16;
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/HedgingPolicyTest.java b/core/src/test/java/io/grpc/internal/HedgingPolicyTest.java
new file mode 100644
index 00000000000..cdcfbded2e1
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/HedgingPolicyTest.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.ImmutableSet;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status.Code;
+import io.grpc.testing.TestMethodDescriptors;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for HedgingPolicy. */
+@RunWith(JUnit4.class)
+public class HedgingPolicyTest {
+  @Test
+  public void getHedgingPolicies() throws Exception {
+    BufferedReader reader = null;
+    try {
+      reader = new BufferedReader(new InputStreamReader(RetryPolicyTest.class.getResourceAsStream(
+          "/io/grpc/internal/test_hedging_service_config.json"), "UTF-8"));
+      StringBuilder sb = new StringBuilder();
+      String line;
+      while ((line = reader.readLine()) != null) {
+        sb.append(line).append('\n');
+      }
+      Object serviceConfigObj = JsonParser.parse(sb.toString());
+      assertTrue(serviceConfigObj instanceof Map);
+
+      @SuppressWarnings("unchecked")
+      Map<String, ?> serviceConfig = (Map<String, ?>) serviceConfigObj;
+      ManagedChannelServiceConfig channelServiceConfig =
+          ManagedChannelServiceConfig.fromServiceConfig(
+              serviceConfig,
+              /* retryEnabled= */ true,
+              /* maxRetryAttemptsLimit= */ 3,
+              /* maxHedgedAttemptsLimit= */ 4,
+              /* loadBalancingConfig= */ null);
+
+      MethodDescriptor.Builder<Void, Void> builder = TestMethodDescriptors.voidMethod().toBuilder();
+
+      MethodDescriptor<Void, Void> method = builder.setFullMethodName("not/exist").build();
+      assertThat(channelServiceConfig.getMethodConfig(method)).isNull();
+
+      method = builder.setFullMethodName("not_exist/Foo1").build();
+      assertThat(channelServiceConfig.getMethodConfig(method)).isNull();
+
+      method = builder.setFullMethodName("SimpleService1/not_exist").build();
+      assertThat(channelServiceConfig.getMethodConfig(method).hedgingPolicy).isEqualTo(
+          new HedgingPolicy(
+              3,
+              TimeUnit.MILLISECONDS.toNanos(2100),
+              ImmutableSet.of(Code.UNAVAILABLE, Code.RESOURCE_EXHAUSTED)));
+
+      method = builder.setFullMethodName("SimpleService1/Foo1").build();
+      assertThat(channelServiceConfig.getMethodConfig(method).hedgingPolicy).isEqualTo(
+          new HedgingPolicy(
+              4,
+              TimeUnit.MILLISECONDS.toNanos(100),
+              ImmutableSet.of(Code.UNAVAILABLE)));
+
+      method = builder.setFullMethodName("SimpleService2/not_exist").build();
+      assertThat(channelServiceConfig.getMethodConfig(method).hedgingPolicy).isNull();
+
+      method = builder.setFullMethodName("SimpleService2/Foo2").build();
+      assertThat(channelServiceConfig.getMethodConfig(method).hedgingPolicy).isEqualTo(
+          new HedgingPolicy(
+              4,
+              TimeUnit.MILLISECONDS.toNanos(100),
+              ImmutableSet.of(Code.UNAVAILABLE)));
+    } finally {
+      if (reader != null) {
+        reader.close();
+      }
+    }
+  }
+
+  @Test
+  public void getRetryPolicies_hedgingDisabled() throws Exception {
+    BufferedReader reader = null;
+    try {
+      reader = new BufferedReader(new InputStreamReader(RetryPolicyTest.class.getResourceAsStream(
+          "/io/grpc/internal/test_hedging_service_config.json"), "UTF-8"));
+      StringBuilder sb = new StringBuilder();
+      String line;
+      while ((line = reader.readLine()) != null) {
+        sb.append(line).append('\n');
+      }
+      Object serviceConfigObj = JsonParser.parse(sb.toString());
+      assertTrue(serviceConfigObj instanceof Map);
+
+      @SuppressWarnings("unchecked")
+      Map<String, ?> serviceConfig = (Map<String, ?>) serviceConfigObj;
+      ManagedChannelServiceConfig channelServiceConfig =
+          ManagedChannelServiceConfig.fromServiceConfig(
+              serviceConfig,
+              /* retryEnabled= */ false,
+              /* maxRetryAttemptsLimit= */ 3,
+              /* maxHedgedAttemptsLimit= */ 4,
+              /* loadBalancingConfig= */ null);
+      MethodDescriptor.Builder<Void, Void> builder = TestMethodDescriptors.voidMethod().toBuilder();
+
+      MethodDescriptor<Void, Void> method =
+          builder.setFullMethodName("SimpleService1/Foo1").build();
+      assertThat(channelServiceConfig.getMethodConfig(method).hedgingPolicy).isNull();
+    } finally {
+      if (reader != null) {
+        reader.close();
+      }
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/Http2ClientStreamTransportStateTest.java b/core/src/test/java/io/grpc/internal/Http2ClientStreamTransportStateTest.java
index ce09427b2de..9d32bf1af7d 100644
--- a/core/src/test/java/io/grpc/internal/Http2ClientStreamTransportStateTest.java
+++ b/core/src/test/java/io/grpc/internal/Http2ClientStreamTransportStateTest.java
@@ -1,99 +1,111 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
-import static com.google.common.base.Charsets.US_ASCII;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
 import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
+import static java.nio.charset.StandardCharsets.US_ASCII;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 
+import io.grpc.CallOptions;
+import io.grpc.InternalMetadata;
 import io.grpc.Metadata;
 import io.grpc.Status;
 import io.grpc.Status.Code;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
 
 /** Unit tests for {@link Http2ClientStreamTransportState}. */
 @RunWith(JUnit4.class)
 public class Http2ClientStreamTransportStateTest {
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private final Metadata.Key<String> testStatusMashaller =
+      InternalMetadata.keyOf(":status", Metadata.ASCII_STRING_MARSHALLER);
+
+  private TransportTracer transportTracer;
   @Mock private ClientStreamListener mockListener;
   @Captor private ArgumentCaptor<Status> statusCaptor;
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
+    transportTracer = new TransportTracer();
+
+    doAnswer(new Answer<Void>() {
+      @Override
+      public Void answer(InvocationOnMock invocation) throws Throwable {
+        StreamListener.MessageProducer producer =
+            (StreamListener.MessageProducer) invocation.getArguments()[0];
+        while (producer.next() != null) {}
+        return null;
+      }
+    }).when(mockListener).messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
   }
 
   @Test
   public void transportHeadersReceived_notifiesListener() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata headers = new Metadata();
-    headers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "200");
+    headers.put(testStatusMashaller, "200");
     headers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER),
         "application/grpc");
     state.transportHeadersReceived(headers);
 
-    verify(mockListener, never()).closed(any(Status.class), any(Metadata.class));
+    verify(mockListener, never()).closed(any(Status.class), same(PROCESSED), any(Metadata.class));
     verify(mockListener).headersRead(headers);
   }
 
   @Test
   public void transportHeadersReceived_doesntRequire200() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata headers = new Metadata();
-    headers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "500");
+    headers.put(testStatusMashaller, "500");
     headers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER),
         "application/grpc");
     state.transportHeadersReceived(headers);
 
-    verify(mockListener, never()).closed(any(Status.class), any(Metadata.class));
+    verify(mockListener, never()).closed(any(Status.class), same(PROCESSED), any(Metadata.class));
     verify(mockListener).headersRead(headers);
   }
 
   @Test
   public void transportHeadersReceived_noHttpStatus() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata headers = new Metadata();
     headers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER),
@@ -102,38 +114,38 @@ public void transportHeadersReceived_noHttpStatus() {
     state.transportDataReceived(ReadableBuffers.empty(), true);
 
     verify(mockListener, never()).headersRead(any(Metadata.class));
-    verify(mockListener).closed(statusCaptor.capture(), same(headers));
+    verify(mockListener).closed(statusCaptor.capture(), same(PROCESSED), same(headers));
     assertEquals(Code.INTERNAL, statusCaptor.getValue().getCode());
   }
 
   @Test
   public void transportHeadersReceived_wrongContentType_200() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata headers = new Metadata();
-    headers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "200");
+    headers.put(testStatusMashaller, "200");
     headers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER), "text/html");
     state.transportHeadersReceived(headers);
     state.transportDataReceived(ReadableBuffers.empty(), true);
 
     verify(mockListener, never()).headersRead(any(Metadata.class));
-    verify(mockListener).closed(statusCaptor.capture(), same(headers));
+    verify(mockListener).closed(statusCaptor.capture(), same(PROCESSED), same(headers));
     assertEquals(Code.UNKNOWN, statusCaptor.getValue().getCode());
     assertTrue(statusCaptor.getValue().getDescription().contains("200"));
   }
 
   @Test
   public void transportHeadersReceived_wrongContentType_401() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata headers = new Metadata();
-    headers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "401");
+    headers.put(testStatusMashaller, "401");
     headers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER), "text/html");
     state.transportHeadersReceived(headers);
     state.transportDataReceived(ReadableBuffers.empty(), true);
 
     verify(mockListener, never()).headersRead(any(Metadata.class));
-    verify(mockListener).closed(statusCaptor.capture(), same(headers));
+    verify(mockListener).closed(statusCaptor.capture(), same(PROCESSED), same(headers));
     assertEquals(Code.UNAUTHENTICATED, statusCaptor.getValue().getCode());
     assertTrue(statusCaptor.getValue().getDescription().contains("401"));
     assertTrue(statusCaptor.getValue().getDescription().contains("text/html"));
@@ -141,32 +153,32 @@ public void transportHeadersReceived_wrongContentType_401() {
 
   @Test
   public void transportHeadersReceived_handles_1xx() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
 
     Metadata infoHeaders = new Metadata();
-    infoHeaders.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "100");
+    infoHeaders.put(testStatusMashaller, "100");
     state.transportHeadersReceived(infoHeaders);
     Metadata infoHeaders2 = new Metadata();
-    infoHeaders2.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "101");
+    infoHeaders2.put(testStatusMashaller, "101");
     state.transportHeadersReceived(infoHeaders2);
 
     Metadata headers = new Metadata();
-    headers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "200");
+    headers.put(testStatusMashaller, "200");
     headers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER),
         "application/grpc");
     state.transportHeadersReceived(headers);
 
-    verify(mockListener, never()).closed(any(Status.class), any(Metadata.class));
+    verify(mockListener, never()).closed(any(Status.class), same(PROCESSED), any(Metadata.class));
     verify(mockListener).headersRead(headers);
   }
 
   @Test
   public void transportHeadersReceived_twice() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata headers = new Metadata();
-    headers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "200");
+    headers.put(testStatusMashaller, "200");
     headers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER),
         "application/grpc");
     state.transportHeadersReceived(headers);
@@ -175,17 +187,17 @@ public void transportHeadersReceived_twice() {
     state.transportDataReceived(ReadableBuffers.empty(), true);
 
     verify(mockListener).headersRead(headers);
-    verify(mockListener).closed(statusCaptor.capture(), same(headersAgain));
+    verify(mockListener).closed(statusCaptor.capture(), same(PROCESSED), same(headersAgain));
     assertEquals(Code.INTERNAL, statusCaptor.getValue().getCode());
     assertTrue(statusCaptor.getValue().getDescription().contains("twice"));
   }
 
   @Test
   public void transportHeadersReceived_unknownAndTwiceLogsSecondHeaders() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata headers = new Metadata();
-    headers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "200");
+    headers.put(testStatusMashaller, "200");
     headers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER), "text/html");
     state.transportHeadersReceived(headers);
     Metadata headersAgain = new Metadata();
@@ -195,47 +207,58 @@ public void transportHeadersReceived_unknownAndTwiceLogsSecondHeaders() {
     state.transportDataReceived(ReadableBuffers.empty(), true);
 
     verify(mockListener, never()).headersRead(any(Metadata.class));
-    verify(mockListener).closed(statusCaptor.capture(), same(headers));
+    verify(mockListener).closed(statusCaptor.capture(), same(PROCESSED), same(headers));
     assertEquals(Code.UNKNOWN, statusCaptor.getValue().getCode());
     assertTrue(statusCaptor.getValue().getDescription().contains(testString));
   }
 
+  @Test
+  public void transportDataReceived_noHeaderReceived() {
+    BaseTransportState state = new BaseTransportState(transportTracer);
+    state.setListener(mockListener);
+    String testString = "This is a test";
+    state.transportDataReceived(ReadableBuffers.wrap(testString.getBytes(US_ASCII)), true);
+
+    verify(mockListener).closed(statusCaptor.capture(), same(PROCESSED), any(Metadata.class));
+    assertEquals(Code.INTERNAL, statusCaptor.getValue().getCode());
+  }
+
   @Test
   public void transportDataReceived_debugData() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata headers = new Metadata();
-    headers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "200");
+    headers.put(testStatusMashaller, "200");
     headers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER), "text/html");
     state.transportHeadersReceived(headers);
     String testString = "This is a test";
     state.transportDataReceived(ReadableBuffers.wrap(testString.getBytes(US_ASCII)), true);
 
-    verify(mockListener).closed(statusCaptor.capture(), same(headers));
+    verify(mockListener).closed(statusCaptor.capture(), same(PROCESSED), same(headers));
     assertTrue(statusCaptor.getValue().getDescription().contains(testString));
   }
 
   @Test
   public void transportTrailersReceived_notifiesListener() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata trailers = new Metadata();
-    trailers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "200");
+    trailers.put(testStatusMashaller, "200");
     trailers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER),
         "application/grpc");
     trailers.put(Metadata.Key.of("grpc-status", Metadata.ASCII_STRING_MARSHALLER), "0");
     state.transportTrailersReceived(trailers);
 
     verify(mockListener, never()).headersRead(any(Metadata.class));
-    verify(mockListener).closed(Status.OK, trailers);
+    verify(mockListener).closed(Status.OK, PROCESSED, trailers);
   }
 
   @Test
   public void transportTrailersReceived_afterHeaders() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata headers = new Metadata();
-    headers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "200");
+    headers.put(testStatusMashaller, "200");
     headers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER),
         "application/grpc");
     state.transportHeadersReceived(headers);
@@ -244,43 +267,43 @@ public void transportTrailersReceived_afterHeaders() {
     state.transportTrailersReceived(trailers);
 
     verify(mockListener).headersRead(headers);
-    verify(mockListener).closed(Status.OK, trailers);
+    verify(mockListener).closed(Status.OK, PROCESSED, trailers);
   }
 
   @Test
   public void transportTrailersReceived_observesStatus() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata trailers = new Metadata();
-    trailers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "200");
+    trailers.put(testStatusMashaller, "200");
     trailers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER),
         "application/grpc");
     trailers.put(Metadata.Key.of("grpc-status", Metadata.ASCII_STRING_MARSHALLER), "1");
     state.transportTrailersReceived(trailers);
 
     verify(mockListener, never()).headersRead(any(Metadata.class));
-    verify(mockListener).closed(Status.CANCELLED, trailers);
+    verify(mockListener).closed(Status.CANCELLED, PROCESSED, trailers);
   }
 
   @Test
   public void transportTrailersReceived_missingStatusUsesHttpStatus() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata trailers = new Metadata();
-    trailers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "401");
+    trailers.put(testStatusMashaller, "401");
     trailers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER),
         "application/grpc");
     state.transportTrailersReceived(trailers);
 
     verify(mockListener, never()).headersRead(any(Metadata.class));
-    verify(mockListener).closed(statusCaptor.capture(), same(trailers));
+    verify(mockListener).closed(statusCaptor.capture(), same(PROCESSED), same(trailers));
     assertEquals(Code.UNAUTHENTICATED, statusCaptor.getValue().getCode());
     assertTrue(statusCaptor.getValue().getDescription().contains("401"));
   }
 
   @Test
   public void transportTrailersReceived_missingHttpStatus() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata trailers = new Metadata();
     trailers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER),
@@ -289,13 +312,13 @@ public void transportTrailersReceived_missingHttpStatus() {
     state.transportTrailersReceived(trailers);
 
     verify(mockListener, never()).headersRead(any(Metadata.class));
-    verify(mockListener).closed(statusCaptor.capture(), same(trailers));
+    verify(mockListener).closed(statusCaptor.capture(), same(PROCESSED), same(trailers));
     assertEquals(Code.INTERNAL, statusCaptor.getValue().getCode());
   }
 
   @Test
   public void transportTrailersReceived_missingStatusAndMissingHttpStatus() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata trailers = new Metadata();
     trailers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER),
@@ -303,42 +326,66 @@ public void transportTrailersReceived_missingStatusAndMissingHttpStatus() {
     state.transportTrailersReceived(trailers);
 
     verify(mockListener, never()).headersRead(any(Metadata.class));
-    verify(mockListener).closed(statusCaptor.capture(), same(trailers));
+    verify(mockListener).closed(statusCaptor.capture(), same(PROCESSED), same(trailers));
     assertEquals(Code.INTERNAL, statusCaptor.getValue().getCode());
   }
 
   @Test
   public void transportTrailersReceived_missingStatusAfterHeadersIgnoresHttpStatus() {
-    BaseTransportState state = new BaseTransportState();
+    BaseTransportState state = new BaseTransportState(transportTracer);
     state.setListener(mockListener);
     Metadata headers = new Metadata();
-    headers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "200");
+    headers.put(testStatusMashaller, "200");
     headers.put(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER),
         "application/grpc");
     state.transportHeadersReceived(headers);
     Metadata trailers = new Metadata();
-    trailers.put(Metadata.Key.of(":status", Metadata.ASCII_STRING_MARSHALLER), "401");
+    trailers.put(testStatusMashaller, "401");
     state.transportTrailersReceived(trailers);
 
     verify(mockListener).headersRead(headers);
-    verify(mockListener).closed(statusCaptor.capture(), same(trailers));
+    verify(mockListener).closed(statusCaptor.capture(), same(PROCESSED), same(trailers));
     assertEquals(Code.UNKNOWN, statusCaptor.getValue().getCode());
   }
 
+  @Test
+  public void transportStateWithOnReadyThreshold() {
+    BaseTransportState state = new BaseTransportState(transportTracer,
+        CallOptions.DEFAULT.withOnReadyThreshold(Integer.MAX_VALUE));
+    assertEquals(Integer.MAX_VALUE, state.onReadyThreshold);
+  }
+
   private static class BaseTransportState extends Http2ClientStreamTransportState {
-    public BaseTransportState() {
-      super(DEFAULT_MAX_MESSAGE_SIZE, StatsTraceContext.NOOP);
+    private int onReadyThreshold;
+
+    public BaseTransportState(TransportTracer transportTracer, CallOptions options) {
+      super(DEFAULT_MAX_MESSAGE_SIZE, StatsTraceContext.NOOP, transportTracer, options);
+    }
+
+    public BaseTransportState(TransportTracer transportTracer) {
+      this(transportTracer, CallOptions.DEFAULT);
     }
 
     @Override
-    protected void http2ProcessingFailed(Status status, Metadata trailers) {
-      transportReportStatus(status, false, trailers);
+    protected void http2ProcessingFailed(Status status, boolean stopDelivery, Metadata trailers) {
+      transportReportStatus(status, stopDelivery, trailers);
     }
 
     @Override
-    protected void deframeFailed(Throwable cause) {}
+    public void deframeFailed(Throwable cause) {}
 
     @Override
     public void bytesRead(int processedBytes) {}
+
+    @Override
+    public void runOnTransportThread(Runnable r) {
+      r.run();
+    }
+
+    @Override
+    void setOnReadyThreshold(int numBytes) {
+      onReadyThreshold = numBytes;
+      super.setOnReadyThreshold(numBytes);
+    }
   }
 }
diff --git a/core/src/test/java/io/grpc/internal/InUseStateAggregatorTest.java b/core/src/test/java/io/grpc/internal/InUseStateAggregatorTest.java
new file mode 100644
index 00000000000..e1bbc063ea3
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/InUseStateAggregatorTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2021 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.internal;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link InUseStateAggregator}.
+ */
+@RunWith(JUnit4.class)
+public class InUseStateAggregatorTest {
+
+  private InUseStateAggregator<String> aggregator;
+
+  @Before
+  public void setUp() {
+    aggregator = new InUseStateAggregator<String>() {
+      @Override
+      protected void handleInUse() {
+      }
+
+      @Override
+      protected void handleNotInUse() {
+      }
+    };
+  }
+
+  @Test
+  public void anyObjectInUse() {
+    String objectOne = "1";
+    String objectTwo = "2";
+    String objectThree = "3";
+
+    aggregator.updateObjectInUse(objectOne, true);
+    assertTrue(aggregator.anyObjectInUse(objectOne));
+
+    aggregator.updateObjectInUse(objectTwo, true);
+    aggregator.updateObjectInUse(objectThree, true);
+    assertTrue(aggregator.anyObjectInUse(objectOne, objectTwo, objectThree));
+
+    aggregator.updateObjectInUse(objectTwo, false);
+    assertTrue(aggregator.anyObjectInUse(objectOne, objectThree));
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/InstantTimeProviderTest.java b/core/src/test/java/io/grpc/internal/InstantTimeProviderTest.java
new file mode 100644
index 00000000000..6702bc421a5
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/InstantTimeProviderTest.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2024 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import java.time.Instant;
+import java.util.concurrent.TimeUnit;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link InstantTimeProvider}.
+ */
+@RunWith(JUnit4.class)
+@IgnoreJRERequirement
+public class InstantTimeProviderTest {
+  @Test
+  public void testInstantCurrentTimeNanos() throws Exception {
+
+    InstantTimeProvider instantTimeProvider = new InstantTimeProvider();
+
+    // Get the current time from the InstantTimeProvider
+    long actualTimeNanos = instantTimeProvider.currentTimeNanos();
+
+    // Get the current time from Instant for comparison
+    Instant instantNow = Instant.now();
+    long expectedTimeNanos = TimeUnit.SECONDS.toNanos(instantNow.getEpochSecond())
+          + instantNow.getNano();
+
+    // Validate the time returned is close to the expected value within a tolerance
+    // (i,e 1000 millisecond (1 second) tolerance in nanoseconds).
+    assertThat(actualTimeNanos).isWithin(1000_000_000L).of(expectedTimeNanos);
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/InternalSubchannelTest.java b/core/src/test/java/io/grpc/internal/InternalSubchannelTest.java
index 260ebd75247..811344da307 100644
--- a/core/src/test/java/io/grpc/internal/InternalSubchannelTest.java
+++ b/core/src/test/java/io/grpc/internal/InternalSubchannelTest.java
@@ -1,44 +1,41 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.same;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
@@ -46,44 +43,75 @@
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
-import io.grpc.ConnectivityState;
+import com.google.common.collect.Iterables;
+import io.grpc.Attributes;
 import io.grpc.ConnectivityStateInfo;
 import io.grpc.EquivalentAddressGroup;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalLogId;
+import io.grpc.InternalWithLogId;
+import io.grpc.LoadBalancer;
+import io.grpc.MetricInstrument;
+import io.grpc.MetricRecorder;
+import io.grpc.NameResolver;
+import io.grpc.SecurityLevel;
 import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.InternalSubchannel.CallTracingTransport;
+import io.grpc.internal.InternalSubchannel.Index;
+import io.grpc.internal.InternalSubchannel.TransportLogger;
 import io.grpc.internal.TestUtils.MockClientTransportInfo;
 import java.net.SocketAddress;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.LinkedList;
+import java.util.List;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
+import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /**
  * Unit tests for {@link InternalSubchannel}.
- *
- * <p>It only tests the logic that is not covered by {@link ManagedChannelImplTransportManagerTest}.
  */
 @RunWith(JUnit4.class)
 public class InternalSubchannelTest {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
 
   private static final String AUTHORITY = "fakeauthority";
+  private static final String BACKEND_SERVICE = "ice-cream-factory-service";
+  private static final String LOCALITY = "mars-olympus-mons-datacenter";
+  private static final SecurityLevel SECURITY_LEVEL = SecurityLevel.PRIVACY_AND_INTEGRITY;
   private static final String USER_AGENT = "mosaic";
   private static final ConnectivityStateInfo UNAVAILABLE_STATE =
       ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE);
   private static final ConnectivityStateInfo RESOURCE_EXHAUSTED_STATE =
       ConnectivityStateInfo.forTransientFailure(Status.RESOURCE_EXHAUSTED);
+  private static final Status SHUTDOWN_REASON = Status.UNAVAILABLE.withDescription("for test");
 
   // For scheduled executor
   private final FakeClock fakeClock = new FakeClock();
-  // For channelExecutor
+  // For syncContext
   private final FakeClock fakeExecutor = new FakeClock();
-  private final ChannelExecutor channelExecutor = new ChannelExecutor();
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+
+  private final InternalChannelz channelz = new InternalChannelz();
 
   @Mock private BackoffPolicy mockBackoffPolicy1;
   @Mock private BackoffPolicy mockBackoffPolicy2;
@@ -91,7 +119,11 @@ public class InternalSubchannelTest {
   @Mock private BackoffPolicy.Provider mockBackoffPolicyProvider;
   @Mock private ClientTransportFactory mockTransportFactory;
 
-  private final LinkedList<String> callbackInvokes = new LinkedList<String>();
+  @Mock private BackoffPolicy mockBackoffPolicy;
+  private MetricRecorder mockMetricRecorder = mock(MetricRecorder.class,
+      delegatesTo(new MetricRecorderImpl()));
+
+  private final LinkedList<String> callbackInvokes = new LinkedList<>();
   private final InternalSubchannel.Callback mockInternalSubchannelCallback =
       new InternalSubchannel.Callback() {
         @Override
@@ -120,17 +152,14 @@ protected void onNotInUse(InternalSubchannel is) {
       };
 
   private InternalSubchannel internalSubchannel;
-  private EquivalentAddressGroup addressGroup;
   private BlockingQueue<MockClientTransportInfo> transports;
 
   @Before public void setUp() {
-    MockitoAnnotations.initMocks(this);
-
     when(mockBackoffPolicyProvider.get())
         .thenReturn(mockBackoffPolicy1, mockBackoffPolicy2, mockBackoffPolicy3);
-    when(mockBackoffPolicy1.nextBackoffMillis()).thenReturn(10L, 100L);
-    when(mockBackoffPolicy2.nextBackoffMillis()).thenReturn(10L, 100L);
-    when(mockBackoffPolicy3.nextBackoffMillis()).thenReturn(10L, 100L);
+    when(mockBackoffPolicy1.nextBackoffNanos()).thenReturn(10L, 100L);
+    when(mockBackoffPolicy2.nextBackoffNanos()).thenReturn(10L, 100L);
+    when(mockBackoffPolicy3.nextBackoffNanos()).thenReturn(10L, 100L);
     transports = TestUtils.captureTransports(mockTransportFactory);
   }
 
@@ -139,10 +168,50 @@ protected void onNotInUse(InternalSubchannel is) {
     assertEquals(0, fakeExecutor.numPendingTasks());
   }
 
+  @Test(expected = IllegalArgumentException.class)
+  public void constructor_emptyEagList_throws() {
+    createInternalSubchannel(new EquivalentAddressGroup[0]);
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void constructor_eagListWithNull_throws() {
+    createInternalSubchannel(new EquivalentAddressGroup[] {null});
+  }
+
+  @Test public void eagAttribute_propagatesToTransport() {
+    SocketAddress addr = new SocketAddress() {};
+    Attributes attr = Attributes.newBuilder().set(Attributes.Key.create("some-key"), "1").build();
+    createInternalSubchannel(new EquivalentAddressGroup(Arrays.asList(addr), attr));
+
+    // First attempt
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertEquals(CONNECTING, internalSubchannel.getState());
+    verify(mockTransportFactory).newClientTransport(
+        eq(addr),
+        eq(createClientTransportOptions().setEagAttributes(attr)),
+        isA(TransportLogger.class));
+  }
+
+  @Test public void eagAuthorityOverride_propagatesToTransport() {
+    SocketAddress addr = new SocketAddress() {};
+    String overriddenAuthority = "authority-override";
+    Attributes attr = Attributes.newBuilder()
+            .set(EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE, overriddenAuthority).build();
+    createInternalSubchannel(new EquivalentAddressGroup(Arrays.asList(addr), attr));
+
+    // First attempt
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertEquals(CONNECTING, internalSubchannel.getState());
+    verify(mockTransportFactory).newClientTransport(
+        eq(addr),
+        eq(createClientTransportOptions().setAuthority(overriddenAuthority).setEagAttributes(attr)),
+        isA(TransportLogger.class));
+  }
+
   @Test public void singleAddressReconnect() {
     SocketAddress addr = mock(SocketAddress.class);
     createInternalSubchannel(addr);
-    assertEquals(ConnectivityState.IDLE, internalSubchannel.getState());
+    assertEquals(IDLE, internalSubchannel.getState());
 
     // Invocation counters
     int transportsCreated = 0;
@@ -151,93 +220,165 @@ protected void onNotInUse(InternalSubchannel is) {
     int backoffReset = 0;
 
     // First attempt
-    assertEquals(ConnectivityState.IDLE, internalSubchannel.getState());
+    assertEquals(IDLE, internalSubchannel.getState());
     assertNoCallbackInvoke();
     assertNull(internalSubchannel.obtainActiveTransport());
     assertExactCallbackInvokes("onStateChange:CONNECTING");
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
+    assertEquals(CONNECTING, internalSubchannel.getState());
     verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
 
     // Fail this one. Because there is only one address to try, enter TRANSIENT_FAILURE.
     assertNoCallbackInvoke();
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, internalSubchannel.getState());
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
     assertExactCallbackInvokes("onStateChange:" + UNAVAILABLE_STATE);
     // Backoff reset and using first back-off value interval
-    verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffMillis();
+    verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffNanos();
     verify(mockBackoffPolicyProvider, times(++backoffReset)).get();
 
     // Second attempt
     // Transport creation doesn't happen until time is due
-    fakeClock.forwardMillis(9);
+    fakeClock.forwardNanos(9);
     assertNull(internalSubchannel.obtainActiveTransport());
     verify(mockTransportFactory, times(transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, internalSubchannel.getState());
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
 
     assertNoCallbackInvoke();
-    fakeClock.forwardMillis(1);
+    fakeClock.forwardNanos(1);
     assertExactCallbackInvokes("onStateChange:CONNECTING");
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
+    assertEquals(CONNECTING, internalSubchannel.getState());
     verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
     // Fail this one too
     assertNoCallbackInvoke();
     // Here we use a different status from the first failure, and verify that it's passed to
     // the callback.
-    transports.poll().listener.transportShutdown(Status.RESOURCE_EXHAUSTED);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, internalSubchannel.getState());
+    transports.poll().listener.transportShutdown(Status.RESOURCE_EXHAUSTED,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
     assertExactCallbackInvokes("onStateChange:" + RESOURCE_EXHAUSTED_STATE);
     // Second back-off interval
-    verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffMillis();
+    verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffNanos();
     verify(mockBackoffPolicyProvider, times(backoffReset)).get();
 
     // Third attempt
     // Transport creation doesn't happen until time is due
-    fakeClock.forwardMillis(99);
+    fakeClock.forwardNanos(99);
     assertNull(internalSubchannel.obtainActiveTransport());
     verify(mockTransportFactory, times(transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, internalSubchannel.getState());
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
     assertNoCallbackInvoke();
-    fakeClock.forwardMillis(1);
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
+    fakeClock.forwardNanos(1);
+    assertEquals(CONNECTING, internalSubchannel.getState());
     assertExactCallbackInvokes("onStateChange:CONNECTING");
     assertNull(internalSubchannel.obtainActiveTransport());
     verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
     // Let this one succeed, will enter READY state.
     assertNoCallbackInvoke();
     transports.peek().listener.transportReady();
     assertExactCallbackInvokes("onStateChange:READY");
-    assertEquals(ConnectivityState.READY, internalSubchannel.getState());
-    assertSame(transports.peek().transport, internalSubchannel.obtainActiveTransport());
+    assertEquals(READY, internalSubchannel.getState());
+    assertSame(
+        transports.peek().transport,
+        ((CallTracingTransport) internalSubchannel.obtainActiveTransport()).delegate());
 
     // Close the READY transport, will enter IDLE state.
     assertNoCallbackInvoke();
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.IDLE, internalSubchannel.getState());
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertEquals(IDLE, internalSubchannel.getState());
     assertExactCallbackInvokes("onStateChange:IDLE");
 
     // Back-off is reset, and the next attempt will happen immediately
     assertNull(internalSubchannel.obtainActiveTransport());
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
+    assertEquals(CONNECTING, internalSubchannel.getState());
     assertExactCallbackInvokes("onStateChange:CONNECTING");
     verify(mockBackoffPolicyProvider, times(backoffReset)).get();
     verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
 
     // Final checks for consultations on back-off policies
-    verify(mockBackoffPolicy1, times(backoff1Consulted)).nextBackoffMillis();
-    verify(mockBackoffPolicy2, times(backoff2Consulted)).nextBackoffMillis();
+    verify(mockBackoffPolicy1, times(backoff1Consulted)).nextBackoffNanos();
+    verify(mockBackoffPolicy2, times(backoff2Consulted)).nextBackoffNanos();
+  }
+
+  @Test public void twoAddressesReconnectDisabled() {
+    SocketAddress addr1 = mock(SocketAddress.class);
+    SocketAddress addr2 = mock(SocketAddress.class);
+    createInternalSubchannel(true,
+        new EquivalentAddressGroup(Arrays.asList(addr1, addr2)));
+    assertEquals(IDLE, internalSubchannel.getState());
+
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertExactCallbackInvokes("onStateChange:CONNECTING");
+    assertEquals(CONNECTING, internalSubchannel.getState());
+    verify(mockTransportFactory).newClientTransport(eq(addr1), any(), any());
+    // Let this one fail without success
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    // Still in CONNECTING
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertNoCallbackInvoke();
+    assertEquals(CONNECTING, internalSubchannel.getState());
+
+    // Second attempt will start immediately. Still no back-off policy.
+    verify(mockBackoffPolicyProvider, times(0)).get();
+    verify(mockTransportFactory, times(1))
+        .newClientTransport(
+            eq(addr2),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    assertNull(internalSubchannel.obtainActiveTransport());
+    // Fail this one too
+    assertNoCallbackInvoke();
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    // All addresses have failed, but we aren't controlling retries.
+    assertEquals(IDLE, internalSubchannel.getState());
+    assertExactCallbackInvokes("onStateChange:" + UNAVAILABLE_STATE);
+    // Backoff reset and first back-off interval begins
+    verify(mockBackoffPolicy1, never()).nextBackoffNanos();
+    verify(mockBackoffPolicyProvider, never()).get();
+    assertTrue("Nothing should have been scheduled", fakeClock.getPendingTasks().isEmpty());
+
+    // Should follow orders and create an active transport.
+    internalSubchannel.obtainActiveTransport();
+    assertExactCallbackInvokes("onStateChange:CONNECTING");
+    assertEquals(CONNECTING, internalSubchannel.getState());
+
+    // Shouldn't have anything scheduled, so shouldn't do anything
+    assertTrue("Nothing should have been scheduled 2", fakeClock.getPendingTasks().isEmpty());
   }
 
   @Test public void twoAddressesReconnect() {
     SocketAddress addr1 = mock(SocketAddress.class);
     SocketAddress addr2 = mock(SocketAddress.class);
-    createInternalSubchannel(addr1, addr2);
-    assertEquals(ConnectivityState.IDLE, internalSubchannel.getState());
+    createInternalSubchannel(false,
+        new EquivalentAddressGroup(Arrays.asList(addr1, addr2)));
+    assertEquals(IDLE, internalSubchannel.getState());
     // Invocation counters
     int transportsAddr1 = 0;
     int transportsAddr2 = 0;
@@ -250,135 +391,544 @@ protected void onNotInUse(InternalSubchannel is) {
     assertNoCallbackInvoke();
     assertNull(internalSubchannel.obtainActiveTransport());
     assertExactCallbackInvokes("onStateChange:CONNECTING");
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
+    assertEquals(CONNECTING, internalSubchannel.getState());
     verify(mockTransportFactory, times(++transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
 
     // Let this one fail without success
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     // Still in CONNECTING
     assertNull(internalSubchannel.obtainActiveTransport());
     assertNoCallbackInvoke();
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
+    assertEquals(CONNECTING, internalSubchannel.getState());
 
     // Second attempt will start immediately. Still no back-off policy.
     verify(mockBackoffPolicyProvider, times(backoffReset)).get();
     verify(mockTransportFactory, times(++transportsAddr2))
-        .newClientTransport(addr2, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr2),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
     assertNull(internalSubchannel.obtainActiveTransport());
     // Fail this one too
     assertNoCallbackInvoke();
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     // All addresses have failed. Delayed transport will be in back-off interval.
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, internalSubchannel.getState());
+    assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
     assertExactCallbackInvokes("onStateChange:" + UNAVAILABLE_STATE);
     // Backoff reset and first back-off interval begins
-    verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffMillis();
+    verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffNanos();
     verify(mockBackoffPolicyProvider, times(++backoffReset)).get();
 
     // No reconnect during TRANSIENT_FAILURE even when requested.
     assertNull(internalSubchannel.obtainActiveTransport());
     assertNoCallbackInvoke();
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, internalSubchannel.getState());
+    assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
 
     // Third attempt is the first address, thus controlled by the first back-off interval.
-    fakeClock.forwardMillis(9);
+    fakeClock.forwardNanos(9);
     verify(mockTransportFactory, times(transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, internalSubchannel.getState());
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
     assertNoCallbackInvoke();
-    fakeClock.forwardMillis(1);
+    fakeClock.forwardNanos(1);
     assertExactCallbackInvokes("onStateChange:CONNECTING");
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
+    assertEquals(CONNECTING, internalSubchannel.getState());
     verify(mockTransportFactory, times(++transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
     // Fail this one too
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertEquals(CONNECTING, internalSubchannel.getState());
 
     // Forth attempt will start immediately. Keep back-off policy.
     assertNull(internalSubchannel.obtainActiveTransport());
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
+    assertEquals(CONNECTING, internalSubchannel.getState());
     verify(mockBackoffPolicyProvider, times(backoffReset)).get();
     verify(mockTransportFactory, times(++transportsAddr2))
-        .newClientTransport(addr2, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr2),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
     // Fail this one too
     assertNoCallbackInvoke();
-    transports.poll().listener.transportShutdown(Status.RESOURCE_EXHAUSTED);
+    transports.poll().listener.transportShutdown(Status.RESOURCE_EXHAUSTED,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     // All addresses have failed again. Delayed transport will be in back-off interval.
     assertExactCallbackInvokes("onStateChange:" + RESOURCE_EXHAUSTED_STATE);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, internalSubchannel.getState());
+    assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
     // Second back-off interval begins
-    verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffMillis();
+    verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffNanos();
     verify(mockBackoffPolicyProvider, times(backoffReset)).get();
 
     // Fifth attempt for the first address, thus controlled by the second back-off interval.
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, internalSubchannel.getState());
-    fakeClock.forwardMillis(99);
+    assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
+    fakeClock.forwardNanos(99);
     verify(mockTransportFactory, times(transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, internalSubchannel.getState());
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
     assertNoCallbackInvoke();
-    fakeClock.forwardMillis(1);
+    fakeClock.forwardNanos(1);
     assertExactCallbackInvokes("onStateChange:CONNECTING");
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
+    assertEquals(CONNECTING, internalSubchannel.getState());
     verify(mockTransportFactory, times(++transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
     // Let it through
     assertNoCallbackInvoke();
     transports.peek().listener.transportReady();
     assertExactCallbackInvokes("onStateChange:READY");
-    assertEquals(ConnectivityState.READY, internalSubchannel.getState());
+    assertEquals(READY, internalSubchannel.getState());
 
-    assertSame(transports.peek().transport, internalSubchannel.obtainActiveTransport());
+    assertSame(
+        transports.peek().transport,
+        ((CallTracingTransport) internalSubchannel.obtainActiveTransport()).delegate());
     // Then close it.
     assertNoCallbackInvoke();
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertExactCallbackInvokes("onStateChange:IDLE");
-    assertEquals(ConnectivityState.IDLE, internalSubchannel.getState());
+    assertEquals(IDLE, internalSubchannel.getState());
 
     // First attempt after a successful connection. Old back-off policy should be ignored, but there
     // is not yet a need for a new one. Start from the first address.
     assertNull(internalSubchannel.obtainActiveTransport());
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
+    assertEquals(CONNECTING, internalSubchannel.getState());
     assertExactCallbackInvokes("onStateChange:CONNECTING");
     verify(mockBackoffPolicyProvider, times(backoffReset)).get();
     verify(mockTransportFactory, times(++transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
     // Fail the transport
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertEquals(CONNECTING, internalSubchannel.getState());
 
     // Second attempt will start immediately. Still no new back-off policy.
     verify(mockBackoffPolicyProvider, times(backoffReset)).get();
     verify(mockTransportFactory, times(++transportsAddr2))
-        .newClientTransport(addr2, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr2),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
     // Fail this one too
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    assertEquals(CONNECTING, internalSubchannel.getState());
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     // All addresses have failed. Enter TRANSIENT_FAILURE. Back-off in effect.
     assertExactCallbackInvokes("onStateChange:" + UNAVAILABLE_STATE);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, internalSubchannel.getState());
+    assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
     // Back-off reset and first back-off interval begins
-    verify(mockBackoffPolicy2, times(++backoff2Consulted)).nextBackoffMillis();
+    verify(mockBackoffPolicy2, times(++backoff2Consulted)).nextBackoffNanos();
     verify(mockBackoffPolicyProvider, times(++backoffReset)).get();
 
     // Third attempt is the first address, thus controlled by the first back-off interval.
-    fakeClock.forwardMillis(9);
+    fakeClock.forwardNanos(9);
     verify(mockTransportFactory, times(transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, internalSubchannel.getState());
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
     assertNoCallbackInvoke();
-    fakeClock.forwardMillis(1);
+    fakeClock.forwardNanos(1);
     assertExactCallbackInvokes("onStateChange:CONNECTING");
-    assertEquals(ConnectivityState.CONNECTING, internalSubchannel.getState());
+    assertEquals(CONNECTING, internalSubchannel.getState());
     verify(mockTransportFactory, times(++transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
 
     // Final checks on invocations on back-off policies
-    verify(mockBackoffPolicy1, times(backoff1Consulted)).nextBackoffMillis();
-    verify(mockBackoffPolicy2, times(backoff2Consulted)).nextBackoffMillis();
-    verify(mockBackoffPolicy3, times(backoff3Consulted)).nextBackoffMillis();
+    verify(mockBackoffPolicy1, times(backoff1Consulted)).nextBackoffNanos();
+    verify(mockBackoffPolicy2, times(backoff2Consulted)).nextBackoffNanos();
+    verify(mockBackoffPolicy3, times(backoff3Consulted)).nextBackoffNanos();
+  }
+
+  @Test
+  public void updateAddresses_emptyEagList_throws() {
+    SocketAddress addr = new FakeSocketAddress();
+    createInternalSubchannel(addr);
+    List<EquivalentAddressGroup> newAddressGroups = Collections.emptyList();
+    assertThrows(IllegalArgumentException.class,
+        () -> internalSubchannel.updateAddresses(newAddressGroups));
+  }
+
+  @Test
+  public void updateAddresses_eagListWithNull_throws() {
+    SocketAddress addr = new FakeSocketAddress();
+    createInternalSubchannel(addr);
+    List<EquivalentAddressGroup> eags = Arrays.asList((EquivalentAddressGroup) null);
+    assertThrows(NullPointerException.class, () -> internalSubchannel.updateAddresses(eags));
+  }
+
+  @Test public void updateAddresses_intersecting_ready() {
+    SocketAddress addr1 = mock(SocketAddress.class);
+    SocketAddress addr2 = mock(SocketAddress.class);
+    SocketAddress addr3 = mock(SocketAddress.class);
+    createInternalSubchannel(addr1, addr2);
+    assertEquals(IDLE, internalSubchannel.getState());
+
+    // First address fails
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertExactCallbackInvokes("onStateChange:CONNECTING");
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertEquals(CONNECTING, internalSubchannel.getState());
+
+    // Second address connects
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr2),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.peek().listener.transportReady();
+    assertExactCallbackInvokes("onStateChange:READY");
+    assertEquals(READY, internalSubchannel.getState());
+
+    // Update addresses
+    internalSubchannel.updateAddresses(
+        Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr2, addr3))));
+    assertNoCallbackInvoke();
+    assertEquals(READY, internalSubchannel.getState());
+    verify(transports.peek().transport, never()).shutdown(any(Status.class));
+    verify(transports.peek().transport, never()).shutdownNow(any(Status.class));
+
+    // And new addresses chosen when re-connecting
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertExactCallbackInvokes("onStateChange:IDLE");
+
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(mockTransportFactory, times(2))
+        .newClientTransport(
+            eq(addr2),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr3),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    verifyNoMoreInteractions(mockTransportFactory);
+
+    fakeClock.forwardNanos(10); // Drain retry, but don't care about result
+  }
+
+  @Test public void updateAddresses_intersecting_connecting() {
+    SocketAddress addr1 = mock(SocketAddress.class);
+    SocketAddress addr2 = mock(SocketAddress.class);
+    SocketAddress addr3 = mock(SocketAddress.class);
+    createInternalSubchannel(addr1, addr2);
+    assertEquals(IDLE, internalSubchannel.getState());
+
+    // First address fails
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertExactCallbackInvokes("onStateChange:CONNECTING");
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertEquals(CONNECTING, internalSubchannel.getState());
+
+    // Second address connecting
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr2),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    assertNoCallbackInvoke();
+    assertEquals(CONNECTING, internalSubchannel.getState());
+
+    // Update addresses
+    internalSubchannel.updateAddresses(
+        Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr2, addr3))));
+    assertNoCallbackInvoke();
+    assertEquals(CONNECTING, internalSubchannel.getState());
+    verify(transports.peek().transport, never()).shutdown(any(Status.class));
+    verify(transports.peek().transport, never()).shutdownNow(any(Status.class));
+
+    // And new addresses chosen when re-connecting
+    transports.peek().listener.transportReady();
+    assertExactCallbackInvokes("onStateChange:READY");
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertExactCallbackInvokes("onStateChange:IDLE");
+
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(mockTransportFactory, times(2))
+        .newClientTransport(
+            eq(addr2),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr3),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    verifyNoMoreInteractions(mockTransportFactory);
+
+    fakeClock.forwardNanos(10); // Drain retry, but don't care about result
+  }
+
+  @Test public void updateAddresses_disjoint_idle() {
+    SocketAddress addr1 = mock(SocketAddress.class);
+    SocketAddress addr2 = mock(SocketAddress.class);
+
+    createInternalSubchannel(addr1);
+    internalSubchannel.updateAddresses(Arrays.asList(new EquivalentAddressGroup(addr2)));
+
+    // Nothing happened on address update
+    verify(mockTransportFactory, never())
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    verify(mockTransportFactory, never())
+        .newClientTransport(
+            eq(addr2),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    verifyNoMoreInteractions(mockTransportFactory);
+    assertNoCallbackInvoke();
+    assertEquals(IDLE, internalSubchannel.getState());
+
+    // But new address chosen when connecting
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertExactCallbackInvokes("onStateChange:CONNECTING");
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr2),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+
+    // And no other addresses attempted
+    assertEquals(0, fakeClock.numPendingTasks());
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertExactCallbackInvokes("onStateChange:" + UNAVAILABLE_STATE);
+    assertEquals(TRANSIENT_FAILURE, internalSubchannel.getState());
+    verifyNoMoreInteractions(mockTransportFactory);
+
+    fakeClock.forwardNanos(10); // Drain retry, but don't care about result
+  }
+
+  @Test public void updateAddresses_disjoint_ready() {
+    SocketAddress addr1 = mock(SocketAddress.class);
+    SocketAddress addr2 = mock(SocketAddress.class);
+    SocketAddress addr3 = mock(SocketAddress.class);
+    SocketAddress addr4 = mock(SocketAddress.class);
+    createInternalSubchannel(addr1, addr2);
+    assertEquals(IDLE, internalSubchannel.getState());
+
+    // First address fails
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertExactCallbackInvokes("onStateChange:CONNECTING");
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertEquals(CONNECTING, internalSubchannel.getState());
+
+    // Second address connects
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr2),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.peek().listener.transportReady();
+    assertExactCallbackInvokes("onStateChange:READY");
+    assertEquals(READY, internalSubchannel.getState());
+
+    // Update addresses
+    internalSubchannel.updateAddresses(
+        Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr3, addr4))));
+    assertExactCallbackInvokes("onStateChange:IDLE");
+    assertEquals(IDLE, internalSubchannel.getState());
+    verify(transports.peek().transport, never()).shutdown(any(Status.class));
+    fakeClock.forwardNanos(
+        TimeUnit.SECONDS.toNanos(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS));
+    verify(transports.peek().transport).shutdown(any(Status.class));
+
+    // And new addresses chosen when re-connecting
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertNoCallbackInvoke();
+    assertEquals(IDLE, internalSubchannel.getState());
+
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr3),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr4),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    verifyNoMoreInteractions(mockTransportFactory);
+
+    fakeClock.forwardNanos(10); // Drain retry, but don't care about result
+  }
+
+  @Test public void updateAddresses_disjoint_connecting() {
+    SocketAddress addr1 = mock(SocketAddress.class);
+    SocketAddress addr2 = mock(SocketAddress.class);
+    SocketAddress addr3 = mock(SocketAddress.class);
+    SocketAddress addr4 = mock(SocketAddress.class);
+    createInternalSubchannel(addr1, addr2);
+    assertEquals(IDLE, internalSubchannel.getState());
+
+    // First address fails
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertExactCallbackInvokes("onStateChange:CONNECTING");
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertEquals(CONNECTING, internalSubchannel.getState());
+
+    // Second address connecting
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr2),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    assertNoCallbackInvoke();
+    assertEquals(CONNECTING, internalSubchannel.getState());
+
+    // Update addresses
+    internalSubchannel.updateAddresses(
+        Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr3, addr4))));
+    assertNoCallbackInvoke();
+    assertEquals(CONNECTING, internalSubchannel.getState());
+
+    // And new addresses chosen immediately
+    verify(transports.poll().transport).shutdown(any(Status.class));
+    assertNoCallbackInvoke();
+    assertEquals(CONNECTING, internalSubchannel.getState());
+
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr3),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr4),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    verifyNoMoreInteractions(mockTransportFactory);
+
+    fakeClock.forwardNanos(10); // Drain retry, but don't care about result
+  }
+
+  @Test public void updateAddresses_disjoint_readyTwice() {
+    SocketAddress addr1 = mock(SocketAddress.class);
+    createInternalSubchannel(addr1);
+    assertEquals(IDLE, internalSubchannel.getState());
+
+    // Address connects
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertExactCallbackInvokes("onStateChange:CONNECTING");
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr1),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.peek().listener.transportReady();
+    assertExactCallbackInvokes("onStateChange:READY");
+    assertEquals(READY, internalSubchannel.getState());
+
+    // Update addresses
+    SocketAddress addr2 = mock(SocketAddress.class);
+    internalSubchannel.updateAddresses(
+        Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr2))));
+    assertExactCallbackInvokes("onStateChange:IDLE");
+    assertEquals(IDLE, internalSubchannel.getState());
+    ConnectionClientTransport firstTransport = transports.poll().transport;
+    verify(firstTransport, never()).shutdown(any(Status.class));
+
+    // Address connects
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertExactCallbackInvokes("onStateChange:CONNECTING");
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr2),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.peek().listener.transportReady();
+    assertExactCallbackInvokes("onStateChange:READY");
+    assertEquals(READY, internalSubchannel.getState());
+
+    // Update addresses
+    SocketAddress addr3 = mock(SocketAddress.class);
+    internalSubchannel.updateAddresses(
+        Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr3))));
+    assertExactCallbackInvokes("onStateChange:IDLE");
+    assertEquals(IDLE, internalSubchannel.getState());
+    // Earlier transport is shutdown eagerly
+    verify(firstTransport).shutdown(any(Status.class));
+    ConnectionClientTransport secondTransport = transports.peek().transport;
+    verify(secondTransport, never()).shutdown(any(Status.class));
+
+    internalSubchannel.shutdown(SHUTDOWN_REASON);
+    verify(secondTransport).shutdown(any(Status.class));
   }
 
   @Test
@@ -391,29 +941,40 @@ public void connectIsLazy() {
 
     // Won't connect until requested
     verify(mockTransportFactory, times(transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
 
     // First attempt
     internalSubchannel.obtainActiveTransport();
     assertExactCallbackInvokes("onStateChange:CONNECTING");
     verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
 
     // Fail this one
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertExactCallbackInvokes("onStateChange:" + UNAVAILABLE_STATE);
 
     // Will always reconnect after back-off
-    fakeClock.forwardMillis(10);
+    fakeClock.forwardNanos(10);
     assertExactCallbackInvokes("onStateChange:CONNECTING");
     verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
 
     // Make this one proceed
     transports.peek().listener.transportReady();
     assertExactCallbackInvokes("onStateChange:READY");
     // Then go-away
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertExactCallbackInvokes("onStateChange:IDLE");
 
     // No scheduled tasks that would ever try to reconnect ...
@@ -424,7 +985,10 @@ public void connectIsLazy() {
     internalSubchannel.obtainActiveTransport();
     assertExactCallbackInvokes("onStateChange:CONNECTING");
     verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
   }
 
   @Test
@@ -437,9 +1001,11 @@ public void shutdownWhenReady() throws Exception {
     transportInfo.listener.transportReady();
     assertExactCallbackInvokes("onStateChange:CONNECTING", "onStateChange:READY");
 
-    internalSubchannel.shutdown();
-    verify(transportInfo.transport).shutdown();
+    internalSubchannel.shutdown(SHUTDOWN_REASON);
+    verify(transportInfo.transport).shutdown(same(SHUTDOWN_REASON));
     assertExactCallbackInvokes("onStateChange:SHUTDOWN");
+    transportInfo.listener.transportShutdown(SHUTDOWN_REASON,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
 
     transportInfo.listener.transportTerminated();
     assertExactCallbackInvokes("onTerminated");
@@ -454,11 +1020,16 @@ public void shutdownBeforeTransportCreated() throws Exception {
     // First transport is created immediately
     internalSubchannel.obtainActiveTransport();
     assertExactCallbackInvokes("onStateChange:CONNECTING");
-    verify(mockTransportFactory).newClientTransport(addr, AUTHORITY, USER_AGENT);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
 
     // Fail this one
     MockClientTransportInfo transportInfo = transports.poll();
-    transportInfo.listener.transportShutdown(Status.UNAVAILABLE);
+    transportInfo.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     transportInfo.listener.transportTerminated();
 
     // Entering TRANSIENT_FAILURE, waiting for back-off
@@ -476,7 +1047,7 @@ public void shutdownBeforeTransportCreated() throws Exception {
     assertNotNull("There should be at least one reconnectTask", reconnectTask);
 
     // Shut down InternalSubchannel before the transport is created.
-    internalSubchannel.shutdown();
+    internalSubchannel.shutdown(SHUTDOWN_REASON);
     assertTrue(reconnectTask.isCancelled());
     // InternalSubchannel terminated promptly.
     assertExactCallbackInvokes("onStateChange:SHUTDOWN", "onTerminated");
@@ -485,14 +1056,14 @@ public void shutdownBeforeTransportCreated() throws Exception {
     // This should not lead to the creation of a new transport.
     reconnectTask.command.run();
 
-    // Futher call to obtainActiveTransport() is no-op.
+    // Further call to obtainActiveTransport() is no-op.
     assertNull(internalSubchannel.obtainActiveTransport());
-    assertEquals(ConnectivityState.SHUTDOWN, internalSubchannel.getState());
+    assertEquals(SHUTDOWN, internalSubchannel.getState());
     assertNoCallbackInvoke();
 
     // No more transports will be created.
-    fakeClock.forwardMillis(10000);
-    assertEquals(ConnectivityState.SHUTDOWN, internalSubchannel.getState());
+    fakeClock.forwardNanos(10000);
+    assertEquals(SHUTDOWN, internalSubchannel.getState());
     verifyNoMoreInteractions(mockTransportFactory);
     assertEquals(0, transports.size());
     assertNoCallbackInvoke();
@@ -509,16 +1080,17 @@ public void shutdownBeforeTransportReady() throws Exception {
 
     // Shutdown the InternalSubchannel before the pending transport is ready
     assertNull(internalSubchannel.obtainActiveTransport());
-    internalSubchannel.shutdown();
+    internalSubchannel.shutdown(SHUTDOWN_REASON);
     assertExactCallbackInvokes("onStateChange:SHUTDOWN");
 
     // The transport should've been shut down even though it's not the active transport yet.
-    verify(transportInfo.transport).shutdown();
-    transportInfo.listener.transportShutdown(Status.UNAVAILABLE);
+    verify(transportInfo.transport).shutdown(same(SHUTDOWN_REASON));
+    transportInfo.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertNoCallbackInvoke();
     transportInfo.listener.transportTerminated();
     assertExactCallbackInvokes("onTerminated");
-    assertEquals(ConnectivityState.SHUTDOWN, internalSubchannel.getState());
+    assertEquals(SHUTDOWN, internalSubchannel.getState());
   }
 
   @Test
@@ -530,7 +1102,7 @@ public void shutdownNow() throws Exception {
     MockClientTransportInfo t1 = transports.poll();
     t1.listener.transportReady();
     assertExactCallbackInvokes("onStateChange:CONNECTING", "onStateChange:READY");
-    t1.listener.transportShutdown(Status.UNAVAILABLE);
+    t1.listener.transportShutdown(Status.UNAVAILABLE, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertExactCallbackInvokes("onStateChange:IDLE");
 
     internalSubchannel.obtainActiveTransport();
@@ -550,13 +1122,17 @@ public void obtainTransportAfterShutdown() throws Exception {
     SocketAddress addr = mock(SocketAddress.class);
     createInternalSubchannel(addr);
 
-    internalSubchannel.shutdown();
+    internalSubchannel.shutdown(SHUTDOWN_REASON);
     assertExactCallbackInvokes("onStateChange:SHUTDOWN", "onTerminated");
-    assertEquals(ConnectivityState.SHUTDOWN, internalSubchannel.getState());
+    assertEquals(SHUTDOWN, internalSubchannel.getState());
     assertNull(internalSubchannel.obtainActiveTransport());
-    verify(mockTransportFactory, times(0)).newClientTransport(addr, AUTHORITY, USER_AGENT);
+    verify(mockTransportFactory, times(0))
+        .newClientTransport(
+            addr,
+            createClientTransportOptions(),
+            internalSubchannel.getChannelLogger());
     assertNoCallbackInvoke();
-    assertEquals(ConnectivityState.SHUTDOWN, internalSubchannel.getState());
+    assertEquals(SHUTDOWN, internalSubchannel.getState());
   }
 
   @Test
@@ -583,7 +1159,7 @@ public void inUseState() {
 
     t0.listener.transportInUse(true);
     assertExactCallbackInvokes("onInUse");
-    t0.listener.transportShutdown(Status.UNAVAILABLE);
+    t0.listener.transportShutdown(Status.UNAVAILABLE, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertExactCallbackInvokes("onStateChange:IDLE");
 
     assertNull(internalSubchannel.obtainActiveTransport());
@@ -616,7 +1192,7 @@ public void transportTerminateWithoutExitingInUse() {
     t0.listener.transportInUse(true);
     assertExactCallbackInvokes("onInUse");
 
-    t0.listener.transportShutdown(Status.UNAVAILABLE);
+    t0.listener.transportShutdown(Status.UNAVAILABLE, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertExactCallbackInvokes("onStateChange:IDLE");
     t0.listener.transportTerminated();
     assertExactCallbackInvokes("onNotInUse");
@@ -643,17 +1219,17 @@ public void run() {
     assertEquals(1, runnableInvokes.get());
 
     MockClientTransportInfo t0 = transports.poll();
-    t0.listener.transportShutdown(Status.UNAVAILABLE);
+    t0.listener.transportShutdown(Status.UNAVAILABLE, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     assertEquals(2, runnableInvokes.get());
 
     // 2nd address: reconnect immediatly
     MockClientTransportInfo t1 = transports.poll();
-    t1.listener.transportShutdown(Status.UNAVAILABLE);
+    t1.listener.transportShutdown(Status.UNAVAILABLE, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
 
     // Addresses exhausted, waiting for back-off.
     assertEquals(2, runnableInvokes.get());
     // Run out the back-off period
-    fakeClock.forwardMillis(10);
+    fakeClock.forwardNanos(10);
     assertEquals(3, runnableInvokes.get());
 
     // This test doesn't care about scheduled InternalSubchannel callbacks.  Clear it up so that
@@ -662,11 +1238,397 @@ public void run() {
     assertEquals(3, runnableInvokes.get());
   }
 
+  @Test
+  public void resetConnectBackoff() throws Exception {
+    SocketAddress addr = mock(SocketAddress.class);
+    createInternalSubchannel(addr);
+
+    // Move into TRANSIENT_FAILURE to schedule reconnect
+    internalSubchannel.obtainActiveTransport();
+    assertExactCallbackInvokes("onStateChange:CONNECTING");
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertExactCallbackInvokes("onStateChange:" + UNAVAILABLE_STATE);
+
+    // Save the reconnectTask
+    FakeClock.ScheduledTask reconnectTask = null;
+    for (FakeClock.ScheduledTask task : fakeClock.getPendingTasks()) {
+      if (task.command.toString().contains("EndOfCurrentBackoff")) {
+        assertNull("There shouldn't be more than one reconnectTask", reconnectTask);
+        assertFalse(task.isDone());
+        reconnectTask = task;
+      }
+    }
+    assertNotNull("There should be at least one reconnectTask", reconnectTask);
+
+    internalSubchannel.resetConnectBackoff();
+
+    verify(mockTransportFactory, times(2))
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    assertExactCallbackInvokes("onStateChange:CONNECTING");
+    assertTrue(reconnectTask.isCancelled());
+
+    // Simulate a race between cancel and the task scheduler. Should be a no-op.
+    reconnectTask.command.run();
+    assertNoCallbackInvoke();
+    verify(mockTransportFactory, times(2))
+        .newClientTransport(
+            eq(addr),
+            eq(createClientTransportOptions()),
+            isA(TransportLogger.class));
+    verify(mockBackoffPolicyProvider, times(1)).get();
+
+    // Fail the reconnect attempt to verify that a fresh reconnect policy is generated after
+    // invoking resetConnectBackoff()
+    transports.poll().listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertExactCallbackInvokes("onStateChange:" + UNAVAILABLE_STATE);
+    verify(mockBackoffPolicyProvider, times(2)).get();
+    fakeClock.forwardNanos(10);
+    assertExactCallbackInvokes("onStateChange:CONNECTING");
+    assertEquals(CONNECTING, internalSubchannel.getState());
+  }
+
+  @Test
+  public void resetConnectBackoff_noopOnIdleTransport() throws Exception {
+    SocketAddress addr = mock(SocketAddress.class);
+    createInternalSubchannel(addr);
+    assertEquals(IDLE, internalSubchannel.getState());
+
+    internalSubchannel.resetConnectBackoff();
+
+    assertNoCallbackInvoke();
+  }
+
+  @Test
+  public void channelzMembership() throws Exception {
+    SocketAddress addr1 = mock(SocketAddress.class);
+    createInternalSubchannel(addr1);
+    internalSubchannel.obtainActiveTransport();
+
+    MockClientTransportInfo t0 = transports.poll();
+    t0.listener.transportReady();
+    assertTrue(channelz.containsClientSocket(t0.transport.getLogId()));
+    t0.listener.transportShutdown(Status.RESOURCE_EXHAUSTED,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    t0.listener.transportTerminated();
+    assertFalse(channelz.containsClientSocket(t0.transport.getLogId()));
+  }
+
+  @Test
+  public void channelzStatContainsTransport() throws Exception {
+    SocketAddress addr = new SocketAddress() {};
+    assertThat(transports).isEmpty();
+    createInternalSubchannel(addr);
+    internalSubchannel.obtainActiveTransport();
+
+    InternalWithLogId registeredTransport
+        = Iterables.getOnlyElement(internalSubchannel.getStats().get().sockets);
+    MockClientTransportInfo actualTransport = Iterables.getOnlyElement(transports);
+    assertEquals(actualTransport.transport.getLogId(), registeredTransport.getLogId());
+  }
+
+  @Test public void index_looping() {
+    Attributes.Key<String> key = Attributes.Key.create("some-key");
+    Attributes attr1 = Attributes.newBuilder().set(key, "1").build();
+    Attributes attr2 = Attributes.newBuilder().set(key, "2").build();
+    Attributes attr3 = Attributes.newBuilder().set(key, "3").build();
+    SocketAddress addr1 = new FakeSocketAddress();
+    SocketAddress addr2 = new FakeSocketAddress();
+    SocketAddress addr3 = new FakeSocketAddress();
+    SocketAddress addr4 = new FakeSocketAddress();
+    SocketAddress addr5 = new FakeSocketAddress();
+    Index index = new Index(Arrays.asList(
+        new EquivalentAddressGroup(Arrays.asList(addr1, addr2), attr1),
+        new EquivalentAddressGroup(Arrays.asList(addr3), attr2),
+        new EquivalentAddressGroup(Arrays.asList(addr4, addr5), attr3)));
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);
+    assertThat(index.isAtBeginning()).isTrue();
+    assertThat(index.isValid()).isTrue();
+
+    index.increment();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr2);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);
+    assertThat(index.isAtBeginning()).isFalse();
+    assertThat(index.isValid()).isTrue();
+
+    index.increment();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr3);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr2);
+    assertThat(index.isAtBeginning()).isFalse();
+    assertThat(index.isValid()).isTrue();
+
+    index.increment();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr4);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr3);
+    assertThat(index.isAtBeginning()).isFalse();
+    assertThat(index.isValid()).isTrue();
+
+    index.increment();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr5);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr3);
+    assertThat(index.isAtBeginning()).isFalse();
+    assertThat(index.isValid()).isTrue();
+
+    index.increment();
+    assertThat(index.isAtBeginning()).isFalse();
+    assertThat(index.isValid()).isFalse();
+
+    index.reset();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);
+    assertThat(index.isAtBeginning()).isTrue();
+    assertThat(index.isValid()).isTrue();
+
+    // We want to make sure both groupIndex and addressIndex are reset
+    index.increment();
+    index.increment();
+    index.increment();
+    index.increment();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr5);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr3);
+    index.reset();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);
+  }
+
+  @Test public void index_updateGroups_resets() {
+    SocketAddress addr1 = new FakeSocketAddress();
+    SocketAddress addr2 = new FakeSocketAddress();
+    SocketAddress addr3 = new FakeSocketAddress();
+    Index index = new Index(Arrays.asList(
+        new EquivalentAddressGroup(Arrays.asList(addr1)),
+        new EquivalentAddressGroup(Arrays.asList(addr2, addr3))));
+    index.increment();
+    index.increment();
+    // We want to make sure both groupIndex and addressIndex are reset
+    index.updateGroups(Arrays.asList(
+        new EquivalentAddressGroup(Arrays.asList(addr1)),
+        new EquivalentAddressGroup(Arrays.asList(addr2, addr3))));
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
+  }
+
+  @Test public void index_seekTo() {
+    SocketAddress addr1 = new FakeSocketAddress();
+    SocketAddress addr2 = new FakeSocketAddress();
+    SocketAddress addr3 = new FakeSocketAddress();
+    Index index = new Index(Arrays.asList(
+        new EquivalentAddressGroup(Arrays.asList(addr1, addr2)),
+        new EquivalentAddressGroup(Arrays.asList(addr3))));
+    assertThat(index.seekTo(addr3)).isTrue();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr3);
+    assertThat(index.seekTo(addr1)).isTrue();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
+    assertThat(index.seekTo(addr2)).isTrue();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr2);
+    index.seekTo(new FakeSocketAddress());
+    // Failed seekTo doesn't change the index
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr2);
+  }
+
+  @Test
+  public void connectedAddressAttributes_ready() {
+    SocketAddress addr = new SocketAddress() {};
+    Attributes attr = Attributes.newBuilder().set(Attributes.Key.create("some-key"), "1").build();
+    createInternalSubchannel(new EquivalentAddressGroup(Arrays.asList(addr), attr));
+
+    assertEquals(IDLE, internalSubchannel.getState());
+    assertNoCallbackInvoke();
+    assertNull(internalSubchannel.obtainActiveTransport());
+    assertNull(internalSubchannel.getConnectedAddressAttributes());
+
+    assertExactCallbackInvokes("onStateChange:CONNECTING");
+    assertEquals(CONNECTING, internalSubchannel.getState());
+    verify(mockTransportFactory).newClientTransport(
+        eq(addr),
+        eq(createClientTransportOptions().setEagAttributes(attr)),
+        isA(TransportLogger.class));
+    assertNull(internalSubchannel.getConnectedAddressAttributes());
+
+    internalSubchannel.obtainActiveTransport();
+    transports.peek().listener.transportReady();
+    assertExactCallbackInvokes("onStateChange:READY");
+    assertEquals(READY, internalSubchannel.getState());
+    assertEquals(attr, internalSubchannel.getConnectedAddressAttributes());
+  }
+
+  /** Create ClientTransportOptions. Should not be reused if it may be mutated. */
+  private ClientTransportFactory.ClientTransportOptions createClientTransportOptions() {
+    return new ClientTransportFactory.ClientTransportOptions()
+        .setAuthority(AUTHORITY)
+        .setUserAgent(USER_AGENT);
+  }
+
   private void createInternalSubchannel(SocketAddress ... addrs) {
-    addressGroup = new EquivalentAddressGroup(Arrays.asList(addrs));
-    internalSubchannel = new InternalSubchannel(addressGroup, AUTHORITY, USER_AGENT,
+    createInternalSubchannel(new EquivalentAddressGroup(Arrays.asList(addrs)));
+  }
+
+  private void createInternalSubchannel(EquivalentAddressGroup ... addrs) {
+    createInternalSubchannel(false, addrs);
+  }
+
+  private void createInternalSubchannel(boolean reconnectDisabled,
+                                        EquivalentAddressGroup ... addrs) {
+    List<EquivalentAddressGroup> addressGroups = Arrays.asList(addrs);
+    InternalLogId logId = InternalLogId.allocate("Subchannel", /*details=*/ AUTHORITY);
+    ChannelTracer subchannelTracer = new ChannelTracer(logId, 10,
+        fakeClock.getTimeProvider().currentTimeNanos(), "Subchannel");
+    LoadBalancer.CreateSubchannelArgs.Builder argBuilder =
+        LoadBalancer.CreateSubchannelArgs.newBuilder().setAddresses(addressGroups);
+    if (reconnectDisabled) {
+      argBuilder.addOption(LoadBalancer.DISABLE_SUBCHANNEL_RECONNECT_KEY, reconnectDisabled);
+    }
+    LoadBalancer.CreateSubchannelArgs createSubchannelArgs = argBuilder.build();
+    internalSubchannel = new InternalSubchannel(
+        createSubchannelArgs,
+        AUTHORITY, USER_AGENT,
         mockBackoffPolicyProvider, mockTransportFactory, fakeClock.getScheduledExecutorService(),
-        fakeClock.getStopwatchSupplier(), channelExecutor, mockInternalSubchannelCallback);
+        fakeClock.getStopwatchSupplier(), syncContext, mockInternalSubchannelCallback,
+        channelz, CallTracer.getDefaultFactory().create(),
+        subchannelTracer,
+        logId,
+        new ChannelLoggerImpl(subchannelTracer, fakeClock.getTimeProvider()),
+        Collections.emptyList(),
+        "",
+        new MetricRecorder() {
+        }
+    );
+  }
+
+  @Test
+  public void subchannelStateChanges_triggersAttemptFailedMetric() {
+    // 1. Setup: Standard subchannel initialization
+    when(mockBackoffPolicyProvider.get()).thenReturn(mockBackoffPolicy);
+    SocketAddress addr = mock(SocketAddress.class);
+    Attributes eagAttributes = Attributes.newBuilder()
+        .set(NameResolver.ATTR_BACKEND_SERVICE, BACKEND_SERVICE)
+        .set(EquivalentAddressGroup.ATTR_LOCALITY_NAME, LOCALITY)
+        .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SECURITY_LEVEL)
+        .build();
+    List<EquivalentAddressGroup> addressGroups =
+        Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr), eagAttributes));
+    InternalLogId logId = InternalLogId.allocate("Subchannel", /*details=*/ AUTHORITY);
+    ChannelTracer subchannelTracer = new ChannelTracer(logId, 10,
+        fakeClock.getTimeProvider().currentTimeNanos(), "Subchannel");
+    LoadBalancer.CreateSubchannelArgs createSubchannelArgs =
+        LoadBalancer.CreateSubchannelArgs.newBuilder().setAddresses(addressGroups).build();
+    internalSubchannel = new InternalSubchannel(
+        createSubchannelArgs, AUTHORITY, USER_AGENT, mockBackoffPolicyProvider,
+        mockTransportFactory, fakeClock.getScheduledExecutorService(),
+        fakeClock.getStopwatchSupplier(), syncContext, mockInternalSubchannelCallback, channelz,
+        CallTracer.getDefaultFactory().create(), subchannelTracer, logId,
+        new ChannelLoggerImpl(subchannelTracer, fakeClock.getTimeProvider()),
+        Collections.emptyList(), AUTHORITY, mockMetricRecorder
+    );
+
+    // --- Action: Simulate the "connecting to failed" transition ---
+    // a. Initiate the connection attempt. The subchannel is now CONNECTING.
+    internalSubchannel.obtainActiveTransport();
+    MockClientTransportInfo transportInfo = transports.poll();
+    assertNotNull("A connection attempt should have been made", transportInfo);
+
+    // b. Fail the transport before it can signal `transportReady()`.
+    transportInfo.listener.transportShutdown(
+        Status.INTERNAL.withDescription("Simulated connect failure"),
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    fakeClock.runDueTasks(); // Process the failure event
+
+    // --- Verification ---
+    // a. Verify that the "connection_attempts_failed" metric was recorded exactly once.
+    verify(mockMetricRecorder).addLongCounter(
+        eqMetricInstrumentName("grpc.subchannel.connection_attempts_failed"),
+        eq(1L),
+        eq(Arrays.asList(AUTHORITY)),
+        eq(Arrays.asList(BACKEND_SERVICE, LOCALITY))
+    );
+
+    // b. Verify no other metrics were recorded. This confirms it wasn't incorrectly
+    //    logged as a success, disconnection, or open connection.
+    verifyNoMoreInteractions(mockMetricRecorder);
+  }
+
+  @Test
+  public void subchannelStateChanges_triggersSuccessAndDisconnectMetrics() {
+    // 1. Mock the backoff policy (needed for subchannel creation)
+    when(mockBackoffPolicyProvider.get()).thenReturn(mockBackoffPolicy);
+
+    // 2. Setup Subchannel with attributes
+    SocketAddress addr = mock(SocketAddress.class);
+    Attributes eagAttributes = Attributes.newBuilder()
+        .set(NameResolver.ATTR_BACKEND_SERVICE, BACKEND_SERVICE)
+        .set(EquivalentAddressGroup.ATTR_LOCALITY_NAME, LOCALITY)
+        .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SECURITY_LEVEL)
+        .build();
+    List<EquivalentAddressGroup> addressGroups =
+        Arrays.asList(new EquivalentAddressGroup(Arrays.asList(addr), eagAttributes));
+    createInternalSubchannel(new EquivalentAddressGroup(addr));
+    InternalLogId logId = InternalLogId.allocate("Subchannel", /*details=*/ AUTHORITY);
+    ChannelTracer subchannelTracer = new ChannelTracer(logId, 10,
+        fakeClock.getTimeProvider().currentTimeNanos(), "Subchannel");
+    LoadBalancer.CreateSubchannelArgs createSubchannelArgs =
+        LoadBalancer.CreateSubchannelArgs.newBuilder().setAddresses(addressGroups).build();
+    internalSubchannel = new InternalSubchannel(
+        createSubchannelArgs, AUTHORITY, USER_AGENT, mockBackoffPolicyProvider,
+        mockTransportFactory, fakeClock.getScheduledExecutorService(),
+        fakeClock.getStopwatchSupplier(), syncContext, mockInternalSubchannelCallback, channelz,
+        CallTracer.getDefaultFactory().create(), subchannelTracer, logId,
+        new ChannelLoggerImpl(subchannelTracer, fakeClock.getTimeProvider()),
+        Collections.emptyList(), AUTHORITY, mockMetricRecorder
+    );
+
+    // --- Action: Successful connection ---
+    internalSubchannel.obtainActiveTransport();
+    MockClientTransportInfo transportInfo = transports.poll();
+    assertNotNull(transportInfo);
+    transportInfo.listener.transportReady();
+    fakeClock.runDueTasks(); // Process the successful connection
+
+    // --- Action: Transport is shut down ---
+    transportInfo.listener.transportShutdown(Status.UNAVAILABLE.withDescription("unknown"),
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    fakeClock.runDueTasks(); // Process the shutdown
+
+    // --- Verification ---
+    InOrder inOrder = inOrder(mockMetricRecorder);
+
+    // Verify successful connection metrics
+    inOrder.verify(mockMetricRecorder).addLongCounter(
+        eqMetricInstrumentName("grpc.subchannel.connection_attempts_succeeded"),
+        eq(1L),
+        eq(Arrays.asList(AUTHORITY)),
+        eq(Arrays.asList(BACKEND_SERVICE, LOCALITY))
+    );
+    inOrder.verify(mockMetricRecorder).addLongUpDownCounter(
+        eqMetricInstrumentName("grpc.subchannel.open_connections"),
+        eq(1L),
+        eq(Arrays.asList(AUTHORITY)),
+        eq(Arrays.asList("privacy_and_integrity", BACKEND_SERVICE, LOCALITY))
+    );
+
+    // Verify disconnection metrics
+    inOrder.verify(mockMetricRecorder).addLongCounter(
+        eqMetricInstrumentName("grpc.subchannel.disconnections"),
+        eq(1L),
+        eq(Arrays.asList(AUTHORITY)),
+        eq(Arrays.asList(BACKEND_SERVICE, LOCALITY, "subchannel shutdown"))
+    );
+    inOrder.verify(mockMetricRecorder).addLongUpDownCounter(
+        eqMetricInstrumentName("grpc.subchannel.open_connections"),
+        eq(-1L),
+        eq(Arrays.asList(AUTHORITY)),
+        eq(Arrays.asList("privacy_and_integrity", BACKEND_SERVICE, LOCALITY))
+    );
+
+    inOrder.verifyNoMoreInteractions();
   }
 
   private void assertNoCallbackInvoke() {
@@ -675,8 +1637,17 @@ private void assertNoCallbackInvoke() {
   }
 
   private void assertExactCallbackInvokes(String ... expectedInvokes) {
-    assertEquals(0, channelExecutor.numPendingTasks());
     assertEquals(Arrays.asList(expectedInvokes), callbackInvokes);
     callbackInvokes.clear();
   }
+
+  static class MetricRecorderImpl implements MetricRecorder {
+  }
+
+  @SuppressWarnings("TypeParameterUnusedInFormals")
+  private <T extends MetricInstrument> T eqMetricInstrumentName(String name) {
+    return argThat(instrument -> instrument.getName().equals(name));
+  }
+
+  private static class FakeSocketAddress extends SocketAddress {}
 }
diff --git a/core/src/test/java/io/grpc/internal/IoUtilsTest.java b/core/src/test/java/io/grpc/internal/IoUtilsTest.java
deleted file mode 100644
index 527c7b6da5a..00000000000
--- a/core/src/test/java/io/grpc/internal/IoUtilsTest.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotSame;
-
-import java.io.ByteArrayInputStream;
-import java.io.InputStream;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit test for IoUtils. */
-@RunWith(JUnit4.class)
-public class IoUtilsTest {
-
-  @Test
-  public void testRoundTrip() throws Exception {
-    byte[] bytes = { 1, 2, 3, -127, 100, 127};
-    InputStream is = new ByteArrayInputStream(bytes);
-    byte[] bytes2 = IoUtils.toByteArray(is);
-    
-    assertNotSame(bytes2, bytes);
-    assertEquals(bytes.length, bytes2.length);
-    for (int i = 0; i < bytes.length; ++i) {
-      assertEquals(bytes[i], bytes2[i]);
-    }
-  }
-
-  @Test
-  public void testEmpty() throws Exception {
-    InputStream is = new ByteArrayInputStream(new byte[0]);
-    byte[] bytes = IoUtils.toByteArray(is);
-
-    assertEquals(0, bytes.length);
-  }
-}
\ No newline at end of file
diff --git a/core/src/test/java/io/grpc/internal/JndiResourceResolverTest.java b/core/src/test/java/io/grpc/internal/JndiResourceResolverTest.java
new file mode 100644
index 00000000000..dd8d34494c0
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/JndiResourceResolverTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import io.grpc.internal.DnsNameResolver.SrvRecord;
+import io.grpc.internal.JndiResourceResolverFactory.JndiRecordFetcher;
+import io.grpc.internal.JndiResourceResolverFactory.JndiResourceResolver;
+import io.grpc.internal.JndiResourceResolverFactory.RecordFetcher;
+import java.util.Arrays;
+import java.util.List;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link JndiResourceResolverFactory}.
+ */
+@RunWith(JUnit4.class)
+public class JndiResourceResolverTest {
+
+  @Test
+  public void normalizeDataRemovesJndiFormattingForTxtRecords() {
+    assertEquals("blah", JndiResourceResolver.unquote("blah"));
+    assertEquals("", JndiResourceResolver.unquote("\"\""));
+    assertEquals("blahblah", JndiResourceResolver.unquote("blah blah"));
+    assertEquals("blahfoo blah", JndiResourceResolver.unquote("blah \"foo blah\""));
+    assertEquals("blah blah", JndiResourceResolver.unquote("\"blah blah\""));
+    assertEquals("blah\"blah", JndiResourceResolver.unquote("\"blah\\\"blah\""));
+    assertEquals("blah\\blah", JndiResourceResolver.unquote("\"blah\\\\blah\""));
+  }
+
+  @IgnoreJRERequirement
+  @Test
+  public void jndiResolverWorks() throws Exception {
+    Assume.assumeNoException(new JndiResourceResolverFactory().unavailabilityCause());
+
+    RecordFetcher recordFetcher = new JndiRecordFetcher();
+    try {
+      recordFetcher.getAllRecords("SRV", "dns:///localhost");
+    } catch (javax.naming.CommunicationException e) {
+      Assume.assumeNoException(e);
+    } catch (javax.naming.NameNotFoundException e) {
+      Assume.assumeNoException(e);
+    }
+  }
+
+  @Test
+  public void txtRecordLookup() throws Exception {
+    RecordFetcher recordFetcher = mock(RecordFetcher.class);
+    when(recordFetcher.getAllRecords("TXT", "dns:///service.example.com"))
+        .thenReturn(Arrays.asList("foo", "\"bar\""));
+
+    List<String> golden = Arrays.asList("foo", "bar");
+    JndiResourceResolver resolver = new JndiResourceResolver(recordFetcher);
+    assertThat(resolver.resolveTxt("service.example.com")).isEqualTo(golden);
+  }
+
+  @SuppressWarnings("deprecation")
+  @Test
+  public void srvRecordLookup() throws Exception {
+    RecordFetcher recordFetcher = mock(RecordFetcher.class);
+    when(recordFetcher.getAllRecords("SRV", "dns:///service.example.com"))
+        .thenReturn(Arrays.asList(
+            "0 0 314 foo.example.com.", "0 0 42 bar.example.com.", "0 0 1 discard.example.com"));
+
+    List<SrvRecord> golden = Arrays.asList(
+        new SrvRecord("foo.example.com.", 314),
+        new SrvRecord("bar.example.com.", 42));
+    JndiResourceResolver resolver = new JndiResourceResolver(recordFetcher);
+    assertThat(resolver.resolveSrv("service.example.com")).isEqualTo(golden);
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/JsonParserTest.java b/core/src/test/java/io/grpc/internal/JsonParserTest.java
new file mode 100644
index 00000000000..a0dd81c20ce
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/JsonParserTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+
+import com.google.gson.stream.MalformedJsonException;
+import java.io.EOFException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link JsonParser}.
+ */
+@RunWith(JUnit4.class)
+public class JsonParserTest {
+
+  @Test
+  public void emptyObject() throws IOException {
+    assertEquals(new LinkedHashMap<String, Object>(), JsonParser.parse("{}"));
+  }
+
+  @Test
+  public void emptyArray() throws IOException {
+    assertEquals(new ArrayList<>(), JsonParser.parse("[]"));
+  }
+
+  @Test
+  public void intNumber() throws IOException {
+    assertEquals(Double.valueOf("1"), JsonParser.parse("1"));
+  }
+
+  @Test
+  public void doubleNumber() throws IOException {
+    assertEquals(Double.valueOf("1.2"), JsonParser.parse("1.2"));
+  }
+
+  @Test
+  public void longNumber() throws IOException {
+    assertEquals(Double.valueOf("9999999999"), JsonParser.parse("9999999999"));
+  }
+
+  @Test
+  public void booleanValue() throws IOException {
+    assertEquals(true, JsonParser.parse("true"));
+  }
+
+  @Test
+  public void nullValue() throws IOException {
+    assertEquals(null, JsonParser.parse("null"));
+  }
+
+  @Test
+  public void nanFails() {
+    assertThrows(MalformedJsonException.class, () -> JsonParser.parse("NaN"));
+  }
+
+  @Test
+  public void objectEarlyEnd() {
+    assertThrows(MalformedJsonException.class, () -> JsonParser.parse("{foo:}"));
+  }
+
+  @Test
+  public void earlyEndArray() {
+    assertThrows(EOFException.class, () -> JsonParser.parse("[1, 2, "));
+  }
+
+  @Test
+  public void arrayMissingElement() {
+    assertThrows(MalformedJsonException.class, () -> JsonParser.parse("[1, 2, ]"));
+  }
+
+  @Test
+  public void objectMissingElement() {
+    assertThrows(MalformedJsonException.class, () -> JsonParser.parse("{1: "));
+  }
+
+  @Test
+  public void objectNoName() {
+    assertThrows(MalformedJsonException.class, () -> JsonParser.parse("{: 1"));
+  }
+
+  @Test
+  public void objectStringName() throws IOException {
+    LinkedHashMap<String, Object> expected = new LinkedHashMap<>();
+    expected.put("hi", Double.valueOf("2"));
+
+    assertEquals(expected, JsonParser.parse("{\"hi\": 2}"));
+  }
+
+  @Test
+  public void duplicate() {
+    assertThrows(IllegalArgumentException.class, () -> JsonParser.parse("{\"hi\": 2, \"hi\": 3}"));
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/JsonUtilTest.java b/core/src/test/java/io/grpc/internal/JsonUtilTest.java
new file mode 100644
index 00000000000..058171814ea
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/JsonUtilTest.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright 2021, gRPC Authors All rights reserved.
+ *
+ * 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link JsonUtil}. */
+@RunWith(JUnit4.class)
+public class JsonUtilTest {
+  @Test
+  public void getNumber() {
+    Map<String, Object> map = new HashMap<>();
+    map.put("key_number_1", 1D);
+    map.put("key_string_2.0", "2.0");
+    map.put("key_string_3", "3");
+    map.put("key_string_nan", "NaN");
+    map.put("key_number_5.5", 5.5D);
+    map.put("key_string_six", "six");
+    map.put("key_number_7", 7F);
+    map.put("key_string_infinity", "Infinity");
+    map.put("key_string_minus_infinity", "-Infinity");
+    map.put("key_string_exponent", "2.998e8");
+    map.put("key_string_minus_zero", "-0");
+    map.put("key_string_boolean", true);
+
+    assertThat(JsonUtil.getNumberAsDouble(map, "key_number_1")).isEqualTo(1D);
+    assertThat(JsonUtil.getNumberAsInteger(map, "key_number_1")).isEqualTo(1);
+    assertThat(JsonUtil.getNumberAsLong(map, "key_number_1")).isEqualTo(1L);
+
+    assertThat(JsonUtil.getNumberAsDouble(map, "key_string_2.0")).isEqualTo(2D);
+    assertThat(JsonUtil.getNumberAsFloat(map, "key_string_2.0")).isEqualTo(2F);
+    try {
+      JsonUtil.getNumberAsInteger(map, "key_string_2.0");
+      fail("expecting to throw but did not");
+    } catch (RuntimeException e) {
+      assertThat(e).hasMessageThat().isEqualTo(
+          "value '2.0' for key 'key_string_2.0' is not an integer");
+    }
+    try {
+      JsonUtil.getNumberAsLong(map, "key_string_2.0");
+      fail("expecting to throw but did not");
+    } catch (RuntimeException e) {
+      assertThat(e).hasMessageThat().isEqualTo(
+          "value '2.0' for key 'key_string_2.0' is not a long integer");
+    }
+
+    assertThat(JsonUtil.getNumberAsDouble(map, "key_string_3")).isEqualTo(3D);
+    assertThat(JsonUtil.getNumberAsInteger(map, "key_string_3")).isEqualTo(3);
+    assertThat(JsonUtil.getNumberAsLong(map, "key_string_3")).isEqualTo(3L);
+    assertThat(JsonUtil.getNumberAsFloat(map, "key_string_3")).isEqualTo(3F);
+
+    assertThat(JsonUtil.getNumberAsDouble(map, "key_string_nan")).isNaN();
+    assertThat(JsonUtil.getNumberAsFloat(map, "key_string_nan")).isNaN();
+    try {
+      JsonUtil.getNumberAsInteger(map, "key_string_nan");
+      fail("expecting to throw but did not");
+    } catch (RuntimeException e) {
+      assertThat(e).hasMessageThat().isEqualTo(
+          "value 'NaN' for key 'key_string_nan' is not an integer");
+    }
+    try {
+      JsonUtil.getNumberAsLong(map, "key_string_nan");
+      fail("expecting to throw but did not");
+    } catch (RuntimeException e) {
+      assertThat(e).hasMessageThat().isEqualTo(
+          "value 'NaN' for key 'key_string_nan' is not a long integer");
+    }
+
+    assertThat(JsonUtil.getNumberAsDouble(map, "key_number_5.5")).isEqualTo(5.5D);
+    try {
+      JsonUtil.getNumberAsInteger(map, "key_number_5.5");
+      fail("expecting to throw but did not");
+    } catch (RuntimeException e) {
+      assertThat(e).hasMessageThat().isEqualTo("Number expected to be integer: 5.5");
+    }
+    try {
+      JsonUtil.getNumberAsLong(map, "key_number_5.5");
+      fail("expecting to throw but did not");
+    } catch (RuntimeException e) {
+      assertThat(e).hasMessageThat().isEqualTo("Number expected to be long: 5.5");
+    }
+
+    try {
+      JsonUtil.getNumberAsDouble(map, "key_string_six");
+      fail("expecting to throw but did not");
+    } catch (RuntimeException e) {
+      assertThat(e).hasMessageThat().isEqualTo(
+          "value 'six' for key 'key_string_six' is not a double");
+    }
+    try {
+      JsonUtil.getNumberAsInteger(map, "key_string_six");
+      fail("expecting to throw but did not");
+    } catch (RuntimeException e) {
+      assertThat(e).hasMessageThat().isEqualTo(
+          "value 'six' for key 'key_string_six' is not an integer");
+    }
+    try {
+      JsonUtil.getNumberAsLong(map, "key_string_six");
+      fail("expecting to throw but did not");
+    } catch (RuntimeException e) {
+      assertThat(e).hasMessageThat().isEqualTo(
+          "value 'six' for key 'key_string_six' is not a long integer");
+    }
+    try {
+      JsonUtil.getNumberAsFloat(map, "key_string_six");
+      fail("expecting to throw but did not");
+    } catch (RuntimeException e) {
+      assertThat(e).hasMessageThat().isEqualTo(
+          "string value 'six' for key 'key_string_six' cannot be parsed as a float");
+    }
+
+    assertThat(JsonUtil.getNumberAsFloat(map, "key_number_7")).isEqualTo(7F);
+
+    assertThat(JsonUtil.getNumberAsDouble(map, "key_string_infinity")).isPositiveInfinity();
+    assertThat(JsonUtil.getNumberAsDouble(map, "key_string_minus_infinity")).isNegativeInfinity();
+    assertThat(JsonUtil.getNumberAsDouble(map, "key_string_exponent")).isEqualTo(2.998e8D);
+
+    assertThat(JsonUtil.getNumberAsFloat(map, "key_string_infinity")).isPositiveInfinity();
+    assertThat(JsonUtil.getNumberAsFloat(map, "key_string_minus_infinity")).isNegativeInfinity();
+    assertThat(JsonUtil.getNumberAsFloat(map, "key_string_exponent")).isEqualTo(2.998e8F);
+
+    assertThat(JsonUtil.getNumberAsDouble(map, "key_string_minus_zero")).isZero();
+    assertThat(JsonUtil.getNumberAsInteger(map, "key_string_minus_zero")).isEqualTo(0);
+    assertThat(JsonUtil.getNumberAsLong(map, "key_string_minus_zero")).isEqualTo(0L);
+    assertThat(JsonUtil.getNumberAsFloat(map, "key_string_minus_zero")).isZero();
+
+    assertThat(JsonUtil.getNumberAsDouble(map, "key_nonexistent")).isNull();
+    assertThat(JsonUtil.getNumberAsInteger(map, "key_nonexistent")).isNull();
+    assertThat(JsonUtil.getNumberAsLong(map, "key_nonexistent")).isNull();
+    assertThat(JsonUtil.getNumberAsFloat(map, "key_nonexistent")).isNull();
+
+    try {
+      JsonUtil.getNumberAsFloat(map, "key_string_boolean");
+      fail("expecting to throw but did not");
+    } catch (RuntimeException e) {
+      assertThat(e).hasMessageThat().isEqualTo(
+          "value true for key 'key_string_boolean' is not a float");
+    }
+  }
+
+  @Test
+  public void getObject_mapExplicitNullValue() {
+    Map<String, ?> mapWithNullValue = Collections.singletonMap("key", null);
+    try {
+      JsonUtil.getObject(mapWithNullValue, "key");
+      fail("ClassCastException expected");
+    } catch (ClassCastException e) {
+      assertThat(e).hasMessageThat()
+          .isEqualTo("value 'null' for key 'key' in '{key=null}' is not object");
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/KeepAliveEnforcerTest.java b/core/src/test/java/io/grpc/internal/KeepAliveEnforcerTest.java
new file mode 100644
index 00000000000..c58ed6ea160
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/KeepAliveEnforcerTest.java
@@ -0,0 +1,214 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link KeepAliveEnforcer}. */
+@RunWith(JUnit4.class)
+public class KeepAliveEnforcerTest {
+  private static final int LARGE_NUMBER = KeepAliveEnforcer.MAX_PING_STRIKES * 5;
+
+  private FakeTicker ticker = new FakeTicker();
+
+  @Test(expected = IllegalArgumentException.class)
+  public void negativeTime() {
+    KeepAliveEnforcer unused = new KeepAliveEnforcer(true, -1, TimeUnit.NANOSECONDS);
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void nullTimeUnit() {
+    KeepAliveEnforcer unused = new KeepAliveEnforcer(true, 1, null);
+  }
+
+  @Test
+  public void permitLimitless() {
+    KeepAliveEnforcer enforcer = new KeepAliveEnforcer(true, 0, TimeUnit.NANOSECONDS, ticker);
+    for (int i = 0; i < LARGE_NUMBER; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+    }
+    enforcer.onTransportActive();
+    for (int i = 0; i < LARGE_NUMBER; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+    }
+    enforcer.onTransportIdle();
+    for (int i = 0; i < LARGE_NUMBER; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+    }
+    enforcer.resetCounters();
+    for (int i = 0; i < LARGE_NUMBER; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+    }
+  }
+
+  @Test
+  public void strikeOutBecauseNoOutstandingCalls() {
+    KeepAliveEnforcer enforcer = new KeepAliveEnforcer(false, 0, TimeUnit.NANOSECONDS, ticker);
+    enforcer.onTransportIdle();
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+    }
+    assertThat(enforcer.pingAcceptable()).isFalse();
+  }
+
+  @Test
+  public void startsIdle() {
+    KeepAliveEnforcer enforcer = new KeepAliveEnforcer(false, 0, TimeUnit.NANOSECONDS, ticker);
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+    }
+    assertThat(enforcer.pingAcceptable()).isFalse();
+  }
+
+  @Test
+  public void strikeOutBecauseRateTooHighWhileActive() {
+    KeepAliveEnforcer enforcer = new KeepAliveEnforcer(true, 1, TimeUnit.NANOSECONDS, ticker);
+    enforcer.onTransportActive();
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+    }
+    assertThat(enforcer.pingAcceptable()).isFalse();
+  }
+
+  @Test
+  public void strikeOutBecauseRateTooHighWhileIdle() {
+    KeepAliveEnforcer enforcer = new KeepAliveEnforcer(true, 1, TimeUnit.NANOSECONDS, ticker);
+    enforcer.onTransportIdle();
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+    }
+    assertThat(enforcer.pingAcceptable()).isFalse();
+  }
+
+  @Test
+  public void permitInRateWhileActive() {
+    KeepAliveEnforcer enforcer = new KeepAliveEnforcer(false, 1, TimeUnit.NANOSECONDS, ticker);
+    enforcer.onTransportActive();
+    for (int i = 0; i < LARGE_NUMBER; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+      ticker.nanoTime += 1;
+    }
+  }
+
+  @Test
+  public void permitInRateWhileIdle() {
+    KeepAliveEnforcer enforcer = new KeepAliveEnforcer(true, 1, TimeUnit.NANOSECONDS, ticker);
+    enforcer.onTransportIdle();
+    for (int i = 0; i < LARGE_NUMBER; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+      ticker.nanoTime += 1;
+    }
+  }
+
+  @Test
+  public void implicitPermittedWhileIdle() {
+    KeepAliveEnforcer enforcer = new KeepAliveEnforcer(
+        false, KeepAliveEnforcer.IMPLICIT_PERMIT_TIME_NANOS * 10, TimeUnit.NANOSECONDS, ticker);
+    enforcer.onTransportIdle();
+    for (int i = 0; i < LARGE_NUMBER; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+      ticker.nanoTime += KeepAliveEnforcer.IMPLICIT_PERMIT_TIME_NANOS;
+    }
+  }
+
+  @Test
+  public void implicitOverridesWhileActive() {
+    KeepAliveEnforcer enforcer = new KeepAliveEnforcer(
+        false, KeepAliveEnforcer.IMPLICIT_PERMIT_TIME_NANOS * 10, TimeUnit.NANOSECONDS, ticker);
+    enforcer.onTransportActive();
+    for (int i = 0; i < LARGE_NUMBER; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+      ticker.nanoTime += KeepAliveEnforcer.IMPLICIT_PERMIT_TIME_NANOS;
+    }
+  }
+
+  @Test
+  public void implicitOverridesWhileIdle() {
+    KeepAliveEnforcer enforcer = new KeepAliveEnforcer(
+        true, KeepAliveEnforcer.IMPLICIT_PERMIT_TIME_NANOS * 10, TimeUnit.NANOSECONDS, ticker);
+    enforcer.onTransportIdle();
+    for (int i = 0; i < LARGE_NUMBER; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+      ticker.nanoTime += KeepAliveEnforcer.IMPLICIT_PERMIT_TIME_NANOS;
+    }
+  }
+
+  @Test
+  public void permitsWhenTimeOverflows() {
+    ticker.nanoTime = Long.MAX_VALUE;
+    KeepAliveEnforcer enforcer = new KeepAliveEnforcer(false, 1, TimeUnit.NANOSECONDS, ticker);
+    enforcer.onTransportActive();
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+    }
+    // Should have the maximum number of strikes now
+    ticker.nanoTime++;
+    assertThat(enforcer.pingAcceptable()).isTrue();
+  }
+
+  @Test
+  public void resetCounters_resetsStrikes() {
+    KeepAliveEnforcer enforcer = new KeepAliveEnforcer(false, 1, TimeUnit.NANOSECONDS, ticker);
+    enforcer.onTransportActive();
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+    }
+    // Should have the maximum number of strikes now
+    enforcer.resetCounters();
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+    }
+    assertThat(enforcer.pingAcceptable()).isFalse();
+  }
+
+  @Test
+  public void resetCounters_resetsPingTime() {
+    KeepAliveEnforcer enforcer = new KeepAliveEnforcer(false, 1, TimeUnit.NANOSECONDS, ticker);
+    enforcer.onTransportActive();
+    ticker.nanoTime += 1;
+    assertThat(enforcer.pingAcceptable()).isTrue();
+    enforcer.resetCounters();
+    // Should not cause a strike
+    assertThat(enforcer.pingAcceptable()).isTrue();
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES; i++) {
+      assertThat(enforcer.pingAcceptable()).isTrue();
+    }
+  }
+
+  @Test
+  public void systemTickerIsSystemNanoTime() {
+    long before = System.nanoTime();
+    long returned = KeepAliveEnforcer.SystemTicker.INSTANCE.nanoTime();
+    long after = System.nanoTime();
+    assertThat(returned).isAtLeast(before);
+    assertThat(returned).isAtMost(after);
+  }
+
+  private static class FakeTicker implements KeepAliveEnforcer.Ticker {
+    long nanoTime;
+
+    @Override
+    public long nanoTime() {
+      return nanoTime;
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/KeepAliveManagerTest.java b/core/src/test/java/io/grpc/internal/KeepAliveManagerTest.java
index cbeb58b1f0e..81e3d1b2638 100644
--- a/core/src/test/java/io/grpc/internal/KeepAliveManagerTest.java
+++ b/core/src/test/java/io/grpc/internal/KeepAliveManagerTest.java
@@ -1,380 +1,314 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.doReturn;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
+import com.google.common.collect.Iterables;
 import io.grpc.Status;
+import io.grpc.internal.KeepAliveManager.ClientKeepAlivePinger;
+import io.grpc.internal.KeepAliveManager.KeepAlivePinger;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 @RunWith(JUnit4.class)
 public final class KeepAliveManagerTest {
-  private final FakeTicker ticker = new FakeTicker();
-  private KeepAliveManager keepAliveManager;
-  @Mock private ManagedClientTransport transport;
-  @Mock private ScheduledExecutorService scheduler;
-
-  static class FakeTicker extends KeepAliveManager.Ticker {
-    long time;
 
-    @Override
-    public long read() {
-      return time;
-    }
-  }
+  private final FakeClock fakeClock = new FakeClock();
+  private KeepAliveManager keepAliveManager;
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  @Mock private KeepAlivePinger keepAlivePinger;
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    keepAliveManager = new KeepAliveManager(transport, scheduler, ticker, 1000, 2000);
+    ScheduledExecutorService scheduler = fakeClock.getScheduledExecutorService();
+    keepAliveManager = new KeepAliveManager(keepAlivePinger, scheduler,
+        fakeClock.getStopwatchSupplier().get(), 1000, 2000, false);
   }
 
   @Test
   public void sendKeepAlivePings() {
-    ticker.time = 1;
+    fakeClock.forwardNanos(1);
     // Transport becomes active. We should schedule keepalive pings.
     keepAliveManager.onTransportActive();
-    ArgumentCaptor<Long> delayCaptor = ArgumentCaptor.forClass(Long.class);
-    ArgumentCaptor<Runnable> sendPingCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(scheduler, times(1)).schedule(sendPingCaptor.capture(), delayCaptor.capture(),
-        isA(TimeUnit.class));
-    Runnable sendPing = sendPingCaptor.getValue();
-    Long delay = delayCaptor.getValue();
-    assertEquals(1000 - 1, delay.longValue());
-
-    ScheduledFuture<?> shutdownFuture = mock(ScheduledFuture.class);
-    doReturn(shutdownFuture)
-        .when(scheduler).schedule(isA(Runnable.class), isA(Long.class), isA(TimeUnit.class));
-    // Mannually running the Runnable will send the ping. Shutdown task should be scheduled.
-    ticker.time = 1000;
-    sendPing.run();
-    ArgumentCaptor<ClientTransport.PingCallback> pingCallbackCaptor =
-        ArgumentCaptor.forClass(ClientTransport.PingCallback.class);
-    verify(transport).ping(pingCallbackCaptor.capture(), isA(Executor.class));
-    ClientTransport.PingCallback pingCallback = pingCallbackCaptor.getValue();
-    verify(scheduler, times(2)).schedule(isA(Runnable.class), delayCaptor.capture(),
-        isA(TimeUnit.class));
-    delay = delayCaptor.getValue();
+    ScheduledFuture<?> future = Iterables.getFirst(fakeClock.getPendingTasks(), null);
+    assertEquals(1000 - 1, future.getDelay(TimeUnit.NANOSECONDS));
+
+    // Forward clock to keepAliveTimeInNanos will send the ping. Shutdown task should be scheduled.
+    fakeClock.forwardNanos(999);
+    verify(keepAlivePinger).ping();
+    ScheduledFuture<?> shutdownFuture = Iterables.getFirst(fakeClock.getPendingTasks(), null);
     // Keepalive timeout is 2000.
-    assertEquals(2000, delay.longValue());
+    assertEquals(2000, shutdownFuture.getDelay(TimeUnit.NANOSECONDS));
 
     // Ping succeeds. Reschedule another ping.
-    ticker.time = 1100;
-    pingCallback.onSuccess(100);
-    verify(scheduler, times(3)).schedule(isA(Runnable.class), delayCaptor.capture(),
-        isA(TimeUnit.class));
+    fakeClock.forwardNanos(100);
+    keepAliveManager.onDataReceived();
     // Shutdown task has been cancelled.
-    verify(shutdownFuture).cancel(isA(Boolean.class));
-    delay = delayCaptor.getValue();
+    assertTrue(shutdownFuture.isCancelled());
+    future = Iterables.getFirst(fakeClock.getPendingTasks(), null);
     // Next ping should be exactly 1000 nanoseconds later.
-    assertEquals(1000, delay.longValue());
+    assertEquals(1000, future.getDelay(TimeUnit.NANOSECONDS));
   }
 
   @Test
   public void keepAlivePingDelayedByIncomingData() {
     // Transport becomes active. We should schedule keepalive pings.
     keepAliveManager.onTransportActive();
-    ArgumentCaptor<Runnable> sendPingCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(scheduler, times(1)).schedule(sendPingCaptor.capture(), isA(Long.class),
-        isA(TimeUnit.class));
-    Runnable sendPing = sendPingCaptor.getValue();
 
     // We receive some data. We may need to delay the ping.
-    ticker.time = 1500;
+    fakeClock.forwardNanos(990);
     keepAliveManager.onDataReceived();
-    ticker.time = 1600;
-    sendPing.run();
+    fakeClock.forwardNanos(20);
+
     // We didn't send the ping.
-    verify(transport, times(0)).ping(isA(ClientTransport.PingCallback.class),
-        isA(Executor.class));
+    verify(keepAlivePinger, never()).ping();
+
     // Instead we reschedule.
-    ArgumentCaptor<Long> delayCaptor = ArgumentCaptor.forClass(Long.class);
-    verify(scheduler, times(2)).schedule(isA(Runnable.class), delayCaptor.capture(),
-        isA(TimeUnit.class));
-    Long delay = delayCaptor.getValue();
-    assertEquals(1500 + 1000 - 1600, delay.longValue());
+    ScheduledFuture<?> future = Iterables.getFirst(fakeClock.getPendingTasks(), null);
+    assertEquals(1000 - 20, future.getDelay(TimeUnit.NANOSECONDS));
   }
 
   @Test
-  public void keepAlivePingFails() {
-    // Transport becomes active. We should schedule keepalive pings.
-    keepAliveManager.onTransportActive();
-    ArgumentCaptor<Runnable> sendPingCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(scheduler, times(1)).schedule(sendPingCaptor.capture(), isA(Long.class),
-        isA(TimeUnit.class));
-    Runnable sendPing = sendPingCaptor.getValue();
-
-    ScheduledFuture<?> shutdownFuture = mock(ScheduledFuture.class);
-    doReturn(shutdownFuture)
-        .when(scheduler).schedule(isA(Runnable.class), isA(Long.class), isA(TimeUnit.class));
-    // Mannually running the Runnable will send the ping. Shutdown task should be scheduled.
-    ticker.time = 1000;
-    sendPing.run();
+  public void clientKeepAlivePinger_pingTimeout() {
+    ClientKeepAlivePinger.TransportWithDisconnectReason transport =
+        mock(ClientKeepAlivePinger.TransportWithDisconnectReason.class);
+    ClientKeepAlivePinger pinger = new ClientKeepAlivePinger(transport);
+
+    pinger.onPingTimeout();
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(transport).shutdownNow(statusCaptor.capture(),
+        eq(SimpleDisconnectError.CONNECTION_TIMED_OUT));
+    Status status = statusCaptor.getValue();
+    assertThat(status.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(status.getDescription()).isEqualTo(
+        "Keepalive failed. The connection is likely gone");
+  }
+
+  @Test
+  public void clientKeepAlivePinger_pingFailure() {
+    ClientKeepAlivePinger.TransportWithDisconnectReason transport =
+        mock(ClientKeepAlivePinger.TransportWithDisconnectReason.class);
+    ClientKeepAlivePinger pinger = new ClientKeepAlivePinger(transport);
+    pinger.ping();
     ArgumentCaptor<ClientTransport.PingCallback> pingCallbackCaptor =
         ArgumentCaptor.forClass(ClientTransport.PingCallback.class);
     verify(transport).ping(pingCallbackCaptor.capture(), isA(Executor.class));
     ClientTransport.PingCallback pingCallback = pingCallbackCaptor.getValue();
-    verify(scheduler, times(2)).schedule(isA(Runnable.class), isA(Long.class),
-        isA(TimeUnit.class));
 
-    // Ping fails. Shutdown the transport.
-    ticker.time = 1100;
-    pingCallback.onFailure(new Throwable());
-    // Shutdown task has been cancelled.
-    verify(shutdownFuture).cancel(isA(Boolean.class));
+    pingCallback.onFailure(Status.UNAVAILABLE.withDescription("I must write descriptions"));
+
     ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
-    verify(transport).shutdownNow(statusCaptor.capture());
+    verify(transport).shutdownNow(statusCaptor.capture(),
+        eq(SimpleDisconnectError.CONNECTION_TIMED_OUT));
     Status status = statusCaptor.getValue();
-    assertEquals(Status.UNAVAILABLE.getCode(), status.getCode());
+    assertThat(status.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(status.getDescription()).isEqualTo(
+        "Keepalive failed. The connection is likely gone");
   }
 
+
   @Test
-  public void keepAlivePingFailsAfterItTimesOut() {
+  public void onTransportTerminationCancelsShutdownFuture() {
     // Transport becomes active. We should schedule keepalive pings.
     keepAliveManager.onTransportActive();
-    ArgumentCaptor<Runnable> sendPingCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(scheduler, times(1)).schedule(sendPingCaptor.capture(), isA(Long.class),
-        isA(TimeUnit.class));
-    Runnable sendPing = sendPingCaptor.getValue();
-
-    ScheduledFuture<?> shutdownFuture = mock(ScheduledFuture.class);
-    doReturn(shutdownFuture)
-        .when(scheduler).schedule(isA(Runnable.class), isA(Long.class), isA(TimeUnit.class));
-    // Mannually running the Runnable will send the ping. Shutdown task should be scheduled.
-    ticker.time = 1000;
-    sendPing.run();
-    ArgumentCaptor<ClientTransport.PingCallback> pingCallbackCaptor =
-        ArgumentCaptor.forClass(ClientTransport.PingCallback.class);
-    verify(transport).ping(pingCallbackCaptor.capture(), isA(Executor.class));
-    ClientTransport.PingCallback pingCallback = pingCallbackCaptor.getValue();
-    ArgumentCaptor<Runnable> shutdownCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(scheduler, times(2)).schedule(shutdownCaptor.capture(), isA(Long.class),
-        isA(TimeUnit.class));
-    Runnable shutdown = shutdownCaptor.getValue();
+    fakeClock.forwardNanos(1000);
 
-    // We do not receive the ping response. Shutdown runnable runs.
-    ticker.time = 3000;
-    shutdown.run();
-    verify(transport).shutdownNow(isA(Status.class));
-
-    // We receive the ping error after we shutdown the transport.
-    pingCallback.onFailure(new Throwable());
-    // We should not shutdown transport again.
-    verify(transport, times(1)).shutdownNow(isA(Status.class));
+    ScheduledFuture<?> shutdownFuture = Iterables.getFirst(fakeClock.getPendingTasks(), null);
+
+    keepAliveManager.onTransportTermination();
+
+    // Shutdown task has been cancelled.
+    assertTrue(shutdownFuture.isCancelled());
   }
 
   @Test
   public void keepAlivePingTimesOut() {
     // Transport becomes active. We should schedule keepalive pings.
     keepAliveManager.onTransportActive();
-    ArgumentCaptor<Runnable> sendPingCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(scheduler, times(1)).schedule(sendPingCaptor.capture(), isA(Long.class),
-        isA(TimeUnit.class));
-    Runnable sendPing = sendPingCaptor.getValue();
-
-    ScheduledFuture<?> shutdownFuture = mock(ScheduledFuture.class);
-    doReturn(shutdownFuture)
-        .when(scheduler).schedule(isA(Runnable.class), isA(Long.class), isA(TimeUnit.class));
-    // Mannually running the Runnable will send the ping. Shutdown task should be scheduled.
-    ticker.time = 1000;
-    sendPing.run();
-    ArgumentCaptor<ClientTransport.PingCallback> pingCallbackCaptor =
-        ArgumentCaptor.forClass(ClientTransport.PingCallback.class);
-    verify(transport).ping(pingCallbackCaptor.capture(), isA(Executor.class));
-    ClientTransport.PingCallback pingCallback = pingCallbackCaptor.getValue();
-    ArgumentCaptor<Runnable> shutdownCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(scheduler, times(2)).schedule(shutdownCaptor.capture(), isA(Long.class),
-        isA(TimeUnit.class));
-    Runnable shutdown = shutdownCaptor.getValue();
+
+    // Forward clock to keepAliveTimeInNanos will send the ping. Shutdown task should be scheduled.
+    fakeClock.forwardNanos(1000);
+    verify(keepAlivePinger).ping();
 
     // We do not receive the ping response. Shutdown runnable runs.
-    ticker.time = 3000;
-    shutdown.run();
-    verify(transport).shutdownNow(isA(Status.class));
+    fakeClock.forwardNanos(2000);
+    verify(keepAlivePinger).onPingTimeout();
 
     // We receive the ping response too late.
-    pingCallback.onSuccess(3000);
+    keepAliveManager.onDataReceived();
     // No more ping should be scheduled.
-    verify(scheduler, times(2)).schedule(isA(Runnable.class), isA(Long.class),
-        isA(TimeUnit.class));
+    assertThat(fakeClock.getPendingTasks()).isEmpty();
   }
 
   @Test
   public void transportGoesIdle() {
     // Transport becomes active. We should schedule keepalive pings.
     keepAliveManager.onTransportActive();
-    ArgumentCaptor<Runnable> sendPingCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(scheduler, times(1)).schedule(sendPingCaptor.capture(), isA(Long.class),
-        isA(TimeUnit.class));
-    Runnable sendPing = sendPingCaptor.getValue();
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
 
     // Transport becomes idle. Nothing should happen when ping runnable runs.
     keepAliveManager.onTransportIdle();
-    sendPing.run();
+    fakeClock.forwardNanos(1000);
     // Ping was not sent.
-    verify(transport, times(0)).ping(isA(ClientTransport.PingCallback.class),
-        isA(Executor.class));
+    verify(keepAlivePinger, never()).ping();
     // No new ping got scheduled.
-    verify(scheduler, times(1)).schedule(isA(Runnable.class), isA(Long.class), isA(TimeUnit.class));
+    assertThat(fakeClock.getPendingTasks()).isEmpty();
+
+    // But when transport goes back to active
+    keepAliveManager.onTransportActive();
+    fakeClock.runDueTasks();
+    // Ping is now sent.
+    verify(keepAlivePinger).ping();
+  }
+
+  @Test
+  public void transportGoesIdle_doesntCauseIdleWhenEnabled() {
+    keepAliveManager.onTransportTermination();
+    ScheduledExecutorService scheduler = fakeClock.getScheduledExecutorService();
+    keepAliveManager = new KeepAliveManager(keepAlivePinger, scheduler, 1000, 2000, true);
+    keepAliveManager.onTransportStarted();
+
+    // Keepalive scheduling should have started immediately.
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
+
+    keepAliveManager.onTransportActive();
+
+    // Transport becomes idle. Should not impact the sending of the ping.
+    keepAliveManager.onTransportIdle();
+    fakeClock.forwardNanos(1000);
+    // Ping was sent.
+    verify(keepAlivePinger).ping();
+    // Shutdown is scheduled.
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
+    // Shutdown is triggered.
+    fakeClock.forwardNanos(2000);
+    verify(keepAlivePinger).onPingTimeout();
   }
 
   @Test
   public void transportGoesIdleAfterPingSent() {
     // Transport becomes active. We should schedule keepalive pings.
     keepAliveManager.onTransportActive();
-    ArgumentCaptor<Runnable> sendPingCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(scheduler, times(1)).schedule(sendPingCaptor.capture(), isA(Long.class),
-        isA(TimeUnit.class));
-    Runnable sendPing = sendPingCaptor.getValue();
-
-    ScheduledFuture<?> shutdownFuture = mock(ScheduledFuture.class);
-    doReturn(shutdownFuture)
-        .when(scheduler).schedule(isA(Runnable.class), isA(Long.class), isA(TimeUnit.class));
-    // Mannually running the Runnable will send the ping. Shutdown task should be scheduled.
-    ticker.time = 1000;
-    sendPing.run();
-    ArgumentCaptor<ClientTransport.PingCallback> pingCallbackCaptor =
-        ArgumentCaptor.forClass(ClientTransport.PingCallback.class);
-    verify(transport).ping(pingCallbackCaptor.capture(), isA(Executor.class));
-    ClientTransport.PingCallback pingCallback = pingCallbackCaptor.getValue();
-    verify(scheduler, times(2)).schedule(isA(Runnable.class), isA(Long.class), isA(TimeUnit.class));
+
+    // Forward clock to keepAliveTimeInNanos will send the ping. Shutdown task should be scheduled.
+    fakeClock.forwardNanos(1000);
+    ScheduledFuture<?> shutdownFuture = Iterables.getFirst(fakeClock.getPendingTasks(), null);
+    verify(keepAlivePinger).ping();
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
 
     // Transport becomes idle. No more ping should be scheduled after we receive a ping response.
     keepAliveManager.onTransportIdle();
-    ticker.time = 1100;
-    pingCallback.onSuccess(100);
-    verify(scheduler, times(2)).schedule(isA(Runnable.class), isA(Long.class), isA(TimeUnit.class));
-    // Shutdown task has been cancelled.
-    verify(shutdownFuture).cancel(isA(Boolean.class));
-
+    fakeClock.forwardNanos(100);
+    keepAliveManager.onDataReceived();
+    assertTrue(shutdownFuture.isCancelled());
+    assertThat(fakeClock.getPendingTasks()).isEmpty();
     // Transport becomes active again. Another ping is scheduled.
     keepAliveManager.onTransportActive();
-    verify(scheduler, times(3)).schedule(isA(Runnable.class), isA(Long.class), isA(TimeUnit.class));
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
   }
 
   @Test
-  public void transportGoesIdleAndPingFails() {
+  public void transportGoesIdleBeforePingSent() {
+
     // Transport becomes active. We should schedule keepalive pings.
     keepAliveManager.onTransportActive();
-    ArgumentCaptor<Runnable> sendPingCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(scheduler, times(1)).schedule(sendPingCaptor.capture(), isA(Long.class),
-        isA(TimeUnit.class));
-    Runnable sendPing = sendPingCaptor.getValue();
-
-    ScheduledFuture<?> shutdownFuture = mock(ScheduledFuture.class);
-    doReturn(shutdownFuture)
-        .when(scheduler).schedule(isA(Runnable.class), isA(Long.class), isA(TimeUnit.class));
-    // Mannually running the Runnable will send the ping. Shutdown task should be scheduled.
-    ticker.time = 1000;
-    sendPing.run();
-    ArgumentCaptor<ClientTransport.PingCallback> pingCallbackCaptor =
-        ArgumentCaptor.forClass(ClientTransport.PingCallback.class);
-    verify(transport).ping(pingCallbackCaptor.capture(), isA(Executor.class));
-    ClientTransport.PingCallback pingCallback = pingCallbackCaptor.getValue();
-    verify(scheduler, times(2)).schedule(isA(Runnable.class), isA(Long.class),
-        isA(TimeUnit.class));
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
+    ScheduledFuture<?> pingFuture = Iterables.getFirst(fakeClock.getPendingTasks(), null);
+
+    // Data is received, and we go to ping delayed
+    keepAliveManager.onDataReceived();
 
-    // Transport becomes idle. It does not stop the failed ping from shutting down the transport.
+    // Transport becomes idle while the 1st ping is still scheduled
     keepAliveManager.onTransportIdle();
-    // Ping fails. Shutdown the transport.
-    ticker.time = 1100;
-    pingCallback.onFailure(new Throwable());
-    // Shutdown task has been cancelled.
-    verify(shutdownFuture).cancel(isA(Boolean.class));
-    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
-    verify(transport).shutdownNow(statusCaptor.capture());
-    Status status = statusCaptor.getValue();
-    assertEquals(Status.UNAVAILABLE.getCode(), status.getCode());
+
+    // Transport becomes active again, we don't need to reschedule another ping
+    keepAliveManager.onTransportActive();
+    assertThat(fakeClock.getPendingTasks()).containsExactly(pingFuture);
   }
 
   @Test
   public void transportShutsdownAfterPingScheduled() {
-    ScheduledFuture<?> pingFuture = mock(ScheduledFuture.class);
-    doReturn(pingFuture)
-        .when(scheduler).schedule(isA(Runnable.class), isA(Long.class), isA(TimeUnit.class));
     // Ping will be scheduled.
     keepAliveManager.onTransportActive();
-    verify(scheduler, times(1)).schedule(isA(Runnable.class), isA(Long.class),
-        isA(TimeUnit.class));
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
+    ScheduledFuture<?> pingFuture = Iterables.getFirst(fakeClock.getPendingTasks(), null);
     // Transport is shutting down.
-    keepAliveManager.onTransportShutdown();
+    keepAliveManager.onTransportTermination();
     // Ping future should have been cancelled.
-    verify(pingFuture).cancel(isA(Boolean.class));
+    assertTrue(pingFuture.isCancelled());
   }
 
   @Test
   public void transportShutsdownAfterPingSent() {
     keepAliveManager.onTransportActive();
-    ArgumentCaptor<Runnable> sendPingCaptor = ArgumentCaptor.forClass(Runnable.class);
-    verify(scheduler, times(1)).schedule(sendPingCaptor.capture(), isA(Long.class),
-        isA(TimeUnit.class));
-    Runnable sendPing = sendPingCaptor.getValue();
-
-    ScheduledFuture<?> shutdownFuture = mock(ScheduledFuture.class);
-    doReturn(shutdownFuture)
-        .when(scheduler).schedule(isA(Runnable.class), isA(Long.class), isA(TimeUnit.class));
-    // Mannually running the Runnable will send the ping. Shutdown task should be scheduled.
-    ticker.time = 1000;
-    sendPing.run();
-    ArgumentCaptor<ClientTransport.PingCallback> pingCallbackCaptor =
-        ArgumentCaptor.forClass(ClientTransport.PingCallback.class);
-    verify(transport).ping(pingCallbackCaptor.capture(), isA(Executor.class));
-    verify(scheduler, times(2)).schedule(isA(Runnable.class), isA(Long.class),
-        isA(TimeUnit.class));
+    // Forward clock to keepAliveTimeInNanos will send the ping. Shutdown task should be scheduled.
+    fakeClock.forwardNanos(1000);
+    verify(keepAlivePinger).ping();
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
+    ScheduledFuture<?> shutdownFuture = Iterables.getFirst(fakeClock.getPendingTasks(), null);
 
     // Transport is shutting down.
-    keepAliveManager.onTransportShutdown();
+    keepAliveManager.onTransportTermination();
     // Shutdown task has been cancelled.
-    verify(shutdownFuture).cancel(isA(Boolean.class));
+    assertTrue(shutdownFuture.isCancelled());
+  }
 
-    ClientTransport.PingCallback pingCallback = pingCallbackCaptor.getValue();
-    // Ping fails after transport shutting down. We will not shutdown the transport again.
-    pingCallback.onFailure(new Throwable());
-    verify(transport, times(0)).shutdownNow(isA(Status.class));
+  @Test
+  public void pingSentThenIdleThenActiveThenAck() {
+    keepAliveManager.onTransportActive();
+    // Forward clock to keepAliveTimeInNanos will send the ping. Shutdown task should be scheduled.
+    fakeClock.forwardNanos(1000);
+    verify(keepAlivePinger).ping();
+
+    // shutdown scheduled
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
+
+    keepAliveManager.onTransportIdle();
+
+    keepAliveManager.onTransportActive();
+
+    keepAliveManager.onDataReceived();
+
+    // another ping scheduled
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
+    fakeClock.forwardNanos(1000);
+    verify(keepAlivePinger, times(2)).ping();
   }
 }
 
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelImpl2IdlenessTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelImpl2IdlenessTest.java
deleted file mode 100644
index f3b64bb548e..00000000000
--- a/core/src/test/java/io/grpc/internal/ManagedChannelImpl2IdlenessTest.java
+++ /dev/null
@@ -1,357 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.same;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import com.google.common.collect.Lists;
-import io.grpc.Attributes;
-import io.grpc.CallOptions;
-import io.grpc.ClientCall;
-import io.grpc.ClientInterceptor;
-import io.grpc.CompressorRegistry;
-import io.grpc.DecompressorRegistry;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.IntegerMarshaller;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.Helper;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.Subchannel;
-import io.grpc.LoadBalancer2.SubchannelPicker;
-import io.grpc.ManagedChannel;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.MethodDescriptor.MethodType;
-import io.grpc.NameResolver;
-import io.grpc.ResolvedServerInfo;
-import io.grpc.ResolvedServerInfoGroup;
-import io.grpc.Status;
-import io.grpc.StringMarshaller;
-import io.grpc.internal.TestUtils.MockClientTransportInfo;
-import java.net.SocketAddress;
-import java.net.URI;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-/**
- * Unit tests for {@link ManagedChannelImpl}'s idle mode.
- */
-@RunWith(JUnit4.class)
-public class ManagedChannelImpl2IdlenessTest {
-  private final FakeClock timer = new FakeClock();
-  private final FakeClock executor = new FakeClock();
-  private final FakeClock oobExecutor = new FakeClock();
-  private static final String AUTHORITY = "fakeauthority";
-  private static final String USER_AGENT = "fakeagent";
-  private static final long IDLE_TIMEOUT_SECONDS = 30;
-  private ManagedChannelImpl2 channel;
-
-  private final MethodDescriptor<String, Integer> method =
-      MethodDescriptor.<String, Integer>newBuilder()
-          .setType(MethodType.UNKNOWN)
-          .setFullMethodName("/service/method")
-          .setRequestMarshaller(new StringMarshaller())
-          .setResponseMarshaller(new IntegerMarshaller())
-          .build();
-
-  private final List<ResolvedServerInfoGroup> servers = Lists.newArrayList();
-  private final List<EquivalentAddressGroup> addressGroupList =
-      new ArrayList<EquivalentAddressGroup>();
-
-  @Mock private ObjectPool<ScheduledExecutorService> timerServicePool;
-  @Mock private ObjectPool<Executor> executorPool;
-  @Mock private ObjectPool<Executor> oobExecutorPool;
-  @Mock private ClientTransportFactory mockTransportFactory;
-  @Mock private LoadBalancer2 mockLoadBalancer;
-  @Mock private LoadBalancer2.Factory mockLoadBalancerFactory;
-  @Mock private NameResolver mockNameResolver;
-  @Mock private NameResolver.Factory mockNameResolverFactory;
-  @Mock private ClientCall.Listener<Integer> mockCallListener;
-  @Mock private ClientCall.Listener<Integer> mockCallListener2;
-  @Captor private ArgumentCaptor<NameResolver.Listener> nameResolverListenerCaptor;
-  private BlockingQueue<MockClientTransportInfo> newTransports;
-
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    when(timerServicePool.getObject()).thenReturn(timer.getScheduledExecutorService());
-    when(executorPool.getObject()).thenReturn(executor.getScheduledExecutorService());
-    when(oobExecutorPool.getObject()).thenReturn(oobExecutor.getScheduledExecutorService());
-    when(mockLoadBalancerFactory.newLoadBalancer(any(Helper.class))).thenReturn(mockLoadBalancer);
-    when(mockNameResolver.getServiceAuthority()).thenReturn(AUTHORITY);
-    when(mockNameResolverFactory
-        .newNameResolver(any(URI.class), any(Attributes.class)))
-        .thenReturn(mockNameResolver);
-
-    channel = new ManagedChannelImpl2("fake://target", new FakeBackoffPolicyProvider(),
-        mockNameResolverFactory, Attributes.EMPTY, mockLoadBalancerFactory,
-        mockTransportFactory, DecompressorRegistry.getDefaultInstance(),
-        CompressorRegistry.getDefaultInstance(), timerServicePool, executorPool, oobExecutorPool,
-        timer.getStopwatchSupplier(), TimeUnit.SECONDS.toMillis(IDLE_TIMEOUT_SECONDS), USER_AGENT,
-        Collections.<ClientInterceptor>emptyList(),
-        NoopStatsContextFactory.INSTANCE);
-    newTransports = TestUtils.captureTransports(mockTransportFactory);
-
-    for (int i = 0; i < 2; i++) {
-      ResolvedServerInfoGroup.Builder resolvedServerInfoGroup = ResolvedServerInfoGroup.builder();
-      for (int j = 0; j < 2; j++) {
-        resolvedServerInfoGroup.add(
-            new ResolvedServerInfo(new FakeSocketAddress("servergroup" + i + "server" + j)));
-      }
-      servers.add(resolvedServerInfoGroup.build());
-      addressGroupList.add(resolvedServerInfoGroup.build().toEquivalentAddressGroup());
-    }
-    verify(mockNameResolverFactory).newNameResolver(any(URI.class), any(Attributes.class));
-    // Verify the initial idleness
-    verify(mockLoadBalancerFactory, never()).newLoadBalancer(any(Helper.class));
-    verify(mockTransportFactory, never()).newClientTransport(
-        any(SocketAddress.class), anyString(), anyString());
-    verify(mockNameResolver, never()).start(any(NameResolver.Listener.class));
-  }
-
-  @After
-  public void allPendingTasksAreRun() {
-    assertEquals(timer.getPendingTasks() + " should be empty", 0, timer.numPendingTasks());
-    assertEquals(executor.getPendingTasks() + " should be empty", 0, executor.numPendingTasks());
-  }
-
-  @Test
-  public void newCallExitsIdleness() throws Exception {
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    call.start(mockCallListener, new Metadata());
-
-    verify(mockLoadBalancerFactory).newLoadBalancer(any(Helper.class));
-
-    verify(mockNameResolver).start(nameResolverListenerCaptor.capture());
-    // Simulate new address resolved to make sure the LoadBalancer is correctly linked to
-    // the NameResolver.
-    nameResolverListenerCaptor.getValue().onUpdate(servers, Attributes.EMPTY);
-    verify(mockLoadBalancer).handleResolvedAddresses(servers, Attributes.EMPTY);
-  }
-
-  @Test
-  public void newCallRefreshesIdlenessTimer() throws Exception {
-    // First call to exit the initial idleness, then immediately cancel the call.
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    call.start(mockCallListener, new Metadata());
-    call.cancel("For testing", null);
-
-    // Verify that we have exited the idle mode
-    verify(mockLoadBalancerFactory).newLoadBalancer(any(Helper.class));
-    assertFalse(channel.inUseStateAggregator.isInUse());
-
-    // Move closer to idleness, but not yet.
-    timer.forwardTime(IDLE_TIMEOUT_SECONDS - 1, TimeUnit.SECONDS);
-    verify(mockLoadBalancer, never()).shutdown();
-    assertFalse(channel.inUseStateAggregator.isInUse());
-
-    // A new call would refresh the timer
-    call = channel.newCall(method, CallOptions.DEFAULT);
-    call.start(mockCallListener, new Metadata());
-    call.cancel("For testing", null);
-    assertFalse(channel.inUseStateAggregator.isInUse());
-
-    // ... so that passing the same length of time will not trigger idle mode
-    timer.forwardTime(IDLE_TIMEOUT_SECONDS - 1, TimeUnit.SECONDS);
-    verify(mockLoadBalancer, never()).shutdown();
-    assertFalse(channel.inUseStateAggregator.isInUse());
-
-    // ... until the time since last call has reached the timeout
-    timer.forwardTime(1, TimeUnit.SECONDS);
-    verify(mockLoadBalancer).shutdown();
-    assertFalse(channel.inUseStateAggregator.isInUse());
-
-    // Drain the app executor, which runs the call listeners
-    verify(mockCallListener, never()).onClose(any(Status.class), any(Metadata.class));
-    assertEquals(2, executor.runDueTasks());
-    verify(mockCallListener, times(2)).onClose(any(Status.class), any(Metadata.class));
-  }
-
-  @Test
-  public void delayedTransportHoldsOffIdleness() throws Exception {
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    call.start(mockCallListener, new Metadata());
-    assertTrue(channel.inUseStateAggregator.isInUse());
-
-    // As long as the delayed transport is in-use (by the pending RPC), the channel won't go idle.
-    timer.forwardTime(IDLE_TIMEOUT_SECONDS * 2, TimeUnit.SECONDS);
-    assertTrue(channel.inUseStateAggregator.isInUse());
-
-    // Cancelling the only RPC will reset the in-use state.
-    assertEquals(0, executor.numPendingTasks());
-    call.cancel("In test", null);
-    assertEquals(1, executor.runDueTasks());
-    assertFalse(channel.inUseStateAggregator.isInUse());
-    // And allow the channel to go idle.
-    timer.forwardTime(IDLE_TIMEOUT_SECONDS - 1, TimeUnit.SECONDS);
-    verify(mockLoadBalancer, never()).shutdown();
-    timer.forwardTime(1, TimeUnit.SECONDS);
-    verify(mockLoadBalancer).shutdown();
-  }
-
-  @Test
-  public void realTransportsHoldsOffIdleness() throws Exception {
-    final EquivalentAddressGroup addressGroup = addressGroupList.get(1);
-
-    // Start a call, which goes to delayed transport
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    call.start(mockCallListener, new Metadata());
-
-    // Verify that we have exited the idle mode
-    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(null);
-    verify(mockLoadBalancerFactory).newLoadBalancer(helperCaptor.capture());
-    Helper helper = helperCaptor.getValue();
-    assertTrue(channel.inUseStateAggregator.isInUse());
-
-    // Assume LoadBalancer has received an address, then create a subchannel.
-    Subchannel subchannel = helper.createSubchannel(addressGroup, Attributes.EMPTY);
-    subchannel.requestConnection();
-    MockClientTransportInfo t0 = newTransports.poll();
-    t0.listener.transportReady();
-
-    SubchannelPicker mockPicker = mock(SubchannelPicker.class);
-    when(mockPicker.pickSubchannel(any(Attributes.class), any(Metadata.class)))
-        .thenReturn(PickResult.withSubchannel(subchannel));
-    helper.updatePicker(mockPicker);
-    // Delayed transport creates real streams in the app executor
-    executor.runDueTasks();
-
-    // Delayed transport exits in-use, while real transport has not entered in-use yet.
-    assertFalse(channel.inUseStateAggregator.isInUse());
-
-    // Now it's in-use
-    t0.listener.transportInUse(true);
-    assertTrue(channel.inUseStateAggregator.isInUse());
-
-    // As long as the transport is in-use, the channel won't go idle.
-    timer.forwardTime(IDLE_TIMEOUT_SECONDS * 2, TimeUnit.SECONDS);
-    assertTrue(channel.inUseStateAggregator.isInUse());
-
-    t0.listener.transportInUse(false);
-    assertFalse(channel.inUseStateAggregator.isInUse());
-    // And allow the channel to go idle.
-    timer.forwardTime(IDLE_TIMEOUT_SECONDS - 1, TimeUnit.SECONDS);
-    verify(mockLoadBalancer, never()).shutdown();
-    timer.forwardTime(1, TimeUnit.SECONDS);
-    verify(mockLoadBalancer).shutdown();
-  }
-
-  @Test
-  public void oobTransportDoesNotAffectIdleness() {
-    // Start a call, which goes to delayed transport
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    call.start(mockCallListener, new Metadata());
-
-    // Verify that we have exited the idle mode
-    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(null);
-    verify(mockLoadBalancerFactory).newLoadBalancer(helperCaptor.capture());
-    Helper helper = helperCaptor.getValue();
-
-    // Fail the RPC
-    SubchannelPicker failingPicker = mock(SubchannelPicker.class);
-    when(failingPicker.pickSubchannel(any(Attributes.class), any(Metadata.class)))
-        .thenReturn(PickResult.withError(Status.UNAVAILABLE));
-    helper.updatePicker(failingPicker);
-    executor.runDueTasks();
-    verify(mockCallListener).onClose(same(Status.UNAVAILABLE), any(Metadata.class));
-
-    // ... so that the channel resets its in-use state
-    assertFalse(channel.inUseStateAggregator.isInUse());
-
-    // Now make an RPC on an OOB channel
-    ManagedChannel oob = helper.createOobChannel(addressGroupList.get(0), "oobauthority");
-    verify(mockTransportFactory, never())
-        .newClientTransport(any(SocketAddress.class), same("oobauthority"), same(USER_AGENT));
-    ClientCall<String, Integer> oobCall = oob.newCall(method, CallOptions.DEFAULT);
-    oobCall.start(mockCallListener2, new Metadata());
-    verify(mockTransportFactory)
-        .newClientTransport(any(SocketAddress.class), same("oobauthority"), same(USER_AGENT));
-    MockClientTransportInfo oobTransportInfo = newTransports.poll();
-    assertEquals(0, newTransports.size());
-    // The OOB transport reports in-use state
-    oobTransportInfo.listener.transportInUse(true);
-
-    // But it won't stop the channel from going idle
-    verify(mockLoadBalancer, never()).shutdown();
-    timer.forwardTime(IDLE_TIMEOUT_SECONDS, TimeUnit.SECONDS);
-    verify(mockLoadBalancer).shutdown();
-  }
-
-  private static class FakeBackoffPolicyProvider implements BackoffPolicy.Provider {
-    @Override
-    public BackoffPolicy get() {
-      return new BackoffPolicy() {
-        @Override
-        public long nextBackoffMillis() {
-          return 1;
-        }
-      };
-    }
-  }
-
-  private static class FakeSocketAddress extends SocketAddress {
-    final String name;
-
-    FakeSocketAddress(String name) {
-      this.name = name;
-    }
-
-    @Override
-    public String toString() {
-      return "FakeSocketAddress-" + name;
-    }
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelImpl2Test.java b/core/src/test/java/io/grpc/internal/ManagedChannelImpl2Test.java
deleted file mode 100644
index af2586a08f5..00000000000
--- a/core/src/test/java/io/grpc/internal/ManagedChannelImpl2Test.java
+++ /dev/null
@@ -1,1219 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static io.grpc.ConnectivityState.CONNECTING;
-import static io.grpc.ConnectivityState.READY;
-import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
-import static junit.framework.TestCase.assertNotSame;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyObject;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.same;
-import static org.mockito.Mockito.atLeast;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-import com.google.common.collect.ImmutableList;
-import io.grpc.Attributes;
-import io.grpc.CallCredentials;
-import io.grpc.CallCredentials.MetadataApplier;
-import io.grpc.CallOptions;
-import io.grpc.Channel;
-import io.grpc.ClientCall;
-import io.grpc.ClientInterceptor;
-import io.grpc.CompressorRegistry;
-import io.grpc.ConnectivityStateInfo;
-import io.grpc.Context;
-import io.grpc.DecompressorRegistry;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.IntegerMarshaller;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.Helper;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.Subchannel;
-import io.grpc.LoadBalancer2.SubchannelPicker;
-import io.grpc.ManagedChannel;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.MethodDescriptor.MethodType;
-import io.grpc.NameResolver;
-import io.grpc.ResolvedServerInfo;
-import io.grpc.ResolvedServerInfoGroup;
-import io.grpc.SecurityLevel;
-import io.grpc.Status;
-import io.grpc.StringMarshaller;
-import io.grpc.internal.TestUtils.MockClientTransportInfo;
-import io.grpc.internal.testing.StatsTestUtils.FakeStatsContextFactory;
-import java.net.SocketAddress;
-import java.net.URI;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicLong;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InOrder;
-import org.mockito.Matchers;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-/** Unit tests for {@link ManagedChannelImpl2}. */
-@RunWith(JUnit4.class)
-public class ManagedChannelImpl2Test {
-  private static final List<ClientInterceptor> NO_INTERCEPTOR =
-      Collections.<ClientInterceptor>emptyList();
-  private static final Attributes NAME_RESOLVER_PARAMS =
-      Attributes.newBuilder().set(NameResolver.Factory.PARAMS_DEFAULT_PORT, 447).build();
-  private static final MethodDescriptor<String, Integer> method =
-      MethodDescriptor.<String, Integer>newBuilder()
-          .setType(MethodType.UNKNOWN)
-          .setFullMethodName("/service/method")
-          .setRequestMarshaller(new StringMarshaller())
-          .setResponseMarshaller(new IntegerMarshaller())
-          .build();
-  private static final Attributes.Key<String> SUBCHANNEL_ATTR_KEY =
-      Attributes.Key.of("subchannel-attr-key");
-  private final String serviceName = "fake.example.com";
-  private final String authority = serviceName;
-  private final String userAgent = "userAgent";
-  private final String target = "fake://" + serviceName;
-  private URI expectedUri;
-  private final SocketAddress socketAddress = new SocketAddress() {};
-  private final EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(socketAddress);
-  private final ResolvedServerInfo server = new ResolvedServerInfo(socketAddress, Attributes.EMPTY);
-  private final FakeClock timer = new FakeClock();
-  private final FakeClock executor = new FakeClock();
-  private final FakeClock oobExecutor = new FakeClock();
-  private final FakeStatsContextFactory statsCtxFactory = new FakeStatsContextFactory();
-
-  @Rule public final ExpectedException thrown = ExpectedException.none();
-
-  private ManagedChannelImpl2 channel;
-  private Helper helper;
-  @Captor
-  private ArgumentCaptor<Status> statusCaptor;
-  @Captor
-  private ArgumentCaptor<StatsTraceContext> statsTraceCtxCaptor;
-  @Mock
-  private LoadBalancer2.Factory mockLoadBalancerFactory;
-  @Mock
-  private LoadBalancer2 mockLoadBalancer;
-  @Captor
-  private ArgumentCaptor<ConnectivityStateInfo> stateInfoCaptor;
-  @Mock
-  private SubchannelPicker mockPicker;
-  @Mock
-  private ClientTransportFactory mockTransportFactory;
-  @Mock
-  private ClientCall.Listener<Integer> mockCallListener;
-  @Mock
-  private ClientCall.Listener<Integer> mockCallListener2;
-  @Mock
-  private ClientCall.Listener<Integer> mockCallListener3;
-  @Mock
-  private ClientCall.Listener<Integer> mockCallListener4;
-  @Mock
-  private ClientCall.Listener<Integer> mockCallListener5;
-  @Mock
-  private ObjectPool<ScheduledExecutorService> timerServicePool;
-  @Mock
-  private ObjectPool<Executor> executorPool;
-  @Mock
-  private ObjectPool<Executor> oobExecutorPool;
-  @Mock
-  private CallCredentials creds;
-  private BlockingQueue<MockClientTransportInfo> transports;
-
-  private ArgumentCaptor<ClientStreamListener> streamListenerCaptor =
-      ArgumentCaptor.forClass(ClientStreamListener.class);
-
-  private void createChannel(
-      NameResolver.Factory nameResolverFactory, List<ClientInterceptor> interceptors) {
-    channel = new ManagedChannelImpl2(target, new FakeBackoffPolicyProvider(),
-        nameResolverFactory, NAME_RESOLVER_PARAMS, mockLoadBalancerFactory,
-        mockTransportFactory, DecompressorRegistry.getDefaultInstance(),
-        CompressorRegistry.getDefaultInstance(), timerServicePool, executorPool, oobExecutorPool,
-        timer.getStopwatchSupplier(),  ManagedChannelImpl2.IDLE_TIMEOUT_MILLIS_DISABLE, userAgent,
-        interceptors, statsCtxFactory);
-    // Force-exit the initial idle-mode
-    channel.exitIdleMode();
-    assertEquals(0, timer.numPendingTasks());
-
-    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(null);
-    verify(mockLoadBalancerFactory).newLoadBalancer(helperCaptor.capture());
-    helper = helperCaptor.getValue();
-  }
-
-  @Before
-  public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
-    expectedUri = new URI(target);
-    when(mockLoadBalancerFactory.newLoadBalancer(any(Helper.class))).thenReturn(mockLoadBalancer);
-    transports = TestUtils.captureTransports(mockTransportFactory);
-    when(timerServicePool.getObject()).thenReturn(timer.getScheduledExecutorService());
-    when(executorPool.getObject()).thenReturn(executor.getScheduledExecutorService());
-    when(oobExecutorPool.getObject()).thenReturn(oobExecutor.getScheduledExecutorService());
-  }
-
-  @After
-  public void allPendingTasksAreRun() throws Exception {
-    // The "never" verifications in the tests only hold up if all due tasks are done.
-    // As for timer, although there may be scheduled tasks in a future time, since we don't test
-    // any time-related behavior in this test suite, we only care the tasks that are due. This
-    // would ignore any time-sensitive tasks, e.g., back-off and the idle timer.
-    assertTrue(timer.getDueTasks() + " should be empty", timer.getDueTasks().isEmpty());
-    assertEquals(executor.getPendingTasks() + " should be empty", 0, executor.numPendingTasks());
-  }
-
-  /**
-   * The counterpart of {@link ManagedChannelImplIdlenessTest#enterIdleModeAfterForceExit}.
-   */
-  @Test
-  @SuppressWarnings("unchecked")
-  public void idleModeDisabled() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-
-    // In this test suite, the channel is always created with idle mode disabled.
-    // No task is scheduled to enter idle mode
-    assertEquals(0, timer.numPendingTasks());
-    assertEquals(0, executor.numPendingTasks());
-  }
-
-  @Test
-  public void immediateDeadlineExceeded() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    ClientCall<String, Integer> call =
-        channel.newCall(method, CallOptions.DEFAULT.withDeadlineAfter(0, TimeUnit.NANOSECONDS));
-    call.start(mockCallListener, new Metadata());
-    assertEquals(1, executor.runDueTasks());
-
-    verify(mockCallListener).onClose(statusCaptor.capture(), any(Metadata.class));
-    Status status = statusCaptor.getValue();
-    assertSame(Status.DEADLINE_EXCEEDED.getCode(), status.getCode());
-  }
-
-  @Test
-  public void shutdownWithNoTransportsEverCreated() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    verify(executorPool).getObject();
-    verify(timerServicePool).getObject();
-    verify(executorPool, never()).returnObject(anyObject());
-    verify(timerServicePool, never()).returnObject(anyObject());
-    verifyNoMoreInteractions(mockTransportFactory);
-    channel.shutdown();
-    assertTrue(channel.isShutdown());
-    assertTrue(channel.isTerminated());
-    verify(executorPool).returnObject(executor.getScheduledExecutorService());
-    verify(timerServicePool).returnObject(timer.getScheduledExecutorService());
-  }
-
-  @Test
-  public void callsAndShutdown() {
-    subtestCallsAndShutdown(false, false);
-  }
-
-  @Test
-  public void callsAndShutdownNow() {
-    subtestCallsAndShutdown(true, false);
-  }
-
-  /** Make sure shutdownNow() after shutdown() has an effect. */
-  @Test
-  public void callsAndShutdownAndShutdownNow() {
-    subtestCallsAndShutdown(false, true);
-  }
-
-  private void subtestCallsAndShutdown(boolean shutdownNow, boolean shutdownNowAfterShutdown) {
-    FakeNameResolverFactory nameResolverFactory = new FakeNameResolverFactory(true);
-    createChannel(nameResolverFactory, NO_INTERCEPTOR);
-    verify(executorPool).getObject();
-    verify(timerServicePool).getObject();
-    ClientStream mockStream = mock(ClientStream.class);
-    ClientStream mockStream2 = mock(ClientStream.class);
-    Metadata headers = new Metadata();
-    Metadata headers2 = new Metadata();
-
-    // Configure the picker so that first RPC goes to delayed transport, and second RPC goes to
-    // real transport.
-    Subchannel subchannel = helper.createSubchannel(addressGroup, Attributes.EMPTY);
-    subchannel.requestConnection();
-    verify(mockTransportFactory).newClientTransport(
-        any(SocketAddress.class), any(String.class), any(String.class));
-    MockClientTransportInfo transportInfo = transports.poll();
-    ConnectionClientTransport mockTransport = transportInfo.transport;
-    verify(mockTransport).start(any(ManagedClientTransport.Listener.class));
-    ManagedClientTransport.Listener transportListener = transportInfo.listener;
-    when(mockTransport.newStream(same(method), same(headers), same(CallOptions.DEFAULT),
-            any(StatsTraceContext.class)))
-        .thenReturn(mockStream);
-    when(mockTransport.newStream(same(method), same(headers2), same(CallOptions.DEFAULT),
-            any(StatsTraceContext.class)))
-        .thenReturn(mockStream2);
-    transportListener.transportReady();
-    when(mockPicker.pickSubchannel(any(Attributes.class), same(headers))).thenReturn(
-        PickResult.withNoResult());
-    when(mockPicker.pickSubchannel(any(Attributes.class), same(headers2))).thenReturn(
-        PickResult.withSubchannel(subchannel));
-    helper.updatePicker(mockPicker);
-
-    // First RPC, will be pending
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    verifyNoMoreInteractions(mockTransportFactory);
-    call.start(mockCallListener, headers);
-
-    verify(mockTransport, never()).newStream(same(method), same(headers), same(CallOptions.DEFAULT),
-        any(StatsTraceContext.class));
-    statsCtxFactory.pollContextOrFail();
-
-    // Second RPC, will be assigned to the real transport
-    ClientCall<String, Integer> call2 = channel.newCall(method, CallOptions.DEFAULT);
-    call2.start(mockCallListener2, headers2);
-    verify(mockTransport).newStream(same(method), same(headers2), same(CallOptions.DEFAULT),
-        statsTraceCtxCaptor.capture());
-    assertEquals(statsCtxFactory.pollContextOrFail(),
-        statsTraceCtxCaptor.getValue().getStatsContext());
-    verify(mockTransport).newStream(same(method), same(headers2), same(CallOptions.DEFAULT),
-        statsTraceCtxCaptor.capture());
-    verify(mockStream2).start(any(ClientStreamListener.class));
-
-    // Shutdown
-    if (shutdownNow) {
-      channel.shutdownNow();
-    } else {
-      channel.shutdown();
-      if (shutdownNowAfterShutdown) {
-        channel.shutdownNow();
-        shutdownNow = true;
-      }
-    }
-    assertTrue(channel.isShutdown());
-    assertFalse(channel.isTerminated());
-    assertEquals(1, nameResolverFactory.resolvers.size());
-    verify(mockLoadBalancerFactory).newLoadBalancer(any(Helper.class));
-
-    // Further calls should fail without going to the transport
-    ClientCall<String, Integer> call3 = channel.newCall(method, CallOptions.DEFAULT);
-    call3.start(mockCallListener3, headers2);
-    timer.runDueTasks();
-    executor.runDueTasks();
-
-    verify(mockCallListener3).onClose(statusCaptor.capture(), any(Metadata.class));
-    assertSame(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
-
-    if (shutdownNow) {
-      // LoadBalancer and NameResolver are shut down as soon as delayed transport is terminated.
-      verify(mockLoadBalancer).shutdown();
-      assertTrue(nameResolverFactory.resolvers.get(0).shutdown);
-      // call should have been aborted by delayed transport
-      executor.runDueTasks();
-      verify(mockCallListener).onClose(same(ManagedChannelImpl2.SHUTDOWN_NOW_STATUS),
-          any(Metadata.class));
-    } else {
-      // LoadBalancer and NameResolver are still running.
-      verify(mockLoadBalancer, never()).shutdown();
-      assertFalse(nameResolverFactory.resolvers.get(0).shutdown);
-      // call and call2 are still alive, and can still be assigned to a real transport
-      SubchannelPicker picker2 = mock(SubchannelPicker.class);
-      when(picker2.pickSubchannel(any(Attributes.class), same(headers))).thenReturn(
-          PickResult.withSubchannel(subchannel));
-      helper.updatePicker(picker2);
-      executor.runDueTasks();
-      verify(mockTransport).newStream(same(method), same(headers), same(CallOptions.DEFAULT),
-          any(StatsTraceContext.class));
-      verify(mockStream).start(any(ClientStreamListener.class));
-    }
-
-    // After call is moved out of delayed transport, LoadBalancer, NameResolver and the transports
-    // will be shutdown.
-    verify(mockLoadBalancer).shutdown();
-    assertTrue(nameResolverFactory.resolvers.get(0).shutdown);
-
-    if (shutdownNow) {
-      // Channel shutdownNow() all subchannels after shutting down LoadBalancer
-      verify(mockTransport).shutdownNow(ManagedChannelImpl2.SHUTDOWN_NOW_STATUS);
-    } else {
-      verify(mockTransport, never()).shutdownNow(any(Status.class));
-    }
-    // LoadBalancer should shutdown the subchannel
-    subchannel.shutdown();
-    verify(mockTransport).shutdown();
-
-    // Killing the remaining real transport will terminate the channel
-    transportListener.transportShutdown(Status.UNAVAILABLE);
-    assertFalse(channel.isTerminated());
-    verify(executorPool, never()).returnObject(anyObject());
-    verify(timerServicePool, never()).returnObject(anyObject());
-    transportListener.transportTerminated();
-    assertTrue(channel.isTerminated());
-    verify(executorPool).returnObject(executor.getScheduledExecutorService());
-    verify(timerServicePool).returnObject(timer.getScheduledExecutorService());
-    verifyNoMoreInteractions(oobExecutorPool);
-
-    verify(mockTransportFactory).close();
-    verifyNoMoreInteractions(mockTransportFactory);
-    verify(mockTransport, atLeast(0)).getLogId();
-    verifyNoMoreInteractions(mockTransport);
-  }
-
-  @Test
-  public void shutdownNowWithMultipleOobChannels() {
-  }
-
-  @Test
-  public void interceptor() throws Exception {
-    final AtomicLong atomic = new AtomicLong();
-    ClientInterceptor interceptor = new ClientInterceptor() {
-      @Override
-      public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> interceptCall(
-          MethodDescriptor<RequestT, ResponseT> method, CallOptions callOptions,
-          Channel next) {
-        atomic.set(1);
-        return next.newCall(method, callOptions);
-      }
-    };
-    createChannel(new FakeNameResolverFactory(true), Arrays.asList(interceptor));
-    assertNotNull(channel.newCall(method, CallOptions.DEFAULT));
-    assertEquals(1, atomic.get());
-  }
-
-  @Test
-  public void callOptionsExecutor() {
-    Metadata headers = new Metadata();
-    ClientStream mockStream = mock(ClientStream.class);
-    FakeClock callExecutor = new FakeClock();
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-
-    // Start a call with a call executor
-    CallOptions options =
-        CallOptions.DEFAULT.withExecutor(callExecutor.getScheduledExecutorService());
-    ClientCall<String, Integer> call = channel.newCall(method, options);
-    call.start(mockCallListener, headers);
-
-    // Make the transport available
-    Subchannel subchannel = helper.createSubchannel(addressGroup, Attributes.EMPTY);
-    verify(mockTransportFactory, never()).newClientTransport(
-        any(SocketAddress.class), any(String.class), any(String.class));
-    subchannel.requestConnection();
-    verify(mockTransportFactory).newClientTransport(
-        any(SocketAddress.class), any(String.class), any(String.class));
-    MockClientTransportInfo transportInfo = transports.poll();
-    ConnectionClientTransport mockTransport = transportInfo.transport;
-    ManagedClientTransport.Listener transportListener = transportInfo.listener;
-    when(mockTransport.newStream(same(method), same(headers), any(CallOptions.class),
-            any(StatsTraceContext.class)))
-        .thenReturn(mockStream);
-    transportListener.transportReady();
-    when(mockPicker.pickSubchannel(any(Attributes.class), any(Metadata.class)))
-        .thenReturn(PickResult.withSubchannel(subchannel));
-    assertEquals(0, callExecutor.numPendingTasks());
-    helper.updatePicker(mockPicker);
-
-    // Real streams are started in the call executor if they were previously buffered.
-    assertEquals(1, callExecutor.runDueTasks());
-    verify(mockTransport).newStream(same(method), same(headers), same(options),
-        any(StatsTraceContext.class));
-    verify(mockStream).start(streamListenerCaptor.capture());
-
-    // Call listener callbacks are also run in the call executor
-    ClientStreamListener streamListener = streamListenerCaptor.getValue();
-    Metadata trailers = new Metadata();
-    assertEquals(0, callExecutor.numPendingTasks());
-    streamListener.closed(Status.CANCELLED, trailers);
-    verify(mockCallListener, never()).onClose(same(Status.CANCELLED), same(trailers));
-    assertEquals(1, callExecutor.runDueTasks());
-    verify(mockCallListener).onClose(same(Status.CANCELLED), same(trailers));
-  }
-
-  @Test
-  public void nameResolutionFailed() {
-    Status error = Status.UNAVAILABLE.withCause(new Throwable("fake name resolution error"));
-
-    // Name resolution is started as soon as channel is created.
-    createChannel(new FailingNameResolverFactory(error), NO_INTERCEPTOR);
-    verify(mockLoadBalancer).handleNameResolutionError(same(error));
-  }
-
-  @Test
-  public void nameResolverReturnsEmptySubLists() {
-    String errorDescription = "NameResolver returned an empty list";
-
-    // Pass a FakeNameResolverFactory with an empty list
-    createChannel(new FakeNameResolverFactory(), NO_INTERCEPTOR);
-
-    // LoadBalancer received the error
-    verify(mockLoadBalancerFactory).newLoadBalancer(any(Helper.class));
-    verify(mockLoadBalancer).handleNameResolutionError(statusCaptor.capture());
-    Status status = statusCaptor.getValue();
-    assertSame(Status.Code.UNAVAILABLE, status.getCode());
-    assertEquals(errorDescription, status.getDescription());
-  }
-
-  @Test
-  public void loadBalancerThrowsInHandleResolvedAddresses() {
-    RuntimeException ex = new RuntimeException("simulated");
-    // Delay the success of name resolution until allResolved() is called
-    FakeNameResolverFactory nameResolverFactory = new FakeNameResolverFactory(false);
-    createChannel(nameResolverFactory, NO_INTERCEPTOR);
-
-    verify(mockLoadBalancerFactory).newLoadBalancer(any(Helper.class));
-    doThrow(ex).when(mockLoadBalancer).handleResolvedAddresses(
-        Matchers.<List<ResolvedServerInfoGroup>>anyObject(), any(Attributes.class));
-
-    // NameResolver returns addresses.
-    nameResolverFactory.allResolved();
-
-    // The LoadBalancer will receive the error that it has thrown.
-    verify(mockLoadBalancer).handleNameResolutionError(statusCaptor.capture());
-    Status status = statusCaptor.getValue();
-    assertSame(Status.Code.INTERNAL, status.getCode());
-    assertSame(ex, status.getCause());
-  }
-
-  @Test
-  public void nameResolvedAfterChannelShutdown() {
-    // Delay the success of name resolution until allResolved() is called.
-    FakeNameResolverFactory nameResolverFactory = new FakeNameResolverFactory(false);
-    createChannel(nameResolverFactory, NO_INTERCEPTOR);
-
-    channel.shutdown();
-
-    assertTrue(channel.isShutdown());
-    assertTrue(channel.isTerminated());
-    verify(mockLoadBalancer).shutdown();
-    // Name resolved after the channel is shut down, which is possible if the name resolution takes
-    // time and is not cancellable. The resolved address will be dropped.
-    nameResolverFactory.allResolved();
-    verifyNoMoreInteractions(mockLoadBalancer);
-  }
-
-  /**
-   * Verify that if the first resolved address points to a server that cannot be connected, the call
-   * will end up with the second address which works.
-   */
-  @Test
-  public void firstResolvedServerFailedToConnect() throws Exception {
-    final SocketAddress goodAddress = new SocketAddress() {
-        @Override public String toString() {
-          return "goodAddress";
-        }
-      };
-    final SocketAddress badAddress = new SocketAddress() {
-        @Override public String toString() {
-          return "badAddress";
-        }
-      };
-    final ResolvedServerInfo goodServer = new ResolvedServerInfo(goodAddress, Attributes.EMPTY);
-    final ResolvedServerInfo badServer = new ResolvedServerInfo(badAddress, Attributes.EMPTY);
-    InOrder inOrder = inOrder(mockLoadBalancer);
-
-    ResolvedServerInfoGroup serverInfoGroup = ResolvedServerInfoGroup.builder()
-        .add(badServer)
-        .add(goodServer)
-        .build();
-    FakeNameResolverFactory nameResolverFactory =
-        new FakeNameResolverFactory(serverInfoGroup.getResolvedServerInfoList());
-    createChannel(nameResolverFactory, NO_INTERCEPTOR);
-
-    // Start the call
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    Metadata headers = new Metadata();
-    call.start(mockCallListener, headers);
-    executor.runDueTasks();
-
-    // Simulate name resolution results
-    inOrder.verify(mockLoadBalancer).handleResolvedAddresses(
-        eq(Arrays.asList(serverInfoGroup)), eq(Attributes.EMPTY));
-    Subchannel subchannel = helper.createSubchannel(
-        serverInfoGroup.toEquivalentAddressGroup(), Attributes.EMPTY);
-    when(mockPicker.pickSubchannel(any(Attributes.class), any(Metadata.class)))
-        .thenReturn(PickResult.withSubchannel(subchannel));
-    subchannel.requestConnection();
-    inOrder.verify(mockLoadBalancer).handleSubchannelState(
-        same(subchannel), stateInfoCaptor.capture());
-    assertEquals(CONNECTING, stateInfoCaptor.getValue().getState());
-
-    // The channel will starts with the first address (badAddress)
-    verify(mockTransportFactory)
-        .newClientTransport(same(badAddress), any(String.class), any(String.class));
-    verify(mockTransportFactory, times(0))
-          .newClientTransport(same(goodAddress), any(String.class), any(String.class));
-
-    MockClientTransportInfo badTransportInfo = transports.poll();
-    // Which failed to connect
-    badTransportInfo.listener.transportShutdown(Status.UNAVAILABLE);
-    inOrder.verifyNoMoreInteractions();
-
-    // The channel then try the second address (goodAddress)
-    verify(mockTransportFactory)
-          .newClientTransport(same(goodAddress), any(String.class), any(String.class));
-    MockClientTransportInfo goodTransportInfo = transports.poll();
-    when(goodTransportInfo.transport.newStream(
-            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
-            any(StatsTraceContext.class)))
-        .thenReturn(mock(ClientStream.class));
-
-    goodTransportInfo.listener.transportReady();
-    inOrder.verify(mockLoadBalancer).handleSubchannelState(
-        same(subchannel), stateInfoCaptor.capture());
-    assertEquals(READY, stateInfoCaptor.getValue().getState());
-
-    // A typical LoadBalancer will call this once the subchannel becomes READY
-    helper.updatePicker(mockPicker);
-    // Delayed transport uses the app executor to create real streams.
-    executor.runDueTasks();
-
-    verify(goodTransportInfo.transport).newStream(same(method), same(headers),
-        same(CallOptions.DEFAULT), any(StatsTraceContext.class));
-    // The bad transport was never used.
-    verify(badTransportInfo.transport, times(0)).newStream(any(MethodDescriptor.class),
-        any(Metadata.class), any(CallOptions.class), any(StatsTraceContext.class));
-  }
-
-  /**
-   * Verify that if all resolved addresses failed to connect, a fail-fast call will fail, while a
-   * wait-for-ready call will still be buffered.
-   */
-  @Test
-  public void allServersFailedToConnect() throws Exception {
-    final SocketAddress addr1 = new SocketAddress() {
-        @Override public String toString() {
-          return "addr1";
-        }
-      };
-    final SocketAddress addr2 = new SocketAddress() {
-        @Override public String toString() {
-          return "addr2";
-        }
-      };
-    final ResolvedServerInfo server1 = new ResolvedServerInfo(addr1, Attributes.EMPTY);
-    final ResolvedServerInfo server2 = new ResolvedServerInfo(addr2, Attributes.EMPTY);
-    InOrder inOrder = inOrder(mockLoadBalancer);
-
-    ResolvedServerInfoGroup serverInfoGroup = ResolvedServerInfoGroup.builder()
-        .add(server1)
-        .add(server2)
-        .build();
-
-    FakeNameResolverFactory nameResolverFactory =
-        new FakeNameResolverFactory(serverInfoGroup.getResolvedServerInfoList());
-    createChannel(nameResolverFactory, NO_INTERCEPTOR);
-
-    // Start a wait-for-ready call
-    ClientCall<String, Integer> call =
-        channel.newCall(method, CallOptions.DEFAULT.withWaitForReady());
-    Metadata headers = new Metadata();
-    call.start(mockCallListener, headers);
-    // ... and a fail-fast call
-    ClientCall<String, Integer> call2 =
-        channel.newCall(method, CallOptions.DEFAULT.withoutWaitForReady());
-    call2.start(mockCallListener2, headers);
-    executor.runDueTasks();
-
-    // Simulate name resolution results
-    inOrder.verify(mockLoadBalancer).handleResolvedAddresses(
-        eq(Arrays.asList(serverInfoGroup)), eq(Attributes.EMPTY));
-    Subchannel subchannel = helper.createSubchannel(
-        serverInfoGroup.toEquivalentAddressGroup(), Attributes.EMPTY);
-    when(mockPicker.pickSubchannel(any(Attributes.class), any(Metadata.class)))
-        .thenReturn(PickResult.withSubchannel(subchannel));
-    subchannel.requestConnection();
-    inOrder.verify(mockLoadBalancer).handleSubchannelState(
-        same(subchannel), stateInfoCaptor.capture());
-    assertEquals(CONNECTING, stateInfoCaptor.getValue().getState());
-
-    // Connecting to server1, which will fail
-    verify(mockTransportFactory)
-        .newClientTransport(same(addr1), any(String.class), any(String.class));
-    verify(mockTransportFactory, times(0))
-        .newClientTransport(same(addr2), any(String.class), any(String.class));
-    MockClientTransportInfo transportInfo1 = transports.poll();
-    transportInfo1.listener.transportShutdown(Status.UNAVAILABLE);
-
-    // Connecting to server2, which will fail too
-    verify(mockTransportFactory)
-        .newClientTransport(same(addr2), any(String.class), any(String.class));
-    MockClientTransportInfo transportInfo2 = transports.poll();
-    Status server2Error = Status.UNAVAILABLE.withDescription("Server2 failed to connect");
-    transportInfo2.listener.transportShutdown(server2Error);
-
-    // ... which makes the subchannel enter TRANSIENT_FAILURE. The last error Status is propagated
-    // to LoadBalancer.
-    inOrder.verify(mockLoadBalancer).handleSubchannelState(
-        same(subchannel), stateInfoCaptor.capture());
-    assertEquals(TRANSIENT_FAILURE, stateInfoCaptor.getValue().getState());
-    assertSame(server2Error, stateInfoCaptor.getValue().getStatus());
-
-    // A typical LoadBalancer would create a picker with error
-    SubchannelPicker picker2 = mock(SubchannelPicker.class);
-    when(picker2.pickSubchannel(any(Attributes.class), any(Metadata.class)))
-        .thenReturn(PickResult.withError(server2Error));
-    helper.updatePicker(picker2);
-    executor.runDueTasks();
-
-    // ... which fails the fail-fast call
-    verify(mockCallListener2).onClose(same(server2Error), any(Metadata.class));
-    // ... while the wait-for-ready call stays
-    verifyNoMoreInteractions(mockCallListener);
-    // No real stream was ever created
-    verify(transportInfo1.transport, times(0))
-        .newStream(any(MethodDescriptor.class), any(Metadata.class));
-    verify(transportInfo2.transport, times(0))
-        .newStream(any(MethodDescriptor.class), any(Metadata.class));
-  }
-
-  @Test
-  public void subchannels() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-
-    // createSubchannel() always return a new Subchannel
-    Attributes attrs1 = Attributes.newBuilder().set(SUBCHANNEL_ATTR_KEY, "attr1").build();
-    Attributes attrs2 = Attributes.newBuilder().set(SUBCHANNEL_ATTR_KEY, "attr2").build();
-    Subchannel sub1 = helper.createSubchannel(addressGroup, attrs1);
-    Subchannel sub2 = helper.createSubchannel(addressGroup, attrs2);
-    assertNotSame(sub1, sub2);
-    assertNotSame(attrs1, attrs2);
-    assertSame(attrs1, sub1.getAttributes());
-    assertSame(attrs2, sub2.getAttributes());
-    assertSame(addressGroup, sub1.getAddresses());
-    assertSame(addressGroup, sub2.getAddresses());
-
-    // requestConnection()
-    verify(mockTransportFactory, never()).newClientTransport(
-        any(SocketAddress.class), any(String.class), any(String.class));
-    sub1.requestConnection();
-    verify(mockTransportFactory).newClientTransport(socketAddress, authority, userAgent);
-    MockClientTransportInfo transportInfo1 = transports.poll();
-    assertNotNull(transportInfo1);
-
-    sub2.requestConnection();
-    verify(mockTransportFactory, times(2)).newClientTransport(socketAddress, authority, userAgent);
-    MockClientTransportInfo transportInfo2 = transports.poll();
-    assertNotNull(transportInfo2);
-
-    sub1.requestConnection();
-    sub2.requestConnection();
-    verify(mockTransportFactory, times(2)).newClientTransport(socketAddress, authority, userAgent);
-
-    // shutdown() has a delay
-    sub1.shutdown();
-    timer.forwardTime(ManagedChannelImpl2.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS - 1, TimeUnit.SECONDS);
-    sub1.shutdown();
-    verify(transportInfo1.transport, never()).shutdown();
-    timer.forwardTime(1, TimeUnit.SECONDS);
-    verify(transportInfo1.transport).shutdown();
-
-    // ... but not after Channel is terminating
-    verify(mockLoadBalancer, never()).shutdown();
-    channel.shutdown();
-    verify(mockLoadBalancer).shutdown();
-    verify(transportInfo2.transport, never()).shutdown();
-
-    sub2.shutdown();
-    verify(transportInfo2.transport).shutdown();
-  }
-
-  @Test
-  public void subchannelsWhenChannelShutdownNow() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    Subchannel sub1 = helper.createSubchannel(addressGroup, Attributes.EMPTY);
-    Subchannel sub2 = helper.createSubchannel(addressGroup, Attributes.EMPTY);
-    sub1.requestConnection();
-    sub2.requestConnection();
-
-    assertEquals(2, transports.size());
-    MockClientTransportInfo ti1 = transports.poll();
-    MockClientTransportInfo ti2 = transports.poll();
-
-    ti1.listener.transportReady();
-    ti2.listener.transportReady();
-
-    channel.shutdownNow();
-    verify(ti1.transport).shutdownNow(any(Status.class));
-    verify(ti2.transport).shutdownNow(any(Status.class));
-
-    ti1.listener.transportShutdown(Status.UNAVAILABLE.withDescription("shutdown now"));
-    ti2.listener.transportShutdown(Status.UNAVAILABLE.withDescription("shutdown now"));
-    ti1.listener.transportTerminated();
-
-    assertFalse(channel.isTerminated());
-    ti2.listener.transportTerminated();
-    assertTrue(channel.isTerminated());
-  }
-
-  @Test
-  public void subchannelsNoConnectionShutdown() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    Subchannel sub1 = helper.createSubchannel(addressGroup, Attributes.EMPTY);
-    Subchannel sub2 = helper.createSubchannel(addressGroup, Attributes.EMPTY);
-
-    channel.shutdown();
-    verify(mockLoadBalancer).shutdown();
-    sub1.shutdown();
-    assertFalse(channel.isTerminated());
-    sub2.shutdown();
-    assertTrue(channel.isTerminated());
-    verify(mockTransportFactory, never()).newClientTransport(any(SocketAddress.class), anyString(),
-        anyString());
-  }
-
-  @Test
-  public void subchannelsNoConnectionShutdownNow() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    helper.createSubchannel(addressGroup, Attributes.EMPTY);
-    helper.createSubchannel(addressGroup, Attributes.EMPTY);
-    channel.shutdownNow();
-
-    verify(mockLoadBalancer).shutdown();
-    // Channel's shutdownNow() will call shutdownNow() on all subchannels and oobchannels.
-    // Therefore, channel is terminated without relying on LoadBalancer to shutdown subchannels.
-    assertTrue(channel.isTerminated());
-    verify(mockTransportFactory, never()).newClientTransport(any(SocketAddress.class), anyString(),
-        anyString());
-  }
-
-  @Test
-  public void oobchannels() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-
-    ManagedChannel oob1 = helper.createOobChannel(addressGroup, "oob1authority");
-    ManagedChannel oob2 = helper.createOobChannel(addressGroup, "oob2authority");
-    verify(oobExecutorPool, times(2)).getObject();
-
-    assertEquals("oob1authority", oob1.authority());
-    assertEquals("oob2authority", oob2.authority());
-
-    // OOB channels create connections lazily.  A new call will initiate the connection.
-    Metadata headers = new Metadata();
-    ClientCall<String, Integer> call = oob1.newCall(method, CallOptions.DEFAULT);
-    call.start(mockCallListener, headers);
-    verify(mockTransportFactory).newClientTransport(socketAddress, "oob1authority", userAgent);
-    MockClientTransportInfo transportInfo = transports.poll();
-    assertNotNull(transportInfo);
-
-    assertEquals(0, oobExecutor.numPendingTasks());
-    transportInfo.listener.transportReady();
-    assertEquals(1, oobExecutor.runDueTasks());
-    verify(transportInfo.transport).newStream(same(method), same(headers),
-        same(CallOptions.DEFAULT), any(StatsTraceContext.class));
-
-    // The transport goes away
-    transportInfo.listener.transportShutdown(Status.UNAVAILABLE);
-    transportInfo.listener.transportTerminated();
-
-    // A new call will trigger a new transport
-    ClientCall<String, Integer> call2 = oob1.newCall(method, CallOptions.DEFAULT);
-    call2.start(mockCallListener2, headers);
-    ClientCall<String, Integer> call3 =
-        oob1.newCall(method, CallOptions.DEFAULT.withWaitForReady());
-    call3.start(mockCallListener3, headers);
-    verify(mockTransportFactory, times(2)).newClientTransport(
-        socketAddress, "oob1authority", userAgent);
-    transportInfo = transports.poll();
-    assertNotNull(transportInfo);
-
-    // This transport fails
-    Status transportError = Status.UNAVAILABLE.withDescription("Connection refused");
-    assertEquals(0, oobExecutor.numPendingTasks());
-    transportInfo.listener.transportShutdown(transportError);
-    assertTrue(oobExecutor.runDueTasks() > 0);
-
-    // Fail-fast RPC will fail, while wait-for-ready RPC will still be pending
-    verify(mockCallListener2).onClose(same(transportError), any(Metadata.class));
-    verify(mockCallListener3, never()).onClose(any(Status.class), any(Metadata.class));
-
-    // Shutdown
-    assertFalse(oob1.isShutdown());
-    assertFalse(oob2.isShutdown());
-    oob1.shutdown();
-    verify(oobExecutorPool, never()).returnObject(anyObject());
-    oob2.shutdownNow();
-    assertTrue(oob1.isShutdown());
-    assertTrue(oob2.isShutdown());
-    assertTrue(oob2.isTerminated());
-    verify(oobExecutorPool).returnObject(oobExecutor.getScheduledExecutorService());
-
-    // New RPCs will be rejected.
-    assertEquals(0, oobExecutor.numPendingTasks());
-    ClientCall<String, Integer> call4 = oob1.newCall(method, CallOptions.DEFAULT);
-    ClientCall<String, Integer> call5 = oob2.newCall(method, CallOptions.DEFAULT);
-    call4.start(mockCallListener4, headers);
-    call5.start(mockCallListener5, headers);
-    assertTrue(oobExecutor.runDueTasks() > 0);
-    verify(mockCallListener4).onClose(statusCaptor.capture(), any(Metadata.class));
-    Status status4 = statusCaptor.getValue();
-    assertEquals(Status.Code.UNAVAILABLE, status4.getCode());
-    verify(mockCallListener5).onClose(statusCaptor.capture(), any(Metadata.class));
-    Status status5 = statusCaptor.getValue();
-    assertEquals(Status.Code.UNAVAILABLE, status5.getCode());
-
-    // The pending RPC will still be pending
-    verify(mockCallListener3, never()).onClose(any(Status.class), any(Metadata.class));
-
-    // This will shutdownNow() the delayed transport, terminating the pending RPC
-    assertEquals(0, oobExecutor.numPendingTasks());
-    oob1.shutdownNow();
-    assertTrue(oobExecutor.runDueTasks() > 0);
-    verify(mockCallListener3).onClose(any(Status.class), any(Metadata.class));
-
-    // Shut down the channel, and it will not terminated because OOB channel has not.
-    channel.shutdown();
-    assertFalse(channel.isTerminated());
-    // Delayed transport has already terminated.  Terminating the transport terminates the
-    // subchannel, which in turn terimates the OOB channel, which terminates the channel.
-    assertFalse(oob1.isTerminated());
-    verify(oobExecutorPool).returnObject(oobExecutor.getScheduledExecutorService());
-    transportInfo.listener.transportTerminated();
-    assertTrue(oob1.isTerminated());
-    assertTrue(channel.isTerminated());
-    verify(oobExecutorPool, times(2)).returnObject(oobExecutor.getScheduledExecutorService());
-  }
-
-  @Test
-  public void oobChannelsWhenChannelShutdownNow() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    ManagedChannel oob1 = helper.createOobChannel(addressGroup, "oob1Authority");
-    ManagedChannel oob2 = helper.createOobChannel(addressGroup, "oob2Authority");
-
-    oob1.newCall(method, CallOptions.DEFAULT).start(mockCallListener, new Metadata());
-    oob2.newCall(method, CallOptions.DEFAULT).start(mockCallListener2, new Metadata());
-
-    assertEquals(2, transports.size());
-    MockClientTransportInfo ti1 = transports.poll();
-    MockClientTransportInfo ti2 = transports.poll();
-
-    ti1.listener.transportReady();
-    ti2.listener.transportReady();
-
-    channel.shutdownNow();
-    verify(ti1.transport).shutdownNow(any(Status.class));
-    verify(ti2.transport).shutdownNow(any(Status.class));
-
-    ti1.listener.transportShutdown(Status.UNAVAILABLE.withDescription("shutdown now"));
-    ti2.listener.transportShutdown(Status.UNAVAILABLE.withDescription("shutdown now"));
-    ti1.listener.transportTerminated();
-
-    assertFalse(channel.isTerminated());
-    ti2.listener.transportTerminated();
-    assertTrue(channel.isTerminated());
-  }
-
-  @Test
-  public void oobChannelsNoConnectionShutdown() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    ManagedChannel oob1 = helper.createOobChannel(addressGroup, "oob1Authority");
-    ManagedChannel oob2 = helper.createOobChannel(addressGroup, "oob2Authority");
-    channel.shutdown();
-
-    verify(mockLoadBalancer).shutdown();
-    oob1.shutdown();
-    assertTrue(oob1.isTerminated());
-    assertFalse(channel.isTerminated());
-    oob2.shutdown();
-    assertTrue(oob2.isTerminated());
-    assertTrue(channel.isTerminated());
-    verify(mockTransportFactory, never()).newClientTransport(any(SocketAddress.class), anyString(),
-        anyString());
-  }
-
-  @Test
-  public void oobChannelsNoConnectionShutdownNow() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    helper.createOobChannel(addressGroup, "oob1Authority");
-    helper.createOobChannel(addressGroup, "oob2Authority");
-    channel.shutdownNow();
-
-    verify(mockLoadBalancer).shutdown();
-    assertTrue(channel.isTerminated());
-    // Channel's shutdownNow() will call shutdownNow() on all subchannels and oobchannels.
-    // Therefore, channel is terminated without relying on LoadBalancer to shutdown oobchannels.
-    verify(mockTransportFactory, never()).newClientTransport(any(SocketAddress.class), anyString(),
-        anyString());
-  }
-
-  @Test
-  public void uriPattern() {
-    assertTrue(ManagedChannelImpl2.URI_PATTERN.matcher("a:/").matches());
-    assertTrue(ManagedChannelImpl2.URI_PATTERN.matcher("Z019+-.:/!@ #~ ").matches());
-    assertFalse(ManagedChannelImpl2.URI_PATTERN.matcher("a/:").matches()); // "/:" not matched
-    assertFalse(ManagedChannelImpl2.URI_PATTERN.matcher("0a:/").matches()); // '0' not matched
-    assertFalse(ManagedChannelImpl2.URI_PATTERN.matcher("a,:/").matches()); // ',' not matched
-    assertFalse(ManagedChannelImpl2.URI_PATTERN.matcher(" a:/").matches()); // space not matched
-  }
-
-  /**
-   * Test that information such as the Call's context, MethodDescriptor, authority, executor are
-   * propagated to newStream() and applyRequestMetadata().
-   */
-  @Test
-  public void informationPropagatedToNewStreamAndCallCredentials() {
-    ResolvedServerInfoGroup serverInfoGroup = ResolvedServerInfoGroup.builder()
-        .add(server).build();
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    CallOptions callOptions = CallOptions.DEFAULT.withCallCredentials(creds);
-    final Context.Key<String> testKey = Context.key("testing");
-    Context ctx = Context.current().withValue(testKey, "testValue");
-    final LinkedList<Context> credsApplyContexts = new LinkedList<Context>();
-    final LinkedList<Context> newStreamContexts = new LinkedList<Context>();
-    doAnswer(new Answer<Void>() {
-        @Override
-        public Void answer(InvocationOnMock in) throws Throwable {
-          credsApplyContexts.add(Context.current());
-          return null;
-        }
-      }).when(creds).applyRequestMetadata(
-          any(MethodDescriptor.class), any(Attributes.class), any(Executor.class),
-          any(MetadataApplier.class));
-
-    // First call will be on delayed transport.  Only newCall() is run within the expected context,
-    // so that we can verify that the context is explicitly attached before calling newStream() and
-    // applyRequestMetadata(), which happens after we detach the context from the thread.
-    Context origCtx = ctx.attach();
-    assertEquals("testValue", testKey.get());
-    ClientCall<String, Integer> call = channel.newCall(method, callOptions);
-    ctx.detach(origCtx);
-    assertNull(testKey.get());
-    call.start(mockCallListener, new Metadata());
-
-    // Simulate name resolution results
-    Subchannel subchannel = helper.createSubchannel(
-        serverInfoGroup.toEquivalentAddressGroup(), Attributes.EMPTY);
-    subchannel.requestConnection();
-    verify(mockTransportFactory).newClientTransport(
-        same(socketAddress), eq(authority), eq(userAgent));
-    MockClientTransportInfo transportInfo = transports.poll();
-    final ConnectionClientTransport transport = transportInfo.transport;
-    when(transport.getAttributes()).thenReturn(Attributes.EMPTY);
-    doAnswer(new Answer<ClientStream>() {
-        @Override
-        public ClientStream answer(InvocationOnMock in) throws Throwable {
-          newStreamContexts.add(Context.current());
-          return mock(ClientStream.class);
-        }
-      }).when(transport).newStream(
-          any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
-          any(StatsTraceContext.class));
-
-    verify(creds, never()).applyRequestMetadata(
-        any(MethodDescriptor.class), any(Attributes.class), any(Executor.class),
-        any(MetadataApplier.class));
-
-    // applyRequestMetadata() is called after the transport becomes ready.
-    transportInfo.listener.transportReady();
-    when(mockPicker.pickSubchannel(any(Attributes.class), any(Metadata.class)))
-        .thenReturn(PickResult.withSubchannel(subchannel));
-    helper.updatePicker(mockPicker);
-    executor.runDueTasks();
-    ArgumentCaptor<Attributes> attrsCaptor = ArgumentCaptor.forClass(Attributes.class);
-    ArgumentCaptor<MetadataApplier> applierCaptor = ArgumentCaptor.forClass(MetadataApplier.class);
-    verify(creds).applyRequestMetadata(same(method), attrsCaptor.capture(),
-        same(executor.getScheduledExecutorService()), applierCaptor.capture());
-    assertEquals("testValue", testKey.get(credsApplyContexts.poll()));
-    assertEquals(authority, attrsCaptor.getValue().get(CallCredentials.ATTR_AUTHORITY));
-    assertEquals(SecurityLevel.NONE,
-        attrsCaptor.getValue().get(CallCredentials.ATTR_SECURITY_LEVEL));
-    verify(transport, never()).newStream(
-        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
-        any(StatsTraceContext.class));
-
-    // newStream() is called after apply() is called
-    applierCaptor.getValue().apply(new Metadata());
-    verify(transport).newStream(same(method), any(Metadata.class), same(callOptions),
-        any(StatsTraceContext.class));
-    assertEquals("testValue", testKey.get(newStreamContexts.poll()));
-    // The context should not live beyond the scope of newStream() and applyRequestMetadata()
-    assertNull(testKey.get());
-
-
-    // Second call will not be on delayed transport
-    origCtx = ctx.attach();
-    call = channel.newCall(method, callOptions);
-    ctx.detach(origCtx);
-    call.start(mockCallListener, new Metadata());
-
-    verify(creds, times(2)).applyRequestMetadata(same(method), attrsCaptor.capture(),
-        same(executor.getScheduledExecutorService()), applierCaptor.capture());
-    assertEquals("testValue", testKey.get(credsApplyContexts.poll()));
-    assertEquals(authority, attrsCaptor.getValue().get(CallCredentials.ATTR_AUTHORITY));
-    assertEquals(SecurityLevel.NONE,
-        attrsCaptor.getValue().get(CallCredentials.ATTR_SECURITY_LEVEL));
-    // This is from the first call
-    verify(transport).newStream(
-        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
-        any(StatsTraceContext.class));
-
-    // Still, newStream() is called after apply() is called
-    applierCaptor.getValue().apply(new Metadata());
-    verify(transport, times(2)).newStream(same(method), any(Metadata.class), same(callOptions),
-        any(StatsTraceContext.class));
-    assertEquals("testValue", testKey.get(newStreamContexts.poll()));
-
-    assertNull(testKey.get());
-  }
-
-  private static class FakeBackoffPolicyProvider implements BackoffPolicy.Provider {
-    @Override
-    public BackoffPolicy get() {
-      return new BackoffPolicy() {
-        @Override
-        public long nextBackoffMillis() {
-          return 1;
-        }
-      };
-    }
-  }
-
-  private class FakeNameResolverFactory extends NameResolver.Factory {
-    final List<ResolvedServerInfoGroup> servers;
-    final boolean resolvedAtStart;
-    final ArrayList<FakeNameResolver> resolvers = new ArrayList<FakeNameResolver>();
-
-    FakeNameResolverFactory(boolean resolvedAtStart) {
-      this.resolvedAtStart = resolvedAtStart;
-      servers = Collections.singletonList(ResolvedServerInfoGroup.builder().add(server).build());
-    }
-
-    FakeNameResolverFactory(List<ResolvedServerInfo> servers) {
-      resolvedAtStart = true;
-      this.servers = Collections.singletonList(
-          ResolvedServerInfoGroup.builder().addAll(servers).build());
-    }
-
-    public FakeNameResolverFactory() {
-      resolvedAtStart = true;
-      this.servers = ImmutableList.of();
-    }
-
-    @Override
-    public NameResolver newNameResolver(final URI targetUri, Attributes params) {
-      if (!expectedUri.equals(targetUri)) {
-        return null;
-      }
-      assertSame(NAME_RESOLVER_PARAMS, params);
-      FakeNameResolver resolver = new FakeNameResolver();
-      resolvers.add(resolver);
-      return resolver;
-    }
-
-    @Override
-    public String getDefaultScheme() {
-      return "fake";
-    }
-
-    void allResolved() {
-      for (FakeNameResolver resolver : resolvers) {
-        resolver.resolved();
-      }
-    }
-
-    private class FakeNameResolver extends NameResolver {
-      Listener listener;
-      boolean shutdown;
-
-      @Override public String getServiceAuthority() {
-        return expectedUri.getAuthority();
-      }
-
-      @Override public void start(final Listener listener) {
-        this.listener = listener;
-        if (resolvedAtStart) {
-          resolved();
-        }
-      }
-
-      void resolved() {
-        listener.onUpdate(servers, Attributes.EMPTY);
-      }
-
-      @Override public void shutdown() {
-        shutdown = true;
-      }
-    }
-  }
-
-  private static class FailingNameResolverFactory extends NameResolver.Factory {
-    final Status error;
-
-    FailingNameResolverFactory(Status error) {
-      this.error = error;
-    }
-
-    @Override
-    public NameResolver newNameResolver(URI notUsedUri, Attributes params) {
-      return new NameResolver() {
-        @Override public String getServiceAuthority() {
-          return "irrelevant-authority";
-        }
-
-        @Override public void start(final Listener listener) {
-          listener.onError(error);
-        }
-
-        @Override public void shutdown() {}
-      };
-    }
-
-    @Override
-    public String getDefaultScheme() {
-      return "fake";
-    }
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelImplBuilderTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelImplBuilderTest.java
new file mode 100644
index 00000000000..8bf10de3949
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelImplBuilderTest.java
@@ -0,0 +1,801 @@
+/*
+ * 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static junit.framework.TestCase.assertFalse;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.CompressorRegistry;
+import io.grpc.DecompressorRegistry;
+import io.grpc.InternalConfigurator;
+import io.grpc.InternalConfiguratorRegistry;
+import io.grpc.InternalManagedChannelBuilder.InternalInterceptorFactory;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.MethodDescriptor;
+import io.grpc.MetricSink;
+import io.grpc.NameResolver;
+import io.grpc.NameResolverRegistry;
+import io.grpc.StaticTestingClassLoader;
+import io.grpc.internal.ManagedChannelImplBuilder.ChannelBuilderDefaultPortProvider;
+import io.grpc.internal.ManagedChannelImplBuilder.ClientTransportFactoryBuilder;
+import io.grpc.internal.ManagedChannelImplBuilder.FixedPortProvider;
+import io.grpc.internal.ManagedChannelImplBuilder.UnsupportedClientTransportFactoryBuilder;
+import io.grpc.testing.GrpcCleanupRule;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for {@link ManagedChannelImplBuilder}. */
+@RunWith(Parameterized.class)
+public class ManagedChannelImplBuilderTest {
+  private static final int DUMMY_PORT = 42;
+  private static final String DUMMY_TARGET = "fake-target";
+  private static final String DUMMY_AUTHORITY_VALID = "valid:1234";
+  private static final String DUMMY_AUTHORITY_INVALID = "[ : : 1]";
+  private static final ClientInterceptor DUMMY_USER_INTERCEPTOR =
+      new ClientInterceptor() {
+        @Override
+        public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+            MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+          return next.newCall(method, callOptions);
+        }
+      };
+  private static final ClientInterceptor DUMMY_USER_INTERCEPTOR1 =
+      new ClientInterceptor() {
+        @Override
+        public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+            MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+          return next.newCall(method, callOptions);
+        }
+      };
+
+  @Parameters(name = "enableRfc3986UrisParam={0}")
+  public static Iterable<Object[]> data() {
+    return Arrays.asList(new Object[][] {{true}, {false}});
+  }
+
+  @Parameter public boolean enableRfc3986UrisParam;
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+  @Rule public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
+  @Rule public final FlagResetRule flagResetRule = new FlagResetRule();
+
+  @Mock private ClientTransportFactory mockClientTransportFactory;
+  @Mock private ClientTransportFactoryBuilder mockClientTransportFactoryBuilder;
+
+  private ManagedChannelImplBuilder builder;
+  private ManagedChannelImplBuilder directAddressBuilder;
+  private final FakeClock clock = new FakeClock();
+  private final StaticTestingClassLoader classLoader =
+      new StaticTestingClassLoader(
+          getClass().getClassLoader(),
+          Pattern.compile(
+              "io\\.grpc\\.InternalConfigurator|io\\.grpc\\.Configurator|"
+                  + "io\\.grpc\\.InternalConfiguratorRegistry|io\\.grpc\\.ConfiguratorRegistry|"
+                  + "io\\.grpc\\.internal\\.[^.]+"));
+
+  @Before
+  public void setUp() throws Exception {
+    flagResetRule.setFlagForTest(
+        ManagedChannelImplBuilder::setRfc3986UrisEnabled, enableRfc3986UrisParam);
+
+    builder = new ManagedChannelImplBuilder(
+        DUMMY_TARGET,
+        new UnsupportedClientTransportFactoryBuilder(),
+        new FixedPortProvider(DUMMY_PORT));
+    directAddressBuilder = new ManagedChannelImplBuilder(
+        new SocketAddress() {},
+        DUMMY_TARGET,
+        new UnsupportedClientTransportFactoryBuilder(),
+        new FixedPortProvider(DUMMY_PORT));
+  }
+
+  /** Ensure getDefaultPort() returns default port when no custom implementation provided. */
+  @Test
+  public void getDefaultPort_default() {
+    builder = new ManagedChannelImplBuilder(DUMMY_TARGET,
+        new UnsupportedClientTransportFactoryBuilder(), null);
+    assertEquals(GrpcUtil.DEFAULT_PORT_SSL, builder.getDefaultPort());
+  }
+
+  /** Ensure getDefaultPort() delegates to the custom implementation. */
+  @Test
+  public void getDefaultPort_custom() {
+    int customPort = 43;
+    ChannelBuilderDefaultPortProvider mockChannelBuilderDefaultPortProvider = mock(
+        ChannelBuilderDefaultPortProvider.class);
+    when(mockChannelBuilderDefaultPortProvider.getDefaultPort()).thenReturn(customPort);
+
+    builder = new ManagedChannelImplBuilder(DUMMY_TARGET,
+        new UnsupportedClientTransportFactoryBuilder(),
+        mockChannelBuilderDefaultPortProvider);
+    assertEquals(customPort, builder.getDefaultPort());
+    verify(mockChannelBuilderDefaultPortProvider).getDefaultPort();
+  }
+
+  /** Test FixedPortProvider(int port). */
+  @Test
+  public void getDefaultPort_fixedPortProvider() {
+    int fixedPort = 43;
+    builder = new ManagedChannelImplBuilder(DUMMY_TARGET,
+        new UnsupportedClientTransportFactoryBuilder(), new FixedPortProvider(fixedPort));
+    assertEquals(fixedPort, builder.getDefaultPort());
+  }
+
+  @Test
+  public void executor_default() {
+    assertNotNull(builder.executorPool);
+  }
+
+  @Test
+  public void executor_normal() {
+    Executor executor = mock(Executor.class);
+    assertSame(builder, builder.executor(executor));
+    assertSame(executor, builder.executorPool.getObject());
+  }
+
+  @Test
+  public void executor_null() {
+    ObjectPool<? extends Executor> defaultValue = builder.executorPool;
+    builder.executor(mock(Executor.class));
+    assertSame(builder, builder.executor(null));
+    assertSame(defaultValue, builder.executorPool);
+  }
+
+  @Test
+  public void directExecutor() {
+    assertSame(builder, builder.directExecutor());
+    assertEquals(MoreExecutors.directExecutor(), builder.executorPool.getObject());
+  }
+
+  @Test
+  public void offloadExecutor_normal() {
+    Executor executor = mock(Executor.class);
+    assertSame(builder, builder.offloadExecutor(executor));
+    assertSame(executor, builder.offloadExecutorPool.getObject());
+  }
+
+  @Test
+  public void offloadExecutor_null() {
+    ObjectPool<? extends Executor> defaultValue = builder.offloadExecutorPool;
+    builder.offloadExecutor(mock(Executor.class));
+    assertSame(builder, builder.offloadExecutor(null));
+    assertSame(defaultValue, builder.offloadExecutorPool);
+  }
+
+  @Test
+  public void nameResolverRegistry_default() {
+    assertNotNull(builder.nameResolverRegistry);
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void nameResolverFactory_normal() {
+    NameResolver.Factory nameResolverFactory = mock(NameResolver.Factory.class);
+    doReturn("testscheme").when(nameResolverFactory).getDefaultScheme();
+    assertSame(builder, builder.nameResolverFactory(nameResolverFactory));
+    assertNotNull(builder.nameResolverRegistry);
+    assertEquals("testscheme", builder.nameResolverRegistry.asFactory().getDefaultScheme());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void nameResolverFactory_null() {
+    NameResolverRegistry defaultValue = builder.nameResolverRegistry;
+    NameResolver.Factory nameResolverFactory = mock(NameResolver.Factory.class);
+    doReturn("testscheme").when(nameResolverFactory).getDefaultScheme();
+    builder.nameResolverFactory(nameResolverFactory);
+    assertNotEquals(defaultValue, builder.nameResolverRegistry);
+    builder.nameResolverFactory(null);
+    assertEquals(defaultValue, builder.nameResolverRegistry);
+  }
+
+  @Test(expected = IllegalStateException.class)
+  @SuppressWarnings("deprecation")
+  public void nameResolverFactory_notAllowedWithDirectAddress() {
+    directAddressBuilder.nameResolverFactory(mock(NameResolver.Factory.class));
+  }
+
+  @Test
+  public void defaultLoadBalancingPolicy_default() {
+    assertEquals("pick_first", builder.defaultLbPolicy);
+  }
+
+  @Test
+  public void defaultLoadBalancingPolicy_normal() {
+    assertSame(builder, builder.defaultLoadBalancingPolicy("magic_balancer"));
+    assertEquals("magic_balancer", builder.defaultLbPolicy);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void defaultLoadBalancingPolicy_null() {
+    builder.defaultLoadBalancingPolicy(null);
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void defaultLoadBalancingPolicy_notAllowedWithDirectAddress() {
+    directAddressBuilder.defaultLoadBalancingPolicy("magic_balancer");
+  }
+
+  @Test
+  public void fullStreamDecompression_default() {
+    assertFalse(builder.fullStreamDecompression);
+  }
+
+  @Test
+  public void decompressorRegistry_default() {
+    assertNotNull(builder.decompressorRegistry);
+  }
+
+  @Test
+  public void decompressorRegistry_normal() {
+    DecompressorRegistry decompressorRegistry = DecompressorRegistry.emptyInstance();
+    assertNotEquals(decompressorRegistry, builder.decompressorRegistry);
+    assertSame(builder, builder.decompressorRegistry(decompressorRegistry));
+    assertEquals(decompressorRegistry, builder.decompressorRegistry);
+  }
+
+  @Test
+  public void decompressorRegistry_null() {
+    DecompressorRegistry defaultValue = builder.decompressorRegistry;
+    assertSame(builder, builder.decompressorRegistry(DecompressorRegistry.emptyInstance()));
+    assertNotEquals(defaultValue, builder.decompressorRegistry);
+    builder.decompressorRegistry(null);
+    assertEquals(defaultValue, builder.decompressorRegistry);
+  }
+
+  @Test
+  public void compressorRegistry_default() {
+    assertNotNull(builder.compressorRegistry);
+  }
+
+  @Test
+  public void compressorRegistry_normal() {
+    CompressorRegistry compressorRegistry = CompressorRegistry.newEmptyInstance();
+    assertNotEquals(compressorRegistry, builder.compressorRegistry);
+    assertSame(builder, builder.compressorRegistry(compressorRegistry));
+    assertSame(compressorRegistry, builder.compressorRegistry);
+  }
+
+  @Test
+  public void compressorRegistry_null() {
+    CompressorRegistry defaultValue = builder.compressorRegistry;
+    builder.compressorRegistry(CompressorRegistry.newEmptyInstance());
+    assertNotEquals(defaultValue, builder.compressorRegistry);
+    assertSame(builder, builder.compressorRegistry(null));
+    assertSame(defaultValue, builder.compressorRegistry);
+  }
+
+  @Test
+  public void userAgent_default() {
+    assertNull(builder.userAgent);
+  }
+
+  @Test
+  public void userAgent_normal() {
+    String userAgent = "user-agent/1";
+    assertSame(builder, builder.userAgent(userAgent));
+    assertSame(userAgent, builder.userAgent);
+  }
+
+  @Test
+  public void userAgent_null() {
+    assertSame(builder, builder.userAgent(null));
+    assertNull(builder.userAgent);
+
+    builder.userAgent("user-agent/1");
+    builder.userAgent(null);
+    assertNull(builder.userAgent);
+  }
+
+  @Test
+  public void authorityIsReadable_default() {
+    when(mockClientTransportFactory.getScheduledExecutorService())
+        .thenReturn(clock.getScheduledExecutorService());
+    when(mockClientTransportFactoryBuilder.buildClientTransportFactory())
+        .thenReturn(mockClientTransportFactory);
+    when(mockClientTransportFactory.getSupportedSocketAddressTypes())
+        .thenReturn(Collections.singleton(InetSocketAddress.class));
+
+    builder = new ManagedChannelImplBuilder(DUMMY_AUTHORITY_VALID,
+        mockClientTransportFactoryBuilder, new FixedPortProvider(DUMMY_PORT));
+    ManagedChannel channel = grpcCleanupRule.register(builder.build());
+    assertEquals(DUMMY_AUTHORITY_VALID, channel.authority());
+  }
+
+  @Test
+  public void authorityIsReadable_overrideAuthority() {
+    String overrideAuthority = "best-authority";
+    when(mockClientTransportFactory.getScheduledExecutorService())
+        .thenReturn(clock.getScheduledExecutorService());
+    when(mockClientTransportFactoryBuilder.buildClientTransportFactory())
+        .thenReturn(mockClientTransportFactory);
+    when(mockClientTransportFactory.getSupportedSocketAddressTypes())
+        .thenReturn(Collections.singleton(InetSocketAddress.class));
+
+    builder = new ManagedChannelImplBuilder(DUMMY_TARGET,
+        mockClientTransportFactoryBuilder, new FixedPortProvider(DUMMY_PORT))
+        .overrideAuthority(overrideAuthority);
+    ManagedChannel channel = grpcCleanupRule.register(builder.build());
+    assertEquals(overrideAuthority, channel.authority());
+  }
+
+  @Test
+  public void transportDoesNotSupportAddressTypes() {
+    when(mockClientTransportFactory.getScheduledExecutorService())
+        .thenReturn(clock.getScheduledExecutorService());
+    when(mockClientTransportFactoryBuilder.buildClientTransportFactory())
+        .thenReturn(mockClientTransportFactory);
+    when(mockClientTransportFactory.getSupportedSocketAddressTypes())
+        .thenReturn(Collections.singleton(CustomSocketAddress.class));
+
+    builder = new ManagedChannelImplBuilder(DUMMY_AUTHORITY_VALID,
+        mockClientTransportFactoryBuilder, new FixedPortProvider(DUMMY_PORT));
+    try {
+      ManagedChannel unused = grpcCleanupRule.register(builder.build());
+      fail("Should fail");
+    } catch (IllegalArgumentException e) {
+      assertThat(e)
+          .hasMessageThat()
+          .isEqualTo(
+              "Address types of NameResolver 'dns' for 'dns:///valid:1234' not supported by"
+                  + " transport");
+    }
+  }
+
+  @Test
+  public void transportAddressTypeCompatibilityCheckSkipped() {
+    when(mockClientTransportFactory.getScheduledExecutorService())
+        .thenReturn(clock.getScheduledExecutorService());
+    when(mockClientTransportFactoryBuilder.buildClientTransportFactory())
+        .thenReturn(mockClientTransportFactory);
+    when(mockClientTransportFactory.getSupportedSocketAddressTypes())
+        .thenReturn(null);
+
+    builder = new ManagedChannelImplBuilder(DUMMY_AUTHORITY_VALID,
+        mockClientTransportFactoryBuilder, new FixedPortProvider(DUMMY_PORT));
+    // should not fail
+    ManagedChannel unused = grpcCleanupRule.register(builder.build());
+  }
+
+  @Test
+  public void overrideAuthority_default() {
+    assertNull(builder.authorityOverride);
+  }
+
+  @Test
+  public void overrideAuthority_normal() {
+    String overrideAuthority = "best-authority";
+    assertSame(builder, builder.overrideAuthority(overrideAuthority));
+    assertSame(overrideAuthority, builder.authorityOverride);
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void overrideAuthority_null() {
+    builder.overrideAuthority(null);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void overrideAuthority_invalid() {
+    builder.overrideAuthority("user@not_allowed");
+  }
+
+  @Test
+  public void checkAuthority_validAuthorityAllowed() {
+    assertEquals(DUMMY_AUTHORITY_VALID, builder.checkAuthority(DUMMY_AUTHORITY_VALID));
+  }
+
+  @Test
+  public void checkAuthority_invalidAuthorityFailed() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.checkAuthority(DUMMY_AUTHORITY_INVALID));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid authority: [ : : 1]");
+  }
+
+  @Test
+  public void disableCheckAuthority_validAuthorityAllowed() {
+    builder.disableCheckAuthority();
+    assertEquals(DUMMY_AUTHORITY_VALID, builder.checkAuthority(DUMMY_AUTHORITY_VALID));
+  }
+
+  @Test
+  public void disableCheckAuthority_invalidAuthorityAllowed() {
+    builder.disableCheckAuthority();
+    assertEquals(DUMMY_AUTHORITY_INVALID, builder.checkAuthority(DUMMY_AUTHORITY_INVALID));
+  }
+
+  @Test
+  public void enableCheckAuthority_validAuthorityAllowed() {
+    builder.disableCheckAuthority().enableCheckAuthority();
+    assertEquals(DUMMY_AUTHORITY_VALID, builder.checkAuthority(DUMMY_AUTHORITY_VALID));
+  }
+
+  @Test
+  public void disableCheckAuthority_invalidAuthorityFailed() {
+    builder.disableCheckAuthority().enableCheckAuthority();
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.checkAuthority(DUMMY_AUTHORITY_INVALID));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid authority: [ : : 1]");
+  }
+
+  @Test
+  public void makeTargetStringForDirectAddress_scopedIpv6() throws Exception {
+    InetSocketAddress address = new InetSocketAddress("0:0:0:0:0:0:0:0%0", 10005);
+    String target = ManagedChannelImplBuilder.makeTargetStringForDirectAddress(address);
+    URI uri = new URI(target);
+    assertThat(address.toString()).isIn(
+        Arrays.asList("/[0:0:0:0:0:0:0:0%0]:10005", "/0:0:0:0:0:0:0:0%0:10005"));
+    assertThat(target).isIn(
+        Arrays.asList(
+            "directaddress:////%5B0:0:0:0:0:0:0:0%250%5D:10005",
+            "directaddress:////0:0:0:0:0:0:0:0%250:10005"));
+    assertEquals(target, uri.toString());
+  }
+
+  @Test
+  public void getEffectiveInterceptors_default() {
+    builder.intercept(DUMMY_USER_INTERCEPTOR);
+    List<ClientInterceptor> effectiveInterceptors = builder.getEffectiveInterceptors("unused:///");
+    assertEquals(3, effectiveInterceptors.size());
+    assertThat(effectiveInterceptors.get(0).getClass().getName())
+        .isEqualTo("io.grpc.census.CensusTracingModule$TracingClientInterceptor");
+    assertThat(effectiveInterceptors.get(1).getClass().getName())
+        .isEqualTo("io.grpc.census.CensusStatsModule$StatsClientInterceptor");
+    assertThat(effectiveInterceptors.get(2)).isSameInstanceAs(DUMMY_USER_INTERCEPTOR);
+  }
+
+  @Test
+  public void getEffectiveInterceptors_disableStats() {
+    builder.intercept(DUMMY_USER_INTERCEPTOR);
+    builder.setStatsEnabled(false);
+    List<ClientInterceptor> effectiveInterceptors = builder.getEffectiveInterceptors("unused:///");
+    assertEquals(2, effectiveInterceptors.size());
+    assertThat(effectiveInterceptors.get(0).getClass().getName())
+        .isEqualTo("io.grpc.census.CensusTracingModule$TracingClientInterceptor");
+    assertThat(effectiveInterceptors.get(1)).isSameInstanceAs(DUMMY_USER_INTERCEPTOR);
+  }
+
+  @Test
+  public void getEffectiveInterceptors_disableTracing() {
+    builder.intercept(DUMMY_USER_INTERCEPTOR);
+    builder.setTracingEnabled(false);
+    List<ClientInterceptor> effectiveInterceptors = builder.getEffectiveInterceptors("unused:///");
+    assertEquals(2, effectiveInterceptors.size());
+    assertThat(effectiveInterceptors.get(0).getClass().getName())
+        .isEqualTo("io.grpc.census.CensusStatsModule$StatsClientInterceptor");
+    assertThat(effectiveInterceptors.get(1)).isSameInstanceAs(DUMMY_USER_INTERCEPTOR);
+  }
+
+  @Test
+  public void getEffectiveInterceptors_disableBoth() {
+    builder.intercept(DUMMY_USER_INTERCEPTOR);
+    builder.setStatsEnabled(false);
+    builder.setTracingEnabled(false);
+    List<ClientInterceptor> effectiveInterceptors = builder.getEffectiveInterceptors("unused:///");
+    assertThat(effectiveInterceptors).containsExactly(DUMMY_USER_INTERCEPTOR);
+  }
+
+  @Test
+  public void getEffectiveInterceptors_callsGetConfiguratorRegistry() throws Exception {
+    Class<?> runnable = classLoader.loadClass(StaticTestingClassLoaderCallsGet.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  // UsedReflectively
+  public static final class StaticTestingClassLoaderCallsGet implements Runnable {
+
+    @Override
+    public void run() {
+      ManagedChannelImplBuilder builder =
+          new ManagedChannelImplBuilder(
+              DUMMY_TARGET,
+              new UnsupportedClientTransportFactoryBuilder(),
+              new FixedPortProvider(DUMMY_PORT));
+      List<ClientInterceptor> effectiveInterceptors =
+          builder.getEffectiveInterceptors("unused:///");
+      assertThat(effectiveInterceptors).hasSize(2);
+      InternalConfiguratorRegistry.setConfigurators(Collections.emptyList());
+      assertThat(InternalConfiguratorRegistry.getConfigurators()).isEmpty();
+      assertThat(InternalConfiguratorRegistry.getConfiguratorsCallCountBeforeSet()).isEqualTo(1);
+    }
+  }
+
+  @Test
+  public void getEffectiveInterceptors_callsSetConfiguratorRegistry() throws Exception {
+    Class<?> runnable = classLoader.loadClass(StaticTestingClassLoaderCallsSet.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  // UsedReflectively
+  public static final class StaticTestingClassLoaderCallsSet implements Runnable {
+
+    @Override
+    public void run() {
+      InternalConfiguratorRegistry.setConfigurators(
+          Arrays.asList(new InternalConfigurator() {
+            @Override
+            public void configureChannelBuilder(ManagedChannelBuilder<?> builder) {
+              builder.intercept(DUMMY_USER_INTERCEPTOR, DUMMY_USER_INTERCEPTOR1);
+            }
+          }));
+      ManagedChannelImplBuilder builder =
+          new ManagedChannelImplBuilder(
+              DUMMY_TARGET,
+              new UnsupportedClientTransportFactoryBuilder(),
+              new FixedPortProvider(DUMMY_PORT));
+      List<ClientInterceptor> effectiveInterceptors =
+          builder.getEffectiveInterceptors("unused:///");
+      assertThat(effectiveInterceptors)
+          .containsExactly(DUMMY_USER_INTERCEPTOR, DUMMY_USER_INTERCEPTOR1);
+    }
+  }
+
+  @Test
+  public void getEffectiveInterceptors_setEmptyConfiguratorRegistry() throws Exception {
+    Class<?> runnable =
+        classLoader.loadClass(StaticTestingClassLoaderCallsSetEmpty.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  // UsedReflectively
+  public static final class StaticTestingClassLoaderCallsSetEmpty implements Runnable {
+
+    @Override
+    public void run() {
+      InternalConfiguratorRegistry.setConfigurators(Collections.emptyList());
+      ManagedChannelImplBuilder builder =
+          new ManagedChannelImplBuilder(
+              DUMMY_TARGET,
+              new UnsupportedClientTransportFactoryBuilder(),
+              new FixedPortProvider(DUMMY_PORT));
+      List<ClientInterceptor> effectiveInterceptors =
+          builder.getEffectiveInterceptors("unused:///");
+      assertThat(effectiveInterceptors).isEmpty();
+    }
+  }
+
+  @Test
+  public void getEffectiveInterceptors_createsFromInterceptorFactories() throws Exception {
+    String target = "dns:///the-host";
+    builder.setStatsEnabled(false);
+    builder.setTracingEnabled(false);
+
+    builder.intercept(DUMMY_USER_INTERCEPTOR)
+        .interceptWithTarget(new InternalInterceptorFactory() {
+          @Override
+          public ClientInterceptor newInterceptor(String passedTarget) {
+            assertThat(passedTarget).isEqualTo(target);
+            return DUMMY_USER_INTERCEPTOR1;
+          }
+        })
+        .intercept(DUMMY_USER_INTERCEPTOR);
+
+    assertThat(builder.getEffectiveInterceptors(target))
+        .isEqualTo(Arrays.asList(
+            DUMMY_USER_INTERCEPTOR,
+            DUMMY_USER_INTERCEPTOR1,
+            DUMMY_USER_INTERCEPTOR));
+  }
+
+  @Test
+  public void idleTimeout() {
+    assertEquals(ManagedChannelImplBuilder.IDLE_MODE_DEFAULT_TIMEOUT_MILLIS,
+        builder.idleTimeoutMillis);
+
+    builder.idleTimeout(Long.MAX_VALUE, TimeUnit.DAYS);
+    assertEquals(ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE, builder.idleTimeoutMillis);
+
+    builder.idleTimeout(ManagedChannelImplBuilder.IDLE_MODE_MAX_TIMEOUT_DAYS,
+        TimeUnit.DAYS);
+    assertEquals(ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE, builder.idleTimeoutMillis);
+
+    try {
+      builder.idleTimeout(0, TimeUnit.SECONDS);
+      fail("Should throw");
+    } catch (IllegalArgumentException e) {
+      // expected
+    }
+
+    builder.idleTimeout(1, TimeUnit.NANOSECONDS);
+    assertEquals(ManagedChannelImplBuilder.IDLE_MODE_MIN_TIMEOUT_MILLIS,
+        builder.idleTimeoutMillis);
+
+    builder.idleTimeout(30, TimeUnit.SECONDS);
+    assertEquals(TimeUnit.SECONDS.toMillis(30), builder.idleTimeoutMillis);
+  }
+
+  @Test
+  public void maxRetryAttempts() {
+    assertEquals(5, builder.maxRetryAttempts);
+
+    builder.maxRetryAttempts(3);
+    assertEquals(3, builder.maxRetryAttempts);
+  }
+
+  @Test
+  public void maxHedgedAttempts() {
+    assertEquals(5, builder.maxHedgedAttempts);
+
+    builder.maxHedgedAttempts(3);
+    assertEquals(3, builder.maxHedgedAttempts);
+  }
+
+  @Test
+  public void retryBufferSize() {
+    assertEquals(1L << 24, builder.retryBufferSize);
+
+    builder.retryBufferSize(3456L);
+    assertEquals(3456L, builder.retryBufferSize);
+  }
+
+  @Test
+  public void perRpcBufferLimit() {
+    assertEquals(1L << 20, builder.perRpcBufferLimit);
+
+    builder.perRpcBufferLimit(3456L);
+    assertEquals(3456L, builder.perRpcBufferLimit);
+  }
+
+  @Test
+  public void retryBufferSizeInvalidArg() {
+    assertThrows(IllegalArgumentException.class, () -> builder.retryBufferSize(0L));
+  }
+
+  @Test
+  public void perRpcBufferLimitInvalidArg() {
+    assertThrows(IllegalArgumentException.class, () -> builder.perRpcBufferLimit(0L));
+  }
+
+  @Test
+  public void disableRetry() {
+    builder.enableRetry();
+    assertTrue(builder.retryEnabled);
+
+    builder.disableRetry();
+    assertFalse(builder.retryEnabled);
+
+    builder.enableRetry();
+    assertTrue(builder.retryEnabled);
+
+    builder.disableRetry();
+    assertFalse(builder.retryEnabled);
+  }
+
+  @Test
+  public void defaultServiceConfig_nullKey() {
+    Map<String, Object> config = new HashMap<>();
+    config.put(null, "val");
+
+    assertThrows(IllegalArgumentException.class, () -> builder.defaultServiceConfig(config));
+  }
+
+  @Test
+  public void defaultServiceConfig_intKey() {
+    Map<Integer, Object> subConfig = new HashMap<>();
+    subConfig.put(3, "val");
+    Map<String, Object> config = new HashMap<>();
+    config.put("key", subConfig);
+
+    assertThrows(IllegalArgumentException.class, () -> builder.defaultServiceConfig(config));
+  }
+
+  @Test
+  public void defaultServiceConfig_intValue() {
+    Map<String, Object> config = new HashMap<>();
+    config.put("key", 3);
+
+    assertThrows(IllegalArgumentException.class, () -> builder.defaultServiceConfig(config));
+  }
+
+  @Test
+  public void defaultServiceConfig_nested() {
+    Map<String, Object> config = new HashMap<>();
+    List<Object> list1 = new ArrayList<>();
+    list1.add(123D);
+    list1.add(null);
+    list1.add(true);
+    list1.add("str");
+    Map<String, Object> map2 = new HashMap<>();
+    map2.put("key2", false);
+    map2.put("key3", null);
+    map2.put("key4", Collections.singletonList("v4"));
+    map2.put("key4", 3.14D);
+    map2.put("key5", new HashMap<String, Object>());
+    list1.add(map2);
+    config.put("key1", list1);
+
+    builder.defaultServiceConfig(config);
+
+    assertThat(builder.defaultServiceConfig).containsExactlyEntriesIn(config);
+  }
+
+  @Test
+  public void disableNameResolverServiceConfig() {
+    assertThat(builder.lookUpServiceConfig).isTrue();
+
+    builder.disableServiceConfigLookUp();
+    assertThat(builder.lookUpServiceConfig).isFalse();
+  }
+
+  @Test
+  public void setNameResolverExtArgs() {
+    assertThat(builder.nameResolverCustomArgs)
+        .isNull();
+
+    NameResolver.Args.Key<Integer> testKey = NameResolver.Args.Key.create("test-key");
+    builder.setNameResolverArg(testKey, 42);
+    assertThat(builder.nameResolverCustomArgs.get(testKey)).isEqualTo(42);
+  }
+
+  @Test
+  public void metricSinks() {
+    MetricSink mocksink = mock(MetricSink.class);
+    builder.addMetricSink(mocksink);
+
+    assertThat(builder.metricSinks).contains(mocksink);
+  }
+
+  @Test
+  public void uriPattern() {
+    Pattern uriPattern = ManagedChannelImplBuilder.URI_PATTERN;
+    assertTrue(uriPattern.matcher("a:/").matches());
+    assertTrue(uriPattern.matcher("Z019+-.:/!@ #~ ").matches());
+    assertFalse(uriPattern.matcher("a/:").matches()); // "/:" not matched
+    assertFalse(uriPattern.matcher("0a:/").matches()); // '0' not matched
+    assertFalse(uriPattern.matcher("a,:/").matches()); // ',' not matched
+    assertFalse(uriPattern.matcher(" a:/").matches()); // space not matched
+  }
+
+  private static class CustomSocketAddress extends SocketAddress {}
+}
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelImplGetNameResolverRfc3986Test.java b/core/src/test/java/io/grpc/internal/ManagedChannelImplGetNameResolverRfc3986Test.java
new file mode 100644
index 00000000000..5bcf24a30e2
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelImplGetNameResolverRfc3986Test.java
@@ -0,0 +1,243 @@
+/*
+ * Copyright 2015 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.internal.UriWrapper.wrap;
+import static org.junit.Assert.fail;
+
+import io.grpc.NameResolver;
+import io.grpc.NameResolverProvider;
+import io.grpc.NameResolverRegistry;
+import io.grpc.Uri;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for ManagedChannelImplBuilder#getNameResolverProviderNew(). */
+@RunWith(JUnit4.class)
+public class ManagedChannelImplGetNameResolverRfc3986Test {
+  @Test
+  public void invalidUriTarget() {
+    testInvalidTarget("defaultscheme:///[invalid]");
+  }
+
+  @Test
+  public void invalidUnescapedSquareBracketsInRfc3986UriFragment() {
+    testInvalidTarget("defaultscheme://8.8.8.8/host#section[1]");
+  }
+
+  @Test
+  public void invalidUnescapedSquareBracketsInRfc3986UriQuery() {
+    testInvalidTarget("dns://8.8.8.8/path?section=[1]");
+  }
+
+  @Test
+  public void validTargetWithInvalidDnsName() throws Exception {
+    testValidTarget(
+        "[valid]",
+        "defaultscheme:///%5Bvalid%5D",
+        Uri.newBuilder().setScheme("defaultscheme").setHost("").setPath("/[valid]").build());
+  }
+
+  @Test
+  public void validAuthorityTarget() throws Exception {
+    testValidTarget(
+        "foo.googleapis.com:8080",
+        "defaultscheme:///foo.googleapis.com:8080",
+        Uri.newBuilder()
+            .setScheme("defaultscheme")
+            .setHost("")
+            .setPath("/foo.googleapis.com:8080")
+            .build());
+  }
+
+  @Test
+  public void validUriTarget() throws Exception {
+    testValidTarget(
+        "scheme:///foo.googleapis.com:8080",
+        "scheme:///foo.googleapis.com:8080",
+        Uri.newBuilder()
+            .setScheme("scheme")
+            .setHost("")
+            .setPath("/foo.googleapis.com:8080")
+            .build());
+  }
+
+  @Test
+  public void validIpv4AuthorityTarget() throws Exception {
+    testValidTarget(
+        "127.0.0.1:1234",
+        "defaultscheme:///127.0.0.1:1234",
+        Uri.newBuilder().setScheme("defaultscheme").setHost("").setPath("/127.0.0.1:1234").build());
+  }
+
+  @Test
+  public void validIpv4UriTarget() throws Exception {
+    testValidTarget(
+        "dns:///127.0.0.1:1234",
+        "dns:///127.0.0.1:1234",
+        Uri.newBuilder().setScheme("dns").setHost("").setPath("/127.0.0.1:1234").build());
+  }
+
+  @Test
+  public void validIpv6AuthorityTarget() throws Exception {
+    testValidTarget(
+        "[::1]:1234",
+        "defaultscheme:///%5B::1%5D:1234",
+        Uri.newBuilder().setScheme("defaultscheme").setHost("").setPath("/[::1]:1234").build());
+  }
+
+  @Test
+  public void invalidIpv6UriTarget() throws Exception {
+    testInvalidTarget("dns:///[::1]:1234");
+  }
+
+  @Test
+  public void invalidIpv6UriWithUnescapedScope() {
+    testInvalidTarget("dns://[::1%eth0]:53/host");
+  }
+
+  @Test
+  public void validIpv6UriTarget() throws Exception {
+    testValidTarget(
+        "dns:///%5B::1%5D:1234",
+        "dns:///%5B::1%5D:1234",
+        Uri.newBuilder().setScheme("dns").setHost("").setPath("/[::1]:1234").build());
+  }
+
+  @Test
+  public void validTargetStartingWithSlash() throws Exception {
+    testValidTarget(
+        "/target",
+        "defaultscheme:////target",
+        Uri.newBuilder().setScheme("defaultscheme").setHost("").setPath("//target").build());
+  }
+
+  @Test
+  public void validTargetNoProvider() {
+    NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
+    try {
+      ManagedChannelImplBuilder.getNameResolverProviderRfc3986(
+          "foo.googleapis.com:8080", nameResolverRegistry);
+      fail("Should fail");
+    } catch (IllegalArgumentException e) {
+      // expected
+    }
+  }
+
+  @Test
+  public void validTargetProviderAddrTypesNotSupported() {
+    NameResolverRegistry nameResolverRegistry = getTestRegistry("testscheme");
+    try {
+      ManagedChannelImplBuilder.getNameResolverProviderRfc3986(
+              "testscheme:///foo.googleapis.com:8080", nameResolverRegistry)
+          .checkAddressTypes(Collections.singleton(CustomSocketAddress.class));
+      fail("Should fail");
+    } catch (IllegalArgumentException e) {
+      assertThat(e)
+          .hasMessageThat()
+          .isEqualTo(
+              "Address types of NameResolver 'testscheme' for "
+                  + "'testscheme:///foo.googleapis.com:8080' not supported by transport");
+    }
+  }
+
+  private void testValidTarget(String target, String expectedUriString, Uri expectedUri) {
+    NameResolverRegistry nameResolverRegistry = getTestRegistry(expectedUri.getScheme());
+    ManagedChannelImplBuilder.ResolvedNameResolver resolved =
+        ManagedChannelImplBuilder.getNameResolverProviderRfc3986(target, nameResolverRegistry);
+    assertThat(resolved.provider).isInstanceOf(FakeNameResolverProvider.class);
+    assertThat(resolved.targetUri).isEqualTo(wrap(expectedUri));
+    assertThat(resolved.targetUri.toString()).isEqualTo(expectedUriString);
+  }
+
+  private void testInvalidTarget(String target) {
+    NameResolverRegistry nameResolverRegistry = getTestRegistry("dns");
+
+    try {
+      ManagedChannelImplBuilder.ResolvedNameResolver resolved =
+          ManagedChannelImplBuilder.getNameResolverProviderRfc3986(target, nameResolverRegistry);
+      FakeNameResolverProvider nameResolverProvider = (FakeNameResolverProvider) resolved.provider;
+      fail("Should have failed, but got resolver provider " + nameResolverProvider);
+    } catch (IllegalArgumentException e) {
+      // expected
+    }
+  }
+
+  private static NameResolverRegistry getTestRegistry(String expectedScheme) {
+    NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
+    FakeNameResolverProvider nameResolverProvider = new FakeNameResolverProvider(expectedScheme);
+    nameResolverRegistry.register(nameResolverProvider);
+    return nameResolverRegistry;
+  }
+
+  private static class FakeNameResolverProvider extends NameResolverProvider {
+    final String expectedScheme;
+
+    FakeNameResolverProvider(String expectedScheme) {
+      this.expectedScheme = expectedScheme;
+    }
+
+    @Override
+    public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+      if (expectedScheme.equals(targetUri.getScheme())) {
+        return new FakeNameResolver(targetUri);
+      }
+      return null;
+    }
+
+    @Override
+    public String getDefaultScheme() {
+      return expectedScheme;
+    }
+
+    @Override
+    protected boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    protected int priority() {
+      return 5;
+    }
+  }
+
+  private static class FakeNameResolver extends NameResolver {
+    final URI uri;
+
+    FakeNameResolver(URI uri) {
+      this.uri = uri;
+    }
+
+    @Override
+    public String getServiceAuthority() {
+      return uri.getAuthority();
+    }
+
+    @Override
+    public void start(final Listener2 listener) {}
+
+    @Override
+    public void shutdown() {}
+  }
+
+  private static class CustomSocketAddress extends SocketAddress {}
+}
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelImplGetNameResolverTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelImplGetNameResolverTest.java
index cd6d59901d3..792f4daca4e 100644
--- a/core/src/test/java/io/grpc/internal/ManagedChannelImplGetNameResolverTest.java
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelImplGetNameResolverTest.java
@@ -1,59 +1,58 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.internal.UriWrapper.wrap;
 import static org.junit.Assert.fail;
 
-import io.grpc.Attributes;
 import io.grpc.NameResolver;
-import io.grpc.NameResolver.Factory;
+import io.grpc.NameResolverProvider;
+import io.grpc.NameResolverRegistry;
+import java.net.SocketAddress;
 import java.net.URI;
+import java.util.Collections;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
-/** Unit tests for {@link ManagedChannelImpl#getNameResolver}. */
+/** Unit tests for ManagedChannelImplBuilder#getNameResolverProvider(). */
 @RunWith(JUnit4.class)
 public class ManagedChannelImplGetNameResolverTest {
-  private static final Attributes NAME_RESOLVER_PARAMS =
-      Attributes.newBuilder().set(NameResolver.Factory.PARAMS_DEFAULT_PORT, 447).build();
-
   @Test
   public void invalidUriTarget() {
     testInvalidTarget("defaultscheme:///[invalid]");
   }
 
+  @Test
+  public void validSquareBracketsInRfc2396UriFragment() throws Exception {
+    testValidTarget("dns://8.8.8.8/host#section[1]",
+        "dns://8.8.8.8/host#section[1]",
+        new URI("dns", "8.8.8.8", "/host", null, "section[1]"));
+  }
+
+
+  @Test
+  public void validSquareBracketsInRfc2396UriQuery() throws Exception {
+    testValidTarget("dns://8.8.8.8/host?section=[1]",
+        "dns://8.8.8.8/host?section=[1]",
+        new URI("dns", "8.8.8.8", "/host", "section=[1]", null));
+  }
+
   @Test
   public void validTargetWithInvalidDnsName() throws Exception {
     testValidTarget("[valid]", "defaultscheme:///%5Bvalid%5D",
@@ -90,6 +89,13 @@ public void validIpv6AuthorityTarget() throws Exception {
         new URI("defaultscheme", "", "/[::1]:1234", null));
   }
 
+  @Test
+  public void validIpv6UriWithJavaNetUriScopeName() throws Exception {
+    testValidTarget("dns://[::1%eth0]:53/host",
+        "dns://[::1%eth0]:53/host",
+        new URI("dns", "[::1%eth0]:53", "/host", null, null));
+  }
+
   @Test
   public void invalidIpv6UriTarget() throws Exception {
     testInvalidTarget("dns:///[::1]:1234");
@@ -108,57 +114,70 @@ public void validTargetStartingWithSlash() throws Exception {
   }
 
   @Test
-  public void validTargetNoResovler() {
-    Factory nameResolverFactory = new NameResolver.Factory() {
-      @Override
-      public NameResolver newNameResolver(URI targetUri, Attributes params) {
-        return null;
-      }
-
-      @Override
-      public String getDefaultScheme() {
-        return "defaultscheme";
-      }
-    };
+  public void validTargetNoProvider() {
+    NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
     try {
-      ManagedChannelImpl.getNameResolver(
-          "foo.googleapis.com:8080", nameResolverFactory, NAME_RESOLVER_PARAMS);
+      ManagedChannelImplBuilder.getNameResolverProvider(
+          "foo.googleapis.com:8080", nameResolverRegistry);
       fail("Should fail");
     } catch (IllegalArgumentException e) {
       // expected
     }
   }
 
+  @Test
+  public void validTargetProviderAddrTypesNotSupported() {
+    NameResolverRegistry nameResolverRegistry = getTestRegistry("testscheme");
+    try {
+      ManagedChannelImplBuilder.getNameResolverProvider(
+              "testscheme:///foo.googleapis.com:8080", nameResolverRegistry)
+          .checkAddressTypes(Collections.singleton(CustomSocketAddress.class));
+      fail("Should fail");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().isEqualTo(
+          "Address types of NameResolver 'testscheme' for "
+              + "'testscheme:///foo.googleapis.com:8080' not supported by transport");
+    }
+  }
+
   private void testValidTarget(String target, String expectedUriString, URI expectedUri) {
-    Factory nameResolverFactory = new FakeNameResolverFactory(expectedUri.getScheme());
-    FakeNameResolver nameResolver = (FakeNameResolver) ManagedChannelImpl.getNameResolver(
-        target, nameResolverFactory, NAME_RESOLVER_PARAMS);
-    assertNotNull(nameResolver);
-    assertEquals(expectedUri, nameResolver.uri);
-    assertEquals(expectedUriString, nameResolver.uri.toString());
+    NameResolverRegistry nameResolverRegistry = getTestRegistry(expectedUri.getScheme());
+    ManagedChannelImplBuilder.ResolvedNameResolver resolved =
+        ManagedChannelImplBuilder.getNameResolverProvider(target, nameResolverRegistry);
+    assertThat(resolved.provider).isInstanceOf(FakeNameResolverProvider.class);
+    assertThat(resolved.targetUri).isEqualTo(wrap(expectedUri));
+    assertThat(resolved.targetUri.toString()).isEqualTo(expectedUriString);
   }
 
   private void testInvalidTarget(String target) {
-    Factory nameResolverFactory = new FakeNameResolverFactory("dns");
+    NameResolverRegistry nameResolverRegistry = getTestRegistry("dns");
 
     try {
-      FakeNameResolver nameResolver = (FakeNameResolver) ManagedChannelImpl.getNameResolver(
-          target, nameResolverFactory, NAME_RESOLVER_PARAMS);
-      fail("Should have failed, but got resolver with " + nameResolver.uri);
+      ManagedChannelImplBuilder.ResolvedNameResolver resolved =
+          ManagedChannelImplBuilder.getNameResolverProvider(target, nameResolverRegistry);
+      FakeNameResolverProvider nameResolverProvider = (FakeNameResolverProvider) resolved.provider;
+      fail("Should have failed, but got resolver provider " + nameResolverProvider);
     } catch (IllegalArgumentException e) {
       // expected
     }
   }
 
-  private static class FakeNameResolverFactory extends NameResolver.Factory {
+  private static NameResolverRegistry getTestRegistry(String expectedScheme) {
+    NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
+    FakeNameResolverProvider nameResolverProvider = new FakeNameResolverProvider(expectedScheme);
+    nameResolverRegistry.register(nameResolverProvider);
+    return nameResolverRegistry;
+  }
+
+  private static class FakeNameResolverProvider extends NameResolverProvider {
     final String expectedScheme;
 
-    FakeNameResolverFactory(String expectedScheme) {
+    FakeNameResolverProvider(String expectedScheme) {
       this.expectedScheme = expectedScheme;
     }
 
     @Override
-    public NameResolver newNameResolver(URI targetUri, Attributes params) {
+    public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
       if (expectedScheme.equals(targetUri.getScheme())) {
         return new FakeNameResolver(targetUri);
       }
@@ -169,6 +188,16 @@ public NameResolver newNameResolver(URI targetUri, Attributes params) {
     public String getDefaultScheme() {
       return expectedScheme;
     }
+
+    @Override
+    protected boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    protected int priority() {
+      return 5;
+    }
   }
 
   private static class FakeNameResolver extends NameResolver {
@@ -182,8 +211,10 @@ private static class FakeNameResolver extends NameResolver {
       return uri.getAuthority();
     }
 
-    @Override public void start(final Listener listener) {}
+    @Override public void start(final Listener2 listener) {}
 
     @Override public void shutdown() {}
   }
+
+  private static class CustomSocketAddress extends SocketAddress {}
 }
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelImplIdlenessTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelImplIdlenessTest.java
index 6b86caa1905..97e92be7fdd 100644
--- a/core/src/test/java/io/grpc/internal/ManagedChannelImplIdlenessTest.java
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelImplIdlenessTest.java
@@ -1,45 +1,36 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static io.grpc.internal.UriWrapper.wrap;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.same;
-import static org.mockito.Mockito.doAnswer;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.atMostOnce;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -48,249 +39,253 @@
 import com.google.common.collect.Lists;
 import io.grpc.Attributes;
 import io.grpc.CallOptions;
+import io.grpc.ChannelLogger;
 import io.grpc.ClientCall;
 import io.grpc.ClientInterceptor;
-import io.grpc.CompressorRegistry;
-import io.grpc.DecompressorRegistry;
+import io.grpc.ConnectivityState;
 import io.grpc.EquivalentAddressGroup;
 import io.grpc.IntegerMarshaller;
 import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.MethodType;
 import io.grpc.NameResolver;
-import io.grpc.ResolvedServerInfo;
-import io.grpc.ResolvedServerInfoGroup;
+import io.grpc.NameResolver.ResolutionResult;
+import io.grpc.NameResolverProvider;
 import io.grpc.Status;
+import io.grpc.StatusOr;
 import io.grpc.StringMarshaller;
-import io.grpc.TransportManager;
-import io.grpc.TransportManager.OobTransportProvider;
+import io.grpc.internal.FakeClock.ScheduledTask;
+import io.grpc.internal.ManagedChannelImplBuilder.UnsupportedClientTransportFactoryBuilder;
 import io.grpc.internal.TestUtils.MockClientTransportInfo;
+import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.net.URI;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Captor;
-import org.mockito.Matchers;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /**
  * Unit tests for {@link ManagedChannelImpl}'s idle mode.
  */
 @RunWith(JUnit4.class)
 public class ManagedChannelImplIdlenessTest {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
   private final FakeClock timer = new FakeClock();
   private final FakeClock executor = new FakeClock();
+  private final FakeClock oobExecutor = new FakeClock();
   private static final String AUTHORITY = "fakeauthority";
   private static final String USER_AGENT = "fakeagent";
   private static final long IDLE_TIMEOUT_SECONDS = 30;
+  private static final String MOCK_POLICY_NAME = "mock_lb";
   private ManagedChannelImpl channel;
 
   private final MethodDescriptor<String, Integer> method =
       MethodDescriptor.<String, Integer>newBuilder()
           .setType(MethodType.UNKNOWN)
-          .setFullMethodName("/service/method")
+          .setFullMethodName("service/method")
           .setRequestMarshaller(new StringMarshaller())
           .setResponseMarshaller(new IntegerMarshaller())
           .build();
-  private final List<ResolvedServerInfoGroup> servers = Lists.newArrayList();
-  private final List<EquivalentAddressGroup> addressGroupList =
-      new ArrayList<EquivalentAddressGroup>();
 
-  @Mock private SharedResourceHolder.Resource<ScheduledExecutorService> timerService;
+  private final List<EquivalentAddressGroup> servers = Lists.newArrayList();
+  private final ObjectPool<Executor> executorPool =
+      new FixedObjectPool<Executor>(executor.getScheduledExecutorService());
+  private final ObjectPool<Executor> oobExecutorPool =
+      new FixedObjectPool<Executor>(oobExecutor.getScheduledExecutorService());
+
   @Mock private ClientTransportFactory mockTransportFactory;
-  @Mock private LoadBalancer<ClientTransport> mockLoadBalancer;
-  @Mock private LoadBalancer.Factory mockLoadBalancerFactory;
+  @Mock private LoadBalancer mockLoadBalancer;
+  @Mock private SubchannelStateListener subchannelStateListener;
+  private final LoadBalancerProvider mockLoadBalancerProvider =
+      mock(LoadBalancerProvider.class, delegatesTo(new LoadBalancerProvider() {
+          @Override
+          public LoadBalancer newLoadBalancer(Helper helper) {
+            return mockLoadBalancer;
+          }
+
+          @Override
+          public boolean isAvailable() {
+            return true;
+          }
+
+          @Override
+          public int getPriority() {
+            return 999;
+          }
+
+          @Override
+          public String getPolicyName() {
+            return MOCK_POLICY_NAME;
+          }
+        }));
+
   @Mock private NameResolver mockNameResolver;
   @Mock private NameResolver.Factory mockNameResolverFactory;
   @Mock private ClientCall.Listener<Integer> mockCallListener;
-  @Captor private ArgumentCaptor<NameResolver.Listener> nameResolverListenerCaptor;
+  @Mock private ClientCall.Listener<Integer> mockCallListener2;
+  @Captor private ArgumentCaptor<NameResolver.Listener2> nameResolverListenerCaptor;
   private BlockingQueue<MockClientTransportInfo> newTransports;
 
   @Before
+  @SuppressWarnings("deprecation") // For NameResolver.Listener
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    when(timerService.create()).thenReturn(timer.getScheduledExecutorService());
-    when(mockLoadBalancerFactory
-        .newLoadBalancer(anyString(), Matchers.<TransportManager<ClientTransport>>any()))
-        .thenReturn(mockLoadBalancer);
+    when(mockLoadBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(
+        Status.OK);
+    LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
     when(mockNameResolver.getServiceAuthority()).thenReturn(AUTHORITY);
     when(mockNameResolverFactory
-        .newNameResolver(any(URI.class), any(Attributes.class)))
+        .newNameResolver(any(URI.class), any(NameResolver.Args.class)))
         .thenReturn(mockNameResolver);
-
-    channel = new ManagedChannelImpl("fake://target", new FakeBackoffPolicyProvider(),
-        mockNameResolverFactory, Attributes.EMPTY, mockLoadBalancerFactory,
-        mockTransportFactory, DecompressorRegistry.getDefaultInstance(),
-        CompressorRegistry.getDefaultInstance(), timerService, timer.getStopwatchSupplier(),
-        TimeUnit.SECONDS.toMillis(IDLE_TIMEOUT_SECONDS),
-        executor.getScheduledExecutorService(), USER_AGENT,
+    when(mockNameResolverFactory.getDefaultScheme())
+        .thenReturn("mockscheme");
+    when(mockTransportFactory.getScheduledExecutorService())
+        .thenReturn(timer.getScheduledExecutorService());
+    when(mockTransportFactory.getSupportedSocketAddressTypes())
+        .thenReturn(Collections.singleton(InetSocketAddress.class));
+
+    String target = "mockscheme:///target";
+    URI targetUri = URI.create(target);
+    ManagedChannelImplBuilder builder = new ManagedChannelImplBuilder(target,
+        new UnsupportedClientTransportFactoryBuilder(), null);
+
+    builder
+        .nameResolverFactory(mockNameResolverFactory)
+        .defaultLoadBalancingPolicy(MOCK_POLICY_NAME)
+        .idleTimeout(IDLE_TIMEOUT_SECONDS, TimeUnit.SECONDS)
+        .userAgent(USER_AGENT);
+    builder.executorPool = executorPool;
+    NameResolverProvider nameResolverProvider =
+        builder.nameResolverRegistry.getProviderForScheme(targetUri.getScheme());
+    channel = new ManagedChannelImpl(
+        builder, mockTransportFactory, wrap(targetUri), nameResolverProvider,
+        new FakeBackoffPolicyProvider(),
+        oobExecutorPool, timer.getStopwatchSupplier(),
         Collections.<ClientInterceptor>emptyList(),
-        NoopStatsContextFactory.INSTANCE);
+        TimeProvider.SYSTEM_TIME_PROVIDER);
     newTransports = TestUtils.captureTransports(mockTransportFactory);
 
     for (int i = 0; i < 2; i++) {
-      ResolvedServerInfoGroup.Builder resolvedServerInfoGroup = ResolvedServerInfoGroup.builder();
+      ArrayList<SocketAddress> addrs = Lists.newArrayList();
       for (int j = 0; j < 2; j++) {
-        resolvedServerInfoGroup.add(
-            new ResolvedServerInfo(new FakeSocketAddress("servergroup" + i + "server" + j)));
+        addrs.add(new FakeSocketAddress("servergroup" + i + "server" + j));
       }
-      servers.add(resolvedServerInfoGroup.build());
-      addressGroupList.add(resolvedServerInfoGroup.build().toEquivalentAddressGroup());
+      servers.add(new EquivalentAddressGroup(addrs));
     }
-    verify(mockNameResolverFactory).newNameResolver(any(URI.class), any(Attributes.class));
+    verify(mockNameResolverFactory).newNameResolver(any(URI.class), any(NameResolver.Args.class));
     // Verify the initial idleness
-    verify(mockLoadBalancerFactory, never()).newLoadBalancer(
-        anyString(), Matchers.<TransportManager<ClientTransport>>any());
+    verify(mockLoadBalancerProvider, never()).newLoadBalancer(any(Helper.class));
     verify(mockTransportFactory, never()).newClientTransport(
-        any(SocketAddress.class), anyString(), anyString());
+        any(SocketAddress.class),
+        any(ClientTransportFactory.ClientTransportOptions.class),
+        any(ChannelLogger.class));
     verify(mockNameResolver, never()).start(any(NameResolver.Listener.class));
+    verify(mockNameResolver, never()).start(any(NameResolver.Listener2.class));
   }
 
   @After
   public void allPendingTasksAreRun() {
-    assertEquals(timer.getPendingTasks() + " should be empty", 0, timer.numPendingTasks());
+    Collection<ScheduledTask> pendingTimerTasks = timer.getPendingTasks();
+    for (ScheduledTask a : pendingTimerTasks) {
+      assertFalse(Rescheduler.isEnabled(a.command));
+    }
     assertEquals(executor.getPendingTasks() + " should be empty", 0, executor.numPendingTasks());
   }
 
+  @After
+  public void cleanUp() {
+    LoadBalancerRegistry.getDefaultRegistry().deregister(mockLoadBalancerProvider);
+  }
+
   @Test
   public void newCallExitsIdleness() throws Exception {
-    final EquivalentAddressGroup addressGroup = addressGroupList.get(1);
-    doAnswer(new Answer<ClientTransport>() {
-        @Override
-        public ClientTransport answer(InvocationOnMock invocation) throws Throwable {
-          return channel.tm.getTransport(addressGroup);
-        }
-      }).when(mockLoadBalancer).pickTransport(any(Attributes.class));
-
     ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
     call.start(mockCallListener, new Metadata());
 
-    verify(mockLoadBalancerFactory).newLoadBalancer(anyString(), same(channel.tm));
-    // NameResolver is started in the scheduled executor
-    timer.runDueTasks();
-    verify(mockNameResolver).start(nameResolverListenerCaptor.capture());
+    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
+    deliverResolutionResult();
 
-    // LoadBalancer is used right after created.
-    verify(mockLoadBalancer).pickTransport(any(Attributes.class));
-    verify(mockTransportFactory).newClientTransport(
-        addressGroup.getAddresses().get(0), AUTHORITY, USER_AGENT);
-
-    // Simulate new address resolved
-    nameResolverListenerCaptor.getValue().onUpdate(servers, Attributes.EMPTY);
-    verify(mockLoadBalancer).handleResolvedAddresses(servers, Attributes.EMPTY);
+    ArgumentCaptor<ResolvedAddresses> resolvedAddressCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
+    assertThat(resolvedAddressCaptor.getValue().getAddresses())
+        .containsExactlyElementsIn(servers);
   }
 
   @Test
-  public void newCallResetsGracePeriod() throws Exception {
-    final EquivalentAddressGroup addressGroup = addressGroupList.get(1);
-    doAnswer(new Answer<ClientTransport>() {
-        @Override
-        public ClientTransport answer(InvocationOnMock invocation) throws Throwable {
-          return channel.tm.getTransport(addressGroup);
-        }
-      }).when(mockLoadBalancer).pickTransport(any(Attributes.class));
-
+  public void newCallRefreshesIdlenessTimer() throws Exception {
+    // First call to exit the initial idleness, then immediately cancel the call.
     ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
     call.start(mockCallListener, new Metadata());
-    call.cancel("cleanup", null);
-    executor.runDueTasks();
-
-    timer.runDueTasks();
-    verify(mockLoadBalancerFactory).newLoadBalancer(anyString(), same(channel.tm));
-    verify(mockLoadBalancer).pickTransport(any(Attributes.class));
+    call.cancel("For testing", null);
 
-    // Enter grace period
-    timer.forwardTime(TimeUnit.SECONDS.toMillis(IDLE_TIMEOUT_SECONDS)
-        - ManagedChannelImpl.IDLE_GRACE_PERIOD_MILLIS, TimeUnit.MILLISECONDS);
-    assertTrue(channel.isInIdleGracePeriod());
-
-    call = channel.newCall(method, CallOptions.DEFAULT);
-    call.start(mockCallListener, new Metadata());
-    assertFalse(channel.isInIdleGracePeriod());
-    call.cancel("cleanup", null);
-    executor.runDueTasks();
-
-    // Load balancer was reused.
-    timer.runDueTasks();
-    verify(mockLoadBalancerFactory).newLoadBalancer(anyString(), same(channel.tm));
-    verify(mockLoadBalancer, times(2)).pickTransport(any(Attributes.class));
+    // Verify that we have exited the idle mode
+    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
+    deliverResolutionResult();
+    assertFalse(channel.inUseStateAggregator.isInUse());
+    verify(mockCallListener).onClose(any(Status.class), any(Metadata.class));
 
-    // Now just let time pass to allow the original idle time to be well past expired.
+    // Move closer to idleness, but not yet.
     timer.forwardTime(IDLE_TIMEOUT_SECONDS - 1, TimeUnit.SECONDS);
+    verify(mockLoadBalancer, never()).shutdown();
+    assertFalse(channel.inUseStateAggregator.isInUse());
 
+    // A new call would refresh the timer
     call = channel.newCall(method, CallOptions.DEFAULT);
     call.start(mockCallListener, new Metadata());
+    call.cancel("For testing", null);
+    assertFalse(channel.inUseStateAggregator.isInUse());
 
-    // Load balancer was reused; the idle time period must have been reset.
-    timer.runDueTasks();
-    verify(mockLoadBalancerFactory).newLoadBalancer(anyString(), same(channel.tm));
-    verify(mockLoadBalancer, times(3)).pickTransport(any(Attributes.class));
-  }
-
-  @Test
-  public void shutdownDuringGracePeriodShutdownLb() throws Exception {
-    forceExitIdleMode();
-    verify(mockLoadBalancerFactory).newLoadBalancer(anyString(), same(channel.tm));
-    // Enter grace period
-    timer.forwardTime(TimeUnit.SECONDS.toMillis(IDLE_TIMEOUT_SECONDS)
-        - ManagedChannelImpl.IDLE_GRACE_PERIOD_MILLIS, TimeUnit.MILLISECONDS);
+    // ... so that passing the same length of time will not trigger idle mode
+    timer.forwardTime(IDLE_TIMEOUT_SECONDS - 1, TimeUnit.SECONDS);
     verify(mockLoadBalancer, never()).shutdown();
-    channel.shutdown();
-    verify(mockLoadBalancer).shutdown();
-  }
-
-  @Test
-  public void enterIdleModeAfterForceExit() throws Exception {
-    forceExitIdleMode();
-
-    // Trigger the creation of TransportSets
-    for (EquivalentAddressGroup addressGroup : addressGroupList) {
-      channel.tm.getTransport(addressGroup);
-      verify(mockTransportFactory).newClientTransport(
-          addressGroup.getAddresses().get(0), AUTHORITY, USER_AGENT);
-    }
-    ArrayList<MockClientTransportInfo> transports = new ArrayList<MockClientTransportInfo>();
-    newTransports.drainTo(transports);
-    assertEquals(addressGroupList.size(), transports.size());
+    assertFalse(channel.inUseStateAggregator.isInUse());
 
-    channel.tm.createInterimTransport();
+    // ... until the time since last call has reached the timeout
+    timer.forwardTime(1, TimeUnit.SECONDS);
+    verify(mockLoadBalancer).shutdown();
+    assertFalse(channel.inUseStateAggregator.isInUse());
 
-    // Without actually using these transports, will eventually enter idle mode
-    walkIntoIdleMode(transports);
+    executor.runDueTasks();
+    verify(mockCallListener, times(2)).onClose(any(Status.class), any(Metadata.class));
   }
 
   @Test
-  public void interimTransportHoldsOffIdleness() throws Exception {
-    doAnswer(new Answer<ClientTransport>() {
-        @Override
-        public ClientTransport answer(InvocationOnMock invocation) throws Throwable {
-          return channel.tm.createInterimTransport().transport();
-        }
-      }).when(mockLoadBalancer).pickTransport(any(Attributes.class));
-
+  public void delayedTransportHoldsOffIdleness() throws Exception {
     ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
     call.start(mockCallListener, new Metadata());
+    deliverResolutionResult();
     assertTrue(channel.inUseStateAggregator.isInUse());
-    // NameResolver is started in the scheduled executor
-    timer.runDueTasks();
 
-    // As long as the interim transport is in-use (by the pending RPC), the channel won't go idle.
+    // As long as the delayed transport is in-use (by the pending RPC), the channel won't go idle.
     timer.forwardTime(IDLE_TIMEOUT_SECONDS * 2, TimeUnit.SECONDS);
     assertTrue(channel.inUseStateAggregator.isInUse());
 
@@ -300,116 +295,276 @@ public ClientTransport answer(InvocationOnMock invocation) throws Throwable {
     assertEquals(1, executor.runDueTasks());
     assertFalse(channel.inUseStateAggregator.isInUse());
     // And allow the channel to go idle.
-    walkIntoIdleMode(Collections.<MockClientTransportInfo>emptyList());
+    timer.forwardTime(IDLE_TIMEOUT_SECONDS - 1, TimeUnit.SECONDS);
+    verify(mockLoadBalancer, never()).shutdown();
+    timer.forwardTime(1, TimeUnit.SECONDS);
+    verify(mockLoadBalancer).shutdown();
+  }
+
+  @Test
+  public void pendingCallExitsIdleAfterEnter() throws Exception {
+    // Create a pending call without starting it.
+    channel.newCall(method, CallOptions.DEFAULT);
+
+    channel.enterIdle();
+
+    // Just the existence of a non-started, pending call means the channel cannot stay
+    // in idle mode because the expectation is that the pending call will also need to
+    // be handled.
+    verify(mockNameResolver, times(2)).start(any(NameResolver.Listener2.class));
+  }
+
+  @Test
+  public void delayedTransportExitsIdleAfterEnter() throws Exception {
+    // Start a new call that will go to the delayed transport
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
+    deliverResolutionResult();
+
+    channel.enterIdle();
+
+    // Since we have a call in delayed transport, the call to enterIdle() should have resulted in
+    // the channel going to idle mode and then immediately exiting. We confirm this by verifying
+    // that the name resolver was started up twice - once when the call was first created and a
+    // second time after exiting idle mode.
+    verify(mockNameResolver, times(2)).start(any(NameResolver.Listener2.class));
   }
 
   @Test
   public void realTransportsHoldsOffIdleness() throws Exception {
-    final EquivalentAddressGroup addressGroup = addressGroupList.get(1);
-    doAnswer(new Answer<ClientTransport>() {
-        @Override
-        public ClientTransport answer(InvocationOnMock invocation) throws Throwable {
-          return channel.tm.getTransport(addressGroup);
-        }
-      }).when(mockLoadBalancer).pickTransport(any(Attributes.class));
+    final EquivalentAddressGroup addressGroup = servers.get(1);
 
+    // Start a call, which goes to delayed transport
     ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
     call.start(mockCallListener, new Metadata());
 
-    // A TransportSet is in-use, while the stream is pending in a delayed transport
+    // Verify that we have exited the idle mode
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+    deliverResolutionResult();
+    Helper helper = helperCaptor.getValue();
     assertTrue(channel.inUseStateAggregator.isInUse());
-    // NameResolver is started in the scheduled executor
-    timer.runDueTasks();
 
-    // Making the real transport ready, will release the delayed transport.
-    // The TransportSet is *not* in-use before the real transport become in-use.
+    // Assume LoadBalancer has received an address, then create a subchannel.
+    Subchannel subchannel = createSubchannelSafely(helper, addressGroup, Attributes.EMPTY);
+    requestConnectionSafely(helper, subchannel);
     MockClientTransportInfo t0 = newTransports.poll();
-    assertEquals(0, executor.numPendingTasks());
     t0.listener.transportReady();
-    // Real streams are started in the executor
-    assertEquals(1, executor.runDueTasks());
+
+    SubchannelPicker mockPicker = mock(SubchannelPicker.class);
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(subchannel));
+    updateBalancingStateSafely(helper, READY, mockPicker);
+    // Delayed transport creates real streams in the app executor
+    executor.runDueTasks();
+
+    // Delayed transport exits in-use, while real transport has not entered in-use yet.
     assertFalse(channel.inUseStateAggregator.isInUse());
+
+    // Now it's in-use
     t0.listener.transportInUse(true);
     assertTrue(channel.inUseStateAggregator.isInUse());
 
     // As long as the transport is in-use, the channel won't go idle.
     timer.forwardTime(IDLE_TIMEOUT_SECONDS * 2, TimeUnit.SECONDS);
+    assertTrue(channel.inUseStateAggregator.isInUse());
 
     t0.listener.transportInUse(false);
     assertFalse(channel.inUseStateAggregator.isInUse());
     // And allow the channel to go idle.
-    walkIntoIdleMode(Arrays.asList(t0));
+    timer.forwardTime(IDLE_TIMEOUT_SECONDS - 1, TimeUnit.SECONDS);
+    verify(mockLoadBalancer, never()).shutdown();
+    timer.forwardTime(1, TimeUnit.SECONDS);
+    verify(mockLoadBalancer).shutdown();
   }
 
   @Test
-  public void idlenessDecommissionsTransports() throws Exception {
-    EquivalentAddressGroup addressGroup = addressGroupList.get(0);
-    forceExitIdleMode();
+  public void enterIdleWhileRealTransportInProgress() {
+    final EquivalentAddressGroup addressGroup = servers.get(1);
 
-    channel.tm.getTransport(addressGroup);
+    // Start a call, which goes to delayed transport
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
+
+    // Verify that we have exited the idle mode
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+    deliverResolutionResult();
+    Helper helper = helperCaptor.getValue();
+
+    // Create a subchannel for the real transport to happen on.
+    Subchannel subchannel = createSubchannelSafely(helper, addressGroup, Attributes.EMPTY);
+    requestConnectionSafely(helper, subchannel);
     MockClientTransportInfo t0 = newTransports.poll();
     t0.listener.transportReady();
-    assertSame(t0.transport, channelTmGetTransportUnwrapped(addressGroup));
 
-    walkIntoIdleMode(Arrays.asList(t0));
-    verify(t0.transport).shutdown();
+    SubchannelPicker mockPicker = mock(SubchannelPicker.class);
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+            .thenReturn(PickResult.withSubchannel(subchannel));
+    updateBalancingStateSafely(helper, READY, mockPicker);
+
+    // Delayed transport creates real streams in the app executor
+    executor.runDueTasks();
+
+    // Move transport to the in-use state
+    t0.listener.transportInUse(true);
+
+    // Now we enter Idle mode while real transport is happening
+    channel.enterIdle();
 
-    forceExitIdleMode();
-    channel.tm.getTransport(addressGroup);
+    // Verify that the name resolver and the load balance were shut down.
+    verify(mockNameResolver).shutdown();
+    verify(mockLoadBalancer).shutdown();
+
+    // When there are no pending streams, the call to enterIdle() should stick and
+    // we remain in idle mode. We verify this by making sure that the name resolver
+    // was not started up more than once (the initial startup).
+    verify(mockNameResolver, atMostOnce()).start(isA(NameResolver.Listener2.class));
+  }
+
+  @Test
+  public void updateSubchannelAddresses_newAddressConnects() {
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata()); // Create LB
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+    deliverResolutionResult();
+    Helper helper = helperCaptor.getValue();
+    Subchannel subchannel = createSubchannelSafely(helper, servers.get(0), Attributes.EMPTY);
+
+    requestConnectionSafely(helper, subchannel);
+    MockClientTransportInfo t0 = newTransports.poll();
+    t0.listener.transportReady();
+
+    updateSubchannelAddressesSafely(helper, subchannel, servers.get(1));
+
+    requestConnectionSafely(helper, subchannel);
     MockClientTransportInfo t1 = newTransports.poll();
     t1.listener.transportReady();
 
-    assertSame(t1.transport, channelTmGetTransportUnwrapped(addressGroup));
-    assertNotSame(t0.transport, channelTmGetTransportUnwrapped(addressGroup));
+    // Drain InternalSubchannel's delayed shutdown on updateAddresses
+    timer.forwardTime(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS, TimeUnit.SECONDS);
+  }
 
-    channel.shutdown();
-    verify(t1.transport).shutdown();
-    channel.shutdownNow();
-    verify(t0.transport).shutdownNow(any(Status.class));
-    verify(t1.transport).shutdownNow(any(Status.class));
+  @Test
+  public void updateSubchannelAddresses_existingAddressDoesNotConnect() {
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata()); // Create LB
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+    deliverResolutionResult();
+    Helper helper = helperCaptor.getValue();
+    Subchannel subchannel = createSubchannelSafely(helper, servers.get(0), Attributes.EMPTY);
+
+    requestConnectionSafely(helper, subchannel);
+    MockClientTransportInfo t0 = newTransports.poll();
+    t0.listener.transportReady();
+
+    List<SocketAddress> changedList = new ArrayList<>(servers.get(0).getAddresses());
+    changedList.add(new FakeSocketAddress("aDifferentServer"));
+    updateSubchannelAddressesSafely(helper, subchannel, new EquivalentAddressGroup(changedList));
 
-    t1.listener.transportTerminated();
-    assertFalse(channel.isTerminated());
-    t0.listener.transportTerminated();
-    assertTrue(channel.isTerminated());
+    requestConnectionSafely(helper, subchannel);
+    assertNull(newTransports.poll());
   }
 
   @Test
-  public void loadBalancerShouldNotCreateConnectionsWhenIdle() throws Exception {
-    // Acts as a misbehaving LoadBalancer that tries to create connections when channel is in idle,
-    // which means the LoadBalancer is supposedly shutdown.
-    assertSame(ManagedChannelImpl.IDLE_MODE_TRANSPORT,
-        channel.tm.getTransport(addressGroupList.get(0)));
-    OobTransportProvider<ClientTransport> oobProvider =
-        channel.tm.createOobTransportProvider(addressGroupList.get(0), AUTHORITY);
-    assertSame(ManagedChannelImpl.IDLE_MODE_TRANSPORT, oobProvider.get());
-    oobProvider.close();
-    verify(mockTransportFactory, never()).newClientTransport(
-        any(SocketAddress.class), anyString(), anyString());
-    // We don't care for delayed (interim) transports, because they don't create connections.
-  }
+  public void oobTransportDoesNotAffectIdleness() {
+    // Start a call, which goes to delayed transport
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
 
-  private void walkIntoIdleMode(Collection<MockClientTransportInfo> currentTransports) {
-    timer.forwardTime(IDLE_TIMEOUT_SECONDS - 1, TimeUnit.SECONDS);
+    // Verify that we have exited the idle mode
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+    Helper helper = helperCaptor.getValue();
+    deliverResolutionResult();
+
+    // Fail the RPC
+    SubchannelPicker failingPicker = mock(SubchannelPicker.class);
+    when(failingPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withError(Status.UNAVAILABLE));
+    updateBalancingStateSafely(helper, TRANSIENT_FAILURE, failingPicker);
+    executor.runDueTasks();
+    verify(mockCallListener).onClose(same(Status.UNAVAILABLE), any(Metadata.class));
+
+    // ... so that the channel resets its in-use state
+    assertFalse(channel.inUseStateAggregator.isInUse());
+
+    // Now make an RPC on an OOB channel
+    ManagedChannel oob = helper.createOobChannel(servers, "oobauthority");
+    verify(mockTransportFactory, never())
+        .newClientTransport(
+            any(SocketAddress.class),
+            eq(new ClientTransportFactory.ClientTransportOptions()
+              .setAuthority("oobauthority")
+              .setUserAgent(USER_AGENT)),
+            any(ChannelLogger.class));
+    ClientCall<String, Integer> oobCall = oob.newCall(method, CallOptions.DEFAULT);
+    oobCall.start(mockCallListener2, new Metadata());
+    verify(mockTransportFactory)
+        .newClientTransport(
+            any(SocketAddress.class),
+            eq(new ClientTransportFactory.ClientTransportOptions()
+              .setAuthority("oobauthority")
+              .setUserAgent(USER_AGENT)),
+            any(ChannelLogger.class));
+    MockClientTransportInfo oobTransportInfo = newTransports.poll();
+    assertEquals(0, newTransports.size());
+    // The OOB transport reports in-use state
+    oobTransportInfo.listener.transportInUse(true);
+
+    // But it won't stop the channel from going idle
     verify(mockLoadBalancer, never()).shutdown();
-    verify(mockNameResolver, never()).shutdown();
-    for (MockClientTransportInfo transport : currentTransports) {
-      verify(transport.transport, never()).shutdown();
-    }
-    timer.forwardTime(1, TimeUnit.SECONDS);
+    timer.forwardTime(IDLE_TIMEOUT_SECONDS, TimeUnit.SECONDS);
     verify(mockLoadBalancer).shutdown();
-    verify(mockNameResolver).shutdown();
-    for (MockClientTransportInfo transport : currentTransports) {
-      verify(transport.transport).shutdown();
-    }
   }
 
-  private void forceExitIdleMode() {
-    channel.exitIdleModeAndGetLb();
+  @Test
+  public void updateOobChannelAddresses_newAddressConnects() {
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata()); // Create LB
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+    deliverResolutionResult();
+    Helper helper = helperCaptor.getValue();
+    ManagedChannel oobChannel = helper.createOobChannel(servers.subList(0,1), "localhost");
+
+    oobChannel.newCall(method, CallOptions.DEFAULT).start(mockCallListener, new Metadata());
+    MockClientTransportInfo t0 = newTransports.poll();
+    t0.listener.transportReady();
+
+    helper.updateOobChannelAddresses(oobChannel, servers.subList(1,2));
+
+    oobChannel.newCall(method, CallOptions.DEFAULT).start(mockCallListener, new Metadata());
+    MockClientTransportInfo t1 = newTransports.poll();
+    t1.listener.transportReady();
+
+    // Drain InternalSubchannel's delayed shutdown on updateAddresses
+    timer.forwardTime(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS, TimeUnit.SECONDS);
   }
 
-  private ClientTransport channelTmGetTransportUnwrapped(EquivalentAddressGroup addressGroup) {
-    return ((ForwardingConnectionClientTransport) channel.tm.getTransport(addressGroup)).delegate();
+  @Test
+  public void updateOobChannelAddresses_existingAddressDoesNotConnect() {
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata()); // Create LB
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+    Helper helper = helperCaptor.getValue();
+    deliverResolutionResult();
+    ManagedChannel oobChannel = helper.createOobChannel(servers.subList(0,1), "localhost");
+
+    oobChannel.newCall(method, CallOptions.DEFAULT).start(mockCallListener, new Metadata());
+    MockClientTransportInfo t0 = newTransports.poll();
+    t0.listener.transportReady();
+
+    List<SocketAddress> changedList = new ArrayList<>(servers.get(0).getAddresses());
+    changedList.add(new FakeSocketAddress("aDifferentServer"));
+    helper.updateOobChannelAddresses(oobChannel, Collections.singletonList(
+        new EquivalentAddressGroup(changedList)));
+
+    oobChannel.newCall(method, CallOptions.DEFAULT).start(mockCallListener, new Metadata());
+    assertNull(newTransports.poll());
   }
 
   private static class FakeBackoffPolicyProvider implements BackoffPolicy.Provider {
@@ -417,7 +572,7 @@ private static class FakeBackoffPolicyProvider implements BackoffPolicy.Provider
     public BackoffPolicy get() {
       return new BackoffPolicy() {
         @Override
-        public long nextBackoffMillis() {
+        public long nextBackoffNanos() {
           return 1;
         }
       };
@@ -436,4 +591,68 @@ public String toString() {
       return "FakeSocketAddress-" + name;
     }
   }
+
+  // Helper methods to call methods from SynchronizationContext
+  private Subchannel createSubchannelSafely(
+      final Helper helper, final EquivalentAddressGroup addressGroup, final Attributes attrs) {
+    final AtomicReference<Subchannel> resultCapture = new AtomicReference<>();
+    helper.getSynchronizationContext().execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            Subchannel s = helper.createSubchannel(CreateSubchannelArgs.newBuilder()
+                .setAddresses(addressGroup)
+                .setAttributes(attrs)
+                .build());
+            s.start(subchannelStateListener);
+            resultCapture.set(s);
+          }
+        });
+    return resultCapture.get();
+  }
+
+  private void deliverResolutionResult() {
+    verify(mockNameResolver).start(nameResolverListenerCaptor.capture());
+    // Simulate new address resolved to make sure the LoadBalancer is correctly linked to
+    // the NameResolver.
+    ResolutionResult resolutionResult =
+        ResolutionResult.newBuilder()
+            .setAddressesOrError(StatusOr.fromValue(servers))
+            .setAttributes(Attributes.EMPTY)
+            .build();
+    nameResolverListenerCaptor.getValue().onResult(resolutionResult);
+    executor.runDueTasks();
+  }
+
+  private static void requestConnectionSafely(Helper helper, final Subchannel subchannel) {
+    helper.getSynchronizationContext().execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            subchannel.requestConnection();
+          }
+        });
+  }
+
+  private static void updateBalancingStateSafely(
+      final Helper helper, final ConnectivityState state, final SubchannelPicker picker) {
+    helper.getSynchronizationContext().execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            helper.updateBalancingState(state, picker);
+          }
+        });
+  }
+
+  private static void updateSubchannelAddressesSafely(
+      final Helper helper, final Subchannel subchannel, final EquivalentAddressGroup addrs) {
+    helper.getSynchronizationContext().execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            subchannel.updateAddresses(Collections.singletonList(addrs));
+          }
+        });
+  }
 }
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java
index f03a33c5718..ae224af27e1 100644
--- a/core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelImplTest.java
@@ -1,147 +1,282 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static io.grpc.ClientStreamTracer.NAME_RESOLUTION_DELAYED;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static io.grpc.EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE;
+import static io.grpc.PickSubchannelArgsMatcher.eqPickSubchannelArgs;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
+import static io.grpc.internal.UriWrapper.wrap;
+import static junit.framework.TestCase.assertNotSame;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Matchers.same;
+import static org.junit.Assert.fail;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.atLeast;
-import static org.mockito.Mockito.atMost;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
+import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
 import io.grpc.Attributes;
+import io.grpc.BinaryLog;
 import io.grpc.CallCredentials;
-import io.grpc.CallCredentials.MetadataApplier;
+import io.grpc.CallCredentials.RequestInfo;
 import io.grpc.CallOptions;
 import io.grpc.Channel;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
 import io.grpc.ClientCall;
 import io.grpc.ClientInterceptor;
-import io.grpc.Compressor;
-import io.grpc.CompressorRegistry;
+import io.grpc.ClientInterceptors;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ClientStreamTracer.StreamInfo;
+import io.grpc.ClientTransportFilter;
+import io.grpc.CompositeChannelCredentials;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
 import io.grpc.Context;
-import io.grpc.DecompressorRegistry;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.InsecureChannelCredentials;
 import io.grpc.IntegerMarshaller;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.ChannelStats;
+import io.grpc.InternalChannelz.ChannelTrace;
+import io.grpc.InternalChannelz.ChannelTrace.Event.Severity;
+import io.grpc.InternalConfigSelector;
+import io.grpc.InternalInstrumented;
 import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.LongCounterMetricInstrument;
+import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.MetricInstrumentRegistry;
+import io.grpc.MetricSink;
 import io.grpc.NameResolver;
-import io.grpc.PickFirstBalancerFactory;
-import io.grpc.ResolvedServerInfo;
-import io.grpc.ResolvedServerInfoGroup;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.NameResolver.ResolutionResult;
+import io.grpc.NameResolverProvider;
+import io.grpc.NameResolverRegistry;
+import io.grpc.ProxiedSocketAddress;
+import io.grpc.ProxyDetector;
 import io.grpc.SecurityLevel;
+import io.grpc.ServerMethodDefinition;
 import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.StatusOr;
 import io.grpc.StringMarshaller;
-import io.grpc.TransportManager;
-import io.grpc.internal.testing.StatsTestUtils.FakeStatsContextFactory;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.ClientTransportFactory.ClientTransportOptions;
+import io.grpc.internal.ClientTransportFactory.SwapChannelCredentialsResult;
+import io.grpc.internal.InternalSubchannel.TransportLogger;
+import io.grpc.internal.ManagedChannelImplBuilder.ClientTransportFactoryBuilder;
+import io.grpc.internal.ManagedChannelImplBuilder.FixedPortProvider;
+import io.grpc.internal.ManagedChannelImplBuilder.UnsupportedClientTransportFactoryBuilder;
+import io.grpc.internal.ManagedChannelServiceConfig.MethodInfo;
+import io.grpc.internal.ServiceConfigUtil.PolicySelection;
+import io.grpc.internal.TestUtils.MockClientTransportInfo;
+import io.grpc.stub.ClientCalls;
+import io.grpc.testing.TestMethodDescriptors;
+import io.grpc.util.ForwardingSubchannel;
+import java.io.IOException;
+import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.net.URI;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.concurrent.CyclicBarrier;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
 import org.junit.After;
+import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
-import org.mockito.Matchers;
+import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
 import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.mockito.stubbing.Answer;
 
 /** Unit tests for {@link ManagedChannelImpl}. */
 @RunWith(JUnit4.class)
+// TODO(creamsoup) remove backward compatible check when fully migrated
+@SuppressWarnings({"deprecation"})
 public class ManagedChannelImplTest {
-  private static final List<ClientInterceptor> NO_INTERCEPTOR =
-      Collections.<ClientInterceptor>emptyList();
-  private static final Attributes NAME_RESOLVER_PARAMS =
-      Attributes.newBuilder().set(NameResolver.Factory.PARAMS_DEFAULT_PORT, 447).build();
-  private final MethodDescriptor<String, Integer> method =
+  private static final int DEFAULT_PORT = 447;
+
+  private static final MethodDescriptor<String, Integer> method =
       MethodDescriptor.<String, Integer>newBuilder()
           .setType(MethodType.UNKNOWN)
-          .setFullMethodName("/service/method")
+          .setFullMethodName("service/method")
           .setRequestMarshaller(new StringMarshaller())
           .setResponseMarshaller(new IntegerMarshaller())
           .build();
-  private final String serviceName = "fake.example.com";
-  private final String authority = serviceName;
-  private final String userAgent = "userAgent";
-  private final String target = "fake://" + serviceName;
+  private static final Attributes.Key<String> SUBCHANNEL_ATTR_KEY =
+      Attributes.Key.create("subchannel-attr-key");
+  private static final long RECONNECT_BACKOFF_INTERVAL_NANOS = 10;
+  private static final String SERVICE_NAME = "fake.example.com";
+  private static final String AUTHORITY = SERVICE_NAME;
+  private static final String USER_AGENT = "userAgent";
+  private static final ClientTransportOptions clientTransportOptions =
+      new ClientTransportOptions()
+          .setAuthority(AUTHORITY)
+          .setUserAgent(USER_AGENT);
+  private static final String TARGET = "fake://" + SERVICE_NAME;
+  private static final String MOCK_POLICY_NAME = "mock_lb";
+  private static final NameResolver.Args NAMERESOLVER_ARGS = NameResolver.Args.newBuilder()
+      .setDefaultPort(447)
+      .setProxyDetector(mock(ProxyDetector.class))
+      .setSynchronizationContext(
+          new SynchronizationContext(mock(Thread.UncaughtExceptionHandler.class)))
+      .setServiceConfigParser(mock(NameResolver.ServiceConfigParser.class))
+      .setScheduledExecutorService(new FakeClock().getScheduledExecutorService())
+      .build();
+  private static final NameResolver.Args.Key<String> TEST_RESOLVER_CUSTOM_ARG_KEY =
+      NameResolver.Args.Key.create("test-key");
+
   private URI expectedUri;
-  private final SocketAddress socketAddress = new SocketAddress() {};
-  private final ResolvedServerInfo server = new ResolvedServerInfo(socketAddress, Attributes.EMPTY);
+  private final SocketAddress socketAddress =
+      new SocketAddress() {
+        @Override
+        public String toString() {
+          return "test-addr";
+        }
+      };
+  private final SocketAddress socketAddress2 =
+      new SocketAddress() {
+        @Override
+        public String toString() {
+          return "test-addr";
+        }
+      };
+  private final EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(socketAddress);
+  private final EquivalentAddressGroup addressGroup2 =
+      new EquivalentAddressGroup(Arrays.asList(socketAddress, socketAddress2));
   private final FakeClock timer = new FakeClock();
   private final FakeClock executor = new FakeClock();
-  private final FakeStatsContextFactory statsCtxFactory = new FakeStatsContextFactory();
-  private SpyingLoadBalancerFactory loadBalancerFactory =
-      new SpyingLoadBalancerFactory(PickFirstBalancerFactory.getInstance());
+  private final FakeClock balancerRpcExecutor = new FakeClock();
+
+  private final InternalChannelz channelz = new InternalChannelz();
 
-  @Rule public final ExpectedException thrown = ExpectedException.none();
+  private final MetricInstrumentRegistry metricInstrumentRegistry =
+      MetricInstrumentRegistry.getDefaultRegistry();
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
 
   private ManagedChannelImpl channel;
+  private Helper helper;
   @Captor
   private ArgumentCaptor<Status> statusCaptor;
   @Captor
-  private ArgumentCaptor<StatsTraceContext> statsTraceCtxCaptor;
+  private ArgumentCaptor<CallOptions> callOptionsCaptor;
+  @Captor
+  private ArgumentCaptor<ClientStreamTracer[]> tracersCaptor;
+  @Mock
+  private LoadBalancer mockLoadBalancer;
+  @Mock
+  private SubchannelStateListener subchannelStateListener;
+  private final LoadBalancerProvider mockLoadBalancerProvider =
+      mock(LoadBalancerProvider.class, delegatesTo(new LoadBalancerProvider() {
+          @Override
+          public LoadBalancer newLoadBalancer(Helper helper) {
+            return mockLoadBalancer;
+          }
+
+          @Override
+          public boolean isAvailable() {
+            return true;
+          }
+
+          @Override
+          public int getPriority() {
+            return 999;
+          }
+
+          @Override
+          public String getPolicyName() {
+            return MOCK_POLICY_NAME;
+          }
+        }));
+
+  @Captor
+  private ArgumentCaptor<ConnectivityStateInfo> stateInfoCaptor;
   @Mock
-  private ConnectionClientTransport mockTransport;
+  private SubchannelPicker mockPicker;
   @Mock
   private ClientTransportFactory mockTransportFactory;
   @Mock
@@ -151,35 +286,92 @@ public class ManagedChannelImplTest {
   @Mock
   private ClientCall.Listener<Integer> mockCallListener3;
   @Mock
-  private SharedResourceHolder.Resource<ScheduledExecutorService> timerService;
+  private ObjectPool<Executor> executorPool;
+  @Mock
+  private ObjectPool<Executor> balancerRpcExecutorPool;
   @Mock
   private CallCredentials creds;
+  @Mock
+  private Executor offloadExecutor;
+  private ManagedChannelImplBuilder channelBuilder;
+  private boolean requestConnection = true;
+  private BlockingQueue<MockClientTransportInfo> transports;
+  private boolean panicExpected;
+  @Captor
+  private ArgumentCaptor<ResolvedAddresses> resolvedAddressCaptor;
 
-  private ArgumentCaptor<ManagedClientTransport.Listener> transportListenerCaptor =
-      ArgumentCaptor.forClass(ManagedClientTransport.Listener.class);
   private ArgumentCaptor<ClientStreamListener> streamListenerCaptor =
       ArgumentCaptor.forClass(ClientStreamListener.class);
 
-  private void createChannel(
-      NameResolver.Factory nameResolverFactory, List<ClientInterceptor> interceptors) {
-    channel = new ManagedChannelImpl(target, new FakeBackoffPolicyProvider(),
-        nameResolverFactory, NAME_RESOLVER_PARAMS, loadBalancerFactory,
-        mockTransportFactory, DecompressorRegistry.getDefaultInstance(),
-        CompressorRegistry.getDefaultInstance(), timerService, timer.getStopwatchSupplier(),
-        ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE,
-        executor.getScheduledExecutorService(), userAgent, interceptors, statsCtxFactory);
-    // Force-exit the initial idle-mode
-    channel.exitIdleModeAndGetLb();
+  private void createChannel(ClientInterceptor... interceptors) {
+    createChannel(false, interceptors);
+  }
+
+  private void createChannel(boolean nameResolutionExpectedToFail,
+      ClientInterceptor... interceptors) {
+    checkState(channel == null);
+
+    when(mockTransportFactory.getSupportedSocketAddressTypes()).thenReturn(Collections.singleton(
+        InetSocketAddress.class));
+    NameResolverProvider nameResolverProvider =
+        channelBuilder.nameResolverRegistry.getProviderForScheme(expectedUri.getScheme());
+    channel = new ManagedChannelImpl(
+        channelBuilder, mockTransportFactory, wrap(expectedUri), nameResolverProvider,
+        new FakeBackoffPolicyProvider(),
+        balancerRpcExecutorPool, timer.getStopwatchSupplier(), Arrays.asList(interceptors),
+        timer.getTimeProvider());
+
+    if (requestConnection) {
+      int numExpectedTasks = nameResolutionExpectedToFail ? 1 : 0;
+
+      // Force-exit the initial idle-mode
+      channel.syncContext.execute(new Runnable() {
+          @Override
+          public void run() {
+            channel.exitIdleMode();
+          }
+        });
+      if (channelBuilder.idleTimeoutMillis != ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE) {
+        numExpectedTasks += 1;
+      }
+
+      assertEquals(numExpectedTasks, timer.numPendingTasks());
+
+      ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+      verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+      helper = helperCaptor.getValue();
+    }
   }
 
   @Before
   public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
-    expectedUri = new URI(target);
-    when(mockTransportFactory.newClientTransport(
-            any(SocketAddress.class), any(String.class), any(String.class)))
-        .thenReturn(mockTransport);
-    when(timerService.create()).thenReturn(timer.getScheduledExecutorService());
+    when(mockLoadBalancer.acceptResolvedAddresses(isA(ResolvedAddresses.class))).thenReturn(
+        Status.OK);
+    LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
+    expectedUri = new URI(TARGET);
+    transports = TestUtils.captureTransports(mockTransportFactory);
+    when(mockTransportFactory.getScheduledExecutorService())
+        .thenReturn(timer.getScheduledExecutorService());
+    when(executorPool.getObject()).thenReturn(executor.getScheduledExecutorService());
+    when(balancerRpcExecutorPool.getObject())
+        .thenReturn(balancerRpcExecutor.getScheduledExecutorService());
+
+    channelBuilder = new ManagedChannelImplBuilder(TARGET,
+        new UnsupportedClientTransportFactoryBuilder(), new FixedPortProvider(DEFAULT_PORT));
+    channelBuilder.disableRetry();
+    configureBuilder(channelBuilder);
+  }
+
+  private void configureBuilder(ManagedChannelImplBuilder channelBuilder) {
+    channelBuilder
+        .nameResolverFactory(new FakeNameResolverFactory.Builder(expectedUri).build())
+        .defaultLoadBalancingPolicy(MOCK_POLICY_NAME)
+        .userAgent(USER_AGENT)
+        .idleTimeout(ManagedChannelImplBuilder.IDLE_MODE_MAX_TIMEOUT_DAYS, TimeUnit.DAYS)
+        .offloadExecutor(offloadExecutor);
+    channelBuilder.executorPool = executorPool;
+    channelBuilder.binlog = null;
+    channelBuilder.channelz = channelz;
   }
 
   @After
@@ -190,17 +382,102 @@ public void allPendingTasksAreRun() throws Exception {
     // would ignore any time-sensitive tasks, e.g., back-off and the idle timer.
     assertTrue(timer.getDueTasks() + " should be empty", timer.getDueTasks().isEmpty());
     assertEquals(executor.getPendingTasks() + " should be empty", 0, executor.numPendingTasks());
+    if (channel != null) {
+      if (!panicExpected) {
+        assertFalse(channel.isInPanicMode());
+      }
+      channel.shutdownNow();
+      channel = null;
+    }
+  }
+
+  @After
+  public void cleanUp() {
+    LoadBalancerRegistry.getDefaultRegistry().deregister(mockLoadBalancerProvider);
+  }
+
+  @Test
+  public void createSubchannel_outsideSynchronizationContextShouldThrow() {
+    createChannel();
+    try {
+      helper.createSubchannel(CreateSubchannelArgs.newBuilder()
+          .setAddresses(addressGroup)
+          .build());
+      fail("Should throw");
+    } catch (IllegalStateException e) {
+      assertThat(e).hasMessageThat().isEqualTo("Not called from the SynchronizationContext");
+    }
+  }
+
+  @Test
+  public void createSubchannel_resolverOverrideAuthority() {
+    EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(
+        socketAddress,
+        Attributes.newBuilder()
+            .set(ATTR_AUTHORITY_OVERRIDE, "resolver.override.authority")
+            .build());
+    channelBuilder.nameResolverFactory(
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(addressGroup))
+            .build());
+    createChannel();
+
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
+    ArgumentCaptor<ClientTransportOptions> transportOptionCaptor =
+        ArgumentCaptor.forClass(ClientTransportOptions.class);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            any(SocketAddress.class), transportOptionCaptor.capture(), any(ChannelLogger.class));
+    assertThat(transportOptionCaptor.getValue().getAuthority())
+        .isEqualTo("resolver.override.authority");
+  }
+
+  @Test
+  public void createSubchannel_channelBuilderOverrideAuthority() {
+    channelBuilder.overrideAuthority("channel-builder.override.authority");
+    EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(
+        socketAddress,
+        Attributes.newBuilder()
+            .set(ATTR_AUTHORITY_OVERRIDE, "resolver.override.authority")
+            .build());
+    channelBuilder.nameResolverFactory(
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(addressGroup))
+            .build());
+    createChannel();
+
+    final Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
+    ArgumentCaptor<ClientTransportOptions> transportOptionCaptor =
+        ArgumentCaptor.forClass(ClientTransportOptions.class);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            any(SocketAddress.class), transportOptionCaptor.capture(), any(ChannelLogger.class));
+    assertThat(transportOptionCaptor.getValue().getAuthority())
+        .isEqualTo("channel-builder.override.authority");
+    final List<EquivalentAddressGroup> subchannelEags = new ArrayList<>();
+    helper.getSynchronizationContext().execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            subchannelEags.addAll(subchannel.getAllAddresses());
+          }
+        });
+    assertThat(subchannelEags).isEqualTo(ImmutableList.of(addressGroup));
   }
 
-  /**
-   * The counterpart of {@link ManagedChannelImplIdlenessTest#enterIdleModeAfterForceExit}.
-   */
   @Test
-  @SuppressWarnings("unchecked")
   public void idleModeDisabled() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    assertEquals(1, loadBalancerFactory.balancers.size());
+    channelBuilder.nameResolverFactory(
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+            .build());
+    createChannel();
 
+    // In this test suite, the channel is always created with idle mode disabled.
     // No task is scheduled to enter idle mode
     assertEquals(0, timer.numPendingTasks());
     assertEquals(0, executor.numPendingTasks());
@@ -208,7 +485,7 @@ public void idleModeDisabled() {
 
   @Test
   public void immediateDeadlineExceeded() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
+    createChannel();
     ClientCall<String, Integer> call =
         channel.newCall(method, CallOptions.DEFAULT.withDeadlineAfter(0, TimeUnit.NANOSECONDS));
     call.start(mockCallListener, new Metadata());
@@ -220,230 +497,677 @@ public void immediateDeadlineExceeded() {
   }
 
   @Test
-  public void shutdownWithNoTransportsEverCreated() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    verifyNoMoreInteractions(mockTransportFactory);
-    channel.shutdown();
-    assertTrue(channel.isShutdown());
-    assertTrue(channel.isTerminated());
+  public void startCallBeforeNameResolution() throws Exception {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(ImmutableList.of(addressGroup)).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    when(mockTransportFactory.getSupportedSocketAddressTypes()).thenReturn(Collections.singleton(
+        InetSocketAddress.class));
+    channel = new ManagedChannelImpl(
+        channelBuilder, mockTransportFactory, wrap(expectedUri), nameResolverFactory,
+        new FakeBackoffPolicyProvider(),
+        balancerRpcExecutorPool, timer.getStopwatchSupplier(),
+        Collections.<ClientInterceptor>emptyList(), timer.getTimeProvider());
+    Map<String, Object> rawServiceConfig =
+        parseConfig("{\"methodConfig\":[{"
+            + "\"name\":[{\"service\":\"service\"}],"
+            + "\"waitForReady\":true}]}");
+    ManagedChannelServiceConfig managedChannelServiceConfig =
+        createManagedChannelServiceConfig(rawServiceConfig, null);
+    nameResolverFactory.nextConfigOrError.set(
+        ConfigOrError.fromConfig(managedChannelServiceConfig));
+    Metadata headers = new Metadata();
+    ClientStream mockStream = mock(ClientStream.class);
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, headers);
+
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+    helper = helperCaptor.getValue();
+    // Make the transport available
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    verify(mockTransportFactory, never())
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    requestConnectionSafely(helper, subchannel);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    MockClientTransportInfo transportInfo = transports.poll();
+    ConnectionClientTransport mockTransport = transportInfo.transport;
+    ManagedClientTransport.Listener transportListener = transportInfo.listener;
+    when(mockTransport.newStream(
+            same(method), same(headers), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream);
+    transportListener.transportReady();
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(subchannel));
+    updateBalancingStateSafely(helper, READY, mockPicker);
+    executor.runDueTasks();
+
+    ArgumentCaptor<CallOptions> callOptionsCaptor = ArgumentCaptor.forClass(CallOptions.class);
+    verify(mockTransport).newStream(
+        same(method), same(headers), callOptionsCaptor.capture(),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    assertThat(callOptionsCaptor.getValue().isWaitForReady()).isTrue();
+    verify(mockStream).start(streamListenerCaptor.capture());
+
+    // Clean up as much as possible to allow the channel to terminate.
+    shutdownSafely(helper, subchannel);
+    timer.forwardNanos(
+        TimeUnit.SECONDS.toNanos(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS));
   }
 
   @Test
-  public void twoCallsAndGracefulShutdown() {
-    FakeNameResolverFactory nameResolverFactory = new FakeNameResolverFactory(true);
-    createChannel(nameResolverFactory, NO_INTERCEPTOR);
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    verifyNoMoreInteractions(mockTransportFactory);
-
-    // Create transport and call
-    ClientStream mockStream = mock(ClientStream.class);
+  public void newCallWithConfigSelector() {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(ImmutableList.of(addressGroup)).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    when(mockTransportFactory.getSupportedSocketAddressTypes()).thenReturn(Collections.singleton(
+        InetSocketAddress.class));
+    channel = new ManagedChannelImpl(
+        channelBuilder, mockTransportFactory, wrap(expectedUri), nameResolverFactory,
+        new FakeBackoffPolicyProvider(),
+        balancerRpcExecutorPool, timer.getStopwatchSupplier(),
+        Collections.<ClientInterceptor>emptyList(), timer.getTimeProvider());
+    nameResolverFactory.nextConfigOrError.set(
+        ConfigOrError.fromConfig(ManagedChannelServiceConfig.empty()));
+    final Metadata.Key<String> metadataKey =
+        Metadata.Key.of("test", Metadata.ASCII_STRING_MARSHALLER);
+    final CallOptions.Key<String> callOptionsKey = CallOptions.Key.create("test");
+    InternalConfigSelector configSelector = new InternalConfigSelector() {
+      @Override
+      public Result selectConfig(final PickSubchannelArgs args) {
+        return Result.newBuilder()
+            .setConfig(ManagedChannelServiceConfig.empty())
+            .setInterceptor(
+                // An interceptor that mutates CallOptions based on headers value.
+                new ClientInterceptor() {
+                  String value = args.getHeaders().get(metadataKey);
+                  @Override
+                  public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+                      MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+                    callOptions = callOptions.withOption(callOptionsKey, value);
+                    return next.newCall(method, callOptions);
+                  }
+                })
+            .build();
+      }
+    };
+    nameResolverFactory.nextAttributes.set(
+        Attributes.newBuilder().set(InternalConfigSelector.KEY, configSelector).build());
+    channel.getState(true);
     Metadata headers = new Metadata();
-    when(mockTransportFactory.newClientTransport(
-            any(SocketAddress.class), any(String.class), any(String.class)))
-        .thenReturn(mockTransport);
-    when(mockTransport.newStream(same(method), same(headers), same(CallOptions.DEFAULT),
-            any(StatsTraceContext.class)))
-        .thenReturn(mockStream);
+    headers.put(metadataKey, "fooValue");
+    ClientStream mockStream = mock(ClientStream.class);
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
     call.start(mockCallListener, headers);
-    timer.runDueTasks();
-    executor.runDueTasks();
 
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+    helper = helperCaptor.getValue();
+    // Make the transport available
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
     verify(mockTransportFactory)
-        .newClientTransport(same(socketAddress), eq(authority), eq(userAgent));
-    verify(mockTransport).start(transportListenerCaptor.capture());
-    ManagedClientTransport.Listener transportListener = transportListenerCaptor.getValue();
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    MockClientTransportInfo transportInfo = transports.poll();
+    ConnectionClientTransport mockTransport = transportInfo.transport;
+    ManagedClientTransport.Listener transportListener = transportInfo.listener;
+    when(mockTransport.newStream(
+            same(method), same(headers), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream);
     transportListener.transportReady();
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(subchannel));
+    updateBalancingStateSafely(helper, READY, mockPicker);
     executor.runDueTasks();
 
-    verify(mockTransport).newStream(same(method), same(headers), same(CallOptions.DEFAULT),
-        statsTraceCtxCaptor.capture());
-    assertEquals(statsCtxFactory.pollContextOrFail(),
-        statsTraceCtxCaptor.getValue().getStatsContext());
+    ArgumentCaptor<CallOptions> callOptionsCaptor = ArgumentCaptor.forClass(CallOptions.class);
+    verify(mockTransport).newStream(
+        same(method), same(headers), callOptionsCaptor.capture(),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    assertThat(callOptionsCaptor.getValue().getOption(callOptionsKey)).isEqualTo("fooValue");
     verify(mockStream).start(streamListenerCaptor.capture());
-    verify(mockStream).setCompressor(isA(Compressor.class));
-    ClientStreamListener streamListener = streamListenerCaptor.getValue();
 
-    // Second call
-    ClientCall<String, Integer> call2 = channel.newCall(method, CallOptions.DEFAULT);
-    ClientStream mockStream2 = mock(ClientStream.class);
-    Metadata headers2 = new Metadata();
-    when(mockTransport.newStream(same(method), same(headers2), same(CallOptions.DEFAULT),
-            any(StatsTraceContext.class)))
-        .thenReturn(mockStream2);
-    call2.start(mockCallListener2, headers2);
-    verify(mockTransport).newStream(same(method), same(headers2), same(CallOptions.DEFAULT),
-        statsTraceCtxCaptor.capture());
-    assertEquals(statsCtxFactory.pollContextOrFail(),
-        statsTraceCtxCaptor.getValue().getStatsContext());
+    // Clean up as much as possible to allow the channel to terminate.
+    shutdownSafely(helper, subchannel);
+    timer.forwardNanos(
+        TimeUnit.SECONDS.toNanos(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS));
+  }
 
-    verify(mockStream2).start(streamListenerCaptor.capture());
-    ClientStreamListener streamListener2 = streamListenerCaptor.getValue();
-    Metadata trailers = new Metadata();
-    streamListener2.closed(Status.CANCELLED, trailers);
-    executor.runDueTasks();
+  @Test
+  public void pickSubchannelAddOptionalLabel_callsTracer() {
+    channelBuilder.directExecutor();
+    createChannel();
 
-    verify(mockCallListener2).onClose(Status.CANCELLED, trailers);
+    updateBalancingStateSafely(helper, TRANSIENT_FAILURE, new SubchannelPicker() {
+      @Override
+      public PickResult pickSubchannel(PickSubchannelArgs args) {
+        args.getPickDetailsConsumer().addOptionalLabel("routed", "perfectly");
+        return PickResult.withError(Status.UNAVAILABLE.withDescription("expected"));
+      }
+    });
+    ClientStreamTracer tracer = mock(ClientStreamTracer.class);
+    ClientStreamTracer.Factory tracerFactory = new ClientStreamTracer.Factory() {
+      @Override
+      public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+        return tracer;
+      }
+    };
+    ClientCall<String, Integer> call = channel.newCall(
+        method, CallOptions.DEFAULT.withStreamTracerFactory(tracerFactory));
+    call.start(mockCallListener, new Metadata());
 
-    // Shutdown
+    verify(tracer).addOptionalLabel("routed", "perfectly");
+  }
+
+  @Test
+  public void metricRecorder_recordsToMetricSink() {
+    MetricSink mockSink = mock(MetricSink.class);
+    channelBuilder.addMetricSink(mockSink);
+    createChannel();
+
+    LongCounterMetricInstrument counter = metricInstrumentRegistry.registerLongCounter(
+        "recorder_duration", "Time taken by metric recorder", "s",
+        ImmutableList.of("grpc.method"), Collections.emptyList(), false);
+    List<String> requiredLabelValues = ImmutableList.of("testMethod");
+    List<String> optionalLabelValues = Collections.emptyList();
+
+    helper.getMetricRecorder()
+        .addLongCounter(counter, 32, requiredLabelValues, optionalLabelValues);
+    verify(mockSink).addLongCounter(eq(counter), eq(32L), eq(requiredLabelValues),
+        eq(optionalLabelValues));
+  }
+
+  @Test
+  public void metricRecorder_fromNameResolverArgs_recordsToMetricSink() {
+    MetricSink mockSink1 = mock(MetricSink.class);
+    MetricSink mockSink2 = mock(MetricSink.class);
+    channelBuilder.addMetricSink(mockSink1);
+    channelBuilder.addMetricSink(mockSink2);
+    createChannel();
+
+    LongCounterMetricInstrument counter = metricInstrumentRegistry.registerLongCounter(
+        "test_counter", "Time taken by metric recorder", "s",
+        ImmutableList.of("grpc.method"), Collections.emptyList(), false);
+    List<String> requiredLabelValues = ImmutableList.of("testMethod");
+    List<String> optionalLabelValues = Collections.emptyList();
+
+    NameResolver.Args args = helper.getNameResolverArgs();
+    assertThat(args.getMetricRecorder()).isNotNull();
+    args.getMetricRecorder()
+        .addLongCounter(counter, 10, requiredLabelValues, optionalLabelValues);
+    verify(mockSink1).addLongCounter(eq(counter), eq(10L), eq(requiredLabelValues),
+        eq(optionalLabelValues));
+    verify(mockSink2).addLongCounter(eq(counter), eq(10L), eq(requiredLabelValues),
+        eq(optionalLabelValues));
+  }
+
+  @Test
+  public void shutdownWithNoTransportsEverCreated() {
+    channelBuilder.nameResolverFactory(
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+            .build());
+    createChannel();
+    verify(executorPool).getObject();
+    verify(executorPool, never()).returnObject(any());
     channel.shutdown();
     assertTrue(channel.isShutdown());
-    assertFalse(channel.isTerminated());
-    verify(mockTransport).shutdown();
-    assertEquals(1, nameResolverFactory.resolvers.size());
-    assertTrue(nameResolverFactory.resolvers.get(0).shutdown);
-    assertEquals(1, loadBalancerFactory.balancers.size());
-    verify(loadBalancerFactory.balancers.get(0)).shutdown();
+    assertTrue(channel.isTerminated());
+    verify(executorPool).returnObject(executor.getScheduledExecutorService());
+  }
 
-    // Further calls should fail without going to the transport
-    ClientCall<String, Integer> call3 = channel.newCall(method, CallOptions.DEFAULT);
-    call3.start(mockCallListener3, new Metadata());
-    timer.runDueTasks();
+  @Test
+  public void shutdownNow_pendingCallShouldFail() {
+    channelBuilder.nameResolverFactory(
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setResolvedAtStart(false)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+            .build());
+    createChannel();
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
+    channel.shutdown();
     executor.runDueTasks();
+    verify(mockCallListener, never()).onClose(any(Status.class), any(Metadata.class));
+    channel.shutdownNow();
+    executor.runDueTasks();
+    verify(mockCallListener).onClose(statusCaptor.capture(), any(Metadata.class));
+    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.CANCELLED);
+  }
 
-    verify(mockCallListener3).onClose(statusCaptor.capture(), any(Metadata.class));
-    assertSame(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
-
-    // Finish shutdown
-    transportListener.transportShutdown(Status.CANCELLED);
-    assertFalse(channel.isTerminated());
-    streamListener.closed(Status.CANCELLED, trailers);
+  @Test
+  public void shutdownWithNoNameResolution_newCallShouldFail() {
+    channelBuilder.nameResolverFactory(
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setResolvedAtStart(false)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+            .build());
+    createChannel();
+    channel.shutdown();
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
     executor.runDueTasks();
+    verify(mockCallListener).onClose(statusCaptor.capture(), any(Metadata.class));
+    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.UNAVAILABLE);
+  }
 
-    verify(mockCallListener).onClose(Status.CANCELLED, trailers);
-    assertFalse(channel.isTerminated());
+  @Test
+  public void channelzMembership() throws Exception {
+    createChannel();
+    assertNotNull(channelz.getRootChannel(channel.getLogId().getId()));
+    assertFalse(channelz.containsSubchannel(channel.getLogId()));
+    channel.shutdownNow();
+    channel.awaitTermination(5, TimeUnit.SECONDS);
+    assertNull(channelz.getRootChannel(channel.getLogId().getId()));
+    assertFalse(channelz.containsSubchannel(channel.getLogId()));
+  }
 
-    transportListener.transportTerminated();
-    assertTrue(channel.isTerminated());
+  @Test
+  public void channelzMembership_subchannel() throws Exception {
+    createChannel();
+    assertNotNull(channelz.getRootChannel(channel.getLogId().getId()));
 
-    verify(mockTransportFactory).close();
-    verifyNoMoreInteractions(mockTransportFactory);
-    verify(mockTransport, atLeast(0)).getLogId();
-    verifyNoMoreInteractions(mockTransport);
-    verifyNoMoreInteractions(mockStream);
+    AbstractSubchannel subchannel =
+        (AbstractSubchannel) createSubchannelSafely(
+            helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    // subchannels are not root channels
+    assertNull(
+        channelz.getRootChannel(subchannel.getInstrumentedInternalSubchannel().getLogId().getId()));
+    assertTrue(
+        channelz.containsSubchannel(subchannel.getInstrumentedInternalSubchannel().getLogId()));
+    assertThat(getStats(channel).subchannels)
+        .containsExactly(subchannel.getInstrumentedInternalSubchannel());
+
+    requestConnectionSafely(helper, subchannel);
+    MockClientTransportInfo transportInfo = transports.poll();
+    assertNotNull(transportInfo);
+    assertTrue(channelz.containsClientSocket(transportInfo.transport.getLogId()));
+    transportInfo.listener.transportReady();
+
+    // terminate transport
+    transportInfo.listener.transportShutdown(Status.CANCELLED,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    transportInfo.listener.transportTerminated();
+    assertFalse(channelz.containsClientSocket(transportInfo.transport.getLogId()));
+
+    // terminate subchannel
+    assertTrue(
+        channelz.containsSubchannel(subchannel.getInstrumentedInternalSubchannel().getLogId()));
+    shutdownSafely(helper, subchannel);
+    timer.forwardTime(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS, TimeUnit.SECONDS);
+    timer.runDueTasks();
+    assertFalse(
+        channelz.containsSubchannel(subchannel.getInstrumentedInternalSubchannel().getLogId()));
+    assertThat(getStats(channel).subchannels).isEmpty();
+
+    // channel still appears
+    assertNotNull(channelz.getRootChannel(channel.getLogId().getId()));
   }
 
   @Test
-  public void callAndShutdownNow() {
-    FakeNameResolverFactory nameResolverFactory = new FakeNameResolverFactory(true);
-    createChannel(nameResolverFactory, NO_INTERCEPTOR);
-    verifyNoMoreInteractions(mockTransportFactory);
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    verifyNoMoreInteractions(mockTransportFactory);
+  public void callsAndShutdown() {
+    subtestCallsAndShutdown(false, false);
+  }
+
+  @Test
+  public void callsAndShutdownNow() {
+    subtestCallsAndShutdown(true, false);
+  }
+
+  /** Make sure shutdownNow() after shutdown() has an effect. */
+  @Test
+  public void callsAndShutdownAndShutdownNow() {
+    subtestCallsAndShutdown(false, true);
+  }
 
-    // Create transport and call
+  private void subtestCallsAndShutdown(boolean shutdownNow, boolean shutdownNowAfterShutdown) {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel();
+    verify(executorPool).getObject();
     ClientStream mockStream = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
     Metadata headers = new Metadata();
-    when(mockTransportFactory.newClientTransport(
-            any(SocketAddress.class), any(String.class), any(String.class)))
-        .thenReturn(mockTransport);
-    when(mockTransport.newStream(same(method), same(headers), same(CallOptions.DEFAULT),
-            any(StatsTraceContext.class)))
-        .thenReturn(mockStream);
-    call.start(mockCallListener, headers);
-    timer.runDueTasks();
-    executor.runDueTasks();
+    Metadata headers2 = new Metadata();
 
+    // Configure the picker so that first RPC goes to delayed transport, and second RPC goes to
+    // real transport.
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
     verify(mockTransportFactory)
-        .newClientTransport(same(socketAddress), eq(authority), any(String.class));
-    verify(mockTransport).start(transportListenerCaptor.capture());
-    ManagedClientTransport.Listener transportListener = transportListenerCaptor.getValue();
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    MockClientTransportInfo transportInfo = transports.poll();
+    ConnectionClientTransport mockTransport = transportInfo.transport;
+    verify(mockTransport).start(any(ManagedClientTransport.Listener.class));
+    ManagedClientTransport.Listener transportListener = transportInfo.listener;
+    when(mockTransport.newStream(
+            same(method), same(headers), same(CallOptions.DEFAULT),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream);
+    when(mockTransport.newStream(
+            same(method), same(headers2), same(CallOptions.DEFAULT),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream2);
     transportListener.transportReady();
-    executor.runDueTasks();
+    when(mockPicker.pickSubchannel(
+        eqPickSubchannelArgs(method, headers, CallOptions.DEFAULT))).thenReturn(
+        PickResult.withNoResult());
+    when(mockPicker.pickSubchannel(
+        eqPickSubchannelArgs(method, headers2, CallOptions.DEFAULT))).thenReturn(
+        PickResult.withSubchannel(subchannel));
+    updateBalancingStateSafely(helper, READY, mockPicker);
 
-    verify(mockTransport).newStream(same(method), same(headers), same(CallOptions.DEFAULT),
-        any(StatsTraceContext.class));
+    // First RPC, will be pending
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    call.start(mockCallListener, headers);
 
-    verify(mockStream).start(streamListenerCaptor.capture());
-    verify(mockStream).setCompressor(isA(Compressor.class));
-    ClientStreamListener streamListener = streamListenerCaptor.getValue();
+    verify(mockTransport, never()).newStream(
+        same(method), same(headers), same(CallOptions.DEFAULT),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
 
-    // ShutdownNow
-    channel.shutdownNow();
+    // Second RPC, will be assigned to the real transport
+    ClientCall<String, Integer> call2 = channel.newCall(method, CallOptions.DEFAULT);
+    call2.start(mockCallListener2, headers2);
+    verify(mockTransport).newStream(
+        same(method), same(headers2), same(CallOptions.DEFAULT),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    verify(mockTransport).newStream(
+        same(method), same(headers2), same(CallOptions.DEFAULT),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    verify(mockStream2).start(any(ClientStreamListener.class));
+
+    // Shutdown
+    if (shutdownNow) {
+      channel.shutdownNow();
+    } else {
+      channel.shutdown();
+      if (shutdownNowAfterShutdown) {
+        channel.shutdownNow();
+        shutdownNow = true;
+      }
+    }
     assertTrue(channel.isShutdown());
     assertFalse(channel.isTerminated());
-    // ShutdownNow may or may not invoke shutdown. Ideally it wouldn't, but it doesn't matter much
-    // either way.
-    verify(mockTransport, atMost(1)).shutdown();
-    verify(mockTransport).shutdownNow(any(Status.class));
-    assertEquals(1, nameResolverFactory.resolvers.size());
-    assertTrue(nameResolverFactory.resolvers.get(0).shutdown);
-    assertEquals(1, loadBalancerFactory.balancers.size());
-    verify(loadBalancerFactory.balancers.get(0)).shutdown();
+    assertThat(nameResolverFactory.resolvers).hasSize(1);
+    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
 
     // Further calls should fail without going to the transport
     ClientCall<String, Integer> call3 = channel.newCall(method, CallOptions.DEFAULT);
-    call3.start(mockCallListener3, new Metadata());
+    call3.start(mockCallListener3, headers2);
+    timer.runDueTasks();
     executor.runDueTasks();
 
     verify(mockCallListener3).onClose(statusCaptor.capture(), any(Metadata.class));
     assertSame(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
 
-    // Finish shutdown
-    transportListener.transportShutdown(Status.CANCELLED);
-    assertFalse(channel.isTerminated());
-    Metadata trailers = new Metadata();
-    streamListener.closed(Status.CANCELLED, trailers);
-    executor.runDueTasks();
+    if (shutdownNow) {
+      // LoadBalancer and NameResolver are shut down as soon as delayed transport is terminated.
+      verify(mockLoadBalancer).shutdown();
+      assertTrue(nameResolverFactory.resolvers.get(0).shutdown);
+      // call should have been aborted by delayed transport
+      executor.runDueTasks();
+      verify(mockCallListener).onClose(same(ManagedChannelImpl.SHUTDOWN_NOW_STATUS),
+          any(Metadata.class));
+    } else {
+      // LoadBalancer and NameResolver are still running.
+      verify(mockLoadBalancer, never()).shutdown();
+      assertFalse(nameResolverFactory.resolvers.get(0).shutdown);
+      // call and call2 are still alive, and can still be assigned to a real transport
+      SubchannelPicker picker2 = mock(SubchannelPicker.class);
+      when(picker2.pickSubchannel(eqPickSubchannelArgs(method, headers, CallOptions.DEFAULT)))
+          .thenReturn(PickResult.withSubchannel(subchannel));
+      updateBalancingStateSafely(helper, READY, picker2);
+      executor.runDueTasks();
+      verify(mockTransport).newStream(
+          same(method), same(headers), same(CallOptions.DEFAULT),
+          ArgumentMatchers.<ClientStreamTracer[]>any());
+      verify(mockStream).start(any(ClientStreamListener.class));
+    }
 
-    verify(mockCallListener).onClose(Status.CANCELLED, trailers);
-    assertFalse(channel.isTerminated());
+    // After call is moved out of delayed transport, LoadBalancer, NameResolver and the transports
+    // will be shutdown.
+    verify(mockLoadBalancer).shutdown();
+    assertTrue(nameResolverFactory.resolvers.get(0).shutdown);
 
+    if (shutdownNow) {
+      // Channel shutdownNow() all subchannels after shutting down LoadBalancer
+      verify(mockTransport).shutdownNow(ManagedChannelImpl.SHUTDOWN_NOW_STATUS);
+    } else {
+      verify(mockTransport, never()).shutdownNow(any(Status.class));
+    }
+    // LoadBalancer should shutdown the subchannel
+    shutdownSafely(helper, subchannel);
+    if (shutdownNow) {
+      verify(mockTransport).shutdown(same(ManagedChannelImpl.SHUTDOWN_NOW_STATUS));
+    } else {
+      verify(mockTransport).shutdown(same(ManagedChannelImpl.SHUTDOWN_STATUS));
+    }
+
+    // Killing the remaining real transport will terminate the channel
+    transportListener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    assertFalse(channel.isTerminated());
+    verify(executorPool, never()).returnObject(any());
     transportListener.transportTerminated();
     assertTrue(channel.isTerminated());
+    verify(executorPool).returnObject(executor.getScheduledExecutorService());
+    verifyNoMoreInteractions(balancerRpcExecutorPool);
 
+    verify(mockTransportFactory)
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
     verify(mockTransportFactory).close();
-    verifyNoMoreInteractions(mockTransportFactory);
     verify(mockTransport, atLeast(0)).getLogId();
     verifyNoMoreInteractions(mockTransport);
-    verifyNoMoreInteractions(mockStream);
   }
 
-  /** Make sure shutdownNow() after shutdown() has an effect. */
   @Test
-  public void callAndShutdownAndShutdownNow() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+  public void noMoreCallbackAfterLoadBalancerShutdown() {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    Status resolutionError = Status.UNAVAILABLE.withDescription("Resolution failed");
+    createChannel();
 
-    // Create transport and call
-    ClientStream mockStream = mock(ClientStream.class);
-    Metadata headers = new Metadata();
-    when(mockTransport.newStream(same(method), same(headers), same(CallOptions.DEFAULT),
-            any(StatsTraceContext.class)))
-        .thenReturn(mockStream);
-    call.start(mockCallListener, headers);
-    timer.runDueTasks();
-    executor.runDueTasks();
+    FakeNameResolverFactory.FakeNameResolver resolver = nameResolverFactory.resolvers.get(0);
+    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
+    verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
+    assertThat(resolvedAddressCaptor.getValue().getAddresses()).containsExactly(addressGroup);
 
-    verify(mockTransport).start(transportListenerCaptor.capture());
-    ManagedClientTransport.Listener transportListener = transportListenerCaptor.getValue();
-    transportListener.transportReady();
-    executor.runDueTasks();
+    SubchannelStateListener stateListener1 = mock(SubchannelStateListener.class);
+    SubchannelStateListener stateListener2 = mock(SubchannelStateListener.class);
+    Subchannel subchannel1 =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, stateListener1);
+    Subchannel subchannel2 =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, stateListener2);
+    requestConnectionSafely(helper, subchannel1);
+    requestConnectionSafely(helper, subchannel2);
+    verify(mockTransportFactory, times(2))
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    MockClientTransportInfo transportInfo1 = transports.poll();
+    MockClientTransportInfo transportInfo2 = transports.poll();
 
-    verify(mockStream).start(streamListenerCaptor.capture());
-    ClientStreamListener streamListener = streamListenerCaptor.getValue();
+    // LoadBalancer receives all sorts of callbacks
+    transportInfo1.listener.transportReady();
+
+    verify(stateListener1, times(2)).onSubchannelState(stateInfoCaptor.capture());
+    assertSame(CONNECTING, stateInfoCaptor.getAllValues().get(0).getState());
+    assertSame(READY, stateInfoCaptor.getAllValues().get(1).getState());
+
+    verify(stateListener2).onSubchannelState(stateInfoCaptor.capture());
+    assertSame(CONNECTING, stateInfoCaptor.getValue().getState());
+
+    resolver.listener.onError(resolutionError);
+    verify(mockLoadBalancer).handleNameResolutionError(resolutionError);
+
+    verifyNoMoreInteractions(mockLoadBalancer);
 
-    // ShutdownNow
     channel.shutdown();
-    channel.shutdownNow();
-    // ShutdownNow may or may not invoke shutdown. Ideally it wouldn't, but it doesn't matter much
-    // either way.
-    verify(mockTransport, atMost(2)).shutdown();
-    verify(mockTransport).shutdownNow(any(Status.class));
+    verify(mockLoadBalancer).shutdown();
+    verifyNoMoreInteractions(stateListener1, stateListener2);
 
-    // Finish shutdown
-    transportListener.transportShutdown(Status.CANCELLED);
-    assertFalse(channel.isTerminated());
-    Metadata trailers = new Metadata();
-    streamListener.closed(Status.CANCELLED, trailers);
-    executor.runDueTasks();
+    // LoadBalancer will normally shutdown all subchannels
+    shutdownSafely(helper, subchannel1);
+    shutdownSafely(helper, subchannel2);
 
-    verify(mockCallListener).onClose(Status.CANCELLED, trailers);
-    assertFalse(channel.isTerminated());
+    // Since subchannels are shutdown, SubchannelStateListeners will only get SHUTDOWN regardless of
+    // the transport states.
+    transportInfo1.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    transportInfo2.listener.transportReady();
+    verify(stateListener1).onSubchannelState(ConnectivityStateInfo.forNonError(SHUTDOWN));
+    verify(stateListener2).onSubchannelState(ConnectivityStateInfo.forNonError(SHUTDOWN));
+    verifyNoMoreInteractions(stateListener1, stateListener2);
 
-    transportListener.transportTerminated();
-    assertTrue(channel.isTerminated());
+    // No more callback should be delivered to LoadBalancer after it's shut down
+    resolver.listener.onError(resolutionError);
+    resolver.resolved();
+    verifyNoMoreInteractions(mockLoadBalancer);
+  }
+
+  @Test  
+  public void noMoreCallbackAfterLoadBalancerShutdown_configError() throws InterruptedException {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    Status resolutionError = Status.UNAVAILABLE.withDescription("Resolution failed");
+    createChannel();
+
+    FakeNameResolverFactory.FakeNameResolver resolver = nameResolverFactory.resolvers.get(0);
+    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
+    verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
+    assertThat(resolvedAddressCaptor.getValue().getAddresses()).containsExactly(addressGroup);
+
+    SubchannelStateListener stateListener1 = mock(SubchannelStateListener.class);
+    SubchannelStateListener stateListener2 = mock(SubchannelStateListener.class);
+    Subchannel subchannel1 =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, stateListener1);
+    Subchannel subchannel2 =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, stateListener2);
+    requestConnectionSafely(helper, subchannel1);
+    requestConnectionSafely(helper, subchannel2);
+    verify(mockTransportFactory, times(2))
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    MockClientTransportInfo transportInfo1 = transports.poll();
+    MockClientTransportInfo transportInfo2 = transports.poll();
+
+    // LoadBalancer receives all sorts of callbacks
+    transportInfo1.listener.transportReady();
+
+    verify(stateListener1, times(2)).onSubchannelState(stateInfoCaptor.capture());
+    assertSame(CONNECTING, stateInfoCaptor.getAllValues().get(0).getState());
+    assertSame(READY, stateInfoCaptor.getAllValues().get(1).getState());
+
+    verify(stateListener2).onSubchannelState(stateInfoCaptor.capture());
+    assertSame(CONNECTING, stateInfoCaptor.getValue().getState());
+
+    channel.syncContext.execute(() ->
+        resolver.listener.onResult2(
+            ResolutionResult.newBuilder()
+                .setAddressesOrError(StatusOr.fromStatus(resolutionError)).build()));
+    verify(mockLoadBalancer).handleNameResolutionError(resolutionError);
+
+    verifyNoMoreInteractions(mockLoadBalancer);
+
+    channel.shutdown();
+    verify(mockLoadBalancer).shutdown();
+    verifyNoMoreInteractions(stateListener1, stateListener2);
+
+    // LoadBalancer will normally shutdown all subchannels
+    shutdownSafely(helper, subchannel1);
+    shutdownSafely(helper, subchannel2);
+
+    // Since subchannels are shutdown, SubchannelStateListeners will only get SHUTDOWN regardless of
+    // the transport states.
+    transportInfo1.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    transportInfo2.listener.transportReady();
+    verify(stateListener1).onSubchannelState(ConnectivityStateInfo.forNonError(SHUTDOWN));
+    verify(stateListener2).onSubchannelState(ConnectivityStateInfo.forNonError(SHUTDOWN));
+    verifyNoMoreInteractions(stateListener1, stateListener2);
+
+    // No more callback should be delivered to LoadBalancer after it's shut down
+    channel.syncContext.execute(() ->
+        resolver.listener.onResult2(
+            ResolutionResult.newBuilder()
+                .setAddressesOrError(StatusOr.fromStatus(resolutionError)).build()));
+    assertThat(timer.getPendingTasks()).isEmpty();
+    resolver.resolved();
+    verifyNoMoreInteractions(mockLoadBalancer);
   }
 
+  @Test
+  public void addressResolutionError_noPriorNameResolution_usesDefaultServiceConfig()
+      throws Exception {
+    Map<String, Object> rawServiceConfig =
+        parseConfig("{\"methodConfig\":[{"
+            + "\"name\":[{\"service\":\"service\"}],"
+            + "\"waitForReady\":true}]}");
+    ManagedChannelServiceConfig managedChannelServiceConfig =
+        createManagedChannelServiceConfig(rawServiceConfig, null);
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+            .setResolvedAtStart(false)
+            .build();
+    nameResolverFactory.nextConfigOrError.set(
+        ConfigOrError.fromConfig(managedChannelServiceConfig));
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    Map<String, Object> defaultServiceConfig =
+        parseConfig("{\"methodConfig\":[{"
+            + "\"name\":[{\"service\":\"service\"}],"
+            + "\"waitForReady\":true}]}");
+    channelBuilder.defaultServiceConfig(defaultServiceConfig);
+    Status resolutionError = Status.UNAVAILABLE.withDescription("Resolution failed");
+    channelBuilder.maxTraceEvents(10);
+    createChannel();
+    FakeNameResolverFactory.FakeNameResolver resolver = nameResolverFactory.resolvers.get(0);
+
+    resolver.listener.onError(resolutionError);
+
+    InternalConfigSelector configSelector = channel.getConfigSelector();
+    ManagedChannelServiceConfig config =
+        (ManagedChannelServiceConfig) configSelector.selectConfig(null).getConfig();
+    MethodInfo methodConfig = config.getMethodConfig(method);
+    assertThat(methodConfig.waitForReady).isTrue();
+    timer.forwardNanos(1234);
+    assertThat(getStats(channel).channelTrace.events).contains(new ChannelTrace.Event.Builder()
+        .setDescription("Initial Name Resolution error, using default service config")
+        .setSeverity(Severity.CT_ERROR)
+        .setTimestampNanos(0)
+        .build());
+
+    // Check that "lastServiceConfig" variable has been set above: a config resolution with the same
+    // config simply gets ignored and not gets reassigned.
+    resolver.resolved();
+    timer.forwardNanos(1234);
+    assertThat(Iterables.filter(
+          getStats(channel).channelTrace.events,
+          event -> event.description.equals("Service config changed")))
+        .isEmpty();
+  }
 
   @Test
   public void interceptor() throws Exception {
@@ -457,198 +1181,160 @@ public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> interceptCall(
         return next.newCall(method, callOptions);
       }
     };
-    createChannel(new FakeNameResolverFactory(true), Arrays.asList(interceptor));
+    createChannel(interceptor);
     assertNotNull(channel.newCall(method, CallOptions.DEFAULT));
     assertEquals(1, atomic.get());
   }
 
-  @Test
-  public void testNoDeadlockOnShutdown() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    // Force creation of transport
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    Metadata headers = new Metadata();
-    ClientStream mockStream = mock(ClientStream.class);
-    when(mockTransport.newStream(same(method), same(headers))).thenReturn(mockStream);
-    call.start(mockCallListener, headers);
-    timer.runDueTasks();
-    executor.runDueTasks();
-    call.cancel("Cancel for test", null);
-    executor.runDueTasks();
-
-    verify(mockTransport).start(transportListenerCaptor.capture());
-    final ManagedClientTransport.Listener transportListener = transportListenerCaptor.getValue();
-    final Object lock = new Object();
-    final CyclicBarrier barrier = new CyclicBarrier(2);
-    new Thread() {
-      @Override
-      public void run() {
-        synchronized (lock) {
-          try {
-            barrier.await();
-          } catch (Exception ex) {
-            throw new AssertionError(ex);
-          }
-          // To deadlock, a lock would be needed for this call to proceed.
-          transportListener.transportShutdown(Status.CANCELLED);
-        }
-      }
-    }.start();
-    doAnswer(new Answer<Void>() {
-      @Override
-      public Void answer(InvocationOnMock invocation) {
-        // To deadlock, a lock would need to be held while this method is in progress.
-        try {
-          barrier.await();
-        } catch (Exception ex) {
-          throw new AssertionError(ex);
-        }
-        // If deadlock is possible with this setup, this sychronization completes the loop because
-        // the transportShutdown needs a lock that Channel is holding while calling this method.
-        synchronized (lock) {
-        }
-        return null;
-      }
-    }).when(mockTransport).shutdown();
-    channel.shutdown();
-
-    transportListener.transportTerminated();
-  }
-
   @Test
   public void callOptionsExecutor() {
     Metadata headers = new Metadata();
     ClientStream mockStream = mock(ClientStream.class);
-    when(mockTransport.newStream(same(method), same(headers), any(CallOptions.class),
-            any(StatsTraceContext.class)))
-        .thenReturn(mockStream);
     FakeClock callExecutor = new FakeClock();
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
+    createChannel();
+
+    // Start a call with a call executor
     CallOptions options =
         CallOptions.DEFAULT.withExecutor(callExecutor.getScheduledExecutorService());
-
     ClientCall<String, Integer> call = channel.newCall(method, options);
     call.start(mockCallListener, headers);
-    timer.runDueTasks();
-    executor.runDueTasks();
 
-    verify(mockTransport).start(transportListenerCaptor.capture());
-    assertEquals(0, executor.numPendingTasks());
-    transportListenerCaptor.getValue().transportReady();
-    // Real streams are started in the channel's executor
-    assertEquals(1, executor.runDueTasks());
+    // Make the transport available
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    verify(mockTransportFactory, never())
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    requestConnectionSafely(helper, subchannel);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    MockClientTransportInfo transportInfo = transports.poll();
+    ConnectionClientTransport mockTransport = transportInfo.transport;
+    ManagedClientTransport.Listener transportListener = transportInfo.listener;
+    when(mockTransport.newStream(
+            same(method), same(headers), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream);
+    transportListener.transportReady();
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(subchannel));
+    assertEquals(0, callExecutor.numPendingTasks());
+    updateBalancingStateSafely(helper, READY, mockPicker);
 
-    verify(mockTransport).newStream(same(method), same(headers), same(options),
-        any(StatsTraceContext.class));
+    // Real streams are started in the call executor if they were previously buffered.
+    assertEquals(1, callExecutor.runDueTasks());
+    verify(mockTransport).newStream(
+        same(method), same(headers), same(options), ArgumentMatchers.<ClientStreamTracer[]>any());
     verify(mockStream).start(streamListenerCaptor.capture());
+
+    // Call listener callbacks are also run in the call executor
     ClientStreamListener streamListener = streamListenerCaptor.getValue();
     Metadata trailers = new Metadata();
     assertEquals(0, callExecutor.numPendingTasks());
-    streamListener.closed(Status.CANCELLED, trailers);
+    streamListener.closed(Status.CANCELLED, PROCESSED, trailers);
     verify(mockCallListener, never()).onClose(same(Status.CANCELLED), same(trailers));
     assertEquals(1, callExecutor.runDueTasks());
-
     verify(mockCallListener).onClose(same(Status.CANCELLED), same(trailers));
-  }
 
-  @Test
-  public void nameResolutionFailed() {
-    Status error = Status.UNAVAILABLE.withCause(new Throwable("fake name resolution error"));
 
-    // Name resolution is started as soon as channel is created.
-    createChannel(new FailingNameResolverFactory(error), NO_INTERCEPTOR);
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    call.start(mockCallListener, new Metadata());
-    timer.runDueTasks();
-    executor.runDueTasks();
+    transportListener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    transportListener.transportTerminated();
 
-    // The call failed with the name resolution error
-    verify(mockCallListener).onClose(statusCaptor.capture(), any(Metadata.class));
-    Status status = statusCaptor.getValue();
-    assertSame(error.getCode(), status.getCode());
-    assertSame(error.getCause(), status.getCause());
-    // LoadBalancer received the same error
-    assertEquals(1, loadBalancerFactory.balancers.size());
-    verify(loadBalancerFactory.balancers.get(0)).handleNameResolutionError(same(error));
+    // Clean up as much as possible to allow the channel to terminate.
+    shutdownSafely(helper, subchannel);
+    timer.forwardNanos(
+        TimeUnit.SECONDS.toNanos(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS));
   }
 
   @Test
-  public void nameResolverReturnsEmptySubLists() {
-    String errorDescription = "NameResolver returned an empty list";
+  public void loadBalancerThrowsInHandleResolvedAddresses() {
+    RuntimeException ex = new RuntimeException("simulated");
+    // Delay the success of name resolution until allResolved() is called
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setResolvedAtStart(false)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel();
 
-    // Name resolution is started as soon as channel is created
-    createChannel(new FakeNameResolverFactory(), NO_INTERCEPTOR);
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    call.start(mockCallListener, new Metadata());
-    timer.runDueTasks();
-    executor.runDueTasks();
+    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
+    doThrow(ex).when(mockLoadBalancer).acceptResolvedAddresses(any(ResolvedAddresses.class));
 
-    // The call failed with the name resolution error
-    verify(mockCallListener).onClose(statusCaptor.capture(), any(Metadata.class));
-    Status status = statusCaptor.getValue();
-    assertSame(Status.Code.UNAVAILABLE, status.getCode());
-    assertTrue(status.getDescription(), status.getDescription().contains(errorDescription));
-    // LoadBalancer received the same error
-    assertEquals(1, loadBalancerFactory.balancers.size());
-    verify(loadBalancerFactory.balancers.get(0)).handleNameResolutionError(statusCaptor.capture());
-    status = statusCaptor.getValue();
-    assertSame(Status.Code.UNAVAILABLE, status.getCode());
-    assertEquals(errorDescription, status.getDescription());
+    // NameResolver returns addresses.
+    nameResolverFactory.allResolved();
+
+    // Exception thrown from balancer is caught by ChannelExecutor, making channel enter panic mode.
+    verifyPanicMode(ex);
   }
 
   @Test
-  public void loadBalancerThrowsInHandleResolvedAddresses() {
-    RuntimeException ex = new RuntimeException("simulated");
-    // Delay the success of name resolution until allResolved() is called
-    FakeNameResolverFactory nameResolverFactory = new FakeNameResolverFactory(false);
-    createChannel(nameResolverFactory, NO_INTERCEPTOR);
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+  public void delayedNameResolution() throws Exception {
+    ClientStream mockStream = mock(ClientStream.class);
+    final ClientStreamTracer tracer = new ClientStreamTracer() {};
+    ClientStreamTracer.Factory factory = new ClientStreamTracer.Factory() {
+      @Override
+      public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+        return tracer;
+      }
+    };
+    FakeNameResolverFactory nsFactory = new FakeNameResolverFactory.Builder(expectedUri)
+        .setResolvedAtStart(false).build();
+    channelBuilder.nameResolverFactory(nsFactory);
+    createChannel();
+
+    CallOptions callOptions = CallOptions.DEFAULT.withStreamTracerFactory(factory);
+    ClientCall<String, Integer> call = channel.newCall(method, callOptions);
     call.start(mockCallListener, new Metadata());
-    timer.runDueTasks();
-    executor.runDueTasks();
 
-    assertEquals(1, loadBalancerFactory.balancers.size());
-    LoadBalancer<?> loadBalancer = loadBalancerFactory.balancers.get(0);
-    doThrow(ex).when(loadBalancer).handleResolvedAddresses(
-        Matchers.<List<ResolvedServerInfoGroup>>anyObject(), any(Attributes.class));
+    Thread.sleep(500);
+    nsFactory.allResolved();
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
+    MockClientTransportInfo transportInfo = transports.poll();
+    transportInfo.listener.transportReady();
+    ClientTransport mockTransport = transportInfo.transport;
+    when(mockTransport.newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream);
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(
+        PickResult.withSubchannel(subchannel));
 
-    // NameResolver returns addresses.
-    nameResolverFactory.allResolved();
-    executor.runDueTasks();
+    updateBalancingStateSafely(helper, READY, mockPicker);
+    assertEquals(3, executor.runDueTasks());
 
-    // The call failed with the error thrown from handleResolvedAddresses()
-    verify(mockCallListener).onClose(statusCaptor.capture(), any(Metadata.class));
-    Status status = statusCaptor.getValue();
-    assertSame(Status.Code.INTERNAL, status.getCode());
-    assertSame(ex, status.getCause());
-    // The LoadBalancer received the same error
-    verify(loadBalancer).handleNameResolutionError(statusCaptor.capture());
-    status = statusCaptor.getValue();
-    assertSame(Status.Code.INTERNAL, status.getCode());
-    assertSame(ex, status.getCause());
+    verify(mockPicker).pickSubchannel(any(PickSubchannelArgs.class));
+    verify(mockTransport).newStream(
+        same(method), any(Metadata.class), callOptionsCaptor.capture(),
+        tracersCaptor.capture());
+    assertThat(Arrays.asList(tracersCaptor.getValue()).contains(tracer)).isTrue();
+    Long realDelay = callOptionsCaptor.getValue().getOption(NAME_RESOLUTION_DELAYED);
+    assertThat(realDelay).isNotNull();
+    assertThat(realDelay).isAtLeast(
+        TimeUnit.MILLISECONDS.toNanos(400));//sleep not precise
   }
 
   @Test
   public void nameResolvedAfterChannelShutdown() {
     // Delay the success of name resolution until allResolved() is called.
-    FakeNameResolverFactory nameResolverFactory = new FakeNameResolverFactory(false);
-    createChannel(nameResolverFactory, NO_INTERCEPTOR);
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    Metadata headers = new Metadata();
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri).setResolvedAtStart(false).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel();
 
-    call.start(mockCallListener, headers);
-    timer.runDueTasks();
-    executor.runDueTasks();
     channel.shutdown();
 
     assertTrue(channel.isShutdown());
+    assertTrue(channel.isTerminated());
+    verify(mockLoadBalancer).shutdown();
     // Name resolved after the channel is shut down, which is possible if the name resolution takes
-    // time and is not cancellable. The resolved address will still be passed to the LoadBalancer.
+    // time and is not cancellable. The resolved address will be dropped.
     nameResolverFactory.allResolved();
-    executor.runDueTasks();
-
-    verify(mockTransportFactory, never())
-        .newClientTransport(any(SocketAddress.class), any(String.class), any(String.class));
+    verifyNoMoreInteractions(mockLoadBalancer);
   }
 
   /**
@@ -667,120 +1353,141 @@ public void firstResolvedServerFailedToConnect() throws Exception {
           return "badAddress";
         }
       };
-    final ResolvedServerInfo goodServer = new ResolvedServerInfo(goodAddress, Attributes.EMPTY);
-    final ResolvedServerInfo badServer = new ResolvedServerInfo(badAddress, Attributes.EMPTY);
-    final ConnectionClientTransport goodTransport = mock(ConnectionClientTransport.class);
-    final ConnectionClientTransport badTransport = mock(ConnectionClientTransport.class);
-    when(goodTransport.newStream(
-            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
-            any(StatsTraceContext.class)))
-        .thenReturn(mock(ClientStream.class));
-    when(mockTransportFactory.newClientTransport(
-            same(goodAddress), any(String.class), any(String.class)))
-        .thenReturn(goodTransport);
-    when(mockTransportFactory.newClientTransport(
-            same(badAddress), any(String.class), any(String.class)))
-        .thenReturn(badTransport);
+    InOrder inOrder = inOrder(mockLoadBalancer, subchannelStateListener);
 
+    List<SocketAddress> resolvedAddrs = Arrays.asList(badAddress, goodAddress);
     FakeNameResolverFactory nameResolverFactory =
-        new FakeNameResolverFactory(Arrays.asList(badServer, goodServer));
-    createChannel(nameResolverFactory, NO_INTERCEPTOR);
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(resolvedAddrs)))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel();
+
+    // Start the call
     ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
     Metadata headers = new Metadata();
-
-    // Start a call. The channel will starts with the first address (badAddress)
     call.start(mockCallListener, headers);
-    timer.runDueTasks();
     executor.runDueTasks();
 
-    ArgumentCaptor<ManagedClientTransport.Listener> badTransportListenerCaptor =
-        ArgumentCaptor.forClass(ManagedClientTransport.Listener.class);
-    verify(badTransport).start(badTransportListenerCaptor.capture());
+    // Simulate name resolution results
+    EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(resolvedAddrs);
+    inOrder.verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
+    assertThat(resolvedAddressCaptor.getValue().getAddresses()).containsExactly(addressGroup);
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(subchannel));
+    requestConnectionSafely(helper, subchannel);
+    inOrder.verify(subchannelStateListener).onSubchannelState(stateInfoCaptor.capture());
+    assertEquals(CONNECTING, stateInfoCaptor.getValue().getState());
+
+    // The channel will starts with the first address (badAddress)
     verify(mockTransportFactory)
-        .newClientTransport(same(badAddress), any(String.class), any(String.class));
+        .newClientTransport(
+            same(badAddress), any(ClientTransportOptions.class), any(ChannelLogger.class));
     verify(mockTransportFactory, times(0))
-          .newClientTransport(same(goodAddress), any(String.class), any(String.class));
-    badTransportListenerCaptor.getValue().transportShutdown(Status.UNAVAILABLE);
+        .newClientTransport(
+            same(goodAddress), any(ClientTransportOptions.class), any(ChannelLogger.class));
+
+    MockClientTransportInfo badTransportInfo = transports.poll();
+    // Which failed to connect
+    badTransportInfo.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    inOrder.verifyNoMoreInteractions();
 
     // The channel then try the second address (goodAddress)
-    ArgumentCaptor<ManagedClientTransport.Listener> goodTransportListenerCaptor =
-        ArgumentCaptor.forClass(ManagedClientTransport.Listener.class);
     verify(mockTransportFactory)
-          .newClientTransport(same(goodAddress), any(String.class), any(String.class));
-    verify(goodTransport).start(goodTransportListenerCaptor.capture());
-    goodTransportListenerCaptor.getValue().transportReady();
+        .newClientTransport(
+            same(goodAddress), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    MockClientTransportInfo goodTransportInfo = transports.poll();
+    when(goodTransportInfo.transport.newStream(
+            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mock(ClientStream.class));
+
+    goodTransportInfo.listener.transportReady();
+    inOrder.verify(subchannelStateListener).onSubchannelState(stateInfoCaptor.capture());
+    assertEquals(READY, stateInfoCaptor.getValue().getState());
+
+    // A typical LoadBalancer will call this once the subchannel becomes READY
+    updateBalancingStateSafely(helper, READY, mockPicker);
+    // Delayed transport uses the app executor to create real streams.
     executor.runDueTasks();
 
-    verify(goodTransport).newStream(same(method), same(headers), same(CallOptions.DEFAULT),
-        any(StatsTraceContext.class));
+    verify(goodTransportInfo.transport).newStream(
+        same(method), same(headers), same(CallOptions.DEFAULT),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
     // The bad transport was never used.
-    verify(badTransport, times(0)).newStream(any(MethodDescriptor.class), any(Metadata.class));
+    verify(badTransportInfo.transport, times(0)).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
   }
 
-  /**
-   * Verify that if all resolved addresses failed to connect, the call will fail.
-   */
   @Test
-  public void allServersFailedToConnect() throws Exception {
-    final SocketAddress addr1 = new SocketAddress() {
-        @Override public String toString() {
-          return "addr1";
-        }
-      };
-    final SocketAddress addr2 = new SocketAddress() {
-        @Override public String toString() {
-          return "addr2";
-        }
-      };
-    final ResolvedServerInfo server1 = new ResolvedServerInfo(addr1, Attributes.EMPTY);
-    final ResolvedServerInfo server2 = new ResolvedServerInfo(addr2, Attributes.EMPTY);
-    final ConnectionClientTransport transport1 = mock(ConnectionClientTransport.class);
-    final ConnectionClientTransport transport2 = mock(ConnectionClientTransport.class);
-    when(mockTransportFactory.newClientTransport(same(addr1), any(String.class), any(String.class)))
-        .thenReturn(transport1);
-    when(mockTransportFactory.newClientTransport(same(addr2), any(String.class), any(String.class)))
-        .thenReturn(transport2);
+  public void failFastRpcFailFromErrorFromBalancer() {
+    subtestFailRpcFromBalancer(false, false, true);
+  }
 
-    FakeNameResolverFactory nameResolverFactory =
-        new FakeNameResolverFactory(Arrays.asList(server1, server2));
-    createChannel(nameResolverFactory, NO_INTERCEPTOR);
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    Metadata headers = new Metadata();
+  @Test
+  public void failFastRpcFailFromDropFromBalancer() {
+    subtestFailRpcFromBalancer(false, true, true);
+  }
 
-    // Start a call. The channel will starts with the first address, which will fail to connect.
-    call.start(mockCallListener, headers);
-    timer.runDueTasks();
-    executor.runDueTasks();
+  @Test
+  public void waitForReadyRpcImmuneFromErrorFromBalancer() {
+    subtestFailRpcFromBalancer(true, false, false);
+  }
 
-    verify(transport1).start(transportListenerCaptor.capture());
-    verify(mockTransportFactory)
-        .newClientTransport(same(addr1), any(String.class), any(String.class));
-    verify(mockTransportFactory, times(0))
-        .newClientTransport(same(addr2), any(String.class), any(String.class));
-    transportListenerCaptor.getValue().transportShutdown(Status.UNAVAILABLE);
+  @Test
+  public void waitForReadyRpcFailFromDropFromBalancer() {
+    subtestFailRpcFromBalancer(true, true, true);
+  }
+
+  private void subtestFailRpcFromBalancer(boolean waitForReady, boolean drop, boolean shouldFail) {
+    createChannel();
+
+    // This call will be buffered by the channel, thus involve delayed transport
+    CallOptions callOptions = CallOptions.DEFAULT;
+    if (waitForReady) {
+      callOptions = callOptions.withWaitForReady();
+    } else {
+      callOptions = callOptions.withoutWaitForReady();
+    }
+    ClientCall<String, Integer> call1 = channel.newCall(method, callOptions);
+    call1.start(mockCallListener, new Metadata());
+
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    Status status = Status.UNAVAILABLE.withDescription("for test");
+
+    when(picker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(drop ? PickResult.withDrop(status) : PickResult.withError(status));
+    updateBalancingStateSafely(helper, READY, picker);
 
-    // The channel then try the second address, which will fail to connect too.
-    verify(transport2).start(transportListenerCaptor.capture());
-    verify(mockTransportFactory)
-        .newClientTransport(same(addr2), any(String.class), any(String.class));
-    verify(transport2).start(transportListenerCaptor.capture());
-    transportListenerCaptor.getValue().transportShutdown(Status.UNAVAILABLE);
     executor.runDueTasks();
+    if (shouldFail) {
+      verify(mockCallListener).onClose(same(status), any(Metadata.class));
+    } else {
+      verifyNoInteractions(mockCallListener);
+    }
 
-    // Call fails
-    verify(mockCallListener).onClose(statusCaptor.capture(), any(Metadata.class));
-    assertEquals(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
-    // No real stream was ever created
-    verify(transport1, times(0)).newStream(any(MethodDescriptor.class), any(Metadata.class));
-    verify(transport2, times(0)).newStream(any(MethodDescriptor.class), any(Metadata.class));
+    // This call doesn't involve delayed transport
+    ClientCall<String, Integer> call2 = channel.newCall(method, callOptions);
+    call2.start(mockCallListener2, new Metadata());
+
+    executor.runDueTasks();
+    if (shouldFail) {
+      verify(mockCallListener2).onClose(same(status), any(Metadata.class));
+    } else {
+      verifyNoInteractions(mockCallListener2);
+    }
   }
 
   /**
-   * Verify that if the first resolved address points to a server that is at first connected, but
-   * disconnected later, all calls will stick to the first address.
+   * Verify that if all resolved addresses failed to connect, a fail-fast call will fail, while a
+   * wait-for-ready call will still be buffered.
    */
   @Test
-  public void firstResolvedServerConnectedThenDisconnected() throws Exception {
+  public void allServersFailedToConnect() throws Exception {
     final SocketAddress addr1 = new SocketAddress() {
         @Override public String toString() {
           return "addr1";
@@ -791,292 +1498,3254 @@ public void firstResolvedServerConnectedThenDisconnected() throws Exception {
           return "addr2";
         }
       };
-    final ResolvedServerInfo server1 = new ResolvedServerInfo(addr1, Attributes.EMPTY);
-    final ResolvedServerInfo server2 = new ResolvedServerInfo(addr2, Attributes.EMPTY);
-    // Addr1 will have two transports throughout this test.
-    final ConnectionClientTransport transport1 = mock(ConnectionClientTransport.class);
-    final ConnectionClientTransport transport2 = mock(ConnectionClientTransport.class);
-    when(transport1.newStream(
-            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
-            any(StatsTraceContext.class)))
-        .thenReturn(mock(ClientStream.class));
-    when(transport2.newStream(
-            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
-            any(StatsTraceContext.class)))
-        .thenReturn(mock(ClientStream.class));
-    when(mockTransportFactory.newClientTransport(same(addr1), any(String.class), any(String.class)))
-        .thenReturn(transport1, transport2);
+    InOrder inOrder = inOrder(mockLoadBalancer, subchannelStateListener);
+
+    List<SocketAddress> resolvedAddrs = Arrays.asList(addr1, addr2);
 
     FakeNameResolverFactory nameResolverFactory =
-        new FakeNameResolverFactory(Arrays.asList(server1, server2));
-    createChannel(nameResolverFactory, NO_INTERCEPTOR);
-    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
-    Metadata headers = new Metadata();
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(resolvedAddrs)))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel();
 
-    // First call will use the first address
+    // Start a wait-for-ready call
+    ClientCall<String, Integer> call =
+        channel.newCall(method, CallOptions.DEFAULT.withWaitForReady());
+    Metadata headers = new Metadata();
     call.start(mockCallListener, headers);
-    timer.runDueTasks();
+    // ... and a fail-fast call
+    ClientCall<String, Integer> call2 =
+        channel.newCall(method, CallOptions.DEFAULT.withoutWaitForReady());
+    call2.start(mockCallListener2, headers);
     executor.runDueTasks();
 
+    // Simulate name resolution results
+    EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(resolvedAddrs);
+    inOrder.verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
+    assertThat(resolvedAddressCaptor.getValue().getAddresses()).containsExactly(addressGroup);
+
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(subchannel));
+    requestConnectionSafely(helper, subchannel);
+
+    inOrder.verify(subchannelStateListener).onSubchannelState(stateInfoCaptor.capture());
+    assertEquals(CONNECTING, stateInfoCaptor.getValue().getState());
+
+    // Connecting to server1, which will fail
     verify(mockTransportFactory)
-        .newClientTransport(same(addr1), any(String.class), any(String.class));
-    verify(transport1).start(transportListenerCaptor.capture());
-    transportListenerCaptor.getValue().transportReady();
-    executor.runDueTasks();
+        .newClientTransport(
+            same(addr1), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    verify(mockTransportFactory, times(0))
+        .newClientTransport(
+            same(addr2), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    MockClientTransportInfo transportInfo1 = transports.poll();
+    transportInfo1.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+
+    // Connecting to server2, which will fail too
+    verify(mockTransportFactory)
+        .newClientTransport(
+            same(addr2), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    MockClientTransportInfo transportInfo2 = transports.poll();
+    Status server2Error = Status.UNAVAILABLE.withDescription("Server2 failed to connect");
+    transportInfo2.listener.transportShutdown(server2Error,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
 
-    verify(transport1).newStream(same(method), same(headers), same(CallOptions.DEFAULT),
-        any(StatsTraceContext.class));
-    transportListenerCaptor.getValue().transportShutdown(Status.UNAVAILABLE);
+    // ... which makes the subchannel enter TRANSIENT_FAILURE. The last error Status is propagated
+    // to LoadBalancer.
+    inOrder.verify(subchannelStateListener).onSubchannelState(stateInfoCaptor.capture());
+    assertEquals(TRANSIENT_FAILURE, stateInfoCaptor.getValue().getState());
+    assertSame(server2Error, stateInfoCaptor.getValue().getStatus());
 
-    // Second call still use the first address, since it was successfully connected.
-    ClientCall<String, Integer> call2 = channel.newCall(method, CallOptions.DEFAULT);
-    call2.start(mockCallListener, headers);
-    verify(transport2).start(transportListenerCaptor.capture());
-    verify(mockTransportFactory, times(2))
-        .newClientTransport(same(addr1), any(String.class), any(String.class));
-    transportListenerCaptor.getValue().transportReady();
+    // A typical LoadBalancer would create a picker with error
+    SubchannelPicker picker2 = mock(SubchannelPicker.class);
+    when(picker2.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withError(server2Error));
+    updateBalancingStateSafely(helper, TRANSIENT_FAILURE, picker2);
     executor.runDueTasks();
 
-    verify(transport2).newStream(same(method), same(headers), same(CallOptions.DEFAULT),
-        any(StatsTraceContext.class));
+    // ... which fails the fail-fast call
+    verify(mockCallListener2).onClose(same(server2Error), any(Metadata.class));
+    // ... while the wait-for-ready call stays
+    verifyNoMoreInteractions(mockCallListener);
+    // No real stream was ever created
+    verify(transportInfo1.transport, times(0)).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    verify(transportInfo2.transport, times(0)).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
   }
 
   @Test
-  public void uriPattern() {
-    assertTrue(ManagedChannelImpl.URI_PATTERN.matcher("a:/").matches());
-    assertTrue(ManagedChannelImpl.URI_PATTERN.matcher("Z019+-.:/!@ #~ ").matches());
-    assertFalse(ManagedChannelImpl.URI_PATTERN.matcher("a/:").matches()); // "/:" not matched
-    assertFalse(ManagedChannelImpl.URI_PATTERN.matcher("0a:/").matches()); // '0' not matched
-    assertFalse(ManagedChannelImpl.URI_PATTERN.matcher("a,:/").matches()); // ',' not matched
-    assertFalse(ManagedChannelImpl.URI_PATTERN.matcher(" a:/").matches()); // space not matched
-  }
+  public void subchannels() {
+    createChannel();
 
-  /**
-   * Test that information such as the Call's context, MethodDescriptor, authority, executor are
-   * propagated to newStream() and applyRequestMetadata().
-   */
-  @Test
-  public void informationPropagatedToNewStreamAndCallCredentials() {
-    createChannel(new FakeNameResolverFactory(true), NO_INTERCEPTOR);
-    CallOptions callOptions = CallOptions.DEFAULT.withCallCredentials(creds);
-    final Context.Key<String> testKey = Context.key("testing");
-    Context ctx = Context.current().withValue(testKey, "testValue");
-    final LinkedList<Context> credsApplyContexts = new LinkedList<Context>();
-    final LinkedList<Context> newStreamContexts = new LinkedList<Context>();
-    doAnswer(new Answer<Void>() {
-        @Override
-        public Void answer(InvocationOnMock in) throws Throwable {
-          credsApplyContexts.add(Context.current());
-          return null;
-        }
-      }).when(creds).applyRequestMetadata(
-          any(MethodDescriptor.class), any(Attributes.class), any(Executor.class),
-          any(MetadataApplier.class));
+    // createSubchannel() always return a new Subchannel
+    Attributes attrs1 = Attributes.newBuilder().set(SUBCHANNEL_ATTR_KEY, "attr1").build();
+    Attributes attrs2 = Attributes.newBuilder().set(SUBCHANNEL_ATTR_KEY, "attr2").build();
+    SubchannelStateListener listener1 = mock(SubchannelStateListener.class);
+    SubchannelStateListener listener2 = mock(SubchannelStateListener.class);
+    final Subchannel sub1 = createSubchannelSafely(helper, addressGroup, attrs1, listener1);
+    final Subchannel sub2 = createSubchannelSafely(helper, addressGroup, attrs2, listener2);
+    assertNotSame(sub1, sub2);
+    assertNotSame(attrs1, attrs2);
+    assertSame(attrs1, sub1.getAttributes());
+    assertSame(attrs2, sub2.getAttributes());
 
-    final ConnectionClientTransport transport = mock(ConnectionClientTransport.class);
-    when(transport.getAttributes()).thenReturn(Attributes.EMPTY);
-    when(mockTransportFactory.newClientTransport(any(SocketAddress.class), any(String.class),
-            any(String.class))).thenReturn(transport);
-    doAnswer(new Answer<ClientStream>() {
+    final AtomicBoolean snippetPassed = new AtomicBoolean(false);
+    helper.getSynchronizationContext().execute(new Runnable() {
         @Override
-        public ClientStream answer(InvocationOnMock in) throws Throwable {
-          newStreamContexts.add(Context.current());
-          return mock(ClientStream.class);
+        public void run() {
+          // getAddresses() must be called from sync context
+          assertSame(addressGroup, sub1.getAddresses());
+          assertSame(addressGroup, sub2.getAddresses());
+          snippetPassed.set(true);
         }
-      }).when(transport).newStream(
-          any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
-          any(StatsTraceContext.class));
-
-    // First call will be on delayed transport.  Only newCall() is run within the expected context,
-    // so that we can verify that the context is explicitly attached before calling newStream() and
-    // applyRequestMetadata(), which happens after we detach the context from the thread.
-    Context origCtx = ctx.attach();
-    assertEquals("testValue", testKey.get());
-    ClientCall<String, Integer> call = channel.newCall(method, callOptions);
-    ctx.detach(origCtx);
-    assertNull(testKey.get());
-    call.start(mockCallListener, new Metadata());
+      });
+    assertThat(snippetPassed.get()).isTrue();
 
-    ArgumentCaptor<ManagedClientTransport.Listener> transportListenerCaptor =
-        ArgumentCaptor.forClass(ManagedClientTransport.Listener.class);
-    verify(mockTransportFactory).newClientTransport(
-        same(socketAddress), eq(authority), eq(userAgent));
-    verify(transport).start(transportListenerCaptor.capture());
-    verify(creds, never()).applyRequestMetadata(
-        any(MethodDescriptor.class), any(Attributes.class), any(Executor.class),
-        any(MetadataApplier.class));
+    // requestConnection()
+    verify(mockTransportFactory, never())
+        .newClientTransport(
+            any(SocketAddress.class),
+            any(ClientTransportOptions.class),
+            any(TransportLogger.class));
+    requestConnectionSafely(helper, sub1);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            eq(socketAddress),
+            eq(clientTransportOptions),
+            isA(TransportLogger.class));
+    MockClientTransportInfo transportInfo1 = transports.poll();
+    assertNotNull(transportInfo1);
 
-    // applyRequestMetadata() is called after the transport becomes ready.
-    transportListenerCaptor.getValue().transportReady();
-    executor.runDueTasks();
-    ArgumentCaptor<Attributes> attrsCaptor = ArgumentCaptor.forClass(Attributes.class);
-    ArgumentCaptor<MetadataApplier> applierCaptor = ArgumentCaptor.forClass(MetadataApplier.class);
-    verify(creds).applyRequestMetadata(same(method), attrsCaptor.capture(),
-        same(executor.getScheduledExecutorService()), applierCaptor.capture());
-    assertEquals("testValue", testKey.get(credsApplyContexts.poll()));
-    assertEquals(authority, attrsCaptor.getValue().get(CallCredentials.ATTR_AUTHORITY));
-    assertEquals(SecurityLevel.NONE,
-        attrsCaptor.getValue().get(CallCredentials.ATTR_SECURITY_LEVEL));
-    verify(transport, never()).newStream(
-        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
-        any(StatsTraceContext.class));
+    requestConnectionSafely(helper, sub2);
+    verify(mockTransportFactory, times(2))
+        .newClientTransport(
+            eq(socketAddress),
+            eq(clientTransportOptions),
+            isA(TransportLogger.class));
+    MockClientTransportInfo transportInfo2 = transports.poll();
+    assertNotNull(transportInfo2);
 
-    // newStream() is called after apply() is called
-    applierCaptor.getValue().apply(new Metadata());
-    verify(transport).newStream(same(method), any(Metadata.class), same(callOptions),
-        any(StatsTraceContext.class));
-    assertEquals("testValue", testKey.get(newStreamContexts.poll()));
-    // The context should not live beyond the scope of newStream() and applyRequestMetadata()
-    assertNull(testKey.get());
+    requestConnectionSafely(helper, sub1);
+    requestConnectionSafely(helper, sub2);
+    // The subchannel doesn't matter since this isn't called
+    verify(mockTransportFactory, times(2))
+        .newClientTransport(
+            eq(socketAddress), eq(clientTransportOptions), isA(TransportLogger.class));
 
+    // updateAddresses()
+    updateAddressesSafely(helper, sub1, Collections.singletonList(addressGroup2));
+    assertThat(((InternalSubchannel) sub1.getInternalSubchannel()).getAddressGroups())
+        .isEqualTo(Collections.singletonList(addressGroup2));
 
-    // Second call will not be on delayed transport
-    origCtx = ctx.attach();
-    call = channel.newCall(method, callOptions);
-    ctx.detach(origCtx);
-    call.start(mockCallListener, new Metadata());
+    // shutdown() has a delay
+    shutdownSafely(helper, sub1);
+    timer.forwardTime(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS - 1, TimeUnit.SECONDS);
+    shutdownSafely(helper, sub1);
+    verify(transportInfo1.transport, never()).shutdown(any(Status.class));
+    timer.forwardTime(1, TimeUnit.SECONDS);
+    verify(transportInfo1.transport).shutdown(same(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_STATUS));
 
-    verify(creds, times(2)).applyRequestMetadata(same(method), attrsCaptor.capture(),
-        same(executor.getScheduledExecutorService()), applierCaptor.capture());
-    assertEquals("testValue", testKey.get(credsApplyContexts.poll()));
-    assertEquals(authority, attrsCaptor.getValue().get(CallCredentials.ATTR_AUTHORITY));
-    assertEquals(SecurityLevel.NONE,
-        attrsCaptor.getValue().get(CallCredentials.ATTR_SECURITY_LEVEL));
-    // This is from the first call
-    verify(transport).newStream(
-        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
-        any(StatsTraceContext.class));
+    // ... but not after Channel is terminating
+    verify(mockLoadBalancer, never()).shutdown();
+    channel.shutdown();
+    verify(mockLoadBalancer).shutdown();
+    verify(transportInfo2.transport, never()).shutdown(any(Status.class));
 
-    // Still, newStream() is called after apply() is called
-    applierCaptor.getValue().apply(new Metadata());
-    verify(transport, times(2)).newStream(same(method), any(Metadata.class), same(callOptions),
-        any(StatsTraceContext.class));
-    assertEquals("testValue", testKey.get(newStreamContexts.poll()));
+    shutdownSafely(helper, sub2);
+    verify(transportInfo2.transport).shutdown(same(ManagedChannelImpl.SHUTDOWN_STATUS));
 
-    assertNull(testKey.get());
+    // Cleanup
+    transportInfo1.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    transportInfo1.listener.transportTerminated();
+    transportInfo2.listener.transportShutdown(Status.UNAVAILABLE,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    transportInfo2.listener.transportTerminated();
+    timer.forwardTime(ManagedChannelImpl.SUBCHANNEL_SHUTDOWN_DELAY_SECONDS, TimeUnit.SECONDS);
   }
 
-  private static class FakeBackoffPolicyProvider implements BackoffPolicy.Provider {
-    @Override
-    public BackoffPolicy get() {
-      return new BackoffPolicy() {
-        @Override
-        public long nextBackoffMillis() {
-          return 1;
-        }
-      };
-    }
+  @Test
+  public void subchannelStringableBeforeStart() {
+    createChannel();
+    Subchannel subchannel = createUnstartedSubchannel(helper, addressGroup, Attributes.EMPTY);
+    assertThat(subchannel.toString()).isNotNull();
   }
 
-  private class FakeNameResolverFactory extends NameResolver.Factory {
-    final List<ResolvedServerInfoGroup> servers;
-    final boolean resolvedAtStart;
-    final ArrayList<FakeNameResolver> resolvers = new ArrayList<FakeNameResolver>();
+  @Test
+  public void subchannelLoggerCreatedBeforeSubchannelStarted() {
+    createChannel();
+    Subchannel subchannel = createUnstartedSubchannel(helper, addressGroup, Attributes.EMPTY);
+    assertThat(subchannel.getChannelLogger()).isNotNull();
+  }
 
-    FakeNameResolverFactory(boolean resolvedAtStart) {
-      this.resolvedAtStart = resolvedAtStart;
-      servers = Collections.singletonList(ResolvedServerInfoGroup.builder().add(server).build());
-    }
+  @Test
+  public void subchannelsWhenChannelShutdownNow() {
+    createChannel();
+    Subchannel sub1 =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    Subchannel sub2 =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, sub1);
+    requestConnectionSafely(helper, sub2);
 
-    FakeNameResolverFactory(List<ResolvedServerInfo> servers) {
-      resolvedAtStart = true;
-      this.servers = Collections.singletonList(
-          ResolvedServerInfoGroup.builder().addAll(servers).build());
-    }
+    assertThat(transports).hasSize(2);
+    MockClientTransportInfo ti1 = transports.poll();
+    MockClientTransportInfo ti2 = transports.poll();
 
-    public FakeNameResolverFactory() {
-      resolvedAtStart = true;
-      this.servers = ImmutableList.of();
-    }
+    ti1.listener.transportReady();
+    ti2.listener.transportReady();
 
-    @Override
-    public NameResolver newNameResolver(final URI targetUri, Attributes params) {
-      if (!expectedUri.equals(targetUri)) {
-        return null;
-      }
-      assertSame(NAME_RESOLVER_PARAMS, params);
-      FakeNameResolver resolver = new FakeNameResolver();
-      resolvers.add(resolver);
-      return resolver;
-    }
+    channel.shutdownNow();
+    verify(ti1.transport).shutdownNow(any(Status.class));
+    verify(ti2.transport).shutdownNow(any(Status.class));
 
-    @Override
-    public String getDefaultScheme() {
-      return "fake";
-    }
+    ti1.listener.transportShutdown(Status.UNAVAILABLE.withDescription("shutdown now"),
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    ti2.listener.transportShutdown(Status.UNAVAILABLE.withDescription("shutdown now"),
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    ti1.listener.transportTerminated();
+
+    assertFalse(channel.isTerminated());
+    ti2.listener.transportTerminated();
+    assertTrue(channel.isTerminated());
+  }
+
+  @Test
+  public void subchannelsNoConnectionShutdown() {
+    createChannel();
+    Subchannel sub1 =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    Subchannel sub2 =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+
+    channel.shutdown();
+    verify(mockLoadBalancer).shutdown();
+    shutdownSafely(helper, sub1);
+    assertFalse(channel.isTerminated());
+    shutdownSafely(helper, sub2);
+    assertTrue(channel.isTerminated());
+    verify(mockTransportFactory, never())
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+  }
+
+  @Test
+  public void subchannelsRequestConnectionNoopAfterShutdown() {
+    createChannel();
+    Subchannel sub1 =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+
+    shutdownSafely(helper, sub1);
+    requestConnectionSafely(helper, sub1);
+    verify(mockTransportFactory, never())
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+  }
+
+  @Test
+  public void subchannelsNoConnectionShutdownNow() {
+    createChannel();
+    createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    channel.shutdownNow();
+
+    verify(mockLoadBalancer).shutdown();
+    // Channel's shutdownNow() will call shutdownNow() on all subchannels.
+    // Therefore, channel is terminated without relying on LoadBalancer to shutdown subchannels.
+    assertTrue(channel.isTerminated());
+    verify(mockTransportFactory, never())
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+  }
+
+  @Test
+  public void oobChannelHasNoChannelCallCredentials() {
+    Metadata.Key<String> metadataKey =
+        Metadata.Key.of("token", Metadata.ASCII_STRING_MARSHALLER);
+    String channelCredValue = "channel-provided call cred";
+    channelBuilder = new ManagedChannelImplBuilder(
+        TARGET, InsecureChannelCredentials.create(),
+        new FakeCallCredentials(metadataKey, channelCredValue),
+        new UnsupportedClientTransportFactoryBuilder(), new FixedPortProvider(DEFAULT_PORT));
+    channelBuilder.disableRetry();
+    configureBuilder(channelBuilder);
+    createChannel();
+
+    // Verify that the normal channel has call creds, to validate configuration
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
+    MockClientTransportInfo transportInfo = transports.poll();
+    assertNotNull(transportInfo);
+    transportInfo.listener.transportReady();
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(
+        PickResult.withSubchannel(subchannel));
+    updateBalancingStateSafely(helper, READY, mockPicker);
+
+    String callCredValue = "per-RPC call cred";
+    CallOptions callOptions = CallOptions.DEFAULT
+        .withCallCredentials(new FakeCallCredentials(metadataKey, callCredValue));
+    Metadata headers = new Metadata();
+    ClientCall<String, Integer> call = channel.newCall(method, callOptions);
+    call.start(mockCallListener, headers);
+
+    verify(transportInfo.transport).newStream(
+        same(method), same(headers), same(callOptions),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    assertThat(headers.getAll(metadataKey))
+        .containsExactly(channelCredValue, callCredValue).inOrder();
+
+    // Verify that the oob channel does not
+    ManagedChannel oob = helper.createOobChannel(
+        Collections.singletonList(addressGroup), "oobauthority");
+
+    headers = new Metadata();
+    call = oob.newCall(method, callOptions);
+    call.start(mockCallListener2, headers);
+
+    transportInfo = transports.poll();
+    assertNotNull(transportInfo);
+    transportInfo.listener.transportReady();
+    balancerRpcExecutor.runDueTasks();
+
+    verify(transportInfo.transport).newStream(
+        same(method), same(headers), ArgumentMatchers.any(),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    assertThat(headers.getAll(metadataKey)).containsExactly(callCredValue);
+    oob.shutdownNow();
+
+    // Verify that resolving oob channel does not
+    oob = helper.createResolvingOobChannelBuilder("oobauthority")
+        .nameResolverFactory(
+            new FakeNameResolverFactory.Builder(URI.create("fake:///oobauthority")).build())
+        .defaultLoadBalancingPolicy(MOCK_POLICY_NAME)
+        .idleTimeout(ManagedChannelImplBuilder.IDLE_MODE_MAX_TIMEOUT_DAYS, TimeUnit.DAYS)
+        .disableRetry() // irrelevant to what we test, disable retry to make verification easy
+        .build();
+    oob.getState(true);
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider, times(2)).newLoadBalancer(helperCaptor.capture());
+    Helper oobHelper = helperCaptor.getValue();
+
+    subchannel =
+        createSubchannelSafely(oobHelper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(oobHelper, subchannel);
+    transportInfo = transports.poll();
+    assertNotNull(transportInfo);
+    transportInfo.listener.transportReady();
+    SubchannelPicker mockPicker2 = mock(SubchannelPicker.class);
+    when(mockPicker2.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(
+        PickResult.withSubchannel(subchannel));
+    updateBalancingStateSafely(oobHelper, READY, mockPicker2);
+
+    headers = new Metadata();
+    call = oob.newCall(method, callOptions);
+    call.start(mockCallListener2, headers);
+
+    // CallOptions may contain StreamTracerFactory for census that is added by default.
+    verify(transportInfo.transport).newStream(
+        same(method), same(headers), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    assertThat(headers.getAll(metadataKey)).containsExactly(callCredValue);
+    oob.shutdownNow();
+  }
+
+  @Test
+  public void oobChannelWithOobChannelCredsHasChannelCallCredentials() {
+    Metadata.Key<String> metadataKey =
+        Metadata.Key.of("token", Metadata.ASCII_STRING_MARSHALLER);
+    String channelCredValue = "channel-provided call cred";
+    when(mockTransportFactory.swapChannelCredentials(any(CompositeChannelCredentials.class)))
+        .thenAnswer(new Answer<SwapChannelCredentialsResult>() {
+          @Override
+          public SwapChannelCredentialsResult answer(InvocationOnMock invocation) {
+            CompositeChannelCredentials c =
+                invocation.getArgument(0, CompositeChannelCredentials.class);
+            return new SwapChannelCredentialsResult(mockTransportFactory, c.getCallCredentials());
+          }
+        });
+    channelBuilder = new ManagedChannelImplBuilder(
+        TARGET, InsecureChannelCredentials.create(),
+        new FakeCallCredentials(metadataKey, channelCredValue),
+        new UnsupportedClientTransportFactoryBuilder(), new FixedPortProvider(DEFAULT_PORT));
+    channelBuilder.disableRetry();
+    configureBuilder(channelBuilder);
+    createChannel();
+
+    // Verify that the normal channel has call creds, to validate configuration
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
+    MockClientTransportInfo transportInfo = transports.poll();
+    transportInfo.listener.transportReady();
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(
+        PickResult.withSubchannel(subchannel));
+    updateBalancingStateSafely(helper, READY, mockPicker);
+
+    String callCredValue = "per-RPC call cred";
+    CallOptions callOptions = CallOptions.DEFAULT
+        .withCallCredentials(new FakeCallCredentials(metadataKey, callCredValue));
+    Metadata headers = new Metadata();
+    ClientCall<String, Integer> call = channel.newCall(method, callOptions);
+    call.start(mockCallListener, headers);
+
+    verify(transportInfo.transport).newStream(
+        same(method), same(headers), same(callOptions),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    assertThat(headers.getAll(metadataKey))
+        .containsExactly(channelCredValue, callCredValue).inOrder();
+
+    // Verify that resolving oob channel with oob channel creds provides call creds
+    String oobChannelCredValue = "oob-channel-provided call cred";
+    ChannelCredentials oobChannelCreds = CompositeChannelCredentials.create(
+        InsecureChannelCredentials.create(),
+        new FakeCallCredentials(metadataKey, oobChannelCredValue));
+    ManagedChannel oob = helper.createResolvingOobChannelBuilder(
+            "fake://oobauthority/", oobChannelCreds)
+        .nameResolverFactory(
+            new FakeNameResolverFactory.Builder(URI.create("fake://oobauthority/")).build())
+        .defaultLoadBalancingPolicy(MOCK_POLICY_NAME)
+        .idleTimeout(ManagedChannelImplBuilder.IDLE_MODE_MAX_TIMEOUT_DAYS, TimeUnit.DAYS)
+        .disableRetry() // irrelevant to what we test, disable retry to make verification easy
+        .build();
+    oob.getState(true);
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider, times(2)).newLoadBalancer(helperCaptor.capture());
+    Helper oobHelper = helperCaptor.getValue();
+
+    subchannel =
+        createSubchannelSafely(oobHelper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(oobHelper, subchannel);
+    transportInfo = transports.poll();
+    transportInfo.listener.transportReady();
+    SubchannelPicker mockPicker2 = mock(SubchannelPicker.class);
+    when(mockPicker2.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(
+        PickResult.withSubchannel(subchannel));
+    updateBalancingStateSafely(oobHelper, READY, mockPicker2);
+
+    headers = new Metadata();
+    call = oob.newCall(method, callOptions);
+    call.start(mockCallListener2, headers);
+
+    // CallOptions may contain StreamTracerFactory for census that is added by default.
+    verify(transportInfo.transport).newStream(
+        same(method), same(headers), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    assertThat(headers.getAll(metadataKey))
+        .containsExactly(oobChannelCredValue, callCredValue).inOrder();
+    oob.shutdownNow();
+  }
+
+  @Test
+  public void subchannelChannel_normalUsage() {
+    createChannel();
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    verify(balancerRpcExecutorPool, never()).getObject();
+
+    Channel sChannel = subchannel.asChannel();
+    verify(balancerRpcExecutorPool).getObject();
+
+    Metadata headers = new Metadata();
+    CallOptions callOptions = CallOptions.DEFAULT.withDeadlineAfter(5, TimeUnit.SECONDS);
+
+    // Subchannel must be READY when creating the RPC.
+    requestConnectionSafely(helper, subchannel);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    MockClientTransportInfo transportInfo = transports.poll();
+    ConnectionClientTransport mockTransport = transportInfo.transport;
+    ManagedClientTransport.Listener transportListener = transportInfo.listener;
+    transportListener.transportReady();
+
+    ClientCall<String, Integer> call = sChannel.newCall(method, callOptions);
+    call.start(mockCallListener, headers);
+    verify(mockTransport).newStream(
+        same(method), same(headers), callOptionsCaptor.capture(),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+
+    CallOptions capturedCallOption = callOptionsCaptor.getValue();
+    assertThat(capturedCallOption.getDeadline()).isSameInstanceAs(callOptions.getDeadline());
+    assertThat(capturedCallOption.getOption(GrpcUtil.CALL_OPTIONS_RPC_OWNED_BY_BALANCER)).isTrue();
+  }
+
+  @Test
+  public void subchannelChannel_failWhenNotReady() {
+    createChannel();
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    Channel sChannel = subchannel.asChannel();
+    Metadata headers = new Metadata();
+
+    requestConnectionSafely(helper, subchannel);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    MockClientTransportInfo transportInfo = transports.poll();
+    ConnectionClientTransport mockTransport = transportInfo.transport;
+
+    assertEquals(0, balancerRpcExecutor.numPendingTasks());
+
+    // Subchannel is still CONNECTING, but not READY yet
+    ClientCall<String, Integer> call = sChannel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, headers);
+    verify(mockTransport, never()).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+
+    verifyNoInteractions(mockCallListener);
+    assertEquals(1, balancerRpcExecutor.runDueTasks());
+    verify(mockCallListener).onClose(
+        same(SubchannelChannel.NOT_READY_ERROR), any(Metadata.class));
+  }
+
+  @Test
+  public void subchannelChannel_failWaitForReady() {
+    createChannel();
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    Channel sChannel = subchannel.asChannel();
+    Metadata headers = new Metadata();
+
+    // Subchannel must be READY when creating the RPC.
+    requestConnectionSafely(helper, subchannel);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    MockClientTransportInfo transportInfo = transports.poll();
+    ConnectionClientTransport mockTransport = transportInfo.transport;
+    ManagedClientTransport.Listener transportListener = transportInfo.listener;
+    transportListener.transportReady();
+    assertEquals(0, balancerRpcExecutor.numPendingTasks());
+
+    // Wait-for-ready RPC is not allowed
+    ClientCall<String, Integer> call =
+        sChannel.newCall(method, CallOptions.DEFAULT.withWaitForReady());
+    call.start(mockCallListener, headers);
+    verify(mockTransport, never()).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+
+    verifyNoInteractions(mockCallListener);
+    assertEquals(1, balancerRpcExecutor.runDueTasks());
+    verify(mockCallListener).onClose(
+        same(SubchannelChannel.WAIT_FOR_READY_ERROR), any(Metadata.class));
+  }
+
+  @Test
+  public void lbHelper_getScheduledExecutorService() {
+    createChannel();
+
+    ScheduledExecutorService ses = helper.getScheduledExecutorService();
+    Runnable task = mock(Runnable.class);
+    helper.getSynchronizationContext().schedule(task, 110, TimeUnit.NANOSECONDS, ses);
+    timer.forwardNanos(109);
+    verify(task, never()).run();
+    timer.forwardNanos(1);
+    verify(task).run();
+
+    try {
+      ses.shutdown();
+      fail("Should throw");
+    } catch (UnsupportedOperationException e) {
+      // expected
+    }
+
+    try {
+      ses.shutdownNow();
+      fail("Should throw");
+    } catch (UnsupportedOperationException e) {
+      // expected
+    }
+  }
+
+  @Test
+  public void lbHelper_getNameResolverArgs() {
+    createChannel();
+
+    NameResolver.Args args = helper.getNameResolverArgs();
+    assertThat(args.getDefaultPort()).isEqualTo(DEFAULT_PORT);
+    assertThat(args.getProxyDetector()).isSameInstanceAs(GrpcUtil.DEFAULT_PROXY_DETECTOR);
+    assertThat(args.getSynchronizationContext())
+        .isSameInstanceAs(helper.getSynchronizationContext());
+    assertThat(args.getServiceConfigParser()).isNotNull();
+    assertThat(args.getMetricRecorder()).isNotNull();
+  }
+
+  @Test
+  public void lbHelper_getNonDefaultNameResolverRegistry() {
+    createChannel();
+
+    assertThat(helper.getNameResolverRegistry())
+        .isNotSameInstanceAs(NameResolverRegistry.getDefaultRegistry());
+  }
+
+  /**
+   * Test that information such as the Call's context, MethodDescriptor, authority, executor are
+   * propagated to newStream() and applyRequestMetadata().
+   */
+  @Test
+  public void informationPropagatedToNewStreamAndCallCredentials() {
+    createChannel();
+    CallOptions callOptions = CallOptions.DEFAULT.withCallCredentials(creds);
+    final Context.Key<String> testKey = Context.key("testing");
+    Context ctx = Context.current().withValue(testKey, "testValue");
+    final LinkedList<Context> credsApplyContexts = new LinkedList<>();
+    final LinkedList<Context> newStreamContexts = new LinkedList<>();
+    doAnswer(new Answer<Void>() {
+        @Override
+        public Void answer(InvocationOnMock in) throws Throwable {
+          credsApplyContexts.add(Context.current());
+          return null;
+        }
+      }).when(creds).applyRequestMetadata(
+          any(RequestInfo.class), any(Executor.class), any(CallCredentials.MetadataApplier.class));
+
+    // First call will be on delayed transport.  Only newCall() is run within the expected context,
+    // so that we can verify that the context is explicitly attached before calling newStream() and
+    // applyRequestMetadata(), which happens after we detach the context from the thread.
+    Context origCtx = ctx.attach();
+    assertEquals("testValue", testKey.get());
+    ClientCall<String, Integer> call = channel.newCall(method, callOptions);
+    ctx.detach(origCtx);
+    assertNull(testKey.get());
+    call.start(mockCallListener, new Metadata());
+
+    // Simulate name resolution results
+    EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(socketAddress);
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
+    verify(mockTransportFactory)
+        .newClientTransport(
+            same(socketAddress), eq(clientTransportOptions), any(ChannelLogger.class));
+    MockClientTransportInfo transportInfo = transports.poll();
+    final ConnectionClientTransport transport = transportInfo.transport;
+    when(transport.getAttributes()).thenReturn(Attributes.EMPTY);
+    doAnswer(new Answer<ClientStream>() {
+        @Override
+        public ClientStream answer(InvocationOnMock in) throws Throwable {
+          newStreamContexts.add(Context.current());
+          return mock(ClientStream.class);
+        }
+      }).when(transport).newStream(
+          any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+          ArgumentMatchers.<ClientStreamTracer[]>any());
+
+    verify(creds, never()).applyRequestMetadata(
+        any(RequestInfo.class), any(Executor.class), any(CallCredentials.MetadataApplier.class));
+
+    // applyRequestMetadata() is called after the transport becomes ready.
+    transportInfo.listener.transportReady();
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(subchannel));
+    updateBalancingStateSafely(helper, READY, mockPicker);
+    executor.runDueTasks();
+    ArgumentCaptor<RequestInfo> infoCaptor = ArgumentCaptor.forClass(RequestInfo.class);
+    ArgumentCaptor<Executor> executorArgumentCaptor = ArgumentCaptor.forClass(Executor.class);
+    ArgumentCaptor<CallCredentials.MetadataApplier> applierCaptor =
+        ArgumentCaptor.forClass(CallCredentials.MetadataApplier.class);
+    verify(creds).applyRequestMetadata(infoCaptor.capture(),
+        executorArgumentCaptor.capture(), applierCaptor.capture());
+    assertSame(offloadExecutor,
+            ((ManagedChannelImpl.ExecutorHolder) executorArgumentCaptor.getValue()).getExecutor());
+    assertEquals("testValue", testKey.get(credsApplyContexts.poll()));
+    assertEquals(AUTHORITY, infoCaptor.getValue().getAuthority());
+    assertEquals(SecurityLevel.NONE, infoCaptor.getValue().getSecurityLevel());
+    verify(transport, never()).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+
+    // newStream() is called after apply() is called
+    applierCaptor.getValue().apply(new Metadata());
+    verify(transport).newStream(
+        same(method), any(Metadata.class), same(callOptions),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    assertEquals("testValue", testKey.get(newStreamContexts.poll()));
+    // The context should not live beyond the scope of newStream() and applyRequestMetadata()
+    assertNull(testKey.get());
+
+
+    // Second call will not be on delayed transport
+    origCtx = ctx.attach();
+    call = channel.newCall(method, callOptions);
+    ctx.detach(origCtx);
+    call.start(mockCallListener, new Metadata());
+
+    verify(creds, times(2)).applyRequestMetadata(infoCaptor.capture(),
+            executorArgumentCaptor.capture(), applierCaptor.capture());
+    assertSame(offloadExecutor,
+            ((ManagedChannelImpl.ExecutorHolder) executorArgumentCaptor.getValue()).getExecutor());
+    assertEquals("testValue", testKey.get(credsApplyContexts.poll()));
+    assertEquals(AUTHORITY, infoCaptor.getValue().getAuthority());
+    assertEquals(SecurityLevel.NONE, infoCaptor.getValue().getSecurityLevel());
+    // This is from the first call
+    verify(transport).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+
+    // Still, newStream() is called after apply() is called
+    applierCaptor.getValue().apply(new Metadata());
+    verify(transport, times(2)).newStream(
+        same(method), any(Metadata.class), same(callOptions),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    assertEquals("testValue", testKey.get(newStreamContexts.poll()));
+
+    assertNull(testKey.get());
+  }
+
+  @Test
+  public void pickerReturnsStreamTracer_noDelay() {
+    ClientStream mockStream = mock(ClientStream.class);
+    final ClientStreamTracer tracer1 = new ClientStreamTracer() {};
+    final ClientStreamTracer tracer2 = new ClientStreamTracer() {};
+    ClientStreamTracer.Factory factory1 = new ClientStreamTracer.Factory() {
+      @Override
+      public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+        return tracer1;
+      }
+    };
+    ClientStreamTracer.Factory factory2 = new ClientStreamTracer.Factory() {
+      @Override
+      public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+        return tracer2;
+      }
+    };
+    createChannel();
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
+    MockClientTransportInfo transportInfo = transports.poll();
+    transportInfo.listener.transportReady();
+    ClientTransport mockTransport = transportInfo.transport;
+    when(mockTransport.newStream(
+            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream);
+
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(
+        PickResult.withSubchannel(subchannel, factory2));
+    updateBalancingStateSafely(helper, READY, mockPicker);
+
+    CallOptions callOptions = CallOptions.DEFAULT.withStreamTracerFactory(factory1);
+    ClientCall<String, Integer> call = channel.newCall(method, callOptions);
+    call.start(mockCallListener, new Metadata());
+
+    verify(mockPicker).pickSubchannel(any(PickSubchannelArgs.class));
+    verify(mockTransport).newStream(
+        same(method), any(Metadata.class), callOptionsCaptor.capture(),
+        tracersCaptor.capture());
+    assertThat(tracersCaptor.getValue()).isEqualTo(new ClientStreamTracer[] {tracer1, tracer2});
+  }
+
+  @Test
+  public void pickerReturnsStreamTracer_delayed() {
+    ClientStream mockStream = mock(ClientStream.class);
+    final ClientStreamTracer tracer1 = new ClientStreamTracer() {};
+    final ClientStreamTracer tracer2 = new ClientStreamTracer() {};
+    ClientStreamTracer.Factory factory1 = new ClientStreamTracer.Factory() {
+      @Override
+      public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+        return tracer1;
+      }
+    };
+    ClientStreamTracer.Factory factory2 = new ClientStreamTracer.Factory() {
+      @Override
+      public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+        return tracer2;
+      }
+    };
+    createChannel();
+
+    CallOptions callOptions = CallOptions.DEFAULT.withStreamTracerFactory(factory1);
+    ClientCall<String, Integer> call = channel.newCall(method, callOptions);
+    call.start(mockCallListener, new Metadata());
+
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
+    MockClientTransportInfo transportInfo = transports.poll();
+    transportInfo.listener.transportReady();
+    ClientTransport mockTransport = transportInfo.transport;
+    when(mockTransport.newStream(
+            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream);
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(
+        PickResult.withSubchannel(subchannel, factory2));
+
+    updateBalancingStateSafely(helper, READY, mockPicker);
+    assertEquals(1, executor.runDueTasks());
+
+    verify(mockPicker).pickSubchannel(any(PickSubchannelArgs.class));
+    verify(mockTransport).newStream(
+        same(method), any(Metadata.class), callOptionsCaptor.capture(),
+        tracersCaptor.capture());
+    assertThat(tracersCaptor.getValue()).isEqualTo(new ClientStreamTracer[] {tracer1, tracer2});
+  }
+
+  @Test
+  public void getState_loadBalancerSupportsChannelState() {
+    channelBuilder.nameResolverFactory(
+        new FakeNameResolverFactory.Builder(expectedUri).setResolvedAtStart(false).build());
+    createChannel();
+    assertEquals(CONNECTING, channel.getState(false));
+
+    updateBalancingStateSafely(helper, TRANSIENT_FAILURE, mockPicker);
+    assertEquals(TRANSIENT_FAILURE, channel.getState(false));
+  }
+
+  @Test
+  public void getState_withRequestConnect() {
+    channelBuilder.nameResolverFactory(
+        new FakeNameResolverFactory.Builder(expectedUri).setResolvedAtStart(false).build());
+    requestConnection = false;
+    createChannel();
+
+    assertEquals(IDLE, channel.getState(false));
+    verify(mockLoadBalancerProvider, never()).newLoadBalancer(any(Helper.class));
+
+    // call getState() with requestConnection = true
+    assertEquals(IDLE, channel.getState(true));
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+    helper = helperCaptor.getValue();
+
+    updateBalancingStateSafely(helper, CONNECTING, mockPicker);
+    assertEquals(CONNECTING, channel.getState(false));
+    assertEquals(CONNECTING, channel.getState(true));
+    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
+  }
+
+  @SuppressWarnings("deprecation")
+  @Test
+  public void getState_withRequestConnect_IdleWithLbRunning() {
+    channelBuilder.nameResolverFactory(
+        new FakeNameResolverFactory.Builder(expectedUri).setResolvedAtStart(false).build());
+    createChannel();
+    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
+
+    updateBalancingStateSafely(helper, IDLE, mockPicker);
+
+    assertEquals(IDLE, channel.getState(true));
+    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
+    verify(mockLoadBalancer).requestConnection();
+  }
+
+  @Test
+  public void notifyWhenStateChanged() {
+    final AtomicBoolean stateChanged = new AtomicBoolean();
+    Runnable onStateChanged = new Runnable() {
+      @Override
+      public void run() {
+        stateChanged.set(true);
+      }
+    };
+
+    channelBuilder.nameResolverFactory(
+        new FakeNameResolverFactory.Builder(expectedUri).setResolvedAtStart(false).build());
+    createChannel();
+    assertEquals(CONNECTING, channel.getState(false));
+
+    channel.notifyWhenStateChanged(CONNECTING, onStateChanged);
+    executor.runDueTasks();
+    assertFalse(stateChanged.get());
+
+    // state change from CONNECTING to IDLE
+    updateBalancingStateSafely(helper, IDLE, mockPicker);
+    // onStateChanged callback should run
+    executor.runDueTasks();
+    assertTrue(stateChanged.get());
+
+    // clear and test form IDLE
+    stateChanged.set(false);
+    channel.notifyWhenStateChanged(CONNECTING, onStateChanged);
+    // onStateChanged callback should run immediately
+    executor.runDueTasks();
+    assertTrue(stateChanged.get());
+  }
+
+  @Test
+  public void channelStateWhenChannelShutdown() {
+    final AtomicBoolean stateChanged = new AtomicBoolean();
+    Runnable onStateChanged = new Runnable() {
+      @Override
+      public void run() {
+        stateChanged.set(true);
+      }
+    };
+
+    channelBuilder.nameResolverFactory(
+        new FakeNameResolverFactory.Builder(expectedUri).setResolvedAtStart(false).build());
+    createChannel();
+    assertEquals(CONNECTING, channel.getState(false));
+    channel.notifyWhenStateChanged(CONNECTING, onStateChanged);
+    executor.runDueTasks();
+    assertFalse(stateChanged.get());
+
+    channel.shutdown();
+    assertEquals(SHUTDOWN, channel.getState(false));
+    executor.runDueTasks();
+    assertTrue(stateChanged.get());
+
+    stateChanged.set(false);
+    channel.notifyWhenStateChanged(SHUTDOWN, onStateChanged);
+    updateBalancingStateSafely(helper, CONNECTING, mockPicker);
+
+    assertEquals(SHUTDOWN, channel.getState(false));
+    executor.runDueTasks();
+    assertFalse(stateChanged.get());
+  }
+
+  @Test
+  public void stateIsIdleOnIdleTimeout() {
+    long idleTimeoutMillis = 2000L;
+    channelBuilder.idleTimeout(idleTimeoutMillis, TimeUnit.MILLISECONDS);
+    createChannel();
+    assertEquals(CONNECTING, channel.getState(false));
+
+    timer.forwardNanos(TimeUnit.MILLISECONDS.toNanos(idleTimeoutMillis));
+    assertEquals(IDLE, channel.getState(false));
+  }
+
+  @Test
+  public void panic_whenIdle() {
+    subtestPanic(IDLE);
+  }
+
+  @Test
+  public void panic_whenConnecting() {
+    subtestPanic(CONNECTING);
+  }
+
+  @Test
+  public void panic_whenTransientFailure() {
+    subtestPanic(TRANSIENT_FAILURE);
+  }
+
+  @Test
+  public void panic_whenReady() {
+    subtestPanic(READY);
+  }
+
+  private void subtestPanic(ConnectivityState initialState) {
+    assertNotEquals("We don't test panic mode if it's already SHUTDOWN", SHUTDOWN, initialState);
+    long idleTimeoutMillis = 2000L;
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    channelBuilder.idleTimeout(idleTimeoutMillis, TimeUnit.MILLISECONDS);
+    createChannel();
+
+    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
+    assertThat(nameResolverFactory.resolvers).hasSize(1);
+    FakeNameResolverFactory.FakeNameResolver resolver = nameResolverFactory.resolvers.remove(0);
+
+    final Throwable panicReason = new Exception("Simulated uncaught exception");
+    if (initialState == IDLE) {
+      timer.forwardNanos(TimeUnit.MILLISECONDS.toNanos(idleTimeoutMillis));
+    } else {
+      updateBalancingStateSafely(helper, initialState, mockPicker);
+    }
+    assertEquals(initialState, channel.getState(false));
+
+    if (initialState == IDLE) {
+      // IDLE mode will shutdown resolver and balancer
+      verify(mockLoadBalancer).shutdown();
+      assertTrue(resolver.shutdown);
+      // A new resolver is created
+      assertThat(nameResolverFactory.resolvers).hasSize(1);
+      resolver = nameResolverFactory.resolvers.remove(0);
+      assertFalse(resolver.shutdown);
+    } else {
+      verify(mockLoadBalancer, never()).shutdown();
+      assertFalse(resolver.shutdown);
+    }
+
+    // Make channel panic!
+    channel.syncContext.execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            channel.panic(panicReason);
+          }
+        });
+
+    // Calls buffered in delayedTransport will fail
+
+    // Resolver and balancer are shutdown
+    verify(mockLoadBalancer).shutdown();
+    assertTrue(resolver.shutdown);
+
+    // Channel will stay in TRANSIENT_FAILURE. getState(true) will not revive it.
+    assertEquals(TRANSIENT_FAILURE, channel.getState(true));
+    assertEquals(TRANSIENT_FAILURE, channel.getState(true));
+    verifyPanicMode(panicReason);
+
+    // Besides the resolver created initially, no new resolver or balancer are created.
+    verify(mockLoadBalancerProvider).newLoadBalancer(any(Helper.class));
+    assertThat(nameResolverFactory.resolvers).isEmpty();
+
+    // A misbehaving balancer that calls updateBalancingState() after it's shut down will not be
+    // able to revive it.
+    updateBalancingStateSafely(helper, READY, mockPicker);
+    verifyPanicMode(panicReason);
+
+    // Cannot be revived by exitIdleMode()
+    channel.syncContext.execute(new Runnable() {
+        @Override
+        public void run() {
+          channel.exitIdleMode();
+        }
+      });
+    verifyPanicMode(panicReason);
+
+    // Can still shutdown normally
+    channel.shutdown();
+    assertTrue(channel.isShutdown());
+    assertTrue(channel.isTerminated());
+    assertEquals(SHUTDOWN, channel.getState(false));
+
+    // We didn't stub mockPicker, because it should have never been called in this test.
+    verifyNoInteractions(mockPicker);
+  }
+
+  @Test
+  public void panic_bufferedCallsWillFail() {
+    createChannel();
+
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withNoResult());
+    updateBalancingStateSafely(helper, CONNECTING, mockPicker);
+
+    // Start RPCs that will be buffered in delayedTransport
+    ClientCall<String, Integer> call =
+        channel.newCall(method, CallOptions.DEFAULT.withoutWaitForReady());
+    call.start(mockCallListener, new Metadata());
+
+    ClientCall<String, Integer> call2 =
+        channel.newCall(method, CallOptions.DEFAULT.withWaitForReady());
+    call2.start(mockCallListener2, new Metadata());
+
+    executor.runDueTasks();
+    verifyNoInteractions(mockCallListener, mockCallListener2);
+
+    // Enter panic
+    final Throwable panicReason = new Exception("Simulated uncaught exception");
+    channel.syncContext.execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            channel.panic(panicReason);
+          }
+        });
+
+    // Buffered RPCs fail immediately
+    executor.runDueTasks();
+    verifyCallListenerClosed(mockCallListener, Status.Code.INTERNAL, panicReason);
+    verifyCallListenerClosed(mockCallListener2, Status.Code.INTERNAL, panicReason);
+    panicExpected = true;
+  }
+
+  @Test
+  public void panic_atStart() {
+    final RuntimeException panicReason = new RuntimeException("Simulated NR exception");
+    final NameResolver failingResolver = new NameResolver() {
+      @Override public String getServiceAuthority() {
+        return "fake-authority";
+      }
+
+      @Override public void start(Listener2 listener) {
+        throw panicReason;
+      }
+
+      @Override public void shutdown() {}
+    };
+    channelBuilder.nameResolverFactory(new NameResolver.Factory() {
+      @Override public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+        return failingResolver;
+      }
+
+      @Override public String getDefaultScheme() {
+        return "fake";
+      }
+    });
+    createChannel();
+
+    // RPCs fail immediately
+    ClientCall<String, Integer> call =
+        channel.newCall(method, CallOptions.DEFAULT.withoutWaitForReady());
+    call.start(mockCallListener, new Metadata());
+    executor.runDueTasks();
+    verifyCallListenerClosed(mockCallListener, Status.Code.INTERNAL, panicReason);
+    panicExpected = true;
+  }
+
+  private void verifyPanicMode(Throwable cause) {
+    panicExpected = true;
+    @SuppressWarnings("unchecked")
+    ClientCall.Listener<Integer> mockListener =
+        (ClientCall.Listener<Integer>) mock(ClientCall.Listener.class);
+    assertEquals(TRANSIENT_FAILURE, channel.getState(false));
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockListener, new Metadata());
+    executor.runDueTasks();
+    verifyCallListenerClosed(mockListener, Status.Code.INTERNAL, cause);
+
+    // Channel is dead.  No more pending task to possibly revive it.
+    assertEquals(0, timer.numPendingTasks());
+    assertEquals(0, executor.numPendingTasks());
+    assertEquals(0, balancerRpcExecutor.numPendingTasks());
+  }
+
+  private void verifyCallListenerClosed(
+      ClientCall.Listener<Integer> listener, Status.Code code, Throwable cause) {
+    ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
+    verify(listener).onClose(captor.capture(), any(Metadata.class));
+    Status rpcStatus = captor.getValue();
+    assertEquals(code, rpcStatus.getCode());
+    assertSame(cause, rpcStatus.getCause());
+    verifyNoMoreInteractions(listener);
+  }
+
+  @Test
+  public void idleTimeoutAndReconnect() {
+    long idleTimeoutMillis = 2000L;
+    channelBuilder.idleTimeout(idleTimeoutMillis, TimeUnit.MILLISECONDS);
+    createChannel();
+
+    timer.forwardNanos(TimeUnit.MILLISECONDS.toNanos(idleTimeoutMillis));
+    assertEquals(IDLE, channel.getState(true /* request connection */));
+
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    // Two times of requesting connection will create loadBalancer twice.
+    verify(mockLoadBalancerProvider, times(2)).newLoadBalancer(helperCaptor.capture());
+    Helper helper2 = helperCaptor.getValue();
+
+    // Updating on the old helper (whose balancer has been shutdown) does not change the channel
+    // state.
+    updateBalancingStateSafely(helper, IDLE, mockPicker);
+    assertEquals(CONNECTING, channel.getState(false));
+
+    updateBalancingStateSafely(helper2, IDLE, mockPicker);
+    assertEquals(IDLE, channel.getState(false));
+  }
+
+  @Test
+  public void idleMode_resetsDelayedTransportPicker() {
+    ClientStream mockStream = mock(ClientStream.class);
+    Status pickError = Status.UNAVAILABLE.withDescription("pick result error");
+    long idleTimeoutMillis = 1000L;
+    channelBuilder.idleTimeout(idleTimeoutMillis, TimeUnit.MILLISECONDS);
+    channelBuilder.nameResolverFactory(
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+            .build());
+    createChannel();
+    assertEquals(CONNECTING, channel.getState(false));
+
+    // This call will be buffered in delayedTransport
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
+
+    // Move channel into TRANSIENT_FAILURE, which will fail the pending call
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withError(pickError));
+    updateBalancingStateSafely(helper, TRANSIENT_FAILURE, mockPicker);
+    assertEquals(TRANSIENT_FAILURE, channel.getState(false));
+    executor.runDueTasks();
+    verify(mockCallListener).onClose(same(pickError), any(Metadata.class));
+
+    // Move channel to idle
+    timer.forwardNanos(TimeUnit.MILLISECONDS.toNanos(idleTimeoutMillis));
+    assertEquals(IDLE, channel.getState(false));
+
+    // This call should be buffered, but will move the channel out of idle
+    ClientCall<String, Integer> call2 = channel.newCall(method, CallOptions.DEFAULT);
+    call2.start(mockCallListener2, new Metadata());
+    executor.runDueTasks();
+    verifyNoMoreInteractions(mockCallListener2);
+
+    // Get the helper created on exiting idle
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider, times(2)).newLoadBalancer(helperCaptor.capture());
+    Helper helper2 = helperCaptor.getValue();
+
+    // Establish a connection
+    Subchannel subchannel =
+        createSubchannelSafely(helper2, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
+    MockClientTransportInfo transportInfo = transports.poll();
+    ConnectionClientTransport mockTransport = transportInfo.transport;
+    ManagedClientTransport.Listener transportListener = transportInfo.listener;
+    when(mockTransport.newStream(
+            same(method), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream);
+    transportListener.transportReady();
+
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(subchannel));
+    updateBalancingStateSafely(helper2, READY, mockPicker);
+    assertEquals(READY, channel.getState(false));
+    executor.runDueTasks();
+
+    // Verify the buffered call was drained
+    verify(mockTransport).newStream(
+        same(method), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    verify(mockStream).start(any(ClientStreamListener.class));
+  }
+
+  @Test
+  public void enterIdleEntersIdle() {
+    createChannel();
+    updateBalancingStateSafely(helper, READY, mockPicker);
+    assertEquals(READY, channel.getState(false));
+
+    channel.enterIdle();
+
+    assertEquals(IDLE, channel.getState(false));
+  }
+
+  @Test
+  public void enterIdleAfterIdleTimerIsNoOp() {
+    long idleTimeoutMillis = 2000L;
+    channelBuilder.idleTimeout(idleTimeoutMillis, TimeUnit.MILLISECONDS);
+    createChannel();
+    timer.forwardNanos(TimeUnit.MILLISECONDS.toNanos(idleTimeoutMillis));
+    assertEquals(IDLE, channel.getState(false));
+
+    channel.enterIdle();
+
+    assertEquals(IDLE, channel.getState(false));
+  }
+
+  @Test
+  public void enterIdle_exitsIdleIfDelayedStreamPending() {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel();
+
+    // Start a call that will be buffered in delayedTransport
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
+
+    // enterIdle() will shut down the name resolver and lb policy used to get a pick for the delayed
+    // call
+    channel.enterIdle();
+    assertEquals(CONNECTING, channel.getState(false));
+
+    // enterIdle() will restart the delayed call by exiting idle. This creates a new helper.
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider, times(2)).newLoadBalancer(helperCaptor.capture());
+    Helper helper2 = helperCaptor.getValue();
+
+    // Establish a connection
+    Subchannel subchannel =
+        createSubchannelSafely(helper2, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
+    ClientStream mockStream = mock(ClientStream.class);
+    MockClientTransportInfo transportInfo = transports.poll();
+    ConnectionClientTransport mockTransport = transportInfo.transport;
+    ManagedClientTransport.Listener transportListener = transportInfo.listener;
+    when(mockTransport.newStream(
+            same(method), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream);
+    transportListener.transportReady();
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(subchannel));
+    updateBalancingStateSafely(helper2, READY, mockPicker);
+    assertEquals(READY, channel.getState(false));
+
+    // Verify the original call was drained
+    executor.runDueTasks();
+    verify(mockTransport).newStream(
+        same(method), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    verify(mockStream).start(any(ClientStreamListener.class));
+  }
+
+  @Test
+  public void updateBalancingStateDoesUpdatePicker() {
+    ClientStream mockStream = mock(ClientStream.class);
+    createChannel();
+
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
+
+    // Make the transport available with subchannel2
+    Subchannel subchannel1 =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    Subchannel subchannel2 =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel2);
+
+    MockClientTransportInfo transportInfo = transports.poll();
+    ConnectionClientTransport mockTransport = transportInfo.transport;
+    ManagedClientTransport.Listener transportListener = transportInfo.listener;
+    when(mockTransport.newStream(
+            same(method), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream);
+    transportListener.transportReady();
+
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(subchannel1));
+    updateBalancingStateSafely(helper, READY, mockPicker);
+
+    executor.runDueTasks();
+    verify(mockTransport, never()).newStream(
+        any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    verify(mockStream, never()).start(any(ClientStreamListener.class));
+
+
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(subchannel2));
+    updateBalancingStateSafely(helper, READY, mockPicker);
+
+    executor.runDueTasks();
+    verify(mockTransport).newStream(
+        same(method), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    verify(mockStream).start(any(ClientStreamListener.class));
+  }
+
+  @Test
+  public void updateBalancingState_withWrappedSubchannel() {
+    ClientStream mockStream = mock(ClientStream.class);
+    createChannel();
+
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
+
+    final Subchannel subchannel1 =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel1);
+
+    MockClientTransportInfo transportInfo = transports.poll();
+    ConnectionClientTransport mockTransport = transportInfo.transport;
+    ManagedClientTransport.Listener transportListener = transportInfo.listener;
+    when(mockTransport.newStream(
+            same(method), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream);
+    transportListener.transportReady();
+
+    Subchannel wrappedSubchannel1 = new ForwardingSubchannel() {
+        @Override
+        protected Subchannel delegate() {
+          return subchannel1;
+        }
+      };
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(wrappedSubchannel1));
+    updateBalancingStateSafely(helper, READY, mockPicker);
+
+    executor.runDueTasks();
+    verify(mockTransport).newStream(
+        same(method), any(Metadata.class), any(CallOptions.class),
+        ArgumentMatchers.<ClientStreamTracer[]>any());
+    verify(mockStream).start(any(ClientStreamListener.class));
+  }
+
+  @Test
+  public void updateBalancingStateWithShutdownShouldBeIgnored() {
+    channelBuilder.nameResolverFactory(
+        new FakeNameResolverFactory.Builder(expectedUri).setResolvedAtStart(false).build());
+    createChannel();
+    assertEquals(CONNECTING, channel.getState(false));
+
+    Runnable onStateChanged = mock(Runnable.class);
+    channel.notifyWhenStateChanged(CONNECTING, onStateChanged);
+
+    updateBalancingStateSafely(helper, SHUTDOWN, mockPicker);
+
+    assertEquals(CONNECTING, channel.getState(false));
+    executor.runDueTasks();
+    verify(onStateChanged, never()).run();
+  }
+
+  @Test
+  public void balancerRefreshNameResolution() {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel();
+
+    FakeNameResolverFactory.FakeNameResolver resolver = nameResolverFactory.resolvers.get(0);
+    int initialRefreshCount = resolver.refreshCalled;
+    refreshNameResolutionSafely(helper);
+    assertEquals(initialRefreshCount + 1, resolver.refreshCalled);
+  }
+
+  @Test
+  public void resetConnectBackoff_noOpWhenChannelShutdown() {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel();
+
+    channel.shutdown();
+    assertTrue(channel.isShutdown());
+    channel.resetConnectBackoff();
+
+    FakeNameResolverFactory.FakeNameResolver nameResolver = nameResolverFactory.resolvers.get(0);
+    assertEquals(0, nameResolver.refreshCalled);
+  }
+
+  @Test
+  public void resetConnectBackoff_noOpWhenNameResolverNotStarted() {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    requestConnection = false;
+    createChannel();
+
+    channel.resetConnectBackoff();
+
+    FakeNameResolverFactory.FakeNameResolver nameResolver = nameResolverFactory.resolvers.get(0);
+    assertEquals(0, nameResolver.refreshCalled);
+  }
+
+  @Test
+  public void channelsAndSubchannels_instrumented_name() throws Exception {
+    createChannel();
+    assertEquals(TARGET, getStats(channel).target);
+
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    assertEquals(Collections.singletonList(addressGroup).toString(),
+        getStats((AbstractSubchannel) subchannel).target);
+  }
+
+  @Test
+  public void channelTracing_channelCreationEvent() throws Exception {
+    timer.forwardNanos(1234);
+    channelBuilder.maxTraceEvents(10);
+    createChannel();
+    assertThat(getStats(channel).channelTrace.events).contains(new ChannelTrace.Event.Builder()
+        .setDescription("Channel for 'fake://fake.example.com' created")
+        .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+        .setTimestampNanos(timer.getTicker().read())
+        .build());
+  }
+
+  @Test
+  public void channelTracing_subchannelCreationEvents() throws Exception {
+    channelBuilder.maxTraceEvents(10);
+    createChannel();
+    timer.forwardNanos(1234);
+    AbstractSubchannel subchannel =
+        (AbstractSubchannel) createSubchannelSafely(
+            helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    assertThat(getStats(channel).channelTrace.events).contains(new ChannelTrace.Event.Builder()
+        .setDescription("Child Subchannel started")
+        .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+        .setTimestampNanos(timer.getTicker().read())
+        .setSubchannelRef(subchannel.getInstrumentedInternalSubchannel())
+        .build());
+    assertThat(getStats(subchannel).channelTrace.events).contains(new ChannelTrace.Event.Builder()
+        .setDescription("Subchannel for [[[test-addr]/{}]] created")
+        .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+        .setTimestampNanos(timer.getTicker().read())
+        .build());
+  }
+
+  @Test
+  public void channelTracing_nameResolvingErrorEvent() throws Exception {
+    timer.forwardNanos(1234);
+    channelBuilder.maxTraceEvents(10);
+
+    Status error = Status.UNAVAILABLE.withDescription("simulated error");
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri).setError(error).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel(true);
+
+    assertThat(getStats(channel).channelTrace.events).contains(new ChannelTrace.Event.Builder()
+        .setDescription("Failed to resolve name: " + error)
+        .setSeverity(ChannelTrace.Event.Severity.CT_WARNING)
+        .setTimestampNanos(timer.getTicker().read())
+        .build());
+  }
+
+  @Test
+  public void channelTracing_nameResolvedEvent() throws Exception {
+    timer.forwardNanos(1234);
+    channelBuilder.maxTraceEvents(10);
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel();
+    assertThat(getStats(channel).channelTrace.events).contains(new ChannelTrace.Event.Builder()
+        .setDescription("Address resolved: "
+            + Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+        .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+        .setTimestampNanos(timer.getTicker().read())
+        .build());
+  }
+
+  @Test
+  public void channelTracing_nameResolvedEvent_zeorAndNonzeroBackends() throws Exception {
+    timer.forwardNanos(1234);
+    channelBuilder.maxTraceEvents(10);
+    List<EquivalentAddressGroup> servers = new ArrayList<>();
+    servers.add(new EquivalentAddressGroup(socketAddress));
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri).setServers(servers).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel();
+
+    int prevSize = getStats(channel).channelTrace.events.size();
+    ResolutionResult resolutionResult1 = ResolutionResult.newBuilder()
+        .setAddresses(Collections.singletonList(
+            new EquivalentAddressGroup(
+                Arrays.asList(new SocketAddress() {}, new SocketAddress() {}))))
+        .build();
+    nameResolverFactory.resolvers.get(0).listener.onResult(resolutionResult1);
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize);
+
+    prevSize = getStats(channel).channelTrace.events.size();
+    nameResolverFactory.resolvers.get(0).listener.onError(Status.INTERNAL);
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize + 1);
+
+    prevSize = getStats(channel).channelTrace.events.size();
+    nameResolverFactory.resolvers.get(0).listener.onError(Status.INTERNAL);
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize);
+
+    prevSize = getStats(channel).channelTrace.events.size();
+    ResolutionResult resolutionResult2 = ResolutionResult.newBuilder()
+        .setAddresses(Collections.singletonList(
+            new EquivalentAddressGroup(
+              Arrays.asList(new SocketAddress() {}, new SocketAddress() {}))))
+        .build();
+    nameResolverFactory.resolvers.get(0).listener.onResult(resolutionResult2);
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize + 1);
+  }
+
+  @Test
+  public void channelTracing_nameResolvedEvent_zeorAndNonzeroBackends_usesListener2onResult2()
+      throws Exception {
+    timer.forwardNanos(1234);
+    channelBuilder.maxTraceEvents(10);
+    List<EquivalentAddressGroup> servers = new ArrayList<>();
+    servers.add(new EquivalentAddressGroup(socketAddress));
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri).setServers(servers).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel();
+
+    int prevSize = getStats(channel).channelTrace.events.size();
+    ResolutionResult resolutionResult1 = ResolutionResult.newBuilder()
+        .setAddresses(Collections.singletonList(
+            new EquivalentAddressGroup(
+                Arrays.asList(new SocketAddress() {}, new SocketAddress() {}))))
+        .build();
+
+    channel.syncContext.execute(
+        () -> nameResolverFactory.resolvers.get(0).listener.onResult2(resolutionResult1));
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize);
+
+    prevSize = getStats(channel).channelTrace.events.size();
+    channel.syncContext.execute(() ->
+        nameResolverFactory.resolvers.get(0).listener.onResult2(
+            ResolutionResult.newBuilder()
+              .setAddressesOrError(
+                  StatusOr.fromStatus(Status.INTERNAL)).build()));
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize + 1);
+
+    prevSize = getStats(channel).channelTrace.events.size();
+    channel.syncContext.execute(() ->
+        nameResolverFactory.resolvers.get(0).listener.onResult2(
+            ResolutionResult.newBuilder()
+                .setAddressesOrError(
+                    StatusOr.fromStatus(Status.INTERNAL)).build()));
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize);
+
+    prevSize = getStats(channel).channelTrace.events.size();
+    ResolutionResult resolutionResult2 = ResolutionResult.newBuilder()
+        .setAddresses(Collections.singletonList(
+            new EquivalentAddressGroup(
+                Arrays.asList(new SocketAddress() {}, new SocketAddress() {}))))
+        .build();
+    channel.syncContext.execute(
+        () -> nameResolverFactory.resolvers.get(0).listener.onResult2(resolutionResult2));
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize + 1);
+  }
+
+  @Test
+  public void channelTracing_serviceConfigChange() throws Exception {
+    timer.forwardNanos(1234);
+    channelBuilder.maxTraceEvents(10);
+    List<EquivalentAddressGroup> servers = new ArrayList<>();
+    servers.add(new EquivalentAddressGroup(socketAddress));
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri).setServers(servers).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel();
+
+    int prevSize = getStats(channel).channelTrace.events.size();
+    ManagedChannelServiceConfig mcsc1 = createManagedChannelServiceConfig(
+        ImmutableMap.<String, Object>of(),
+        new PolicySelection(
+            mockLoadBalancerProvider, null));
+    ResolutionResult resolutionResult1 = ResolutionResult.newBuilder()
+        .setAddresses(Collections.singletonList(
+            new EquivalentAddressGroup(
+                Arrays.asList(new SocketAddress() {}, new SocketAddress() {}))))
+        .setServiceConfig(ConfigOrError.fromConfig(mcsc1))
+        .build();
+    nameResolverFactory.resolvers.get(0).listener.onResult(resolutionResult1);
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize + 1);
+    assertThat(getStats(channel).channelTrace.events.get(prevSize))
+        .isEqualTo(new ChannelTrace.Event.Builder()
+            .setDescription("Service config changed")
+            .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+            .setTimestampNanos(timer.getTicker().read())
+            .build());
+
+    prevSize = getStats(channel).channelTrace.events.size();
+    ResolutionResult resolutionResult2 = ResolutionResult.newBuilder().setAddresses(
+        Collections.singletonList(
+            new EquivalentAddressGroup(
+                Arrays.asList(new SocketAddress() {}, new SocketAddress() {}))))
+        .setServiceConfig(ConfigOrError.fromConfig(mcsc1))
+        .build();
+    nameResolverFactory.resolvers.get(0).listener.onResult(resolutionResult2);
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize);
+
+    prevSize = getStats(channel).channelTrace.events.size();
+    timer.forwardNanos(1234);
+    ResolutionResult resolutionResult3 = ResolutionResult.newBuilder()
+        .setAddresses(Collections.singletonList(
+            new EquivalentAddressGroup(
+                Arrays.asList(new SocketAddress() {}, new SocketAddress() {}))))
+        .setServiceConfig(ConfigOrError.fromConfig(ManagedChannelServiceConfig.empty()))
+        .build();
+    nameResolverFactory.resolvers.get(0).listener.onResult(resolutionResult3);
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize + 1);
+    assertThat(getStats(channel).channelTrace.events.get(prevSize))
+        .isEqualTo(new ChannelTrace.Event.Builder()
+            .setDescription("Service config changed")
+            .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+            .setTimestampNanos(timer.getTicker().read())
+            .build());
+  }
+
+  @Test
+  public void channelTracing_serviceConfigChange_usesListener2OnResult2() throws Exception {
+    timer.forwardNanos(1234);
+    channelBuilder.maxTraceEvents(10);
+    List<EquivalentAddressGroup> servers = new ArrayList<>();
+    servers.add(new EquivalentAddressGroup(socketAddress));
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri).setServers(servers).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    createChannel();
+
+    int prevSize = getStats(channel).channelTrace.events.size();
+    ManagedChannelServiceConfig mcsc1 = createManagedChannelServiceConfig(
+        ImmutableMap.<String, Object>of(),
+        new PolicySelection(
+            mockLoadBalancerProvider, null));
+    ResolutionResult resolutionResult1 = ResolutionResult.newBuilder()
+        .setAddresses(Collections.singletonList(
+            new EquivalentAddressGroup(
+                Arrays.asList(new SocketAddress() {}, new SocketAddress() {}))))
+        .setServiceConfig(ConfigOrError.fromConfig(mcsc1))
+        .build();
+
+    channel.syncContext.execute(() ->
+        nameResolverFactory.resolvers.get(0).listener.onResult2(resolutionResult1));
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize + 1);
+    assertThat(getStats(channel).channelTrace.events.get(prevSize))
+        .isEqualTo(new ChannelTrace.Event.Builder()
+            .setDescription("Service config changed")
+            .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+            .setTimestampNanos(timer.getTicker().read())
+            .build());
+
+    prevSize = getStats(channel).channelTrace.events.size();
+    ResolutionResult resolutionResult2 = ResolutionResult.newBuilder().setAddresses(
+            Collections.singletonList(
+                new EquivalentAddressGroup(
+                    Arrays.asList(new SocketAddress() {}, new SocketAddress() {}))))
+        .setServiceConfig(ConfigOrError.fromConfig(mcsc1))
+        .build();
+    channel.syncContext.execute(() ->
+        nameResolverFactory.resolvers.get(0).listener.onResult(resolutionResult2));
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize);
+
+    prevSize = getStats(channel).channelTrace.events.size();
+    timer.forwardNanos(1234);
+    ResolutionResult resolutionResult3 = ResolutionResult.newBuilder()
+        .setAddresses(Collections.singletonList(
+            new EquivalentAddressGroup(
+                Arrays.asList(new SocketAddress() {}, new SocketAddress() {}))))
+        .setServiceConfig(ConfigOrError.fromConfig(ManagedChannelServiceConfig.empty()))
+        .build();
+    channel.syncContext.execute(() ->
+        nameResolverFactory.resolvers.get(0).listener.onResult(resolutionResult3));
+    assertThat(getStats(channel).channelTrace.events).hasSize(prevSize + 1);
+    assertThat(getStats(channel).channelTrace.events.get(prevSize))
+        .isEqualTo(new ChannelTrace.Event.Builder()
+            .setDescription("Service config changed")
+            .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+            .setTimestampNanos(timer.getTicker().read())
+            .build());
+  }
+
+  @Test
+  public void channelTracing_stateChangeEvent() throws Exception {
+    channelBuilder.maxTraceEvents(10);
+    createChannel();
+    timer.forwardNanos(1234);
+    updateBalancingStateSafely(helper, CONNECTING, mockPicker);
+    assertThat(getStats(channel).channelTrace.events).contains(new ChannelTrace.Event.Builder()
+        .setDescription("Entering CONNECTING state with picker: mockPicker")
+        .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+        .setTimestampNanos(timer.getTicker().read())
+        .build());
+  }
+
+  @Test
+  public void channelTracing_subchannelStateChangeEvent() throws Exception {
+    channelBuilder.maxTraceEvents(10);
+    createChannel();
+    AbstractSubchannel subchannel =
+        (AbstractSubchannel) createSubchannelSafely(
+            helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    timer.forwardNanos(1234);
+    ((TransportProvider) subchannel.getInternalSubchannel()).obtainActiveTransport();
+    assertThat(getStats(subchannel).channelTrace.events).contains(new ChannelTrace.Event.Builder()
+        .setDescription("CONNECTING as requested")
+        .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+        .setTimestampNanos(timer.getTicker().read())
+        .build());
+  }
+
+  @Test
+  public void channelsAndSubchannels_instrumented_state() throws Exception {
+    createChannel();
+
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+    helper = helperCaptor.getValue();
+
+    assertEquals(CONNECTING, getStats(channel).state);
+
+    AbstractSubchannel subchannel =
+        (AbstractSubchannel) createSubchannelSafely(
+            helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+
+    assertEquals(IDLE, getStats(subchannel).state);
+    requestConnectionSafely(helper, subchannel);
+    assertEquals(CONNECTING, getStats(subchannel).state);
+
+    MockClientTransportInfo transportInfo = transports.poll();
+
+    assertEquals(CONNECTING, getStats(subchannel).state);
+    transportInfo.listener.transportReady();
+    assertEquals(READY, getStats(subchannel).state);
+
+    assertEquals(CONNECTING, getStats(channel).state);
+    updateBalancingStateSafely(helper, READY, mockPicker);
+    assertEquals(READY, getStats(channel).state);
+
+    channel.shutdownNow();
+    assertEquals(SHUTDOWN, getStats(channel).state);
+    assertEquals(SHUTDOWN, getStats(subchannel).state);
+  }
+
+  @Test
+  public void channelStat_callStarted() throws Exception {
+    createChannel();
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    assertEquals(0, getStats(channel).callsStarted);
+    call.start(mockCallListener, new Metadata());
+    assertEquals(1, getStats(channel).callsStarted);
+    assertEquals(executor.getTicker().read(), getStats(channel).lastCallStartedNanos);
+  }
+
+  @Test
+  public void channelsAndSubChannels_instrumented_success() throws Exception {
+    channelsAndSubchannels_instrumented0(true);
+  }
+
+  @Test
+  public void channelsAndSubChannels_instrumented_fail() throws Exception {
+    channelsAndSubchannels_instrumented0(false);
+  }
+
+  private void channelsAndSubchannels_instrumented0(boolean success) throws Exception {
+    createChannel();
+
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+
+    // Channel stat bumped when ClientCall.start() called
+    assertEquals(0, getStats(channel).callsStarted);
+    call.start(mockCallListener, new Metadata());
+    assertEquals(1, getStats(channel).callsStarted);
+
+    ClientStream mockStream = mock(ClientStream.class);
+    ClientStreamTracer.Factory factory = mock(ClientStreamTracer.Factory.class);
+    AbstractSubchannel subchannel =
+        (AbstractSubchannel) createSubchannelSafely(
+            helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
+    MockClientTransportInfo transportInfo = transports.poll();
+    transportInfo.listener.transportReady();
+    ClientTransport mockTransport = transportInfo.transport;
+    when(mockTransport.newStream(
+            any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream);
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class))).thenReturn(
+        PickResult.withSubchannel(subchannel, factory));
+
+    // subchannel stat bumped when call gets assigned to it
+    assertEquals(0, getStats(subchannel).callsStarted);
+    updateBalancingStateSafely(helper, READY, mockPicker);
+    assertEquals(1, executor.runDueTasks());
+    verify(mockStream).start(streamListenerCaptor.capture());
+    assertEquals(1, getStats(subchannel).callsStarted);
+
+    ClientStreamListener streamListener = streamListenerCaptor.getValue();
+    call.halfClose();
+
+    // closing stream listener affects subchannel stats immediately
+    assertEquals(0, getStats(subchannel).callsSucceeded);
+    assertEquals(0, getStats(subchannel).callsFailed);
+    streamListener.closed(
+        success ? Status.OK : Status.UNKNOWN, PROCESSED, new Metadata());
+    if (success) {
+      assertEquals(1, getStats(subchannel).callsSucceeded);
+      assertEquals(0, getStats(subchannel).callsFailed);
+    } else {
+      assertEquals(0, getStats(subchannel).callsSucceeded);
+      assertEquals(1, getStats(subchannel).callsFailed);
+    }
+
+    // channel stats bumped when the ClientCall.Listener is notified
+    assertEquals(0, getStats(channel).callsSucceeded);
+    assertEquals(0, getStats(channel).callsFailed);
+    executor.runDueTasks();
+    if (success) {
+      assertEquals(1, getStats(channel).callsSucceeded);
+      assertEquals(0, getStats(channel).callsFailed);
+    } else {
+      assertEquals(0, getStats(channel).callsSucceeded);
+      assertEquals(1, getStats(channel).callsFailed);
+    }
+  }
+
+  @Test
+  public void binaryLogInstalled() throws Exception {
+    final SettableFuture<Boolean> intercepted = SettableFuture.create();
+    channelBuilder.binlog = new BinaryLog() {
+      @Override
+      public void close() throws IOException {
+        // noop
+      }
+
+      @Override
+      public <ReqT, RespT> ServerMethodDefinition<?, ?> wrapMethodDefinition(
+          ServerMethodDefinition<ReqT, RespT> oMethodDef) {
+        return oMethodDef;
+      }
+
+      @Override
+      public Channel wrapChannel(Channel channel) {
+        return ClientInterceptors.intercept(channel,
+            new ClientInterceptor() {
+              @Override
+              public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+                  MethodDescriptor<ReqT, RespT> method,
+                  CallOptions callOptions,
+                  Channel next) {
+                intercepted.set(true);
+                return next.newCall(method, callOptions);
+              }
+            });
+      }
+    };
+
+    createChannel();
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
+    assertTrue(intercepted.get());
+  }
+
+  @Test
+  public void retryBackoffThenChannelShutdown_retryShouldStillHappen_newCallShouldFail() {
+    Map<String, Object> retryPolicy = new HashMap<>();
+    retryPolicy.put("maxAttempts", 3D);
+    retryPolicy.put("initialBackoff", "10s");
+    retryPolicy.put("maxBackoff", "30s");
+    retryPolicy.put("backoffMultiplier", 2D);
+    retryPolicy.put("retryableStatusCodes", Arrays.<Object>asList("UNAVAILABLE"));
+    Map<String, Object> methodConfig = new HashMap<>();
+    Map<String, Object> name = new HashMap<>();
+    name.put("service", "service");
+    methodConfig.put("name", Arrays.<Object>asList(name));
+    methodConfig.put("retryPolicy", retryPolicy);
+    Map<String, Object> rawServiceConfig = new HashMap<>();
+    rawServiceConfig.put("methodConfig", Arrays.<Object>asList(methodConfig));
+
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+            .build();
+    ManagedChannelServiceConfig managedChannelServiceConfig =
+        createManagedChannelServiceConfig(rawServiceConfig, null);
+    nameResolverFactory.nextConfigOrError.set(
+        ConfigOrError.fromConfig(managedChannelServiceConfig));
+
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    channelBuilder.executor(MoreExecutors.directExecutor());
+    channelBuilder.enableRetry();
+    RetriableStream.setRandom(
+        // not random
+        new Random() {
+          @Override
+          public double nextDouble() {
+            return 1D; // fake random
+          }
+        });
+
+    requestConnection = false;
+    createChannel();
+
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+    helper = helperCaptor.getValue();
+    verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
+    ResolvedAddresses resolvedAddresses = resolvedAddressCaptor.getValue();
+    assertThat(resolvedAddresses.getAddresses()).isEqualTo(nameResolverFactory.servers);
+
+    // simulating request connection and then transport ready after resolved address
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(subchannel));
+    requestConnectionSafely(helper, subchannel);
+    MockClientTransportInfo transportInfo = transports.poll();
+    ConnectionClientTransport mockTransport = transportInfo.transport;
+    ClientStream mockStream = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    when(mockTransport.newStream(
+            same(method), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream).thenReturn(mockStream2);
+    transportInfo.listener.transportReady();
+    updateBalancingStateSafely(helper, READY, mockPicker);
+
+    ArgumentCaptor<ClientStreamListener> streamListenerCaptor =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream).start(streamListenerCaptor.capture());
+    assertThat(timer.getPendingTasks()).isEmpty();
+
+    // trigger retry
+    streamListenerCaptor.getValue().closed(
+        Status.UNAVAILABLE, PROCESSED, new Metadata());
+
+    // in backoff
+    timer.forwardTime(6, TimeUnit.SECONDS);
+    assertThat(timer.getPendingTasks()).hasSize(1);
+    verify(mockStream2, never()).start(any(ClientStreamListener.class));
+
+    // shutdown during backoff period
+    channel.shutdown();
+
+    assertThat(timer.getPendingTasks()).hasSize(1);
+    verify(mockCallListener, never()).onClose(any(Status.class), any(Metadata.class));
+
+    ClientCall<String, Integer> call2 = channel.newCall(method, CallOptions.DEFAULT);
+    call2.start(mockCallListener2, new Metadata());
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockCallListener2).onClose(statusCaptor.capture(), any(Metadata.class));
+    assertSame(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
+    assertEquals("Channel shutdown invoked", statusCaptor.getValue().getDescription());
+
+    // backoff ends
+    timer.forwardTime(6, TimeUnit.SECONDS);
+    assertThat(timer.getPendingTasks()).isEmpty();
+    verify(mockStream2).start(streamListenerCaptor.capture());
+    verify(mockLoadBalancer, never()).shutdown();
+    assertFalse(
+        "channel.isTerminated() is expected to be false but was true",
+        channel.isTerminated());
+
+    streamListenerCaptor.getValue().closed(
+        Status.INTERNAL, PROCESSED, new Metadata());
+    verify(mockLoadBalancer).shutdown();
+    // simulating the shutdown of load balancer triggers the shutdown of subchannel
+    shutdownSafely(helper, subchannel);
+    transportInfo.listener.transportShutdown(Status.INTERNAL,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    transportInfo.listener.transportTerminated(); // simulating transport terminated
+    assertTrue(
+        "channel.isTerminated() is expected to be true but was false",
+        channel.isTerminated());
+  }
+
+  @Test
+  public void hedgingScheduledThenChannelShutdown_hedgeShouldStillHappen_newCallShouldFail() {
+    Map<String, Object> hedgingPolicy = new HashMap<>();
+    hedgingPolicy.put("maxAttempts", 3D);
+    hedgingPolicy.put("hedgingDelay", "10s");
+    hedgingPolicy.put("nonFatalStatusCodes", Arrays.<Object>asList("UNAVAILABLE"));
+    Map<String, Object> methodConfig = new HashMap<>();
+    Map<String, Object> name = new HashMap<>();
+    name.put("service", "service");
+    methodConfig.put("name", Arrays.<Object>asList(name));
+    methodConfig.put("hedgingPolicy", hedgingPolicy);
+    Map<String, Object> rawServiceConfig = new HashMap<>();
+    rawServiceConfig.put("methodConfig", Arrays.<Object>asList(methodConfig));
+
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+            .build();
+    ManagedChannelServiceConfig managedChannelServiceConfig =
+        createManagedChannelServiceConfig(rawServiceConfig, null);
+    nameResolverFactory.nextConfigOrError.set(
+        ConfigOrError.fromConfig(managedChannelServiceConfig));
+
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    channelBuilder.executor(MoreExecutors.directExecutor());
+    channelBuilder.enableRetry();
+
+    requestConnection = false;
+    createChannel();
+
+    ClientCall<String, Integer> call = channel.newCall(method, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+    helper = helperCaptor.getValue();
+    verify(mockLoadBalancer).acceptResolvedAddresses(resolvedAddressCaptor.capture());
+    ResolvedAddresses resolvedAddresses = resolvedAddressCaptor.getValue();
+    assertThat(resolvedAddresses.getAddresses()).isEqualTo(nameResolverFactory.servers);
+
+    // simulating request connection and then transport ready after resolved address
+    Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    when(mockPicker.pickSubchannel(any(PickSubchannelArgs.class)))
+        .thenReturn(PickResult.withSubchannel(subchannel));
+    requestConnectionSafely(helper, subchannel);
+    MockClientTransportInfo transportInfo = transports.poll();
+    ConnectionClientTransport mockTransport = transportInfo.transport;
+    ClientStream mockStream = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    when(mockTransport.newStream(
+            same(method), any(Metadata.class), any(CallOptions.class),
+            ArgumentMatchers.<ClientStreamTracer[]>any()))
+        .thenReturn(mockStream).thenReturn(mockStream2);
+    transportInfo.listener.transportReady();
+    updateBalancingStateSafely(helper, READY, mockPicker);
+
+    ArgumentCaptor<ClientStreamListener> streamListenerCaptor =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream).start(streamListenerCaptor.capture());
+
+    // in hedging delay backoff
+    timer.forwardTime(5, TimeUnit.SECONDS);
+    assertThat(timer.numPendingTasks()).isEqualTo(1);
+    // first hedge fails
+    streamListenerCaptor.getValue().closed(
+        Status.UNAVAILABLE, PROCESSED, new Metadata());
+    verify(mockStream2, never()).start(any(ClientStreamListener.class));
+
+    // shutdown during backoff period
+    channel.shutdown();
+
+    assertThat(timer.numPendingTasks()).isEqualTo(1);
+    verify(mockCallListener, never()).onClose(any(Status.class), any(Metadata.class));
+
+    ClientCall<String, Integer> call2 = channel.newCall(method, CallOptions.DEFAULT);
+    call2.start(mockCallListener2, new Metadata());
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockCallListener2).onClose(statusCaptor.capture(), any(Metadata.class));
+    assertSame(Status.Code.UNAVAILABLE, statusCaptor.getValue().getCode());
+    assertEquals("Channel shutdown invoked", statusCaptor.getValue().getDescription());
+
+    // backoff ends
+    timer.forwardTime(5, TimeUnit.SECONDS);
+    assertThat(timer.numPendingTasks()).isEqualTo(1);
+    verify(mockStream2).start(streamListenerCaptor.capture());
+    verify(mockLoadBalancer, never()).shutdown();
+    assertFalse(
+        "channel.isTerminated() is expected to be false but was true",
+        channel.isTerminated());
+
+    streamListenerCaptor.getValue().closed(
+        Status.INTERNAL, PROCESSED, new Metadata());
+    assertThat(timer.numPendingTasks()).isEqualTo(0);
+    verify(mockLoadBalancer).shutdown();
+    // simulating the shutdown of load balancer triggers the shutdown of subchannel
+    shutdownSafely(helper, subchannel);
+    // simulating transport shutdown & terminated
+    transportInfo.listener.transportShutdown(Status.INTERNAL,
+        SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    transportInfo.listener.transportTerminated();
+    assertTrue(
+        "channel.isTerminated() is expected to be true but was false",
+        channel.isTerminated());
+  }
+
+  @Test
+  public void badServiceConfigIsRecoverable() throws Exception {
+    final List<EquivalentAddressGroup> addresses =
+        ImmutableList.of(new EquivalentAddressGroup(new SocketAddress() {}));
+    final class FakeNameResolver extends NameResolver {
+      Listener2 listener;
+
+      @Override
+      public String getServiceAuthority() {
+        return "also fake";
+      }
+
+      @Override
+      public void start(Listener2 listener) {
+        this.listener = listener;
+        listener.onResult(
+            ResolutionResult.newBuilder()
+                .setAddresses(addresses)
+                .setServiceConfig(
+                    ConfigOrError.fromError(
+                        Status.INTERNAL.withDescription("kaboom is invalid")))
+                .build());
+      }
+
+      @Override
+      public void shutdown() {}
+    }
+
+    final class FakeNameResolverFactory2 extends NameResolver.Factory {
+      FakeNameResolver resolver;
+
+      @Nullable
+      @Override
+      public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+        return (resolver = new FakeNameResolver());
+      }
+
+      @Override
+      public String getDefaultScheme() {
+        return "fake";
+      }
+    }
+
+    FakeNameResolverFactory2 factory = new FakeNameResolverFactory2();
+
+    ManagedChannelImplBuilder customBuilder = new ManagedChannelImplBuilder(TARGET,
+        new ClientTransportFactoryBuilder() {
+          @Override
+          public ClientTransportFactory buildClientTransportFactory() {
+            return mockTransportFactory;
+          }
+        },
+        null);
+    when(mockTransportFactory.getSupportedSocketAddressTypes()).thenReturn(Collections.singleton(
+        InetSocketAddress.class));
+    customBuilder.executorPool = executorPool;
+    customBuilder.channelz = channelz;
+    ManagedChannel mychannel = customBuilder.nameResolverFactory(factory).build();
+
+    ClientCall<Void, Void> call1 =
+        mychannel.newCall(TestMethodDescriptors.voidMethod(), CallOptions.DEFAULT);
+    ListenableFuture<Void> future1 = ClientCalls.futureUnaryCall(call1, null);
+    executor.runDueTasks();
+    try {
+      future1.get(1, TimeUnit.SECONDS);
+      Assert.fail();
+    } catch (ExecutionException e) {
+      assertThat(Throwables.getStackTraceAsString(e.getCause())).contains("kaboom");
+    }
+
+    // ok the service config is bad, let's fix it.
+    Map<String, Object> rawServiceConfig =
+        parseConfig("{\"loadBalancingConfig\": [{\"round_robin\": {}}]}");
+    Object fakeLbConfig = new Object();
+    PolicySelection lbConfigs =
+        new PolicySelection(
+            mockLoadBalancerProvider, fakeLbConfig);
+    mockLoadBalancerProvider.parseLoadBalancingPolicyConfig(rawServiceConfig);
+    ManagedChannelServiceConfig managedChannelServiceConfig =
+        createManagedChannelServiceConfig(rawServiceConfig, lbConfigs);
+    factory.resolver.listener.onResult(
+        ResolutionResult.newBuilder()
+            .setAddresses(addresses)
+            .setServiceConfig(ConfigOrError.fromConfig(managedChannelServiceConfig))
+            .build());
+
+    ClientCall<Void, Void> call2 = mychannel.newCall(
+        TestMethodDescriptors.voidMethod(),
+        CallOptions.DEFAULT.withDeadlineAfter(5, TimeUnit.SECONDS));
+    ListenableFuture<Void> future2 = ClientCalls.futureUnaryCall(call2, null);
+
+    timer.forwardTime(1234, TimeUnit.SECONDS);
+
+    executor.runDueTasks();
+    try {
+      future2.get();
+      Assert.fail();
+    } catch (ExecutionException e) {
+      assertThat(Throwables.getStackTraceAsString(e.getCause())).contains("deadline");
+    }
+
+    mychannel.shutdownNow();
+  }
+
+  @Test
+  public void badServiceConfigIsRecoverable_usesListener2OnResult2() throws Exception {
+    final List<EquivalentAddressGroup> addresses =
+        ImmutableList.of(new EquivalentAddressGroup(new SocketAddress() {}));
+    final class FakeNameResolver extends NameResolver {
+      Listener2 listener;
+      private final SynchronizationContext syncContext;
+
+      FakeNameResolver(Args args) {
+        this.syncContext = args.getSynchronizationContext();
+      }
+
+      @Override
+      public String getServiceAuthority() {
+        return "also fake";
+      }
+
+      @Override
+      public void start(Listener2 listener) {
+        this.listener = listener;
+        syncContext.execute(() ->
+            listener.onResult2(
+                ResolutionResult.newBuilder()
+                    .setAddresses(addresses)
+                    .setServiceConfig(
+                        ConfigOrError.fromError(
+                            Status.INTERNAL.withDescription("kaboom is invalid")))
+                    .build()));
+      }
+
+      @Override
+      public void shutdown() {}
+    }
+
+    final class FakeNameResolverFactory2 extends NameResolver.Factory {
+      FakeNameResolver resolver;
+      ManagedChannelImpl managedChannel;
+      SynchronizationContext syncContext;
+
+      @Nullable
+      @Override
+      public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+        syncContext = args.getSynchronizationContext();
+        return (resolver = new FakeNameResolver(args));
+      }
+
+      @Override
+      public String getDefaultScheme() {
+        return "fake";
+      }
+    }
+
+    FakeNameResolverFactory2 factory = new FakeNameResolverFactory2();
+
+    ManagedChannelImplBuilder customBuilder = new ManagedChannelImplBuilder(TARGET,
+        new ClientTransportFactoryBuilder() {
+          @Override
+          public ClientTransportFactory buildClientTransportFactory() {
+            return mockTransportFactory;
+          }
+        },
+        null);
+    when(mockTransportFactory.getSupportedSocketAddressTypes()).thenReturn(Collections.singleton(
+        InetSocketAddress.class));
+    customBuilder.executorPool = executorPool;
+    customBuilder.channelz = channelz;
+    ManagedChannel mychannel = customBuilder.nameResolverFactory(factory).build();
+
+    ClientCall<Void, Void> call1 =
+        mychannel.newCall(TestMethodDescriptors.voidMethod(), CallOptions.DEFAULT);
+    ListenableFuture<Void> future1 = ClientCalls.futureUnaryCall(call1, null);
+    executor.runDueTasks();
+    try {
+      future1.get(1, TimeUnit.SECONDS);
+      Assert.fail();
+    } catch (ExecutionException e) {
+      assertThat(Throwables.getStackTraceAsString(e.getCause())).contains("kaboom");
+    }
+
+    // ok the service config is bad, let's fix it.
+    Map<String, Object> rawServiceConfig =
+        parseConfig("{\"loadBalancingConfig\": [{\"round_robin\": {}}]}");
+    Object fakeLbConfig = new Object();
+    PolicySelection lbConfigs =
+        new PolicySelection(
+            mockLoadBalancerProvider, fakeLbConfig);
+    mockLoadBalancerProvider.parseLoadBalancingPolicyConfig(rawServiceConfig);
+    ManagedChannelServiceConfig managedChannelServiceConfig =
+        createManagedChannelServiceConfig(rawServiceConfig, lbConfigs);
+    factory.syncContext.execute(() ->
+        factory.resolver.listener.onResult2(
+            ResolutionResult.newBuilder()
+                .setAddresses(addresses)
+                .setServiceConfig(ConfigOrError.fromConfig(managedChannelServiceConfig))
+                .build()));
+
+    ClientCall<Void, Void> call2 = mychannel.newCall(
+        TestMethodDescriptors.voidMethod(),
+        CallOptions.DEFAULT.withDeadlineAfter(5, TimeUnit.SECONDS));
+    ListenableFuture<Void> future2 = ClientCalls.futureUnaryCall(call2, null);
+
+    timer.forwardTime(1234, TimeUnit.SECONDS);
+
+    executor.runDueTasks();
+    try {
+      future2.get();
+      Assert.fail();
+    } catch (ExecutionException e) {
+      assertThat(Throwables.getStackTraceAsString(e.getCause())).contains("deadline");
+    }
+
+    mychannel.shutdownNow();
+  }
+
+  @Test
+  public void nameResolverArgsPropagation() {
+    final AtomicReference<NameResolver.Args> capturedArgs = new AtomicReference<>();
+    final NameResolver noopResolver = new NameResolver() {
+        @Override
+        public String getServiceAuthority() {
+          return "fake-authority";
+        }
+
+        @Override
+        public void start(Listener2 listener) {
+        }
+
+        @Override
+        public void shutdown() {}
+      };
+    ProxyDetector neverProxy = new ProxyDetector() {
+        @Override
+        public ProxiedSocketAddress proxyFor(SocketAddress targetAddress) {
+          return null;
+        }
+      };
+    NameResolver.Factory factory = new NameResolver.Factory() {
+        @Override
+        public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+          capturedArgs.set(args);
+          return noopResolver;
+        }
+
+        @Override
+        public String getDefaultScheme() {
+          return "fake";
+        }
+      };
+    channelBuilder
+        .nameResolverFactory(factory)
+        .proxyDetector(neverProxy)
+        .setNameResolverArg(TEST_RESOLVER_CUSTOM_ARG_KEY, "test-value");
+
+    createChannel();
+
+    NameResolver.Args args = capturedArgs.get();
+    assertThat(args).isNotNull();
+    assertThat(args.getDefaultPort()).isEqualTo(DEFAULT_PORT);
+    assertThat(args.getProxyDetector()).isSameInstanceAs(neverProxy);
+    assertThat(args.getArg(TEST_RESOLVER_CUSTOM_ARG_KEY)).isEqualTo("test-value");
+
+    verify(offloadExecutor, never()).execute(any(Runnable.class));
+    args.getOffloadExecutor()
+        .execute(
+            new Runnable() {
+              @Override
+              public void run() {}
+            });
+    verify(offloadExecutor, times(1)).execute(any(Runnable.class));
+  }
+
+  @Test
+  public void getAuthorityAfterShutdown() throws Exception {
+    createChannel();
+    assertEquals(SERVICE_NAME, channel.authority());
+    channel.shutdownNow().awaitTermination(1, TimeUnit.SECONDS);
+    assertEquals(SERVICE_NAME, channel.authority());
+  }
+
+  @Test
+  public void nameResolverHelper_emptyConfigSucceeds() {
+    boolean retryEnabled = false;
+    int maxRetryAttemptsLimit = 2;
+    int maxHedgedAttemptsLimit = 3;
+    AutoConfiguredLoadBalancerFactory autoConfiguredLoadBalancerFactory =
+        new AutoConfiguredLoadBalancerFactory("pick_first");
+
+    ScParser parser = new ScParser(
+        retryEnabled,
+        maxRetryAttemptsLimit,
+        maxHedgedAttemptsLimit,
+        autoConfiguredLoadBalancerFactory);
+
+    ConfigOrError coe = parser.parseServiceConfig(ImmutableMap.<String, Object>of());
+
+    assertThat(coe.getError()).isNull();
+    ManagedChannelServiceConfig cfg = (ManagedChannelServiceConfig) coe.getConfig();
+    assertThat(cfg.getMethodConfig(method)).isEqualTo(
+        ManagedChannelServiceConfig.empty().getMethodConfig(method));
+  }
+
+  @Test
+  public void nameResolverHelper_badConfigFails() {
+    boolean retryEnabled = false;
+    int maxRetryAttemptsLimit = 2;
+    int maxHedgedAttemptsLimit = 3;
+    AutoConfiguredLoadBalancerFactory autoConfiguredLoadBalancerFactory =
+        new AutoConfiguredLoadBalancerFactory("pick_first");
+
+    ScParser parser = new ScParser(
+        retryEnabled,
+        maxRetryAttemptsLimit,
+        maxHedgedAttemptsLimit,
+        autoConfiguredLoadBalancerFactory);
+
+    ConfigOrError coe =
+        parser.parseServiceConfig(ImmutableMap.<String, Object>of("methodConfig", "bogus"));
+
+    assertThat(coe.getError()).isNotNull();
+    assertThat(coe.getError().getCode()).isEqualTo(Code.UNKNOWN);
+    assertThat(coe.getError().getDescription()).contains("failed to parse service config");
+    assertThat(coe.getError().getCause()).isInstanceOf(ClassCastException.class);
+  }
+
+  @Test
+  public void nameResolverHelper_badParser_failsGracefully() {
+    boolean retryEnabled = false;
+    int maxRetryAttemptsLimit = 2;
+    int maxHedgedAttemptsLimit = 3;
+
+    Throwable t = new Error("really poor config parser");
+    when(mockLoadBalancerProvider.parseLoadBalancingPolicyConfig(any())).thenThrow(t);
+    ScParser parser = new ScParser(
+        retryEnabled,
+        maxRetryAttemptsLimit,
+        maxHedgedAttemptsLimit,
+        mockLoadBalancerProvider);
+
+    ConfigOrError coe = parser.parseServiceConfig(ImmutableMap.of());
+
+    assertThat(coe.getError()).isNotNull();
+    assertThat(coe.getError().getCode()).isEqualTo(Code.INTERNAL);
+    assertThat(coe.getError().getDescription()).contains("Unexpected error parsing service config");
+    assertThat(coe.getError().getCause()).isSameInstanceAs(t);
+  }
+
+  @Test
+  public void nameResolverHelper_noConfigChosen() {
+    boolean retryEnabled = false;
+    int maxRetryAttemptsLimit = 2;
+    int maxHedgedAttemptsLimit = 3;
+    LoadBalancerRegistry registry = new LoadBalancerRegistry();
+    registry.register(mockLoadBalancerProvider);
+    AutoConfiguredLoadBalancerFactory autoConfiguredLoadBalancerFactory =
+        new AutoConfiguredLoadBalancerFactory(registry, MOCK_POLICY_NAME);
+
+    ScParser parser = new ScParser(
+        retryEnabled,
+        maxRetryAttemptsLimit,
+        maxHedgedAttemptsLimit,
+        autoConfiguredLoadBalancerFactory);
+
+    ConfigOrError coe =
+        parser.parseServiceConfig(ImmutableMap.of("loadBalancingConfig", ImmutableList.of()));
+
+    assertThat(coe.getError()).isNull();
+    ManagedChannelServiceConfig cfg = (ManagedChannelServiceConfig) coe.getConfig();
+    assertThat(cfg.getLoadBalancingConfig()).isNull();
+  }
+
+  @Test
+  public void disableServiceConfigLookUp_noDefaultConfig() throws Exception {
+    LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
+    try {
+      FakeNameResolverFactory nameResolverFactory =
+          new FakeNameResolverFactory.Builder(expectedUri)
+              .setServers(ImmutableList.of(addressGroup)).build();
+      channelBuilder.nameResolverFactory(nameResolverFactory);
+      channelBuilder.disableServiceConfigLookUp();
+
+      Map<String, Object> rawServiceConfig =
+          parseConfig("{\"methodConfig\":[{"
+              + "\"name\":[{\"service\":\"SimpleService1\"}],"
+              + "\"waitForReady\":true}]}");
+      ManagedChannelServiceConfig managedChannelServiceConfig =
+          createManagedChannelServiceConfig(rawServiceConfig, null);
+      nameResolverFactory.nextConfigOrError.set(
+          ConfigOrError.fromConfig(managedChannelServiceConfig));
+      nameResolverFactory.nextAttributes.set(
+          Attributes.newBuilder()
+              .set(InternalConfigSelector.KEY, mock(InternalConfigSelector.class))
+              .build());
+
+      createChannel();
+
+      ArgumentCaptor<ResolvedAddresses> resultCaptor =
+          ArgumentCaptor.forClass(ResolvedAddresses.class);
+      verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+      assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
+      assertThat(resultCaptor.getValue().getAttributes().get(InternalConfigSelector.KEY)).isNull();
+      verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+    } finally {
+      LoadBalancerRegistry.getDefaultRegistry().deregister(mockLoadBalancerProvider);
+    }
+  }
+
+  @Test
+  public void disableServiceConfigLookUp_withDefaultConfig() throws Exception {
+    LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
+    try {
+      FakeNameResolverFactory nameResolverFactory =
+          new FakeNameResolverFactory.Builder(expectedUri)
+              .setServers(ImmutableList.of(addressGroup)).build();
+      channelBuilder.nameResolverFactory(nameResolverFactory);
+      channelBuilder.disableServiceConfigLookUp();
+      Map<String, Object> defaultServiceConfig =
+          parseConfig("{\"methodConfig\":[{"
+              + "\"name\":[{\"service\":\"SimpleService1\"}],"
+              + "\"waitForReady\":true}]}");
+      channelBuilder.defaultServiceConfig(defaultServiceConfig);
+
+      Map<String, Object> rawServiceConfig = new HashMap<>();
+      ManagedChannelServiceConfig managedChannelServiceConfig =
+          createManagedChannelServiceConfig(rawServiceConfig, null);
+      nameResolverFactory.nextConfigOrError.set(
+          ConfigOrError.fromConfig(managedChannelServiceConfig));
+      nameResolverFactory.nextAttributes.set(
+          Attributes.newBuilder()
+              .set(InternalConfigSelector.KEY, mock(InternalConfigSelector.class))
+              .build());
+
+      createChannel();
+
+      ArgumentCaptor<ResolvedAddresses> resultCaptor =
+          ArgumentCaptor.forClass(ResolvedAddresses.class);
+      verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+      assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
+      assertThat(resultCaptor.getValue().getAttributes().get(InternalConfigSelector.KEY)).isNull();
+      verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+    } finally {
+      LoadBalancerRegistry.getDefaultRegistry().deregister(mockLoadBalancerProvider);
+    }
+  }
+
+  @Test
+  public void disableServiceConfigLookUp_withDefaultConfig_withRetryThrottle() throws Exception {
+    LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
+    try {
+      FakeNameResolverFactory nameResolverFactory =
+              new FakeNameResolverFactory.Builder(expectedUri)
+                      .setServers(ImmutableList.of(addressGroup)).build();
+      channelBuilder.nameResolverFactory(nameResolverFactory);
+      channelBuilder.disableServiceConfigLookUp();
+      channelBuilder.enableRetry();
+      Map<String, Object> defaultServiceConfig =
+              parseConfig("{"
+                      + "\"retryThrottling\":{\"maxTokens\": 1, \"tokenRatio\": 1},"
+                      + "\"methodConfig\":[{"
+                      + "\"name\":[{\"service\":\"SimpleService1\"}],"
+                      + "\"waitForReady\":true"
+                      + "}]}");
+      channelBuilder.defaultServiceConfig(defaultServiceConfig);
+
+      createChannel();
+
+      ArgumentCaptor<ResolvedAddresses> resultCaptor =
+              ArgumentCaptor.forClass(ResolvedAddresses.class);
+      verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+      assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
+      assertThat(resultCaptor.getValue().getAttributes().get(InternalConfigSelector.KEY)).isNull();
+      verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+      assertThat(channel.hasThrottle()).isTrue();
+
+    } finally {
+      LoadBalancerRegistry.getDefaultRegistry().deregister(mockLoadBalancerProvider);
+    }
+  }
+
+  @Test
+  public void enableServiceConfigLookUp_noDefaultConfig() throws Exception {
+    LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
+    try {
+      FakeNameResolverFactory nameResolverFactory =
+          new FakeNameResolverFactory.Builder(expectedUri)
+              .setServers(ImmutableList.of(addressGroup)).build();
+      channelBuilder.nameResolverFactory(nameResolverFactory);
+
+      Map<String, Object> rawServiceConfig =
+          parseConfig("{\"methodConfig\":[{"
+              + "\"name\":[{\"service\":\"SimpleService1\"}],"
+              + "\"waitForReady\":true}]}");
+      ManagedChannelServiceConfig managedChannelServiceConfig =
+          createManagedChannelServiceConfig(rawServiceConfig, null);
+      nameResolverFactory.nextConfigOrError.set(
+          ConfigOrError.fromConfig(managedChannelServiceConfig));
+
+      createChannel();
+      ArgumentCaptor<ResolvedAddresses> resultCaptor =
+          ArgumentCaptor.forClass(ResolvedAddresses.class);
+      verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+      assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
+      verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+
+      // new config
+      rawServiceConfig =
+          parseConfig("{\"methodConfig\":[{"
+              + "\"name\":[{\"service\":\"SimpleService1\"}],"
+              + "\"waitForReady\":false}]}");
+      managedChannelServiceConfig =
+          createManagedChannelServiceConfig(rawServiceConfig, null);
+      nameResolverFactory.nextConfigOrError.set(
+          ConfigOrError.fromConfig(managedChannelServiceConfig));
+      nameResolverFactory.allResolved();
+
+      resultCaptor = ArgumentCaptor.forClass(ResolvedAddresses.class);
+      verify(mockLoadBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture());
+      assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
+      verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+    } finally {
+      LoadBalancerRegistry.getDefaultRegistry().deregister(mockLoadBalancerProvider);
+    }
+  }
+
+  @Test
+  public void enableServiceConfigLookUp_withDefaultConfig() throws Exception {
+    LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
+    try {
+      FakeNameResolverFactory nameResolverFactory =
+          new FakeNameResolverFactory.Builder(expectedUri)
+              .setServers(ImmutableList.of(addressGroup)).build();
+      channelBuilder.nameResolverFactory(nameResolverFactory);
+      Map<String, Object> defaultServiceConfig =
+          parseConfig("{\"methodConfig\":[{"
+              + "\"name\":[{\"service\":\"SimpleService1\"}],"
+              + "\"waitForReady\":true}]}");
+      channelBuilder.defaultServiceConfig(defaultServiceConfig);
+
+      Map<String, Object> rawServiceConfig =
+          parseConfig("{\"methodConfig\":[{"
+              + "\"name\":[{\"service\":\"SimpleService2\"}],"
+              + "\"waitForReady\":false}]}");
+      ManagedChannelServiceConfig managedChannelServiceConfig =
+          createManagedChannelServiceConfig(rawServiceConfig, null);
+      nameResolverFactory.nextConfigOrError.set(
+          ConfigOrError.fromConfig(managedChannelServiceConfig));
+
+      createChannel();
+      ArgumentCaptor<ResolvedAddresses> resultCaptor =
+          ArgumentCaptor.forClass(ResolvedAddresses.class);
+      verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+      assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
+      verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+    } finally {
+      LoadBalancerRegistry.getDefaultRegistry().deregister(mockLoadBalancerProvider);
+    }
+  }
+
+  @Test
+  public void enableServiceConfigLookUp_resolverReturnsNoConfig_withDefaultConfig()
+      throws Exception {
+    LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
+    try {
+      FakeNameResolverFactory nameResolverFactory =
+          new FakeNameResolverFactory.Builder(expectedUri)
+              .setServers(ImmutableList.of(addressGroup)).build();
+      channelBuilder.nameResolverFactory(nameResolverFactory);
+      Map<String, Object> defaultServiceConfig =
+          parseConfig("{\"methodConfig\":[{"
+              + "\"name\":[{\"service\":\"SimpleService1\"}],"
+              + "\"waitForReady\":true}]}");
+      channelBuilder.defaultServiceConfig(defaultServiceConfig);
+
+      nameResolverFactory.nextConfigOrError.set(null);
+
+      createChannel();
+      ArgumentCaptor<ResolvedAddresses> resultCaptor =
+          ArgumentCaptor.forClass(ResolvedAddresses.class);
+      verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+      assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
+      verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+    } finally {
+      LoadBalancerRegistry.getDefaultRegistry().deregister(mockLoadBalancerProvider);
+    }
+  }
+
+
+  @Test
+  public void enableServiceConfigLookUp_usingDefaultConfig_withRetryThrottling() throws Exception {
+    LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
+    try {
+      FakeNameResolverFactory nameResolverFactory =
+              new FakeNameResolverFactory.Builder(expectedUri)
+                      .setServers(ImmutableList.of(addressGroup)).build();
+      channelBuilder.nameResolverFactory(nameResolverFactory);
+      channelBuilder.enableRetry();
+      Map<String, Object> defaultServiceConfig =
+              parseConfig("{"
+                      + "\"retryThrottling\":{\"maxTokens\": 1, \"tokenRatio\": 1},"
+                      + "\"methodConfig\":[{"
+                      + "\"name\":[{\"service\":\"SimpleService1\"}],"
+                      + "\"waitForReady\":true"
+                      + "}]}");
+      channelBuilder.defaultServiceConfig(defaultServiceConfig);
+
+      createChannel();
+
+      ArgumentCaptor<ResolvedAddresses> resultCaptor =
+              ArgumentCaptor.forClass(ResolvedAddresses.class);
+      verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+      assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
+      assertThat(resultCaptor.getValue().getAttributes().get(InternalConfigSelector.KEY)).isNull();
+      verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+      assertThat(channel.hasThrottle()).isTrue();
+    } finally {
+      LoadBalancerRegistry.getDefaultRegistry().deregister(mockLoadBalancerProvider);
+    }
+  }
+
+  @Test
+  public void enableServiceConfigLookUp_resolverReturnsNoConfig_noDefaultConfig() {
+    LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
+    try {
+      FakeNameResolverFactory nameResolverFactory =
+          new FakeNameResolverFactory.Builder(expectedUri)
+              .setServers(ImmutableList.of(addressGroup)).build();
+      channelBuilder.nameResolverFactory(nameResolverFactory);
+
+      Map<String, Object> rawServiceConfig = Collections.emptyMap();
+      ManagedChannelServiceConfig managedChannelServiceConfig =
+          createManagedChannelServiceConfig(rawServiceConfig, null);
+      nameResolverFactory.nextConfigOrError.set(
+          ConfigOrError.fromConfig(managedChannelServiceConfig));
+
+      createChannel();
+      ArgumentCaptor<ResolvedAddresses> resultCaptor =
+          ArgumentCaptor.forClass(ResolvedAddresses.class);
+      verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+      assertThat(resultCaptor.getValue().getAddresses()).containsExactly(addressGroup);
+      verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+    } finally {
+      LoadBalancerRegistry.getDefaultRegistry().deregister(mockLoadBalancerProvider);
+    }
+  }
+
+  @Test
+  public void useDefaultImmediatelyIfDisableLookUp() throws Exception {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(ImmutableList.of(addressGroup)).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    channelBuilder.disableServiceConfigLookUp();
+    Map<String, Object> defaultServiceConfig =
+        parseConfig("{\"methodConfig\":[{"
+            + "\"name\":[{\"service\":\"SimpleService1\"}],"
+            + "\"waitForReady\":true}]}");
+    channelBuilder.defaultServiceConfig(defaultServiceConfig);
+    requestConnection = false;
+    channelBuilder.maxTraceEvents(10);
+
+    createChannel();
+
+    int size = getStats(channel).channelTrace.events.size();
+    assertThat(getStats(channel).channelTrace.events.get(size - 1))
+        .isEqualTo(new ChannelTrace.Event.Builder()
+            .setDescription("Service config look-up disabled, using default service config")
+            .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+            .setTimestampNanos(timer.getTicker().read())
+            .build());
+  }
+
+  @Test
+  public void notUseDefaultImmediatelyIfEnableLookUp() throws Exception {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(ImmutableList.of(addressGroup)).build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    Map<String, Object> defaultServiceConfig =
+        parseConfig("{\"methodConfig\":[{"
+            + "\"name\":[{\"service\":\"SimpleService1\"}],"
+            + "\"waitForReady\":true}]}");
+    channelBuilder.defaultServiceConfig(defaultServiceConfig);
+    requestConnection = false;
+    channelBuilder.maxTraceEvents(10);
+
+    createChannel();
+
+    int size = getStats(channel).channelTrace.events.size();
+    assertThat(getStats(channel).channelTrace.events.get(size - 1))
+        .isNotEqualTo(new ChannelTrace.Event.Builder()
+            .setDescription("timer.forwardNanos(1234);")
+            .setSeverity(ChannelTrace.Event.Severity.CT_INFO)
+            .setTimestampNanos(timer.getTicker().read())
+            .build());
+  }
+
+  @Test
+  public void healthCheckingConfigPropagated() throws Exception {
+    LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
+    try {
+      FakeNameResolverFactory nameResolverFactory =
+          new FakeNameResolverFactory.Builder(expectedUri)
+              .setServers(Collections.singletonList(new EquivalentAddressGroup(socketAddress)))
+              .build();
+      channelBuilder.nameResolverFactory(nameResolverFactory);
+
+      Map<String, Object> rawServiceConfig =
+          parseConfig("{\"healthCheckConfig\": {\"serviceName\": \"service1\"}}");
+      ManagedChannelServiceConfig managedChannelServiceConfig =
+          createManagedChannelServiceConfig(rawServiceConfig, null);
+      nameResolverFactory.nextConfigOrError.set(
+          ConfigOrError.fromConfig(managedChannelServiceConfig));
+
+      createChannel();
+
+      ArgumentCaptor<ResolvedAddresses> resultCaptor =
+          ArgumentCaptor.forClass(ResolvedAddresses.class);
+      verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+      assertThat(resultCaptor.getValue().getAttributes()
+          .get(LoadBalancer.ATTR_HEALTH_CHECKING_CONFIG))
+          .containsExactly("serviceName", "service1");
+    } finally {
+      LoadBalancerRegistry.getDefaultRegistry().deregister(mockLoadBalancerProvider);
+    }
+  }
+
+  @Test
+  public void createResolvingOobChannel() throws Exception {
+    String oobTarget = "fake://second.example.com";
+    URI oobUri = new URI(oobTarget);
+    channelBuilder
+        .nameResolverFactory(new FakeNameResolverFactory.Builder(expectedUri, oobUri).build());
+    createChannel();
+
+    ManagedChannel resolvedOobChannel = null;
+    try {
+      resolvedOobChannel = helper.createResolvingOobChannel(oobTarget);
+
+      assertWithMessage("resolving oob channel should have same authority")
+          .that(resolvedOobChannel.authority())
+          .isEqualTo(channel.authority());
+    } finally {
+      if (resolvedOobChannel != null) {
+        resolvedOobChannel.shutdownNow();
+      }
+    }
+  }
+
+  @Test
+  public void transportFilters() {
+
+    final AtomicInteger readyCallbackCalled = new AtomicInteger(0);
+    final AtomicInteger terminationCallbackCalled = new AtomicInteger(0);
+    ClientTransportFilter transportFilter = new ClientTransportFilter() {
+      @Override
+      public Attributes transportReady(Attributes transportAttrs) {
+        readyCallbackCalled.incrementAndGet();
+        return transportAttrs;
+      }
+
+      @Override
+      public void transportTerminated(Attributes transportAttrs) {
+        terminationCallbackCalled.incrementAndGet();
+      }
+    };
+
+    channelBuilder.addTransportFilter(transportFilter);
+    assertEquals(0, readyCallbackCalled.get());
+
+    createChannel();
+    final Subchannel subchannel =
+        createSubchannelSafely(helper, addressGroup, Attributes.EMPTY, subchannelStateListener);
+    requestConnectionSafely(helper, subchannel);
+    verify(mockTransportFactory)
+        .newClientTransport(
+        any(SocketAddress.class), any(ClientTransportOptions.class), any(ChannelLogger.class));
+    MockClientTransportInfo transportInfo = transports.poll();
+    ManagedClientTransport.Listener transportListener = transportInfo.listener;
+
+    transportListener.filterTransport(Attributes.EMPTY);
+    transportListener.transportReady();
+    assertEquals(1, readyCallbackCalled.get());
+    assertEquals(0, terminationCallbackCalled.get());
+
+    transportListener.transportShutdown(Status.OK, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+
+    transportListener.transportTerminated();
+    assertEquals(1, terminationCallbackCalled.get());
+  }
+
+  @Test
+  public void validAuthorityTarget_overrideAuthority() throws Exception {
+    String overrideAuthority = "override.authority";
+    String serviceAuthority = "fakeauthority";
+    NameResolverProvider nameResolverProvider = new NameResolverProvider() {
+      @Override protected boolean isAvailable() {
+        return true;
+      }
+
+      @Override protected int priority() {
+        return 5;
+      }
+
+      @Override public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+        return new NameResolver() {
+          @Override public String getServiceAuthority() {
+            return serviceAuthority;
+          }
+
+          @Override public void start(final Listener2 listener) {}
+
+          @Override public void shutdown() {}
+        };
+      }
+
+      @Override public String getDefaultScheme() {
+        return "defaultscheme";
+      }
+    };
+
+    URI targetUri = new URI("defaultscheme", "", "/foo.googleapis.com:8080", null);
+    NameResolver nameResolver = ManagedChannelImpl.getNameResolver(
+        wrap(targetUri), null, nameResolverProvider, NAMERESOLVER_ARGS);
+    assertThat(nameResolver.getServiceAuthority()).isEqualTo(serviceAuthority);
+
+    nameResolver = ManagedChannelImpl.getNameResolver(
+        wrap(targetUri), overrideAuthority, nameResolverProvider, NAMERESOLVER_ARGS);
+    assertThat(nameResolver.getServiceAuthority()).isEqualTo(overrideAuthority);
+  }
+
+  @Test
+  public void validTargetNoResolver_throws() {
+    NameResolverProvider nameResolverProvider = new NameResolverProvider() {
+      @Override
+      protected boolean isAvailable() {
+        return true;
+      }
+
+      @Override
+      protected int priority() {
+        return 5;
+      }
+
+      @Override
+      public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+        return null;
+      }
+
+      @Override
+      public String getDefaultScheme() {
+        return "defaultscheme";
+      }
+    };
+    try {
+      ManagedChannelImpl.getNameResolver(
+          wrap(URI.create("defaultscheme:///foo.gogoleapis.com:8080")),
+          null, nameResolverProvider, NAMERESOLVER_ARGS);
+      fail("Should fail");
+    } catch (IllegalArgumentException e) {
+      // expected
+    }
+  }
+
+
+  private static final class FakeBackoffPolicyProvider implements BackoffPolicy.Provider {
+    @Override
+    public BackoffPolicy get() {
+      return new BackoffPolicy() {
+        int multiplier = 1;
+
+        @Override
+        public long nextBackoffNanos() {
+          return RECONNECT_BACKOFF_INTERVAL_NANOS * multiplier++;
+        }
+      };
+    }
+  }
+
+  private static final class FakeNameResolverFactory extends NameResolverProvider {
+    final List<URI> expectedUris;
+    final List<EquivalentAddressGroup> servers;
+    final boolean resolvedAtStart;
+    final Status error;
+    final ArrayList<FakeNameResolverFactory.FakeNameResolver> resolvers = new ArrayList<>();
+    final AtomicReference<ConfigOrError> nextConfigOrError = new AtomicReference<>();
+    final AtomicReference<Attributes> nextAttributes = new AtomicReference<>(Attributes.EMPTY);
+
+    FakeNameResolverFactory(
+        List<URI> expectedUris,
+        List<EquivalentAddressGroup> servers,
+        boolean resolvedAtStart,
+        Status error) {
+      this.expectedUris = expectedUris;
+      this.servers = servers;
+      this.resolvedAtStart = resolvedAtStart;
+      this.error = error;
+    }
+
+    @Override
+    public NameResolver newNameResolver(final URI targetUri, NameResolver.Args args) {
+      if (!expectedUris.contains(targetUri)) {
+        return null;
+      }
+      assertEquals(DEFAULT_PORT, args.getDefaultPort());
+      FakeNameResolverFactory.FakeNameResolver resolver =
+          new FakeNameResolverFactory.FakeNameResolver(targetUri, error, args);
+      resolvers.add(resolver);
+      return resolver;
+    }
+
+    @Override
+    public String getDefaultScheme() {
+      return "fake";
+    }
+
+    @Override
+    public int priority() {
+      return 9;
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
 
     void allResolved() {
-      for (FakeNameResolver resolver : resolvers) {
+      for (FakeNameResolverFactory.FakeNameResolver resolver : resolvers) {
         resolver.resolved();
       }
     }
 
-    private class FakeNameResolver extends NameResolver {
-      Listener listener;
+    final class FakeNameResolver extends NameResolver {
+      final URI targetUri;
+      final SynchronizationContext syncContext;
+      Listener2 listener;
       boolean shutdown;
+      int refreshCalled;
+      Status error;
+
+      FakeNameResolver(URI targetUri, Status error, Args args) {
+        this.targetUri = targetUri;
+        this.error = error;
+        syncContext = args.getSynchronizationContext();
+      }
 
       @Override public String getServiceAuthority() {
-        return expectedUri.getAuthority();
+        return targetUri.getAuthority();
       }
 
-      @Override public void start(final Listener listener) {
+      @Override public void start(Listener2 listener) {
         this.listener = listener;
         if (resolvedAtStart) {
           resolved();
         }
       }
 
+      @Override public void refresh() {
+        refreshCalled++;
+        resolved();
+      }
+
       void resolved() {
-        listener.onUpdate(servers, Attributes.EMPTY);
+        if (error != null) {
+          syncContext.execute(() ->
+              listener.onResult2(
+                  ResolutionResult.newBuilder()
+                      .setAddressesOrError(StatusOr.fromStatus(error)).build()));
+          return;
+        }
+        ResolutionResult.Builder builder =
+            ResolutionResult.newBuilder()
+                .setAddresses(servers)
+                .setAttributes(nextAttributes.get());
+        ConfigOrError configOrError = nextConfigOrError.get();
+        if (configOrError != null) {
+          builder.setServiceConfig(configOrError);
+        }
+        syncContext.execute(() -> listener.onResult(builder.build()));
       }
 
       @Override public void shutdown() {
         shutdown = true;
       }
+
+      @Override
+      public String toString() {
+        return "FakeNameResolver";
+      }
     }
-  }
 
-  private static class FailingNameResolverFactory extends NameResolver.Factory {
-    final Status error;
+    static final class Builder {
+      List<URI> expectedUris;
+      List<EquivalentAddressGroup> servers = ImmutableList.of();
+      boolean resolvedAtStart = true;
+      Status error = null;
 
-    FailingNameResolverFactory(Status error) {
-      this.error = error;
-    }
+      Builder(URI... expectedUris) {
+        this.expectedUris = Collections.unmodifiableList(Arrays.asList(expectedUris));
+      }
 
-    @Override
-    public NameResolver newNameResolver(URI notUsedUri, Attributes params) {
-      return new NameResolver() {
-        @Override public String getServiceAuthority() {
-          return "irrelevant-authority";
-        }
+      FakeNameResolverFactory.Builder setServers(List<EquivalentAddressGroup> servers) {
+        this.servers = servers;
+        return this;
+      }
 
-        @Override public void start(final Listener listener) {
-          listener.onError(error);
-        }
+      FakeNameResolverFactory.Builder setResolvedAtStart(boolean resolvedAtStart) {
+        this.resolvedAtStart = resolvedAtStart;
+        return this;
+      }
 
-        @Override public void shutdown() {}
-      };
-    }
+      FakeNameResolverFactory.Builder setError(Status error) {
+        this.error = error;
+        return this;
+      }
 
-    @Override
-    public String getDefaultScheme() {
-      return "fake";
+      FakeNameResolverFactory build() {
+        return new FakeNameResolverFactory(expectedUris, servers, resolvedAtStart, error);
+      }
     }
   }
 
-  private static class SpyingLoadBalancerFactory extends LoadBalancer.Factory {
-    private final LoadBalancer.Factory delegate;
-    private final List<LoadBalancer<?>> balancers = new ArrayList<LoadBalancer<?>>();
+  private static ChannelStats getStats(AbstractSubchannel subchannel) throws Exception {
+    return subchannel.getInstrumentedInternalSubchannel().getStats().get();
+  }
 
-    private SpyingLoadBalancerFactory(LoadBalancer.Factory delegate) {
-      this.delegate = delegate;
-    }
+  private static ChannelStats getStats(
+      InternalInstrumented<ChannelStats> instrumented) throws Exception {
+    return instrumented.getStats().get();
+  }
 
-    @Override
-    public <T> LoadBalancer<T> newLoadBalancer(String serviceName, TransportManager<T> tm) {
-      LoadBalancer<T> lb = spy(delegate.newLoadBalancer(serviceName, tm));
-      balancers.add(lb);
-      return lb;
-    }
+  // Helper methods to call methods from SynchronizationContext
+  private static Subchannel createSubchannelSafely(
+      final Helper helper, final EquivalentAddressGroup addressGroup, final Attributes attrs,
+      final SubchannelStateListener stateListener) {
+    final AtomicReference<Subchannel> resultCapture = new AtomicReference<>();
+    helper.getSynchronizationContext().execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            Subchannel s = helper.createSubchannel(CreateSubchannelArgs.newBuilder()
+                .setAddresses(addressGroup)
+                .setAttributes(attrs)
+                .build());
+            s.start(stateListener);
+            resultCapture.set(s);
+          }
+        });
+    return resultCapture.get();
+  }
+
+  private static Subchannel createUnstartedSubchannel(
+      final Helper helper, final EquivalentAddressGroup addressGroup, final Attributes attrs) {
+    final AtomicReference<Subchannel> resultCapture = new AtomicReference<>();
+    helper.getSynchronizationContext().execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            Subchannel s = helper.createSubchannel(CreateSubchannelArgs.newBuilder()
+                .setAddresses(addressGroup)
+                .setAttributes(attrs)
+                .build());
+            resultCapture.set(s);
+          }
+        });
+    return resultCapture.get();
+  }
+
+  private static void requestConnectionSafely(Helper helper, final Subchannel subchannel) {
+    helper.getSynchronizationContext().execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            subchannel.requestConnection();
+          }
+        });
+  }
+
+  private static void updateBalancingStateSafely(
+      final Helper helper, final ConnectivityState state, final SubchannelPicker picker) {
+    helper.getSynchronizationContext().execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            helper.updateBalancingState(state, picker);
+          }
+        });
+  }
+
+  private static void refreshNameResolutionSafely(final Helper helper) {
+    helper.getSynchronizationContext().execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            helper.refreshNameResolution();
+          }
+        });
+  }
+
+  private static void updateAddressesSafely(
+      Helper helper, final Subchannel subchannel, final List<EquivalentAddressGroup> addrs) {
+    helper.getSynchronizationContext().execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            subchannel.updateAddresses(addrs);
+          }
+        });
+  }
+
+  private static void shutdownSafely(
+      final Helper helper, final Subchannel subchannel) {
+    helper.getSynchronizationContext().execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            subchannel.shutdown();
+          }
+        });
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, Object> parseConfig(String json) throws Exception {
+    return (Map<String, Object>) JsonParser.parse(json);
+  }
+
+  private static ManagedChannelServiceConfig createManagedChannelServiceConfig(
+      Map<String, Object> rawServiceConfig, PolicySelection policySelection) {
+    // Provides dummy variable for retry related params (not used in this test class)
+    return ManagedChannelServiceConfig
+        .fromServiceConfig(rawServiceConfig, true, 3, 4, policySelection);
   }
 }
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelImplTransportManagerTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelImplTransportManagerTest.java
deleted file mode 100644
index a1ed1390765..00000000000
--- a/core/src/test/java/io/grpc/internal/ManagedChannelImplTransportManagerTest.java
+++ /dev/null
@@ -1,408 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.same;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.timeout;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-import io.grpc.Attributes;
-import io.grpc.CallOptions;
-import io.grpc.ClientInterceptor;
-import io.grpc.CompressorRegistry;
-import io.grpc.DecompressorRegistry;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.MethodDescriptor.MethodType;
-import io.grpc.NameResolver;
-import io.grpc.Status;
-import io.grpc.StringMarshaller;
-import io.grpc.TransportManager;
-import io.grpc.TransportManager.InterimTransport;
-import io.grpc.TransportManager.OobTransportProvider;
-import io.grpc.internal.TestUtils.MockClientTransportInfo;
-import java.net.SocketAddress;
-import java.net.URI;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-/**
- * Unit tests for {@link ManagedChannelImpl}'s {@link TransportManager} implementation as well as
- * {@link TransportSet}.
- */
-@RunWith(JUnit4.class)
-public class ManagedChannelImplTransportManagerTest {
-
-  private static final String AUTHORITY = "fakeauthority";
-  private static final String USER_AGENT = "mosaic";
-
-  private final ExecutorService executor = Executors.newSingleThreadExecutor();
-  private final MethodDescriptor<String, String> method =
-      MethodDescriptor.<String, String>newBuilder()
-          .setType(MethodType.UNKNOWN)
-          .setFullMethodName("/service/method")
-          .setRequestMarshaller(new StringMarshaller())
-          .setResponseMarshaller(new StringMarshaller())
-          .build();
-
-  private final MethodDescriptor<String, String> method2 = method.toBuilder()
-      .setFullMethodName("/service/method2")
-      .build();
-  private final CallOptions callOptions = CallOptions.DEFAULT.withAuthority("dummy_value");
-  private final CallOptions callOptions2 = CallOptions.DEFAULT.withAuthority("dummy_value2");
-  private final StatsTraceContext statsTraceCtx = StatsTraceContext.newClientContext(
-      method.getFullMethodName(), NoopStatsContextFactory.INSTANCE,
-      GrpcUtil.STOPWATCH_SUPPLIER);
-  private final StatsTraceContext statsTraceCtx2 = StatsTraceContext.newClientContext(
-      method2.getFullMethodName(), NoopStatsContextFactory.INSTANCE,
-      GrpcUtil.STOPWATCH_SUPPLIER);
-
-  private ManagedChannelImpl channel;
-
-  @Mock private ClientTransportFactory mockTransportFactory;
-  @Mock private LoadBalancer.Factory mockLoadBalancerFactory;
-  @Mock private NameResolver mockNameResolver;
-  @Mock private NameResolver.Factory mockNameResolverFactory;
-  @Mock private BackoffPolicy.Provider mockBackoffPolicyProvider;
-  @Mock private BackoffPolicy mockBackoffPolicy;
-
-  private BlockingQueue<MockClientTransportInfo> transports;
-
-  private TransportManager<ClientTransport> tm;
-
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-
-    when(mockBackoffPolicyProvider.get()).thenReturn(mockBackoffPolicy);
-    when(mockNameResolver.getServiceAuthority()).thenReturn(AUTHORITY);
-    when(mockNameResolverFactory
-        .newNameResolver(any(URI.class), any(Attributes.class)))
-        .thenReturn(mockNameResolver);
-    @SuppressWarnings("unchecked")
-    LoadBalancer<ClientTransport> loadBalancer = mock(LoadBalancer.class);
-    when(mockLoadBalancerFactory
-        .newLoadBalancer(anyString(), Matchers.<TransportManager<ClientTransport>>any()))
-        .thenReturn(loadBalancer);
-
-    channel = new ManagedChannelImpl("fake://target", mockBackoffPolicyProvider,
-        mockNameResolverFactory, Attributes.EMPTY, mockLoadBalancerFactory,
-        mockTransportFactory, DecompressorRegistry.getDefaultInstance(),
-        CompressorRegistry.getDefaultInstance(), GrpcUtil.TIMER_SERVICE,
-        GrpcUtil.STOPWATCH_SUPPLIER, ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE,
-        executor, USER_AGENT, Collections.<ClientInterceptor>emptyList(),
-        NoopStatsContextFactory.INSTANCE);
-
-    ArgumentCaptor<TransportManager<ClientTransport>> tmCaptor
-        = ArgumentCaptor.forClass(null);
-    // Force Channel to exit the initial idleness to get NameResolver and LoadBalancer created.
-    channel.exitIdleModeAndGetLb();
-    verify(mockNameResolverFactory).newNameResolver(any(URI.class), any(Attributes.class));
-    verify(mockLoadBalancerFactory).newLoadBalancer(anyString(), tmCaptor.capture());
-    tm = tmCaptor.getValue();
-    transports = TestUtils.captureTransports(mockTransportFactory);
-    // NameResolver is started in the executor
-    verify(mockNameResolver, timeout(1000)).start(any(NameResolver.Listener.class));
-  }
-
-  @After
-  public void tearDown() {
-    channel.shutdown();
-    executor.shutdown();
-  }
-
-  @Test
-  public void createAndReuseTransport() throws Exception {
-    SocketAddress addr = mock(SocketAddress.class);
-    EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(addr);
-    ClientTransport t1 = tm.getTransport(addressGroup);
-    verify(mockTransportFactory, timeout(1000)).newClientTransport(addr, AUTHORITY, USER_AGENT);
-    // The real transport
-    MockClientTransportInfo transportInfo = transports.poll(1, TimeUnit.SECONDS);
-    transportInfo.listener.transportReady();
-    ForwardingConnectionClientTransport t2 =
-        (ForwardingConnectionClientTransport) tm.getTransport(addressGroup);
-    assertTrue(t1 instanceof DelayedClientTransport);
-    assertSame(transportInfo.transport, t2.delegate());
-    verify(mockBackoffPolicyProvider, times(0)).get();
-    verify(mockBackoffPolicy, times(0)).nextBackoffMillis();
-    verifyNoMoreInteractions(mockTransportFactory);
-  }
-
-  @Test
-  public void reconnect() throws Exception {
-    SocketAddress addr1 = mock(SocketAddress.class);
-    SocketAddress addr2 = mock(SocketAddress.class);
-    EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(Arrays.asList(addr1, addr2));
-
-    // Invocation counters
-    int backoffReset = 0;
-
-    // Pick the first transport
-    ClientTransport t1 = tm.getTransport(addressGroup);
-    assertNotNull(t1);
-    verify(mockTransportFactory, timeout(1000)).newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    verify(mockBackoffPolicyProvider, times(backoffReset)).get();
-    // Fail the first transport, without setting it to ready
-    MockClientTransportInfo transportInfo = transports.poll(1, TimeUnit.SECONDS);
-    ClientTransport rt1 = transportInfo.transport;
-    transportInfo.listener.transportShutdown(Status.UNAVAILABLE);
-
-    // Subsequent getTransport() will use the next address
-    ClientTransport t2 = tm.getTransport(addressGroup);
-    assertNotNull(t2);
-    t2.newStream(method, new Metadata(), callOptions, statsTraceCtx);
-    // Will keep the previous back-off policy, and not consult back-off policy
-    verify(mockTransportFactory, timeout(1000)).newClientTransport(addr2, AUTHORITY, USER_AGENT);
-    verify(mockBackoffPolicyProvider, times(backoffReset)).get();
-    transportInfo = transports.poll(1, TimeUnit.SECONDS);
-    ClientTransport rt2 = transportInfo.transport;
-    // Make the second transport ready
-    transportInfo.listener.transportReady();
-    verify(rt2, timeout(1000)).newStream(
-        same(method), any(Metadata.class), same(callOptions), same(statsTraceCtx));
-    verify(mockNameResolver, times(0)).refresh();
-    // Disconnect the second transport
-    transportInfo.listener.transportShutdown(Status.UNAVAILABLE);
-    // Will trigger NameResolver refresh
-    verify(mockNameResolver).refresh();
-
-    // Subsequent getTransport() will use the first address, since last attempt was successful.
-    ClientTransport t3 = tm.getTransport(addressGroup);
-    t3.newStream(method2, new Metadata(), callOptions2, statsTraceCtx2);
-    verify(mockTransportFactory, timeout(1000).times(2))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    // Still no back-off policy creation, because an address succeeded.
-    verify(mockBackoffPolicyProvider, times(backoffReset)).get();
-    transportInfo = transports.poll(1, TimeUnit.SECONDS);
-    ClientTransport rt3 = transportInfo.transport;
-    transportInfo.listener.transportReady();
-    verify(rt3, timeout(1000)).newStream(
-        same(method2), any(Metadata.class), same(callOptions2), same(statsTraceCtx2));
-
-    verify(rt1, times(0)).newStream(any(MethodDescriptor.class), any(Metadata.class));
-    // Back-off policy was never consulted.
-    verify(mockBackoffPolicy, times(0)).nextBackoffMillis();
-    verifyNoMoreInteractions(mockTransportFactory);
-    // NameResolver was refreshed only once
-    verify(mockNameResolver).refresh();
-  }
-
-  @Test
-  public void reconnectWithBackoff() throws Exception {
-    SocketAddress addr1 = mock(SocketAddress.class);
-    SocketAddress addr2 = mock(SocketAddress.class);
-    EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(Arrays.asList(addr1, addr2));
-
-    // Invocation counters
-    int transportsAddr1 = 0;
-    int transportsAddr2 = 0;
-    int backoffConsulted = 0;
-    int backoffReset = 0;
-    int nameResolverRefresh = 0;
-
-    // First pick succeeds
-    ClientTransport t1 = tm.getTransport(addressGroup);
-    assertNotNull(t1);
-    verify(mockTransportFactory, timeout(1000).times(++transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    // Back-off policy was unset initially.
-    verify(mockBackoffPolicyProvider, times(backoffReset)).get();
-    MockClientTransportInfo transportInfo = transports.poll(1, TimeUnit.SECONDS);
-    verify(mockNameResolver, times(nameResolverRefresh)).refresh();
-    transportInfo.listener.transportReady();
-    // Then close it
-    transportInfo.listener.transportShutdown(Status.UNAVAILABLE);
-    verify(mockNameResolver, times(++nameResolverRefresh)).refresh();
-
-    // Second pick fails. This is the beginning of a series of failures.
-    ClientTransport t2 = tm.getTransport(addressGroup);
-    assertNotNull(t2);
-    verify(mockTransportFactory, timeout(1000).times(++transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    // Back-off policy was not reset.
-    verify(mockBackoffPolicyProvider, times(backoffReset)).get();
-    transports.poll(1, TimeUnit.SECONDS).listener.transportShutdown(Status.UNAVAILABLE);
-    verify(mockNameResolver, times(nameResolverRefresh)).refresh();
-
-    // Third pick fails too
-    ClientTransport t3 = tm.getTransport(addressGroup);
-    assertNotNull(t3);
-    verify(mockTransportFactory, timeout(1000).times(++transportsAddr2))
-        .newClientTransport(addr2, AUTHORITY, USER_AGENT);
-    // Back-off policy was not reset.
-    verify(mockBackoffPolicyProvider, times(backoffReset)).get();
-    transports.poll(1, TimeUnit.SECONDS).listener.transportShutdown(Status.UNAVAILABLE);
-    verify(mockNameResolver, times(++nameResolverRefresh)).refresh();
-
-    // Forth pick is on the first address, back-off policy kicks in.
-    ClientTransport t4 = tm.getTransport(addressGroup);
-    assertNotNull(t4);
-    // If backoff's DelayedTransport is still active, this is necessary. Otherwise it would be racy.
-    t4.newStream(method, new Metadata(), CallOptions.DEFAULT.withWaitForReady(), statsTraceCtx);
-    verify(mockTransportFactory, timeout(1000).times(++transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    // Back-off policy was reset and consulted.
-    verify(mockBackoffPolicyProvider, times(++backoffReset)).get();
-    verify(mockBackoffPolicy, times(++backoffConsulted)).nextBackoffMillis();
-    verify(mockNameResolver, times(nameResolverRefresh)).refresh();
-  }
-
-  @Test
-  public void createFailingTransport() {
-    Status error = Status.UNAVAILABLE.augmentDescription("simulated");
-    FailingClientTransport transport = (FailingClientTransport) tm.createFailingTransport(error);
-    assertSame(error, transport.error);
-  }
-
-  @Test
-  public void createInterimTransport() {
-    InterimTransport<ClientTransport> interimTransport = tm.createInterimTransport();
-    ClientTransport transport = interimTransport.transport();
-    assertTrue(transport instanceof DelayedClientTransport);
-    ClientStream s1 = transport.newStream(method, new Metadata());
-    ClientStreamListener sl1 = mock(ClientStreamListener.class);
-    s1.start(sl1);
-
-    // Shutting down the channel will shutdown the interim transport, thus refusing further streams,
-    // but will continue existing streams.
-    channel.shutdown();
-    ClientStream s2 = transport.newStream(method, new Metadata());
-    ClientStreamListener sl2 = mock(ClientStreamListener.class);
-    s2.start(sl2);
-    verify(sl2).closed(any(Status.class), any(Metadata.class));
-    verify(sl1, times(0)).closed(any(Status.class), any(Metadata.class));
-    assertFalse(channel.isTerminated());
-
-    // After channel has shut down, createInterimTransport() will get you a transport that has
-    // already set error.
-    ClientTransport transportAfterShutdown = tm.createInterimTransport().transport();
-    ClientStream s3 = transportAfterShutdown.newStream(method, new Metadata());
-    ClientStreamListener sl3 = mock(ClientStreamListener.class);
-    s3.start(sl3);
-    verify(sl3).closed(any(Status.class), any(Metadata.class));
-
-    // Closing the interim transport with error will terminate the interim transport, which in turn
-    // allows channel to terminate.
-    interimTransport.closeWithError(Status.UNAVAILABLE);
-    verify(sl1).closed(same(Status.UNAVAILABLE), any(Metadata.class));
-    assertTrue(channel.isTerminated());
-  }
-
-  @Test
-  public void createOobTransportProvider() throws Exception {
-    SocketAddress addr = mock(SocketAddress.class);
-    EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(addr);
-    String oobAuthority = "oobauthority";
-
-    OobTransportProvider<ClientTransport> p1 =
-        tm.createOobTransportProvider(addressGroup, oobAuthority);
-    ClientTransport t1 = p1.get();
-    assertNotNull(t1);
-    assertSame(t1, p1.get());
-    verify(mockTransportFactory, timeout(1000)).newClientTransport(addr, oobAuthority, USER_AGENT);
-    MockClientTransportInfo transportInfo1 = transports.poll(1, TimeUnit.SECONDS);
-
-    // OOB transport providers are not indexed by addresses, thus each time it creates
-    // a new provider.
-    OobTransportProvider<ClientTransport> p2 =
-        tm.createOobTransportProvider(addressGroup, oobAuthority);
-    assertNotSame(p1, p2);
-    ClientTransport t2 = p2.get();
-    verify(mockTransportFactory, timeout(1000).times(2))
-        .newClientTransport(addr, oobAuthority, USER_AGENT);
-    assertNotSame(t1, t2);
-    MockClientTransportInfo transportInfo2 = transports.poll(1, TimeUnit.SECONDS);
-    assertNotSame(transportInfo1.transport, transportInfo2.transport);
-
-    // Closing the OobTransportProvider will shutdown the transport
-    p1.close();
-    verify(transportInfo1.transport).shutdown();
-    transportInfo1.listener.transportTerminated();
-
-    channel.shutdown();
-    verify(transportInfo2.transport).shutdown();
-
-    OobTransportProvider<ClientTransport> p3 =
-        tm.createOobTransportProvider(addressGroup, oobAuthority);
-    assertTrue(p3.get() instanceof FailingClientTransport);
-
-    p2.close();
-
-    // The channel will not be terminated until all OOB transports are terminated.
-    assertFalse(channel.isTerminated());
-    transportInfo2.listener.transportTerminated();
-    assertTrue(channel.isTerminated());
-  }
-
-  @Test
-  public void interimTransportShutdownNow() {
-    InterimTransport<ClientTransport> interimTransport = tm.createInterimTransport();
-    ClientTransport transport = interimTransport.transport();
-    assertTrue(transport instanceof DelayedClientTransport);
-    ClientStream s1 = transport.newStream(method, new Metadata());
-    ClientStreamListener sl1 = mock(ClientStreamListener.class);
-    s1.start(sl1);
-
-    // Shutting down the channel will shutdownNow the interim transport, thus kill existing streams.
-    channel.shutdownNow();
-    verify(sl1).closed(any(Status.class), any(Metadata.class));
-    assertTrue(channel.isShutdown());
-    assertTrue(channel.isTerminated());
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelOrphanWrapperTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelOrphanWrapperTest.java
new file mode 100644
index 00000000000..5ae97c69211
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelOrphanWrapperTest.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.testing.GcFinalization;
+import com.google.common.testing.GcFinalization.FinalizationPredicate;
+import io.grpc.CallOptions;
+import io.grpc.ClientCall;
+import io.grpc.ManagedChannel;
+import io.grpc.MethodDescriptor;
+import io.grpc.internal.ManagedChannelOrphanWrapper.ManagedChannelReference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Filter;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class ManagedChannelOrphanWrapperTest {
+  @Test
+  public void orphanedChannelsAreLogged() {
+    ManagedChannel mc = new TestManagedChannel();
+    String channelString = mc.toString();
+    final ReferenceQueue<ManagedChannelOrphanWrapper> refqueue =
+        new ReferenceQueue<>();
+    ConcurrentMap<ManagedChannelReference, ManagedChannelReference> refs =
+        new ConcurrentHashMap<>();
+
+    assertEquals(0, refs.size());
+    @SuppressWarnings("UnusedVariable")
+    ManagedChannelOrphanWrapper channel = new ManagedChannelOrphanWrapper(mc, refqueue, refs);
+    assertEquals(1, refs.size());
+
+    // Try to capture the log output but without causing terminal noise.  Adding the filter must
+    // be done before clearing the ref or else it might be missed.
+    final List<LogRecord> records = new ArrayList<>(1);
+    Logger orphanLogger = Logger.getLogger(ManagedChannelOrphanWrapper.class.getName());
+    Filter oldFilter = orphanLogger.getFilter();
+    orphanLogger.setFilter(new Filter() {
+
+      @Override
+      public boolean isLoggable(LogRecord record) {
+        synchronized (records) {
+          records.add(record);
+        }
+        return false;
+      }
+    });
+
+    try {
+      channel = null;
+      final AtomicInteger numOrphans = new AtomicInteger();
+      GcFinalization.awaitDone(
+          new FinalizationPredicate() {
+            @Override
+            public boolean isDone() {
+              numOrphans.getAndAdd(ManagedChannelReference.cleanQueue(refqueue));
+              return numOrphans.get() > 0;
+            }
+          });
+      assertEquals("unexpected extra orphans", 1, numOrphans.get());
+
+      LogRecord lr;
+      synchronized (records) {
+        assertEquals(1, records.size());
+        lr = records.get(0);
+      }
+      assertThat(lr.getMessage()).contains("shutdown");
+      assertThat(lr.getParameters()).asList().containsExactly(channelString).inOrder();
+      assertEquals(Level.SEVERE, lr.getLevel());
+      assertEquals(0, refs.size());
+    } finally {
+      orphanLogger.setFilter(oldFilter);
+    }
+  }
+
+  @Test
+  public void refCycleIsGCed() {
+    ReferenceQueue<ManagedChannelOrphanWrapper> refqueue =
+        new ReferenceQueue<>();
+    ConcurrentMap<ManagedChannelReference, ManagedChannelReference> refs =
+        new ConcurrentHashMap<>();
+    @SuppressWarnings("UnusedVariable")
+    ApplicationWithChannelRef app = new ApplicationWithChannelRef();
+    @SuppressWarnings("UnusedVariable")
+    ChannelWithApplicationRef channelImpl = new ChannelWithApplicationRef();
+    @SuppressWarnings("UnusedVariable")
+    ManagedChannelOrphanWrapper channel =
+        new ManagedChannelOrphanWrapper(channelImpl, refqueue, refs);
+    app.channel = channel;
+    channelImpl.application = app;
+    WeakReference<ApplicationWithChannelRef> appWeakRef =
+        new WeakReference<>(app);
+
+    // Simulate the application and channel going out of scope. A ref cycle between app and
+    // channel remains, so ensure that our tracking of orphaned channels does not prevent this
+    // reference cycle from being GCed.
+    channel = null;
+    app = null;
+    channelImpl = null;
+
+    GcFinalization.awaitClear(appWeakRef);
+  }
+
+  private static class TestManagedChannel extends ManagedChannel {
+    @Override
+    public ManagedChannel shutdown() {
+      return null;
+    }
+
+    @Override
+    public boolean isShutdown() {
+      return false;
+    }
+
+    @Override
+    public boolean isTerminated() {
+      return false;
+    }
+
+    @Override
+    public ManagedChannel shutdownNow() {
+      return null;
+    }
+
+    @Override
+    public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+      return false;
+    }
+
+    @Override
+    public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+        MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+      return null;
+    }
+
+    @Override
+    public String authority() {
+      return null;
+    }
+  }
+
+  private static final class ApplicationWithChannelRef {
+    @SuppressWarnings("UnusedVariable")
+    private ManagedChannel channel;
+  }
+
+  private static final class ChannelWithApplicationRef extends TestManagedChannel {
+    @SuppressWarnings("UnusedVariable")
+    private ApplicationWithChannelRef application;
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ManagedChannelServiceConfigTest.java b/core/src/test/java/io/grpc/internal/ManagedChannelServiceConfigTest.java
new file mode 100644
index 00000000000..fefc37e4fdc
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ManagedChannelServiceConfigTest.java
@@ -0,0 +1,301 @@
+/*
+ * 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.MethodDescriptor.MethodType.UNARY;
+import static io.grpc.Status.Code.UNAVAILABLE;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.CallOptions;
+import io.grpc.InternalConfigSelector;
+import io.grpc.InternalConfigSelector.Result;
+import io.grpc.LoadBalancer.PickDetailsConsumer;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.internal.ManagedChannelServiceConfig.MethodInfo;
+import io.grpc.testing.TestMethodDescriptors;
+import java.util.Collections;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ManagedChannelServiceConfigTest {
+
+  @Test
+  public void managedChannelServiceConfig_shouldParseHealthCheckingConfig() throws Exception {
+    Map<String, ?> rawServiceConfig =
+        parseConfig(
+            "{\"healthCheckConfig\": "
+                + "{\"serviceName\": \"COVID-19\", "
+                + "\"description\": \"I can't visit korea, because of you\"}}");
+    ManagedChannelServiceConfig mcsc =
+        ManagedChannelServiceConfig.fromServiceConfig(rawServiceConfig, true, 3, 4, null);
+    Map<String, ?> healthCheckingConfig = mcsc.getHealthCheckingConfig();
+    assertThat(healthCheckingConfig).isNotNull();
+    assertThat(healthCheckingConfig)
+        .containsExactly(
+            "serviceName", "COVID-19", "description", "I can't visit korea, because of you");
+  }
+
+  @Test
+  public void managedChannelServiceConfig_shouldHandleNoHealthCheckingConfig() throws Exception {
+    ManagedChannelServiceConfig mcsc =
+        ManagedChannelServiceConfig
+            .fromServiceConfig(Collections.<String, Object>emptyMap(), true, 3, 4, null);
+
+    assertThat(mcsc.getHealthCheckingConfig()).isNull();
+  }
+
+  @Test
+  public void createManagedChannelServiceConfig_failsOnDuplicateMethod() {
+    Map<String, ?> name1 = ImmutableMap.of("service", "service", "method", "method");
+    Map<String, ?> name2 = ImmutableMap.of("service", "service", "method", "method");
+    Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name1, name2));
+    Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
+
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
+    assertThat(e).hasMessageThat().isEqualTo("Duplicate method name service/method");
+  }
+
+  @Test
+  public void createManagedChannelServiceConfig_failsOnDuplicateService() {
+    Map<String, ?> name1 = ImmutableMap.of("service", "service");
+    Map<String, ?> name2 = ImmutableMap.of("service", "service");
+    Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name1, name2));
+    Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
+
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
+    assertThat(e).hasMessageThat().isEqualTo("Duplicate service service");
+  }
+
+  @Test
+  public void createManagedChannelServiceConfig_failsOnDuplicateServiceMultipleConfig() {
+    Map<String, ?> name1 = ImmutableMap.of("service", "service");
+    Map<String, ?> name2 = ImmutableMap.of("service", "service");
+    Map<String, ?> methodConfig1 = ImmutableMap.of("name", ImmutableList.of(name1));
+    Map<String, ?> methodConfig2 = ImmutableMap.of("name", ImmutableList.of(name2));
+    Map<String, ?> serviceConfig =
+        ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig1, methodConfig2));
+
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
+    assertThat(e).hasMessageThat().isEqualTo("Duplicate service service");
+  }
+
+  @Test
+  public void createManagedChannelServiceConfig_failsOnMethodNameWithEmptyServiceName() {
+    Map<String, ?> name = ImmutableMap.of("service", "", "method", "method1");
+    Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name));
+    Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
+
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
+    assertThat(e).hasMessageThat().isEqualTo("missing service name for method method1");
+  }
+
+  @Test
+  public void createManagedChannelServiceConfig_failsOnMethodNameWithoutServiceName() {
+    Map<String, ?> name = ImmutableMap.of("method", "method1");
+    Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name));
+    Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
+
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
+    assertThat(e).hasMessageThat().isEqualTo("missing service name for method method1");
+  }
+
+  @Test
+  public void createManagedChannelServiceConfig_failsOnMissingServiceName() {
+    Map<String, ?> name = ImmutableMap.of("method", "method");
+    Map<String, ?> methodConfig = ImmutableMap.of("name", ImmutableList.of(name));
+    Map<String, ?> serviceConfig = ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
+
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> ManagedChannelServiceConfig.fromServiceConfig(serviceConfig, true, 3, 4, null));
+    assertThat(e).hasMessageThat().isEqualTo("missing service name for method method");
+  }
+
+  @Test
+  public void managedChannelServiceConfig_parseMethodConfig() {
+    Map<String, ?> name1 = ImmutableMap.of("service", "service1", "method", "method1");
+    Map<String, ?> name2 = ImmutableMap.of("service", "service2");
+    Map<String, ?> methodConfig = ImmutableMap.of(
+        "name", ImmutableList.of(name1, name2),
+        "timeout", "1.234s",
+        "retryPolicy",
+        ImmutableMap.builder()
+            .put("maxAttempts", 3.0D)
+            .put("initialBackoff", "1s")
+            .put("maxBackoff", "10s")
+            .put("backoffMultiplier", 1.5D)
+            .put("perAttemptRecvTimeout", "2.5s")
+            .put("retryableStatusCodes", ImmutableList.of("UNAVAILABLE"))
+            .buildOrThrow());
+    Map<String, ?> defaultMethodConfig = ImmutableMap.of(
+        "name", ImmutableList.of(ImmutableMap.of()),
+        "timeout", "4.321s");
+    Map<String, ?> rawServiceConfig =
+        ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig, defaultMethodConfig));
+
+    // retry disabled
+    ManagedChannelServiceConfig serviceConfig =
+        ManagedChannelServiceConfig.fromServiceConfig(rawServiceConfig, false, 0, 0, null);
+    MethodInfo methodInfo = serviceConfig.getMethodConfig(methodForName("service1", "method1"));
+    assertThat(methodInfo.timeoutNanos).isEqualTo(MILLISECONDS.toNanos(1234));
+    assertThat(methodInfo.retryPolicy).isNull();
+    methodInfo = serviceConfig.getMethodConfig(methodForName("service1", "methodX"));
+    assertThat(methodInfo.timeoutNanos).isEqualTo(MILLISECONDS.toNanos(4321));
+    assertThat(methodInfo.retryPolicy).isNull();
+    methodInfo = serviceConfig.getMethodConfig(methodForName("service2", "methodX"));
+    assertThat(methodInfo.timeoutNanos).isEqualTo(MILLISECONDS.toNanos(1234));
+    assertThat(methodInfo.retryPolicy).isNull();
+
+    // retry enabled
+    serviceConfig =
+        ManagedChannelServiceConfig.fromServiceConfig(rawServiceConfig, true, 2, 0, null);
+    methodInfo = serviceConfig.getMethodConfig(methodForName("service1", "method1"));
+    assertThat(methodInfo.timeoutNanos).isEqualTo(MILLISECONDS.toNanos(1234));
+    assertThat(methodInfo.retryPolicy.maxAttempts).isEqualTo(2);
+    assertThat(methodInfo.retryPolicy.perAttemptRecvTimeoutNanos)
+        .isEqualTo(MILLISECONDS.toNanos(2500));
+    assertThat(methodInfo.retryPolicy.retryableStatusCodes).containsExactly(UNAVAILABLE);
+    methodInfo = serviceConfig.getMethodConfig(methodForName("service1", "methodX"));
+    assertThat(methodInfo.timeoutNanos).isEqualTo(MILLISECONDS.toNanos(4321));
+    assertThat(methodInfo.retryPolicy).isNull();
+  }
+
+  @Test
+  public void getDefaultConfigSelectorFromConfig() {
+    Map<String, ?> name = ImmutableMap.of("service", "service1", "method", "method1");
+    Map<String, ?> methodConfig = ImmutableMap.of(
+        "name", ImmutableList.of(name), "timeout", "1.234s");
+    Map<String, ?> rawServiceConfig =
+        ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
+    ManagedChannelServiceConfig serviceConfig =
+        ManagedChannelServiceConfig.fromServiceConfig(rawServiceConfig, false, 0, 0, null);
+    InternalConfigSelector configSelector = serviceConfig.getDefaultConfigSelector();
+    MethodDescriptor<?, ?> method = methodForName("service1", "method1");
+    Result result = configSelector.selectConfig(
+        new PickSubchannelArgsImpl(
+            method, new Metadata(), CallOptions.DEFAULT, new PickDetailsConsumer() {}));
+    MethodInfo methodInfoFromDefaultConfigSelector =
+        ((ManagedChannelServiceConfig) result.getConfig()).getMethodConfig(method);
+    assertThat(methodInfoFromDefaultConfigSelector)
+        .isEqualTo(serviceConfig.getMethodConfig(method));
+  }
+
+  @Test
+  public void retryConfig_emptyRetriableStatusCodesAllowedWithPerAttemptRecvTimeoutGiven() {
+    Map<String, ?> retryPolicy = ImmutableMap.<String, Object>builder()
+        .put("maxAttempts", 3.0D)
+        .put("initialBackoff", "1s")
+        .put("maxBackoff", "10s")
+        .put("backoffMultiplier", 1.5D)
+        .put("perAttemptRecvTimeout", "2.5s")
+        .put("retryableStatusCodes", ImmutableList.of())
+        .buildOrThrow();
+    Map<String, ?> methodConfig = ImmutableMap.of(
+        "name", ImmutableList.of(ImmutableMap.of()), "retryPolicy", retryPolicy);
+    Map<String, ?> rawServiceConfig =
+        ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
+    assertThat(ManagedChannelServiceConfig.fromServiceConfig(rawServiceConfig, true, 5, 5, null))
+        .isNotNull();
+  }
+
+  @Test
+  public void retryConfig_PerAttemptRecvTimeoutUnsetAllowedIfRetryableStatusCodesNonempty() {
+    Map<String, ?> retryPolicy = ImmutableMap.<String, Object>builder()
+        .put("maxAttempts", 3.0D)
+        .put("initialBackoff", "1s")
+        .put("maxBackoff", "10s")
+        .put("backoffMultiplier", 1.5D)
+        .put("retryableStatusCodes", ImmutableList.of("UNAVAILABLE"))
+        .buildOrThrow();
+    Map<String, ?> methodConfig = ImmutableMap.of(
+        "name", ImmutableList.of(ImmutableMap.of()), "retryPolicy", retryPolicy);
+    Map<String, ?> rawServiceConfig =
+        ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
+    assertThat(ManagedChannelServiceConfig.fromServiceConfig(rawServiceConfig, true, 5, 5, null))
+        .isNotNull();
+  }
+
+  @Test
+  public void retryConfig_emptyRetriableStatusCodesNotAllowedWithPerAttemptRecvTimeoutUnset() {
+    Map<String, ?> retryPolicy = ImmutableMap.<String, Object>builder()
+        .put("maxAttempts", 3.0D)
+        .put("initialBackoff", "1s")
+        .put("maxBackoff", "10s")
+        .put("backoffMultiplier", 1.5D)
+        .put("retryableStatusCodes", ImmutableList.of())
+        .buildOrThrow();
+    Map<String, ?> methodConfig = ImmutableMap.of(
+        "name", ImmutableList.of(ImmutableMap.of()), "retryPolicy", retryPolicy);
+    Map<String, ?> rawServiceConfig =
+        ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
+    try {
+      ManagedChannelServiceConfig.fromServiceConfig(rawServiceConfig, true, 5, 5, null);
+      fail("The expected IllegalArgumentException is not thrown");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().contains(
+          "retryableStatusCodes cannot be empty without perAttemptRecvTimeout");
+    }
+  }
+
+  // For now we allow perAttemptRecvTimeout being zero although it does not make sense.
+  // TODO(zdapeng): disallow zero perAttemptRecvTimeout if hedging is not enabled once we support
+  //   hedge_on_per_try_timeout.
+  @Test
+  public void retryConfig_AllowPerAttemptRecvTimeoutZero() {
+    Map<String, ?> retryPolicy = ImmutableMap.<String, Object>builder()
+        .put("maxAttempts", 3.0D)
+        .put("initialBackoff", "1s")
+        .put("maxBackoff", "10s")
+        .put("backoffMultiplier", 1.5D)
+        .put("perAttemptRecvTimeout", "0s")
+        .put("retryableStatusCodes", ImmutableList.of())
+        .buildOrThrow();
+    Map<String, ?> methodConfig = ImmutableMap.of(
+        "name", ImmutableList.of(ImmutableMap.of()), "retryPolicy", retryPolicy);
+    Map<String, ?> rawServiceConfig =
+        ImmutableMap.of("methodConfig", ImmutableList.of(methodConfig));
+    assertThat(ManagedChannelServiceConfig.fromServiceConfig(rawServiceConfig, true, 5, 5, null))
+        .isNotNull();
+  }
+
+  private static MethodDescriptor<?, ?> methodForName(String service, String method) {
+    return MethodDescriptor.<Void, Void>newBuilder()
+        .setFullMethodName(service + "/" + method)
+        .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+        .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
+        .setType(UNARY)
+        .build();
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, Object> parseConfig(String json) throws Exception {
+    return (Map<String, Object>) JsonParser.parse(json);
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ManagedClientTransportTest.java b/core/src/test/java/io/grpc/internal/ManagedClientTransportTest.java
new file mode 100644
index 00000000000..5ddea08131b
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ManagedClientTransportTest.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2024 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.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import io.grpc.Attributes;
+import io.grpc.Status;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ManagedClientTransportTest {
+
+  @Test
+  public void testListener() {
+    ManagedClientTransport.Listener listener = new ManagedClientTransport.Listener() {
+      @Override
+      public void transportShutdown(Status s, DisconnectError e) {}
+
+      @Override
+      public void transportTerminated() {}
+
+      @Override
+      public void transportReady() {}
+
+      @Override
+      public void transportInUse(boolean inUse) {}
+    };
+
+    // Test that the listener methods do not throw.
+    listener.transportShutdown(Status.OK, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    listener.transportTerminated();
+    listener.transportReady();
+    listener.transportInUse(true);
+
+
+    assertNull(listener.filterTransport(null));
+
+    Attributes attributes = Attributes.newBuilder()
+        .set(Attributes.Key.create("yolo"), "To be, or not to be?")
+        .set(Attributes.Key.create("foo"), "bar!")
+        .set(Attributes.Key.create("bar"), "foo?")
+        .build();
+    assertEquals(attributes, listener.filterTransport(attributes));
+  }
+}
\ No newline at end of file
diff --git a/core/src/test/java/io/grpc/internal/MaxConnectionIdleManagerTest.java b/core/src/test/java/io/grpc/internal/MaxConnectionIdleManagerTest.java
new file mode 100644
index 00000000000..4a8a776cd01
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/MaxConnectionIdleManagerTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for {@link MaxConnectionIdleManager}. */
+@RunWith(JUnit4.class)
+public class MaxConnectionIdleManagerTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private final FakeClock fakeClock = new FakeClock();
+  private final MaxConnectionIdleManager.Ticker ticker = new MaxConnectionIdleManager.Ticker() {
+    @Override
+    public long nanoTime() {
+      return fakeClock.getTicker().read();
+    }
+  };
+
+  @Mock
+  private Runnable closure;
+
+  @Test
+  public void maxIdleReached() {
+    MaxConnectionIdleManager maxConnectionIdleManager =
+        new MaxConnectionIdleManager(123L, ticker);
+
+    maxConnectionIdleManager.start(closure, fakeClock.getScheduledExecutorService());
+    maxConnectionIdleManager.onTransportIdle();
+    fakeClock.forwardNanos(123L);
+
+    verify(closure).run();
+  }
+
+  @Test
+  public void maxIdleNotReachedAndReached() {
+    MaxConnectionIdleManager maxConnectionIdleManager =
+        new MaxConnectionIdleManager(123L, ticker);
+
+    maxConnectionIdleManager.start(closure, fakeClock.getScheduledExecutorService());
+    maxConnectionIdleManager.onTransportIdle();
+    fakeClock.forwardNanos(100L);
+    // max idle not reached
+    maxConnectionIdleManager.onTransportActive();
+    maxConnectionIdleManager.onTransportIdle();
+    fakeClock.forwardNanos(100L);
+    // max idle not reached although accumulative idle time exceeds max idle time
+    maxConnectionIdleManager.onTransportActive();
+    fakeClock.forwardNanos(100L);
+
+    verify(closure, never()).run();
+
+    // max idle reached
+    maxConnectionIdleManager.onTransportIdle();
+    fakeClock.forwardNanos(123L);
+
+    verify(closure).run();
+  }
+
+  @Test
+  public void shutdownThenMaxIdleReached() {
+    MaxConnectionIdleManager maxConnectionIdleManager =
+        new MaxConnectionIdleManager(123L, ticker);
+
+    maxConnectionIdleManager.start(closure, fakeClock.getScheduledExecutorService());
+    maxConnectionIdleManager.onTransportIdle();
+    maxConnectionIdleManager.onTransportTermination();
+    fakeClock.forwardNanos(123L);
+
+    verify(closure, never()).run();
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/MessageDeframerTest.java b/core/src/test/java/io/grpc/internal/MessageDeframerTest.java
index 93e0e900c7f..54758bc096f 100644
--- a/core/src/test/java/io/grpc/internal/MessageDeframerTest.java
+++ b/core/src/test/java/io/grpc/internal/MessageDeframerTest.java
@@ -1,41 +1,30 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.truth.Truth.assertThat;
 import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.anyInt;
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
@@ -43,370 +32,511 @@
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 
-import com.google.common.base.Charsets;
 import com.google.common.io.ByteStreams;
 import com.google.common.primitives.Bytes;
-import com.google.instrumentation.stats.RpcConstants;
 import io.grpc.Codec;
-import io.grpc.Status;
+import io.grpc.InternalChannelz.TransportStats;
 import io.grpc.StatusRuntimeException;
+import io.grpc.StreamTracer;
 import io.grpc.internal.MessageDeframer.Listener;
 import io.grpc.internal.MessageDeframer.SizeEnforcingInputStream;
-import io.grpc.internal.testing.StatsTestUtils.FakeStatsContextFactory;
-import io.grpc.internal.testing.StatsTestUtils.MetricsRecord;
+import io.grpc.internal.testing.TestStreamTracer.TestBaseStreamTracer;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.TimeUnit;
 import java.util.zip.GZIPOutputStream;
-import org.junit.Rule;
+import org.junit.Before;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.experimental.runners.Enclosed;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
 /**
  * Tests for {@link MessageDeframer}.
  */
-@RunWith(JUnit4.class)
+@RunWith(Enclosed.class)
 public class MessageDeframerTest {
-  @Rule public final ExpectedException thrown = ExpectedException.none();
-
-  private Listener listener = mock(Listener.class);
-  private final FakeStatsContextFactory statsCtxFactory = new FakeStatsContextFactory();
-  // MessageFramerTest tests with a server-side StatsTraceContext, so here we test with a
-  // client-side StatsTraceContext.
-  private StatsTraceContext statsTraceCtx = StatsTraceContext.newClientContext(
-      "service/method", statsCtxFactory, GrpcUtil.STOPWATCH_SUPPLIER);
-
-  private MessageDeframer deframer = new MessageDeframer(listener, Codec.Identity.NONE,
-      DEFAULT_MAX_MESSAGE_SIZE, statsTraceCtx, "test");
-
-  private ArgumentCaptor<InputStream> messages = ArgumentCaptor.forClass(InputStream.class);
-
-  @Test
-  public void simplePayload() {
-    deframer.request(1);
-    deframer.deframe(buffer(new byte[] {0, 0, 0, 0, 2, 3, 14}), false);
-    verify(listener).messageRead(messages.capture());
-    assertEquals(Bytes.asList(new byte[]{3, 14}), bytes(messages));
-    verify(listener, atLeastOnce()).bytesRead(anyInt());
-    verifyNoMoreInteractions(listener);
-    checkStats(2, 2);
-  }
 
-  @Test
-  public void smallCombinedPayloads() {
-    deframer.request(2);
-    deframer.deframe(buffer(new byte[] {0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 2, 14, 15}), false);
-    verify(listener, times(2)).messageRead(messages.capture());
-    List<InputStream> streams = messages.getAllValues();
-    assertEquals(2, streams.size());
-    assertEquals(Bytes.asList(new byte[] {3}), bytes(streams.get(0)));
-    verify(listener, atLeastOnce()).bytesRead(anyInt());
-    assertEquals(Bytes.asList(new byte[] {14, 15}), bytes(streams.get(1)));
-    verifyNoMoreInteractions(listener);
-    checkStats(3, 3);
-  }
-
-  @Test
-  public void endOfStreamWithPayloadShouldNotifyEndOfStream() {
-    deframer.request(1);
-    deframer.deframe(buffer(new byte[] {0, 0, 0, 0, 1, 3}), true);
-    verify(listener).messageRead(messages.capture());
-    assertEquals(Bytes.asList(new byte[] {3}), bytes(messages));
-    verify(listener).endOfStream();
-    verify(listener, atLeastOnce()).bytesRead(anyInt());
-    verifyNoMoreInteractions(listener);
-    checkStats(1, 1);
-  }
+  @RunWith(Parameterized.class)
+  public static class WithAndWithoutFullStreamCompressionTests {
+
+    /**
+     * Auto called by test.
+     */
+    @Parameters(name = "{index}: useGzipInflatingBuffer={0}")
+    public static Collection<Object[]> data() {
+      return Arrays.asList(new Object[][]{
+              {false}, {true}
+      });
+    }
 
-  @Test
-  public void endOfStreamShouldNotifyEndOfStream() {
-    deframer.deframe(buffer(new byte[0]), true);
-    verify(listener).endOfStream();
-    verifyNoMoreInteractions(listener);
-    checkStats(0, 0);
-  }
+    private final FakeClock fakeClock = new FakeClock();
+
+    @Parameter // Automatically set by test runner, must be public
+    public boolean useGzipInflatingBuffer;
+
+    private Listener listener = mock(Listener.class);
+    private TestBaseStreamTracer tracer = new TestBaseStreamTracer();
+    private StatsTraceContext statsTraceCtx = new StatsTraceContext(new StreamTracer[]{tracer});
+    private TransportTracer transportTracer =
+        new TransportTracer.Factory(fakeClock.getTimeProvider()).create();
+
+    private MessageDeframer deframer = new MessageDeframer(listener, Codec.Identity.NONE,
+            DEFAULT_MAX_MESSAGE_SIZE, statsTraceCtx, transportTracer);
+
+    private ArgumentCaptor<StreamListener.MessageProducer> producer =
+            ArgumentCaptor.forClass(StreamListener.MessageProducer.class);
+
+    @Before
+    public void setUp() {
+      if (useGzipInflatingBuffer) {
+        deframer.setFullStreamDecompressor(new GzipInflatingBuffer() {
+          @Override
+          public void addGzippedBytes(ReadableBuffer buffer) {
+            try {
+              ByteArrayOutputStream gzippedOutputStream = new ByteArrayOutputStream();
+              OutputStream gzipCompressingStream = new GZIPOutputStream(
+                      gzippedOutputStream);
+              buffer.readBytes(gzipCompressingStream, buffer.readableBytes());
+              gzipCompressingStream.close();
+              super.addGzippedBytes(ReadableBuffers.wrap(gzippedOutputStream.toByteArray()));
+            } catch (IOException e) {
+              throw new RuntimeException(e);
+            }
+          }
+        });
+      }
+    }
 
-  @Test
-  public void payloadSplitBetweenBuffers() {
-    deframer.request(1);
-    deframer.deframe(buffer(new byte[] {0, 0, 0, 0, 7, 3, 14, 1, 5, 9}), false);
-    verify(listener, atLeastOnce()).bytesRead(anyInt());
-    verifyNoMoreInteractions(listener);
-    deframer.deframe(buffer(new byte[] {2, 6}), false);
-    verify(listener).messageRead(messages.capture());
-    assertEquals(Bytes.asList(new byte[] {3, 14, 1, 5, 9, 2, 6}), bytes(messages));
-    verify(listener, atLeastOnce()).bytesRead(anyInt());
-    assertTrue(deframer.isStalled());
-    verifyNoMoreInteractions(listener);
-    checkStats(7, 7);
-  }
+    @Test
+    public void simplePayload() {
+      deframer.request(1);
+      fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+      deframer.deframe(buffer(new byte[]{0, 0, 0, 0, 2, 3, 14}));
+      verify(listener).messagesAvailable(producer.capture());
+      assertEquals(Bytes.asList(new byte[]{3, 14}), bytes(producer.getValue().next()));
+      verify(listener, atLeastOnce()).bytesRead(anyInt());
+      verifyNoMoreInteractions(listener);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, useGzipInflatingBuffer, 2, 2);
+    }
 
-  @Test
-  public void frameHeaderSplitBetweenBuffers() {
-    deframer.request(1);
-
-    deframer.deframe(buffer(new byte[] {0, 0}), false);
-    verify(listener, atLeastOnce()).bytesRead(anyInt());
-    verifyNoMoreInteractions(listener);
-    deframer.deframe(buffer(new byte[] {0, 0, 1, 3}), false);
-    verify(listener).messageRead(messages.capture());
-    assertEquals(Bytes.asList(new byte[] {3}), bytes(messages));
-    verify(listener, atLeastOnce()).bytesRead(anyInt());
-    assertTrue(deframer.isStalled());
-    verifyNoMoreInteractions(listener);
-    checkStats(1, 1);
-  }
+    @Test
+    public void smallCombinedPayloads() {
+      deframer.request(2);
+      fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+      deframer.deframe(buffer(new byte[]{0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 2, 14, 15}));
+      verify(listener, times(2)).messagesAvailable(producer.capture());
+      List<StreamListener.MessageProducer> streams = producer.getAllValues();
+      assertEquals(2, streams.size());
+      assertEquals(Bytes.asList(new byte[]{3}), bytes(streams.get(0).next()));
+      verify(listener, atLeastOnce()).bytesRead(anyInt());
+      assertEquals(Bytes.asList(new byte[]{14, 15}), bytes(streams.get(1).next()));
+      verifyNoMoreInteractions(listener);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, useGzipInflatingBuffer, 1, 1, 2, 2);
+    }
 
-  @Test
-  public void emptyPayload() {
-    deframer.request(1);
-    deframer.deframe(buffer(new byte[] {0, 0, 0, 0, 0}), false);
-    verify(listener).messageRead(messages.capture());
-    assertEquals(Bytes.asList(), bytes(messages));
-    verify(listener, atLeastOnce()).bytesRead(anyInt());
-    verifyNoMoreInteractions(listener);
-    checkStats(0, 0);
-  }
+    @Test
+    public void endOfStreamWithPayloadShouldNotifyEndOfStream() {
+      deframer.request(1);
+      fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+      deframer.deframe(buffer(new byte[]{0, 0, 0, 0, 1, 3}));
+      deframer.closeWhenComplete();
+      verify(listener).messagesAvailable(producer.capture());
+      assertEquals(Bytes.asList(new byte[]{3}), bytes(producer.getValue().next()));
+      verify(listener).deframerClosed(false);
+      verify(listener, atLeastOnce()).bytesRead(anyInt());
+      verifyNoMoreInteractions(listener);
+      checkStats(tracer, transportTracer.getStats(), fakeClock,  useGzipInflatingBuffer, 1, 1);
+    }
 
-  @Test
-  public void largerFrameSize() {
-    deframer.request(1);
-    deframer.deframe(ReadableBuffers.wrap(
-        Bytes.concat(new byte[] {0, 0, 0, 3, (byte) 232}, new byte[1000])), false);
-    verify(listener).messageRead(messages.capture());
-    assertEquals(Bytes.asList(new byte[1000]), bytes(messages));
-    verify(listener, atLeastOnce()).bytesRead(anyInt());
-    verifyNoMoreInteractions(listener);
-    checkStats(1000, 1000);
-  }
+    @Test
+    public void endOfStreamShouldNotifyEndOfStream() {
+      fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+      deframer.deframe(buffer(new byte[0]));
+      deframer.closeWhenComplete();
+      deframer.request(1);
+      if (useGzipInflatingBuffer) {
+        deframer.request(1); // process the 20-byte empty GZIP stream, to get stalled=true
+        verify(listener, atLeast(1)).bytesRead(anyInt());
+      }
+      verify(listener).deframerClosed(false);
+      verifyNoMoreInteractions(listener);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, false);
+    }
 
-  @Test
-  public void endOfStreamCallbackShouldWaitForMessageDelivery() {
-    deframer.deframe(buffer(new byte[] {0, 0, 0, 0, 1, 3}), true);
-    verifyNoMoreInteractions(listener);
-
-    deframer.request(1);
-    verify(listener).messageRead(messages.capture());
-    assertEquals(Bytes.asList(new byte[] {3}), bytes(messages));
-    verify(listener).endOfStream();
-    verify(listener, atLeastOnce()).bytesRead(anyInt());
-    verifyNoMoreInteractions(listener);
-    checkStats(1, 1);
-  }
+    @Test
+    public void endOfStreamWithPartialMessageShouldNotifyDeframerClosedWithPartialMessage() {
+      deframer.request(1);
+      fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+      deframer.deframe(buffer(new byte[1]));
+      deframer.closeWhenComplete();
+      verify(listener, atLeastOnce()).bytesRead(anyInt());
+      verify(listener).deframerClosed(true);
+      verifyNoMoreInteractions(listener);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, false);
+    }
 
-  @Test
-  public void compressed() {
-    deframer = new MessageDeframer(listener, new Codec.Gzip(), DEFAULT_MAX_MESSAGE_SIZE,
-        statsTraceCtx, "test");
-    deframer.request(1);
-
-    byte[] payload = compress(new byte[1000]);
-    assertTrue(payload.length < 100);
-    byte[] header = new byte[] {1, 0, 0, 0, (byte) payload.length};
-    deframer.deframe(buffer(Bytes.concat(header, payload)), false);
-    verify(listener).messageRead(messages.capture());
-    assertEquals(Bytes.asList(new byte[1000]), bytes(messages));
-    verify(listener, atLeastOnce()).bytesRead(anyInt());
-    verifyNoMoreInteractions(listener);
-    checkStats(payload.length, 1000);
-  }
+    @Test
+    public void endOfStreamWithInvalidGzipBlockShouldNotifyDeframerClosedWithPartialMessage() {
+      assumeTrue("test only valid for full-stream compression", useGzipInflatingBuffer);
+
+      // Create new deframer to allow writing bytes directly to the GzipInflatingBuffer
+      MessageDeframer deframer = new MessageDeframer(listener, Codec.Identity.NONE,
+              DEFAULT_MAX_MESSAGE_SIZE, statsTraceCtx, transportTracer);
+      deframer.setFullStreamDecompressor(new GzipInflatingBuffer());
+      deframer.request(1);
+      fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+      deframer.deframe(buffer(new byte[1]));
+      deframer.closeWhenComplete();
+      verify(listener).deframerClosed(true);
+      verifyNoMoreInteractions(listener);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, false);
+    }
 
-  @Test
-  public void deliverIsReentrantSafe() {
-    doAnswer(new Answer<Void>() {
-      @Override
-      public Void answer(InvocationOnMock invocation) throws Throwable {
-        deframer.request(1);
-        return null;
+    @Test
+    public void payloadSplitBetweenBuffers() {
+      deframer.request(1);
+      fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+      deframer.deframe(buffer(new byte[]{0, 0, 0, 0, 7, 3, 14, 1, 5, 9}));
+      verify(listener, atLeastOnce()).bytesRead(anyInt());
+      verifyNoMoreInteractions(listener);
+      deframer.deframe(buffer(new byte[]{2, 6}));
+      verify(listener).messagesAvailable(producer.capture());
+      assertEquals(
+              Bytes.asList(new byte[]{3, 14, 1, 5, 9, 2, 6}), bytes(producer.getValue().next()));
+      verify(listener, atLeastOnce()).bytesRead(anyInt());
+      verifyNoMoreInteractions(listener);
+
+      if (useGzipInflatingBuffer) {
+        checkStats(
+            tracer,
+            transportTracer.getStats(),
+            fakeClock,
+            true,
+            7 /* msg size */ + 2 /* second buffer adds two bytes of overhead in deflate block */,
+            7);
+      } else {
+        checkStats(tracer, transportTracer.getStats(), fakeClock, false, 7, 7);
       }
-    }).when(listener).messageRead(Matchers.<InputStream>any());
-    deframer.deframe(buffer(new byte[] {0, 0, 0, 0, 1, 3}), true);
-    verifyNoMoreInteractions(listener);
-
-    deframer.request(1);
-    verify(listener).messageRead(messages.capture());
-    assertEquals(Bytes.asList(new byte[] {3}), bytes(messages));
-    verify(listener).endOfStream();
-    verify(listener, atLeastOnce()).bytesRead(anyInt());
-    verifyNoMoreInteractions(listener);
-  }
+    }
 
-  @Test
-  public void sizeEnforcingInputStream_readByteBelowLimit() throws IOException {
-    ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
-    SizeEnforcingInputStream stream =
-        new MessageDeframer.SizeEnforcingInputStream(in, 4, statsTraceCtx, "test");
+    @Test
+    public void frameHeaderSplitBetweenBuffers() {
+      deframer.request(1);
+      fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+      deframer.deframe(buffer(new byte[]{0, 0}));
+      verify(listener, atLeastOnce()).bytesRead(anyInt());
+      verifyNoMoreInteractions(listener);
+      fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+      deframer.deframe(buffer(new byte[]{0, 0, 1, 3}));
+      verify(listener).messagesAvailable(producer.capture());
+      assertEquals(Bytes.asList(new byte[]{3}), bytes(producer.getValue().next()));
+      verify(listener, atLeastOnce()).bytesRead(anyInt());
+      verifyNoMoreInteractions(listener);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, useGzipInflatingBuffer, 1, 1);
+    }
 
-    while (stream.read() != -1) {}
+    @Test
+    public void emptyPayload() {
+      deframer.request(1);
+      deframer.deframe(buffer(new byte[]{0, 0, 0, 0, 0}));
+      verify(listener).messagesAvailable(producer.capture());
+      assertEquals(Bytes.asList(), bytes(producer.getValue().next()));
+      verify(listener, atLeastOnce()).bytesRead(anyInt());
+      verifyNoMoreInteractions(listener);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, useGzipInflatingBuffer, 0, 0);
+    }
 
-    stream.close();
-    // SizeEnforcingInputStream only reports uncompressed bytes
-    checkStats(0, 3);
-  }
+    @Test
+    public void largerFrameSize() {
+      deframer.request(1);
+      fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+      deframer.deframe(ReadableBuffers.wrap(
+              Bytes.concat(new byte[]{0, 0, 0, 3, (byte) 232}, new byte[1000])));
+      verify(listener).messagesAvailable(producer.capture());
+      assertEquals(Bytes.asList(new byte[1000]), bytes(producer.getValue().next()));
+      verify(listener, atLeastOnce()).bytesRead(anyInt());
+      verifyNoMoreInteractions(listener);
+      if (useGzipInflatingBuffer) {
+        checkStats(tracer, transportTracer.getStats(), fakeClock,true,
+            8 /* compressed size */, 1000);
+      } else {
+        checkStats(tracer, transportTracer.getStats(), fakeClock, false, 1000, 1000);
+      }
+    }
 
-  @Test
-  public void sizeEnforcingInputStream_readByteAtLimit() throws IOException {
-    ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
-    SizeEnforcingInputStream stream =
-        new MessageDeframer.SizeEnforcingInputStream(in, 3, statsTraceCtx, "test");
+    @Test
+    public void endOfStreamCallbackShouldWaitForMessageDelivery() {
+      fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+      deframer.deframe(buffer(new byte[]{0, 0, 0, 0, 1, 3}));
+      deframer.closeWhenComplete();
+      verifyNoMoreInteractions(listener);
+
+      deframer.request(1);
+      verify(listener).messagesAvailable(producer.capture());
+      assertEquals(Bytes.asList(new byte[]{3}), bytes(producer.getValue().next()));
+      verify(listener).deframerClosed(false);
+      verify(listener, atLeastOnce()).bytesRead(anyInt());
+      verifyNoMoreInteractions(listener);
+      checkStats(tracer, transportTracer.getStats(), fakeClock, useGzipInflatingBuffer, 1, 1);
+    }
 
-    while (stream.read() != -1) {}
+    @Test
+    public void compressed() {
+      deframer = new MessageDeframer(listener, new Codec.Gzip(), DEFAULT_MAX_MESSAGE_SIZE,
+              statsTraceCtx, transportTracer);
+      deframer.request(1);
+
+      byte[] payload = compress(new byte[1000]);
+      assertTrue(payload.length < 100);
+      byte[] header = new byte[]{1, 0, 0, 0, (byte) payload.length};
+      deframer.deframe(buffer(Bytes.concat(header, payload)));
+      verify(listener).messagesAvailable(producer.capture());
+      assertEquals(Bytes.asList(new byte[1000]), bytes(producer.getValue().next()));
+      verify(listener, atLeastOnce()).bytesRead(anyInt());
+      checkStats(tracer, transportTracer.getStats(), fakeClock, true, 29, 1000);
+      verifyNoMoreInteractions(listener);
+    }
 
-    stream.close();
-    // SizeEnforcingInputStream only reports uncompressed bytes
-    checkStats(0, 3);
+    @Test
+    public void deliverIsReentrantSafe() {
+      doAnswer(
+          new Answer<Void>() {
+            @Override
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+              deframer.request(1);
+              return null;
+            }
+          })
+          .when(listener)
+          .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
+      deframer.deframe(buffer(new byte[]{0, 0, 0, 0, 1, 3}));
+      deframer.closeWhenComplete();
+      verifyNoMoreInteractions(listener);
+
+      deframer.request(1);
+      verify(listener).messagesAvailable(producer.capture());
+      assertEquals(Bytes.asList(new byte[]{3}), bytes(producer.getValue().next()));
+      verify(listener).deframerClosed(false);
+      verify(listener, atLeastOnce()).bytesRead(anyInt());
+      verifyNoMoreInteractions(listener);
+    }
   }
 
-  @Test
-  public void sizeEnforcingInputStream_readByteAboveLimit() throws IOException {
-    ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
-    SizeEnforcingInputStream stream =
-        new MessageDeframer.SizeEnforcingInputStream(in, 2, statsTraceCtx, "test");
-
-    thrown.expect(StatusRuntimeException.class);
-    thrown.expectMessage("INTERNAL: test: Compressed frame exceeds");
+  @RunWith(JUnit4.class)
+  public static class SizeEnforcingInputStreamTests {
 
-    while (stream.read() != -1) {}
+    private TestBaseStreamTracer tracer = new TestBaseStreamTracer();
+    private StatsTraceContext statsTraceCtx = new StatsTraceContext(new StreamTracer[]{tracer});
 
-    // Never run, makes compiler nag go away
-    stream.close();
-  }
+    @Test
+    public void sizeEnforcingInputStream_readByteBelowLimit() throws IOException {
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
+      SizeEnforcingInputStream stream =
+              new MessageDeframer.SizeEnforcingInputStream(in, 4, statsTraceCtx);
 
-  @Test
-  public void sizeEnforcingInputStream_readBelowLimit() throws IOException {
-    ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
-    SizeEnforcingInputStream stream =
-        new MessageDeframer.SizeEnforcingInputStream(in, 4, statsTraceCtx, "test");
-    byte[] buf = new byte[10];
+      while (stream.read() != -1) {
+      }
 
-    int read = stream.read(buf, 0, buf.length);
+      stream.close();
+      checkSizeEnforcingInputStreamStats(tracer, 3);
+    }
 
-    assertEquals(3, read);
-    stream.close();
-    // SizeEnforcingInputStream only reports uncompressed bytes
-    checkStats(0, 3);
-  }
+    @Test
+    public void sizeEnforcingInputStream_readByteAtLimit() throws IOException {
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
+      SizeEnforcingInputStream stream =
+              new MessageDeframer.SizeEnforcingInputStream(in, 3, statsTraceCtx);
 
-  @Test
-  public void sizeEnforcingInputStream_readAtLimit() throws IOException {
-    ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
-    SizeEnforcingInputStream stream =
-        new MessageDeframer.SizeEnforcingInputStream(in, 3, statsTraceCtx, "test");
-    byte[] buf = new byte[10];
+      while (stream.read() != -1) {
+      }
 
-    int read = stream.read(buf, 0, buf.length);
+      stream.close();
+      checkSizeEnforcingInputStreamStats(tracer, 3);
+    }
 
-    assertEquals(3, read);
-    stream.close();
-    // SizeEnforcingInputStream only reports uncompressed bytes
-    checkStats(0, 3);
-  }
+    @Test
+    public void sizeEnforcingInputStream_readByteAboveLimit() throws IOException {
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
+      SizeEnforcingInputStream stream =
+              new MessageDeframer.SizeEnforcingInputStream(in, 2, statsTraceCtx);
+
+      try {
+        StatusRuntimeException e = assertThrows(StatusRuntimeException.class, () -> {
+          while (stream.read() != -1) {
+          }
+        });
+        assertThat(e).hasMessageThat()
+            .isEqualTo("RESOURCE_EXHAUSTED: Decompressed gRPC message exceeds maximum size 2");
+      } finally {
+        stream.close();
+      }
+    }
 
-  @Test
-  public void sizeEnforcingInputStream_readAboveLimit() throws IOException {
-    ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
-    SizeEnforcingInputStream stream =
-        new MessageDeframer.SizeEnforcingInputStream(in, 2, statsTraceCtx, "test");
-    byte[] buf = new byte[10];
+    @Test
+    public void sizeEnforcingInputStream_readBelowLimit() throws IOException {
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
+      SizeEnforcingInputStream stream =
+              new MessageDeframer.SizeEnforcingInputStream(in, 4, statsTraceCtx);
+      byte[] buf = new byte[10];
 
-    thrown.expect(StatusRuntimeException.class);
-    thrown.expectMessage("INTERNAL: test: Compressed frame exceeds");
+      int read = stream.read(buf, 0, buf.length);
 
-    stream.read(buf, 0, buf.length);
+      assertEquals(3, read);
+      stream.close();
+      checkSizeEnforcingInputStreamStats(tracer, 3);
+    }
 
-    // Never called
-    stream.close();
-  }
+    @Test
+    public void sizeEnforcingInputStream_readAtLimit() throws IOException {
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
+      SizeEnforcingInputStream stream =
+              new MessageDeframer.SizeEnforcingInputStream(in, 3, statsTraceCtx);
+      byte[] buf = new byte[10];
 
-  @Test
-  public void sizeEnforcingInputStream_skipBelowLimit() throws IOException {
-    ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
-    SizeEnforcingInputStream stream =
-        new MessageDeframer.SizeEnforcingInputStream(in, 4, statsTraceCtx, "test");
+      int read = stream.read(buf, 0, buf.length);
 
-    long skipped = stream.skip(4);
+      assertEquals(3, read);
+      stream.close();
+      checkSizeEnforcingInputStreamStats(tracer, 3);
+    }
 
-    assertEquals(3, skipped);
+    @Test
+    public void sizeEnforcingInputStream_readAboveLimit() throws IOException {
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
+      SizeEnforcingInputStream stream =
+              new MessageDeframer.SizeEnforcingInputStream(in, 2, statsTraceCtx);
+      byte[] buf = new byte[10];
+
+      try {
+        StatusRuntimeException e = assertThrows(StatusRuntimeException.class,
+            () -> stream.read(buf, 0, buf.length));
+        assertThat(e).hasMessageThat()
+            .isEqualTo("RESOURCE_EXHAUSTED: Decompressed gRPC message exceeds maximum size 2");
+      } finally {
+        stream.close();
+      }
+    }
 
-    stream.close();
-    // SizeEnforcingInputStream only reports uncompressed bytes
-    checkStats(0, 3);
-  }
+    @Test
+    public void sizeEnforcingInputStream_skipBelowLimit() throws IOException {
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
+      SizeEnforcingInputStream stream =
+              new MessageDeframer.SizeEnforcingInputStream(in, 4, statsTraceCtx);
 
-  @Test
-  public void sizeEnforcingInputStream_skipAtLimit() throws IOException {
-    ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
-    SizeEnforcingInputStream stream =
-        new MessageDeframer.SizeEnforcingInputStream(in, 3, statsTraceCtx, "test");
+      long skipped = stream.skip(4);
 
-    long skipped = stream.skip(4);
+      assertEquals(3, skipped);
 
-    assertEquals(3, skipped);
-    stream.close();
-    // SizeEnforcingInputStream only reports uncompressed bytes
-    checkStats(0, 3);
-  }
+      stream.close();
+      checkSizeEnforcingInputStreamStats(tracer, 3);
+    }
 
-  @Test
-  public void sizeEnforcingInputStream_skipAboveLimit() throws IOException {
-    ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
-    SizeEnforcingInputStream stream =
-        new MessageDeframer.SizeEnforcingInputStream(in, 2, statsTraceCtx, "test");
+    @Test
+    public void sizeEnforcingInputStream_skipAtLimit() throws IOException {
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
+      SizeEnforcingInputStream stream =
+              new MessageDeframer.SizeEnforcingInputStream(in, 3, statsTraceCtx);
 
-    thrown.expect(StatusRuntimeException.class);
-    thrown.expectMessage("INTERNAL: test: Compressed frame exceeds");
+      long skipped = stream.skip(4);
 
-    stream.skip(4);
+      assertEquals(3, skipped);
+      stream.close();
+      checkSizeEnforcingInputStreamStats(tracer, 3);
+    }
 
-    // never run
-    stream.close();
-  }
+    @Test
+    public void sizeEnforcingInputStream_skipAboveLimit() throws IOException {
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
+      SizeEnforcingInputStream stream =
+              new MessageDeframer.SizeEnforcingInputStream(in, 2, statsTraceCtx);
+
+      try {
+        StatusRuntimeException e = assertThrows(StatusRuntimeException.class, () -> stream.skip(4));
+        assertThat(e).hasMessageThat()
+            .isEqualTo("RESOURCE_EXHAUSTED: Decompressed gRPC message exceeds maximum size 2");
+      } finally {
+        stream.close();
+      }
+    }
 
-  @Test
-  public void sizeEnforcingInputStream_markReset() throws IOException {
-    ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(Charsets.UTF_8));
-    SizeEnforcingInputStream stream =
-        new MessageDeframer.SizeEnforcingInputStream(in, 3, statsTraceCtx, "test");
-    // stream currently looks like: |foo
-    stream.skip(1); // f|oo
-    stream.mark(10); // any large number will work.
-    stream.skip(2); // foo|
-    stream.reset(); // f|oo
-    long skipped = stream.skip(2); // foo|
-
-    assertEquals(2, skipped);
-    stream.close();
-    // SizeEnforcingInputStream only reports uncompressed bytes
-    checkStats(0, 3);
+    @Test
+    public void sizeEnforcingInputStream_markReset() throws IOException {
+      ByteArrayInputStream in = new ByteArrayInputStream("foo".getBytes(StandardCharsets.UTF_8));
+      SizeEnforcingInputStream stream =
+              new MessageDeframer.SizeEnforcingInputStream(in, 3, statsTraceCtx);
+      // stream currently looks like: |foo
+      stream.skip(1); // f|oo
+      stream.mark(10); // any large number will work.
+      stream.skip(2); // foo|
+      stream.reset(); // f|oo
+      long skipped = stream.skip(2); // foo|
+
+      assertEquals(2, skipped);
+      stream.close();
+      checkSizeEnforcingInputStreamStats(tracer, 3);
+    }
   }
 
-  private void checkStats(long wireBytesReceived, long uncompressedBytesReceived) {
-    statsTraceCtx.callEnded(Status.OK);
-    MetricsRecord record = statsCtxFactory.pollRecord();
-    assertEquals(0, record.getMetricAsLongOrFail(
-            RpcConstants.RPC_CLIENT_REQUEST_BYTES));
-    assertEquals(0, record.getMetricAsLongOrFail(
-            RpcConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
-    assertEquals(wireBytesReceived,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_RESPONSE_BYTES));
-    assertEquals(uncompressedBytesReceived,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_SERVER_REQUEST_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_SERVER_RESPONSE_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES));
+  /**
+   * Verify stats were published through the tracer.
+   *
+   * @param transportStats the transport level stats counters
+   * @param clock the fakeClock to verify timestamp
+   * @param sizes in the format {wire0, uncompressed0, wire1, uncompressed1, ...}
+   */
+  private static void checkStats(
+      TestBaseStreamTracer tracer, TransportStats transportStats, FakeClock clock,
+      boolean compressed, long... sizes) {
+    assertEquals(0, sizes.length % 2);
+    int count = sizes.length / 2;
+    long expectedWireSize = 0;
+    long expectedUncompressedSize = 0;
+    for (int i = 0; i < count; i++) {
+      assertEquals("inboundMessage(" + i + ")", tracer.nextInboundEvent());
+      assertEquals(
+          String.format(Locale.US, "inboundMessageRead(%d, %d, %d)", i, sizes[i * 2],
+              compressed ? -1 : sizes[i * 2 + 1]),
+          tracer.nextInboundEvent());
+      expectedWireSize += sizes[i * 2];
+      expectedUncompressedSize += sizes[i * 2 + 1];
+    }
+    assertNull(tracer.nextInboundEvent());
+    assertNull(tracer.nextOutboundEvent());
+    assertEquals(expectedWireSize, tracer.getInboundWireSize());
+    assertEquals(expectedUncompressedSize, tracer.getInboundUncompressedSize());
+
+    assertEquals(count, transportStats.messagesReceived);
+    if (count > 0) {
+      assertThat(transportStats.lastMessageReceivedTimeNanos)
+          .isEqualTo(clock.getTimeProvider().currentTimeNanos());
+    } else {
+      assertEquals(0L, transportStats.lastMessageReceivedTimeNanos);
+    }
   }
 
-  private static List<Byte> bytes(ArgumentCaptor<InputStream> captor) {
-    return bytes(captor.getValue());
+  private static void checkSizeEnforcingInputStreamStats(
+      TestBaseStreamTracer tracer, long uncompressedSize) {
+    assertNull(tracer.nextInboundEvent());
+    assertNull(tracer.nextOutboundEvent());
+    assertEquals(0, tracer.getInboundWireSize());
+    // SizeEnforcingInputStream only reports uncompressed bytes
+    assertEquals(uncompressedSize, tracer.getInboundUncompressedSize());
   }
 
   private static List<Byte> bytes(InputStream in) {
diff --git a/core/src/test/java/io/grpc/internal/MessageFramerTest.java b/core/src/test/java/io/grpc/internal/MessageFramerTest.java
index 68cb7fc6d14..07f717cb81d 100644
--- a/core/src/test/java/io/grpc/internal/MessageFramerTest.java
+++ b/core/src/test/java/io/grpc/internal/MessageFramerTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -35,57 +20,57 @@
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
 
-import com.google.instrumentation.stats.RpcConstants;
 import io.grpc.Codec;
-import io.grpc.Metadata;
-import io.grpc.Status;
-import io.grpc.internal.testing.StatsTestUtils.FakeStatsContextFactory;
-import io.grpc.internal.testing.StatsTestUtils.MetricsRecord;
+import io.grpc.StreamTracer;
+import io.grpc.internal.testing.TestStreamTracer.TestBaseStreamTracer;
 import java.io.BufferedInputStream;
 import java.io.ByteArrayInputStream;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.Arrays;
+import java.util.Locale;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Captor;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /**
  * Tests for {@link MessageFramer}.
  */
 @RunWith(JUnit4.class)
 public class MessageFramerTest {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
   @Mock
   private MessageFramer.Sink sink;
+
+  private final TestBaseStreamTracer tracer = new TestBaseStreamTracer();
   private MessageFramer framer;
 
   @Captor
   private ArgumentCaptor<ByteWritableBuffer> frameCaptor;
   private BytesWritableBufferAllocator allocator =
       new BytesWritableBufferAllocator(1000, 1000);
-  private FakeStatsContextFactory statsCtxFactory;
   private StatsTraceContext statsTraceCtx;
 
   /** Set up for test. */
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    statsCtxFactory = new FakeStatsContextFactory();
     // MessageDeframerTest tests with a client-side StatsTraceContext, so here we test with a
     // server-side StatsTraceContext.
-    statsTraceCtx = StatsTraceContext.newServerContext(
-        "service/method", statsCtxFactory, new Metadata(), GrpcUtil.STOPWATCH_SUPPLIER);
+    statsTraceCtx = new StatsTraceContext(new StreamTracer[]{tracer});
     framer = new MessageFramer(sink, allocator, statsTraceCtx);
   }
 
@@ -95,7 +80,7 @@ public void simplePayload() {
     verifyNoMoreInteractions(sink);
     framer.flush();
 
-    verify(sink).deliverFrame(toWriteBuffer(new byte[] {0, 0, 0, 0, 2, 3, 14}), false, true);
+    verify(sink).deliverFrame(toWriteBuffer(new byte[] {0, 0, 0, 0, 2, 3, 14}), false, true, 1);
     assertEquals(1, allocator.allocCount);
     verifyNoMoreInteractions(sink);
     checkStats(2, 2);
@@ -106,8 +91,8 @@ public void simpleUnknownLengthPayload() {
     writeUnknownLength(framer, new byte[]{3, 14});
     framer.flush();
     // Header is written first, then payload
-    verify(sink).deliverFrame(toWriteBuffer(new byte[] {0, 0, 0, 0, 2}), false, false);
-    verify(sink).deliverFrame(toWriteBuffer(new byte[] {3, 14}), false, true);
+    verify(sink).deliverFrame(toWriteBuffer(new byte[] {0, 0, 0, 0, 2}), false, false, 0);
+    verify(sink).deliverFrame(toWriteBuffer(new byte[] {3, 14}), false, true, 1);
     assertEquals(2, allocator.allocCount);
     verifyNoMoreInteractions(sink);
     checkStats(2, 2);
@@ -121,10 +106,10 @@ public void smallPayloadsShouldBeCombined() {
     verifyNoMoreInteractions(sink);
     framer.flush();
     verify(sink).deliverFrame(
-        toWriteBuffer(new byte[] {0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 1, 14}), false, true);
+        toWriteBuffer(new byte[] {0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 1, 14}), false, true, 2);
     verifyNoMoreInteractions(sink);
     assertEquals(1, allocator.allocCount);
-    checkStats(2, 2);
+    checkStats(1, 1, 1, 1);
   }
 
   @Test
@@ -133,7 +118,7 @@ public void closeCombinedWithFullSink() {
     verifyNoMoreInteractions(sink);
     framer.close();
     verify(sink).deliverFrame(
-        toWriteBuffer(new byte[] {0, 0, 0, 0, 7, 3, 14, 1, 5, 9, 2, 6}), true, true);
+        toWriteBuffer(new byte[] {0, 0, 0, 0, 7, 3, 14, 1, 5, 9, 2, 6}), true, true, 1);
     verifyNoMoreInteractions(sink);
     assertEquals(1, allocator.allocCount);
     checkStats(7, 7);
@@ -142,10 +127,10 @@ public void closeCombinedWithFullSink() {
   @Test
   public void closeWithoutBufferedFrameGivesNullBuffer() {
     framer.close();
-    verify(sink).deliverFrame(null, true, true);
+    verify(sink).deliverFrame(null, true, true, 0);
     verifyNoMoreInteractions(sink);
     assertEquals(0, allocator.allocCount);
-    checkStats(0, 0);
+    checkStats();
   }
 
   @Test
@@ -154,11 +139,11 @@ public void payloadSplitBetweenSinks() {
     framer = new MessageFramer(sink, allocator, statsTraceCtx);
     writeKnownLength(framer, new byte[]{3, 14, 1, 5, 9, 2, 6, 5});
     verify(sink).deliverFrame(
-        toWriteBuffer(new byte[] {0, 0, 0, 0, 8, 3, 14, 1, 5, 9, 2, 6}), false, false);
+        toWriteBuffer(new byte[] {0, 0, 0, 0, 8, 3, 14, 1, 5, 9, 2, 6}), false, false, 1);
     verifyNoMoreInteractions(sink);
 
     framer.flush();
-    verify(sink).deliverFrame(toWriteBuffer(new byte[] {5}), false, true);
+    verify(sink).deliverFrame(toWriteBuffer(new byte[] {5}), false, true, 0);
     verifyNoMoreInteractions(sink);
     assertEquals(2, allocator.allocCount);
     checkStats(8, 8);
@@ -171,31 +156,31 @@ public void frameHeaderSplitBetweenSinks() {
     writeKnownLength(framer, new byte[]{3, 14, 1});
     writeKnownLength(framer, new byte[]{3});
     verify(sink).deliverFrame(
-            toWriteBuffer(new byte[] {0, 0, 0, 0, 3, 3, 14, 1, 0, 0, 0, 0}), false, false);
+            toWriteBuffer(new byte[] {0, 0, 0, 0, 3, 3, 14, 1, 0, 0, 0, 0}), false, false, 2);
     verifyNoMoreInteractions(sink);
 
     framer.flush();
-    verify(sink).deliverFrame(toWriteBufferWithMinSize(new byte[] {1, 3}, 12), false, true);
+    verify(sink).deliverFrame(toWriteBufferWithMinSize(new byte[] {1, 3}, 12), false, true, 0);
     verifyNoMoreInteractions(sink);
     assertEquals(2, allocator.allocCount);
-    checkStats(4, 4);
+    checkStats(3, 3, 1, 1);
   }
 
   @Test
-  public void emptyPayloadYieldsFrame() throws Exception {
+  public void emptyPayloadYieldsFrame() {
     writeKnownLength(framer, new byte[0]);
     framer.flush();
-    verify(sink).deliverFrame(toWriteBuffer(new byte[] {0, 0, 0, 0, 0}), false, true);
+    verify(sink).deliverFrame(toWriteBuffer(new byte[] {0, 0, 0, 0, 0}), false, true, 1);
     assertEquals(1, allocator.allocCount);
     checkStats(0, 0);
   }
 
   @Test
-  public void emptyUnknownLengthPayloadYieldsFrame() throws Exception {
+  public void emptyUnknownLengthPayloadYieldsFrame() {
     writeUnknownLength(framer, new byte[0]);
-    verifyZeroInteractions(sink);
+    verifyNoInteractions(sink);
     framer.flush();
-    verify(sink).deliverFrame(toWriteBuffer(new byte[] {0, 0, 0, 0, 0}), false, true);
+    verify(sink).deliverFrame(toWriteBuffer(new byte[] {0, 0, 0, 0, 0}), false, true, 1);
     // One alloc for the header
     assertEquals(1, allocator.allocCount);
     checkStats(0, 0);
@@ -206,19 +191,19 @@ public void flushIsIdempotent() {
     writeKnownLength(framer, new byte[]{3, 14});
     framer.flush();
     framer.flush();
-    verify(sink).deliverFrame(toWriteBuffer(new byte[] {0, 0, 0, 0, 2, 3, 14}), false, true);
+    verify(sink).deliverFrame(toWriteBuffer(new byte[] {0, 0, 0, 0, 2, 3, 14}), false, true, 1);
     verifyNoMoreInteractions(sink);
     assertEquals(1, allocator.allocCount);
     checkStats(2, 2);
   }
 
   @Test
-  public void largerFrameSize() throws Exception {
+  public void largerFrameSize() {
     allocator = new BytesWritableBufferAllocator(0, 10000);
     framer = new MessageFramer(sink, allocator, statsTraceCtx);
     writeKnownLength(framer, new byte[1000]);
     framer.flush();
-    verify(sink).deliverFrame(frameCaptor.capture(), eq(false), eq(true));
+    verify(sink).deliverFrame(frameCaptor.capture(), eq(false), eq(true), eq(1));
     ByteWritableBuffer buffer = frameCaptor.getValue();
     assertEquals(1005, buffer.size());
 
@@ -233,16 +218,17 @@ public void largerFrameSize() throws Exception {
   }
 
   @Test
-  public void largerFrameSizeUnknownLength() throws Exception {
+  public void largerFrameSizeUnknownLength() {
     // Force payload to be split into two chunks
     allocator = new BytesWritableBufferAllocator(500, 500);
     framer = new MessageFramer(sink, allocator, statsTraceCtx);
     writeUnknownLength(framer, new byte[1000]);
     framer.flush();
     // Header and first chunk written with flush = false
-    verify(sink, times(2)).deliverFrame(frameCaptor.capture(), eq(false), eq(false));
+    verify(sink, times(2)).deliverFrame(frameCaptor.capture(), eq(false), eq(false), eq(0));
     // On flush third buffer written with flish = true
-    verify(sink).deliverFrame(frameCaptor.capture(), eq(false), eq(true));
+    // The message count is only bumped when a message is completely written.
+    verify(sink).deliverFrame(frameCaptor.capture(), eq(false), eq(true), eq(1));
 
     // header has fixed length of 5 and specifies correct length
     assertEquals(5, frameCaptor.getAllValues().get(0).readableBytes());
@@ -260,15 +246,17 @@ public void largerFrameSizeUnknownLength() throws Exception {
   }
 
   @Test
-  public void compressed() throws Exception {
+  public void compressed() {
     allocator = new BytesWritableBufferAllocator(100, Integer.MAX_VALUE);
     // setMessageCompression should default to true
-    framer = new MessageFramer(sink, allocator, statsTraceCtx).setCompressor(new Codec.Gzip());
+    framer = new MessageFramer(sink, allocator, statsTraceCtx)
+        .setCompressor(new Codec.Gzip());
     writeKnownLength(framer, new byte[1000]);
     framer.flush();
     // The GRPC header is written first as a separate frame.
-    verify(sink).deliverFrame(frameCaptor.capture(), eq(false), eq(false));
-    verify(sink).deliverFrame(frameCaptor.capture(), eq(false), eq(true));
+    // The message count is only bumped when a message is completely written.
+    verify(sink).deliverFrame(frameCaptor.capture(), eq(false), eq(false), eq(0));
+    verify(sink).deliverFrame(frameCaptor.capture(), eq(false), eq(true), eq(1));
 
     // Check the header
     ByteWritableBuffer buffer = frameCaptor.getAllValues().get(0);
@@ -285,14 +273,14 @@ public void compressed() throws Exception {
   }
 
   @Test
-  public void dontCompressIfNoEncoding() throws Exception {
+  public void dontCompressIfNoEncoding() {
     allocator = new BytesWritableBufferAllocator(100, Integer.MAX_VALUE);
     framer = new MessageFramer(sink, allocator, statsTraceCtx)
         .setMessageCompression(true);
     writeKnownLength(framer, new byte[1000]);
     framer.flush();
     // The GRPC header is written first as a separate frame
-    verify(sink).deliverFrame(frameCaptor.capture(), eq(false), eq(true));
+    verify(sink).deliverFrame(frameCaptor.capture(), eq(false), eq(true), eq(1));
 
     // Check the header
     ByteWritableBuffer buffer = frameCaptor.getAllValues().get(0);
@@ -310,7 +298,7 @@ public void dontCompressIfNoEncoding() throws Exception {
   }
 
   @Test
-  public void dontCompressIfNotRequested() throws Exception {
+  public void dontCompressIfNotRequested() {
     allocator = new BytesWritableBufferAllocator(100, Integer.MAX_VALUE);
     framer = new MessageFramer(sink, allocator, statsTraceCtx)
         .setCompressor(new Codec.Gzip())
@@ -318,7 +306,7 @@ public void dontCompressIfNotRequested() throws Exception {
     writeKnownLength(framer, new byte[1000]);
     framer.flush();
     // The GRPC header is written first as a separate frame
-    verify(sink).deliverFrame(frameCaptor.capture(), eq(false), eq(true));
+    verify(sink).deliverFrame(frameCaptor.capture(), eq(false), eq(true), eq(1));
 
     // Check the header
     ByteWritableBuffer buffer = frameCaptor.getAllValues().get(0);
@@ -336,11 +324,12 @@ public void dontCompressIfNotRequested() throws Exception {
   }
 
   @Test
-  public void closeIsRentrantSafe() throws Exception {
+  public void closeIsRentrantSafe() {
     MessageFramer.Sink reentrant = new MessageFramer.Sink() {
       int count = 0;
       @Override
-      public void deliverFrame(WritableBuffer frame, boolean endOfStream, boolean flush) {
+      public void deliverFrame(
+          WritableBuffer frame, boolean endOfStream, boolean flush, int numMessages) {
         if (count == 0) {
           framer.close();
           count++;
@@ -360,7 +349,7 @@ public void zeroLengthCompressibleMessageIsNotCompressed() {
     framer.setMessageCompression(true);
     writeKnownLength(framer, new byte[]{});
     framer.flush();
-    verify(sink).deliverFrame(toWriteBuffer(new byte[] {0, 0, 0, 0, 0}), false, true);
+    verify(sink).deliverFrame(toWriteBuffer(new byte[] {0, 0, 0, 0, 0}), false, true, 1);
     checkStats(0, 0);
   }
 
@@ -383,21 +372,29 @@ private static void writeKnownLength(MessageFramer framer, byte[] bytes) {
     // TODO(carl-mastrangelo): add framer.flush() here.
   }
 
-  private void checkStats(long wireBytesSent, long uncompressedBytesSent) {
-    statsTraceCtx.callEnded(Status.OK);
-    MetricsRecord record = statsCtxFactory.pollRecord();
-    assertEquals(0, record.getMetricAsLongOrFail(
-            RpcConstants.RPC_SERVER_REQUEST_BYTES));
-    assertEquals(0, record.getMetricAsLongOrFail(
-            RpcConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES));
-    assertEquals(wireBytesSent,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_RESPONSE_BYTES));
-    assertEquals(uncompressedBytesSent,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_REQUEST_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_RESPONSE_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
+  /**
+   * Verify stats were published through the tracer.
+   *
+   * @param sizes in the format {wire0, uncompressed0, wire1, uncompressed1, ...}
+   */
+  private void checkStats(long... sizes) {
+    assertEquals(0, sizes.length % 2);
+    int count = sizes.length / 2;
+    long expectedWireSize = 0;
+    long expectedUncompressedSize = 0;
+    for (int i = 0; i < count; i++) {
+      assertEquals("outboundMessage(" + i + ")", tracer.nextOutboundEvent());
+      assertEquals(
+          String.format(
+              Locale.US, "outboundMessageSent(%d, %d, %d)", i, sizes[i * 2], sizes[i * 2 + 1]),
+          tracer.nextOutboundEvent());
+      expectedWireSize += sizes[i * 2];
+      expectedUncompressedSize += sizes[i * 2 + 1];
+    }
+    assertNull(tracer.nextOutboundEvent());
+    assertNull(tracer.nextInboundEvent());
+    assertEquals(expectedWireSize, tracer.getOutboundWireSize());
+    assertEquals(expectedUncompressedSize, tracer.getOutboundUncompressedSize());
   }
 
   static class ByteWritableBuffer implements WritableBuffer {
diff --git a/core/src/test/java/io/grpc/internal/MetricRecorderImplTest.java b/core/src/test/java/io/grpc/internal/MetricRecorderImplTest.java
new file mode 100644
index 00000000000..33bf9bb41e2
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/MetricRecorderImplTest.java
@@ -0,0 +1,329 @@
+/*
+ * Copyright 2024 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.internal;
+
+import static org.junit.Assert.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.DoubleCounterMetricInstrument;
+import io.grpc.DoubleHistogramMetricInstrument;
+import io.grpc.LongCounterMetricInstrument;
+import io.grpc.LongGaugeMetricInstrument;
+import io.grpc.LongHistogramMetricInstrument;
+import io.grpc.LongUpDownCounterMetricInstrument;
+import io.grpc.MetricInstrumentRegistry;
+import io.grpc.MetricInstrumentRegistryAccessor;
+import io.grpc.MetricRecorder;
+import io.grpc.MetricSink;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+
+/**
+ * Unit test for {@link MetricRecorderImpl}.
+ */
+@RunWith(JUnit4.class)
+public class MetricRecorderImplTest {
+  private static final String DESCRIPTION = "description";
+  private static final String UNIT = "unit";
+  private static final boolean ENABLED = true;
+  private static final ImmutableList<String> REQUIRED_LABEL_KEYS = ImmutableList.of("KEY1", "KEY2");
+  private static final ImmutableList<String> OPTIONAL_LABEL_KEYS = ImmutableList.of(
+      "OPTIONAL_KEY_1");
+  private static final ImmutableList<String> REQUIRED_LABEL_VALUES = ImmutableList.of("VALUE1",
+      "VALUE2");
+  private static final ImmutableList<String> OPTIONAL_LABEL_VALUES = ImmutableList.of(
+      "OPTIONAL_VALUE_1");
+  private MetricSink mockSink = mock(MetricSink.class);
+  private List<MetricSink> sinks = Arrays.asList(mockSink, mockSink);
+  private MetricInstrumentRegistry registry =
+      MetricInstrumentRegistryAccessor.createMetricInstrumentRegistry();
+  private final DoubleCounterMetricInstrument doubleCounterInstrument =
+      registry.registerDoubleCounter("counter0", DESCRIPTION, UNIT, REQUIRED_LABEL_KEYS,
+          OPTIONAL_LABEL_KEYS, ENABLED);
+  private final LongCounterMetricInstrument longCounterInstrument =
+      registry.registerLongCounter("counter1", DESCRIPTION, UNIT, REQUIRED_LABEL_KEYS,
+          OPTIONAL_LABEL_KEYS, ENABLED);
+  private final DoubleHistogramMetricInstrument doubleHistogramInstrument =
+      registry.registerDoubleHistogram("histogram1", DESCRIPTION, UNIT,
+          Collections.emptyList(), REQUIRED_LABEL_KEYS, OPTIONAL_LABEL_KEYS, ENABLED);
+  private final LongHistogramMetricInstrument longHistogramInstrument =
+      registry.registerLongHistogram("histogram2", DESCRIPTION, UNIT,
+          Collections.emptyList(), REQUIRED_LABEL_KEYS, OPTIONAL_LABEL_KEYS, ENABLED);
+  private final LongGaugeMetricInstrument longGaugeInstrument =
+      registry.registerLongGauge("gauge0", DESCRIPTION, UNIT, REQUIRED_LABEL_KEYS,
+          OPTIONAL_LABEL_KEYS, ENABLED);
+  private final LongUpDownCounterMetricInstrument longUpDownCounterInstrument =
+      registry.registerLongUpDownCounter("upDownCounter0", DESCRIPTION, UNIT,
+          REQUIRED_LABEL_KEYS, OPTIONAL_LABEL_KEYS, ENABLED);
+  private MetricRecorder recorder;
+
+  @Before
+  public void setUp() {
+    recorder = new MetricRecorderImpl(sinks, registry);
+  }
+
+  @Test
+  public void addCounter() {
+    when(mockSink.getMeasuresSize()).thenReturn(6);
+
+    recorder.addDoubleCounter(doubleCounterInstrument, 1.0, REQUIRED_LABEL_VALUES,
+        OPTIONAL_LABEL_VALUES);
+    verify(mockSink, times(2)).addDoubleCounter(eq(doubleCounterInstrument), eq(1D),
+        eq(REQUIRED_LABEL_VALUES), eq(OPTIONAL_LABEL_VALUES));
+
+    recorder.addLongCounter(longCounterInstrument, 1, REQUIRED_LABEL_VALUES,
+        OPTIONAL_LABEL_VALUES);
+    verify(mockSink, times(2)).addLongCounter(eq(longCounterInstrument), eq(1L),
+        eq(REQUIRED_LABEL_VALUES), eq(OPTIONAL_LABEL_VALUES));
+
+    recorder.addLongUpDownCounter(longUpDownCounterInstrument, -10, REQUIRED_LABEL_VALUES,
+        OPTIONAL_LABEL_VALUES);
+    verify(mockSink, times(2))
+        .addLongUpDownCounter(eq(longUpDownCounterInstrument), eq(-10L),
+            eq(REQUIRED_LABEL_VALUES), eq(OPTIONAL_LABEL_VALUES));
+
+    verify(mockSink, never()).updateMeasures(registry.getMetricInstruments());
+  }
+
+  @Test
+  public void recordHistogram() {
+    when(mockSink.getMeasuresSize()).thenReturn(4);
+
+    recorder.recordDoubleHistogram(doubleHistogramInstrument, 99.0, REQUIRED_LABEL_VALUES,
+        OPTIONAL_LABEL_VALUES);
+    verify(mockSink, times(2)).recordDoubleHistogram(eq(doubleHistogramInstrument),
+        eq(99D), eq(REQUIRED_LABEL_VALUES), eq(OPTIONAL_LABEL_VALUES));
+
+    recorder.recordLongHistogram(longHistogramInstrument, 99, REQUIRED_LABEL_VALUES,
+        OPTIONAL_LABEL_VALUES);
+    verify(mockSink, times(2)).recordLongHistogram(eq(longHistogramInstrument), eq(99L),
+        eq(REQUIRED_LABEL_VALUES), eq(OPTIONAL_LABEL_VALUES));
+
+    verify(mockSink, never()).updateMeasures(registry.getMetricInstruments());
+  }
+
+  @Test
+  public void recordCallback() {
+    MetricSink.Registration mockRegistration = mock(MetricSink.Registration.class);
+    when(mockSink.getMeasuresSize()).thenReturn(5);
+    when(mockSink.registerBatchCallback(any(Runnable.class), eq(longGaugeInstrument)))
+        .thenReturn(mockRegistration);
+
+    MetricRecorder.Registration registration = recorder.registerBatchCallback((recorder) -> {
+      recorder.recordLongGauge(
+          longGaugeInstrument, 99, REQUIRED_LABEL_VALUES, OPTIONAL_LABEL_VALUES);
+    }, longGaugeInstrument);
+
+    ArgumentCaptor<Runnable> callbackCaptor = ArgumentCaptor.forClass(Runnable.class);
+    verify(mockSink, times(2))
+        .registerBatchCallback(callbackCaptor.capture(), eq(longGaugeInstrument));
+
+    callbackCaptor.getValue().run();
+    // Only once, for the one sink that called the callback.
+    verify(mockSink).recordLongGauge(
+        longGaugeInstrument, 99, REQUIRED_LABEL_VALUES, OPTIONAL_LABEL_VALUES);
+
+    verify(mockRegistration, never()).close();
+    registration.close();
+    verify(mockRegistration, times(2)).close();
+
+    verify(mockSink, never()).updateMeasures(registry.getMetricInstruments());
+  }
+
+  @Test
+  public void newRegisteredMetricUpdateMeasures() {
+    // Sink is initialized with zero measures, should trigger updateMeasures() on sinks
+    when(mockSink.getMeasuresSize()).thenReturn(0);
+
+    // Double Counter
+    recorder.addDoubleCounter(doubleCounterInstrument, 1.0, REQUIRED_LABEL_VALUES,
+        OPTIONAL_LABEL_VALUES);
+    verify(mockSink, times(2)).updateMeasures(anyList());
+    verify(mockSink, times(2)).addDoubleCounter(eq(doubleCounterInstrument), eq(1D),
+        eq(REQUIRED_LABEL_VALUES), eq(OPTIONAL_LABEL_VALUES));
+
+    // Long Counter
+    recorder.addLongCounter(longCounterInstrument, 1, REQUIRED_LABEL_VALUES,
+        OPTIONAL_LABEL_VALUES);
+    verify(mockSink, times(4)).updateMeasures(anyList());
+    verify(mockSink, times(2)).addLongCounter(eq(longCounterInstrument), eq(1L),
+        eq(REQUIRED_LABEL_VALUES), eq(OPTIONAL_LABEL_VALUES));
+
+    // Double Histogram
+    recorder.recordDoubleHistogram(doubleHistogramInstrument, 99.0, REQUIRED_LABEL_VALUES,
+        OPTIONAL_LABEL_VALUES);
+    verify(mockSink, times(6)).updateMeasures(anyList());
+    verify(mockSink, times(2)).recordDoubleHistogram(eq(doubleHistogramInstrument),
+        eq(99D), eq(REQUIRED_LABEL_VALUES), eq(OPTIONAL_LABEL_VALUES));
+
+    // Long Histogram
+    recorder.recordLongHistogram(longHistogramInstrument, 99, REQUIRED_LABEL_VALUES,
+        OPTIONAL_LABEL_VALUES);
+    verify(mockSink, times(8)).updateMeasures(registry.getMetricInstruments());
+    verify(mockSink, times(2)).recordLongHistogram(eq(longHistogramInstrument), eq(99L),
+        eq(REQUIRED_LABEL_VALUES), eq(OPTIONAL_LABEL_VALUES));
+
+    // Callback
+    when(mockSink.registerBatchCallback(any(Runnable.class), eq(longGaugeInstrument)))
+        .thenReturn(mock(MetricSink.Registration.class));
+    MetricRecorder.Registration registration = recorder.registerBatchCallback(
+        (recorder) -> { }, longGaugeInstrument);
+    verify(mockSink, times(10)).updateMeasures(registry.getMetricInstruments());
+    verify(mockSink, times(2))
+        .registerBatchCallback(any(Runnable.class), eq(longGaugeInstrument));
+    registration.close();
+
+    // Long UpDown Counter
+    recorder.addLongUpDownCounter(longUpDownCounterInstrument, -10, REQUIRED_LABEL_VALUES,
+        OPTIONAL_LABEL_VALUES);
+    verify(mockSink, times(12)).updateMeasures(anyList());
+    verify(mockSink, times(2)).addLongUpDownCounter(eq(longUpDownCounterInstrument), eq(-10L),
+        eq(REQUIRED_LABEL_VALUES), eq(OPTIONAL_LABEL_VALUES));
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void addDoubleCounterMismatchedRequiredLabelValues() {
+    when(mockSink.getMeasuresSize()).thenReturn(4);
+
+    recorder.addDoubleCounter(doubleCounterInstrument, 1.0, ImmutableList.of(),
+        OPTIONAL_LABEL_VALUES);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void addLongCounterMismatchedRequiredLabelValues() {
+    when(mockSink.getMeasuresSize()).thenReturn(4);
+
+    recorder.addLongCounter(longCounterInstrument, 1, ImmutableList.of(),
+        OPTIONAL_LABEL_VALUES);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void addLongUpDownCounterMismatchedRequiredLabelValues() {
+    when(mockSink.getMeasuresSize()).thenReturn(6);
+    recorder.addLongUpDownCounter(longUpDownCounterInstrument, 1, ImmutableList.of(),
+        OPTIONAL_LABEL_VALUES);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void recordDoubleHistogramMismatchedRequiredLabelValues() {
+    when(mockSink.getMeasuresSize()).thenReturn(4);
+
+    recorder.recordDoubleHistogram(doubleHistogramInstrument, 99.0, ImmutableList.of(),
+        OPTIONAL_LABEL_VALUES);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void recordLongHistogramMismatchedRequiredLabelValues() {
+    when(mockSink.getMeasuresSize()).thenReturn(4);
+
+    recorder.recordLongHistogram(longHistogramInstrument, 99, ImmutableList.of(),
+        OPTIONAL_LABEL_VALUES);
+  }
+
+  @Test
+  public void recordLongGaugeMismatchedRequiredLabelValues() {
+    when(mockSink.getMeasuresSize()).thenReturn(4);
+    when(mockSink.registerBatchCallback(any(Runnable.class), eq(longGaugeInstrument)))
+        .thenReturn(mock(MetricSink.Registration.class));
+
+    MetricRecorder.Registration registration = recorder.registerBatchCallback((recorder) -> {
+      assertThrows(
+          IllegalArgumentException.class,
+          () -> recorder.recordLongGauge(
+              longGaugeInstrument, 99, ImmutableList.of(), OPTIONAL_LABEL_VALUES));
+    }, longGaugeInstrument);
+
+    ArgumentCaptor<Runnable> callbackCaptor = ArgumentCaptor.forClass(Runnable.class);
+    verify(mockSink, times(2))
+        .registerBatchCallback(callbackCaptor.capture(), eq(longGaugeInstrument));
+    callbackCaptor.getValue().run();
+    registration.close();
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void addDoubleCounterMismatchedOptionalLabelValues() {
+    when(mockSink.getMeasuresSize()).thenReturn(4);
+
+    recorder.addDoubleCounter(doubleCounterInstrument, 1.0, REQUIRED_LABEL_VALUES,
+        ImmutableList.of());
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void addLongCounterMismatchedOptionalLabelValues() {
+    when(mockSink.getMeasuresSize()).thenReturn(4);
+
+    recorder.addLongCounter(longCounterInstrument, 1, REQUIRED_LABEL_VALUES,
+        ImmutableList.of());
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void addLongUpDownCounterMismatchedOptionalLabelValues() {
+    when(mockSink.getMeasuresSize()).thenReturn(6);
+    recorder.addLongUpDownCounter(longUpDownCounterInstrument, 1, REQUIRED_LABEL_VALUES,
+        ImmutableList.of());
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void recordDoubleHistogramMismatchedOptionalLabelValues() {
+    when(mockSink.getMeasuresSize()).thenReturn(4);
+
+    recorder.recordDoubleHistogram(doubleHistogramInstrument, 99.0, REQUIRED_LABEL_VALUES,
+        ImmutableList.of());
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void recordLongHistogramMismatchedOptionalLabelValues() {
+    when(mockSink.getMeasuresSize()).thenReturn(4);
+
+    recorder.recordLongHistogram(longHistogramInstrument, 99, REQUIRED_LABEL_VALUES,
+        ImmutableList.of());
+  }
+
+  @Test
+  public void recordLongGaugeMismatchedOptionalLabelValues() {
+    when(mockSink.getMeasuresSize()).thenReturn(4);
+    when(mockSink.registerBatchCallback(any(Runnable.class), eq(longGaugeInstrument)))
+        .thenReturn(mock(MetricSink.Registration.class));
+
+    MetricRecorder.Registration registration = recorder.registerBatchCallback((recorder) -> {
+      assertThrows(
+          IllegalArgumentException.class,
+          () -> recorder.recordLongGauge(
+              longGaugeInstrument, 99, REQUIRED_LABEL_VALUES, ImmutableList.of()));
+    }, longGaugeInstrument);
+
+    ArgumentCaptor<Runnable> callbackCaptor = ArgumentCaptor.forClass(Runnable.class);
+    verify(mockSink, times(2))
+        .registerBatchCallback(callbackCaptor.capture(), eq(longGaugeInstrument));
+    callbackCaptor.getValue().run();
+    registration.close();
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/NoopClientStreamListener.java b/core/src/test/java/io/grpc/internal/NoopClientStreamListener.java
deleted file mode 100644
index 1a2a342b234..00000000000
--- a/core/src/test/java/io/grpc/internal/NoopClientStreamListener.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import io.grpc.Metadata;
-import io.grpc.Status;
-import java.io.InputStream;
-
-/**
- * No-op base class for testing.
- */
-class NoopClientStreamListener implements ClientStreamListener {
-  @Override
-  public void messageRead(InputStream message) {}
-
-  @Override
-  public void onReady() {}
-
-  @Override
-  public void headersRead(Metadata headers) {}
-
-  @Override
-  public void closed(Status status, Metadata trailers) {}
-}
diff --git a/core/src/test/java/io/grpc/internal/PickFirstLeafLoadBalancerTest.java b/core/src/test/java/io/grpc/internal/PickFirstLeafLoadBalancerTest.java
new file mode 100644
index 00000000000..8b09fce2aa2
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/PickFirstLeafLoadBalancerTest.java
@@ -0,0 +1,3000 @@
+/*
+ * Copyright 2023 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.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static io.grpc.LoadBalancer.HAS_HEALTH_PRODUCER_LISTENER_KEY;
+import static io.grpc.LoadBalancer.HEALTH_CONSUMER_LISTENER_ARG_KEY;
+import static io.grpc.LoadBalancer.IS_PETIOLE_POLICY;
+import static io.grpc.internal.PickFirstLeafLoadBalancer.CONNECTION_DELAY_INTERVAL_MS;
+import static io.grpc.internal.PickFirstLeafLoadBalancer.isSerializingRetries;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.google.errorprone.annotations.Keep;
+import io.grpc.Attributes;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.ManagedChannel;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.PickFirstLeafLoadBalancer.PickFirstLeafLoadBalancerConfig;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+
+/** Unit test for {@link PickFirstLeafLoadBalancer}. */
+@RunWith(Parameterized.class)
+public class PickFirstLeafLoadBalancerTest {
+  public static final Status CONNECTION_ERROR =
+      Status.UNAVAILABLE.withDescription("Simulated connection error");
+  public static final String GRPC_SERIALIZE_RETRIES = "GRPC_SERIALIZE_RETRIES";
+
+  @Parameterized.Parameters(name = "{0}-{1}")
+  public static List<Object[]> data() {
+    return Arrays.asList(new Object[][] {
+        {false, false},
+        {false, true},
+        {true, false}});
+  }
+
+  @Parameterized.Parameter(value = 0)
+  public boolean serializeRetries;
+
+  @Parameterized.Parameter(value = 1)
+  public boolean enableHappyEyeballs;
+
+  private PickFirstLeafLoadBalancer loadBalancer;
+  private final List<EquivalentAddressGroup> servers = Lists.newArrayList();
+  private static final Attributes.Key<String> FOO = Attributes.Key.create("foo");
+  // For scheduled executor
+  private final FakeClock fakeClock = new FakeClock();
+  // For syncContext
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final Attributes affinity = Attributes.newBuilder().set(FOO, "bar").build();
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  @Captor
+  private ArgumentCaptor<SubchannelPicker> pickerCaptor;
+  @Captor
+  private ArgumentCaptor<ConnectivityState> connectivityStateCaptor;
+  @Captor
+  private ArgumentCaptor<CreateSubchannelArgs> createArgsCaptor;
+  @Captor
+  private ArgumentCaptor<SubchannelStateListener> stateListenerCaptor;
+  private Helper mockHelper;
+  private FakeSubchannel mockSubchannel1;
+  private FakeSubchannel mockSubchannel1n2;
+  private FakeSubchannel mockSubchannel2;
+  private FakeSubchannel mockSubchannel2n2;
+  private FakeSubchannel mockSubchannel3;
+  private FakeSubchannel mockSubchannel3n2;
+  private FakeSubchannel mockSubchannel4;
+  private FakeSubchannel mockSubchannel5;
+  @Mock // This LoadBalancer doesn't use any of the arg fields, as verified in tearDown().
+  private PickSubchannelArgs mockArgs;
+
+  private String originalHappyEyeballsEnabledValue;
+  private String originalSerializeRetriesValue;
+
+  private long backoffMillis;
+
+  @Before
+  public void setUp() {
+    assumeTrue(!serializeRetries || !enableHappyEyeballs); // they are not compatible
+
+    backoffMillis = TimeUnit.SECONDS.toMillis(1);
+    originalSerializeRetriesValue = System.getProperty(GRPC_SERIALIZE_RETRIES);
+    System.setProperty(GRPC_SERIALIZE_RETRIES, Boolean.toString(serializeRetries));
+
+    originalHappyEyeballsEnabledValue =
+        System.getProperty(PickFirstLoadBalancerProvider.GRPC_PF_USE_HAPPY_EYEBALLS);
+    System.setProperty(PickFirstLoadBalancerProvider.GRPC_PF_USE_HAPPY_EYEBALLS,
+        Boolean.toString(enableHappyEyeballs));
+
+    for (int i = 1; i <= 5; i++) {
+      SocketAddress addr = new FakeSocketAddress("server" + i);
+      servers.add(new EquivalentAddressGroup(addr));
+    }
+    mockSubchannel1 = mock(FakeSubchannel.class, delegatesTo(
+        new FakeSubchannel(Arrays.asList(servers.get(0)), Attributes.EMPTY)));
+    mockSubchannel1n2 = mock(FakeSubchannel.class, delegatesTo(
+        new FakeSubchannel(Arrays.asList(servers.get(0)), Attributes.EMPTY)));
+    mockSubchannel2 = mock(FakeSubchannel.class, delegatesTo(
+        new FakeSubchannel(Arrays.asList(servers.get(1)), Attributes.EMPTY)));
+    mockSubchannel2n2 = mock(FakeSubchannel.class, delegatesTo(
+        new FakeSubchannel(Arrays.asList(servers.get(1)), Attributes.EMPTY)));
+    mockSubchannel3 = mock(FakeSubchannel.class, delegatesTo(
+        new FakeSubchannel(Arrays.asList(servers.get(2)), Attributes.EMPTY)));
+    mockSubchannel3n2 = mock(FakeSubchannel.class, delegatesTo(
+        new FakeSubchannel(Arrays.asList(servers.get(2)), Attributes.EMPTY)));
+    mockSubchannel4 = mock(FakeSubchannel.class, delegatesTo(
+        new FakeSubchannel(Arrays.asList(servers.get(3)), Attributes.EMPTY)));
+    mockSubchannel5 = mock(FakeSubchannel.class, delegatesTo(
+        new FakeSubchannel(Arrays.asList(servers.get(4)), Attributes.EMPTY)));
+
+    mockHelper = mock(Helper.class, delegatesTo(new MockHelperImpl(Arrays.asList(
+        mockSubchannel1, mockSubchannel1n2,
+        mockSubchannel2, mockSubchannel2n2,
+        mockSubchannel3, mockSubchannel3n2,
+        mockSubchannel4, mockSubchannel5))));
+    loadBalancer = new PickFirstLeafLoadBalancer(mockHelper);
+  }
+
+  @After
+  public void tearDown() {
+    if (originalSerializeRetriesValue == null) {
+      System.clearProperty(GRPC_SERIALIZE_RETRIES);
+    } else {
+      System.setProperty(GRPC_SERIALIZE_RETRIES, originalSerializeRetriesValue);
+    }
+    if (originalHappyEyeballsEnabledValue == null) {
+      System.clearProperty(PickFirstLoadBalancerProvider.GRPC_PF_USE_HAPPY_EYEBALLS);
+    } else {
+      System.setProperty(PickFirstLoadBalancerProvider.GRPC_PF_USE_HAPPY_EYEBALLS,
+          originalHappyEyeballsEnabledValue);
+    }
+
+    loadBalancer.shutdown();
+    verifyNoMoreInteractions(mockArgs);
+  }
+
+  @Test
+  public void pickAfterResolved() {
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    forwardTimeByConnectionDelay(3);
+    int expectedCreates = enableHappyEyeballs ? 4 : 1;
+    verify(mockHelper, times(expectedCreates)).createSubchannel(createArgsCaptor.capture());
+    List<CreateSubchannelArgs> argsList = createArgsCaptor.getAllValues();
+    assertThat(argsList.get(0).getAddresses().get(0)).isEqualTo(servers.get(0));
+    assertThat(argsList.get(0).getAddresses().size()).isEqualTo(1);
+    if (enableHappyEyeballs) {
+      assertThat(argsList.get(1).getAddresses().get(0)).isEqualTo(servers.get(1));
+      assertThat(argsList.get(2).getAddresses().get(0)).isEqualTo(servers.get(2));
+      assertThat(argsList.get(3).getAddresses().get(0)).isEqualTo(servers.get(3));
+      assertThat(argsList.get(1).getAddresses().size()).isEqualTo(1);
+      assertThat(argsList.get(2).getAddresses().size()).isEqualTo(1);
+      assertThat(argsList.get(3).getAddresses().size()).isEqualTo(1);
+    }
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockSubchannel1).requestConnection();
+    verify(mockHelper, atLeast(0)).getScheduledExecutorService();
+    verify(mockHelper, atLeast(0)).getSynchronizationContext();
+
+    // Calling pickSubchannel() twice gave the same result and doesn't interact with mockHelper
+    assertEquals(pickerCaptor.getValue().pickSubchannel(mockArgs),
+        pickerCaptor.getValue().pickSubchannel(mockArgs));
+
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void pickAfterResolved_shuffle() {
+    servers.remove(4);
+    servers.remove(3);
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity)
+            .setLoadBalancingPolicyConfig(new PickFirstLeafLoadBalancerConfig(true, 123L)).build());
+
+    verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+
+
+    forwardTimeByConnectionDelay(servers.size() - 1);
+    int expectedScs = enableHappyEyeballs ? servers.size() : 1;
+    verify(mockHelper, times(expectedScs)).createSubchannel(createArgsCaptor.capture());
+
+    List<CreateSubchannelArgs> argsList = createArgsCaptor.getAllValues();
+    // We should still see the same set of addresses.
+    // Because we use a fixed seed, the addresses should always be shuffled in this order.
+    assertThat(argsList.get(0).getAddresses().get(0)).isEqualTo(servers.get(1));
+    assertThat(argsList.get(0).getAddresses().size()).isEqualTo(1);
+    if (enableHappyEyeballs) {
+      assertThat(argsList.get(1).getAddresses().get(0)).isEqualTo(servers.get(0));
+      assertThat(argsList.get(2).getAddresses().get(0)).isEqualTo(servers.get(2));
+      assertThat(argsList.get(1).getAddresses().size()).isEqualTo(1);
+      assertThat(argsList.get(2).getAddresses().size()).isEqualTo(1);
+      verify(mockSubchannel1).requestConnection();
+    }
+
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockHelper, atLeast(0)).getScheduledExecutorService();
+    verify(mockHelper, atLeast(0)).getSynchronizationContext();
+
+    // Calling pickSubchannel() twice gives the same result and doesn't interact with mockHelper
+    PickResult pick1 = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    PickResult pick2 = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertEquals(pick1, pick2);
+    verifyNoMoreInteractions(mockHelper);
+    assertThat(pick1.getSubchannel()).isNull();
+
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    PickResult pick3 = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    PickResult pick4 = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertEquals(pick3, pick4);
+    assertThat(pick3.getSubchannel()).isEqualTo(mockSubchannel2);
+  }
+
+  @Test
+  public void pickAfterResolved_noShuffle() {
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity)
+            .setLoadBalancingPolicyConfig(new PickFirstLeafLoadBalancerConfig(false)).build());
+
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockSubchannel1).requestConnection();
+
+    // Calling pickSubchannel() twice gave the same result
+    assertEquals(pickerCaptor.getValue().pickSubchannel(mockArgs),
+        pickerCaptor.getValue().pickSubchannel(mockArgs));
+    assertNotNull(pickerCaptor.getValue().pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void requestConnectionPicker() {
+    // Set up
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(0), servers.get(1),
+        servers.get(2));
+
+    // Accepting resolved addresses
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2, mockSubchannel3);
+
+    // We initialize and start first subchannel
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockHelper).createSubchannel(any());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+
+    // We start connection attempt to the first address in the list
+    inOrder.verify(mockSubchannel1).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // If we send the first subchannel into idle ...
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+
+    // Calling pickSubchannel() requests a connection, gives the same result when called twice.
+    assertEquals(picker.pickSubchannel(mockArgs), picker.pickSubchannel(mockArgs));
+
+    // But the picker calls requestConnection() only once for a total of two connection requests.
+    inOrder.verify(mockSubchannel1).requestConnection();
+    verify(mockSubchannel1, times(2)).requestConnection();
+  }
+
+  @Test
+  public void refreshNameResolutionAfterSubchannelConnectionBroken() {
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(0));
+    when(mockSubchannel1.getAllAddresses()).thenReturn(Lists.newArrayList(servers.get(0)));
+
+    // accept resolved addresses
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1);
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    assertNull(pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+    inOrder.verify(mockSubchannel1).requestConnection();
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    inOrder.verify(mockHelper).refreshNameResolution();
+    assertEquals(CONNECTION_ERROR, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertEquals(mockSubchannel1, pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+
+    // Simulate receiving go-away so the subchannel transit to IDLE.
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(mockHelper).refreshNameResolution();
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
+  }
+
+  @Test
+  public void pickAfterResolvedAndUnchanged() {
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1);
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    inOrder.verify(mockSubchannel1, times(1)).requestConnection();
+
+    // Second acceptResolvedAddresses shouldn't do anything
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel1, never()).requestConnection();
+    inOrder.verify(mockHelper, never()).updateBalancingState(any(), any());
+  }
+
+  @Test
+  public void pickAfterResolvedAndChanged() {
+    SocketAddress socketAddr1 = new FakeSocketAddress("server1");
+    List<EquivalentAddressGroup> oldServers =
+        Lists.newArrayList(new EquivalentAddressGroup(socketAddr1));
+
+    SocketAddress socketAddr2 = new FakeSocketAddress("server2");
+    List<EquivalentAddressGroup> newServers =
+        Lists.newArrayList(new EquivalentAddressGroup(socketAddr2));
+
+    // accept resolved addresses which starts connection attempt to first address
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    assertNull(pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+
+    // updating the subchannel addresses is unnecessary, but doesn't hurt anything
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockSubchannel1).shutdown();
+    verify(mockSubchannel2).requestConnection();
+  }
+
+  @Test
+  public void healthCheck_nonPetiolePolicy() {
+    when(mockSubchannel1.getAttributes()).thenReturn(
+        Attributes.newBuilder().set(HAS_HEALTH_PRODUCER_LISTENER_KEY, true).build());
+
+    // Initialize with one server loadbalancer and both health and state listeners
+    List<EquivalentAddressGroup> oneServer = Lists.newArrayList(servers.get(0));
+    loadBalancer.acceptResolvedAddresses(ResolvedAddresses.newBuilder().setAddresses(oneServer)
+        .setAttributes(Attributes.EMPTY).build());
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1);
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+    inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    SubchannelStateListener healthListener = createArgsCaptor.getValue()
+        .getOption(HEALTH_CONSUMER_LISTENER_ARG_KEY);
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    healthListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    inOrder.verify(mockHelper, never()).updateBalancingState(any(), any());
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), any()); // health listener ignored
+
+    healthListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(Status.INTERNAL));
+    inOrder.verify(mockHelper, never()).updateBalancingState(any(), any(SubchannelPicker.class));
+  }
+
+  @Test
+  public void healthCheckFlow() {
+    when(mockSubchannel1.getAttributes()).thenReturn(
+        Attributes.newBuilder().set(HAS_HEALTH_PRODUCER_LISTENER_KEY, true).build());
+    when(mockSubchannel2.getAttributes()).thenReturn(
+        Attributes.newBuilder().set(HAS_HEALTH_PRODUCER_LISTENER_KEY, true).build());
+
+    List<EquivalentAddressGroup> oneServer = Lists.newArrayList(servers.get(0), servers.get(1));
+    loadBalancer.acceptResolvedAddresses(ResolvedAddresses.newBuilder().setAddresses(oneServer)
+        .setAttributes(Attributes.newBuilder().set(IS_PETIOLE_POLICY, true).build()).build());
+
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2);
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+    inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    SubchannelStateListener healthListener = createArgsCaptor.getValue()
+        .getOption(HEALTH_CONSUMER_LISTENER_ARG_KEY);
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1).requestConnection();
+
+    // subchannel  |  state    |   health
+    // subchannel1 | CONNECTING| CONNECTING
+    // subchannel2 | IDLE      | IDLE
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    healthListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    inOrder.verify(mockHelper, never()).updateBalancingState(any(), any());
+
+    // subchannel  |  state    |   health
+    // subchannel1 | READY     | CONNECTING
+    // subchannel2 | IDLE      | IDLE
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper, never()).updateBalancingState(any(), any());
+
+    // subchannel  |  state    |   health
+    // subchannel1 | READY     | READY
+    healthListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), any(SubchannelPicker.class));
+    healthListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(Status.CANCELLED));
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    assertThat(pickerCaptor.getValue().pickSubchannel(mockArgs)
+        .getStatus()).isEqualTo(Status.CANCELLED);
+    //sticky tf
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(mockHelper).refreshNameResolution();
+    inOrder.verify(mockSubchannel1).requestConnection();
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    inOrder.verify(mockHelper, times(0)).updateBalancingState(any(), any());
+    healthListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper, times(0)).updateBalancingState(any(), any());
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(Status.INTERNAL));
+
+    inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    SubchannelStateListener healthListener2 = createArgsCaptor.getValue()
+        .getOption(HEALTH_CONSUMER_LISTENER_ARG_KEY);
+    inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel2).requestConnection();
+    //ignore health update on non-ready subchannel
+    healthListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+
+    verify(mockHelper, atLeast(0)).getSynchronizationContext();
+    verify(mockHelper, atLeast(0)).getScheduledExecutorService();
+    verifyNoMoreInteractions(mockHelper);
+
+    // subchannel  |  state    |   health
+    // subchannel1 | TF     | READY
+    // subchannel2 | TF      | IDLE
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    inOrder.verify(mockHelper).refreshNameResolution();
+    assertThat(pickerCaptor.getValue().pickSubchannel(mockArgs)
+        .getStatus()).isEqualTo(Status.UNAVAILABLE);
+    // subchannel  |  state    |   health
+    // subchannel1 | READY     | READY
+    // subchannel2 | TF      | IDLE
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertThat(pickerCaptor.getValue().pickSubchannel(mockArgs)
+        .getSubchannel()).isSameInstanceAs(mockSubchannel1);
+    verify(mockHelper, atLeast(0)).getSynchronizationContext();
+    verify(mockHelper, atLeast(0)).getScheduledExecutorService();
+    verifyNoMoreInteractions(mockHelper);
+
+    healthListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void pickAfterStateChangeAfterResolution() {
+    InOrder inOrder =
+        inOrder(mockHelper, mockSubchannel1, mockSubchannel2, mockSubchannel3, mockSubchannel4);
+
+    SubchannelStateListener[] stateListeners = new SubchannelStateListener[4];
+    Subchannel[] subchannels = new Subchannel[] {
+        mockSubchannel1, mockSubchannel2, mockSubchannel3, mockSubchannel4};
+
+    servers.remove(4);
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    stateListeners[0] = stateListenerCaptor.getValue();
+
+    stateListeners[0].onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    stateListeners[0].onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(mockHelper).refreshNameResolution();
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+
+    // subchannel reports connecting when pick subchannel is called
+    assertEquals(Status.OK, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+    stateListeners[0].onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+
+    Status error = Status.UNAVAILABLE.withDescription("boom!");
+    reset(mockHelper);
+
+    if (enableHappyEyeballs) {
+      stateListeners[0].onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+      forwardTimeByConnectionDelay();
+      inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+      stateListeners[1] = stateListenerCaptor.getValue();
+      stateListeners[1].onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+      forwardTimeByConnectionDelay();
+      inOrder.verify(mockSubchannel3).start(stateListenerCaptor.capture());
+      stateListeners[2] = stateListenerCaptor.getValue();
+      stateListeners[2].onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+      forwardTimeByConnectionDelay();
+      inOrder.verify(mockSubchannel4).start(stateListenerCaptor.capture());
+      stateListeners[3] = stateListenerCaptor.getValue();
+      stateListeners[3].onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+      forwardTimeByConnectionDelay();
+    } else {
+      stateListeners[0].onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+      for (int i = 1; i < stateListeners.length; i++) {
+        inOrder.verify(subchannels[i]).start(stateListenerCaptor.capture());
+        stateListeners[i] = stateListenerCaptor.getValue();
+        stateListeners[i].onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+      }
+    }
+
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    inOrder.verify(mockHelper).refreshNameResolution();
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    stateListeners[0].onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(mockSubchannel1, picker.pickSubchannel(mockArgs).getSubchannel());
+  }
+
+  @Test
+  public void pickAfterResolutionAfterTransientValue() {
+    InOrder inOrder = inOrder(mockHelper);
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(0));
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+
+    reset(mockHelper);
+
+    // An error has happened.
+    Status error = Status.UNAVAILABLE.withDescription("boom!");
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    inOrder.verify(mockHelper).refreshNameResolution();
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    // Transition from TRANSIENT_ERROR to CONNECTING should also be ignored.
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    verify(mockHelper, atLeast(0)).getSynchronizationContext();
+    verify(mockHelper, atLeast(0)).getScheduledExecutorService();
+    verifyNoMoreInteractions(mockHelper);
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+  }
+
+  @Test
+  public void pickWithDupAddressesUpDownUp() {
+    InOrder inOrder = inOrder(mockHelper);
+    SocketAddress socketAddress = servers.get(0).getAddresses().get(0);
+    EquivalentAddressGroup badEag = new EquivalentAddressGroup(
+        Lists.newArrayList(socketAddress, socketAddress));
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(badEag);
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+
+    reset(mockHelper);
+
+    // An error has happened.
+    Status error = Status.UNAVAILABLE.withDescription("boom!");
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    inOrder.verify(mockHelper).refreshNameResolution();
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    // Transition from TRANSIENT_ERROR to CONNECTING should also be ignored.
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    verify(mockHelper, atLeast(0)).getSynchronizationContext();
+    verify(mockHelper, atLeast(0)).getScheduledExecutorService();
+    verifyNoMoreInteractions(mockHelper);
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    // Transition from CONNECTING to READY .
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertEquals(Status.OK, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+  }
+
+  @Test
+  public void pickWithDupEagsUpDownUp() {
+    InOrder inOrder = inOrder(mockHelper);
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(0), servers.get(0));
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+
+    reset(mockHelper);
+
+    // An error has happened.
+    Status error = Status.UNAVAILABLE.withDescription("boom!");
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    inOrder.verify(mockHelper).refreshNameResolution();
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    // Transition from TRANSIENT_ERROR to CONNECTING should also be ignored.
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    verify(mockHelper, atLeast(0)).getSynchronizationContext();
+    verify(mockHelper, atLeast(0)).getScheduledExecutorService();
+    verifyNoMoreInteractions(mockHelper);
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    // Transition from CONNECTING to READY .
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertEquals(Status.OK, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+  }
+
+  @Test
+  public void nameResolutionError() {
+    Status error = Status.NOT_FOUND.withDescription("nameResolutionError");
+    loadBalancer.handleNameResolutionError(error);
+    verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    PickResult pickResult = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertNull(pickResult.getSubchannel());
+    assertEquals(error, pickResult.getStatus());
+    verify(mockSubchannel1, never()).requestConnection();
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void nameResolutionError_emptyAddressList() {
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(Collections.emptyList()).setAttributes(affinity).build());
+    verify(mockHelper).updateBalancingState(connectivityStateCaptor.capture(),
+        pickerCaptor.capture());
+    PickResult pickResult = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertThat(pickResult.getSubchannel()).isNull();
+    assertThat(pickResult.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(pickResult.getStatus().getDescription()).contains("no usable address");
+    verify(mockSubchannel1, never()).requestConnection();
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void nameResolutionAfterSufficientTFs_multipleEags() {
+    InOrder inOrder = inOrder(mockHelper);
+    acceptXSubchannels(3);
+    Status error = Status.UNAVAILABLE.withDescription("boom!");
+
+    // Initial subchannel gets TF, LB is still in CONNECTING
+    verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener1 = stateListenerCaptor.getValue();
+    stateListener1.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    assertEquals(Status.OK, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    // Second subchannel gets TF, no UpdateBalancingState called
+    verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+    inOrder.verify(mockHelper, never()).updateBalancingState(any(), any());
+
+    // Third subchannel gets TF, LB goes into TRANSIENT_FAILURE and does a refreshNameResolution
+    verify(mockSubchannel3).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener3 = stateListenerCaptor.getValue();
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    inOrder.verify(mockHelper).refreshNameResolution();
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    // Only after we have TFs reported for # of subchannels do we call refreshNameResolution
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).refreshNameResolution();
+
+    // Now that we have refreshed, the count should have been reset
+    // Only after we have TFs reported for # of subchannels do we call refreshNameResolution
+    stateListener1.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).refreshNameResolution();
+  }
+
+  @Test
+  public void nameResolutionAfterSufficientTFs_singleEag() {
+    InOrder inOrder = inOrder(mockHelper);
+    EquivalentAddressGroup eag = new EquivalentAddressGroup(Arrays.asList(
+        new FakeSocketAddress("server1"),
+        new FakeSocketAddress("server2"),
+        new FakeSocketAddress("server3")));
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(Arrays.asList(eag)).build());
+    Status error = Status.UNAVAILABLE.withDescription("boom!");
+
+    // Initial subchannel gets TF, LB is still in CONNECTING
+    verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener1 = stateListenerCaptor.getValue();
+    stateListener1.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    assertEquals(Status.OK, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    // Second subchannel gets TF, no UpdateBalancingState called
+    verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+    inOrder.verify(mockHelper, never()).updateBalancingState(any(), any());
+
+    // Third subchannel gets TF, LB goes into TRANSIENT_FAILURE and does a refreshNameResolution
+    verify(mockSubchannel3).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener3 = stateListenerCaptor.getValue();
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    inOrder.verify(mockHelper).refreshNameResolution();
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    // Only after we have TFs reported for # of subchannels do we call refreshNameResolution
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).refreshNameResolution();
+
+    // Now that we have refreshed, the count should have been reset
+    // Only after we have TFs reported for # of subchannels do we call refreshNameResolution
+    stateListener1.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).refreshNameResolution();
+  }
+
+  @Test
+  public void nameResolutionSuccessAfterError() {
+    loadBalancer.handleNameResolutionError(Status.NOT_FOUND.withDescription("nameResolutionError"));
+    verify(mockHelper)
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    verify(mockSubchannel1, never()).requestConnection();
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+
+    assertNull(pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertEquals(mockSubchannel1, pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+  }
+
+  @Test
+  public void nameResolutionTemporaryError() {
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(0));
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel1n2);
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener1 = stateListenerCaptor.getValue();
+    stateListener1.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertEquals(mockSubchannel1, pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+
+    loadBalancer.handleNameResolutionError(
+        Status.UNAVAILABLE.withDescription("nameResolutionError"));
+    inOrder.verify(mockHelper).updateBalancingState(
+        eq(TRANSIENT_FAILURE), any(SubchannelPicker.class));
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    inOrder.verify(mockSubchannel1n2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+
+    assertNull(pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertEquals(mockSubchannel1n2,
+        pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+  }
+
+
+  @Test
+  public void nameResolutionErrorWithStateChanges() {
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(0));
+    InOrder inOrder = inOrder(mockHelper);
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+    inOrder.verify(mockHelper).updateBalancingState(
+        eq(TRANSIENT_FAILURE), any(SubchannelPicker.class));
+    inOrder.verify(mockHelper).refreshNameResolution();
+    Status error = Status.NOT_FOUND.withDescription("nameResolutionError");
+    loadBalancer.handleNameResolutionError(error);
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    PickResult pickResult = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertNull(pickResult.getSubchannel());
+    assertEquals(error, pickResult.getStatus());
+
+    Status error2 = Status.NOT_FOUND.withDescription("nameResolutionError2");
+    loadBalancer.handleNameResolutionError(error2);
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+
+    pickResult = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertNull(pickResult.getSubchannel());
+    assertEquals(error2, pickResult.getStatus());
+  }
+
+  @Test
+  public void requestConnection() {
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4);
+    List<EquivalentAddressGroup> oldServers = Lists.newArrayList(servers.get(0), servers.get(1));
+
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1).requestConnection();
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+
+    // calling requestConnection() only starts next subchannel when it is in TF
+    loadBalancer.requestConnection();
+    inOrder.verify(mockSubchannel2, never()).start(any());
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+    loadBalancer.requestConnection();
+    inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel2).requestConnection();
+
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+
+    // calling requestConnection is now a no-op
+    loadBalancer.requestConnection();
+    inOrder.verify(mockHelper, never()).updateBalancingState(any(), any());
+    inOrder.verify(mockSubchannel1, never()).requestConnection();
+    inOrder.verify(mockSubchannel2, never()).requestConnection();
+  }
+
+  @Test
+  public void failChannelWhenSubchannelsFail() {
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(0), servers.get(1));
+    when(mockSubchannel1.getAllAddresses()).thenReturn(Lists.newArrayList(servers.get(0)));
+    when(mockSubchannel2.getAllAddresses()).thenReturn(Lists.newArrayList(servers.get(1)));
+
+    // accept resolved addresses
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2);
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    assertNull(pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+
+    inOrder.verify(mockSubchannel1).requestConnection();
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+
+    inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    assertEquals(CONNECTION_ERROR, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+  }
+
+  @Test
+  public void updateAddresses_emptyEagList_returns_false() {
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    assertFalse(loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(Collections.emptyList()).setAttributes(affinity).build()).isOk());
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+  }
+
+  @Test
+  public void updateAddresses_eagListWithNull_returns_false() {
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    List<EquivalentAddressGroup> eags = Collections.singletonList(null);
+    assertFalse(loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(eags).setAttributes(affinity).build()).isOk());
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+  }
+
+  @Test
+  public void updateAddresses_disjoint_idle() {
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4);
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers = Lists.newArrayList(servers.get(0), servers.get(1));
+    SubchannelStateListener stateListener2 = null;
+
+    // Accept Addresses and verify proper connection flow
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    forwardTimeByConnectionDelay();
+    if (enableHappyEyeballs) {
+      inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+      stateListener2 = stateListenerCaptor.getValue();
+    }
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // First connection attempt is successful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // Verify that picker returns correct subchannel
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel1), picker.pickSubchannel(mockArgs));
+
+    // Going into IDLE state
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    picker = pickerCaptor.getValue();
+
+    // Creating second set of disjoint endpoints/addresses
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(2), servers.get(3));
+
+    // Accept new resolved addresses to update
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+
+    // New channels not created until there is a request, remove old ones, keep intersecting ones
+    inOrder.verify(mockHelper, never()).createSubchannel(any());
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    verify(mockSubchannel1).shutdown();
+    if (enableHappyEyeballs) {
+      verify(mockSubchannel2).shutdown();
+    }
+
+    // If obsolete subchannel becomes ready, the state should not be affected
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    if (enableHappyEyeballs) {
+      stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    }
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+
+    // Calling pickSubchannel() creates the subchannel and starts a connection
+    picker.pickSubchannel(mockArgs);
+    inOrder.verify(mockSubchannel3).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener3 = stateListenerCaptor.getValue();
+
+    // But the picker calls requestConnection() only once
+    inOrder.verify(mockSubchannel3).requestConnection();
+
+    // Ready subchannel 3
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    // Picking a subchannel returns subchannel 3
+    picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel3), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void updateAddresses_disjoint_connecting() {
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4);
+
+    SubchannelStateListener stateListener2 = null;
+    SubchannelStateListener stateListener4 = null;
+
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers = Lists.newArrayList(servers.get(0), servers.get(1));
+
+    // Accept Addresses and verify proper connection flow
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1).requestConnection();
+    if (enableHappyEyeballs) {
+      forwardTimeByConnectionDelay();
+      inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+      stateListener2 = stateListenerCaptor.getValue();
+    }
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Creating second set of endpoints/addresses
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(2), servers.get(3));
+
+    // Accept new resolved addresses to update
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    forwardTimeByConnectionDelay();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel3).start(stateListenerCaptor.capture());
+    inOrder.verify(mockSubchannel3).requestConnection();
+    SubchannelStateListener stateListener3 = stateListenerCaptor.getValue();
+    if (enableHappyEyeballs) {
+      inOrder.verify(mockSubchannel4).start(stateListenerCaptor.capture());
+      stateListener4 = stateListenerCaptor.getValue();
+    }
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Old subchannels should shut down (in no particular order) and request a connection
+    verify(mockSubchannel1).shutdown();
+    if (enableHappyEyeballs) {
+      verify(mockSubchannel2).shutdown();
+    }
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // If old subchannel becomes ready, the state should not be affected
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    if (enableHappyEyeballs) {
+      stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    }
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Fail connection attempt to third address
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Verify starting connection attempt to fourth address
+    if (!enableHappyEyeballs) {
+      inOrder.verify(mockSubchannel4).start(stateListenerCaptor.capture());
+      stateListener4 = stateListenerCaptor.getValue();
+    }
+    inOrder.verify(mockSubchannel4).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Succeed connection attempt to fourth address
+    stateListener4.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // Verify that picker returns correct subchannel
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel4), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void updateAddresses_disjoint_ready_twice() {
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4, mockSubchannel1n2, mockSubchannel2n2);
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers = Lists.newArrayList(servers.get(0), servers.get(1));
+    SubchannelStateListener stateListener2 = null;
+    SubchannelStateListener stateListener4 = null;
+
+    // Accept Addresses and verify proper connection flow
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // First connection attempt is successful
+    inOrder.verify(mockSubchannel1).requestConnection();
+
+    // Trigger second subchannel to connect
+    if (enableHappyEyeballs) {
+      forwardTimeByConnectionDelay();
+      inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+      stateListener2 = stateListenerCaptor.getValue();
+      assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    }
+
+    // Mark first subchannel ready, verify state change
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+
+    if (enableHappyEyeballs) {
+      // Successful connection shuts down other subchannel
+      inOrder.verify(mockSubchannel2).shutdown();
+    }
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+
+    // Verify that picker returns correct subchannel
+    assertEquals(PickResult.withSubchannel(mockSubchannel1), picker.pickSubchannel(mockArgs));
+
+    // Creating second set of endpoints/addresses
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(2), servers.get(3));
+
+    // Accept new resolved addresses to update
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel1).shutdown();
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    inOrder.verify(mockSubchannel3, never()).start(stateListenerCaptor.capture());
+
+    // Trigger connection creation
+    picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withNoResult(), picker.pickSubchannel(mockArgs));
+    inOrder.verify(mockSubchannel3).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener3 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel3).requestConnection();
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+
+    if (enableHappyEyeballs) {
+      forwardTimeByConnectionDelay();
+      inOrder.verify(mockSubchannel4).start(stateListenerCaptor.capture());
+      stateListener4 = stateListenerCaptor.getValue();
+    }
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    picker = pickerCaptor.getValue();
+
+    // If obsolete subchannel becomes ready, the state should not be affected
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    if (enableHappyEyeballs) {
+      stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    }
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Calling pickSubchannel() twice gave the same result
+    assertEquals(picker.pickSubchannel(mockArgs), picker.pickSubchannel(mockArgs));
+
+    // The picker should only call requestConnection() once
+    picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withNoResult(), picker.pickSubchannel(mockArgs));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Ready subchannel 3
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+
+    if (enableHappyEyeballs) {
+      // Successful connection shuts down other subchannel
+      inOrder.verify(mockSubchannel4).shutdown();
+    }
+
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    picker = pickerCaptor.getValue();
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // Verify that pickSubchannel() returns correct subchannel
+    assertEquals(PickResult.withSubchannel(mockSubchannel3), picker.pickSubchannel(mockArgs));
+
+    // Creating third set of endpoints/addresses
+    List<EquivalentAddressGroup> newestServers = Lists.newArrayList(servers.get(0), servers.get(1));
+
+    // Second address update
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newestServers).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel3).shutdown();
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    picker = pickerCaptor.getValue();
+
+    // Calling pickSubchannel() twice gave the same result
+    assertEquals(picker.pickSubchannel(mockArgs), picker.pickSubchannel(mockArgs));
+
+    // But the picker calls requestConnection() only once
+    inOrder.verify(mockSubchannel1n2).start(stateListenerCaptor.capture());
+    stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1n2).requestConnection();
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    assertEquals(PickResult.withNoResult(), pickerCaptor.getValue().pickSubchannel(mockArgs));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // If obsolete subchannel becomes ready, the state should not be affected
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    if (enableHappyEyeballs) {
+      stateListener4.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    }
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Connection attempt to address 1 is unsuccessful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+
+    // Starting connection attempt to address 2
+    FakeSubchannel mockSubchannel2Attempt =
+        enableHappyEyeballs ? mockSubchannel2n2 : mockSubchannel2;
+    inOrder.verify(mockSubchannel2Attempt).start(stateListenerCaptor.capture());
+    stateListener2 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel2Attempt).requestConnection();
+
+    // Connection attempt to address 2 is successful
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel1n2).shutdown();
+
+    // Successful connection shuts down other subchannel
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    picker = pickerCaptor.getValue();
+
+    // Verify that picker still returns correct subchannel
+    assertEquals(
+        PickResult.withSubchannel(mockSubchannel2Attempt), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void updateAddresses_disjoint_transient_failure() {
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4);
+
+    SubchannelStateListener stateListener2 = null;
+
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> addrs = Lists.newArrayList(servers.get(0), servers.get(1));
+
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(addrs).setAttributes(affinity).build());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    if (enableHappyEyeballs) {
+      forwardTimeByConnectionDelay();
+      inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+      stateListener2 = stateListenerCaptor.getValue();
+    }
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Failing first connection attempt
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Starting second connection attempt
+    if (!enableHappyEyeballs) {
+      inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+      stateListener2 = stateListenerCaptor.getValue();
+    }
+    inOrder.verify(mockSubchannel2).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Failing second connection attempt
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    // sticky transient failure
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Creating second set of endpoints/addresses
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(2), servers.get(3));
+
+    // Accept new resolved addresses to update
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+
+    // subchannel 3 still attempts a connection even though we stay in transient failure
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel3).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener3 = stateListenerCaptor.getValue();
+    verify(mockSubchannel1).shutdown();
+    verify(mockSubchannel2).shutdown();
+    inOrder.verify(mockSubchannel3).requestConnection();
+
+    // obsolete subchannels should not affect us
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Third subchannel connection attempt is unsuccessful
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel4).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener4 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel4).requestConnection();
+
+    // Fourth subchannel connection attempt is successful
+    stateListener4.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockSubchannel3).shutdown();
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // Picking a subchannel returns subchannel 3
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel4), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void updateAddresses_intersecting_idle() {
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4);
+
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers =
+        Lists.newArrayList(servers.get(0), servers.get(1));
+
+    // Accept Addresses and verify proper connection flow
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    if (enableHappyEyeballs) {
+      forwardTimeByConnectionDelay();
+      inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    } else {
+      stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+      inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    }
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // First connection attempt is successful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // Successful connection attempt shuts down other subchannels
+    if (enableHappyEyeballs) {
+      inOrder.verify(mockSubchannel2).shutdown();
+    }
+
+    // Verify that picker returns correct subchannel
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel1), picker.pickSubchannel(mockArgs));
+
+    // Going into IDLE state, nothing should happen unless requested
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockHelper).refreshNameResolution();
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    picker = pickerCaptor.getValue();
+
+    // Creating second set of intersecting endpoints/addresses
+    List<EquivalentAddressGroup> newServers =
+        Lists.newArrayList(servers.get(0), servers.get(2), servers.get(3));
+
+    // Accept new resolved addresses to update
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+
+    // We create new channels and remove old ones, keeping intersecting ones
+    inOrder.verify(mockHelper, never()).createSubchannel(createArgsCaptor.capture());
+    forwardTimeByConnectionDelay(2);
+    verify(mockSubchannel3, never()).start(stateListenerCaptor.capture());
+    verify(mockSubchannel4, never()).start(stateListenerCaptor.capture());
+
+    // If obsolete subchannel becomes ready, the state should not be affected
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+
+    // Calling pickSubchannel() twice gave the same result
+    inOrder.verify(mockHelper, never()).updateBalancingState(any(), any());
+    assertEquals(picker.pickSubchannel(mockArgs), picker.pickSubchannel(mockArgs));
+    assertEquals(PickResult.withNoResult(), picker.pickSubchannel(mockArgs));
+    verify(mockSubchannel3, never()).start(stateListenerCaptor.capture());
+
+    // But the picker calls requestConnection() only once
+    inOrder.verify(mockSubchannel1).requestConnection();
+    inOrder.verify(mockSubchannel1, never()).requestConnection();
+
+    // internal subchannel calls back and reports connecting
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    assertEquals(PickResult.withNoResult(), pickerCaptor.getValue().pickSubchannel(mockArgs));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Ready subchannel 1
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    // Picking a subchannel returns subchannel 1 through multiple calls
+    picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel1), picker.pickSubchannel(mockArgs));
+    assertEquals(picker.pickSubchannel(mockArgs), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void updateAddresses_intersecting_connecting() {
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4);
+
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers =
+        Lists.newArrayList(servers.get(0), servers.get(1), servers.get(2));
+
+    // Accept Addresses and verify proper connection flow
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    forwardTimeByConnectionDelay(2);
+
+    // callback from internal subchannel
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    inOrder.verify(mockSubchannel1).requestConnection();
+
+    // Creating second set of endpoints/addresses
+    List<EquivalentAddressGroup> newServers =
+        Lists.newArrayList(servers.get(0), servers.get(1), servers.get(3), servers.get(4));
+
+    // Accept new resolved addresses to update
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper, never()).updateBalancingState(eq(CONNECTING), any());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // keep intersecting ones kept and start over so nothing should try to connect
+    verify(mockSubchannel1, never()).shutdown();
+    verify(mockSubchannel2, never()).shutdown();
+    inOrder.verify(mockSubchannel4, never()).requestConnection();
+    verify(mockSubchannel5, never()).start(stateListenerCaptor.capture());
+
+    if (enableHappyEyeballs) {
+      forwardTimeByConnectionDelay(2);
+      inOrder.verify(mockSubchannel1, never()).requestConnection();
+      inOrder.verify(mockSubchannel4).requestConnection();
+    }
+
+    // First connection attempt is successful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // verify that picker returns correct subchannel
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel1), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void updateAddresses_intersecting_ready() {
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4);
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers =
+        Lists.newArrayList(servers.get(0), servers.get(1));
+
+    // Accept Addresses and verify proper connection flow
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    forwardTimeByConnectionDelay();
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // First connection attempt is successful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // Verify that picker returns correct subchannel
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel1), picker.pickSubchannel(mockArgs));
+
+    // Creating second set of endpoints/addresses
+    List<EquivalentAddressGroup> newServers =
+        Lists.newArrayList(servers.get(0), servers.get(1), servers.get(2));
+    // Accept new resolved addresses to update
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+
+    // The state is still READY after update since we had an intersecting subchannel that was READY.
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // Verify that picker still returns correct subchannel
+    picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel1), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void updateAddresses_intersecting_transient_failure() {
+    assumeTrue(!isSerializingRetries());
+
+    // Starting first connection attempt
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4); // captor: captures
+
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers =
+        Lists.newArrayList(servers.get(0), servers.get(1));
+
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Failing first connection attempt
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Starting second connection attempt
+    inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel2).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Failing second connection attempt
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    // sticky transient failure
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Creating second set of endpoints/addresses
+    List<EquivalentAddressGroup> newServers =
+        Lists.newArrayList(servers.get(0), servers.get(1), servers.get(2));
+
+    // Accept new resolved addresses to update
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+
+    // subchannel 3 still attempts a connection even though we stay in transient failure
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel3).getAttributes();
+    inOrder.verify(mockSubchannel3).start(stateListenerCaptor.capture());
+    inOrder.verify(mockSubchannel3).requestConnection();
+
+    // no other connections should be requested by LB, we should come out of backoff to request
+    verifyNoMoreInteractions(mockSubchannel3);
+
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Second subchannel connection attempt is now successful
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel3).shutdown();
+
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    // Picking a subchannel returns subchannel 3
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel2), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void updateAddresses_intersecting_enter_transient_failure() {
+    // after an address update occurs, verify that the client properly tries all
+    // addresses and only then enters transient failure.
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4);
+
+    SubchannelStateListener stateListener3 = null;
+
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers = Lists.newArrayList(servers.get(0), servers.get(1));
+
+    // Accept Addresses and verify proper connection flow
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1).requestConnection();
+
+    if (enableHappyEyeballs) {
+      forwardTimeByConnectionDelay();
+      inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    }
+
+    // callback from internal subchannel
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+
+    // Creating second set of endpoints/addresses
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(0), servers.get(2));
+
+    // Accept new resolved addresses to update
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // We create new channels and remove old ones, keeping intersecting ones
+    if (enableHappyEyeballs) {
+      inOrder.verify(mockSubchannel2).shutdown();
+      forwardTimeByConnectionDelay();
+      inOrder.verify(mockSubchannel3).start(stateListenerCaptor.capture());
+      stateListener3 = stateListenerCaptor.getValue();
+    }
+
+    // First connection attempt is unsuccessful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    if (!enableHappyEyeballs) {
+      inOrder.verify(mockSubchannel3).start(stateListenerCaptor.capture());
+      stateListener3 = stateListenerCaptor.getValue();
+    }
+
+    // Subchannel 3 attempt starts but fails
+    inOrder.verify(mockSubchannel3).requestConnection();
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+  }
+
+  @Test
+  public void updateAddresses_identical_idle() {
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4);
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers = Lists.newArrayList(servers.get(0), servers.get(1));
+
+    // Accept Addresses and verify proper connection flow
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // First connection attempt is successful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // Verify that picker returns correct subchannel
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel1), picker.pickSubchannel(mockArgs));
+
+    // Going into IDLE state
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+
+    // Accept same resolved addresses to update
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+
+    // Verify that no new subchannels were created or started
+    verify(mockHelper, times(1)).createSubchannel(createArgsCaptor.capture());
+    verify(mockSubchannel1, times(1)).start(stateListenerCaptor.capture());
+    verify(mockSubchannel2, times(0)).start(stateListenerCaptor.capture());
+
+    // First connection attempt is successful
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // verify that picker returns correct subchannel
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel1), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void updateAddresses_identical_connecting() {
+    InOrder inOrder = inOrder(mockHelper);
+
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers = Lists.newArrayList(servers.get(0), servers.get(1));
+
+    // Accept Addresses and verify proper connection flow
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).createSubchannel(any());
+    verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Accept same resolved addresses to update
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+
+    // Verify that started over and found a noop on connecting for first subchannel
+    inOrder.verify(mockHelper, never()).createSubchannel(any());
+
+    if (enableHappyEyeballs) {
+      forwardTimeByConnectionDelay();
+      inOrder.verify(mockHelper).createSubchannel(any());
+      verify(mockSubchannel2).start(any());
+    }
+
+    // Accept same resolved addresses to update - all were connecting, no updateBalancingState
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockHelper, never()).updateBalancingState(any(), any());
+
+    // Verify that no new subchannels were created or started
+    inOrder.verify(mockHelper, never()).createSubchannel(any());
+    verify(mockSubchannel1, times(1)).start(any());
+    if (enableHappyEyeballs) {
+      verify(mockSubchannel2, times(1)).start(any());
+    } else {
+      verify(mockSubchannel2, times(0)).start(any());
+    }
+
+    // First connection attempt is successful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // verify that picker returns correct subchannel
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel1), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void updateAddresses_identical_ready() {
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers = Lists.newArrayList(servers.get(0), servers.get(1));
+
+    // Accept Addresses and verify proper connection flow
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // First connection attempt is successful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // verify that picker returns correct subchannel
+    verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel1), picker.pickSubchannel(mockArgs));
+
+    // Accept same resolved addresses to update
+    reset(mockHelper);
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    fakeClock.forwardTime(CONNECTION_DELAY_INTERVAL_MS, TimeUnit.MILLISECONDS);
+
+    // Verify that no new subchannels were created or started
+    verify(mockSubchannel2,never()).start(any());
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // verify that picker hasn't changed via checking mock helper's interactions
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void updateAddresses_identical_transient_failure() {
+    assumeTrue(!isSerializingRetries());
+
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4);
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers = Lists.newArrayList(servers.get(0), servers.get(1));
+
+    // Accept Addresses and verify proper connection flow
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // First connection attempt is unsuccessful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Second connection attempt is unsuccessful
+    inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    inOrder.verify(mockHelper).refreshNameResolution();
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Accept same resolved addresses to update
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+
+    // Verify that no new subchannels were created or started
+    verify(mockHelper, times(2)).createSubchannel(createArgsCaptor.capture());
+    verify(mockSubchannel1, times(1)).start(stateListenerCaptor.capture());
+    verify(mockSubchannel2, times(1)).start(stateListenerCaptor.capture());
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // No new connections are requested, subchannels responsible for completing their own backoff
+    verify(mockHelper, atLeast(0)).getSynchronizationContext();  // Don't care
+    verify(mockHelper, atLeast(0)).getScheduledExecutorService();
+    verifyNoMoreInteractions(mockHelper);
+
+    // First connection attempt is successful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel2).shutdown();
+
+    // verify that picker returns correct subchannel
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel1), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void updateAddresses_identicalSingleAddress_connecting() {
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers = Lists.newArrayList(servers.get(0));
+
+    // Accept Addresses and verify proper connection flow
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // First connection attempt is successful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    fakeClock.forwardTime(CONNECTION_DELAY_INTERVAL_MS, TimeUnit.MILLISECONDS);
+
+    // verify that picker returns no subchannel
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withNoResult(), picker.pickSubchannel(mockArgs));
+
+    // Accept same resolved addresses to update
+    reset(mockHelper);
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    fakeClock.forwardTime(CONNECTION_DELAY_INTERVAL_MS, TimeUnit.MILLISECONDS);
+
+    // Verify that no new subchannels were created or started
+    verify(mockSubchannel2, never()).start(any());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // verify that picker hasn't changed via checking mock helper's interactions
+    verify(mockHelper, atLeast(0)).getSynchronizationContext();  // Don't care
+    verify(mockHelper, atLeast(0)).getScheduledExecutorService();
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void twoAddressesSeriallyConnect() {
+    // Starting first connection attempt
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2, mockSubchannel3);
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1).requestConnection();
+
+    // Failing first connection attempt
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Starting second connection attempt
+    inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel2).requestConnection();
+
+    // Second connection attempt is successful
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // Verify that picker returns correct subchannel
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel2), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void multiple_backoffs() {
+    // This test case mimics a backoff without implementing one
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4);
+
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(0), servers.get(1));
+
+    // Starting first connection attempt
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1).requestConnection();
+
+    // Failing first connection attempt
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Starting second connection attempt
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel2).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Failing second connection attempt
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    inOrder.verify(mockHelper).refreshNameResolution();
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // backoff for first address
+    forwardTimeByConnectionDelay();
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Mimic backoff for second address
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Failing first connection attempt
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Failing second connection attempt
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Mimic backoff for first address
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Mimic backoff for second address
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Connection attempt to second address is now successful
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel1).shutdown();
+
+    // Verify that picker returns correct subchannel
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    when(mockSubchannel2.getAllAddresses()).thenReturn(Lists.newArrayList(servers.get(0)));
+    assertEquals(PickResult.withSubchannel(mockSubchannel2), picker.pickSubchannel(mockArgs));
+
+    // If first subchannel is ready before it completes shutdown, we still choose subchannel 2
+    // This can be verified by checking the mock helper actions after setting it READY.
+    reset(mockHelper);
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+
+    // Happy Eyeballs, once transient failure is reported, no longer schedules connections.
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void backoff_faster_than_serial_connection() {
+    // this tests the case where a subchannel completes its backoff and readies a connection
+    // before the other addresses have a chance to complete their connection attempts
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4); // captor: captures
+
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> addrs = Lists.newArrayList(servers.get(0),
+        servers.get(1));
+
+    // Accepting resolved addresses starts all subchannels
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(addrs).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Failing first connection attempt
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Starting second connection attempt
+    inOrder.verify(mockSubchannel2).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Mimic backoff for first address
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Connection attempt to first address is now successful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // verify that picker returns correct subchannel
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel1), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void success_from_transient_failure() {
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4);
+
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> addrs = Lists.newArrayList(servers.get(0), servers.get(1));
+
+    // Accepting resolved addresses starts first subchannel and cascades on failures
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(addrs).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Failing first connection attempt
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Starting second connection attempt
+    inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel2).requestConnection();
+
+    // Mimic backoff for first address
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Failing second connection attempt
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    inOrder.verify(mockHelper).refreshNameResolution();
+    //   sticky transient failure
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Failing connection attempt to first address
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Mimic backoff for second address
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Connection attempt to second address is now successful
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel1).shutdown();
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    // Verify that picker returns correct subchannel
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel2), picker.pickSubchannel(mockArgs));
+
+    // If first address is successful, nothing happens. Verify by checking mock helper
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper,never()).updateBalancingState(any(), any());
+    inOrder.verify(mockHelper,never()).createSubchannel(any());
+  }
+
+  @Test
+  public void lastAddressFailingNotTransientFailure() {
+    // This tests the case where after an address update, the last address escapes a backoff
+    // and reports transient failure before all addresses have failed connection
+    // attempts, in which case we should not report TRANSIENT_FAILURE.
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4);
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> oldServers = Lists.newArrayList(servers.get(0), servers.get(1));
+    SubchannelStateListener stateListener2 = null;
+
+    // Accept Addresses and verify proper connection flow
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(oldServers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1).requestConnection();
+    forwardTimeByConnectionDelay();
+
+    if (enableHappyEyeballs) {
+      inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+      stateListener2 = stateListenerCaptor.getValue();
+    }
+
+    // First connection attempt is unsuccessful
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Second connection attempt is connecting
+    if (!enableHappyEyeballs) {
+      inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+      stateListener2 = stateListenerCaptor.getValue();
+    }
+    inOrder.verify(mockSubchannel2).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Accept same resolved addresses to update
+    List<EquivalentAddressGroup> newServers = Lists.newArrayList(servers.get(2), servers.get(1));
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+
+    // Subchannel 2 should be reused since it was trying to connect and is present.
+    inOrder.verify(mockSubchannel1).shutdown();
+    inOrder.verify(mockSubchannel3, never()).start(stateListenerCaptor.capture());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Second address connection attempt is unsuccessful, so since at end, but don't have all
+    // subchannels, schedule a backoff for the first address
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    fakeClock.forwardTime(1, TimeUnit.SECONDS);
+    inOrder.verify(mockSubchannel3).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener3 = stateListenerCaptor.getValue();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Third address connection attempt is unsuccessful, now we enter TF, do name resolution
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // obsolete subchannels have no impact
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+
+    // Second subchannel is successful
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // verify that picker returns correct subchannel
+    inOrder.verify(mockSubchannel3).shutdown();
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel2), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void recreate_shutdown_subchannel() {
+    // Take the case where the latter subchannel is readied. If we then go to an IDLE state and
+    // re-request a connection, we should start and create a new subchannel for the first
+    // address in our list.
+
+    // Starting first connection attempt
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4, mockSubchannel1n2); // captor: captures
+
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> addrs =
+        Lists.newArrayList(servers.get(0), servers.get(1));
+
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(addrs).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Failing first connection attempt
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Starting second connection attempt
+    inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel2).requestConnection();
+
+    // Successful second connection attempt
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockSubchannel1).shutdown();
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // Go to IDLE
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+
+    SubchannelPicker picker = pickerCaptor.getValue();
+
+    // Calling pickSubchannel() requests a connection.
+    assertEquals(picker.pickSubchannel(mockArgs), picker.pickSubchannel(mockArgs));
+    inOrder.verify(mockSubchannel1n2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener3 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1n2).requestConnection();
+    when(mockSubchannel1.getAllAddresses()).thenReturn(Lists.newArrayList(servers.get(0)));
+
+    // gives the same result when called twice
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // third subchannel connection attempt fails
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // second subchannel connection attempt succeeds
+    inOrder.verify(mockSubchannel2).requestConnection();
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockSubchannel1n2).shutdown();
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // verify that picker returns correct subchannel
+    picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel2), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void shutdown() {
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2, mockSubchannel3,
+        mockSubchannel4, mockSubchannel5);
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).build());
+
+    forwardTimeByConnectionDelay(servers.size() - 1);
+    int expectedSubchannelsCreated = enableHappyEyeballs ? servers.size() : 1;
+    inOrder.verify(mockHelper, times(expectedSubchannelsCreated)).createSubchannel(any());
+
+    loadBalancer.shutdown();
+
+    inOrder.verify(mockSubchannel1).shutdown();
+    if (enableHappyEyeballs) {
+      verify(mockSubchannel2).shutdown();
+      verify(mockSubchannel3).shutdown();
+      verify(mockSubchannel4).shutdown();
+      verify(mockSubchannel5).shutdown();
+    }
+    assertEquals(SHUTDOWN, loadBalancer.getConcludedConnectivityState());
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).build());
+    forwardTimeByConnectionDelay();
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+    inOrder.verify(mockSubchannel1, never()).start(any());
+    inOrder.verify(mockSubchannel1, never()).requestConnection();
+    inOrder.verify(mockSubchannel2, never()).requestConnection();
+  }
+
+  @Test
+  public void ready_then_transient_failure_again() {
+    // Starting first connection attempt
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2,
+        mockSubchannel3, mockSubchannel4, mockSubchannel1n2); // captor: captures
+
+    // Creating first set of endpoints/addresses
+    List<EquivalentAddressGroup> addrs =
+        Lists.newArrayList(servers.get(0), servers.get(1));
+
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(addrs).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Failing first connection attempt
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Starting second connection attempt
+    inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel2).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Successful second connection attempt
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockSubchannel1).shutdown();
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // Go to IDLE
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+
+    SubchannelPicker picker = pickerCaptor.getValue();
+
+    // Calling pickSubchannel() requests a connection, gives the same result when called twice.
+    assertEquals(picker.pickSubchannel(mockArgs), picker.pickSubchannel(mockArgs));
+    inOrder.verify(mockSubchannel1n2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener3 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel1n2).requestConnection();
+    when(mockSubchannel3.getAllAddresses()).thenReturn(Lists.newArrayList(servers.get(0)));
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // first subchannel connection attempt fails
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forTransientFailure(CONNECTION_ERROR));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // second subchannel connection attempt
+    inOrder.verify(mockSubchannel2).requestConnection();
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // verify that picker returns correct subchannel
+    inOrder.verify(mockSubchannel1n2).shutdown();
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel2), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void happy_eyeballs_trigger_connection_delay() {
+    assumeTrue(enableHappyEyeballs); // This test is only for happy eyeballs
+    // Starting first connection attempt
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1,
+        mockSubchannel2, mockSubchannel3, mockSubchannel4);
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    inOrder.verify(mockSubchannel1).requestConnection();
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+
+    // Until we hit the connection delay interval threshold, nothing should happen
+    verifyNoMoreInteractions(mockSubchannel2);
+    fakeClock.forwardTime(CONNECTION_DELAY_INTERVAL_MS - 1, TimeUnit.MILLISECONDS);
+    verifyNoMoreInteractions(mockSubchannel2);
+
+    // After 250 ms, second connection attempt starts
+    fakeClock.forwardTime(1, TimeUnit.MILLISECONDS);
+    verify(mockHelper, times(2)).createSubchannel(createArgsCaptor.capture());
+    inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel2).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    verifyNoMoreInteractions(mockSubchannel3);
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Second connection attempt is successful
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // Verify that picker returns correct subchannel
+    inOrder.verify(mockSubchannel1).shutdown();
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel2), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void happy_eyeballs_connection_results_happen_after_get_to_end() {
+    assumeTrue(enableHappyEyeballs); // This test is only for happy eyeballs
+
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2, mockSubchannel3);
+    Status error = Status.UNAUTHENTICATED.withDescription("simulated failure");
+
+    List<EquivalentAddressGroup> addrs =
+        Lists.newArrayList(servers.get(0), servers.get(1), servers.get(2));
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(addrs).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    forwardTimeByConnectionDelay(2);
+    inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    inOrder.verify(mockSubchannel3).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener3 = stateListenerCaptor.getValue();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // first connection attempt fails
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Move off the end of the list, but connections requests haven't been completed
+    forwardTimeByConnectionDelay();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // second connection attempt fails
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    // second connection attempt fails again, but still haven't finished third subchannel
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+
+    // last subchannel's connection attempt fails
+    stateListener3.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockHelper).refreshNameResolution();
+
+
+    // Refail the first one, after third time should refreshNameResolution
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper, never()).refreshNameResolution();
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).refreshNameResolution();
+  }
+
+
+  @Test
+  public void happy_eyeballs_pick_pushes_index_over_end() {
+    assumeTrue(enableHappyEyeballs); // This test is only for happy eyeballs
+
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2, mockSubchannel3,
+        mockSubchannel2n2, mockSubchannel3n2);
+    Status error = Status.UNAUTHENTICATED.withDescription("simulated failure");
+
+    List<EquivalentAddressGroup> addrs =
+        Lists.newArrayList(servers.get(0), servers.get(1), servers.get(2));
+    Subchannel[] subchannels = new Subchannel[] {mockSubchannel1, mockSubchannel2, mockSubchannel3};
+    SubchannelStateListener[] listeners = new SubchannelStateListener[subchannels.length];
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(addrs).setAttributes(affinity).build());
+    forwardTimeByConnectionDelay(2);
+    for (int i = 0; i < subchannels.length; i++) {
+      inOrder.verify(subchannels[i]).start(stateListenerCaptor.capture());
+      listeners[i] = stateListenerCaptor.getValue();
+      listeners[i].onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    }
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(addrs).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    SubchannelPicker requestingPicker = pickerCaptor.getValue();
+
+    // First pick moves index to addr 2
+    PickResult pickResult = requestingPicker.pickSubchannel(mockArgs);
+    assertEquals("RequestConnectionPicker", requestingPicker.getClass().getSimpleName());
+    assertEquals(PickResult.withNoResult(), pickResult);
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+
+    // Second pick moves index to addr 3
+    pickResult = requestingPicker.pickSubchannel(mockArgs);
+    assertEquals(PickResult.withNoResult(), pickResult);
+
+    // Sending TF state to one subchannel pushes index past end, but shouldn't do anything
+    listeners[2].onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper, never()).updateBalancingState(eq(TRANSIENT_FAILURE), any());
+
+    // Put the LB into TF
+    listeners[0].onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    listeners[1].onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    PickResult pickResultTF = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertFalse(pickResultTF.getStatus().isOk());
+
+    // Doing a pick on the old RequestConnectionPicker when past the index end
+    pickResult = requestingPicker.pickSubchannel(mockArgs);
+    assertEquals(PickResult.withNoResult(), pickResult);
+    inOrder.verify(mockHelper, never()).updateBalancingState(any(), any());
+
+    // Try pushing after end with just picks
+    listeners[0].onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    verify(mockSubchannel2).shutdown();
+    verify(mockSubchannel3).shutdown();
+    listeners[0].onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(addrs).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    SubchannelPicker requestingPicker2 = pickerCaptor.getValue();
+    for (int i = 0; i <= subchannels.length; i++) {
+      pickResult = requestingPicker2.pickSubchannel(mockArgs);
+      assertEquals(PickResult.withNoResult(), pickResult);
+    }
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+
+    listeners[0].onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockSubchannel2n2).start(stateListenerCaptor.capture());
+    stateListenerCaptor.getValue().onSubchannelState(
+        ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockSubchannel3n2).start(stateListenerCaptor.capture());
+    stateListenerCaptor.getValue().onSubchannelState(
+        ConnectivityStateInfo.forTransientFailure(error));
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+  }
+
+  @Test
+  public void happy_eyeballs_fail_then_trigger_connection_delay() {
+    assumeTrue(enableHappyEyeballs); // This test is only for happy eyeballs
+    // Starting first connection attempt
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2, mockSubchannel3);
+    assertEquals(IDLE, loadBalancer.getConcludedConnectivityState());
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    inOrder.verify(mockSubchannel1).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // indicates scheduling a connection
+    inOrder.verify(mockSubchannel1).requestConnection();
+    inOrder.verify(mockHelper).getSynchronizationContext();
+    inOrder.verify(mockHelper).getScheduledExecutorService();
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Until we hit the connection delay interval threshold, no connections should be requested
+    verify(mockSubchannel1, times(1)).requestConnection();
+    verify(mockSubchannel2, times(0)).requestConnection();
+    fakeClock.forwardTime(CONNECTION_DELAY_INTERVAL_MS - 1, TimeUnit.MILLISECONDS);
+    verify(mockSubchannel1, times(1)).requestConnection();
+    verify(mockSubchannel2, times(0)).requestConnection();
+
+    // If a connection fails, the next scheduled connection is reset to happen 250 ms later
+    Status error = Status.UNAUTHENTICATED.withDescription("simulated failure");
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+    verify(mockSubchannel2, times(1)).requestConnection();
+
+    // This time, after 1 ms, no connection attempt occurs
+    fakeClock.forwardTime(1, TimeUnit.MILLISECONDS);
+    inOrder.verify(mockSubchannel2).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener2 = stateListenerCaptor.getValue();
+    verify(mockSubchannel1, times(1)).requestConnection();
+    verify(mockSubchannel2, times(1)).requestConnection();
+
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    verify(mockSubchannel3, times(0)).requestConnection();
+
+    // After 250 ms, second connection attempt starts
+    // Skip subchannel 2 and request to address 3
+    fakeClock.forwardTime(CONNECTION_DELAY_INTERVAL_MS - 1, TimeUnit.MILLISECONDS);
+    verify(mockSubchannel1, times(1)).requestConnection();
+    verify(mockSubchannel2, times(1)).requestConnection();
+    verify(mockSubchannel3, times(1)).requestConnection();
+    fakeClock.forwardTime(1, TimeUnit.MILLISECONDS);
+    inOrder.verify(mockSubchannel2).requestConnection();
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Simulate first connection attempt coming out of backoff
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    assertEquals(CONNECTING, loadBalancer.getConcludedConnectivityState());
+
+    // Both subchannels racing, second connection attempt is successful
+    stateListener2.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    assertEquals(READY, loadBalancer.getConcludedConnectivityState());
+
+    // Verify that picker returns correct subchannel
+    inOrder.verify(mockSubchannel1).shutdown();
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertEquals(PickResult.withSubchannel(mockSubchannel2), picker.pickSubchannel(mockArgs));
+  }
+
+  @Test
+  public void advance_index_then_request_connection() {
+    loadBalancer.requestConnection(); // should be handled without throwing exception
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    forwardTimeByConnectionDelay(servers.size());
+
+    loadBalancer.requestConnection(); // should be handled without throwing exception
+  }
+
+  @Test
+  public void serialized_retries_two_passes() {
+    assumeTrue(serializeRetries); // This test is only for serialized retries
+
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel1, mockSubchannel2, mockSubchannel3);
+    Status error = Status.UNAUTHENTICATED.withDescription("simulated failure");
+
+    List<EquivalentAddressGroup> addrs =
+        Lists.newArrayList(servers.get(0), servers.get(1), servers.get(2));
+    Subchannel[] subchannels = new Subchannel[]{mockSubchannel1, mockSubchannel2, mockSubchannel3};
+    SubchannelStateListener[] listeners = new SubchannelStateListener[subchannels.length];
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(addrs).build());
+    forwardTimeByConnectionDelay(2);
+    for (int i = 0; i < subchannels.length; i++) {
+      inOrder.verify(subchannels[i]).start(stateListenerCaptor.capture());
+      inOrder.verify(subchannels[i]).requestConnection();
+      listeners[i] = stateListenerCaptor.getValue();
+      listeners[i].onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    }
+    assertEquals(TRANSIENT_FAILURE, loadBalancer.getConcludedConnectivityState());
+    assertFalse("Index should be at end", loadBalancer.isIndexValid());
+
+    forwardTimeByBackoffDelay(); // should trigger retry
+    for (int i = 0; i < subchannels.length; i++) {
+      inOrder.verify(subchannels[i]).requestConnection();
+      listeners[i].onSubchannelState(ConnectivityStateInfo.forTransientFailure(error)); // cascade
+    }
+    inOrder.verify(subchannels[0], never()).requestConnection(); // should wait for backoff delay
+
+    forwardTimeByBackoffDelay(); // should trigger retry again
+    for (int i = 0; i < subchannels.length; i++) {
+      inOrder.verify(subchannels[i]).requestConnection();
+      assertEquals(i, loadBalancer.getIndexLocation());
+      listeners[i].onSubchannelState(ConnectivityStateInfo.forTransientFailure(error)); // cascade
+    }
+  }
+
+  @Test
+  public void index_looping() {
+    Attributes.Key<String> key = Attributes.Key.create("some-key");
+    Attributes attr1 = Attributes.newBuilder().set(key, "1").build();
+    Attributes attr2 = Attributes.newBuilder().set(key, "2").build();
+    Attributes attr3 = Attributes.newBuilder().set(key, "3").build();
+    SocketAddress addr1 = new FakeSocketAddress("addr1");
+    SocketAddress addr2 = new FakeSocketAddress("addr2");
+    SocketAddress addr3 = new FakeSocketAddress("addr3");
+    SocketAddress addr4 = new FakeSocketAddress("addr4");
+    SocketAddress addr5 = new FakeSocketAddress("addr5");
+    PickFirstLeafLoadBalancer.Index index = new PickFirstLeafLoadBalancer.Index(Arrays.asList(
+        new EquivalentAddressGroup(Arrays.asList(addr1, addr2), attr1),
+        new EquivalentAddressGroup(Arrays.asList(addr3), attr2),
+        new EquivalentAddressGroup(Arrays.asList(addr4, addr5), attr3)), enableHappyEyeballs);
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);
+    assertThat(index.isAtBeginning()).isTrue();
+    assertThat(index.isValid()).isTrue();
+
+    index.increment();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr2);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);
+    assertThat(index.isAtBeginning()).isFalse();
+    assertThat(index.isValid()).isTrue();
+
+    index.increment();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr3);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr2);
+    assertThat(index.isAtBeginning()).isFalse();
+    assertThat(index.isValid()).isTrue();
+
+    index.increment();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr4);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr3);
+    assertThat(index.isAtBeginning()).isFalse();
+    assertThat(index.isValid()).isTrue();
+
+    index.increment();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr5);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr3);
+    assertThat(index.isAtBeginning()).isFalse();
+    assertThat(index.isValid()).isTrue();
+
+    index.increment();
+    assertThat(index.isAtBeginning()).isFalse();
+    assertThat(index.isValid()).isFalse();
+
+    index.reset();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);
+    assertThat(index.isAtBeginning()).isTrue();
+    assertThat(index.isValid()).isTrue();
+
+    // We want to make sure both groupIndex and addressIndex are reset
+    index.increment();
+    index.increment();
+    index.increment();
+    index.increment();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr5);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr3);
+    index.reset();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attr1);
+  }
+
+  @Test
+  public void index_updateGroups_resets() {
+    SocketAddress addr1 = new FakeSocketAddress("addr1");
+    SocketAddress addr2 = new FakeSocketAddress("addr2");
+    SocketAddress addr3 = new FakeSocketAddress("addr3");
+    PickFirstLeafLoadBalancer.Index index = new PickFirstLeafLoadBalancer.Index(Arrays.asList(
+        new EquivalentAddressGroup(Arrays.asList(addr1)),
+        new EquivalentAddressGroup(Arrays.asList(addr2, addr3))), enableHappyEyeballs);
+    index.increment();
+    index.increment();
+    // We want to make sure both groupIndex and addressIndex are reset
+    index.updateGroups(ImmutableList.of(
+        new EquivalentAddressGroup(Arrays.asList(addr1)),
+        new EquivalentAddressGroup(Arrays.asList(addr2, addr3))));
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
+  }
+
+  @Test
+  public void index_seekTo() {
+    SocketAddress addr1 = new FakeSocketAddress("addr1");
+    SocketAddress addr2 = new FakeSocketAddress("addr2");
+    SocketAddress addr3 = new FakeSocketAddress("addr3");
+    PickFirstLeafLoadBalancer.Index index = new PickFirstLeafLoadBalancer.Index(Arrays.asList(
+        new EquivalentAddressGroup(Arrays.asList(addr1, addr2)),
+        new EquivalentAddressGroup(Arrays.asList(addr3))), enableHappyEyeballs);
+    assertThat(index.seekTo(addr3)).isTrue();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr3);
+    assertThat(index.seekTo(addr1)).isTrue();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1);
+    assertThat(index.seekTo(addr2)).isTrue();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr2);
+    index.seekTo(new FakeSocketAddress("addr4"));
+    // Failed seekTo doesn't change the index
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr2);
+  }
+
+  @Test
+  public void index_interleaving() {
+    InetSocketAddress addr1_6 = new InetSocketAddress("f38:1:1", 1234);
+    InetSocketAddress addr1_4 = new InetSocketAddress("10.1.1.1", 1234);
+    InetSocketAddress addr2_4 = new InetSocketAddress("10.1.1.2", 1234);
+    InetSocketAddress addr3_4 = new InetSocketAddress("10.1.1.3", 1234);
+    InetSocketAddress addr4_4 = new InetSocketAddress("10.1.1.4", 1234);
+    InetSocketAddress addr4_6 = new InetSocketAddress("f38:1:4", 1234);
+
+    Attributes attrs1 = Attributes.newBuilder().build();
+    Attributes attrs2 = Attributes.newBuilder().build();
+    Attributes attrs3 = Attributes.newBuilder().build();
+    Attributes attrs4 = Attributes.newBuilder().build();
+
+    PickFirstLeafLoadBalancer.Index index = new PickFirstLeafLoadBalancer.Index(Arrays.asList(
+        new EquivalentAddressGroup(Arrays.asList(addr1_4, addr1_6), attrs1),
+        new EquivalentAddressGroup(Arrays.asList(addr2_4), attrs2),
+        new EquivalentAddressGroup(Arrays.asList(addr3_4), attrs3),
+        new EquivalentAddressGroup(Arrays.asList(addr4_4, addr4_6), attrs4)), enableHappyEyeballs);
+
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1_4);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attrs1);
+    assertThat(index.isAtBeginning()).isTrue();
+
+    index.increment();
+    assertThat(index.isValid()).isTrue();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1_6);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attrs1);
+    assertThat(index.isAtBeginning()).isFalse();
+
+    index.increment();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr2_4);
+    assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attrs2);
+
+    index.increment();
+    if (enableHappyEyeballs) {
+      assertThat(index.getCurrentAddress()).isSameInstanceAs(addr4_6);
+      assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attrs4);
+    } else {
+      assertThat(index.getCurrentAddress()).isSameInstanceAs(addr3_4);
+      assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attrs3);
+    }
+
+    index.increment();
+    if (enableHappyEyeballs) {
+      assertThat(index.getCurrentAddress()).isSameInstanceAs(addr3_4);
+      assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attrs3);
+    } else {
+      assertThat(index.getCurrentAddress()).isSameInstanceAs(addr4_4);
+      assertThat(index.getCurrentEagAttributes()).isSameInstanceAs(attrs4);
+    }
+
+    // Move to last entry
+    assertThat(index.increment()).isTrue();
+    assertThat(index.isValid()).isTrue();
+    if (enableHappyEyeballs) {
+      assertThat(index.getCurrentAddress()).isSameInstanceAs(addr4_4);
+    } else {
+      assertThat(index.getCurrentAddress()).isSameInstanceAs(addr4_6);
+    }
+
+    // Move off of the end
+    assertThat(index.increment()).isFalse();
+    assertThat(index.isValid()).isFalse();
+    assertThrows(IllegalStateException.class, index::getCurrentAddress);
+
+    // Reset
+    index.reset();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr1_4);
+    assertThat(index.isAtBeginning()).isTrue();
+    assertThat(index.isValid()).isTrue();
+
+    // Seek to an address
+    assertThat(index.seekTo(addr4_4)).isTrue();
+    assertThat(index.getCurrentAddress()).isSameInstanceAs(addr4_4);
+  }
+
+  private static class FakeSocketAddress extends SocketAddress {
+    final String name;
+
+    FakeSocketAddress(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public String toString() {
+      return "FakeSocketAddress(" + name + ")";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (!(o instanceof FakeSocketAddress)) {
+        return false;
+      }
+      FakeSocketAddress that = (FakeSocketAddress) o;
+      return this.name.equals(that.name);
+    }
+
+    @Override
+    public int hashCode() {
+      return name.hashCode();
+    }
+  }
+
+  private void forwardTimeByConnectionDelay() {
+    fakeClock.forwardTime(CONNECTION_DELAY_INTERVAL_MS, TimeUnit.MILLISECONDS);
+  }
+
+  private void forwardTimeByConnectionDelay(int times) {
+    for (int i = 0; i < times; i++) {
+      forwardTimeByConnectionDelay();
+    }
+  }
+
+  private void forwardTimeByBackoffDelay() {
+    backoffMillis = (long) (backoffMillis * 1.8); // backoff factor default is 1.6 with Jitter .2
+    fakeClock.forwardTime(backoffMillis, TimeUnit.MILLISECONDS);
+  }
+
+  private void acceptXSubchannels(int num) {
+    List<EquivalentAddressGroup> newServers = new ArrayList<>();
+    for (int i = 0; i < num; i++) {
+      newServers.add(servers.get(i));
+    }
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+  }
+
+  /**
+   * This is currently only used for mocks, but could be used in a real test.
+   */
+  private static class FakeSubchannel extends Subchannel {
+    private final Attributes attributes;
+    private List<EquivalentAddressGroup> eags;
+    private SubchannelStateListener listener;
+
+    @Keep
+    public FakeSubchannel(List<EquivalentAddressGroup> eags, Attributes attributes) {
+      this.eags = Collections.unmodifiableList(eags);
+      this.attributes = attributes;
+    }
+
+    @Override
+    public List<EquivalentAddressGroup> getAllAddresses() {
+      return eags;
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return attributes;
+    }
+
+    @Override
+    public void start(SubchannelStateListener listener) {
+      this.listener = checkNotNull(listener, "listener");
+    }
+
+    @Override
+    public void updateAddresses(List<EquivalentAddressGroup> addrs) {
+      this.eags = Collections.unmodifiableList(addrs);
+    }
+
+    @Override
+    public void shutdown() {
+      listener.onSubchannelState(ConnectivityStateInfo.forNonError(SHUTDOWN));
+    }
+
+    @Override
+    public void requestConnection() {
+    }
+
+    @Override
+    public String toString() {
+      return "FakeSubchannel@" + hashCode() + "(" + eags + ")";
+    }
+  }
+
+  private class MockHelperImpl extends LoadBalancer.Helper {
+    private final List<Subchannel> subchannels;
+
+    public MockHelperImpl(List<? extends Subchannel> subchannels) {
+      this.subchannels = new ArrayList<Subchannel>(subchannels);
+    }
+
+    @Override
+    public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String authority) {
+      return null;
+    }
+
+    @Override
+    public String getAuthority() {
+      return null;
+    }
+
+    @Override
+    public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+      // ignore
+    }
+
+    @Override
+    public SynchronizationContext getSynchronizationContext() {
+      return syncContext;
+    }
+
+    @Override
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return fakeClock.getScheduledExecutorService();
+    }
+
+    @Override
+    public void refreshNameResolution() {
+      // noop
+    }
+
+    @Override
+    public Subchannel createSubchannel(CreateSubchannelArgs args) {
+      for (int i = 0; i < subchannels.size(); i++) {
+        Subchannel subchannel = subchannels.get(i);
+        List<EquivalentAddressGroup> addrs = subchannel.getAllAddresses();
+        verify(subchannel, atLeast(1)).getAllAddresses(); // ignore the interaction
+        if (!args.getAddresses().equals(addrs)) {
+          continue;
+        }
+        subchannels.remove(i);
+        return subchannel;
+      }
+      throw new IllegalArgumentException("Unexpected addresses: " + args.getAddresses());
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/PickFirstLoadBalancerProviderTest.java b/core/src/test/java/io/grpc/internal/PickFirstLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..7844aebd3fd
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/PickFirstLoadBalancerProviderTest.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2023 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.internal.PickFirstLeafLoadBalancer.PickFirstLeafLoadBalancerConfig;
+import io.grpc.internal.PickFirstLoadBalancer.PickFirstLoadBalancerConfig;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class PickFirstLoadBalancerProviderTest {
+
+  @Test
+  public void parseWithConfig() {
+    Map<String, Object> rawConfig = new HashMap<>();
+    rawConfig.put("shuffleAddressList", true);
+    ConfigOrError parsedConfig = new PickFirstLoadBalancerProvider().parseLoadBalancingPolicyConfig(
+        rawConfig);
+
+    Boolean shuffleAddressList;
+    Long randomSeed;
+
+    if (PickFirstLoadBalancerProvider.isEnabledNewPickFirst()) {
+      PickFirstLeafLoadBalancerConfig config =
+          (PickFirstLeafLoadBalancerConfig) parsedConfig.getConfig();
+      shuffleAddressList = config.shuffleAddressList;
+      randomSeed = config.randomSeed;
+    } else {
+      PickFirstLoadBalancerConfig config = (PickFirstLoadBalancerConfig) parsedConfig.getConfig();
+      shuffleAddressList = config.shuffleAddressList;
+      randomSeed = config.randomSeed;
+    }
+
+    assertThat(shuffleAddressList).isTrue();
+    assertThat(randomSeed).isNull();
+  }
+
+  @Test
+  public void parseWithoutConfig() {
+    Map<String, Object> rawConfig = new HashMap<>();
+    ConfigOrError parsedConfig = new PickFirstLoadBalancerProvider().parseLoadBalancingPolicyConfig(
+        rawConfig);
+
+    Boolean shuffleAddressList;
+    Long randomSeed;
+
+    if (PickFirstLoadBalancerProvider.isEnabledNewPickFirst()) {
+      PickFirstLeafLoadBalancerConfig config =
+          (PickFirstLeafLoadBalancerConfig) parsedConfig.getConfig();
+      shuffleAddressList = config.shuffleAddressList;
+      randomSeed = config.randomSeed;
+    } else {
+      PickFirstLoadBalancerConfig config = (PickFirstLoadBalancerConfig) parsedConfig.getConfig();
+      shuffleAddressList = config.shuffleAddressList;
+      randomSeed = config.randomSeed;
+    }
+
+    assertThat(shuffleAddressList).isNull();
+    assertThat(randomSeed).isNull();
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/PickFirstLoadBalancerTest.java b/core/src/test/java/io/grpc/internal/PickFirstLoadBalancerTest.java
new file mode 100644
index 00000000000..819293e070b
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/PickFirstLoadBalancerTest.java
@@ -0,0 +1,489 @@
+/*
+ * Copyright 2016 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.Lists;
+import io.grpc.Attributes;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.PickFirstLoadBalancer.PickFirstLoadBalancerConfig;
+import java.net.SocketAddress;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+
+/** Unit test for {@link PickFirstLoadBalancer}. */
+@RunWith(JUnit4.class)
+public class PickFirstLoadBalancerTest {
+  private PickFirstLoadBalancer loadBalancer;
+  private List<EquivalentAddressGroup> servers = Lists.newArrayList();
+  private List<SocketAddress> socketAddresses = Lists.newArrayList();
+
+  private static final Attributes.Key<String> FOO = Attributes.Key.create("foo");
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private Attributes affinity = Attributes.newBuilder().set(FOO, "bar").build();
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  @Captor
+  private ArgumentCaptor<SubchannelPicker> pickerCaptor;
+  @Captor
+  private ArgumentCaptor<ConnectivityState> connectivityStateCaptor;
+  @Captor
+  private ArgumentCaptor<CreateSubchannelArgs> createArgsCaptor;
+  @Captor
+  private ArgumentCaptor<SubchannelStateListener> stateListenerCaptor;
+  @Mock
+  private Helper mockHelper;
+  @Mock
+  private Subchannel mockSubchannel;
+  @Mock // This LoadBalancer doesn't use any of the arg fields, as verified in tearDown().
+  private PickSubchannelArgs mockArgs;
+
+  @Before
+  public void setUp() {
+    for (int i = 0; i < 3; i++) {
+      SocketAddress addr = new FakeSocketAddress("server" + i);
+      servers.add(new EquivalentAddressGroup(addr));
+      socketAddresses.add(addr);
+    }
+
+    when(mockSubchannel.getAllAddresses()).thenThrow(new UnsupportedOperationException());
+    when(mockHelper.getSynchronizationContext()).thenReturn(syncContext);
+    when(mockHelper.createSubchannel(any(CreateSubchannelArgs.class))).thenReturn(mockSubchannel);
+
+    loadBalancer = new PickFirstLoadBalancer(mockHelper);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    verifyNoMoreInteractions(mockArgs);
+  }
+
+  @Test
+  public void pickAfterResolved() throws Exception {
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+
+    verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    CreateSubchannelArgs args = createArgsCaptor.getValue();
+    assertThat(args.getAddresses()).isEqualTo(servers);
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockSubchannel).requestConnection();
+
+    // Calling pickSubchannel() twice gave the same result
+    assertEquals(pickerCaptor.getValue().pickSubchannel(mockArgs),
+        pickerCaptor.getValue().pickSubchannel(mockArgs));
+
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void pickAfterResolved_shuffle() throws Exception {
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity)
+            .setLoadBalancingPolicyConfig(new PickFirstLoadBalancerConfig(true, 123L)).build());
+
+    verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    CreateSubchannelArgs args = createArgsCaptor.getValue();
+    // We should still see the same set of addresses.
+    assertThat(args.getAddresses()).containsExactlyElementsIn(servers);
+    // Because we use a fixed seed, the addresses should always be shuffled in this order.
+    assertThat(args.getAddresses().get(0)).isEqualTo(servers.get(1));
+    assertThat(args.getAddresses().get(1)).isEqualTo(servers.get(0));
+    assertThat(args.getAddresses().get(2)).isEqualTo(servers.get(2));
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockSubchannel).requestConnection();
+
+    // Calling pickSubchannel() twice gave the same result
+    assertEquals(pickerCaptor.getValue().pickSubchannel(mockArgs),
+        pickerCaptor.getValue().pickSubchannel(mockArgs));
+
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void pickAfterResolved_noShuffle() throws Exception {
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity)
+            .setLoadBalancingPolicyConfig(new PickFirstLoadBalancerConfig(false)).build());
+
+    verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    CreateSubchannelArgs args = createArgsCaptor.getValue();
+    assertThat(args.getAddresses()).isEqualTo(servers);
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockSubchannel).requestConnection();
+
+    // Calling pickSubchannel() twice gave the same result
+    assertEquals(pickerCaptor.getValue().pickSubchannel(mockArgs),
+        pickerCaptor.getValue().pickSubchannel(mockArgs));
+
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void requestConnectionPicker() throws Exception {
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel);
+    inOrder.verify(mockSubchannel).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+    inOrder.verify(mockSubchannel).requestConnection();
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+
+    SubchannelPicker picker = pickerCaptor.getValue();
+
+    // Calling pickSubchannel() twice gave the same result
+    assertEquals(picker.pickSubchannel(mockArgs), picker.pickSubchannel(mockArgs));
+
+    // But the picker calls requestConnection() only once
+    inOrder.verify(mockSubchannel).requestConnection();
+
+    verify(mockSubchannel, times(2)).requestConnection();
+  }
+
+  @Test
+  public void refreshNameResolutionAfterSubchannelConnectionBroken() {
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    verify(mockHelper).createSubchannel(any(CreateSubchannelArgs.class));
+
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel);
+    inOrder.verify(mockSubchannel).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    assertThat(pickerCaptor.getValue().pickSubchannel(mockArgs).hasResult()).isFalse();
+    inOrder.verify(mockSubchannel).requestConnection();
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    assertNull(pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+    Status error = Status.UNAUTHENTICATED.withDescription("permission denied");
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).refreshNameResolution();
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertSame(mockSubchannel, pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+    // Simulate receiving go-away so the subchannel transit to IDLE.
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(mockHelper).refreshNameResolution();
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
+
+    verifyNoMoreInteractions(mockHelper, mockSubchannel);
+  }
+
+  @Test
+  public void pickAfterResolvedAndUnchanged() throws Exception {
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    verify(mockSubchannel).start(any(SubchannelStateListener.class));
+    verify(mockSubchannel).requestConnection();
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    verify(mockSubchannel).updateAddresses(eq(servers));
+    verifyNoMoreInteractions(mockSubchannel);
+
+    verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    assertThat(createArgsCaptor.getValue()).isNotNull();
+    verify(mockHelper)
+        .updateBalancingState(isA(ConnectivityState.class), isA(SubchannelPicker.class));
+    // Updating the subchannel addresses is unnecessary, but doesn't hurt anything
+    verify(mockSubchannel).updateAddresses(ArgumentMatchers.<EquivalentAddressGroup>anyList());
+
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void pickAfterResolvedAndChanged() throws Exception {
+    SocketAddress socketAddr = new FakeSocketAddress("newserver");
+    List<EquivalentAddressGroup> newServers =
+        Lists.newArrayList(new EquivalentAddressGroup(socketAddr));
+
+    InOrder inOrder = inOrder(mockHelper, mockSubchannel);
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    verify(mockSubchannel).start(any(SubchannelStateListener.class));
+    CreateSubchannelArgs args = createArgsCaptor.getValue();
+    assertThat(args.getAddresses()).isEqualTo(servers);
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockSubchannel).requestConnection();
+    assertThat(pickerCaptor.getValue().pickSubchannel(mockArgs).hasResult()).isFalse();
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(newServers).setAttributes(affinity).build());
+    inOrder.verify(mockSubchannel).updateAddresses(eq(newServers));
+
+    verifyNoMoreInteractions(mockSubchannel);
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void pickAfterStateChangeAfterResolution() throws Exception {
+    InOrder inOrder = inOrder(mockHelper);
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    CreateSubchannelArgs args = createArgsCaptor.getValue();
+    assertThat(args.getAddresses()).isEqualTo(servers);
+    verify(mockSubchannel).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    assertThat(pickerCaptor.getValue().pickSubchannel(mockArgs).hasResult()).isFalse();
+    reset(mockHelper);
+    when(mockHelper.getSynchronizationContext()).thenReturn(syncContext);
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(mockHelper).refreshNameResolution();
+    inOrder.verify(mockHelper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    assertEquals(Status.OK, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    Status error = Status.UNAVAILABLE.withDescription("boom!");
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).refreshNameResolution();
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertEquals(mockSubchannel, pickerCaptor.getValue().pickSubchannel(mockArgs).getSubchannel());
+
+    verify(mockHelper, atLeast(0)).getSynchronizationContext();  // Don't care
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void pickAfterResolutionAfterTransientValue() throws Exception {
+    InOrder inOrder = inOrder(mockHelper);
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    CreateSubchannelArgs args = createArgsCaptor.getValue();
+    assertThat(args.getAddresses()).isEqualTo(servers);
+    verify(mockSubchannel).start(stateListenerCaptor.capture());
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+    verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockSubchannel).requestConnection();
+    reset(mockHelper);
+    when(mockHelper.getSynchronizationContext()).thenReturn(syncContext);
+
+    // An error has happened.
+    Status error = Status.UNAVAILABLE.withDescription("boom!");
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(mockHelper).refreshNameResolution();
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+
+    // But a subsequent IDLE update should be ignored and the LB state not updated. Additionally,
+    // a request for a new connection should be made keep the subchannel trying to connect.
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(mockHelper).refreshNameResolution();
+    verifyNoMoreInteractions(mockHelper);
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+    verify(mockSubchannel, times(2)).requestConnection();
+
+    // Transition from TRANSIENT_ERROR to CONNECTING should also be ignored.
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(CONNECTING));
+    verifyNoMoreInteractions(mockHelper);
+    assertEquals(error, pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus());
+  }
+
+  @Test
+  public void nameResolutionError() throws Exception {
+    Status error = Status.NOT_FOUND.withDescription("nameResolutionError");
+    loadBalancer.handleNameResolutionError(error);
+    verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    PickResult pickResult = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertEquals(null, pickResult.getSubchannel());
+    assertEquals(error, pickResult.getStatus());
+    verify(mockSubchannel, never()).requestConnection();
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void nameResolutionError_emptyAddressList() throws Exception {
+    servers.clear();
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    verify(mockHelper).updateBalancingState(connectivityStateCaptor.capture(),
+        pickerCaptor.capture());
+    PickResult pickResult = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertThat(pickResult.getSubchannel()).isNull();
+    assertThat(pickResult.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(pickResult.getStatus().getDescription()).contains("returned no usable address");
+    verify(mockSubchannel, never()).requestConnection();
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void nameResolutionSuccessAfterError() throws Exception {
+    InOrder inOrder = inOrder(mockHelper);
+
+    loadBalancer.handleNameResolutionError(Status.NOT_FOUND.withDescription("nameResolutionError"));
+    inOrder.verify(mockHelper)
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    verify(mockSubchannel, never()).requestConnection();
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    CreateSubchannelArgs args = createArgsCaptor.getValue();
+    assertThat(args.getAddresses()).isEqualTo(servers);
+    assertThat(args.getAttributes()).isEqualTo(Attributes.EMPTY);
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verify(mockSubchannel).requestConnection();
+
+    assertThat(pickerCaptor.getValue().pickSubchannel(mockArgs).hasResult()).isFalse();
+
+    assertEquals(pickerCaptor.getValue().pickSubchannel(mockArgs),
+        pickerCaptor.getValue().pickSubchannel(mockArgs));
+
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void nameResolutionErrorWithStateChanges() throws Exception {
+    InOrder inOrder = inOrder(mockHelper);
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    inOrder.verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    verify(mockSubchannel).start(stateListenerCaptor.capture());
+    CreateSubchannelArgs args = createArgsCaptor.getValue();
+    assertThat(args.getAddresses()).isEqualTo(servers);
+
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+    inOrder.verify(mockHelper).refreshNameResolution();
+    inOrder.verify(mockHelper).updateBalancingState(
+        eq(TRANSIENT_FAILURE), any(SubchannelPicker.class));
+
+    Status error = Status.NOT_FOUND.withDescription("nameResolutionError");
+    loadBalancer.handleNameResolutionError(error);
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+
+    PickResult pickResult = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertEquals(null, pickResult.getSubchannel());
+    assertEquals(error, pickResult.getStatus());
+
+    Status error2 = Status.NOT_FOUND.withDescription("nameResolutionError2");
+    loadBalancer.handleNameResolutionError(error2);
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+
+    pickResult = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertEquals(null, pickResult.getSubchannel());
+    assertEquals(error2, pickResult.getStatus());
+
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void requestConnection() {
+    loadBalancer.requestConnection();
+
+    verify(mockSubchannel, never()).requestConnection();
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    verify(mockSubchannel).requestConnection();
+
+    verify(mockHelper).createSubchannel(createArgsCaptor.capture());
+    verify(mockSubchannel).start(stateListenerCaptor.capture());
+    CreateSubchannelArgs args = createArgsCaptor.getValue();
+    assertThat(args.getAddresses()).isEqualTo(servers);
+    SubchannelStateListener stateListener = stateListenerCaptor.getValue();
+
+    stateListener.onSubchannelState(ConnectivityStateInfo.forNonError(IDLE));
+    verify(mockHelper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
+
+    verify(mockSubchannel).requestConnection();
+    loadBalancer.requestConnection();
+    verify(mockSubchannel, times(2)).requestConnection();
+  }
+
+  private static class FakeSocketAddress extends SocketAddress {
+    final String name;
+
+    FakeSocketAddress(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public String toString() {
+      return "FakeSocketAddress-" + name;
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ProxyDetectorImplTest.java b/core/src/test/java/io/grpc/internal/ProxyDetectorImplTest.java
new file mode 100644
index 00000000000..771050f119d
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ProxyDetectorImplTest.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static junit.framework.TestCase.assertFalse;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import io.grpc.HttpConnectProxiedSocketAddress;
+import io.grpc.ProxiedSocketAddress;
+import io.grpc.ProxyDetector;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.PasswordAuthentication;
+import java.net.Proxy;
+import java.net.ProxySelector;
+import java.net.SocketAddress;
+import java.net.URI;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.AdditionalMatchers;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class ProxyDetectorImplTest {
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  @Mock private ProxySelector proxySelector;
+  @Mock private ProxyDetectorImpl.AuthenticationProvider authenticator;
+  private InetSocketAddress destination = InetSocketAddress.createUnresolved("10.10.10.10", 5678);
+  private Supplier<ProxySelector> proxySelectorSupplier;
+  private ProxyDetector proxyDetector;
+  private InetSocketAddress unresolvedProxy;
+  private HttpConnectProxiedSocketAddress proxySocketAddress;
+  private final int proxyPort = 1234;
+
+  @Before
+  public void setUp() throws Exception {
+    proxySelectorSupplier = new Supplier<ProxySelector>() {
+      @Override
+      public ProxySelector get() {
+        return proxySelector;
+      }
+    };
+    proxyDetector = new ProxyDetectorImpl(proxySelectorSupplier, authenticator);
+    unresolvedProxy = InetSocketAddress.createUnresolved("10.0.0.1", proxyPort);
+    proxySocketAddress = HttpConnectProxiedSocketAddress.newBuilder()
+        .setTargetAddress(destination)
+        .setProxyAddress(
+          new InetSocketAddress(InetAddress.getByName(unresolvedProxy.getHostName()), proxyPort))
+        .build();
+  }
+
+  @Test
+  public void returnNullWhenNoProxy() throws Exception {
+    when(proxySelector.select(any(URI.class)))
+        .thenReturn(ImmutableList.of(java.net.Proxy.NO_PROXY));
+    assertNull(proxyDetector.proxyFor(destination));
+  }
+
+  @Test
+  public void detectProxyForUnresolvedDestination() throws Exception {
+    Proxy proxy = new Proxy(Proxy.Type.HTTP, unresolvedProxy);
+    when(proxySelector.select(any(URI.class))).thenReturn(ImmutableList.of(proxy));
+
+    ProxiedSocketAddress detected = proxyDetector.proxyFor(destination);
+    assertNotNull(detected);
+    assertEquals(proxySocketAddress, detected);
+  }
+
+  @Test
+  public void detectProxyForResolvedDestination() throws Exception {
+    InetSocketAddress resolved = new InetSocketAddress(InetAddress.getByName("10.1.2.3"), 10);
+    assertFalse(resolved.isUnresolved());
+
+    Proxy proxy = new Proxy(Proxy.Type.HTTP, unresolvedProxy);
+    when(proxySelector.select(any(URI.class))).thenReturn(ImmutableList.of(proxy));
+
+    ProxiedSocketAddress detected = proxyDetector.proxyFor(resolved);
+    assertNotNull(detected);
+    HttpConnectProxiedSocketAddress expected = HttpConnectProxiedSocketAddress.newBuilder()
+        .setTargetAddress(resolved)
+        .setProxyAddress(
+            new InetSocketAddress(InetAddress.getByName(unresolvedProxy.getHostName()), proxyPort))
+        .build();
+    assertEquals(expected, detected);
+  }
+
+  @Test
+  public void unresolvedProxyAddressBecomesResolved() throws Exception {
+    InetSocketAddress unresolvedProxy = InetSocketAddress.createUnresolved("10.0.0.100", 1234);
+    assertTrue(unresolvedProxy.isUnresolved());
+    Proxy proxy1 = new java.net.Proxy(java.net.Proxy.Type.HTTP, unresolvedProxy);
+    when(proxySelector.select(any(URI.class))).thenReturn(ImmutableList.of(proxy1));
+    HttpConnectProxiedSocketAddress proxy =
+        (HttpConnectProxiedSocketAddress) proxyDetector.proxyFor(destination);
+    assertFalse(((InetSocketAddress) proxy.getProxyAddress()).isUnresolved());
+  }
+
+  @Test
+  public void pickFirstHttpProxy() throws Exception {
+    InetSocketAddress otherProxy = InetSocketAddress.createUnresolved("10.0.0.2", 11111);
+    assertNotEquals(unresolvedProxy, otherProxy);
+    Proxy proxy1 = new java.net.Proxy(java.net.Proxy.Type.HTTP, unresolvedProxy);
+    Proxy proxy2 = new java.net.Proxy(java.net.Proxy.Type.HTTP, otherProxy);
+    when(proxySelector.select(any(URI.class))).thenReturn(ImmutableList.of(proxy1, proxy2));
+
+    ProxiedSocketAddress detected = proxyDetector.proxyFor(destination);
+    assertNotNull(detected);
+    assertEquals(proxySocketAddress, detected);
+  }
+
+  // Mainly for InProcessSocketAddress
+  @Test
+  public void noProxyForNonInetSocket() throws Exception {
+    assertNull(proxyDetector.proxyFor(mock(SocketAddress.class)));
+  }
+
+  @Test
+  public void authRequired() throws Exception {
+    Proxy proxy = new java.net.Proxy(java.net.Proxy.Type.HTTP, unresolvedProxy);
+    final String proxyUser = "testuser";
+    final String proxyPassword = "testpassword";
+    PasswordAuthentication auth = new PasswordAuthentication(
+        proxyUser,
+        proxyPassword.toCharArray());
+    when(authenticator.requestPasswordAuthentication(
+            anyString(),
+            ArgumentMatchers.<InetAddress>any(),
+            anyInt(),
+            anyString(),
+            anyString(),
+            AdditionalMatchers.or(anyString(), ArgumentMatchers.<String>any())))
+        .thenReturn(auth);
+    when(proxySelector.select(any(URI.class))).thenReturn(ImmutableList.of(proxy));
+
+    ProxiedSocketAddress detected = proxyDetector.proxyFor(destination);
+    assertEquals(
+        HttpConnectProxiedSocketAddress.newBuilder()
+            .setTargetAddress(destination)
+            .setProxyAddress(
+                new InetSocketAddress(
+                    InetAddress.getByName(unresolvedProxy.getHostName()),
+                    unresolvedProxy.getPort()))
+            .setUsername(proxyUser)
+            .setPassword(proxyPassword)
+            .build(),
+        detected);
+  }
+
+  @Test
+  public void proxySelectorReturnsNull() throws Exception {
+    ProxyDetectorImpl proxyDetector = new ProxyDetectorImpl(
+        new Supplier<ProxySelector>() {
+          @Override
+          public ProxySelector get() {
+            return null;
+          }
+        },
+        authenticator);
+    assertNull(proxyDetector.proxyFor(destination));
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ReadableBufferTestBase.java b/core/src/test/java/io/grpc/internal/ReadableBufferTestBase.java
deleted file mode 100644
index 0dff9a09304..00000000000
--- a/core/src/test/java/io/grpc/internal/ReadableBufferTestBase.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static com.google.common.base.Charsets.UTF_8;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-
-import java.io.ByteArrayOutputStream;
-import java.nio.ByteBuffer;
-import java.util.Arrays;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Abstract base class for tests of {@link ReadableBuffer} subclasses.
- */
-@RunWith(JUnit4.class)
-public abstract class ReadableBufferTestBase {
-  // Use a long string to ensure that any chunking/splitting works correctly.
-  protected static final String msg = repeatUntilLength("hello", 8 * 1024);
-
-  @Test
-  public void bufferShouldReadAllBytes() {
-    ReadableBuffer buffer = buffer();
-    for (int ix = 0; ix < msg.length(); ++ix) {
-      assertEquals(msg.length() - ix, buffer.readableBytes());
-      assertEquals(msg.charAt(ix), buffer.readUnsignedByte());
-    }
-    assertEquals(0, buffer.readableBytes());
-  }
-
-  @Test
-  public void readToArrayShouldSucceed() {
-    ReadableBuffer buffer = buffer();
-    byte[] array = new byte[msg.length()];
-    buffer.readBytes(array, 0, array.length);
-    assertArrayEquals(msg.getBytes(UTF_8), array);
-    assertEquals(0, buffer.readableBytes());
-  }
-
-  @Test
-  public void partialReadToArrayShouldSucceed() {
-    ReadableBuffer buffer = buffer();
-    byte[] array = new byte[msg.length()];
-    buffer.readBytes(array, 1, 2);
-    assertArrayEquals(new byte[] {'h', 'e'}, Arrays.copyOfRange(array, 1, 3));
-    assertEquals(msg.length() - 2, buffer.readableBytes());
-  }
-
-  @Test
-  public void readToStreamShouldSucceed() throws Exception {
-    ReadableBuffer buffer = buffer();
-    ByteArrayOutputStream stream = new ByteArrayOutputStream();
-    buffer.readBytes(stream, msg.length());
-    assertArrayEquals(msg.getBytes(UTF_8), stream.toByteArray());
-    assertEquals(0, buffer.readableBytes());
-  }
-
-  @Test
-  public void partialReadToStreamShouldSucceed() throws Exception {
-    ReadableBuffer buffer = buffer();
-    ByteArrayOutputStream stream = new ByteArrayOutputStream();
-    buffer.readBytes(stream, 2);
-    assertArrayEquals(new byte[]{'h', 'e'}, Arrays.copyOfRange(stream.toByteArray(), 0, 2));
-    assertEquals(msg.length() - 2, buffer.readableBytes());
-  }
-
-  @Test
-  public void readToByteBufferShouldSucceed() {
-    ReadableBuffer buffer = buffer();
-    ByteBuffer byteBuffer = ByteBuffer.allocate(msg.length());
-    buffer.readBytes(byteBuffer);
-    byteBuffer.flip();
-    byte[] array = new byte[msg.length()];
-    byteBuffer.get(array);
-    assertArrayEquals(msg.getBytes(UTF_8), array);
-    assertEquals(0, buffer.readableBytes());
-  }
-
-  @Test
-  public void partialReadToByteBufferShouldSucceed() {
-    ReadableBuffer buffer = buffer();
-    ByteBuffer byteBuffer = ByteBuffer.allocate(2);
-    buffer.readBytes(byteBuffer);
-    byteBuffer.flip();
-    byte[] array = new byte[2];
-    byteBuffer.get(array);
-    assertArrayEquals(new byte[]{'h', 'e'}, array);
-    assertEquals(msg.length() - 2, buffer.readableBytes());
-  }
-
-  @Test
-  public void partialReadToReadableBufferShouldSucceed() {
-    ReadableBuffer buffer = buffer();
-    ReadableBuffer newBuffer = buffer.readBytes(2);
-    assertEquals(2, newBuffer.readableBytes());
-    assertEquals(msg.length() - 2, buffer.readableBytes());
-    byte[] array = new byte[2];
-    newBuffer.readBytes(array, 0, 2);
-    assertArrayEquals(new byte[] {'h', 'e'}, Arrays.copyOfRange(array, 0, 2));     
-  }
-
-  protected abstract ReadableBuffer buffer();
-
-  private static String repeatUntilLength(String toRepeat, int length) {
-    StringBuilder buf = new StringBuilder();
-    while (buf.length() < length) {
-      buf.append(toRepeat);
-    }
-    buf.setLength(length);
-    return buf.toString();
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/ReadableBuffersArrayTest.java b/core/src/test/java/io/grpc/internal/ReadableBuffersArrayTest.java
index 58e7e008997..5b0fb02c611 100644
--- a/core/src/test/java/io/grpc/internal/ReadableBuffersArrayTest.java
+++ b/core/src/test/java/io/grpc/internal/ReadableBuffersArrayTest.java
@@ -1,48 +1,36 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
-import static com.google.common.base.Charsets.UTF_8;
 import static io.grpc.internal.ReadableBuffers.wrap;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
 
 /**
  * Tests for the array-backed {@link ReadableBuffer} returned by {@link ReadableBuffers#wrap(byte[],
  * int, int)}.
  */
+@RunWith(JUnit4.class)
 public class ReadableBuffersArrayTest extends ReadableBufferTestBase {
 
   @Test
diff --git a/core/src/test/java/io/grpc/internal/ReadableBuffersByteBufferTest.java b/core/src/test/java/io/grpc/internal/ReadableBuffersByteBufferTest.java
index ab4be7693a2..67e7aaf9132 100644
--- a/core/src/test/java/io/grpc/internal/ReadableBuffersByteBufferTest.java
+++ b/core/src/test/java/io/grpc/internal/ReadableBuffersByteBufferTest.java
@@ -1,37 +1,22 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
-import static com.google.common.base.Charsets.UTF_8;
+import static java.nio.charset.StandardCharsets.UTF_8;
 
 import java.nio.ByteBuffer;
 
diff --git a/core/src/test/java/io/grpc/internal/ReadableBuffersTest.java b/core/src/test/java/io/grpc/internal/ReadableBuffersTest.java
new file mode 100644
index 00000000000..b9135b49503
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ReadableBuffersTest.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.grpc.Detachable;
+import io.grpc.HasByteBuffer;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.InvalidMarkException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link ReadableBuffers}.
+ * See also: {@link ReadableBuffersArrayTest}, {@link ReadableBuffersByteBufferTest}.
+ */
+@RunWith(JUnit4.class)
+public class ReadableBuffersTest {
+  private static final byte[] MSG_BYTES = "hello".getBytes(UTF_8);
+
+  @Test
+  public void empty_returnsEmptyBuffer() {
+    ReadableBuffer buffer = ReadableBuffers.empty();
+    assertArrayEquals(new byte[0], buffer.array());
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void readArray_checksNotNull() {
+    ReadableBuffers.readArray(null);
+  }
+
+  @Test
+  public void readArray_returnsBufferArray() {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    assertArrayEquals(new byte[]{'h', 'e', 'l', 'l', 'o'}, ReadableBuffers.readArray(buffer));
+  }
+
+  @Test
+  public void readAsString_returnsString() {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    assertEquals("hello", ReadableBuffers.readAsString(buffer, UTF_8));
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void readAsString_checksNotNull() {
+    ReadableBuffers.readAsString(null, UTF_8);
+  }
+
+  @Test
+  public void readAsStringUtf8_returnsString() {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    assertEquals("hello", ReadableBuffers.readAsStringUtf8(buffer));
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void readAsStringUtf8_checksNotNull() {
+    ReadableBuffers.readAsStringUtf8(null);
+  }
+
+  @Test
+  public void openStream_ignoresClose() throws Exception {
+    ReadableBuffer buffer = mock(ReadableBuffer.class);
+    InputStream stream = ReadableBuffers.openStream(buffer, false);
+    stream.close();
+    verify(buffer, never()).close();
+  }
+
+  @Test
+  public void bufferInputStream_available_returnsReadableBytes() throws Exception {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    assertEquals(5, inputStream.available());
+    while (inputStream.available() != 0) {
+      inputStream.read();
+    }
+    assertEquals(-1, inputStream.read());
+  }
+
+  @Test
+  public void bufferInputStream_read_returnsUnsignedByte() throws Exception {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    assertEquals((int) 'h', inputStream.read());
+  }
+
+  @Test
+  public void bufferInputStream_read_writes() throws Exception {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    byte[] dest = new byte[5];
+    assertEquals(5, inputStream.read(dest, /*destOffset*/ 0, /*length*/ 5));
+    assertArrayEquals(new byte[]{'h', 'e', 'l', 'l', 'o'}, dest);
+    assertEquals(-1, inputStream.read(/*dest*/ new byte[1], /*destOffset*/ 0, /*length*/1));
+  }
+
+  @Test
+  public void bufferInputStream_read_writesPartially() throws Exception {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    byte[] dest = new byte[3];
+    assertEquals(2, inputStream.read(dest, /*destOffset*/ 1, /*length*/ 2));
+    assertArrayEquals(new byte[]{0x00, 'h', 'e'}, dest);
+  }
+
+  @Test
+  public void bufferInputStream_close_closesBuffer() throws Exception {
+    ReadableBuffer buffer = mock(ReadableBuffer.class);
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    inputStream.close();
+    verify(buffer, times(1)).close();
+  }
+
+  @Test
+  public void bufferInputStream_markAndReset() throws IOException {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    assertTrue(inputStream.markSupported());
+    inputStream.mark(2);
+    byte[] first = new byte[5];
+    inputStream.read(first);
+    assertEquals(0, inputStream.available());
+    inputStream.reset();
+    assertEquals(5, inputStream.available());
+    byte[] second = new byte[5];
+    inputStream.read(second);
+    assertArrayEquals(first, second);
+  }
+
+  @Test
+  public void bufferInputStream_getByteBufferDelegatesToBuffer() {
+    ReadableBuffer buffer = mock(ReadableBuffer.class);
+    when(buffer.byteBufferSupported()).thenReturn(true);
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    assertTrue(((HasByteBuffer) inputStream).byteBufferSupported());
+    ((HasByteBuffer) inputStream).getByteBuffer();
+    verify(buffer).getByteBuffer();
+  }
+
+  @Test
+  public void bufferInputStream_availableAfterDetached_returnsZeroByte() throws IOException {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    assertEquals(5, inputStream.available());
+    InputStream detachedStream = ((Detachable) inputStream).detach();
+    assertEquals(0, inputStream.available());
+    assertEquals(5, detachedStream.available());
+  }
+
+  @Test
+  public void bufferInputStream_skipAfterDetached() throws IOException {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    assertEquals(3, inputStream.skip(3));
+    InputStream detachedStream = ((Detachable) inputStream).detach();
+    assertEquals(0, inputStream.skip(2));
+    assertEquals(2, detachedStream.skip(2));
+  }
+
+  @Test
+  public void bufferInputStream_readUnsignedByteAfterDetached() throws IOException {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    assertEquals((int) 'h', inputStream.read());
+    InputStream detachedStream = ((Detachable) inputStream).detach();
+    assertEquals(-1, inputStream.read());
+    assertEquals((int) 'e', detachedStream.read());
+  }
+
+  @Test
+  public void bufferInputStream_partialReadAfterDetached() throws IOException {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    byte[] dest = new byte[3];
+    assertEquals(3, inputStream.read(dest, /*destOffset*/ 0, /*length*/ 3));
+    assertArrayEquals(new byte[]{'h', 'e', 'l'}, dest);
+    InputStream detachedStream = ((Detachable) inputStream).detach();
+    byte[] newDest = new byte[2];
+    assertEquals(2, detachedStream.read(newDest, /*destOffset*/ 0, /*length*/ 2));
+    assertArrayEquals(new byte[]{'l', 'o'}, newDest);
+  }
+
+  @Test
+  public void bufferInputStream_markDiscardedAfterDetached() throws IOException {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    inputStream.mark(5);
+    ((Detachable) inputStream).detach();
+    assertThrows(InvalidMarkException.class, () -> inputStream.reset());
+  }
+
+  @Test
+  public void bufferInputStream_markPreservedInForkedInputStream() throws IOException {
+    ReadableBuffer buffer = ReadableBuffers.wrap(MSG_BYTES);
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    inputStream.skip(2);
+    inputStream.mark(3);
+    InputStream detachedStream = ((Detachable) inputStream).detach();
+    detachedStream.skip(3);
+    assertEquals(0, detachedStream.available());
+    detachedStream.reset();
+    assertEquals(3, detachedStream.available());
+  }
+
+  @Test
+  public void bufferInputStream_closeAfterDetached() throws IOException {
+    ReadableBuffer buffer = mock(ReadableBuffer.class);
+    when(buffer.readBytes(anyInt())).thenReturn(mock(ReadableBuffer.class));
+    InputStream inputStream = ReadableBuffers.openStream(buffer, true);
+    InputStream detachedStream = ((Detachable) inputStream).detach();
+    inputStream.close();
+    verify(buffer, never()).close();
+    detachedStream.close();
+    verify(buffer).close();
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ReflectionLongAdderCounterTest.java b/core/src/test/java/io/grpc/internal/ReflectionLongAdderCounterTest.java
new file mode 100644
index 00000000000..8e3b67b04d6
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ReflectionLongAdderCounterTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ReflectionLongAdderCounterTest {
+  private ReflectionLongAdderCounter counter = new ReflectionLongAdderCounter();
+
+  @Test
+  public void testInitialValue() {
+    assertEquals(0, counter.value());
+  }
+
+  @Test
+  public void testIncrement() {
+    counter.add(1);
+    assertEquals(1, counter.value());
+  }
+
+  @Test
+  public void testIncrementDelta() {
+    counter.add(2);
+    assertEquals(2, counter.value());
+  }
+
+  @Test
+  public void testIncrementMulti() {
+    counter.add(2);
+    counter.add(1);
+    assertEquals(3, counter.value());
+  }
+
+  @Test
+  public void testDecrement() {
+    counter.add(2);
+    counter.add(-1);
+    assertEquals(1, counter.value());
+  }
+
+  @Test
+  public void testNegativeValue() {
+    counter.add(-2);
+    assertEquals(-2, counter.value());
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ReschedulerTest.java b/core/src/test/java/io/grpc/internal/ReschedulerTest.java
new file mode 100644
index 00000000000..c2e2fc719a2
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ReschedulerTest.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link Rescheduler}.
+ */
+@RunWith(JUnit4.class)
+public class ReschedulerTest {
+
+  private final Runner runner = new Runner();
+  private final Exec exec = new Exec();
+  private final FakeClock scheduler = new FakeClock();
+  private final Rescheduler rescheduler = new Rescheduler(
+      runner,
+      exec,
+      scheduler.getScheduledExecutorService(),
+      scheduler.getStopwatchSupplier().get());
+
+  @Test
+  public void runs() {
+    assertFalse(runner.ran);
+    rescheduler.reschedule(1, TimeUnit.NANOSECONDS);
+    assertFalse(runner.ran);
+
+    scheduler.forwardNanos(1);
+
+    assertTrue(runner.ran);
+  }
+
+  @Test
+  public void cancels() {
+    assertFalse(runner.ran);
+    rescheduler.reschedule(1, TimeUnit.NANOSECONDS);
+    assertFalse(runner.ran);
+    rescheduler.cancel(/* permanent= */ false);
+
+    scheduler.forwardNanos(1);
+
+    assertFalse(runner.ran);
+    assertTrue(exec.executed);
+  }
+
+  @Test
+  public void cancelPermanently() {
+    assertFalse(runner.ran);
+    rescheduler.reschedule(1, TimeUnit.NANOSECONDS);
+    assertFalse(runner.ran);
+    rescheduler.cancel(/* permanent= */ true);
+
+    scheduler.forwardNanos(1);
+
+    assertFalse(runner.ran);
+    assertFalse(exec.executed);
+  }
+
+  @Test
+  public void reschedules() {
+    assertFalse(runner.ran);
+    rescheduler.reschedule(1, TimeUnit.NANOSECONDS);
+    assertFalse(runner.ran);
+    assertFalse(exec.executed);
+    rescheduler.reschedule(50, TimeUnit.NANOSECONDS);
+    assertFalse(runner.ran);
+    assertFalse(exec.executed);
+
+    scheduler.forwardNanos(1);
+    assertFalse(runner.ran);
+    assertTrue(exec.executed);
+
+    scheduler.forwardNanos(50);
+
+    assertTrue(runner.ran);
+  }
+
+  @Test
+  public void reschedulesShortDelay() {
+    assertFalse(runner.ran);
+    rescheduler.reschedule(50, TimeUnit.NANOSECONDS);
+    assertFalse(runner.ran);
+    assertFalse(exec.executed);
+    rescheduler.reschedule(1, TimeUnit.NANOSECONDS);
+    assertFalse(runner.ran);
+    assertFalse(exec.executed);
+
+    scheduler.forwardNanos(1);
+    assertTrue(runner.ran);
+    assertTrue(exec.executed);
+  }
+
+  private static final class Exec implements Executor {
+    boolean executed;
+
+    @Override
+    public void execute(Runnable command) {
+      executed = true;
+
+      command.run();
+    }
+  }
+
+  private static final class Runner implements Runnable {
+    boolean ran;
+
+    @Override
+    public void run() {
+      ran = true;
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/RetriableStreamTest.java b/core/src/test/java/io/grpc/internal/RetriableStreamTest.java
new file mode 100644
index 00000000000..afbdaa395b0
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/RetriableStreamTest.java
@@ -0,0 +1,2995 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.DROPPED;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.MISCARRIED;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.REFUSED;
+import static io.grpc.internal.RetriableStream.GRPC_PREVIOUS_RPC_ATTEMPTS;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Codec;
+import io.grpc.Compressor;
+import io.grpc.DecompressorRegistry;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.StringMarshaller;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
+import io.grpc.internal.RetriableStream.ChannelBufferMeter;
+import io.grpc.internal.RetriableStream.Throttle;
+import io.grpc.internal.StreamListener.MessageProducer;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.ReentrantLock;
+import javax.annotation.Nullable;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InOrder;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+/** Unit tests for {@link RetriableStream}. */
+@RunWith(JUnit4.class)
+public class RetriableStreamTest {
+  private static final String CANCELLED_BECAUSE_COMMITTED =
+      "Stream thrown away because RetriableStream committed";
+  private static final String AUTHORITY = "fakeAuthority";
+  private static final Compressor COMPRESSOR = Codec.Identity.NONE;
+  private static final DecompressorRegistry DECOMPRESSOR_REGISTRY =
+      DecompressorRegistry.getDefaultInstance();
+  private static final int MAX_INBOUND_MESSAGE_SIZE = 1234;
+  private static final int MAX_OUTBOUND_MESSAGE_SIZE = 5678;
+  private static final long PER_RPC_BUFFER_LIMIT = 1000;
+  private static final long CHANNEL_BUFFER_LIMIT = 2000;
+  private static final int MAX_ATTEMPTS = 6;
+  private static final long INITIAL_BACKOFF_IN_SECONDS = 100;
+  private static final long HEDGING_DELAY_IN_SECONDS = 100;
+  private static final long MAX_BACKOFF_IN_SECONDS = 700;
+  private static final double BACKOFF_MULTIPLIER = 2D;
+  private static final double FAKE_RANDOM = .5D;
+  private static final ClientStreamTracer.StreamInfo STREAM_INFO =
+      ClientStreamTracer.StreamInfo.newBuilder().build();
+
+  static {
+    RetriableStream.setRandom(
+        // not random
+        new Random() {
+          @Override
+          public double nextDouble() {
+            return FAKE_RANDOM;
+          }
+        });
+  }
+
+  private static final Code RETRIABLE_STATUS_CODE_1 = Code.UNAVAILABLE;
+  private static final Code RETRIABLE_STATUS_CODE_2 = Code.DATA_LOSS;
+  private static final Code NON_RETRIABLE_STATUS_CODE = Code.INTERNAL;
+  private static final Code NON_FATAL_STATUS_CODE_1 = Code.UNAVAILABLE;
+  private static final Code NON_FATAL_STATUS_CODE_2 = Code.DATA_LOSS;
+  private static final Code FATAL_STATUS_CODE = Code.INTERNAL;
+  private static final RetryPolicy RETRY_POLICY =
+      new RetryPolicy(
+          MAX_ATTEMPTS,
+          TimeUnit.SECONDS.toNanos(INITIAL_BACKOFF_IN_SECONDS),
+          TimeUnit.SECONDS.toNanos(MAX_BACKOFF_IN_SECONDS),
+          BACKOFF_MULTIPLIER,
+          null,
+          ImmutableSet.of(RETRIABLE_STATUS_CODE_1, RETRIABLE_STATUS_CODE_2));
+  private static final HedgingPolicy HEDGING_POLICY =
+      new HedgingPolicy(
+          MAX_ATTEMPTS,
+          TimeUnit.SECONDS.toNanos(HEDGING_DELAY_IN_SECONDS),
+          ImmutableSet.of(NON_FATAL_STATUS_CODE_1, NON_FATAL_STATUS_CODE_2));
+
+  private final RetriableStreamRecorder retriableStreamRecorder =
+      mock(RetriableStreamRecorder.class);
+  private final ClientStreamListener masterListener = mock(ClientStreamListener.class);
+  private final MethodDescriptor<String, String> method =
+      MethodDescriptor.<String, String>newBuilder()
+          .setType(MethodType.BIDI_STREAMING)
+          .setFullMethodName(MethodDescriptor.generateFullMethodName("service_foo", "method_bar"))
+          .setRequestMarshaller(new StringMarshaller())
+          .setResponseMarshaller(new StringMarshaller())
+          .build();
+  private final ChannelBufferMeter channelBufferUsed = new ChannelBufferMeter();
+  private final FakeClock fakeClock = new FakeClock();
+
+  private static long calculateBackoffWithRetries(int retryCount) {
+    // Calculate the exponential backoff delay with jitter
+    double exponent = retryCount > 0 ? Math.pow(BACKOFF_MULTIPLIER, retryCount) : 1;
+    long delay = (long) (INITIAL_BACKOFF_IN_SECONDS * exponent);
+    return RetriableStream.intervalWithJitter(delay);
+  }
+
+  private static long calculateMaxBackoff() {
+    return RetriableStream.intervalWithJitter(MAX_BACKOFF_IN_SECONDS);
+  }
+
+  private final class RecordedRetriableStream extends RetriableStream<String> {
+    RecordedRetriableStream(MethodDescriptor<String, ?> method, Metadata headers,
+        ChannelBufferMeter channelBufferUsed, long perRpcBufferLimit, long channelBufferLimit,
+        Executor callExecutor,
+        ScheduledExecutorService scheduledExecutorService,
+        @Nullable RetryPolicy retryPolicy,
+        @Nullable HedgingPolicy hedgingPolicy,
+        @Nullable Throttle throttle) {
+      super(
+          method, headers, channelBufferUsed, perRpcBufferLimit, channelBufferLimit, callExecutor,
+          scheduledExecutorService,
+          retryPolicy,
+          hedgingPolicy,
+          throttle);
+    }
+
+    @Override
+    @SuppressWarnings("DirectInvocationOnMock")
+    void postCommit() {
+      retriableStreamRecorder.postCommit();
+    }
+
+    @Override
+    @SuppressWarnings("DirectInvocationOnMock")
+    ClientStream newSubstream(
+        Metadata metadata,
+        ClientStreamTracer.Factory tracerFactory,
+        int previousAttempts,
+        boolean isTransparentRetry,
+        boolean isHedgedStream) {
+      bufferSizeTracer =
+          tracerFactory.newClientStreamTracer(STREAM_INFO, metadata);
+      int actualPreviousRpcAttemptsInHeader = metadata.get(GRPC_PREVIOUS_RPC_ATTEMPTS) == null
+          ? 0 : Integer.valueOf(metadata.get(GRPC_PREVIOUS_RPC_ATTEMPTS));
+      return retriableStreamRecorder.newSubstream(actualPreviousRpcAttemptsInHeader);
+    }
+
+    @Override
+    @SuppressWarnings("DirectInvocationOnMock")
+    Status prestart() {
+      return retriableStreamRecorder.prestart();
+    }
+  }
+
+  private RetriableStream<String> retriableStream =
+      newThrottledRetriableStream(null /* throttle */);
+  private RetriableStream<String> hedgingStream =
+      newThrottledHedgingStream(null /* throttle */);
+
+  private ClientStreamTracer bufferSizeTracer;
+
+  private RetriableStream<String> newThrottledRetriableStream(Throttle throttle) {
+    return newThrottledRetriableStream(throttle, MoreExecutors.directExecutor());
+  }
+
+  private RetriableStream<String> newThrottledRetriableStream(Throttle throttle, Executor drainer) {
+    return new RecordedRetriableStream(
+        method, new Metadata(), channelBufferUsed, PER_RPC_BUFFER_LIMIT, CHANNEL_BUFFER_LIMIT,
+        drainer, fakeClock.getScheduledExecutorService(), RETRY_POLICY, null, throttle);
+  }
+
+  private RetriableStream<String> newThrottledHedgingStream(Throttle throttle) {
+    return newThrottledHedgingStream(throttle, MoreExecutors.directExecutor());
+  }
+
+  private RetriableStream<String> newThrottledHedgingStream(Throttle throttle, Executor executor) {
+    return new RecordedRetriableStream(
+        method, new Metadata(), channelBufferUsed, PER_RPC_BUFFER_LIMIT, CHANNEL_BUFFER_LIMIT,
+        executor, fakeClock.getScheduledExecutorService(),
+        null, HEDGING_POLICY, throttle);
+  }
+
+  @After
+  public void tearDown() {
+    assertEquals(0, fakeClock.numPendingTasks());
+  }
+
+  @Test
+  public void retry_everythingDrained() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    doAnswer(new Answer<Void>() {
+        @Override
+        public Void answer(InvocationOnMock in) {
+          InsightBuilder insight = (InsightBuilder) in.getArguments()[0];
+          insight.appendKeyValue("remote_addr", "2.2.2.2:443");
+          return null;
+        }
+      }).when(mockStream3).appendTimeoutInsight(any(InsightBuilder.class));
+
+    InOrder inOrder =
+        inOrder(retriableStreamRecorder, masterListener, mockStream1, mockStream2, mockStream3);
+
+    // stream settings before start
+    retriableStream.setAuthority(AUTHORITY);
+    retriableStream.setCompressor(COMPRESSOR);
+    retriableStream.setDecompressorRegistry(DECOMPRESSOR_REGISTRY);
+    retriableStream.setFullStreamDecompression(false);
+    retriableStream.setFullStreamDecompression(true);
+    retriableStream.setMaxInboundMessageSize(MAX_INBOUND_MESSAGE_SIZE);
+    retriableStream.setMessageCompression(true);
+    retriableStream.setMaxOutboundMessageSize(MAX_OUTBOUND_MESSAGE_SIZE);
+    retriableStream.setMessageCompression(false);
+
+    inOrder.verifyNoMoreInteractions();
+
+    // start
+    retriableStream.start(masterListener);
+
+    inOrder.verify(retriableStreamRecorder).prestart();
+    inOrder.verify(retriableStreamRecorder).newSubstream(0);
+
+    inOrder.verify(mockStream1).setAuthority(AUTHORITY);
+    inOrder.verify(mockStream1).setCompressor(COMPRESSOR);
+    inOrder.verify(mockStream1).setDecompressorRegistry(DECOMPRESSOR_REGISTRY);
+    inOrder.verify(mockStream1).setFullStreamDecompression(false);
+    inOrder.verify(mockStream1).setFullStreamDecompression(true);
+    inOrder.verify(mockStream1).setMaxInboundMessageSize(MAX_INBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream1).setMessageCompression(true);
+    inOrder.verify(mockStream1).setMaxOutboundMessageSize(MAX_OUTBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream1).setMessageCompression(false);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    retriableStream.sendMessage("msg1");
+    retriableStream.sendMessage("msg2");
+    retriableStream.request(345);
+    retriableStream.flush();
+    retriableStream.flush();
+    retriableStream.sendMessage("msg3");
+    retriableStream.request(456);
+
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream1).flush(); // Memory leak workaround
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream1).flush(); // Memory leak workaround
+    inOrder.verify(mockStream1).request(345);
+    inOrder.verify(mockStream1, times(2)).flush();
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream1).flush(); // Memory leak workaround
+    inOrder.verify(mockStream1).request(456);
+    inOrder.verifyNoMoreInteractions();
+
+    // retry1
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_2), PROCESSED, new Metadata());
+    inOrder.verify(retriableStreamRecorder).newSubstream(1);
+    assertEquals(1, fakeClock.numPendingTasks());
+
+    // send more messages during backoff
+    retriableStream.sendMessage("msg1 during backoff1");
+    retriableStream.sendMessage("msg2 during backoff1");
+
+    fakeClock.forwardTime(calculateBackoffWithRetries(0) - 1L, TimeUnit.SECONDS);
+    inOrder.verifyNoMoreInteractions();
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(1L, TimeUnit.SECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    inOrder.verify(mockStream2).setAuthority(AUTHORITY);
+    inOrder.verify(mockStream2).setCompressor(COMPRESSOR);
+    inOrder.verify(mockStream2).setDecompressorRegistry(DECOMPRESSOR_REGISTRY);
+    inOrder.verify(mockStream2).setFullStreamDecompression(false);
+    inOrder.verify(mockStream2).setFullStreamDecompression(true);
+    inOrder.verify(mockStream2).setMaxInboundMessageSize(MAX_INBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream2).setMessageCompression(true);
+    inOrder.verify(mockStream2).setMaxOutboundMessageSize(MAX_OUTBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream2).setMessageCompression(false);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+    inOrder.verify(mockStream2).request(345);
+    inOrder.verify(mockStream2, times(2)).flush();
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+    inOrder.verify(mockStream2).request(456);
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // send more messages
+    retriableStream.sendMessage("msg1 after retry1");
+    retriableStream.sendMessage("msg2 after retry1");
+
+    // mockStream1 is closed so it is not in the drainedSubstreams
+    verifyNoMoreInteractions(mockStream1);
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+
+    // retry2
+    doReturn(mockStream3).when(retriableStreamRecorder).newSubstream(2);
+    sublistenerCaptor2.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    inOrder.verify(retriableStreamRecorder).newSubstream(2);
+    assertEquals(1, fakeClock.numPendingTasks());
+
+    // send more messages during backoff
+    retriableStream.sendMessage("msg1 during backoff2");
+    retriableStream.sendMessage("msg2 during backoff2");
+    retriableStream.sendMessage("msg3 during backoff2");
+
+    fakeClock.forwardTime(calculateBackoffWithRetries(1) - 1L, TimeUnit.SECONDS);
+    inOrder.verifyNoMoreInteractions();
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(1L, TimeUnit.SECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    inOrder.verify(mockStream3).setAuthority(AUTHORITY);
+    inOrder.verify(mockStream3).setCompressor(COMPRESSOR);
+    inOrder.verify(mockStream3).setDecompressorRegistry(DECOMPRESSOR_REGISTRY);
+    inOrder.verify(mockStream3).setFullStreamDecompression(false);
+    inOrder.verify(mockStream3).setFullStreamDecompression(true);
+    inOrder.verify(mockStream3).setMaxInboundMessageSize(MAX_INBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream3).setMessageCompression(true);
+    inOrder.verify(mockStream3).setMaxOutboundMessageSize(MAX_OUTBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream3).setMessageCompression(false);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
+    inOrder.verify(mockStream3).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream3).flush(); // Memory leak workaround
+    inOrder.verify(mockStream3).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream3).flush(); // Memory leak workaround
+    inOrder.verify(mockStream3).request(345);
+    inOrder.verify(mockStream3, times(2)).flush();
+    inOrder.verify(mockStream3).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream3).flush(); // Memory leak workaround
+    inOrder.verify(mockStream3).request(456);
+    for (int i = 0; i < 7; i++) {
+      inOrder.verify(mockStream3).writeMessage(any(InputStream.class));
+      inOrder.verify(mockStream3).flush(); // Memory leak workaround
+    }
+    inOrder.verify(mockStream3).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    InsightBuilder insight = new InsightBuilder();
+    retriableStream.appendTimeoutInsight(insight);
+    assertThat(insight.toString()).isEqualTo(
+        "[closed=[DATA_LOSS, UNAVAILABLE], open=[[remote_addr=2.2.2.2:443]]]");
+
+    // no more retry
+    sublistenerCaptor3.getValue().closed(
+        Status.fromCode(NON_RETRIABLE_STATUS_CODE), PROCESSED, new Metadata());
+
+    inOrder.verify(retriableStreamRecorder).postCommit();
+    inOrder.verify(masterListener).closed(
+        any(Status.class), any(RpcProgress.class), any(Metadata.class));
+    inOrder.verifyNoMoreInteractions();
+
+    insight = new InsightBuilder();
+    retriableStream.appendTimeoutInsight(insight);
+    assertThat(insight.toString()).isEqualTo(
+        "[closed=[DATA_LOSS, UNAVAILABLE, INTERNAL], committed=[remote_addr=2.2.2.2:443]]");
+  }
+
+  @Test
+  public void headersRead_cancel() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    InOrder inOrder = inOrder(retriableStreamRecorder);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    sublistenerCaptor1.getValue().headersRead(new Metadata());
+
+    inOrder.verify(retriableStreamRecorder).postCommit();
+
+    retriableStream.cancel(Status.CANCELLED);
+
+    inOrder.verify(retriableStreamRecorder, never()).postCommit();
+  }
+
+  @Test
+  public void retry_headersRead_cancel() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    InOrder inOrder = inOrder(retriableStreamRecorder);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    // retry
+    ClientStream mockStream2 = mock(ClientStream.class);
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(retriableStreamRecorder, never()).postCommit();
+
+    // headersRead
+    sublistenerCaptor2.getValue().headersRead(new Metadata());
+
+    inOrder.verify(retriableStreamRecorder).postCommit();
+
+    // cancel
+    retriableStream.cancel(Status.CANCELLED);
+
+    inOrder.verify(retriableStreamRecorder, never()).postCommit();
+  }
+
+  @Test
+  public void headersRead_closed() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    InOrder inOrder = inOrder(retriableStreamRecorder);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    sublistenerCaptor1.getValue().headersRead(new Metadata());
+
+    inOrder.verify(retriableStreamRecorder).postCommit();
+
+    Status status = Status.fromCode(RETRIABLE_STATUS_CODE_1);
+    Metadata metadata = new Metadata();
+    sublistenerCaptor1.getValue().closed(status, PROCESSED, metadata);
+
+    verify(masterListener).closed(status, PROCESSED, metadata);
+    inOrder.verify(retriableStreamRecorder, never()).postCommit();
+  }
+
+  @Test
+  public void retry_headersRead_closed() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    InOrder inOrder = inOrder(retriableStreamRecorder);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    // retry
+    ClientStream mockStream2 = mock(ClientStream.class);
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(retriableStreamRecorder, never()).postCommit();
+
+    // headersRead
+    sublistenerCaptor2.getValue().headersRead(new Metadata());
+
+    inOrder.verify(retriableStreamRecorder).postCommit();
+
+    // closed even with retriable status
+    Status status = Status.fromCode(RETRIABLE_STATUS_CODE_1);
+    Metadata metadata = new Metadata();
+    sublistenerCaptor2.getValue().closed(status, PROCESSED, metadata);
+
+    verify(masterListener).closed(status, PROCESSED, metadata);
+    inOrder.verify(retriableStreamRecorder, never()).postCommit();
+  }
+
+  @Test
+  public void cancel_closed() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    InOrder inOrder = inOrder(retriableStreamRecorder);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    // cancel
+    retriableStream.cancel(Status.CANCELLED);
+
+    inOrder.verify(retriableStreamRecorder).postCommit();
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockStream1).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+
+    // closed even with retriable status
+    Status status = Status.fromCode(RETRIABLE_STATUS_CODE_1);
+    Metadata metadata = new Metadata();
+    sublistenerCaptor1.getValue().closed(status, PROCESSED, metadata);
+    inOrder.verify(retriableStreamRecorder, never()).postCommit();
+  }
+
+  @Test
+  public void retry_cancel_closed() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    InOrder inOrder = inOrder(retriableStreamRecorder);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    // retry
+    ClientStream mockStream2 = mock(ClientStream.class);
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(retriableStreamRecorder, never()).postCommit();
+
+    // cancel
+    retriableStream.cancel(Status.CANCELLED);
+
+    inOrder.verify(retriableStreamRecorder).postCommit();
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockStream2).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+
+    // closed
+    Status status = Status.fromCode(NON_RETRIABLE_STATUS_CODE);
+    Metadata metadata = new Metadata();
+    sublistenerCaptor2.getValue().closed(status, PROCESSED, metadata);
+    inOrder.verify(retriableStreamRecorder, never()).postCommit();
+  }
+
+  @Test
+  public void transparentRetry_cancel_race() {
+    FakeClock drainer = new FakeClock();
+    retriableStream = newThrottledRetriableStream(null, drainer.getScheduledExecutorService());
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    InOrder inOrder = inOrder(retriableStreamRecorder);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    // retry, but don't drain
+    ClientStream mockStream2 = mock(ClientStream.class);
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(0);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(NON_RETRIABLE_STATUS_CODE), MISCARRIED, new Metadata());
+    assertEquals(1, drainer.numPendingTasks());
+
+    // cancel
+    retriableStream.cancel(Status.CANCELLED);
+    // drain transparent retry
+    drainer.runDueTasks();
+    inOrder.verify(retriableStreamRecorder).postCommit();
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream2).start(sublistenerCaptor2.capture());
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockStream2).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+    sublistenerCaptor2.getValue().closed(statusCaptor.getValue(), PROCESSED, new Metadata());
+    verify(masterListener).closed(same(Status.CANCELLED), same(PROCESSED), any(Metadata.class));
+  }
+
+  @Test
+  public void unretriableClosed_cancel() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    InOrder inOrder = inOrder(retriableStreamRecorder);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    // closed
+    Status status = Status.fromCode(NON_RETRIABLE_STATUS_CODE);
+    Metadata metadata = new Metadata();
+    sublistenerCaptor1.getValue().closed(status, PROCESSED, metadata);
+
+    inOrder.verify(retriableStreamRecorder).postCommit();
+    verify(masterListener).closed(status, PROCESSED, metadata);
+
+    // cancel
+    retriableStream.cancel(Status.CANCELLED);
+    inOrder.verify(retriableStreamRecorder, never()).postCommit();
+  }
+
+  @Test
+  public void retry_unretriableClosed_cancel() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    InOrder inOrder = inOrder(retriableStreamRecorder);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    // retry
+    ClientStream mockStream2 = mock(ClientStream.class);
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(retriableStreamRecorder, never()).postCommit();
+
+    // closed
+    Status status = Status.fromCode(NON_RETRIABLE_STATUS_CODE);
+    Metadata metadata = new Metadata();
+    sublistenerCaptor2.getValue().closed(status, PROCESSED, metadata);
+
+    inOrder.verify(retriableStreamRecorder).postCommit();
+    verify(masterListener).closed(status, PROCESSED, metadata);
+
+    // cancel
+    retriableStream.cancel(Status.CANCELLED);
+    inOrder.verify(retriableStreamRecorder, never()).postCommit();
+    verify(masterListener, times(1)).closed(any(), any(), any());
+  }
+
+  @Test
+  public void retry_cancelWhileBackoff() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+    verify(mockStream1).isReady();
+
+    // retry
+    ClientStream mockStream2 = mock(ClientStream.class);
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+
+    // cancel while backoff
+    assertEquals(1, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder, never()).postCommit();
+    retriableStream.cancel(Status.CANCELLED);
+    verify(retriableStreamRecorder).postCommit();
+
+    verifyNoMoreInteractions(mockStream1);
+    verifyNoMoreInteractions(mockStream2);
+    verify(masterListener, times(1)).closed(any(), any(), any());
+  }
+
+  @Test
+  public void operationsWhileDraining() {
+    final ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    final AtomicReference<ClientStreamListener> sublistenerCaptor2 =
+        new AtomicReference<>();
+    final Status cancelStatus = Status.CANCELLED.withDescription("c");
+    ClientStream mockStream1 =
+        mock(
+            ClientStream.class,
+            delegatesTo(
+                new NoopClientStream() {
+                  @Override
+                  public void request(int numMessages) {
+                    retriableStream.sendMessage("substream1 request " + numMessages);
+                    sublistenerCaptor1.getValue().onReady();
+                    if (numMessages > 1) {
+                      retriableStream.request(--numMessages);
+                    }
+                  }
+
+                  @Override
+                  public boolean isReady() {
+                    return true;
+                  }
+                }));
+
+    final ClientStream mockStream2 =
+        mock(
+            ClientStream.class,
+            delegatesTo(
+                new NoopClientStream() {
+                  @Override
+                  public void start(ClientStreamListener listener) {
+                    sublistenerCaptor2.set(listener);
+                  }
+
+                  @Override
+                  public void request(int numMessages) {
+                    retriableStream.sendMessage("substream2 request " + numMessages);
+                    sublistenerCaptor2.get().onReady();
+                    if (numMessages == 3) {
+                      sublistenerCaptor2.get().headersRead(new Metadata());
+                    }
+                    if (numMessages == 2) {
+                      retriableStream.request(100);
+                    }
+                    if (numMessages == 100) {
+                      retriableStream.cancel(cancelStatus);
+                    }
+                  }
+
+                  @Override
+                  public boolean isReady() {
+                    return true;
+                  }
+                }));
+
+    InOrder inOrder = inOrder(retriableStreamRecorder, mockStream1, mockStream2, masterListener);
+
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    retriableStream.start(masterListener);
+
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    retriableStream.request(3);
+
+    inOrder.verify(mockStream1).request(3);
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class)); // msg "substream1 request 3"
+    inOrder.verify(mockStream1).request(2);
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class)); // msg "substream1 request 2"
+    inOrder.verify(mockStream1).request(1);
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class)); // msg "substream1 request 1"
+    inOrder.verify(masterListener).onReady();
+
+    // retry
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    assertEquals(1, fakeClock.numPendingTasks());
+
+    // send more requests during backoff
+    retriableStream.request(789);
+
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.get());
+    inOrder.verify(mockStream2).request(3);
+    inOrder.verify(retriableStreamRecorder).postCommit();
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class)); // msg "substream1 request 3"
+    inOrder.verify(mockStream2).request(2);
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class)); // msg "substream1 request 2"
+    inOrder.verify(mockStream2).request(1);
+
+    // msg "substream1 request 1"
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).request(789);
+    // msg "substream2 request 3"
+    // msg "substream2 request 2"
+    inOrder.verify(mockStream2, times(2)).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).request(100);
+    inOrder.verify(mockStream2).cancel(cancelStatus);
+    inOrder.verify(masterListener, never()).onReady();
+
+    // "substream2 request 1" will never be sent
+    inOrder.verify(mockStream2, never()).writeMessage(any(InputStream.class));
+  }
+
+  @Test
+  public void cancelWhileDraining() {
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 =
+        mock(
+            ClientStream.class,
+            delegatesTo(
+                new NoopClientStream() {
+                  @Override
+                  public void request(int numMessages) {
+                    retriableStream.cancel(
+                        Status.CANCELLED.withDescription("cancelled while requesting"));
+                  }
+                }));
+
+    InOrder inOrder = inOrder(retriableStreamRecorder, mockStream1, mockStream2);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    retriableStream.start(masterListener);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    retriableStream.request(3);
+    inOrder.verify(mockStream1).request(3);
+
+    // retry
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).request(3);
+    inOrder.verify(retriableStreamRecorder).postCommit();
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    inOrder.verify(mockStream2).cancel(statusCaptor.capture());
+    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.CANCELLED);
+    assertThat(statusCaptor.getValue().getDescription())
+        .isEqualTo("Stream thrown away because RetriableStream committed");
+    sublistenerCaptor2.getValue().closed(Status.CANCELLED, PROCESSED, new Metadata());
+    verify(masterListener).closed(
+        statusCaptor.capture(), any(RpcProgress.class), any(Metadata.class));
+    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.CANCELLED);
+    assertThat(statusCaptor.getValue().getDescription()).isEqualTo("cancelled while requesting");
+  }
+
+  @Test
+  public void cancelWhileRetryStart() {
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 =
+        mock(
+            ClientStream.class,
+            delegatesTo(
+                new NoopClientStream() {
+                  @Override
+                  public void start(ClientStreamListener listener) {
+                    retriableStream.cancel(
+                        Status.CANCELLED.withDescription("cancelled while retry start"));
+                  }
+                }));
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+
+    InOrder inOrder = inOrder(retriableStreamRecorder, mockStream1, mockStream2);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    retriableStream.start(masterListener);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    // retry
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(retriableStreamRecorder).postCommit();
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    inOrder.verify(mockStream2).cancel(statusCaptor.capture());
+    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.CANCELLED);
+    assertThat(statusCaptor.getValue().getDescription())
+        .isEqualTo("Stream thrown away because RetriableStream committed");
+    sublistenerCaptor2.getValue().closed(Status.CANCELLED, PROCESSED, new Metadata());
+    verify(masterListener).closed(
+        statusCaptor.capture(), any(RpcProgress.class), any(Metadata.class));
+    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.CANCELLED);
+    assertThat(statusCaptor.getValue().getDescription()).isEqualTo("cancelled while retry start");
+  }
+
+  @Test
+  public void operationsAfterImmediateCommit() {
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    ClientStream mockStream1 = mock(ClientStream.class);
+
+    InOrder inOrder = inOrder(retriableStreamRecorder, mockStream1);
+
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    retriableStream.start(masterListener);
+
+    // drained
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    // commit
+    sublistenerCaptor1.getValue().headersRead(new Metadata());
+
+    retriableStream.request(3);
+    inOrder.verify(mockStream1).request(3);
+    retriableStream.sendMessage("msg 1");
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class));
+  }
+
+  @Test
+  public void isReady_whenDrained() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    retriableStream.start(masterListener);
+
+    assertFalse(retriableStream.isReady());
+
+    doReturn(true).when(mockStream1).isReady();
+
+    assertTrue(retriableStream.isReady());
+  }
+
+  @Test
+  public void isReady_whileDraining() {
+    final AtomicReference<ClientStreamListener> sublistenerCaptor1 =
+        new AtomicReference<>();
+    final List<Boolean> readiness = new ArrayList<>();
+    ClientStream mockStream1 =
+        mock(
+            ClientStream.class,
+            delegatesTo(
+                new NoopClientStream() {
+                  @Override
+                  public void start(ClientStreamListener listener) {
+                    sublistenerCaptor1.set(listener);
+                    readiness.add(retriableStream.isReady()); // expected false b/c in draining
+                  }
+
+                  @Override
+                  public boolean isReady() {
+                    return true;
+                  }
+                }));
+
+    final ClientStream mockStream2 =
+        mock(
+            ClientStream.class,
+            delegatesTo(
+                new NoopClientStream() {
+                  @Override
+                  public void start(ClientStreamListener listener) {
+                    readiness.add(retriableStream.isReady()); // expected false b/c in draining
+                  }
+
+                  @Override
+                  public boolean isReady() {
+                    return true;
+                  }
+                }));
+
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    retriableStream.start(masterListener);
+
+    verify(mockStream1).start(sublistenerCaptor1.get());
+    readiness.add(retriableStream.isReady()); // expected true
+
+    // retry
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    doReturn(false).when(mockStream1).isReady(); // mockStream1 closed, so isReady false
+    sublistenerCaptor1.get().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    assertEquals(1, fakeClock.numPendingTasks());
+
+    // send more requests during backoff
+    retriableStream.request(789);
+    readiness.add(retriableStream.isReady()); // expected false b/c in backoff
+
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+
+    verify(mockStream2).start(any(ClientStreamListener.class));
+    readiness.add(retriableStream.isReady()); // expected true
+
+    assertThat(readiness).containsExactly(false, true, false, false, true).inOrder();
+  }
+
+  @Test
+  public void messageAvailable() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    ClientStreamListener listener = sublistenerCaptor1.getValue();
+    listener.headersRead(new Metadata());
+    MessageProducer messageProducer = mock(MessageProducer.class);
+    listener.messagesAvailable(messageProducer);
+    verify(masterListener).messagesAvailable(messageProducer);
+  }
+
+  @Test
+  public void inboundMessagesClosedOnCancel() throws Exception {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+
+    retriableStream.start(masterListener);
+    retriableStream.request(1);
+    retriableStream.cancel(Status.CANCELLED.withDescription("on purpose"));
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    ClientStreamListener listener = sublistenerCaptor1.getValue();
+    listener.headersRead(new Metadata());
+    InputStream is = mock(InputStream.class);
+    listener.messagesAvailable(new FakeMessageProducer(is));
+    verify(masterListener, never()).messagesAvailable(any(MessageProducer.class));
+    verify(is).close();
+  }
+
+  @Test
+  public void notAdd0PrevRetryAttemptsToRespHeaders() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor =
+            ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor.capture());
+
+    sublistenerCaptor.getValue().headersRead(new Metadata());
+
+    ArgumentCaptor<Metadata> metadataCaptor =
+            ArgumentCaptor.forClass(Metadata.class);
+    verify(masterListener).headersRead(metadataCaptor.capture());
+    assertEquals(null, metadataCaptor.getValue().get(GRPC_PREVIOUS_RPC_ATTEMPTS));
+  }
+
+  @Test
+  public void addPrevRetryAttemptsToRespHeaders() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+            ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    // retry
+    ClientStream mockStream2 = mock(ClientStream.class);
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor1.getValue().closed(
+            Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+            ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream2).start(sublistenerCaptor2.capture());
+    Metadata headers = new Metadata();
+    headers.put(GRPC_PREVIOUS_RPC_ATTEMPTS, "3");
+    sublistenerCaptor2.getValue().headersRead(headers);
+
+    ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
+    verify(masterListener).headersRead(metadataCaptor.capture());
+    Iterable<String> iterable = metadataCaptor.getValue().getAll(GRPC_PREVIOUS_RPC_ATTEMPTS);
+    assertEquals(1, Iterables.size(iterable));
+    assertEquals("1", iterable.iterator().next());
+  }
+
+  @Test
+  public void closedWhileDraining() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    final ClientStream mockStream2 =
+        mock(
+            ClientStream.class,
+            delegatesTo(
+                new NoopClientStream() {
+                  @Override
+                  public void start(ClientStreamListener listener) {
+                    // closed while draning
+                    listener.closed(
+                        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+                  }
+                }));
+    final ClientStream mockStream3 = mock(ClientStream.class);
+
+    when(retriableStreamRecorder.newSubstream(anyInt()))
+        .thenReturn(mockStream1, mockStream2, mockStream3);
+
+    retriableStream.start(masterListener);
+    retriableStream.sendMessage("msg1");
+    retriableStream.sendMessage("msg2");
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    ClientStreamListener listener1 = sublistenerCaptor1.getValue();
+
+    // retry
+    listener1.closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+
+    // send requests during backoff
+    retriableStream.request(3);
+    fakeClock.forwardTime(calculateBackoffWithRetries(1), TimeUnit.SECONDS);
+
+    retriableStream.request(1);
+    verify(mockStream1, never()).request(anyInt());
+    verify(mockStream2, never()).request(anyInt());
+    verify(mockStream3).request(3);
+    verify(mockStream3).request(1);
+  }
+
+  @Test
+  public void commitAndCancelWhileDraining() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 =
+        mock(
+            ClientStream.class,
+            delegatesTo(
+                new NoopClientStream() {
+                  @Override
+                  public void start(ClientStreamListener listener) {
+                    // commit while draining
+                    listener.headersRead(new Metadata());
+                    // cancel while draining
+                    retriableStream.cancel(
+                        Status.CANCELLED.withDescription("cancelled while drained"));
+                  }
+                }));
+
+    when(retriableStreamRecorder.newSubstream(anyInt()))
+        .thenReturn(mockStream1, mockStream2);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    ClientStreamListener listener1 = sublistenerCaptor1.getValue();
+
+    // retry
+    listener1.closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+
+    verify(mockStream2).start(any(ClientStreamListener.class));
+    verify(retriableStreamRecorder).postCommit();
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockStream2).cancel(statusCaptor.capture());
+    assertThat(statusCaptor.getValue().getCode()).isEqualTo(Code.CANCELLED);
+    assertThat(statusCaptor.getValue().getDescription()).isEqualTo("cancelled while drained");
+  }
+
+  @Test
+  public void perRpcBufferLimitExceeded() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+
+    retriableStream.start(masterListener);
+
+    bufferSizeTracer.outboundWireSize(PER_RPC_BUFFER_LIMIT);
+
+    assertEquals(PER_RPC_BUFFER_LIMIT, channelBufferUsed.addAndGet(0));
+
+    verify(retriableStreamRecorder, never()).postCommit();
+    bufferSizeTracer.outboundWireSize(2);
+    verify(retriableStreamRecorder).postCommit();
+
+    // verify channel buffer is adjusted
+    assertEquals(0, channelBufferUsed.addAndGet(0));
+  }
+
+  @Test
+  public void perRpcBufferLimitExceededDuringBackoff() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+
+    retriableStream.start(masterListener);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+    verify(mockStream1).isReady();
+
+    bufferSizeTracer.outboundWireSize(PER_RPC_BUFFER_LIMIT - 1);
+
+    // retry
+    ClientStream mockStream2 = mock(ClientStream.class);
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+
+    assertEquals(1, fakeClock.numPendingTasks());
+    bufferSizeTracer.outboundWireSize(2);
+    verify(retriableStreamRecorder, never()).postCommit();
+
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+    verify(mockStream2).start(any(ClientStreamListener.class));
+    verify(mockStream2).isReady();
+
+    // bufferLimitExceeded
+    bufferSizeTracer.outboundWireSize(PER_RPC_BUFFER_LIMIT - 1);
+    verify(retriableStreamRecorder).postCommit();
+
+    verifyNoMoreInteractions(mockStream1);
+    verifyNoMoreInteractions(mockStream2);
+  }
+
+  @Test
+  public void channelBufferLimitExceeded() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+
+    retriableStream.start(masterListener);
+
+    bufferSizeTracer.outboundWireSize(100);
+
+    assertEquals(100, channelBufferUsed.addAndGet(0));
+
+    channelBufferUsed.addAndGet(CHANNEL_BUFFER_LIMIT - 200);
+    verify(retriableStreamRecorder, never()).postCommit();
+    bufferSizeTracer.outboundWireSize(100 + 1);
+    verify(retriableStreamRecorder).postCommit();
+
+    // verify channel buffer is adjusted
+    assertEquals(CHANNEL_BUFFER_LIMIT - 200, channelBufferUsed.addAndGet(0));
+  }
+
+  @Test
+  public void updateHeaders() {
+    Metadata originalHeaders = new Metadata();
+    Metadata headers = retriableStream.updateHeaders(originalHeaders, 0);
+    assertNotSame(originalHeaders, headers);
+    assertNull(headers.get(GRPC_PREVIOUS_RPC_ATTEMPTS));
+
+    headers = retriableStream.updateHeaders(originalHeaders, 345);
+    assertEquals("345", headers.get(GRPC_PREVIOUS_RPC_ATTEMPTS));
+    assertNull(originalHeaders.get(GRPC_PREVIOUS_RPC_ATTEMPTS));
+  }
+
+  @Test
+  public void expBackoff_maxBackoff_maxRetryAttempts() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    ClientStream mockStream4 = mock(ClientStream.class);
+    ClientStream mockStream5 = mock(ClientStream.class);
+    ClientStream mockStream6 = mock(ClientStream.class);
+    ClientStream mockStream7 = mock(ClientStream.class);
+    InOrder inOrder = inOrder(
+        mockStream1, mockStream2, mockStream3, mockStream4, mockStream5, mockStream6, mockStream7);
+    when(retriableStreamRecorder.newSubstream(anyInt())).thenReturn(
+        mockStream1, mockStream2, mockStream3, mockStream4, mockStream5, mockStream6, mockStream7);
+
+    retriableStream.start(masterListener);
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder).newSubstream(0);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+
+    // retry1
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0) - 1L, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(1L, TimeUnit.SECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder).newSubstream(1);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // retry2
+    sublistenerCaptor2.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_2), PROCESSED, new Metadata());
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateBackoffWithRetries(1) - 1L, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(1L, TimeUnit.SECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder).newSubstream(2);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
+    inOrder.verify(mockStream3).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // retry3
+    sublistenerCaptor3.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateBackoffWithRetries(2) - 1L, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(1L, TimeUnit.SECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder).newSubstream(3);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor4 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream4).start(sublistenerCaptor4.capture());
+    inOrder.verify(mockStream4).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // retry4
+    sublistenerCaptor4.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_2), PROCESSED, new Metadata());
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateMaxBackoff() - 1L, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(1L, TimeUnit.SECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder).newSubstream(4);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor5 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream5).start(sublistenerCaptor5.capture());
+    inOrder.verify(mockStream5).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // retry5
+    sublistenerCaptor5.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_2), PROCESSED, new Metadata());
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateMaxBackoff() - 1L, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(1L, TimeUnit.SECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder).newSubstream(5);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor6 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream6).start(sublistenerCaptor6.capture());
+    inOrder.verify(mockStream6).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // can not retry any more
+    verify(retriableStreamRecorder, never()).postCommit();
+    sublistenerCaptor6.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    verify(retriableStreamRecorder).postCommit();
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void pushback() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    ClientStream mockStream4 = mock(ClientStream.class);
+    ClientStream mockStream5 = mock(ClientStream.class);
+    ClientStream mockStream6 = mock(ClientStream.class);
+    ClientStream mockStream7 = mock(ClientStream.class);
+    InOrder inOrder = inOrder(
+        mockStream1, mockStream2, mockStream3, mockStream4, mockStream5, mockStream6, mockStream7);
+    when(retriableStreamRecorder.newSubstream(anyInt())).thenReturn(
+        mockStream1, mockStream2, mockStream3, mockStream4, mockStream5, mockStream6, mockStream7);
+
+    retriableStream.start(masterListener);
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder).newSubstream(0);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+
+    // retry1
+    int pushbackInMillis = 123;
+    Metadata headers = new Metadata();
+    headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "" + pushbackInMillis);
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, headers);
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(pushbackInMillis - 1, TimeUnit.MILLISECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(1L, TimeUnit.MILLISECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder).newSubstream(1);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // retry2
+    pushbackInMillis = 4567 * 1000;
+    headers = new Metadata();
+    headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "" + pushbackInMillis);
+    sublistenerCaptor2.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_2), PROCESSED, headers);
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(pushbackInMillis - 1, TimeUnit.MILLISECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(1L, TimeUnit.MILLISECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder).newSubstream(2);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
+    inOrder.verify(mockStream3).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // retry3
+    sublistenerCaptor3.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0) - 1L, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(1L, TimeUnit.SECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder).newSubstream(3);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor4 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream4).start(sublistenerCaptor4.capture());
+    inOrder.verify(mockStream4).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // retry4
+    sublistenerCaptor4.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_2), PROCESSED, new Metadata());
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateBackoffWithRetries(1) - 1L, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(1L, TimeUnit.SECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder).newSubstream(4);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor5 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream5).start(sublistenerCaptor5.capture());
+    inOrder.verify(mockStream5).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // retry5
+    sublistenerCaptor5.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_2), PROCESSED, new Metadata());
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateBackoffWithRetries(2) - 1L, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(1L, TimeUnit.SECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder).newSubstream(5);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor6 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream6).start(sublistenerCaptor6.capture());
+    inOrder.verify(mockStream6).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // can not retry any more even pushback is positive
+    pushbackInMillis = 4567 * 1000;
+    headers = new Metadata();
+    headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "" + pushbackInMillis);
+    verify(retriableStreamRecorder, never()).postCommit();
+    sublistenerCaptor6.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, headers);
+    verify(retriableStreamRecorder).postCommit();
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void pushback_noRetry() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(anyInt());
+
+    retriableStream.start(masterListener);
+    assertEquals(0, fakeClock.numPendingTasks());
+    verify(retriableStreamRecorder).newSubstream(0);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+    verify(retriableStreamRecorder, never()).postCommit();
+
+    // pushback no retry
+    Metadata headers = new Metadata();
+    headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "");
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, headers);
+
+    verify(retriableStreamRecorder, never()).newSubstream(1);
+    verify(retriableStreamRecorder).postCommit();
+  }
+
+  @Test
+  public void throttle() {
+    Throttle throttle = new Throttle(4f, 0.8f);
+    assertTrue(throttle.isAboveThreshold());
+    assertTrue(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // token = 3
+    assertTrue(throttle.isAboveThreshold());
+    assertFalse(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // token = 2
+    assertFalse(throttle.isAboveThreshold());
+    assertFalse(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // token = 1
+    assertFalse(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // token = 0
+    assertFalse(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // token = 0
+    assertFalse(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // token = 0
+    assertFalse(throttle.isAboveThreshold());
+
+    throttle.onSuccess(); // token = 0.8
+    assertFalse(throttle.isAboveThreshold());
+    throttle.onSuccess(); // token = 1.6
+    assertFalse(throttle.isAboveThreshold());
+    throttle.onSuccess(); // token = 3.2
+    assertTrue(throttle.isAboveThreshold());
+    throttle.onSuccess(); // token = 4
+    assertTrue(throttle.isAboveThreshold());
+    throttle.onSuccess(); // token = 4
+    assertTrue(throttle.isAboveThreshold());
+    throttle.onSuccess(); // token = 4
+    assertTrue(throttle.isAboveThreshold());
+
+    assertTrue(throttle.isAboveThreshold());
+    assertTrue(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // token = 3
+    assertTrue(throttle.isAboveThreshold());
+    assertFalse(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // token = 2
+    assertFalse(throttle.isAboveThreshold());
+  }
+
+  @Test
+  public void throttledStream_FailWithRetriableStatusCode_WithoutPushback() {
+    Throttle throttle = new Throttle(4f, 0.8f);
+    RetriableStream<String> retriableStream = newThrottledRetriableStream(throttle);
+
+    ClientStream mockStream = mock(ClientStream.class);
+    doReturn(mockStream).when(retriableStreamRecorder).newSubstream(anyInt());
+    retriableStream.start(masterListener);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream).start(sublistenerCaptor.capture());
+
+    // mimic some other call in the channel triggers a throttle countdown
+    assertTrue(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // count = 3
+
+    sublistenerCaptor.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+    verify(retriableStreamRecorder).postCommit();
+    assertFalse(throttle.isAboveThreshold()); // count = 2
+  }
+
+  @Test
+  public void throttledStream_FailWithNonRetriableStatusCode_WithoutPushback() {
+    Throttle throttle = new Throttle(4f, 0.8f);
+    RetriableStream<String> retriableStream = newThrottledRetriableStream(throttle);
+
+    ClientStream mockStream = mock(ClientStream.class);
+    doReturn(mockStream).when(retriableStreamRecorder).newSubstream(anyInt());
+    retriableStream.start(masterListener);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream).start(sublistenerCaptor.capture());
+
+    // mimic some other call in the channel triggers a throttle countdown
+    assertTrue(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // count = 3
+
+    sublistenerCaptor.getValue().closed(
+        Status.fromCode(NON_RETRIABLE_STATUS_CODE), PROCESSED, new Metadata());
+    verify(retriableStreamRecorder).postCommit();
+    assertTrue(throttle.isAboveThreshold()); // count = 3
+
+    assertFalse(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // count = 2
+  }
+
+  @Test
+  public void throttledStream_FailWithRetriableStatusCode_WithRetriablePushback() {
+    Throttle throttle = new Throttle(4f, 0.8f);
+    RetriableStream<String> retriableStream = newThrottledRetriableStream(throttle);
+
+    ClientStream mockStream = mock(ClientStream.class);
+    doReturn(mockStream).when(retriableStreamRecorder).newSubstream(anyInt());
+    retriableStream.start(masterListener);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream).start(sublistenerCaptor.capture());
+
+    // mimic some other call in the channel triggers a throttle countdown
+    assertTrue(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // count = 3
+
+    int pushbackInMillis = 123;
+    Metadata headers = new Metadata();
+    headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "" + pushbackInMillis);
+    sublistenerCaptor.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, headers);
+    verify(retriableStreamRecorder).postCommit();
+    assertFalse(throttle.isAboveThreshold()); // count = 2
+  }
+
+  @Test
+  public void throttledStream_FailWithNonRetriableStatusCode_WithRetriablePushback() {
+    Throttle throttle = new Throttle(4f, 0.8f);
+    RetriableStream<String> retriableStream = newThrottledRetriableStream(throttle);
+
+    ClientStream mockStream = mock(ClientStream.class);
+    doReturn(mockStream).when(retriableStreamRecorder).newSubstream(anyInt());
+    retriableStream.start(masterListener);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream).start(sublistenerCaptor.capture());
+
+    // mimic some other call in the channel triggers a throttle countdown
+    assertTrue(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // count = 3
+
+    int pushbackInMillis = 123;
+    Metadata headers = new Metadata();
+    headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "" + pushbackInMillis);
+    sublistenerCaptor.getValue().closed(
+        Status.fromCode(NON_RETRIABLE_STATUS_CODE), PROCESSED, headers);
+    verify(retriableStreamRecorder, never()).postCommit();
+    assertTrue(throttle.isAboveThreshold()); // count = 3
+
+    // drain pending retry
+    fakeClock.forwardTime(pushbackInMillis, TimeUnit.MILLISECONDS);
+
+    assertTrue(throttle.isAboveThreshold()); // count = 3
+    assertFalse(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // count = 2
+  }
+
+  @Test
+  public void throttledStream_FailWithRetriableStatusCode_WithNonRetriablePushback() {
+    Throttle throttle = new Throttle(4f, 0.8f);
+    RetriableStream<String> retriableStream = newThrottledRetriableStream(throttle);
+
+    ClientStream mockStream = mock(ClientStream.class);
+    doReturn(mockStream).when(retriableStreamRecorder).newSubstream(anyInt());
+    retriableStream.start(masterListener);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream).start(sublistenerCaptor.capture());
+
+    // mimic some other call in the channel triggers a throttle countdown
+    assertTrue(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // count = 3
+
+    Metadata headers = new Metadata();
+    headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "");
+    sublistenerCaptor.getValue().closed(
+        Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, headers);
+    verify(retriableStreamRecorder).postCommit();
+    assertFalse(throttle.isAboveThreshold()); // count = 2
+  }
+
+  @Test
+  public void throttledStream_FailWithNonRetriableStatusCode_WithNonRetriablePushback() {
+    Throttle throttle = new Throttle(4f, 0.8f);
+    RetriableStream<String> retriableStream = newThrottledRetriableStream(throttle);
+
+    ClientStream mockStream = mock(ClientStream.class);
+    doReturn(mockStream).when(retriableStreamRecorder).newSubstream(anyInt());
+    retriableStream.start(masterListener);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream).start(sublistenerCaptor.capture());
+
+    // mimic some other call in the channel triggers a throttle countdown
+    assertTrue(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // count = 3
+
+    Metadata headers = new Metadata();
+    headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "");
+    sublistenerCaptor.getValue().closed(
+        Status.fromCode(NON_RETRIABLE_STATUS_CODE), PROCESSED, headers);
+    verify(retriableStreamRecorder).postCommit();
+    assertFalse(throttle.isAboveThreshold()); // count = 2
+  }
+
+  @Test
+  public void throttleStream_Succeed() {
+    Throttle throttle = new Throttle(4f, 0.8f);
+    RetriableStream<String> retriableStream = newThrottledRetriableStream(throttle);
+
+    ClientStream mockStream = mock(ClientStream.class);
+    doReturn(mockStream).when(retriableStreamRecorder).newSubstream(anyInt());
+    retriableStream.start(masterListener);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream).start(sublistenerCaptor.capture());
+
+    // mimic some other calls in the channel trigger throttle countdowns
+    assertTrue(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // count = 3
+    assertFalse(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // count = 2
+    assertFalse(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // count = 1
+
+    sublistenerCaptor.getValue().headersRead(new Metadata());
+    verify(retriableStreamRecorder).postCommit();
+    assertFalse(throttle.isAboveThreshold());  // count = 1.8
+
+    // mimic some other call in the channel triggers a success
+    throttle.onSuccess();
+    assertTrue(throttle.isAboveThreshold()); // count = 2.6
+  }
+
+  @Test
+  public void transparentRetry_onlyOnceOnRefused() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    InOrder inOrder = inOrder(
+        retriableStreamRecorder,
+        mockStream1, mockStream2, mockStream3);
+
+    // start
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    retriableStream.start(masterListener);
+
+    inOrder.verify(retriableStreamRecorder).newSubstream(0);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // transparent retry
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(0);
+    sublistenerCaptor1.getValue()
+        .closed(Status.fromCode(NON_RETRIABLE_STATUS_CODE), REFUSED, new Metadata());
+
+    inOrder.verify(retriableStreamRecorder).newSubstream(0);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+    verify(retriableStreamRecorder, never()).postCommit();
+    assertEquals(0, fakeClock.numPendingTasks());
+
+    // no more transparent retry
+    doReturn(mockStream3).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor2.getValue()
+        .closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), REFUSED, new Metadata());
+
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+    inOrder.verify(retriableStreamRecorder).newSubstream(1);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
+    inOrder.verify(mockStream3).isReady();
+    inOrder.verifyNoMoreInteractions();
+    verify(retriableStreamRecorder, never()).postCommit();
+    assertEquals(0, fakeClock.numPendingTasks());
+  }
+
+  @Test
+  public void transparentRetry_unlimitedTimesOnMiscarried() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    InOrder inOrder = inOrder(
+        retriableStreamRecorder,
+        mockStream1, mockStream2, mockStream3);
+
+    // start
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    retriableStream.start(masterListener);
+
+    inOrder.verify(retriableStreamRecorder).newSubstream(0);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // transparent retry
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(0);
+    sublistenerCaptor1.getValue()
+        .closed(Status.fromCode(NON_RETRIABLE_STATUS_CODE), MISCARRIED, new Metadata());
+
+    inOrder.verify(retriableStreamRecorder).newSubstream(0);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+    verify(retriableStreamRecorder, never()).postCommit();
+    assertEquals(0, fakeClock.numPendingTasks());
+
+    // more transparent retry
+    doReturn(mockStream3).when(retriableStreamRecorder).newSubstream(0);
+    sublistenerCaptor2.getValue()
+        .closed(Status.fromCode(NON_RETRIABLE_STATUS_CODE), MISCARRIED, new Metadata());
+
+    inOrder.verify(retriableStreamRecorder).newSubstream(0);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
+    inOrder.verify(mockStream3).isReady();
+    inOrder.verifyNoMoreInteractions();
+    verify(retriableStreamRecorder, never()).postCommit();
+    assertEquals(0, fakeClock.numPendingTasks());
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor = sublistenerCaptor3;
+    for (int i = 0; i < 999; i++) {
+      ClientStream mockStream = mock(ClientStream.class);
+      doReturn(mockStream).when(retriableStreamRecorder).newSubstream(0);
+      sublistenerCaptor.getValue()
+          .closed(Status.fromCode(NON_RETRIABLE_STATUS_CODE), MISCARRIED, new Metadata());
+      if (i == 998) {
+        verify(retriableStreamRecorder).postCommit();
+        verify(masterListener)
+            .closed(any(Status.class), any(RpcProgress.class), any(Metadata.class));
+      } else {
+        verify(retriableStreamRecorder, never()).postCommit();
+        sublistenerCaptor = ArgumentCaptor.forClass(ClientStreamListener.class);
+        verify(mockStream).start(sublistenerCaptor.capture());
+      }
+    }
+  }
+
+  @Test
+  public void normalRetry_thenNoTransparentRetry_butNormalRetry() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    InOrder inOrder = inOrder(
+        retriableStreamRecorder,
+        mockStream1, mockStream2, mockStream3);
+
+    // start
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    retriableStream.start(masterListener);
+
+    inOrder.verify(retriableStreamRecorder).newSubstream(0);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // normal retry
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor1.getValue()
+        .closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+    inOrder.verify(retriableStreamRecorder).newSubstream(1);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+    verify(retriableStreamRecorder, never()).postCommit();
+    assertEquals(0, fakeClock.numPendingTasks());
+
+    // no more transparent retry
+    doReturn(mockStream3).when(retriableStreamRecorder).newSubstream(2);
+    sublistenerCaptor2.getValue()
+        .closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), REFUSED, new Metadata());
+
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateBackoffWithRetries(1), TimeUnit.SECONDS);
+    inOrder.verify(retriableStreamRecorder).newSubstream(2);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
+    inOrder.verify(mockStream3).isReady();
+    inOrder.verifyNoMoreInteractions();
+    verify(retriableStreamRecorder, never()).postCommit();
+  }
+
+  @Test
+  public void normalRetry_thenNoTransparentRetry_andNoMoreRetry() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    InOrder inOrder = inOrder(
+        retriableStreamRecorder,
+        mockStream1, mockStream2, mockStream3);
+
+    // start
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    retriableStream.start(masterListener);
+
+    inOrder.verify(retriableStreamRecorder).newSubstream(0);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // normal retry
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+    sublistenerCaptor1.getValue()
+        .closed(Status.fromCode(RETRIABLE_STATUS_CODE_1), PROCESSED, new Metadata());
+
+    assertEquals(1, fakeClock.numPendingTasks());
+    fakeClock.forwardTime(calculateBackoffWithRetries(0), TimeUnit.SECONDS);
+    inOrder.verify(retriableStreamRecorder).newSubstream(1);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+    verify(retriableStreamRecorder, never()).postCommit();
+    assertEquals(0, fakeClock.numPendingTasks());
+
+    // no more transparent retry
+    doReturn(mockStream3).when(retriableStreamRecorder).newSubstream(2);
+    sublistenerCaptor2.getValue()
+        .closed(Status.fromCode(NON_RETRIABLE_STATUS_CODE), REFUSED, new Metadata());
+
+    verify(retriableStreamRecorder).postCommit();
+  }
+
+  @Test
+  public void noRetry_transparentRetry_noEarlyCommit() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    InOrder inOrder = inOrder(retriableStreamRecorder, mockStream1, mockStream2);
+    RetriableStream<String> unretriableStream = new RecordedRetriableStream(
+        method, new Metadata(), channelBufferUsed, PER_RPC_BUFFER_LIMIT, CHANNEL_BUFFER_LIMIT,
+        MoreExecutors.directExecutor(), fakeClock.getScheduledExecutorService(),
+        null, null, null);
+
+    // start
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    unretriableStream.start(masterListener);
+
+    inOrder.verify(retriableStreamRecorder).newSubstream(0);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // transparent retry
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(0);
+    sublistenerCaptor1.getValue()
+        .closed(Status.fromCode(NON_RETRIABLE_STATUS_CODE), REFUSED, new Metadata());
+
+    inOrder.verify(retriableStreamRecorder).newSubstream(0);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(retriableStreamRecorder, never()).postCommit();
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+    assertEquals(0, fakeClock.numPendingTasks());
+  }
+
+  @Test
+  public void droppedShouldNeverRetry() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+
+    // start
+    retriableStream.start(masterListener);
+
+    verify(retriableStreamRecorder).newSubstream(0);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+    verify(mockStream1).isReady();
+
+    // drop and verify no retry
+    Status status = Status.fromCode(RETRIABLE_STATUS_CODE_1);
+    sublistenerCaptor1.getValue().closed(status, DROPPED, new Metadata());
+
+    verifyNoMoreInteractions(mockStream1, mockStream2);
+    verify(retriableStreamRecorder).postCommit();
+    verify(masterListener).closed(same(status), any(RpcProgress.class), any(Metadata.class));
+  }
+
+
+  @Test
+  public void hedging_everythingDrained_oneHedgeReceivesNonFatal_oneHedgeReceivesFatalStatus() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    ClientStream mockStream4 = mock(ClientStream.class);
+    ClientStream[] mockStreams =
+        new ClientStream[]{mockStream1, mockStream2, mockStream3, mockStream4};
+
+    for (int i = 0; i < mockStreams.length; i++) {
+      doReturn(mockStreams[i]).when(retriableStreamRecorder).newSubstream(i);
+      final int fakePort = 80 + i;
+      doAnswer(new Answer<Void>() {
+          @Override
+          public Void answer(InvocationOnMock in) {
+            InsightBuilder insight = (InsightBuilder) in.getArguments()[0];
+            insight.appendKeyValue("remote_addr", "2.2.2.2:" + fakePort);
+            return null;
+          }
+        }).when(mockStreams[i]).appendTimeoutInsight(any(InsightBuilder.class));
+    }
+
+    InOrder inOrder = inOrder(
+        retriableStreamRecorder,
+        masterListener,
+        mockStream1, mockStream2, mockStream3, mockStream4);
+
+    // stream settings before start
+    hedgingStream.setAuthority(AUTHORITY);
+    hedgingStream.setCompressor(COMPRESSOR);
+    hedgingStream.setDecompressorRegistry(DECOMPRESSOR_REGISTRY);
+    hedgingStream.setFullStreamDecompression(false);
+    hedgingStream.setFullStreamDecompression(true);
+    hedgingStream.setMaxInboundMessageSize(MAX_INBOUND_MESSAGE_SIZE);
+    hedgingStream.setMessageCompression(true);
+    hedgingStream.setMaxOutboundMessageSize(MAX_OUTBOUND_MESSAGE_SIZE);
+    hedgingStream.setMessageCompression(false);
+
+    inOrder.verifyNoMoreInteractions();
+
+    // start
+    hedgingStream.start(masterListener);
+    assertEquals(1, fakeClock.numPendingTasks());
+
+    inOrder.verify(retriableStreamRecorder).prestart();
+    inOrder.verify(retriableStreamRecorder).newSubstream(0);
+
+    inOrder.verify(mockStream1).setAuthority(AUTHORITY);
+    inOrder.verify(mockStream1).setCompressor(COMPRESSOR);
+    inOrder.verify(mockStream1).setDecompressorRegistry(DECOMPRESSOR_REGISTRY);
+    inOrder.verify(mockStream1).setFullStreamDecompression(false);
+    inOrder.verify(mockStream1).setFullStreamDecompression(true);
+    inOrder.verify(mockStream1).setMaxInboundMessageSize(MAX_INBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream1).setMessageCompression(true);
+    inOrder.verify(mockStream1).setMaxOutboundMessageSize(MAX_OUTBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream1).setMessageCompression(false);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    hedgingStream.sendMessage("msg1");
+    hedgingStream.sendMessage("msg2");
+    hedgingStream.request(345);
+    hedgingStream.flush();
+    hedgingStream.flush();
+    hedgingStream.sendMessage("msg3");
+    hedgingStream.request(456);
+
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream1).flush(); // Memory leak workaround
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream1).flush(); // Memory leak workaround
+    inOrder.verify(mockStream1).request(345);
+    inOrder.verify(mockStream1, times(2)).flush();
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream1).flush(); // Memory leak workaround
+    inOrder.verify(mockStream1).request(456);
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS - 1, TimeUnit.SECONDS);
+    inOrder.verifyNoMoreInteractions();
+    // hedge2 starts
+    fakeClock.forwardTime(1, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    inOrder.verify(retriableStreamRecorder).newSubstream(1);
+    inOrder.verify(mockStream2).setAuthority(AUTHORITY);
+    inOrder.verify(mockStream2).setCompressor(COMPRESSOR);
+    inOrder.verify(mockStream2).setDecompressorRegistry(DECOMPRESSOR_REGISTRY);
+    inOrder.verify(mockStream2).setFullStreamDecompression(false);
+    inOrder.verify(mockStream2).setFullStreamDecompression(true);
+    inOrder.verify(mockStream2).setMaxInboundMessageSize(MAX_INBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream2).setMessageCompression(true);
+    inOrder.verify(mockStream2).setMaxOutboundMessageSize(MAX_OUTBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream2).setMessageCompression(false);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+    inOrder.verify(mockStream2).request(345);
+    inOrder.verify(mockStream2, times(2)).flush();
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+    inOrder.verify(mockStream2).request(456);
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // send more messages
+    hedgingStream.sendMessage("msg1 after hedge2 starts");
+    hedgingStream.sendMessage("msg2 after hedge2 starts");
+
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream1).flush(); // Memory leak workaround
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream1).flush(); // Memory leak workaround
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+    inOrder.verifyNoMoreInteractions();
+
+
+    // hedge3 starts
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+
+    inOrder.verify(retriableStreamRecorder).newSubstream(2);
+    inOrder.verify(mockStream3).setAuthority(AUTHORITY);
+    inOrder.verify(mockStream3).setCompressor(COMPRESSOR);
+    inOrder.verify(mockStream3).setDecompressorRegistry(DECOMPRESSOR_REGISTRY);
+    inOrder.verify(mockStream3).setFullStreamDecompression(false);
+    inOrder.verify(mockStream3).setFullStreamDecompression(true);
+    inOrder.verify(mockStream3).setMaxInboundMessageSize(MAX_INBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream3).setMessageCompression(true);
+    inOrder.verify(mockStream3).setMaxOutboundMessageSize(MAX_OUTBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream3).setMessageCompression(false);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
+    inOrder.verify(mockStream3).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream3).flush(); // Memory leak workaround
+    inOrder.verify(mockStream3).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream3).flush(); // Memory leak workaround
+    inOrder.verify(mockStream3).request(345);
+    inOrder.verify(mockStream3, times(2)).flush();
+    inOrder.verify(mockStream3).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream3).flush(); // Memory leak workaround
+    inOrder.verify(mockStream3).request(456);
+    inOrder.verify(mockStream3).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream3).flush(); // Memory leak workaround
+    inOrder.verify(mockStream3).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream3).flush(); // Memory leak workaround
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verify(mockStream3).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // send one more message
+    hedgingStream.sendMessage("msg1 after hedge3 starts");
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream1).flush(); // Memory leak workaround
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+    inOrder.verify(mockStream3).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream3).flush(); // Memory leak workaround
+
+    // hedge3 receives nonFatalStatus
+    sublistenerCaptor3.getValue().closed(
+        NON_FATAL_STATUS_CODE_1.toStatus(), PROCESSED, new Metadata());
+    inOrder.verifyNoMoreInteractions();
+
+    // send one more message
+    hedgingStream.sendMessage("msg1 after hedge3 fails");
+    inOrder.verify(mockStream1).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream1).flush(); // Memory leak workaround
+    inOrder.verify(mockStream2).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream2).flush(); // Memory leak workaround
+
+    // the hedge mockStream4 starts
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+
+    inOrder.verify(retriableStreamRecorder).newSubstream(3);
+    inOrder.verify(mockStream4).setAuthority(AUTHORITY);
+    inOrder.verify(mockStream4).setCompressor(COMPRESSOR);
+    inOrder.verify(mockStream4).setDecompressorRegistry(DECOMPRESSOR_REGISTRY);
+    inOrder.verify(mockStream4).setFullStreamDecompression(false);
+    inOrder.verify(mockStream4).setFullStreamDecompression(true);
+    inOrder.verify(mockStream4).setMaxInboundMessageSize(MAX_INBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream4).setMessageCompression(true);
+    inOrder.verify(mockStream4).setMaxOutboundMessageSize(MAX_OUTBOUND_MESSAGE_SIZE);
+    inOrder.verify(mockStream4).setMessageCompression(false);
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor4 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream4).start(sublistenerCaptor4.capture());
+    inOrder.verify(mockStream4).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream4).flush(); // Memory leak workaround
+    inOrder.verify(mockStream4).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream4).flush(); // Memory leak workaround
+    inOrder.verify(mockStream4).request(345);
+    inOrder.verify(mockStream4, times(2)).flush();
+    inOrder.verify(mockStream4).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream4).flush(); // Memory leak workaround
+    inOrder.verify(mockStream4).request(456);
+    for (int i = 0; i < 4; i++) {
+      inOrder.verify(mockStream4).writeMessage(any(InputStream.class));
+      inOrder.verify(mockStream4).flush(); // Memory leak workaround
+    }
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verify(mockStream4).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    InsightBuilder insight = new InsightBuilder();
+    hedgingStream.appendTimeoutInsight(insight);
+    assertThat(insight.toString()).isEqualTo(
+        "[closed=[UNAVAILABLE], "
+        + "open=[[remote_addr=2.2.2.2:80], [remote_addr=2.2.2.2:81], [remote_addr=2.2.2.2:83]]]");
+
+    // commit
+    sublistenerCaptor2.getValue().closed(
+        Status.fromCode(FATAL_STATUS_CODE), PROCESSED, new Metadata());
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    inOrder.verify(mockStream1).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+    inOrder.verify(mockStream4).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+    inOrder.verify(retriableStreamRecorder).postCommit();
+    sublistenerCaptor1.getValue().closed(
+        Status.CANCELLED, PROCESSED, new Metadata());
+    sublistenerCaptor4.getValue().closed(
+        Status.CANCELLED, PROCESSED, new Metadata());
+    inOrder.verify(masterListener).closed(
+        any(Status.class), any(RpcProgress.class), any(Metadata.class));
+    inOrder.verifyNoMoreInteractions();
+
+    insight = new InsightBuilder();
+    hedgingStream.appendTimeoutInsight(insight);
+    assertThat(insight.toString()).isEqualTo(
+        "[closed=[UNAVAILABLE, INTERNAL, CANCELLED, CANCELLED], "
+            + "committed=[remote_addr=2.2.2.2:81]]");
+  }
+
+  @Test
+  public void hedging_maxAttempts() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    ClientStream mockStream4 = mock(ClientStream.class);
+    ClientStream mockStream5 = mock(ClientStream.class);
+    ClientStream mockStream6 = mock(ClientStream.class);
+    ClientStream mockStream7 = mock(ClientStream.class);
+    InOrder inOrder = inOrder(
+        mockStream1, mockStream2, mockStream3, mockStream4, mockStream5, mockStream6, mockStream7,
+        retriableStreamRecorder, masterListener);
+    when(retriableStreamRecorder.newSubstream(anyInt())).thenReturn(
+        mockStream1, mockStream2, mockStream3, mockStream4, mockStream5, mockStream6, mockStream7);
+
+    hedgingStream.start(masterListener);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
+    inOrder.verify(mockStream3).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor4 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream4).start(sublistenerCaptor4.capture());
+    inOrder.verify(mockStream4).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // a random one of the hedges fails
+    sublistenerCaptor2.getValue().closed(
+        NON_FATAL_STATUS_CODE_1.toStatus(), PROCESSED, new Metadata());
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor5 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream5).start(sublistenerCaptor5.capture());
+    inOrder.verify(mockStream5).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor6 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream6).start(sublistenerCaptor6.capture());
+    inOrder.verify(mockStream6).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    inOrder.verifyNoMoreInteractions();
+
+    // all but one of the hedges fail
+    sublistenerCaptor1.getValue().closed(
+        NON_FATAL_STATUS_CODE_2.toStatus(), PROCESSED, new Metadata());
+    sublistenerCaptor4.getValue().closed(
+        NON_FATAL_STATUS_CODE_2.toStatus(), PROCESSED, new Metadata());
+    sublistenerCaptor5.getValue().closed(
+        NON_FATAL_STATUS_CODE_2.toStatus(), PROCESSED, new Metadata());
+    inOrder.verifyNoMoreInteractions();
+    sublistenerCaptor6.getValue().closed(
+        NON_FATAL_STATUS_CODE_1.toStatus(), PROCESSED, new Metadata());
+    inOrder.verifyNoMoreInteractions();
+
+    hedgingStream.sendMessage("msg1 after commit");
+    inOrder.verify(mockStream3).writeMessage(any(InputStream.class));
+    inOrder.verify(mockStream3).flush(); // Memory leak workaround
+    inOrder.verifyNoMoreInteractions();
+
+    Metadata heders = new Metadata();
+    sublistenerCaptor3.getValue().headersRead(heders);
+    inOrder.verify(retriableStreamRecorder).postCommit();
+    inOrder.verify(masterListener).headersRead(heders);
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void hedging_receiveHeaders() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    InOrder inOrder = inOrder(
+        mockStream1, mockStream2, mockStream3,
+        retriableStreamRecorder, masterListener);
+    when(retriableStreamRecorder.newSubstream(anyInt())).thenReturn(
+        mockStream1, mockStream2, mockStream3);
+
+    hedgingStream.start(masterListener);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
+    inOrder.verify(mockStream3).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // a random one of the hedges receives headers
+    Metadata headers = new Metadata();
+    sublistenerCaptor2.getValue().headersRead(headers);
+
+    // all but one of the hedges get cancelled
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    inOrder.verify(mockStream1).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+    inOrder.verify(mockStream3).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+    inOrder.verify(retriableStreamRecorder).postCommit();
+    inOrder.verify(masterListener).headersRead(headers);
+    inOrder.verifyNoMoreInteractions();
+
+  }
+
+  @Test
+  public void hedging_pushback_negative() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    ClientStream mockStream4 = mock(ClientStream.class);
+    InOrder inOrder = inOrder(
+        mockStream1, mockStream2, mockStream3, mockStream4,
+        retriableStreamRecorder, masterListener);
+    when(retriableStreamRecorder.newSubstream(anyInt())).thenReturn(
+        mockStream1, mockStream2, mockStream3, mockStream4);
+
+    hedgingStream.start(masterListener);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
+    inOrder.verify(mockStream3).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // a random one of the hedges receives a negative pushback
+    Metadata headers = new Metadata();
+    headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "-1");
+    sublistenerCaptor2.getValue().closed(
+        Status.fromCode(NON_FATAL_STATUS_CODE_1), PROCESSED, headers);
+    assertEquals(0, fakeClock.numPendingTasks());
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(0, fakeClock.numPendingTasks());
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  // This is for hedging deadlock when multiple in-flight streams races when transports call back,
+  // particularly for OkHttp:
+  // e.g. stream1 subListener gets closed() and in turn creates another stream. This ends up with
+  // transport1 thread lock is held while waiting for transport2 lock for creating a new stream.
+  // Stream2 subListener gets headersRead() and then try to commit and cancel all other drained
+  // streams, including the ones that is on transport1. This causes transport2 thread lock held
+  // while waiting for transport1 (cancel stream requires lock). Thus deadlock.
+  // Deadlock could also happen when two streams both gets headerRead() at the same time.
+  // It is believed that retry does not have the issue because streams are created sequentially.
+  @Test(timeout = 15000)
+  public void hedging_deadlock() throws Exception {
+    ClientStream mockStream1 = mock(ClientStream.class); //on transport1
+    ClientStream mockStream2 = mock(ClientStream.class); //on transport2
+    ClientStream mockStream3 = mock(ClientStream.class); //on transport2
+    ClientStream mockStream4 = mock(ClientStream.class); //on transport1
+
+    ReentrantLock transport1Lock = new ReentrantLock();
+    ReentrantLock transport2Lock = new ReentrantLock();
+    InOrder inOrder = inOrder(
+        mockStream1, mockStream2, mockStream3,
+        retriableStreamRecorder, masterListener);
+    when(retriableStreamRecorder.newSubstream(anyInt()))
+        .thenReturn(mockStream1)
+        .thenReturn(mockStream2)
+        .thenReturn(mockStream3)
+        .thenAnswer(new Answer<ClientStream>() {
+
+          @Override
+          public ClientStream answer(InvocationOnMock invocation) throws Throwable {
+            transport1Lock.lock();
+            return mockStream4;
+          }
+        });
+
+    hedgingStream = newThrottledHedgingStream(null, fakeClock.getScheduledExecutorService());
+    hedgingStream.start(masterListener);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
+    inOrder.verify(mockStream3).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    doAnswer(new Answer<Void>() {
+      @Override
+      @SuppressWarnings("LockNotBeforeTry")
+      public Void answer(InvocationOnMock invocation) throws Throwable {
+        transport2Lock.lock();
+        transport2Lock.unlock();
+        return null;
+      }
+    }).when(mockStream3).cancel(any(Status.class));
+
+    doAnswer(new Answer<Void>() {
+      @Override
+      @SuppressWarnings("LockNotBeforeTry")
+      public Void answer(InvocationOnMock invocation) throws Throwable {
+        transport2Lock.lock();
+        transport2Lock.unlock();
+        return null;
+      }
+    }).when(mockStream2).cancel(any(Status.class));
+
+    CountDownLatch latch = new CountDownLatch(1);
+    Thread transport1Activity = new Thread(new Runnable() {
+      @Override
+      public void run() {
+        transport1Lock.lock();
+        try {
+          sublistenerCaptor1.getValue().headersRead(new Metadata());
+          latch.countDown();
+        } finally {
+          transport1Lock.unlock();
+        }
+      }
+    }, "Thread-transport1");
+    transport1Activity.start();
+    Thread transport2Activity = new Thread(new Runnable() {
+      @Override
+      public void run() {
+        transport2Lock.lock();
+        try {
+          sublistenerCaptor2.getValue()
+              .closed(Status.fromCode(NON_FATAL_STATUS_CODE_1), REFUSED, new Metadata());
+        } finally {
+          transport2Lock.unlock();
+          transport1Lock.unlock();
+        }
+      }
+    }, "Thread-transport2");
+    transport2Activity.start();
+    latch.await();
+    fakeClock.runDueTasks();
+    transport2Activity.join();
+    transport1Activity.join();
+  }
+
+  @Test
+  public void hedging_pushback_positive() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    ClientStream mockStream4 = mock(ClientStream.class);
+    InOrder inOrder = inOrder(
+        mockStream1, mockStream2, mockStream3, mockStream4,
+        retriableStreamRecorder, masterListener);
+    when(retriableStreamRecorder.newSubstream(anyInt())).thenReturn(
+        mockStream1, mockStream2, mockStream3, mockStream4);
+
+    hedgingStream.start(masterListener);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+
+    // hedge1 receives a pushback for HEDGING_DELAY_IN_SECONDS + 1 second
+    Metadata headers = new Metadata();
+    headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "101000");
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(NON_FATAL_STATUS_CODE_1), PROCESSED, headers);
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    inOrder.verify(retriableStreamRecorder).newSubstream(anyInt());
+
+    fakeClock.forwardTime(1, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream3).start(sublistenerCaptor3.capture());
+    inOrder.verify(mockStream3).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // hedge2 receives a pushback for HEDGING_DELAY_IN_SECONDS - 1 second
+    headers = new Metadata();
+    headers.put(RetriableStream.GRPC_RETRY_PUSHBACK_MS, "99000");
+    sublistenerCaptor2.getValue().closed(
+        Status.fromCode(NON_FATAL_STATUS_CODE_1), PROCESSED, headers);
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS - 1, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor4 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream4).start(sublistenerCaptor4.capture());
+    inOrder.verify(mockStream4).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    // commit
+    Status fatal = FATAL_STATUS_CODE.toStatus();
+    Metadata metadata = new Metadata();
+    sublistenerCaptor4.getValue().closed(fatal, PROCESSED, metadata);
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    inOrder.verify(mockStream3).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+    inOrder.verify(retriableStreamRecorder).postCommit();
+    sublistenerCaptor3.getValue().closed(Status.CANCELLED, PROCESSED, metadata);
+    inOrder.verify(masterListener).closed(fatal, PROCESSED, metadata);
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void hedging_cancelled() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    InOrder inOrder = inOrder(
+        mockStream1, mockStream2,
+        retriableStreamRecorder, masterListener);
+    when(retriableStreamRecorder.newSubstream(anyInt())).thenReturn(mockStream1, mockStream2);
+
+    hedgingStream.start(masterListener);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream1).start(sublistenerCaptor1.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    assertEquals(1, fakeClock.numPendingTasks());
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    inOrder.verify(mockStream2).start(sublistenerCaptor2.capture());
+    inOrder.verify(mockStream1).isReady();
+    inOrder.verify(mockStream2).isReady();
+    inOrder.verifyNoMoreInteractions();
+
+    Status status = Status.CANCELLED.withDescription("cancelled");
+    hedgingStream.cancel(status);
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    inOrder.verify(mockStream1).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+    inOrder.verify(mockStream2).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+
+    inOrder.verify(retriableStreamRecorder).postCommit();
+    sublistenerCaptor1.getValue().closed(Status.CANCELLED, PROCESSED, new Metadata());
+    sublistenerCaptor2.getValue().closed(Status.CANCELLED, PROCESSED, new Metadata());
+    inOrder.verify(masterListener).closed(
+        any(Status.class), any(RpcProgress.class), any(Metadata.class));
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void hedging_perRpcBufferLimitExceeded() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+
+    hedgingStream.start(masterListener);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+    verify(mockStream1).isReady();
+
+    ClientStreamTracer bufferSizeTracer1 = bufferSizeTracer;
+    bufferSizeTracer1.outboundWireSize(PER_RPC_BUFFER_LIMIT - 1);
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream2).start(sublistenerCaptor2.capture());
+    verify(mockStream1, times(2)).isReady();
+    verify(mockStream2).isReady();
+
+    ClientStreamTracer bufferSizeTracer2 = bufferSizeTracer;
+    bufferSizeTracer2.outboundWireSize(PER_RPC_BUFFER_LIMIT - 1);
+
+    verify(retriableStreamRecorder, never()).postCommit();
+
+    // bufferLimitExceeded
+    bufferSizeTracer2.outboundWireSize(2);
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockStream1).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+    verify(retriableStreamRecorder).postCommit();
+
+    verifyNoMoreInteractions(mockStream1);
+    verify(mockStream2).isReady();
+    verifyNoMoreInteractions(mockStream2);
+  }
+
+  @Test
+  public void hedging_channelBufferLimitExceeded() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    doReturn(mockStream1).when(retriableStreamRecorder).newSubstream(0);
+    doReturn(mockStream2).when(retriableStreamRecorder).newSubstream(1);
+
+    hedgingStream.start(masterListener);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+    verify(mockStream1).isReady();
+
+    ClientStreamTracer bufferSizeTracer1 = bufferSizeTracer;
+    bufferSizeTracer1.outboundWireSize(100);
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream2).start(sublistenerCaptor2.capture());
+    verify(mockStream1, times(2)).isReady();
+    verify(mockStream2).isReady();
+
+    ClientStreamTracer bufferSizeTracer2 = bufferSizeTracer;
+    bufferSizeTracer2.outboundWireSize(100);
+
+    verify(retriableStreamRecorder, never()).postCommit();
+
+    //  channel bufferLimitExceeded
+    channelBufferUsed.addAndGet(CHANNEL_BUFFER_LIMIT - 200);
+    bufferSizeTracer2.outboundWireSize(101);
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockStream1).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+    verify(retriableStreamRecorder).postCommit();
+    verifyNoMoreInteractions(mockStream1);
+    verifyNoMoreInteractions(mockStream2);
+    // verify channel buffer is adjusted
+    assertEquals(CHANNEL_BUFFER_LIMIT - 200, channelBufferUsed.addAndGet(0));
+  }
+
+  @Test
+  public void hedging_transparentRetry() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    ClientStream mockStream4 = mock(ClientStream.class);
+    when(retriableStreamRecorder.newSubstream(anyInt()))
+        .thenReturn(mockStream1, mockStream2, mockStream3, mockStream4);
+
+    hedgingStream.start(masterListener);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream2).start(sublistenerCaptor2.capture());
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream3).start(sublistenerCaptor3.capture());
+
+    // transparent retry for hedge2
+    sublistenerCaptor2.getValue()
+        .closed(Status.fromCode(FATAL_STATUS_CODE), REFUSED, new Metadata());
+
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor4 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream4).start(sublistenerCaptor4.capture());
+    assertEquals(1, fakeClock.numPendingTasks());
+
+    // no more transparent retry
+    Status status = Status.fromCode(FATAL_STATUS_CODE);
+    Metadata metadata = new Metadata();
+    sublistenerCaptor3.getValue().closed(status, REFUSED, metadata);
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockStream1).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+    verify(mockStream4).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+    verify(retriableStreamRecorder).postCommit();
+    sublistenerCaptor1.getValue().closed(Status.CANCELLED, PROCESSED, metadata);
+    sublistenerCaptor4.getValue().closed(Status.CANCELLED, PROCESSED, metadata);
+    verify(masterListener).closed(status, REFUSED, metadata);
+  }
+
+  @Test
+  public void hedging_transparentRetryNotAllowed() {
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    when(retriableStreamRecorder.newSubstream(anyInt()))
+        .thenReturn(mockStream1, mockStream2, mockStream3);
+
+    hedgingStream.start(masterListener);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream2).start(sublistenerCaptor2.capture());
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor3 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream3).start(sublistenerCaptor3.capture());
+
+    sublistenerCaptor2.getValue()
+        .closed(Status.fromCode(NON_FATAL_STATUS_CODE_1), PROCESSED, new Metadata());
+
+    // no more transparent retry
+    Status status = Status.fromCode(FATAL_STATUS_CODE);
+    Metadata metadata = new Metadata();
+    sublistenerCaptor3.getValue()
+        .closed(status, REFUSED, metadata);
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(mockStream1).cancel(statusCaptor.capture());
+    assertEquals(Status.CANCELLED.getCode(), statusCaptor.getValue().getCode());
+    assertEquals(CANCELLED_BECAUSE_COMMITTED, statusCaptor.getValue().getDescription());
+    verify(retriableStreamRecorder).postCommit();
+    sublistenerCaptor1.getValue()
+        .closed(Status.CANCELLED, REFUSED, new Metadata());
+    //master listener close should wait until all substreams are closed
+    verify(masterListener).closed(status, REFUSED, metadata);
+  }
+
+  @Test
+  public void hedging_throttledByOtherCall() {
+    Throttle throttle = new Throttle(4f, 0.8f);
+    RetriableStream<String> hedgingStream = newThrottledHedgingStream(throttle);
+
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    when(retriableStreamRecorder.newSubstream(anyInt()))
+        .thenReturn(mockStream1, mockStream2, mockStream3);
+
+    hedgingStream.start(masterListener);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    verify(mockStream2).start(any(ClientStreamListener.class));
+
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(NON_FATAL_STATUS_CODE_1), PROCESSED, new Metadata());
+    assertTrue(throttle.isAboveThreshold()); // count = 3
+
+    // mimic some other call in the channel triggers a throttle countdown
+    assertFalse(throttle.onQualifiedFailureThenCheckIsAboveThreshold()); // count = 2
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    verify(mockStream3).start(any(ClientStreamListener.class));
+    assertEquals(0, fakeClock.numPendingTasks());
+  }
+
+  @Test
+  public void hedging_throttledByHedgingStreams() {
+    Throttle throttle = new Throttle(4f, 0.8f);
+    RetriableStream<String> hedgingStream = newThrottledHedgingStream(throttle);
+
+    ClientStream mockStream1 = mock(ClientStream.class);
+    ClientStream mockStream2 = mock(ClientStream.class);
+    ClientStream mockStream3 = mock(ClientStream.class);
+    when(retriableStreamRecorder.newSubstream(anyInt()))
+        .thenReturn(mockStream1, mockStream2, mockStream3);
+
+    hedgingStream.start(masterListener);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor1 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream1).start(sublistenerCaptor1.capture());
+
+    fakeClock.forwardTime(HEDGING_DELAY_IN_SECONDS, TimeUnit.SECONDS);
+    ArgumentCaptor<ClientStreamListener> sublistenerCaptor2 =
+        ArgumentCaptor.forClass(ClientStreamListener.class);
+    verify(mockStream2).start(sublistenerCaptor2.capture());
+
+    sublistenerCaptor1.getValue().closed(
+        Status.fromCode(NON_FATAL_STATUS_CODE_1), PROCESSED, new Metadata());
+    assertTrue(throttle.isAboveThreshold()); // count = 3
+    sublistenerCaptor2.getValue().closed(
+        Status.fromCode(NON_FATAL_STATUS_CODE_1), PROCESSED, new Metadata());
+    assertFalse(throttle.isAboveThreshold()); // count = 2
+
+    verify(masterListener).closed(any(Status.class), any(RpcProgress.class), any(Metadata.class));
+    verifyNoInteractions(mockStream3);
+    assertEquals(0, fakeClock.numPendingTasks());
+  }
+
+  /**
+   * Used to stub a retriable stream as well as to record methods of the retriable stream being
+   * called.
+   */
+  private interface RetriableStreamRecorder {
+    void postCommit();
+
+    ClientStream newSubstream(int previousAttempts);
+
+    Status prestart();
+  }
+
+  private static final class FakeMessageProducer implements MessageProducer {
+    private final Iterator<InputStream> iterator;
+
+    public FakeMessageProducer(InputStream... iss) {
+      this.iterator = Arrays.asList(iss).iterator();
+    }
+
+    @Override
+    @Nullable
+    public InputStream next() {
+      if (iterator.hasNext()) {
+        return iterator.next();
+      } else {
+        return null;
+      }
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/RetryPolicyTest.java b/core/src/test/java/io/grpc/internal/RetryPolicyTest.java
new file mode 100644
index 00000000000..51d196c20bf
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/RetryPolicyTest.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2018 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.lang.Double.parseDouble;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.ImmutableSet;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status.Code;
+import io.grpc.internal.RetriableStream.Throttle;
+import io.grpc.testing.TestMethodDescriptors;
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for RetryPolicy. */
+@RunWith(JUnit4.class)
+public class RetryPolicyTest {
+
+  @Test
+  public void getRetryPolicies() throws Exception {
+    BufferedReader reader = null;
+    try {
+      reader = new BufferedReader(new InputStreamReader(RetryPolicyTest.class.getResourceAsStream(
+          "/io/grpc/internal/test_retry_service_config.json"), "UTF-8"));
+      StringBuilder sb = new StringBuilder();
+      String line;
+      while ((line = reader.readLine()) != null) {
+        sb.append(line).append('\n');
+      }
+      Object serviceConfigObj = JsonParser.parse(sb.toString());
+      assertTrue(serviceConfigObj instanceof Map);
+
+      @SuppressWarnings("unchecked")
+      Map<String, ?> serviceConfig = (Map<String, ?>) serviceConfigObj;
+
+      ManagedChannelServiceConfig channelServiceConfig =
+          ManagedChannelServiceConfig.fromServiceConfig(
+              serviceConfig,
+              /* retryEnabled= */ true,
+              /* maxRetryAttemptsLimit= */ 4,
+              /* maxHedgedAttemptsLimit= */ 3,
+              /* loadBalancingConfig= */ null);
+
+      MethodDescriptor.Builder<Void, Void> builder = TestMethodDescriptors.voidMethod().toBuilder();
+
+      MethodDescriptor<Void, Void> method = builder.setFullMethodName("not/exist").build();
+      assertThat(channelServiceConfig.getMethodConfig(method)).isNull();
+
+      method = builder.setFullMethodName("not_exist/Foo1").build();
+      assertThat(channelServiceConfig.getMethodConfig(method)).isNull();
+
+      method = builder.setFullMethodName("SimpleService1/not_exist").build();
+      assertThat(channelServiceConfig.getMethodConfig(method).retryPolicy).isEqualTo(
+          new RetryPolicy(
+              3,
+              TimeUnit.MILLISECONDS.toNanos(2100),
+              TimeUnit.MILLISECONDS.toNanos(2200),
+              parseDouble("3"),
+              null,
+              ImmutableSet.of(Code.UNAVAILABLE, Code.RESOURCE_EXHAUSTED)));
+
+      method = builder.setFullMethodName("SimpleService1/Foo1").build();
+      assertThat(channelServiceConfig.getMethodConfig(method).retryPolicy).isEqualTo(
+          new RetryPolicy(
+              4,
+              TimeUnit.MILLISECONDS.toNanos(100),
+              TimeUnit.MILLISECONDS.toNanos(1000),
+              parseDouble("2"),
+              null,
+              ImmutableSet.of(Code.UNAVAILABLE)));
+
+      method = builder.setFullMethodName("SimpleService2/not_exist").build();
+      assertThat(channelServiceConfig.getMethodConfig(method).retryPolicy).isNull();
+
+      method = builder.setFullMethodName("SimpleService2/Foo2").build();
+      assertThat(channelServiceConfig.getMethodConfig(method).retryPolicy).isEqualTo(
+          new RetryPolicy(
+              4,
+              TimeUnit.MILLISECONDS.toNanos(100),
+              TimeUnit.MILLISECONDS.toNanos(1000),
+              parseDouble("2"),
+              null,
+              ImmutableSet.of(Code.UNAVAILABLE)));
+    } finally {
+      if (reader != null) {
+        reader.close();
+      }
+    }
+  }
+
+  @Test
+  public void getRetryPolicies_retryDisabled() throws Exception {
+    BufferedReader reader = null;
+    try {
+      reader = new BufferedReader(new InputStreamReader(RetryPolicyTest.class.getResourceAsStream(
+          "/io/grpc/internal/test_retry_service_config.json"), "UTF-8"));
+      StringBuilder sb = new StringBuilder();
+      String line;
+      while ((line = reader.readLine()) != null) {
+        sb.append(line).append('\n');
+      }
+      Object serviceConfigObj = JsonParser.parse(sb.toString());
+      assertTrue(serviceConfigObj instanceof Map);
+
+      @SuppressWarnings("unchecked")
+      Map<String, ?> serviceConfig = (Map<String, ?>) serviceConfigObj;
+      ManagedChannelServiceConfig channelServiceConfig =
+          ManagedChannelServiceConfig.fromServiceConfig(
+              serviceConfig,
+              /* retryEnabled= */ false,
+              /* maxRetryAttemptsLimit= */ 4,
+              /* maxHedgedAttemptsLimit= */ 3,
+              /* loadBalancingConfig= */ null);
+      MethodDescriptor.Builder<Void, Void> builder = TestMethodDescriptors.voidMethod().toBuilder();
+      MethodDescriptor<Void, Void> method =
+          builder.setFullMethodName("SimpleService1/Foo1").build();
+      assertThat(channelServiceConfig.getMethodConfig(method).retryPolicy).isNull();
+    } finally {
+      if (reader != null) {
+        reader.close();
+      }
+    }
+  }
+
+  @Test
+  public void getThrottle() throws Exception {
+    BufferedReader reader = null;
+    try {
+      reader = new BufferedReader(new InputStreamReader(RetryPolicyTest.class.getResourceAsStream(
+          "/io/grpc/internal/test_retry_service_config.json"), "UTF-8"));
+      StringBuilder sb = new StringBuilder();
+      String line;
+      while ((line = reader.readLine()) != null) {
+        sb.append(line).append('\n');
+      }
+      Object serviceConfigObj = JsonParser.parse(sb.toString());
+      assertTrue(serviceConfigObj instanceof Map);
+
+      @SuppressWarnings("unchecked")
+      Map<String, ?> serviceConfig = (Map<String, ?>) serviceConfigObj;
+      Throttle throttle = ServiceConfigUtil.getThrottlePolicy(serviceConfig);
+
+      assertEquals(new Throttle(10f, 0.1f), throttle);
+    } finally {
+      if (reader != null) {
+        reader.close();
+      }
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/RetryingNameResolverTest.java b/core/src/test/java/io/grpc/internal/RetryingNameResolverTest.java
new file mode 100644
index 00000000000..1da93f05fe2
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/RetryingNameResolverTest.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2023 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.Listener2;
+import io.grpc.NameResolver.ResolutionResult;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import java.lang.Thread.UncaughtExceptionHandler;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Unit test for {@link RetryingNameResolver}.
+ */
+@RunWith(JUnit4.class)
+public class RetryingNameResolverTest {
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock
+  private NameResolver mockNameResolver;
+  @Mock
+  private Listener2 mockListener;
+  @Mock
+  private RetryScheduler mockRetryScheduler;
+  @Captor
+  private ArgumentCaptor<Listener2> listenerCaptor;
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      mock(UncaughtExceptionHandler.class));
+
+  private RetryingNameResolver retryingNameResolver;
+
+  @Before
+  public void setup() {
+    retryingNameResolver = new RetryingNameResolver(mockNameResolver, mockRetryScheduler,
+        syncContext);
+  }
+
+  @Test
+  public void startAndShutdown() {
+    retryingNameResolver.start(mockListener);
+    retryingNameResolver.shutdown();
+  }
+
+  @Test
+  public void onResult_success() {
+    when(mockListener.onResult2(isA(ResolutionResult.class))).thenReturn(Status.OK);
+    retryingNameResolver.start(mockListener);
+    verify(mockNameResolver).start(listenerCaptor.capture());
+
+    listenerCaptor.getValue().onResult(ResolutionResult.newBuilder().build());
+
+    verify(mockRetryScheduler).reset();
+  }
+
+  @Test
+  public void onResult2_sucesss() {
+    when(mockListener.onResult2(isA(ResolutionResult.class))).thenReturn(Status.OK);
+    retryingNameResolver.start(mockListener);
+    verify(mockNameResolver).start(listenerCaptor.capture());
+
+    assertThat(listenerCaptor.getValue().onResult2(ResolutionResult.newBuilder().build()))
+        .isEqualTo(Status.OK);
+
+    verify(mockRetryScheduler).reset();
+  }
+
+  // Make sure that a retry gets scheduled when the resolution results are rejected.
+  @Test
+  public void onResult_failure() {
+    when(mockListener.onResult2(isA(ResolutionResult.class))).thenReturn(Status.UNAVAILABLE);
+    retryingNameResolver.start(mockListener);
+    verify(mockNameResolver).start(listenerCaptor.capture());
+
+    listenerCaptor.getValue().onResult(ResolutionResult.newBuilder().build());
+
+    verify(mockRetryScheduler).schedule(isA(Runnable.class));
+  }
+
+  // Make sure that a retry gets scheduled when the resolution results are rejected.
+  @Test
+  public void onResult2_failure() {
+    when(mockListener.onResult2(isA(ResolutionResult.class))).thenReturn(Status.UNAVAILABLE);
+    retryingNameResolver.start(mockListener);
+    verify(mockNameResolver).start(listenerCaptor.capture());
+
+    assertThat(listenerCaptor.getValue().onResult2(ResolutionResult.newBuilder().build()))
+        .isEqualTo(Status.UNAVAILABLE);
+
+    verify(mockRetryScheduler).schedule(isA(Runnable.class));
+  }
+
+  // A retry should get scheduled when name resolution fails.
+  @Test
+  public void onError() {
+    retryingNameResolver.start(mockListener);
+    verify(mockNameResolver).start(listenerCaptor.capture());
+    listenerCaptor.getValue().onError(Status.DEADLINE_EXCEEDED);
+    verify(mockListener).onError(Status.DEADLINE_EXCEEDED);
+    verify(mockRetryScheduler).schedule(isA(Runnable.class));
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/SerializeReentrantCallsDirectExecutorTest.java b/core/src/test/java/io/grpc/internal/SerializeReentrantCallsDirectExecutorTest.java
index 2da64552697..493f79c4b4c 100644
--- a/core/src/test/java/io/grpc/internal/SerializeReentrantCallsDirectExecutorTest.java
+++ b/core/src/test/java/io/grpc/internal/SerializeReentrantCallsDirectExecutorTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -55,7 +40,7 @@ public void setup() {
   }
 
   @Test public void reentrantCallsShouldBeSerialized() {
-    final List<Integer> callOrder = new ArrayList<Integer>(4);
+    final List<Integer> callOrder = new ArrayList<>(4);
     executor.execute(new Runnable() {
       @Override
       public void run() {
@@ -120,7 +105,7 @@ public void executingNullShouldFail() {
 
   @Test
   public void executeCanBeRepeated() {
-    final List<Integer> executes = new ArrayList<Integer>();
+    final List<Integer> executes = new ArrayList<>();
     executor.execute(new Runnable() {
       @Override
       public void run() {
diff --git a/core/src/test/java/io/grpc/internal/SerializingExecutorTest.java b/core/src/test/java/io/grpc/internal/SerializingExecutorTest.java
new file mode 100644
index 00000000000..a1a8146b7bb
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/SerializingExecutorTest.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright 2017 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Executor;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class SerializingExecutorTest {
+  private SingleExecutor singleExecutor = new SingleExecutor();
+  private SerializingExecutor executor = new SerializingExecutor(singleExecutor);
+  private List<Integer> runs = new ArrayList<>();
+
+  private class AddToRuns implements Runnable {
+    private final int val;
+
+    public AddToRuns(int val) {
+      this.val = val;
+    }
+
+    @Override
+    public void run() {
+      runs.add(val);
+    }
+  }
+
+  @Test
+  public void resumable() {
+    class CoyExecutor implements Executor {
+      int runCount;
+
+      @Override
+      public void execute(Runnable command) {
+        runCount++;
+        if (runCount == 1) {
+          throw new RuntimeException();
+        }
+        command.run();
+      }
+    }
+
+    executor = new SerializingExecutor(new CoyExecutor());
+    try {
+      executor.execute(new AddToRuns(1));
+      fail();
+    } catch (RuntimeException expected) {
+    }
+
+    // Ensure that the runnable enqueued was actually removed on the failed execute above.
+    executor.execute(new AddToRuns(2));
+
+    assertThat(runs).containsExactly(2);
+  }
+
+
+  @Test
+  public void serial() {
+    executor.execute(new AddToRuns(1));
+    assertEquals(Collections.<Integer>emptyList(), runs);
+    singleExecutor.drain();
+    assertEquals(Arrays.asList(1), runs);
+
+    executor.execute(new AddToRuns(2));
+    assertEquals(Arrays.asList(1), runs);
+    singleExecutor.drain();
+    assertEquals(Arrays.asList(1, 2), runs);
+  }
+
+  @Test
+  public void parallel() {
+    executor.execute(new AddToRuns(1));
+    executor.execute(new AddToRuns(2));
+    executor.execute(new AddToRuns(3));
+    assertEquals(Collections.<Integer>emptyList(), runs);
+    singleExecutor.drain();
+    assertEquals(Arrays.asList(1, 2, 3), runs);
+  }
+
+  @Test
+  public void reentrant() {
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        executor.execute(new AddToRuns(3));
+        runs.add(1);
+      }
+    });
+    executor.execute(new AddToRuns(2));
+    singleExecutor.drain();
+    assertEquals(Arrays.asList(1, 2, 3), runs);
+  }
+
+  @Test
+  public void testFirstRunnableThrows() {
+    final RuntimeException ex = new RuntimeException();
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        runs.add(1);
+        throw ex;
+      }
+    });
+    executor.execute(new AddToRuns(2));
+    executor.execute(new AddToRuns(3));
+
+    singleExecutor.drain();
+
+    assertEquals(Arrays.asList(1, 2, 3), runs);
+  }
+
+  @Test
+  public void lastRunnableThrows() {
+    final RuntimeException ex = new RuntimeException();
+    executor.execute(new AddToRuns(1));
+    executor.execute(new AddToRuns(2));
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        runs.add(3);
+        throw ex;
+      }
+    });
+
+    singleExecutor.drain();
+    assertEquals(Arrays.asList(1, 2, 3), runs);
+
+    // Scheduling more still works
+    executor.execute(new AddToRuns(4));
+    assertEquals(Arrays.asList(1, 2, 3), runs);
+    singleExecutor.drain();
+    assertEquals(Arrays.asList(1, 2, 3, 4), runs);
+  }
+
+  @Test
+  public void firstExecuteThrows() {
+    final RuntimeException ex = new RuntimeException();
+    ForwardingExecutor forwardingExecutor = new ForwardingExecutor(new Executor() {
+      @Override
+      public void execute(Runnable r) {
+        throw ex;
+      }
+    });
+    executor = new SerializingExecutor(forwardingExecutor);
+    try {
+      executor.execute(new AddToRuns(1));
+      fail("expected exception");
+    } catch (RuntimeException e) {
+      assertSame(ex, e);
+    }
+    assertEquals(Collections.<Integer>emptyList(), runs);
+
+    forwardingExecutor.executor = singleExecutor;
+    executor.execute(new AddToRuns(2));
+    executor.execute(new AddToRuns(3));
+    assertEquals(Collections.<Integer>emptyList(), runs);
+    singleExecutor.drain();
+    assertEquals(Arrays.asList(2, 3), runs);
+  }
+
+  @Test
+  public void direct() {
+    executor = new SerializingExecutor(MoreExecutors.directExecutor());
+    executor.execute(new AddToRuns(1));
+    assertEquals(Arrays.asList(1), runs);
+    executor.execute(new AddToRuns(2));
+    assertEquals(Arrays.asList(1, 2), runs);
+    executor.execute(new AddToRuns(3));
+    assertEquals(Arrays.asList(1, 2, 3), runs);
+  }
+
+  @Test
+  public void testDirectReentrant() {
+    executor = new SerializingExecutor(MoreExecutors.directExecutor());
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        executor.execute(new AddToRuns(2));
+        runs.add(1);
+      }
+    });
+    assertEquals(Arrays.asList(1, 2), runs);
+    executor.execute(new AddToRuns(3));
+    assertEquals(Arrays.asList(1, 2, 3), runs);
+  }
+
+  @Test
+  public void switchable() {
+    final SerializingExecutor testExecutor =
+            new SerializingExecutor(MoreExecutors.directExecutor());
+    testExecutor.execute(new Runnable() {
+      @Override
+      public void run() {
+        runs.add(1);
+        testExecutor.setExecutor(singleExecutor);
+      }
+    });
+    testExecutor.execute(new AddToRuns(-2));
+    assertThat(runs).isEqualTo(Arrays.asList(1));
+    singleExecutor.drain();
+    assertThat(runs).isEqualTo(Arrays.asList(1, -2));
+  }
+
+  @Test
+  public void notSwitch() {
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        runs.add(1);
+        executor.setExecutor(singleExecutor);
+      }
+    });
+    executor.execute(new AddToRuns(-2));
+    assertThat(runs).isEqualTo(Collections.emptyList());
+    singleExecutor.drain();
+    assertThat(runs).isEqualTo(Arrays.asList(1, -2));
+  }
+
+  private static class SingleExecutor implements Executor {
+    private Runnable runnable;
+
+    @Override
+    public void execute(Runnable r) {
+      if (runnable != null) {
+        fail("Already have runnable scheduled");
+      }
+      runnable = r;
+    }
+
+    public void drain() {
+      if (runnable != null) {
+        Runnable r = runnable;
+        runnable = null;
+        r.run();
+      }
+    }
+  }
+
+  private static class ForwardingExecutor implements Executor {
+    Executor executor;
+
+    public ForwardingExecutor(Executor executor) {
+      this.executor = executor;
+    }
+
+    @Override
+    public void execute(Runnable r) {
+      executor.execute(r);
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ServerCallImplTest.java b/core/src/test/java/io/grpc/internal/ServerCallImplTest.java
index 4a7acdc2504..7394c83eab2 100644
--- a/core/src/test/java/io/grpc/internal/ServerCallImplTest.java
+++ b/core/src/test/java/io/grpc/internal/ServerCallImplTest.java
@@ -1,107 +1,142 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
-import static com.google.common.base.Charsets.UTF_8;
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.internal.GrpcUtil.CONTENT_LENGTH_KEY;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.isA;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import com.google.common.io.CharStreams;
-import com.google.instrumentation.stats.RpcConstants;
-import com.google.instrumentation.stats.TagValue;
+import io.grpc.Attributes;
 import io.grpc.CompressorRegistry;
 import io.grpc.Context;
 import io.grpc.DecompressorRegistry;
+import io.grpc.InternalChannelz.ServerStats;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.Marshaller;
 import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.SecurityLevel;
 import io.grpc.ServerCall;
 import io.grpc.Status;
 import io.grpc.internal.ServerCallImpl.ServerStreamListenerImpl;
-import io.grpc.internal.testing.StatsTestUtils;
-import io.grpc.internal.testing.StatsTestUtils.FakeStatsContextFactory;
+import io.perfmark.PerfMark;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
 import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 @RunWith(JUnit4.class)
 public class ServerCallImplTest {
-  @Rule public final ExpectedException thrown = ExpectedException.none();
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
   @Mock private ServerStream stream;
   @Mock private ServerCall.Listener<Long> callListener;
-  @Captor private ArgumentCaptor<Status> statusCaptor;
 
+  private final CallTracer serverCallTracer = CallTracer.getDefaultFactory().create();
   private ServerCallImpl<Long, Long> call;
   private Context.CancellableContext context;
 
-  private final MethodDescriptor<Long, Long> method = MethodDescriptor.<Long, Long>newBuilder()
-      .setType(MethodType.UNARY)
-      .setFullMethodName("/service/method")
-      .setRequestMarshaller(new LongMarshaller())
-      .setResponseMarshaller(new LongMarshaller())
-      .build();
+  private static final MethodDescriptor<Long, Long> UNARY_METHOD =
+      MethodDescriptor.<Long, Long>newBuilder()
+          .setType(MethodType.UNARY)
+          .setFullMethodName("service/method")
+          .setRequestMarshaller(new LongMarshaller())
+          .setResponseMarshaller(new LongMarshaller())
+          .build();
+
+  private static final MethodDescriptor<Long, Long> CLIENT_STREAMING_METHOD =
+      MethodDescriptor.<Long, Long>newBuilder()
+          .setType(MethodType.UNARY)
+          .setFullMethodName("service/method")
+          .setRequestMarshaller(new LongMarshaller())
+          .setResponseMarshaller(new LongMarshaller())
+          .build();
 
   private final Metadata requestHeaders = new Metadata();
-  private final FakeStatsContextFactory statsCtxFactory = new FakeStatsContextFactory();
-  private final StatsTraceContext statsTraceCtx = StatsTraceContext.newServerContext(
-      method.getFullMethodName(), statsCtxFactory, requestHeaders, GrpcUtil.STOPWATCH_SUPPLIER);
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
     context = Context.ROOT.withCancellation();
-    call = new ServerCallImpl<Long, Long>(stream, method, requestHeaders, context,
-        statsTraceCtx, DecompressorRegistry.getDefaultInstance(),
-        CompressorRegistry.getDefaultInstance());
+    call = new ServerCallImpl<>(stream, UNARY_METHOD, requestHeaders, context,
+        DecompressorRegistry.getDefaultInstance(), CompressorRegistry.getDefaultInstance(),
+        serverCallTracer, PerfMark.createTag());
+  }
+
+  @Test
+  public void callTracer_success() {
+    callTracer0(Status.OK);
+  }
+
+  @Test
+  public void callTracer_failure() {
+    callTracer0(Status.UNKNOWN);
+  }
+
+  private void callTracer0(Status status) {
+    CallTracer tracer = CallTracer.getDefaultFactory().create();
+    ServerStats.Builder beforeBuilder = new ServerStats.Builder();
+    tracer.updateBuilder(beforeBuilder);
+    ServerStats before = beforeBuilder.build();
+    assertEquals(0, before.callsStarted);
+    assertEquals(0, before.lastCallStartedNanos);
+
+    call = new ServerCallImpl<>(stream, UNARY_METHOD, requestHeaders, context,
+        DecompressorRegistry.getDefaultInstance(), CompressorRegistry.getDefaultInstance(),
+        tracer, PerfMark.createTag());
+
+    // required boilerplate
+    call.sendHeaders(new Metadata());
+    call.sendMessage(123L);
+    // end: required boilerplate
+
+    call.close(status, new Metadata());
+    ServerStats.Builder afterBuilder = new ServerStats.Builder();
+    tracer.updateBuilder(afterBuilder);
+    ServerStats after = afterBuilder.build();
+    assertEquals(1, after.callsStarted);
+    if (status.isOk()) {
+      assertEquals(1, after.callsSucceeded);
+    } else {
+      assertEquals(1, after.callsFailed);
+    }
   }
 
   @Test
@@ -111,32 +146,48 @@ public void request() {
     verify(stream).request(10);
   }
 
+  @Test
+  public void setOnReadyThreshold() {
+    call.setOnReadyThreshold(10);
+    verify(stream).setOnReadyThreshold(10);
+  }
+
   @Test
   public void sendHeader_firstCall() {
     Metadata headers = new Metadata();
 
     call.sendHeaders(headers);
 
-    verify(stream).writeHeaders(headers);
+    verify(stream).writeHeaders(headers, false);
   }
 
   @Test
-  public void sendHeader_failsOnSecondCall() {
-    call.sendHeaders(new Metadata());
-    thrown.expect(IllegalStateException.class);
-    thrown.expectMessage("sendHeaders has already been called");
+  public void sendHeader_contentLengthDiscarded() {
+    Metadata headers = new Metadata();
+    headers.put(CONTENT_LENGTH_KEY, "123");
+    call.sendHeaders(headers);
 
+    verify(stream).writeHeaders(headers, false);
+    assertNull(headers.get(CONTENT_LENGTH_KEY));
+  }
+
+  @Test
+  public void sendHeader_failsOnSecondCall() {
     call.sendHeaders(new Metadata());
+    Metadata headers = new Metadata();
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        () -> call.sendHeaders(headers));
+    assertThat(e).hasMessageThat().isEqualTo("sendHeaders has already been called");
   }
 
   @Test
   public void sendHeader_failsOnClosed() {
     call.close(Status.CANCELLED, new Metadata());
 
-    thrown.expect(IllegalStateException.class);
-    thrown.expectMessage("call is closed");
-
-    call.sendHeaders(new Metadata());
+    Metadata headers = new Metadata();
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        () -> call.sendHeaders(headers));
+    assertThat(e).hasMessageThat().isEqualTo("call is closed");
   }
 
   @Test
@@ -145,7 +196,6 @@ public void sendMessage() {
     call.sendMessage(1234L);
 
     verify(stream).writeMessage(isA(InputStream.class));
-    verify(stream).flush();
   }
 
   @Test
@@ -153,18 +203,16 @@ public void sendMessage_failsOnClosed() {
     call.sendHeaders(new Metadata());
     call.close(Status.CANCELLED, new Metadata());
 
-    thrown.expect(IllegalStateException.class);
-    thrown.expectMessage("call is closed");
-
-    call.sendMessage(1234L);
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        () -> call.sendMessage(1234L));
+    assertThat(e).hasMessageThat().isEqualTo("call is closed");
   }
 
   @Test
   public void sendMessage_failsIfheadersUnsent() {
-    thrown.expect(IllegalStateException.class);
-    thrown.expectMessage("sendHeaders has not been called");
-
-    call.sendMessage(1234L);
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        () -> call.sendMessage(1234L));
+    assertThat(e).hasMessageThat().isEqualTo("sendHeaders has not been called");
   }
 
   @Test
@@ -172,14 +220,119 @@ public void sendMessage_closesOnFailure() {
     call.sendHeaders(new Metadata());
     doThrow(new RuntimeException("bad")).when(stream).writeMessage(isA(InputStream.class));
 
+    call.sendMessage(1234L);
+
+    verify(stream).cancel(isA(Status.class));
+  }
+
+  @Test
+  public void sendMessage_serverSendsOne_closeOnSecondCall_unary() {
+    sendMessage_serverSendsOne_closeOnSecondCall(UNARY_METHOD);
+  }
+
+  @Test
+  public void sendMessage_serverSendsOne_closeOnSecondCall_clientStreaming() {
+    sendMessage_serverSendsOne_closeOnSecondCall(CLIENT_STREAMING_METHOD);
+  }
+
+  private void sendMessage_serverSendsOne_closeOnSecondCall(
+      MethodDescriptor<Long, Long> method) {
+    ServerCallImpl<Long, Long> serverCall = new ServerCallImpl<>(
+        stream,
+        method,
+        requestHeaders,
+        context,
+        DecompressorRegistry.getDefaultInstance(),
+        CompressorRegistry.getDefaultInstance(),
+        serverCallTracer,
+        PerfMark.createTag());
+    serverCall.sendHeaders(new Metadata());
+    serverCall.sendMessage(1L);
+    verify(stream, times(1)).writeMessage(any(InputStream.class));
+    verify(stream, never()).close(any(Status.class), any(Metadata.class));
+
+    // trying to send a second message causes gRPC to close the underlying stream
+    serverCall.sendMessage(1L);
+    verify(stream, times(1)).writeMessage(any(InputStream.class));
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(stream, times(1)).cancel(statusCaptor.capture());
+    assertEquals(Status.Code.INTERNAL, statusCaptor.getValue().getCode());
+    assertEquals(ServerCallImpl.TOO_MANY_RESPONSES, statusCaptor.getValue().getDescription());
+  }
+
+  @Test
+  public void sendMessage_serverSendsOne_closeOnSecondCall_appRunToCompletion_unary() {
+    sendMessage_serverSendsOne_closeOnSecondCall_appRunToCompletion(UNARY_METHOD);
+  }
+
+  @Test
+  public void sendMessage_serverSendsOne_closeOnSecondCall_appRunToCompletion_clientStreaming() {
+    sendMessage_serverSendsOne_closeOnSecondCall_appRunToCompletion(CLIENT_STREAMING_METHOD);
+  }
+
+  private void sendMessage_serverSendsOne_closeOnSecondCall_appRunToCompletion(
+      MethodDescriptor<Long, Long> method) {
+    ServerCallImpl<Long, Long> serverCall = new ServerCallImpl<>(
+        stream,
+        method,
+        requestHeaders,
+        context,
+        DecompressorRegistry.getDefaultInstance(),
+        CompressorRegistry.getDefaultInstance(),
+        serverCallTracer,
+        PerfMark.createTag());
+    serverCall.sendHeaders(new Metadata());
+    serverCall.sendMessage(1L);
+    serverCall.sendMessage(1L);
+    verify(stream, times(1)).writeMessage(any(InputStream.class));
+    verify(stream, times(1)).cancel(any(Status.class));
+
+    // App runs to completion but everything is ignored
+    serverCall.sendMessage(1L);
+    serverCall.close(Status.OK, new Metadata());
     try {
-      call.sendMessage(1234L);
-      fail();
-    } catch (RuntimeException e) {
-      // expected
+      serverCall.close(Status.OK, new Metadata());
+      fail("calling a second time should still cause an error");
+    } catch (IllegalStateException expected) {
+      // noop
     }
+  }
+
+  @Test
+  public void serverSendsOne_okFailsOnMissingResponse_unary() {
+    serverSendsOne_okFailsOnMissingResponse(UNARY_METHOD);
+  }
+
+  @Test
+  public void serverSendsOne_okFailsOnMissingResponse_clientStreaming() {
+    serverSendsOne_okFailsOnMissingResponse(CLIENT_STREAMING_METHOD);
+  }
 
-    verify(stream).close(isA(Status.class), isA(Metadata.class));
+  private void serverSendsOne_okFailsOnMissingResponse(
+      MethodDescriptor<Long, Long> method) {
+    ServerCallImpl<Long, Long> serverCall = new ServerCallImpl<>(
+        stream,
+        method,
+        requestHeaders,
+        context,
+        DecompressorRegistry.getDefaultInstance(),
+        CompressorRegistry.getDefaultInstance(),
+        serverCallTracer,
+        PerfMark.createTag());
+    serverCall.close(Status.OK, new Metadata());
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(stream, times(1)).cancel(statusCaptor.capture());
+    assertEquals(Status.Code.INTERNAL, statusCaptor.getValue().getCode());
+    assertEquals(ServerCallImpl.MISSING_RESPONSE, statusCaptor.getValue().getDescription());
+  }
+
+  @Test
+  public void serverSendsOne_canErrorWithoutResponse() {
+    final String description = "test description";
+    final Status status = Status.RESOURCE_EXHAUSTED.withDescription(description);
+    final Metadata metadata = new Metadata();
+    call.close(status, metadata);
+    verify(stream, times(1)).close(same(status), same(metadata));
   }
 
   @Test
@@ -187,8 +340,41 @@ public void isReady() {
     when(stream.isReady()).thenReturn(true);
 
     assertTrue(call.isReady());
+    call.close(Status.OK, new Metadata());
+    assertFalse(call.isReady());
   }
 
+  @Test
+  public void getAuthority() {
+    when(stream.getAuthority()).thenReturn("fooapi.googleapis.com");
+    assertEquals("fooapi.googleapis.com", call.getAuthority());
+    verify(stream).getAuthority();
+  }
+
+  @Test
+  public void getNullAuthority() {
+    when(stream.getAuthority()).thenReturn(null);
+    assertNull(call.getAuthority());
+    verify(stream).getAuthority();
+  }
+
+  @Test
+  public void getSecurityLevel() {
+    Attributes attributes = Attributes.newBuilder()
+        .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.INTEGRITY).build();
+    when(stream.getAttributes()).thenReturn(attributes);
+    assertEquals(SecurityLevel.INTEGRITY, call.getSecurityLevel());
+    verify(stream).getAttributes();
+  }
+
+  @Test
+  public void getNullSecurityLevel() {
+    when(stream.getAttributes()).thenReturn(null);
+    assertEquals(SecurityLevel.NONE, call.getSecurityLevel());
+    verify(stream).getAttributes();
+  }
+
+
   @Test
   public void setMessageCompression() {
     call.setMessageCompression(true);
@@ -199,8 +385,7 @@ public void setMessageCompression() {
   @Test
   public void streamListener_halfClosed() {
     ServerStreamListenerImpl<Long> streamListener =
-        new ServerCallImpl.ServerStreamListenerImpl<Long>(
-            call, callListener, context, statsTraceCtx);
+        new ServerCallImpl.ServerStreamListenerImpl<>(call, callListener, context);
 
     streamListener.halfClosed();
 
@@ -210,8 +395,7 @@ public void streamListener_halfClosed() {
   @Test
   public void streamListener_halfClosed_onlyOnce() {
     ServerStreamListenerImpl<Long> streamListener =
-        new ServerCallImpl.ServerStreamListenerImpl<Long>(
-            call, callListener, context, statsTraceCtx);
+        new ServerCallImpl.ServerStreamListenerImpl<>(call, callListener, context);
     streamListener.halfClosed();
     // canceling the call should short circuit future halfClosed() calls.
     streamListener.closed(Status.CANCELLED);
@@ -224,36 +408,34 @@ public void streamListener_halfClosed_onlyOnce() {
   @Test
   public void streamListener_closedOk() {
     ServerStreamListenerImpl<Long> streamListener =
-        new ServerCallImpl.ServerStreamListenerImpl<Long>(
-            call, callListener, context, statsTraceCtx);
+        new ServerCallImpl.ServerStreamListenerImpl<>(call, callListener, context);
 
     streamListener.closed(Status.OK);
 
     verify(callListener).onComplete();
     assertTrue(context.isCancelled());
     assertNull(context.cancellationCause());
-    checkStats(Status.Code.OK);
+    // The call considers cancellation to be an exceptional situation so it should
+    // not be cancelled with an OK status.
+    assertFalse(call.isCancelled());
   }
 
   @Test
   public void streamListener_closedCancelled() {
     ServerStreamListenerImpl<Long> streamListener =
-        new ServerCallImpl.ServerStreamListenerImpl<Long>(
-            call, callListener, context, statsTraceCtx);
+        new ServerCallImpl.ServerStreamListenerImpl<>(call, callListener, context);
 
     streamListener.closed(Status.CANCELLED);
 
     verify(callListener).onCancel();
     assertTrue(context.isCancelled());
-    assertNull(context.cancellationCause());
-    checkStats(Status.Code.CANCELLED);
+    assertNotNull(context.cancellationCause());
   }
 
   @Test
   public void streamListener_onReady() {
     ServerStreamListenerImpl<Long> streamListener =
-        new ServerCallImpl.ServerStreamListenerImpl<Long>(
-            call, callListener, context, statsTraceCtx);
+        new ServerCallImpl.ServerStreamListenerImpl<>(call, callListener, context);
 
     streamListener.onReady();
 
@@ -263,8 +445,7 @@ public void streamListener_onReady() {
   @Test
   public void streamListener_onReady_onlyOnce() {
     ServerStreamListenerImpl<Long> streamListener =
-        new ServerCallImpl.ServerStreamListenerImpl<Long>(
-            call, callListener, context, statsTraceCtx);
+        new ServerCallImpl.ServerStreamListenerImpl<>(call, callListener, context);
     streamListener.onReady();
     // canceling the call should short circuit future halfClosed() calls.
     streamListener.closed(Status.CANCELLED);
@@ -277,38 +458,21 @@ public void streamListener_onReady_onlyOnce() {
   @Test
   public void streamListener_messageRead() {
     ServerStreamListenerImpl<Long> streamListener =
-        new ServerCallImpl.ServerStreamListenerImpl<Long>(
-            call, callListener, context, statsTraceCtx);
-    streamListener.messageRead(method.streamRequest(1234L));
-
-    verify(callListener).onMessage(1234L);
-  }
-
-  @Test
-  public void streamListener_messageRead_unaryFailsOnMultiple() {
-    ServerStreamListenerImpl<Long> streamListener =
-        new ServerCallImpl.ServerStreamListenerImpl<Long>(
-            call, callListener, context, statsTraceCtx);
-    streamListener.messageRead(method.streamRequest(1234L));
-    streamListener.messageRead(method.streamRequest(1234L));
+        new ServerCallImpl.ServerStreamListenerImpl<>(call, callListener, context);
+    streamListener.messagesAvailable(new SingleMessageProducer(UNARY_METHOD.streamRequest(1234L)));
 
-    // Makes sure this was only called once.
     verify(callListener).onMessage(1234L);
-
-    verify(stream).close(statusCaptor.capture(), Mockito.isA(Metadata.class));
-    assertEquals(Status.Code.INTERNAL, statusCaptor.getValue().getCode());
   }
 
   @Test
   public void streamListener_messageRead_onlyOnce() {
     ServerStreamListenerImpl<Long> streamListener =
-        new ServerCallImpl.ServerStreamListenerImpl<Long>(
-            call, callListener, context, statsTraceCtx);
-    streamListener.messageRead(method.streamRequest(1234L));
+        new ServerCallImpl.ServerStreamListenerImpl<>(call, callListener, context);
+    streamListener.messagesAvailable(new SingleMessageProducer(UNARY_METHOD.streamRequest(1234L)));
     // canceling the call should short circuit future halfClosed() calls.
     streamListener.closed(Status.CANCELLED);
 
-    streamListener.messageRead(method.streamRequest(1234L));
+    streamListener.messagesAvailable(new SingleMessageProducer(UNARY_METHOD.streamRequest(1234L)));
 
     verify(callListener).onMessage(1234L);
   }
@@ -316,37 +480,17 @@ public void streamListener_messageRead_onlyOnce() {
   @Test
   public void streamListener_unexpectedRuntimeException() {
     ServerStreamListenerImpl<Long> streamListener =
-        new ServerCallImpl.ServerStreamListenerImpl<Long>(
-            call, callListener, context, statsTraceCtx);
+        new ServerCallImpl.ServerStreamListenerImpl<>(call, callListener, context);
     doThrow(new RuntimeException("unexpected exception"))
         .when(callListener)
         .onMessage(any(Long.class));
 
-    thrown.expect(RuntimeException.class);
-    thrown.expectMessage("unexpected exception");
-    streamListener.messageRead(method.streamRequest(1234L));
-  }
-
-  private void checkStats(Status.Code statusCode) {
-    StatsTestUtils.MetricsRecord record = statsCtxFactory.pollRecord();
-    assertNotNull(record);
-    TagValue statusTag = record.tags.get(RpcConstants.RPC_STATUS);
-    assertNotNull(statusTag);
-    assertEquals(statusCode.toString(), statusTag.toString());
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_REQUEST_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_RESPONSE_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
-    // The test doesn't invoke MessageFramer and MessageDeframer which keep the sizes.
-    // Thus the sizes reported to stats would be zero.
-    assertEquals(0,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_REQUEST_BYTES));
-    assertEquals(0,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_RESPONSE_BYTES));
-    assertEquals(0,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES));
-    assertEquals(0,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES));
+    InputStream inputStream = UNARY_METHOD.streamRequest(1234L);
+
+    SingleMessageProducer producer = new SingleMessageProducer(inputStream);
+    RuntimeException e = assertThrows(RuntimeException.class,
+        () -> streamListener.messagesAvailable(producer));
+    assertThat(e).hasMessageThat().isEqualTo("unexpected exception");
   }
 
   private static class LongMarshaller implements Marshaller<Long> {
diff --git a/core/src/test/java/io/grpc/internal/ServerImplBuilderTest.java b/core/src/test/java/io/grpc/internal/ServerImplBuilderTest.java
new file mode 100644
index 00000000000..7ad7f15f358
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ServerImplBuilderTest.java
@@ -0,0 +1,202 @@
+/*
+ * 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import io.grpc.InternalConfigurator;
+import io.grpc.InternalConfiguratorRegistry;
+import io.grpc.Metadata;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerStreamTracer;
+import io.grpc.StaticTestingClassLoader;
+import io.grpc.internal.ServerImplBuilder.ClientTransportServersBuilder;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.Pattern;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ServerImplBuilder}. */
+@RunWith(JUnit4.class)
+public class ServerImplBuilderTest {
+  private static final ServerStreamTracer.Factory DUMMY_USER_TRACER =
+      new ServerStreamTracer.Factory() {
+        @Override
+        public ServerStreamTracer newServerStreamTracer(String fullMethodName, Metadata headers) {
+          throw new UnsupportedOperationException();
+        }
+      };
+  private static final ServerInterceptor DUMMY_TEST_INTERCEPTOR =
+      new ServerInterceptor() {
+
+        @Override
+        public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+            ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+          throw new UnsupportedOperationException();
+        }
+      };
+  private final StaticTestingClassLoader classLoader =
+      new StaticTestingClassLoader(
+          getClass().getClassLoader(),
+          Pattern.compile(
+              "io\\.grpc\\.InternalConfigurator|io\\.grpc\\.Configurator|"
+                  + "io\\.grpc\\.InternalConfiguratorRegistry|io\\.grpc\\.ConfiguratorRegistry|"
+                  + "io\\.grpc\\.internal\\.[^.]+"));
+
+  private ServerImplBuilder builder;
+
+  @Before
+  public void setUp() throws Exception {
+    builder = new ServerImplBuilder(
+        new ClientTransportServersBuilder() {
+          @Override
+          public InternalServer buildClientTransportServers(
+              List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+            throw new UnsupportedOperationException();
+          }
+        });
+  }
+
+  @Test
+  public void getTracerFactories_default() {
+    builder.addStreamTracerFactory(DUMMY_USER_TRACER);
+
+    List<? extends ServerStreamTracer.Factory> factories = builder.getTracerFactories();
+
+    assertEquals(3, factories.size());
+    assertThat(factories.get(0).getClass().getName())
+        .isEqualTo("io.grpc.census.CensusStatsModule$ServerTracerFactory");
+    assertThat(factories.get(1).getClass().getName())
+        .isEqualTo("io.grpc.census.CensusTracingModule$ServerTracerFactory");
+    assertThat(factories.get(2)).isSameInstanceAs(DUMMY_USER_TRACER);
+  }
+
+  @Test
+  public void getTracerFactories_disableStats() {
+    builder.addStreamTracerFactory(DUMMY_USER_TRACER);
+    builder.setStatsEnabled(false);
+
+    List<? extends ServerStreamTracer.Factory> factories = builder.getTracerFactories();
+
+    assertEquals(2, factories.size());
+    assertThat(factories.get(0).getClass().getName())
+        .isEqualTo("io.grpc.census.CensusTracingModule$ServerTracerFactory");
+    assertThat(factories.get(1)).isSameInstanceAs(DUMMY_USER_TRACER);
+  }
+
+  @Test
+  public void getTracerFactories_disableTracing() {
+    builder.addStreamTracerFactory(DUMMY_USER_TRACER);
+    builder.setTracingEnabled(false);
+
+    List<? extends ServerStreamTracer.Factory> factories = builder.getTracerFactories();
+
+    assertEquals(2, factories.size());
+    assertThat(factories.get(0).getClass().getName())
+        .isEqualTo("io.grpc.census.CensusStatsModule$ServerTracerFactory");
+    assertThat(factories.get(1)).isSameInstanceAs(DUMMY_USER_TRACER);
+  }
+
+  @Test
+  public void getTracerFactories_disableBoth() {
+    builder.addStreamTracerFactory(DUMMY_USER_TRACER);
+    builder.setTracingEnabled(false);
+    builder.setStatsEnabled(false);
+    List<? extends ServerStreamTracer.Factory> factories = builder.getTracerFactories();
+    assertThat(factories).containsExactly(DUMMY_USER_TRACER);
+  }
+
+  @Test
+  public void getTracerFactories_callsGet() throws Exception {
+    Class<?> runnable = classLoader.loadClass(StaticTestingClassLoaderCallsGet.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  public static final class StaticTestingClassLoaderCallsGet implements Runnable {
+    @Override
+    public void run() {
+      ServerImplBuilder builder =
+          new ServerImplBuilder(
+              streamTracerFactories -> {
+                throw new UnsupportedOperationException();
+              });
+      assertThat(builder.getTracerFactories()).hasSize(2);
+      assertThat(builder.interceptors).hasSize(0);
+      InternalConfiguratorRegistry.setConfigurators(Collections.emptyList());
+      assertThat(InternalConfiguratorRegistry.getConfigurators()).isEmpty();
+      assertThat(InternalConfiguratorRegistry.getConfiguratorsCallCountBeforeSet()).isEqualTo(1);
+    }
+  }
+
+  @Test
+  public void getTracerFactories_callsSet() throws Exception {
+    Class<?> runnable = classLoader.loadClass(StaticTestingClassLoaderCallsSet.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  public static final class StaticTestingClassLoaderCallsSet implements Runnable {
+    @Override
+    public void run() {
+      InternalConfiguratorRegistry.setConfigurators(
+          Arrays.asList(new InternalConfigurator() {
+            @Override
+            public void configureServerBuilder(ServerBuilder<?> builder) {
+              builder.intercept(DUMMY_TEST_INTERCEPTOR);
+              builder.addStreamTracerFactory(DUMMY_USER_TRACER);
+            }
+          }));
+      ServerImplBuilder builder =
+          new ServerImplBuilder(
+              streamTracerFactories -> {
+                throw new UnsupportedOperationException();
+              });
+      assertThat(builder.getTracerFactories()).containsExactly(DUMMY_USER_TRACER);
+      assertThat(builder.interceptors).containsExactly(DUMMY_TEST_INTERCEPTOR);
+    }
+  }
+
+  @Test
+  public void getEffectiveInterceptors_setEmpty() throws Exception {
+    Class<?> runnable =
+        classLoader.loadClass(StaticTestingClassLoaderCallsSetEmpty.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  // UsedReflectively
+  public static final class StaticTestingClassLoaderCallsSetEmpty implements Runnable {
+
+    @Override
+    public void run() {
+      InternalConfiguratorRegistry.setConfigurators(Collections.emptyList());
+      ServerImplBuilder builder =
+          new ServerImplBuilder(
+              streamTracerFactories -> {
+                throw new UnsupportedOperationException();
+              });
+      assertThat(builder.getTracerFactories()).isEmpty();
+      assertThat(builder.interceptors).isEmpty();
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ServerImplTest.java b/core/src/test/java/io/grpc/internal/ServerImplTest.java
index 5aaf90addb8..0f18efe078c 100644
--- a/core/src/test/java/io/grpc/internal/ServerImplTest.java
+++ b/core/src/test/java/io/grpc/internal/ServerImplTest.java
@@ -1,51 +1,43 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.InternalChannelz.id;
+import static io.grpc.internal.GrpcUtil.MESSAGE_ENCODING_KEY;
+import static io.grpc.internal.GrpcUtil.TIMEOUT_KEY;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Matchers.isNotNull;
-import static org.mockito.Matchers.notNull;
-import static org.mockito.Matchers.same;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
@@ -53,74 +45,103 @@
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
-import com.google.common.collect.ImmutableList;
-import com.google.common.truth.Truth;
+import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.MoreExecutors;
-import com.google.instrumentation.stats.RpcConstants;
-import com.google.instrumentation.stats.StatsContext;
-import com.google.instrumentation.stats.TagValue;
+import com.google.common.util.concurrent.SettableFuture;
 import io.grpc.Attributes;
+import io.grpc.BinaryLog;
+import io.grpc.Channel;
 import io.grpc.Compressor;
-import io.grpc.CompressorRegistry;
 import io.grpc.Context;
-import io.grpc.DecompressorRegistry;
+import io.grpc.Deadline;
 import io.grpc.Grpc;
 import io.grpc.HandlerRegistry;
 import io.grpc.IntegerMarshaller;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.ServerSocketsList;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.InternalLogId;
+import io.grpc.InternalServerInterceptors;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.ServerCall;
+import io.grpc.ServerCall.Listener;
+import io.grpc.ServerCallExecutorSupplier;
 import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerMethodDefinition;
 import io.grpc.ServerServiceDefinition;
+import io.grpc.ServerStreamTracer;
 import io.grpc.ServerTransportFilter;
 import io.grpc.ServiceDescriptor;
 import io.grpc.Status;
+import io.grpc.Status.Code;
 import io.grpc.StringMarshaller;
 import io.grpc.internal.ServerImpl.JumpToApplicationThreadServerStreamListener;
-import io.grpc.internal.testing.StatsTestUtils;
-import io.grpc.internal.testing.StatsTestUtils.FakeStatsContextFactory;
+import io.grpc.internal.ServerImplBuilder.ClientTransportServersBuilder;
+import io.grpc.internal.SingleMessageProducer;
+import io.grpc.internal.testing.TestServerStreamTracer;
 import io.grpc.util.MutableHandlerRegistry;
+import io.perfmark.PerfMark;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.InetSocketAddress;
 import java.net.SocketAddress;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.concurrent.CyclicBarrier;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
-import org.mockito.Matchers;
+import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /** Unit tests for {@link ServerImpl}. */
 @RunWith(JUnit4.class)
 public class ServerImplTest {
   private static final IntegerMarshaller INTEGER_MARSHALLER = IntegerMarshaller.INSTANCE;
   private static final StringMarshaller STRING_MARSHALLER = StringMarshaller.INSTANCE;
+  private static final MethodDescriptor<String, Integer> METHOD =
+      MethodDescriptor.<String, Integer>newBuilder()
+          .setType(MethodDescriptor.MethodType.UNKNOWN)
+          .setFullMethodName("Waiter/serve")
+          .setRequestMarshaller(STRING_MARSHALLER)
+          .setResponseMarshaller(INTEGER_MARSHALLER)
+          .build();
   private static final Context.Key<String> SERVER_ONLY = Context.key("serverOnly");
+  private static final Context.Key<String> SERVER_TRACER_ADDED_KEY = Context.key("tracer-added");
   private static final Context.CancellableContext SERVER_CONTEXT =
       Context.ROOT.withValue(SERVER_ONLY, "yes").withCancellation();
-  private static final ImmutableList<ServerTransportFilter> NO_FILTERS = ImmutableList.of();
-
-  private final FakeStatsContextFactory statsCtxFactory = new FakeStatsContextFactory();
-  private final CompressorRegistry compressorRegistry = CompressorRegistry.getDefaultInstance();
-  private final DecompressorRegistry decompressorRegistry =
-      DecompressorRegistry.getDefaultInstance();
+  private static final FakeClock.TaskFilter CONTEXT_CLOSER_TASK_FILTER =
+      new FakeClock.TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable runnable) {
+          return runnable instanceof ServerImpl.ContextCloser;
+        }
+      };
+  private static final String AUTHORITY = "some_authority";
 
-  @Rule public final ExpectedException thrown = ExpectedException.none();
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
 
   @BeforeClass
   public static void beforeStartUp() {
@@ -131,19 +152,44 @@ public static void beforeStartUp() {
 
   private final FakeClock executor = new FakeClock();
   private final FakeClock timer = new FakeClock();
+  private final InternalChannelz channelz = new InternalChannelz();
+
   @Mock
-  private ObjectPool<Executor> executorPool;
+  private ServerStreamTracer.Factory streamTracerFactory;
+  private List<ServerStreamTracer.Factory> streamTracerFactories;
+  private final TestServerStreamTracer streamTracer = new TestServerStreamTracer() {
+      @Override
+      public Context filterContext(Context context) {
+        Context newCtx = super.filterContext(context);
+        return newCtx.withValue(SERVER_TRACER_ADDED_KEY, "context added by tracer");
+      }
+    };
   @Mock
-  private ObjectPool<ScheduledExecutorService> timerPool;
-  private InternalHandlerRegistry registry = new InternalHandlerRegistry.Builder().build();
+  private ObjectPool<Executor> executorPool;
+  private ServerImplBuilder builder;
   private MutableHandlerRegistry mutableFallbackRegistry = new MutableHandlerRegistry();
-  private HandlerRegistry fallbackRegistry = mutableFallbackRegistry;
+  private HandlerRegistry fallbackRegistry = mock(
+      HandlerRegistry.class,
+      delegatesTo(new HandlerRegistry() {
+        @Override
+        public ServerMethodDefinition<?, ?> lookupMethod(
+            String methodName, @Nullable String authority) {
+          return mutableFallbackRegistry.lookupMethod(methodName, authority);
+        }
+
+        @Override
+        public List<ServerServiceDefinition> getServices() {
+          return mutableFallbackRegistry.getServices();
+        }
+      }));
   private SimpleServer transportServer = new SimpleServer();
   private ServerImpl server;
 
   @Captor
   private ArgumentCaptor<Status> statusCaptor;
   @Captor
+  private ArgumentCaptor<Metadata> metadataCaptor;
+  @Captor
   private ArgumentCaptor<ServerStreamListener> streamListenerCaptor;
 
   @Mock
@@ -156,9 +202,21 @@ public static void beforeStartUp() {
   /** Set up for test. */
   @Before
   public void startUp() throws IOException {
-    MockitoAnnotations.initMocks(this);
+    builder = new ServerImplBuilder(
+        new ClientTransportServersBuilder() {
+          @Override
+          public InternalServer buildClientTransportServers(
+              List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+            throw new UnsupportedOperationException();
+          }
+        });
+    builder.channelz = channelz;
+    builder.ticker = timer.getDeadlineTicker();
+    streamTracerFactories = Arrays.asList(streamTracerFactory);
     when(executorPool.getObject()).thenReturn(executor.getScheduledExecutorService());
-    when(timerPool.getObject()).thenReturn(timer.getScheduledExecutorService());
+    when(streamTracerFactory.newServerStreamTracer(anyString(), any(Metadata.class)))
+        .thenReturn(streamTracer);
+    when(stream.getAuthority()).thenReturn(AUTHORITY);
   }
 
   @After
@@ -167,13 +225,29 @@ public void noPendingTasks() {
     assertEquals(0, timer.numPendingTasks());
   }
 
+  @Test
+  public void getListenSockets() throws Exception {
+    int port = 800;
+    final List<InetSocketAddress> addresses =
+        Collections.singletonList(new InetSocketAddress(800));
+    transportServer = new SimpleServer() {
+      @Override
+      public List<InetSocketAddress> getListenSocketAddresses() {
+        return addresses;
+      }
+    };
+    createAndStartServer();
+    assertEquals(port, server.getPort());
+    assertThat(server.getListenSockets()).isEqualTo(addresses);
+  }
+
   @Test
   public void startStopImmediate() throws IOException {
     transportServer = new SimpleServer() {
       @Override
       public void shutdown() {}
     };
-    createAndStartServer(NO_FILTERS);
+    createAndStartServer();
     server.shutdown();
     assertTrue(server.isShutdown());
     assertFalse(server.isTerminated());
@@ -189,17 +263,16 @@ public void shutdown() {
         throw new AssertionError("Should not be called, because wasn't started");
       }
     };
-    createServer(NO_FILTERS);
+    createServer();
     server.shutdown();
     assertTrue(server.isShutdown());
     assertTrue(server.isTerminated());
     verifyNoMoreInteractions(executorPool);
-    verifyNoMoreInteractions(timerPool);
   }
 
   @Test
   public void startStopImmediateWithChildTransport() throws IOException {
-    createAndStartServer(NO_FILTERS);
+    createAndStartServer();
     verifyExecutorsAcquired();
     class DelayedShutdownServerTransport extends SimpleServerTransport {
       boolean shutdown;
@@ -225,7 +298,7 @@ public void shutdown() {
 
   @Test
   public void startShutdownNowImmediateWithChildTransport() throws IOException {
-    createAndStartServer(NO_FILTERS);
+    createAndStartServer();
     verifyExecutorsAcquired();
     class DelayedShutdownServerTransport extends SimpleServerTransport {
       boolean shutdown;
@@ -254,7 +327,7 @@ public void shutdownNow(Status reason) {
 
   @Test
   public void shutdownNowAfterShutdown() throws IOException {
-    createAndStartServer(NO_FILTERS);
+    createAndStartServer();
     verifyExecutorsAcquired();
     class DelayedShutdownServerTransport extends SimpleServerTransport {
       boolean shutdown;
@@ -290,7 +363,7 @@ public void shutdown() {
         // Don't call super which calls listener.serverShutdown(). We'll call it manually.
       }
     };
-    createAndStartServer(NO_FILTERS);
+    createAndStartServer();
     verifyExecutorsAcquired();
     class DelayedShutdownServerTransport extends SimpleServerTransport {
       boolean shutdown;
@@ -329,7 +402,7 @@ public void start(ServerListener listener) throws IOException {
     }
 
     transportServer = new FailingStartupServer();
-    createServer(NO_FILTERS);
+    createServer();
     try {
       server.start();
       fail("expected exception");
@@ -337,17 +410,40 @@ public void start(ServerListener listener) throws IOException {
       assertSame(ex, e);
     }
     verifyNoMoreInteractions(executorPool);
-    verifyNoMoreInteractions(timerPool);
+  }
+
+  @Test
+  public void transportHandshakeTimeout_expired() throws Exception {
+    class ShutdownRecordingTransport extends SimpleServerTransport {
+      Status shutdownNowStatus;
+
+      @Override public void shutdownNow(Status status) {
+        shutdownNowStatus = status;
+        super.shutdownNow(status);
+      }
+    }
+
+    builder.handshakeTimeout(60, TimeUnit.SECONDS);
+    createAndStartServer();
+    ShutdownRecordingTransport serverTransport = new ShutdownRecordingTransport();
+    transportServer.registerNewServerTransport(serverTransport);
+    timer.forwardTime(59, TimeUnit.SECONDS);
+    assertNull("shutdownNow status", serverTransport.shutdownNowStatus);
+    // Don't call transportReady() in time
+    timer.forwardTime(2, TimeUnit.SECONDS);
+    assertNotNull("shutdownNow status", serverTransport.shutdownNowStatus);
   }
 
   @Test
   public void methodNotFound() throws Exception {
-    createAndStartServer(NO_FILTERS);
+    createAndStartServer();
     ServerTransportListener transportListener
         = transportServer.registerNewServerTransport(new SimpleServerTransport());
+    transportListener.transportReady(Attributes.EMPTY);
     Metadata requestHeaders = new Metadata();
     StatsTraceContext statsTraceCtx =
-        transportListener.methodDetermined("Waiter/nonexist", requestHeaders);
+        StatsTraceContext.newServerContext(
+            streamTracerFactories, "Waiter/nonexist", requestHeaders);
     when(stream.statsTraceContext()).thenReturn(statsTraceCtx);
     transportListener.streamCreated(stream, "Waiter/nonexist", requestHeaders);
     verify(stream).setListener(isA(ServerStreamListener.class));
@@ -359,31 +455,174 @@ public void methodNotFound() throws Exception {
     assertEquals(Status.Code.UNIMPLEMENTED, status.getCode());
     assertEquals("Method not found: Waiter/nonexist", status.getDescription());
 
-    StatsTestUtils.MetricsRecord record = statsCtxFactory.pollRecord();
-    assertNotNull(record);
-    TagValue methodTag = record.tags.get(RpcConstants.RPC_SERVER_METHOD);
-    assertNotNull(methodTag);
-    assertEquals("Waiter/nonexist", methodTag.toString());
-    TagValue statusTag = record.tags.get(RpcConstants.RPC_STATUS);
-    assertNotNull(statusTag);
-    assertEquals(Status.Code.UNIMPLEMENTED.toString(), statusTag.toString());
+    verify(streamTracerFactory).newServerStreamTracer(eq("Waiter/nonexist"), same(requestHeaders));
+    assertNull(streamTracer.getServerCallInfo());
+    assertEquals(Status.Code.UNIMPLEMENTED, statusCaptor.getValue().getCode());
+  }
+
+
+  @Test
+  public void executorSupplierSameExecutorBasic() throws Exception {
+    builder.executorSupplier = new ServerCallExecutorSupplier() {
+      @Override
+      public <ReqT, RespT> Executor getExecutor(ServerCall<ReqT, RespT> call, Metadata metadata) {
+        return executor.getScheduledExecutorService();
+      }
+    };
+    basicExchangeSuccessful();
+  }
+
+  @Test
+  public void executorSupplierNullBasic() throws Exception {
+    builder.executorSupplier = new ServerCallExecutorSupplier() {
+      @Override
+      public <ReqT, RespT> Executor getExecutor(ServerCall<ReqT, RespT> call, Metadata metadata) {
+        return null;
+      }
+    };
+    basicExchangeSuccessful();
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void executorSupplierSwitchExecutor() throws Exception {
+    SingleExecutor switchingExecutor = new SingleExecutor();
+    ServerCallExecutorSupplier mockSupplier = mock(ServerCallExecutorSupplier.class);
+    when(mockSupplier.getExecutor(any(ServerCall.class), any(Metadata.class)))
+            .thenReturn(switchingExecutor);
+    builder.executorSupplier = mockSupplier;
+    final AtomicReference<ServerCall<String, Integer>> callReference
+            = new AtomicReference<>();
+    mutableFallbackRegistry.addService(ServerServiceDefinition.builder(
+            new ServiceDescriptor("Waiter", METHOD))
+            .addMethod(METHOD,
+                new ServerCallHandler<String, Integer>() {
+                  @Override
+                  public ServerCall.Listener<String> startCall(
+                          ServerCall<String, Integer> call,
+                          Metadata headers) {
+                    callReference.set(call);
+                    return callListener;
+                  }
+                }).build());
+
+    createAndStartServer();
+    ServerTransportListener transportListener
+            = transportServer.registerNewServerTransport(new SimpleServerTransport());
+    transportListener.transportReady(Attributes.EMPTY);
+    Metadata requestHeaders = new Metadata();
+    StatsTraceContext statsTraceCtx =
+            StatsTraceContext.newServerContext(
+                    streamTracerFactories, "Waiter/serve", requestHeaders);
+    when(stream.statsTraceContext()).thenReturn(statsTraceCtx);
+    transportListener.streamCreated(stream, "Waiter/serve", requestHeaders);
+    verify(stream).setListener(isA(ServerStreamListener.class));
+    verify(stream, atLeast(1)).statsTraceContext();
+
+    assertEquals(1, executor.runDueTasks());
+    verify(fallbackRegistry).lookupMethod("Waiter/serve", AUTHORITY);
+    verify(streamTracerFactory).newServerStreamTracer(eq("Waiter/serve"), same(requestHeaders));
+    ArgumentCaptor<ServerCall<?,?>> callCapture = ArgumentCaptor.forClass(ServerCall.class);
+    verify(mockSupplier).getExecutor(callCapture.capture(), eq(requestHeaders));
+
+    assertThat(switchingExecutor.runnable).isNotNull();
+    assertEquals(0, executor.numPendingTasks());
+    switchingExecutor.drain();
+    ServerCall<String, Integer> call = callReference.get();
+    assertNotNull(call);
+    assertThat(call).isEqualTo(callCapture.getValue());
+  }
+
+  @Test
+  @SuppressWarnings("CheckReturnValue")
+  public void executorSupplierFutureNotSet() throws Exception {
+    builder.executorSupplier = new ServerCallExecutorSupplier() {
+      @Override
+      public <ReqT, RespT> Executor getExecutor(ServerCall<ReqT, RespT> call, Metadata metadata) {
+        throw new IllegalStateException("Yeah!");
+      }
+    };
+    doThrow(new IllegalStateException("Yeah")).doNothing()
+            .when(stream).close(any(Status.class), any(Metadata.class));
+    final AtomicReference<ServerCall<String, Integer>> callReference
+            = new AtomicReference<>();
+    mutableFallbackRegistry.addService(ServerServiceDefinition.builder(
+        new ServiceDescriptor("Waiter", METHOD))
+        .addMethod(METHOD,
+            new ServerCallHandler<String, Integer>() {
+                @Override
+                public ServerCall.Listener<String> startCall(
+                        ServerCall<String, Integer> call,
+                        Metadata headers) {
+                  callReference.set(call);
+                  return callListener;
+                }
+            }).build());
+
+    createAndStartServer();
+    ServerTransportListener transportListener
+            = transportServer.registerNewServerTransport(new SimpleServerTransport());
+    transportListener.transportReady(Attributes.EMPTY);
+    Metadata requestHeaders = new Metadata();
+    StatsTraceContext statsTraceCtx =
+            StatsTraceContext.newServerContext(
+                    streamTracerFactories, "Waiter/serve", requestHeaders);
+    when(stream.statsTraceContext()).thenReturn(statsTraceCtx);
+    transportListener.streamCreated(stream, "Waiter/serve", requestHeaders);
+    verify(stream).setListener(isA(ServerStreamListener.class));
+    verify(stream, atLeast(1)).statsTraceContext();
+
+    assertEquals(1, executor.runDueTasks());
+    verify(fallbackRegistry).lookupMethod("Waiter/serve", AUTHORITY);
+    assertThat(callReference.get()).isNull();
+    verify(stream, times(2)).close(statusCaptor.capture(), any(Metadata.class));
+    Status status = statusCaptor.getAllValues().get(1);
+    assertEquals(Code.UNKNOWN, status.getCode());
+    assertThat(status.getCause() instanceof IllegalStateException);
+  }
+
+  @Test
+  public void decompressorNotFound() throws Exception {
+    String decompressorName = "NON_EXISTENT_DECOMPRESSOR";
+    createAndStartServer();
+    ServerTransportListener transportListener
+        = transportServer.registerNewServerTransport(new SimpleServerTransport());
+    transportListener.transportReady(Attributes.EMPTY);
+    Metadata requestHeaders = new Metadata();
+    requestHeaders.put(MESSAGE_ENCODING_KEY, decompressorName);
+    StatsTraceContext statsTraceCtx =
+        StatsTraceContext.newServerContext(
+            streamTracerFactories, "Waiter/nonexist", requestHeaders);
+    when(stream.statsTraceContext()).thenReturn(statsTraceCtx);
+
+    transportListener.streamCreated(stream, "Waiter/nonexist", requestHeaders);
+
+    verify(stream).setListener(isA(ServerStreamListener.class));
+    verify(stream).streamId();
+    verify(stream).close(statusCaptor.capture(), any(Metadata.class));
+    Status status = statusCaptor.getValue();
+    assertEquals(Status.Code.UNIMPLEMENTED, status.getCode());
+    assertEquals("Can't find decompressor for " + decompressorName, status.getDescription());
+
+    verifyNoMoreInteractions(stream);
   }
 
   @Test
   public void basicExchangeSuccessful() throws Exception {
-    createAndStartServer(NO_FILTERS);
+    createAndStartServer();
+    basicExchangeHelper(METHOD, "Lots of pizza, please", 314, 50);
+  }
+
+  private void basicExchangeHelper(
+      MethodDescriptor<String, Integer> method,
+      String request,
+      int firstResponse,
+      Integer extraResponse) throws Exception {
     final Metadata.Key<String> metadataKey
         = Metadata.Key.of("inception", Metadata.ASCII_STRING_MARSHALLER);
-    final Metadata.Key<StatsContext> statsHeaderKey
-        = StatsTraceContext.createStatsHeader(statsCtxFactory);
     final AtomicReference<ServerCall<String, Integer>> callReference
-        = new AtomicReference<ServerCall<String, Integer>>();
-    MethodDescriptor<String, Integer> method = MethodDescriptor.<String, Integer>newBuilder()
-        .setType(MethodDescriptor.MethodType.UNKNOWN)
-        .setFullMethodName("Waiter/serve")
-        .setRequestMarshaller(STRING_MARSHALLER)
-        .setResponseMarshaller(INTEGER_MARSHALLER)
-        .build();
+        = new AtomicReference<>();
+    final AtomicReference<Context> callContextReference = new AtomicReference<>();
     mutableFallbackRegistry.addService(ServerServiceDefinition.builder(
         new ServiceDescriptor("Waiter", method))
         .addMethod(
@@ -398,20 +637,18 @@ public ServerCall.Listener<String> startCall(
                 assertNotNull(headers);
                 assertEquals("value", headers.get(metadataKey));
                 callReference.set(call);
+                callContextReference.set(Context.current());
                 return callListener;
               }
             }).build());
     ServerTransportListener transportListener
         = transportServer.registerNewServerTransport(new SimpleServerTransport());
+    transportListener.transportReady(Attributes.EMPTY);
 
     Metadata requestHeaders = new Metadata();
     requestHeaders.put(metadataKey, "value");
-    StatsContext statsContextOnClient = statsCtxFactory.getDefault().with(
-        StatsTestUtils.EXTRA_TAG, TagValue.create("extraTagValue"));
-    requestHeaders.put(statsHeaderKey, statsContextOnClient);
     StatsTraceContext statsTraceCtx =
-        transportListener.methodDetermined("Waiter/serve", requestHeaders);
-    assertNotNull(statsTraceCtx);
+        StatsTraceContext.newServerContext(streamTracerFactories, "Waiter/serve", requestHeaders);
     when(stream.statsTraceContext()).thenReturn(statsTraceCtx);
 
     transportListener.streamCreated(stream, "Waiter/serve", requestHeaders);
@@ -419,37 +656,50 @@ public ServerCall.Listener<String> startCall(
     ServerStreamListener streamListener = streamListenerCaptor.getValue();
     assertNotNull(streamListener);
     verify(stream, atLeast(1)).statsTraceContext();
+    verify(fallbackRegistry, never()).lookupMethod(any(String.class), any(String.class));
 
     assertEquals(1, executor.runDueTasks());
     ServerCall<String, Integer> call = callReference.get();
     assertNotNull(call);
-    verify(stream).getAuthority();
-
-    String order = "Lots of pizza, please";
-    streamListener.messageRead(STRING_MARSHALLER.stream(order));
+    assertEquals(
+        new ServerCallInfoImpl<>(
+            call.getMethodDescriptor(),
+            call.getAttributes(),
+            call.getAuthority()),
+        streamTracer.getServerCallInfo());
+    verify(fallbackRegistry).lookupMethod("Waiter/serve", AUTHORITY);
+    Context callContext = callContextReference.get();
+    assertNotNull(callContext);
+    assertEquals("context added by tracer", SERVER_TRACER_ADDED_KEY.get(callContext));
+    assertEquals(server, io.grpc.InternalServer.SERVER_CONTEXT_KEY.get(callContext));
+
+    streamListener.messagesAvailable(new SingleMessageProducer(STRING_MARSHALLER.stream(request)));
     assertEquals(1, executor.runDueTasks());
-    verify(callListener).onMessage(order);
+    verify(callListener).onMessage(request);
 
     Metadata responseHeaders = new Metadata();
     responseHeaders.put(metadataKey, "response value");
     call.sendHeaders(responseHeaders);
-    verify(stream).writeHeaders(responseHeaders);
+    verify(stream).writeHeaders(responseHeaders, true);
     verify(stream).setCompressor(isA(Compressor.class));
 
-    call.sendMessage(314);
+    call.sendMessage(firstResponse);
     ArgumentCaptor<InputStream> inputCaptor = ArgumentCaptor.forClass(InputStream.class);
     verify(stream).writeMessage(inputCaptor.capture());
     verify(stream).flush();
-    assertEquals(314, INTEGER_MARSHALLER.parse(inputCaptor.getValue()).intValue());
+    assertEquals(firstResponse, INTEGER_MARSHALLER.parse(inputCaptor.getValue()).intValue());
 
     streamListener.halfClosed(); // All full; no dessert.
     assertEquals(1, executor.runDueTasks());
     verify(callListener).onHalfClose();
 
-    call.sendMessage(50);
-    verify(stream, times(2)).writeMessage(inputCaptor.capture());
-    verify(stream, times(2)).flush();
-    assertEquals(50, INTEGER_MARSHALLER.parse(inputCaptor.getValue()).intValue());
+    if (extraResponse != null) {
+      call.sendMessage(extraResponse);
+      verify(stream, times(2)).writeMessage(inputCaptor.capture());
+      verify(stream, times(2)).flush();
+      assertEquals(
+          (int) extraResponse, INTEGER_MARSHALLER.parse(inputCaptor.getValue()).intValue());
+    }
 
     Metadata trailers = new Metadata();
     trailers.put(metadataKey, "another value");
@@ -462,55 +712,31 @@ public ServerCall.Listener<String> startCall(
     verify(callListener).onComplete();
 
     verify(stream, atLeast(1)).statsTraceContext();
-    verifyNoMoreInteractions(stream);
     verifyNoMoreInteractions(callListener);
 
-    // Check stats
-    StatsTestUtils.MetricsRecord record = statsCtxFactory.pollRecord();
-    assertNotNull(record);
-    TagValue methodTag = record.tags.get(RpcConstants.RPC_SERVER_METHOD);
-    assertNotNull(methodTag);
-    assertEquals("Waiter/serve", methodTag.toString());
-    TagValue statusTag = record.tags.get(RpcConstants.RPC_STATUS);
-    assertNotNull(statusTag);
-    assertEquals(Status.Code.OK.toString(), statusTag.toString());
-    TagValue extraTag = record.tags.get(StatsTestUtils.EXTRA_TAG);
-    assertNotNull(extraTag);
-    assertEquals("extraTagValue", extraTag.toString());
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_REQUEST_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_RESPONSE_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
-    // The test doesn't invoke MessageFramer and MessageDeframer which keep the sizes.
-    // Thus the sizes reported to stats would be zero.
-    assertEquals(0, record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_REQUEST_BYTES));
-    assertEquals(0, record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_RESPONSE_BYTES));
-    assertEquals(0,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES));
-    assertEquals(0,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES));
+    verify(streamTracerFactory).newServerStreamTracer(eq("Waiter/serve"), same(requestHeaders));
   }
 
   @Test
   public void transportFilters() throws Exception {
     final SocketAddress remoteAddr = mock(SocketAddress.class);
-    final Attributes.Key<String> key1 = Attributes.Key.of("test-key1");
-    final Attributes.Key<String> key2 = Attributes.Key.of("test-key2");
-    final Attributes.Key<String> key3 = Attributes.Key.of("test-key3");
+    final Attributes.Key<String> key1 = Attributes.Key.create("test-key1");
+    final Attributes.Key<String> key2 = Attributes.Key.create("test-key2");
+    final Attributes.Key<String> key3 = Attributes.Key.create("test-key3");
     final AtomicReference<Attributes> filter1TerminationCallbackArgument =
-        new AtomicReference<Attributes>();
+        new AtomicReference<>();
     final AtomicReference<Attributes> filter2TerminationCallbackArgument =
-        new AtomicReference<Attributes>();
+        new AtomicReference<>();
     final AtomicInteger readyCallbackCalled = new AtomicInteger(0);
     final AtomicInteger terminationCallbackCalled = new AtomicInteger(0);
-    ServerTransportFilter filter1 = new ServerTransportFilter() {
+    builder.addTransportFilter(new ServerTransportFilter() {
         @Override
         public Attributes transportReady(Attributes attrs) {
           assertEquals(Attributes.newBuilder()
               .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, remoteAddr)
               .build(), attrs);
           readyCallbackCalled.incrementAndGet();
-          return Attributes.newBuilder(attrs)
+          return attrs.toBuilder()
               .set(key1, "yalayala")
               .set(key2, "blabla")
               .build();
@@ -521,8 +747,8 @@ public void transportTerminated(Attributes attrs) {
           terminationCallbackCalled.incrementAndGet();
           filter1TerminationCallbackArgument.set(attrs);
         }
-      };
-    ServerTransportFilter filter2 = new ServerTransportFilter() {
+      });
+    builder.addTransportFilter(new ServerTransportFilter() {
         @Override
         public Attributes transportReady(Attributes attrs) {
           assertEquals(Attributes.newBuilder()
@@ -531,7 +757,7 @@ public Attributes transportReady(Attributes attrs) {
               .set(key2, "blabla")
               .build(), attrs);
           readyCallbackCalled.incrementAndGet();
-          return Attributes.newBuilder(attrs)
+          return attrs.toBuilder()
               .set(key1, "ouch")
               .set(key3, "puff")
               .build();
@@ -542,7 +768,7 @@ public void transportTerminated(Attributes attrs) {
           terminationCallbackCalled.incrementAndGet();
           filter2TerminationCallbackArgument.set(attrs);
         }
-      };
+      });
     Attributes expectedTransportAttrs = Attributes.newBuilder()
         .set(key1, "ouch")
         .set(key2, "blabla")
@@ -550,7 +776,7 @@ public void transportTerminated(Attributes attrs) {
         .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, remoteAddr)
         .build();
 
-    createAndStartServer(ImmutableList.of(filter1, filter2));
+    createAndStartServer();
     ServerTransportListener transportListener
         = transportServer.registerNewServerTransport(new SimpleServerTransport());
     Attributes transportAttrs = transportListener.transportReady(Attributes.newBuilder()
@@ -567,19 +793,99 @@ public void transportTerminated(Attributes attrs) {
     assertEquals(2, terminationCallbackCalled.get());
   }
 
+  @Test
+  public void interceptors() throws Exception {
+    final LinkedList<Context> capturedContexts = new LinkedList<>();
+    final Context.Key<String> key1 = Context.key("key1");
+    final Context.Key<String> key2 = Context.key("key2");
+    final Context.Key<String> key3 = Context.key("key3");
+    ServerInterceptor interceptor1 = new ServerInterceptor() {
+        @Override
+        public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+            ServerCall<ReqT, RespT> call,
+            Metadata headers,
+            ServerCallHandler<ReqT, RespT> next) {
+          Context ctx = Context.current().withValue(key1, "value1");
+          Context origCtx = ctx.attach();
+          try {
+            capturedContexts.add(ctx);
+            return next.startCall(call, headers);
+          } finally {
+            ctx.detach(origCtx);
+          }
+        }
+      };
+    ServerInterceptor interceptor2 = new ServerInterceptor() {
+        @Override
+        public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+            ServerCall<ReqT, RespT> call,
+            Metadata headers,
+            ServerCallHandler<ReqT, RespT> next) {
+          Context ctx = Context.current().withValue(key2, "value2");
+          Context origCtx = ctx.attach();
+          try {
+            capturedContexts.add(ctx);
+            return next.startCall(call, headers);
+          } finally {
+            ctx.detach(origCtx);
+          }
+        }
+      };
+    ServerCallHandler<String, Integer> callHandler = new ServerCallHandler<String, Integer>() {
+        @Override
+        public ServerCall.Listener<String> startCall(
+            ServerCall<String, Integer> call,
+            Metadata headers) {
+          capturedContexts.add(Context.current().withValue(key3, "value3"));
+          return callListener;
+        }
+      };
+
+    mutableFallbackRegistry.addService(
+        ServerServiceDefinition.builder(new ServiceDescriptor("Waiter", METHOD))
+            .addMethod(METHOD, callHandler).build());
+    builder.intercept(interceptor2);
+    builder.intercept(interceptor1);
+    createServer();
+    server.start();
+
+    ServerTransportListener transportListener
+        = transportServer.registerNewServerTransport(new SimpleServerTransport());
+    transportListener.transportReady(Attributes.EMPTY);
+
+    Metadata requestHeaders = new Metadata();
+    StatsTraceContext statsTraceCtx =
+        StatsTraceContext.newServerContext(streamTracerFactories, "Waiter/serve", requestHeaders);
+    when(stream.statsTraceContext()).thenReturn(statsTraceCtx);
+
+    transportListener.streamCreated(stream, "Waiter/serve", requestHeaders);
+    assertEquals(1, executor.runDueTasks());
+
+    Context ctx1 = capturedContexts.poll();
+    assertEquals("value1", key1.get(ctx1));
+    assertNull(key2.get(ctx1));
+    assertNull(key3.get(ctx1));
+
+    Context ctx2 = capturedContexts.poll();
+    assertEquals("value1", key1.get(ctx2));
+    assertEquals("value2", key2.get(ctx2));
+    assertNull(key3.get(ctx2));
+
+    Context ctx3 = capturedContexts.poll();
+    assertEquals("value1", key1.get(ctx3));
+    assertEquals("value2", key2.get(ctx3));
+    assertEquals("value3", key3.get(ctx3));
+
+    assertTrue(capturedContexts.isEmpty());
+  }
+
   @Test
   public void exceptionInStartCallPropagatesToStream() throws Exception {
-    createAndStartServer(NO_FILTERS);
+    createAndStartServer();
     final Status status = Status.ABORTED.withDescription("Oh, no!");
-    MethodDescriptor<String, Integer> method = MethodDescriptor.<String, Integer>newBuilder()
-        .setType(MethodDescriptor.MethodType.UNKNOWN)
-        .setFullMethodName("Waiter/serve")
-        .setRequestMarshaller(STRING_MARSHALLER)
-        .setResponseMarshaller(INTEGER_MARSHALLER)
-        .build();
     mutableFallbackRegistry.addService(ServerServiceDefinition.builder(
-        new ServiceDescriptor("Waiter", method))
-        .addMethod(method,
+        new ServiceDescriptor("Waiter", METHOD))
+        .addMethod(METHOD,
             new ServerCallHandler<String, Integer>() {
               @Override
               public ServerCall.Listener<String> startCall(
@@ -590,25 +896,26 @@ public ServerCall.Listener<String> startCall(
             }).build());
     ServerTransportListener transportListener
         = transportServer.registerNewServerTransport(new SimpleServerTransport());
+    transportListener.transportReady(Attributes.EMPTY);
 
     Metadata requestHeaders = new Metadata();
     StatsTraceContext statsTraceCtx =
-        transportListener.methodDetermined("Waiter/serve", requestHeaders);
-    assertNotNull(statsTraceCtx);
+        StatsTraceContext.newServerContext(streamTracerFactories, "Waiter/serve", requestHeaders);
     when(stream.statsTraceContext()).thenReturn(statsTraceCtx);
 
     transportListener.streamCreated(stream, "Waiter/serve", requestHeaders);
+    verify(stream).streamId();
     verify(stream).setListener(streamListenerCaptor.capture());
     ServerStreamListener streamListener = streamListenerCaptor.getValue();
     assertNotNull(streamListener);
     verify(stream, atLeast(1)).statsTraceContext();
     verifyNoMoreInteractions(stream);
+    verify(fallbackRegistry, never()).lookupMethod(any(String.class), any(String.class));
 
     assertEquals(1, executor.runDueTasks());
-    verify(stream).getAuthority();
-    verify(stream).close(same(status), notNull(Metadata.class));
+    verify(fallbackRegistry).lookupMethod("Waiter/serve", AUTHORITY);
+    verify(stream).close(same(status), ArgumentMatchers.<Metadata>notNull());
     verify(stream, atLeast(1)).statsTraceContext();
-    verifyNoMoreInteractions(stream);
   }
 
   @Test
@@ -624,7 +931,7 @@ public void shutdown() {
         } catch (Exception ex) {
           throw new AssertionError(ex);
         }
-        // If deadlock is possible with this setup, this sychronization completes the loop because
+        // If deadlock is possible with this setup, this synchronization completes the loop because
         // the serverShutdown needs a lock that Server is holding while calling this method.
         synchronized (lock) {
         }
@@ -632,7 +939,7 @@ public void shutdown() {
     }
 
     transportServer = new MaybeDeadlockingServer();
-    createAndStartServer(NO_FILTERS);
+    createAndStartServer();
     new Thread() {
       @Override
       public void run() {
@@ -652,7 +959,7 @@ public void run() {
 
   @Test
   public void testNoDeadlockOnTransportShutdown() throws Exception {
-    createAndStartServer(NO_FILTERS);
+    createAndStartServer();
     final Object lock = new Object();
     final CyclicBarrier barrier = new CyclicBarrier(2);
     class MaybeDeadlockingServerTransport extends SimpleServerTransport {
@@ -664,7 +971,7 @@ public void shutdown() {
         } catch (Exception ex) {
           throw new AssertionError(ex);
         }
-        // If deadlock is possible with this setup, this sychronization completes the loop
+        // If deadlock is possible with this setup, this synchronization completes the loop
         // because the transportTerminated needs a lock that Server is holding while calling this
         // method.
         synchronized (lock) {
@@ -693,21 +1000,15 @@ public void run() {
 
   @Test
   public void testCallContextIsBoundInListenerCallbacks() throws Exception {
-    createAndStartServer(NO_FILTERS);
-    MethodDescriptor<String, Integer> method = MethodDescriptor.<String, Integer>newBuilder()
-        .setType(MethodDescriptor.MethodType.UNKNOWN)
-        .setFullMethodName("Waiter/serve")
-        .setRequestMarshaller(STRING_MARSHALLER)
-        .setResponseMarshaller(INTEGER_MARSHALLER)
-        .build();
+    createAndStartServer();
     final AtomicBoolean  onReadyCalled = new AtomicBoolean(false);
     final AtomicBoolean onMessageCalled = new AtomicBoolean(false);
     final AtomicBoolean onHalfCloseCalled = new AtomicBoolean(false);
     final AtomicBoolean onCancelCalled = new AtomicBoolean(false);
     mutableFallbackRegistry.addService(ServerServiceDefinition.builder(
-        new ServiceDescriptor("Waiter", method))
+        new ServiceDescriptor("Waiter", METHOD))
         .addMethod(
-            method,
+            METHOD,
             new ServerCallHandler<String, Integer>() {
               @Override
               public ServerCall.Listener<String> startCall(
@@ -758,11 +1059,11 @@ private void checkContext() {
             }).build());
     ServerTransportListener transportListener
         = transportServer.registerNewServerTransport(new SimpleServerTransport());
+    transportListener.transportReady(Attributes.EMPTY);
 
     Metadata requestHeaders = new Metadata();
     StatsTraceContext statsTraceCtx =
-        transportListener.methodDetermined("Waiter/serve", requestHeaders);
-    assertNotNull(statsTraceCtx);
+        StatsTraceContext.newServerContext(streamTracerFactories, "Waitier/serve", requestHeaders);
     when(stream.statsTraceContext()).thenReturn(statsTraceCtx);
 
     transportListener.streamCreated(stream, "Waiter/serve", requestHeaders);
@@ -774,7 +1075,8 @@ private void checkContext() {
     assertEquals(1, executor.runDueTasks());
     assertTrue(onReadyCalled.get());
 
-    streamListener.messageRead(new ByteArrayInputStream(new byte[0]));
+    streamListener
+        .messagesAvailable(new SingleMessageProducer(new ByteArrayInputStream(new byte[0])));
     assertEquals(1, executor.runDueTasks());
     assertTrue(onMessageCalled.get());
 
@@ -783,20 +1085,24 @@ private void checkContext() {
     assertTrue(onHalfCloseCalled.get());
 
     streamListener.closed(Status.CANCELLED);
-    assertEquals(1, executor.runDueTasks());
+    assertEquals(1, executor.numPendingTasks(CONTEXT_CLOSER_TASK_FILTER));
+    assertEquals(2, executor.runDueTasks());
     assertTrue(onCancelCalled.get());
 
     // Close should never be called if asserts in listener pass.
-    verify(stream, times(0)).close(isA(Status.class), isNotNull(Metadata.class));
+    verify(stream, times(0)).close(isA(Status.class), ArgumentMatchers.<Metadata>isNotNull());
   }
 
-  @Test
-  public void testClientCancelTriggersContextCancellation() throws Exception {
-    createAndStartServer(NO_FILTERS);
-    final AtomicBoolean contextCancelled = new AtomicBoolean(false);
+  private ServerStreamListener testStreamClose_setup(
+      final AtomicReference<ServerCall<String, Integer>> callReference,
+      final AtomicReference<Context> context,
+      final AtomicBoolean contextCancelled,
+      @Nullable Long timeoutNanos) throws Exception {
+    createAndStartServer();
     callListener = new ServerCall.Listener<String>() {
       @Override
       public void onReady() {
+        context.set(Context.current());
         Context.current().addListener(new Context.CancellationListener() {
           @Override
           public void cancelled(Context context) {
@@ -806,18 +1112,9 @@ public void cancelled(Context context) {
       }
     };
 
-    final AtomicReference<ServerCall<String, Integer>> callReference
-        = new AtomicReference<ServerCall<String, Integer>>();
-    MethodDescriptor<String, Integer> method = MethodDescriptor.<String, Integer>newBuilder()
-        .setType(MethodDescriptor.MethodType.UNKNOWN)
-        .setFullMethodName("Waiter/serve")
-        .setRequestMarshaller(STRING_MARSHALLER)
-        .setResponseMarshaller(INTEGER_MARSHALLER)
-        .build();
-
     mutableFallbackRegistry.addService(ServerServiceDefinition.builder(
-        new ServiceDescriptor("Waiter", method))
-        .addMethod(method,
+        new ServiceDescriptor("Waiter", METHOD))
+        .addMethod(METHOD,
             new ServerCallHandler<String, Integer>() {
               @Override
               public ServerCall.Listener<String> startCall(
@@ -829,10 +1126,13 @@ public ServerCall.Listener<String> startCall(
             }).build());
     ServerTransportListener transportListener
         = transportServer.registerNewServerTransport(new SimpleServerTransport());
+    transportListener.transportReady(Attributes.EMPTY);
     Metadata requestHeaders = new Metadata();
+    if (timeoutNanos != null) {
+      requestHeaders.put(TIMEOUT_KEY, timeoutNanos);
+    }
     StatsTraceContext statsTraceCtx =
-        transportListener.methodDetermined("Waiter/serve", requestHeaders);
-    assertNotNull(statsTraceCtx);
+        StatsTraceContext.newServerContext(streamTracerFactories, "Waitier/serve", requestHeaders);
     when(stream.statsTraceContext()).thenReturn(statsTraceCtx);
     transportListener.streamCreated(stream, "Waiter/serve", requestHeaders);
     verify(stream).setListener(streamListenerCaptor.capture());
@@ -840,79 +1140,176 @@ public ServerCall.Listener<String> startCall(
     assertNotNull(streamListener);
 
     streamListener.onReady();
+    assertEquals(1, executor.runDueTasks());
+    return streamListener;
+  }
+
+  @Test
+  public void testContextExpiredBeforeStreamCreate_StreamCancelNotCalledBeforeSetListener()
+      throws Exception {
+    builder.ticker = new Deadline.Ticker() {
+      private long time;
+
+      @Override
+      public long nanoTime() {
+        time += 1000;
+        return time;
+      }
+    };
+
+    AtomicBoolean contextCancelled = new AtomicBoolean(false);
+    AtomicReference<Context> context = new AtomicReference<>();
+    AtomicReference<ServerCall<String, Integer>> callReference = new AtomicReference<>();
+
+    testStreamClose_setup(callReference, context, contextCancelled, 1L);
+
+    // This assert that stream.setListener(jumpListener) is called before stream.cancel(), which
+    // prevents extremely short deadlines causing NPEs.
+    InOrder inOrder = inOrder(stream);
+    inOrder.verify(stream).setListener(any(ServerStreamListener.class));
+    inOrder.verify(stream).cancel(statusCaptor.capture());
+
+    assertThat(statusCaptor.getValue().asException())
+        .hasMessageThat().contains("context timed out");
+    assertTrue(callReference.get().isCancelled());
+  }
+
+  @Test
+  public void testStreamClose_clientCancelTriggersImmediateCancellation() throws Exception {
+    AtomicBoolean contextCancelled = new AtomicBoolean(false);
+    AtomicReference<Context> context = new AtomicReference<>();
+    AtomicReference<ServerCall<String, Integer>> callReference = new AtomicReference<>();
+
+    ServerStreamListener streamListener = testStreamClose_setup(callReference,
+        context, contextCancelled, null);
+
+    // For close status being non OK:
+    // isCancelled is expected to be true immediately after calling closed(), without needing
+    // to wait for the main executor to run any tasks.
+    assertFalse(callReference.get().isCancelled());
+    assertFalse(context.get().isCancelled());
     streamListener.closed(Status.CANCELLED);
+    assertEquals(1, executor.numPendingTasks(CONTEXT_CLOSER_TASK_FILTER));
+    assertEquals(2, executor.runDueTasks());
+    assertTrue(callReference.get().isCancelled());
+    assertTrue(context.get().isCancelled());
+    assertThat(context.get().cancellationCause()).isNotNull();
+    assertTrue(contextCancelled.get());
+  }
+
+  @Test
+  public void testStreamClose_clientOkTriggersDelayedCancellation() throws Exception {
+    AtomicBoolean contextCancelled = new AtomicBoolean(false);
+    AtomicReference<Context> context = new AtomicReference<>();
+    AtomicReference<ServerCall<String, Integer>> callReference = new AtomicReference<>();
+
+    ServerStreamListener streamListener = testStreamClose_setup(callReference,
+        context, contextCancelled, null);
+
+    // For close status OK:
+    // The context isCancelled is expected to be true after all pending work is done,
+    // but for the call it should be false as it gets set cancelled only if the call
+    // fails with a non-OK status.
+    assertFalse(callReference.get().isCancelled());
+    assertFalse(context.get().isCancelled());
+    streamListener.closed(Status.OK);
+    assertFalse(callReference.get().isCancelled());
+    assertFalse(context.get().isCancelled());
 
     assertEquals(1, executor.runDueTasks());
+    assertFalse(callReference.get().isCancelled());
+    assertTrue(context.get().isCancelled());
+    assertThat(context.get().cancellationCause()).isNull();
+    assertTrue(contextCancelled.get());
+  }
+
+  @Test
+  public void testStreamClose_deadlineExceededTriggersImmediateCancellation() throws Exception {
+    AtomicBoolean contextCancelled = new AtomicBoolean(false);
+    AtomicReference<Context> context = new AtomicReference<>();
+    AtomicReference<ServerCall<String, Integer>> callReference = new AtomicReference<>();
+
+    testStreamClose_setup(callReference, context, contextCancelled, 50L);
+
+    timer.forwardNanos(49);
+
+    assertFalse(callReference.get().isCancelled());
+    assertFalse(context.get().isCancelled());
+
+    assertEquals(1, timer.forwardNanos(1));
+
+    assertTrue(callReference.get().isCancelled());
+    assertTrue(context.get().isCancelled());
+    assertThat(context.get().cancellationCause()).isNotNull();
     assertTrue(contextCancelled.get());
   }
 
   @Test
   public void getPort() throws Exception {
+    final InetSocketAddress addr = new InetSocketAddress(65535);
+    final List<InetSocketAddress> addrs = Collections.singletonList(addr);
     transportServer = new SimpleServer() {
       @Override
-      public int getPort() {
-        return 65535;
+      public InetSocketAddress getListenSocketAddress() {
+        return addr;
+      }
+
+      @Override
+      public List<InetSocketAddress> getListenSocketAddresses() {
+        return addrs;
       }
     };
-    createAndStartServer(NO_FILTERS);
+    createAndStartServer();
 
-    Truth.assertThat(server.getPort()).isEqualTo(65535);
+    assertThat(server.getPort()).isEqualTo(addr.getPort());
+    assertThat(server.getListenSockets()).isEqualTo(addrs);
   }
 
   @Test
   public void getPortBeforeStartedFails() {
     transportServer = new SimpleServer();
-    createServer(NO_FILTERS);
-    thrown.expect(IllegalStateException.class);
-    thrown.expectMessage("started");
-    server.getPort();
+    createServer();
+    IllegalStateException e = assertThrows(IllegalStateException.class, () -> server.getPort());
+    assertThat(e).hasMessageThat().isEqualTo("Not started");
   }
 
   @Test
   public void getPortAfterTerminationFails() throws Exception {
     transportServer = new SimpleServer();
-    createAndStartServer(NO_FILTERS);
+    createAndStartServer();
     server.shutdown();
     server.awaitTermination();
-    thrown.expect(IllegalStateException.class);
-    thrown.expectMessage("terminated");
-    server.getPort();
+    IllegalStateException e = assertThrows(IllegalStateException.class, () -> server.getPort());
+    assertThat(e).hasMessageThat().isEqualTo("Already terminated");
   }
 
   @Test
   public void handlerRegistryPriorities() throws Exception {
     fallbackRegistry = mock(HandlerRegistry.class);
-    MethodDescriptor<String, Integer> method1 = MethodDescriptor.<String, Integer>newBuilder()
-        .setType(MethodDescriptor.MethodType.UNKNOWN)
-        .setFullMethodName("Service1/Method1")
-        .setRequestMarshaller(STRING_MARSHALLER)
-        .setResponseMarshaller(INTEGER_MARSHALLER)
-        .build();
-    registry = new InternalHandlerRegistry.Builder()
-        .addService(ServerServiceDefinition.builder(new ServiceDescriptor("Service1", method1))
-            .addMethod(method1, callHandler).build())
-        .build();
+    builder.addService(
+        ServerServiceDefinition.builder(new ServiceDescriptor("Waiter", METHOD))
+            .addMethod(METHOD, callHandler).build());
     transportServer = new SimpleServer();
-    createAndStartServer(NO_FILTERS);
+    createAndStartServer();
 
     ServerTransportListener transportListener
         = transportServer.registerNewServerTransport(new SimpleServerTransport());
+    transportListener.transportReady(Attributes.EMPTY);
     Metadata requestHeaders = new Metadata();
     StatsTraceContext statsTraceCtx =
-        transportListener.methodDetermined("Waiter/serve", requestHeaders);
-    assertNotNull(statsTraceCtx);
+        StatsTraceContext.newServerContext(streamTracerFactories, "Waiter/serve", requestHeaders);
     when(stream.statsTraceContext()).thenReturn(statsTraceCtx);
 
     // This call will be handled by callHandler from the internal registry
-    transportListener.streamCreated(stream, "Service1/Method1", requestHeaders);
+    transportListener.streamCreated(stream, "Waiter/serve", requestHeaders);
     assertEquals(1, executor.runDueTasks());
-    verify(callHandler).startCall(Matchers.<ServerCall<String, Integer>>anyObject(),
-        Matchers.<Metadata>anyObject());
-    // This call will be handled by the fallbackRegistry because it's not registred in the internal
+    verify(callHandler).startCall(ArgumentMatchers.<ServerCall<String, Integer>>any(),
+        ArgumentMatchers.<Metadata>any());
+    // This call will be handled by the fallbackRegistry because it's not registered in the internal
     // registry.
     transportListener.streamCreated(stream, "Service1/Method2", requestHeaders);
     assertEquals(1, executor.runDueTasks());
-    verify(fallbackRegistry).lookupMethod("Service1/Method2", null);
+    verify(fallbackRegistry).lookupMethod("Service1/Method2", AUTHORITY);
 
     verifyNoMoreInteractions(callHandler);
     verifyNoMoreInteractions(fallbackRegistry);
@@ -922,21 +1319,25 @@ public void handlerRegistryPriorities() throws Exception {
   public void messageRead_errorCancelsCall() throws Exception {
     JumpToApplicationThreadServerStreamListener listener
         = new JumpToApplicationThreadServerStreamListener(
-            executor.getScheduledExecutorService(), stream, Context.ROOT.withCancellation());
+            executor.getScheduledExecutorService(),
+            executor.getScheduledExecutorService(),
+            stream,
+            Context.ROOT.withCancellation(),
+            PerfMark.createTag());
     ServerStreamListener mockListener = mock(ServerStreamListener.class);
     listener.setListener(mockListener);
 
-    Throwable expectedT = new AssertionError();
-    doThrow(expectedT).when(mockListener).messageRead(any(InputStream.class));
+    TestError expectedT = new TestError();
+    doThrow(expectedT).when(mockListener)
+        .messagesAvailable(any(StreamListener.MessageProducer.class));
     // Closing the InputStream is done by the delegated listener (generally ServerCallImpl)
-    listener.messageRead(mock(InputStream.class));
+    listener.messagesAvailable(mock(StreamListener.MessageProducer.class));
     try {
       executor.runDueTasks();
       fail("Expected exception");
-    } catch (Throwable t) {
+    } catch (TestError t) {
       assertSame(expectedT, t);
-      verify(stream).close(statusCaptor.capture(), any(Metadata.class));
-      assertSame(expectedT, statusCaptor.getValue().getCause());
+      ensureServerStateNotLeaked();
     }
   }
 
@@ -944,21 +1345,25 @@ public void messageRead_errorCancelsCall() throws Exception {
   public void messageRead_runtimeExceptionCancelsCall() throws Exception {
     JumpToApplicationThreadServerStreamListener listener
         = new JumpToApplicationThreadServerStreamListener(
-            executor.getScheduledExecutorService(), stream, Context.ROOT.withCancellation());
+            executor.getScheduledExecutorService(),
+            executor.getScheduledExecutorService(),
+            stream,
+            Context.ROOT.withCancellation(),
+            PerfMark.createTag());
     ServerStreamListener mockListener = mock(ServerStreamListener.class);
     listener.setListener(mockListener);
 
-    Throwable expectedT = new RuntimeException();
-    doThrow(expectedT).when(mockListener).messageRead(any(InputStream.class));
+    RuntimeException expectedT = new RuntimeException();
+    doThrow(expectedT).when(mockListener)
+        .messagesAvailable(any(StreamListener.MessageProducer.class));
     // Closing the InputStream is done by the delegated listener (generally ServerCallImpl)
-    listener.messageRead(mock(InputStream.class));
+    listener.messagesAvailable(mock(StreamListener.MessageProducer.class));
     try {
       executor.runDueTasks();
       fail("Expected exception");
-    } catch (Throwable t) {
+    } catch (RuntimeException t) {
       assertSame(expectedT, t);
-      verify(stream).close(statusCaptor.capture(), any(Metadata.class));
-      assertSame(expectedT, statusCaptor.getValue().getCause());
+      ensureServerStateNotLeaked();
     }
   }
 
@@ -966,20 +1371,23 @@ public void messageRead_runtimeExceptionCancelsCall() throws Exception {
   public void halfClosed_errorCancelsCall() {
     JumpToApplicationThreadServerStreamListener listener
         = new JumpToApplicationThreadServerStreamListener(
-            executor.getScheduledExecutorService(), stream, Context.ROOT.withCancellation());
+            executor.getScheduledExecutorService(),
+            executor.getScheduledExecutorService(),
+            stream,
+            Context.ROOT.withCancellation(),
+            PerfMark.createTag());
     ServerStreamListener mockListener = mock(ServerStreamListener.class);
     listener.setListener(mockListener);
 
-    Throwable expectedT = new AssertionError();
+    TestError expectedT = new TestError();
     doThrow(expectedT).when(mockListener).halfClosed();
     listener.halfClosed();
     try {
       executor.runDueTasks();
       fail("Expected exception");
-    } catch (Throwable t) {
+    } catch (TestError t) {
       assertSame(expectedT, t);
-      verify(stream).close(statusCaptor.capture(), any(Metadata.class));
-      assertSame(expectedT, statusCaptor.getValue().getCause());
+      ensureServerStateNotLeaked();
     }
   }
 
@@ -987,20 +1395,23 @@ public void halfClosed_errorCancelsCall() {
   public void halfClosed_runtimeExceptionCancelsCall() {
     JumpToApplicationThreadServerStreamListener listener
         = new JumpToApplicationThreadServerStreamListener(
-            executor.getScheduledExecutorService(), stream, Context.ROOT.withCancellation());
+            executor.getScheduledExecutorService(),
+            executor.getScheduledExecutorService(),
+            stream,
+            Context.ROOT.withCancellation(),
+            PerfMark.createTag());
     ServerStreamListener mockListener = mock(ServerStreamListener.class);
     listener.setListener(mockListener);
 
-    Throwable expectedT = new RuntimeException();
+    RuntimeException expectedT = new RuntimeException();
     doThrow(expectedT).when(mockListener).halfClosed();
     listener.halfClosed();
     try {
       executor.runDueTasks();
       fail("Expected exception");
-    } catch (Throwable t) {
+    } catch (RuntimeException t) {
       assertSame(expectedT, t);
-      verify(stream).close(statusCaptor.capture(), any(Metadata.class));
-      assertSame(expectedT, statusCaptor.getValue().getCause());
+      ensureServerStateNotLeaked();
     }
   }
 
@@ -1008,20 +1419,23 @@ public void halfClosed_runtimeExceptionCancelsCall() {
   public void onReady_errorCancelsCall() {
     JumpToApplicationThreadServerStreamListener listener
         = new JumpToApplicationThreadServerStreamListener(
-            executor.getScheduledExecutorService(), stream, Context.ROOT.withCancellation());
+            executor.getScheduledExecutorService(),
+            executor.getScheduledExecutorService(),
+            stream,
+            Context.ROOT.withCancellation(),
+            PerfMark.createTag());
     ServerStreamListener mockListener = mock(ServerStreamListener.class);
     listener.setListener(mockListener);
 
-    Throwable expectedT = new AssertionError();
+    TestError expectedT = new TestError();
     doThrow(expectedT).when(mockListener).onReady();
     listener.onReady();
     try {
       executor.runDueTasks();
       fail("Expected exception");
-    } catch (Throwable t) {
+    } catch (TestError t) {
       assertSame(expectedT, t);
-      verify(stream).close(statusCaptor.capture(), any(Metadata.class));
-      assertSame(expectedT, statusCaptor.getValue().getCause());
+      ensureServerStateNotLeaked();
     }
   }
 
@@ -1029,52 +1443,138 @@ public void onReady_errorCancelsCall() {
   public void onReady_runtimeExceptionCancelsCall() {
     JumpToApplicationThreadServerStreamListener listener
         = new JumpToApplicationThreadServerStreamListener(
-            executor.getScheduledExecutorService(), stream, Context.ROOT.withCancellation());
+            executor.getScheduledExecutorService(),
+            executor.getScheduledExecutorService(),
+            stream,
+            Context.ROOT.withCancellation(),
+            PerfMark.createTag());
     ServerStreamListener mockListener = mock(ServerStreamListener.class);
     listener.setListener(mockListener);
 
-    Throwable expectedT = new RuntimeException();
+    RuntimeException expectedT = new RuntimeException();
     doThrow(expectedT).when(mockListener).onReady();
     listener.onReady();
     try {
       executor.runDueTasks();
       fail("Expected exception");
-    } catch (Throwable t) {
+    } catch (RuntimeException t) {
       assertSame(expectedT, t);
-      verify(stream).close(statusCaptor.capture(), any(Metadata.class));
-      assertSame(expectedT, statusCaptor.getValue().getCause());
+      ensureServerStateNotLeaked();
     }
   }
 
-  private void createAndStartServer(List<ServerTransportFilter> filters) throws IOException {
-    createServer(filters);
+  @Test
+  public void binaryLogInstalled() throws Exception {
+    final SettableFuture<Boolean> intercepted = SettableFuture.create();
+    final ServerInterceptor interceptor = new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+          Metadata headers,
+          ServerCallHandler<ReqT, RespT> next) {
+        intercepted.set(true);
+        return next.startCall(call, headers);
+      }
+    };
+
+    builder.binlog = new BinaryLog() {
+      @Override
+      public void close() throws IOException {
+        // noop
+      }
+
+      @Override
+      public <ReqT, RespT> ServerMethodDefinition<?, ?> wrapMethodDefinition(
+          ServerMethodDefinition<ReqT, RespT> oMethodDef) {
+        return ServerMethodDefinition.create(
+            oMethodDef.getMethodDescriptor(),
+            InternalServerInterceptors.interceptCallHandlerCreate(
+                interceptor,
+                oMethodDef.getServerCallHandler()));
+      }
+
+      @Override
+      public Channel wrapChannel(Channel channel) {
+        return channel;
+      }
+    };
+    createAndStartServer();
+    basicExchangeHelper(METHOD, "Lots of pizza, please", 314, 50);
+    assertTrue(intercepted.get());
+  }
+
+  @Test
+  public void channelz_membership() throws Exception {
+    createServer();
+    assertTrue(builder.channelz.containsServer(server.getLogId()));
+    server.shutdownNow().awaitTermination();
+    assertFalse(builder.channelz.containsServer(server.getLogId()));
+  }
+
+  @Test
+  public void channelz_serverStats() throws Exception {
+    createAndStartServer();
+    assertEquals(0, server.getStats().get().callsSucceeded);
+    basicExchangeHelper(METHOD, "Lots of pizza, please", 314, null);
+    assertEquals(1, server.getStats().get().callsSucceeded);
+  }
+
+  @Test
+  public void channelz_transport_membershp() throws Exception {
+    createAndStartServer();
+    SimpleServerTransport transport = new SimpleServerTransport();
+
+    ServerSocketsList before = builder.channelz
+        .getServerSockets(id(server), id(transport), /*maxPageSize=*/ 1);
+    assertThat(before.sockets).isEmpty();
+    assertTrue(before.end);
+
+    ServerTransportListener listener
+        = transportServer.registerNewServerTransport(transport);
+    ServerSocketsList added = builder.channelz
+        .getServerSockets(id(server), id(transport), /*maxPageSize=*/ 1);
+    assertThat(added.sockets).containsExactly(transport);
+    assertTrue(before.end);
+
+    listener.transportTerminated();
+    ServerSocketsList after = builder.channelz
+        .getServerSockets(id(server), id(transport), /*maxPageSize=*/ 1);
+    assertThat(after.sockets).isEmpty();
+    assertTrue(after.end);
+  }
+
+  private void createAndStartServer() throws IOException {
+    createServer();
     server.start();
   }
 
-  private void createServer(List<ServerTransportFilter> filters) {
+  private void createServer() {
     assertNull(server);
-    server = new ServerImpl(executorPool, timerPool, registry, fallbackRegistry,
-        transportServer, SERVER_CONTEXT, decompressorRegistry, compressorRegistry, filters,
-        statsCtxFactory, GrpcUtil.STOPWATCH_SUPPLIER);
+
+    builder.fallbackHandlerRegistry(fallbackRegistry);
+    builder.executorPool = executorPool;
+    server = new ServerImpl(builder, transportServer, SERVER_CONTEXT);
   }
 
   private void verifyExecutorsAcquired() {
     verify(executorPool).getObject();
-    verify(timerPool).getObject();
     verifyNoMoreInteractions(executorPool);
-    verifyNoMoreInteractions(timerPool);
   }
 
   private void verifyExecutorsNotReturned() {
     verify(executorPool, never()).returnObject(any(Executor.class));
-    verify(timerPool, never()).returnObject(any(ScheduledExecutorService.class));
   }
 
   private void verifyExecutorsReturned() {
     verify(executorPool).returnObject(same(executor.getScheduledExecutorService()));
-    verify(timerPool).returnObject(same(timer.getScheduledExecutorService()));
     verifyNoMoreInteractions(executorPool);
-    verifyNoMoreInteractions(timerPool);
+  }
+
+  private void ensureServerStateNotLeaked() {
+    verify(stream).close(statusCaptor.capture(), metadataCaptor.capture());
+    assertEquals(Status.UNKNOWN.getCode(), statusCaptor.getValue().getCode());
+    // Used in InProcessTransport when set to include the cause with the status
+    assertNotNull(statusCaptor.getValue().getCause());
+    assertTrue(metadataCaptor.getValue().keys().isEmpty());
   }
 
   private static class SimpleServer implements io.grpc.internal.InternalServer {
@@ -1086,8 +1586,23 @@ public void start(ServerListener listener) throws IOException {
     }
 
     @Override
-    public int getPort() {
-      return -1;
+    public SocketAddress getListenSocketAddress() {
+      return new InetSocketAddress(12345);
+    }
+
+    @Override
+    public List<InetSocketAddress> getListenSocketAddresses() {
+      return Collections.singletonList(new InetSocketAddress(12345));
+    }
+
+    @Override
+    public InternalInstrumented<SocketStats> getListenSocketStats() {
+      return null;
+    }
+
+    @Override
+    public List<InternalInstrumented<SocketStats>> getListenSocketStatsList() {
+      return null;
     }
 
     @Override
@@ -1100,8 +1615,9 @@ public ServerTransportListener registerNewServerTransport(SimpleServerTransport
     }
   }
 
-  private static class SimpleServerTransport implements ServerTransport {
+  private class SimpleServerTransport implements ServerTransport {
     ServerTransportListener listener;
+    InternalLogId id = InternalLogId.allocate(getClass(), /*details=*/ null);
 
     @Override
     public void shutdown() {
@@ -1114,8 +1630,43 @@ public void shutdownNow(Status status) {
     }
 
     @Override
-    public LogId getLogId() {
-      throw new UnsupportedOperationException();
+    public InternalLogId getLogId() {
+      return id;
+    }
+
+    @Override
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return timer.getScheduledExecutorService();
+    }
+
+    @Override
+    public ListenableFuture<SocketStats> getStats() {
+      SettableFuture<SocketStats> ret = SettableFuture.create();
+      ret.set(null);
+      return ret;
+    }
+  }
+
+  /** Allows more precise catch blocks than plain Error to avoid catching AssertionError. */
+  private static final class TestError extends Error {}
+
+  private static class SingleExecutor implements Executor {
+    private Runnable runnable;
+
+    @Override
+    public void execute(Runnable r) {
+      if (runnable != null) {
+        fail("Already have runnable scheduled");
+      }
+      runnable = r;
+    }
+
+    public void drain() {
+      if (runnable != null) {
+        Runnable r = runnable;
+        runnable = null;
+        r.run();
+      }
     }
   }
 }
diff --git a/core/src/test/java/io/grpc/internal/ServiceConfigErrorHandlingTest.java b/core/src/test/java/io/grpc/internal/ServiceConfigErrorHandlingTest.java
new file mode 100644
index 00000000000..0daee676b82
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ServiceConfigErrorHandlingTest.java
@@ -0,0 +1,698 @@
+/*
+ * Copyright 2019 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.internal;
+
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static io.grpc.internal.UriWrapper.wrap;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import io.grpc.Attributes;
+import io.grpc.ClientInterceptor;
+import io.grpc.ConnectivityState;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalConfigSelector;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.NameResolverProvider;
+import io.grpc.Status;
+import io.grpc.internal.ManagedChannelImplBuilder.FixedPortProvider;
+import io.grpc.internal.ManagedChannelImplBuilder.UnsupportedClientTransportFactoryBuilder;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for ServiceConfig error handling. */
+@RunWith(JUnit4.class)
+// TODO(creamsoup) remove backward compatible check when fully migrated
+@SuppressWarnings("deprecation")
+public class ServiceConfigErrorHandlingTest {
+
+  private static final int DEFAULT_PORT = 447;
+  private static final long RECONNECT_BACKOFF_INTERVAL_NANOS = 10;
+  private static final String SERVICE_NAME = "fake.example.com";
+  private static final String USER_AGENT = "userAgent";
+  private static final String TARGET = "fake://" + SERVICE_NAME;
+  private static final String MOCK_POLICY_NAME = "mock_lb";
+  private URI expectedUri;
+  private final SocketAddress socketAddress =
+      new SocketAddress() {
+        @Override
+        public String toString() {
+          return "test-addr";
+        }
+      };
+  private final EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(socketAddress);
+  private final FakeClock timer = new FakeClock();
+  private final FakeClock executor = new FakeClock();
+  private static final FakeClock.TaskFilter NAME_RESOLVER_REFRESH_TASK_FILTER =
+      new FakeClock.TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable command) {
+          return command.toString().contains(
+              RetryingNameResolver.DelayedNameResolverRefresh.class.getName());
+        }
+      };
+
+  private final InternalChannelz channelz = new InternalChannelz();
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private ManagedChannelImpl channel;
+  private final AtomicReference<Status> nextLbPolicyConfigError = new AtomicReference<>();
+
+  private FakeLoadBalancer mockLoadBalancer =
+      mock(FakeLoadBalancer.class, delegatesTo(new FakeLoadBalancer()));
+
+  private final LoadBalancerProvider mockLoadBalancerProvider =
+      mock(LoadBalancerProvider.class, delegatesTo(new LoadBalancerProvider() {
+        @Override
+        public LoadBalancer newLoadBalancer(final Helper helper) {
+          mockLoadBalancer.setHelper(helper);
+          return mockLoadBalancer;
+        }
+
+        @Override
+        public boolean isAvailable() {
+          return true;
+        }
+
+        @Override
+        public int getPriority() {
+          return 999;
+        }
+
+        @Override
+        public String getPolicyName() {
+          return MOCK_POLICY_NAME;
+        }
+
+        @Override
+        public ConfigOrError parseLoadBalancingPolicyConfig(
+            Map<String, ?> rawLoadBalancingPolicyConfig) {
+          if (nextLbPolicyConfigError.get() != null) {
+            return ConfigOrError.fromError(nextLbPolicyConfigError.get());
+          }
+          return ConfigOrError.fromConfig(rawLoadBalancingPolicyConfig.get("check"));
+        }
+      }));
+
+  @Mock
+  private ClientTransportFactory mockTransportFactory;
+  @Mock
+  private ObjectPool<Executor> executorPool;
+  @Mock
+  private ObjectPool<Executor> balancerRpcExecutorPool;
+  @Mock
+  private Executor blockingExecutor;
+  private ManagedChannelImplBuilder channelBuilder;
+
+  private void createChannel(ClientInterceptor... interceptors) {
+    checkState(channel == null);
+
+    when(mockTransportFactory.getSupportedSocketAddressTypes()).thenReturn(Collections.singleton(
+        InetSocketAddress.class));
+    NameResolverProvider nameResolverProvider =
+        channelBuilder.nameResolverRegistry.getProviderForScheme(expectedUri.getScheme());
+    channel =
+        new ManagedChannelImpl(
+            channelBuilder,
+            mockTransportFactory,
+            wrap(expectedUri),
+            nameResolverProvider,
+            new FakeBackoffPolicyProvider(),
+            balancerRpcExecutorPool,
+            timer.getStopwatchSupplier(),
+            Arrays.asList(interceptors),
+            timer.getTimeProvider());
+
+    int numExpectedTasks = 0;
+
+    // Force-exit the initial idle-mode
+    channel.syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        channel.exitIdleMode();
+      }
+    });
+    if (channelBuilder.idleTimeoutMillis != ManagedChannelImpl.IDLE_TIMEOUT_MILLIS_DISABLE) {
+      numExpectedTasks += 1;
+    }
+
+    if (getNameResolverRefresh() != null) {
+      numExpectedTasks += 1;
+    }
+
+    assertEquals(numExpectedTasks, timer.numPendingTasks());
+    ArgumentCaptor<Helper> helperCaptor = ArgumentCaptor.forClass(Helper.class);
+    verify(mockLoadBalancerProvider).newLoadBalancer(helperCaptor.capture());
+  }
+
+  @Before
+  public void setUp() throws Exception {
+    mockLoadBalancer.setAddressAcceptanceStatus(Status.OK);
+    LoadBalancerRegistry.getDefaultRegistry().register(mockLoadBalancerProvider);
+    expectedUri = new URI(TARGET);
+    when(mockTransportFactory.getScheduledExecutorService())
+        .thenReturn(timer.getScheduledExecutorService());
+    when(executorPool.getObject()).thenReturn(executor.getScheduledExecutorService());
+
+    channelBuilder = new ManagedChannelImplBuilder(TARGET,
+        new UnsupportedClientTransportFactoryBuilder(), new FixedPortProvider(DEFAULT_PORT));
+
+    channelBuilder
+        .nameResolverFactory(new FakeNameResolverFactory.Builder(expectedUri).build())
+        .defaultLoadBalancingPolicy(MOCK_POLICY_NAME)
+        .userAgent(USER_AGENT)
+        .idleTimeout(ManagedChannelImplBuilder.IDLE_MODE_MAX_TIMEOUT_DAYS, TimeUnit.DAYS)
+        .offloadExecutor(blockingExecutor);
+    channelBuilder.executorPool = executorPool;
+    channelBuilder.binlog = null;
+    channelBuilder.channelz = channelz;
+  }
+
+  @After
+  public void allPendingTasksAreRun() throws Exception {
+    // The "never" verifications in the tests only hold up if all due tasks are done.
+    // As for timer, although there may be scheduled tasks in a future time, since we don't test
+    // any time-related behavior in this test suite, we only care the tasks that are due. This
+    // would ignore any time-sensitive tasks, e.g., back-off and the idle timer.
+    assertTrue(timer.getDueTasks() + " should be empty", timer.getDueTasks().isEmpty());
+    assertEquals(executor.getPendingTasks() + " should be empty", 0, executor.numPendingTasks());
+    if (channel != null) {
+      channel.shutdownNow();
+      channel = null;
+    }
+  }
+
+  @After
+  public void cleanUp() {
+    LoadBalancerRegistry.getDefaultRegistry().deregister(mockLoadBalancerProvider);
+  }
+
+  @Test
+  public void emptyAddresses_validConfig_firstResolution_lbNeedsAddress() throws Exception {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.emptyList())
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+
+    Map<String, Object> rawServiceConfig =
+        parseJson("{\"loadBalancingConfig\": [{\"round_robin\": {}}]}");
+    nameResolverFactory.nextRawServiceConfig.set(rawServiceConfig);
+
+    createChannel();
+
+    assertThat(channel.getState(true)).isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+    assertWithMessage("Empty address should schedule NameResolver retry")
+        .that(getNameResolverRefresh())
+        .isNotNull();
+  }
+
+  @Test
+  public void emptyAddresses_validConfig_2ndResolution_lbNeedsAddress() throws Exception {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(new ArrayList<>(ImmutableList.of(addressGroup)))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+
+    Map<String, Object> rawServiceConfig =
+        parseJson("{\"loadBalancingConfig\": [{\"mock_lb\": {\"check\": \"12\"}}]}");
+    nameResolverFactory.nextRawServiceConfig.set(rawServiceConfig);
+
+    createChannel();
+
+    ArgumentCaptor<ResolvedAddresses> resultCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+    ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
+    assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
+    assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("12");
+    verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+
+    assertThat(channel.getState(true)).isEqualTo(ConnectivityState.CONNECTING);
+
+    reset(mockLoadBalancer);
+    nameResolverFactory.servers.clear();
+
+    // 2nd resolution
+    mockLoadBalancer.setAddressAcceptanceStatus(Status.UNAVAILABLE);
+    nameResolverFactory.allResolved();
+
+    // 2nd service config without addresses
+    verify(mockLoadBalancer).acceptResolvedAddresses(any(ResolvedAddresses.class));
+
+    // A resolution retry has been scheduled
+    assertEquals(1, timer.numPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER));
+  }
+
+  @Test
+  public void emptyAddresses_validConfig_lbDoesNotNeedAddress() throws Exception {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(Collections.emptyList())
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+
+    Map<String, Object> rawServiceConfig =
+        parseJson("{\"loadBalancingConfig\": [{\"mock_lb\": {\"check\": \"val\"}}]}");
+    nameResolverFactory.nextRawServiceConfig.set(rawServiceConfig);
+
+    createChannel();
+
+    ArgumentCaptor<ResolvedAddresses> resultCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+
+    ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
+    assertThat(resolvedAddresses.getAddresses()).isEmpty();
+    assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("val");
+
+    verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+    assertThat(channel.getState(false)).isNotEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+  }
+
+  @Test
+  public void validConfig_lbDoesNotNeedAddress() throws Exception {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(ImmutableList.of(addressGroup))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+
+    Map<String, Object> rawServiceConfig =
+        parseJson("{\"loadBalancingConfig\": [{\"mock_lb\": {\"check\": \"foo\"}}]}");
+    nameResolverFactory.nextRawServiceConfig.set(rawServiceConfig);
+
+    createChannel();
+
+    ArgumentCaptor<ResolvedAddresses> resultCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+    ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
+    assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
+    assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("foo");
+    verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+
+    assertThat(channel.getState(false)).isNotEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+  }
+
+  @Test
+  public void noConfig_noDefaultConfig() {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(ImmutableList.of(addressGroup))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    nameResolverFactory.nextRawServiceConfig.set(null);
+
+    createChannel();
+
+    ArgumentCaptor<ResolvedAddresses> resultCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+    ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
+    assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
+    assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isNull();
+    verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+
+    assertThat(channel.getState(false)).isNotEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+  }
+
+  @Test
+  public void noConfig_usingDefaultConfig() throws Exception {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(ImmutableList.of(addressGroup))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    Map<String, Object> defaultServiceConfig =
+        parseJson("{\"loadBalancingConfig\": [{\"mock_lb\": {\"check\": \"foo\"}}]}");
+    channelBuilder.defaultServiceConfig(defaultServiceConfig);
+
+    nameResolverFactory.nextRawServiceConfig.set(null);
+
+    createChannel();
+
+    ArgumentCaptor<ResolvedAddresses> resultCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+    ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
+    assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
+    assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("foo");
+    verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+    assertThat(channel.getState(false)).isNotEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+  }
+
+  @Test
+  public void invalidConfig_noDefaultConfig() throws Exception {
+    Status error = Status.NOT_FOUND.withDescription("service config error");
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(ImmutableList.of(addressGroup))
+            .build();
+    nameResolverFactory.nextRawServiceConfig.set(
+        parseJson("{\"loadBalancingConfig\": [{\"mock_lb\": {\"no_check\": \"foo\"}}]}"));
+    nextLbPolicyConfigError.set(error);
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+
+    createChannel();
+
+    ArgumentCaptor<Status> statusCaptor =
+        ArgumentCaptor.forClass(Status.class);
+    verify(mockLoadBalancer).handleNameResolutionError(statusCaptor.capture());
+    assertThat(statusCaptor.getValue()).isEqualTo(error);
+
+    assertThat(channel.getState(true)).isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+  }
+
+  @Test
+  public void invalidConfig_withDefaultConfig() throws Exception {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(ImmutableList.of(addressGroup))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    Map<String, Object> defaultServiceConfig =
+        parseJson("{\"loadBalancingConfig\": [{\"mock_lb\": {\"check\": \"mate\"}}]}");
+    channelBuilder.defaultServiceConfig(defaultServiceConfig);
+
+    createChannel();
+
+    ArgumentCaptor<ResolvedAddresses> resultCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+
+    ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
+    assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
+    assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("mate");
+    verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+
+    assertThat(channel.getState(false)).isNotEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+  }
+
+  @Test
+  public void invalidConfig_2ndResolution() throws Exception {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(ImmutableList.of(addressGroup))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+
+    Map<String, Object> rawServiceConfig =
+        parseJson("{\"loadBalancingConfig\": [{\"mock_lb\": {\"check\": \"1st raw config\"}}]}");
+    nameResolverFactory.nextRawServiceConfig.set(rawServiceConfig);
+    InternalConfigSelector configSelector = mock(InternalConfigSelector.class);
+    nameResolverFactory.nextAttributes.set(
+        Attributes.newBuilder()
+            .set(InternalConfigSelector.KEY, configSelector)
+            .build());
+
+    createChannel();
+
+    ArgumentCaptor<ResolvedAddresses> resultCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+    ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
+    assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
+    assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("1st raw config");
+    assertThat(channel.getConfigSelector()).isSameInstanceAs(configSelector);
+    verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+
+    assertThat(channel.getState(false)).isNotEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+
+    reset(mockLoadBalancer);
+
+    // 2nd resolution lbConfig is error
+    nextLbPolicyConfigError.set(Status.UNKNOWN);
+    nameResolverFactory.allResolved();
+
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+    ResolvedAddresses newResolvedAddress = resultCaptor.getValue();
+    // should use previous service config because new service config is invalid.
+    assertThat(newResolvedAddress.getLoadBalancingPolicyConfig()).isEqualTo("1st raw config");
+    assertThat(channel.getConfigSelector()).isSameInstanceAs(configSelector);
+    verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+    assertThat(channel.getState(false)).isEqualTo(ConnectivityState.CONNECTING);
+  }
+
+  @Test
+  public void validConfig_thenNoConfig_withDefaultConfig() throws Exception {
+    FakeNameResolverFactory nameResolverFactory =
+        new FakeNameResolverFactory.Builder(expectedUri)
+            .setServers(ImmutableList.of(addressGroup))
+            .build();
+    channelBuilder.nameResolverFactory(nameResolverFactory);
+    Map<String, Object> defaultServiceConfig =
+        parseJson("{\"loadBalancingConfig\": [{\"mock_lb\": {\"check\": \"mate\"}}]}");
+    channelBuilder.defaultServiceConfig(defaultServiceConfig);
+
+    Map<String, Object> rawServiceConfig =
+        parseJson("{\"loadBalancingConfig\": [{\"mock_lb\": {\"check\": \"1st raw config\"}}]}");
+    nameResolverFactory.nextRawServiceConfig.set(rawServiceConfig);
+    InternalConfigSelector configSelector = mock(InternalConfigSelector.class);
+    nameResolverFactory.nextAttributes.set(
+        Attributes.newBuilder()
+            .set(InternalConfigSelector.KEY, configSelector)
+            .build());
+
+    createChannel();
+
+    ArgumentCaptor<ResolvedAddresses> resultCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    verify(mockLoadBalancer).acceptResolvedAddresses(resultCaptor.capture());
+    ResolvedAddresses resolvedAddresses = resultCaptor.getValue();
+    assertThat(resolvedAddresses.getAddresses()).containsExactly(addressGroup);
+    // should use previous service config because new resolution result is no config.
+    assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo("1st raw config");
+    assertThat(channel.getConfigSelector()).isSameInstanceAs(configSelector);
+    verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+
+    // 2nd resolution lbConfig is no config
+    nameResolverFactory.nextRawServiceConfig.set(null);
+    nameResolverFactory.allResolved();
+
+    verify(mockLoadBalancer, times(2)).acceptResolvedAddresses(resultCaptor.capture());
+    ResolvedAddresses newResolvedAddress = resultCaptor.getValue();
+    assertThat(newResolvedAddress.getLoadBalancingPolicyConfig()).isEqualTo("mate");
+    assertThat(newResolvedAddress.getAttributes().get(InternalConfigSelector.KEY))
+        .isNull();
+    verify(mockLoadBalancer, never()).handleNameResolutionError(any(Status.class));
+  }
+
+  private static final class FakeBackoffPolicyProvider implements BackoffPolicy.Provider {
+    @Override
+    public BackoffPolicy get() {
+      return new BackoffPolicy() {
+        int multiplier = 1;
+
+        @Override
+        public long nextBackoffNanos() {
+          return RECONNECT_BACKOFF_INTERVAL_NANOS * multiplier++;
+        }
+      };
+    }
+  }
+
+  private static final class FakeNameResolverFactory extends NameResolver.Factory {
+    final URI expectedUri;
+    final List<EquivalentAddressGroup> servers;
+    final boolean resolvedAtStart;
+    final ArrayList<FakeNameResolver> resolvers = new ArrayList<>();
+    final AtomicReference<Map<String, ?>> nextRawServiceConfig = new AtomicReference<>();
+    final AtomicReference<Attributes> nextAttributes = new AtomicReference<>(Attributes.EMPTY);
+
+    FakeNameResolverFactory(
+        URI expectedUri,
+        List<EquivalentAddressGroup> servers,
+        boolean resolvedAtStart) {
+      this.expectedUri = expectedUri;
+      this.servers = servers;
+      this.resolvedAtStart = resolvedAtStart;
+    }
+
+    @Override
+    public NameResolver newNameResolver(final URI targetUri, NameResolver.Args args) {
+      if (!expectedUri.equals(targetUri)) {
+        return null;
+      }
+      assertEquals(DEFAULT_PORT, args.getDefaultPort());
+      FakeNameResolver resolver = new FakeNameResolver(args.getServiceConfigParser());
+      resolvers.add(resolver);
+      return resolver;
+    }
+
+    @Override
+    public String getDefaultScheme() {
+      return "fake";
+    }
+
+    void allResolved() {
+      for (FakeNameResolver resolver : resolvers) {
+        resolver.resolved();
+      }
+    }
+
+    final class FakeNameResolver extends NameResolver {
+
+      final ServiceConfigParser serviceConfigParser;
+      Listener2 listener;
+
+      FakeNameResolver(ServiceConfigParser serviceConfigParser) {
+        this.serviceConfigParser = serviceConfigParser;
+      }
+
+      @Override public String getServiceAuthority() {
+        return expectedUri.getAuthority();
+      }
+
+      @Override public void start(Listener2 listener) {
+        this.listener = listener;
+        if (resolvedAtStart) {
+          resolved();
+        }
+      }
+
+      @Override public void refresh() {
+        resolved();
+      }
+
+      void resolved() {
+        Map<String, ?> rawServiceConfig = nextRawServiceConfig.get();
+        ResolutionResult.Builder builder =
+            ResolutionResult.newBuilder().setAddresses(servers).setAttributes(nextAttributes.get());
+        if (rawServiceConfig != null) {
+          builder
+              .setServiceConfig(serviceConfigParser.parseServiceConfig(rawServiceConfig));
+        }
+
+        listener.onResult(builder.build());
+      }
+
+      @Override public void shutdown() {
+      }
+
+      @Override
+      public String toString() {
+        return "FakeNameResolver";
+      }
+    }
+
+    static final class Builder {
+      final URI expectedUri;
+      List<EquivalentAddressGroup> servers = ImmutableList.of();
+      boolean resolvedAtStart = true;
+
+      Builder(URI expectedUri) {
+        this.expectedUri = expectedUri;
+      }
+
+      Builder setServers(List<EquivalentAddressGroup> servers) {
+        this.servers = servers;
+        return this;
+      }
+
+      FakeNameResolverFactory build() {
+        return new FakeNameResolverFactory(expectedUri, servers, resolvedAtStart);
+      }
+    }
+  }
+
+  private FakeClock.ScheduledTask getNameResolverRefresh() {
+    return Iterables.getOnlyElement(
+       timer.getPendingTasks(NAME_RESOLVER_REFRESH_TASK_FILTER), null);
+  }
+
+  private static class FakeLoadBalancer extends LoadBalancer {
+
+    private Status addressAcceptanceStatus = Status.OK;
+
+    @Nullable
+    private Helper helper;
+
+    public void setHelper(Helper helper) {
+      this.helper = helper;
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      return addressAcceptanceStatus;
+    }
+
+    public void setAddressAcceptanceStatus(Status addressAcceptanceStatus) {
+      this.addressAcceptanceStatus = addressAcceptanceStatus;
+    }
+
+    @Override
+    public void handleNameResolutionError(final Status error) {
+      helper.updateBalancingState(ConnectivityState.TRANSIENT_FAILURE,
+          new SubchannelPicker() {
+            @Override
+            public PickResult pickSubchannel(PickSubchannelArgs args) {
+              return PickResult.withError(error);
+            }
+          });
+    }
+
+    @Override
+    public void shutdown() {}
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, Object> parseJson(String json) throws Exception {
+    return (Map<String, Object>) JsonParser.parse(json);
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ServiceConfigStateTest.java b/core/src/test/java/io/grpc/internal/ServiceConfigStateTest.java
new file mode 100644
index 00000000000..4390ff44ea3
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ServiceConfigStateTest.java
@@ -0,0 +1,456 @@
+/*
+ * Copyright 2019 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.ManagedChannelServiceConfig.MethodInfo;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link ServiceConfigState}.
+ */
+@RunWith(JUnit4.class)
+public class ServiceConfigStateTest {
+
+  private final ManagedChannelServiceConfig serviceConfig1 = new ManagedChannelServiceConfig(
+      null,
+      Collections.<String, MethodInfo>emptyMap(),
+      Collections.<String, MethodInfo>emptyMap(),
+      null,
+      null,
+      null);
+  private final ManagedChannelServiceConfig serviceConfig2 = new ManagedChannelServiceConfig(
+      null,
+      Collections.<String, MethodInfo>emptyMap(),
+      Collections.<String, MethodInfo>emptyMap(),
+      null,
+      null,
+      null);
+  private final ConfigOrError config1 = ConfigOrError.fromConfig(serviceConfig1);
+  private final ConfigOrError config2 = ConfigOrError.fromConfig(serviceConfig2);
+  private final Status serviceConfigError1 = Status.UNKNOWN.withDescription("bang");
+  private final Status serviceConfigError2 = Status.INTERNAL.withDescription("boom");
+  private final ConfigOrError error1 = ConfigOrError.fromError(serviceConfigError1);
+  private final ConfigOrError error2 = ConfigOrError.fromError(serviceConfigError2);
+  private final ManagedChannelServiceConfig noServiceConfig = null;
+  private final ConfigOrError noConfig = null;
+
+  @Test
+  public void noLookup_default() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, false);
+
+    assertFalse(scs.expectUpdates());
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSameConfig(config1, scs.getCurrent());
+  }
+
+  @Test
+  public void noLookup_default_allUpdatesFail() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, false);
+
+    try {
+      scs.update(error1);
+      fail();
+    } catch (IllegalStateException e) {
+      assertThat(e).hasMessageThat().contains("unexpected service config update");
+    }
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSameConfig(config1, scs.getCurrent());
+
+    try {
+      scs.update(error1);
+      fail();
+    } catch (IllegalStateException e) {
+      assertThat(e).hasMessageThat().contains("unexpected service config update");
+    }
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSameConfig(config1, scs.getCurrent());
+
+    try {
+      scs.update(noConfig);
+      fail();
+    } catch (IllegalStateException e) {
+      assertThat(e).hasMessageThat().contains("unexpected service config update");
+    }
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSameConfig(config1, scs.getCurrent());
+  }
+
+  @Test
+  public void noLookup_noDefault() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, false);
+
+    assertFalse(scs.expectUpdates());
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertNull(scs.getCurrent());
+  }
+
+  @Test
+  public void noLookup_noDefault_allUpdatesFail() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, false);
+
+    try {
+      scs.update(error1);
+      fail();
+    } catch (IllegalStateException e) {
+      assertThat(e).hasMessageThat().contains("unexpected service config update");
+    }
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertNull(scs.getCurrent());
+
+    try {
+      scs.update(config2);
+      fail();
+    } catch (IllegalStateException e) {
+      assertThat(e).hasMessageThat().contains("unexpected service config update");
+    }
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertNull(scs.getCurrent());
+
+    try {
+      scs.update(noConfig);
+      fail();
+    } catch (IllegalStateException e) {
+      assertThat(e).hasMessageThat().contains("unexpected service config update");
+    }
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertNull(scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_noDefault() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, true);
+
+    assertTrue(scs.expectUpdates());
+    assertTrue(scs.shouldWaitOnServiceConfig());
+    try {
+      scs.getCurrent();
+      fail();
+    } catch (IllegalStateException e) {
+      assertThat(e).hasMessageThat().contains("still waiting on service config");
+    }
+  }
+
+  @Test
+  public void lookup_noDefault_onError_onError() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, true);
+
+    scs.update(error1);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSame(error1, scs.getCurrent());
+
+    scs.update(error2);
+    assertSame(error2, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_noDefault_onError_onAbsent() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, true);
+
+    scs.update(error1);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSame(error1, scs.getCurrent());
+
+    scs.update(noConfig);
+    assertNull(scs.getCurrent());
+
+    scs.update(error2);
+    assertNull(scs.getCurrent()); //ignores future errors
+  }
+
+  @Test
+  public void lookup_noDefault_onError_onPresent() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, true);
+
+    scs.update(error1);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSame(error1, scs.getCurrent());
+
+    scs.update(config1);
+    assertSame(config1, scs.getCurrent());
+
+    scs.update(error2);
+    assertSame(config1, scs.getCurrent()); //ignores future errors
+  }
+
+  @Test
+  public void lookup_noDefault_onAbsent() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, true);
+
+    scs.update(noConfig);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertNull(scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_noDefault_onAbsent_onError() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, true);
+
+    scs.update(noConfig);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertNull(scs.getCurrent());
+
+    scs.update(error1);
+    assertNull(scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_noDefault_onAbsent_onAbsent() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, true);
+
+    scs.update(noConfig);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertNull(scs.getCurrent());
+
+    scs.update(noConfig);
+    assertNull(scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_noDefault_onAbsent_onPresent() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, true);
+
+    scs.update(noConfig);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertNull(scs.getCurrent());
+
+    scs.update(config1);
+    assertSame(config1, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_noDefault_onPresent() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, true);
+
+    scs.update(config1);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSame(config1, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_noDefault_onPresent_onError() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, true);
+
+    scs.update(config1);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSame(config1, scs.getCurrent());
+
+    scs.update(error1);
+    assertSame(config1, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_noDefault_onPresent_onAbsent() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, true);
+
+    scs.update(config1);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSame(config1, scs.getCurrent());
+
+    scs.update(noConfig);
+    assertNull(scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_noDefault_onPresent_onPresent() {
+    ServiceConfigState scs = new ServiceConfigState(noServiceConfig, true);
+
+    scs.update(config1);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSame(config1, scs.getCurrent());
+
+    scs.update(config2);
+    assertSame(config2, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_default() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, true);
+
+    assertTrue(scs.expectUpdates());
+    assertTrue(scs.shouldWaitOnServiceConfig());
+    try {
+      scs.getCurrent();
+      fail();
+    } catch (IllegalStateException e) {
+      assertThat(e).hasMessageThat().contains("still waiting on service config");
+    }
+  }
+
+  @Test
+  public void lookup_default_onError() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, true);
+
+    scs.update(error1);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSameConfig(config1, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_default_onError_onError() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, true);
+
+    scs.update(error1);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSameConfig(config1, scs.getCurrent());
+
+    scs.update(error2);
+    assertSameConfig(config1, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_default_onError_onAbsent() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, true);
+
+    scs.update(error1);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSameConfig(config1, scs.getCurrent());
+
+    scs.update(noConfig);
+    assertSameConfig(config1, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_default_onError_onPresent() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, true);
+
+    scs.update(error1);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSameConfig(config1, scs.getCurrent());
+
+    scs.update(config2);
+    assertSame(config2, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_default_onAbsent() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, true);
+
+    scs.update(noConfig);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSameConfig(config1, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_default_onAbsent_onError() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, true);
+
+    scs.update(noConfig);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSameConfig(config1, scs.getCurrent());
+
+    scs.update(error1);
+    assertSameConfig(config1, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_default_onAbsent_onAbsent() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, true);
+
+    scs.update(noConfig);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSameConfig(config1, scs.getCurrent());
+
+    scs.update(noConfig);
+    assertSameConfig(config1, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_default_onAbsent_onPresent() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, true);
+
+    scs.update(noConfig);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSameConfig(config1, scs.getCurrent());
+
+    scs.update(config2);
+    assertSame(config2, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_default_onPresent() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, true);
+
+    scs.update(config2);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSame(config2, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_default_onPresent_onError() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, true);
+
+    scs.update(config2);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSame(config2, scs.getCurrent());
+
+    scs.update(error1);
+    assertSame(config2, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_default_onPresent_onAbsent() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, true);
+
+    scs.update(config2);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSame(config2, scs.getCurrent());
+
+    scs.update(noConfig);
+    assertSameConfig(config1, scs.getCurrent());
+  }
+
+  @Test
+  public void lookup_default_onPresent_onPresent() {
+    ServiceConfigState scs = new ServiceConfigState(serviceConfig1, true);
+    ManagedChannelServiceConfig serviceConfig3 = new ManagedChannelServiceConfig(
+        null,
+        Collections.<String, MethodInfo>emptyMap(),
+        Collections.<String, MethodInfo>emptyMap(),
+        null,
+        null,
+        null);
+    ConfigOrError config3 = ConfigOrError.fromConfig(serviceConfig3);
+
+    scs.update(config2);
+    assertFalse(scs.shouldWaitOnServiceConfig());
+    assertSame(config2, scs.getCurrent());
+
+    scs.update(config3);
+    assertSame(config3, scs.getCurrent());
+  }
+
+  private static void assertSameConfig(ConfigOrError expected, ConfigOrError actual) {
+    if (actual == null || expected == null) {
+      assertSame(expected, actual);
+    }
+    assertWithMessage(actual.toString()).that(actual.getConfig())
+        .isSameInstanceAs(expected.getConfig());
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/ServiceConfigUtilTest.java b/core/src/test/java/io/grpc/internal/ServiceConfigUtilTest.java
new file mode 100644
index 00000000000..a49ae33f515
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/ServiceConfigUtilTest.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2019 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import io.grpc.internal.ServiceConfigUtil.LbConfig;
+import java.util.List;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit test for {@link ServiceConfigUtil}.
+ */
+@RunWith(JUnit4.class)
+public class ServiceConfigUtilTest {
+
+  @Test
+  public void unwrapLoadBalancingConfig() throws Exception {
+    String lbConfig = "{\"xds_experimental\" : { "
+        + "\"childPolicy\" : [{\"round_robin\" : {}}, {\"lbPolicy2\" : {\"key\" : \"val\"}}]"
+        + "}}";
+
+    LbConfig config =
+        ServiceConfigUtil.unwrapLoadBalancingConfig(checkObject(JsonParser.parse(lbConfig)));
+    assertThat(config.getPolicyName()).isEqualTo("xds_experimental");
+    assertThat(config.getRawConfigValue()).isEqualTo(JsonParser.parse(
+            "{\"childPolicy\" : [{\"round_robin\" : {}}, {\"lbPolicy2\" : {\"key\" : \"val\"}}]"
+            + "}"));
+  }
+
+  @Test
+  public void unwrapLoadBalancingConfig_failOnTooManyFields() throws Exception {
+    // A LoadBalancingConfig should not have more than one field.
+    String lbConfig = "{\"xds_experimental\" : { "
+        + "\"childPolicy\" : [{\"round_robin\" : {}}, {\"lbPolicy2\" : {\"key\" : \"val\"}}]"
+        + "},"
+        + "\"grpclb\" : {} }";
+    try {
+      ServiceConfigUtil.unwrapLoadBalancingConfig(checkObject(JsonParser.parse(lbConfig)));
+      fail("Should throw");
+    } catch (Exception e) {
+      assertThat(e).hasMessageThat().contains("There are 2 fields");
+    }
+  }
+
+  @Test
+  public void unwrapLoadBalancingConfig_failOnEmptyObject() throws Exception {
+    // A LoadBalancingConfig should not exactly one field.
+    String lbConfig = "{}";
+    try {
+      ServiceConfigUtil.unwrapLoadBalancingConfig(checkObject(JsonParser.parse(lbConfig)));
+      fail("Should throw");
+    } catch (Exception e) {
+      assertThat(e).hasMessageThat().contains("There are 0 fields");
+    }
+  }
+
+  @Test
+  public void unwrapLoadBalancingConfig_failWhenConfigIsString() throws Exception {
+    // The value of the config should be a JSON dictionary (map)
+    String lbConfig = "{ \"xds\" : \"I thought I was a config.\" }";
+    try {
+      ServiceConfigUtil.unwrapLoadBalancingConfig(checkObject(JsonParser.parse(lbConfig)));
+      fail("Should throw");
+    } catch (Exception e) {
+      assertThat(e).hasMessageThat().contains("is not object");
+    }
+  }
+
+  @Test
+  public void unwrapLoadBalancingConfigList() throws Exception {
+    String lbConfig = "[ "
+        + "{\"xds_experimental\" : {\"unknown_field\" : \"dns:///balancer.example.com:8080\"} },"
+        + "{\"grpclb\" : {} } ]";
+    List<LbConfig> configs =
+        ServiceConfigUtil.unwrapLoadBalancingConfigList(
+            checkObjectList(JsonParser.parse(lbConfig)));
+    assertThat(configs).containsExactly(
+        ServiceConfigUtil.unwrapLoadBalancingConfig(checkObject(JsonParser.parse(
+                "{\"xds_experimental\" : "
+                + "{\"unknown_field\" : \"dns:///balancer.example.com:8080\"} }"))),
+        ServiceConfigUtil.unwrapLoadBalancingConfig(checkObject(JsonParser.parse(
+                "{\"grpclb\" : {} }")))).inOrder();
+  }
+
+  @Test
+  public void unwrapLoadBalancingConfigList_failOnMalformedConfig() throws Exception {
+    String lbConfig = "[ "
+        + "{\"xds_experimental\" : \"I thought I was a config\" },"
+        + "{\"grpclb\" : {} } ]";
+    try {
+      ServiceConfigUtil.unwrapLoadBalancingConfigList(checkObjectList(JsonParser.parse(lbConfig)));
+      fail("Should throw");
+    } catch (Exception e) {
+      assertThat(e).hasMessageThat().contains("is not object");
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  private static List<Map<String, ?>> checkObjectList(Object o) {
+    return (List<Map<String, ?>>) o;
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, ?> checkObject(Object o) {
+    return (Map<String, ?>) o;
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/SharedResourceHolderTest.java b/core/src/test/java/io/grpc/internal/SharedResourceHolderTest.java
index adb56be6802..692b22a0a68 100644
--- a/core/src/test/java/io/grpc/internal/SharedResourceHolderTest.java
+++ b/core/src/test/java/io/grpc/internal/SharedResourceHolderTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
@@ -38,14 +23,16 @@
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyLong;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 import io.grpc.internal.SharedResourceHolder.Resource;
 import java.util.LinkedList;
+import java.util.concurrent.CyclicBarrier;
 import java.util.concurrent.Delayed;
+import java.util.concurrent.FutureTask;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
@@ -61,7 +48,7 @@
 public class SharedResourceHolderTest {
 
   private final LinkedList<MockScheduledFuture<?>> scheduledDestroyTasks =
-      new LinkedList<MockScheduledFuture<?>>();
+      new LinkedList<>();
 
   private SharedResourceHolder holder;
 
@@ -113,7 +100,7 @@ public void close(ResourceInstance instance) {
     assertEquals(SharedResourceHolder.DESTROY_DELAY_SECONDS,
         scheduledDestroyTask.getDelay(TimeUnit.SECONDS));
 
-    // Simluate that the destroyer executes the foo destroying task
+    // Simulate that the destroyer executes the foo destroying task
     scheduledDestroyTask.runTask();
     assertTrue(sharedFoo.closed);
 
@@ -121,7 +108,7 @@ public void close(ResourceInstance instance) {
     ResourceInstance foo3 = holder.getInternal(SHARED_FOO);
     assertNotSame(sharedFoo, foo3);
 
-    bar1 = holder.releaseInternal(SHARED_BAR, bar1);
+    holder.releaseInternal(SHARED_BAR, bar1);
 
     // bar refcount has reached 0, a destroying task is scheduled
     assertEquals(1, scheduledDestroyTasks.size());
@@ -137,7 +124,7 @@ public void close(ResourceInstance instance) {
   @Test public void cancelDestroyTask() {
     ResourceInstance foo1 = holder.getInternal(SHARED_FOO);
     ResourceInstance sharedFoo = foo1;
-    foo1 = holder.releaseInternal(SHARED_FOO, foo1);
+    holder.releaseInternal(SHARED_FOO, foo1);
     // A destroying task for foo is scheduled
     MockScheduledFuture<?> scheduledDestroyTask = scheduledDestroyTasks.poll();
     assertFalse(scheduledDestroyTask.cancelled);
@@ -152,7 +139,7 @@ public void close(ResourceInstance instance) {
     assertSame(sharedFoo, foo2);
 
     // Release it and the destroying task is scheduled again
-    foo2 = holder.releaseInternal(SHARED_FOO, foo2);
+    holder.releaseInternal(SHARED_FOO, foo2);
     scheduledDestroyTask = scheduledDestroyTasks.poll();
     assertFalse(scheduledDestroyTask.cancelled);
     scheduledDestroyTask.runTask();
@@ -188,6 +175,74 @@ public void close(ResourceInstance instance) {
     }
   }
 
+  @Test public void handleInstanceCloseError() {
+    class ExceptionOnCloseResource implements Resource<ResourceInstance> {
+      @Override
+      public ResourceInstance create() {
+        return new ResourceInstance();
+      }
+
+      @Override
+      public void close(ResourceInstance instance) {
+        throw new RuntimeException();
+      }
+    }
+
+    Resource<ResourceInstance> resource = new ExceptionOnCloseResource();
+    ResourceInstance instance = holder.getInternal(resource);
+    holder.releaseInternal(resource, instance);
+    MockScheduledFuture<?> scheduledDestroyTask = scheduledDestroyTasks.poll();
+    try {
+      scheduledDestroyTask.runTask();
+      fail("Should throw RuntimeException");
+    } catch (RuntimeException e) {
+      // expected
+    }
+
+    // Future resource fetches should not get the partially-closed one.
+    assertNotSame(instance, holder.getInternal(resource));
+  }
+
+  @Test(timeout = 5000)
+  public void closeRunsConcurrently() throws Exception {
+    CyclicBarrier barrier = new CyclicBarrier(2);
+    class SlowResource implements Resource<ResourceInstance> {
+      @Override
+      public ResourceInstance create() {
+        return new ResourceInstance();
+      }
+
+      @Override
+      public void close(ResourceInstance instance) {
+        instance.closed = true;
+        try {
+          barrier.await();
+          barrier.await();
+        } catch (Exception ex) {
+          throw new AssertionError(ex);
+        }
+      }
+    }
+
+    Resource<ResourceInstance> resource = new SlowResource();
+    ResourceInstance instance = holder.getInternal(resource);
+    holder.releaseInternal(resource, instance);
+    MockScheduledFuture<?> scheduledDestroyTask = scheduledDestroyTasks.poll();
+    FutureTask<Void> runTask = new FutureTask<>(scheduledDestroyTask::runTask, null);
+    Thread t = new Thread(runTask);
+    t.start();
+
+    barrier.await(); // Ensure the other thread has blocked
+    assertTrue(instance.closed);
+    instance = holder.getInternal(resource);
+    assertFalse(instance.closed);
+    holder.releaseInternal(resource, instance);
+
+    barrier.await(); // Resume the other thread
+    t.join();
+    runTask.get(); // Check for exception
+  }
+
   private class MockExecutorFactory implements
       SharedResourceHolder.ScheduledExecutorFactory {
     @Override
@@ -201,7 +256,7 @@ public MockScheduledFuture<Void> answer(InvocationOnMock invocation) {
               Runnable command = (Runnable) args[0];
               long delay = (Long) args[1];
               TimeUnit unit = (TimeUnit) args[2];
-              MockScheduledFuture<Void> future = new MockScheduledFuture<Void>(
+              MockScheduledFuture<Void> future = new MockScheduledFuture<>(
                   command, delay, unit);
               scheduledDestroyTasks.add(future);
               return future;
diff --git a/core/src/test/java/io/grpc/internal/SpiffeUtilTest.java b/core/src/test/java/io/grpc/internal/SpiffeUtilTest.java
new file mode 100644
index 00000000000..57824cf207f
--- /dev/null
+++ b/core/src/test/java/io/grpc/internal/SpiffeUtilTest.java
@@ -0,0 +1,388 @@
+/*
+ * Copyright 2024 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.internal;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.base.Optional;
+import com.google.common.io.ByteStreams;
+import io.grpc.internal.SpiffeUtil.SpiffeBundle;
+import io.grpc.internal.SpiffeUtil.SpiffeId;
+import io.grpc.testing.TlsTesting;
+import io.grpc.util.CertificateUtils;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.security.cert.X509Certificate;
+import java.util.Arrays;
+import java.util.Collection;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+
+@RunWith(Enclosed.class)
+public class SpiffeUtilTest {
+
+  @RunWith(Parameterized.class)
+  public static class ParseSuccessTest {
+    @Parameter
+    public String uri;
+
+    @Parameter(1)
+    public String trustDomain;
+
+    @Parameter(2)
+    public String path;
+
+    @Test
+    public void parseSuccessTest() {
+      SpiffeUtil.SpiffeId spiffeId = SpiffeUtil.parse(uri);
+      assertEquals(trustDomain, spiffeId.getTrustDomain());
+      assertEquals(path, spiffeId.getPath());
+    }
+
+    @Parameters(name = "spiffeId={0}")
+    public static Collection<String[]> data() {
+      return Arrays.asList(new String[][] {
+          {"spiffe://example.com", "example.com", ""},
+          {"spiffe://example.com/us", "example.com", "/us"},
+          {"spIFfe://qa-staging.final_check.example.com/us", "qa-staging.final_check.example.com",
+              "/us"},
+          {"spiffe://example.com/country/us/state/FL/city/Miami", "example.com",
+              "/country/us/state/FL/city/Miami"},
+          {"SPIFFE://example.com/Czech.Republic/region0.1/city_of-Prague", "example.com",
+              "/Czech.Republic/region0.1/city_of-Prague"},
+          {"spiffe://trust-domain-name/path", "trust-domain-name", "/path"},
+          {"spiffe://staging.example.com/payments/mysql", "staging.example.com", "/payments/mysql"},
+          {"spiffe://staging.example.com/payments/web-fe", "staging.example.com",
+              "/payments/web-fe"},
+          {"spiffe://k8s-west.example.com/ns/staging/sa/default", "k8s-west.example.com",
+              "/ns/staging/sa/default"},
+          {"spiffe://example.com/9eebccd2-12bf-40a6-b262-65fe0487d453", "example.com",
+              "/9eebccd2-12bf-40a6-b262-65fe0487d453"},
+          {"spiffe://trustdomain/.a..", "trustdomain", "/.a.."},
+          {"spiffe://trustdomain/...", "trustdomain", "/..."},
+          {"spiffe://trustdomain/abcdefghijklmnopqrstuvwxyz", "trustdomain",
+              "/abcdefghijklmnopqrstuvwxyz"},
+          {"spiffe://trustdomain/abc0123.-_", "trustdomain", "/abc0123.-_"},
+          {"spiffe://trustdomain/0123456789", "trustdomain", "/0123456789"},
+          {"spiffe://trustdomain0123456789/path", "trustdomain0123456789", "/path"},
+      });
+    }
+  }
+
+  @RunWith(Parameterized.class)
+  public static class ParseFailureTest {
+    @Parameter
+    public String uri;
+
+    @Test
+    public void parseFailureTest() {
+      assertThrows(IllegalArgumentException.class, () -> SpiffeUtil.parse(uri));
+    }
+
+    @Parameters(name = "spiffeId={0}")
+    public static Collection<String> data() {
+      return Arrays.asList(
+          "spiffe:///",
+          "spiffe://example!com",
+          "spiffe://exampleя.com/workload-1",
+          "spiffe://example.com/us/florida/miamiя",
+          "spiffe:/trustdomain/path",
+          "spiffe:///path",
+          "spiffe://trust%20domain/path",
+          "spiffe://user@trustdomain/path",
+          "spiffe:// /",
+          "",
+          "http://trustdomain/path",
+          "//trustdomain/path",
+          "://trustdomain/path",
+          "piffe://trustdomain/path",
+          "://",
+          "://trustdomain",
+          "spiff",
+          "spiffe",
+          "spiffe:////",
+          "spiffe://trust.domain/../path"
+          );
+    }
+  }
+
+  public static class ExceptionMessageTest {
+
+    @Test
+    public void spiffeUriFormatTest() {
+      NullPointerException npe = assertThrows(NullPointerException.class, () ->
+          SpiffeUtil.parse(null));
+      assertEquals("uri", npe.getMessage());
+
+      IllegalArgumentException iae = assertThrows(IllegalArgumentException.class, () ->
+          SpiffeUtil.parse("https://example.com"));
+      assertEquals("Spiffe Id must start with spiffe://", iae.getMessage());
+
+      iae = assertThrows(IllegalArgumentException.class, () ->
+          SpiffeUtil.parse("spiffe://example.com/workload#1"));
+      assertEquals("Spiffe Id must not contain query fragments", iae.getMessage());
+
+      iae = assertThrows(IllegalArgumentException.class, () ->
+          SpiffeUtil.parse("spiffe://example.com/workload-1?t=1"));
+      assertEquals("Spiffe Id must not contain query parameters", iae.getMessage());
+    }
+
+    @Test
+    public void spiffeTrustDomainFormatTest() {
+      IllegalArgumentException iae = assertThrows(IllegalArgumentException.class, () ->
+          SpiffeUtil.parse("spiffe://"));
+      assertEquals("Trust Domain can't be empty", iae.getMessage());
+
+      iae = assertThrows(IllegalArgumentException.class, () ->
+          SpiffeUtil.parse("spiffe://eXample.com"));
+      assertEquals(
+          "Trust Domain must contain only letters, numbers, dots, dashes, and underscores "
+              + "([a-z0-9.-_])",
+          iae.getMessage());
+
+      StringBuilder longTrustDomain = new StringBuilder("spiffe://pi.eu.");
+      for (int i = 0; i < 50; i++) {
+        longTrustDomain.append("pi.eu");
+      }
+      iae = assertThrows(IllegalArgumentException.class, () ->
+          SpiffeUtil.parse(longTrustDomain.toString()));
+      assertEquals("Trust Domain maximum length is 255 characters", iae.getMessage());
+
+      @SuppressWarnings("OrphanedFormatString")
+      StringBuilder longSpiffe = new StringBuilder("spiffe://mydomain%21com/");
+      for (int i = 0; i < 405; i++) {
+        longSpiffe.append("qwert");
+      }
+      iae = assertThrows(IllegalArgumentException.class, () ->
+          SpiffeUtil.parse(longSpiffe.toString()));
+      assertEquals("Spiffe Id maximum length is 2048 characters", iae.getMessage());
+    }
+
+    @Test
+    public void spiffePathFormatTest() {
+      IllegalArgumentException iae = assertThrows(IllegalArgumentException.class, () ->
+          SpiffeUtil.parse("spiffe://example.com//"));
+      assertEquals("Path must not include a trailing '/'", iae.getMessage());
+
+      iae = assertThrows(IllegalArgumentException.class, () ->
+          SpiffeUtil.parse("spiffe://example.com/"));
+      assertEquals("Path must not include a trailing '/'", iae.getMessage());
+
+      iae = assertThrows(IllegalArgumentException.class, () ->
+          SpiffeUtil.parse("spiffe://example.com/us//miami"));
+      assertEquals("Individual path segments must not be empty", iae.getMessage());
+
+      iae = assertThrows(IllegalArgumentException.class, () ->
+          SpiffeUtil.parse("spiffe://example.com/us/."));
+      assertEquals("Individual path segments must not be relative path modifiers (i.e. ., ..)",
+          iae.getMessage());
+
+      iae = assertThrows(IllegalArgumentException.class, () ->
+          SpiffeUtil.parse("spiffe://example.com/us!"));
+      assertEquals("Individual path segments must contain only letters, numbers, dots, dashes, and "
+          + "underscores ([a-zA-Z0-9.-_])", iae.getMessage());
+    }
+  }
+
+  public static class CertificateApiTest {
+    private static final String SPIFFE_PEM_FILE = "spiffe_cert.pem";
+    private static final String MULTI_URI_SAN_PEM_FILE = "spiffe_multi_uri_san_cert.pem";
+    private static final String SERVER_0_PEM_FILE = "server0.pem";
+    private static final String TEST_DIRECTORY_PREFIX = "io/grpc/internal/";
+    private static final String SPIFFE_TRUST_BUNDLE = "spiffebundle.json";
+    private static final String SPIFFE_TRUST_BUNDLE_WITH_EC_KTY = "spiffebundle_ec.json";
+    private static final String SPIFFE_TRUST_BUNDLE_MALFORMED = "spiffebundle_malformed.json";
+    private static final String SPIFFE_TRUST_BUNDLE_CORRUPTED_CERT =
+        "spiffebundle_corrupted_cert.json";
+    private static final String SPIFFE_TRUST_BUNDLE_WRONG_KTY = "spiffebundle_wrong_kty.json";
+    private static final String SPIFFE_TRUST_BUNDLE_WRONG_KID = "spiffebundle_wrong_kid.json";
+    private static final String SPIFFE_TRUST_BUNDLE_WRONG_USE = "spiffebundle_wrong_use.json";
+    private static final String SPIFFE_TRUST_BUNDLE_WRONG_MULTI_CERTS =
+        "spiffebundle_wrong_multi_certs.json";
+    private static final String SPIFFE_TRUST_BUNDLE_DUPLICATES = "spiffebundle_duplicates.json";
+    private static final String SPIFFE_TRUST_BUNDLE_WRONG_ROOT = "spiffebundle_wrong_root.json";
+    private static final String SPIFFE_TRUST_BUNDLE_WRONG_SEQ = "spiffebundle_wrong_seq_type.json";
+    private static final String DOMAIN_ERROR_MESSAGE =
+        " Certificate loading for trust domain 'google.com' failed.";
+
+
+    @Rule public TemporaryFolder tempFolder = new TemporaryFolder();
+
+    private X509Certificate[] spiffeCert;
+    private X509Certificate[] multipleUriSanCert;
+    private X509Certificate[] serverCert0;
+
+    @Before
+    public void setUp() throws Exception {
+      spiffeCert = CertificateUtils.getX509Certificates(TlsTesting.loadCert(SPIFFE_PEM_FILE));
+      multipleUriSanCert = CertificateUtils.getX509Certificates(TlsTesting
+          .loadCert(MULTI_URI_SAN_PEM_FILE));
+      serverCert0 = CertificateUtils.getX509Certificates(TlsTesting.loadCert(SERVER_0_PEM_FILE));
+    }
+
+    private String copyFileToTmp(String fileName) throws Exception {
+      File tempFile = tempFolder.newFile(fileName);
+      try (InputStream resourceStream = SpiffeUtilTest.class.getClassLoader()
+            .getResourceAsStream(TEST_DIRECTORY_PREFIX + fileName);
+          OutputStream fileStream = new FileOutputStream(tempFile)) {
+        ByteStreams.copy(resourceStream, fileStream);
+        fileStream.flush();
+      }
+      return tempFile.toString();
+    }
+
+    @Test
+    public void extractSpiffeIdSuccessTest() throws Exception {
+      Optional<SpiffeId> spiffeId = SpiffeUtil.extractSpiffeId(spiffeCert);
+      assertTrue(spiffeId.isPresent());
+      assertEquals("foo.bar.com", spiffeId.get().getTrustDomain());
+      assertEquals("/client/workload/1", spiffeId.get().getPath());
+    }
+
+    @Test
+    public void extractSpiffeIdFailureTest() throws Exception {
+      Optional<SpiffeUtil.SpiffeId> spiffeId = SpiffeUtil.extractSpiffeId(serverCert0);
+      assertFalse(spiffeId.isPresent());
+      IllegalArgumentException iae = assertThrows(IllegalArgumentException.class, () -> SpiffeUtil
+          .extractSpiffeId(multipleUriSanCert));
+      assertEquals("Multiple URI SAN values found in the leaf cert.", iae.getMessage());
+
+    }
+
+    @Test
+    public void extractSpiffeIdFromChainTest() throws Exception {
+      // Check that the SPIFFE ID is extracted only from the leaf cert in the chain (spiffeCert
+      // contains it, but serverCert0 does not).
+      X509Certificate[] leafWithSpiffeChain = new X509Certificate[]{spiffeCert[0], serverCert0[0]};
+      assertTrue(SpiffeUtil.extractSpiffeId(leafWithSpiffeChain).isPresent());
+      X509Certificate[] leafWithoutSpiffeChain =
+          new X509Certificate[]{serverCert0[0], spiffeCert[0]};
+      assertFalse(SpiffeUtil.extractSpiffeId(leafWithoutSpiffeChain).isPresent());
+    }
+
+    @Test
+    public void extractSpiffeIdParameterValidityTest() {
+      NullPointerException npe = assertThrows(NullPointerException.class, () -> SpiffeUtil
+          .extractSpiffeId(null));
+      assertEquals("certChain", npe.getMessage());
+      IllegalArgumentException iae = assertThrows(IllegalArgumentException.class, () -> SpiffeUtil
+          .extractSpiffeId(new X509Certificate[]{}));
+      assertEquals("certChain can't be empty", iae.getMessage());
+    }
+
+    @Test
+    public void loadTrustBundleFromFileSuccessTest() throws Exception {
+      SpiffeBundle tb = SpiffeUtil.loadTrustBundleFromFile(copyFileToTmp(SPIFFE_TRUST_BUNDLE));
+      assertEquals(2, tb.getSequenceNumbers().size());
+      assertEquals(12035488L, (long) tb.getSequenceNumbers().get("example.com"));
+      assertEquals(-1L, (long) tb.getSequenceNumbers().get("test.example.com"));
+      assertEquals(3, tb.getBundleMap().size());
+      assertEquals(0, tb.getBundleMap().get("test.google.com.au").size());
+      assertEquals(1, tb.getBundleMap().get("example.com").size());
+      assertEquals(2, tb.getBundleMap().get("test.example.com").size());
+      Optional<SpiffeId> spiffeId = SpiffeUtil.extractSpiffeId(tb.getBundleMap().get("example.com")
+              .toArray(new X509Certificate[0]));
+      assertTrue(spiffeId.isPresent());
+      assertEquals("foo.bar.com", spiffeId.get().getTrustDomain());
+
+      SpiffeBundle tb_ec = SpiffeUtil.loadTrustBundleFromFile(
+          copyFileToTmp(SPIFFE_TRUST_BUNDLE_WITH_EC_KTY));
+      assertEquals(2, tb_ec.getSequenceNumbers().size());
+      assertEquals(12035488L, (long) tb_ec.getSequenceNumbers().get("example.com"));
+      assertEquals(-1L, (long) tb_ec.getSequenceNumbers().get("test.example.com"));
+      assertEquals(3, tb_ec.getBundleMap().size());
+      assertEquals(0, tb_ec.getBundleMap().get("test.google.com.au").size());
+      assertEquals(1, tb_ec.getBundleMap().get("example.com").size());
+      assertEquals(2, tb_ec.getBundleMap().get("test.example.com").size());
+      Optional<SpiffeId> spiffeId_ec =
+          SpiffeUtil.extractSpiffeId(tb_ec.getBundleMap().get("example.com")
+                                         .toArray(new X509Certificate[0]));
+      assertTrue(spiffeId_ec.isPresent());
+      assertEquals("foo.bar.com", spiffeId_ec.get().getTrustDomain());
+    }
+
+    @Test
+    public void loadTrustBundleFromFileFailureTest() {
+      // Check the exception if JSON root element is different from 'trust_domains'
+      NullPointerException npe = assertThrows(NullPointerException.class, () -> SpiffeUtil
+          .loadTrustBundleFromFile(copyFileToTmp(SPIFFE_TRUST_BUNDLE_WRONG_ROOT)));
+      assertEquals("Mandatory trust_domains element is missing", npe.getMessage());
+      // Check the exception if JSON root element is different from 'trust_domains'
+      ClassCastException cce = assertThrows(ClassCastException.class, () -> SpiffeUtil
+          .loadTrustBundleFromFile(copyFileToTmp(SPIFFE_TRUST_BUNDLE_WRONG_SEQ)));
+      assertTrue(cce.getMessage().contains("Number expected to be long"));
+      // Check the exception if JSON file doesn't contain an object
+      IllegalArgumentException iae = assertThrows(IllegalArgumentException.class, () -> SpiffeUtil
+          .loadTrustBundleFromFile(copyFileToTmp(SPIFFE_TRUST_BUNDLE_MALFORMED)));
+      assertTrue(iae.getMessage().contains("SPIFFE Trust Bundle should be a JSON object."));
+      // Check the exception if JSON contains duplicates
+      iae = assertThrows(IllegalArgumentException.class, () -> SpiffeUtil
+          .loadTrustBundleFromFile(copyFileToTmp(SPIFFE_TRUST_BUNDLE_DUPLICATES)));
+      assertEquals("Duplicate key found: google.com", iae.getMessage());
+      // Check the exception if 'x5c' value cannot be parsed
+      iae = assertThrows(IllegalArgumentException.class, () -> SpiffeUtil
+          .loadTrustBundleFromFile(copyFileToTmp(SPIFFE_TRUST_BUNDLE_CORRUPTED_CERT)));
+      assertEquals("Certificate can't be parsed." + DOMAIN_ERROR_MESSAGE, iae.getMessage());
+      // Check the exception if 'kty' value differs from 'RSA'
+      iae = assertThrows(IllegalArgumentException.class, () -> SpiffeUtil
+          .loadTrustBundleFromFile(copyFileToTmp(SPIFFE_TRUST_BUNDLE_WRONG_KTY)));
+      assertEquals(
+          "'kty' parameter must be one of [RSA, EC] but 'null' found." + DOMAIN_ERROR_MESSAGE,
+          iae.getMessage());
+      // Check the exception if 'kid' has a value
+      iae = assertThrows(IllegalArgumentException.class, () -> SpiffeUtil
+          .loadTrustBundleFromFile(copyFileToTmp(SPIFFE_TRUST_BUNDLE_WRONG_KID)));
+      assertEquals("'kid' parameter must not be set." + DOMAIN_ERROR_MESSAGE, iae.getMessage());
+      // Check the exception if 'use' value differs from 'x509-svid'
+      iae = assertThrows(IllegalArgumentException.class, () -> SpiffeUtil
+          .loadTrustBundleFromFile(copyFileToTmp(SPIFFE_TRUST_BUNDLE_WRONG_USE)));
+      assertEquals("'use' parameter must be 'x509-svid' but 'i_am_not_x509-svid' found."
+          + DOMAIN_ERROR_MESSAGE, iae.getMessage());
+      // Check the exception if multiple certs are provided for 'x5c'
+      iae = assertThrows(IllegalArgumentException.class, () -> SpiffeUtil
+          .loadTrustBundleFromFile(copyFileToTmp(SPIFFE_TRUST_BUNDLE_WRONG_MULTI_CERTS)));
+      assertEquals("Exactly 1 certificate is expected, but 2 found." + DOMAIN_ERROR_MESSAGE,
+          iae.getMessage());
+    }
+
+    @Test
+    public void loadTrustBundleFromFileParameterValidityTest() {
+      NullPointerException npe = assertThrows(NullPointerException.class, () -> SpiffeUtil
+          .loadTrustBundleFromFile(null));
+      assertEquals("trustBundleFile", npe.getMessage());
+      FileNotFoundException nsfe = assertThrows(FileNotFoundException.class, () -> SpiffeUtil
+          .loadTrustBundleFromFile("i_do_not_exist"));
+      assertTrue(
+          "Did not contain expected substring: " + nsfe.getMessage(),
+          nsfe.getMessage().contains("i_do_not_exist"));
+    }
+  }
+}
diff --git a/core/src/test/java/io/grpc/internal/StatsTraceContextTest.java b/core/src/test/java/io/grpc/internal/StatsTraceContextTest.java
deleted file mode 100644
index 18af820f653..00000000000
--- a/core/src/test/java/io/grpc/internal/StatsTraceContextTest.java
+++ /dev/null
@@ -1,242 +0,0 @@
-/*
- * Copyright 2017, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-
-import com.google.instrumentation.stats.RpcConstants;
-import com.google.instrumentation.stats.StatsContext;
-import com.google.instrumentation.stats.TagValue;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.Status;
-import io.grpc.internal.testing.StatsTestUtils.FakeStatsContextFactory;
-import io.grpc.internal.testing.StatsTestUtils;
-import org.junit.After;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Test for {@link StatsTraceContext}.
- */
-@RunWith(JUnit4.class)
-public class StatsTraceContextTest {
-  private FakeClock fakeClock = new FakeClock();
-  private FakeStatsContextFactory statsCtxFactory = new FakeStatsContextFactory();
-
-  @After
-  public void allRecordsVerified() {
-    assertNull(statsCtxFactory.pollRecord());
-  }
-
-  @Test
-  public void clientBasic() {
-    String methodName = MethodDescriptor.generateFullMethodName("Service1", "method1");
-    StatsTraceContext ctx = StatsTraceContext.newClientContextForTesting(
-        methodName, statsCtxFactory, statsCtxFactory.getDefault(),
-        fakeClock.getStopwatchSupplier());
-    fakeClock.forwardMillis(30);
-    ctx.clientHeadersSent();
-
-    fakeClock.forwardMillis(100);
-    ctx.wireBytesSent(1028);
-    ctx.uncompressedBytesSent(1128);
-
-    fakeClock.forwardMillis(16);
-    ctx.wireBytesReceived(33);
-    ctx.uncompressedBytesReceived(67);
-    ctx.wireBytesSent(99);
-    ctx.uncompressedBytesSent(865);
-
-    fakeClock.forwardMillis(24);
-    ctx.wireBytesReceived(154);
-    ctx.uncompressedBytesReceived(552);
-    ctx.callEnded(Status.OK);
-
-    StatsTestUtils.MetricsRecord record = statsCtxFactory.pollRecord();
-    assertNotNull(record);
-    assertNoServerContent(record);
-    TagValue methodTag = record.tags.get(RpcConstants.RPC_CLIENT_METHOD);
-    assertEquals(methodName, methodTag.toString());
-    TagValue statusTag = record.tags.get(RpcConstants.RPC_STATUS);
-    assertEquals(Status.Code.OK.toString(), statusTag.toString());
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_ERROR_COUNT));
-    assertEquals(1028 + 99, record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_REQUEST_BYTES));
-    assertEquals(1128 + 865,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
-    assertEquals(33 + 154, record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_RESPONSE_BYTES));
-    assertEquals(67 + 552,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
-    assertEquals(30 + 100 + 16 + 24,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_ROUNDTRIP_LATENCY));
-    assertEquals(100 + 16 + 24,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_SERVER_ELAPSED_TIME));
-  }
-
-  @Test
-  public void clientNotSent() {
-    String methodName = MethodDescriptor.generateFullMethodName("Service1", "method2");
-    StatsTraceContext ctx = StatsTraceContext.newClientContextForTesting(
-        methodName, statsCtxFactory, statsCtxFactory.getDefault(),
-        fakeClock.getStopwatchSupplier());
-    fakeClock.forwardMillis(3000);
-    ctx.callEnded(Status.DEADLINE_EXCEEDED.withDescription("3 seconds"));
-
-    StatsTestUtils.MetricsRecord record = statsCtxFactory.pollRecord();
-    assertNotNull(record);
-    assertNoServerContent(record);
-    TagValue methodTag = record.tags.get(RpcConstants.RPC_CLIENT_METHOD);
-    assertEquals(methodName, methodTag.toString());
-    TagValue statusTag = record.tags.get(RpcConstants.RPC_STATUS);
-    assertEquals(Status.Code.DEADLINE_EXCEEDED.toString(), statusTag.toString());
-    assertEquals(1, record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_ERROR_COUNT));
-    assertEquals(0, record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_REQUEST_BYTES));
-    assertEquals(0,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
-    assertEquals(0, record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_RESPONSE_BYTES));
-    assertEquals(0,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
-    assertEquals(3000, record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_ROUNDTRIP_LATENCY));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_SERVER_ELAPSED_TIME));
-  }
-
-  /**
-   * Tags that are propagated by the {@link StatsContextFactory} are properly propagated via
-   * the headers.
-   */
-  @Test
-  public void tagPropagation() {
-    String methodName = MethodDescriptor.generateFullMethodName("Service1", "method3");
-
-    // EXTRA_TAG is propagated by the FakeStatsContextFactory. Note that not all tags are
-    // propagated.  The StatsContextFactory decides which tags are to propagated.  gRPC facilitates
-    // the propagation by putting them in the headers.
-    StatsContext parentCtx = statsCtxFactory.getDefault().with(
-        StatsTestUtils.EXTRA_TAG, TagValue.create("extra-tag-value-897"));
-    StatsTraceContext clientCtx = StatsTraceContext.newClientContextForTesting(
-        methodName, statsCtxFactory, parentCtx, fakeClock.getStopwatchSupplier());
-    Metadata headers = new Metadata();
-    clientCtx.propagateToHeaders(headers);
-
-    // The server gets the propagated tag from the headers, and puts it on the server-side
-    // StatsContext.
-    StatsTraceContext serverCtx = StatsTraceContext.newServerContext(
-        methodName, statsCtxFactory, headers, fakeClock.getStopwatchSupplier());
-
-    serverCtx.callEnded(Status.OK);
-    clientCtx.callEnded(Status.OK);
-
-    StatsTestUtils.MetricsRecord serverRecord = statsCtxFactory.pollRecord();
-    assertNotNull(serverRecord);
-    assertNoClientContent(serverRecord);
-    TagValue serverMethodTag = serverRecord.tags.get(RpcConstants.RPC_SERVER_METHOD);
-    assertEquals(methodName, serverMethodTag.toString());
-    TagValue serverStatusTag = serverRecord.tags.get(RpcConstants.RPC_STATUS);
-    assertEquals(Status.Code.OK.toString(), serverStatusTag.toString());
-    assertNull(serverRecord.getMetric(RpcConstants.RPC_SERVER_ERROR_COUNT));
-    TagValue serverPropagatedTag = serverRecord.tags.get(StatsTestUtils.EXTRA_TAG);
-    assertEquals("extra-tag-value-897", serverPropagatedTag.toString());
-    
-    StatsTestUtils.MetricsRecord clientRecord = statsCtxFactory.pollRecord();
-    assertNotNull(clientRecord);
-    assertNoServerContent(clientRecord);
-    TagValue clientMethodTag = clientRecord.tags.get(RpcConstants.RPC_CLIENT_METHOD);
-    assertEquals(methodName, clientMethodTag.toString());
-    TagValue clientStatusTag = clientRecord.tags.get(RpcConstants.RPC_STATUS);
-    assertEquals(Status.Code.OK.toString(), clientStatusTag.toString());
-    assertNull(clientRecord.getMetric(RpcConstants.RPC_CLIENT_ERROR_COUNT));
-    TagValue clientPropagatedTag = clientRecord.tags.get(StatsTestUtils.EXTRA_TAG);
-    assertEquals("extra-tag-value-897", clientPropagatedTag.toString());
-  }
-
-  @Test
-  public void serverBasic() {
-    String methodName = MethodDescriptor.generateFullMethodName("Service1", "method4");
-    StatsTraceContext ctx = StatsTraceContext.newServerContext(
-        methodName, statsCtxFactory, new Metadata(), fakeClock.getStopwatchSupplier());
-    ctx.wireBytesReceived(34);
-    ctx.uncompressedBytesReceived(67);
-
-    fakeClock.forwardMillis(100);
-    ctx.wireBytesSent(1028);
-    ctx.uncompressedBytesSent(1128);
-
-    fakeClock.forwardMillis(16);
-    ctx.wireBytesReceived(154);
-    ctx.uncompressedBytesReceived(552);
-    ctx.wireBytesSent(99);
-    ctx.uncompressedBytesSent(865);
-
-    fakeClock.forwardMillis(24);
-    ctx.callEnded(Status.CANCELLED);
-
-    StatsTestUtils.MetricsRecord record = statsCtxFactory.pollRecord();
-    assertNotNull(record);
-    assertNoClientContent(record);
-    TagValue methodTag = record.tags.get(RpcConstants.RPC_SERVER_METHOD);
-    assertEquals(methodName, methodTag.toString());
-    TagValue statusTag = record.tags.get(RpcConstants.RPC_STATUS);
-    assertEquals(Status.Code.CANCELLED.toString(), statusTag.toString());
-    assertEquals(1, record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_ERROR_COUNT));
-    assertEquals(1028 + 99, record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_RESPONSE_BYTES));
-    assertEquals(1128 + 865,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES));
-    assertEquals(34 + 154, record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_REQUEST_BYTES));
-    assertEquals(67 + 552,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES));
-    assertEquals(100 + 16 + 24,
-        record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_SERVER_LATENCY));
-  }
-
-  private static void assertNoServerContent(StatsTestUtils.MetricsRecord record) {
-    assertNull(record.getMetric(RpcConstants.RPC_SERVER_ERROR_COUNT));
-    assertNull(record.getMetric(RpcConstants.RPC_SERVER_REQUEST_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_SERVER_RESPONSE_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_SERVER_SERVER_ELAPSED_TIME));
-    assertNull(record.getMetric(RpcConstants.RPC_SERVER_SERVER_LATENCY));
-    assertNull(record.getMetric(RpcConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES));
-  }
-
-  private static void assertNoClientContent(StatsTestUtils.MetricsRecord record) {
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_ERROR_COUNT));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_REQUEST_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_RESPONSE_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_ROUNDTRIP_LATENCY));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_SERVER_ELAPSED_TIME));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
-    assertNull(record.getMetric(RpcConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/TestUtils.java b/core/src/test/java/io/grpc/internal/TestUtils.java
deleted file mode 100644
index 36532eaea0e..00000000000
--- a/core/src/test/java/io/grpc/internal/TestUtils.java
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-import io.grpc.CallOptions;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import java.net.SocketAddress;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
-import javax.annotation.Nullable;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-/**
- * Common utility methods for tests.
- */
-final class TestUtils {
-
-  static class MockClientTransportInfo {
-    /**
-     * A mock transport created by the mock transport factory.
-     */
-    final ConnectionClientTransport transport;
-
-    /**
-     * The listener passed to the start() of the mock transport.
-     */
-    final ManagedClientTransport.Listener listener;
-
-    MockClientTransportInfo(ConnectionClientTransport transport,
-        ManagedClientTransport.Listener listener) {
-      this.transport = transport;
-      this.listener = listener;
-    }
-  }
-
-  /**
-   * Stub the given mock {@link ClientTransportFactory} by returning mock
-   * {@link ManagedClientTransport}s which saves their listeners along with them. This method
-   * returns a list of {@link MockClientTransportInfo}, each of which is a started mock transport
-   * and its listener.
-   */
-  static BlockingQueue<MockClientTransportInfo> captureTransports(
-      ClientTransportFactory mockTransportFactory) {
-    return captureTransports(mockTransportFactory, null);
-  }
-
-  static BlockingQueue<MockClientTransportInfo> captureTransports(
-      ClientTransportFactory mockTransportFactory, @Nullable final Runnable startRunnable) {
-    final BlockingQueue<MockClientTransportInfo> captor =
-        new LinkedBlockingQueue<MockClientTransportInfo>();
-
-    doAnswer(new Answer<ConnectionClientTransport>() {
-      @Override
-      public ConnectionClientTransport answer(InvocationOnMock invocation) throws Throwable {
-        final ConnectionClientTransport mockTransport = mock(ConnectionClientTransport.class);
-        when(mockTransport.newStream(any(MethodDescriptor.class), any(Metadata.class),
-                any(CallOptions.class), any(StatsTraceContext.class)))
-            .thenReturn(mock(ClientStream.class));
-        // Save the listener
-        doAnswer(new Answer<Runnable>() {
-          @Override
-          public Runnable answer(InvocationOnMock invocation) throws Throwable {
-            captor.add(new MockClientTransportInfo(
-                mockTransport, (ManagedClientTransport.Listener) invocation.getArguments()[0]));
-            return startRunnable;
-          }
-        }).when(mockTransport).start(any(ManagedClientTransport.Listener.class));
-        return mockTransport;
-      }
-    }).when(mockTransportFactory)
-        .newClientTransport(any(SocketAddress.class), any(String.class), any(String.class));
-
-    return captor;
-  }
-
-  private TestUtils() {
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/TransportFrameUtilTest.java b/core/src/test/java/io/grpc/internal/TransportFrameUtilTest.java
index 14505246e99..8b4bc170d52 100644
--- a/core/src/test/java/io/grpc/internal/TransportFrameUtilTest.java
+++ b/core/src/test/java/io/grpc/internal/TransportFrameUtilTest.java
@@ -1,49 +1,36 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal;
 
-import static com.google.common.base.Charsets.US_ASCII;
-import static com.google.common.base.Charsets.UTF_8;
 import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
+import static io.grpc.Metadata.BINARY_BYTE_MARSHALLER;
+import static java.nio.charset.StandardCharsets.US_ASCII;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import com.google.common.collect.Iterables;
 import com.google.common.io.BaseEncoding;
 import io.grpc.InternalMetadata;
 import io.grpc.Metadata;
 import io.grpc.Metadata.BinaryMarshaller;
-import io.grpc.Metadata.Key;
 import java.util.Arrays;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -59,21 +46,25 @@ public class TransportFrameUtilTest {
 
   private static final BinaryMarshaller<String> UTF8_STRING_MARSHALLER =
       new BinaryMarshaller<String>() {
-    @Override
-    public byte[] toBytes(String value) {
-      return value.getBytes(UTF_8);
-    }
+        @Override
+        public byte[] toBytes(String value) {
+          return value.getBytes(UTF_8);
+        }
 
-    @Override
-    public String parseBytes(byte[] serialized) {
-      return new String(serialized, UTF_8);
-    }
-  };
+        @Override
+        public String parseBytes(byte[] serialized) {
+          return new String(serialized, UTF_8);
+        }
+      };
 
-  private static final Key<String> PLAIN_STRING = Key.of("plainstring", ASCII_STRING_MARSHALLER);
-  private static final Key<String> BINARY_STRING = Key.of("string-bin", UTF8_STRING_MARSHALLER);
-  private static final Key<String> BINARY_STRING_WITHOUT_SUFFIX =
-      Key.of("string", ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> PLAIN_STRING =
+      Metadata.Key.of("plainstring", ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> BINARY_STRING =
+      Metadata.Key.of("string-bin", UTF8_STRING_MARSHALLER);
+  private static final Metadata.Key<String> BINARY_STRING_WITHOUT_SUFFIX =
+      Metadata.Key.of("string", ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<byte[]> BINARY_BYTES =
+      Metadata.Key.of("bytes-bin", BINARY_BYTE_MARSHALLER);
 
   @Test
   public void testToHttp2Headers() {
@@ -97,7 +88,7 @@ public void testToHttp2Headers() {
 
   @Test(expected = IllegalArgumentException.class)
   public void binaryHeaderWithoutSuffix() {
-    Key.of("plainstring", UTF8_STRING_MARSHALLER);
+    Metadata.Key.of("plainstring", UTF8_STRING_MARSHALLER);
   }
 
   @Test
@@ -114,6 +105,31 @@ public void testToAndFromHttp2Headers() {
     assertNull(recoveredHeaders.get(BINARY_STRING_WITHOUT_SUFFIX));
   }
 
+  @Test
+  public void dupBinHeadersWithComma() {
+    byte[][] http2Headers = new byte[][] {
+        BINARY_BYTES.name().getBytes(US_ASCII),
+        "BaS,e6,,4+,padding==".getBytes(US_ASCII),
+        BINARY_BYTES.name().getBytes(US_ASCII),
+        "more".getBytes(US_ASCII),
+        BINARY_BYTES.name().getBytes(US_ASCII),
+        "".getBytes(US_ASCII)};
+    byte[][] rawSerialized = TransportFrameUtil.toRawSerializedHeaders(http2Headers);
+    Metadata recoveredHeaders = InternalMetadata.newMetadata(rawSerialized);
+    byte[][] values = Iterables.toArray(recoveredHeaders.getAll(BINARY_BYTES), byte[].class);
+
+    assertTrue(Arrays.deepEquals(
+        new byte[][] {
+            BaseEncoding.base64().decode("BaS"),
+            BaseEncoding.base64().decode("e6"),
+            BaseEncoding.base64().decode(""),
+            BaseEncoding.base64().decode("4+"),
+            BaseEncoding.base64().decode("padding"),
+            BaseEncoding.base64().decode("more"),
+            BaseEncoding.base64().decode("")},
+        values));
+  }
+
   private static void assertContains(byte[][] headers, byte[] key, byte[] value) {
     String keyString = new String(key, US_ASCII);
     for (int i = 0; i < headers.length; i += 2) {
@@ -126,7 +142,7 @@ private static void assertContains(byte[][] headers, byte[] key, byte[] value) {
   }
 
   private static byte[] base64Encode(byte[] input) {
-    return BaseEncoding.base64().encode(input).getBytes(US_ASCII);
+    return InternalMetadata.BASE64_ENCODING_OMIT_PADDING.encode(input).getBytes(US_ASCII);
   }
 
 }
diff --git a/core/src/test/java/io/grpc/internal/TransportSetTest.java b/core/src/test/java/io/grpc/internal/TransportSetTest.java
deleted file mode 100644
index 7fbbb34430c..00000000000
--- a/core/src/test/java/io/grpc/internal/TransportSetTest.java
+++ /dev/null
@@ -1,802 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.same;
-import static org.mockito.Mockito.atLeast;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-import io.grpc.CallOptions;
-import io.grpc.ConnectivityState;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.IntegerMarshaller;
-import io.grpc.LoadBalancer;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.Status;
-import io.grpc.StringMarshaller;
-import io.grpc.internal.TestUtils.MockClientTransportInfo;
-import java.net.SocketAddress;
-import java.util.Arrays;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.Executor;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-/**
- * Unit tests for {@link TransportSet}.
- *
- * <p>It only tests the logic that is not covered by {@link ManagedChannelImplTransportManagerTest}.
- */
-@RunWith(JUnit4.class)
-public class TransportSetTest {
-
-  private static final String AUTHORITY = "fakeauthority";
-  private static final String USER_AGENT = "mosaic";
-
-  private FakeClock fakeClock;
-  private FakeClock fakeExecutor;
-
-  @Mock private LoadBalancer<ClientTransport> mockLoadBalancer;
-  @Mock private BackoffPolicy mockBackoffPolicy1;
-  @Mock private BackoffPolicy mockBackoffPolicy2;
-  @Mock private BackoffPolicy mockBackoffPolicy3;
-  @Mock private BackoffPolicy.Provider mockBackoffPolicyProvider;
-  @Mock private ClientTransportFactory mockTransportFactory;
-  @Mock private TransportSet.Callback mockTransportSetCallback;
-  @Mock private ClientStreamListener mockStreamListener;
-
-  private final MethodDescriptor<String, Integer> method =
-      MethodDescriptor.<String, Integer>newBuilder()
-          .setType(MethodDescriptor.MethodType.UNKNOWN)
-          .setFullMethodName("/service/method")
-          .setRequestMarshaller(new StringMarshaller())
-          .setResponseMarshaller(new IntegerMarshaller())
-          .build();
-  private final Metadata headers = new Metadata();
-  private final CallOptions waitForReadyCallOptions = CallOptions.DEFAULT.withWaitForReady();
-  private final CallOptions failFastCallOptions = CallOptions.DEFAULT;
-  private final StatsTraceContext statsTraceCtx = StatsTraceContext.NOOP;
-
-  private TransportSet transportSet;
-  private EquivalentAddressGroup addressGroup;
-  private BlockingQueue<MockClientTransportInfo> transports;
-
-  @Before public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    fakeClock = new FakeClock();
-    fakeExecutor = new FakeClock();
-
-    when(mockBackoffPolicyProvider.get())
-        .thenReturn(mockBackoffPolicy1, mockBackoffPolicy2, mockBackoffPolicy3);
-    when(mockBackoffPolicy1.nextBackoffMillis()).thenReturn(10L, 100L);
-    when(mockBackoffPolicy2.nextBackoffMillis()).thenReturn(10L, 100L);
-    when(mockBackoffPolicy3.nextBackoffMillis()).thenReturn(10L, 100L);
-    transports = TestUtils.captureTransports(mockTransportFactory);
-  }
-
-  @After public void noMorePendingTasks() {
-    assertEquals(0, fakeClock.numPendingTasks());
-    assertEquals(0, fakeExecutor.numPendingTasks());
-  }
-
-  @Test public void singleAddressReconnect() {
-    SocketAddress addr = mock(SocketAddress.class);
-    createTransportSet(addr);
-    assertEquals(ConnectivityState.IDLE, transportSet.getState(false));
-
-    // Invocation counters
-    int transportsCreated = 0;
-    int backoff1Consulted = 0;
-    int backoff2Consulted = 0;
-    int backoffReset = 0;
-    int onAllAddressesFailed = 0;
-
-    // First attempt
-    transportSet.obtainActiveTransport().newStream(method, new Metadata(), waitForReadyCallOptions,
-        statsTraceCtx);
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
-
-    // Fail this one
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    verify(mockTransportSetCallback, times(++onAllAddressesFailed)).onAllAddressesFailed();
-    // Backoff reset and using first back-off value interval
-    verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffMillis();
-    verify(mockBackoffPolicyProvider, times(++backoffReset)).get();
-
-    // Second attempt
-    // Transport creation doesn't happen until time is due
-    fakeClock.forwardMillis(9);
-    verify(mockTransportFactory, times(transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    fakeClock.forwardMillis(1);
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
-    // Fail this one too
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    verify(mockTransportSetCallback, times(++onAllAddressesFailed)).onAllAddressesFailed();
-    // Second back-off interval
-    verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffMillis();
-    verify(mockBackoffPolicyProvider, times(backoffReset)).get();
-
-    // Third attempt
-    // Transport creation doesn't happen until time is due
-    fakeClock.forwardMillis(99);
-    verify(mockTransportFactory, times(transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    fakeClock.forwardMillis(1);
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
-    // Let this one succeed
-    transports.peek().listener.transportReady();
-    assertEquals(ConnectivityState.READY, transportSet.getState(false));
-    fakeClock.runDueTasks();
-    verify(mockTransportSetCallback, never()).onConnectionClosedByServer(any(Status.class));
-    // And close it
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.IDLE, transportSet.getState(false));
-    verify(mockTransportSetCallback).onConnectionClosedByServer(same(Status.UNAVAILABLE));
-    verify(mockTransportSetCallback, times(onAllAddressesFailed)).onAllAddressesFailed();
-
-    // Back-off is reset, and the next attempt will happen immediately
-    transportSet.obtainActiveTransport();
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    verify(mockBackoffPolicyProvider, times(backoffReset)).get();
-    verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
-
-    // Final checks for consultations on back-off policies
-    verify(mockBackoffPolicy1, times(backoff1Consulted)).nextBackoffMillis();
-    verify(mockBackoffPolicy2, times(backoff2Consulted)).nextBackoffMillis();
-    verify(mockTransportSetCallback, atLeast(0)).onInUse(transportSet);
-    verify(mockTransportSetCallback, atLeast(0)).onNotInUse(transportSet);
-    verifyNoMoreInteractions(mockTransportSetCallback);
-    fakeExecutor.runDueTasks(); // Drain new 'real' stream creation; not important to this test.
-  }
-
-  @Test public void twoAddressesReconnect() {
-    SocketAddress addr1 = mock(SocketAddress.class);
-    SocketAddress addr2 = mock(SocketAddress.class);
-    createTransportSet(addr1, addr2);
-    assertEquals(ConnectivityState.IDLE, transportSet.getState(false));
-    // Invocation counters
-    int transportsAddr1 = 0;
-    int transportsAddr2 = 0;
-    int backoff1Consulted = 0;
-    int backoff2Consulted = 0;
-    int backoff3Consulted = 0;
-    int backoffReset = 0;
-    int onAllAddressesFailed = 0;
-
-    // First attempt
-    DelayedClientTransport delayedTransport1 =
-        (DelayedClientTransport) transportSet.obtainActiveTransport();
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    verify(mockTransportFactory, times(++transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    delayedTransport1.newStream(method, new Metadata(), waitForReadyCallOptions, statsTraceCtx);
-    // Let this one fail without success
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    assertNull(delayedTransport1.getTransportSupplier());
-    verify(mockTransportSetCallback, times(onAllAddressesFailed)).onAllAddressesFailed();
-
-    // Second attempt will start immediately. Still no back-off policy.
-    DelayedClientTransport delayedTransport2 =
-        (DelayedClientTransport) transportSet.obtainActiveTransport();
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    assertSame(delayedTransport1, delayedTransport2);
-    verify(mockBackoffPolicyProvider, times(backoffReset)).get();
-    verify(mockTransportFactory, times(++transportsAddr2))
-        .newClientTransport(addr2, AUTHORITY, USER_AGENT);
-    // Fail this one too
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    // All addresses have failed. Delayed transport will be in back-off interval.
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    assertNull(delayedTransport2.getTransportSupplier());
-    assertTrue(delayedTransport2.isInBackoffPeriod());
-    verify(mockTransportSetCallback, times(++onAllAddressesFailed)).onAllAddressesFailed();
-    // Backoff reset and first back-off interval begins
-    verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffMillis();
-    verify(mockBackoffPolicyProvider, times(++backoffReset)).get();
-
-    // Third attempt is the first address, thus controlled by the first back-off interval.
-    DelayedClientTransport delayedTransport3 =
-        (DelayedClientTransport) transportSet.obtainActiveTransport();
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    assertSame(delayedTransport2, delayedTransport3);
-    fakeClock.forwardMillis(9);
-    verify(mockTransportFactory, times(transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    fakeClock.forwardMillis(1);
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    verify(mockTransportFactory, times(++transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    // Fail this one too
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    assertNull(delayedTransport3.getTransportSupplier());
-    verify(mockTransportSetCallback, times(onAllAddressesFailed)).onAllAddressesFailed();
-
-    // Forth attempt will start immediately. Keep back-off policy.
-    DelayedClientTransport delayedTransport4 =
-        (DelayedClientTransport) transportSet.obtainActiveTransport();
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    assertSame(delayedTransport3, delayedTransport4);
-    verify(mockBackoffPolicyProvider, times(backoffReset)).get();
-    verify(mockTransportFactory, times(++transportsAddr2))
-        .newClientTransport(addr2, AUTHORITY, USER_AGENT);
-    // Fail this one too
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    // All addresses have failed again. Delayed transport will be in back-off interval.
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    assertNull(delayedTransport4.getTransportSupplier());
-    assertTrue(delayedTransport4.isInBackoffPeriod());
-    verify(mockTransportSetCallback, times(++onAllAddressesFailed)).onAllAddressesFailed();
-    // Second back-off interval begins
-    verify(mockBackoffPolicy1, times(++backoff1Consulted)).nextBackoffMillis();
-    verify(mockBackoffPolicyProvider, times(backoffReset)).get();
-
-    // Fifth attempt for the first address, thus controlled by the second back-off interval.
-    DelayedClientTransport delayedTransport5 =
-        (DelayedClientTransport) transportSet.obtainActiveTransport();
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    assertSame(delayedTransport4, delayedTransport5);
-    fakeClock.forwardMillis(99);
-    verify(mockTransportFactory, times(transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    fakeClock.forwardMillis(1);
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    verify(mockTransportFactory, times(++transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    // Let it through
-    transports.peek().listener.transportReady();
-    assertEquals(ConnectivityState.READY, transportSet.getState(false));
-    // Delayed transport will see the connected transport.
-    assertSame(transports.peek().transport, delayedTransport5.getTransportSupplier().get());
-    verify(mockTransportSetCallback, never()).onConnectionClosedByServer(any(Status.class));
-    // Then close it.
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.IDLE, transportSet.getState(false));
-    verify(mockTransportSetCallback).onConnectionClosedByServer(same(Status.UNAVAILABLE));
-    verify(mockTransportSetCallback, times(onAllAddressesFailed)).onAllAddressesFailed();
-
-    // First attempt after a successful connection. Old back-off policy should be ignored, but there
-    // is not yet a need for a new one. Start from the first address.
-    DelayedClientTransport delayedTransport6 =
-        (DelayedClientTransport) transportSet.obtainActiveTransport();
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    assertNotSame(delayedTransport5, delayedTransport6);
-    delayedTransport6.newStream(method, headers, waitForReadyCallOptions, statsTraceCtx);
-    verify(mockBackoffPolicyProvider, times(backoffReset)).get();
-    verify(mockTransportFactory, times(++transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    // Fail the transport
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    assertNull(delayedTransport6.getTransportSupplier());
-    verify(mockTransportSetCallback, times(onAllAddressesFailed)).onAllAddressesFailed();
-
-    // Second attempt will start immediately. Still no new back-off policy.
-    DelayedClientTransport delayedTransport7 =
-        (DelayedClientTransport) transportSet.obtainActiveTransport();
-    assertSame(delayedTransport6, delayedTransport7);
-    verify(mockBackoffPolicyProvider, times(backoffReset)).get();
-    verify(mockTransportFactory, times(++transportsAddr2))
-        .newClientTransport(addr2, AUTHORITY, USER_AGENT);
-    // Fail this one too
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    // All addresses have failed. Delayed transport will be in back-off interval.
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    assertNull(delayedTransport7.getTransportSupplier());
-    assertTrue(delayedTransport7.isInBackoffPeriod());
-    verify(mockTransportSetCallback, times(++onAllAddressesFailed)).onAllAddressesFailed();
-    // Back-off reset and first back-off interval begins
-    verify(mockBackoffPolicy2, times(++backoff2Consulted)).nextBackoffMillis();
-    verify(mockBackoffPolicyProvider, times(++backoffReset)).get();
-
-    // Third attempt is the first address, thus controlled by the first back-off interval.
-    DelayedClientTransport delayedTransport8 =
-        (DelayedClientTransport) transportSet.obtainActiveTransport();
-    assertSame(delayedTransport7, delayedTransport8);
-    fakeClock.forwardMillis(9);
-    verify(mockTransportFactory, times(transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    fakeClock.forwardMillis(1);
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    verify(mockTransportFactory, times(++transportsAddr1))
-        .newClientTransport(addr1, AUTHORITY, USER_AGENT);
-
-    // Final checks on invocations on back-off policies
-    verify(mockBackoffPolicy1, times(backoff1Consulted)).nextBackoffMillis();
-    verify(mockBackoffPolicy2, times(backoff2Consulted)).nextBackoffMillis();
-    verify(mockBackoffPolicy3, times(backoff3Consulted)).nextBackoffMillis();
-    verify(mockTransportSetCallback, atLeast(0)).onInUse(transportSet);
-    verify(mockTransportSetCallback, atLeast(0)).onNotInUse(transportSet);
-    verifyNoMoreInteractions(mockTransportSetCallback);
-    fakeExecutor.runDueTasks(); // Drain new 'real' stream creation; not important to this test.
-  }
-
-  @Test
-  public void verifyFailFastAndNonFailFastBehaviors() {
-    int pendingStreamsCount = 0;
-    int failFastPendingStreamsCount = 0;
-
-    final SocketAddress addr1 = mock(SocketAddress.class);
-    final SocketAddress addr2 = mock(SocketAddress.class);
-    createTransportSet(addr1, addr2);
-
-    final DelayedClientTransport delayedTransport =
-        (DelayedClientTransport) transportSet.obtainActiveTransport();
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    assertFalse(delayedTransport.isInBackoffPeriod());
-
-    // Create a new fail fast stream.
-    ClientStream ffStream = delayedTransport.newStream(method, headers, failFastCallOptions,
-        statsTraceCtx);
-    ffStream.start(mockStreamListener);
-    // Verify it is queued.
-    assertEquals(++pendingStreamsCount, delayedTransport.getPendingStreamsCount());
-    failFastPendingStreamsCount++;
-    // Create a new non fail fast stream.
-    delayedTransport.newStream(method, headers, waitForReadyCallOptions, statsTraceCtx);
-    // Verify it is queued.
-    assertEquals(++pendingStreamsCount, delayedTransport.getPendingStreamsCount());
-
-    // Let this 1st address fail without success.
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    assertFalse(delayedTransport.isInBackoffPeriod());
-    // Verify pending streams still in queue.
-    assertEquals(pendingStreamsCount, delayedTransport.getPendingStreamsCount());
-
-    // Create a new fail fast stream.
-    delayedTransport.newStream(method, headers, failFastCallOptions, statsTraceCtx);
-    // Verify it is queued.
-    assertEquals(++pendingStreamsCount, delayedTransport.getPendingStreamsCount());
-    failFastPendingStreamsCount++;
-    // Create a new non fail fast stream
-    delayedTransport.newStream(method, headers, waitForReadyCallOptions, statsTraceCtx);
-    // Verify it is queued.
-    assertEquals(++pendingStreamsCount, delayedTransport.getPendingStreamsCount());
-
-    // Let this 2nd address fail without success.
-    Status failureStatus = Status.UNAVAILABLE.withDescription("some unique failure");
-    transports.poll().listener.transportShutdown(failureStatus);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    assertTrue(delayedTransport.isInBackoffPeriod());
-    // Fail fast pending streams should be cleared
-    assertEquals(pendingStreamsCount - failFastPendingStreamsCount,
-        delayedTransport.getPendingStreamsCount());
-    pendingStreamsCount -= failFastPendingStreamsCount;
-    failFastPendingStreamsCount = 0;
-    fakeExecutor.runDueTasks();
-    verify(mockStreamListener).closed(same(failureStatus), any(Metadata.class));
-
-    // Create a new fail fast stream.
-    delayedTransport.newStream(method, headers, failFastCallOptions, statsTraceCtx);
-    // Verify it is not queued.
-    assertEquals(pendingStreamsCount, delayedTransport.getPendingStreamsCount());
-    // Create a new non fail fast stream
-    delayedTransport.newStream(method, headers, waitForReadyCallOptions, statsTraceCtx);
-    // Verify it is queued.
-    assertEquals(++pendingStreamsCount, delayedTransport.getPendingStreamsCount());
-
-    fakeClock.forwardMillis(10);
-    // Now back-off is over
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    assertFalse(delayedTransport.isInBackoffPeriod());
-
-    // Create a new fail fast stream.
-    delayedTransport.newStream(method, headers, failFastCallOptions, statsTraceCtx);
-    // Verify it is queued.
-    assertEquals(++pendingStreamsCount, delayedTransport.getPendingStreamsCount());
-    failFastPendingStreamsCount++;
-    assertEquals(1, failFastPendingStreamsCount);
-
-    fakeExecutor.runDueTasks(); // Drain new 'real' stream creation; not important to this test.
-  }
-
-  @Test
-  public void connectIsLazy() {
-    SocketAddress addr = mock(SocketAddress.class);
-    createTransportSet(addr);
-
-    // Invocation counters
-    int transportsCreated = 0;
-
-    // Won't connect until requested
-    verify(mockTransportFactory, times(transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
-
-    // First attempt
-    transportSet.obtainActiveTransport().newStream(method, new Metadata());
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
-
-    // Fail this one
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-
-    // Will always reconnect after back-off
-    fakeClock.forwardMillis(10);
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
-
-    // Make this one proceed
-    transports.peek().listener.transportReady();
-    assertEquals(ConnectivityState.READY, transportSet.getState(false));
-    // Then go-away
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.IDLE, transportSet.getState(false));
-
-    // Request immediately
-    transportSet.obtainActiveTransport().newStream(method, new Metadata(), waitForReadyCallOptions,
-        statsTraceCtx);
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    verify(mockTransportFactory, times(++transportsCreated))
-        .newClientTransport(addr, AUTHORITY, USER_AGENT);
-    fakeExecutor.runDueTasks(); // Drain new 'real' stream creation; not important to this test.
-  }
-
-  @Test
-  public void shutdownBeforeTransportCreatedWithPendingStream() throws Exception {
-    SocketAddress addr = mock(SocketAddress.class);
-    createTransportSet(addr);
-
-    // First transport is created immediately
-    ClientTransport pick = transportSet.obtainActiveTransport();
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    verify(mockTransportFactory).newClientTransport(addr, AUTHORITY, USER_AGENT);
-    assertNotNull(pick);
-    // Fail this one
-    MockClientTransportInfo transportInfo = transports.poll();
-    transportInfo.listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    transportInfo.listener.transportTerminated();
-
-    // Second transport will wait for back-off
-    pick = transportSet.obtainActiveTransport();
-    assertTrue(pick instanceof DelayedClientTransport);
-    // Start a stream, which will be pending in the delayed transport
-    ClientStream pendingStream = pick.newStream(method, headers, waitForReadyCallOptions,
-        statsTraceCtx);
-    pendingStream.start(mockStreamListener);
-
-    // Shut down TransportSet before the transport is created. Further call to
-    // obtainActiveTransport() gets failing transports
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(false));
-    transportSet.shutdown();
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-    pick = transportSet.obtainActiveTransport();
-    assertNotNull(pick);
-    assertTrue(pick instanceof FailingClientTransport);
-    verify(mockTransportFactory).newClientTransport(addr, AUTHORITY, USER_AGENT);
-
-    // Reconnect will eventually happen, even though TransportSet has been shut down
-    fakeClock.forwardMillis(10);
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-    verify(mockTransportFactory, times(2)).newClientTransport(addr, AUTHORITY, USER_AGENT);
-    // The pending stream will be started on this newly started transport after it's ready.
-    // The transport is shut down by TransportSet right after the stream is created.
-    transportInfo = transports.poll();
-    verify(transportInfo.transport, times(0)).shutdown();
-    assertEquals(0, fakeExecutor.numPendingTasks());
-    transportInfo.listener.transportReady();
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-    verify(transportInfo.transport, times(0)).newStream(
-        any(MethodDescriptor.class), any(Metadata.class));
-    assertEquals(1, fakeExecutor.runDueTasks());
-    verify(transportInfo.transport).newStream(same(method), same(headers),
-        same(waitForReadyCallOptions), any(StatsTraceContext.class));
-    verify(transportInfo.transport).shutdown();
-    transportInfo.listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-    verify(mockTransportSetCallback, never()).onTerminated(any(TransportSet.class));
-    // Terminating the transport will let TransportSet to be terminated.
-    transportInfo.listener.transportTerminated();
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-    verify(mockTransportSetCallback).onTerminated(transportSet);
-
-    // No more transports will be created.
-    fakeClock.forwardMillis(10000);
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-    verifyNoMoreInteractions(mockTransportFactory);
-    assertEquals(0, transports.size());
-  }
-
-  @Test
-  public void shutdownBeforeTransportCreatedWithoutPendingStream() throws Exception {
-    SocketAddress addr = mock(SocketAddress.class);
-    createTransportSet(addr);
-
-    // First transport is created immediately
-    ClientTransport pick = transportSet.obtainActiveTransport();
-    verify(mockTransportFactory).newClientTransport(addr, AUTHORITY, USER_AGENT);
-    assertNotNull(pick);
-    // Fail this one
-    MockClientTransportInfo transportInfo = transports.poll();
-    transportInfo.listener.transportShutdown(Status.UNAVAILABLE);
-    transportInfo.listener.transportTerminated();
-
-    // Second transport will wait for back-off
-    pick = transportSet.obtainActiveTransport();
-    assertTrue(pick instanceof DelayedClientTransport);
-
-    // Shut down TransportSet before the transport is created. Futher call to
-    // obtainActiveTransport() gets failing transports
-    transportSet.shutdown();
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-    pick = transportSet.obtainActiveTransport();
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-    assertNotNull(pick);
-    assertTrue(pick instanceof FailingClientTransport);
-
-    // TransportSet terminated promptly.
-    verify(mockTransportSetCallback).onTerminated(transportSet);
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-
-    // No more transports will be created.
-    fakeClock.forwardMillis(10000);
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-    verifyNoMoreInteractions(mockTransportFactory);
-    assertEquals(0, transports.size());
-  }
-
-  @Test
-  public void shutdownBeforeTransportReady() throws Exception {
-    SocketAddress addr = mock(SocketAddress.class);
-    createTransportSet(addr);
-
-    ClientTransport pick = transportSet.obtainActiveTransport();
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-    MockClientTransportInfo transportInfo = transports.poll();
-    assertNotSame(transportInfo.transport, pick);
-
-    // Shutdown the TransportSet before the pending transport is ready
-    transportSet.shutdown();
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-
-    // The transport should've been shut down even though it's not the active transport yet.
-    verify(transportInfo.transport).shutdown();
-    transportInfo.listener.transportShutdown(Status.UNAVAILABLE);
-    transportInfo.listener.transportTerminated();
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-  }
-
-  @Test
-  public void obtainTransportAfterShutdown() throws Exception {
-    SocketAddress addr = mock(SocketAddress.class);
-    createTransportSet(addr);
-
-    transportSet.shutdown();
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-    ClientTransport pick = transportSet.obtainActiveTransport();
-    assertNotNull(pick);
-    verify(mockTransportFactory, times(0)).newClientTransport(addr, AUTHORITY, USER_AGENT);
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-  }
-
-  @Test
-  public void requireConnectionThroughGetState() throws Exception {
-    SocketAddress addr = mock(SocketAddress.class);
-    createTransportSet(addr);
-
-    assertEquals(ConnectivityState.IDLE, transportSet.getState(false));
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(true));
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(true));
-
-    transportSet.obtainActiveTransport().newStream(method, new Metadata(), waitForReadyCallOptions,
-        statsTraceCtx);
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(true));
-
-    // Fail it
-    transports.peek().listener.transportShutdown(Status.UNAVAILABLE);
-    // requireConnection == true doesn't skip the back-off
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(true));
-    transports.poll().listener.transportTerminated();
-    fakeClock.forwardMillis(9);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(true));
-    fakeClock.forwardMillis(1);
-    // Only when back-off is over, do we try to connect again
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(false));
-
-    // Let it through and fail, thus a go-away
-    transports.peek().listener.transportReady();
-    transports.peek().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.IDLE, transportSet.getState(false));
-    transports.poll().listener.transportTerminated();
-
-    // Request for connecting again
-    assertEquals(ConnectivityState.CONNECTING, transportSet.getState(true));
-    // And fail it again
-    transports.peek().listener.transportShutdown(Status.UNAVAILABLE);
-    assertEquals(ConnectivityState.TRANSIENT_FAILURE, transportSet.getState(true));
-
-    // Shut it down
-    transportSet.shutdown();
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(true));
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-    assertFalse(transportSet.isTerminated());
-
-    // Terminate it
-    transports.poll().listener.transportTerminated();
-    assertTrue(transportSet.isTerminated());
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(true));
-    assertEquals(ConnectivityState.SHUTDOWN, transportSet.getState(false));
-
-    fakeExecutor.runDueTasks(); // What tasks are scheduled is not important to this test.
-  }
-
-  @Test
-  public void logId() {
-    createTransportSet(mock(SocketAddress.class));
-
-    assertNotNull(transportSet.getLogId());
-  }
-
-  @Test
-  public void inUseState() {
-    SocketAddress addr = mock(SocketAddress.class);
-    createTransportSet(addr);
-
-    // Invocation counters
-    int inUse = 0;
-    int notInUse = 0;
-
-    verify(mockTransportSetCallback, never()).onInUse(any(TransportSet.class));
-    transportSet.obtainActiveTransport().newStream(method, new Metadata(), waitForReadyCallOptions,
-        statsTraceCtx);
-    verify(mockTransportSetCallback, times(++inUse)).onInUse(transportSet);
-
-    MockClientTransportInfo t0 = transports.poll();
-
-    verify(mockTransportSetCallback, never()).onNotInUse(any(TransportSet.class));
-    t0.listener.transportReady();
-    // The race between delayed transport being terminated (thus not in-use) and
-    // the real transport become in-use, caused a brief period of TransportSet not in-use.
-    verify(mockTransportSetCallback, times(++notInUse)).onNotInUse(transportSet);
-    // Delayed transport calls newStream() on the real transport in the executor
-    fakeExecutor.runDueTasks();
-    verify(t0.transport).newStream(
-        same(method), any(Metadata.class), same(waitForReadyCallOptions),
-        any(StatsTraceContext.class));
-    verify(mockTransportSetCallback, times(inUse)).onInUse(transportSet);
-    t0.listener.transportInUse(true);
-    verify(mockTransportSetCallback, times(++inUse)).onInUse(transportSet);
-
-    t0.listener.transportInUse(false);
-    verify(mockTransportSetCallback, times(++notInUse)).onNotInUse(transportSet);
-
-    t0.listener.transportInUse(true);
-    verify(mockTransportSetCallback, times(++inUse)).onInUse(transportSet);
-
-    // Simulate that the server sends a go-away
-    t0.listener.transportShutdown(Status.UNAVAILABLE);
-
-    // Creates a new transport
-    transportSet.obtainActiveTransport().newStream(method, new Metadata(), waitForReadyCallOptions,
-        statsTraceCtx);
-    MockClientTransportInfo t1 = transports.poll();
-    t1.listener.transportReady();
-    // Delayed transport calls newStream() on the real transport in the executor
-    fakeExecutor.runDueTasks();
-    verify(t1.transport).newStream(
-        same(method), any(Metadata.class), same(waitForReadyCallOptions),
-        any(StatsTraceContext.class));
-    t1.listener.transportInUse(true);
-    // No turbulance from the race mentioned eariler, because t0 has been in-use
-    verify(mockTransportSetCallback, times(inUse)).onInUse(transportSet);
-    verify(mockTransportSetCallback, times(notInUse)).onNotInUse(transportSet);
-
-    // TransportSet is not in-use when both transports are not in-use.
-    t1.listener.transportInUse(false);
-    verify(mockTransportSetCallback, times(notInUse)).onNotInUse(transportSet);
-    t0.listener.transportInUse(false);
-    verify(mockTransportSetCallback, times(++notInUse)).onNotInUse(transportSet);
-    verify(mockTransportSetCallback, times(inUse)).onInUse(transportSet);
-  }
-
-  @Test
-  public void scheduleBackoff_DoNotScheduleEndOfBackoffIfAlreadyShutdown() {
-    // Setup
-    final boolean[] startBackoffAndShutdownAreCalled = {false};
-    Executor executor = new Executor() {
-      @Override
-      public void execute(Runnable command) {
-        if (command.getClass().getName().contains("FailTheFailFastPendingStreams")) {
-          // shutdown during startBackoff
-          transportSet.shutdown();
-          startBackoffAndShutdownAreCalled[0] = true;
-        }
-        fakeExecutor.getScheduledExecutorService().execute(command);
-      }
-    };
-    SocketAddress addr = mock(SocketAddress.class);
-    addressGroup = new EquivalentAddressGroup(Arrays.asList(addr));
-    transportSet = new TransportSet(addressGroup, AUTHORITY, USER_AGENT, mockLoadBalancer,
-        mockBackoffPolicyProvider, mockTransportFactory, fakeClock.getScheduledExecutorService(),
-        fakeClock.getStopwatchSupplier(), executor, mockTransportSetCallback);
-
-    // Attempt and fail, scheduleBackoff should be triggered,
-    // and transportSet.shutdown should be triggered by setup
-    transportSet.obtainActiveTransport().newStream(method, new Metadata(), waitForReadyCallOptions,
-        statsTraceCtx);
-    transports.poll().listener.transportShutdown(Status.UNAVAILABLE);
-    verify(mockTransportSetCallback, times(1)).onAllAddressesFailed();
-    assertTrue(startBackoffAndShutdownAreCalled[0]);
-
-    fakeExecutor.runDueTasks();
-    // verify endOfBackoff not scheduled
-    verify(mockBackoffPolicy1, never()).nextBackoffMillis();
-  }
-
-  private void createTransportSet(SocketAddress ... addrs) {
-    addressGroup = new EquivalentAddressGroup(Arrays.asList(addrs));
-    transportSet = new TransportSet(addressGroup, AUTHORITY, USER_AGENT, mockLoadBalancer,
-        mockBackoffPolicyProvider, mockTransportFactory, fakeClock.getScheduledExecutorService(),
-        fakeClock.getStopwatchSupplier(), fakeExecutor.getScheduledExecutorService(),
-        mockTransportSetCallback);
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/WritableBufferAllocatorTestBase.java b/core/src/test/java/io/grpc/internal/WritableBufferAllocatorTestBase.java
deleted file mode 100644
index cd14c297110..00000000000
--- a/core/src/test/java/io/grpc/internal/WritableBufferAllocatorTestBase.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static org.junit.Assert.assertNotSame;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Abstract base class for tests of {@link WritableBufferAllocator} subclasses.
- */
-@RunWith(JUnit4.class)
-public abstract class WritableBufferAllocatorTestBase {
-
-  protected abstract WritableBufferAllocator allocator();
-
-  @Test
-  public void testBuffersAreDifferent() {
-    WritableBuffer buffer1 = allocator().allocate(100);
-    WritableBuffer buffer2 = allocator().allocate(100);
-
-    assertNotSame(buffer1, buffer2);
-
-    buffer1.release();
-    buffer2.release();
-  }
-}
diff --git a/core/src/test/java/io/grpc/internal/WritableBufferTestBase.java b/core/src/test/java/io/grpc/internal/WritableBufferTestBase.java
deleted file mode 100644
index 902ac29bc52..00000000000
--- a/core/src/test/java/io/grpc/internal/WritableBufferTestBase.java
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Abstract base class for tests of {@link WritableBuffer} subclasses.
- */
-@RunWith(JUnit4.class)
-public abstract class WritableBufferTestBase {
-
-  /**
-   * Returns a new buffer for every test case with
-   * at least 100 byte of capacity.
-   */
-  protected abstract WritableBuffer buffer();
-
-  /**
-   * Bytes written to {@link #buffer()}.
-   */
-  protected abstract byte[] writtenBytes();
-
-  @Test(expected = RuntimeException.class)
-  public void testWriteNegativeLength() {
-    buffer().write(new byte[1], 0, -1);
-  }
-
-  @Test(expected = IndexOutOfBoundsException.class)
-  public void testWriteNegativeSrcIndex() {
-    buffer().write(new byte[1], -1, 0);
-  }
-
-  @Test(expected = IndexOutOfBoundsException.class)
-  public void testWriteSrcIndexAndLengthExceedSrcLength() {
-    buffer().write(new byte[10], 1, 10);
-  }
-
-  @Test(expected = IndexOutOfBoundsException.class)
-  public void testWriteSrcIndexAndLengthExceedWritableBytes() {
-    buffer().write(new byte[buffer().writableBytes()], 1, buffer().writableBytes());
-  }
-
-  @Test
-  public void testWritableAndReadableBytes() {
-    int before = buffer().writableBytes();
-    buffer().write(new byte[10], 0, 5);
-
-    assertEquals(5, before - buffer().writableBytes());
-    assertEquals(5, buffer().readableBytes());
-  }
-
-  @Test
-  public void testWriteSrcIndex() {
-    byte[] b = new byte[10];
-    for (byte i = 5; i < 10; i++) {
-      b[i] = i;
-    }
-
-    buffer().write(b, 5, 5);
-
-    assertEquals(5, buffer().readableBytes());
-    byte[] writtenBytes = writtenBytes();
-    assertEquals(5, writtenBytes.length);
-    for (int i = 0; i < writtenBytes.length; i++) {
-      assertEquals(5 + i, writtenBytes[i]);
-    }
-  }
-
-  @Test
-  public void testMultipleWrites() {
-    byte[] b = new byte[100];
-    for (byte i = 0; i < b.length; i++) {
-      b[i] = i;
-    }
-
-    // Write in chunks of 10 bytes
-    for (int i = 0; i < 10; i++) {
-      buffer().write(b, 10 * i, 10);
-      assertEquals(10 * (i + 1), buffer().readableBytes());
-    }
-
-    assertArrayEquals(b, writtenBytes());
-  }
-}
diff --git a/core/src/test/java/io/grpc/util/RoundRobinLoadBalancer2Test.java b/core/src/test/java/io/grpc/util/RoundRobinLoadBalancer2Test.java
deleted file mode 100644
index fb28afa4963..00000000000
--- a/core/src/test/java/io/grpc/util/RoundRobinLoadBalancer2Test.java
+++ /dev/null
@@ -1,375 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.util;
-
-import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.ConnectivityState.IDLE;
-import static io.grpc.ConnectivityState.READY;
-import static io.grpc.util.RoundRobinLoadBalancerFactory2.RoundRobinLoadBalancer.STATE_INFO;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import io.grpc.Attributes;
-import io.grpc.ConnectivityState;
-import io.grpc.ConnectivityStateInfo;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.Helper;
-import io.grpc.LoadBalancer2.Subchannel;
-import io.grpc.Metadata;
-import io.grpc.ResolvedServerInfo;
-import io.grpc.ResolvedServerInfoGroup;
-import io.grpc.Status;
-import io.grpc.util.RoundRobinLoadBalancerFactory2.Picker;
-import io.grpc.util.RoundRobinLoadBalancerFactory2.RoundRobinLoadBalancer;
-import java.net.SocketAddress;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.atomic.AtomicReference;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-/** Unit test for {@link RoundRobinLoadBalancerFactory2}. */
-@RunWith(JUnit4.class)
-public class RoundRobinLoadBalancer2Test {
-  private RoundRobinLoadBalancer loadBalancer;
-  private Map<ResolvedServerInfoGroup, EquivalentAddressGroup> servers = Maps.newHashMap();
-  private Map<EquivalentAddressGroup, Subchannel> subchannels = Maps.newLinkedHashMap();
-  private static final Attributes.Key<String> MAJOR_KEY = Attributes.Key.of("major-key");
-  private Attributes affinity = Attributes.newBuilder().set(MAJOR_KEY, "I got the keys").build();
-
-  @Captor
-  private ArgumentCaptor<Picker> pickerCaptor;
-  @Captor
-  private ArgumentCaptor<EquivalentAddressGroup> eagCaptor;
-  @Mock
-  private Helper mockHelper;
-  @Mock
-  private Subchannel mockSubchannel;
-
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-
-    for (int i = 0; i < 3; i++) {
-      SocketAddress addr = new FakeSocketAddress("server" + i);
-      EquivalentAddressGroup eag = new EquivalentAddressGroup(addr);
-      servers.put(ResolvedServerInfoGroup.builder().add(new ResolvedServerInfo(addr)).build(), eag);
-      subchannels.put(eag, createMockSubchannel());
-    }
-
-    when(mockHelper.createSubchannel(any(EquivalentAddressGroup.class), any(Attributes.class)))
-        .then(new Answer<Subchannel>() {
-          @Override
-          public Subchannel answer(InvocationOnMock invocation) throws Throwable {
-            Object[] args = invocation.getArguments();
-            return subchannels.get(args[0]);
-          }
-        });
-
-    loadBalancer = (RoundRobinLoadBalancer) RoundRobinLoadBalancerFactory2.getInstance()
-        .newLoadBalancer(mockHelper);
-  }
-
-  @Test
-  public void pickAfterResolved() throws Exception {
-    Subchannel readySubchannel = subchannels.get(servers.get(servers.keySet().iterator().next()));
-    when(readySubchannel.getAttributes()).thenReturn(Attributes.newBuilder()
-        .set(STATE_INFO, new AtomicReference<ConnectivityStateInfo>(
-            ConnectivityStateInfo.forNonError(READY)))
-        .build());
-    loadBalancer.handleResolvedAddresses(Lists.newArrayList(servers.keySet()), affinity);
-
-    verify(mockHelper, times(3)).createSubchannel(eagCaptor.capture(),
-        any(Attributes.class));
-
-    assertThat(eagCaptor.getAllValues()).containsAllIn(subchannels.keySet());
-    for (Subchannel subchannel : subchannels.values()) {
-      verify(subchannel).requestConnection();
-      verify(subchannel, never()).shutdown();
-    }
-
-    verify(mockHelper, times(1)).updatePicker(pickerCaptor.capture());
-
-    assertThat(pickerCaptor.getValue().getList()).containsExactly(readySubchannel);
-
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void pickAfterResolvedUpdatedHosts() throws Exception {
-    Subchannel removedSubchannel = mock(Subchannel.class);
-    Subchannel oldSubchannel = mock(Subchannel.class);
-    Subchannel newSubchannel = mock(Subchannel.class);
-
-    for (Subchannel subchannel : Lists.newArrayList(removedSubchannel, oldSubchannel,
-        newSubchannel)) {
-      when(subchannel.getAttributes()).thenReturn(Attributes.newBuilder().set(STATE_INFO,
-          new AtomicReference<ConnectivityStateInfo>(
-              ConnectivityStateInfo.forNonError(READY))).build());
-    }
-
-    FakeSocketAddress removedAddr = new FakeSocketAddress("removed");
-    FakeSocketAddress oldAddr = new FakeSocketAddress("old");
-    FakeSocketAddress newAddr = new FakeSocketAddress("new");
-
-    final Map<EquivalentAddressGroup, Subchannel> subchannels2 = Maps.newHashMap();
-    subchannels2.put(new EquivalentAddressGroup(removedAddr), removedSubchannel);
-    subchannels2.put(new EquivalentAddressGroup(oldAddr), oldSubchannel);
-
-    List<ResolvedServerInfoGroup> currentServers = Lists.newArrayList(
-        ResolvedServerInfoGroup.builder()
-            .add(new ResolvedServerInfo(removedAddr))
-            .add(new ResolvedServerInfo(oldAddr))
-            .build());
-
-    when(mockHelper.createSubchannel(any(EquivalentAddressGroup.class), any(Attributes.class)))
-        .then(new Answer<Subchannel>() {
-          @Override
-          public Subchannel answer(InvocationOnMock invocation) throws Throwable {
-            Object[] args = invocation.getArguments();
-            return subchannels2.get(args[0]);
-          }
-        });
-
-    loadBalancer.handleResolvedAddresses(currentServers, affinity);
-
-    InOrder inOrder = inOrder(mockHelper);
-
-    inOrder.verify(mockHelper).updatePicker(pickerCaptor.capture());
-    Picker picker = pickerCaptor.getValue();
-    assertNull(picker.getStatus());
-    assertThat(picker.getList()).containsExactly(removedSubchannel, oldSubchannel);
-
-    verify(removedSubchannel, times(1)).requestConnection();
-    verify(oldSubchannel, times(1)).requestConnection();
-
-    assertThat(loadBalancer.getSubchannels()).containsExactly(removedSubchannel,
-        oldSubchannel);
-
-    subchannels2.clear();
-    subchannels2.put(new EquivalentAddressGroup(oldAddr), oldSubchannel);
-    subchannels2.put(new EquivalentAddressGroup(newAddr), newSubchannel);
-
-    List<ResolvedServerInfoGroup> latestServers = Lists.newArrayList(
-        ResolvedServerInfoGroup.builder()
-            .add(new ResolvedServerInfo(oldAddr))
-            .add(new ResolvedServerInfo(newAddr))
-            .build());
-
-    loadBalancer.handleResolvedAddresses(latestServers, affinity);
-
-    verify(newSubchannel, times(1)).requestConnection();
-    verify(removedSubchannel, times(1)).shutdown();
-
-    assertThat(loadBalancer.getSubchannels()).containsExactly(oldSubchannel,
-        newSubchannel);
-
-    verify(mockHelper, times(3)).createSubchannel(any(EquivalentAddressGroup.class),
-        any(Attributes.class));
-    inOrder.verify(mockHelper).updatePicker(pickerCaptor.capture());
-
-    picker = pickerCaptor.getValue();
-    assertNull(picker.getStatus());
-    assertThat(picker.getList()).containsExactly(oldSubchannel, newSubchannel);
-
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void pickAfterStateChangeBeforeResolution() throws Exception {
-    loadBalancer.handleSubchannelState(mockSubchannel,
-        ConnectivityStateInfo.forNonError(ConnectivityState.READY));
-    verifyNoMoreInteractions(mockSubchannel);
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void pickAfterStateChangeAndResolutionError() throws Exception {
-    loadBalancer.handleSubchannelState(mockSubchannel,
-        ConnectivityStateInfo.forNonError(ConnectivityState.READY));
-    verifyNoMoreInteractions(mockSubchannel);
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void pickAfterStateChange() throws Exception {
-    InOrder inOrder = inOrder(mockHelper);
-    when(mockHelper.createSubchannel(any(EquivalentAddressGroup.class), any(Attributes.class)))
-        .then(new Answer<Subchannel>() {
-          @Override
-          public Subchannel answer(InvocationOnMock invocation) throws Throwable {
-            return createMockSubchannel();
-          }
-        });
-    loadBalancer.handleResolvedAddresses(Lists.newArrayList(servers.keySet()), Attributes.EMPTY);
-    Subchannel subchannel = loadBalancer.getSubchannels().iterator().next();
-    AtomicReference<ConnectivityStateInfo> subchannelStateInfo = subchannel.getAttributes().get(
-        STATE_INFO);
-
-    inOrder.verify(mockHelper).updatePicker(isA(Picker.class));
-    assertThat(subchannelStateInfo.get()).isEqualTo(ConnectivityStateInfo.forNonError(IDLE));
-
-    loadBalancer.handleSubchannelState(subchannel,
-        ConnectivityStateInfo.forNonError(ConnectivityState.READY));
-    inOrder.verify(mockHelper).updatePicker(pickerCaptor.capture());
-    assertNull(pickerCaptor.getValue().getStatus());
-    assertThat(subchannelStateInfo.get()).isEqualTo(
-        ConnectivityStateInfo.forNonError(ConnectivityState.READY));
-
-    Status error = Status.UNKNOWN.withDescription("¯\\_(ツ)_//¯");
-    loadBalancer.handleSubchannelState(subchannel,
-        ConnectivityStateInfo.forTransientFailure(error));
-    assertThat(subchannelStateInfo.get()).isEqualTo(
-        ConnectivityStateInfo.forTransientFailure(error));
-    inOrder.verify(mockHelper).updatePicker(pickerCaptor.capture());
-    assertNull(pickerCaptor.getValue().getStatus());
-
-    loadBalancer.handleSubchannelState(subchannel,
-        ConnectivityStateInfo.forNonError(ConnectivityState.IDLE));
-    inOrder.verify(mockHelper).updatePicker(pickerCaptor.capture());
-    assertNull(pickerCaptor.getValue().getStatus());
-    assertThat(subchannelStateInfo.get()).isEqualTo(
-        ConnectivityStateInfo.forNonError(ConnectivityState.IDLE));
-
-    verify(subchannel, times(2)).requestConnection();
-    verify(mockHelper, times(3)).createSubchannel(any(EquivalentAddressGroup.class),
-        any(Attributes.class));
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void pickerRoundRobin() throws Exception {
-    Subchannel subchannel = mock(Subchannel.class);
-    Subchannel subchannel1 = mock(Subchannel.class);
-    Subchannel subchannel2 = mock(Subchannel.class);
-
-    Picker picker = new Picker(Collections.unmodifiableList(
-        Lists.<Subchannel>newArrayList(subchannel, subchannel1, subchannel2)), null);
-
-    assertThat(picker.getList()).containsExactly(subchannel, subchannel1, subchannel2);
-
-    assertEquals(subchannel,
-        picker.pickSubchannel(Attributes.EMPTY, new Metadata()).getSubchannel());
-    assertEquals(subchannel1,
-        picker.pickSubchannel(Attributes.EMPTY, new Metadata()).getSubchannel());
-    assertEquals(subchannel2,
-        picker.pickSubchannel(Attributes.EMPTY, new Metadata()).getSubchannel());
-    assertEquals(subchannel,
-        picker.pickSubchannel(Attributes.EMPTY, new Metadata()).getSubchannel());
-  }
-
-  @Test
-  public void pickerEmptyList() throws Exception {
-    Picker picker = new Picker(Lists.<Subchannel>newArrayList(), Status.UNKNOWN);
-
-    assertEquals(null, picker.pickSubchannel(Attributes.EMPTY, new Metadata()).getSubchannel());
-    assertEquals(Status.UNKNOWN,
-        picker.pickSubchannel(Attributes.EMPTY, new Metadata()).getStatus());
-  }
-
-  @Test
-  public void nameResolutionErrorWithNoChannels() throws Exception {
-    Status error = Status.NOT_FOUND.withDescription("nameResolutionError");
-    loadBalancer.handleNameResolutionError(error);
-    verify(mockHelper).updatePicker(pickerCaptor.capture());
-    LoadBalancer2.PickResult pickResult = pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
-        new Metadata());
-    assertNull(pickResult.getSubchannel());
-    assertEquals(error, pickResult.getStatus());
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  @Test
-  public void nameResolutionErrorWithActiveChannels() throws Exception {
-    Subchannel readySubchannel = subchannels.values().iterator().next();
-    readySubchannel.getAttributes().get(STATE_INFO).set(ConnectivityStateInfo.forNonError(READY));
-    loadBalancer.handleResolvedAddresses(Lists.newArrayList(servers.keySet()), affinity);
-    loadBalancer.handleNameResolutionError(Status.NOT_FOUND.withDescription("nameResolutionError"));
-
-    verify(mockHelper, times(3)).createSubchannel(any(EquivalentAddressGroup.class),
-        any(Attributes.class));
-    verify(mockHelper, times(2)).updatePicker(pickerCaptor.capture());
-
-    LoadBalancer2.PickResult pickResult = pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
-        new Metadata());
-    assertEquals(readySubchannel, pickResult.getSubchannel());
-    assertEquals(Status.OK.getCode(), pickResult.getStatus().getCode());
-
-    LoadBalancer2.PickResult pickResult2 = pickerCaptor.getValue().pickSubchannel(Attributes.EMPTY,
-        new Metadata());
-    assertEquals(readySubchannel, pickResult2.getSubchannel());
-    verifyNoMoreInteractions(mockHelper);
-  }
-
-  private Subchannel createMockSubchannel() {
-    Subchannel subchannel = mock(Subchannel.class);
-    when(subchannel.getAttributes()).thenReturn(Attributes.newBuilder().set(STATE_INFO,
-        new AtomicReference<ConnectivityStateInfo>(
-            ConnectivityStateInfo.forNonError(IDLE))).build());
-    return subchannel;
-  }
-
-  private static class FakeSocketAddress extends SocketAddress {
-    final String name;
-
-    FakeSocketAddress(String name) {
-      this.name = name;
-    }
-
-    @Override
-    public String toString() {
-      return "FakeSocketAddress-" + name;
-    }
-  }
-}
diff --git a/core/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java b/core/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java
deleted file mode 100644
index 7dc3f7e04dd..00000000000
--- a/core/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.util;
-
-import static org.junit.Assert.assertSame;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-import com.google.common.base.Supplier;
-import com.google.common.collect.Lists;
-import io.grpc.Attributes;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer;
-import io.grpc.ResolvedServerInfo;
-import io.grpc.ResolvedServerInfoGroup;
-import io.grpc.Status;
-import io.grpc.TransportManager;
-import io.grpc.TransportManager.InterimTransport;
-import java.net.SocketAddress;
-import java.util.List;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
-
-/** Unit test for {@link RoundRobinLoadBalancerFactory}. */
-@RunWith(JUnit4.class)
-public class RoundRobinLoadBalancerTest {
-  private LoadBalancer<Transport> loadBalancer;
-
-  private List<ResolvedServerInfoGroup> servers;
-  private List<EquivalentAddressGroup> addressGroupList;
-
-  @Mock private TransportManager<Transport> mockTransportManager;
-  @Mock private Transport mockTransport0;
-  @Mock private Transport mockTransport1;
-  @Mock private Transport mockTransport2;
-  @Mock private InterimTransport<Transport> mockInterimTransport;
-  @Mock private Transport mockInterimTransportAsTransport;
-  @Captor private ArgumentCaptor<Supplier<Transport>> transportSupplierCaptor;
-
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    loadBalancer = RoundRobinLoadBalancerFactory.getInstance().newLoadBalancer(
-        "fakeservice", mockTransportManager);
-    addressGroupList = Lists.newArrayList();
-    servers = Lists.newArrayList();
-    for (int i = 0; i < 3; i++) {
-      ResolvedServerInfoGroup.Builder resolvedServerInfoGroup = ResolvedServerInfoGroup.builder();
-      for (int j = 0; j < 3; j++) {
-        resolvedServerInfoGroup.add(
-            new ResolvedServerInfo(new FakeSocketAddress("servergroup" + i + "server" + j)));
-      }
-      servers.add(resolvedServerInfoGroup.build());
-      addressGroupList.add(resolvedServerInfoGroup.build().toEquivalentAddressGroup());
-    }
-    when(mockTransportManager.getTransport(eq(addressGroupList.get(0))))
-        .thenReturn(mockTransport0);
-    when(mockTransportManager.getTransport(eq(addressGroupList.get(1))))
-        .thenReturn(mockTransport1);
-    when(mockTransportManager.getTransport(eq(addressGroupList.get(2))))
-        .thenReturn(mockTransport2);
-    when(mockTransportManager.createInterimTransport()).thenReturn(mockInterimTransport);
-    when(mockInterimTransport.transport()).thenReturn(mockInterimTransportAsTransport);
-  }
-
-  @Test
-  public void pickBeforeResolved() throws Exception {
-    Transport t1 = loadBalancer.pickTransport(null);
-    Transport t2 = loadBalancer.pickTransport(null);
-    assertSame(mockInterimTransportAsTransport, t1);
-    assertSame(mockInterimTransportAsTransport, t2);
-    verify(mockTransportManager).createInterimTransport();
-    verify(mockTransportManager, never()).getTransport(any(EquivalentAddressGroup.class));
-    verify(mockInterimTransport, times(2)).transport();
-
-    loadBalancer.handleResolvedAddresses(servers, Attributes.EMPTY);
-    verify(mockInterimTransport).closeWithRealTransports(transportSupplierCaptor.capture());
-    assertSame(mockTransport0, transportSupplierCaptor.getValue().get());
-    assertSame(mockTransport1, transportSupplierCaptor.getValue().get());
-    InOrder inOrder = Mockito.inOrder(mockTransportManager);
-    inOrder.verify(mockTransportManager).getTransport(eq(addressGroupList.get(0)));
-    inOrder.verify(mockTransportManager).getTransport(eq(addressGroupList.get(1)));
-    inOrder.verifyNoMoreInteractions();
-    verifyNoMoreInteractions(mockInterimTransport);
-  }
-
-  @Test
-  public void pickBeforeNameResolutionError() {
-    Transport t1 = loadBalancer.pickTransport(null);
-    Transport t2 = loadBalancer.pickTransport(null);
-    assertSame(mockInterimTransportAsTransport, t1);
-    assertSame(mockInterimTransportAsTransport, t2);
-    verify(mockTransportManager).createInterimTransport();
-    verify(mockTransportManager, never()).getTransport(any(EquivalentAddressGroup.class));
-    verify(mockInterimTransport, times(2)).transport();
-
-    loadBalancer.handleNameResolutionError(Status.UNAVAILABLE);
-    verify(mockInterimTransport).closeWithError(any(Status.class));
-    // Ensure a shutdown after error closes without incident
-    loadBalancer.shutdown();
-    // Ensure a name resolution error after shutdown does nothing
-    loadBalancer.handleNameResolutionError(Status.UNAVAILABLE);
-    verifyNoMoreInteractions(mockInterimTransport);
-  }
-
-  @Test
-  public void pickBeforeShutdown() {
-    Transport t1 = loadBalancer.pickTransport(null);
-    Transport t2 = loadBalancer.pickTransport(null);
-    assertSame(mockInterimTransportAsTransport, t1);
-    assertSame(mockInterimTransportAsTransport, t2);
-    verify(mockTransportManager).createInterimTransport();
-    verify(mockTransportManager, never()).getTransport(any(EquivalentAddressGroup.class));
-    verify(mockInterimTransport, times(2)).transport();
-
-    loadBalancer.shutdown();
-    verify(mockInterimTransport).closeWithError(any(Status.class));
-    // Ensure double shutdown just returns immediately without closing again.
-    loadBalancer.shutdown();
-    verifyNoMoreInteractions(mockInterimTransport);
-  }
-
-  @Test
-  public void pickAfterResolved() throws Exception {
-    loadBalancer.handleResolvedAddresses(servers, Attributes.EMPTY);
-    InOrder inOrder = Mockito.inOrder(mockTransportManager);
-    for (int i = 0; i < 100; i++) {
-      assertSame(mockTransport0, loadBalancer.pickTransport(null));
-      inOrder.verify(mockTransportManager).getTransport(eq(addressGroupList.get(0)));
-      assertSame(mockTransport1, loadBalancer.pickTransport(null));
-      inOrder.verify(mockTransportManager).getTransport(eq(addressGroupList.get(1)));
-      assertSame(mockTransport2, loadBalancer.pickTransport(null));
-      inOrder.verify(mockTransportManager).getTransport(eq(addressGroupList.get(2)));
-    }
-    inOrder.verifyNoMoreInteractions();
-  }
-
-  private static class FakeSocketAddress extends SocketAddress {
-    final String name;
-
-    FakeSocketAddress(String name) {
-      this.name = name;
-    }
-
-    @Override
-    public String toString() {
-      return "FakeSocketAddress-" + name;
-    }
-  }
-
-  private static class Transport {}
-}
diff --git a/core/src/test/resources/io/grpc/ManagedChannelProviderTest-multipleProvider.txt b/core/src/test/resources/io/grpc/ManagedChannelProviderTest-multipleProvider.txt
deleted file mode 100644
index e048430544c..00000000000
--- a/core/src/test/resources/io/grpc/ManagedChannelProviderTest-multipleProvider.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-io.grpc.ManagedChannelProviderTest$Available5Provider
-io.grpc.ManagedChannelProviderTest$Available7Provider
-io.grpc.ManagedChannelProviderTest$Available0Provider
diff --git a/core/src/test/resources/io/grpc/ManagedChannelProviderTest-unavailableProvider.txt b/core/src/test/resources/io/grpc/ManagedChannelProviderTest-unavailableProvider.txt
deleted file mode 100644
index b24a3465325..00000000000
--- a/core/src/test/resources/io/grpc/ManagedChannelProviderTest-unavailableProvider.txt
+++ /dev/null
@@ -1 +0,0 @@
-io.grpc.ManagedChannelProviderTest$UnavailableProvider
diff --git a/core/src/test/resources/io/grpc/NameResolverProviderTest-multipleProvider.txt b/core/src/test/resources/io/grpc/NameResolverProviderTest-multipleProvider.txt
deleted file mode 100644
index d8f555d9f31..00000000000
--- a/core/src/test/resources/io/grpc/NameResolverProviderTest-multipleProvider.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-io.grpc.NameResolverProviderTest$Available5Provider
-io.grpc.NameResolverProviderTest$Available7Provider
-io.grpc.NameResolverProviderTest$Available0Provider
diff --git a/core/src/test/resources/io/grpc/NameResolverProviderTest-unavailableProvider.txt b/core/src/test/resources/io/grpc/NameResolverProviderTest-unavailableProvider.txt
deleted file mode 100644
index 336702614ac..00000000000
--- a/core/src/test/resources/io/grpc/NameResolverProviderTest-unavailableProvider.txt
+++ /dev/null
@@ -1 +0,0 @@
-io.grpc.NameResolverProviderTest$UnavailableProvider
diff --git a/core/src/test/resources/io/grpc/ServerProviderTest-multipleProvider.txt b/core/src/test/resources/io/grpc/ServerProviderTest-multipleProvider.txt
deleted file mode 100644
index ba9aadacce0..00000000000
--- a/core/src/test/resources/io/grpc/ServerProviderTest-multipleProvider.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-io.grpc.ServerProviderTest$Available5Provider
-io.grpc.ServerProviderTest$Available7Provider
-io.grpc.ServerProviderTest$Available0Provider
diff --git a/core/src/test/resources/io/grpc/ServerProviderTest-unavailableProvider.txt b/core/src/test/resources/io/grpc/ServerProviderTest-unavailableProvider.txt
deleted file mode 100644
index 00769083592..00000000000
--- a/core/src/test/resources/io/grpc/ServerProviderTest-unavailableProvider.txt
+++ /dev/null
@@ -1 +0,0 @@
-io.grpc.ServerProviderTest$UnavailableProvider
diff --git a/core/src/test/resources/io/grpc/internal/spiffebundle.json b/core/src/test/resources/io/grpc/internal/spiffebundle.json
new file mode 100644
index 00000000000..f968f730d94
--- /dev/null
+++ b/core/src/test/resources/io/grpc/internal/spiffebundle.json
@@ -0,0 +1,115 @@
+{
+  "trust_domains": {
+    "test.google.com.au": {},
+    "example.com": {
+      "spiffe_sequence": 12035488,
+      "keys": [
+        {
+          "kty": "RSA",
+          "use": "x509-svid",
+          "x5c": ["MIIFsjCCA5qgAwIBAgIURygVMMzdr+Q7rsUaz189JozyHMwwDQYJKoZIhvcNAQEL
+          BQAwTjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQwwCgYDVQQHDANTVkwxDTAL
+          BgNVBAoMBGdSUEMxFTATBgNVBAMMDHRlc3QtY2xpZW50MTAeFw0yMTEyMjMxODQy
+          NTJaFw0zMTEyMjExODQyNTJaME4xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEM
+          MAoGA1UEBwwDU1ZMMQ0wCwYDVQQKDARnUlBDMRUwEwYDVQQDDAx0ZXN0LWNsaWVu
+          dDEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ4AqpGetyVSqGUuBJ
+          LVFla+7bEfca7UYzfVSSZLZ/X+JDmWIVN8UIPuFib5jhMEc3XaUnFXUmM7zEtz/Z
+          G5hapwLwOb2C3ZxOP6PQjYCJxbkLie+b43UQrFu1xxd3vMhVJgcj/AIxEpmszuqO
+          a6kUrkYifjJADQ+64kZgl66bsTdXMCzpxyFl9xUfff59L8OX+HUfAcoZz3emjg3Z
+          JPYURQEmjdZTOau1EjFilwHgd989Jt7NKgx30NXoHmw7nusVBIY94fL2VKN3f1XV
+          m0dHu5NI279Q6zr0ZBU7k5T3IeHnzsUesQS4NGlklDWoVTKk73Uv9Pna8yQsSW75
+          7PEbHOGp9Knu4bnoGPOlsG81yIPipO6hTgGFK24pF97M9kpGbWqYX4+2vLlrCAfc
+          msHqaUPmQlYeRVTT6vw7ctYo2kyUYGtnODXk76LqewRBVvkzx75QUhfjAyb740Yc
+          DmIenc56Tq6gebJHjhEmVSehR6xIpXP7SVeurTyhPsEQnpJHtgs4dcwWOZp7BvPN
+          zHXmJqfr7vsshie3vS5kQ0u1e1yqAqXgyDjqKXOkx+dpgUTehSJHhPNHvTc5LXRs
+          vvXKYz6FrwR/DZ8t7BNEvPeLjFgxpH7QVJFLCvCbXs5K6yYbsnLfxFIBPRnrbJkI
+          sK+sQwnRdnsiUdPsTkG5B2lQfQIDAQABo4GHMIGEMB0GA1UdDgQWBBQ2lBp0PiRH
+          HvQ5IRURm8aHsj4RETAfBgNVHSMEGDAWgBQ2lBp0PiRHHvQ5IRURm8aHsj4RETAP
+          BgNVHRMBAf8EBTADAQH/MDEGA1UdEQQqMCiGJnNwaWZmZTovL2Zvby5iYXIuY29t
+          L2NsaWVudC93b3JrbG9hZC8xMA0GCSqGSIb3DQEBCwUAA4ICAQA1mSkgRclAl+E/
+          aS9zJ7t8+Y4n3T24nOKKveSIjxXm/zjhWqVsLYBI6kglWtih2+PELvU8JdPqNZK3
+          4Kl0Q6FWpVSGDdWN1i6NyORt2ocggL3ke3iXxRk3UpUKJmqwz81VhA2KUHnMlyE0
+          IufFfZNwNWWHBv13uJfRbjeQpKPhU+yf4DeXrsWcvrZlGvAET+mcplafUzCp7Iv+
+          PcISJtUerbxbVtuHVeZCLlgDXWkLAWJN8rf0dIG4x060LJ+j6j9uRVhb9sZn1HJV
+          +j4XdIYm1VKilluhOtNwP2d3Ox/JuTBxf7hFHXZPfMagQE5k5PzmxRaCAEMJ1l2D
+          vUbZw+shJfSNoWcBo2qadnUaWT3BmmJRBDh7ZReib/RQ1Rd4ygOyzP3E0vkV4/gq
+          yjLdApXh5PZP8KLQZ+1JN/sdWt7VfIt9wYOpkIqujdll51ESHzwQeAK9WVCB4UvV
+          z6zdhItB9CRbXPreWC+wCB1xDovIzFKOVsLs5+Gqs1m7VinG2LxbDqaKyo/FB0Hx
+          x0acBNzezLWoDwXYQrN0T0S4pnqhKD1CYPpdArBkNezUYAjS725FkApuK+mnBX3U
+          0msBffEaUEOkcyar1EW2m/33vpetD/k3eQQkmvQf4Hbiu9AF+9cNDm/hMuXEw5EX
+          GA91fn0891b5eEW8BJHXX0jri0aN8g=="],
+          "n": "<base64urlUint-encoded value>",
+          "e": "AQAB"
+        }
+      ]
+    },
+    "test.example.com": {
+      "keys": [
+        {
+          "kty": "RSA",
+          "use": "x509-svid",
+          "x5c": ["MIIFsjCCA5qgAwIBAgIURygVMMzdr+Q7rsUaz189JozyHMwwDQYJKoZIhvcNAQEL
+          BQAwTjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQwwCgYDVQQHDANTVkwxDTAL
+          BgNVBAoMBGdSUEMxFTATBgNVBAMMDHRlc3QtY2xpZW50MTAeFw0yMTEyMjMxODQy
+          NTJaFw0zMTEyMjExODQyNTJaME4xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEM
+          MAoGA1UEBwwDU1ZMMQ0wCwYDVQQKDARnUlBDMRUwEwYDVQQDDAx0ZXN0LWNsaWVu
+          dDEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ4AqpGetyVSqGUuBJ
+          LVFla+7bEfca7UYzfVSSZLZ/X+JDmWIVN8UIPuFib5jhMEc3XaUnFXUmM7zEtz/Z
+          G5hapwLwOb2C3ZxOP6PQjYCJxbkLie+b43UQrFu1xxd3vMhVJgcj/AIxEpmszuqO
+          a6kUrkYifjJADQ+64kZgl66bsTdXMCzpxyFl9xUfff59L8OX+HUfAcoZz3emjg3Z
+          JPYURQEmjdZTOau1EjFilwHgd989Jt7NKgx30NXoHmw7nusVBIY94fL2VKN3f1XV
+          m0dHu5NI279Q6zr0ZBU7k5T3IeHnzsUesQS4NGlklDWoVTKk73Uv9Pna8yQsSW75
+          7PEbHOGp9Knu4bnoGPOlsG81yIPipO6hTgGFK24pF97M9kpGbWqYX4+2vLlrCAfc
+          msHqaUPmQlYeRVTT6vw7ctYo2kyUYGtnODXk76LqewRBVvkzx75QUhfjAyb740Yc
+          DmIenc56Tq6gebJHjhEmVSehR6xIpXP7SVeurTyhPsEQnpJHtgs4dcwWOZp7BvPN
+          zHXmJqfr7vsshie3vS5kQ0u1e1yqAqXgyDjqKXOkx+dpgUTehSJHhPNHvTc5LXRs
+          vvXKYz6FrwR/DZ8t7BNEvPeLjFgxpH7QVJFLCvCbXs5K6yYbsnLfxFIBPRnrbJkI
+          sK+sQwnRdnsiUdPsTkG5B2lQfQIDAQABo4GHMIGEMB0GA1UdDgQWBBQ2lBp0PiRH
+          HvQ5IRURm8aHsj4RETAfBgNVHSMEGDAWgBQ2lBp0PiRHHvQ5IRURm8aHsj4RETAP
+          BgNVHRMBAf8EBTADAQH/MDEGA1UdEQQqMCiGJnNwaWZmZTovL2Zvby5iYXIuY29t
+          L2NsaWVudC93b3JrbG9hZC8xMA0GCSqGSIb3DQEBCwUAA4ICAQA1mSkgRclAl+E/
+          aS9zJ7t8+Y4n3T24nOKKveSIjxXm/zjhWqVsLYBI6kglWtih2+PELvU8JdPqNZK3
+          4Kl0Q6FWpVSGDdWN1i6NyORt2ocggL3ke3iXxRk3UpUKJmqwz81VhA2KUHnMlyE0
+          IufFfZNwNWWHBv13uJfRbjeQpKPhU+yf4DeXrsWcvrZlGvAET+mcplafUzCp7Iv+
+          PcISJtUerbxbVtuHVeZCLlgDXWkLAWJN8rf0dIG4x060LJ+j6j9uRVhb9sZn1HJV
+          +j4XdIYm1VKilluhOtNwP2d3Ox/JuTBxf7hFHXZPfMagQE5k5PzmxRaCAEMJ1l2D
+          vUbZw+shJfSNoWcBo2qadnUaWT3BmmJRBDh7ZReib/RQ1Rd4ygOyzP3E0vkV4/gq
+          yjLdApXh5PZP8KLQZ+1JN/sdWt7VfIt9wYOpkIqujdll51ESHzwQeAK9WVCB4UvV
+          z6zdhItB9CRbXPreWC+wCB1xDovIzFKOVsLs5+Gqs1m7VinG2LxbDqaKyo/FB0Hx
+          x0acBNzezLWoDwXYQrN0T0S4pnqhKD1CYPpdArBkNezUYAjS725FkApuK+mnBX3U
+          0msBffEaUEOkcyar1EW2m/33vpetD/k3eQQkmvQf4Hbiu9AF+9cNDm/hMuXEw5EX
+          GA91fn0891b5eEW8BJHXX0jri0aN8g=="],
+          "n": "<base64urlUint-encoded value>",
+          "e": "AQAB"
+        },
+        {
+          "kty": "RSA",
+          "use": "x509-svid",
+          "x5c": ["MIIELTCCAxWgAwIBAgIUVXGlXjNENtOZbI12epjgIhMaShEwDQYJKoZIhvcNAQEL
+          BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+          GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTI0
+          MDkxNzE2MTk0NFoXDTM0MDkxNTE2MTk0NFowTjELMAkGA1UEBhMCVVMxCzAJBgNV
+          BAgMAkNBMQwwCgYDVQQHDANTVkwxDTALBgNVBAoMBGdSUEMxFTATBgNVBAMMDHRl
+          c3QtY2xpZW50MTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOcTjjcS
+          SfG/EGrr6G+f+3T2GXyHHfroQFi9mZUz80L7uKBdECOImID+YhoK8vcxLQjPmEEv
+          FIYgJT5amugDcYIgUhMjBx/8RPJaP/nGmBngAqsuuNCaZfyaHBRqN8XdS/AwmsI5
+          Wo+nru0+0/7aQFdqqtd2+e9dHjUWwgHxXvMgC4hkHpsdCGIZWVzWyBliwTYQYb1Y
+          yYe1LzqqQA5OMbZfKOY9MYDCEYOliRiunOn30iIOHj9V5qLzWGfSyxCRuvLRdEP8
+          iDeNweHbdaKuI80nQmxuBdRIspE9k5sD1WA4vLZpeg3zggxp4rfLL5zBJgb/33D3
+          d9Rkm14xfDPihhkCAwEAAaOB+jCB9zBZBgNVHREEUjBQhiZzcGlmZmU6Ly9mb28u
+          YmFyLmNvbS9jbGllbnQvd29ya2xvYWQvMYYmc3BpZmZlOi8vZm9vLmJhci5jb20v
+          Y2xpZW50L3dvcmtsb2FkLzIwHQYDVR0OBBYEFG9GkBgdBg/p0U9/lXv8zIJ+2c2N
+          MHsGA1UdIwR0MHKhWqRYMFYxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0
+          YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxDzANBgNVBAMM
+          BnRlc3RjYYIUWrP0VvHcy+LP6UuYNtiL9gBhD5owDQYJKoZIhvcNAQELBQADggEB
+          AJ4Cbxv+02SpUgkEu4hP/1+8DtSBXUxNxI0VG4e3Ap2+Rhjm3YiFeS/UeaZhNrrw
+          UEjkSTPFODyXR7wI7UO9OO1StyD6CMkp3SEvevU5JsZtGL6mTiTLTi3Qkywa91Bt
+          GlyZdVMghA1bBJLBMwiD5VT5noqoJBD7hDy6v9yNmt1Sw2iYBJPqI3Gnf5bMjR3s
+          UICaxmFyqaMCZsPkfJh0DmZpInGJys3m4QqGz6ZE2DWgcSr1r/ML7/5bSPjjr8j4
+          WFFSqFR3dMu8CbGnfZTCTXa4GTX/rARXbAO67Z/oJbJBK7VKayskL+PzKuohb9ox
+          jGL772hQMbwtFCOFXu5VP0s="]
+        }
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/core/src/test/resources/io/grpc/internal/spiffebundle_corrupted_cert.json b/core/src/test/resources/io/grpc/internal/spiffebundle_corrupted_cert.json
new file mode 100644
index 00000000000..9ca51733ff3
--- /dev/null
+++ b/core/src/test/resources/io/grpc/internal/spiffebundle_corrupted_cert.json
@@ -0,0 +1,14 @@
+{
+  "trust_domains": {
+    "google.com": {
+      "spiffe_sequence": 123,
+      "keys": [
+        {
+          "kty": "RSA",
+          "use": "x509-svid",
+          "x5c": ["UNPARSABLE_CERTIFICATE"]
+        }
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/core/src/test/resources/io/grpc/internal/spiffebundle_duplicates.json b/core/src/test/resources/io/grpc/internal/spiffebundle_duplicates.json
new file mode 100644
index 00000000000..3f015bd1568
--- /dev/null
+++ b/core/src/test/resources/io/grpc/internal/spiffebundle_duplicates.json
@@ -0,0 +1,23 @@
+{
+  "trust_domains": {
+    "google.com": {
+      "spiffe_sequence": 123,
+      "keys": [
+        {
+          "x5c": "VALUE_DOESN'T_MATTER"
+        }
+      ]
+    },
+    "google.com": {
+      "spiffe_sequence": 123,
+      "keys": [
+        {
+          "use": "x509-svid",
+          "kid": "some_value",
+          "x5c": "VALUE_DOESN'T_MATTER"
+        }
+      ]
+    },
+    "test.google.com.au": {}
+  }
+}
\ No newline at end of file
diff --git a/core/src/test/resources/io/grpc/internal/spiffebundle_ec.json b/core/src/test/resources/io/grpc/internal/spiffebundle_ec.json
new file mode 100644
index 00000000000..1732310f8cf
--- /dev/null
+++ b/core/src/test/resources/io/grpc/internal/spiffebundle_ec.json
@@ -0,0 +1,116 @@
+{
+  "trust_domains": {
+    "test.google.com.au": {},
+    "example.com": {
+      "spiffe_sequence": 12035488,
+      "keys": [
+        {
+          
+          "kty": "EC",
+          "use": "x509-svid",
+          "x5c": ["MIIFsjCCA5qgAwIBAgIURygVMMzdr+Q7rsUaz189JozyHMwwDQYJKoZIhvcNAQEL
+          BQAwTjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQwwCgYDVQQHDANTVkwxDTAL
+          BgNVBAoMBGdSUEMxFTATBgNVBAMMDHRlc3QtY2xpZW50MTAeFw0yMTEyMjMxODQy
+          NTJaFw0zMTEyMjExODQyNTJaME4xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEM
+          MAoGA1UEBwwDU1ZMMQ0wCwYDVQQKDARnUlBDMRUwEwYDVQQDDAx0ZXN0LWNsaWVu
+          dDEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ4AqpGetyVSqGUuBJ
+          LVFla+7bEfca7UYzfVSSZLZ/X+JDmWIVN8UIPuFib5jhMEc3XaUnFXUmM7zEtz/Z
+          G5hapwLwOb2C3ZxOP6PQjYCJxbkLie+b43UQrFu1xxd3vMhVJgcj/AIxEpmszuqO
+          a6kUrkYifjJADQ+64kZgl66bsTdXMCzpxyFl9xUfff59L8OX+HUfAcoZz3emjg3Z
+          JPYURQEmjdZTOau1EjFilwHgd989Jt7NKgx30NXoHmw7nusVBIY94fL2VKN3f1XV
+          m0dHu5NI279Q6zr0ZBU7k5T3IeHnzsUesQS4NGlklDWoVTKk73Uv9Pna8yQsSW75
+          7PEbHOGp9Knu4bnoGPOlsG81yIPipO6hTgGFK24pF97M9kpGbWqYX4+2vLlrCAfc
+          msHqaUPmQlYeRVTT6vw7ctYo2kyUYGtnODXk76LqewRBVvkzx75QUhfjAyb740Yc
+          DmIenc56Tq6gebJHjhEmVSehR6xIpXP7SVeurTyhPsEQnpJHtgs4dcwWOZp7BvPN
+          zHXmJqfr7vsshie3vS5kQ0u1e1yqAqXgyDjqKXOkx+dpgUTehSJHhPNHvTc5LXRs
+          vvXKYz6FrwR/DZ8t7BNEvPeLjFgxpH7QVJFLCvCbXs5K6yYbsnLfxFIBPRnrbJkI
+          sK+sQwnRdnsiUdPsTkG5B2lQfQIDAQABo4GHMIGEMB0GA1UdDgQWBBQ2lBp0PiRH
+          HvQ5IRURm8aHsj4RETAfBgNVHSMEGDAWgBQ2lBp0PiRHHvQ5IRURm8aHsj4RETAP
+          BgNVHRMBAf8EBTADAQH/MDEGA1UdEQQqMCiGJnNwaWZmZTovL2Zvby5iYXIuY29t
+          L2NsaWVudC93b3JrbG9hZC8xMA0GCSqGSIb3DQEBCwUAA4ICAQA1mSkgRclAl+E/
+          aS9zJ7t8+Y4n3T24nOKKveSIjxXm/zjhWqVsLYBI6kglWtih2+PELvU8JdPqNZK3
+          4Kl0Q6FWpVSGDdWN1i6NyORt2ocggL3ke3iXxRk3UpUKJmqwz81VhA2KUHnMlyE0
+          IufFfZNwNWWHBv13uJfRbjeQpKPhU+yf4DeXrsWcvrZlGvAET+mcplafUzCp7Iv+
+          PcISJtUerbxbVtuHVeZCLlgDXWkLAWJN8rf0dIG4x060LJ+j6j9uRVhb9sZn1HJV
+          +j4XdIYm1VKilluhOtNwP2d3Ox/JuTBxf7hFHXZPfMagQE5k5PzmxRaCAEMJ1l2D
+          vUbZw+shJfSNoWcBo2qadnUaWT3BmmJRBDh7ZReib/RQ1Rd4ygOyzP3E0vkV4/gq
+          yjLdApXh5PZP8KLQZ+1JN/sdWt7VfIt9wYOpkIqujdll51ESHzwQeAK9WVCB4UvV
+          z6zdhItB9CRbXPreWC+wCB1xDovIzFKOVsLs5+Gqs1m7VinG2LxbDqaKyo/FB0Hx
+          x0acBNzezLWoDwXYQrN0T0S4pnqhKD1CYPpdArBkNezUYAjS725FkApuK+mnBX3U
+          0msBffEaUEOkcyar1EW2m/33vpetD/k3eQQkmvQf4Hbiu9AF+9cNDm/hMuXEw5EX
+          GA91fn0891b5eEW8BJHXX0jri0aN8g=="],
+          "n": "<base64urlUint-encoded value>",
+          "e": "AQAB"
+        }
+      ]
+    },
+    "test.example.com": {
+      "keys": [
+        {
+          "kty": "RSA",
+          "use": "x509-svid",
+          "x5c": ["MIIFsjCCA5qgAwIBAgIURygVMMzdr+Q7rsUaz189JozyHMwwDQYJKoZIhvcNAQEL
+          BQAwTjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQwwCgYDVQQHDANTVkwxDTAL
+          BgNVBAoMBGdSUEMxFTATBgNVBAMMDHRlc3QtY2xpZW50MTAeFw0yMTEyMjMxODQy
+          NTJaFw0zMTEyMjExODQyNTJaME4xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEM
+          MAoGA1UEBwwDU1ZMMQ0wCwYDVQQKDARnUlBDMRUwEwYDVQQDDAx0ZXN0LWNsaWVu
+          dDEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ4AqpGetyVSqGUuBJ
+          LVFla+7bEfca7UYzfVSSZLZ/X+JDmWIVN8UIPuFib5jhMEc3XaUnFXUmM7zEtz/Z
+          G5hapwLwOb2C3ZxOP6PQjYCJxbkLie+b43UQrFu1xxd3vMhVJgcj/AIxEpmszuqO
+          a6kUrkYifjJADQ+64kZgl66bsTdXMCzpxyFl9xUfff59L8OX+HUfAcoZz3emjg3Z
+          JPYURQEmjdZTOau1EjFilwHgd989Jt7NKgx30NXoHmw7nusVBIY94fL2VKN3f1XV
+          m0dHu5NI279Q6zr0ZBU7k5T3IeHnzsUesQS4NGlklDWoVTKk73Uv9Pna8yQsSW75
+          7PEbHOGp9Knu4bnoGPOlsG81yIPipO6hTgGFK24pF97M9kpGbWqYX4+2vLlrCAfc
+          msHqaUPmQlYeRVTT6vw7ctYo2kyUYGtnODXk76LqewRBVvkzx75QUhfjAyb740Yc
+          DmIenc56Tq6gebJHjhEmVSehR6xIpXP7SVeurTyhPsEQnpJHtgs4dcwWOZp7BvPN
+          zHXmJqfr7vsshie3vS5kQ0u1e1yqAqXgyDjqKXOkx+dpgUTehSJHhPNHvTc5LXRs
+          vvXKYz6FrwR/DZ8t7BNEvPeLjFgxpH7QVJFLCvCbXs5K6yYbsnLfxFIBPRnrbJkI
+          sK+sQwnRdnsiUdPsTkG5B2lQfQIDAQABo4GHMIGEMB0GA1UdDgQWBBQ2lBp0PiRH
+          HvQ5IRURm8aHsj4RETAfBgNVHSMEGDAWgBQ2lBp0PiRHHvQ5IRURm8aHsj4RETAP
+          BgNVHRMBAf8EBTADAQH/MDEGA1UdEQQqMCiGJnNwaWZmZTovL2Zvby5iYXIuY29t
+          L2NsaWVudC93b3JrbG9hZC8xMA0GCSqGSIb3DQEBCwUAA4ICAQA1mSkgRclAl+E/
+          aS9zJ7t8+Y4n3T24nOKKveSIjxXm/zjhWqVsLYBI6kglWtih2+PELvU8JdPqNZK3
+          4Kl0Q6FWpVSGDdWN1i6NyORt2ocggL3ke3iXxRk3UpUKJmqwz81VhA2KUHnMlyE0
+          IufFfZNwNWWHBv13uJfRbjeQpKPhU+yf4DeXrsWcvrZlGvAET+mcplafUzCp7Iv+
+          PcISJtUerbxbVtuHVeZCLlgDXWkLAWJN8rf0dIG4x060LJ+j6j9uRVhb9sZn1HJV
+          +j4XdIYm1VKilluhOtNwP2d3Ox/JuTBxf7hFHXZPfMagQE5k5PzmxRaCAEMJ1l2D
+          vUbZw+shJfSNoWcBo2qadnUaWT3BmmJRBDh7ZReib/RQ1Rd4ygOyzP3E0vkV4/gq
+          yjLdApXh5PZP8KLQZ+1JN/sdWt7VfIt9wYOpkIqujdll51ESHzwQeAK9WVCB4UvV
+          z6zdhItB9CRbXPreWC+wCB1xDovIzFKOVsLs5+Gqs1m7VinG2LxbDqaKyo/FB0Hx
+          x0acBNzezLWoDwXYQrN0T0S4pnqhKD1CYPpdArBkNezUYAjS725FkApuK+mnBX3U
+          0msBffEaUEOkcyar1EW2m/33vpetD/k3eQQkmvQf4Hbiu9AF+9cNDm/hMuXEw5EX
+          GA91fn0891b5eEW8BJHXX0jri0aN8g=="],
+          "n": "<base64urlUint-encoded value>",
+          "e": "AQAB"
+        },
+        {
+          "kty": "RSA",
+          "use": "x509-svid",
+          "x5c": ["MIIELTCCAxWgAwIBAgIUVXGlXjNENtOZbI12epjgIhMaShEwDQYJKoZIhvcNAQEL
+          BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+          GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTI0
+          MDkxNzE2MTk0NFoXDTM0MDkxNTE2MTk0NFowTjELMAkGA1UEBhMCVVMxCzAJBgNV
+          BAgMAkNBMQwwCgYDVQQHDANTVkwxDTALBgNVBAoMBGdSUEMxFTATBgNVBAMMDHRl
+          c3QtY2xpZW50MTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOcTjjcS
+          SfG/EGrr6G+f+3T2GXyHHfroQFi9mZUz80L7uKBdECOImID+YhoK8vcxLQjPmEEv
+          FIYgJT5amugDcYIgUhMjBx/8RPJaP/nGmBngAqsuuNCaZfyaHBRqN8XdS/AwmsI5
+          Wo+nru0+0/7aQFdqqtd2+e9dHjUWwgHxXvMgC4hkHpsdCGIZWVzWyBliwTYQYb1Y
+          yYe1LzqqQA5OMbZfKOY9MYDCEYOliRiunOn30iIOHj9V5qLzWGfSyxCRuvLRdEP8
+          iDeNweHbdaKuI80nQmxuBdRIspE9k5sD1WA4vLZpeg3zggxp4rfLL5zBJgb/33D3
+          d9Rkm14xfDPihhkCAwEAAaOB+jCB9zBZBgNVHREEUjBQhiZzcGlmZmU6Ly9mb28u
+          YmFyLmNvbS9jbGllbnQvd29ya2xvYWQvMYYmc3BpZmZlOi8vZm9vLmJhci5jb20v
+          Y2xpZW50L3dvcmtsb2FkLzIwHQYDVR0OBBYEFG9GkBgdBg/p0U9/lXv8zIJ+2c2N
+          MHsGA1UdIwR0MHKhWqRYMFYxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0
+          YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxDzANBgNVBAMM
+          BnRlc3RjYYIUWrP0VvHcy+LP6UuYNtiL9gBhD5owDQYJKoZIhvcNAQELBQADggEB
+          AJ4Cbxv+02SpUgkEu4hP/1+8DtSBXUxNxI0VG4e3Ap2+Rhjm3YiFeS/UeaZhNrrw
+          UEjkSTPFODyXR7wI7UO9OO1StyD6CMkp3SEvevU5JsZtGL6mTiTLTi3Qkywa91Bt
+          GlyZdVMghA1bBJLBMwiD5VT5noqoJBD7hDy6v9yNmt1Sw2iYBJPqI3Gnf5bMjR3s
+          UICaxmFyqaMCZsPkfJh0DmZpInGJys3m4QqGz6ZE2DWgcSr1r/ML7/5bSPjjr8j4
+          WFFSqFR3dMu8CbGnfZTCTXa4GTX/rARXbAO67Z/oJbJBK7VKayskL+PzKuohb9ox
+          jGL772hQMbwtFCOFXu5VP0s="]
+        }
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/core/src/test/resources/io/grpc/internal/spiffebundle_malformed.json b/core/src/test/resources/io/grpc/internal/spiffebundle_malformed.json
new file mode 100644
index 00000000000..a2488eeb3cd
--- /dev/null
+++ b/core/src/test/resources/io/grpc/internal/spiffebundle_malformed.json
@@ -0,0 +1,4 @@
+[
+  "test.google.com",
+  "test.google.com.au"
+]
\ No newline at end of file
diff --git a/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_kid.json b/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_kid.json
new file mode 100644
index 00000000000..f93af634a54
--- /dev/null
+++ b/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_kid.json
@@ -0,0 +1,15 @@
+{
+  "trust_domains": {
+    "google.com": {
+      "spiffe_sequence": 123,
+      "keys": [
+        {
+          "kty": "RSA",
+          "use": "x509-svid",
+          "kid": "some_value",
+          "x5c": "VALUE_DOESN'T_MATTER"
+        }
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_kty.json b/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_kty.json
new file mode 100644
index 00000000000..384da03fd6f
--- /dev/null
+++ b/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_kty.json
@@ -0,0 +1,12 @@
+{
+  "trust_domains": {
+    "google.com": {
+      "spiffe_sequence": 123,
+      "keys": [
+        {
+          "x5c": "VALUE_DOESN'T_MATTER"
+        }
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_multi_certs.json b/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_multi_certs.json
new file mode 100644
index 00000000000..5e85635bb02
--- /dev/null
+++ b/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_multi_certs.json
@@ -0,0 +1,67 @@
+{
+  "trust_domains": {
+    "google.com": {
+      "spiffe_sequence": 123,
+      "keys": [
+        {
+          "kty": "RSA",
+          "use": "x509-svid",
+          "x5c": ["MIIFsjCCA5qgAwIBAgIURygVMMzdr+Q7rsUaz189JozyHMwwDQYJKoZIhvcNAQEL
+            BQAwTjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQwwCgYDVQQHDANTVkwxDTAL
+            BgNVBAoMBGdSUEMxFTATBgNVBAMMDHRlc3QtY2xpZW50MTAeFw0yMTEyMjMxODQy
+            NTJaFw0zMTEyMjExODQyNTJaME4xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEM
+            MAoGA1UEBwwDU1ZMMQ0wCwYDVQQKDARnUlBDMRUwEwYDVQQDDAx0ZXN0LWNsaWVu
+            dDEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ4AqpGetyVSqGUuBJ
+            LVFla+7bEfca7UYzfVSSZLZ/X+JDmWIVN8UIPuFib5jhMEc3XaUnFXUmM7zEtz/Z
+            G5hapwLwOb2C3ZxOP6PQjYCJxbkLie+b43UQrFu1xxd3vMhVJgcj/AIxEpmszuqO
+            a6kUrkYifjJADQ+64kZgl66bsTdXMCzpxyFl9xUfff59L8OX+HUfAcoZz3emjg3Z
+            JPYURQEmjdZTOau1EjFilwHgd989Jt7NKgx30NXoHmw7nusVBIY94fL2VKN3f1XV
+            m0dHu5NI279Q6zr0ZBU7k5T3IeHnzsUesQS4NGlklDWoVTKk73Uv9Pna8yQsSW75
+            7PEbHOGp9Knu4bnoGPOlsG81yIPipO6hTgGFK24pF97M9kpGbWqYX4+2vLlrCAfc
+            msHqaUPmQlYeRVTT6vw7ctYo2kyUYGtnODXk76LqewRBVvkzx75QUhfjAyb740Yc
+            DmIenc56Tq6gebJHjhEmVSehR6xIpXP7SVeurTyhPsEQnpJHtgs4dcwWOZp7BvPN
+            zHXmJqfr7vsshie3vS5kQ0u1e1yqAqXgyDjqKXOkx+dpgUTehSJHhPNHvTc5LXRs
+            vvXKYz6FrwR/DZ8t7BNEvPeLjFgxpH7QVJFLCvCbXs5K6yYbsnLfxFIBPRnrbJkI
+            sK+sQwnRdnsiUdPsTkG5B2lQfQIDAQABo4GHMIGEMB0GA1UdDgQWBBQ2lBp0PiRH
+            HvQ5IRURm8aHsj4RETAfBgNVHSMEGDAWgBQ2lBp0PiRHHvQ5IRURm8aHsj4RETAP
+            BgNVHRMBAf8EBTADAQH/MDEGA1UdEQQqMCiGJnNwaWZmZTovL2Zvby5iYXIuY29t
+            L2NsaWVudC93b3JrbG9hZC8xMA0GCSqGSIb3DQEBCwUAA4ICAQA1mSkgRclAl+E/
+            aS9zJ7t8+Y4n3T24nOKKveSIjxXm/zjhWqVsLYBI6kglWtih2+PELvU8JdPqNZK3
+            4Kl0Q6FWpVSGDdWN1i6NyORt2ocggL3ke3iXxRk3UpUKJmqwz81VhA2KUHnMlyE0
+            IufFfZNwNWWHBv13uJfRbjeQpKPhU+yf4DeXrsWcvrZlGvAET+mcplafUzCp7Iv+
+            PcISJtUerbxbVtuHVeZCLlgDXWkLAWJN8rf0dIG4x060LJ+j6j9uRVhb9sZn1HJV
+            +j4XdIYm1VKilluhOtNwP2d3Ox/JuTBxf7hFHXZPfMagQE5k5PzmxRaCAEMJ1l2D
+            vUbZw+shJfSNoWcBo2qadnUaWT3BmmJRBDh7ZReib/RQ1Rd4ygOyzP3E0vkV4/gq
+            yjLdApXh5PZP8KLQZ+1JN/sdWt7VfIt9wYOpkIqujdll51ESHzwQeAK9WVCB4UvV
+            z6zdhItB9CRbXPreWC+wCB1xDovIzFKOVsLs5+Gqs1m7VinG2LxbDqaKyo/FB0Hx
+            x0acBNzezLWoDwXYQrN0T0S4pnqhKD1CYPpdArBkNezUYAjS725FkApuK+mnBX3U
+            0msBffEaUEOkcyar1EW2m/33vpetD/k3eQQkmvQf4Hbiu9AF+9cNDm/hMuXEw5EX
+            GA91fn0891b5eEW8BJHXX0jri0aN8g==",
+            "MIIELTCCAxWgAwIBAgIUVXGlXjNENtOZbI12epjgIhMaShEwDQYJKoZIhvcNAQEL
+            BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+            GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTI0
+            MDkxNzE2MTk0NFoXDTM0MDkxNTE2MTk0NFowTjELMAkGA1UEBhMCVVMxCzAJBgNV
+            BAgMAkNBMQwwCgYDVQQHDANTVkwxDTALBgNVBAoMBGdSUEMxFTATBgNVBAMMDHRl
+            c3QtY2xpZW50MTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOcTjjcS
+            SfG/EGrr6G+f+3T2GXyHHfroQFi9mZUz80L7uKBdECOImID+YhoK8vcxLQjPmEEv
+            FIYgJT5amugDcYIgUhMjBx/8RPJaP/nGmBngAqsuuNCaZfyaHBRqN8XdS/AwmsI5
+            Wo+nru0+0/7aQFdqqtd2+e9dHjUWwgHxXvMgC4hkHpsdCGIZWVzWyBliwTYQYb1Y
+            yYe1LzqqQA5OMbZfKOY9MYDCEYOliRiunOn30iIOHj9V5qLzWGfSyxCRuvLRdEP8
+            iDeNweHbdaKuI80nQmxuBdRIspE9k5sD1WA4vLZpeg3zggxp4rfLL5zBJgb/33D3
+            d9Rkm14xfDPihhkCAwEAAaOB+jCB9zBZBgNVHREEUjBQhiZzcGlmZmU6Ly9mb28u
+            YmFyLmNvbS9jbGllbnQvd29ya2xvYWQvMYYmc3BpZmZlOi8vZm9vLmJhci5jb20v
+            Y2xpZW50L3dvcmtsb2FkLzIwHQYDVR0OBBYEFG9GkBgdBg/p0U9/lXv8zIJ+2c2N
+            MHsGA1UdIwR0MHKhWqRYMFYxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0
+            YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxDzANBgNVBAMM
+            BnRlc3RjYYIUWrP0VvHcy+LP6UuYNtiL9gBhD5owDQYJKoZIhvcNAQELBQADggEB
+            AJ4Cbxv+02SpUgkEu4hP/1+8DtSBXUxNxI0VG4e3Ap2+Rhjm3YiFeS/UeaZhNrrw
+            UEjkSTPFODyXR7wI7UO9OO1StyD6CMkp3SEvevU5JsZtGL6mTiTLTi3Qkywa91Bt
+            GlyZdVMghA1bBJLBMwiD5VT5noqoJBD7hDy6v9yNmt1Sw2iYBJPqI3Gnf5bMjR3s
+            UICaxmFyqaMCZsPkfJh0DmZpInGJys3m4QqGz6ZE2DWgcSr1r/ML7/5bSPjjr8j4
+            WFFSqFR3dMu8CbGnfZTCTXa4GTX/rARXbAO67Z/oJbJBK7VKayskL+PzKuohb9ox
+            jGL772hQMbwtFCOFXu5VP0s="]
+            }
+          ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_root.json b/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_root.json
new file mode 100644
index 00000000000..90d2847dc05
--- /dev/null
+++ b/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_root.json
@@ -0,0 +1,6 @@
+{
+  "trustDomains": {
+    "test.google.com": {},
+    "test.google.com.au": {}
+  }
+}
\ No newline at end of file
diff --git a/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_seq_type.json b/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_seq_type.json
new file mode 100644
index 00000000000..4e0aeacc89f
--- /dev/null
+++ b/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_seq_type.json
@@ -0,0 +1,12 @@
+{
+  "trust_domains": {
+    "google.com": {
+      "spiffe_sequence": 123.5,
+      "keys": [
+        {
+          "x5c": "VALUE_DOESN'T_MATTER"
+        }
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_use.json b/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_use.json
new file mode 100644
index 00000000000..166be04846c
--- /dev/null
+++ b/core/src/test/resources/io/grpc/internal/spiffebundle_wrong_use.json
@@ -0,0 +1,13 @@
+{
+  "trust_domains": {
+    "google.com": {
+      "keys": [
+        {
+          "kty": "RSA",
+          "use": "i_am_not_x509-svid",
+          "x5c": "VALUE_DOESN'T_MATTER"
+        }
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/core/src/test/resources/io/grpc/internal/test_hedging_service_config.json b/core/src/test/resources/io/grpc/internal/test_hedging_service_config.json
new file mode 100644
index 00000000000..5533973dd32
--- /dev/null
+++ b/core/src/test/resources/io/grpc/internal/test_hedging_service_config.json
@@ -0,0 +1,54 @@
+{
+  "loadBalancingPolicy":"round_robin",
+  "methodConfig":[
+    {
+      "name":[
+        {
+          "service":"SimpleService1"
+        }
+      ],
+      "waitForReady":false,
+      "hedgingPolicy":{
+        "maxAttempts":3,
+        "hedgingDelay":"2.1s",
+        "nonFatalStatusCodes":[
+          "UNAVAILABLE",
+          "RESOURCE_EXHAUSTED"
+        ]
+      }
+    },
+    {
+      "name":[
+        {
+          "service":"SimpleService2"
+        }
+      ],
+      "waitForReady":false
+    },
+    {
+      "name":[
+        {
+          "service":"SimpleService1",
+          "method":"Foo1"
+        },
+        {
+          "service":"SimpleService2",
+          "method":"Foo2"
+        }
+      ],
+      "waitForReady":true,
+      "hedgingPolicy":{
+        "maxAttempts":5,
+        "hedgingDelay":"0.1s",
+        "nonFatalStatusCodes":[
+          "UNAVAILABLE"
+        ]
+      }
+    }
+  ],
+
+  "retryThrottling": {
+    "maxTokens": 10,
+    "tokenRatio": 0.1
+  }
+}
diff --git a/core/src/test/resources/io/grpc/internal/test_retry_service_config.json b/core/src/test/resources/io/grpc/internal/test_retry_service_config.json
new file mode 100644
index 00000000000..7274bf7a1e5
--- /dev/null
+++ b/core/src/test/resources/io/grpc/internal/test_retry_service_config.json
@@ -0,0 +1,58 @@
+{
+  "loadBalancingPolicy":"round_robin",
+  "methodConfig":[
+    {
+      "name":[
+        {
+          "service":"SimpleService1"
+        }
+      ],
+      "waitForReady":false,
+      "retryPolicy":{
+        "maxAttempts":3,
+        "initialBackoff":"2.1s",
+        "maxBackoff":"2.2s",
+        "backoffMultiplier":3,
+        "retryableStatusCodes":[
+          "UNAVAILABLE",
+          "RESOURCE_EXHAUSTED"
+        ]
+      }
+    },
+    {
+      "name":[
+        {
+          "service":"SimpleService2"
+        }
+      ],
+      "waitForReady":false
+    },
+    {
+      "name":[
+        {
+          "service":"SimpleService1",
+          "method":"Foo1"
+        },
+        {
+          "service":"SimpleService2",
+          "method":"Foo2"
+        }
+      ],
+      "waitForReady":true,
+      "retryPolicy":{
+        "maxAttempts":5,
+        "initialBackoff":"0.1s",
+        "maxBackoff":"1s",
+        "backoffMultiplier":2,
+        "retryableStatusCodes":[
+          "UNAVAILABLE"
+        ]
+      }
+    }
+  ],
+
+  "retryThrottling": {
+    "maxTokens": 10,
+    "tokenRatio": 0.1
+  }
+}
diff --git a/interop-testing/src/main/resources/io/grpc/testing/integration/testdata/uncompressable.bin b/core/src/test/resources/io/grpc/internal/uncompressable.bin
similarity index 100%
rename from interop-testing/src/main/resources/io/grpc/testing/integration/testdata/uncompressable.bin
rename to core/src/test/resources/io/grpc/internal/uncompressable.bin
diff --git a/core/src/testFixtures/java/io/grpc/internal/AbstractClientTransportFactoryTest.java b/core/src/testFixtures/java/io/grpc/internal/AbstractClientTransportFactoryTest.java
new file mode 100644
index 00000000000..8e6f00fbc65
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/AbstractClientTransportFactoryTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2016 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.internal;
+
+import io.grpc.ChannelLogger;
+import java.net.InetSocketAddress;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public abstract class AbstractClientTransportFactoryTest {
+
+  protected abstract ClientTransportFactory newClientTransportFactory();
+
+  @Test
+  public void multipleCallsToCloseShouldNotThrow() {
+    ClientTransportFactory transportFactory = newClientTransportFactory();
+    transportFactory.close();
+    transportFactory.close();
+    transportFactory.close();
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void newClientTransportAfterCloseShouldThrow() {
+    ClientTransportFactory transportFactory = newClientTransportFactory();
+    transportFactory.close();
+    transportFactory.newClientTransport(
+        new InetSocketAddress("localhost", 12345),
+        new ClientTransportFactory.ClientTransportOptions(),
+        new ChannelLogger() {
+
+          @Override
+          public void log(ChannelLogLevel level, String message) {}
+
+          @Override
+          public void log(ChannelLogLevel level, String messageFormat, Object... args) {}
+        }
+    );
+  }
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/AbstractTransportTest.java b/core/src/testFixtures/java/io/grpc/internal/AbstractTransportTest.java
new file mode 100644
index 00000000000..5d6b88a1392
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/AbstractTransportTest.java
@@ -0,0 +1,2242 @@
+/*
+ * Copyright 2016 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.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.Lists;
+import com.google.common.io.ByteStreams;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ChannelLogger;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Grpc;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalChannelz.TransportStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.internal.MockServerTransportListener.StreamCreation;
+import io.grpc.internal.testing.TestClientStreamTracer;
+import io.grpc.internal.testing.TestServerStreamTracer;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.InOrder;
+
+/** Standard unit tests for {@link ClientTransport}s and {@link ServerTransport}s. */
+@RunWith(JUnit4.class)
+public abstract class AbstractTransportTest {
+  /**
+   * Use a small flow control to help detect flow control bugs. Don't use 64KiB to test
+   * SETTINGS/WINDOW_UPDATE exchange.
+   */
+  public static final int TEST_FLOW_CONTROL_WINDOW = 65 * 1024;
+
+  protected static final int TIMEOUT_MS = 5000;
+
+  protected static final String GRPC_EXPERIMENTAL_SUPPORT_TRACING_MESSAGE_SIZES =
+      "GRPC_EXPERIMENTAL_SUPPORT_TRACING_MESSAGE_SIZES";
+
+  private static final Attributes.Key<String> ADDITIONAL_TRANSPORT_ATTR_KEY =
+      Attributes.Key.create("additional-attr");
+
+  private static final Attributes.Key<String> EAG_ATTR_KEY =
+      Attributes.Key.create("eag-attr");
+
+  private static final Attributes EAG_ATTRS =
+      Attributes.newBuilder().set(EAG_ATTR_KEY, "value").build();
+
+  protected final TransportTracer.Factory fakeClockTransportTracer = new TransportTracer.Factory(
+      new TimeProvider() {
+        @Override
+        public long currentTimeNanos() {
+          return fakeCurrentTimeNanos();
+        }
+      });
+
+  /**
+   * Returns a new server that when started will be able to be connected to from the client. Each
+   * returned instance should be new and yet be accessible by new client transports.
+   */
+  protected abstract InternalServer newServer(
+      List<ServerStreamTracer.Factory> streamTracerFactories);
+
+  /**
+   * Builds a new server that is listening on the same port as the given server instance does.
+   */
+  protected abstract InternalServer newServer(
+      int port, List<ServerStreamTracer.Factory> streamTracerFactories);
+
+  /**
+   * Returns a new transport that when started will be able to connect to {@code server}.
+   */
+  protected abstract ManagedClientTransport newClientTransport(InternalServer server);
+
+  /**
+   * Returns the authority string used by a client to connect to {@code server}.
+   */
+  protected abstract String testAuthority(InternalServer server);
+
+  protected final Attributes eagAttrs() {
+    return EAG_ATTRS;
+  }
+
+  protected final ChannelLogger transportLogger() {
+    return new ChannelLogger() {
+      @Override
+      public void log(ChannelLogLevel level, String message) {}
+
+      @Override
+      public void log(ChannelLogLevel level, String messageFormat, Object... args) {}
+    };
+  }
+
+  /**
+   * When non-null, will be shut down during tearDown(). However, it _must_ have been started with
+   * {@code serverListener}, otherwise tearDown() can't wait for shutdown which can put following
+   * tests in an indeterminate state.
+   */
+  protected InternalServer server;
+  protected ServerTransport serverTransport;
+  protected ManagedClientTransport client;
+  protected MethodDescriptor<String, String> methodDescriptor =
+      MethodDescriptor.<String, String>newBuilder()
+          .setType(MethodDescriptor.MethodType.UNKNOWN)
+          .setFullMethodName("service/method")
+          .setRequestMarshaller(StringMarshaller.INSTANCE)
+          .setResponseMarshaller(StringMarshaller.INSTANCE)
+          .build();
+  private final CallOptions callOptions = CallOptions.DEFAULT;
+
+  private Metadata.Key<String> asciiKey = Metadata.Key.of(
+      "ascii-key", Metadata.ASCII_STRING_MARSHALLER);
+  private Metadata.Key<String> binaryKey = Metadata.Key.of(
+      "key-bin", StringBinaryMarshaller.INSTANCE);
+  private final Metadata.Key<String> tracerHeaderKey = Metadata.Key.of(
+      "tracer-key", Metadata.ASCII_STRING_MARSHALLER);
+  private final String tracerKeyValue = "tracer-key-value";
+
+  protected ManagedClientTransport.Listener mockClientTransportListener
+      = mock(ManagedClientTransport.Listener.class);
+  protected MockServerListener serverListener = new MockServerListener();
+  private ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+  protected final TestClientStreamTracer clientStreamTracer1 = new TestHeaderClientStreamTracer();
+  private final TestClientStreamTracer clientStreamTracer2 = new TestHeaderClientStreamTracer();
+  protected final ClientStreamTracer[] tracers = new ClientStreamTracer[] {
+      clientStreamTracer1, clientStreamTracer2
+  };
+  private final ClientStreamTracer[] noopTracers = new ClientStreamTracer[] {
+    new ClientStreamTracer() {}
+  };
+
+  protected final TestServerStreamTracer serverStreamTracer1 = new TestServerStreamTracer();
+  private final TestServerStreamTracer serverStreamTracer2 = new TestServerStreamTracer();
+  protected final ServerStreamTracer.Factory serverStreamTracerFactory = mock(
+      ServerStreamTracer.Factory.class,
+      delegatesTo(new ServerStreamTracer.Factory() {
+          final ArrayDeque<TestServerStreamTracer> tracers =
+              new ArrayDeque<>(Arrays.asList(serverStreamTracer1, serverStreamTracer2));
+
+          @Override
+          public ServerStreamTracer newServerStreamTracer(String fullMethodName, Metadata headers) {
+            TestServerStreamTracer tracer = tracers.poll();
+            if (tracer != null) {
+              return tracer;
+            }
+            return new TestServerStreamTracer();
+          }
+        }));
+
+  @Before
+  public void setUp() {
+    server = newServer(Arrays.asList(serverStreamTracerFactory));
+    when(mockClientTransportListener.filterTransport(any())).thenAnswer(i -> i.getArguments()[0]);
+  }
+
+  @After
+  public void tearDown() throws InterruptedException {
+    if (client != null) {
+      client.shutdownNow(Status.UNKNOWN.withDescription("teardown"));
+    }
+    if (serverTransport != null) {
+      serverTransport.shutdownNow(Status.UNKNOWN.withDescription("teardown"));
+    }
+    if (server != null) {
+      server.shutdown();
+      assertTrue(serverListener.waitForShutdown(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    }
+  }
+
+  /**
+   * Moves the clock forward, for tests that require moving the clock forward. It is the transport
+   * subclass's responsibility to implement this method.
+   */
+  protected void advanceClock(long offset, TimeUnit unit) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Returns true if env var is set.
+   */
+  protected static boolean isEnabledSupportTracingMessageSizes() {
+    return GrpcUtil.getFlag(GRPC_EXPERIMENTAL_SUPPORT_TRACING_MESSAGE_SIZES, false);
+  }
+
+  /**
+   * Returns the current time, for tests that rely on the clock.
+   */
+  protected long fakeCurrentTimeNanos() {
+    throw new UnsupportedOperationException();
+  }
+
+  // TODO(ejona):
+  //   multiple streams on same transport
+  //   multiple client transports to same server
+  //   halfClose to trigger flush (client and server)
+  //   flow control pushes back (client and server)
+  //   flow control provides precisely number of messages requested (client and server)
+  //   onReady called when buffer drained (on server and client)
+  //   test no start reentrancy (esp. during failure) (transport and call)
+  //   multiple requests/responses (verifying contents received)
+  //   server transport shutdown triggers client shutdown (via GOAWAY)
+  //   queued message InputStreams are closed on stream cancel
+  //     (and maybe exceptions handled)
+
+  /**
+   * Test for issue https://github.com/grpc/grpc-java/issues/1682 .
+   */
+  @Test
+  public void frameAfterRstStreamShouldNotBreakClientChannel() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    // Try to create a sequence of frames so that the client receives a HEADERS or DATA frame
+    // after having sent a RST_STREAM to the server. Previously, this would have broken the
+    // Netty channel.
+
+    ClientStream stream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    stream.start(clientStreamListener);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    stream.flush();
+    stream.writeMessage(methodDescriptor.streamRequest("foo"));
+    stream.flush();
+    stream.cancel(Status.CANCELLED);
+    stream.flush();
+    serverStreamCreation.stream.writeHeaders(new Metadata(), true);
+    serverStreamCreation.stream.flush();
+    serverStreamCreation.stream.writeMessage(methodDescriptor.streamResponse("bar"));
+    serverStreamCreation.stream.flush();
+
+    assertEquals(
+        Status.CANCELLED, clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    ClientStreamListener mockClientStreamListener2 = mock(ClientStreamListener.class);
+
+    // Test that the channel is still usable i.e. we can receive headers from the server on a
+    // new stream.
+    stream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
+    stream.start(mockClientStreamListener2);
+    serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverStreamCreation.stream.writeHeaders(new Metadata(), true);
+    serverStreamCreation.stream.flush();
+
+    verify(mockClientStreamListener2, timeout(TIMEOUT_MS)).headersRead(any(Metadata.class));
+  }
+
+  @Test
+  public void serverNotListening() throws Exception {
+    // Start server to just acquire a port.
+    server.start(serverListener);
+    client = newClientTransport(server);
+    server.shutdown();
+    assertTrue(serverListener.waitForShutdown(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    server = null;
+
+    InOrder inOrder = inOrder(mockClientTransportListener);
+    runIfNotNull(client.start(mockClientTransportListener));
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    inOrder.verify(mockClientTransportListener).transportShutdown(statusCaptor.capture(),
+        any(DisconnectError.class));
+    assertCodeEquals(Status.UNAVAILABLE, statusCaptor.getValue());
+    inOrder.verify(mockClientTransportListener).transportTerminated();
+    verify(mockClientTransportListener, never()).transportReady();
+    verify(mockClientTransportListener, never()).transportInUse(anyBoolean());
+  }
+
+  @Test
+  public void clientStartStop() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    InOrder inOrder = inOrder(mockClientTransportListener);
+    startTransport(client, mockClientTransportListener);
+    Status shutdownReason = Status.UNAVAILABLE.withDescription("shutdown called");
+    client.shutdown(shutdownReason);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
+    inOrder.verify(mockClientTransportListener).transportShutdown(same(shutdownReason),
+        any(DisconnectError.class));
+    inOrder.verify(mockClientTransportListener).transportTerminated();
+    verify(mockClientTransportListener, never()).transportInUse(anyBoolean());
+  }
+
+  @Test
+  public void clientStartAndStopOnceConnected() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    InOrder inOrder = inOrder(mockClientTransportListener);
+    startTransport(client, mockClientTransportListener);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    client.shutdown(Status.UNAVAILABLE);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
+    inOrder.verify(mockClientTransportListener).transportShutdown(any(Status.class),
+        any(DisconnectError.class));
+    inOrder.verify(mockClientTransportListener).transportTerminated();
+    assertTrue(serverTransportListener.waitForTermination(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    server.shutdown();
+    assertTrue(serverListener.waitForShutdown(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    server = null;
+    verify(mockClientTransportListener, never()).transportInUse(anyBoolean());
+  }
+
+  @Test
+  public void checkClientAttributes() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    assumeTrue(client instanceof ConnectionClientTransport);
+    ConnectionClientTransport connectionClient = (ConnectionClientTransport) client;
+    startTransport(connectionClient, mockClientTransportListener);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+
+    assertNotNull("security level should be set in client attributes",
+        connectionClient.getAttributes().get(GrpcAttributes.ATTR_SECURITY_LEVEL));
+  }
+
+  @Test
+  public void serverAlreadyListening() throws Exception {
+    client = null;
+    server.start(serverListener);
+    int port = -1;
+    SocketAddress addr = server.getListenSocketAddress();
+    if (addr instanceof InetSocketAddress) {
+      port = ((InetSocketAddress) addr).getPort();
+    }
+    InternalServer server2 = newServer(port, Arrays.asList(serverStreamTracerFactory));
+    assertThrows(IOException.class, () -> server2.start(new MockServerListener()));
+  }
+
+  @Test
+  public void serverStartInterrupted() throws Exception {
+    client = null;
+
+    // Just get free port
+    server.start(serverListener);
+    int port = -1;
+    SocketAddress addr = server.getListenSocketAddress();
+    if (addr instanceof InetSocketAddress) {
+      port = ((InetSocketAddress) addr).getPort();
+    }
+    assumeTrue("transport is not using InetSocketAddress", port != -1);
+    server.shutdown();
+    assertTrue(serverListener.waitForShutdown(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    server = newServer(port, Arrays.asList(serverStreamTracerFactory));
+    boolean success;
+    Thread.currentThread().interrupt();
+    try {
+      server.start(serverListener = new MockServerListener());
+      success = true;
+    } catch (Exception ex) {
+      success = false;
+    } finally {
+      Thread.interrupted(); // clear interruption
+    }
+    assumeTrue("apparently start is not impacted by interruption, so nothing to test", !success);
+    // second time should not throw, as the first time should not have bound to the port
+    server.start(serverListener);
+  }
+
+  @Test
+  public void openStreamPreventsTermination() throws Exception {
+    server.start(serverListener);
+    int port = -1;
+    SocketAddress addr = server.getListenSocketAddress();
+    if (addr instanceof InetSocketAddress) {
+      port = ((InetSocketAddress) addr).getPort();
+    }
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    client.shutdown(Status.UNAVAILABLE);
+    client = null;
+    server.shutdown();
+    serverTransport.shutdown();
+    serverTransport = null;
+
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class),
+        any(DisconnectError.class));
+    assertTrue(serverListener.waitForShutdown(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    // A new server should be able to start listening, since the current server has given up
+    // resources. There may be cases this is impossible in the future, but for now it is a useful
+    // property.
+    serverListener = new MockServerListener();
+    server = newServer(port, Arrays.asList(serverStreamTracerFactory));
+    server.start(serverListener);
+
+    // Try to "flush" out any listener notifications on client and server. This also ensures that
+    // the stream still functions.
+    serverStream.writeHeaders(new Metadata(), true);
+    clientStream.halfClose();
+    assertNotNull(clientStreamListener.awaitHeaders(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertTrue(serverStreamListener.awaitHalfClosed(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    verify(mockClientTransportListener, never()).transportTerminated();
+    verify(mockClientTransportListener, never()).transportInUse(false);
+    assertFalse(serverTransportListener.isTerminated());
+
+    clientStream.cancel(Status.CANCELLED);
+
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(false);
+    assertTrue(serverTransportListener.waitForTermination(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+  }
+
+  @Test
+  public void shutdownNowKillsClientStream() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    Status status = Status.UNKNOWN.withDescription("test shutdownNow");
+    client.shutdownNow(status);
+    client = null;
+
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class),
+        any(DisconnectError.class));
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(false);
+    assertTrue(serverTransportListener.waitForTermination(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertTrue(serverTransportListener.isTerminated());
+
+    assertEquals(status, clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status serverStatus = serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertFalse(serverStatus.isOk());
+    assertTrue(clientStreamTracer1.await(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNull(clientStreamTracer1.getInboundTrailers());
+    assertStatusEquals(status, clientStreamTracer1.getStatus());
+    assertTrue(serverStreamTracer1.await(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertStatusEquals(serverStatus, serverStreamTracer1.getStatus());
+  }
+
+  @Test
+  public void shutdownNowKillsServerStream() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    Status shutdownStatus = Status.UNKNOWN.withDescription("test shutdownNow");
+    serverTransport.shutdownNow(shutdownStatus);
+    serverTransport = null;
+
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class),
+        any(DisconnectError.class));
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(false);
+    assertTrue(serverTransportListener.waitForTermination(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertTrue(serverTransportListener.isTerminated());
+
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertFalse(clientStreamStatus.isOk());
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertTrue(clientStreamTracer1.await(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNull(clientStreamTracer1.getInboundTrailers());
+    assertStatusEquals(clientStreamStatus, clientStreamTracer1.getStatus());
+    assertTrue(serverStreamTracer1.await(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertStatusEquals(shutdownStatus, serverStreamTracer1.getStatus());
+
+    // Generally will be same status provided to shutdownNow, but InProcessTransport can't
+    // differentiate between client and server shutdownNow. The status is not really used on
+    // server-side, so we don't care much.
+    assertNotNull(serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+  }
+
+  @Test
+  public void ping() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    ClientTransport.PingCallback mockPingCallback = mock(ClientTransport.PingCallback.class);
+    try {
+      client.ping(mockPingCallback, MoreExecutors.directExecutor());
+    } catch (UnsupportedOperationException ex) {
+      // Transport doesn't support ping, so this neither passes nor fails.
+      assumeTrue(false);
+    }
+    verify(mockPingCallback, timeout(TIMEOUT_MS)).onSuccess(ArgumentMatchers.anyLong());
+    verify(mockClientTransportListener, never()).transportInUse(anyBoolean());
+  }
+
+  @Test
+  public void ping_duringShutdown() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    // Stream prevents termination
+    ClientStream stream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    stream.start(clientStreamListener);
+    client.shutdown(Status.UNAVAILABLE);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class),
+        any(DisconnectError.class));
+    ClientTransport.PingCallback mockPingCallback = mock(ClientTransport.PingCallback.class);
+    try {
+      client.ping(mockPingCallback, MoreExecutors.directExecutor());
+    } catch (UnsupportedOperationException ex) {
+      // Transport doesn't support ping, so this neither passes nor fails.
+      assumeTrue(false);
+    }
+    verify(mockPingCallback, timeout(TIMEOUT_MS)).onSuccess(ArgumentMatchers.anyLong());
+    stream.cancel(Status.CANCELLED);
+  }
+
+  @Test
+  public void ping_afterTermination() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+    Status shutdownReason = Status.UNAVAILABLE.withDescription("shutdown called");
+    client.shutdown(shutdownReason);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
+    ClientTransport.PingCallback mockPingCallback = mock(ClientTransport.PingCallback.class);
+    try {
+      client.ping(mockPingCallback, MoreExecutors.directExecutor());
+    } catch (UnsupportedOperationException ex) {
+      // Transport doesn't support ping, so this neither passes nor fails.
+      assumeTrue(false);
+    }
+    verify(mockPingCallback, timeout(TIMEOUT_MS)).onFailure(statusCaptor.capture());
+    Status status = statusCaptor.getValue();
+    assertSame(shutdownReason, status);
+  }
+
+  @Test
+  public void newStream_duringShutdown() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    // Stream prevents termination
+    ClientStream stream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    stream.start(clientStreamListener);
+    client.shutdown(Status.UNAVAILABLE);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class),
+        any(DisconnectError.class));
+
+    ClientStream stream2 = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener2 = new ClientStreamListenerBase();
+    stream2.start(clientStreamListener2);
+    Status clientStreamStatus2 =
+        clientStreamListener2.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertNotNull(clientStreamListener2.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertCodeEquals(Status.UNAVAILABLE, clientStreamStatus2);
+    assertNull(clientStreamTracer2.getInboundTrailers());
+    assertSame(clientStreamStatus2, clientStreamTracer2.getStatus());
+
+    // Make sure earlier stream works.
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+    // TODO(zdapeng): Increased timeout to 20 seconds to see if flakiness of #2328 persists. Take
+    // further action after sufficient observation.
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(20 * TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverStreamCreation.stream.close(Status.OK, new Metadata());
+    assertCodeEquals(Status.OK, clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+  }
+
+  @Test
+  public void newStream_afterTermination() throws Exception {
+    // We expect the same general behavior as duringShutdown, but for some transports (e.g., Netty)
+    // dealing with afterTermination is harder than duringShutdown.
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
+    Status shutdownReason = Status.UNAVAILABLE.withDescription("shutdown called");
+    client.shutdown(shutdownReason);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
+    Thread.sleep(100);
+    ClientStream stream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    stream.start(clientStreamListener);
+    assertEquals(
+        shutdownReason, clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    verify(mockClientTransportListener, never()).transportInUse(anyBoolean());
+    assertNull(clientStreamTracer1.getInboundTrailers());
+    assertSame(shutdownReason, clientStreamTracer1.getStatus());
+    // Assert no interactions
+    assertNull(serverStreamTracer1.getServerCallInfo());
+  }
+
+  @Test
+  public void transportInUse_balancerRpcsNotCounted() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+
+    // stream1 is created by balancer through Subchannel.asChannel(), which is marked by
+    // CALL_OPTIONS_RPC_OWNED_BY_BALANCER in CallOptions.  It won't be counted for in-use signal.
+    ClientStream stream1 = client.newStream(
+        methodDescriptor, new Metadata(),
+        callOptions.withOption(GrpcUtil.CALL_OPTIONS_RPC_OWNED_BY_BALANCER, Boolean.TRUE),
+        noopTracers);
+    ClientStreamListenerBase clientStreamListener1 = new ClientStreamListenerBase();
+    stream1.start(clientStreamListener1);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    StreamCreation serverStreamCreation1
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+
+    // stream2 is the normal RPC, and will be counted for in-use
+    ClientStream stream2 = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
+    ClientStreamListenerBase clientStreamListener2 = new ClientStreamListenerBase();
+    stream2.start(clientStreamListener2);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
+    StreamCreation serverStreamCreation2
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+
+    stream2.halfClose();
+    verify(mockClientTransportListener, never()).transportInUse(false);
+    serverStreamCreation2.stream.close(Status.OK, new Metadata());
+    // As soon as stream2 is closed, even though stream1 is still open, the transport will report
+    // in-use == false.
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(false);
+
+    stream1.halfClose();
+    serverStreamCreation1.stream.close(Status.OK, new Metadata());
+    // Verify that the callback has been called only once for true and false respectively
+    verify(mockClientTransportListener).transportInUse(true);
+    verify(mockClientTransportListener).transportInUse(false);
+  }
+
+  @Test
+  public void transportInUse_normalClose() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    ClientStream stream1 = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
+    ClientStreamListenerBase clientStreamListener1 = new ClientStreamListenerBase();
+    stream1.start(clientStreamListener1);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    StreamCreation serverStreamCreation1
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ClientStream stream2 = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
+    ClientStreamListenerBase clientStreamListener2 = new ClientStreamListenerBase();
+    stream2.start(clientStreamListener2);
+    StreamCreation serverStreamCreation2
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+
+    stream1.halfClose();
+    serverStreamCreation1.stream.close(Status.OK, new Metadata());
+    stream2.halfClose();
+    verify(mockClientTransportListener, never()).transportInUse(false);
+    serverStreamCreation2.stream.close(Status.OK, new Metadata());
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(false);
+    // Verify that the callback has been called only once for true and false respectively
+    verify(mockClientTransportListener).transportInUse(true);
+    verify(mockClientTransportListener).transportInUse(false);
+  }
+
+  @Test
+  public void transportInUse_clientCancel() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    ClientStream stream1 = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
+    ClientStreamListenerBase clientStreamListener1 = new ClientStreamListenerBase();
+    stream1.start(clientStreamListener1);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
+    ClientStream stream2 = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, noopTracers);
+    ClientStreamListenerBase clientStreamListener2 = new ClientStreamListenerBase();
+    stream2.start(clientStreamListener2);
+
+    stream1.cancel(Status.CANCELLED);
+    verify(mockClientTransportListener, never()).transportInUse(false);
+    stream2.cancel(Status.CANCELLED);
+    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(false);
+    // Verify that the callback has been called only once for true and false respectively
+    verify(mockClientTransportListener).transportInUse(true);
+    verify(mockClientTransportListener).transportInUse(false);
+  }
+
+  @Test
+  public void basicStream() throws Exception {
+    serverListener =
+        new MockServerListener(
+            transport ->
+                new MockServerTransportListener(transport) {
+                  @Override
+                  public Attributes transportReady(Attributes attributes) {
+                    return super.transportReady(attributes).toBuilder()
+                        .set(ADDITIONAL_TRANSPORT_ATTR_KEY, "additional attribute value")
+                        .build();
+                  }
+                });
+    InOrder serverInOrder = inOrder(serverStreamTracerFactory);
+    server.start(serverListener);
+    client = newClientTransport(server);
+
+    startTransport(client, mockClientTransportListener);
+
+    // This attribute is available right after transport is started
+    assertThat(((ConnectionClientTransport) client).getAttributes()
+        .get(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS)).isSameInstanceAs(EAG_ATTRS);
+
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    Metadata clientHeaders = new Metadata();
+    clientHeaders.put(asciiKey, "client");
+    clientHeaders.put(asciiKey, "dupvalue");
+    clientHeaders.put(asciiKey, "dupvalue");
+    clientHeaders.put(binaryKey, "äbinaryclient");
+    clientHeaders.put(binaryKey, "dup,value");
+    Metadata clientHeadersCopy = new Metadata();
+
+    clientHeadersCopy.merge(clientHeaders);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, clientHeaders, callOptions, tracers);
+    assertThat(((TestHeaderClientStreamTracer) clientStreamTracer1).transportAttrs)
+        .isSameInstanceAs(((ConnectionClientTransport) client).getAttributes());
+
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertTrue(clientStreamTracer1.awaitOutboundHeaders(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertEquals(methodDescriptor.getFullMethodName(), serverStreamCreation.method);
+    assertEquals(Lists.newArrayList(clientHeadersCopy.getAll(asciiKey)),
+        Lists.newArrayList(serverStreamCreation.headers.getAll(asciiKey)));
+    assertEquals(Lists.newArrayList(clientHeadersCopy.getAll(binaryKey)),
+        Lists.newArrayList(serverStreamCreation.headers.getAll(binaryKey)));
+    assertEquals(tracerKeyValue, serverStreamCreation.headers.get(tracerHeaderKey));
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    serverInOrder.verify(serverStreamTracerFactory).newServerStreamTracer(
+        eq(methodDescriptor.getFullMethodName()), any(Metadata.class));
+
+    assertEquals("additional attribute value",
+        serverStream.getAttributes().get(ADDITIONAL_TRANSPORT_ATTR_KEY));
+    assertNotNull(serverStream.getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR));
+    assertNotNull(serverStream.getAttributes().get(Grpc.TRANSPORT_ATTR_LOCAL_ADDR));
+
+    // This attribute is still available when the transport is connected
+    assertThat(((ConnectionClientTransport) client).getAttributes()
+        .get(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS)).isSameInstanceAs(EAG_ATTRS);
+
+    serverStream.request(1);
+    assertTrue(clientStreamListener.awaitOnReadyAndDrain(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertTrue(clientStream.isReady());
+    clientStream.writeMessage(methodDescriptor.streamRequest("Hello!"));
+    assertThat(clientStreamTracer1.nextOutboundEvent()).isEqualTo("outboundMessage(0)");
+
+    clientStream.flush();
+    InputStream message = serverStreamListener.messageQueue.poll(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertEquals("Hello!", methodDescriptor.parseRequest(message));
+    message.close();
+    assertThat(clientStreamTracer1.nextOutboundEvent())
+        .matches("outboundMessageSent\\(0, -?[0-9]+, -?[0-9]+\\)");
+    if (isEnabledSupportTracingMessageSizes()) {
+      assertThat(clientStreamTracer1.getOutboundWireSize()).isGreaterThan(0L);
+      assertThat(clientStreamTracer1.getOutboundUncompressedSize()).isGreaterThan(0L);
+    }
+
+    assertThat(serverStreamTracer1.nextInboundEvent()).isEqualTo("inboundMessage(0)");
+    assertNull("no additional message expected", serverStreamListener.messageQueue.poll());
+
+    clientStream.halfClose();
+    assertTrue(serverStreamListener.awaitHalfClosed(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    if (isEnabledSupportTracingMessageSizes()) {
+      assertThat(serverStreamTracer1.getInboundWireSize()).isGreaterThan(0L);
+      assertThat(serverStreamTracer1.getInboundUncompressedSize()).isGreaterThan(0L);
+    }
+    assertThat(serverStreamTracer1.nextInboundEvent())
+        .matches("inboundMessageRead\\(0, -?[0-9]+, -?[0-9]+\\)");
+
+    Metadata serverHeaders = new Metadata();
+    serverHeaders.put(asciiKey, "server");
+    serverHeaders.put(asciiKey, "dupvalue");
+    serverHeaders.put(asciiKey, "dupvalue");
+    serverHeaders.put(binaryKey, "äbinaryserver");
+    serverHeaders.put(binaryKey, "dup,value");
+    Metadata serverHeadersCopy = new Metadata();
+    serverHeadersCopy.merge(serverHeaders);
+    serverStream.writeHeaders(serverHeaders, true);
+    Metadata headers = clientStreamListener.awaitHeaders(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertNotNull(headers);
+    assertAsciiMetadataValuesEqual(serverHeadersCopy.getAll(asciiKey), headers.getAll(asciiKey));
+    assertEquals(
+        Lists.newArrayList(serverHeadersCopy.getAll(binaryKey)),
+        Lists.newArrayList(headers.getAll(binaryKey)));
+
+    clientStream.request(1);
+    assertTrue(serverStreamListener.awaitOnReadyAndDrain(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertTrue(serverStream.isReady());
+    serverStream.writeMessage(methodDescriptor.streamResponse("Hi. Who are you?"));
+    assertThat(serverStreamTracer1.nextOutboundEvent()).isEqualTo("outboundMessage(0)");
+
+    serverStream.flush();
+    message = clientStreamListener.messageQueue.poll(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertNotNull("message expected", message);
+    assertThat(serverStreamTracer1.nextOutboundEvent())
+        .matches("outboundMessageSent\\(0, -?[0-9]+, -?[0-9]+\\)");
+    if (isEnabledSupportTracingMessageSizes()) {
+      assertThat(serverStreamTracer1.getOutboundWireSize()).isGreaterThan(0L);
+      assertThat(serverStreamTracer1.getOutboundUncompressedSize()).isGreaterThan(0L);
+    }
+    assertTrue(clientStreamTracer1.getInboundHeaders());
+    assertThat(clientStreamTracer1.nextInboundEvent()).isEqualTo("inboundMessage(0)");
+    assertEquals("Hi. Who are you?", methodDescriptor.parseResponse(message));
+    assertThat(clientStreamTracer1.nextInboundEvent())
+        .matches("inboundMessageRead\\(0, -?[0-9]+, -?[0-9]+\\)");
+    if (isEnabledSupportTracingMessageSizes()) {
+      assertThat(clientStreamTracer1.getInboundWireSize()).isGreaterThan(0L);
+      assertThat(clientStreamTracer1.getInboundUncompressedSize()).isGreaterThan(0L);
+    }
+
+    message.close();
+    assertNull("no additional message expected", clientStreamListener.messageQueue.poll());
+
+    Status status = Status.OK.withDescription("That was normal");
+    Metadata trailers = new Metadata();
+    trailers.put(asciiKey, "trailers");
+    trailers.put(asciiKey, "dupvalue");
+    trailers.put(asciiKey, "dupvalue");
+    trailers.put(binaryKey, "äbinarytrailers");
+    trailers.put(binaryKey, "dup,value");
+    serverStream.close(status, trailers);
+    assertNull(serverStreamTracer1.nextInboundEvent());
+    assertNull(serverStreamTracer1.nextOutboundEvent());
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertSame(status, serverStreamTracer1.getStatus());
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    Metadata clientStreamTrailers =
+        clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertSame(clientStreamTrailers, clientStreamTracer1.getInboundTrailers());
+    assertSame(clientStreamStatus, clientStreamTracer1.getStatus());
+    assertNull(clientStreamTracer1.nextInboundEvent());
+    assertNull(clientStreamTracer1.nextOutboundEvent());
+    assertEquals(status.getCode(), clientStreamStatus.getCode());
+    assertEquals(status.getDescription(), clientStreamStatus.getDescription());
+    assertAsciiMetadataValuesEqual(
+        trailers.getAll(asciiKey), clientStreamTrailers.getAll(asciiKey));
+    assertEquals(
+        Lists.newArrayList(trailers.getAll(binaryKey)),
+        Lists.newArrayList(clientStreamTrailers.getAll(binaryKey)));
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void authorityPropagation() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+            = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+
+    Metadata clientHeaders = new Metadata();
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, clientHeaders, callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation
+            = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+
+    assertEquals(testAuthority(server), serverStream.getAuthority());
+  }
+
+  private void assertAsciiMetadataValuesEqual(Iterable<String> expected, Iterable<String> actural) {
+    StringBuilder sbExpected = new StringBuilder();
+    for (String str : expected) {
+      sbExpected.append(str).append(",");
+    }
+    StringBuilder sbActual = new StringBuilder();
+    for (String str : actural) {
+      sbActual.append(str).append(",");
+    }
+    assertEquals(sbExpected.toString(), sbActual.toString());
+  }
+
+  @Test
+  public void zeroMessageStream() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    clientStream.halfClose();
+    assertTrue(serverStreamListener.awaitHalfClosed(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    serverStream.writeHeaders(new Metadata(), true);
+    assertNotNull(clientStreamListener.awaitHeaders(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    Status status = Status.OK.withDescription("Nice talking to you");
+    serverStream.close(status, new Metadata());
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    Metadata clientStreamTrailers =
+        clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertNotNull(clientStreamTrailers);
+    assertEquals(status.getCode(), clientStreamStatus.getCode());
+    assertEquals(status.getDescription(), clientStreamStatus.getDescription());
+    assertTrue(clientStreamTracer1.getOutboundHeaders());
+    assertTrue(clientStreamTracer1.getInboundHeaders());
+    assertSame(clientStreamTrailers, clientStreamTracer1.getInboundTrailers());
+    assertSame(clientStreamStatus, clientStreamTracer1.getStatus());
+    assertSame(status, serverStreamTracer1.getStatus());
+  }
+
+  @Test
+  public void earlyServerClose_withServerHeaders() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    serverStream.writeHeaders(new Metadata(), true);
+    assertNotNull(clientStreamListener.awaitHeaders(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    Status strippedStatus = Status.OK.withDescription("Hello. Goodbye.");
+    Status status = strippedStatus.withCause(new Exception());
+    serverStream.close(status, new Metadata());
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    Metadata clientStreamTrailers =
+        clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertNotNull(clientStreamTrailers);
+    checkClientStatus(status, clientStreamStatus);
+    assertTrue(clientStreamTracer1.getOutboundHeaders());
+    assertTrue(clientStreamTracer1.getInboundHeaders());
+    assertSame(clientStreamTrailers, clientStreamTracer1.getInboundTrailers());
+    assertSame(clientStreamStatus, clientStreamTracer1.getStatus());
+    assertSame(status, serverStreamTracer1.getStatus());
+  }
+
+  @Test
+  public void earlyServerClose_noServerHeaders() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    Status strippedStatus = Status.OK.withDescription("Hellogoodbye");
+    Status status = strippedStatus.withCause(new Exception());
+    Metadata trailers = new Metadata();
+    trailers.put(asciiKey, "trailers");
+    trailers.put(asciiKey, "dupvalue");
+    trailers.put(asciiKey, "dupvalue");
+    trailers.put(binaryKey, "äbinarytrailers");
+    serverStream.close(status, trailers);
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    Metadata clientStreamTrailers =
+        clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    checkClientStatus(status, clientStreamStatus);
+    assertEquals(
+        Lists.newArrayList(trailers.getAll(asciiKey)),
+        Lists.newArrayList(clientStreamTrailers.getAll(asciiKey)));
+    assertEquals(
+        Lists.newArrayList(trailers.getAll(binaryKey)),
+        Lists.newArrayList(clientStreamTrailers.getAll(binaryKey)));
+    assertTrue(clientStreamTracer1.getOutboundHeaders());
+    assertSame(clientStreamTrailers, clientStreamTracer1.getInboundTrailers());
+    assertSame(clientStreamStatus, clientStreamTracer1.getStatus());
+    assertSame(status, serverStreamTracer1.getStatus());
+  }
+
+  @Test
+  public void earlyServerClose_serverFailure() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    Status strippedStatus = Status.INTERNAL.withDescription("I'm not listening");
+    Status status = strippedStatus.withCause(new Exception());
+    serverStream.close(status, new Metadata());
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    Metadata clientStreamTrailers =
+        clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertNotNull(clientStreamTrailers);
+    checkClientStatus(status, clientStreamStatus);
+    assertTrue(clientStreamTracer1.getOutboundHeaders());
+    assertSame(clientStreamTrailers, clientStreamTracer1.getInboundTrailers());
+    assertSame(clientStreamStatus, clientStreamTracer1.getStatus());
+    assertSame(status, serverStreamTracer1.getStatus());
+  }
+
+  @Test
+  public void earlyServerClose_serverFailure_withClientCancelOnListenerClosed() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    final ClientStream clientStream =
+        client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase() {
+
+      @Override
+      public void closed(
+          Status status, RpcProgress rpcProgress, Metadata trailers) {
+        super.closed(status, rpcProgress, trailers);
+        // This simulates the blocking calls which can trigger clientStream.cancel().
+        clientStream.cancel(Status.CANCELLED.withCause(status.asRuntimeException()));
+      }
+    };
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    Status strippedStatus = Status.INTERNAL.withDescription("I'm not listening");
+    Status status = strippedStatus.withCause(new Exception());
+    serverStream.close(status, new Metadata());
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    Metadata clientStreamTrailers =
+        clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertNotNull(clientStreamTrailers);
+    checkClientStatus(status, clientStreamStatus);
+    assertTrue(clientStreamTracer1.getOutboundHeaders());
+    assertSame(clientStreamTrailers, clientStreamTracer1.getInboundTrailers());
+    assertSame(clientStreamStatus, clientStreamTracer1.getStatus());
+    assertSame(status, serverStreamTracer1.getStatus());
+  }
+
+  @Test
+  public void clientCancel() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    Status status = Status.CANCELLED.withDescription("Nevermind").withCause(new Exception());
+    clientStream.cancel(status);
+    assertEquals(status, clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status serverStatus = serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertNotEquals(Status.Code.OK, serverStatus.getCode());
+    // Cause should not be transmitted between client and server by default
+    assertNull(serverStatus.getCause());
+
+    clientStream.cancel(status);
+    assertTrue(clientStreamTracer1.getOutboundHeaders());
+    assertNull(clientStreamTracer1.getInboundTrailers());
+    assertSame(status, clientStreamTracer1.getStatus());
+    assertSame(serverStatus, serverStreamTracer1.getStatus());
+  }
+
+  @Test
+  public void clientCancelFromWithinMessageRead() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    final SettableFuture<Boolean> closedCalled = SettableFuture.create();
+    final ClientStream clientStream =
+        client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    final Status status = Status.CANCELLED.withDescription("nevermind");
+    clientStream.start(new ClientStreamListener() {
+      private boolean messageReceived = false;
+
+      @Override
+      public void headersRead(Metadata headers) {
+      }
+
+      @Override
+      public void closed(
+          Status status, RpcProgress rpcProgress, Metadata trailers) {
+        assertEquals(Status.CANCELLED.getCode(), status.getCode());
+        assertEquals("nevermind", status.getDescription());
+        closedCalled.set(true);
+      }
+
+      @Override
+      public void messagesAvailable(MessageProducer producer) {
+        InputStream message;
+        while ((message = producer.next()) != null) {
+          assertFalse("too many messages received", messageReceived);
+          messageReceived = true;
+          assertEquals("foo", methodDescriptor.parseResponse(message));
+          clientStream.cancel(status);
+        }
+      }
+
+      @Override
+      public void onReady() {
+      }
+    });
+    clientStream.halfClose();
+    clientStream.request(1);
+
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertEquals(methodDescriptor.getFullMethodName(), serverStreamCreation.method);
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+    assertTrue(serverStreamListener.awaitOnReadyAndDrain(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    assertTrue(serverStream.isReady());
+    serverStream.writeHeaders(new Metadata(), true);
+    serverStream.writeMessage(methodDescriptor.streamRequest("foo"));
+    serverStream.flush();
+
+    // Block until closedCalled was set.
+    closedCalled.get(5, TimeUnit.SECONDS);
+
+    serverStream.close(Status.OK, new Metadata());
+    assertTrue(clientStreamTracer1.getOutboundHeaders());
+    assertTrue(clientStreamTracer1.getInboundHeaders());
+    if (isEnabledSupportTracingMessageSizes()) {
+      assertThat(clientStreamTracer1.getInboundWireSize()).isGreaterThan(0L);
+      assertThat(clientStreamTracer1.getInboundUncompressedSize()).isGreaterThan(0L);
+      assertThat(serverStreamTracer1.getOutboundWireSize()).isGreaterThan(0L);
+      assertThat(serverStreamTracer1.getOutboundUncompressedSize()).isGreaterThan(0L);
+    }
+    assertNull(clientStreamTracer1.getInboundTrailers());
+    assertSame(status, clientStreamTracer1.getStatus());
+    // There is a race between client cancelling and server closing.  The final status seen by the
+    // server is non-deterministic.
+    assertTrue(serverStreamTracer1.await(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(serverStreamTracer1.getStatus());
+  }
+
+  @Test
+  public void serverCancel() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    Status status = Status.DEADLINE_EXCEEDED.withDescription("It was bound to happen")
+        .withCause(new Exception());
+    serverStream.cancel(status);
+    assertEquals(status, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    // Presently we can't sent much back to the client in this case. Verify that is the current
+    // behavior for consistency between transports.
+    assertCodeEquals(Status.CANCELLED, clientStreamStatus);
+    // Cause should not be transmitted between server and client
+    assertNull(clientStreamStatus.getCause());
+
+    assertTrue(clientStreamTracer1.getOutboundHeaders());
+    assertNull(clientStreamTracer1.getInboundTrailers());
+    assertSame(clientStreamStatus, clientStreamTracer1.getStatus());
+    verify(serverStreamTracerFactory).newServerStreamTracer(anyString(), any(Metadata.class));
+    assertSame(status, serverStreamTracer1.getStatus());
+
+    // Second cancellation shouldn't trigger additional callbacks
+    serverStream.cancel(status);
+    doPingPong(serverListener);
+  }
+
+  @Test
+  public void flowControlPushBack() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener =
+        serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    ClientStream clientStream =
+        client.newStream(methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation =
+        serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertEquals(methodDescriptor.getFullMethodName(), serverStreamCreation.method);
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    serverStream.writeHeaders(new Metadata(), true);
+
+    String largeMessage = newString(1024);
+
+    serverStream.request(1);
+    assertTrue(clientStreamListener.awaitOnReadyAndDrain(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertTrue(clientStream.isReady());
+    final int maxToSend = 10 * 1024;
+    int clientSent;
+    // Verify that flow control will push back on client.
+    for (clientSent = 0; clientStream.isReady(); clientSent++) {
+      if (clientSent > maxToSend) {
+        // It seems like flow control isn't working. _Surely_ flow control would have pushed-back
+        // already. If this is normal, please configure the transport to buffer less.
+        fail("Too many messages sent before isReady() returned false");
+      }
+      clientStream.writeMessage(methodDescriptor.streamRequest(largeMessage));
+      clientStream.flush();
+    }
+    assertTrue(clientSent > 0);
+    // Make sure there are at least a few messages buffered.
+    for (; clientSent < 5; clientSent++) {
+      clientStream.writeMessage(methodDescriptor.streamResponse(largeMessage));
+      clientStream.flush();
+    }
+    doPingPong(serverListener);
+
+    int serverReceived = verifyMessageCountAndClose(serverStreamListener.messageQueue, 1);
+
+    clientStream.request(1);
+    assertTrue(serverStreamListener.awaitOnReadyAndDrain(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertTrue(serverStream.isReady());
+    int serverSent;
+    // Verify that flow control will push back on server.
+    for (serverSent = 0; serverStream.isReady(); serverSent++) {
+      if (serverSent > maxToSend) {
+        // It seems like flow control isn't working. _Surely_ flow control would have pushed-back
+        // already. If this is normal, please configure the transport to buffer less.
+        fail("Too many messages sent before isReady() returned false");
+      }
+      serverStream.writeMessage(methodDescriptor.streamResponse(largeMessage));
+      serverStream.flush();
+    }
+    assertTrue(serverSent > 0);
+    // Make sure there are at least a few messages buffered.
+    for (; serverSent < 5; serverSent++) {
+      serverStream.writeMessage(methodDescriptor.streamResponse(largeMessage));
+      serverStream.flush();
+    }
+    doPingPong(serverListener);
+
+    int clientReceived = verifyMessageCountAndClose(clientStreamListener.messageQueue, 1);
+
+    serverStream.request(3);
+    clientStream.request(3);
+    doPingPong(serverListener);
+    clientReceived += verifyMessageCountAndClose(clientStreamListener.messageQueue, 3);
+    serverReceived += verifyMessageCountAndClose(serverStreamListener.messageQueue, 3);
+
+    // Request the rest
+    serverStream.request(clientSent);
+    clientStream.request(serverSent);
+    clientReceived +=
+        verifyMessageCountAndClose(clientStreamListener.messageQueue, serverSent - clientReceived);
+    serverReceived +=
+        verifyMessageCountAndClose(serverStreamListener.messageQueue, clientSent - serverReceived);
+
+    assertTrue(clientStreamListener.awaitOnReadyAndDrain(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertTrue(clientStream.isReady());
+    assertTrue(serverStreamListener.awaitOnReadyAndDrain(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertTrue(serverStream.isReady());
+
+    // Request four more
+    for (int i = 0; i < 5; i++) {
+      clientStream.writeMessage(methodDescriptor.streamRequest(largeMessage));
+      clientStream.flush();
+      serverStream.writeMessage(methodDescriptor.streamResponse(largeMessage));
+      serverStream.flush();
+    }
+    doPingPong(serverListener);
+    clientReceived += verifyMessageCountAndClose(clientStreamListener.messageQueue, 4);
+    serverReceived += verifyMessageCountAndClose(serverStreamListener.messageQueue, 4);
+
+    // Drain exactly how many messages are left
+    serverStream.request(1);
+    clientStream.request(1);
+    clientReceived += verifyMessageCountAndClose(clientStreamListener.messageQueue, 1);
+    serverReceived += verifyMessageCountAndClose(serverStreamListener.messageQueue, 1);
+
+    // And now check that the streams can still complete gracefully
+    clientStream.writeMessage(methodDescriptor.streamRequest(largeMessage));
+    clientStream.flush();
+    clientStream.halfClose();
+    doPingPong(serverListener);
+    assertFalse(serverStreamListener.isHalfClosed());
+
+    serverStream.request(1);
+    serverReceived += verifyMessageCountAndClose(serverStreamListener.messageQueue, 1);
+    assertEquals(clientSent + 6, serverReceived);
+    assertTrue(serverStreamListener.awaitHalfClosed(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    serverStream.writeMessage(methodDescriptor.streamResponse(largeMessage));
+    serverStream.flush();
+    Status status = Status.OK.withDescription("... quite a lengthy discussion");
+    serverStream.close(status, new Metadata());
+    doPingPong(serverListener);
+    assertFalse(clientStreamListener.isClosed());
+
+    clientStream.request(1);
+    clientReceived += verifyMessageCountAndClose(clientStreamListener.messageQueue, 1);
+    assertEquals(serverSent + 6, clientReceived);
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertEquals(status.getCode(), clientStreamStatus.getCode());
+    assertEquals(status.getDescription(), clientStreamStatus.getDescription());
+  }
+
+  @Test
+  public void flowControlDoesNotDeadlockLargeMessage() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener =
+        serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    ClientStream clientStream =
+        client.newStream(methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation =
+        serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertEquals(methodDescriptor.getFullMethodName(), serverStreamCreation.method);
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    serverStream.writeHeaders(new Metadata(), true);
+
+    String largeMessage = newString(TEST_FLOW_CONTROL_WINDOW + 1);
+
+    serverStream.request(1);
+    assertTrue(clientStreamListener.awaitOnReadyAndDrain(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertTrue(clientStream.isReady());
+    clientStream.writeMessage(methodDescriptor.streamRequest(largeMessage));
+    clientStream.flush();
+    doPingPong(serverListener);
+
+    verifyMessageCountAndClose(serverStreamListener.messageQueue, 1);
+
+    clientStream.request(1);
+    assertTrue(serverStreamListener.awaitOnReadyAndDrain(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertTrue(serverStream.isReady());
+    serverStream.writeMessage(methodDescriptor.streamResponse(largeMessage));
+    serverStream.flush();
+    doPingPong(serverListener);
+
+    verifyMessageCountAndClose(clientStreamListener.messageQueue, 1);
+
+    // And now check that the streams can still complete normally.
+    clientStream.halfClose();
+    doPingPong(serverListener);
+    serverStream.request(1);
+    assertTrue(serverStreamListener.awaitHalfClosed(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    Status status = Status.OK.withDescription("... quite a lengthy discussion");
+    serverStream.close(status, new Metadata());
+    doPingPong(serverListener);
+    clientStream.request(1);
+    assertCodeEquals(Status.OK, serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    Status clientStreamStatus = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertEquals(status.getCode(), clientStreamStatus.getCode());
+    assertEquals(status.getDescription(), clientStreamStatus.getDescription());
+  }
+
+  private int verifyMessageCountAndClose(BlockingQueue<InputStream> messageQueue, int count)
+      throws Exception {
+    InputStream message;
+    for (int i = 0; i < count; i++) {
+      message = messageQueue.poll(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+      assertNotNull(message);
+      message.close();
+    }
+    assertNull("no additional message expected", messageQueue.poll());
+    return count;
+  }
+
+  @Test
+  public void messageProducerOnlyProducesRequestedMessages() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener =
+        serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    // Start an RPC.
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation =
+        serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertEquals(methodDescriptor.getFullMethodName(), serverStreamCreation.method);
+
+    // Have the client send two messages.
+    clientStream.writeMessage(methodDescriptor.streamRequest("MESSAGE"));
+    clientStream.writeMessage(methodDescriptor.streamRequest("MESSAGE"));
+    clientStream.flush();
+
+    doPingPong(serverListener);
+
+    // Verify server only receives one message if that's all it requests.
+    serverStreamCreation.stream.request(1);
+    verifyMessageCountAndClose(serverStreamCreation.listener.messageQueue, 1);
+  }
+
+  @Test
+  public void interactionsAfterServerStreamCloseAreNoops() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    // boilerplate
+    ClientStream clientStream =
+        client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation server
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+
+    // setup
+    clientStream.request(1);
+    server.stream.close(Status.INTERNAL, new Metadata());
+    assertNotNull(clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    // Ensure that for a closed ServerStream, interactions are noops
+    server.stream.writeHeaders(new Metadata(), true);
+    server.stream.writeMessage(methodDescriptor.streamResponse("response"));
+    server.stream.close(Status.INTERNAL, new Metadata());
+
+    // Make sure new streams still work properly
+    doPingPong(serverListener);
+  }
+
+  @Test
+  public void interactionsAfterClientStreamCancelAreNoops() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    // boilerplate
+    ClientStream clientStream =
+        client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListener clientListener = mock(ClientStreamListener.class);
+    clientStream.start(clientListener);
+    StreamCreation server
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+
+    // setup
+    server.stream.request(1);
+    clientStream.cancel(Status.UNKNOWN);
+    assertNotNull(server.listener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    // Ensure that for a cancelled ClientStream, interactions are noops
+    clientStream.writeMessage(methodDescriptor.streamRequest("request"));
+    clientStream.halfClose();
+    clientStream.cancel(Status.UNKNOWN);
+
+    // Make sure new streams still work properly
+    doPingPong(serverListener);
+  }
+
+  // Not all transports support the tracer yet
+  protected boolean haveTransportTracer() {
+    return false;
+  }
+
+  @Test
+  public void transportTracer_streamStarted() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    if (!haveTransportTracer()) {
+      return;
+    }
+
+    // start first stream
+    long serverFirstTimestampNanos;
+    long clientFirstTimestampNanos;
+    {
+      TransportStats serverBefore = getTransportStats(serverTransportListener.transport);
+      assertEquals(0, serverBefore.streamsStarted);
+      assertEquals(0, serverBefore.lastRemoteStreamCreatedTimeNanos);
+      TransportStats clientBefore = getTransportStats(client);
+      assertEquals(0, clientBefore.streamsStarted);
+      assertEquals(0, clientBefore.lastRemoteStreamCreatedTimeNanos);
+
+      ClientStream clientStream = client.newStream(
+          methodDescriptor, new Metadata(), callOptions, tracers);
+      ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+      clientStream.start(clientStreamListener);
+      StreamCreation serverStreamCreation = serverTransportListener
+          .takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+
+      TransportStats serverAfter = getTransportStats(serverTransportListener.transport);
+      assertEquals(1, serverAfter.streamsStarted);
+      serverFirstTimestampNanos = serverAfter.lastRemoteStreamCreatedTimeNanos;
+      assertEquals(fakeCurrentTimeNanos(), serverAfter.lastRemoteStreamCreatedTimeNanos);
+
+      TransportStats clientAfter = getTransportStats(client);
+      assertEquals(1, clientAfter.streamsStarted);
+      clientFirstTimestampNanos = clientAfter.lastLocalStreamCreatedTimeNanos;
+      assertEquals(fakeCurrentTimeNanos(), clientFirstTimestampNanos);
+
+      ServerStream serverStream = serverStreamCreation.stream;
+      serverStream.close(Status.OK, new Metadata());
+    }
+
+    final long elapsedMillis = 100;
+    advanceClock(100, TimeUnit.MILLISECONDS);
+
+    // start second stream
+    {
+      TransportStats serverBefore = getTransportStats(serverTransportListener.transport);
+      assertEquals(1, serverBefore.streamsStarted);
+      TransportStats clientBefore = getTransportStats(client);
+      assertEquals(1, clientBefore.streamsStarted);
+
+      ClientStream clientStream = client.newStream(
+          methodDescriptor, new Metadata(), callOptions, noopTracers);
+      ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+      clientStream.start(clientStreamListener);
+      StreamCreation serverStreamCreation = serverTransportListener
+          .takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+
+      TransportStats serverAfter = getTransportStats(serverTransportListener.transport);
+      assertEquals(2, serverAfter.streamsStarted);
+      assertEquals(
+          TimeUnit.MILLISECONDS.toNanos(elapsedMillis),
+          serverAfter.lastRemoteStreamCreatedTimeNanos - serverFirstTimestampNanos);
+      assertEquals(fakeCurrentTimeNanos(), serverAfter.lastRemoteStreamCreatedTimeNanos);
+
+      TransportStats clientAfter = getTransportStats(client);
+      assertEquals(2, clientAfter.streamsStarted);
+      assertEquals(
+          TimeUnit.MILLISECONDS.toNanos(elapsedMillis),
+          clientAfter.lastLocalStreamCreatedTimeNanos - clientFirstTimestampNanos);
+      assertEquals(fakeCurrentTimeNanos(), clientAfter.lastLocalStreamCreatedTimeNanos);
+
+      ServerStream serverStream = serverStreamCreation.stream;
+      serverStream.close(Status.OK, new Metadata());
+    }
+  }
+
+  @Test
+  public void transportTracer_server_streamEnded_ok() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+    if (!haveTransportTracer()) {
+      return;
+    }
+
+    TransportStats serverBefore = getTransportStats(serverTransportListener.transport);
+    assertEquals(0, serverBefore.streamsSucceeded);
+    assertEquals(0, serverBefore.streamsFailed);
+    TransportStats clientBefore = getTransportStats(client);
+    assertEquals(0, clientBefore.streamsSucceeded);
+    assertEquals(0, clientBefore.streamsFailed);
+
+    clientStream.halfClose();
+    serverStream.close(Status.OK, new Metadata());
+    // do not validate stats until close() has been called on client
+    assertNotNull(clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    TransportStats serverAfter = getTransportStats(serverTransportListener.transport);
+    assertEquals(1, serverAfter.streamsSucceeded);
+    assertEquals(0, serverAfter.streamsFailed);
+    TransportStats clientAfter = getTransportStats(client);
+    assertEquals(1, clientAfter.streamsSucceeded);
+    assertEquals(0, clientAfter.streamsFailed);
+  }
+
+  @Test
+  public void transportTracer_server_streamEnded_nonOk() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+    if (!haveTransportTracer()) {
+      return;
+    }
+
+    TransportStats serverBefore = getTransportStats(serverTransportListener.transport);
+    assertEquals(0, serverBefore.streamsFailed);
+    assertEquals(0, serverBefore.streamsSucceeded);
+    TransportStats clientBefore = getTransportStats(client);
+    assertEquals(0, clientBefore.streamsFailed);
+    assertEquals(0, clientBefore.streamsSucceeded);
+
+    serverStream.close(Status.UNKNOWN, new Metadata());
+    // do not validate stats until close() has been called on client
+    assertNotNull(clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    TransportStats serverAfter = getTransportStats(serverTransportListener.transport);
+    assertEquals(1, serverAfter.streamsFailed);
+    assertEquals(0, serverAfter.streamsSucceeded);
+    TransportStats clientAfter = getTransportStats(client);
+    assertEquals(1, clientAfter.streamsFailed);
+    assertEquals(0, clientAfter.streamsSucceeded);
+
+    client.shutdown(Status.UNAVAILABLE);
+  }
+
+  @Test
+  public void transportTracer_client_streamEnded_nonOk() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    MockServerTransportListener serverTransportListener =
+        serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    StreamCreation serverStreamCreation =
+        serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    if (!haveTransportTracer()) {
+      return;
+    }
+
+    TransportStats serverBefore = getTransportStats(serverTransportListener.transport);
+    assertEquals(0, serverBefore.streamsFailed);
+    assertEquals(0, serverBefore.streamsSucceeded);
+    TransportStats clientBefore = getTransportStats(client);
+    assertEquals(0, clientBefore.streamsFailed);
+    assertEquals(0, clientBefore.streamsSucceeded);
+
+    clientStream.cancel(Status.UNKNOWN);
+    // do not validate stats until close() has been called on server
+    assertNotNull(serverStreamCreation.listener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+
+    TransportStats serverAfter = getTransportStats(serverTransportListener.transport);
+    assertEquals(1, serverAfter.streamsFailed);
+    assertEquals(0, serverAfter.streamsSucceeded);
+    TransportStats clientAfter = getTransportStats(client);
+    assertEquals(1, clientAfter.streamsFailed);
+    assertEquals(0, clientAfter.streamsSucceeded);
+  }
+
+  @Test
+  public void transportTracer_server_receive_msg() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+    if (!haveTransportTracer()) {
+      return;
+    }
+
+    TransportStats serverBefore = getTransportStats(serverTransportListener.transport);
+    assertEquals(0, serverBefore.messagesReceived);
+    assertEquals(0, serverBefore.lastMessageReceivedTimeNanos);
+    TransportStats clientBefore = getTransportStats(client);
+    assertEquals(0, clientBefore.messagesSent);
+    assertEquals(0, clientBefore.lastMessageSentTimeNanos);
+
+    serverStream.request(1);
+    clientStream.writeMessage(methodDescriptor.streamRequest("request"));
+    clientStream.flush();
+    clientStream.halfClose();
+    verifyMessageCountAndClose(serverStreamListener.messageQueue, 1);
+
+    TransportStats serverAfter = getTransportStats(serverTransportListener.transport);
+    assertEquals(1, serverAfter.messagesReceived);
+    assertEquals(fakeCurrentTimeNanos(), serverAfter.lastMessageReceivedTimeNanos);
+    TransportStats clientAfter = getTransportStats(client);
+    assertEquals(1, clientAfter.messagesSent);
+    assertEquals(fakeCurrentTimeNanos(), clientAfter.lastMessageSentTimeNanos);
+
+    serverStream.close(Status.OK, new Metadata());
+  }
+
+  @Test
+  public void transportTracer_server_send_msg() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+    if (!haveTransportTracer()) {
+      return;
+    }
+
+    TransportStats serverBefore = getTransportStats(serverTransportListener.transport);
+    assertEquals(0, serverBefore.messagesSent);
+    assertEquals(0, serverBefore.lastMessageSentTimeNanos);
+    TransportStats clientBefore = getTransportStats(client);
+    assertEquals(0, clientBefore.messagesReceived);
+    assertEquals(0, clientBefore.lastMessageReceivedTimeNanos);
+
+    clientStream.request(1);
+    serverStream.writeHeaders(new Metadata(), true);
+    serverStream.writeMessage(methodDescriptor.streamResponse("response"));
+    serverStream.flush();
+    verifyMessageCountAndClose(clientStreamListener.messageQueue, 1);
+
+    TransportStats serverAfter = getTransportStats(serverTransportListener.transport);
+    assertEquals(1, serverAfter.messagesSent);
+    assertEquals(fakeCurrentTimeNanos(), serverAfter.lastMessageSentTimeNanos);
+    TransportStats clientAfter = getTransportStats(client);
+    assertEquals(1, clientAfter.messagesReceived);
+    assertEquals(fakeCurrentTimeNanos(), clientAfter.lastMessageReceivedTimeNanos);
+
+    serverStream.close(Status.OK, new Metadata());
+  }
+
+  @Test
+  public void socketStats() throws Exception {
+    server.start(serverListener);
+    ManagedClientTransport client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+
+    SocketAddress serverAddress = clientStream.getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
+    SocketAddress clientAddress = serverStream.getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
+
+    SocketStats clientSocketStats = client.getStats().get();
+    assertEquals(
+        "clientLocal " + clientStream.getAttributes(), clientAddress, clientSocketStats.local);
+    assertEquals(
+        "clientRemote " + clientStream.getAttributes(), serverAddress, clientSocketStats.remote);
+    // very basic sanity check that socket options are populated
+    assertNotNull(clientSocketStats.socketOptions.lingerSeconds);
+    assertTrue(clientSocketStats.socketOptions.others.containsKey("SO_SNDBUF"));
+
+    SocketStats serverSocketStats = serverTransportListener.transport.getStats().get();
+    assertEquals(
+        "serverLocal " + serverStream.getAttributes(), serverAddress, serverSocketStats.local);
+    assertEquals(
+        "serverRemote " + serverStream.getAttributes(), clientAddress, serverSocketStats.remote);
+    // very basic sanity check that socket options are populated
+    assertNotNull(serverSocketStats.socketOptions.lingerSeconds);
+    assertTrue(serverSocketStats.socketOptions.others.containsKey("SO_SNDBUF"));
+  }
+
+  /** This assumes the server limits metadata size to GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE. */
+  @Test
+  public void serverChecksInboundMetadataSize() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    Metadata tooLargeMetadata = new Metadata();
+    tooLargeMetadata.put(
+        Metadata.Key.of("foo-bin", Metadata.BINARY_BYTE_MARSHALLER),
+        new byte[GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE]);
+
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, tooLargeMetadata, callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+
+    clientStream.writeMessage(methodDescriptor.streamRequest("foo"));
+    clientStream.halfClose();
+    clientStream.request(1);
+    // Server shouldn't have created a stream, so nothing to clean up on server-side
+
+    // If this times out, the server probably isn't noticing the metadata size
+    Status status = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    List<Status.Code> codeOptions = Arrays.asList(
+        Status.Code.UNKNOWN, Status.Code.RESOURCE_EXHAUSTED, Status.Code.INTERNAL);
+    if (!codeOptions.contains(status.getCode())) {
+      fail("Status code was not expected: " + status);
+    }
+  }
+
+  /** This assumes the client limits metadata size to GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE. */
+  @Test
+  public void clientChecksInboundMetadataSize_header() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    Metadata tooLargeMetadata = new Metadata();
+    tooLargeMetadata.put(
+        Metadata.Key.of("foo-bin", Metadata.BINARY_BYTE_MARSHALLER),
+        new byte[GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE]);
+
+    ClientStream clientStream =
+        client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+
+    clientStream.writeMessage(methodDescriptor.streamRequest("foo"));
+    clientStream.halfClose();
+    clientStream.request(1);
+
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+
+    serverStreamCreation.stream.request(1);
+    serverStreamCreation.stream.writeHeaders(tooLargeMetadata, true);
+    serverStreamCreation.stream.writeMessage(methodDescriptor.streamResponse("response"));
+    serverStreamCreation.stream.close(Status.OK, new Metadata());
+
+    Status status = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    List<Status.Code> codeOptions = Arrays.asList(
+        Status.Code.UNKNOWN, Status.Code.RESOURCE_EXHAUSTED, Status.Code.INTERNAL);
+    if (!codeOptions.contains(status.getCode())) {
+      fail("Status code was not expected: " + status);
+    }
+    assertFalse(clientStreamListener.hasHeaders());
+  }
+
+  /** This assumes the client limits metadata size to GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE. */
+  @Test
+  public void clientChecksInboundMetadataSize_trailer() throws Exception {
+    server.start(serverListener);
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    Metadata.Key<String> tellTaleKey
+        = Metadata.Key.of("tell-tale", Metadata.ASCII_STRING_MARSHALLER);
+    Metadata tooLargeMetadata = new Metadata();
+    tooLargeMetadata.put(tellTaleKey, "true");
+    tooLargeMetadata.put(
+        Metadata.Key.of("foo-bin", Metadata.BINARY_BYTE_MARSHALLER),
+        new byte[GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE]);
+
+    ClientStream clientStream =
+        client.newStream(
+        methodDescriptor, new Metadata(), callOptions, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+
+    clientStream.writeMessage(methodDescriptor.streamRequest("foo"));
+    clientStream.halfClose();
+    clientStream.request(1);
+
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+
+    serverStreamCreation.stream.request(1);
+    serverStreamCreation.stream.writeHeaders(new Metadata(), true);
+    serverStreamCreation.stream.writeMessage(methodDescriptor.streamResponse("response"));
+    serverStreamCreation.stream.close(Status.OK, tooLargeMetadata);
+
+    Status status = clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    List<Status.Code> codeOptions = Arrays.asList(
+        Status.Code.UNKNOWN, Status.Code.RESOURCE_EXHAUSTED, Status.Code.INTERNAL);
+    if (!codeOptions.contains(status.getCode())) {
+      fail("Status code was not expected: " + status);
+    }
+    Metadata metadata = clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertNull(metadata.get(tellTaleKey));
+  }
+
+  /**
+   * Helper that simply does an RPC. It can be used similar to a sleep for negative testing: to give
+   * time for actions _not_ to happen. Since it is based on doing an actual RPC with actual
+   * callbacks, it generally provides plenty of time for Runnables to execute. But it is also faster
+   * on faster machines and more reliable on slower machines.
+   */
+  private void doPingPong(MockServerListener serverListener) throws Exception {
+    ManagedClientTransport client = newClientTransport(server);
+    ManagedClientTransport.Listener listener = mock(ManagedClientTransport.Listener.class);
+    startTransport(client, listener);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), callOptions,
+        new ClientStreamTracer[] { new ClientStreamTracer() {} });
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+
+    serverStream.close(Status.OK, new Metadata());
+    assertNotNull(clientStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(clientStreamListener.awaitTrailers(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    assertNotNull(serverStreamListener.awaitClose(TIMEOUT_MS, TimeUnit.MILLISECONDS));
+    client.shutdown(Status.UNAVAILABLE);
+  }
+
+  /**
+   * Only assert that the Status.Code matches, but provide the entire actual result in case the
+   * assertion fails.
+   */
+  private static void assertCodeEquals(String message, Status expected, Status actual) {
+    if (expected == null) {
+      fail("expected should not be null");
+    }
+    if (actual == null || !expected.getCode().equals(actual.getCode())) {
+      assertEquals(message, expected, actual);
+    }
+  }
+
+  private static void assertCodeEquals(Status expected, Status actual) {
+    assertCodeEquals(null, expected, actual);
+  }
+
+  private static void assertStatusEquals(Status expected, Status actual) {
+    if (expected == null) {
+      fail("expected should not be null");
+    }
+    if (actual == null || !expected.getCode().equals(actual.getCode())
+        || !Objects.equal(expected.getDescription(), actual.getDescription())
+        || !Objects.equal(expected.getCause(), actual.getCause())) {
+      assertEquals(expected, actual);
+    }
+  }
+
+  /**
+   * Verifies that the client status is as expected. By default, the code and description should
+   * be present, and the cause should be stripped away.
+   */
+  private static void checkClientStatus(Status expectedStatus, Status clientStreamStatus) {
+    if (!clientStreamStatus.isOk() && clientStreamStatus.getCode() != expectedStatus.getCode()) {
+      System.out.println("Full Status:  " + clientStreamStatus);
+    }
+    assertEquals(expectedStatus.getCode(), clientStreamStatus.getCode());
+    assertEquals(expectedStatus.getDescription(), clientStreamStatus.getDescription());
+    assertNull(clientStreamStatus.getCause());
+  }
+
+  static boolean waitForFuture(Future<?> future, long timeout, TimeUnit unit)
+      throws InterruptedException {
+    try {
+      future.get(timeout, unit);
+    } catch (ExecutionException ex) {
+      throw new AssertionError(ex);
+    } catch (TimeoutException ex) {
+      return false;
+    }
+    return true;
+  }
+
+  protected static void runIfNotNull(Runnable runnable) {
+    if (runnable != null) {
+      runnable.run();
+    }
+  }
+
+  protected static void startTransport(
+      ManagedClientTransport clientTransport,
+      ManagedClientTransport.Listener listener) {
+    runIfNotNull(clientTransport.start(listener));
+    verify(listener, timeout(TIMEOUT_MS)).filterTransport(any());
+    verify(listener, timeout(TIMEOUT_MS)).transportReady();
+  }
+
+  private final class TestHeaderClientStreamTracer extends TestClientStreamTracer {
+    Attributes transportAttrs;
+
+    @Override
+    public void streamCreated(Attributes transportAttrs, Metadata metadata) {
+      this.transportAttrs = transportAttrs;
+      metadata.put(tracerHeaderKey, tracerKeyValue);
+    }
+  }
+
+  private static class StringMarshaller implements MethodDescriptor.Marshaller<String> {
+    public static final StringMarshaller INSTANCE = new StringMarshaller();
+
+    @Override
+    public InputStream stream(String value) {
+      return new ByteArrayInputStream(value.getBytes(UTF_8));
+    }
+
+    @Override
+    public String parse(InputStream stream) {
+      try {
+        return new String(ByteStreams.toByteArray(stream), UTF_8);
+      } catch (IOException ex) {
+        throw new RuntimeException(ex);
+      }
+    }
+  }
+
+  private static class StringBinaryMarshaller implements Metadata.BinaryMarshaller<String> {
+    public static final StringBinaryMarshaller INSTANCE = new StringBinaryMarshaller();
+
+    @Override
+    public byte[] toBytes(String value) {
+      return value.getBytes(UTF_8);
+    }
+
+    @Override
+    public String parseBytes(byte[] serialized) {
+      return new String(serialized, UTF_8);
+    }
+  }
+
+  private static TransportStats getTransportStats(InternalInstrumented<SocketStats> socket)
+      throws ExecutionException, InterruptedException {
+    return socket.getStats().get().data;
+  }
+
+  private static String newString(int size) {
+    StringBuilder sb = new StringBuilder(size);
+    for (int i = 0; i < size; i++) {
+      sb.append('a');
+    }
+    return sb.toString();
+  }
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/ClientStreamListenerBase.java b/core/src/testFixtures/java/io/grpc/internal/ClientStreamListenerBase.java
new file mode 100644
index 00000000000..3c35cf59225
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/ClientStreamListenerBase.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2025 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.internal;
+
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import java.io.InputStream;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+public class ClientStreamListenerBase implements ClientStreamListener {
+  public final BlockingQueue<InputStream> messageQueue = new LinkedBlockingQueue<>();
+  // Would have used Void instead of Object, but null elements are not allowed
+  private final BlockingQueue<Object> readyQueue = new LinkedBlockingQueue<>();
+  private final SettableFuture<Metadata> headers = SettableFuture.create();
+  private final SettableFuture<Metadata> trailers = SettableFuture.create();
+  private final SettableFuture<Status> status = SettableFuture.create();
+
+  /**
+   * Returns the stream's status or throws {@link java.util.concurrent.TimeoutException} if it isn't
+   * closed before the timeout.
+   */
+  public Status awaitClose(int timeout, TimeUnit unit) throws Exception {
+    return status.get(timeout, unit);
+  }
+
+  /**
+   * Return {@code true} if {@code #awaitClose} would return immediately with a status.
+   */
+  public boolean isClosed() {
+    return status.isDone();
+  }
+
+  /**
+   * Returns response headers from the server or throws {@link
+   * java.util.concurrent.TimeoutException} if they aren't delivered before the timeout.
+   *
+   * <p>Callers must not modify the returned object.
+   */
+  public Metadata awaitHeaders(int timeout, TimeUnit unit) throws Exception {
+    return headers.get(timeout, unit);
+  }
+
+  /**
+   * Returns response trailers from the server or throws {@link
+   * java.util.concurrent.TimeoutException} if they aren't delivered before the timeout.
+   *
+   * <p>Callers must not modify the returned object.
+   */
+  public Metadata awaitTrailers(int timeout, TimeUnit unit) throws Exception {
+    return trailers.get(timeout, unit);
+  }
+
+  public boolean awaitOnReady(int timeout, TimeUnit unit) throws Exception {
+    return readyQueue.poll(timeout, unit) != null;
+  }
+
+  public boolean awaitOnReadyAndDrain(int timeout, TimeUnit unit) throws Exception {
+    if (!awaitOnReady(timeout, unit)) {
+      return false;
+    }
+    // Throw the rest away
+    readyQueue.drainTo(Lists.newArrayList());
+    return true;
+  }
+
+  @Override
+  public void messagesAvailable(MessageProducer producer) {
+    if (status.isDone()) {
+      fail("messagesAvailable invoked after closed");
+    }
+    InputStream message;
+    while ((message = producer.next()) != null) {
+      messageQueue.add(message);
+    }
+  }
+
+  @Override
+  public void onReady() {
+    if (status.isDone()) {
+      fail("onReady invoked after closed");
+    }
+    readyQueue.add(new Object());
+  }
+
+  @Override
+  public void headersRead(Metadata headers) {
+    if (status.isDone()) {
+      fail("headersRead invoked after closed");
+    }
+    this.headers.set(headers);
+  }
+
+  @Override
+  public void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {
+    if (this.status.isDone()) {
+      fail("headersRead invoked after closed");
+    }
+    this.status.set(status);
+    this.trailers.set(trailers);
+  }
+
+  /** Returns true iff response headers have been received from the server. */
+  public boolean hasHeaders() {
+    return headers.isDone();
+  }
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/FakeClock.java b/core/src/testFixtures/java/io/grpc/internal/FakeClock.java
new file mode 100644
index 00000000000..1a3584f4e2c
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/FakeClock.java
@@ -0,0 +1,421 @@
+/*
+ * Copyright 2015 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.internal;
+
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.base.Ticker;
+import com.google.common.util.concurrent.AbstractFuture;
+import io.grpc.Deadline;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Delayed;
+import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.PriorityBlockingQueue;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A manipulated clock that exports a {@link Ticker} and a {@link ScheduledExecutorService}.
+ *
+ * <p>To simulate the locking scenario of using real executors, it never runs tasks within {@code
+ * schedule()} or {@code execute()}. Instead, you should call {@link #runDueTasks} in your test
+ * method to run all due tasks. {@link #forwardTime} and {@link #forwardNanos} call {@link
+ * #runDueTasks} automatically.
+ */
+public final class FakeClock {
+
+  private static final TaskFilter ACCEPT_ALL_FILTER = new TaskFilter() {
+      @Override
+      public boolean shouldAccept(Runnable command) {
+        return true;
+      }
+    };
+
+  private final ScheduledExecutorService scheduledExecutorService = new ScheduledExecutorImpl();
+
+  private final PriorityBlockingQueue<ScheduledTask> scheduledTasks = new PriorityBlockingQueue<>();
+  private final LinkedBlockingQueue<ScheduledTask> dueTasks = new LinkedBlockingQueue<>();
+
+  private final Ticker ticker =
+      new Ticker() {
+        @Override public long read() {
+          return currentTimeNanos;
+        }
+      };
+
+  private final Deadline.Ticker deadlineTicker =
+      new Deadline.Ticker() {
+        @Override public long nanoTime() {
+          return currentTimeNanos;
+        }
+      };
+
+  private final Supplier<Stopwatch> stopwatchSupplier =
+      new Supplier<Stopwatch>() {
+        @Override public Stopwatch get() {
+          return Stopwatch.createUnstarted(ticker);
+        }
+      };
+
+  private final TimeProvider timeProvider =
+      new TimeProvider() {
+        @Override
+        public long currentTimeNanos() {
+          return currentTimeNanos;
+        }
+      };
+
+  private long currentTimeNanos;
+
+  public class ScheduledTask extends AbstractFuture<Void> implements ScheduledFuture<Void> {
+    public final Runnable command;
+    public long dueTimeNanos;
+
+    ScheduledTask(Runnable command) {
+      this.command = command;
+    }
+
+    void run() {
+      command.run();
+      set(null);
+    }
+
+    void setDueTimeNanos(long dueTimeNanos) {
+      this.dueTimeNanos = dueTimeNanos;
+    }
+
+    @Override public boolean cancel(boolean mayInterruptIfRunning) {
+      scheduledTasks.remove(this);
+      dueTasks.remove(this);
+      return super.cancel(mayInterruptIfRunning);
+    }
+
+    @Override public long getDelay(TimeUnit unit) {
+      return unit.convert(dueTimeNanos - currentTimeNanos, TimeUnit.NANOSECONDS);
+    }
+
+    @Override public int compareTo(Delayed other) {
+      ScheduledTask otherTask = (ScheduledTask) other;
+      if (dueTimeNanos > otherTask.dueTimeNanos) {
+        return 1;
+      } else if (dueTimeNanos < otherTask.dueTimeNanos) {
+        return -1;
+      } else {
+        return 0;
+      }
+    }
+
+    @Override
+    public String toString() {
+      return "[due=" + dueTimeNanos + ", task=" + command + "]";
+    }
+  }
+
+  private class ScheduledExecutorImpl implements ScheduledExecutorService {
+    @Override public <V> ScheduledFuture<V> schedule(
+        Callable<V> callable, long delay, TimeUnit unit) {
+      throw new UnsupportedOperationException();
+    }
+
+    private void schedule(ScheduledTask task, long delay, TimeUnit unit) {
+      task.setDueTimeNanos(currentTimeNanos + unit.toNanos(delay));
+      if (delay > 0) {
+        scheduledTasks.add(task);
+      } else {
+        dueTasks.add(task);
+      }
+    }
+
+    @Override public ScheduledFuture<?> schedule(Runnable cmd, long delay, TimeUnit unit) {
+      ScheduledTask task = new ScheduledTask(cmd);
+      schedule(task, delay, unit);
+      return task;
+    }
+
+    @Override public ScheduledFuture<?> scheduleAtFixedRate(
+        Runnable cmd, long initialDelay, long period, TimeUnit unit) {
+      ScheduledTask task = new ScheduleAtFixedRateTask(cmd, period, unit);
+      schedule(task, initialDelay, unit);
+      return task;
+    }
+
+    @Override public ScheduledFuture<?> scheduleWithFixedDelay(
+        Runnable cmd, long initialDelay, long delay, TimeUnit unit) {
+      ScheduledTask task = new ScheduleWithFixedDelayTask(cmd, delay, unit);
+      schedule(task, initialDelay, unit);
+      return task;
+    }
+
+    @Override public boolean awaitTermination(long timeout, TimeUnit unit) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override public <T> List<Future<T>> invokeAll(
+        Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override public <T> T invokeAny(Collection<? extends Callable<T>> tasks) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override public <T> T invokeAny(
+        Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override public boolean isShutdown() {
+      // If shutdown is not implemented, then it is never shutdown.
+      return false;
+    }
+
+    @Override public boolean isTerminated() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override public void shutdown() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override public List<Runnable> shutdownNow() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override public <T> Future<T> submit(Callable<T> task) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override public Future<?> submit(Runnable task) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override public <T> Future<T> submit(Runnable task, T result) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override public void execute(Runnable command) {
+      // Since it is being enqueued immediately, no point in tracing the future for cancellation.
+      Future<?> unused = schedule(command, 0, TimeUnit.NANOSECONDS);
+    }
+
+    class ScheduleAtFixedRateTask extends ScheduledTask {
+      final long periodNanos;
+
+      public ScheduleAtFixedRateTask(Runnable command, long period, TimeUnit unit) {
+        super(command);
+        this.periodNanos = unit.toNanos(period);
+      }
+
+      @Override void run() {
+        long startTimeNanos = currentTimeNanos;
+        command.run();
+        if (!isCancelled()) {
+          schedule(this, startTimeNanos + periodNanos - currentTimeNanos, TimeUnit.NANOSECONDS);
+        }
+      }
+    }
+
+    class ScheduleWithFixedDelayTask extends ScheduledTask {
+
+      final long delayNanos;
+
+      ScheduleWithFixedDelayTask(Runnable command, long delay, TimeUnit unit) {
+        super(command);
+        this.delayNanos = unit.toNanos(delay);
+      }
+
+      @Override
+      void run() {
+        command.run();
+        if (!isCancelled()) {
+          schedule(this, delayNanos, TimeUnit.NANOSECONDS);
+        }
+      }
+    }
+  }
+
+  /**
+   * Provides a partially implemented instance of {@link ScheduledExecutorService} that uses the
+   * fake clock ticker for testing.
+   */
+  public ScheduledExecutorService getScheduledExecutorService() {
+    return scheduledExecutorService;
+  }
+
+  /**
+   * Provides a {@link TimeProvider} that is backed by this FakeClock.
+   */
+  public TimeProvider getTimeProvider() {
+    return timeProvider;
+  }
+
+  /**
+   * Provides a stopwatch instance that uses the fake clock ticker.
+   */
+  public Supplier<Stopwatch> getStopwatchSupplier() {
+    return stopwatchSupplier;
+  }
+
+  /**
+   * Ticker of the FakeClock.
+   */
+  public Ticker getTicker() {
+    return ticker;
+  }
+
+  /**
+   * Deadline ticker of the FakeClock.
+   */
+  public Deadline.Ticker getDeadlineTicker() {
+    return deadlineTicker;
+  }
+
+  /**
+   * Run all due tasks. Immediately due tasks that are queued during the process also get executed.
+   *
+   * @return the number of tasks run by this call
+   */
+  public int runDueTasks() {
+    int count = 0;
+    while (true) {
+      checkDueTasks();
+      if (dueTasks.isEmpty()) {
+        break;
+      }
+      ScheduledTask task;
+      while ((task = dueTasks.poll()) != null) {
+        task.run();
+        count++;
+      }
+    }
+    return count;
+  }
+
+  private void checkDueTasks() {
+    while (true) {
+      ScheduledTask task = scheduledTasks.peek();
+      if (task == null || task.dueTimeNanos > currentTimeNanos) {
+        break;
+      }
+      if (scheduledTasks.remove(task)) {
+        dueTasks.add(task);
+      }
+    }
+  }
+
+  /**
+   * Return all due tasks.
+   */
+  public Collection<ScheduledTask> getDueTasks() {
+    checkDueTasks();
+    return new ArrayList<>(dueTasks);
+  }
+
+  /**
+   * Return all unrun tasks.
+   */
+  public Collection<ScheduledTask> getPendingTasks() {
+    return getPendingTasks(ACCEPT_ALL_FILTER);
+  }
+
+  /**
+   * Return all unrun tasks accepted by the given filter.
+   */
+  public Collection<ScheduledTask> getPendingTasks(TaskFilter filter) {
+    ArrayList<ScheduledTask> result = new ArrayList<>();
+    for (ScheduledTask task : dueTasks) {
+      if (filter.shouldAccept(task.command)) {
+        result.add(task);
+      }
+    }
+    for (ScheduledTask task : scheduledTasks) {
+      if (filter.shouldAccept(task.command)) {
+        result.add(task);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Forward the time by the given duration and run all due tasks.
+   *
+   * @return the number of tasks run by this call
+   */
+  public int forwardTime(long value, TimeUnit unit) {
+    currentTimeNanos += unit.toNanos(value);
+    return runDueTasks();
+  }
+
+  /**
+   * Forward the time by the given nanoseconds and run all due tasks.
+   *
+   * @return the number of tasks run by this call
+   */
+  public int forwardNanos(long nanos) {
+    return forwardTime(nanos, TimeUnit.NANOSECONDS);
+  }
+
+  /**
+   * Return the number of queued tasks.
+   */
+  public int numPendingTasks() {
+    return dueTasks.size() + scheduledTasks.size();
+  }
+
+  /**
+   * Return the number of queued tasks accepted by the given filter.
+   */
+  public int numPendingTasks(TaskFilter filter) {
+    int count = 0;
+    for (ScheduledTask task : dueTasks) {
+      if (filter.shouldAccept(task.command)) {
+        count++;
+      }
+    }
+    for (ScheduledTask task : scheduledTasks) {
+      if (filter.shouldAccept(task.command)) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  public long currentTimeMillis() {
+    // Normally millis and nanos are of different epochs. Add an offset to simulate that.
+    return TimeUnit.NANOSECONDS.toMillis(currentTimeNanos + 1234567890123456789L);
+  }
+
+  /**
+   * A filter that allows us to have fine grained control over which tasks are accepted for certain
+   * operation.
+   */
+  public interface TaskFilter {
+    /**
+     * Inspect the Runnable and returns true if it should be accepted.
+     */
+    boolean shouldAccept(Runnable runnable);
+  }
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/FlagResetRule.java b/core/src/testFixtures/java/io/grpc/internal/FlagResetRule.java
new file mode 100644
index 00000000000..96125cd0c8a
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/FlagResetRule.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2026 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.internal;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import javax.annotation.Nullable;
+import org.junit.rules.ExternalResource;
+
+/**
+ * A {@link org.junit.rules.TestRule} that lets you set one or more feature flags just for
+ * the duration of the current test case.
+ *
+ * <p>Flags and other global variables must be reset to ensure no state leaks across tests.
+ */
+public final class FlagResetRule extends ExternalResource {
+
+  /** A functional interface representing a standard gRPC feature flag setter. */
+  public interface SetterMethod<T> {
+    /** Sets a flag for testing and returns its previous value. */
+    T set(T val);
+  }
+
+  private final Deque<Runnable> toRunAfter = new ArrayDeque<>();
+
+  /**
+   * Sets a global feature flag to 'value' using 'setter' and arranges for its previous value to be
+   * unconditionally restored when the test completes.
+   */
+  public <T> void setFlagForTest(SetterMethod<T> setter, T value) {
+    final T oldValue = setter.set(value);
+    toRunAfter.push(() -> setter.set(oldValue));
+  }
+
+  /**
+   * Sets java system property 'key' to 'value' and arranges for its previous value to be
+   * unconditionally restored when the test completes.
+   */
+  public void setSystemPropertyForTest(String key, String value) {
+    String oldValue = System.setProperty(key, value);
+    restoreSystemPropertyAfterTest(key, oldValue);
+  }
+
+  /**
+   * Clears java system property 'key' and arranges for its previous value to be unconditionally
+   * restored when the test completes.
+   */
+  public void clearSystemPropertyForTest(String key) {
+    String oldValue = System.clearProperty(key);
+    restoreSystemPropertyAfterTest(key, oldValue);
+  }
+
+  private void restoreSystemPropertyAfterTest(String key, @Nullable String oldValue) {
+    toRunAfter.push(
+        () -> {
+          if (oldValue == null) {
+            System.clearProperty(key);
+          } else {
+            System.setProperty(key, oldValue);
+          }
+        });
+  }
+
+  @Override
+  protected void after() {
+    RuntimeException toThrow = null;
+    while (!toRunAfter.isEmpty()) {
+      try {
+        toRunAfter.pop().run();
+      } catch (RuntimeException e) {
+        if (toThrow == null) {
+          toThrow = e;
+        } else {
+          toThrow.addSuppressed(e);
+        }
+      }
+    }
+    if (toThrow != null) {
+      throw toThrow;
+    }
+  }
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/MockServerListener.java b/core/src/testFixtures/java/io/grpc/internal/MockServerListener.java
new file mode 100644
index 00000000000..0c33b98cf1c
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/MockServerListener.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2025 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.internal;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.util.concurrent.SettableFuture;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A {@link ServerListener} that helps you write blocking unit tests.
+ *
+ * <p>TODO: Rename, since this is not actually a mock:
+ * https://testing.googleblog.com/2013/07/testing-on-toilet-know-your-test-doubles.html
+ */
+public class MockServerListener implements ServerListener {
+  private final BlockingQueue<MockServerTransportListener> listeners = new LinkedBlockingQueue<>();
+  private final SettableFuture<?> shutdown = SettableFuture.create();
+  private final ServerTransportListenerFactory serverTransportListenerFactory;
+
+  /**
+   * Lets you customize the {@link MockServerTransportListener} installed on newly created
+   * {@link ServerTransport}s.
+   */
+  public interface ServerTransportListenerFactory {
+    MockServerTransportListener create(ServerTransport transport);
+  }
+
+  public MockServerListener(ServerTransportListenerFactory serverTransportListenerFactory) {
+    this.serverTransportListenerFactory = serverTransportListenerFactory;
+  }
+
+  public MockServerListener() {
+    this(MockServerTransportListener::new);
+  }
+
+  @Override
+  public ServerTransportListener transportCreated(ServerTransport transport) {
+    MockServerTransportListener listener = serverTransportListenerFactory.create(transport);
+    listeners.add(listener);
+    return listener;
+  }
+
+  @Override
+  public void serverShutdown() {
+    assertTrue(shutdown.set(null));
+  }
+
+  public boolean waitForShutdown(long timeout, TimeUnit unit) throws InterruptedException {
+    return AbstractTransportTest.waitForFuture(shutdown, timeout, unit);
+  }
+
+  public MockServerTransportListener takeListenerOrFail(long timeout, TimeUnit unit)
+      throws InterruptedException {
+    MockServerTransportListener listener = listeners.poll(timeout, unit);
+    if (listener == null) {
+      fail("Timed out waiting for server transport");
+    }
+    return listener;
+  }
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/MockServerTransportListener.java b/core/src/testFixtures/java/io/grpc/internal/MockServerTransportListener.java
new file mode 100644
index 00000000000..e6c4e2f578e
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/MockServerTransportListener.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2025 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.internal;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.Attributes;
+import io.grpc.Metadata;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A {@link ServerTransportListener} that helps you write blocking unit tests.
+ *
+ * <p>TODO: Rename, since this is not actually a mock:
+ * https://testing.googleblog.com/2013/07/testing-on-toilet-know-your-test-doubles.html
+ */
+public class MockServerTransportListener implements ServerTransportListener {
+  public final ServerTransport transport;
+  private final BlockingQueue<StreamCreation> streams = new LinkedBlockingQueue<>();
+  private final SettableFuture<?> terminated = SettableFuture.create();
+
+  public MockServerTransportListener(ServerTransport transport) {
+    this.transport = transport;
+  }
+
+  @Override
+  public void streamCreated(ServerStream stream, String method, Metadata headers) {
+    ServerStreamListenerBase listener = new ServerStreamListenerBase();
+    streams.add(new StreamCreation(stream, method, headers, listener));
+    stream.setListener(listener);
+  }
+
+  @Override
+  public Attributes transportReady(Attributes attributes) {
+    assertFalse(terminated.isDone());
+    return attributes;
+  }
+
+  @Override
+  public void transportTerminated() {
+    assertTrue(terminated.set(null));
+  }
+
+  public boolean waitForTermination(long timeout, TimeUnit unit) throws InterruptedException {
+    return AbstractTransportTest.waitForFuture(terminated, timeout, unit);
+  }
+
+  public boolean isTerminated() {
+    return terminated.isDone();
+  }
+
+  public StreamCreation takeStreamOrFail(long timeout, TimeUnit unit) throws InterruptedException {
+    StreamCreation stream = streams.poll(timeout, unit);
+    if (stream == null) {
+      fail("Timed out waiting for server stream");
+    }
+    return stream;
+  }
+
+  public static class StreamCreation {
+    public final ServerStream stream;
+    public final String method;
+    public final Metadata headers;
+    public final ServerStreamListenerBase listener;
+
+    public StreamCreation(
+        ServerStream stream, String method, Metadata headers, ServerStreamListenerBase listener) {
+      this.stream = stream;
+      this.method = method;
+      this.headers = headers;
+      this.listener = listener;
+    }
+  }
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/NoopClientStreamListener.java b/core/src/testFixtures/java/io/grpc/internal/NoopClientStreamListener.java
new file mode 100644
index 00000000000..5cd4f4f00d0
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/NoopClientStreamListener.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2015 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.internal;
+
+import io.grpc.Metadata;
+import io.grpc.Status;
+
+/**
+ * No-op base class for testing.
+ */
+public class NoopClientStreamListener implements ClientStreamListener {
+  @Override
+  public void messagesAvailable(MessageProducer producer) {}
+
+  @Override
+  public void onReady() {}
+
+  @Override
+  public void headersRead(Metadata headers) {}
+
+  @Override
+  public void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {}
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/PickFirstLoadBalancerProviderAccessor.java b/core/src/testFixtures/java/io/grpc/internal/PickFirstLoadBalancerProviderAccessor.java
new file mode 100644
index 00000000000..a6e94df03c2
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/PickFirstLoadBalancerProviderAccessor.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2024 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.internal;
+
+/**
+ * Accessor for PickFirstLoadBalancerProvider, allowing access only during tests.
+ */
+public final class PickFirstLoadBalancerProviderAccessor {
+  private PickFirstLoadBalancerProviderAccessor() {}
+
+  public static void setEnableNewPickFirst(boolean enableNewPickFirst) {
+    PickFirstLoadBalancerProvider.enableNewPickFirst = enableNewPickFirst;
+  }
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/ReadableBufferTestBase.java b/core/src/testFixtures/java/io/grpc/internal/ReadableBufferTestBase.java
new file mode 100644
index 00000000000..2262f0466f7
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/ReadableBufferTestBase.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2014 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.internal;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import java.io.ByteArrayOutputStream;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Abstract base class for tests of {@link ReadableBuffer} subclasses.
+ */
+@RunWith(JUnit4.class)
+public abstract class ReadableBufferTestBase {
+  // Use a long string to ensure that any chunking/splitting works correctly.
+  protected static final String msg = repeatUntilLength("hello", 8 * 1024);
+
+  @Test
+  public void bufferShouldReadAllBytes() {
+    ReadableBuffer buffer = buffer();
+    for (int ix = 0; ix < msg.length(); ++ix) {
+      assertEquals(msg.length() - ix, buffer.readableBytes());
+      assertEquals(msg.charAt(ix), buffer.readUnsignedByte());
+    }
+    assertEquals(0, buffer.readableBytes());
+  }
+
+  @Test
+  public void readToArrayShouldSucceed() {
+    ReadableBuffer buffer = buffer();
+    byte[] array = new byte[msg.length()];
+    buffer.readBytes(array, 0, array.length);
+    assertArrayEquals(msg.getBytes(UTF_8), array);
+    assertEquals(0, buffer.readableBytes());
+  }
+
+  @Test
+  public void partialReadToArrayShouldSucceed() {
+    ReadableBuffer buffer = buffer();
+    byte[] array = new byte[msg.length()];
+    buffer.readBytes(array, 1, 2);
+    assertArrayEquals(new byte[] {'h', 'e'}, Arrays.copyOfRange(array, 1, 3));
+    assertEquals(msg.length() - 2, buffer.readableBytes());
+  }
+
+  @Test
+  public void readToStreamShouldSucceed() throws Exception {
+    ReadableBuffer buffer = buffer();
+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
+    buffer.readBytes(stream, msg.length());
+    assertArrayEquals(msg.getBytes(UTF_8), stream.toByteArray());
+    assertEquals(0, buffer.readableBytes());
+  }
+
+  @Test
+  public void partialReadToStreamShouldSucceed() throws Exception {
+    ReadableBuffer buffer = buffer();
+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
+    buffer.readBytes(stream, 2);
+    assertArrayEquals(new byte[]{'h', 'e'}, Arrays.copyOfRange(stream.toByteArray(), 0, 2));
+    assertEquals(msg.length() - 2, buffer.readableBytes());
+  }
+
+  @Test
+  public void partialReadToReadableBufferShouldSucceed() {
+    ReadableBuffer buffer = buffer();
+    ReadableBuffer newBuffer = buffer.readBytes(2);
+    assertEquals(2, newBuffer.readableBytes());
+    assertEquals(msg.length() - 2, buffer.readableBytes());
+    byte[] array = new byte[2];
+    newBuffer.readBytes(array, 0, 2);
+    assertArrayEquals(new byte[] {'h', 'e'}, Arrays.copyOfRange(array, 0, 2));     
+  }
+
+  @Test
+  public void markAndResetWithReadShouldSucceed() {
+    ReadableBuffer buffer = buffer();
+    int offset = 5;
+    buffer.readBytes(new byte[offset], 0, offset);
+    buffer.mark();
+    int b = buffer.readUnsignedByte();
+    assertEquals(msg.length() - offset - 1, buffer.readableBytes());
+    buffer.reset();
+    assertEquals(msg.length() - offset, buffer.readableBytes());
+    assertEquals(b, buffer.readUnsignedByte());
+  }
+
+  @Test
+  public void markAndResetWithReadToReadableBufferShouldSucceed() {
+    ReadableBuffer buffer = buffer();
+    int offset = 5;
+    buffer.readBytes(offset);
+    int testLen = 100;
+    buffer.mark();
+    ReadableBuffer first = buffer.readBytes(testLen);
+    assertEquals(msg.length() - offset - testLen, buffer.readableBytes());
+    buffer.reset();
+    assertEquals(msg.length() - offset, buffer.readableBytes());
+    ReadableBuffer second = buffer.readBytes(testLen);
+    byte[] array1 = new byte[testLen];
+    byte[] array2 = new byte[testLen];
+    first.readBytes(array1, 0, testLen);
+    second.readBytes(array2, 0, testLen);
+    assertArrayEquals(array1, array2);
+  }
+
+  @Test
+  public void getByteBufferDoesNotAffectBufferPosition() {
+    ReadableBuffer buffer = buffer();
+    Assume.assumeTrue(buffer.byteBufferSupported());
+    ByteBuffer byteBuffer = buffer.getByteBuffer();
+    assertEquals(msg.length(), buffer.readableBytes());
+    byteBuffer.get(new byte[byteBuffer.remaining()]);
+    assertEquals(msg.length(), buffer.readableBytes());
+  }
+
+  @Test
+  public void getByteBufferIsNotAffectedByBufferRead() {
+    ReadableBuffer buffer = buffer();
+    Assume.assumeTrue(buffer.byteBufferSupported());
+    ByteBuffer byteBuffer = buffer.getByteBuffer();
+    int initialRemaining = byteBuffer.remaining();
+    buffer.readBytes(new byte[100], 0, 100);
+    assertEquals(initialRemaining, byteBuffer.remaining());
+  }
+
+  protected abstract ReadableBuffer buffer();
+
+  private static String repeatUntilLength(String toRepeat, int length) {
+    StringBuilder buf = new StringBuilder();
+    while (buf.length() < length) {
+      buf.append(toRepeat);
+    }
+    buf.setLength(length);
+    return buf.toString();
+  }
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/ServerStreamListenerBase.java b/core/src/testFixtures/java/io/grpc/internal/ServerStreamListenerBase.java
new file mode 100644
index 00000000000..aaa70600542
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/ServerStreamListenerBase.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2025 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.internal;
+
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.Status;
+import java.io.InputStream;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A {@link ServerStreamListener} that helps you write blocking unit tests.
+ */
+public class ServerStreamListenerBase implements ServerStreamListener {
+  public final BlockingQueue<InputStream> messageQueue = new LinkedBlockingQueue<>();
+  // Would have used Void instead of Object, but null elements are not allowed
+  private final BlockingQueue<Object> readyQueue = new LinkedBlockingQueue<>();
+  private final CountDownLatch halfClosedLatch = new CountDownLatch(1);
+  private final SettableFuture<Status> status = SettableFuture.create();
+
+  public boolean awaitOnReady(int timeout, TimeUnit unit) throws Exception {
+    return readyQueue.poll(timeout, unit) != null;
+  }
+
+  public boolean awaitOnReadyAndDrain(int timeout, TimeUnit unit) throws Exception {
+    if (!awaitOnReady(timeout, unit)) {
+      return false;
+    }
+    // Throw the rest away
+    readyQueue.drainTo(Lists.newArrayList());
+    return true;
+  }
+
+  public boolean awaitHalfClosed(int timeout, TimeUnit unit) throws Exception {
+    return halfClosedLatch.await(timeout, unit);
+  }
+
+  public boolean isHalfClosed() {
+    return halfClosedLatch.getCount() == 0;
+  }
+
+  public Status awaitClose(int timeout, TimeUnit unit) throws Exception {
+    return status.get(timeout, unit);
+  }
+
+  @Override
+  public void messagesAvailable(MessageProducer producer) {
+    if (status.isDone()) {
+      fail("messagesAvailable invoked after closed");
+    }
+    InputStream message;
+    while ((message = producer.next()) != null) {
+      messageQueue.add(message);
+    }
+  }
+
+  @Override
+  public void onReady() {
+    if (status.isDone()) {
+      fail("onReady invoked after closed");
+    }
+    readyQueue.add(new Object());
+  }
+
+  @Override
+  public void halfClosed() {
+    if (status.isDone()) {
+      fail("halfClosed invoked after closed");
+    }
+    halfClosedLatch.countDown();
+  }
+
+  @Override
+  public void closed(Status status) {
+    if (this.status.isDone()) {
+      fail("closed invoked more than once");
+    }
+    this.status.set(status);
+  }
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/SingleMessageProducer.java b/core/src/testFixtures/java/io/grpc/internal/SingleMessageProducer.java
new file mode 100644
index 00000000000..8f89ed103ae
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/SingleMessageProducer.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2017 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.internal;
+
+import java.io.InputStream;
+import javax.annotation.Nullable;
+
+public class SingleMessageProducer implements StreamListener.MessageProducer {
+  private InputStream message;
+
+  public SingleMessageProducer(InputStream message) {
+    this.message = message;
+  }
+
+  @Nullable
+  @Override
+  public InputStream next() {
+    InputStream messageToReturn = message;
+    message = null;
+    return messageToReturn;
+  }
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/TestUtils.java b/core/src/testFixtures/java/io/grpc/internal/TestUtils.java
new file mode 100644
index 00000000000..e5aab81c1bb
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/TestUtils.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright 2015 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.internal;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ChannelLogger;
+import io.grpc.ClientStreamTracer;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.InternalLogId;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import java.net.SocketAddress;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import javax.annotation.Nullable;
+import org.mockito.ArgumentMatchers;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+/**
+ * Common utility methods for tests.
+ */
+public final class TestUtils {
+
+  /** Base class for a standard LoadBalancerProvider implementation. */
+  public abstract static class StandardLoadBalancerProvider extends LoadBalancerProvider {
+    private final String policyName;
+
+    protected StandardLoadBalancerProvider(String policyName) {
+      this.policyName = policyName;
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 5;
+    }
+
+    @Override
+    public final String getPolicyName() {
+      return policyName;
+    }
+  }
+
+  /** Creates a {@link SubchannelPicker} that returns the given {@link Subchannel} on every pick. */
+  public static SubchannelPicker pickerOf(final Subchannel subchannel) {
+    return new SubchannelPicker() {
+      @Override
+      public PickResult pickSubchannel(PickSubchannelArgs args) {
+        return PickResult.withSubchannel(subchannel);
+      }
+    };
+  }
+
+  static class MockClientTransportInfo {
+    /**
+     * A mock transport created by the mock transport factory.
+     */
+    final ConnectionClientTransport transport;
+
+    /**
+     * The listener passed to the start() of the mock transport.
+     */
+    final ManagedClientTransport.Listener listener;
+
+    MockClientTransportInfo(ConnectionClientTransport transport,
+        ManagedClientTransport.Listener listener) {
+      this.transport = transport;
+      this.listener = listener;
+    }
+  }
+
+  /**
+   * Stub the given mock {@link ClientTransportFactory} by returning mock
+   * {@link ManagedClientTransport}s which saves their listeners along with them. This method
+   * returns a list of {@link MockClientTransportInfo}, each of which is a started mock transport
+   * and its listener.
+   */
+  static BlockingQueue<MockClientTransportInfo> captureTransports(
+      ClientTransportFactory mockTransportFactory) {
+    return captureTransports(mockTransportFactory, null);
+  }
+
+  static BlockingQueue<MockClientTransportInfo> captureTransports(
+      ClientTransportFactory mockTransportFactory, @Nullable final Runnable startRunnable) {
+    final BlockingQueue<MockClientTransportInfo> captor =
+        new LinkedBlockingQueue<>();
+
+    doAnswer(new Answer<ConnectionClientTransport>() {
+      @Override
+      public ConnectionClientTransport answer(InvocationOnMock invocation) throws Throwable {
+        final ConnectionClientTransport mockTransport = mock(ConnectionClientTransport.class);
+        when(mockTransport.getLogId())
+            .thenReturn(InternalLogId.allocate("mocktransport", /*details=*/ null));
+        when(mockTransport.newStream(
+                any(MethodDescriptor.class), any(Metadata.class), any(CallOptions.class),
+                ArgumentMatchers.<ClientStreamTracer[]>any()))
+            .thenReturn(mock(ClientStream.class));
+        // Save the listener
+        doAnswer(new Answer<Runnable>() {
+          @Override
+          public Runnable answer(InvocationOnMock invocation) throws Throwable {
+            captor.add(new MockClientTransportInfo(
+                mockTransport, (ManagedClientTransport.Listener) invocation.getArguments()[0]));
+            return startRunnable;
+          }
+        }).when(mockTransport).start(any(ManagedClientTransport.Listener.class));
+        return mockTransport;
+      }
+    }).when(mockTransportFactory)
+        .newClientTransport(
+            any(SocketAddress.class),
+            any(ClientTransportFactory.ClientTransportOptions.class),
+            any(ChannelLogger.class));
+
+    return captor;
+  }
+
+  @SuppressWarnings("ReferenceEquality")
+  public static EquivalentAddressGroup stripAttrs(EquivalentAddressGroup eag) {
+    if (eag.getAttributes() == Attributes.EMPTY) {
+      return eag;
+    }
+    return new EquivalentAddressGroup(eag.getAddresses());
+  }
+
+  private TestUtils() {
+  }
+
+  public static class NoopChannelLogger extends ChannelLogger {
+
+    @Override
+    public void log(ChannelLogLevel level, String message) {}
+
+    @Override
+    public void log(ChannelLogLevel level, String messageFormat, Object... args) {}
+  }
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/WritableBufferAllocatorTestBase.java b/core/src/testFixtures/java/io/grpc/internal/WritableBufferAllocatorTestBase.java
new file mode 100644
index 00000000000..f7aff08985f
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/WritableBufferAllocatorTestBase.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2015 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.internal;
+
+import static org.junit.Assert.assertNotSame;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Abstract base class for tests of {@link WritableBufferAllocator} subclasses.
+ */
+@RunWith(JUnit4.class)
+public abstract class WritableBufferAllocatorTestBase {
+
+  protected abstract WritableBufferAllocator allocator();
+
+  @Test
+  public void testBuffersAreDifferent() {
+    WritableBuffer buffer1 = allocator().allocate(100);
+    WritableBuffer buffer2 = allocator().allocate(100);
+
+    assertNotSame(buffer1, buffer2);
+
+    buffer1.release();
+    buffer2.release();
+  }
+}
diff --git a/core/src/testFixtures/java/io/grpc/internal/WritableBufferTestBase.java b/core/src/testFixtures/java/io/grpc/internal/WritableBufferTestBase.java
new file mode 100644
index 00000000000..0245359597f
--- /dev/null
+++ b/core/src/testFixtures/java/io/grpc/internal/WritableBufferTestBase.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright 2015 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.internal;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Abstract base class for tests of {@link WritableBuffer} subclasses.
+ */
+@RunWith(JUnit4.class)
+public abstract class WritableBufferTestBase {
+
+  /**
+   * Returns a new buffer for every test case with
+   * at least 100 byte of capacity.
+   */
+  protected abstract WritableBuffer buffer();
+
+  /**
+   * Bytes written to {@link #buffer()}.
+   */
+  protected abstract byte[] writtenBytes();
+
+  @Test(expected = RuntimeException.class)
+  public void testWriteNegativeLength() {
+    buffer().write(new byte[1], 0, -1);
+  }
+
+  @Test(expected = IndexOutOfBoundsException.class)
+  public void testWriteNegativeSrcIndex() {
+    buffer().write(new byte[1], -1, 0);
+  }
+
+  @Test(expected = IndexOutOfBoundsException.class)
+  public void testWriteSrcIndexAndLengthExceedSrcLength() {
+    buffer().write(new byte[10], 1, 10);
+  }
+
+  @Test(expected = IndexOutOfBoundsException.class)
+  public void testWriteSrcIndexAndLengthExceedWritableBytes() {
+    buffer().write(new byte[buffer().writableBytes()], 1, buffer().writableBytes());
+  }
+
+  @Test
+  public void testWritableAndReadableBytes() {
+    int before = buffer().writableBytes();
+    buffer().write(new byte[10], 0, 5);
+
+    assertEquals(5, before - buffer().writableBytes());
+    assertEquals(5, buffer().readableBytes());
+  }
+
+  @Test
+  public void testWriteSrcIndex() {
+    byte[] b = new byte[10];
+    for (byte i = 5; i < 10; i++) {
+      b[i] = i;
+    }
+
+    buffer().write(b, 5, 5);
+
+    assertEquals(5, buffer().readableBytes());
+    byte[] writtenBytes = writtenBytes();
+    assertEquals(5, writtenBytes.length);
+    for (int i = 0; i < writtenBytes.length; i++) {
+      assertEquals(5 + i, writtenBytes[i]);
+    }
+  }
+
+  @Test
+  public void testMultipleWrites() {
+    byte[] b = new byte[100];
+    for (byte i = 0; i < b.length; i++) {
+      b[i] = i;
+    }
+
+    // Write in chunks of 10 bytes
+    for (int i = 0; i < 10; i++) {
+      buffer().write(b, 10 * i, 10);
+      assertEquals(10 * (i + 1), buffer().readableBytes());
+    }
+
+    assertArrayEquals(b, writtenBytes());
+  }
+}
diff --git a/cronet/.gitignore b/cronet/.gitignore
new file mode 100644
index 00000000000..2fd4c3b3501
--- /dev/null
+++ b/cronet/.gitignore
@@ -0,0 +1 @@
+libs/
diff --git a/cronet/README.md b/cronet/README.md
new file mode 100644
index 00000000000..b62ed634b06
--- /dev/null
+++ b/cronet/README.md
@@ -0,0 +1,54 @@
+gRPC Cronet Transport
+========================
+
+**EXPERIMENTAL:**  *gRPC's Cronet transport is an experimental API. Its stability
+depends on upstream Cronet's implementation, which involves some experimental features.*
+
+This code enables using the [Chromium networking stack
+(Cronet)](https://chromium.googlesource.com/chromium/src/+/master/components/cronet)
+as the transport layer for gRPC on Android. This lets your Android app make
+RPCs using the same networking stack as used in the Chrome browser.
+
+Some advantages of using Cronet with gRPC:
+
+* Bundles an OpenSSL implementation, enabling TLS connections even on older
+  versions of Android without additional configuration
+* Robust to Android network connectivity changes
+* Support for [QUIC](https://www.chromium.org/quic)
+
+Since gRPC's 1.24 release, the `grpc-cronet` package provides access to the 
+`CronetChannelBuilder` class. Cronet jars are available on Google's Maven repository. 
+See the example app at https://github.com/GoogleChrome/cronet-sample/blob/master/README.md.
+
+## Example usage:
+
+In your app module's `build.gradle` file, include a dependency on both
+`io.grpc:grpc-cronet` and the Google Play Services Client Library for Cronet,
+`com.google.android.gms:play-services-cronet`.
+
+In cases where Cronet cannot be loaded from Google Play services, there is a less performant 
+implementation of Cronet's API that can be used. Depend on `org.chromium.net:cronet-fallback` 
+to use this fall-back implementation.
+
+
+You will also need permission to access the device's network state in your 
+`AndroidManifest.xml`:
+
+```
+<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+```
+
+Once the above steps are completed, you can create a gRPC Cronet channel as
+follows:
+
+```
+import io.grpc.cronet.CronetChannelBuilder;
+import org.chromium.net.ExperimentalCronetEngine;
+
+...
+
+ExperimentalCronetEngine engine =
+    new ExperimentalCronetEngine.Builder(context /* Android Context */).build();
+ManagedChannel channel = CronetChannelBuilder.forAddress("localhost", 8080, engine).build();
+```
+
diff --git a/cronet/build.gradle b/cronet/build.gradle
new file mode 100644
index 00000000000..d6d773a97e4
--- /dev/null
+++ b/cronet/build.gradle
@@ -0,0 +1,94 @@
+plugins {
+    id "maven-publish"
+
+    id "com.android.library"
+}
+
+description = "gRPC: Cronet Android"
+
+repositories {
+    google()
+}
+
+android {
+    namespace = 'io.grpc.cronet'
+    compileSdkVersion 33
+    defaultConfig {
+        minSdkVersion 22
+        targetSdkVersion 33
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        debug { minifyEnabled false }
+        release {
+            minifyEnabled false
+            consumerProguardFiles 'proguard-rules.pro'
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    testOptions { unitTests { includeAndroidResources = true } }
+    lintOptions { disable 'InvalidPackage' }
+    publishing {
+        singleVariant('release') {
+            withSourcesJar()
+            withJavadocJar()
+        }
+    }
+}
+
+dependencies {
+    api project(':grpc-api'),
+            libraries.cronet.api
+    implementation project(':grpc-core')
+    implementation libraries.guava
+    implementation 'org.checkerframework:checker-qual:3.49.5'
+    testImplementation project(':grpc-testing')
+
+    testImplementation libraries.cronet.embedded
+
+    testImplementation libraries.junit
+    testImplementation libraries.mockito.core
+    testImplementation libraries.robolectric
+}
+
+task javadocs(type: Javadoc) {
+    source = android.sourceSets.main.java.srcDirs
+    classpath += files(android.getBootClasspath())
+    classpath += files({
+        android.libraryVariants.collect { variant ->
+            variant.javaCompileProvider.get().classpath
+        }
+    })
+    options {
+        // Disable JavaDoc doclint on Java 8.
+        if (JavaVersion.current().isJava8Compatible()) {
+            addStringOption('Xdoclint:none', '-quiet')
+        }
+    }
+    exclude 'io/grpc/cronet/Internal*'
+}
+
+task javadocJar(type: Jar, dependsOn: javadocs) {
+    archiveClassifier = 'javadoc'
+    from javadocs.destinationDir
+}
+
+task sourcesJar(type: Jar) {
+    archiveClassifier = 'sources'
+    from android.sourceSets.main.java.srcDirs
+}
+
+publishing {
+    publications {
+        maven {
+            afterEvaluate {
+                from components.release
+            }
+        }
+    }
+}
diff --git a/cronet/proguard-rules.pro b/cronet/proguard-rules.pro
new file mode 100644
index 00000000000..b671e77af60
--- /dev/null
+++ b/cronet/proguard-rules.pro
@@ -0,0 +1,13 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in $ANDROID_HOME/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+-dontwarn org.chromium.**
+-dontnote org.chromium.**
diff --git a/cronet/src/main/AndroidManifest.xml b/cronet/src/main/AndroidManifest.xml
new file mode 100644
index 00000000000..94cbbcfc396
--- /dev/null
+++ b/cronet/src/main/AndroidManifest.xml
@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />
diff --git a/cronet/src/main/java/io/grpc/cronet/CronetChannelBuilder.java b/cronet/src/main/java/io/grpc/cronet/CronetChannelBuilder.java
new file mode 100644
index 00000000000..f42dabdd55a
--- /dev/null
+++ b/cronet/src/main/java/io/grpc/cronet/CronetChannelBuilder.java
@@ -0,0 +1,350 @@
+/*
+ * Copyright 2016 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.cronet;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
+
+import android.net.Network;
+import android.os.Build;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.DoNotCall;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingChannelBuilder2;
+import io.grpc.Internal;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.ConnectionClientTransport;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.ManagedChannelImplBuilder;
+import io.grpc.internal.ManagedChannelImplBuilder.ClientTransportFactoryBuilder;
+import io.grpc.internal.SharedResourceHolder;
+import io.grpc.internal.TransportTracer;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import javax.annotation.Nullable;
+import org.chromium.net.BidirectionalStream;
+import org.chromium.net.CronetEngine;
+
+/** Convenience class for building channels with the cronet transport. */
+@ExperimentalApi("There is no plan to make this API stable, given transport API instability")
+public final class CronetChannelBuilder extends ForwardingChannelBuilder2<CronetChannelBuilder> {
+
+  /** BidirectionalStream.Builder factory used for getting the gRPC BidirectionalStream. */
+  public static abstract class StreamBuilderFactory {
+    public abstract BidirectionalStream.Builder newBidirectionalStreamBuilder(
+        String url, BidirectionalStream.Callback callback, Executor executor);
+  }
+
+  /** Creates a new builder for the given server host, port and CronetEngine. */
+  public static CronetChannelBuilder forAddress(String host, int port, CronetEngine cronetEngine) {
+    Preconditions.checkNotNull(cronetEngine, "cronetEngine");
+    return new CronetChannelBuilder(host, port, cronetEngine);
+  }
+
+  /**
+   * Always fails.  Call {@link #forAddress(String, int, CronetEngine)} instead.
+   */
+  @DoNotCall("Unsupported. Use forAddress(String, int, CronetEngine) instead")
+  public static CronetChannelBuilder forTarget(String target) {
+    throw new UnsupportedOperationException("call forAddress() instead");
+  }
+
+  /**
+   * Always fails.  Call {@link #forAddress(String, int, CronetEngine)} instead.
+   */
+  @DoNotCall("Unsupported. Use forAddress(String, int, CronetEngine) instead")
+  public static CronetChannelBuilder forAddress(String name, int port) {
+    throw new UnsupportedOperationException("call forAddress(String, int, CronetEngine) instead");
+  }
+
+  @Nullable
+  private ScheduledExecutorService scheduledExecutorService;
+
+  private final CronetEngine cronetEngine;
+  private final ManagedChannelImplBuilder managedChannelImplBuilder;
+  private final TransportTracer.Factory transportTracerFactory = TransportTracer.getDefaultFactory();
+
+  private boolean alwaysUsePut = false;
+
+  private int maxMessageSize = DEFAULT_MAX_MESSAGE_SIZE;
+
+  /**
+   * If true, indicates that the transport may use the GET method for RPCs, and may include the
+   * request body in the query params.
+   */
+  private final boolean useGetForSafeMethods = false;
+
+  /**
+   * If true, indicates that the transport may use the PUT method for RPCs.
+   */
+  private final boolean usePutForIdempotentMethods = false;
+
+  private boolean trafficStatsTagSet;
+  private int trafficStatsTag;
+  private boolean trafficStatsUidSet;
+  private int trafficStatsUid;
+  private Network network;
+
+  private CronetChannelBuilder(String host, int port, CronetEngine cronetEngine) {
+    final class CronetChannelTransportFactoryBuilder implements ClientTransportFactoryBuilder {
+      @Override
+      public ClientTransportFactory buildClientTransportFactory() {
+        return buildTransportFactory();
+      }
+    }
+
+    managedChannelImplBuilder = new ManagedChannelImplBuilder(
+        InetSocketAddress.createUnresolved(host, port),
+        GrpcUtil.authorityFromHostAndPort(host, port),
+        new CronetChannelTransportFactoryBuilder(),
+        null);
+    this.cronetEngine = Preconditions.checkNotNull(cronetEngine, "cronetEngine");
+  }
+
+  @Internal
+  @Override
+  protected ManagedChannelBuilder<?> delegate() {
+    return managedChannelImplBuilder;
+  }
+
+  /**
+   * Sets the maximum message size allowed to be received on the channel. If not called,
+   * defaults to {@link io.grpc.internal.GrpcUtil#DEFAULT_MAX_MESSAGE_SIZE}.
+   */
+  public CronetChannelBuilder maxMessageSize(int maxMessageSize) {
+    checkArgument(maxMessageSize >= 0, "maxMessageSize must be >= 0");
+    this.maxMessageSize = maxMessageSize;
+    return this;
+  }
+
+  /**
+   * Sets the Cronet channel to always use PUT instead of POST. Defaults to false.
+   */
+  public CronetChannelBuilder alwaysUsePut(boolean enable) {
+    this.alwaysUsePut = enable;
+    return this;
+  }
+
+  /**
+   * Sets {@link android.net.TrafficStats} tag to use when accounting socket traffic caused by this
+   * channel. See {@link android.net.TrafficStats} for more information. If no tag is set (e.g. this
+   * method isn't called), then Android accounts for the socket traffic caused by this channel as if
+   * the tag value were set to 0.
+   *
+   * <p><b>NOTE:</b>Setting a tag disallows sharing of sockets with channels with other tags, which
+   * may adversely effect performance by prohibiting connection sharing. In other words use of
+   * multiplexed sockets (e.g. HTTP/2 and QUIC) will only be allowed if all channels have the same
+   * socket tag.
+   *
+   * @param tag the tag value used to when accounting for socket traffic caused by this channel.
+   *     Tags between 0xFFFFFF00 and 0xFFFFFFFF are reserved and used internally by system services
+   *     like {@link android.app.DownloadManager} when performing traffic on behalf of an
+   *     application.
+   * @return the builder to facilitate chaining.
+   */
+  CronetChannelBuilder setTrafficStatsTag(int tag) {
+    trafficStatsTagSet = true;
+    trafficStatsTag = tag;
+    return this;
+  }
+
+  /**
+   * Sets specific UID to use when accounting socket traffic caused by this channel. See {@link
+   * android.net.TrafficStats} for more information. Designed for use when performing an operation
+   * on behalf of another application. Caller must hold {@link
+   * android.Manifest.permission#UPDATE_DEVICE_STATS} permission. By default traffic is
+   * attributed to UID of caller.
+   *
+   * <p><b>NOTE:</b>Setting a UID disallows sharing of sockets with channels with other UIDs, which
+   * may adversely effect performance by prohibiting connection sharing. In other words use of
+   * multiplexed sockets (e.g. HTTP/2 and QUIC) will only be allowed if all channels have the same
+   * UID set.
+   *
+   * @param uid the UID to attribute socket traffic caused by this channel.
+   * @return the builder to facilitate chaining.
+   */
+  CronetChannelBuilder setTrafficStatsUid(int uid) {
+    trafficStatsUidSet = true;
+    trafficStatsUid = uid;
+    return this;
+  }
+
+  /** Sets the network ID to use for this channel traffic. */
+  @CanIgnoreReturnValue
+  CronetChannelBuilder bindToNetwork(@Nullable Network network) {
+    this.network = network;
+    return this;
+  }
+
+  /**
+   * Provides a custom scheduled executor service.
+   *
+   * <p>It's an optional parameter. If the user has not provided a scheduled executor service when
+   * the channel is built, the builder will use a static cached thread pool.
+   *
+   * @return this
+   *
+   * @since 1.12.0
+   */
+  public CronetChannelBuilder scheduledExecutorService(
+      ScheduledExecutorService scheduledExecutorService) {
+    this.scheduledExecutorService =
+        checkNotNull(scheduledExecutorService, "scheduledExecutorService");
+    return this;
+  }
+
+  ClientTransportFactory buildTransportFactory() {
+    return new CronetTransportFactory(
+        new TaggingStreamFactory(
+            cronetEngine,
+            trafficStatsTagSet,
+            trafficStatsTag,
+            trafficStatsUidSet,
+            trafficStatsUid,
+            network),
+        MoreExecutors.directExecutor(),
+        scheduledExecutorService,
+        maxMessageSize,
+        alwaysUsePut,
+        transportTracerFactory.create(),
+        useGetForSafeMethods,
+        usePutForIdempotentMethods);
+  }
+
+  @VisibleForTesting
+  static class CronetTransportFactory implements ClientTransportFactory {
+    private final ScheduledExecutorService timeoutService;
+    private final Executor executor;
+    private final int maxMessageSize;
+    private final boolean alwaysUsePut;
+    private final StreamBuilderFactory streamFactory;
+    private final TransportTracer transportTracer;
+    private final boolean usingSharedScheduler;
+    private final boolean useGetForSafeMethods;
+    private final boolean usePutForIdempotentMethods;
+
+    private CronetTransportFactory(
+        StreamBuilderFactory streamFactory,
+        Executor executor,
+        @Nullable ScheduledExecutorService timeoutService,
+        int maxMessageSize,
+        boolean alwaysUsePut,
+        TransportTracer transportTracer,
+        boolean useGetForSafeMethods,
+        boolean usePutForIdempotentMethods) {
+      usingSharedScheduler = timeoutService == null;
+      this.timeoutService = usingSharedScheduler
+          ? SharedResourceHolder.get(GrpcUtil.TIMER_SERVICE) : timeoutService;
+      this.maxMessageSize = maxMessageSize;
+      this.alwaysUsePut = alwaysUsePut;
+      this.streamFactory = streamFactory;
+      this.executor = Preconditions.checkNotNull(executor, "executor");
+      this.transportTracer = Preconditions.checkNotNull(transportTracer, "transportTracer");
+      this.useGetForSafeMethods = useGetForSafeMethods;
+      this.usePutForIdempotentMethods = usePutForIdempotentMethods;
+    }
+
+    @Override
+    public ConnectionClientTransport newClientTransport(
+        SocketAddress addr, ClientTransportOptions options, ChannelLogger channelLogger) {
+      InetSocketAddress inetSocketAddr = (InetSocketAddress) addr;
+      return new CronetClientTransport(streamFactory, inetSocketAddr, options.getAuthority(),
+          options.getUserAgent(), options.getEagAttributes(), executor, maxMessageSize,
+          alwaysUsePut, transportTracer, useGetForSafeMethods, usePutForIdempotentMethods);
+    }
+
+    @Override
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return timeoutService;
+    }
+
+    @Override
+    public SwapChannelCredentialsResult swapChannelCredentials(ChannelCredentials channelCreds) {
+      return null;
+    }
+
+    @Override
+    public void close() {
+      if (usingSharedScheduler) {
+        SharedResourceHolder.release(GrpcUtil.TIMER_SERVICE, timeoutService);
+      }
+    }
+
+    @Override
+    public Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+      return Collections.singleton(InetSocketAddress.class);
+    }
+  }
+
+  /**
+   * StreamBuilderFactory impl that applies TrafficStats tags to stream builders that are produced.
+   */
+  private static class TaggingStreamFactory extends StreamBuilderFactory {
+    private final CronetEngine cronetEngine;
+    private final boolean trafficStatsTagSet;
+    private final int trafficStatsTag;
+    private final boolean trafficStatsUidSet;
+    private final int trafficStatsUid;
+    private final Network network;
+
+    TaggingStreamFactory(
+        CronetEngine cronetEngine,
+        boolean trafficStatsTagSet,
+        int trafficStatsTag,
+        boolean trafficStatsUidSet,
+        int trafficStatsUid,
+        Network network) {
+      this.cronetEngine = cronetEngine;
+      this.trafficStatsTagSet = trafficStatsTagSet;
+      this.trafficStatsTag = trafficStatsTag;
+      this.trafficStatsUidSet = trafficStatsUidSet;
+      this.trafficStatsUid = trafficStatsUid;
+      this.network = network;
+    }
+
+    @Override
+    public BidirectionalStream.Builder newBidirectionalStreamBuilder(
+        String url, BidirectionalStream.Callback callback, Executor executor) {
+      BidirectionalStream.Builder builder =
+          cronetEngine
+              .newBidirectionalStreamBuilder(url, callback, executor);
+      if (trafficStatsTagSet) {
+        builder.setTrafficStatsTag(trafficStatsTag);
+      }
+      if (trafficStatsUidSet) {
+        builder.setTrafficStatsUid(trafficStatsUid);
+      }
+      if (network != null) {
+        if (Build.VERSION.SDK_INT >= 23) {
+          builder.bindToNetwork(network.getNetworkHandle());
+        }
+      }
+      return builder;
+    }
+  }
+}
diff --git a/cronet/src/main/java/io/grpc/cronet/CronetClientStream.java b/cronet/src/main/java/io/grpc/cronet/CronetClientStream.java
new file mode 100644
index 00000000000..fcba49a7ae1
--- /dev/null
+++ b/cronet/src/main/java/io/grpc/cronet/CronetClientStream.java
@@ -0,0 +1,587 @@
+/*
+ * Copyright 2016 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.cronet;
+
+import static io.grpc.internal.GrpcUtil.CONTENT_TYPE_KEY;
+import static io.grpc.internal.GrpcUtil.TE_HEADER;
+import static io.grpc.internal.GrpcUtil.USER_AGENT_KEY;
+
+// TODO(ericgribkoff): Consider changing from android.util.Log to java logging.
+import android.util.Log;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.io.BaseEncoding;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.InternalMetadata;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.grpc.cronet.CronetChannelBuilder.StreamBuilderFactory;
+import io.grpc.internal.AbstractClientStream;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.Http2ClientStreamTransportState;
+import io.grpc.internal.ReadableBuffers;
+import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.TransportFrameUtil;
+import io.grpc.internal.TransportTracer;
+import io.grpc.internal.WritableBuffer;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import javax.annotation.Nullable;
+import org.chromium.net.BidirectionalStream;
+import org.chromium.net.CronetException;
+import org.chromium.net.UrlResponseInfo;
+
+/**
+ * Client stream for the cronet transport.
+ */
+class CronetClientStream extends AbstractClientStream {
+  private static final int READ_BUFFER_CAPACITY = 4 * 1024;
+  private static final ByteBuffer EMPTY_BUFFER = ByteBuffer.allocateDirect(0);
+  private static final String LOG_TAG = "grpc-java-cronet";
+
+  @Deprecated
+  static final CallOptions.Key<Object> CRONET_ANNOTATION_KEY =
+      CallOptions.Key.create("cronet-annotation");
+
+  static final CallOptions.Key<Collection<Object>> CRONET_ANNOTATIONS_KEY =
+      CallOptions.Key.create("cronet-annotations");
+
+  private final String url;
+  private final String userAgent;
+  private final StatsTraceContext statsTraceCtx;
+  private final Executor executor;
+  private final Metadata headers;
+  private final CronetClientTransport transport;
+  private final Runnable startCallback;
+  @VisibleForTesting
+  final boolean idempotent;
+  private BidirectionalStream stream;
+  private final boolean delayRequestHeader;
+  private final Object annotation;
+  private final Collection<Object> annotations;
+  private final TransportState state;
+  private final Sink sink = new Sink();
+  private StreamBuilderFactory streamFactory;
+
+  CronetClientStream(
+      final String url,
+      @Nullable String userAgent,
+      Executor executor,
+      final Metadata headers,
+      CronetClientTransport transport,
+      Runnable startCallback,
+      Object lock,
+      int maxMessageSize,
+      boolean alwaysUsePut,
+      MethodDescriptor<?, ?> method,
+      StatsTraceContext statsTraceCtx,
+      CallOptions callOptions,
+      TransportTracer transportTracer,
+      boolean useGetForSafeMethods,
+      boolean usePutForIdempotentMethods) {
+    super(
+        new CronetWritableBufferAllocator(), statsTraceCtx, transportTracer, headers, callOptions,
+        useGetForSafeMethods && method.isSafe());
+    this.url = Preconditions.checkNotNull(url, "url");
+    this.userAgent = Preconditions.checkNotNull(userAgent, "userAgent");
+    this.statsTraceCtx = Preconditions.checkNotNull(statsTraceCtx, "statsTraceCtx");
+    this.executor = Preconditions.checkNotNull(executor, "executor");
+    this.headers = Preconditions.checkNotNull(headers, "headers");
+    this.transport = Preconditions.checkNotNull(transport, "transport");
+    this.startCallback = Preconditions.checkNotNull(startCallback, "startCallback");
+    this.idempotent = (usePutForIdempotentMethods && method.isIdempotent()) || alwaysUsePut;
+    // Only delay flushing header for unary rpcs.
+    this.delayRequestHeader = (method.getType() == MethodDescriptor.MethodType.UNARY);
+    this.annotation = callOptions.getOption(CRONET_ANNOTATION_KEY);
+    this.annotations = callOptions.getOption(CRONET_ANNOTATIONS_KEY);
+    this.state = new TransportState(maxMessageSize, statsTraceCtx, lock, transportTracer,
+            callOptions);
+
+    // Tests expect the "plain" deframer behavior, not MigratingDeframer
+    // https://github.com/grpc/grpc-java/issues/7140
+    optimizeForDirectExecutor();
+  }
+
+  @Override
+  protected TransportState transportState() {
+    return state;
+  }
+
+  @Override
+  protected Sink abstractClientStreamSink() {
+    return sink;
+  }
+
+  @Override
+  public void setAuthority(String authority) {
+    throw new UnsupportedOperationException("Cronet does not support overriding authority");
+  }
+
+  /**
+   * Returns a copy of {@code callOptions} with {@code annotation} included as one of the Cronet
+   * annotation objects. When an RPC is made using a {@link CallOptions} instance returned by this
+   * method, the annotation objects will be attached to the underlying Cronet bidirectional stream.
+   * When the stream finishes, the user can retrieve the annotation objects via {@link
+   * org.chromium.net.RequestFinishedInfo.Listener}.
+   *
+   * @param annotation the object to attach to the Cronet stream
+   */
+  static CallOptions withAnnotation(CallOptions callOptions, Object annotation) {
+    Collection<Object> existingAnnotations = callOptions.getOption(CRONET_ANNOTATIONS_KEY);
+    ArrayList<Object> newAnnotations;
+    if (existingAnnotations == null) {
+      newAnnotations = new ArrayList<>();
+    } else {
+      newAnnotations = new ArrayList<>(existingAnnotations);
+    }
+    newAnnotations.add(annotation);
+    return callOptions.withOption(
+        CRONET_ANNOTATIONS_KEY, Collections.unmodifiableList(newAnnotations));
+  }
+
+  class Sink implements AbstractClientStream.Sink {
+    @Override
+    public void writeHeaders(Metadata metadata, byte[] payload) {
+      startCallback.run();
+      // streamFactory will be set by startCallback, unless the transport is in go-away state
+      if (streamFactory == null) {
+        return;
+      }
+
+      BidirectionalStreamCallback callback = new BidirectionalStreamCallback();
+      String path = url;
+      if (payload != null) {
+        path += "?" + BaseEncoding.base64().encode(payload);
+      }
+      BidirectionalStream.Builder builder =
+          streamFactory.newBidirectionalStreamBuilder(path, callback, executor);
+      if (payload != null) {
+        builder.setHttpMethod("GET");
+      } else if (idempotent) {
+        builder.setHttpMethod("PUT");
+      }
+      if (delayRequestHeader) {
+        builder.delayRequestHeadersUntilFirstFlush(true);
+      }
+      if (annotation != null || annotations != null) {
+        if (annotation != null) {
+          builder.addRequestAnnotation(annotation);
+        }
+        if (annotations != null) {
+          for (Object o : annotations) {
+            builder.addRequestAnnotation(o);
+          }
+        }
+      }
+      setGrpcHeaders(builder);
+      stream = builder.build();
+      stream.start();
+    }
+
+    @Override
+    public void writeFrame(
+        WritableBuffer buffer, boolean endOfStream, boolean flush, int numMessages) {
+      synchronized (state.lock) {
+        if (state.cancelSent) {
+          return;
+        }
+        ByteBuffer byteBuffer;
+        if (buffer != null) {
+          byteBuffer = ((CronetWritableBuffer) buffer).buffer();
+          ((Buffer) byteBuffer).flip();
+        } else {
+          byteBuffer = EMPTY_BUFFER;
+        }
+        onSendingBytes(byteBuffer.remaining());
+        if (!state.streamReady) {
+          state.enqueuePendingData(new PendingData(byteBuffer, endOfStream, flush));
+        } else {
+          streamWrite(byteBuffer, endOfStream, flush);
+        }
+      }
+    }
+
+    @Override
+    public void cancel(Status reason) {
+      synchronized (state.lock) {
+        if (state.cancelSent) {
+          return;
+        }
+        state.cancelSent = true;
+        state.cancelReason = reason;
+        state.clearPendingData();
+        if (stream != null) {
+          // Will report stream finish when BidirectionalStreamCallback.onCanceled is called.
+          stream.cancel();
+        } else {
+          transport.finishStream(CronetClientStream.this, reason);
+        }
+      }
+    }
+  }
+
+  class TransportState extends Http2ClientStreamTransportState {
+    private final Object lock;
+    @GuardedBy("lock")
+    private final Collection<PendingData> pendingData = new ArrayList<>();
+    @GuardedBy("lock")
+    private boolean streamReady;
+    @GuardedBy("lock")
+    private boolean cancelSent = false;
+    @GuardedBy("lock")
+    private int bytesPendingProcess;
+    @GuardedBy("lock")
+    private Status cancelReason;
+    @GuardedBy("lock")
+    private boolean readClosed;
+    @GuardedBy("lock")
+    private boolean firstWriteComplete;
+
+    public TransportState(
+        int maxMessageSize, StatsTraceContext statsTraceCtx, Object lock,
+        TransportTracer transportTracer, CallOptions options) {
+      super(maxMessageSize, statsTraceCtx, transportTracer, options);
+      this.lock = Preconditions.checkNotNull(lock, "lock");
+    }
+
+    @GuardedBy("lock")
+    public void start(StreamBuilderFactory factory) {
+      streamFactory = factory;
+    }
+
+    @GuardedBy("lock")
+    @Override
+    protected void onStreamAllocated() {
+      super.onStreamAllocated();
+    }
+
+    @GuardedBy("lock")
+    @Override
+    protected void http2ProcessingFailed(Status status, boolean stopDelivery, Metadata trailers) {
+      Preconditions.checkNotNull(stream, "stream must not be null");
+      stream.cancel();
+      transportReportStatus(status, stopDelivery, trailers);
+    }
+
+    @GuardedBy("lock")
+    @Override
+    public void deframeFailed(Throwable cause) {
+      http2ProcessingFailed(Status.fromThrowable(cause), true, new Metadata());
+    }
+
+    @Override
+    public void runOnTransportThread(final Runnable r) {
+      synchronized (lock) {
+        r.run();
+      }
+    }
+
+    @GuardedBy("lock")
+    @Override
+    public void bytesRead(int processedBytes) {
+      Preconditions.checkNotNull(stream, "stream must not be null");
+      bytesPendingProcess -= processedBytes;
+      if (bytesPendingProcess == 0 && !readClosed) {
+        if (Log.isLoggable(LOG_TAG, Log.VERBOSE)) {
+          Log.v(LOG_TAG, "BidirectionalStream.read");
+        }
+        stream.read(ByteBuffer.allocateDirect(READ_BUFFER_CAPACITY));
+      }
+    }
+
+    @GuardedBy("lock")
+    private void transportHeadersReceived(Metadata metadata, boolean endOfStream) {
+      if (endOfStream) {
+        transportTrailersReceived(metadata);
+      } else {
+        transportHeadersReceived(metadata);
+      }
+    }
+
+    @GuardedBy("lock")
+    private void transportDataReceived(ByteBuffer buffer, boolean endOfStream) {
+      bytesPendingProcess += buffer.remaining();
+      super.transportDataReceived(ReadableBuffers.wrap(buffer), endOfStream);
+    }
+
+    @GuardedBy("lock")
+    private void clearPendingData() {
+      for (PendingData data : pendingData) {
+        data.buffer.clear();
+      }
+      pendingData.clear();
+    }
+
+    @GuardedBy("lock")
+    private void enqueuePendingData(PendingData data) {
+      pendingData.add(data);
+    }
+
+    @GuardedBy("lock")
+    private void writeAllPendingData() {
+      for (PendingData data : pendingData) {
+        streamWrite(data.buffer, data.endOfStream, data.flush);
+      }
+      pendingData.clear();
+    }
+  }
+
+  // TODO(ericgribkoff): move header related method to a common place like GrpcUtil.
+  private static boolean isApplicationHeader(String key) {
+    // Don't allow reserved non HTTP/2 pseudo headers to be added
+    // HTTP/2 headers can not be created as keys because Header.Key disallows the ':' character.
+    return !CONTENT_TYPE_KEY.name().equalsIgnoreCase(key)
+        && !USER_AGENT_KEY.name().equalsIgnoreCase(key)
+        && !TE_HEADER.name().equalsIgnoreCase(key);
+  }
+
+  private void setGrpcHeaders(BidirectionalStream.Builder builder) {
+    // Psuedo-headers are set by cronet.
+    // All non-pseudo headers must come after pseudo headers.
+    builder.addHeader(USER_AGENT_KEY.name(), userAgent);
+    builder.addHeader(CONTENT_TYPE_KEY.name(), GrpcUtil.CONTENT_TYPE_GRPC);
+    builder.addHeader("te", GrpcUtil.TE_TRAILERS);
+
+    // Now add any application-provided headers.
+    // TODO(ericgribkoff): make a String-based version to avoid unnecessary conversion between
+    // String and byte array.
+    byte[][] serializedHeaders = TransportFrameUtil.toHttp2Headers(headers);
+    for (int i = 0; i < serializedHeaders.length; i += 2) {
+      String key = new String(serializedHeaders[i], StandardCharsets.UTF_8);
+      // TODO(ericgribkoff): log an error or throw an exception
+      if (isApplicationHeader(key)) {
+        String value = new String(serializedHeaders[i + 1], StandardCharsets.UTF_8);
+        builder.addHeader(key, value);
+      }
+    }
+  }
+
+  private void streamWrite(ByteBuffer buffer, boolean endOfStream, boolean flush) {
+    if (stream == null) {
+      return;
+    }
+    if (Log.isLoggable(LOG_TAG, Log.VERBOSE)) {
+      Log.v(LOG_TAG, "BidirectionalStream.write");
+    }
+    stream.write(buffer, endOfStream);
+    if (flush) {
+      if (Log.isLoggable(LOG_TAG, Log.VERBOSE)) {
+        Log.v(LOG_TAG, "BidirectionalStream.flush");
+      }
+      stream.flush();
+    }
+  }
+
+  private void finishStream(Status status) {
+    transport.finishStream(this, status);
+  }
+
+  @Override
+  public Attributes getAttributes() {
+    return Attributes.EMPTY;
+  }
+
+  class BidirectionalStreamCallback extends BidirectionalStream.Callback {
+    private List<Map.Entry<String, String>> trailerList;
+
+    @Override
+    public void onStreamReady(BidirectionalStream stream) {
+      if (Log.isLoggable(LOG_TAG, Log.VERBOSE)) {
+        Log.v(LOG_TAG, "onStreamReady");
+      }
+      synchronized (state.lock) {
+        // Now that the stream is ready, call the listener's onReady callback if
+        // appropriate.
+        state.onStreamAllocated();
+        state.streamReady = true;
+        state.writeAllPendingData();
+      }
+    }
+
+    @Override
+    public void onResponseHeadersReceived(BidirectionalStream stream, UrlResponseInfo info) {
+      if (Log.isLoggable(LOG_TAG, Log.VERBOSE)) {
+        Log.v(LOG_TAG, "onResponseHeadersReceived. Header=" + info.getAllHeadersAsList());
+        Log.v(LOG_TAG, "BidirectionalStream.read");
+      }
+      reportHeaders(info.getAllHeadersAsList(), false);
+      stream.read(ByteBuffer.allocateDirect(READ_BUFFER_CAPACITY));
+    }
+
+    @Override
+    public void onReadCompleted(BidirectionalStream stream, UrlResponseInfo info,
+        ByteBuffer buffer, boolean endOfStream) {
+      ((Buffer) buffer).flip();
+      if (Log.isLoggable(LOG_TAG, Log.VERBOSE)) {
+        Log.v(LOG_TAG, "onReadCompleted. Size=" + buffer.remaining());
+      }
+
+      synchronized (state.lock) {
+        state.readClosed = endOfStream;
+        // The endOfStream in gRPC has a different meaning so we always call transportDataReceived
+        // with endOfStream=false.
+        if (buffer.remaining() != 0) {
+          state.transportDataReceived(buffer, false);
+        }
+      }
+      if (endOfStream && trailerList != null) {
+        // Process trailers if we have already received any.
+        reportHeaders(trailerList, true);
+      }
+    }
+
+    @Override
+    public void onWriteCompleted(BidirectionalStream stream, UrlResponseInfo info,
+        ByteBuffer buffer, boolean endOfStream) {
+      if (Log.isLoggable(LOG_TAG, Log.VERBOSE)) {
+        Log.v(LOG_TAG, "onWriteCompleted");
+      }
+      synchronized (state.lock) {
+        if (!state.firstWriteComplete) {
+          // Cronet API doesn't notify when headers are written to wire, but it occurs before first
+          // onWriteCompleted callback.
+          state.firstWriteComplete = true;
+          statsTraceCtx.clientOutboundHeaders();
+        }
+        state.onSentBytes(buffer.position());
+      }
+    }
+
+    @Override
+    public void onResponseTrailersReceived(BidirectionalStream stream, UrlResponseInfo info,
+        UrlResponseInfo.HeaderBlock trailers) {
+      processTrailers(trailers.getAsList());
+    }
+
+    // We need this method because UrlResponseInfo.HeaderBlock is a final class and cannot be
+    // mocked.
+    @VisibleForTesting
+    void processTrailers(List<Map.Entry<String, String>> trailerList) {
+      this.trailerList = trailerList;
+      boolean readClosed;
+      synchronized (state.lock) {
+        readClosed = state.readClosed;
+      }
+      if (readClosed) {
+        // There's no pending onReadCompleted callback so we can report trailers now.
+        reportHeaders(trailerList, true);
+      }
+      // Otherwise report trailers in onReadCompleted, or onSucceeded.
+      if (Log.isLoggable(LOG_TAG, Log.VERBOSE)) {
+        Log.v(LOG_TAG, "onResponseTrailersReceived. Trailer=" + trailerList.toString());
+      }
+    }
+
+    @Override
+    public void onSucceeded(BidirectionalStream stream, UrlResponseInfo info) {
+      if (Log.isLoggable(LOG_TAG, Log.VERBOSE)) {
+        Log.v(LOG_TAG, "onSucceeded");
+      }
+
+      if (!haveTrailersBeenReported()) {
+        if (trailerList != null) {
+          reportHeaders(trailerList, true);
+        } else if (info != null) {
+          reportHeaders(info.getAllHeadersAsList(), true);
+        } else {
+          throw new AssertionError("No response header or trailer");
+        }
+      }
+      finishStream(toGrpcStatus(info));
+    }
+
+    @Override
+    public void onFailed(BidirectionalStream stream, UrlResponseInfo info,
+        CronetException error) {
+      if (Log.isLoggable(LOG_TAG, Log.VERBOSE)) {
+        Log.v(LOG_TAG, "onFailed");
+      }
+      finishStream(Status.UNAVAILABLE.withCause(error));
+    }
+
+    @Override
+    public void onCanceled(BidirectionalStream stream, UrlResponseInfo info) {
+      if (Log.isLoggable(LOG_TAG, Log.VERBOSE)) {
+        Log.v(LOG_TAG, "onCanceled");
+      }
+      Status status;
+      synchronized (state.lock) {
+        if (state.cancelReason != null) {
+          status = state.cancelReason;
+        } else if (info != null) {
+          status = toGrpcStatus(info);
+        } else {
+          status = Status.CANCELLED.withDescription("stream cancelled without reason");
+        }
+      }
+      finishStream(status);
+    }
+
+    private void reportHeaders(List<Map.Entry<String, String>> headers, boolean endOfStream) {
+      // TODO(ericgribkoff): create new utility methods to eliminate all these conversions
+      List<String> headerList = new ArrayList<>();
+      for (Map.Entry<String, String> entry : headers) {
+        headerList.add(entry.getKey());
+        headerList.add(entry.getValue());
+      }
+
+      byte[][] headerValues = new byte[headerList.size()][];
+      for (int i = 0; i < headerList.size(); i += 2) {
+        headerValues[i] = headerList.get(i).getBytes(StandardCharsets.UTF_8);
+        headerValues[i + 1] = headerList.get(i + 1).getBytes(StandardCharsets.UTF_8);
+      }
+      Metadata metadata =
+          InternalMetadata.newMetadata(TransportFrameUtil.toRawSerializedHeaders(headerValues));
+      synchronized (state.lock) {
+        // There's no pending onReadCompleted callback so we can report trailers now.
+        state.transportHeadersReceived(metadata, endOfStream);
+      }
+    }
+
+    private boolean haveTrailersBeenReported() {
+      synchronized (state.lock) {
+        return trailerList != null && state.readClosed;
+      }
+    }
+
+    private Status toGrpcStatus(UrlResponseInfo info) {
+      return GrpcUtil.httpStatusToGrpcStatus(info.getHttpStatusCode());
+    }
+  }
+
+  private static class PendingData {
+    ByteBuffer buffer;
+    boolean endOfStream;
+    boolean flush;
+
+    PendingData(ByteBuffer buffer, boolean endOfStream, boolean flush) {
+      this.buffer = buffer;
+      this.endOfStream = endOfStream;
+      this.flush = flush;
+    }
+  }
+}
diff --git a/cronet/src/main/java/io/grpc/cronet/CronetClientTransport.java b/cronet/src/main/java/io/grpc/cronet/CronetClientTransport.java
new file mode 100644
index 00000000000..99eb88737aa
--- /dev/null
+++ b/cronet/src/main/java/io/grpc/cronet/CronetClientTransport.java
@@ -0,0 +1,280 @@
+/*
+ * Copyright 2016 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.cronet;
+
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalLogId;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.SecurityLevel;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.cronet.CronetChannelBuilder.StreamBuilderFactory;
+import io.grpc.internal.ConnectionClientTransport;
+import io.grpc.internal.GrpcAttributes;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.SimpleDisconnectError;
+import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.TransportTracer;
+import java.net.InetSocketAddress;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.Set;
+import java.util.concurrent.Executor;
+import javax.annotation.Nullable;
+
+/**
+ * A cronet-based {@link ConnectionClientTransport} implementation.
+ */
+class CronetClientTransport implements ConnectionClientTransport {
+  private final InternalLogId logId;
+  private final InetSocketAddress address;
+  private final String authority;
+  private final String userAgent;
+  private Listener listener;
+  private final Object lock = new Object();
+  @GuardedBy("lock")
+  private final Set<CronetClientStream> streams = Collections.newSetFromMap(
+          new IdentityHashMap<>());
+  private final Executor executor;
+  private final int maxMessageSize;
+  private final boolean alwaysUsePut;
+  private final TransportTracer transportTracer;
+  private Attributes attrs;
+  private final boolean useGetForSafeMethods;
+  private final boolean usePutForIdempotentMethods;
+  private final StreamBuilderFactory streamFactory;
+  // Indicates the transport is in go-away state: no new streams will be processed,
+  // but existing streams may continue.
+  @GuardedBy("lock")
+  private boolean goAway;
+  // Used to indicate the special phase while we are going to enter go-away state but before
+  // goAway is turned to true, see the comment at where this is set about why it is needed.
+  @GuardedBy("lock")
+  private boolean startedGoAway;
+  @GuardedBy("lock")
+  private Status goAwayStatus;
+  @GuardedBy("lock")
+  private boolean stopped;
+  @GuardedBy("lock")
+  // Whether this transport has started.
+  private boolean started;
+
+  CronetClientTransport(
+      StreamBuilderFactory streamFactory,
+      InetSocketAddress address,
+      String authority,
+      @Nullable String userAgent,
+      Attributes eagAttrs,
+      Executor executor,
+      int maxMessageSize,
+      boolean alwaysUsePut,
+      TransportTracer transportTracer,
+      boolean useGetForSafeMethods,
+      boolean usePutForIdempotentMethods) {
+    this.address = Preconditions.checkNotNull(address, "address");
+    this.logId = InternalLogId.allocate(getClass(), address.toString());
+    this.authority = authority;
+    this.userAgent = GrpcUtil.getGrpcUserAgent("cronet", userAgent);
+    this.maxMessageSize = maxMessageSize;
+    this.alwaysUsePut = alwaysUsePut;
+    this.executor = Preconditions.checkNotNull(executor, "executor");
+    this.streamFactory = Preconditions.checkNotNull(streamFactory, "streamFactory");
+    this.transportTracer = Preconditions.checkNotNull(transportTracer, "transportTracer");
+    this.attrs = Attributes.newBuilder()
+        .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.PRIVACY_AND_INTEGRITY)
+        .set(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS, eagAttrs)
+        .build();
+    this.useGetForSafeMethods = useGetForSafeMethods;
+    this.usePutForIdempotentMethods = usePutForIdempotentMethods;
+  }
+
+  @Override
+  public ListenableFuture<SocketStats> getStats() {
+    SettableFuture<SocketStats> f = SettableFuture.create();
+    f.set(null);
+    return f;
+  }
+
+  @Override
+  public CronetClientStream newStream(final MethodDescriptor<?, ?> method, final Metadata headers,
+      final CallOptions callOptions, ClientStreamTracer[] tracers) {
+    Preconditions.checkNotNull(method, "method");
+    Preconditions.checkNotNull(headers, "headers");
+
+    final String defaultPath = "/" + method.getFullMethodName();
+    final String url = "https://" + authority + defaultPath;
+
+    final StatsTraceContext statsTraceCtx =
+        StatsTraceContext.newClientContext(tracers, attrs, headers);
+    class StartCallback implements Runnable {
+      final CronetClientStream clientStream = new CronetClientStream(
+          url, userAgent, executor, headers, CronetClientTransport.this, this, lock, maxMessageSize,
+          alwaysUsePut, method, statsTraceCtx, callOptions, transportTracer, useGetForSafeMethods,
+          usePutForIdempotentMethods);
+
+      @Override
+      public void run() {
+        synchronized (lock) {
+          if (goAway) {
+            clientStream.transportState().transportReportStatus(goAwayStatus, true, new Metadata());
+          } else if (started) {
+            startStream(clientStream);
+          } else {
+            throw new AssertionError("Transport is not started");
+          }
+        }
+      }
+    }
+
+    return new StartCallback().clientStream;
+  }
+
+  @SuppressWarnings("GuardedBy")
+  @GuardedBy("lock")
+  private void startStream(CronetClientStream stream) {
+    streams.add(stream);
+    // TODO(b/145386688): This access should be guarded by 'stream.transportState().lock'; instead
+    // found: 'this.lock'
+    stream.transportState().start(streamFactory);
+  }
+
+  @Override
+  public Runnable start(Listener listener) {
+    this.listener = Preconditions.checkNotNull(listener, "listener");
+    synchronized (lock) {
+      started = true;
+    }
+    return new Runnable() {
+      @Override
+      public void run() {
+        attrs = CronetClientTransport.this.listener.filterTransport(attrs);
+        // Listener callbacks should not be called simultaneously
+        CronetClientTransport.this.listener.transportReady();
+      }
+    };
+  }
+
+  @Override
+  public String toString() {
+    return super.toString() + "(" + address + ")";
+  }
+
+  public void shutdown() {
+    shutdown(Status.UNAVAILABLE.withDescription("Transport stopped"));
+  }
+
+  @Override
+  public void shutdown(Status status) {
+    synchronized (lock) {
+      if (goAway) {
+        return;
+      }
+    }
+
+    startGoAway(status);
+  }
+
+  @Override
+  public void shutdownNow(Status status) {
+    shutdown(status);
+    ArrayList<CronetClientStream> streamsCopy;
+    synchronized (lock) {
+      // A copy is always necessary since cancel() can call finishStream() which calls
+      // streams.remove()
+      streamsCopy = new ArrayList<>(streams);
+    }
+    for (CronetClientStream cronetClientStream : streamsCopy) {
+      // Avoid deadlock by calling into stream without lock held
+      cronetClientStream.cancel(status);
+    }
+    stopIfNecessary();
+  }
+
+  @Override
+  public Attributes getAttributes() {
+    return attrs;
+  }
+
+  private void startGoAway(Status status) {
+    synchronized (lock) {
+      if (startedGoAway) {
+        // Another go-away is in progress, ignore this one.
+        return;
+      }
+      // We use startedGoAway here instead of goAway, because once the goAway becomes true, other
+      // thread in stopIfNecessary() may stop the transport and cause the
+      // listener.transportTerminated() be called before listener.transportShutdown().
+      startedGoAway = true;
+    }
+
+    listener.transportShutdown(status, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+
+    synchronized (lock) {
+      goAway = true;
+      goAwayStatus = status;
+    }
+
+    stopIfNecessary();
+  }
+
+  @Override
+  public void ping(final PingCallback callback, Executor executor) {
+    // TODO(ericgribkoff): depend on cronet implemenetation
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  public InternalLogId getLogId() {
+    return logId;
+  }
+
+  /**
+   * When the transport is in goAway state, we should stop it once all active streams finish.
+   */
+  void stopIfNecessary() {
+    synchronized (lock) {
+      if (goAway && !stopped && streams.isEmpty()) {
+        stopped = true;
+      } else {
+        return;
+      }
+    }
+    listener.transportTerminated();
+  }
+
+  void finishStream(CronetClientStream stream, Status status) {
+    synchronized (lock) {
+      if (streams.remove(stream)) {
+        boolean isCancelled = (status.getCode() == Code.CANCELLED
+            || status.getCode() == Code.DEADLINE_EXCEEDED);
+        stream.transportState().transportReportStatus(status, isCancelled, new Metadata());
+      } else {
+        return;
+      }
+    }
+    stopIfNecessary();
+  }
+}
diff --git a/cronet/src/main/java/io/grpc/cronet/CronetWritableBuffer.java b/cronet/src/main/java/io/grpc/cronet/CronetWritableBuffer.java
new file mode 100644
index 00000000000..989520698b2
--- /dev/null
+++ b/cronet/src/main/java/io/grpc/cronet/CronetWritableBuffer.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2016 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.cronet;
+
+import com.google.common.base.Preconditions;
+import io.grpc.internal.WritableBuffer;
+import java.nio.ByteBuffer;
+
+class CronetWritableBuffer implements WritableBuffer {
+  private final ByteBuffer buffer;
+
+  public CronetWritableBuffer(ByteBuffer buffer, int capacity) {
+    this.buffer = Preconditions.checkNotNull(buffer, "buffer");
+  }
+
+  @Override
+  public void write(byte[] src, int srcIndex, int length) {
+    buffer.put(src, srcIndex, length);
+  }
+
+  @Override
+  public void write(byte b) {
+    buffer.put(b);
+  }
+
+  @Override
+  public int writableBytes() {
+    return buffer.remaining();
+  }
+
+  @Override
+  public int readableBytes() {
+    return buffer.position();
+  }
+
+  @Override
+  public void release() {
+  }
+
+  ByteBuffer buffer() {
+    return buffer;
+  }
+}
diff --git a/cronet/src/main/java/io/grpc/cronet/CronetWritableBufferAllocator.java b/cronet/src/main/java/io/grpc/cronet/CronetWritableBufferAllocator.java
new file mode 100644
index 00000000000..0ccb211ce17
--- /dev/null
+++ b/cronet/src/main/java/io/grpc/cronet/CronetWritableBufferAllocator.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2016 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.cronet;
+
+import io.grpc.internal.WritableBuffer;
+import io.grpc.internal.WritableBufferAllocator;
+import java.nio.ByteBuffer;
+
+/**
+ * The default allocator for {@link CronetWritableBuffer}s used by the Cronet transport.
+ */
+class CronetWritableBufferAllocator implements WritableBufferAllocator {
+  // Set the maximum buffer size to 1MB
+  private static final int MAX_BUFFER = 1024 * 1024;
+
+  /**
+   * Construct a new instance.
+   */
+  CronetWritableBufferAllocator() {
+  }
+
+  @Override
+  public WritableBuffer allocate(int capacityHint) {
+    capacityHint = Math.min(MAX_BUFFER, capacityHint);
+    return new CronetWritableBuffer(ByteBuffer.allocateDirect(capacityHint), capacityHint);
+  }
+}
diff --git a/cronet/src/main/java/io/grpc/cronet/InternalCronetCallOptions.java b/cronet/src/main/java/io/grpc/cronet/InternalCronetCallOptions.java
new file mode 100644
index 00000000000..e7c4144e63a
--- /dev/null
+++ b/cronet/src/main/java/io/grpc/cronet/InternalCronetCallOptions.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2019 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.cronet;
+
+import io.grpc.CallOptions;
+import io.grpc.Internal;
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * Internal accessor class for call options using with the Cronet transport. This is intended for
+ * usage internal to the gRPC team. If you *really* think you need to use this, contact the gRPC
+ * team first.
+ */
+@Internal
+public final class InternalCronetCallOptions {
+
+  // Prevent instantiation
+  private InternalCronetCallOptions() {}
+
+  public static CallOptions withAnnotation(CallOptions callOptions, Object annotation) {
+    return CronetClientStream.withAnnotation(callOptions, annotation);
+  }
+
+  /**
+   * Returns Cronet annotations for gRPC included in the given {@code callOptions}. Annotations
+   * are attached via {@link #withAnnotation(CallOptions, Object)}.
+   */
+  public static Collection<Object> getAnnotations(CallOptions callOptions) {
+    Collection<Object> annotations =
+        callOptions.getOption(CronetClientStream.CRONET_ANNOTATIONS_KEY);
+    if (annotations == null) {
+      annotations = Collections.emptyList();
+    }
+    return annotations;
+  }
+}
diff --git a/cronet/src/main/java/io/grpc/cronet/InternalCronetChannelBuilder.java b/cronet/src/main/java/io/grpc/cronet/InternalCronetChannelBuilder.java
new file mode 100644
index 00000000000..7e5e610ca67
--- /dev/null
+++ b/cronet/src/main/java/io/grpc/cronet/InternalCronetChannelBuilder.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2019 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.cronet;
+
+import android.net.Network;
+import io.grpc.Internal;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+/**
+ * Internal {@link CronetChannelBuilder} accessor. This is intended for usage internal to the gRPC
+ * team. If you *really* think you need to use this, contact the gRPC team first.
+ */
+@Internal
+public final class InternalCronetChannelBuilder {
+
+  // Prevent instantiation
+  private InternalCronetChannelBuilder() {}
+
+  /**
+   * Sets {@link android.net.TrafficStats} tag to use when accounting socket traffic caused by this
+   * channel. See {@link android.net.TrafficStats} for more information. If no tag is set (e.g. this
+   * method isn't called), then Android accounts for the socket traffic caused by this channel as if
+   * the tag value were set to 0.
+   *
+   * <p><b>NOTE:</b>Setting a tag disallows sharing of sockets with channels with other tags, which
+   * may adversely effect performance by prohibiting connection sharing. In other words use of
+   * multiplexed sockets (e.g. HTTP/2 and QUIC) will only be allowed if all channels have the same
+   * socket tag.
+   */
+  public static void setTrafficStatsTag(CronetChannelBuilder builder, int tag) {
+    builder.setTrafficStatsTag(tag);
+  }
+
+  /**
+   * Sets specific UID to use when accounting socket traffic caused by this channel. See {@link
+   * android.net.TrafficStats} for more information. Designed for use when performing an operation
+   * on behalf of another application. Caller must hold {@link
+   * android.Manifest.permission#UPDATE_DEVICE_STATS} permission. By default traffic is
+   * attributed to UID of caller.
+   *
+   * <p><b>NOTE:</b>Setting a UID disallows sharing of sockets with channels with other UIDs, which
+   * may adversely effect performance by prohibiting connection sharing. In other words use of
+   * multiplexed sockets (e.g. HTTP/2 and QUIC) will only be allowed if all channels have the same
+   * UID set.
+   */
+  public static void setTrafficStatsUid(CronetChannelBuilder builder, int uid) {
+    builder.setTrafficStatsUid(uid);
+  }
+
+  /** Sets the network {@link android.net.Network} to use when relying traffic by this channel. */
+  public static void bindToNetwork(CronetChannelBuilder builder, @Nullable Network network) {
+    builder.bindToNetwork(network);
+  }
+}
diff --git a/cronet/src/test/java/io/grpc/cronet/CronetChannelBuilderTest.java b/cronet/src/test/java/io/grpc/cronet/CronetChannelBuilderTest.java
new file mode 100644
index 00000000000..41f48bc03bb
--- /dev/null
+++ b/cronet/src/test/java/io/grpc/cronet/CronetChannelBuilderTest.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2016 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.cronet;
+
+import static io.grpc.internal.GrpcUtil.TIMER_SERVICE;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+
+import android.os.Build;
+import io.grpc.CallOptions;
+import io.grpc.ChannelLogger;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.cronet.CronetChannelBuilder.CronetTransportFactory;
+import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.ClientTransportFactory.ClientTransportOptions;
+import io.grpc.internal.SharedResourceHolder;
+import io.grpc.testing.TestMethodDescriptors;
+import java.net.InetSocketAddress;
+import java.util.concurrent.ScheduledExecutorService;
+import org.chromium.net.CronetEngine;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = Build.VERSION_CODES.P)
+public final class CronetChannelBuilderTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock private CronetEngine mockEngine;
+  @Mock private ChannelLogger channelLogger;
+
+  private final ClientStreamTracer[] tracers =
+      new ClientStreamTracer[]{ new ClientStreamTracer() {} };
+  private MethodDescriptor<?, ?> method = TestMethodDescriptors.voidMethod();
+
+  @Test
+  public void alwaysUsePutTrue_cronetStreamIsIdempotent() throws Exception {
+    CronetChannelBuilder builder =
+        CronetChannelBuilder.forAddress("address", 1234, mockEngine).alwaysUsePut(true);
+    CronetTransportFactory transportFactory =
+        (CronetTransportFactory) builder.buildTransportFactory();
+    CronetClientTransport transport =
+        (CronetClientTransport)
+            transportFactory.newClientTransport(
+                new InetSocketAddress("localhost", 443),
+                new ClientTransportOptions(),
+                channelLogger);
+    CronetClientStream stream = transport.newStream(
+        method, new Metadata(), CallOptions.DEFAULT, tracers);
+
+    assertTrue(stream.idempotent);
+  }
+
+  @Test
+  public void alwaysUsePut_defaultsToFalse() throws Exception {
+    CronetChannelBuilder builder = CronetChannelBuilder.forAddress("address", 1234, mockEngine);
+    CronetTransportFactory transportFactory =
+        (CronetTransportFactory) builder.buildTransportFactory();
+    CronetClientTransport transport =
+        (CronetClientTransport)
+            transportFactory.newClientTransport(
+                new InetSocketAddress("localhost", 443),
+                new ClientTransportOptions(),
+                channelLogger);
+    CronetClientStream stream = transport.newStream(
+        method, new Metadata(), CallOptions.DEFAULT, tracers);
+
+    assertFalse(stream.idempotent);
+  }
+
+  @Test
+  public void scheduledExecutorService_default() {
+    CronetChannelBuilder builder = CronetChannelBuilder.forAddress("address", 1234, mockEngine);
+    ClientTransportFactory clientTransportFactory = builder.buildTransportFactory();
+    assertSame(
+        SharedResourceHolder.get(TIMER_SERVICE),
+        clientTransportFactory.getScheduledExecutorService());
+
+    SharedResourceHolder.release(
+        TIMER_SERVICE, clientTransportFactory.getScheduledExecutorService());
+    clientTransportFactory.close();
+  }
+
+  @Test
+  public void scheduledExecutorService_custom() {
+    CronetChannelBuilder builder = CronetChannelBuilder.forAddress("address", 1234, mockEngine);
+    ScheduledExecutorService scheduledExecutorService = mock(ScheduledExecutorService.class);
+
+    CronetChannelBuilder builder1 = builder.scheduledExecutorService(scheduledExecutorService);
+    assertSame(builder, builder1);
+
+    ClientTransportFactory clientTransportFactory = builder1.buildTransportFactory();
+    assertSame(scheduledExecutorService, clientTransportFactory.getScheduledExecutorService());
+
+    clientTransportFactory.close();
+  }
+}
diff --git a/cronet/src/test/java/io/grpc/cronet/CronetClientStreamTest.java b/cronet/src/test/java/io/grpc/cronet/CronetClientStreamTest.java
new file mode 100644
index 00000000000..e2b0e0b26ca
--- /dev/null
+++ b/cronet/src/test/java/io/grpc/cronet/CronetClientStreamTest.java
@@ -0,0 +1,814 @@
+/*
+ * Copyright 2016 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.cronet;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.os.Build;
+import com.google.common.io.BaseEncoding;
+import io.grpc.CallOptions;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.grpc.cronet.CronetChannelBuilder.StreamBuilderFactory;
+import io.grpc.internal.ClientStreamListener;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.StreamListener.MessageProducer;
+import io.grpc.internal.TransportTracer;
+import io.grpc.internal.WritableBuffer;
+import io.grpc.testing.TestMethodDescriptors;
+import java.io.ByteArrayInputStream;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import org.chromium.net.BidirectionalStream;
+import org.chromium.net.CronetException;
+import org.chromium.net.UrlResponseInfo;
+import org.chromium.net.impl.UrlResponseInfoImpl;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = Build.VERSION_CODES.P)
+public final class CronetClientStreamTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock private CronetClientTransport transport;
+  private Metadata metadata = new Metadata();
+  @Mock private StreamBuilderFactory factory;
+  @Mock private BidirectionalStream cronetStream;
+  @Mock private ClientStreamListener clientListener;
+  @Mock private BidirectionalStream.Builder builder;
+  private final Object lock = new Object();
+  private final TransportTracer transportTracer = TransportTracer.getDefaultFactory().create();
+  private final Executor executor = Runnable::run;
+  CronetClientStream clientStream;
+
+  private MethodDescriptor.Marshaller<Void> marshaller = TestMethodDescriptors.voidMarshaller();
+
+  private MethodDescriptor<?, ?> method = TestMethodDescriptors.voidMethod();
+
+  private static class SetStreamFactoryRunnable implements Runnable {
+    private final StreamBuilderFactory factory;
+    private CronetClientStream stream;
+
+    SetStreamFactoryRunnable(StreamBuilderFactory factory) {
+      this.factory = factory;
+    }
+
+    void setStream(CronetClientStream stream) {
+      this.stream = stream;
+    }
+
+    @Override
+    @SuppressWarnings("GuardedBy")
+    public void run() {
+      assertNotNull(stream);
+      stream.transportState().start(factory);
+    }
+  }
+
+  @Before
+  public void setUp() {
+    SetStreamFactoryRunnable callback = new SetStreamFactoryRunnable(factory);
+    clientStream =
+        new CronetClientStream(
+            "https://www.google.com:443",
+            "cronet",
+            executor,
+            metadata,
+            transport,
+            callback,
+            lock,
+            100,
+            false /* alwaysUsePut */,
+            method,
+            StatsTraceContext.NOOP,
+            CallOptions.DEFAULT,
+            transportTracer,
+            false,
+            false);
+    callback.setStream(clientStream);
+    when(factory.newBidirectionalStreamBuilder(
+            any(String.class), any(BidirectionalStream.Callback.class), any(Executor.class)))
+        .thenReturn(builder);
+    when(builder.build()).thenReturn(cronetStream);
+    clientStream.start(clientListener);
+  }
+
+  @Test
+  public void startStream() {
+    verify(factory)
+        .newBidirectionalStreamBuilder(
+            eq("https://www.google.com:443"),
+            isA(BidirectionalStream.Callback.class),
+            eq(executor));
+    verify(builder).build();
+    // At least content type and trailer headers are set.
+    verify(builder, atLeast(2)).addHeader(isA(String.class), isA(String.class));
+    // addRequestAnnotation should only be called when we explicitly add the CRONET_ANNOTATION_KEY
+    // to CallOptions.
+    verify(builder, times(0)).addRequestAnnotation(isA(Object.class));
+    verify(builder, times(0)).setHttpMethod(any(String.class));
+    verify(cronetStream).start();
+  }
+
+  @Test
+  public void write() {
+    ArgumentCaptor<BidirectionalStream.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(BidirectionalStream.Callback.class);
+    verify(factory)
+        .newBidirectionalStreamBuilder(
+            isA(String.class), callbackCaptor.capture(), isA(Executor.class));
+    BidirectionalStream.Callback callback = callbackCaptor.getValue();
+
+    // Create 5 frames to send.
+    CronetWritableBufferAllocator allocator = new CronetWritableBufferAllocator();
+    String[] requests = new String[5];
+    WritableBuffer[] buffers = new WritableBuffer[5];
+    for (int i = 0; i < 5; ++i) {
+      requests[i] = "request" + i;
+      buffers[i] = allocator.allocate(requests[i].length());
+      buffers[i].write(requests[i].getBytes(StandardCharsets.UTF_8), 0, requests[i].length());
+      // The 3rd and 5th writeFrame calls have flush=true.
+      clientStream.abstractClientStreamSink().writeFrame(buffers[i], false, i == 2 || i == 4, 1);
+    }
+    // BidirectionalStream.write is not called because stream is not ready yet.
+    verify(cronetStream, times(0)).write(isA(ByteBuffer.class), isA(Boolean.class));
+
+    // Stream is ready.
+    callback.onStreamReady(cronetStream);
+    // 5 writes are called.
+    verify(cronetStream, times(5)).write(isA(ByteBuffer.class), eq(false));
+    ByteBuffer fakeBuffer = ByteBuffer.allocateDirect(8);
+    ((Buffer) fakeBuffer).position(8);
+    verify(cronetStream, times(2)).flush();
+
+    // 5 onWriteCompleted callbacks for previous writes.
+    callback.onWriteCompleted(cronetStream, null, fakeBuffer, false);
+    callback.onWriteCompleted(cronetStream, null, fakeBuffer, false);
+    callback.onWriteCompleted(cronetStream, null, fakeBuffer, false);
+    callback.onWriteCompleted(cronetStream, null, fakeBuffer, false);
+    callback.onWriteCompleted(cronetStream, null, fakeBuffer, false);
+
+    // All pending data has been sent. onWriteCompleted callback will not trigger any additional
+    // write call.
+    verify(cronetStream, times(5)).write(isA(ByteBuffer.class), eq(false));
+
+    // Send end of stream. write will be immediately called since stream is ready.
+    clientStream.abstractClientStreamSink().writeFrame(null, true, true, 1);
+    verify(cronetStream, times(1)).write(isA(ByteBuffer.class), eq(true));
+    verify(cronetStream, times(3)).flush();
+  }
+
+  private static List<Map.Entry<String, String>> responseHeader(String status) {
+    Map<String, String> headers = new HashMap<>();
+    headers.put(":status", status);
+    headers.put("content-type", "application/grpc");
+    headers.put("test-key", "test-value");
+    return new ArrayList<>(headers.entrySet());
+  }
+
+  private static List<Map.Entry<String, String>> trailers(int status) {
+    Map<String, String> trailers = new HashMap<>();
+    trailers.put("grpc-status", String.valueOf(status));
+    trailers.put("content-type", "application/grpc");
+    trailers.put("test-trailer-key", "test-trailer-value");
+    return new ArrayList<>(trailers.entrySet());
+  }
+
+  private static ByteBuffer createMessageFrame(byte[] bytes) {
+    ByteBuffer buffer = ByteBuffer.allocate(1 + 4 + bytes.length);
+    buffer.put((byte) 0 /* UNCOMPRESSED */);
+    buffer.putInt(bytes.length);
+    buffer.put(bytes);
+    return buffer;
+  }
+
+  @Test
+  public void read() {
+    ArgumentCaptor<BidirectionalStream.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(BidirectionalStream.Callback.class);
+    verify(factory)
+        .newBidirectionalStreamBuilder(
+            isA(String.class), callbackCaptor.capture(), isA(Executor.class));
+    BidirectionalStream.Callback callback = callbackCaptor.getValue();
+
+    // Read is not called until we receive the response header.
+    verify(cronetStream, times(0)).read(isA(ByteBuffer.class));
+    UrlResponseInfo info =
+        new UrlResponseInfoImpl(
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
+    callback.onResponseHeadersReceived(cronetStream, info);
+    verify(cronetStream, times(1)).read(isA(ByteBuffer.class));
+    ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
+    verify(clientListener).headersRead(metadataCaptor.capture());
+    // Verify recevied headers.
+    Metadata metadata = metadataCaptor.getValue();
+    assertEquals(
+        "application/grpc",
+        metadata.get(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER)));
+    assertEquals(
+        "test-value", metadata.get(Metadata.Key.of("test-key", Metadata.ASCII_STRING_MARSHALLER)));
+
+    callback.onReadCompleted(
+        cronetStream,
+        info,
+        createMessageFrame("response1".getBytes(StandardCharsets.UTF_8)),
+        false);
+    // Haven't request any message, so no callback is called here.
+    verify(clientListener, times(0)).messagesAvailable(isA(MessageProducer.class));
+    verify(cronetStream, times(1)).read(isA(ByteBuffer.class));
+    // Request one message
+    clientStream.request(1);
+    verify(clientListener, times(1)).messagesAvailable(isA(MessageProducer.class));
+    verify(cronetStream, times(2)).read(isA(ByteBuffer.class));
+
+    // BidirectionalStream.read will not be called again after receiving endOfStream(empty buffer).
+    clientStream.request(1);
+    callback.onReadCompleted(cronetStream, info, ByteBuffer.allocate(0), true);
+    verify(clientListener, times(1)).messagesAvailable(isA(MessageProducer.class));
+    verify(cronetStream, times(2)).read(isA(ByteBuffer.class));
+  }
+
+  @Test
+  public void streamSucceeded() {
+    ArgumentCaptor<BidirectionalStream.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(BidirectionalStream.Callback.class);
+    verify(factory)
+        .newBidirectionalStreamBuilder(
+            isA(String.class), callbackCaptor.capture(), isA(Executor.class));
+    BidirectionalStream.Callback callback = callbackCaptor.getValue();
+
+    callback.onStreamReady(cronetStream);
+    verify(cronetStream, times(0)).write(isA(ByteBuffer.class), isA(Boolean.class));
+    // Send the first data frame.
+    CronetWritableBufferAllocator allocator = new CronetWritableBufferAllocator();
+    String request = "request";
+    WritableBuffer writableBuffer = allocator.allocate(request.length());
+    writableBuffer.write(request.getBytes(StandardCharsets.UTF_8), 0, request.length());
+    clientStream.abstractClientStreamSink().writeFrame(writableBuffer, false, true, 1);
+    ArgumentCaptor<ByteBuffer> bufferCaptor = ArgumentCaptor.forClass(ByteBuffer.class);
+    verify(cronetStream, times(1)).write(bufferCaptor.capture(), isA(Boolean.class));
+    ByteBuffer buffer = bufferCaptor.getValue();
+    ((Buffer) buffer).position(request.length());
+    verify(cronetStream, times(1)).flush();
+
+    // Receive response header
+    clientStream.request(2);
+    UrlResponseInfo info =
+        new UrlResponseInfoImpl(
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
+    callback.onResponseHeadersReceived(cronetStream, info);
+    verify(cronetStream, times(1)).read(isA(ByteBuffer.class));
+    // Receive one message
+    callback.onReadCompleted(
+        cronetStream,
+        info,
+        createMessageFrame("response".getBytes(StandardCharsets.UTF_8)),
+        false);
+    verify(clientListener, times(1)).messagesAvailable(isA(MessageProducer.class));
+    verify(cronetStream, times(2)).read(isA(ByteBuffer.class));
+
+    // Send endOfStream
+    callback.onWriteCompleted(cronetStream, null, buffer, false);
+    clientStream.abstractClientStreamSink().writeFrame(null, true, true, 1);
+    verify(cronetStream, times(2)).write(isA(ByteBuffer.class), isA(Boolean.class));
+    verify(cronetStream, times(2)).flush();
+
+    // Receive trailer
+    ((CronetClientStream.BidirectionalStreamCallback) callback).processTrailers(trailers(0));
+    callback.onSucceeded(cronetStream, info);
+
+    // Verify trailer
+    ArgumentCaptor<Metadata> trailerCaptor = ArgumentCaptor.forClass(Metadata.class);
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(clientListener)
+        .closed(statusCaptor.capture(), isA(RpcProgress.class), trailerCaptor.capture());
+    // Verify recevied headers.
+    Metadata trailers = trailerCaptor.getValue();
+    Status status = statusCaptor.getValue();
+    assertEquals(
+        "test-trailer-value",
+        trailers.get(Metadata.Key.of("test-trailer-key", Metadata.ASCII_STRING_MARSHALLER)));
+    assertEquals(
+        "application/grpc",
+        trailers.get(Metadata.Key.of("content-type", Metadata.ASCII_STRING_MARSHALLER)));
+    assertTrue(status.isOk());
+  }
+
+  @Test
+  public void streamSucceededWithGrpcError() {
+    ArgumentCaptor<BidirectionalStream.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(BidirectionalStream.Callback.class);
+    verify(factory)
+        .newBidirectionalStreamBuilder(
+            isA(String.class), callbackCaptor.capture(), isA(Executor.class));
+    BidirectionalStream.Callback callback = callbackCaptor.getValue();
+
+    callback.onStreamReady(cronetStream);
+    verify(cronetStream, times(0)).write(isA(ByteBuffer.class), isA(Boolean.class));
+    clientStream.abstractClientStreamSink().writeFrame(null, true, true, 1);
+    verify(cronetStream, times(1)).write(isA(ByteBuffer.class), isA(Boolean.class));
+    verify(cronetStream, times(1)).flush();
+
+    // Receive response header
+    clientStream.request(2);
+    UrlResponseInfo info =
+        new UrlResponseInfoImpl(
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
+    callback.onResponseHeadersReceived(cronetStream, info);
+    verify(cronetStream, times(1)).read(isA(ByteBuffer.class));
+
+    // Receive trailer
+    callback.onReadCompleted(cronetStream, null, ByteBuffer.allocate(0), true);
+    ((CronetClientStream.BidirectionalStreamCallback) callback)
+        .processTrailers(trailers(Status.PERMISSION_DENIED.getCode().value()));
+    callback.onSucceeded(cronetStream, info);
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(clientListener)
+        .closed(statusCaptor.capture(), isA(RpcProgress.class), isA(Metadata.class));
+    // Verify error status.
+    Status status = statusCaptor.getValue();
+    assertFalse(status.isOk());
+    assertEquals(Status.PERMISSION_DENIED.getCode(), status.getCode());
+  }
+
+  @Test
+  public void streamFailed() {
+    ArgumentCaptor<BidirectionalStream.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(BidirectionalStream.Callback.class);
+    verify(factory)
+        .newBidirectionalStreamBuilder(
+            isA(String.class), callbackCaptor.capture(), isA(Executor.class));
+    BidirectionalStream.Callback callback = callbackCaptor.getValue();
+
+    // Nothing happens and stream fails
+
+    CronetException exception = mock(CronetException.class);
+    callback.onFailed(cronetStream, null, exception);
+    verify(transport).finishStream(eq(clientStream), isA(Status.class));
+    // finishStream calls transportReportStatus.
+    clientStream.transportState().transportReportStatus(Status.UNAVAILABLE, false, new Metadata());
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(clientListener)
+        .closed(statusCaptor.capture(), isA(RpcProgress.class), isA(Metadata.class));
+    Status status = statusCaptor.getValue();
+    assertEquals(Status.UNAVAILABLE.getCode(), status.getCode());
+  }
+
+  @Test
+  public void streamFailedAfterResponseHeaderReceived() {
+    ArgumentCaptor<BidirectionalStream.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(BidirectionalStream.Callback.class);
+    verify(factory)
+        .newBidirectionalStreamBuilder(
+            isA(String.class), callbackCaptor.capture(), isA(Executor.class));
+    BidirectionalStream.Callback callback = callbackCaptor.getValue();
+
+    // Receive response header
+    UrlResponseInfo info =
+        new UrlResponseInfoImpl(
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
+    callback.onResponseHeadersReceived(cronetStream, info);
+
+    CronetException exception = mock(CronetException.class);
+    callback.onFailed(cronetStream, info, exception);
+    verify(transport).finishStream(eq(clientStream), isA(Status.class));
+    // finishStream calls transportReportStatus.
+    clientStream.transportState().transportReportStatus(Status.UNAVAILABLE, false, new Metadata());
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(clientListener)
+        .closed(statusCaptor.capture(), isA(RpcProgress.class), isA(Metadata.class));
+    Status status = statusCaptor.getValue();
+    assertEquals(Status.UNAVAILABLE.getCode(), status.getCode());
+  }
+
+  @Test
+  public void streamFailedAfterTrailerReceived() {
+    ArgumentCaptor<BidirectionalStream.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(BidirectionalStream.Callback.class);
+    verify(factory)
+        .newBidirectionalStreamBuilder(
+            isA(String.class), callbackCaptor.capture(), isA(Executor.class));
+    BidirectionalStream.Callback callback = callbackCaptor.getValue();
+
+    // Receive response header
+    UrlResponseInfo info =
+        new UrlResponseInfoImpl(
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
+    callback.onResponseHeadersReceived(cronetStream, info);
+
+    // Report trailer but not endOfStream.
+    ((CronetClientStream.BidirectionalStreamCallback) callback).processTrailers(trailers(0));
+
+    CronetException exception = mock(CronetException.class);
+    callback.onFailed(cronetStream, info, exception);
+    verify(transport).finishStream(eq(clientStream), isA(Status.class));
+    // finishStream calls transportReportStatus.
+    clientStream.transportState().transportReportStatus(Status.UNAVAILABLE, false, new Metadata());
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(clientListener)
+        .closed(statusCaptor.capture(), isA(RpcProgress.class), isA(Metadata.class));
+    Status status = statusCaptor.getValue();
+    // Stream has already finished so OK status should be reported.
+    assertEquals(Status.UNAVAILABLE.getCode(), status.getCode());
+  }
+
+  @Test
+  public void streamFailedAfterTrailerAndEndOfStreamReceived() {
+    ArgumentCaptor<BidirectionalStream.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(BidirectionalStream.Callback.class);
+    verify(factory)
+        .newBidirectionalStreamBuilder(
+            isA(String.class), callbackCaptor.capture(), isA(Executor.class));
+    BidirectionalStream.Callback callback = callbackCaptor.getValue();
+
+    // Receive response header
+    UrlResponseInfo info =
+        new UrlResponseInfoImpl(
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
+    callback.onResponseHeadersReceived(cronetStream, info);
+
+    // Report trailer and endOfStream
+    callback.onReadCompleted(cronetStream, null, ByteBuffer.allocate(0), true);
+    ((CronetClientStream.BidirectionalStreamCallback) callback).processTrailers(trailers(0));
+
+    CronetException exception = mock(CronetException.class);
+    callback.onFailed(cronetStream, info, exception);
+    verify(transport).finishStream(eq(clientStream), isA(Status.class));
+    // finishStream calls transportReportStatus.
+    clientStream.transportState().transportReportStatus(Status.UNAVAILABLE, false, new Metadata());
+
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(clientListener)
+        .closed(statusCaptor.capture(), isA(RpcProgress.class), isA(Metadata.class));
+    Status status = statusCaptor.getValue();
+    // Stream has already finished so OK status should be reported.
+    assertEquals(Status.OK.getCode(), status.getCode());
+  }
+
+  @Test
+  public void cancelStream() {
+    ArgumentCaptor<BidirectionalStream.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(BidirectionalStream.Callback.class);
+    verify(factory)
+        .newBidirectionalStreamBuilder(
+            isA(String.class), callbackCaptor.capture(), isA(Executor.class));
+    BidirectionalStream.Callback callback = callbackCaptor.getValue();
+
+    // Cancel the stream
+    clientStream.cancel(Status.DEADLINE_EXCEEDED);
+    verify(transport, times(0)).finishStream(eq(clientStream), isA(Status.class));
+
+    callback.onCanceled(cronetStream, null);
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(transport, times(1)).finishStream(eq(clientStream), statusCaptor.capture());
+    Status status = statusCaptor.getValue();
+    assertEquals(Status.DEADLINE_EXCEEDED.getCode(), status.getCode());
+  }
+
+  @Test
+  public void reportTrailersWhenTrailersReceivedBeforeReadClosed() {
+    ArgumentCaptor<BidirectionalStream.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(BidirectionalStream.Callback.class);
+    verify(factory)
+        .newBidirectionalStreamBuilder(
+            isA(String.class), callbackCaptor.capture(), isA(Executor.class));
+    BidirectionalStream.Callback callback = callbackCaptor.getValue();
+
+    callback.onStreamReady(cronetStream);
+    UrlResponseInfo info =
+        new UrlResponseInfoImpl(
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
+    callback.onResponseHeadersReceived(cronetStream, info);
+    // Receive trailer first
+    ((CronetClientStream.BidirectionalStreamCallback) callback)
+        .processTrailers(trailers(Status.UNAUTHENTICATED.getCode().value()));
+    verify(clientListener, times(0))
+        .closed(isA(Status.class), isA(RpcProgress.class), isA(Metadata.class));
+
+    // Receive cronet's endOfStream
+    callback.onReadCompleted(cronetStream, null, ByteBuffer.allocate(0), true);
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(clientListener, times(1))
+        .closed(statusCaptor.capture(), isA(RpcProgress.class), isA(Metadata.class));
+    Status status = statusCaptor.getValue();
+    assertEquals(Status.UNAUTHENTICATED.getCode(), status.getCode());
+  }
+
+  @Test
+  public void reportTrailersWhenTrailersReceivedAfterReadClosed() {
+    ArgumentCaptor<BidirectionalStream.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(BidirectionalStream.Callback.class);
+    verify(factory)
+        .newBidirectionalStreamBuilder(
+            isA(String.class), callbackCaptor.capture(), isA(Executor.class));
+    BidirectionalStream.Callback callback = callbackCaptor.getValue();
+
+    callback.onStreamReady(cronetStream);
+    UrlResponseInfo info =
+        new UrlResponseInfoImpl(
+            new ArrayList<>(), 200, "", responseHeader("200"), false, "", "", 0);
+    callback.onResponseHeadersReceived(cronetStream, info);
+    // Receive cronet's endOfStream
+    callback.onReadCompleted(cronetStream, null, ByteBuffer.allocate(0), true);
+    verify(clientListener, times(0))
+        .closed(isA(Status.class), isA(RpcProgress.class), isA(Metadata.class));
+
+    // Receive trailer
+    ((CronetClientStream.BidirectionalStreamCallback) callback)
+        .processTrailers(trailers(Status.UNAUTHENTICATED.getCode().value()));
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(clientListener, times(1))
+        .closed(statusCaptor.capture(), isA(RpcProgress.class), isA(Metadata.class));
+    Status status = statusCaptor.getValue();
+    assertEquals(Status.UNAUTHENTICATED.getCode(), status.getCode());
+  }
+
+  @SuppressWarnings("deprecation")
+  @Test
+  public void addCronetRequestAnnotation_deprecated() {
+    Object annotation = new Object();
+    SetStreamFactoryRunnable callback = new SetStreamFactoryRunnable(factory);
+    CronetClientStream stream =
+        new CronetClientStream(
+            "https://www.google.com:443",
+            "cronet",
+            executor,
+            metadata,
+            transport,
+            callback,
+            lock,
+            100,
+            false /* alwaysUsePut */,
+            method,
+            StatsTraceContext.NOOP,
+            CallOptions.DEFAULT.withOption(CronetClientStream.CRONET_ANNOTATION_KEY, annotation),
+            transportTracer,
+            false,
+            false);
+    callback.setStream(stream);
+    when(factory.newBidirectionalStreamBuilder(
+            any(String.class), any(BidirectionalStream.Callback.class), any(Executor.class)))
+        .thenReturn(builder);
+    stream.start(clientListener);
+
+    // addRequestAnnotation should be called since we add the option CRONET_ANNOTATION_KEY above.
+    verify(builder).addRequestAnnotation(annotation);
+  }
+
+  @Test
+  public void withAnnotation() {
+    Object annotation1 = new Object();
+    Object annotation2 = new Object();
+    CallOptions callOptions = CronetClientStream.withAnnotation(CallOptions.DEFAULT, annotation1);
+    callOptions = CronetClientStream.withAnnotation(callOptions, annotation2);
+
+    SetStreamFactoryRunnable callback = new SetStreamFactoryRunnable(factory);
+    CronetClientStream stream =
+        new CronetClientStream(
+            "https://www.google.com:443",
+            "cronet",
+            executor,
+            metadata,
+            transport,
+            callback,
+            lock,
+            100,
+            false /* alwaysUsePut */,
+            method,
+            StatsTraceContext.NOOP,
+            callOptions,
+            transportTracer,
+            false,
+            false);
+    callback.setStream(stream);
+    when(factory.newBidirectionalStreamBuilder(
+            any(String.class), any(BidirectionalStream.Callback.class), any(Executor.class)))
+        .thenReturn(builder);
+    stream.start(clientListener);
+
+    verify(builder).addRequestAnnotation(annotation1);
+    verify(builder).addRequestAnnotation(annotation2);
+  }
+
+  @Test
+  public void getUnaryRequest() {
+    StreamBuilderFactory getFactory = mock(StreamBuilderFactory.class);
+    MethodDescriptor<?, ?> getMethod =
+        MethodDescriptor.<Void, Void>newBuilder()
+            .setType(MethodDescriptor.MethodType.UNARY)
+            .setFullMethodName("/service/method")
+            .setIdempotent(true)
+            .setSafe(true)
+            .setRequestMarshaller(marshaller)
+            .setResponseMarshaller(marshaller)
+            .build();
+    SetStreamFactoryRunnable callback = new SetStreamFactoryRunnable(getFactory);
+    CronetClientStream stream =
+        new CronetClientStream(
+            "https://www.google.com/service/method",
+            "cronet",
+            executor,
+            metadata,
+            transport,
+            callback,
+            lock,
+            100,
+            false /* alwaysUsePut */,
+            getMethod,
+            StatsTraceContext.NOOP,
+            CallOptions.DEFAULT,
+            transportTracer,
+            true,
+            false);
+    callback.setStream(stream);
+    BidirectionalStream.Builder getBuilder =
+        mock(BidirectionalStream.Builder.class);
+    when(getFactory.newBidirectionalStreamBuilder(
+            any(String.class), any(BidirectionalStream.Callback.class), any(Executor.class)))
+        .thenReturn(getBuilder);
+    when(getBuilder.build()).thenReturn(cronetStream);
+    stream.start(clientListener);
+
+    // We will not create BidirectionalStream until we have the full request.
+    verify(getFactory, times(0))
+        .newBidirectionalStreamBuilder(
+            isA(String.class), isA(BidirectionalStream.Callback.class), isA(Executor.class));
+
+    byte[] msg = "request".getBytes(StandardCharsets.UTF_8);
+    stream.writeMessage(new ByteArrayInputStream(msg));
+    // We still haven't built the stream or sent anything.
+    verify(cronetStream, times(0)).write(isA(ByteBuffer.class), isA(Boolean.class));
+    verify(getFactory, times(0))
+        .newBidirectionalStreamBuilder(
+            isA(String.class), isA(BidirectionalStream.Callback.class), isA(Executor.class));
+
+    // halfClose will trigger sending.
+    stream.halfClose();
+
+    // Stream should be built with request payload in the header.
+    ArgumentCaptor<String> urlCaptor = ArgumentCaptor.forClass(String.class);
+    verify(getFactory)
+        .newBidirectionalStreamBuilder(
+            urlCaptor.capture(), isA(BidirectionalStream.Callback.class), isA(Executor.class));
+    verify(getBuilder).setHttpMethod("GET");
+    assertEquals(
+        "https://www.google.com/service/method?" + BaseEncoding.base64().encode(msg),
+        urlCaptor.getValue());
+  }
+
+  @Test
+  public void idempotentMethod_usesHttpPut() {
+    SetStreamFactoryRunnable callback = new SetStreamFactoryRunnable(factory);
+    MethodDescriptor<?, ?> idempotentMethod = method.toBuilder().setIdempotent(true).build();
+    CronetClientStream stream =
+        new CronetClientStream(
+            "https://www.google.com:443",
+            "cronet",
+            executor,
+            metadata,
+            transport,
+            callback,
+            lock,
+            100,
+            false /* alwaysUsePut */,
+            idempotentMethod,
+            StatsTraceContext.NOOP,
+            CallOptions.DEFAULT,
+            transportTracer,
+            true,
+            true);
+    callback.setStream(stream);
+    BidirectionalStream.Builder builder =
+        mock(BidirectionalStream.Builder.class);
+    when(factory.newBidirectionalStreamBuilder(
+            any(String.class), any(BidirectionalStream.Callback.class), any(Executor.class)))
+        .thenReturn(builder);
+    when(builder.build()).thenReturn(cronetStream);
+    stream.start(clientListener);
+
+    verify(builder).setHttpMethod("PUT");
+  }
+
+  @Test
+  public void alwaysUsePutOption_usesHttpPut() {
+    SetStreamFactoryRunnable callback = new SetStreamFactoryRunnable(factory);
+    CronetClientStream stream =
+        new CronetClientStream(
+            "https://www.google.com:443",
+            "cronet",
+            executor,
+            metadata,
+            transport,
+            callback,
+            lock,
+            100,
+            true /* alwaysUsePut */,
+            method,
+            StatsTraceContext.NOOP,
+            CallOptions.DEFAULT,
+            transportTracer,
+            true,
+            true);
+    callback.setStream(stream);
+    BidirectionalStream.Builder builder =
+        mock(BidirectionalStream.Builder.class);
+    when(factory.newBidirectionalStreamBuilder(
+            any(String.class), any(BidirectionalStream.Callback.class), any(Executor.class)))
+        .thenReturn(builder);
+    when(builder.build()).thenReturn(cronetStream);
+    stream.start(clientListener);
+
+    verify(builder).setHttpMethod("PUT");
+  }
+
+  @Test
+  public void reservedHeadersStripped() {
+    String userAgent = "cronet";
+    Metadata headers = new Metadata();
+    Metadata.Key<String> userKey = Metadata.Key.of("user-key", Metadata.ASCII_STRING_MARSHALLER);
+    headers.put(GrpcUtil.CONTENT_TYPE_KEY, "to-be-removed");
+    headers.put(GrpcUtil.USER_AGENT_KEY, "to-be-removed");
+    headers.put(GrpcUtil.TE_HEADER, "to-be-removed");
+    headers.put(userKey, "user-value");
+
+    SetStreamFactoryRunnable callback = new SetStreamFactoryRunnable(factory);
+    CronetClientStream stream =
+        new CronetClientStream(
+            "https://www.google.com:443",
+            userAgent,
+            executor,
+            headers,
+            transport,
+            callback,
+            lock,
+            100,
+            false /* alwaysUsePut */,
+            method,
+            StatsTraceContext.NOOP,
+            CallOptions.DEFAULT,
+            transportTracer,
+            false,
+            false);
+    callback.setStream(stream);
+    BidirectionalStream.Builder builder =
+        mock(BidirectionalStream.Builder.class);
+    when(factory.newBidirectionalStreamBuilder(
+            any(String.class), any(BidirectionalStream.Callback.class), any(Executor.class)))
+        .thenReturn(builder);
+    when(builder.build()).thenReturn(cronetStream);
+    stream.start(clientListener);
+
+    verify(builder, times(4)).addHeader(any(String.class), any(String.class));
+    verify(builder).addHeader(GrpcUtil.USER_AGENT_KEY.name(), userAgent);
+    verify(builder).addHeader(GrpcUtil.CONTENT_TYPE_KEY.name(), GrpcUtil.CONTENT_TYPE_GRPC);
+    verify(builder).addHeader("te", GrpcUtil.TE_TRAILERS);
+    verify(builder).addHeader(userKey.name(), "user-value");
+  }
+}
diff --git a/cronet/src/test/java/io/grpc/cronet/CronetClientTransportTest.java b/cronet/src/test/java/io/grpc/cronet/CronetClientTransportTest.java
new file mode 100644
index 00000000000..3a79cc0b6a8
--- /dev/null
+++ b/cronet/src/test/java/io/grpc/cronet/CronetClientTransportTest.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright 2016 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.cronet;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.os.Build;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.SecurityLevel;
+import io.grpc.Status;
+import io.grpc.cronet.CronetChannelBuilder.StreamBuilderFactory;
+import io.grpc.internal.ClientStreamListener;
+import io.grpc.internal.DisconnectError;
+import io.grpc.internal.GrpcAttributes;
+import io.grpc.internal.ManagedClientTransport;
+import io.grpc.internal.TransportTracer;
+import io.grpc.testing.TestMethodDescriptors;
+import java.net.InetSocketAddress;
+import java.util.concurrent.Executor;
+import org.chromium.net.BidirectionalStream;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = Build.VERSION_CODES.P)
+public final class CronetClientTransportTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private static final String AUTHORITY = "test.example.com";
+  private static final Attributes.Key<String> EAG_ATTR_KEY =
+      Attributes.Key.create("eag-attr");
+
+  private static final Attributes EAG_ATTRS =
+      Attributes.newBuilder().set(EAG_ATTR_KEY, "value").build();
+
+  private final ClientStreamTracer[] tracers =
+      new ClientStreamTracer[]{ new ClientStreamTracer() {} };
+  private CronetClientTransport transport;
+  @Mock private StreamBuilderFactory streamFactory;
+  private MethodDescriptor<Void, Void> descriptor = TestMethodDescriptors.voidMethod();
+  @Mock private ManagedClientTransport.Listener clientTransportListener;
+  @Mock private BidirectionalStream.Builder builder;
+  private final Executor executor = Runnable::run;
+
+  @Before
+  public void setUp() {
+    when(clientTransportListener.filterTransport(any()))
+        .thenAnswer(i -> i.getArgument(0, Attributes.class));
+    transport =
+        new CronetClientTransport(
+            streamFactory,
+            new InetSocketAddress("localhost", 443),
+            AUTHORITY,
+            null,
+            EAG_ATTRS,
+            executor,
+            5000,
+            false,
+            TransportTracer.getDefaultFactory().create(),
+            false,
+            false);
+    Runnable callback = transport.start(clientTransportListener);
+    assertNotNull(callback);
+    callback.run();
+    verify(clientTransportListener).transportReady();
+  }
+
+  @Test
+  public void transportAttributes() {
+    Attributes attrs = transport.getAttributes();
+    assertEquals(
+        SecurityLevel.PRIVACY_AND_INTEGRITY, attrs.get(GrpcAttributes.ATTR_SECURITY_LEVEL));
+    assertEquals(EAG_ATTRS, attrs.get(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS));
+  }
+
+  @Test
+  public void shutdownTransport() throws Exception {
+    CronetClientStream stream1 =
+        transport.newStream(descriptor, new Metadata(), CallOptions.DEFAULT, tracers);
+    CronetClientStream stream2 =
+        transport.newStream(descriptor, new Metadata(), CallOptions.DEFAULT, tracers);
+
+    // Create a transport and start two streams on it.
+    ArgumentCaptor<BidirectionalStream.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(BidirectionalStream.Callback.class);
+    when(streamFactory.newBidirectionalStreamBuilder(
+            any(String.class), callbackCaptor.capture(), any(Executor.class)))
+        .thenReturn(builder);
+    BidirectionalStream cronetStream1 = mock(BidirectionalStream.class);
+    when(builder.build()).thenReturn(cronetStream1);
+    stream1.start(mock(ClientStreamListener.class));
+    BidirectionalStream.Callback callback1 = callbackCaptor.getValue();
+
+    BidirectionalStream cronetStream2 = mock(BidirectionalStream.class);
+    when(builder.build()).thenReturn(cronetStream2);
+    stream2.start(mock(ClientStreamListener.class));
+    BidirectionalStream.Callback callback2 = callbackCaptor.getValue();
+    // Shut down the transport. transportShutdown should be called immediately.
+    transport.shutdown();
+    verify(clientTransportListener).transportShutdown(any(Status.class),
+        any(DisconnectError.class));
+    // Have two live streams. Transport has not been terminated.
+    verify(clientTransportListener, times(0)).transportTerminated();
+
+    callback1.onCanceled(cronetStream1, null);
+    // Still has one live stream
+    verify(clientTransportListener, times(0)).transportTerminated();
+    callback2.onCanceled(cronetStream1, null);
+    // All streams are gone now.
+    verify(clientTransportListener, times(1)).transportTerminated();
+  }
+
+  @Test
+  public void startStreamAfterShutdown() throws Exception {
+    CronetClientStream stream =
+        transport.newStream(descriptor, new Metadata(), CallOptions.DEFAULT, tracers);
+    transport.shutdown();
+    BaseClientStreamListener listener = new BaseClientStreamListener();
+    stream.start(listener);
+
+    assertEquals(Status.UNAVAILABLE.getCode(), listener.status.getCode());
+  }
+
+  private static class BaseClientStreamListener implements ClientStreamListener {
+    private Status status;
+
+    @Override
+    public void messagesAvailable(MessageProducer producer) {}
+
+    @Override
+    public void onReady() {}
+
+    @Override
+    public void headersRead(Metadata headers) {}
+
+    @Override
+    public void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {
+      this.status = status;
+    }
+  }
+}
diff --git a/cronet/src/test/java/io/grpc/cronet/CronetWritableBufferAllocatorTest.java b/cronet/src/test/java/io/grpc/cronet/CronetWritableBufferAllocatorTest.java
new file mode 100644
index 00000000000..a549d94b350
--- /dev/null
+++ b/cronet/src/test/java/io/grpc/cronet/CronetWritableBufferAllocatorTest.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2016 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.cronet;
+
+import static org.junit.Assert.assertEquals;
+
+import io.grpc.internal.WritableBuffer;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class CronetWritableBufferAllocatorTest {
+
+  @Test
+  public void testAllocate() throws Exception {
+    CronetWritableBufferAllocator allocator = new CronetWritableBufferAllocator();
+    WritableBuffer buffer = allocator.allocate(1000);
+    assertEquals(1000, buffer.writableBytes());
+  }
+
+  @Test
+  public void testAllocateLargeBuffer() throws Exception {
+    CronetWritableBufferAllocator allocator = new CronetWritableBufferAllocator();
+    // Ask for 1GB
+    WritableBuffer buffer = allocator.allocate(1024 * 1024 * 1024);
+    // Only get 1MB
+    assertEquals(1024 * 1024, buffer.writableBytes());
+  }
+}
diff --git a/documentation/android-binderchannel-status-codes.md b/documentation/android-binderchannel-status-codes.md
new file mode 100644
index 00000000000..fae4ef406af
--- /dev/null
+++ b/documentation/android-binderchannel-status-codes.md
@@ -0,0 +1,405 @@
+# Android gRPC/BinderChannel Status Codes
+
+## Background
+
+[BinderChannel](https://github.com/grpc/proposal/blob/master/L73-java-binderchannel.md) is a gRPC transport that lets Android apps communicate across processes using familiar gRPC concepts and APIs. A BinderChannel-backed gRPC request can fail for many Android-specific reasons, both at `ServiceConnection` establishment and at `transact()` time. These transport-specific failures must be reported to clients using [gRPC’s standard canonical status code abstraction](https://github.com/grpc/grpc/blob/master/doc/statuscodes.md#status-codes-and-their-use-in-grpc). This document enumerates the BinderChannel errors one can expect to encounter, specifies a canonical status code mapping for each possibility and discusses how clients should handle them.
+
+
+## Status Code Mapping
+
+Consider the table that follows as an BinderChannel-specific addendum to the “[Codes that may be returned by the gRPC libraries](https://github.com/grpc/grpc/blob/master/doc/statuscodes.md#status-codes-and-their-use-in-grpc)” document. Mappings in that table that share a status code with one of the binder-specific mappings are repeated here for comparison.
+
+<table>
+  <tr>
+   <td><strong>#</strong>
+   </td>
+   <td><strong>Error Case</strong>
+   </td>
+   <td><strong>Android API Manifestation</strong>
+   </td>
+   <td><strong>Status Code</strong>
+   </td>
+   <td><strong>Expected Client Handling</strong>
+   </td>
+  </tr>
+  <tr>
+   <td>0
+   </td>
+   <td><a href="https://developer.android.com/training/package-visibility">Server app not visible</a>.
+   </td>
+   <td rowspan="7" >bindService() returns false
+   </td>
+   <td rowspan="10" ><p>UNIMPLEMENTED<p>“The operation is not implemented or is not supported / enabled in this service.”
+   </td>
+   <td>Give up - This is an error in the client manifest.
+   </td>
+  </tr>
+  <tr>
+   <td>1
+   </td>
+   <td>
+   <a href="https://developer.android.com/about/versions/15/behavior-changes-15#safer-intents">Safer Intents</a> violation.
+   </td>
+   <td rowspan="8" >Direct the user to install/reinstall the server app.
+   </td>
+  </tr>
+  <tr>
+   <td>2
+   </td>
+   <td>Server app not installed
+   </td>
+  </tr>
+  <tr>
+   <td>3
+   </td>
+   <td>Old version of the server app doesn’t declare the target android.app.Service in its manifest.
+   </td>
+  </tr>
+  <tr>
+   <td>4
+   </td>
+   <td>Target android.app.Service is disabled
+   </td>
+  </tr>
+  <tr>
+   <td>5
+   </td>
+   <td>The whole server app is disabled
+   </td>
+  </tr>
+  <tr>
+   <td>6
+   </td>
+   <td>Server app predates <a href="https://developer.android.com/guide/topics/permissions/overview">the Android M permissions model</a> and the user must review and approve some newly requested permissions before it can run.
+   </td>
+  </tr>
+  <tr>
+   <td>7
+   </td>
+   <td>Target android.app.Service doesn’t recognize grpc binding Intent (old version of server app?)
+   </td>
+   <td>onNullBinding() ServiceConnection callback
+   </td>
+  </tr>
+  <tr>
+   <td>8
+   </td>
+   <td>Method not found on the io.grpc.Server (old version of server app?)
+   </td>
+   <td rowspan="2" >N/A
+   </td>
+  </tr>
+  <tr>
+   <td>9
+   </td>
+   <td>Request cardinality violation (old version of server app expects unary rather than streaming, say)
+   </td>
+  </tr>
+  <tr>
+   <td>10
+   </td>
+   <td>Old version of the server app exposes target android.app.Service but doesn’t android:export it.
+   </td>
+   <td rowspan="3" >bindService() throws SecurityException
+   </td>
+   <td rowspan="5" ><p>PERMISSION_DENIED<p>
+“The caller does not have permission to execute the specified operation …”
+   </td>
+   <td>Direct the user to update the server app in the hopes that a newer version fixes this error in its manifest.
+   </td>
+  </tr>
+  <tr>
+   <td>11
+   </td>
+   <td>Target android.app.Service requires an &lt;android:permission&gt; that client doesn’t hold. 
+   </td>
+   <td>Prompt the user to grant the needed Android permission
+   </td>
+  </tr>
+  <tr>
+   <td>12
+   </td>
+   <td>Violations of the security policy for miscellaneous Android features like android:isolatedProcess, android:externalService, android:singleUser, instant apps, BIND_TREAT_LIKE_ACTIVITY, etc, 
+   </td>
+   <td rowspan="3" >Give up - This is a programming or packaging error that only the app developer can fix.
+   </td>
+  </tr>
+  <tr>
+   <td>13
+   </td>
+   <td>Calling Android UID not allowed by ServerSecurityPolicy 
+   </td>
+   <td rowspan="2" >N/A
+   </td>
+  </tr>
+  <tr>
+   <td>14
+   </td>
+   <td>Server Android UID not allowed by client’s SecurityPolicy
+   </td>
+  </tr>
+  <tr>
+   <td rowspan="3" >15
+   </td>
+   <td rowspan="3" >Server process crashed or killed with request in flight.
+   </td>
+   <td>onDisconnected() ServiceConnection callback
+   </td>
+   <td rowspan="6" ><p>UNAVAILABLE
+<p>
+“The service is currently unavailable. This is most likely a transient condition, which can be corrected by retrying with a backoff ...”
+   </td>
+   <td rowspan="6" >Retry with exponential backoff and deadline (see <a href="https://grpc.github.io/grpc-java/javadoc/io/grpc/ManagedChannelBuilder.html#enableRetry--">ManagedChannelBuilder#enableRetry()</a>
+   </td>
+  </tr>
+  <tr>
+   <td>onBinderDied() IBinder.DeathRecipient callback
+   </td>
+  </tr>
+  <tr>
+   <td>IBinder.transact() throws DeadObjectException
+   </td>
+  </tr>
+  <tr>
+   <td>16
+   </td>
+   <td>Server app is currently being upgraded to a new version
+   </td>
+   <td rowspan="2" >onBindingDied() ServiceConnection callback
+   </td>
+  </tr>
+  <tr>
+   <td>17
+   </td>
+   <td>The whole server app or the target android.app.Service was disabled
+   </td>
+  </tr>
+  <tr>
+   <td>18
+   </td>
+   <td>Binder transaction buffer overflow
+   </td>
+   <td>IBinder.transact() throws TransactionTooLargeException
+   </td>
+  </tr>
+  <tr>
+   <td>19
+   </td>
+   <td>Source Context for bindService() is destroyed with a request in flight
+   </td>
+   <td>onDestroy()
+   </td>
+   <td rowspan="2" ><p>CANCELLED
+<p>
+“The operation was cancelled, typically by the caller.”
+   </td>
+   <td rowspan="2" >Give up for now.
+<p>
+(Re. 19: The caller can try again later when the user opens the source Activity or restarts the source Service) 
+   </td>
+  </tr>
+  <tr>
+   <td>20
+   </td>
+   <td>Client application cancelled the request
+   </td>
+   <td>N/A
+   </td>
+  </tr>
+  <tr>
+   <td rowspan="2" >21
+   </td>
+   <td rowspan="2" >Bug in Android itself or the way the io.grpc.binder transport uses it.
+   </td>
+   <td>IBinder.transact() returns false
+   </td>
+   <td rowspan="4" ><p>INTERNAL
+<p>
+“This means that some invariants expected by the underlying system have been broken. … Reserved for serious errors.”
+   </td>
+   <td rowspan="4" >Give up - This is a programming error that only the app or grpc developers can fix
+   </td>
+  </tr>
+  <tr>
+   <td>bindService() throws IllegalArgumentException
+   </td>
+  </tr>
+  <tr>
+   <td>22
+   </td>
+   <td>Flow-control protocol violation
+   </td>
+   <td rowspan="2" >N/A
+   </td>
+  </tr>
+  <tr>
+   <td>23
+   </td>
+   <td>Can’t parse request/response proto
+   </td>
+  </tr>
+</table>
+
+
+### Ambiguity
+
+We say a status code is ambiguous if it maps to two error cases that reasonable clients want to handle differently. For instance, a client may have good reasons to handle error cases 10 and 11 above differently. But they can’t do so based on status code alone because those error cases map to the same one. 
+
+In contrast, for example, even though error case 19 and 20 both map to the status code (`CANCELLED`), they are not ambiguous because we see no reason that clients would want to distinguish them. In both cases, clients will simply give up on the request.
+
+
+#### Ambiguity of PERMISSION_DENIED and Mitigations
+
+The mapping above has only one apparently ambiguous status code: `PERMISSION_DENIED`. However, this isn’t so bad because of the following:
+
+The use of `<android:permission>`s for inter-app IPC access control (error case 11) is uncommon. Instead, we recommend that server apps only allow IPC from a limited set of client apps known in advance and identified by signature.
+
+However, there may be gRPC server apps that want to use custom &lt;android:permission&gt;’s to let the end user decide which arbitrary other apps can make use of its gRPC services. In that case, clients should preempt error case 11 simply by [checking whether they hold the required permissions](https://developer.android.com/training/permissions/requesting) before sending a request.
+
+Server apps can avoid error case 10 by never reusing an android.app.Service as a gRPC host if it has ever been android:exported=false in some previous app version. Instead they should simply create a new android.app.Service for this purpose.
+
+Only error cases 12 - 14 remain, making `PERMISSION_DENIED` unambiguous for the purpose of error handling. Reasonable client apps can handle it in a generic way by displaying an error message and/or proceeding with degraded functionality.
+
+
+#### Non-Ambiguity of UNIMPLEMENTED
+
+The `UNIMPLEMENTED` status code corresponds to quite a few different problems with the server app: It’s either not installed, too old, misconfigured, or disabled in whole or in part. Despite the diversity of underlying error cases, we believe most client apps will and should handle `UNIMPLEMENTED` in the same way: by sending the user to the app store to (re)install the server app. Reinstalling might be overkill for the disabled cases but most end users don't know what it means to enable/disable an app and there’s neither enough space in a UI dialog nor enough reader attention to explain it. Reinstalling is something users likely already understand and likely to cure problems 0-9 (once a fixed version of the server is available).
+
+
+## Detailed Discussion of Binder Failure Modes
+
+### IBinder.transact() returns false
+
+According to the [docs](https://developer.android.com/reference/android/os/IBinder#transact(int,%20android.os.Parcel,%20android.os.Parcel,%20int)), false “generally means the transaction code was not understood.” This is true for synchronous transactions but all gRPC/BinderChannel transactions are `FLAG_ONEWAY` meaning the calling thread doesn’t wait around for the server to return from `onTransact()`. Examination of the AOSP source code shows several additional undocumented reasons `transact()` could return false but all of these cases should be impossible and aren’t things that reasonable apps want to handle.
+
+### IBinder.transact() Throws an Exception
+
+According to the docs, `transact()` can throw `RemoteException` but the significance of this exception [isn’t documented](https://developer.android.com/reference/android/os/IBinder#transact(int,%20android.os.Parcel,%20android.os.Parcel,%20int)). By inspection of the AOSP source, we see there are several cases:
+
+1. The remote process is no longer alive (`android.os.DeadObjectException`)
+2. The IPC buffer is full (`android.os.TransactionTooLargeException`)
+3. Certain internal errors from the underlying `ioctl()` system call.
+
+Status code mappings: 
+<table>
+  <tr>
+   <td><strong>Exception</strong>
+   </td>
+   <td><strong>Status Code</strong>
+   </td>
+   <td><strong>Rationale</strong>
+   </td>
+  </tr>
+  <tr>
+   <td>android.os.DeadObjectException
+   </td>
+   <td>UNAVAILABLE
+   </td>
+   <td>So the caller can retry against a new incarnation of the server process
+   </td>
+  </tr>
+  <tr>
+   <td>android.os.TransactionTooLargeException
+   </td>
+   <td>UNAVAILABLE
+   </td>
+   <td>These are usually transient. A retry is likely to succeed later when demand for the IPC buffer subsides.
+   </td>
+  </tr>
+  <tr>
+   <td>Some other RemoteException
+   </td>
+   <td>INTERNAL
+   </td>
+   <td rowspan="2" >So the caller doesn’t bother retrying
+   </td>
+  </tr>
+  <tr>
+   <td>Some other RuntimeException
+   </td>
+   <td>INTERNAL
+   </td>
+  </tr>
+</table>
+
+
+### bindService() returns false
+
+According to the [docs](https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)), this bindService() returns false when “the system couldn't find the service or if your client doesn't have permission to bind to it.” However, the part about permission is somewhat misleading.
+
+According to a review of the AOSP source code, there are in fact several cases:
+
+1. The target package is not installed
+2. The target package is installed but does not declare the target Service in its manifest.
+3. The target package requests dangerous permissions but targets sdk &lt;= M and therefore requires a permissions review, but the caller is not running in the foreground and so it would be inappropriate to launch the review UI.
+4. The target package is not visible to the client due to [Android 11 package visibility rules](https://developer.android.com/training/package-visibility).
+5. One of the new [Safer Intents](https://developer.android.com/about/versions/15/behavior-changes-15#safer-intents) rules is violated. Most commonly, the bind `Intent` specifies a `ComponentName` explicitly but doesn't match any of its &lt;intent-filter&gt;s. 
+
+Status code mapping: **UNIMPLEMENTED**
+
+(1) and (2) are interesting new possibilities unique to on-device RPC. (1) is straightforward and the most likely cause of (2) is that the user has an old version of the server app installed that predates its gRPC integration. Many clients will want to handle these cases, likely by directing the user to the app store in order to install/upgrade the server.
+
+Unfortunately `UNIMPLEMENTED` doesn’t capture (3) but none of the other canonical status codes do either and we expect this case to be extremely rare.
+
+(4) and (5) are intentially indistinguishable from (1) by Android design so we can't handle them differently. However, as an error in its own manifest, (4) isn't something a reasonable client would handle at runtime anyway. (5) is an error in the server manifest and so, just like the other cases, the best practice for handling it is to send the user to the app store in the hope that the server can be updated with a fix.
+
+### bindService() throws SecurityException
+
+According to the [docs](https://developer.android.com/reference/android/content/Context#bindService(android.content.Intent,%20android.content.ServiceConnection,%20int)), SecurityException is thrown “if the calling app does not have permission to bind to the given service”. There are quite a few specific cases:
+
+1. The target Service sets `android:exported = “false”` in its manifest but the caller is in a different app.
+2. The target Service declares a required permission in its manifest but the calling package doesn’t have it. 
+3. The target Service is marked as `android:singleton` in the manifest but doesn’t hold the `INTERACT_ACROSS_USERS` permission. 
+4. The caller is an `android:isolatedProcess`.
+5. The caller requested certain security-related flags on the binding without the necessary permission (gRPC/BinderChannel doesn’t do this)
+6. … according to the source code, a long tail of unlikely security-related internal errors.
+
+Status code mapping: **PERMISSION_DENIED**.
+
+### bindService() throws IllegalArgumentException
+
+There are a couple cases:
+
+1. The binding Intent is not explicit.
+2. The binding Intent contains file descriptors.
+
+Status Code mapping: **INTERNAL**. These cases should be impossible. 
+
+
+### onBindingDied() ServiceConnection callback
+
+According to the [docs](https://developer.android.com/reference/android/content/ServiceConnection#onBindingDied(android.content.ComponentName)): “... This means the interface will never receive another connection. The application will need to unbind and rebind the connection to activate it again. This may happen, for example, if the application hosting the service it is bound to has been updated.”
+
+Status code mapping: **UNAVAILABLE**
+
+`UNAVAILABLE` is the best mapping since a retry is likely to succeed in the near future once the server application finishes updating. 
+
+
+### onNullBinding() ServiceConnection callback
+
+According to the [docs](https://developer.android.com/reference/android/content/ServiceConnection#onNullBinding(android.content.ComponentName)): “Called when the service being bound has returned null from its `onBind()` method. This indicates that the attempting service binding represented by this `ServiceConnection` will never become usable.”
+
+Status code mapping: **UNIMPLEMENTED**
+
+`UNIMPLEMENTED` is used here because a retry is likely to fail for the same reason. The most likely root cause for a null binding is an older version of the server app where the `android.app.Service` exists but either doesn’t implement `onBind()` or doesn’t recognize the `grpc.io.action.BIND` Intent action.
+
+
+### onServiceDisconnected() ServiceConnection callback
+
+According to the [docs](https://developer.android.com/reference/android/content/ServiceConnection#onServiceDisconnected(android.content.ComponentName)): “Called when a connection to the Service has been lost. This typically happens when the process hosting the service has crashed or been killed ...”
+
+Status code mapping: **UNAVAILABLE**
+
+`UNAVAILABLE` is used here since a retry is likely to succeed against a newly restarted instance of the server.
+
+
+### Response Parcel Contains an Exception
+
+Android’s Parcel class exposes a mechanism for marshalling certain types of `RuntimeException`s between traditional Binder IPC peers. However we won’t consider this case because gRPC/BinderChannel doesn’t use this mechanism. In fact, all BinderChannel transactions are `FLAG_ONE_WAY` so there is no response Parcel.
+
+
+### Source Context for bindService() is Destroyed
+
+The calling Activity or Service Context might be destroyed with a gRPC request in flight. Apps should cease operations when the Context hosting it goes away and this includes cancelling any outstanding RPCs.  
+
+Status code mapping: **CANCELLED**
diff --git a/documentation/android-channel-builder.md b/documentation/android-channel-builder.md
new file mode 100644
index 00000000000..d7b07908d15
--- /dev/null
+++ b/documentation/android-channel-builder.md
@@ -0,0 +1,60 @@
+# AndroidChannelBuilder
+
+ The `grpc-android` package provides access to the
+`AndroidChannelBuilder` class. Given an Android Context, this builder
+registers a network event listener upon channel construction.  The listener
+automatically responds to changes in the device's network state, avoiding
+delays and interrupted RPCs that may otherwise occur.
+
+By default, gRPC uses exponential backoff to recover from connection failures.
+Depending on the scheduled backoff delay when the device regains connectivity,
+this could result in a  one minute or longer delay before gRPC re-establishes
+the connection. This delay is removed when `AndroidChannelBuilder` is provided
+with the app's Android Context.  Notifications from the network listener
+cause the channel to immediately reconnect upon network recovery.
+
+On Android API levels 24+, `AndroidChannelBuilder`'s network listener mechanism
+allows graceful switching from cellular to wifi connections. When an Android
+device on a cellular network connects to a wifi network, there is a brief
+(typically 30 second) interval when both cellular and wifi networks remain
+available, then any connections on the cellular network are terminated.  By
+listening for changes in the device's default network, `AndroidChannelBuilder`
+sends new RPCs via wifi rather than using an already-established cellular
+connection. Without listening for pending network changes, new RPCs sent on an
+already established cellular connection would fail when the device terminates
+cellular connections.
+
+***Note:*** *Currently, `AndroidChannelBuilder` is only compatible with gRPC
+OkHttp. We plan to offer additional Android-specific features compatible with
+both the OkHttp and Cronet transports in the future, but the network listener
+mechanism is only necessary with OkHttp; the Cronet library internally handles
+connection management on Android devices.*
+
+## Example usage:
+
+In your `build.gradle` file, include a dependency on both `io.grpc:grpc-android` and
+`io.grpc:grpc-okhttp`.
+
+You also need permission to access the device's network state in your
+`AndroidManifest.xml`:
+
+```
+<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+```
+
+When constructing your channel, use `AndroidChannelBuilder` and provide it with
+your app's Context:
+
+```
+import io.grpc.android.AndroidChannelBuilder;
+...
+ManagedChannel channel = AndroidChannelBuilder.forAddress("localhost", 8080)
+    .context(getApplicationContext())
+    .build();
+```
+
+You continue to use the constructed channel exactly as you would any other
+channel. gRPC will now monitor and respond to the device's network state
+automatically. When you shutdown the managed channel, the network listener
+registered by `AndroidChannelBuilder` will be unregistered.
+
diff --git a/documentation/server-reflection-tutorial.md b/documentation/server-reflection-tutorial.md
index 47be7c2396b..f452174738a 100644
--- a/documentation/server-reflection-tutorial.md
+++ b/documentation/server-reflection-tutorial.md
@@ -10,9 +10,9 @@ proto-based services.
 ## Enable Server Reflection
 
 gRPC-Java Server Reflection is implemented by
-`io.grpc.protobuf.service.ProtoReflectionService` in the `grpc-services`
+`io.grpc.protobuf.services.ProtoReflectionServiceV1` in the `grpc-services`
 package. To enable server reflection, you need to add the
-`ProtoReflectionService` to your gRPC server.
+`ProtoReflectionServiceV1` to your gRPC server.
 
 For example, to enable server reflection in
 `examples/src/main/java/io/grpc/examples/helloworld/HelloWorldServer.java`, we
@@ -23,29 +23,27 @@ need to make the following changes:
 +++ b/examples/build.gradle
 @@ -27,6 +27,7 @@
  dependencies {
-   compile "io.grpc:grpc-netty:${grpcVersion}"
+   compile "io.grpc:grpc-netty-shaded:${grpcVersion}"
    compile "io.grpc:grpc-protobuf:${grpcVersion}"
 +  compile "io.grpc:grpc-services:${grpcVersion}"
    compile "io.grpc:grpc-stub:${grpcVersion}"
-
-   testCompile "junit:junit:4.11"
-diff --git a/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldServer.java b/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldServer.java
-index ce1158a4..788bcc62 100644
+ 
+   testCompile "junit:junit:4.13.2"
 --- a/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldServer.java
 +++ b/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldServer.java
 @@ -33,6 +33,7 @@ package io.grpc.examples.helloworld;
-
+ 
  import io.grpc.Server;
  import io.grpc.ServerBuilder;
-+import io.grpc.protobuf.service.ProtoReflectionService;
++import io.grpc.protobuf.services.ProtoReflectionServiceV1;
  import io.grpc.stub.StreamObserver;
-
  import java.io.IOException;
-@@ -51,6 +52,7 @@ public class HelloWorldServer {
+ import java.util.logging.Logger;
+@@ -50,6 +51,7 @@ public class HelloWorldServer {
      int port = 50051;
      server = ServerBuilder.forPort(port)
          .addService(new GreeterImpl())
-+        .addService(ProtoReflectionService.getInstance())
++        .addService(ProtoReflectionServiceV1.newInstance())
          .build()
          .start();
      logger.info("Server started, listening on " + port);
diff --git a/examples/.bazelrc b/examples/.bazelrc
new file mode 100644
index 00000000000..53485cb9743
--- /dev/null
+++ b/examples/.bazelrc
@@ -0,0 +1 @@
+build --cxxopt=-std=c++17 --host_cxxopt=-std=c++17
diff --git a/examples/BUILD.bazel b/examples/BUILD.bazel
new file mode 100644
index 00000000000..e3ef8c5ac5d
--- /dev/null
+++ b/examples/BUILD.bazel
@@ -0,0 +1,280 @@
+load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library")
+load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library")
+load("@io_grpc_grpc_java//:java_grpc_library.bzl", "java_grpc_library")
+load("@rules_java//java:java_binary.bzl", "java_binary")
+load("@rules_java//java:java_library.bzl", "java_library")
+
+proto_library(
+    name = "helloworld_proto",
+    srcs = ["src/main/proto/helloworld.proto"],
+)
+
+java_proto_library(
+    name = "helloworld_java_proto",
+    deps = [":helloworld_proto"],
+)
+
+java_grpc_library(
+    name = "helloworld_java_grpc",
+    srcs = [":helloworld_proto"],
+    deps = [":helloworld_java_proto"],
+)
+
+proto_library(
+    name = "hello_streaming_proto",
+    srcs = [
+        "src/main/proto/hello_streaming.proto",
+    ],
+)
+
+java_proto_library(
+    name = "hello_streaming_java_proto",
+    deps = [":hello_streaming_proto"],
+)
+
+java_grpc_library(
+    name = "hello_streaming_java_grpc",
+    srcs = [":hello_streaming_proto"],
+    deps = [":hello_streaming_java_proto"],
+)
+
+proto_library(
+    name = "route_guide_proto",
+    srcs = ["src/main/proto/route_guide.proto"],
+)
+
+java_proto_library(
+    name = "route_guide_java_proto",
+    deps = [":route_guide_proto"],
+)
+
+java_grpc_library(
+    name = "route_guide_java_grpc",
+    srcs = [":route_guide_proto"],
+    deps = [":route_guide_java_proto"],
+)
+
+proto_library(
+    name = "echo_proto",
+    srcs = ["src/main/proto/grpc/examples/echo/echo.proto"],
+)
+
+java_proto_library(
+    name = "echo_java_proto",
+    deps = [":echo_proto"],
+)
+
+java_grpc_library(
+    name = "echo_java_grpc",
+    srcs = [":echo_proto"],
+    deps = [":echo_java_proto"],
+)
+
+java_library(
+    name = "examples",
+    testonly = 1,
+    srcs = glob(
+        ["src/main/java/**/*.java"],
+    ),
+    resources = glob(
+        ["src/main/resources/**"],
+    ),
+    runtime_deps = [
+        "@io_grpc_grpc_java//netty",
+    ],
+    deps = [
+        ":_health_java_grpc",
+        ":echo_java_grpc",
+        ":echo_java_proto",
+        ":hello_streaming_java_grpc",
+        ":hello_streaming_java_proto",
+        ":helloworld_java_grpc",
+        ":helloworld_java_proto",
+        ":route_guide_java_grpc",
+        ":route_guide_java_proto",
+        "@com_google_protobuf//:protobuf_java",
+        "@com_google_protobuf//:protobuf_java_util",
+        "@io_grpc_grpc_java//api",
+        "@io_grpc_grpc_java//context",
+        "@io_grpc_grpc_java//protobuf",
+        "@io_grpc_grpc_java//services:health",
+        "@io_grpc_grpc_java//services:healthlb",
+        "@io_grpc_grpc_java//stub",
+        "@io_grpc_grpc_proto//:health_java_proto",
+        "@io_grpc_grpc_proto//:health_proto",
+        "@maven//:com_google_api_grpc_proto_google_common_protos",
+        "@maven//:com_google_code_findbugs_jsr305",
+        "@maven//:com_google_code_gson_gson",
+        "@maven//:com_google_guava_guava",
+    ],
+)
+
+java_binary(
+    name = "hello-world-client",
+    testonly = 1,
+    main_class = "io.grpc.examples.helloworld.HelloWorldClient",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "hello-world-server",
+    testonly = 1,
+    main_class = "io.grpc.examples.helloworld.HelloWorldServer",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "route-guide-client",
+    testonly = 1,
+    main_class = "io.grpc.examples.routeguide.RouteGuideClient",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "route-guide-server",
+    testonly = 1,
+    main_class = "io.grpc.examples.routeguide.RouteGuideServer",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "manual-flow-control-client",
+    testonly = 1,
+    main_class = "io.grpc.examples.manualflowcontrol.ManualFlowControlClient",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "manual-flow-control-server",
+    testonly = 1,
+    main_class = "io.grpc.examples.manualflowcontrol.ManualFlowControlServer",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "load-balance-client",
+    testonly = 1,
+    main_class = "io.grpc.examples.loadbalance.LoadBalanceClient",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "load-balance-server",
+    testonly = 1,
+    main_class = "io.grpc.examples.loadbalance.LoadBalanceServer",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "custom-load-balance-client",
+    testonly = 1,
+    main_class = "io.grpc.examples.customloadbalance.CustomLoadBalanceClient",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "name-resolve-client",
+    testonly = 1,
+    main_class = "io.grpc.examples.nameresolve.NameResolveClient",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "name-resolve-server",
+    testonly = 1,
+    main_class = "io.grpc.examples.nameresolve.NameResolveServer",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "deadline-server",
+    testonly = 1,
+    main_class = "io.grpc.examples.deadline.DeadlineServer",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "deadline-client",
+    testonly = 1,
+    main_class = "io.grpc.examples.deadline.DeadlineClient",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "healthservice-server",
+    testonly = 1,
+    main_class = "io.grpc.examples.healthservice.HealthServiceServer",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "healthservice-client",
+    testonly = 1,
+    main_class = "io.grpc.examples.healthservice.HealthServiceClient",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_grpc_library(
+    name = "_health_java_grpc",
+    srcs = ["@io_grpc_grpc_proto//:health_proto"],
+    visibility = ["//visibility:private"],
+    deps = ["@io_grpc_grpc_proto//:health_java_proto"],
+)
+
+java_binary(
+    name = "retrying-hello-world-client",
+    testonly = 1,
+    main_class = "io.grpc.examples.retrying.RetryingHelloWorldClient",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+java_binary(
+    name = "retrying-hello-world-server",
+    testonly = 1,
+    main_class = "io.grpc.examples.retrying.RetryingHelloWorldServer",
+    runtime_deps = [
+        ":examples",
+    ],
+)
+
+# grpc-xds requires some WORKSPACE/MODULE deps that aren't needed by the other
+# targets. This just makes sure the example WORKSPACE/MODULE works with
+# grpc-xds.
+java_library(
+    name = "test_grpc_xds_compiles",
+    runtime_deps = [
+        "@io_grpc_grpc_java//xds",
+    ],
+)
diff --git a/examples/MODULE.bazel b/examples/MODULE.bazel
new file mode 100644
index 00000000000..489cf3e3f5c
--- /dev/null
+++ b/examples/MODULE.bazel
@@ -0,0 +1,32 @@
+bazel_dep(name = "grpc-java", version = "1.80.0-SNAPSHOT", repo_name = "io_grpc_grpc_java")  # CURRENT_GRPC_VERSION
+bazel_dep(name = "rules_java", version = "9.3.0")
+bazel_dep(name = "grpc-proto", version = "0.0.0-20240627-ec30f58", repo_name = "io_grpc_grpc_proto")
+bazel_dep(name = "protobuf", version = "33.1", repo_name = "com_google_protobuf")
+bazel_dep(name = "rules_jvm_external", version = "6.0")
+
+# Do not use this override in your own MODULE.bazel. It is unnecessary when
+# using a version from BCR. Be aware the gRPC Java team does not update the
+# BCR for new releases, so you may need to create a PR for the BCR to add the
+# version. To not use the BCR, you could use:
+#
+# git_override(
+#    module_name = "grpc-java",
+#    remote = "https://github.com/grpc/grpc-java.git",
+#    tag = "v<VERSION>",
+# )
+local_path_override(
+    module_name = "grpc-java",
+    path = "..",
+)
+
+maven = use_extension("@rules_jvm_external//:extensions.bzl", "maven")
+use_repo(maven, "maven")
+
+maven.install(
+    artifacts = [
+        "com.google.api.grpc:grpc-google-cloud-pubsub-v1:0.1.24",
+        "com.google.api.grpc:proto-google-cloud-pubsub-v1:0.1.24",
+    ],
+    repositories = ["https://repo.maven.apache.org/maven2/"],
+    strict_visibility = True,
+)
diff --git a/examples/README.md b/examples/README.md
index bc090cd7821..91fde2c045c 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -1,22 +1,69 @@
-grpc Examples
+gRPC Examples
 ==============================================
 
-The examples require grpc-java to already be built. You are strongly encouraged
-to check out a git release tag, since there will already be a build of grpc
+The examples require `grpc-java` to already be built. You are strongly encouraged
+to check out a git release tag, since there will already be a build of gRPC
 available. Otherwise you must follow [COMPILING](../COMPILING.md).
 
 You may want to read through the
-[Quick Start Guide](http://www.grpc.io/docs/quickstart/java.html)
+[Quick Start](https://grpc.io/docs/languages/java/quickstart)
 before trying out the examples.
 
-To build the examples, run in this directory:
+## Basic examples
 
+- [Hello world](src/main/java/io/grpc/examples/helloworld)
+
+- [Route guide](src/main/java/io/grpc/examples/routeguide)
+
+- [Metadata](src/main/java/io/grpc/examples/header)
+
+- [Error handling](src/main/java/io/grpc/examples/errorhandling)
+
+- [Compression](src/main/java/io/grpc/examples/experimental)
+
+- [Flow control](src/main/java/io/grpc/examples/manualflowcontrol)
+
+- [Wait For Ready](src/main/java/io/grpc/examples/waitforready)
+
+- [Json serialization](src/main/java/io/grpc/examples/advanced)
+
+- [Hedging example](src/main/java/io/grpc/examples/hedging)
+
+- [Retrying example](src/main/java/io/grpc/examples/retrying)
+
+- [Health Service example](src/main/java/io/grpc/examples/healthservice)
+
+- [Keep Alive](src/main/java/io/grpc/examples/keepalive)
+
+- [Cancellation](src/main/java/io/grpc/examples/cancellation)
+
+- [Custom Load Balance](src/main/java/io/grpc/examples/customloadbalance)
+
+- [Deadline](src/main/java/io/grpc/examples/deadline)
+
+- [Error Details](src/main/java/io/grpc/examples/errordetails)
+
+- [GRPC Proxy](src/main/java/io/grpc/examples/grpcproxy)
+
+- [Load Balance](src/main/java/io/grpc/examples/loadbalance)
+
+- [Multiplex](src/main/java/io/grpc/examples/multiplex)
+
+- [Name Resolve](src/main/java/io/grpc/examples/nameresolve)
+
+- [Pre-Serialized Messages](src/main/java/io/grpc/examples/preserialized)
+
+### <a name="to-build-the-examples"></a> To build the examples
+
+1. **[Install gRPC Java library SNAPSHOT locally, including code generation plugin](../COMPILING.md) (Only need this step for non-released versions, e.g. master HEAD).**
+
+2. From grpc-java/examples directory:
 ```
 $ ./gradlew installDist
 ```
 
 This creates the scripts `hello-world-server`, `hello-world-client`,
-`route-guide-server`, and `route-guide-client` in the
+`route-guide-server`, `route-guide-client`, etc. in the
 `build/install/examples/bin/` directory that run the examples. Each
 example requires the server to be running before starting the client.
 
@@ -34,13 +81,15 @@ $ ./build/install/examples/bin/hello-world-client
 
 That's it!
 
-Please refer to gRPC Java's [README](../README.md) and
-[tutorial](http://www.grpc.io/docs/tutorials/basic/java.html) for more
-information.
+For more information, refer to gRPC Java's [README](../README.md) and
+[tutorial](https://grpc.io/docs/languages/java/basics).
 
-## Maven
+### Maven
 
 If you prefer to use Maven:
+1. **[Install gRPC Java library SNAPSHOT locally, including code generation plugin](../COMPILING.md) (Only need this step for non-released versions, e.g. master HEAD).**
+
+2. Run in this directory:
 ```
 $ mvn verify
 $ # Run the server
@@ -49,22 +98,73 @@ $ # In another terminal run the client
 $ mvn exec:java -Dexec.mainClass=io.grpc.examples.helloworld.HelloWorldClient
 ```
 
-Unit test examples
-==============================================
+### Bazel
+
+If you prefer to use Bazel:
+```
+$ bazel build :hello-world-server :hello-world-client
+$ # Run the server
+$ bazel-bin/hello-world-server
+$ # In another terminal run the client
+$ bazel-bin/hello-world-client
+```
+
+## Other examples
+
+- [Android examples](android)
+
+- Secure channel examples
+
+  + [TLS examples](example-tls)
+
+  + [ALTS examples](example-alts)
+
+- [Google Authentication](example-gauth)
+
+- [JWT-based Authentication](example-jwt-auth)
+
+- [OAuth2-based Authentication](example-oauth)
+
+- [Pre-serialized messages](src/main/java/io/grpc/examples/preserialized)
+
+## Unit test examples
 
 Examples for unit testing gRPC clients and servers are located in [examples/src/test](src/test).
 
-In general, we DO NOT allow overriding the client stub.
-We encourage users to leverage `InProcessTransport` as demonstrated in the examples to
-write unit tests. `InProcessTransport` is light-weight and runs the server
+In general, we DO NOT allow overriding the client stub and we DO NOT support mocking final methods
+in gRPC-Java library. Users should be cautious that using tools like PowerMock or
+[mockito-inline](https://search.maven.org/search?q=g:org.mockito%20a:mockito-inline) can easily
+break this rule of thumb. We encourage users to leverage `InProcessTransport` as demonstrated in the
+examples to write unit tests. `InProcessTransport` is light-weight and runs the server
 and client in the same process without any socket/TCP connection.
 
+Mocking the client stub provides a false sense of security when writing tests. Mocking stubs and responses
+allows for tests that don't map to reality, causing the tests to pass, but the system-under-test to fail.
+The gRPC client library is complicated, and accurately reproducing that complexity with mocks is very hard.
+You will be better off and write less code by using `InProcessTransport` instead.
+
+Example bugs not caught by mocked stub tests include:
+
+* Calling the stub with a `null` message
+* Not calling `close()`
+* Sending invalid headers
+* Ignoring deadlines
+* Ignoring cancellation
+
 For testing a gRPC client, create the client with a real stub
 using an
-[InProcessChannel](../core/src/main/java/io/grpc/inprocess/InProcessChannelBuilder.java),
+[InProcessChannel](../inprocess/src/main/java/io/grpc/inprocess/InProcessChannelBuilder.java),
 and test it against an
-[InProcessServer](../core/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java)
+[InProcessServer](../inprocess/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java)
 with a mock/fake service implementation.
 
 For testing a gRPC server, create the server as an InProcessServer,
 and test it against a real client stub with an InProcessChannel.
+
+The gRPC-java library also provides a JUnit rule,
+[GrpcCleanupRule](../testing/src/main/java/io/grpc/testing/GrpcCleanupRule.java), to do the graceful
+shutdown boilerplate for you.
+
+## Even more examples
+
+A wide variety of third-party examples can be found [here](https://github.com/saturnism/grpc-java-by-example).
diff --git a/examples/WORKSPACE b/examples/WORKSPACE
new file mode 100644
index 00000000000..1387cc4cf12
--- /dev/null
+++ b/examples/WORKSPACE
@@ -0,0 +1,77 @@
+workspace(name = "examples")
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+# For released versions, use release tag:
+# http_archive(
+#     name = "io_grpc_grpc_java",
+#     sha256 = "<SHA>",
+#     strip_prefix = "grpc-java-<TAG>",
+#     url = "https://github.com/grpc/grpc-java/archive/<TAG>.zip",
+# )
+local_repository(
+    name = "io_grpc_grpc_java",
+    path = "..",
+)
+
+load("@io_grpc_grpc_java//:repositories.bzl", "IO_GRPC_GRPC_JAVA_ARTIFACTS", "IO_GRPC_GRPC_JAVA_OVERRIDE_TARGETS", "grpc_java_repositories")
+
+grpc_java_repositories()
+
+http_archive(
+    name = "rules_java",
+    sha256 = "47632cc506c858011853073449801d648e10483d4b50e080ec2549a4b2398960",
+    urls = [
+        "https://github.com/bazelbuild/rules_java/releases/download/8.15.2/rules_java-8.15.2.tar.gz",
+    ],
+)
+
+# Protobuf now requires C++14 or higher, which requires Bazel configuration
+# outside the WORKSPACE. See .bazelrc in this directory.
+load("@com_google_protobuf//:protobuf_deps.bzl", "PROTOBUF_MAVEN_ARTIFACTS", "protobuf_deps")
+
+protobuf_deps()
+
+load("@rules_java//java:rules_java_deps.bzl", "compatibility_proxy_repo", "rules_java_dependencies")
+
+rules_java_dependencies()
+
+load("@bazel_features//:deps.bzl", "bazel_features_deps")
+
+bazel_features_deps()
+
+compatibility_proxy_repo()
+
+load("@bazel_jar_jar//:jar_jar.bzl", "jar_jar_repositories")
+
+jar_jar_repositories()
+
+load("@rules_python//python:repositories.bzl", "py_repositories")
+
+py_repositories()
+
+load("@com_google_googleapis//:repository_rules.bzl", "switched_rules_by_language")
+
+switched_rules_by_language(
+    name = "com_google_googleapis_imports",
+)
+
+http_archive(
+    name = "rules_jvm_external",
+    sha256 = "d31e369b854322ca5098ea12c69d7175ded971435e55c18dd9dd5f29cc5249ac",
+    strip_prefix = "rules_jvm_external-5.3",
+    url = "https://github.com/bazelbuild/rules_jvm_external/releases/download/5.3/rules_jvm_external-5.3.tar.gz",
+)
+
+load("@rules_jvm_external//:defs.bzl", "maven_install")
+
+maven_install(
+    artifacts = [
+        "com.google.api.grpc:grpc-google-cloud-pubsub-v1:0.1.24",
+        "com.google.api.grpc:proto-google-cloud-pubsub-v1:0.1.24",
+    ] + IO_GRPC_GRPC_JAVA_ARTIFACTS + PROTOBUF_MAVEN_ARTIFACTS,
+    override_targets = IO_GRPC_GRPC_JAVA_OVERRIDE_TARGETS,
+    repositories = [
+        "https://repo.maven.apache.org/maven2/",
+    ],
+)
diff --git a/examples/WORKSPACE.bzlmod b/examples/WORKSPACE.bzlmod
new file mode 100644
index 00000000000..4ecb9e5d985
--- /dev/null
+++ b/examples/WORKSPACE.bzlmod
@@ -0,0 +1 @@
+# When using bzlmod this makes sure nothing from the legacy WORKSPACE is loaded
diff --git a/examples/android/README.md b/examples/android/README.md
index f96b2ebcd77..b01548e50ae 100644
--- a/examples/android/README.md
+++ b/examples/android/README.md
@@ -7,26 +7,21 @@ PREREQUISITES
 
 - [Android Tutorial](https://developer.android.com/training/basics/firstapp/index.html) if you're new to Android development
 
-- [gRPC Java Android Quick Start Guide](http://www.grpc.io/docs/quickstart/android.html)
+- [gRPC Java Android Quick Start Guide](https://grpc.io/docs/quickstart/android.html)
 
 - We only have Android gRPC client in this example. Please follow examples in other languages to build and run a gRPC server.
 
 INSTALL
 -------
 
-1. (Only for non-released versions) Install gRPC Java
-```sh
-$ cd ../..
-$ ./gradlew install -PskipCodegen=true
-$ cd examples/android
-```
+1. **[Install gRPC Java library SNAPSHOT locally, including code generation plugin](../../COMPILING.md) (Only need this step for non-released versions, e.g. master HEAD).**
 
 2. Install the app
 ```sh
 $ cd helloworld  # or "cd routeguide"
-$ ./gradlew installDebug
+$ ../../gradlew installDebug
 ```
 
 Please refer to the
-[tutorial](http://www.grpc.io/docs/tutorials/basic/android.html) on
+[tutorial](https://grpc.io/docs/tutorials/basic/android.html) on
 how to use gRPC in Android programs.
diff --git a/examples/android/clientcache/app/build.gradle b/examples/android/clientcache/app/build.gradle
new file mode 100644
index 00000000000..2870850562d
--- /dev/null
+++ b/examples/android/clientcache/app/build.gradle
@@ -0,0 +1,64 @@
+apply plugin: 'com.android.application'
+apply plugin: 'com.google.protobuf'
+
+android {
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    compileSdkVersion 34
+
+    defaultConfig {
+        applicationId "io.grpc.clientcacheexample"
+        minSdkVersion 21
+        targetSdkVersion 33
+        multiDexEnabled true
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        debug { minifyEnabled false }
+        release {
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        disable 'GoogleAppIndexingWarning', 'HardcodedText', 'InvalidPackage'
+        textReport true
+        textOutput "stdout"
+    }
+}
+
+protobuf {
+    protoc { artifact = 'com.google.protobuf:protoc:3.25.1' }
+    plugins {
+        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+        }
+    }
+    generateProtoTasks {
+        all().each { task ->
+            task.builtins {
+                java { option 'lite' }
+            }
+            task.plugins {
+                grpc { // Options added to --grpc_out
+                    option 'lite' }
+            }
+        }
+    }
+}
+
+dependencies {
+    implementation 'androidx.appcompat:appcompat:1.0.0'
+
+    // You need to build grpc-java to obtain these libraries below.
+    implementation 'io.grpc:grpc-okhttp:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-protobuf-lite:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-stub:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation 'com.google.truth:truth:1.4.5'
+    testImplementation 'io.grpc:grpc-testing:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+}
diff --git a/examples/android/clientcache/app/proguard-rules.pro b/examples/android/clientcache/app/proguard-rules.pro
new file mode 100644
index 00000000000..1507a526787
--- /dev/null
+++ b/examples/android/clientcache/app/proguard-rules.pro
@@ -0,0 +1,17 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in $ANDROID_HOME/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+-dontwarn com.google.common.**
+# Ignores: can't find referenced class javax.lang.model.element.Modifier
+-dontwarn com.google.errorprone.annotations.**
+-dontwarn javax.naming.**
+-dontwarn okio.**
+-dontwarn sun.misc.Unsafe
diff --git a/examples/android/clientcache/app/src/main/AndroidManifest.xml b/examples/android/clientcache/app/src/main/AndroidManifest.xml
new file mode 100644
index 00000000000..ddf863e9912
--- /dev/null
+++ b/examples/android/clientcache/app/src/main/AndroidManifest.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="io.grpc.clientcacheexample" >
+
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <application
+        android:allowBackup="false"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:theme="@style/Base.V7.Theme.AppCompat.Light" >
+        <activity
+            android:name="io.grpc.clientcacheexample.ClientCacheExampleActivity"
+            android:label="@string/app_name"
+            android:exported="true" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
diff --git a/examples/android/clientcache/app/src/main/java/io/grpc/clientcacheexample/ClientCacheExampleActivity.java b/examples/android/clientcache/app/src/main/java/io/grpc/clientcacheexample/ClientCacheExampleActivity.java
new file mode 100644
index 00000000000..74b89b7a958
--- /dev/null
+++ b/examples/android/clientcache/app/src/main/java/io/grpc/clientcacheexample/ClientCacheExampleActivity.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2015 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.clientcacheexample;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import androidx.appcompat.app.AppCompatActivity;
+import android.text.TextUtils;
+import android.text.method.ScrollingMovementMethod;
+import android.util.Log;
+import android.view.View;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.Button;
+import android.widget.CheckBox;
+import android.widget.EditText;
+import android.widget.TextView;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientInterceptors;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.MethodDescriptor;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.ClientCalls;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.lang.ref.WeakReference;
+import java.util.concurrent.TimeUnit;
+
+public final class ClientCacheExampleActivity extends AppCompatActivity {
+  private static final int CACHE_SIZE_IN_BYTES = 1 * 1024 * 1024; // 1MB
+  private static final String TAG = "grpcCacheExample";
+  private Button sendButton;
+  private EditText hostEdit;
+  private EditText portEdit;
+  private EditText messageEdit;
+  private TextView resultText;
+  private CheckBox getCheckBox;
+  private CheckBox noCacheCheckBox;
+  private CheckBox onlyIfCachedCheckBox;
+  private SafeMethodCachingInterceptor.Cache cache;
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.activity_clientcacheexample);
+    sendButton = (Button) findViewById(R.id.send_button);
+    hostEdit = (EditText) findViewById(R.id.host_edit_text);
+    portEdit = (EditText) findViewById(R.id.port_edit_text);
+    messageEdit = (EditText) findViewById(R.id.message_edit_text);
+    getCheckBox = (CheckBox) findViewById(R.id.get_checkbox);
+    noCacheCheckBox = (CheckBox) findViewById(R.id.no_cache_checkbox);
+    onlyIfCachedCheckBox = (CheckBox) findViewById(R.id.only_if_cached_checkbox);
+    resultText = (TextView) findViewById(R.id.grpc_response_text);
+    resultText.setMovementMethod(new ScrollingMovementMethod());
+    cache = SafeMethodCachingInterceptor.newLruCache(CACHE_SIZE_IN_BYTES);
+  }
+
+  /** Sends RPC. Invoked when app button is pressed. */
+  public void sendMessage(View view) {
+    ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE))
+        .hideSoftInputFromWindow(hostEdit.getWindowToken(), 0);
+    sendButton.setEnabled(false);
+    resultText.setText("");
+    new GrpcTask(this, cache)
+        .execute(
+            hostEdit.getText().toString(),
+            messageEdit.getText().toString(),
+            portEdit.getText().toString(),
+            getCheckBox.isChecked(),
+            noCacheCheckBox.isChecked(),
+            onlyIfCachedCheckBox.isChecked());
+  }
+
+  private static class GrpcTask extends AsyncTask<Object, Void, String> {
+    private final WeakReference<Activity> activityReference;
+    private final SafeMethodCachingInterceptor.Cache cache;
+    private ManagedChannel channel;
+
+    private GrpcTask(Activity activity, SafeMethodCachingInterceptor.Cache cache) {
+      this.activityReference = new WeakReference<Activity>(activity);
+      this.cache = cache;
+    }
+
+    @Override
+    protected String doInBackground(Object... params) {
+      String host = (String) params[0];
+      String message = (String) params[1];
+      String portStr = (String) params[2];
+      boolean useGet = (boolean) params[3];
+      boolean noCache = (boolean) params[4];
+      boolean onlyIfCached = (boolean) params[5];
+      int port = TextUtils.isEmpty(portStr) ? 0 : Integer.valueOf(portStr);
+      try {
+        channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext().build();
+        Channel channelToUse =
+            ClientInterceptors.intercept(
+                channel, SafeMethodCachingInterceptor.newSafeMethodCachingInterceptor(cache));
+        HelloRequest request = HelloRequest.newBuilder().setName(message).build();
+        HelloReply reply;
+        if (useGet) {
+          MethodDescriptor<HelloRequest, HelloReply> safeCacheableUnaryCallMethod =
+              GreeterGrpc.getSayHelloMethod().toBuilder().setSafe(true).build();
+          CallOptions callOptions = CallOptions.DEFAULT;
+          if (noCache) {
+            callOptions =
+                callOptions.withOption(SafeMethodCachingInterceptor.NO_CACHE_CALL_OPTION, true);
+          }
+          if (onlyIfCached) {
+            callOptions =
+                callOptions.withOption(
+                    SafeMethodCachingInterceptor.ONLY_IF_CACHED_CALL_OPTION, true);
+          }
+          reply =
+              ClientCalls.blockingUnaryCall(
+                  channelToUse, safeCacheableUnaryCallMethod, callOptions, request);
+        } else {
+          GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(channelToUse);
+          reply = stub.sayHello(request);
+        }
+        return reply.getMessage();
+      } catch (Exception e) {
+        Log.e(TAG, "RPC failed", e);
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw);
+        e.printStackTrace(pw);
+        pw.flush();
+        return String.format("Failed... : %n%s", sw);
+      }
+    }
+
+    @Override
+    protected void onPostExecute(String result) {
+      if (channel != null) {
+        try {
+          channel.shutdown().awaitTermination(1, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+        }
+      }
+      Activity activity = activityReference.get();
+      if (activity == null) {
+        return;
+      }
+      TextView resultText = (TextView) activity.findViewById(R.id.grpc_response_text);
+      Button sendButton = (Button) activity.findViewById(R.id.send_button);
+      resultText.setText(result);
+      sendButton.setEnabled(true);
+    }
+  }
+}
diff --git a/examples/android/clientcache/app/src/main/java/io/grpc/clientcacheexample/SafeMethodCachingInterceptor.java b/examples/android/clientcache/app/src/main/java/io/grpc/clientcacheexample/SafeMethodCachingInterceptor.java
new file mode 100644
index 00000000000..6dfc6d48d04
--- /dev/null
+++ b/examples/android/clientcache/app/src/main/java/io/grpc/clientcacheexample/SafeMethodCachingInterceptor.java
@@ -0,0 +1,301 @@
+package io.grpc.clientcacheexample;
+
+import android.util.Log;
+import android.util.LruCache;
+import com.google.common.base.Splitter;
+import com.google.protobuf.MessageLite;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.Deadline;
+import io.grpc.ForwardingClientCall;
+import io.grpc.ForwardingClientCallListener;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * An example of an on-device cache for Android implemented using the {@link ClientInterceptor} API.
+ *
+ * <p>Client-side cache-control directives are not directly supported. Instead, two call options can
+ * be added to the call: no-cache (always go to the network) or only-if-cached (never use network;
+ * if response is not in cache, the request fails).
+ *
+ * <p>This interceptor respects the cache-control directives in the server's response: max-age
+ * determines when the cache entry goes stale. no-cache, no-store, and no-transform entirely skip
+ * caching of the response. must-revalidate is ignored, as the cache does not support returning
+ * stale responses.
+ *
+ * <p>Note: other response headers besides cache-control (such as Expiration, Varies) are ignored by
+ * this implementation.
+ */
+final class SafeMethodCachingInterceptor implements ClientInterceptor {
+  static CallOptions.Key<Boolean> NO_CACHE_CALL_OPTION = CallOptions.Key.of("no-cache", false);
+  static CallOptions.Key<Boolean> ONLY_IF_CACHED_CALL_OPTION =
+      CallOptions.Key.of("only-if-cached", false);
+  private static final String TAG = "grpcCacheExample";
+
+  public static final class Key {
+    private final String fullMethodName;
+    private final MessageLite request;
+
+    public Key(String fullMethodName, MessageLite request) {
+      this.fullMethodName = fullMethodName;
+      this.request = request;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+      if (object instanceof Key) {
+        Key other = (Key) object;
+        return Objects.equals(this.fullMethodName, other.fullMethodName)
+            && Objects.equals(this.request, other.request);
+      }
+      return false;
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(fullMethodName, request);
+    }
+  }
+
+  public static final class Value {
+    private final MessageLite response;
+    private final Deadline maxAgeDeadline;
+
+    public Value(MessageLite response, Deadline maxAgeDeadline) {
+      this.response = response;
+      this.maxAgeDeadline = maxAgeDeadline;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+      if (object instanceof Value) {
+        Value other = (Value) object;
+        return Objects.equals(this.response, other.response)
+            && Objects.equals(this.maxAgeDeadline, other.maxAgeDeadline);
+      }
+      return false;
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(response, maxAgeDeadline);
+    }
+  }
+
+  public interface Cache {
+    void put(Key key, Value value);
+
+    Value get(Key key);
+
+    void remove(Key key);
+
+    void clear();
+  }
+
+  /**
+   * Obtain a new cache with a least-recently used eviction policy and the specified size limit. The
+   * backing caching implementation is provided by {@link LruCache}. It is safe for a single cache
+   * to be shared across multiple {@link SafeMethodCachingInterceptor}s without synchronization.
+   */
+  public static Cache newLruCache(final int cacheSizeInBytes) {
+    return new Cache() {
+      private final LruCache<Key, Value> lruCache =
+          new LruCache<Key, Value>(cacheSizeInBytes) {
+            protected int sizeOf(Key key, Value value) {
+              return value.response.getSerializedSize();
+            }
+          };
+
+      @Override
+      public void put(Key key, Value value) {
+        lruCache.put(key, value);
+      }
+
+      @Override
+      public Value get(Key key) {
+        return lruCache.get(key);
+      }
+
+      @Override
+      public void remove(Key key) {
+        lruCache.remove(key);
+      }
+
+      @Override
+      public void clear() {
+        lruCache.evictAll();
+      }
+    };
+  }
+
+  public static SafeMethodCachingInterceptor newSafeMethodCachingInterceptor(Cache cache) {
+    return newSafeMethodCachingInterceptor(cache, DEFAULT_MAX_AGE_SECONDS);
+  }
+
+  public static SafeMethodCachingInterceptor newSafeMethodCachingInterceptor(
+      Cache cache, int defaultMaxAge) {
+    return new SafeMethodCachingInterceptor(cache, defaultMaxAge);
+  }
+
+  private static int DEFAULT_MAX_AGE_SECONDS = 3600;
+
+  private static final Metadata.Key<String> CACHE_CONTROL_KEY =
+      Metadata.Key.of("cache-control", Metadata.ASCII_STRING_MARSHALLER);
+
+  private static final Splitter CACHE_CONTROL_SPLITTER =
+      Splitter.on(',').trimResults().omitEmptyStrings();
+
+  private final Cache internalCache;
+  private final int defaultMaxAge;
+
+  private SafeMethodCachingInterceptor(Cache cache, int defaultMaxAge) {
+    this.internalCache = cache;
+    this.defaultMaxAge = defaultMaxAge;
+  }
+
+  @Override
+  public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+      final MethodDescriptor<ReqT, RespT> method, final CallOptions callOptions, Channel next) {
+    // Currently only unary methods can be marked safe, but check anyways.
+    if (!method.isSafe() || method.getType() != MethodDescriptor.MethodType.UNARY) {
+      return next.newCall(method, callOptions);
+    }
+
+    final String fullMethodName = method.getFullMethodName();
+
+    return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(
+        next.newCall(method, callOptions)) {
+      private Listener<RespT> interceptedListener;
+      private Key requestKey;
+      private boolean cacheResponse = true;
+      private volatile String cacheOptionsErrorMsg;
+
+      @Override
+      public void start(Listener<RespT> responseListener, Metadata headers) {
+        interceptedListener =
+            new ForwardingClientCallListener.SimpleForwardingClientCallListener<RespT>(
+                responseListener) {
+              private Deadline deadline;
+              private int maxAge = -1;
+
+              @Override
+              public void onHeaders(Metadata headers) {
+                Iterable<String> cacheControlHeaders = headers.getAll(CACHE_CONTROL_KEY);
+                if (cacheResponse && cacheControlHeaders != null) {
+                  for (String cacheControlHeader : cacheControlHeaders) {
+                    for (String directive : CACHE_CONTROL_SPLITTER.split(cacheControlHeader)) {
+                      if (directive.equalsIgnoreCase("no-cache")) {
+                        cacheResponse = false;
+                        break;
+                      } else if (directive.equalsIgnoreCase("no-store")) {
+                        cacheResponse = false;
+                        break;
+                      } else if (directive.equalsIgnoreCase("no-transform")) {
+                        cacheResponse = false;
+                        break;
+                      } else if (directive.toLowerCase(Locale.US).startsWith("max-age")) {
+                        String[] parts = directive.split("=");
+                        if (parts.length == 2) {
+                          try {
+                            maxAge = Integer.parseInt(parts[1]);
+                          } catch (NumberFormatException e) {
+                            Log.e(TAG, "max-age directive failed to parse", e);
+                            continue;
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+                if (cacheResponse) {
+                  if (maxAge > -1) {
+                    deadline = Deadline.after(maxAge, TimeUnit.SECONDS);
+                  } else {
+                    deadline = Deadline.after(defaultMaxAge, TimeUnit.SECONDS);
+                  }
+                }
+                super.onHeaders(headers);
+              }
+
+              @Override
+              public void onMessage(RespT message) {
+                if (cacheResponse && !deadline.isExpired()) {
+                  Value value = new Value((MessageLite) message, deadline);
+                  internalCache.put(requestKey, value);
+                }
+                super.onMessage(message);
+              }
+
+              @Override
+              public void onClose(Status status, Metadata trailers) {
+                if (cacheOptionsErrorMsg != null) {
+                  // UNAVAILABLE is the canonical gRPC mapping for HTTP response code 504 (as used
+                  // by the built-in Android HTTP request cache).
+                  super.onClose(
+                      Status.UNAVAILABLE.withDescription(cacheOptionsErrorMsg), new Metadata());
+                } else {
+                  super.onClose(status, trailers);
+                }
+              }
+            };
+        delegate().start(interceptedListener, headers);
+      }
+
+      @Override
+      public void sendMessage(ReqT message) {
+        boolean noCache = callOptions.getOption(NO_CACHE_CALL_OPTION);
+        boolean onlyIfCached = callOptions.getOption(ONLY_IF_CACHED_CALL_OPTION);
+
+        if (noCache) {
+          if (onlyIfCached) {
+            cacheOptionsErrorMsg = "Unsatisfiable Request (no-cache and only-if-cached conflict)";
+            super.cancel(cacheOptionsErrorMsg, null);
+            return;
+          }
+          cacheResponse = false;
+          super.sendMessage(message);
+          return;
+        }
+
+        // Check the cache
+        requestKey = new Key(fullMethodName, (MessageLite) message);
+        Value cachedResponse = internalCache.get(requestKey);
+        if (cachedResponse != null) {
+          if (cachedResponse.maxAgeDeadline.isExpired()) {
+            internalCache.remove(requestKey);
+          } else {
+            cacheResponse = false; // already cached
+            interceptedListener.onMessage((RespT) cachedResponse.response);
+            Metadata metadata = new Metadata();
+            interceptedListener.onClose(Status.OK, metadata);
+            return;
+          }
+        }
+
+        if (onlyIfCached) {
+          cacheOptionsErrorMsg =
+              "Unsatisfiable Request (only-if-cached set, but value not in cache)";
+          super.cancel(cacheOptionsErrorMsg, null);
+          return;
+        }
+        super.sendMessage(message);
+      }
+
+      @Override
+      public void halfClose() {
+        if (cacheOptionsErrorMsg != null) {
+          // already canceled
+          return;
+        }
+        super.halfClose();
+      }
+    };
+  }
+}
diff --git a/examples/android/clientcache/app/src/main/proto/helloworld.proto b/examples/android/clientcache/app/src/main/proto/helloworld.proto
new file mode 100644
index 00000000000..3ee78e7a900
--- /dev/null
+++ b/examples/android/clientcache/app/src/main/proto/helloworld.proto
@@ -0,0 +1,44 @@
+// Copyright 2015 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+
+  rpc SayAnotherHello (HelloRequest) returns (HelloReply) {}
+
+}
+
+service AnotherGreeter {
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/android/clientcache/app/src/main/res/layout/activity_clientcacheexample.xml b/examples/android/clientcache/app/src/main/res/layout/activity_clientcacheexample.xml
new file mode 100644
index 00000000000..2e48e8a2738
--- /dev/null
+++ b/examples/android/clientcache/app/src/main/res/layout/activity_clientcacheexample.xml
@@ -0,0 +1,73 @@
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+              xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
+              android:layout_height="match_parent"
+              tools:context=".MainActivity"
+              android:orientation="vertical" >
+
+    <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal">
+        <EditText
+                android:id="@+id/host_edit_text"
+                android:layout_weight="2"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:hint="Enter Host" />
+        <EditText
+                android:id="@+id/port_edit_text"
+                android:layout_weight="1"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:inputType="numberDecimal"
+                android:hint="Enter Port" />
+    </LinearLayout>
+
+
+    <EditText
+            android:id="@+id/message_edit_text"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:hint="Enter message to send" />
+
+    <CheckBox android:id="@+id/get_checkbox"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="Use GET"
+        />
+
+    <CheckBox android:id="@+id/no_cache_checkbox"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="Cache-control: no-cache (only for GET)"
+        />
+
+    <CheckBox android:id="@+id/only_if_cached_checkbox"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="Cache-control: only-if-cached (only for GET)"
+        />
+
+    <Button
+            android:id="@+id/send_button"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:onClick="sendMessage"
+            android:text="Send Grpc Request" />
+
+    <TextView
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:paddingTop="12dp"
+            android:paddingBottom="12dp"
+            android:textSize="16sp"
+            android:text="Response:" />
+
+    <TextView
+            android:id="@+id/grpc_response_text"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:scrollbars = "vertical"
+            android:textSize="16sp" />
+
+</LinearLayout>
diff --git a/examples/android/clientcache/app/src/main/res/mipmap-hdpi/ic_launcher.png b/examples/android/clientcache/app/src/main/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 00000000000..cde69bcccec
Binary files /dev/null and b/examples/android/clientcache/app/src/main/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/examples/android/clientcache/app/src/main/res/mipmap-mdpi/ic_launcher.png b/examples/android/clientcache/app/src/main/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 00000000000..c133a0cbd37
Binary files /dev/null and b/examples/android/clientcache/app/src/main/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/examples/android/clientcache/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/examples/android/clientcache/app/src/main/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 00000000000..bfa42f0e7b9
Binary files /dev/null and b/examples/android/clientcache/app/src/main/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/examples/android/clientcache/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/examples/android/clientcache/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 00000000000..324e72cdd74
Binary files /dev/null and b/examples/android/clientcache/app/src/main/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/examples/android/clientcache/app/src/main/res/values/strings.xml b/examples/android/clientcache/app/src/main/res/values/strings.xml
new file mode 100644
index 00000000000..0f8d82d9523
--- /dev/null
+++ b/examples/android/clientcache/app/src/main/res/values/strings.xml
@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">GrpcClientCacheExample</string>
+</resources>
diff --git a/examples/android/clientcache/app/src/test/java/io/grpc/clientcacheexample/SafeMethodCachingInterceptorTest.java b/examples/android/clientcache/app/src/test/java/io/grpc/clientcacheexample/SafeMethodCachingInterceptorTest.java
new file mode 100644
index 00000000000..63e8a329040
--- /dev/null
+++ b/examples/android/clientcache/app/src/test/java/io/grpc/clientcacheexample/SafeMethodCachingInterceptorTest.java
@@ -0,0 +1,557 @@
+package io.grpc.clientcacheexample;
+
+import com.google.common.truth.Truth;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientInterceptors;
+import io.grpc.ForwardingServerCall;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerInterceptors;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.AnotherGreeterGrpc;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.ClientCalls;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcServerRule;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+public class SafeMethodCachingInterceptorTest {
+  private static final Metadata.Key<String> CACHE_CONTROL_METADATA_KEY =
+      Metadata.Key.of("cache-control", Metadata.ASCII_STRING_MARSHALLER);
+
+  @Rule public final GrpcServerRule grpcServerRule = new GrpcServerRule().directExecutor();
+
+  private final GreeterGrpc.GreeterImplBase greeterServiceImpl =
+      new GreeterGrpc.GreeterImplBase() {
+        private int count = 1;
+
+        @Override
+        public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+          HelloReply reply =
+              HelloReply.newBuilder().setMessage("Hello " + req.getName() + " " + count++).build();
+          responseObserver.onNext(reply);
+          responseObserver.onCompleted();
+        }
+
+        @Override
+        public void sayAnotherHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+          HelloReply reply =
+              HelloReply.newBuilder()
+                  .setMessage("Hello again " + req.getName() + " " + count++)
+                  .build();
+          responseObserver.onNext(reply);
+          responseObserver.onCompleted();
+        }
+      };
+
+  private final AnotherGreeterGrpc.AnotherGreeterImplBase anotherGreeterServiceImpl =
+      new AnotherGreeterGrpc.AnotherGreeterImplBase() {
+        private int count = 1;
+
+        @Override
+        public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+          HelloReply reply =
+              HelloReply.newBuilder().setMessage("Hey " + req.getName() + " " + count++).build();
+          responseObserver.onNext(reply);
+          responseObserver.onCompleted();
+        }
+      };
+
+  private final List<String> cacheControlDirectives = new ArrayList<>();
+  private ServerInterceptor injectCacheControlInterceptor =
+      new ServerInterceptor() {
+        @Override
+        public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+            ServerCall<ReqT, RespT> call,
+            final Metadata requestHeaders,
+            ServerCallHandler<ReqT, RespT> next) {
+          return next.startCall(
+              new ForwardingServerCall.SimpleForwardingServerCall<ReqT, RespT>(call) {
+                @Override
+                public void sendHeaders(Metadata headers) {
+                  for (String cacheControlDirective : cacheControlDirectives) {
+                    headers.put(CACHE_CONTROL_METADATA_KEY, cacheControlDirective);
+                  }
+                  super.sendHeaders(headers);
+                }
+              },
+              requestHeaders);
+        }
+      };
+
+  private final HelloRequest message = HelloRequest.newBuilder().setName("Test Name").build();
+  private final MethodDescriptor<HelloRequest, HelloReply> safeGreeterSayHelloMethod =
+      GreeterGrpc.getSayHelloMethod().toBuilder().setSafe(true).build();
+  private final TestCache cache = new TestCache();
+
+  private ManagedChannel baseChannel;
+  private Channel channelToUse;
+
+  @Before
+  public void setUp() throws Exception {
+    grpcServerRule
+        .getServiceRegistry()
+        .addService(
+            ServerInterceptors.intercept(greeterServiceImpl, injectCacheControlInterceptor));
+    grpcServerRule.getServiceRegistry().addService(anotherGreeterServiceImpl);
+    baseChannel = grpcServerRule.getChannel();
+
+    SafeMethodCachingInterceptor interceptor =
+        SafeMethodCachingInterceptor.newSafeMethodCachingInterceptor(cache);
+
+    channelToUse = ClientInterceptors.intercept(baseChannel, interceptor);
+  }
+
+  @After
+  public void tearDown() {
+    baseChannel.shutdown();
+  }
+
+  @Test
+  public void safeCallsAreCached() {
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+
+    assertSame(reply1, reply2);
+  }
+
+  @Test
+  public void safeCallsAreCachedWithCopiedMethodDescriptor() {
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse,
+            safeGreeterSayHelloMethod.toBuilder().build(),
+            CallOptions.DEFAULT,
+            message);
+
+    assertSame(reply1, reply2);
+  }
+
+  @Test
+  public void requestWithNoCacheOptionSkipsCache() {
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse,
+            safeGreeterSayHelloMethod,
+            CallOptions.DEFAULT.withOption(SafeMethodCachingInterceptor.NO_CACHE_CALL_OPTION, true),
+            message);
+    HelloReply reply3 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+
+    assertNotEquals(reply1, reply2);
+    assertSame(reply1, reply3);
+  }
+
+  @Test
+  public void requestWithOnlyIfCachedOption_unavailableIfNotInCache() {
+    try {
+      ClientCalls.blockingUnaryCall(
+          channelToUse,
+          safeGreeterSayHelloMethod,
+          CallOptions.DEFAULT.withOption(
+              SafeMethodCachingInterceptor.ONLY_IF_CACHED_CALL_OPTION, true),
+          message);
+      fail("Expected call to fail");
+    } catch (StatusRuntimeException sre) {
+      assertEquals(Status.UNAVAILABLE.getCode(), sre.getStatus().getCode());
+      assertEquals(
+          "Unsatisfiable Request (only-if-cached set, but value not in cache)",
+          sre.getStatus().getDescription());
+    }
+  }
+
+  @Test
+  public void requestWithOnlyIfCachedOption_usesCache() {
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse,
+            safeGreeterSayHelloMethod,
+            CallOptions.DEFAULT.withOption(
+                SafeMethodCachingInterceptor.ONLY_IF_CACHED_CALL_OPTION, true),
+            message);
+
+    assertSame(reply1, reply2);
+  }
+
+  @Test
+  public void requestWithNoCacheAndOnlyIfCached_fails() {
+    try {
+      ClientCalls.blockingUnaryCall(
+          channelToUse,
+          safeGreeterSayHelloMethod,
+          CallOptions.DEFAULT
+              .withOption(SafeMethodCachingInterceptor.NO_CACHE_CALL_OPTION, true)
+              .withOption(SafeMethodCachingInterceptor.ONLY_IF_CACHED_CALL_OPTION, true),
+          message);
+      fail("Expected call to fail");
+    } catch (StatusRuntimeException sre) {
+      assertEquals(Status.UNAVAILABLE.getCode(), sre.getStatus().getCode());
+      assertEquals(
+          "Unsatisfiable Request (no-cache and only-if-cached conflict)",
+          sre.getStatus().getDescription());
+    }
+  }
+
+  @Test
+  public void responseNoCacheDirective_notCached() throws Exception {
+    cacheControlDirectives.add("no-cache");
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+
+    assertNotEquals(reply1, reply2);
+    assertNotEquals(reply1, reply2);
+    Truth.assertThat(cache.internalCache).isEmpty();
+    Truth.assertThat(cache.removedKeys).isEmpty();
+  }
+
+  @Test
+  public void responseNoStoreDirective_notCached() throws Exception {
+    cacheControlDirectives.add("no-store");
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+
+    assertNotEquals(reply1, reply2);
+    Truth.assertThat(cache.internalCache).isEmpty();
+    Truth.assertThat(cache.removedKeys).isEmpty();
+  }
+
+  @Test
+  public void responseNoTransformDirective_notCached() throws Exception {
+    cacheControlDirectives.add("no-transform");
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+
+    assertNotEquals(reply1, reply2);
+    Truth.assertThat(cache.internalCache).isEmpty();
+    Truth.assertThat(cache.removedKeys).isEmpty();
+  }
+
+  @Test
+  public void responseMustRevalidateDirective_isIgnored() throws Exception {
+    cacheControlDirectives.add("must-revalidate");
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+
+    assertSame(reply1, reply2);
+  }
+
+  @Test
+  public void responseMaxAge_caseInsensitive() throws Exception {
+    cacheControlDirectives.add("MaX-aGe=0");
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+
+    assertNotEquals(reply1, reply2);
+    Truth.assertThat(cache.internalCache).isEmpty();
+    Truth.assertThat(cache.removedKeys).isEmpty();
+  }
+
+  @Test
+  public void responseNoCache_caseInsensitive() throws Exception {
+    cacheControlDirectives.add("No-CaCHe");
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+
+    assertNotEquals(reply1, reply2);
+    Truth.assertThat(cache.internalCache).isEmpty();
+    Truth.assertThat(cache.removedKeys).isEmpty();
+  }
+
+  @Test
+  public void combinedResponseCacheControlDirectives_parsesWithoutError() throws Exception {
+    cacheControlDirectives.add("max-age=1,no-store , no-cache");
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+
+    assertNotEquals(reply1, reply2);
+    Truth.assertThat(cache.internalCache).isEmpty();
+    Truth.assertThat(cache.removedKeys).isEmpty();
+  }
+
+  @Test
+  public void separateResponseCacheControlDirectives_parsesWithoutError() throws Exception {
+    cacheControlDirectives.add("max-age=1");
+    cacheControlDirectives.add("no-store , no-cache");
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+
+    assertNotEquals(reply1, reply2);
+    Truth.assertThat(cache.internalCache).isEmpty();
+    Truth.assertThat(cache.removedKeys).isEmpty();
+  }
+
+  @Test
+  public void afterResponseMaxAge_cacheEntryInvalidated() throws Exception {
+    cacheControlDirectives.add("max-age=1");
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    assertSame(reply1, reply2);
+
+    // Wait for cache entry to expire
+    sleepAtLeast(1001);
+
+    assertNotEquals(
+        reply1,
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message));
+    Truth.assertThat(cache.removedKeys).hasSize(1);
+    assertEquals(
+        new SafeMethodCachingInterceptor.Key(
+            GreeterGrpc.getSayHelloMethod().getFullMethodName(), message),
+        cache.removedKeys.get(0));
+  }
+
+  @Test
+  public void invalidResponseMaxAge_usesDefault() throws Exception {
+    SafeMethodCachingInterceptor interceptorWithCustomMaxAge =
+        SafeMethodCachingInterceptor.newSafeMethodCachingInterceptor(cache, 1);
+    channelToUse = ClientInterceptors.intercept(baseChannel, interceptorWithCustomMaxAge);
+    cacheControlDirectives.add("max-age=-10");
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    assertEquals(reply1, reply2);
+
+    // Wait for cache entry to expire
+    sleepAtLeast(1001);
+
+    assertNotEquals(
+        reply1,
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message));
+    Truth.assertThat(cache.removedKeys).hasSize(1);
+    assertEquals(
+        new SafeMethodCachingInterceptor.Key(
+            GreeterGrpc.getSayHelloMethod().getFullMethodName(), message),
+        cache.removedKeys.get(0));
+  }
+
+  @Test
+  public void responseMaxAgeZero_notAddedToCache() throws Exception {
+    cacheControlDirectives.add("max-age=0");
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+
+    assertNotEquals(reply1, reply2);
+    Truth.assertThat(cache.internalCache).isEmpty();
+    Truth.assertThat(cache.removedKeys).isEmpty();
+  }
+
+  @Test
+  public void cacheHit_doesNotResetExpiration() throws Exception {
+    cacheControlDirectives.add("max-age=1");
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+
+    sleepAtLeast(1001);
+
+    HelloReply reply3 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+
+    assertSame(reply1, reply2);
+    assertNotEquals(reply1, reply3);
+    Truth.assertThat(cache.internalCache).hasSize(1);
+    Truth.assertThat(cache.removedKeys).hasSize(1);
+  }
+
+  @Test
+  public void afterDefaultMaxAge_cacheEntryInvalidated() throws Exception {
+    SafeMethodCachingInterceptor interceptorWithCustomMaxAge =
+        SafeMethodCachingInterceptor.newSafeMethodCachingInterceptor(cache, 1);
+    channelToUse = ClientInterceptors.intercept(baseChannel, interceptorWithCustomMaxAge);
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    assertSame(reply1, reply2);
+
+    // Wait for cache entry to expire
+    sleepAtLeast(1001);
+
+    assertNotEquals(
+        reply1,
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message));
+    Truth.assertThat(cache.removedKeys).hasSize(1);
+    assertEquals(
+        new SafeMethodCachingInterceptor.Key(
+            GreeterGrpc.getSayHelloMethod().getFullMethodName(), message),
+        cache.removedKeys.get(0));
+  }
+
+  @Test
+  public void unsafeCallsAreNotCached() {
+    GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(channelToUse);
+
+    HelloReply reply1 = stub.sayHello(message);
+    HelloReply reply2 = stub.sayHello(message);
+
+    assertNotEquals(reply1, reply2);
+  }
+
+  @Test
+  public void differentMethodCallsAreNotConflated() {
+    MethodDescriptor<HelloRequest, HelloReply> anotherSafeMethod =
+        GreeterGrpc.getSayAnotherHelloMethod().toBuilder().setSafe(true).build();
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, anotherSafeMethod, CallOptions.DEFAULT, message);
+
+    assertNotEquals(reply1, reply2);
+  }
+
+  @Test
+  public void differentServiceCallsAreNotConflated() {
+    MethodDescriptor<HelloRequest, HelloReply> anotherSafeMethod =
+        AnotherGreeterGrpc.getSayHelloMethod().toBuilder().setSafe(true).build();
+
+    HelloReply reply1 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, safeGreeterSayHelloMethod, CallOptions.DEFAULT, message);
+    HelloReply reply2 =
+        ClientCalls.blockingUnaryCall(
+            channelToUse, anotherSafeMethod, CallOptions.DEFAULT, message);
+
+    assertNotEquals(reply1, reply2);
+  }
+
+  private static void sleepAtLeast(long millis) throws InterruptedException {
+    long delay = TimeUnit.MILLISECONDS.toNanos(millis);
+    long end = System.nanoTime() + delay;
+    while (delay > 0) {
+      TimeUnit.NANOSECONDS.sleep(delay);
+      delay = end - System.nanoTime();
+    }
+  }
+
+  private static class TestCache implements SafeMethodCachingInterceptor.Cache {
+    private Map<SafeMethodCachingInterceptor.Key, SafeMethodCachingInterceptor.Value>
+        internalCache =
+            new HashMap<SafeMethodCachingInterceptor.Key, SafeMethodCachingInterceptor.Value>();
+    private List<SafeMethodCachingInterceptor.Key> removedKeys =
+        new ArrayList<SafeMethodCachingInterceptor.Key>();
+
+    @Override
+    public void put(
+        SafeMethodCachingInterceptor.Key key, SafeMethodCachingInterceptor.Value value) {
+      internalCache.put(key, value);
+    }
+
+    @Override
+    public SafeMethodCachingInterceptor.Value get(SafeMethodCachingInterceptor.Key key) {
+      return internalCache.get(key);
+    }
+
+    @Override
+    public void remove(SafeMethodCachingInterceptor.Key key) {
+      removedKeys.add(key);
+      internalCache.remove(key);
+    }
+
+    @Override
+    public void clear() {}
+  }
+}
diff --git a/examples/android/clientcache/build.gradle b/examples/android/clientcache/build.gradle
new file mode 100644
index 00000000000..6db6a9bced1
--- /dev/null
+++ b/examples/android/clientcache/build.gradle
@@ -0,0 +1,23 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:7.4.0'
+        classpath "com.google.protobuf:protobuf-gradle-plugin:0.9.5"
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+        mavenLocal()
+    }
+}
diff --git a/examples/android/clientcache/settings.gradle b/examples/android/clientcache/settings.gradle
new file mode 100644
index 00000000000..6208d70e838
--- /dev/null
+++ b/examples/android/clientcache/settings.gradle
@@ -0,0 +1,17 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+}
+
+include ':app'
diff --git a/examples/android/helloworld/app/build.gradle b/examples/android/helloworld/app/build.gradle
index d7637141fcb..afc2a97e92f 100644
--- a/examples/android/helloworld/app/build.gradle
+++ b/examples/android/helloworld/app/build.gradle
@@ -2,63 +2,57 @@ apply plugin: 'com.android.application'
 apply plugin: 'com.google.protobuf'
 
 android {
-    compileSdkVersion 22
-    buildToolsVersion "22.0.1"
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    compileSdkVersion 34
 
     defaultConfig {
-        applicationId "io.grpc.android.helloworldexample"
-        minSdkVersion 9
-        targetSdkVersion 22
+        applicationId "io.grpc.helloworldexample"
+        minSdkVersion 21
+        targetSdkVersion 33
         versionCode 1
         versionName "1.0"
     }
     buildTypes {
+        debug { minifyEnabled false }
         release {
             minifyEnabled true
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
     lintOptions {
-        disable 'InvalidPackage', 'HardcodedText'
+        disable 'GoogleAppIndexingWarning', 'HardcodedText', 'InvalidPackage'
         textReport true
         textOutput "stdout"
     }
 }
 
 protobuf {
-    protoc {
-        artifact = 'com.google.protobuf:protoc:3.2.0'
-    }
+    protoc { artifact = 'com.google.protobuf:protoc:3.25.1' }
     plugins {
-        javalite {
-            artifact = "com.google.protobuf:protoc-gen-javalite:3.0.0"
-        }
-        grpc {
-            artifact = 'io.grpc:protoc-gen-grpc-java:1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
         }
     }
     generateProtoTasks {
         all().each { task ->
+            task.builtins {
+                java { option 'lite' }
+            }
             task.plugins {
-                javalite {}
-                grpc {
-                    // Options added to --grpc_out
-                    option 'lite'
-                }
+                grpc { // Options added to --grpc_out
+                    option 'lite' }
             }
         }
     }
 }
 
 dependencies {
-    compile 'com.android.support:appcompat-v7:22.1.1'
-    compile 'com.google.code.findbugs:jsr305:3.0.0'
-    compile 'com.google.guava:guava:20.0'
-    compile 'com.squareup.okhttp:okhttp:2.2.0'
+    implementation 'androidx.appcompat:appcompat:1.0.0'
 
     // You need to build grpc-java to obtain these libraries below.
-    compile 'io.grpc:grpc-okhttp:1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    compile 'io.grpc:grpc-protobuf-lite:1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    compile 'io.grpc:grpc-stub:1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    compile 'javax.annotation:javax.annotation-api:1.2'
+    implementation 'io.grpc:grpc-okhttp:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-protobuf-lite:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-stub:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
 }
diff --git a/examples/android/helloworld/app/proguard-rules.pro b/examples/android/helloworld/app/proguard-rules.pro
index 6471f5f3648..1507a526787 100644
--- a/examples/android/helloworld/app/proguard-rules.pro
+++ b/examples/android/helloworld/app/proguard-rules.pro
@@ -9,10 +9,9 @@
 
 # Add any project specific keep options here:
 
--dontwarn sun.misc.Unsafe
 -dontwarn com.google.common.**
--dontwarn okio.**
 # Ignores: can't find referenced class javax.lang.model.element.Modifier
 -dontwarn com.google.errorprone.annotations.**
--keep class io.grpc.internal.DnsNameResolverProvider
--keep class io.grpc.okhttp.OkHttpChannelProvider
+-dontwarn javax.naming.**
+-dontwarn okio.**
+-dontwarn sun.misc.Unsafe
diff --git a/examples/android/helloworld/app/src/main/AndroidManifest.xml b/examples/android/helloworld/app/src/main/AndroidManifest.xml
index 8c40f11684d..0beff2dc840 100644
--- a/examples/android/helloworld/app/src/main/AndroidManifest.xml
+++ b/examples/android/helloworld/app/src/main/AndroidManifest.xml
@@ -5,13 +5,14 @@
     <uses-permission android:name="android.permission.INTERNET" />
 
     <application
-        android:allowBackup="true"
+        android:allowBackup="false"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:theme="@style/Base.V7.Theme.AppCompat.Light" >
         <activity
             android:name=".HelloworldActivity"
-            android:label="@string/app_name" >
+            android:label="@string/app_name"
+            android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
diff --git a/examples/android/helloworld/app/src/main/java/io/grpc/helloworldexample/HelloworldActivity.java b/examples/android/helloworld/app/src/main/java/io/grpc/helloworldexample/HelloworldActivity.java
index b4329df1fc5..201c385a7aa 100644
--- a/examples/android/helloworld/app/src/main/java/io/grpc/helloworldexample/HelloworldActivity.java
+++ b/examples/android/helloworld/app/src/main/java/io/grpc/helloworldexample/HelloworldActivity.java
@@ -1,40 +1,26 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.helloworldexample;
 
+import android.app.Activity;
 import android.content.Context;
 import android.os.AsyncTask;
 import android.os.Bundle;
-import android.support.v7.app.ActionBarActivity;
+import androidx.appcompat.app.AppCompatActivity;
 import android.text.TextUtils;
 import android.text.method.ScrollingMovementMethod;
 import android.view.View;
@@ -42,86 +28,98 @@
 import android.widget.Button;
 import android.widget.EditText;
 import android.widget.TextView;
-
 import io.grpc.ManagedChannel;
 import io.grpc.ManagedChannelBuilder;
 import io.grpc.examples.helloworld.GreeterGrpc;
 import io.grpc.examples.helloworld.HelloReply;
 import io.grpc.examples.helloworld.HelloRequest;
-
 import java.io.PrintWriter;
 import java.io.StringWriter;
+import java.lang.ref.WeakReference;
 import java.util.concurrent.TimeUnit;
 
-public class HelloworldActivity extends ActionBarActivity {
-    private Button mSendButton;
-    private EditText mHostEdit;
-    private EditText mPortEdit;
-    private EditText mMessageEdit;
-    private TextView mResultText;
+public class HelloworldActivity extends AppCompatActivity {
+  private Button sendButton;
+  private EditText hostEdit;
+  private EditText portEdit;
+  private EditText messageEdit;
+  private TextView resultText;
 
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        setContentView(R.layout.activity_helloworld);
-        mSendButton = (Button) findViewById(R.id.send_button);
-        mHostEdit = (EditText) findViewById(R.id.host_edit_text);
-        mPortEdit = (EditText) findViewById(R.id.port_edit_text);
-        mMessageEdit = (EditText) findViewById(R.id.message_edit_text);
-        mResultText = (TextView) findViewById(R.id.grpc_response_text);
-        mResultText.setMovementMethod(new ScrollingMovementMethod());
-    }
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.activity_helloworld);
+    sendButton = (Button) findViewById(R.id.send_button);
+    sendButton.setOnClickListener(
+            new View.OnClickListener() {
+              @Override
+              public void onClick(View v) {
+                sendMessage(v);
+              }
+            });
+    hostEdit = (EditText) findViewById(R.id.host_edit_text);
+    portEdit = (EditText) findViewById(R.id.port_edit_text);
+    messageEdit = (EditText) findViewById(R.id.message_edit_text);
+    resultText = (TextView) findViewById(R.id.grpc_response_text);
+    resultText.setMovementMethod(new ScrollingMovementMethod());
+  }
 
-    public void sendMessage(View view) {
-        ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE))
-                .hideSoftInputFromWindow(mHostEdit.getWindowToken(), 0);
-        mSendButton.setEnabled(false);
-        new GrpcTask().execute();
-    }
+  public void sendMessage(View view) {
+    ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE))
+        .hideSoftInputFromWindow(hostEdit.getWindowToken(), 0);
+    sendButton.setEnabled(false);
+    resultText.setText("");
+    new GrpcTask(this)
+        .execute(
+            hostEdit.getText().toString(),
+            messageEdit.getText().toString(),
+            portEdit.getText().toString());
+  }
 
-    private class GrpcTask extends AsyncTask<Void, Void, String> {
-        private String mHost;
-        private String mMessage;
-        private int mPort;
-        private ManagedChannel mChannel;
+  private static class GrpcTask extends AsyncTask<String, Void, String> {
+    private final WeakReference<Activity> activityReference;
+    private ManagedChannel channel;
 
-        @Override
-        protected void onPreExecute() {
-            mHost = mHostEdit.getText().toString();
-            mMessage = mMessageEdit.getText().toString();
-            String portStr = mPortEdit.getText().toString();
-            mPort = TextUtils.isEmpty(portStr) ? 0 : Integer.valueOf(portStr);
-            mResultText.setText("");
-        }
+    private GrpcTask(Activity activity) {
+      this.activityReference = new WeakReference<Activity>(activity);
+    }
 
-        @Override
-        protected String doInBackground(Void... nothing) {
-            try {
-                mChannel = ManagedChannelBuilder.forAddress(mHost, mPort)
-                    .usePlaintext(true)
-                    .build();
-                GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(mChannel);
-                HelloRequest message = HelloRequest.newBuilder().setName(mMessage).build();
-                HelloReply reply = stub.sayHello(message);
-                return reply.getMessage();
-            } catch (Exception e) {
-                StringWriter sw = new StringWriter();
-                PrintWriter pw = new PrintWriter(sw);
-                e.printStackTrace(pw);
-                pw.flush();
-                return String.format("Failed... : %n%s", sw);
-            }
-        }
+    @Override
+    protected String doInBackground(String... params) {
+      String host = params[0];
+      String message = params[1];
+      String portStr = params[2];
+      int port = TextUtils.isEmpty(portStr) ? 0 : Integer.valueOf(portStr);
+      try {
+        channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext().build();
+        GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(channel);
+        HelloRequest request = HelloRequest.newBuilder().setName(message).build();
+        HelloReply reply = stub.sayHello(request);
+        return reply.getMessage();
+      } catch (Exception e) {
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw);
+        e.printStackTrace(pw);
+        pw.flush();
+        return String.format("Failed... : %n%s", sw);
+      }
+    }
 
-        @Override
-        protected void onPostExecute(String result) {
-            try {
-                mChannel.shutdown().awaitTermination(1, TimeUnit.SECONDS);
-            } catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
-            }
-            mResultText.setText(result);
-            mSendButton.setEnabled(true);
-        }
+    @Override
+    protected void onPostExecute(String result) {
+      try {
+        channel.shutdown().awaitTermination(1, TimeUnit.SECONDS);
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+      }
+      Activity activity = activityReference.get();
+      if (activity == null) {
+        return;
+      }
+      TextView resultText = (TextView) activity.findViewById(R.id.grpc_response_text);
+      Button sendButton = (Button) activity.findViewById(R.id.send_button);
+      resultText.setText(result);
+      sendButton.setEnabled(true);
     }
+  }
 }
diff --git a/examples/android/helloworld/app/src/main/proto/helloworld.proto b/examples/android/helloworld/app/src/main/proto/helloworld.proto
index 0bee1fcfcfb..c60d9416f1f 100644
--- a/examples/android/helloworld/app/src/main/proto/helloworld.proto
+++ b/examples/android/helloworld/app/src/main/proto/helloworld.proto
@@ -1,32 +1,16 @@
-// Copyright 2015, Google Inc.
-// All rights reserved.
+// Copyright 2015 The gRPC Authors
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
+//     http://www.apache.org/licenses/LICENSE-2.0
 //
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
+// 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.
 syntax = "proto3";
 
 option java_multiple_files = true;
diff --git a/examples/android/helloworld/app/src/main/res/layout/activity_helloworld.xml b/examples/android/helloworld/app/src/main/res/layout/activity_helloworld.xml
index 18b05c3bd6e..5831f1d1f54 100644
--- a/examples/android/helloworld/app/src/main/res/layout/activity_helloworld.xml
+++ b/examples/android/helloworld/app/src/main/res/layout/activity_helloworld.xml
@@ -13,6 +13,7 @@
                 android:layout_weight="2"
                 android:layout_width="0dp"
                 android:layout_height="wrap_content"
+                android:inputType="text"
                 android:hint="Enter Host" />
         <EditText
                 android:id="@+id/port_edit_text"
@@ -28,13 +29,13 @@
             android:id="@+id/message_edit_text"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
+            android:inputType="text"
             android:hint="Enter message to send" />
 
     <Button
             android:id="@+id/send_button"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
-            android:onClick="sendMessage"
             android:text="Send Grpc Request" />
 
     <TextView
diff --git a/examples/android/helloworld/build.gradle b/examples/android/helloworld/build.gradle
index d5cf08626b6..6db6a9bced1 100644
--- a/examples/android/helloworld/build.gradle
+++ b/examples/android/helloworld/build.gradle
@@ -2,11 +2,12 @@
 
 buildscript {
     repositories {
-        jcenter()
+        google()
+        mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:2.2.0'
-        classpath "com.google.protobuf:protobuf-gradle-plugin:0.8.0"
+        classpath 'com.android.tools.build:gradle:7.4.0'
+        classpath "com.google.protobuf:protobuf-gradle-plugin:0.9.5"
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
@@ -15,7 +16,8 @@ buildscript {
 
 allprojects {
     repositories {
-        jcenter()
+        google()
+        mavenCentral()
         mavenLocal()
     }
 }
diff --git a/examples/android/helloworld/gradle/wrapper/gradle-wrapper.jar b/examples/android/helloworld/gradle/wrapper/gradle-wrapper.jar
deleted file mode 100644
index d6e2637affb..00000000000
Binary files a/examples/android/helloworld/gradle/wrapper/gradle-wrapper.jar and /dev/null differ
diff --git a/examples/android/helloworld/gradle/wrapper/gradle-wrapper.properties b/examples/android/helloworld/gradle/wrapper/gradle-wrapper.properties
deleted file mode 100644
index 30073c3a447..00000000000
--- a/examples/android/helloworld/gradle/wrapper/gradle-wrapper.properties
+++ /dev/null
@@ -1,6 +0,0 @@
-#Wed Nov 16 15:29:01 PST 2016
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-3.2-bin.zip
diff --git a/examples/android/helloworld/gradlew b/examples/android/helloworld/gradlew
deleted file mode 100755
index 4ef3a871f2e..00000000000
--- a/examples/android/helloworld/gradlew
+++ /dev/null
@@ -1,171 +0,0 @@
-#!/usr/bin/env sh
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Escape application args
-for s in "${@}" ; do
-    s=\"$s\"
-    APP_ARGS=$APP_ARGS" "$s
-done
-
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- "$DEFAULT_JVM_OPTS" "$JAVA_OPTS" "$GRADLE_OPTS" "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
-
-exec "$JAVACMD" "$@"
diff --git a/examples/android/helloworld/gradlew.bat b/examples/android/helloworld/gradlew.bat
deleted file mode 100644
index e95643d6a2c..00000000000
--- a/examples/android/helloworld/gradlew.bat
+++ /dev/null
@@ -1,84 +0,0 @@
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
diff --git a/examples/android/helloworld/settings.gradle b/examples/android/helloworld/settings.gradle
index e7b4def49cb..6208d70e838 100644
--- a/examples/android/helloworld/settings.gradle
+++ b/examples/android/helloworld/settings.gradle
@@ -1 +1,17 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+}
+
 include ':app'
diff --git a/examples/android/routeguide/app/build.gradle b/examples/android/routeguide/app/build.gradle
index a2a48c7058a..c6fb344e82e 100644
--- a/examples/android/routeguide/app/build.gradle
+++ b/examples/android/routeguide/app/build.gradle
@@ -2,61 +2,57 @@ apply plugin: 'com.android.application'
 apply plugin: 'com.google.protobuf'
 
 android {
-    compileSdkVersion 23
-    buildToolsVersion "24.0.0"
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    compileSdkVersion 34
 
     defaultConfig {
-    applicationId "io.grpc.routeguideexample"
-        minSdkVersion 23
-        targetSdkVersion 23
+        applicationId "io.grpc.routeguideexample"
+        minSdkVersion 21
+        targetSdkVersion 33
         versionCode 1
         versionName "1.0"
     }
     buildTypes {
+        debug { minifyEnabled false }
         release {
-            minifyEnabled false
+            minifyEnabled true
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
     lintOptions {
-        disable 'InvalidPackage'
+        disable 'GoogleAppIndexingWarning', 'HardcodedText', 'InvalidPackage'
+        textReport true
+        textOutput "stdout"
     }
 }
 
 protobuf {
-    protoc {
-        artifact = 'com.google.protobuf:protoc:3.2.0'
-    }
+    protoc { artifact = 'com.google.protobuf:protoc:3.25.1' }
     plugins {
-        javalite {
-            artifact = "com.google.protobuf:protoc-gen-javalite:3.0.0"
-        }
-        grpc {
-            artifact = 'io.grpc:protoc-gen-grpc-java:1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
         }
     }
     generateProtoTasks {
         all().each { task ->
+            task.builtins {
+                java { option 'lite' }
+            }
             task.plugins {
-                javalite {}
-                grpc {
-                    // Options added to --grpc_out
-                    option 'lite'
-                }
+                grpc { // Options added to --grpc_out
+                    option 'lite' }
             }
         }
     }
 }
 
 dependencies {
-    compile 'com.android.support:appcompat-v7:23.+'
-    compile 'com.google.code.findbugs:jsr305:3.0.0'
-    compile 'com.google.guava:guava:20.0'
-    compile 'com.squareup.okhttp:okhttp:2.2.0'
+    implementation 'androidx.appcompat:appcompat:1.0.0'
 
     // You need to build grpc-java to obtain these libraries below.
-    compile 'io.grpc:grpc-okhttp:1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    compile 'io.grpc:grpc-protobuf-lite:1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    compile 'io.grpc:grpc-stub:1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-    compile 'javax.annotation:javax.annotation-api:1.2'
+    implementation 'io.grpc:grpc-okhttp:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-protobuf-lite:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-stub:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
 }
diff --git a/examples/android/routeguide/app/proguard-rules.pro b/examples/android/routeguide/app/proguard-rules.pro
index 6471f5f3648..8f066eb506d 100644
--- a/examples/android/routeguide/app/proguard-rules.pro
+++ b/examples/android/routeguide/app/proguard-rules.pro
@@ -11,8 +11,7 @@
 
 -dontwarn sun.misc.Unsafe
 -dontwarn com.google.common.**
+-dontwarn javax.naming.**
 -dontwarn okio.**
 # Ignores: can't find referenced class javax.lang.model.element.Modifier
 -dontwarn com.google.errorprone.annotations.**
--keep class io.grpc.internal.DnsNameResolverProvider
--keep class io.grpc.okhttp.OkHttpChannelProvider
diff --git a/examples/android/routeguide/app/src/main/AndroidManifest.xml b/examples/android/routeguide/app/src/main/AndroidManifest.xml
index d557afc0856..2031166ea2b 100644
--- a/examples/android/routeguide/app/src/main/AndroidManifest.xml
+++ b/examples/android/routeguide/app/src/main/AndroidManifest.xml
@@ -3,14 +3,15 @@
 
     <uses-permission android:name="android.permission.INTERNET" />
 
-    <application android:allowBackup="true"
+    <application android:allowBackup="false"
         android:label="@string/app_name"
         android:icon="@mipmap/ic_launcher"
         android:supportsRtl="true"
         android:theme="@style/AppTheme">
         <activity
             android:name=".RouteGuideActivity"
-            android:label="@string/app_name" >
+            android:label="@string/app_name"
+            android:exported="true" >
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
diff --git a/examples/android/routeguide/app/src/main/java/io/grpc/routeguideexample/RouteGuideActivity.java b/examples/android/routeguide/app/src/main/java/io/grpc/routeguideexample/RouteGuideActivity.java
index 432e338ff06..7f50158a23f 100644
--- a/examples/android/routeguide/app/src/main/java/io/grpc/routeguideexample/RouteGuideActivity.java
+++ b/examples/android/routeguide/app/src/main/java/io/grpc/routeguideexample/RouteGuideActivity.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.routeguideexample;
@@ -34,7 +19,7 @@
 import android.content.Context;
 import android.os.AsyncTask;
 import android.os.Bundle;
-import android.support.v7.app.AppCompatActivity;
+import androidx.appcompat.app.AppCompatActivity;
 import android.text.TextUtils;
 import android.text.method.ScrollingMovementMethod;
 import android.view.View;
@@ -42,18 +27,15 @@
 import android.widget.Button;
 import android.widget.EditText;
 import android.widget.TextView;
-
 import io.grpc.ManagedChannel;
 import io.grpc.ManagedChannelBuilder;
-import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
 import io.grpc.routeguideexample.RouteGuideGrpc.RouteGuideBlockingStub;
 import io.grpc.routeguideexample.RouteGuideGrpc.RouteGuideStub;
 import io.grpc.stub.StreamObserver;
-
-import java.io.IOException;
 import java.io.PrintWriter;
 import java.io.StringWriter;
+import java.lang.ref.WeakReference;
 import java.text.MessageFormat;
 import java.util.ArrayList;
 import java.util.Iterator;
@@ -61,372 +43,407 @@
 import java.util.Random;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 
 public class RouteGuideActivity extends AppCompatActivity {
-    private static final Logger logger = Logger.getLogger(RouteGuideActivity.class.getName());
-    private EditText mHostEdit;
-    private EditText mPortEdit;
-    private Button mStartRouteGuideButton;
-    private Button mExitRouteGuideButton;    
-    private Button mGetFeatureButton;
-    private Button mListFeaturesButton;
-    private Button mRecordRouteButton;
-    private Button mRouteChatButton;
-    private TextView mResultText;
-
-    private ManagedChannel mChannel;
-        
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        setContentView(R.layout.activity_routeguide);
-        mHostEdit = (EditText) findViewById(R.id.host_edit_text);
-        mPortEdit = (EditText) findViewById(R.id.port_edit_text);
-        mStartRouteGuideButton = (Button) findViewById(R.id.start_route_guide_button);
-        mExitRouteGuideButton = (Button) findViewById(R.id.exit_route_guide_button);
-        mGetFeatureButton = (Button) findViewById(R.id.get_feature_button);
-        mListFeaturesButton = (Button) findViewById(R.id.list_features_button);
-        mRecordRouteButton = (Button) findViewById(R.id.record_route_button);
-        mRouteChatButton = (Button) findViewById(R.id.route_chat_button);
-        mResultText = (TextView) findViewById(R.id.result_text);
-        mResultText.setMovementMethod(new ScrollingMovementMethod());
-        disableButtons();
-    }
-    
-    public void startRouteGuide(View view) {
-        String host = mHostEdit.getText().toString();
-        String portStr = mPortEdit.getText().toString();
-        int port = TextUtils.isEmpty(portStr) ? 0 : Integer.valueOf(portStr);
-        ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE))
-                .hideSoftInputFromWindow(mHostEdit.getWindowToken(), 0);
-        mChannel = ManagedChannelBuilder.forAddress(host, port).usePlaintext(true).build();
-        mHostEdit.setEnabled(false);
-        mPortEdit.setEnabled(false);
-        mStartRouteGuideButton.setEnabled(false);
-        enableButtons();
-    }
-    
-    public void exitRouteGuide(View view) {
-        mChannel.shutdown();
-        disableButtons();
-        mHostEdit.setEnabled(true);
-        mPortEdit.setEnabled(true);
-        mStartRouteGuideButton.setEnabled(true);
+  private EditText hostEdit;
+  private EditText portEdit;
+  private Button startRouteGuideButton;
+  private Button exitRouteGuideButton;
+  private Button getFeatureButton;
+  private Button listFeaturesButton;
+  private Button recordRouteButton;
+  private Button routeChatButton;
+  private TextView resultText;
+  private ManagedChannel channel;
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.activity_routeguide);
+    hostEdit = (EditText) findViewById(R.id.host_edit_text);
+    portEdit = (EditText) findViewById(R.id.port_edit_text);
+    startRouteGuideButton = (Button) findViewById(R.id.start_route_guide_button);
+    exitRouteGuideButton = (Button) findViewById(R.id.exit_route_guide_button);
+    getFeatureButton = (Button) findViewById(R.id.get_feature_button);
+    listFeaturesButton = (Button) findViewById(R.id.list_features_button);
+    recordRouteButton = (Button) findViewById(R.id.record_route_button);
+    routeChatButton = (Button) findViewById(R.id.route_chat_button);
+    resultText = (TextView) findViewById(R.id.result_text);
+    resultText.setMovementMethod(new ScrollingMovementMethod());
+    disableButtons();
+  }
+
+  public void startRouteGuide(View view) {
+    String host = hostEdit.getText().toString();
+    String portStr = portEdit.getText().toString();
+    int port = TextUtils.isEmpty(portStr) ? 0 : Integer.valueOf(portStr);
+    ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE))
+        .hideSoftInputFromWindow(hostEdit.getWindowToken(), 0);
+    channel = ManagedChannelBuilder.forAddress(host, port).usePlaintext().build();
+    hostEdit.setEnabled(false);
+    portEdit.setEnabled(false);
+    startRouteGuideButton.setEnabled(false);
+    enableButtons();
+  }
+
+  public void exitRouteGuide(View view) {
+    channel.shutdown();
+    disableButtons();
+    hostEdit.setEnabled(true);
+    portEdit.setEnabled(true);
+    startRouteGuideButton.setEnabled(true);
+  }
+
+  public void getFeature(View view) {
+    setResultText("");
+    disableButtons();
+    new GrpcTask(new GetFeatureRunnable(), channel, this).execute();
+  }
+
+  public void listFeatures(View view) {
+    setResultText("");
+    disableButtons();
+    new GrpcTask(new ListFeaturesRunnable(), channel, this).execute();
+  }
+
+  public void recordRoute(View view) {
+    setResultText("");
+    disableButtons();
+    new GrpcTask(new RecordRouteRunnable(), channel, this).execute();
+  }
+
+  public void routeChat(View view) {
+    setResultText("");
+    disableButtons();
+    new GrpcTask(new RouteChatRunnable(), channel, this).execute();
+  }
+
+  private void setResultText(String text) {
+    resultText.setText(text);
+  }
+
+  private void disableButtons() {
+    getFeatureButton.setEnabled(false);
+    listFeaturesButton.setEnabled(false);
+    recordRouteButton.setEnabled(false);
+    routeChatButton.setEnabled(false);
+    exitRouteGuideButton.setEnabled(false);
+  }
+
+  private void enableButtons() {
+    exitRouteGuideButton.setEnabled(true);
+    getFeatureButton.setEnabled(true);
+    listFeaturesButton.setEnabled(true);
+    recordRouteButton.setEnabled(true);
+    routeChatButton.setEnabled(true);
+  }
+
+  private static class GrpcTask extends AsyncTask<Void, Void, String> {
+    private final GrpcRunnable grpcRunnable;
+    private final ManagedChannel channel;
+    private final WeakReference<RouteGuideActivity> activityReference;
+
+    GrpcTask(GrpcRunnable grpcRunnable, ManagedChannel channel, RouteGuideActivity activity) {
+      this.grpcRunnable = grpcRunnable;
+      this.channel = channel;
+      this.activityReference = new WeakReference<RouteGuideActivity>(activity);
     }
 
-    public void getFeature(View view) {
-        new GrpcTask(new GetFeatureRunnable()).execute();
+    @Override
+    protected String doInBackground(Void... nothing) {
+      try {
+        String logs =
+            grpcRunnable.run(
+                RouteGuideGrpc.newBlockingStub(channel), RouteGuideGrpc.newStub(channel));
+        return "Success!\n" + logs;
+      } catch (Exception e) {
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw);
+        e.printStackTrace(pw);
+        pw.flush();
+        return "Failed... :\n" + sw;
+      }
     }
 
-    public void listFeatures(View view) {
-        new GrpcTask(new ListFeaturesRunnable()).execute();
+    @Override
+    protected void onPostExecute(String result) {
+      RouteGuideActivity activity = activityReference.get();
+      if (activity == null) {
+        return;
+      }
+      activity.setResultText(result);
+      activity.enableButtons();
     }
+  }
+
+  private interface GrpcRunnable {
+    /** Perform a grpcRunnable and return all the logs. */
+    String run(RouteGuideBlockingStub blockingStub, RouteGuideStub asyncStub) throws Exception;
+  }
 
-    public void recordRoute(View view) {
-        new GrpcTask(new RecordRouteRunnable()).execute();
+  private static class GetFeatureRunnable implements GrpcRunnable {
+    @Override
+    public String run(RouteGuideBlockingStub blockingStub, RouteGuideStub asyncStub)
+        throws Exception {
+      return getFeature(409146138, -746188906, blockingStub);
     }
 
-    public void routeChat(View view) {
-        new GrpcTask(new RouteChatRunnable()).execute();
+    /** Blocking unary call example. Calls getFeature and prints the response. */
+    private String getFeature(int lat, int lon, RouteGuideBlockingStub blockingStub)
+        throws StatusRuntimeException {
+      StringBuffer logs = new StringBuffer();
+      appendLogs(logs, "*** GetFeature: lat={0} lon={1}", lat, lon);
+
+      Point request = Point.newBuilder().setLatitude(lat).setLongitude(lon).build();
+
+      Feature feature;
+      feature = blockingStub.getFeature(request);
+      if (RouteGuideUtil.exists(feature)) {
+        appendLogs(
+            logs,
+            "Found feature called \"{0}\" at {1}, {2}",
+            feature.getName(),
+            RouteGuideUtil.getLatitude(feature.getLocation()),
+            RouteGuideUtil.getLongitude(feature.getLocation()));
+      } else {
+        appendLogs(
+            logs,
+            "Found no feature at {0}, {1}",
+            RouteGuideUtil.getLatitude(feature.getLocation()),
+            RouteGuideUtil.getLongitude(feature.getLocation()));
+      }
+      return logs.toString();
     }
-    
-    private void disableButtons() {
-        mGetFeatureButton.setEnabled(false);
-        mListFeaturesButton.setEnabled(false);
-        mRecordRouteButton.setEnabled(false);
-        mRouteChatButton.setEnabled(false);
-        mExitRouteGuideButton.setEnabled(false);
+  }
+
+  private static class ListFeaturesRunnable implements GrpcRunnable {
+    @Override
+    public String run(RouteGuideBlockingStub blockingStub, RouteGuideStub asyncStub)
+        throws Exception {
+      return listFeatures(400000000, -750000000, 420000000, -730000000, blockingStub);
     }
-    
-    private void enableButtons() {
-        mExitRouteGuideButton.setEnabled(true);
-        mGetFeatureButton.setEnabled(true);
-        mListFeaturesButton.setEnabled(true);
-        mRecordRouteButton.setEnabled(true);
-        mRouteChatButton.setEnabled(true);
+
+    /**
+     * Blocking server-streaming example. Calls listFeatures with a rectangle of interest. Prints
+     * each response feature as it arrives.
+     */
+    private String listFeatures(
+        int lowLat, int lowLon, int hiLat, int hiLon, RouteGuideBlockingStub blockingStub)
+        throws StatusRuntimeException {
+      StringBuffer logs = new StringBuffer("Result: ");
+      appendLogs(
+          logs,
+          "*** ListFeatures: lowLat={0} lowLon={1} hiLat={2} hiLon={3}",
+          lowLat,
+          lowLon,
+          hiLat,
+          hiLon);
+
+      Rectangle request =
+          Rectangle.newBuilder()
+              .setLo(Point.newBuilder().setLatitude(lowLat).setLongitude(lowLon).build())
+              .setHi(Point.newBuilder().setLatitude(hiLat).setLongitude(hiLon).build())
+              .build();
+      Iterator<Feature> features;
+      features = blockingStub.listFeatures(request);
+
+      while (features.hasNext()) {
+        Feature feature = features.next();
+        appendLogs(logs, feature.toString());
+      }
+      return logs.toString();
     }
+  }
 
-    private class GrpcTask extends AsyncTask<Void, Void, String> {
-        private final GrpcRunnable mGrpc;
+  private static class RecordRouteRunnable implements GrpcRunnable {
+    private Throwable failed;
 
-        GrpcTask(GrpcRunnable grpc) {
-            this.mGrpc = grpc;
-        }
+    @Override
+    public String run(RouteGuideBlockingStub blockingStub, RouteGuideStub asyncStub)
+        throws Exception {
+      List<Point> points = new ArrayList<>();
+      points.add(Point.newBuilder().setLatitude(407838351).setLongitude(-746143763).build());
+      points.add(Point.newBuilder().setLatitude(408122808).setLongitude(-743999179).build());
+      points.add(Point.newBuilder().setLatitude(413628156).setLongitude(-749015468).build());
+      return recordRoute(points, 5, asyncStub);
+    }
 
-        @Override
-        protected void onPreExecute() {
-            mResultText.setText("");
-            disableButtons();
-        }
+    /**
+     * Async client-streaming example. Sends {@code numPoints} randomly chosen points from {@code
+     * features} with a variable delay in between. Prints the statistics when they are sent from the
+     * server.
+     */
+    private String recordRoute(List<Point> points, int numPoints, RouteGuideStub asyncStub)
+        throws InterruptedException, RuntimeException {
+      final StringBuffer logs = new StringBuffer();
+      appendLogs(logs, "*** RecordRoute");
+
+      final CountDownLatch finishLatch = new CountDownLatch(1);
+      StreamObserver<RouteSummary> responseObserver =
+          new StreamObserver<RouteSummary>() {
+            @Override
+            public void onNext(RouteSummary summary) {
+              appendLogs(
+                  logs,
+                  "Finished trip with {0} points. Passed {1} features. "
+                      + "Travelled {2} meters. It took {3} seconds.",
+                  summary.getPointCount(),
+                  summary.getFeatureCount(),
+                  summary.getDistance(),
+                  summary.getElapsedTime());
+            }
 
-        @Override
-        protected String doInBackground(Void... nothing) {
-            try {
-                String logs = mGrpc.run(RouteGuideGrpc.newBlockingStub(mChannel),
-                        RouteGuideGrpc.newStub(mChannel));
-                return "Success!" + System.lineSeparator() + logs;
-            } catch (Exception e) {
-                StringWriter sw = new StringWriter();
-                PrintWriter pw = new PrintWriter(sw);
-                e.printStackTrace(pw);
-                pw.flush();
-                return "Failed... : " + System.lineSeparator() + sw;
+            @Override
+            public void onError(Throwable t) {
+              failed = t;
+              finishLatch.countDown();
             }
-        }
 
-        @Override
-        protected void onPostExecute(String result) {
-            mResultText.setText(result);
-            enableButtons();
+            @Override
+            public void onCompleted() {
+              appendLogs(logs, "Finished RecordRoute");
+              finishLatch.countDown();
+            }
+          };
+
+      StreamObserver<Point> requestObserver = asyncStub.recordRoute(responseObserver);
+      try {
+        // Send numPoints points randomly selected from the points list.
+        Random rand = new Random();
+        for (int i = 0; i < numPoints; ++i) {
+          int index = rand.nextInt(points.size());
+          Point point = points.get(index);
+          appendLogs(
+              logs,
+              "Visiting point {0}, {1}",
+              RouteGuideUtil.getLatitude(point),
+              RouteGuideUtil.getLongitude(point));
+          requestObserver.onNext(point);
+          // Sleep for a bit before sending the next one.
+          Thread.sleep(rand.nextInt(1000) + 500);
+          if (finishLatch.getCount() == 0) {
+            // RPC completed or errored before we finished sending.
+            // Sending further requests won't error, but they will just be thrown away.
+            break;
+          }
         }
+      } catch (RuntimeException e) {
+        // Cancel RPC
+        requestObserver.onError(e);
+        throw e;
+      }
+      // Mark the end of requests
+      requestObserver.onCompleted();
+
+      // Receiving happens asynchronously
+      if (!finishLatch.await(1, TimeUnit.MINUTES)) {
+        throw new RuntimeException(
+            "Could not finish rpc within 1 minute, the server is likely down");
+      }
+
+      if (failed != null) {
+        throw new RuntimeException(failed);
+      }
+      return logs.toString();
     }
+  }
 
-    private interface GrpcRunnable {
-        /**
-         * Perform a grpc and return all the logs.
-         */
-        String run(RouteGuideBlockingStub blockingStub, RouteGuideStub asyncStub) throws Exception;
-    }
-
-    private class GetFeatureRunnable implements GrpcRunnable {
-        @Override
-        public String run(RouteGuideBlockingStub blockingStub, RouteGuideStub asyncStub)
-                throws Exception {
-            return getFeature(409146138, -746188906, blockingStub);
-        }
-
-        /**
-         * Blocking unary call example.  Calls getFeature and prints the response.
-         */
-        private String getFeature(int lat, int lon, RouteGuideBlockingStub blockingStub)
-                throws StatusRuntimeException {
-            StringBuffer logs = new StringBuffer();
-            appendLogs(logs, "*** GetFeature: lat={0} lon={1}", lat, lon);
-
-            Point request = Point.newBuilder().setLatitude(lat).setLongitude(lon).build();
-
-            Feature feature;
-            feature = blockingStub.getFeature(request);
-            if (RouteGuideUtil.exists(feature)) {
-                appendLogs(logs, "Found feature called \"{0}\" at {1}, {2}",
-                        feature.getName(),
-                        RouteGuideUtil.getLatitude(feature.getLocation()),
-                        RouteGuideUtil.getLongitude(feature.getLocation()));
-            } else {
-                appendLogs(logs, "Found no feature at {0}, {1}",
-                        RouteGuideUtil.getLatitude(feature.getLocation()),
-                        RouteGuideUtil.getLongitude(feature.getLocation()));
-            }
-            return logs.toString();
-        }    
-    }
+  private static class RouteChatRunnable implements GrpcRunnable {
+    private Throwable failed;
 
-    private class ListFeaturesRunnable implements GrpcRunnable {
-        @Override
-        public String run(RouteGuideBlockingStub blockingStub, RouteGuideStub asyncStub)
-                throws Exception {
-            return listFeatures(400000000, -750000000, 420000000, -730000000, blockingStub);
-        }
-        
-        /**
-         * Blocking server-streaming example. Calls listFeatures with a rectangle of interest.
-         * Prints each response feature as it arrives.
-         */
-        private String listFeatures(int lowLat, int lowLon, int hiLat, int hiLon,
-                RouteGuideBlockingStub blockingStub) throws StatusRuntimeException {
-            StringBuffer logs = new StringBuffer("Result: ");
-            appendLogs(logs, "*** ListFeatures: lowLat={0} lowLon={1} hiLat={2} hiLon={3}",
-                    lowLat, lowLon, hiLat, hiLon);
-
-            Rectangle request = Rectangle.newBuilder()
-                    .setLo(Point.newBuilder().setLatitude(lowLat).setLongitude(lowLon).build())
-                    .setHi(Point.newBuilder().setLatitude(hiLat).setLongitude(hiLon).build())
-                    .build();
-            Iterator<Feature> features;
-            features = blockingStub.listFeatures(request);
-
-            while (features.hasNext()) {
-                Feature feature = features.next();
-                appendLogs(logs, feature.toString());
-            }
-            return logs.toString();
-        }
+    @Override
+    public String run(RouteGuideBlockingStub blockingStub, RouteGuideStub asyncStub)
+        throws Exception {
+      return routeChat(asyncStub);
     }
 
-    private class RecordRouteRunnable implements GrpcRunnable {
-        private Throwable failed;
-
-        @Override
-        public String run(RouteGuideBlockingStub blockingStub, RouteGuideStub asyncStub)
-              throws Exception {
-            List<Point> points = new ArrayList<Point>();
-            points.add(Point.newBuilder()
-                    .setLatitude(407838351).setLongitude(-746143763).build());
-            points.add(Point.newBuilder()
-                    .setLatitude(408122808).setLongitude(-743999179).build());
-            points.add(Point.newBuilder()
-                    .setLatitude(413628156).setLongitude(-749015468).build());
-            return recordRoute(points, 5, asyncStub);
-        }
-        
-        /**
-         * Async client-streaming example. Sends {@code numPoints} randomly chosen points from
-         * {@code features} with a variable delay in between. Prints the statistics when they are
-         * sent from the server.
-         */
-        private String recordRoute(List<Point> points, int numPoints, RouteGuideStub asyncStub)
-                throws InterruptedException, RuntimeException {
-            final StringBuffer logs = new StringBuffer();
-            appendLogs(logs, "*** RecordRoute");
-
-            final CountDownLatch finishLatch = new CountDownLatch(1);
-            StreamObserver<RouteSummary> responseObserver = new StreamObserver<RouteSummary>() {
+    /**
+     * Bi-directional example, which can only be asynchronous. Send some chat messages, and print
+     * any chat messages that are sent from the server.
+     */
+    private String routeChat(RouteGuideStub asyncStub)
+        throws InterruptedException, RuntimeException {
+      final StringBuffer logs = new StringBuffer();
+      appendLogs(logs, "*** RouteChat");
+      final CountDownLatch finishLatch = new CountDownLatch(1);
+      StreamObserver<RouteNote> requestObserver =
+          asyncStub.routeChat(
+              new StreamObserver<RouteNote>() {
                 @Override
-                public void onNext(RouteSummary summary) {
-                    appendLogs(logs, "Finished trip with {0} points. Passed {1} features. "
-                            + "Travelled {2} meters. It took {3} seconds.", summary.getPointCount(),
-                            summary.getFeatureCount(), summary.getDistance(),
-                            summary.getElapsedTime());
+                public void onNext(RouteNote note) {
+                  appendLogs(
+                      logs,
+                      "Got message \"{0}\" at {1}, {2}",
+                      note.getMessage(),
+                      note.getLocation().getLatitude(),
+                      note.getLocation().getLongitude());
                 }
 
                 @Override
                 public void onError(Throwable t) {
-                    failed = t;
-                    finishLatch.countDown();
+                  failed = t;
+                  finishLatch.countDown();
                 }
 
                 @Override
                 public void onCompleted() {
-                    appendLogs(logs, "Finished RecordRoute");
-                    finishLatch.countDown();
-                }
-            };
-
-            StreamObserver<Point> requestObserver = asyncStub.recordRoute(responseObserver);
-            try {
-                // Send numPoints points randomly selected from the points list.
-                Random rand = new Random();
-                for (int i = 0; i < numPoints; ++i) {
-                    int index = rand.nextInt(points.size());
-                    Point point = points.get(index);
-                    appendLogs(logs, "Visiting point {0}, {1}", RouteGuideUtil.getLatitude(point),
-                            RouteGuideUtil.getLongitude(point));
-                    requestObserver.onNext(point);
-                    // Sleep for a bit before sending the next one.
-                    Thread.sleep(rand.nextInt(1000) + 500);
-                    if (finishLatch.getCount() == 0) {
-                        // RPC completed or errored before we finished sending.
-                        // Sending further requests won't error, but they will just be thrown away.
-                        break;
-                    }
+                  appendLogs(logs, "Finished RouteChat");
+                  finishLatch.countDown();
                 }
-            } catch (RuntimeException e) {
-                // Cancel RPC
-                requestObserver.onError(e);
-                throw e;
-            }
-            // Mark the end of requests
-            requestObserver.onCompleted();
-
-            // Receiving happens asynchronously
-            if (!finishLatch.await(1, TimeUnit.MINUTES)) {
-                throw new RuntimeException(
-                       "Could not finish rpc within 1 minute, the server is likely down");
-            }
-            
-            if (failed != null) {
-                throw new RuntimeException(failed);
-            }
-            return logs.toString();
-        }
-    }
-
-    private class RouteChatRunnable implements GrpcRunnable {
-        private Throwable failed;
-
-        @Override
-        public String run(RouteGuideBlockingStub blockingStub, RouteGuideStub asyncStub)
-                throws Exception {
-            return routeChat(asyncStub);
-        }
-        
-        /**
-         * Bi-directional example, which can only be asynchronous. Send some chat messages, and
-         * print any chat messages that are sent from the server.
-         */
-        private String routeChat(RouteGuideStub asyncStub) throws InterruptedException,
-                RuntimeException {
-            final StringBuffer logs = new StringBuffer();
-            appendLogs(logs, "*** RouteChat");
-            final CountDownLatch finishLatch = new CountDownLatch(1);
-            StreamObserver<RouteNote> requestObserver =
-                    asyncStub.routeChat(new StreamObserver<RouteNote>() {
-                        @Override
-                        public void onNext(RouteNote note) {
-                            appendLogs(logs, "Got message \"{0}\" at {1}, {2}", note.getMessage(),
-                                    note.getLocation().getLatitude(),
-                                    note.getLocation().getLongitude());
-                        }
-
-                        @Override
-                        public void onError(Throwable t) {
-                            failed = t;
-                            finishLatch.countDown();
-                        }
-
-                        @Override
-                        public void onCompleted() {
-                            appendLogs(logs,"Finished RouteChat");
-                            finishLatch.countDown();
-                        }
-                    });
-
-            try {
-                RouteNote[] requests =
-                        {newNote("First message", 0, 0), newNote("Second message", 0, 1),
-                                newNote("Third message", 1, 0), newNote("Fourth message", 1, 1)};
-
-                for (RouteNote request : requests) {
-                    appendLogs(logs, "Sending message \"{0}\" at {1}, {2}", request.getMessage(),
-                            request.getLocation().getLatitude(),
-                            request.getLocation().getLongitude());
-                    requestObserver.onNext(request);
-                }
-            } catch (RuntimeException e) {
-                // Cancel RPC
-                requestObserver.onError(e);
-                throw e;
-            }
-            // Mark the end of requests
-            requestObserver.onCompleted();
-
-            // Receiving happens asynchronously
-            if (!finishLatch.await(1, TimeUnit.MINUTES)) {
-                throw new RuntimeException(
-                        "Could not finish rpc within 1 minute, the server is likely down");
-            }
-            
-            if (failed != null) {
-                throw new RuntimeException(failed);
-            }
-
-            return logs.toString();
-        }
-    }
-
-    private static void appendLogs(StringBuffer logs, String msg, Object... params) {
-        if (params.length > 0) {
-            logs.append(MessageFormat.format(msg, params));
-        } else {
-            logs.append(msg);
+              });
+
+      try {
+        RouteNote[] requests = {
+          newNote("First message", 0, 0),
+          newNote("Second message", 0, 1),
+          newNote("Third message", 1, 0),
+          newNote("Fourth message", 1, 1)
+        };
+
+        for (RouteNote request : requests) {
+          appendLogs(
+              logs,
+              "Sending message \"{0}\" at {1}, {2}",
+              request.getMessage(),
+              request.getLocation().getLatitude(),
+              request.getLocation().getLongitude());
+          requestObserver.onNext(request);
         }
-        logs.append(System.lineSeparator());
+      } catch (RuntimeException e) {
+        // Cancel RPC
+        requestObserver.onError(e);
+        throw e;
+      }
+      // Mark the end of requests
+      requestObserver.onCompleted();
+
+      // Receiving happens asynchronously
+      if (!finishLatch.await(1, TimeUnit.MINUTES)) {
+        throw new RuntimeException(
+            "Could not finish rpc within 1 minute, the server is likely down");
+      }
+
+      if (failed != null) {
+        throw new RuntimeException(failed);
+      }
+
+      return logs.toString();
     }
+  }
 
-    private static RouteNote newNote(String message, int lat, int lon) {
-        return RouteNote.newBuilder().setMessage(message)
-                .setLocation(Point.newBuilder().setLatitude(lat).setLongitude(lon).build()).build();
+  private static void appendLogs(StringBuffer logs, String msg, Object... params) {
+    if (params.length > 0) {
+      logs.append(MessageFormat.format(msg, params));
+    } else {
+      logs.append(msg);
     }
+    logs.append("\n");
+  }
+
+  private static RouteNote newNote(String message, int lat, int lon) {
+    return RouteNote.newBuilder()
+        .setMessage(message)
+        .setLocation(Point.newBuilder().setLatitude(lat).setLongitude(lon).build())
+        .build();
+  }
 }
diff --git a/examples/android/routeguide/app/src/main/java/io/grpc/routeguideexample/RouteGuideUtil.java b/examples/android/routeguide/app/src/main/java/io/grpc/routeguideexample/RouteGuideUtil.java
index 775f1beb9f0..56af278d9f7 100644
--- a/examples/android/routeguide/app/src/main/java/io/grpc/routeguideexample/RouteGuideUtil.java
+++ b/examples/android/routeguide/app/src/main/java/io/grpc/routeguideexample/RouteGuideUtil.java
@@ -1,66 +1,37 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.routeguideexample;
 
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
-import java.net.URL;
-import java.util.List;
 
-/**
- * Common utilities for the RouteGuide demo.
- */
+/** Common utilities for the RouteGuide demo. */
 public class RouteGuideUtil {
   private static final double COORD_FACTOR = 1e7;
 
-  /**
-   * Gets the latitude for the given point.
-   */
+  /** Gets the latitude for the given point. */
   public static double getLatitude(Point location) {
     return location.getLatitude() / COORD_FACTOR;
   }
 
-  /**
-   * Gets the longitude for the given point.
-   */
+  /** Gets the longitude for the given point. */
   public static double getLongitude(Point location) {
     return location.getLongitude() / COORD_FACTOR;
   }
 
-  /**
-   * Indicates whether the given feature exists (i.e. has a valid name).
-   */
+  /** Indicates whether the given feature exists (i.e. has a valid name). */
   public static boolean exists(Feature feature) {
     return feature != null && !feature.getName().isEmpty();
   }
diff --git a/examples/android/routeguide/app/src/main/proto/route_guide.proto b/examples/android/routeguide/app/src/main/proto/route_guide.proto
index f765fc5e160..3991c9622f7 100644
--- a/examples/android/routeguide/app/src/main/proto/route_guide.proto
+++ b/examples/android/routeguide/app/src/main/proto/route_guide.proto
@@ -1,32 +1,16 @@
-// Copyright 2015, Google Inc.
-// All rights reserved.
+// Copyright 2015 The gRPC Authors
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
+//     http://www.apache.org/licenses/LICENSE-2.0
 //
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
+// 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.
 syntax = "proto3";
 
 option java_multiple_files = true;
diff --git a/examples/android/routeguide/app/src/main/res/layout/activity_routeguide.xml b/examples/android/routeguide/app/src/main/res/layout/activity_routeguide.xml
index 4b73bf34ab1..b76a7a301ce 100644
--- a/examples/android/routeguide/app/src/main/res/layout/activity_routeguide.xml
+++ b/examples/android/routeguide/app/src/main/res/layout/activity_routeguide.xml
@@ -23,18 +23,18 @@
                 android:hint="Enter Port" />
     </LinearLayout>
 
-    <LinearLayout
+    <LinearLayout style="?android:buttonBarStyle"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:orientation="horizontal">
-        <Button
+        <Button style="?android:buttonBarButtonStyle"
             android:id="@+id/start_route_guide_button"
             android:layout_weight="1"
             android:layout_width="0dp"
             android:layout_height="wrap_content"
             android:onClick="startRouteGuide"
             android:text="Start Route Guide" />
-        <Button
+        <Button style="?android:buttonBarButtonStyle"
             android:id="@+id/exit_route_guide_button"
             android:layout_weight="1"
             android:layout_width="0dp"
diff --git a/examples/android/routeguide/build.gradle b/examples/android/routeguide/build.gradle
index a29e50ef8cb..8fc1d293228 100644
--- a/examples/android/routeguide/build.gradle
+++ b/examples/android/routeguide/build.gradle
@@ -2,11 +2,12 @@
 
 buildscript {
     repositories {
-        jcenter()
+        google()
+        mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:2.2.0'
-        classpath "com.google.protobuf:protobuf-gradle-plugin:0.8.0"
+        classpath 'com.android.tools.build:gradle:7.4.0'
+        classpath "com.google.protobuf:protobuf-gradle-plugin:0.9.5"
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
@@ -15,11 +16,10 @@ buildscript {
 
 allprojects {
     repositories {
-        jcenter()
+        google()
+        mavenCentral()
         mavenLocal()
     }
 }
 
-task clean(type: Delete) {
-    delete rootProject.buildDir
-}
+task clean(type: Delete) { delete rootProject.buildDir }
diff --git a/examples/android/routeguide/gradle/wrapper/gradle-wrapper.jar b/examples/android/routeguide/gradle/wrapper/gradle-wrapper.jar
deleted file mode 100644
index d6e2637affb..00000000000
Binary files a/examples/android/routeguide/gradle/wrapper/gradle-wrapper.jar and /dev/null differ
diff --git a/examples/android/routeguide/gradle/wrapper/gradle-wrapper.properties b/examples/android/routeguide/gradle/wrapper/gradle-wrapper.properties
deleted file mode 100644
index e15796cb397..00000000000
--- a/examples/android/routeguide/gradle/wrapper/gradle-wrapper.properties
+++ /dev/null
@@ -1,6 +0,0 @@
-#Wed Nov 16 15:29:19 PST 2016
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-3.2-bin.zip
diff --git a/examples/android/routeguide/gradlew b/examples/android/routeguide/gradlew
deleted file mode 100755
index 4ef3a871f2e..00000000000
--- a/examples/android/routeguide/gradlew
+++ /dev/null
@@ -1,171 +0,0 @@
-#!/usr/bin/env sh
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Escape application args
-for s in "${@}" ; do
-    s=\"$s\"
-    APP_ARGS=$APP_ARGS" "$s
-done
-
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- "$DEFAULT_JVM_OPTS" "$JAVA_OPTS" "$GRADLE_OPTS" "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
-
-exec "$JAVACMD" "$@"
diff --git a/examples/android/routeguide/gradlew.bat b/examples/android/routeguide/gradlew.bat
deleted file mode 100644
index e95643d6a2c..00000000000
--- a/examples/android/routeguide/gradlew.bat
+++ /dev/null
@@ -1,84 +0,0 @@
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
diff --git a/examples/android/routeguide/settings.gradle b/examples/android/routeguide/settings.gradle
index e7b4def49cb..6208d70e838 100644
--- a/examples/android/routeguide/settings.gradle
+++ b/examples/android/routeguide/settings.gradle
@@ -1 +1,17 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+}
+
 include ':app'
diff --git a/examples/android/strictmode/README.md b/examples/android/strictmode/README.md
new file mode 100644
index 00000000000..1ed2aa6a2ff
--- /dev/null
+++ b/examples/android/strictmode/README.md
@@ -0,0 +1,8 @@
+gRPC Android StrictMode Example
+========================
+
+- This example intends to show the compatibility of gRPC with Android StrictMode.
+- Android SDK version 28 is required for [`StrictMode.VmPolicy.Builder.penaltyListener`](https://developer.android.com/reference/android/os/StrictMode.VmPolicy.Builder.html#penaltyListener(java.util.concurrent.Executor,%20android.os.StrictMode.OnVmViolationListener)) used in the example.
+- This example does the same thing as [HelloWorld example](../helloworld) except popping up a dialog for detected StrictMode policy violation (shown below).
+
+![demo img](./demo.png)
diff --git a/examples/android/strictmode/app/build.gradle b/examples/android/strictmode/app/build.gradle
new file mode 100644
index 00000000000..fad9bfb58fb
--- /dev/null
+++ b/examples/android/strictmode/app/build.gradle
@@ -0,0 +1,59 @@
+apply plugin: 'com.android.application'
+apply plugin: 'com.google.protobuf'
+
+android {
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    compileSdkVersion 34
+
+    defaultConfig {
+        applicationId "io.grpc.strictmodehelloworldexample"
+        // API level 28 is required for StrictMode penaltyListener
+        minSdkVersion 28
+        targetSdkVersion 33
+        versionCode 1
+        versionName "1.0"
+    }
+    buildTypes {
+        debug { minifyEnabled false }
+        release {
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        disable 'GoogleAppIndexingWarning', 'HardcodedText', 'InvalidPackage'
+        textReport true
+        textOutput "stdout"
+    }
+}
+
+protobuf {
+    protoc { artifact = 'com.google.protobuf:protoc:3.25.1' }
+    plugins {
+        grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+        }
+    }
+    generateProtoTasks {
+        all().each { task ->
+            task.builtins {
+                java { option 'lite' }
+            }
+            task.plugins {
+                grpc { // Options added to --grpc_out
+                    option 'lite' }
+            }
+        }
+    }
+}
+
+dependencies {
+    implementation 'androidx.appcompat:appcompat:1.0.0'
+
+    // You need to build grpc-java to obtain these libraries below.
+    implementation 'io.grpc:grpc-okhttp:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-protobuf-lite:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+    implementation 'io.grpc:grpc-stub:1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+}
diff --git a/examples/android/strictmode/app/proguard-rules.pro b/examples/android/strictmode/app/proguard-rules.pro
new file mode 100644
index 00000000000..1507a526787
--- /dev/null
+++ b/examples/android/strictmode/app/proguard-rules.pro
@@ -0,0 +1,17 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in $ANDROID_HOME/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+-dontwarn com.google.common.**
+# Ignores: can't find referenced class javax.lang.model.element.Modifier
+-dontwarn com.google.errorprone.annotations.**
+-dontwarn javax.naming.**
+-dontwarn okio.**
+-dontwarn sun.misc.Unsafe
diff --git a/examples/android/strictmode/app/src/main/AndroidManifest.xml b/examples/android/strictmode/app/src/main/AndroidManifest.xml
new file mode 100644
index 00000000000..d2ff3b2d077
--- /dev/null
+++ b/examples/android/strictmode/app/src/main/AndroidManifest.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="io.grpc.strictmodehelloworldexample" >
+
+    <uses-permission android:name="android.permission.INTERNET" />
+
+    <application
+        android:allowBackup="false"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:theme="@style/Base.V7.Theme.AppCompat.Light" >
+        <activity
+            android:name=".StrictModeHelloworldActivity"
+            android:label="@string/app_name"
+            android:exported="true" >
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
diff --git a/examples/android/strictmode/app/src/main/java/io/grpc/strictmodehelloworldexample/StrictModeHelloworldActivity.java b/examples/android/strictmode/app/src/main/java/io/grpc/strictmodehelloworldexample/StrictModeHelloworldActivity.java
new file mode 100644
index 00000000000..c9e6675d221
--- /dev/null
+++ b/examples/android/strictmode/app/src/main/java/io/grpc/strictmodehelloworldexample/StrictModeHelloworldActivity.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright 2019 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.strictmodehelloworldexample;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.net.TrafficStats;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.os.StrictMode;
+import android.os.StrictMode.OnVmViolationListener;
+import android.os.StrictMode.VmPolicy;
+import android.os.strictmode.Violation;
+import androidx.appcompat.app.AppCompatActivity;
+import android.text.TextUtils;
+import android.text.method.ScrollingMovementMethod;
+import android.view.View;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.TextView;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import io.grpc.ManagedChannel;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.okhttp.OkHttpChannelBuilder;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.lang.ref.WeakReference;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+public class StrictModeHelloworldActivity extends AppCompatActivity {
+  private Button sendButton;
+  private EditText hostEdit;
+  private EditText portEdit;
+  private EditText messageEdit;
+  private TextView resultText;
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    VmPolicy policy =
+        new StrictMode.VmPolicy.Builder()
+            .detectCleartextNetwork()
+            .penaltyListener(
+                MoreExecutors.directExecutor(),
+                new OnVmViolationListener() {
+                  @Override
+                  public void onVmViolation(final Violation v) {
+                    runOnUiThread(
+                        new Runnable() {
+                          @Override
+                          public void run() {
+                            new AlertDialog.Builder(StrictModeHelloworldActivity.this)
+                                .setTitle("StrictMode VM Violation")
+                                .setMessage(v.getLocalizedMessage())
+                                .show();
+                          }
+                        });
+                  }
+                })
+            .penaltyLog()
+            .build();
+    StrictMode.setVmPolicy(policy);
+    setContentView(R.layout.activity_strictmodehelloworld);
+    sendButton = (Button) findViewById(R.id.send_button);
+    hostEdit = (EditText) findViewById(R.id.host_edit_text);
+    portEdit = (EditText) findViewById(R.id.port_edit_text);
+    messageEdit = (EditText) findViewById(R.id.message_edit_text);
+    resultText = (TextView) findViewById(R.id.grpc_response_text);
+    resultText.setMovementMethod(new ScrollingMovementMethod());
+  }
+
+  public void sendMessage(View view) {
+    ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE))
+        .hideSoftInputFromWindow(hostEdit.getWindowToken(), 0);
+    sendButton.setEnabled(false);
+    resultText.setText("");
+    new GrpcTask(this)
+        .execute(
+            hostEdit.getText().toString(),
+            messageEdit.getText().toString(),
+            portEdit.getText().toString());
+  }
+
+  private static class GrpcTask extends AsyncTask<String, Void, String> {
+    private final WeakReference<Activity> activityReference;
+    private ManagedChannel channel;
+
+    private GrpcTask(Activity activity) {
+      this.activityReference = new WeakReference<Activity>(activity);
+    }
+
+    @Override
+    protected String doInBackground(String... params) {
+      String host = params[0];
+      String message = params[1];
+      String portStr = params[2];
+      int port = TextUtils.isEmpty(portStr) ? 0 : Integer.valueOf(portStr);
+      try {
+        channel =
+            OkHttpChannelBuilder.forAddress(host, port)
+                .transportExecutor(new NetworkTaggingExecutor(0xFDD))
+                .usePlaintext()
+                .build();
+        GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(channel);
+        HelloRequest request = HelloRequest.newBuilder().setName(message).build();
+        HelloReply reply = stub.sayHello(request);
+        return reply.getMessage();
+      } catch (Exception e) {
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw);
+        e.printStackTrace(pw);
+        pw.flush();
+        return String.format("Failed... : %n%s", sw);
+      }
+    }
+
+    @Override
+    protected void onPostExecute(String result) {
+      try {
+        channel.shutdown().awaitTermination(1, TimeUnit.SECONDS);
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+      }
+      Activity activity = activityReference.get();
+      if (activity == null) {
+        return;
+      }
+      TextView resultText = (TextView) activity.findViewById(R.id.grpc_response_text);
+      Button sendButton = (Button) activity.findViewById(R.id.send_button);
+      resultText.setText(result);
+      sendButton.setEnabled(true);
+    }
+  }
+
+  private static class NetworkTaggingExecutor extends ThreadPoolExecutor {
+
+    private int trafficStatsTag;
+
+    NetworkTaggingExecutor(int tag) {
+      super(
+          0,
+          Integer.MAX_VALUE,
+          60L,
+          TimeUnit.SECONDS,
+          new SynchronousQueue<Runnable>(),
+          new ThreadFactoryBuilder().setDaemon(true).setNameFormat("grpc-android-%d").build());
+      trafficStatsTag = tag;
+    }
+
+    @Override
+    protected void beforeExecute(Thread t, Runnable r) {
+      TrafficStats.setThreadStatsTag(trafficStatsTag);
+      super.beforeExecute(t, r);
+    }
+
+    @Override
+    protected void afterExecute(Runnable r, Throwable t) {
+      TrafficStats.clearThreadStatsTag();
+      super.afterExecute(r, t);
+    }
+  }
+}
diff --git a/examples/android/strictmode/app/src/main/proto/helloworld.proto b/examples/android/strictmode/app/src/main/proto/helloworld.proto
new file mode 100644
index 00000000000..c60d9416f1f
--- /dev/null
+++ b/examples/android/strictmode/app/src/main/proto/helloworld.proto
@@ -0,0 +1,37 @@
+// Copyright 2015 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/android/strictmode/app/src/main/res/layout/activity_strictmodehelloworld.xml b/examples/android/strictmode/app/src/main/res/layout/activity_strictmodehelloworld.xml
new file mode 100644
index 00000000000..18b05c3bd6e
--- /dev/null
+++ b/examples/android/strictmode/app/src/main/res/layout/activity_strictmodehelloworld.xml
@@ -0,0 +1,55 @@
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+              xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
+              android:layout_height="match_parent"
+              tools:context=".MainActivity"
+              android:orientation="vertical" >
+
+    <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal">
+        <EditText
+                android:id="@+id/host_edit_text"
+                android:layout_weight="2"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:hint="Enter Host" />
+        <EditText
+                android:id="@+id/port_edit_text"
+                android:layout_weight="1"
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:inputType="numberDecimal"
+                android:hint="Enter Port" />
+    </LinearLayout>
+
+
+    <EditText
+            android:id="@+id/message_edit_text"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:hint="Enter message to send" />
+
+    <Button
+            android:id="@+id/send_button"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:onClick="sendMessage"
+            android:text="Send Grpc Request" />
+
+    <TextView
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:paddingTop="12dp"
+            android:paddingBottom="12dp"
+            android:textSize="16sp"
+            android:text="Response:" />
+
+    <TextView
+            android:id="@+id/grpc_response_text"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:scrollbars = "vertical"
+            android:textSize="16sp" />
+
+</LinearLayout>
diff --git a/examples/android/strictmode/app/src/main/res/mipmap-hdpi/ic_launcher.png b/examples/android/strictmode/app/src/main/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 00000000000..cde69bcccec
Binary files /dev/null and b/examples/android/strictmode/app/src/main/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/examples/android/strictmode/app/src/main/res/mipmap-mdpi/ic_launcher.png b/examples/android/strictmode/app/src/main/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 00000000000..c133a0cbd37
Binary files /dev/null and b/examples/android/strictmode/app/src/main/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/examples/android/strictmode/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/examples/android/strictmode/app/src/main/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 00000000000..bfa42f0e7b9
Binary files /dev/null and b/examples/android/strictmode/app/src/main/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/examples/android/strictmode/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/examples/android/strictmode/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 00000000000..324e72cdd74
Binary files /dev/null and b/examples/android/strictmode/app/src/main/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/examples/android/strictmode/app/src/main/res/values/strings.xml b/examples/android/strictmode/app/src/main/res/values/strings.xml
new file mode 100644
index 00000000000..53389a06236
--- /dev/null
+++ b/examples/android/strictmode/app/src/main/res/values/strings.xml
@@ -0,0 +1,3 @@
+<resources>
+    <string name="app_name">GrpcStrictModeHelloworldExample</string>
+</resources>
diff --git a/examples/android/strictmode/build.gradle b/examples/android/strictmode/build.gradle
new file mode 100644
index 00000000000..6db6a9bced1
--- /dev/null
+++ b/examples/android/strictmode/build.gradle
@@ -0,0 +1,23 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:7.4.0'
+        classpath "com.google.protobuf:protobuf-gradle-plugin:0.9.5"
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+        mavenLocal()
+    }
+}
diff --git a/examples/android/strictmode/demo.png b/examples/android/strictmode/demo.png
new file mode 100644
index 00000000000..dd409cfce58
Binary files /dev/null and b/examples/android/strictmode/demo.png differ
diff --git a/examples/android/strictmode/settings.gradle b/examples/android/strictmode/settings.gradle
new file mode 100644
index 00000000000..6208d70e838
--- /dev/null
+++ b/examples/android/strictmode/settings.gradle
@@ -0,0 +1,17 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+}
+
+include ':app'
diff --git a/examples/build.gradle b/examples/build.gradle
index f71403c7e86..cfaea82333a 100644
--- a/examples/build.gradle
+++ b/examples/build.gradle
@@ -1,20 +1,19 @@
-apply plugin: 'java'
-apply plugin: 'com.google.protobuf'
+plugins {
+    // Provide convenience executables for trying out the examples.
+    id 'application'
+    id 'com.google.protobuf' version '0.9.5'
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+}
 
-buildscript {
-  repositories {
+repositories {
     mavenCentral()
-  }
-  dependencies {
-    // ASSUMES GRADLE 2.12 OR HIGHER. Use plugin version 0.7.5 with earlier
-    // gradle versions
-    classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.0'
-  }
+    mavenLocal()
 }
 
-repositories {
-  mavenCentral()
-  mavenLocal()
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
 }
 
 // IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
@@ -22,94 +21,101 @@ repositories {
 
 // Feel free to delete the comment at the next line. It is just for safely
 // updating the version in our release process.
-def grpcVersion = '1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protobufVersion = '3.25.8'
+def protocVersion = protobufVersion
 
 dependencies {
-  compile "io.grpc:grpc-netty:${grpcVersion}"
-  compile "io.grpc:grpc-protobuf:${grpcVersion}"
-  compile "io.grpc:grpc-stub:${grpcVersion}"
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-services:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+
+    // examples/advanced need this for JsonFormat
+    implementation "com.google.protobuf:protobuf-java-util:${protobufVersion}"
+
+    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
 
-  testCompile "junit:junit:4.11"
-  testCompile "org.mockito:mockito-core:1.9.5"
+    testImplementation "io.grpc:grpc-testing:${grpcVersion}"
+    testImplementation "io.grpc:grpc-inprocess:${grpcVersion}"
+    testImplementation "junit:junit:4.13.2"
+    testImplementation "org.mockito:mockito-core:4.4.0"
 }
 
 protobuf {
-  protoc {
-    artifact = 'com.google.protobuf:protoc:3.2.0'
-  }
-  plugins {
-    grpc {
-      artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}"
+    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
+    plugins {
+        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
     }
-  }
-  generateProtoTasks {
-    all()*.plugins {
-      grpc {
-        // To generate deprecated interfaces and static bindService method,
-        // turn the enable_deprecated option to true below:
-        option 'enable_deprecated=false'
-      }
+    generateProtoTasks {
+        all()*.plugins { grpc {} }
     }
-  }
 }
 
-// Inform IntelliJ projects about the generated code.
-apply plugin: 'idea'
-
-idea {
-  module {
-    // Not using generatedSourceDirs because of
-    // https://discuss.gradle.org/t/support-for-intellij-2016/15294/8
-    sourceDirs += file("${projectDir}/build/generated/source/proto/main/java");
-    sourceDirs += file("${projectDir}/build/generated/source/proto/main/grpc");
-  }
-}
-
-// Provide convenience executables for trying out the examples.
-apply plugin: 'application'
+// gRPC uses java.util.ServiceLoader, which reads class names from
+// META-INF/services in jars. If you package your application as a "fat" jar
+// that includes dependencies, you need to make sure the packaging tool
+// concatenates duplicate files in META-INF/services.
+//
+// For the Shadow Gradle Plugin, use call mergeServiceFiles() within the
+// shadowJar task.
+// https://gradleup.com/shadow/configuration/merging/#merging-service-descriptor-files
 
 startScripts.enabled = false
 
-task routeGuideServer(type: CreateStartScripts) {
-  mainClassName = 'io.grpc.examples.routeguide.RouteGuideServer'
-  applicationName = 'route-guide-server'
-  outputDir = new File(project.buildDir, 'tmp')
-  classpath = jar.outputs.files + project.configurations.runtime
-}
-
-task routeGuideClient(type: CreateStartScripts) {
-  mainClassName = 'io.grpc.examples.routeguide.RouteGuideClient'
-  applicationName = 'route-guide-client'
-  outputDir = new File(project.buildDir, 'tmp')
-  classpath = jar.outputs.files + project.configurations.runtime
-}
-
-task helloWorldServer(type: CreateStartScripts) {
-  mainClassName = 'io.grpc.examples.helloworld.HelloWorldServer'
-  applicationName = 'hello-world-server'
-  outputDir = new File(project.buildDir, 'tmp')
-  classpath = jar.outputs.files + project.configurations.runtime
-}
-
-task helloWorldClient(type: CreateStartScripts) {
-  mainClassName = 'io.grpc.examples.helloworld.HelloWorldClient'
-  applicationName = 'hello-world-client'
-  outputDir = new File(project.buildDir, 'tmp')
-  classpath = jar.outputs.files + project.configurations.runtime
-}
-
-task compressingHelloWorldClient(type: CreateStartScripts) {
-  mainClassName = 'io.grpc.examples.experimental.CompressingHelloWorldClient'
-  applicationName = 'compressing-hello-world-client'
-  outputDir = new File(project.buildDir, 'tmp')
-  classpath = jar.outputs.files + project.configurations.runtime
+// Creates start scripts for a class name and adds it to the distribution. The
+// base class name is used to name the task and scripts. For example, passed
+// the class io.grpc.examples.helloworld.HelloWorldClient, it creates the task
+// helloWorldClient with script name hello-world-client.
+def createStartScripts(String mainClassName) {
+    String bareName = mainClassName.substring(mainClassName.lastIndexOf('.') + 1);
+    String taskName = bareName.uncapitalize();
+    def newTask = tasks.register(taskName, CreateStartScripts) {
+        mainClass = mainClassName
+        applicationName = taskName.replaceAll('([A-Z])') { '-' + it[0].uncapitalize() }
+        outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+        classpath = startScripts.classpath
+    }
+    application {
+        applicationDistribution.into('bin') {
+            from(newTask)
+            filePermissions {
+                unix(0755)
+            }
+        }
+    }
 }
 
-applicationDistribution.into('bin') {
-  from(routeGuideServer)
-  from(routeGuideClient)
-  from(helloWorldServer)
-  from(helloWorldClient)
-  from(compressingHelloWorldClient)
-  fileMode = 0755
-}
+createStartScripts('io.grpc.examples.advanced.HelloJsonClient')
+createStartScripts('io.grpc.examples.advanced.HelloJsonServer')
+createStartScripts('io.grpc.examples.cancellation.CancellationClient')
+createStartScripts('io.grpc.examples.cancellation.CancellationServer')
+createStartScripts('io.grpc.examples.customloadbalance.CustomLoadBalanceClient')
+createStartScripts('io.grpc.examples.deadline.DeadlineClient')
+createStartScripts('io.grpc.examples.deadline.DeadlineServer')
+createStartScripts('io.grpc.examples.errordetails.ErrorDetailsExample')
+createStartScripts('io.grpc.examples.experimental.CompressingHelloWorldClient')
+createStartScripts('io.grpc.examples.grpcproxy.GrpcProxy')
+createStartScripts('io.grpc.examples.healthservice.HealthServiceClient')
+createStartScripts('io.grpc.examples.healthservice.HealthServiceServer')
+createStartScripts('io.grpc.examples.hedging.HedgingHelloWorldClient')
+createStartScripts('io.grpc.examples.hedging.HedgingHelloWorldServer')
+createStartScripts('io.grpc.examples.helloworld.HelloWorldClient')
+createStartScripts('io.grpc.examples.helloworld.HelloWorldServer')
+createStartScripts('io.grpc.examples.keepalive.KeepAliveClient')
+createStartScripts('io.grpc.examples.keepalive.KeepAliveServer')
+createStartScripts('io.grpc.examples.loadbalance.LoadBalanceClient')
+createStartScripts('io.grpc.examples.loadbalance.LoadBalanceServer')
+createStartScripts('io.grpc.examples.manualflowcontrol.BidiBlockingClient')
+createStartScripts('io.grpc.examples.manualflowcontrol.ManualFlowControlClient')
+createStartScripts('io.grpc.examples.manualflowcontrol.ManualFlowControlServer')
+createStartScripts('io.grpc.examples.multiplex.MultiplexingServer')
+createStartScripts('io.grpc.examples.multiplex.SharingClient')
+createStartScripts('io.grpc.examples.nameresolve.NameResolveClient')
+createStartScripts('io.grpc.examples.nameresolve.NameResolveServer')
+createStartScripts('io.grpc.examples.preserialized.PreSerializedClient')
+createStartScripts('io.grpc.examples.preserialized.PreSerializedServer')
+createStartScripts('io.grpc.examples.retrying.RetryingHelloWorldClient')
+createStartScripts('io.grpc.examples.retrying.RetryingHelloWorldServer')
+createStartScripts('io.grpc.examples.routeguide.RouteGuideClient')
+createStartScripts('io.grpc.examples.routeguide.RouteGuideServer')
+createStartScripts('io.grpc.examples.waitforready.WaitForReadyClient')
diff --git a/examples/example-alts/BUILD.bazel b/examples/example-alts/BUILD.bazel
new file mode 100644
index 00000000000..4d66accfc19
--- /dev/null
+++ b/examples/example-alts/BUILD.bazel
@@ -0,0 +1,57 @@
+load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library")
+load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library")
+load("@io_grpc_grpc_java//:java_grpc_library.bzl", "java_grpc_library")
+load("@rules_java//java:java_binary.bzl", "java_binary")
+load("@rules_java//java:java_library.bzl", "java_library")
+
+proto_library(
+    name = "helloworld_proto",
+    srcs = ["src/main/proto/helloworld/helloworld.proto"],
+)
+
+java_proto_library(
+    name = "helloworld_java_proto",
+    deps = [":helloworld_proto"],
+)
+
+java_grpc_library(
+    name = "helloworld_java_grpc",
+    srcs = [":helloworld_proto"],
+    deps = [":helloworld_java_proto"],
+)
+
+java_library(
+    name = "example-alts",
+    testonly = 1,
+    srcs = glob(
+        ["src/main/java/**/*.java"],
+    ),
+    deps = [
+        ":helloworld_java_grpc",
+        ":helloworld_java_proto",
+        "@io_grpc_grpc_java//alts",
+        "@io_grpc_grpc_java//api",
+        "@io_grpc_grpc_java//protobuf",
+        "@io_grpc_grpc_java//stub",
+    ],
+)
+
+java_binary(
+    name = "hello-world-alts-client",
+    testonly = 1,
+    main_class = "io.grpc.examples.alts.HelloWorldAltsClient",
+    runtime_deps = [
+        ":example-alts",
+        "@io_grpc_grpc_java//netty",
+    ],
+)
+
+java_binary(
+    name = "hello-world-alts-server",
+    testonly = 1,
+    main_class = "io.grpc.examples.alts.HelloWorldAltsServer",
+    runtime_deps = [
+        ":example-alts",
+        "@io_grpc_grpc_java//netty",
+    ],
+)
diff --git a/examples/example-alts/README.md b/examples/example-alts/README.md
new file mode 100644
index 00000000000..f15aa609235
--- /dev/null
+++ b/examples/example-alts/README.md
@@ -0,0 +1,62 @@
+gRPC ALTS Example
+==================
+
+This example suite shows secure communication between a Hello World 
+client and a Hello World server authenticated by Google's Application Layer 
+Transport Security (ALTS). For more information about ALTS itself, see 
+[ALTS Whiltepaper](https://cloud.google.com/security/encryption-in-transit/application-layer-transport-security) or [grpc.io tutorial](https://grpc.io/docs/languages/java/alts/).
+
+In the gRPC-java context, for both the ALTS client and the ALTS server, a 
+`gRPC-client`-backed handshaker is installed in their channel protocol 
+negotiator. Once a connection is established between the ALTS Client and the 
+ALTS Server, the protocol negotiators will trigger the ALTS handshaking process, 
+which fires multiple rounds of gRPC communication between multiple parties, 
+including the ALTS client, the ALTS server and a pre-deployed handshaker 
+server. At the end, they will reach a shared secret to be used to encrypt the 
+following RPC calls.
+
+The example runs successfully in a GCP environment 
+out-of-the-box, and can be further configured to run in any environments
+with a pre-deployed handshaker service.
+
+
+### Build the example
+
+To build the example,
+
+1. **[Install gRPC Java library SNAPSHOT locally, including code generation plugin](../../COMPILING.md) (Only need this step for non-released versions, e.g. master HEAD).**
+
+2. Run in this directory:
+```
+$ ../gradlew installDist
+```
+
+This creates the scripts `hello-world-alts-server`, `hello-world-alts-client`,
+in the
+`build/install/example-atls/bin/` directory that run the example.
+
+### Run the example in a GCP environment
+ALTS handshake protocol negotiation requires a separate handshaker service. It is
+available in the GCP environment, so we can run the application directly:
+
+```bash
+# Run the server:
+./build/install/example-alts/bin/hello-world-alts-server
+
+```
+
+In another terminal run the client
+
+```
+./build/install/example-alts/bin/hello-world-alts-client
+```
+
+That's it!
+
+### Test the example in a non-GCP environment
+
+To run the example in a non-GCP environment, you should first deploy a 
+[handshaker service](https://github.com/grpc/grpc/blob/7e367da22a137e2e7caeae8342c239a91434ba50/src/proto/grpc/gcp/handshaker.proto#L224-L234) 
+and know its name. You should configure both the [ALTS client](https://github.com/grpc/grpc-java/blob/master/alts/src/main/java/io/grpc/alts/AltsChannelBuilder.java#L63-L76) 
+and [ALTS server](https://github.com/grpc/grpc-java/blob/master/alts/src/main/java/io/grpc/alts/AltsServerCredentials.java#L55-L72)
+to use the known handshaker server for testing. See [example](https://github.com/grpc/grpc-java/blob/master/interop-testing/src/test/java/io/grpc/testing/integration/AltsHandshakerTest.java#L45).
diff --git a/examples/example-alts/build.gradle b/examples/example-alts/build.gradle
new file mode 100644
index 00000000000..939b6ff73e4
--- /dev/null
+++ b/examples/example-alts/build.gradle
@@ -0,0 +1,67 @@
+plugins {
+    // Provide convenience executables for trying out the examples.
+    id 'application'
+    id 'com.google.protobuf' version '0.9.5'
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
+// are looking at a tagged version of the example and not "master"!
+
+// Feel free to delete the comment at the next line. It is just for safely
+// updating the version in our release process.
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protocVersion = '3.25.8'
+
+dependencies {
+    // grpc-alts transitively depends on grpc-netty-shaded, grpc-protobuf, and grpc-stub
+    implementation "io.grpc:grpc-alts:${grpcVersion}"
+}
+
+protobuf {
+    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
+    plugins {
+        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
+    }
+    generateProtoTasks {
+        all()*.plugins { grpc {} }
+    }
+}
+
+startScripts.enabled = false
+
+
+task helloWorldAltsServer(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.alts.HelloWorldAltsServer'
+    applicationName = 'hello-world-alts-server'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+task helloWorldAltsClient(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.alts.HelloWorldAltsClient'
+    applicationName = 'hello-world-alts-client'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into('bin') {
+        from(helloWorldAltsServer)
+        from(helloWorldAltsClient)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
diff --git a/examples/example-alts/settings.gradle b/examples/example-alts/settings.gradle
new file mode 100644
index 00000000000..6bd0f0cdc2d
--- /dev/null
+++ b/examples/example-alts/settings.gradle
@@ -0,0 +1,19 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+
+    repositories {
+        gradlePluginPortal()
+    }
+}
diff --git a/examples/example-alts/src/main/java/io/grpc/examples/alts/HelloWorldAltsClient.java b/examples/example-alts/src/main/java/io/grpc/examples/alts/HelloWorldAltsClient.java
new file mode 100644
index 00000000000..991ad777309
--- /dev/null
+++ b/examples/example-alts/src/main/java/io/grpc/examples/alts/HelloWorldAltsClient.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2018 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.examples.alts;
+
+import io.grpc.alts.AltsChannelCredentials;
+import io.grpc.Grpc;
+import io.grpc.ManagedChannel;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * An example gRPC client that uses ALTS. Shows how to do a Unary RPC. This example can only be run
+ * on Google Cloud Platform.
+ */
+public final class HelloWorldAltsClient {
+  private static final Logger logger = Logger.getLogger(HelloWorldAltsClient.class.getName());
+  private String serverAddress = "localhost:10001";
+
+  public static void main(String[] args) throws InterruptedException {
+    new HelloWorldAltsClient().run(args);
+  }
+
+  private void parseArgs(String[] args) {
+    boolean usage = false;
+    for (String arg : args) {
+      if (!arg.startsWith("--")) {
+        System.err.println("All arguments must start with '--': " + arg);
+        usage = true;
+        break;
+      }
+      String[] parts = arg.substring(2).split("=", 2);
+      String key = parts[0];
+      if ("help".equals(key)) {
+        usage = true;
+        break;
+      }
+      if (parts.length != 2) {
+        System.err.println("All arguments must be of the form --arg=value");
+        usage = true;
+        break;
+      }
+      String value = parts[1];
+      if ("server".equals(key)) {
+        serverAddress = value;
+      } else {
+        System.err.println("Unknown argument: " + key);
+        usage = true;
+        break;
+      }
+    }
+    if (usage) {
+      HelloWorldAltsClient c = new HelloWorldAltsClient();
+      System.out.println(
+          "Usage: [ARGS...]"
+              + "\n"
+              + "\n  --server=SERVER_ADDRESS        Server address to connect to. Default "
+              + c.serverAddress);
+      System.exit(1);
+    }
+  }
+
+  private void run(String[] args) throws InterruptedException {
+    parseArgs(args);
+    ExecutorService executor = Executors.newFixedThreadPool(1);
+    ManagedChannel channel = Grpc.newChannelBuilder(serverAddress, AltsChannelCredentials.create())
+        .executor(executor).build();
+    try {
+      GreeterGrpc.GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(channel);
+      HelloReply resp = stub.sayHello(HelloRequest.newBuilder().setName("Waldo").build());
+
+      logger.log(Level.INFO, "Got {0}", resp);
+    } finally {
+      channel.shutdown();
+      channel.awaitTermination(1, TimeUnit.SECONDS);
+      // Wait until the channel has terminated, since tasks can be queued after the channel is
+      // shutdown.
+      executor.shutdown();
+    }
+  }
+}
diff --git a/examples/example-alts/src/main/java/io/grpc/examples/alts/HelloWorldAltsServer.java b/examples/example-alts/src/main/java/io/grpc/examples/alts/HelloWorldAltsServer.java
new file mode 100644
index 00000000000..6bc5226bf59
--- /dev/null
+++ b/examples/example-alts/src/main/java/io/grpc/examples/alts/HelloWorldAltsServer.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2018 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.examples.alts;
+
+import io.grpc.alts.AltsServerCredentials;
+import io.grpc.Grpc;
+import io.grpc.Server;
+import io.grpc.examples.helloworld.GreeterGrpc.GreeterImplBase;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.concurrent.Executors;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * An example gRPC server that uses ALTS. Shows how to do a Unary RPC. This example can only be run
+ * on Google Cloud Platform.
+ */
+public final class HelloWorldAltsServer extends GreeterImplBase {
+  private static final Logger logger = Logger.getLogger(HelloWorldAltsServer.class.getName());
+  private Server server;
+  private int port = 10001;
+
+  public static void main(String[] args) throws IOException, InterruptedException {
+    new HelloWorldAltsServer().start(args);
+  }
+
+  private void parseArgs(String[] args) {
+    boolean usage = false;
+    for (String arg : args) {
+      if (!arg.startsWith("--")) {
+        System.err.println("All arguments must start with '--': " + arg);
+        usage = true;
+        break;
+      }
+      String[] parts = arg.substring(2).split("=", 2);
+      String key = parts[0];
+      if ("help".equals(key)) {
+        usage = true;
+        break;
+      }
+      if (parts.length != 2) {
+        System.err.println("All arguments must be of the form --arg=value");
+        usage = true;
+        break;
+      }
+      String value = parts[1];
+      if ("port".equals(key)) {
+        port = Integer.parseInt(value);
+      } else {
+        System.err.println("Unknown argument: " + key);
+        usage = true;
+        break;
+      }
+    }
+    if (usage) {
+      HelloWorldAltsServer s = new HelloWorldAltsServer();
+      System.out.println(
+          "Usage: [ARGS...]"
+              + "\n"
+              + "\n  --port=PORT           Server port to bind to. Default "
+              + s.port);
+      System.exit(1);
+    }
+  }
+
+  private void start(String[] args) throws IOException, InterruptedException {
+    parseArgs(args);
+    server =
+        Grpc.newServerBuilderForPort(port, AltsServerCredentials.create())
+            .addService(this)
+            .executor(Executors.newFixedThreadPool(1))
+            .build();
+    server.start();
+    logger.log(Level.INFO, "Started on {0}", port);
+    server.awaitTermination();
+  }
+
+  @Override
+  public void sayHello(HelloRequest request, StreamObserver<HelloReply> observer) {
+    observer.onNext(HelloReply.newBuilder().setMessage("Hello, " + request.getName()).build());
+    observer.onCompleted();
+  }
+}
diff --git a/examples/example-alts/src/main/proto/helloworld/helloworld.proto b/examples/example-alts/src/main/proto/helloworld/helloworld.proto
new file mode 100644
index 00000000000..c60d9416f1f
--- /dev/null
+++ b/examples/example-alts/src/main/proto/helloworld/helloworld.proto
@@ -0,0 +1,37 @@
+// Copyright 2015 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/example-debug/README.md b/examples/example-debug/README.md
new file mode 100644
index 00000000000..3c13de391c4
--- /dev/null
+++ b/examples/example-debug/README.md
@@ -0,0 +1,238 @@
+# gRPC Debug Example
+
+The debug example uses a Hello World style server whose response includes its
+hostname. It demonstrates usage of the AdminInterface and the grpcdebug
+commandline tool.
+
+The example requires grpc-java to already be built. You are strongly encouraged
+to check out a git release tag, since there will already be a build of grpc
+available. Otherwise, you must follow [COMPILING](../../COMPILING.md).
+
+### Build the example
+
+1. Optional:  Build the hello-world-debug example client.
+   See [the examples README](../README.md)
+
+2. Build the debuggable server and client. From the
+   `grpc-java/examples/example-debug` directory run:
+
+```bash
+$ ../gradlew installDist
+```
+
+This creates the script
+`build/install/example-debug/bin/hostname-debuggable-server` that runs the
+example.
+
+To run the debug example, run:
+
+```bash
+$ ./build/install/example-debug/bin/hostname-debuggable-server
+```
+
+And in a different terminal window run the client.
+
+Note:  You can use the standard hello-world client with no debugging enabled and
+still see results on the server. However, if you want to get debug information
+about the client you need to run the hello-world-debuggable client.
+
+Simple client
+
+```bash
+$ ../build/install/examples/bin/hello-world-client
+```
+
+debug enabled client
+
+```bash
+$ ./build/install/example-debug/bin/hello-world-debuggable-client
+```
+
+### Maven
+
+If you prefer to use Maven:
+
+1. Build the hello-world example client. See [the examples README](../README.md)
+
+2. Run in this directory:
+
+```bash
+$ mvn verify
+$ # Run the server (from the example-debug directory)
+$ mvn exec:java -Dexec.mainClass=io.grpc.examples.debug.HostnameServer
+$ # In another terminal run the client (from the examples directory)
+$ cd ..
+$ mvn exec:java -Dexec.mainClass=io.grpc.examples.helloworld.HelloWorldClient
+```
+
+## Using grpcdebug
+
+grpcdebug is a tool that has been created to access the metrics from the
+channelz and health services.
+
+### Installing the grpcdebug tool
+
+The source code is located in a github project
+[grpc-ecosystem/grpcdebug](https://github.com/grpc-ecosystem/grpcdebug). You
+can either download [the latest built version]
+(https://github.com/grpc-ecosystem/grpcdebug/releases/latest) (recommended) or
+follow the README.md to build it yourself.
+
+### Running the grpcdebug tool
+#### Usage
+`grpcdebug <target address> [flags] channelz <command> [argument]`
+
+
+| Command    |       Argument       | Description                                       |
+|:-----------|:--------------------:|:--------------------------------------------------|
+| channel    | \<channel id or URL> | Display channel states in a human readable way.   |
+| channels   |                      | Lists client channels for the target application. |
+| server     |     \<server ID>     | Displays server state in a human readable way.    |
+| servers    |                      | Lists servers in a human readable way.            |
+| socket     |     \<socket ID>     | Displays socket states in a human readable way.   |
+| subchannel |        \<id>         | Display subchannel states in human readable way.  |
+
+Generally, you will start with either `servers` or `channels` and then work down
+to the details
+<br><br>
+
+#### Getting overall server info
+```bash
+bin/grpcdebug/grpcdebug localhost:50051 channelz servers
+```
+This will show you the server ids with their activity
+```text
+Server ID   Listen Addresses   Calls(Started/Succeeded/Failed)   Last Call Started   
+2           [[::]:50051]       38/34/3                           now                 
+```
+<br>
+
+#### Getting details for a service
+```bash
+bin/grpcdebug/grpcdebug localhost:50051 channelz server 2
+```
+
+The output will include more communication details and will show socket ids for
+currently connected clients
+
+```text
+Server Id:           2              
+Listen Addresses:    [[::]:50051]   
+Calls Started:       33             
+Calls Succeeded:     29             
+Calls Failed:        3              
+Last Call Started:   now
+---
+Socket ID   Local->Remote              Streams(Started/Succeeded/Failed)   Messages(Sent/Received)   
+19          [::1]:50051->[::1]:39834   4/3/0                               3/4
+```
+
+#### Displaying detailed info for a server side connection (socket)
+
+```bash
+bin/grpcdebug/grpcdebug localhost:50051 channelz socket 19
+```
+
+This will show a lot of gRPC internal information
+
+```text
+Socket ID:                       19                         
+Address:                         [::1]:50051->[::1]:50094   
+Streams Started:                 1                          
+Streams Succeeded:               0                          
+Streams Failed:                  0                          
+Messages Sent:                   0                          
+Messages Received:               1                          
+Keep Alives Sent:                0                          
+Last Local Stream Created:                                  
+Last Remote Stream Created:      now                        
+Last Message Sent Created:                                  
+Last Message Received Created:   now                        
+Local Flow Control Window:       65535                      
+Remote Flow Control Window:      1048569
+---
+Socket Options Name                                                                Value                                                                         
+SO_LINGER                                                                          [type.googleapis.com/grpc.channelz.v1.SocketOptionLinger]:{}                  
+io.grpc.netty.shaded.io.netty.channel.epoll.EpollChannelOption#TCP_CORK            false                                                                         
+WRITE_BUFFER_HIGH_WATER_MARK                                                       65536                                                                         
+WRITE_BUFFER_LOW_WATER_MARK                                                        32768                                                                         
+IP_TOS                                                                             0                                                                             
+io.grpc.netty.shaded.io.netty.channel.epoll.EpollChannelOption#TCP_KEEPCNT         9                                                                             
+SINGLE_EVENTEXECUTOR_PER_GROUP                                                     true                                                                          
+SO_SNDBUF                                                                          2626560                                                                       
+io.grpc.netty.shaded.io.netty.channel.epoll.EpollChannelOption#TCP_NOTSENT_LOWAT   0                                                                             
+WRITE_BUFFER_WATER_MARK                                                            WriteBufferWaterMark(low: 32768, high: 65536)                                 
+TCP_NODELAY                                                                        true                                                                          
+SO_RCVBUF                                                                          131072                                                                        
+io.grpc.netty.shaded.io.netty.channel.epoll.EpollChannelOption#SO_BUSY_POLL        0                                                                             
+IP_TRANSPARENT                                                                     false                                                                         
+SO_KEEPALIVE                                                                       true                                                                          
+io.grpc.netty.shaded.io.netty.channel.epoll.EpollChannelOption#TCP_QUICKACK        false                                                                         
+ALLOCATOR                                                                          PooledByteBufAllocator(directByDefault: true)                                 
+TCP_FASTOPEN_CONNECT                                                               false                                                                         
+MESSAGE_SIZE_ESTIMATOR                                                             io.grpc.netty.shaded.io.netty.channel.DefaultMessageSizeEstimator@48d475b6    
+WRITE_SPIN_COUNT                                                                   16                                                                            
+SO_REUSEADDR                                                                       true                                                                          
+CONNECT_TIMEOUT_MILLIS                                                             30000                                                                         
+ALLOW_HALF_CLOSURE                                                                 false                                                                         
+io.grpc.netty.shaded.io.netty.channel.epoll.EpollChannelOption#EPOLL_MODE          EDGE_TRIGGERED                                                                
+MAX_MESSAGES_PER_READ                                                              16                                                                            
+io.grpc.netty.shaded.io.netty.channel.epoll.EpollChannelOption#TCP_KEEPIDLE        7200                                                                          
+AUTO_CLOSE                                                                         true                                                                          
+io.grpc.netty.shaded.io.netty.channel.epoll.EpollChannelOption#TCP_KEEPINTVL       75                                                                            
+MAX_MESSAGES_PER_WRITE                                                             2147483647                                                                    
+AUTO_READ                                                                          true                                                                          
+TCP_MD5SIG                                                                         null                                                                          
+RCVBUF_ALLOCATOR                                                                   io.grpc.netty.shaded.io.netty.channel.AdaptiveRecvByteBufAllocator@360691a0   
+```
+#### Displaying the list of gRPC client channels
+Command
+```bash
+bin/grpcdebug/grpcdebug localhost:50051 channelz channels
+```
+Output
+```text
+Channel ID   Target            State     Calls(Started/Succeeded/Failed)   Created Time   
+1            localhost:50051   READY     34/34/0                                          
+3            localhost:50051   READY     16/16/0
+```
+Note:  If you have a simple server that doesn't use gRPC clients to contact other
+servers, then this table will be empty.
+
+#### Displaying details of a gRPC client channel
+Command
+```bash
+bin/grpcdebug/grpcdebug localhost:50051 channelz channel 3
+```
+Output
+```text   
+Channel ID:        3                 
+Target:            localhost:50051   
+State:             READY             
+Calls Started:     16                
+Calls Succeeded:   16                
+Calls Failed:      0                 
+Created Time:                        
+---
+Subchannel ID   Target                                               State     Calls(Started/Succeeded/Failed)   CreatedTime   
+10              [[[localhost/127.0.0.1:50051]/{}], [[localhost/0:0   READY     16/16/0                                                                                
+```
+
+#### Displaying details of a gRPC client subchannel
+Command
+```bash
+bin/grpcdebug/grpcdebug localhost:50051 channelz subchannel 10
+```
+Output
+```text
+Subchannel ID:     10                                                                           
+Target:            [[[localhost/127.0.0.1:50051]/{}], [[localhost/0:0:0:0:0:0:0:1:50051]/{}]]   
+State:             READY                                                                        
+Calls Started:     16                                                                           
+Calls Succeeded:   16                                                                           
+Calls Failed:      0                                                                            
+Created Time:                                                                                   
+---
+Socket ID   Local->Remote                      Streams(Started/Succeeded/Failed)   Messages(Sent/Received)   
+11          127.0.0.1:48536->127.0.0.1:50051   16/16/0                             12/12                     
+```
diff --git a/examples/example-debug/build.gradle b/examples/example-debug/build.gradle
new file mode 100644
index 00000000000..bb7c85cb2be
--- /dev/null
+++ b/examples/example-debug/build.gradle
@@ -0,0 +1,79 @@
+plugins {
+    id 'application' // Provide convenience executables for trying out the examples.
+    id 'java'
+
+    id "com.google.protobuf" version "0.9.5"
+
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
+// are looking at a tagged version of the example and not "master"!
+
+// Feel free to delete the comment at the next line. It is just for safely
+// updating the version in our release process.
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protobufVersion = '3.25.8'
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    implementation "io.grpc:grpc-services:${grpcVersion}"
+    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
+
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation "io.grpc:grpc-testing:${grpcVersion}"
+}
+
+protobuf {
+  protoc {
+    artifact = "com.google.protobuf:protoc:${protobufVersion}"
+  }
+  plugins {
+    grpc {
+      artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}"
+    }
+  }
+  generateProtoTasks {
+    all()*.plugins {
+      grpc {}
+    }
+  }
+}
+
+startScripts.enabled = false
+
+task HelloWorldDebuggableClient(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.debug.HelloWorldDebuggableClient'
+    applicationName = 'hello-world-debuggable-client'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+task HostnameDebuggableServer(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.debug.HostnameDebuggableServer'
+    applicationName = 'hostname-debuggable-server'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into('bin') {
+        from(HelloWorldDebuggableClient)
+        from(HostnameDebuggableServer)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
diff --git a/examples/example-debug/pom.xml b/examples/example-debug/pom.xml
new file mode 100644
index 00000000000..cef96ad17fe
--- /dev/null
+++ b/examples/example-debug/pom.xml
@@ -0,0 +1,112 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>io.grpc</groupId>
+  <artifactId>example-debug</artifactId>
+  <packaging>jar</packaging>
+  <!-- Feel free to delete the comment at the end of these lines. It is just
+       for safely updating the version in our release process. -->
+  <version>1.80.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
+  <name>example-debug</name>
+  <url>https://github.com/grpc/grpc-java</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <grpc.version>1.80.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
+    <protoc.version>3.25.8</protoc.version>
+    <!-- required for jdk9 -->
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+  </properties>
+
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>io.grpc</groupId>
+        <artifactId>grpc-bom</artifactId>
+        <version>${grpc.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+
+  <dependencies>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-services</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-protobuf</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-stub</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-netty-shaded</artifactId>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.13.2</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-testing</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <extensions>
+      <extension>
+        <groupId>kr.motd.maven</groupId>
+        <artifactId>os-maven-plugin</artifactId>
+        <version>1.7.1</version>
+      </extension>
+    </extensions>
+    <plugins>
+      <plugin>
+        <groupId>org.xolstice.maven.plugins</groupId>
+        <artifactId>protobuf-maven-plugin</artifactId>
+        <version>0.6.1</version>
+        <configuration>
+          <protocArtifact>com.google.protobuf:protoc:${protoc.version}:exe:${os.detected.classifier}</protocArtifact>
+          <pluginId>grpc-java</pluginId>
+          <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
+        </configuration>
+        <executions>
+          <execution>
+            <goals>
+              <goal>compile</goal>
+              <goal>compile-custom</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-enforcer-plugin</artifactId>
+        <version>3.5.0</version>
+        <executions>
+          <execution>
+            <id>enforce</id>
+            <goals>
+              <goal>enforce</goal>
+            </goals>
+            <configuration>
+              <rules>
+                <requireUpperBoundDeps/>
+              </rules>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>
diff --git a/examples/example-debug/settings.gradle b/examples/example-debug/settings.gradle
new file mode 100644
index 00000000000..48c08629ca9
--- /dev/null
+++ b/examples/example-debug/settings.gradle
@@ -0,0 +1,17 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+}
+
+rootProject.name = 'example-debug'
diff --git a/examples/example-debug/src/main/java/io/grpc/examples/debug/HelloWorldDebuggableClient.java b/examples/example-debug/src/main/java/io/grpc/examples/debug/HelloWorldDebuggableClient.java
new file mode 100644
index 00000000000..ef1340cf259
--- /dev/null
+++ b/examples/example-debug/src/main/java/io/grpc/examples/debug/HelloWorldDebuggableClient.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2023 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.examples.debug;
+
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.protobuf.services.ProtoReflectionServiceV1;
+import io.grpc.services.AdminInterface;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A client that creates a channelz service and then requests a greeting 50 times.
+ * It uses 2 channels to communicate with the server one of which is shared by 2 stubs and
+ * one of which has only 1 stub.  The requests are split over the 3 channels.
+ * Once completed, there is a 30 second sleep to allow more time to run the commandline debugger.
+ */
+public class HelloWorldDebuggableClient {
+
+  private static final Logger logger = Logger.getLogger(HelloWorldDebuggableClient.class.getName());
+  public static final int NUM_ITERATIONS = 50;
+
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+  /** Construct client for accessing HelloWorld server using the specified channel. */
+  public HelloWorldDebuggableClient(Channel channel) {
+    blockingStub = GreeterGrpc.newBlockingStub(channel);
+  }
+
+  /** Say hello to server. */
+  public void greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response;
+    try {
+      response = blockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    logger.info("Greeting: " + response.getMessage());
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the
+   * greeting. The second argument is the target server.
+   */
+  public static void main(String[] args) throws Exception {
+    String user = "world";
+    // Access a service running on the local machine on port 50051
+    String target = "localhost:50051";
+    int debugPort = 51051;
+    // Allow passing in the user and target strings as command line arguments
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [name [target]]");
+        System.err.println("");
+        System.err.println("  name    The name you wish to be greeted by. Defaults to " + user);
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.exit(1);
+      }
+      user = args[0];
+    }
+    if (args.length > 1) {
+      target = args[1];
+    }
+
+    // Create a pair of communication channels to the server. Channels are thread-safe
+    // and reusable.
+    ManagedChannel channel1 = Grpc.newChannelBuilder(target,
+        InsecureChannelCredentials.create()).build();
+    ManagedChannel channel2 = Grpc.newChannelBuilder(target,
+        InsecureChannelCredentials.create()).build();
+    Server server = null;
+    try {
+      // Create a service from which grpcdebug can request debug info
+      server = Grpc.newServerBuilderForPort(debugPort, InsecureServerCredentials.create())
+          .addServices(AdminInterface.getStandardServices())
+          .build()
+          .start();
+
+      // Create the 3 clients
+      HelloWorldDebuggableClient client1 = new HelloWorldDebuggableClient(channel1);
+      HelloWorldDebuggableClient client2 = new HelloWorldDebuggableClient(channel1);
+      HelloWorldDebuggableClient client3 = new HelloWorldDebuggableClient(channel2);
+
+      // Do the client requests spreadying them over the 3 clients
+      for (int i=0; i < NUM_ITERATIONS; i++) {
+        switch (i % 3) {
+          case 0:
+            client1.greet(user);
+            break;
+          case 1:
+            client2.greet(user);
+            break;
+          case 2:
+            client3.greet(user);
+            break;
+        }
+      }
+      System.out.println("Completed " + NUM_ITERATIONS +
+          " requests, will now sleep for 30 seconds to give some time for command line calls");
+      Thread.sleep(30000); // Give some time for running grpcdebug
+    } finally {
+      // ManagedChannels use resources like threads and TCP connections. To prevent leaking these
+      // resources the channel should be shut down when it will no longer be used. If it may be used
+      // again leave it running.
+      channel1.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+      channel2.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+
+      if (server != null) {
+        server.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+      }
+    }
+  }
+}
diff --git a/examples/example-debug/src/main/java/io/grpc/examples/debug/HostnameDebuggableServer.java b/examples/example-debug/src/main/java/io/grpc/examples/debug/HostnameDebuggableServer.java
new file mode 100644
index 00000000000..5525ba91d9c
--- /dev/null
+++ b/examples/example-debug/src/main/java/io/grpc/examples/debug/HostnameDebuggableServer.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2023 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.examples.debug;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
+import io.grpc.protobuf.services.ProtoReflectionServiceV1;
+import io.grpc.services.AdminInterface;
+import io.grpc.services.HealthStatusManager;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A server that hosts HostnameGreeter, plus the channelz service which grpcdebug uses.
+ */
+public final class HostnameDebuggableServer {
+  static int port = 50051;
+  static String hostname = null;
+
+  public static void main(String[] args) throws IOException, InterruptedException {
+    parseArgs(args); // sets port and hostname
+
+    final Server server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new HostnameGreeter(hostname))
+        .addServices(AdminInterface.getStandardServices()) // the key add for enabling grpcdebug
+        .build()
+        .start();
+
+    System.out.println("Listening on port " + port);
+
+    addShutdownHook(server); // Configures cleanup
+    server.awaitTermination();  // Block until shutdown
+  }
+
+  private static void parseArgs(String[] args) {
+    if (args.length >= 1) {
+      try {
+        port = Integer.parseInt(args[0]);
+      } catch (NumberFormatException ex) {
+        System.err.println("Usage: [port [hostname]]");
+        System.err.println("");
+        System.err.println("  port      The listen port. Defaults to " + port);
+        System.err.println("  hostname  The name clients will see in greet responses. ");
+        System.err.println("            Defaults to the machine's hostname");
+        System.exit(1);
+      }
+    }
+    if (args.length >= 2) {
+      hostname = args[1];
+    }
+  }
+
+  private static void addShutdownHook(final Server server) {
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Start graceful shutdown
+        server.shutdown();
+        try {
+          // Wait for RPCs to complete processing
+          if (!server.awaitTermination(30, TimeUnit.SECONDS)) {
+            // That was plenty of time. Let's cancel the remaining RPCs
+            server.shutdownNow();
+            // shutdownNow isn't instantaneous, so give a bit of time to clean resources up
+            // gracefully. Normally this will be well under a second.
+            server.awaitTermination(5, TimeUnit.SECONDS);
+          }
+        } catch (InterruptedException ex) {
+          server.shutdownNow();
+        }
+      }
+    });
+  }
+}
diff --git a/examples/example-debug/src/main/java/io/grpc/examples/debug/HostnameGreeter.java b/examples/example-debug/src/main/java/io/grpc/examples/debug/HostnameGreeter.java
new file mode 100644
index 00000000000..7146f30cfe6
--- /dev/null
+++ b/examples/example-debug/src/main/java/io/grpc/examples/debug/HostnameGreeter.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2023 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.examples.debug;
+
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/** Greeter implementation which replies identifying itself with its hostname. */
+public final class HostnameGreeter extends GreeterGrpc.GreeterImplBase {
+  private static final Logger logger = Logger.getLogger(HostnameGreeter.class.getName());
+
+  private AtomicInteger callCount = new AtomicInteger();
+
+  private final String serverName;
+
+  public HostnameGreeter(String serverName) {
+    if (serverName == null) {
+      serverName = determineHostname();
+    }
+    this.serverName = serverName;
+  }
+
+  @Override
+  public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+    int curCount = callCount.incrementAndGet();
+    HelloReply reply = HelloReply.newBuilder()
+        .setMessage(String.format("Hello %s, from %s.  You are requester number %d.",
+                req.getName(), serverName, curCount))
+        .build();
+    // Add a pause so that there is time to run debug commands
+    try {
+      int sleep_interval = (curCount % 10) * 100; // 0 - 1 second
+      Thread.sleep(sleep_interval);
+    } catch (InterruptedException e) {
+      responseObserver.onError(e);
+    }
+    // Send the response
+    responseObserver.onNext(reply);
+    responseObserver.onCompleted();
+  }
+
+  private static String determineHostname() {
+    try {
+      return InetAddress.getLocalHost().getHostName();
+    } catch (IOException ex) {
+      logger.log(Level.INFO, "Failed to determine hostname. Will generate one", ex);
+    }
+    // Strange. Well, let's make an identifier for ourselves.
+    return "generated-" + new Random().nextInt();
+  }
+}
diff --git a/examples/example-debug/src/main/proto/helloworld/helloworld.proto b/examples/example-debug/src/main/proto/helloworld/helloworld.proto
new file mode 100644
index 00000000000..c60d9416f1f
--- /dev/null
+++ b/examples/example-debug/src/main/proto/helloworld/helloworld.proto
@@ -0,0 +1,37 @@
+// Copyright 2015 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/example-dualstack/README.md b/examples/example-dualstack/README.md
new file mode 100644
index 00000000000..5a26886e259
--- /dev/null
+++ b/examples/example-dualstack/README.md
@@ -0,0 +1,54 @@
+# gRPC Dualstack Example
+
+The dualstack example uses a custom name resolver that provides both IPv4 and IPv6 localhost
+endpoints for each of 3 server instances. The client will first use the default name resolver and
+load balancers which will only connect to the first server.  It will then use the 
+custom name resolver with round robin to connect to each of the servers in turn.  The 3 instances
+of the server will bind respectively to: both IPv4 and IPv6, IPv4 only, and IPv6 only.
+
+The example requires grpc-java to already be built. You are strongly encouraged
+to check out a git release tag, since there will already be a build of grpc
+available. Otherwise, you must follow [COMPILING](../../COMPILING.md).
+
+### Build the example
+
+To build the dualstack example server and client. From the
+   `grpc-java/examples/example-dualstack` directory run:
+
+```bash
+$ ../gradlew installDist
+```
+
+This creates the scripts
+`build/install/example-dualstack/bin/dual-stack-server`
+ and `build/install/example-dualstack/bin/dual-stack-client`.
+
+To run the dualstack example, run the server with:
+
+```bash
+$ ./build/install/example-dualstack/bin/dual-stack-server
+```
+
+And in a different terminal window run the client.
+
+```bash
+$ ./build/install/example-dualstack/bin/dual-stack-client
+```
+
+### Maven
+
+If you prefer to use Maven:
+
+Run in the example-debug directory:
+
+```bash
+$ mvn verify
+$ # Run the server in one terminal
+$ mvn exec:java -Dexec.mainClass=io.grpc.examples.dualstack.DualStackServer
+```
+
+```bash
+$ # In another terminal run the client
+$ mvn exec:java -Dexec.mainClass=io.grpc.examples.dualstack.DualStackClient
+```
+
diff --git a/examples/example-dualstack/build.gradle b/examples/example-dualstack/build.gradle
new file mode 100644
index 00000000000..0b5e165f692
--- /dev/null
+++ b/examples/example-dualstack/build.gradle
@@ -0,0 +1,76 @@
+plugins {
+    id 'application' // Provide convenience executables for trying out the examples.
+    id 'java'
+
+    id "com.google.protobuf" version "0.9.5"
+
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
+// are looking at a tagged version of the example and not "master"!
+
+// Feel free to delete the comment at the next line. It is just for safely
+// updating the version in our release process.
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protobufVersion = '3.25.8'
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-netty:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    implementation "io.grpc:grpc-services:${grpcVersion}"
+}
+
+protobuf {
+  protoc {
+    artifact = "com.google.protobuf:protoc:${protobufVersion}"
+  }
+  plugins {
+    grpc {
+      artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}"
+    }
+  }
+  generateProtoTasks {
+    all()*.plugins {
+      grpc {}
+    }
+  }
+}
+
+startScripts.enabled = false
+
+task DualStackClient(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.dualstack.DualStackClient'
+    applicationName = 'dual-stack-client'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+task DualStackServer(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.dualstack.DualStackServer'
+    applicationName = 'dual-stack-server'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into('bin') {
+        from(DualStackClient)
+        from(DualStackServer)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
diff --git a/examples/example-dualstack/pom.xml b/examples/example-dualstack/pom.xml
new file mode 100644
index 00000000000..96be352c45f
--- /dev/null
+++ b/examples/example-dualstack/pom.xml
@@ -0,0 +1,116 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>io.grpc</groupId>
+  <artifactId>example-dualstack</artifactId>
+  <packaging>jar</packaging>
+  <!-- Feel free to delete the comment at the end of these lines. It is just
+       for safely updating the version in our release process. -->
+  <version>1.80.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
+  <name>example-dualstack</name>
+  <url>https://github.com/grpc/grpc-java</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <grpc.version>1.80.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
+    <protoc.version>3.25.8</protoc.version>
+    <!-- required for jdk9 -->
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+  </properties>
+
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>io.grpc</groupId>
+        <artifactId>grpc-bom</artifactId>
+        <version>${grpc.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+
+  <dependencies>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-services</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-protobuf</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-stub</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-netty</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-netty-shaded</artifactId>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.13.2</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-testing</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <extensions>
+      <extension>
+        <groupId>kr.motd.maven</groupId>
+        <artifactId>os-maven-plugin</artifactId>
+        <version>1.7.1</version>
+      </extension>
+    </extensions>
+    <plugins>
+      <plugin>
+        <groupId>org.xolstice.maven.plugins</groupId>
+        <artifactId>protobuf-maven-plugin</artifactId>
+        <version>0.6.1</version>
+        <configuration>
+          <protocArtifact>com.google.protobuf:protoc:${protoc.version}:exe:${os.detected.classifier}</protocArtifact>
+          <pluginId>grpc-java</pluginId>
+          <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
+        </configuration>
+        <executions>
+          <execution>
+            <goals>
+              <goal>compile</goal>
+              <goal>compile-custom</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-enforcer-plugin</artifactId>
+        <version>3.5.0</version>
+        <executions>
+          <execution>
+            <id>enforce</id>
+            <goals>
+              <goal>enforce</goal>
+            </goals>
+            <configuration>
+              <rules>
+                <requireUpperBoundDeps/>
+              </rules>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>
diff --git a/examples/example-dualstack/settings.gradle b/examples/example-dualstack/settings.gradle
new file mode 100644
index 00000000000..160d5134334
--- /dev/null
+++ b/examples/example-dualstack/settings.gradle
@@ -0,0 +1,21 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+
+    repositories {
+        gradlePluginPortal()
+    }
+}
+
+rootProject.name = 'example-dualstack'
diff --git a/examples/example-dualstack/src/main/java/io/grpc/examples/dualstack/DualStackClient.java b/examples/example-dualstack/src/main/java/io/grpc/examples/dualstack/DualStackClient.java
new file mode 100644
index 00000000000..b9993a524d6
--- /dev/null
+++ b/examples/example-dualstack/src/main/java/io/grpc/examples/dualstack/DualStackClient.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2024 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.examples.dualstack;
+
+import io.grpc.Channel;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.NameResolverRegistry;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A client that requests greetings from the {@link DualStackServer}.
+ * First it sends 5 requests using the default nameresolver and load balancer.
+ * Then it sends 10 requests using the example nameresolver and round robin load balancer.  These
+ * requests are evenly distributed among the 3 servers rather than favoring the server listening
+ * on both addresses because the ExampleDualStackNameResolver groups the 3 servers as 3 endpoints
+ * each with 2 addresses.
+ */
+public class DualStackClient {
+    public static final String channelTarget = "example:///lb.example.grpc.io";
+    private static final Logger logger = Logger.getLogger(DualStackClient.class.getName());
+    private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+    public DualStackClient(Channel channel) {
+        blockingStub = GreeterGrpc.newBlockingStub(channel);
+    }
+
+    public static void main(String[] args) throws Exception {
+        NameResolverRegistry.getDefaultRegistry()
+            .register(new ExampleDualStackNameResolverProvider());
+
+        logger.info("\n **** Use default DNS resolver ****");
+        ManagedChannel channel = ManagedChannelBuilder.forTarget("localhost:50051")
+                .usePlaintext()
+                .build();
+        try {
+            DualStackClient client = new DualStackClient(channel);
+            for (int i = 0; i < 5; i++) {
+                client.greet("request:" + i);
+            }
+        } finally {
+            channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+        }
+
+        logger.info("\n  **** Change to use example name resolver ****");
+        /*
+          Dial to "example:///resolver.example.grpc.io", use {@link ExampleNameResolver} to create connection
+          "resolver.example.grpc.io" is converted to {@link java.net.URI.path}
+         */
+        channel = ManagedChannelBuilder.forTarget(channelTarget)
+            .defaultLoadBalancingPolicy("round_robin")
+            .usePlaintext()
+            .build();
+        try {
+            DualStackClient client = new DualStackClient(channel);
+            for (int i = 0; i < 10; i++) {
+                client.greet("request:" + i);
+            }
+        } finally {
+            channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+        }
+    }
+
+    public void greet(String name) {
+        HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+        HelloReply response;
+        try {
+            response = blockingStub.sayHello(request);
+        } catch (StatusRuntimeException e) {
+            logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+            return;
+        }
+        logger.info("Greeting: " + response.getMessage());
+    }
+}
diff --git a/examples/example-dualstack/src/main/java/io/grpc/examples/dualstack/DualStackServer.java b/examples/example-dualstack/src/main/java/io/grpc/examples/dualstack/DualStackServer.java
new file mode 100644
index 00000000000..43b21e963f8
--- /dev/null
+++ b/examples/example-dualstack/src/main/java/io/grpc/examples/dualstack/DualStackServer.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2024 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.examples.dualstack;
+
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.netty.NettyServerBuilder;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * Starts 3 different greeter services each on its own port, but all for localhost.
+ * The first service listens on both IPv4 and IPv6,
+ * the second on just IPv4, and the third on just IPv6.
+ */
+public class DualStackServer {
+    private static final Logger logger = Logger.getLogger(DualStackServer.class.getName());
+    private List<Server> servers;
+
+    public static void main(String[] args) throws IOException, InterruptedException {
+        final DualStackServer server = new DualStackServer();
+        server.start();
+        server.blockUntilShutdown();
+    }
+
+    private void start() throws IOException {
+        InetSocketAddress inetSocketAddress;
+
+        servers = new ArrayList<>();
+        int[] serverPorts = ExampleDualStackNameResolver.SERVER_PORTS;
+        for (int i = 0; i < serverPorts.length; i++ ) {
+            String addressType;
+            int port = serverPorts[i];
+            ServerBuilder<?> serverBuilder;
+            switch (i) {
+                case 0:
+                    serverBuilder = ServerBuilder.forPort(port); // bind to both IPv4 and IPv6
+                    addressType = "both IPv4 and IPv6";
+                    break;
+                case 1:
+                    // bind to IPv4 only
+                    inetSocketAddress = new InetSocketAddress("127.0.0.1", port);
+                    serverBuilder = NettyServerBuilder.forAddress(inetSocketAddress);
+                    addressType = "IPv4 only";
+                    break;
+                case 2:
+                    // bind to IPv6 only
+                    inetSocketAddress = new InetSocketAddress("::1", port);
+                    serverBuilder = NettyServerBuilder.forAddress(inetSocketAddress);
+                    addressType = "IPv6 only";
+                    break;
+                default:
+                    throw new IllegalStateException("Unexpected value: " + i);
+            }
+
+            servers.add(serverBuilder
+                .addService(new GreeterImpl(port, addressType))
+                .build()
+                .start());
+            logger.info("Server started, listening on " + port);
+        }
+        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+            System.err.println("*** shutting down gRPC server since JVM is shutting down");
+            try {
+                DualStackServer.this.stop();
+            } catch (InterruptedException e) {
+                e.printStackTrace(System.err);
+            }
+            System.err.println("*** server shut down");
+        }));
+    }
+
+    private void stop() throws InterruptedException {
+        for (Server server : servers) {
+            server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+        }
+    }
+
+    private void blockUntilShutdown() throws InterruptedException {
+        for (Server server : servers) {
+            server.awaitTermination();
+        }
+    }
+
+    static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+        int port;
+        String addressType;
+
+        public GreeterImpl(int port, String addressType) {
+            this.port = port;
+            this.addressType = addressType;
+        }
+
+        @Override
+        public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+            String msg = String.format("Hello %s from server<%d> type: %s",
+                req.getName(), this.port, addressType);
+            HelloReply reply = HelloReply.newBuilder().setMessage(msg).build();
+            responseObserver.onNext(reply);
+            responseObserver.onCompleted();
+        }
+    }
+}
diff --git a/examples/example-dualstack/src/main/java/io/grpc/examples/dualstack/ExampleDualStackNameResolver.java b/examples/example-dualstack/src/main/java/io/grpc/examples/dualstack/ExampleDualStackNameResolver.java
new file mode 100644
index 00000000000..70675b3de3d
--- /dev/null
+++ b/examples/example-dualstack/src/main/java/io/grpc/examples/dualstack/ExampleDualStackNameResolver.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2024 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.examples.dualstack;
+
+import com.google.common.collect.ImmutableMap;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.Status;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * A fake name resolver that resolves to a hard-coded list of 3 endpoints (EquivalentAddressGropu)
+ * each with 2 addresses (one IPv4 and one IPv6).
+ */
+public class ExampleDualStackNameResolver extends NameResolver {
+    static public final int[] SERVER_PORTS = {50051, 50052, 50053};
+
+    // This is a fake name resolver, so we just hard code the address here.
+    private static final ImmutableMap<String, List<List<SocketAddress>>> addrStore =
+        ImmutableMap.<String, List<List<SocketAddress>>>builder()
+        .put("lb.example.grpc.io",
+            Arrays.stream(SERVER_PORTS)
+                .mapToObj(port -> getLocalAddrs(port))
+                .collect(Collectors.toList())
+        )
+        .build();
+
+    private Listener2 listener;
+
+    private final URI uri;
+
+    public ExampleDualStackNameResolver(URI targetUri) {
+        this.uri = targetUri;
+    }
+
+    private static List<SocketAddress> getLocalAddrs(int port) {
+        return Arrays.asList(
+            new InetSocketAddress("127.0.0.1", port),
+            new InetSocketAddress("::1", port));
+    }
+
+    @Override
+    public String getServiceAuthority() {
+        return uri.getPath().substring(1);
+    }
+
+    @Override
+    public void shutdown() {
+    }
+
+    @Override
+    public void start(Listener2 listener) {
+        this.listener = listener;
+        this.resolve();
+    }
+
+    @Override
+    public void refresh() {
+        this.resolve();
+    }
+
+    private void resolve() {
+        List<List<SocketAddress>> addresses = addrStore.get(uri.getPath().substring(1));
+        try {
+            List<EquivalentAddressGroup> eagList = new ArrayList<>();
+            for (List<SocketAddress> endpoint : addresses) {
+                // every server is an EquivalentAddressGroup, so they can be accessed randomly
+                eagList.add(new EquivalentAddressGroup(endpoint));
+            }
+
+            this.listener.onResult(ResolutionResult.newBuilder().setAddresses(eagList).build());
+        } catch (Exception e){
+            // when error occurs, notify listener
+            this.listener.onError(Status.UNAVAILABLE.withDescription("Unable to resolve host ").withCause(e));
+        }
+    }
+
+}
diff --git a/examples/example-dualstack/src/main/java/io/grpc/examples/dualstack/ExampleDualStackNameResolverProvider.java b/examples/example-dualstack/src/main/java/io/grpc/examples/dualstack/ExampleDualStackNameResolverProvider.java
new file mode 100644
index 00000000000..a01d68aca3e
--- /dev/null
+++ b/examples/example-dualstack/src/main/java/io/grpc/examples/dualstack/ExampleDualStackNameResolverProvider.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2024 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.examples.dualstack;
+
+import io.grpc.NameResolver;
+import io.grpc.NameResolverProvider;
+
+import java.net.URI;
+
+public class ExampleDualStackNameResolverProvider extends NameResolverProvider {
+    public static final String exampleScheme = "example";
+
+    @Override
+    public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+        return new ExampleDualStackNameResolver(targetUri);
+    }
+
+    @Override
+    protected boolean isAvailable() {
+        return true;
+    }
+
+    @Override
+    protected int priority() {
+        return 5;
+    }
+
+    @Override
+    // gRPC choose the first NameResolverProvider that supports the target URI scheme.
+    public String getDefaultScheme() {
+        return exampleScheme;
+    }
+}
diff --git a/examples/example-dualstack/src/main/proto/helloworld/helloworld.proto b/examples/example-dualstack/src/main/proto/helloworld/helloworld.proto
new file mode 100644
index 00000000000..c60d9416f1f
--- /dev/null
+++ b/examples/example-dualstack/src/main/proto/helloworld/helloworld.proto
@@ -0,0 +1,37 @@
+// Copyright 2015 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/example-gauth/BUILD.bazel b/examples/example-gauth/BUILD.bazel
new file mode 100644
index 00000000000..033c51f8856
--- /dev/null
+++ b/examples/example-gauth/BUILD.bazel
@@ -0,0 +1,28 @@
+load("@rules_java//java:java_binary.bzl", "java_binary")
+load("@rules_java//java:java_library.bzl", "java_library")
+
+java_library(
+    name = "example-gauth",
+    testonly = 1,
+    srcs = glob(
+        ["src/main/java/**/*.java"],
+    ),
+    deps = [
+        "@io_grpc_grpc_java//api",
+        "@io_grpc_grpc_java//auth",
+        "@io_grpc_grpc_java//protobuf",
+        "@io_grpc_grpc_java//stub",
+        "@maven//:com_google_api_grpc_grpc_google_cloud_pubsub_v1",
+        "@maven//:com_google_api_grpc_proto_google_cloud_pubsub_v1",
+        "@maven//:com_google_auth_google_auth_library_oauth2_http",
+    ],
+)
+
+java_binary(
+    name = "google-auth-client",
+    testonly = 1,
+    main_class = "io.grpc.examples.googleAuth.GoogleAuthClient",
+    runtime_deps = [
+        ":example-gauth",
+    ],
+)
diff --git a/examples/example-gauth/README.md b/examples/example-gauth/README.md
new file mode 100644
index 00000000000..b49d346a9be
--- /dev/null
+++ b/examples/example-gauth/README.md
@@ -0,0 +1,104 @@
+Google Authentication Example
+==============================================
+
+This example illustrates how to access [Google APIs](https://cloud.google.com/apis/docs/overview) via gRPC and
+open source [Google API libraries](https://github.com/googleapis) using
+[Google authentication](https://developers.google.com/identity/protocols/OAuth2), specifically the
+[GoogleCredentials](https://github.com/googleapis/google-auth-library-java/blob/master/oauth2_http/java/com/google/auth/oauth2/GoogleCredentials.java)
+class.
+
+The example requires grpc-java to be pre-built. Using a release tag will download the relevant binaries
+from a maven repository. But if you need the latest SNAPSHOT binaries you will need to follow
+[COMPILING](../COMPILING.md) to build these.
+
+Please follow the [steps](./README.md#to-build-the-examples) to build the examples. The build creates
+the script `google-auth-client` in the `build/install/examples/bin/` directory which can be
+used to run this example.
+
+The example uses [Google PubSub gRPC API](https://cloud.google.com/pubsub/docs/reference/rpc/) to get a list
+of PubSub topics for a project. You will need to perform the following steps to get the example to work.
+Wherever possible, the required UI links or `gcloud` shell commands are mentioned.
+
+1. Create or use an existing [Google Cloud](https://cloud.google.com) account. In your account, you may need
+to enable features to exercise this example and this may cost some money.
+
+2. Use an existing project, or [create a project](https://pantheon.corp.google.com/projectcreate),
+say `Google Auth Pubsub example`. Note down the project ID of this project - say `xyz123` for this example.
+Use the project drop-down from the top or use the cloud shell command
+```
+gcloud projects list
+```
+to get the project ID.
+
+3. Unless already enabled, [enable the Cloud Pub/Sub API for your project](https://console.developers.google.com/apis/api/pubsub.googleapis.com/overview)
+by clicking `Enable`.
+
+4. Go to the [GCP Pub/Sub console](https://pantheon.corp.google.com/cloudpubsub). Create a couple of new
+topics using the "+ CREATE TOPIC" button, say `Topic1` and `Topic2`. You can also use the gcloud command
+to create a topic:
+```
+gcloud pubsub topics create Topic1
+```
+
+5. You will now need to set up [authentication](https://cloud.google.com/docs/authentication/) and a
+[service account](https://cloud.google.com/docs/authentication/#service_accounts) in order to access
+Pub/Sub via gRPC APIs as described [here](https://cloud.google.com/iam/docs/creating-managing-service-accounts).
+(**Note:** This step is unnecessary on Google platforms (Google App Engine / Google Cloud Shell / Google Compute Engine) as it will
+automatically use the in-built Google credentials). Assign the [role](https://cloud.google.com/iam/docs/granting-roles-to-service-accounts) `Project -> Owner`
+and for Key type select JSON. Once you click `Create`, a JSON file containing your key is downloaded to
+your computer. Note down the path of this file or copy this file to the computer and file system where
+you will be running the example application as described later. Assume this JSON file is available at
+`/path/to/JSON/file` Set the value of the environment variable GOOGLE_APPLICATION_CREDENTIALS to this file path. You can also use the `gcloud` shell commands to
+[create the service account](https://cloud.google.com/iam/docs/creating-managing-service-accounts#iam-service-accounts-create-gcloud).
+
+#### To build the examples
+
+1. **[Install gRPC Java library SNAPSHOT locally, including code generation plugin](../../COMPILING.md) (Only need this step for non-released versions, e.g. master HEAD).**
+
+2. Run in this directory:
+```
+$ ../gradlew installDist
+```
+
+
+#### How to run the example:
+`google-auth-client` requires one command line argument for the project ID:
+
+ ```text
+USAGE: GoogleAuthClient <project-ID>
+```
+
+The first argument <project-ID> is the project ID in the form "projects/xyz123" where "xyz123" is
+the project ID of the project you created (or used) in step 2 above.
+
+ ```bash
+# Run the client
+./build/install/example-gauth/bin/google-auth-client projects/xyz123
+```
+ That's it! The client will show the list of Pub/Sub topics for the project as follows:
+
+ ```
+ INFO: Topics list:
+ [name: "projects/xyz123/topics/Topic1"
+ , name: "projects/xyz123/topics/Topic2"
+ ]
+ ```
+
+ ## Maven
+ If you prefer to use Maven:
+ 1. **[Install gRPC Java library SNAPSHOT locally, including code generation plugin](../../COMPILING.md) (Only need this step for non-released versions, e.g. master HEAD).**
+
+ 2. Run in this directory:
+ ```
+ $ mvn verify
+ $ # Run the client
+ $ mvn exec:java -Dexec.mainClass=io.grpc.examples.googleAuth.GoogleAuthClient -Dexec.args="projects/xyz123"
+ ```
+
+ ## Bazel
+ If you prefer to use Bazel:
+ ```
+ $ bazel build :google-auth-client
+ $ # Run the client
+ $ ../bazel-bin/google-auth-client projects/xyz123
+ ```
\ No newline at end of file
diff --git a/examples/example-gauth/build.gradle b/examples/example-gauth/build.gradle
new file mode 100644
index 00000000000..48294d0a5b3
--- /dev/null
+++ b/examples/example-gauth/build.gradle
@@ -0,0 +1,64 @@
+plugins {
+    // Provide convenience executables for trying out the examples.
+    id 'application'
+    id 'com.google.protobuf' version '0.9.5'
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
+// are looking at a tagged version of the example and not "master"!
+
+// Feel free to delete the comment at the next line. It is just for safely
+// updating the version in our release process.
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protobufVersion = '3.25.8'
+def protocVersion = protobufVersion
+
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    implementation "io.grpc:grpc-auth:${grpcVersion}"
+    implementation "com.google.auth:google-auth-library-oauth2-http:1.41.0"
+    implementation "com.google.api.grpc:grpc-google-cloud-pubsub-v1:0.1.24"
+    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
+}
+
+protobuf {
+    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
+    plugins {
+        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
+    }
+    generateProtoTasks {
+        all()*.plugins { grpc {} }
+    }
+}
+
+startScripts.enabled = false
+
+task googleAuthClient(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.googleAuth.GoogleAuthClient'
+    applicationName = 'google-auth-client'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into('bin') {
+        from(googleAuthClient)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
diff --git a/examples/example-gauth/pom.xml b/examples/example-gauth/pom.xml
new file mode 100644
index 00000000000..9c520141027
--- /dev/null
+++ b/examples/example-gauth/pom.xml
@@ -0,0 +1,110 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>io.grpc</groupId>
+  <artifactId>example-gauth</artifactId>
+  <packaging>jar</packaging>
+  <!-- Feel free to delete the comment at the end of these lines. It is just
+       for safely updating the version in our release process. -->
+  <version>1.80.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
+  <name>example-gauth</name>
+  <url>https://github.com/grpc/grpc-java</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <grpc.version>1.80.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
+    <protobuf.version>3.25.8</protobuf.version>
+    <!-- required for jdk9 -->
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+  </properties>
+
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>io.grpc</groupId>
+        <artifactId>grpc-bom</artifactId>
+        <version>${grpc.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+
+  <dependencies>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-netty-shaded</artifactId>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-protobuf</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-stub</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-auth</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-testing</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.google.auth</groupId>
+      <artifactId>google-auth-library-oauth2-http</artifactId>
+      <version>1.40.0</version>
+    </dependency>
+    <dependency>
+      <groupId>com.google.api.grpc</groupId>
+      <artifactId>grpc-google-cloud-pubsub-v1</artifactId>
+      <version>0.1.24</version>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.13.2</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <version>4.4.0</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <extensions>
+      <extension>
+        <groupId>kr.motd.maven</groupId>
+        <artifactId>os-maven-plugin</artifactId>
+        <version>1.7.1</version>
+      </extension>
+    </extensions>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-enforcer-plugin</artifactId>
+        <version>3.5.0</version>
+        <executions>
+          <execution>
+            <id>enforce</id>
+            <goals>
+              <goal>enforce</goal>
+            </goals>
+            <configuration>
+              <rules>
+                <requireUpperBoundDeps/>
+              </rules>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>
diff --git a/examples/example-gauth/settings.gradle b/examples/example-gauth/settings.gradle
new file mode 100644
index 00000000000..6bd0f0cdc2d
--- /dev/null
+++ b/examples/example-gauth/settings.gradle
@@ -0,0 +1,19 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+
+    repositories {
+        gradlePluginPortal()
+    }
+}
diff --git a/examples/example-gauth/src/main/java/io/grpc/examples/googleAuth/GoogleAuthClient.java b/examples/example-gauth/src/main/java/io/grpc/examples/googleAuth/GoogleAuthClient.java
new file mode 100644
index 00000000000..eb0d9feedfc
--- /dev/null
+++ b/examples/example-gauth/src/main/java/io/grpc/examples/googleAuth/GoogleAuthClient.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2018 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.examples.googleAuth;
+
+import com.google.auth.oauth2.GoogleCredentials;
+import com.google.pubsub.v1.ListTopicsRequest;
+import com.google.pubsub.v1.ListTopicsResponse;
+import com.google.pubsub.v1.PublisherGrpc;
+import io.grpc.CallCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.StatusRuntimeException;
+import io.grpc.auth.MoreCallCredentials;
+import java.io.FileInputStream;
+import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Example to illustrate use of Google credentials as described in
+ * @see <a href="../../../../../../README.md">Google Auth Example README</a>
+ *
+ * Also @see <a href="https://cloud.google.com/pubsub/docs/reference/rpc/">Google Cloud Pubsub via gRPC</a>
+ */
+public class GoogleAuthClient {
+  private static final Logger logger = Logger.getLogger(GoogleAuthClient.class.getName());
+
+  private final ManagedChannel channel;
+
+  /**
+   * stub generated from the proto file.
+   */
+  private final PublisherGrpc.PublisherBlockingStub blockingStub;
+
+  /**
+   * Construct our gRPC client that connects to the pubsub server at {@code host:port}.
+   *
+   * @param host  host to connect to - typically "pubsub.googleapis.com"
+   * @param port  port to connect to - typically 443 - the TLS port
+   * @param callCredentials  the Google call credentials
+   */
+  public GoogleAuthClient(String host, int port, CallCredentials callCredentials) {
+    // Google API invocation requires a secure channel. Channels are secure by default (SSL/TLS)
+    this(ManagedChannelBuilder.forAddress(host, port).build(), callCredentials);
+  }
+
+  /**
+   * Construct our gRPC client that connects to the pubsub server using an existing channel.
+   *
+   * @param channel    channel that has been built already
+   * @param callCredentials  the Google call credentials
+   */
+  GoogleAuthClient(ManagedChannel channel, CallCredentials callCredentials) {
+    this.channel = channel;
+    blockingStub = PublisherGrpc.newBlockingStub(channel).withCallCredentials(callCredentials);
+  }
+
+  public void shutdown() throws InterruptedException {
+    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
+  }
+
+  /**
+   * Get topics (max 10) for our project ID: the topic list is logged to the logger.
+   *
+   * @param projectID  the GCP project ID to get the pubsub topics for. This is a string like
+   *                   "projects/balmy-cirrus-225307" where "balmy-cirrus-225307" is
+   *                   the project ID for the project you created.
+   */
+  public void getTopics(String projectID) {
+    logger.log(Level.INFO, "Will try to get topics for project {0} ...", projectID);
+
+    ListTopicsRequest request = ListTopicsRequest.newBuilder()
+            .setPageSize(10)        // get max 10 topics
+            .setProject(projectID)  // for our projectID
+            .build();
+
+    ListTopicsResponse response;
+    try {
+      response = blockingStub.listTopics(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    logger.log(Level.INFO, "Topics list:\n {0}", response.getTopicsList());
+  }
+
+  /**
+   * The app requires 2 arguments as described in
+   * @see <a href="../../../../../../README.md">Google Auth Example README</a>
+   *
+   * arg0 = project name in the form "projects/balmy-cirrus-225307" where "balmy-cirrus-225307" is
+   *        the project ID for the project you created.
+   *
+   * On non-Google platforms, the GOOGLE_APPLICATION_CREDENTIALS env variable should be set to the
+   * location of the JSON file for the service account you created in the GCP console.
+   */
+  public static void main(String[] args) throws Exception {
+    if (args.length < 1) {
+      logger.severe("Usage: please pass 1 argument:\n" +
+                    "arg0 = project name in the form \"projects/xyz\" where \"xyz\" is the project ID of the project you created.\n");
+      System.exit(1);
+    }
+    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault();
+
+    // We need to create appropriate scope as per https://cloud.google.com/storage/docs/authentication#oauth-scopes
+    credentials = credentials.createScoped(Arrays.asList("https://www.googleapis.com/auth/cloud-platform"));
+
+    GoogleAuthClient client =
+            new GoogleAuthClient("pubsub.googleapis.com", 443, MoreCallCredentials.from(credentials));
+
+    try {
+      client.getTopics(args[0]);
+    } finally {
+      client.shutdown();
+    }
+  }
+}
diff --git a/examples/example-gcp-csm-observability/README.md b/examples/example-gcp-csm-observability/README.md
new file mode 100644
index 00000000000..cbb206fbb46
--- /dev/null
+++ b/examples/example-gcp-csm-observability/README.md
@@ -0,0 +1,43 @@
+gRPC GCP CSM Observability Example
+================
+
+The GCP CSM Observability example consists of a Hello World client and a Hello World server and shows how to configure CSM Observability
+for gRPC client and gRPC server.
+
+## Configuration
+
+`CsmObservabilityClient` takes the following command-line arguments -
+* user - Name to be greeted.
+* target - Server address. Default value is `xds:///helloworld:50051`.
+  * When client tries to connect to target, gRPC would use xDS to resolve this target and connect to the server backend.
+* prometheusPort - Port used for exposing prometheus metrics. Default value is `9464`.
+
+
+`CsmObservabilityServer` takes the following command-line arguments -
+* port - Port used for running Hello World server. Default value is `50051`.
+* prometheusPort - Port used for exposing prometheus metrics. Default value is `9464`.
+
+## Build the example
+
+From the `grpc-java/examples/`directory i.e,
+```
+cd grpc-java/examples
+```
+Run the following to generate client and server images respectively.
+
+Client:
+```
+docker build -f example-gcp-csm-observability/csm-client.Dockerfile .
+```
+Server:
+```
+docker build -f example-gcp-csm-observability/csm-server.Dockerfile .
+```
+
+To push to a registry, add a tag to the image either by adding a `-t` flag to `docker build` command above or run:
+
+```
+docker image tag ${sha from build command above} ${tag}
+```
+
+And then push the tagged image using `docker push`.
diff --git a/examples/example-gcp-csm-observability/build.gradle b/examples/example-gcp-csm-observability/build.gradle
new file mode 100644
index 00000000000..6d20464e567
--- /dev/null
+++ b/examples/example-gcp-csm-observability/build.gradle
@@ -0,0 +1,76 @@
+plugins {
+    // Provide convenience executables for trying out the examples.
+    id 'application'
+    id 'com.google.protobuf' version '0.9.5'
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+    id 'java'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
+// are looking at a tagged version of the example and not "master"!
+
+// Feel free to delete the comment at the next line. It is just for safely
+// updating the version in our release process.
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protocVersion = '3.25.8'
+def openTelemetryVersion = '1.56.0'
+def openTelemetryPrometheusVersion = '1.56.0-alpha'
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    implementation "io.grpc:grpc-gcp-csm-observability:${grpcVersion}"
+    implementation "io.grpc:grpc-xds:${grpcVersion}"
+    implementation "io.opentelemetry:opentelemetry-sdk:${openTelemetryVersion}"
+    implementation "io.opentelemetry:opentelemetry-sdk-metrics:${openTelemetryVersion}"
+    implementation "io.opentelemetry:opentelemetry-exporter-prometheus:${openTelemetryPrometheusVersion}"
+    runtimeOnly "io.grpc:grpc-xds:${grpcVersion}"
+    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
+}
+
+protobuf {
+    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
+    plugins {
+        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
+    }
+    generateProtoTasks {
+        all()*.plugins { grpc {} }
+    }
+}
+
+startScripts.enabled = false
+
+task CsmObservabilityHelloWorldServer(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.csmobservability.CsmObservabilityServer'
+    applicationName = 'csm-observability-server'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+task CsmObservabilityHelloWorldClient(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.csmobservability.CsmObservabilityClient'
+    applicationName = 'csm-observability-client'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into('bin') {
+        from(CsmObservabilityHelloWorldServer)
+        from(CsmObservabilityHelloWorldClient)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
diff --git a/examples/example-gcp-csm-observability/csm-client.Dockerfile b/examples/example-gcp-csm-observability/csm-client.Dockerfile
new file mode 100644
index 00000000000..31a3262e863
--- /dev/null
+++ b/examples/example-gcp-csm-observability/csm-client.Dockerfile
@@ -0,0 +1,47 @@
+# Copyright 2024 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.
+
+#
+# Stage 1: Build CSM client
+#
+
+FROM eclipse-temurin:11-jdk AS build
+
+WORKDIR /grpc-java/examples
+COPY . .
+
+RUN cd example-gcp-csm-observability && ../gradlew installDist -PskipCodegen=true -PskipAndroid=true
+
+#
+# Stage 2:
+#
+# - Copy only the necessary files to reduce Docker image size.
+# - Have an ENTRYPOINT script which will launch the CSM client
+#   with the given parameters.
+#
+
+FROM eclipse-temurin:11-jre
+
+WORKDIR /grpc-java/
+COPY --from=build /grpc-java/examples/example-gcp-csm-observability/build/install/example-gcp-csm-observability/. .
+
+# Intentionally after the COPY to force the update on each build.
+# Update Ubuntu system packages:
+RUN apt-get update \
+    && apt-get -y upgrade \
+    && apt-get -y autoremove \
+    && rm -rf /var/lib/apt/lists/*
+
+# Client
+ENTRYPOINT ["bin/csm-observability-client"]
diff --git a/examples/example-gcp-csm-observability/csm-server.Dockerfile b/examples/example-gcp-csm-observability/csm-server.Dockerfile
new file mode 100644
index 00000000000..675b450143f
--- /dev/null
+++ b/examples/example-gcp-csm-observability/csm-server.Dockerfile
@@ -0,0 +1,47 @@
+# Copyright 2024 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.
+
+#
+# Stage 1: Build CSM server
+#
+
+FROM eclipse-temurin:11-jdk AS build
+
+WORKDIR /grpc-java/examples
+COPY . .
+
+RUN cd example-gcp-csm-observability && ../gradlew installDist -PskipCodegen=true -PskipAndroid=true
+
+#
+# Stage 2:
+#
+# - Copy only the necessary files to reduce Docker image size.
+# - Have an ENTRYPOINT script which will launch the CSM server
+#   with the given parameters.
+#
+
+FROM eclipse-temurin:11-jre
+
+WORKDIR /grpc-java/
+COPY --from=build /grpc-java/examples/example-gcp-csm-observability/build/install/example-gcp-csm-observability/. .
+
+# Intentionally after the COPY to force the update on each build.
+# Update Ubuntu system packages:
+RUN apt-get update \
+    && apt-get -y upgrade \
+    && apt-get -y autoremove \
+    && rm -rf /var/lib/apt/lists/*
+
+# Server
+ENTRYPOINT ["bin/csm-observability-server"]
diff --git a/examples/example-gcp-csm-observability/settings.gradle b/examples/example-gcp-csm-observability/settings.gradle
new file mode 100644
index 00000000000..44e6f340ede
--- /dev/null
+++ b/examples/example-gcp-csm-observability/settings.gradle
@@ -0,0 +1,17 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+}
+
+rootProject.name = 'example-gcp-csm-observability'
diff --git a/examples/example-gcp-csm-observability/src/main/java/io/grpc/examples/csmobservability/CsmObservabilityClient.java b/examples/example-gcp-csm-observability/src/main/java/io/grpc/examples/csmobservability/CsmObservabilityClient.java
new file mode 100644
index 00000000000..dd0ab7eb546
--- /dev/null
+++ b/examples/example-gcp-csm-observability/src/main/java/io/grpc/examples/csmobservability/CsmObservabilityClient.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2024 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.examples.csmobservability;
+
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.gcp.csm.observability.CsmObservability;
+import io.grpc.xds.XdsChannelCredentials;
+import io.opentelemetry.exporter.prometheus.PrometheusHttpServer;
+import io.opentelemetry.sdk.OpenTelemetrySdk;
+import io.opentelemetry.sdk.metrics.SdkMeterProvider;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A simple CSM observability client that requests a greeting from the {@link HelloWorldServer} and
+ * generates CSM telemetry data based on the configuration.
+ */
+public class CsmObservabilityClient {
+  private static final Logger logger = Logger.getLogger(CsmObservabilityClient.class.getName());
+
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+  /** Construct client for accessing HelloWorld server using the existing channel. */
+  public CsmObservabilityClient(Channel channel) {
+    blockingStub = GreeterGrpc.newBlockingStub(channel);
+  }
+
+  /** Say hello to server. */
+  public void greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response;
+    try {
+      response = blockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    logger.info("Greeting: " + response.getMessage());
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the
+   * greeting. The second argument is the target server.
+   */
+  public static void main(String[] args) throws Exception {
+    String user = "world";
+    // Use xDS to establish contact with the server "helloworld:50051".
+    String target = "xds:///helloworld:50051";
+    // The port on which prometheus metrics will be exposed.
+    int prometheusPort = 9464;
+    AtomicBoolean sendRpcs = new AtomicBoolean(true);
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [name [target [prometheusPort]]]");
+        System.err.println("");
+        System.err.println("  name    The name you wish to be greeted by. Defaults to " + user);
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.err.println("  prometheusPort  The port to expose prometheus metrics. Defaults to " + prometheusPort);
+        System.exit(1);
+      }
+      user = args[0];
+    }
+    if (args.length > 1) {
+      target = args[1];
+    }
+    if (args.length > 2) {
+      prometheusPort = Integer.parseInt(args[2]);
+    }
+
+    Thread mainThread = Thread.currentThread();
+
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC client since JVM is shutting down");
+
+        sendRpcs.set(false);
+        try {
+          mainThread.join();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** client shut down");
+      }
+    });
+
+    // Adds a PrometheusHttpServer to convert OpenTelemetry metrics to Prometheus format and
+    // expose these via a HttpServer exporter to the SdkMeterProvider.
+    SdkMeterProvider sdkMeterProvider = SdkMeterProvider.builder()
+        .registerMetricReader(
+            PrometheusHttpServer.builder().setPort(prometheusPort).build())
+        .build();
+
+    // Initialize OpenTelemetry SDK with MeterProvider configured with Prometeheus.
+    OpenTelemetrySdk openTelemetrySdk =
+        OpenTelemetrySdk.builder().setMeterProvider(sdkMeterProvider).build();
+
+    // Initialize CSM Observability.
+    CsmObservability observability = CsmObservability.newBuilder()
+        .sdk(openTelemetrySdk)
+        .build();
+    // Registers CSM observabiity globally.
+    observability.registerGlobal();
+
+    // Create a communication channel to the server, known as a Channel.
+    ManagedChannel channel =
+        Grpc.newChannelBuilder(
+                target, XdsChannelCredentials.create(InsecureChannelCredentials.create()))
+            .build();
+    CsmObservabilityClient client = new CsmObservabilityClient(channel);
+
+    try {
+      // Run RPCs every second.
+      while (sendRpcs.get()) {
+        client.greet(user);
+        // Sleep for a bit before sending the next RPC.
+        Thread.sleep(1000);
+      }
+    } finally {
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+      // Shut down CSM Observability.
+      observability.close();
+      // Shut down OpenTelemetry SDK.
+      openTelemetrySdk.close();
+    }
+  }
+}
diff --git a/examples/example-gcp-csm-observability/src/main/java/io/grpc/examples/csmobservability/CsmObservabilityServer.java b/examples/example-gcp-csm-observability/src/main/java/io/grpc/examples/csmobservability/CsmObservabilityServer.java
new file mode 100644
index 00000000000..589753b1a4c
--- /dev/null
+++ b/examples/example-gcp-csm-observability/src/main/java/io/grpc/examples/csmobservability/CsmObservabilityServer.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2024 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.examples.csmobservability;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.gcp.csm.observability.CsmObservability;
+import io.grpc.stub.StreamObserver;
+import io.grpc.xds.XdsServerBuilder;
+import io.grpc.xds.XdsServerCredentials;
+import io.opentelemetry.exporter.prometheus.PrometheusHttpServer;
+import io.opentelemetry.sdk.OpenTelemetrySdk;
+import io.opentelemetry.sdk.metrics.SdkMeterProvider;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * CSM Observability server that manages startup/shutdown of a {@code Greeter} server and generates
+ * CSM telemetry based on the configuration.
+ */
+public class CsmObservabilityServer {
+  private static final Logger logger = Logger.getLogger(CsmObservabilityServer.class.getName());
+
+  private Server server;
+  private void start(int port) throws IOException {
+    server =
+        XdsServerBuilder.forPort(
+                port, XdsServerCredentials.create(InsecureServerCredentials.create()))
+            .addService(new GreeterImpl())
+            .build()
+            .start();
+    logger.info("Server started, listening on " + port);
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    // The port on which the server should run.
+    int port = 50051;
+    // The port on which prometheus metrics will be exposed.
+    int prometheusPort = 9464;
+
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [port [prometheus_port]]");
+        System.err.println("");
+        System.err.println("  port  The port on which server will run. Defaults to " + port);
+        System.err.println("  prometheusPort  The port to expose prometheus metrics. Defaults to " + prometheusPort);
+        System.exit(1);
+      }
+      port = Integer.parseInt(args[0]);
+    }
+    if (args.length > 1) {
+      prometheusPort = Integer.parseInt(args[1]);
+    }
+
+    // Adds a PrometheusHttpServer to convert OpenTelemetry metrics to Prometheus format and
+    // expose these via a HttpServer exporter to the SdkMeterProvider.
+    SdkMeterProvider sdkMeterProvider = SdkMeterProvider.builder()
+        .registerMetricReader(
+            PrometheusHttpServer.builder().setPort(prometheusPort).build())
+        .build();
+
+    // Initialize OpenTelemetry SDK with MeterProvider configured with Prometheus metrics exporter
+    OpenTelemetrySdk openTelemetrySdk =
+        OpenTelemetrySdk.builder().setMeterProvider(sdkMeterProvider).build();
+
+    // Initialize CSM Observability
+    CsmObservability observability = CsmObservability.newBuilder()
+        .sdk(openTelemetrySdk)
+        .build();
+    // Registers CSM observabiity globally
+    observability.registerGlobal();
+
+    final CsmObservabilityServer server = new CsmObservabilityServer();
+    server.start(port);
+
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          server.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        // Shut down CSM observability.
+        observability.close();
+        // Shut down OpenTelemetry SDK.
+        openTelemetrySdk.close();
+
+        System.err.println("*** server shut down");
+      }
+    });
+
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/examples/example-gcp-csm-observability/src/main/proto/helloworld/helloworld.proto b/examples/example-gcp-csm-observability/src/main/proto/helloworld/helloworld.proto
new file mode 100644
index 00000000000..64a8c09ee16
--- /dev/null
+++ b/examples/example-gcp-csm-observability/src/main/proto/helloworld/helloworld.proto
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2023 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.
+ */
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/example-gcp-observability/README.md b/examples/example-gcp-observability/README.md
new file mode 100644
index 00000000000..95270fa8140
--- /dev/null
+++ b/examples/example-gcp-observability/README.md
@@ -0,0 +1,39 @@
+gRPC GCP Observability Example
+================
+
+The GCP Observability example consists of a Hello World client and a Hello World server instrumented for logs, metrics and tracing. 
+
+__Please refer to Microservices Observability user guide for setup.__
+
+### Build the example
+
+Build the Observability client & server. From the `grpc-java/examples/example-gcp-observability`
+directory:
+```
+$ ../gradlew installDist
+```
+
+This creates the scripts `build/install/example-gcp-observability/bin/gcp-observability-client` and
+`build/install/example-gcp-observability/bin/gcp-observability-server`.
+
+### Run the example with configuration
+
+To use Observability, you should first setup and configure authorization as mentioned in the user guide. 
+
+You need to set the `GRPC_GCP_OBSERVABILITY_CONFIG_FILE` environment variable to point to the gRPC GCP Observability configuration file (preferred) or if that
+is not set then `GRPC_GCP_OBSERVABILITY_CONFIG` environment variable to gRPC GCP Observability configuration value. This is needed by both
+`build/install/example-gcp-observability/bin/gcp-observability-client` and
+`build/install/example-gcp-observability/bin/gcp-observability-server`.
+
+1. To start the observability-enabled example server on its default port of 50051, run:
+```
+$ export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=src/main/resources/io/grpc/examples/gcpobservability/gcp_observability_server_config.json
+$ ./build/install/example-gcp-observability/bin/gcp-observability-server
+```
+
+2. In a different terminal window, run the observability-enabled example client:
+```
+$ export GRPC_GCP_OBSERVABILITY_CONFIG_FILE=src/main/resources/io/grpc/examples/gcpobservability/gcp_observability_client_config.json
+$ ./build/install/example-gcp-observability/bin/gcp-observability-client
+```
+
diff --git a/examples/example-gcp-observability/build.gradle b/examples/example-gcp-observability/build.gradle
new file mode 100644
index 00000000000..c64eed714c9
--- /dev/null
+++ b/examples/example-gcp-observability/build.gradle
@@ -0,0 +1,69 @@
+plugins {
+    // Provide convenience executables for trying out the examples.
+    id 'application'
+    id 'com.google.protobuf' version '0.9.5'
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+    id 'java'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
+// are looking at a tagged version of the example and not "master"!
+
+// Feel free to delete the comment at the next line. It is just for safely
+// updating the version in our release process.
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protocVersion = '3.25.8'
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    implementation "io.grpc:grpc-gcp-observability:${grpcVersion}"
+    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
+}
+
+protobuf {
+    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
+    plugins {
+        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
+    }
+    generateProtoTasks {
+        all()*.plugins { grpc {} }
+    }
+}
+
+startScripts.enabled = false
+
+task ObservabilityHelloWorldServer(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.gcpobservability.GcpObservabilityServer'
+    applicationName = 'gcp-observability-server'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+task ObservabilityHelloWorldClient(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.gcpobservability.GcpObservabilityClient'
+    applicationName = 'gcp-observability-client'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into('bin') {
+        from(ObservabilityHelloWorldServer)
+        from(ObservabilityHelloWorldClient)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
diff --git a/examples/example-gcp-observability/settings.gradle b/examples/example-gcp-observability/settings.gradle
new file mode 100644
index 00000000000..39efc20a459
--- /dev/null
+++ b/examples/example-gcp-observability/settings.gradle
@@ -0,0 +1,17 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+}
+
+rootProject.name = 'example-gcp-observability'
diff --git a/examples/example-gcp-observability/src/main/java/io/grpc/examples/gcpobservability/GcpObservabilityClient.java b/examples/example-gcp-observability/src/main/java/io/grpc/examples/gcpobservability/GcpObservabilityClient.java
new file mode 100644
index 00000000000..34112adb108
--- /dev/null
+++ b/examples/example-gcp-observability/src/main/java/io/grpc/examples/gcpobservability/GcpObservabilityClient.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2023 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.examples.gcpobservability;
+
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.gcp.observability.GcpObservability;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A simple observability client that requests a greeting from the {@link HelloWorldServer} and
+ * generates logs, metrics and traces based on the configuration.
+ */
+public class GcpObservabilityClient {
+  private static final Logger logger = Logger.getLogger(GcpObservabilityClient.class.getName());
+
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+  /** Construct client for accessing HelloWorld server using the existing channel. */
+  public GcpObservabilityClient(Channel channel) {
+    blockingStub = GreeterGrpc.newBlockingStub(channel);
+  }
+
+  /** Say hello to server. */
+  public void greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response;
+    try {
+      response = blockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    logger.info("Greeting: " + response.getMessage());
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the
+   * greeting. The second argument is the target server.
+   */
+  public static void main(String[] args) throws Exception {
+    String user = "world";
+    String target = "localhost:50051";
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [name [target]]");
+        System.err.println("");
+        System.err.println("  name    The name you wish to be greeted by. Defaults to " + user);
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.exit(1);
+      }
+      user = args[0];
+    }
+    if (args.length > 1) {
+      target = args[1];
+    }
+
+    // Initialize observability
+    try (GcpObservability observability = GcpObservability.grpcInit()) {
+      ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+          .build();
+      try {
+        GcpObservabilityClient client = new GcpObservabilityClient(channel);
+        client.greet(user);
+      } finally {
+        channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+      }
+    } // observability.close() called implicitly
+  }
+}
diff --git a/examples/example-gcp-observability/src/main/java/io/grpc/examples/gcpobservability/GcpObservabilityServer.java b/examples/example-gcp-observability/src/main/java/io/grpc/examples/gcpobservability/GcpObservabilityServer.java
new file mode 100644
index 00000000000..c599e7047c5
--- /dev/null
+++ b/examples/example-gcp-observability/src/main/java/io/grpc/examples/gcpobservability/GcpObservabilityServer.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2023 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.examples.gcpobservability;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.gcp.observability.GcpObservability;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * Observability server that manages startup/shutdown of a {@code Greeter} server and generates
+ * logs, metrics and traces based on the configuration.
+ */
+public class GcpObservabilityServer {
+  private static final Logger logger = Logger.getLogger(GcpObservabilityServer.class.getName());
+
+  private Server server;
+
+  private void start() throws IOException {
+    int port = 50051;
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new GreeterImpl())
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    // Initialize observability
+    GcpObservability observability = GcpObservability.grpcInit();
+    final GcpObservabilityServer server = new GcpObservabilityServer();
+    server.start();
+
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          server.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        // Shut down observability
+        observability.close();
+        System.err.println("*** server shut down");
+      }
+    });
+
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/examples/example-gcp-observability/src/main/proto/helloworld/helloworld.proto b/examples/example-gcp-observability/src/main/proto/helloworld/helloworld.proto
new file mode 100644
index 00000000000..64a8c09ee16
--- /dev/null
+++ b/examples/example-gcp-observability/src/main/proto/helloworld/helloworld.proto
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2023 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.
+ */
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/example-gcp-observability/src/main/resources/io/grpc/examples/gcpobservability/gcp_observability_client_config.json b/examples/example-gcp-observability/src/main/resources/io/grpc/examples/gcpobservability/gcp_observability_client_config.json
new file mode 100644
index 00000000000..9c69d55e7f7
--- /dev/null
+++ b/examples/example-gcp-observability/src/main/resources/io/grpc/examples/gcpobservability/gcp_observability_client_config.json
@@ -0,0 +1,17 @@
+{
+  "cloud_monitoring": {},
+  "cloud_trace": {
+    "sampling_rate": 1.0
+  },
+  "cloud_logging": {
+    "client_rpc_events": [{
+      "methods": ["helloworld.Greeter/*"]
+    }],
+    "server_rpc_events": [{
+      "methods": ["helloworld.Greeter/*"]
+    }]
+  },
+  "labels": {
+    "environment" : "example-client"
+  }
+}
diff --git a/examples/example-gcp-observability/src/main/resources/io/grpc/examples/gcpobservability/gcp_observability_server_config.json b/examples/example-gcp-observability/src/main/resources/io/grpc/examples/gcpobservability/gcp_observability_server_config.json
new file mode 100644
index 00000000000..78698c05faf
--- /dev/null
+++ b/examples/example-gcp-observability/src/main/resources/io/grpc/examples/gcpobservability/gcp_observability_server_config.json
@@ -0,0 +1,17 @@
+{
+  "cloud_monitoring": {},
+  "cloud_trace": {
+    "sampling_rate": 1.0
+  },
+  "cloud_logging": {
+    "client_rpc_events": [{
+      "methods": ["helloworld.Greeter/*"]
+    }],
+    "server_rpc_events": [{
+      "methods": ["helloworld.Greeter/*"]
+    }]
+  },
+  "labels": {
+    "environment" : "example-server"
+  }
+}
diff --git a/examples/example-hostname/BUILD.bazel b/examples/example-hostname/BUILD.bazel
new file mode 100644
index 00000000000..d5bd3aba94c
--- /dev/null
+++ b/examples/example-hostname/BUILD.bazel
@@ -0,0 +1,53 @@
+load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library")
+load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library")
+load("@io_grpc_grpc_java//:java_grpc_library.bzl", "java_grpc_library")
+load("@rules_java//java:java_binary.bzl", "java_binary")
+load("@rules_java//java:java_library.bzl", "java_library")
+
+proto_library(
+    name = "helloworld_proto",
+    srcs = ["src/main/proto/helloworld/helloworld.proto"],
+)
+
+java_proto_library(
+    name = "helloworld_java_proto",
+    deps = [":helloworld_proto"],
+)
+
+java_grpc_library(
+    name = "helloworld_java_grpc",
+    srcs = [":helloworld_proto"],
+    deps = [":helloworld_java_proto"],
+)
+
+java_library(
+    name = "hostname_greeter",
+    testonly = 1,
+    srcs = [
+        "src/main/java/io/grpc/examples/hostname/HostnameGreeter.java",
+    ],
+    deps = [
+        ":helloworld_java_grpc",
+        ":helloworld_java_proto",
+        "@io_grpc_grpc_java//stub",
+    ],
+)
+
+java_binary(
+    name = "hostname-server",
+    testonly = 1,
+    srcs = [
+        "src/main/java/io/grpc/examples/hostname/HostnameServer.java",
+    ],
+    main_class = "io.grpc.examples.hostname.HostnameServer",
+    runtime_deps = [
+        "@io_grpc_grpc_java//netty",
+    ],
+    deps = [
+        ":hostname_greeter",
+        "@io_grpc_grpc_java//api",
+        "@io_grpc_grpc_java//services:health",
+        "@io_grpc_grpc_java//services:reflection",
+        "@io_grpc_grpc_proto//:health_java_proto",
+    ],
+)
diff --git a/examples/example-hostname/README.md b/examples/example-hostname/README.md
new file mode 100644
index 00000000000..8794937d280
--- /dev/null
+++ b/examples/example-hostname/README.md
@@ -0,0 +1,60 @@
+gRPC Hostname Example
+=====================
+
+The hostname example is a Hello World server whose response includes its
+hostname. It also supports health and reflection services. This makes it a good
+server to test infrastructure, like load balancing.
+
+The example requires grpc-java to already be built. You are strongly encouraged
+to check out a git release tag, since there will already be a build of grpc
+available. Otherwise you must follow [COMPILING](../../COMPILING.md).
+
+### Build the example
+
+1. Build the hello-world example client. See [the examples README](../README.md)
+
+2. Build this server. From the `grpc-java/examples/examples-hostname` directory:
+```
+$ ../gradlew installDist
+```
+
+This creates the script `build/install/hostname-server/bin/hostname-server` that
+runs the example.
+
+To run the hostname example, run:
+
+```
+$ ./build/install/hostname-server/bin/hostname-server
+```
+
+And in a different terminal window run the hello-world client:
+
+```
+$ ../build/install/examples/bin/hello-world-client
+```
+
+### Maven
+
+If you prefer to use Maven:
+1. Build the hello-world example client. See [the examples README](../README.md)
+
+2. Run in this directory:
+```
+$ mvn verify
+$ # Run the server (from the examples-hostname directory)
+$ mvn exec:java -Dexec.mainClass=io.grpc.examples.hostname.HostnameServer
+$ # In another terminal run the client (from the examples directory)
+$ cd ..
+$ mvn exec:java -Dexec.mainClass=io.grpc.examples.helloworld.HelloWorldClient
+```
+
+### Bazel
+
+If you prefer to use Bazel, run from the `grpc-java/examples` directory:
+```
+$ bazel build :hello-world-client example-hostname:hostname-server
+$ # Run the server
+$ ./bazel-bin/example-hostname/hostname-server
+$ # In another terminal run the client
+$ ./bazel-bin/hello-world-client
+```
diff --git a/examples/example-hostname/build.gradle b/examples/example-hostname/build.gradle
new file mode 100644
index 00000000000..0facab784d3
--- /dev/null
+++ b/examples/example-hostname/build.gradle
@@ -0,0 +1,66 @@
+plugins {
+    id 'application' // Provide convenience executables for trying out the examples.
+    id 'java'
+
+    id "com.google.protobuf" version "0.9.5"
+    id 'com.google.cloud.tools.jib' version '3.4.4' // For releasing to Docker Hub
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
+// are looking at a tagged version of the example and not "master"!
+
+// Feel free to delete the comment at the next line. It is just for safely
+// updating the version in our release process.
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protobufVersion = '3.25.8'
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    implementation "io.grpc:grpc-services:${grpcVersion}"
+    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
+
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation "io.grpc:grpc-testing:${grpcVersion}"
+    testImplementation "io.grpc:grpc-inprocess:${grpcVersion}"
+}
+
+protobuf {
+  protoc {
+    artifact = "com.google.protobuf:protoc:${protobufVersion}"
+  }
+  plugins {
+    grpc {
+      artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}"
+    }
+  }
+  generateProtoTasks {
+    all()*.plugins {
+      grpc {}
+    }
+  }
+}
+
+applicationName = 'hostname-server'
+mainClassName = 'io.grpc.examples.hostname.HostnameServer'
+
+// For releasing to Docker Hub
+jib {
+  from.image = "gcr.io/distroless/java17-debian12"
+  container.ports = ['50051']
+  outputPaths {
+    tar = 'build/example-hostname.tar'
+    digest = 'build/example-hostname.digest'
+    imageId = 'build/example-hostname.id'
+  }
+}
diff --git a/examples/example-hostname/pom.xml b/examples/example-hostname/pom.xml
new file mode 100644
index 00000000000..c21e85d1333
--- /dev/null
+++ b/examples/example-hostname/pom.xml
@@ -0,0 +1,112 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>io.grpc</groupId>
+  <artifactId>example-hostname</artifactId>
+  <packaging>jar</packaging>
+  <!-- Feel free to delete the comment at the end of these lines. It is just
+       for safely updating the version in our release process. -->
+  <version>1.80.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
+  <name>example-hostname</name>
+  <url>https://github.com/grpc/grpc-java</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <grpc.version>1.80.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
+    <protoc.version>3.25.8</protoc.version>
+    <!-- required for jdk9 -->
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+  </properties>
+
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>io.grpc</groupId>
+        <artifactId>grpc-bom</artifactId>
+        <version>${grpc.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+
+  <dependencies>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-services</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-protobuf</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-stub</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-netty-shaded</artifactId>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.13.2</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-testing</artifactId>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <extensions>
+      <extension>
+        <groupId>kr.motd.maven</groupId>
+        <artifactId>os-maven-plugin</artifactId>
+        <version>1.7.1</version>
+      </extension>
+    </extensions>
+    <plugins>
+      <plugin>
+        <groupId>org.xolstice.maven.plugins</groupId>
+        <artifactId>protobuf-maven-plugin</artifactId>
+        <version>0.6.1</version>
+        <configuration>
+          <protocArtifact>com.google.protobuf:protoc:${protoc.version}:exe:${os.detected.classifier}</protocArtifact>
+          <pluginId>grpc-java</pluginId>
+          <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
+        </configuration>
+        <executions>
+          <execution>
+            <goals>
+              <goal>compile</goal>
+              <goal>compile-custom</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-enforcer-plugin</artifactId>
+        <version>3.5.0</version>
+        <executions>
+          <execution>
+            <id>enforce</id>
+            <goals>
+              <goal>enforce</goal>
+            </goals>
+            <configuration>
+              <rules>
+                <requireUpperBoundDeps/>
+              </rules>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>
diff --git a/examples/example-hostname/settings.gradle b/examples/example-hostname/settings.gradle
new file mode 100644
index 00000000000..5bd641b3fc1
--- /dev/null
+++ b/examples/example-hostname/settings.gradle
@@ -0,0 +1,17 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+}
+
+rootProject.name = 'hostname'
diff --git a/examples/example-hostname/src/main/java/io/grpc/examples/hostname/HostnameGreeter.java b/examples/example-hostname/src/main/java/io/grpc/examples/hostname/HostnameGreeter.java
new file mode 100644
index 00000000000..b15ade5684d
--- /dev/null
+++ b/examples/example-hostname/src/main/java/io/grpc/examples/hostname/HostnameGreeter.java
@@ -0,0 +1,60 @@
+/*
+ * 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.examples.hostname;
+
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.util.Random;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/** Greeter implementation which replies identifying itself with its hostname. */
+public final class HostnameGreeter extends GreeterGrpc.GreeterImplBase {
+  private static final Logger logger = Logger.getLogger(HostnameGreeter.class.getName());
+
+  private final String serverName;
+
+  public HostnameGreeter(String serverName) {
+    if (serverName == null) {
+      serverName = determineHostname();
+    }
+    this.serverName = serverName;
+  }
+
+  @Override
+  public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+    HelloReply reply = HelloReply.newBuilder()
+        .setMessage("Hello " + req.getName() + ", from " + serverName)
+        .build();
+    responseObserver.onNext(reply);
+    responseObserver.onCompleted();
+  }
+
+  private static String determineHostname() {
+    try {
+      return InetAddress.getLocalHost().getHostName();
+    } catch (IOException ex) {
+      logger.log(Level.INFO, "Failed to determine hostname. Will generate one", ex);
+    }
+    // Strange. Well, let's make an identifier for ourselves.
+    return "generated-" + new Random().nextInt();
+  }
+}
diff --git a/examples/example-hostname/src/main/java/io/grpc/examples/hostname/HostnameServer.java b/examples/example-hostname/src/main/java/io/grpc/examples/hostname/HostnameServer.java
new file mode 100644
index 00000000000..7baa2d4733d
--- /dev/null
+++ b/examples/example-hostname/src/main/java/io/grpc/examples/hostname/HostnameServer.java
@@ -0,0 +1,87 @@
+/*
+ * 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.examples.hostname;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
+import io.grpc.protobuf.services.ProtoReflectionServiceV1;
+import io.grpc.services.HealthStatusManager;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A server that hosts HostnameGreeter, plus infrastructure services like health and reflection.
+ *
+ * <p>This server is intended to be a general purpose "dummy" server.
+ */
+public final class HostnameServer {
+  public static void main(String[] args) throws IOException, InterruptedException {
+    int port = 50051;
+    String hostname = null;
+    if (args.length >= 1) {
+      try {
+        port = Integer.parseInt(args[0]);
+      } catch (NumberFormatException ex) {
+        System.err.println("Usage: [port [hostname]]");
+        System.err.println("");
+        System.err.println("  port      The listen port. Defaults to " + port);
+        System.err.println("  hostname  The name clients will see in greet responses. ");
+        System.err.println("            Defaults to the machine's hostname");
+        System.exit(1);
+      }
+    }
+    if (args.length >= 2) {
+      hostname = args[1];
+    }
+    HealthStatusManager health = new HealthStatusManager();
+    final Server server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new HostnameGreeter(hostname))
+        .addService(ProtoReflectionServiceV1.newInstance())
+        .addService(health.getHealthService())
+        .build()
+        .start();
+    System.out.println("Listening on port " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Start graceful shutdown
+        server.shutdown();
+        try {
+          // Wait up to 30 seconds for RPCs to complete processing.
+          server.awaitTermination(30, TimeUnit.SECONDS);
+        } catch (InterruptedException ex) {
+          Thread.currentThread().interrupt();
+        }
+        // Cancel any remaining RPCs. If awaitTermination() returned true above, then there are no
+        // RPCs and the server is already terminated. But it is safe to call even when terminated.
+        server.shutdownNow();
+        // shutdownNow isn't instantaneous, so you want an additional awaitTermination() to give
+        // time to clean resources up gracefully. Normally it will return in well under a second. In
+        // this example, the server.awaitTermination() in main() provides that delay.
+      }
+    });
+    // This would normally be tied to the service's dependencies. For example, if HostnameGreeter
+    // used a Channel to contact a required service, then when 'channel.getState() ==
+    // TRANSIENT_FAILURE' we'd want to set NOT_SERVING. But HostnameGreeter has no dependencies, so
+    // hard-coding SERVING is appropriate.
+    health.setStatus("", ServingStatus.SERVING);
+    server.awaitTermination();
+  }
+}
diff --git a/examples/example-hostname/src/main/proto/helloworld/helloworld.proto b/examples/example-hostname/src/main/proto/helloworld/helloworld.proto
new file mode 100644
index 00000000000..c60d9416f1f
--- /dev/null
+++ b/examples/example-hostname/src/main/proto/helloworld/helloworld.proto
@@ -0,0 +1,37 @@
+// Copyright 2015 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/example-hostname/src/test/java/io/grpc/examples/hostname/HostnameGreeterTest.java b/examples/example-hostname/src/test/java/io/grpc/examples/hostname/HostnameGreeterTest.java
new file mode 100644
index 00000000000..4165064b4b1
--- /dev/null
+++ b/examples/example-hostname/src/test/java/io/grpc/examples/hostname/HostnameGreeterTest.java
@@ -0,0 +1,70 @@
+/*
+ * 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.examples.hostname;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.hostname.HostnameGreeter;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.testing.GrpcCleanupRule;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link HostnameGreeter}.
+ *
+ * <p>This is very similar to HelloWorldServerTest, so see it for more descriptions.
+ */
+@RunWith(JUnit4.class)
+public class HostnameGreeterTest {
+  @Rule
+  public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+  private GreeterGrpc.GreeterBlockingStub blockingStub =
+        GreeterGrpc.newBlockingStub(grpcCleanup.register(
+            InProcessChannelBuilder.forName("hostname").directExecutor().build()));
+
+  @Test
+  public void sayHello_fixedHostname() throws Exception {
+    grpcCleanup.register(
+        InProcessServerBuilder.forName("hostname")
+          .directExecutor().addService(new HostnameGreeter("me")).build().start());
+
+    HelloReply reply =
+        blockingStub.sayHello(HelloRequest.newBuilder().setName("you").build());
+    assertEquals("Hello you, from me", reply.getMessage());
+  }
+
+  @Test
+  public void sayHello_dynamicHostname() throws Exception {
+    grpcCleanup.register(
+        InProcessServerBuilder.forName("hostname")
+          .directExecutor().addService(new HostnameGreeter(null)).build().start());
+
+    // Just verifying the service doesn't crash
+    HelloReply reply =
+        blockingStub.sayHello(HelloRequest.newBuilder().setName("anonymous").build());
+    assertTrue(reply.getMessage(), reply.getMessage().startsWith("Hello anonymous, from "));
+  }
+}
diff --git a/examples/example-jwt-auth/README.md b/examples/example-jwt-auth/README.md
new file mode 100644
index 00000000000..ba497139983
--- /dev/null
+++ b/examples/example-jwt-auth/README.md
@@ -0,0 +1,70 @@
+Authentication Example
+==============================================
+
+This example illustrates a simple JWT-based authentication implementation in gRPC using
+ server interceptor. It uses the JJWT library to create and verify JSON Web Tokens (JWTs).
+
+The example requires grpc-java to be pre-built. Using a release tag will download the relevant binaries
+from a maven repository. But if you need the latest SNAPSHOT binaries you will need to follow
+[COMPILING](../../COMPILING.md) to build these.
+
+The source code is [here](src/main/java/io/grpc/examples/jwtauth). 
+To build the example, run in this directory:
+```
+$ ../gradlew installDist
+```
+The build creates scripts `auth-server` and `auth-client` in the `build/install/example-jwt-auth/bin/` directory 
+which can be used to run this example. The example requires the server to be running before starting the
+client.
+
+Running auth-server is similar to the normal hello world example and there are no arguments to supply:
+
+**auth-server**:
+
+The auth-server accepts optional argument for port on which the server should run:
+
+```text
+USAGE: auth-server [port]
+```
+
+The auth-client accepts optional arguments for server-host, server-port, user-name and client-id:
+
+**auth-client**:
+
+```text
+USAGE: auth-client [server-host [server-port [user-name [client-id]]]]
+```
+
+The `user-name` value is simply passed in the `HelloRequest` message as payload and the value of
+`client-id` is included in the JWT claims passed in the metadata header.
+
+
+#### How to run the example:
+
+```bash
+# Run the server:
+./build/install/example-jwt-auth/bin/auth-server 50051
+# In another terminal run the client
+./build/install/example-jwt-auth/bin/auth-client localhost 50051 userA clientB
+```
+
+That's it! The client will show the user-name reflected back in the message from the server as follows:
+```
+INFO: Greeting: Hello, userA
+```
+
+And on the server side you will see the message with the client's identifier:
+```
+Processing request from clientB
+```
+
+## Maven
+
+If you prefer to use Maven follow these [steps](../README.md#maven). You can run the example as follows:
+
+```
+$ # Run the server
+$ mvn exec:java -Dexec.mainClass=io.grpc.examples.authentication.AuthServer -Dexec.args="50051"
+$ # In another terminal run the client
+$ mvn exec:java -Dexec.mainClass=io.grpc.examples.authentication.AuthClient -Dexec.args="localhost 50051 userA clientB"
+```
diff --git a/examples/example-jwt-auth/build.gradle b/examples/example-jwt-auth/build.gradle
new file mode 100644
index 00000000000..224d822f2e3
--- /dev/null
+++ b/examples/example-jwt-auth/build.gradle
@@ -0,0 +1,76 @@
+plugins {
+    // Provide convenience executables for trying out the examples.
+    id 'application'
+    id 'com.google.protobuf' version '0.9.5'
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
+// are looking at a tagged version of the example and not "master"!
+
+// Feel free to delete the comment at the next line. It is just for safely
+// updating the version in our release process.
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protobufVersion = '3.25.8'
+def protocVersion = protobufVersion
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    implementation "io.jsonwebtoken:jjwt:0.9.1"
+    implementation "javax.xml.bind:jaxb-api:2.3.1"
+
+    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
+
+    testImplementation "io.grpc:grpc-testing:${grpcVersion}"
+    testImplementation "io.grpc:grpc-inprocess:${grpcVersion}"
+    testImplementation "junit:junit:4.13.2"
+    testImplementation "org.mockito:mockito-core:4.4.0"
+}
+
+protobuf {
+    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
+    plugins {
+        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
+    }
+    generateProtoTasks {
+        all()*.plugins { grpc {} }
+    }
+}
+
+startScripts.enabled = false
+
+task hellowWorldJwtAuthServer(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.jwtauth.AuthServer'
+    applicationName = 'auth-server'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+task hellowWorldJwtAuthClient(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.jwtauth.AuthClient'
+    applicationName = 'auth-client'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into('bin') {
+        from(hellowWorldJwtAuthServer)
+        from(hellowWorldJwtAuthClient)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
diff --git a/examples/example-jwt-auth/pom.xml b/examples/example-jwt-auth/pom.xml
new file mode 100644
index 00000000000..6208b1251f0
--- /dev/null
+++ b/examples/example-jwt-auth/pom.xml
@@ -0,0 +1,130 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>io.grpc</groupId>
+  <artifactId>example-jwt-auth</artifactId>
+  <packaging>jar</packaging>
+  <!-- Feel free to delete the comment at the end of these lines. It is just
+       for safely updating the version in our release process. -->
+  <version>1.80.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
+  <name>example-jwt-auth</name>
+  <url>https://github.com/grpc/grpc-java</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <grpc.version>1.80.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
+    <protobuf.version>3.25.8</protobuf.version>
+    <protoc.version>3.25.8</protoc.version>
+    <!-- required for jdk9 -->
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+  </properties>
+
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>io.grpc</groupId>
+        <artifactId>grpc-bom</artifactId>
+        <version>${grpc.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+
+  <dependencies>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-netty-shaded</artifactId>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-protobuf</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-stub</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.jsonwebtoken</groupId>
+      <artifactId>jjwt</artifactId>
+      <version>0.9.1</version>
+    </dependency>
+    <dependency>
+      <groupId>javax.xml.bind</groupId>
+      <artifactId>jaxb-api</artifactId>
+      <version>2.3.1</version>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-testing</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.13.2</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <version>4.4.0</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <extensions>
+      <extension>
+        <groupId>kr.motd.maven</groupId>
+        <artifactId>os-maven-plugin</artifactId>
+        <version>1.7.1</version>
+      </extension>
+    </extensions>
+    <plugins>
+      <plugin>
+        <groupId>org.xolstice.maven.plugins</groupId>
+        <artifactId>protobuf-maven-plugin</artifactId>
+        <version>0.6.1</version>
+        <configuration>
+          <protocArtifact>
+            com.google.protobuf:protoc:${protoc.version}:exe:${os.detected.classifier}
+          </protocArtifact>
+          <pluginId>grpc-java</pluginId>
+          <pluginArtifact>
+            io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}
+          </pluginArtifact>
+        </configuration>
+        <executions>
+          <execution>
+            <goals>
+              <goal>compile</goal>
+              <goal>compile-custom</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-enforcer-plugin</artifactId>
+        <version>3.5.0</version>
+        <executions>
+          <execution>
+            <id>enforce</id>
+            <goals>
+              <goal>enforce</goal>
+            </goals>
+            <configuration>
+              <rules>
+                <requireUpperBoundDeps/>
+              </rules>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>
diff --git a/examples/example-jwt-auth/settings.gradle b/examples/example-jwt-auth/settings.gradle
new file mode 100644
index 00000000000..6bd0f0cdc2d
--- /dev/null
+++ b/examples/example-jwt-auth/settings.gradle
@@ -0,0 +1,19 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+
+    repositories {
+        gradlePluginPortal()
+    }
+}
diff --git a/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/AuthClient.java b/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/AuthClient.java
new file mode 100644
index 00000000000..c5769625807
--- /dev/null
+++ b/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/AuthClient.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2019 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.examples.jwtauth;
+
+import io.grpc.CallCredentials;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * An authenticating client that requests a greeting from the {@link AuthServer}.
+ */
+public class AuthClient {
+
+  private static final Logger logger = Logger.getLogger(AuthClient.class.getName());
+
+  private final ManagedChannel channel;
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+  private final CallCredentials callCredentials;
+
+  /**
+   * Construct client for accessing GreeterGrpc server.
+   */
+  AuthClient(CallCredentials callCredentials, String host, int port) {
+    this(
+        callCredentials,
+        // For this example we use plaintext to avoid needing certificates, but it is
+        // recommended to use TlsChannelCredentials.
+        Grpc.newChannelBuilderForAddress(host, port, InsecureChannelCredentials.create())
+            .build());
+  }
+
+  /**
+   * Construct client for accessing GreeterGrpc server using the existing channel.
+   */
+  AuthClient(CallCredentials callCredentials, ManagedChannel channel) {
+    this.callCredentials = callCredentials;
+    this.channel = channel;
+    this.blockingStub = GreeterGrpc.newBlockingStub(channel);
+  }
+
+  public void shutdown() throws InterruptedException {
+    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
+  }
+
+  /**
+   * Say hello to server.
+   *
+   * @param name name to set in HelloRequest
+   * @return the message in the HelloReply from the server
+   */
+  public String greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+
+    // Use a stub with the given call credentials applied to invoke the RPC.
+    HelloReply response =
+        blockingStub
+            .withCallCredentials(callCredentials)
+            .sayHello(request);
+
+    logger.info("Greeting: " + response.getMessage());
+    return response.getMessage();
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the greeting
+   * and the second is the client identifier to set in JWT
+   */
+  public static void main(String[] args) throws Exception {
+
+    String host = "localhost";
+    int port = 50051;
+    String user = "world";
+    String clientId = "default-client";
+
+    if (args.length > 0) {
+      host = args[0]; // Use the arg as the server host if provided
+    }
+    if (args.length > 1) {
+      port = Integer.parseInt(args[1]); // Use the second argument as the server port if provided
+    }
+    if (args.length > 2) {
+      user = args[2]; // Use the the third argument as the name to greet if provided
+    }
+    if (args.length > 3) {
+      clientId = args[3]; // Use the fourth argument as the client identifier if provided
+    }
+
+    CallCredentials credentials = new JwtCredential(clientId);
+    AuthClient client = new AuthClient(credentials, host, port);
+
+    try {
+      client.greet(user);
+    } finally {
+      client.shutdown();
+    }
+  }
+}
diff --git a/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/AuthServer.java b/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/AuthServer.java
new file mode 100644
index 00000000000..208645e4fad
--- /dev/null
+++ b/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/AuthServer.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright 2019 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.examples.jwtauth;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.logging.Logger;
+
+/**
+ * Server that manages startup/shutdown of a {@code Greeter} server. This also uses a {@link
+ * JwtServerInterceptor} to intercept the JWT token passed
+ */
+public class AuthServer {
+
+  private static final Logger logger = Logger.getLogger(AuthServer.class.getName());
+
+  private Server server;
+  private int port;
+
+  public AuthServer(int port) {
+    this.port = port;
+  }
+
+  private void start() throws IOException {
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new GreeterImpl())
+        .intercept(new JwtServerInterceptor())  // add the JwtServerInterceptor
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        AuthServer.this.stop();
+        System.err.println("*** server shut down");
+      }
+    });
+  }
+
+  private void stop() {
+    if (server != null) {
+      server.shutdown();
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+
+    // The port on which the server should run
+    int port = 50051; // default
+    if (args.length > 0) {
+      port = Integer.parseInt(args[0]);
+    }
+
+    final AuthServer server = new AuthServer(port);
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      // get client id added to context by interceptor
+      String clientId = Constant.CLIENT_ID_CONTEXT_KEY.get();
+      logger.info("Processing request from " + clientId);
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello, " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/Constant.java b/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/Constant.java
new file mode 100644
index 00000000000..434422f069d
--- /dev/null
+++ b/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/Constant.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2019 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.examples.jwtauth;
+
+import io.grpc.Context;
+import io.grpc.Metadata;
+
+import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
+
+/**
+ * Constants definition
+ */
+final class Constant {
+    static final String JWT_SIGNING_KEY = "L8hHXsaQOUjk5rg7XPGv4eL36anlCrkMz8CJ0i/8E/0=";
+    static final String BEARER_TYPE = "Bearer";
+
+    static final Metadata.Key<String> AUTHORIZATION_METADATA_KEY = Metadata.Key.of("Authorization", ASCII_STRING_MARSHALLER);
+    static final Context.Key<String> CLIENT_ID_CONTEXT_KEY = Context.key("clientId");
+
+    private Constant() {
+        throw new AssertionError();
+    }
+}
diff --git a/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/JwtCredential.java b/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/JwtCredential.java
new file mode 100644
index 00000000000..bf6243224d2
--- /dev/null
+++ b/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/JwtCredential.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2019 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.examples.jwtauth;
+
+import io.grpc.CallCredentials;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import java.util.concurrent.Executor;
+
+/**
+ * CallCredentials implementation, which carries the JWT value that will be propagated to the
+ * server in the request metadata with the "Authorization" key and the "Bearer" prefix.
+ */
+public class JwtCredential extends CallCredentials {
+
+  private final String subject;
+
+  JwtCredential(String subject) {
+    this.subject = subject;
+  }
+
+  @Override
+  public void applyRequestMetadata(final RequestInfo requestInfo, final Executor executor,
+      final MetadataApplier metadataApplier) {
+    // Make a JWT compact serialized string.
+    // This example omits setting the expiration, but a real application should do it.
+    final String jwt =
+        Jwts.builder()
+            .setSubject(subject)
+            .signWith(SignatureAlgorithm.HS256, Constant.JWT_SIGNING_KEY)
+            .compact();
+
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          Metadata headers = new Metadata();
+          headers.put(Constant.AUTHORIZATION_METADATA_KEY,
+              String.format("%s %s", Constant.BEARER_TYPE, jwt));
+          metadataApplier.apply(headers);
+        } catch (Throwable e) {
+          metadataApplier.fail(Status.UNAUTHENTICATED.withCause(e));
+        }
+      }
+    });
+  }
+}
diff --git a/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/JwtServerInterceptor.java b/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/JwtServerInterceptor.java
new file mode 100644
index 00000000000..d24e814e3c0
--- /dev/null
+++ b/examples/example-jwt-auth/src/main/java/io/grpc/examples/jwtauth/JwtServerInterceptor.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2019 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.examples.jwtauth;
+
+import io.grpc.Context;
+import io.grpc.Contexts;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.Status;
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jws;
+import io.jsonwebtoken.JwtException;
+import io.jsonwebtoken.JwtParser;
+import io.jsonwebtoken.Jwts;
+
+/**
+ * This interceptor gets the JWT from the metadata, verifies it and sets the client identifier
+ * obtained from the token into the context. In order not to complicate the example with additional
+ * checks (expiration date, issuer and etc.), it relies only on the signature of the token for
+ * verification.
+ */
+public class JwtServerInterceptor implements ServerInterceptor {
+
+  private JwtParser parser = Jwts.parser().setSigningKey(Constant.JWT_SIGNING_KEY);
+
+  @Override
+  public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> serverCall,
+      Metadata metadata, ServerCallHandler<ReqT, RespT> serverCallHandler) {
+    String value = metadata.get(Constant.AUTHORIZATION_METADATA_KEY);
+
+    Status status = Status.OK;
+    if (value == null) {
+      status = Status.UNAUTHENTICATED.withDescription("Authorization token is missing");
+    } else if (!value.startsWith(Constant.BEARER_TYPE)) {
+      status = Status.UNAUTHENTICATED.withDescription("Unknown authorization type");
+    } else {
+      Jws<Claims> claims = null;
+      // remove authorization type prefix
+      String token = value.substring(Constant.BEARER_TYPE.length()).trim();
+      try {
+        // verify token signature and parse claims
+        claims = parser.parseClaimsJws(token);
+      } catch (JwtException e) {
+        status = Status.UNAUTHENTICATED.withDescription(e.getMessage()).withCause(e);
+      }
+      if (claims != null) {
+        // set client id into current context
+        Context ctx = Context.current()
+            .withValue(Constant.CLIENT_ID_CONTEXT_KEY, claims.getBody().getSubject());
+        return Contexts.interceptCall(ctx, serverCall, metadata, serverCallHandler);
+      }
+    }
+
+    serverCall.close(status, new Metadata());
+    return new ServerCall.Listener<ReqT>() {
+      // noop
+    };
+  }
+
+}
diff --git a/examples/example-jwt-auth/src/main/proto/helloworld.proto b/examples/example-jwt-auth/src/main/proto/helloworld.proto
new file mode 100644
index 00000000000..6340c54f7bb
--- /dev/null
+++ b/examples/example-jwt-auth/src/main/proto/helloworld.proto
@@ -0,0 +1,37 @@
+// Copyright 2019 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/example-jwt-auth/src/test/java/io/grpc/examples/jwtauth/AuthClientTest.java b/examples/example-jwt-auth/src/test/java/io/grpc/examples/jwtauth/AuthClientTest.java
new file mode 100644
index 00000000000..8428009175d
--- /dev/null
+++ b/examples/example-jwt-auth/src/test/java/io/grpc/examples/jwtauth/AuthClientTest.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2019 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.examples.jwtauth;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.CallCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptors;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.ServerCall.Listener;
+import io.grpc.ServerInterceptor;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import java.io.IOException;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+
+/**
+ * Unit tests for {@link AuthClient} testing the default and non-default tokens
+ *
+ *
+ */
+@RunWith(JUnit4.class)
+public class AuthClientTest {
+  /**
+   * This rule manages automatic graceful shutdown for the registered servers and channels at the
+   * end of test.
+   */
+  @Rule
+  public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+  private final ServerInterceptor mockServerInterceptor = mock(ServerInterceptor.class, delegatesTo(
+      new ServerInterceptor() {
+        @Override
+        public <ReqT, RespT> Listener<ReqT> interceptCall(
+            ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+          return next.startCall(call, headers);
+        }
+      }));
+
+  private AuthClient client;
+
+
+  @Before
+  public void setUp() throws IOException {
+    // Generate a unique in-process server name.
+    String serverName = InProcessServerBuilder.generateName();
+
+    // Create a server, add service, start, and register for automatic graceful shutdown.
+    grpcCleanup.register(InProcessServerBuilder.forName(serverName).directExecutor()
+        .addService(ServerInterceptors.intercept(
+            new GreeterGrpc.GreeterImplBase() {
+
+              @Override
+              public void sayHello(
+                  HelloRequest request, StreamObserver<HelloReply> responseObserver) {
+                HelloReply reply = HelloReply.newBuilder()
+                    .setMessage("AuthClientTest user=" + request.getName()).build();
+                responseObserver.onNext(reply);
+                responseObserver.onCompleted();
+              }
+            },
+            mockServerInterceptor))
+        .build().start());
+
+    CallCredentials credentials = new JwtCredential("test-client");
+    ManagedChannel channel = InProcessChannelBuilder.forName(serverName).directExecutor().build();
+    client = new AuthClient(credentials, channel);
+  }
+
+  @Test
+  public void greet() {
+    ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
+    String retVal = client.greet("John");
+
+    verify(mockServerInterceptor).interceptCall(
+        ArgumentMatchers.<ServerCall<HelloRequest, HelloReply>>any(),
+        metadataCaptor.capture(),
+        ArgumentMatchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
+
+    String token = metadataCaptor.getValue().get(Constant.AUTHORIZATION_METADATA_KEY);
+    assertNotNull(token);
+    assertTrue(token.startsWith("Bearer"));
+    assertEquals("AuthClientTest user=John", retVal);
+  }
+}
diff --git a/examples/example-oauth/README.md b/examples/example-oauth/README.md
new file mode 100644
index 00000000000..26a6e223f60
--- /dev/null
+++ b/examples/example-oauth/README.md
@@ -0,0 +1,73 @@
+Authentication Example
+==============================================
+
+This example illustrates a simple OAuth2-based authentication implementation in gRPC using
+ server interceptor. It uses the Google OAuth2 library since it already has the OAuth2
+semantics which makes it easy to illustrate the OAuth2 flow. The example creates an OAuth2
+credentials using the library and converts it to gRPC CallCredentials. However, you may
+use your own OAuth2 implementation, so use of Google OAuth2 library is not necessary.
+
+The example requires grpc-java to be pre-built. Using a release tag will download the relevant binaries
+from a maven repository. But if you need the latest SNAPSHOT binaries you will need to follow
+[COMPILING](../../COMPILING.md) to build these.
+
+The source code is [here](src/main/java/io/grpc/examples/oauth). 
+To build the example, run in this directory:
+```
+$ ../gradlew installDist
+```
+The build creates scripts `auth-server` and `auth-client` in the `build/install/example-oauth/bin/` directory
+which can be used to run this example. The example requires the server to be running before starting the
+client.
+
+Running auth-server is similar to the normal hello world example and there are no arguments to supply:
+
+**auth-server**:
+
+The auth-server accepts optional argument for port on which the server should run:
+
+```text
+USAGE: auth-server [port]
+```
+
+The auth-client accepts optional arguments for server-host, server-port, user-name and client-id:
+
+**auth-client**:
+
+```text
+USAGE: auth-client [server-host [server-port [user-name [client-id]]]]
+```
+
+The `user-name` value is simply passed in the `HelloRequest` message as payload and the value of
+`client-id` is included in the OAuth2 access token passed in the metadata header.
+
+
+#### How to run the example:
+
+```bash
+# Run the server:
+./build/install/example-oauth/bin/auth-server 50051
+# In another terminal run the client
+./build/install/example-oauth/bin/auth-client localhost 50051 userA clientB
+```
+
+That's it! The client will show the user-name reflected back in the message from the server as follows:
+```
+INFO: Greeting: Hello, userA
+```
+
+And on the server side you will see the message with the client's identifier:
+```
+Processing request from clientB
+```
+
+## Maven
+
+If you prefer to use Maven follow these [steps](../README.md#maven). You can run the example as follows:
+
+```
+$ # Run the server
+$ mvn exec:java -Dexec.mainClass=io.grpc.examples.oauth.AuthServer -Dexec.args="50051"
+$ # In another terminal run the client
+$ mvn exec:java -Dexec.mainClass=io.grpc.examples.oauth.AuthClient -Dexec.args="localhost 50051 userA clientB"
+```
diff --git a/examples/example-oauth/build.gradle b/examples/example-oauth/build.gradle
new file mode 100644
index 00000000000..63dd47fc61b
--- /dev/null
+++ b/examples/example-oauth/build.gradle
@@ -0,0 +1,76 @@
+plugins {
+    // Provide convenience executables for trying out the examples.
+    id 'application'
+    id 'com.google.protobuf' version '0.9.5'
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
+// are looking at a tagged version of the example and not "master"!
+
+// Feel free to delete the comment at the next line. It is just for safely
+// updating the version in our release process.
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protobufVersion = '3.25.8'
+def protocVersion = protobufVersion
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    implementation "io.grpc:grpc-auth:${grpcVersion}"
+    implementation "com.google.auth:google-auth-library-oauth2-http:1.41.0"
+
+    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
+
+    testImplementation "io.grpc:grpc-testing:${grpcVersion}"
+    testImplementation "io.grpc:grpc-inprocess:${grpcVersion}"
+    testImplementation "junit:junit:4.13.2"
+    testImplementation "org.mockito:mockito-core:4.4.0"
+}
+
+protobuf {
+    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
+    plugins {
+        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
+    }
+    generateProtoTasks {
+        all()*.plugins { grpc {} }
+    }
+}
+
+startScripts.enabled = false
+
+task hellowWorldOauthServer(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.oauth.AuthServer'
+    applicationName = 'auth-server'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+task hellowWorldOauthClient(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.oauth.AuthClient'
+    applicationName = 'auth-client'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into('bin') {
+        from(hellowWorldOauthServer)
+        from(hellowWorldOauthClient)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
diff --git a/examples/example-oauth/pom.xml b/examples/example-oauth/pom.xml
new file mode 100644
index 00000000000..cac1a949a85
--- /dev/null
+++ b/examples/example-oauth/pom.xml
@@ -0,0 +1,129 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>io.grpc</groupId>
+  <artifactId>example-oauth</artifactId>
+  <packaging>jar</packaging>
+  <!-- Feel free to delete the comment at the end of these lines. It is just
+       for safely updating the version in our release process. -->
+  <version>1.80.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
+  <name>example-oauth</name>
+  <url>https://github.com/grpc/grpc-java</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <grpc.version>1.80.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
+    <protobuf.version>3.25.8</protobuf.version>
+    <protoc.version>3.25.8</protoc.version>
+    <!-- required for jdk9 -->
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+  </properties>
+
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>io.grpc</groupId>
+        <artifactId>grpc-bom</artifactId>
+        <version>${grpc.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+
+  <dependencies>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-netty-shaded</artifactId>
+      <scope>runtime</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-protobuf</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-stub</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-auth</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>com.google.auth</groupId>
+      <artifactId>google-auth-library-oauth2-http</artifactId>
+      <version>1.40.0</version>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-testing</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.13.2</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <version>4.4.0</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <extensions>
+      <extension>
+        <groupId>kr.motd.maven</groupId>
+        <artifactId>os-maven-plugin</artifactId>
+        <version>1.7.1</version>
+      </extension>
+    </extensions>
+    <plugins>
+      <plugin>
+        <groupId>org.xolstice.maven.plugins</groupId>
+        <artifactId>protobuf-maven-plugin</artifactId>
+        <version>0.6.1</version>
+        <configuration>
+          <protocArtifact>
+            com.google.protobuf:protoc:${protoc.version}:exe:${os.detected.classifier}
+          </protocArtifact>
+          <pluginId>grpc-java</pluginId>
+          <pluginArtifact>
+            io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}
+          </pluginArtifact>
+        </configuration>
+        <executions>
+          <execution>
+            <goals>
+              <goal>compile</goal>
+              <goal>compile-custom</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-enforcer-plugin</artifactId>
+        <version>3.5.0</version>
+        <executions>
+          <execution>
+            <id>enforce</id>
+            <goals>
+              <goal>enforce</goal>
+            </goals>
+            <configuration>
+              <rules>
+                <requireUpperBoundDeps/>
+              </rules>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>
diff --git a/examples/example-oauth/settings.gradle b/examples/example-oauth/settings.gradle
new file mode 100644
index 00000000000..6bd0f0cdc2d
--- /dev/null
+++ b/examples/example-oauth/settings.gradle
@@ -0,0 +1,19 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+
+    repositories {
+        gradlePluginPortal()
+    }
+}
diff --git a/examples/example-oauth/src/main/java/io/grpc/examples/oauth/AuthClient.java b/examples/example-oauth/src/main/java/io/grpc/examples/oauth/AuthClient.java
new file mode 100644
index 00000000000..a43f6fbd98e
--- /dev/null
+++ b/examples/example-oauth/src/main/java/io/grpc/examples/oauth/AuthClient.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2023 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.examples.oauth;
+
+import io.grpc.CallCredentials;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.auth.MoreCallCredentials;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * An authenticating client that requests a greeting from the {@link AuthServer}.
+ */
+public class AuthClient {
+
+  private static final Logger logger = Logger.getLogger(AuthClient.class.getName());
+
+  private final ManagedChannel channel;
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+  private final CallCredentials callCredentials;
+
+  /**
+   * Construct client for accessing GreeterGrpc server.
+   */
+  AuthClient(CallCredentials callCredentials, String host, int port) {
+    this(
+        callCredentials,
+        // For this example we use plaintext to avoid needing certificates, but it is
+        // recommended to use TlsChannelCredentials.
+        Grpc.newChannelBuilderForAddress(host, port, InsecureChannelCredentials.create())
+            .build());
+  }
+
+  /**
+   * Construct a client for accessing GreeterGrpc server using an existing channel.
+   */
+  AuthClient(CallCredentials callCredentials, ManagedChannel channel) {
+    this.callCredentials = callCredentials;
+    this.channel = channel;
+    this.blockingStub = GreeterGrpc.newBlockingStub(channel);
+  }
+
+  public void shutdown() throws InterruptedException {
+    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
+  }
+
+  /**
+   * Say hello to server.
+   *
+   * @param name name to set in HelloRequest
+   * @return the message in the HelloReply from the server
+   */
+  public String greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+
+    // Use a stub with the given call credentials applied to invoke the RPC.
+    HelloReply response =
+        blockingStub
+            .withCallCredentials(callCredentials)  //   callCredentials
+            .sayHello(request);
+
+    logger.info("Greeting: " + response.getMessage());
+    return response.getMessage();
+  }
+
+  private static CallCredentials getOauthCred(String clientId) {
+    ExampleOAuth2Credentials oAuth2Credentials = new ExampleOAuth2Credentials(clientId);
+    return MoreCallCredentials.from(oAuth2Credentials);
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the greeting
+   * and the second is the client identifier to set in JWT
+   */
+  public static void main(String[] args) throws Exception {
+
+    String host = "localhost";
+    int port = 50051;
+    String user = "world";
+    String clientId = "default-client";
+
+    if (args.length > 0) {
+      host = args[0]; // Use the arg as the server host if provided
+    }
+    if (args.length > 1) {
+      port = Integer.parseInt(args[1]); // Use the second argument as the server port if provided
+    }
+    if (args.length > 2) {
+      user = args[2]; // Use the the third argument as the name to greet if provided
+    }
+    if (args.length > 3) {
+      clientId = args[3]; // Use the fourth argument as the client identifier if provided
+    }
+
+    CallCredentials credentials = getOauthCred(clientId);
+    AuthClient client = new AuthClient(credentials, host, port);
+
+    try {
+      client.greet(user);
+    } finally {
+      client.shutdown();
+    }
+  }
+}
diff --git a/examples/example-oauth/src/main/java/io/grpc/examples/oauth/AuthServer.java b/examples/example-oauth/src/main/java/io/grpc/examples/oauth/AuthServer.java
new file mode 100644
index 00000000000..c44d55476da
--- /dev/null
+++ b/examples/example-oauth/src/main/java/io/grpc/examples/oauth/AuthServer.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright 2023 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.examples.oauth;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.logging.Logger;
+
+/**
+ * Server that manages startup/shutdown of a {@code Greeter} server. This also uses a
+ * {@link OAuth2ServerInterceptor} to intercept the OAuth2 token passed.
+ */
+public class AuthServer {
+
+  private static final Logger logger = Logger.getLogger(AuthServer.class.getName());
+
+  private Server server;
+  private int port;
+
+  public AuthServer(int port) {
+    this.port = port;
+  }
+
+  private void start() throws IOException {
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new GreeterImpl())
+        .intercept(new OAuth2ServerInterceptor())
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        AuthServer.this.stop();
+        System.err.println("*** server shut down");
+      }
+    });
+  }
+
+  private void stop() {
+    if (server != null) {
+      server.shutdown();
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+
+    // The port on which the server should run
+    int port = 50051; // default
+    if (args.length > 0) {
+      port = Integer.parseInt(args[0]);
+    }
+
+    final AuthServer server = new AuthServer(port);
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      // get client id added to context by interceptor
+      String clientId = Constant.CLIENT_ID_CONTEXT_KEY.get();
+      logger.info("Processing request from " + clientId);
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello, " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/examples/example-oauth/src/main/java/io/grpc/examples/oauth/Constant.java b/examples/example-oauth/src/main/java/io/grpc/examples/oauth/Constant.java
new file mode 100644
index 00000000000..1db9b6e4e47
--- /dev/null
+++ b/examples/example-oauth/src/main/java/io/grpc/examples/oauth/Constant.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2023 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.examples.oauth;
+
+import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
+
+import io.grpc.Context;
+import io.grpc.Metadata;
+
+/**
+ * Constants definition
+ */
+final class Constant {
+
+    static final String REFRESH_SUFFIX = "+1";
+    static final String ACCESS_TOKEN = "access-token";
+    static final Context.Key<String> CLIENT_ID_CONTEXT_KEY = Context.key("clientId");
+    static final Metadata.Key<String> AUTHORIZATION_METADATA_KEY = Metadata.Key.of("Authorization", ASCII_STRING_MARSHALLER);
+
+    private Constant() {
+    }
+}
diff --git a/examples/example-oauth/src/main/java/io/grpc/examples/oauth/ExampleOAuth2Credentials.java b/examples/example-oauth/src/main/java/io/grpc/examples/oauth/ExampleOAuth2Credentials.java
new file mode 100644
index 00000000000..e2171ea20f4
--- /dev/null
+++ b/examples/example-oauth/src/main/java/io/grpc/examples/oauth/ExampleOAuth2Credentials.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2023 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.examples.oauth;
+
+import com.google.auth.oauth2.AccessToken;
+import com.google.auth.oauth2.OAuth2Credentials;
+import java.io.IOException;
+import java.time.Instant;
+import java.util.Date;
+
+/**
+ * Subclass of {@link OAuth2Credentials } with a simple implementation of
+ * {@link OAuth2Credentials#refreshAccessToken()}. A real implementation
+ * will maintain a refresh token and use it to exchange it for a new
+ * access token from the authorization server.
+ */
+public class ExampleOAuth2Credentials extends OAuth2Credentials {
+
+  /**
+   * Creates an access token using the passed in clientId. A real
+   * implementation will contact the authorization server to get an access
+   * token and a refresh token.
+   *
+   */
+  public ExampleOAuth2Credentials(String clientId) {
+    super(new AccessToken(Constant.ACCESS_TOKEN + ":" + clientId,
+        new Date()));
+  }
+
+
+  /**
+   * Refreshes access token by simply appending ":+1" to the previous value.
+   * A real implementation will use the existing refresh token to get
+   * fresh access and refresh tokens from the authorization server.
+   */
+  @Override
+  public AccessToken refreshAccessToken() throws IOException {
+    AccessToken accessToken = getAccessToken();
+    if (accessToken == null) {
+      throw new IOException("No existing token found");
+    }
+    String tokenValue = accessToken.getTokenValue();
+    return new AccessToken(tokenValue + ":" + Constant.REFRESH_SUFFIX,
+        Date.from((Instant.now().plusSeconds(120))));
+  }
+}
diff --git a/examples/example-oauth/src/main/java/io/grpc/examples/oauth/OAuth2ServerInterceptor.java b/examples/example-oauth/src/main/java/io/grpc/examples/oauth/OAuth2ServerInterceptor.java
new file mode 100644
index 00000000000..032c9297de4
--- /dev/null
+++ b/examples/example-oauth/src/main/java/io/grpc/examples/oauth/OAuth2ServerInterceptor.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2023 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.examples.oauth;
+
+import io.grpc.Context;
+import io.grpc.Contexts;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.Status;
+
+/**
+ * This interceptor gets the OAuth2 access token from metadata, verifies it and sets the client
+ * identifier obtained from the token into the context. The one check it does on the access token
+ * is that the token has been refreshed at least once.
+ *
+ * A real implementation will validate the access token using the resource server (or the
+ * authorization server).
+ */
+class OAuth2ServerInterceptor implements ServerInterceptor {
+
+  private static final String BEARER_TYPE = "Bearer";
+
+  @Override
+  public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> serverCall,
+      Metadata metadata, ServerCallHandler<ReqT, RespT> serverCallHandler) {
+    String authHeaderValue = metadata.get(Constant.AUTHORIZATION_METADATA_KEY);
+
+    Status status = Status.OK;
+    if (authHeaderValue == null) {
+      status = Status.UNAUTHENTICATED.withDescription("Authorization token is missing");
+    } else if (!authHeaderValue.startsWith(BEARER_TYPE)) {
+      status = Status.UNAUTHENTICATED.withDescription("Unknown authorization type");
+    } else {
+      // remove authorization type prefix
+      String tokenValue = authHeaderValue.substring(BEARER_TYPE.length()).trim();
+      if (!tokenValue.startsWith(Constant.ACCESS_TOKEN)) {
+        status = Status.UNAUTHENTICATED.withDescription("Invalid access token authHeaderValue");
+      } else {
+        String[] tokens = tokenValue.split(":");
+        if (tokens.length >= 3 && tokens[2].equals(Constant.REFRESH_SUFFIX)) {
+          // set access tokenValue into current context
+          Context ctx = Context.current()
+              .withValue(Constant.CLIENT_ID_CONTEXT_KEY, tokens[1]);
+          return Contexts.interceptCall(ctx, serverCall, metadata, serverCallHandler);
+        } else {
+          status = Status.UNAUTHENTICATED.withDescription("stale credentials");
+        }
+      }
+    }
+
+    // at this point we have auth failure: skip further processing and close the call
+    serverCall.close(status, new Metadata());
+    return new ServerCall.Listener<ReqT>() {
+      // noop
+    };
+  }
+
+}
diff --git a/examples/example-oauth/src/main/proto/helloworld.proto b/examples/example-oauth/src/main/proto/helloworld.proto
new file mode 100644
index 00000000000..6340c54f7bb
--- /dev/null
+++ b/examples/example-oauth/src/main/proto/helloworld.proto
@@ -0,0 +1,37 @@
+// Copyright 2019 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/example-oauth/src/test/java/io/grpc/examples/oauth/AuthClientTest.java b/examples/example-oauth/src/test/java/io/grpc/examples/oauth/AuthClientTest.java
new file mode 100644
index 00000000000..739018cc5a8
--- /dev/null
+++ b/examples/example-oauth/src/test/java/io/grpc/examples/oauth/AuthClientTest.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2023 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.examples.oauth;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.CallCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptors;
+import io.grpc.auth.MoreCallCredentials;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.ServerCall.Listener;
+import io.grpc.ServerInterceptor;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import java.io.IOException;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+
+/**
+ * Unit tests for {@link AuthClient} testing the default and non-default tokens
+ *
+ *
+ */
+@RunWith(JUnit4.class)
+public class AuthClientTest {
+  /**
+   * This rule manages automatic graceful shutdown for the registered servers and channels at the
+   * end of test.
+   */
+  @Rule
+  public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+  private final ServerInterceptor mockServerInterceptor = mock(ServerInterceptor.class, delegatesTo(
+      new ServerInterceptor() {
+        @Override
+        public <ReqT, RespT> Listener<ReqT> interceptCall(
+            ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+          return next.startCall(call, headers);
+        }
+      }));
+
+  private AuthClient client;
+
+
+  @Before
+  public void setUp() throws IOException {
+    // Generate a unique in-process server name.
+    String serverName = InProcessServerBuilder.generateName();
+
+    // Create a server, add service, start, and register for automatic graceful shutdown.
+    grpcCleanup.register(InProcessServerBuilder.forName(serverName).directExecutor()
+        .addService(ServerInterceptors.intercept(
+            new GreeterGrpc.GreeterImplBase() {
+
+              @Override
+              public void sayHello(
+                  HelloRequest request, StreamObserver<HelloReply> responseObserver) {
+                HelloReply reply = HelloReply.newBuilder()
+                    .setMessage("AuthClientTest user=" + request.getName()).build();
+                responseObserver.onNext(reply);
+                responseObserver.onCompleted();
+              }
+            },
+            mockServerInterceptor))
+        .build().start());
+
+    CallCredentials credentials = MoreCallCredentials.from(
+        new ExampleOAuth2Credentials("test-client"));
+    ManagedChannel channel = InProcessChannelBuilder.forName(serverName).directExecutor().build();
+    client = new AuthClient(credentials, channel);
+  }
+
+  @Test
+  public void greet() {
+    ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
+    String retVal = client.greet("John");
+
+    verify(mockServerInterceptor).interceptCall(
+        ArgumentMatchers.<ServerCall<HelloRequest, HelloReply>>any(),
+        metadataCaptor.capture(),
+        ArgumentMatchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
+
+    String token = metadataCaptor.getValue().get(Constant.AUTHORIZATION_METADATA_KEY);
+    assertNotNull(token);
+    assertTrue(token.startsWith("Bearer"));
+    assertEquals("AuthClientTest user=John", retVal);
+  }
+}
diff --git a/examples/example-opentelemetry/README.md b/examples/example-opentelemetry/README.md
new file mode 100644
index 00000000000..4515d5423ff
--- /dev/null
+++ b/examples/example-opentelemetry/README.md
@@ -0,0 +1,54 @@
+gRPC OpenTelemetry Example
+================
+
+The example extends the gRPC "hello world" example by modifying the client and server to
+showcase a sample configuration for gRPC OpenTelemetry with a Prometheus exporter.
+
+The example requires grpc-java to be pre-built. Using a release tag will download the relevant binaries
+from a maven repository. But if you need the latest SNAPSHOT binaries you will need to follow
+[COMPILING](../../COMPILING.md) to build these.
+
+### Build the example
+
+The source code is [here](src/main/java/io/grpc/examples/opentelemetry).
+To build the example, run in this directory:
+```
+$ ../gradlew installDist
+```
+The build creates scripts `opentelemetry-server` and `opentelemetry-client` in the `build/install/example-opentelemetry/bin/` directory
+which can be used to run this example. The example requires the server to be running before starting the
+client.
+
+### Run the example
+
+**opentelemetry-server**:
+
+The opentelemetry-server accepts optional arguments for server-port and prometheus-port:
+
+```text
+USAGE: opentelemetry-server [server-port [prometheus-port]]
+```
+
+**opentelemetry-client**:
+
+The opentelemetry-client accepts optional arguments for user-name, target and prometheus-port:
+
+```text
+USAGE: opentelemetry-client-client [user-name [target [prometheus-port]]]
+```
+
+The opentelemetry-client continuously sends an RPC to the server every second.
+
+To make sure that the server and client metrics are being exported properly, in
+a separate terminal, run the following:
+
+```
+$ curl localhost:9464/metrics
+```
+
+```
+$ curl localhost:9465/metrics
+```
+
+> ***NOTE:*** If the prometheus endpoint configured is overridden, please update the target in the
+> above curl command.
diff --git a/examples/example-opentelemetry/build.gradle b/examples/example-opentelemetry/build.gradle
new file mode 100644
index 00000000000..ab703b5acda
--- /dev/null
+++ b/examples/example-opentelemetry/build.gradle
@@ -0,0 +1,90 @@
+plugins {
+    // Provide convenience executables for trying out the examples.
+    id 'application'
+    id 'com.google.protobuf' version '0.9.5'
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
+// are looking at a tagged version of the example and not "master"!
+
+// Feel free to delete the comment at the next line. It is just for safely
+// updating the version in our release process.
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protocVersion = '3.25.8'
+def openTelemetryVersion = '1.56.0'
+def openTelemetryPrometheusVersion = '1.56.0-alpha'
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    implementation "io.grpc:grpc-opentelemetry:${grpcVersion}"
+    implementation "io.opentelemetry:opentelemetry-sdk:${openTelemetryVersion}"
+    implementation "io.opentelemetry:opentelemetry-sdk-metrics:${openTelemetryVersion}"
+    implementation "io.opentelemetry:opentelemetry-exporter-logging:${openTelemetryVersion}"
+    implementation "io.opentelemetry:opentelemetry-exporter-prometheus:${openTelemetryPrometheusVersion}"
+    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
+}
+
+protobuf {
+    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
+    plugins {
+        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
+    }
+    generateProtoTasks {
+        all()*.plugins { grpc {} }
+    }
+}
+
+startScripts.enabled = false
+
+task OpenTelemetryHelloWorldServer(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.opentelemetry.OpenTelemetryServer'
+    applicationName = 'opentelemetry-server'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+task OpenTelemetryHelloWorldClient(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.opentelemetry.OpenTelemetryClient'
+    applicationName = 'opentelemetry-client'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+task LoggingOpenTelemetryHelloWorldServer(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.opentelemetry.logging.LoggingOpenTelemetryServer'
+    applicationName = 'logging-opentelemetry-server'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+task LoggingOpenTelemetryHelloWorldClient(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.opentelemetry.logging.LoggingOpenTelemetryClient'
+    applicationName = 'logging-opentelemetry-client'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into('bin') {
+        from(OpenTelemetryHelloWorldServer)
+        from(OpenTelemetryHelloWorldClient)
+        from(LoggingOpenTelemetryHelloWorldServer)
+        from(LoggingOpenTelemetryHelloWorldClient)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
diff --git a/examples/example-opentelemetry/settings.gradle b/examples/example-opentelemetry/settings.gradle
new file mode 100644
index 00000000000..26e3bea044b
--- /dev/null
+++ b/examples/example-opentelemetry/settings.gradle
@@ -0,0 +1,17 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+}
+
+rootProject.name = 'example-opentelemetry'
diff --git a/examples/example-opentelemetry/src/main/java/io/grpc/example/opentelemetry/OpenTelemetryClient.java b/examples/example-opentelemetry/src/main/java/io/grpc/example/opentelemetry/OpenTelemetryClient.java
new file mode 100644
index 00000000000..a21d711750f
--- /dev/null
+++ b/examples/example-opentelemetry/src/main/java/io/grpc/example/opentelemetry/OpenTelemetryClient.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2024 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.examples.opentelemetry;
+
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.opentelemetry.GrpcOpenTelemetry;
+import io.opentelemetry.exporter.prometheus.PrometheusHttpServer;
+import io.opentelemetry.sdk.OpenTelemetrySdk;
+import io.opentelemetry.sdk.metrics.SdkMeterProvider;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A simple gRPC client that requests a greeting from the {@link HelloWorldServer} and
+ * generates gRPC OpenTelmetry metrics data based on the configuration.
+ */
+public class OpenTelemetryClient {
+  private static final Logger logger = Logger.getLogger(OpenTelemetryClient.class.getName());
+
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+  /** Construct client for accessing HelloWorld server using the existing channel. */
+  public OpenTelemetryClient(Channel channel) {
+    blockingStub = GreeterGrpc.newBlockingStub(channel);
+  }
+
+  /** Say hello to server. */
+  public void greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response;
+    try {
+      response = blockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    logger.info("Greeting: " + response.getMessage());
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the
+   * greeting. The second argument is the target server.
+   */
+  public static void main(String[] args) throws Exception {
+    String user = "world";
+    // Access a service running on the local machine on port 50051
+    String target = "localhost:50051";
+    // The port on which prometheus metrics are exposed.
+    int prometheusPort = 9465;
+    AtomicBoolean sendRpcs = new AtomicBoolean(true);
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [name [target [prometheusPort]]]");
+        System.err.println("");
+        System.err.println("  name    The name you wish to be greeted by. Defaults to " + user);
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.err.println("  prometheusPort  The port to expose prometheus metrics. Defaults to " + prometheusPort);
+        System.exit(1);
+      }
+      user = args[0];
+    }
+    if (args.length > 1) {
+      target = args[1];
+    }
+    if (args.length > 2) {
+      prometheusPort = Integer.parseInt(args[2]);
+    }
+
+    Thread mainThread = Thread.currentThread();
+
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC client since JVM is shutting down");
+
+        sendRpcs.set(false);
+        try {
+          mainThread.join();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** client shut down");
+      }
+    });
+
+    // Adds a PrometheusHttpServer to convert OpenTelemetry metrics to Prometheus format and
+    // expose these via a HttpServer exporter to the SdkMeterProvider.
+    SdkMeterProvider sdkMeterProvider = SdkMeterProvider.builder()
+        .registerMetricReader(
+            PrometheusHttpServer.builder().setPort(prometheusPort).build())
+        .build();
+
+    // Initialize OpenTelemetry SDK with MeterProvider configured with Prometeheus.
+    OpenTelemetrySdk openTelemetrySdk =
+        OpenTelemetrySdk.builder().setMeterProvider(sdkMeterProvider).build();
+
+    // Initialize gRPC OpenTelemetry.
+    // Following client metrics are enabled by default :
+    //     1. grpc.client.attempt.started
+    //     2. grpc.client.attempt.sent_total_compressed_message_size
+    //     3. grpc.client.attempt.rcvd_total_compressed_message_size
+    //     4. grpc.client.attempt.duration
+    //     5. grpc.client.call.duration
+    GrpcOpenTelemetry grpcOpenTelmetry = GrpcOpenTelemetry.newBuilder()
+        .sdk(openTelemetrySdk)
+        .build();
+    // Registers gRPC OpenTelemetry globally.
+    grpcOpenTelmetry.registerGlobal();
+
+    // Create a communication channel to the server, known as a Channel.
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .build();
+    OpenTelemetryClient client = new OpenTelemetryClient(channel);
+
+    try {
+      // Run RPCs every second.
+      while (sendRpcs.get()) {
+        client.greet(user);
+        // Sleep for a bit before sending the next RPC.
+        Thread.sleep(1000);
+      }
+    } finally {
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+      // Shut down OpenTelemetry SDK.
+      openTelemetrySdk.close();
+    }
+  }
+}
diff --git a/examples/example-opentelemetry/src/main/java/io/grpc/example/opentelemetry/OpenTelemetryServer.java b/examples/example-opentelemetry/src/main/java/io/grpc/example/opentelemetry/OpenTelemetryServer.java
new file mode 100644
index 00000000000..3601572ab4b
--- /dev/null
+++ b/examples/example-opentelemetry/src/main/java/io/grpc/example/opentelemetry/OpenTelemetryServer.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2024 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.examples.opentelemetry;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.opentelemetry.GrpcOpenTelemetry;
+import io.grpc.stub.StreamObserver;
+import io.opentelemetry.exporter.prometheus.PrometheusHttpServer;
+import io.opentelemetry.sdk.OpenTelemetrySdk;
+import io.opentelemetry.sdk.metrics.SdkMeterProvider;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * gRPC server that manages startup/shutdown of a {@code Greeter} server and generates
+ * gRPC OpenTelemetry metrics data based on the configuration.
+ */
+public class OpenTelemetryServer {
+  private static final Logger logger = Logger.getLogger(OpenTelemetryServer.class.getName());
+
+  private Server server;
+  private void start(int port) throws IOException {
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new GreeterImpl())
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    // The port on which the server should run.
+    int port = 50051;
+    // The port on which prometheus metrics are exposed.
+    int prometheusPort = 9464;
+
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [port [prometheus_port]]");
+        System.err.println("");
+        System.err.println("  port  The port on which server will run. Defaults to " + port);
+        System.err.println("  prometheusPort  The port to expose prometheus metrics. Defaults to " + prometheusPort);
+        System.exit(1);
+      }
+      port = Integer.parseInt(args[0]);
+    }
+    if (args.length > 1) {
+      prometheusPort = Integer.parseInt(args[1]);
+    }
+
+    // Adds a PrometheusHttpServer to convert OpenTelemetry metrics to Prometheus format and
+    // expose these via a HttpServer exporter to the SdkMeterProvider.
+    SdkMeterProvider sdkMeterProvider = SdkMeterProvider.builder()
+        .registerMetricReader(
+            PrometheusHttpServer.builder().setPort(prometheusPort).build())
+        .build();
+
+    // Initialize OpenTelemetry SDK with MeterProvider configured with Prometheus metrics exporter
+    OpenTelemetrySdk openTelemetrySdk =
+        OpenTelemetrySdk.builder().setMeterProvider(sdkMeterProvider).build();
+
+    // Initialize gRPC OpenTelemetry.
+    // Following client metrics are enabled by default :
+    //     1. grpc.server.call.started
+    //     2. grpc.server.call.sent_total_compressed_message_size
+    //     3. grpc.server.call.rcvd_total_compressed_message_size
+    //     4. grpc.server.call.duration
+    GrpcOpenTelemetry grpcOpenTelmetry = GrpcOpenTelemetry.newBuilder()
+        .sdk(openTelemetrySdk)
+        .build();
+    // Registers gRPC OpenTelemetry globally.
+    grpcOpenTelmetry.registerGlobal();
+
+    final OpenTelemetryServer server = new OpenTelemetryServer();
+    server.start(port);
+
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          server.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        // Shut down OpenTelemetry SDK.
+        openTelemetrySdk.close();
+
+        System.err.println("*** server shut down");
+      }
+    });
+
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/examples/example-opentelemetry/src/main/java/io/grpc/example/opentelemetry/logging/LoggingOpenTelemetryClient.java b/examples/example-opentelemetry/src/main/java/io/grpc/example/opentelemetry/logging/LoggingOpenTelemetryClient.java
new file mode 100644
index 00000000000..1a6d4966145
--- /dev/null
+++ b/examples/example-opentelemetry/src/main/java/io/grpc/example/opentelemetry/logging/LoggingOpenTelemetryClient.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2024 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.examples.opentelemetry.logging;
+
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.opentelemetry.GrpcOpenTelemetry;
+import io.opentelemetry.exporter.logging.LoggingMetricExporter;
+import io.opentelemetry.sdk.OpenTelemetrySdk;
+import io.opentelemetry.sdk.metrics.SdkMeterProvider;
+import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader;
+import java.time.Duration;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A simple gRPC client that requests a greeting from the {@link HelloWorldServer} and
+ * exports gRPC OpenTelmetry metrics data using {@code java.util.logging}.
+ */
+public class LoggingOpenTelemetryClient {
+  private static final Logger logger = Logger.getLogger(LoggingOpenTelemetryClient.class.getName());
+
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+  /** Construct client for accessing HelloWorld server using the existing channel. */
+  public LoggingOpenTelemetryClient(Channel channel) {
+    blockingStub = GreeterGrpc.newBlockingStub(channel);
+  }
+
+  /** Say hello to server. */
+  public void greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response;
+    try {
+      response = blockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    logger.info("Greeting: " + response.getMessage());
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the
+   * greeting. The second argument is the target server.
+   */
+  public static void main(String[] args) throws Exception {
+    String user = "world";
+    // Access a service running on the local machine on port 50051
+    String target = "localhost:50051";
+    // The number of milliseconds between metric exports.
+    long metricExportInterval = 800L;
+    AtomicBoolean sendRpcs = new AtomicBoolean(true);
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [name [target]]");
+        System.err.println("");
+        System.err.println("  name    The name you wish to be greeted by. Defaults to " + user);
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.exit(1);
+      }
+      user = args[0];
+    }
+    if (args.length > 1) {
+      target = args[1];
+    }
+
+    Thread mainThread = Thread.currentThread();
+
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC client since JVM is shutting down");
+
+        sendRpcs.set(false);
+        try {
+          mainThread.join();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** client shut down");
+      }
+    });
+
+    // Create an instance of PeriodicMetricReader and configure it to export
+    // via a logging exporter to the SdkMeterProvider.
+    SdkMeterProvider sdkMeterProvider = SdkMeterProvider.builder()
+        .registerMetricReader(
+            PeriodicMetricReader.builder(LoggingMetricExporter.create())
+                .setInterval(Duration.ofMillis(metricExportInterval))
+                .build())
+        .build();
+
+    // Initialize OpenTelemetry SDK with MeterProvider configured with Prometeheus.
+    OpenTelemetrySdk openTelemetrySdk =
+        OpenTelemetrySdk.builder().setMeterProvider(sdkMeterProvider).build();
+
+    // Initialize gRPC OpenTelemetry.
+    // Following client metrics are enabled by default :
+    //     1. grpc.client.attempt.started
+    //     2. grpc.client.attempt.sent_total_compressed_message_size
+    //     3. grpc.client.attempt.rcvd_total_compressed_message_size
+    //     4. grpc.client.attempt.duration
+    //     5. grpc.client.call.duration
+    GrpcOpenTelemetry grpcOpenTelmetry = GrpcOpenTelemetry.newBuilder()
+        .sdk(openTelemetrySdk)
+        .build();
+    // Registers gRPC OpenTelemetry globally.
+    grpcOpenTelmetry.registerGlobal();
+
+    // Create a communication channel to the server, known as a Channel.
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .build();
+    LoggingOpenTelemetryClient client = new LoggingOpenTelemetryClient(channel);
+
+    try {
+      // Run RPCs every second.
+      while (sendRpcs.get()) {
+        client.greet(user);
+        // Sleep for a bit before sending the next RPC.
+        Thread.sleep(1000);
+      }
+    } finally {
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+      // Shut down OpenTelemetry SDK.
+      openTelemetrySdk.close();
+    }
+  }
+}
diff --git a/examples/example-opentelemetry/src/main/java/io/grpc/example/opentelemetry/logging/LoggingOpenTelemetryServer.java b/examples/example-opentelemetry/src/main/java/io/grpc/example/opentelemetry/logging/LoggingOpenTelemetryServer.java
new file mode 100644
index 00000000000..121898c3ab5
--- /dev/null
+++ b/examples/example-opentelemetry/src/main/java/io/grpc/example/opentelemetry/logging/LoggingOpenTelemetryServer.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2024 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.examples.opentelemetry.logging;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.opentelemetry.GrpcOpenTelemetry;
+import io.grpc.stub.StreamObserver;
+import io.opentelemetry.exporter.logging.LoggingMetricExporter;
+import io.opentelemetry.sdk.OpenTelemetrySdk;
+import io.opentelemetry.sdk.metrics.SdkMeterProvider;
+import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader;
+import java.time.Duration;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * gRPC server that manages startup/shutdown of a {@code Greeter} server and exports
+ * gRPC OpenTelemetry metrics data using {@code java.util.logging}.
+ */
+public class LoggingOpenTelemetryServer {
+  private static final Logger logger = Logger.getLogger(LoggingOpenTelemetryServer.class.getName());
+
+  private Server gRPCServer;
+  private void start(int port) throws IOException {
+    gRPCServer = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new GreeterImpl())
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+  }
+
+  private void stop() throws InterruptedException {
+    if (gRPCServer != null) {
+      gRPCServer.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (gRPCServer != null) {
+      gRPCServer.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    // The port on which the server should run.
+    int port = 50051;
+    // The port on which prometheus metrics are exposed.
+    int prometheusPort = 9464;
+    // The number of milliseconds between metric exports.
+    long metricExportInterval = 800L;
+
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [port]");
+        System.err.println("");
+        System.err.println("  port  The port on which server will run. Defaults to " + port);
+        System.exit(1);
+      }
+      port = Integer.parseInt(args[0]);
+    }
+
+    // Create an instance of PeriodicMetricReader and configure it to export
+    // via a logging exporter to the SdkMeterProvider.
+    SdkMeterProvider sdkMeterProvider = SdkMeterProvider.builder()
+        .registerMetricReader(
+            PeriodicMetricReader.builder(LoggingMetricExporter.create())
+                .setInterval(Duration.ofMillis(metricExportInterval))
+                .build())
+        .build();
+
+    // Initialize OpenTelemetry SDK with MeterProvider configured with Logging metrics exporter
+    OpenTelemetrySdk openTelemetrySdk =
+        OpenTelemetrySdk.builder().setMeterProvider(sdkMeterProvider).build();
+
+    // Initialize gRPC OpenTelemetry.
+    // Following client metrics are enabled by default :
+    //     1. grpc.server.call.started
+    //     2. grpc.server.call.sent_total_compressed_message_size
+    //     3. grpc.server.call.rcvd_total_compressed_message_size
+    //     4. grpc.server.call.duration
+    GrpcOpenTelemetry grpcOpenTelmetry = GrpcOpenTelemetry.newBuilder()
+        .sdk(openTelemetrySdk)
+        .build();
+    // Registers gRPC OpenTelemetry globally.
+    grpcOpenTelmetry.registerGlobal();
+
+    final LoggingOpenTelemetryServer server = new LoggingOpenTelemetryServer();
+    server.start(port);
+
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          server.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        // Shut down OpenTelemetry SDK.
+        openTelemetrySdk.close();
+
+        System.err.println("*** server shut down");
+      }
+    });
+
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/examples/example-opentelemetry/src/main/proto/helloworld/helloworld.proto b/examples/example-opentelemetry/src/main/proto/helloworld/helloworld.proto
new file mode 100644
index 00000000000..64a8c09ee16
--- /dev/null
+++ b/examples/example-opentelemetry/src/main/proto/helloworld/helloworld.proto
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2023 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.
+ */
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/example-orca/README.md b/examples/example-orca/README.md
new file mode 100644
index 00000000000..7461b3ba397
--- /dev/null
+++ b/examples/example-orca/README.md
@@ -0,0 +1,44 @@
+gRPC ORCA Example
+================
+
+The ORCA example consists of a Hello World client and a Hello World server. Out-of-the-box the 
+client behaves the same the hello-world version and the server behaves similar to the
+example-hostname. In addition, they have been integrated with backend metrics reporting features.
+
+### Build the example
+
+Build the ORCA hello-world example client & server. From the `grpc-java/examples/examples-orca`
+directory:
+```
+$ ../gradlew installDist
+```
+
+This creates the scripts `build/install/example-orca/bin/custom-backend-metrics-client` and
+`build/install/example-orca/bin/custom-backend-metrics-server`.
+
+### Run the example
+
+To use ORCA, you have to instrument both the client and the server.
+At the client, in your own load balancer policy, you use gRPC APIs to install listeners to receive
+per-query and out-of-band metric reports.
+At the server, you add a server interceptor provided by gRPC in order to send per-query backend metrics.
+And you register a bindable service, also provided by gRPC, in order to send out-of-band backend metrics.
+Meanwhile, you update the metrics data from your own measurements.
+
+That's it! In this example, we simply put all the necessary pieces together to demonstrate the
+metrics reporting mechanism.
+
+1. To start the ORCA enabled example server on its default port of 50051, run:
+```
+$ ./build/install/example-orca/bin/custom-backend-metrics-server
+```
+
+2. In a different terminal window, run the ORCA enabled example client:
+```
+$ ./build/install/example-orca/bin/custom-backend-metrics-client "orca tester" 1500
+```
+The first command line argument (`orca tester`) is the name you wish to include in
+the greeting request to the server and the second argument
+(`1500`) is the time period (in milliseconds) you want to run the client before it shut downed so that it will show 
+more periodic backend metrics reports. You are expected to see the metrics data printed out. Try it!
+
diff --git a/examples/example-orca/build.gradle b/examples/example-orca/build.gradle
new file mode 100644
index 00000000000..049158088ec
--- /dev/null
+++ b/examples/example-orca/build.gradle
@@ -0,0 +1,63 @@
+plugins {
+    id 'application' // Provide convenience executables for trying out the examples.
+    id 'com.google.protobuf' version '0.9.5'
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+    id 'java'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protocVersion = '3.25.8'
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-services:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    implementation "io.grpc:grpc-xds:${grpcVersion}"
+}
+
+protobuf {
+    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
+    plugins {
+        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
+    }
+    generateProtoTasks {
+        all()*.plugins { grpc {} }
+    }
+}
+
+startScripts.enabled = false
+
+task CustomBackendMetricsClient(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.orca.CustomBackendMetricsClient'
+    applicationName = 'custom-backend-metrics-client'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+task CustomBackendMetricsServer(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.orca.CustomBackendMetricsServer'
+    applicationName = 'custom-backend-metrics-server'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into('bin') {
+        from(CustomBackendMetricsClient)
+        from(CustomBackendMetricsServer)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
diff --git a/examples/example-orca/settings.gradle b/examples/example-orca/settings.gradle
new file mode 100644
index 00000000000..12536c0ca8d
--- /dev/null
+++ b/examples/example-orca/settings.gradle
@@ -0,0 +1,17 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+}
+
+rootProject.name = 'example-orca'
diff --git a/examples/example-orca/src/main/java/io/grpc/examples/orca/CustomBackendMetricsClient.java b/examples/example-orca/src/main/java/io/grpc/examples/orca/CustomBackendMetricsClient.java
new file mode 100644
index 00000000000..66143b44364
--- /dev/null
+++ b/examples/example-orca/src/main/java/io/grpc/examples/orca/CustomBackendMetricsClient.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2022 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.examples.orca;
+
+import static io.grpc.examples.orca.CustomBackendMetricsLoadBalancerProvider.EXAMPLE_LOAD_BALANCER;
+
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.ManagedChannel;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A simple xDS client that requests a greeting from {@link CustomBackendMetricsServer}.
+ * The client channel is configured to use an example load balancer policy
+ * {@link CustomBackendMetricsLoadBalancerProvider} which integrates with ORCA metrics reporting.
+ */
+public class CustomBackendMetricsClient {
+  private static final Logger logger = Logger.getLogger(CustomBackendMetricsClient.class.getName());
+
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+  /** Construct client for accessing HelloWorld server using the existing channel. */
+  public CustomBackendMetricsClient(Channel channel) {
+    blockingStub = GreeterGrpc.newBlockingStub(channel);
+  }
+
+  /** Say hello to server. */
+  public void greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response;
+    try {
+      response = blockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    logger.info("Greeting: " + response.getMessage());
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the
+   * greeting. The second argument is the target server.
+   */
+  public static void main(String[] args) throws Exception {
+    String user = "orca tester";
+    // The example defaults to the same behavior as the hello world example.
+    // To receive more periodic OOB metrics reports, use duration argument to a longer value.
+    String target = "localhost:50051";
+    long timeBeforeShutdown = 1500;
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [name [duration [target]]]");
+        System.err.println("");
+        System.err.println("  name    The name you wish to be greeted by. Defaults to " + user);
+        System.err.println("  duration  The time period in milliseconds that the client application " +
+            "wait until shutdown. Defaults to " + timeBeforeShutdown);
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.exit(1);
+      }
+      user = args[0];
+    }
+    if (args.length > 1) {
+      timeBeforeShutdown = Long.parseLong(args[1]);
+    }
+
+    if (args.length > 2) {
+      target = args[2];
+    }
+
+    LoadBalancerRegistry.getDefaultRegistry().register(
+        new CustomBackendMetricsLoadBalancerProvider());
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .defaultLoadBalancingPolicy(EXAMPLE_LOAD_BALANCER)
+        .build();
+    try {
+      CustomBackendMetricsClient client = new CustomBackendMetricsClient(channel);
+      client.greet(user);
+      Thread.sleep(timeBeforeShutdown);
+    } finally {
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+    }
+  }
+}
diff --git a/examples/example-orca/src/main/java/io/grpc/examples/orca/CustomBackendMetricsLoadBalancerProvider.java b/examples/example-orca/src/main/java/io/grpc/examples/orca/CustomBackendMetricsLoadBalancerProvider.java
new file mode 100644
index 00000000000..c42fb7cdc10
--- /dev/null
+++ b/examples/example-orca/src/main/java/io/grpc/examples/orca/CustomBackendMetricsLoadBalancerProvider.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2022 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.examples.orca;
+
+import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.services.MetricReport;
+import io.grpc.util.ForwardingLoadBalancer;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import io.grpc.xds.orca.OrcaOobUtil;
+import io.grpc.xds.orca.OrcaPerRequestUtil;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Implements a test LB policy that receives ORCA load reports.
+ * The load balancer mostly delegates to {@link io.grpc.internal.PickFirstLoadBalancerProvider},
+ * in addition, it installs {@link OrcaOobUtil.OrcaOobReportListener} and
+ * {@link OrcaPerRequestUtil.OrcaPerRequestReportListener} to be notified with backend metrics.
+ */
+final class CustomBackendMetricsLoadBalancerProvider extends LoadBalancerProvider {
+
+  static final String EXAMPLE_LOAD_BALANCER = "example_backend_metrics_load_balancer";
+
+  @Override
+  public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+    return new CustomBackendMetricsLoadBalancer(helper);
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return EXAMPLE_LOAD_BALANCER;
+  }
+
+  private final class CustomBackendMetricsLoadBalancer extends ForwardingLoadBalancer {
+    private LoadBalancer delegate;
+
+    public CustomBackendMetricsLoadBalancer(LoadBalancer.Helper helper) {
+      this.delegate = LoadBalancerRegistry.getDefaultRegistry()
+          .getProvider("pick_first")
+          .newLoadBalancer(new CustomBackendMetricsLoadBalancerHelper(helper));
+    }
+
+    @Override
+    public LoadBalancer delegate() {
+      return delegate;
+    }
+
+    private final class CustomBackendMetricsLoadBalancerHelper
+        extends ForwardingLoadBalancerHelper {
+      private final LoadBalancer.Helper orcaHelper;
+
+      public CustomBackendMetricsLoadBalancerHelper(LoadBalancer.Helper helper) {
+        this.orcaHelper = OrcaOobUtil.newOrcaReportingHelper(helper);
+      }
+
+      @Override
+      public LoadBalancer.Subchannel createSubchannel(LoadBalancer.CreateSubchannelArgs args) {
+        LoadBalancer.Subchannel subchannel = super.createSubchannel(args);
+        // Installs ORCA OOB metrics reporting listener and configures to receive report every 1s.
+        // The interval can not be smaller than server minimum report interval configuration,
+        // otherwise it is treated as server minimum report interval.
+        OrcaOobUtil.setListener(subchannel, new OrcaOobUtil.OrcaOobReportListener() {
+              @Override
+              public void onLoadReport(MetricReport orcaLoadReport) {
+                System.out.println("Example load balancer received OOB metrics report:\n"
+                    + orcaLoadReport);
+              }
+            },
+            OrcaOobUtil.OrcaReportingConfig.newBuilder()
+                .setReportInterval(1, TimeUnit.SECONDS)
+                .build()
+        );
+        return subchannel;
+      }
+
+      @Override
+      public void updateBalancingState(ConnectivityState newState, LoadBalancer.SubchannelPicker newPicker) {
+        delegate().updateBalancingState(newState, new MayReportLoadPicker(newPicker));
+      }
+
+      @Override
+      public LoadBalancer.Helper delegate() {
+        return orcaHelper;
+      }
+    }
+
+    private final class MayReportLoadPicker extends LoadBalancer.SubchannelPicker {
+      private LoadBalancer.SubchannelPicker delegate;
+
+      public MayReportLoadPicker(LoadBalancer.SubchannelPicker delegate) {
+        this.delegate = delegate;
+      }
+
+      @Override
+      public LoadBalancer.PickResult pickSubchannel(LoadBalancer.PickSubchannelArgs args) {
+        LoadBalancer.PickResult result = delegate.pickSubchannel(args);
+        if (result.getSubchannel() == null) {
+          return result;
+        }
+        // Installs ORCA per-query metrics reporting listener.
+        final OrcaPerRequestUtil.OrcaPerRequestReportListener orcaListener =
+            new OrcaPerRequestUtil.OrcaPerRequestReportListener() {
+          @Override
+          public void onLoadReport(MetricReport orcaLoadReport) {
+            System.out.println("Example load balancer received per-rpc metrics report:\n"
+                + orcaLoadReport);
+          }
+        };
+        if (result.getStreamTracerFactory() == null) {
+          return LoadBalancer.PickResult.withSubchannel(
+              result.getSubchannel(),
+              OrcaPerRequestUtil.getInstance().newOrcaClientStreamTracerFactory(orcaListener));
+        } else {
+            return LoadBalancer.PickResult.withSubchannel(
+                result.getSubchannel(),
+                OrcaPerRequestUtil.getInstance().newOrcaClientStreamTracerFactory(
+                    result.getStreamTracerFactory(), orcaListener));
+        }
+      }
+    }
+  }
+}
diff --git a/examples/example-orca/src/main/java/io/grpc/examples/orca/CustomBackendMetricsServer.java b/examples/example-orca/src/main/java/io/grpc/examples/orca/CustomBackendMetricsServer.java
new file mode 100644
index 00000000000..669a091eb58
--- /dev/null
+++ b/examples/example-orca/src/main/java/io/grpc/examples/orca/CustomBackendMetricsServer.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2022 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.examples.orca;
+
+import com.google.common.collect.ImmutableMap;
+import io.grpc.BindableService;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.services.CallMetricRecorder;
+import io.grpc.services.InternalCallMetricRecorder;
+import io.grpc.services.MetricRecorder;
+import io.grpc.stub.StreamObserver;
+import io.grpc.xds.orca.OrcaMetricReportingServerInterceptor;
+import io.grpc.xds.orca.OrcaServiceImpl;
+import java.io.IOException;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * Server that manages startup/shutdown of a {@code Greeter} server.
+ */
+public class CustomBackendMetricsServer {
+  private static final Logger logger = Logger.getLogger(CustomBackendMetricsServer.class.getName());
+
+  private Server server;
+  private static Random random = new Random();
+  private MetricRecorder metricRecorder;
+
+  private void start() throws IOException {
+    /* The port on which the server should run */
+    int port = 50051;
+
+    ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
+    metricRecorder = MetricRecorder.newInstance();
+    // Configure OOB metrics reporting minimum report interval to be 1s. This allows client
+    // configuration to be as short as 1s, suitable for test demonstration.
+    BindableService orcaOobService =
+        OrcaServiceImpl.createService(executor, metricRecorder, 1, TimeUnit.SECONDS);
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new GreeterImpl())
+        // Enable OOB custom backend metrics reporting.
+        .addService(orcaOobService)
+        // Enable per-query custom backend metrics reporting.
+        .intercept(OrcaMetricReportingServerInterceptor.create(metricRecorder))
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          CustomBackendMetricsServer.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** server shut down");
+      }
+    });
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    CustomBackendMetricsServer server = new CustomBackendMetricsServer();
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      double cpuUtilization = random.nextDouble();
+      double memoryUtilization = random.nextDouble();
+      Map<String, Double> utilization = ImmutableMap.of("util", random.nextDouble());
+      Map<String, Double> requestCost = ImmutableMap.of("cost", random.nextDouble());
+      // Sets per-query backend metrics to a random test report.
+      CallMetricRecorder.getCurrent()
+          .recordCpuUtilizationMetric(cpuUtilization)
+          .recordMemoryUtilizationMetric(memoryUtilization)
+          .recordCallMetric("cost", requestCost.get("cost"))
+          .recordUtilizationMetric("util", utilization.get("util"));
+      System.out.println(String.format("Hello World Server updates RPC metrics data:\n" +
+          "cpu: %s, memory: %s, request cost: %s, utilization: %s\n",
+          cpuUtilization, memoryUtilization, requestCost,  utilization));
+
+      cpuUtilization = random.nextDouble();
+      memoryUtilization = random.nextDouble();
+      utilization = ImmutableMap.of("util", random.nextDouble());
+      // Sets OOB backend metrics to a random test report.
+      metricRecorder.setCpuUtilizationMetric(cpuUtilization);
+      metricRecorder.setMemoryUtilizationMetric(memoryUtilization);
+      metricRecorder.setAllUtilizationMetrics(utilization);
+      System.out.println(String.format("Hello World Server updates OOB metrics data:\n" +
+              "cpu: %s, memory: %s, utilization: %s\n",
+          cpuUtilization, memoryUtilization, utilization));
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/examples/example-orca/src/main/proto/helloworld/helloworld.proto b/examples/example-orca/src/main/proto/helloworld/helloworld.proto
new file mode 100644
index 00000000000..77184aa8326
--- /dev/null
+++ b/examples/example-orca/src/main/proto/helloworld/helloworld.proto
@@ -0,0 +1,37 @@
+// Copyright 2022 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/example-reflection/README.md b/examples/example-reflection/README.md
new file mode 100644
index 00000000000..4bc30e84b3b
--- /dev/null
+++ b/examples/example-reflection/README.md
@@ -0,0 +1,106 @@
+gRPC Reflection Example
+================
+
+The reflection example has a Hello World server with `ProtoReflectionServiceV1` registered. 
+
+### Build the example
+
+To build the example server, from the `grpc-java/examples/examples-reflection`
+directory:
+```
+$ ../gradlew installDist
+```
+
+This creates the scripts `build/install/example-reflection/bin/reflection-server`.
+
+### Run the example
+
+gRPC Server Reflection provides information about publicly-accessible gRPC services on a server,
+and assists clients at runtime to construct RPC requests and responses without precompiled
+service information. It is used by gRPCurl, which can be used to introspect server protos and
+send/receive test RPCs.
+
+1. To start the reflection example server on its default port of 50051, run:
+```
+$ ./build/install/example-reflection/bin/reflection-server
+```
+
+2. After enabling Server Reflection in a server application, you can use gRPCurl to check its
+services. Instructions on how to install and use gRPCurl can be found at [gRPCurl Installation](https://github.com/fullstorydev/grpcurl#installation)
+
+After installing gRPCurl, open a new terminal and run the commands from the new terminal.
+
+### List all the services exposed at a given port
+
+  ```
+  $ grpcurl -plaintext localhost:50051 list
+  ```
+
+Output
+
+  ```
+  grpc.reflection.v1alpha.ServerReflection
+  helloworld.Greeter
+  ```
+
+### List all the methods of a service
+  ```
+  $ grpcurl -plaintext localhost:50051 list helloworld.Greeter
+  ```
+Output
+  ```
+  helloworld.Greeter.SayHello
+  ```
+
+### Describe services and methods
+
+The describe command inspects a method given its full name(in the format of 
+`<package>.<service>.<method>`).
+
+  ```
+$ grpcurl -plaintext localhost:50051 describe helloworld.Greeter.SayHello
+  ```
+
+Output
+
+  ```
+  helloworld.Greeter.SayHello is a method:
+  rpc SayHello ( .helloworld.HelloRequest ) returns ( .helloworld.HelloReply );
+  ```
+
+### Inspect message types
+
+We can use the describe command to inspect request/response types given the full name of the type 
+(in the format of `<package>.<type>`).
+
+Get information about the request type:
+
+  ```
+$ grpcurl -plaintext localhost:50051 describe helloworld.HelloRequest
+  ```
+
+Output
+
+  ```
+  helloworld.HelloRequest is a message:
+  message HelloRequest {
+    string name = 1;
+  }
+  ```
+
+### Call a remote method
+
+We can send RPCs to a server and get responses using the full method name
+(in the format of `<package>.<service>.<method>`). The `-d <string>` flag represents the request data
+and the -format text flag indicates that the request data is in text format.
+
+  ```
+  $ grpcurl -plaintext -format text -d 'name: "gRPCurl"' \
+    localhost:50051 helloworld.Greeter.SayHello
+  ```
+
+Output
+
+  ```
+  message: "Hello gRPCurl"
+  ```
diff --git a/examples/example-reflection/build.gradle b/examples/example-reflection/build.gradle
new file mode 100644
index 00000000000..c06f276c2a0
--- /dev/null
+++ b/examples/example-reflection/build.gradle
@@ -0,0 +1,55 @@
+plugins {
+    id 'application' // Provide convenience executables for trying out the examples.
+    id 'com.google.protobuf' version '0.9.5'
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+    id 'java'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protocVersion = '3.25.8'
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-services:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    implementation "io.grpc:grpc-netty-shaded:${grpcVersion}"
+}
+
+protobuf {
+    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
+    plugins {
+        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
+    }
+    generateProtoTasks {
+        all()*.plugins { grpc {} }
+    }
+}
+
+startScripts.enabled = false
+
+task ReflectionServer(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.reflection.ReflectionServer'
+    applicationName = 'reflection-server'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into('bin') {
+        from(ReflectionServer)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
diff --git a/examples/example-reflection/settings.gradle b/examples/example-reflection/settings.gradle
new file mode 100644
index 00000000000..28e44b77905
--- /dev/null
+++ b/examples/example-reflection/settings.gradle
@@ -0,0 +1,17 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+}
+
+rootProject.name = 'example-reflection'
diff --git a/examples/example-reflection/src/main/java/io/grpc/examples/reflection/ReflectionServer.java b/examples/example-reflection/src/main/java/io/grpc/examples/reflection/ReflectionServer.java
new file mode 100644
index 00000000000..8406317aad6
--- /dev/null
+++ b/examples/example-reflection/src/main/java/io/grpc/examples/reflection/ReflectionServer.java
@@ -0,0 +1,81 @@
+
+package io.grpc.examples.reflection;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.protobuf.services.ProtoReflectionServiceV1;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * Server that manages startup/shutdown of a {@code Greeter} server.
+ */
+public class ReflectionServer {
+  private static final Logger logger = Logger.getLogger(ReflectionServer.class.getName());
+
+  private Server server;
+
+  private void start() throws IOException {
+    /* The port on which the server should run */
+    int port = 50051;
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new GreeterImpl())
+        .addService(ProtoReflectionServiceV1.newInstance()) // add reflection service
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          ReflectionServer.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** server shut down");
+      }
+    });
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    final ReflectionServer server = new ReflectionServer();
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/examples/example-reflection/src/main/proto/helloworld/helloworld.proto b/examples/example-reflection/src/main/proto/helloworld/helloworld.proto
new file mode 100644
index 00000000000..77184aa8326
--- /dev/null
+++ b/examples/example-reflection/src/main/proto/helloworld/helloworld.proto
@@ -0,0 +1,37 @@
+// Copyright 2022 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/example-servlet/README.md b/examples/example-servlet/README.md
new file mode 100644
index 00000000000..f2e6188069a
--- /dev/null
+++ b/examples/example-servlet/README.md
@@ -0,0 +1,37 @@
+# Hello World Example using Servlets
+
+This example uses Java Servlets instead of Netty for the gRPC server. This example requires `grpc-java`
+and `protoc-gen-grpc-java` to already be built. You are strongly encouraged to check out a git release
+tag, since these builds will already be available.
+
+```bash
+git checkout v<major>.<minor>.<patch>
+```
+Otherwise, you must follow [COMPILING](../../COMPILING.md).
+
+To build the example,
+
+1. **[Install gRPC Java library SNAPSHOT locally, including code generation plugin](../../COMPILING.md) (Only need this step for non-released versions, e.g. master HEAD).**
+
+2. In this directory, build the war file
+```bash
+$ ../gradlew war
+```
+
+To run this, deploy the war, now found in `build/libs/example-servlet.war` to your choice of servlet 
+container. Note that this container must support the Servlet 4.0 spec, for this particular example must
+use `javax.servlet` packages instead of the more modern `jakarta.servlet`, though there is a `grpc-servlet-jakarta`
+artifact that can be used for Jakarta support. Be sure to enable http/2 support in the servlet container,
+or clients will not be able to connect.
+
+To test that this is working properly, build the HelloWorldClient example and direct it to connect to your
+http/2 server. From the parent directory:
+
+1. Build the executables:
+```bash
+$ ../gradlew installDist
+```
+2. Run the client app, specifying the name to say hello to and the server's address:
+```bash
+$ ./build/install/examples/bin/hello-world-client World localhost:8080
+```
\ No newline at end of file
diff --git a/examples/example-servlet/build.gradle b/examples/example-servlet/build.gradle
new file mode 100644
index 00000000000..a41e998a455
--- /dev/null
+++ b/examples/example-servlet/build.gradle
@@ -0,0 +1,35 @@
+plugins {
+    id 'com.google.protobuf' version '0.9.5'
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+    id 'war'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protocVersion = '3.25.8'
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}",
+            "io.grpc:grpc-servlet:${grpcVersion}",
+            "io.grpc:grpc-stub:${grpcVersion}"
+
+    compileOnly "javax.servlet:javax.servlet-api:4.0.1"
+}
+
+protobuf {
+    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
+    plugins { grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" } }
+    generateProtoTasks {
+        all()*.plugins { grpc {} }
+    }
+}
diff --git a/examples/example-servlet/settings.gradle b/examples/example-servlet/settings.gradle
new file mode 100644
index 00000000000..6bd0f0cdc2d
--- /dev/null
+++ b/examples/example-servlet/settings.gradle
@@ -0,0 +1,19 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+
+    repositories {
+        gradlePluginPortal()
+    }
+}
diff --git a/examples/example-servlet/src/main/java/io/grpc/servlet/examples/helloworld/HelloWorldServlet.java b/examples/example-servlet/src/main/java/io/grpc/servlet/examples/helloworld/HelloWorldServlet.java
new file mode 100644
index 00000000000..a970c26a119
--- /dev/null
+++ b/examples/example-servlet/src/main/java/io/grpc/servlet/examples/helloworld/HelloWorldServlet.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2018 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.servlet.examples.helloworld;
+
+import io.grpc.stub.StreamObserver;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.servlet.ServletAdapter;
+import io.grpc.servlet.ServletServerBuilder;
+import java.io.IOException;
+import javax.servlet.annotation.WebServlet;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * A servlet that hosts a gRPC server over HTTP/2 and shares the resource URI for the normal servlet
+ * clients over HTTP/1.0+.
+ *
+ * <p>For creating a servlet that solely serves gRPC services, do not follow this example, simply
+ * extend or register a {@link io.grpc.servlet.GrpcServlet} instead.
+ */
+@WebServlet(urlPatterns = {"/helloworld.Greeter/SayHello"}, asyncSupported = true)
+public class HelloWorldServlet extends HttpServlet {
+  private static final long serialVersionUID = 1L;
+
+  private final ServletAdapter servletAdapter =
+      new ServletServerBuilder().addService(new GreeterImpl()).buildServletAdapter();
+
+  private static final class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+    GreeterImpl() {}
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+
+  @Override
+  protected void doGet(HttpServletRequest request, HttpServletResponse response)
+      throws IOException {
+    response.setContentType("text/html");
+    response.getWriter().println("<p>Hello World!</p>");
+  }
+
+  @Override
+  protected void doPost(HttpServletRequest request, HttpServletResponse response)
+      throws IOException {
+    if (ServletAdapter.isGrpc(request)) {
+      servletAdapter.doPost(request, response);
+    } else {
+      response.setContentType("text/html");
+      response.getWriter().println("<p>Hello non-gRPC client!</p>");
+    }
+  }
+
+  @Override
+  public void destroy() {
+    servletAdapter.destroy();
+    super.destroy();
+  }
+}
diff --git a/examples/example-servlet/src/main/proto/helloworld/helloworld.proto b/examples/example-servlet/src/main/proto/helloworld/helloworld.proto
new file mode 100644
index 00000000000..c60d9416f1f
--- /dev/null
+++ b/examples/example-servlet/src/main/proto/helloworld/helloworld.proto
@@ -0,0 +1,37 @@
+// Copyright 2015 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/example-servlet/src/main/webapp/WEB-INF/glassfish-web.xml b/examples/example-servlet/src/main/webapp/WEB-INF/glassfish-web.xml
new file mode 100644
index 00000000000..426162a9d13
--- /dev/null
+++ b/examples/example-servlet/src/main/webapp/WEB-INF/glassfish-web.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Need this file for deployment to GlassFish -->
+<!DOCTYPE glassfish-web-app PUBLIC "-//GlassFish.org//DTD GlassFish Application Server 3.1 Servlet 3.0//EN" "http://glassfish.org/dtds/glassfish-web-app_3_0-1.dtd">
+<glassfish-web-app error-url="">
+   <class-loader delegate="false"/>
+</glassfish-web-app>
diff --git a/examples/example-servlet/src/main/webapp/WEB-INF/jboss-web.xml b/examples/example-servlet/src/main/webapp/WEB-INF/jboss-web.xml
new file mode 100644
index 00000000000..9c83263e0c9
--- /dev/null
+++ b/examples/example-servlet/src/main/webapp/WEB-INF/jboss-web.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Need this file for deployment to WildFly  -->
+<jboss-web xmlns="http://www.jboss.com/xml/ns/javaee"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="
+  http://www.jboss.com/xml/ns/javaee
+  http://www.jboss.org/j2ee/schema/jboss-web_5_1.xsd">
+  <context-root>/</context-root>
+</jboss-web>
diff --git a/examples/example-tls/BUILD.bazel b/examples/example-tls/BUILD.bazel
new file mode 100644
index 00000000000..cb46ef5bb30
--- /dev/null
+++ b/examples/example-tls/BUILD.bazel
@@ -0,0 +1,60 @@
+load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library")
+load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library")
+load("@io_grpc_grpc_java//:java_grpc_library.bzl", "java_grpc_library")
+load("@rules_java//java:java_binary.bzl", "java_binary")
+load("@rules_java//java:java_library.bzl", "java_library")
+
+proto_library(
+    name = "helloworld_proto",
+    srcs = ["src/main/proto/helloworld/helloworld.proto"],
+)
+
+java_proto_library(
+    name = "helloworld_java_proto",
+    deps = [":helloworld_proto"],
+)
+
+java_grpc_library(
+    name = "helloworld_java_grpc",
+    srcs = [":helloworld_proto"],
+    deps = [":helloworld_java_proto"],
+)
+
+java_library(
+    name = "example-tls",
+    testonly = 1,
+    srcs = glob(
+        ["src/main/java/**/*.java"],
+    ),
+    runtime_deps = [
+        "@maven//:io_netty_netty_tcnative_boringssl_static",
+        "@maven//:io_netty_netty_tcnative_classes",
+    ],
+    deps = [
+        ":helloworld_java_grpc",
+        ":helloworld_java_proto",
+        "@io_grpc_grpc_java//api",
+        "@io_grpc_grpc_java//netty",
+        "@io_grpc_grpc_java//protobuf",
+        "@io_grpc_grpc_java//stub",
+        "@maven//:io_netty_netty_handler",
+    ],
+)
+
+java_binary(
+    name = "hello-world-tls-client",
+    testonly = 1,
+    main_class = "io.grpc.examples.helloworldtls.HelloWorldClientTls",
+    runtime_deps = [
+        ":example-tls",
+    ],
+)
+
+java_binary(
+    name = "hello-world-tls-server",
+    testonly = 1,
+    main_class = "io.grpc.examples.helloworldtls.HelloWorldServerTls",
+    runtime_deps = [
+        ":example-tls",
+    ],
+)
diff --git a/examples/example-tls/README.md b/examples/example-tls/README.md
new file mode 100644
index 00000000000..6bbf89224fd
--- /dev/null
+++ b/examples/example-tls/README.md
@@ -0,0 +1,95 @@
+Hello World Example with TLS
+==============================================
+
+The example require grpc-java to already be built. You are strongly encouraged
+to **check out a git release tag**, since there will already be a build of grpc
+available:
+```
+git checkout v<major>.<minor>.<patch>
+```
+
+Otherwise you must follow [COMPILING](../COMPILING.md).
+
+To build the example,
+
+1. **[Install gRPC Java library SNAPSHOT locally, including code generation plugin](../../COMPILING.md) (Only need this step for non-released versions, e.g. master HEAD).**
+
+2. Run in this directory:
+```
+$ ../gradlew installDist
+```
+
+This creates the scripts `hello-world-tls-server`, `hello-world-tls-client`,
+in the
+`build/install/example-tls/bin/` directory that run the example. The
+example requires the server to be running before starting the client.
+
+Running the hello world with TLS is the same as the normal hello world, but takes additional args:
+
+**hello-world-tls-server**:
+
+```text
+USAGE: HelloWorldServerTls port certChainFilePath privateKeyFilePath [trustCertCollectionFilePath]
+  Note: You only need to supply trustCertCollectionFilePath if you want to enable Mutual TLS.
+```
+
+**hello-world-tls-client**:
+
+```text
+USAGE: HelloWorldClientTls host port [trustCertCollectionFilePath [clientCertChainFilePath clientPrivateKeyFilePath]]
+  Note: clientCertChainFilePath and clientPrivateKeyFilePath are only needed if mutual auth is desired.
+```
+- Note `trustCertCollectionFilePath` is not needed if you are using system default certificate authority.
+
+You can run this example with our [test credentials](../../testing/src/main/resources/certs) with 
+`.overrideAuthority("foo.test.google.fr")` for `ManagedChannelBuilder` to match the Subject Alternative Names
+in the test certificates. You can generate your own self-signed certificates with commands in the test certs
+[README](../../testing/src/main/resources/certs/README).
+
+- Note you can use system default certificate authority if you are using a real server certificate.
+
+#### Hello world example with TLS (no mutual auth):
+
+```bash
+# Run the server:
+./build/install/example-tls/bin/hello-world-tls-server 50440 ../../testing/src/main/resources/certs/server1.pem ../../testing/src/main/resources/certs/server1.key
+# In another terminal run the client
+./build/install/example-tls/bin/hello-world-tls-client localhost 50440 ../../testing/src/main/resources/certs/ca.pem
+```
+
+#### Hello world example with TLS with mutual auth:
+
+```bash
+# Run the server:
+./build/install/example-tls/bin/hello-world-tls-server 50440 ../../testing/src/main/resources/certs/server1.pem ../../testing/src/main/resources/certs/server1.key ../../testing/src/main/resources/certs/ca.pem
+# In another terminal run the client
+./build/install/example-tls/bin/hello-world-tls-client localhost 50440 ../../testing/src/main/resources/certs/ca.pem ../../testing/src/main/resources/certs/client.pem ../../testing/src/main/resources/certs/client.key
+```
+
+That's it!
+
+## Maven
+
+If you prefer to use Maven:
+
+1. **[Install gRPC Java library SNAPSHOT locally, including code generation plugin](../../COMPILING.md) (Only need this step for non-released versions, e.g. master HEAD).**
+
+2. Run in this directory:
+```
+$ mvn verify
+$ # Run the server
+$ mvn exec:java -Dexec.mainClass=io.grpc.examples.helloworldtls.HelloWorldServerTls -Dexec.args="50440 ../../testing/src/main/resources/certs/server1.pem ../../testing/src/main/resources/certs/server1.key"
+$ # In another terminal run the client
+$ mvn exec:java -Dexec.mainClass=io.grpc.examples.helloworldtls.HelloWorldClientTls -Dexec.args="localhost 50440 ../../testing/src/main/resources/certs/ca.pem"
+```
+
+## Bazel
+
+If you prefer to use Bazel:
+```
+$ bazel build :hello-world-tls-server :hello-world-tls-client
+$ # Run the server
+$ ../bazel-bin/hello-world-tls-server 50440 ../../testing/src/main/resources/certs/server1.pem ../../testing/src/main/resources/certs/server1.key
+$ # In another terminal run the client
+$ ../bazel-bin/hello-world-tls-client localhost 50440 ../../testing/src/main/resources/certs/ca.pem
+```
diff --git a/examples/example-tls/build.gradle b/examples/example-tls/build.gradle
new file mode 100644
index 00000000000..8d410146570
--- /dev/null
+++ b/examples/example-tls/build.gradle
@@ -0,0 +1,67 @@
+plugins {
+    // Provide convenience executables for trying out the examples.
+    id 'application'
+    id 'com.google.protobuf' version '0.9.5'
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
+// are looking at a tagged version of the example and not "master"!
+
+// Feel free to delete the comment at the next line. It is just for safely
+// updating the version in our release process.
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protocVersion = '3.25.8'
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
+}
+
+protobuf {
+    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
+    plugins {
+        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
+    }
+    generateProtoTasks {
+        all()*.plugins { grpc {} }
+    }
+}
+
+startScripts.enabled = false
+
+task helloWorldTlsServer(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.helloworldtls.HelloWorldServerTls'
+    applicationName = 'hello-world-tls-server'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+task helloWorldTlsClient(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.helloworldtls.HelloWorldClientTls'
+    applicationName = 'hello-world-tls-client'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into('bin') {
+        from(helloWorldTlsServer)
+        from(helloWorldTlsClient)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
diff --git a/examples/example-tls/pom.xml b/examples/example-tls/pom.xml
new file mode 100644
index 00000000000..9dd823ad563
--- /dev/null
+++ b/examples/example-tls/pom.xml
@@ -0,0 +1,96 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>io.grpc</groupId>
+  <artifactId>example-tls</artifactId>
+  <packaging>jar</packaging>
+  <!-- Feel free to delete the comment at the end of these lines. It is just
+       for safely updating the version in our release process. -->
+  <version>1.80.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
+  <name>example-tls</name>
+  <url>https://github.com/grpc/grpc-java</url>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <grpc.version>1.80.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
+    <protoc.version>3.25.8</protoc.version>
+    <!-- required for jdk9 -->
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+  </properties>
+
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>io.grpc</groupId>
+        <artifactId>grpc-bom</artifactId>
+        <version>${grpc.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+
+  <dependencies>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-protobuf</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-stub</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-netty-shaded</artifactId>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <extensions>
+      <extension>
+        <groupId>kr.motd.maven</groupId>
+        <artifactId>os-maven-plugin</artifactId>
+        <version>1.7.1</version>
+      </extension>
+    </extensions>
+    <plugins>
+      <plugin>
+        <groupId>org.xolstice.maven.plugins</groupId>
+        <artifactId>protobuf-maven-plugin</artifactId>
+        <version>0.6.1</version>
+        <configuration>
+          <protocArtifact>com.google.protobuf:protoc:${protoc.version}:exe:${os.detected.classifier}</protocArtifact>
+          <pluginId>grpc-java</pluginId>
+          <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
+        </configuration>
+        <executions>
+          <execution>
+            <goals>
+              <goal>compile</goal>
+              <goal>compile-custom</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-enforcer-plugin</artifactId>
+        <version>3.5.0</version>
+        <executions>
+          <execution>
+            <id>enforce</id>
+            <goals>
+              <goal>enforce</goal>
+            </goals>
+            <configuration>
+              <rules>
+                <requireUpperBoundDeps/>
+              </rules>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>
diff --git a/examples/example-tls/settings.gradle b/examples/example-tls/settings.gradle
new file mode 100644
index 00000000000..6bd0f0cdc2d
--- /dev/null
+++ b/examples/example-tls/settings.gradle
@@ -0,0 +1,19 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+
+    repositories {
+        gradlePluginPortal()
+    }
+}
diff --git a/examples/example-tls/src/main/java/io/grpc/examples/helloworldtls/HelloWorldClientTls.java b/examples/example-tls/src/main/java/io/grpc/examples/helloworldtls/HelloWorldClientTls.java
new file mode 100644
index 00000000000..4ff7e23a299
--- /dev/null
+++ b/examples/example-tls/src/main/java/io/grpc/examples/helloworldtls/HelloWorldClientTls.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright 2015 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.examples.helloworldtls;
+
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.ManagedChannel;
+import io.grpc.StatusRuntimeException;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import java.io.File;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A simple client that requests a greeting from the {@link HelloWorldServerTls} with TLS.
+ */
+public class HelloWorldClientTls {
+    private static final Logger logger = Logger.getLogger(HelloWorldClientTls.class.getName());
+
+    private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+    /**
+     * Construct client for accessing RouteGuide server using the existing channel.
+     */
+    public HelloWorldClientTls(Channel channel) {
+        blockingStub = GreeterGrpc.newBlockingStub(channel);
+    }
+
+    /**
+     * Say hello to server.
+     */
+    public void greet(String name) {
+        logger.info("Will try to greet " + name + " ...");
+        HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+        HelloReply response;
+        try {
+            response = blockingStub.sayHello(request);
+        } catch (StatusRuntimeException e) {
+            logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+            return;
+        }
+        logger.info("Greeting: " + response.getMessage());
+    }
+
+    /**
+     * Greet server. If provided, the first element of {@code args} is the name to use in the
+     * greeting.
+     */
+    public static void main(String[] args) throws Exception {
+
+        if (args.length < 2 || args.length == 4 || args.length > 5) {
+            System.out.println("USAGE: HelloWorldClientTls host port [trustCertCollectionFilePath " +
+                    "[clientCertChainFilePath clientPrivateKeyFilePath]]\n  Note: clientCertChainFilePath and " +
+                    "clientPrivateKeyFilePath are only needed if mutual auth is desired.");
+            System.exit(0);
+        }
+
+        // If only defaults are necessary, you can use TlsChannelCredentials.create() instead of
+        // interacting with the Builder.
+        TlsChannelCredentials.Builder tlsBuilder = TlsChannelCredentials.newBuilder();
+        switch (args.length) {
+            case 5:
+                tlsBuilder.keyManager(new File(args[3]), new File(args[4]));
+                // fallthrough
+            case 3:
+                tlsBuilder.trustManager(new File(args[2]));
+                // fallthrough
+            default:
+        }
+        String host = args[0];
+        int port = Integer.parseInt(args[1]);
+        ManagedChannel channel = Grpc.newChannelBuilderForAddress(host, port, tlsBuilder.build())
+                /* Only for using provided test certs. */
+                .overrideAuthority("foo.test.google.fr")
+                .build();
+        try {
+            HelloWorldClientTls client = new HelloWorldClientTls(channel);
+            client.greet(host);
+        } finally {
+            channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+        }
+    }
+}
diff --git a/examples/example-tls/src/main/java/io/grpc/examples/helloworldtls/HelloWorldServerTls.java b/examples/example-tls/src/main/java/io/grpc/examples/helloworldtls/HelloWorldServerTls.java
new file mode 100644
index 00000000000..83ac012cc99
--- /dev/null
+++ b/examples/example-tls/src/main/java/io/grpc/examples/helloworldtls/HelloWorldServerTls.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2015 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.examples.helloworldtls;
+
+import io.grpc.Grpc;
+import io.grpc.Server;
+import io.grpc.ServerCredentials;
+import io.grpc.TlsServerCredentials;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+import java.io.File;
+import java.io.IOException;
+import java.util.logging.Logger;
+
+/**
+ * Server that manages startup/shutdown of a {@code Greeter} server with TLS enabled.
+ */
+public class HelloWorldServerTls {
+    private static final Logger logger = Logger.getLogger(HelloWorldServerTls.class.getName());
+
+    private Server server;
+
+    private final int port;
+    private final ServerCredentials creds;
+
+    public HelloWorldServerTls(int port, ServerCredentials creds) {
+        this.port = port;
+        this.creds = creds;
+    }
+
+    private void start() throws IOException {
+        server = Grpc.newServerBuilderForPort(port, creds)
+                .addService(new GreeterImpl())
+                .build()
+                .start();
+        logger.info("Server started, listening on " + port);
+        Runtime.getRuntime().addShutdownHook(new Thread() {
+            @Override
+            public void run() {
+                // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+                System.err.println("*** shutting down gRPC server since JVM is shutting down");
+                HelloWorldServerTls.this.stop();
+                System.err.println("*** server shut down");
+            }
+        });
+    }
+
+    private void stop() {
+        if (server != null) {
+            server.shutdown();
+        }
+    }
+
+    /**
+     * Await termination on the main thread since the grpc library uses daemon threads.
+     */
+    private void blockUntilShutdown() throws InterruptedException {
+        if (server != null) {
+            server.awaitTermination();
+        }
+    }
+
+    /**
+     * Main launches the server from the command line.
+     */
+    public static void main(String[] args) throws IOException, InterruptedException {
+
+        if (args.length < 3 || args.length > 4) {
+            System.out.println(
+                    "USAGE: HelloWorldServerTls port certChainFilePath privateKeyFilePath " +
+                    "[trustCertCollectionFilePath]\n  Note: You only need to supply trustCertCollectionFilePath if you want " +
+                    "to enable Mutual TLS.");
+            System.exit(0);
+        }
+
+        // If only providing a private key, you can use TlsServerCredentials.create() instead of
+        // interacting with the Builder.
+        TlsServerCredentials.Builder tlsBuilder = TlsServerCredentials.newBuilder()
+            .keyManager(new File(args[1]), new File(args[2]));
+        if (args.length == 4) {
+            tlsBuilder.trustManager(new File(args[3]));
+            tlsBuilder.clientAuth(TlsServerCredentials.ClientAuth.REQUIRE);
+        }
+        final HelloWorldServerTls server = new HelloWorldServerTls(
+                Integer.parseInt(args[0]), tlsBuilder.build());
+        server.start();
+        server.blockUntilShutdown();
+    }
+
+    static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+        @Override
+        public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+            HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+            responseObserver.onNext(reply);
+            responseObserver.onCompleted();
+        }
+    }
+}
diff --git a/examples/example-tls/src/main/proto/helloworld/helloworld.proto b/examples/example-tls/src/main/proto/helloworld/helloworld.proto
new file mode 100644
index 00000000000..c60d9416f1f
--- /dev/null
+++ b/examples/example-tls/src/main/proto/helloworld/helloworld.proto
@@ -0,0 +1,37 @@
+// Copyright 2015 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/example-xds/README.md b/examples/example-xds/README.md
new file mode 100644
index 00000000000..92b91ea0851
--- /dev/null
+++ b/examples/example-xds/README.md
@@ -0,0 +1,70 @@
+gRPC XDS Example
+================
+
+The XDS example consists of a Hello World client and a Hello World server capable of
+being configured with the XDS management protocol. Out-of-the-box the client
+behaves the same the hello-world version and the server behaves similar to the
+example-hostname but with a required dependency on xDS.
+
+__XDS support is incomplete and experimental, with limited compatibility. It
+will be very hard to produce a working environment just by this example. Please
+refer to documentation specific for your XDS management server and
+environment.__
+
+### Build the example
+
+Build the XDS hello-world example client & server. From the `grpc-java/examples/examples-xds`
+directory:
+```
+$ ../gradlew installDist
+```
+
+This creates the scripts `build/install/example-xds/bin/xds-hello-world-client` and
+`build/install/example-xds/bin/xds-hello-world-server`.
+
+### Run the example without using XDS Credentials
+
+To use XDS, you should first deploy the XDS management server in your deployment environment
+and know its name. You need to set the `GRPC_XDS_BOOTSTRAP` environment variable (preferred) or if that is not set then
+the `io.grpc.xds.bootstrap` java system property to point to the gRPC XDS bootstrap file (see
+[gRFC A27](https://github.com/grpc/proposal/blob/master/A27-xds-global-load-balancing.md#xdsclient-and-bootstrap-file) for the
+bootstrap format). This is needed by both `build/install/example-xds/bin/xds-hello-world-client`
+and `build/install/example-xds/bin/xds-hello-world-server`.
+
+1. To start the XDS-enabled example server on its default port of 50051, run:
+```
+$ export GRPC_XDS_BOOTSTRAP=/path/to/bootstrap.json
+$ ./build/install/example-xds/bin/xds-hello-world-server
+```
+
+2. In a different terminal window, run the XDS-enabled example client:
+```
+$ export GRPC_XDS_BOOTSTRAP=/path/to/bootstrap.json
+$ ./build/install/example-xds/bin/xds-hello-world-client "xds world" xds:///yourServersName
+```
+The first command line argument (`xds world`) is the name you wish to include in
+the greeting request to the server and the second argument
+(`xds:///yourServersName`) is the target to connect to using the `xds:` target
+scheme.
+
+### Run the example with xDS Credentials
+
+The above example used plaintext (insecure) credentials as explicitly provided by the client and server
+code. We will now demonstrate how the code can authorize use of xDS provided credentials by using
+`XdsChannelCredentials` on the client side and using `XdsServerCredentials` on the server side.
+This code is enabled by providing an additional command line argument.
+
+1. On the server side, add `--xds-creds` on the command line to authorize use of xDS security:
+```
+$ export GRPC_XDS_BOOTSTRAP=/path/to/bootstrap.json
+$ ./build/install/example-xds/bin/xds-hello-world-server --xds-creds
+```
+
+2. Similarly, add `--xds-creds` on the command line when you run the xDS client:
+```
+$ export GRPC_XDS_BOOTSTRAP=/path/to/bootstrap.json
+$ ./build/install/example-xds/bin/xds-hello-world-client --xds-creds "xds world" xds:///yourServersName
+```
+
+In this case, if the xDS management server is configured to provide mTLS credentials (for example) to the client and
+server, then they will use these credentials to create an mTLS channel to authenticate and encrypt.
diff --git a/examples/example-xds/build.gradle b/examples/example-xds/build.gradle
new file mode 100644
index 00000000000..f04cedc5a74
--- /dev/null
+++ b/examples/example-xds/build.gradle
@@ -0,0 +1,70 @@
+plugins {
+    id 'application' // Provide convenience executables for trying out the examples.
+    id 'com.google.protobuf' version '0.9.5'
+    // Generate IntelliJ IDEA's .idea & .iml project files
+    id 'idea'
+    id 'java'
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+// IMPORTANT: You probably want the non-SNAPSHOT version of gRPC. Make sure you
+// are looking at a tagged version of the example and not "master"!
+
+// Feel free to delete the comment at the next line. It is just for safely
+// updating the version in our release process.
+def grpcVersion = '1.80.0-SNAPSHOT' // CURRENT_GRPC_VERSION
+def protocVersion = '3.25.8'
+
+dependencies {
+    implementation "io.grpc:grpc-protobuf:${grpcVersion}"
+    implementation "io.grpc:grpc-services:${grpcVersion}"
+    implementation "io.grpc:grpc-stub:${grpcVersion}"
+    implementation "io.grpc:grpc-xds:${grpcVersion}"
+
+    runtimeOnly "io.grpc:grpc-netty-shaded:${grpcVersion}"
+}
+
+protobuf {
+    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
+    plugins {
+        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
+    }
+    generateProtoTasks {
+        all()*.plugins { grpc {} }
+    }
+}
+
+startScripts.enabled = false
+
+task xdsHelloWorldClient(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.helloworldxds.XdsHelloWorldClient'
+    applicationName = 'xds-hello-world-client'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+task xdsHelloWorldServer(type: CreateStartScripts) {
+    mainClass = 'io.grpc.examples.helloworldxds.XdsHelloWorldServer'
+    applicationName = 'xds-hello-world-server'
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into('bin') {
+        from(xdsHelloWorldClient)
+        from(xdsHelloWorldServer)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
diff --git a/examples/example-xds/settings.gradle b/examples/example-xds/settings.gradle
new file mode 100644
index 00000000000..4197fa6760d
--- /dev/null
+++ b/examples/example-xds/settings.gradle
@@ -0,0 +1,17 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+}
+
+rootProject.name = 'example-xds'
diff --git a/examples/example-xds/src/main/java/io/grpc/examples/helloworldxds/HostnameGreeter.java b/examples/example-xds/src/main/java/io/grpc/examples/helloworldxds/HostnameGreeter.java
new file mode 100644
index 00000000000..9ea1f25a989
--- /dev/null
+++ b/examples/example-xds/src/main/java/io/grpc/examples/helloworldxds/HostnameGreeter.java
@@ -0,0 +1,60 @@
+/*
+ * 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.examples.helloworldxds;
+
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.util.Random;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/** Greeter implementation which replies identifying itself with its hostname. */
+public final class HostnameGreeter extends GreeterGrpc.GreeterImplBase {
+  private static final Logger logger = Logger.getLogger(HostnameGreeter.class.getName());
+
+  private final String serverName;
+
+  public HostnameGreeter(String serverName) {
+    if (serverName == null) {
+      serverName = determineHostname();
+    }
+    this.serverName = serverName;
+  }
+
+  @Override
+  public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+    HelloReply reply = HelloReply.newBuilder()
+        .setMessage("Hello " + req.getName() + ", from " + serverName)
+        .build();
+    responseObserver.onNext(reply);
+    responseObserver.onCompleted();
+  }
+
+  private static String determineHostname() {
+    try {
+      return InetAddress.getLocalHost().getHostName();
+    } catch (IOException ex) {
+      logger.log(Level.INFO, "Failed to determine hostname. Will generate one", ex);
+    }
+    // Strange. Well, let's make an identifier for ourselves.
+    return "generated-" + new Random().nextInt();
+  }
+}
diff --git a/examples/example-xds/src/main/java/io/grpc/examples/helloworldxds/XdsHelloWorldClient.java b/examples/example-xds/src/main/java/io/grpc/examples/helloworldxds/XdsHelloWorldClient.java
new file mode 100644
index 00000000000..70c684746cf
--- /dev/null
+++ b/examples/example-xds/src/main/java/io/grpc/examples/helloworldxds/XdsHelloWorldClient.java
@@ -0,0 +1,109 @@
+/*
+ * 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.examples.helloworldxds;
+
+import io.grpc.Channel;
+import io.grpc.ChannelCredentials;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.xds.XdsChannelCredentials;
+import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A simple xDS client that requests a greeting from {@code HelloWorldServer} or {@link
+ * XdsHelloWorldServer}.
+ */
+public class XdsHelloWorldClient {
+  private static final Logger logger = Logger.getLogger(XdsHelloWorldClient.class.getName());
+
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+  /** Construct client for accessing HelloWorld server using the existing channel. */
+  public XdsHelloWorldClient(Channel channel) {
+    blockingStub = GreeterGrpc.newBlockingStub(channel);
+  }
+
+  /** Say hello to server. */
+  public void greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response;
+    try {
+      response = blockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    logger.info("Greeting: " + response.getMessage());
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the
+   * greeting. The second argument is the target server. A {@code --xds-creds} flag is also accepted.
+   */
+  public static void main(String[] args) throws Exception {
+    String user = "xds world";
+    // The example defaults to the same behavior as the hello world example. To enable xDS, pass an
+    // "xds:"-prefixed string as the target.
+    String target = "localhost:50051";
+    ChannelCredentials credentials = InsecureChannelCredentials.create();
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.out.println("Usage: [--xds-creds] [NAME [TARGET]]");
+        System.out.println("");
+        System.err.println("  --xds-creds  Use credentials provided by xDS. Defaults to insecure");
+        System.out.println("");
+        System.err.println("  NAME    The name you wish to be greeted by. Defaults to " + user);
+        System.err.println("  TARGET  The server to connect to. Defaults to " + target);
+        System.exit(1);
+      } else if ("--xds-creds".equals(args[0])) {
+        // The xDS credentials use the security configured by the xDS server when available. When
+        // xDS is not used or when xDS does not provide security configuration, the xDS credentials
+        // fall back to other credentials (in this case, InsecureChannelCredentials).
+        credentials = XdsChannelCredentials.create(InsecureChannelCredentials.create());
+        args = Arrays.copyOfRange(args, 1, args.length);
+      }
+    }
+    if (args.length > 0) {
+      user = args[0];
+    }
+    if (args.length > 1) {
+      target = args[1];
+    }
+
+    // This uses the new ChannelCredentials API. Grpc.newChannelBuilder() is the same as
+    // ManagedChannelBuilder.forTarget(), except that it is passed credentials. When using this API,
+    // you don't use methods like `managedChannelBuilder.usePlaintext()`, as that configuration is
+    // provided by the ChannelCredentials.
+    ManagedChannel channel = Grpc.newChannelBuilder(target, credentials)
+        .build();
+    try {
+      XdsHelloWorldClient client = new XdsHelloWorldClient(channel);
+      client.greet(user);
+    } finally {
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+    }
+  }
+}
diff --git a/examples/example-xds/src/main/java/io/grpc/examples/helloworldxds/XdsHelloWorldServer.java b/examples/example-xds/src/main/java/io/grpc/examples/helloworldxds/XdsHelloWorldServer.java
new file mode 100644
index 00000000000..c7c67f8d681
--- /dev/null
+++ b/examples/example-xds/src/main/java/io/grpc/examples/helloworldxds/XdsHelloWorldServer.java
@@ -0,0 +1,110 @@
+/*
+ * 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.examples.helloworldxds;
+
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.ServerCredentials;
+import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
+import io.grpc.protobuf.services.ProtoReflectionServiceV1;
+import io.grpc.services.HealthStatusManager;
+import io.grpc.xds.XdsServerBuilder;
+import io.grpc.xds.XdsServerCredentials;
+import java.util.Arrays;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * An xDS-managed Server for the {@code Greeter} service.
+ */
+public class XdsHelloWorldServer {
+  public static void main(String[] args) throws IOException, InterruptedException {
+    int port = 50051;
+    String hostname = null;
+    ServerCredentials credentials = InsecureServerCredentials.create();
+    if (args.length >= 1 && "--xds-creds".equals(args[0])) {
+      // The xDS credentials use the security configured by the xDS server when available. When xDS
+      // is not used or when xDS does not provide security configuration, the xDS credentials fall
+      // back to other credentials (in this case, InsecureServerCredentials).
+      credentials = XdsServerCredentials.create(InsecureServerCredentials.create());
+      args = Arrays.copyOfRange(args, 1, args.length);
+    }
+    if (args.length >= 1) {
+      try {
+        port = Integer.parseInt(args[0]);
+      } catch (NumberFormatException ex) {
+        System.err.println("Usage: [--xds-creds] [PORT [HOSTNAME]]");
+        System.err.println("");
+        System.err.println("  --xds-creds  Use credentials provided by xDS. Defaults to insecure");
+        System.err.println("");
+        System.err.println("  PORT      The listen port. Defaults to " + port);
+        System.err.println("  HOSTNAME  The name clients will see in greet responses. ");
+        System.err.println("            Defaults to the machine's hostname");
+        System.exit(1);
+      }
+    }
+    if (args.length >= 2) {
+      hostname = args[1];
+    }
+    // Since the main server may be using TLS, we start a second server just for plaintext health
+    // checks
+    int healthPort = port + 1;
+    final HealthStatusManager health = new HealthStatusManager();
+    final Server server = XdsServerBuilder.forPort(port, credentials)
+        .addService(new HostnameGreeter(hostname))
+        .addService(ProtoReflectionServiceV1.newInstance()) // convenient for command line tools
+        .addService(health.getHealthService()) // allow management servers to monitor health
+        .build()
+        .start();
+    final Server healthServer =
+        XdsServerBuilder.forPort(healthPort, InsecureServerCredentials.create())
+        .addService(health.getHealthService()) // allow management servers to monitor health
+        .build()
+        .start();
+    System.out.println("Listening on port " + port);
+    System.out.println("Plaintext health service listening on port " + healthPort);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        health.setStatus("", ServingStatus.NOT_SERVING);
+        // Start graceful shutdown
+        server.shutdown();
+        try {
+          // Wait for RPCs to complete processing
+          if (!server.awaitTermination(30, TimeUnit.SECONDS)) {
+            // That was plenty of time. Let's cancel the remaining RPCs
+            server.shutdownNow();
+            // shutdownNow isn't instantaneous, so give a bit of time to clean resources up
+            // gracefully. Normally this will be well under a second.
+            server.awaitTermination(5, TimeUnit.SECONDS);
+          }
+          healthServer.shutdownNow();
+          healthServer.awaitTermination(5, TimeUnit.SECONDS);
+        } catch (InterruptedException ex) {
+          server.shutdownNow();
+          healthServer.shutdownNow();
+        }
+      }
+    });
+    // This would normally be tied to the service's dependencies. For example, if HostnameGreeter
+    // used a Channel to contact a required service, then when 'channel.getState() ==
+    // TRANSIENT_FAILURE' we'd want to set NOT_SERVING. But HostnameGreeter has no dependencies, so
+    // hard-coding SERVING is appropriate.
+    health.setStatus("", ServingStatus.SERVING);
+    server.awaitTermination();
+  }
+}
diff --git a/examples/example-xds/src/main/proto/helloworld/helloworld.proto b/examples/example-xds/src/main/proto/helloworld/helloworld.proto
new file mode 100644
index 00000000000..be254697373
--- /dev/null
+++ b/examples/example-xds/src/main/proto/helloworld/helloworld.proto
@@ -0,0 +1,37 @@
+// 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.helloworld";
+option java_outer_classname = "HelloWorldProto";
+option objc_class_prefix = "HLW";
+
+package helloworld;
+
+// The greeting service definition.
+service Greeter {
+  // Sends a greeting
+  rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/gradle/wrapper/gradle-wrapper.jar b/examples/gradle/wrapper/gradle-wrapper.jar
index d6e2637affb..13536770052 100644
Binary files a/examples/gradle/wrapper/gradle-wrapper.jar and b/examples/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/examples/gradle/wrapper/gradle-wrapper.properties b/examples/gradle/wrapper/gradle-wrapper.properties
index 48b5ceea3b1..1e2fbf0d458 100644
--- a/examples/gradle/wrapper/gradle-wrapper.properties
+++ b/examples/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,5 @@
-#Wed Nov 16 15:32:41 PST 2016
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-3.2-bin.zip
diff --git a/examples/gradlew b/examples/gradlew
index 4ef3a871f2e..1b6c787337f 100755
--- a/examples/gradlew
+++ b/examples/gradlew
@@ -1,78 +1,129 @@
-#!/usr/bin/env sh
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original 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
+#
+#      https://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.
+#
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+APP_BASE_NAME=${0##*/}
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
-warn ( ) {
+warn () {
     echo "$*"
-}
+} >&2
 
-die ( ) {
+die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -81,7 +132,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    JAVACMD=java
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -89,83 +140,95 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
 fi
 
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
 
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
     # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
         fi
-        i=$((i+1))
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
     done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
 fi
 
-# Escape application args
-for s in "${@}" ; do
-    s=\"$s\"
-    APP_ARGS=$APP_ARGS" "$s
-done
-
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- "$DEFAULT_JVM_OPTS" "$JAVA_OPTS" "$GRADLE_OPTS" "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
-fi
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
 
 exec "$JAVACMD" "$@"
diff --git a/examples/gradlew.bat b/examples/gradlew.bat
index e95643d6a2c..ac1b06f9382 100644
--- a/examples/gradlew.bat
+++ b/examples/gradlew.bat
@@ -1,3 +1,19 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
 @if "%DEBUG%" == "" @echo off
 @rem ##########################################################################
 @rem
@@ -13,15 +29,18 @@ if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if "%ERRORLEVEL%" == "0" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -35,7 +54,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -45,28 +64,14 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell
diff --git a/examples/logging.properties b/examples/logging.properties
new file mode 100644
index 00000000000..b807613adcd
--- /dev/null
+++ b/examples/logging.properties
@@ -0,0 +1,8 @@
+# Create a file called logging.properties with the following contents.
+handlers=java.util.logging.ConsoleHandler
+io.grpc.level=FINE
+java.util.logging.ConsoleHandler.level=ALL
+java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter
+
+# Pass the location of the file to JVM via this command-line flag
+JAVA_OPTS=-Djava.util.logging.config.file=logging.properties
diff --git a/examples/maven-assembly-jar-with-dependencies.xml b/examples/maven-assembly-jar-with-dependencies.xml
new file mode 100644
index 00000000000..6c8abbfe7e8
--- /dev/null
+++ b/examples/maven-assembly-jar-with-dependencies.xml
@@ -0,0 +1,27 @@
+<assembly xmlns="http://maven.apache.org/ASSEMBLY/2.2.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/ASSEMBLY/2.2.0 https://maven.apache.org/xsd/assembly-2.2.0.xsd">
+<!--
+This is jar-with-dependencies with the metaInf-services handler added.
+https://maven.apache.org/plugins/maven-assembly-plugin/descriptor-refs.html#jar-with-dependencies
+https://maven.apache.org/plugins/maven-assembly-plugin/examples/single/using-container-descriptor-handlers.html
+-->
+  <id>jar-with-dependencies</id>
+  <formats>
+    <format>jar</format>
+  </formats>
+  <includeBaseDirectory>false</includeBaseDirectory>
+  <dependencySets>
+    <dependencySet>
+      <outputDirectory>/</outputDirectory>
+      <useProjectArtifact>true</useProjectArtifact>
+      <unpack>true</unpack>
+      <scope>runtime</scope>
+    </dependencySet>
+  </dependencySets>
+  <containerDescriptorHandlers>
+    <containerDescriptorHandler>
+      <handlerName>metaInf-services</handlerName>
+    </containerDescriptorHandler>
+  </containerDescriptorHandlers>
+</assembly>
diff --git a/examples/pom.xml b/examples/pom.xml
index 0f5ba3e59e0..4deaaca54a4 100644
--- a/examples/pom.xml
+++ b/examples/pom.xml
@@ -6,56 +6,94 @@
   <packaging>jar</packaging>
   <!-- Feel free to delete the comment at the end of these lines. It is just
        for safely updating the version in our release process. -->
-  <version>1.2.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
+  <version>1.80.0-SNAPSHOT</version><!-- CURRENT_GRPC_VERSION -->
   <name>examples</name>
-  <url>http://maven.apache.org</url>
+  <url>https://github.com/grpc/grpc-java</url>
+
   <properties>
-    <grpc.version>1.2.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <grpc.version>1.80.0-SNAPSHOT</grpc.version><!-- CURRENT_GRPC_VERSION -->
+    <protobuf.version>3.25.8</protobuf.version>
+    <protoc.version>3.25.8</protoc.version>
+    <!-- required for JDK 8 -->
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
   </properties>
+
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>io.grpc</groupId>
+        <artifactId>grpc-bom</artifactId>
+        <version>${grpc.version}</version>
+        <type>pom</type>
+        <scope>import</scope>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
+
   <dependencies>
     <dependency>
       <groupId>io.grpc</groupId>
-      <artifactId>grpc-netty</artifactId>
-      <version>${grpc.version}</version>
+      <artifactId>grpc-services</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-netty-shaded</artifactId>
+      <scope>runtime</scope>
     </dependency>
     <dependency>
       <groupId>io.grpc</groupId>
       <artifactId>grpc-protobuf</artifactId>
-      <version>${grpc.version}</version>
     </dependency>
     <dependency>
       <groupId>io.grpc</groupId>
       <artifactId>grpc-stub</artifactId>
-      <version>${grpc.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>com.google.protobuf</groupId>
+      <artifactId>protobuf-java-util</artifactId>
+      <version>${protobuf.version}</version>
+    </dependency>
+    <dependency> <!-- Use newer version than in protobuf-java-util -->
+      <groupId>com.google.j2objc</groupId>
+      <artifactId>j2objc-annotations</artifactId>
+      <version>3.1</version>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-testing</artifactId>
+      <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>4.11</version>
+      <version>4.13.2</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-core</artifactId>
-      <version>1.9.5</version>
+      <version>4.4.0</version>
       <scope>test</scope>
     </dependency>
   </dependencies>
+
   <build>
     <extensions>
       <extension>
         <groupId>kr.motd.maven</groupId>
         <artifactId>os-maven-plugin</artifactId>
-        <version>1.4.1.Final</version>
+        <version>1.7.1</version>
       </extension>
     </extensions>
     <plugins>
       <plugin>
         <groupId>org.xolstice.maven.plugins</groupId>
         <artifactId>protobuf-maven-plugin</artifactId>
-        <version>0.5.0</version>
+        <version>0.6.1</version>
         <configuration>
-          <protocArtifact>com.google.protobuf:protoc:3.2.0:exe:${os.detected.classifier}</protocArtifact>
+          <protocArtifact>com.google.protobuf:protoc:${protoc.version}:exe:${os.detected.classifier}</protocArtifact>
           <pluginId>grpc-java</pluginId>
           <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
         </configuration>
@@ -68,6 +106,53 @@
           </execution>
         </executions>
       </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-enforcer-plugin</artifactId>
+        <version>3.5.0</version>
+        <executions>
+          <execution>
+            <id>enforce</id>
+            <goals>
+              <goal>enforce</goal>
+            </goals>
+            <configuration>
+              <rules>
+                <requireUpperBoundDeps/>
+              </rules>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+
+      <!-- gRPC uses java.util.ServiceLoader, which reads class names from
+        META-INF/services in jars. If you package your application as a "fat"
+        jar that includes dependencies, you need to make sure the packaging tool
+        concatenates duplicate files in META-INF/services. -->
+
+      <!-- If using maven-shade-plugin, use ServicesResourceTransformer, as
+        documented by maven-shade-plugin.
+        https://maven.apache.org/plugins/maven-shade-plugin/examples/resource-transformers.html#ServicesResourceTransformer -->
+
+      <!-- If using maven-assembly-plugin, you need to add the metaInf-services
+        handler to the descriptor, which requires making a copy of
+        jar-with-dependencies. -->
+      <plugin>
+        <artifactId>maven-assembly-plugin</artifactId>
+        <version>3.7.1</version>
+        <configuration>
+          <descriptors>${project.basedir}/maven-assembly-jar-with-dependencies.xml</descriptors>
+        </configuration>
+        <executions>
+          <execution>
+            <id>make-assembly</id>
+            <phase>package</phase>
+            <goals>
+              <goal>single</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
     </plugins>
   </build>
 </project>
diff --git a/examples/settings.gradle b/examples/settings.gradle
index 091fcf2a34b..4d39e8b45ba 100644
--- a/examples/settings.gradle
+++ b/examples/settings.gradle
@@ -1,2 +1,21 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+
+    repositories {
+        gradlePluginPortal()
+    }
+}
+
 rootProject.name = 'examples'
-include 'thrift'
diff --git a/examples/src/main/java/io/grpc/examples/advanced/HelloJsonClient.java b/examples/src/main/java/io/grpc/examples/advanced/HelloJsonClient.java
index 308e4182058..9291e45bafe 100644
--- a/examples/src/main/java/io/grpc/examples/advanced/HelloJsonClient.java
+++ b/examples/src/main/java/io/grpc/examples/advanced/HelloJsonClient.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.advanced;
@@ -35,17 +20,15 @@
 
 import io.grpc.CallOptions;
 import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
 import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
 import io.grpc.MethodDescriptor;
 import io.grpc.StatusRuntimeException;
 import io.grpc.examples.helloworld.GreeterGrpc;
 import io.grpc.examples.helloworld.HelloReply;
 import io.grpc.examples.helloworld.HelloRequest;
-import io.grpc.examples.helloworld.HelloWorldClient;
-import io.grpc.protobuf.ProtoUtils;
 import io.grpc.stub.AbstractStub;
-
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -60,15 +43,14 @@
  * https://groups.google.com/forum/#!forum/grpc-io
  */
 public final class HelloJsonClient {
-  private static final Logger logger = Logger.getLogger(HelloWorldClient.class.getName());
+  private static final Logger logger = Logger.getLogger(HelloJsonClient.class.getName());
 
   private final ManagedChannel channel;
   private final HelloJsonStub blockingStub;
 
   /** Construct client connecting to HelloWorld server at {@code host:port}. */
   public HelloJsonClient(String host, int port) {
-    channel = ManagedChannelBuilder.forAddress(host, port)
-        .usePlaintext(true)
+    channel = Grpc.newChannelBuilderForAddress(host, port, InsecureChannelCredentials.create())
         .build();
     blockingStub = new HelloJsonStub(channel);
   }
@@ -96,12 +78,13 @@ public void greet(String name) {
    * greeting.
    */
   public static void main(String[] args) throws Exception {
+    // Access a service running on the local machine on port 50051
     HelloJsonClient client = new HelloJsonClient("localhost", 50051);
     try {
-      /* Access a service running on the local machine on port 50051 */
       String user = "world";
+      // Use the arg as the name to greet if provided
       if (args.length > 0) {
-        user = args[0]; /* Use the arg as the name to greet if provided */
+        user = args[0];
       }
       client.greet(user);
     } finally {
@@ -112,11 +95,11 @@ public static void main(String[] args) throws Exception {
   static final class HelloJsonStub extends AbstractStub<HelloJsonStub> {
 
     static final MethodDescriptor<HelloRequest, HelloReply> METHOD_SAY_HELLO =
-        MethodDescriptor.create(
-            GreeterGrpc.METHOD_SAY_HELLO.getType(),
-            GreeterGrpc.METHOD_SAY_HELLO.getFullMethodName(),
-            ProtoUtils.jsonMarshaller(HelloRequest.getDefaultInstance()),
-            ProtoUtils.jsonMarshaller(HelloReply.getDefaultInstance()));
+        GreeterGrpc.getSayHelloMethod()
+            .toBuilder(
+                JsonMarshaller.jsonMarshaller(HelloRequest.getDefaultInstance()),
+                JsonMarshaller.jsonMarshaller(HelloReply.getDefaultInstance()))
+            .build();
 
     protected HelloJsonStub(Channel channel) {
       super(channel);
diff --git a/examples/src/main/java/io/grpc/examples/advanced/HelloJsonServer.java b/examples/src/main/java/io/grpc/examples/advanced/HelloJsonServer.java
index 54d923210d3..0f4e5d28f16 100644
--- a/examples/src/main/java/io/grpc/examples/advanced/HelloJsonServer.java
+++ b/examples/src/main/java/io/grpc/examples/advanced/HelloJsonServer.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.advanced;
@@ -34,17 +19,17 @@
 import static io.grpc.stub.ServerCalls.asyncUnaryCall;
 
 import io.grpc.BindableService;
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
 import io.grpc.Server;
-import io.grpc.ServerBuilder;
 import io.grpc.ServerServiceDefinition;
 import io.grpc.examples.helloworld.GreeterGrpc;
 import io.grpc.examples.helloworld.HelloReply;
 import io.grpc.examples.helloworld.HelloRequest;
-import io.grpc.examples.helloworld.HelloWorldServer;
 import io.grpc.stub.ServerCalls.UnaryMethod;
 import io.grpc.stub.StreamObserver;
-
 import java.io.IOException;
+import java.util.concurrent.TimeUnit;
 import java.util.logging.Logger;
 
 /**
@@ -59,14 +44,14 @@
  * https://groups.google.com/forum/#!forum/grpc-io
  */
 public class HelloJsonServer {
-  private static final Logger logger = Logger.getLogger(HelloWorldServer.class.getName());
+  private static final Logger logger = Logger.getLogger(HelloJsonServer.class.getName());
 
   private Server server;
 
   private void start() throws IOException {
     /* The port on which the server should run */
     int port = 50051;
-    server = ServerBuilder.forPort(port)
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
         .addService(new GreeterImpl())
         .build()
         .start();
@@ -76,15 +61,19 @@ private void start() throws IOException {
       public void run() {
         // Use stderr here since the logger may have been reset by its JVM shutdown hook.
         System.err.println("*** shutting down gRPC server since JVM is shutting down");
-        HelloJsonServer.this.stop();
+        try {
+          HelloJsonServer.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
         System.err.println("*** server shut down");
       }
     });
   }
 
-  private void stop() {
+  private void stop() throws InterruptedException {
     if (server != null) {
-      server.shutdown();
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
     }
   }
 
diff --git a/examples/src/main/java/io/grpc/examples/advanced/JsonMarshaller.java b/examples/src/main/java/io/grpc/examples/advanced/JsonMarshaller.java
new file mode 100644
index 00000000000..8b3068cc009
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/advanced/JsonMarshaller.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2018 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.examples.advanced;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Message;
+import com.google.protobuf.Message.Builder;
+import com.google.protobuf.util.JsonFormat;
+import com.google.protobuf.util.JsonFormat.Parser;
+import com.google.protobuf.util.JsonFormat.Printer;
+import io.grpc.MethodDescriptor.Marshaller;
+import io.grpc.Status;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.nio.charset.Charset;
+
+/**
+ * A {@link Marshaller} for JSON.  This marshals in the Protobuf 3 format described here:
+ * https://developers.google.com/protocol-buffers/docs/proto3#json
+ */
+final class JsonMarshaller {
+
+  private JsonMarshaller() {}
+
+  /**
+   * Create a {@code Marshaller} for json protos of the same type as {@code defaultInstance}.
+   *
+   * <p>This is an unstable API and has not been optimized yet for performance.
+   */
+  public static <T extends Message> Marshaller<T> jsonMarshaller(final T defaultInstance) {
+    final Parser parser = JsonFormat.parser();
+    final Printer printer = JsonFormat.printer();
+    return jsonMarshaller(defaultInstance, parser, printer);
+  }
+
+  /**
+   * Create a {@code Marshaller} for json protos of the same type as {@code defaultInstance}.
+   *
+   * <p>This is an unstable API and has not been optimized yet for performance.
+   */
+  public static <T extends Message> Marshaller<T> jsonMarshaller(
+      final T defaultInstance, final Parser parser, final Printer printer) {
+
+    final Charset charset = Charset.forName("UTF-8");
+
+    return new Marshaller<T>() {
+      @Override
+      public InputStream stream(T value) {
+        try {
+          return new ByteArrayInputStream(printer.print(value).getBytes(charset));
+        } catch (InvalidProtocolBufferException e) {
+          throw Status.INTERNAL
+              .withCause(e)
+              .withDescription("Unable to print json proto")
+              .asRuntimeException();
+        }
+      }
+
+      @SuppressWarnings("unchecked")
+      @Override
+      public T parse(InputStream stream) {
+        Builder builder = defaultInstance.newBuilderForType();
+        Reader reader = new InputStreamReader(stream, charset);
+        T proto;
+        try {
+          parser.merge(reader, builder);
+          proto = (T) builder.build();
+          reader.close();
+        } catch (InvalidProtocolBufferException e) {
+          throw Status.INTERNAL.withDescription("Invalid protobuf byte sequence")
+              .withCause(e).asRuntimeException();
+        } catch (IOException e) {
+          // Same for now, might be unavailable
+          throw Status.INTERNAL.withDescription("Invalid protobuf byte sequence")
+              .withCause(e).asRuntimeException();
+        }
+        return proto;
+      }
+    };
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/advanced/README.md b/examples/src/main/java/io/grpc/examples/advanced/README.md
new file mode 100644
index 00000000000..f5b5c6cc7fc
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/advanced/README.md
@@ -0,0 +1,16 @@
+gRPC JSON Serialization Example
+=====================
+
+gRPC is a modern high-performance framework for building Remote Procedure Call (RPC) systems.
+It commonly uses Protocol Buffers (Protobuf) as its serialization format, which is compact and efficient.
+However, gRPC can also support JSON serialization when needed, typically for interoperability with 
+systems or clients that do not use Protobuf.
+This is an advanced example of how to swap out the serialization logic, Normal users do not need to do this.
+This code is not intended to be a production-ready implementation, since JSON encoding is slow.
+Additionally, JSON serialization as implemented may be not resilient to malicious input.
+
+This advanced example uses Marshaller for JSON which marshals in the Protobuf 3 format described here
+https://developers.google.com/protocol-buffers/docs/proto3#json
+
+If you are considering implementing your own serialization logic, contact the grpc team at
+https://groups.google.com/forum/#!forum/grpc-io
diff --git a/examples/src/main/java/io/grpc/examples/cancellation/CancellationClient.java b/examples/src/main/java/io/grpc/examples/cancellation/CancellationClient.java
new file mode 100644
index 00000000000..fa31ee8e6c1
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/cancellation/CancellationClient.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2023 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.examples.cancellation;
+
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.Channel;
+import io.grpc.Context;
+import io.grpc.Context.CancellableContext;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.echo.EchoGrpc;
+import io.grpc.examples.echo.EchoRequest;
+import io.grpc.examples.echo.EchoResponse;
+import io.grpc.stub.ClientCallStreamObserver;
+import io.grpc.stub.StreamObserver;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A client that cancels RPCs to an Echo server.
+ */
+public class CancellationClient {
+  private final Channel channel;
+
+  public CancellationClient(Channel channel) {
+    this.channel = channel;
+  }
+
+  private void demonstrateCancellation() throws Exception {
+    echoBlocking("I'M A BLOCKING CLIENT! HEAR ME ROAR!");
+
+    // io.grpc.Context can be used to cancel RPCs using any of the stubs. It is the only way to
+    // cancel blocking stub RPCs. io.grpc.Context is a general-purpose alternative to thread
+    // interruption and can be used outside of gRPC, like to coordinate within your application.
+    //
+    // CancellableContext must always be cancelled or closed at the end of its lifetime, otherwise
+    // it could "leak" memory.
+    try (CancellableContext context = Context.current().withCancellation()) {
+      new Thread(() -> {
+        try {
+          Thread.sleep(500); // Do some work
+        } catch (InterruptedException ex) {
+          Thread.currentThread().interrupt();
+        }
+        // Cancellation reasons are never sent to the server. But they are echoed back to the
+        // client as the RPC failure reason.
+        context.cancel(new RuntimeException("Oops. Messed that up, let me try again"));
+      }).start();
+
+      // context.run() attaches the context to this thread for gRPC to observe. It also restores
+      // the previous context before returning.
+      context.run(() -> echoBlocking("RAAWRR haha lol hehe AWWRR GRRR"));
+    }
+
+    // Futures cancelled with interruption cancel the RPC.
+    ListenableFuture<EchoResponse> future = echoFuture("Future clie*cough*nt was here!");
+    Thread.sleep(500); // Do some work
+    // We realize we really don't want to hear that echo.
+    future.cancel(true);
+    Thread.sleep(100); // Make logs more obvious. Cancel is async
+
+    ClientCallStreamObserver<EchoRequest> reqCallObserver = echoAsync("Testing, testing, 1, 2, 3");
+    reqCallObserver.onCompleted();
+    Thread.sleep(500); // Make logs more obvious. Wait for completion
+
+    // Async's onError() will cancel. But the method can't be called concurrently with other calls
+    // on the StreamObserver. If you need thread-safety, use CancellableContext as above.
+    StreamObserver<EchoRequest> reqObserver = echoAsync("... async client... is the... best...");
+    try {
+      Thread.sleep(500); // Do some work
+    } catch (InterruptedException ex) {
+      Thread.currentThread().interrupt();
+    }
+    // Since reqObserver.onCompleted() hasn't been called, we can use onError().
+    reqObserver.onError(new RuntimeException("That was weak..."));
+    Thread.sleep(100); // Make logs more obvious. Cancel is async
+
+    // Async's cancel() will cancel. Also may not be called concurrently with other calls on the
+    // StreamObserver.
+    reqCallObserver = echoAsync("Async client or bust!");
+    reqCallObserver.onCompleted();
+    try {
+      Thread.sleep(250); // Do some work
+    } catch (InterruptedException ex) {
+      Thread.currentThread().interrupt();
+    }
+    // Since onCompleted() has been called, we can't use onError(). It is safe to use cancel()
+    // regardless of onCompleted() being called.
+    reqCallObserver.cancel("That's enough. I'm bored", null);
+    Thread.sleep(100); // Make logs more obvious. Cancel is async
+  }
+
+  /** Say hello to server, just like in helloworld example. */
+  public void echoBlocking(String text) {
+    System.out.println("\nYelling: " + text);
+    EchoRequest request = EchoRequest.newBuilder().setMessage(text).build();
+    EchoResponse response;
+    try {
+      response = EchoGrpc.newBlockingStub(channel).unaryEcho(request);
+    } catch (StatusRuntimeException e) {
+      System.out.println("RPC failed: " + e.getStatus());
+      return;
+    }
+    System.out.println("Echo: " + response.getMessage());
+  }
+
+  /** Say hello to the server, but using future API. */
+  public ListenableFuture<EchoResponse> echoFuture(String text) {
+    System.out.println("\nYelling: " + text);
+    EchoRequest request = EchoRequest.newBuilder().setMessage(text).build();
+    ListenableFuture<EchoResponse> future = EchoGrpc.newFutureStub(channel).unaryEcho(request);
+    Futures.addCallback(future, new FutureCallback<EchoResponse>() {
+      @Override
+      public void onSuccess(EchoResponse response) {
+        System.out.println("Echo: " + response.getMessage());
+      }
+
+      @Override
+      public void onFailure(Throwable t) {
+        System.out.println("RPC failed: " + Status.fromThrowable(t));
+      }
+    }, MoreExecutors.directExecutor());
+    return future;
+  }
+
+  /** Say hello to the server, but using async API and cancelling. */
+  public ClientCallStreamObserver<EchoRequest> echoAsync(String text) {
+    System.out.println("\nYelling: " + text);
+    EchoRequest request = EchoRequest.newBuilder().setMessage(text).build();
+
+    // Client-streaming and bidirectional RPCs can cast the returned StreamObserver to
+    // ClientCallStreamObserver.
+    //
+    // Unary and server-streaming stub methods don't return a StreamObserver. For such RPCs, you can
+    // use ClientResponseObserver to get the ClientCallStreamObserver. For example:
+    //     EchoGrpc.newStub(channel).unaryEcho(new ClientResponseObserver<EchoResponse>() {...});
+    // Since ClientCallStreamObserver.cancel() is not thread-safe, it isn't safe to call from
+    // another thread until the RPC stub method (e.g., unaryEcho()) returns.
+    ClientCallStreamObserver<EchoRequest> reqObserver = (ClientCallStreamObserver<EchoRequest>)
+        EchoGrpc.newStub(channel).bidirectionalStreamingEcho(new StreamObserver<EchoResponse>() {
+      @Override
+      public void onNext(EchoResponse response) {
+        System.out.println("Echo: " + response.getMessage());
+      }
+
+      @Override
+      public void onCompleted() {
+        System.out.println("RPC completed");
+      }
+
+      @Override
+      public void onError(Throwable t) {
+        System.out.println("RPC failed: " + Status.fromThrowable(t));
+      }
+    });
+
+    reqObserver.onNext(request);
+    return reqObserver;
+  }
+
+  /**
+   * Cancel RPCs to a server. If provided, the first element of {@code args} is the target server.
+   */
+  public static void main(String[] args) throws Exception {
+    String target = "localhost:50051";
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [target]");
+        System.err.println("");
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.exit(1);
+      }
+      target = args[0];
+    }
+
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .build();
+    try {
+      CancellationClient client = new CancellationClient(channel);
+      client.demonstrateCancellation();
+    } finally {
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/cancellation/CancellationServer.java b/examples/src/main/java/io/grpc/examples/cancellation/CancellationServer.java
new file mode 100644
index 00000000000..cf26e974f5f
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/cancellation/CancellationServer.java
@@ -0,0 +1,206 @@
+/*
+ * Copyright 2023 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.examples.cancellation;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.Context;
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.Status;
+import io.grpc.examples.echo.EchoGrpc;
+import io.grpc.examples.echo.EchoRequest;
+import io.grpc.examples.echo.EchoResponse;
+import io.grpc.stub.ServerCallStreamObserver;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * Server that manages startup/shutdown of a {@code Greeter} server.
+ *
+ * <p>Any abort of an ongoing RPC is considered "cancellation" of that RPC. The common causes of
+ * cancellation are the client explicitly cancelling, the deadline expires, and I/O failures. The
+ * service is not informed the reason for the cancellation.
+ *
+ * <p>There are two APIs for services to be notified of RPC cancellation: io.grpc.Context and
+ * ServerCallStreamObserver. Context listeners are called on a different thread, so need to be
+ * thread-safe. The ServerCallStreamObserver cancellation callback is called like other
+ * StreamObserver callbacks, so the application may not need thread-safe handling. Both APIs have
+ * thread-safe isCancelled() polling methods.
+ */
+public class CancellationServer {
+  public static void main(String[] args) throws IOException, InterruptedException {
+    ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
+    int port = 50051;
+    Server server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new SlowEcho(scheduler))
+        .build()
+        .start();
+    System.out.println("Server started, listening on " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        try {
+          server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+      }
+    });
+    server.awaitTermination();
+    scheduler.shutdown();
+    if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
+      scheduler.shutdownNow();
+    }
+  }
+
+  static class SlowEcho extends EchoGrpc.EchoImplBase {
+    private final ScheduledExecutorService scheduler;
+
+    /** {@code scheduler} must be single-threaded. */
+    public SlowEcho(ScheduledExecutorService scheduler) {
+      this.scheduler = scheduler;
+    }
+
+    /**
+     * Repeatedly echos each request until the client has no more requests. It performs all work
+     * asynchronously on a single thread. It uses ServerCallStreamObserver to be notified of RPC
+     * cancellation.
+     */
+    @Override
+    public StreamObserver<EchoRequest> bidirectionalStreamingEcho(
+        StreamObserver<EchoResponse> responseObserver) {
+      // If the service is truly asynchronous, using ServerCallStreamObserver to receive
+      // cancellation notifications tends to work well.
+
+      // It is safe to cast the provided observer to ServerCallStreamObserver.
+      ServerCallStreamObserver<EchoResponse> responseCallObserver =
+          (ServerCallStreamObserver<EchoResponse>) responseObserver;
+      System.out.println("\nBidi RPC started");
+      class EchoObserver implements StreamObserver<EchoRequest> {
+        private static final int delayMs = 200;
+        private final List<Future<?>> echos = new ArrayList<>();
+
+        @Override
+        public void onNext(EchoRequest request) {
+          System.out.println("Bidi RPC received request: " + request.getMessage());
+          EchoResponse response
+              = EchoResponse.newBuilder().setMessage(request.getMessage()).build();
+          Runnable echo = () -> responseObserver.onNext(response);
+          echos.add(scheduler.scheduleAtFixedRate(echo, delayMs, delayMs, TimeUnit.MILLISECONDS));
+        }
+
+        @Override
+        public void onCompleted() {
+          System.out.println("Bidi RPC client finished");
+          // Let each echo happen two more times, and then stop.
+          List<Future<?>> echosCopy = new ArrayList<>(echos);
+          Runnable complete = () -> {
+            stopEchos(echosCopy);
+            responseObserver.onCompleted();
+            System.out.println("Bidi RPC completed");
+          };
+          echos.add(scheduler.schedule(complete, 2*delayMs, TimeUnit.MILLISECONDS));
+        }
+
+        @Override
+        public void onError(Throwable t) {
+          System.out.println("Bidi RPC failed: " + Status.fromThrowable(t));
+          stopEchos(echos);
+          scheduler.execute(() -> responseObserver.onError(t));
+        }
+
+        public void onCancel() {
+          // If onCompleted() hasn't been called by this point, then this method and onError are
+          // both called. If onCompleted() has been called, then just this method is called.
+          System.out.println("Bidi RPC cancelled");
+          stopEchos(echos);
+        }
+
+        private void stopEchos(List<Future<?>> echos) {
+          for (Future<?> echo : echos) {
+            echo.cancel(false);
+          }
+        }
+      }
+
+      EchoObserver requestObserver = new EchoObserver();
+      // onCancel() can be called even after the service completes or fails the RPC, because
+      // callbacks are racy and the response still has to be sent to the client. Use
+      // setOnCloseHandler() to be notified when the RPC completed without cancellation (as best as
+      // the server is able to tell).
+      responseCallObserver.setOnCancelHandler(requestObserver::onCancel);
+      return requestObserver;
+    }
+
+    /**
+     * Echos the request after a delay. It processes the request in-line within the callback. It
+     * uses Context to be notified of RPC cancellation.
+     */
+    @Override
+    public void unaryEcho(EchoRequest request, StreamObserver<EchoResponse> responseObserver) {
+      // ServerCallStreamObserver.setOnCancelHandler(Runnable) is not useful for this method, since
+      // this method only returns once it has a result. ServerCallStreamObserver guarantees the
+      // Runnable is not run at the same time as other RPC callback methods (including this method),
+      // so the cancellation notification would be guaranteed to occur too late.
+      System.out.println("\nUnary RPC started: " + request.getMessage());
+      Context currentContext = Context.current();
+      // Let's start a multi-part operation. We can check cancellation periodically.
+      for (int i = 0; i < 10; i++) {
+        // ServerCallStreamObserver.isCancelled() returns true only if the RPC is cancelled.
+        // Context.isCancelled() is similar, but also returns true when the RPC completes normally.
+        // It doesn't matter which API is used here.
+        if (currentContext.isCancelled()) {
+          System.out.println("Unary RPC cancelled");
+          responseObserver.onError(
+              Status.CANCELLED.withDescription("RPC cancelled").asRuntimeException());
+          return;
+        }
+
+        FutureTask<Void> task = new FutureTask<>(() -> {
+          Thread.sleep(100); // Do some work
+          return null;
+        });
+        // Some Java blocking APIs have a method to cancel an ongoing operation, like closing an
+        // InputStream or interrupting the thread. We can use a Context listener to call that API
+        // from another thread if the RPC is cancelled.
+        Context.CancellationListener listener = (Context context) -> task.cancel(true);
+        Context.current().addListener(listener, MoreExecutors.directExecutor());
+        task.run(); // A cancellable operation
+        Context.current().removeListener(listener);
+
+        // gRPC stubs observe io.grpc.Context cancellation, so cancellation is automatically
+        // propagated when performing an RPC. You can use a different Context or use Context.fork()
+        // to disable the automatic propagation. For example,
+        //   Context.ROOT.call(() -> futureStub.unaryEcho(request));
+        //   context.fork().call(() -> futureStub.unaryEcho(request));
+      }
+      responseObserver.onNext(
+          EchoResponse.newBuilder().setMessage(request.getMessage()).build());
+      responseObserver.onCompleted();
+      System.out.println("Unary RPC completed");
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/cancellation/README.md b/examples/src/main/java/io/grpc/examples/cancellation/README.md
new file mode 100644
index 00000000000..6b11a17c517
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/cancellation/README.md
@@ -0,0 +1,18 @@
+gRPC Cancellation Example
+=====================
+
+When a gRPC client is no longer interested in the result of an RPC call,
+it may cancel to signal this discontinuation of interest to the server.
+
+Any abort of an ongoing RPC is considered "cancellation" of that RPC.
+The common causes of cancellation are the client explicitly cancelling, the deadline expires, and I/O failures.
+The service is not informed the reason for the cancellation.
+
+There are two APIs for services to be notified of RPC cancellation: io.grpc.Context and ServerCallStreamObserver
+
+Context listeners are called on a different thread, so need to be thread-safe.
+The ServerCallStreamObserver cancellation callback is called like other StreamObserver callbacks, 
+so the application may not need thread-safe handling.
+Both APIs have thread-safe isCancelled() polling methods.
+
+Refer the gRPC documentation for details on Cancellation of RPCs https://grpc.io/docs/guides/cancellation/
diff --git a/examples/src/main/java/io/grpc/examples/customloadbalance/CustomLoadBalanceClient.java b/examples/src/main/java/io/grpc/examples/customloadbalance/CustomLoadBalanceClient.java
new file mode 100644
index 00000000000..2cf50a80b0a
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/customloadbalance/CustomLoadBalanceClient.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2023 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.examples.customloadbalance;
+
+import com.google.gson.Gson;
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.NameResolverRegistry;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.examples.loadbalance.ExampleNameResolverProvider;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * This client is intended for connecting with the {@code LoadBalanceServer} in the "loadbalance"
+ * example.
+ */
+public class CustomLoadBalanceClient {
+
+  private static final Logger logger = Logger.getLogger(CustomLoadBalanceClient.class.getName());
+
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+  public CustomLoadBalanceClient(Channel channel) {
+    blockingStub = GreeterGrpc.newBlockingStub(channel);
+  }
+
+  public void greet(String name) {
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response;
+    try {
+      response = blockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    logger.info("Greeting: " + response.getMessage());
+  }
+
+
+  public static void main(String[] args) throws Exception {
+    // We need to register the provider of our custom load balancer implementation
+    LoadBalancerRegistry.getDefaultRegistry()
+        .register(new ShufflingPickFirstLoadBalancerProvider());
+
+    NameResolverRegistry.getDefaultRegistry().register(new ExampleNameResolverProvider());
+
+    String target = "example:///lb.example.grpc.io";
+
+    logger.info("Use default first_pick load balance policy");
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .build();
+
+    try {
+      CustomLoadBalanceClient client = new CustomLoadBalanceClient(channel);
+      for (int i = 0; i < 5; i++) {
+        client.greet("request" + i);
+      }
+    } finally {
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+    }
+
+    logger.info("Change to custom shuffling_pick_first policy with a configured random seed");
+    // The load balancer name in the config needs to match what getPolicyName() in the provider
+    // returns. The randomSeed field we are using also needs to be understood by the provider when
+    // parseLoadBalancingPolicyConfig() gets called.
+    Map<String, ?> serviceConfig = new Gson().fromJson(
+        "{ \"loadBalancingConfig\": " +
+        "    [ { \"grpc.examples.customloadbalance.ShufflingPickFirst\": { \"randomSeed\": 123 } } ]" +
+        "}",
+        Map.class);
+    channel = ManagedChannelBuilder.forTarget(target)
+        .defaultServiceConfig(serviceConfig)
+        .usePlaintext()
+        .build();
+    try {
+      CustomLoadBalanceClient client = new CustomLoadBalanceClient(channel);
+      for (int i = 0; i < 5; i++) {
+        client.greet("request" + i);
+      }
+    } finally {
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/customloadbalance/README.md b/examples/src/main/java/io/grpc/examples/customloadbalance/README.md
new file mode 100644
index 00000000000..20dbccb81ac
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/customloadbalance/README.md
@@ -0,0 +1,19 @@
+gRPC Custom Load Balance Example
+=====================
+
+One of the key features of gRPC is load balancing, which allows requests from clients to be distributed across multiple servers. 
+This helps prevent any one server from becoming overloaded and allows the system to scale up by adding more servers.
+
+A gRPC load balancing policy is given a list of server IP addresses by the name resolver. 
+The policy is responsible for maintaining connections (subchannels) to the servers and picking a connection to use when an RPC is sent.
+
+This example gives the details about how we can implement our own custom load balance policy, If the built-in policies does not meet your requirements
+and follow below steps for the same.
+
+ - Register your implementation in the load balancer registry so that it can be referred to from the service config
+ - Parse the JSON configuration object of your implementation. This allows your load balancer to be configured in the service config with any arbitrary JSON you choose to support
+ - Manage what backends to maintain a connection with
+ - Implement a picker that will choose which backend to connect to when an RPC is made. Note that this needs to be a fast operation as it is on the RPC call path
+ - To enable your load balancer, configure it in your service config
+
+Refer the gRPC documentation for more details https://grpc.io/docs/guides/custom-load-balancing/
diff --git a/examples/src/main/java/io/grpc/examples/customloadbalance/ShufflingPickFirstLoadBalancer.java b/examples/src/main/java/io/grpc/examples/customloadbalance/ShufflingPickFirstLoadBalancer.java
new file mode 100644
index 00000000000..4715b551524
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/customloadbalance/ShufflingPickFirstLoadBalancer.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright 2023 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.examples.customloadbalance;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.Status;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * An example {@link LoadBalancer} largely based on {@link ShufflingPickFirstLoadBalancer} that adds
+ * shuffling of the list of servers so that the first server provided in {@link ResolvedAddresses}
+ * won't necessarily be the server the channel will connect to.
+ */
+class ShufflingPickFirstLoadBalancer extends LoadBalancer {
+
+  private final Helper helper;
+  private Subchannel subchannel;
+
+  /**
+   * This class defines the configuration used by this {@link LoadBalancer}. Note that no part of
+   * the gRPC library is aware of this class, it will be populated by the
+   * {@link ShufflingPickFirstLoadBalancerProvider}.
+   */
+  static class Config {
+
+    final Long randomSeed;
+
+    Config(Long randomSeed) {
+      this.randomSeed = randomSeed;
+    }
+  }
+
+  public ShufflingPickFirstLoadBalancer(Helper helper) {
+    this.helper = checkNotNull(helper, "helper");
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    List<EquivalentAddressGroup> servers = new ArrayList<>(resolvedAddresses.getAddresses());
+    if (servers.isEmpty()) {
+      Status unavailableStatus = Status.UNAVAILABLE.withDescription(
+          "NameResolver returned no usable address. addrs=" + resolvedAddresses.getAddresses()
+              + ", attrs=" + resolvedAddresses.getAttributes());
+      handleNameResolutionError(unavailableStatus);
+      return unavailableStatus;
+    }
+
+    Config config
+        = (Config) resolvedAddresses.getLoadBalancingPolicyConfig();
+
+    Collections.shuffle(servers,
+        config.randomSeed != null ? new Random(config.randomSeed) : new Random());
+
+    if (subchannel == null) {
+      final Subchannel subchannel = helper.createSubchannel(
+          CreateSubchannelArgs.newBuilder()
+              .setAddresses(servers)
+              .build());
+      subchannel.start(new SubchannelStateListener() {
+        @Override
+        public void onSubchannelState(ConnectivityStateInfo stateInfo) {
+          processSubchannelState(subchannel, stateInfo);
+        }
+      });
+      this.subchannel = subchannel;
+
+      helper.updateBalancingState(CONNECTING, new FixedResultPicker(PickResult.withNoResult()));
+      subchannel.requestConnection();
+    } else {
+      subchannel.updateAddresses(servers);
+    }
+
+    return Status.OK;
+  }
+
+  @Override
+  public void handleNameResolutionError(Status error) {
+    if (subchannel != null) {
+      subchannel.shutdown();
+      subchannel = null;
+    }
+    helper.updateBalancingState(
+        TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
+  }
+
+  private void processSubchannelState(Subchannel subchannel, ConnectivityStateInfo stateInfo) {
+    ConnectivityState currentState = stateInfo.getState();
+    if (currentState == SHUTDOWN) {
+      return;
+    }
+    if (stateInfo.getState() == TRANSIENT_FAILURE || stateInfo.getState() == IDLE) {
+      helper.refreshNameResolution();
+    }
+
+    SubchannelPicker picker;
+    switch (currentState) {
+      case IDLE:
+        picker = new RequestConnectionPicker();
+        break;
+      case CONNECTING:
+        picker = new FixedResultPicker(PickResult.withNoResult());
+        break;
+      case READY:
+        picker = new FixedResultPicker(PickResult.withSubchannel(subchannel));
+        break;
+      case TRANSIENT_FAILURE:
+        picker = new FixedResultPicker(PickResult.withError(stateInfo.getStatus()));
+        break;
+      default:
+        throw new IllegalArgumentException("Unsupported state:" + currentState);
+    }
+    helper.updateBalancingState(currentState, picker);
+  }
+
+
+  @Override
+  public void shutdown() {
+    if (subchannel != null) {
+      subchannel.shutdown();
+    }
+  }
+
+  @Override
+  public void requestConnection() {
+    if (subchannel != null) {
+      subchannel.requestConnection();
+    }
+  }
+
+  /**
+   * Picker that requests connection during the first pick, and returns noResult.
+   */
+  private final class RequestConnectionPicker extends SubchannelPicker {
+
+    private final AtomicBoolean connectionRequested = new AtomicBoolean(false);
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      if (connectionRequested.compareAndSet(false, true)) {
+        helper.getSynchronizationContext().execute(
+            ShufflingPickFirstLoadBalancer.this::requestConnection);
+      }
+      return PickResult.withNoResult();
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/customloadbalance/ShufflingPickFirstLoadBalancerProvider.java b/examples/src/main/java/io/grpc/examples/customloadbalance/ShufflingPickFirstLoadBalancerProvider.java
new file mode 100644
index 00000000000..d72b8ca1c8d
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/customloadbalance/ShufflingPickFirstLoadBalancerProvider.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2023 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.examples.customloadbalance;
+
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import java.util.Map;
+
+public class ShufflingPickFirstLoadBalancerProvider extends LoadBalancerProvider {
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawLoadBalancingPolicyConfig) {
+    Long randomSeed = null;
+
+    // The load balancing configuration generally comes from a remote source over the wire, be
+    // defensive when parsing it.
+    try {
+      Object randomSeedObj = rawLoadBalancingPolicyConfig.get("randomSeed");
+      if (randomSeedObj instanceof Double) {
+        randomSeed = ((Double) randomSeedObj).longValue();
+      }
+      return ConfigOrError.fromConfig(new ShufflingPickFirstLoadBalancer.Config(randomSeed));
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError(
+          Status.UNAVAILABLE.withDescription("unable to parse LB config").withCause(e));
+    }
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    return new ShufflingPickFirstLoadBalancer(helper);
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return "grpc.examples.customloadbalance.ShufflingPickFirst";
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/deadline/DeadlineClient.java b/examples/src/main/java/io/grpc/examples/deadline/DeadlineClient.java
new file mode 100644
index 00000000000..378688ee1cc
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/deadline/DeadlineClient.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2023 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.examples.deadline;
+
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.examples.helloworld.HelloWorldServer;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.ConsoleHandler;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.logging.SimpleFormatter;
+
+/**
+ * A simple client that requests a greeting from the {@link HelloWorldServer}.
+ *
+ * <p>This is based off the client in the helloworld example with some deadline logic added.
+ */
+public class DeadlineClient {
+  private static final Logger logger = Logger.getLogger(DeadlineClient.class.getName());
+
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+  /** Construct client for accessing HelloWorld server using the existing channel. */
+  public DeadlineClient(Channel channel) {
+    blockingStub = GreeterGrpc.newBlockingStub(channel);
+  }
+
+  /** Say hello to server. */
+  public Status greet(String name, long timeoutMillis) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response;
+    try {
+      response = blockingStub.withDeadlineAfter(timeoutMillis, TimeUnit.MILLISECONDS)
+          .sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return e.getStatus();
+    }
+    logger.info("Greeting: " + response.getMessage());
+    return Status.OK;
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the
+   * greeting. The second argument is the target server.
+   */
+  public static void main(String[] args) throws Exception {
+    System.setProperty("java.util.logging.SimpleFormatter.format",
+        "%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %4$s %2$s %5$s%6$s%n");
+
+    // Access a service running on the local machine on port 50051
+    String target = "localhost:50051";
+
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .build();
+    try {
+      DeadlineClient client = new DeadlineClient(channel);
+
+      // The server takes 500ms to process the call, so setting a deadline further in the future we
+      // should get a successful response.
+      logger.info("Calling server with a generous deadline, expected to work");
+      client.greet("deadline client", 1000);
+
+      // A smaller deadline will result in us getting a DEADLINE_EXCEEDED error.
+      logger.info(
+          "Calling server with an unrealistic (300ms) deadline, expecting a DEADLINE_EXCEEDED");
+      client.greet("deadline client", 300);
+
+      // Including the "propagate" magic string in the request will cause the server to call itself
+      // to simulate a situation where a server needs to call another server to satisfy the original
+      // request. This will double the time it takes to respond to the client request, but with
+      // an increased deadline we should get a successful response.
+      logger.info("Calling server with propagation and a generous deadline, expected to work");
+      client.greet("deadline client [propagate]", 2000);
+
+      // With this propagated call we reduce the deadline making it impossible for the both the
+      // first server call and the propagated one to succeed. You should see the call fail with
+      // DEADLINE_EXCEEDED, and you should also see DEADLINE_EXCEEDED in the server output as it
+      // runs out of time waiting for the propagated call to finish.
+      logger.info(
+          "Calling server with propagation and a generous deadline, expecting a DEADLINE_EXCEEDED");
+      client.greet("deadline client [propagate]", 1000);
+    } finally {
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/deadline/DeadlineServer.java b/examples/src/main/java/io/grpc/examples/deadline/DeadlineServer.java
new file mode 100644
index 00000000000..49214fc77d5
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/deadline/DeadlineServer.java
@@ -0,0 +1,119 @@
+
+/*
+ * Copyright 2023 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.examples.deadline;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+public class DeadlineServer {
+  private static final Logger logger = Logger.getLogger(DeadlineServer.class.getName());
+
+  private Server server;
+
+
+  private void start() throws IOException {
+    int port = 50051;
+    SlowGreeter slowGreeter = new SlowGreeter();
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(slowGreeter)
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+
+    // Create a channel to this same server so we can make a recursive call to demonstrate deadline
+    // propagation.
+    String target = "localhost:50051";
+    slowGreeter.setClientStub(GreeterGrpc.newBlockingStub(
+        Grpc.newChannelBuilder(target, InsecureChannelCredentials.create()).build()));
+
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          DeadlineServer.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** server shut down");
+      }
+    });
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    System.setProperty("java.util.logging.SimpleFormatter.format",
+        "%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS %4$s %2$s %5$s%6$s%n");
+
+    final DeadlineServer server = new DeadlineServer();
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  static class SlowGreeter extends GreeterGrpc.GreeterImplBase {
+    private GreeterGrpc.GreeterBlockingStub clientStub;
+
+    void setClientStub(GreeterGrpc.GreeterBlockingStub clientStub) {
+      this.clientStub = clientStub;
+    }
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      try {
+        Thread.sleep(500);
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+        throw new RuntimeException(e);
+      }
+
+      if (req.getName().contains("propagate")) {
+        clientStub.sayHello(HelloRequest.newBuilder().setName("Server").build());
+      }
+
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/deadline/README.md b/examples/src/main/java/io/grpc/examples/deadline/README.md
new file mode 100644
index 00000000000..3c7646f1e5f
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/deadline/README.md
@@ -0,0 +1,15 @@
+gRPC Deadline Example
+=====================
+
+A Deadline is used to specify a point in time past which a client is unwilling to wait for a response from a server.
+This simple idea is very important in building robust distributed systems.
+Clients that do not wait around unnecessarily and servers that know when to give up processing requests will improve the resource utilization and latency of your system.
+
+Note that while some language APIs have the concept of a deadline, others use the idea of a timeout. 
+When an API asks for a deadline, you provide a point in time which the call should not go past.
+A timeout is the max duration of time that the call can take. 
+A timeout can be converted to a deadline by adding the timeout to the current time when the application starts a call.
+
+This Example gives usage and implementation of Deadline on Server, Client and Propagation.
+
+Refer the gRPC documentation for more details on Deadlines https://grpc.io/docs/guides/deadlines/
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/errordetails/ErrorDetailsExample.java b/examples/src/main/java/io/grpc/examples/errordetails/ErrorDetailsExample.java
new file mode 100644
index 00000000000..1d1d72ed837
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/errordetails/ErrorDetailsExample.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright 2023 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.examples.errordetails;
+
+import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
+
+import com.google.common.base.Verify;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.Uninterruptibles;
+import com.google.protobuf.Any;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.rpc.Code;
+import com.google.rpc.DebugInfo;
+import com.google.rpc.Status;
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.GreeterGrpc.GreeterBlockingStub;
+import io.grpc.examples.helloworld.GreeterGrpc.GreeterFutureStub;
+import io.grpc.examples.helloworld.GreeterGrpc.GreeterStub;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.protobuf.StatusProto;
+import io.grpc.stub.StreamObserver;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * Shows how to set and read com.google.rpc.Status objects as google.rpc.Status error details.
+ */
+public class ErrorDetailsExample {
+  private static final DebugInfo DEBUG_INFO =
+      DebugInfo.newBuilder()
+          .addStackEntries("stack_entry_1")
+          .addStackEntries("stack_entry_2")
+          .addStackEntries("stack_entry_3")
+          .setDetail("detailed error info.").build();
+
+  public static void main(String[] args) throws Exception {
+    Server server = null;
+    ManagedChannel channel = null;
+
+    try {
+      server = launchServer();
+      channel = Grpc.newChannelBuilderForAddress(
+          "localhost", server.getPort(), InsecureChannelCredentials.create()).build();
+
+      runClientTests(channel);
+    } finally {
+      cleanup(channel, server);
+    }
+  }
+
+
+  /**
+   * Create server and start it
+   */
+  static Server launchServer() throws Exception {
+    return Grpc.newServerBuilderForPort(0, InsecureServerCredentials.create())
+        .addService(new GreeterGrpc.GreeterImplBase() {
+          @Override
+          public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
+            // This is com.google.rpc.Status, not io.grpc.Status
+            Status status = Status.newBuilder()
+                .setCode(Code.INVALID_ARGUMENT.getNumber())
+                .setMessage("Email or password malformed")
+                .addDetails(Any.pack(DEBUG_INFO))
+                .build();
+            responseObserver.onError(StatusProto.toStatusRuntimeException(status));
+          }
+        })
+        .build()
+        .start();
+  }
+
+  private static void runClientTests(Channel channel) {
+    blockingCall(channel);
+    futureCallDirect(channel);
+    futureCallCallback(channel);
+    asyncCall(channel);
+  }
+
+  private static void cleanup(ManagedChannel channel, Server server) throws InterruptedException {
+
+    // Shutdown client and server for resources to be cleanly released
+    if (channel != null) {
+      channel.shutdown();
+    }
+    if (server != null) {
+      server.shutdown();
+    }
+
+    // Wait for cleanup to complete
+    if (channel != null) {
+      channel.awaitTermination(1, TimeUnit.SECONDS);
+    }
+    if (server != null) {
+      server.awaitTermination(1, TimeUnit.SECONDS);
+    }
+  }
+
+  static void verifyErrorReply(Throwable t) {
+    Status status = StatusProto.fromThrowable(t);
+    Verify.verify(status.getCode() == Code.INVALID_ARGUMENT.getNumber());
+    Verify.verify(status.getMessage().equals("Email or password malformed"));
+    try {
+      DebugInfo unpackedDetail = status.getDetails(0).unpack(DebugInfo.class);
+      Verify.verify(unpackedDetail.equals(DEBUG_INFO));
+    } catch (InvalidProtocolBufferException e) {
+      Verify.verify(false, "Message was a different type than expected");
+    }
+  }
+
+  static void blockingCall(Channel channel) {
+    GreeterBlockingStub stub = GreeterGrpc.newBlockingStub(channel);
+    try {
+      stub.sayHello(HelloRequest.newBuilder().build());
+    } catch (Exception e) {
+      verifyErrorReply(e);
+      System.out.println("Blocking call received expected error details");
+    }
+  }
+
+  static void futureCallDirect(Channel channel) {
+    GreeterFutureStub stub = GreeterGrpc.newFutureStub(channel);
+    ListenableFuture<HelloReply> response =
+        stub.sayHello(HelloRequest.newBuilder().build());
+
+    try {
+      response.get();
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      throw new RuntimeException(e);
+    } catch (ExecutionException e) {
+      verifyErrorReply(e.getCause());
+      System.out.println("Future call direct received expected error details");
+    }
+  }
+
+  static void futureCallCallback(Channel channel) {
+    GreeterFutureStub stub = GreeterGrpc.newFutureStub(channel);
+    ListenableFuture<HelloReply> response =
+        stub.sayHello(HelloRequest.newBuilder().build());
+
+    final CountDownLatch latch = new CountDownLatch(1);
+
+    Futures.addCallback(
+        response,
+        new FutureCallback<HelloReply>() {
+          @Override
+          public void onSuccess(@Nullable HelloReply result) {
+            // Won't be called, since the server in this example always fails.
+          }
+
+          @Override
+          public void onFailure(Throwable t) {
+            verifyErrorReply(t);
+            System.out.println("Future callback received expected error details");
+            latch.countDown();
+          }
+        },
+        directExecutor());
+
+    if (!Uninterruptibles.awaitUninterruptibly(latch, 1, TimeUnit.SECONDS)) {
+      throw new RuntimeException("timeout!");
+    }
+  }
+
+  static void asyncCall(Channel channel) {
+    GreeterStub stub = GreeterGrpc.newStub(channel);
+    HelloRequest request = HelloRequest.newBuilder().build();
+    final CountDownLatch latch = new CountDownLatch(1);
+    StreamObserver<HelloReply> responseObserver = new StreamObserver<HelloReply>() {
+
+      @Override
+      public void onNext(HelloReply value) {
+        // Won't be called.
+      }
+
+      @Override
+      public void onError(Throwable t) {
+        verifyErrorReply(t);
+        System.out.println("Async call received expected error details");
+        latch.countDown();
+      }
+
+      @Override
+      public void onCompleted() {
+        // Won't be called, since the server in this example always fails.
+      }
+    };
+    stub.sayHello(request, responseObserver);
+
+    if (!Uninterruptibles.awaitUninterruptibly(latch, 1, TimeUnit.SECONDS)) {
+      throw new RuntimeException("timeout!");
+    }
+  }
+}
+
diff --git a/examples/src/main/java/io/grpc/examples/errordetails/README.md b/examples/src/main/java/io/grpc/examples/errordetails/README.md
new file mode 100644
index 00000000000..8f241ba37a7
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/errordetails/README.md
@@ -0,0 +1,16 @@
+gRPC Error Details Example
+=====================
+
+If a gRPC call completes successfully the server returns an OK status to the client (depending on the language the OK status may or may not be directly used in your code). 
+But what happens if the call isn’t successful?
+
+This Example gives the usage and implementation of how return the error details if gRPC call not successful or fails
+and how to set and read com.google.rpc.Status objects as google.rpc.Status error details.
+
+gRPC allows detailed error information to be encapsulated in protobuf messages, which are sent alongside the status codes.
+
+If an error occurs, gRPC returns one of its error status codes with error message that provides further error details about what happened.
+
+Refer the below links for more details on error details and status codes  
+- https://grpc.io/docs/guides/error/
+- https://github.com/grpc/grpc-java/blob/master/api/src/main/java/io/grpc/Status.java
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java b/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
index 25fdc25577c..b026b6f32dc 100644
--- a/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
+++ b/examples/src/main/java/io/grpc/examples/errorhandling/DetailErrorSample.java
@@ -1,36 +1,23 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.errorhandling;
 
+import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
+
 import com.google.common.base.Verify;
 import com.google.common.base.VerifyException;
 import com.google.common.util.concurrent.FutureCallback;
@@ -38,14 +25,14 @@
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.Uninterruptibles;
 import com.google.rpc.DebugInfo;
-
 import io.grpc.CallOptions;
 import io.grpc.ClientCall;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
 import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
 import io.grpc.Metadata;
 import io.grpc.Server;
-import io.grpc.ServerBuilder;
 import io.grpc.Status;
 import io.grpc.examples.helloworld.GreeterGrpc;
 import io.grpc.examples.helloworld.GreeterGrpc.GreeterBlockingStub;
@@ -55,11 +42,9 @@
 import io.grpc.examples.helloworld.HelloRequest;
 import io.grpc.protobuf.ProtoUtils;
 import io.grpc.stub.StreamObserver;
-
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
-
 import javax.annotation.Nullable;
 
 /**
@@ -89,7 +74,8 @@ public static void main(String[] args) throws Exception {
   private ManagedChannel channel;
 
   void run() throws Exception {
-    Server server = ServerBuilder.forPort(0).addService(new GreeterGrpc.GreeterImplBase() {
+    Server server = Grpc.newServerBuilderForPort(0, InsecureServerCredentials.create())
+        .addService(new GreeterGrpc.GreeterImplBase() {
       @Override
       public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
         Metadata trailers = new Metadata();
@@ -98,8 +84,8 @@ public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseOb
             .asRuntimeException(trailers));
       }
     }).build().start();
-    channel =
-        ManagedChannelBuilder.forAddress("localhost", server.getPort()).usePlaintext(true).build();
+    channel = Grpc.newChannelBuilderForAddress(
+          "localhost", server.getPort(), InsecureChannelCredentials.create()).build();
 
     blockingCall();
     futureCallDirect();
@@ -157,18 +143,21 @@ void futureCallCallback() {
 
     final CountDownLatch latch = new CountDownLatch(1);
 
-    Futures.addCallback(response, new FutureCallback<HelloReply>() {
-      @Override
-      public void onSuccess(@Nullable HelloReply result) {
-        // Won't be called, since the server in this example always fails.
-      }
-
-      @Override
-      public void onFailure(Throwable t) {
-        verifyErrorReply(t);
-        latch.countDown();
-      }
-    });
+    Futures.addCallback(
+        response,
+        new FutureCallback<HelloReply>() {
+          @Override
+          public void onSuccess(@Nullable HelloReply result) {
+            // Won't be called, since the server in this example always fails.
+          }
+
+          @Override
+          public void onFailure(Throwable t) {
+            verifyErrorReply(t);
+            latch.countDown();
+          }
+        },
+        directExecutor());
 
     if (!Uninterruptibles.awaitUninterruptibly(latch, 1, TimeUnit.SECONDS)) {
       throw new RuntimeException("timeout!");
@@ -211,7 +200,7 @@ public void onCompleted() {
    */
   void advancedAsyncCall() {
     ClientCall<HelloRequest, HelloReply> call =
-        channel.newCall(GreeterGrpc.METHOD_SAY_HELLO, CallOptions.DEFAULT);
+        channel.newCall(GreeterGrpc.getSayHelloMethod(), CallOptions.DEFAULT);
 
     final CountDownLatch latch = new CountDownLatch(1);
 
diff --git a/examples/src/main/java/io/grpc/examples/errorhandling/ErrorHandlingClient.java b/examples/src/main/java/io/grpc/examples/errorhandling/ErrorHandlingClient.java
index bdfdb8ed122..9f86e9ceac8 100644
--- a/examples/src/main/java/io/grpc/examples/errorhandling/ErrorHandlingClient.java
+++ b/examples/src/main/java/io/grpc/examples/errorhandling/ErrorHandlingClient.java
@@ -1,49 +1,36 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.errorhandling;
 
+import static com.google.common.util.concurrent.MoreExecutors.directExecutor;
+
 import com.google.common.base.Verify;
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.Uninterruptibles;
-
 import io.grpc.CallOptions;
 import io.grpc.ClientCall;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
 import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
 import io.grpc.Metadata;
 import io.grpc.Server;
-import io.grpc.ServerBuilder;
 import io.grpc.Status;
 import io.grpc.examples.helloworld.GreeterGrpc;
 import io.grpc.examples.helloworld.GreeterGrpc.GreeterBlockingStub;
@@ -52,15 +39,13 @@
 import io.grpc.examples.helloworld.HelloReply;
 import io.grpc.examples.helloworld.HelloRequest;
 import io.grpc.stub.StreamObserver;
-
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
-
 import javax.annotation.Nullable;
 
 /**
- * Shows how to extract error information from a server response.
+ * Shows how to extract error information from a failed RPC.
  */
 public class ErrorHandlingClient {
   public static void main(String [] args) throws Exception {
@@ -71,15 +56,18 @@ public static void main(String [] args) throws Exception {
 
   void run() throws Exception {
     // Port 0 means that the operating system will pick an available port to use.
-    Server server = ServerBuilder.forPort(0).addService(new GreeterGrpc.GreeterImplBase() {
+    Server server = Grpc.newServerBuilderForPort(0, InsecureServerCredentials.create())
+        .addService(new GreeterGrpc.GreeterImplBase() {
       @Override
       public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
+        // The server will always fail, and we'll see this failure on client-side. The exception is
+        // not sent to the client, only the status code (i.e., INTERNAL) and description.
         responseObserver.onError(Status.INTERNAL
             .withDescription("Eggplant Xerxes Crybaby Overbite Narwhal").asRuntimeException());
       }
     }).build().start();
-    channel =
-        ManagedChannelBuilder.forAddress("localhost", server.getPort()).usePlaintext(true).build();
+    channel = Grpc.newChannelBuilderForAddress(
+        "localhost", server.getPort(), InsecureChannelCredentials.create()).build();
 
     blockingCall();
     futureCallDirect();
@@ -130,21 +118,24 @@ void futureCallCallback() {
 
     final CountDownLatch latch = new CountDownLatch(1);
 
-    Futures.addCallback(response, new FutureCallback<HelloReply>() {
-      @Override
-      public void onSuccess(@Nullable HelloReply result) {
-        // Won't be called, since the server in this example always fails.
-      }
-
-      @Override
-      public void onFailure(Throwable t) {
-        Status status = Status.fromThrowable(t);
-        Verify.verify(status.getCode() == Status.Code.INTERNAL);
-        Verify.verify(status.getDescription().contains("Crybaby"));
-        // Cause is not transmitted over the wire..
-        latch.countDown();
-      }
-    });
+    Futures.addCallback(
+        response,
+        new FutureCallback<HelloReply>() {
+          @Override
+          public void onSuccess(@Nullable HelloReply result) {
+            // Won't be called, since the server in this example always fails.
+          }
+
+          @Override
+          public void onFailure(Throwable t) {
+            Status status = Status.fromThrowable(t);
+            Verify.verify(status.getCode() == Status.Code.INTERNAL);
+            Verify.verify(status.getDescription().contains("Crybaby"));
+            // Cause is not transmitted over the wire..
+            latch.countDown();
+          }
+        },
+        directExecutor());
 
     if (!Uninterruptibles.awaitUninterruptibly(latch, 1, TimeUnit.SECONDS)) {
       throw new RuntimeException("timeout!");
@@ -190,7 +181,7 @@ public void onCompleted() {
    */
   void advancedAsyncCall() {
     ClientCall<HelloRequest, HelloReply> call =
-        channel.newCall(GreeterGrpc.METHOD_SAY_HELLO, CallOptions.DEFAULT);
+        channel.newCall(GreeterGrpc.getSayHelloMethod(), CallOptions.DEFAULT);
 
     final CountDownLatch latch = new CountDownLatch(1);
 
diff --git a/examples/src/main/java/io/grpc/examples/errorhandling/README.md b/examples/src/main/java/io/grpc/examples/errorhandling/README.md
new file mode 100644
index 00000000000..a920e939c86
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/errorhandling/README.md
@@ -0,0 +1,27 @@
+gRPC Error Handling Example
+=====================
+
+Error handling in gRPC is a critical aspect of designing reliable and robust distributed systems. 
+gRPC provides a standardized mechanism for handling errors using status codes, error details, and optional metadata.
+
+This Example gives the usage and implementation of how to handle the Errors/Exceptions in gRPC,
+shows how to extract error information from a failed RPC and setting and reading RPC error details.
+
+If a gRPC call completes successfully the server returns an OK status to the client (depending on the language the OK status may or may not be directly used in your code).
+
+If an error occurs gRPC returns one of its error status codes with error message that provides further error details about what happened.
+
+Error Propagation:
+- When an error occurs on the server, gRPC stops processing the RPC and sends the error (status code, description, and optional details) to the client.
+- On the client side, the error can be handled based on the status code.
+
+Client Side Error Handling: 
+ - The gRPC client typically throws an exception or returns an error object when an RPC fails.
+
+Server Side Error Handling:
+- Servers use the gRPC API to return errors explicitly using the grpc library's status functions.
+
+gRPC uses predefined status codes to represent the outcome of an RPC call. These status codes are part of the Status object that is sent from the server to the client.
+Each status code is accompanied by a human-readable description(Please refer https://github.com/grpc/grpc-java/blob/master/api/src/main/java/io/grpc/Status.java)
+
+Refer the gRPC documentation for more details on Error Handling https://grpc.io/docs/guides/error/
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldClient.java b/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldClient.java
index 22b621e81ae..49e9cb36d53 100644
--- a/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldClient.java
+++ b/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldClient.java
@@ -1,43 +1,28 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.experimental;
 
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
 import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
 import io.grpc.StatusRuntimeException;
 import io.grpc.examples.helloworld.GreeterGrpc;
 import io.grpc.examples.helloworld.HelloReply;
 import io.grpc.examples.helloworld.HelloRequest;
-
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -46,7 +31,7 @@
  * A simple client that requests a greeting from the
  *      {@link io.grpc.examples.helloworld.HelloWorldServer}.
  *
- * <p>This class should act a a drop in replacement for
+ * <p>This class should act a drop in replacement for
  *      {@link io.grpc.examples.helloworld.HelloWorldClient}.
  */
 public class CompressingHelloWorldClient {
@@ -58,8 +43,7 @@ public class CompressingHelloWorldClient {
 
   /** Construct client connecting to HelloWorld server at {@code host:port}. */
   public CompressingHelloWorldClient(String host, int port) {
-    channel = ManagedChannelBuilder.forAddress(host, port)
-        .usePlaintext(true)
+    channel = Grpc.newChannelBuilderForAddress(host, port, InsecureChannelCredentials.create())
         .build();
     blockingStub = GreeterGrpc.newBlockingStub(channel);
   }
@@ -89,12 +73,13 @@ public void greet(String name) {
    * greeting.
    */
   public static void main(String[] args) throws Exception {
+    // Access a service running on the local machine on port 50051
     CompressingHelloWorldClient client = new CompressingHelloWorldClient("localhost", 50051);
     try {
-      /* Access a service running on the local machine on port 50051 */
       String user = "world";
+      // Use the arg as the name to greet if provided
       if (args.length > 0) {
-        user = args[0]; /* Use the arg as the name to greet if provided */
+        user = args[0];
       }
       client.greet(user);
     } finally {
diff --git a/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerAllMethods.java b/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerAllMethods.java
new file mode 100644
index 00000000000..794d7196f35
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerAllMethods.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2019 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.examples.experimental;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Metadata;
+import io.grpc.Server;
+import io.grpc.ServerCall;
+import io.grpc.ServerCall.Listener;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+
+/**
+ * Server that manages startup/shutdown of a {@code Greeter} server
+ * with an interceptor to enable compression for all responses.
+ */
+public class CompressingHelloWorldServerAllMethods {
+  private static final Logger logger = Logger.getLogger(CompressingHelloWorldServerAllMethods.class.getName());
+
+  private Server server;
+
+  private void start() throws IOException {
+    /* The port on which the server should run */
+    int port = 50051;
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        /* This method call adds the Interceptor to enable compressed server responses for all RPCs */
+        .intercept(new ServerInterceptor() {
+          @Override
+          public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers,
+              ServerCallHandler<ReqT, RespT> next) {
+            call.setCompression("gzip");
+            return next.startCall(call, headers);
+          }
+        })
+        .addService(new GreeterImpl())
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          CompressingHelloWorldServerAllMethods.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** server shut down");
+      }
+    });
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    CompressingHelloWorldServerAllMethods server = new CompressingHelloWorldServerAllMethods();
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerPerMethod.java b/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerPerMethod.java
new file mode 100644
index 00000000000..b7faa96d7b4
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/experimental/CompressingHelloWorldServerPerMethod.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright 2019 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.examples.experimental;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.ServerCallStreamObserver;
+import io.grpc.stub.StreamObserver;
+
+/**
+ * Server that manages startup/shutdown of a {@code Greeter} server
+ * that enables compressed responses for only particular methods
+ */
+public class CompressingHelloWorldServerPerMethod {
+  private static final Logger logger = Logger.getLogger(CompressingHelloWorldServerPerMethod.class.getName());
+
+  private Server server;
+
+  private void start() throws IOException {
+    /* The port on which the server should run */
+    int port = 50051;
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new GreeterImpl())
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          CompressingHelloWorldServerPerMethod.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** server shut down");
+      }
+    });
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    CompressingHelloWorldServerPerMethod server = new CompressingHelloWorldServerPerMethod();
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> plainResponseObserver) {
+      ServerCallStreamObserver<HelloReply> responseObserver =
+          (ServerCallStreamObserver<HelloReply>) plainResponseObserver;
+      /* This line by itself enables compression for the response */
+      responseObserver.setCompression("gzip");
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/experimental/README.md b/examples/src/main/java/io/grpc/examples/experimental/README.md
new file mode 100644
index 00000000000..295b0801538
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/experimental/README.md
@@ -0,0 +1,13 @@
+gRPC Compression Example
+=====================
+
+This example shows how clients can specify compression options when performing RPCs, 
+and how to enable compressed(i,e gzip) requests/responses for only particular method and in case of all methods by using the interceptors.
+
+Compression is used to reduce the amount of bandwidth used when communicating between client/server or peers and 
+can be enabled or disabled based on call or message level for all languages.
+
+gRPC allows asymmetrically compressed communication, whereby a response may be compressed differently with the request, 
+or not compressed at all.
+
+Refer the gRPC documentation for more details on Compression https://grpc.io/docs/guides/compression/
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/grpcproxy/GrpcProxy.java b/examples/src/main/java/io/grpc/examples/grpcproxy/GrpcProxy.java
new file mode 100644
index 00000000000..b576680560f
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/grpcproxy/GrpcProxy.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright 2023, gRPC Authors All rights reserved.
+ *
+ * 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.examples.grpcproxy;
+
+import com.google.common.io.ByteStreams;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.Grpc;
+import io.grpc.HandlerRegistry;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Server;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerMethodDefinition;
+import io.grpc.Status;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * A grpc-level proxy. GrpcProxy itself can be used unmodified to proxy any service for both unary
+ * and streaming. It doesn't care what type of messages are being used. The Registry class causes it
+ * to be called for any inbound RPC, and uses plain bytes for messages which avoids marshalling
+ * messages and the need for Protobuf schema information.
+ *
+ * <p>Route guide has unary and streaming RPCs which makes it a nice showcase. To test with route
+ * guide, run each in a separate terminal window:
+ * <pre>{@code
+ *   ./build/install/examples/bin/route-guide-server
+ *   ./build/install/examples/bin/grpc-proxy
+ *   ./build/install/examples/bin/route-guide-client localhost:8981
+ * }<pre>
+ *
+ * <p>You can verify the proxy is being used by shutting down the proxy and seeing the client fail.
+ */
+public final class GrpcProxy<ReqT, RespT> implements ServerCallHandler<ReqT, RespT> {
+  private static final Logger logger = Logger.getLogger(GrpcProxy.class.getName());
+
+  private final Channel channel;
+
+  public GrpcProxy(Channel channel) {
+    this.channel = channel;
+  }
+
+  @Override
+  public ServerCall.Listener<ReqT> startCall(
+      ServerCall<ReqT, RespT> serverCall, Metadata headers) {
+    ClientCall<ReqT, RespT> clientCall
+        = channel.newCall(serverCall.getMethodDescriptor(), CallOptions.DEFAULT);
+    CallProxy<ReqT, RespT> proxy = new CallProxy<ReqT, RespT>(serverCall, clientCall);
+    clientCall.start(proxy.clientCallListener, headers);
+    serverCall.request(1);
+    clientCall.request(1);
+    return proxy.serverCallListener;
+  }
+
+  private static class CallProxy<ReqT, RespT> {
+    final RequestProxy serverCallListener;
+    final ResponseProxy clientCallListener;
+
+    public CallProxy(ServerCall<ReqT, RespT> serverCall, ClientCall<ReqT, RespT> clientCall) {
+      serverCallListener = new RequestProxy(clientCall);
+      clientCallListener = new ResponseProxy(serverCall);
+    }
+
+    private class RequestProxy extends ServerCall.Listener<ReqT> {
+      private final ClientCall<ReqT, ?> clientCall;
+      // Hold 'this' lock when accessing
+      private boolean needToRequest;
+
+      public RequestProxy(ClientCall<ReqT, ?> clientCall) {
+        this.clientCall = clientCall;
+      }
+
+      @Override public void onCancel() {
+        clientCall.cancel("Server cancelled", null);
+      }
+
+      @Override public void onHalfClose() {
+        clientCall.halfClose();
+      }
+
+      @Override public void onMessage(ReqT message) {
+        clientCall.sendMessage(message);
+        synchronized (this) {
+          if (clientCall.isReady()) {
+            clientCallListener.serverCall.request(1);
+          } else {
+            // The outgoing call is not ready for more requests. Stop requesting additional data and
+            // wait for it to catch up.
+            needToRequest = true;
+          }
+        }
+      }
+
+      @Override public void onReady() {
+        clientCallListener.onServerReady();
+      }
+
+      // Called from ResponseProxy, which is a different thread than the ServerCall.Listener
+      // callbacks.
+      synchronized void onClientReady() {
+        if (needToRequest) {
+          clientCallListener.serverCall.request(1);
+          needToRequest = false;
+        }
+      }
+    }
+
+    private class ResponseProxy extends ClientCall.Listener<RespT> {
+      private final ServerCall<?, RespT> serverCall;
+      // Hold 'this' lock when accessing
+      private boolean needToRequest;
+
+      public ResponseProxy(ServerCall<?, RespT> serverCall) {
+        this.serverCall = serverCall;
+      }
+
+      @Override public void onClose(Status status, Metadata trailers) {
+        serverCall.close(status, trailers);
+      }
+
+      @Override public void onHeaders(Metadata headers) {
+        serverCall.sendHeaders(headers);
+      }
+
+      @Override public void onMessage(RespT message) {
+        serverCall.sendMessage(message);
+        synchronized (this) {
+          if (serverCall.isReady()) {
+            serverCallListener.clientCall.request(1);
+          } else {
+            // The incoming call is not ready for more responses. Stop requesting additional data
+            // and wait for it to catch up.
+            needToRequest = true;
+          }
+        }
+      }
+
+      @Override public void onReady() {
+        serverCallListener.onClientReady();
+      }
+
+      // Called from RequestProxy, which is a different thread than the ClientCall.Listener
+      // callbacks.
+      synchronized void onServerReady() {
+        if (needToRequest) {
+          serverCallListener.clientCall.request(1);
+          needToRequest = false;
+        }
+      }
+    }
+  }
+
+  private static class ByteMarshaller implements MethodDescriptor.Marshaller<byte[]> {
+    @Override public byte[] parse(InputStream stream) {
+      try {
+        return ByteStreams.toByteArray(stream);
+      } catch (IOException ex) {
+        throw new RuntimeException();
+      }
+    }
+
+    @Override public InputStream stream(byte[] value) {
+      return new ByteArrayInputStream(value);
+    }
+  };
+
+  public static class Registry extends HandlerRegistry {
+    private final MethodDescriptor.Marshaller<byte[]> byteMarshaller = new ByteMarshaller();
+    private final ServerCallHandler<byte[], byte[]> handler;
+
+    public Registry(ServerCallHandler<byte[], byte[]> handler) {
+      this.handler = handler;
+    }
+
+    @Override
+    public ServerMethodDefinition<?,?> lookupMethod(String methodName, String authority) {
+      MethodDescriptor<byte[], byte[]> methodDescriptor
+          = MethodDescriptor.newBuilder(byteMarshaller, byteMarshaller)
+          .setFullMethodName(methodName)
+          .setType(MethodDescriptor.MethodType.UNKNOWN)
+          .build();
+      return ServerMethodDefinition.create(methodDescriptor, handler);
+    }
+  }
+
+  public static void main(String[] args) throws IOException, InterruptedException {
+    String target = "localhost:8980";
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .build();
+    logger.info("Proxy will connect to " + target);
+    GrpcProxy<byte[], byte[]> proxy = new GrpcProxy<byte[], byte[]>(channel);
+    int port = 8981;
+    Server server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .fallbackHandlerRegistry(new Registry(proxy))
+        .build()
+        .start();
+    logger.info("Proxy started, listening on " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        server.shutdown();
+        try {
+          server.awaitTermination(10, TimeUnit.SECONDS);
+        } catch (InterruptedException ex) {
+          Thread.currentThread().interrupt();
+        }
+        server.shutdownNow();
+        channel.shutdownNow();
+      }
+    });
+    server.awaitTermination();
+    if (!channel.awaitTermination(1, TimeUnit.SECONDS)) {
+      System.out.println("Channel didn't shut down promptly");
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/grpcproxy/README.md b/examples/src/main/java/io/grpc/examples/grpcproxy/README.md
new file mode 100644
index 00000000000..cc13dc3d9d0
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/grpcproxy/README.md
@@ -0,0 +1,22 @@
+gRPC Proxy Example
+=====================
+
+A gRPC proxy is a component or tool that acts as an intermediary between gRPC clients and servers, 
+facilitating communication while offering additional capabilities.
+Proxies are used in scenarios where you need to handle tasks like load balancing, routing, monitoring, 
+or providing a bridge between gRPC and other protocols.
+
+GrpcProxy itself can be used unmodified to proxy any service for both unary and streaming.
+It doesn't care what type of messages are being used.
+The Registry class causes it to be called for any inbound RPC, and uses plain bytes for messages which avoids marshalling
+messages and the need for Protobuf schema information.
+
+We can run the Grpc Proxy with Route guide example to see how it works by running the below
+
+Route guide has unary and streaming RPCs which makes it a nice showcase, and we can run each in a separate terminal window.
+
+./build/install/examples/bin/route-guide-server 
+./build/install/examples/bin/grpc-proxy 
+./build/install/examples/bin/route-guide-client localhost:8981
+
+you can verify the proxy is being used by shutting down the proxy and seeing the client fail.
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/header/CustomHeaderClient.java b/examples/src/main/java/io/grpc/examples/header/CustomHeaderClient.java
index b07516e8027..52287040ba0 100644
--- a/examples/src/main/java/io/grpc/examples/header/CustomHeaderClient.java
+++ b/examples/src/main/java/io/grpc/examples/header/CustomHeaderClient.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.header;
@@ -34,13 +19,13 @@
 import io.grpc.Channel;
 import io.grpc.ClientInterceptor;
 import io.grpc.ClientInterceptors;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
 import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
 import io.grpc.StatusRuntimeException;
 import io.grpc.examples.helloworld.GreeterGrpc;
 import io.grpc.examples.helloworld.HelloReply;
 import io.grpc.examples.helloworld.HelloRequest;
-
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -59,8 +44,8 @@ public class CustomHeaderClient {
    * A custom client.
    */
   private CustomHeaderClient(String host, int port) {
-    originChannel = ManagedChannelBuilder.forAddress(host, port)
-        .usePlaintext(true)
+    originChannel = Grpc
+        .newChannelBuilderForAddress(host, port, InsecureChannelCredentials.create())
         .build();
     ClientInterceptor interceptor = new HeaderClientInterceptor();
     Channel channel = ClientInterceptors.intercept(originChannel, interceptor);
@@ -91,12 +76,13 @@ private void greet(String name) {
    * Main start the client from the command line.
    */
   public static void main(String[] args) throws Exception {
+    // Access a service running on the local machine on port 50051
     CustomHeaderClient client = new CustomHeaderClient("localhost", 50051);
     try {
-      /* Access a service running on the local machine on port 50051 */
       String user = "world";
+      // Use the arg as the name to greet if provided
       if (args.length > 0) {
-        user = args[0]; /* Use the arg as the name to greet if provided */
+        user = args[0]; 
       }
       client.greet(user);
     } finally {
diff --git a/examples/src/main/java/io/grpc/examples/header/CustomHeaderServer.java b/examples/src/main/java/io/grpc/examples/header/CustomHeaderServer.java
index b6c62cff60f..75a3d24934f 100644
--- a/examples/src/main/java/io/grpc/examples/header/CustomHeaderServer.java
+++ b/examples/src/main/java/io/grpc/examples/header/CustomHeaderServer.java
@@ -1,45 +1,31 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.header;
 
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
 import io.grpc.Server;
-import io.grpc.ServerBuilder;
 import io.grpc.ServerInterceptors;
 import io.grpc.examples.helloworld.GreeterGrpc;
 import io.grpc.examples.helloworld.HelloReply;
 import io.grpc.examples.helloworld.HelloRequest;
 import io.grpc.stub.StreamObserver;
-
 import java.io.IOException;
+import java.util.concurrent.TimeUnit;
 import java.util.logging.Logger;
 
 /**
@@ -50,29 +36,33 @@ public class CustomHeaderServer {
   private static final Logger logger = Logger.getLogger(CustomHeaderServer.class.getName());
 
   /* The port on which the server should run */
-  private static final int port = 50051;
+  private static final int PORT = 50051;
   private Server server;
 
   private void start() throws IOException {
-    server = ServerBuilder.forPort(port)
+    server = Grpc.newServerBuilderForPort(PORT, InsecureServerCredentials.create())
         .addService(ServerInterceptors.intercept(new GreeterImpl(), new HeaderServerInterceptor()))
         .build()
         .start();
-    logger.info("Server started, listening on " + port);
+    logger.info("Server started, listening on " + PORT);
     Runtime.getRuntime().addShutdownHook(new Thread() {
       @Override
       public void run() {
         // Use stderr here since the logger may have been reset by its JVM shutdown hook.
         System.err.println("*** shutting down gRPC server since JVM is shutting down");
-        CustomHeaderServer.this.stop();
+        try {
+          CustomHeaderServer.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
         System.err.println("*** server shut down");
       }
     });
   }
 
-  private void stop() {
+  private void stop() throws InterruptedException {
     if (server != null) {
-      server.shutdown();
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
     }
   }
 
diff --git a/examples/src/main/java/io/grpc/examples/header/HeaderClientInterceptor.java b/examples/src/main/java/io/grpc/examples/header/HeaderClientInterceptor.java
index a7042e33c13..2a60eeda6c4 100644
--- a/examples/src/main/java/io/grpc/examples/header/HeaderClientInterceptor.java
+++ b/examples/src/main/java/io/grpc/examples/header/HeaderClientInterceptor.java
@@ -1,38 +1,22 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.header;
 
 import com.google.common.annotations.VisibleForTesting;
-
 import io.grpc.CallOptions;
 import io.grpc.Channel;
 import io.grpc.ClientCall;
@@ -41,7 +25,6 @@
 import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
-
 import java.util.logging.Logger;
 
 /**
@@ -69,7 +52,7 @@ public void start(Listener<RespT> responseListener, Metadata headers) {
           public void onHeaders(Metadata headers) {
             /**
              * if you don't need receive header from server,
-             * you can use {@link io.grpc.stub.MetadataUtils#attachHeaders}
+             * you can use {@link io.grpc.stub.MetadataUtils#newAttachHeadersInterceptor}
              * directly to send header
              */
             logger.info("header received from server:" + headers);
diff --git a/examples/src/main/java/io/grpc/examples/header/HeaderServerInterceptor.java b/examples/src/main/java/io/grpc/examples/header/HeaderServerInterceptor.java
index 2d1f52a9cfc..35ca71ed0b3 100644
--- a/examples/src/main/java/io/grpc/examples/header/HeaderServerInterceptor.java
+++ b/examples/src/main/java/io/grpc/examples/header/HeaderServerInterceptor.java
@@ -1,44 +1,27 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.header;
 
 import com.google.common.annotations.VisibleForTesting;
-
 import io.grpc.ForwardingServerCall.SimpleForwardingServerCall;
 import io.grpc.Metadata;
 import io.grpc.ServerCall;
 import io.grpc.ServerCallHandler;
 import io.grpc.ServerInterceptor;
-
 import java.util.logging.Logger;
 
 /**
diff --git a/examples/src/main/java/io/grpc/examples/header/README.md b/examples/src/main/java/io/grpc/examples/header/README.md
new file mode 100644
index 00000000000..1563a2799cc
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/header/README.md
@@ -0,0 +1,16 @@
+gRPC Custom Header Example
+=====================
+
+This example gives the usage and implementation of how to create and process(send/receive) the custom headers between Client and Server 
+using the interceptors (HeaderServerInterceptor, ClientServerInterceptor) along with Metadata.
+
+Metadata is a side channel that allows clients and servers to provide information to each other that is associated with an RPC.
+gRPC metadata is a key-value pair of data that is sent with initial or final gRPC requests or responses. 
+It is used to provide additional information about the call, such as authentication credentials, 
+tracing information, or custom headers.
+
+gRPC metadata can be used to send custom headers to the server or from the server to the client. 
+This can be used to implement application-specific features, such as load balancing, 
+rate limiting or providing detailed error messages from the server to the client.
+
+Refer the gRPC documentation for more on Metadata/Headers https://grpc.io/docs/guides/metadata/
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/healthservice/HealthServiceClient.java b/examples/src/main/java/io/grpc/examples/healthservice/HealthServiceClient.java
new file mode 100644
index 00000000000..471084feab6
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/healthservice/HealthServiceClient.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright 2023 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.examples.healthservice;
+
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.health.v1.HealthCheckRequest;
+import io.grpc.health.v1.HealthCheckResponse;
+import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
+import io.grpc.health.v1.HealthGrpc;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A client that requests a greeting from the {@link HelloWorldServer}.
+ */
+public class HealthServiceClient {
+  private static final Logger logger = Logger.getLogger(HealthServiceClient.class.getName());
+
+  private final GreeterGrpc.GreeterBlockingStub greeterBlockingStub;
+  private final HealthGrpc.HealthStub healthStub;
+  private final HealthGrpc.HealthBlockingStub healthBlockingStub;
+
+  private final HealthCheckRequest healthRequest;
+
+  /** Construct client for accessing HelloWorld server using the existing channel. */
+  public HealthServiceClient(Channel channel) {
+    greeterBlockingStub = GreeterGrpc.newBlockingStub(channel);
+    healthStub = HealthGrpc.newStub(channel);
+    healthBlockingStub = HealthGrpc.newBlockingStub(channel);
+    healthRequest = HealthCheckRequest.getDefaultInstance();
+    LoadBalancerProvider roundRobin = LoadBalancerRegistry.getDefaultRegistry()
+        .getProvider("round_robin");
+
+  }
+
+  private ServingStatus checkHealth(String prefix) {
+    HealthCheckResponse response =
+        healthBlockingStub.check(healthRequest);
+    logger.info(prefix + ", current health is: " + response.getStatus());
+    return response.getStatus();
+  }
+
+  /** Say hello to server. */
+  public void greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response;
+    try {
+      response = greeterBlockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    } catch (Exception e) {
+      e.printStackTrace();
+      return;
+    }
+    logger.info("Greeting: " + response.getMessage());
+  }
+
+
+  private static void runTest(String target, String[] users, boolean useRoundRobin)
+      throws InterruptedException {
+    ManagedChannelBuilder<?> builder =
+        Grpc.newChannelBuilder(target, InsecureChannelCredentials.create());
+
+    // Round Robin, when a healthCheckConfig is present in the default service configuration, runs
+    // a watch on the health service and when picking an endpoint will
+    // consider a transport to a server whose service is not in SERVING state to be unavailable.
+    // Since we only have a single server we are connecting to, then the load balancer will
+    // return an error without sending the RPC.
+    if (useRoundRobin) {
+      builder = builder
+        .defaultLoadBalancingPolicy("round_robin")
+        .defaultServiceConfig(generateHealthConfig(""));
+    }
+
+    ManagedChannel channel = builder.build();
+
+    System.out.println("\nDoing test with" + (useRoundRobin ? "" : "out")
+      + " the Round Robin load balancer\n");
+
+    try {
+      HealthServiceClient client = new HealthServiceClient(channel);
+      if (!useRoundRobin) {
+        client.checkHealth("Before call");
+      }
+      client.greet(users[0]);
+      if (!useRoundRobin) {
+        client.checkHealth("After user " + users[0]);
+      }
+
+      for (String user : users) {
+        client.greet(user);
+        Thread.sleep(100); // Since the health update is asynchronous give it time to propagate
+      }
+
+      if (!useRoundRobin) {
+        client.checkHealth("After all users");
+        Thread.sleep(10000);
+        client.checkHealth("After 10 second wait");
+      } else {
+        Thread.sleep(10000);
+      }
+      client.greet("Larry");
+    } finally {
+      // ManagedChannels use resources like threads and TCP connections. To prevent leaking these
+      // resources the channel should be shut down when it will no longer be used. If it may be used
+      // again leave it running.
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+    }
+  }
+  private static Map<String, Object> generateHealthConfig(String serviceName) {
+    Map<String, Object> config = new HashMap<>();
+    Map<String, Object> serviceMap = new HashMap<>();
+
+    config.put("healthCheckConfig", serviceMap);
+    serviceMap.put("serviceName", serviceName);
+    return config;
+  }
+
+  /**
+   * Uses a server with both a greet service and the health service.
+   * If provided, the first element of {@code args} is the name to use in the
+   * greeting. The second argument is the target server.
+   * This has an example of using the health service directly through the unary call
+   * <a href="https://github.com/grpc/grpc-java/blob/master/services/src/main/proto/grpc/health/v1/health.proto">check</a>
+   * to get the current health.  It also utilizes the health of the server's greet service
+   * indirectly through the round robin load balancer, which uses the streaming rpc
+   * <strong>watch</strong> (you can see how it is done in
+   * {@link  io.grpc.protobuf.services.HealthCheckingLoadBalancerFactory}).
+   */
+  public static void main(String[] args) throws Exception {
+    System.setProperty("java.util.logging.SimpleFormatter.format",
+        "%1$tH:%1$tM:%1$tS %4$s %2$s: %5$s%6$s%n");
+
+    String[] users = {"world", "foo", "I am Grut"};
+    // Access a service running on the local machine on port 50051
+    String target = "localhost:50051";
+    // Allow passing in the user and target strings as command line arguments
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [target [name] [name] ...]");
+        System.err.println("");
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.err.println("  name    The names you wish to be greeted by. Defaults to " + Arrays.toString(users));
+        System.exit(1);
+      }
+      target = args[0];
+    }
+    if (args.length > 1) {
+      users = new String[args.length-1];
+      for (int i=0; i < users.length; i++) {
+        users[i] = args[i+1];
+      }
+    }
+
+    // Will see failures of rpc's sent while server service is not serving, where the failures come
+    // from the server
+    runTest(target, users, false);
+
+    // The client will throw an error when sending the rpc to a non-serving service because the
+    // round robin load balancer uses the health service's watch rpc.
+    runTest(target, users, true);
+
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/healthservice/HealthServiceServer.java b/examples/src/main/java/io/grpc/examples/healthservice/HealthServiceServer.java
new file mode 100644
index 00000000000..f6547c11103
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/healthservice/HealthServiceServer.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2023 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.examples.healthservice;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.Status;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
+import io.grpc.protobuf.services.HealthStatusManager;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * Server that manages startup/shutdown of a {@code Greeter} server.
+ */
+public class HealthServiceServer {
+  private static final Logger logger = Logger.getLogger(HealthServiceServer.class.getName());
+
+  private Server server;
+  private HealthStatusManager health;
+
+  private void start() throws IOException {
+    /* The port on which the server should run */
+    int port = 50051;
+    health = new HealthStatusManager();
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new GreeterImpl())
+        .addService(health.getHealthService())
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          HealthServiceServer.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** server shut down");
+      }
+    });
+
+    health.setStatus("", ServingStatus.SERVING);
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    System.setProperty("java.util.logging.SimpleFormatter.format",
+        "%1$tH:%1$tM:%1$tS %4$s %2$s: %5$s%6$s%n");
+
+    final HealthServiceServer server = new HealthServiceServer();
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  private class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+    boolean isServing = true;
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      if (!isServing) {
+        responseObserver.onError(
+            Status.INTERNAL.withDescription("Not Serving right now").asRuntimeException());
+        return;
+      }
+
+      if (isNameLongEnough(req)) {
+        HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+        responseObserver.onNext(reply);
+        responseObserver.onCompleted();
+      } else {
+        logger.warning("Tiny message received, throwing a temper tantrum");
+        health.setStatus("", ServingStatus.NOT_SERVING);
+        isServing = false;
+
+        // In 10 seconds set it back to serving
+        new Thread(new Runnable() {
+          @Override
+          public void run() {
+            try {
+              Thread.sleep(10000);
+            } catch (InterruptedException e) {
+              Thread.currentThread().interrupt();
+              return;
+            }
+            isServing = true;
+            health.setStatus("", ServingStatus.SERVING);
+            logger.info("tantrum complete");
+          }
+        }).start();
+        responseObserver.onError(
+            Status.INVALID_ARGUMENT.withDescription("Offended by short name").asRuntimeException());
+      }
+    }
+
+    private boolean isNameLongEnough(HelloRequest req) {
+      return isServing && req.getName().length() >= 5;
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/healthservice/README.md b/examples/src/main/java/io/grpc/examples/healthservice/README.md
new file mode 100644
index 00000000000..181bd70977f
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/healthservice/README.md
@@ -0,0 +1,10 @@
+gRPC Health Service Example
+=====================
+
+The Health Service example provides a HelloWorld gRPC server that doesn't like short names along with a
+health service. It also provides a client application which makes HelloWorld
+calls and checks the health status.
+
+The client application also shows how the round robin load balancer can
+utilize the health status to avoid making calls to a service that is
+not actively serving.
diff --git a/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldClient.java b/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldClient.java
new file mode 100644
index 00000000000..429cceb50c3
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldClient.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright 2019 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.examples.hedging;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.google.gson.Gson;
+import com.google.gson.stream.JsonReader;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import java.io.InputStreamReader;
+import java.util.Map;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.PriorityBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A client that requests a greeting from the {@link HedgingHelloWorldServer} with a hedging policy.
+ */
+public class HedgingHelloWorldClient {
+  static final String ENV_DISABLE_HEDGING = "DISABLE_HEDGING_IN_HEDGING_EXAMPLE";
+
+  private static final Logger logger = Logger.getLogger(HedgingHelloWorldClient.class.getName());
+
+  private final boolean hedging;
+  private final ManagedChannel channel;
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+  private final PriorityBlockingQueue<Long> latencies = new PriorityBlockingQueue<>();
+  private final AtomicInteger failedRpcs = new AtomicInteger();
+
+  /** Construct client connecting to HelloWorld server at {@code host:port}. */
+  public HedgingHelloWorldClient(String host, int port, boolean hedging) {
+    ManagedChannelBuilder<?> channelBuilder
+        = Grpc.newChannelBuilderForAddress(host, port, InsecureChannelCredentials.create());
+    if (hedging) {
+      Map<String, ?> hedgingServiceConfig =
+          new Gson()
+              .fromJson(
+                  new JsonReader(
+                      new InputStreamReader(
+                          HedgingHelloWorldClient.class.getResourceAsStream(
+                              "hedging_service_config.json"),
+                          UTF_8)),
+                  Map.class);
+      channelBuilder.defaultServiceConfig(hedgingServiceConfig).enableRetry();
+    }
+    channel = channelBuilder.build();
+    blockingStub = GreeterGrpc.newBlockingStub(channel);
+    this.hedging = hedging;
+  }
+
+  public void shutdown() throws InterruptedException {
+    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
+  }
+
+  /** Say hello to server. */
+  public void greet(String name) {
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response = null;
+    StatusRuntimeException statusRuntimeException = null;
+    long startTime = System.nanoTime();
+    try {
+      response = blockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      failedRpcs.incrementAndGet();
+      statusRuntimeException = e;
+    }
+    long latencyMills = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime);
+    latencies.offer(latencyMills);
+
+    if (statusRuntimeException == null) {
+      logger.log(
+          Level.INFO,
+          "Greeting: {0}. Latency: {1}ms",
+          new Object[] {response.getMessage(), latencyMills});
+    } else {
+      logger.log(
+          Level.INFO,
+          "RPC failed: {0}. Latency: {1}ms",
+          new Object[] {statusRuntimeException.getStatus(), latencyMills});
+    }
+  }
+
+  void printSummary() {
+    int rpcCount = latencies.size();
+    long latency50 = 0L;
+    long latency90 = 0L;
+    long latency95 = 0L;
+    long latency99 = 0L;
+    long latency999 = 0L;
+    long latencyMax = 0L;
+    for (int i = 0; i < rpcCount; i++) {
+      long latency = latencies.poll();
+      if (i == rpcCount * 50 / 100 - 1) {
+        latency50 = latency;
+      }
+      if (i == rpcCount * 90 / 100 - 1) {
+        latency90 = latency;
+      }
+      if (i == rpcCount * 95 / 100 - 1) {
+        latency95 = latency;
+      }
+      if (i == rpcCount * 99 / 100 - 1) {
+        latency99 = latency;
+      }
+      if (i == rpcCount * 999 / 1000 - 1) {
+        latency999 = latency;
+      }
+      if (i == rpcCount - 1) {
+        latencyMax = latency;
+      }
+    }
+
+    logger.log(
+        Level.INFO,
+        "\n\nTotal RPCs sent: {0}. Total RPCs failed: {1}\n"
+            + (hedging ? "[Hedging enabled]\n" : "[Hedging disabled]\n")
+            + "========================\n"
+            + "50% latency: {2}ms\n"
+            + "90% latency: {3}ms\n"
+            + "95% latency: {4}ms\n"
+            + "99% latency: {5}ms\n"
+            + "99.9% latency: {6}ms\n"
+            + "Max latency: {7}ms\n"
+            + "========================\n",
+        new Object[]{
+            rpcCount, failedRpcs.get(),
+            latency50, latency90, latency95, latency99, latency999, latencyMax});
+
+    if (hedging) {
+      logger.log(
+          Level.INFO,
+          "To disable hedging, run the client with environment variable {0}=true.",
+          ENV_DISABLE_HEDGING);
+    } else {
+      logger.log(
+          Level.INFO,
+          "To enable hedging, unset environment variable {0} and then run the client.",
+          ENV_DISABLE_HEDGING);
+    }
+  }
+
+  public static void main(String[] args) throws Exception {
+    boolean hedging = !Boolean.parseBoolean(System.getenv(ENV_DISABLE_HEDGING));
+    final HedgingHelloWorldClient client = new HedgingHelloWorldClient("localhost", 50051, hedging);
+    ForkJoinPool executor = new ForkJoinPool();
+
+    for (int i = 0; i < 2000; i++) {
+      final String userId = "user" + i;
+      executor.execute(
+          new Runnable() {
+            @Override
+            public void run() {
+              client.greet(userId);
+            }
+          });
+    }
+
+    executor.awaitQuiescence(100, TimeUnit.SECONDS);
+    executor.shutdown();
+    client.printSummary();
+    client.shutdown();
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldServer.java b/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldServer.java
new file mode 100644
index 00000000000..784269eea1c
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/hedging/HedgingHelloWorldServer.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2019 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.examples.hedging;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Metadata;
+import io.grpc.Server;
+import io.grpc.ServerCall;
+import io.grpc.ServerCall.Listener;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * A HelloWorld server that responds to requests with a long latency tail.
+ */
+public class HedgingHelloWorldServer {
+  private static final Logger logger = Logger.getLogger(HedgingHelloWorldServer.class.getName());
+
+  private Server server;
+
+  private void start() throws IOException {
+    /* The port on which the server should run */
+    int port = 50051;
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new GreeterImpl())
+        .intercept(new LatencyInjectionInterceptor())
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          HedgingHelloWorldServer.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** server shut down");
+      }
+    });
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    final HedgingHelloWorldServer server = new HedgingHelloWorldServer();
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+
+  static class LatencyInjectionInterceptor implements ServerInterceptor {
+
+    @Override
+    public <HelloRequestT, HelloReplyT> Listener<HelloRequestT> interceptCall(
+        ServerCall<HelloRequestT, HelloReplyT> call,
+        Metadata headers, ServerCallHandler<HelloRequestT, HelloReplyT> next) {
+      int random = new Random().nextInt(100);
+      long delay = 0;
+      if (random < 1) {
+        delay = 10_000;
+      } else if (random < 5) {
+        delay = 5_000;
+      } else if (random < 10) {
+        delay = 2_000;
+      }
+
+      if (delay > 0) {
+        try {
+          Thread.sleep(delay);
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+        }
+      }
+      return next.startCall(call, headers);
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/hedging/README.md b/examples/src/main/java/io/grpc/examples/hedging/README.md
new file mode 100644
index 00000000000..0154e5c2cee
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/hedging/README.md
@@ -0,0 +1,59 @@
+gRPC Hedging Example
+=====================
+
+The Hedging example demonstrates that enabling hedging
+can reduce tail latency. (Users should note that enabling hedging may introduce other overhead;
+and in some scenarios, such as when some server resource gets exhausted for a period of time and
+almost every RPC during that time has high latency or fails, hedging may make things worse.
+Setting a throttle in the service config is recommended to protect the server from too many
+inappropriate retry or hedging requests.)
+
+The server and the client in the example are basically the same as those in the
+[hello world](src/main/java/io/grpc/examples/helloworld) example, except that the server mimics a
+long tail of latency, and the client sends 2000 requests and can turn on and off hedging.
+
+To mimic the latency, the server randomly delays the RPC handling by 2 seconds at 10% chance, 5
+seconds at 5% chance, and 10 seconds at 1% chance.
+
+When running the client enabling the following hedging policy
+
+  ```json
+        "hedgingPolicy": {
+          "maxAttempts": 3,
+          "hedgingDelay": "1s"
+        }
+  ```
+Then the latency summary in the client log is like the following
+
+  ```text
+  Total RPCs sent: 2,000. Total RPCs failed: 0
+  [Hedging enabled]
+  ========================
+  50% latency: 0ms
+  90% latency: 6ms
+  95% latency: 1,003ms
+  99% latency: 2,002ms
+  99.9% latency: 2,011ms
+  Max latency: 5,272ms
+  ========================
+  ```
+
+See [the section below](#to-build-the-examples) for how to build and run the example. The
+executables for the server and the client are `hedging-hello-world-server` and
+`hedging-hello-world-client`.
+
+To disable hedging, set environment variable `DISABLE_HEDGING_IN_HEDGING_EXAMPLE=true` before
+running the client. That produces a latency summary in the client log like the following
+
+  ```text
+  Total RPCs sent: 2,000. Total RPCs failed: 0
+  [Hedging disabled]
+  ========================
+  50% latency: 0ms
+  90% latency: 2,002ms
+  95% latency: 5,002ms
+  99% latency: 10,004ms
+  99.9% latency: 10,007ms
+  Max latency: 10,007ms
+  ========================
+  ```
diff --git a/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldClient.java b/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldClient.java
index fc2e1672e02..6b186facf46 100644
--- a/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldClient.java
+++ b/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldClient.java
@@ -1,40 +1,26 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.helloworld;
 
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
 import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
 import io.grpc.StatusRuntimeException;
-
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -45,27 +31,17 @@
 public class HelloWorldClient {
   private static final Logger logger = Logger.getLogger(HelloWorldClient.class.getName());
 
-  private final ManagedChannel channel;
   private final GreeterGrpc.GreeterBlockingStub blockingStub;
 
-  /** Construct client connecting to HelloWorld server at {@code host:port}. */
-  public HelloWorldClient(String host, int port) {
-    this(ManagedChannelBuilder.forAddress(host, port)
-        // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
-        // needing certificates.
-        .usePlaintext(true));
-  }
+  /** Construct client for accessing HelloWorld server using the existing channel. */
+  public HelloWorldClient(Channel channel) {
+    // 'channel' here is a Channel, not a ManagedChannel, so it is not this code's responsibility to
+    // shut it down.
 
-  /** Construct client for accessing RouteGuide server using the existing channel. */
-  HelloWorldClient(ManagedChannelBuilder<?> channelBuilder) {
-    channel = channelBuilder.build();
+    // Passing Channels to code makes code easier to test and makes it easier to reuse Channels.
     blockingStub = GreeterGrpc.newBlockingStub(channel);
   }
 
-  public void shutdown() throws InterruptedException {
-    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
-  }
-
   /** Say hello to server. */
   public void greet(String name) {
     logger.info("Will try to greet " + name + " ...");
@@ -82,19 +58,43 @@ public void greet(String name) {
 
   /**
    * Greet server. If provided, the first element of {@code args} is the name to use in the
-   * greeting.
+   * greeting. The second argument is the target server.
    */
   public static void main(String[] args) throws Exception {
-    HelloWorldClient client = new HelloWorldClient("localhost", 50051);
-    try {
-      /* Access a service running on the local machine on port 50051 */
-      String user = "world";
-      if (args.length > 0) {
-        user = args[0]; /* Use the arg as the name to greet if provided */
+    String user = "world";
+    // Access a service running on the local machine on port 50051
+    String target = "localhost:50051";
+    // Allow passing in the user and target strings as command line arguments
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [name [target]]");
+        System.err.println("");
+        System.err.println("  name    The name you wish to be greeted by. Defaults to " + user);
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.exit(1);
       }
+      user = args[0];
+    }
+    if (args.length > 1) {
+      target = args[1];
+    }
+
+    // Create a communication channel to the server, known as a Channel. Channels are thread-safe
+    // and reusable. It is common to create channels at the beginning of your application and reuse
+    // them until the application shuts down.
+    //
+    // For the example we use plaintext insecure credentials to avoid needing TLS certificates. To
+    // use TLS, use TlsChannelCredentials instead.
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .build();
+    try {
+      HelloWorldClient client = new HelloWorldClient(channel);
       client.greet(user);
     } finally {
-      client.shutdown();
+      // ManagedChannels use resources like threads and TCP connections. To prevent leaking these
+      // resources the channel should be shut down when it will no longer be used. If it may be used
+      // again leave it running.
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
     }
   }
 }
diff --git a/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldServer.java b/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldServer.java
index ce1158a43d7..0e39581c98f 100644
--- a/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldServer.java
+++ b/examples/src/main/java/io/grpc/examples/helloworld/HelloWorldServer.java
@@ -1,42 +1,30 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.helloworld;
 
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
 import io.grpc.Server;
-import io.grpc.ServerBuilder;
 import io.grpc.stub.StreamObserver;
-
 import java.io.IOException;
+import java.util.concurrent.TimeUnit;
 import java.util.logging.Logger;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 /**
  * Server that manages startup/shutdown of a {@code Greeter} server.
@@ -45,11 +33,20 @@ public class HelloWorldServer {
   private static final Logger logger = Logger.getLogger(HelloWorldServer.class.getName());
 
   private Server server;
-
   private void start() throws IOException {
     /* The port on which the server should run */
     int port = 50051;
-    server = ServerBuilder.forPort(port)
+    /*
+     * By default gRPC uses a global, shared Executor.newCachedThreadPool() for gRPC callbacks into
+     * your application. This is convenient, but can cause an excessive number of threads to be
+     * created if there are many RPCs. It is often better to limit the number of threads your
+     * application uses for processing and let RPCs queue when the CPU is saturated.
+     * The appropriate number of threads varies heavily between applications.
+     * Async application code generally does not need more threads than CPU cores.
+     */
+    ExecutorService executor = Executors.newFixedThreadPool(2);
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .executor(executor)
         .addService(new GreeterImpl())
         .build()
         .start();
@@ -59,15 +56,24 @@ private void start() throws IOException {
       public void run() {
         // Use stderr here since the logger may have been reset by its JVM shutdown hook.
         System.err.println("*** shutting down gRPC server since JVM is shutting down");
-        HelloWorldServer.this.stop();
+        try {
+          HelloWorldServer.this.stop();
+        } catch (InterruptedException e) {
+          if (server != null) {
+            server.shutdownNow();
+          }
+          e.printStackTrace(System.err);
+        } finally {
+          executor.shutdown();
+        }
         System.err.println("*** server shut down");
       }
     });
   }
 
-  private void stop() {
+  private void stop() throws InterruptedException {
     if (server != null) {
-      server.shutdown();
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
     }
   }
 
diff --git a/examples/src/main/java/io/grpc/examples/helloworld/README.md b/examples/src/main/java/io/grpc/examples/helloworld/README.md
new file mode 100644
index 00000000000..5b11d4945c2
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/helloworld/README.md
@@ -0,0 +1,7 @@
+gRPC Hello World Example
+=====================
+This Example gives the details about basic implementation of gRPC Client and Server along with
+how the communication happens between them by sending a greeting message.
+
+Refer the gRPC documentation for more details on helloworld.proto specification, creation of gRPC services and 
+methods along with Execution process https://grpc.io/docs/languages/java/quickstart/
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/keepalive/KeepAliveClient.java b/examples/src/main/java/io/grpc/examples/keepalive/KeepAliveClient.java
new file mode 100644
index 00000000000..414d92dea4c
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/keepalive/KeepAliveClient.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2023 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.examples.keepalive;
+
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A simple client that requests a greeting from the {@link KeepAliveServer}.
+ */
+public class KeepAliveClient {
+  private static final Logger logger = Logger.getLogger(KeepAliveClient.class.getName());
+
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+  /** Construct client for accessing HelloWorld server using the existing channel. */
+  public KeepAliveClient(Channel channel) {
+    // 'channel' here is a Channel, not a ManagedChannel, so it is not this code's responsibility to
+    // shut it down.
+
+    // Passing Channels to code makes code easier to test and makes it easier to reuse Channels.
+    blockingStub = GreeterGrpc.newBlockingStub(channel);
+  }
+
+  /** Say hello to server. */
+  public void greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response;
+    try {
+      response = blockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    logger.info("Greeting: " + response.getMessage());
+  }
+
+  /**
+   * Greet server.
+   */
+  public static void main(String[] args) throws Exception {
+    // Access a service running on the local machine on port 50051
+    String target = "localhost:50051";
+
+    // Create a channel with the following keep alive configurations (demo only, you should set
+    // more appropriate values based on your environment):
+    // keepAliveTime: Send pings every 10 seconds if there is no activity. Set to an appropriate
+    // value in reality, e.g. (5, TimeUnit.MINUTES).
+    // keepAliveTimeout: Wait 1 second for ping ack before considering the connection dead. Set to a
+    // larger value in reality, e.g. (10, TimeUnit.SECONDS). You should only set such a small value,
+    // e.g. (1, TimeUnit.SECONDS) in certain low latency environments.
+    // keepAliveWithoutCalls: Send pings even without active streams. Normally disable it.
+    // Use JAVA_OPTS=-Djava.util.logging.config.file=logging.properties to see the keep alive ping
+    // frames.
+    // More details see: https://github.com/grpc/proposal/blob/master/A8-client-side-keepalive.md
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .keepAliveTime(10, TimeUnit.SECONDS) // Change to a larger value, e.g. 5min.
+        .keepAliveTimeout(1, TimeUnit.SECONDS) // Change to a larger value, e.g. 10s.
+        .keepAliveWithoutCalls(true)// You should normally avoid enabling this.
+        .build();
+
+    try {
+      KeepAliveClient client = new KeepAliveClient(channel);
+      client.greet("Keep-alive Demo");
+      Thread.sleep(30000);
+    } finally {
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/keepalive/KeepAliveServer.java b/examples/src/main/java/io/grpc/examples/keepalive/KeepAliveServer.java
new file mode 100644
index 00000000000..884bbfea532
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/keepalive/KeepAliveServer.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2023 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.examples.keepalive;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * Server that manages startup/shutdown of a keep alive server.
+ */
+public class KeepAliveServer {
+  private static final Logger logger = Logger.getLogger(KeepAliveServer.class.getName());
+
+  private Server server;
+
+  private void start() throws IOException {
+    /* The port on which the server should run */
+    int port = 50051;
+
+    // Start a server with the following configurations (demo only, you should set more appropriate
+    // values based on your real environment):
+    // keepAliveTime: Ping the client if it is idle for 5 seconds to ensure the connection is
+    // still active. Set to an appropriate value in reality, e.g. in minutes.
+    // keepAliveTimeout: Wait 1 second for the ping ack before assuming the connection is dead.
+    // Set to an appropriate value in reality, e.g. (10, TimeUnit.SECONDS).
+    // permitKeepAliveTime: If a client pings more than once every 5 seconds, terminate the
+    // connection.
+    // permitKeepAliveWithoutCalls: Allow pings even when there are no active streams.
+    // maxConnectionIdle: If a client is idle for 15 seconds, send a GOAWAY.
+    // maxConnectionAge: If any connection is alive for more than 30 seconds, send a GOAWAY.
+    // maxConnectionAgeGrace: Allow 5 seconds for pending RPCs to complete before forcibly closing
+    // connections.
+    // Use JAVA_OPTS=-Djava.util.logging.config.file=logging.properties to see keep alive ping
+    // frames.
+    // More details see: https://github.com/grpc/proposal/blob/master/A9-server-side-conn-mgt.md
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new GreeterImpl())
+        .keepAliveTime(5, TimeUnit.SECONDS)
+        .keepAliveTimeout(1, TimeUnit.SECONDS)
+        .permitKeepAliveTime(5, TimeUnit.SECONDS)
+        .permitKeepAliveWithoutCalls(true)
+        .maxConnectionIdle(15, TimeUnit.SECONDS)
+        .maxConnectionAge(30, TimeUnit.SECONDS)
+        .maxConnectionAgeGrace(5, TimeUnit.SECONDS)
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          KeepAliveServer.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** server shut down");
+      }
+    });
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    final KeepAliveServer server = new KeepAliveServer();
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/keepalive/README.md b/examples/src/main/java/io/grpc/examples/keepalive/README.md
new file mode 100644
index 00000000000..7b5b72665e7
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/keepalive/README.md
@@ -0,0 +1,16 @@
+gRPC Keepalive Example
+=====================
+
+This example gives the usage and implementation of the Keepalives methods, configurations in gRPC Client and 
+Server and how the communication happens between them.
+
+HTTP/2 PING-based keepalives are a way to keep an HTTP/2 connection alive even when there is no data being transferred.
+This is done by periodically sending a PING Frames to the other end of the connection.
+HTTP/2 keepalives can improve performance and reliability of HTTP/2 connections, 
+but it is important to configure the keepalive interval carefully.
+
+gRPC sends http2 pings on the transport to detect if the connection is down.
+If the ping is not acknowledged by the other side within a certain period, the connection will be closed.
+Note that pings are only necessary when there's no activity on the connection.
+
+Refer the gRPC documentation for more on Keepalive details and configurations https://grpc.io/docs/guides/keepalive/
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/loadbalance/ExampleNameResolver.java b/examples/src/main/java/io/grpc/examples/loadbalance/ExampleNameResolver.java
new file mode 100644
index 00000000000..6ef327ade84
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/loadbalance/ExampleNameResolver.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2022 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.examples.loadbalance;
+
+import com.google.common.collect.ImmutableMap;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.Status;
+
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static io.grpc.examples.loadbalance.LoadBalanceClient.exampleServiceName;
+
+public class ExampleNameResolver extends NameResolver {
+
+    static private final int[] SERVER_PORTS = {50051, 50052, 50053};
+    private Listener2 listener;
+
+    private final URI uri;
+
+    private final Map<String,List<InetSocketAddress>> addrStore;
+
+    public ExampleNameResolver(URI targetUri) {
+        this.uri = targetUri;
+        // This is a fake name resolver, so we just hard code the address here.
+        addrStore = ImmutableMap.<String,List<InetSocketAddress>>builder()
+            .put(exampleServiceName,
+                Arrays.stream(SERVER_PORTS)
+                    .mapToObj(port->new InetSocketAddress("localhost",port))
+                    .collect(Collectors.toList())
+            )
+                .build();
+    }
+
+    @Override
+    public String getServiceAuthority() {
+        // Be consistent with behavior in grpc-go, authority is saved in Host field of URI.
+        if (uri.getHost() != null) {
+            return uri.getHost();
+        }
+        return "no host";
+    }
+
+    @Override
+    public void shutdown() {
+    }
+
+    @Override
+    public void start(Listener2 listener) {
+        this.listener = listener;
+        this.resolve();
+    }
+
+    @Override
+    public void refresh() {
+        this.resolve();
+    }
+
+    private void resolve() {
+        List<InetSocketAddress> addresses = addrStore.get(uri.getPath().substring(1));
+        try {
+            List<EquivalentAddressGroup> equivalentAddressGroup = addresses.stream()
+                    // convert to socket address
+                    .map(this::toSocketAddress)
+                    // every socket address is a single EquivalentAddressGroup, so they can be accessed randomly
+                    .map(Arrays::asList)
+                    .map(this::addrToEquivalentAddressGroup)
+                    .collect(Collectors.toList());
+
+            ResolutionResult resolutionResult = ResolutionResult.newBuilder()
+                    .setAddresses(equivalentAddressGroup)
+                    .build();
+
+            this.listener.onResult(resolutionResult);
+
+        } catch (Exception e){
+            // when error occurs, notify listener
+            this.listener.onError(Status.UNAVAILABLE.withDescription("Unable to resolve host ").withCause(e));
+        }
+    }
+
+    private SocketAddress toSocketAddress(InetSocketAddress address) {
+        return new InetSocketAddress(address.getHostName(), address.getPort());
+    }
+
+    private EquivalentAddressGroup addrToEquivalentAddressGroup(List<SocketAddress> addrList) {
+        return new EquivalentAddressGroup(addrList);
+    }
+}
diff --git a/examples/src/main/java/io/grpc/examples/loadbalance/ExampleNameResolverProvider.java b/examples/src/main/java/io/grpc/examples/loadbalance/ExampleNameResolverProvider.java
new file mode 100644
index 00000000000..ee966fd044c
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/loadbalance/ExampleNameResolverProvider.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2022 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.examples.loadbalance;
+
+import io.grpc.NameResolver;
+import io.grpc.NameResolverProvider;
+
+import java.net.URI;
+
+import static io.grpc.examples.loadbalance.LoadBalanceClient.exampleScheme;
+
+public class ExampleNameResolverProvider extends NameResolverProvider {
+    @Override
+    public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+        return new ExampleNameResolver(targetUri);
+    }
+
+    @Override
+    protected boolean isAvailable() {
+        return true;
+    }
+
+    @Override
+    protected int priority() {
+        return 5;
+    }
+
+    @Override
+    // gRPC choose the first NameResolverProvider that supports the target URI scheme.
+    public String getDefaultScheme() {
+        return exampleScheme;
+    }
+}
diff --git a/examples/src/main/java/io/grpc/examples/loadbalance/LoadBalanceClient.java b/examples/src/main/java/io/grpc/examples/loadbalance/LoadBalanceClient.java
new file mode 100644
index 00000000000..97444922871
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/loadbalance/LoadBalanceClient.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2022 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.examples.loadbalance;
+
+import io.grpc.*;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class LoadBalanceClient {
+    private static final Logger logger = Logger.getLogger(LoadBalanceClient.class.getName());
+
+    public static final String exampleScheme = "example";
+    public static final String exampleServiceName = "lb.example.grpc.io";
+
+    private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+    public LoadBalanceClient(Channel channel) {
+        blockingStub = GreeterGrpc.newBlockingStub(channel);
+    }
+
+    public void greet(String name) {
+        HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+        HelloReply response;
+        try {
+            response = blockingStub.sayHello(request);
+        } catch (StatusRuntimeException e) {
+            logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+            return;
+        }
+        logger.info("Greeting: " + response.getMessage());
+    }
+
+
+    public static void main(String[] args) throws Exception {
+        NameResolverRegistry.getDefaultRegistry().register(new ExampleNameResolverProvider());
+
+        String target = String.format("%s:///%s", exampleScheme, exampleServiceName);
+
+        logger.info("Use default first_pick load balance policy");
+        ManagedChannel channel = ManagedChannelBuilder.forTarget(target)
+                .usePlaintext()
+                .build();
+        try {
+            LoadBalanceClient client = new LoadBalanceClient(channel);
+            for (int i = 0; i < 5; i++) {
+                client.greet("request" + i);
+            }
+        } finally {
+            channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+        }
+
+        logger.info("Change to round_robin policy");
+        channel = ManagedChannelBuilder.forTarget(target)
+                .defaultLoadBalancingPolicy("round_robin")
+                .usePlaintext()
+                .build();
+        try {
+            LoadBalanceClient client = new LoadBalanceClient(channel);
+            for (int i = 0; i < 5; i++) {
+                client.greet("request" + i);
+            }
+        } finally {
+            channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+        }
+    }
+}
diff --git a/examples/src/main/java/io/grpc/examples/loadbalance/LoadBalanceServer.java b/examples/src/main/java/io/grpc/examples/loadbalance/LoadBalanceServer.java
new file mode 100644
index 00000000000..85ae92a537a
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/loadbalance/LoadBalanceServer.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2022 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.examples.loadbalance;
+
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+public class LoadBalanceServer {
+    private static final Logger logger = Logger.getLogger(LoadBalanceServer.class.getName());
+    static final int[] SERVER_PORTS = {50051, 50052, 50053};
+    private List<Server> servers;
+
+    private void start() throws IOException {
+        servers = new ArrayList<>();
+        for (int port : SERVER_PORTS) {
+            servers.add(
+                ServerBuilder.forPort(port)
+                    .addService(new GreeterImpl(port))
+                    .build()
+                    .start());
+            logger.info("Server started, listening on " + port);
+        }
+        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+            System.err.println("*** shutting down gRPC server since JVM is shutting down");
+            try {
+                LoadBalanceServer.this.stop();
+            } catch (InterruptedException e) {
+                e.printStackTrace(System.err);
+            }
+            System.err.println("*** server shut down");
+        }));
+    }
+
+    private void stop() throws InterruptedException {
+        for (Server server : servers) {
+            server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+        }
+    }
+
+    private void blockUntilShutdown() throws InterruptedException {
+        for (Server server : servers) {
+            server.awaitTermination();
+        }
+    }
+
+    public static void main(String[] args) throws IOException, InterruptedException {
+        final LoadBalanceServer server = new LoadBalanceServer();
+        server.start();
+        server.blockUntilShutdown();
+    }
+
+    static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+        int port;
+
+        public GreeterImpl(int port) {
+            this.port = port;
+        }
+
+        @Override
+        public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+            HelloReply reply = HelloReply.newBuilder()
+                .setMessage("Hello " + req.getName() + " from server<" + this.port + ">").build();
+            responseObserver.onNext(reply);
+            responseObserver.onCompleted();
+        }
+    }
+}
diff --git a/examples/src/main/java/io/grpc/examples/loadbalance/README.md b/examples/src/main/java/io/grpc/examples/loadbalance/README.md
new file mode 100644
index 00000000000..0d19d2f3335
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/loadbalance/README.md
@@ -0,0 +1,20 @@
+gRPC Load Balance Example
+=====================
+
+One of the key features of gRPC is load balancing, which allows requests from clients to be distributed across multiple servers. 
+This helps prevent any one server from becoming overloaded and allows the system to scale up by adding more servers.
+
+A gRPC load balancing policy is given a list of server IP addresses by the name resolver. 
+The policy is responsible for maintaining connections (subchannels) to the servers and picking a connection to use when an RPC is sent.
+
+By default, the pick_first policy will be used. 
+This policy actually does no load balancing but just tries each address it gets from the name resolver and uses the first one it can connect to.
+By updating the gRPC service config you can also switch to using round_robin that connects to every address it gets and rotates through the connected backends for each RPC.
+There are also some other load balancing policies available, but the exact set varies by language.
+
+This example gives the details about how to implement Load Balance in gRPC, If the built-in policies does not meet your requirements
+you can implement your own custom load balance [Custom Load Balance](src/main/java/io/grpc/examples/customloadbalance)
+
+gRPC supports both client side and server side load balancing but by default gRPC uses client side load balancing.
+
+Refer the gRPC documentation for more details on Load Balancing https://grpc.io/blog/grpc-load-balancing/
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/manualflowcontrol/BidiBlockingClient.java b/examples/src/main/java/io/grpc/examples/manualflowcontrol/BidiBlockingClient.java
new file mode 100644
index 00000000000..902d46c8cc6
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/manualflowcontrol/BidiBlockingClient.java
@@ -0,0 +1,286 @@
+/*
+ * Copyright 2023 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.examples.manualflowcontrol;
+
+import com.google.protobuf.ByteString;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.StatusException;
+import io.grpc.examples.manualflowcontrol.StreamingGreeterGrpc.StreamingGreeterBlockingV2Stub;
+import io.grpc.stub.BlockingClientCall;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+
+/**
+ * A class that tries multiple ways to do blocking bidi streaming
+ * communication with an echo server
+ */
+public class BidiBlockingClient {
+
+  private static final Logger logger = Logger.getLogger(BidiBlockingClient.class.getName());
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the
+   * greeting. The second argument is the target server. You can see the multiplexing in the server
+   * logs.
+   */
+  public static void main(String[] args) throws Exception {
+    System.setProperty("java.util.logging.SimpleFormatter.format", "%1$tH:%1$tM:%1$tS %5$s%6$s%n");
+
+    // Access a service running on the local machine on port 50051
+    String target = "localhost:50051";
+    // Allow passing in the user and target strings as command line arguments
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [target]\n");
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.exit(1);
+      }
+      target = args[0];
+    }
+
+    // Create a communication channel to the server, known as a Channel. Channels are thread-safe
+    // and reusable. It is common to create channels at the beginning of your application and reuse
+    // them until the application shuts down.
+    //
+    // For the example we use plaintext insecure credentials to avoid needing TLS certificates. To
+    // use TLS, use TlsChannelCredentials instead.
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .build();
+    StreamingGreeterBlockingV2Stub blockingStub = StreamingGreeterGrpc.newBlockingV2Stub(channel);
+    List<String> echoInput = names();
+    try {
+      long start = System.currentTimeMillis();
+      List<String> twoThreadResult = useTwoThreads(blockingStub, echoInput);
+      long finish = System.currentTimeMillis();
+
+      System.out.println("The echo requests and results were:");
+      printResultMessage("Input", echoInput, 0L);
+      printResultMessage("2 threads", twoThreadResult, finish - start);
+    } finally {
+      // ManagedChannels use resources like threads and TCP connections. To prevent leaking these
+      // resources the channel should be shut down when it will no longer be used. If it may be used
+      // again leave it running.
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+    }
+  }
+
+  private static void printResultMessage(String type, List<String> result, long millis) {
+    String msg = String.format("%-32s: %2d, %.3f sec", type, result.size(), millis/1000.0);
+    logger.info(msg);
+  }
+
+  private static void logMethodStart(String method) {
+    logger.info("--------------------- Starting to process using method:  " + method);
+  }
+
+  /**
+   *  Create 2 threads, one that writes all values, and one that reads until the stream closes.
+   */
+  private static List<String> useTwoThreads(StreamingGreeterBlockingV2Stub blockingStub,
+      List<String> valuesToWrite) throws InterruptedException {
+    logMethodStart("Two Threads");
+
+    List<String> readValues = new ArrayList<>();
+    final BlockingClientCall<HelloRequest, HelloReply> stream = blockingStub.sayHelloStreaming();
+
+    Thread reader = new Thread(null,
+        new Runnable() {
+          @Override
+          public void run() {
+            int count = 0;
+            try {
+              while (stream.hasNext()) {
+                readValues.add(stream.read().getMessage());
+                if (++count % 10 == 0) {
+                  logger.info("Finished " + count + " reads");
+                }
+              }
+            } catch (InterruptedException e) {
+              Thread.currentThread().interrupt();
+              stream.cancel("Interrupted", e);
+            } catch (StatusException e) {
+              logger.warning("Encountered error while reading: " + e);
+            }
+          }
+        },"reader");
+
+    Thread writer = new Thread(null,
+        new Runnable() {
+      @Override
+      public void run() {
+        ByteString padding = createPadding();
+        int count = 0;
+        Iterator<String> iterator = valuesToWrite.iterator();
+        boolean hadProblem = false;
+        try {
+          while (iterator.hasNext()) {
+            if (!stream.write(HelloRequest.newBuilder().setName(iterator.next()).setPadding(padding)
+                .build())) {
+              logger.warning("Stream closed before writes completed");
+              hadProblem = true;
+              break;
+            }
+            if (++count % 10 == 0) {
+              logger.info("Finished " + count + " writes");
+            }
+          }
+          if (!hadProblem) {
+            logger.info("Completed writes");
+            stream.halfClose();
+          }
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+          stream.cancel("Interrupted", e);
+        } catch (StatusException e) {
+          logger.warning("Encountered error while writing: " + e);
+        }
+      }
+    }, "writer");
+
+    writer.start();
+    reader.start();
+    writer.join();
+    reader.join();
+
+    return readValues;
+  }
+
+  private static ByteString createPadding() {
+    int multiple = 50;
+    ByteBuffer data = ByteBuffer.allocate(1024 * multiple);
+
+    for (int i = 0; i < multiple * 1024 / 4; i++) {
+      data.putInt(4 * i, 1111);
+    }
+
+    return ByteString.copyFrom(data);
+  }
+
+
+  private static List<String> names() {
+    return Arrays.asList(
+        "Sophia",
+        "Jackson",
+        "Emma",
+        "Aiden",
+        "Olivia",
+        "Lucas",
+        "Ava",
+        "Liam",
+        "Mia",
+        "Noah",
+        "Isabella",
+        "Ethan",
+        "Riley",
+        "Mason",
+        "Aria",
+        "Caden",
+        "Zoe",
+        "Oliver",
+        "Charlotte",
+        "Elijah",
+        "Lily",
+        "Grayson",
+        "Layla",
+        "Jacob",
+        "Amelia",
+        "Michael",
+        "Emily",
+        "Benjamin",
+        "Madelyn",
+        "Carter",
+        "Aubrey",
+        "James",
+        "Adalyn",
+        "Jayden",
+        "Madison",
+        "Logan",
+        "Chloe",
+        "Alexander",
+        "Harper",
+        "Caleb",
+        "Abigail",
+        "Ryan",
+        "Aaliyah",
+        "Luke",
+        "Avery",
+        "Daniel",
+        "Evelyn",
+        "Jack",
+        "Kaylee",
+        "William",
+        "Ella",
+        "Owen",
+        "Ellie",
+        "Gabriel",
+        "Scarlett",
+        "Matthew",
+        "Arianna",
+        "Connor",
+        "Hailey",
+        "Jayce",
+        "Nora",
+        "Isaac",
+        "Addison",
+        "Sebastian",
+        "Brooklyn",
+        "Henry",
+        "Hannah",
+        "Muhammad",
+        "Mila",
+        "Cameron",
+        "Leah",
+        "Wyatt",
+        "Elizabeth",
+        "Dylan",
+        "Sarah",
+        "Nathan",
+        "Eliana",
+        "Nicholas",
+        "Mackenzie",
+        "Julian",
+        "Peyton",
+        "Eli",
+        "Maria",
+        "Levi",
+        "Grace",
+        "Isaiah",
+        "Adeline",
+        "Landon",
+        "Elena",
+        "David",
+        "Anna",
+        "Christian",
+        "Victoria",
+        "Andrew",
+        "Camilla",
+        "Brayden",
+        "Lillian",
+        "John",
+        "Natalie",
+        "Lincoln"
+    );
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/manualflowcontrol/ManualFlowControlClient.java b/examples/src/main/java/io/grpc/examples/manualflowcontrol/ManualFlowControlClient.java
new file mode 100644
index 00000000000..324392db150
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/manualflowcontrol/ManualFlowControlClient.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright 2017 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.examples.manualflowcontrol;
+
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.stub.ClientCallStreamObserver;
+import io.grpc.stub.ClientResponseObserver;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+public class ManualFlowControlClient {
+    private static final Logger logger =
+        Logger.getLogger(ManualFlowControlClient.class.getName());
+
+  public static void main(String[] args) throws InterruptedException {
+    final CountDownLatch done = new CountDownLatch(1);
+
+    // Create a channel and a stub
+    ManagedChannel channel = ManagedChannelBuilder
+        .forAddress("localhost", 50051)
+        .usePlaintext()
+        .build();
+    StreamingGreeterGrpc.StreamingGreeterStub stub = StreamingGreeterGrpc.newStub(channel);
+
+    // When using manual flow-control and back-pressure on the client, the ClientResponseObserver handles both
+    // request and response streams.
+    ClientResponseObserver<HelloRequest, HelloReply> clientResponseObserver =
+        new ClientResponseObserver<HelloRequest, HelloReply>() {
+
+          ClientCallStreamObserver<HelloRequest> requestStream;
+
+          @Override
+          public void beforeStart(final ClientCallStreamObserver<HelloRequest> requestStream) {
+            this.requestStream = requestStream;
+            // Set up manual flow control for the response stream. It feels backwards to configure the response
+            // stream's flow control using the request stream's observer, but this is the way it is.
+            requestStream.disableAutoRequestWithInitial(1);
+
+            // Set up a back-pressure-aware producer for the request stream. The onReadyHandler will be invoked
+            // when the consuming side has enough buffer space to receive more messages.
+            //
+            // Messages are serialized into a transport-specific transmit buffer. Depending on the size of this buffer,
+            // MANY messages may be buffered, however, they haven't yet been sent to the server. The server must call
+            // request() to pull a buffered message from the client.
+            //
+            // Note: the onReadyHandler's invocation is serialized on the same thread pool as the incoming
+            // StreamObserver's onNext(), onError(), and onComplete() handlers. Blocking the onReadyHandler will prevent
+            // additional messages from being processed by the incoming StreamObserver. The onReadyHandler must return
+            // in a timely manner or else message processing throughput will suffer.
+            requestStream.setOnReadyHandler(new Runnable() {
+              // An iterator is used so we can pause and resume iteration of the request data.
+              Iterator<String> iterator = names().iterator();
+
+              @Override
+              public void run() {
+                // Start generating values from where we left off on a non-gRPC thread.
+                while (requestStream.isReady()) {
+                  if (iterator.hasNext()) {
+                      // Send more messages if there are more messages to send.
+                      String name = iterator.next();
+                      logger.info("--> " + name);
+                      HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+                      requestStream.onNext(request);
+                  } else {
+                      // Signal completion if there is nothing left to send.
+                      requestStream.onCompleted();
+                  }
+                }
+              }
+            });
+          }
+
+          @Override
+          public void onNext(HelloReply value) {
+            logger.info("<-- " + value.getMessage());
+            // Signal the sender to send one message.
+            requestStream.request(1);
+          }
+
+          @Override
+          public void onError(Throwable t) {
+            t.printStackTrace();
+            done.countDown();
+          }
+
+          @Override
+          public void onCompleted() {
+            logger.info("All Done");
+            done.countDown();
+          }
+        };
+
+    // Note: clientResponseObserver is handling both request and response stream processing.
+    stub.sayHelloStreaming(clientResponseObserver);
+
+    done.await();
+
+    channel.shutdown();
+    channel.awaitTermination(1, TimeUnit.SECONDS);
+  }
+
+  private static List<String> names() {
+    return Arrays.asList(
+        "Sophia",
+        "Jackson",
+        "Emma",
+        "Aiden",
+        "Olivia",
+        "Lucas",
+        "Ava",
+        "Liam",
+        "Mia",
+        "Noah",
+        "Isabella",
+        "Ethan",
+        "Riley",
+        "Mason",
+        "Aria",
+        "Caden",
+        "Zoe",
+        "Oliver",
+        "Charlotte",
+        "Elijah",
+        "Lily",
+        "Grayson",
+        "Layla",
+        "Jacob",
+        "Amelia",
+        "Michael",
+        "Emily",
+        "Benjamin",
+        "Madelyn",
+        "Carter",
+        "Aubrey",
+        "James",
+        "Adalyn",
+        "Jayden",
+        "Madison",
+        "Logan",
+        "Chloe",
+        "Alexander",
+        "Harper",
+        "Caleb",
+        "Abigail",
+        "Ryan",
+        "Aaliyah",
+        "Luke",
+        "Avery",
+        "Daniel",
+        "Evelyn",
+        "Jack",
+        "Kaylee",
+        "William",
+        "Ella",
+        "Owen",
+        "Ellie",
+        "Gabriel",
+        "Scarlett",
+        "Matthew",
+        "Arianna",
+        "Connor",
+        "Hailey",
+        "Jayce",
+        "Nora",
+        "Isaac",
+        "Addison",
+        "Sebastian",
+        "Brooklyn",
+        "Henry",
+        "Hannah",
+        "Muhammad",
+        "Mila",
+        "Cameron",
+        "Leah",
+        "Wyatt",
+        "Elizabeth",
+        "Dylan",
+        "Sarah",
+        "Nathan",
+        "Eliana",
+        "Nicholas",
+        "Mackenzie",
+        "Julian",
+        "Peyton",
+        "Eli",
+        "Maria",
+        "Levi",
+        "Grace",
+        "Isaiah",
+        "Adeline",
+        "Landon",
+        "Elena",
+        "David",
+        "Anna",
+        "Christian",
+        "Victoria",
+        "Andrew",
+        "Camilla",
+        "Brayden",
+        "Lillian",
+        "John",
+        "Natalie",
+        "Lincoln"
+    );
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/manualflowcontrol/ManualFlowControlServer.java b/examples/src/main/java/io/grpc/examples/manualflowcontrol/ManualFlowControlServer.java
new file mode 100644
index 00000000000..3b7f980e08c
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/manualflowcontrol/ManualFlowControlServer.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2017 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.examples.manualflowcontrol;
+
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.Status;
+import io.grpc.stub.ServerCallStreamObserver;
+import io.grpc.stub.StreamObserver;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+public class ManualFlowControlServer {
+  private static final Logger logger =
+      Logger.getLogger(ManualFlowControlServer.class.getName());
+
+  public static void main(String[] args) throws InterruptedException, IOException {
+    // Service class implementation
+    StreamingGreeterGrpc.StreamingGreeterImplBase svc = new StreamingGreeterGrpc.StreamingGreeterImplBase() {
+      @Override
+      public StreamObserver<HelloRequest> sayHelloStreaming(final StreamObserver<HelloReply> responseObserver) {
+        // Set up manual flow control for the request stream. It feels backwards to configure the request
+        // stream's flow control using the response stream's observer, but this is the way it is.
+        final ServerCallStreamObserver<HelloReply> serverCallStreamObserver =
+            (ServerCallStreamObserver<HelloReply>) responseObserver;
+        serverCallStreamObserver.disableAutoRequest();
+
+        // Set up a back-pressure-aware consumer for the request stream. The onReadyHandler will be invoked
+        // when the consuming side has enough buffer space to receive more messages.
+        //
+        // Note: the onReadyHandler's invocation is serialized on the same thread pool as the incoming StreamObserver's
+        // onNext(), onError(), and onComplete() handlers. Blocking the onReadyHandler will prevent additional messages
+        // from being processed by the incoming StreamObserver. The onReadyHandler must return in a timely manner or
+        // else message processing throughput will suffer.
+        class OnReadyHandler implements Runnable {
+          // Guard against spurious onReady() calls caused by a race between onNext() and onReady(). If the transport
+          // toggles isReady() from false to true while onNext() is executing, but before onNext() checks isReady(),
+          // request(1) would be called twice - once by onNext() and once by the onReady() scheduled during onNext()'s
+          // execution.
+          private boolean wasReady = false;
+
+          @Override
+          public void run() {
+            if (serverCallStreamObserver.isReady() && !wasReady) {
+              wasReady = true;
+              logger.info("READY");
+              // Signal the request sender to send one message. This happens when isReady() turns true, signaling that
+              // the receive buffer has enough free space to receive more messages. Calling request() serves to prime
+              // the message pump.
+              serverCallStreamObserver.request(1);
+            }
+          }
+        }
+        final OnReadyHandler onReadyHandler = new OnReadyHandler();
+        serverCallStreamObserver.setOnReadyHandler(onReadyHandler);
+
+        // Give gRPC a StreamObserver that can observe and process incoming requests.
+        return new StreamObserver<HelloRequest>() {
+          int cnt = 0;
+          @Override
+          public void onNext(HelloRequest request) {
+            // Process the request and send a response or an error.
+            try {
+              // Accept and enqueue the request.
+              String name = request.getName();
+              logger.info("--> " + name);
+
+              // Simulate server "work"
+              int sleepMillis = ++cnt % 20 == 0 ? 2000 : 100;
+              Thread.sleep(sleepMillis);
+
+              // Send a response.
+              String message = "Hello " + name;
+              logger.info("<-- " + message);
+              HelloReply reply = HelloReply.newBuilder().setMessage(message).build();
+              responseObserver.onNext(reply);
+
+              // Check the provided ServerCallStreamObserver to see if it is still ready to accept more messages.
+              if (serverCallStreamObserver.isReady()) {
+                // Signal the sender to send another request. As long as isReady() stays true, the server will keep
+                // cycling through the loop of onNext() -> request(1)...onNext() -> request(1)... until the client runs
+                // out of messages and ends the loop (via onCompleted()).
+                //
+                // If request() was called here with the argument of more than 1, the server might runs out of receive
+                // buffer space, and isReady() will turn false. When the receive buffer has sufficiently drained,
+                // isReady() will turn true, and the serverCallStreamObserver's onReadyHandler will be called to restart
+                // the message pump.
+                serverCallStreamObserver.request(1);
+              } else {
+                // If not, note that back-pressure has begun.
+                onReadyHandler.wasReady = false;
+              }
+            } catch (Throwable throwable) {
+              throwable.printStackTrace();
+              responseObserver.onError(
+                  Status.UNKNOWN.withDescription("Error handling request").withCause(throwable).asException());
+            }
+          }
+
+          @Override
+          public void onError(Throwable t) {
+            // End the response stream if the client presents an error.
+            t.printStackTrace();
+            responseObserver.onCompleted();
+          }
+
+          @Override
+          public void onCompleted() {
+            // Signal the end of work when the client ends the request stream.
+            logger.info("COMPLETED");
+            responseObserver.onCompleted();
+          }
+        };
+      }
+    };
+
+    final Server server = ServerBuilder
+        .forPort(50051)
+        .addService(svc)
+        .build()
+        .start();
+
+    logger.info("Listening on " + server.getPort());
+
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("Shutting down");
+        try {
+          server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+      }
+    });
+    server.awaitTermination();
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/manualflowcontrol/README.md b/examples/src/main/java/io/grpc/examples/manualflowcontrol/README.md
new file mode 100644
index 00000000000..a30688cea15
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/manualflowcontrol/README.md
@@ -0,0 +1,76 @@
+gRPC Manual Flow Control Example
+=====================
+Flow control is relevant for streaming RPC calls.
+
+By default, gRPC will handle dealing with flow control. However, for specific
+use cases, you may wish to take explicit control.
+
+The default, if you do not disable auto requests, is for the gRPC framework to
+automatically request 1 message at startup and after each onNext call,
+request 1 more. With manual flow control, you explicitly do the request. Note
+that acknowledgements (which is what lets the server know that the receiver can
+handle more data) are sent after an onNext call. The onNext method is called
+when there is both an undelivered message and an outstanding request.
+
+The most common use case for manual flow control is to avoid requiring your
+asynchronous onNext method to block when processing of the read message is being
+done somewhere else.
+
+Another, minor use case for manual flow control, is when there are lots of small
+messages and you are using Netty. To avoid switching back and forth between the
+application and network threads, you can specify a larger initial value (such
+as 5) so that the application thread can have values waiting for it rather than
+constantly having to block and wait for the network thread to provide the next
+value.
+
+### Outgoing Flow Control
+
+The underlying layer (such as Netty) will make the write wait when there is no
+space to write the next message. This causes the request stream to go into
+a not ready state and the outgoing onNext method invocation waits. You can
+explicitly check that the stream is ready for writing before calling onNext to
+avoid blocking. This is done with `CallStreamObserver.isReady()`. You can
+utilize this to start doing reads, which may allow
+the other side of the channel to complete a write and then to do its own reads,
+thereby avoiding deadlock.
+
+### Incoming Manual Flow Control
+
+An example use case is, you have a buffer where your onNext places values from
+the stream. Manual flow control can be used to avoid buffer overflows. You could
+use a blocking buffer, but you may not want to have the thread being used by
+onNext block.
+
+By default, gRPC will configure a stream to request one value at startup and
+then at the completion of each "onNext" invocation requests one more message.
+You can take control of this by disabling AutoRequest on the
+request stream. If you do so, then you are responsible for asynchronously
+telling the stream each time that you would like a new message to be
+asynchronously sent to onNext when one is available. This is done by calling a
+method on the request stream to request messages (while this has a count,
+generally you request 1). Putting this request at the end of your onNext method
+essentially duplicates the default behavior.
+
+#### Client side (server or bidi streaming)
+
+In the `ClientResponseObserver.beforeStart` method, call
+`requestStream.disableAutoRequestWithInitial(1)`
+
+When you are ready to begin processing the next value from the stream call
+`requestStream.request(1)`
+
+#### Server side (client or bidi streaming)
+
+In your stub methods supporting streaming, add the following at the top
+
+1. cast `StreamObserver<> responseObserver`
+   to `ServerCallStreamObserver<> serverCallStreamObserver`
+1. call `serverCallStreamObserver.disableAutoRequest()`
+
+When you are ready to begin processing the next value from the stream call
+`serverCallStreamObserver.request(1)`
+
+### Related documents
+Also see [gRPC Flow Control Users Guide][user guide]
+
+ [user guide]: https://grpc.io/docs/guides/flow-control
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/multiplex/EchoService.java b/examples/src/main/java/io/grpc/examples/multiplex/EchoService.java
new file mode 100644
index 00000000000..f7410f34ce4
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/multiplex/EchoService.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2023 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.examples.multiplex;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.examples.echo.EchoGrpc;
+import io.grpc.examples.echo.EchoRequest;
+import io.grpc.examples.echo.EchoResponse;
+import io.grpc.stub.StreamObserver;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+/**
+ * Service that echoes back whatever is sent to it.
+ */
+public class EchoService extends EchoGrpc.EchoImplBase {
+  private static final Logger logger = Logger.getLogger(EchoService.class.getName());
+
+  @Override
+  public void unaryEcho(EchoRequest request,
+      StreamObserver<EchoResponse> responseObserver) {
+    logger.info("Received echo request: " + request.getMessage());
+    EchoResponse response = EchoResponse.newBuilder().setMessage(request.getMessage()).build();
+    responseObserver.onNext(response);
+    responseObserver.onCompleted();
+  }
+
+  @Override
+  public void serverStreamingEcho(EchoRequest request,
+      StreamObserver<EchoResponse> responseObserver) {
+    logger.info("Received server streaming echo request: " + request.getMessage());
+    EchoResponse response = EchoResponse.newBuilder().setMessage(request.getMessage()).build();
+    responseObserver.onNext(response);
+    responseObserver.onCompleted();
+  }
+
+  @Override
+  public StreamObserver<EchoRequest> clientStreamingEcho(
+      final StreamObserver<EchoResponse> responseObserver) {
+    return new StreamObserver<EchoRequest>() {
+      List<String> requestList = new ArrayList<>();
+
+      @Override
+      public void onNext(EchoRequest request) {
+        logger.info("Received client streaming echo request: " + request.getMessage());
+        requestList.add(request.getMessage());
+      }
+
+      @Override
+      public void onError(Throwable t) {
+        logger.log(Level.WARNING, "echo stream cancelled or had a problem and is no longer usable " + t.getMessage());
+        responseObserver.onError(t);
+      }
+
+      @Override
+      public void onCompleted() {
+        logger.info("Client streaming complete");
+        String reply = requestList.stream().collect(Collectors.joining(", "));
+        EchoResponse response = EchoResponse.newBuilder().setMessage(reply).build();
+        responseObserver.onNext(response);
+        responseObserver.onCompleted();
+      }
+    };
+  }
+
+  @Override
+  public StreamObserver<EchoRequest> bidirectionalStreamingEcho(
+      final StreamObserver<EchoResponse> responseObserver) {
+    return new StreamObserver<EchoRequest>() {
+      @Override
+      public void onNext(EchoRequest request) {
+        logger.info("Received bidirection streaming echo request: " + request.getMessage());
+        EchoResponse response = EchoResponse.newBuilder().setMessage(request.getMessage()).build();
+        responseObserver.onNext(response);
+      }
+
+      @Override
+      public void onError(Throwable t) {
+        logger.log(Level.WARNING,
+            "echo stream cancelled or had a problem and is no longer usable " + t.getMessage());
+        responseObserver.onError(t);
+      }
+
+      @Override
+      public void onCompleted() {
+        logger.info("Bidirectional stream completed from client side");
+        responseObserver.onCompleted();
+      }
+    };
+  }
+}
+
diff --git a/examples/src/main/java/io/grpc/examples/multiplex/MultiplexingServer.java b/examples/src/main/java/io/grpc/examples/multiplex/MultiplexingServer.java
new file mode 100644
index 00000000000..a52aba06599
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/multiplex/MultiplexingServer.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2023 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.examples.multiplex;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.examples.echo.EchoGrpc;
+import io.grpc.examples.echo.EchoRequest;
+import io.grpc.examples.echo.EchoResponse;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * A sample gRPC server that serves both the Greeting and Echo services.
+ */
+public class MultiplexingServer {
+
+  private static final Logger logger = Logger.getLogger(MultiplexingServer.class.getName());
+
+  private final int port;
+  private Server server;
+
+  public MultiplexingServer(int port) throws IOException {
+    this.port = port;
+  }
+
+  private void start() throws IOException {
+    /* The port on which the server should run */
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new MultiplexingServer.GreeterImpl())
+        .addService(new EchoService())
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          MultiplexingServer.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** server shut down");
+      }
+    });
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    System.setProperty("java.util.logging.SimpleFormatter.format",
+        "%1$tH:%1$tM:%1$tS %4$s %2$s: %5$s%6$s%n");
+
+    final MultiplexingServer server = new MultiplexingServer(50051);
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+    @Override
+    public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+      logger.info("Received sayHello request: " + req.getName());
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/multiplex/README.md b/examples/src/main/java/io/grpc/examples/multiplex/README.md
new file mode 100644
index 00000000000..fb24642a41b
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/multiplex/README.md
@@ -0,0 +1,20 @@
+gRPC Multiplex Example
+=====================
+
+gRPC multiplexing refers to the ability of a single gRPC connection to handle multiple independent streams of communication simultaneously. 
+This is part of the HTTP/2 protocol on which gRPC is built. 
+Each gRPC connection supports multiple streams that can carry different RPCs, making it highly efficient for high-throughput, low-latency communication.
+
+In gRPC, sharing resources like channels and servers can improve efficiency and resource utilization.
+
+- Sharing gRPC Channels and Servers
+
+  1. Shared gRPC Channel:
+     - A single gRPC channel can be used by multiple stubs, enabling different service clients to communicate over the same connection.
+     - This minimizes the overhead of establishing and managing multiple connections
+
+  2. Shared gRPC Server:
+     - A single gRPC channel can be used by multiple stubs, enabling different service clients to communicate over the same connection.
+     - This minimizes the overhead of establishing and managing multiple connections    
+
+This example demonstrates how to implement a gRPC server that serves both a GreetingService and an EchoService, and a client that shares a single channel across multiple stubs for both services.
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/multiplex/SharingClient.java b/examples/src/main/java/io/grpc/examples/multiplex/SharingClient.java
new file mode 100644
index 00000000000..d4128b11258
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/multiplex/SharingClient.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright 2023 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.examples.multiplex;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.AbstractFuture;
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.examples.echo.EchoGrpc;
+import io.grpc.examples.echo.EchoRequest;
+import io.grpc.examples.echo.EchoResponse;
+import io.grpc.examples.helloworld.HelloWorldClient;
+import io.grpc.stub.StreamObserver;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+
+/**
+ * A client that shares a channel across multiple stubs to a single service and across services
+ * being provided by one server process.
+ */
+public class SharingClient {
+  private static final Logger logger = Logger.getLogger(
+      HelloWorldClient.class.getName());
+
+  private final GreeterGrpc.GreeterBlockingStub greeterStub1;
+  private final GreeterGrpc.GreeterBlockingStub greeterStub2;
+  private final EchoGrpc.EchoStub echoStub;
+
+  private Random random = new Random();
+
+  /** Construct client for accessing HelloWorld server using the existing channel. */
+  public SharingClient(Channel channel) {
+    // 'channel' here is a Channel, not a ManagedChannel, so it is not this code's responsibility to
+    // shut it down.
+
+    // Passing Channels to code makes code easier to test and makes it easier to reuse Channels.
+    greeterStub1 = GreeterGrpc.newBlockingStub(channel);
+    greeterStub2 = GreeterGrpc.newBlockingStub(channel);
+    echoStub = EchoGrpc.newStub(channel);
+  }
+
+  /** Say hello to server. */
+  private void greet(String name, GreeterGrpc.GreeterBlockingStub stub, String stubName)
+      throws InterruptedException {
+    System.out.println("Will try to greet " + name + " using " + stubName);
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response;
+    try {
+      response = stub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    System.out.println("Greeting: " + response.getMessage());
+    // pause to allow interleaving
+    Thread.sleep(1000);
+  }
+
+  public void greet1(String name) throws InterruptedException {
+    greet(name, greeterStub1, "greeter #1");
+  }
+
+  public void greet2(String name) throws InterruptedException {
+    greet(name, greeterStub2, "greeter #2");
+  }
+
+  public StreamingFuture<List<String>> initiateEchos(List<String> valuesToSend) {
+    StreamingFuture<List<String>> future = new StreamingFuture<List<String>> ();
+    List<String> valuesReceived = new ArrayList<>();
+
+    // The logic that gets called by the framework during the RPC's lifecycle
+    StreamObserver<EchoResponse> responseObserver = new StreamObserver<EchoResponse>() {
+      @Override
+      public void onNext(EchoResponse response) {
+        System.out.println("Received an echo: " + response.getMessage());
+        valuesReceived.add(response.getMessage());
+      }
+
+      @Override
+      public void onError(Throwable t) {
+        logger.warning("Echo Failed: {0}" + Status.fromThrowable(t));
+        future.setException(t);
+      }
+
+      @Override
+      public void onCompleted() {
+        System.out.println("Server acknowledged end of echo stream.");
+        future.set(valuesReceived);
+      }
+    };
+
+    future.setObserver(responseObserver);
+
+    new Thread(new Runnable() {
+      public void run() {
+        StreamObserver<EchoRequest> requestObserver =
+            echoStub.bidirectionalStreamingEcho(responseObserver);
+
+        try {
+          for (String curValue : valuesToSend) {
+            System.out.println("Sending an echo request for: " + curValue);
+            EchoRequest req = EchoRequest.newBuilder().setMessage(curValue).build();
+            requestObserver.onNext(req);
+
+            // Sleep for a bit before sending the next one.
+            Thread.sleep(random.nextInt(1000) + 500);
+          }
+        } catch (RuntimeException e) {
+          // Cancel RPC
+          requestObserver.onError(e);
+          throw e;
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+          requestObserver.onError(e);
+          return;
+        }
+
+        // Mark the end of requests
+        requestObserver.onCompleted();
+      }
+    }).start();
+
+    return future;
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the
+   * greeting. The second argument is the target server.
+   * You can see the multiplexing in the server logs.
+   */
+  public static void main(String[] args) throws Exception {
+    String user = "world";
+    // Access a service running on the local machine on port 50051
+    String target = "localhost:50051";
+    // Allow passing in the user and target strings as command line arguments
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [name [target]]");
+        System.err.println("");
+        System.err.println("  name    The name you wish to be greeted by. Defaults to " + user);
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.exit(1);
+      }
+      user = args[0];
+    }
+    if (args.length > 1) {
+      target = args[1];
+    }
+
+    // Create a communication channel to the server, known as a Channel. Channels are thread-safe
+    // and reusable. It is common to create channels at the beginning of your application and reuse
+    // them until the application shuts down.
+    //
+    // For the example we use plaintext insecure credentials to avoid needing TLS certificates. To
+    // use TLS, use TlsChannelCredentials instead.
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .build();
+    List<String> echoInput = ImmutableList.of("some", "thing", "wicked", "this", "way", "comes");
+    try {
+      SharingClient client = new SharingClient(channel);
+
+      StreamingFuture<List<String>> future = client.initiateEchos(echoInput);
+      client.greet1(user + " the great");
+      client.greet2(user + " the lesser");
+      client.greet1(user + " the humble");
+      // Receiving happens asynchronously
+
+      String resultStr = future.get(1, TimeUnit.MINUTES).toString();
+      System.out.println("The echo requests and results were:");
+      System.out.println(echoInput.toString());
+      System.out.println(resultStr);
+
+      if (!future.isDone()) {
+        System.err.println("Streaming rpc failed to complete in 1 minute");
+      }
+    } finally {
+      // ManagedChannels use resources like threads and TCP connections. To prevent leaking these
+      // resources the channel should be shut down when it will no longer be used. If it may be used
+      // again leave it running.
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+    }
+  }
+
+  private class StreamingFuture<RespT> extends AbstractFuture<RespT> {
+
+    private StreamObserver<EchoResponse> responseObserver = null;
+
+    private void setObserver(StreamObserver<EchoResponse> responseObserver) {
+      this.responseObserver = responseObserver;
+    }
+
+    @Override
+    protected void interruptTask() {
+      if (responseObserver != null) {
+        responseObserver.onError(Status.ABORTED.asException());
+      }
+
+    }
+
+    // These are needed for visibility from the parent object
+    @Override
+    protected boolean set(@Nullable RespT resp) {
+      return super.set(resp);
+    }
+
+    @Override
+    protected boolean setException(Throwable throwable) {
+      return super.setException(throwable);
+    }
+
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/nameresolve/ExampleNameResolver.java b/examples/src/main/java/io/grpc/examples/nameresolve/ExampleNameResolver.java
new file mode 100644
index 00000000000..95bf20dd580
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/nameresolve/ExampleNameResolver.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2022 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.examples.nameresolve;
+
+import com.google.common.collect.ImmutableMap;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.Status;
+
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static io.grpc.examples.loadbalance.LoadBalanceClient.exampleServiceName;
+
+public class ExampleNameResolver extends NameResolver {
+
+    private final URI uri;
+    private final Map<String, List<InetSocketAddress>> addrStore;
+    private Listener2 listener;
+
+    public ExampleNameResolver(URI targetUri) {
+        this.uri = targetUri;
+        // This is a fake name resolver, so we just hard code the address here.
+        addrStore = ImmutableMap.<String, List<InetSocketAddress>>builder()
+                .put(exampleServiceName,
+                        Stream.iterate(NameResolveServer.startPort, p -> p + 1)
+                                .limit(NameResolveServer.serverCount)
+                                .map(port -> new InetSocketAddress("localhost", port))
+                                .collect(Collectors.toList())
+                )
+                .build();
+    }
+
+    @Override
+    public String getServiceAuthority() {
+        // Be consistent with behavior in grpc-go, authority is saved in Host field of URI.
+        if (uri.getHost() != null) {
+            return uri.getHost();
+        }
+        return "no host";
+    }
+
+    @Override
+    public void shutdown() {
+    }
+
+    @Override
+    public void start(Listener2 listener) {
+        this.listener = listener;
+        this.resolve();
+    }
+
+    @Override
+    public void refresh() {
+        this.resolve();
+    }
+
+    private void resolve() {
+        List<InetSocketAddress> addresses = addrStore.get(uri.getPath().substring(1));
+        try {
+            List<EquivalentAddressGroup> equivalentAddressGroup = addresses.stream()
+                    // convert to socket address
+                    .map(this::toSocketAddress)
+                    // every socket address is a single EquivalentAddressGroup, so they can be accessed randomly
+                    .map(Arrays::asList)
+                    .map(this::addrToEquivalentAddressGroup)
+                    .collect(Collectors.toList());
+
+            ResolutionResult resolutionResult = ResolutionResult.newBuilder()
+                    .setAddresses(equivalentAddressGroup)
+                    .build();
+
+            this.listener.onResult(resolutionResult);
+
+        } catch (Exception e) {
+            // when error occurs, notify listener
+            this.listener.onError(Status.UNAVAILABLE.withDescription("Unable to resolve host ").withCause(e));
+        }
+    }
+
+    private SocketAddress toSocketAddress(InetSocketAddress address) {
+        return new InetSocketAddress(address.getHostName(), address.getPort());
+    }
+
+    private EquivalentAddressGroup addrToEquivalentAddressGroup(List<SocketAddress> addrList) {
+        return new EquivalentAddressGroup(addrList);
+    }
+}
diff --git a/examples/src/main/java/io/grpc/examples/nameresolve/ExampleNameResolverProvider.java b/examples/src/main/java/io/grpc/examples/nameresolve/ExampleNameResolverProvider.java
new file mode 100644
index 00000000000..cd05f3214f6
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/nameresolve/ExampleNameResolverProvider.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2022 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.examples.nameresolve;
+
+import io.grpc.NameResolver;
+import io.grpc.NameResolverProvider;
+
+import java.net.URI;
+
+import static io.grpc.examples.loadbalance.LoadBalanceClient.exampleScheme;
+
+public class ExampleNameResolverProvider extends NameResolverProvider {
+    @Override
+    public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+        return new ExampleNameResolver(targetUri);
+    }
+
+    @Override
+    protected boolean isAvailable() {
+        return true;
+    }
+
+    @Override
+    protected int priority() {
+        return 5;
+    }
+
+    @Override
+    // gRPC choose the first NameResolverProvider that supports the target URI scheme.
+    public String getDefaultScheme() {
+        return exampleScheme;
+    }
+}
diff --git a/examples/src/main/java/io/grpc/examples/nameresolve/NameResolveClient.java b/examples/src/main/java/io/grpc/examples/nameresolve/NameResolveClient.java
new file mode 100644
index 00000000000..9aaccbe1096
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/nameresolve/NameResolveClient.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2022 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.examples.nameresolve;
+
+import io.grpc.*;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class NameResolveClient {
+    public static final String channelTarget = "example:///lb.example.grpc.io";
+    private static final Logger logger = Logger.getLogger(NameResolveClient.class.getName());
+    private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+    public NameResolveClient(Channel channel) {
+        blockingStub = GreeterGrpc.newBlockingStub(channel);
+    }
+
+    public static void main(String[] args) throws Exception {
+        NameResolverRegistry.getDefaultRegistry().register(new ExampleNameResolverProvider());
+
+        logger.info("Use default DNS resolver");
+        ManagedChannel channel = ManagedChannelBuilder.forTarget("localhost:50051")
+                .usePlaintext()
+                .build();
+        try {
+            NameResolveClient client = new NameResolveClient(channel);
+            for (int i = 0; i < 5; i++) {
+                client.greet("request" + i);
+            }
+        } finally {
+            channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+        }
+
+        logger.info("Change to use example name resolver");
+        /*
+          Dial to "example:///resolver.example.grpc.io", use {@link ExampleNameResolver} to create connection
+          "resolver.example.grpc.io" is converted to {@link java.net.URI.path}
+         */
+        channel = ManagedChannelBuilder.forTarget(channelTarget)
+            .defaultLoadBalancingPolicy("round_robin")
+            .usePlaintext()
+            .build();
+        try {
+            NameResolveClient client = new NameResolveClient(channel);
+            for (int i = 0; i < 5; i++) {
+                client.greet("request" + i);
+            }
+        } finally {
+            channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+        }
+    }
+
+    public void greet(String name) {
+        HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+        HelloReply response;
+        try {
+            response = blockingStub.sayHello(request);
+        } catch (StatusRuntimeException e) {
+            logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+            return;
+        }
+        logger.info("Greeting: " + response.getMessage());
+    }
+}
diff --git a/examples/src/main/java/io/grpc/examples/nameresolve/NameResolveServer.java b/examples/src/main/java/io/grpc/examples/nameresolve/NameResolveServer.java
new file mode 100644
index 00000000000..0a402485906
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/nameresolve/NameResolveServer.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2022 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.examples.nameresolve;
+
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+public class NameResolveServer {
+    static public final int serverCount = 3;
+    static public final int startPort = 50051;
+    private static final Logger logger = Logger.getLogger(NameResolveServer.class.getName());
+    private Server[] servers;
+
+    public static void main(String[] args) throws IOException, InterruptedException {
+        final NameResolveServer server = new NameResolveServer();
+        server.start();
+        server.blockUntilShutdown();
+    }
+
+    private void start() throws IOException {
+        servers = new Server[serverCount];
+        for (int i = 0; i < serverCount; i++) {
+            int port = startPort + i;
+            servers[i] = ServerBuilder.forPort(port)
+                    .addService(new GreeterImpl(port))
+                    .build()
+                    .start();
+            logger.info("Server started, listening on " + port);
+        }
+        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+            System.err.println("*** shutting down gRPC server since JVM is shutting down");
+            try {
+                NameResolveServer.this.stop();
+            } catch (InterruptedException e) {
+                e.printStackTrace(System.err);
+            }
+            System.err.println("*** server shut down");
+        }));
+    }
+
+    private void stop() throws InterruptedException {
+        for (int i = 0; i < serverCount; i++) {
+            if (servers[i] != null) {
+                servers[i].shutdown().awaitTermination(30, TimeUnit.SECONDS);
+            }
+        }
+    }
+
+    private void blockUntilShutdown() throws InterruptedException {
+        for (int i = 0; i < serverCount; i++) {
+            if (servers[i] != null) {
+                servers[i].awaitTermination();
+            }
+        }
+    }
+
+    static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+
+        int port;
+
+        public GreeterImpl(int port) {
+            this.port = port;
+        }
+
+        @Override
+        public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
+            HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName() + " from server<" + this.port + ">").build();
+            responseObserver.onNext(reply);
+            responseObserver.onCompleted();
+        }
+    }
+}
diff --git a/examples/src/main/java/io/grpc/examples/nameresolve/README.md b/examples/src/main/java/io/grpc/examples/nameresolve/README.md
new file mode 100644
index 00000000000..36c8d7e2a6b
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/nameresolve/README.md
@@ -0,0 +1,22 @@
+gRPC Name Resolve Example
+=====================
+
+This example explains standard name resolution process and how to implement it using the Name Resolver component.
+
+Name Resolution is fundamentally about Service Discovery.
+Name Resolution refers to the process of converting a name into an address and 
+Name Resolver is the component that implements the Name Resolution process.
+
+When sending gRPC Request, Client must determine the IP address of the Service Name,
+By Default DNS Name Resolution will be used when request received from the gRPC client.
+
+The Name Resolver in gRPC is necessary because clients often don’t know the exact IP address or port of the server 
+they need to connect to.
+
+The client registers an implementation of a **name resolver provider** to a process-global **registry** close to the start of the process. 
+The name resolver provider will be called by the **gRPC library** with a **target strings** intended for the custom name resolver. 
+Given that target string, the name resolver provider will return an instance of a **name resolver**, 
+which will interact with the client connection to direct the request according to the target string.
+
+Refer the gRPC documentation for more on Name Resolution and Custom Name Resolution 
+https://grpc.io/docs/guides/custom-name-resolution/
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/preserialized/ByteArrayMarshaller.java b/examples/src/main/java/io/grpc/examples/preserialized/ByteArrayMarshaller.java
new file mode 100644
index 00000000000..c6f099280f9
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/preserialized/ByteArrayMarshaller.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2023 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.examples.preserialized;
+
+import com.google.common.io.ByteStreams;
+import io.grpc.MethodDescriptor;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * A marshaller that produces a byte[] instead of decoding into typical POJOs. It can be used for
+ * any message type.
+ */
+final class ByteArrayMarshaller implements MethodDescriptor.Marshaller<byte[]> {
+  @Override
+  public byte[] parse(InputStream stream) {
+    try {
+      return ByteStreams.toByteArray(stream);
+    } catch (IOException ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+
+  @Override
+  public InputStream stream(byte[] b) {
+    return new ByteArrayInputStream(b);
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/preserialized/PreSerializedClient.java b/examples/src/main/java/io/grpc/examples/preserialized/PreSerializedClient.java
new file mode 100644
index 00000000000..511e8a177f8
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/preserialized/PreSerializedClient.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2023 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.examples.preserialized;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.MethodDescriptor;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.ClientCalls;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A client that requests a greeting from a hello-world server, but using a pre-serialized request.
+ * This is a performance optimization that can be useful if you read the request from on-disk or a
+ * database where it is already serialized, or if you need to send the same complicated message to
+ * many servers. The same approach can avoid deserializing responses, to be stored in a database.
+ * This adjustment is client-side only; the server is unable to detect the difference, so this
+ * client is fully-compatible with the normal {@link HelloWorldServer}.
+ */
+public class PreSerializedClient {
+  private static final Logger logger = Logger.getLogger(PreSerializedClient.class.getName());
+
+  /**
+   * Modified sayHello() descriptor with bytes as the request, instead of HelloRequest. By adjusting
+   * toBuilder() you can choose which of the request and response are bytes.
+   */
+  private static final MethodDescriptor<byte[], HelloReply> SAY_HELLO
+      = GreeterGrpc.getSayHelloMethod()
+      .toBuilder(new ByteArrayMarshaller(), GreeterGrpc.getSayHelloMethod().getResponseMarshaller())
+      .build();
+
+  private final Channel channel;
+
+  /** Construct client for accessing hello-world server using the existing channel. */
+  public PreSerializedClient(Channel channel) {
+    this.channel = channel;
+  }
+
+  /** Say hello to server. */
+  public void greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    byte[] request = HelloRequest.newBuilder().setName(name).build().toByteArray();
+    HelloReply response;
+    try {
+      // Stubs use ClientCalls to send RPCs. Since the generated stub won't have byte[] in its
+      // method signature, this uses ClientCalls directly. It isn't as convenient, but it behaves
+      // the same as a normal stub.
+      response = ClientCalls.blockingUnaryCall(channel, SAY_HELLO, CallOptions.DEFAULT, request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    logger.info("Greeting: " + response.getMessage());
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the
+   * greeting. The second argument is the target server.
+   */
+  public static void main(String[] args) throws Exception {
+    String user = "world";
+    String target = "localhost:50051";
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [name [target]]");
+        System.err.println("");
+        System.err.println("  name    The name you wish to be greeted by. Defaults to " + user);
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.exit(1);
+      }
+      user = args[0];
+    }
+    if (args.length > 1) {
+      target = args[1];
+    }
+
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .build();
+    try {
+      PreSerializedClient client = new PreSerializedClient(channel);
+      client.greet(user);
+    } finally {
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/preserialized/PreSerializedServer.java b/examples/src/main/java/io/grpc/examples/preserialized/PreSerializedServer.java
new file mode 100644
index 00000000000..51beca57386
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/preserialized/PreSerializedServer.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright 2023 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.examples.preserialized;
+
+import io.grpc.BindableService;
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.MethodDescriptor;
+import io.grpc.Server;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerMethodDefinition;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.ServiceDescriptor;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.ServerCalls;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * Server that provides a {@code Greeter} service, but that uses a pre-serialized response. This is
+ * a performance optimization that can be useful if you read the response from on-disk or a database
+ * where it is already serialized, or if you need to send the same complicated message to many
+ * clients. The same approach can avoid deserializing requests, to be stored in a database. This
+ * adjustment is server-side only; the client is unable to detect the differences, so this server is
+ * fully-compatible with the normal {@link HelloWorldClient}.
+ */
+public class PreSerializedServer {
+  private static final Logger logger = Logger.getLogger(PreSerializedServer.class.getName());
+
+  private Server server;
+
+  private void start() throws IOException {
+    int port = 50051;
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new GreeterImpl())
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          PreSerializedServer.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** server shut down");
+      }
+    });
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    final PreSerializedServer server = new PreSerializedServer();
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl implements GreeterGrpc.AsyncService, BindableService {
+
+    public void byteSayHello(HelloRequest req, StreamObserver<byte[]> responseObserver) {
+      HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply.toByteArray());
+      responseObserver.onCompleted();
+    }
+
+    @Override
+    public ServerServiceDefinition bindService() {
+      MethodDescriptor<HelloRequest, HelloReply> sayHello = GreeterGrpc.getSayHelloMethod();
+      // Modifying the method descriptor to use bytes as the response, instead of HelloReply. By
+      // adjusting toBuilder() you can choose which of the request and response are bytes.
+      MethodDescriptor<HelloRequest, byte[]> byteSayHello = sayHello
+          .toBuilder(sayHello.getRequestMarshaller(), new ByteArrayMarshaller())
+          .build();
+      // GreeterGrpc.bindService() will bind every service method, including sayHello(). (Although
+      // Greeter only has one method, this approach would work for any service.) AsyncService
+      // provides a default implementation of sayHello() that returns UNIMPLEMENTED, and that
+      // implementation will be used by bindService(). replaceMethod() will rewrite that method to
+      // use our byte-based method instead.
+      //
+      // The generated bindService() uses ServerCalls to make RPC handlers. Since the generated
+      // bindService() won't expect byte[] in the AsyncService, this uses ServerCalls directly. It
+      // isn't as convenient, but it behaves the same as a normal RPC handler.
+      return replaceMethod(
+          GreeterGrpc.bindService(this),
+          byteSayHello,
+          ServerCalls.asyncUnaryCall(this::byteSayHello));
+    }
+
+    /** Rewrites the ServerServiceDefinition replacing one method's definition. */
+    private static <ReqT, RespT> ServerServiceDefinition replaceMethod(
+        ServerServiceDefinition def,
+        MethodDescriptor<ReqT, RespT> newDesc,
+        ServerCallHandler<ReqT, RespT> newHandler) {
+      // There are two data structures involved. The first is the "descriptor" which describes the
+      // service and methods as a schema. This is the same on client and server. The second is the
+      // "definition" which includes the handlers to execute methods. This is specific to the server
+      // and is generated by "bind." This adjusts both the descriptor and definition.
+
+      // Descriptor
+      ServiceDescriptor desc = def.getServiceDescriptor();
+      ServiceDescriptor.Builder descBuilder = ServiceDescriptor.newBuilder(desc.getName())
+          .setSchemaDescriptor(desc.getSchemaDescriptor())
+          .addMethod(newDesc); // Add the modified method
+      // Copy methods other than the modified one
+      for (MethodDescriptor<?,?> md : desc.getMethods()) {
+        if (newDesc.getFullMethodName().equals(md.getFullMethodName())) {
+          continue;
+        }
+        descBuilder.addMethod(md);
+      }
+
+      // Definition
+      ServerServiceDefinition.Builder defBuilder =
+          ServerServiceDefinition.builder(descBuilder.build())
+          .addMethod(newDesc, newHandler); // Add the modified method
+      // Copy methods other than the modified one
+      for (ServerMethodDefinition<?,?> smd : def.getMethods()) {
+        if (newDesc.getFullMethodName().equals(smd.getMethodDescriptor().getFullMethodName())) {
+          continue;
+        }
+        defBuilder.addMethod(smd);
+      }
+      return defBuilder.build();
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/preserialized/README.md b/examples/src/main/java/io/grpc/examples/preserialized/README.md
new file mode 100644
index 00000000000..d49b3507d03
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/preserialized/README.md
@@ -0,0 +1,18 @@
+gRPC Pre-Serialized Messages Example
+=====================
+
+This example gives the usage and implementation of pre-serialized request and response messages 
+communication/exchange between grpc client and server by using ByteArrayMarshaller which produces 
+a byte[] instead of decoding into typical POJOs.
+
+This is a performance optimization that can be useful if you read the request/response from on-disk or a database
+where it is already serialized, or if you need to send the same complicated message to many clients and servers.
+The same approach can avoid deserializing requests/responses, to be stored in a database.
+
+It shows how to modify MethodDescriptor to use bytes as the response instead of HelloReply. By
+adjusting toBuilder() you can choose which of the request and response are bytes.
+The generated bindService() uses ServerCalls to make RPC handlers, Since the generated
+bindService() won't expect byte[] in the AsyncService, this uses ServerCalls directly.
+
+Stubs use ClientCalls to send RPCs, Since the generated stub won't have byte[] in its
+method signature, this uses ClientCalls directly.
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/retrying/README.md b/examples/src/main/java/io/grpc/examples/retrying/README.md
new file mode 100644
index 00000000000..bb29ce75e43
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/retrying/README.md
@@ -0,0 +1,27 @@
+gRPC Retrying Example
+=====================
+
+The Retrying example provides a HelloWorld gRPC client &
+server which demos the effect of client retry policy configured on the [ManagedChannel](
+https://github.com/grpc/grpc-java/blob/master/api/src/main/java/io/grpc/ManagedChannel.java) via [gRPC ServiceConfig](
+https://github.com/grpc/grpc/blob/master/doc/service_config.md). Retry policy implementation &
+configuration details are outlined in the [proposal](https://github.com/grpc/proposal/blob/master/A6-client-retries.md).
+
+This retrying example is very similar to the [hedging example](https://github.com/grpc/grpc-java/tree/master/examples/src/main/java/io/grpc/examples/hedging) in its setup.
+The [RetryingHelloWorldServer](src/main/java/io/grpc/examples/retrying/RetryingHelloWorldServer.java) responds with
+a status UNAVAILABLE error response to a specified percentage of requests to simulate server resource exhaustion and
+general flakiness. The [RetryingHelloWorldClient](src/main/java/io/grpc/examples/retrying/RetryingHelloWorldClient.java) makes
+a number of sequential requests to the server, several of which will be retried depending on the configured policy in
+[retrying_service_config.json](https://github.com/grpc/grpc-java/blob/master/examples/src/main/resources/io/grpc/examples/retrying/retrying_service_config.json). Although
+the requests are blocking unary calls for simplicity, these could easily be changed to future unary calls in order to
+test the result of request concurrency with retry policy enabled.
+
+One can experiment with the [RetryingHelloWorldServer](src/main/java/io/grpc/examples/retrying/RetryingHelloWorldServer.java)
+failure conditions to simulate server throttling, as well as alter policy values in the [retrying_service_config.json](
+https://github.com/grpc/grpc-java/blob/master/examples/src/main/resources/io/grpc/examples/retrying/retrying_service_config.json) to see their effects. To disable retrying
+entirely, set environment variable `DISABLE_RETRYING_IN_RETRYING_EXAMPLE=true` before running the client.
+Disabling the retry policy should produce many more failed gRPC calls as seen in the output log.
+
+See [the section](https://github.com/grpc/grpc-java/tree/master/examples#-to-build-the-examples) for how to build and run the example. The
+executables for the server and the client are `retrying-hello-world-server` and
+`retrying-hello-world-client`.
diff --git a/examples/src/main/java/io/grpc/examples/retrying/RetryingHelloWorldClient.java b/examples/src/main/java/io/grpc/examples/retrying/RetryingHelloWorldClient.java
new file mode 100644
index 00000000000..20c9e5893fb
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/retrying/RetryingHelloWorldClient.java
@@ -0,0 +1,148 @@
+/*
+ * 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.examples.retrying;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.google.gson.Gson;
+import com.google.gson.stream.JsonReader;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import java.io.InputStreamReader;
+import java.util.Map;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A client that requests a greeting from the {@link RetryingHelloWorldServer} with a retrying policy.
+ */
+public class RetryingHelloWorldClient {
+  static final String ENV_DISABLE_RETRYING = "DISABLE_RETRYING_IN_RETRYING_EXAMPLE";
+
+  private static final Logger logger = Logger.getLogger(RetryingHelloWorldClient.class.getName());
+
+  private final boolean enableRetries;
+  private final ManagedChannel channel;
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+  private final AtomicInteger totalRpcs = new AtomicInteger();
+  private final AtomicInteger failedRpcs = new AtomicInteger();
+
+  protected Map<String, ?> getRetryingServiceConfig() {
+    return new Gson()
+        .fromJson(
+            new JsonReader(
+                new InputStreamReader(
+                    RetryingHelloWorldClient.class.getResourceAsStream(
+                        "retrying_service_config.json"),
+                    UTF_8)),
+            Map.class);
+  }
+
+  /**
+   * Construct client connecting to HelloWorld server at {@code host:port}.
+   */
+  public RetryingHelloWorldClient(String host, int port, boolean enableRetries) {
+
+    ManagedChannelBuilder<?> channelBuilder
+        = Grpc.newChannelBuilderForAddress(host, port, InsecureChannelCredentials.create());
+    if (enableRetries) {
+      Map<String, ?> serviceConfig = getRetryingServiceConfig();
+      logger.info("Client started with retrying configuration: " + serviceConfig);
+      channelBuilder.defaultServiceConfig(serviceConfig).enableRetry();
+    }
+    channel = channelBuilder.build();
+    blockingStub = GreeterGrpc.newBlockingStub(channel);
+    this.enableRetries = enableRetries;
+  }
+
+  public void shutdown() throws InterruptedException {
+    channel.shutdown().awaitTermination(60, TimeUnit.SECONDS);
+  }
+
+  /**
+   * Say hello to server in a blocking unary call.
+   */
+  public void greet(String name) {
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response = null;
+    StatusRuntimeException statusRuntimeException = null;
+    try {
+      response = blockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      failedRpcs.incrementAndGet();
+      statusRuntimeException = e;
+    }
+
+    totalRpcs.incrementAndGet();
+
+    if (statusRuntimeException == null) {
+      logger.log(Level.INFO,"Greeting: {0}", new Object[]{response.getMessage()});
+    } else {
+      logger.log(Level.INFO,"RPC failed: {0}", new Object[]{statusRuntimeException.getStatus()});
+    }
+  }
+
+  private void printSummary() {
+    logger.log(
+        Level.INFO,
+        "\n\nTotal RPCs sent: {0}. Total RPCs failed: {1}\n",
+        new Object[]{
+            totalRpcs.get(), failedRpcs.get()});
+
+    if (enableRetries) {
+      logger.log(
+          Level.INFO,
+          "Retrying enabled. To disable retries, run the client with environment variable {0}=true.",
+          ENV_DISABLE_RETRYING);
+    } else {
+      logger.log(
+          Level.INFO,
+          "Retrying disabled. To enable retries, unset environment variable {0} and then run the client.",
+          ENV_DISABLE_RETRYING);
+    }
+  }
+
+  public static void main(String[] args) throws Exception {
+    boolean enableRetries = !Boolean.parseBoolean(System.getenv(ENV_DISABLE_RETRYING));
+    final RetryingHelloWorldClient client = new RetryingHelloWorldClient("localhost", 50051, enableRetries);
+    ForkJoinPool executor = new ForkJoinPool();
+
+    for (int i = 0; i < 50; i++) {
+      final String userId = "user" + i;
+      executor.execute(
+          new Runnable() {
+            @Override
+            public void run() {
+              client.greet(userId);
+            }
+          });
+    }
+    executor.awaitQuiescence(100, TimeUnit.SECONDS);
+    executor.shutdown();
+    client.printSummary();
+    client.shutdown();
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/retrying/RetryingHelloWorldServer.java b/examples/src/main/java/io/grpc/examples/retrying/RetryingHelloWorldServer.java
new file mode 100644
index 00000000000..165cc72ffa3
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/retrying/RetryingHelloWorldServer.java
@@ -0,0 +1,112 @@
+/*
+ * 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.examples.retrying;
+
+import java.text.DecimalFormat;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Server;
+import io.grpc.Status;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * A HelloWorld server that responds to requests with UNAVAILABLE with a given percentage.
+ */
+public class RetryingHelloWorldServer {
+  private static final Logger logger = Logger.getLogger(RetryingHelloWorldServer.class.getName());
+  private static final float UNAVAILABLE_PERCENTAGE = 0.5F;
+  private static final Random random = new Random();
+
+  private Server server;
+
+  private void start() throws IOException {
+    /* The port on which the server should run */
+    int port = 50051;
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(new GreeterImpl())
+        .build()
+        .start();
+    logger.info("Server started, listening on " + port);
+
+    DecimalFormat df = new DecimalFormat("#%");
+    logger.info("Responding as UNAVAILABLE to " + df.format(UNAVAILABLE_PERCENTAGE) + " requests");
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      public void run() {
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
+        System.err.println("*** shutting down gRPC server since JVM is shutting down");
+        try {
+          RetryingHelloWorldServer.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
+        System.err.println("*** server shut down");
+      }
+    });
+  }
+
+  private void stop() throws InterruptedException {
+    if (server != null) {
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
+    }
+  }
+
+  /**
+   * Await termination on the main thread since the grpc library uses daemon threads.
+   */
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+  }
+
+  /**
+   * Main launches the server from the command line.
+   */
+  public static void main(String[] args) throws IOException, InterruptedException {
+    final RetryingHelloWorldServer server = new RetryingHelloWorldServer();
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
+    AtomicInteger retryCounter = new AtomicInteger(0);
+
+    @Override
+    public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
+      int count = retryCounter.incrementAndGet();
+      if (random.nextFloat() < UNAVAILABLE_PERCENTAGE) {
+        logger.info("Returning stubbed UNAVAILABLE error. count: " + count);
+        responseObserver.onError(Status.UNAVAILABLE
+            .withDescription("Greeter temporarily unavailable...").asRuntimeException());
+      } else {
+        logger.info("Returning successful Hello response, count: " + count);
+        HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + request.getName()).build();
+        responseObserver.onNext(reply);
+        responseObserver.onCompleted();
+      }
+    }
+  }
+}
diff --git a/examples/src/main/java/io/grpc/examples/routeguide/README.md b/examples/src/main/java/io/grpc/examples/routeguide/README.md
new file mode 100644
index 00000000000..2528b26410c
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/routeguide/README.md
@@ -0,0 +1,24 @@
+gRPC Route Guide Example
+=====================
+
+This example illustrates how to implement and use a gRPC server and client for a RouteGuide service, 
+which demonstrates all 4 types of gRPC methods (unary, client streaming, server streaming, and bidirectional streaming).
+Additionally, the service loads geographic features from a JSON file [route_guide_db.json](https://github.com/grpc/grpc-java/blob/master/examples/src/main/resources/io/grpc/examples/routeguide/route_guide_db.json) and retrieves features based on latitude and longitude.
+
+The route_guide.proto file defines a gRPC service with 4 types of RPC methods, showcasing different communication patterns between client and server.
+1. Unary RPC
+   - rpc GetFeature(Point) returns (Feature) {}
+2. Server-Side Streaming RPC
+    - rpc ListFeatures(Rectangle) returns (stream Feature) {}
+3. Client-Side Streaming RPC
+    - rpc RecordRoute(stream Point) returns (RouteSummary) {}  
+4. Bidirectional Streaming RPC
+    - rpc RouteChat(stream RouteNote) returns (stream RouteNote) {}    
+
+These RPC methods illustrate the versatility of gRPC in handling various communication patterns, 
+from simple request-response interactions to complex bidirectional streaming scenarios.
+
+For more details, refer to the full route_guide.proto file on GitHub: https://github.com/grpc/grpc-java/blob/master/examples/src/main/proto/route_guide.proto
+
+Refer the gRPC documentation for more details on creation, build and execution of route guide example with explanation
+https://grpc.io/docs/languages/java/basics/
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideClient.java b/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideClient.java
index 64066995a13..f65b1215359 100644
--- a/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideClient.java
+++ b/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideClient.java
@@ -1,47 +1,32 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.routeguide;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.protobuf.Message;
-
+import io.grpc.Channel;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
 import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
 import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
 import io.grpc.examples.routeguide.RouteGuideGrpc.RouteGuideBlockingStub;
 import io.grpc.examples.routeguide.RouteGuideGrpc.RouteGuideStub;
 import io.grpc.stub.StreamObserver;
-
 import java.io.IOException;
 import java.util.Iterator;
 import java.util.List;
@@ -57,29 +42,18 @@
 public class RouteGuideClient {
   private static final Logger logger = Logger.getLogger(RouteGuideClient.class.getName());
 
-  private final ManagedChannel channel;
   private final RouteGuideBlockingStub blockingStub;
   private final RouteGuideStub asyncStub;
 
   private Random random = new Random();
   private TestHelper testHelper;
 
-  /** Construct client for accessing RouteGuide server at {@code host:port}. */
-  public RouteGuideClient(String host, int port) {
-    this(ManagedChannelBuilder.forAddress(host, port).usePlaintext(true));
-  }
-
   /** Construct client for accessing RouteGuide server using the existing channel. */
-  public RouteGuideClient(ManagedChannelBuilder<?> channelBuilder) {
-    channel = channelBuilder.build();
+  public RouteGuideClient(Channel channel) {
     blockingStub = RouteGuideGrpc.newBlockingStub(channel);
     asyncStub = RouteGuideGrpc.newStub(channel);
   }
 
-  public void shutdown() throws InterruptedException {
-    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
-  }
-
   /**
    * Blocking unary call example.  Calls getFeature and prints the response.
    */
@@ -245,8 +219,8 @@ public void onCompleted() {
 
     try {
       RouteNote[] requests =
-          {newNote("First message", 0, 0), newNote("Second message", 0, 1),
-              newNote("Third message", 1, 0), newNote("Fourth message", 1, 1)};
+          {newNote("First message", 0, 0), newNote("Second message", 0, 10_000_000),
+              newNote("Third message", 10_000_000, 0), newNote("Fourth message", 10_000_000, 10_000_000)};
 
       for (RouteNote request : requests) {
         info("Sending message \"{0}\" at {1}, {2}", request.getMessage(), request.getLocation()
@@ -267,6 +241,17 @@ public void onCompleted() {
 
   /** Issues several different requests and then exits. */
   public static void main(String[] args) throws InterruptedException {
+    String target = "localhost:8980";
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [target]");
+        System.err.println("");
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.exit(1);
+      }
+      target = args[0];
+    }
+
     List<Feature> features;
     try {
       features = RouteGuideUtil.parseFeatures(RouteGuideUtil.getDefaultFeaturesFile());
@@ -275,8 +260,10 @@ public static void main(String[] args) throws InterruptedException {
       return;
     }
 
-    RouteGuideClient client = new RouteGuideClient("localhost", 8980);
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .build();
     try {
+      RouteGuideClient client = new RouteGuideClient(channel);
       // Looking for a valid feature
       client.getFeature(409146138, -746188906);
 
@@ -296,7 +283,7 @@ public static void main(String[] args) throws InterruptedException {
         client.warning("routeChat can not finish within 1 minutes");
       }
     } finally {
-      client.shutdown();
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
     }
   }
 
diff --git a/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideServer.java b/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideServer.java
index c890e252768..1a3ecb0f882 100644
--- a/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideServer.java
+++ b/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideServer.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.routeguide;
@@ -40,10 +25,11 @@
 import static java.lang.Math.toRadians;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
 
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
 import io.grpc.Server;
 import io.grpc.ServerBuilder;
 import io.grpc.stub.StreamObserver;
-
 import java.io.IOException;
 import java.net.URL;
 import java.util.ArrayList;
@@ -52,6 +38,7 @@
 import java.util.List;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -70,7 +57,8 @@ public RouteGuideServer(int port) throws IOException {
 
   /** Create a RouteGuide server listening on {@code port} using {@code featureFile} database. */
   public RouteGuideServer(int port, URL featureFile) throws IOException {
-    this(ServerBuilder.forPort(port), port, RouteGuideUtil.parseFeatures(featureFile));
+    this(Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create()),
+        port, RouteGuideUtil.parseFeatures(featureFile));
   }
 
   /** Create a RouteGuide server using serverBuilder as a base and features as data. */
@@ -87,18 +75,22 @@ public void start() throws IOException {
     Runtime.getRuntime().addShutdownHook(new Thread() {
       @Override
       public void run() {
-        // Use stderr here since the logger may has been reset by its JVM shutdown hook.
+        // Use stderr here since the logger may have been reset by its JVM shutdown hook.
         System.err.println("*** shutting down gRPC server since JVM is shutting down");
-        RouteGuideServer.this.stop();
+        try {
+          RouteGuideServer.this.stop();
+        } catch (InterruptedException e) {
+          e.printStackTrace(System.err);
+        }
         System.err.println("*** server shut down");
       }
     });
   }
 
   /** Stop serving requests and shutdown resources. */
-  public void stop() {
+  public void stop() throws InterruptedException {
     if (server != null) {
-      server.shutdown();
+      server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
     }
   }
 
@@ -259,7 +251,7 @@ public void onCompleted() {
      * Get the notes list for the given location. If missing, create it.
      */
     private List<RouteNote> getOrCreateNotes(Point location) {
-      List<RouteNote> notes = Collections.synchronizedList(new ArrayList<RouteNote>());
+      List<RouteNote> notes = Collections.synchronizedList(new ArrayList<>());
       List<RouteNote> prevNotes = routeNotes.putIfAbsent(location, notes);
       return prevNotes != null ? prevNotes : notes;
     }
@@ -284,25 +276,23 @@ private Feature checkFeature(Point location) {
 
     /**
      * Calculate the distance between two points using the "haversine" formula.
-     * This code was taken from http://www.movable-type.co.uk/scripts/latlong.html.
+     * The formula is based on http://mathforum.org/library/drmath/view/51879.html.
      *
      * @param start The starting point
      * @param end The end point
      * @return The distance between the points in meters
      */
     private static int calcDistance(Point start, Point end) {
-      double lat1 = RouteGuideUtil.getLatitude(start);
-      double lat2 = RouteGuideUtil.getLatitude(end);
-      double lon1 = RouteGuideUtil.getLongitude(start);
-      double lon2 = RouteGuideUtil.getLongitude(end);
-      int r = 6371000; // meters
-      double phi1 = toRadians(lat1);
-      double phi2 = toRadians(lat2);
-      double deltaPhi = toRadians(lat2 - lat1);
-      double deltaLambda = toRadians(lon2 - lon1);
-
-      double a = sin(deltaPhi / 2) * sin(deltaPhi / 2)
-          + cos(phi1) * cos(phi2) * sin(deltaLambda / 2) * sin(deltaLambda / 2);
+      int r = 6371000; // earth radius in meters
+      double lat1 = toRadians(RouteGuideUtil.getLatitude(start));
+      double lat2 = toRadians(RouteGuideUtil.getLatitude(end));
+      double lon1 = toRadians(RouteGuideUtil.getLongitude(start));
+      double lon2 = toRadians(RouteGuideUtil.getLongitude(end));
+      double deltaLat = lat2 - lat1;
+      double deltaLon = lon2 - lon1;
+
+      double a = sin(deltaLat / 2) * sin(deltaLat / 2)
+          + cos(lat1) * cos(lat2) * sin(deltaLon / 2) * sin(deltaLon / 2);
       double c = 2 * atan2(sqrt(a), sqrt(1 - a));
 
       return (int) (r * c);
diff --git a/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideUtil.java b/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideUtil.java
index ec85c916d30..6e49492da06 100644
--- a/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideUtil.java
+++ b/examples/src/main/java/io/grpc/examples/routeguide/RouteGuideUtil.java
@@ -1,43 +1,28 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.routeguide;
 
 import com.google.protobuf.util.JsonFormat;
-
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.net.URL;
+import java.nio.charset.Charset;
 import java.util.List;
 
 /**
@@ -73,7 +58,7 @@ public static URL getDefaultFeaturesFile() {
   public static List<Feature> parseFeatures(URL file) throws IOException {
     InputStream input = file.openStream();
     try {
-      Reader reader = new InputStreamReader(input);
+      Reader reader = new InputStreamReader(input, Charset.forName("UTF-8"));
       try {
         FeatureDatabase.Builder database = FeatureDatabase.newBuilder();
         JsonFormat.parser().merge(reader, database);
diff --git a/examples/src/main/java/io/grpc/examples/waitforready/README.md b/examples/src/main/java/io/grpc/examples/waitforready/README.md
new file mode 100644
index 00000000000..1e294b453b6
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/waitforready/README.md
@@ -0,0 +1,29 @@
+gRPC Wait-For-Ready Example
+=====================
+
+This example gives the usage and implementation of the Wait-For-Ready feature.
+
+This feature can be activated on a client stub, ensuring that Remote Procedure Calls (RPCs) are held until the server is ready to receive them. 
+By waiting for the server to become available before sending requests, this mechanism enhances reliability, 
+particularly in situations where server availability may be delayed or unpredictable.
+
+When an RPC is initiated and the channel fails to connect to the server, its behavior depends on the Wait-for-Ready option:
+
+- Without Wait-for-Ready (Default Behavior):
+
+  - The RPC will immediately fail if the channel cannot establish a connection, providing prompt feedback about the connectivity issue.
+
+- With Wait-for-Ready:
+  
+  - The RPC will not fail immediately. Instead, it will be queued and will wait until the connection is successfully established.
+    This approach is beneficial for handling temporary network disruptions more gracefully, ensuring the RPC is eventually executed once the connection is ready.
+
+
+Example gives the Simple client that requests a greeting from the HelloWorldServer and defines waitForReady on the stub.
+
+To test this flow need to follow below steps:
+- run this client without a server running(client rpc should hang)
+- start the server (client rpc should complete)
+- run this client again (client rpc should complete nearly immediately)
+
+Refer the gRPC documentation for more on Wait-For-Ready https://grpc.io/docs/guides/wait-for-ready/
\ No newline at end of file
diff --git a/examples/src/main/java/io/grpc/examples/waitforready/WaitForReadyClient.java b/examples/src/main/java/io/grpc/examples/waitforready/WaitForReadyClient.java
new file mode 100644
index 00000000000..98372395c6e
--- /dev/null
+++ b/examples/src/main/java/io/grpc/examples/waitforready/WaitForReadyClient.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2023 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.examples.waitforready;
+
+import io.grpc.Channel;
+import io.grpc.Deadline;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.grpc.examples.helloworld.HelloReply;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * This is an example of using waitForReady.  This is a feature which can be used on a stub
+ * which will cause the rpcs to wait (until optional deadline is exceeded) for the
+ * server to become available before sending the request.  This is useful for batch workflows
+ * where there is no need to fail fast.
+ *
+ * Below is a simple client that requests a greeting from the
+ * {@link io.grpc.examples.helloworld.HelloWorldServer} and defines waitForReady on the stub.
+ * To test,
+ *   1. run this client without a server running - client rpc should hang
+ *   2. start the server - client rpc should complete
+ *   3. run this client again - client rpc should complete nearly immediately
+ */
+public class WaitForReadyClient {
+  private static final Logger logger = Logger.getLogger(WaitForReadyClient.class.getName());
+
+  private final GreeterGrpc.GreeterBlockingStub blockingStub;
+
+  /**
+   *  Construct client for accessing HelloWorld server using the existing channel which will
+   *  wait for the server to become ready, however long that may take, before sending the request.
+   */
+  public WaitForReadyClient(Channel channel) {
+    // This is the only difference from the simple HelloWorld example
+    blockingStub = GreeterGrpc.newBlockingStub(channel).withWaitForReady();
+  }
+
+  /**
+   *  Construct a client for accessing HelloWorld server using the existing channel which will
+   *  wait for the server to become ready, up to the specified deadline, before sending the request.
+   *  if the deadline is exceeded before the server becomes ready, then the rpc call will fail with
+   *  a Status of DEADLINE_EXCEEDED without the request being sent.
+   */
+  public WaitForReadyClient(Channel channel, Deadline deadline) {
+    blockingStub = GreeterGrpc.newBlockingStub(channel).withWaitForReady().withDeadline(deadline);
+  }
+
+
+  /** Say hello to server. */
+  public void greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
+    HelloReply response;
+    try {
+      response = blockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    logger.info("Greeting: " + response.getMessage());
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the
+   * greeting. The second argument is the target server.
+   */
+  public static void main(String[] args) throws Exception {
+    String user = "world";
+    // Access a service running on the local machine on port 50051
+    String target = "localhost:50051";
+    // Allow passing in the user and target strings as command line arguments
+    if (args.length > 0) {
+      if ("--help".equals(args[0])) {
+        System.err.println("Usage: [name [target]]");
+        System.err.println();
+        System.err.println("  name    The name you wish to be greeted by. Defaults to " + user);
+        System.err.println("  target  The server to connect to. Defaults to " + target);
+        System.exit(1);
+      }
+      user = args[0];
+    }
+    if (args.length > 1) {
+      target = args[1];
+    }
+
+    // Create a communication channel to the server, known as a Channel. Channels are thread-safe
+    // and reusable. It is common to create channels at the beginning of your application and reuse
+    // them until the application shuts down.
+    //
+    // For the example we use plaintext insecure credentials to avoid needing TLS certificates. To
+    // use TLS, use TlsChannelCredentials instead.
+    ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create())
+        .build();
+    try {
+      // If server isn't running, this will fail after 5 seconds.  Will also fail if the server is
+      // running particularly slowly and takes more than 5 minutes to respond.
+      WaitForReadyClient clientWithTimeout =
+          new WaitForReadyClient(channel, Deadline.after(5, TimeUnit.SECONDS));
+      clientWithTimeout.greet(user);
+
+      // This will wait forever until the server becomes ready
+      WaitForReadyClient client = new WaitForReadyClient(channel);
+      client.greet(user);
+    } finally {
+      // ManagedChannels use resources like threads and TCP connections. To prevent leaking these
+      // resources the channel should be shut down when it will no longer be used. If it may be used
+      // again leave it running.
+      channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+    }
+  }
+}
diff --git a/examples/src/main/proto/error_details.proto b/examples/src/main/proto/error_details.proto
deleted file mode 100644
index 2c795a6df17..00000000000
--- a/examples/src/main/proto/error_details.proto
+++ /dev/null
@@ -1,157 +0,0 @@
-// Copyright (c) 2016, Google Inc.
-//
-// 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.
-
-syntax = "proto3";
-
-package google.rpc;
-
-import "google/protobuf/duration.proto";
-
-option java_multiple_files = true;
-option java_outer_classname = "ErrorDetailsProto";
-option java_package = "com.google.rpc";
-
-
-// Describes when the clients can retry a failed request. Clients could ignore
-// the recommendation here or retry when this information is missing from error
-// responses.
-//
-// It's always recommended that clients should use exponential backoff when
-// retrying.
-//
-// Clients should wait until `retry_delay` amount of time has passed since
-// receiving the error response before retrying.  If retrying requests also
-// fail, clients should use an exponential backoff scheme to gradually increase
-// the delay between retries based on `retry_delay`, until either a maximum
-// number of retires have been reached or a maximum retry delay cap has been
-// reached.
-message RetryInfo {
-    // Clients should wait at least this long between retrying the same request.
-    google.protobuf.Duration retry_delay = 1;
-}
-
-// Describes additional debugging info.
-message DebugInfo {
-    // The stack trace entries indicating where the error occurred.
-    repeated string stack_entries = 1;
-
-    // Additional debugging information provided by the server.
-    string detail = 2;
-}
-
-// Describes how a quota check failed.
-//
-// For example if a daily limit was exceeded for the calling project,
-// a service could respond with a QuotaFailure detail containing the project
-// id and the description of the quota limit that was exceeded.  If the
-// calling project hasn't enabled the service in the developer console, then
-// a service could respond with the project id and set `service_disabled`
-// to true.
-//
-// Also see RetryDetail and Help types for other details about handling a
-// quota failure.
-message QuotaFailure {
-    // A message type used to describe a single quota violation.  For example, a
-    // daily quota or a custom quota that was exceeded.
-    message Violation {
-        // The subject on which the quota check failed.
-        // For example, "clientip:<ip address of client>" or "project:<Google
-        // developer project id>".
-        string subject = 1;
-
-        // A description of how the quota check failed. Clients can use this
-        // description to find more about the quota configuration in the service's
-        // public documentation, or find the relevant quota limit to adjust through
-        // developer console.
-        //
-        // For example: "Service disabled" or "Daily Limit for read operations
-        // exceeded".
-        string description = 2;
-    }
-
-    // Describes all quota violations.
-    repeated Violation violations = 1;
-}
-
-// Describes violations in a client request. This error type focuses on the
-// syntactic aspects of the request.
-message BadRequest {
-    // A message type used to describe a single bad request field.
-    message FieldViolation {
-        // A path leading to a field in the request body. The value will be a
-        // sequence of dot-separated identifiers that identify a protocol buffer
-        // field. E.g., "violations.field" would identify this field.
-        string field = 1;
-
-        // A description of why the request element is bad.
-        string description = 2;
-    }
-
-    // Describes all violations in a client request.
-    repeated FieldViolation field_violations = 1;
-}
-
-// Contains metadata about the request that clients can attach when filing a bug
-// or providing other forms of feedback.
-message RequestInfo {
-    // An opaque string that should only be interpreted by the service generating
-    // it. For example, it can be used to identify requests in the service's logs.
-    string request_id = 1;
-
-    // Any data that was used to serve this request. For example, an encrypted
-    // stack trace that can be sent back to the service provider for debugging.
-    string serving_data = 2;
-}
-
-// Describes the resource that is being accessed.
-message ResourceInfo {
-    // A name for the type of resource being accessed, e.g. "sql table",
-    // "cloud storage bucket", "file", "Google calendar"; or the type URL
-    // of the resource: e.g. "type.googleapis.com/google.pubsub.v1.Topic".
-    string resource_type = 1;
-
-    // The name of the resource being accessed.  For example, a shared calendar
-    // name: "example.com_4fghdhgsrgh@group.calendar.google.com", if the current
-    // error is [google.rpc.Code.PERMISSION_DENIED][google.rpc.Code.PERMISSION_DENIED].
-    string resource_name = 2;
-
-    // The owner of the resource (optional).
-    // For example, "user:<owner email>" or "project:<Google developer project
-    // id>".
-    string owner = 3;
-
-    // Describes what error is encountered when accessing this resource.
-    // For example, updating a cloud project may require the `writer` permission
-    // on the developer console project.
-    string description = 4;
-}
-
-// Provides links to documentation or for performing an out of band action.
-//
-// For example, if a quota check failed with an error indicating the calling
-// project hasn't enabled the accessed service, this can contain a URL pointing
-// directly to the right place in the developer console to flip the bit.
-message Help {
-    // Describes a URL link.
-    message Link {
-        // Describes what the link offers.
-        string description = 1;
-
-        // The URL of the link.
-        string url = 2;
-    }
-
-    // URL(s) pointing to additional information on handling the current error.
-    repeated Link links = 1;
-}
\ No newline at end of file
diff --git a/examples/src/main/proto/grpc/examples/echo/echo.proto b/examples/src/main/proto/grpc/examples/echo/echo.proto
new file mode 100644
index 00000000000..b18e295a9a5
--- /dev/null
+++ b/examples/src/main/proto/grpc/examples/echo/echo.proto
@@ -0,0 +1,48 @@
+/*
+ *
+ * Copyright 2018 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.
+ *
+ */
+
+syntax = "proto3";
+
+option go_package = "google.golang.org/grpc/examples/features/proto/echo";
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.echo";
+option java_outer_classname = "EchoProto";
+
+package grpc.examples.echo;
+
+// EchoRequest is the request for echo.
+message EchoRequest {
+  string message = 1;
+}
+
+// EchoResponse is the response for echo.
+message EchoResponse {
+  string message = 1;
+}
+
+// Echo is the echo service.
+service Echo {
+  // UnaryEcho is unary echo.
+  rpc UnaryEcho(EchoRequest) returns (EchoResponse) {}
+  // ServerStreamingEcho is server side streaming.
+  rpc ServerStreamingEcho(EchoRequest) returns (stream EchoResponse) {}
+  // ClientStreamingEcho is client side streaming.
+  rpc ClientStreamingEcho(stream EchoRequest) returns (EchoResponse) {}
+  // BidirectionalStreamingEcho is bidi streaming.
+  rpc BidirectionalStreamingEcho(stream EchoRequest) returns (stream EchoResponse) {}
+}
diff --git a/examples/src/main/proto/hello_streaming.proto b/examples/src/main/proto/hello_streaming.proto
new file mode 100644
index 00000000000..b4f0f5287dd
--- /dev/null
+++ b/examples/src/main/proto/hello_streaming.proto
@@ -0,0 +1,38 @@
+// Copyright 2015 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.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.manualflowcontrol";
+option java_outer_classname = "HelloStreamingProto";
+option objc_class_prefix = "HLWS";
+
+package manualflowcontrol;
+
+// The greeting service definition.
+service StreamingGreeter {
+  // Streams a many greetings
+  rpc SayHelloStreaming (stream HelloRequest) returns (stream HelloReply) {}
+}
+
+// The request message containing the user's name.
+message HelloRequest {
+  string name = 1;
+  bytes padding = 2;
+}
+
+// The response message containing the greetings
+message HelloReply {
+  string message = 1;
+}
diff --git a/examples/src/main/proto/helloworld.proto b/examples/src/main/proto/helloworld.proto
index 0bee1fcfcfb..c60d9416f1f 100644
--- a/examples/src/main/proto/helloworld.proto
+++ b/examples/src/main/proto/helloworld.proto
@@ -1,32 +1,16 @@
-// Copyright 2015, Google Inc.
-// All rights reserved.
+// Copyright 2015 The gRPC Authors
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
+//     http://www.apache.org/licenses/LICENSE-2.0
 //
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
+// 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.
 syntax = "proto3";
 
 option java_multiple_files = true;
diff --git a/examples/src/main/proto/route_guide.proto b/examples/src/main/proto/route_guide.proto
index 4c864d6f0dd..3c179f2ff11 100644
--- a/examples/src/main/proto/route_guide.proto
+++ b/examples/src/main/proto/route_guide.proto
@@ -1,32 +1,16 @@
-// Copyright 2015, Google Inc.
-// All rights reserved.
+// Copyright 2015 The gRPC Authors
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
+//     http://www.apache.org/licenses/LICENSE-2.0
 //
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
+// 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.
 syntax = "proto3";
 
 option java_multiple_files = true;
diff --git a/examples/src/main/resources/io/grpc/examples/hedging/hedging_service_config.json b/examples/src/main/resources/io/grpc/examples/hedging/hedging_service_config.json
new file mode 100644
index 00000000000..c3718626b9c
--- /dev/null
+++ b/examples/src/main/resources/io/grpc/examples/hedging/hedging_service_config.json
@@ -0,0 +1,22 @@
+{
+  "methodConfig": [
+    {
+      "name": [
+        {
+          "service": "helloworld.Greeter",
+          "method": "SayHello"
+        }
+      ],
+
+      "hedgingPolicy": {
+        "maxAttempts": 3,
+        "hedgingDelay": "1s"
+      }
+    }
+  ],
+
+  "retryThrottling": {
+    "maxTokens": 10,
+    "tokenRatio": 0.1
+  }
+}
diff --git a/examples/src/main/resources/io/grpc/examples/retrying/retrying_service_config.json b/examples/src/main/resources/io/grpc/examples/retrying/retrying_service_config.json
new file mode 100644
index 00000000000..ff115a9ad65
--- /dev/null
+++ b/examples/src/main/resources/io/grpc/examples/retrying/retrying_service_config.json
@@ -0,0 +1,22 @@
+{
+  "methodConfig": [
+    {
+      "name": [
+        {
+          "service": "helloworld.Greeter",
+          "method": "SayHello"
+        }
+      ],
+
+      "retryPolicy": {
+        "maxAttempts": 5,
+        "initialBackoff": "0.5s",
+        "maxBackoff": "30s",
+        "backoffMultiplier": 2,
+        "retryableStatusCodes": [
+          "UNAVAILABLE"
+        ]
+      }
+    }
+  ]
+}
diff --git a/examples/src/test/java/io/grpc/examples/header/HeaderClientInterceptorTest.java b/examples/src/test/java/io/grpc/examples/header/HeaderClientInterceptorTest.java
index b01c08f167c..7bd48ec727e 100644
--- a/examples/src/test/java/io/grpc/examples/header/HeaderClientInterceptorTest.java
+++ b/examples/src/test/java/io/grpc/examples/header/HeaderClientInterceptorTest.java
@@ -1,44 +1,30 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.header;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.fail;
-import static org.mockito.Mockito.spy;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 
+import io.grpc.ClientInterceptors;
 import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
-import io.grpc.Server;
 import io.grpc.ServerCall;
 import io.grpc.ServerCall.Listener;
 import io.grpc.ServerCallHandler;
@@ -52,14 +38,13 @@
 import io.grpc.examples.helloworld.HelloRequest;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
-
-import org.junit.After;
-import org.junit.Before;
+import io.grpc.testing.GrpcCleanupRule;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 
 /**
  * Unit tests for {@link HeaderClientInterceptor}.
@@ -71,42 +56,35 @@
  */
 @RunWith(JUnit4.class)
 public class HeaderClientInterceptorTest {
+  /**
+   * This rule manages automatic graceful shutdown for the registered servers and channels at the
+   * end of test.
+   */
+  @Rule
+  public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
 
-  private final ServerInterceptor mockServerInterceptor = spy(
+  private final ServerInterceptor mockServerInterceptor = mock(ServerInterceptor.class, delegatesTo(
       new ServerInterceptor() {
         @Override
         public <ReqT, RespT> Listener<ReqT> interceptCall(
             ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
           return next.startCall(call, headers);
         }
-      });
-
-  private Server fakeServer;
-  private ManagedChannel inProcessChannel;
-
-  @Before
-  public void setUp() throws Exception {
-    String uniqueServerName = "fake server for " + getClass();
-    fakeServer = InProcessServerBuilder.forName(uniqueServerName)
-        .addService(ServerInterceptors.intercept(new GreeterImplBase() {}, mockServerInterceptor))
-        .directExecutor()
-        .build()
-        .start();
-    inProcessChannel = InProcessChannelBuilder.forName(uniqueServerName)
-        .intercept(new HeaderClientInterceptor())
-        .directExecutor()
-        .build();
-  }
-
-  @After
-  public void tearDown() {
-    inProcessChannel.shutdownNow();
-    fakeServer.shutdownNow();
-  }
+      }));
 
   @Test
-  public void clientHeaderDeliveredToServer() {
-    GreeterBlockingStub blockingStub = GreeterGrpc.newBlockingStub(inProcessChannel);
+  public void clientHeaderDeliveredToServer() throws Exception {
+    // Generate a unique in-process server name.
+    String serverName = InProcessServerBuilder.generateName();
+    // Create a server, add service, start, and register for automatic graceful shutdown.
+    grpcCleanup.register(InProcessServerBuilder.forName(serverName).directExecutor()
+        .addService(ServerInterceptors.intercept(new GreeterImplBase() {}, mockServerInterceptor))
+        .build().start());
+    // Create a client channel and register for automatic graceful shutdown.
+    ManagedChannel channel = grpcCleanup.register(
+        InProcessChannelBuilder.forName(serverName).directExecutor().build());
+    GreeterBlockingStub blockingStub = GreeterGrpc.newBlockingStub(
+        ClientInterceptors.intercept(channel, new HeaderClientInterceptor()));
     ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
 
     try {
@@ -117,9 +95,9 @@ public void clientHeaderDeliveredToServer() {
     }
 
     verify(mockServerInterceptor).interceptCall(
-        Matchers.<ServerCall<HelloRequest, HelloReply>>any(),
+        ArgumentMatchers.<ServerCall<HelloRequest, HelloReply>>any(),
         metadataCaptor.capture(),
-        Matchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
+        ArgumentMatchers.<ServerCallHandler<HelloRequest, HelloReply>>any());
     assertEquals(
         "customRequestValue",
         metadataCaptor.getValue().get(HeaderClientInterceptor.CUSTOM_HEADER_KEY));
diff --git a/examples/src/test/java/io/grpc/examples/header/HeaderServerInterceptorTest.java b/examples/src/test/java/io/grpc/examples/header/HeaderServerInterceptorTest.java
index e1c8a1e8a44..4fc5c2901be 100644
--- a/examples/src/test/java/io/grpc/examples/header/HeaderServerInterceptorTest.java
+++ b/examples/src/test/java/io/grpc/examples/header/HeaderServerInterceptorTest.java
@@ -1,39 +1,25 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.header;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
-import static org.mockito.Mockito.spy;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 
 import io.grpc.CallOptions;
@@ -41,10 +27,8 @@
 import io.grpc.ClientCall;
 import io.grpc.ClientInterceptor;
 import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
-import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
-import io.grpc.Server;
 import io.grpc.ServerInterceptors;
 import io.grpc.examples.helloworld.GreeterGrpc;
 import io.grpc.examples.helloworld.GreeterGrpc.GreeterBlockingStub;
@@ -54,9 +38,9 @@
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
 import io.grpc.stub.StreamObserver;
-
-import org.junit.After;
+import io.grpc.testing.GrpcCleanupRule;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -72,12 +56,17 @@
  */
 @RunWith(JUnit4.class)
 public class HeaderServerInterceptorTest {
-  private Server fakeServer;
-  private ManagedChannel inProcessChannel;
+  /**
+   * This rule manages automatic graceful shutdown for the registered servers and channels at the
+   * end of test.
+   */
+  @Rule
+  public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+  private Channel channel;
 
   @Before
   public void setUp() throws Exception {
-    String uniqueServerName = "fake server for " + getClass();
     GreeterImplBase greeterImplBase =
         new GreeterImplBase() {
           @Override
@@ -86,18 +75,15 @@ public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseOb
             responseObserver.onCompleted();
           }
         };
-    fakeServer = InProcessServerBuilder.forName(uniqueServerName)
+    // Generate a unique in-process server name.
+    String serverName = InProcessServerBuilder.generateName();
+    // Create a server, add service, start, and register for automatic graceful shutdown.
+    grpcCleanup.register(InProcessServerBuilder.forName(serverName).directExecutor()
         .addService(ServerInterceptors.intercept(greeterImplBase, new HeaderServerInterceptor()))
-        .directExecutor()
-        .build()
-        .start();
-    inProcessChannel = InProcessChannelBuilder.forName(uniqueServerName).directExecutor().build();
-  }
-
-  @After
-  public void tearDown() {
-    inProcessChannel.shutdownNow();
-    fakeServer.shutdownNow();
+        .build().start());
+    // Create a client channel and register for automatic graceful shutdown.
+    channel =
+        grpcCleanup.register(InProcessChannelBuilder.forName(serverName).directExecutor().build());
   }
 
   @Test
@@ -111,7 +97,8 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
         return new SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {
           @Override
           public void start(Listener<RespT> responseListener, Metadata headers) {
-            spyListener = responseListener = spy(responseListener);
+            spyListener = responseListener =
+                mock(ClientCall.Listener.class, delegatesTo(responseListener));
             super.start(responseListener, headers);
           }
         };
@@ -119,8 +106,8 @@ public void start(Listener<RespT> responseListener, Metadata headers) {
     }
 
     SpyingClientInterceptor clientInterceptor = new SpyingClientInterceptor();
-    GreeterBlockingStub blockingStub =
-        GreeterGrpc.newBlockingStub(inProcessChannel).withInterceptors(clientInterceptor);
+    GreeterBlockingStub blockingStub = GreeterGrpc.newBlockingStub(channel)
+        .withInterceptors(clientInterceptor);
     ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
 
     blockingStub.sayHello(HelloRequest.getDefaultInstance());
diff --git a/examples/src/test/java/io/grpc/examples/helloworld/HelloWorldClientTest.java b/examples/src/test/java/io/grpc/examples/helloworld/HelloWorldClientTest.java
index 2a726513a1e..8c6cf60279a 100644
--- a/examples/src/test/java/io/grpc/examples/helloworld/HelloWorldClientTest.java
+++ b/examples/src/test/java/io/grpc/examples/helloworld/HelloWorldClientTest.java
@@ -1,88 +1,88 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.helloworld;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.spy;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 
-import io.grpc.Server;
+import io.grpc.ManagedChannel;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
 import io.grpc.stub.StreamObserver;
-
-import org.junit.After;
+import io.grpc.testing.GrpcCleanupRule;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
 
 /**
  * Unit tests for {@link HelloWorldClient}.
  * For demonstrating how to write gRPC unit test only.
  * Not intended to provide a high code coverage or to test every major usecase.
  *
+ * directExecutor() makes it easier to have deterministic tests.
+ *
  * <p>For more unit test examples see {@link io.grpc.examples.routeguide.RouteGuideClientTest} and
  * {@link io.grpc.examples.routeguide.RouteGuideServerTest}.
  */
 @RunWith(JUnit4.class)
 public class HelloWorldClientTest {
-  private final GreeterGrpc.GreeterImplBase serviceImpl = spy(new GreeterGrpc.GreeterImplBase() {});
+  /**
+   * This rule manages automatic graceful shutdown for the registered servers and channels at the
+   * end of test.
+   */
+  @Rule
+  public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+  private final GreeterGrpc.GreeterImplBase serviceImpl =
+      mock(GreeterGrpc.GreeterImplBase.class, delegatesTo(
+          new GreeterGrpc.GreeterImplBase() {
+          // By default the client will receive Status.UNIMPLEMENTED for all RPCs.
+          // You might need to implement necessary behaviors for your test here, like this:
+          //
+          // @Override
+          // public void sayHello(HelloRequest request, StreamObserver<HelloReply> respObserver) {
+          //   respObserver.onNext(HelloReply.getDefaultInstance());
+          //   respObserver.onCompleted();
+          // }
+          }));
 
-  private Server fakeServer;
   private HelloWorldClient client;
 
-  /**
-   * Creates and starts a fake in-process server, and creates a client with an in-process channel.
-   */
   @Before
   public void setUp() throws Exception {
-    String uniqueServerName = "fake server for " + getClass();
-    fakeServer = InProcessServerBuilder
-        .forName(uniqueServerName).directExecutor().addService(serviceImpl).build().start();
-    InProcessChannelBuilder channelBuilder =
-        InProcessChannelBuilder.forName(uniqueServerName).directExecutor();
-    client = new HelloWorldClient(channelBuilder);
-  }
+    // Generate a unique in-process server name.
+    String serverName = InProcessServerBuilder.generateName();
 
-  /**
-   * Shuts down the client and server.
-   */
-  @After
-  public void tearDown() throws Exception {
-    client.shutdown();
-    fakeServer.shutdownNow();
+    // Create a server, add service, start, and register for automatic graceful shutdown.
+    grpcCleanup.register(InProcessServerBuilder
+        .forName(serverName).directExecutor().addService(serviceImpl).build().start());
+
+    // Create a client channel and register for automatic graceful shutdown.
+    ManagedChannel channel = grpcCleanup.register(
+        InProcessChannelBuilder.forName(serverName).directExecutor().build());
+
+    // Create a HelloWorldClient using the in-process channel;
+    client = new HelloWorldClient(channel);
   }
 
   /**
@@ -92,12 +92,11 @@ public void tearDown() throws Exception {
   @Test
   public void greet_messageDeliveredToServer() {
     ArgumentCaptor<HelloRequest> requestCaptor = ArgumentCaptor.forClass(HelloRequest.class);
-    String testName = "test name";
 
-    client.greet(testName);
+    client.greet("test name");
 
     verify(serviceImpl)
-        .sayHello(requestCaptor.capture(), Matchers.<StreamObserver<HelloReply>>any());
-    assertEquals(testName, requestCaptor.getValue().getName());
+        .sayHello(requestCaptor.capture(), ArgumentMatchers.<StreamObserver<HelloReply>>any());
+    assertEquals("test name", requestCaptor.getValue().getName());
   }
 }
diff --git a/examples/src/test/java/io/grpc/examples/helloworld/HelloWorldServerTest.java b/examples/src/test/java/io/grpc/examples/helloworld/HelloWorldServerTest.java
index 9f51258fea9..63281eeba1a 100644
--- a/examples/src/test/java/io/grpc/examples/helloworld/HelloWorldServerTest.java
+++ b/examples/src/test/java/io/grpc/examples/helloworld/HelloWorldServerTest.java
@@ -1,46 +1,28 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.helloworld;
 
 import static org.junit.Assert.assertEquals;
 
-import io.grpc.ManagedChannel;
-import io.grpc.Server;
 import io.grpc.examples.helloworld.HelloWorldServer.GreeterImpl;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
-
-import org.junit.After;
-import org.junit.Before;
+import io.grpc.testing.GrpcCleanupRule;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -50,35 +32,19 @@
  * For demonstrating how to write gRPC unit test only.
  * Not intended to provide a high code coverage or to test every major usecase.
  *
+ * directExecutor() makes it easier to have deterministic tests.
+ *
  * <p>For more unit test examples see {@link io.grpc.examples.routeguide.RouteGuideClientTest} and
  * {@link io.grpc.examples.routeguide.RouteGuideServerTest}.
  */
 @RunWith(JUnit4.class)
 public class HelloWorldServerTest {
-  private static final String UNIQUE_SERVER_NAME =
-      "in-process server for " + HelloWorldServerTest.class;
-  private final Server inProcessServer = InProcessServerBuilder
-      .forName(UNIQUE_SERVER_NAME).addService(new GreeterImpl()).directExecutor().build();
-  private final ManagedChannel inProcessChannel =
-      InProcessChannelBuilder.forName(UNIQUE_SERVER_NAME).directExecutor().build();
-
-  /**
-   * Creates and starts the server with the {@link InProcessServerBuilder},
-   * and creates an in-process channel with the {@link InProcessChannelBuilder}.
-   */
-  @Before
-  public void setUp() throws Exception {
-    inProcessServer.start();
-  }
-
   /**
-   * Shuts down the in-process channel and server.
+   * This rule manages automatic graceful shutdown for the registered servers and channels at the
+   * end of test.
    */
-  @After
-  public void tearDown() {
-    inProcessChannel.shutdownNow();
-    inProcessServer.shutdownNow();
-  }
+  @Rule
+  public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
 
   /**
    * To test the server, make calls with a real stub using the in-process channel, and verify
@@ -86,11 +52,21 @@ public void tearDown() {
    */
   @Test
   public void greeterImpl_replyMessage() throws Exception {
-    GreeterGrpc.GreeterBlockingStub blockingStub = GreeterGrpc.newBlockingStub(inProcessChannel);
-    String testName = "test name";
+    // Generate a unique in-process server name.
+    String serverName = InProcessServerBuilder.generateName();
+
+    // Create a server, add service, start, and register for automatic graceful shutdown.
+    grpcCleanup.register(InProcessServerBuilder
+        .forName(serverName).directExecutor().addService(new GreeterImpl()).build().start());
+
+    GreeterGrpc.GreeterBlockingStub blockingStub = GreeterGrpc.newBlockingStub(
+        // Create a client channel and register for automatic graceful shutdown.
+        grpcCleanup.register(InProcessChannelBuilder.forName(serverName).directExecutor().build()));
+
 
-    HelloReply reply = blockingStub.sayHello(HelloRequest.newBuilder().setName(testName).build());
+    HelloReply reply =
+        blockingStub.sayHello(HelloRequest.newBuilder().setName( "test name").build());
 
-    assertEquals("Hello " + testName, reply.getMessage());
+    assertEquals("Hello test name", reply.getMessage());
   }
 }
diff --git a/examples/src/test/java/io/grpc/examples/routeguide/RouteGuideClientTest.java b/examples/src/test/java/io/grpc/examples/routeguide/RouteGuideClientTest.java
index c5a61ea7782..4c184fb82ee 100644
--- a/examples/src/test/java/io/grpc/examples/routeguide/RouteGuideClientTest.java
+++ b/examples/src/test/java/io/grpc/examples/routeguide/RouteGuideClientTest.java
@@ -1,46 +1,29 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.routeguide;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 
 import com.google.protobuf.Message;
-
-import io.grpc.Server;
 import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
 import io.grpc.examples.routeguide.RouteGuideClient.TestHelper;
@@ -48,15 +31,8 @@
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
 import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
 import io.grpc.util.MutableHandlerRegistry;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentCaptor;
-
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -64,17 +40,31 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
 
 /**
  * Unit tests for {@link RouteGuideClient}.
  * For demonstrating how to write gRPC unit test only.
  * Not intended to provide a high code coverage or to test every major usecase.
  *
+ * directExecutor() makes it easier to have deterministic tests.
+ *
  * <p>For basic unit test examples see {@link io.grpc.examples.helloworld.HelloWorldClientTest} and
  * {@link io.grpc.examples.helloworld.HelloWorldServerTest}.
  */
 @RunWith(JUnit4.class)
 public class RouteGuideClientTest {
+  /**
+   * This rule manages automatic graceful shutdown for the registered server at the end of test.
+   */
+  @Rule
+  public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
   private final MutableHandlerRegistry serviceRegistry = new MutableHandlerRegistry();
   private final TestHelper testHelper = mock(TestHelper.class);
   private final Random noRandomness =
@@ -94,27 +84,20 @@ public int nextInt(int bound) {
           return retVal;
         }
       };
-  private Server fakeServer;
   private RouteGuideClient client;
 
   @Before
   public void setUp() throws Exception {
-    String uniqueServerName = "fake server for " + getClass();
-
-    // use a mutable service registry for later registering the service impl for each test case.
-    fakeServer = InProcessServerBuilder.forName(uniqueServerName)
-        .fallbackHandlerRegistry(serviceRegistry).directExecutor().build().start();
-    client =
-        new RouteGuideClient(InProcessChannelBuilder.forName(uniqueServerName).directExecutor());
+    // Generate a unique in-process server name.
+    String serverName = InProcessServerBuilder.generateName();
+    // Use a mutable service registry for later registering the service impl for each test case.
+    grpcCleanup.register(InProcessServerBuilder.forName(serverName)
+        .fallbackHandlerRegistry(serviceRegistry).directExecutor().build().start());
+    client = new RouteGuideClient(grpcCleanup.register(
+        InProcessChannelBuilder.forName(serverName).directExecutor().build()));
     client.setTestHelper(testHelper);
   }
 
-  @After
-  public void tearDown() throws Exception {
-    client.shutdown();
-    fakeServer.shutdownNow();
-  }
-
   /**
    * Example for testing blocking unary call.
    */
@@ -267,7 +250,7 @@ public void recordRoute() throws Exception {
         Feature.newBuilder().setLocation(point3).build();
     final List<Feature> features = Arrays.asList(
         requestFeature1, requestFeature2, requestFeature3);
-    final List<Point> pointsDelivered = new ArrayList<Point>();
+    final List<Point> pointsDelivered = new ArrayList<>();
     final RouteSummary fakeResponse = RouteSummary
         .newBuilder()
         .setPointCount(7)
@@ -318,52 +301,6 @@ public void onCompleted() {
     verify(testHelper, never()).onRpcError(any(Throwable.class));
   }
 
-  /**
-   * Example for testing async client-streaming.
-   */
-  @Test
-  public void recordRoute_wrongResponse() throws Exception {
-    client.setRandom(noRandomness);
-    Point point1 = Point.newBuilder().setLatitude(1).setLongitude(1).build();
-    final Feature requestFeature1 =
-        Feature.newBuilder().setLocation(point1).build();
-    final List<Feature> features = Arrays.asList(requestFeature1);
-
-    // implement the fake service
-    RouteGuideImplBase recordRouteImpl =
-        new RouteGuideImplBase() {
-          @Override
-          public StreamObserver<Point> recordRoute(StreamObserver<RouteSummary> responseObserver) {
-            RouteSummary response = RouteSummary.getDefaultInstance();
-            // sending more than one responses is not right for client-streaming call.
-            responseObserver.onNext(response);
-            responseObserver.onNext(response);
-            responseObserver.onCompleted();
-
-            return new StreamObserver<Point>() {
-              @Override
-              public void onNext(Point value) {
-              }
-
-              @Override
-              public void onError(Throwable t) {
-              }
-
-              @Override
-              public void onCompleted() {
-              }
-            };
-          }
-        };
-    serviceRegistry.addService(recordRouteImpl);
-
-    client.recordRoute(features, 4);
-
-    ArgumentCaptor<Throwable> errorCaptor = ArgumentCaptor.forClass(Throwable.class);
-    verify(testHelper).onRpcError(errorCaptor.capture());
-    assertEquals(Status.Code.CANCELLED, Status.fromThrowable(errorCaptor.getValue()).getCode());
-  }
-
   /**
    * Example for testing async client-streaming.
    */
@@ -416,8 +353,8 @@ public void onCompleted() {
   public void routeChat_simpleResponse() throws Exception {
     RouteNote fakeResponse1 = RouteNote.newBuilder().setMessage("dummy msg1").build();
     RouteNote fakeResponse2 = RouteNote.newBuilder().setMessage("dummy msg2").build();
-    final List<String> messagesDelivered = new ArrayList<String>();
-    final List<Point> locationsDelivered = new ArrayList<Point>();
+    final List<String> messagesDelivered = new ArrayList<>();
+    final List<Point> locationsDelivered = new ArrayList<>();
     final AtomicReference<StreamObserver<RouteNote>> responseObserverRef =
         new AtomicReference<StreamObserver<RouteNote>>();
     final CountDownLatch allRequestsDelivered = new CountDownLatch(1);
@@ -461,9 +398,9 @@ public void onCompleted() {
     assertEquals(
         Arrays.asList(
             Point.newBuilder().setLatitude(0).setLongitude(0).build(),
-            Point.newBuilder().setLatitude(0).setLongitude(1).build(),
-            Point.newBuilder().setLatitude(1).setLongitude(0).build(),
-            Point.newBuilder().setLatitude(1).setLongitude(1).build()
+            Point.newBuilder().setLatitude(0).setLongitude(10_000_000).build(),
+            Point.newBuilder().setLatitude(10_000_000).setLongitude(0).build(),
+            Point.newBuilder().setLatitude(10_000_000).setLongitude(10_000_000).build()
         ),
         locationsDelivered);
 
@@ -487,7 +424,7 @@ public void onCompleted() {
    */
   @Test
   public void routeChat_echoResponse() throws Exception {
-    final List<RouteNote> notesDelivered = new ArrayList<RouteNote>();
+    final List<RouteNote> notesDelivered = new ArrayList<>();
 
     // implement the fake service
     RouteGuideImplBase routeChatImpl =
@@ -535,7 +472,7 @@ public void onCompleted() {
    */
   @Test
   public void routeChat_errorResponse() throws Exception {
-    final List<RouteNote> notesDelivered = new ArrayList<RouteNote>();
+    final List<RouteNote> notesDelivered = new ArrayList<>();
     final StatusRuntimeException fakeError = new StatusRuntimeException(Status.PERMISSION_DENIED);
 
     // implement the fake service
diff --git a/examples/src/test/java/io/grpc/examples/routeguide/RouteGuideServerTest.java b/examples/src/test/java/io/grpc/examples/routeguide/RouteGuideServerTest.java
index 31977765055..a5a84824af6 100644
--- a/examples/src/test/java/io/grpc/examples/routeguide/RouteGuideServerTest.java
+++ b/examples/src/test/java/io/grpc/examples/routeguide/RouteGuideServerTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.examples.routeguide;
@@ -34,7 +19,7 @@
 import static junit.framework.TestCase.fail;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.timeout;
@@ -44,51 +29,61 @@
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
 import io.grpc.stub.StreamObserver;
-
+import io.grpc.testing.GrpcCleanupRule;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-
 /**
  * Unit tests for {@link RouteGuideServer}.
  * For demonstrating how to write gRPC unit test only.
  * Not intended to provide a high code coverage or to test every major usecase.
  *
+ * directExecutor() makes it easier to have deterministic tests.
+ *
  * <p>For basic unit test examples see {@link io.grpc.examples.helloworld.HelloWorldClientTest} and
  * {@link io.grpc.examples.helloworld.HelloWorldServerTest}.
  */
 @RunWith(JUnit4.class)
 public class RouteGuideServerTest {
+  /**
+   * This rule manages automatic graceful shutdown for the registered channel at the end of test.
+   */
+  @Rule
+  public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
   private RouteGuideServer server;
   private ManagedChannel inProcessChannel;
   private Collection<Feature> features;
 
   @Before
   public void setUp() throws Exception {
-    String uniqueServerName = "in-process server for " + getClass();
-    features = new ArrayList<Feature>();
-    // use directExecutor for both InProcessServerBuilder and InProcessChannelBuilder can reduce the
+    // Generate a unique in-process server name.
+    String serverName = InProcessServerBuilder.generateName();
+    features = new ArrayList<>();
+    // Use directExecutor for both InProcessServerBuilder and InProcessChannelBuilder can reduce the
     // usage timeouts and latches in test. But we still add timeout and latches where they would be
     // needed if no directExecutor were used, just for demo purpose.
     server = new RouteGuideServer(
-        InProcessServerBuilder.forName(uniqueServerName).directExecutor(), 0, features);
+        InProcessServerBuilder.forName(serverName).directExecutor(), 0, features);
     server.start();
-    inProcessChannel = InProcessChannelBuilder.forName(uniqueServerName).directExecutor().build();
+    // Create a client channel and register for automatic graceful shutdown.
+    inProcessChannel = grpcCleanup.register(
+        InProcessChannelBuilder.forName(serverName).directExecutor().build());
   }
 
   @After
   public void tearDown() throws Exception {
-    inProcessChannel.shutdownNow();
     server.stop();
   }
 
@@ -140,7 +135,7 @@ public void listFeatures() throws Exception {
     features.add(f2);
     features.add(f3);
     features.add(f4);
-    final Collection<Feature> result = new HashSet<Feature>();
+    final List<Feature> result = new ArrayList<Feature>();
     final CountDownLatch latch = new CountDownLatch(1);
     StreamObserver<Feature> responseObserver =
         new StreamObserver<Feature>() {
@@ -166,7 +161,7 @@ public void onCompleted() {
     assertTrue(latch.await(1, TimeUnit.SECONDS));
 
     // verify
-    assertEquals(new HashSet<Feature>(Arrays.asList(f2, f3)), result);
+    assertEquals(Arrays.asList(f2, f3), result);
   }
 
   @Test
diff --git a/examples/thrift/build.gradle b/examples/thrift/build.gradle
deleted file mode 100644
index 5cf20a02e05..00000000000
--- a/examples/thrift/build.gradle
+++ /dev/null
@@ -1,55 +0,0 @@
-apply plugin: 'application'
-
-description = "Thrift Examples"
-
-startScripts.enabled = false
-
-def grpcVersion = '1.2.0-SNAPSHOT' // CURRENT_GRPC_VERSION
-
-repositories {
-  mavenCentral()
-  mavenLocal()
-}
-
-dependencies {
-  compile "io.grpc:grpc-stub:${grpcVersion}"
-  compile "io.grpc:grpc-thrift:${grpcVersion}"
-  compile "io.grpc:grpc-netty:${grpcVersion}"
-}
-
-String generatedSourcePath = "${projectDir}/src/generated"
-project.sourceSets {
-  main {
-    java {
-      srcDir "${generatedSourcePath}/main/java"
-      srcDir "${generatedSourcePath}/main/grpc"
-    }
-  }
-}
-
-task thriftHelloWorldServer(type: CreateStartScripts) {
-    mainClassName = "io.grpc.examples.thrift.helloworld.HelloWorldServer"
-    applicationName = "thrift-hello-world-server"
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = jar.outputs.files + project.configurations.runtime
-}
-
-task thriftHelloWorldClient(type: CreateStartScripts) {
-   mainClassName = "io.grpc.examples.thrift.helloworld.HelloWorldClient"
-   applicationName = "thrift-hello-world-client"
-   outputDir = new File(project.buildDir, 'tmp')
-   classpath = jar.outputs.files + project.configurations.runtime
-}
-
-applicationDistribution.into("bin") {
-    from(thriftHelloWorldServer)
-    from(thriftHelloWorldClient)
-    fileMode = 0755
-}
-
-idea {
-    module {
-        sourceDirs += file("${projectDir}/src/generated/main/java");
-        sourceDirs += file("${projectDir}/src/generated/main/grpc");
-    }
-}
diff --git a/examples/thrift/src/generated/main/grpc/io/grpc/examples/thrift/helloworld/GreeterGrpc.java b/examples/thrift/src/generated/main/grpc/io/grpc/examples/thrift/helloworld/GreeterGrpc.java
deleted file mode 100644
index b4bdeee008e..00000000000
--- a/examples/thrift/src/generated/main/grpc/io/grpc/examples/thrift/helloworld/GreeterGrpc.java
+++ /dev/null
@@ -1,1007 +0,0 @@
-/**
- * Autogenerated by Thrift Compiler (1.0.0-dev)
- *
- * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *  @generated
- */
-package io.grpc.examples.thrift.helloworld;
-
-import org.apache.thrift.scheme.IScheme;
-import org.apache.thrift.scheme.SchemeFactory;
-import org.apache.thrift.scheme.StandardScheme;
-
-import org.apache.thrift.scheme.TupleScheme;
-import org.apache.thrift.protocol.TTupleProtocol;
-import org.apache.thrift.protocol.TProtocolException;
-import org.apache.thrift.EncodingUtils;
-import org.apache.thrift.server.AbstractNonblockingServer.*;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.Map;
-import java.util.HashMap;
-import java.util.EnumMap;
-import java.util.Set;
-import java.util.HashSet;
-import java.util.EnumSet;
-import java.util.Collections;
-import java.util.BitSet;
-import java.nio.ByteBuffer;
-import java.util.Arrays;
-import javax.annotation.Generated;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
-import io.grpc.thrift.ThriftUtils;
-
-public class GreeterGrpc {
-
-  private GreeterGrpc() {}
-
-  public static final String SERVICE_NAME = "io.grpc.examples.thrift.helloworld.Greeter";
-
-  @java.lang.Deprecated public static interface Greeter {
-    public void sayHello(sayHello_args request,
-        io.grpc.stub.StreamObserver<sayHello_result> responseObserver);
-
-  }
-
-  private static final int ARG_IN_METHOD_sayHello = 1;
-  private static final int ARG_OUT_METHOD_sayHello = 2;
-
-  private static final class ThriftMessageFactory<T extends org.apache.thrift.TBase<T,?>>
-      implements io.grpc.thrift.MessageFactory<T> {
-    private final int id;
-
-
-    ThriftMessageFactory(int id) {
-      this.id = id;
-    }
-    @java.lang.Override
-    public T newInstance() {
-      Object o;
-      switch (id) {
-      case ARG_IN_METHOD_sayHello:
-        o = new sayHello_args();
-        break;
-      case ARG_OUT_METHOD_sayHello:
-       o = new sayHello_result();
-        break;
-      default:
-  throw new AssertionError();
-}
-      @java.lang.SuppressWarnings("unchecked")
-      T t = (T) o;
-return t;
-    }
-  }
-  public static abstract class GreeterImplBase implements Greeter, io.grpc.BindableService {
-    @java.lang.Override
-    public void sayHello(sayHello_args request, 
-        io.grpc.stub.StreamObserver<sayHello_result> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_sayHello, responseObserver);
-    }
-
-    @java.lang.Override public io.grpc.ServerServiceDefinition bindService() {
-      return GreeterGrpc.bindService(this);
-    }
-
-  }
-
-  @java.lang.Deprecated public static abstract class AbstractGreeter extends GreeterImplBase {}
-
-  public static class sayHello_args implements org.apache.thrift.TBase<sayHello_args, sayHello_args._Fields>, java.io.Serializable, Cloneable, Comparable<sayHello_args>   {
-    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("sayHello_args");
-
-    private static final org.apache.thrift.protocol.TField REQUEST_FIELD_DESC = new org.apache.thrift.protocol.TField("request", org.apache.thrift.protocol.TType.STRUCT, (short)1);
-
-    private static final SchemeFactory STANDARD_SCHEME_FACTORY = new sayHello_argsStandardSchemeFactory();
-    private static final SchemeFactory TUPLE_SCHEME_FACTORY = new sayHello_argsTupleSchemeFactory();
-
-    public HelloRequest request; // required
-
-    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
-    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
-      REQUEST((short)1, "request");
-
-      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
-
-      static {
-        for (_Fields field : EnumSet.allOf(_Fields.class)) {
-          byName.put(field.getFieldName(), field);
-        }
-      }
-
-      /**
-       * Find the _Fields constant that matches fieldId, or null if its not found.
-       */
-      public static _Fields findByThriftId(int fieldId) {
-        switch(fieldId) {
-          case 1: // REQUEST
-            return REQUEST;
-          default:
-            return null;
-        }
-      }
-
-      /**
-       * Find the _Fields constant that matches fieldId, throwing an exception
-       * if it is not found.
-       */
-      public static _Fields findByThriftIdOrThrow(int fieldId) {
-        _Fields fields = findByThriftId(fieldId);
-        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
-        return fields;
-      }
-
-      /**
-       * Find the _Fields constant that matches name, or null if its not found.
-       */
-      public static _Fields findByName(String name) {
-        return byName.get(name);
-      }
-
-      private final short _thriftId;
-      private final String _fieldName;
-
-      _Fields(short thriftId, String fieldName) {
-        _thriftId = thriftId;
-        _fieldName = fieldName;
-      }
-
-      public short getThriftFieldId() {
-        return _thriftId;
-      }
-
-      public String getFieldName() {
-        return _fieldName;
-      }
-    }
-
-    // isset id assignments
-    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
-    static {
-      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
-      tmpMap.put(_Fields.REQUEST, new org.apache.thrift.meta_data.FieldMetaData("request", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, HelloRequest.class)));
-      metaDataMap = Collections.unmodifiableMap(tmpMap);
-      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(sayHello_args.class, metaDataMap);
-    }
-
-    public sayHello_args() {
-    }
-
-    public sayHello_args(
-      HelloRequest request)
-    {
-      this();
-      this.request = request;
-    }
-
-    /**
-     * Performs a deep copy on <i>other</i>.
-     */
-    public sayHello_args(sayHello_args other) {
-      if (other.isSetRequest()) {
-        this.request = new HelloRequest(other.request);
-      }
-    }
-
-    public sayHello_args deepCopy() {
-      return new sayHello_args(this);
-    }
-
-    @Override
-    public void clear() {
-      this.request = null;
-    }
-
-    public HelloRequest getRequest() {
-      return this.request;
-    }
-
-    public sayHello_args setRequest(HelloRequest request) {
-      this.request = request;
-      return this;
-    }
-
-    public void unsetRequest() {
-      this.request = null;
-    }
-
-    /** Returns true if field request is set (has been assigned a value) and false otherwise */
-    public boolean isSetRequest() {
-      return this.request != null;
-    }
-
-    public void setRequestIsSet(boolean value) {
-      if (!value) {
-        this.request = null;
-      }
-    }
-
-    public void setFieldValue(_Fields field, Object value) {
-      switch (field) {
-      case REQUEST:
-        if (value == null) {
-          unsetRequest();
-        } else {
-          setRequest((HelloRequest)value);
-        }
-        break;
-
-      }
-    }
-
-    public Object getFieldValue(_Fields field) {
-      switch (field) {
-      case REQUEST:
-        return getRequest();
-
-      }
-      throw new IllegalStateException();
-    }
-
-    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
-    public boolean isSet(_Fields field) {
-      if (field == null) {
-        throw new IllegalArgumentException();
-      }
-
-      switch (field) {
-      case REQUEST:
-        return isSetRequest();
-      }
-      throw new IllegalStateException();
-    }
-
-    @Override
-    public boolean equals(Object that) {
-      if (that == null)
-        return false;
-      if (that instanceof sayHello_args)
-        return this.equals((sayHello_args)that);
-      return false;
-    }
-
-    public boolean equals(sayHello_args that) {
-      if (that == null)
-        return false;
-
-      boolean this_present_request = true && this.isSetRequest();
-      boolean that_present_request = true && that.isSetRequest();
-      if (this_present_request || that_present_request) {
-        if (!(this_present_request && that_present_request))
-          return false;
-        if (!this.request.equals(that.request))
-          return false;
-      }
-
-      return true;
-    }
-
-    @Override
-    public int hashCode() {
-      int hashCode = 1;
-
-      hashCode = hashCode * 8191 + ((isSetRequest()) ? 131071 : 524287);
-      if (isSetRequest())
-        hashCode = hashCode * 8191 + request.hashCode();
-
-      return hashCode;
-    }
-
-    @Override
-    public int compareTo(sayHello_args other) {
-      if (!getClass().equals(other.getClass())) {
-        return getClass().getName().compareTo(other.getClass().getName());
-      }
-
-      int lastComparison = 0;
-
-      lastComparison = Boolean.valueOf(isSetRequest()).compareTo(other.isSetRequest());
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
-      if (isSetRequest()) {
-        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.request, other.request);
-        if (lastComparison != 0) {
-          return lastComparison;
-        }
-      }
-      return 0;
-    }
-
-    public _Fields fieldForId(int fieldId) {
-      return _Fields.findByThriftId(fieldId);
-    }
-
-    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
-      scheme(iprot).read(iprot, this);
-    }
-
-    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
-      scheme(oprot).write(oprot, this);
-    }
-
-    @Override
-    public String toString() {
-      StringBuilder sb = new StringBuilder("sayHello_args(");
-      boolean first = true;
-
-      sb.append("request:");
-      if (this.request == null) {
-        sb.append("null");
-      } else {
-        sb.append(this.request);
-      }
-      first = false;
-      sb.append(")");
-      return sb.toString();
-    }
-
-    public void validate() throws org.apache.thrift.TException {
-      // check for required fields
-      // check for sub-struct validity
-      if (request != null) {
-        request.validate();
-      }
-    }
-
-    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
-      try {
-        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
-      } catch (org.apache.thrift.TException te) {
-        throw new java.io.IOException(te);
-      }
-    }
-
-    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
-      try {
-        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
-      } catch (org.apache.thrift.TException te) {
-        throw new java.io.IOException(te);
-      }
-    }
-
-    private static class sayHello_argsStandardSchemeFactory implements SchemeFactory {
-      public sayHello_argsStandardScheme getScheme() {
-        return new sayHello_argsStandardScheme();
-      }
-    }
-
-    private static class sayHello_argsStandardScheme extends StandardScheme<sayHello_args> {
-
-      public void read(org.apache.thrift.protocol.TProtocol iprot, sayHello_args struct) throws org.apache.thrift.TException {
-        org.apache.thrift.protocol.TField schemeField;
-        iprot.readStructBegin();
-        while (true)
-        {
-          schemeField = iprot.readFieldBegin();
-          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
-            break;
-          }
-          switch (schemeField.id) {
-            case 1: // REQUEST
-              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
-                struct.request = new HelloRequest();
-                struct.request.read(iprot);
-                struct.setRequestIsSet(true);
-              } else { 
-                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
-              }
-              break;
-            default:
-              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
-          }
-          iprot.readFieldEnd();
-        }
-        iprot.readStructEnd();
-
-        // check for required fields of primitive type, which can't be checked in the validate method
-        struct.validate();
-      }
-
-      public void write(org.apache.thrift.protocol.TProtocol oprot, sayHello_args struct) throws org.apache.thrift.TException {
-        struct.validate();
-
-        oprot.writeStructBegin(STRUCT_DESC);
-        if (struct.request != null) {
-          oprot.writeFieldBegin(REQUEST_FIELD_DESC);
-          struct.request.write(oprot);
-          oprot.writeFieldEnd();
-        }
-        oprot.writeFieldStop();
-        oprot.writeStructEnd();
-      }
-
-    }
-
-    private static class sayHello_argsTupleSchemeFactory implements SchemeFactory {
-      public sayHello_argsTupleScheme getScheme() {
-        return new sayHello_argsTupleScheme();
-      }
-    }
-
-    private static class sayHello_argsTupleScheme extends TupleScheme<sayHello_args> {
-
-      @Override
-      public void write(org.apache.thrift.protocol.TProtocol prot, sayHello_args struct) throws org.apache.thrift.TException {
-        TTupleProtocol oprot = (TTupleProtocol) prot;
-        BitSet optionals = new BitSet();
-        if (struct.isSetRequest()) {
-          optionals.set(0);
-        }
-        oprot.writeBitSet(optionals, 1);
-        if (struct.isSetRequest()) {
-          struct.request.write(oprot);
-        }
-      }
-
-      @Override
-      public void read(org.apache.thrift.protocol.TProtocol prot, sayHello_args struct) throws org.apache.thrift.TException {
-        TTupleProtocol iprot = (TTupleProtocol) prot;
-        BitSet incoming = iprot.readBitSet(1);
-        if (incoming.get(0)) {
-          struct.request = new HelloRequest();
-          struct.request.read(iprot);
-          struct.setRequestIsSet(true);
-        }
-      }
-    }
-
-    private static <S extends IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
-      return (StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
-    }
-  }
-
-  public static class sayHello_result implements org.apache.thrift.TBase<sayHello_result, sayHello_result._Fields>, java.io.Serializable, Cloneable, Comparable<sayHello_result>   {
-    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("sayHello_result");
-
-    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.STRUCT, (short)0);
-
-    private static final SchemeFactory STANDARD_SCHEME_FACTORY = new sayHello_resultStandardSchemeFactory();
-    private static final SchemeFactory TUPLE_SCHEME_FACTORY = new sayHello_resultTupleSchemeFactory();
-
-    public HelloResponse success; // required
-
-    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
-    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
-      SUCCESS((short)0, "success");
-
-      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
-
-      static {
-        for (_Fields field : EnumSet.allOf(_Fields.class)) {
-          byName.put(field.getFieldName(), field);
-        }
-      }
-
-      /**
-       * Find the _Fields constant that matches fieldId, or null if its not found.
-       */
-      public static _Fields findByThriftId(int fieldId) {
-        switch(fieldId) {
-          case 0: // SUCCESS
-            return SUCCESS;
-          default:
-            return null;
-        }
-      }
-
-      /**
-       * Find the _Fields constant that matches fieldId, throwing an exception
-       * if it is not found.
-       */
-      public static _Fields findByThriftIdOrThrow(int fieldId) {
-        _Fields fields = findByThriftId(fieldId);
-        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
-        return fields;
-      }
-
-      /**
-       * Find the _Fields constant that matches name, or null if its not found.
-       */
-      public static _Fields findByName(String name) {
-        return byName.get(name);
-      }
-
-      private final short _thriftId;
-      private final String _fieldName;
-
-      _Fields(short thriftId, String fieldName) {
-        _thriftId = thriftId;
-        _fieldName = fieldName;
-      }
-
-      public short getThriftFieldId() {
-        return _thriftId;
-      }
-
-      public String getFieldName() {
-        return _fieldName;
-      }
-    }
-
-    // isset id assignments
-    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
-    static {
-      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
-      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-          new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, HelloResponse.class)));
-      metaDataMap = Collections.unmodifiableMap(tmpMap);
-      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(sayHello_result.class, metaDataMap);
-    }
-
-    public sayHello_result() {
-    }
-
-    public sayHello_result(
-      HelloResponse success)
-    {
-      this();
-      this.success = success;
-    }
-
-    /**
-     * Performs a deep copy on <i>other</i>.
-     */
-    public sayHello_result(sayHello_result other) {
-      if (other.isSetSuccess()) {
-        this.success = new HelloResponse(other.success);
-      }
-    }
-
-    public sayHello_result deepCopy() {
-      return new sayHello_result(this);
-    }
-
-    @Override
-    public void clear() {
-      this.success = null;
-    }
-
-    public HelloResponse getSuccess() {
-      return this.success;
-    }
-
-    public sayHello_result setSuccess(HelloResponse success) {
-      this.success = success;
-      return this;
-    }
-
-    public void unsetSuccess() {
-      this.success = null;
-    }
-
-    /** Returns true if field success is set (has been assigned a value) and false otherwise */
-    public boolean isSetSuccess() {
-      return this.success != null;
-    }
-
-    public void setSuccessIsSet(boolean value) {
-      if (!value) {
-        this.success = null;
-      }
-    }
-
-    public void setFieldValue(_Fields field, Object value) {
-      switch (field) {
-      case SUCCESS:
-        if (value == null) {
-          unsetSuccess();
-        } else {
-          setSuccess((HelloResponse)value);
-        }
-        break;
-
-      }
-    }
-
-    public Object getFieldValue(_Fields field) {
-      switch (field) {
-      case SUCCESS:
-        return getSuccess();
-
-      }
-      throw new IllegalStateException();
-    }
-
-    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
-    public boolean isSet(_Fields field) {
-      if (field == null) {
-        throw new IllegalArgumentException();
-      }
-
-      switch (field) {
-      case SUCCESS:
-        return isSetSuccess();
-      }
-      throw new IllegalStateException();
-    }
-
-    @Override
-    public boolean equals(Object that) {
-      if (that == null)
-        return false;
-      if (that instanceof sayHello_result)
-        return this.equals((sayHello_result)that);
-      return false;
-    }
-
-    public boolean equals(sayHello_result that) {
-      if (that == null)
-        return false;
-
-      boolean this_present_success = true && this.isSetSuccess();
-      boolean that_present_success = true && that.isSetSuccess();
-      if (this_present_success || that_present_success) {
-        if (!(this_present_success && that_present_success))
-          return false;
-        if (!this.success.equals(that.success))
-          return false;
-      }
-
-      return true;
-    }
-
-    @Override
-    public int hashCode() {
-      int hashCode = 1;
-
-      hashCode = hashCode * 8191 + ((isSetSuccess()) ? 131071 : 524287);
-      if (isSetSuccess())
-        hashCode = hashCode * 8191 + success.hashCode();
-
-      return hashCode;
-    }
-
-    @Override
-    public int compareTo(sayHello_result other) {
-      if (!getClass().equals(other.getClass())) {
-        return getClass().getName().compareTo(other.getClass().getName());
-      }
-
-      int lastComparison = 0;
-
-      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
-      if (isSetSuccess()) {
-        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, other.success);
-        if (lastComparison != 0) {
-          return lastComparison;
-        }
-      }
-      return 0;
-    }
-
-    public _Fields fieldForId(int fieldId) {
-      return _Fields.findByThriftId(fieldId);
-    }
-
-    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
-      scheme(iprot).read(iprot, this);
-    }
-
-    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
-      scheme(oprot).write(oprot, this);
-      }
-
-    @Override
-    public String toString() {
-      StringBuilder sb = new StringBuilder("sayHello_result(");
-      boolean first = true;
-
-      sb.append("success:");
-      if (this.success == null) {
-        sb.append("null");
-      } else {
-        sb.append(this.success);
-      }
-      first = false;
-      sb.append(")");
-      return sb.toString();
-    }
-
-    public void validate() throws org.apache.thrift.TException {
-      // check for required fields
-      // check for sub-struct validity
-      if (success != null) {
-        success.validate();
-      }
-    }
-
-    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
-      try {
-        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
-      } catch (org.apache.thrift.TException te) {
-        throw new java.io.IOException(te);
-      }
-    }
-
-    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
-      try {
-        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
-      } catch (org.apache.thrift.TException te) {
-        throw new java.io.IOException(te);
-      }
-    }
-
-    private static class sayHello_resultStandardSchemeFactory implements SchemeFactory {
-      public sayHello_resultStandardScheme getScheme() {
-        return new sayHello_resultStandardScheme();
-      }
-    }
-
-    private static class sayHello_resultStandardScheme extends StandardScheme<sayHello_result> {
-
-      public void read(org.apache.thrift.protocol.TProtocol iprot, sayHello_result struct) throws org.apache.thrift.TException {
-        org.apache.thrift.protocol.TField schemeField;
-        iprot.readStructBegin();
-        while (true)
-        {
-          schemeField = iprot.readFieldBegin();
-          if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
-            break;
-          }
-          switch (schemeField.id) {
-            case 0: // SUCCESS
-              if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
-                struct.success = new HelloResponse();
-                struct.success.read(iprot);
-                struct.setSuccessIsSet(true);
-              } else { 
-                org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
-              }
-              break;
-            default:
-              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
-          }
-          iprot.readFieldEnd();
-        }
-        iprot.readStructEnd();
-
-        // check for required fields of primitive type, which can't be checked in the validate method
-        struct.validate();
-      }
-
-      public void write(org.apache.thrift.protocol.TProtocol oprot, sayHello_result struct) throws org.apache.thrift.TException {
-        struct.validate();
-
-        oprot.writeStructBegin(STRUCT_DESC);
-        if (struct.success != null) {
-          oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
-          struct.success.write(oprot);
-          oprot.writeFieldEnd();
-        }
-        oprot.writeFieldStop();
-        oprot.writeStructEnd();
-      }
-
-    }
-
-    private static class sayHello_resultTupleSchemeFactory implements SchemeFactory {
-      public sayHello_resultTupleScheme getScheme() {
-        return new sayHello_resultTupleScheme();
-      }
-    }
-
-    private static class sayHello_resultTupleScheme extends TupleScheme<sayHello_result> {
-
-      @Override
-      public void write(org.apache.thrift.protocol.TProtocol prot, sayHello_result struct) throws org.apache.thrift.TException {
-        TTupleProtocol oprot = (TTupleProtocol) prot;
-        BitSet optionals = new BitSet();
-        if (struct.isSetSuccess()) {
-          optionals.set(0);
-        }
-        oprot.writeBitSet(optionals, 1);
-        if (struct.isSetSuccess()) {
-          struct.success.write(oprot);
-        }
-      }
-
-      @Override
-      public void read(org.apache.thrift.protocol.TProtocol prot, sayHello_result struct) throws org.apache.thrift.TException {
-        TTupleProtocol iprot = (TTupleProtocol) prot;
-        BitSet incoming = iprot.readBitSet(1);
-        if (incoming.get(0)) {
-          struct.success = new HelloResponse();
-          struct.success.read(iprot);
-          struct.setSuccessIsSet(true);
-        }
-      }
-    }
-
-    private static <S extends IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
-      return (StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
-    }
-  }
-
-  public static final io.grpc.MethodDescriptor<sayHello_args,
-      sayHello_result> METHOD_sayHello = 
-      io.grpc.MethodDescriptor.create(
-        io.grpc.MethodDescriptor.MethodType.UNARY,
-        generateFullMethodName("io.grpc.examples.thrift.helloworld.Greeter" , "sayHello"),
-        io.grpc.thrift.ThriftUtils.marshaller(
-        new ThriftMessageFactory<sayHello_args>( ARG_IN_METHOD_sayHello)),
-        io.grpc.thrift.ThriftUtils.marshaller(
-        new ThriftMessageFactory<sayHello_result>( ARG_OUT_METHOD_sayHello)));
-
-  public static GreeterStub newStub(io.grpc.Channel channel) {
-    return new GreeterStub(channel);
-  }
-
-  public static class GreeterStub extends io.grpc.stub.AbstractStub<GreeterStub>
-      implements Greeter{
-    private GreeterStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private GreeterStub(io.grpc.Channel channel, 
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected GreeterStub build(io.grpc.Channel channel, 
-        io.grpc.CallOptions callOptions) {
-      return new GreeterStub(channel, callOptions);
-    }
-
-    @java.lang.Override
-    public void sayHello(sayHello_args request,
-        io.grpc.stub.StreamObserver<sayHello_result> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_sayHello, getCallOptions()), request, responseObserver);
-    }
-
-  }
-
-  public static GreeterBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    return new GreeterBlockingStub(channel);
-  }
-
-  @java.lang.Deprecated public static interface GreeterBlockingClient {
-    public sayHello_result sayHello(sayHello_args request);
-
-  }
-
-  public static class GreeterBlockingStub extends io.grpc.stub.AbstractStub<GreeterBlockingStub>
-      implements GreeterBlockingClient {
-    private GreeterBlockingStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private GreeterBlockingStub(io.grpc.Channel channel, 
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected GreeterBlockingStub build(io.grpc.Channel channel, 
-        io.grpc.CallOptions callOptions) {
-      return new GreeterBlockingStub(channel, callOptions);
-    }
-
-    @java.lang.Override
-    public sayHello_result sayHello(sayHello_args request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_sayHello, getCallOptions(), request);
-    }
-
-  }
-
-  public static GreeterFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    return new GreeterFutureStub(channel);
-  }
-
-  @java.lang.Deprecated public static interface GreeterFutureClient {
-    public com.google.common.util.concurrent.ListenableFuture<sayHello_result> sayHello(
-        sayHello_args request);
-
-  }
-
-  public static class GreeterFutureStub extends io.grpc.stub.AbstractStub<GreeterFutureStub>
-      implements GreeterFutureClient {
-    private GreeterFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private GreeterFutureStub(io.grpc.Channel channel, 
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected GreeterFutureStub build(io.grpc.Channel channel, 
-        io.grpc.CallOptions callOptions) {
-      return new GreeterFutureStub(channel, callOptions);
-    }
-
-    @java.lang.Override
-    public com.google.common.util.concurrent.ListenableFuture<sayHello_result> sayHello(
-        sayHello_args request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_sayHello, getCallOptions()), request);
-    }
-
-  }
-
-  private static final int METHODID_sayHello = 0;
-
-  private static class MethodHandlers<Req, Resp> implements
-      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final Greeter serviceImpl;
-    private final int methodId;
-
-    public MethodHandlers(Greeter serviceImpl, int methodId) {
-      this.serviceImpl = serviceImpl;
-      this.methodId = methodId;
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        case METHODID_sayHello:
-          serviceImpl.sayHello((sayHello_args) request,
-              (io.grpc.stub.StreamObserver<sayHello_result>) responseObserver);
-          break;
-
-        default:
-          throw new AssertionError();
-      }
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public io.grpc.stub.StreamObserver<Req> invoke(
-        io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        default:
-          throw new AssertionError();
-      }
-    }
-
-  }
-
-  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
-    return new io.grpc.ServiceDescriptor(SERVICE_NAME    ,
-        METHOD_sayHello);
-  }
-
-  @java.lang.Deprecated public static io.grpc.ServerServiceDefinition bindService(
-      final Greeter serviceImpl) {
-    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-        .addMethod(
-          METHOD_sayHello,
-          asyncUnaryCall(
-            new MethodHandlers<
-              sayHello_args,
-              sayHello_result>(
-                serviceImpl, METHODID_sayHello)))
-        .build();
-  }
-
-}
diff --git a/examples/thrift/src/generated/main/java/io/grpc/examples/thrift/helloworld/HelloRequest.java b/examples/thrift/src/generated/main/java/io/grpc/examples/thrift/helloworld/HelloRequest.java
deleted file mode 100644
index 8c4646586fa..00000000000
--- a/examples/thrift/src/generated/main/java/io/grpc/examples/thrift/helloworld/HelloRequest.java
+++ /dev/null
@@ -1,395 +0,0 @@
-/**
- * Autogenerated by Thrift Compiler (1.0.0-dev)
- *
- * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *  @generated
- */
-package io.grpc.examples.thrift.helloworld;
-
-import org.apache.thrift.scheme.IScheme;
-import org.apache.thrift.scheme.SchemeFactory;
-import org.apache.thrift.scheme.StandardScheme;
-
-import org.apache.thrift.scheme.TupleScheme;
-import org.apache.thrift.protocol.TTupleProtocol;
-import org.apache.thrift.protocol.TProtocolException;
-import org.apache.thrift.EncodingUtils;
-import org.apache.thrift.server.AbstractNonblockingServer.*;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.Map;
-import java.util.HashMap;
-import java.util.EnumMap;
-import java.util.Set;
-import java.util.HashSet;
-import java.util.EnumSet;
-import java.util.Collections;
-import java.util.BitSet;
-import java.nio.ByteBuffer;
-import java.util.Arrays;
-import javax.annotation.Generated;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
-@Generated(value = "Autogenerated by Thrift Compiler (1.0.0-dev)", date = "2016-07-21")
-public class HelloRequest implements org.apache.thrift.TBase<HelloRequest, HelloRequest._Fields>, java.io.Serializable, Cloneable, Comparable<HelloRequest> {
-  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("HelloRequest");
-
-  private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)1);
-
-  private static final SchemeFactory STANDARD_SCHEME_FACTORY = new HelloRequestStandardSchemeFactory();
-  private static final SchemeFactory TUPLE_SCHEME_FACTORY = new HelloRequestTupleSchemeFactory();
-
-  public String name; // required
-
-  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
-  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
-    NAME((short)1, "name");
-
-    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
-
-    static {
-      for (_Fields field : EnumSet.allOf(_Fields.class)) {
-        byName.put(field.getFieldName(), field);
-      }
-    }
-
-    /**
-     * Find the _Fields constant that matches fieldId, or null if its not found.
-     */
-    public static _Fields findByThriftId(int fieldId) {
-      switch(fieldId) {
-        case 1: // NAME
-          return NAME;
-        default:
-          return null;
-      }
-    }
-
-    /**
-     * Find the _Fields constant that matches fieldId, throwing an exception
-     * if it is not found.
-     */
-    public static _Fields findByThriftIdOrThrow(int fieldId) {
-      _Fields fields = findByThriftId(fieldId);
-      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
-      return fields;
-    }
-
-    /**
-     * Find the _Fields constant that matches name, or null if its not found.
-     */
-    public static _Fields findByName(String name) {
-      return byName.get(name);
-    }
-
-    private final short _thriftId;
-    private final String _fieldName;
-
-    _Fields(short thriftId, String fieldName) {
-      _thriftId = thriftId;
-      _fieldName = fieldName;
-    }
-
-    public short getThriftFieldId() {
-      return _thriftId;
-    }
-
-    public String getFieldName() {
-      return _fieldName;
-    }
-  }
-
-  // isset id assignments
-  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
-  static {
-    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
-    tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
-    metaDataMap = Collections.unmodifiableMap(tmpMap);
-    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(HelloRequest.class, metaDataMap);
-  }
-
-  public HelloRequest() {
-  }
-
-  public HelloRequest(
-    String name)
-  {
-    this();
-    this.name = name;
-  }
-
-  /**
-   * Performs a deep copy on <i>other</i>.
-   */
-  public HelloRequest(HelloRequest other) {
-    if (other.isSetName()) {
-      this.name = other.name;
-    }
-  }
-
-  public HelloRequest deepCopy() {
-    return new HelloRequest(this);
-  }
-
-  @Override
-  public void clear() {
-    this.name = null;
-  }
-
-  public String getName() {
-    return this.name;
-  }
-
-  public HelloRequest setName(String name) {
-    this.name = name;
-    return this;
-  }
-
-  public void unsetName() {
-    this.name = null;
-  }
-
-  /** Returns true if field name is set (has been assigned a value) and false otherwise */
-  public boolean isSetName() {
-    return this.name != null;
-  }
-
-  public void setNameIsSet(boolean value) {
-    if (!value) {
-      this.name = null;
-    }
-  }
-
-  public void setFieldValue(_Fields field, Object value) {
-    switch (field) {
-    case NAME:
-      if (value == null) {
-        unsetName();
-      } else {
-        setName((String)value);
-      }
-      break;
-
-    }
-  }
-
-  public Object getFieldValue(_Fields field) {
-    switch (field) {
-    case NAME:
-      return getName();
-
-    }
-    throw new IllegalStateException();
-  }
-
-  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
-  public boolean isSet(_Fields field) {
-    if (field == null) {
-      throw new IllegalArgumentException();
-    }
-
-    switch (field) {
-    case NAME:
-      return isSetName();
-    }
-    throw new IllegalStateException();
-  }
-
-  @Override
-  public boolean equals(Object that) {
-    if (that == null)
-      return false;
-    if (that instanceof HelloRequest)
-      return this.equals((HelloRequest)that);
-    return false;
-  }
-
-  public boolean equals(HelloRequest that) {
-    if (that == null)
-      return false;
-
-    boolean this_present_name = true && this.isSetName();
-    boolean that_present_name = true && that.isSetName();
-    if (this_present_name || that_present_name) {
-      if (!(this_present_name && that_present_name))
-        return false;
-      if (!this.name.equals(that.name))
-        return false;
-    }
-
-    return true;
-  }
-
-  @Override
-  public int hashCode() {
-    int hashCode = 1;
-
-    hashCode = hashCode * 8191 + ((isSetName()) ? 131071 : 524287);
-    if (isSetName())
-      hashCode = hashCode * 8191 + name.hashCode();
-
-    return hashCode;
-  }
-
-  @Override
-  public int compareTo(HelloRequest other) {
-    if (!getClass().equals(other.getClass())) {
-      return getClass().getName().compareTo(other.getClass().getName());
-    }
-
-    int lastComparison = 0;
-
-    lastComparison = Boolean.valueOf(isSetName()).compareTo(other.isSetName());
-    if (lastComparison != 0) {
-      return lastComparison;
-    }
-    if (isSetName()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, other.name);
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
-    }
-    return 0;
-  }
-
-  public _Fields fieldForId(int fieldId) {
-    return _Fields.findByThriftId(fieldId);
-  }
-
-  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
-    scheme(iprot).read(iprot, this);
-  }
-
-  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
-    scheme(oprot).write(oprot, this);
-  }
-
-  @Override
-  public String toString() {
-    StringBuilder sb = new StringBuilder("HelloRequest(");
-    boolean first = true;
-
-    sb.append("name:");
-    if (this.name == null) {
-      sb.append("null");
-    } else {
-      sb.append(this.name);
-    }
-    first = false;
-    sb.append(")");
-    return sb.toString();
-  }
-
-  public void validate() throws org.apache.thrift.TException {
-    // check for required fields
-    // check for sub-struct validity
-  }
-
-  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
-    try {
-      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
-    } catch (org.apache.thrift.TException te) {
-      throw new java.io.IOException(te);
-    }
-  }
-
-  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
-    try {
-      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
-    } catch (org.apache.thrift.TException te) {
-      throw new java.io.IOException(te);
-    }
-  }
-
-  private static class HelloRequestStandardSchemeFactory implements SchemeFactory {
-    public HelloRequestStandardScheme getScheme() {
-      return new HelloRequestStandardScheme();
-    }
-  }
-
-  private static class HelloRequestStandardScheme extends StandardScheme<HelloRequest> {
-
-    public void read(org.apache.thrift.protocol.TProtocol iprot, HelloRequest struct) throws org.apache.thrift.TException {
-      org.apache.thrift.protocol.TField schemeField;
-      iprot.readStructBegin();
-      while (true)
-      {
-        schemeField = iprot.readFieldBegin();
-        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
-          break;
-        }
-        switch (schemeField.id) {
-          case 1: // NAME
-            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
-              struct.name = iprot.readString();
-              struct.setNameIsSet(true);
-            } else { 
-              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
-            }
-            break;
-          default:
-            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
-        }
-        iprot.readFieldEnd();
-      }
-      iprot.readStructEnd();
-
-      // check for required fields of primitive type, which can't be checked in the validate method
-      struct.validate();
-    }
-
-    public void write(org.apache.thrift.protocol.TProtocol oprot, HelloRequest struct) throws org.apache.thrift.TException {
-      struct.validate();
-
-      oprot.writeStructBegin(STRUCT_DESC);
-      if (struct.name != null) {
-        oprot.writeFieldBegin(NAME_FIELD_DESC);
-        oprot.writeString(struct.name);
-        oprot.writeFieldEnd();
-      }
-      oprot.writeFieldStop();
-      oprot.writeStructEnd();
-    }
-
-  }
-
-  private static class HelloRequestTupleSchemeFactory implements SchemeFactory {
-    public HelloRequestTupleScheme getScheme() {
-      return new HelloRequestTupleScheme();
-    }
-  }
-
-  private static class HelloRequestTupleScheme extends TupleScheme<HelloRequest> {
-
-    @Override
-    public void write(org.apache.thrift.protocol.TProtocol prot, HelloRequest struct) throws org.apache.thrift.TException {
-      TTupleProtocol oprot = (TTupleProtocol) prot;
-      BitSet optionals = new BitSet();
-      if (struct.isSetName()) {
-        optionals.set(0);
-      }
-      oprot.writeBitSet(optionals, 1);
-      if (struct.isSetName()) {
-        oprot.writeString(struct.name);
-      }
-    }
-
-    @Override
-    public void read(org.apache.thrift.protocol.TProtocol prot, HelloRequest struct) throws org.apache.thrift.TException {
-      TTupleProtocol iprot = (TTupleProtocol) prot;
-      BitSet incoming = iprot.readBitSet(1);
-      if (incoming.get(0)) {
-        struct.name = iprot.readString();
-        struct.setNameIsSet(true);
-      }
-    }
-  }
-
-  private static <S extends IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
-    return (StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
-  }
-}
-
diff --git a/examples/thrift/src/generated/main/java/io/grpc/examples/thrift/helloworld/HelloResponse.java b/examples/thrift/src/generated/main/java/io/grpc/examples/thrift/helloworld/HelloResponse.java
deleted file mode 100644
index 17c295f3a05..00000000000
--- a/examples/thrift/src/generated/main/java/io/grpc/examples/thrift/helloworld/HelloResponse.java
+++ /dev/null
@@ -1,395 +0,0 @@
-/**
- * Autogenerated by Thrift Compiler (1.0.0-dev)
- *
- * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *  @generated
- */
-package io.grpc.examples.thrift.helloworld;
-
-import org.apache.thrift.scheme.IScheme;
-import org.apache.thrift.scheme.SchemeFactory;
-import org.apache.thrift.scheme.StandardScheme;
-
-import org.apache.thrift.scheme.TupleScheme;
-import org.apache.thrift.protocol.TTupleProtocol;
-import org.apache.thrift.protocol.TProtocolException;
-import org.apache.thrift.EncodingUtils;
-import org.apache.thrift.server.AbstractNonblockingServer.*;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.Map;
-import java.util.HashMap;
-import java.util.EnumMap;
-import java.util.Set;
-import java.util.HashSet;
-import java.util.EnumSet;
-import java.util.Collections;
-import java.util.BitSet;
-import java.nio.ByteBuffer;
-import java.util.Arrays;
-import javax.annotation.Generated;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
-@Generated(value = "Autogenerated by Thrift Compiler (1.0.0-dev)", date = "2016-07-21")
-public class HelloResponse implements org.apache.thrift.TBase<HelloResponse, HelloResponse._Fields>, java.io.Serializable, Cloneable, Comparable<HelloResponse> {
-  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("HelloResponse");
-
-  private static final org.apache.thrift.protocol.TField MESSAGE_FIELD_DESC = new org.apache.thrift.protocol.TField("message", org.apache.thrift.protocol.TType.STRING, (short)1);
-
-  private static final SchemeFactory STANDARD_SCHEME_FACTORY = new HelloResponseStandardSchemeFactory();
-  private static final SchemeFactory TUPLE_SCHEME_FACTORY = new HelloResponseTupleSchemeFactory();
-
-  public String message; // required
-
-  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
-  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
-    MESSAGE((short)1, "message");
-
-    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
-
-    static {
-      for (_Fields field : EnumSet.allOf(_Fields.class)) {
-        byName.put(field.getFieldName(), field);
-      }
-    }
-
-    /**
-     * Find the _Fields constant that matches fieldId, or null if its not found.
-     */
-    public static _Fields findByThriftId(int fieldId) {
-      switch(fieldId) {
-        case 1: // MESSAGE
-          return MESSAGE;
-        default:
-          return null;
-      }
-    }
-
-    /**
-     * Find the _Fields constant that matches fieldId, throwing an exception
-     * if it is not found.
-     */
-    public static _Fields findByThriftIdOrThrow(int fieldId) {
-      _Fields fields = findByThriftId(fieldId);
-      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
-      return fields;
-    }
-
-    /**
-     * Find the _Fields constant that matches name, or null if its not found.
-     */
-    public static _Fields findByName(String name) {
-      return byName.get(name);
-    }
-
-    private final short _thriftId;
-    private final String _fieldName;
-
-    _Fields(short thriftId, String fieldName) {
-      _thriftId = thriftId;
-      _fieldName = fieldName;
-    }
-
-    public short getThriftFieldId() {
-      return _thriftId;
-    }
-
-    public String getFieldName() {
-      return _fieldName;
-    }
-  }
-
-  // isset id assignments
-  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
-  static {
-    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
-    tmpMap.put(_Fields.MESSAGE, new org.apache.thrift.meta_data.FieldMetaData("message", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
-    metaDataMap = Collections.unmodifiableMap(tmpMap);
-    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(HelloResponse.class, metaDataMap);
-  }
-
-  public HelloResponse() {
-  }
-
-  public HelloResponse(
-    String message)
-  {
-    this();
-    this.message = message;
-  }
-
-  /**
-   * Performs a deep copy on <i>other</i>.
-   */
-  public HelloResponse(HelloResponse other) {
-    if (other.isSetMessage()) {
-      this.message = other.message;
-    }
-  }
-
-  public HelloResponse deepCopy() {
-    return new HelloResponse(this);
-  }
-
-  @Override
-  public void clear() {
-    this.message = null;
-  }
-
-  public String getMessage() {
-    return this.message;
-  }
-
-  public HelloResponse setMessage(String message) {
-    this.message = message;
-    return this;
-  }
-
-  public void unsetMessage() {
-    this.message = null;
-  }
-
-  /** Returns true if field message is set (has been assigned a value) and false otherwise */
-  public boolean isSetMessage() {
-    return this.message != null;
-  }
-
-  public void setMessageIsSet(boolean value) {
-    if (!value) {
-      this.message = null;
-    }
-  }
-
-  public void setFieldValue(_Fields field, Object value) {
-    switch (field) {
-    case MESSAGE:
-      if (value == null) {
-        unsetMessage();
-      } else {
-        setMessage((String)value);
-      }
-      break;
-
-    }
-  }
-
-  public Object getFieldValue(_Fields field) {
-    switch (field) {
-    case MESSAGE:
-      return getMessage();
-
-    }
-    throw new IllegalStateException();
-  }
-
-  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
-  public boolean isSet(_Fields field) {
-    if (field == null) {
-      throw new IllegalArgumentException();
-    }
-
-    switch (field) {
-    case MESSAGE:
-      return isSetMessage();
-    }
-    throw new IllegalStateException();
-  }
-
-  @Override
-  public boolean equals(Object that) {
-    if (that == null)
-      return false;
-    if (that instanceof HelloResponse)
-      return this.equals((HelloResponse)that);
-    return false;
-  }
-
-  public boolean equals(HelloResponse that) {
-    if (that == null)
-      return false;
-
-    boolean this_present_message = true && this.isSetMessage();
-    boolean that_present_message = true && that.isSetMessage();
-    if (this_present_message || that_present_message) {
-      if (!(this_present_message && that_present_message))
-        return false;
-      if (!this.message.equals(that.message))
-        return false;
-    }
-
-    return true;
-  }
-
-  @Override
-  public int hashCode() {
-    int hashCode = 1;
-
-    hashCode = hashCode * 8191 + ((isSetMessage()) ? 131071 : 524287);
-    if (isSetMessage())
-      hashCode = hashCode * 8191 + message.hashCode();
-
-    return hashCode;
-  }
-
-  @Override
-  public int compareTo(HelloResponse other) {
-    if (!getClass().equals(other.getClass())) {
-      return getClass().getName().compareTo(other.getClass().getName());
-    }
-
-    int lastComparison = 0;
-
-    lastComparison = Boolean.valueOf(isSetMessage()).compareTo(other.isSetMessage());
-    if (lastComparison != 0) {
-      return lastComparison;
-    }
-    if (isSetMessage()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.message, other.message);
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
-    }
-    return 0;
-  }
-
-  public _Fields fieldForId(int fieldId) {
-    return _Fields.findByThriftId(fieldId);
-  }
-
-  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
-    scheme(iprot).read(iprot, this);
-  }
-
-  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
-    scheme(oprot).write(oprot, this);
-  }
-
-  @Override
-  public String toString() {
-    StringBuilder sb = new StringBuilder("HelloResponse(");
-    boolean first = true;
-
-    sb.append("message:");
-    if (this.message == null) {
-      sb.append("null");
-    } else {
-      sb.append(this.message);
-    }
-    first = false;
-    sb.append(")");
-    return sb.toString();
-  }
-
-  public void validate() throws org.apache.thrift.TException {
-    // check for required fields
-    // check for sub-struct validity
-  }
-
-  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
-    try {
-      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
-    } catch (org.apache.thrift.TException te) {
-      throw new java.io.IOException(te);
-    }
-  }
-
-  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
-    try {
-      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
-    } catch (org.apache.thrift.TException te) {
-      throw new java.io.IOException(te);
-    }
-  }
-
-  private static class HelloResponseStandardSchemeFactory implements SchemeFactory {
-    public HelloResponseStandardScheme getScheme() {
-      return new HelloResponseStandardScheme();
-    }
-  }
-
-  private static class HelloResponseStandardScheme extends StandardScheme<HelloResponse> {
-
-    public void read(org.apache.thrift.protocol.TProtocol iprot, HelloResponse struct) throws org.apache.thrift.TException {
-      org.apache.thrift.protocol.TField schemeField;
-      iprot.readStructBegin();
-      while (true)
-      {
-        schemeField = iprot.readFieldBegin();
-        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
-          break;
-        }
-        switch (schemeField.id) {
-          case 1: // MESSAGE
-            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
-              struct.message = iprot.readString();
-              struct.setMessageIsSet(true);
-            } else { 
-              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
-            }
-            break;
-          default:
-            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
-        }
-        iprot.readFieldEnd();
-      }
-      iprot.readStructEnd();
-
-      // check for required fields of primitive type, which can't be checked in the validate method
-      struct.validate();
-    }
-
-    public void write(org.apache.thrift.protocol.TProtocol oprot, HelloResponse struct) throws org.apache.thrift.TException {
-      struct.validate();
-
-      oprot.writeStructBegin(STRUCT_DESC);
-      if (struct.message != null) {
-        oprot.writeFieldBegin(MESSAGE_FIELD_DESC);
-        oprot.writeString(struct.message);
-        oprot.writeFieldEnd();
-      }
-      oprot.writeFieldStop();
-      oprot.writeStructEnd();
-    }
-
-  }
-
-  private static class HelloResponseTupleSchemeFactory implements SchemeFactory {
-    public HelloResponseTupleScheme getScheme() {
-      return new HelloResponseTupleScheme();
-    }
-  }
-
-  private static class HelloResponseTupleScheme extends TupleScheme<HelloResponse> {
-
-    @Override
-    public void write(org.apache.thrift.protocol.TProtocol prot, HelloResponse struct) throws org.apache.thrift.TException {
-      TTupleProtocol oprot = (TTupleProtocol) prot;
-      BitSet optionals = new BitSet();
-      if (struct.isSetMessage()) {
-        optionals.set(0);
-      }
-      oprot.writeBitSet(optionals, 1);
-      if (struct.isSetMessage()) {
-        oprot.writeString(struct.message);
-      }
-    }
-
-    @Override
-    public void read(org.apache.thrift.protocol.TProtocol prot, HelloResponse struct) throws org.apache.thrift.TException {
-      TTupleProtocol iprot = (TTupleProtocol) prot;
-      BitSet incoming = iprot.readBitSet(1);
-      if (incoming.get(0)) {
-        struct.message = iprot.readString();
-        struct.setMessageIsSet(true);
-      }
-    }
-  }
-
-  private static <S extends IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
-    return (StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
-  }
-}
-
diff --git a/examples/thrift/src/main/java/io/grpc/examples/thrift/helloworld/HelloWorldClient.java b/examples/thrift/src/main/java/io/grpc/examples/thrift/helloworld/HelloWorldClient.java
deleted file mode 100644
index 5d89c43a78c..00000000000
--- a/examples/thrift/src/main/java/io/grpc/examples/thrift/helloworld/HelloWorldClient.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.examples.thrift.helloworld;
-
-import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
-import io.grpc.StatusRuntimeException;
-
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-/** Simple client that requests a greeting from {@link HelloWorldServer}. */
-public class HelloWorldClient {
-  private static final Logger logger = Logger.getLogger(HelloWorldClient.class.getName());
-
-  private final ManagedChannel channel;
-  private final GreeterGrpc.GreeterBlockingStub blockingStub;
-
-  public HelloWorldClient(String host, int port) {
-    channel = ManagedChannelBuilder.forAddress(host, port)
-        .usePlaintext(true)
-        .build();
-    blockingStub = GreeterGrpc.newBlockingStub(channel);
-  }
-
-  public void shutdown() throws InterruptedException {
-    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
-  }
-
-  /** Say Hello to Server. */
-  public void greet(String name) {
-    logger.info("Will try to greet " + name + " ...");
-    HelloRequest hellorequest = new HelloRequest(name);
-    GreeterGrpc.sayHello_args request = new GreeterGrpc.sayHello_args(hellorequest);
-
-    GreeterGrpc.sayHello_result response;
-    try {
-      response = blockingStub.sayHello(request);
-    } catch (StatusRuntimeException e) {
-      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
-      return;
-    }
-    logger.info("Greeting: " + response.success.message);
-  }
-
-  /** Greet Server. */
-  public static void main(String[] args) throws Exception {
-    HelloWorldClient client = new HelloWorldClient("localhost" , 50051);
-    try {
-      String user = "world";
-      if (args.length > 0) {
-        user = args[0];
-      }
-      client.greet(user);
-    } finally {
-      client.shutdown();
-    }
-  }
-}
\ No newline at end of file
diff --git a/examples/thrift/src/main/java/io/grpc/examples/thrift/helloworld/HelloWorldServer.java b/examples/thrift/src/main/java/io/grpc/examples/thrift/helloworld/HelloWorldServer.java
deleted file mode 100644
index 48da768ae5b..00000000000
--- a/examples/thrift/src/main/java/io/grpc/examples/thrift/helloworld/HelloWorldServer.java
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.examples.thrift.helloworld;
-
-import io.grpc.Server;
-import io.grpc.ServerBuilder;
-import io.grpc.stub.StreamObserver;
-
-import java.io.IOException;
-import java.util.logging.Logger;
-
-/** Server that manages startup/ shutdown of a Greeter server. */
-public class HelloWorldServer {
-  private static final Logger logger = Logger.getLogger(HelloWorldServer.class.getName());
-
-  /** Port on which the server should run. */
-  private int port = 50051;
-  private Server server;
-
-  private void start() throws IOException {
-    server = ServerBuilder.forPort(port)
-        .addService(new GreeterImpl())
-        .build()
-        .start();
-    logger.info("Server started, listening on "+ port);
-    Runtime.getRuntime().addShutdownHook(new Thread() {
-      @Override
-      public void run() {
-        System.err.println("*** Shutting down gRPC server since JVM is shutting down");
-        HelloWorldServer.this.stop();
-        System.err.println("*** Server shut down");
-      }
-    });
-  }
-
-  private void stop() {
-    if (server != null) {
-      server.shutdown();
-    }
-  }
-
-  private void blockUntilShutdown() throws InterruptedException {
-    if (server != null) {
-      server.awaitTermination();
-    }
-  }
-
-  /** Main function to launch server from cmd. */
-  public static void main(String[] args) throws IOException, InterruptedException {
-    final HelloWorldServer server = new HelloWorldServer();
-    server.start();
-    server.blockUntilShutdown();
-  }
-
-  private class GreeterImpl extends GreeterGrpc.GreeterImplBase {
-    @Override
-    public void sayHello(GreeterGrpc.sayHello_args req, StreamObserver<GreeterGrpc.sayHello_result> responseObserver) {
-      GreeterGrpc.sayHello_result reply = new GreeterGrpc.sayHello_result();
-      reply.success = new HelloResponse("Hello " + req.request.name);
-      responseObserver.onNext(reply);
-      responseObserver.onCompleted();
-    }
-  } 
-}
\ No newline at end of file
diff --git a/examples/thrift/src/main/thrift/helloworld.thrift b/examples/thrift/src/main/thrift/helloworld.thrift
deleted file mode 100644
index a042e563ea3..00000000000
--- a/examples/thrift/src/main/thrift/helloworld.thrift
+++ /dev/null
@@ -1,13 +0,0 @@
-namespace java io.grpc.examples.thrift.helloworld
-
-struct HelloRequest {
-	1:string name
-}
-
-struct HelloResponse {
-	1:string message
-}
-
-service Greeter {
-	HelloResponse sayHello(1:HelloRequest request);
-}
diff --git a/gae-interop-testing/README.md b/gae-interop-testing/README.md
new file mode 100644
index 00000000000..d7925822522
--- /dev/null
+++ b/gae-interop-testing/README.md
@@ -0,0 +1,48 @@
+Google App Engine interop tests
+=====================================
+
+This directory contains interop tests that runs in Google App Engine
+as gRPC clients.
+
+Prerequisites
+==========================
+
+- Install the Google Cloud SDK and ensure that `gcloud` is in the path
+- Set up an [App Engine app](https://appengine.google.com) with your
+  choice of a PROJECT_ID.
+- Associate your `gcloud` environment with your app:
+  ```bash
+  # Log into Google Cloud
+  $ gcloud auth login
+
+  # Associate this codebase with a GAE project
+  $ gcloud config set project PROJECT_ID
+  ```
+
+Running the tests in GAE
+==========================
+
+You can run the gradle task to execute the interop tests.
+```bash
+# cd into gae-jdk8
+$ ../../gradlew runInteropTestRemote
+
+# Or run one of these from the root gRPC Java directory:
+$ ./gradlew :grpc-gae-interop-testing-jdk8:runInteropTestRemote
+```
+
+Optional:
+
+You can also browse to `http://${PROJECT_ID}.appspot.google.com` to
+see the result of the interop test.
+
+
+Debugging
+==========================
+
+You can find the server side logs by logging into
+`http://appengine.google.com` and scrolling down to the section titled
+`Application Errors` and `Server Errors`.
+
+Click on the `/` URI to view the log entries for each test run.
+
diff --git a/gae-interop-testing/gae-jdk8/build.gradle b/gae-interop-testing/gae-jdk8/build.gradle
new file mode 100644
index 00000000000..07033f403de
--- /dev/null
+++ b/gae-interop-testing/gae-jdk8/build.gradle
@@ -0,0 +1,161 @@
+// Copyright 2017 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.
+
+buildscript {
+    // Configuration for building
+    dependencies {
+        classpath 'com.squareup.okhttp:okhttp:2.7.4'
+    }
+}
+
+plugins {
+    id "java"
+    id "war"
+
+    id "ru.vyarus.animalsniffer"
+    id 'com.google.cloud.tools.appengine'
+}
+
+description = 'gRPC: gae interop testing (jdk8)'
+
+dependencies {
+    providedCompile group: 'javax.servlet', name: 'servlet-api', version:'2.5'
+    runtimeOnly 'com.google.appengine:appengine-api-1.0-sdk:1.9.59'
+    implementation project(':grpc-netty')
+    implementation project(":grpc-stub")
+    implementation (project(':grpc-interop-testing')) {
+        // Avoid grpc-netty-shaded dependency
+        exclude group: 'io.grpc', module: 'grpc-alts'
+        exclude group: 'io.grpc', module: 'grpc-xds'
+    }
+    implementation libraries.junit
+    implementation libraries.protobuf.java
+    runtimeOnly libraries.netty.tcnative, libraries.netty.tcnative.classes
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+tasks.named("compileJava").configure {
+    // Disable "No processor claimed any of these annotations: org.junit.Ignore"
+    options.compilerArgs += ["-Xlint:-processing"]
+}
+
+def createDefaultVersion() {
+    return new java.text.SimpleDateFormat("yyyyMMdd't'HHmmss").format(new Date())
+}
+
+def nonShadowedProject = project
+// [START model]
+appengine {
+    // App Engine tasks configuration
+    run {      // local (dev_appserver) configuration (standard environments only)
+        port = 8080                 // default
+    }
+
+    deploy {
+        // deploy configuration
+        projectId = nonShadowedProject.findProperty('gaeProjectId') ?: 'GCLOUD_CONFIG'
+        // default - stop the current version
+        stopPreviousVersion = nonShadowedProject.findProperty('gaeStopPreviousVersion') ?: true
+        // default - do not make this the promoted version
+        promote = nonShadowedProject.findProperty('gaePromote') ?: false
+        // Use -PgaeDeployVersion if set, otherwise the version is null and the plugin will generate it
+        version = nonShadowedProject.findProperty('gaeDeployVersion') ?: createDefaultVersion()
+    }
+}
+// [END model]
+
+group = 'io.grpc'   // Generated output GroupId
+version = '1.0-SNAPSHOT'          // Version in generated output
+
+/** Returns the service name. */
+String getGaeProject() {
+    def configuredProjectId = appengine.deploy.projectId
+    if (!"GCLOUD_CONFIG".equals(configuredProjectId)) {
+        return configuredProjectId
+    }
+    def stream = new ByteArrayOutputStream()
+    exec {
+        executable 'gcloud'
+        args = [
+            'config',
+            'get-value',
+            'project'
+        ]
+        standardOutput = stream
+    }
+    return stream.toString().trim()
+}
+
+String getService(java.nio.file.Path projectPath) {
+    Node xml = new XmlParser().parse(projectPath.resolve("src/main/webapp/WEB-INF/appengine-web.xml").toFile())
+    if (xml.service.isEmpty()) {
+        return "default"
+    } else {
+        return xml.service.text()
+    }
+}
+
+String getAppUrl(String project, String service, String version) {
+    return "http://${version}.${service}.${project}.appspot.com"
+}
+
+tasks.register("runInteropTestRemote") {
+    mustRunAfter appengineDeploy
+    doLast {
+        def appUrl = getAppUrl(
+                getGaeProject(),
+                getService(project.getProjectDir().toPath()),
+                appengine.deploy.version)
+        logger.log(LogLevel.INFO, "the appURL=" + appUrl)
+        def client = new com.squareup.okhttp.OkHttpClient()
+        // The '?jdk8' argument is ignored by the server, it exists only to tag the request log entry
+        client.setReadTimeout(30, java.util.concurrent.TimeUnit.SECONDS)
+        def request = new com.squareup.okhttp.Request.Builder()
+                .url("${appUrl}/long_lived_channel?jdk8").build()
+        def result1 = client.newCall(request).execute()
+        def result2 = client.newCall(request).execute()
+        if (result1.code() != 200 || result2.code() != 200) {
+            throw new GradleException("Unable to reuse same channel across requests")
+        }
+
+        // The test suite can take a while to run
+        client.setReadTimeout(3, java.util.concurrent.TimeUnit.MINUTES)
+        // The '?jdk8' argument is ignored by the server, it exists only to tag the request log entry
+        def interopRequest = new com.squareup.okhttp.Request.Builder()
+                .url("${appUrl}/?jdk8").build()
+
+        // Retry in case GAE is slow and times out
+        int maxRetries = 5
+        String result = null
+        Throwable caught = null
+        for (int attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                def response = client.newCall(interopRequest).execute()
+                result = response.body().string()
+                project.println(result)
+                if (response.code() == 200) {
+                    return
+                }
+            } catch (Throwable t) {
+                caught = t
+                logger.log(LogLevel.ERROR, "caught exception. will retry if possible", t)
+            }
+        }
+        throw new GradleException("Interop test failed:\nthrowable:${caught}")
+    }
+}
diff --git a/gae-interop-testing/gae-jdk8/src/main/java/io/grpc/testing/integration/LongLivedChannel.java b/gae-interop-testing/gae-jdk8/src/main/java/io/grpc/testing/integration/LongLivedChannel.java
new file mode 100644
index 00000000000..90e56c198b4
--- /dev/null
+++ b/gae-interop-testing/gae-jdk8/src/main/java/io/grpc/testing/integration/LongLivedChannel.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2017 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.testing.integration;
+
+import com.google.protobuf.ByteString;
+import io.grpc.Grpc;
+import io.grpc.ManagedChannel;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.testing.integration.Messages.Payload;
+import io.grpc.testing.integration.Messages.SimpleRequest;
+import io.grpc.testing.integration.Messages.SimpleResponse;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * A test class that checks we can reuse a channel across requests.
+ *
+ * <p>This servlet communicates with {@code grpc-test.sandbox.googleapis.com}, which is a server
+ * managed by the gRPC team. For more information, see
+ * <a href="https://github.com/grpc/grpc/blob/master/doc/interop-test-descriptions.md">
+ *   Interoperability Test Case Descriptions</a>.
+ */
+@SuppressWarnings("serial")
+public final class LongLivedChannel extends HttpServlet {
+  private static final String INTEROP_TEST_ADDRESS = "grpc-test.sandbox.googleapis.com:443";
+  private final ManagedChannel channel =
+      Grpc.newChannelBuilder(INTEROP_TEST_ADDRESS, TlsChannelCredentials.create()).build();
+
+  @Override
+  public void destroy() {
+    try {
+      channel.shutdownNow().awaitTermination(1, TimeUnit.SECONDS);
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Override
+  public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+    int requestSize = 1234;
+    int responseSize = 5678;
+    SimpleRequest request = SimpleRequest.newBuilder()
+        .setResponseSize(responseSize)
+        .setPayload(Payload.newBuilder()
+            .setBody(ByteString.copyFrom(new byte[requestSize])))
+        .build();
+    TestServiceGrpc.TestServiceBlockingStub blockingStub =
+            TestServiceGrpc.newBlockingStub(channel);
+    SimpleResponse simpleResponse = blockingStub.unaryCall(request);
+    resp.setContentType("text/plain");
+    if (simpleResponse.getPayload().getBody().size() == responseSize) {
+      resp.setStatus(200);
+      resp.getWriter().println("PASS!");
+    } else {
+      resp.setStatus(500);
+      resp.getWriter().println("FAILED!");
+    }
+  }
+}
diff --git a/gae-interop-testing/gae-jdk8/src/main/java/io/grpc/testing/integration/NettyClientInteropServlet.java b/gae-interop-testing/gae-jdk8/src/main/java/io/grpc/testing/integration/NettyClientInteropServlet.java
new file mode 100644
index 00000000000..5a388d27ce9
--- /dev/null
+++ b/gae-interop-testing/gae-jdk8/src/main/java/io/grpc/testing/integration/NettyClientInteropServlet.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright 2017 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.testing.integration;
+
+import io.grpc.Grpc;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.netty.NettyChannelBuilder;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Locale;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import java.util.logging.SimpleFormatter;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import org.junit.Ignore;
+import org.junit.runner.JUnitCore;
+import org.junit.runner.Result;
+import org.junit.runner.notification.Failure;
+
+/**
+ * This servlet communicates with {@code grpc-test.sandbox.googleapis.com}, which is a server
+ * managed by the gRPC team. For more information, see
+ * <a href="https://github.com/grpc/grpc/blob/master/doc/interop-test-descriptions.md">
+ *   Interoperability Test Case Descriptions</a>.
+ */
+@SuppressWarnings("serial")
+public final class NettyClientInteropServlet extends HttpServlet {
+  private static final String INTEROP_TEST_ADDRESS = "grpc-test.sandbox.googleapis.com:443";
+
+  private static final class LogEntryRecorder extends Handler {
+    private Queue<LogRecord> loggedMessages = new ConcurrentLinkedQueue<>();
+
+    @Override
+    public void publish(LogRecord logRecord) {
+      loggedMessages.add(logRecord);
+    }
+
+    @Override
+    public void flush() {}
+
+    @Override
+    public void close() {}
+
+    public String getLogOutput() {
+      SimpleFormatter formatter = new SimpleFormatter();
+      StringBuilder sb = new StringBuilder();
+      for (LogRecord loggedMessage : loggedMessages) {
+        sb.append(formatter.format(loggedMessage));
+      }
+      return sb.toString();
+    }
+  }
+
+  @Override
+  public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+    LogEntryRecorder handler = new LogEntryRecorder();
+    Logger.getLogger("").addHandler(handler);
+    try {
+      doGetHelper(resp);
+    } finally {
+      Logger.getLogger("").removeHandler(handler);
+    }
+    resp.getWriter().append("=======================================\n")
+        .append("Server side java.util.logging messages:\n")
+        .append(handler.getLogOutput());
+  }
+
+  private void doGetHelper(HttpServletResponse resp) throws IOException {
+    resp.setContentType("text/plain");
+    PrintWriter writer = resp.getWriter();
+    writer.println("Test invoked at: ");
+    writer.println(new SimpleDateFormat("yyyy/MM/dd HH:mm:ss Z")
+        .format(Calendar.getInstance().getTime()));
+
+    Result result = new JUnitCore().run(Tester.class);
+    if (result.wasSuccessful()) {
+      resp.setStatus(200);
+      writer.println(
+          String.format(
+              Locale.US,
+              "PASS! Tests ran %d, tests ignored %d",
+              result.getRunCount(),
+              result.getIgnoreCount()));
+    } else {
+      resp.setStatus(500);
+      writer.println(
+          String.format(
+              Locale.US,
+              "FAILED! Tests ran %d, tests failed %d, tests ignored %d",
+              result.getRunCount(),
+              result.getFailureCount(),
+              result.getIgnoreCount()));
+      for (Failure failure : result.getFailures()) {
+        writer.println("================================");
+        writer.println(failure.getTestHeader());
+        Throwable thrown = failure.getException();
+        StringWriter stringWriter = new StringWriter();
+        PrintWriter printWriter = new PrintWriter(stringWriter);
+        thrown.printStackTrace(printWriter);
+        writer.println(stringWriter);
+      }
+    }
+  }
+
+  public static final class Tester extends AbstractInteropTest {
+    @Override
+    protected ManagedChannelBuilder<?> createChannelBuilder() {
+      ManagedChannelBuilder<?> builder =
+          Grpc.newChannelBuilder(INTEROP_TEST_ADDRESS, TlsChannelCredentials.create())
+              .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
+      ((NettyChannelBuilder) builder)
+          .flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW);
+      return builder;
+    }
+
+    @Override
+    protected boolean metricsExpected() {
+      // Server-side metrics won't be found because the server is running remotely.
+      return false;
+    }
+
+    // grpc-test.sandbox.googleapis.com does not support these tests
+    @Ignore
+    @Override
+    public void customMetadata() { }
+
+    @Ignore
+    @Override
+    public void statusCodeAndMessage() { }
+
+    @Ignore
+    @Override
+    public void exchangeMetadataUnaryCall() { }
+
+    @Ignore
+    @Override
+    public void exchangeMetadataStreamingCall() { }
+
+    @Ignore
+    @Override
+    public void specialStatusMessage() {}
+  }
+}
diff --git a/gae-interop-testing/gae-jdk8/src/main/webapp/WEB-INF/appengine-web.xml b/gae-interop-testing/gae-jdk8/src/main/webapp/WEB-INF/appengine-web.xml
new file mode 100644
index 00000000000..715906ada47
--- /dev/null
+++ b/gae-interop-testing/gae-jdk8/src/main/webapp/WEB-INF/appengine-web.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Copyright 2017 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.
+-->
+<!-- [START config] -->
+<appengine-web-app xmlns='http://appengine.google.com/ns/1.0'>
+  <service>java-gae-interop-test</service>
+  <runtime>java17</runtime>
+</appengine-web-app>
+<!-- [END config] -->
diff --git a/gae-interop-testing/gae-jdk8/src/main/webapp/WEB-INF/web.xml b/gae-interop-testing/gae-jdk8/src/main/webapp/WEB-INF/web.xml
new file mode 100644
index 00000000000..2d825eb025e
--- /dev/null
+++ b/gae-interop-testing/gae-jdk8/src/main/webapp/WEB-INF/web.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"
+  xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
+  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
+  version="2.5">
+  <servlet>
+    <servlet-name>interoptest</servlet-name>
+    <servlet-class>io.grpc.testing.integration.NettyClientInteropServlet</servlet-class>
+  </servlet>
+  <servlet>
+    <servlet-name>longlivedchannel</servlet-name>
+    <servlet-class>io.grpc.testing.integration.LongLivedChannel</servlet-class>
+  </servlet>
+  <servlet-mapping>
+    <servlet-name>interoptest</servlet-name>
+    <url-pattern>/</url-pattern>
+  </servlet-mapping>
+  <servlet-mapping>
+    <servlet-name>longlivedchannel</servlet-name>
+    <url-pattern>/long_lived_channel</url-pattern>
+  </servlet-mapping>
+</web-app>
diff --git a/gcp-csm-observability/build.gradle b/gcp-csm-observability/build.gradle
new file mode 100644
index 00000000000..bda54ca8146
--- /dev/null
+++ b/gcp-csm-observability/build.gradle
@@ -0,0 +1,36 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "ru.vyarus.animalsniffer"
+}
+
+description = "gRPC: GCP CSM Observability"
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.gcp.csm.observability')
+    }
+}
+
+dependencies {
+    implementation project(':grpc-api'),
+            project(':grpc-core'),
+            project(':grpc-opentelemetry'),
+            project(':grpc-protobuf'),
+            project(path: ':grpc-xds', configuration: 'shadow'),
+            libraries.guava.jre, // jre version pulled in via xds
+            libraries.protobuf.java,
+            libraries.opentelemetry.gcp.resources,
+            libraries.opentelemetry.sdk.extension.autoconfigure // opentelemetry.gcp.resources uses compileOnly for this dep
+    testImplementation project(":grpc-testing"),
+            project(":grpc-inprocess"),
+            libraries.opentelemetry.sdk.testing,
+            libraries.assertj.core // opentelemetry.sdk.testing uses compileOnly for this dep
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
diff --git a/gcp-csm-observability/src/main/java/io/grpc/gcp/csm/observability/CsmObservability.java b/gcp-csm-observability/src/main/java/io/grpc/gcp/csm/observability/CsmObservability.java
new file mode 100644
index 00000000000..c345fb35d0a
--- /dev/null
+++ b/gcp-csm-observability/src/main/java/io/grpc/gcp/csm/observability/CsmObservability.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright 2024 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.gcp.csm.observability;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.ExperimentalApi;
+import io.grpc.InternalConfigurator;
+import io.grpc.InternalConfiguratorRegistry;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.ServerBuilder;
+import io.grpc.opentelemetry.GrpcOpenTelemetry;
+import io.grpc.opentelemetry.InternalGrpcOpenTelemetry;
+import io.opentelemetry.api.OpenTelemetry;
+import java.io.Closeable;
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * The entrypoint for GCP's CSM OpenTelemetry metrics functionality in gRPC.
+ *
+ * <p>CsmObservability uses {@link io.opentelemetry.api.OpenTelemetry} APIs for instrumentation.
+ * When no SDK is explicitly added no telemetry data will be collected. See
+ * {@code io.opentelemetry.sdk.OpenTelemetrySdk} for information on how to construct the SDK.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/11249")
+public final class CsmObservability implements Closeable {
+  private final GrpcOpenTelemetry delegate;
+  private final MetadataExchanger exchanger;
+
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  private CsmObservability(Builder builder) {
+    this.delegate = builder.delegate.build();
+    this.exchanger = builder.exchanger;
+  }
+
+  /**
+   * Registers CsmObservability globally, applying its configuration to all subsequently created
+   * gRPC channels and servers.
+   *
+   * <p>Note: Only one of CsmObservability and GrpcOpenTelemetry instance can be registered
+   * globally. Any subsequent call to {@code registerGlobal()} will throw an {@code
+   * IllegalStateException}.
+   */
+  public void registerGlobal() {
+    InternalConfiguratorRegistry.setConfigurators(Collections.singletonList(
+        new InternalConfigurator() {
+          @Override
+          public void configureChannelBuilder(ManagedChannelBuilder<?> channelBuilder) {
+            CsmObservability.this.configureChannelBuilder(channelBuilder);
+          }
+
+          @Override
+          public void configureServerBuilder(ServerBuilder<?> serverBuilder) {
+            CsmObservability.this.configureServerBuilder(serverBuilder);
+          }
+        }));
+  }
+
+  @VisibleForTesting
+  void configureChannelBuilder(ManagedChannelBuilder<?> builder) {
+    delegate.configureChannelBuilder(builder);
+  }
+
+  @VisibleForTesting
+  void configureServerBuilder(ServerBuilder<?> serverBuilder) {
+    delegate.configureServerBuilder(serverBuilder);
+    exchanger.configureServerBuilder(serverBuilder);
+  }
+
+  @Override
+  public void close() {}
+
+  /**
+   * Builder for configuring {@link CsmObservability}.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11249")
+  public static final class Builder {
+    private final GrpcOpenTelemetry.Builder delegate = GrpcOpenTelemetry.newBuilder();
+    private final MetadataExchanger exchanger;
+
+    private Builder() {
+      this(new MetadataExchanger());
+    }
+
+    @VisibleForTesting
+    Builder(MetadataExchanger exchanger) {
+      this.exchanger = exchanger;
+      InternalGrpcOpenTelemetry.builderPlugin(delegate, exchanger);
+    }
+
+    /**
+     * Sets the {@link io.opentelemetry.api.OpenTelemetry} entrypoint to use. This can be used to
+     * configure OpenTelemetry by returning the instance created by a
+     * {@code io.opentelemetry.sdk.OpenTelemetrySdkBuilder}.
+     */
+    public Builder sdk(OpenTelemetry sdk) {
+      delegate.sdk(sdk);
+      return this;
+    }
+
+    /**
+     * Adds optionalLabelKey to all the metrics that can provide value for the
+     * optionalLabelKey.
+     */
+    public Builder addOptionalLabel(String optionalLabelKey) {
+      delegate.addOptionalLabel(optionalLabelKey);
+      return this;
+    }
+
+    /**
+     * Enables the specified metrics for collection and export. By default, only a subset of
+     * metrics are enabled.
+     */
+    public Builder enableMetrics(Collection<String> enableMetrics) {
+      delegate.enableMetrics(enableMetrics);
+      return this;
+    }
+
+    /**
+     * Disables the specified metrics from being collected and exported.
+     */
+    public Builder disableMetrics(Collection<String> disableMetrics) {
+      delegate.disableMetrics(disableMetrics);
+      return this;
+    }
+
+    /**
+     * Disable all metrics. If set to true all metrics must be explicitly enabled.
+     */
+    public Builder disableAllMetrics() {
+      delegate.disableAllMetrics();
+      return this;
+    }
+
+    /**
+     * Returns a new {@link CsmObservability} built with the configuration of this {@link
+     * Builder}.
+     */
+    public CsmObservability build() {
+      return new CsmObservability(this);
+    }
+  }
+}
diff --git a/gcp-csm-observability/src/main/java/io/grpc/gcp/csm/observability/MetadataExchanger.java b/gcp-csm-observability/src/main/java/io/grpc/gcp/csm/observability/MetadataExchanger.java
new file mode 100644
index 00000000000..5f05d52c7e7
--- /dev/null
+++ b/gcp-csm-observability/src/main/java/io/grpc/gcp/csm/observability/MetadataExchanger.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright 2024 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.gcp.csm.observability;
+
+import com.google.common.base.Preconditions;
+import com.google.common.io.BaseEncoding;
+import com.google.protobuf.Struct;
+import com.google.protobuf.Value;
+import io.grpc.CallOptions;
+import io.grpc.ForwardingServerCall.SimpleForwardingServerCall;
+import io.grpc.Metadata;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.Status;
+import io.grpc.opentelemetry.InternalOpenTelemetryPlugin;
+import io.grpc.protobuf.ProtoUtils;
+import io.grpc.xds.ClusterImplLoadBalancerProvider;
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.common.AttributesBuilder;
+import io.opentelemetry.contrib.gcp.resource.GCPResourceProvider;
+import io.opentelemetry.sdk.autoconfigure.ResourceConfiguration;
+import java.net.URI;
+import java.util.Map;
+import java.util.function.Consumer;
+
+/**
+ * OpenTelemetryPlugin implementing metadata-based workload property exchange for both client and
+ * server. Is responsible for determining the metadata, communicating the metadata, and adding local
+ * and remote details to metrics.
+ */
+final class MetadataExchanger implements InternalOpenTelemetryPlugin {
+
+  private static final AttributeKey<String> CLOUD_PLATFORM =
+      AttributeKey.stringKey("cloud.platform");
+  private static final AttributeKey<String> K8S_NAMESPACE_NAME =
+      AttributeKey.stringKey("k8s.namespace.name");
+  private static final AttributeKey<String> K8S_CLUSTER_NAME =
+      AttributeKey.stringKey("k8s.cluster.name");
+  private static final AttributeKey<String> CLOUD_AVAILABILITY_ZONE =
+      AttributeKey.stringKey("cloud.availability_zone");
+  private static final AttributeKey<String> CLOUD_REGION =
+      AttributeKey.stringKey("cloud.region");
+  private static final AttributeKey<String> CLOUD_ACCOUNT_ID =
+      AttributeKey.stringKey("cloud.account.id");
+
+  private static final Metadata.Key<String> SEND_KEY =
+      Metadata.Key.of("x-envoy-peer-metadata", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<Struct> RECV_KEY =
+      Metadata.Key.of("x-envoy-peer-metadata", new BinaryToAsciiMarshaller<>(
+          ProtoUtils.metadataMarshaller(Struct.getDefaultInstance())));
+
+  private static final String EXCHANGE_TYPE = "type";
+  private static final String EXCHANGE_CANONICAL_SERVICE = "canonical_service";
+  private static final String EXCHANGE_PROJECT_ID = "project_id";
+  private static final String EXCHANGE_LOCATION = "location";
+  private static final String EXCHANGE_CLUSTER_NAME = "cluster_name";
+  private static final String EXCHANGE_NAMESPACE_NAME = "namespace_name";
+  private static final String EXCHANGE_WORKLOAD_NAME = "workload_name";
+  private static final String TYPE_GKE = "gcp_kubernetes_engine";
+  private static final String TYPE_GCE = "gcp_compute_engine";
+
+  private final String localMetadata;
+  private final Attributes localAttributes;
+
+  public MetadataExchanger() {
+    this(
+        addOtelResourceAttributes(new GCPResourceProvider().getAttributes()),
+        System::getenv);
+  }
+
+  MetadataExchanger(Attributes platformAttributes, Lookup env) {
+    String type = platformAttributes.get(CLOUD_PLATFORM);
+    String canonicalService = env.get("CSM_CANONICAL_SERVICE_NAME");
+    Struct.Builder struct = Struct.newBuilder();
+    put(struct, EXCHANGE_TYPE, type);
+    put(struct, EXCHANGE_CANONICAL_SERVICE, canonicalService);
+    if (TYPE_GKE.equals(type)) {
+      String location = platformAttributes.get(CLOUD_AVAILABILITY_ZONE);
+      if (location == null) {
+        location = platformAttributes.get(CLOUD_REGION);
+      }
+      put(struct, EXCHANGE_WORKLOAD_NAME,  env.get("CSM_WORKLOAD_NAME"));
+      put(struct, EXCHANGE_NAMESPACE_NAME, platformAttributes.get(K8S_NAMESPACE_NAME));
+      put(struct, EXCHANGE_CLUSTER_NAME,   platformAttributes.get(K8S_CLUSTER_NAME));
+      put(struct, EXCHANGE_LOCATION,       location);
+      put(struct, EXCHANGE_PROJECT_ID,     platformAttributes.get(CLOUD_ACCOUNT_ID));
+    } else if (TYPE_GCE.equals(type)) {
+      String location = platformAttributes.get(CLOUD_AVAILABILITY_ZONE);
+      if (location == null) {
+        location = platformAttributes.get(CLOUD_REGION);
+      }
+      put(struct, EXCHANGE_WORKLOAD_NAME, env.get("CSM_WORKLOAD_NAME"));
+      put(struct, EXCHANGE_LOCATION,      location);
+      put(struct, EXCHANGE_PROJECT_ID,    platformAttributes.get(CLOUD_ACCOUNT_ID));
+    }
+    localMetadata = BaseEncoding.base64().encode(struct.build().toByteArray());
+
+    localAttributes = Attributes.builder()
+        .put("csm.mesh_id", nullIsUnknown(env.get("CSM_MESH_ID")))
+        .put("csm.workload_canonical_service", nullIsUnknown(canonicalService))
+        .build();
+  }
+
+  private static String nullIsUnknown(String value) {
+    return value == null ? "unknown" : value;
+  }
+
+  private static void put(Struct.Builder struct, String key, String value) {
+    value = nullIsUnknown(value);
+    struct.putFields(key, Value.newBuilder().setStringValue(value).build());
+  }
+
+  private static void put(AttributesBuilder attributes, String key, Value value) {
+    attributes.put(key, nullIsUnknown(fromValue(value)));
+  }
+
+  private static String fromValue(Value value) {
+    if (value == null) {
+      return null;
+    }
+    if (value.getKindCase() != Value.KindCase.STRING_VALUE) {
+      return null;
+    }
+    return value.getStringValue();
+  }
+
+  private static Attributes addOtelResourceAttributes(Attributes platformAttributes) {
+    // Can't inject env variables as ResourceConfiguration requires the large ConfigProperties API
+    // to inject our own values and a default implementation isn't provided. So this reads directly
+    // from System.getenv().
+    Attributes envAttributes = ResourceConfiguration
+        .createEnvironmentResource()
+        .getAttributes();
+
+    AttributesBuilder builder = platformAttributes.toBuilder();
+    builder.putAll(envAttributes);
+    return builder.build();
+  }
+
+  private void addLabels(AttributesBuilder to, Struct struct) {
+    to.putAll(localAttributes);
+    Map<String, Value> remote = struct.getFieldsMap();
+    Value typeValue = remote.get(EXCHANGE_TYPE);
+    String type = fromValue(typeValue);
+    put(to, "csm.remote_workload_type", typeValue);
+    put(to, "csm.remote_workload_canonical_service", remote.get(EXCHANGE_CANONICAL_SERVICE));
+    if (TYPE_GKE.equals(type)) {
+      put(to, "csm.remote_workload_project_id",     remote.get(EXCHANGE_PROJECT_ID));
+      put(to, "csm.remote_workload_location",       remote.get(EXCHANGE_LOCATION));
+      put(to, "csm.remote_workload_cluster_name",   remote.get(EXCHANGE_CLUSTER_NAME));
+      put(to, "csm.remote_workload_namespace_name", remote.get(EXCHANGE_NAMESPACE_NAME));
+      put(to, "csm.remote_workload_name",           remote.get(EXCHANGE_WORKLOAD_NAME));
+    } else if (TYPE_GCE.equals(type)) {
+      put(to, "csm.remote_workload_project_id",     remote.get(EXCHANGE_PROJECT_ID));
+      put(to, "csm.remote_workload_location",       remote.get(EXCHANGE_LOCATION));
+      put(to, "csm.remote_workload_name",           remote.get(EXCHANGE_WORKLOAD_NAME));
+    }
+  }
+
+  @Override
+  public boolean enablePluginForChannel(String target) {
+    URI uri;
+    try {
+      uri = new URI(target);
+    } catch (Exception ex) {
+      return false;
+    }
+    String authority = uri.getAuthority();
+    return "xds".equals(uri.getScheme())
+        && (authority == null || "traffic-director-global.xds.googleapis.com".equals(authority));
+  }
+
+  @Override
+  public ClientCallPlugin newClientCallPlugin() {
+    return new ClientCallState();
+  }
+
+  public void configureServerBuilder(ServerBuilder<?> serverBuilder) {
+    serverBuilder.intercept(new ServerCallInterceptor());
+  }
+
+  @Override
+  public ServerStreamPlugin newServerStreamPlugin(Metadata inboundMetadata) {
+    return new ServerStreamState(inboundMetadata.get(RECV_KEY));
+  }
+
+  final class ClientCallState implements ClientCallPlugin {
+    private volatile Value serviceName;
+    private volatile Value serviceNamespace;
+
+    @Override
+    public ClientStreamPlugin newClientStreamPlugin() {
+      return new ClientStreamState();
+    }
+
+    @Override
+    public CallOptions filterCallOptions(CallOptions options) {
+      Consumer<Map<String, Struct>> existingConsumer =
+          options.getOption(ClusterImplLoadBalancerProvider.FILTER_METADATA_CONSUMER);
+      return options.withOption(
+          ClusterImplLoadBalancerProvider.FILTER_METADATA_CONSUMER,
+          (Map<String, Struct> clusterMetadata) -> {
+            metadataConsumer(clusterMetadata);
+            existingConsumer.accept(clusterMetadata);
+          });
+    }
+
+    private void metadataConsumer(Map<String, Struct> clusterMetadata) {
+      Struct struct = clusterMetadata.get("com.google.csm.telemetry_labels");
+      if (struct == null) {
+        struct = Struct.getDefaultInstance();
+      }
+      serviceName = struct.getFieldsMap().get("service_name");
+      serviceNamespace = struct.getFieldsMap().get("service_namespace");
+    }
+
+    @Override
+    public void addMetadata(Metadata toMetadata) {
+      toMetadata.put(SEND_KEY, localMetadata);
+    }
+
+    class ClientStreamState implements ClientStreamPlugin {
+      private Struct receivedExchange;
+
+      @Override
+      public void inboundHeaders(Metadata headers) {
+        setExchange(headers);
+      }
+
+      @Override
+      public void inboundTrailers(Metadata trailers) {
+        if (receivedExchange != null) {
+          return; // Received headers
+        }
+        setExchange(trailers);
+      }
+
+      private void setExchange(Metadata metadata) {
+        Struct received = metadata.get(RECV_KEY);
+        if (received == null) {
+          receivedExchange = Struct.getDefaultInstance();
+        } else {
+          receivedExchange = received;
+        }
+      }
+
+      @Override
+      public void addLabels(AttributesBuilder to) {
+        put(to, "csm.service_name",           serviceName);
+        put(to, "csm.service_namespace_name", serviceNamespace);
+        Struct exchange = receivedExchange;
+        if (exchange == null) {
+          exchange = Struct.getDefaultInstance();
+        }
+        MetadataExchanger.this.addLabels(to, exchange);
+      }
+    }
+  }
+
+  final class ServerCallInterceptor implements ServerInterceptor {
+    @Override
+    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+        ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+      if (!headers.containsKey(RECV_KEY)) {
+        return next.startCall(call, headers);
+      } else {
+        return next.startCall(new SimpleForwardingServerCall<ReqT, RespT>(call) {
+          private boolean headersSent;
+
+          @Override
+          public void sendHeaders(Metadata headers) {
+            headersSent = true;
+            headers.put(SEND_KEY, localMetadata);
+            super.sendHeaders(headers);
+          }
+
+          @Override
+          public void close(Status status, Metadata trailers) {
+            if (!headersSent) {
+              trailers.put(SEND_KEY, localMetadata);
+            }
+            super.close(status, trailers);
+          }
+        }, headers);
+      }
+    }
+  }
+
+  final class ServerStreamState implements ServerStreamPlugin {
+    private final Struct receivedExchange;
+
+    ServerStreamState(Struct exchange) {
+      if (exchange == null) {
+        exchange = Struct.getDefaultInstance();
+      }
+      receivedExchange = exchange;
+    }
+
+    @Override
+    public void addLabels(AttributesBuilder to) {
+      MetadataExchanger.this.addLabels(to, receivedExchange);
+    }
+  }
+
+  interface Lookup {
+    String get(String name);
+  }
+
+  interface Supplier<T> {
+    T get() throws Exception;
+  }
+
+  static final class BinaryToAsciiMarshaller<T> implements Metadata.AsciiMarshaller<T> {
+    private final Metadata.BinaryMarshaller<T> delegate;
+
+    public BinaryToAsciiMarshaller(Metadata.BinaryMarshaller<T> delegate) {
+      this.delegate = Preconditions.checkNotNull(delegate, "delegate");
+    }
+
+    @Override
+    public T parseAsciiString(String serialized) {
+      return delegate.parseBytes(BaseEncoding.base64().decode(serialized));
+    }
+
+    @Override
+    public String toAsciiString(T value) {
+      return BaseEncoding.base64().encode(delegate.toBytes(value));
+    }
+  }
+}
diff --git a/gcp-csm-observability/src/test/java/io/grpc/gcp/csm/observability/CsmObservabilityTest.java b/gcp-csm-observability/src/test/java/io/grpc/gcp/csm/observability/CsmObservabilityTest.java
new file mode 100644
index 00000000000..aba2c43c44f
--- /dev/null
+++ b/gcp-csm-observability/src/test/java/io/grpc/gcp/csm/observability/CsmObservabilityTest.java
@@ -0,0 +1,607 @@
+/*
+ * Copyright 2024 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.gcp.csm.observability;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.opentelemetry.api.common.AttributeKey.stringKey;
+import static org.junit.Assert.assertThrows;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Struct;
+import com.google.protobuf.Value;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.NameResolverProvider;
+import io.grpc.NameResolverRegistry;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCall;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.inprocess.InProcessSocketAddress;
+import io.grpc.internal.testing.FakeNameResolverProvider;
+import io.grpc.stub.ClientCalls;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.TestMethodDescriptors;
+import io.grpc.xds.ClusterImplLoadBalancerProvider;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions;
+import io.opentelemetry.sdk.testing.junit4.OpenTelemetryRule;
+import org.junit.After;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link CsmObservability}. */
+@RunWith(JUnit4.class)
+public final class CsmObservabilityTest {
+  @Rule
+  public final OpenTelemetryRule openTelemetryTesting = OpenTelemetryRule.create();
+  @Rule
+  public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
+
+  private NameResolverProvider fakeNameResolverProvider;
+  private InProcessSocketAddress socketAddress = new InProcessSocketAddress("csm-test-server");
+  private ServerBuilder<?> serverBuilder = InProcessServerBuilder.forAddress(socketAddress)
+      .addService(voidService(Status.OK))
+      .directExecutor();
+
+  @After
+  public void tearDown() {
+    if (fakeNameResolverProvider != null) {
+      NameResolverRegistry.getDefaultRegistry().deregister(fakeNameResolverProvider);
+    }
+  }
+
+  @Test
+  public void unknownDataExchange() throws Exception {
+    MetadataExchanger clientExchanger = new MetadataExchanger(
+        Attributes.builder().build(),
+        ImmutableMap.<String, String>of()::get);
+    CsmObservability.Builder clientCsmBuilder = new CsmObservability.Builder(clientExchanger)
+        .sdk(openTelemetryTesting.getOpenTelemetry());
+    MetadataExchanger serverExchanger = new MetadataExchanger(
+        Attributes.builder().build(),
+        ImmutableMap.<String, String>of()::get);
+    CsmObservability.Builder serverCsmBuilder = new CsmObservability.Builder(serverExchanger)
+        .sdk(openTelemetryTesting.getOpenTelemetry());
+
+    String target = "xds:///csm-test";
+    register(new FakeNameResolverProvider(target, socketAddress));
+    serverCsmBuilder.build().configureServerBuilder(serverBuilder);
+    grpcCleanupRule.register(serverBuilder.build().start());
+
+    ManagedChannelBuilder<?> channelBuilder = InProcessChannelBuilder.forTarget(target)
+        .directExecutor();
+    clientCsmBuilder.build().configureChannelBuilder(channelBuilder);
+    Channel channel = grpcCleanupRule.register(channelBuilder.build());
+
+    ClientCalls.blockingUnaryCall(
+        channel, TestMethodDescriptors.voidMethod(), CallOptions.DEFAULT, null);
+    Attributes preexistingClientAttributes = Attributes.builder()
+        .put(stringKey("grpc.method"), "other")
+        .put(stringKey("grpc.target"), target)
+        .build();
+    Attributes preexistingClientEndAttributes = preexistingClientAttributes.toBuilder()
+        .put(stringKey("grpc.status"), "OK")
+        .build();
+    Attributes newClientAttributes = preexistingClientEndAttributes.toBuilder()
+        .put(stringKey("csm.remote_workload_canonical_service"), "unknown")
+        .put(stringKey("csm.remote_workload_type"),              "unknown")
+        .put(stringKey("csm.service_name"),                      "unknown")
+        .put(stringKey("csm.service_namespace_name"),            "unknown")
+        .put(stringKey("csm.workload_canonical_service"),        "unknown")
+        .put(stringKey("csm.mesh_id"),                           "unknown")
+        .build();
+    Attributes preexistingServerAttributes = Attributes.builder()
+        .put(stringKey("grpc.method"), "other")
+        .build();
+    Attributes preexistingServerEndAttributes = preexistingServerAttributes.toBuilder()
+        .put(stringKey("grpc.status"), "OK")
+        .build();
+    Attributes newServerAttributes = preexistingServerEndAttributes.toBuilder()
+        .put(stringKey("csm.remote_workload_canonical_service"), "unknown")
+        .put(stringKey("csm.remote_workload_type"),              "unknown")
+        .put(stringKey("csm.workload_canonical_service"),        "unknown")
+        .put(stringKey("csm.mesh_id"),                           "unknown")
+        .build();
+    assertMetrics(
+        preexistingClientAttributes,
+        preexistingClientEndAttributes,
+        newClientAttributes,
+        preexistingServerAttributes,
+        newServerAttributes);
+  }
+
+  @Test
+  public void nonCsmServer() throws Exception {
+    MetadataExchanger clientExchanger = new MetadataExchanger(
+        Attributes.builder().build(),
+        ImmutableMap.<String, String>of()::get);
+    CsmObservability.Builder clientCsmBuilder = new CsmObservability.Builder(clientExchanger)
+        .sdk(openTelemetryTesting.getOpenTelemetry());
+
+    String target = "xds:///csm-test";
+    register(new FakeNameResolverProvider(target, socketAddress));
+    grpcCleanupRule.register(serverBuilder.build().start());
+
+    ManagedChannelBuilder<?> channelBuilder = InProcessChannelBuilder.forTarget(target)
+        .directExecutor();
+    clientCsmBuilder.build().configureChannelBuilder(channelBuilder);
+    Channel channel = grpcCleanupRule.register(channelBuilder.build());
+
+    ClientCalls.blockingUnaryCall(
+        channel, TestMethodDescriptors.voidMethod(), CallOptions.DEFAULT, null);
+    Attributes preexistingClientAttributes = Attributes.builder()
+        .put(stringKey("grpc.method"), "other")
+        .put(stringKey("grpc.target"), target)
+        .build();
+    Attributes preexistingClientEndAttributes = preexistingClientAttributes.toBuilder()
+        .put(stringKey("grpc.status"), "OK")
+        .build();
+    Attributes newClientAttributes = preexistingClientEndAttributes.toBuilder()
+        .put(stringKey("csm.remote_workload_canonical_service"), "unknown")
+        .put(stringKey("csm.remote_workload_type"),              "unknown")
+        .put(stringKey("csm.service_name"),                      "unknown")
+        .put(stringKey("csm.service_namespace_name"),            "unknown")
+        .put(stringKey("csm.workload_canonical_service"),        "unknown")
+        .put(stringKey("csm.mesh_id"),                           "unknown")
+        .build();
+    OpenTelemetryAssertions.assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.client.attempt.started")
+                .hasLongSumSatisfying(
+                    longSum -> longSum.hasPointsSatisfying(
+                        point -> point.hasAttributes(preexistingClientAttributes))),
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.client.attempt.duration")
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttributes(newClientAttributes))),
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.client.attempt.sent_total_compressed_message_size")
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttributes(newClientAttributes))),
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.client.attempt.rcvd_total_compressed_message_size")
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttributes(newClientAttributes))),
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.client.call.duration")
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttributes(preexistingClientEndAttributes))));
+  }
+
+  @Test
+  public void nonCsmClient() throws Exception {
+    MetadataExchanger clientExchanger = new MetadataExchanger(
+        Attributes.builder()
+            .put(stringKey("cloud.platform"), "gcp_kubernetes_engine")
+            .build(),
+        ImmutableMap.<String, String>of()::get);
+    CsmObservability.Builder clientCsmBuilder = new CsmObservability.Builder(clientExchanger)
+        .sdk(openTelemetryTesting.getOpenTelemetry());
+    MetadataExchanger serverExchanger = new MetadataExchanger(
+        Attributes.builder().build(),
+        ImmutableMap.<String, String>of()::get);
+    CsmObservability.Builder serverCsmBuilder = new CsmObservability.Builder(serverExchanger)
+        .sdk(openTelemetryTesting.getOpenTelemetry());
+
+    String target = "xds://not-a-csm-authority/csm-test";
+    register(new FakeNameResolverProvider(target, socketAddress));
+    serverCsmBuilder.build().configureServerBuilder(serverBuilder);
+    grpcCleanupRule.register(serverBuilder.build().start());
+
+    ManagedChannelBuilder<?> channelBuilder = InProcessChannelBuilder.forTarget(target)
+        .directExecutor();
+    clientCsmBuilder.build().configureChannelBuilder(channelBuilder);
+    Channel channel = grpcCleanupRule.register(channelBuilder.build());
+
+    ClientCalls.blockingUnaryCall(
+        channel, TestMethodDescriptors.voidMethod(), CallOptions.DEFAULT, null);
+    Attributes preexistingClientAttributes = Attributes.builder()
+        .put(stringKey("grpc.method"), "other")
+        .put(stringKey("grpc.target"), target)
+        .build();
+    Attributes preexistingClientEndAttributes = preexistingClientAttributes.toBuilder()
+        .put(stringKey("grpc.status"), "OK")
+        .build();
+    Attributes preexistingServerAttributes = Attributes.builder()
+        .put(stringKey("grpc.method"), "other")
+        .build();
+    Attributes preexistingServerEndAttributes = preexistingServerAttributes.toBuilder()
+        .put(stringKey("grpc.status"), "OK")
+        .build();
+    Attributes newServerAttributes = preexistingServerEndAttributes.toBuilder()
+        .put(stringKey("csm.remote_workload_canonical_service"), "unknown")
+        .put(stringKey("csm.remote_workload_type"),              "unknown")
+        .put(stringKey("csm.workload_canonical_service"),        "unknown")
+        .put(stringKey("csm.mesh_id"),                           "unknown")
+        .build();
+    assertMetrics(
+        preexistingClientAttributes,
+        preexistingClientEndAttributes,
+        preexistingClientEndAttributes,
+        preexistingServerAttributes,
+        newServerAttributes);
+  }
+
+  @Test
+  public void k8sExchange() throws Exception {
+    MetadataExchanger clientExchanger = new MetadataExchanger(
+        Attributes.builder()
+            .put(stringKey("cloud.platform"), "gcp_kubernetes_engine")
+            .put(stringKey("k8s.namespace.name"), "namespace-aeiou")
+            .put(stringKey("k8s.cluster.name"), "mycluster1")
+            .put(stringKey("cloud.region"), "us-central1")
+            .put(stringKey("cloud.account.id"), "31415926")
+            .build(),
+        ImmutableMap.of(
+            "CSM_CANONICAL_SERVICE_NAME", "canon-service-is-a-client",
+            "CSM_WORKLOAD_NAME", "best-client",
+            "CSM_MESH_ID", "mymesh")::get);
+    CsmObservability.Builder clientCsmBuilder = new CsmObservability.Builder(clientExchanger)
+        .sdk(openTelemetryTesting.getOpenTelemetry());
+    MetadataExchanger serverExchanger = new MetadataExchanger(
+        Attributes.builder()
+            .put(stringKey("cloud.platform"), "gcp_kubernetes_engine")
+            .put(stringKey("k8s.namespace.name"), "namespace-1e43c")
+            .put(stringKey("k8s.cluster.name"), "mycluster2")
+            .put(stringKey("cloud.availability_zone"), "us-east2-c")
+            .put(stringKey("cloud.region"), "us-east2")
+            .put(stringKey("cloud.account.id"), "11235813")
+            .build(),
+        ImmutableMap.of(
+            "CSM_CANONICAL_SERVICE_NAME", "server-has-a-single-name",
+            "CSM_WORKLOAD_NAME", "fast-server",
+            "CSM_MESH_ID", "meshhh")::get);
+    CsmObservability.Builder serverCsmBuilder = new CsmObservability.Builder(serverExchanger)
+        .sdk(openTelemetryTesting.getOpenTelemetry());
+
+    String target = "xds:///csm-test-k8s";
+    register(new FakeNameResolverProvider(target, socketAddress));
+    serverCsmBuilder.build().configureServerBuilder(serverBuilder);
+    grpcCleanupRule.register(serverBuilder.build().start());
+
+    ManagedChannelBuilder<?> channelBuilder = InProcessChannelBuilder.forTarget(target)
+        .directExecutor()
+        .intercept(new ProvideFilterMetadataInterceptor(
+            ImmutableMap.of("com.google.csm.telemetry_labels", Struct.newBuilder()
+                .putFields("service_name",
+                    Value.newBuilder().setStringValue("second-server-name").build())
+                .putFields("service_namespace",
+                    Value.newBuilder().setStringValue("namespace-0001").build())
+                .build())));
+    clientCsmBuilder.build().configureChannelBuilder(channelBuilder);
+    Channel channel = grpcCleanupRule.register(channelBuilder.build());
+
+    ClientCalls.blockingUnaryCall(
+        channel, TestMethodDescriptors.voidMethod(), CallOptions.DEFAULT, null);
+    Attributes preexistingClientAttributes = Attributes.builder()
+        .put(stringKey("grpc.method"), "other")
+        .put(stringKey("grpc.target"), target)
+        .build();
+    Attributes preexistingClientEndAttributes = preexistingClientAttributes.toBuilder()
+        .put(stringKey("grpc.status"), "OK")
+        .build();
+    Attributes newClientAttributes = preexistingClientEndAttributes.toBuilder()
+        .put(stringKey("csm.remote_workload_canonical_service"), "server-has-a-single-name")
+        .put(stringKey("csm.remote_workload_type"),              "gcp_kubernetes_engine")
+        .put(stringKey("csm.remote_workload_project_id"),        "11235813")
+        .put(stringKey("csm.remote_workload_location"),          "us-east2-c")
+        .put(stringKey("csm.remote_workload_cluster_name"),      "mycluster2")
+        .put(stringKey("csm.remote_workload_namespace_name"),    "namespace-1e43c")
+        .put(stringKey("csm.remote_workload_name"),              "fast-server")
+        .put(stringKey("csm.service_name"),                      "second-server-name")
+        .put(stringKey("csm.service_namespace_name"),            "namespace-0001")
+        .put(stringKey("csm.workload_canonical_service"),        "canon-service-is-a-client")
+        .put(stringKey("csm.mesh_id"),                           "mymesh")
+        .build();
+    Attributes preexistingServerAttributes = Attributes.builder()
+        .put(stringKey("grpc.method"), "other")
+        .build();
+    Attributes preexistingServerEndAttributes = preexistingServerAttributes.toBuilder()
+        .put(stringKey("grpc.status"), "OK")
+        .build();
+    Attributes newServerAttributes = preexistingServerEndAttributes.toBuilder()
+        .put(stringKey("csm.remote_workload_canonical_service"), "canon-service-is-a-client")
+        .put(stringKey("csm.remote_workload_type"),              "gcp_kubernetes_engine")
+        .put(stringKey("csm.remote_workload_project_id"),        "31415926")
+        .put(stringKey("csm.remote_workload_location"),          "us-central1")
+        .put(stringKey("csm.remote_workload_cluster_name"),      "mycluster1")
+        .put(stringKey("csm.remote_workload_namespace_name"),    "namespace-aeiou")
+        .put(stringKey("csm.remote_workload_name"),              "best-client")
+        .put(stringKey("csm.workload_canonical_service"),        "server-has-a-single-name")
+        .put(stringKey("csm.mesh_id"),                           "meshhh")
+        .build();
+    assertMetrics(
+        preexistingClientAttributes,
+        preexistingClientEndAttributes,
+        newClientAttributes,
+        preexistingServerAttributes,
+        newServerAttributes);
+  }
+
+  @Test
+  public void gceExchange() throws Exception {
+    MetadataExchanger clientExchanger = new MetadataExchanger(
+        Attributes.builder()
+            .put(stringKey("cloud.platform"), "gcp_compute_engine")
+            .put(stringKey("cloud.region"), "us-central1")
+            .put(stringKey("cloud.account.id"), "31415926")
+            .build(),
+        ImmutableMap.of(
+            "CSM_CANONICAL_SERVICE_NAME", "canon-service-is-a-client",
+            "CSM_WORKLOAD_NAME", "best-client",
+            "CSM_MESH_ID", "mymesh")::get);
+    CsmObservability.Builder clientCsmBuilder = new CsmObservability.Builder(clientExchanger)
+        .sdk(openTelemetryTesting.getOpenTelemetry());
+    MetadataExchanger serverExchanger = new MetadataExchanger(
+        Attributes.builder()
+            .put(stringKey("cloud.platform"), "gcp_compute_engine")
+            .put(stringKey("cloud.availability_zone"), "us-east2-c")
+            .put(stringKey("cloud.region"), "us-east2")
+            .put(stringKey("cloud.account.id"), "11235813")
+            .build(),
+        ImmutableMap.of(
+            "CSM_CANONICAL_SERVICE_NAME", "server-has-a-single-name",
+            "CSM_WORKLOAD_NAME", "fast-server",
+            "CSM_MESH_ID", "meshhh")::get);
+    CsmObservability.Builder serverCsmBuilder = new CsmObservability.Builder(serverExchanger)
+        .sdk(openTelemetryTesting.getOpenTelemetry());
+
+    String target = "xds:///csm-test";
+    register(new FakeNameResolverProvider(target, socketAddress));
+    serverCsmBuilder.build().configureServerBuilder(serverBuilder);
+    grpcCleanupRule.register(serverBuilder.build().start());
+
+    ManagedChannelBuilder<?> channelBuilder = InProcessChannelBuilder.forTarget(target)
+        .directExecutor()
+        .intercept(new ProvideFilterMetadataInterceptor(ImmutableMap.<String, Struct>of()));
+    clientCsmBuilder.build().configureChannelBuilder(channelBuilder);
+    Channel channel = grpcCleanupRule.register(channelBuilder.build());
+
+    ClientCalls.blockingUnaryCall(
+        channel, TestMethodDescriptors.voidMethod(), CallOptions.DEFAULT, null);
+    Attributes preexistingClientAttributes = Attributes.builder()
+        .put(stringKey("grpc.method"), "other")
+        .put(stringKey("grpc.target"), target)
+        .build();
+    Attributes preexistingClientEndAttributes = preexistingClientAttributes.toBuilder()
+        .put(stringKey("grpc.status"), "OK")
+        .build();
+    Attributes newClientAttributes = preexistingClientEndAttributes.toBuilder()
+        .put(stringKey("csm.remote_workload_canonical_service"), "server-has-a-single-name")
+        .put(stringKey("csm.remote_workload_type"),              "gcp_compute_engine")
+        .put(stringKey("csm.remote_workload_project_id"),        "11235813")
+        .put(stringKey("csm.remote_workload_location"),          "us-east2-c")
+        .put(stringKey("csm.remote_workload_name"),              "fast-server")
+        .put(stringKey("csm.service_name"),                      "unknown")
+        .put(stringKey("csm.service_namespace_name"),            "unknown")
+        .put(stringKey("csm.workload_canonical_service"),        "canon-service-is-a-client")
+        .put(stringKey("csm.mesh_id"),                           "mymesh")
+        .build();
+    Attributes preexistingServerAttributes = Attributes.builder()
+        .put(stringKey("grpc.method"), "other")
+        .build();
+    Attributes preexistingServerEndAttributes = preexistingServerAttributes.toBuilder()
+        .put(stringKey("grpc.status"), "OK")
+        .build();
+    Attributes newServerAttributes = preexistingServerEndAttributes.toBuilder()
+        .put(stringKey("csm.remote_workload_canonical_service"), "canon-service-is-a-client")
+        .put(stringKey("csm.remote_workload_type"),              "gcp_compute_engine")
+        .put(stringKey("csm.remote_workload_project_id"),        "31415926")
+        .put(stringKey("csm.remote_workload_location"),          "us-central1")
+        .put(stringKey("csm.remote_workload_name"),              "best-client")
+        .put(stringKey("csm.workload_canonical_service"),        "server-has-a-single-name")
+        .put(stringKey("csm.mesh_id"),                           "meshhh")
+        .build();
+    assertMetrics(
+        preexistingClientAttributes,
+        preexistingClientEndAttributes,
+        newClientAttributes,
+        preexistingServerAttributes,
+        newServerAttributes);
+  }
+
+  @Test
+  public void trailersOnly() throws Exception {
+    MetadataExchanger clientExchanger = new MetadataExchanger(
+        Attributes.builder()
+            .put(stringKey("cloud.platform"), "gcp_compute_engine")
+            .put(stringKey("cloud.region"), "us-central1")
+            .put(stringKey("cloud.account.id"), "31415926")
+            .build(),
+        ImmutableMap.of(
+            "CSM_CANONICAL_SERVICE_NAME", "canon-service-is-a-client",
+            "CSM_WORKLOAD_NAME", "best-client",
+            "CSM_MESH_ID", "mymesh")::get);
+    CsmObservability.Builder clientCsmBuilder = new CsmObservability.Builder(clientExchanger)
+        .sdk(openTelemetryTesting.getOpenTelemetry());
+
+    MetadataExchanger serverExchanger = new MetadataExchanger(
+        Attributes.builder()
+            .put(stringKey("cloud.platform"), "gcp_compute_engine")
+            .put(stringKey("cloud.availability_zone"), "us-east2-c")
+            .put(stringKey("cloud.region"), "us-east2")
+            .put(stringKey("cloud.account.id"), "11235813")
+            .build(),
+        ImmutableMap.of(
+            "CSM_CANONICAL_SERVICE_NAME", "server-has-a-single-name",
+            "CSM_WORKLOAD_NAME", "fast-server",
+            "CSM_MESH_ID", "meshhh")::get);
+    CsmObservability.Builder serverCsmBuilder = new CsmObservability.Builder(serverExchanger)
+        .sdk(openTelemetryTesting.getOpenTelemetry());
+
+    String target = "xds:///csm-test";
+    register(new FakeNameResolverProvider(target, socketAddress));
+    // Trailers-only
+    serverBuilder.addService(voidService(Status.INVALID_ARGUMENT));
+    serverCsmBuilder.build().configureServerBuilder(serverBuilder);
+    grpcCleanupRule.register(serverBuilder.build().start());
+
+    ManagedChannelBuilder<?> channelBuilder = InProcessChannelBuilder.forTarget(target)
+        .directExecutor();
+    clientCsmBuilder.build().configureChannelBuilder(channelBuilder);
+    Channel channel = grpcCleanupRule.register(channelBuilder.build());
+
+    assertThrows(StatusRuntimeException.class, () ->
+        ClientCalls.blockingUnaryCall(
+            channel, TestMethodDescriptors.voidMethod(), CallOptions.DEFAULT, null));
+    Attributes preexistingClientAttributes = Attributes.builder()
+        .put(stringKey("grpc.method"), "other")
+        .put(stringKey("grpc.target"), target)
+        .build();
+    Attributes preexistingClientEndAttributes = preexistingClientAttributes.toBuilder()
+        .put(stringKey("grpc.status"), "INVALID_ARGUMENT")
+        .build();
+    Attributes newClientAttributes = preexistingClientEndAttributes.toBuilder()
+        .put(stringKey("csm.remote_workload_canonical_service"), "server-has-a-single-name")
+        .put(stringKey("csm.remote_workload_type"),              "gcp_compute_engine")
+        .put(stringKey("csm.remote_workload_project_id"),        "11235813")
+        .put(stringKey("csm.remote_workload_location"),          "us-east2-c")
+        .put(stringKey("csm.remote_workload_name"),              "fast-server")
+        .put(stringKey("csm.service_name"),                      "unknown")
+        .put(stringKey("csm.service_namespace_name"),            "unknown")
+        .put(stringKey("csm.workload_canonical_service"),        "canon-service-is-a-client")
+        .put(stringKey("csm.mesh_id"),                           "mymesh")
+        .build();
+    Attributes preexistingServerAttributes = Attributes.builder()
+        .put(stringKey("grpc.method"), "other")
+        .build();
+    Attributes preexistingServerEndAttributes = preexistingServerAttributes.toBuilder()
+        .put(stringKey("grpc.status"), "INVALID_ARGUMENT")
+        .build();
+    Attributes newServerAttributes = preexistingServerEndAttributes.toBuilder()
+        .put(stringKey("csm.remote_workload_canonical_service"), "canon-service-is-a-client")
+        .put(stringKey("csm.remote_workload_type"),              "gcp_compute_engine")
+        .put(stringKey("csm.remote_workload_project_id"),        "31415926")
+        .put(stringKey("csm.remote_workload_location"),          "us-central1")
+        .put(stringKey("csm.remote_workload_name"),              "best-client")
+        .put(stringKey("csm.workload_canonical_service"),        "server-has-a-single-name")
+        .put(stringKey("csm.mesh_id"),                           "meshhh")
+        .build();
+    assertMetrics(
+        preexistingClientAttributes,
+        preexistingClientEndAttributes,
+        newClientAttributes,
+        preexistingServerAttributes,
+        newServerAttributes);
+  }
+
+  private void register(NameResolverProvider provider) {
+    assertThat(fakeNameResolverProvider).isNull();
+    fakeNameResolverProvider = provider;
+    NameResolverRegistry.getDefaultRegistry().register(provider);
+  }
+
+  private static ServerServiceDefinition voidService(Status status) {
+    return ServerServiceDefinition.builder(TestMethodDescriptors.voidMethod().getServiceName())
+        .addMethod(TestMethodDescriptors.voidMethod(), (call, headers) -> {
+          if (status.isOk()) {
+            call.sendHeaders(new Metadata());
+            call.sendMessage(null);
+          }
+          call.close(status, new Metadata());
+          return new ServerCall.Listener<Void>() {};
+        })
+        .build();
+  }
+
+  private void assertMetrics(
+      Attributes preexistingClientAttributes,
+      Attributes preexistingClientEndAttributes,
+      Attributes newClientAttributes,
+      Attributes preexistingServerAttributes,
+      Attributes newServerAttributes) {
+    OpenTelemetryAssertions.assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.client.attempt.started")
+                .hasLongSumSatisfying(
+                    longSum -> longSum.hasPointsSatisfying(
+                        point -> point.hasAttributes(preexistingClientAttributes))),
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.client.attempt.duration")
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttributes(newClientAttributes))),
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.client.attempt.sent_total_compressed_message_size")
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttributes(newClientAttributes))),
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.client.attempt.rcvd_total_compressed_message_size")
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttributes(newClientAttributes))),
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.client.call.duration")
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttributes(preexistingClientEndAttributes))),
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.server.call.started")
+                .hasLongSumSatisfying(
+                    longSum -> longSum.hasPointsSatisfying(
+                        point -> point.hasAttributes(preexistingServerAttributes))),
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.server.call.duration")
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttributes(newServerAttributes))),
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.server.call.sent_total_compressed_message_size")
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttributes(newServerAttributes))),
+             metric -> OpenTelemetryAssertions.assertThat(metric)
+                .hasName("grpc.server.call.rcvd_total_compressed_message_size")
+                .hasHistogramSatisfying(
+                    histogram -> histogram.hasPointsSatisfying(
+                        point -> point.hasAttributes(newServerAttributes))));
+  }
+
+  private static class ProvideFilterMetadataInterceptor implements ClientInterceptor {
+    private final ImmutableMap<String, Struct> filterMetadata;
+
+    public ProvideFilterMetadataInterceptor(ImmutableMap<String, Struct> filterMetadata) {
+      this.filterMetadata = filterMetadata;
+    }
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+      callOptions.getOption(ClusterImplLoadBalancerProvider.FILTER_METADATA_CONSUMER)
+          .accept(filterMetadata);
+      return next.newCall(method, callOptions);
+    }
+  }
+}
diff --git a/gcp-csm-observability/src/test/java/io/grpc/gcp/csm/observability/MetadataExchangerTest.java b/gcp-csm-observability/src/test/java/io/grpc/gcp/csm/observability/MetadataExchangerTest.java
new file mode 100644
index 00000000000..cc3472be182
--- /dev/null
+++ b/gcp-csm-observability/src/test/java/io/grpc/gcp/csm/observability/MetadataExchangerTest.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2024 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.gcp.csm.observability;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.opentelemetry.api.common.AttributeKey.stringKey;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.io.BaseEncoding;
+import com.google.protobuf.Struct;
+import com.google.protobuf.Value;
+import io.grpc.Metadata;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.common.AttributesBuilder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link MetadataExchanger}. */
+@RunWith(JUnit4.class)
+public final class MetadataExchangerTest {
+
+  @Test
+  public void enablePluginForChannel_matches() {
+    MetadataExchanger exchanger =
+        new MetadataExchanger(Attributes.builder().build(), (name) -> null);
+    assertThat(exchanger.enablePluginForChannel("xds:///testing")).isTrue();
+    assertThat(exchanger.enablePluginForChannel("xds:/testing")).isTrue();
+    assertThat(exchanger.enablePluginForChannel(
+        "xds://traffic-director-global.xds.googleapis.com/testing:123")).isTrue();
+  }
+
+  @Test
+  public void enablePluginForChannel_doesNotMatch() {
+    MetadataExchanger exchanger =
+        new MetadataExchanger(Attributes.builder().build(), (name) -> null);
+    assertThat(exchanger.enablePluginForChannel("dns:///localhost")).isFalse();
+    assertThat(exchanger.enablePluginForChannel("xds:///[]")).isFalse();
+    assertThat(exchanger.enablePluginForChannel("xds://my-xds-server/testing")).isFalse();
+  }
+
+  @Test
+  public void addLabels_receivedWrongType() {
+    MetadataExchanger exchanger =
+        new MetadataExchanger(Attributes.builder().build(), (name) -> null);
+    Metadata metadata = new Metadata();
+    metadata.put(Metadata.Key.of("x-envoy-peer-metadata", Metadata.ASCII_STRING_MARSHALLER),
+        BaseEncoding.base64().encode(Struct.newBuilder()
+          .putFields("type", Value.newBuilder().setNumberValue(1).build())
+          .build()
+          .toByteArray()));
+    AttributesBuilder builder = Attributes.builder();
+    exchanger.newServerStreamPlugin(metadata).addLabels(builder);
+
+    assertThat(builder.build()).isEqualTo(Attributes.builder()
+        .put(stringKey("csm.mesh_id"), "unknown")
+        .put(stringKey("csm.workload_canonical_service"), "unknown")
+        .put(stringKey("csm.remote_workload_type"), "unknown")
+        .put(stringKey("csm.remote_workload_canonical_service"), "unknown")
+        .build());
+  }
+
+  @Test
+  public void addLabelsFromExchange_unknownGcpType() {
+    MetadataExchanger exchanger =
+        new MetadataExchanger(Attributes.builder().build(), (name) -> null);
+    Metadata metadata = new Metadata();
+    metadata.put(Metadata.Key.of("x-envoy-peer-metadata", Metadata.ASCII_STRING_MARSHALLER),
+        BaseEncoding.base64().encode(Struct.newBuilder()
+          .putFields("type", Value.newBuilder().setStringValue("gcp_surprise").build())
+          .putFields("canonical_service", Value.newBuilder().setStringValue("myservice1").build())
+          .build()
+          .toByteArray()));
+    AttributesBuilder builder = Attributes.builder();
+    exchanger.newServerStreamPlugin(metadata).addLabels(builder);
+
+    assertThat(builder.build()).isEqualTo(Attributes.builder()
+        .put(stringKey("csm.mesh_id"), "unknown")
+        .put(stringKey("csm.workload_canonical_service"), "unknown")
+        .put(stringKey("csm.remote_workload_type"), "gcp_surprise")
+        .put(stringKey("csm.remote_workload_canonical_service"), "myservice1")
+        .build());
+  }
+
+  @Test
+  public void addMetadata_k8s() throws Exception {
+    MetadataExchanger exchanger = new MetadataExchanger(
+        Attributes.builder()
+            .put(stringKey("cloud.platform"), "gcp_kubernetes_engine")
+            .put(stringKey("k8s.namespace.name"), "mynamespace1")
+            .put(stringKey("k8s.cluster.name"), "mycluster1")
+            .put(stringKey("cloud.availability_zone"), "myzone1")
+            .put(stringKey("cloud.account.id"), "0001")
+            .build(),
+        ImmutableMap.of(
+            "CSM_CANONICAL_SERVICE_NAME", "myservice1",
+            "CSM_WORKLOAD_NAME", "myworkload1")::get);
+    Metadata metadata = new Metadata();
+    exchanger.newClientCallPlugin().addMetadata(metadata);
+
+    Struct peer = Struct.parseFrom(BaseEncoding.base64().decode(metadata.get(
+        Metadata.Key.of("x-envoy-peer-metadata", Metadata.ASCII_STRING_MARSHALLER))));
+    assertThat(peer).isEqualTo(
+        Struct.newBuilder()
+          .putFields("type", Value.newBuilder().setStringValue("gcp_kubernetes_engine").build())
+          .putFields("canonical_service", Value.newBuilder().setStringValue("myservice1").build())
+          .putFields("workload_name", Value.newBuilder().setStringValue("myworkload1").build())
+          .putFields("namespace_name", Value.newBuilder().setStringValue("mynamespace1").build())
+          .putFields("cluster_name", Value.newBuilder().setStringValue("mycluster1").build())
+          .putFields("location", Value.newBuilder().setStringValue("myzone1").build())
+          .putFields("project_id", Value.newBuilder().setStringValue("0001").build())
+          .build());
+  }
+
+  @Test
+  public void addMetadata_gce() throws Exception {
+    MetadataExchanger exchanger = new MetadataExchanger(
+        Attributes.builder()
+            .put(stringKey("cloud.platform"), "gcp_compute_engine")
+            .put(stringKey("cloud.availability_zone"), "myzone1")
+            .put(stringKey("cloud.account.id"), "0001")
+            .build(),
+        ImmutableMap.of(
+            "CSM_CANONICAL_SERVICE_NAME", "myservice1",
+            "CSM_WORKLOAD_NAME", "myworkload1")::get);
+    Metadata metadata = new Metadata();
+    exchanger.newClientCallPlugin().addMetadata(metadata);
+
+    Struct peer = Struct.parseFrom(BaseEncoding.base64().decode(metadata.get(
+        Metadata.Key.of("x-envoy-peer-metadata", Metadata.ASCII_STRING_MARSHALLER))));
+    assertThat(peer).isEqualTo(
+        Struct.newBuilder()
+          .putFields("type", Value.newBuilder().setStringValue("gcp_compute_engine").build())
+          .putFields("canonical_service", Value.newBuilder().setStringValue("myservice1").build())
+          .putFields("workload_name", Value.newBuilder().setStringValue("myworkload1").build())
+          .putFields("location", Value.newBuilder().setStringValue("myzone1").build())
+          .putFields("project_id", Value.newBuilder().setStringValue("0001").build())
+          .build());
+  }
+}
diff --git a/gcp-observability/build.gradle b/gcp-observability/build.gradle
new file mode 100644
index 00000000000..1d8c7a9f961
--- /dev/null
+++ b/gcp-observability/build.gradle
@@ -0,0 +1,83 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "com.google.protobuf"
+    id "ru.vyarus.animalsniffer"
+}
+
+description = "gRPC: Google Cloud Platform Observability"
+
+tasks.named("compileJava").configure {
+    it.options.compilerArgs += [
+            // only has AutoValue annotation processor
+            "-Xlint:-processing"
+    ]
+    appendToProperty(
+            it.options.errorprone.excludedPaths,
+            ".*/build/generated/sources/annotationProcessor/java/.*",
+            "|")
+}
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.gcp.observability')
+    }
+}
+
+dependencies {
+    annotationProcessor libraries.auto.value
+    api project(':grpc-api')
+
+    // TODO(dnvindhya): Prefer using our own libraries, update the dependencies
+    //  in gradle/libs.versions instead
+    implementation project(':grpc-protobuf'),
+            project(':grpc-stub'),
+            project(':grpc-census'),
+            project(":grpc-context"), // Override opencensus dependency with our newer version
+            libraries.opencensus.contrib.grpc.metrics
+    // Avoid gradle using project dependencies without configuration: shadow
+    implementation (libraries.google.cloud.logging) {
+        exclude group: 'io.grpc', module: 'grpc-alts'
+        exclude group: 'io.grpc', module: 'grpc-netty-shaded'
+        exclude group: 'io.grpc', module: 'grpc-xds'
+    }
+    implementation (libraries.opencensus.exporter.stats.stackdriver) {
+        exclude group: 'io.grpc', module: 'grpc-alts'
+        exclude group: 'io.grpc', module: 'grpc-netty-shaded'
+        exclude group: 'io.grpc', module: 'grpc-xds'
+    }
+    implementation (libraries.opencensus.exporter.trace.stackdriver) {
+        exclude group: 'io.grpc', module: 'grpc-alts'
+        exclude group: 'io.grpc', module: 'grpc-netty-shaded'
+        exclude group: 'io.grpc', module: 'grpc-xds'
+    }
+
+    runtimeOnly libraries.opencensus.impl,
+            project(path: ':grpc-netty-shaded', configuration: 'shadow'),
+            project(path: ':grpc-xds', configuration: 'shadow'),
+            project(path: ':grpc-alts', configuration: 'shadow'),
+            project(':grpc-auth'), // Align grpc versions
+            project(':grpc-core'), // Align grpc versions
+            project(':grpc-services'), // Align grpc versions
+            libraries.animalsniffer.annotations, // Use our newer version
+            libraries.auto.value.annotations, // Use our newer version
+            libraries.guava.jre, // Use our newer version
+            libraries.protobuf.java.util, // Use our newer version
+            libraries.re2j // Use our newer version
+
+    testImplementation testFixtures(project(':grpc-api')),
+            project(':grpc-testing'),
+            project(':grpc-testing-proto')
+    testImplementation (libraries.guava.testlib) {
+        exclude group: 'junit', module: 'junit'
+    }
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+configureProtoCompilation()
diff --git a/gcp-observability/interop/build.gradle b/gcp-observability/interop/build.gradle
new file mode 100644
index 00000000000..7e17624995a
--- /dev/null
+++ b/gcp-observability/interop/build.gradle
@@ -0,0 +1,26 @@
+plugins {
+    id "application"
+
+    id "ru.vyarus.animalsniffer"
+}
+
+description = "gRPC: Google Cloud Platform Observability Interop"
+
+dependencies {
+    implementation project(':grpc-interop-testing'),
+            project(':grpc-gcp-observability')
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+application {
+    mainClass = 'io.grpc.gcp.observability.interop.TestServiceInterop'
+}
+
+tasks.named('startScripts').configure {
+    applicationName = 'gcp-observability-interop'
+}
diff --git a/gcp-observability/interop/src/main/java/io/grpc/gcp/observability/interop/TestServiceInterop.java b/gcp-observability/interop/src/main/java/io/grpc/gcp/observability/interop/TestServiceInterop.java
new file mode 100644
index 00000000000..f854d20eaaf
--- /dev/null
+++ b/gcp-observability/interop/src/main/java/io/grpc/gcp/observability/interop/TestServiceInterop.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2023 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.gcp.observability.interop;
+
+import io.grpc.gcp.observability.GcpObservability;
+import io.grpc.testing.integration.TestServiceClient;
+import io.grpc.testing.integration.TestServiceServer;
+import java.util.Arrays;
+
+/**
+ * Combined interop client and server for observability testing.
+ */
+public final class TestServiceInterop {
+  public static void main(String[] args) throws Exception {
+    boolean client;
+    if (args.length < 1) {
+      usage();
+      return;
+    }
+    if ("server".equals(args[0])) {
+      client = false;
+    } else if ("client".equals(args[0])) {
+      client = true;
+    } else {
+      usage();
+      return;
+    }
+    args = Arrays.asList(args).subList(1, args.length).toArray(new String[0]);
+    try (GcpObservability gcpObservability = GcpObservability.grpcInit()) {
+      if (client) {
+        TestServiceClient.main(args);
+      } else {
+        TestServiceServer.main(args);
+      }
+    }
+  }
+
+  private static void usage() {
+    System.out.println("Usage: client|server [ARGS...]");
+    System.exit(1);
+  }
+}
diff --git a/gcp-observability/src/main/java/io/grpc/gcp/observability/GcpObservability.java b/gcp-observability/src/main/java/io/grpc/gcp/observability/GcpObservability.java
new file mode 100644
index 00000000000..7fe4e3a8a3c
--- /dev/null
+++ b/gcp-observability/src/main/java/io/grpc/gcp/observability/GcpObservability.java
@@ -0,0 +1,308 @@
+/*
+ * Copyright 2022 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.gcp.observability;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import io.grpc.ClientInterceptor;
+import io.grpc.InternalConfigurator;
+import io.grpc.InternalConfiguratorRegistry;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.ManagedChannelProvider.ProviderNotFoundException;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerStreamTracer;
+import io.grpc.census.InternalCensusStatsAccessor;
+import io.grpc.census.InternalCensusTracingAccessor;
+import io.grpc.census.internal.ObservabilityCensusConstants;
+import io.grpc.gcp.observability.interceptors.ConditionalClientInterceptor;
+import io.grpc.gcp.observability.interceptors.ConfigFilterHelper;
+import io.grpc.gcp.observability.interceptors.InternalLoggingChannelInterceptor;
+import io.grpc.gcp.observability.interceptors.InternalLoggingServerInterceptor;
+import io.grpc.gcp.observability.interceptors.LogHelper;
+import io.grpc.gcp.observability.logging.GcpLogSink;
+import io.grpc.gcp.observability.logging.Sink;
+import io.grpc.gcp.observability.logging.TraceLoggingHelper;
+import io.opencensus.common.Duration;
+import io.opencensus.contrib.grpc.metrics.RpcViewConstants;
+import io.opencensus.exporter.stats.stackdriver.StackdriverStatsConfiguration;
+import io.opencensus.exporter.stats.stackdriver.StackdriverStatsExporter;
+import io.opencensus.exporter.trace.stackdriver.StackdriverTraceConfiguration;
+import io.opencensus.exporter.trace.stackdriver.StackdriverTraceExporter;
+import io.opencensus.metrics.LabelKey;
+import io.opencensus.metrics.LabelValue;
+import io.opencensus.stats.Stats;
+import io.opencensus.stats.ViewManager;
+import io.opencensus.trace.AttributeValue;
+import io.opencensus.trace.Tracing;
+import io.opencensus.trace.config.TraceConfig;
+import java.io.IOException;
+import java.lang.management.ManagementFactory;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+/** The main class for gRPC Google Cloud Platform Observability features. */
+public final class GcpObservability implements AutoCloseable {
+
+  private static final Logger logger = Logger.getLogger(GcpObservability.class.getName());
+  private static final int METRICS_EXPORT_INTERVAL = 30;
+
+  static final String DEFAULT_METRIC_CUSTOM_TAG_KEY = "opencensus_task";
+  @VisibleForTesting
+  static final ImmutableSet<String> SERVICES_TO_EXCLUDE = ImmutableSet.of(
+      "google.logging.v2.LoggingServiceV2", "google.monitoring.v3.MetricService",
+      "google.devtools.cloudtrace.v2.TraceService");
+
+  private static GcpObservability instance = null;
+  private final Sink sink;
+  private final ObservabilityConfig config;
+  private final ArrayList<ClientInterceptor> clientInterceptors = new ArrayList<>();
+  private final ArrayList<ServerInterceptor> serverInterceptors = new ArrayList<>();
+  private final ArrayList<ServerStreamTracer.Factory> tracerFactories = new ArrayList<>();
+
+  /**
+   * Initialize grpc-observability.
+   *
+   * @throws ProviderNotFoundException if no underlying channel/server provider is available.
+   */
+  public static synchronized GcpObservability grpcInit() throws IOException {
+    if (instance == null) {
+      ObservabilityConfigImpl observabilityConfig = ObservabilityConfigImpl.getInstance();
+      TraceLoggingHelper traceLoggingHelper = new TraceLoggingHelper(
+          observabilityConfig.getProjectId());
+      Sink sink = new GcpLogSink(observabilityConfig.getProjectId(), observabilityConfig,
+          SERVICES_TO_EXCLUDE, traceLoggingHelper);
+      LogHelper helper = new LogHelper(sink);
+      ConfigFilterHelper configFilterHelper = ConfigFilterHelper.getInstance(observabilityConfig);
+      instance = grpcInit(sink, observabilityConfig,
+          new InternalLoggingChannelInterceptor.FactoryImpl(helper, configFilterHelper),
+          new InternalLoggingServerInterceptor.FactoryImpl(helper, configFilterHelper));
+      instance.registerStackDriverExporter(observabilityConfig.getProjectId(),
+          observabilityConfig.getCustomTags());
+    }
+    return instance;
+  }
+
+  @VisibleForTesting
+  static GcpObservability grpcInit(
+      Sink sink,
+      ObservabilityConfig config,
+      InternalLoggingChannelInterceptor.Factory channelInterceptorFactory,
+      InternalLoggingServerInterceptor.Factory serverInterceptorFactory)
+      throws IOException {
+    if (instance == null) {
+      instance = new GcpObservability(sink, config);
+      instance.setProducer(channelInterceptorFactory, serverInterceptorFactory);
+    }
+    return instance;
+  }
+
+  /** Un-initialize/shutdown grpc-observability. */
+  @Override
+  public void close() {
+    closeWithSleepTime(2 * METRICS_EXPORT_INTERVAL, TimeUnit.SECONDS);
+  }
+
+  /**
+   * Method to close along with sleep time explicitly.
+   *
+   * @param sleepTime sleepTime
+   */
+  void closeWithSleepTime(long sleepTime, TimeUnit timeUnit) {
+    synchronized (GcpObservability.class) {
+      if (instance == null) {
+        throw new IllegalStateException("GcpObservability already closed!");
+      }
+      sink.close();
+      if (config.isEnableCloudMonitoring() || config.isEnableCloudTracing()) {
+        try {
+          // Sleeping before shutdown to ensure all metrics and traces are flushed
+          timeUnit.sleep(sleepTime);
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+          logger.log(Level.SEVERE, "Caught exception during sleep", e);
+        }
+      }
+      instance = null;
+    }
+  }
+
+  // TODO(dnvindhya): Remove <channel/server>InterceptorFactory and replace with respective
+  // interceptors
+  private void setProducer(
+      InternalLoggingChannelInterceptor.Factory channelInterceptorFactory,
+      InternalLoggingServerInterceptor.Factory serverInterceptorFactory) {
+    if (config.isEnableCloudLogging()) {
+      clientInterceptors.add(channelInterceptorFactory.create());
+      serverInterceptors.add(serverInterceptorFactory.create());
+    }
+    if (config.isEnableCloudMonitoring()) {
+      clientInterceptors.add(getConditionalInterceptor(
+          InternalCensusStatsAccessor.getClientInterceptor(true, true, false, true)));
+      tracerFactories.add(
+          InternalCensusStatsAccessor.getServerStreamTracerFactory(true, true, false));
+    }
+    if (config.isEnableCloudTracing()) {
+      clientInterceptors.add(
+          getConditionalInterceptor(InternalCensusTracingAccessor.getClientInterceptor()));
+      tracerFactories.add(InternalCensusTracingAccessor.getServerStreamTracerFactory());
+    }
+
+    InternalConfiguratorRegistry.setConfigurators(Arrays.asList(
+        new ObservabilityConfigurator(clientInterceptors, serverInterceptors, tracerFactories)));
+  }
+
+  @VisibleForTesting
+  static final class ObservabilityConfigurator implements InternalConfigurator {
+    final List<ClientInterceptor> clientInterceptors;
+    final List<ServerInterceptor> serverInterceptors;
+    final List<ServerStreamTracer.Factory> tracerFactories;
+
+    ObservabilityConfigurator(
+        List<ClientInterceptor> clientInterceptors,
+        List<ServerInterceptor> serverInterceptors,
+        List<ServerStreamTracer.Factory> tracerFactories) {
+      this.clientInterceptors = ImmutableList.copyOf(
+          checkNotNull(clientInterceptors, "clientInterceptors"));
+      this.serverInterceptors = ImmutableList.copyOf(
+          checkNotNull(serverInterceptors, "serverInterceptors"));
+      this.tracerFactories = ImmutableList.copyOf(
+          checkNotNull(tracerFactories, "tracerFactories"));
+    }
+
+    @Override
+    public void configureChannelBuilder(ManagedChannelBuilder<?> builder) {
+      builder.intercept(clientInterceptors);
+    }
+
+    @Override
+    public void configureServerBuilder(ServerBuilder<?> builder) {
+      for (ServerInterceptor interceptor : serverInterceptors) {
+        builder.intercept(interceptor);
+      }
+      for (ServerStreamTracer.Factory factory : tracerFactories) {
+        builder.addStreamTracerFactory(factory);
+      }
+    }
+  }
+
+  static ConditionalClientInterceptor getConditionalInterceptor(ClientInterceptor interceptor) {
+    return new ConditionalClientInterceptor(interceptor,
+        (m, c) -> !SERVICES_TO_EXCLUDE.contains(m.getServiceName()));
+  }
+
+  private static void registerObservabilityViews() {
+    ViewManager viewManager = Stats.getViewManager();
+
+    // client views
+    viewManager.registerView(RpcViewConstants.GRPC_CLIENT_COMPLETED_RPC_VIEW);
+    viewManager.registerView(RpcViewConstants.GRPC_CLIENT_STARTED_RPC_VIEW);
+    viewManager.registerView(RpcViewConstants.GRPC_CLIENT_ROUNDTRIP_LATENCY_VIEW);
+    viewManager.registerView(ObservabilityCensusConstants.GRPC_CLIENT_API_LATENCY_VIEW);
+    viewManager.registerView(
+        ObservabilityCensusConstants.GRPC_CLIENT_SENT_COMPRESSED_MESSAGE_BYTES_PER_RPC_VIEW);
+    viewManager.registerView(
+        ObservabilityCensusConstants.GRPC_CLIENT_RECEIVED_COMPRESSED_MESSAGE_BYTES_PER_RPC_VIEW);
+
+    // server views
+    viewManager.registerView(RpcViewConstants.GRPC_SERVER_COMPLETED_RPC_VIEW);
+    viewManager.registerView(RpcViewConstants.GRPC_SERVER_STARTED_RPC_VIEW);
+    viewManager.registerView(RpcViewConstants.GRPC_SERVER_SERVER_LATENCY_VIEW);
+    viewManager.registerView(
+        ObservabilityCensusConstants.GRPC_SERVER_SENT_COMPRESSED_MESSAGE_BYTES_PER_RPC_VIEW);
+    viewManager.registerView(
+        ObservabilityCensusConstants.GRPC_SERVER_RECEIVED_COMPRESSED_MESSAGE_BYTES_PER_RPC_VIEW);
+  }
+
+  @VisibleForTesting
+  void registerStackDriverExporter(String projectId, Map<String, String> customTags)
+      throws IOException {
+    if (config.isEnableCloudMonitoring()) {
+      registerObservabilityViews();
+      StackdriverStatsConfiguration.Builder statsConfigurationBuilder =
+          StackdriverStatsConfiguration.builder();
+      if (projectId != null) {
+        statsConfigurationBuilder.setProjectId(projectId);
+      }
+      Map<LabelKey, LabelValue> constantLabels = new HashMap<>();
+      constantLabels.put(
+          LabelKey.create(DEFAULT_METRIC_CUSTOM_TAG_KEY, DEFAULT_METRIC_CUSTOM_TAG_KEY),
+          LabelValue.create(generateDefaultMetricTagValue()));
+      if (customTags != null) {
+        for (Map.Entry<String, String> mapEntry : customTags.entrySet()) {
+          constantLabels.putIfAbsent(LabelKey.create(mapEntry.getKey(), mapEntry.getKey()),
+              LabelValue.create(mapEntry.getValue()));
+        }
+      }
+      statsConfigurationBuilder.setConstantLabels(constantLabels);
+      statsConfigurationBuilder.setExportInterval(Duration.create(METRICS_EXPORT_INTERVAL, 0));
+      StackdriverStatsExporter.createAndRegister(statsConfigurationBuilder.build());
+    }
+
+    if (config.isEnableCloudTracing()) {
+      TraceConfig traceConfig = Tracing.getTraceConfig();
+      traceConfig.updateActiveTraceParams(
+          traceConfig.getActiveTraceParams().toBuilder().setSampler(config.getSampler()).build());
+      StackdriverTraceConfiguration.Builder traceConfigurationBuilder =
+          StackdriverTraceConfiguration.builder();
+      if (projectId != null) {
+        traceConfigurationBuilder.setProjectId(projectId);
+      }
+      if (customTags != null) {
+        Map<String, AttributeValue> fixedAttributes = customTags.entrySet().stream()
+            .collect(Collectors.toMap(e -> e.getKey(),
+                e -> AttributeValue.stringAttributeValue(e.getValue())));
+        traceConfigurationBuilder.setFixedAttributes(fixedAttributes);
+      }
+      StackdriverTraceExporter.createAndRegister(traceConfigurationBuilder.build());
+    }
+  }
+
+  private static String generateDefaultMetricTagValue() {
+    final String jvmName = ManagementFactory.getRuntimeMXBean().getName();
+    if (jvmName.indexOf('@') < 1) {
+      String hostname = "localhost";
+      try {
+        hostname = InetAddress.getLocalHost().getHostName();
+      } catch (UnknownHostException e) {
+        logger.log(Level.INFO, "Unable to get the hostname.", e);
+      }
+      return "java-" + new SecureRandom().nextInt() + "@" + hostname;
+    }
+    return "java-" + jvmName;
+  }
+
+  private GcpObservability(
+      Sink sink,
+      ObservabilityConfig config) {
+    this.sink = checkNotNull(sink);
+    this.config = checkNotNull(config);
+  }
+}
diff --git a/gcp-observability/src/main/java/io/grpc/gcp/observability/ObservabilityConfig.java b/gcp-observability/src/main/java/io/grpc/gcp/observability/ObservabilityConfig.java
new file mode 100644
index 00000000000..0489c8b5e3b
--- /dev/null
+++ b/gcp-observability/src/main/java/io/grpc/gcp/observability/ObservabilityConfig.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2022 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.gcp.observability;
+
+import io.grpc.Internal;
+import io.opencensus.trace.Sampler;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.concurrent.ThreadSafe;
+
+@Internal
+public interface ObservabilityConfig {
+  /** Is Cloud Logging enabled. */
+  boolean isEnableCloudLogging();
+
+  /** Is Cloud Monitoring enabled. */
+  boolean isEnableCloudMonitoring();
+
+  /** Is Cloud Tracing enabled. */
+  boolean isEnableCloudTracing();
+
+  /** Get project ID - where logs will go. */
+  String getProjectId();
+
+  /** Get filters for client logging. */
+  List<LogFilter> getClientLogFilters();
+
+  /** Get filters for server logging. */
+  List<LogFilter> getServerLogFilters();
+
+  /** Get sampler for TraceConfig - when Cloud Tracing is enabled. */
+  Sampler getSampler();
+
+  /** Map of all custom tags used for logging, metrics and traces. */
+  Map<String, String> getCustomTags();
+
+  /**
+   * POJO for representing a filter used in configuration.
+   */
+  @ThreadSafe
+  class LogFilter {
+    /** Set of services. */
+    public final Set<String> services;
+
+    /* Set of fullMethodNames. */
+    public final Set<String> methods;
+
+    /** Boolean to indicate all services and methods. */
+    public final boolean matchAll;
+
+    /** Number of bytes of header to log. */
+    public final int headerBytes;
+
+    /** Number of bytes of message to log. */
+    public final int messageBytes;
+
+    /** Boolean to indicate if services and methods matching pattern needs to be excluded. */
+    public final boolean excludePattern;
+
+    /**
+     * Object used to represent filter used in configuration.
+     * @param services Set of services derived from pattern
+     * @param serviceMethods Set of fullMethodNames derived from pattern
+     * @param matchAll If true, match all services and methods
+     * @param headerBytes Total number of bytes of header to log
+     * @param messageBytes Total number of bytes of  message to log
+     * @param excludePattern If true, services and methods matching pattern be excluded
+     */
+    public LogFilter(Set<String> services, Set<String> serviceMethods, boolean matchAll,
+        int headerBytes, int messageBytes,
+        boolean excludePattern) {
+      this.services = services;
+      this.methods = serviceMethods;
+      this.matchAll = matchAll;
+      this.headerBytes = headerBytes;
+      this.messageBytes = messageBytes;
+      this.excludePattern = excludePattern;
+    }
+  }
+}
diff --git a/gcp-observability/src/main/java/io/grpc/gcp/observability/ObservabilityConfigImpl.java b/gcp-observability/src/main/java/io/grpc/gcp/observability/ObservabilityConfigImpl.java
new file mode 100644
index 00000000000..ae74bf10c43
--- /dev/null
+++ b/gcp-observability/src/main/java/io/grpc/gcp/observability/ObservabilityConfigImpl.java
@@ -0,0 +1,276 @@
+/*
+ * Copyright 2022 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.gcp.observability;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.cloud.ServiceOptions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import io.grpc.internal.JsonParser;
+import io.grpc.internal.JsonUtil;
+import io.opencensus.trace.Sampler;
+import io.opencensus.trace.samplers.Samplers;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * gRPC GcpObservability configuration processor.
+ */
+final class ObservabilityConfigImpl implements ObservabilityConfig {
+  private static final Logger logger = Logger
+      .getLogger(ObservabilityConfigImpl.class.getName());
+  private static final String CONFIG_ENV_VAR_NAME = "GRPC_GCP_OBSERVABILITY_CONFIG";
+  private static final String CONFIG_FILE_ENV_VAR_NAME = "GRPC_GCP_OBSERVABILITY_CONFIG_FILE";
+  // Tolerance for floating-point comparisons.
+  private static final double EPSILON = 1e-6;
+
+  private static final Pattern METHOD_NAME_REGEX =
+      Pattern.compile("^([*])|((([\\w.]+)/((?:\\w+)|[*])))$");
+
+  private boolean enableCloudLogging = false;
+  private boolean enableCloudMonitoring = false;
+  private boolean enableCloudTracing = false;
+  private String projectId = null;
+
+  private List<LogFilter> clientLogFilters;
+  private List<LogFilter> serverLogFilters;
+  private Sampler sampler;
+  private Map<String, String> customTags;
+
+  static ObservabilityConfigImpl getInstance() throws IOException {
+    ObservabilityConfigImpl config = new ObservabilityConfigImpl();
+    String configFile = System.getenv(CONFIG_FILE_ENV_VAR_NAME);
+    if (configFile != null) {
+      config.parseFile(configFile);
+    } else {
+      config.parse(System.getenv(CONFIG_ENV_VAR_NAME));
+    }
+    return config;
+  }
+
+  void parseFile(String configFile) throws IOException {
+    String configFileContent =
+        new String(Files.readAllBytes(Paths.get(configFile)), StandardCharsets.UTF_8);
+    checkArgument(!configFileContent.isEmpty(), CONFIG_FILE_ENV_VAR_NAME + " is empty!");
+    parse(configFileContent);
+  }
+
+  @SuppressWarnings("unchecked")
+  void parse(String config) throws IOException {
+    checkArgument(config != null, CONFIG_ENV_VAR_NAME + " value is null!");
+    parseConfig((Map<String, ?>) JsonParser.parse(config));
+  }
+
+  private void parseConfig(Map<String, ?> config) {
+    checkArgument(config != null, "Invalid configuration");
+    if (config.isEmpty()) {
+      clientLogFilters = Collections.emptyList();
+      serverLogFilters = Collections.emptyList();
+      customTags = Collections.emptyMap();
+      return;
+    }
+    projectId = fetchProjectId(JsonUtil.getString(config, "project_id"));
+
+    Map<String, ?> rawCloudLoggingObject = JsonUtil.getObject(config, "cloud_logging");
+    if (rawCloudLoggingObject != null) {
+      enableCloudLogging = true;
+      ImmutableList.Builder<LogFilter> clientFiltersBuilder = new ImmutableList.Builder<>();
+      ImmutableList.Builder<LogFilter> serverFiltersBuilder = new ImmutableList.Builder<>();
+      parseLoggingObject(rawCloudLoggingObject, clientFiltersBuilder, serverFiltersBuilder);
+      clientLogFilters = clientFiltersBuilder.build();
+      serverLogFilters = serverFiltersBuilder.build();
+    }
+
+    Map<String, ?> rawCloudMonitoringObject = JsonUtil.getObject(config, "cloud_monitoring");
+    if (rawCloudMonitoringObject != null) {
+      enableCloudMonitoring = true;
+    }
+
+    Map<String, ?> rawCloudTracingObject = JsonUtil.getObject(config, "cloud_trace");
+    if (rawCloudTracingObject != null) {
+      enableCloudTracing = true;
+      sampler = parseTracingObject(rawCloudTracingObject);
+    }
+
+    Map<String, ?> rawCustomTagsObject = JsonUtil.getObject(config, "labels");
+    if (rawCustomTagsObject != null) {
+      customTags = parseCustomTags(rawCustomTagsObject);
+    }
+
+    if (clientLogFilters == null) {
+      clientLogFilters = Collections.emptyList();
+    }
+    if (serverLogFilters == null) {
+      serverLogFilters = Collections.emptyList();
+    }
+    if (customTags == null) {
+      customTags = Collections.emptyMap();
+    }
+  }
+
+  private static String fetchProjectId(String configProjectId) {
+    // If project_id is not specified in config, get default GCP project id from the environment
+    String projectId = configProjectId != null ? configProjectId : getDefaultGcpProjectId();
+    checkArgument(projectId != null, "Unable to detect project_id");
+    logger.log(Level.FINEST, "Found project ID : ", projectId);
+    return projectId;
+  }
+
+  private static String getDefaultGcpProjectId() {
+    return ServiceOptions.getDefaultProjectId();
+  }
+
+  private static void parseLoggingObject(
+      Map<String, ?> rawLoggingConfig,
+      ImmutableList.Builder<LogFilter> clientFilters,
+      ImmutableList.Builder<LogFilter> serverFilters) {
+    parseRpcEvents(JsonUtil.getList(rawLoggingConfig, "client_rpc_events"), clientFilters);
+    parseRpcEvents(JsonUtil.getList(rawLoggingConfig, "server_rpc_events"), serverFilters);
+  }
+
+  private static Sampler parseTracingObject(Map<String, ?> rawCloudTracingConfig) {
+    Sampler defaultSampler = Samplers.probabilitySampler(0.0);
+    Double samplingRate = JsonUtil.getNumberAsDouble(rawCloudTracingConfig, "sampling_rate");
+    if (samplingRate == null) {
+      return defaultSampler;
+    }
+    checkArgument(samplingRate >= 0.0 && samplingRate <= 1.0,
+        "'sampling_rate' needs to be between [0.0, 1.0]");
+    // Using alwaysSample() instead of probabilitySampler() because according to
+    // {@link io.opencensus.trace.samplers.ProbabilitySampler#shouldSample}
+    // there is a (very) small chance of *not* sampling if probability = 1.00.
+    return 1 - samplingRate < EPSILON ? Samplers.alwaysSample()
+        : Samplers.probabilitySampler(samplingRate);
+  }
+
+  private static Map<String, String> parseCustomTags(Map<String, ?> rawCustomTags) {
+    ImmutableMap.Builder<String, String> builder = new ImmutableMap.Builder<>();
+    for (Map.Entry<String, ?> entry: rawCustomTags.entrySet()) {
+      checkArgument(
+          entry.getValue() instanceof String,
+          "'labels' needs to be a map of <string, string>");
+      builder.put(entry.getKey(), (String) entry.getValue());
+    }
+    return builder.build();
+  }
+
+  private static void parseRpcEvents(List<?> rpcEvents, ImmutableList.Builder<LogFilter> filters) {
+    if (rpcEvents == null) {
+      return;
+    }
+    List<Map<String, ?>> jsonRpcEvents = JsonUtil.checkObjectList(rpcEvents);
+    for (Map<String, ?> jsonClientRpcEvent : jsonRpcEvents) {
+      filters.add(parseJsonLogFilter(jsonClientRpcEvent));
+    }
+  }
+
+  private static LogFilter parseJsonLogFilter(Map<String, ?> logFilterMap) {
+    ImmutableSet.Builder<String> servicesSetBuilder = new ImmutableSet.Builder<>();
+    ImmutableSet.Builder<String> methodsSetBuilder = new ImmutableSet.Builder<>();
+    boolean wildCardFilter = false;
+
+    boolean excludeFilter =
+        Boolean.TRUE.equals(JsonUtil.getBoolean(logFilterMap, "exclude"));
+    List<String> methodsList = JsonUtil.getListOfStrings(logFilterMap, "methods");
+    if (methodsList != null) {
+      wildCardFilter = extractMethodOrServicePattern(
+              methodsList, excludeFilter, servicesSetBuilder, methodsSetBuilder);
+    }
+    Integer maxHeaderBytes = JsonUtil.getNumberAsInteger(logFilterMap, "max_metadata_bytes");
+    Integer maxMessageBytes = JsonUtil.getNumberAsInteger(logFilterMap, "max_message_bytes");
+
+    return new LogFilter(
+        servicesSetBuilder.build(),
+        methodsSetBuilder.build(),
+        wildCardFilter,
+        maxHeaderBytes != null ? maxHeaderBytes.intValue() : 0,
+        maxMessageBytes != null ? maxMessageBytes.intValue() : 0,
+        excludeFilter);
+  }
+
+  private static boolean extractMethodOrServicePattern(List<String> patternList, boolean exclude,
+      ImmutableSet.Builder<String> servicesSetBuilder,
+      ImmutableSet.Builder<String> methodsSetBuilder) {
+    boolean globalFilter = false;
+    for (String methodOrServicePattern : patternList) {
+      Matcher matcher = METHOD_NAME_REGEX.matcher(methodOrServicePattern);
+      checkArgument(
+          matcher.matches(), "invalid service or method filter : " + methodOrServicePattern);
+      if ("*".equals(methodOrServicePattern)) {
+        checkArgument(!exclude, "cannot have 'exclude' and '*' wildcard in the same filter");
+        globalFilter = true;
+      } else if ("*".equals(matcher.group(5))) {
+        String service = matcher.group(4);
+        servicesSetBuilder.add(service);
+      } else {
+        methodsSetBuilder.add(methodOrServicePattern);
+      }
+    }
+    return globalFilter;
+  }
+
+  @Override
+  public boolean isEnableCloudLogging() {
+    return enableCloudLogging;
+  }
+
+  @Override
+  public boolean isEnableCloudMonitoring() {
+    return enableCloudMonitoring;
+  }
+
+  @Override
+  public boolean isEnableCloudTracing() {
+    return enableCloudTracing;
+  }
+
+  @Override
+  public String getProjectId() {
+    return projectId;
+  }
+
+  @Override
+  public List<LogFilter> getClientLogFilters() {
+    return clientLogFilters;
+  }
+
+  @Override
+  public List<LogFilter> getServerLogFilters() {
+    return serverLogFilters;
+  }
+
+  @Override
+  public Sampler getSampler() {
+    return sampler;
+  }
+
+  @Override
+  public Map<String, String> getCustomTags() {
+    return customTags;
+  }
+}
diff --git a/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/ConditionalClientInterceptor.java b/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/ConditionalClientInterceptor.java
new file mode 100644
index 00000000000..5051453ce0e
--- /dev/null
+++ b/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/ConditionalClientInterceptor.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2022 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.gcp.observability.interceptors;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.Internal;
+import io.grpc.MethodDescriptor;
+import java.util.function.BiPredicate;
+
+/**
+ * A client interceptor that conditionally calls a delegated interceptor.
+ */
+@Internal
+public final class ConditionalClientInterceptor implements ClientInterceptor {
+
+  private final ClientInterceptor delegate;
+  private final BiPredicate<MethodDescriptor<?, ?>, CallOptions> predicate;
+
+  public ConditionalClientInterceptor(ClientInterceptor delegate,
+      BiPredicate<MethodDescriptor<?, ?>, CallOptions> predicate) {
+    this.delegate = checkNotNull(delegate, "delegate");
+    this.predicate = checkNotNull(predicate, "predicate");
+  }
+
+  @Override
+  public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method,
+      CallOptions callOptions, Channel next) {
+    if (!predicate.test(method, callOptions)) {
+      return next.newCall(method, callOptions);
+    }
+    return delegate.interceptCall(method, callOptions, next);
+  }
+}
diff --git a/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/ConfigFilterHelper.java b/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/ConfigFilterHelper.java
new file mode 100644
index 00000000000..9b05634dbfe
--- /dev/null
+++ b/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/ConfigFilterHelper.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2022 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.gcp.observability.interceptors;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Internal;
+import io.grpc.gcp.observability.ObservabilityConfig;
+import io.grpc.gcp.observability.ObservabilityConfig.LogFilter;
+import java.util.List;
+
+/**
+ * Parses gRPC GcpObservability configuration filters for interceptors usage.
+ */
+@Internal
+public class ConfigFilterHelper {
+  public static final FilterParams NO_FILTER_PARAMS
+      = FilterParams.create(false, 0, 0);
+
+  private final ObservabilityConfig config;
+
+  private ConfigFilterHelper(ObservabilityConfig config) {
+    this.config = config;
+  }
+
+  /**
+   * Creates and returns helper instance for log filtering.
+   *
+   * @param config processed ObservabilityConfig object
+   * @return helper instance for filtering
+   */
+  public static ConfigFilterHelper getInstance(ObservabilityConfig config) {
+    return new ConfigFilterHelper(config);
+  }
+
+
+  /**
+   * Checks if the corresponding service/method passed needs to be logged according to user provided
+   * observability configuration.
+   * Filters are evaluated in text order, first match is used.
+   *
+   * @param fullMethodName the fully qualified name of the method
+   * @param client set to true if method being checked is a client method; false otherwise
+   * @return FilterParams object 1. specifies if the corresponding method needs to be logged
+   *     (log field will be set to true) 2. values of payload limits retrieved from configuration
+   */
+  public FilterParams logRpcMethod(String fullMethodName, boolean client) {
+    FilterParams params = NO_FILTER_PARAMS;
+
+    int index = checkNotNull(fullMethodName, "fullMethodName").lastIndexOf('/');
+    String serviceName = fullMethodName.substring(0, index);
+
+    List<LogFilter> logFilters =
+        client ? config.getClientLogFilters() : config.getServerLogFilters();
+
+    // TODO (dnvindhya): Optimize by caching results for fullMethodName.
+    for (LogFilter logFilter : logFilters) {
+      if (logFilter.matchAll
+          || logFilter.services.contains(serviceName)
+          || logFilter.methods.contains(fullMethodName)) {
+        if (logFilter.excludePattern) {
+          return params;
+        }
+        int currentHeaderBytes = logFilter.headerBytes;
+        int currentMessageBytes = logFilter.messageBytes;
+        return FilterParams.create(true, currentHeaderBytes, currentMessageBytes);
+      }
+    }
+    return params;
+  }
+
+  /**
+   * Class containing results for method/service filter information, such as flag for logging
+   * method/service and payload limits to be used for filtering.
+   */
+  @AutoValue
+  public abstract static class FilterParams {
+
+    abstract boolean log();
+
+    abstract int headerBytes();
+
+    abstract int messageBytes();
+
+    @VisibleForTesting
+    public static FilterParams create(boolean log, int headerBytes, int messageBytes) {
+      return new AutoValue_ConfigFilterHelper_FilterParams(
+          log, headerBytes, messageBytes);
+    }
+  }
+}
diff --git a/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/InetAddressUtil.java b/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/InetAddressUtil.java
new file mode 100644
index 00000000000..376ada4f736
--- /dev/null
+++ b/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/InetAddressUtil.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2022 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.gcp.observability.interceptors;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.primitives.Ints;
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.util.Arrays;
+
+// This is copied from guava 20.0 because it is a @Beta api
+final class InetAddressUtil {
+  private static final int IPV6_PART_COUNT = 8;
+
+  public static String toAddrString(InetAddress ip) {
+    checkNotNull(ip);
+    if (ip instanceof Inet4Address) {
+      // For IPv4, Java's formatting is good enough.
+      return ip.getHostAddress();
+    }
+    checkArgument(ip instanceof Inet6Address);
+    byte[] bytes = ip.getAddress();
+    int[] hextets = new int[IPV6_PART_COUNT];
+    for (int i = 0; i < hextets.length; i++) {
+      hextets[i] = Ints.fromBytes((byte) 0, (byte) 0, bytes[2 * i], bytes[2 * i + 1]);
+    }
+    compressLongestRunOfZeroes(hextets);
+    return hextetsToIPv6String(hextets);
+  }
+
+  private static void compressLongestRunOfZeroes(int[] hextets) {
+    int bestRunStart = -1;
+    int bestRunLength = -1;
+    int runStart = -1;
+    for (int i = 0; i < hextets.length + 1; i++) {
+      if (i < hextets.length && hextets[i] == 0) {
+        if (runStart < 0) {
+          runStart = i;
+        }
+      } else if (runStart >= 0) {
+        int runLength = i - runStart;
+        if (runLength > bestRunLength) {
+          bestRunStart = runStart;
+          bestRunLength = runLength;
+        }
+        runStart = -1;
+      }
+    }
+    if (bestRunLength >= 2) {
+      Arrays.fill(hextets, bestRunStart, bestRunStart + bestRunLength, -1);
+    }
+  }
+
+  private static String hextetsToIPv6String(int[] hextets) {
+    // While scanning the array, handle these state transitions:
+    //   start->num => "num"     start->gap => "::"
+    //   num->num   => ":num"    num->gap   => "::"
+    //   gap->num   => "num"     gap->gap   => ""
+    StringBuilder buf = new StringBuilder(39);
+    boolean lastWasNumber = false;
+    for (int i = 0; i < hextets.length; i++) {
+      boolean thisIsNumber = hextets[i] >= 0;
+      if (thisIsNumber) {
+        if (lastWasNumber) {
+          buf.append(':');
+        }
+        buf.append(Integer.toHexString(hextets[i]));
+      } else {
+        if (i == 0 || lastWasNumber) {
+          buf.append("::");
+        }
+      }
+      lastWasNumber = thisIsNumber;
+    }
+    return buf.toString();
+  }
+}
diff --git a/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/InternalLoggingChannelInterceptor.java b/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/InternalLoggingChannelInterceptor.java
new file mode 100644
index 00000000000..f5082564df0
--- /dev/null
+++ b/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/InternalLoggingChannelInterceptor.java
@@ -0,0 +1,268 @@
+/*
+ * Copyright 2022 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.gcp.observability.interceptors;
+
+import static io.grpc.census.internal.ObservabilityCensusConstants.CLIENT_TRACE_SPAN_CONTEXT_KEY;
+
+import com.google.protobuf.Duration;
+import com.google.protobuf.util.Durations;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.Context;
+import io.grpc.Deadline;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
+import io.grpc.Internal;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.grpc.gcp.observability.interceptors.ConfigFilterHelper.FilterParams;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventLogger;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventType;
+import io.opencensus.trace.SpanContext;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A logging client interceptor for Observability.
+ */
+@Internal
+public final class InternalLoggingChannelInterceptor implements ClientInterceptor {
+
+  private static final Logger logger = Logger
+      .getLogger(InternalLoggingChannelInterceptor.class.getName());
+
+  private final LogHelper helper;
+  private final ConfigFilterHelper filterHelper;
+
+  // TODO(dnvindhya): Remove factory and use interceptors directly
+  public interface Factory {
+    ClientInterceptor create();
+  }
+
+  public static class FactoryImpl implements Factory {
+
+    private final LogHelper helper;
+    private final ConfigFilterHelper filterHelper;
+
+    /**
+     * Create the {@link Factory} we need to create our {@link ClientInterceptor}s.
+     */
+    public FactoryImpl(LogHelper helper, ConfigFilterHelper filterHelper) {
+      this.helper = helper;
+      this.filterHelper = filterHelper;
+    }
+
+    @Override
+    public ClientInterceptor create() {
+      return new InternalLoggingChannelInterceptor(helper, filterHelper);
+    }
+  }
+
+  private InternalLoggingChannelInterceptor(LogHelper helper, ConfigFilterHelper filterHelper) {
+    this.helper = helper;
+    this.filterHelper = filterHelper;
+  }
+
+  @Override
+  public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method,
+      CallOptions callOptions, Channel next) {
+
+    final AtomicLong seq = new AtomicLong(1);
+    final String callId = UUID.randomUUID().toString();
+    final String authority = next.authority();
+    final String serviceName = method.getServiceName();
+    final String methodName = method.getBareMethodName();
+    // Get the stricter deadline to calculate the timeout once the call starts
+    final Deadline deadline = LogHelper.min(callOptions.getDeadline(),
+        Context.current().getDeadline());
+    final SpanContext clientSpanContext = callOptions.getOption(CLIENT_TRACE_SPAN_CONTEXT_KEY);
+
+    FilterParams filterParams = filterHelper.logRpcMethod(method.getFullMethodName(), true);
+    if (!filterParams.log()) {
+      return next.newCall(method, callOptions);
+    }
+
+    final int maxHeaderBytes = filterParams.headerBytes();
+    final int maxMessageBytes = filterParams.messageBytes();
+
+    return new SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {
+
+      @Override
+      public void start(Listener<RespT> responseListener, Metadata headers) {
+        // Event: EventType.CLIENT_HEADER
+        // The timeout should reflect the time remaining when the call is started, so compute
+        // remaining time here.
+        final Duration timeout = deadline == null ? null
+            : Durations.fromNanos(deadline.timeRemaining(TimeUnit.NANOSECONDS));
+
+        try {
+          helper.logClientHeader(
+              seq.getAndIncrement(),
+              serviceName,
+              methodName,
+              authority,
+              timeout,
+              headers,
+              maxHeaderBytes,
+              EventLogger.CLIENT,
+              callId,
+              null,
+              clientSpanContext);
+        } catch (Exception e) {
+          // Catching generic exceptions instead of specific ones for all the events.
+          // This way we can catch both expected and unexpected exceptions instead of re-throwing
+          // exceptions to callers which will lead to RPC getting aborted.
+          // Expected exceptions to be caught:
+          // 1. IllegalArgumentException
+          // 2. NullPointerException
+          logger.log(Level.SEVERE, "Unable to log request header", e);
+        }
+
+        Listener<RespT> observabilityListener =
+            new SimpleForwardingClientCallListener<RespT>(responseListener) {
+              @Override
+              public void onMessage(RespT message) {
+                // Event: EventType.SERVER_MESSAGE
+                try {
+                  helper.logRpcMessage(
+                      seq.getAndIncrement(),
+                      serviceName,
+                      methodName,
+                      authority,
+                      EventType.SERVER_MESSAGE,
+                      message,
+                      maxMessageBytes,
+                      EventLogger.CLIENT,
+                      callId,
+                      clientSpanContext);
+                } catch (Exception e) {
+                  logger.log(Level.SEVERE, "Unable to log response message", e);
+                }
+                super.onMessage(message);
+              }
+
+              @Override
+              public void onHeaders(Metadata headers) {
+                // Event: EventType.SERVER_HEADER
+                try {
+                  helper.logServerHeader(
+                      seq.getAndIncrement(),
+                      serviceName,
+                      methodName,
+                      authority,
+                      headers,
+                      maxHeaderBytes,
+                      EventLogger.CLIENT,
+                      callId,
+                      LogHelper.getPeerAddress(getAttributes()),
+                      clientSpanContext);
+                } catch (Exception e) {
+                  logger.log(Level.SEVERE, "Unable to log response header", e);
+                }
+                super.onHeaders(headers);
+              }
+
+              @Override
+              public void onClose(Status status, Metadata trailers) {
+                // Event: EventType.SERVER_TRAILER
+                try {
+                  helper.logTrailer(
+                      seq.getAndIncrement(),
+                      serviceName,
+                      methodName,
+                      authority,
+                      status,
+                      trailers,
+                      maxHeaderBytes,
+                      EventLogger.CLIENT,
+                      callId,
+                      LogHelper.getPeerAddress(getAttributes()),
+                      clientSpanContext);
+                } catch (Exception e) {
+                  logger.log(Level.SEVERE, "Unable to log trailer", e);
+                }
+                super.onClose(status, trailers);
+              }
+            };
+        super.start(observabilityListener, headers);
+      }
+
+      @Override
+      public void sendMessage(ReqT message) {
+        // Event: EventType.CLIENT_MESSAGE
+        try {
+          helper.logRpcMessage(
+              seq.getAndIncrement(),
+              serviceName,
+              methodName,
+              authority,
+              EventType.CLIENT_MESSAGE,
+              message,
+              maxMessageBytes,
+              EventLogger.CLIENT,
+              callId,
+              clientSpanContext);
+        } catch (Exception e) {
+          logger.log(Level.SEVERE, "Unable to log request message", e);
+        }
+        super.sendMessage(message);
+      }
+
+      @Override
+      public void halfClose() {
+        // Event: EventType.CLIENT_HALF_CLOSE
+        try {
+          helper.logHalfClose(
+              seq.getAndIncrement(),
+              serviceName,
+              methodName,
+              authority,
+              EventLogger.CLIENT,
+              callId,
+              clientSpanContext);
+        } catch (Exception e) {
+          logger.log(Level.SEVERE, "Unable to log half close", e);
+        }
+        super.halfClose();
+      }
+
+      @Override
+      public void cancel(String message, Throwable cause) {
+        // Event: EventType.CANCEL
+        try {
+          helper.logCancel(
+              seq.getAndIncrement(),
+              serviceName,
+              methodName,
+              authority,
+              EventLogger.CLIENT,
+              callId,
+              clientSpanContext);
+        } catch (Exception e) {
+          logger.log(Level.SEVERE, "Unable to log cancel", e);
+        }
+        super.cancel(message, cause);
+      }
+    };
+  }
+}
diff --git a/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/InternalLoggingServerInterceptor.java b/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/InternalLoggingServerInterceptor.java
new file mode 100644
index 00000000000..78d488ef58f
--- /dev/null
+++ b/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/InternalLoggingServerInterceptor.java
@@ -0,0 +1,263 @@
+/*
+ * Copyright 2022 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.gcp.observability.interceptors;
+
+import com.google.protobuf.Duration;
+import com.google.protobuf.util.Durations;
+import io.grpc.Context;
+import io.grpc.Deadline;
+import io.grpc.ForwardingServerCall.SimpleForwardingServerCall;
+import io.grpc.ForwardingServerCallListener.SimpleForwardingServerCallListener;
+import io.grpc.Internal;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.Status;
+import io.grpc.gcp.observability.interceptors.ConfigFilterHelper.FilterParams;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventLogger;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventType;
+import io.opencensus.trace.Span;
+import io.opencensus.trace.SpanContext;
+import io.opencensus.trace.unsafe.ContextHandleUtils;
+import java.net.SocketAddress;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A logging server interceptor for Observability.
+ */
+@Internal
+public final class InternalLoggingServerInterceptor implements ServerInterceptor {
+
+  private static final Logger logger = Logger
+      .getLogger(InternalLoggingServerInterceptor.class.getName());
+
+  private final LogHelper helper;
+  private final ConfigFilterHelper filterHelper;
+
+  // TODO(dnvindhya): Remove factory and use interceptors directly
+  public interface Factory {
+    ServerInterceptor create();
+  }
+
+  public static class FactoryImpl implements Factory {
+
+    private final LogHelper helper;
+    private final ConfigFilterHelper filterHelper;
+
+    /**
+     * Create the {@link Factory} we need to create our {@link ServerInterceptor}s.
+     */
+    public FactoryImpl(LogHelper helper, ConfigFilterHelper filterHelper) {
+      this.helper = helper;
+      this.filterHelper = filterHelper;
+    }
+
+    @Override
+    public ServerInterceptor create() {
+      return new InternalLoggingServerInterceptor(helper, filterHelper);
+    }
+  }
+
+  private InternalLoggingServerInterceptor(LogHelper helper, ConfigFilterHelper filterHelper) {
+    this.helper = helper;
+    this.filterHelper = filterHelper;
+  }
+
+  @Override
+  public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+      Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+    final AtomicLong seq = new AtomicLong(1);
+    final String callId = UUID.randomUUID().toString();
+    final String authority = call.getAuthority();
+    final String serviceName = call.getMethodDescriptor().getServiceName();
+    final String methodName = call.getMethodDescriptor().getBareMethodName();
+    final SocketAddress peerAddress = LogHelper.getPeerAddress(call.getAttributes());
+    Deadline deadline = Context.current().getDeadline();
+    final Duration timeout = deadline == null ? null
+        : Durations.fromNanos(deadline.timeRemaining(TimeUnit.NANOSECONDS));
+    Span span = ContextHandleUtils.getValue(ContextHandleUtils.currentContext());
+    final SpanContext serverSpanContext = span == null ? SpanContext.INVALID : span.getContext();
+
+    FilterParams filterParams =
+        filterHelper.logRpcMethod(call.getMethodDescriptor().getFullMethodName(), false);
+    if (!filterParams.log()) {
+      return next.startCall(call, headers);
+    }
+
+    final int maxHeaderBytes = filterParams.headerBytes();
+    final int maxMessageBytes = filterParams.messageBytes();
+
+    // Event: EventType.CLIENT_HEADER
+    try {
+      helper.logClientHeader(
+          seq.getAndIncrement(),
+          serviceName,
+          methodName,
+          authority,
+          timeout,
+          headers,
+          maxHeaderBytes,
+          EventLogger.SERVER,
+          callId,
+          peerAddress,
+          serverSpanContext);
+    } catch (Exception e) {
+      // Catching generic exceptions instead of specific ones for all the events.
+      // This way we can catch both expected and unexpected exceptions instead of re-throwing
+      // exceptions to callers which will lead to RPC getting aborted.
+      // Expected exceptions to be caught:
+      // 1. IllegalArgumentException
+      // 2. NullPointerException
+      logger.log(Level.SEVERE, "Unable to log request header", e);
+    }
+
+    ServerCall<ReqT, RespT> wrapperCall =
+        new SimpleForwardingServerCall<ReqT, RespT>(call) {
+          @Override
+          public void sendHeaders(Metadata headers) {
+            // Event: EventType.SERVER_HEADER
+            try {
+              helper.logServerHeader(
+                  seq.getAndIncrement(),
+                  serviceName,
+                  methodName,
+                  authority,
+                  headers,
+                  maxHeaderBytes,
+                  EventLogger.SERVER,
+                  callId,
+                  null,
+                  serverSpanContext);
+            } catch (Exception e) {
+              logger.log(Level.SEVERE, "Unable to log response header", e);
+            }
+            super.sendHeaders(headers);
+          }
+
+          @Override
+          public void sendMessage(RespT message) {
+            // Event: EventType.SERVER_MESSAGE
+            EventType responseMessageType = EventType.SERVER_MESSAGE;
+            try {
+              helper.logRpcMessage(
+                  seq.getAndIncrement(),
+                  serviceName,
+                  methodName,
+                  authority,
+                  responseMessageType,
+                  message,
+                  maxMessageBytes,
+                  EventLogger.SERVER,
+                  callId,
+                  serverSpanContext);
+            } catch (Exception e) {
+              logger.log(Level.SEVERE, "Unable to log response message", e);
+            }
+            super.sendMessage(message);
+          }
+
+          @Override
+          public void close(Status status, Metadata trailers) {
+            // Event: EventType.SERVER_TRAILER
+            try {
+              helper.logTrailer(
+                  seq.getAndIncrement(),
+                  serviceName,
+                  methodName,
+                  authority,
+                  status,
+                  trailers,
+                  maxHeaderBytes,
+                  EventLogger.SERVER,
+                  callId,
+                  null,
+                  serverSpanContext);
+            } catch (Exception e) {
+              logger.log(Level.SEVERE, "Unable to log trailer", e);
+            }
+            super.close(status, trailers);
+          }
+        };
+
+    ServerCall.Listener<ReqT> listener = next.startCall(wrapperCall, headers);
+    return new SimpleForwardingServerCallListener<ReqT>(listener) {
+      @Override
+      public void onMessage(ReqT message) {
+
+        // Event: EventType.CLIENT_MESSAGE
+        EventType requestMessageType = EventType.CLIENT_MESSAGE;
+        try {
+          helper.logRpcMessage(
+              seq.getAndIncrement(),
+              serviceName,
+              methodName,
+              authority,
+              requestMessageType,
+              message,
+              maxMessageBytes,
+              EventLogger.SERVER,
+              callId,
+              serverSpanContext);
+        } catch (Exception e) {
+          logger.log(Level.SEVERE, "Unable to log request message", e);
+        }
+        super.onMessage(message);
+      }
+
+      @Override
+      public void onHalfClose() {
+        // Event: EventType.CLIENT_HALF_CLOSE
+        try {
+          helper.logHalfClose(
+              seq.getAndIncrement(),
+              serviceName,
+              methodName,
+              authority,
+              EventLogger.SERVER,
+              callId,
+              serverSpanContext);
+        } catch (Exception e) {
+          logger.log(Level.SEVERE, "Unable to log half close", e);
+        }
+        super.onHalfClose();
+      }
+
+      @Override
+      public void onCancel() {
+        // Event: EventType.CANCEL
+        try {
+          helper.logCancel(
+              seq.getAndIncrement(),
+              serviceName,
+              methodName,
+              authority,
+              EventLogger.SERVER,
+              callId,
+              serverSpanContext);
+        } catch (Exception e) {
+          logger.log(Level.SEVERE, "Unable to log cancel", e);
+        }
+        super.onCancel();
+      }
+    };
+  }
+}
diff --git a/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/LogHelper.java b/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/LogHelper.java
new file mode 100644
index 00000000000..65b539a66f5
--- /dev/null
+++ b/gcp-observability/src/main/java/io/grpc/gcp/observability/interceptors/LogHelper.java
@@ -0,0 +1,455 @@
+/*
+ * Copyright 2022 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.gcp.observability.interceptors;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.InternalMetadata.BASE64_ENCODING_OMIT_PADDING;
+
+import com.google.common.base.Joiner;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.Duration;
+import com.google.rpc.Code;
+import io.grpc.Attributes;
+import io.grpc.Deadline;
+import io.grpc.Grpc;
+import io.grpc.Internal;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.gcp.observability.logging.Sink;
+import io.grpc.observabilitylog.v1.Address;
+import io.grpc.observabilitylog.v1.GrpcLogRecord;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventLogger;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventType;
+import io.grpc.observabilitylog.v1.Payload;
+import io.opencensus.trace.SpanContext;
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * Helper class for GCP observability logging.
+ */
+@Internal
+public class LogHelper {
+  private static final Logger logger = Logger.getLogger(LogHelper.class.getName());
+
+  // TODO(DNVindhya): Define it in one places(TBD) to make it easily accessible from everywhere
+  static final Metadata.Key<byte[]> STATUS_DETAILS_KEY =
+      Metadata.Key.of(
+          "grpc-status-details-bin",
+          Metadata.BINARY_BYTE_MARSHALLER);
+
+  private final Sink sink;
+
+  /**
+   * Creates a LogHelper instance.
+   *  @param sink sink
+   *
+   */
+  public LogHelper(Sink sink) {
+    this.sink = sink;
+  }
+
+  /**
+   * Logs the request header. Binary logging equivalent of logClientHeader.
+   */
+  void logClientHeader(
+      long seqId,
+      String serviceName,
+      String methodName,
+      String authority,
+      @Nullable Duration timeout,
+      Metadata metadata,
+      int maxHeaderBytes,
+      GrpcLogRecord.EventLogger eventLogger,
+      String callId,
+      // null on client side
+      @Nullable SocketAddress peerAddress,
+      SpanContext spanContext) {
+    checkNotNull(serviceName, "serviceName");
+    checkNotNull(methodName, "methodName");
+    checkNotNull(authority, "authority");
+    checkNotNull(callId, "callId");
+    checkArgument(
+        peerAddress == null || eventLogger == GrpcLogRecord.EventLogger.SERVER,
+        "peerAddress can only be specified by server");
+    PayloadBuilderHelper<Payload.Builder> pair =
+        createMetadataProto(metadata, maxHeaderBytes);
+    if (timeout != null) {
+      pair.payloadBuilder.setTimeout(timeout);
+    }
+    GrpcLogRecord.Builder logEntryBuilder = GrpcLogRecord.newBuilder()
+        .setSequenceId(seqId)
+        .setServiceName(serviceName)
+        .setMethodName(methodName)
+        .setAuthority(authority)
+        .setType(EventType.CLIENT_HEADER)
+        .setLogger(eventLogger)
+        .setPayload(pair.payloadBuilder)
+        .setPayloadTruncated(pair.truncated)
+        .setCallId(callId);
+    if (peerAddress != null) {
+      logEntryBuilder.setPeer(socketAddressToProto(peerAddress));
+    }
+    sink.write(logEntryBuilder.build(), spanContext);
+  }
+
+  /**
+   * Logs the response header. Binary logging equivalent of logServerHeader.
+   */
+  void logServerHeader(
+      long seqId,
+      String serviceName,
+      String methodName,
+      String authority,
+      Metadata metadata,
+      int maxHeaderBytes,
+      GrpcLogRecord.EventLogger eventLogger,
+      String callId,
+      @Nullable SocketAddress peerAddress,
+      SpanContext spanContext) {
+    checkNotNull(serviceName, "serviceName");
+    checkNotNull(methodName, "methodName");
+    checkNotNull(authority, "authority");
+    checkNotNull(callId, "callId");
+    // Logging peer address only on the first incoming event. On server side, peer address will
+    // of logging request header
+    checkArgument(
+        peerAddress == null || eventLogger == GrpcLogRecord.EventLogger.CLIENT,
+        "peerAddress can only be specified for client");
+
+    PayloadBuilderHelper<Payload.Builder> pair =
+        createMetadataProto(metadata, maxHeaderBytes);
+    GrpcLogRecord.Builder logEntryBuilder = GrpcLogRecord.newBuilder()
+        .setSequenceId(seqId)
+        .setServiceName(serviceName)
+        .setMethodName(methodName)
+        .setAuthority(authority)
+        .setType(EventType.SERVER_HEADER)
+        .setLogger(eventLogger)
+        .setPayload(pair.payloadBuilder)
+        .setPayloadTruncated(pair.truncated)
+        .setCallId(callId);
+    if (peerAddress != null) {
+      logEntryBuilder.setPeer(socketAddressToProto(peerAddress));
+    }
+    sink.write(logEntryBuilder.build(), spanContext);
+  }
+
+  /**
+   * Logs the server trailer.
+   */
+  void logTrailer(
+      long seqId,
+      String serviceName,
+      String methodName,
+      String authority,
+      Status status,
+      Metadata metadata,
+      int maxHeaderBytes,
+      GrpcLogRecord.EventLogger eventLogger,
+      String callId,
+      @Nullable SocketAddress peerAddress,
+      SpanContext spanContext) {
+    checkNotNull(serviceName, "serviceName");
+    checkNotNull(methodName, "methodName");
+    checkNotNull(authority, "authority");
+    checkNotNull(status, "status");
+    checkNotNull(callId, "callId");
+    checkArgument(
+        peerAddress == null || eventLogger == GrpcLogRecord.EventLogger.CLIENT,
+        "peerAddress can only be specified for client");
+
+    PayloadBuilderHelper<Payload.Builder> pair =
+        createMetadataProto(metadata, maxHeaderBytes);
+    pair.payloadBuilder.setStatusCode(Code.forNumber(status.getCode().value()));
+    String statusDescription = status.getDescription();
+    if (statusDescription != null) {
+      pair.payloadBuilder.setStatusMessage(statusDescription);
+    }
+    byte[] statusDetailBytes = metadata.get(STATUS_DETAILS_KEY);
+    if (statusDetailBytes != null) {
+      pair.payloadBuilder.setStatusDetails(ByteString.copyFrom(statusDetailBytes));
+    }
+    GrpcLogRecord.Builder logEntryBuilder = GrpcLogRecord.newBuilder()
+        .setSequenceId(seqId)
+        .setServiceName(serviceName)
+        .setMethodName(methodName)
+        .setAuthority(authority)
+        .setType(EventType.SERVER_TRAILER)
+        .setLogger(eventLogger)
+        .setPayload(pair.payloadBuilder)
+        .setPayloadTruncated(pair.truncated)
+        .setCallId(callId);
+    if (peerAddress != null) {
+      logEntryBuilder.setPeer(socketAddressToProto(peerAddress));
+    }
+    sink.write(logEntryBuilder.build(), spanContext);
+  }
+
+  /**
+   * Logs the RPC message.
+   */
+  <T> void logRpcMessage(
+      long seqId,
+      String serviceName,
+      String methodName,
+      String authority,
+      EventType eventType,
+      T message,
+      int maxMessageBytes,
+      EventLogger eventLogger,
+      String callId,
+      SpanContext spanContext) {
+    checkNotNull(serviceName, "serviceName");
+    checkNotNull(methodName, "methodName");
+    checkNotNull(authority, "authority");
+    checkNotNull(callId, "callId");
+    checkArgument(
+        eventType == EventType.CLIENT_MESSAGE
+            || eventType == EventType.SERVER_MESSAGE,
+        "event type must correspond to client message or server message");
+    checkNotNull(message, "message");
+
+    // TODO(DNVindhya): Implement conversion of generics to ByteString
+    // Following is a temporary workaround to log if message is of following types :
+    // 1. com.google.protobuf.Message
+    // 2. byte[]
+    byte[] messageBytesArray = null;
+    if (message instanceof com.google.protobuf.Message) {
+      messageBytesArray = ((com.google.protobuf.Message) message).toByteArray();
+    } else if (message instanceof byte[]) {
+      messageBytesArray = (byte[]) message;
+    } else {
+      logger.log(Level.WARNING, "message is of UNKNOWN type, message and payload_size fields "
+          + "of GrpcLogRecord proto will not be logged");
+    }
+    PayloadBuilderHelper<Payload.Builder> pair = null;
+    if (messageBytesArray != null) {
+      pair = createMessageProto(messageBytesArray, maxMessageBytes);
+    }
+    GrpcLogRecord.Builder logEntryBuilder = GrpcLogRecord.newBuilder()
+        .setSequenceId(seqId)
+        .setServiceName(serviceName)
+        .setMethodName(methodName)
+        .setAuthority(authority)
+        .setType(eventType)
+        .setLogger(eventLogger)
+        .setCallId(callId);
+    if (pair != null) {
+      logEntryBuilder.setPayload(pair.payloadBuilder)
+          .setPayloadTruncated(pair.truncated);
+    }
+    sink.write(logEntryBuilder.build(), spanContext);
+  }
+
+  /**
+   * Logs half close.
+   */
+  void logHalfClose(
+      long seqId,
+      String serviceName,
+      String methodName,
+      String authority,
+      GrpcLogRecord.EventLogger eventLogger,
+      String callId,
+      SpanContext spanContext) {
+    checkNotNull(serviceName, "serviceName");
+    checkNotNull(methodName, "methodName");
+    checkNotNull(authority, "authority");
+    checkNotNull(callId, "callId");
+
+    GrpcLogRecord.Builder logEntryBuilder = GrpcLogRecord.newBuilder()
+        .setSequenceId(seqId)
+        .setServiceName(serviceName)
+        .setMethodName(methodName)
+        .setAuthority(authority)
+        .setType(EventType.CLIENT_HALF_CLOSE)
+        .setLogger(eventLogger)
+        .setCallId(callId);
+    sink.write(logEntryBuilder.build(), spanContext);
+  }
+
+  /**
+   * Logs cancellation.
+   */
+  void logCancel(
+      long seqId,
+      String serviceName,
+      String methodName,
+      String authority,
+      GrpcLogRecord.EventLogger eventLogger,
+      String callId,
+      SpanContext spanContext) {
+    checkNotNull(serviceName, "serviceName");
+    checkNotNull(methodName, "methodName");
+    checkNotNull(authority, "authority");
+    checkNotNull(callId, "callId");
+
+    GrpcLogRecord.Builder logEntryBuilder = GrpcLogRecord.newBuilder()
+        .setSequenceId(seqId)
+        .setServiceName(serviceName)
+        .setMethodName(methodName)
+        .setAuthority(authority)
+        .setType(EventType.CANCEL)
+        .setLogger(eventLogger)
+        .setCallId(callId);
+    sink.write(logEntryBuilder.build(), spanContext);
+  }
+
+  // TODO(DNVindhya): Evaluate if we need following clause for metadata logging in GcpObservability
+  // Leaving the implementation for now as is to have same behavior across Java and Go
+  private static final Set<String> NEVER_INCLUDED_METADATA = new HashSet<>(
+      Collections.singletonList(
+          // grpc-status-details-bin is already logged in `status_details` field of the
+          // observabilitylog proto
+          STATUS_DETAILS_KEY.name()));
+  private static final Set<String> ALWAYS_INCLUDED_METADATA = new HashSet<>(
+      Collections.singletonList(
+          "grpc-trace-bin"));
+
+  static final class PayloadBuilderHelper<T> {
+    T payloadBuilder;
+    boolean truncated;
+
+    private PayloadBuilderHelper(T payload, boolean truncated) {
+      this.payloadBuilder = payload;
+      this.truncated = truncated;
+    }
+  }
+
+  static PayloadBuilderHelper<Payload.Builder> createMetadataProto(Metadata metadata,
+      int maxHeaderBytes) {
+    checkNotNull(metadata, "metadata");
+    checkArgument(maxHeaderBytes >= 0,
+        "maxHeaderBytes must be non negative");
+    Joiner joiner = Joiner.on(",").skipNulls();
+    Payload.Builder payloadBuilder = Payload.newBuilder();
+    boolean truncated = false;
+    int totalMetadataBytes = 0;
+    for (String key : metadata.keys()) {
+      if (NEVER_INCLUDED_METADATA.contains(key)) {
+        continue;
+      }
+      boolean forceInclude = ALWAYS_INCLUDED_METADATA.contains(key);
+      String metadataValue;
+      if (key.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
+        Iterable<byte[]> metadataValues =
+            metadata.getAll(Metadata.Key.of(key, Metadata.BINARY_BYTE_MARSHALLER));
+        List<String> numList = new ArrayList<String>();
+        metadataValues.forEach(
+            (element) -> {
+              numList.add(BASE64_ENCODING_OMIT_PADDING.encode(element));
+            });
+        metadataValue = joiner.join(numList);
+      } else {
+        Iterable<String> metadataValues = metadata.getAll(
+            Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER));
+        metadataValue = joiner.join(metadataValues);
+      }
+
+      int metadataBytesAfterAdd = totalMetadataBytes + key.length() + metadataValue.length();
+      if (!forceInclude && metadataBytesAfterAdd > maxHeaderBytes) {
+        truncated = true;
+        continue;
+      }
+      payloadBuilder.putMetadata(key, metadataValue);
+      if (!forceInclude) {
+        // force included keys do not count towards the size limit
+        totalMetadataBytes = metadataBytesAfterAdd;
+      }
+    }
+    return new PayloadBuilderHelper<>(payloadBuilder, truncated);
+  }
+
+  static PayloadBuilderHelper<Payload.Builder> createMessageProto(
+      byte[] message, int maxMessageBytes) {
+    checkArgument(maxMessageBytes >= 0,
+        "maxMessageBytes must be non negative");
+    Payload.Builder payloadBuilder = Payload.newBuilder();
+    int desiredBytes = 0;
+    int messageLength = message.length;
+    if (maxMessageBytes > 0) {
+      desiredBytes = Math.min(maxMessageBytes, messageLength);
+    }
+    ByteString messageData =
+        ByteString.copyFrom(message, 0, desiredBytes);
+    payloadBuilder.setMessage(messageData);
+    payloadBuilder.setMessageLength(messageLength);
+
+    return new PayloadBuilderHelper<>(payloadBuilder,
+        maxMessageBytes < message.length);
+  }
+
+  static Address socketAddressToProto(SocketAddress address) {
+    checkNotNull(address, "address");
+    Address.Builder builder = Address.newBuilder();
+    if (address instanceof InetSocketAddress) {
+      InetAddress inetAddress = ((InetSocketAddress) address).getAddress();
+      if (inetAddress instanceof Inet4Address) {
+        builder.setType(Address.Type.IPV4)
+            .setAddress(InetAddressUtil.toAddrString(inetAddress));
+      } else if (inetAddress instanceof Inet6Address) {
+        builder.setType(Address.Type.IPV6)
+            .setAddress(InetAddressUtil.toAddrString(inetAddress));
+      } else {
+        logger.log(Level.SEVERE, "unknown type of InetSocketAddress: {}", address);
+        builder.setAddress(address.toString());
+      }
+      builder.setIpPort(((InetSocketAddress) address).getPort());
+    } else if (address.getClass().getName().equals("io.netty.channel.unix.DomainSocketAddress")) {
+      // To avoid a compiled time dependency on grpc-netty, we check against the
+      // runtime class name.
+      builder.setType(Address.Type.UNIX)
+          .setAddress(address.toString());
+    } else {
+      builder.setType(Address.Type.TYPE_UNKNOWN).setAddress(address.toString());
+    }
+    return builder.build();
+  }
+
+  /**
+   * Retrieves socket address.
+   */
+  static SocketAddress getPeerAddress(Attributes streamAttributes) {
+    return streamAttributes.get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
+  }
+
+  /**
+   * Checks deadline for timeout.
+   */
+  static Deadline min(@Nullable Deadline deadline0, @Nullable Deadline deadline1) {
+    if (deadline0 == null) {
+      return deadline1;
+    }
+    if (deadline1 == null) {
+      return deadline0;
+    }
+    return deadline0.minimum(deadline1);
+  }
+}
diff --git a/gcp-observability/src/main/java/io/grpc/gcp/observability/logging/GcpLogSink.java b/gcp-observability/src/main/java/io/grpc/gcp/observability/logging/GcpLogSink.java
new file mode 100644
index 00000000000..270c71ed2fa
--- /dev/null
+++ b/gcp-observability/src/main/java/io/grpc/gcp/observability/logging/GcpLogSink.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright 2022 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.gcp.observability.logging;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.api.gax.batching.BatchingSettings;
+import com.google.api.gax.batching.FlowController;
+import com.google.cloud.logging.LogEntry;
+import com.google.cloud.logging.Logging;
+import com.google.cloud.logging.LoggingOptions;
+import com.google.cloud.logging.Payload.JsonPayload;
+import com.google.cloud.logging.Severity;
+import com.google.cloud.logging.v2.stub.LoggingServiceV2StubSettings;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.util.JsonFormat;
+import io.grpc.Internal;
+import io.grpc.gcp.observability.ObservabilityConfig;
+import io.grpc.internal.JsonParser;
+import io.grpc.observabilitylog.v1.GrpcLogRecord;
+import io.opencensus.trace.SpanContext;
+import java.io.IOException;
+import java.time.Instant;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.threeten.bp.Duration;
+
+/**
+ * Sink for Google Cloud Logging.
+ */
+@Internal
+public class GcpLogSink implements Sink {
+  private final Logger logger = Logger.getLogger(GcpLogSink.class.getName());
+
+  private static final String DEFAULT_LOG_NAME =
+      "microservices.googleapis.com%2Fobservability%2Fgrpc";
+  private static final Severity DEFAULT_LOG_LEVEL = Severity.DEBUG;
+  private final String projectId;
+  private final Map<String, String> customTags;
+  /** Lazily initialize cloud logging client to avoid circular initialization. Because cloud
+   * logging APIs also uses gRPC. */
+  private volatile Logging gcpLoggingClient;
+  private final Collection<String> servicesToExclude;
+  private final boolean isTraceEnabled;
+
+  private final TraceLoggingHelper traceLoggingHelper;
+
+
+  @VisibleForTesting
+  GcpLogSink(Logging loggingClient, String projectId,
+      ObservabilityConfig config, Collection<String> servicesToExclude,
+      TraceLoggingHelper traceLoggingHelper) {
+    this(projectId, config, servicesToExclude, traceLoggingHelper);
+    this.gcpLoggingClient = loggingClient;
+  }
+
+  /**
+   * Retrieves a single instance of GcpLogSink.
+   *
+   * @param projectId GCP project id to write logs
+   * @param servicesToExclude service names for which log entries should not be generated
+   */
+  public GcpLogSink(String projectId,
+      ObservabilityConfig config, Collection<String> servicesToExclude,
+      TraceLoggingHelper traceLoggingHelper) {
+    this.projectId = projectId;
+    this.customTags = getCustomTags(config.getCustomTags());
+    this.servicesToExclude = checkNotNull(servicesToExclude, "servicesToExclude");
+    this.isTraceEnabled = config.isEnableCloudTracing();
+    this.traceLoggingHelper = traceLoggingHelper;
+  }
+
+  /**
+   * Writes logs to GCP Cloud Logging.
+   *
+   * @param logProto gRPC logging proto containing the message to be logged
+   */
+  @Override
+  public void write(GrpcLogRecord logProto, SpanContext spanContext) {
+    if (gcpLoggingClient == null) {
+      synchronized (this) {
+        if (gcpLoggingClient == null) {
+          gcpLoggingClient = createLoggingClient();
+        }
+      }
+    }
+    if (servicesToExclude.contains(logProto.getServiceName())) {
+      return;
+    }
+    LogEntry grpcLogEntry = null;
+    try {
+      GrpcLogRecord.EventType eventType = logProto.getType();
+      // TODO(DNVindhya): make sure all (int, long) values are not displayed as double
+      // For now, every value is being converted as string because of JsonFormat.printer().print
+      Map<String, Object> logProtoMap = protoToMapConverter(logProto);
+      LogEntry.Builder grpcLogEntryBuilder =
+          LogEntry.newBuilder(JsonPayload.of(logProtoMap))
+              .setSeverity(DEFAULT_LOG_LEVEL)
+              .setLogName(DEFAULT_LOG_NAME)
+              .setTimestamp(Instant.now());
+
+      if (!customTags.isEmpty()) {
+        grpcLogEntryBuilder.setLabels(customTags);
+      }
+
+      addTraceData(grpcLogEntryBuilder, spanContext);
+      grpcLogEntry = grpcLogEntryBuilder.build();
+
+      synchronized (this) {
+        logger.log(Level.FINEST, "Writing gRPC event : {0} to Cloud Logging", eventType);
+        gcpLoggingClient.write(Collections.singleton(grpcLogEntry));
+      }
+    } catch (FlowController.FlowControlRuntimeException e) {
+      String grpcLogEntryString = null;
+      if (grpcLogEntry != null) {
+        grpcLogEntryString = grpcLogEntry.toStructuredJsonString();
+      }
+      logger.log(Level.SEVERE, "Limit exceeded while writing log entry to cloud logging");
+      logger.log(Level.SEVERE, "Log entry = ", grpcLogEntryString);
+    } catch (Exception e) {
+      logger.log(Level.SEVERE, "Caught exception while writing to Cloud Logging", e);
+    }
+  }
+
+  void addTraceData(LogEntry.Builder builder, SpanContext spanContext) {
+    if (!isTraceEnabled) {
+      return;
+    }
+    traceLoggingHelper.enhanceLogEntry(builder, spanContext);
+  }
+
+  Logging createLoggingClient() {
+    LoggingOptions.Builder builder = LoggingOptions.newBuilder();
+    if (!Strings.isNullOrEmpty(projectId)) {
+      builder.setProjectId(projectId);
+    }
+    BatchingSettings loggingDefaultBatchingSettings = LoggingServiceV2StubSettings.newBuilder()
+        .writeLogEntriesSettings().getBatchingSettings();
+    // Custom batching settings
+    BatchingSettings grpcLoggingVBatchingSettings = loggingDefaultBatchingSettings.toBuilder()
+        .setDelayThreshold(Duration.ofSeconds(1L)).setFlowControlSettings(
+            loggingDefaultBatchingSettings.getFlowControlSettings().toBuilder()
+                .setMaxOutstandingRequestBytes(52428800L) //50 MiB
+                .setLimitExceededBehavior(FlowController.LimitExceededBehavior.ThrowException)
+                .build()).build();
+    builder.setBatchingSettings(grpcLoggingVBatchingSettings);
+    return builder.build().getService();
+  }
+
+  @VisibleForTesting
+  static Map<String, String> getCustomTags(Map<String, String> customTags) {
+    ImmutableMap.Builder<String, String> tagsBuilder = ImmutableMap.builder();
+    if (customTags != null) {
+      tagsBuilder.putAll(customTags);
+    }
+    return tagsBuilder.buildOrThrow();
+  }
+
+
+  @SuppressWarnings("unchecked")
+  private Map<String, Object> protoToMapConverter(GrpcLogRecord logProto)
+      throws IOException {
+    JsonFormat.Printer printer = JsonFormat.printer();
+    String recordJson = printer.print(logProto);
+    return (Map<String, Object>) JsonParser.parse(recordJson);
+  }
+
+  /**
+   * Closes Cloud Logging Client.
+   */
+  @Override
+  public synchronized void close() {
+    if (gcpLoggingClient == null) {
+      logger.log(Level.WARNING, "Attempt to close after GcpLogSink is closed.");
+      return;
+    }
+    try {
+      gcpLoggingClient.close();
+    } catch (Exception e) {
+      logger.log(Level.SEVERE, "Caught exception while closing", e);
+    }
+  }
+}
diff --git a/gcp-observability/src/main/java/io/grpc/gcp/observability/logging/Sink.java b/gcp-observability/src/main/java/io/grpc/gcp/observability/logging/Sink.java
new file mode 100644
index 00000000000..a29aab0c433
--- /dev/null
+++ b/gcp-observability/src/main/java/io/grpc/gcp/observability/logging/Sink.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2022 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.gcp.observability.logging;
+
+import io.grpc.Internal;
+import io.grpc.observabilitylog.v1.GrpcLogRecord;
+import io.opencensus.trace.SpanContext;
+
+/**
+ * Sink for GCP observability.
+ */
+@Internal
+public interface Sink {
+  /**
+   * Writes the {@code message} to the destination.
+   */
+  void write(GrpcLogRecord message, SpanContext spanContext);
+
+  /**
+   * Closes the sink.
+   */
+  void close();
+}
diff --git a/gcp-observability/src/main/java/io/grpc/gcp/observability/logging/TraceLoggingHelper.java b/gcp-observability/src/main/java/io/grpc/gcp/observability/logging/TraceLoggingHelper.java
new file mode 100644
index 00000000000..a53f934a5e8
--- /dev/null
+++ b/gcp-observability/src/main/java/io/grpc/gcp/observability/logging/TraceLoggingHelper.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2023 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.gcp.observability.logging;
+
+import com.google.cloud.logging.LogEntry;
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Internal;
+import io.opencensus.trace.SpanContext;
+import io.opencensus.trace.TraceId;
+
+@Internal
+public class TraceLoggingHelper {
+
+  private final String tracePrefix;
+
+  public TraceLoggingHelper(String projectId) {
+    this.tracePrefix = "projects/" + projectId + "/traces/";;
+  }
+
+  @VisibleForTesting
+  void enhanceLogEntry(LogEntry.Builder builder, SpanContext spanContext) {
+    addTracingData(tracePrefix, spanContext, builder);
+  }
+
+  private static void addTracingData(
+      String tracePrefix, SpanContext spanContext, LogEntry.Builder builder) {
+    builder.setTrace(formatTraceId(tracePrefix, spanContext.getTraceId()));
+    builder.setSpanId(spanContext.getSpanId().toLowerBase16());
+    builder.setTraceSampled(spanContext.getTraceOptions().isSampled());
+  }
+
+  private static String formatTraceId(String tracePrefix, TraceId traceId) {
+    return tracePrefix + traceId.toLowerBase16();
+  }
+}
diff --git a/gcp-observability/src/main/proto/grpc/observabilitylog/v1/observabilitylog.proto b/gcp-observability/src/main/proto/grpc/observabilitylog/v1/observabilitylog.proto
new file mode 100644
index 00000000000..7d278aa08a9
--- /dev/null
+++ b/gcp-observability/src/main/proto/grpc/observabilitylog/v1/observabilitylog.proto
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2022 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.
+ */
+
+syntax = "proto3";
+
+package grpc.observabilitylog.v1;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "google/rpc/code.proto";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.observabilitylog.v1";
+option java_outer_classname = "ObservabilityLogProto";
+
+message GrpcLogRecord {
+  // List of event types
+  enum EventType {
+    EVENT_TYPE_UNKNOWN = 0;
+    // Header sent from client to server
+    CLIENT_HEADER = 1;
+    // Header sent from server to client
+    SERVER_HEADER = 2;
+    // Message sent from client to server
+    CLIENT_MESSAGE = 3;
+    // Message sent from server to client
+    SERVER_MESSAGE = 4;
+    // A signal that client is done sending
+    CLIENT_HALF_CLOSE = 5;
+    // Trailer indicates the end of the gRPC call
+    SERVER_TRAILER = 6;
+    // A signal that the rpc is canceled
+    CANCEL = 7;
+  }
+
+  // The entity that generates the log entry
+  enum EventLogger {
+    LOGGER_UNKNOWN = 0;
+    CLIENT = 1;
+    SERVER = 2;
+  }
+
+  // Uniquely identifies a call.
+  // Each call may have several log entries. They will all have the same call_id.
+  // Nothing is guaranteed about their value other than they are unique across
+  // different RPCs in the same gRPC process.
+  string call_id = 2;
+
+  // The entry sequence ID for this call. The first message has a value of 1,
+  // to disambiguate from an unset value. The purpose of this field is to
+  // detect missing entries in environments where durability or ordering is
+  // not guaranteed.
+  uint64 sequence_id = 3;
+
+  EventType type = 4;      // one of the above EventType enum
+  EventLogger logger = 5;  // one of the above EventLogger enum
+
+  // Payload for log entry.
+  // It can include a combination of {metadata, message, status based on type of
+  // the event event being logged and config options.
+  Payload payload = 6;
+
+  // true if message or metadata field is either truncated or omitted due
+  // to config options
+  bool payload_truncated = 7;
+  // Peer address information. On client side, peer is logged on server
+  // header event or trailer event (if trailer-only). On server side, peer
+  // is always logged on the client header event.
+  Address peer = 8;
+
+  // A single process may be used to run multiple virtual servers with
+  // different identities.
+  // The authority is the name of such a server identify. It is typically a
+  // portion of the URI in the form of <host> or <host>:<port>.
+  string authority = 10;
+  // the name of the service
+  string service_name = 11;
+  // the name of the RPC method
+  string method_name = 12;
+}
+
+message Payload {
+  // A list of metadata pairs
+  map<string, string> metadata = 1;
+  // the RPC timeout value
+  google.protobuf.Duration timeout = 2;
+  // The gRPC status code
+  google.rpc.Code status_code = 3;
+  // The gRPC status message
+  string status_message = 4;
+  // The value of the grpc-status-details-bin metadata key, if any.
+  // This is always an encoded google.rpc.Status message
+  bytes status_details = 5;
+  // Size of the message or metadata, depending on the event type,
+  // regardless of whether the full message or metadata is being logged
+  // (i.e. could be truncated or omitted).
+  uint32 message_length = 6;
+  // Used by message event
+  bytes message = 7;
+}
+
+// Address information
+message Address {
+  enum Type {
+    TYPE_UNKNOWN = 0;
+    IPV4 = 1;  // in 1.2.3.4 form
+    IPV6 = 2;  // IPv6 canonical form (RFC5952 section 4)
+    UNIX = 3;  // UDS string
+  }
+  Type type = 1;
+  string address = 2;
+  // only for TYPE_IPV4 and TYPE_IPV6
+  uint32 ip_port = 3;
+}
diff --git a/gcp-observability/src/test/java/io/grpc/gcp/observability/GcpObservabilityTest.java b/gcp-observability/src/test/java/io/grpc/gcp/observability/GcpObservabilityTest.java
new file mode 100644
index 00000000000..25467839dd6
--- /dev/null
+++ b/gcp-observability/src/test/java/io/grpc/gcp/observability/GcpObservabilityTest.java
@@ -0,0 +1,267 @@
+/*
+ * Copyright 2022 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.gcp.observability;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.InternalConfiguratorRegistry;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.StaticTestingClassLoader;
+import io.grpc.gcp.observability.GcpObservability.ObservabilityConfigurator;
+import io.grpc.gcp.observability.interceptors.ConditionalClientInterceptor;
+import io.grpc.gcp.observability.interceptors.InternalLoggingChannelInterceptor;
+import io.grpc.gcp.observability.interceptors.InternalLoggingServerInterceptor;
+import io.grpc.gcp.observability.logging.Sink;
+import io.opencensus.trace.samplers.Samplers;
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class GcpObservabilityTest {
+
+  private final StaticTestingClassLoader classLoader =
+      new StaticTestingClassLoader(
+          getClass().getClassLoader(),
+          Pattern.compile(
+              "io\\.grpc\\.InternalConfigurator|io\\.grpc\\.Configurator|"
+                  + "io\\.grpc\\.InternalConfiguratorRegistry|io\\.grpc\\.ConfiguratorRegistry|"
+                  + "io\\.grpc\\.gcp\\.observability\\.[^.]+|"
+                  + "io\\.grpc\\.gcp\\.observability\\.interceptors\\.[^.]+|"
+                  + "io\\.grpc\\.gcp\\.observability\\.GcpObservabilityTest\\$.*"));
+
+  @Test
+  public void initFinish() throws Exception {
+    Class<?> runnable =
+        classLoader.loadClass(StaticTestingClassInitFinish.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  @Test
+  public void enableObservability() throws Exception {
+    Class<?> runnable =
+        classLoader.loadClass(StaticTestingClassEnableObservability.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  @Test
+  public void disableObservability() throws Exception {
+    Class<?> runnable =
+        classLoader.loadClass(StaticTestingClassDisableObservability.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void conditionalInterceptor() {
+    ClientInterceptor delegate = mock(ClientInterceptor.class);
+    Channel channel = mock(Channel.class);
+    ClientCall<?, ?> returnedCall = mock(ClientCall.class);
+
+    ConditionalClientInterceptor conditionalClientInterceptor
+        = GcpObservability.getConditionalInterceptor(
+        delegate);
+    MethodDescriptor<?, ?> method = MethodDescriptor.newBuilder()
+        .setType(MethodDescriptor.MethodType.UNARY)
+        .setFullMethodName("google.logging.v2.LoggingServiceV2/method")
+        .setRequestMarshaller(mock(MethodDescriptor.Marshaller.class))
+        .setResponseMarshaller(mock(MethodDescriptor.Marshaller.class))
+        .build();
+    doReturn(returnedCall).when(channel).newCall(method, CallOptions.DEFAULT);
+    ClientCall<?, ?> clientCall = conditionalClientInterceptor.interceptCall(method,
+        CallOptions.DEFAULT, channel);
+    verifyNoInteractions(delegate);
+    assertThat(clientCall).isSameInstanceAs(returnedCall);
+
+    method = MethodDescriptor.newBuilder().setType(MethodDescriptor.MethodType.UNARY)
+        .setFullMethodName("google.monitoring.v3.MetricService/method2")
+        .setRequestMarshaller(mock(MethodDescriptor.Marshaller.class))
+        .setResponseMarshaller(mock(MethodDescriptor.Marshaller.class))
+        .build();
+    doReturn(returnedCall).when(channel).newCall(method, CallOptions.DEFAULT);
+    clientCall = conditionalClientInterceptor.interceptCall(method, CallOptions.DEFAULT, channel);
+    verifyNoInteractions(delegate);
+    assertThat(clientCall).isSameInstanceAs(returnedCall);
+
+    method = MethodDescriptor.newBuilder().setType(MethodDescriptor.MethodType.UNARY)
+        .setFullMethodName("google.devtools.cloudtrace.v2.TraceService/method3")
+        .setRequestMarshaller(mock(MethodDescriptor.Marshaller.class))
+        .setResponseMarshaller(mock(MethodDescriptor.Marshaller.class))
+        .build();
+    doReturn(returnedCall).when(channel).newCall(method, CallOptions.DEFAULT);
+    clientCall = conditionalClientInterceptor.interceptCall(method, CallOptions.DEFAULT, channel);
+    verifyNoInteractions(delegate);
+    assertThat(clientCall).isSameInstanceAs(returnedCall);
+
+    reset(channel);
+    ClientCall<?, ?> interceptedCall = mock(ClientCall.class);
+    method = MethodDescriptor.newBuilder().setType(MethodDescriptor.MethodType.UNARY)
+        .setFullMethodName("some.other.random.service/method4")
+        .setRequestMarshaller(mock(MethodDescriptor.Marshaller.class))
+        .setResponseMarshaller(mock(MethodDescriptor.Marshaller.class))
+        .build();
+    doReturn(interceptedCall).when(delegate).interceptCall(method, CallOptions.DEFAULT, channel);
+    clientCall = conditionalClientInterceptor.interceptCall(method, CallOptions.DEFAULT, channel);
+    verifyNoInteractions(channel);
+    assertThat(clientCall).isSameInstanceAs(interceptedCall);
+  }
+
+  // UsedReflectively
+  public static final class StaticTestingClassInitFinish implements Runnable {
+
+    @Override
+    public void run() {
+      Sink sink = mock(Sink.class);
+      ObservabilityConfig config = mock(ObservabilityConfig.class);
+      InternalLoggingChannelInterceptor.Factory channelInterceptorFactory =
+          mock(InternalLoggingChannelInterceptor.Factory.class);
+      InternalLoggingServerInterceptor.Factory serverInterceptorFactory =
+          mock(InternalLoggingServerInterceptor.Factory.class);
+      GcpObservability observability1;
+      try {
+        GcpObservability observability =
+            GcpObservability.grpcInit(
+              sink, config, channelInterceptorFactory, serverInterceptorFactory);
+        observability1 =
+            GcpObservability.grpcInit(
+                sink, config, channelInterceptorFactory, serverInterceptorFactory);
+        assertThat(observability1).isSameInstanceAs(observability);
+        observability.close();
+        verify(sink).close();
+        try {
+          observability1.close();
+          fail("should have failed for calling close() second time");
+        } catch (IllegalStateException e) {
+          assertThat(e).hasMessageThat().contains("GcpObservability already closed!");
+        }
+      } catch (IOException e) {
+        fail("Encountered exception: " + e);
+      }
+    }
+  }
+
+  public static final class StaticTestingClassEnableObservability implements Runnable {
+
+    @Override
+    public void run() {
+      Sink sink = mock(Sink.class);
+      ObservabilityConfig config = mock(ObservabilityConfig.class);
+      when(config.isEnableCloudLogging()).thenReturn(true);
+      when(config.isEnableCloudMonitoring()).thenReturn(true);
+      when(config.isEnableCloudTracing()).thenReturn(true);
+      when(config.getSampler()).thenReturn(Samplers.neverSample());
+
+      ClientInterceptor clientInterceptor =
+          mock(ClientInterceptor.class, delegatesTo(new NoopClientInterceptor()));
+      InternalLoggingChannelInterceptor.Factory channelInterceptorFactory =
+          mock(InternalLoggingChannelInterceptor.Factory.class);
+      when(channelInterceptorFactory.create()).thenReturn(clientInterceptor);
+
+      ServerInterceptor serverInterceptor =
+          mock(ServerInterceptor.class, delegatesTo(new NoopServerInterceptor()));
+      InternalLoggingServerInterceptor.Factory serverInterceptorFactory =
+          mock(InternalLoggingServerInterceptor.Factory.class);
+      when(serverInterceptorFactory.create()).thenReturn(serverInterceptor);
+
+      try {
+        GcpObservability gcpObservability = GcpObservability.grpcInit(
+            sink, config, channelInterceptorFactory, serverInterceptorFactory);
+        List<?> configurators = InternalConfiguratorRegistry.getConfigurators();
+        assertThat(configurators).hasSize(1);
+        ObservabilityConfigurator configurator = (ObservabilityConfigurator) configurators.get(0);
+        List<ClientInterceptor> list = configurator.clientInterceptors;
+        assertThat(list).hasSize(3);
+        assertThat(list.get(1)).isInstanceOf(ConditionalClientInterceptor.class);
+        assertThat(list.get(2)).isInstanceOf(ConditionalClientInterceptor.class);
+        assertThat(configurator.serverInterceptors).hasSize(1);
+        assertThat(configurator.tracerFactories).hasSize(2);
+        gcpObservability.closeWithSleepTime(3000, TimeUnit.MILLISECONDS);
+      } catch (Exception e) {
+        fail("Encountered exception: " + e);
+      }
+      verify(sink).close();
+    }
+  }
+
+  public static final class StaticTestingClassDisableObservability implements Runnable {
+
+    @Override
+    public void run() {
+      Sink sink = mock(Sink.class);
+      ObservabilityConfig config = mock(ObservabilityConfig.class);
+      when(config.isEnableCloudLogging()).thenReturn(false);
+      when(config.isEnableCloudMonitoring()).thenReturn(false);
+      when(config.isEnableCloudTracing()).thenReturn(false);
+      when(config.getSampler()).thenReturn(Samplers.neverSample());
+
+      InternalLoggingChannelInterceptor.Factory channelInterceptorFactory =
+          mock(InternalLoggingChannelInterceptor.Factory.class);
+      InternalLoggingServerInterceptor.Factory serverInterceptorFactory =
+          mock(InternalLoggingServerInterceptor.Factory.class);
+
+      try (GcpObservability unused =
+          GcpObservability.grpcInit(
+              sink, config, channelInterceptorFactory, serverInterceptorFactory)) {
+        List<?> configurators = InternalConfiguratorRegistry.getConfigurators();
+        assertThat(configurators).hasSize(1);
+        ObservabilityConfigurator configurator = (ObservabilityConfigurator) configurators.get(0);
+        assertThat(configurator.clientInterceptors).isEmpty();
+        assertThat(configurator.serverInterceptors).isEmpty();
+        assertThat(configurator.tracerFactories).isEmpty();
+      } catch (Exception e) {
+        fail("Encountered exception: " + e);
+      }
+      verify(sink).close();
+    }
+  }
+
+  private static class NoopClientInterceptor implements ClientInterceptor {
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+      return next.newCall(method, callOptions);
+    }
+  }
+
+  private static class NoopServerInterceptor implements ServerInterceptor {
+    @Override
+    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+        ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+      return next.startCall(call, headers);
+    }
+  }
+}
diff --git a/gcp-observability/src/test/java/io/grpc/gcp/observability/LoggingTest.java b/gcp-observability/src/test/java/io/grpc/gcp/observability/LoggingTest.java
new file mode 100644
index 00000000000..92e67b01e01
--- /dev/null
+++ b/gcp-observability/src/test/java/io/grpc/gcp/observability/LoggingTest.java
@@ -0,0 +1,252 @@
+/*
+ * Copyright 2022 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.gcp.observability;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableMap;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.StaticTestingClassLoader;
+import io.grpc.gcp.observability.interceptors.ConfigFilterHelper;
+import io.grpc.gcp.observability.interceptors.ConfigFilterHelper.FilterParams;
+import io.grpc.gcp.observability.interceptors.InternalLoggingChannelInterceptor;
+import io.grpc.gcp.observability.interceptors.InternalLoggingServerInterceptor;
+import io.grpc.gcp.observability.interceptors.LogHelper;
+import io.grpc.gcp.observability.logging.GcpLogSink;
+import io.grpc.gcp.observability.logging.Sink;
+import io.grpc.gcp.observability.logging.TraceLoggingHelper;
+import io.grpc.observabilitylog.v1.GrpcLogRecord;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import io.opencensus.trace.SpanContext;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.regex.Pattern;
+import org.junit.ClassRule;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.AdditionalMatchers;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mockito;
+
+@RunWith(JUnit4.class)
+public class LoggingTest {
+
+  @ClassRule
+  public static final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+
+  private static final String PROJECT_ID = "PROJECT";
+  private static final ImmutableMap<String, String> CUSTOM_TAGS = ImmutableMap.of(
+      "KEY1", "Value1",
+      "KEY2", "VALUE2");
+
+  private final StaticTestingClassLoader classLoader =
+      new StaticTestingClassLoader(getClass().getClassLoader(), Pattern.compile("io\\.grpc\\..*"));
+
+  /**
+   * Cloud logging test using global interceptors.
+   *
+   * <p>Ignoring test, because it calls external Cloud Logging APIs.
+   * To test cloud logging setup locally,
+   * 1. Set up Cloud auth credentials
+   * 2. Assign permissions to service account to write logs to project specified by
+   * variable PROJECT_ID
+   * 3. Comment @Ignore annotation
+   * 4. This test is expected to pass when ran with above setup. This has been verified manually.
+   * </p>
+   */
+  @Ignore
+  @Test
+  public void clientServer_interceptorCalled_logAlways() throws Exception {
+    Class<?> runnable =
+        classLoader.loadClass(LoggingTest.StaticTestingClassEndtoEndLogging.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  @Test
+  public void clientServer_interceptorCalled_logNever() throws Exception {
+    Class<?> runnable =
+        classLoader.loadClass(LoggingTest.StaticTestingClassLogNever.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  @Test
+  public void clientServer_interceptorCalled_logEvents_usingMockSink() throws Exception {
+    Class<?> runnable =
+        classLoader.loadClass(StaticTestingClassLogEventsUsingMockSink.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  // UsedReflectively
+  public static final class StaticTestingClassEndtoEndLogging implements Runnable {
+
+    @Override
+    public void run() {
+      ObservabilityConfig config = mock(ObservabilityConfig.class);
+      when(config.getCustomTags()).thenReturn(CUSTOM_TAGS);
+      Sink sink =
+          new GcpLogSink(
+              PROJECT_ID, config, Collections.emptySet(),
+              mock(TraceLoggingHelper.class));
+      LogHelper spyLogHelper = spy(new LogHelper(sink));
+      ConfigFilterHelper mockFilterHelper = mock(ConfigFilterHelper.class);
+      InternalLoggingChannelInterceptor.Factory channelInterceptorFactory =
+          new InternalLoggingChannelInterceptor.FactoryImpl(spyLogHelper, mockFilterHelper);
+      InternalLoggingServerInterceptor.Factory serverInterceptorFactory =
+          new InternalLoggingServerInterceptor.FactoryImpl(spyLogHelper, mockFilterHelper);
+
+      when(config.isEnableCloudLogging()).thenReturn(true);
+      FilterParams logAlwaysFilterParams = FilterParams.create(true, 1024, 10);
+      when(mockFilterHelper.logRpcMethod(anyString(), eq(true)))
+          .thenReturn(logAlwaysFilterParams);
+      when(mockFilterHelper.logRpcMethod(anyString(), eq(false)))
+          .thenReturn(logAlwaysFilterParams);
+
+      try (GcpObservability unused =
+          GcpObservability.grpcInit(
+              sink, config, channelInterceptorFactory, serverInterceptorFactory)) {
+        Server server =
+            ServerBuilder.forPort(0)
+                .addService(new ObservabilityTestHelper.SimpleServiceImpl())
+                .build()
+                .start();
+        int port = cleanupRule.register(server).getPort();
+        SimpleServiceGrpc.SimpleServiceBlockingStub stub =
+            SimpleServiceGrpc.newBlockingStub(
+                cleanupRule.register(
+                    ManagedChannelBuilder.forAddress("localhost", port).usePlaintext().build()));
+        assertThat(ObservabilityTestHelper.makeUnaryRpcViaClientStub("buddy", stub))
+            .isEqualTo("Hello buddy");
+        assertThat(Mockito.mockingDetails(spyLogHelper).getInvocations().size()).isGreaterThan(11);
+      } catch (IOException e) {
+        throw new AssertionError("Exception while testing logging", e);
+      }
+    }
+  }
+
+  public static final class StaticTestingClassLogNever implements Runnable {
+
+    @Override
+    public void run() {
+      Sink mockSink = mock(GcpLogSink.class);
+      ObservabilityConfig config = mock(ObservabilityConfig.class);
+      LogHelper spyLogHelper = spy(new LogHelper(mockSink));
+      ConfigFilterHelper mockFilterHelper = mock(ConfigFilterHelper.class);
+      InternalLoggingChannelInterceptor.Factory channelInterceptorFactory =
+          new InternalLoggingChannelInterceptor.FactoryImpl(spyLogHelper, mockFilterHelper);
+      InternalLoggingServerInterceptor.Factory serverInterceptorFactory =
+          new InternalLoggingServerInterceptor.FactoryImpl(spyLogHelper, mockFilterHelper);
+
+      when(config.isEnableCloudLogging()).thenReturn(true);
+      FilterParams logNeverFilterParams = FilterParams.create(false, 0, 0);
+      when(mockFilterHelper.logRpcMethod(anyString(), eq(true)))
+          .thenReturn(logNeverFilterParams);
+      when(mockFilterHelper.logRpcMethod(anyString(), eq(false)))
+          .thenReturn(logNeverFilterParams);
+
+      try (GcpObservability unused =
+          GcpObservability.grpcInit(
+              mockSink, config, channelInterceptorFactory, serverInterceptorFactory)) {
+        Server server =
+            ServerBuilder.forPort(0)
+                .addService(new ObservabilityTestHelper.SimpleServiceImpl())
+                .build()
+                .start();
+        int port = cleanupRule.register(server).getPort();
+        SimpleServiceGrpc.SimpleServiceBlockingStub stub =
+            SimpleServiceGrpc.newBlockingStub(
+                cleanupRule.register(
+                    ManagedChannelBuilder.forAddress("localhost", port).usePlaintext().build()));
+        assertThat(ObservabilityTestHelper.makeUnaryRpcViaClientStub("buddy", stub))
+            .isEqualTo("Hello buddy");
+        verifyNoInteractions(spyLogHelper);
+        verifyNoInteractions(mockSink);
+      } catch (IOException e) {
+        throw new AssertionError("Exception while testing logging event filter", e);
+      }
+    }
+  }
+
+  public static final class StaticTestingClassLogEventsUsingMockSink implements Runnable {
+
+    @Override
+    public void run() {
+      Sink mockSink = mock(GcpLogSink.class);
+      ObservabilityConfig config = mock(ObservabilityConfig.class);
+      LogHelper spyLogHelper = spy(new LogHelper(mockSink));
+      ConfigFilterHelper mockFilterHelper2 = mock(ConfigFilterHelper.class);
+      InternalLoggingChannelInterceptor.Factory channelInterceptorFactory =
+          new InternalLoggingChannelInterceptor.FactoryImpl(spyLogHelper, mockFilterHelper2);
+      InternalLoggingServerInterceptor.Factory serverInterceptorFactory =
+          new InternalLoggingServerInterceptor.FactoryImpl(spyLogHelper, mockFilterHelper2);
+
+      when(config.isEnableCloudLogging()).thenReturn(true);
+      FilterParams logAlwaysFilterParams = FilterParams.create(true, 0, 0);
+      when(mockFilterHelper2.logRpcMethod(anyString(), eq(true)))
+          .thenReturn(logAlwaysFilterParams);
+      when(mockFilterHelper2.logRpcMethod(anyString(), eq(false)))
+          .thenReturn(logAlwaysFilterParams);
+
+      try (GcpObservability observability =
+          GcpObservability.grpcInit(
+              mockSink, config, channelInterceptorFactory, serverInterceptorFactory)) {
+        Server server =
+            ServerBuilder.forPort(0)
+                .addService(new ObservabilityTestHelper.SimpleServiceImpl())
+                .build()
+                .start();
+        int port = cleanupRule.register(server).getPort();
+        SimpleServiceGrpc.SimpleServiceBlockingStub stub =
+            SimpleServiceGrpc.newBlockingStub(
+                cleanupRule.register(
+                    ManagedChannelBuilder.forAddress("localhost", port).usePlaintext().build()));
+        assertThat(ObservabilityTestHelper.makeUnaryRpcViaClientStub("buddy", stub))
+            .isEqualTo("Hello buddy");
+        // Total number of calls should have been 14 (6 from client and 6 from server)
+        // Since cancel is not invoked, it will be 12.
+        // Request message(Total count:2 (1 from client and 1 from server) and Response
+        // message(count:2)
+        // events are not in the event_types list, i.e  14 - 2(cancel) - 2(req_msg) - 2(resp_msg)
+        // = 8
+        assertThat(Mockito.mockingDetails(mockSink).getInvocations().size()).isEqualTo(12);
+        ArgumentCaptor<GrpcLogRecord> captor = ArgumentCaptor.forClass(GrpcLogRecord.class);
+        verify(mockSink, times(12)).write(captor.capture(),
+            AdditionalMatchers.or(ArgumentMatchers.isNull(),
+                ArgumentMatchers.any(SpanContext.class)));
+        for (GrpcLogRecord record : captor.getAllValues()) {
+          assertThat(record.getType()).isInstanceOf(GrpcLogRecord.EventType.class);
+          assertThat(record.getLogger()).isInstanceOf(GrpcLogRecord.EventLogger.class);
+        }
+      } catch (IOException e) {
+        throw new AssertionError("Exception while testing logging using mock sink", e);
+      }
+    }
+  }
+}
diff --git a/gcp-observability/src/test/java/io/grpc/gcp/observability/MetricsTest.java b/gcp-observability/src/test/java/io/grpc/gcp/observability/MetricsTest.java
new file mode 100644
index 00000000000..046799cc9d2
--- /dev/null
+++ b/gcp-observability/src/test/java/io/grpc/gcp/observability/MetricsTest.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright 2022 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.gcp.observability;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.cloud.monitoring.v3.MetricServiceClient;
+import com.google.cloud.monitoring.v3.MetricServiceClient.ListTimeSeriesPagedResponse;
+import com.google.monitoring.v3.ListTimeSeriesRequest;
+import com.google.monitoring.v3.ProjectName;
+import com.google.monitoring.v3.TimeInterval;
+import com.google.monitoring.v3.TimeSeries;
+import com.google.protobuf.util.Timestamps;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.StaticTestingClassLoader;
+import io.grpc.gcp.observability.interceptors.InternalLoggingChannelInterceptor;
+import io.grpc.gcp.observability.interceptors.InternalLoggingServerInterceptor;
+import io.grpc.gcp.observability.logging.GcpLogSink;
+import io.grpc.gcp.observability.logging.Sink;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
+import org.junit.ClassRule;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class MetricsTest {
+
+  @ClassRule
+  public static final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+
+  private static final String PROJECT_ID = "PROJECT";
+  private static final String TEST_CLIENT_METHOD = "grpc.testing.SimpleService/UnaryRpc";
+  private static final String CUSTOM_TAG_KEY = "Version";
+  private static final String CUSTOM_TAG_VALUE =
+      String.format("C67J9A-%s", String.valueOf(System.currentTimeMillis()));
+  private static final Map<String, String> CUSTOM_TAGS = Collections.singletonMap(CUSTOM_TAG_KEY,
+      CUSTOM_TAG_VALUE);
+
+  private final StaticTestingClassLoader classLoader =
+      new StaticTestingClassLoader(getClass().getClassLoader(),
+          Pattern.compile("io\\.grpc\\..*|io\\.opencensus\\..*"));
+
+  /**
+   * End to end cloud monitoring test.
+   *
+   * <p>Ignoring test, because it calls external Cloud Monitoring APIs. To test cloud monitoring
+   * setup locally,
+   * 1. Set up Cloud auth credentials
+   * 2. Assign permissions to service account to write metrics to project specified by variable
+   * PROJECT_ID
+   * 3. Comment @Ignore annotation
+   * 4. This test is expected to pass when ran with above setup. This has been verified manually.
+   */
+  @Ignore
+  @Test
+  public void testMetricsExporter() throws Exception {
+    Class<?> runnable =
+        classLoader.loadClass(MetricsTest.StaticTestingClassTestMetricsExporter.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  public static final class StaticTestingClassTestMetricsExporter implements Runnable {
+
+    @Override
+    public void run() {
+      Sink mockSink = mock(GcpLogSink.class);
+      ObservabilityConfig mockConfig = mock(ObservabilityConfig.class);
+      InternalLoggingChannelInterceptor.Factory mockChannelInterceptorFactory =
+          mock(InternalLoggingChannelInterceptor.Factory.class);
+      InternalLoggingServerInterceptor.Factory mockServerInterceptorFactory =
+          mock(InternalLoggingServerInterceptor.Factory.class);
+
+      when(mockConfig.isEnableCloudMonitoring()).thenReturn(true);
+      when(mockConfig.getProjectId()).thenReturn(PROJECT_ID);
+
+      try {
+        GcpObservability observability =
+            GcpObservability.grpcInit(
+                mockSink, mockConfig, mockChannelInterceptorFactory, mockServerInterceptorFactory);
+        observability.registerStackDriverExporter(PROJECT_ID, CUSTOM_TAGS);
+
+        Server server =
+            ServerBuilder.forPort(0)
+                .addService(new ObservabilityTestHelper.SimpleServiceImpl())
+                .build()
+                .start();
+        int port = cleanupRule.register(server).getPort();
+        SimpleServiceGrpc.SimpleServiceBlockingStub stub =
+            SimpleServiceGrpc.newBlockingStub(
+                cleanupRule.register(
+                    ManagedChannelBuilder.forAddress("localhost", port).usePlaintext().build()));
+        assertThat(ObservabilityTestHelper.makeUnaryRpcViaClientStub("buddy", stub))
+            .isEqualTo("Hello buddy");
+        // Adding sleep to ensure metrics are exported before querying cloud monitoring backend
+        TimeUnit.SECONDS.sleep(40);
+
+        // This checks Cloud monitoring for the new metrics that was just exported.
+        MetricServiceClient metricServiceClient = MetricServiceClient.create();
+        // Restrict time to last 1 minute
+        long startMillis = System.currentTimeMillis() - ((60 * 1) * 1000);
+        TimeInterval interval =
+            TimeInterval.newBuilder()
+                .setStartTime(Timestamps.fromMillis(startMillis))
+                .setEndTime(Timestamps.fromMillis(System.currentTimeMillis()))
+                .build();
+        // Timeseries data
+        String metricsFilter =
+            String.format(
+                "metric.type=\"custom.googleapis.com/opencensus/grpc.io/client/completed_rpcs\""
+                    + " AND metric.labels.grpc_client_method=\"%s\""
+                    + " AND metric.labels.%s=%s",
+                TEST_CLIENT_METHOD, CUSTOM_TAG_KEY, CUSTOM_TAG_VALUE);
+        ListTimeSeriesRequest metricsRequest =
+            ListTimeSeriesRequest.newBuilder()
+                .setName(ProjectName.of(PROJECT_ID).toString())
+                .setFilter(metricsFilter)
+                .setInterval(interval)
+                .build();
+        ListTimeSeriesPagedResponse response = metricServiceClient.listTimeSeries(metricsRequest);
+        assertThat(response.iterateAll()).isNotEmpty();
+        for (TimeSeries ts : response.iterateAll()) {
+          assertThat(ts.getMetric().getLabelsMap().get("grpc_client_method"))
+              .isEqualTo(TEST_CLIENT_METHOD);
+          assertThat(ts.getMetric().getLabelsMap().get("grpc_client_status")).isEqualTo("OK");
+          assertThat(ts.getPoints(0).getValue().getInt64Value()).isEqualTo(1);
+        }
+        observability.close();
+      } catch (IOException | InterruptedException e) {
+        throw new AssertionError("Exception while testing metrics", e);
+      }
+    }
+  }
+}
diff --git a/gcp-observability/src/test/java/io/grpc/gcp/observability/ObservabilityConfigImplTest.java b/gcp-observability/src/test/java/io/grpc/gcp/observability/ObservabilityConfigImplTest.java
new file mode 100644
index 00000000000..f409a149bf1
--- /dev/null
+++ b/gcp-observability/src/test/java/io/grpc/gcp/observability/ObservabilityConfigImplTest.java
@@ -0,0 +1,491 @@
+/*
+ * Copyright 2022 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.gcp.observability;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.grpc.gcp.observability.ObservabilityConfig.LogFilter;
+import io.opencensus.trace.Sampler;
+import io.opencensus.trace.samplers.Samplers;
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ObservabilityConfigImplTest {
+  private static final String LOG_FILTERS = "{\n"
+      + "    \"project_id\": \"grpc-testing\",\n"
+      + "    \"cloud_logging\": {\n"
+      + "    \"client_rpc_events\": [{\n"
+      + "        \"methods\": [\"*\"],\n"
+      + "        \"max_metadata_bytes\": 4096\n"
+      + "    }"
+      + "    ],\n"
+      + "    \"server_rpc_events\": [{\n"
+      + "        \"methods\": [\"*\"],\n"
+      + "        \"max_metadata_bytes\": 32,\n"
+      + "        \"max_message_bytes\": 64\n"
+      + "    }"
+      + "    ]\n"
+      + "    }\n"
+      + "}";
+
+  private static final String CLIENT_LOG_FILTERS = "{\n"
+      + "    \"project_id\": \"grpc-testing\",\n"
+      + "    \"cloud_logging\": {\n"
+      + "    \"client_rpc_events\": [{\n"
+      + "        \"methods\": [\"*\"],\n"
+      + "        \"max_metadata_bytes\": 4096,\n"
+      + "        \"max_message_bytes\": 2048\n"
+      + "    },"
+      + "   {\n"
+      + "        \"methods\": [\"service1/Method2\", \"Service2/*\"],\n"
+      + "        \"exclude\": true\n"
+      + "    }"
+      + "    ]\n"
+      + "    }\n"
+      + "}";
+
+  private static final String SERVER_LOG_FILTERS = "{\n"
+          + "    \"project_id\": \"grpc-testing\",\n"
+          + "    \"cloud_logging\": {\n"
+          + "    \"server_rpc_events\": [{\n"
+          + "        \"methods\": [\"service1/method4\", \"service2/method234\"],\n"
+          + "        \"max_metadata_bytes\": 32,\n"
+          + "        \"max_message_bytes\": 64\n"
+          + "    },"
+          + "   {\n"
+          + "        \"methods\": [\"service4/*\", \"Service2/*\"],\n"
+          + "        \"exclude\": true\n"
+          + "    }"
+          + "    ]\n"
+          + "    }\n"
+          + "}";
+
+  private static final String VALID_LOG_FILTERS = "{\n"
+      + "    \"project_id\": \"grpc-testing\",\n"
+      + "    \"cloud_logging\": {\n"
+      + "    \"server_rpc_events\": [{\n"
+      + "        \"methods\": [\"service.Service1/*\", \"service2.Service4/method4\"],\n"
+      + "        \"max_metadata_bytes\": 16,\n"
+      + "        \"max_message_bytes\": 64\n"
+      + "    }"
+      + "    ]\n"
+      + "    }\n"
+      + "}";
+
+
+  private static final String PROJECT_ID = "{\n"
+      + "    \"project_id\": \"grpc-testing\",\n"
+      + "    \"cloud_logging\": {}\n"
+      + "}";
+
+  private static final String EMPTY_CONFIG = "{}";
+
+  private static final String ENABLE_CLOUD_MONITORING_AND_TRACING = "{\n"
+      + "    \"project_id\": \"grpc-testing\",\n"
+      + "    \"cloud_monitoring\": {},\n"
+      + "    \"cloud_trace\": {}\n"
+      + "}";
+
+  private static final String ENABLE_CLOUD_MONITORING = "{\n"
+      + "    \"project_id\": \"grpc-testing\",\n"
+      + "    \"cloud_monitoring\": {}\n"
+      + "}";
+
+  private static final String ENABLE_CLOUD_TRACE = "{\n"
+      + "    \"project_id\": \"grpc-testing\",\n"
+      + "    \"cloud_trace\": {}\n"
+      + "}";
+
+  private static final String TRACING_ALWAYS_SAMPLER = "{\n"
+      + "    \"project_id\": \"grpc-testing\",\n"
+      + "    \"cloud_trace\": {\n"
+      + "      \"sampling_rate\": 1.00\n"
+      + "    }\n"
+      + "}";
+
+  private static final String TRACING_NEVER_SAMPLER = "{\n"
+      + "    \"project_id\": \"grpc-testing\",\n"
+      + "    \"cloud_trace\": {\n"
+      + "      \"sampling_rate\": 0.00\n"
+      + "    }\n"
+      + "}";
+
+  private static final String TRACING_PROBABILISTIC_SAMPLER = "{\n"
+      + "    \"project_id\": \"grpc-testing\",\n"
+      + "    \"cloud_trace\": {\n"
+      + "      \"sampling_rate\": 0.75\n"
+      + "    }\n"
+      + "}";
+
+  private static final String TRACING_DEFAULT_SAMPLER = "{\n"
+      + "    \"project_id\": \"grpc-testing\",\n"
+      + "    \"cloud_trace\": {}\n"
+      + "}";
+
+  private static final String GLOBAL_TRACING_BAD_PROBABILISTIC_SAMPLER = "{\n"
+      + "    \"project_id\": \"grpc-testing\",\n"
+      + "    \"cloud_trace\": {\n"
+      + "      \"sampling_rate\": -0.75\n"
+      + "    }\n"
+      + "}";
+
+  private static final String CUSTOM_TAGS = "{\n"
+          + "    \"project_id\": \"grpc-testing\",\n"
+          + "    \"cloud_logging\": {},\n"
+          + "    \"labels\": {\n"
+          + "      \"SOURCE_VERSION\" : \"J2e1Cf\",\n"
+          + "      \"SERVICE_NAME\" : \"payment-service\",\n"
+          + "      \"ENTRYPOINT_SCRIPT\" : \"entrypoint.sh\"\n"
+          + "    }\n"
+          + "}";
+
+  private static final String BAD_CUSTOM_TAGS =
+      "{\n"
+          + "    \"project_id\": \"grpc-testing\",\n"
+          + "    \"cloud_monitoring\": {},\n"
+          + "    \"labels\": {\n"
+          + "      \"SOURCE_VERSION\" : \"J2e1Cf\",\n"
+          + "      \"SERVICE_NAME\" : { \"SUB_SERVICE_NAME\" : \"payment-service\"},\n"
+          + "      \"ENTRYPOINT_SCRIPT\" : \"entrypoint.sh\"\n"
+          + "    }\n"
+          + "}";
+
+  private static final String LOG_FILTER_GLOBAL_EXCLUDE =
+      "{\n"
+          + "    \"project_id\": \"grpc-testing\",\n"
+          + "    \"cloud_logging\": {\n"
+          + "    \"client_rpc_events\": [{\n"
+          + "        \"methods\": [\"service1/Method2\", \"*\"],\n"
+          + "        \"max_metadata_bytes\": 20,\n"
+          + "        \"max_message_bytes\": 15,\n"
+          + "        \"exclude\": true\n"
+          + "    }"
+          + "    ]\n"
+          + "    }\n"
+          + "}";
+
+  private static final String LOG_FILTER_INVALID_METHOD =
+      "{\n"
+          + "    \"project_id\": \"grpc-testing\",\n"
+          + "    \"cloud_logging\": {\n"
+          + "    \"client_rpc_events\": [{\n"
+          + "        \"methods\": [\"s*&%ervice1/Method2\", \"*\"],\n"
+          + "        \"max_metadata_bytes\": 20\n"
+          + "    }"
+          + "    ]\n"
+          + "    }\n"
+          + "}";
+
+  ObservabilityConfigImpl observabilityConfig = new ObservabilityConfigImpl();
+
+  @Rule public TemporaryFolder tempFolder = new TemporaryFolder();
+
+  @Test
+  public void nullConfig() throws IOException {
+    try {
+      observabilityConfig.parse(null);
+      fail("exception expected!");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae.getMessage()).isEqualTo("GRPC_GCP_OBSERVABILITY_CONFIG value is null!");
+    }
+  }
+
+  @Test
+  public void emptyConfig() throws IOException {
+    observabilityConfig.parse(EMPTY_CONFIG);
+    assertFalse(observabilityConfig.isEnableCloudLogging());
+    assertFalse(observabilityConfig.isEnableCloudMonitoring());
+    assertFalse(observabilityConfig.isEnableCloudTracing());
+    assertThat(observabilityConfig.getClientLogFilters()).isEmpty();
+    assertThat(observabilityConfig.getServerLogFilters()).isEmpty();
+    assertThat(observabilityConfig.getSampler()).isNull();
+    assertThat(observabilityConfig.getProjectId()).isNull();
+    assertThat(observabilityConfig.getCustomTags()).isEmpty();
+  }
+
+  @Test
+  public void emptyConfigFile() throws IOException {
+    File configFile = tempFolder.newFile();
+    try {
+      observabilityConfig.parseFile(configFile.getAbsolutePath());
+      fail("exception expected!");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae.getMessage()).isEqualTo(
+          "GRPC_GCP_OBSERVABILITY_CONFIG_FILE is empty!");
+    }
+  }
+
+  @Test
+  public void setProjectId() throws IOException {
+    observabilityConfig.parse(PROJECT_ID);
+    assertTrue(observabilityConfig.isEnableCloudLogging());
+    assertThat(observabilityConfig.getProjectId()).isEqualTo("grpc-testing");
+  }
+
+  @Test
+  public void logFilters() throws IOException {
+    observabilityConfig.parse(LOG_FILTERS);
+    assertTrue(observabilityConfig.isEnableCloudLogging());
+    assertThat(observabilityConfig.getProjectId()).isEqualTo("grpc-testing");
+
+    List<LogFilter> clientLogFilters = observabilityConfig.getClientLogFilters();
+    assertThat(clientLogFilters).hasSize(1);
+    assertThat(clientLogFilters.get(0).headerBytes).isEqualTo(4096);
+    assertThat(clientLogFilters.get(0).messageBytes).isEqualTo(0);
+    assertThat(clientLogFilters.get(0).excludePattern).isFalse();
+    assertThat(clientLogFilters.get(0).matchAll).isTrue();
+    assertThat(clientLogFilters.get(0).services).isEmpty();
+    assertThat(clientLogFilters.get(0).methods).isEmpty();
+
+    List<LogFilter> serverLogFilters = observabilityConfig.getServerLogFilters();
+    assertThat(serverLogFilters).hasSize(1);
+    assertThat(serverLogFilters.get(0).headerBytes).isEqualTo(32);
+    assertThat(serverLogFilters.get(0).messageBytes).isEqualTo(64);
+    assertThat(serverLogFilters.get(0).excludePattern).isFalse();
+    assertThat(serverLogFilters.get(0).matchAll).isTrue();
+    assertThat(serverLogFilters.get(0).services).isEmpty();
+    assertThat(serverLogFilters.get(0).methods).isEmpty();
+  }
+
+  @Test
+  public void setClientLogFilters() throws IOException {
+    observabilityConfig.parse(CLIENT_LOG_FILTERS);
+    assertTrue(observabilityConfig.isEnableCloudLogging());
+    assertThat(observabilityConfig.getProjectId()).isEqualTo("grpc-testing");
+    List<LogFilter> logFilterList = observabilityConfig.getClientLogFilters();
+    assertThat(logFilterList).hasSize(2);
+    assertThat(logFilterList.get(0).headerBytes).isEqualTo(4096);
+    assertThat(logFilterList.get(0).messageBytes).isEqualTo(2048);
+    assertThat(logFilterList.get(0).excludePattern).isFalse();
+    assertThat(logFilterList.get(0).matchAll).isTrue();
+    assertThat(logFilterList.get(0).services).isEmpty();
+    assertThat(logFilterList.get(0).methods).isEmpty();
+
+    assertThat(logFilterList.get(1).headerBytes).isEqualTo(0);
+    assertThat(logFilterList.get(1).messageBytes).isEqualTo(0);
+    assertThat(logFilterList.get(1).excludePattern).isTrue();
+    assertThat(logFilterList.get(1).matchAll).isFalse();
+    assertThat(logFilterList.get(1).services).isEqualTo(Collections.singleton("Service2"));
+    assertThat(logFilterList.get(1).methods)
+        .isEqualTo(Collections.singleton("service1/Method2"));
+  }
+
+  @Test
+  public void setServerLogFilters() throws IOException {
+    Set<String> expectedMethods = Stream.of("service1/method4", "service2/method234")
+        .collect(Collectors.toCollection(HashSet::new));
+    observabilityConfig.parse(SERVER_LOG_FILTERS);
+    assertTrue(observabilityConfig.isEnableCloudLogging());
+    List<LogFilter> logFilterList = observabilityConfig.getServerLogFilters();
+    assertThat(logFilterList).hasSize(2);
+    assertThat(logFilterList.get(0).headerBytes).isEqualTo(32);
+    assertThat(logFilterList.get(0).messageBytes).isEqualTo(64);
+    assertThat(logFilterList.get(0).excludePattern).isFalse();
+    assertThat(logFilterList.get(0).matchAll).isFalse();
+    assertThat(logFilterList.get(0).services).isEmpty();
+    assertThat(logFilterList.get(0).methods)
+        .isEqualTo(expectedMethods);
+
+    Set<String> expectedServices = Stream.of("service4", "Service2")
+        .collect(Collectors.toCollection(HashSet::new));
+    assertThat(logFilterList.get(1).headerBytes).isEqualTo(0);
+    assertThat(logFilterList.get(1).messageBytes).isEqualTo(0);
+    assertThat(logFilterList.get(1).excludePattern).isTrue();
+    assertThat(logFilterList.get(1).matchAll).isFalse();
+    assertThat(logFilterList.get(1).services).isEqualTo(expectedServices);
+    assertThat(logFilterList.get(1).methods).isEmpty();
+  }
+
+  @Test
+  public void enableCloudMonitoring() throws IOException {
+    observabilityConfig.parse(ENABLE_CLOUD_MONITORING);
+    assertTrue(observabilityConfig.isEnableCloudMonitoring());
+  }
+
+  @Test
+  public void enableCloudTracing() throws IOException {
+    observabilityConfig.parse(ENABLE_CLOUD_TRACE);
+    assertTrue(observabilityConfig.isEnableCloudTracing());
+  }
+
+  @Test
+  public void enableCloudMonitoringAndTracing() throws IOException {
+    observabilityConfig.parse(ENABLE_CLOUD_MONITORING_AND_TRACING);
+    assertFalse(observabilityConfig.isEnableCloudLogging());
+    assertTrue(observabilityConfig.isEnableCloudMonitoring());
+    assertTrue(observabilityConfig.isEnableCloudTracing());
+  }
+
+  @Test
+  public void alwaysSampler() throws IOException {
+    observabilityConfig.parse(TRACING_ALWAYS_SAMPLER);
+    assertTrue(observabilityConfig.isEnableCloudTracing());
+    Sampler sampler = observabilityConfig.getSampler();
+    assertThat(sampler).isNotNull();
+    assertThat(sampler).isEqualTo(Samplers.alwaysSample());
+  }
+
+  @Test
+  public void neverSampler() throws IOException {
+    observabilityConfig.parse(TRACING_NEVER_SAMPLER);
+    assertTrue(observabilityConfig.isEnableCloudTracing());
+    Sampler sampler = observabilityConfig.getSampler();
+    assertThat(sampler).isNotNull();
+    assertThat(sampler).isEqualTo(Samplers.probabilitySampler(0.0));
+  }
+
+  @Test
+  public void probabilisticSampler() throws IOException {
+    observabilityConfig.parse(TRACING_PROBABILISTIC_SAMPLER);
+    assertTrue(observabilityConfig.isEnableCloudTracing());
+    Sampler sampler = observabilityConfig.getSampler();
+    assertThat(sampler).isNotNull();
+    assertThat(sampler).isEqualTo(Samplers.probabilitySampler(0.75));
+  }
+
+  @Test
+  public void defaultSampler() throws IOException {
+    observabilityConfig.parse(TRACING_DEFAULT_SAMPLER);
+    assertTrue(observabilityConfig.isEnableCloudTracing());
+    Sampler sampler = observabilityConfig.getSampler();
+    assertThat(sampler).isNotNull();
+    assertThat(sampler).isEqualTo(Samplers.probabilitySampler(0.00));
+  }
+
+  @Test
+  public void badProbabilisticSampler_error() throws IOException {
+    try {
+      observabilityConfig.parse(GLOBAL_TRACING_BAD_PROBABILISTIC_SAMPLER);
+      fail("exception expected!");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae.getMessage()).isEqualTo(
+          "'sampling_rate' needs to be between [0.0, 1.0]");
+    }
+  }
+
+  @Test
+  public void configFileLogFilters() throws Exception {
+    File configFile = tempFolder.newFile();
+    Files.write(
+        Paths.get(configFile.getAbsolutePath()),
+        CLIENT_LOG_FILTERS.getBytes(StandardCharsets.US_ASCII));
+    observabilityConfig.parseFile(configFile.getAbsolutePath());
+    assertTrue(observabilityConfig.isEnableCloudLogging());
+    assertThat(observabilityConfig.getProjectId()).isEqualTo("grpc-testing");
+    List<LogFilter> logFilters = observabilityConfig.getClientLogFilters();
+    assertThat(logFilters).hasSize(2);
+    assertThat(logFilters.get(0).headerBytes).isEqualTo(4096);
+    assertThat(logFilters.get(0).messageBytes).isEqualTo(2048);
+    assertThat(logFilters.get(1).headerBytes).isEqualTo(0);
+    assertThat(logFilters.get(1).messageBytes).isEqualTo(0);
+
+    assertThat(logFilters).hasSize(2);
+    assertThat(logFilters.get(0).headerBytes).isEqualTo(4096);
+    assertThat(logFilters.get(0).messageBytes).isEqualTo(2048);
+    assertThat(logFilters.get(0).excludePattern).isFalse();
+    assertThat(logFilters.get(0).matchAll).isTrue();
+    assertThat(logFilters.get(0).services).isEmpty();
+    assertThat(logFilters.get(0).methods).isEmpty();
+
+    assertThat(logFilters.get(1).headerBytes).isEqualTo(0);
+    assertThat(logFilters.get(1).messageBytes).isEqualTo(0);
+    assertThat(logFilters.get(1).excludePattern).isTrue();
+    assertThat(logFilters.get(1).matchAll).isFalse();
+    assertThat(logFilters.get(1).services).isEqualTo(Collections.singleton("Service2"));
+    assertThat(logFilters.get(1).methods)
+        .isEqualTo(Collections.singleton("service1/Method2"));
+  }
+
+  @Test
+  public void customTags() throws IOException {
+    observabilityConfig.parse(CUSTOM_TAGS);
+    assertTrue(observabilityConfig.isEnableCloudLogging());
+    Map<String, String> customTags = observabilityConfig.getCustomTags();
+    assertThat(customTags).hasSize(3);
+    assertThat(customTags).containsEntry("SOURCE_VERSION", "J2e1Cf");
+    assertThat(customTags).containsEntry("SERVICE_NAME", "payment-service");
+    assertThat(customTags).containsEntry("ENTRYPOINT_SCRIPT", "entrypoint.sh");
+  }
+
+  @Test
+  public void badCustomTags() throws IOException {
+    try {
+      observabilityConfig.parse(BAD_CUSTOM_TAGS);
+      fail("exception expected!");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae.getMessage()).isEqualTo(
+              "'labels' needs to be a map of <string, string>");
+    }
+  }
+
+  @Test
+  public void globalLogFilterExclude() throws IOException {
+    try {
+      observabilityConfig.parse(LOG_FILTER_GLOBAL_EXCLUDE);
+      fail("exception expected!");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae.getMessage()).isEqualTo(
+          "cannot have 'exclude' and '*' wildcard in the same filter");
+    }
+  }
+
+  @Test
+  public void logFilterInvalidMethod() throws IOException {
+    try {
+      observabilityConfig.parse(LOG_FILTER_INVALID_METHOD);
+      fail("exception expected!");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae.getMessage()).contains(
+          "invalid service or method filter");
+    }
+  }
+
+  @Test
+  public void validLogFilter() throws Exception {
+    observabilityConfig.parse(VALID_LOG_FILTERS);
+    assertTrue(observabilityConfig.isEnableCloudLogging());
+    assertThat(observabilityConfig.getProjectId()).isEqualTo("grpc-testing");
+    List<LogFilter> logFilterList = observabilityConfig.getServerLogFilters();
+    assertThat(logFilterList).hasSize(1);
+    assertThat(logFilterList.get(0).headerBytes).isEqualTo(16);
+    assertThat(logFilterList.get(0).messageBytes).isEqualTo(64);
+    assertThat(logFilterList.get(0).excludePattern).isFalse();
+    assertThat(logFilterList.get(0).matchAll).isFalse();
+    assertThat(logFilterList.get(0).services).isEqualTo(Collections.singleton("service.Service1"));
+    assertThat(logFilterList.get(0).methods)
+        .isEqualTo(Collections.singleton("service2.Service4/method4"));
+  }
+}
diff --git a/gcp-observability/src/test/java/io/grpc/gcp/observability/ObservabilityTestHelper.java b/gcp-observability/src/test/java/io/grpc/gcp/observability/ObservabilityTestHelper.java
new file mode 100644
index 00000000000..ebb73ec76a1
--- /dev/null
+++ b/gcp-observability/src/test/java/io/grpc/gcp/observability/ObservabilityTestHelper.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2022 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.gcp.observability;
+
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+
+public class ObservabilityTestHelper {
+
+  static String makeUnaryRpcViaClientStub(
+      String requestMessage, SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub) {
+    SimpleRequest request = SimpleRequest.newBuilder().setRequestMessage(requestMessage).build();
+    SimpleResponse response = blockingStub.unaryRpc(request);
+    return response.getResponseMessage();
+  }
+
+  static class SimpleServiceImpl extends SimpleServiceGrpc.SimpleServiceImplBase {
+
+    @Override
+    public void unaryRpc(SimpleRequest req, StreamObserver<SimpleResponse> responseObserver) {
+      SimpleResponse response =
+          SimpleResponse.newBuilder()
+              .setResponseMessage("Hello " + req.getRequestMessage())
+              .build();
+      responseObserver.onNext(response);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/gcp-observability/src/test/java/io/grpc/gcp/observability/TracesTest.java b/gcp-observability/src/test/java/io/grpc/gcp/observability/TracesTest.java
new file mode 100644
index 00000000000..ae7aa63befc
--- /dev/null
+++ b/gcp-observability/src/test/java/io/grpc/gcp/observability/TracesTest.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright 2022 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.gcp.observability;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.cloud.trace.v1.TraceServiceClient;
+import com.google.cloud.trace.v1.TraceServiceClient.ListTracesPagedResponse;
+import com.google.devtools.cloudtrace.v1.GetTraceRequest;
+import com.google.devtools.cloudtrace.v1.ListTracesRequest;
+import com.google.devtools.cloudtrace.v1.Trace;
+import com.google.devtools.cloudtrace.v1.TraceSpan;
+import com.google.protobuf.util.Timestamps;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.StaticTestingClassLoader;
+import io.grpc.gcp.observability.interceptors.InternalLoggingChannelInterceptor;
+import io.grpc.gcp.observability.interceptors.InternalLoggingServerInterceptor;
+import io.grpc.gcp.observability.logging.GcpLogSink;
+import io.grpc.gcp.observability.logging.Sink;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import io.opencensus.trace.samplers.Samplers;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.regex.Pattern;
+import org.junit.ClassRule;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class TracesTest {
+
+  @ClassRule
+  public static final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+
+  private static final String PROJECT_ID = "PROJECT";
+  private static final String CUSTOM_TAG_KEY = "service";
+  private static final String CUSTOM_TAG_VALUE =
+      String.format("payment-%s", String.valueOf(System.currentTimeMillis()));
+  private static final Map<String, String> CUSTOM_TAGS =
+      Collections.singletonMap(CUSTOM_TAG_KEY, CUSTOM_TAG_VALUE);
+
+  private final StaticTestingClassLoader classLoader =
+      new StaticTestingClassLoader(getClass().getClassLoader(),
+          Pattern.compile("io\\.grpc\\..*|io\\.opencensus\\..*"));
+
+  /**
+   * End to end cloud trace test.
+   *
+   * <p>Ignoring test, because it calls external Cloud Tracing APIs. To test cloud trace setup
+   * locally,
+   * 1. Set up Cloud auth credentials
+   * 2. Assign permissions to service account to write traces to project specified by variable
+   * PROJECT_ID
+   * 3. Comment @Ignore annotation
+   * 4. This test is expected to pass when ran with above setup. This has been verified manually.
+   */
+  @Ignore
+  @Test
+  public void testTracesExporter() throws Exception {
+    Class<?> runnable =
+        classLoader.loadClass(TracesTest.StaticTestingClassTestTracesExporter.class.getName());
+    ((Runnable) runnable.getDeclaredConstructor().newInstance()).run();
+  }
+
+  public static final class StaticTestingClassTestTracesExporter implements Runnable {
+
+    @Override
+    public void run() {
+      Sink mockSink = mock(GcpLogSink.class);
+      ObservabilityConfig mockConfig = mock(ObservabilityConfig.class);
+      InternalLoggingChannelInterceptor.Factory mockChannelInterceptorFactory =
+          mock(InternalLoggingChannelInterceptor.Factory.class);
+      InternalLoggingServerInterceptor.Factory mockServerInterceptorFactory =
+          mock(InternalLoggingServerInterceptor.Factory.class);
+
+      when(mockConfig.isEnableCloudTracing()).thenReturn(true);
+      when(mockConfig.getSampler()).thenReturn(Samplers.alwaysSample());
+      when(mockConfig.getProjectId()).thenReturn(PROJECT_ID);
+
+      try {
+        GcpObservability observability =
+            GcpObservability.grpcInit(
+                mockSink, mockConfig, mockChannelInterceptorFactory, mockServerInterceptorFactory);
+        observability.registerStackDriverExporter(PROJECT_ID, CUSTOM_TAGS);
+
+        Server server =
+            ServerBuilder.forPort(0)
+                .addService(new ObservabilityTestHelper.SimpleServiceImpl())
+                .build()
+                .start();
+        int port = cleanupRule.register(server).getPort();
+        SimpleServiceGrpc.SimpleServiceBlockingStub stub =
+            SimpleServiceGrpc.newBlockingStub(
+                cleanupRule.register(
+                    ManagedChannelBuilder.forAddress("localhost", port).usePlaintext().build()));
+        assertThat(ObservabilityTestHelper.makeUnaryRpcViaClientStub("buddy", stub))
+            .isEqualTo("Hello buddy");
+        // Adding sleep to ensure traces are exported before querying cloud tracing backend
+        TimeUnit.SECONDS.sleep(10);
+
+        TraceServiceClient traceServiceClient = TraceServiceClient.create();
+        String traceFilter =
+            String.format(
+                "span:Sent.grpc.testing.SimpleService +%s:%s", CUSTOM_TAG_KEY, CUSTOM_TAG_VALUE);
+        String traceOrder = "start";
+        // Restrict time to last 1 minute
+        long startMillis = System.currentTimeMillis() - ((60 * 1) * 1000);
+        ListTracesRequest traceRequest =
+            ListTracesRequest.newBuilder()
+                .setProjectId(PROJECT_ID)
+                .setStartTime(Timestamps.fromMillis(startMillis))
+                .setEndTime(Timestamps.fromMillis(System.currentTimeMillis()))
+                .setFilter(traceFilter)
+                .setOrderBy(traceOrder)
+                .build();
+        ListTracesPagedResponse traceResponse = traceServiceClient.listTraces(traceRequest);
+        assertThat(traceResponse.iterateAll()).isNotEmpty();
+        List<String> traceIdList = new ArrayList<>();
+        for (Trace t : traceResponse.iterateAll()) {
+          traceIdList.add(t.getTraceId());
+        }
+
+        for (String traceId : traceIdList) {
+          // This checks Cloud trace for the new trace that was just created.
+          GetTraceRequest getTraceRequest =
+              GetTraceRequest.newBuilder().setProjectId(PROJECT_ID).setTraceId(traceId).build();
+          Trace trace = traceServiceClient.getTrace(getTraceRequest);
+          assertThat(trace.getSpansList()).hasSize(3);
+          for (TraceSpan span : trace.getSpansList()) {
+            assertThat(span.getName()).contains("grpc.testing.SimpleService.UnaryRpc");
+            assertThat(span.getLabelsMap().get(CUSTOM_TAG_KEY)).isEqualTo(CUSTOM_TAG_VALUE);
+          }
+        }
+        observability.close();
+      } catch (IOException | InterruptedException e) {
+        throw new AssertionError("Exception while testing traces", e);
+      }
+    }
+  }
+}
diff --git a/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/ConditionalClientInterceptorTest.java b/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/ConditionalClientInterceptorTest.java
new file mode 100644
index 00000000000..d9e37a08293
--- /dev/null
+++ b/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/ConditionalClientInterceptorTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2022 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.gcp.observability.interceptors;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.MethodType;
+import java.util.function.BiPredicate;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Tests for {@link ConditionalClientInterceptor}.
+ */
+@RunWith(JUnit4.class)
+public class ConditionalClientInterceptorTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private ConditionalClientInterceptor conditionalClientInterceptor;
+  @Mock private ClientInterceptor delegate;
+  @Mock private BiPredicate<MethodDescriptor<?, ?>, CallOptions> predicate;
+  @Mock private Channel channel;
+  @Mock private ClientCall<?, ?> returnedCall;
+  private MethodDescriptor<?, ?> method;
+
+  @Before
+  @SuppressWarnings("unchecked")
+  public void setUp() throws Exception {
+    conditionalClientInterceptor = new ConditionalClientInterceptor(
+        delegate, predicate);
+    method = MethodDescriptor.newBuilder().setType(MethodType.UNARY)
+        .setFullMethodName("service/method")
+        .setRequestMarshaller(mock(MethodDescriptor.Marshaller.class))
+        .setResponseMarshaller(mock(MethodDescriptor.Marshaller.class))
+        .build();
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void predicateFalse() {
+    when(predicate.test(any(MethodDescriptor.class), any(CallOptions.class))).thenReturn(false);
+    doReturn(returnedCall).when(channel).newCall(method, CallOptions.DEFAULT);
+    ClientCall<?, ?> clientCall = conditionalClientInterceptor.interceptCall(method,
+        CallOptions.DEFAULT, channel);
+    assertThat(clientCall).isSameInstanceAs(returnedCall);
+    verify(delegate, never()).interceptCall(any(MethodDescriptor.class), any(CallOptions.class),
+        any(Channel.class));
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void predicateTrue() {
+    when(predicate.test(any(MethodDescriptor.class), any(CallOptions.class))).thenReturn(true);
+    doReturn(returnedCall).when(delegate).interceptCall(method, CallOptions.DEFAULT, channel);
+    ClientCall<?, ?> clientCall = conditionalClientInterceptor.interceptCall(method,
+        CallOptions.DEFAULT, channel);
+    assertThat(clientCall).isSameInstanceAs(returnedCall);
+    verify(channel, never()).newCall(any(MethodDescriptor.class), any(CallOptions.class));
+  }
+}
diff --git a/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/ConfigFilterHelperTest.java b/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/ConfigFilterHelperTest.java
new file mode 100644
index 00000000000..971e6070777
--- /dev/null
+++ b/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/ConfigFilterHelperTest.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright 2022 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.gcp.observability.interceptors;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.gcp.observability.ObservabilityConfig;
+import io.grpc.gcp.observability.ObservabilityConfig.LogFilter;
+import io.grpc.gcp.observability.interceptors.ConfigFilterHelper.FilterParams;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ConfigFilterHelperTest {
+  private static final ImmutableList<LogFilter> configLogFilters =
+      ImmutableList.of(
+          new LogFilter(Collections.emptySet(), Collections.singleton("service1/Method2"), false,
+              1024, 1024, false),
+          new LogFilter(
+              Collections.singleton("service2"), Collections.singleton("service4/method2"), false,
+              2048, 1024, false),
+          new LogFilter(
+              Collections.singleton("service2"), Collections.singleton("service4/method3"), false,
+              2048, 1024, true),
+          new LogFilter(
+              Collections.emptySet(), Collections.emptySet(), true,
+              128, 128, false));
+
+  private ObservabilityConfig mockConfig;
+  private ConfigFilterHelper configFilterHelper;
+
+  @Before
+  public void setup() {
+    mockConfig = mock(ObservabilityConfig.class);
+    configFilterHelper = ConfigFilterHelper.getInstance(mockConfig);
+  }
+
+  @Test
+  public void enableCloudLogging_withoutLogFilters() {
+    when(mockConfig.isEnableCloudLogging()).thenReturn(true);
+    assertThat(mockConfig.getClientLogFilters()).isEmpty();
+    assertThat(mockConfig.getServerLogFilters()).isEmpty();
+  }
+
+  @Test
+  public void checkMethodLog_withoutLogFilters() {
+    when(mockConfig.isEnableCloudLogging()).thenReturn(true);
+    assertThat(mockConfig.getClientLogFilters()).isEmpty();
+    assertThat(mockConfig.getServerLogFilters()).isEmpty();
+
+    FilterParams expectedParams =
+        FilterParams.create(false, 0, 0);
+    FilterParams clientResultParams
+        = configFilterHelper.logRpcMethod("service3/Method3", true);
+    assertThat(clientResultParams).isEqualTo(expectedParams);
+    FilterParams serverResultParams
+        = configFilterHelper.logRpcMethod("service3/Method3", false);
+    assertThat(serverResultParams).isEqualTo(expectedParams);
+  }
+
+  @Test
+  public void checkMethodAlwaysLogged() {
+    List<LogFilter> sampleLogFilters =
+        ImmutableList.of(
+            new LogFilter(
+                Collections.emptySet(), Collections.emptySet(), true,
+                4096, 4096, false));
+    when(mockConfig.getClientLogFilters()).thenReturn(sampleLogFilters);
+    when(mockConfig.getServerLogFilters()).thenReturn(sampleLogFilters);
+
+    FilterParams expectedParams =
+        FilterParams.create(true, 4096, 4096);
+    FilterParams clientResultParams
+        = configFilterHelper.logRpcMethod("service1/Method6", true);
+    assertThat(clientResultParams).isEqualTo(expectedParams);
+    FilterParams serverResultParams
+        = configFilterHelper.logRpcMethod("service1/Method6", false);
+    assertThat(serverResultParams).isEqualTo(expectedParams);
+  }
+
+  @Test
+  public void checkMethodNotToBeLogged() {
+    List<LogFilter> sampleLogFilters =
+        ImmutableList.of(
+            new LogFilter(Collections.emptySet(), Collections.singleton("service2/*"), false,
+                1024, 1024, true),
+            new LogFilter(
+                Collections.singleton("service2/Method1"), Collections.emptySet(), false,
+                2048, 1024, false));
+    when(mockConfig.getClientLogFilters()).thenReturn(sampleLogFilters);
+    when(mockConfig.getServerLogFilters()).thenReturn(sampleLogFilters);
+
+    FilterParams expectedParams =
+        FilterParams.create(false, 0, 0);
+    FilterParams clientResultParams1
+        = configFilterHelper.logRpcMethod("service3/Method3", true);
+    assertThat(clientResultParams1).isEqualTo(expectedParams);
+
+    FilterParams clientResultParams2
+        = configFilterHelper.logRpcMethod("service2/Method1", true);
+    assertThat(clientResultParams2).isEqualTo(expectedParams);
+
+    FilterParams serverResultParams
+        = configFilterHelper.logRpcMethod("service2/Method1", false);
+    assertThat(serverResultParams).isEqualTo(expectedParams);
+  }
+
+  @Test
+  public void checkMethodToBeLoggedConditional() {
+    when(mockConfig.getClientLogFilters()).thenReturn(configLogFilters);
+    when(mockConfig.getServerLogFilters()).thenReturn(configLogFilters);
+
+    FilterParams expectedParams =
+        FilterParams.create(true, 1024, 1024);
+    FilterParams resultParams
+        = configFilterHelper.logRpcMethod("service1/Method2", true);
+    assertThat(resultParams).isEqualTo(expectedParams);
+
+    FilterParams expectedParamsWildCard =
+        FilterParams.create(true, 2048, 1024);
+    FilterParams resultParamsWildCard
+        = configFilterHelper.logRpcMethod("service2/Method1", true);
+    assertThat(resultParamsWildCard).isEqualTo(expectedParamsWildCard);
+
+    FilterParams excludeParams =
+        FilterParams.create(false, 0, 0);
+    FilterParams serverResultParams
+        = configFilterHelper.logRpcMethod("service4/method3", false);
+    assertThat(serverResultParams).isEqualTo(excludeParams);
+  }
+}
diff --git a/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/InternalLoggingChannelInterceptorTest.java b/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/InternalLoggingChannelInterceptorTest.java
new file mode 100644
index 00000000000..6594876ff53
--- /dev/null
+++ b/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/InternalLoggingChannelInterceptorTest.java
@@ -0,0 +1,828 @@
+/*
+ * Copyright 2022 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.gcp.observability.interceptors;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.census.internal.ObservabilityCensusConstants.CLIENT_TRACE_SPAN_CONTEXT_KEY;
+import static io.grpc.gcp.observability.interceptors.LogHelperTest.BYTEARRAY_MARSHALLER;
+import static org.junit.Assert.assertSame;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.protobuf.Duration;
+import com.google.protobuf.util.Durations;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.Context;
+import io.grpc.Deadline;
+import io.grpc.Grpc;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.NoopClientCall;
+import io.grpc.Status;
+import io.grpc.gcp.observability.interceptors.ConfigFilterHelper.FilterParams;
+import io.grpc.observabilitylog.v1.GrpcLogRecord;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventLogger;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventType;
+import io.opencensus.trace.SpanContext;
+import io.opencensus.trace.SpanId;
+import io.opencensus.trace.TraceId;
+import io.opencensus.trace.TraceOptions;
+import io.opencensus.trace.Tracestate;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.Objects;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.AdditionalMatchers;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Tests for {@link InternalLoggingChannelInterceptor}.
+ */
+@RunWith(JUnit4.class)
+public class InternalLoggingChannelInterceptorTest {
+
+  @Rule
+  public final MockitoRule mockito = MockitoJUnit.rule();
+
+  private static final Charset US_ASCII = StandardCharsets.US_ASCII;
+  private static final SpanContext DEFAULT_CLIENT_SPAN_CONTEXT = SpanContext.INVALID;
+  private static final SpanContext SPAN_CONTEXT = SpanContext.create(
+      TraceId.fromLowerBase16("4c6af40c499951eb7de2777ba1e4fefa"),
+      SpanId.fromLowerBase16("de52e84d13dd232d"),
+      TraceOptions.builder().setIsSampled(true).build(),
+      Tracestate.builder().build());
+  private static final CallOptions CALL_OPTIONS_WITH_SPAN_CONTEXT =
+      CallOptions.DEFAULT.withOption(CLIENT_TRACE_SPAN_CONTEXT_KEY, SPAN_CONTEXT);
+
+  private InternalLoggingChannelInterceptor.Factory factory;
+  private AtomicReference<ClientCall.Listener<byte[]>> interceptedListener;
+  private AtomicReference<Metadata> actualClientInitial;
+  private AtomicReference<Object> actualRequest;
+  private SettableFuture<Void> halfCloseCalled;
+  private SettableFuture<Void> cancelCalled;
+  @SuppressWarnings("AddressSelection") // It will only be one address
+  private SocketAddress peer = new InetSocketAddress("127.0.0.1", 1234);
+  private LogHelper mockLogHelper;
+  private ConfigFilterHelper mockFilterHelper;
+  private FilterParams filterParams;
+
+  @Before
+  public void setup() throws Exception {
+    mockLogHelper = mock(LogHelper.class);
+    mockFilterHelper = mock(ConfigFilterHelper.class);
+    factory = new InternalLoggingChannelInterceptor.FactoryImpl(mockLogHelper, mockFilterHelper);
+    interceptedListener = new AtomicReference<>();
+    actualClientInitial = new AtomicReference<>();
+    actualRequest = new AtomicReference<>();
+    halfCloseCalled = SettableFuture.create();
+    cancelCalled = SettableFuture.create();
+    filterParams = FilterParams.create(true, 0, 0);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void internalLoggingChannelInterceptor() throws Exception {
+    Channel channel = new Channel() {
+      @Override
+      public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+          MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+        return new NoopClientCall<RequestT, ResponseT>() {
+          @Override
+          @SuppressWarnings("unchecked")
+          public void start(Listener<ResponseT> responseListener, Metadata headers) {
+            interceptedListener.set((Listener<byte[]>) responseListener);
+            actualClientInitial.set(headers);
+          }
+
+          @Override
+          public void sendMessage(RequestT message) {
+            actualRequest.set(message);
+          }
+
+          @Override
+          public void cancel(String message, Throwable cause) {
+            cancelCalled.set(null);
+          }
+
+          @Override
+          public void halfClose() {
+            halfCloseCalled.set(null);
+          }
+
+          @Override
+          public Attributes getAttributes() {
+            return Attributes.newBuilder().set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, peer).build();
+          }
+        };
+      }
+
+      @Override
+      public String authority() {
+        return "the-authority";
+      }
+    };
+
+    ClientCall.Listener<byte[]> mockListener = mock(ClientCall.Listener.class);
+
+    MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    when(mockFilterHelper.logRpcMethod(method.getFullMethodName(), true))
+        .thenReturn(filterParams);
+
+    ClientCall<byte[], byte[]> interceptedLoggingCall =
+        factory.create()
+            .interceptCall(method,
+                CallOptions.DEFAULT,
+                channel);
+
+    // send request header
+    {
+      Metadata clientInitial = new Metadata();
+      String dataA = "aaaaaaaaa";
+      String dataB = "bbbbbbbbb";
+      Metadata.Key<String> keyA =
+          Metadata.Key.of("a", Metadata.ASCII_STRING_MARSHALLER);
+      Metadata.Key<String> keyB =
+          Metadata.Key.of("b", Metadata.ASCII_STRING_MARSHALLER);
+      clientInitial.put(keyA, dataA);
+      clientInitial.put(keyB, dataB);
+      interceptedLoggingCall.start(mockListener, clientInitial);
+      verify(mockLogHelper).logClientHeader(
+          /*seq=*/ eq(1L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          ArgumentMatchers.isNull(),
+          same(clientInitial),
+          eq(filterParams.headerBytes()),
+          eq(EventLogger.CLIENT),
+          anyString(),
+          ArgumentMatchers.isNull(),
+          eq(DEFAULT_CLIENT_SPAN_CONTEXT));
+      verifyNoMoreInteractions(mockLogHelper);
+      assertSame(clientInitial, actualClientInitial.get());
+    }
+
+    reset(mockLogHelper);
+    reset(mockListener);
+
+    // receive response header
+    {
+      Metadata serverInitial = new Metadata();
+      interceptedListener.get().onHeaders(serverInitial);
+      verify(mockLogHelper).logServerHeader(
+          /*seq=*/ eq(2L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          same(serverInitial),
+          eq(filterParams.headerBytes()),
+          eq(EventLogger.CLIENT),
+          anyString(),
+          same(peer),
+          any(SpanContext.class));
+      verifyNoMoreInteractions(mockLogHelper);
+      verify(mockListener).onHeaders(same(serverInitial));
+    }
+
+    reset(mockLogHelper);
+    reset(mockListener);
+
+    // send request message
+    {
+      byte[] request = "this is a request".getBytes(US_ASCII);
+      interceptedLoggingCall.sendMessage(request);
+      verify(mockLogHelper).logRpcMessage(
+          /*seq=*/ eq(3L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          eq(EventType.CLIENT_MESSAGE),
+          same(request),
+          eq(filterParams.messageBytes()),
+          eq(EventLogger.CLIENT),
+          anyString(),
+          any(SpanContext.class));
+      verifyNoMoreInteractions(mockLogHelper);
+      assertSame(request, actualRequest.get());
+    }
+
+    reset(mockLogHelper);
+    reset(mockListener);
+
+    // client half close
+    {
+      interceptedLoggingCall.halfClose();
+      verify(mockLogHelper).logHalfClose(
+          /*seq=*/ eq(4L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          eq(EventLogger.CLIENT),
+          anyString(),
+          any(SpanContext.class));
+      halfCloseCalled.get(1, TimeUnit.MILLISECONDS);
+      verifyNoMoreInteractions(mockLogHelper);
+    }
+
+    reset(mockLogHelper);
+    reset(mockListener);
+
+    // receive response message
+    {
+      byte[] response = "this is a response".getBytes(US_ASCII);
+      interceptedListener.get().onMessage(response);
+      verify(mockLogHelper).logRpcMessage(
+          /*seq=*/ eq(5L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          eq(EventType.SERVER_MESSAGE),
+          same(response),
+          eq(filterParams.messageBytes()),
+          eq(EventLogger.CLIENT),
+          anyString(),
+          any(SpanContext.class));
+      verifyNoMoreInteractions(mockLogHelper);
+      verify(mockListener).onMessage(same(response));
+    }
+
+    reset(mockLogHelper);
+    reset(mockListener);
+
+    // receive trailer
+    {
+      Status status = Status.INTERNAL.withDescription("trailer description");
+      Metadata trailers = new Metadata();
+      interceptedListener.get().onClose(status, trailers);
+      verify(mockLogHelper).logTrailer(
+          /*seq=*/ eq(6L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          same(status),
+          same(trailers),
+          eq(filterParams.headerBytes()),
+          eq(EventLogger.CLIENT),
+          anyString(),
+          same(peer),
+          any(SpanContext.class));
+      verifyNoMoreInteractions(mockLogHelper);
+      verify(mockListener).onClose(same(status), same(trailers));
+    }
+
+    reset(mockLogHelper);
+    reset(mockListener);
+
+    // cancel
+    {
+      interceptedLoggingCall.cancel(null, null);
+      verify(mockLogHelper).logCancel(
+          /*seq=*/ eq(7L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          eq(EventLogger.CLIENT),
+          anyString(),
+          any(SpanContext.class));
+      cancelCalled.get(1, TimeUnit.MILLISECONDS);
+    }
+  }
+
+  @Test
+  public void clientDeadLineLogged_deadlineSetViaCallOption() {
+    MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    when(mockFilterHelper.logRpcMethod(method.getFullMethodName(), true))
+        .thenReturn(filterParams);
+    @SuppressWarnings("unchecked")
+    ClientCall.Listener<byte[]> mockListener = mock(ClientCall.Listener.class);
+
+    int durationSecs = 5;
+    ClientCall<byte[], byte[]> interceptedLoggingCall =
+        factory.create()
+            .interceptCall(
+                method,
+                CallOptions.DEFAULT.withDeadlineAfter(durationSecs, TimeUnit.SECONDS),
+                new Channel() {
+                  @Override
+                  public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+                      MethodDescriptor<RequestT, ResponseT> methodDescriptor,
+                      CallOptions callOptions) {
+                    return new NoopClientCall<>();
+                  }
+
+                  @Override
+                  public String authority() {
+                    return "the-authority";
+                  }
+                });
+    interceptedLoggingCall.start(mockListener, new Metadata());
+    ArgumentCaptor<Duration> callOptTimeoutCaptor = ArgumentCaptor.forClass(Duration.class);
+    verify(mockLogHelper, times(1))
+        .logClientHeader(
+            anyLong(),
+            AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+            AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+            AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+            callOptTimeoutCaptor.capture(),
+            any(Metadata.class),
+            anyInt(),
+            any(GrpcLogRecord.EventLogger.class),
+            anyString(),
+            AdditionalMatchers.or(ArgumentMatchers.isNull(),
+                ArgumentMatchers.any()),
+            any(SpanContext.class));
+    Duration timeout = callOptTimeoutCaptor.getValue();
+    assertThat(Math.abs(TimeUnit.SECONDS.toNanos(durationSecs) - Durations.toNanos(timeout)))
+        .isAtMost(TimeUnit.MILLISECONDS.toNanos(750));
+  }
+
+  @Test
+  public void clientDeadlineLogged_deadlineSetViaContext() throws Exception {
+    final SettableFuture<ClientCall<byte[], byte[]>> callFuture = SettableFuture.create();
+    Context.current()
+        .withDeadline(
+            Deadline.after(2, TimeUnit.SECONDS),
+            Executors.newSingleThreadScheduledExecutor())
+        .run(() -> {
+          MethodDescriptor<byte[], byte[]> method =
+              MethodDescriptor.<byte[], byte[]>newBuilder()
+                  .setType(MethodType.UNKNOWN)
+                  .setFullMethodName("service/method")
+                  .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+                  .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+                  .build();
+          when(mockFilterHelper.logRpcMethod(method.getFullMethodName(), true))
+              .thenReturn(filterParams);
+
+          callFuture.set(
+              factory.create()
+                  .interceptCall(
+                      method,
+                      CallOptions.DEFAULT.withDeadlineAfter(5, TimeUnit.SECONDS),
+                      new Channel() {
+                        @Override
+                        public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+                            MethodDescriptor<RequestT, ResponseT> methodDescriptor,
+                            CallOptions callOptions) {
+                          return new NoopClientCall<>();
+                        }
+
+                        @Override
+                        public String authority() {
+                          return "the-authority";
+                        }
+                      }));
+        });
+    @SuppressWarnings("unchecked")
+    ClientCall.Listener<byte[]> mockListener = mock(ClientCall.Listener.class);
+    Objects.requireNonNull(callFuture.get()).start(mockListener, new Metadata());
+    ArgumentCaptor<Duration> contextTimeoutCaptor = ArgumentCaptor.forClass(Duration.class);
+    verify(mockLogHelper, times(1))
+        .logClientHeader(
+            anyLong(),
+            AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+            AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+            AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+            contextTimeoutCaptor.capture(),
+            any(Metadata.class),
+            anyInt(),
+            any(GrpcLogRecord.EventLogger.class),
+            anyString(),
+            AdditionalMatchers.or(ArgumentMatchers.isNull(),
+                ArgumentMatchers.any()),
+            any(SpanContext.class));
+    Duration timeout = contextTimeoutCaptor.getValue();
+    assertThat(Math.abs(TimeUnit.SECONDS.toNanos(2) - Durations.toNanos(timeout)))
+        .isAtMost(TimeUnit.MILLISECONDS.toNanos(750));
+  }
+
+  @Test
+  public void clientDeadlineLogged_deadlineSetViaContextAndCallOptions() throws Exception {
+    Deadline contextDeadline = Deadline.after(10, TimeUnit.SECONDS);
+    Deadline callOptionsDeadline = CallOptions.DEFAULT
+        .withDeadlineAfter(15, TimeUnit.SECONDS).getDeadline();
+
+    final SettableFuture<ClientCall<byte[], byte[]>> callFuture = SettableFuture.create();
+    Context.current()
+        .withDeadline(
+            contextDeadline, Executors.newSingleThreadScheduledExecutor())
+        .run(() -> {
+          MethodDescriptor<byte[], byte[]> method =
+              MethodDescriptor.<byte[], byte[]>newBuilder()
+                  .setType(MethodType.UNKNOWN)
+                  .setFullMethodName("service/method")
+                  .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+                  .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+                  .build();
+          when(mockFilterHelper.logRpcMethod(method.getFullMethodName(), true))
+              .thenReturn(filterParams);
+
+          callFuture.set(
+              factory.create()
+                  .interceptCall(
+                      method,
+                      CallOptions.DEFAULT.withDeadlineAfter(15, TimeUnit.SECONDS),
+                      new Channel() {
+                        @Override
+                        public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+                            MethodDescriptor<RequestT, ResponseT> methodDescriptor,
+                            CallOptions callOptions) {
+                          return new NoopClientCall<>();
+                        }
+
+                        @Override
+                        public String authority() {
+                          return "the-authority";
+                        }
+                      }));
+        });
+    @SuppressWarnings("unchecked")
+    ClientCall.Listener<byte[]> mockListener = mock(ClientCall.Listener.class);
+    Objects.requireNonNull(callFuture.get()).start(mockListener, new Metadata());
+    ArgumentCaptor<Duration> timeoutCaptor = ArgumentCaptor.forClass(Duration.class);
+    verify(mockLogHelper, times(1))
+        .logClientHeader(
+            anyLong(),
+            AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+            AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+            AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+            timeoutCaptor.capture(),
+            any(Metadata.class),
+            anyInt(),
+            any(GrpcLogRecord.EventLogger.class),
+            anyString(),
+            AdditionalMatchers.or(ArgumentMatchers.isNull(),
+                ArgumentMatchers.any()),
+            any(SpanContext.class));
+    Duration timeout = timeoutCaptor.getValue();
+    assertThat(LogHelper.min(contextDeadline, callOptionsDeadline))
+        .isSameInstanceAs(contextDeadline);
+    assertThat(Math.abs(TimeUnit.SECONDS.toNanos(10) - Durations.toNanos(timeout)))
+        .isAtMost(TimeUnit.MILLISECONDS.toNanos(750));
+  }
+
+  @Test
+  public void clientMethodOrServiceFilter_disabled() {
+    Channel channel = new Channel() {
+      @Override
+      public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+          MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+        return new NoopClientCall<RequestT, ResponseT>() {
+          @Override
+          @SuppressWarnings("unchecked")
+          public void start(Listener<ResponseT> responseListener, Metadata headers) {
+            interceptedListener.set((Listener<byte[]>) responseListener);
+            actualClientInitial.set(headers);
+          }
+
+          @Override
+          public void sendMessage(RequestT message) {
+            actualRequest.set(message);
+          }
+
+          @Override
+          public void cancel(String message, Throwable cause) {
+            cancelCalled.set(null);
+          }
+
+          @Override
+          public void halfClose() {
+            halfCloseCalled.set(null);
+          }
+
+          @Override
+          public Attributes getAttributes() {
+            return Attributes.newBuilder().set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, peer).build();
+          }
+        };
+      }
+
+      @Override
+      public String authority() {
+        return "the-authority";
+      }
+    };
+
+    @SuppressWarnings("unchecked")
+    ClientCall.Listener<byte[]> mockListener = mock(ClientCall.Listener.class);
+
+    MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    when(mockFilterHelper.logRpcMethod(method.getFullMethodName(), true))
+        .thenReturn(FilterParams.create(false, 0, 0));
+
+    ClientCall<byte[], byte[]> interceptedLoggingCall =
+        factory.create()
+            .interceptCall(method,
+                CallOptions.DEFAULT,
+                channel);
+
+    interceptedLoggingCall.start(mockListener, new Metadata());
+    verifyNoInteractions(mockLogHelper);
+  }
+
+  @Test
+  public void clientMethodOrServiceFilter_enabled() {
+    Channel channel = new Channel() {
+      @Override
+      public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+          MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+        return new NoopClientCall<RequestT, ResponseT>() {
+          @Override
+          @SuppressWarnings("unchecked")
+          public void start(Listener<ResponseT> responseListener, Metadata headers) {
+            interceptedListener.set((Listener<byte[]>) responseListener);
+            actualClientInitial.set(headers);
+          }
+
+          @Override
+          public void sendMessage(RequestT message) {
+            actualRequest.set(message);
+          }
+
+          @Override
+          public void cancel(String message, Throwable cause) {
+            cancelCalled.set(null);
+          }
+
+          @Override
+          public void halfClose() {
+            halfCloseCalled.set(null);
+          }
+
+          @Override
+          public Attributes getAttributes() {
+            return Attributes.newBuilder().set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, peer).build();
+          }
+        };
+      }
+
+      @Override
+      public String authority() {
+        return "the-authority";
+      }
+    };
+
+    @SuppressWarnings("unchecked")
+    ClientCall.Listener<byte[]> mockListener = mock(ClientCall.Listener.class);
+
+    MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    when(mockFilterHelper.logRpcMethod(method.getFullMethodName(), true))
+        .thenReturn(FilterParams.create(true, 10, 10));
+
+    ClientCall<byte[], byte[]> interceptedLoggingCall =
+        factory.create()
+            .interceptCall(method,
+                CallOptions.DEFAULT,
+                channel);
+
+    {
+      interceptedLoggingCall.start(mockListener, new Metadata());
+      interceptedListener.get().onHeaders(new Metadata());
+      byte[] request = "this is a request".getBytes(US_ASCII);
+      interceptedLoggingCall.sendMessage(request);
+      interceptedLoggingCall.halfClose();
+      byte[] response = "this is a response".getBytes(US_ASCII);
+      interceptedListener.get().onMessage(response);
+      Status status = Status.INTERNAL.withDescription("trailer description");
+      Metadata trailers = new Metadata();
+      interceptedListener.get().onClose(status, trailers);
+      interceptedLoggingCall.cancel(null, null);
+      assertThat(Mockito.mockingDetails(mockLogHelper).getInvocations().size()).isEqualTo(7);
+    }
+  }
+
+  @Test
+  public void clientSpanContextLogged_contextSetViaCallOption() {
+    Channel channel = new Channel() {
+      @Override
+      public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+          MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+        return new NoopClientCall<RequestT, ResponseT>() {
+          @Override
+          @SuppressWarnings("unchecked")
+          public void start(Listener<ResponseT> responseListener, Metadata headers) {
+            interceptedListener.set((Listener<byte[]>) responseListener);
+            actualClientInitial.set(headers);
+          }
+
+          @Override
+          public void sendMessage(RequestT message) {
+            actualRequest.set(message);
+          }
+
+          @Override
+          public void cancel(String message, Throwable cause) {
+            cancelCalled.set(null);
+          }
+
+          @Override
+          public void halfClose() {
+            halfCloseCalled.set(null);
+          }
+
+          @Override
+          public Attributes getAttributes() {
+            return Attributes.newBuilder().set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, peer).build();
+          }
+        };
+      }
+
+      @Override
+      public String authority() {
+        return "the-authority";
+      }
+    };
+
+    @SuppressWarnings("unchecked")
+    ClientCall.Listener<byte[]> mockListener = mock(ClientCall.Listener.class);
+
+    MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    when(mockFilterHelper.logRpcMethod(method.getFullMethodName(), true))
+        .thenReturn(FilterParams.create(true, 10, 10));
+
+    ClientCall<byte[], byte[]> interceptedLoggingCall =
+        factory.create()
+            .interceptCall(method,
+                CALL_OPTIONS_WITH_SPAN_CONTEXT,
+                channel);
+
+    {
+      interceptedLoggingCall.start(mockListener, new Metadata());
+      ArgumentCaptor<SpanContext> callOptSpanContextCaptor = ArgumentCaptor.forClass(
+          SpanContext.class);
+      verify(mockLogHelper, times(1))
+          .logClientHeader(
+              anyLong(),
+              AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+              AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+              AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+              ArgumentMatchers.isNull(),
+              any(Metadata.class),
+              anyInt(),
+              any(GrpcLogRecord.EventLogger.class),
+              anyString(),
+              AdditionalMatchers.or(ArgumentMatchers.isNull(),
+                  ArgumentMatchers.any()),
+              callOptSpanContextCaptor.capture());
+      SpanContext spanContext = callOptSpanContextCaptor.getValue();
+      assertThat(spanContext).isEqualTo(SPAN_CONTEXT);
+    }
+  }
+
+  @Test
+  public void clientSpanContextLogged_contextNotSetViaCallOption() {
+    Channel channel = new Channel() {
+      @Override
+      public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+          MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+        return new NoopClientCall<RequestT, ResponseT>() {
+          @Override
+          @SuppressWarnings("unchecked")
+          public void start(Listener<ResponseT> responseListener, Metadata headers) {
+            interceptedListener.set((Listener<byte[]>) responseListener);
+            actualClientInitial.set(headers);
+          }
+
+          @Override
+          public void sendMessage(RequestT message) {
+            actualRequest.set(message);
+          }
+
+          @Override
+          public void cancel(String message, Throwable cause) {
+            cancelCalled.set(null);
+          }
+
+          @Override
+          public void halfClose() {
+            halfCloseCalled.set(null);
+          }
+
+          @Override
+          public Attributes getAttributes() {
+            return Attributes.newBuilder().set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, peer).build();
+          }
+        };
+      }
+
+      @Override
+      public String authority() {
+        return "the-authority";
+      }
+    };
+
+    @SuppressWarnings("unchecked")
+    ClientCall.Listener<byte[]> mockListener = mock(ClientCall.Listener.class);
+
+    MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    when(mockFilterHelper.logRpcMethod(method.getFullMethodName(), true))
+        .thenReturn(FilterParams.create(true, 10, 10));
+
+    ClientCall<byte[], byte[]> interceptedLoggingCall =
+        factory.create()
+            .interceptCall(method,
+                CallOptions.DEFAULT,
+                channel);
+
+    {
+      interceptedLoggingCall.start(mockListener, new Metadata());
+      ArgumentCaptor<SpanContext> callOptSpanContextCaptor = ArgumentCaptor.forClass(
+          SpanContext.class);
+      verify(mockLogHelper, times(1))
+          .logClientHeader(
+              anyLong(),
+              AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+              AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+              AdditionalMatchers.or(ArgumentMatchers.isNull(), anyString()),
+              ArgumentMatchers.isNull(),
+              any(Metadata.class),
+              anyInt(),
+              any(GrpcLogRecord.EventLogger.class),
+              anyString(),
+              AdditionalMatchers.or(ArgumentMatchers.isNull(),
+                  ArgumentMatchers.any()),
+              callOptSpanContextCaptor.capture());
+      SpanContext spanContext = callOptSpanContextCaptor.getValue();
+      assertThat(spanContext).isEqualTo(DEFAULT_CLIENT_SPAN_CONTEXT);
+    }
+  }
+}
diff --git a/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/InternalLoggingServerInterceptorTest.java b/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/InternalLoggingServerInterceptorTest.java
new file mode 100644
index 00000000000..5bc8323e6e0
--- /dev/null
+++ b/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/InternalLoggingServerInterceptorTest.java
@@ -0,0 +1,489 @@
+/*
+ * Copyright 2022 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.gcp.observability.interceptors;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.gcp.observability.interceptors.LogHelperTest.BYTEARRAY_MARSHALLER;
+import static org.junit.Assert.assertSame;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.protobuf.Duration;
+import com.google.protobuf.util.Durations;
+import io.grpc.Attributes;
+import io.grpc.Context;
+import io.grpc.Grpc;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.NoopServerCall;
+import io.grpc.ServerCall;
+import io.grpc.Status;
+import io.grpc.gcp.observability.interceptors.ConfigFilterHelper.FilterParams;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventLogger;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventType;
+import io.opencensus.trace.SpanContext;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Tests for {@link InternalLoggingServerInterceptor}.
+ */
+@RunWith(JUnit4.class)
+public class InternalLoggingServerInterceptorTest {
+
+  @Rule
+  public final MockitoRule mockito = MockitoJUnit.rule();
+
+  private static final Charset US_ASCII = StandardCharsets.US_ASCII;
+
+  private InternalLoggingServerInterceptor.Factory factory;
+  private AtomicReference<ServerCall<byte[], byte[]>> interceptedLoggingCall;
+  ServerCall.Listener<byte[]> capturedListener;
+  private ServerCall.Listener<byte[]> mockListener;
+  // capture these manually because ServerCall can not be mocked
+  private AtomicReference<Metadata> actualServerInitial;
+  private AtomicReference<byte[]> actualResponse;
+  private AtomicReference<Status> actualStatus;
+  private AtomicReference<Metadata> actualTrailers;
+  private LogHelper mockLogHelper;
+  private ConfigFilterHelper mockFilterHelper;
+  @SuppressWarnings("AddressSelection") // It will only be one address
+  private SocketAddress peer = new InetSocketAddress("127.0.0.1", 1234);
+
+  @Before
+  @SuppressWarnings("unchecked")
+  public void setup() throws Exception {
+    mockLogHelper = mock(LogHelper.class);
+    mockFilterHelper = mock(ConfigFilterHelper.class);
+    factory = new InternalLoggingServerInterceptor.FactoryImpl(mockLogHelper, mockFilterHelper);
+    interceptedLoggingCall = new AtomicReference<>();
+    mockListener = mock(ServerCall.Listener.class);
+    actualServerInitial = new AtomicReference<>();
+    actualResponse = new AtomicReference<>();
+    actualStatus = new AtomicReference<>();
+    actualTrailers = new AtomicReference<>();
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void internalLoggingServerInterceptor() {
+    Metadata clientInitial = new Metadata();
+    final MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    FilterParams filterParams = FilterParams.create(true, 0, 0);
+    when(mockFilterHelper.logRpcMethod(method.getFullMethodName(), false)).thenReturn(filterParams);
+    capturedListener =
+        factory.create()
+            .interceptCall(
+                new NoopServerCall<byte[], byte[]>() {
+                  @Override
+                  public void sendHeaders(Metadata headers) {
+                    actualServerInitial.set(headers);
+                  }
+
+                  @Override
+                  public void sendMessage(byte[] message) {
+                    actualResponse.set(message);
+                  }
+
+                  @Override
+                  public void close(Status status, Metadata trailers) {
+                    actualStatus.set(status);
+                    actualTrailers.set(trailers);
+                  }
+
+                  @Override
+                  public MethodDescriptor<byte[], byte[]> getMethodDescriptor() {
+                    return method;
+                  }
+
+                  @Override
+                  public Attributes getAttributes() {
+                    return Attributes
+                        .newBuilder()
+                        .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, peer)
+                        .build();
+                  }
+
+                  @Override
+                  public String getAuthority() {
+                    return "the-authority";
+                  }
+                },
+                clientInitial,
+                (call, headers) -> {
+                  interceptedLoggingCall.set(call);
+                  return mockListener;
+                });
+    // receive request header
+    {
+      verify(mockLogHelper).logClientHeader(
+          /*seq=*/ eq(1L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          ArgumentMatchers.isNull(),
+          same(clientInitial),
+          eq(filterParams.headerBytes()),
+          eq(EventLogger.SERVER),
+          anyString(),
+          same(peer),
+          eq(SpanContext.INVALID));
+      verifyNoMoreInteractions(mockLogHelper);
+    }
+
+    reset(mockLogHelper);
+    reset(mockListener);
+
+    // send response header
+    {
+      Metadata serverInitial = new Metadata();
+      interceptedLoggingCall.get().sendHeaders(serverInitial);
+      verify(mockLogHelper).logServerHeader(
+          /*seq=*/ eq(2L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          same(serverInitial),
+          eq(filterParams.headerBytes()),
+          eq(EventLogger.SERVER),
+          anyString(),
+          ArgumentMatchers.isNull(),
+          eq(SpanContext.INVALID));
+      verifyNoMoreInteractions(mockLogHelper);
+      assertSame(serverInitial, actualServerInitial.get());
+    }
+
+    reset(mockLogHelper);
+    reset(mockListener);
+
+    // receive request message
+    {
+      byte[] request = "this is a request".getBytes(US_ASCII);
+      capturedListener.onMessage(request);
+      verify(mockLogHelper).logRpcMessage(
+          /*seq=*/ eq(3L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          eq(EventType.CLIENT_MESSAGE),
+          same(request),
+          eq(filterParams.messageBytes()),
+          eq(EventLogger.SERVER),
+          anyString(),
+          eq(SpanContext.INVALID));
+      verifyNoMoreInteractions(mockLogHelper);
+      verify(mockListener).onMessage(same(request));
+    }
+
+    reset(mockLogHelper);
+    reset(mockListener);
+
+    // client half close
+    {
+      capturedListener.onHalfClose();
+      verify(mockLogHelper).logHalfClose(
+          /*seq=*/ eq(4L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          eq(EventLogger.SERVER),
+          anyString(),
+          eq(SpanContext.INVALID));
+      verifyNoMoreInteractions(mockLogHelper);
+      verify(mockListener).onHalfClose();
+    }
+
+    reset(mockLogHelper);
+    reset(mockListener);
+
+    // send response message
+    {
+      byte[] response = "this is a response".getBytes(US_ASCII);
+      interceptedLoggingCall.get().sendMessage(response);
+      verify(mockLogHelper).logRpcMessage(
+          /*seq=*/ eq(5L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          eq(EventType.SERVER_MESSAGE),
+          same(response),
+          eq(filterParams.messageBytes()),
+          eq(EventLogger.SERVER),
+          anyString(),
+          eq(SpanContext.INVALID));
+      verifyNoMoreInteractions(mockLogHelper);
+      assertSame(response, actualResponse.get());
+    }
+
+    reset(mockLogHelper);
+    reset(mockListener);
+
+    // send trailer
+    {
+      Status status = Status.INTERNAL.withDescription("trailer description");
+      Metadata trailers = new Metadata();
+      interceptedLoggingCall.get().close(status, trailers);
+      verify(mockLogHelper).logTrailer(
+          /*seq=*/ eq(6L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          same(status),
+          same(trailers),
+          eq(filterParams.headerBytes()),
+          eq(EventLogger.SERVER),
+          anyString(),
+          ArgumentMatchers.isNull(),
+          eq(SpanContext.INVALID));
+      verifyNoMoreInteractions(mockLogHelper);
+      assertSame(status, actualStatus.get());
+      assertSame(trailers, actualTrailers.get());
+    }
+
+    reset(mockLogHelper);
+    reset(mockListener);
+
+    // cancel
+    {
+      capturedListener.onCancel();
+      verify(mockLogHelper).logCancel(
+          /*seq=*/ eq(7L),
+          eq("service"),
+          eq("method"),
+          eq("the-authority"),
+          eq(EventLogger.SERVER),
+          anyString(),
+          eq(SpanContext.INVALID));
+      verify(mockListener).onCancel();
+    }
+  }
+
+  @Test
+  public void serverDeadlineLogged() {
+    final MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    FilterParams filterParams = FilterParams.create(true, 0, 0);
+    when(mockFilterHelper.logRpcMethod(method.getFullMethodName(), false)).thenReturn(filterParams);
+    final ServerCall<byte[], byte[]> noopServerCall = new NoopServerCall<byte[], byte[]>() {
+      @Override
+      public MethodDescriptor<byte[], byte[]> getMethodDescriptor() {
+        return method;
+      }
+
+      @Override
+      public String getAuthority() {
+        return "the-authority";
+      }
+    };
+
+    // We expect the contents of the "grpc-timeout" header to be installed the context
+    Context.current()
+        .withDeadlineAfter(1, TimeUnit.SECONDS, Executors.newSingleThreadScheduledExecutor())
+        .run(
+            () -> {
+              ServerCall.Listener<byte[]> unused =
+                  factory.create()
+                      .interceptCall(noopServerCall,
+                          new Metadata(),
+                          (call, headers) -> new ServerCall.Listener<byte[]>() {});
+            });
+    ArgumentCaptor<Duration> timeoutCaptor = ArgumentCaptor.forClass(Duration.class);
+    verify(mockLogHelper, times(1))
+        .logClientHeader(
+        /*seq=*/ eq(1L),
+        eq("service"),
+        eq("method"),
+        eq("the-authority"),
+        timeoutCaptor.capture(),
+        any(Metadata.class),
+        eq(filterParams.headerBytes()),
+        eq(EventLogger.SERVER),
+        anyString(),
+        ArgumentMatchers.isNull(),
+            eq(SpanContext.INVALID));
+    verifyNoMoreInteractions(mockLogHelper);
+    Duration timeout = timeoutCaptor.getValue();
+    assertThat(Math.abs(TimeUnit.SECONDS.toNanos(1) - Durations.toNanos(timeout)))
+        .isAtMost(TimeUnit.MILLISECONDS.toNanos(250));
+  }
+
+  @Test
+  public void serverMethodOrServiceFilter_disabled() {
+    Metadata clientInitial = new Metadata();
+    final MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    when(mockFilterHelper.logRpcMethod(method.getFullMethodName(), false))
+        .thenReturn(FilterParams.create(false, 0, 0));
+    capturedListener =
+        factory.create()
+            .interceptCall(
+                new NoopServerCall<byte[], byte[]>() {
+                  @Override
+                  public void sendHeaders(Metadata headers) {
+                    actualServerInitial.set(headers);
+                  }
+
+                  @Override
+                  public void sendMessage(byte[] message) {
+                    actualResponse.set(message);
+                  }
+
+                  @Override
+                  public void close(Status status, Metadata trailers) {
+                    actualStatus.set(status);
+                    actualTrailers.set(trailers);
+                  }
+
+                  @Override
+                  public MethodDescriptor<byte[], byte[]> getMethodDescriptor() {
+                    return method;
+                  }
+
+                  @Override
+                  public Attributes getAttributes() {
+                    return Attributes
+                        .newBuilder()
+                        .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, peer)
+                        .build();
+                  }
+
+                  @Override
+                  public String getAuthority() {
+                    return "the-authority";
+                  }
+                },
+                clientInitial,
+                (call, headers) -> {
+                  interceptedLoggingCall.set(call);
+                  return mockListener;
+                });
+    verifyNoInteractions(mockLogHelper);
+  }
+
+  @Test
+  public void serverMethodOrServiceFilter_enabled() {
+    Metadata clientInitial = new Metadata();
+    final MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    when(mockFilterHelper.logRpcMethod(method.getFullMethodName(), false))
+        .thenReturn(FilterParams.create(true, 10, 10));
+
+    capturedListener =
+        factory.create()
+            .interceptCall(
+                new NoopServerCall<byte[], byte[]>() {
+                  @Override
+                  public void sendHeaders(Metadata headers) {
+                    actualServerInitial.set(headers);
+                  }
+
+                  @Override
+                  public void sendMessage(byte[] message) {
+                    actualResponse.set(message);
+                  }
+
+                  @Override
+                  public void close(Status status, Metadata trailers) {
+                    actualStatus.set(status);
+                    actualTrailers.set(trailers);
+                  }
+
+                  @Override
+                  public MethodDescriptor<byte[], byte[]> getMethodDescriptor() {
+                    return method;
+                  }
+
+                  @Override
+                  public Attributes getAttributes() {
+                    return Attributes
+                        .newBuilder()
+                        .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, peer)
+                        .build();
+                  }
+
+                  @Override
+                  public String getAuthority() {
+                    return "the-authority";
+                  }
+                },
+                clientInitial,
+                (call, headers) -> {
+                  interceptedLoggingCall.set(call);
+                  return mockListener;
+                });
+
+    {
+      interceptedLoggingCall.get().sendHeaders(new Metadata());
+      byte[] request = "this is a request".getBytes(US_ASCII);
+      capturedListener.onMessage(request);
+      capturedListener.onHalfClose();
+      byte[] response = "this is a response".getBytes(US_ASCII);
+      interceptedLoggingCall.get().sendMessage(response);
+      Status status = Status.INTERNAL.withDescription("trailer description");
+      Metadata trailers = new Metadata();
+      interceptedLoggingCall.get().close(status, trailers);
+      capturedListener.onCancel();
+      assertThat(Mockito.mockingDetails(mockLogHelper).getInvocations().size()).isEqualTo(7);
+    }
+  }
+}
diff --git a/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/LogHelperTest.java b/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/LogHelperTest.java
new file mode 100644
index 00000000000..1da8a7cbe2c
--- /dev/null
+++ b/gcp-observability/src/test/java/io/grpc/gcp/observability/interceptors/LogHelperTest.java
@@ -0,0 +1,800 @@
+/*
+ * Copyright 2022 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.gcp.observability.interceptors;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import com.google.protobuf.ByteString;
+import com.google.protobuf.Duration;
+import com.google.protobuf.util.Durations;
+import com.google.rpc.Code;
+import io.grpc.Attributes;
+import io.grpc.Grpc;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor.Marshaller;
+import io.grpc.Status;
+import io.grpc.gcp.observability.interceptors.LogHelper.PayloadBuilderHelper;
+import io.grpc.gcp.observability.logging.GcpLogSink;
+import io.grpc.gcp.observability.logging.Sink;
+import io.grpc.observabilitylog.v1.Address;
+import io.grpc.observabilitylog.v1.GrpcLogRecord;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventLogger;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventType;
+import io.grpc.observabilitylog.v1.Payload;
+import io.opencensus.trace.SpanContext;
+import io.opencensus.trace.SpanId;
+import io.opencensus.trace.TraceId;
+import io.opencensus.trace.TraceOptions;
+import io.opencensus.trace.Tracestate;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link LogHelper}.
+ */
+@SuppressWarnings("AddressSelection") // It will only be one address
+@RunWith(JUnit4.class)
+public class LogHelperTest {
+  public static final Marshaller<byte[]> BYTEARRAY_MARSHALLER = new ByteArrayMarshaller();
+  private static final String DATA_A = "aaaaaaaaa";
+  private static final String DATA_B = "bbbbbbbbb";
+  private static final String DATA_C = "ccccccccc";
+  private static final Metadata.Key<String> KEY_A =
+      Metadata.Key.of("a", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> KEY_B =
+      Metadata.Key.of("b", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> KEY_C =
+      Metadata.Key.of("c", Metadata.ASCII_STRING_MARSHALLER);
+  private static final int HEADER_LIMIT = 10;
+  private static final int MESSAGE_LIMIT = Integer.MAX_VALUE;
+  private static final SpanContext CLIENT_SPAN_CONTEXT = SpanContext.create(
+      TraceId.fromLowerBase16("4c6af40c499951eb7de2777ba1e4fefa"),
+      SpanId.fromLowerBase16("de52e84d13dd232d"),
+      TraceOptions.builder().setIsSampled(true).build(),
+      Tracestate.builder().build());
+  private static final SpanContext SERVER_SPAN_CONTEXT = SpanContext.create(
+      TraceId.fromLowerBase16("549a8a64db2d0c757fdf6bb1bfe84e2c"),
+      SpanId.fromLowerBase16("a5b7704614fe903d"),
+      TraceOptions.builder().setIsSampled(true).build(),
+      Tracestate.builder().build());
+
+  private final Metadata nonEmptyMetadata = new Metadata();
+  private final Sink sink = mock(GcpLogSink.class);
+  private final LogHelper logHelper = new LogHelper(sink);
+
+
+  @Before
+  public void setUp() {
+    nonEmptyMetadata.put(KEY_A, DATA_A);
+    nonEmptyMetadata.put(KEY_B, DATA_B);
+    nonEmptyMetadata.put(KEY_C, DATA_C);
+  }
+
+  @Test
+  public void socketToProto_ipv4() throws Exception {
+    InetAddress address = InetAddress.getByName("127.0.0.1");
+    int port = 12345;
+    InetSocketAddress socketAddress = new InetSocketAddress(address, port);
+    assertThat(LogHelper.socketAddressToProto(socketAddress))
+        .isEqualTo(Address
+            .newBuilder()
+            .setType(Address.Type.IPV4)
+            .setAddress("127.0.0.1")
+            .setIpPort(12345)
+            .build());
+  }
+
+  @Test
+  public void socketToProto_ipv6() throws Exception {
+    // this is a ipv6 link local address
+    InetAddress address = InetAddress.getByName("2001:db8:0:0:0:0:2:1");
+    int port = 12345;
+    InetSocketAddress socketAddress = new InetSocketAddress(address, port);
+    assertThat(LogHelper.socketAddressToProto(socketAddress))
+        .isEqualTo(Address
+            .newBuilder()
+            .setType(Address.Type.IPV6)
+            .setAddress("2001:db8::2:1") // RFC 5952 section 4: ipv6 canonical form required
+            .setIpPort(12345)
+            .build());
+  }
+
+  @Test
+  public void socketToProto_unknown() {
+    SocketAddress unknownSocket = new SocketAddress() {
+      @Override
+      public String toString() {
+        return "some-socket-address";
+      }
+    };
+    assertThat(LogHelper.socketAddressToProto(unknownSocket))
+        .isEqualTo(Address.newBuilder()
+            .setType(Address.Type.TYPE_UNKNOWN)
+            .setAddress("some-socket-address")
+            .build());
+  }
+
+  @Test
+  public void metadataToProto_empty() {
+    assertThat(metadataToProtoTestHelper(
+            EventType.CLIENT_HEADER, new Metadata(), Integer.MAX_VALUE))
+        .isEqualTo(GrpcLogRecord.newBuilder()
+            .setType(EventType.CLIENT_HEADER)
+            .setPayload(
+                Payload.newBuilder().putAllMetadata(new HashMap<>()))
+            .build());
+  }
+
+  @Test
+  public void metadataToProto() {
+    Payload.Builder payloadBuilder = Payload.newBuilder()
+        .putMetadata("a", DATA_A)
+            .putMetadata("b", DATA_B)
+                .putMetadata("c", DATA_C);
+
+    assertThat(metadataToProtoTestHelper(
+            EventType.CLIENT_HEADER, nonEmptyMetadata, Integer.MAX_VALUE))
+        .isEqualTo(GrpcLogRecord.newBuilder()
+            .setType(EventType.CLIENT_HEADER)
+            .setPayload(payloadBuilder)
+            .build());
+  }
+
+  @Test
+  public void metadataToProto_setsTruncated() {
+    assertTrue(LogHelper.createMetadataProto(nonEmptyMetadata, 0).truncated);
+  }
+
+  @Test
+  public void metadataToProto_truncated() {
+    // 0 byte limit not enough for any metadata
+    assertThat(LogHelper.createMetadataProto(nonEmptyMetadata, 0).payloadBuilder.build())
+        .isEqualTo(
+            io.grpc.observabilitylog.v1.Payload.newBuilder()
+                .putAllMetadata(new HashMap<>())
+                .build());
+    // not enough bytes for first key value
+    assertThat(LogHelper.createMetadataProto(nonEmptyMetadata, 9).payloadBuilder.build())
+        .isEqualTo(
+            io.grpc.observabilitylog.v1.Payload.newBuilder()
+                .putAllMetadata(new HashMap<>())
+                .build());
+    // enough for first key value
+    assertThat(LogHelper.createMetadataProto(nonEmptyMetadata, 10).payloadBuilder.build())
+        .isEqualTo(
+            io.grpc.observabilitylog.v1.Payload.newBuilder().putMetadata("a", DATA_A).build());
+    // Test edge cases for >= 2 key values
+    assertThat(LogHelper.createMetadataProto(nonEmptyMetadata, 19).payloadBuilder.build())
+        .isEqualTo(
+            io.grpc.observabilitylog.v1.Payload.newBuilder().putMetadata("a", DATA_A).build());
+    assertThat(LogHelper.createMetadataProto(nonEmptyMetadata, 20).payloadBuilder.build())
+        .isEqualTo(
+            io.grpc.observabilitylog.v1.Payload.newBuilder()
+                .putMetadata("a", DATA_A)
+                .putMetadata("b", DATA_B)
+                .build());
+    assertThat(LogHelper.createMetadataProto(nonEmptyMetadata, 29).payloadBuilder.build())
+        .isEqualTo(
+            io.grpc.observabilitylog.v1.Payload.newBuilder()
+                .putMetadata("a", DATA_A)
+                .putMetadata("b", DATA_B)
+                .build());
+    // not truncated: enough for all keys
+    assertThat(LogHelper.createMetadataProto(nonEmptyMetadata, 30).payloadBuilder.build())
+        .isEqualTo(
+            io.grpc.observabilitylog.v1.Payload.newBuilder()
+                .putMetadata("a", DATA_A)
+                .putMetadata("b", DATA_B)
+                .putMetadata("c", DATA_C)
+                .build());
+  }
+
+  @Test
+  public void messageToProto() {
+    byte[] bytes
+        = "this is a long message: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".getBytes(
+        StandardCharsets.US_ASCII);
+    assertThat(messageTestHelper(bytes, Integer.MAX_VALUE))
+        .isEqualTo(GrpcLogRecord.newBuilder()
+            .setPayload(
+                Payload.newBuilder()
+                    .setMessage(
+                        ByteString.copyFrom(bytes))
+                    .setMessageLength(bytes.length))
+            .build());
+  }
+
+  @Test
+  public void messageToProto_truncated() {
+    byte[] bytes
+        = "this is a long message: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".getBytes(
+        StandardCharsets.US_ASCII);
+    assertThat(messageTestHelper(bytes, 0))
+        .isEqualTo(GrpcLogRecord.newBuilder()
+            .setPayload(
+                Payload.newBuilder()
+                    .setMessageLength(bytes.length))
+            .setPayloadTruncated(true)
+            .build());
+
+    int limit = 10;
+    String truncatedMessage = "this is a ";
+    assertThat(messageTestHelper(bytes, limit))
+        .isEqualTo(
+            GrpcLogRecord.newBuilder()
+                .setPayload(
+                    Payload.newBuilder()
+                        .setMessage(
+                            ByteString.copyFrom(
+                                truncatedMessage.getBytes(StandardCharsets.US_ASCII)))
+                        .setMessageLength(bytes.length))
+                .setPayloadTruncated(true)
+                .build());
+  }
+
+
+  @Test
+  public void logRequestHeader() throws Exception {
+    long seqId = 1;
+    String serviceName = "service";
+    String methodName = "method";
+    String authority = "authority";
+    Duration timeout = Durations.fromMillis(1234);
+    String callId = "d155e885-9587-4e77-81f7-3aa5a443d47f";
+    InetAddress address = InetAddress.getByName("127.0.0.1");
+    int port = 12345;
+    InetSocketAddress peerAddress = new InetSocketAddress(address, port);
+
+    GrpcLogRecord.Builder builder =
+        metadataToProtoTestHelper(EventType.CLIENT_HEADER, nonEmptyMetadata,
+            HEADER_LIMIT)
+            .toBuilder()
+            .setSequenceId(seqId)
+            .setServiceName(serviceName)
+            .setMethodName(methodName)
+            .setType(EventType.CLIENT_HEADER)
+            .setLogger(EventLogger.CLIENT)
+            .setCallId(callId);
+    builder.setAuthority(authority);
+    builder.setPayload(builder.getPayload().toBuilder().setTimeout(timeout).build());
+    GrpcLogRecord base = builder.build();
+
+    // logged on client
+    {
+      logHelper.logClientHeader(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          timeout,
+          nonEmptyMetadata,
+          HEADER_LIMIT,
+          EventLogger.CLIENT,
+          callId,
+          null,
+          CLIENT_SPAN_CONTEXT);
+      verify(sink).write(base, CLIENT_SPAN_CONTEXT);
+    }
+
+    // logged on server
+    {
+      logHelper.logClientHeader(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          timeout,
+          nonEmptyMetadata,
+          HEADER_LIMIT,
+          EventLogger.SERVER,
+          callId,
+          peerAddress,
+          SERVER_SPAN_CONTEXT);
+      verify(sink).write(
+          base.toBuilder()
+              .setPeer(LogHelper.socketAddressToProto(peerAddress))
+              .setLogger(EventLogger.SERVER)
+              .build(),
+          SERVER_SPAN_CONTEXT);
+    }
+
+    // timeout is null
+    {
+      logHelper.logClientHeader(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          null,
+          nonEmptyMetadata,
+          HEADER_LIMIT,
+          EventLogger.CLIENT,
+          callId,
+          null,
+          CLIENT_SPAN_CONTEXT);
+      verify(sink).write(
+          base.toBuilder()
+              .setPayload(base.getPayload().toBuilder().clearTimeout().build())
+              .build(),
+          CLIENT_SPAN_CONTEXT);
+    }
+
+    // peerAddress is not null (error on client)
+    try {
+      logHelper.logClientHeader(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          timeout,
+          nonEmptyMetadata,
+          HEADER_LIMIT,
+          EventLogger.CLIENT,
+          callId,
+          peerAddress,
+          CLIENT_SPAN_CONTEXT);
+      fail();
+    } catch (IllegalArgumentException expected) {
+      assertThat(expected).hasMessageThat().contains("peerAddress can only be specified by server");
+    }
+  }
+
+  @Test
+  public void logResponseHeader() throws Exception {
+    long seqId = 1;
+    String serviceName = "service";
+    String methodName = "method";
+    String authority = "authority";
+    String callId = "d155e885-9587-4e77-81f7-3aa5a443d47f";
+    InetAddress address = InetAddress.getByName("127.0.0.1");
+    int port = 12345;
+    InetSocketAddress peerAddress = new InetSocketAddress(address, port);
+
+    GrpcLogRecord.Builder builder =
+        metadataToProtoTestHelper(EventType.SERVER_HEADER, nonEmptyMetadata,
+            HEADER_LIMIT)
+            .toBuilder()
+            .setSequenceId(seqId)
+            .setServiceName(serviceName)
+            .setMethodName(methodName)
+            .setAuthority(authority)
+            .setType(EventType.SERVER_HEADER)
+            .setLogger(EventLogger.CLIENT)
+            .setCallId(callId);
+    builder.setPeer(LogHelper.socketAddressToProto(peerAddress));
+    GrpcLogRecord base = builder.build();
+
+    // logged on client
+    {
+      logHelper.logServerHeader(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          nonEmptyMetadata,
+          HEADER_LIMIT,
+          EventLogger.CLIENT,
+          callId,
+          peerAddress,
+          CLIENT_SPAN_CONTEXT);
+      verify(sink).write(base, CLIENT_SPAN_CONTEXT);
+    }
+
+    // logged on server
+    {
+      logHelper.logServerHeader(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          nonEmptyMetadata,
+          HEADER_LIMIT,
+          EventLogger.SERVER,
+          callId,
+          null,
+          SERVER_SPAN_CONTEXT);
+      verify(sink).write(
+          base.toBuilder()
+              .setLogger(EventLogger.SERVER)
+              .clearPeer()
+              .build(),
+          SERVER_SPAN_CONTEXT);
+    }
+
+    // peerAddress is not null (error on server)
+    try {
+      logHelper.logServerHeader(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          nonEmptyMetadata,
+          HEADER_LIMIT,
+          EventLogger.SERVER,
+          callId,
+          peerAddress,
+          SERVER_SPAN_CONTEXT);
+
+      fail();
+    } catch (IllegalArgumentException expected) {
+      assertThat(expected).hasMessageThat()
+          .contains("peerAddress can only be specified for client");
+    }
+  }
+
+  @Test
+  public void logTrailer() throws Exception {
+    long seqId = 1;
+    String serviceName = "service";
+    String methodName = "method";
+    String authority = "authority";
+    String callId = "d155e885-9587-4e77-81f7-3aa5a443d47f";
+    InetAddress address = InetAddress.getByName("127.0.0.1");
+    int port = 12345;
+    InetSocketAddress peer = new InetSocketAddress(address, port);
+    Status statusDescription = Status.INTERNAL.withDescription("test description");
+
+    GrpcLogRecord.Builder builder =
+        metadataToProtoTestHelper(EventType.SERVER_HEADER, nonEmptyMetadata,
+            HEADER_LIMIT)
+            .toBuilder()
+            .setSequenceId(seqId)
+            .setServiceName(serviceName)
+            .setMethodName(methodName)
+            .setAuthority(authority)
+            .setType(EventType.SERVER_TRAILER)
+            .setLogger(EventLogger.CLIENT)
+            .setCallId(callId);
+    builder.setPeer(LogHelper.socketAddressToProto(peer));
+    builder.setPayload(
+        builder.getPayload().toBuilder()
+            .setStatusCode(Code.forNumber(Status.INTERNAL.getCode().value()))
+            .setStatusMessage("test description")
+            .build());
+    GrpcLogRecord base = builder.build();
+
+    // logged on client
+    {
+      logHelper.logTrailer(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          statusDescription,
+          nonEmptyMetadata,
+          HEADER_LIMIT,
+          EventLogger.CLIENT,
+          callId,
+          peer,
+          CLIENT_SPAN_CONTEXT);
+      verify(sink).write(base, CLIENT_SPAN_CONTEXT);
+    }
+
+    // logged on server
+    {
+      logHelper.logTrailer(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          statusDescription,
+          nonEmptyMetadata,
+          HEADER_LIMIT,
+          EventLogger.SERVER,
+          callId,
+          null,
+          SERVER_SPAN_CONTEXT);
+      verify(sink).write(
+          base.toBuilder()
+              .clearPeer()
+              .setLogger(EventLogger.SERVER)
+              .build(),
+          SERVER_SPAN_CONTEXT);
+    }
+
+    // peer address is null
+    {
+      logHelper.logTrailer(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          statusDescription,
+          nonEmptyMetadata,
+          HEADER_LIMIT,
+          EventLogger.CLIENT,
+          callId,
+          null,
+          CLIENT_SPAN_CONTEXT);
+      verify(sink).write(
+          base.toBuilder()
+              .clearPeer()
+              .build(),
+          CLIENT_SPAN_CONTEXT);
+    }
+
+    // status description is null
+    {
+      logHelper.logTrailer(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          statusDescription.getCode().toStatus(),
+          nonEmptyMetadata,
+          HEADER_LIMIT,
+          EventLogger.CLIENT,
+          callId,
+          peer,
+          CLIENT_SPAN_CONTEXT);
+      verify(sink).write(
+          base.toBuilder()
+              .setPayload(base.getPayload().toBuilder().clearStatusMessage().build())
+              .build(),
+          CLIENT_SPAN_CONTEXT);
+    }
+  }
+
+  @Test
+  public void alwaysLoggedMetadata_grpcTraceBin() {
+    Metadata.Key<byte[]> key
+        = Metadata.Key.of("grpc-trace-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    Metadata metadata = new Metadata();
+    metadata.put(key, new byte[1]);
+    int zeroHeaderBytes = 0;
+    PayloadBuilderHelper<Payload.Builder> pair =
+        LogHelper.createMetadataProto(metadata, zeroHeaderBytes);
+    assertThat(pair.payloadBuilder.build().getMetadataMap().containsKey(key.name())).isTrue();
+    assertFalse(pair.truncated);
+  }
+
+  @Test
+  public void neverLoggedMetadata_grpcStatusDetailsBin() {
+    Metadata.Key<byte[]> key
+        = Metadata.Key.of("grpc-status-details-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    Metadata metadata = new Metadata();
+    metadata.put(key, new byte[1]);
+    int unlimitedHeaderBytes = Integer.MAX_VALUE;
+    PayloadBuilderHelper<Payload.Builder> pair
+        = LogHelper.createMetadataProto(metadata, unlimitedHeaderBytes);
+    assertThat(pair.payloadBuilder.getMetadataMap()).isEmpty();
+    assertFalse(pair.truncated);
+  }
+
+  @Test
+  public void logRpcMessage() {
+    long seqId = 1;
+    String serviceName = "service";
+    String methodName = "method";
+    String authority = "authority";
+    String callId = "d155e885-9587-4e77-81f7-3aa5a443d47f";
+    byte[] message = new byte[100];
+
+    GrpcLogRecord.Builder builder = messageTestHelper(message, MESSAGE_LIMIT)
+        .toBuilder()
+        .setSequenceId(seqId)
+        .setServiceName(serviceName)
+        .setMethodName(methodName)
+        .setAuthority(authority)
+        .setType(EventType.CLIENT_MESSAGE)
+        .setLogger(EventLogger.CLIENT)
+        .setCallId(callId);
+    GrpcLogRecord base = builder.build();
+    // request message
+    {
+      logHelper.logRpcMessage(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          EventType.CLIENT_MESSAGE,
+          message,
+          MESSAGE_LIMIT,
+          EventLogger.CLIENT,
+          callId,
+          CLIENT_SPAN_CONTEXT);
+      verify(sink).write(base, CLIENT_SPAN_CONTEXT);
+    }
+    // response message, logged on client
+    {
+      logHelper.logRpcMessage(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          EventType.SERVER_MESSAGE,
+          message,
+          MESSAGE_LIMIT,
+          EventLogger.CLIENT,
+          callId,
+          CLIENT_SPAN_CONTEXT);
+      verify(sink).write(
+          base.toBuilder()
+              .setType(EventType.SERVER_MESSAGE)
+              .build(),
+          CLIENT_SPAN_CONTEXT);
+    }
+    // request message, logged on server
+    {
+      logHelper.logRpcMessage(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          EventType.CLIENT_MESSAGE,
+          message,
+          MESSAGE_LIMIT,
+          EventLogger.SERVER,
+          callId,
+          SERVER_SPAN_CONTEXT);
+      verify(sink).write(
+          base.toBuilder()
+              .setLogger(EventLogger.SERVER)
+              .build(),
+          SERVER_SPAN_CONTEXT);
+    }
+    // response message, logged on server
+    {
+      logHelper.logRpcMessage(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          EventType.SERVER_MESSAGE,
+          message,
+          MESSAGE_LIMIT,
+          EventLogger.SERVER,
+          callId,
+          SpanContext.INVALID);
+      verify(sink).write(
+          base.toBuilder()
+              .setType(EventType.SERVER_MESSAGE)
+              .setLogger(EventLogger.SERVER)
+              .build(),
+          SpanContext.INVALID);
+    }
+    // message is not of type : com.google.protobuf.Message or byte[]
+    {
+      logHelper.logRpcMessage(
+          seqId,
+          serviceName,
+          methodName,
+          authority,
+          EventType.CLIENT_MESSAGE,
+          "message",
+          MESSAGE_LIMIT,
+          EventLogger.CLIENT,
+          callId,
+          CLIENT_SPAN_CONTEXT);
+      verify(sink).write(
+          base.toBuilder()
+              .clearPayload()
+              .clearPayloadTruncated()
+              .build(),
+          CLIENT_SPAN_CONTEXT);
+    }
+  }
+
+  @Test
+  public void getPeerAddressTest() throws Exception {
+    SocketAddress peer = new InetSocketAddress(InetAddress.getByName("127.0.0.1"), 1234);
+    assertNull(LogHelper.getPeerAddress(Attributes.EMPTY));
+    assertSame(
+        peer,
+        LogHelper.getPeerAddress(
+            Attributes.newBuilder().set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, peer).build()));
+  }
+
+  private static GrpcLogRecord metadataToProtoTestHelper(
+      EventType type, Metadata metadata, int maxHeaderBytes) {
+    GrpcLogRecord.Builder builder = GrpcLogRecord.newBuilder();
+    PayloadBuilderHelper<Payload.Builder> pair
+        = LogHelper.createMetadataProto(metadata, maxHeaderBytes);
+    builder.setPayload(pair.payloadBuilder);
+    builder.setPayloadTruncated(pair.truncated);
+    builder.setType(type);
+    return builder.build();
+  }
+
+  private static GrpcLogRecord messageTestHelper(byte[] message, int maxMessageBytes) {
+    GrpcLogRecord.Builder builder = GrpcLogRecord.newBuilder();
+    PayloadBuilderHelper<Payload.Builder> pair
+        = LogHelper.createMessageProto(message, maxMessageBytes);
+    builder.setPayload(pair.payloadBuilder);
+    builder.setPayloadTruncated(pair.truncated);
+    return builder.build();
+  }
+
+  // Used only in tests
+  // Copied from internal
+  static final class ByteArrayMarshaller implements Marshaller<byte[]> {
+
+    @Override
+    public InputStream stream(byte[] value) {
+      return new ByteArrayInputStream(value);
+    }
+
+    @Override
+    public byte[] parse(InputStream stream) {
+      try {
+        return parseHelper(stream);
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+    }
+
+    private byte[] parseHelper(InputStream stream) throws IOException {
+      try {
+        return IoUtils.toByteArray(stream);
+      } finally {
+        stream.close();
+      }
+    }
+  }
+
+  // Copied from internal
+  static final class IoUtils {
+
+    /** maximum buffer to be read is 16 KB. */
+    private static final int MAX_BUFFER_LENGTH = 16384;
+
+    /** Returns the byte array. */
+    public static byte[] toByteArray(InputStream in) throws IOException {
+      ByteArrayOutputStream out = new ByteArrayOutputStream();
+      copy(in, out);
+      return out.toByteArray();
+    }
+
+    /** Copies the data from input stream to output stream. */
+    public static long copy(InputStream from, OutputStream to) throws IOException {
+      // Copied from guava com.google.common.io.ByteStreams because its API is unstable (beta)
+      checkNotNull(from);
+      checkNotNull(to);
+      byte[] buf = new byte[MAX_BUFFER_LENGTH];
+      long total = 0;
+      while (true) {
+        int r = from.read(buf);
+        if (r == -1) {
+          break;
+        }
+        to.write(buf, 0, r);
+        total += r;
+      }
+      return total;
+    }
+  }
+}
diff --git a/gcp-observability/src/test/java/io/grpc/gcp/observability/logging/GcpLogSinkTest.java b/gcp-observability/src/test/java/io/grpc/gcp/observability/logging/GcpLogSinkTest.java
new file mode 100644
index 00000000000..6cc0dca907d
--- /dev/null
+++ b/gcp-observability/src/test/java/io/grpc/gcp/observability/logging/GcpLogSinkTest.java
@@ -0,0 +1,309 @@
+/*
+ * Copyright 2022 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.gcp.observability.logging;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.anyIterable;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.cloud.logging.LogEntry;
+import com.google.cloud.logging.Logging;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Duration;
+import com.google.protobuf.Struct;
+import com.google.protobuf.Value;
+import com.google.protobuf.util.Durations;
+import io.grpc.gcp.observability.ObservabilityConfig;
+import io.grpc.observabilitylog.v1.GrpcLogRecord;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventLogger;
+import io.grpc.observabilitylog.v1.GrpcLogRecord.EventType;
+import io.opencensus.trace.SpanContext;
+import io.opencensus.trace.SpanId;
+import io.opencensus.trace.TraceId;
+import io.opencensus.trace.TraceOptions;
+import io.opencensus.trace.Tracestate;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Tests for {@link GcpLogSink}.
+ */
+@RunWith(JUnit4.class)
+public class GcpLogSinkTest {
+
+  @Rule
+  public final MockitoRule mockito = MockitoJUnit.rule();
+
+  private static final ImmutableMap<String, String> CUSTOM_TAGS =
+      ImmutableMap.of("KEY1", "Value1",
+      "KEY2", "VALUE2");
+  // gRPC is expected to always use this log name when reporting to GCP cloud logging.
+  private static final String EXPECTED_LOG_NAME =
+      "microservices.googleapis.com%2Fobservability%2Fgrpc";
+  private static final long SEQ_ID = 1;
+  private static final String DEST_PROJECT_NAME = "PROJECT";
+  private static final String SERVICE_NAME = "service";
+  private static final String METHOD_NAME = "method";
+  private static final String AUTHORITY = "authority";
+  private static final Duration TIMEOUT = Durations.fromMillis(1234);
+  private static final String CALL_ID = "d155e885-9587-4e77-81f7-3aa5a443d47f";
+  private static final GrpcLogRecord LOG_PROTO = GrpcLogRecord.newBuilder()
+      .setSequenceId(SEQ_ID)
+      .setServiceName(SERVICE_NAME)
+      .setMethodName(METHOD_NAME)
+      .setAuthority(AUTHORITY)
+      .setPayload(io.grpc.observabilitylog.v1.Payload.newBuilder().setTimeout(TIMEOUT))
+      .setType(EventType.CLIENT_HEADER)
+      .setLogger(EventLogger.CLIENT)
+      .setCallId(CALL_ID)
+      .build();
+  //       .putFields("timeout", Value.newBuilder().setStringValue("1.234s").build())
+  private static final Struct struct =
+      Struct.newBuilder()
+          .putFields("timeout", Value.newBuilder().setStringValue("1.234s").build())
+          .build();
+  private static final Struct EXPECTED_STRUCT_LOG_PROTO = Struct.newBuilder()
+      .putFields("sequenceId", Value.newBuilder().setStringValue(String.valueOf(SEQ_ID)).build())
+      .putFields("serviceName", Value.newBuilder().setStringValue(SERVICE_NAME).build())
+      .putFields("methodName", Value.newBuilder().setStringValue(METHOD_NAME).build())
+      .putFields("authority", Value.newBuilder().setStringValue(AUTHORITY).build())
+      .putFields("payload", Value.newBuilder().setStructValue(struct).build())
+      .putFields("type", Value.newBuilder().setStringValue(
+          String.valueOf(EventType.CLIENT_HEADER)).build())
+      .putFields("logger", Value.newBuilder().setStringValue(
+          String.valueOf(EventLogger.CLIENT)).build())
+      .putFields("callId", Value.newBuilder().setStringValue(CALL_ID).build())
+      .build();
+  @Mock
+  private Logging mockLogging;
+  @Mock
+  private ObservabilityConfig mockConfig;
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void verifyWrite() throws Exception {
+    when(mockConfig.getCustomTags()).thenReturn(CUSTOM_TAGS);
+    GcpLogSink sink = new GcpLogSink(mockLogging, DEST_PROJECT_NAME,
+        mockConfig, Collections.emptySet(), new TraceLoggingHelper(DEST_PROJECT_NAME));
+    sink.write(LOG_PROTO, null);
+
+    ArgumentCaptor<Collection<LogEntry>> logEntrySetCaptor = ArgumentCaptor.forClass(
+        (Class) Collection.class);
+    verify(mockLogging, times(1)).write(logEntrySetCaptor.capture());
+    for (Iterator<LogEntry> it = logEntrySetCaptor.getValue().iterator(); it.hasNext(); ) {
+      LogEntry entry = it.next();
+      assertThat(entry.getPayload().getData()).isEqualTo(EXPECTED_STRUCT_LOG_PROTO);
+      assertThat(entry.getLogName()).isEqualTo(EXPECTED_LOG_NAME);
+    }
+    verifyNoMoreInteractions(mockLogging);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void verifyWriteWithTags() {
+    when(mockConfig.getCustomTags()).thenReturn(CUSTOM_TAGS);
+    GcpLogSink sink = new GcpLogSink(mockLogging, DEST_PROJECT_NAME,
+        mockConfig, Collections.emptySet(), new TraceLoggingHelper(DEST_PROJECT_NAME));
+    sink.write(LOG_PROTO, null);
+
+    ArgumentCaptor<Collection<LogEntry>> logEntrySetCaptor = ArgumentCaptor.forClass(
+        (Class) Collection.class);
+    verify(mockLogging, times(1)).write(logEntrySetCaptor.capture());
+    System.out.println(logEntrySetCaptor.getValue());
+    for (Iterator<LogEntry> it = logEntrySetCaptor.getValue().iterator(); it.hasNext(); ) {
+      LogEntry entry = it.next();
+      assertThat(entry.getLabels()).isEqualTo(CUSTOM_TAGS);
+      assertThat(entry.getPayload().getData()).isEqualTo(EXPECTED_STRUCT_LOG_PROTO);
+      assertThat(entry.getLogName()).isEqualTo(EXPECTED_LOG_NAME);
+    }
+    verifyNoMoreInteractions(mockLogging);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void emptyCustomTags_labelsNotSet() {
+    Map<String, String> emptyCustomTags = null;
+    when(mockConfig.getCustomTags()).thenReturn(emptyCustomTags);
+    Map<String, String> expectedEmptyLabels = new HashMap<>();
+    GcpLogSink sink = new GcpLogSink(mockLogging, DEST_PROJECT_NAME,
+        mockConfig, Collections.emptySet(), new TraceLoggingHelper(DEST_PROJECT_NAME));
+    sink.write(LOG_PROTO, null);
+
+    ArgumentCaptor<Collection<LogEntry>> logEntrySetCaptor = ArgumentCaptor.forClass(
+        (Class) Collection.class);
+    verify(mockLogging, times(1)).write(logEntrySetCaptor.capture());
+    for (Iterator<LogEntry> it = logEntrySetCaptor.getValue().iterator(); it.hasNext(); ) {
+      LogEntry entry = it.next();
+      assertThat(entry.getLabels()).isEqualTo(expectedEmptyLabels);
+      assertThat(entry.getPayload().getData()).isEqualTo(EXPECTED_STRUCT_LOG_PROTO);
+    }
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void emptyCustomTags_setSourceProject() {
+    Map<String, String> emptyCustomTags = null;
+    when(mockConfig.getCustomTags()).thenReturn(emptyCustomTags);
+    String projectId = "PROJECT";
+    Map<String, String> expectedLabels = GcpLogSink.getCustomTags(emptyCustomTags
+    );
+    GcpLogSink sink = new GcpLogSink(mockLogging, projectId,
+        mockConfig, Collections.emptySet(), new TraceLoggingHelper(DEST_PROJECT_NAME));
+    sink.write(LOG_PROTO, null);
+
+    ArgumentCaptor<Collection<LogEntry>> logEntrySetCaptor = ArgumentCaptor.forClass(
+        (Class) Collection.class);
+    verify(mockLogging, times(1)).write(logEntrySetCaptor.capture());
+    for (Iterator<LogEntry> it = logEntrySetCaptor.getValue().iterator(); it.hasNext(); ) {
+      LogEntry entry = it.next();
+      assertThat(entry.getLabels()).isEqualTo(expectedLabels);
+      assertThat(entry.getPayload().getData()).isEqualTo(EXPECTED_STRUCT_LOG_PROTO);
+    }
+  }
+
+  @Test
+  public void verifyClose() throws Exception {
+    GcpLogSink sink = new GcpLogSink(mockLogging, DEST_PROJECT_NAME,
+        mockConfig, Collections.emptySet(), new TraceLoggingHelper(DEST_PROJECT_NAME));
+    sink.write(LOG_PROTO, null);
+    verify(mockLogging, times(1)).write(anyIterable());
+    sink.close();
+    verify(mockLogging).close();
+    verifyNoMoreInteractions(mockLogging);
+  }
+
+  @Test
+  public void verifyExclude() throws Exception {
+    Sink mockSink = new GcpLogSink(mockLogging, DEST_PROJECT_NAME,
+        mockConfig, Collections.singleton("service"), new TraceLoggingHelper(DEST_PROJECT_NAME));
+    mockSink.write(LOG_PROTO, null);
+    verifyNoInteractions(mockLogging);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void verifyNoTraceDataInLogs_withTraceDisabled() throws Exception {
+    SpanContext validSpanContext = SpanContext.create(
+        TraceId.fromLowerBase16("4c6af40c499951eb7de2777ba1e4fefa"),
+        SpanId.fromLowerBase16("de52e84d13dd232d"),
+        TraceOptions.builder().setIsSampled(true).build(),
+        Tracestate.builder().build());
+
+    TraceLoggingHelper traceLoggingHelper = new TraceLoggingHelper(DEST_PROJECT_NAME);
+    when(mockConfig.isEnableCloudTracing()).thenReturn(false);
+    Sink mockSink = new GcpLogSink(mockLogging, DEST_PROJECT_NAME,
+        mockConfig, Collections.emptySet(), traceLoggingHelper);
+    mockSink.write(LOG_PROTO, validSpanContext);
+
+    ArgumentCaptor<Collection<LogEntry>> logEntrySetCaptor = ArgumentCaptor.forClass(
+        (Class) Collection.class);
+    verify(mockLogging, times(1)).write(logEntrySetCaptor.capture());
+    for (Iterator<LogEntry> it = logEntrySetCaptor.getValue().iterator(); it.hasNext(); ) {
+      LogEntry entry = it.next();
+      assertThat(entry.getTrace()).isNull(); // Field not present
+      assertThat(entry.getSpanId()).isNull(); // Field not present
+      assertThat(entry.getTraceSampled()).isFalse(); // Default value
+      assertThat(entry.getPayload().getData()).isEqualTo(EXPECTED_STRUCT_LOG_PROTO);
+    }
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void verifyTraceDataInLogs_withValidSpanContext() throws Exception {
+    CharSequence traceIdSeq = "4c6af40c499951eb7de2777ba1e4fefa";
+    CharSequence spanIdSeq = "de52e84d13dd232d";
+    TraceId traceId = TraceId.fromLowerBase16(traceIdSeq);
+    SpanId spanId = SpanId.fromLowerBase16(spanIdSeq);
+    boolean traceSampled = true;
+
+    SpanContext validSpanContext = SpanContext.create(traceId, spanId,
+        TraceOptions.builder().setIsSampled(traceSampled).build(),
+        Tracestate.builder().build());
+
+    TraceLoggingHelper traceLoggingHelper = new TraceLoggingHelper(DEST_PROJECT_NAME);
+    when(mockConfig.isEnableCloudTracing()).thenReturn(true);
+    Sink mockSink = new GcpLogSink(mockLogging, DEST_PROJECT_NAME,
+        mockConfig, Collections.emptySet(), traceLoggingHelper);
+    mockSink.write(LOG_PROTO, validSpanContext);
+
+    String expectedTrace = "projects/" + DEST_PROJECT_NAME + "/traces/" + traceIdSeq;
+
+    ArgumentCaptor<Collection<LogEntry>> logEntrySetCaptor = ArgumentCaptor.forClass(
+        (Class) Collection.class);
+    verify(mockLogging, times(1)).write(logEntrySetCaptor.capture());
+    for (Iterator<LogEntry> it = logEntrySetCaptor.getValue().iterator(); it.hasNext(); ) {
+      LogEntry entry = it.next();
+      assertThat(entry.getTrace()).isEqualTo(expectedTrace);
+      assertThat(entry.getSpanId()).isEqualTo("" + spanIdSeq);
+      assertThat(entry.getTraceSampled()).isEqualTo(traceSampled);
+      assertThat(entry.getPayload().getData()).isEqualTo(EXPECTED_STRUCT_LOG_PROTO);
+    }
+
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void verifyTraceDataLogs_withNullSpanContext() throws Exception {
+    TraceLoggingHelper traceLoggingHelper = new TraceLoggingHelper(DEST_PROJECT_NAME);
+    when(mockConfig.isEnableCloudTracing()).thenReturn(true);
+    Sink mockSink = new GcpLogSink(mockLogging, DEST_PROJECT_NAME,
+        mockConfig, Collections.emptySet(), traceLoggingHelper);
+
+    String expectedTrace =
+        "projects/" + DEST_PROJECT_NAME + "/traces/00000000000000000000000000000000";
+    String expectedSpanId = "0000000000000000";
+
+    ArgumentCaptor<Collection<LogEntry>> logEntrySetCaptor = ArgumentCaptor.forClass(
+        (Class) Collection.class);
+
+    // Client log with default span context
+    mockSink.write(LOG_PROTO , SpanContext.INVALID);
+    verify(mockLogging, times(1)).write(logEntrySetCaptor.capture());
+    for (Iterator<LogEntry> it = logEntrySetCaptor.getValue().iterator(); it.hasNext(); ) {
+      LogEntry entry = it.next();
+      assertThat(entry.getTrace()).isEqualTo(expectedTrace);
+      assertThat(entry.getSpanId()).isEqualTo(expectedSpanId);
+      assertThat(entry.getTraceSampled()).isFalse();
+    }
+
+    // Server log
+    GrpcLogRecord serverLogProto = LOG_PROTO.toBuilder().setLogger(EventLogger.SERVER).build();
+    mockSink.write(serverLogProto , SpanContext.INVALID);
+    verify(mockLogging, times(2)).write(logEntrySetCaptor.capture());
+    for (Iterator<LogEntry> it = logEntrySetCaptor.getValue().iterator(); it.hasNext(); ) {
+      LogEntry entry = it.next();
+      assertThat(entry.getTrace()).isEqualTo(expectedTrace);
+      assertThat(entry.getSpanId()).isEqualTo(expectedSpanId);
+      assertThat(entry.getTraceSampled()).isFalse();
+    }
+  }
+}
diff --git a/gcp-observability/src/test/java/io/grpc/gcp/observability/logging/TraceLoggingHelperTest.java b/gcp-observability/src/test/java/io/grpc/gcp/observability/logging/TraceLoggingHelperTest.java
new file mode 100644
index 00000000000..893cf478c4c
--- /dev/null
+++ b/gcp-observability/src/test/java/io/grpc/gcp/observability/logging/TraceLoggingHelperTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2023 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.gcp.observability.logging;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.cloud.logging.LogEntry;
+import io.opencensus.trace.SpanContext;
+import io.opencensus.trace.SpanId;
+import io.opencensus.trace.TraceId;
+import io.opencensus.trace.TraceOptions;
+import io.opencensus.trace.Tracestate;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link TraceLoggingHelper}.
+ */
+@RunWith(JUnit4.class)
+public class TraceLoggingHelperTest {
+
+  private static final String PROJECT = "PROJECT";
+  private static final Tracestate EMPTY_TRACESTATE = Tracestate.builder().build();
+  private static TraceLoggingHelper traceLoggingHelper;
+
+  @Before
+  public void setUp() {
+    traceLoggingHelper = new TraceLoggingHelper(PROJECT);
+  }
+
+  @Test
+  public void enhanceLogEntry_AddSampledSpanContextToLogEntry() {
+    SpanContext spanContext = SpanContext.create(
+        TraceId.fromLowerBase16("5ce724c382c136b2a67bb447e6a6bd27"),
+        SpanId.fromLowerBase16("de52e84d13dd232d"),
+        TraceOptions.builder().setIsSampled(true).build(),
+        EMPTY_TRACESTATE);
+    LogEntry logEntry = getEnhancedLogEntry(traceLoggingHelper, spanContext);
+    assertThat(logEntry.getTraceSampled()).isTrue();
+    assertThat(logEntry.getTrace())
+        .isEqualTo("projects/PROJECT/traces/5ce724c382c136b2a67bb447e6a6bd27");
+    assertThat(logEntry.getSpanId()).isEqualTo("de52e84d13dd232d");
+  }
+
+  @Test
+  public void enhanceLogEntry_AddNonSampledSpanContextToLogEntry() {
+    SpanContext spanContext = SpanContext.create(
+        TraceId.fromLowerBase16("649a8a64db2d0c757fd06bb1bfe84e2c"),
+        SpanId.fromLowerBase16("731e102335b7a5a0"),
+        TraceOptions.builder().setIsSampled(false).build(),
+        EMPTY_TRACESTATE);
+    LogEntry logEntry = getEnhancedLogEntry(traceLoggingHelper, spanContext);
+    assertThat(logEntry.getTraceSampled()).isFalse();
+    assertThat(logEntry.getTrace())
+        .isEqualTo("projects/PROJECT/traces/649a8a64db2d0c757fd06bb1bfe84e2c");
+    assertThat(logEntry.getSpanId()).isEqualTo("731e102335b7a5a0");
+  }
+
+  @Test
+  public void enhanceLogEntry_AddBlankSpanContextToLogEntry() {
+    SpanContext spanContext = SpanContext.INVALID;
+    LogEntry logEntry = getEnhancedLogEntry(traceLoggingHelper, spanContext);
+    assertThat(logEntry.getTraceSampled()).isFalse();
+    assertThat(logEntry.getTrace())
+        .isEqualTo("projects/PROJECT/traces/00000000000000000000000000000000");
+    assertThat(logEntry.getSpanId()).isEqualTo("0000000000000000");
+  }
+
+  private static LogEntry getEnhancedLogEntry(TraceLoggingHelper traceLoggingHelper,
+      SpanContext spanContext) {
+    LogEntry.Builder logEntryBuilder = LogEntry.newBuilder(null);
+    traceLoggingHelper.enhanceLogEntry(logEntryBuilder, spanContext);
+    return logEntryBuilder.build();
+  }
+}
diff --git a/googleapis/BUILD.bazel b/googleapis/BUILD.bazel
new file mode 100644
index 00000000000..5b62b21cb3a
--- /dev/null
+++ b/googleapis/BUILD.bazel
@@ -0,0 +1,18 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "googleapis",
+    srcs = glob([
+        "src/main/java/**/*.java",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//alts",
+        "//api",
+        "//core:internal",
+        "//xds",
+        artifact("com.google.guava:guava"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+    ],
+)
diff --git a/googleapis/build.gradle b/googleapis/build.gradle
new file mode 100644
index 00000000000..3a7a3a2766a
--- /dev/null
+++ b/googleapis/build.gradle
@@ -0,0 +1,29 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "ru.vyarus.animalsniffer"
+}
+
+description = 'gRPC: googleapis'
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.googleapis')
+    }
+}
+
+dependencies {
+    api project(':grpc-api')
+    implementation project(path: ':grpc-alts', configuration: 'shadow'),
+                   project(':grpc-core'),
+                   project(path: ':grpc-xds', configuration: 'shadow'),
+                   libraries.guava.jre // JRE required by transitive protobuf-java-util
+    testImplementation testFixtures(project(':grpc-core'))
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
diff --git a/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdExperimentalNameResolverProvider.java b/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdExperimentalNameResolverProvider.java
new file mode 100644
index 00000000000..349e1c94380
--- /dev/null
+++ b/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdExperimentalNameResolverProvider.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2022 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.googleapis;
+
+import io.grpc.Internal;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.Args;
+import io.grpc.NameResolverProvider;
+import java.net.URI;
+
+/**
+ * A provider for {@link GoogleCloudToProdNameResolver}, with experimental scheme.
+ */
+@Internal
+public final class GoogleCloudToProdExperimentalNameResolverProvider extends NameResolverProvider {
+  private final GoogleCloudToProdNameResolverProvider delegate =
+      new GoogleCloudToProdNameResolverProvider("google-c2p-experimental");
+
+  @Override
+  public NameResolver newNameResolver(URI targetUri, Args args) {
+    return delegate.newNameResolver(targetUri, args);
+  }
+
+  @Override
+  public String getDefaultScheme() {
+    return delegate.getDefaultScheme();
+  }
+
+  @Override
+  protected boolean isAvailable() {
+    return delegate.isAvailable();
+  }
+
+  @Override
+  protected int priority() {
+    return delegate.priority();
+  }
+}
diff --git a/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolver.java b/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolver.java
new file mode 100644
index 00000000000..0aee17b6b9f
--- /dev/null
+++ b/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolver.java
@@ -0,0 +1,371 @@
+/*
+ * Copyright 2021 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.googleapis;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.io.CharStreams;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.MetricRecorder;
+import io.grpc.NameResolver;
+import io.grpc.NameResolverRegistry;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.alts.InternalCheckGcpEnvironment;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.SharedResourceHolder;
+import io.grpc.internal.SharedResourceHolder.Resource;
+import io.grpc.xds.InternalGrpcBootstrapperImpl;
+import io.grpc.xds.InternalSharedXdsClientPoolProvider;
+import io.grpc.xds.InternalSharedXdsClientPoolProvider.XdsClientResult;
+import io.grpc.xds.XdsNameResolverProvider;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsInitializationException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.Random;
+import java.util.concurrent.Executor;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * CloudToProd version of {@link NameResolver}.
+ */
+final class GoogleCloudToProdNameResolver extends NameResolver {
+  private static final Logger logger =
+      Logger.getLogger(GoogleCloudToProdNameResolver.class.getName());
+
+  @VisibleForTesting
+  static final String METADATA_URL_ZONE =
+      "http://metadata.google.internal/computeMetadata/v1/instance/zone";
+  @VisibleForTesting
+  static final String METADATA_URL_SUPPORT_IPV6 =
+      "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ipv6s";
+  static final String C2P_AUTHORITY = "traffic-director-c2p.xds.googleapis.com";
+  @VisibleForTesting
+  static boolean isOnGcp = InternalCheckGcpEnvironment.isOnGcp();
+
+  private static final String serverUriOverride =
+      System.getenv("GRPC_TEST_ONLY_GOOGLE_C2P_RESOLVER_TRAFFIC_DIRECTOR_URI");
+
+  @GuardedBy("GoogleCloudToProdNameResolver.class")
+  private static BootstrapInfo bootstrapInfo;
+  private static HttpConnectionProvider httpConnectionProvider = HttpConnectionFactory.INSTANCE;
+  private static int c2pId = new Random().nextInt();
+
+  private static synchronized BootstrapInfo getBootstrapInfo()
+      throws XdsInitializationException, IOException {
+    if (bootstrapInfo != null) {
+      return bootstrapInfo;
+    }
+    BootstrapInfo bootstrapInfoTmp =
+        InternalGrpcBootstrapperImpl.parseBootstrap(generateBootstrap());
+    // Avoid setting global when testing
+    if (httpConnectionProvider == HttpConnectionFactory.INSTANCE) {
+      bootstrapInfo = bootstrapInfoTmp;
+    }
+    return bootstrapInfoTmp;
+  }
+
+  private final String authority;
+  private final SynchronizationContext syncContext;
+  private final Resource<Executor> executorResource;
+  private final String target;
+  private final MetricRecorder metricRecorder;
+  private final NameResolver delegate;
+  private final boolean usingExecutorResource;
+  private final String schemeOverride = !isOnGcp ? "dns" : "xds";
+  private XdsClientResult xdsClientPool;
+  private XdsClient xdsClient;
+  private Executor executor;
+  private Listener2 listener;
+  private boolean succeeded;
+  private boolean resolving;
+  private boolean shutdown;
+
+  GoogleCloudToProdNameResolver(URI targetUri, Args args, Resource<Executor> executorResource) {
+    this(targetUri, args, executorResource,
+        NameResolverRegistry.getDefaultRegistry().asFactory());
+  }
+
+  @VisibleForTesting
+  GoogleCloudToProdNameResolver(URI targetUri, Args args, Resource<Executor> executorResource,
+      NameResolver.Factory nameResolverFactory) {
+    this.executorResource = checkNotNull(executorResource, "executorResource");
+    String targetPath = checkNotNull(checkNotNull(targetUri, "targetUri").getPath(), "targetPath");
+    Preconditions.checkArgument(
+        targetPath.startsWith("/"),
+        "the path component (%s) of the target (%s) must start with '/'",
+        targetPath,
+        targetUri);
+    authority = GrpcUtil.checkAuthority(targetPath.substring(1));
+    syncContext = checkNotNull(args, "args").getSynchronizationContext();
+    targetUri = overrideUriScheme(targetUri, schemeOverride);
+    if (schemeOverride.equals("xds")) {
+      targetUri = overrideUriAuthority(targetUri, C2P_AUTHORITY);
+      args = args.toBuilder()
+          .setArg(XdsNameResolverProvider.XDS_CLIENT_SUPPLIER, () -> xdsClient)
+          .build();
+    }
+    target = targetUri.toString();
+    metricRecorder = args.getMetricRecorder();
+    delegate = checkNotNull(nameResolverFactory, "nameResolverFactory").newNameResolver(
+        targetUri, args);
+    executor = args.getOffloadExecutor();
+    usingExecutorResource = executor == null;
+  }
+
+  @Override
+  public String getServiceAuthority() {
+    return authority;
+  }
+
+  @Override
+  public void start(final Listener2 listener) {
+    if (delegate == null) {
+      listener.onError(Status.INTERNAL.withDescription(
+          "Delegate resolver not found, scheme: " + schemeOverride));
+      return;
+    }
+    this.listener = checkNotNull(listener, "listener");
+    resolve();
+  }
+
+  private void resolve() {
+    if (resolving || shutdown || delegate == null) {
+      return;
+    }
+
+    resolving = true;
+    if (logger.isLoggable(Level.FINE)) {
+      logger.log(Level.FINE, "start with schemaOverride = {0}", schemeOverride);
+    }
+
+    if (schemeOverride.equals("dns")) {
+      delegate.start(listener);
+      succeeded = true;
+      resolving = false;
+      return;
+    }
+
+    // Since not dns, we must be using xds
+    if (executor == null) {
+      executor = SharedResourceHolder.get(executorResource);
+    }
+
+    class Resolve implements Runnable {
+      @Override
+      public void run() {
+        BootstrapInfo bootstrapInfo = null;
+        try {
+          bootstrapInfo = getBootstrapInfo();
+        } catch (IOException e) {
+          listener.onError(
+              Status.INTERNAL.withDescription("Unable to get metadata").withCause(e));
+        } catch (XdsInitializationException e) {
+          listener.onError(
+              Status.INTERNAL.withDescription("Unable to create c2p bootstrap").withCause(e));
+        } catch (Throwable t) {
+          listener.onError(
+              Status.INTERNAL.withDescription("Unexpected error creating c2p bootstrap")
+              .withCause(t));
+        } finally {
+          final BootstrapInfo finalBootstrapInfo = bootstrapInfo;
+          syncContext.execute(new Runnable() {
+            @Override
+            public void run() {
+              if (!shutdown && finalBootstrapInfo != null) {
+                xdsClientPool = InternalSharedXdsClientPoolProvider.getOrCreate(
+                    target, finalBootstrapInfo, metricRecorder, null);
+                xdsClient = xdsClientPool.getObject();
+                delegate.start(listener);
+                succeeded = true;
+              }
+              resolving = false;
+            }
+          });
+        }
+      }
+    }
+
+    executor.execute(new Resolve());
+  }
+
+  @VisibleForTesting
+  static ImmutableMap<String, ?> generateBootstrap() throws IOException {
+    return generateBootstrap(
+        queryZoneMetadata(METADATA_URL_ZONE),
+        queryIpv6SupportMetadata(METADATA_URL_SUPPORT_IPV6));
+  }
+
+  private static ImmutableMap<String, ?> generateBootstrap(String zone, boolean supportIpv6) {
+    ImmutableMap.Builder<String, Object> nodeBuilder = ImmutableMap.builder();
+    nodeBuilder.put("id", "C2P-" + (c2pId & Integer.MAX_VALUE));
+    if (!zone.isEmpty()) {
+      nodeBuilder.put("locality", ImmutableMap.of("zone", zone));
+    }
+    if (supportIpv6) {
+      nodeBuilder.put("metadata",
+          ImmutableMap.of("TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE", true));
+    }
+    ImmutableMap.Builder<String, Object> serverBuilder = ImmutableMap.builder();
+    String serverUri = "directpath-pa.googleapis.com";
+    if (serverUriOverride != null && serverUriOverride.length() > 0) {
+      serverUri = serverUriOverride;
+    }
+    serverBuilder.put("server_uri", serverUri);
+    serverBuilder.put("channel_creds",
+        ImmutableList.of(ImmutableMap.of("type", "google_default")));
+    serverBuilder.put("server_features", ImmutableList.of("xds_v3", "ignore_resource_deletion"));
+    ImmutableMap.Builder<String, Object> authoritiesBuilder = ImmutableMap.builder();
+    authoritiesBuilder.put(
+        C2P_AUTHORITY,
+        ImmutableMap.of("xds_servers", ImmutableList.of(serverBuilder.buildOrThrow())));
+    return ImmutableMap.of(
+        "node", nodeBuilder.buildOrThrow(),
+        "xds_servers", ImmutableList.of(serverBuilder.buildOrThrow()),
+        "authorities", authoritiesBuilder.buildOrThrow());
+  }
+
+  @Override
+  public void refresh() {
+    if (succeeded) {
+      delegate.refresh();
+    } else if (!resolving) {
+      resolve();
+    }
+  }
+
+  @Override
+  public void shutdown() {
+    if (shutdown) {
+      return;
+    }
+    shutdown = true;
+    if (delegate != null) {
+      delegate.shutdown();
+    }
+    if (xdsClient != null) {
+      xdsClient = xdsClientPool.returnObject(xdsClient);
+    }
+    if (executor != null && usingExecutorResource) {
+      executor = SharedResourceHolder.release(executorResource, executor);
+    }
+  }
+
+  private static String queryZoneMetadata(String url) throws IOException {
+    HttpURLConnection con = null;
+    String respBody;
+    try {
+      con = httpConnectionProvider.createConnection(url);
+      if (con.getResponseCode() != 200) {
+        return "";
+      }
+      try (Reader reader = new InputStreamReader(con.getInputStream(), StandardCharsets.UTF_8)) {
+        respBody = CharStreams.toString(reader);
+      }
+    } finally {
+      if (con != null) {
+        con.disconnect();
+      }
+    }
+    int index = respBody.lastIndexOf('/');
+    return index == -1 ? "" : respBody.substring(index + 1);
+  }
+
+  private static boolean queryIpv6SupportMetadata(String url) throws IOException {
+    HttpURLConnection con = null;
+    try {
+      con = httpConnectionProvider.createConnection(url);
+      if (con.getResponseCode() != 200 ) {
+        return false;
+      }
+      InputStream inputStream = con.getInputStream();
+      int c;
+      return (inputStream != null
+          && (c = inputStream.read()) != -1 && !Character.isWhitespace(c));
+    } finally {
+      if (con != null) {
+        con.disconnect();
+      }
+    }
+  }
+
+  @VisibleForTesting
+  static void setHttpConnectionProvider(HttpConnectionProvider httpConnectionProvider) {
+    if (httpConnectionProvider == null) {
+      GoogleCloudToProdNameResolver.httpConnectionProvider = HttpConnectionFactory.INSTANCE;
+    } else {
+      GoogleCloudToProdNameResolver.httpConnectionProvider = httpConnectionProvider;
+    }
+  }
+
+  @VisibleForTesting
+  static void setC2pId(int c2pId) {
+    GoogleCloudToProdNameResolver.c2pId = c2pId;
+  }
+
+  private static URI overrideUriScheme(URI uri, String scheme) {
+    URI res;
+    try {
+      res = new URI(scheme, uri.getAuthority(), uri.getPath(), uri.getQuery(), uri.getFragment());
+    } catch (URISyntaxException ex) {
+      throw new IllegalArgumentException("Invalid scheme: " + scheme, ex);
+    }
+    return res;
+  }
+
+  private static URI overrideUriAuthority(URI uri, String authority) {
+    URI res;
+    try {
+      res = new URI(uri.getScheme(), authority, uri.getPath(), uri.getQuery(), uri.getFragment());
+    } catch (URISyntaxException ex) {
+      throw new IllegalArgumentException("Invalid authority: " + authority, ex);
+    }
+    return res;
+  }
+
+  private enum HttpConnectionFactory implements HttpConnectionProvider {
+    INSTANCE;
+
+    @Override
+    public HttpURLConnection createConnection(String url) throws IOException {
+      HttpURLConnection con = (HttpURLConnection) new URL(url).openConnection();
+      con.setRequestMethod("GET");
+      con.setReadTimeout(10000);
+      con.setRequestProperty("Metadata-Flavor", "Google");
+      return con;
+    }
+  }
+
+  @VisibleForTesting
+  interface HttpConnectionProvider {
+    HttpURLConnection createConnection(String url) throws IOException;
+  }
+}
diff --git a/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProvider.java b/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProvider.java
new file mode 100644
index 00000000000..c02cf53c2d2
--- /dev/null
+++ b/googleapis/src/main/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProvider.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2021 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.googleapis;
+
+import com.google.common.base.Preconditions;
+import io.grpc.Internal;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.Args;
+import io.grpc.NameResolverProvider;
+import io.grpc.internal.GrpcUtil;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * A provider for {@link GoogleCloudToProdNameResolver}.
+ */
+@Internal
+public final class GoogleCloudToProdNameResolverProvider extends NameResolverProvider {
+
+  private static final String SCHEME = "google-c2p";
+
+  private final String scheme;
+
+  public GoogleCloudToProdNameResolverProvider() {
+    this(SCHEME);
+  }
+
+  GoogleCloudToProdNameResolverProvider(String scheme) {
+    this.scheme = Preconditions.checkNotNull(scheme, "scheme");
+  }
+
+  @Override
+  public NameResolver newNameResolver(URI targetUri, Args args) {
+    if (scheme.equals(targetUri.getScheme())) {
+      return new GoogleCloudToProdNameResolver(
+          targetUri, args, GrpcUtil.SHARED_CHANNEL_EXECUTOR);
+    }
+    return null;
+  }
+
+  @Override
+  public String getDefaultScheme() {
+    return scheme;
+  }
+
+  @Override
+  protected boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  protected int priority() {
+    return 4;
+  }
+
+  @Override
+  public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+    return Collections.singleton(InetSocketAddress.class);
+  }
+}
diff --git a/googleapis/src/main/resources/META-INF/services/io.grpc.NameResolverProvider b/googleapis/src/main/resources/META-INF/services/io.grpc.NameResolverProvider
new file mode 100644
index 00000000000..1d08ff2bb0b
--- /dev/null
+++ b/googleapis/src/main/resources/META-INF/services/io.grpc.NameResolverProvider
@@ -0,0 +1,2 @@
+io.grpc.googleapis.GoogleCloudToProdExperimentalNameResolverProvider
+io.grpc.googleapis.GoogleCloudToProdNameResolverProvider
diff --git a/googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProviderTest.java b/googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProviderTest.java
new file mode 100644
index 00000000000..447b102c8c7
--- /dev/null
+++ b/googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverProviderTest.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2021 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.googleapis;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.ChannelLogger;
+import io.grpc.InternalServiceProviders;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.NameResolverProvider;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GrpcUtil;
+import java.net.URI;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link GoogleCloudToProdNameResolverProvider}.
+ */
+@RunWith(JUnit4.class)
+public class GoogleCloudToProdNameResolverProviderTest {
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+
+  private final FakeClock fakeClock = new FakeClock();
+  private final NameResolver.Args args = NameResolver.Args.newBuilder()
+      .setDefaultPort(8080)
+      .setProxyDetector(GrpcUtil.NOOP_PROXY_DETECTOR)
+      .setSynchronizationContext(syncContext)
+      .setServiceConfigParser(mock(ServiceConfigParser.class))
+      .setScheduledExecutorService(fakeClock.getScheduledExecutorService())
+      .setChannelLogger(mock(ChannelLogger.class))
+      .build();
+
+  private GoogleCloudToProdNameResolverProvider provider =
+      new GoogleCloudToProdNameResolverProvider();
+
+  @Test
+  public void provided() {
+    for (NameResolverProvider current
+        : InternalServiceProviders.getCandidatesViaServiceLoader(
+        NameResolverProvider.class, getClass().getClassLoader())) {
+      if (current instanceof GoogleCloudToProdNameResolverProvider) {
+        return;
+      }
+    }
+    fail("GoogleCloudToProdNameResolverProvider not registered");
+  }
+
+  @Test
+  public void experimentalProvided() {
+    for (NameResolverProvider current
+        : InternalServiceProviders.getCandidatesViaServiceLoader(
+        NameResolverProvider.class, getClass().getClassLoader())) {
+      if (current instanceof GoogleCloudToProdExperimentalNameResolverProvider) {
+        return;
+      }
+    }
+    fail("GoogleCloudToProdExperimentalNameResolverProvider not registered");
+  }
+
+  @Test
+  public void newNameResolver() {
+    assertThat(provider
+        .newNameResolver(URI.create("google-c2p:///foo.googleapis.com"), args))
+        .isInstanceOf(GoogleCloudToProdNameResolver.class);
+  }
+
+  @Test
+  public void experimentalNewNameResolver() {
+    assertThat(new GoogleCloudToProdExperimentalNameResolverProvider()
+        .newNameResolver(URI.create("google-c2p-experimental:///foo.googleapis.com"), args))
+        .isInstanceOf(GoogleCloudToProdNameResolver.class);
+  }
+}
diff --git a/googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverTest.java b/googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverTest.java
new file mode 100644
index 00000000000..6a144696447
--- /dev/null
+++ b/googleapis/src/test/java/io/grpc/googleapis/GoogleCloudToProdNameResolverTest.java
@@ -0,0 +1,280 @@
+/*
+ * Copyright 2021 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.googleapis;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import io.grpc.ChannelLogger;
+import io.grpc.MetricRecorder;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.Args;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.NameResolverProvider;
+import io.grpc.NameResolverRegistry;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.googleapis.GoogleCloudToProdNameResolver.HttpConnectionProvider;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.SharedResourceHolder.Resource;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.Executor;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class GoogleCloudToProdNameResolverTest {
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private static final URI TARGET_URI = URI.create("google-c2p:///googleapis.com");
+  private static final String ZONE = "us-central1-a";
+  private static final int DEFAULT_PORT = 887;
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final FakeClock fakeExecutor = new FakeClock();
+  private final NameResolver.Args args = NameResolver.Args.newBuilder()
+      .setDefaultPort(DEFAULT_PORT)
+      .setProxyDetector(GrpcUtil.DEFAULT_PROXY_DETECTOR)
+      .setSynchronizationContext(syncContext)
+      .setScheduledExecutorService(fakeExecutor.getScheduledExecutorService())
+      .setServiceConfigParser(mock(ServiceConfigParser.class))
+      .setChannelLogger(mock(ChannelLogger.class))
+      .setMetricRecorder(new MetricRecorder() {})
+      .build();
+  private final Resource<Executor> fakeExecutorResource = new Resource<Executor>() {
+    @Override
+    public Executor create() {
+      return fakeExecutor.getScheduledExecutorService();
+    }
+
+    @Override
+    public void close(Executor instance) {}
+  };
+
+  private final NameResolverRegistry nsRegistry = new NameResolverRegistry();
+  private final Map<String, NameResolver> delegatedResolver = new HashMap<>();
+
+  @Mock
+  private NameResolver.Listener2 mockListener;
+  @Captor
+  private ArgumentCaptor<Status> errorCaptor;
+  private boolean originalIsOnGcp;
+  private GoogleCloudToProdNameResolver resolver;
+  private String responseToIpV6 = "1:1:1";
+
+  @Before
+  public void setUp() {
+    nsRegistry.register(new FakeNsProvider("dns"));
+    nsRegistry.register(new FakeNsProvider("xds"));
+    originalIsOnGcp = GoogleCloudToProdNameResolver.isOnGcp;
+
+    HttpConnectionProvider httpConnections = new HttpConnectionProvider() {
+      @Override
+      public HttpURLConnection createConnection(String url) throws IOException {
+        HttpURLConnection con = mock(HttpURLConnection.class);
+        when(con.getResponseCode()).thenReturn(200);
+        if (url.equals(GoogleCloudToProdNameResolver.METADATA_URL_ZONE)) {
+          when(con.getInputStream()).thenReturn(
+              new ByteArrayInputStream(("/" + ZONE).getBytes(StandardCharsets.UTF_8)));
+          return con;
+        } else if (url.equals(GoogleCloudToProdNameResolver.METADATA_URL_SUPPORT_IPV6)) {
+          if (responseToIpV6 != null) {
+            when(con.getInputStream()).thenReturn(
+                new ByteArrayInputStream(responseToIpV6.getBytes(StandardCharsets.UTF_8)));
+          }
+          return con;
+        }
+        throw new AssertionError("Unknown http query");
+      }
+    };
+    GoogleCloudToProdNameResolver.setHttpConnectionProvider(httpConnections);
+
+    GoogleCloudToProdNameResolver.setC2pId(new Random(1).nextInt());
+  }
+
+  @After
+  public void tearDown() {
+    GoogleCloudToProdNameResolver.isOnGcp = originalIsOnGcp;
+    GoogleCloudToProdNameResolver.setHttpConnectionProvider(null);
+    if (resolver != null) {
+      resolver.shutdown();
+      verify(Iterables.getOnlyElement(delegatedResolver.values())).shutdown();
+    }
+  }
+
+  private void createResolver() {
+    resolver = new GoogleCloudToProdNameResolver(
+        TARGET_URI, args, fakeExecutorResource, nsRegistry.asFactory());
+  }
+
+  @Test
+  public void notOnGcp_DelegateToDns() {
+    GoogleCloudToProdNameResolver.isOnGcp = false;
+    createResolver();
+    resolver.start(mockListener);
+    assertThat(delegatedResolver.keySet()).containsExactly("dns");
+    verify(Iterables.getOnlyElement(delegatedResolver.values())).start(mockListener);
+  }
+
+  @Test
+  public void onGcpAndNoProvidedBootstrap_DelegateToXds() {
+    GoogleCloudToProdNameResolver.isOnGcp = true;
+    createResolver();
+    resolver.start(mockListener);
+    fakeExecutor.runDueTasks();
+    assertThat(delegatedResolver.keySet()).containsExactly("xds");
+    verify(Iterables.getOnlyElement(delegatedResolver.values())).start(mockListener);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void generateBootstrap_ipv6() throws IOException {
+    Map<String, ?> bootstrap = GoogleCloudToProdNameResolver.generateBootstrap();
+    Map<String, ?> node = (Map<String, ?>) bootstrap.get("node");
+    assertThat(node).containsExactly(
+        "id", "C2P-991614323",
+        "locality", ImmutableMap.of("zone", ZONE),
+        "metadata", ImmutableMap.of("TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE", true));
+    Map<String, ?> server = Iterables.getOnlyElement(
+        (List<Map<String, ?>>) bootstrap.get("xds_servers"));
+    assertThat(server).containsExactly(
+        "server_uri", "directpath-pa.googleapis.com",
+        "channel_creds", ImmutableList.of(ImmutableMap.of("type", "google_default")),
+        "server_features", ImmutableList.of("xds_v3", "ignore_resource_deletion"));
+    Map<String, ?> authorities = (Map<String, ?>) bootstrap.get("authorities");
+    assertThat(authorities).containsExactly(
+        "traffic-director-c2p.xds.googleapis.com",
+        ImmutableMap.of("xds_servers", ImmutableList.of(server)));
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void generateBootstrap_noIpV6() throws IOException {
+    responseToIpV6 = null;
+    Map<String, ?> bootstrap = GoogleCloudToProdNameResolver.generateBootstrap();
+    Map<String, ?> node = (Map<String, ?>) bootstrap.get("node");
+    assertThat(node).containsExactly(
+        "id", "C2P-991614323",
+        "locality", ImmutableMap.of("zone", ZONE));
+    Map<String, ?> server = Iterables.getOnlyElement(
+        (List<Map<String, ?>>) bootstrap.get("xds_servers"));
+    assertThat(server).containsExactly(
+        "server_uri", "directpath-pa.googleapis.com",
+        "channel_creds", ImmutableList.of(ImmutableMap.of("type", "google_default")),
+        "server_features", ImmutableList.of("xds_v3", "ignore_resource_deletion"));
+    Map<String, ?> authorities = (Map<String, ?>) bootstrap.get("authorities");
+    assertThat(authorities).containsExactly(
+        "traffic-director-c2p.xds.googleapis.com",
+        ImmutableMap.of("xds_servers", ImmutableList.of(server)));
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void emptyResolverMeetadataValue() throws IOException {
+    responseToIpV6 = "";
+    Map<String, ?> bootstrap = GoogleCloudToProdNameResolver.generateBootstrap();
+    Map<String, ?> node = (Map<String, ?>) bootstrap.get("node");
+    assertThat(node).containsExactly(
+        "id", "C2P-991614323",
+        "locality", ImmutableMap.of("zone", ZONE));
+  }
+
+  @Test
+  public void failToQueryMetadata() {
+    GoogleCloudToProdNameResolver.isOnGcp = true;
+    createResolver();
+    HttpConnectionProvider httpConnections = new HttpConnectionProvider() {
+      @Override
+      public HttpURLConnection createConnection(String url) throws IOException {
+        HttpURLConnection con = mock(HttpURLConnection.class);
+        when(con.getResponseCode()).thenThrow(new IOException("unknown error"));
+        return con;
+      }
+    };
+    GoogleCloudToProdNameResolver.setHttpConnectionProvider(httpConnections);
+    resolver.start(mockListener);
+    fakeExecutor.runDueTasks();
+    verify(mockListener).onError(errorCaptor.capture());
+    assertThat(errorCaptor.getValue().getCode()).isEqualTo(Code.INTERNAL);
+    assertThat(errorCaptor.getValue().getDescription()).isEqualTo("Unable to get metadata");
+  }
+
+  private final class FakeNsProvider extends NameResolverProvider {
+    private final String scheme;
+
+    private FakeNsProvider(String scheme) {
+      this.scheme = scheme;
+    }
+
+    @Override
+    public NameResolver newNameResolver(URI targetUri, Args args) {
+      if (scheme.equals(targetUri.getScheme())) {
+        NameResolver resolver = mock(NameResolver.class);
+        delegatedResolver.put(scheme, resolver);
+        return resolver;
+      }
+      return null;
+    }
+
+    @Override
+    protected boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    protected int priority() {
+      return 5;
+    }
+
+    @Override
+    public String getDefaultScheme() {
+      return scheme;
+    }
+  }
+}
diff --git a/gradle/javadoc/docs.oracle.com-javase-8-docs-api/package-list b/gradle/javadoc/docs.oracle.com-javase-8-docs-api/package-list
new file mode 100644
index 00000000000..351c1868559
--- /dev/null
+++ b/gradle/javadoc/docs.oracle.com-javase-8-docs-api/package-list
@@ -0,0 +1,217 @@
+java.applet
+java.awt
+java.awt.color
+java.awt.datatransfer
+java.awt.dnd
+java.awt.event
+java.awt.font
+java.awt.geom
+java.awt.im
+java.awt.im.spi
+java.awt.image
+java.awt.image.renderable
+java.awt.print
+java.beans
+java.beans.beancontext
+java.io
+java.lang
+java.lang.annotation
+java.lang.instrument
+java.lang.invoke
+java.lang.management
+java.lang.ref
+java.lang.reflect
+java.math
+java.net
+java.nio
+java.nio.channels
+java.nio.channels.spi
+java.nio.charset
+java.nio.charset.spi
+java.nio.file
+java.nio.file.attribute
+java.nio.file.spi
+java.rmi
+java.rmi.activation
+java.rmi.dgc
+java.rmi.registry
+java.rmi.server
+java.security
+java.security.acl
+java.security.cert
+java.security.interfaces
+java.security.spec
+java.sql
+java.text
+java.text.spi
+java.time
+java.time.chrono
+java.time.format
+java.time.temporal
+java.time.zone
+java.util
+java.util.concurrent
+java.util.concurrent.atomic
+java.util.concurrent.locks
+java.util.function
+java.util.jar
+java.util.logging
+java.util.prefs
+java.util.regex
+java.util.spi
+java.util.stream
+java.util.zip
+javax.accessibility
+javax.activation
+javax.activity
+javax.annotation
+javax.annotation.processing
+javax.crypto
+javax.crypto.interfaces
+javax.crypto.spec
+javax.imageio
+javax.imageio.event
+javax.imageio.metadata
+javax.imageio.plugins.bmp
+javax.imageio.plugins.jpeg
+javax.imageio.spi
+javax.imageio.stream
+javax.jws
+javax.jws.soap
+javax.lang.model
+javax.lang.model.element
+javax.lang.model.type
+javax.lang.model.util
+javax.management
+javax.management.loading
+javax.management.modelmbean
+javax.management.monitor
+javax.management.openmbean
+javax.management.relation
+javax.management.remote
+javax.management.remote.rmi
+javax.management.timer
+javax.naming
+javax.naming.directory
+javax.naming.event
+javax.naming.ldap
+javax.naming.spi
+javax.net
+javax.net.ssl
+javax.print
+javax.print.attribute
+javax.print.attribute.standard
+javax.print.event
+javax.rmi
+javax.rmi.CORBA
+javax.rmi.ssl
+javax.script
+javax.security.auth
+javax.security.auth.callback
+javax.security.auth.kerberos
+javax.security.auth.login
+javax.security.auth.spi
+javax.security.auth.x500
+javax.security.cert
+javax.security.sasl
+javax.sound.midi
+javax.sound.midi.spi
+javax.sound.sampled
+javax.sound.sampled.spi
+javax.sql
+javax.sql.rowset
+javax.sql.rowset.serial
+javax.sql.rowset.spi
+javax.swing
+javax.swing.border
+javax.swing.colorchooser
+javax.swing.event
+javax.swing.filechooser
+javax.swing.plaf
+javax.swing.plaf.basic
+javax.swing.plaf.metal
+javax.swing.plaf.multi
+javax.swing.plaf.nimbus
+javax.swing.plaf.synth
+javax.swing.table
+javax.swing.text
+javax.swing.text.html
+javax.swing.text.html.parser
+javax.swing.text.rtf
+javax.swing.tree
+javax.swing.undo
+javax.tools
+javax.transaction
+javax.transaction.xa
+javax.xml
+javax.xml.bind
+javax.xml.bind.annotation
+javax.xml.bind.annotation.adapters
+javax.xml.bind.attachment
+javax.xml.bind.helpers
+javax.xml.bind.util
+javax.xml.crypto
+javax.xml.crypto.dom
+javax.xml.crypto.dsig
+javax.xml.crypto.dsig.dom
+javax.xml.crypto.dsig.keyinfo
+javax.xml.crypto.dsig.spec
+javax.xml.datatype
+javax.xml.namespace
+javax.xml.parsers
+javax.xml.soap
+javax.xml.stream
+javax.xml.stream.events
+javax.xml.stream.util
+javax.xml.transform
+javax.xml.transform.dom
+javax.xml.transform.sax
+javax.xml.transform.stax
+javax.xml.transform.stream
+javax.xml.validation
+javax.xml.ws
+javax.xml.ws.handler
+javax.xml.ws.handler.soap
+javax.xml.ws.http
+javax.xml.ws.soap
+javax.xml.ws.spi
+javax.xml.ws.spi.http
+javax.xml.ws.wsaddressing
+javax.xml.xpath
+org.ietf.jgss
+org.omg.CORBA
+org.omg.CORBA.DynAnyPackage
+org.omg.CORBA.ORBPackage
+org.omg.CORBA.TypeCodePackage
+org.omg.CORBA.portable
+org.omg.CORBA_2_3
+org.omg.CORBA_2_3.portable
+org.omg.CosNaming
+org.omg.CosNaming.NamingContextExtPackage
+org.omg.CosNaming.NamingContextPackage
+org.omg.Dynamic
+org.omg.DynamicAny
+org.omg.DynamicAny.DynAnyFactoryPackage
+org.omg.DynamicAny.DynAnyPackage
+org.omg.IOP
+org.omg.IOP.CodecFactoryPackage
+org.omg.IOP.CodecPackage
+org.omg.Messaging
+org.omg.PortableInterceptor
+org.omg.PortableInterceptor.ORBInitInfoPackage
+org.omg.PortableServer
+org.omg.PortableServer.CurrentPackage
+org.omg.PortableServer.POAManagerPackage
+org.omg.PortableServer.POAPackage
+org.omg.PortableServer.ServantLocatorPackage
+org.omg.PortableServer.portable
+org.omg.SendingContext
+org.omg.stub.java.rmi
+org.w3c.dom
+org.w3c.dom.bootstrap
+org.w3c.dom.events
+org.w3c.dom.ls
+org.w3c.dom.views
+org.xml.sax
+org.xml.sax.ext
+org.xml.sax.helpers
diff --git a/gradle/javadoc/netty.io-4.1-api/package-list b/gradle/javadoc/netty.io-4.1-api/package-list
new file mode 100644
index 00000000000..1e0c21c9569
--- /dev/null
+++ b/gradle/javadoc/netty.io-4.1-api/package-list
@@ -0,0 +1,77 @@
+io.netty.bootstrap
+io.netty.buffer
+io.netty.buffer.search
+io.netty.channel
+io.netty.channel.embedded
+io.netty.channel.epoll
+io.netty.channel.group
+io.netty.channel.internal
+io.netty.channel.kqueue
+io.netty.channel.local
+io.netty.channel.nio
+io.netty.channel.oio
+io.netty.channel.pool
+io.netty.channel.rxtx
+io.netty.channel.sctp
+io.netty.channel.sctp.nio
+io.netty.channel.sctp.oio
+io.netty.channel.socket
+io.netty.channel.socket.nio
+io.netty.channel.socket.oio
+io.netty.channel.udt
+io.netty.channel.udt.nio
+io.netty.channel.unix
+io.netty.handler.address
+io.netty.handler.codec
+io.netty.handler.codec.base64
+io.netty.handler.codec.bytes
+io.netty.handler.codec.compression
+io.netty.handler.codec.dns
+io.netty.handler.codec.haproxy
+io.netty.handler.codec.http
+io.netty.handler.codec.http.cookie
+io.netty.handler.codec.http.cors
+io.netty.handler.codec.http.multipart
+io.netty.handler.codec.http.websocketx
+io.netty.handler.codec.http.websocketx.extensions
+io.netty.handler.codec.http.websocketx.extensions.compression
+io.netty.handler.codec.http2
+io.netty.handler.codec.json
+io.netty.handler.codec.marshalling
+io.netty.handler.codec.memcache
+io.netty.handler.codec.memcache.binary
+io.netty.handler.codec.mqtt
+io.netty.handler.codec.protobuf
+io.netty.handler.codec.redis
+io.netty.handler.codec.rtsp
+io.netty.handler.codec.sctp
+io.netty.handler.codec.serialization
+io.netty.handler.codec.smtp
+io.netty.handler.codec.socks
+io.netty.handler.codec.socksx
+io.netty.handler.codec.socksx.v4
+io.netty.handler.codec.socksx.v5
+io.netty.handler.codec.spdy
+io.netty.handler.codec.stomp
+io.netty.handler.codec.string
+io.netty.handler.codec.xml
+io.netty.handler.flow
+io.netty.handler.flush
+io.netty.handler.ipfilter
+io.netty.handler.logging
+io.netty.handler.pcap
+io.netty.handler.proxy
+io.netty.handler.ssl
+io.netty.handler.ssl.ocsp
+io.netty.handler.ssl.util
+io.netty.handler.stream
+io.netty.handler.timeout
+io.netty.handler.traffic
+io.netty.resolver
+io.netty.resolver.dns
+io.netty.resolver.dns.macos
+io.netty.util
+io.netty.util.collection
+io.netty.util.concurrent
+io.netty.util.internal
+io.netty.util.internal.logging
diff --git a/gradle/javadoc/protobuf.dev-reference-java-api-docs/package-list b/gradle/javadoc/protobuf.dev-reference-java-api-docs/package-list
new file mode 100644
index 00000000000..31bcc3a0531
--- /dev/null
+++ b/gradle/javadoc/protobuf.dev-reference-java-api-docs/package-list
@@ -0,0 +1,3 @@
+com.google.protobuf
+com.google.protobuf.compiler
+com.google.protobuf.util
diff --git a/gradle/javadoc/square.github.io-okhttp-2.x-okhttp/package-list b/gradle/javadoc/square.github.io-okhttp-2.x-okhttp/package-list
new file mode 100644
index 00000000000..ac5f84bc538
--- /dev/null
+++ b/gradle/javadoc/square.github.io-okhttp-2.x-okhttp/package-list
@@ -0,0 +1 @@
+com.squareup.okhttp
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
new file mode 100644
index 00000000000..3806fa3404e
--- /dev/null
+++ b/gradle/libs.versions.toml
@@ -0,0 +1,145 @@
+[versions]
+opencensus = "0.31.1"
+
+[libraries]
+android-annotations = "com.google.android:annotations:4.1.1.4"
+# 1.9.1+ uses Kotlin and requires Android Gradle Plugin 9+
+# checkForUpdates: androidx-annotation:1.9.0
+androidx-annotation = "androidx.annotation:annotation:1.9.0"
+# 1.15.0+ requires minSdkVersion 21 in android-interop-testing (1.14.x doesn't exist)
+# checkForUpdates: androidx-core:1.13.+
+androidx-core = "androidx.core:core:1.13.1"
+# 2.9+ requires minSdkVersion 21 in android-intetrop-testing
+# checkForUpdates: androidx-lifecycle-common:2.8.+
+androidx-lifecycle-common = "androidx.lifecycle:lifecycle-common:2.8.7"
+# checkForUpdates: androidx-lifecycle-service:2.8.+
+androidx-lifecycle-service = "androidx.lifecycle:lifecycle-service:2.8.7"
+androidx-test-core = "androidx.test:core:1.7.0"
+androidx-test-ext-junit = "androidx.test.ext:junit:1.3.0"
+# 1.7.0+ requires minSdkVersion 21 in android-interop-testing
+# checkForUpdates: androidx-test-rules:1.6.+
+androidx-test-rules = "androidx.test:rules:1.6.1"
+animalsniffer = "org.codehaus.mojo:animal-sniffer:1.26"
+animalsniffer-annotations = "org.codehaus.mojo:animal-sniffer-annotations:1.26"
+assertj-core = "org.assertj:assertj-core:3.27.6"
+# 1.11.1 started converting jsr305 @Nullable to jspecify
+# checkForUpdates: auto-value:1.11.0
+auto-value = "com.google.auto.value:auto-value:1.11.0"
+# checkForUpdates: auto-value-annotations:1.11.0
+auto-value-annotations = "com.google.auto.value:auto-value-annotations:1.11.0"
+# 11.0+ requires Java 17+
+# https://checkstyle.sourceforge.io/releasenotes.html
+# checkForUpdates: checkstyle:10.+
+checkstyle = "com.puppycrawl.tools:checkstyle:10.26.1"
+# checkstyle 10.0+ requires Java 11+
+# See https://checkstyle.sourceforge.io/releasenotes_old_8-35_10-26.html#Release_10.0
+# checkForUpdates: checkstylejava8:9.+
+checkstylejava8 = "com.puppycrawl.tools:checkstyle:9.3"
+commons-math3 = "org.apache.commons:commons-math3:3.6.1"
+conscrypt = "org.conscrypt:conscrypt-openjdk-uber:2.5.2"
+# 141.7340.3+ requires minSdkVersion 23
+# checkForUpdates: cronet-api:119.6045.31
+cronet-api = "org.chromium.net:cronet-api:119.6045.31"
+# checkForUpdates: cronet-embedded:119.6045.31
+cronet-embedded = "org.chromium.net:cronet-embedded:119.6045.31"
+errorprone-annotations = "com.google.errorprone:error_prone_annotations:2.45.0"
+# 2.32.0+ requires Java 17+
+# checkForUpdates: errorprone-core:2.31.+
+errorprone-core = "com.google.errorprone:error_prone_core:2.31.0"
+# 2.11.0+ requires JDK 11+ (See https://github.com/google/error-prone/releases/tag/v2.11.0)
+# checkForUpdates: errorprone-corejava8:2.10.+
+errorprone-corejava8 = "com.google.errorprone:error_prone_core:2.10.0"
+google-api-protos = "com.google.api.grpc:proto-google-common-protos:2.63.2"
+google-auth-credentials = "com.google.auth:google-auth-library-credentials:1.41.0"
+google-auth-oauth2Http = "com.google.auth:google-auth-library-oauth2-http:1.41.0"
+# Release notes: https://cloud.google.com/logging/docs/release-notes
+google-cloud-logging = "com.google.cloud:google-cloud-logging:3.23.9"
+# 2.13.0 requires error_prone_annotations:2.37.0, but we are stuck with 2.36.0
+# checkForUpdates: gson:2.12.+
+gson = "com.google.code.gson:gson:2.12.1"
+guava = "com.google.guava:guava:33.5.0-android"
+guava-betaChecker = "com.google.guava:guava-beta-checker:1.0"
+guava-testlib = "com.google.guava:guava-testlib:33.5.0-android"
+# JRE version is needed for projects where its a transitive dependency, f.e. gcp-observability.
+# May be different from the -android version.
+guava-jre = "com.google.guava:guava:33.5.0-jre"
+hdrhistogram = "org.hdrhistogram:HdrHistogram:2.2.2"
+# 6.0.0+ use java.lang.Deprecated forRemoval and since from Java 9
+# checkForUpdates: jakarta-servlet-api:5.+
+jakarta-servlet-api = "jakarta.servlet:jakarta.servlet-api:5.0.0"
+javax-servlet-api = "javax.servlet:javax.servlet-api:4.0.1"
+# 12.0.0+ require Java 17+
+# checkForUpdates: jetty-client:11.+
+jetty-client = "org.eclipse.jetty:jetty-client:11.0.26"
+jetty-http2-server = "org.eclipse.jetty.http2:jetty-http2-server:12.1.5"
+# 10.0.25+ uses uses @Deprecated(since=/forRemoval=) from Java 9
+# checkForUpdates: jetty-http2-server10:10.0.24
+jetty-http2-server10 = "org.eclipse.jetty.http2:http2-server:10.0.24"
+jetty-servlet = "org.eclipse.jetty.ee10:jetty-ee10-servlet:12.1.5"
+# checkForUpdates: jetty-servlet10:10.0.24
+jetty-servlet10 = "org.eclipse.jetty:jetty-servlet:10.0.24"
+jsr305 = "com.google.code.findbugs:jsr305:3.0.2"
+junit = "junit:junit:4.13.2"
+lincheck = "org.jetbrains.lincheck:lincheck:3.3.2"
+# Update notes / 2023-07-19 sergiitk:
+#    Couldn't update to 5.4.0, updated to the last in 4.x line. Version 5.x breaks some tests.
+#    Error log: https://github.com/grpc/grpc-java/pull/10359#issuecomment-1632834435
+# Update notes / 2023-10-09 temawi:
+#    4.5.0 Has been breaking the android integration tests as mockito now uses streams
+#    (not available in API levels < 24). https://github.com/grpc/grpc-java/issues/10457
+# checkForUpdates: mockito-android:4.4.+
+mockito-android = "org.mockito:mockito-android:4.4.0"
+# checkForUpdates: mockito-core:4.4.+
+mockito-core = "org.mockito:mockito-core:4.4.0"
+# Need to decide when we require users to absorb the breaking changes in 4.2
+# checkForUpdates: netty-codec-http2:4.1.+
+netty-codec-http2 = "io.netty:netty-codec-http2:4.1.130.Final"
+# checkForUpdates: netty-handler-proxy:4.1.+
+netty-handler-proxy = "io.netty:netty-handler-proxy:4.1.130.Final"
+# Keep the following references of tcnative version in sync whenever it's updated:
+#   SECURITY.md
+netty-tcnative = "io.netty:netty-tcnative-boringssl-static:2.0.74.Final"
+netty-tcnative-classes = "io.netty:netty-tcnative-classes:2.0.74.Final"
+# checkForUpdates: netty-transport-epoll:4.1.+
+netty-transport-epoll = "io.netty:netty-transport-native-epoll:4.1.130.Final"
+# checkForUpdates: netty-unix-common:4.1.+
+netty-unix-common = "io.netty:netty-transport-native-unix-common:4.1.130.Final"
+okhttp = "com.squareup.okhttp:okhttp:2.7.5"
+# okio 3.5+ uses Kotlin 1.9+ which requires Android Gradle Plugin 9+
+# checkForUpdates: okio:3.4.+
+okio = "com.squareup.okio:okio:3.4.0"
+opencensus-api = { module = "io.opencensus:opencensus-api", version.ref = "opencensus" }
+opencensus-contrib-grpc-metrics = { module = "io.opencensus:opencensus-contrib-grpc-metrics", version.ref = "opencensus" }
+opencensus-exporter-stats-stackdriver = { module = "io.opencensus:opencensus-exporter-stats-stackdriver", version.ref = "opencensus" }
+opencensus-exporter-trace-stackdriver = { module = "io.opencensus:opencensus-exporter-trace-stackdriver", version.ref = "opencensus" }
+opencensus-impl = { module = "io.opencensus:opencensus-impl", version.ref = "opencensus" }
+opentelemetry-api = "io.opentelemetry:opentelemetry-api:1.57.0"
+opentelemetry-exporter-prometheus = "io.opentelemetry:opentelemetry-exporter-prometheus:1.57.0-alpha"
+opentelemetry-gcp-resources = "io.opentelemetry.contrib:opentelemetry-gcp-resources:1.52.0-alpha"
+opentelemetry-sdk-extension-autoconfigure = "io.opentelemetry:opentelemetry-sdk-extension-autoconfigure:1.57.0"
+opentelemetry-sdk-testing = "io.opentelemetry:opentelemetry-sdk-testing:1.57.0"
+perfmark-api = "io.perfmark:perfmark-api:0.27.0"
+# Not upgrading to 4.x as it is not yet ABI compatible.
+# https://github.com/protocolbuffers/protobuf/issues/17247
+# checkForUpdates: protobuf-java:3.+
+protobuf-java = "com.google.protobuf:protobuf-java:3.25.8"
+# checkForUpdates: protobuf-java-util:3.+
+protobuf-java-util = "com.google.protobuf:protobuf-java-util:3.25.8"
+# checkForUpdates: protobuf-javalite:3.+
+protobuf-javalite = "com.google.protobuf:protobuf-javalite:3.25.8"
+# checkForUpdates: protobuf-protoc:3.+
+protobuf-protoc = "com.google.protobuf:protoc:3.25.8"
+re2j = "com.google.re2j:re2j:1.8"
+robolectric = "org.robolectric:robolectric:4.16"
+s2a-proto = "com.google.s2a.proto.v2:s2a-proto:0.1.3"
+signature-android = "net.sf.androidscents.signature:android-api-level-21:5.0.1_r2"
+signature-java = "org.codehaus.mojo.signature:java18:1.0"
+# 11.0.0+ require Java 17+
+# checkForUpdates: tomcat-embed-core:10.+
+tomcat-embed-core = "org.apache.tomcat.embed:tomcat-embed-core:10.1.50"
+# checkForUpdates: tomcat-embed-core9:9.+
+tomcat-embed-core9 = "org.apache.tomcat.embed:tomcat-embed-core:9.0.113"
+truth = "com.google.truth:truth:1.4.5"
+# checkForUpdates: undertow-servlet22:2.2.+
+undertow-servlet22 = "io.undertow:undertow-servlet:2.2.38.Final"
+undertow-servlet = "io.undertow:undertow-servlet:2.3.20.Final"
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index d6e2637affb..7f93135c49b 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 17b2993f7f0..d4081da476b 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,7 @@
-#Wed Nov 16 15:29:58 PST 2016
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-3.2-bin.zip
diff --git a/gradlew b/gradlew
index 4ef3a871f2e..0adc8e1a532 100755
--- a/gradlew
+++ b/gradlew
@@ -1,78 +1,127 @@
-#!/usr/bin/env sh
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original 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
+#
+#      https://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.
+#
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
-warn ( ) {
+warn () {
     echo "$*"
-}
+} >&2
 
-die ( ) {
+die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -81,91 +130,120 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
 fi
 
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
 
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
     # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
         fi
-        i=$((i+1))
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
     done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
 fi
 
-# Escape application args
-for s in "${@}" ; do
-    s=\"$s\"
-    APP_ARGS=$APP_ARGS" "$s
-done
-
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- "$DEFAULT_JVM_OPTS" "$JAVA_OPTS" "$GRADLE_OPTS" "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
 
-# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
-if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
-  cd "$(dirname "$0")"
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
 fi
 
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
 exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
index e95643d6a2c..6689b85beec 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -1,4 +1,20 @@
-@if "%DEBUG%" == "" @echo off
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -9,19 +25,23 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -35,7 +55,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -45,38 +65,26 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal
diff --git a/grpclb/BUILD.bazel b/grpclb/BUILD.bazel
new file mode 100644
index 00000000000..ca9975b7ce6
--- /dev/null
+++ b/grpclb/BUILD.bazel
@@ -0,0 +1,33 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+load("//:java_grpc_library.bzl", "java_grpc_library")
+
+java_library(
+    name = "grpclb",
+    srcs = glob([
+        "src/main/java/io/grpc/grpclb/*.java",
+    ]),
+    resources = glob([
+        "src/main/resources/**",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        ":load_balancer_java_grpc",
+        "//api",
+        "//context",
+        "//core:internal",
+        "//stub",
+        "//util",
+        "@com_google_protobuf//:protobuf_java_util",
+        "@io_grpc_grpc_proto//:grpclb_load_balancer_java_proto",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+    ],
+)
+
+java_grpc_library(
+    name = "load_balancer_java_grpc",
+    srcs = ["@io_grpc_grpc_proto//:grpclb_load_balancer_proto"],
+    deps = ["@io_grpc_grpc_proto//:grpclb_load_balancer_java_proto"],
+)
diff --git a/grpclb/build.gradle b/grpclb/build.gradle
index e82e1fee805..e8896604f03 100644
--- a/grpclb/build.gradle
+++ b/grpclb/build.gradle
@@ -1,26 +1,52 @@
+plugins {
+    id "java"
+    id "maven-publish"
+
+    id "com.google.protobuf"
+    id "me.champeau.gradle.japicmp"
+    id "ru.vyarus.animalsniffer"
+}
+
 description = "gRPC: GRPCLB LoadBalancer plugin"
 
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-    dependencies {
-        classpath libraries.protobuf_plugin
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.grpclb')
     }
 }
 
 dependencies {
-    compile project(':grpc-core'),
+    implementation project(':grpc-core'),
             project(':grpc-protobuf'),
             project(':grpc-stub'),
-            libraries.protobuf
+            project(':grpc-util'),
+            libraries.guava,
+            libraries.protobuf.java,
+            libraries.protobuf.java.util
+    runtimeOnly libraries.errorprone.annotations
+    testImplementation libraries.truth,
+            project(':grpc-inprocess'),
+            testFixtures(project(':grpc-core'))
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
 configureProtoCompilation()
 
-idea {
-    module {
-        sourceDirs += file("${projectDir}/src/generated/main/grpc");
-        sourceDirs += file("${projectDir}/src/generated/main/java");
+tasks.named("javadoc").configure {
+    exclude 'io/grpc/grpclb/Internal*'
+    exclude 'io/grpc/grpclb/*Provider.java'
+}
+
+tasks.named("jacocoTestReport").configure {
+    classDirectories.from = sourceSets.main.output.collect {
+        fileTree(dir: it,
+        exclude: [
+                '**/io/grpc/lb/v1/**',
+        ])
     }
 }
diff --git a/grpclb/src/generated/main/grpc/io/grpc/grpclb/LoadBalancerGrpc.java b/grpclb/src/generated/main/grpc/io/grpc/grpclb/LoadBalancerGrpc.java
deleted file mode 100644
index 03c26054201..00000000000
--- a/grpclb/src/generated/main/grpc/io/grpc/grpclb/LoadBalancerGrpc.java
+++ /dev/null
@@ -1,220 +0,0 @@
-package io.grpc.grpclb;
-
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
-
-/**
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: load_balancer.proto")
-public final class LoadBalancerGrpc {
-
-  private LoadBalancerGrpc() {}
-
-  public static final String SERVICE_NAME = "grpc.lb.v1.LoadBalancer";
-
-  // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.grpclb.LoadBalanceRequest,
-      io.grpc.grpclb.LoadBalanceResponse> METHOD_BALANCE_LOAD =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
-          generateFullMethodName(
-              "grpc.lb.v1.LoadBalancer", "BalanceLoad"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.grpclb.LoadBalanceRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.grpclb.LoadBalanceResponse.getDefaultInstance()));
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static LoadBalancerStub newStub(io.grpc.Channel channel) {
-    return new LoadBalancerStub(channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static LoadBalancerBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    return new LoadBalancerBlockingStub(channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
-   */
-  public static LoadBalancerFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    return new LoadBalancerFutureStub(channel);
-  }
-
-  /**
-   */
-  public static abstract class LoadBalancerImplBase implements io.grpc.BindableService {
-
-    /**
-     * <pre>
-     * Bidirectional rpc to get a list of servers.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.grpclb.LoadBalanceRequest> balanceLoad(
-        io.grpc.stub.StreamObserver<io.grpc.grpclb.LoadBalanceResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_BALANCE_LOAD, responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_BALANCE_LOAD,
-            asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.grpclb.LoadBalanceRequest,
-                io.grpc.grpclb.LoadBalanceResponse>(
-                  this, METHODID_BALANCE_LOAD)))
-          .build();
-    }
-  }
-
-  /**
-   */
-  public static final class LoadBalancerStub extends io.grpc.stub.AbstractStub<LoadBalancerStub> {
-    private LoadBalancerStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private LoadBalancerStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected LoadBalancerStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new LoadBalancerStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * Bidirectional rpc to get a list of servers.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.grpclb.LoadBalanceRequest> balanceLoad(
-        io.grpc.stub.StreamObserver<io.grpc.grpclb.LoadBalanceResponse> responseObserver) {
-      return asyncBidiStreamingCall(
-          getChannel().newCall(METHOD_BALANCE_LOAD, getCallOptions()), responseObserver);
-    }
-  }
-
-  /**
-   */
-  public static final class LoadBalancerBlockingStub extends io.grpc.stub.AbstractStub<LoadBalancerBlockingStub> {
-    private LoadBalancerBlockingStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private LoadBalancerBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected LoadBalancerBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new LoadBalancerBlockingStub(channel, callOptions);
-    }
-  }
-
-  /**
-   */
-  public static final class LoadBalancerFutureStub extends io.grpc.stub.AbstractStub<LoadBalancerFutureStub> {
-    private LoadBalancerFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private LoadBalancerFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected LoadBalancerFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new LoadBalancerFutureStub(channel, callOptions);
-    }
-  }
-
-  private static final int METHODID_BALANCE_LOAD = 0;
-
-  private static final class MethodHandlers<Req, Resp> implements
-      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final LoadBalancerImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(LoadBalancerImplBase serviceImpl, int methodId) {
-      this.serviceImpl = serviceImpl;
-      this.methodId = methodId;
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        default:
-          throw new AssertionError();
-      }
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public io.grpc.stub.StreamObserver<Req> invoke(
-        io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        case METHODID_BALANCE_LOAD:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.balanceLoad(
-              (io.grpc.stub.StreamObserver<io.grpc.grpclb.LoadBalanceResponse>) responseObserver);
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  private static final class LoadBalancerDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return io.grpc.grpclb.LoadBalancerProto.getDescriptor();
-    }
-  }
-
-  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
-
-  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
-    io.grpc.ServiceDescriptor result = serviceDescriptor;
-    if (result == null) {
-      synchronized (LoadBalancerGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new LoadBalancerDescriptorSupplier())
-              .addMethod(METHOD_BALANCE_LOAD)
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/grpclb/src/generated/main/grpc/io/grpc/lb/v1/LoadBalancerGrpc.java b/grpclb/src/generated/main/grpc/io/grpc/lb/v1/LoadBalancerGrpc.java
new file mode 100644
index 00000000000..b730eff7b37
--- /dev/null
+++ b/grpclb/src/generated/main/grpc/io/grpc/lb/v1/LoadBalancerGrpc.java
@@ -0,0 +1,324 @@
+package io.grpc.lb.v1;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class LoadBalancerGrpc {
+
+  private LoadBalancerGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.lb.v1.LoadBalancer";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.lb.v1.LoadBalanceRequest,
+      io.grpc.lb.v1.LoadBalanceResponse> getBalanceLoadMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "BalanceLoad",
+      requestType = io.grpc.lb.v1.LoadBalanceRequest.class,
+      responseType = io.grpc.lb.v1.LoadBalanceResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.lb.v1.LoadBalanceRequest,
+      io.grpc.lb.v1.LoadBalanceResponse> getBalanceLoadMethod() {
+    io.grpc.MethodDescriptor<io.grpc.lb.v1.LoadBalanceRequest, io.grpc.lb.v1.LoadBalanceResponse> getBalanceLoadMethod;
+    if ((getBalanceLoadMethod = LoadBalancerGrpc.getBalanceLoadMethod) == null) {
+      synchronized (LoadBalancerGrpc.class) {
+        if ((getBalanceLoadMethod = LoadBalancerGrpc.getBalanceLoadMethod) == null) {
+          LoadBalancerGrpc.getBalanceLoadMethod = getBalanceLoadMethod =
+              io.grpc.MethodDescriptor.<io.grpc.lb.v1.LoadBalanceRequest, io.grpc.lb.v1.LoadBalanceResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "BalanceLoad"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.lb.v1.LoadBalanceRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.lb.v1.LoadBalanceResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new LoadBalancerMethodDescriptorSupplier("BalanceLoad"))
+              .build();
+        }
+      }
+    }
+    return getBalanceLoadMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static LoadBalancerStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStub>() {
+        @java.lang.Override
+        public LoadBalancerStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerStub(channel, callOptions);
+        }
+      };
+    return LoadBalancerStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static LoadBalancerBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerBlockingV2Stub>() {
+        @java.lang.Override
+        public LoadBalancerBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return LoadBalancerBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static LoadBalancerBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerBlockingStub>() {
+        @java.lang.Override
+        public LoadBalancerBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerBlockingStub(channel, callOptions);
+        }
+      };
+    return LoadBalancerBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static LoadBalancerFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerFutureStub>() {
+        @java.lang.Override
+        public LoadBalancerFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerFutureStub(channel, callOptions);
+        }
+      };
+    return LoadBalancerFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Bidirectional rpc to get a list of servers.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.lb.v1.LoadBalanceRequest> balanceLoad(
+        io.grpc.stub.StreamObserver<io.grpc.lb.v1.LoadBalanceResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getBalanceLoadMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service LoadBalancer.
+   */
+  public static abstract class LoadBalancerImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return LoadBalancerGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service LoadBalancer.
+   */
+  public static final class LoadBalancerStub
+      extends io.grpc.stub.AbstractAsyncStub<LoadBalancerStub> {
+    private LoadBalancerStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Bidirectional rpc to get a list of servers.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.lb.v1.LoadBalanceRequest> balanceLoad(
+        io.grpc.stub.StreamObserver<io.grpc.lb.v1.LoadBalanceResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getBalanceLoadMethod(), getCallOptions()), responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service LoadBalancer.
+   */
+  public static final class LoadBalancerBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<LoadBalancerBlockingV2Stub> {
+    private LoadBalancerBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Bidirectional rpc to get a list of servers.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.lb.v1.LoadBalanceRequest, io.grpc.lb.v1.LoadBalanceResponse>
+        balanceLoad() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getBalanceLoadMethod(), getCallOptions());
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service LoadBalancer.
+   */
+  public static final class LoadBalancerBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<LoadBalancerBlockingStub> {
+    private LoadBalancerBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerBlockingStub(channel, callOptions);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service LoadBalancer.
+   */
+  public static final class LoadBalancerFutureStub
+      extends io.grpc.stub.AbstractFutureStub<LoadBalancerFutureStub> {
+    private LoadBalancerFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerFutureStub(channel, callOptions);
+    }
+  }
+
+  private static final int METHODID_BALANCE_LOAD = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_BALANCE_LOAD:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.balanceLoad(
+              (io.grpc.stub.StreamObserver<io.grpc.lb.v1.LoadBalanceResponse>) responseObserver);
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getBalanceLoadMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.lb.v1.LoadBalanceRequest,
+              io.grpc.lb.v1.LoadBalanceResponse>(
+                service, METHODID_BALANCE_LOAD)))
+        .build();
+  }
+
+  private static abstract class LoadBalancerBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    LoadBalancerBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.lb.v1.LoadBalancerProto.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("LoadBalancer");
+    }
+  }
+
+  private static final class LoadBalancerFileDescriptorSupplier
+      extends LoadBalancerBaseDescriptorSupplier {
+    LoadBalancerFileDescriptorSupplier() {}
+  }
+
+  private static final class LoadBalancerMethodDescriptorSupplier
+      extends LoadBalancerBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    LoadBalancerMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (LoadBalancerGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new LoadBalancerFileDescriptorSupplier())
+              .addMethod(getBalanceLoadMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/ClientStats.java b/grpclb/src/generated/main/java/io/grpc/grpclb/ClientStats.java
deleted file mode 100644
index 53c0acfb68c..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/ClientStats.java
+++ /dev/null
@@ -1,602 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-/**
- * <pre>
- * Contains client level statistics that are useful to load balancing. Each
- * count should be reset to zero after reporting the stats.
- * </pre>
- *
- * Protobuf type {@code grpc.lb.v1.ClientStats}
- */
-public  final class ClientStats extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.lb.v1.ClientStats)
-    ClientStatsOrBuilder {
-  // Use ClientStats.newBuilder() to construct.
-  private ClientStats(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private ClientStats() {
-    totalRequests_ = 0L;
-    clientRpcErrors_ = 0L;
-    droppedRequests_ = 0L;
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private ClientStats(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 8: {
-
-            totalRequests_ = input.readInt64();
-            break;
-          }
-          case 16: {
-
-            clientRpcErrors_ = input.readInt64();
-            break;
-          }
-          case 24: {
-
-            droppedRequests_ = input.readInt64();
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_ClientStats_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_ClientStats_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.grpclb.ClientStats.class, io.grpc.grpclb.ClientStats.Builder.class);
-  }
-
-  public static final int TOTAL_REQUESTS_FIELD_NUMBER = 1;
-  private long totalRequests_;
-  /**
-   * <pre>
-   * The total number of requests sent by the client since the last report.
-   * </pre>
-   *
-   * <code>int64 total_requests = 1;</code>
-   */
-  public long getTotalRequests() {
-    return totalRequests_;
-  }
-
-  public static final int CLIENT_RPC_ERRORS_FIELD_NUMBER = 2;
-  private long clientRpcErrors_;
-  /**
-   * <pre>
-   * The number of client rpc errors since the last report.
-   * </pre>
-   *
-   * <code>int64 client_rpc_errors = 2;</code>
-   */
-  public long getClientRpcErrors() {
-    return clientRpcErrors_;
-  }
-
-  public static final int DROPPED_REQUESTS_FIELD_NUMBER = 3;
-  private long droppedRequests_;
-  /**
-   * <pre>
-   * The number of dropped requests since the last report.
-   * </pre>
-   *
-   * <code>int64 dropped_requests = 3;</code>
-   */
-  public long getDroppedRequests() {
-    return droppedRequests_;
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (totalRequests_ != 0L) {
-      output.writeInt64(1, totalRequests_);
-    }
-    if (clientRpcErrors_ != 0L) {
-      output.writeInt64(2, clientRpcErrors_);
-    }
-    if (droppedRequests_ != 0L) {
-      output.writeInt64(3, droppedRequests_);
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (totalRequests_ != 0L) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeInt64Size(1, totalRequests_);
-    }
-    if (clientRpcErrors_ != 0L) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeInt64Size(2, clientRpcErrors_);
-    }
-    if (droppedRequests_ != 0L) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeInt64Size(3, droppedRequests_);
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.grpclb.ClientStats)) {
-      return super.equals(obj);
-    }
-    io.grpc.grpclb.ClientStats other = (io.grpc.grpclb.ClientStats) obj;
-
-    boolean result = true;
-    result = result && (getTotalRequests()
-        == other.getTotalRequests());
-    result = result && (getClientRpcErrors()
-        == other.getClientRpcErrors());
-    result = result && (getDroppedRequests()
-        == other.getDroppedRequests());
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (37 * hash) + TOTAL_REQUESTS_FIELD_NUMBER;
-    hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-        getTotalRequests());
-    hash = (37 * hash) + CLIENT_RPC_ERRORS_FIELD_NUMBER;
-    hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-        getClientRpcErrors());
-    hash = (37 * hash) + DROPPED_REQUESTS_FIELD_NUMBER;
-    hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-        getDroppedRequests());
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.grpclb.ClientStats parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.ClientStats parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.ClientStats parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.ClientStats parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.ClientStats parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.ClientStats parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.ClientStats parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.ClientStats parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.ClientStats parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.ClientStats parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.grpclb.ClientStats prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * <pre>
-   * Contains client level statistics that are useful to load balancing. Each
-   * count should be reset to zero after reporting the stats.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.lb.v1.ClientStats}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.lb.v1.ClientStats)
-      io.grpc.grpclb.ClientStatsOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_ClientStats_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_ClientStats_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.grpclb.ClientStats.class, io.grpc.grpclb.ClientStats.Builder.class);
-    }
-
-    // Construct using io.grpc.grpclb.ClientStats.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      totalRequests_ = 0L;
-
-      clientRpcErrors_ = 0L;
-
-      droppedRequests_ = 0L;
-
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_ClientStats_descriptor;
-    }
-
-    public io.grpc.grpclb.ClientStats getDefaultInstanceForType() {
-      return io.grpc.grpclb.ClientStats.getDefaultInstance();
-    }
-
-    public io.grpc.grpclb.ClientStats build() {
-      io.grpc.grpclb.ClientStats result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.grpclb.ClientStats buildPartial() {
-      io.grpc.grpclb.ClientStats result = new io.grpc.grpclb.ClientStats(this);
-      result.totalRequests_ = totalRequests_;
-      result.clientRpcErrors_ = clientRpcErrors_;
-      result.droppedRequests_ = droppedRequests_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.grpclb.ClientStats) {
-        return mergeFrom((io.grpc.grpclb.ClientStats)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.grpclb.ClientStats other) {
-      if (other == io.grpc.grpclb.ClientStats.getDefaultInstance()) return this;
-      if (other.getTotalRequests() != 0L) {
-        setTotalRequests(other.getTotalRequests());
-      }
-      if (other.getClientRpcErrors() != 0L) {
-        setClientRpcErrors(other.getClientRpcErrors());
-      }
-      if (other.getDroppedRequests() != 0L) {
-        setDroppedRequests(other.getDroppedRequests());
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.grpclb.ClientStats parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.grpclb.ClientStats) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-
-    private long totalRequests_ ;
-    /**
-     * <pre>
-     * The total number of requests sent by the client since the last report.
-     * </pre>
-     *
-     * <code>int64 total_requests = 1;</code>
-     */
-    public long getTotalRequests() {
-      return totalRequests_;
-    }
-    /**
-     * <pre>
-     * The total number of requests sent by the client since the last report.
-     * </pre>
-     *
-     * <code>int64 total_requests = 1;</code>
-     */
-    public Builder setTotalRequests(long value) {
-      
-      totalRequests_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * The total number of requests sent by the client since the last report.
-     * </pre>
-     *
-     * <code>int64 total_requests = 1;</code>
-     */
-    public Builder clearTotalRequests() {
-      
-      totalRequests_ = 0L;
-      onChanged();
-      return this;
-    }
-
-    private long clientRpcErrors_ ;
-    /**
-     * <pre>
-     * The number of client rpc errors since the last report.
-     * </pre>
-     *
-     * <code>int64 client_rpc_errors = 2;</code>
-     */
-    public long getClientRpcErrors() {
-      return clientRpcErrors_;
-    }
-    /**
-     * <pre>
-     * The number of client rpc errors since the last report.
-     * </pre>
-     *
-     * <code>int64 client_rpc_errors = 2;</code>
-     */
-    public Builder setClientRpcErrors(long value) {
-      
-      clientRpcErrors_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * The number of client rpc errors since the last report.
-     * </pre>
-     *
-     * <code>int64 client_rpc_errors = 2;</code>
-     */
-    public Builder clearClientRpcErrors() {
-      
-      clientRpcErrors_ = 0L;
-      onChanged();
-      return this;
-    }
-
-    private long droppedRequests_ ;
-    /**
-     * <pre>
-     * The number of dropped requests since the last report.
-     * </pre>
-     *
-     * <code>int64 dropped_requests = 3;</code>
-     */
-    public long getDroppedRequests() {
-      return droppedRequests_;
-    }
-    /**
-     * <pre>
-     * The number of dropped requests since the last report.
-     * </pre>
-     *
-     * <code>int64 dropped_requests = 3;</code>
-     */
-    public Builder setDroppedRequests(long value) {
-      
-      droppedRequests_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * The number of dropped requests since the last report.
-     * </pre>
-     *
-     * <code>int64 dropped_requests = 3;</code>
-     */
-    public Builder clearDroppedRequests() {
-      
-      droppedRequests_ = 0L;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.lb.v1.ClientStats)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.lb.v1.ClientStats)
-  private static final io.grpc.grpclb.ClientStats DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.grpclb.ClientStats();
-  }
-
-  public static io.grpc.grpclb.ClientStats getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<ClientStats>
-      PARSER = new com.google.protobuf.AbstractParser<ClientStats>() {
-    public ClientStats parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new ClientStats(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<ClientStats> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<ClientStats> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.grpclb.ClientStats getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/ClientStatsOrBuilder.java b/grpclb/src/generated/main/java/io/grpc/grpclb/ClientStatsOrBuilder.java
deleted file mode 100644
index a730718dbac..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/ClientStatsOrBuilder.java
+++ /dev/null
@@ -1,36 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-public interface ClientStatsOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.lb.v1.ClientStats)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <pre>
-   * The total number of requests sent by the client since the last report.
-   * </pre>
-   *
-   * <code>int64 total_requests = 1;</code>
-   */
-  long getTotalRequests();
-
-  /**
-   * <pre>
-   * The number of client rpc errors since the last report.
-   * </pre>
-   *
-   * <code>int64 client_rpc_errors = 2;</code>
-   */
-  long getClientRpcErrors();
-
-  /**
-   * <pre>
-   * The number of dropped requests since the last report.
-   * </pre>
-   *
-   * <code>int64 dropped_requests = 3;</code>
-   */
-  long getDroppedRequests();
-}
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/InitialLoadBalanceRequest.java b/grpclb/src/generated/main/java/io/grpc/grpclb/InitialLoadBalanceRequest.java
deleted file mode 100644
index f7fce04b8f9..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/InitialLoadBalanceRequest.java
+++ /dev/null
@@ -1,522 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-/**
- * Protobuf type {@code grpc.lb.v1.InitialLoadBalanceRequest}
- */
-public  final class InitialLoadBalanceRequest extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.lb.v1.InitialLoadBalanceRequest)
-    InitialLoadBalanceRequestOrBuilder {
-  // Use InitialLoadBalanceRequest.newBuilder() to construct.
-  private InitialLoadBalanceRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private InitialLoadBalanceRequest() {
-    name_ = "";
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private InitialLoadBalanceRequest(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            java.lang.String s = input.readStringRequireUtf8();
-
-            name_ = s;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_InitialLoadBalanceRequest_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_InitialLoadBalanceRequest_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.grpclb.InitialLoadBalanceRequest.class, io.grpc.grpclb.InitialLoadBalanceRequest.Builder.class);
-  }
-
-  public static final int NAME_FIELD_NUMBER = 1;
-  private volatile java.lang.Object name_;
-  /**
-   * <pre>
-   * Name of load balanced service
-   * </pre>
-   *
-   * <code>string name = 1;</code>
-   */
-  public java.lang.String getName() {
-    java.lang.Object ref = name_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      name_ = s;
-      return s;
-    }
-  }
-  /**
-   * <pre>
-   * Name of load balanced service
-   * </pre>
-   *
-   * <code>string name = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getNameBytes() {
-    java.lang.Object ref = name_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      name_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (!getNameBytes().isEmpty()) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_);
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (!getNameBytes().isEmpty()) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_);
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.grpclb.InitialLoadBalanceRequest)) {
-      return super.equals(obj);
-    }
-    io.grpc.grpclb.InitialLoadBalanceRequest other = (io.grpc.grpclb.InitialLoadBalanceRequest) obj;
-
-    boolean result = true;
-    result = result && getName()
-        .equals(other.getName());
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (37 * hash) + NAME_FIELD_NUMBER;
-    hash = (53 * hash) + getName().hashCode();
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.grpclb.InitialLoadBalanceRequest parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceRequest parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceRequest parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceRequest parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceRequest parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceRequest parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceRequest parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceRequest parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceRequest parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceRequest parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.grpclb.InitialLoadBalanceRequest prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.lb.v1.InitialLoadBalanceRequest}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.lb.v1.InitialLoadBalanceRequest)
-      io.grpc.grpclb.InitialLoadBalanceRequestOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_InitialLoadBalanceRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_InitialLoadBalanceRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.grpclb.InitialLoadBalanceRequest.class, io.grpc.grpclb.InitialLoadBalanceRequest.Builder.class);
-    }
-
-    // Construct using io.grpc.grpclb.InitialLoadBalanceRequest.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      name_ = "";
-
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_InitialLoadBalanceRequest_descriptor;
-    }
-
-    public io.grpc.grpclb.InitialLoadBalanceRequest getDefaultInstanceForType() {
-      return io.grpc.grpclb.InitialLoadBalanceRequest.getDefaultInstance();
-    }
-
-    public io.grpc.grpclb.InitialLoadBalanceRequest build() {
-      io.grpc.grpclb.InitialLoadBalanceRequest result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.grpclb.InitialLoadBalanceRequest buildPartial() {
-      io.grpc.grpclb.InitialLoadBalanceRequest result = new io.grpc.grpclb.InitialLoadBalanceRequest(this);
-      result.name_ = name_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.grpclb.InitialLoadBalanceRequest) {
-        return mergeFrom((io.grpc.grpclb.InitialLoadBalanceRequest)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.grpclb.InitialLoadBalanceRequest other) {
-      if (other == io.grpc.grpclb.InitialLoadBalanceRequest.getDefaultInstance()) return this;
-      if (!other.getName().isEmpty()) {
-        name_ = other.name_;
-        onChanged();
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.grpclb.InitialLoadBalanceRequest parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.grpclb.InitialLoadBalanceRequest) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-
-    private java.lang.Object name_ = "";
-    /**
-     * <pre>
-     * Name of load balanced service
-     * </pre>
-     *
-     * <code>string name = 1;</code>
-     */
-    public java.lang.String getName() {
-      java.lang.Object ref = name_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        name_ = s;
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Name of load balanced service
-     * </pre>
-     *
-     * <code>string name = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getNameBytes() {
-      java.lang.Object ref = name_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        name_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Name of load balanced service
-     * </pre>
-     *
-     * <code>string name = 1;</code>
-     */
-    public Builder setName(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  
-      name_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Name of load balanced service
-     * </pre>
-     *
-     * <code>string name = 1;</code>
-     */
-    public Builder clearName() {
-      
-      name_ = getDefaultInstance().getName();
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Name of load balanced service
-     * </pre>
-     *
-     * <code>string name = 1;</code>
-     */
-    public Builder setNameBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      
-      name_ = value;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.lb.v1.InitialLoadBalanceRequest)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.lb.v1.InitialLoadBalanceRequest)
-  private static final io.grpc.grpclb.InitialLoadBalanceRequest DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.grpclb.InitialLoadBalanceRequest();
-  }
-
-  public static io.grpc.grpclb.InitialLoadBalanceRequest getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<InitialLoadBalanceRequest>
-      PARSER = new com.google.protobuf.AbstractParser<InitialLoadBalanceRequest>() {
-    public InitialLoadBalanceRequest parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new InitialLoadBalanceRequest(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<InitialLoadBalanceRequest> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<InitialLoadBalanceRequest> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.grpclb.InitialLoadBalanceRequest getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/InitialLoadBalanceRequestOrBuilder.java b/grpclb/src/generated/main/java/io/grpc/grpclb/InitialLoadBalanceRequestOrBuilder.java
deleted file mode 100644
index ee63dbdd2df..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/InitialLoadBalanceRequestOrBuilder.java
+++ /dev/null
@@ -1,27 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-public interface InitialLoadBalanceRequestOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.lb.v1.InitialLoadBalanceRequest)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <pre>
-   * Name of load balanced service
-   * </pre>
-   *
-   * <code>string name = 1;</code>
-   */
-  java.lang.String getName();
-  /**
-   * <pre>
-   * Name of load balanced service
-   * </pre>
-   *
-   * <code>string name = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getNameBytes();
-}
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/InitialLoadBalanceResponse.java b/grpclb/src/generated/main/java/io/grpc/grpclb/InitialLoadBalanceResponse.java
deleted file mode 100644
index 62fbd4362c9..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/InitialLoadBalanceResponse.java
+++ /dev/null
@@ -1,796 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-/**
- * Protobuf type {@code grpc.lb.v1.InitialLoadBalanceResponse}
- */
-public  final class InitialLoadBalanceResponse extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.lb.v1.InitialLoadBalanceResponse)
-    InitialLoadBalanceResponseOrBuilder {
-  // Use InitialLoadBalanceResponse.newBuilder() to construct.
-  private InitialLoadBalanceResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private InitialLoadBalanceResponse() {
-    loadBalancerDelegate_ = "";
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private InitialLoadBalanceResponse(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            java.lang.String s = input.readStringRequireUtf8();
-
-            loadBalancerDelegate_ = s;
-            break;
-          }
-          case 18: {
-            com.google.protobuf.Duration.Builder subBuilder = null;
-            if (clientStatsReportInterval_ != null) {
-              subBuilder = clientStatsReportInterval_.toBuilder();
-            }
-            clientStatsReportInterval_ = input.readMessage(com.google.protobuf.Duration.parser(), extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom(clientStatsReportInterval_);
-              clientStatsReportInterval_ = subBuilder.buildPartial();
-            }
-
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_InitialLoadBalanceResponse_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_InitialLoadBalanceResponse_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.grpclb.InitialLoadBalanceResponse.class, io.grpc.grpclb.InitialLoadBalanceResponse.Builder.class);
-  }
-
-  public static final int LOAD_BALANCER_DELEGATE_FIELD_NUMBER = 1;
-  private volatile java.lang.Object loadBalancerDelegate_;
-  /**
-   * <pre>
-   * This is an application layer redirect that indicates the client should use
-   * the specified server for load balancing. When this field is non-empty in
-   * the response, the client should open a separate connection to the
-   * load_balancer_delegate and call the BalanceLoad method.
-   * </pre>
-   *
-   * <code>string load_balancer_delegate = 1;</code>
-   */
-  public java.lang.String getLoadBalancerDelegate() {
-    java.lang.Object ref = loadBalancerDelegate_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      loadBalancerDelegate_ = s;
-      return s;
-    }
-  }
-  /**
-   * <pre>
-   * This is an application layer redirect that indicates the client should use
-   * the specified server for load balancing. When this field is non-empty in
-   * the response, the client should open a separate connection to the
-   * load_balancer_delegate and call the BalanceLoad method.
-   * </pre>
-   *
-   * <code>string load_balancer_delegate = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getLoadBalancerDelegateBytes() {
-    java.lang.Object ref = loadBalancerDelegate_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      loadBalancerDelegate_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  public static final int CLIENT_STATS_REPORT_INTERVAL_FIELD_NUMBER = 2;
-  private com.google.protobuf.Duration clientStatsReportInterval_;
-  /**
-   * <pre>
-   * This interval defines how often the client should send the client stats
-   * to the load balancer. Stats should only be reported when the duration is
-   * positive.
-   * </pre>
-   *
-   * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-   */
-  public boolean hasClientStatsReportInterval() {
-    return clientStatsReportInterval_ != null;
-  }
-  /**
-   * <pre>
-   * This interval defines how often the client should send the client stats
-   * to the load balancer. Stats should only be reported when the duration is
-   * positive.
-   * </pre>
-   *
-   * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-   */
-  public com.google.protobuf.Duration getClientStatsReportInterval() {
-    return clientStatsReportInterval_ == null ? com.google.protobuf.Duration.getDefaultInstance() : clientStatsReportInterval_;
-  }
-  /**
-   * <pre>
-   * This interval defines how often the client should send the client stats
-   * to the load balancer. Stats should only be reported when the duration is
-   * positive.
-   * </pre>
-   *
-   * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-   */
-  public com.google.protobuf.DurationOrBuilder getClientStatsReportIntervalOrBuilder() {
-    return getClientStatsReportInterval();
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (!getLoadBalancerDelegateBytes().isEmpty()) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, loadBalancerDelegate_);
-    }
-    if (clientStatsReportInterval_ != null) {
-      output.writeMessage(2, getClientStatsReportInterval());
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (!getLoadBalancerDelegateBytes().isEmpty()) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, loadBalancerDelegate_);
-    }
-    if (clientStatsReportInterval_ != null) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(2, getClientStatsReportInterval());
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.grpclb.InitialLoadBalanceResponse)) {
-      return super.equals(obj);
-    }
-    io.grpc.grpclb.InitialLoadBalanceResponse other = (io.grpc.grpclb.InitialLoadBalanceResponse) obj;
-
-    boolean result = true;
-    result = result && getLoadBalancerDelegate()
-        .equals(other.getLoadBalancerDelegate());
-    result = result && (hasClientStatsReportInterval() == other.hasClientStatsReportInterval());
-    if (hasClientStatsReportInterval()) {
-      result = result && getClientStatsReportInterval()
-          .equals(other.getClientStatsReportInterval());
-    }
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (37 * hash) + LOAD_BALANCER_DELEGATE_FIELD_NUMBER;
-    hash = (53 * hash) + getLoadBalancerDelegate().hashCode();
-    if (hasClientStatsReportInterval()) {
-      hash = (37 * hash) + CLIENT_STATS_REPORT_INTERVAL_FIELD_NUMBER;
-      hash = (53 * hash) + getClientStatsReportInterval().hashCode();
-    }
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.grpclb.InitialLoadBalanceResponse parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceResponse parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceResponse parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceResponse parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceResponse parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceResponse parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceResponse parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceResponse parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceResponse parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.InitialLoadBalanceResponse parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.grpclb.InitialLoadBalanceResponse prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.lb.v1.InitialLoadBalanceResponse}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.lb.v1.InitialLoadBalanceResponse)
-      io.grpc.grpclb.InitialLoadBalanceResponseOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_InitialLoadBalanceResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_InitialLoadBalanceResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.grpclb.InitialLoadBalanceResponse.class, io.grpc.grpclb.InitialLoadBalanceResponse.Builder.class);
-    }
-
-    // Construct using io.grpc.grpclb.InitialLoadBalanceResponse.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      loadBalancerDelegate_ = "";
-
-      if (clientStatsReportIntervalBuilder_ == null) {
-        clientStatsReportInterval_ = null;
-      } else {
-        clientStatsReportInterval_ = null;
-        clientStatsReportIntervalBuilder_ = null;
-      }
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_InitialLoadBalanceResponse_descriptor;
-    }
-
-    public io.grpc.grpclb.InitialLoadBalanceResponse getDefaultInstanceForType() {
-      return io.grpc.grpclb.InitialLoadBalanceResponse.getDefaultInstance();
-    }
-
-    public io.grpc.grpclb.InitialLoadBalanceResponse build() {
-      io.grpc.grpclb.InitialLoadBalanceResponse result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.grpclb.InitialLoadBalanceResponse buildPartial() {
-      io.grpc.grpclb.InitialLoadBalanceResponse result = new io.grpc.grpclb.InitialLoadBalanceResponse(this);
-      result.loadBalancerDelegate_ = loadBalancerDelegate_;
-      if (clientStatsReportIntervalBuilder_ == null) {
-        result.clientStatsReportInterval_ = clientStatsReportInterval_;
-      } else {
-        result.clientStatsReportInterval_ = clientStatsReportIntervalBuilder_.build();
-      }
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.grpclb.InitialLoadBalanceResponse) {
-        return mergeFrom((io.grpc.grpclb.InitialLoadBalanceResponse)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.grpclb.InitialLoadBalanceResponse other) {
-      if (other == io.grpc.grpclb.InitialLoadBalanceResponse.getDefaultInstance()) return this;
-      if (!other.getLoadBalancerDelegate().isEmpty()) {
-        loadBalancerDelegate_ = other.loadBalancerDelegate_;
-        onChanged();
-      }
-      if (other.hasClientStatsReportInterval()) {
-        mergeClientStatsReportInterval(other.getClientStatsReportInterval());
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.grpclb.InitialLoadBalanceResponse parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.grpclb.InitialLoadBalanceResponse) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-
-    private java.lang.Object loadBalancerDelegate_ = "";
-    /**
-     * <pre>
-     * This is an application layer redirect that indicates the client should use
-     * the specified server for load balancing. When this field is non-empty in
-     * the response, the client should open a separate connection to the
-     * load_balancer_delegate and call the BalanceLoad method.
-     * </pre>
-     *
-     * <code>string load_balancer_delegate = 1;</code>
-     */
-    public java.lang.String getLoadBalancerDelegate() {
-      java.lang.Object ref = loadBalancerDelegate_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        loadBalancerDelegate_ = s;
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <pre>
-     * This is an application layer redirect that indicates the client should use
-     * the specified server for load balancing. When this field is non-empty in
-     * the response, the client should open a separate connection to the
-     * load_balancer_delegate and call the BalanceLoad method.
-     * </pre>
-     *
-     * <code>string load_balancer_delegate = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getLoadBalancerDelegateBytes() {
-      java.lang.Object ref = loadBalancerDelegate_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        loadBalancerDelegate_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <pre>
-     * This is an application layer redirect that indicates the client should use
-     * the specified server for load balancing. When this field is non-empty in
-     * the response, the client should open a separate connection to the
-     * load_balancer_delegate and call the BalanceLoad method.
-     * </pre>
-     *
-     * <code>string load_balancer_delegate = 1;</code>
-     */
-    public Builder setLoadBalancerDelegate(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  
-      loadBalancerDelegate_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * This is an application layer redirect that indicates the client should use
-     * the specified server for load balancing. When this field is non-empty in
-     * the response, the client should open a separate connection to the
-     * load_balancer_delegate and call the BalanceLoad method.
-     * </pre>
-     *
-     * <code>string load_balancer_delegate = 1;</code>
-     */
-    public Builder clearLoadBalancerDelegate() {
-      
-      loadBalancerDelegate_ = getDefaultInstance().getLoadBalancerDelegate();
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * This is an application layer redirect that indicates the client should use
-     * the specified server for load balancing. When this field is non-empty in
-     * the response, the client should open a separate connection to the
-     * load_balancer_delegate and call the BalanceLoad method.
-     * </pre>
-     *
-     * <code>string load_balancer_delegate = 1;</code>
-     */
-    public Builder setLoadBalancerDelegateBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      
-      loadBalancerDelegate_ = value;
-      onChanged();
-      return this;
-    }
-
-    private com.google.protobuf.Duration clientStatsReportInterval_ = null;
-    private com.google.protobuf.SingleFieldBuilderV3<
-        com.google.protobuf.Duration, com.google.protobuf.Duration.Builder, com.google.protobuf.DurationOrBuilder> clientStatsReportIntervalBuilder_;
-    /**
-     * <pre>
-     * This interval defines how often the client should send the client stats
-     * to the load balancer. Stats should only be reported when the duration is
-     * positive.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-     */
-    public boolean hasClientStatsReportInterval() {
-      return clientStatsReportIntervalBuilder_ != null || clientStatsReportInterval_ != null;
-    }
-    /**
-     * <pre>
-     * This interval defines how often the client should send the client stats
-     * to the load balancer. Stats should only be reported when the duration is
-     * positive.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-     */
-    public com.google.protobuf.Duration getClientStatsReportInterval() {
-      if (clientStatsReportIntervalBuilder_ == null) {
-        return clientStatsReportInterval_ == null ? com.google.protobuf.Duration.getDefaultInstance() : clientStatsReportInterval_;
-      } else {
-        return clientStatsReportIntervalBuilder_.getMessage();
-      }
-    }
-    /**
-     * <pre>
-     * This interval defines how often the client should send the client stats
-     * to the load balancer. Stats should only be reported when the duration is
-     * positive.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-     */
-    public Builder setClientStatsReportInterval(com.google.protobuf.Duration value) {
-      if (clientStatsReportIntervalBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        clientStatsReportInterval_ = value;
-        onChanged();
-      } else {
-        clientStatsReportIntervalBuilder_.setMessage(value);
-      }
-
-      return this;
-    }
-    /**
-     * <pre>
-     * This interval defines how often the client should send the client stats
-     * to the load balancer. Stats should only be reported when the duration is
-     * positive.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-     */
-    public Builder setClientStatsReportInterval(
-        com.google.protobuf.Duration.Builder builderForValue) {
-      if (clientStatsReportIntervalBuilder_ == null) {
-        clientStatsReportInterval_ = builderForValue.build();
-        onChanged();
-      } else {
-        clientStatsReportIntervalBuilder_.setMessage(builderForValue.build());
-      }
-
-      return this;
-    }
-    /**
-     * <pre>
-     * This interval defines how often the client should send the client stats
-     * to the load balancer. Stats should only be reported when the duration is
-     * positive.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-     */
-    public Builder mergeClientStatsReportInterval(com.google.protobuf.Duration value) {
-      if (clientStatsReportIntervalBuilder_ == null) {
-        if (clientStatsReportInterval_ != null) {
-          clientStatsReportInterval_ =
-            com.google.protobuf.Duration.newBuilder(clientStatsReportInterval_).mergeFrom(value).buildPartial();
-        } else {
-          clientStatsReportInterval_ = value;
-        }
-        onChanged();
-      } else {
-        clientStatsReportIntervalBuilder_.mergeFrom(value);
-      }
-
-      return this;
-    }
-    /**
-     * <pre>
-     * This interval defines how often the client should send the client stats
-     * to the load balancer. Stats should only be reported when the duration is
-     * positive.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-     */
-    public Builder clearClientStatsReportInterval() {
-      if (clientStatsReportIntervalBuilder_ == null) {
-        clientStatsReportInterval_ = null;
-        onChanged();
-      } else {
-        clientStatsReportInterval_ = null;
-        clientStatsReportIntervalBuilder_ = null;
-      }
-
-      return this;
-    }
-    /**
-     * <pre>
-     * This interval defines how often the client should send the client stats
-     * to the load balancer. Stats should only be reported when the duration is
-     * positive.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-     */
-    public com.google.protobuf.Duration.Builder getClientStatsReportIntervalBuilder() {
-      
-      onChanged();
-      return getClientStatsReportIntervalFieldBuilder().getBuilder();
-    }
-    /**
-     * <pre>
-     * This interval defines how often the client should send the client stats
-     * to the load balancer. Stats should only be reported when the duration is
-     * positive.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-     */
-    public com.google.protobuf.DurationOrBuilder getClientStatsReportIntervalOrBuilder() {
-      if (clientStatsReportIntervalBuilder_ != null) {
-        return clientStatsReportIntervalBuilder_.getMessageOrBuilder();
-      } else {
-        return clientStatsReportInterval_ == null ?
-            com.google.protobuf.Duration.getDefaultInstance() : clientStatsReportInterval_;
-      }
-    }
-    /**
-     * <pre>
-     * This interval defines how often the client should send the client stats
-     * to the load balancer. Stats should only be reported when the duration is
-     * positive.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-     */
-    private com.google.protobuf.SingleFieldBuilderV3<
-        com.google.protobuf.Duration, com.google.protobuf.Duration.Builder, com.google.protobuf.DurationOrBuilder> 
-        getClientStatsReportIntervalFieldBuilder() {
-      if (clientStatsReportIntervalBuilder_ == null) {
-        clientStatsReportIntervalBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-            com.google.protobuf.Duration, com.google.protobuf.Duration.Builder, com.google.protobuf.DurationOrBuilder>(
-                getClientStatsReportInterval(),
-                getParentForChildren(),
-                isClean());
-        clientStatsReportInterval_ = null;
-      }
-      return clientStatsReportIntervalBuilder_;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.lb.v1.InitialLoadBalanceResponse)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.lb.v1.InitialLoadBalanceResponse)
-  private static final io.grpc.grpclb.InitialLoadBalanceResponse DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.grpclb.InitialLoadBalanceResponse();
-  }
-
-  public static io.grpc.grpclb.InitialLoadBalanceResponse getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<InitialLoadBalanceResponse>
-      PARSER = new com.google.protobuf.AbstractParser<InitialLoadBalanceResponse>() {
-    public InitialLoadBalanceResponse parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new InitialLoadBalanceResponse(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<InitialLoadBalanceResponse> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<InitialLoadBalanceResponse> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.grpclb.InitialLoadBalanceResponse getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/InitialLoadBalanceResponseOrBuilder.java b/grpclb/src/generated/main/java/io/grpc/grpclb/InitialLoadBalanceResponseOrBuilder.java
deleted file mode 100644
index 34be9e847dc..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/InitialLoadBalanceResponseOrBuilder.java
+++ /dev/null
@@ -1,64 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-public interface InitialLoadBalanceResponseOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.lb.v1.InitialLoadBalanceResponse)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <pre>
-   * This is an application layer redirect that indicates the client should use
-   * the specified server for load balancing. When this field is non-empty in
-   * the response, the client should open a separate connection to the
-   * load_balancer_delegate and call the BalanceLoad method.
-   * </pre>
-   *
-   * <code>string load_balancer_delegate = 1;</code>
-   */
-  java.lang.String getLoadBalancerDelegate();
-  /**
-   * <pre>
-   * This is an application layer redirect that indicates the client should use
-   * the specified server for load balancing. When this field is non-empty in
-   * the response, the client should open a separate connection to the
-   * load_balancer_delegate and call the BalanceLoad method.
-   * </pre>
-   *
-   * <code>string load_balancer_delegate = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getLoadBalancerDelegateBytes();
-
-  /**
-   * <pre>
-   * This interval defines how often the client should send the client stats
-   * to the load balancer. Stats should only be reported when the duration is
-   * positive.
-   * </pre>
-   *
-   * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-   */
-  boolean hasClientStatsReportInterval();
-  /**
-   * <pre>
-   * This interval defines how often the client should send the client stats
-   * to the load balancer. Stats should only be reported when the duration is
-   * positive.
-   * </pre>
-   *
-   * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-   */
-  com.google.protobuf.Duration getClientStatsReportInterval();
-  /**
-   * <pre>
-   * This interval defines how often the client should send the client stats
-   * to the load balancer. Stats should only be reported when the duration is
-   * positive.
-   * </pre>
-   *
-   * <code>.google.protobuf.Duration client_stats_report_interval = 2;</code>
-   */
-  com.google.protobuf.DurationOrBuilder getClientStatsReportIntervalOrBuilder();
-}
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalanceRequest.java b/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalanceRequest.java
deleted file mode 100644
index 71f6b65f6bf..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalanceRequest.java
+++ /dev/null
@@ -1,909 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-/**
- * Protobuf type {@code grpc.lb.v1.LoadBalanceRequest}
- */
-public  final class LoadBalanceRequest extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.lb.v1.LoadBalanceRequest)
-    LoadBalanceRequestOrBuilder {
-  // Use LoadBalanceRequest.newBuilder() to construct.
-  private LoadBalanceRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private LoadBalanceRequest() {
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private LoadBalanceRequest(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            io.grpc.grpclb.InitialLoadBalanceRequest.Builder subBuilder = null;
-            if (loadBalanceRequestTypeCase_ == 1) {
-              subBuilder = ((io.grpc.grpclb.InitialLoadBalanceRequest) loadBalanceRequestType_).toBuilder();
-            }
-            loadBalanceRequestType_ =
-                input.readMessage(io.grpc.grpclb.InitialLoadBalanceRequest.parser(), extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom((io.grpc.grpclb.InitialLoadBalanceRequest) loadBalanceRequestType_);
-              loadBalanceRequestType_ = subBuilder.buildPartial();
-            }
-            loadBalanceRequestTypeCase_ = 1;
-            break;
-          }
-          case 18: {
-            io.grpc.grpclb.ClientStats.Builder subBuilder = null;
-            if (loadBalanceRequestTypeCase_ == 2) {
-              subBuilder = ((io.grpc.grpclb.ClientStats) loadBalanceRequestType_).toBuilder();
-            }
-            loadBalanceRequestType_ =
-                input.readMessage(io.grpc.grpclb.ClientStats.parser(), extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom((io.grpc.grpclb.ClientStats) loadBalanceRequestType_);
-              loadBalanceRequestType_ = subBuilder.buildPartial();
-            }
-            loadBalanceRequestTypeCase_ = 2;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_LoadBalanceRequest_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_LoadBalanceRequest_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.grpclb.LoadBalanceRequest.class, io.grpc.grpclb.LoadBalanceRequest.Builder.class);
-  }
-
-  private int loadBalanceRequestTypeCase_ = 0;
-  private java.lang.Object loadBalanceRequestType_;
-  public enum LoadBalanceRequestTypeCase
-      implements com.google.protobuf.Internal.EnumLite {
-    INITIAL_REQUEST(1),
-    CLIENT_STATS(2),
-    LOADBALANCEREQUESTTYPE_NOT_SET(0);
-    private final int value;
-    private LoadBalanceRequestTypeCase(int value) {
-      this.value = value;
-    }
-    /**
-     * @deprecated Use {@link #forNumber(int)} instead.
-     */
-    @java.lang.Deprecated
-    public static LoadBalanceRequestTypeCase valueOf(int value) {
-      return forNumber(value);
-    }
-
-    public static LoadBalanceRequestTypeCase forNumber(int value) {
-      switch (value) {
-        case 1: return INITIAL_REQUEST;
-        case 2: return CLIENT_STATS;
-        case 0: return LOADBALANCEREQUESTTYPE_NOT_SET;
-        default: return null;
-      }
-    }
-    public int getNumber() {
-      return this.value;
-    }
-  };
-
-  public LoadBalanceRequestTypeCase
-  getLoadBalanceRequestTypeCase() {
-    return LoadBalanceRequestTypeCase.forNumber(
-        loadBalanceRequestTypeCase_);
-  }
-
-  public static final int INITIAL_REQUEST_FIELD_NUMBER = 1;
-  /**
-   * <pre>
-   * This message should be sent on the first request to the load balancer.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.InitialLoadBalanceRequest initial_request = 1;</code>
-   */
-  public io.grpc.grpclb.InitialLoadBalanceRequest getInitialRequest() {
-    if (loadBalanceRequestTypeCase_ == 1) {
-       return (io.grpc.grpclb.InitialLoadBalanceRequest) loadBalanceRequestType_;
-    }
-    return io.grpc.grpclb.InitialLoadBalanceRequest.getDefaultInstance();
-  }
-  /**
-   * <pre>
-   * This message should be sent on the first request to the load balancer.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.InitialLoadBalanceRequest initial_request = 1;</code>
-   */
-  public io.grpc.grpclb.InitialLoadBalanceRequestOrBuilder getInitialRequestOrBuilder() {
-    if (loadBalanceRequestTypeCase_ == 1) {
-       return (io.grpc.grpclb.InitialLoadBalanceRequest) loadBalanceRequestType_;
-    }
-    return io.grpc.grpclb.InitialLoadBalanceRequest.getDefaultInstance();
-  }
-
-  public static final int CLIENT_STATS_FIELD_NUMBER = 2;
-  /**
-   * <pre>
-   * The client stats should be periodically reported to the load balancer
-   * based on the duration defined in the InitialLoadBalanceResponse.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.ClientStats client_stats = 2;</code>
-   */
-  public io.grpc.grpclb.ClientStats getClientStats() {
-    if (loadBalanceRequestTypeCase_ == 2) {
-       return (io.grpc.grpclb.ClientStats) loadBalanceRequestType_;
-    }
-    return io.grpc.grpclb.ClientStats.getDefaultInstance();
-  }
-  /**
-   * <pre>
-   * The client stats should be periodically reported to the load balancer
-   * based on the duration defined in the InitialLoadBalanceResponse.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.ClientStats client_stats = 2;</code>
-   */
-  public io.grpc.grpclb.ClientStatsOrBuilder getClientStatsOrBuilder() {
-    if (loadBalanceRequestTypeCase_ == 2) {
-       return (io.grpc.grpclb.ClientStats) loadBalanceRequestType_;
-    }
-    return io.grpc.grpclb.ClientStats.getDefaultInstance();
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (loadBalanceRequestTypeCase_ == 1) {
-      output.writeMessage(1, (io.grpc.grpclb.InitialLoadBalanceRequest) loadBalanceRequestType_);
-    }
-    if (loadBalanceRequestTypeCase_ == 2) {
-      output.writeMessage(2, (io.grpc.grpclb.ClientStats) loadBalanceRequestType_);
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (loadBalanceRequestTypeCase_ == 1) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(1, (io.grpc.grpclb.InitialLoadBalanceRequest) loadBalanceRequestType_);
-    }
-    if (loadBalanceRequestTypeCase_ == 2) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(2, (io.grpc.grpclb.ClientStats) loadBalanceRequestType_);
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.grpclb.LoadBalanceRequest)) {
-      return super.equals(obj);
-    }
-    io.grpc.grpclb.LoadBalanceRequest other = (io.grpc.grpclb.LoadBalanceRequest) obj;
-
-    boolean result = true;
-    result = result && getLoadBalanceRequestTypeCase().equals(
-        other.getLoadBalanceRequestTypeCase());
-    if (!result) return false;
-    switch (loadBalanceRequestTypeCase_) {
-      case 1:
-        result = result && getInitialRequest()
-            .equals(other.getInitialRequest());
-        break;
-      case 2:
-        result = result && getClientStats()
-            .equals(other.getClientStats());
-        break;
-      case 0:
-      default:
-    }
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    switch (loadBalanceRequestTypeCase_) {
-      case 1:
-        hash = (37 * hash) + INITIAL_REQUEST_FIELD_NUMBER;
-        hash = (53 * hash) + getInitialRequest().hashCode();
-        break;
-      case 2:
-        hash = (37 * hash) + CLIENT_STATS_FIELD_NUMBER;
-        hash = (53 * hash) + getClientStats().hashCode();
-        break;
-      case 0:
-      default:
-    }
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.grpclb.LoadBalanceRequest parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.LoadBalanceRequest parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.LoadBalanceRequest parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.LoadBalanceRequest parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.LoadBalanceRequest parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.LoadBalanceRequest parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.LoadBalanceRequest parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.LoadBalanceRequest parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.LoadBalanceRequest parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.LoadBalanceRequest parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.grpclb.LoadBalanceRequest prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.lb.v1.LoadBalanceRequest}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.lb.v1.LoadBalanceRequest)
-      io.grpc.grpclb.LoadBalanceRequestOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_LoadBalanceRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_LoadBalanceRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.grpclb.LoadBalanceRequest.class, io.grpc.grpclb.LoadBalanceRequest.Builder.class);
-    }
-
-    // Construct using io.grpc.grpclb.LoadBalanceRequest.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      loadBalanceRequestTypeCase_ = 0;
-      loadBalanceRequestType_ = null;
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_LoadBalanceRequest_descriptor;
-    }
-
-    public io.grpc.grpclb.LoadBalanceRequest getDefaultInstanceForType() {
-      return io.grpc.grpclb.LoadBalanceRequest.getDefaultInstance();
-    }
-
-    public io.grpc.grpclb.LoadBalanceRequest build() {
-      io.grpc.grpclb.LoadBalanceRequest result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.grpclb.LoadBalanceRequest buildPartial() {
-      io.grpc.grpclb.LoadBalanceRequest result = new io.grpc.grpclb.LoadBalanceRequest(this);
-      if (loadBalanceRequestTypeCase_ == 1) {
-        if (initialRequestBuilder_ == null) {
-          result.loadBalanceRequestType_ = loadBalanceRequestType_;
-        } else {
-          result.loadBalanceRequestType_ = initialRequestBuilder_.build();
-        }
-      }
-      if (loadBalanceRequestTypeCase_ == 2) {
-        if (clientStatsBuilder_ == null) {
-          result.loadBalanceRequestType_ = loadBalanceRequestType_;
-        } else {
-          result.loadBalanceRequestType_ = clientStatsBuilder_.build();
-        }
-      }
-      result.loadBalanceRequestTypeCase_ = loadBalanceRequestTypeCase_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.grpclb.LoadBalanceRequest) {
-        return mergeFrom((io.grpc.grpclb.LoadBalanceRequest)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.grpclb.LoadBalanceRequest other) {
-      if (other == io.grpc.grpclb.LoadBalanceRequest.getDefaultInstance()) return this;
-      switch (other.getLoadBalanceRequestTypeCase()) {
-        case INITIAL_REQUEST: {
-          mergeInitialRequest(other.getInitialRequest());
-          break;
-        }
-        case CLIENT_STATS: {
-          mergeClientStats(other.getClientStats());
-          break;
-        }
-        case LOADBALANCEREQUESTTYPE_NOT_SET: {
-          break;
-        }
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.grpclb.LoadBalanceRequest parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.grpclb.LoadBalanceRequest) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int loadBalanceRequestTypeCase_ = 0;
-    private java.lang.Object loadBalanceRequestType_;
-    public LoadBalanceRequestTypeCase
-        getLoadBalanceRequestTypeCase() {
-      return LoadBalanceRequestTypeCase.forNumber(
-          loadBalanceRequestTypeCase_);
-    }
-
-    public Builder clearLoadBalanceRequestType() {
-      loadBalanceRequestTypeCase_ = 0;
-      loadBalanceRequestType_ = null;
-      onChanged();
-      return this;
-    }
-
-
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.grpclb.InitialLoadBalanceRequest, io.grpc.grpclb.InitialLoadBalanceRequest.Builder, io.grpc.grpclb.InitialLoadBalanceRequestOrBuilder> initialRequestBuilder_;
-    /**
-     * <pre>
-     * This message should be sent on the first request to the load balancer.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceRequest initial_request = 1;</code>
-     */
-    public io.grpc.grpclb.InitialLoadBalanceRequest getInitialRequest() {
-      if (initialRequestBuilder_ == null) {
-        if (loadBalanceRequestTypeCase_ == 1) {
-          return (io.grpc.grpclb.InitialLoadBalanceRequest) loadBalanceRequestType_;
-        }
-        return io.grpc.grpclb.InitialLoadBalanceRequest.getDefaultInstance();
-      } else {
-        if (loadBalanceRequestTypeCase_ == 1) {
-          return initialRequestBuilder_.getMessage();
-        }
-        return io.grpc.grpclb.InitialLoadBalanceRequest.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first request to the load balancer.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceRequest initial_request = 1;</code>
-     */
-    public Builder setInitialRequest(io.grpc.grpclb.InitialLoadBalanceRequest value) {
-      if (initialRequestBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        loadBalanceRequestType_ = value;
-        onChanged();
-      } else {
-        initialRequestBuilder_.setMessage(value);
-      }
-      loadBalanceRequestTypeCase_ = 1;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first request to the load balancer.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceRequest initial_request = 1;</code>
-     */
-    public Builder setInitialRequest(
-        io.grpc.grpclb.InitialLoadBalanceRequest.Builder builderForValue) {
-      if (initialRequestBuilder_ == null) {
-        loadBalanceRequestType_ = builderForValue.build();
-        onChanged();
-      } else {
-        initialRequestBuilder_.setMessage(builderForValue.build());
-      }
-      loadBalanceRequestTypeCase_ = 1;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first request to the load balancer.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceRequest initial_request = 1;</code>
-     */
-    public Builder mergeInitialRequest(io.grpc.grpclb.InitialLoadBalanceRequest value) {
-      if (initialRequestBuilder_ == null) {
-        if (loadBalanceRequestTypeCase_ == 1 &&
-            loadBalanceRequestType_ != io.grpc.grpclb.InitialLoadBalanceRequest.getDefaultInstance()) {
-          loadBalanceRequestType_ = io.grpc.grpclb.InitialLoadBalanceRequest.newBuilder((io.grpc.grpclb.InitialLoadBalanceRequest) loadBalanceRequestType_)
-              .mergeFrom(value).buildPartial();
-        } else {
-          loadBalanceRequestType_ = value;
-        }
-        onChanged();
-      } else {
-        if (loadBalanceRequestTypeCase_ == 1) {
-          initialRequestBuilder_.mergeFrom(value);
-        }
-        initialRequestBuilder_.setMessage(value);
-      }
-      loadBalanceRequestTypeCase_ = 1;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first request to the load balancer.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceRequest initial_request = 1;</code>
-     */
-    public Builder clearInitialRequest() {
-      if (initialRequestBuilder_ == null) {
-        if (loadBalanceRequestTypeCase_ == 1) {
-          loadBalanceRequestTypeCase_ = 0;
-          loadBalanceRequestType_ = null;
-          onChanged();
-        }
-      } else {
-        if (loadBalanceRequestTypeCase_ == 1) {
-          loadBalanceRequestTypeCase_ = 0;
-          loadBalanceRequestType_ = null;
-        }
-        initialRequestBuilder_.clear();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first request to the load balancer.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceRequest initial_request = 1;</code>
-     */
-    public io.grpc.grpclb.InitialLoadBalanceRequest.Builder getInitialRequestBuilder() {
-      return getInitialRequestFieldBuilder().getBuilder();
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first request to the load balancer.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceRequest initial_request = 1;</code>
-     */
-    public io.grpc.grpclb.InitialLoadBalanceRequestOrBuilder getInitialRequestOrBuilder() {
-      if ((loadBalanceRequestTypeCase_ == 1) && (initialRequestBuilder_ != null)) {
-        return initialRequestBuilder_.getMessageOrBuilder();
-      } else {
-        if (loadBalanceRequestTypeCase_ == 1) {
-          return (io.grpc.grpclb.InitialLoadBalanceRequest) loadBalanceRequestType_;
-        }
-        return io.grpc.grpclb.InitialLoadBalanceRequest.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first request to the load balancer.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceRequest initial_request = 1;</code>
-     */
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.grpclb.InitialLoadBalanceRequest, io.grpc.grpclb.InitialLoadBalanceRequest.Builder, io.grpc.grpclb.InitialLoadBalanceRequestOrBuilder> 
-        getInitialRequestFieldBuilder() {
-      if (initialRequestBuilder_ == null) {
-        if (!(loadBalanceRequestTypeCase_ == 1)) {
-          loadBalanceRequestType_ = io.grpc.grpclb.InitialLoadBalanceRequest.getDefaultInstance();
-        }
-        initialRequestBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-            io.grpc.grpclb.InitialLoadBalanceRequest, io.grpc.grpclb.InitialLoadBalanceRequest.Builder, io.grpc.grpclb.InitialLoadBalanceRequestOrBuilder>(
-                (io.grpc.grpclb.InitialLoadBalanceRequest) loadBalanceRequestType_,
-                getParentForChildren(),
-                isClean());
-        loadBalanceRequestType_ = null;
-      }
-      loadBalanceRequestTypeCase_ = 1;
-      onChanged();;
-      return initialRequestBuilder_;
-    }
-
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.grpclb.ClientStats, io.grpc.grpclb.ClientStats.Builder, io.grpc.grpclb.ClientStatsOrBuilder> clientStatsBuilder_;
-    /**
-     * <pre>
-     * The client stats should be periodically reported to the load balancer
-     * based on the duration defined in the InitialLoadBalanceResponse.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ClientStats client_stats = 2;</code>
-     */
-    public io.grpc.grpclb.ClientStats getClientStats() {
-      if (clientStatsBuilder_ == null) {
-        if (loadBalanceRequestTypeCase_ == 2) {
-          return (io.grpc.grpclb.ClientStats) loadBalanceRequestType_;
-        }
-        return io.grpc.grpclb.ClientStats.getDefaultInstance();
-      } else {
-        if (loadBalanceRequestTypeCase_ == 2) {
-          return clientStatsBuilder_.getMessage();
-        }
-        return io.grpc.grpclb.ClientStats.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * The client stats should be periodically reported to the load balancer
-     * based on the duration defined in the InitialLoadBalanceResponse.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ClientStats client_stats = 2;</code>
-     */
-    public Builder setClientStats(io.grpc.grpclb.ClientStats value) {
-      if (clientStatsBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        loadBalanceRequestType_ = value;
-        onChanged();
-      } else {
-        clientStatsBuilder_.setMessage(value);
-      }
-      loadBalanceRequestTypeCase_ = 2;
-      return this;
-    }
-    /**
-     * <pre>
-     * The client stats should be periodically reported to the load balancer
-     * based on the duration defined in the InitialLoadBalanceResponse.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ClientStats client_stats = 2;</code>
-     */
-    public Builder setClientStats(
-        io.grpc.grpclb.ClientStats.Builder builderForValue) {
-      if (clientStatsBuilder_ == null) {
-        loadBalanceRequestType_ = builderForValue.build();
-        onChanged();
-      } else {
-        clientStatsBuilder_.setMessage(builderForValue.build());
-      }
-      loadBalanceRequestTypeCase_ = 2;
-      return this;
-    }
-    /**
-     * <pre>
-     * The client stats should be periodically reported to the load balancer
-     * based on the duration defined in the InitialLoadBalanceResponse.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ClientStats client_stats = 2;</code>
-     */
-    public Builder mergeClientStats(io.grpc.grpclb.ClientStats value) {
-      if (clientStatsBuilder_ == null) {
-        if (loadBalanceRequestTypeCase_ == 2 &&
-            loadBalanceRequestType_ != io.grpc.grpclb.ClientStats.getDefaultInstance()) {
-          loadBalanceRequestType_ = io.grpc.grpclb.ClientStats.newBuilder((io.grpc.grpclb.ClientStats) loadBalanceRequestType_)
-              .mergeFrom(value).buildPartial();
-        } else {
-          loadBalanceRequestType_ = value;
-        }
-        onChanged();
-      } else {
-        if (loadBalanceRequestTypeCase_ == 2) {
-          clientStatsBuilder_.mergeFrom(value);
-        }
-        clientStatsBuilder_.setMessage(value);
-      }
-      loadBalanceRequestTypeCase_ = 2;
-      return this;
-    }
-    /**
-     * <pre>
-     * The client stats should be periodically reported to the load balancer
-     * based on the duration defined in the InitialLoadBalanceResponse.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ClientStats client_stats = 2;</code>
-     */
-    public Builder clearClientStats() {
-      if (clientStatsBuilder_ == null) {
-        if (loadBalanceRequestTypeCase_ == 2) {
-          loadBalanceRequestTypeCase_ = 0;
-          loadBalanceRequestType_ = null;
-          onChanged();
-        }
-      } else {
-        if (loadBalanceRequestTypeCase_ == 2) {
-          loadBalanceRequestTypeCase_ = 0;
-          loadBalanceRequestType_ = null;
-        }
-        clientStatsBuilder_.clear();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * The client stats should be periodically reported to the load balancer
-     * based on the duration defined in the InitialLoadBalanceResponse.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ClientStats client_stats = 2;</code>
-     */
-    public io.grpc.grpclb.ClientStats.Builder getClientStatsBuilder() {
-      return getClientStatsFieldBuilder().getBuilder();
-    }
-    /**
-     * <pre>
-     * The client stats should be periodically reported to the load balancer
-     * based on the duration defined in the InitialLoadBalanceResponse.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ClientStats client_stats = 2;</code>
-     */
-    public io.grpc.grpclb.ClientStatsOrBuilder getClientStatsOrBuilder() {
-      if ((loadBalanceRequestTypeCase_ == 2) && (clientStatsBuilder_ != null)) {
-        return clientStatsBuilder_.getMessageOrBuilder();
-      } else {
-        if (loadBalanceRequestTypeCase_ == 2) {
-          return (io.grpc.grpclb.ClientStats) loadBalanceRequestType_;
-        }
-        return io.grpc.grpclb.ClientStats.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * The client stats should be periodically reported to the load balancer
-     * based on the duration defined in the InitialLoadBalanceResponse.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ClientStats client_stats = 2;</code>
-     */
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.grpclb.ClientStats, io.grpc.grpclb.ClientStats.Builder, io.grpc.grpclb.ClientStatsOrBuilder> 
-        getClientStatsFieldBuilder() {
-      if (clientStatsBuilder_ == null) {
-        if (!(loadBalanceRequestTypeCase_ == 2)) {
-          loadBalanceRequestType_ = io.grpc.grpclb.ClientStats.getDefaultInstance();
-        }
-        clientStatsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-            io.grpc.grpclb.ClientStats, io.grpc.grpclb.ClientStats.Builder, io.grpc.grpclb.ClientStatsOrBuilder>(
-                (io.grpc.grpclb.ClientStats) loadBalanceRequestType_,
-                getParentForChildren(),
-                isClean());
-        loadBalanceRequestType_ = null;
-      }
-      loadBalanceRequestTypeCase_ = 2;
-      onChanged();;
-      return clientStatsBuilder_;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.lb.v1.LoadBalanceRequest)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.lb.v1.LoadBalanceRequest)
-  private static final io.grpc.grpclb.LoadBalanceRequest DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.grpclb.LoadBalanceRequest();
-  }
-
-  public static io.grpc.grpclb.LoadBalanceRequest getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<LoadBalanceRequest>
-      PARSER = new com.google.protobuf.AbstractParser<LoadBalanceRequest>() {
-    public LoadBalanceRequest parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new LoadBalanceRequest(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<LoadBalanceRequest> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<LoadBalanceRequest> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.grpclb.LoadBalanceRequest getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalanceRequestOrBuilder.java b/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalanceRequestOrBuilder.java
deleted file mode 100644
index 6afc7b68fa7..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalanceRequestOrBuilder.java
+++ /dev/null
@@ -1,47 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-public interface LoadBalanceRequestOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.lb.v1.LoadBalanceRequest)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <pre>
-   * This message should be sent on the first request to the load balancer.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.InitialLoadBalanceRequest initial_request = 1;</code>
-   */
-  io.grpc.grpclb.InitialLoadBalanceRequest getInitialRequest();
-  /**
-   * <pre>
-   * This message should be sent on the first request to the load balancer.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.InitialLoadBalanceRequest initial_request = 1;</code>
-   */
-  io.grpc.grpclb.InitialLoadBalanceRequestOrBuilder getInitialRequestOrBuilder();
-
-  /**
-   * <pre>
-   * The client stats should be periodically reported to the load balancer
-   * based on the duration defined in the InitialLoadBalanceResponse.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.ClientStats client_stats = 2;</code>
-   */
-  io.grpc.grpclb.ClientStats getClientStats();
-  /**
-   * <pre>
-   * The client stats should be periodically reported to the load balancer
-   * based on the duration defined in the InitialLoadBalanceResponse.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.ClientStats client_stats = 2;</code>
-   */
-  io.grpc.grpclb.ClientStatsOrBuilder getClientStatsOrBuilder();
-
-  public io.grpc.grpclb.LoadBalanceRequest.LoadBalanceRequestTypeCase getLoadBalanceRequestTypeCase();
-}
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalanceResponse.java b/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalanceResponse.java
deleted file mode 100644
index 5f3eedded24..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalanceResponse.java
+++ /dev/null
@@ -1,909 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-/**
- * Protobuf type {@code grpc.lb.v1.LoadBalanceResponse}
- */
-public  final class LoadBalanceResponse extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.lb.v1.LoadBalanceResponse)
-    LoadBalanceResponseOrBuilder {
-  // Use LoadBalanceResponse.newBuilder() to construct.
-  private LoadBalanceResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private LoadBalanceResponse() {
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private LoadBalanceResponse(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            io.grpc.grpclb.InitialLoadBalanceResponse.Builder subBuilder = null;
-            if (loadBalanceResponseTypeCase_ == 1) {
-              subBuilder = ((io.grpc.grpclb.InitialLoadBalanceResponse) loadBalanceResponseType_).toBuilder();
-            }
-            loadBalanceResponseType_ =
-                input.readMessage(io.grpc.grpclb.InitialLoadBalanceResponse.parser(), extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom((io.grpc.grpclb.InitialLoadBalanceResponse) loadBalanceResponseType_);
-              loadBalanceResponseType_ = subBuilder.buildPartial();
-            }
-            loadBalanceResponseTypeCase_ = 1;
-            break;
-          }
-          case 18: {
-            io.grpc.grpclb.ServerList.Builder subBuilder = null;
-            if (loadBalanceResponseTypeCase_ == 2) {
-              subBuilder = ((io.grpc.grpclb.ServerList) loadBalanceResponseType_).toBuilder();
-            }
-            loadBalanceResponseType_ =
-                input.readMessage(io.grpc.grpclb.ServerList.parser(), extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom((io.grpc.grpclb.ServerList) loadBalanceResponseType_);
-              loadBalanceResponseType_ = subBuilder.buildPartial();
-            }
-            loadBalanceResponseTypeCase_ = 2;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_LoadBalanceResponse_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_LoadBalanceResponse_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.grpclb.LoadBalanceResponse.class, io.grpc.grpclb.LoadBalanceResponse.Builder.class);
-  }
-
-  private int loadBalanceResponseTypeCase_ = 0;
-  private java.lang.Object loadBalanceResponseType_;
-  public enum LoadBalanceResponseTypeCase
-      implements com.google.protobuf.Internal.EnumLite {
-    INITIAL_RESPONSE(1),
-    SERVER_LIST(2),
-    LOADBALANCERESPONSETYPE_NOT_SET(0);
-    private final int value;
-    private LoadBalanceResponseTypeCase(int value) {
-      this.value = value;
-    }
-    /**
-     * @deprecated Use {@link #forNumber(int)} instead.
-     */
-    @java.lang.Deprecated
-    public static LoadBalanceResponseTypeCase valueOf(int value) {
-      return forNumber(value);
-    }
-
-    public static LoadBalanceResponseTypeCase forNumber(int value) {
-      switch (value) {
-        case 1: return INITIAL_RESPONSE;
-        case 2: return SERVER_LIST;
-        case 0: return LOADBALANCERESPONSETYPE_NOT_SET;
-        default: return null;
-      }
-    }
-    public int getNumber() {
-      return this.value;
-    }
-  };
-
-  public LoadBalanceResponseTypeCase
-  getLoadBalanceResponseTypeCase() {
-    return LoadBalanceResponseTypeCase.forNumber(
-        loadBalanceResponseTypeCase_);
-  }
-
-  public static final int INITIAL_RESPONSE_FIELD_NUMBER = 1;
-  /**
-   * <pre>
-   * This message should be sent on the first response to the client.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.InitialLoadBalanceResponse initial_response = 1;</code>
-   */
-  public io.grpc.grpclb.InitialLoadBalanceResponse getInitialResponse() {
-    if (loadBalanceResponseTypeCase_ == 1) {
-       return (io.grpc.grpclb.InitialLoadBalanceResponse) loadBalanceResponseType_;
-    }
-    return io.grpc.grpclb.InitialLoadBalanceResponse.getDefaultInstance();
-  }
-  /**
-   * <pre>
-   * This message should be sent on the first response to the client.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.InitialLoadBalanceResponse initial_response = 1;</code>
-   */
-  public io.grpc.grpclb.InitialLoadBalanceResponseOrBuilder getInitialResponseOrBuilder() {
-    if (loadBalanceResponseTypeCase_ == 1) {
-       return (io.grpc.grpclb.InitialLoadBalanceResponse) loadBalanceResponseType_;
-    }
-    return io.grpc.grpclb.InitialLoadBalanceResponse.getDefaultInstance();
-  }
-
-  public static final int SERVER_LIST_FIELD_NUMBER = 2;
-  /**
-   * <pre>
-   * Contains the list of servers selected by the load balancer. The client
-   * should send requests to these servers in the specified order.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.ServerList server_list = 2;</code>
-   */
-  public io.grpc.grpclb.ServerList getServerList() {
-    if (loadBalanceResponseTypeCase_ == 2) {
-       return (io.grpc.grpclb.ServerList) loadBalanceResponseType_;
-    }
-    return io.grpc.grpclb.ServerList.getDefaultInstance();
-  }
-  /**
-   * <pre>
-   * Contains the list of servers selected by the load balancer. The client
-   * should send requests to these servers in the specified order.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.ServerList server_list = 2;</code>
-   */
-  public io.grpc.grpclb.ServerListOrBuilder getServerListOrBuilder() {
-    if (loadBalanceResponseTypeCase_ == 2) {
-       return (io.grpc.grpclb.ServerList) loadBalanceResponseType_;
-    }
-    return io.grpc.grpclb.ServerList.getDefaultInstance();
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (loadBalanceResponseTypeCase_ == 1) {
-      output.writeMessage(1, (io.grpc.grpclb.InitialLoadBalanceResponse) loadBalanceResponseType_);
-    }
-    if (loadBalanceResponseTypeCase_ == 2) {
-      output.writeMessage(2, (io.grpc.grpclb.ServerList) loadBalanceResponseType_);
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (loadBalanceResponseTypeCase_ == 1) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(1, (io.grpc.grpclb.InitialLoadBalanceResponse) loadBalanceResponseType_);
-    }
-    if (loadBalanceResponseTypeCase_ == 2) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(2, (io.grpc.grpclb.ServerList) loadBalanceResponseType_);
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.grpclb.LoadBalanceResponse)) {
-      return super.equals(obj);
-    }
-    io.grpc.grpclb.LoadBalanceResponse other = (io.grpc.grpclb.LoadBalanceResponse) obj;
-
-    boolean result = true;
-    result = result && getLoadBalanceResponseTypeCase().equals(
-        other.getLoadBalanceResponseTypeCase());
-    if (!result) return false;
-    switch (loadBalanceResponseTypeCase_) {
-      case 1:
-        result = result && getInitialResponse()
-            .equals(other.getInitialResponse());
-        break;
-      case 2:
-        result = result && getServerList()
-            .equals(other.getServerList());
-        break;
-      case 0:
-      default:
-    }
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    switch (loadBalanceResponseTypeCase_) {
-      case 1:
-        hash = (37 * hash) + INITIAL_RESPONSE_FIELD_NUMBER;
-        hash = (53 * hash) + getInitialResponse().hashCode();
-        break;
-      case 2:
-        hash = (37 * hash) + SERVER_LIST_FIELD_NUMBER;
-        hash = (53 * hash) + getServerList().hashCode();
-        break;
-      case 0:
-      default:
-    }
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.grpclb.LoadBalanceResponse parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.LoadBalanceResponse parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.LoadBalanceResponse parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.LoadBalanceResponse parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.LoadBalanceResponse parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.LoadBalanceResponse parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.LoadBalanceResponse parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.LoadBalanceResponse parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.LoadBalanceResponse parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.LoadBalanceResponse parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.grpclb.LoadBalanceResponse prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.lb.v1.LoadBalanceResponse}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.lb.v1.LoadBalanceResponse)
-      io.grpc.grpclb.LoadBalanceResponseOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_LoadBalanceResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_LoadBalanceResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.grpclb.LoadBalanceResponse.class, io.grpc.grpclb.LoadBalanceResponse.Builder.class);
-    }
-
-    // Construct using io.grpc.grpclb.LoadBalanceResponse.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      loadBalanceResponseTypeCase_ = 0;
-      loadBalanceResponseType_ = null;
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_LoadBalanceResponse_descriptor;
-    }
-
-    public io.grpc.grpclb.LoadBalanceResponse getDefaultInstanceForType() {
-      return io.grpc.grpclb.LoadBalanceResponse.getDefaultInstance();
-    }
-
-    public io.grpc.grpclb.LoadBalanceResponse build() {
-      io.grpc.grpclb.LoadBalanceResponse result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.grpclb.LoadBalanceResponse buildPartial() {
-      io.grpc.grpclb.LoadBalanceResponse result = new io.grpc.grpclb.LoadBalanceResponse(this);
-      if (loadBalanceResponseTypeCase_ == 1) {
-        if (initialResponseBuilder_ == null) {
-          result.loadBalanceResponseType_ = loadBalanceResponseType_;
-        } else {
-          result.loadBalanceResponseType_ = initialResponseBuilder_.build();
-        }
-      }
-      if (loadBalanceResponseTypeCase_ == 2) {
-        if (serverListBuilder_ == null) {
-          result.loadBalanceResponseType_ = loadBalanceResponseType_;
-        } else {
-          result.loadBalanceResponseType_ = serverListBuilder_.build();
-        }
-      }
-      result.loadBalanceResponseTypeCase_ = loadBalanceResponseTypeCase_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.grpclb.LoadBalanceResponse) {
-        return mergeFrom((io.grpc.grpclb.LoadBalanceResponse)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.grpclb.LoadBalanceResponse other) {
-      if (other == io.grpc.grpclb.LoadBalanceResponse.getDefaultInstance()) return this;
-      switch (other.getLoadBalanceResponseTypeCase()) {
-        case INITIAL_RESPONSE: {
-          mergeInitialResponse(other.getInitialResponse());
-          break;
-        }
-        case SERVER_LIST: {
-          mergeServerList(other.getServerList());
-          break;
-        }
-        case LOADBALANCERESPONSETYPE_NOT_SET: {
-          break;
-        }
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.grpclb.LoadBalanceResponse parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.grpclb.LoadBalanceResponse) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int loadBalanceResponseTypeCase_ = 0;
-    private java.lang.Object loadBalanceResponseType_;
-    public LoadBalanceResponseTypeCase
-        getLoadBalanceResponseTypeCase() {
-      return LoadBalanceResponseTypeCase.forNumber(
-          loadBalanceResponseTypeCase_);
-    }
-
-    public Builder clearLoadBalanceResponseType() {
-      loadBalanceResponseTypeCase_ = 0;
-      loadBalanceResponseType_ = null;
-      onChanged();
-      return this;
-    }
-
-
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.grpclb.InitialLoadBalanceResponse, io.grpc.grpclb.InitialLoadBalanceResponse.Builder, io.grpc.grpclb.InitialLoadBalanceResponseOrBuilder> initialResponseBuilder_;
-    /**
-     * <pre>
-     * This message should be sent on the first response to the client.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceResponse initial_response = 1;</code>
-     */
-    public io.grpc.grpclb.InitialLoadBalanceResponse getInitialResponse() {
-      if (initialResponseBuilder_ == null) {
-        if (loadBalanceResponseTypeCase_ == 1) {
-          return (io.grpc.grpclb.InitialLoadBalanceResponse) loadBalanceResponseType_;
-        }
-        return io.grpc.grpclb.InitialLoadBalanceResponse.getDefaultInstance();
-      } else {
-        if (loadBalanceResponseTypeCase_ == 1) {
-          return initialResponseBuilder_.getMessage();
-        }
-        return io.grpc.grpclb.InitialLoadBalanceResponse.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first response to the client.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceResponse initial_response = 1;</code>
-     */
-    public Builder setInitialResponse(io.grpc.grpclb.InitialLoadBalanceResponse value) {
-      if (initialResponseBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        loadBalanceResponseType_ = value;
-        onChanged();
-      } else {
-        initialResponseBuilder_.setMessage(value);
-      }
-      loadBalanceResponseTypeCase_ = 1;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first response to the client.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceResponse initial_response = 1;</code>
-     */
-    public Builder setInitialResponse(
-        io.grpc.grpclb.InitialLoadBalanceResponse.Builder builderForValue) {
-      if (initialResponseBuilder_ == null) {
-        loadBalanceResponseType_ = builderForValue.build();
-        onChanged();
-      } else {
-        initialResponseBuilder_.setMessage(builderForValue.build());
-      }
-      loadBalanceResponseTypeCase_ = 1;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first response to the client.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceResponse initial_response = 1;</code>
-     */
-    public Builder mergeInitialResponse(io.grpc.grpclb.InitialLoadBalanceResponse value) {
-      if (initialResponseBuilder_ == null) {
-        if (loadBalanceResponseTypeCase_ == 1 &&
-            loadBalanceResponseType_ != io.grpc.grpclb.InitialLoadBalanceResponse.getDefaultInstance()) {
-          loadBalanceResponseType_ = io.grpc.grpclb.InitialLoadBalanceResponse.newBuilder((io.grpc.grpclb.InitialLoadBalanceResponse) loadBalanceResponseType_)
-              .mergeFrom(value).buildPartial();
-        } else {
-          loadBalanceResponseType_ = value;
-        }
-        onChanged();
-      } else {
-        if (loadBalanceResponseTypeCase_ == 1) {
-          initialResponseBuilder_.mergeFrom(value);
-        }
-        initialResponseBuilder_.setMessage(value);
-      }
-      loadBalanceResponseTypeCase_ = 1;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first response to the client.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceResponse initial_response = 1;</code>
-     */
-    public Builder clearInitialResponse() {
-      if (initialResponseBuilder_ == null) {
-        if (loadBalanceResponseTypeCase_ == 1) {
-          loadBalanceResponseTypeCase_ = 0;
-          loadBalanceResponseType_ = null;
-          onChanged();
-        }
-      } else {
-        if (loadBalanceResponseTypeCase_ == 1) {
-          loadBalanceResponseTypeCase_ = 0;
-          loadBalanceResponseType_ = null;
-        }
-        initialResponseBuilder_.clear();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first response to the client.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceResponse initial_response = 1;</code>
-     */
-    public io.grpc.grpclb.InitialLoadBalanceResponse.Builder getInitialResponseBuilder() {
-      return getInitialResponseFieldBuilder().getBuilder();
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first response to the client.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceResponse initial_response = 1;</code>
-     */
-    public io.grpc.grpclb.InitialLoadBalanceResponseOrBuilder getInitialResponseOrBuilder() {
-      if ((loadBalanceResponseTypeCase_ == 1) && (initialResponseBuilder_ != null)) {
-        return initialResponseBuilder_.getMessageOrBuilder();
-      } else {
-        if (loadBalanceResponseTypeCase_ == 1) {
-          return (io.grpc.grpclb.InitialLoadBalanceResponse) loadBalanceResponseType_;
-        }
-        return io.grpc.grpclb.InitialLoadBalanceResponse.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * This message should be sent on the first response to the client.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.InitialLoadBalanceResponse initial_response = 1;</code>
-     */
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.grpclb.InitialLoadBalanceResponse, io.grpc.grpclb.InitialLoadBalanceResponse.Builder, io.grpc.grpclb.InitialLoadBalanceResponseOrBuilder> 
-        getInitialResponseFieldBuilder() {
-      if (initialResponseBuilder_ == null) {
-        if (!(loadBalanceResponseTypeCase_ == 1)) {
-          loadBalanceResponseType_ = io.grpc.grpclb.InitialLoadBalanceResponse.getDefaultInstance();
-        }
-        initialResponseBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-            io.grpc.grpclb.InitialLoadBalanceResponse, io.grpc.grpclb.InitialLoadBalanceResponse.Builder, io.grpc.grpclb.InitialLoadBalanceResponseOrBuilder>(
-                (io.grpc.grpclb.InitialLoadBalanceResponse) loadBalanceResponseType_,
-                getParentForChildren(),
-                isClean());
-        loadBalanceResponseType_ = null;
-      }
-      loadBalanceResponseTypeCase_ = 1;
-      onChanged();;
-      return initialResponseBuilder_;
-    }
-
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.grpclb.ServerList, io.grpc.grpclb.ServerList.Builder, io.grpc.grpclb.ServerListOrBuilder> serverListBuilder_;
-    /**
-     * <pre>
-     * Contains the list of servers selected by the load balancer. The client
-     * should send requests to these servers in the specified order.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ServerList server_list = 2;</code>
-     */
-    public io.grpc.grpclb.ServerList getServerList() {
-      if (serverListBuilder_ == null) {
-        if (loadBalanceResponseTypeCase_ == 2) {
-          return (io.grpc.grpclb.ServerList) loadBalanceResponseType_;
-        }
-        return io.grpc.grpclb.ServerList.getDefaultInstance();
-      } else {
-        if (loadBalanceResponseTypeCase_ == 2) {
-          return serverListBuilder_.getMessage();
-        }
-        return io.grpc.grpclb.ServerList.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * Contains the list of servers selected by the load balancer. The client
-     * should send requests to these servers in the specified order.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ServerList server_list = 2;</code>
-     */
-    public Builder setServerList(io.grpc.grpclb.ServerList value) {
-      if (serverListBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        loadBalanceResponseType_ = value;
-        onChanged();
-      } else {
-        serverListBuilder_.setMessage(value);
-      }
-      loadBalanceResponseTypeCase_ = 2;
-      return this;
-    }
-    /**
-     * <pre>
-     * Contains the list of servers selected by the load balancer. The client
-     * should send requests to these servers in the specified order.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ServerList server_list = 2;</code>
-     */
-    public Builder setServerList(
-        io.grpc.grpclb.ServerList.Builder builderForValue) {
-      if (serverListBuilder_ == null) {
-        loadBalanceResponseType_ = builderForValue.build();
-        onChanged();
-      } else {
-        serverListBuilder_.setMessage(builderForValue.build());
-      }
-      loadBalanceResponseTypeCase_ = 2;
-      return this;
-    }
-    /**
-     * <pre>
-     * Contains the list of servers selected by the load balancer. The client
-     * should send requests to these servers in the specified order.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ServerList server_list = 2;</code>
-     */
-    public Builder mergeServerList(io.grpc.grpclb.ServerList value) {
-      if (serverListBuilder_ == null) {
-        if (loadBalanceResponseTypeCase_ == 2 &&
-            loadBalanceResponseType_ != io.grpc.grpclb.ServerList.getDefaultInstance()) {
-          loadBalanceResponseType_ = io.grpc.grpclb.ServerList.newBuilder((io.grpc.grpclb.ServerList) loadBalanceResponseType_)
-              .mergeFrom(value).buildPartial();
-        } else {
-          loadBalanceResponseType_ = value;
-        }
-        onChanged();
-      } else {
-        if (loadBalanceResponseTypeCase_ == 2) {
-          serverListBuilder_.mergeFrom(value);
-        }
-        serverListBuilder_.setMessage(value);
-      }
-      loadBalanceResponseTypeCase_ = 2;
-      return this;
-    }
-    /**
-     * <pre>
-     * Contains the list of servers selected by the load balancer. The client
-     * should send requests to these servers in the specified order.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ServerList server_list = 2;</code>
-     */
-    public Builder clearServerList() {
-      if (serverListBuilder_ == null) {
-        if (loadBalanceResponseTypeCase_ == 2) {
-          loadBalanceResponseTypeCase_ = 0;
-          loadBalanceResponseType_ = null;
-          onChanged();
-        }
-      } else {
-        if (loadBalanceResponseTypeCase_ == 2) {
-          loadBalanceResponseTypeCase_ = 0;
-          loadBalanceResponseType_ = null;
-        }
-        serverListBuilder_.clear();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Contains the list of servers selected by the load balancer. The client
-     * should send requests to these servers in the specified order.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ServerList server_list = 2;</code>
-     */
-    public io.grpc.grpclb.ServerList.Builder getServerListBuilder() {
-      return getServerListFieldBuilder().getBuilder();
-    }
-    /**
-     * <pre>
-     * Contains the list of servers selected by the load balancer. The client
-     * should send requests to these servers in the specified order.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ServerList server_list = 2;</code>
-     */
-    public io.grpc.grpclb.ServerListOrBuilder getServerListOrBuilder() {
-      if ((loadBalanceResponseTypeCase_ == 2) && (serverListBuilder_ != null)) {
-        return serverListBuilder_.getMessageOrBuilder();
-      } else {
-        if (loadBalanceResponseTypeCase_ == 2) {
-          return (io.grpc.grpclb.ServerList) loadBalanceResponseType_;
-        }
-        return io.grpc.grpclb.ServerList.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * Contains the list of servers selected by the load balancer. The client
-     * should send requests to these servers in the specified order.
-     * </pre>
-     *
-     * <code>.grpc.lb.v1.ServerList server_list = 2;</code>
-     */
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.grpclb.ServerList, io.grpc.grpclb.ServerList.Builder, io.grpc.grpclb.ServerListOrBuilder> 
-        getServerListFieldBuilder() {
-      if (serverListBuilder_ == null) {
-        if (!(loadBalanceResponseTypeCase_ == 2)) {
-          loadBalanceResponseType_ = io.grpc.grpclb.ServerList.getDefaultInstance();
-        }
-        serverListBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-            io.grpc.grpclb.ServerList, io.grpc.grpclb.ServerList.Builder, io.grpc.grpclb.ServerListOrBuilder>(
-                (io.grpc.grpclb.ServerList) loadBalanceResponseType_,
-                getParentForChildren(),
-                isClean());
-        loadBalanceResponseType_ = null;
-      }
-      loadBalanceResponseTypeCase_ = 2;
-      onChanged();;
-      return serverListBuilder_;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.lb.v1.LoadBalanceResponse)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.lb.v1.LoadBalanceResponse)
-  private static final io.grpc.grpclb.LoadBalanceResponse DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.grpclb.LoadBalanceResponse();
-  }
-
-  public static io.grpc.grpclb.LoadBalanceResponse getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<LoadBalanceResponse>
-      PARSER = new com.google.protobuf.AbstractParser<LoadBalanceResponse>() {
-    public LoadBalanceResponse parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new LoadBalanceResponse(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<LoadBalanceResponse> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<LoadBalanceResponse> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.grpclb.LoadBalanceResponse getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalanceResponseOrBuilder.java b/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalanceResponseOrBuilder.java
deleted file mode 100644
index 9c8bd6387a4..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalanceResponseOrBuilder.java
+++ /dev/null
@@ -1,47 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-public interface LoadBalanceResponseOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.lb.v1.LoadBalanceResponse)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <pre>
-   * This message should be sent on the first response to the client.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.InitialLoadBalanceResponse initial_response = 1;</code>
-   */
-  io.grpc.grpclb.InitialLoadBalanceResponse getInitialResponse();
-  /**
-   * <pre>
-   * This message should be sent on the first response to the client.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.InitialLoadBalanceResponse initial_response = 1;</code>
-   */
-  io.grpc.grpclb.InitialLoadBalanceResponseOrBuilder getInitialResponseOrBuilder();
-
-  /**
-   * <pre>
-   * Contains the list of servers selected by the load balancer. The client
-   * should send requests to these servers in the specified order.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.ServerList server_list = 2;</code>
-   */
-  io.grpc.grpclb.ServerList getServerList();
-  /**
-   * <pre>
-   * Contains the list of servers selected by the load balancer. The client
-   * should send requests to these servers in the specified order.
-   * </pre>
-   *
-   * <code>.grpc.lb.v1.ServerList server_list = 2;</code>
-   */
-  io.grpc.grpclb.ServerListOrBuilder getServerListOrBuilder();
-
-  public io.grpc.grpclb.LoadBalanceResponse.LoadBalanceResponseTypeCase getLoadBalanceResponseTypeCase();
-}
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalancerProto.java b/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalancerProto.java
deleted file mode 100644
index 840eda64897..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/LoadBalancerProto.java
+++ /dev/null
@@ -1,147 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-public final class LoadBalancerProto {
-  private LoadBalancerProto() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_lb_v1_LoadBalanceRequest_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_lb_v1_LoadBalanceRequest_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_lb_v1_InitialLoadBalanceRequest_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_lb_v1_InitialLoadBalanceRequest_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_lb_v1_ClientStats_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_lb_v1_ClientStats_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_lb_v1_LoadBalanceResponse_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_lb_v1_LoadBalanceResponse_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_lb_v1_InitialLoadBalanceResponse_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_lb_v1_InitialLoadBalanceResponse_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_lb_v1_ServerList_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_lb_v1_ServerList_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_lb_v1_Server_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_lb_v1_Server_fieldAccessorTable;
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n\023load_balancer.proto\022\ngrpc.lb.v1\032\036googl" +
-      "e/protobuf/duration.proto\"\244\001\n\022LoadBalanc" +
-      "eRequest\022@\n\017initial_request\030\001 \001(\0132%.grpc" +
-      ".lb.v1.InitialLoadBalanceRequestH\000\022/\n\014cl" +
-      "ient_stats\030\002 \001(\0132\027.grpc.lb.v1.ClientStat" +
-      "sH\000B\033\n\031load_balance_request_type\")\n\031Init" +
-      "ialLoadBalanceRequest\022\014\n\004name\030\001 \001(\t\"Z\n\013C" +
-      "lientStats\022\026\n\016total_requests\030\001 \001(\003\022\031\n\021cl" +
-      "ient_rpc_errors\030\002 \001(\003\022\030\n\020dropped_request" +
-      "s\030\003 \001(\003\"\246\001\n\023LoadBalanceResponse\022B\n\020initi",
-      "al_response\030\001 \001(\0132&.grpc.lb.v1.InitialLo" +
-      "adBalanceResponseH\000\022-\n\013server_list\030\002 \001(\013" +
-      "2\026.grpc.lb.v1.ServerListH\000B\034\n\032load_balan" +
-      "ce_response_type\"}\n\032InitialLoadBalanceRe" +
-      "sponse\022\036\n\026load_balancer_delegate\030\001 \001(\t\022?" +
-      "\n\034client_stats_report_interval\030\002 \001(\0132\031.g" +
-      "oogle.protobuf.Duration\"i\n\nServerList\022#\n" +
-      "\007servers\030\001 \003(\0132\022.grpc.lb.v1.Server\0226\n\023ex" +
-      "piration_interval\030\003 \001(\0132\031.google.protobu" +
-      "f.Duration\"\\\n\006Server\022\022\n\nip_address\030\001 \001(\014",
-      "\022\014\n\004port\030\002 \001(\005\022\032\n\022load_balance_token\030\003 \001" +
-      "(\t\022\024\n\014drop_request\030\004 \001(\0102b\n\014LoadBalancer" +
-      "\022R\n\013BalanceLoad\022\036.grpc.lb.v1.LoadBalance" +
-      "Request\032\037.grpc.lb.v1.LoadBalanceResponse" +
-      "(\0010\001B%\n\016io.grpc.grpclbB\021LoadBalancerProt" +
-      "oP\001b\006proto3"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-          com.google.protobuf.DurationProto.getDescriptor(),
-        }, assigner);
-    internal_static_grpc_lb_v1_LoadBalanceRequest_descriptor =
-      getDescriptor().getMessageTypes().get(0);
-    internal_static_grpc_lb_v1_LoadBalanceRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_lb_v1_LoadBalanceRequest_descriptor,
-        new java.lang.String[] { "InitialRequest", "ClientStats", "LoadBalanceRequestType", });
-    internal_static_grpc_lb_v1_InitialLoadBalanceRequest_descriptor =
-      getDescriptor().getMessageTypes().get(1);
-    internal_static_grpc_lb_v1_InitialLoadBalanceRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_lb_v1_InitialLoadBalanceRequest_descriptor,
-        new java.lang.String[] { "Name", });
-    internal_static_grpc_lb_v1_ClientStats_descriptor =
-      getDescriptor().getMessageTypes().get(2);
-    internal_static_grpc_lb_v1_ClientStats_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_lb_v1_ClientStats_descriptor,
-        new java.lang.String[] { "TotalRequests", "ClientRpcErrors", "DroppedRequests", });
-    internal_static_grpc_lb_v1_LoadBalanceResponse_descriptor =
-      getDescriptor().getMessageTypes().get(3);
-    internal_static_grpc_lb_v1_LoadBalanceResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_lb_v1_LoadBalanceResponse_descriptor,
-        new java.lang.String[] { "InitialResponse", "ServerList", "LoadBalanceResponseType", });
-    internal_static_grpc_lb_v1_InitialLoadBalanceResponse_descriptor =
-      getDescriptor().getMessageTypes().get(4);
-    internal_static_grpc_lb_v1_InitialLoadBalanceResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_lb_v1_InitialLoadBalanceResponse_descriptor,
-        new java.lang.String[] { "LoadBalancerDelegate", "ClientStatsReportInterval", });
-    internal_static_grpc_lb_v1_ServerList_descriptor =
-      getDescriptor().getMessageTypes().get(5);
-    internal_static_grpc_lb_v1_ServerList_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_lb_v1_ServerList_descriptor,
-        new java.lang.String[] { "Servers", "ExpirationInterval", });
-    internal_static_grpc_lb_v1_Server_descriptor =
-      getDescriptor().getMessageTypes().get(6);
-    internal_static_grpc_lb_v1_Server_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_lb_v1_Server_descriptor,
-        new java.lang.String[] { "IpAddress", "Port", "LoadBalanceToken", "DropRequest", });
-    com.google.protobuf.DurationProto.getDescriptor();
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/Server.java b/grpclb/src/generated/main/java/io/grpc/grpclb/Server.java
deleted file mode 100644
index f0e20c12aea..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/Server.java
+++ /dev/null
@@ -1,777 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-/**
- * Protobuf type {@code grpc.lb.v1.Server}
- */
-public  final class Server extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.lb.v1.Server)
-    ServerOrBuilder {
-  // Use Server.newBuilder() to construct.
-  private Server(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private Server() {
-    ipAddress_ = com.google.protobuf.ByteString.EMPTY;
-    port_ = 0;
-    loadBalanceToken_ = "";
-    dropRequest_ = false;
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private Server(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-
-            ipAddress_ = input.readBytes();
-            break;
-          }
-          case 16: {
-
-            port_ = input.readInt32();
-            break;
-          }
-          case 26: {
-            java.lang.String s = input.readStringRequireUtf8();
-
-            loadBalanceToken_ = s;
-            break;
-          }
-          case 32: {
-
-            dropRequest_ = input.readBool();
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_Server_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_Server_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.grpclb.Server.class, io.grpc.grpclb.Server.Builder.class);
-  }
-
-  public static final int IP_ADDRESS_FIELD_NUMBER = 1;
-  private com.google.protobuf.ByteString ipAddress_;
-  /**
-   * <pre>
-   * A resolved address for the server, serialized in network-byte-order. It may
-   * either be an IPv4 or IPv6 address.
-   * </pre>
-   *
-   * <code>bytes ip_address = 1;</code>
-   */
-  public com.google.protobuf.ByteString getIpAddress() {
-    return ipAddress_;
-  }
-
-  public static final int PORT_FIELD_NUMBER = 2;
-  private int port_;
-  /**
-   * <pre>
-   * A resolved port number for the server.
-   * </pre>
-   *
-   * <code>int32 port = 2;</code>
-   */
-  public int getPort() {
-    return port_;
-  }
-
-  public static final int LOAD_BALANCE_TOKEN_FIELD_NUMBER = 3;
-  private volatile java.lang.Object loadBalanceToken_;
-  /**
-   * <pre>
-   * An opaque but printable token given to the frontend for each pick. All
-   * frontend requests for that pick must include the token in its initial
-   * metadata. The token is used by the backend to verify the request and to
-   * allow the backend to report load to the gRPC LB system.
-   * </pre>
-   *
-   * <code>string load_balance_token = 3;</code>
-   */
-  public java.lang.String getLoadBalanceToken() {
-    java.lang.Object ref = loadBalanceToken_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      loadBalanceToken_ = s;
-      return s;
-    }
-  }
-  /**
-   * <pre>
-   * An opaque but printable token given to the frontend for each pick. All
-   * frontend requests for that pick must include the token in its initial
-   * metadata. The token is used by the backend to verify the request and to
-   * allow the backend to report load to the gRPC LB system.
-   * </pre>
-   *
-   * <code>string load_balance_token = 3;</code>
-   */
-  public com.google.protobuf.ByteString
-      getLoadBalanceTokenBytes() {
-    java.lang.Object ref = loadBalanceToken_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      loadBalanceToken_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  public static final int DROP_REQUEST_FIELD_NUMBER = 4;
-  private boolean dropRequest_;
-  /**
-   * <pre>
-   * Indicates whether this particular request should be dropped by the client
-   * when this server is chosen from the list.
-   * </pre>
-   *
-   * <code>bool drop_request = 4;</code>
-   */
-  public boolean getDropRequest() {
-    return dropRequest_;
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (!ipAddress_.isEmpty()) {
-      output.writeBytes(1, ipAddress_);
-    }
-    if (port_ != 0) {
-      output.writeInt32(2, port_);
-    }
-    if (!getLoadBalanceTokenBytes().isEmpty()) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 3, loadBalanceToken_);
-    }
-    if (dropRequest_ != false) {
-      output.writeBool(4, dropRequest_);
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (!ipAddress_.isEmpty()) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeBytesSize(1, ipAddress_);
-    }
-    if (port_ != 0) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeInt32Size(2, port_);
-    }
-    if (!getLoadBalanceTokenBytes().isEmpty()) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, loadBalanceToken_);
-    }
-    if (dropRequest_ != false) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeBoolSize(4, dropRequest_);
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.grpclb.Server)) {
-      return super.equals(obj);
-    }
-    io.grpc.grpclb.Server other = (io.grpc.grpclb.Server) obj;
-
-    boolean result = true;
-    result = result && getIpAddress()
-        .equals(other.getIpAddress());
-    result = result && (getPort()
-        == other.getPort());
-    result = result && getLoadBalanceToken()
-        .equals(other.getLoadBalanceToken());
-    result = result && (getDropRequest()
-        == other.getDropRequest());
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (37 * hash) + IP_ADDRESS_FIELD_NUMBER;
-    hash = (53 * hash) + getIpAddress().hashCode();
-    hash = (37 * hash) + PORT_FIELD_NUMBER;
-    hash = (53 * hash) + getPort();
-    hash = (37 * hash) + LOAD_BALANCE_TOKEN_FIELD_NUMBER;
-    hash = (53 * hash) + getLoadBalanceToken().hashCode();
-    hash = (37 * hash) + DROP_REQUEST_FIELD_NUMBER;
-    hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
-        getDropRequest());
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.grpclb.Server parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.Server parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.Server parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.Server parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.Server parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.Server parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.Server parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.Server parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.Server parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.Server parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.grpclb.Server prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.lb.v1.Server}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.lb.v1.Server)
-      io.grpc.grpclb.ServerOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_Server_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_Server_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.grpclb.Server.class, io.grpc.grpclb.Server.Builder.class);
-    }
-
-    // Construct using io.grpc.grpclb.Server.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      ipAddress_ = com.google.protobuf.ByteString.EMPTY;
-
-      port_ = 0;
-
-      loadBalanceToken_ = "";
-
-      dropRequest_ = false;
-
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_Server_descriptor;
-    }
-
-    public io.grpc.grpclb.Server getDefaultInstanceForType() {
-      return io.grpc.grpclb.Server.getDefaultInstance();
-    }
-
-    public io.grpc.grpclb.Server build() {
-      io.grpc.grpclb.Server result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.grpclb.Server buildPartial() {
-      io.grpc.grpclb.Server result = new io.grpc.grpclb.Server(this);
-      result.ipAddress_ = ipAddress_;
-      result.port_ = port_;
-      result.loadBalanceToken_ = loadBalanceToken_;
-      result.dropRequest_ = dropRequest_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.grpclb.Server) {
-        return mergeFrom((io.grpc.grpclb.Server)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.grpclb.Server other) {
-      if (other == io.grpc.grpclb.Server.getDefaultInstance()) return this;
-      if (other.getIpAddress() != com.google.protobuf.ByteString.EMPTY) {
-        setIpAddress(other.getIpAddress());
-      }
-      if (other.getPort() != 0) {
-        setPort(other.getPort());
-      }
-      if (!other.getLoadBalanceToken().isEmpty()) {
-        loadBalanceToken_ = other.loadBalanceToken_;
-        onChanged();
-      }
-      if (other.getDropRequest() != false) {
-        setDropRequest(other.getDropRequest());
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.grpclb.Server parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.grpclb.Server) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-
-    private com.google.protobuf.ByteString ipAddress_ = com.google.protobuf.ByteString.EMPTY;
-    /**
-     * <pre>
-     * A resolved address for the server, serialized in network-byte-order. It may
-     * either be an IPv4 or IPv6 address.
-     * </pre>
-     *
-     * <code>bytes ip_address = 1;</code>
-     */
-    public com.google.protobuf.ByteString getIpAddress() {
-      return ipAddress_;
-    }
-    /**
-     * <pre>
-     * A resolved address for the server, serialized in network-byte-order. It may
-     * either be an IPv4 or IPv6 address.
-     * </pre>
-     *
-     * <code>bytes ip_address = 1;</code>
-     */
-    public Builder setIpAddress(com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  
-      ipAddress_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * A resolved address for the server, serialized in network-byte-order. It may
-     * either be an IPv4 or IPv6 address.
-     * </pre>
-     *
-     * <code>bytes ip_address = 1;</code>
-     */
-    public Builder clearIpAddress() {
-      
-      ipAddress_ = getDefaultInstance().getIpAddress();
-      onChanged();
-      return this;
-    }
-
-    private int port_ ;
-    /**
-     * <pre>
-     * A resolved port number for the server.
-     * </pre>
-     *
-     * <code>int32 port = 2;</code>
-     */
-    public int getPort() {
-      return port_;
-    }
-    /**
-     * <pre>
-     * A resolved port number for the server.
-     * </pre>
-     *
-     * <code>int32 port = 2;</code>
-     */
-    public Builder setPort(int value) {
-      
-      port_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * A resolved port number for the server.
-     * </pre>
-     *
-     * <code>int32 port = 2;</code>
-     */
-    public Builder clearPort() {
-      
-      port_ = 0;
-      onChanged();
-      return this;
-    }
-
-    private java.lang.Object loadBalanceToken_ = "";
-    /**
-     * <pre>
-     * An opaque but printable token given to the frontend for each pick. All
-     * frontend requests for that pick must include the token in its initial
-     * metadata. The token is used by the backend to verify the request and to
-     * allow the backend to report load to the gRPC LB system.
-     * </pre>
-     *
-     * <code>string load_balance_token = 3;</code>
-     */
-    public java.lang.String getLoadBalanceToken() {
-      java.lang.Object ref = loadBalanceToken_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        loadBalanceToken_ = s;
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <pre>
-     * An opaque but printable token given to the frontend for each pick. All
-     * frontend requests for that pick must include the token in its initial
-     * metadata. The token is used by the backend to verify the request and to
-     * allow the backend to report load to the gRPC LB system.
-     * </pre>
-     *
-     * <code>string load_balance_token = 3;</code>
-     */
-    public com.google.protobuf.ByteString
-        getLoadBalanceTokenBytes() {
-      java.lang.Object ref = loadBalanceToken_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        loadBalanceToken_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <pre>
-     * An opaque but printable token given to the frontend for each pick. All
-     * frontend requests for that pick must include the token in its initial
-     * metadata. The token is used by the backend to verify the request and to
-     * allow the backend to report load to the gRPC LB system.
-     * </pre>
-     *
-     * <code>string load_balance_token = 3;</code>
-     */
-    public Builder setLoadBalanceToken(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  
-      loadBalanceToken_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * An opaque but printable token given to the frontend for each pick. All
-     * frontend requests for that pick must include the token in its initial
-     * metadata. The token is used by the backend to verify the request and to
-     * allow the backend to report load to the gRPC LB system.
-     * </pre>
-     *
-     * <code>string load_balance_token = 3;</code>
-     */
-    public Builder clearLoadBalanceToken() {
-      
-      loadBalanceToken_ = getDefaultInstance().getLoadBalanceToken();
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * An opaque but printable token given to the frontend for each pick. All
-     * frontend requests for that pick must include the token in its initial
-     * metadata. The token is used by the backend to verify the request and to
-     * allow the backend to report load to the gRPC LB system.
-     * </pre>
-     *
-     * <code>string load_balance_token = 3;</code>
-     */
-    public Builder setLoadBalanceTokenBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      
-      loadBalanceToken_ = value;
-      onChanged();
-      return this;
-    }
-
-    private boolean dropRequest_ ;
-    /**
-     * <pre>
-     * Indicates whether this particular request should be dropped by the client
-     * when this server is chosen from the list.
-     * </pre>
-     *
-     * <code>bool drop_request = 4;</code>
-     */
-    public boolean getDropRequest() {
-      return dropRequest_;
-    }
-    /**
-     * <pre>
-     * Indicates whether this particular request should be dropped by the client
-     * when this server is chosen from the list.
-     * </pre>
-     *
-     * <code>bool drop_request = 4;</code>
-     */
-    public Builder setDropRequest(boolean value) {
-      
-      dropRequest_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Indicates whether this particular request should be dropped by the client
-     * when this server is chosen from the list.
-     * </pre>
-     *
-     * <code>bool drop_request = 4;</code>
-     */
-    public Builder clearDropRequest() {
-      
-      dropRequest_ = false;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.lb.v1.Server)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.lb.v1.Server)
-  private static final io.grpc.grpclb.Server DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.grpclb.Server();
-  }
-
-  public static io.grpc.grpclb.Server getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<Server>
-      PARSER = new com.google.protobuf.AbstractParser<Server>() {
-    public Server parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new Server(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<Server> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<Server> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.grpclb.Server getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/ServerList.java b/grpclb/src/generated/main/java/io/grpc/grpclb/ServerList.java
deleted file mode 100644
index 003b9a33906..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/ServerList.java
+++ /dev/null
@@ -1,1141 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-/**
- * Protobuf type {@code grpc.lb.v1.ServerList}
- */
-public  final class ServerList extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.lb.v1.ServerList)
-    ServerListOrBuilder {
-  // Use ServerList.newBuilder() to construct.
-  private ServerList(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private ServerList() {
-    servers_ = java.util.Collections.emptyList();
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private ServerList(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
-              servers_ = new java.util.ArrayList<io.grpc.grpclb.Server>();
-              mutable_bitField0_ |= 0x00000001;
-            }
-            servers_.add(
-                input.readMessage(io.grpc.grpclb.Server.parser(), extensionRegistry));
-            break;
-          }
-          case 26: {
-            com.google.protobuf.Duration.Builder subBuilder = null;
-            if (expirationInterval_ != null) {
-              subBuilder = expirationInterval_.toBuilder();
-            }
-            expirationInterval_ = input.readMessage(com.google.protobuf.Duration.parser(), extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom(expirationInterval_);
-              expirationInterval_ = subBuilder.buildPartial();
-            }
-
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
-        servers_ = java.util.Collections.unmodifiableList(servers_);
-      }
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_ServerList_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_ServerList_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.grpclb.ServerList.class, io.grpc.grpclb.ServerList.Builder.class);
-  }
-
-  private int bitField0_;
-  public static final int SERVERS_FIELD_NUMBER = 1;
-  private java.util.List<io.grpc.grpclb.Server> servers_;
-  /**
-   * <pre>
-   * Contains a list of servers selected by the load balancer. The list will
-   * be updated when server resolutions change or as needed to balance load
-   * across more servers. The client should consume the server list in order
-   * unless instructed otherwise via the client_config.
-   * </pre>
-   *
-   * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-   */
-  public java.util.List<io.grpc.grpclb.Server> getServersList() {
-    return servers_;
-  }
-  /**
-   * <pre>
-   * Contains a list of servers selected by the load balancer. The list will
-   * be updated when server resolutions change or as needed to balance load
-   * across more servers. The client should consume the server list in order
-   * unless instructed otherwise via the client_config.
-   * </pre>
-   *
-   * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-   */
-  public java.util.List<? extends io.grpc.grpclb.ServerOrBuilder> 
-      getServersOrBuilderList() {
-    return servers_;
-  }
-  /**
-   * <pre>
-   * Contains a list of servers selected by the load balancer. The list will
-   * be updated when server resolutions change or as needed to balance load
-   * across more servers. The client should consume the server list in order
-   * unless instructed otherwise via the client_config.
-   * </pre>
-   *
-   * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-   */
-  public int getServersCount() {
-    return servers_.size();
-  }
-  /**
-   * <pre>
-   * Contains a list of servers selected by the load balancer. The list will
-   * be updated when server resolutions change or as needed to balance load
-   * across more servers. The client should consume the server list in order
-   * unless instructed otherwise via the client_config.
-   * </pre>
-   *
-   * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-   */
-  public io.grpc.grpclb.Server getServers(int index) {
-    return servers_.get(index);
-  }
-  /**
-   * <pre>
-   * Contains a list of servers selected by the load balancer. The list will
-   * be updated when server resolutions change or as needed to balance load
-   * across more servers. The client should consume the server list in order
-   * unless instructed otherwise via the client_config.
-   * </pre>
-   *
-   * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-   */
-  public io.grpc.grpclb.ServerOrBuilder getServersOrBuilder(
-      int index) {
-    return servers_.get(index);
-  }
-
-  public static final int EXPIRATION_INTERVAL_FIELD_NUMBER = 3;
-  private com.google.protobuf.Duration expirationInterval_;
-  /**
-   * <pre>
-   * Indicates the amount of time that the client should consider this server
-   * list as valid. It may be considered stale after waiting this interval of
-   * time after receiving the list. If the interval is not positive, the
-   * client can assume the list is valid until the next list is received.
-   * </pre>
-   *
-   * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-   */
-  public boolean hasExpirationInterval() {
-    return expirationInterval_ != null;
-  }
-  /**
-   * <pre>
-   * Indicates the amount of time that the client should consider this server
-   * list as valid. It may be considered stale after waiting this interval of
-   * time after receiving the list. If the interval is not positive, the
-   * client can assume the list is valid until the next list is received.
-   * </pre>
-   *
-   * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-   */
-  public com.google.protobuf.Duration getExpirationInterval() {
-    return expirationInterval_ == null ? com.google.protobuf.Duration.getDefaultInstance() : expirationInterval_;
-  }
-  /**
-   * <pre>
-   * Indicates the amount of time that the client should consider this server
-   * list as valid. It may be considered stale after waiting this interval of
-   * time after receiving the list. If the interval is not positive, the
-   * client can assume the list is valid until the next list is received.
-   * </pre>
-   *
-   * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-   */
-  public com.google.protobuf.DurationOrBuilder getExpirationIntervalOrBuilder() {
-    return getExpirationInterval();
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    for (int i = 0; i < servers_.size(); i++) {
-      output.writeMessage(1, servers_.get(i));
-    }
-    if (expirationInterval_ != null) {
-      output.writeMessage(3, getExpirationInterval());
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    for (int i = 0; i < servers_.size(); i++) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(1, servers_.get(i));
-    }
-    if (expirationInterval_ != null) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(3, getExpirationInterval());
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.grpclb.ServerList)) {
-      return super.equals(obj);
-    }
-    io.grpc.grpclb.ServerList other = (io.grpc.grpclb.ServerList) obj;
-
-    boolean result = true;
-    result = result && getServersList()
-        .equals(other.getServersList());
-    result = result && (hasExpirationInterval() == other.hasExpirationInterval());
-    if (hasExpirationInterval()) {
-      result = result && getExpirationInterval()
-          .equals(other.getExpirationInterval());
-    }
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    if (getServersCount() > 0) {
-      hash = (37 * hash) + SERVERS_FIELD_NUMBER;
-      hash = (53 * hash) + getServersList().hashCode();
-    }
-    if (hasExpirationInterval()) {
-      hash = (37 * hash) + EXPIRATION_INTERVAL_FIELD_NUMBER;
-      hash = (53 * hash) + getExpirationInterval().hashCode();
-    }
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.grpclb.ServerList parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.ServerList parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.ServerList parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.grpclb.ServerList parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.grpclb.ServerList parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.ServerList parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.ServerList parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.ServerList parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.grpclb.ServerList parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.grpclb.ServerList parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.grpclb.ServerList prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.lb.v1.ServerList}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.lb.v1.ServerList)
-      io.grpc.grpclb.ServerListOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_ServerList_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_ServerList_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.grpclb.ServerList.class, io.grpc.grpclb.ServerList.Builder.class);
-    }
-
-    // Construct using io.grpc.grpclb.ServerList.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-        getServersFieldBuilder();
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      if (serversBuilder_ == null) {
-        servers_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000001);
-      } else {
-        serversBuilder_.clear();
-      }
-      if (expirationIntervalBuilder_ == null) {
-        expirationInterval_ = null;
-      } else {
-        expirationInterval_ = null;
-        expirationIntervalBuilder_ = null;
-      }
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.grpclb.LoadBalancerProto.internal_static_grpc_lb_v1_ServerList_descriptor;
-    }
-
-    public io.grpc.grpclb.ServerList getDefaultInstanceForType() {
-      return io.grpc.grpclb.ServerList.getDefaultInstance();
-    }
-
-    public io.grpc.grpclb.ServerList build() {
-      io.grpc.grpclb.ServerList result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.grpclb.ServerList buildPartial() {
-      io.grpc.grpclb.ServerList result = new io.grpc.grpclb.ServerList(this);
-      int from_bitField0_ = bitField0_;
-      int to_bitField0_ = 0;
-      if (serversBuilder_ == null) {
-        if (((bitField0_ & 0x00000001) == 0x00000001)) {
-          servers_ = java.util.Collections.unmodifiableList(servers_);
-          bitField0_ = (bitField0_ & ~0x00000001);
-        }
-        result.servers_ = servers_;
-      } else {
-        result.servers_ = serversBuilder_.build();
-      }
-      if (expirationIntervalBuilder_ == null) {
-        result.expirationInterval_ = expirationInterval_;
-      } else {
-        result.expirationInterval_ = expirationIntervalBuilder_.build();
-      }
-      result.bitField0_ = to_bitField0_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.grpclb.ServerList) {
-        return mergeFrom((io.grpc.grpclb.ServerList)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.grpclb.ServerList other) {
-      if (other == io.grpc.grpclb.ServerList.getDefaultInstance()) return this;
-      if (serversBuilder_ == null) {
-        if (!other.servers_.isEmpty()) {
-          if (servers_.isEmpty()) {
-            servers_ = other.servers_;
-            bitField0_ = (bitField0_ & ~0x00000001);
-          } else {
-            ensureServersIsMutable();
-            servers_.addAll(other.servers_);
-          }
-          onChanged();
-        }
-      } else {
-        if (!other.servers_.isEmpty()) {
-          if (serversBuilder_.isEmpty()) {
-            serversBuilder_.dispose();
-            serversBuilder_ = null;
-            servers_ = other.servers_;
-            bitField0_ = (bitField0_ & ~0x00000001);
-            serversBuilder_ = 
-              com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
-                 getServersFieldBuilder() : null;
-          } else {
-            serversBuilder_.addAllMessages(other.servers_);
-          }
-        }
-      }
-      if (other.hasExpirationInterval()) {
-        mergeExpirationInterval(other.getExpirationInterval());
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.grpclb.ServerList parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.grpclb.ServerList) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int bitField0_;
-
-    private java.util.List<io.grpc.grpclb.Server> servers_ =
-      java.util.Collections.emptyList();
-    private void ensureServersIsMutable() {
-      if (!((bitField0_ & 0x00000001) == 0x00000001)) {
-        servers_ = new java.util.ArrayList<io.grpc.grpclb.Server>(servers_);
-        bitField0_ |= 0x00000001;
-       }
-    }
-
-    private com.google.protobuf.RepeatedFieldBuilderV3<
-        io.grpc.grpclb.Server, io.grpc.grpclb.Server.Builder, io.grpc.grpclb.ServerOrBuilder> serversBuilder_;
-
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public java.util.List<io.grpc.grpclb.Server> getServersList() {
-      if (serversBuilder_ == null) {
-        return java.util.Collections.unmodifiableList(servers_);
-      } else {
-        return serversBuilder_.getMessageList();
-      }
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public int getServersCount() {
-      if (serversBuilder_ == null) {
-        return servers_.size();
-      } else {
-        return serversBuilder_.getCount();
-      }
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public io.grpc.grpclb.Server getServers(int index) {
-      if (serversBuilder_ == null) {
-        return servers_.get(index);
-      } else {
-        return serversBuilder_.getMessage(index);
-      }
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public Builder setServers(
-        int index, io.grpc.grpclb.Server value) {
-      if (serversBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        ensureServersIsMutable();
-        servers_.set(index, value);
-        onChanged();
-      } else {
-        serversBuilder_.setMessage(index, value);
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public Builder setServers(
-        int index, io.grpc.grpclb.Server.Builder builderForValue) {
-      if (serversBuilder_ == null) {
-        ensureServersIsMutable();
-        servers_.set(index, builderForValue.build());
-        onChanged();
-      } else {
-        serversBuilder_.setMessage(index, builderForValue.build());
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public Builder addServers(io.grpc.grpclb.Server value) {
-      if (serversBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        ensureServersIsMutable();
-        servers_.add(value);
-        onChanged();
-      } else {
-        serversBuilder_.addMessage(value);
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public Builder addServers(
-        int index, io.grpc.grpclb.Server value) {
-      if (serversBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        ensureServersIsMutable();
-        servers_.add(index, value);
-        onChanged();
-      } else {
-        serversBuilder_.addMessage(index, value);
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public Builder addServers(
-        io.grpc.grpclb.Server.Builder builderForValue) {
-      if (serversBuilder_ == null) {
-        ensureServersIsMutable();
-        servers_.add(builderForValue.build());
-        onChanged();
-      } else {
-        serversBuilder_.addMessage(builderForValue.build());
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public Builder addServers(
-        int index, io.grpc.grpclb.Server.Builder builderForValue) {
-      if (serversBuilder_ == null) {
-        ensureServersIsMutable();
-        servers_.add(index, builderForValue.build());
-        onChanged();
-      } else {
-        serversBuilder_.addMessage(index, builderForValue.build());
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public Builder addAllServers(
-        java.lang.Iterable<? extends io.grpc.grpclb.Server> values) {
-      if (serversBuilder_ == null) {
-        ensureServersIsMutable();
-        com.google.protobuf.AbstractMessageLite.Builder.addAll(
-            values, servers_);
-        onChanged();
-      } else {
-        serversBuilder_.addAllMessages(values);
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public Builder clearServers() {
-      if (serversBuilder_ == null) {
-        servers_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000001);
-        onChanged();
-      } else {
-        serversBuilder_.clear();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public Builder removeServers(int index) {
-      if (serversBuilder_ == null) {
-        ensureServersIsMutable();
-        servers_.remove(index);
-        onChanged();
-      } else {
-        serversBuilder_.remove(index);
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public io.grpc.grpclb.Server.Builder getServersBuilder(
-        int index) {
-      return getServersFieldBuilder().getBuilder(index);
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public io.grpc.grpclb.ServerOrBuilder getServersOrBuilder(
-        int index) {
-      if (serversBuilder_ == null) {
-        return servers_.get(index);  } else {
-        return serversBuilder_.getMessageOrBuilder(index);
-      }
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public java.util.List<? extends io.grpc.grpclb.ServerOrBuilder> 
-         getServersOrBuilderList() {
-      if (serversBuilder_ != null) {
-        return serversBuilder_.getMessageOrBuilderList();
-      } else {
-        return java.util.Collections.unmodifiableList(servers_);
-      }
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public io.grpc.grpclb.Server.Builder addServersBuilder() {
-      return getServersFieldBuilder().addBuilder(
-          io.grpc.grpclb.Server.getDefaultInstance());
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public io.grpc.grpclb.Server.Builder addServersBuilder(
-        int index) {
-      return getServersFieldBuilder().addBuilder(
-          index, io.grpc.grpclb.Server.getDefaultInstance());
-    }
-    /**
-     * <pre>
-     * Contains a list of servers selected by the load balancer. The list will
-     * be updated when server resolutions change or as needed to balance load
-     * across more servers. The client should consume the server list in order
-     * unless instructed otherwise via the client_config.
-     * </pre>
-     *
-     * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-     */
-    public java.util.List<io.grpc.grpclb.Server.Builder> 
-         getServersBuilderList() {
-      return getServersFieldBuilder().getBuilderList();
-    }
-    private com.google.protobuf.RepeatedFieldBuilderV3<
-        io.grpc.grpclb.Server, io.grpc.grpclb.Server.Builder, io.grpc.grpclb.ServerOrBuilder> 
-        getServersFieldBuilder() {
-      if (serversBuilder_ == null) {
-        serversBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-            io.grpc.grpclb.Server, io.grpc.grpclb.Server.Builder, io.grpc.grpclb.ServerOrBuilder>(
-                servers_,
-                ((bitField0_ & 0x00000001) == 0x00000001),
-                getParentForChildren(),
-                isClean());
-        servers_ = null;
-      }
-      return serversBuilder_;
-    }
-
-    private com.google.protobuf.Duration expirationInterval_ = null;
-    private com.google.protobuf.SingleFieldBuilderV3<
-        com.google.protobuf.Duration, com.google.protobuf.Duration.Builder, com.google.protobuf.DurationOrBuilder> expirationIntervalBuilder_;
-    /**
-     * <pre>
-     * Indicates the amount of time that the client should consider this server
-     * list as valid. It may be considered stale after waiting this interval of
-     * time after receiving the list. If the interval is not positive, the
-     * client can assume the list is valid until the next list is received.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-     */
-    public boolean hasExpirationInterval() {
-      return expirationIntervalBuilder_ != null || expirationInterval_ != null;
-    }
-    /**
-     * <pre>
-     * Indicates the amount of time that the client should consider this server
-     * list as valid. It may be considered stale after waiting this interval of
-     * time after receiving the list. If the interval is not positive, the
-     * client can assume the list is valid until the next list is received.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-     */
-    public com.google.protobuf.Duration getExpirationInterval() {
-      if (expirationIntervalBuilder_ == null) {
-        return expirationInterval_ == null ? com.google.protobuf.Duration.getDefaultInstance() : expirationInterval_;
-      } else {
-        return expirationIntervalBuilder_.getMessage();
-      }
-    }
-    /**
-     * <pre>
-     * Indicates the amount of time that the client should consider this server
-     * list as valid. It may be considered stale after waiting this interval of
-     * time after receiving the list. If the interval is not positive, the
-     * client can assume the list is valid until the next list is received.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-     */
-    public Builder setExpirationInterval(com.google.protobuf.Duration value) {
-      if (expirationIntervalBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        expirationInterval_ = value;
-        onChanged();
-      } else {
-        expirationIntervalBuilder_.setMessage(value);
-      }
-
-      return this;
-    }
-    /**
-     * <pre>
-     * Indicates the amount of time that the client should consider this server
-     * list as valid. It may be considered stale after waiting this interval of
-     * time after receiving the list. If the interval is not positive, the
-     * client can assume the list is valid until the next list is received.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-     */
-    public Builder setExpirationInterval(
-        com.google.protobuf.Duration.Builder builderForValue) {
-      if (expirationIntervalBuilder_ == null) {
-        expirationInterval_ = builderForValue.build();
-        onChanged();
-      } else {
-        expirationIntervalBuilder_.setMessage(builderForValue.build());
-      }
-
-      return this;
-    }
-    /**
-     * <pre>
-     * Indicates the amount of time that the client should consider this server
-     * list as valid. It may be considered stale after waiting this interval of
-     * time after receiving the list. If the interval is not positive, the
-     * client can assume the list is valid until the next list is received.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-     */
-    public Builder mergeExpirationInterval(com.google.protobuf.Duration value) {
-      if (expirationIntervalBuilder_ == null) {
-        if (expirationInterval_ != null) {
-          expirationInterval_ =
-            com.google.protobuf.Duration.newBuilder(expirationInterval_).mergeFrom(value).buildPartial();
-        } else {
-          expirationInterval_ = value;
-        }
-        onChanged();
-      } else {
-        expirationIntervalBuilder_.mergeFrom(value);
-      }
-
-      return this;
-    }
-    /**
-     * <pre>
-     * Indicates the amount of time that the client should consider this server
-     * list as valid. It may be considered stale after waiting this interval of
-     * time after receiving the list. If the interval is not positive, the
-     * client can assume the list is valid until the next list is received.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-     */
-    public Builder clearExpirationInterval() {
-      if (expirationIntervalBuilder_ == null) {
-        expirationInterval_ = null;
-        onChanged();
-      } else {
-        expirationInterval_ = null;
-        expirationIntervalBuilder_ = null;
-      }
-
-      return this;
-    }
-    /**
-     * <pre>
-     * Indicates the amount of time that the client should consider this server
-     * list as valid. It may be considered stale after waiting this interval of
-     * time after receiving the list. If the interval is not positive, the
-     * client can assume the list is valid until the next list is received.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-     */
-    public com.google.protobuf.Duration.Builder getExpirationIntervalBuilder() {
-      
-      onChanged();
-      return getExpirationIntervalFieldBuilder().getBuilder();
-    }
-    /**
-     * <pre>
-     * Indicates the amount of time that the client should consider this server
-     * list as valid. It may be considered stale after waiting this interval of
-     * time after receiving the list. If the interval is not positive, the
-     * client can assume the list is valid until the next list is received.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-     */
-    public com.google.protobuf.DurationOrBuilder getExpirationIntervalOrBuilder() {
-      if (expirationIntervalBuilder_ != null) {
-        return expirationIntervalBuilder_.getMessageOrBuilder();
-      } else {
-        return expirationInterval_ == null ?
-            com.google.protobuf.Duration.getDefaultInstance() : expirationInterval_;
-      }
-    }
-    /**
-     * <pre>
-     * Indicates the amount of time that the client should consider this server
-     * list as valid. It may be considered stale after waiting this interval of
-     * time after receiving the list. If the interval is not positive, the
-     * client can assume the list is valid until the next list is received.
-     * </pre>
-     *
-     * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-     */
-    private com.google.protobuf.SingleFieldBuilderV3<
-        com.google.protobuf.Duration, com.google.protobuf.Duration.Builder, com.google.protobuf.DurationOrBuilder> 
-        getExpirationIntervalFieldBuilder() {
-      if (expirationIntervalBuilder_ == null) {
-        expirationIntervalBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-            com.google.protobuf.Duration, com.google.protobuf.Duration.Builder, com.google.protobuf.DurationOrBuilder>(
-                getExpirationInterval(),
-                getParentForChildren(),
-                isClean());
-        expirationInterval_ = null;
-      }
-      return expirationIntervalBuilder_;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.lb.v1.ServerList)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.lb.v1.ServerList)
-  private static final io.grpc.grpclb.ServerList DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.grpclb.ServerList();
-  }
-
-  public static io.grpc.grpclb.ServerList getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<ServerList>
-      PARSER = new com.google.protobuf.AbstractParser<ServerList>() {
-    public ServerList parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new ServerList(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<ServerList> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<ServerList> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.grpclb.ServerList getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/ServerListOrBuilder.java b/grpclb/src/generated/main/java/io/grpc/grpclb/ServerListOrBuilder.java
deleted file mode 100644
index 883b5986c90..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/ServerListOrBuilder.java
+++ /dev/null
@@ -1,102 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-public interface ServerListOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.lb.v1.ServerList)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <pre>
-   * Contains a list of servers selected by the load balancer. The list will
-   * be updated when server resolutions change or as needed to balance load
-   * across more servers. The client should consume the server list in order
-   * unless instructed otherwise via the client_config.
-   * </pre>
-   *
-   * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-   */
-  java.util.List<io.grpc.grpclb.Server> 
-      getServersList();
-  /**
-   * <pre>
-   * Contains a list of servers selected by the load balancer. The list will
-   * be updated when server resolutions change or as needed to balance load
-   * across more servers. The client should consume the server list in order
-   * unless instructed otherwise via the client_config.
-   * </pre>
-   *
-   * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-   */
-  io.grpc.grpclb.Server getServers(int index);
-  /**
-   * <pre>
-   * Contains a list of servers selected by the load balancer. The list will
-   * be updated when server resolutions change or as needed to balance load
-   * across more servers. The client should consume the server list in order
-   * unless instructed otherwise via the client_config.
-   * </pre>
-   *
-   * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-   */
-  int getServersCount();
-  /**
-   * <pre>
-   * Contains a list of servers selected by the load balancer. The list will
-   * be updated when server resolutions change or as needed to balance load
-   * across more servers. The client should consume the server list in order
-   * unless instructed otherwise via the client_config.
-   * </pre>
-   *
-   * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-   */
-  java.util.List<? extends io.grpc.grpclb.ServerOrBuilder> 
-      getServersOrBuilderList();
-  /**
-   * <pre>
-   * Contains a list of servers selected by the load balancer. The list will
-   * be updated when server resolutions change or as needed to balance load
-   * across more servers. The client should consume the server list in order
-   * unless instructed otherwise via the client_config.
-   * </pre>
-   *
-   * <code>repeated .grpc.lb.v1.Server servers = 1;</code>
-   */
-  io.grpc.grpclb.ServerOrBuilder getServersOrBuilder(
-      int index);
-
-  /**
-   * <pre>
-   * Indicates the amount of time that the client should consider this server
-   * list as valid. It may be considered stale after waiting this interval of
-   * time after receiving the list. If the interval is not positive, the
-   * client can assume the list is valid until the next list is received.
-   * </pre>
-   *
-   * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-   */
-  boolean hasExpirationInterval();
-  /**
-   * <pre>
-   * Indicates the amount of time that the client should consider this server
-   * list as valid. It may be considered stale after waiting this interval of
-   * time after receiving the list. If the interval is not positive, the
-   * client can assume the list is valid until the next list is received.
-   * </pre>
-   *
-   * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-   */
-  com.google.protobuf.Duration getExpirationInterval();
-  /**
-   * <pre>
-   * Indicates the amount of time that the client should consider this server
-   * list as valid. It may be considered stale after waiting this interval of
-   * time after receiving the list. If the interval is not positive, the
-   * client can assume the list is valid until the next list is received.
-   * </pre>
-   *
-   * <code>.google.protobuf.Duration expiration_interval = 3;</code>
-   */
-  com.google.protobuf.DurationOrBuilder getExpirationIntervalOrBuilder();
-}
diff --git a/grpclb/src/generated/main/java/io/grpc/grpclb/ServerOrBuilder.java b/grpclb/src/generated/main/java/io/grpc/grpclb/ServerOrBuilder.java
deleted file mode 100644
index f508d170eb3..00000000000
--- a/grpclb/src/generated/main/java/io/grpc/grpclb/ServerOrBuilder.java
+++ /dev/null
@@ -1,62 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: load_balancer.proto
-
-package io.grpc.grpclb;
-
-public interface ServerOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.lb.v1.Server)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <pre>
-   * A resolved address for the server, serialized in network-byte-order. It may
-   * either be an IPv4 or IPv6 address.
-   * </pre>
-   *
-   * <code>bytes ip_address = 1;</code>
-   */
-  com.google.protobuf.ByteString getIpAddress();
-
-  /**
-   * <pre>
-   * A resolved port number for the server.
-   * </pre>
-   *
-   * <code>int32 port = 2;</code>
-   */
-  int getPort();
-
-  /**
-   * <pre>
-   * An opaque but printable token given to the frontend for each pick. All
-   * frontend requests for that pick must include the token in its initial
-   * metadata. The token is used by the backend to verify the request and to
-   * allow the backend to report load to the gRPC LB system.
-   * </pre>
-   *
-   * <code>string load_balance_token = 3;</code>
-   */
-  java.lang.String getLoadBalanceToken();
-  /**
-   * <pre>
-   * An opaque but printable token given to the frontend for each pick. All
-   * frontend requests for that pick must include the token in its initial
-   * metadata. The token is used by the backend to verify the request and to
-   * allow the backend to report load to the gRPC LB system.
-   * </pre>
-   *
-   * <code>string load_balance_token = 3;</code>
-   */
-  com.google.protobuf.ByteString
-      getLoadBalanceTokenBytes();
-
-  /**
-   * <pre>
-   * Indicates whether this particular request should be dropped by the client
-   * when this server is chosen from the list.
-   * </pre>
-   *
-   * <code>bool drop_request = 4;</code>
-   */
-  boolean getDropRequest();
-}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/BackendAddressGroup.java b/grpclb/src/main/java/io/grpc/grpclb/BackendAddressGroup.java
new file mode 100644
index 00000000000..f6154121d48
--- /dev/null
+++ b/grpclb/src/main/java/io/grpc/grpclb/BackendAddressGroup.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2017 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.grpclb;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.EquivalentAddressGroup;
+import javax.annotation.Nullable;
+
+final class BackendAddressGroup {
+  private final EquivalentAddressGroup addresses;
+  @Nullable
+  private final String token;
+
+  BackendAddressGroup(EquivalentAddressGroup addresses, @Nullable String token) {
+    this.addresses = checkNotNull(addresses, "addresses");
+    this.token = token;
+  }
+
+  EquivalentAddressGroup getAddresses() {
+    return addresses;
+  }
+
+  @Nullable
+  String getToken() {
+    return token;
+  }
+
+  @Override
+  public String toString() {
+    // This is printed in logs.  Be concise.
+    StringBuilder buffer = new StringBuilder();
+    buffer.append(addresses);
+    if (token != null) {
+      buffer.append("(").append(token).append(")");
+    }
+    return buffer.toString();
+  }
+}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/CachedSubchannelPool.java b/grpclb/src/main/java/io/grpc/grpclb/CachedSubchannelPool.java
new file mode 100644
index 00000000000..820915f0f2e
--- /dev/null
+++ b/grpclb/src/main/java/io/grpc/grpclb/CachedSubchannelPool.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright 2018 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.grpclb;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Attributes;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import java.util.HashMap;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A {@link SubchannelPool} that keeps returned {@link Subchannel}s for a given time before it's
+ * shut down by the pool.
+ */
+final class CachedSubchannelPool implements SubchannelPool {
+  private final HashMap<EquivalentAddressGroup, CacheEntry> cache =
+      new HashMap<>();
+
+  private final Helper helper;
+  private PooledSubchannelStateListener listener;
+
+  @VisibleForTesting
+  static final long SHUTDOWN_TIMEOUT_MS = 10000;
+
+  public CachedSubchannelPool(Helper helper) {
+    this.helper = checkNotNull(helper, "helper");
+  }
+
+  @Override
+  public void registerListener(PooledSubchannelStateListener listener) {
+    this.listener = checkNotNull(listener, "listener");
+  }
+
+  @Override
+  public Subchannel takeOrCreateSubchannel(
+      EquivalentAddressGroup eag, Attributes defaultAttributes) {
+    final CacheEntry entry = cache.remove(eag);
+    final Subchannel subchannel;
+    if (entry == null) {
+      subchannel =
+          helper.createSubchannel(
+              CreateSubchannelArgs.newBuilder()
+                  .setAddresses(eag)
+                  .setAttributes(defaultAttributes)
+                  .build());
+      subchannel.start(new SubchannelStateListener() {
+        @Override
+        public void onSubchannelState(ConnectivityStateInfo newState) {
+          updateCachedSubchannelState(subchannel, newState);
+          listener.onSubchannelState(subchannel, newState);
+        }
+      });
+    } else {
+      subchannel = entry.subchannel;
+      entry.shutdownTimer.cancel();
+      // Make the balancer up-to-date with the latest state in case it has changed while it's
+      // in the cache.
+      helper.getSynchronizationContext().execute(new Runnable() {
+          @Override
+          public void run() {
+            listener.onSubchannelState(subchannel, entry.state);
+          }
+        });
+    }
+    return subchannel;
+  }
+
+  private void updateCachedSubchannelState(
+      Subchannel subchannel, ConnectivityStateInfo newStateInfo) {
+    CacheEntry cached = cache.get(subchannel.getAddresses());
+    if (cached == null || cached.subchannel != subchannel) {
+      // Given subchannel is not cached.  Not our responsibility.
+      return;
+    }
+    cached.state = newStateInfo;
+  }
+
+  @Override
+  public void returnSubchannel(Subchannel subchannel, ConnectivityStateInfo lastKnownState) {
+    CacheEntry prev = cache.get(subchannel.getAddresses());
+    if (prev != null) {
+      // Returning the same Subchannel twice has no effect.
+      // Returning a different Subchannel for an already cached EAG will cause the
+      // latter Subchannel to be shutdown immediately.
+      if (prev.subchannel != subchannel) {
+        subchannel.shutdown();
+      }
+      return;
+    }
+    final ShutdownSubchannelTask shutdownTask = new ShutdownSubchannelTask(subchannel);
+    ScheduledHandle shutdownTimer =
+        helper.getSynchronizationContext().schedule(
+            shutdownTask, SHUTDOWN_TIMEOUT_MS, TimeUnit.MILLISECONDS,
+            helper.getScheduledExecutorService());
+    CacheEntry entry = new CacheEntry(subchannel, shutdownTimer, lastKnownState);
+    cache.put(subchannel.getAddresses(), entry);
+  }
+
+  @Override
+  public void clear() {
+    for (CacheEntry entry : cache.values()) {
+      entry.shutdownTimer.cancel();
+      entry.subchannel.shutdown();
+    }
+    cache.clear();
+  }
+
+  @VisibleForTesting
+  final class ShutdownSubchannelTask implements Runnable {
+    private final Subchannel subchannel;
+
+    private ShutdownSubchannelTask(Subchannel subchannel) {
+      this.subchannel = checkNotNull(subchannel, "subchannel");
+    }
+
+    // This runs in channelExecutor
+    @Override
+    public void run() {
+      CacheEntry entry = cache.remove(subchannel.getAddresses());
+      checkState(entry.subchannel == subchannel, "Inconsistent state");
+      subchannel.shutdown();
+    }
+  }
+
+  private static class CacheEntry {
+    final Subchannel subchannel;
+    final ScheduledHandle shutdownTimer;
+    ConnectivityStateInfo state;
+
+    CacheEntry(Subchannel subchannel, ScheduledHandle shutdownTimer, ConnectivityStateInfo state) {
+      this.subchannel = checkNotNull(subchannel, "subchannel");
+      this.shutdownTimer = checkNotNull(shutdownTimer, "shutdownTimer");
+      this.state = checkNotNull(state, "state");
+    }
+  }
+}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/DropType.java b/grpclb/src/main/java/io/grpc/grpclb/DropType.java
new file mode 100644
index 00000000000..704b79ee0ab
--- /dev/null
+++ b/grpclb/src/main/java/io/grpc/grpclb/DropType.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2017 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.grpclb;
+
+/**
+ * The reason for dropping a request as instructed by the remote balancer.
+ */
+enum DropType {
+    RATE_LIMITING,
+    LOAD_BALANCING
+}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbClientLoadRecorder.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbClientLoadRecorder.java
new file mode 100644
index 00000000000..fe928263ef9
--- /dev/null
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbClientLoadRecorder.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2017 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.grpclb;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import com.google.protobuf.util.Timestamps;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.internal.TimeProvider;
+import io.grpc.lb.v1.ClientStats;
+import io.grpc.lb.v1.ClientStatsPerToken;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicLongFieldUpdater;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Record and aggregate client-side load data for GRPCLB.  This records load occurred during the
+ * span of an LB stream with the remote load-balancer.
+ */
+@ThreadSafe
+final class GrpclbClientLoadRecorder extends ClientStreamTracer.Factory {
+
+  private static final AtomicLongFieldUpdater<GrpclbClientLoadRecorder> callsStartedUpdater =
+      AtomicLongFieldUpdater.newUpdater(GrpclbClientLoadRecorder.class, "callsStarted");
+  private static final AtomicLongFieldUpdater<GrpclbClientLoadRecorder> callsFinishedUpdater =
+      AtomicLongFieldUpdater.newUpdater(GrpclbClientLoadRecorder.class, "callsFinished");
+  private static final AtomicLongFieldUpdater<GrpclbClientLoadRecorder> callsFailedToSendUpdater =
+      AtomicLongFieldUpdater.newUpdater(GrpclbClientLoadRecorder.class, "callsFailedToSend");
+  private static final AtomicLongFieldUpdater<GrpclbClientLoadRecorder>
+      callsFinishedKnownReceivedUpdater =
+          AtomicLongFieldUpdater.newUpdater(
+              GrpclbClientLoadRecorder.class, "callsFinishedKnownReceived");
+
+  private final TimeProvider time;
+  @SuppressWarnings("unused")
+  private volatile long callsStarted;
+  @SuppressWarnings("unused")
+  private volatile long callsFinished;
+
+  private static final class LongHolder {
+    long num;
+  }
+
+  // Specific finish types
+  @GuardedBy("this")
+  private Map<String, LongHolder> callsDroppedPerToken = new HashMap<>(1);
+  @SuppressWarnings("unused")
+  private volatile long callsFailedToSend;
+  @SuppressWarnings("unused")
+  private volatile long callsFinishedKnownReceived;
+
+  GrpclbClientLoadRecorder(TimeProvider time) {
+    this.time = checkNotNull(time, "time provider");
+  }
+
+  @Override
+  public ClientStreamTracer newClientStreamTracer(
+      ClientStreamTracer.StreamInfo info, Metadata headers) {
+    callsStartedUpdater.getAndIncrement(this);
+    return new StreamTracer();
+  }
+
+  /**
+   * Records that a request has been dropped as instructed by the remote balancer.
+   */
+  void recordDroppedRequest(String token) {
+    callsStartedUpdater.getAndIncrement(this);
+    callsFinishedUpdater.getAndIncrement(this);
+
+    synchronized (this) {
+      LongHolder holder;
+      if ((holder = callsDroppedPerToken.get(token)) == null) {
+        callsDroppedPerToken.put(token, (holder = new LongHolder()));
+      }
+      holder.num++;
+    }
+  }
+
+  /**
+   * Generate the report with the data recorded this LB stream since the last report.
+   */
+  ClientStats generateLoadReport() {
+    ClientStats.Builder statsBuilder =
+        ClientStats.newBuilder()
+        .setTimestamp(Timestamps.fromNanos(time.currentTimeNanos()))
+        .setNumCallsStarted(callsStartedUpdater.getAndSet(this, 0))
+        .setNumCallsFinished(callsFinishedUpdater.getAndSet(this, 0))
+        .setNumCallsFinishedWithClientFailedToSend(callsFailedToSendUpdater.getAndSet(this, 0))
+        .setNumCallsFinishedKnownReceived(callsFinishedKnownReceivedUpdater.getAndSet(this, 0));
+
+    Map<String, LongHolder> localCallsDroppedPerToken = Collections.emptyMap();
+    synchronized (this) {
+      if (!callsDroppedPerToken.isEmpty()) {
+        localCallsDroppedPerToken = callsDroppedPerToken;
+        callsDroppedPerToken = new HashMap<>(localCallsDroppedPerToken.size());
+      }
+    }
+    for (Map.Entry<String, LongHolder> entry : localCallsDroppedPerToken.entrySet()) {
+      statsBuilder.addCallsFinishedWithDrop(
+          ClientStatsPerToken.newBuilder()
+              .setLoadBalanceToken(entry.getKey())
+              .setNumCalls(entry.getValue().num)
+              .build());
+    }
+    return statsBuilder.build();
+  }
+
+  private class StreamTracer extends ClientStreamTracer {
+    private volatile boolean headersSent;
+    private volatile boolean anythingReceived;
+
+    @Override
+    public void outboundHeaders() {
+      headersSent = true;
+    }
+
+    @Override
+    public void inboundHeaders() {
+      anythingReceived = true;
+    }
+
+    @Override
+    public void inboundMessage(int seqNo) {
+      anythingReceived = true;
+    }
+
+    @Override
+    public void streamClosed(Status status) {
+      callsFinishedUpdater.getAndIncrement(GrpclbClientLoadRecorder.this);
+      if (!headersSent) {
+        callsFailedToSendUpdater.getAndIncrement(GrpclbClientLoadRecorder.this);
+      }
+      if (anythingReceived) {
+        callsFinishedKnownReceivedUpdater.getAndIncrement(GrpclbClientLoadRecorder.this);
+      }
+    }
+  }
+}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbConfig.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbConfig.java
new file mode 100644
index 00000000000..1476e3e2f83
--- /dev/null
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbConfig.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2019 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.grpclb;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import io.grpc.grpclb.GrpclbState.Mode;
+import javax.annotation.Nullable;
+
+final class GrpclbConfig {
+
+  private final Mode mode;
+  @Nullable
+  private final String serviceName;
+  private final long fallbackTimeoutMs;
+
+  private GrpclbConfig(Mode mode, @Nullable String serviceName, long fallbackTimeoutMs) {
+    this.mode = checkNotNull(mode, "mode");
+    this.serviceName = serviceName;
+    this.fallbackTimeoutMs = fallbackTimeoutMs;
+  }
+
+  static GrpclbConfig create(Mode mode) {
+    return create(mode, null, GrpclbState.FALLBACK_TIMEOUT_MS);
+  }
+
+  static GrpclbConfig create(Mode mode, @Nullable String serviceName, long fallbackTimeoutMs) {
+    checkArgument(fallbackTimeoutMs > 0, "Invalid timeout (%s)", fallbackTimeoutMs);
+    return new GrpclbConfig(mode, serviceName, fallbackTimeoutMs);
+  }
+
+  Mode getMode() {
+    return mode;
+  }
+
+  long getFallbackTimeoutMs() {
+    return fallbackTimeoutMs;
+  }
+
+  /**
+   * If specified, it overrides the name of the service name to be sent to the balancer. if not, the
+   * target to be sent to the balancer will continue to be obtained from the target URI passed
+   * to the gRPC client channel.
+   */
+  @Nullable
+  String getServiceName() {
+    return serviceName;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    GrpclbConfig that = (GrpclbConfig) o;
+    return mode == that.mode
+        && Objects.equal(serviceName, that.serviceName)
+        && fallbackTimeoutMs == that.fallbackTimeoutMs;
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(mode, serviceName, fallbackTimeoutMs);
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("mode", mode)
+        .add("serviceName", serviceName)
+        .add("fallbackTimeoutMs", fallbackTimeoutMs)
+        .toString();
+  }
+}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbConstants.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbConstants.java
index 535f4f0ab44..be09b1ce306 100644
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbConstants.java
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbConstants.java
@@ -1,65 +1,68 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.grpclb;
 
 import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
 import io.grpc.ExperimentalApi;
+import io.grpc.Metadata;
+import java.util.List;
 
 /**
  * Constants for the GRPCLB load-balancer.
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1782")
 public final class GrpclbConstants {
+
+  /**
+   * The opaque token given by the remote balancer for each returned server address.  The client
+   * will send this token with any requests sent to the associated server.
+   */
+  public static final Metadata.Key<String> TOKEN_METADATA_KEY =
+      Metadata.Key.of("lb-token", Metadata.ASCII_STRING_MARSHALLER);
+
   /**
-   * The load-balancing policy designated by the naming system.
+   * For passing LB tokens via the EAG attributes.
    */
-  public enum LbPolicy {
-    PICK_FIRST,
-    ROUND_ROBIN,
-    GRPCLB
-  }
+  @EquivalentAddressGroup.Attr
+  static final Attributes.Key<String> TOKEN_ATTRIBUTE_KEY =
+      Attributes.Key.create("lb-token");
 
   /**
-   * An attribute of a name resolution result, designating the LB policy.
+   * Attribute key for gRPC LB server addresses.
    */
-  public static final Attributes.Key<LbPolicy> ATTR_LB_POLICY =
-      Attributes.Key.of("io.grpc.grpclb.lbPolicy");
+  public static final Attributes.Key<List<EquivalentAddressGroup>> ATTR_LB_ADDRS =
+      Attributes.Key.create("io.grpc.grpclb.GrpclbConstants.ATTR_LB_ADDRS");
 
   /**
-   * The naming authority of an LB server address.  It is an address-group-level attribute, present
-   * when the address group is a LoadBalancer.
+   * The naming authority of a gRPC LB server address.  It is an address-group-level attribute,
+   * present when the address group is a LoadBalancer.
    */
+  @EquivalentAddressGroup.Attr
   public static final Attributes.Key<String> ATTR_LB_ADDR_AUTHORITY =
-      Attributes.Key.of("io.grpc.grpclb.lbAddrAuthority");
+      Attributes.Key.create("io.grpc.grpclb.GrpclbConstants.ATTR_LB_ADDR_AUTHORITY");
+
+  /**
+   * Whether this EquivalentAddressGroup was provided by a GRPCLB server. It would be rare for this
+   * value to be {@code false}; generally it would be better to not have the key present at all.
+   */
+  @EquivalentAddressGroup.Attr
+  public static final Attributes.Key<Boolean> ATTR_LB_PROVIDED_BACKEND =
+      Attributes.Key.create("io.grpc.grpclb.GrpclbConstants.ATTR_LB_PROVIDED_BACKEND");
 
   private GrpclbConstants() { }
 }
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer.java
index e5e899ab0b2..872937b03c1 100644
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer.java
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer.java
@@ -1,383 +1,166 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.grpclb;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Supplier;
-import com.google.common.base.Suppliers;
+import com.google.common.base.Stopwatch;
 import io.grpc.Attributes;
-import io.grpc.Channel;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.Context;
 import io.grpc.EquivalentAddressGroup;
 import io.grpc.LoadBalancer;
-import io.grpc.ResolvedServerInfo;
-import io.grpc.ResolvedServerInfoGroup;
 import io.grpc.Status;
-import io.grpc.TransportManager;
-import io.grpc.TransportManager.InterimTransport;
-import io.grpc.internal.GrpcUtil;
-import io.grpc.internal.RoundRobinServerList;
-import io.grpc.internal.SharedResourceHolder;
-import io.grpc.stub.StreamObserver;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.net.SocketAddress;
-import java.net.UnknownHostException;
+import io.grpc.grpclb.GrpclbState.Mode;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.TimeProvider;
 import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
+import java.util.Collections;
 import java.util.List;
-import java.util.concurrent.ExecutorService;
-import java.util.logging.Logger;
-import javax.annotation.concurrent.GuardedBy;
+import javax.annotation.Nullable;
 
 /**
  * A {@link LoadBalancer} that uses the GRPCLB protocol.
+ *
+ * <p>Optionally, when requested by the naming system, will delegate the work to a local pick-first
+ * or round-robin balancer.
  */
-class GrpclbLoadBalancer<T> extends LoadBalancer<T> {
-  private static final Logger logger = Logger.getLogger(GrpclbLoadBalancer.class.getName());
-
-  private static final Status SHUTDOWN_STATUS =
-      Status.UNAVAILABLE.augmentDescription("GrpclbLoadBalancer has shut down");
-
-  private final Object lock = new Object();
-  private final String serviceName;
-  private final TransportManager<T> tm;
-
-  // General states
-  @GuardedBy("lock")
-  private InterimTransport<T> interimTransport;
-  @GuardedBy("lock")
-  private Status lastError;
-
-  @GuardedBy("lock")
-  private boolean closed;
-
-  // Load-balancer service states
-  @GuardedBy("lock")
-  private EquivalentAddressGroup lbAddresses;
-  @GuardedBy("lock")
-  private T lbTransport;
-  @GuardedBy("lock")
-  private T directTransport;
-  @GuardedBy("lock")
-  private StreamObserver<LoadBalanceResponse> lbResponseObserver;
-  @GuardedBy("lock")
-  private StreamObserver<LoadBalanceRequest> lbRequestWriter;
-
-  // Server list states
-  @GuardedBy("lock")
-  private HashMap<SocketAddress, ResolvedServerInfo> servers;
-  @GuardedBy("lock")
-  @VisibleForTesting
-  private RoundRobinServerList<T> roundRobinServerList;
-
-  private ExecutorService executor;
-
-  GrpclbLoadBalancer(String serviceName, TransportManager<T> tm) {
-    this.serviceName = serviceName;
-    this.tm = tm;
-    executor = SharedResourceHolder.get(GrpcUtil.SHARED_CHANNEL_EXECUTOR);
-  }
-
-  @VisibleForTesting
-  StreamObserver<LoadBalanceResponse> getLbResponseObserver() {
-    synchronized (lock) {
-      return lbResponseObserver;
-    }
-  }
-
-  @VisibleForTesting
-  RoundRobinServerList<T> getRoundRobinServerList() {
-    synchronized (lock) {
-      return roundRobinServerList;
-    }
+class GrpclbLoadBalancer extends LoadBalancer {
+
+  private static final GrpclbConfig DEFAULT_CONFIG = GrpclbConfig.create(Mode.ROUND_ROBIN);
+
+  private final Helper helper;
+  private final Context context;
+  private final TimeProvider time;
+  private final Stopwatch stopwatch;
+  private final SubchannelPool subchannelPool;
+  private final BackoffPolicy.Provider backoffPolicyProvider;
+
+  private GrpclbConfig config = DEFAULT_CONFIG;
+
+  // All mutable states in this class are mutated ONLY from Channel Executor
+  @Nullable
+  private GrpclbState grpclbState;
+
+  GrpclbLoadBalancer(
+      Helper helper,
+      Context context,
+      SubchannelPool subchannelPool,
+      TimeProvider time,
+      Stopwatch stopwatch,
+      BackoffPolicy.Provider backoffPolicyProvider) {
+    this.helper = checkNotNull(helper, "helper");
+    this.context = checkNotNull(context, "context");
+    this.time = checkNotNull(time, "time provider");
+    this.stopwatch = checkNotNull(stopwatch, "stopwatch");
+    this.backoffPolicyProvider = checkNotNull(backoffPolicyProvider, "backoffPolicyProvider");
+    this.subchannelPool = checkNotNull(subchannelPool, "subchannelPool");
+    recreateStates();
+    checkNotNull(grpclbState, "grpclbState");
   }
 
   @Override
-  public T pickTransport(Attributes affinity) {
-    RoundRobinServerList<T> serverListCopy;
-    synchronized (lock) {
-      if (closed) {
-        return tm.createFailingTransport(SHUTDOWN_STATUS);
-      }
-      if (directTransport != null) {
-        return directTransport;
-      }
-      if (roundRobinServerList == null) {
-        if (lastError != null) {
-          return tm.createFailingTransport(lastError);
-        }
-        if (interimTransport == null) {
-          interimTransport = tm.createInterimTransport();
-        }
-        return interimTransport.transport();
-      }
-      serverListCopy = roundRobinServerList;
-    }
-    return serverListCopy.getTransportForNextServer();
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    Attributes attributes = resolvedAddresses.getAttributes();
+    List<EquivalentAddressGroup> newLbAddresses = attributes.get(GrpclbConstants.ATTR_LB_ADDRS);
+    if (newLbAddresses == null) {
+      newLbAddresses = Collections.emptyList();
+    }
+    if (newLbAddresses.isEmpty() && resolvedAddresses.getAddresses().isEmpty()) {
+      Status unavailableStatus = Status.UNAVAILABLE.withDescription(
+          "No backend or balancer addresses found");
+      handleNameResolutionError(unavailableStatus);
+      return unavailableStatus;
+    }
+    List<EquivalentAddressGroup> overrideAuthorityLbAddresses =
+        new ArrayList<>(newLbAddresses.size());
+    for (EquivalentAddressGroup lbAddr : newLbAddresses) {
+      String lbAddrAuthority = lbAddr.getAttributes().get(GrpclbConstants.ATTR_LB_ADDR_AUTHORITY);
+      if (lbAddrAuthority == null) {
+        throw new AssertionError(
+            "This is a bug: LB address " + lbAddr + " does not have an authority.");
+      }
+      Attributes attrs = lbAddr.getAttributes().toBuilder()
+          .set(EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE, lbAddrAuthority)
+          .build();
+      overrideAuthorityLbAddresses.add(new EquivalentAddressGroup(lbAddr.getAddresses(), attrs));
+    }
+
+    List<EquivalentAddressGroup> newBackendServers =
+        Collections.unmodifiableList(resolvedAddresses.getAddresses());
+    GrpclbConfig newConfig = (GrpclbConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+    if (newConfig == null) {
+      newConfig = DEFAULT_CONFIG;
+    }
+    if (!config.equals(newConfig)) {
+      config = newConfig;
+      helper.getChannelLogger().log(ChannelLogLevel.INFO, "Config: " + newConfig);
+      recreateStates();
+    }
+    grpclbState.handleAddresses(Collections.unmodifiableList(overrideAuthorityLbAddresses),
+        newBackendServers);
+
+    return Status.OK;
   }
 
   @Override
-  public void handleResolvedAddresses(List<ResolvedServerInfoGroup> updatedServers,
-      Attributes attributes) {
-    synchronized (lock) {
-      if (closed) {
-        return;
-      }
-      EquivalentAddressGroup newLbAddresses = resolvedServerInfoGroupsToEquivalentAddressGroup(
-          updatedServers);
-      if (!newLbAddresses.equals(lbAddresses)) {
-        lbAddresses = newLbAddresses;
-        connectToLb();
-      }
-    }
-    updateRetainedTransports();
-  }
-
-  @GuardedBy("lock")
-  private void connectToLb() {
-    directTransport = null;
-    if (closed) {
-      return;
+  public void requestConnection() {
+    if (grpclbState != null) {
+      grpclbState.requestConnection();
     }
-    lbResponseObserver = null;
-    Preconditions.checkNotNull(lbAddresses, "lbAddresses");
-    // TODO(zhangkun83): LB servers may use an authority different from the service's.
-    // getTransport() will need to add an argument for the authority.
-    lbTransport = tm.getTransport(lbAddresses);
-    startNegotiation();
   }
 
-  @GuardedBy("lock")
-  private void startNegotiation() {
-    if (closed) {
-      return;
+  private void resetStates() {
+    if (grpclbState != null) {
+      grpclbState.shutdown();
+      grpclbState = null;
     }
-    Preconditions.checkState(lbTransport != null, "lbTransport must be available");
-    logger.info("Starting LB negotiation");
-    LoadBalanceRequest initRequest = LoadBalanceRequest.newBuilder()
-        .setInitialRequest(InitialLoadBalanceRequest.newBuilder()
-            .setName(serviceName).build())
-        .build();
-    lbResponseObserver = new LbResponseObserver();
-    sendLbRequest(lbTransport, initRequest);
   }
 
-  @VisibleForTesting  // to be mocked in tests
-  @GuardedBy("lock")
-  void sendLbRequest(T transport, LoadBalanceRequest request) {
-    Channel channel = tm.makeChannel(transport);
-    LoadBalancerGrpc.LoadBalancerStub stub = LoadBalancerGrpc.newStub(channel);
-    lbRequestWriter = stub.balanceLoad(lbResponseObserver);
-    lbRequestWriter.onNext(request);
-  }
-
-  @Override
-  public void handleNameResolutionError(Status error) {
-    handleError(error.augmentDescription("Name resolution failed"));
+  private void recreateStates() {
+    resetStates();
+    checkState(grpclbState == null, "Should've been cleared");
+    grpclbState =
+        new GrpclbState(
+            config, helper, context, subchannelPool, time, stopwatch, backoffPolicyProvider);
   }
 
   @Override
   public void shutdown() {
-    InterimTransport<T> savedInterimTransport;
-    synchronized (lock) {
-      if (closed) {
-        return;
-      }
-      closed = true;
-      if (lbRequestWriter != null) {
-        lbRequestWriter.onCompleted();
-      }
-      savedInterimTransport = interimTransport;
-      interimTransport = null;
-      executor = SharedResourceHolder.release(GrpcUtil.SHARED_CHANNEL_EXECUTOR, executor);
-    }
-    if (savedInterimTransport != null) {
-      savedInterimTransport.closeWithError(SHUTDOWN_STATUS);
-    }
+    resetStates();
   }
 
   @Override
-  public void handleTransportShutdown(EquivalentAddressGroup addressGroup, Status status) {
-    handleError(status.augmentDescription("Transport to LB server closed"));
-    synchronized (lock) {
-      if (closed) {
-        return;
-      }
-      if (addressGroup.equals(lbAddresses)) {
-        connectToLb();
-      }
-    }
-  }
-
-  private void handleError(Status error) {
-    InterimTransport<T> savedInterimTransport;
-    synchronized (lock) {
-      savedInterimTransport = interimTransport;
-      interimTransport = null;
-      lastError = error;
-    }
-    if (savedInterimTransport != null) {
-      savedInterimTransport.closeWithError(error);
-    }
-  }
-
-  private void updateRetainedTransports() {
-    HashSet<EquivalentAddressGroup> addresses = new HashSet<EquivalentAddressGroup>();
-    synchronized (lock) {
-      if (lbAddresses != null) {
-        addresses.add(lbAddresses);
-      }
-      if (servers != null) {
-        for (SocketAddress addr : servers.keySet()) {
-          addresses.add(new EquivalentAddressGroup(addr));
-        }
-      }
+  public void handleNameResolutionError(Status error) {
+    if (grpclbState != null) {
+      grpclbState.propagateError(error);
     }
-    tm.updateRetainedTransports(addresses);
   }
 
-  /**
-   * Converts list of ResolvedServerInfoGroup objects into one EquivalentAddressGroup object.
-   */
-  private static EquivalentAddressGroup resolvedServerInfoGroupsToEquivalentAddressGroup(
-      List<ResolvedServerInfoGroup> groupList) {
-    List<SocketAddress> addrs = new ArrayList<SocketAddress>(groupList.size());
-    for (ResolvedServerInfoGroup group : groupList) {
-      for (ResolvedServerInfo srv : group.getResolvedServerInfoList()) {
-        addrs.add(srv.getAddress());
-      }
-    }
-    return new EquivalentAddressGroup(addrs);
+  @Override
+  public boolean canHandleEmptyAddressListFromNameResolution() {
+    return true;
   }
 
-  private class LbResponseObserver implements StreamObserver<LoadBalanceResponse> {
-    @Override public void onNext(LoadBalanceResponse response) {
-      logger.info("Got a LB response: " + response);
-      // TODO(zhangkun83): make use of initialResponse
-      // InitialLoadBalanceResponse initialResponse = response.getInitialResponse();
-      RoundRobinServerList.Builder<T> listBuilder = new RoundRobinServerList.Builder<T>(tm);
-      ServerList serverList = response.getServerList();
-      HashMap<SocketAddress, ResolvedServerInfo> newServerMap =
-          new HashMap<SocketAddress, ResolvedServerInfo>();
-      // TODO(zhangkun83): honor expiration_interval
-      for (Server server : serverList.getServersList()) {
-        if (server.getDropRequest()) {
-          listBuilder.addSocketAddress(null);
-        } else {
-          try {
-            InetSocketAddress address = new InetSocketAddress(
-                InetAddress.getByAddress(server.getIpAddress().toByteArray()), server.getPort());
-            listBuilder.addSocketAddress(address);
-            // TODO(zhangkun83): fill the LB token to the attributes, and insert it to the
-            // application RPCs.
-            if (!newServerMap.containsKey(address)) {
-              newServerMap.put(address, new ResolvedServerInfo(address, Attributes.EMPTY));
-            }
-          } catch (UnknownHostException e) {
-            throw new RuntimeException(e);
-          }
-        }
-      }
-      final RoundRobinServerList<T> newRoundRobinServerList = listBuilder.build();
-      if (newRoundRobinServerList.size() == 0) {
-        // initialResponse and serverList are under a oneof group. If initialResponse is set,
-        // serverList will be empty.
-        return;
-      }
-      InterimTransport<T> savedInterimTransport;
-      synchronized (lock) {
-        if (lbResponseObserver != this) {
-          // Make sure I am still the current stream.
-          return;
-        }
-        roundRobinServerList = newRoundRobinServerList;
-        servers = newServerMap;
-        savedInterimTransport = interimTransport;
-        interimTransport = null;
-      }
-      updateRetainedTransports();
-      if (savedInterimTransport != null) {
-        savedInterimTransport.closeWithRealTransports(new Supplier<T>() {
-            @Override
-            public T get() {
-              return newRoundRobinServerList.getTransportForNextServer();
-            }
-          });
-      }
-    }
-
-    @Override public void onError(Throwable error) {
-      onStreamClosed(Status.fromThrowable(error)
-          .augmentDescription("Stream to GRPCLB LoadBalancer had an error"));
-    }
-
-    @Override public void onCompleted() {
-      onStreamClosed(Status.UNAVAILABLE.augmentDescription(
-          "Stream to GRPCLB LoadBalancer was closed"));
-    }
-
-    private void onStreamClosed(Status status) {
-      if (status.getCode() == Status.Code.UNIMPLEMENTED) {
-        InterimTransport<T> savedInterimTransport;
-        final T transport;
-        // This LB transport doesn't seem to be an actual LB server, if the LB address comes
-        // directly from NameResolver, just use it to serve normal RPCs.
-        // TODO(zhangkun83): check if lbAddresses are from NameResolver after we start getting
-        // lbAddresses from LoadBalanceResponse.
-        synchronized (lock) {
-          if (lbResponseObserver != this) {
-            return;
-          }
-          directTransport = transport = lbTransport;
-          savedInterimTransport = interimTransport;
-          interimTransport = null;
-        }
-        if (savedInterimTransport != null) {
-          savedInterimTransport.closeWithRealTransports(Suppliers.ofInstance(transport));
-        }
-      } else {
-        handleError(status);
-        synchronized (lock) {
-          if (lbResponseObserver != this) {
-            return;
-          }
-          // TODO(zhangkun83): apply back-off, otherwise this will spam the server continually
-          // with requests if the server tends to fail it for any reason.
-          // I am still the active LB stream. Reopen the stream.
-          startNegotiation();
-        }
-      }
-    }
+  @VisibleForTesting
+  @Nullable
+  GrpclbState getGrpclbState() {
+    return grpclbState;
   }
 }
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer2.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer2.java
deleted file mode 100644
index d3b95071fb5..00000000000
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancer2.java
+++ /dev/null
@@ -1,498 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.grpclb;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-import static io.grpc.ConnectivityState.IDLE;
-import static io.grpc.ConnectivityState.READY;
-import static io.grpc.ConnectivityState.SHUTDOWN;
-import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
-
-import com.google.common.annotations.VisibleForTesting;
-import io.grpc.Attributes;
-import io.grpc.ConnectivityStateInfo;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer2;
-import io.grpc.ManagedChannel;
-import io.grpc.Metadata;
-import io.grpc.ResolvedServerInfoGroup;
-import io.grpc.Status;
-import io.grpc.grpclb.GrpclbConstants.LbPolicy;
-import io.grpc.internal.LogId;
-import io.grpc.internal.WithLogId;
-import io.grpc.stub.StreamObserver;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.net.UnknownHostException;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import javax.annotation.Nullable;
-
-/**
- * A {@link LoadBalancer2} that uses the GRPCLB protocol.
- *
- * <p>Optionally, when requested by the naming system, will delegate the work to a local pick-first
- * or round-robin balancer.
- */
-class GrpclbLoadBalancer2 extends LoadBalancer2 implements WithLogId {
-  private static final Logger logger = Logger.getLogger(GrpclbLoadBalancer2.class.getName());
-
-  @VisibleForTesting
-  static final SubchannelPicker BUFFER_PICKER = new SubchannelPicker() {
-      @Override
-      public PickResult pickSubchannel(Attributes affinity, Metadata headers) {
-        return PickResult.withNoResult();
-      }
-    };
-
-  private final LogId logId = LogId.allocate(getClass().getName());
-
-  private final String serviceName;
-  private final Helper helper;
-  private final Factory pickFirstBalancerFactory;
-  private final Factory roundRobinBalancerFactory;
-
-  private static final Attributes.Key<AtomicReference<ConnectivityStateInfo>> STATE_INFO =
-        Attributes.Key.of("io.grpc.grpclb.GrpclbLoadBalancer.stateInfo");
-  @VisibleForTesting
-  static final PickResult THROTTLED_RESULT =
-      PickResult.withError(Status.UNAVAILABLE.withDescription("Throttled by LB"));
-
-  // All mutable states in this class are mutated ONLY from Channel Executor
-
-  ///////////////////////////////////////////////////////////////////////////////
-  // General states.
-  ///////////////////////////////////////////////////////////////////////////////
-
-  // If not null, all work is delegated to it.
-  @Nullable
-  private LoadBalancer2 delegate;
-  private LbPolicy lbPolicy;
-
-  ///////////////////////////////////////////////////////////////////////////////
-  // GRPCLB states, valid only if lbPolicy == GRPCLB
-  ///////////////////////////////////////////////////////////////////////////////
-
-  // null if there isn't any available LB addresses.
-  // If non-null, never empty.
-  @Nullable
-  private List<LbAddressGroup> lbAddressGroups;
-  @Nullable
-  private ManagedChannel lbCommChannel;
-  // Points to the position of the LB address that lbCommChannel is bound to, if
-  // lbCommChannel != null.
-  private int currentLbIndex;
-  @Nullable
-  private LbResponseObserver lbResponseObserver;
-  @Nullable
-  private StreamObserver<LoadBalanceRequest> lbRequestWriter;
-  private Map<EquivalentAddressGroup, Subchannel> subchannels = Collections.emptyMap();
-  // A null element indicate a simulated error for throttling purpose
-  private List<EquivalentAddressGroup> roundRobinList = Collections.emptyList();
-
-  GrpclbLoadBalancer2(Helper helper, Factory pickFirstBalancerFactory,
-      Factory roundRobinBalancerFactory) {
-    this.helper = checkNotNull(helper, "helper");
-    this.serviceName = checkNotNull(helper.getAuthority(), "helper returns null authority");
-    this.pickFirstBalancerFactory =
-        checkNotNull(pickFirstBalancerFactory, "pickFirstBalancerFactory");
-    this.roundRobinBalancerFactory =
-        checkNotNull(roundRobinBalancerFactory, "roundRobinBalancerFactory");
-  }
-
-  @Override
-  public LogId getLogId() {
-    return logId;
-  }
-
-  @Override
-  public void handleSubchannelState(Subchannel subchannel, ConnectivityStateInfo newState) {
-    if (delegate != null) {
-      delegate.handleSubchannelState(subchannel, newState);
-      return;
-    }
-    if (newState.getState() == SHUTDOWN || !(subchannels.values().contains(subchannel))) {
-      return;
-    }
-    if (newState.getState() == IDLE) {
-      subchannel.requestConnection();
-    }
-    subchannel.getAttributes().get(STATE_INFO).set(newState);
-    helper.updatePicker(makePicker());
-  }
-
-  @Override
-  public void handleResolvedAddresses(List<ResolvedServerInfoGroup> updatedServers,
-      Attributes attributes) {
-    LbPolicy newLbPolicy = attributes.get(GrpclbConstants.ATTR_LB_POLICY);
-    // LB addresses and backend addresses are treated separately
-    List<LbAddressGroup> newLbAddressGroups = new ArrayList<LbAddressGroup>();
-    List<ResolvedServerInfoGroup> newBackendServerInfoGroups =
-        new ArrayList<ResolvedServerInfoGroup>();
-    for (ResolvedServerInfoGroup serverInfoGroup : updatedServers) {
-      String lbAddrAuthority = serverInfoGroup.getAttributes().get(
-          GrpclbConstants.ATTR_LB_ADDR_AUTHORITY);
-      EquivalentAddressGroup eag = serverInfoGroup.toEquivalentAddressGroup();
-      if (lbAddrAuthority != null) {
-        newLbAddressGroups.add(new LbAddressGroup(eag, lbAddrAuthority));
-      } else {
-        newBackendServerInfoGroups.add(serverInfoGroup);
-      }
-    }
-
-    if (newBackendServerInfoGroups.isEmpty()) {
-      // handleResolvedAddresses()'s javadoc has guaranteed updatedServers is never empty.
-      checkState(!newLbAddressGroups.isEmpty(),
-          "No backend address nor LB address.  updatedServers=%s", updatedServers);
-      if (newLbPolicy != LbPolicy.GRPCLB) {
-        newLbPolicy = LbPolicy.GRPCLB;
-        logger.log(Level.FINE, "[{0}] Switching to GRPCLB because all addresses are balancers",
-            logId);
-      }
-    }
-    if (newLbPolicy == null) {
-      logger.log(Level.FINE, "[{0}] New config missing policy. Using PICK_FIRST", logId);
-      newLbPolicy = LbPolicy.PICK_FIRST;
-    }
-
-    // Switch LB policy if requested
-    if (newLbPolicy != lbPolicy) {
-      shutdownDelegate();
-      shutdownLbComm();
-      lbAddressGroups = null;
-      currentLbIndex = 0;
-      switch (newLbPolicy) {
-        case PICK_FIRST:
-          delegate = checkNotNull(pickFirstBalancerFactory.newLoadBalancer(helper),
-              "pickFirstBalancerFactory.newLoadBalancer()");
-          break;
-        case ROUND_ROBIN:
-          delegate = checkNotNull(roundRobinBalancerFactory.newLoadBalancer(helper),
-              "roundRobinBalancerFactory.newLoadBalancer()");
-          break;
-        default:
-          // Do nohting
-      }
-    }
-    lbPolicy = newLbPolicy;
-
-    // Consume the new addresses
-    switch (lbPolicy) {
-      case PICK_FIRST:
-      case ROUND_ROBIN:
-        checkNotNull(delegate, "delegate should not be null. newLbPolicy=" + newLbPolicy);
-        delegate.handleResolvedAddresses(newBackendServerInfoGroups, attributes);
-        break;
-      case GRPCLB:
-        if (newLbAddressGroups.isEmpty()) {
-          shutdownLbComm();
-          lbAddressGroups = null;
-          handleGrpclbError(Status.UNAVAILABLE.withDescription(
-                  "NameResolver returned no LB address while asking for GRPCLB"));
-        } else {
-          // See if the currently used LB server is in the new list.
-          int newIndexOfCurrentLb = -1;
-          if (lbAddressGroups != null) {
-            LbAddressGroup currentLb = lbAddressGroups.get(currentLbIndex);
-            newIndexOfCurrentLb = newLbAddressGroups.indexOf(currentLb);
-          }
-          lbAddressGroups = newLbAddressGroups;
-          if (newIndexOfCurrentLb == -1) {
-            shutdownLbComm();
-            currentLbIndex = 0;
-            startLbComm();
-          } else {
-            // Current LB is still in the list, calibrate index.
-            currentLbIndex = newIndexOfCurrentLb;
-          }
-        }
-        break;
-      default:
-        // Do nothing
-    }
-  }
-
-  private void shutdownLbComm() {
-    if (lbCommChannel != null) {
-      lbCommChannel.shutdown();
-      lbCommChannel = null;
-    }
-    if (lbRequestWriter != null) {
-      lbRequestWriter.onCompleted();
-      lbRequestWriter = null;
-    }
-    if (lbResponseObserver != null) {
-      lbResponseObserver.dismissed = true;
-      lbResponseObserver = null;
-    }
-  }
-
-  private void startLbComm() {
-    checkState(lbCommChannel == null, "previous lbCommChannel has not been closed yet");
-    checkState(lbRequestWriter == null, "previous lbRequestWriter has not been cleared yet");
-    checkState(lbResponseObserver == null, "previous lbResponseObserver has not been cleared yet");
-    LbAddressGroup currentLb = lbAddressGroups.get(currentLbIndex);
-    lbCommChannel = helper.createOobChannel(currentLb.getAddresses(), currentLb.getAuthority());
-    LoadBalancerGrpc.LoadBalancerStub stub = LoadBalancerGrpc.newStub(lbCommChannel);
-    lbResponseObserver = new LbResponseObserver();
-    lbRequestWriter = stub.balanceLoad(lbResponseObserver);
-
-    LoadBalanceRequest initRequest = LoadBalanceRequest.newBuilder()
-        .setInitialRequest(InitialLoadBalanceRequest.newBuilder()
-            .setName(serviceName).build())
-        .build();
-    lbRequestWriter.onNext(initRequest);
-  }
-
-  private void shutdownDelegate() {
-    if (delegate != null) {
-      delegate.shutdown();
-      delegate = null;
-    }
-  }
-
-  @Override
-  public void shutdown() {
-    shutdownDelegate();
-    shutdownLbComm();
-    for (Subchannel subchannel : subchannels.values()) {
-      subchannel.shutdown();
-    }
-    subchannels = Collections.emptyMap();
-  }
-
-  private void handleGrpclbError(Status status) {
-    logger.log(Level.FINE, "[{0}] Had an error: {1}; roundRobinList={2}",
-        new Object[] {logId, status, roundRobinList});
-    if (roundRobinList.isEmpty()) {
-      helper.updatePicker(new ErrorPicker(status));
-    }
-  }
-
-  @Override
-  public void handleNameResolutionError(Status error) {
-    if (delegate != null) {
-      delegate.handleNameResolutionError(error);
-    } else {
-      handleGrpclbError(error);
-    }
-  }
-
-  private class LbResponseObserver implements StreamObserver<LoadBalanceResponse> {
-    boolean dismissed;
-
-    @Override public void onNext(final LoadBalanceResponse response) {
-      helper.runSerialized(new Runnable() {
-          @Override
-          public void run() {
-            handleResponse(response);
-          }
-        });
-    }
-
-    private void handleResponse(LoadBalanceResponse response) {
-      if (dismissed) {
-        return;
-      }
-      logger.log(Level.FINE, "[{0}] Got an LB response: {1}", new Object[] {logId, response});
-      // TODO(zhangkun83): make use of initialResponse
-      // InitialLoadBalanceResponse initialResponse = response.getInitialResponse();
-      ServerList serverList = response.getServerList();
-      HashMap<EquivalentAddressGroup, Subchannel> newSubchannelMap =
-          new HashMap<EquivalentAddressGroup, Subchannel>();
-      List<EquivalentAddressGroup> newRoundRobinList = new ArrayList<EquivalentAddressGroup>();
-      // TODO(zhangkun83): honor expiration_interval
-      // Construct the new collections. Create new Subchannels when necessary.
-      for (Server server : serverList.getServersList()) {
-        if (server.getDropRequest()) {
-          newRoundRobinList.add(null);
-        } else {
-          InetSocketAddress address;
-          try {
-            address = new InetSocketAddress(
-                InetAddress.getByAddress(server.getIpAddress().toByteArray()), server.getPort());
-          } catch (UnknownHostException e) {
-            handleGrpclbError(Status.UNAVAILABLE.withCause(e));
-            continue;
-          }
-          EquivalentAddressGroup eag = new EquivalentAddressGroup(address);
-          // TODO(zhangkun83): save the LB token and insert it to the application RPCs' headers.
-          if (!newSubchannelMap.containsKey(eag)) {
-            Attributes subchannelAttrs = Attributes.newBuilder()
-                .set(STATE_INFO,
-                    new AtomicReference<ConnectivityStateInfo>(
-                        ConnectivityStateInfo.forNonError(IDLE)))
-                .build();
-            Subchannel subchannel = helper.createSubchannel(eag, subchannelAttrs);
-            subchannel.requestConnection();
-            newSubchannelMap.put(eag, subchannel);
-          }
-          newRoundRobinList.add(eag);
-        }
-      }
-      // Close Subchannels whose addresses have been delisted
-      for (Entry<EquivalentAddressGroup, Subchannel> entry : subchannels.entrySet()) {
-        EquivalentAddressGroup eag = entry.getKey();
-        if (!newSubchannelMap.containsKey(eag)) {
-          entry.getValue().shutdown();
-        }
-      }
-
-      subchannels = newSubchannelMap;
-      roundRobinList = newRoundRobinList;
-      helper.updatePicker(makePicker());
-    }
-
-    @Override public void onError(final Throwable error) {
-      helper.runSerialized(new Runnable() {
-          @Override
-          public void run() {
-            handleStreamClosed(Status.fromThrowable(error)
-                .augmentDescription("Stream to GRPCLB LoadBalancer had an error"));
-          }
-        });
-    }
-
-    @Override public void onCompleted() {
-      helper.runSerialized(new Runnable() {
-          @Override
-          public void run() {
-            handleStreamClosed(Status.UNAVAILABLE.augmentDescription(
-                    "Stream to GRPCLB LoadBalancer was closed"));
-          }
-        });
-    }
-
-    private void handleStreamClosed(Status status) {
-      if (dismissed) {
-        return;
-      }
-      lbRequestWriter = null;
-      handleGrpclbError(status);
-      shutdownLbComm();
-      currentLbIndex = (currentLbIndex + 1) % lbAddressGroups.size();
-      startLbComm();
-    }
-  }
-
-  /**
-   * Make a picker out of the current roundRobinList and the states of subchannels.
-   */
-  private SubchannelPicker makePicker() {
-    List<PickResult> resultList = new ArrayList<PickResult>();
-    Status error = null;
-    for (EquivalentAddressGroup eag : roundRobinList) {
-      if (eag == null) {
-        resultList.add(THROTTLED_RESULT);
-      } else {
-        Subchannel subchannel = subchannels.get(eag);
-        checkNotNull(subchannel, "Subchannel for %s not found", eag);
-        Attributes attrs = subchannel.getAttributes();
-        ConnectivityStateInfo stateInfo = attrs.get(STATE_INFO).get();
-        if (stateInfo.getState() == READY) {
-          resultList.add(PickResult.withSubchannel(subchannel));
-        } else if (stateInfo.getState() == TRANSIENT_FAILURE) {
-          error = stateInfo.getStatus();
-        }
-      }
-    }
-    if (resultList.isEmpty()) {
-      if (error != null) {
-        logger.log(Level.FINE, "[{0}] No ready Subchannel. Using error: {1}",
-            new Object[] {logId, error});
-        return new ErrorPicker(error);
-      } else {
-        logger.log(Level.FINE, "[{0}] No ready Subchannel and no error", logId);
-        return BUFFER_PICKER;
-      }
-    } else {
-      logger.log(Level.FINE, "[{0}] Using list {1}", new Object[] {logId, resultList});
-      return new RoundRobinPicker(resultList);
-    }
-  }
-
-  @VisibleForTesting
-  LoadBalancer2 getDelegate() {
-    return delegate;
-  }
-
-  @VisibleForTesting
-  LbPolicy getLbPolicy() {
-    return lbPolicy;
-  }
-
-  @VisibleForTesting
-  static final class ErrorPicker extends SubchannelPicker {
-    final PickResult result;
-
-    ErrorPicker(Status status) {
-      result = PickResult.withError(status);
-    }
-
-    @Override
-    public PickResult pickSubchannel(Attributes affinity, Metadata headers) {
-      return result;
-    }
-  }
-
-  @VisibleForTesting
-  static final class RoundRobinPicker extends SubchannelPicker {
-    final List<PickResult> list;
-    int index;
-
-    RoundRobinPicker(List<PickResult> resultList) {
-      checkArgument(!resultList.isEmpty(), "resultList is empty");
-      list = resultList;
-    }
-
-    @Override
-    public PickResult pickSubchannel(Attributes affinity, Metadata headers) {
-      synchronized (list) {
-        PickResult result = list.get(index);
-        index++;
-        if (index == list.size()) {
-          index = 0;
-        }
-        return result;
-      }
-    }
-  }
-}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerFactory.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerFactory.java
deleted file mode 100644
index 226c06ad3ec..00000000000
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerFactory.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.grpclb;
-
-import io.grpc.ExperimentalApi;
-import io.grpc.LoadBalancer;
-import io.grpc.TransportManager;
-
-/**
- * A factory for {@link LoadBalancer}s that uses the GRPCLB protocol.
- *
- * <p><b>Experimental:</b>This only works with the GRPCLB load-balancer service, which is not
- * available yet. Right now it's only good for internal testing. It's not feature-complete either,
- * so before using it, make sure you have read all the {@code TODO} comments in {@link
- * GrpclbLoadBalancer}.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1782")
-public class GrpclbLoadBalancerFactory extends LoadBalancer.Factory {
-
-  private static final GrpclbLoadBalancerFactory instance = new GrpclbLoadBalancerFactory();
-
-  private GrpclbLoadBalancerFactory() {
-  }
-
-  public static GrpclbLoadBalancerFactory getInstance() {
-    return instance;
-  }
-
-  @Override
-  public <T> LoadBalancer<T> newLoadBalancer(String serviceName, TransportManager<T> tm) {
-    return new GrpclbLoadBalancer<T>(serviceName, tm);
-  }
-}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerFactory2.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerFactory2.java
deleted file mode 100644
index 34712657405..00000000000
--- a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerFactory2.java
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright 2017, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.grpclb;
-
-import io.grpc.ExperimentalApi;
-import io.grpc.LoadBalancer2;
-import io.grpc.PickFirstBalancerFactory2;
-import io.grpc.util.RoundRobinLoadBalancerFactory2;
-
-/**
- * A factory for {@link LoadBalancer2}s that uses the GRPCLB protocol.
- *
- * <p><strong>TECHNICAL PREVIEW: </strong>The name of this class is temporary. It will be renamed to
- * {@code GrpclbLoadBalancerFactory} during <a href="https://github.com/grpc/grpc-java/issues/2656">
- * transition to LBv2</a>. You should use it only if you want to experiment the LBv2 code path.
- *
- * <p><b>Experimental:</b>This only works with the GRPCLB load-balancer service, which is not
- * available yet. Right now it's only good for internal testing.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1782")
-public class GrpclbLoadBalancerFactory2 extends LoadBalancer2.Factory {
-
-  private static final GrpclbLoadBalancerFactory2 instance = new GrpclbLoadBalancerFactory2();
-
-  private GrpclbLoadBalancerFactory2() {
-  }
-
-  public static GrpclbLoadBalancerFactory2 getInstance() {
-    return instance;
-  }
-
-  @Override
-  public LoadBalancer2 newLoadBalancer(LoadBalancer2.Helper helper) {
-    return new GrpclbLoadBalancer2(
-        helper, PickFirstBalancerFactory2.getInstance(),
-        RoundRobinLoadBalancerFactory2.getInstance());
-  }
-}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerProvider.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerProvider.java
new file mode 100644
index 00000000000..abb3be77407
--- /dev/null
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbLoadBalancerProvider.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2018 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.grpclb;
+
+import com.google.common.base.Stopwatch;
+import io.grpc.Context;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.grpclb.GrpclbState.Mode;
+import io.grpc.internal.ExponentialBackoffPolicy;
+import io.grpc.internal.JsonUtil;
+import io.grpc.internal.ServiceConfigUtil;
+import io.grpc.internal.ServiceConfigUtil.LbConfig;
+import io.grpc.internal.TimeProvider;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * The provider for the "grpclb" balancing policy.  This class should not be directly referenced in
+ * code.  The policy should be accessed through {@link io.grpc.LoadBalancerRegistry#getProvider}
+ * with the name "grpclb".
+ */
+@Internal
+public final class GrpclbLoadBalancerProvider extends LoadBalancerProvider {
+
+  private static final Mode DEFAULT_MODE = Mode.ROUND_ROBIN;
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return "grpclb";
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+    return
+        new GrpclbLoadBalancer(
+            helper,
+            Context.ROOT,
+            new CachedSubchannelPool(helper),
+            TimeProvider.SYSTEM_TIME_PROVIDER,
+            Stopwatch.createUnstarted(),
+            new ExponentialBackoffPolicy.Provider());
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(
+      Map<String, ?> rawLoadBalancingConfigPolicy) {
+    try {
+      return parseLoadBalancingConfigPolicyInternal(rawLoadBalancingConfigPolicy);
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError(
+          Status.fromThrowable(e).withDescription(
+              "Failed to parse GRPCLB config: " + rawLoadBalancingConfigPolicy));
+    }
+  }
+
+  ConfigOrError parseLoadBalancingConfigPolicyInternal(
+      Map<String, ?> rawLoadBalancingPolicyConfig) {
+    if (rawLoadBalancingPolicyConfig == null) {
+      return ConfigOrError.fromConfig(GrpclbConfig.create(DEFAULT_MODE));
+    }
+    String serviceName = JsonUtil.getString(rawLoadBalancingPolicyConfig, "serviceName");
+    List<?> rawChildPolicies = JsonUtil.getList(rawLoadBalancingPolicyConfig, "childPolicy");
+    Long initialFallbackTimeoutNs =
+        JsonUtil.getStringAsDuration(rawLoadBalancingPolicyConfig, "initialFallbackTimeout");
+    long timeoutMs = GrpclbState.FALLBACK_TIMEOUT_MS;
+    if (initialFallbackTimeoutNs != null) {
+      timeoutMs = initialFallbackTimeoutNs / 1000000;
+    }
+
+    List<LbConfig> childPolicies = null;
+    if (rawChildPolicies != null) {
+      childPolicies =
+          ServiceConfigUtil
+              .unwrapLoadBalancingConfigList(JsonUtil.checkObjectList(rawChildPolicies));
+    }
+
+    if (childPolicies == null || childPolicies.isEmpty()) {
+      return ConfigOrError.fromConfig(
+          GrpclbConfig.create(DEFAULT_MODE, serviceName, timeoutMs));
+    }
+
+    List<String> policiesTried = new ArrayList<>();
+    for (LbConfig childPolicy : childPolicies) {
+      String childPolicyName = childPolicy.getPolicyName();
+      switch (childPolicyName) {
+        case "round_robin":
+          return ConfigOrError.fromConfig(
+              GrpclbConfig.create(Mode.ROUND_ROBIN, serviceName, timeoutMs));
+        case "pick_first":
+          return ConfigOrError.fromConfig(
+              GrpclbConfig.create(Mode.PICK_FIRST, serviceName, timeoutMs));
+        default:
+          policiesTried.add(childPolicyName);
+      }
+    }
+    return ConfigOrError.fromError(
+        Status
+            .UNAVAILABLE
+            .withDescription(
+                "None of " + policiesTried + " specified child policies are available."));
+  }
+}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbNameResolver.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbNameResolver.java
new file mode 100644
index 00000000000..d17587fb14d
--- /dev/null
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbNameResolver.java
@@ -0,0 +1,146 @@
+/*
+ * 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.grpclb;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Stopwatch;
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.internal.DnsNameResolver;
+import io.grpc.internal.SharedResourceHolder.Resource;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * A DNS-based {@link NameResolver} with gRPC LB specific add-ons for resolving balancer
+ * addresses via service records.
+ *
+ * @see SecretGrpclbNameResolverProvider
+ */
+final class GrpclbNameResolver extends DnsNameResolver {
+
+  private static final Logger logger = Logger.getLogger(GrpclbNameResolver.class.getName());
+
+  // From https://github.com/grpc/proposal/blob/master/A5-grpclb-in-dns.md
+  private static final String GRPCLB_NAME_PREFIX = "_grpclb._tcp.";
+
+  GrpclbNameResolver(
+      @Nullable String nsAuthority,
+      String name,
+      Args args,
+      Resource<Executor> executorResource,
+      Stopwatch stopwatch,
+      boolean isAndroid) {
+    super(nsAuthority, name, args, executorResource, stopwatch, isAndroid);
+  }
+
+  @Override
+  protected InternalResolutionResult doResolve(boolean forceTxt) {
+    List<EquivalentAddressGroup> balancerAddrs = resolveBalancerAddresses();
+    InternalResolutionResult result = super.doResolve(!balancerAddrs.isEmpty());
+    if (!balancerAddrs.isEmpty()) {
+      result.attributes =
+          Attributes.newBuilder()
+              .set(GrpclbConstants.ATTR_LB_ADDRS, balancerAddrs)
+              .build();
+    }
+    return result;
+  }
+
+  private List<EquivalentAddressGroup> resolveBalancerAddresses() {
+    List<SrvRecord> srvRecords = Collections.emptyList();
+    Exception srvRecordsException = null;
+    ResourceResolver resourceResolver = getResourceResolver();
+    if (resourceResolver != null) {
+      try {
+        // This host behaves "unconventionally" with SRV records - we exclude it here.
+        if (!getHost().equals("metadata.google.internal.")) {
+          srvRecords = resourceResolver.resolveSrv(GRPCLB_NAME_PREFIX + getHost());
+        }
+      } catch (Exception e) {
+        srvRecordsException = e;
+      }
+    }
+    List<EquivalentAddressGroup> balancerAddresses = new ArrayList<>(srvRecords.size());
+    Exception balancerAddressesException = null;
+    Level level = Level.WARNING;
+    for (SrvRecord record : srvRecords) {
+      try {
+        // Strip trailing dot for appearance's sake. It _should_ be fine either way, but most
+        // people expect to see it without the dot.
+        String authority = record.host.substring(0, record.host.length() - 1);
+        // But we want to use the trailing dot for the IP lookup. The dot makes the name absolute
+        // instead of relative and so will avoid the search list like that in resolv.conf.
+        List<? extends InetAddress> addrs = addressResolver.resolveAddress(record.host);
+        List<SocketAddress> sockAddrs = new ArrayList<>(addrs.size());
+        for (InetAddress addr : addrs) {
+          sockAddrs.add(new InetSocketAddress(addr, record.port));
+        }
+        Attributes attrs =
+            Attributes.newBuilder()
+                .set(GrpclbConstants.ATTR_LB_ADDR_AUTHORITY, authority)
+                .build();
+        balancerAddresses.add(
+            new EquivalentAddressGroup(Collections.unmodifiableList(sockAddrs), attrs));
+      } catch (Exception e) {
+        logger.log(level, "Can't find address for SRV record " + record, e);
+        if (balancerAddressesException == null) {
+          balancerAddressesException = e;
+          level = Level.FINE;
+        }
+      }
+    }
+    if (srvRecordsException != null) {
+      logger.log(Level.FINE, "SRV lookup failure", srvRecordsException);
+    } else if (balancerAddressesException != null && balancerAddresses.isEmpty()) {
+      logger.log(Level.FINE, "SRV-provided hostname lookup failure", balancerAddressesException);
+    }
+    return Collections.unmodifiableList(balancerAddresses);
+  }
+
+  @VisibleForTesting
+  @Override
+  protected void setAddressResolver(AddressResolver addressResolver) {
+    super.setAddressResolver(addressResolver);
+  }
+
+  @VisibleForTesting
+  @Override
+  protected void setResourceResolver(ResourceResolver resourceResolver) {
+    super.setResourceResolver(resourceResolver);
+  }
+
+  @VisibleForTesting
+  @Override
+  protected String getHost() {
+    return super.getHost();
+  }
+
+  @VisibleForTesting
+  static void setEnableTxt(boolean enableTxt) {
+    DnsNameResolver.enableTxt = enableTxt;
+  }
+}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/GrpclbState.java b/grpclb/src/main/java/io/grpc/grpclb/GrpclbState.java
new file mode 100644
index 00000000000..5ed84ade2f8
--- /dev/null
+++ b/grpclb/src/main/java/io/grpc/grpclb/GrpclbState.java
@@ -0,0 +1,1281 @@
+/*
+ * Copyright 2017 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.grpclb;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import com.google.common.base.Stopwatch;
+import com.google.protobuf.util.Durations;
+import io.grpc.Attributes;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.Context;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.FixedResultPicker;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import io.grpc.grpclb.SubchannelPool.PooledSubchannelStateListener;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.TimeProvider;
+import io.grpc.lb.v1.ClientStats;
+import io.grpc.lb.v1.InitialLoadBalanceRequest;
+import io.grpc.lb.v1.InitialLoadBalanceResponse;
+import io.grpc.lb.v1.LoadBalanceRequest;
+import io.grpc.lb.v1.LoadBalanceResponse;
+import io.grpc.lb.v1.LoadBalanceResponse.LoadBalanceResponseTypeCase;
+import io.grpc.lb.v1.LoadBalancerGrpc;
+import io.grpc.lb.v1.Server;
+import io.grpc.lb.v1.ServerList;
+import io.grpc.stub.StreamObserver;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.NotThreadSafe;
+
+/**
+ * The states of a GRPCLB working session of {@link GrpclbLoadBalancer}.  Created when
+ * GrpclbLoadBalancer switches to GRPCLB mode.  Closed and discarded when GrpclbLoadBalancer
+ * switches away from GRPCLB mode.
+ */
+@NotThreadSafe
+final class GrpclbState {
+  static final long FALLBACK_TIMEOUT_MS = TimeUnit.SECONDS.toMillis(10);
+  private static final Attributes LB_PROVIDED_BACKEND_ATTRS =
+      Attributes.newBuilder().set(GrpclbConstants.ATTR_LB_PROVIDED_BACKEND, true).build();
+
+  // Temporary workaround to reduce log spam for a grpclb server that incessantly sends updates
+  // Tracked by b/198440401
+  static final boolean SHOULD_LOG_SERVER_LISTS =
+      Boolean.parseBoolean(System.getProperty("io.grpc.grpclb.LogServerLists", "true"));
+
+  @VisibleForTesting
+  static final PickResult DROP_PICK_RESULT =
+      PickResult.withDrop(Status.UNAVAILABLE.withDescription("Dropped as requested by balancer"));
+  @VisibleForTesting
+  static final Status NO_AVAILABLE_BACKENDS_STATUS =
+      Status.UNAVAILABLE.withDescription("LoadBalancer responded without any backends");
+  @VisibleForTesting
+  static final Status BALANCER_TIMEOUT_STATUS =
+      Status.UNAVAILABLE.withDescription("Timeout waiting for remote balancer");
+  @VisibleForTesting
+  static final Status BALANCER_REQUESTED_FALLBACK_STATUS =
+      Status.UNAVAILABLE.withDescription("Fallback requested by balancer");
+  @VisibleForTesting
+  static final Status NO_FALLBACK_BACKENDS_STATUS =
+      Status.UNAVAILABLE.withDescription("Unable to fallback, no fallback addresses found");
+  // This error status should never be propagated to RPC failures, as "no backend or balancer
+  // addresses found" should be directly handled as a name resolution error. So in cases of no
+  // balancer address, fallback should never fail.
+  private static final Status NO_LB_ADDRESS_PROVIDED_STATUS =
+      Status.UNAVAILABLE.withDescription("No balancer address found");
+
+
+  @VisibleForTesting
+  static final RoundRobinEntry BUFFER_ENTRY = new RoundRobinEntry() {
+      @Override
+      public PickResult picked(PickSubchannelArgs args) {
+        return PickResult.withNoResult();
+      }
+
+      @Override
+      public String toString() {
+        return "BUFFER_ENTRY";
+      }
+    };
+  @VisibleForTesting
+  static final String NO_USE_AUTHORITY_SUFFIX = "-notIntendedToBeUsed";
+
+  enum Mode {
+    ROUND_ROBIN,
+    PICK_FIRST,
+  }
+
+  private final String serviceName;
+  private final long fallbackTimeoutMs;
+  private final Helper helper;
+  private final Context context;
+  private final SynchronizationContext syncContext;
+  @Nullable
+  private final SubchannelPool subchannelPool;
+  private final TimeProvider time;
+  private final Stopwatch stopwatch;
+  private final ScheduledExecutorService timerService;
+
+  private static final Attributes.Key<AtomicReference<ConnectivityStateInfo>> STATE_INFO =
+      Attributes.Key.create("io.grpc.grpclb.GrpclbLoadBalancer.stateInfo");
+  private final BackoffPolicy.Provider backoffPolicyProvider;
+  private final ChannelLogger logger;
+
+  // Scheduled only once.  Never reset.
+  @Nullable
+  private ScheduledHandle fallbackTimer;
+  private List<EquivalentAddressGroup> fallbackBackendList = Collections.emptyList();
+  private boolean usingFallbackBackends;
+  // Reason to fallback, will be used as RPC's error message if fail to fallback (e.g., no
+  // fallback addresses found).
+  @Nullable
+  private Status fallbackReason;
+  // True if the current balancer has returned a serverlist.  Will be reset to false when lost
+  // connection to a balancer.
+  private boolean balancerWorking;
+  @Nullable
+  private BackoffPolicy lbRpcRetryPolicy;
+  @Nullable
+  private ScheduledHandle lbRpcRetryTimer;
+
+  @Nullable
+  private ManagedChannel lbCommChannel;
+
+  @Nullable
+  private LbStream lbStream;
+  private Map<List<EquivalentAddressGroup>, Subchannel> subchannels = Collections.emptyMap();
+  private final GrpclbConfig config;
+
+  // Has the same size as the round-robin list from the balancer.
+  // A drop entry from the round-robin list becomes a DropEntry here.
+  // A backend entry from the robin-robin list becomes a null here.
+  private List<DropEntry> dropList = Collections.emptyList();
+  // Contains only non-drop, i.e., backends from the round-robin list from the balancer.
+  private List<BackendEntry> backendList = Collections.emptyList();
+  private ConnectivityState currentState = ConnectivityState.CONNECTING;
+  private RoundRobinPicker currentPicker =
+      new RoundRobinPicker(Collections.<DropEntry>emptyList(), Arrays.asList(BUFFER_ENTRY));
+  private boolean requestConnectionPending;
+
+  // Child LoadBalancer and state for PICK_FIRST mode delegation.
+  private final LoadBalancerProvider pickFirstLbProvider;
+  @Nullable
+  private LoadBalancer pickFirstLb;
+  private ConnectivityState pickFirstLbState = CONNECTING;
+  private SubchannelPicker pickFirstLbPicker = new FixedResultPicker(PickResult.withNoResult());
+  @Nullable
+  private GrpclbClientLoadRecorder currentPickFirstLoadRecorder;
+
+  GrpclbState(
+      GrpclbConfig config,
+      Helper helper,
+      Context context,
+      SubchannelPool subchannelPool,
+      TimeProvider time,
+      Stopwatch stopwatch,
+      BackoffPolicy.Provider backoffPolicyProvider) {
+    this.config = checkNotNull(config, "config");
+    this.helper = checkNotNull(helper, "helper");
+    this.context = checkNotNull(context, "context");
+    this.syncContext = checkNotNull(helper.getSynchronizationContext(), "syncContext");
+    if (config.getMode() == Mode.ROUND_ROBIN) {
+      this.subchannelPool = checkNotNull(subchannelPool, "subchannelPool");
+      subchannelPool.registerListener(
+          new PooledSubchannelStateListener() {
+            @Override
+            public void onSubchannelState(
+                Subchannel subchannel, ConnectivityStateInfo newState) {
+              handleSubchannelState(subchannel, newState);
+            }
+          });
+    } else {
+      this.subchannelPool = null;
+    }
+    this.pickFirstLbProvider = checkNotNull(
+        LoadBalancerRegistry.getDefaultRegistry().getProvider("pick_first"),
+        "pick_first balancer not available");
+    this.time = checkNotNull(time, "time provider");
+    this.stopwatch = checkNotNull(stopwatch, "stopwatch");
+    this.timerService = checkNotNull(helper.getScheduledExecutorService(), "timerService");
+    this.backoffPolicyProvider = checkNotNull(backoffPolicyProvider, "backoffPolicyProvider");
+    if (config.getServiceName() != null) {
+      this.serviceName = config.getServiceName();
+    } else {
+      this.serviceName = checkNotNull(helper.getAuthority(), "helper returns null authority");
+    }
+    this.fallbackTimeoutMs = config.getFallbackTimeoutMs();
+    this.logger = checkNotNull(helper.getChannelLogger(), "logger");
+    logger.log(ChannelLogLevel.INFO, "[grpclb-<{0}>] Created", serviceName);
+  }
+
+  void handleSubchannelState(Subchannel subchannel, ConnectivityStateInfo newState) {
+    if (newState.getState() == SHUTDOWN || !subchannels.containsValue(subchannel)) {
+      return;
+    }
+    if (config.getMode() == Mode.ROUND_ROBIN && newState.getState() == IDLE) {
+      subchannel.requestConnection();
+    }
+    if (newState.getState() == TRANSIENT_FAILURE || newState.getState() == IDLE) {
+      helper.refreshNameResolution();
+    }
+
+    AtomicReference<ConnectivityStateInfo> stateInfoRef =
+        subchannel.getAttributes().get(STATE_INFO);
+    // If all RR servers are unhealthy, it's possible that at least one connection is CONNECTING at
+    // every moment which causes RR to stay in CONNECTING. It's better to keep the TRANSIENT_FAILURE
+    // state in that case so that fail-fast RPCs can fail fast.
+    boolean keepState =
+        config.getMode() == Mode.ROUND_ROBIN
+        && stateInfoRef.get().getState() == TRANSIENT_FAILURE
+        && (newState.getState() == CONNECTING || newState.getState() == IDLE);
+    if (!keepState) {
+      stateInfoRef.set(newState);
+      maybeUseFallbackBackends();
+      maybeUpdatePicker();
+    }
+  }
+
+  /**
+   * Handle new addresses of the balancer and backends from the resolver, and create connection if
+   * not yet connected.
+   */
+  void handleAddresses(
+      List<EquivalentAddressGroup> newLbAddressGroups,
+      List<EquivalentAddressGroup> newBackendServers) {
+    logger.log(
+        ChannelLogLevel.DEBUG,
+        "[grpclb-<{0}>] Resolved addresses: lb addresses {1}, backends: {2}",
+        serviceName,
+        newLbAddressGroups,
+        newBackendServers);
+    fallbackBackendList = newBackendServers;
+    if (newLbAddressGroups.isEmpty()) {
+      // No balancer address: close existing balancer connection and prepare to enter fallback
+      // mode. If there is no successful backend connection, it enters fallback mode immediately.
+      // Otherwise, fallback does not happen until backend connections are lost. This behavior
+      // might be different from other languages (e.g., existing balancer connection is not
+      // closed in C-core), but we aren't changing it at this time.
+      shutdownLbComm();
+      if (!usingFallbackBackends) {
+        fallbackReason = NO_LB_ADDRESS_PROVIDED_STATUS;
+        cancelFallbackTimer();
+        maybeUseFallbackBackends();
+      }
+    } else {
+      startLbComm(newLbAddressGroups);
+      // Avoid creating a new RPC just because the addresses were updated, as it can cause a
+      // stampeding herd. The current RPC may be on a connection to an address not present in
+      // newLbAddressGroups, but we're considering that "okay". If we detected the RPC is to an
+      // outdated backend, we could choose to re-create the RPC.
+      if (lbStream == null) {
+        cancelLbRpcRetryTimer();
+        startLbRpc();
+      }
+      // Start the fallback timer if it's never started and we are not already using fallback
+      // backends.
+      if (fallbackTimer == null && !usingFallbackBackends) {
+        fallbackTimer =
+            syncContext.schedule(
+                new FallbackModeTask(BALANCER_TIMEOUT_STATUS),
+                fallbackTimeoutMs,
+                TimeUnit.MILLISECONDS,
+                timerService);
+      }
+    }
+    if (usingFallbackBackends) {
+      // Populate the new fallback backends to round-robin list.
+      useFallbackBackends();
+    }
+    maybeUpdatePicker();
+  }
+
+  void requestConnection() {
+    requestConnectionPending = true;
+    // For PICK_FIRST mode with delegation, forward to the child LB.
+    if (config.getMode() == Mode.PICK_FIRST && pickFirstLb != null) {
+      pickFirstLb.requestConnection();
+      requestConnectionPending = false;
+      return;
+    }
+    for (RoundRobinEntry entry : currentPicker.pickList) {
+      if (entry instanceof IdleSubchannelEntry) {
+        ((IdleSubchannelEntry) entry).subchannel.requestConnection();
+        requestConnectionPending = false;
+      }
+    }
+  }
+
+  private void maybeUseFallbackBackends() {
+    if (balancerWorking || usingFallbackBackends) {
+      return;
+    }
+    // Balancer RPC should have either been broken or timed out.
+    checkState(fallbackReason != null, "no reason to fallback");
+    // For PICK_FIRST mode with delegation, check the child LB's state.
+    if (config.getMode() == Mode.PICK_FIRST) {
+      if (pickFirstLb != null && pickFirstLbState == READY) {
+        return;
+      }
+      // For PICK_FIRST, we don't have individual subchannel states to use as fallback reason.
+    } else {
+      for (Subchannel subchannel : subchannels.values()) {
+        ConnectivityStateInfo stateInfo = subchannel.getAttributes().get(STATE_INFO).get();
+        if (stateInfo.getState() == READY) {
+          return;
+        }
+        // If we do have balancer-provided backends, use one of its error in the error message if
+        // fail to fallback.
+        if (stateInfo.getState() == TRANSIENT_FAILURE) {
+          fallbackReason = stateInfo.getStatus();
+        }
+      }
+    }
+    // Fallback conditions met
+    useFallbackBackends();
+  }
+
+  /**
+   * Populate backend servers to be used from the fallback backends.
+   */
+  private void useFallbackBackends() {
+    usingFallbackBackends = true;
+    logger.log(ChannelLogLevel.INFO, "[grpclb-<{0}>] Using fallback backends", serviceName);
+
+    List<DropEntry> newDropList = new ArrayList<>();
+    List<BackendAddressGroup> newBackendAddrList = new ArrayList<>();
+    for (EquivalentAddressGroup eag : fallbackBackendList) {
+      newDropList.add(null);
+      newBackendAddrList.add(new BackendAddressGroup(eag, null));
+    }
+    updateServerList(newDropList, newBackendAddrList, null);
+  }
+
+  private void shutdownLbComm() {
+    shutdownLbRpc();
+    if (lbCommChannel != null) {
+      // The channel should have no RPCs at this point
+      lbCommChannel.shutdownNow();
+      lbCommChannel = null;
+    }
+  }
+
+  private void shutdownLbRpc() {
+    if (lbStream != null) {
+      lbStream.close(Status.CANCELLED.withDescription("balancer shutdown").asException());
+      // lbStream will be set to null in LbStream.cleanup()
+    }
+  }
+
+  private void startLbComm(List<EquivalentAddressGroup> overrideAuthorityEags) {
+    checkNotNull(overrideAuthorityEags, "overrideAuthorityEags");
+    assert !overrideAuthorityEags.isEmpty();
+    String doNotUseAuthority = overrideAuthorityEags.get(0).getAttributes()
+        .get(EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE) + NO_USE_AUTHORITY_SUFFIX;
+    if (lbCommChannel == null) {
+      lbCommChannel = helper.createOobChannel(overrideAuthorityEags, doNotUseAuthority);
+      logger.log(
+          ChannelLogLevel.DEBUG,
+          "[grpclb-<{0}>] Created grpclb channel: EAG={1}",
+          serviceName,
+          overrideAuthorityEags);
+    } else {
+      helper.updateOobChannelAddresses(lbCommChannel, overrideAuthorityEags);
+    }
+  }
+
+  private void startLbRpc() {
+    checkState(lbStream == null, "previous lbStream has not been cleared yet");
+    LoadBalancerGrpc.LoadBalancerStub stub = LoadBalancerGrpc.newStub(lbCommChannel);
+    lbStream = new LbStream(stub);
+    Context prevContext = context.attach();
+    try {
+      lbStream.start();
+    } finally {
+      context.detach(prevContext);
+    }
+    stopwatch.reset().start();
+
+    LoadBalanceRequest initRequest = LoadBalanceRequest.newBuilder()
+        .setInitialRequest(InitialLoadBalanceRequest.newBuilder()
+            .setName(serviceName).build())
+        .build();
+    logger.log(
+        ChannelLogLevel.DEBUG,
+        "[grpclb-<{0}>] Sent initial grpclb request {1}", serviceName, initRequest);
+    try {
+      lbStream.lbRequestWriter.onNext(initRequest);
+    } catch (Exception e) {
+      lbStream.close(e);
+    }
+  }
+
+  private void cancelFallbackTimer() {
+    if (fallbackTimer != null) {
+      fallbackTimer.cancel();
+    }
+  }
+
+  private void cancelLbRpcRetryTimer() {
+    if (lbRpcRetryTimer != null) {
+      lbRpcRetryTimer.cancel();
+      lbRpcRetryTimer = null;
+    }
+  }
+
+  void shutdown() {
+    logger.log(ChannelLogLevel.INFO, "[grpclb-<{0}>] Shutdown", serviceName);
+    shutdownLbComm();
+    switch (config.getMode()) {
+      case ROUND_ROBIN:
+        // We close the subchannels through subchannelPool instead of helper just for convenience of
+        // testing.
+        for (Subchannel subchannel : subchannels.values()) {
+          returnSubchannelToPool(subchannel);
+        }
+        subchannelPool.clear();
+        break;
+      case PICK_FIRST:
+        // Shutdown the child pick_first LB which manages its own subchannels.
+        if (pickFirstLb != null) {
+          pickFirstLb.shutdown();
+          pickFirstLb = null;
+        }
+        break;
+      default:
+        throw new AssertionError("Missing case for " + config.getMode());
+    }
+    subchannels = Collections.emptyMap();
+    cancelFallbackTimer();
+    cancelLbRpcRetryTimer();
+  }
+
+  void propagateError(Status status) {
+    logger.log(ChannelLogLevel.DEBUG, "[grpclb-<{0}>] Error: {1}", serviceName, status);
+    if (backendList.isEmpty()) {
+      Status error =
+          Status.UNAVAILABLE.withCause(status.getCause()).withDescription(status.getDescription());
+      maybeUpdatePicker(
+          TRANSIENT_FAILURE, new RoundRobinPicker(dropList, Arrays.asList(new ErrorEntry(error))));
+    }
+  }
+
+  private void returnSubchannelToPool(Subchannel subchannel) {
+    subchannelPool.returnSubchannel(subchannel, subchannel.getAttributes().get(STATE_INFO).get());
+  }
+
+  @VisibleForTesting
+  @Nullable
+  GrpclbClientLoadRecorder getLoadRecorder() {
+    if (lbStream == null) {
+      return null;
+    }
+    return lbStream.loadRecorder;
+  }
+
+  /**
+   * Populate backend servers to be used based on the given list of addresses.
+   */
+  private void updateServerList(
+      List<DropEntry> newDropList, List<BackendAddressGroup> newBackendAddrList,
+      @Nullable GrpclbClientLoadRecorder loadRecorder) {
+    HashMap<List<EquivalentAddressGroup>, Subchannel> newSubchannelMap =
+        new HashMap<>();
+    List<BackendEntry> newBackendList = new ArrayList<>();
+
+    switch (config.getMode()) {
+      case ROUND_ROBIN:
+        for (BackendAddressGroup backendAddr : newBackendAddrList) {
+          EquivalentAddressGroup eag = backendAddr.getAddresses();
+          List<EquivalentAddressGroup> eagAsList = Collections.singletonList(eag);
+          Subchannel subchannel = newSubchannelMap.get(eagAsList);
+          if (subchannel == null) {
+            subchannel = subchannels.get(eagAsList);
+            if (subchannel == null) {
+              subchannel = subchannelPool.takeOrCreateSubchannel(eag, createSubchannelAttrs());
+              subchannel.requestConnection();
+            }
+            newSubchannelMap.put(eagAsList, subchannel);
+          }
+          BackendEntry entry;
+          // Only picks with tokens are reported to LoadRecorder
+          if (backendAddr.getToken() == null) {
+            entry = new BackendEntry(subchannel);
+          } else {
+            entry = new BackendEntry(subchannel, loadRecorder, backendAddr.getToken());
+          }
+          newBackendList.add(entry);
+        }
+        // Close Subchannels whose addresses have been delisted
+        for (Map.Entry<List<EquivalentAddressGroup>, Subchannel> entry : subchannels.entrySet()) {
+          List<EquivalentAddressGroup> eagList = entry.getKey();
+          if (!newSubchannelMap.containsKey(eagList)) {
+            returnSubchannelToPool(entry.getValue());
+          }
+        }
+        subchannels = Collections.unmodifiableMap(newSubchannelMap);
+        break;
+      case PICK_FIRST:
+        // Delegate to child pick_first LB for address management.
+        // Shutdown existing child LB if addresses become empty.
+        if (newBackendAddrList.isEmpty()) {
+          if (pickFirstLb != null) {
+            pickFirstLb.shutdown();
+            pickFirstLb = null;
+          }
+          break;
+        }
+        List<EquivalentAddressGroup> eagList = new ArrayList<>();
+        // Attach tokens to EAG attributes for TokenAttachingTracerFactory to retrieve.
+        for (BackendAddressGroup bag : newBackendAddrList) {
+          EquivalentAddressGroup origEag = bag.getAddresses();
+          Attributes eagAttrs = origEag.getAttributes();
+          if (bag.getToken() != null) {
+            eagAttrs = eagAttrs.toBuilder()
+                .set(GrpclbConstants.TOKEN_ATTRIBUTE_KEY, bag.getToken()).build();
+          }
+          eagList.add(new EquivalentAddressGroup(origEag.getAddresses(), eagAttrs));
+        }
+
+        if (pickFirstLb == null) {
+          pickFirstLb = pickFirstLbProvider.newLoadBalancer(new PickFirstLbHelper());
+        }
+
+        // Pass addresses to child LB.
+        pickFirstLb.acceptResolvedAddresses(
+            ResolvedAddresses.newBuilder()
+                .setAddresses(eagList)
+                .build());
+        if (requestConnectionPending) {
+          pickFirstLb.requestConnection();
+          requestConnectionPending = false;
+        }
+        // Store the load recorder for token attachment.
+        currentPickFirstLoadRecorder = loadRecorder;
+        break;
+      default:
+        throw new AssertionError("Missing case for " + config.getMode());
+    }
+
+    dropList = Collections.unmodifiableList(newDropList);
+    backendList = Collections.unmodifiableList(newBackendList);
+  }
+
+  @VisibleForTesting
+  class FallbackModeTask implements Runnable {
+    private final Status reason;
+
+    private FallbackModeTask(Status reason) {
+      this.reason = reason;
+    }
+
+    @Override
+    public void run() {
+      // Timer should have been cancelled if entered fallback early.
+      checkState(!usingFallbackBackends, "already in fallback");
+      fallbackReason = reason;
+      maybeUseFallbackBackends();
+      maybeUpdatePicker();
+    }
+  }
+
+  @VisibleForTesting
+  class LbRpcRetryTask implements Runnable {
+    @Override
+    public void run() {
+      startLbRpc();
+    }
+  }
+
+  @VisibleForTesting
+  static class LoadReportingTask implements Runnable {
+    private final LbStream stream;
+
+    LoadReportingTask(LbStream stream) {
+      this.stream = stream;
+    }
+
+    @Override
+    public void run() {
+      stream.loadReportTimer = null;
+      stream.sendLoadReport();
+    }
+  }
+
+  private class LbStream implements StreamObserver<LoadBalanceResponse> {
+    final GrpclbClientLoadRecorder loadRecorder;
+    final LoadBalancerGrpc.LoadBalancerStub stub;
+    StreamObserver<LoadBalanceRequest> lbRequestWriter;
+
+    // These fields are only accessed from helper.runSerialized()
+    boolean initialResponseReceived;
+    boolean closed;
+    long loadReportIntervalMillis = -1;
+    ScheduledHandle loadReportTimer;
+
+    LbStream(LoadBalancerGrpc.LoadBalancerStub stub) {
+      this.stub = checkNotNull(stub, "stub");
+      // Stats data only valid for current LbStream.  We do not carry over data from previous
+      // stream.
+      loadRecorder = new GrpclbClientLoadRecorder(time);
+    }
+
+    void start() {
+      lbRequestWriter = stub.withWaitForReady().balanceLoad(this);
+    }
+
+    @Override public void onNext(final LoadBalanceResponse response) {
+      syncContext.execute(new Runnable() {
+          @Override
+          public void run() {
+            handleResponse(response);
+          }
+        });
+    }
+
+    @Override public void onError(final Throwable error) {
+      syncContext.execute(new Runnable() {
+          @Override
+          public void run() {
+            handleStreamClosed(Status.fromThrowable(error)
+                .augmentDescription("Stream to GRPCLB LoadBalancer had an error"));
+          }
+        });
+    }
+
+    @Override public void onCompleted() {
+      syncContext.execute(new Runnable() {
+          @Override
+          public void run() {
+            handleStreamClosed(
+                Status.UNAVAILABLE.withDescription("Stream to GRPCLB LoadBalancer was closed"));
+          }
+        });
+    }
+
+    // Following methods must be run in helper.runSerialized()
+
+    private void sendLoadReport() {
+      if (closed) {
+        return;
+      }
+      ClientStats stats = loadRecorder.generateLoadReport();
+      // TODO(zhangkun83): flow control?
+      try {
+        lbRequestWriter.onNext(LoadBalanceRequest.newBuilder().setClientStats(stats).build());
+        scheduleNextLoadReport();
+      } catch (Exception e) {
+        close(e);
+      }
+    }
+
+    private void scheduleNextLoadReport() {
+      if (loadReportIntervalMillis > 0) {
+        loadReportTimer = syncContext.schedule(
+            new LoadReportingTask(this), loadReportIntervalMillis, TimeUnit.MILLISECONDS,
+            timerService);
+      }
+    }
+
+    private void handleResponse(LoadBalanceResponse response) {
+      if (closed) {
+        return;
+      }
+
+      LoadBalanceResponseTypeCase typeCase = response.getLoadBalanceResponseTypeCase();
+      if (!initialResponseReceived) {
+        logger.log(
+            ChannelLogLevel.INFO,
+            "[grpclb-<{0}>] Got an LB initial response: {1}", serviceName, response);
+        if (typeCase != LoadBalanceResponseTypeCase.INITIAL_RESPONSE) {
+          logger.log(
+              ChannelLogLevel.WARNING,
+              "[grpclb-<{0}>] Received a response without initial response",
+              serviceName);
+          return;
+        }
+        initialResponseReceived = true;
+        InitialLoadBalanceResponse initialResponse = response.getInitialResponse();
+        loadReportIntervalMillis =
+            Durations.toMillis(initialResponse.getClientStatsReportInterval());
+        scheduleNextLoadReport();
+        return;
+      }
+      if (SHOULD_LOG_SERVER_LISTS) {
+        logger.log(
+            ChannelLogLevel.DEBUG, "[grpclb-<{0}>] Got an LB response: {1}", serviceName, response);
+      } else {
+        logger.log(ChannelLogLevel.DEBUG, "[grpclb-<{0}>] Got an LB response", serviceName);
+      }
+
+      if (typeCase == LoadBalanceResponseTypeCase.FALLBACK_RESPONSE) {
+        // Force entering fallback requested by balancer.
+        cancelFallbackTimer();
+        fallbackReason = BALANCER_REQUESTED_FALLBACK_STATUS;
+        useFallbackBackends();
+        maybeUpdatePicker();
+        return;
+      } else if (typeCase != LoadBalanceResponseTypeCase.SERVER_LIST) {
+        logger.log(
+            ChannelLogLevel.WARNING,
+            "[grpclb-<{0}>] Ignoring unexpected response type: {1}",
+            serviceName,
+            typeCase);
+        return;
+      }
+
+      balancerWorking = true;
+      // TODO(zhangkun83): handle delegate from initialResponse
+      ServerList serverList = response.getServerList();
+      List<DropEntry> newDropList = new ArrayList<>();
+      List<BackendAddressGroup> newBackendAddrList = new ArrayList<>();
+      // Construct the new collections. Create new Subchannels when necessary.
+      for (Server server : serverList.getServersList()) {
+        String token = server.getLoadBalanceToken();
+        if (server.getDrop()) {
+          newDropList.add(new DropEntry(loadRecorder, token));
+        } else {
+          newDropList.add(null);
+          InetSocketAddress address;
+          try {
+            address = new InetSocketAddress(
+                InetAddress.getByAddress(server.getIpAddress().toByteArray()), server.getPort());
+          } catch (UnknownHostException e) {
+            propagateError(
+                Status.UNAVAILABLE
+                    .withDescription("Invalid backend address: " + server)
+                    .withCause(e));
+            continue;
+          }
+          // ALTS code can use the presence of ATTR_LB_PROVIDED_BACKEND to select ALTS instead of
+          // TLS, with Netty.
+          EquivalentAddressGroup eag =
+              new EquivalentAddressGroup(address, LB_PROVIDED_BACKEND_ATTRS);
+          newBackendAddrList.add(new BackendAddressGroup(eag, token));
+        }
+      }
+      // Exit fallback as soon as a new server list is received from the balancer.
+      usingFallbackBackends = false;
+      fallbackReason = null;
+      cancelFallbackTimer();
+      updateServerList(newDropList, newBackendAddrList, loadRecorder);
+      maybeUpdatePicker();
+    }
+
+    private void handleStreamClosed(Status error) {
+      checkArgument(!error.isOk(), "unexpected OK status");
+      if (closed) {
+        return;
+      }
+      closed = true;
+      cleanUp();
+      propagateError(error);
+      balancerWorking = false;
+      fallbackReason = error;
+      cancelFallbackTimer();
+      maybeUseFallbackBackends();
+      maybeUpdatePicker();
+
+      long delayNanos = 0;
+      if (initialResponseReceived || lbRpcRetryPolicy == null) {
+        // Reset the backoff sequence if balancer has sent the initial response, or backoff sequence
+        // has never been initialized.
+        lbRpcRetryPolicy = backoffPolicyProvider.get();
+      }
+      // Backoff only when balancer wasn't working previously.
+      if (!initialResponseReceived) {
+        // The back-off policy determines the interval between consecutive RPC upstarts, thus the
+        // actual delay may be smaller than the value from the back-off policy, or even negative,
+        // depending how much time was spent in the previous RPC.
+        delayNanos =
+            lbRpcRetryPolicy.nextBackoffNanos() - stopwatch.elapsed(TimeUnit.NANOSECONDS);
+      }
+      if (delayNanos <= 0) {
+        startLbRpc();
+      } else {
+        lbRpcRetryTimer =
+            syncContext.schedule(new LbRpcRetryTask(), delayNanos, TimeUnit.NANOSECONDS,
+                timerService);
+      }
+
+      helper.refreshNameResolution();
+    }
+
+    void close(Exception error) {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      cleanUp();
+      lbRequestWriter.onError(error);
+    }
+
+    private void cleanUp() {
+      if (loadReportTimer != null) {
+        loadReportTimer.cancel();
+        loadReportTimer = null;
+      }
+      if (lbStream == this) {
+        lbStream = null;
+      }
+    }
+  }
+
+  /**
+   * Make and use a picker out of the current lists and the states of subchannels if they have
+   * changed since the last picker created.
+   */
+  private void maybeUpdatePicker() {
+    List<RoundRobinEntry> pickList;
+    ConnectivityState state;
+    // For PICK_FIRST mode with delegation, check if child LB exists instead of backendList.
+    boolean hasBackends = config.getMode() == Mode.PICK_FIRST
+        ? pickFirstLb != null
+        : !backendList.isEmpty();
+    if (!hasBackends) {
+      // Note balancer (is working) may enforce using fallback backends, and that fallback may
+      // fail. So we should check if currently in fallback first.
+      if (usingFallbackBackends) {
+        Status error =
+            NO_FALLBACK_BACKENDS_STATUS
+                .withCause(fallbackReason.getCause())
+                .augmentDescription(fallbackReason.getDescription());
+        pickList = Collections.<RoundRobinEntry>singletonList(new ErrorEntry(error));
+        state = TRANSIENT_FAILURE;
+      } else if (balancerWorking)  {
+        pickList =
+            Collections.<RoundRobinEntry>singletonList(
+                new ErrorEntry(NO_AVAILABLE_BACKENDS_STATUS));
+        state = TRANSIENT_FAILURE;
+      } else {  // still waiting for balancer
+        pickList = Collections.singletonList(BUFFER_ENTRY);
+        state = CONNECTING;
+      }
+      maybeUpdatePicker(state, new RoundRobinPicker(dropList, pickList));
+      return;
+    }
+    switch (config.getMode()) {
+      case ROUND_ROBIN:
+        pickList = new ArrayList<>(backendList.size());
+        Status error = null;
+        boolean hasPending = false;
+        for (BackendEntry entry : backendList) {
+          Subchannel subchannel = entry.subchannel;
+          Attributes attrs = subchannel.getAttributes();
+          ConnectivityStateInfo stateInfo = attrs.get(STATE_INFO).get();
+          if (stateInfo.getState() == READY) {
+            pickList.add(entry);
+          } else if (stateInfo.getState() == TRANSIENT_FAILURE) {
+            error = stateInfo.getStatus();
+          } else {
+            hasPending = true;
+          }
+        }
+        if (pickList.isEmpty()) {
+          if (hasPending) {
+            pickList.add(BUFFER_ENTRY);
+            state = CONNECTING;
+          } else {
+            pickList.add(new ErrorEntry(error));
+            state = TRANSIENT_FAILURE;
+          }
+        } else {
+          state = READY;
+        }
+        break;
+      case PICK_FIRST: {
+        // Use child LB's state and picker. Wrap the picker for token attachment.
+        state = pickFirstLbState;
+        TokenAttachingTracerFactory tracerFactory =
+            new TokenAttachingTracerFactory(currentPickFirstLoadRecorder);
+        pickList = Collections.<RoundRobinEntry>singletonList(
+            new ChildLbPickerEntry(pickFirstLbPicker, tracerFactory));
+        break;
+      }
+      default:
+        throw new AssertionError("Missing case for " + config.getMode());
+    }
+    maybeUpdatePicker(state, new RoundRobinPicker(dropList, pickList));
+  }
+
+  /**
+   * Update the given picker to the helper if it's different from the current one.
+   */
+  private void maybeUpdatePicker(ConnectivityState state, RoundRobinPicker picker) {
+    // Discard the new picker if we are sure it won't make any difference, in order to save
+    // re-processing pending streams, and avoid unnecessary resetting of the pointer in
+    // RoundRobinPicker.
+    if (state.equals(currentState)
+        && picker.dropList.equals(currentPicker.dropList)
+        && picker.pickList.equals(currentPicker.pickList)) {
+      return;
+    }
+    currentState = state;
+    currentPicker = picker;
+    helper.updateBalancingState(state, picker);
+  }
+
+  private static Attributes createSubchannelAttrs() {
+    return Attributes.newBuilder()
+        .set(STATE_INFO,
+            new AtomicReference<>(
+                ConnectivityStateInfo.forNonError(IDLE)))
+        .build();
+  }
+
+  @VisibleForTesting
+  static final class DropEntry {
+    private final GrpclbClientLoadRecorder loadRecorder;
+    private final String token;
+
+    DropEntry(GrpclbClientLoadRecorder loadRecorder, String token) {
+      this.loadRecorder = checkNotNull(loadRecorder, "loadRecorder");
+      this.token = checkNotNull(token, "token");
+    }
+
+    PickResult picked() {
+      loadRecorder.recordDroppedRequest(token);
+      return DROP_PICK_RESULT;
+    }
+
+    @Override
+    public String toString() {
+      // This is printed in logs.  Only include useful information.
+      return "drop(" + token + ")";
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(loadRecorder, token);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+      if (!(other instanceof DropEntry)) {
+        return false;
+      }
+      DropEntry that = (DropEntry) other;
+      return Objects.equal(loadRecorder, that.loadRecorder) && Objects.equal(token, that.token);
+    }
+  }
+
+  @VisibleForTesting
+  interface RoundRobinEntry {
+    PickResult picked(PickSubchannelArgs args);
+  }
+
+  @VisibleForTesting
+  static final class BackendEntry implements RoundRobinEntry {
+    final Subchannel subchannel;
+    @VisibleForTesting
+    final PickResult result;
+    @Nullable
+    private final String token;
+
+    /**
+     * For ROUND_ROBIN: creates a BackendEntry whose usage will be reported to load recorder.
+     */
+    BackendEntry(Subchannel subchannel, GrpclbClientLoadRecorder loadRecorder, String token) {
+      this.subchannel = checkNotNull(subchannel, "subchannel");
+      this.result =
+          PickResult.withSubchannel(subchannel, checkNotNull(loadRecorder, "loadRecorder"));
+      this.token = checkNotNull(token, "token");
+    }
+
+    /**
+     * For ROUND_ROBIN/PICK_FIRST: creates a BackendEntry whose usage will not be reported.
+     */
+    BackendEntry(Subchannel subchannel) {
+      this.subchannel = checkNotNull(subchannel, "subchannel");
+      this.result = PickResult.withSubchannel(subchannel);
+      this.token = null;
+    }
+
+    /**
+     * For PICK_FIRST: creates a BackendEntry that includes all addresses.
+     */
+    BackendEntry(Subchannel subchannel, TokenAttachingTracerFactory tracerFactory) {
+      this.subchannel = checkNotNull(subchannel, "subchannel");
+      this.result =
+          PickResult.withSubchannel(subchannel, checkNotNull(tracerFactory, "tracerFactory"));
+      this.token = null;
+    }
+
+    @Override
+    public PickResult picked(PickSubchannelArgs args) {
+      Metadata headers = args.getHeaders();
+      headers.discardAll(GrpclbConstants.TOKEN_METADATA_KEY);
+      if (token != null) {
+        headers.put(GrpclbConstants.TOKEN_METADATA_KEY, token);
+      }
+      return result;
+    }
+
+    @Override
+    public String toString() {
+      // This is printed in logs.  Only give out useful information.
+      return "[" + subchannel.getAllAddresses().toString() + "(" + token + ")]";
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(result, token);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+      if (!(other instanceof BackendEntry)) {
+        return false;
+      }
+      BackendEntry that = (BackendEntry) other;
+      return Objects.equal(result, that.result) && Objects.equal(token, that.token);
+    }
+  }
+
+  @VisibleForTesting
+  static final class IdleSubchannelEntry implements RoundRobinEntry {
+    private final SynchronizationContext syncContext;
+    private final Subchannel subchannel;
+    private final AtomicBoolean connectionRequested = new AtomicBoolean(false);
+
+    IdleSubchannelEntry(Subchannel subchannel, SynchronizationContext syncContext) {
+      this.subchannel = checkNotNull(subchannel, "subchannel");
+      this.syncContext = checkNotNull(syncContext, "syncContext");
+    }
+
+    @Override
+    public PickResult picked(PickSubchannelArgs args) {
+      if (connectionRequested.compareAndSet(false, true)) {
+        syncContext.execute(new Runnable() {
+            @Override
+            public void run() {
+              subchannel.requestConnection();
+            }
+          });
+      }
+      return PickResult.withNoResult();
+    }
+
+    @Override
+    public String toString() {
+      // This is printed in logs.  Only give out useful information.
+      return "(idle)[" + subchannel.getAllAddresses().toString() + "]";
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(subchannel, syncContext);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+      if (!(other instanceof IdleSubchannelEntry)) {
+        return false;
+      }
+      IdleSubchannelEntry that = (IdleSubchannelEntry) other;
+      return Objects.equal(subchannel, that.subchannel)
+          && Objects.equal(syncContext, that.syncContext);
+    }
+  }
+
+  @VisibleForTesting
+  static final class ErrorEntry implements RoundRobinEntry {
+    final PickResult result;
+
+    ErrorEntry(Status status) {
+      result = PickResult.withError(status);
+    }
+
+    @Override
+    public PickResult picked(PickSubchannelArgs args) {
+      return result;
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(result);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+      if (!(other instanceof ErrorEntry)) {
+        return false;
+      }
+      return Objects.equal(result, ((ErrorEntry) other).result);
+    }
+
+    @Override
+    public String toString() {
+      // This is printed in logs.  Only include useful information.
+      return result.getStatus().toString();
+    }
+  }
+
+  /**
+   * Entry that wraps a child LB's picker for PICK_FIRST mode delegation.
+   * Attaches TokenAttachingTracerFactory to the pick result for token propagation.
+   */
+  @VisibleForTesting
+  static final class ChildLbPickerEntry implements RoundRobinEntry {
+    private final SubchannelPicker childPicker;
+    private final TokenAttachingTracerFactory tracerFactory;
+
+    ChildLbPickerEntry(SubchannelPicker childPicker, TokenAttachingTracerFactory tracerFactory) {
+      this.childPicker = checkNotNull(childPicker, "childPicker");
+      this.tracerFactory = checkNotNull(tracerFactory, "tracerFactory");
+    }
+
+    @Override
+    public PickResult picked(PickSubchannelArgs args) {
+      PickResult childResult = childPicker.pickSubchannel(args);
+      if (childResult.getSubchannel() == null) {
+        // No subchannel (e.g., buffer, error), return as-is.
+        return childResult;
+      }
+      // Wrap the pick result to attach tokens via the tracer factory.
+      return PickResult.withSubchannel(
+          childResult.getSubchannel(), tracerFactory, childResult.getAuthorityOverride());
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(childPicker, tracerFactory);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+      if (!(other instanceof ChildLbPickerEntry)) {
+        return false;
+      }
+      ChildLbPickerEntry that = (ChildLbPickerEntry) other;
+      return Objects.equal(childPicker, that.childPicker)
+          && Objects.equal(tracerFactory, that.tracerFactory);
+    }
+
+    @Override
+    public String toString() {
+      return "ChildLbPickerEntry(" + childPicker + ")";
+    }
+
+    @VisibleForTesting
+    SubchannelPicker getChildPicker() {
+      return childPicker;
+    }
+  }
+
+  @VisibleForTesting
+  static final class RoundRobinPicker extends SubchannelPicker {
+    @VisibleForTesting
+    final List<DropEntry> dropList;
+    private int dropIndex;
+
+    @VisibleForTesting
+    final List<? extends RoundRobinEntry> pickList;
+    private int pickIndex;
+
+    // dropList can be empty, which means no drop.
+    // pickList must not be empty.
+    RoundRobinPicker(List<DropEntry> dropList, List<? extends RoundRobinEntry> pickList) {
+      this.dropList = checkNotNull(dropList, "dropList");
+      this.pickList = checkNotNull(pickList, "pickList");
+      checkArgument(!pickList.isEmpty(), "pickList is empty");
+    }
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      synchronized (pickList) {
+        // Two-level round-robin.
+        // First round-robin on dropList. If a drop entry is selected, request will be dropped.  If
+        // a non-drop entry is selected, then round-robin on pickList.  This makes sure requests are
+        // dropped at the same proportion as the drop entries appear on the round-robin list from
+        // the balancer, while only backends from pickList are selected for the non-drop cases.
+        if (!dropList.isEmpty()) {
+          DropEntry drop = dropList.get(dropIndex);
+          dropIndex++;
+          if (dropIndex == dropList.size()) {
+            dropIndex = 0;
+          }
+          if (drop != null) {
+            return drop.picked();
+          }
+        }
+
+        RoundRobinEntry pick = pickList.get(pickIndex);
+        pickIndex++;
+        if (pickIndex == pickList.size()) {
+          pickIndex = 0;
+        }
+        return pick.picked(args);
+      }
+    }
+
+    @Override
+    public String toString() {
+      if (SHOULD_LOG_SERVER_LISTS) {
+        return MoreObjects.toStringHelper(RoundRobinPicker.class)
+            .add("dropList", dropList)
+            .add("pickList", pickList)
+            .toString();
+      }
+      return MoreObjects.toStringHelper(RoundRobinPicker.class).toString();
+    }
+  }
+
+  /**
+   * Helper for the child pick_first LB in PICK_FIRST mode. Intercepts updateBalancingState()
+   * to store state and trigger the grpclb picker update with drops and token attachment.
+   */
+  private final class PickFirstLbHelper extends ForwardingLoadBalancerHelper {
+
+    @Override
+    protected Helper delegate() {
+      return helper;
+    }
+
+    @Override
+    public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+      pickFirstLbState = newState;
+      pickFirstLbPicker = newPicker;
+      // Trigger name resolution refresh on TRANSIENT_FAILURE or IDLE, similar to ROUND_ROBIN.
+      if (newState == TRANSIENT_FAILURE || newState == IDLE) {
+        helper.refreshNameResolution();
+      }
+      maybeUseFallbackBackends();
+      maybeUpdatePicker();
+    }
+  }
+}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/InternalGrpclbConstantsAccessor.java b/grpclb/src/main/java/io/grpc/grpclb/InternalGrpclbConstantsAccessor.java
new file mode 100644
index 00000000000..a458cb87d55
--- /dev/null
+++ b/grpclb/src/main/java/io/grpc/grpclb/InternalGrpclbConstantsAccessor.java
@@ -0,0 +1,41 @@
+/*
+ * 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.grpclb;
+
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.Internal;
+import java.util.List;
+
+/**
+ * Internal {@link GrpclbConstants} accessor. This is intended for usage internal to the gRPC
+ * team. If you *really* think you need to use this, contact the gRPC team first.
+ */
+@Internal
+public final class InternalGrpclbConstantsAccessor {
+
+  // Prevent instantiation.
+  private InternalGrpclbConstantsAccessor() {
+  }
+
+  public static final Attributes.Key<List<EquivalentAddressGroup>> ATTR_LB_ADDRS =
+      GrpclbConstants.ATTR_LB_ADDRS;
+
+  @EquivalentAddressGroup.Attr
+  public static final Attributes.Key<String> ATTR_LB_ADDR_AUTHORITY =
+      GrpclbConstants.ATTR_LB_ADDR_AUTHORITY;
+}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/LbAddressGroup.java b/grpclb/src/main/java/io/grpc/grpclb/LbAddressGroup.java
deleted file mode 100644
index 1fb75c445f0..00000000000
--- a/grpclb/src/main/java/io/grpc/grpclb/LbAddressGroup.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.grpclb;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import io.grpc.EquivalentAddressGroup;
-
-/**
- * Represents a balancer address entry.
- */
-class LbAddressGroup {
-  private final EquivalentAddressGroup addresses;
-  private final String authority;
-
-  LbAddressGroup(EquivalentAddressGroup addresses, String authority) {
-    this.addresses = checkNotNull(addresses, "addresses");
-    this.authority = checkNotNull(authority, "authority");
-  }
-
-  @Override
-  public boolean equals(Object other) {
-    if (!(other instanceof LbAddressGroup)) {
-      return false;
-    }
-    LbAddressGroup otherGroup = (LbAddressGroup) other;
-    return addresses.equals(otherGroup.addresses) && authority.equals(otherGroup.authority);
-  }
-
-  @Override
-  public int hashCode() {
-    return addresses.hashCode();
-  }
-
-  EquivalentAddressGroup getAddresses() {
-    return addresses;
-  }
-
-  String getAuthority() {
-    return authority;
-  }
-}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/SecretGrpclbNameResolverProvider.java b/grpclb/src/main/java/io/grpc/grpclb/SecretGrpclbNameResolverProvider.java
new file mode 100644
index 00000000000..8952ea1d8fb
--- /dev/null
+++ b/grpclb/src/main/java/io/grpc/grpclb/SecretGrpclbNameResolverProvider.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright 2019 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.grpclb;
+
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import io.grpc.InternalServiceProviders;
+import io.grpc.NameResolver.Args;
+import io.grpc.NameResolverProvider;
+import io.grpc.internal.GrpcUtil;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * A provider for {@code io.grpc.grpclb.GrpclbNameResolver}.
+ *
+ * <p>It resolves a target URI whose scheme is {@code "dns"}. The (optional) authority of the target
+ * URI is reserved for the address of alternative DNS server (not implemented yet). The path of the
+ * target URI, excluding the leading slash {@code '/'}, is treated as the host name and the optional
+ * port to be resolved by DNS. Example target URIs:
+ *
+ * <ul>
+ *   <li>{@code "dns:///foo.googleapis.com:8080"} (using default DNS)</li>
+ *   <li>{@code "dns://8.8.8.8/foo.googleapis.com:8080"} (using alternative DNS (not implemented
+ *   yet))</li>
+ *   <li>{@code "dns:///foo.googleapis.com"} (without port)</li>
+ * </ul>
+ */
+// Make it package-private so that it cannot be directly referenced by users.  Java service loader
+// requires the provider to be public, but we can hide it under a package-private class.
+final class SecretGrpclbNameResolverProvider {
+
+  private SecretGrpclbNameResolverProvider() {}
+
+  public static final class Provider extends NameResolverProvider {
+
+    private static final String SCHEME = "dns";
+
+    private static final boolean IS_ANDROID = InternalServiceProviders
+        .isAndroid(SecretGrpclbNameResolverProvider.class.getClassLoader());
+
+    @Override
+    public GrpclbNameResolver newNameResolver(URI targetUri, Args args) {
+      if (SCHEME.equals(targetUri.getScheme())) {
+        String targetPath = Preconditions.checkNotNull(targetUri.getPath(), "targetPath");
+        Preconditions.checkArgument(
+            targetPath.startsWith("/"),
+            "the path component (%s) of the target (%s) must start with '/'",
+            targetPath, targetUri);
+        String name = targetPath.substring(1);
+        return new GrpclbNameResolver(
+            targetUri.getAuthority(),
+            name,
+            args,
+            GrpcUtil.SHARED_CHANNEL_EXECUTOR,
+            Stopwatch.createUnstarted(),
+            IS_ANDROID);
+      } else {
+        return null;
+      }
+    }
+
+    @Override
+    public String getDefaultScheme() {
+      return SCHEME;
+    }
+
+    @Override
+    protected boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int priority() {
+      // Must be higher than DnsNameResolverProvider#priority.
+      return 6;
+    }
+
+    @Override
+    public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+      return Collections.singleton(InetSocketAddress.class);
+    }
+  }
+}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/SubchannelPool.java b/grpclb/src/main/java/io/grpc/grpclb/SubchannelPool.java
new file mode 100644
index 00000000000..e312ecdc0cf
--- /dev/null
+++ b/grpclb/src/main/java/io/grpc/grpclb/SubchannelPool.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2018 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.grpclb;
+
+import io.grpc.Attributes;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer.Subchannel;
+import javax.annotation.concurrent.NotThreadSafe;
+
+/**
+ * Manages life-cycle of Subchannels for {@link GrpclbState}.
+ *
+ * <p>All methods are run from the ChannelExecutor that the helper uses.
+ */
+@NotThreadSafe
+interface SubchannelPool {
+
+  /**
+   * Registers a listener to received Subchannel status updates.
+   */
+  void registerListener(PooledSubchannelStateListener listener);
+
+  /**
+   * Takes a {@link Subchannel} from the pool for the given {@code eag} if there is one available.
+   * Otherwise, creates and returns a new {@code Subchannel} with the given {@code eag} and {@code
+   * defaultAttributes}.
+   */
+  Subchannel takeOrCreateSubchannel(EquivalentAddressGroup eag, Attributes defaultAttributes);
+
+  /**
+   * Puts a {@link Subchannel} back to the pool.  From this point the Subchannel is owned by the
+   * pool, and the caller should stop referencing to this Subchannel.
+   */
+  void returnSubchannel(Subchannel subchannel, ConnectivityStateInfo lastKnownState);
+
+  /**
+   * Shuts down all subchannels in the pool immediately.
+   */
+  void clear();
+
+  /**
+   * Receives state changes for a pooled {@link Subchannel}.
+   */
+  interface PooledSubchannelStateListener {
+
+    /**
+     * Handles a state change on a Subchannel. The behavior is similar to {@link
+     * io.grpc.LoadBalancer.SubchannelStateListener}.
+     *
+     * <p>When a subchannel is reused, subchannel state change event will be triggered even if the
+     * underlying status remains same.
+     */
+    void onSubchannelState(Subchannel subchannel, ConnectivityStateInfo newState);
+
+  }
+}
diff --git a/grpclb/src/main/java/io/grpc/grpclb/TokenAttachingTracerFactory.java b/grpclb/src/main/java/io/grpc/grpclb/TokenAttachingTracerFactory.java
new file mode 100644
index 00000000000..c00d988aa5d
--- /dev/null
+++ b/grpclb/src/main/java/io/grpc/grpclb/TokenAttachingTracerFactory.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2019 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.grpclb;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Objects;
+import io.grpc.Attributes;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Metadata;
+import io.grpc.internal.ForwardingClientStreamTracer;
+import io.grpc.internal.GrpcAttributes;
+import javax.annotation.Nullable;
+
+/**
+ * Wraps a {@link ClientStreamTracer.Factory}, retrieves tokens from transport attributes and
+ * attaches them to headers.  This is only used in the PICK_FIRST mode.
+ */
+final class TokenAttachingTracerFactory extends ClientStreamTracer.Factory {
+  private static final ClientStreamTracer NOOP_TRACER = new ClientStreamTracer() {};
+
+  @Nullable
+  private final ClientStreamTracer.Factory delegate;
+
+  TokenAttachingTracerFactory(@Nullable ClientStreamTracer.Factory delegate) {
+    this.delegate = delegate;
+  }
+
+  @Override
+  public ClientStreamTracer newClientStreamTracer(
+      ClientStreamTracer.StreamInfo info, Metadata headers) {
+    if (delegate == null) {
+      return NOOP_TRACER;
+    }
+    final ClientStreamTracer clientStreamTracer = delegate.newClientStreamTracer(info, headers);
+    class TokenPropagationTracer extends ForwardingClientStreamTracer {
+      @Override
+      protected ClientStreamTracer delegate() {
+        return clientStreamTracer;
+      }
+
+      @Override
+      public void streamCreated(Attributes transportAttrs, Metadata headers) {
+        Attributes eagAttrs =
+            checkNotNull(transportAttrs.get(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS), "eagAttrs");
+        String token = eagAttrs.get(GrpclbConstants.TOKEN_ATTRIBUTE_KEY);
+        headers.discardAll(GrpclbConstants.TOKEN_METADATA_KEY);
+        if (token != null) {
+          headers.put(GrpclbConstants.TOKEN_METADATA_KEY, token);
+        }
+        delegate().streamCreated(transportAttrs, headers);
+      }
+    }
+
+    return new TokenPropagationTracer();
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(delegate);
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (!(other instanceof TokenAttachingTracerFactory)) {
+      return false;
+    }
+    return Objects.equal(delegate, ((TokenAttachingTracerFactory) other).delegate);
+  }
+}
diff --git a/grpclb/src/main/proto/grpc/lb/v1/load_balancer.proto b/grpclb/src/main/proto/grpc/lb/v1/load_balancer.proto
new file mode 100644
index 00000000000..00fc7096c9c
--- /dev/null
+++ b/grpclb/src/main/proto/grpc/lb/v1/load_balancer.proto
@@ -0,0 +1,151 @@
+// Copyright 2015 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.
+
+// This file defines the GRPCLB LoadBalancing protocol.
+//
+// The canonical version of this proto can be found at
+// https://github.com/grpc/grpc-proto/blob/master/grpc/lb/v1/load_balancer.proto
+syntax = "proto3";
+
+package grpc.lb.v1;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+
+option go_package = "google.golang.org/grpc/balancer/grpclb/grpc_lb_v1";
+option java_multiple_files = true;
+option java_outer_classname = "LoadBalancerProto";
+option java_package = "io.grpc.lb.v1";
+
+service LoadBalancer {
+  // Bidirectional rpc to get a list of servers.
+  rpc BalanceLoad(stream LoadBalanceRequest) returns (stream LoadBalanceResponse);
+}
+
+message LoadBalanceRequest {
+  oneof load_balance_request_type {
+    // This message should be sent on the first request to the load balancer.
+    InitialLoadBalanceRequest initial_request = 1;
+
+    // The client stats should be periodically reported to the load balancer
+    // based on the duration defined in the InitialLoadBalanceResponse.
+    ClientStats client_stats = 2;
+  }
+}
+
+message InitialLoadBalanceRequest {
+  // The name of the load balanced service (e.g., service.googleapis.com). Its
+  // length should be less than 256 bytes.
+  // The name might include a port number. How to handle the port number is up
+  // to the balancer.
+  string name = 1;
+}
+
+// Contains the number of calls finished for a particular load balance token.
+message ClientStatsPerToken {
+  // See Server.load_balance_token.
+  string load_balance_token = 1;
+
+  // The total number of RPCs that finished associated with the token.
+  int64 num_calls = 2;
+}
+
+// Contains client level statistics that are useful to load balancing. Each
+// count except the timestamp should be reset to zero after reporting the stats.
+message ClientStats {
+  // The timestamp of generating the report.
+  google.protobuf.Timestamp timestamp = 1;
+
+  // The total number of RPCs that started.
+  int64 num_calls_started = 2;
+
+  // The total number of RPCs that finished.
+  int64 num_calls_finished = 3;
+
+  // The total number of RPCs that failed to reach a server except dropped RPCs.
+  int64 num_calls_finished_with_client_failed_to_send = 6;
+
+  // The total number of RPCs that finished and are known to have been received
+  // by a server.
+  int64 num_calls_finished_known_received = 7;
+
+  // The list of dropped calls.
+  repeated ClientStatsPerToken calls_finished_with_drop = 8;
+
+  reserved 4, 5;
+}
+
+message LoadBalanceResponse {
+  oneof load_balance_response_type {
+    // This message should be sent on the first response to the client.
+    InitialLoadBalanceResponse initial_response = 1;
+
+    // Contains the list of servers selected by the load balancer. The client
+    // should send requests to these servers in the specified order.
+    ServerList server_list = 2;
+
+    // If this field is set, then the client should eagerly enter fallback
+    // mode (even if there are existing, healthy connections to backends).
+    FallbackResponse fallback_response = 3;
+  }
+}
+
+message FallbackResponse {}
+
+message InitialLoadBalanceResponse {
+  reserved 1; // never-used load_balancer_delegate
+
+  // This interval defines how often the client should send the client stats
+  // to the load balancer. Stats should only be reported when the duration is
+  // positive.
+  google.protobuf.Duration client_stats_report_interval = 2;
+}
+
+message ServerList {
+  // Contains a list of servers selected by the load balancer. The list will
+  // be updated when server resolutions change or as needed to balance load
+  // across more servers. The client should consume the server list in order
+  // unless instructed otherwise via the client_config.
+  repeated Server servers = 1;
+
+  // Was google.protobuf.Duration expiration_interval.
+  reserved 3;
+}
+
+// Contains server information. When the drop field is not true, use the other
+// fields.
+message Server {
+  // A resolved address for the server, serialized in network-byte-order. It may
+  // either be an IPv4 or IPv6 address.
+  bytes ip_address = 1;
+
+  // A resolved port number for the server.
+  int32 port = 2;
+
+  // An opaque but printable token for load reporting. The client must include
+  // the token of the picked server into the initial metadata when it starts a
+  // call to that server. The token is used by the server to verify the request
+  // and to allow the server to report load to the gRPC LB system. The token is
+  // also used in client stats for reporting dropped calls.
+  //
+  // Its length can be variable but must be less than 50 bytes.
+  string load_balance_token = 3;
+
+  // Indicates whether this particular request should be dropped by the client.
+  // If the request is dropped, there will be a corresponding entry in
+  // ClientStats.calls_finished_with_drop.
+  bool drop = 4;
+
+  reserved 5;
+}
diff --git a/grpclb/src/main/proto/load_balancer.proto b/grpclb/src/main/proto/load_balancer.proto
deleted file mode 100644
index e296b9a3a42..00000000000
--- a/grpclb/src/main/proto/load_balancer.proto
+++ /dev/null
@@ -1,103 +0,0 @@
-// The GRPCLB LoadBalancing protocol
-
-syntax = "proto3";
-
-import "google/protobuf/duration.proto";
-
-package grpc.lb.v1;
-
-option java_multiple_files = true;
-option java_package = "io.grpc.grpclb";
-option java_outer_classname = "LoadBalancerProto";
-
-service LoadBalancer {
-  // Bidirectional rpc to get a list of servers.
-  rpc BalanceLoad(stream LoadBalanceRequest)
-      returns (stream LoadBalanceResponse);
-}
-
-message LoadBalanceRequest {
-  oneof load_balance_request_type {
-    // This message should be sent on the first request to the load balancer.
-    InitialLoadBalanceRequest initial_request = 1;
-
-    // The client stats should be periodically reported to the load balancer
-    // based on the duration defined in the InitialLoadBalanceResponse.
-    ClientStats client_stats = 2;
-  }
-}
-
-message InitialLoadBalanceRequest {
-  // Name of load balanced service
-  string name = 1;
-}
-
-// Contains client level statistics that are useful to load balancing. Each
-// count should be reset to zero after reporting the stats.
-message ClientStats {
-  // The total number of requests sent by the client since the last report.
-  int64 total_requests = 1;
-
-  // The number of client rpc errors since the last report.
-  int64 client_rpc_errors = 2;
-
-  // The number of dropped requests since the last report.
-  int64 dropped_requests = 3;
-}
-
-message LoadBalanceResponse {
-  oneof load_balance_response_type {
-    // This message should be sent on the first response to the client.
-    InitialLoadBalanceResponse initial_response = 1;
-
-    // Contains the list of servers selected by the load balancer. The client
-    // should send requests to these servers in the specified order.
-    ServerList server_list = 2;
-  }
-}
-
-message InitialLoadBalanceResponse {
-  // This is an application layer redirect that indicates the client should use
-  // the specified server for load balancing. When this field is non-empty in
-  // the response, the client should open a separate connection to the
-  // load_balancer_delegate and call the BalanceLoad method.
-  string load_balancer_delegate = 1;
-
-  // This interval defines how often the client should send the client stats
-  // to the load balancer. Stats should only be reported when the duration is
-  // positive.
-  google.protobuf.Duration client_stats_report_interval = 2;
-}
-
-message ServerList {
-  // Contains a list of servers selected by the load balancer. The list will
-  // be updated when server resolutions change or as needed to balance load
-  // across more servers. The client should consume the server list in order
-  // unless instructed otherwise via the client_config.
-  repeated Server servers = 1;
-
-  // Indicates the amount of time that the client should consider this server
-  // list as valid. It may be considered stale after waiting this interval of
-  // time after receiving the list. If the interval is not positive, the
-  // client can assume the list is valid until the next list is received.
-  google.protobuf.Duration expiration_interval = 3;
-}
-
-message Server {
-  // A resolved address for the server, serialized in network-byte-order. It may
-  // either be an IPv4 or IPv6 address.
-  bytes ip_address = 1;
-
-  // A resolved port number for the server.
-  int32 port = 2;
-
-  // An opaque but printable token given to the frontend for each pick. All
-  // frontend requests for that pick must include the token in its initial
-  // metadata. The token is used by the backend to verify the request and to
-  // allow the backend to report load to the gRPC LB system.
-  string load_balance_token = 3;
-
-  // Indicates whether this particular request should be dropped by the client
-  // when this server is chosen from the list.
-  bool drop_request = 4;
-}
diff --git a/grpclb/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider b/grpclb/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
new file mode 100644
index 00000000000..581711343ee
--- /dev/null
+++ b/grpclb/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
@@ -0,0 +1 @@
+io.grpc.grpclb.GrpclbLoadBalancerProvider
diff --git a/grpclb/src/main/resources/META-INF/services/io.grpc.NameResolverProvider b/grpclb/src/main/resources/META-INF/services/io.grpc.NameResolverProvider
new file mode 100644
index 00000000000..bf02b5e8470
--- /dev/null
+++ b/grpclb/src/main/resources/META-INF/services/io.grpc.NameResolverProvider
@@ -0,0 +1 @@
+io.grpc.grpclb.SecretGrpclbNameResolverProvider$Provider
diff --git a/grpclb/src/test/java/io/grpc/grpclb/CachedSubchannelPoolTest.java b/grpclb/src/test/java/io/grpc/grpclb/CachedSubchannelPoolTest.java
new file mode 100644
index 00000000000..1c102db5c94
--- /dev/null
+++ b/grpclb/src/test/java/io/grpc/grpclb/CachedSubchannelPoolTest.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright 2018 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.grpclb;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.grpclb.CachedSubchannelPool.SHUTDOWN_TIMEOUT_MS;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.atMost;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import io.grpc.Attributes;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.SynchronizationContext;
+import io.grpc.grpclb.CachedSubchannelPool.ShutdownSubchannelTask;
+import io.grpc.grpclb.SubchannelPool.PooledSubchannelStateListener;
+import io.grpc.internal.FakeClock;
+import java.util.ArrayList;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.AdditionalAnswers;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InOrder;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+/** Unit tests for {@link CachedSubchannelPool}. */
+@RunWith(JUnit4.class)
+public class CachedSubchannelPoolTest {
+  private static final EquivalentAddressGroup EAG1 =
+      new EquivalentAddressGroup(new FakeSocketAddress("fake-address-1"), Attributes.EMPTY);
+  private static final EquivalentAddressGroup EAG2 =
+      new EquivalentAddressGroup(new FakeSocketAddress("fake-address-2"), Attributes.EMPTY);
+  private static final Attributes.Key<String> ATTR_KEY = Attributes.Key.create("test-attr");
+  private static final Attributes ATTRS1 = Attributes.newBuilder().set(ATTR_KEY, "1").build();
+  private static final Attributes ATTRS2 = Attributes.newBuilder().set(ATTR_KEY, "2").build();
+  
+  private static final ConnectivityStateInfo READY_STATE =
+      ConnectivityStateInfo.forNonError(ConnectivityState.READY);
+  private static final FakeClock.TaskFilter SHUTDOWN_TASK_FILTER =
+      new FakeClock.TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable command) {
+          // The task is wrapped by SynchronizationContext, so we can't compare the type
+          // directly.
+          return command.toString().contains(ShutdownSubchannelTask.class.getSimpleName());
+        }
+      };
+
+  private final Helper helper = mock(Helper.class);
+  private final PooledSubchannelStateListener listener = mock(
+      PooledSubchannelStateListener.class,
+      AdditionalAnswers.delegatesTo(new PooledSubchannelStateListener() {
+        @Override
+        public void onSubchannelState(Subchannel subchannel, ConnectivityStateInfo newState) {
+          syncContext.throwIfNotInThisSynchronizationContext();
+        }
+      }));
+
+  private final FakeClock clock = new FakeClock();
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final SubchannelPool pool = new CachedSubchannelPool(helper);
+  private final ArrayList<Subchannel> mockSubchannels = new ArrayList<>();
+  private final ArgumentCaptor<CreateSubchannelArgs> createSubchannelArgsCaptor
+      = ArgumentCaptor.forClass(CreateSubchannelArgs.class);
+
+  @Before
+  public void setUp() {
+    doAnswer(new Answer<Subchannel>() {
+        @Override
+        public Subchannel answer(InvocationOnMock invocation) throws Throwable {
+          Subchannel subchannel = mock(Subchannel.class);
+          CreateSubchannelArgs args = (CreateSubchannelArgs) invocation.getArguments()[0];
+          when(subchannel.getAllAddresses()).thenReturn(args.getAddresses());
+          when(subchannel.getAttributes()).thenReturn(args.getAttributes());
+          mockSubchannels.add(subchannel);
+          return subchannel;
+        }
+      }).when(helper).createSubchannel(any(CreateSubchannelArgs.class));
+    when(helper.getSynchronizationContext()).thenReturn(syncContext);
+    when(helper.getScheduledExecutorService()).thenReturn(clock.getScheduledExecutorService());
+    pool.registerListener(listener);
+  }
+
+  @After
+  public void wrapUp() {
+    if (mockSubchannels.isEmpty()) {
+      return;
+    }
+    // Sanity checks
+    for (Subchannel subchannel : mockSubchannels) {
+      verify(subchannel, atMost(1)).shutdown();
+    }
+    verify(listener, atLeast(0))
+        .onSubchannelState(any(Subchannel.class), any(ConnectivityStateInfo.class));
+    verifyNoMoreInteractions(listener);
+  }
+
+  @Test
+  public void subchannelExpireAfterReturned() {
+    Subchannel subchannel1 = pool.takeOrCreateSubchannel(EAG1, ATTRS1);
+    assertThat(subchannel1).isNotNull();
+    InOrder inOrder = Mockito.inOrder(helper);
+    inOrder.verify(helper).createSubchannel(createSubchannelArgsCaptor.capture());
+    CreateSubchannelArgs createSubchannelArgs = createSubchannelArgsCaptor.getValue();
+    assertThat(createSubchannelArgs.getAddresses()).containsExactly(EAG1);
+    assertThat(createSubchannelArgs.getAttributes()).isEqualTo(ATTRS1);
+
+    Subchannel subchannel2 = pool.takeOrCreateSubchannel(EAG2, ATTRS2);
+    assertThat(subchannel2).isNotNull();
+    assertThat(subchannel2).isNotSameInstanceAs(subchannel1);
+    inOrder.verify(helper).createSubchannel(createSubchannelArgsCaptor.capture());
+    createSubchannelArgs = createSubchannelArgsCaptor.getValue();
+    assertThat(createSubchannelArgs.getAddresses()).containsExactly(EAG2);
+    assertThat(createSubchannelArgs.getAttributes()).isEqualTo(ATTRS2);
+
+    pool.returnSubchannel(subchannel1, READY_STATE);
+
+    // subchannel1 is 1ms away from expiration.
+    clock.forwardTime(SHUTDOWN_TIMEOUT_MS - 1, MILLISECONDS);
+    verify(subchannel1, never()).shutdown();
+
+    pool.returnSubchannel(subchannel2, READY_STATE);
+
+    // subchannel1 expires. subchannel2 is (SHUTDOWN_TIMEOUT_MS - 1) away from expiration.
+    clock.forwardTime(1, MILLISECONDS);
+    verify(subchannel1).shutdown();
+
+    // subchanne2 expires.
+    clock.forwardTime(SHUTDOWN_TIMEOUT_MS - 1, MILLISECONDS);
+    verify(subchannel2).shutdown();
+
+    assertThat(clock.numPendingTasks()).isEqualTo(0);
+  }
+
+  @Test
+  public void subchannelReused() {
+    Subchannel subchannel1 = pool.takeOrCreateSubchannel(EAG1, ATTRS1);
+    assertThat(subchannel1).isNotNull();
+    InOrder inOrder = Mockito.inOrder(helper);
+    inOrder.verify(helper).createSubchannel(createSubchannelArgsCaptor.capture());
+    CreateSubchannelArgs createSubchannelArgs = createSubchannelArgsCaptor.getValue();
+    assertThat(createSubchannelArgs.getAddresses()).containsExactly(EAG1);
+    assertThat(createSubchannelArgs.getAttributes()).isEqualTo(ATTRS1);
+
+    Subchannel subchannel2 = pool.takeOrCreateSubchannel(EAG2, ATTRS2);
+    assertThat(subchannel2).isNotNull();
+    assertThat(subchannel2).isNotSameInstanceAs(subchannel1);
+    inOrder.verify(helper).createSubchannel(createSubchannelArgsCaptor.capture());
+    createSubchannelArgs = createSubchannelArgsCaptor.getValue();
+    assertThat(createSubchannelArgs.getAddresses()).containsExactly(EAG2);
+    assertThat(createSubchannelArgs.getAttributes()).isEqualTo(ATTRS2);
+
+    pool.returnSubchannel(subchannel1, READY_STATE);
+
+    // subchannel1 is 1ms away from expiration.
+    clock.forwardTime(SHUTDOWN_TIMEOUT_MS - 1, MILLISECONDS);
+
+    // This will cancel the shutdown timer for subchannel1
+    Subchannel subchannel1a = pool.takeOrCreateSubchannel(EAG1, ATTRS1);
+    assertThat(subchannel1a).isSameInstanceAs(subchannel1);
+
+    pool.returnSubchannel(subchannel2, READY_STATE);
+
+    // subchannel2 expires SHUTDOWN_TIMEOUT_MS after being returned
+    clock.forwardTime(SHUTDOWN_TIMEOUT_MS - 1, MILLISECONDS);
+    verify(subchannel2, never()).shutdown();
+    clock.forwardTime(1, MILLISECONDS);
+    verify(subchannel2).shutdown();
+
+    // pool will create a new channel for EAG2 when requested
+    Subchannel subchannel2a = pool.takeOrCreateSubchannel(EAG2, ATTRS2);
+    assertThat(subchannel2a).isNotSameInstanceAs(subchannel2);
+    inOrder.verify(helper).createSubchannel(createSubchannelArgsCaptor.capture());
+    createSubchannelArgs = createSubchannelArgsCaptor.getValue();
+    assertThat(createSubchannelArgs.getAddresses()).containsExactly(EAG2);
+    assertThat(createSubchannelArgs.getAttributes()).isEqualTo(ATTRS2);
+
+    // subchannel1 expires SHUTDOWN_TIMEOUT_MS after being returned
+    pool.returnSubchannel(subchannel1a, READY_STATE);
+    clock.forwardTime(SHUTDOWN_TIMEOUT_MS - 1, MILLISECONDS);
+    verify(subchannel1a, never()).shutdown();
+    clock.forwardTime(1, MILLISECONDS);
+    verify(subchannel1a).shutdown();
+
+    assertThat(clock.numPendingTasks()).isEqualTo(0);
+  }
+
+  @Test
+  public void returnDuplicateAddressSubchannel() {
+    Subchannel subchannel1 = pool.takeOrCreateSubchannel(EAG1, ATTRS1);
+    Subchannel subchannel2 = pool.takeOrCreateSubchannel(EAG1, ATTRS2);
+    Subchannel subchannel3 = pool.takeOrCreateSubchannel(EAG2, ATTRS1);
+    assertThat(subchannel1).isNotSameInstanceAs(subchannel2);
+
+    assertThat(clock.getPendingTasks(SHUTDOWN_TASK_FILTER)).isEmpty();
+    pool.returnSubchannel(subchannel2, READY_STATE);
+    assertThat(clock.getPendingTasks(SHUTDOWN_TASK_FILTER)).hasSize(1);
+
+    // If the subchannel being returned has an address that is the same as a subchannel in the pool,
+    // the returned subchannel will be shut down.
+    verify(subchannel1, never()).shutdown();
+    pool.returnSubchannel(subchannel1, READY_STATE);
+    assertThat(clock.getPendingTasks(SHUTDOWN_TASK_FILTER)).hasSize(1);
+    verify(subchannel1).shutdown();
+
+    pool.returnSubchannel(subchannel3, READY_STATE);
+    assertThat(clock.getPendingTasks(SHUTDOWN_TASK_FILTER)).hasSize(2);
+    // Returning the same subchannel twice has no effect.
+    pool.returnSubchannel(subchannel3, READY_STATE);
+    assertThat(clock.getPendingTasks(SHUTDOWN_TASK_FILTER)).hasSize(2);
+
+    verify(subchannel2, never()).shutdown();
+    verify(subchannel3, never()).shutdown();
+  }
+
+  @Test
+  public void clear() {
+    Subchannel subchannel1 = pool.takeOrCreateSubchannel(EAG1, ATTRS1);
+    Subchannel subchannel2 = pool.takeOrCreateSubchannel(EAG2, ATTRS2);
+    Subchannel subchannel3 = pool.takeOrCreateSubchannel(EAG2, ATTRS2);
+
+    pool.returnSubchannel(subchannel1, READY_STATE);
+    pool.returnSubchannel(subchannel2, READY_STATE);
+
+    verify(subchannel1, never()).shutdown();
+    verify(subchannel2, never()).shutdown();
+    pool.clear();
+    verify(subchannel1).shutdown();
+    verify(subchannel2).shutdown();
+
+    verify(subchannel3, never()).shutdown();
+    assertThat(clock.numPendingTasks()).isEqualTo(0);
+  }
+}
diff --git a/grpclb/src/test/java/io/grpc/grpclb/FakeSocketAddress.java b/grpclb/src/test/java/io/grpc/grpclb/FakeSocketAddress.java
new file mode 100644
index 00000000000..b74ea74fbe1
--- /dev/null
+++ b/grpclb/src/test/java/io/grpc/grpclb/FakeSocketAddress.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2018 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.grpclb;
+
+import java.net.SocketAddress;
+
+final class FakeSocketAddress extends SocketAddress {
+  final String name;
+
+  FakeSocketAddress(String name) {
+    this.name = name;
+  }
+
+  @Override
+  public String toString() {
+    return "FakeSocketAddress-" + name;
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (other instanceof FakeSocketAddress) {
+      FakeSocketAddress otherAddr = (FakeSocketAddress) other;
+      return name.equals(otherAddr.name);
+    }
+    return false;
+  }
+
+  @Override
+  public int hashCode() {
+    return name.hashCode();
+  }
+}
diff --git a/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancer2Test.java b/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancer2Test.java
deleted file mode 100644
index 28d25fd749a..00000000000
--- a/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancer2Test.java
+++ /dev/null
@@ -1,843 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.grpclb;
-
-import static com.google.common.base.Charsets.UTF_8;
-import static io.grpc.ConnectivityState.CONNECTING;
-import static io.grpc.ConnectivityState.IDLE;
-import static io.grpc.ConnectivityState.READY;
-import static io.grpc.ConnectivityState.SHUTDOWN;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Matchers.same;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-import com.google.common.io.ByteStreams;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.google.protobuf.ByteString;
-import io.grpc.Attributes;
-import io.grpc.CallOptions;
-import io.grpc.ConnectivityStateInfo;
-import io.grpc.EquivalentAddressGroup;
-import io.grpc.LoadBalancer2;
-import io.grpc.LoadBalancer2.Helper;
-import io.grpc.LoadBalancer2.PickResult;
-import io.grpc.LoadBalancer2.Subchannel;
-import io.grpc.LoadBalancer2.SubchannelPicker;
-import io.grpc.ManagedChannel;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.MethodDescriptor.Marshaller;
-import io.grpc.ResolvedServerInfo;
-import io.grpc.ResolvedServerInfoGroup;
-import io.grpc.Status;
-import io.grpc.StatusRuntimeException;
-import io.grpc.grpclb.GrpclbConstants.LbPolicy;
-import io.grpc.grpclb.GrpclbLoadBalancer2.ErrorPicker;
-import io.grpc.grpclb.GrpclbLoadBalancer2.RoundRobinPicker;
-import io.grpc.inprocess.InProcessChannelBuilder;
-import io.grpc.inprocess.InProcessServerBuilder;
-import io.grpc.internal.SerializingExecutor;
-import io.grpc.stub.ClientCalls;
-import io.grpc.stub.StreamObserver;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.InetSocketAddress;
-import java.net.SocketAddress;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.InOrder;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-/** Unit tests for {@link GrpclbLoadBalancer2}. */
-@RunWith(JUnit4.class)
-public class GrpclbLoadBalancer2Test {
-  private static final Attributes.Key<String> RESOLUTION_ATTR =
-      Attributes.Key.of("resolution-attr");
-  private static final String SERVICE_AUTHORITY = "api.google.com";
-
-  private static final MethodDescriptor<String, String> TRASH_METHOD =
-      MethodDescriptor.<String, String>newBuilder()
-          .setType(MethodDescriptor.MethodType.UNARY)
-          .setFullMethodName("/service/trashmethod")
-          .setRequestMarshaller(StringMarshaller.INSTANCE)
-          .setResponseMarshaller(StringMarshaller.INSTANCE)
-          .build();
-
-  private static class StringMarshaller implements Marshaller<String> {
-    static final StringMarshaller INSTANCE = new StringMarshaller();
-
-    @Override
-    public InputStream stream(String value) {
-      return new ByteArrayInputStream(value.getBytes(UTF_8));
-    }
-
-    @Override
-    public String parse(InputStream stream) {
-      try {
-        return new String(ByteStreams.toByteArray(stream), UTF_8);
-      } catch (IOException ex) {
-        throw new RuntimeException(ex);
-      }
-    }
-  }
-
-  @Mock
-  private Helper helper;
-  @Mock
-  private Subchannel mockSubchannel;
-  private LoadBalancerGrpc.LoadBalancerImplBase mockLbService;
-  @Captor
-  private ArgumentCaptor<StreamObserver<LoadBalanceResponse>> lbResponseObserverCaptor;
-  private final LinkedList<StreamObserver<LoadBalanceRequest>> lbRequestObservers =
-      new LinkedList<StreamObserver<LoadBalanceRequest>>();
-  private final LinkedList<Subchannel> mockSubchannels = new LinkedList<Subchannel>();
-  private final LinkedList<ManagedChannel> fakeOobChannels = new LinkedList<ManagedChannel>();
-  private final ArrayList<Subchannel> subchannelTracker = new ArrayList<Subchannel>();
-  private final ArrayList<ManagedChannel> oobChannelTracker = new ArrayList<ManagedChannel>();
-  private final ArrayList<String> failingLbAuthorities = new ArrayList<String>();
-  private io.grpc.Server fakeLbServer;
-  @Captor
-  private ArgumentCaptor<SubchannelPicker> pickerCaptor;
-  private final SerializingExecutor channelExecutor =
-      new SerializingExecutor(MoreExecutors.directExecutor());
-  private final Metadata headers = new Metadata();
-  @Mock
-  private LoadBalancer2.Factory pickFirstBalancerFactory;
-  @Mock
-  private LoadBalancer2 pickFirstBalancer;
-  @Mock
-  private LoadBalancer2.Factory roundRobinBalancerFactory;
-  @Mock
-  private LoadBalancer2 roundRobinBalancer;
-  private GrpclbLoadBalancer2 balancer;
-
-  @SuppressWarnings("unchecked")
-  @Before
-  public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
-    when(pickFirstBalancerFactory.newLoadBalancer(any(Helper.class)))
-        .thenReturn(pickFirstBalancer);
-    when(roundRobinBalancerFactory.newLoadBalancer(any(Helper.class)))
-        .thenReturn(roundRobinBalancer);
-    mockLbService = spy(new LoadBalancerGrpc.LoadBalancerImplBase() {
-        @Override
-        public StreamObserver<LoadBalanceRequest> balanceLoad(
-            final StreamObserver<LoadBalanceResponse> responseObserver) {
-          StreamObserver<LoadBalanceRequest> requestObserver =
-              mock(StreamObserver.class);
-          Answer<Void> closeRpc = new Answer<Void>() {
-              @Override
-              public Void answer(InvocationOnMock invocation) {
-                responseObserver.onCompleted();
-                return null;
-              }
-            };
-          doAnswer(closeRpc).when(requestObserver).onCompleted();
-          lbRequestObservers.add(requestObserver);
-          return requestObserver;
-        }
-      });
-    fakeLbServer = InProcessServerBuilder.forName("fakeLb")
-        .directExecutor().addService(mockLbService).build().start();
-    doAnswer(new Answer<ManagedChannel>() {
-        @Override
-        public ManagedChannel answer(InvocationOnMock invocation) throws Throwable {
-          String authority = (String) invocation.getArguments()[1];
-          ManagedChannel channel;
-          if (failingLbAuthorities.contains(authority)) {
-            channel = InProcessChannelBuilder.forName("nonExistFakeLb").directExecutor().build();
-          } else {
-            channel = InProcessChannelBuilder.forName("fakeLb").directExecutor().build();
-          }
-          // TODO(zhangkun83): #2444: non-determinism of Channel due to starting NameResolver on the
-          // timer "Prime" it before use.  Remove it after #2444 is resolved.
-          try {
-            ClientCalls.blockingUnaryCall(channel, TRASH_METHOD, CallOptions.DEFAULT, "trash");
-          } catch (StatusRuntimeException ignored) {
-            // Ignored
-          }
-          fakeOobChannels.add(channel);
-          oobChannelTracker.add(channel);
-          return channel;
-        }
-      }).when(helper).createOobChannel(any(EquivalentAddressGroup.class), any(String.class));
-    doAnswer(new Answer<Subchannel>() {
-        @Override
-        public Subchannel answer(InvocationOnMock invocation) throws Throwable {
-          Subchannel subchannel = mock(Subchannel.class);
-          EquivalentAddressGroup eag = (EquivalentAddressGroup) invocation.getArguments()[0];
-          Attributes attrs = (Attributes) invocation.getArguments()[1];
-          when(subchannel.getAddresses()).thenReturn(eag);
-          when(subchannel.getAttributes()).thenReturn(attrs);
-          mockSubchannels.add(subchannel);
-          subchannelTracker.add(subchannel);
-          return subchannel;
-        }
-      }).when(helper).createSubchannel(any(EquivalentAddressGroup.class), any(Attributes.class));
-    doAnswer(new Answer<Void>() {
-        @Override
-        public Void answer(InvocationOnMock invocation) throws Throwable {
-          Runnable task = (Runnable) invocation.getArguments()[0];
-          channelExecutor.execute(task);
-          return null;
-        }
-      }).when(helper).runSerialized(any(Runnable.class));
-    when(helper.getAuthority()).thenReturn(SERVICE_AUTHORITY);
-    balancer = new GrpclbLoadBalancer2(helper, pickFirstBalancerFactory, roundRobinBalancerFactory);
-  }
-
-  @After
-  public void tearDown() {
-    try {
-      if (balancer != null) {
-        channelExecutor.execute(new Runnable() {
-            @Override
-            public void run() {
-              balancer.shutdown();
-            }
-          });
-      }
-      for (ManagedChannel channel : oobChannelTracker) {
-        assertTrue(channel + " is shutdown", channel.isShutdown());
-        // balancer should have closed the LB stream, terminating the OOB channel.
-        assertTrue(channel + " is terminated", channel.isTerminated());
-      }
-      for (Subchannel subchannel: subchannelTracker) {
-        verify(subchannel).shutdown();
-      }
-    } finally {
-      if (fakeLbServer != null) {
-        fakeLbServer.shutdownNow();
-      }
-    }
-  }
-
-  @Test
-  public void errorPicker() {
-    Status error = Status.UNAVAILABLE.withDescription("Just don't know why");
-    ErrorPicker picker = new ErrorPicker(error);
-    assertSame(error, picker.pickSubchannel(Attributes.EMPTY, headers).getStatus());
-  }
-
-  @Test
-  public void roundRobinPicker() {
-    PickResult pr1 = PickResult.withError(Status.UNAVAILABLE.withDescription("Just error"));
-    PickResult pr2 = PickResult.withSubchannel(mockSubchannel);
-    List<PickResult> list = Arrays.asList(pr1, pr2);
-    RoundRobinPicker picker = new RoundRobinPicker(list);
-    assertSame(pr1, picker.pickSubchannel(Attributes.EMPTY, headers));
-    assertSame(pr2, picker.pickSubchannel(Attributes.EMPTY, headers));
-    assertSame(pr1, picker.pickSubchannel(Attributes.EMPTY, headers));
-  }
-
-  @Test
-  public void bufferPicker() {
-    assertEquals(PickResult.withNoResult(),
-        GrpclbLoadBalancer2.BUFFER_PICKER.pickSubchannel(Attributes.EMPTY, headers));
-  }
-
-  @Test
-  public void nameResolutionFailsThenRecoverToDelegate() {
-    Status error = Status.NOT_FOUND.withDescription("www.google.com not found");
-    deliverNameResolutionError(error);
-    verify(helper).updatePicker(pickerCaptor.capture());
-    ErrorPicker errorPicker = (ErrorPicker) pickerCaptor.getValue();
-    assertSame(error, errorPicker.result.getStatus());
-
-    // Recover with a subsequent success
-    List<ResolvedServerInfoGroup> resolvedServers = createResolvedServerInfoGroupList(false);
-
-    Attributes resolutionAttrs = Attributes.newBuilder().set(RESOLUTION_ATTR, "yeah").build();
-    deliverResolvedAddresses(resolvedServers, resolutionAttrs);
-
-    verify(pickFirstBalancerFactory).newLoadBalancer(helper);
-    verify(pickFirstBalancer).handleResolvedAddresses(eq(resolvedServers), eq(resolutionAttrs));
-    verifyNoMoreInteractions(roundRobinBalancerFactory);
-    verifyNoMoreInteractions(roundRobinBalancer);
-  }
-
-  @Test
-  public void nameResolutionFailsThenRecoverToGrpclb() {
-    Status error = Status.NOT_FOUND.withDescription("www.google.com not found");
-    deliverNameResolutionError(error);
-    verify(helper).updatePicker(pickerCaptor.capture());
-    ErrorPicker errorPicker = (ErrorPicker) pickerCaptor.getValue();
-    assertSame(error, errorPicker.result.getStatus());
-
-    // Recover with a subsequent success
-    List<ResolvedServerInfoGroup> resolvedServers = createResolvedServerInfoGroupList(true);
-    EquivalentAddressGroup eag = resolvedServers.get(0).toEquivalentAddressGroup();
-
-    Attributes resolutionAttrs = Attributes.newBuilder()
-        .set(GrpclbConstants.ATTR_LB_POLICY, LbPolicy.GRPCLB).build();
-    deliverResolvedAddresses(resolvedServers, resolutionAttrs);
-
-    assertSame(LbPolicy.GRPCLB, balancer.getLbPolicy());
-    assertNull(balancer.getDelegate());
-    verify(helper).createOobChannel(eq(eag), eq(lbAuthority(0)));
-    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
-
-    verifyNoMoreInteractions(pickFirstBalancerFactory);
-    verifyNoMoreInteractions(pickFirstBalancer);
-    verifyNoMoreInteractions(roundRobinBalancerFactory);
-    verifyNoMoreInteractions(roundRobinBalancer);
-  }
-
-  @Test
-  public void delegatingPickFirstThenNameResolutionFails() {
-    List<ResolvedServerInfoGroup> resolvedServers = createResolvedServerInfoGroupList(false);
-
-    Attributes resolutionAttrs = Attributes.newBuilder().set(RESOLUTION_ATTR, "yeah").build();
-    deliverResolvedAddresses(resolvedServers, resolutionAttrs);
-
-    verify(pickFirstBalancerFactory).newLoadBalancer(helper);
-    verify(pickFirstBalancer).handleResolvedAddresses(eq(resolvedServers), eq(resolutionAttrs));
-
-    // Then let name resolution fail.  The error will be passed directly to the delegate.
-    Status error = Status.NOT_FOUND.withDescription("www.google.com not found");
-    deliverNameResolutionError(error);
-    verify(pickFirstBalancer).handleNameResolutionError(error);
-    verify(helper, never()).updatePicker(any(SubchannelPicker.class));
-    verifyNoMoreInteractions(roundRobinBalancerFactory);
-    verifyNoMoreInteractions(roundRobinBalancer);
-  }
-
-  @Test
-  public void delegatingRoundRobinThenNameResolutionFails() {
-    List<ResolvedServerInfoGroup> resolvedServers = createResolvedServerInfoGroupList(false, false);
-
-    Attributes resolutionAttrs = Attributes.newBuilder()
-        .set(RESOLUTION_ATTR, "yeah")
-        .set(GrpclbConstants.ATTR_LB_POLICY, LbPolicy.ROUND_ROBIN)
-        .build();
-    deliverResolvedAddresses(resolvedServers, resolutionAttrs);
-
-    verify(roundRobinBalancerFactory).newLoadBalancer(helper);
-    verify(roundRobinBalancer).handleResolvedAddresses(resolvedServers, resolutionAttrs);
-
-    // Then let name resolution fail.  The error will be passed directly to the delegate.
-    Status error = Status.NOT_FOUND.withDescription("www.google.com not found");
-    deliverNameResolutionError(error);
-    verify(roundRobinBalancer).handleNameResolutionError(error);
-    verify(helper, never()).updatePicker(any(SubchannelPicker.class));
-    verifyNoMoreInteractions(pickFirstBalancerFactory);
-    verifyNoMoreInteractions(pickFirstBalancer);
-  }
-
-  @Test
-  public void grpclbThenNameResolutionFails() {
-    InOrder inOrder = inOrder(helper);
-    // Go to GRPCLB first
-    List<ResolvedServerInfoGroup> grpclbResolutionList =
-        createResolvedServerInfoGroupList(true, true);
-    Attributes grpclbResolutionAttrs = Attributes.newBuilder()
-        .set(GrpclbConstants.ATTR_LB_POLICY, LbPolicy.GRPCLB).build();
-    deliverResolvedAddresses(grpclbResolutionList, grpclbResolutionAttrs);
-
-    assertSame(LbPolicy.GRPCLB, balancer.getLbPolicy());
-    assertNull(balancer.getDelegate());
-    verify(helper).createOobChannel(eq(grpclbResolutionList.get(0).toEquivalentAddressGroup()),
-        eq(lbAuthority(0)));
-    assertEquals(1, fakeOobChannels.size());
-    ManagedChannel oobChannel = fakeOobChannels.poll();
-    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
-    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
-
-    // Let name resolution fail before round-robin list is ready
-    Status error = Status.NOT_FOUND.withDescription("www.google.com not found");
-    deliverNameResolutionError(error);
-
-    inOrder.verify(helper).updatePicker(pickerCaptor.capture());
-    ErrorPicker errorPicker = (ErrorPicker) pickerCaptor.getValue();
-    assertSame(error, errorPicker.result.getStatus());
-    assertFalse(oobChannel.isShutdown());
-
-    // Simulate receiving LB response
-    List<InetSocketAddress> backends = Arrays.asList(
-        new InetSocketAddress("127.0.0.1", 2000),
-        new InetSocketAddress("127.0.0.1", 2010));
-    verify(helper, never()).runSerialized(any(Runnable.class));
-    lbResponseObserver.onNext(buildInitialResponse());
-    lbResponseObserver.onNext(buildLbResponse(backends));
-
-    verify(helper, times(2)).runSerialized(any(Runnable.class));
-    inOrder.verify(helper).createSubchannel(
-        eq(new EquivalentAddressGroup(backends.get(0))), any(Attributes.class));
-    inOrder.verify(helper).createSubchannel(
-        eq(new EquivalentAddressGroup(backends.get(1))), any(Attributes.class));
-  }
-
-  @SuppressWarnings("unchecked")
-  @Test
-  public void switchPolicy() {
-    // Go to GRPCLB first
-    List<ResolvedServerInfoGroup> grpclbResolutionList =
-        createResolvedServerInfoGroupList(true, false, true);
-    Attributes grpclbResolutionAttrs = Attributes.newBuilder()
-        .set(GrpclbConstants.ATTR_LB_POLICY, LbPolicy.GRPCLB).build();
-    deliverResolvedAddresses(grpclbResolutionList, grpclbResolutionAttrs);
-
-    assertSame(LbPolicy.GRPCLB, balancer.getLbPolicy());
-    assertNull(balancer.getDelegate());
-    verify(helper).createOobChannel(eq(grpclbResolutionList.get(0).toEquivalentAddressGroup()),
-        eq(lbAuthority(0)));
-    assertEquals(1, fakeOobChannels.size());
-    ManagedChannel oobChannel = fakeOobChannels.poll();
-    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
-
-    // Switch to PICK_FIRST
-    List<ResolvedServerInfoGroup> pickFirstResolutionList =
-        createResolvedServerInfoGroupList(true, false, true);
-    Attributes pickFirstResolutionAttrs = Attributes.newBuilder()
-        .set(GrpclbConstants.ATTR_LB_POLICY, LbPolicy.PICK_FIRST).build();
-    verify(pickFirstBalancerFactory, never()).newLoadBalancer(any(Helper.class));
-    assertEquals(1, lbRequestObservers.size());
-    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
-
-    verify(lbRequestObserver, never()).onCompleted();
-    assertFalse(oobChannel.isShutdown());
-    deliverResolvedAddresses(pickFirstResolutionList, pickFirstResolutionAttrs);
-
-    verify(pickFirstBalancerFactory).newLoadBalancer(same(helper));
-    // Only non-LB addresses are passed to the delegate
-    verify(pickFirstBalancer).handleResolvedAddresses(
-        eq(Arrays.asList(pickFirstResolutionList.get(1))), same(pickFirstResolutionAttrs));
-    assertSame(LbPolicy.PICK_FIRST, balancer.getLbPolicy());
-    assertSame(pickFirstBalancer, balancer.getDelegate());
-    // GRPCLB connection is closed
-    verify(lbRequestObserver).onCompleted();
-    assertTrue(oobChannel.isShutdown());
-
-    // Switch to ROUND_ROBIN
-    List<ResolvedServerInfoGroup> roundRobinResolutionList =
-        createResolvedServerInfoGroupList(true, false, false);
-    Attributes roundRobinResolutionAttrs = Attributes.newBuilder()
-        .set(GrpclbConstants.ATTR_LB_POLICY, LbPolicy.ROUND_ROBIN).build();
-    verify(roundRobinBalancerFactory, never()).newLoadBalancer(any(Helper.class));
-    deliverResolvedAddresses(roundRobinResolutionList, roundRobinResolutionAttrs);
-
-    verify(roundRobinBalancerFactory).newLoadBalancer(same(helper));
-    // Only non-LB addresses are passed to the delegate
-    verify(roundRobinBalancer).handleResolvedAddresses(
-        eq(roundRobinResolutionList.subList(1, 3)), same(roundRobinResolutionAttrs));
-    assertSame(LbPolicy.ROUND_ROBIN, balancer.getLbPolicy());
-    assertSame(roundRobinBalancer, balancer.getDelegate());
-
-    // Special case: if all addresses are loadbalancers, use GRPCLB no matter what the NameResolver
-    // says.
-    grpclbResolutionList = createResolvedServerInfoGroupList(true, true, true);
-    grpclbResolutionAttrs = Attributes.newBuilder()
-        .set(GrpclbConstants.ATTR_LB_POLICY, LbPolicy.PICK_FIRST).build();
-    deliverResolvedAddresses(grpclbResolutionList, grpclbResolutionAttrs);
-
-    assertSame(LbPolicy.GRPCLB, balancer.getLbPolicy());
-    assertNull(balancer.getDelegate());
-    verify(helper, times(2)).createOobChannel(
-        eq(grpclbResolutionList.get(0).toEquivalentAddressGroup()),
-        eq(lbAuthority(0)));
-    verify(helper, times(2)).createOobChannel(any(EquivalentAddressGroup.class), any(String.class));
-    assertEquals(1, fakeOobChannels.size());
-    oobChannel = fakeOobChannels.poll();
-    verify(mockLbService, times(2)).balanceLoad(lbResponseObserverCaptor.capture());
-
-    // Special case: PICK_FIRST is the default
-    pickFirstResolutionList = createResolvedServerInfoGroupList(true, false, false);
-    pickFirstResolutionAttrs = Attributes.EMPTY;
-    verify(pickFirstBalancerFactory).newLoadBalancer(any(Helper.class));
-    assertFalse(oobChannel.isShutdown());
-    deliverResolvedAddresses(pickFirstResolutionList, pickFirstResolutionAttrs);
-
-    verify(pickFirstBalancerFactory, times(2)).newLoadBalancer(same(helper));
-    // Only non-LB addresses are passed to the delegate
-    verify(pickFirstBalancer).handleResolvedAddresses(
-        eq(pickFirstResolutionList.subList(1, 3)), same(pickFirstResolutionAttrs));
-    assertSame(LbPolicy.PICK_FIRST, balancer.getLbPolicy());
-    assertSame(pickFirstBalancer, balancer.getDelegate());
-    // GRPCLB connection is closed
-    assertTrue(oobChannel.isShutdown());
-  }
-
-  @Test
-  public void grpclbWorking() {
-    InOrder inOrder = inOrder(helper);
-    List<ResolvedServerInfoGroup> grpclbResolutionList =
-        createResolvedServerInfoGroupList(true, true);
-    Attributes grpclbResolutionAttrs = Attributes.newBuilder()
-        .set(GrpclbConstants.ATTR_LB_POLICY, LbPolicy.GRPCLB).build();
-    deliverResolvedAddresses(grpclbResolutionList, grpclbResolutionAttrs);
-
-    assertSame(LbPolicy.GRPCLB, balancer.getLbPolicy());
-    assertNull(balancer.getDelegate());
-    verify(helper).createOobChannel(eq(grpclbResolutionList.get(0).toEquivalentAddressGroup()),
-        eq(lbAuthority(0)));
-    assertEquals(1, fakeOobChannels.size());
-    ManagedChannel oobChannel = fakeOobChannels.poll();
-    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
-    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
-
-    // Simulate receiving LB response
-    List<InetSocketAddress> backends1 = Arrays.asList(
-        new InetSocketAddress("127.0.0.1", 2000),
-        new InetSocketAddress("127.0.0.1", 2010));
-    inOrder.verify(helper, never()).updatePicker(any(SubchannelPicker.class));
-    lbResponseObserver.onNext(buildInitialResponse());
-    lbResponseObserver.onNext(buildLbResponse(backends1));
-
-    inOrder.verify(helper).createSubchannel(
-        eq(new EquivalentAddressGroup(backends1.get(0))), any(Attributes.class));
-    inOrder.verify(helper).createSubchannel(
-        eq(new EquivalentAddressGroup(backends1.get(1))), any(Attributes.class));
-    assertEquals(2, mockSubchannels.size());
-    Subchannel subchannel1 = mockSubchannels.poll();
-    Subchannel subchannel2 = mockSubchannels.poll();
-    verify(subchannel1).requestConnection();
-    verify(subchannel2).requestConnection();
-    assertEquals(new EquivalentAddressGroup(backends1.get(0)), subchannel1.getAddresses());
-    assertEquals(new EquivalentAddressGroup(backends1.get(1)), subchannel2.getAddresses());
-
-    // Before any subchannel is READY, a buffer picker will be provided
-    inOrder.verify(helper).updatePicker(same(GrpclbLoadBalancer2.BUFFER_PICKER));
-
-    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(CONNECTING));
-    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(CONNECTING));
-    inOrder.verify(helper, times(2)).updatePicker(same(GrpclbLoadBalancer2.BUFFER_PICKER));
-
-    // Let subchannels be connected
-    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(READY));
-    inOrder.verify(helper).updatePicker(pickerCaptor.capture());
-    RoundRobinPicker picker1 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertRoundRobinList(picker1, subchannel2);
-
-    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(READY));
-    inOrder.verify(helper).updatePicker(pickerCaptor.capture());
-    RoundRobinPicker picker2 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertRoundRobinList(picker2, subchannel1, subchannel2);
-
-    // Disconnected subchannels
-    verify(subchannel1).requestConnection();
-    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(IDLE));
-    verify(subchannel1, times(2)).requestConnection();
-    inOrder.verify(helper).updatePicker(pickerCaptor.capture());
-    RoundRobinPicker picker3 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertRoundRobinList(picker3, subchannel2);
-
-    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(CONNECTING));
-    inOrder.verify(helper).updatePicker(pickerCaptor.capture());
-    RoundRobinPicker picker4 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertRoundRobinList(picker4, subchannel2);
-
-    // As long as there is at least one READY subchannel, round robin will work.
-    Status error1 = Status.UNAVAILABLE.withDescription("error1");
-    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forTransientFailure(error1));
-    inOrder.verify(helper).updatePicker(pickerCaptor.capture());
-    RoundRobinPicker picker5 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertRoundRobinList(picker5, subchannel2);
-
-    // If no subchannel is READY, will propagate an error from an arbitrary subchannel (but here
-    // only subchannel1 has error).
-    verify(subchannel2).requestConnection();
-    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(IDLE));
-    verify(subchannel2, times(2)).requestConnection();
-    inOrder.verify(helper).updatePicker(pickerCaptor.capture());
-    ErrorPicker picker6 = (ErrorPicker) pickerCaptor.getValue();
-    assertNull(picker6.result.getSubchannel());
-    assertSame(error1, picker6.result.getStatus());
-
-    // Update backends, with a drop entry
-    List<InetSocketAddress> backends2 = Arrays.asList(
-        new InetSocketAddress("127.0.0.1", 2030), null);
-    verify(subchannel1, never()).shutdown();
-    verify(subchannel2, never()).shutdown();
-
-    lbResponseObserver.onNext(buildLbResponse(backends2));
-    verify(subchannel1).shutdown();
-    verify(subchannel2).shutdown();
-
-    inOrder.verify(helper).createSubchannel(
-        eq(new EquivalentAddressGroup(backends2.get(0))), any(Attributes.class));
-    assertEquals(1, mockSubchannels.size());
-    Subchannel subchannel3 = mockSubchannels.poll();
-    verify(subchannel3).requestConnection();
-    assertEquals(new EquivalentAddressGroup(backends2.get(0)), subchannel3.getAddresses());
-    inOrder.verify(helper).updatePicker(pickerCaptor.capture());
-    RoundRobinPicker picker7 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertRoundRobinList(picker7, (Subchannel) null);
-
-    // State updates on obsolete subchannels will have no effect
-    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(READY));
-    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(SHUTDOWN));
-    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(SHUTDOWN));
-    inOrder.verifyNoMoreInteractions();
-
-    deliverSubchannelState(subchannel3, ConnectivityStateInfo.forNonError(READY));
-    inOrder.verify(helper).updatePicker(pickerCaptor.capture());
-    RoundRobinPicker picker8 = (RoundRobinPicker) pickerCaptor.getValue();
-    assertRoundRobinList(picker8, subchannel3, null);
-
-    verify(subchannel3, never()).shutdown();
-    assertFalse(oobChannel.isShutdown());
-    assertEquals(1, lbRequestObservers.size());
-    verify(lbRequestObservers.peek(), never()).onCompleted();
-    verify(lbRequestObservers.peek(), never()).onError(any(Throwable.class));
-  }
-
-  @Test
-  public void grpclbBalanerCommErrors() {
-    InOrder inOrder = inOrder(helper, mockLbService);
-    // Make the first LB address fail to connect
-    failingLbAuthorities.add(lbAuthority(0));
-    List<ResolvedServerInfoGroup> grpclbResolutionList =
-        createResolvedServerInfoGroupList(true, true, true);
-
-    Attributes grpclbResolutionAttrs = Attributes.newBuilder()
-        .set(GrpclbConstants.ATTR_LB_POLICY, LbPolicy.GRPCLB).build();
-    deliverResolvedAddresses(grpclbResolutionList, grpclbResolutionAttrs);
-
-    // First LB addr fails to connect
-    inOrder.verify(helper).createOobChannel(
-        eq(grpclbResolutionList.get(0).toEquivalentAddressGroup()),
-        eq(lbAuthority(0)));
-    inOrder.verify(helper).updatePicker(isA(ErrorPicker.class));
-
-    assertEquals(2, fakeOobChannels.size());
-    assertTrue(fakeOobChannels.poll().isShutdown());
-    // Will move on to second LB addr
-    inOrder.verify(helper).createOobChannel(
-        eq(grpclbResolutionList.get(1).toEquivalentAddressGroup()),
-        eq(lbAuthority(1)));
-    inOrder.verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
-    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
-    assertEquals(1, lbRequestObservers.size());
-    lbRequestObservers.poll();
-    assertEquals(1, fakeOobChannels.size());
-    assertFalse(fakeOobChannels.peek().isShutdown());
-
-    Status error1 = Status.UNAVAILABLE.withDescription("error1");
-    // Simulate that the stream on the second LB failed
-    lbResponseObserver.onError(error1.asException());
-    assertTrue(fakeOobChannels.poll().isShutdown());
-
-    inOrder.verify(helper).updatePicker(pickerCaptor.capture());
-    ErrorPicker errorPicker = (ErrorPicker) pickerCaptor.getValue();
-    assertEquals(error1.getCode(), errorPicker.result.getStatus().getCode());
-    assertTrue(errorPicker.result.getStatus().getDescription().contains(error1.getDescription()));
-    // Move on to the third LB.
-    inOrder.verify(helper).createOobChannel(
-        eq(grpclbResolutionList.get(2).toEquivalentAddressGroup()),
-        eq(lbAuthority(2)));
-
-    inOrder.verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
-    lbResponseObserver = lbResponseObserverCaptor.getValue();
-    assertEquals(1, lbRequestObservers.size());
-    lbRequestObservers.poll();
-    assertEquals(1, fakeOobChannels.size());
-    assertFalse(fakeOobChannels.peek().isShutdown());
-
-    // Simulate that the stream on the third LB closed without error.  It is treated
-    // as an error.
-    lbResponseObserver.onCompleted();
-    assertTrue(fakeOobChannels.poll().isShutdown());
-
-    // Loop back to the first LB addr, which still fails.
-    inOrder.verify(helper).createOobChannel(
-        eq(grpclbResolutionList.get(0).toEquivalentAddressGroup()),
-        eq(lbAuthority(0)));
-    inOrder.verify(helper).updatePicker(isA(ErrorPicker.class));
-
-    assertEquals(2, fakeOobChannels.size());
-    assertTrue(fakeOobChannels.poll().isShutdown());
-    // Will move on to second LB addr
-    inOrder.verify(helper).createOobChannel(
-        eq(grpclbResolutionList.get(1).toEquivalentAddressGroup()),
-        eq(lbAuthority(1)));
-    inOrder.verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
-    lbResponseObserver = lbResponseObserverCaptor.getValue();
-    assertEquals(1, lbRequestObservers.size());
-
-    assertEquals(1, fakeOobChannels.size());
-    assertFalse(fakeOobChannels.peek().isShutdown());
-
-    // Finally it works.
-    lbResponseObserver.onNext(buildInitialResponse());
-    List<InetSocketAddress> backends = Arrays.asList(
-        new InetSocketAddress("127.0.0.1", 2000),
-        new InetSocketAddress("127.0.0.1", 2010));
-    lbResponseObserver.onNext(buildLbResponse(backends));
-    inOrder.verify(helper).createSubchannel(
-        eq(new EquivalentAddressGroup(backends.get(0))), any(Attributes.class));
-    inOrder.verify(helper).createSubchannel(
-        eq(new EquivalentAddressGroup(backends.get(1))), any(Attributes.class));
-    inOrder.verify(helper).updatePicker(same(GrpclbLoadBalancer2.BUFFER_PICKER));
-    inOrder.verifyNoMoreInteractions();
-  }
-
-  private void deliverSubchannelState(
-      final Subchannel subchannel, final ConnectivityStateInfo newState) {
-    channelExecutor.execute(new Runnable() {
-        @Override
-        public void run() {
-          balancer.handleSubchannelState(subchannel, newState);
-        }
-      });
-  }
-
-  private void deliverNameResolutionError(final Status error) {
-    channelExecutor.execute(new Runnable() {
-        @Override
-        public void run() {
-          balancer.handleNameResolutionError(error);
-        }
-      });
-  }
-
-  private void deliverResolvedAddresses(
-      final List<ResolvedServerInfoGroup> addrs, final Attributes attrs) {
-    channelExecutor.execute(new Runnable() {
-        @Override
-        public void run() {
-          balancer.handleResolvedAddresses(addrs, attrs);
-        }
-      });
-  }
-
-  private static List<ResolvedServerInfoGroup> createResolvedServerInfoGroupList(boolean ... isLb) {
-    ArrayList<ResolvedServerInfoGroup> list = new ArrayList<ResolvedServerInfoGroup>();
-    for (int i = 0; i < isLb.length; i++) {
-      SocketAddress addr = new FakeSocketAddress("fake-address-" + i);
-      ResolvedServerInfoGroup serverInfoGroup = ResolvedServerInfoGroup
-          .builder(isLb[i] ? Attributes.newBuilder()
-              .set(GrpclbConstants.ATTR_LB_ADDR_AUTHORITY, lbAuthority(i))
-              .build()
-              : Attributes.EMPTY)
-          .add(new ResolvedServerInfo(addr))
-          .build();
-      list.add(serverInfoGroup);
-    }
-    return list;
-  }
-
-  private static String lbAuthority(int i) {
-    return "lb" + i + ".google.com";
-  }
-
-  private static LoadBalanceResponse buildInitialResponse() {
-    return LoadBalanceResponse.newBuilder().setInitialResponse(
-        InitialLoadBalanceResponse.getDefaultInstance())
-        .build();
-  }
-
-  private static LoadBalanceResponse buildLbResponse(List<InetSocketAddress> addrs) {
-    ServerList.Builder serverListBuilder = ServerList.newBuilder();
-    for (InetSocketAddress addr : addrs) {
-      if (addr != null) {
-        serverListBuilder.addServers(Server.newBuilder()
-            .setIpAddress(ByteString.copyFrom(addr.getAddress().getAddress()))
-            .setPort(addr.getPort())
-            .build());
-      } else {
-        serverListBuilder.addServers(Server.newBuilder().setDropRequest(true).build());
-      }
-    }
-    return LoadBalanceResponse.newBuilder()
-        .setServerList(serverListBuilder.build())
-        .build();
-  }
-
-  private static void assertRoundRobinList(RoundRobinPicker picker, Subchannel ... subchannels) {
-    assertEquals(subchannels.length, picker.list.size());
-    for (int i = 0; i < subchannels.length; i++) {
-      Subchannel subchannel = subchannels[i];
-      if (subchannel == null) {
-        assertSame("list[" + i + "] should be drop",
-            GrpclbLoadBalancer2.THROTTLED_RESULT, picker.list.get(i));
-      } else {
-        assertEquals("list[" + i + "] should be Subchannel",
-            subchannel, picker.list.get(i).getSubchannel());
-      }
-    }
-  }
-
-  private static class FakeSocketAddress extends SocketAddress {
-    final String name;
-
-    FakeSocketAddress(String name) {
-      this.name = name;
-    }
-
-    @Override
-    public String toString() {
-      return "FakeSocketAddress-" + name;
-    }
-
-    @Override
-    public boolean equals(Object other) {
-      if (other instanceof FakeSocketAddress) {
-        FakeSocketAddress otherAddr = (FakeSocketAddress) other;
-        return name.equals(otherAddr.name);
-      }
-      return false;
-    }
-
-    @Override
-    public int hashCode() {
-      return name.hashCode();
-    }
-  }
-}
diff --git a/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerProviderTest.java b/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..153ce5a86f1
--- /dev/null
+++ b/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerProviderTest.java
@@ -0,0 +1,229 @@
+/*
+ * 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.grpclb;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.grpclb.GrpclbState.Mode;
+import io.grpc.internal.JsonParser;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class GrpclbLoadBalancerProviderTest {
+  private final GrpclbLoadBalancerProvider provider = new GrpclbLoadBalancerProvider();
+
+  @Test
+  public void provider_isRegistered() {
+    LoadBalancerRegistry registry = LoadBalancerRegistry.getDefaultRegistry();
+    assertThat(registry.getProvider("grpclb")).isInstanceOf(GrpclbLoadBalancerProvider.class);
+  }
+
+  @Test
+  public void provider_getPriority() {
+    assertThat(provider.getPriority()).isEqualTo(5);
+  }
+
+  @Test
+  public void retrieveModeFromLbConfig_pickFirst() throws Exception {
+    String lbConfig = "{\"childPolicy\" : [{\"pick_first\" : {}}, {\"round_robin\" : {}}]}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+
+    assertThat(configOrError.getConfig()).isNotNull();
+    GrpclbConfig config = (GrpclbConfig) configOrError.getConfig();
+    assertThat(config.getMode()).isEqualTo(Mode.PICK_FIRST);
+    assertThat(config.getServiceName()).isNull();
+    assertThat(config.getFallbackTimeoutMs()).isEqualTo(GrpclbState.FALLBACK_TIMEOUT_MS);
+  }
+
+  @Test
+  public void retrieveModeFromLbConfig_roundRobin() throws Exception {
+    String lbConfig = "{\"childPolicy\" : [{\"round_robin\" : {}}, {\"pick_first\" : {}}]}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+
+    assertThat(configOrError.getConfig()).isNotNull();
+    GrpclbConfig config = (GrpclbConfig) configOrError.getConfig();
+    assertThat(config.getMode()).isEqualTo(Mode.ROUND_ROBIN);
+    assertThat(config.getServiceName()).isNull();
+    assertThat(config.getFallbackTimeoutMs()).isEqualTo(GrpclbState.FALLBACK_TIMEOUT_MS);
+  }
+
+  @Test
+  public void setTimeoutToLbConfig() throws Exception {
+    String lbConfig =
+        "{\"initialFallbackTimeout\" : \"123s\", \"childPolicy\" : [{\"pick_first\" : {}},"
+            + " {\"round_robin\" : {}}]}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+
+    assertThat(configOrError.getConfig()).isNotNull();
+    GrpclbConfig config = (GrpclbConfig) configOrError.getConfig();
+    assertThat(config.getMode()).isEqualTo(Mode.PICK_FIRST);
+    assertThat(config.getServiceName()).isNull();
+    assertThat(config.getFallbackTimeoutMs()).isEqualTo(123000);
+  }
+
+  @Test
+  public void setInvalidTimeoutToLbConfig() throws Exception {
+    String lbConfig =
+        "{\"initialFallbackTimeout\" : \"-1s\", \"childPolicy\" : [{\"pick_first\" : {}},"
+            + " {\"round_robin\" : {}}]}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+
+    assertThat(configOrError.getConfig()).isNull();
+    assertThat(configOrError.getError()).isNotNull();
+    Status errorStatus = configOrError.getError();
+    assertThat(errorStatus.getCause()).hasMessageThat().isEqualTo("Invalid timeout (-1000)");
+  }
+
+  @Test
+  public void setInvalidTimeoutDurationProtoToLbConfig() throws Exception {
+    String lbConfig =
+        "{\"initialFallbackTimeout\" : \"1000\", \"childPolicy\" : [{\"pick_first\" : {}},"
+            + " {\"round_robin\" : {}}]}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+
+    assertThat(configOrError.getError()).isNotNull();
+    Status errorStatus = configOrError.getError();
+    assertThat(errorStatus.getCause())
+        .hasMessageThat()
+        .isEqualTo("java.text.ParseException: Invalid duration string: 1000");
+  }
+
+  @Test
+  public void retrieveModeFromLbConfig_nullConfigUseRoundRobin() throws Exception {
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(null);
+
+    assertThat(configOrError.getConfig()).isNotNull();
+    GrpclbConfig config = (GrpclbConfig) configOrError.getConfig();
+    assertThat(config.getMode()).isEqualTo(Mode.ROUND_ROBIN);
+    assertThat(config.getServiceName()).isNull();
+    assertThat(config.getFallbackTimeoutMs()).isEqualTo(GrpclbState.FALLBACK_TIMEOUT_MS);
+  }
+
+  @Test
+  public void retrieveModeFromLbConfig_emptyConfigUseRoundRobin() throws Exception {
+    String lbConfig = "{}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+
+    assertThat(configOrError.getConfig()).isNotNull();
+    GrpclbConfig config = (GrpclbConfig) configOrError.getConfig();
+    assertThat(config.getMode()).isEqualTo(Mode.ROUND_ROBIN);
+    assertThat(config.getServiceName()).isNull();
+    assertThat(config.getFallbackTimeoutMs()).isEqualTo(GrpclbState.FALLBACK_TIMEOUT_MS);
+  }
+
+  @Test
+  public void retrieveModeFromLbConfig_emptyChildPolicyUseRoundRobin() throws Exception {
+    String lbConfig = "{\"childPolicy\" : []}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+
+    assertThat(configOrError.getConfig()).isNotNull();
+    GrpclbConfig config = (GrpclbConfig) configOrError.getConfig();
+    assertThat(config.getMode()).isEqualTo(Mode.ROUND_ROBIN);
+    assertThat(config.getServiceName()).isNull();
+    assertThat(config.getFallbackTimeoutMs()).isEqualTo(GrpclbState.FALLBACK_TIMEOUT_MS);
+  }
+
+  @Test
+  public void retrieveModeFromLbConfig_unsupportedChildPolicy()
+      throws Exception {
+    String lbConfig = "{\"childPolicy\" : [ {\"nonono\" : {}} ]}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+
+    assertThat(configOrError.getError()).isNotNull();
+    assertThat(configOrError.getError().getDescription())
+        .contains("None of [nonono] specified child policies are available.");
+  }
+
+  @Test
+  public void retrieveModeFromLbConfig_skipUnsupportedChildPolicy() throws Exception {
+    String lbConfig = "{\"childPolicy\" : [ {\"nono\" : {}}, {\"pick_first\" : {} } ]}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+
+    assertThat(configOrError.getConfig()).isNotNull();
+    GrpclbConfig config = (GrpclbConfig) configOrError.getConfig();
+    assertThat(config.getMode()).isEqualTo(Mode.PICK_FIRST);
+    assertThat(config.getServiceName()).isNull();
+    assertThat(config.getFallbackTimeoutMs()).isEqualTo(GrpclbState.FALLBACK_TIMEOUT_MS);
+  }
+
+  @Test
+  public void retrieveModeFromLbConfig_skipUnsupportedChildPolicyWithTarget() throws Exception {
+    String lbConfig = "{\"childPolicy\" : [ {\"nono\" : {}}, {\"pick_first\" : {}} ],"
+        + "\"serviceName\": \"foo.google.com\"}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+
+    assertThat(configOrError.getConfig()).isNotNull();
+    GrpclbConfig config = (GrpclbConfig) configOrError.getConfig();
+    assertThat(config.getMode()).isEqualTo(Mode.PICK_FIRST);
+    assertThat(config.getServiceName()).isEqualTo("foo.google.com");
+    assertThat(config.getFallbackTimeoutMs()).isEqualTo(GrpclbState.FALLBACK_TIMEOUT_MS);
+  }
+
+  @Test
+  public void retrieveModeFromLbConfig_wrongChildPolicyType() throws Exception {
+    String lbConfig = "{\"childPolicy\" : {}}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+
+    assertThat(configOrError.getError()).isNotNull();
+    assertThat(configOrError.getError().getCause()).hasMessageThat().contains("is not List");
+  }
+
+  @Test
+  public void retrieveModeFromLbConfig_wrongChildPolicyTypeWithTarget() throws Exception {
+    String lbConfig = "{\"childPolicy\" : {}, \"serviceName\": \"foo.google.com\"}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+
+    assertThat(configOrError.getError()).isNotNull();
+    assertThat(configOrError.getError().getCause()).hasMessageThat().contains("is not List");
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, ?> parseJsonObject(String json) throws Exception {
+    return (Map<String, ?>) JsonParser.parse(json);
+  }
+}
diff --git a/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerTest.java b/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerTest.java
index 5e0d594d8e2..ef31b318cb5 100644
--- a/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerTest.java
+++ b/grpclb/src/test/java/io/grpc/grpclb/GrpclbLoadBalancerTest.java
@@ -1,535 +1,2983 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.grpclb;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static io.grpc.grpclb.GrpclbState.BUFFER_ENTRY;
+import static io.grpc.grpclb.GrpclbState.DROP_PICK_RESULT;
+import static io.grpc.grpclb.GrpclbState.NO_USE_AUTHORITY_SUFFIX;
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
-import static org.mockito.Mockito.withSettings;
 
-import com.google.common.base.Supplier;
+import com.google.common.collect.Iterables;
 import com.google.protobuf.ByteString;
+import com.google.protobuf.util.Durations;
+import com.google.protobuf.util.Timestamps;
 import io.grpc.Attributes;
+import io.grpc.ChannelLogger;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.Context;
+import io.grpc.Context.CancellableContext;
 import io.grpc.EquivalentAddressGroup;
-import io.grpc.ResolvedServerInfo;
-import io.grpc.ResolvedServerInfoGroup;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
 import io.grpc.Status;
-import io.grpc.TransportManager;
-import io.grpc.TransportManager.InterimTransport;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.grpclb.GrpclbState.BackendEntry;
+import io.grpc.grpclb.GrpclbState.ChildLbPickerEntry;
+import io.grpc.grpclb.GrpclbState.DropEntry;
+import io.grpc.grpclb.GrpclbState.ErrorEntry;
+import io.grpc.grpclb.GrpclbState.IdleSubchannelEntry;
+import io.grpc.grpclb.GrpclbState.Mode;
+import io.grpc.grpclb.GrpclbState.RoundRobinPicker;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.FakeClock;
+import io.grpc.lb.v1.ClientStats;
+import io.grpc.lb.v1.ClientStatsPerToken;
+import io.grpc.lb.v1.FallbackResponse;
+import io.grpc.lb.v1.InitialLoadBalanceRequest;
+import io.grpc.lb.v1.InitialLoadBalanceResponse;
+import io.grpc.lb.v1.LoadBalanceRequest;
+import io.grpc.lb.v1.LoadBalanceResponse;
+import io.grpc.lb.v1.LoadBalancerGrpc;
+import io.grpc.lb.v1.Server;
+import io.grpc.lb.v1.ServerList;
+import io.grpc.stub.StreamObserver;
 import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.text.MessageFormat;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
-import java.util.Collection;
+import java.util.Arrays;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.List;
-import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
+import org.mockito.AdditionalAnswers;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
+import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
 
 /** Unit tests for {@link GrpclbLoadBalancer}. */
 @RunWith(JUnit4.class)
 public class GrpclbLoadBalancerTest {
-
-  private static final String serviceName = "testlbservice";
-
-  @Mock private TransportManager<Transport> mockTransportManager;
-  @Mock private InterimTransport<Transport> interimTransport;
-  @Mock private Transport interimTransportAsTransport;
-  @Mock private Transport failingTransport;
-  @Captor private ArgumentCaptor<Supplier<Transport>> transportSupplierCaptor;
-
-  // The test subject
-  private TestGrpclbLoadBalancer loadBalancer;
-
-  // Current addresses of the LB server
-  private EquivalentAddressGroup lbAddressGroup;
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private static final String SERVICE_AUTHORITY = "api.google.com";
+
+  // The tasks are wrapped by SynchronizationContext, so we can't compare the types
+  // directly.
+  private static final FakeClock.TaskFilter LOAD_REPORTING_TASK_FILTER =
+      new FakeClock.TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable command) {
+          return command.toString().contains(GrpclbState.LoadReportingTask.class.getSimpleName());
+        }
+      };
+  private static final FakeClock.TaskFilter FALLBACK_MODE_TASK_FILTER =
+      new FakeClock.TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable command) {
+          return command.toString().contains(GrpclbState.FallbackModeTask.class.getSimpleName());
+        }
+      };
+  private static final FakeClock.TaskFilter LB_RPC_RETRY_TASK_FILTER =
+      new FakeClock.TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable command) {
+          return command.toString().contains(GrpclbState.LbRpcRetryTask.class.getSimpleName());
+        }
+      };
+  private static final Attributes LB_BACKEND_ATTRS =
+      Attributes.newBuilder().set(GrpclbConstants.ATTR_LB_PROVIDED_BACKEND, true).build();
+
+  private final Helper helper = mock(Helper.class, delegatesTo(new FakeHelper()));
+  private final SubchannelPool subchannelPool =
+      mock(
+          SubchannelPool.class,
+          delegatesTo(new CachedSubchannelPool(helper)));
+  private final ArrayList<String> logs = new ArrayList<>();
+  private final ChannelLogger channelLogger = new ChannelLogger() {
+      @Override
+      public void log(ChannelLogLevel level, String msg) {
+        logs.add(level + ": " + msg);
+      }
+
+      @Override
+      public void log(ChannelLogLevel level, String template, Object... args) {
+        log(level, MessageFormat.format(template, args));
+      }
+    };
+  private SubchannelPicker currentPicker;
+  private LoadBalancerGrpc.LoadBalancerImplBase mockLbService;
+  @Captor
+  private ArgumentCaptor<StreamObserver<LoadBalanceResponse>> lbResponseObserverCaptor;
+  private final FakeClock fakeClock = new FakeClock();
+  private final ArrayDeque<StreamObserver<LoadBalanceRequest>> lbRequestObservers =
+      new ArrayDeque<>();
+  private final ArrayDeque<Subchannel> mockSubchannels = new ArrayDeque<>();
+  private final ArrayDeque<ManagedChannel> fakeOobChannels = new ArrayDeque<>();
+  private final ArrayList<Subchannel> unpooledSubchannelTracker = new ArrayList<>();
+  private final ArrayList<ManagedChannel> oobChannelTracker = new ArrayList<>();
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private static final ClientStreamTracer.StreamInfo STREAM_INFO =
+      ClientStreamTracer.StreamInfo.newBuilder().build();
+
+  private io.grpc.Server fakeLbServer;
+  @Captor
+  private ArgumentCaptor<SubchannelPicker> pickerCaptor;
+  @Mock
+  private BackoffPolicy.Provider backoffPolicyProvider;
+  @Mock
+  private BackoffPolicy backoffPolicy1;
+  @Mock
+  private BackoffPolicy backoffPolicy2;
+  private GrpclbLoadBalancer balancer;
+  private final ArgumentCaptor<CreateSubchannelArgs> createSubchannelArgsCaptor =
+      ArgumentCaptor.forClass(CreateSubchannelArgs.class);
 
   @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    when(mockTransportManager.createInterimTransport()).thenReturn(interimTransport);
-    when(mockTransportManager.createFailingTransport(any(Status.class)))
-        .thenReturn(failingTransport);
-    when(interimTransport.transport()).thenReturn(interimTransportAsTransport);
-    loadBalancer = new TestGrpclbLoadBalancer();
+  public void setUp() throws Exception {
+    mockLbService = mock(LoadBalancerGrpc.LoadBalancerImplBase.class, delegatesTo(
+        new LoadBalancerGrpc.LoadBalancerImplBase() {
+          @Override
+          @SuppressWarnings("unchecked")
+          public StreamObserver<LoadBalanceRequest> balanceLoad(
+              final StreamObserver<LoadBalanceResponse> responseObserver) {
+            StreamObserver<LoadBalanceRequest> requestObserver =
+                mock(StreamObserver.class);
+            Answer<Void> closeRpc = new Answer<Void>() {
+                @Override
+                public Void answer(InvocationOnMock invocation) {
+                  responseObserver.onCompleted();
+                  return null;
+                }
+              };
+            doAnswer(closeRpc).when(requestObserver).onCompleted();
+            lbRequestObservers.add(requestObserver);
+            return requestObserver;
+          }
+        }));
+    fakeLbServer = InProcessServerBuilder.forName("fakeLb")
+        .directExecutor().addService(mockLbService).build().start();
+    when(backoffPolicy1.nextBackoffNanos()).thenReturn(10L, 100L);
+    when(backoffPolicy2.nextBackoffNanos()).thenReturn(10L, 100L);
+    when(backoffPolicyProvider.get()).thenReturn(backoffPolicy1, backoffPolicy2);
+    balancer = new GrpclbLoadBalancer(
+        helper,
+        Context.ROOT,
+        subchannelPool,
+        fakeClock.getTimeProvider(),
+        fakeClock.getStopwatchSupplier().get(),
+        backoffPolicyProvider);
   }
 
-  @Test
-  public void balancing() throws Exception {
-    List<ResolvedServerInfo> servers = createResolvedServerInfoList(4000, 4001);
+  @After
+  public void tearDown() {
+    try {
+      if (balancer != null) {
+        syncContext.execute(new Runnable() {
+            @Override
+            public void run() {
+              balancer.shutdown();
+            }
+          });
+      }
+      for (ManagedChannel channel : oobChannelTracker) {
+        assertTrue(channel + " is shutdown", channel.isShutdown());
+        // balancer should have closed the LB stream, terminating the OOB channel.
+        assertTrue(channel + " is terminated", channel.isTerminated());
+      }
+      for (Subchannel subchannel : unpooledSubchannelTracker) {
+        verify(subchannel).shutdown();
+      }
+      // No timer should linger after shutdown
+      assertThat(fakeClock.getPendingTasks()).isEmpty();
+    } finally {
+      if (fakeLbServer != null) {
+        fakeLbServer.shutdownNow();
+      }
+    }
+  }
 
-    // Set up mocks
-    List<Transport> transports = new ArrayList<Transport>(servers.size());
-    for (ResolvedServerInfo server : servers) {
-      Transport transport = mock(Transport.class, withSettings().name("Transport for "  + server));
-      transports.add(transport);
-      when(mockTransportManager.getTransport(eq(new EquivalentAddressGroup(server.getAddress()))))
-          .thenReturn(transport);
-    }
+  @Test
+  public void roundRobinPickerNoDrop() {
+    GrpclbClientLoadRecorder loadRecorder =
+        new GrpclbClientLoadRecorder(fakeClock.getTimeProvider());
+    Subchannel subchannel = mock(Subchannel.class);
+    BackendEntry b1 = new BackendEntry(subchannel, loadRecorder, "LBTOKEN0001");
+    BackendEntry b2 = new BackendEntry(subchannel, loadRecorder, "LBTOKEN0002");
+
+    List<BackendEntry> pickList = Arrays.asList(b1, b2);
+    RoundRobinPicker picker = new RoundRobinPicker(Collections.<DropEntry>emptyList(), pickList);
+
+    PickSubchannelArgs args1 = mock(PickSubchannelArgs.class);
+    Metadata headers1 = new Metadata();
+    // The existing token on the headers will be replaced
+    headers1.put(GrpclbConstants.TOKEN_METADATA_KEY, "LBTOKEN__OLD");
+    when(args1.getHeaders()).thenReturn(headers1);
+    assertSame(b1.result, picker.pickSubchannel(args1));
+    verify(args1).getHeaders();
+    assertThat(headers1.getAll(GrpclbConstants.TOKEN_METADATA_KEY)).containsExactly("LBTOKEN0001");
+
+    PickSubchannelArgs args2 = mock(PickSubchannelArgs.class);
+    Metadata headers2 = new Metadata();
+    when(args2.getHeaders()).thenReturn(headers2);
+    assertSame(b2.result, picker.pickSubchannel(args2));
+    verify(args2).getHeaders();
+    assertThat(headers2.getAll(GrpclbConstants.TOKEN_METADATA_KEY)).containsExactly("LBTOKEN0002");
+
+    PickSubchannelArgs args3 = mock(PickSubchannelArgs.class);
+    Metadata headers3 = new Metadata();
+    when(args3.getHeaders()).thenReturn(headers3);
+    assertSame(b1.result, picker.pickSubchannel(args3));
+    verify(args3).getHeaders();
+    assertThat(headers3.getAll(GrpclbConstants.TOKEN_METADATA_KEY)).containsExactly("LBTOKEN0001");
+
+    verify(subchannel, never()).getAttributes();
+  }
 
-    Transport pick0;
-    Transport pick1;
-    Transport pick2;
-
-    // Pick before name resolved
-    pick0 = loadBalancer.pickTransport(null);
-
-    // Name resolved
-    Transport lbTransport = simulateLbAddressResolved(30001);
-
-    // Pick after name resolved
-    pick1 = loadBalancer.pickTransport(null);
-    pick2 = loadBalancer.pickTransport(null);
-
-    // Both picks end up with interimTransport
-    verify(mockTransportManager).createInterimTransport();
-    assertSame(interimTransportAsTransport, pick0);
-    assertSame(interimTransportAsTransport, pick1);
-    assertSame(interimTransportAsTransport, pick2);
+  @Test
+  public void roundRobinPickerWithDrop() {
+    assertTrue(DROP_PICK_RESULT.isDrop());
+    GrpclbClientLoadRecorder loadRecorder =
+        new GrpclbClientLoadRecorder(fakeClock.getTimeProvider());
+    Subchannel subchannel = mock(Subchannel.class);
+    // 1 out of 2 requests are to be dropped
+    DropEntry d = new DropEntry(loadRecorder, "LBTOKEN0003");
+    List<DropEntry> dropList = Arrays.asList(null, d);
+
+    BackendEntry b1 = new BackendEntry(subchannel, loadRecorder, "LBTOKEN0001");
+    BackendEntry b2 = new BackendEntry(subchannel, loadRecorder, "LBTOKEN0002");
+    List<BackendEntry> pickList = Arrays.asList(b1, b2);
+    RoundRobinPicker picker = new RoundRobinPicker(dropList, pickList);
+
+    // dropList[0], pickList[0]
+    PickSubchannelArgs args1 = mock(PickSubchannelArgs.class);
+    Metadata headers1 = new Metadata();
+    headers1.put(GrpclbConstants.TOKEN_METADATA_KEY, "LBTOKEN__OLD");
+    when(args1.getHeaders()).thenReturn(headers1);
+    assertSame(b1.result, picker.pickSubchannel(args1));
+    verify(args1).getHeaders();
+    assertThat(headers1.getAll(GrpclbConstants.TOKEN_METADATA_KEY)).containsExactly("LBTOKEN0001");
+
+    // dropList[1]: drop
+    PickSubchannelArgs args2 = mock(PickSubchannelArgs.class);
+    Metadata headers2 = new Metadata();
+    when(args2.getHeaders()).thenReturn(headers2);
+    assertSame(DROP_PICK_RESULT, picker.pickSubchannel(args2));
+    verify(args2, never()).getHeaders();
+
+    // dropList[0], pickList[1]
+    PickSubchannelArgs args3 = mock(PickSubchannelArgs.class);
+    Metadata headers3 = new Metadata();
+    when(args3.getHeaders()).thenReturn(headers3);
+    assertSame(b2.result, picker.pickSubchannel(args3));
+    verify(args3).getHeaders();
+    assertThat(headers3.getAll(GrpclbConstants.TOKEN_METADATA_KEY)).containsExactly("LBTOKEN0002");
+
+    // dropList[1]: drop
+    PickSubchannelArgs args4 = mock(PickSubchannelArgs.class);
+    Metadata headers4 = new Metadata();
+    when(args4.getHeaders()).thenReturn(headers4);
+    assertSame(DROP_PICK_RESULT, picker.pickSubchannel(args4));
+    verify(args4, never()).getHeaders();
+
+    // dropList[0], pickList[0]
+    PickSubchannelArgs args5 = mock(PickSubchannelArgs.class);
+    Metadata headers5 = new Metadata();
+    when(args5.getHeaders()).thenReturn(headers5);
+    assertSame(b1.result, picker.pickSubchannel(args5));
+    verify(args5).getHeaders();
+    assertThat(headers5.getAll(GrpclbConstants.TOKEN_METADATA_KEY)).containsExactly("LBTOKEN0001");
+
+    verify(subchannel, never()).getAttributes();
+  }
 
-    // An LB request is sent
-    SendLbRequestArgs sentLbRequest = loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS);
-    assertNotNull(sentLbRequest);
-    assertSame(lbTransport, sentLbRequest.transport);
+  @Test
+  public void roundRobinPickerWithIdleEntry_noDrop() {
+    Subchannel subchannel = mock(Subchannel.class);
+    IdleSubchannelEntry entry = new IdleSubchannelEntry(subchannel, syncContext);
+
+    RoundRobinPicker picker =
+        new RoundRobinPicker(Collections.<DropEntry>emptyList(), Collections.singletonList(entry));
+    PickSubchannelArgs args = mock(PickSubchannelArgs.class);
+
+    verify(subchannel, never()).requestConnection();
+    assertThat(picker.pickSubchannel(args)).isSameInstanceAs(PickResult.withNoResult());
+    verify(subchannel).requestConnection();
+    assertThat(picker.pickSubchannel(args)).isSameInstanceAs(PickResult.withNoResult());
+    // Only the first pick triggers requestConnection()
+    verify(subchannel).requestConnection();
+  }
 
-    // Simulate an initial LB response
-    loadBalancer.getLbResponseObserver().onNext(
-        LoadBalanceResponse.newBuilder().setInitialResponse(
-            InitialLoadBalanceResponse.getDefaultInstance())
-        .build());
+  @Test
+  public void roundRobinPickerWithIdleEntry_andDrop() {
+    GrpclbClientLoadRecorder loadRecorder =
+        new GrpclbClientLoadRecorder(fakeClock.getTimeProvider());
+    // 1 out of 2 requests are to be dropped
+    DropEntry d = new DropEntry(loadRecorder, "LBTOKEN0003");
+    List<DropEntry> dropList = Arrays.asList(null, d);
 
-    // Simulate that the LB server reponses, with servers 0, 1, 1
-    List<ResolvedServerInfo> serverList1 = new ArrayList<ResolvedServerInfo>();
-    Collections.addAll(serverList1, servers.get(0), servers.get(1), servers.get(1));
-    assertNotNull(loadBalancer.getLbResponseObserver());
-    loadBalancer.getLbResponseObserver().onNext(buildLbResponse(serverList1));
+    Subchannel subchannel = mock(Subchannel.class);
+    IdleSubchannelEntry entry = new IdleSubchannelEntry(subchannel, syncContext);
 
-    verify(mockTransportManager).updateRetainedTransports(eq(buildRetainedAddressSet(servers)));
+    RoundRobinPicker picker = new RoundRobinPicker(dropList, Collections.singletonList(entry));
+    PickSubchannelArgs args = mock(PickSubchannelArgs.class);
 
-    verify(interimTransport).closeWithRealTransports(transportSupplierCaptor.capture());
-    assertSame(transports.get(0), transportSupplierCaptor.getValue().get());
-    assertSame(transports.get(1), transportSupplierCaptor.getValue().get());
-    assertSame(transports.get(1), transportSupplierCaptor.getValue().get());
-    verify(mockTransportManager).getTransport(eq(buildAddressGroup(servers.get(0))));
-    verify(mockTransportManager, times(2)).getTransport(eq(buildAddressGroup(servers.get(1))));
+    verify(subchannel, never()).requestConnection();
+    assertThat(picker.pickSubchannel(args)).isSameInstanceAs(PickResult.withNoResult());
+    verify(subchannel).requestConnection();
 
-    // Pick beyond the end of the list. Go back to the beginning.
-    pick0 = loadBalancer.pickTransport(null);
-    assertSame(transports.get(0), pick0);
+    assertThat(picker.pickSubchannel(args)).isSameInstanceAs(DROP_PICK_RESULT);
 
-    // Only one LB request has ever been sent at this point
-    assertEquals(0, loadBalancer.sentLbRequests.size());
+    verify(subchannel).requestConnection();
+    assertThat(picker.pickSubchannel(args)).isSameInstanceAs(PickResult.withNoResult());
+    // Only the first pick triggers requestConnection()
+    verify(subchannel).requestConnection();
   }
 
-  @Test public void serverListUpdated() throws Exception {
-    // Simulate the initial set of LB addresses resolved
-    Transport lbTransport = simulateLbAddressResolved(30001);
-
-    // An LB request is sent
-    SendLbRequestArgs sentLbRequest = loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS);
-    assertNotNull(sentLbRequest);
-    assertSame(lbTransport, sentLbRequest.transport);
-
-    // Simulate LB server responds a server list
-    List<ResolvedServerInfo> serverList = createResolvedServerInfoList(4000, 4001);
-    loadBalancer.getLbResponseObserver().onNext(buildLbResponse(serverList));
-    verify(mockTransportManager).updateRetainedTransports(eq(buildRetainedAddressSet(serverList)));
+  @Test
+  public void loadReporting() {
+    Metadata headers = new Metadata();
+    PickSubchannelArgs args = mock(PickSubchannelArgs.class);
+    when(args.getHeaders()).thenReturn(headers);
+
+    long loadReportIntervalMillis = 1983;
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
+
+    // Fallback timer is started as soon as address is resolved.
+    assertEquals(1, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
+
+    assertEquals(1, fakeOobChannels.size());
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+    InOrder inOrder = inOrder(lbRequestObserver);
+    InOrder helperInOrder = inOrder(helper, subchannelPool);
+
+    inOrder.verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    // Simulate receiving LB response
+    assertEquals(0, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    lbResponseObserver.onNext(buildInitialResponse(loadReportIntervalMillis));
+
+    // Load reporting task is scheduled
+    assertEquals(1, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    assertEquals(0, fakeClock.runDueTasks());
+
+    List<ServerEntry> backends = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("token0001"),  // drop
+        new ServerEntry("127.0.0.1", 2010, "token0002"),
+        new ServerEntry("token0003"));  // drop
+
+    lbResponseObserver.onNext(buildLbResponse(backends));
+
+    assertEquals(2, mockSubchannels.size());
+    Subchannel subchannel1 = mockSubchannels.poll();
+    Subchannel subchannel2 = mockSubchannels.poll();
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(CONNECTING));
+    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(CONNECTING));
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(READY));
+
+    helperInOrder.verify(helper, atLeast(1))
+        .updateBalancingState(eq(READY), pickerCaptor.capture());
+    RoundRobinPicker picker = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker.dropList).containsExactly(
+        null,
+        new DropEntry(getLoadRecorder(), "token0001"),
+        null,
+        new DropEntry(getLoadRecorder(), "token0003")).inOrder();
+    assertThat(picker.pickList).containsExactly(
+        new BackendEntry(subchannel1, getLoadRecorder(), "token0001"),
+        new BackendEntry(subchannel2, getLoadRecorder(), "token0002")).inOrder();
+
+    // Report, no data
+    assertNextReport(
+        inOrder, lbRequestObserver, loadReportIntervalMillis,
+        ClientStats.newBuilder().build());
+
+    PickResult pick1 = picker.pickSubchannel(args);
+    assertSame(subchannel1, pick1.getSubchannel());
+    assertSame(getLoadRecorder(), pick1.getStreamTracerFactory());
+
+    // Merely the pick will not be recorded as upstart.
+    assertNextReport(
+        inOrder, lbRequestObserver, loadReportIntervalMillis,
+        ClientStats.newBuilder().build());
+
+    ClientStreamTracer tracer1 =
+        pick1.getStreamTracerFactory().newClientStreamTracer(STREAM_INFO, new Metadata());
+    tracer1.streamCreated(Attributes.EMPTY, new Metadata());
+
+    PickResult pick2 = picker.pickSubchannel(args);
+    assertNull(pick2.getSubchannel());
+    assertSame(DROP_PICK_RESULT, pick2);
+
+    // Report includes upstart of pick1 and the drop of pick2
+    assertNextReport(
+        inOrder, lbRequestObserver, loadReportIntervalMillis,
+        ClientStats.newBuilder()
+            .setNumCallsStarted(2)
+            .setNumCallsFinished(1)  // pick2
+            .addCallsFinishedWithDrop(
+                ClientStatsPerToken.newBuilder()
+                    .setLoadBalanceToken("token0001")
+                    .setNumCalls(1)          // pick2
+                    .build())
+            .build());
+
+    PickResult pick3 = picker.pickSubchannel(args);
+    assertSame(subchannel2, pick3.getSubchannel());
+    assertSame(getLoadRecorder(), pick3.getStreamTracerFactory());
+    ClientStreamTracer tracer3 =
+        pick3.getStreamTracerFactory().newClientStreamTracer(STREAM_INFO, new Metadata());
+    tracer3.streamCreated(Attributes.EMPTY, new Metadata());
+
+    // pick3 has sent out headers
+    tracer3.outboundHeaders();
+
+    // 3rd report includes pick3's upstart
+    assertNextReport(
+        inOrder, lbRequestObserver, loadReportIntervalMillis,
+        ClientStats.newBuilder()
+            .setNumCallsStarted(1)
+            .build());
+
+    PickResult pick4 = picker.pickSubchannel(args);
+    assertNull(pick4.getSubchannel());
+    assertSame(DROP_PICK_RESULT, pick4);
+
+    // pick1 ended without sending anything
+    tracer1.streamClosed(Status.CANCELLED);
+
+    // 4th report includes end of pick1 and drop of pick4
+    assertNextReport(
+        inOrder, lbRequestObserver, loadReportIntervalMillis,
+        ClientStats.newBuilder()
+            .setNumCallsStarted(1)  // pick4
+            .setNumCallsFinished(2)
+            .setNumCallsFinishedWithClientFailedToSend(1)   // pick1
+            .addCallsFinishedWithDrop(
+                ClientStatsPerToken.newBuilder()
+                    .setLoadBalanceToken("token0003")
+                    .setNumCalls(1)   // pick4
+                    .build())
+            .build());
+
+    PickResult pick5 = picker.pickSubchannel(args);
+    assertSame(subchannel1, pick1.getSubchannel());
+    assertSame(getLoadRecorder(), pick5.getStreamTracerFactory());
+    ClientStreamTracer tracer5 =
+        pick5.getStreamTracerFactory().newClientStreamTracer(STREAM_INFO, new Metadata());
+    tracer5.streamCreated(Attributes.EMPTY, new Metadata());
+
+    // pick3 ended without receiving response headers
+    tracer3.streamClosed(Status.DEADLINE_EXCEEDED);
+
+    // pick5 sent and received headers
+    tracer5.outboundHeaders();
+    tracer5.inboundHeaders();
+
+    // 5th report includes pick3's end and pick5's upstart
+    assertNextReport(
+        inOrder, lbRequestObserver, loadReportIntervalMillis,
+        ClientStats.newBuilder()
+            .setNumCallsStarted(1)  // pick5
+            .setNumCallsFinished(1)  // pick3
+            .build());
+
+    // pick5 ends
+    tracer5.streamClosed(Status.OK);
+
+    // 6th report includes pick5's end
+    assertNextReport(
+        inOrder, lbRequestObserver, loadReportIntervalMillis,
+        ClientStats.newBuilder()
+            .setNumCallsFinished(1)
+            .setNumCallsFinishedKnownReceived(1)
+            .build());
+
+    assertEquals(1, fakeClock.numPendingTasks());
+    // Balancer closes the stream, scheduled reporting task cancelled
+    lbResponseObserver.onError(Status.UNAVAILABLE.asException());
+    assertEquals(0, fakeClock.numPendingTasks());
+
+    // New stream created
+    verify(mockLbService, times(2)).balanceLoad(lbResponseObserverCaptor.capture());
+    lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    lbRequestObserver = lbRequestObservers.poll();
+    inOrder = inOrder(lbRequestObserver);
+
+    inOrder.verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    // Load reporting is also requested
+    lbResponseObserver.onNext(buildInitialResponse(loadReportIntervalMillis));
+
+    // No picker created because balancer is still using the results from the last stream
+    helperInOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+
+    // Make a new pick on that picker.  It will not show up on the report of the new stream, because
+    // that picker is associated with the previous stream.
+    PickResult pick6 = picker.pickSubchannel(args);
+    assertNull(pick6.getSubchannel());
+    assertSame(DROP_PICK_RESULT, pick6);
+    assertNextReport(
+        inOrder, lbRequestObserver, loadReportIntervalMillis,
+        ClientStats.newBuilder().build());
+
+    // New stream got the list update
+    lbResponseObserver.onNext(buildLbResponse(backends));
+
+    // Same backends, thus no new subchannels
+    helperInOrder.verify(subchannelPool, never()).takeOrCreateSubchannel(
+        any(EquivalentAddressGroup.class), any(Attributes.class));
+    // But the new RoundRobinEntries have a new loadRecorder, thus considered different from
+    // the previous list, thus a new picker is created
+    helperInOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    picker = (RoundRobinPicker) pickerCaptor.getValue();
+
+    PickResult pick1p = picker.pickSubchannel(args);
+    assertSame(subchannel1, pick1p.getSubchannel());
+    assertSame(getLoadRecorder(), pick1p.getStreamTracerFactory());
+    pick1p.getStreamTracerFactory().newClientStreamTracer(STREAM_INFO, new Metadata());
+
+    // The pick from the new stream will be included in the report
+    assertNextReport(
+        inOrder, lbRequestObserver, loadReportIntervalMillis,
+        ClientStats.newBuilder()
+            .setNumCallsStarted(1)
+            .build());
+
+    verify(args, atLeast(0)).getHeaders();
+    verifyNoMoreInteractions(args);
+  }
 
-    // The server list is in effect
-    assertEquals(buildRoundRobinList(serverList), loadBalancer.getRoundRobinServerList().getList());
+  @Test
+  public void abundantInitialResponse() {
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
+    assertEquals(1, fakeOobChannels.size());
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+
+    // Simulate LB initial response
+    assertEquals(0, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    lbResponseObserver.onNext(buildInitialResponse(1983));
+
+    // Load reporting task is scheduled
+    assertEquals(1, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    FakeClock.ScheduledTask scheduledTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    assertEquals(1983, scheduledTask.getDelay(TimeUnit.MILLISECONDS));
+
+    logs.clear();
+    // Simulate an abundant LB initial response, with a different report interval
+    lbResponseObserver.onNext(buildInitialResponse(9097));
+
+    // This incident is logged
+    assertThat(logs).containsExactly(
+            "DEBUG: [grpclb-<api.google.com>] Got an LB response: " + buildInitialResponse(9097),
+            "WARNING: [grpclb-<api.google.com>] "
+                + "Ignoring unexpected response type: INITIAL_RESPONSE")
+        .inOrder();
+
+    // It doesn't affect load-reporting at all
+    assertThat(fakeClock.getPendingTasks(LOAD_REPORTING_TASK_FILTER))
+        .containsExactly(scheduledTask);
+    assertEquals(1983, scheduledTask.getDelay(TimeUnit.MILLISECONDS));
+  }
 
-    // Simulate LB server responds another server list
-    serverList = createResolvedServerInfoList(4002, 4003);
-    loadBalancer.getLbResponseObserver().onNext(buildLbResponse(serverList));
-    verify(mockTransportManager).updateRetainedTransports(eq(buildRetainedAddressSet(serverList)));
+  @SuppressWarnings("unchecked")
+  @Test
+  public void raceBetweenHandleAddressesAndLbStreamClosure() {
+    InOrder inOrder = inOrder(mockLbService, backoffPolicyProvider, backoffPolicy1);
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(),
+        createResolvedBalancerAddresses(1));
+    assertEquals(1, fakeOobChannels.size());
+    inOrder.verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    // Close lbStream
+    lbResponseObserver.onCompleted();
+    inOrder.verify(backoffPolicyProvider).get();
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+    // Retry task scheduled
+    assertEquals(1, fakeClock.numPendingTasks(LB_RPC_RETRY_TASK_FILTER));
+    FakeClock.ScheduledTask retryTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(LB_RPC_RETRY_TASK_FILTER));
+    assertEquals(10L, retryTask.getDelay(TimeUnit.NANOSECONDS));
+
+    // Receive the same Lb address again
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(),
+        createResolvedBalancerAddresses(1));
+    // Retry task cancelled
+    assertEquals(0, fakeClock.numPendingTasks(LB_RPC_RETRY_TASK_FILTER));
+    // Reuse the existing OOB channel
+    assertEquals(1, fakeOobChannels.size());
+    // Start a new LoadBalance RPC
+    inOrder.verify(mockLbService).balanceLoad(any(StreamObserver.class));
+    assertEquals(1, lbRequestObservers.size());
+    lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    // Simulate a race condition where the task has just started when it's cancelled
+    retryTask.command.run();
+    inOrder.verifyNoMoreInteractions();
+  }
 
-    // The new list is in effect
-    assertEquals(buildRoundRobinList(serverList), loadBalancer.getRoundRobinServerList().getList());
+  @Test
+  public void raceBetweenLoadReportingAndLbStreamClosure() {
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
+    assertEquals(1, fakeOobChannels.size());
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+    InOrder inOrder = inOrder(lbRequestObserver);
+
+    inOrder.verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    // Simulate receiving LB response
+    assertEquals(0, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    lbResponseObserver.onNext(buildInitialResponse(1983));
+    // Load reporting task is scheduled
+    assertEquals(1, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    FakeClock.ScheduledTask scheduledTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    assertEquals(1983, scheduledTask.getDelay(TimeUnit.MILLISECONDS));
+
+    // Close lbStream
+    lbResponseObserver.onCompleted();
+
+    // Reporting task cancelled
+    assertEquals(0, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+
+    // Simulate a race condition where the task has just started when its cancelled
+    scheduledTask.command.run();
+
+    // No report sent. No new task scheduled
+    inOrder.verify(lbRequestObserver, never()).onNext(any(LoadBalanceRequest.class));
+    assertEquals(0, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
   }
 
-  @Test public void newLbAddressesResolved() throws Exception {
-    // Simulate the initial set of LB addresses resolved
-    Transport lbTransport = simulateLbAddressResolved(30001);
+  private void assertNextReport(
+      InOrder inOrder, StreamObserver<LoadBalanceRequest> lbRequestObserver,
+      long loadReportIntervalMillis, ClientStats expectedReport) {
+    assertEquals(0, fakeClock.forwardTime(loadReportIntervalMillis - 1, TimeUnit.MILLISECONDS));
+    inOrder.verifyNoMoreInteractions();
+    assertEquals(1, fakeClock.forwardTime(1, TimeUnit.MILLISECONDS));
+    assertEquals(1, fakeClock.numPendingTasks());
+    inOrder.verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder()
+            .setClientStats(
+                ClientStats.newBuilder(expectedReport)
+                    .setTimestamp(Timestamps.fromNanos(fakeClock.getTicker().read()))
+                    .build())
+            .build()));
+  }
 
-    EquivalentAddressGroup lbAddress1 = lbAddressGroup;
-    verify(mockTransportManager).updateRetainedTransports(eq(Collections.singleton(lbAddress1)));
-    verify(mockTransportManager).getTransport(eq(lbAddressGroup));
+  @Test
+  public void receiveNoBackendAndBalancerAddress() {
+    deliverResolvedAddresses(
+        Collections.<EquivalentAddressGroup>emptyList(),
+        Collections.<EquivalentAddressGroup>emptyList());
+    verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    RoundRobinPicker picker = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker.dropList).isEmpty();
+    PickSubchannelArgs args = mock(PickSubchannelArgs.class);
+    when(args.getHeaders()).thenReturn(new Metadata());
+    Status error = Iterables.getOnlyElement(picker.pickList).picked(args).getStatus();
+    assertThat(error.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(error.getDescription()).isEqualTo("No backend or balancer addresses found");
+  }
 
-    // An LB request is sent
-    SendLbRequestArgs sentLbRequest = loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS);
-    assertNotNull(sentLbRequest);
-    assertSame(lbTransport, sentLbRequest.transport);
+  @Test
+  public void nameResolutionFailsThenRecover() {
+    Status error = Status.NOT_FOUND.withDescription("www.google.com not found");
+    deliverNameResolutionError(error);
+    verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    assertThat(logs)
+        .containsExactly(
+            "INFO: [grpclb-<api.google.com>] Created",
+            "DEBUG: [grpclb-<api.google.com>] Error: " + error)
+        .inOrder();
+    logs.clear();
+
+    RoundRobinPicker picker = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker.dropList).isEmpty();
+    PickResult result = picker.pickSubchannel(mock(PickSubchannelArgs.class));
+    assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(result.getStatus().getDescription()).isEqualTo(error.getDescription());
+
+    // Recover with a subsequent success
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
+
+    verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+  }
 
-    // Simulate a second set of LB addresses resolved
-    lbTransport = simulateLbAddressResolved(30002);
-    EquivalentAddressGroup lbAddress2 = lbAddressGroup;
-    assertNotEquals(lbAddress1, lbAddress2);
-    verify(mockTransportManager).updateRetainedTransports(eq(Collections.singleton(lbAddress2)));
-    verify(mockTransportManager).getTransport(eq(lbAddressGroup));
+  @Test
+  public void grpclbThenNameResolutionFails() {
+    InOrder inOrder = inOrder(helper, subchannelPool);
+    // Go to GRPCLB first
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
+
+    verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
+    assertEquals(1, fakeOobChannels.size());
+    ManagedChannel oobChannel = fakeOobChannels.poll();
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+
+    // Let name resolution fail before round-robin list is ready
+    Status error = Status.NOT_FOUND.withDescription("www.google.com not found");
+    deliverNameResolutionError(error);
+
+    inOrder.verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    RoundRobinPicker picker = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker.dropList).isEmpty();
+    PickResult result = picker.pickSubchannel(mock(PickSubchannelArgs.class));
+    assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(result.getStatus().getDescription()).isEqualTo(error.getDescription());
+    assertFalse(oobChannel.isShutdown());
+
+    // Simulate receiving LB response
+    List<ServerEntry> backends = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "TOKEN1"),
+        new ServerEntry("127.0.0.1", 2010, "TOKEN2"));
+    lbResponseObserver.onNext(buildInitialResponse());
+    lbResponseObserver.onNext(buildLbResponse(backends));
+
+    inOrder.verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backends.get(0).addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+    inOrder.verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backends.get(1).addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+  }
 
-    // Another LB request is sent
-    sentLbRequest = loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS);
-    assertNotNull(sentLbRequest);
-    assertSame(lbTransport, sentLbRequest.transport);
+  @Test
+  public void grpclbUpdatedAddresses_avoidsReconnect() {
+    List<EquivalentAddressGroup> backendList = createResolvedBackendAddresses(1);
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(backendList, grpclbBalancerList);
+
+    verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
+    ManagedChannel oobChannel = fakeOobChannels.poll();
+    assertEquals(1, lbRequestObservers.size());
+
+    List<EquivalentAddressGroup> backendList2 = createResolvedBackendAddresses(1);
+    List<EquivalentAddressGroup> grpclbBalancerList2 = createResolvedBalancerAddresses(2);
+    deliverResolvedAddresses(backendList2, grpclbBalancerList2);
+    verify(helper).updateOobChannelAddresses(eq(oobChannel), eq(xattr(grpclbBalancerList2)));
+    assertEquals(1, lbRequestObservers.size()); // No additional RPC
+  }
 
-    // Simulate that an identical set of LB addresses is resolved
-    simulateLbAddressResolved(30002);
-    EquivalentAddressGroup lbAddress3 = lbAddressGroup;
-    assertEquals(lbAddress2, lbAddress3);
-    verify(mockTransportManager).getTransport(eq(lbAddressGroup));
 
-    // Only when LB address changes, getTransport is called.
-    verify(mockTransportManager, times(2)).getTransport(any(EquivalentAddressGroup.class));
+  @Test
+  public void grpclbUpdatedAddresses_reconnectOnAuthorityChange() {
+    List<EquivalentAddressGroup> backendList = createResolvedBackendAddresses(1);
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(backendList, grpclbBalancerList);
+
+    verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
+    ManagedChannel oobChannel = fakeOobChannels.poll();
+    assertEquals(1, lbRequestObservers.size());
+
+    final String newAuthority = "some-new-authority";
+    List<EquivalentAddressGroup> backendList2 = createResolvedBackendAddresses(1);
+    List<EquivalentAddressGroup> grpclbBalancerList2 =
+        Collections.singletonList(
+            new EquivalentAddressGroup(
+                new FakeSocketAddress("somethingNew"), lbAttributes(newAuthority)));
+    deliverResolvedAddresses(backendList2, grpclbBalancerList2);
+    verify(helper).updateOobChannelAddresses(eq(oobChannel), eq(xattr(grpclbBalancerList2)));
+    assertEquals(1, lbRequestObservers.size()); // No additional RPC
   }
 
-  @Test public void lbStreamErrorAfterResponse() throws Exception {
-    // Simulate the initial set of LB addresses resolved
-    simulateLbAddressResolved(30001);
+  @Test
+  public void grpclbWorking() {
+    InOrder inOrder = inOrder(helper, subchannelPool);
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
+
+    // Fallback timer is started as soon as the addresses are resolved.
+    assertEquals(1, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
+
+    verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
+    assertEquals(1, fakeOobChannels.size());
+    ManagedChannel oobChannel = fakeOobChannels.poll();
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    // Simulate receiving LB response
+    List<ServerEntry> backends1 = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("127.0.0.1", 2010, "token0002"));
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    logs.clear();
+    lbResponseObserver.onNext(buildInitialResponse());
+    assertThat(logs).containsExactly(
+        "INFO: [grpclb-<api.google.com>] Got an LB initial response: " + buildInitialResponse());
+    logs.clear();
+    lbResponseObserver.onNext(buildLbResponse(backends1));
+
+    inOrder.verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backends1.get(0).addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+    inOrder.verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backends1.get(1).addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+    assertEquals(2, mockSubchannels.size());
+    Subchannel subchannel1 = mockSubchannels.poll();
+    Subchannel subchannel2 = mockSubchannels.poll();
+    verify(subchannel1).requestConnection();
+    verify(subchannel2).requestConnection();
+    assertEquals(
+        new EquivalentAddressGroup(backends1.get(0).addr, LB_BACKEND_ATTRS),
+        subchannel1.getAddresses());
+    assertEquals(
+        new EquivalentAddressGroup(backends1.get(1).addr, LB_BACKEND_ATTRS),
+        subchannel2.getAddresses());
+
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(CONNECTING));
+    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(CONNECTING));
+
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    RoundRobinPicker picker0 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker0.dropList).containsExactly(null, null);
+    assertThat(picker0.pickList).containsExactly(BUFFER_ENTRY);
+    inOrder.verifyNoMoreInteractions();
+
+    assertThat(logs).containsExactly(
+        "DEBUG: [grpclb-<api.google.com>] Got an LB response: " + buildLbResponse(backends1))
+        .inOrder();
+    logs.clear();
+
+    // Let subchannels be connected
+    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    RoundRobinPicker picker1 = (RoundRobinPicker) pickerCaptor.getValue();
+
+    assertThat(picker1.dropList).containsExactly(null, null);
+    assertThat(picker1.pickList).containsExactly(
+        new BackendEntry(subchannel2, getLoadRecorder(), "token0002"));
+
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    RoundRobinPicker picker2 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker2.dropList).containsExactly(null, null);
+    assertThat(picker2.pickList).containsExactly(
+        new BackendEntry(subchannel1, getLoadRecorder(), "token0001"),
+        new BackendEntry(subchannel2, getLoadRecorder(), "token0002"))
+        .inOrder();
+
+    // Disconnected subchannels
+    verify(subchannel1).requestConnection();
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(IDLE));
+    verify(subchannel1, times(2)).requestConnection();
+    inOrder.verify(helper).refreshNameResolution();
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    RoundRobinPicker picker3 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker3.dropList).containsExactly(null, null);
+    assertThat(picker3.pickList).containsExactly(
+        new BackendEntry(subchannel2, getLoadRecorder(), "token0002"));
+
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(CONNECTING));
+    inOrder.verifyNoMoreInteractions();
+
+    // As long as there is at least one READY subchannel, round robin will work.
+    ConnectivityStateInfo errorState1 =
+        ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE.withDescription("error1"));
+    deliverSubchannelState(subchannel1, errorState1);
+    inOrder.verify(helper).refreshNameResolution();
+    inOrder.verifyNoMoreInteractions();
+
+    // If no subchannel is READY, some with error and the others are IDLE, will report CONNECTING
+    verify(subchannel2).requestConnection();
+    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(IDLE));
+    verify(subchannel2, times(2)).requestConnection();
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+
+    RoundRobinPicker picker4 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker4.dropList).containsExactly(null, null);
+    assertThat(picker4.pickList).containsExactly(BUFFER_ENTRY);
+
+    // Update backends, with a drop entry
+    List<ServerEntry> backends2 =
+        Arrays.asList(
+            new ServerEntry("127.0.0.1", 2030, "token0003"),  // New address
+            new ServerEntry("token0003"),  // drop
+            new ServerEntry("127.0.0.1", 2010, "token0004"),  // Existing address with token changed
+            new ServerEntry("127.0.0.1", 2030, "token0005"),  // New address appearing second time
+            new ServerEntry("token0006"));  // drop
+    verify(subchannelPool, never())
+        .returnSubchannel(same(subchannel1), any(ConnectivityStateInfo.class));
+
+    lbResponseObserver.onNext(buildLbResponse(backends2));
+    assertThat(logs).containsExactly(
+        "DEBUG: [grpclb-<api.google.com>] Got an LB response: " + buildLbResponse(backends2))
+        .inOrder();
+    logs.clear();
+
+    // not in backends2, closed
+    verify(subchannelPool).returnSubchannel(same(subchannel1), same(errorState1));
+    // backends2[2], will be kept
+    verify(subchannelPool, never())
+        .returnSubchannel(same(subchannel2), any(ConnectivityStateInfo.class));
+
+    inOrder.verify(subchannelPool, never()).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backends2.get(2).addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+    inOrder.verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backends2.get(0).addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+
+    ConnectivityStateInfo errorOnCachedSubchannel1 =
+        ConnectivityStateInfo.forTransientFailure(
+            Status.UNAVAILABLE.withDescription("You can get this error even if you are cached"));
+    deliverSubchannelState(subchannel1, errorOnCachedSubchannel1);
+
+    assertEquals(1, mockSubchannels.size());
+    Subchannel subchannel3 = mockSubchannels.poll();
+    verify(subchannel3).requestConnection();
+    assertEquals(
+        new EquivalentAddressGroup(backends2.get(0).addr, LB_BACKEND_ATTRS),
+        subchannel3.getAddresses());
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    RoundRobinPicker picker7 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker7.dropList).containsExactly(
+        null,
+        new DropEntry(getLoadRecorder(), "token0003"),
+        null,
+        null,
+        new DropEntry(getLoadRecorder(), "token0006")).inOrder();
+    assertThat(picker7.pickList).containsExactly(BUFFER_ENTRY);
+
+    // State updates on obsolete subchannel1 will only be passed to the pool
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(
+        subchannel1, ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(SHUTDOWN));
+
+    deliverSubchannelState(subchannel3, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    RoundRobinPicker picker8 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker8.dropList).containsExactly(
+        null,
+        new DropEntry(getLoadRecorder(), "token0003"),
+        null,
+        null,
+        new DropEntry(getLoadRecorder(), "token0006")).inOrder();
+    // subchannel2 is still IDLE, thus not in the active list
+    assertThat(picker8.pickList).containsExactly(
+        new BackendEntry(subchannel3, getLoadRecorder(), "token0003"),
+        new BackendEntry(subchannel3, getLoadRecorder(), "token0005")).inOrder();
+    // subchannel2 becomes READY and makes it into the list
+    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    RoundRobinPicker picker9 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker9.dropList).containsExactly(
+        null,
+        new DropEntry(getLoadRecorder(), "token0003"),
+        null,
+        null,
+        new DropEntry(getLoadRecorder(), "token0006")).inOrder();
+    assertThat(picker9.pickList).containsExactly(
+        new BackendEntry(subchannel3, getLoadRecorder(), "token0003"),
+        new BackendEntry(subchannel2, getLoadRecorder(), "token0004"),
+        new BackendEntry(subchannel3, getLoadRecorder(), "token0005")).inOrder();
+    verify(subchannelPool, never())
+        .returnSubchannel(same(subchannel3), any(ConnectivityStateInfo.class));
+
+    // Update backends, with no entry
+    lbResponseObserver.onNext(buildLbResponse(Collections.<ServerEntry>emptyList()));
+    verify(subchannelPool)
+        .returnSubchannel(same(subchannel2), eq(ConnectivityStateInfo.forNonError(READY)));
+    verify(subchannelPool)
+        .returnSubchannel(same(subchannel3), eq(ConnectivityStateInfo.forNonError(READY)));
+    inOrder.verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    RoundRobinPicker picker10 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker10.dropList).isEmpty();
+    assertThat(picker10.pickList)
+        .containsExactly(new ErrorEntry(GrpclbState.NO_AVAILABLE_BACKENDS_STATUS));
+
+    assertFalse(oobChannel.isShutdown());
+    assertEquals(0, lbRequestObservers.size());
+    verify(lbRequestObserver, never()).onCompleted();
+    verify(lbRequestObserver, never()).onError(any(Throwable.class));
+
+    // Load reporting was not requested, thus never scheduled
+    assertEquals(0, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+
+    verify(subchannelPool, never()).clear();
+    balancer.shutdown();
+    verify(subchannelPool).clear();
+  }
 
-    // An LB request is sent
-    assertNotNull(loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS));
+  @Test
+  public void roundRobinMode_subchannelStayTransientFailureUntilReady() {
+    InOrder inOrder = inOrder(helper);
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+
+    // Simulate receiving LB response
+    List<ServerEntry> backends1 = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("127.0.0.1", 2010, "token0002"));
+    lbResponseObserver.onNext(buildInitialResponse());
+    lbResponseObserver.onNext(buildLbResponse(backends1));
+    assertEquals(2, mockSubchannels.size());
+    Subchannel subchannel1 = mockSubchannels.poll();
+    Subchannel subchannel2 = mockSubchannels.poll();
+
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(CONNECTING));
+    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(CONNECTING));
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+
+    // Switch all subchannels to TRANSIENT_FAILURE, making the general state TRANSIENT_FAILURE too.
+    Status error = Status.UNAVAILABLE.withDescription("error");
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(helper).refreshNameResolution();
+    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forTransientFailure(error));
+    inOrder.verify(helper).refreshNameResolution();
+    inOrder.verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    assertThat(((RoundRobinPicker) pickerCaptor.getValue()).pickList)
+        .containsExactly(new ErrorEntry(error));
+
+    // Switch subchannel1 to IDLE, then to CONNECTING, which are ignored since the previous
+    // subchannel state is TRANSIENT_FAILURE. General state is unchanged.
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(helper).refreshNameResolution();
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(CONNECTING));
+    inOrder.verifyNoMoreInteractions();
+
+    // Switch subchannel1 to READY, which will affect the general state
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertThat(((RoundRobinPicker) pickerCaptor.getValue()).pickList)
+        .containsExactly(new BackendEntry(subchannel1, getLoadRecorder(), "token0001"));
+    inOrder.verifyNoMoreInteractions();
+  }
 
-    // Simulate LB server responds a server list
-    List<ResolvedServerInfo> serverList = createResolvedServerInfoList(4000, 4001);
-    loadBalancer.getLbResponseObserver().onNext(buildLbResponse(serverList));
-    assertEquals(buildRoundRobinList(serverList), loadBalancer.getRoundRobinServerList().getList());
+  @Test
+  public void grpclbFallback_initialTimeout_serverListReceivedBeforeTimerExpires() {
+    subtestGrpclbFallbackTimeout(false, GrpclbState.FALLBACK_TIMEOUT_MS);
+  }
 
-    // Simulate a stream error
-    loadBalancer.getLbResponseObserver().onError(
-        Status.UNAVAILABLE.withDescription("simulated").asException());
+  @Test
+  public void grpclbFallback_initialTimeout_timerExpires() {
+    subtestGrpclbFallbackTimeout(true, GrpclbState.FALLBACK_TIMEOUT_MS);
+  }
 
-    // Another LB request is sent
-    assertNotNull(loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS));
+  @Test
+  public void grpclbFallback_timeout_serverListReceivedBeforeTimerExpires() {
+    subtestGrpclbFallbackTimeout(false, 12345);
+  }
 
-    // Simulate LB server responds a new list
-    serverList = createResolvedServerInfoList(4002, 4003);
-    loadBalancer.getLbResponseObserver().onNext(buildLbResponse(serverList));
-    assertEquals(buildRoundRobinList(serverList), loadBalancer.getRoundRobinServerList().getList());
+  @Test
+  public void grpclbFallback_timeout_timerExpires() {
+    subtestGrpclbFallbackTimeout(true, 12345);
   }
 
-  @Test public void lbStreamErrorWithoutResponse() throws Exception {
-    // Simulate the initial set of LB addresses resolved
-    Transport lbTransport = simulateLbAddressResolved(30001);
+  // Fallback or not within the period of the initial timeout.
+  private void subtestGrpclbFallbackTimeout(boolean timerExpires, long timeout) {
+    long loadReportIntervalMillis = 1983;
+    InOrder inOrder = inOrder(helper, subchannelPool);
+
+    // Create balancer and backend addresses
+    List<EquivalentAddressGroup> backendList = createResolvedBackendAddresses(2);
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(
+        backendList, grpclbBalancerList, GrpclbConfig.create(Mode.ROUND_ROBIN, null, timeout));
+    inOrder.verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
+
+    // Attempted to connect to balancer
+    assertEquals(1, fakeOobChannels.size());
+    ManagedChannel oobChannel = fakeOobChannels.poll();
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+    lbResponseObserver.onNext(buildInitialResponse(loadReportIntervalMillis));
+    // We don't care if these methods have been run.
+    inOrder.verify(helper, atLeast(0)).getSynchronizationContext();
+    inOrder.verify(helper, atLeast(0)).getScheduledExecutorService();
+
+    inOrder.verifyNoMoreInteractions();
+
+    assertEquals(1, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
+    fakeClock.forwardTime(timeout - 1, TimeUnit.MILLISECONDS);
+    assertEquals(1, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
+
+    //////////////////////////////////
+    // Fallback timer expires (or not)
+    //////////////////////////////////
+    if (timerExpires) {
+      logs.clear();
+      fakeClock.forwardTime(1, TimeUnit.MILLISECONDS);
+
+      assertEquals(0, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
+      assertThat(logs)
+          .containsExactly("INFO: [grpclb-<api.google.com>] Using fallback backends")
+          .inOrder();
+
+      // Fall back to the backends from resolver
+      fallbackTestVerifyUseOfFallbackBackendLists(inOrder, backendList);
+
+      assertFalse(oobChannel.isShutdown());
+      verify(lbRequestObserver, never()).onCompleted();
+    }
 
-    // First pick, will be pending
-    Transport pick = loadBalancer.pickTransport(null);
-    assertSame(interimTransportAsTransport, pick);
+    //////////////////////////////////////////////////////////////////////
+    // Name resolver sends new resolution results without any backend addr
+    //////////////////////////////////////////////////////////////////////
+    grpclbBalancerList = createResolvedBalancerAddresses(2);
+    deliverResolvedAddresses(
+        Collections.<EquivalentAddressGroup>emptyList(),
+        grpclbBalancerList,
+        GrpclbConfig.create(Mode.ROUND_ROBIN, null, timeout));
+
+    // New addresses are updated to the OobChannel
+    inOrder.verify(helper).updateOobChannelAddresses(
+        same(oobChannel), eq(xattr(grpclbBalancerList)));
+
+    if (timerExpires) {
+      // Still in fallback logic, except that the backend list is empty
+      for (Subchannel subchannel : mockSubchannels) {
+        verify(subchannelPool).returnSubchannel(eq(subchannel), any(ConnectivityStateInfo.class));
+      }
+
+      // RPC error status includes message of balancer RPC timeout
+      inOrder.verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+      PickResult result = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
+      assertThat(result.getStatus().getCode())
+          .isEqualTo(Code.UNAVAILABLE);
+      assertThat(result.getStatus().getDescription())
+          .startsWith(GrpclbState.NO_FALLBACK_BACKENDS_STATUS.getDescription());
+      assertThat(result.getStatus().getDescription())
+          .contains(GrpclbState.BALANCER_TIMEOUT_STATUS.getDescription());
+    }
 
-    // An LB request is sent
-    SendLbRequestArgs sentLbRequest = loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS);
-    assertNotNull(sentLbRequest);
-    assertSame(lbTransport, sentLbRequest.transport);
+    ////////////////////////////////////////////////////////////////
+    // Name resolver sends new resolution results with backend addrs
+    ////////////////////////////////////////////////////////////////
+    // prevents the cached subchannel to be used
+    subchannelPool.clear();
+    backendList = createResolvedBackendAddresses(2);
+    grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(
+        backendList, grpclbBalancerList, GrpclbConfig.create(Mode.ROUND_ROBIN, null, timeout));
+
+    // New LB address is updated to the OobChannel
+    inOrder.verify(helper).updateOobChannelAddresses(
+        same(oobChannel), eq(xattr(grpclbBalancerList)));
+
+    if (timerExpires) {
+      // New backend addresses are used for fallback
+      fallbackTestVerifyUseOfFallbackBackendLists(
+          inOrder, Arrays.asList(backendList.get(0), backendList.get(1)));
+    }
 
-    // Simulate that the LB stream fails
-    loadBalancer.getLbResponseObserver().onError(
-        Status.UNAVAILABLE.withDescription("simulated").asException());
+    ////////////////////////////////////////////////
+    // Break the LB stream after the timer expires
+    ////////////////////////////////////////////////
+    if (timerExpires) {
+      Status streamError = Status.UNAVAILABLE.withDescription("OOB stream broken");
+      lbResponseObserver.onError(streamError.asException());
+
+      // The error will NOT propagate to picker because fallback list is in use.
+      inOrder.verify(helper, never())
+          .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+      // A new stream is created
+      verify(mockLbService, times(2)).balanceLoad(lbResponseObserverCaptor.capture());
+      lbResponseObserver = lbResponseObserverCaptor.getValue();
+      assertEquals(1, lbRequestObservers.size());
+      lbRequestObserver = lbRequestObservers.poll();
+      verify(lbRequestObserver).onNext(
+          eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+              InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+              .build()));
+    }
 
-    // The pending pick will fail
-    verifyInterimTransportClosedWithError(Status.Code.UNAVAILABLE, "simulated",
-        "Stream to GRPCLB LoadBalancer had an error");
+    /////////////////////////////////
+    // Balancer returns a server list
+    /////////////////////////////////
+    List<ServerEntry> serverList = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("127.0.0.1", 2010, "token0002"));
+    lbResponseObserver.onNext(buildInitialResponse());
+    lbResponseObserver.onNext(buildLbResponse(serverList));
+
+    // Balancer-provided server list now in effect
+    fallbackTestVerifyUseOfBalancerBackendLists(inOrder, serverList);
+
+    ///////////////////////////////////////////////////////////////
+    // New backend addresses from resolver outside of fallback mode
+    ///////////////////////////////////////////////////////////////
+    backendList = createResolvedBackendAddresses(1);
+    grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(
+        backendList, grpclbBalancerList, GrpclbConfig.create(Mode.ROUND_ROBIN, null, timeout));
+    // Will not affect the round robin list at all
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+
+    // No fallback timeout timer scheduled.
+    assertEquals(0, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
+  }
 
-    // Another LB request is sent
-    sentLbRequest = loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS);
-    assertNotNull(sentLbRequest);
+  @Test
+  public void grpclbFallback_breakLbStreamBeforeFallbackTimerExpires() {
+    long loadReportIntervalMillis = 1983;
+    InOrder inOrder = inOrder(helper, subchannelPool);
+
+    // Create balancer and backend addresses
+    List<EquivalentAddressGroup> backendList = createResolvedBackendAddresses(2);
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(backendList, grpclbBalancerList);
+
+    inOrder.verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
+
+    // Attempted to connect to balancer
+    assertThat(fakeOobChannels).hasSize(1);
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertThat(lbRequestObservers).hasSize(1);
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+    lbResponseObserver.onNext(buildInitialResponse(loadReportIntervalMillis));
+    // We don't care if these methods have been run.
+    inOrder.verify(helper, atLeast(0)).getSynchronizationContext();
+    inOrder.verify(helper, atLeast(0)).getScheduledExecutorService();
+
+    inOrder.verifyNoMoreInteractions();
+
+    assertEquals(1, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
+
+    /////////////////////////////////////////////
+    // Break the LB stream before timer expires
+    /////////////////////////////////////////////
+    Status streamError = Status.UNAVAILABLE.withDescription("OOB stream broken");
+    lbResponseObserver.onError(streamError.asException());
+
+    // Fallback time has been short-circuited
+    assertEquals(0, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
+
+    // Fall back to the backends from resolver
+    fallbackTestVerifyUseOfFallbackBackendLists(
+        inOrder, Arrays.asList(backendList.get(0), backendList.get(1)));
+
+    // A new stream is created
+    verify(mockLbService, times(2)).balanceLoad(lbResponseObserverCaptor.capture());
+    assertThat(lbRequestObservers).hasSize(1);
+    lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    //////////////////////////////////////////////////////////////////////
+    // Name resolver sends new resolution results without any backend addr
+    //////////////////////////////////////////////////////////////////////
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
+
+    // Still in fallback logic, except that the backend list is empty
+    for (Subchannel subchannel : mockSubchannels) {
+      verify(subchannelPool).returnSubchannel(eq(subchannel), any(ConnectivityStateInfo.class));
+    }
 
-    // Round-robin list not available at this point
-    assertNull(loadBalancer.getRoundRobinServerList());
+    // RPC error status includes error of balancer stream
+    inOrder.verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
+    assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(result.getStatus().getDescription())
+        .startsWith(GrpclbState.NO_FALLBACK_BACKENDS_STATUS.getDescription());
+    assertThat(result.getStatus().getDescription()).contains(streamError.getDescription());
   }
 
-  @Test public void lbStreamUnimplemented() throws Exception {
-    // Simulate the initial set of LB addresses resolved
-    Transport lbTransport = simulateLbAddressResolved(30001);
+  @Test
+  public void grpclbFallback_noBalancerAddress() {
+    InOrder inOrder = inOrder(helper, subchannelPool);
+
+    // Create 5 distinct backends
+    List<EquivalentAddressGroup> backends = createResolvedBackendAddresses(5);
+
+    // Name resolver gives the first two backend addresses
+    List<EquivalentAddressGroup> backendList = backends.subList(0, 2);
+    deliverResolvedAddresses(backendList, Collections.<EquivalentAddressGroup>emptyList());
+
+    assertThat(logs).contains("INFO: [grpclb-<api.google.com>] Using fallback backends");
+
+    // Fall back to the backends from resolver
+    fallbackTestVerifyUseOfFallbackBackendLists(inOrder, backendList);
+
+    // No fallback timeout timer scheduled.
+    assertEquals(0, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
+    verify(helper, never())
+        .createOobChannel(ArgumentMatchers.<EquivalentAddressGroup>anyList(), anyString());
+    logs.clear();
+
+    /////////////////////////////////////////////////////////////////////////////////////////
+    // Name resolver sends new resolution results with new backend addr but no balancer addr
+    /////////////////////////////////////////////////////////////////////////////////////////
+    // Name resolver then gives the last three backends
+    backendList = backends.subList(2, 5);
+    deliverResolvedAddresses(backendList, Collections.<EquivalentAddressGroup>emptyList());
+
+    assertThat(logs).contains("INFO: [grpclb-<api.google.com>] Using fallback backends");
+
+    // Shift to use updated backends
+    fallbackTestVerifyUseOfFallbackBackendLists(inOrder, backendList);
+    logs.clear();
+
+    ///////////////////////////////////////////////////////////////////////////////////////
+    // Name resolver sends new resolution results without any backend addr or balancer addr
+    ///////////////////////////////////////////////////////////////////////////////////////
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(),
+        Collections.<EquivalentAddressGroup>emptyList());
+    assertThat(logs).containsExactly(
+        "DEBUG: [grpclb-<api.google.com>] Error: Status{code=UNAVAILABLE, "
+            + "description=No backend or balancer addresses found, cause=null}");
+
+    // Keep using existing fallback addresses without interruption
+    for (Subchannel subchannel : mockSubchannels) {
+      verify(subchannelPool, never())
+          .returnSubchannel(eq(subchannel), any(ConnectivityStateInfo.class));
+    }
+    verify(helper, never())
+        .updateBalancingState(eq(TRANSIENT_FAILURE), any(SubchannelPicker.class));
+  }
 
-    // First pick, will be pending
-    Transport pick = loadBalancer.pickTransport(null);
-    assertSame(interimTransportAsTransport, pick);
+  /**
+   * A test for a situation where we first only get backend addresses resolved and then in a
+   * later name resolution get both backend and load balancer addresses. The first instance
+   * will switch us to using fallback backends and it is important that in the second instance
+   * we do not start a fallback timer as it will fail when it triggers if the fallback backends
+   * are already in use.
+   */
+  @Test
+  public void grpclbFallback_noTimerWhenAlreadyInFallback() {
+    // Initially we only get backend addresses without any LB ones. This should get us to use
+    // fallback backends from the start as we won't be able to even talk to the load balancer.
+    // No fallback timer would be started as we already started to use fallback backends.
+    deliverResolvedAddresses(createResolvedBalancerAddresses(1),
+        Collections.<EquivalentAddressGroup>emptyList());
+    assertEquals(0, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
+
+    // Later a new name resolution call happens and we get both backend and LB addresses. Since we
+    // are already operating with fallback backends a fallback timer should not be started to move
+    // us to fallback mode.
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(),
+        createResolvedBalancerAddresses(1));
+
+    // If a fallback timer is started it will eventually throw an exception when it tries to switch
+    // us to using fallback backends when we already are using them.
+    assertEquals(0, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
+  }
 
-    // An LB request is sent
-    SendLbRequestArgs sentLbRequest = loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS);
-    assertNotNull(sentLbRequest);
-    assertSame(lbTransport, sentLbRequest.transport);
+  @Test
+  public void grpclbFallback_balancerLost() {
+    subtestGrpclbFallbackConnectionLost(true, false);
+  }
 
-    // Simulate that the LB stream fails with UNIMPLEMENTED
-    loadBalancer.getLbResponseObserver().onError(Status.UNIMPLEMENTED.asException());
+  @Test
+  public void grpclbFallback_subchannelsLost() {
+    subtestGrpclbFallbackConnectionLost(false, true);
+  }
 
-    // The pending pick will succeed with lbTransport
-    verify(interimTransport).closeWithRealTransports(transportSupplierCaptor.capture());
-    assertSame(lbTransport, transportSupplierCaptor.getValue().get());
+  @Test
+  public void grpclbFallback_allLost() {
+    subtestGrpclbFallbackConnectionLost(true, true);
+  }
 
-    // Subsequent picks will also get lbTransport
-    pick = loadBalancer.pickTransport(null);
-    assertSame(lbTransport, pick);
+  // Fallback outside of the initial timeout, where all connections are lost.
+  private void subtestGrpclbFallbackConnectionLost(
+      boolean balancerBroken, boolean allSubchannelsBroken) {
+    long loadReportIntervalMillis = 1983;
+    InOrder inOrder = inOrder(helper, mockLbService, subchannelPool);
+
+    // Create balancer and backend addresses
+    List<EquivalentAddressGroup> backendList = createResolvedBackendAddresses(2);
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(backendList, grpclbBalancerList);
+
+    inOrder.verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
+
+    // Attempted to connect to balancer
+    assertEquals(1, fakeOobChannels.size());
+    fakeOobChannels.poll();
+    inOrder.verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+    lbResponseObserver.onNext(buildInitialResponse(loadReportIntervalMillis));
+    // We don't care if these methods have been run.
+    inOrder.verify(helper, atLeast(0)).getSynchronizationContext();
+    inOrder.verify(helper, atLeast(0)).getScheduledExecutorService();
+
+    inOrder.verifyNoMoreInteractions();
+
+    // Balancer returns a server list
+    List<ServerEntry> serverList = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("127.0.0.1", 2010, "token0002"));
+    lbResponseObserver.onNext(buildInitialResponse());
+    lbResponseObserver.onNext(buildLbResponse(serverList));
+
+    List<Subchannel> subchannels = fallbackTestVerifyUseOfBalancerBackendLists(inOrder, serverList);
+
+    // Break connections
+    if (balancerBroken) {
+      lbResponseObserver.onError(Status.UNAVAILABLE.asException());
+      // A new stream to LB is created
+      inOrder.verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+      lbResponseObserver = lbResponseObserverCaptor.getValue();
+      assertEquals(1, lbRequestObservers.size());
+      lbRequestObserver = lbRequestObservers.poll();
+      inOrder.verify(helper).refreshNameResolution();
+    }
+    if (allSubchannelsBroken) {
+      for (Subchannel subchannel : subchannels) {
+        // A READY subchannel transits to IDLE when receiving a go-away
+        deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(IDLE));
+        inOrder.verify(helper).refreshNameResolution();
+      }
+    }
 
-    // Round-robin list NOT available at this point
-    assertNull(loadBalancer.getRoundRobinServerList());
+    if (balancerBroken && allSubchannelsBroken) {
+      // Going into fallback
+      subchannels = fallbackTestVerifyUseOfFallbackBackendLists(
+          inOrder, Arrays.asList(backendList.get(0), backendList.get(1)));
+
+      // When in fallback mode, fallback timer should not be scheduled when all backend
+      // connections are lost
+      for (Subchannel subchannel : subchannels) {
+        deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(IDLE));
+        inOrder.verify(helper).refreshNameResolution();
+      }
+
+      // Exit fallback mode or cancel fallback timer when receiving a new server list from balancer
+      List<ServerEntry> serverList2 = Arrays.asList(
+          new ServerEntry("127.0.0.1", 2001, "token0003"),
+          new ServerEntry("127.0.0.1", 2011, "token0004"));
+      lbResponseObserver.onNext(buildInitialResponse());
+      lbResponseObserver.onNext(buildLbResponse(serverList2));
+
+      fallbackTestVerifyUseOfBalancerBackendLists(inOrder, serverList2);
+    }
+    assertEquals(0, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
+
+    // No subchannel to fallback backends should have been created if no fallback happened
+    if (!(balancerBroken && allSubchannelsBroken)) {
+      verify(subchannelPool, never()).takeOrCreateSubchannel(
+          eq(backendList.get(0)), any(Attributes.class));
+      verify(subchannelPool, never()).takeOrCreateSubchannel(
+          eq(backendList.get(1)), any(Attributes.class));
+    }
+  }
 
-    verify(mockTransportManager, times(1)).getTransport(eq(lbAddressGroup));
+  @Test
+  public void grpclbFallback_allLost_failToFallback() {
+    long loadReportIntervalMillis = 1983;
+    InOrder inOrder = inOrder(helper, mockLbService, subchannelPool);
+
+    // Create balancer and (empty) backend addresses
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
+
+    inOrder.verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
+
+    // Attempted to connect to balancer
+    assertEquals(1, fakeOobChannels.size());
+    fakeOobChannels.poll();
+    inOrder.verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+    lbResponseObserver.onNext(buildInitialResponse(loadReportIntervalMillis));
+    // We don't care if these methods have been run.
+    inOrder.verify(helper, atLeast(0)).getSynchronizationContext();
+    inOrder.verify(helper, atLeast(0)).getScheduledExecutorService();
+
+    inOrder.verifyNoMoreInteractions();
+
+    // Balancer returns a server list
+    List<ServerEntry> serverList = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("127.0.0.1", 2010, "token0002"));
+    lbResponseObserver.onNext(buildInitialResponse());
+    lbResponseObserver.onNext(buildLbResponse(serverList));
+
+    List<Subchannel> subchannels = fallbackTestVerifyUseOfBalancerBackendLists(inOrder, serverList);
+
+    // Break connections
+    lbResponseObserver.onError(Status.UNAVAILABLE.asException());
+    // A new stream to LB is created
+    inOrder.verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    assertEquals(1, lbRequestObservers.size());
+
+    // Break all subchannel connections
+    Status error = Status.UNAUTHENTICATED.withDescription("Permission denied");
+    for (Subchannel subchannel : subchannels) {
+      deliverSubchannelState(subchannel, ConnectivityStateInfo.forTransientFailure(error));
+    }
 
-    // Didn't send additional requests other than the initial one
-    assertEquals(0, loadBalancer.sentLbRequests.size());
+    // Recycle all subchannels
+    for (Subchannel subchannel : subchannels) {
+      verify(subchannelPool).returnSubchannel(eq(subchannel), any(ConnectivityStateInfo.class));
+    }
 
-    // Shut down the transport
-    loadBalancer.handleTransportShutdown(lbAddressGroup,
-        Status.UNAVAILABLE.withDescription("simulated"));
+    // RPC error status includes errors of subchannels to balancer-provided backends
+    inOrder.verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
+    assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(result.getStatus().getDescription())
+        .startsWith(GrpclbState.NO_FALLBACK_BACKENDS_STATUS.getDescription());
+    assertThat(result.getStatus().getDescription()).contains(error.getDescription());
+  }
 
-    // Subsequent pick will result in a failing transport because an error has occurred
-    pick = loadBalancer.pickTransport(null);
-    assertSame(failingTransport, pick);
-    verifyCreateFailingTransport(Status.Code.UNAVAILABLE,
-        "simulated", "Transport to LB server closed");
+  private List<Subchannel> fallbackTestVerifyUseOfFallbackBackendLists(
+      InOrder inOrder, List<EquivalentAddressGroup> addrs) {
+    return fallbackTestVerifyUseOfBackendLists(inOrder, addrs, null);
+  }
 
-    // Will get another lbTransport, and send another LB request
-    verify(mockTransportManager, times(2)).getTransport(eq(lbAddressGroup));
-    assertNotNull(loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS));
+  private List<Subchannel> fallbackTestVerifyUseOfBalancerBackendLists(
+      InOrder inOrder, List<ServerEntry> servers) {
+    ArrayList<EquivalentAddressGroup> addrs = new ArrayList<>();
+    ArrayList<String> tokens = new ArrayList<>();
+    for (ServerEntry server : servers) {
+      addrs.add(new EquivalentAddressGroup(server.addr, LB_BACKEND_ATTRS));
+      tokens.add(server.token);
+    }
+    return fallbackTestVerifyUseOfBackendLists(inOrder, addrs, tokens);
   }
 
-  @Test public void lbConnectionClosedAfterResponse() throws Exception {
-    // Simulate the initial set of LB addresses resolved
-    simulateLbAddressResolved(30001);
+  private List<Subchannel> fallbackTestVerifyUseOfBackendLists(
+      InOrder inOrder, List<EquivalentAddressGroup> addrs,
+      @Nullable List<String> tokens) {
+    if (tokens != null) {
+      assertEquals(addrs.size(), tokens.size());
+    }
+    for (EquivalentAddressGroup addr : addrs) {
+      inOrder.verify(subchannelPool).takeOrCreateSubchannel(eq(addr), any(Attributes.class));
+    }
+    RoundRobinPicker picker = (RoundRobinPicker) currentPicker;
+    assertThat(picker.dropList).containsExactlyElementsIn(Collections.nCopies(addrs.size(), null));
+    assertThat(picker.pickList).containsExactly(GrpclbState.BUFFER_ENTRY);
+    assertEquals(addrs.size(), mockSubchannels.size());
+    ArrayList<Subchannel> subchannels = new ArrayList<>(mockSubchannels);
+    mockSubchannels.clear();
+    for (Subchannel subchannel : subchannels) {
+      deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(CONNECTING));
+    }
+    inOrder.verify(helper, atLeast(0))
+        .updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+
+    ArrayList<BackendEntry> pickList = new ArrayList<>();
+    for (int i = 0; i < addrs.size(); i++) {
+      Subchannel subchannel = subchannels.get(i);
+      BackendEntry backend;
+      if (tokens == null) {
+        backend = new BackendEntry(subchannel);
+      } else {
+        backend = new BackendEntry(subchannel, getLoadRecorder(), tokens.get(i));
+      }
+      pickList.add(backend);
+      deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(READY));
+      inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+      picker = (RoundRobinPicker) pickerCaptor.getValue();
+      assertThat(picker.dropList)
+          .containsExactlyElementsIn(Collections.nCopies(addrs.size(), null));
+      assertThat(picker.pickList).containsExactlyElementsIn(pickList);
+      inOrder.verify(helper, never())
+          .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    }
+    return subchannels;
+  }
 
-    // An LB request is sent
-    assertNotNull(loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS));
+  @Test
+  public void grpclbMultipleAuthorities() throws Exception {
+    List<EquivalentAddressGroup> backendList = Collections.singletonList(
+        new EquivalentAddressGroup(new FakeSocketAddress("not-a-lb-address")));
+    List<EquivalentAddressGroup> grpclbBalancerList = Arrays.asList(
+        new EquivalentAddressGroup(
+            new FakeSocketAddress("fake-address-1"),
+            lbAttributes("fake-authority-1")),
+        new EquivalentAddressGroup(
+            new FakeSocketAddress("fake-address-2"),
+            lbAttributes("fake-authority-2")),
+        new EquivalentAddressGroup(
+            new FakeSocketAddress("fake-address-3"),
+            lbAttributes("fake-authority-1").toBuilder()
+                .set(GrpclbConstants.TOKEN_ATTRIBUTE_KEY, "value").build()
+            ));
+    deliverResolvedAddresses(backendList, grpclbBalancerList);
+
+    List<EquivalentAddressGroup> goldenOobEagList =
+        Arrays.asList(
+            new EquivalentAddressGroup(
+                new FakeSocketAddress("fake-address-1"),
+                Attributes.newBuilder()
+                    .set(GrpclbConstants.ATTR_LB_ADDR_AUTHORITY, "fake-authority-1")
+                    .set(EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE, "fake-authority-1")
+                    .build()),
+            new EquivalentAddressGroup(
+                new FakeSocketAddress("fake-address-2"),
+                Attributes.newBuilder()
+                    .set(GrpclbConstants.ATTR_LB_ADDR_AUTHORITY, "fake-authority-2")
+                    .set(EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE, "fake-authority-2")
+                    .build()),
+            new EquivalentAddressGroup(
+                new FakeSocketAddress("fake-address-3"),
+                Attributes.newBuilder()
+                    .set(GrpclbConstants.ATTR_LB_ADDR_AUTHORITY, "fake-authority-1")
+                    .set(GrpclbConstants.TOKEN_ATTRIBUTE_KEY, "value")
+                    .set(EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE, "fake-authority-1")
+                    .build()
+            ));
+
+    verify(helper).createOobChannel(eq(goldenOobEagList),
+        eq("fake-authority-1" + NO_USE_AUTHORITY_SUFFIX));
+  }
 
-    // Simulate LB server responds a server list
-    List<ResolvedServerInfo> serverList = createResolvedServerInfoList(4000, 4001);
-    loadBalancer.getLbResponseObserver().onNext(buildLbResponse(serverList));
-    assertEquals(buildRoundRobinList(serverList), loadBalancer.getRoundRobinServerList().getList());
+  @Test
+  public void grpclbBalancerStreamClosedAndRetried() throws Exception {
+    LoadBalanceRequest expectedInitialRequest =
+        LoadBalanceRequest.newBuilder()
+            .setInitialRequest(
+                InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build();
+    InOrder inOrder =
+        inOrder(mockLbService, backoffPolicyProvider, backoffPolicy1, backoffPolicy2, helper);
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
+
+    assertEquals(1, fakeOobChannels.size());
+    @SuppressWarnings("unused")
+    ManagedChannel oobChannel = fakeOobChannels.poll();
+
+    // First balancer RPC
+    inOrder.verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(eq(expectedInitialRequest));
+    assertEquals(0, fakeClock.numPendingTasks(LB_RPC_RETRY_TASK_FILTER));
+
+    // Balancer closes it immediately (erroneously)
+    lbResponseObserver.onCompleted();
+
+    // Will start backoff sequence 1 (10ns)
+    inOrder.verify(backoffPolicyProvider).get();
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+    assertEquals(1, fakeClock.numPendingTasks(LB_RPC_RETRY_TASK_FILTER));
+    inOrder.verify(helper).refreshNameResolution();
+
+    // Fast-forward to a moment before the retry
+    fakeClock.forwardNanos(9);
+    verifyNoMoreInteractions(mockLbService);
+    // Then time for retry
+    fakeClock.forwardNanos(1);
+    inOrder.verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(eq(expectedInitialRequest));
+    assertEquals(0, fakeClock.numPendingTasks(LB_RPC_RETRY_TASK_FILTER));
+
+    // Balancer closes it with an error.
+    lbResponseObserver.onError(Status.UNAVAILABLE.asException());
+    // Will continue the backoff sequence 1 (100ns)
+    verifyNoMoreInteractions(backoffPolicyProvider);
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+    assertEquals(1, fakeClock.numPendingTasks(LB_RPC_RETRY_TASK_FILTER));
+    inOrder.verify(helper).refreshNameResolution();
+
+    // Fast-forward to a moment before the retry
+    fakeClock.forwardNanos(100 - 1);
+    verifyNoMoreInteractions(mockLbService);
+    // Then time for retry
+    fakeClock.forwardNanos(1);
+    inOrder.verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(eq(expectedInitialRequest));
+    assertEquals(0, fakeClock.numPendingTasks(LB_RPC_RETRY_TASK_FILTER));
+
+    // Balancer sends initial response.
+    lbResponseObserver.onNext(buildInitialResponse());
+
+    // Then breaks the RPC
+    lbResponseObserver.onError(Status.UNAVAILABLE.asException());
+
+    // Will reset the retry sequence and retry immediately, because balancer has responded.
+    inOrder.verify(backoffPolicyProvider).get();
+    inOrder.verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(eq(expectedInitialRequest));
+    inOrder.verify(helper).refreshNameResolution();
+
+    // Fail the retry after spending 4ns
+    fakeClock.forwardNanos(4);
+    lbResponseObserver.onError(Status.UNAVAILABLE.asException());
+
+    // Will be on the first retry (10ns) of backoff sequence 2.
+    inOrder.verify(backoffPolicy2).nextBackoffNanos();
+    assertEquals(1, fakeClock.numPendingTasks(LB_RPC_RETRY_TASK_FILTER));
+    inOrder.verify(helper).refreshNameResolution();
+
+    // Fast-forward to a moment before the retry, the time spent in the last try is deducted.
+    fakeClock.forwardNanos(10 - 4 - 1);
+    verifyNoMoreInteractions(mockLbService);
+    // Then time for retry
+    fakeClock.forwardNanos(1);
+    inOrder.verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    assertEquals(1, lbRequestObservers.size());
+    lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(eq(expectedInitialRequest));
+    assertEquals(0, fakeClock.numPendingTasks(LB_RPC_RETRY_TASK_FILTER));
+
+    // Wrapping up
+    verify(backoffPolicyProvider, times(2)).get();
+    verify(backoffPolicy1, times(2)).nextBackoffNanos();
+    verify(backoffPolicy2, times(1)).nextBackoffNanos();
+    verify(helper, times(4)).refreshNameResolution();
+  }
 
-    // Simulate transport closes
-    loadBalancer.handleTransportShutdown(lbAddressGroup, Status.UNAVAILABLE);
+  @Test
+  public void grpclbWorking_pickFirstMode() throws Exception {
+    InOrder inOrder = inOrder(helper);
+
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+
+    deliverResolvedAddresses(
+        Collections.<EquivalentAddressGroup>emptyList(),
+        grpclbBalancerList,
+        GrpclbConfig.create(Mode.PICK_FIRST));
+
+    assertEquals(1, fakeOobChannels.size());
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    // Simulate receiving LB response
+    List<ServerEntry> backends1 = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("127.0.0.1", 2010, "token0002"));
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    lbResponseObserver.onNext(buildInitialResponse());
+    lbResponseObserver.onNext(buildLbResponse(backends1));
+
+    // With delegation, the child pick_first creates the subchannel
+    inOrder.verify(helper).createSubchannel(createSubchannelArgsCaptor.capture());
+    CreateSubchannelArgs createSubchannelArgs = createSubchannelArgsCaptor.getValue();
+    assertThat(createSubchannelArgs.getAddresses())
+        .containsExactly(
+            new EquivalentAddressGroup(backends1.get(0).addr, eagAttrsWithToken("token0001")),
+            new EquivalentAddressGroup(backends1.get(1).addr, eagAttrsWithToken("token0002")));
+
+    // Child pick_first eagerly connects, so we start in CONNECTING
+    inOrder.verify(helper, atLeast(1)).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    RoundRobinPicker picker0 = (RoundRobinPicker) pickerCaptor.getValue();
+    // Only one subchannel is created by the child LB
+    assertThat(mockSubchannels).hasSize(1);
+    Subchannel subchannel = mockSubchannels.poll();
+    assertThat(picker0.dropList).containsExactly(null, null);
+    assertThat(picker0.pickList).hasSize(1);
+    assertThat(picker0.pickList.get(0)).isInstanceOf(ChildLbPickerEntry.class);
+
+    // Child pick_first eagerly calls requestConnection()
+    verify(subchannel).requestConnection();
+
+    // TRANSIENT_FAILURE
+    Status error = Status.UNAVAILABLE.withDescription("Simulated connection error");
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forTransientFailure(error));
+    // The child LB will notify our helper, which updates grpclb state
+    inOrder.verify(helper, atLeast(1))
+        .updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    RoundRobinPicker picker1 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker1.dropList).containsExactly(null, null);
+    ChildLbPickerEntry failureEntry = (ChildLbPickerEntry) picker1.pickList.get(0);
+    PickResult failureResult =
+        failureEntry.getChildPicker().pickSubchannel(mock(PickSubchannelArgs.class));
+    assertThat(failureResult.getStatus()).isEqualTo(error);
+
+    // READY
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper, atLeast(1)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    RoundRobinPicker picker2 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker2.dropList).containsExactly(null, null);
+    ChildLbPickerEntry readyEntry = (ChildLbPickerEntry) picker2.pickList.get(0);
+    PickResult readyResult =
+        readyEntry.getChildPicker().pickSubchannel(mock(PickSubchannelArgs.class));
+    assertThat(readyResult.getSubchannel()).isEqualTo(subchannel);
+
+    // New server list with drops
+    List<ServerEntry> backends2 = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("token0003"),  // drop
+        new ServerEntry("127.0.0.1", 2020, "token0004"));
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    lbResponseObserver.onNext(buildLbResponse(backends2));
+
+    // Verify child LB is updated with new addresses, NOT recreated
+    inOrder.verify(helper, never()).createSubchannel(any(CreateSubchannelArgs.class));
+    verify(helper, times(1)).createSubchannel(any(CreateSubchannelArgs.class));
+    assertThat(mockSubchannels).isEmpty();
+
+    // The child LB policy internally calls updateAddresses on the subchannel
+    verify(subchannel).updateAddresses(
+        eq(Arrays.asList(
+            new EquivalentAddressGroup(backends2.get(0).addr, eagAttrsWithToken("token0001")),
+            new EquivalentAddressGroup(backends2.get(2).addr,
+                eagAttrsWithToken("token0004")))));
+    inOrder.verify(helper, atLeast(1)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    RoundRobinPicker picker3 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker3.dropList).containsExactly(
+        null, new DropEntry(getLoadRecorder(), "token0003"), null);
+    ChildLbPickerEntry updatedEntry = (ChildLbPickerEntry) picker3.pickList.get(0);
+    PickResult updatedResult =
+        updatedEntry.getChildPicker().pickSubchannel(mock(PickSubchannelArgs.class));
+    assertThat(updatedResult.getSubchannel()).isEqualTo(subchannel);
+
+    // Subchannel goes IDLE, grpclb state should follow
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    RoundRobinPicker picker4 = (RoundRobinPicker) pickerCaptor.getValue();
+
+    // No new connection request should have happened yet (beyond the first eager one)
+    verify(subchannel, times(1)).requestConnection();
+    PickSubchannelArgs args = mock(PickSubchannelArgs.class);
+    PickResult pick = picker4.pickSubchannel(args);
+    // Child pick_first picker returns withNoResult() when IDLE and requests connection
+    assertThat(pick.getSubchannel()).isNull();
+    verify(subchannel, times(2)).requestConnection();
+    balancer.requestConnection();
+    verify(subchannel, times(3)).requestConnection();
+
+    // PICK_FIRST doesn't use subchannelPool
+    verify(subchannelPool, never())
+        .takeOrCreateSubchannel(any(EquivalentAddressGroup.class), any(Attributes.class));
+    verify(subchannelPool, never())
+        .returnSubchannel(any(Subchannel.class), any(ConnectivityStateInfo.class));
+  }
 
-    // Will get another transport
-    verify(mockTransportManager, times(2)).getTransport(eq(lbAddressGroup));
+  @Test
+  public void grpclbWorking_pickFirstMode_lbSendsEmptyAddress() throws Exception {
+    InOrder inOrder = inOrder(helper);
+
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(
+        Collections.<EquivalentAddressGroup>emptyList(),
+        grpclbBalancerList,
+        GrpclbConfig.create(Mode.PICK_FIRST));
+
+    assertEquals(1, fakeOobChannels.size());
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    // Simulate receiving LB response
+    List<ServerEntry> backends1 = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("127.0.0.1", 2010, "token0002"));
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    lbResponseObserver.onNext(buildInitialResponse());
+    lbResponseObserver.onNext(buildLbResponse(backends1));
+
+    // The child pick_first creates the first subchannel
+    inOrder.verify(helper).createSubchannel(createSubchannelArgsCaptor.capture());
+    CreateSubchannelArgs createSubchannelArgs = createSubchannelArgsCaptor.getValue();
+    assertThat(createSubchannelArgs.getAddresses())
+        .containsExactly(
+            new EquivalentAddressGroup(backends1.get(0).addr, eagAttrsWithToken("token0001")),
+            new EquivalentAddressGroup(backends1.get(1).addr, eagAttrsWithToken("token0002")));
+
+    // Child pick_first eagerly connects, so initial state is CONNECTING
+    inOrder.verify(helper, atLeast(1)).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    RoundRobinPicker picker0 = (RoundRobinPicker) pickerCaptor.getValue();
+    // Verify subchannel creation by child LB
+    assertThat(mockSubchannels).hasSize(1);
+    Subchannel subchannel = mockSubchannels.poll();
+    assertThat(picker0.dropList).containsExactly(null, null);
+    assertThat(picker0.pickList).hasSize(1);
+    assertThat(picker0.pickList.get(0)).isInstanceOf(ChildLbPickerEntry.class);
+
+    // Child pick_first eagerly calls requestConnection()
+    verify(subchannel).requestConnection();
+
+    // READY
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper, atLeast(1)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    RoundRobinPicker pickerReady = (RoundRobinPicker) pickerCaptor.getValue();
+    // Verify the subchannel in the delegated picker
+    ChildLbPickerEntry readyEntry = (ChildLbPickerEntry) pickerReady.pickList.get(0);
+    assertThat(
+        readyEntry.getChildPicker().pickSubchannel(mock(PickSubchannelArgs.class)).getSubchannel())
+        .isEqualTo(subchannel);
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+
+    // Empty addresses from LB - child LB is shutdown
+    lbResponseObserver.onNext(buildLbResponse(Collections.<ServerEntry>emptyList()));
+
+    // Child LB is shutdown (which shuts down its subchannel)
+    // createSubchannel() has ever been called only once
+    inOrder.verify(helper, never()).createSubchannel(any(CreateSubchannelArgs.class));
+    assertThat(mockSubchannels).isEmpty();
+    verify(subchannel).shutdown();
+
+    // RPC error status includes message of no backends provided by balancer
+    inOrder.verify(helper, atLeast(1))
+        .updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    RoundRobinPicker errorPicker = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(errorPicker.pickList)
+        .containsExactly(new ErrorEntry(GrpclbState.NO_AVAILABLE_BACKENDS_STATUS));
+
+    lbResponseObserver.onNext(buildLbResponse(Collections.<ServerEntry>emptyList()));
+
+    // Test recover from new LB response with addresses
+    // New server list with drops
+    List<ServerEntry> backends2 = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("token0003"),  // drop
+        new ServerEntry("127.0.0.1", 2020, "token0004"));
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    lbResponseObserver.onNext(buildLbResponse(backends2));
+
+    // A NEW child LB and NEW subchannel are created upon recovery
+    inOrder.verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
+    assertThat(mockSubchannels).hasSize(1);
+    Subchannel subchannel2 = mockSubchannels.poll();
+    inOrder.verify(helper, atLeast(1)).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+
+    // Subchannel became READY
+    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper, atLeast(1)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    RoundRobinPicker pickerFinal = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(pickerFinal.dropList).containsExactly(
+        null, new DropEntry(getLoadRecorder(), "token0003"), null);
+    ChildLbPickerEntry finalEntry = (ChildLbPickerEntry) pickerFinal.pickList.get(0);
+    assertThat(
+        finalEntry.getChildPicker().pickSubchannel(mock(PickSubchannelArgs.class)).getSubchannel())
+        .isEqualTo(subchannel2);
+  }
 
-    // Another LB request is sent
-    assertNotNull(loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS));
+  @Test
+  public void shutdownWithoutSubchannel_roundRobin() throws Exception {
+    subtestShutdownWithoutSubchannel(GrpclbConfig.create(Mode.ROUND_ROBIN));
   }
 
-  @Test public void lbConnectionClosedWithoutResponse() throws Exception {
-    // Simulate the initial set of LB addresses resolved
-    Transport lbTransport = simulateLbAddressResolved(30001);
+  @Test
+  public void shutdownWithoutSubchannel_pickFirst() throws Exception {
+    subtestShutdownWithoutSubchannel(GrpclbConfig.create(Mode.PICK_FIRST));
+  }
 
-    // First pick, will be pending
-    Transport pick = loadBalancer.pickTransport(null);
-    assertSame(interimTransportAsTransport, pick);
+  private void subtestShutdownWithoutSubchannel(GrpclbConfig grpclbConfig) {
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(
+        Collections.<EquivalentAddressGroup>emptyList(),
+        grpclbBalancerList,
+        grpclbConfig);
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> requestObserver = lbRequestObservers.poll();
+
+    verify(requestObserver, never()).onCompleted();
+    balancer.shutdown();
+    ArgumentCaptor<Throwable> throwableCaptor = ArgumentCaptor.forClass(Throwable.class);
+    verify(requestObserver).onError(throwableCaptor.capture());
+    assertThat(Status.fromThrowable(throwableCaptor.getValue()).getCode())
+        .isEqualTo(Code.CANCELLED);
+  }
 
-    // An LB request is sent
-    SendLbRequestArgs sentLbRequest = loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS);
-    assertNotNull(sentLbRequest);
-    assertSame(lbTransport, sentLbRequest.transport);
+  @Test
+  public void pickFirstMode_defaultTimeout_fallback() throws Exception {
+    pickFirstModeFallback(GrpclbState.FALLBACK_TIMEOUT_MS);
+  }
 
-    // Simulate that the transport closed
-    loadBalancer.handleTransportShutdown(
-        lbAddressGroup, Status.UNAVAILABLE.withDescription("simulated"));
+  @Test
+  public void pickFirstMode_serviceConfigTimeout_fallback() throws Exception {
+    pickFirstModeFallback(12345);
+  }
 
-    // The interim transport will close with error
-    verifyInterimTransportClosedWithError(Status.Code.UNAVAILABLE,
-        "simulated", "Transport to LB server closed");
+  private void pickFirstModeFallback(long timeout) throws Exception {
+    InOrder inOrder = inOrder(helper);
+
+    // Name resolver returns balancer and backend addresses
+    List<EquivalentAddressGroup> backendList = createResolvedBackendAddresses(2);
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(
+        backendList, grpclbBalancerList, GrpclbConfig.create(Mode.PICK_FIRST, null, timeout));
+
+    // Attempted to connect to balancer
+    assertEquals(1, fakeOobChannels.size());
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+
+    // Fallback timer expires with no response
+    fakeClock.forwardTime(timeout, TimeUnit.MILLISECONDS);
+
+    // Entering fallback mode - child LB is created for fallback backends
+    inOrder.verify(helper).createSubchannel(createSubchannelArgsCaptor.capture());
+    CreateSubchannelArgs createSubchannelArgs = createSubchannelArgsCaptor.getValue();
+    assertThat(createSubchannelArgs.getAddresses())
+        .containsExactly(backendList.get(0), backendList.get(1));
+
+    assertThat(mockSubchannels).hasSize(1);
+    Subchannel subchannel = mockSubchannels.poll();
+
+    // child pick_first eagerly connects, so initial state is CONNECTING
+    inOrder.verify(helper, atLeast(1)).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    RoundRobinPicker picker0 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker0.pickList.get(0)).isInstanceOf(ChildLbPickerEntry.class);
+
+    // Initial eager connection request
+    verify(subchannel).requestConnection();
+    // READY transition in fallback
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper, atLeast(1)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    RoundRobinPicker picker1 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker1.dropList).containsExactly(null, null);
+    ChildLbPickerEntry readyEntry = (ChildLbPickerEntry) picker1.pickList.get(0);
+    assertThat(
+        readyEntry.getChildPicker().pickSubchannel(mock(PickSubchannelArgs.class)).getSubchannel())
+        .isEqualTo(subchannel);
+
+    // Finally, an LB response arrives, which brings us out of fallback
+    List<ServerEntry> backends1 = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("127.0.0.1", 2010, "token0002"));
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    lbResponseObserver.onNext(buildInitialResponse());
+    lbResponseObserver.onNext(buildLbResponse(backends1));
+
+    // subchannel should be updated, NOT recreated
+    inOrder.verify(helper, never()).createSubchannel(any(CreateSubchannelArgs.class));
+    assertThat(mockSubchannels).isEmpty();
+    // The child LB internally calls updateAddresses on the existing subchannel
+    verify(subchannel).updateAddresses(
+        eq(Arrays.asList(
+            new EquivalentAddressGroup(backends1.get(0).addr, eagAttrsWithToken("token0001")),
+            new EquivalentAddressGroup(backends1.get(1).addr,
+                eagAttrsWithToken("token0002")))));
+    inOrder.verify(helper, atLeast(1)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    RoundRobinPicker picker2 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker2.dropList).containsExactly(null, null);
+
+    // Verify subchannel is still the same via delegated picker
+    ChildLbPickerEntry updatedEntry = (ChildLbPickerEntry) picker2.pickList.get(0);
+    assertThat(
+        updatedEntry.getChildPicker().pickSubchannel(mock(PickSubchannelArgs.class))
+            .getSubchannel())
+        .isEqualTo(subchannel);
+
+    // Subchannel goes IDLE, grpclb follows
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    RoundRobinPicker pickerIdle = (RoundRobinPicker) pickerCaptor.getValue();
+
+    // Verify connection is NOT eagerly requested again yet (still only the 1st request from start)
+    verify(subchannel, times(1)).requestConnection();
+
+    // Picking while IDLE triggers a new connection request
+    PickSubchannelArgs args = mock(PickSubchannelArgs.class);
+    PickResult pick = pickerIdle.pickSubchannel(args);
+    assertThat(pick.getSubchannel()).isNull(); // BUFFERing while IDLE
+    verify(subchannel, times(2)).requestConnection();
+
+    balancer.requestConnection();
+    verify(subchannel, times(3)).requestConnection();
+
+    // PICK_FIRST doesn't use subchannelPool
+    verify(subchannelPool, never())
+        .takeOrCreateSubchannel(any(EquivalentAddressGroup.class), any(Attributes.class));
+    verify(subchannelPool, never())
+        .returnSubchannel(any(Subchannel.class), any(ConnectivityStateInfo.class));
+  }
 
-    // Will try to get another transport
-    verify(mockTransportManager, times(2)).getTransport(eq(lbAddressGroup));
+  @Test
+  public void switchMode() throws Exception {
+    InOrder inOrder = inOrder(helper);
+
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(
+        Collections.<EquivalentAddressGroup>emptyList(),
+        grpclbBalancerList,
+        GrpclbConfig.create(Mode.ROUND_ROBIN));
+
+    assertEquals(1, fakeOobChannels.size());
+    ManagedChannel oobChannel = fakeOobChannels.poll();
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    // Simulate receiving LB response
+    List<ServerEntry> backends1 = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("127.0.0.1", 2010, "token0002"));
+
+    // RR Mode: Ensure no updates before initial response
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    lbResponseObserver.onNext(buildInitialResponse());
+    lbResponseObserver.onNext(buildLbResponse(backends1));
+
+    // ROUND_ROBIN: create one subchannel per server
+    verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backends1.get(0).addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+    verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backends1.get(1).addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+    assertEquals(2, mockSubchannels.size());
+    Subchannel subchannel1 = mockSubchannels.poll();
+    Subchannel subchannel2 = mockSubchannels.poll();
+    verify(subchannelPool, never())
+        .returnSubchannel(any(Subchannel.class), any(ConnectivityStateInfo.class));
+
+    // Switch to PICK_FIRST
+    deliverResolvedAddresses(
+        Collections.<EquivalentAddressGroup>emptyList(),
+        grpclbBalancerList, GrpclbConfig.create(Mode.PICK_FIRST));
+
+    // GrpclbState will be shutdown, and a new one will be created
+    assertThat(oobChannel.isShutdown()).isTrue();
+    verify(subchannelPool)
+        .returnSubchannel(same(subchannel1), eq(ConnectivityStateInfo.forNonError(IDLE)));
+    verify(subchannelPool)
+        .returnSubchannel(same(subchannel2), eq(ConnectivityStateInfo.forNonError(IDLE)));
+
+    // A new LB stream is created
+    assertEquals(1, fakeOobChannels.size());
+    verify(mockLbService, times(2)).balanceLoad(lbResponseObserverCaptor.capture());
+    lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    // Simulate receiving LB response for PICK_FIRST
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    lbResponseObserver.onNext(buildInitialResponse());
+    lbResponseObserver.onNext(buildLbResponse(backends1));
+
+    // PICK_FIRST Subchannel: child LB creates it
+    inOrder.verify(helper).createSubchannel(createSubchannelArgsCaptor.capture());
+    CreateSubchannelArgs createSubchannelArgs = createSubchannelArgsCaptor.getValue();
+    assertThat(createSubchannelArgs.getAddresses())
+        .containsExactly(
+            new EquivalentAddressGroup(backends1.get(0).addr, eagAttrsWithToken("token0001")),
+            new EquivalentAddressGroup(backends1.get(1).addr, eagAttrsWithToken("token0002")));
+
+    // Child pick_first eagerly connects, so initial state is CONNECTING (not IDLE)
+    inOrder.verify(helper, atLeast(1))
+        .updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+  }
 
-    // Round-robin list not available at this point
-    assertNull(loadBalancer.getRoundRobinServerList());
+  private static Attributes eagAttrsWithToken(String token) {
+    return LB_BACKEND_ATTRS.toBuilder().set(GrpclbConstants.TOKEN_ATTRIBUTE_KEY, token).build();
   }
 
-  @Test public void nameResolutionFailed() throws Exception {
-    Transport pick0 = loadBalancer.pickTransport(null);
-    assertSame(interimTransportAsTransport, pick0);
+  @Test
+  public void switchMode_nullLbPolicy() throws Exception {
+    InOrder inOrder = inOrder(helper);
+
+    final List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(
+        Collections.<EquivalentAddressGroup>emptyList(),
+        grpclbBalancerList);
+
+    assertEquals(1, fakeOobChannels.size());
+    ManagedChannel oobChannel = fakeOobChannels.poll();
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    // Simulate receiving LB response (Initial default mode: ROUND_ROBIN)
+    List<ServerEntry> backends1 = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("127.0.0.1", 2010, "token0002"));
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    lbResponseObserver.onNext(buildInitialResponse());
+    lbResponseObserver.onNext(buildLbResponse(backends1));
+
+    // ROUND_ROBIN: create one subchannel per server
+    verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backends1.get(0).addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+    verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backends1.get(1).addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+    assertEquals(2, mockSubchannels.size());
+    Subchannel subchannel1 = mockSubchannels.poll();
+    Subchannel subchannel2 = mockSubchannels.poll();
+    verify(subchannelPool, never())
+        .returnSubchannel(any(Subchannel.class), any(ConnectivityStateInfo.class));
+
+    // Switch to PICK_FIRST
+    deliverResolvedAddresses(
+        Collections.<EquivalentAddressGroup>emptyList(),
+        grpclbBalancerList,
+        GrpclbConfig.create(Mode.PICK_FIRST));
+
+    // GrpclbState will be shutdown, and a new one will be created
+    assertThat(oobChannel.isShutdown()).isTrue();
+    verify(subchannelPool)
+        .returnSubchannel(same(subchannel1), eq(ConnectivityStateInfo.forNonError(IDLE)));
+    verify(subchannelPool)
+        .returnSubchannel(same(subchannel2), eq(ConnectivityStateInfo.forNonError(IDLE)));
+
+    // A new LB stream is created
+    assertEquals(1, fakeOobChannels.size());
+    verify(mockLbService, times(2)).balanceLoad(lbResponseObserverCaptor.capture());
+    lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    // Simulate receiving LB response for PICK_FIRST
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    lbResponseObserver.onNext(buildInitialResponse());
+    lbResponseObserver.onNext(buildLbResponse(backends1));
+
+    // PICK_FIRST Subchannel: with delegation, child LB creates the subchannel
+    inOrder.verify(helper).createSubchannel(createSubchannelArgsCaptor.capture());
+    CreateSubchannelArgs createSubchannelArgs = createSubchannelArgsCaptor.getValue();
+    assertThat(createSubchannelArgs.getAddresses())
+        .containsExactly(
+            new EquivalentAddressGroup(backends1.get(0).addr, eagAttrsWithToken("token0001")),
+            new EquivalentAddressGroup(backends1.get(1).addr, eagAttrsWithToken("token0002")));
+
+    // Child pick_first eagerly connects, so state is CONNECTING (not IDLE)
+    inOrder.verify(helper, atLeast(1))
+        .updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+  }
 
-    loadBalancer.handleNameResolutionError(Status.UNAVAILABLE);
-    verifyInterimTransportClosedWithError(Status.Code.UNAVAILABLE, "Name resolution failed");
-    Transport pick1 = loadBalancer.pickTransport(null);
-    assertSame(failingTransport, pick1);
-    verifyCreateFailingTransport(Status.Code.UNAVAILABLE, "Name resolution failed");
+  @Test
+  public void switchServiceName() throws Exception {
+    InOrder inOrder = inOrder(helper);
+
+    String serviceName = "foo.google.com";
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(1);
+
+    deliverResolvedAddresses(
+        Collections.<EquivalentAddressGroup>emptyList(),
+        grpclbBalancerList,
+        GrpclbConfig.create(Mode.ROUND_ROBIN, serviceName, GrpclbState.FALLBACK_TIMEOUT_MS));
+
+    assertEquals(1, fakeOobChannels.size());
+    ManagedChannel oobChannel = fakeOobChannels.poll();
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(serviceName).build())
+            .build()));
+
+    // Simulate receiving LB response
+    List<ServerEntry> backends1 = Arrays.asList(
+        new ServerEntry("127.0.0.1", 2000, "token0001"),
+        new ServerEntry("127.0.0.1", 2010, "token0002"));
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    lbResponseObserver.onNext(buildInitialResponse());
+    lbResponseObserver.onNext(buildLbResponse(backends1));
+
+    // ROUND_ROBIN: create one subchannel per server
+    verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backends1.get(0).addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+    verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backends1.get(1).addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+    assertEquals(2, mockSubchannels.size());
+    Subchannel subchannel1 = mockSubchannels.poll();
+    Subchannel subchannel2 = mockSubchannels.poll();
+    verify(subchannelPool, never())
+        .returnSubchannel(any(Subchannel.class), any(ConnectivityStateInfo.class));
+
+    // Switch to different serviceName
+    serviceName = "bar.google.com";
+    List<EquivalentAddressGroup> newGrpclbResolutionList = createResolvedBalancerAddresses(1);
+    deliverResolvedAddresses(
+        Collections.<EquivalentAddressGroup>emptyList(),
+        newGrpclbResolutionList,
+        GrpclbConfig.create(Mode.ROUND_ROBIN, serviceName, GrpclbState.FALLBACK_TIMEOUT_MS));
+
+    // GrpclbState will be shutdown, and a new one will be created
+    assertThat(oobChannel.isShutdown()).isTrue();
+    verify(subchannelPool)
+        .returnSubchannel(same(subchannel1), eq(ConnectivityStateInfo.forNonError(IDLE)));
+    verify(subchannelPool)
+        .returnSubchannel(same(subchannel2), eq(ConnectivityStateInfo.forNonError(IDLE)));
+
+    assertEquals(1, fakeOobChannels.size());
+    verify(mockLbService, times(2)).balanceLoad(lbResponseObserverCaptor.capture());
+    assertEquals(1, lbRequestObservers.size());
+    lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder().setInitialRequest(
+            InitialLoadBalanceRequest.newBuilder().setName(serviceName).build())
+            .build()));
   }
 
-  @Test public void shutdown() throws Exception {
-    // Simulate the initial set of LB addresses resolved
-    simulateLbAddressResolved(30001);
+  @Test
+  public void grpclbWorking_lbSendsFallbackMessage() {
+    InOrder inOrder = inOrder(helper, subchannelPool);
+    List<EquivalentAddressGroup> backendList = createResolvedBackendAddresses(2);
+    List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(2);
+    deliverResolvedAddresses(backendList, grpclbBalancerList);
+
+    // Fallback timer is started as soon as the addresses are resolved.
+    assertEquals(1, fakeClock.numPendingTasks(FALLBACK_MODE_TASK_FILTER));
+    verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+        eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
+    assertEquals(1, fakeOobChannels.size());
+    ManagedChannel oobChannel = fakeOobChannels.poll();
+    verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+    StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+    assertEquals(1, lbRequestObservers.size());
+    StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+    verify(lbRequestObserver).onNext(
+        eq(LoadBalanceRequest.newBuilder()
+            .setInitialRequest(
+                InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+            .build()));
+
+    // Simulate receiving LB response
+    ServerEntry backend1a = new ServerEntry("127.0.0.1", 2000, "token0001");
+    ServerEntry backend1b = new ServerEntry("127.0.0.1", 2010, "token0002");
+    List<ServerEntry> backends1 = Arrays.asList(backend1a, backend1b);
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    logs.clear();
+    lbResponseObserver.onNext(buildInitialResponse());
+    assertThat(logs).containsExactly(
+        "INFO: [grpclb-<api.google.com>] Got an LB initial response: " + buildInitialResponse());
+    logs.clear();
+    lbResponseObserver.onNext(buildLbResponse(backends1));
+
+    inOrder.verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backend1a.addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+    inOrder.verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backend1b.addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+
+    assertEquals(2, mockSubchannels.size());
+    Subchannel subchannel1 = mockSubchannels.poll();
+    Subchannel subchannel2 = mockSubchannels.poll();
+
+    verify(subchannel1).requestConnection();
+    verify(subchannel2).requestConnection();
+    assertEquals(
+        new EquivalentAddressGroup(backend1a.addr, LB_BACKEND_ATTRS),
+        subchannel1.getAddresses());
+    assertEquals(
+        new EquivalentAddressGroup(backend1b.addr, LB_BACKEND_ATTRS),
+        subchannel2.getAddresses());
+
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(CONNECTING));
+    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(CONNECTING));
+
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    RoundRobinPicker picker0 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker0.dropList).containsExactly(null, null);
+    assertThat(picker0.pickList).containsExactly(BUFFER_ENTRY);
+    inOrder.verifyNoMoreInteractions();
+
+    assertThat(logs)
+        .containsExactly(
+            "DEBUG: [grpclb-<api.google.com>] Got an LB response: " + buildLbResponse(backends1))
+        .inOrder();
+    logs.clear();
+
+    // Let subchannels be connected
+    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    RoundRobinPicker picker1 = (RoundRobinPicker) pickerCaptor.getValue();
+
+    assertThat(picker1.dropList).containsExactly(null, null);
+    assertThat(picker1.pickList).containsExactly(
+        new BackendEntry(subchannel2, getLoadRecorder(), "token0002"));
+
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    RoundRobinPicker picker2 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker2.dropList).containsExactly(null, null);
+    assertThat(picker2.pickList).containsExactly(
+        new BackendEntry(subchannel1, getLoadRecorder(), "token0001"),
+        new BackendEntry(subchannel2, getLoadRecorder(), "token0002"))
+        .inOrder();
+
+    // Balancer forces entering fallback mode
+    lbResponseObserver.onNext(buildLbFallbackResponse());
+
+    // existing subchannels must be returned immediately to gracefully shutdown.
+    verify(subchannelPool)
+        .returnSubchannel(eq(subchannel1), eq(ConnectivityStateInfo.forNonError(READY)));
+    verify(subchannelPool)
+        .returnSubchannel(eq(subchannel2), eq(ConnectivityStateInfo.forNonError(READY)));
+
+    // verify fallback
+    fallbackTestVerifyUseOfFallbackBackendLists(inOrder, backendList);
+
+    assertFalse(oobChannel.isShutdown());
+    verify(lbRequestObserver, never()).onCompleted();
+
+    //////////////////////////////////////////////////////////////////////
+    // Name resolver sends new resolution results without any backend addr
+    //////////////////////////////////////////////////////////////////////
+    deliverResolvedAddresses(Collections.<EquivalentAddressGroup>emptyList(), grpclbBalancerList);
+
+    // Still in fallback logic, except that the backend list is empty
+    for (Subchannel subchannel : mockSubchannels) {
+      verify(subchannelPool).returnSubchannel(eq(subchannel), any(ConnectivityStateInfo.class));
+    }
 
-    // An LB request is sent
-    assertNotNull(loadBalancer.sentLbRequests.poll(1000, TimeUnit.SECONDS));
+    // RPC error status includes message of fallback requested by balancer
+    inOrder.verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
+    assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(result.getStatus().getDescription())
+        .startsWith(GrpclbState.NO_FALLBACK_BACKENDS_STATUS.getDescription());
+    assertThat(result.getStatus().getDescription())
+        .contains(GrpclbState.BALANCER_REQUESTED_FALLBACK_STATUS.getDescription());
+
+    // exit fall back by providing two new backends
+    ServerEntry backend2a = new ServerEntry("127.0.0.1", 8000, "token1001");
+    ServerEntry backend2b = new ServerEntry("127.0.0.1", 8010, "token1002");
+    List<ServerEntry> backends2 = Arrays.asList(backend2a, backend2b);
+
+    inOrder.verify(helper, never())
+        .updateBalancingState(any(ConnectivityState.class), any(SubchannelPicker.class));
+    logs.clear();
+    lbResponseObserver.onNext(buildLbResponse(backends2));
+
+    inOrder.verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backend2a.addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+    inOrder.verify(subchannelPool).takeOrCreateSubchannel(
+        eq(new EquivalentAddressGroup(backend2b.addr, LB_BACKEND_ATTRS)),
+        any(Attributes.class));
+
+    assertEquals(2, mockSubchannels.size());
+    Subchannel subchannel3 = mockSubchannels.poll();
+    Subchannel subchannel4 = mockSubchannels.poll();
+    verify(subchannel3).requestConnection();
+    verify(subchannel4).requestConnection();
+    assertEquals(
+        new EquivalentAddressGroup(backend2a.addr, LB_BACKEND_ATTRS),
+        subchannel3.getAddresses());
+    assertEquals(
+        new EquivalentAddressGroup(backend2b.addr, LB_BACKEND_ATTRS),
+        subchannel4.getAddresses());
+
+    deliverSubchannelState(subchannel3, ConnectivityStateInfo.forNonError(CONNECTING));
+    deliverSubchannelState(subchannel4, ConnectivityStateInfo.forNonError(CONNECTING));
+
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    RoundRobinPicker picker6 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker6.dropList).containsExactly(null, null);
+    assertThat(picker6.pickList).containsExactly(BUFFER_ENTRY);
+    inOrder.verifyNoMoreInteractions();
+
+    assertThat(logs)
+        .containsExactly(
+            "DEBUG: [grpclb-<api.google.com>] Got an LB response: " + buildLbResponse(backends2))
+        .inOrder();
+    logs.clear();
+
+    // Let new subchannels be connected
+    deliverSubchannelState(subchannel3, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    RoundRobinPicker picker3 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker3.dropList).containsExactly(null, null);
+    assertThat(picker3.pickList).containsExactly(
+        new BackendEntry(subchannel3, getLoadRecorder(), "token1001"));
+
+    deliverSubchannelState(subchannel4, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    RoundRobinPicker picker4 = (RoundRobinPicker) pickerCaptor.getValue();
+    assertThat(picker4.dropList).containsExactly(null, null);
+    assertThat(picker4.pickList).containsExactly(
+        new BackendEntry(subchannel3, getLoadRecorder(), "token1001"),
+        new BackendEntry(subchannel4, getLoadRecorder(), "token1002"))
+        .inOrder();
+  }
 
-    // Simulate LB server responds a server list
-    List<ResolvedServerInfo> serverList = createResolvedServerInfoList(4000, 4001);
-    loadBalancer.getLbResponseObserver().onNext(buildLbResponse(serverList));
-    verify(mockTransportManager).getTransport(eq(lbAddressGroup));
-    assertEquals(buildRoundRobinList(serverList), loadBalancer.getRoundRobinServerList().getList());
+  @Test
+  public void useIndependentRpcContext() {
+    // Simulates making RPCs within the context of an inbound RPC.
+    CancellableContext cancellableContext = Context.current().withCancellation();
+    Context prevContext = cancellableContext.attach();
+    try {
+      List<EquivalentAddressGroup> backendList = createResolvedBackendAddresses(2);
+      List<EquivalentAddressGroup> grpclbBalancerList = createResolvedBalancerAddresses(2);
+      deliverResolvedAddresses(backendList, grpclbBalancerList);
+
+      verify(helper).createOobChannel(eq(xattr(grpclbBalancerList)),
+          eq(lbAuthority(0) + NO_USE_AUTHORITY_SUFFIX));
+      verify(mockLbService).balanceLoad(lbResponseObserverCaptor.capture());
+      StreamObserver<LoadBalanceResponse> lbResponseObserver = lbResponseObserverCaptor.getValue();
+      assertEquals(1, lbRequestObservers.size());
+      StreamObserver<LoadBalanceRequest> lbRequestObserver = lbRequestObservers.poll();
+      verify(lbRequestObserver).onNext(
+          eq(LoadBalanceRequest.newBuilder()
+              .setInitialRequest(
+                  InitialLoadBalanceRequest.newBuilder().setName(SERVICE_AUTHORITY).build())
+              .build()));
+      lbResponseObserver.onNext(buildInitialResponse());
+
+      // The inbound RPC finishes and closes its context. The outbound RPC's control plane RPC
+      // should not be impacted (no retry).
+      cancellableContext.close();
+      assertEquals(0, fakeClock.numPendingTasks(LB_RPC_RETRY_TASK_FILTER));
+      verifyNoMoreInteractions(mockLbService);
+    } finally {
+      cancellableContext.detach(prevContext);
+    }
+  }
 
-    // Shut down the LoadBalancer
-    loadBalancer.shutdown();
+  private void deliverSubchannelState(
+      final Subchannel subchannel, final ConnectivityStateInfo newState) {
+    ((FakeSubchannel) subchannel).updateState(newState);
+  }
 
-    // Simulate a stream error
-    loadBalancer.getLbResponseObserver().onError(Status.CANCELLED.asException());
+  private void deliverNameResolutionError(final Status error) {
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        balancer.handleNameResolutionError(error);
+      }
+    });
+  }
 
-    // Won't send a request
-    assertEquals(0, loadBalancer.sentLbRequests.size());
+  private void deliverResolvedAddresses(
+      final List<EquivalentAddressGroup> backendAddrs,
+      List<EquivalentAddressGroup> balancerAddrs) {
+    deliverResolvedAddresses(backendAddrs, balancerAddrs, GrpclbConfig.create(Mode.ROUND_ROBIN));
+  }
 
-    // Simulate transport closure
-    loadBalancer.handleTransportShutdown(lbAddressGroup, Status.CANCELLED);
+  private void deliverResolvedAddresses(
+      final List<EquivalentAddressGroup> backendAddrs,
+      List<EquivalentAddressGroup> balancerAddrs,
+      final GrpclbConfig grpclbConfig) {
+    final Attributes attrs =
+        Attributes.newBuilder().set(GrpclbConstants.ATTR_LB_ADDRS, balancerAddrs).build();
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        balancer.acceptResolvedAddresses(
+            ResolvedAddresses.newBuilder()
+                .setAddresses(backendAddrs)
+                .setAttributes(attrs)
+                .setLoadBalancingPolicyConfig(grpclbConfig)
+                .build());
+      }
+    });
+  }
 
-    // Won't get a new transport. getTransport() was call once before.
-    verify(mockTransportManager).getTransport(any(EquivalentAddressGroup.class));
+  private GrpclbClientLoadRecorder getLoadRecorder() {
+    return balancer.getGrpclbState().getLoadRecorder();
   }
 
-  /**
-   * Simulates a single LB address is resolved and sets up lbAddressGroup. Returns the transport
-   * to LB.
-   */
-  private Transport simulateLbAddressResolved(int lbPort) {
-    ResolvedServerInfo lbServerInfo = new ResolvedServerInfo(
-        new InetSocketAddress("127.0.0.1", lbPort), Attributes.EMPTY);
-    lbAddressGroup = buildAddressGroup(lbServerInfo);
-    Transport lbTransport = new Transport();
-    when(mockTransportManager.getTransport(eq(lbAddressGroup))).thenReturn(lbTransport);
-    loadBalancer.handleResolvedAddresses(
-        Collections.singletonList(ResolvedServerInfoGroup.builder().add(lbServerInfo).build()),
-        Attributes.EMPTY);
-    verify(mockTransportManager).getTransport(eq(lbAddressGroup));
-    return lbTransport;
+  private static List<EquivalentAddressGroup> createResolvedBackendAddresses(int n) {
+    List<EquivalentAddressGroup> list = new ArrayList<>();
+    for (int i = 0; i < n; i++) {
+      SocketAddress addr = new FakeSocketAddress("fake-address-" + i);
+      list.add(new EquivalentAddressGroup(addr));
+    }
+    return list;
   }
 
-  private HashSet<EquivalentAddressGroup> buildRetainedAddressSet(
-      Collection<ResolvedServerInfo> serverInfos) {
-    HashSet<EquivalentAddressGroup> addrs = new HashSet<EquivalentAddressGroup>();
-    for (ResolvedServerInfo serverInfo : serverInfos) {
-      addrs.add(new EquivalentAddressGroup(serverInfo.getAddress()));
+  private static List<EquivalentAddressGroup> createResolvedBalancerAddresses(int n) {
+    List<EquivalentAddressGroup> list = new ArrayList<>();
+    for (int i = 0; i < n; i++) {
+      SocketAddress addr = new FakeSocketAddress("fake-address-" + i);
+      list.add(new EquivalentAddressGroup(addr, lbAttributes(lbAuthority(i))));
     }
-    addrs.add(lbAddressGroup);
-    return addrs;
+    return list;
   }
 
-  /**
-   * A slightly modified {@link GrpclbLoadBalancerTest} that saves LB requests in a queue instead of
-   * sending them out.
-   */
-  private class TestGrpclbLoadBalancer extends GrpclbLoadBalancer<Transport> {
-    final LinkedBlockingQueue<SendLbRequestArgs> sentLbRequests =
-        new LinkedBlockingQueue<SendLbRequestArgs>();
+  private static String lbAuthority(int unused) {
+    // TODO(ejona): Support varying authorities
+    return "lb.google.com";
+  }
 
-    TestGrpclbLoadBalancer() {
-      super(serviceName, mockTransportManager);
-    }
+  private static Attributes lbAttributes(String authority) {
+    return Attributes.newBuilder()
+        .set(GrpclbConstants.ATTR_LB_ADDR_AUTHORITY, authority)
+        .build();
+  }
 
-    @Override void sendLbRequest(Transport transport, LoadBalanceRequest request) {
-      sentLbRequests.add(new SendLbRequestArgs(transport, request));
-    }
+  private static LoadBalanceResponse buildInitialResponse() {
+    return buildInitialResponse(0);
   }
 
-  private static class SendLbRequestArgs {
-    final Transport transport;
-    final LoadBalanceRequest request;
+  private static LoadBalanceResponse buildInitialResponse(long loadReportIntervalMillis) {
+    return LoadBalanceResponse.newBuilder()
+        .setInitialResponse(
+            InitialLoadBalanceResponse.newBuilder()
+                .setClientStatsReportInterval(Durations.fromMillis(loadReportIntervalMillis)))
+        .build();
+  }
 
-    SendLbRequestArgs(Transport transport, LoadBalanceRequest request) {
-      this.transport = transport;
-      this.request = request;
-    }
+  private static LoadBalanceResponse buildLbFallbackResponse() {
+    return LoadBalanceResponse.newBuilder()
+        .setFallbackResponse(FallbackResponse.newBuilder().build())
+        .build();
   }
 
-  private static LoadBalanceResponse buildLbResponse(List<ResolvedServerInfo> servers) {
+  private static LoadBalanceResponse buildLbResponse(List<ServerEntry> servers) {
     ServerList.Builder serverListBuilder = ServerList.newBuilder();
-    for (ResolvedServerInfo server : servers) {
-      InetSocketAddress addr = (InetSocketAddress) server.getAddress();
-      serverListBuilder.addServers(Server.newBuilder()
-          .setIpAddress(ByteString.copyFrom(addr.getAddress().getAddress()))
-          .setPort(addr.getPort())
-          .build());
+    for (ServerEntry server : servers) {
+      if (server.addr != null) {
+        serverListBuilder.addServers(Server.newBuilder()
+            .setIpAddress(ByteString.copyFrom(server.addr.getAddress().getAddress()))
+            .setPort(server.addr.getPort())
+            .setLoadBalanceToken(server.token)
+            .build());
+      } else {
+        serverListBuilder.addServers(Server.newBuilder()
+            .setDrop(true)
+            .setLoadBalanceToken(server.token)
+            .build());
+      }
     }
     return LoadBalanceResponse.newBuilder()
         .setServerList(serverListBuilder.build())
         .build();
   }
 
-  private static EquivalentAddressGroup buildAddressGroup(ResolvedServerInfo serverInfo) {
-    return new EquivalentAddressGroup(serverInfo.getAddress());
+  private List<EquivalentAddressGroup> xattr(List<EquivalentAddressGroup> lbAddr) {
+    List<EquivalentAddressGroup> oobAddr = new ArrayList<>(lbAddr.size());
+    for (EquivalentAddressGroup lb : lbAddr) {
+      String authority = lb.getAttributes().get(GrpclbConstants.ATTR_LB_ADDR_AUTHORITY);
+      Attributes attrs = lb.getAttributes().toBuilder()
+          .set(EquivalentAddressGroup.ATTR_AUTHORITY_OVERRIDE, authority)
+          .build();
+      oobAddr.add(new EquivalentAddressGroup(lb.getAddresses(), attrs));
+    }
+    return oobAddr;
   }
 
-  private static List<EquivalentAddressGroup> buildRoundRobinList(
-      List<ResolvedServerInfo> serverList) {
-    ArrayList<EquivalentAddressGroup> roundRobinList = new ArrayList<EquivalentAddressGroup>();
-    for (ResolvedServerInfo serverInfo : serverList) {
-      roundRobinList.add(new EquivalentAddressGroup(serverInfo.getAddress()));
+  private static class ServerEntry {
+    final InetSocketAddress addr;
+    final String token;
+
+    ServerEntry(String host, int port, String token) {
+      this.addr = new InetSocketAddress(host, port);
+      this.token = token;
     }
-    return roundRobinList;
-  }
 
-  private static List<ResolvedServerInfo> createResolvedServerInfoList(int ... ports) {
-    List<ResolvedServerInfo> result = new ArrayList<ResolvedServerInfo>(ports.length);
-    for (int port : ports) {
-      InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", port);
-      result.add(new ResolvedServerInfo(inetSocketAddress, Attributes.EMPTY));
+    // Drop entry
+    ServerEntry(String token) {
+      this.addr = null;
+      this.token = token;
     }
-    return result;
   }
 
-  private void verifyInterimTransportClosedWithError(
-      Status.Code statusCode, String ... descriptions) {
-    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
-    verify(interimTransport).closeWithError(statusCaptor.capture());
-    assertError(statusCaptor.getValue(), statusCode, descriptions);
-  }
+  private static class FakeSubchannel extends Subchannel {
+    private final Attributes attributes;
+    private List<EquivalentAddressGroup> eags;
+    private SubchannelStateListener listener;
 
-  private void verifyCreateFailingTransport(
-      Status.Code statusCode, String ... descriptions) {
-    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
-    verify(mockTransportManager).createFailingTransport(statusCaptor.capture());
-    assertError(statusCaptor.getValue(), statusCode, descriptions);
-  }
+    public FakeSubchannel(List<EquivalentAddressGroup> eags, Attributes attributes) {
+      this.eags = Collections.unmodifiableList(eags);
+      this.attributes = attributes;
+    }
 
+    @Override
+    public List<EquivalentAddressGroup> getAllAddresses() {
+      return eags;
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return attributes;
+    }
 
-  private static void assertError(Status s, Status.Code statusCode, String ... descriptions) {
-    assertEquals(statusCode, s.getCode());
-    for (String desc : descriptions) {
-      assertTrue("'" + s.getDescription() + "' contains '" + desc + "'",
-          s.getDescription().contains(desc));
+    @Override
+    public void start(SubchannelStateListener listener) {
+      this.listener = checkNotNull(listener, "listener");
+    }
+
+    @Override
+    public void updateAddresses(List<EquivalentAddressGroup> addrs) {
+      this.eags = Collections.unmodifiableList(addrs);
+    }
+
+    @Override
+    public void shutdown() {
+    }
+
+    @Override
+    public void requestConnection() {
+    }
+
+    public void updateState(ConnectivityStateInfo newState) {
+      listener.onSubchannelState(newState);
     }
   }
 
-  public static class Transport {}
+  private class FakeHelper extends Helper {
+
+    @Override
+    public SynchronizationContext getSynchronizationContext() {
+      return syncContext;
+    }
+
+    @Override
+    public ManagedChannel createOobChannel(List<EquivalentAddressGroup> eag, String authority) {
+      ManagedChannel channel =
+          InProcessChannelBuilder
+              .forName("fakeLb")
+              .directExecutor()
+              .overrideAuthority(authority)
+              .build();
+      fakeOobChannels.add(channel);
+      oobChannelTracker.add(channel);
+      return channel;
+    }
+
+    @Override
+    public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String authority) {
+      return createOobChannel(Collections.singletonList(eag), authority);
+    }
+
+    @Override
+    public Subchannel createSubchannel(CreateSubchannelArgs args) {
+      FakeSubchannel subchannel =
+          mock(
+              FakeSubchannel.class,
+              AdditionalAnswers
+                  .delegatesTo(new FakeSubchannel(args.getAddresses(), args.getAttributes())));
+      mockSubchannels.add(subchannel);
+      unpooledSubchannelTracker.add(subchannel);
+      return subchannel;
+    }
+
+    @Override
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return fakeClock.getScheduledExecutorService();
+    }
+
+    @Override
+    public ChannelLogger getChannelLogger() {
+      return channelLogger;
+    }
+
+    @Override
+    public void updateBalancingState(
+        @Nonnull ConnectivityState newState, @Nonnull SubchannelPicker newPicker) {
+      currentPicker = newPicker;
+    }
+
+    @Override
+    public void refreshNameResolution() {
+    }
+
+    @Override
+    public String getAuthority() {
+      return SERVICE_AUTHORITY;
+    }
+
+    @Override
+    public void updateOobChannelAddresses(ManagedChannel channel, EquivalentAddressGroup eag) {
+    }
+
+    @Override
+    public void updateOobChannelAddresses(ManagedChannel channel,
+        List<EquivalentAddressGroup> eag) {
+    }
+  }
 }
diff --git a/grpclb/src/test/java/io/grpc/grpclb/GrpclbNameResolverTest.java b/grpclb/src/test/java/io/grpc/grpclb/GrpclbNameResolverTest.java
new file mode 100644
index 00000000000..1aa11ecf9af
--- /dev/null
+++ b/grpclb/src/test/java/io/grpc/grpclb/GrpclbNameResolverTest.java
@@ -0,0 +1,344 @@
+/*
+ * 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.grpclb;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.Iterables;
+import io.grpc.Attributes;
+import io.grpc.ChannelLogger;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.NameResolver.ResolutionResult;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.NameResolverRegistry;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.DnsNameResolver.AddressResolver;
+import io.grpc.internal.DnsNameResolver.ResourceResolver;
+import io.grpc.internal.DnsNameResolver.SrvRecord;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.SharedResourceHolder.Resource;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.UnknownHostException;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Executor;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
+
+/** Unit tests for {@link GrpclbNameResolver}. */
+@RunWith(JUnit4.class)
+public class GrpclbNameResolverTest {
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private static final String NAME = "foo.googleapis.com";
+  private static final int DEFAULT_PORT = 887;
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+
+  private final FakeClock fakeClock = new FakeClock();
+  private final FakeExecutorResource fakeExecutorResource = new FakeExecutorResource();
+
+  private final class FakeExecutorResource implements Resource<Executor> {
+
+    @Override
+    public Executor create() {
+      return fakeClock.getScheduledExecutorService();
+    }
+
+    @Override
+    public void close(Executor instance) {}
+  }
+
+  @Captor private ArgumentCaptor<ResolutionResult> resultCaptor;
+  @Mock private ServiceConfigParser serviceConfigParser;
+  @Mock private NameResolver.Listener2 mockListener;
+
+  private GrpclbNameResolver resolver;
+  private String hostName;
+
+  @Before
+  public void setUp() {
+    GrpclbNameResolver.setEnableTxt(true);
+    NameResolver.Args args =
+        NameResolver.Args.newBuilder()
+            .setDefaultPort(DEFAULT_PORT)
+            .setProxyDetector(GrpcUtil.NOOP_PROXY_DETECTOR)
+            .setSynchronizationContext(syncContext)
+            .setServiceConfigParser(serviceConfigParser)
+            .setChannelLogger(mock(ChannelLogger.class))
+            .build();
+    resolver =
+        new GrpclbNameResolver(
+            null, NAME, args, fakeExecutorResource, fakeClock.getStopwatchSupplier().get(),
+            /* isAndroid */false);
+    hostName = resolver.getHost();
+    assertThat(hostName).isEqualTo(NAME);
+  }
+
+  @Test
+  public void provider_isRegistered() {
+    NameResolverRegistry registry = NameResolverRegistry.getDefaultRegistry();
+    assertThat(registry.getProviderForScheme("dns").getClass().getName())
+        .isEqualTo("io.grpc.grpclb.SecretGrpclbNameResolverProvider$Provider");
+  }
+
+  @Test
+  public void resolve_emptyResult() {
+    resolver.setAddressResolver(new AddressResolver() {
+      @Override
+      public List<InetAddress> resolveAddress(String host) throws Exception {
+        return Collections.emptyList();
+      }
+    });
+    resolver.setResourceResolver(new ResourceResolver() {
+      @Override
+      public List<String> resolveTxt(String host) throws Exception {
+        return Collections.emptyList();
+      }
+
+      @Override
+      public List<SrvRecord> resolveSrv(String host) throws Exception {
+        return Collections.emptyList();
+      }
+    });
+
+    resolver.start(mockListener);
+    assertThat(fakeClock.runDueTasks()).isEqualTo(1);
+
+    verify(mockListener).onResult2(resultCaptor.capture());
+    ResolutionResult result = resultCaptor.getValue();
+    assertThat(result.getAddressesOrError().getValue()).isEmpty();
+    assertThat(result.getAttributes()).isEqualTo(Attributes.EMPTY);
+    assertThat(result.getServiceConfig()).isNull();
+  }
+
+  @Test
+  public void resolve_presentResourceResolver() throws Exception {
+    InetAddress backendAddr = InetAddress.getByAddress(new byte[] {127, 0, 0, 0});
+    InetAddress lbAddr = InetAddress.getByAddress(new byte[] {10, 1, 0, 0});
+    int lbPort = 8080;
+    String lbName = "foo.example.com.";  // original name in SRV record
+    SrvRecord srvRecord = new SrvRecord(lbName, 8080);
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    when(mockAddressResolver.resolveAddress(hostName))
+        .thenReturn(Collections.singletonList(backendAddr));
+    when(mockAddressResolver.resolveAddress(lbName))
+        .thenReturn(Collections.singletonList(lbAddr));
+    ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
+    when(mockResourceResolver.resolveTxt(anyString()))
+        .thenReturn(
+            Collections.singletonList(
+                "grpc_config=[{\"clientLanguage\": [\"java\"], \"serviceConfig\": {}}]"));
+    when(mockResourceResolver.resolveSrv(anyString()))
+        .thenReturn(Collections.singletonList(srvRecord));
+    when(serviceConfigParser.parseServiceConfig(ArgumentMatchers.<String, Object>anyMap()))
+        .thenAnswer(new Answer<ConfigOrError>() {
+          @Override
+          public ConfigOrError answer(InvocationOnMock invocation) {
+            Object[] args = invocation.getArguments();
+            return ConfigOrError.fromConfig(args[0]);
+          }
+        });
+
+    resolver.setAddressResolver(mockAddressResolver);
+    resolver.setResourceResolver(mockResourceResolver);
+
+    resolver.start(mockListener);
+    assertThat(fakeClock.runDueTasks()).isEqualTo(1);
+    verify(mockListener).onResult2(resultCaptor.capture());
+    ResolutionResult result = resultCaptor.getValue();
+    InetSocketAddress resolvedBackendAddr =
+        (InetSocketAddress) Iterables.getOnlyElement(
+            Iterables.getOnlyElement(result.getAddressesOrError().getValue()).getAddresses());
+    assertThat(resolvedBackendAddr.getAddress()).isEqualTo(backendAddr);
+    EquivalentAddressGroup resolvedBalancerAddr =
+        Iterables.getOnlyElement(result.getAttributes().get(GrpclbConstants.ATTR_LB_ADDRS));
+    assertThat(resolvedBalancerAddr.getAttributes().get(GrpclbConstants.ATTR_LB_ADDR_AUTHORITY))
+        .isEqualTo("foo.example.com");
+    InetSocketAddress resolvedBalancerSockAddr =
+        (InetSocketAddress) Iterables.getOnlyElement(resolvedBalancerAddr.getAddresses());
+    assertThat(resolvedBalancerSockAddr.getAddress()).isEqualTo(lbAddr);
+    assertThat(resolvedBalancerSockAddr.getPort()).isEqualTo(lbPort);
+    assertThat(result.getServiceConfig().getConfig()).isNotNull();
+    verify(mockAddressResolver).resolveAddress(hostName);
+    verify(mockResourceResolver).resolveTxt("_grpc_config." + hostName);
+    verify(mockResourceResolver).resolveSrv("_grpclb._tcp." + hostName);
+  }
+
+  @Test
+  public void resolve_nullResourceResolver() throws Exception {
+    InetAddress backendAddr = InetAddress.getByAddress(new byte[] {127, 0, 0, 0});
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    when(mockAddressResolver.resolveAddress(anyString()))
+        .thenReturn(Collections.singletonList(backendAddr));
+    ResourceResolver resourceResolver = null;
+
+    resolver.setAddressResolver(mockAddressResolver);
+    resolver.setResourceResolver(resourceResolver);
+
+    resolver.start(mockListener);
+    assertThat(fakeClock.runDueTasks()).isEqualTo(1);
+    verify(mockListener).onResult2(resultCaptor.capture());
+    ResolutionResult result = resultCaptor.getValue();
+    assertThat(result.getAddressesOrError().getValue())
+        .containsExactly(
+            new EquivalentAddressGroup(new InetSocketAddress(backendAddr, DEFAULT_PORT)));
+    assertThat(result.getAttributes()).isEqualTo(Attributes.EMPTY);
+    assertThat(result.getServiceConfig()).isNull();
+  }
+
+  @Test
+  public void resolve_nullResourceResolver_addressFailure() throws Exception {
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    when(mockAddressResolver.resolveAddress(anyString())).thenThrow(new IOException("no addr"));
+    ResourceResolver resourceResolver = null;
+
+    resolver.setAddressResolver(mockAddressResolver);
+    resolver.setResourceResolver(resourceResolver);
+
+    resolver.start(mockListener);
+    assertThat(fakeClock.runDueTasks()).isEqualTo(1);
+    verify(mockListener).onResult2(resultCaptor.capture());
+    Status errorStatus = resultCaptor.getValue().getAddressesOrError().getStatus();
+    assertThat(errorStatus.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(errorStatus.getCause()).hasMessageThat().contains("no addr");
+  }
+
+  @Test
+  public void resolve_addressFailure_stillLookUpBalancersAndServiceConfig() throws Exception {
+    InetAddress lbAddr = InetAddress.getByAddress(new byte[] {10, 1, 0, 0});
+    int lbPort = 8080;
+    String lbName = "foo.example.com.";  // original name in SRV record
+    SrvRecord srvRecord = new SrvRecord(lbName, 8080);
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    when(mockAddressResolver.resolveAddress(hostName))
+        .thenThrow(new UnknownHostException("I really tried"));
+    when(mockAddressResolver.resolveAddress(lbName))
+        .thenReturn(Collections.singletonList(lbAddr));
+    ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
+    when(mockResourceResolver.resolveTxt(anyString())).thenReturn(Collections.<String>emptyList());
+    when(mockResourceResolver.resolveSrv(anyString()))
+        .thenReturn(Collections.singletonList(srvRecord));
+
+    resolver.setAddressResolver(mockAddressResolver);
+    resolver.setResourceResolver(mockResourceResolver);
+
+    resolver.start(mockListener);
+    assertThat(fakeClock.runDueTasks()).isEqualTo(1);
+    verify(mockListener).onResult2(resultCaptor.capture());
+    ResolutionResult result = resultCaptor.getValue();
+    assertThat(result.getAddressesOrError().getValue()).isEmpty();
+    EquivalentAddressGroup resolvedBalancerAddr =
+        Iterables.getOnlyElement(result.getAttributes().get(GrpclbConstants.ATTR_LB_ADDRS));
+    assertThat(resolvedBalancerAddr.getAttributes().get(GrpclbConstants.ATTR_LB_ADDR_AUTHORITY))
+        .isEqualTo("foo.example.com");
+    InetSocketAddress resolvedBalancerSockAddr =
+        (InetSocketAddress) Iterables.getOnlyElement(resolvedBalancerAddr.getAddresses());
+    assertThat(resolvedBalancerSockAddr.getAddress()).isEqualTo(lbAddr);
+    assertThat(resolvedBalancerSockAddr.getPort()).isEqualTo(lbPort);
+    assertThat(result.getServiceConfig()).isNull();
+    verify(mockAddressResolver).resolveAddress(hostName);
+    verify(mockResourceResolver).resolveTxt("_grpc_config." + hostName);
+    verify(mockResourceResolver).resolveSrv("_grpclb._tcp." + hostName);
+  }
+
+  @Test
+  public void resolveAll_balancerLookupFails_stillLookUpServiceConfig() throws Exception {
+    InetAddress backendAddr = InetAddress.getByAddress(new byte[] {127, 0, 0, 0});
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    when(mockAddressResolver.resolveAddress(hostName))
+        .thenReturn(Collections.singletonList(backendAddr));
+    ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
+    when(mockResourceResolver.resolveTxt(anyString()))
+        .thenReturn(Collections.<String>emptyList());
+    when(mockResourceResolver.resolveSrv(anyString()))
+        .thenThrow(new Exception("something like javax.naming.NamingException"));
+
+    resolver.setAddressResolver(mockAddressResolver);
+    resolver.setResourceResolver(mockResourceResolver);
+
+    resolver.start(mockListener);
+    assertThat(fakeClock.runDueTasks()).isEqualTo(1);
+    verify(mockListener).onResult2(resultCaptor.capture());
+    ResolutionResult result = resultCaptor.getValue();
+
+    InetSocketAddress resolvedBackendAddr =
+        (InetSocketAddress) Iterables.getOnlyElement(
+            Iterables.getOnlyElement(result.getAddressesOrError().getValue()).getAddresses());
+    assertThat(resolvedBackendAddr.getAddress()).isEqualTo(backendAddr);
+    assertThat(result.getAttributes().get(GrpclbConstants.ATTR_LB_ADDRS)).isNull();
+    verify(mockAddressResolver).resolveAddress(hostName);
+    verify(mockResourceResolver).resolveTxt("_grpc_config." + hostName);
+    verify(mockResourceResolver).resolveSrv("_grpclb._tcp." + hostName);
+  }
+
+  @Test
+  public void resolve_addressAndBalancersLookupFail_neverLookupServiceConfig() throws Exception {
+    AddressResolver mockAddressResolver = mock(AddressResolver.class);
+    when(mockAddressResolver.resolveAddress(anyString()))
+        .thenThrow(new UnknownHostException("I really tried"));
+    ResourceResolver mockResourceResolver = mock(ResourceResolver.class);
+    lenient().when(mockResourceResolver.resolveTxt(anyString()))
+        .thenThrow(new Exception("something like javax.naming.NamingException"));
+    when(mockResourceResolver.resolveSrv(anyString()))
+        .thenThrow(new Exception("something like javax.naming.NamingException"));
+
+    resolver.setAddressResolver(mockAddressResolver);
+    resolver.setResourceResolver(mockResourceResolver);
+
+    resolver.start(mockListener);
+    assertThat(fakeClock.runDueTasks()).isEqualTo(1);
+    verify(mockListener).onResult2(resultCaptor.capture());
+    Status errorStatus = resultCaptor.getValue().getAddressesOrError().getStatus();
+    assertThat(errorStatus.getCode()).isEqualTo(Code.UNAVAILABLE);
+    verify(mockAddressResolver).resolveAddress(hostName);
+    verify(mockResourceResolver, never()).resolveTxt("_grpc_config." + hostName);
+    verify(mockResourceResolver).resolveSrv("_grpclb._tcp." + hostName);
+  }
+}
diff --git a/grpclb/src/test/java/io/grpc/grpclb/SecretGrpclbNameResolverProviderTest.java b/grpclb/src/test/java/io/grpc/grpclb/SecretGrpclbNameResolverProviderTest.java
new file mode 100644
index 00000000000..24b1c781f58
--- /dev/null
+++ b/grpclb/src/test/java/io/grpc/grpclb/SecretGrpclbNameResolverProviderTest.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2019 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.grpclb;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.ChannelLogger;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.DnsNameResolverProvider;
+import io.grpc.internal.GrpcUtil;
+import java.net.URI;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link SecretGrpclbNameResolverProvider}. */
+@RunWith(JUnit4.class)
+public class SecretGrpclbNameResolverProviderTest {
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final NameResolver.Args args = NameResolver.Args.newBuilder()
+      .setDefaultPort(8080)
+      .setProxyDetector(GrpcUtil.DEFAULT_PROXY_DETECTOR)
+      .setSynchronizationContext(syncContext)
+      .setServiceConfigParser(mock(ServiceConfigParser.class))
+      .setChannelLogger(mock(ChannelLogger.class))
+      .build();
+
+  private SecretGrpclbNameResolverProvider.Provider provider =
+      new SecretGrpclbNameResolverProvider.Provider();
+
+  @Test
+  public void isAvailable() {
+    assertThat(provider.isAvailable()).isTrue();
+  }
+
+  @Test
+  public void priority_shouldBeHigherThanDefaultDnsNameResolver() {
+    DnsNameResolverProvider defaultDnsNameResolver = new DnsNameResolverProvider();
+
+    assertThat(provider.priority()).isGreaterThan(defaultDnsNameResolver.priority());
+  }
+
+  @Test
+  public void newNameResolver() {
+    assertThat(provider.newNameResolver(URI.create("dns:///localhost:443"), args))
+        .isInstanceOf(GrpclbNameResolver.class);
+    assertThat(provider.newNameResolver(URI.create("notdns:///localhost:443"), args)).isNull();
+  }
+
+  @Test
+  public void invalidDnsName() throws Exception {
+    testInvalidUri(new URI("dns", null, "/[invalid]", null));
+  }
+
+  @Test
+  public void validIpv6() throws Exception {
+    testValidUri(new URI("dns", null, "/[::1]", null));
+  }
+
+  @Test
+  public void validDnsNameWithoutPort() throws Exception {
+    testValidUri(new URI("dns", null, "/foo.googleapis.com", null));
+  }
+
+  @Test
+  public void validDnsNameWithPort() throws Exception {
+    testValidUri(new URI("dns", null, "/foo.googleapis.com:456", null));
+  }
+
+  private void testInvalidUri(URI uri) {
+    try {
+      provider.newNameResolver(uri, args);
+      fail("Should have failed");
+    } catch (IllegalArgumentException e) {
+      // expected
+    }
+  }
+
+  private void testValidUri(URI uri) {
+    GrpclbNameResolver resolver = provider.newNameResolver(uri, args);
+    assertThat(resolver).isNotNull();
+  }
+}
diff --git a/grpclb/src/test/java/io/grpc/grpclb/TokenAttachingTracerFactoryTest.java b/grpclb/src/test/java/io/grpc/grpclb/TokenAttachingTracerFactoryTest.java
new file mode 100644
index 00000000000..4787c8697cc
--- /dev/null
+++ b/grpclb/src/test/java/io/grpc/grpclb/TokenAttachingTracerFactoryTest.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2019 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.grpclb;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.Attributes;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Metadata;
+import io.grpc.internal.GrpcAttributes;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link TokenAttachingTracerFactory}. */
+@RunWith(JUnit4.class)
+public class TokenAttachingTracerFactoryTest {
+  private static final class FakeClientStreamTracer extends ClientStreamTracer {
+    Attributes transportAttrs;
+    Metadata headers;
+
+    @Override
+    public void streamCreated(Attributes transportAttrs, Metadata headers) {
+      this.transportAttrs = transportAttrs;
+      this.headers = headers;
+    }
+  }
+
+  private static final FakeClientStreamTracer fakeTracer = new FakeClientStreamTracer();
+
+  private final ClientStreamTracer.Factory delegate = mock(
+      ClientStreamTracer.Factory.class,
+      delegatesTo(
+          new ClientStreamTracer.Factory() {
+            @Override
+            public ClientStreamTracer newClientStreamTracer(
+                ClientStreamTracer.StreamInfo info, Metadata headers) {
+              return fakeTracer;
+            }
+          }));
+
+  @Test
+  public void hasToken() {
+    TokenAttachingTracerFactory factory = new TokenAttachingTracerFactory(delegate);
+    Attributes eagAttrs = Attributes.newBuilder()
+        .set(GrpclbConstants.TOKEN_ATTRIBUTE_KEY, "token0001").build();
+    ClientStreamTracer.StreamInfo info = ClientStreamTracer.StreamInfo.newBuilder().build();
+    Metadata headers = new Metadata();
+    // Preexisting token should be replaced
+    headers.put(GrpclbConstants.TOKEN_METADATA_KEY, "preexisting-token");
+
+    ClientStreamTracer tracer = factory.newClientStreamTracer(info, headers);
+    verify(delegate).newClientStreamTracer(same(info), same(headers));
+    Attributes transportAttrs =
+        Attributes.newBuilder().set(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS, eagAttrs).build();
+    tracer.streamCreated(transportAttrs, headers);
+    assertThat(fakeTracer.transportAttrs).isSameInstanceAs(transportAttrs);
+    assertThat(fakeTracer.headers).isSameInstanceAs(headers);
+    assertThat(headers.getAll(GrpclbConstants.TOKEN_METADATA_KEY)).containsExactly("token0001");
+  }
+
+  @Test
+  public void noToken() {
+    TokenAttachingTracerFactory factory = new TokenAttachingTracerFactory(delegate);
+    ClientStreamTracer.StreamInfo info = ClientStreamTracer.StreamInfo.newBuilder().build();
+
+    Metadata headers = new Metadata();
+    // Preexisting token should be removed
+    headers.put(GrpclbConstants.TOKEN_METADATA_KEY, "preexisting-token");
+
+    ClientStreamTracer tracer = factory.newClientStreamTracer(info, headers);
+    verify(delegate).newClientStreamTracer(same(info), same(headers));
+    Attributes transportAttrs =
+        Attributes.newBuilder().set(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS, Attributes.EMPTY).build();
+    tracer.streamCreated(transportAttrs, headers);
+    assertThat(fakeTracer.transportAttrs).isSameInstanceAs(transportAttrs);
+    assertThat(fakeTracer.headers).isSameInstanceAs(headers);
+    assertThat(headers.get(GrpclbConstants.TOKEN_METADATA_KEY)).isNull();
+  }
+
+  @Test
+  public void nullDelegate() {
+    TokenAttachingTracerFactory factory = new TokenAttachingTracerFactory(null);
+    ClientStreamTracer.StreamInfo info = ClientStreamTracer.StreamInfo.newBuilder().build();
+
+    Metadata headers = new Metadata();
+
+    ClientStreamTracer tracer = factory.newClientStreamTracer(info, headers);
+    tracer.streamCreated(
+        Attributes.newBuilder().set(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS, Attributes.EMPTY).build(),
+        headers);
+    assertThat(tracer).isNotNull();
+    assertThat(headers.get(GrpclbConstants.TOKEN_METADATA_KEY)).isNull();
+  }
+}
diff --git a/inprocess/BUILD.bazel b/inprocess/BUILD.bazel
new file mode 100644
index 00000000000..e9c5001c5ec
--- /dev/null
+++ b/inprocess/BUILD.bazel
@@ -0,0 +1,18 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "inprocess",
+    srcs = glob([
+        "src/main/java/io/grpc/inprocess/*.java",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api",
+        "//context",
+        "//core:internal",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+    ],
+)
diff --git a/inprocess/build.gradle b/inprocess/build.gradle
new file mode 100644
index 00000000000..075968ccb9a
--- /dev/null
+++ b/inprocess/build.gradle
@@ -0,0 +1,39 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "ru.vyarus.animalsniffer"
+}
+
+description = 'gRPC: Inprocess'
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.inprocess')
+    }
+}
+
+dependencies {
+    api project(':grpc-api')
+
+    implementation project(':grpc-core')
+    implementation libraries.guava
+    testImplementation project(':grpc-testing'),
+            testFixtures(project(':grpc-core'))
+    testImplementation libraries.guava.testlib
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+tasks.named("javadoc").configure {
+    exclude 'io/grpc/inprocess/Internal*'
+}
diff --git a/inprocess/src/main/java/io/grpc/inprocess/AnonymousInProcessSocketAddress.java b/inprocess/src/main/java/io/grpc/inprocess/AnonymousInProcessSocketAddress.java
new file mode 100644
index 00000000000..c458857d70b
--- /dev/null
+++ b/inprocess/src/main/java/io/grpc/inprocess/AnonymousInProcessSocketAddress.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2021 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.inprocess;
+
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.ExperimentalApi;
+import java.io.IOException;
+import java.io.NotSerializableException;
+import java.io.ObjectOutputStream;
+import java.net.SocketAddress;
+import javax.annotation.Nullable;
+
+/**
+ * Custom SocketAddress class for {@link InProcessTransport}, for 
+ * a server which can only be referenced via this address instance.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/8626")
+public final class AnonymousInProcessSocketAddress extends SocketAddress {
+  private static final long serialVersionUID = -8567592561863414695L;
+
+  @Nullable
+  @GuardedBy("this")
+  @SuppressWarnings("serial")
+  private InProcessServer server;
+
+  private void writeObject(ObjectOutputStream out) throws IOException {
+    throw new NotSerializableException("AnonymousInProcessSocketAddress is not serializable");
+  }
+
+  /** Creates a new AnonymousInProcessSocketAddress. */
+  public AnonymousInProcessSocketAddress() { }
+
+  @Nullable
+  synchronized InProcessServer getServer() {
+    return server;
+  }
+
+  synchronized void setServer(InProcessServer server) throws IOException {
+    if (this.server != null) {
+      throw new IOException("Server instance already registered");
+    }
+    this.server = server;
+  }
+
+  synchronized void clearServer(InProcessServer server) {
+    checkState(this.server == server);
+    this.server = null;
+  }
+}
diff --git a/inprocess/src/main/java/io/grpc/inprocess/InProcessChannelBuilder.java b/inprocess/src/main/java/io/grpc/inprocess/InProcessChannelBuilder.java
new file mode 100644
index 00000000000..9b33b3d3618
--- /dev/null
+++ b/inprocess/src/main/java/io/grpc/inprocess/InProcessChannelBuilder.java
@@ -0,0 +1,313 @@
+/*
+ * Copyright 2015 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.inprocess;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.inprocess.InProcessTransport.isEnabledSupportTracingMessageSizes;
+
+import com.google.errorprone.annotations.DoNotCall;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingChannelBuilder2;
+import io.grpc.Internal;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.ConnectionClientTransport;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.ManagedChannelImplBuilder;
+import io.grpc.internal.ManagedChannelImplBuilder.ClientTransportFactoryBuilder;
+import io.grpc.internal.SharedResourceHolder;
+import java.net.SocketAddress;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * Builder for a channel that issues in-process requests. Clients identify the in-process server by
+ * its name.
+ *
+ * <p>The channel is intended to be fully-featured, high performance, and useful in testing.
+ *
+ * <p>For usage examples, see {@link InProcessServerBuilder}.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1783")
+public final class InProcessChannelBuilder extends
+    ForwardingChannelBuilder2<InProcessChannelBuilder> {
+
+  /**
+   * Create a channel builder that will connect to the server with the given name.
+   *
+   * @param name the identity of the server to connect to
+   * @return a new builder
+   */
+  public static InProcessChannelBuilder forName(String name) {
+    return forAddress(new InProcessSocketAddress(checkNotNull(name, "name")));
+  }
+
+  /**
+   * Create a channel builder that will connect to the server referenced by the given target URI.
+   * Only intended for use with a custom name resolver.
+   *
+   * @param target the identity of the server to connect to
+   * @return a new builder
+   */
+  public static InProcessChannelBuilder forTarget(String target) {
+    return new InProcessChannelBuilder(null, checkNotNull(target, "target"));
+  }
+
+  /**
+   * Create a channel builder that will connect to the server referenced by the given address.
+   *
+   * @param address the address of the server to connect to
+   * @return a new builder
+   */
+  public static InProcessChannelBuilder forAddress(SocketAddress address) {
+    return new InProcessChannelBuilder(checkNotNull(address, "address"), null);
+  }
+
+  /**
+   * Always fails.  Call {@link #forName} instead.
+   */
+  @DoNotCall("Unsupported. Use forName() instead")
+  public static InProcessChannelBuilder forAddress(String name, int port) {
+    throw new UnsupportedOperationException("call forName() instead");
+  }
+
+  private final ManagedChannelImplBuilder managedChannelImplBuilder;
+  private ScheduledExecutorService scheduledExecutorService;
+  private int maxInboundMetadataSize = Integer.MAX_VALUE;
+  private boolean transportIncludeStatusCause = false;
+  private long assumedMessageSize = -1;
+
+  private InProcessChannelBuilder(@Nullable SocketAddress directAddress, @Nullable String target) {
+
+    final class InProcessChannelTransportFactoryBuilder implements ClientTransportFactoryBuilder {
+      @Override
+      public ClientTransportFactory buildClientTransportFactory() {
+        return buildTransportFactory();
+      }
+    }
+
+    if (directAddress != null) {
+      managedChannelImplBuilder = new ManagedChannelImplBuilder(directAddress, "localhost",
+          new InProcessChannelTransportFactoryBuilder(), null);
+    } else {
+      managedChannelImplBuilder = new ManagedChannelImplBuilder(target,
+          new InProcessChannelTransportFactoryBuilder(), null);
+    }
+
+    // In-process transport should not record its traffic to the stats module.
+    // https://github.com/grpc/grpc-java/issues/2284
+    managedChannelImplBuilder.setStatsRecordStartedRpcs(false);
+    managedChannelImplBuilder.setStatsRecordFinishedRpcs(false);
+    managedChannelImplBuilder.setStatsRecordRetryMetrics(false);
+    if (!isEnabledSupportTracingMessageSizes) {
+      managedChannelImplBuilder.disableRetry();
+    }
+  }
+
+  @Internal
+  @Override
+  protected ManagedChannelBuilder<?> delegate() {
+    return managedChannelImplBuilder;
+  }
+
+  @Override
+  public InProcessChannelBuilder maxInboundMessageSize(int max) {
+    // TODO(carl-mastrangelo): maybe throw an exception since this not enforced?
+    return super.maxInboundMessageSize(max);
+  }
+
+  /**
+   * Does nothing.
+   */
+  @Override
+  public InProcessChannelBuilder useTransportSecurity() {
+    return this;
+  }
+
+  /**
+   * Does nothing.
+   */
+  @Override
+  public InProcessChannelBuilder usePlaintext() {
+    return this;
+  }
+
+  /** Does nothing. */
+  @Override
+  public InProcessChannelBuilder keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    return this;
+  }
+
+  /** Does nothing. */
+  @Override
+  public InProcessChannelBuilder keepAliveTimeout(long keepAliveTimeout, TimeUnit timeUnit) {
+    return this;
+  }
+
+  /** Does nothing. */
+  @Override
+  public InProcessChannelBuilder keepAliveWithoutCalls(boolean enable) {
+    return this;
+  }
+
+  /**
+   * Provides a custom scheduled executor service.
+   *
+   * <p>It's an optional parameter. If the user has not provided a scheduled executor service when
+   * the channel is built, the builder will use a static cached thread pool.
+   *
+   * @return this
+   *
+   * @since 1.11.0
+   */
+  public InProcessChannelBuilder scheduledExecutorService(
+      ScheduledExecutorService scheduledExecutorService) {
+    this.scheduledExecutorService =
+        checkNotNull(scheduledExecutorService, "scheduledExecutorService");
+    return this;
+  }
+
+  /**
+   * Sets the maximum size of metadata allowed to be received. {@code Integer.MAX_VALUE} disables
+   * the enforcement. Defaults to no limit ({@code Integer.MAX_VALUE}).
+   *
+   * <p>There is potential for performance penalty when this setting is enabled, as the Metadata
+   * must actually be serialized. Since the current implementation of Metadata pre-serializes, it's
+   * currently negligible. But Metadata is free to change its implementation.
+   *
+   * @param bytes the maximum size of received metadata
+   * @return this
+   * @throws IllegalArgumentException if bytes is non-positive
+   * @since 1.17.0
+   */
+  @Override
+  public InProcessChannelBuilder maxInboundMetadataSize(int bytes) {
+    checkArgument(bytes > 0, "maxInboundMetadataSize must be > 0");
+    this.maxInboundMetadataSize = bytes;
+    return this;
+  }
+
+  /**
+   * Sets whether to include the cause with the status that is propagated
+   * forward from the InProcessTransport. This was added to make debugging failing
+   * tests easier by showing the cause of the status.
+   *
+   * <p>By default, this is set to false.
+   * A default value of false maintains consistency with other transports which strip causal
+   * information from the status to avoid leaking information to untrusted clients, and
+   * to avoid sharing language-specific information with the client.
+   * For the in-process implementation, this is not a concern.
+   *
+   * @param enable whether to include cause in status
+   * @return this
+   */
+  public InProcessChannelBuilder propagateCauseWithStatus(boolean enable) {
+    this.transportIncludeStatusCause = enable;
+    return this;
+  }
+
+  /**
+   * Assumes RPC messages are the specified size. This avoids serializing
+   * messages for metrics and retry memory tracking. This can dramatically
+   * improve performance when accurate message sizes are not needed and if
+   * nothing else needs the serialized message.
+   * @param assumedMessageSize length of InProcess transport's messageSize.
+   * @return this
+   * @throws IllegalArgumentException if assumedMessageSize is negative.
+   */
+  public InProcessChannelBuilder assumedMessageSize(long assumedMessageSize) {
+    checkArgument(assumedMessageSize >= 0, "assumedMessageSize must be >= 0");
+    this.assumedMessageSize = assumedMessageSize;
+    return this;
+  }
+
+  ClientTransportFactory buildTransportFactory() {
+    return new InProcessClientTransportFactory(scheduledExecutorService,
+            maxInboundMetadataSize, transportIncludeStatusCause, assumedMessageSize);
+  }
+
+  void setStatsEnabled(boolean value) {
+    this.managedChannelImplBuilder.setStatsEnabled(value);
+  }
+
+  /**
+   * Creates InProcess transports. Exposed for internal use, as it should be private.
+   */
+  static final class InProcessClientTransportFactory implements ClientTransportFactory {
+    private final ScheduledExecutorService timerService;
+    private final boolean useSharedTimer;
+    private final int maxInboundMetadataSize;
+    private boolean closed;
+    private final boolean includeCauseWithStatus;
+    private long assumedMessageSize;
+
+    private InProcessClientTransportFactory(
+        @Nullable ScheduledExecutorService scheduledExecutorService,
+        int maxInboundMetadataSize, boolean includeCauseWithStatus, long assumedMessageSize) {
+      useSharedTimer = scheduledExecutorService == null;
+      timerService = useSharedTimer
+          ? SharedResourceHolder.get(GrpcUtil.TIMER_SERVICE) : scheduledExecutorService;
+      this.maxInboundMetadataSize = maxInboundMetadataSize;
+      this.includeCauseWithStatus = includeCauseWithStatus;
+      this.assumedMessageSize = assumedMessageSize;
+    }
+
+    @Override
+    public ConnectionClientTransport newClientTransport(
+        SocketAddress addr, ClientTransportOptions options, ChannelLogger channelLogger) {
+      if (closed) {
+        throw new IllegalStateException("The transport factory is closed.");
+      }
+      // TODO(carl-mastrangelo): Pass channelLogger in.
+      return new InProcessTransport(
+          addr, maxInboundMetadataSize, options.getAuthority(), options.getUserAgent(),
+          options.getEagAttributes(), includeCauseWithStatus, assumedMessageSize);
+    }
+
+    @Override
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return timerService;
+    }
+
+    @Override
+    public SwapChannelCredentialsResult swapChannelCredentials(ChannelCredentials channelCreds) {
+      return null;
+    }
+
+    @Override
+    public void close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      if (useSharedTimer) {
+        SharedResourceHolder.release(GrpcUtil.TIMER_SERVICE, timerService);
+      }
+    }
+
+    @Override
+    public Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+      return Arrays.asList(InProcessSocketAddress.class, AnonymousInProcessSocketAddress.class);
+    }
+  }
+}
diff --git a/inprocess/src/main/java/io/grpc/inprocess/InProcessServer.java b/inprocess/src/main/java/io/grpc/inprocess/InProcessServer.java
new file mode 100644
index 00000000000..ffaca78f397
--- /dev/null
+++ b/inprocess/src/main/java/io/grpc/inprocess/InProcessServer.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright 2015 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.inprocess;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.ServerListener;
+import io.grpc.internal.ServerTransportListener;
+import java.io.IOException;
+import java.net.SocketAddress;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ScheduledExecutorService;
+import javax.annotation.concurrent.ThreadSafe;
+
+@ThreadSafe
+final class InProcessServer implements InternalServer {
+  private static final ConcurrentMap<String, InProcessServer> registry
+      = new ConcurrentHashMap<>();
+
+  static InProcessServer findServer(SocketAddress addr) {
+    if (addr instanceof AnonymousInProcessSocketAddress) {
+      return ((AnonymousInProcessSocketAddress) addr).getServer();
+    } else if (addr instanceof InProcessSocketAddress) {
+      return registry.get(((InProcessSocketAddress) addr).getName());
+    }
+    return null;
+  }
+
+  private final SocketAddress listenAddress;
+  private final int maxInboundMetadataSize;
+  private final List<ServerStreamTracer.Factory> streamTracerFactories;
+  private ServerListener listener;
+  private boolean shutdown;
+  /** Defaults to be a SharedResourcePool. */
+  private final ObjectPool<ScheduledExecutorService> schedulerPool;
+  /**
+   * Only used to make sure the scheduler has at least one reference. Since child transports can
+   * outlive this server, they must get their own reference.
+   */
+  private ScheduledExecutorService scheduler;
+
+  InProcessServer(
+      InProcessServerBuilder builder,
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+    this.listenAddress = builder.listenAddress;
+    this.schedulerPool = builder.schedulerPool;
+    this.maxInboundMetadataSize = builder.maxInboundMetadataSize;
+    this.streamTracerFactories =
+        Collections.unmodifiableList(checkNotNull(streamTracerFactories, "streamTracerFactories"));
+  }
+
+  @Override
+  public void start(ServerListener serverListener) throws IOException {
+    this.listener = serverListener;
+    this.scheduler = schedulerPool.getObject();
+    // Must be last, as channels can start connecting after this point.
+    registerInstance();
+  }
+
+  private void registerInstance() throws IOException {
+    if (listenAddress instanceof AnonymousInProcessSocketAddress) {
+      ((AnonymousInProcessSocketAddress) listenAddress).setServer(this);
+    } else if (listenAddress instanceof InProcessSocketAddress) {
+      String name = ((InProcessSocketAddress) listenAddress).getName();
+      if (registry.putIfAbsent(name, this) != null) {
+        throw new IOException("name already registered: " + name);
+      }
+    } else {
+      throw new AssertionError();
+    }
+  }
+
+  @Override
+  public SocketAddress getListenSocketAddress() {
+    return listenAddress;
+  }
+
+  @Override
+  public List<? extends SocketAddress> getListenSocketAddresses() {
+    return Collections.singletonList(getListenSocketAddress());
+  }
+
+  @Override
+  public InternalInstrumented<SocketStats> getListenSocketStats() {
+    return null;
+  }
+
+  @Override
+  public List<InternalInstrumented<SocketStats>> getListenSocketStatsList() {
+    return null;
+  }
+
+  @Override
+  public void shutdown() {
+    unregisterInstance();
+    scheduler = schedulerPool.returnObject(scheduler);
+    synchronized (this) {
+      shutdown = true;
+      listener.serverShutdown();
+    }
+  }
+
+  private void unregisterInstance() {
+    if (listenAddress instanceof AnonymousInProcessSocketAddress) {
+      ((AnonymousInProcessSocketAddress) listenAddress).clearServer(this);
+    } else if (listenAddress instanceof InProcessSocketAddress) {
+      String name = ((InProcessSocketAddress) listenAddress).getName();
+      if (!registry.remove(name, this)) {
+        throw new AssertionError();
+      }
+    } else {
+      throw new AssertionError();
+    }
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("listenAddress", listenAddress).toString();
+  }
+
+  synchronized ServerTransportListener register(InProcessTransport transport) {
+    if (shutdown) {
+      return null;
+    }
+    return listener.transportCreated(transport);
+  }
+
+  ObjectPool<ScheduledExecutorService> getScheduledExecutorServicePool() {
+    return schedulerPool;
+  }
+
+  int getMaxInboundMetadataSize() {
+    return maxInboundMetadataSize;
+  }
+
+  List<ServerStreamTracer.Factory> getStreamTracerFactories() {
+    return streamTracerFactories;
+  }
+}
diff --git a/inprocess/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java b/inprocess/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java
new file mode 100644
index 00000000000..190f67603c3
--- /dev/null
+++ b/inprocess/src/main/java/io/grpc/inprocess/InProcessServerBuilder.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2015 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.inprocess;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.DoNotCall;
+import io.grpc.Deadline;
+import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingServerBuilder;
+import io.grpc.Internal;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.FixedObjectPool;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.ServerImplBuilder;
+import io.grpc.internal.ServerImplBuilder.ClientTransportServersBuilder;
+import io.grpc.internal.SharedResourcePool;
+import java.io.File;
+import java.net.SocketAddress;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Builder for a server that services in-process requests. Clients identify the in-process server by
+ * its name.
+ *
+ * <p>The server is intended to be fully-featured, high performance, and useful in testing.
+ *
+ * <h3>Using JUnit TestRule</h3>
+ * The class "GrpcServerRule" (from "grpc-java/testing") is a JUnit TestRule that
+ * creates a {@link InProcessServer} and a {@link io.grpc.ManagedChannel ManagedChannel}. This
+ * test rule contains the boilerplate code shown below. The classes "HelloWorldServerTest" and
+ * "HelloWorldClientTest" (from "grpc-java/examples") demonstrate basic usage.
+ *
+ * <h3>Usage example</h3>
+ * <h4>Server and client channel setup</h4>
+ * <pre>
+ *   String uniqueName = InProcessServerBuilder.generateName();
+ *   Server server = InProcessServerBuilder.forName(uniqueName)
+ *       .directExecutor() // directExecutor is fine for unit tests
+ *       .addService(&#47;* your code here *&#47;)
+ *       .build().start();
+ *   ManagedChannel channel = InProcessChannelBuilder.forName(uniqueName)
+ *       .directExecutor()
+ *       .build();
+ * </pre>
+ *
+ * <h4>Usage in tests</h4>
+ * The channel can be used normally. A blocking stub example:
+ * <pre>
+ *   TestServiceGrpc.TestServiceBlockingStub blockingStub =
+ *       TestServiceGrpc.newBlockingStub(channel);
+ * </pre>
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1783")
+public final class InProcessServerBuilder extends ForwardingServerBuilder<InProcessServerBuilder> {
+  /**
+   * Create a server builder that will bind with the given name.
+   *
+   * @param name the identity of the server for clients to connect to
+   * @return a new builder
+   */
+  public static InProcessServerBuilder forName(String name) {
+    return forAddress(new InProcessSocketAddress(checkNotNull(name, "name")));
+  }
+
+  /**
+   * Create a server builder which listens on the given address.
+   * @param listenAddress The SocketAddress this server will listen on.
+   * @return a new builder
+   */
+  public static InProcessServerBuilder forAddress(SocketAddress listenAddress) {
+    return new InProcessServerBuilder(listenAddress);
+  }
+
+  /**
+   * Always fails.  Call {@link #forName} instead.
+   */
+  @DoNotCall("Unsupported. Use forName() instead")
+  public static InProcessServerBuilder forPort(int port) {
+    throw new UnsupportedOperationException("call forName() instead");
+  }
+
+  /**
+   * Generates a new server name that is unique each time.
+   */
+  public static String generateName() {
+    return UUID.randomUUID().toString();
+  }
+
+  private final ServerImplBuilder serverImplBuilder;
+  final SocketAddress listenAddress;
+  int maxInboundMetadataSize = Integer.MAX_VALUE;
+  ObjectPool<ScheduledExecutorService> schedulerPool =
+      SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE);
+
+  private InProcessServerBuilder(SocketAddress listenAddress) {
+    this.listenAddress = checkNotNull(listenAddress, "listenAddress");
+
+    final class InProcessClientTransportServersBuilder implements ClientTransportServersBuilder {
+      @Override
+      public InternalServer buildClientTransportServers(
+          List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+        return buildTransportServers(streamTracerFactories);
+      }
+    }
+
+    serverImplBuilder = new ServerImplBuilder(new InProcessClientTransportServersBuilder());
+
+    // In-process transport should not record its traffic to the stats module.
+    // https://github.com/grpc/grpc-java/issues/2284
+    serverImplBuilder.setStatsRecordStartedRpcs(false);
+    serverImplBuilder.setStatsRecordFinishedRpcs(false);
+    // Disable handshake timeout because it is unnecessary, and can trigger Thread creation that can
+    // break some environments (like tests).
+    handshakeTimeout(Long.MAX_VALUE, TimeUnit.SECONDS);
+  }
+
+  @Internal
+  @Override
+  protected ServerBuilder<?> delegate() {
+    return serverImplBuilder;
+  }
+
+  /**
+   * Provides a custom scheduled executor service.
+   *
+   * <p>It's an optional parameter. If the user has not provided a scheduled executor service when
+   * the channel is built, the builder will use a static cached thread pool.
+   *
+   * @return this
+   *
+   * @since 1.11.0
+   */
+  public InProcessServerBuilder scheduledExecutorService(
+      ScheduledExecutorService scheduledExecutorService) {
+    schedulerPool = new FixedObjectPool<>(
+        checkNotNull(scheduledExecutorService, "scheduledExecutorService"));
+    return this;
+  }
+
+  /**
+   * Provides a custom deadline ticker that this server will use to create incoming {@link
+   * Deadline}s.
+   *
+   * <p>This is intended for unit tests that fake out the clock.  You should also have a fake {@link
+   * ScheduledExecutorService} whose clock is synchronized with this ticker and set it to {@link
+   * #scheduledExecutorService}. DO NOT use this in production.
+   *
+   * @return this
+   * @see Deadline#after(long, TimeUnit, Deadline.Ticker)
+   *
+   * @since 1.24.0
+   */
+  public InProcessServerBuilder deadlineTicker(Deadline.Ticker ticker) {
+    serverImplBuilder.setDeadlineTicker(ticker);
+    return this;
+  }
+
+  /**
+   * Sets the maximum size of metadata allowed to be received. {@code Integer.MAX_VALUE} disables
+   * the enforcement. Defaults to no limit ({@code Integer.MAX_VALUE}).
+   *
+   * <p>There is potential for performance penalty when this setting is enabled, as the Metadata
+   * must actually be serialized. Since the current implementation of Metadata pre-serializes, it's
+   * currently negligible. But Metadata is free to change its implementation.
+   *
+   * @param bytes the maximum size of received metadata
+   * @return this
+   * @throws IllegalArgumentException if bytes is non-positive
+   * @since 1.17.0
+   */
+  @Override
+  public InProcessServerBuilder maxInboundMetadataSize(int bytes) {
+    Preconditions.checkArgument(bytes > 0, "maxInboundMetadataSize must be > 0");
+    this.maxInboundMetadataSize = bytes;
+    return this;
+  }
+
+  InProcessServer buildTransportServers(
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+    return new InProcessServer(this, streamTracerFactories);
+  }
+
+  @Override
+  public InProcessServerBuilder useTransportSecurity(File certChain, File privateKey) {
+    throw new UnsupportedOperationException("TLS not supported in InProcessServer");
+  }
+
+  void setStatsEnabled(boolean value) {
+    this.serverImplBuilder.setStatsEnabled(value);
+  }
+}
diff --git a/inprocess/src/main/java/io/grpc/inprocess/InProcessSocketAddress.java b/inprocess/src/main/java/io/grpc/inprocess/InProcessSocketAddress.java
new file mode 100644
index 00000000000..98ecf7e1a5f
--- /dev/null
+++ b/inprocess/src/main/java/io/grpc/inprocess/InProcessSocketAddress.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2016 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.inprocess;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.net.SocketAddress;
+
+/**
+ * Custom SocketAddress class for {@link InProcessTransport}.
+ */
+public final class InProcessSocketAddress extends SocketAddress {
+  private static final long serialVersionUID = -2803441206326023474L;
+
+  private final String name;
+
+  /**
+   * Construct an address for a server identified by name.
+   *
+   * @param name The name of the inprocess server.
+   * @since 1.0.0
+   */
+  public InProcessSocketAddress(String name) {
+    this.name = checkNotNull(name, "name");
+  }
+
+  /**
+   * Gets the name of the inprocess server.
+   *
+   * @since 1.0.0
+   */
+  public String getName() {
+    return name;
+  }
+
+  /**
+   * Returns {@link #getName}.
+   *
+   * @since 1.14.0
+   */
+  @Override
+  public String toString() {
+    return name;
+  }
+
+  @Override
+  public int hashCode() {
+    return name.hashCode();
+  }
+
+  /**
+   * Returns {@code true} if the object is of the same type and server names match.
+   *
+   * @since 1.15.0
+   */
+  @Override
+  public boolean equals(Object obj) {
+    if (!(obj instanceof InProcessSocketAddress)) {
+      return false;
+    }
+    return name.equals(((InProcessSocketAddress) obj).name);
+  }
+}
diff --git a/inprocess/src/main/java/io/grpc/inprocess/InProcessTransport.java b/inprocess/src/main/java/io/grpc/inprocess/InProcessTransport.java
new file mode 100644
index 00000000000..a92f10fd5c5
--- /dev/null
+++ b/inprocess/src/main/java/io/grpc/inprocess/InProcessTransport.java
@@ -0,0 +1,988 @@
+/*
+ * Copyright 2015 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.inprocess;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.internal.GrpcUtil.TIMEOUT_KEY;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.io.ByteStreams;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.errorprone.annotations.CheckReturnValue;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Compressor;
+import io.grpc.Deadline;
+import io.grpc.Decompressor;
+import io.grpc.DecompressorRegistry;
+import io.grpc.Grpc;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalLogId;
+import io.grpc.InternalMetadata;
+import io.grpc.KnownLength;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.SecurityLevel;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.ClientStream;
+import io.grpc.internal.ClientStreamListener;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
+import io.grpc.internal.ConnectionClientTransport;
+import io.grpc.internal.GrpcAttributes;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.InUseStateAggregator;
+import io.grpc.internal.InsightBuilder;
+import io.grpc.internal.ManagedClientTransport;
+import io.grpc.internal.NoopClientStream;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.ServerStream;
+import io.grpc.internal.ServerStreamListener;
+import io.grpc.internal.ServerTransport;
+import io.grpc.internal.ServerTransportListener;
+import io.grpc.internal.SimpleDisconnectError;
+import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.StreamListener;
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.net.SocketAddress;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+@ThreadSafe
+final class InProcessTransport implements ServerTransport, ConnectionClientTransport {
+  private static final Logger log = Logger.getLogger(InProcessTransport.class.getName());
+  static boolean isEnabledSupportTracingMessageSizes =
+      GrpcUtil.getFlag("GRPC_EXPERIMENTAL_SUPPORT_TRACING_MESSAGE_SIZES", false);
+
+  private final InternalLogId logId;
+  private final SocketAddress address;
+  private final int clientMaxInboundMetadataSize;
+  private final String authority;
+  private final String userAgent;
+  private int serverMaxInboundMetadataSize;
+  private final boolean includeCauseWithStatus;
+  private ObjectPool<ScheduledExecutorService> serverSchedulerPool;
+  private ScheduledExecutorService serverScheduler;
+  private ServerTransportListener serverTransportListener;
+  private Attributes serverStreamAttributes;
+  private ManagedClientTransport.Listener clientTransportListener;
+  // The size is assumed from the sender's side.
+  private final long assumedMessageSize;
+  @GuardedBy("this")
+  private boolean shutdown;
+  @GuardedBy("this")
+  private boolean terminated;
+  @GuardedBy("this")
+  private Status shutdownStatus;
+  @GuardedBy("this")
+  private final Set<InProcessStream> streams = Collections.newSetFromMap(
+          new IdentityHashMap<InProcessStream, Boolean>());
+  @GuardedBy("this")
+  private List<ServerStreamTracer.Factory> serverStreamTracerFactories;
+  private Attributes attributes;
+
+  private Thread.UncaughtExceptionHandler uncaughtExceptionHandler =
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          if (e instanceof Error) {
+            throw new Error(e);
+          }
+          throw new RuntimeException(e);
+        }
+      };
+
+
+  @GuardedBy("this")
+  private final InUseStateAggregator<InProcessStream> inUseState =
+      new InUseStateAggregator<InProcessStream>() {
+        @Override
+        protected void handleInUse() {
+          clientTransportListener.transportInUse(true);
+        }
+
+        @Override
+        protected void handleNotInUse() {
+          clientTransportListener.transportInUse(false);
+        }
+      };
+
+  public InProcessTransport(SocketAddress address, int maxInboundMetadataSize, String authority,
+      String userAgent, Attributes eagAttrs,
+      boolean includeCauseWithStatus, long assumedMessageSize) {
+    this.address = address;
+    this.clientMaxInboundMetadataSize = maxInboundMetadataSize;
+    this.authority = authority;
+    this.userAgent = GrpcUtil.getGrpcUserAgent("inprocess", userAgent);
+    checkNotNull(eagAttrs, "eagAttrs");
+    this.attributes = Attributes.newBuilder()
+        .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.PRIVACY_AND_INTEGRITY)
+        .set(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS, eagAttrs)
+        .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, address)
+        .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, address)
+        .build();
+    logId = InternalLogId.allocate(getClass(), address.toString());
+    this.includeCauseWithStatus = includeCauseWithStatus;
+    this.assumedMessageSize = assumedMessageSize;
+  }
+
+  @CheckReturnValue
+  @Override
+  public synchronized Runnable start(ManagedClientTransport.Listener listener) {
+    this.clientTransportListener = listener;
+    InProcessServer server = InProcessServer.findServer(address);
+    if (server != null) {
+      serverMaxInboundMetadataSize = server.getMaxInboundMetadataSize();
+      serverSchedulerPool = server.getScheduledExecutorServicePool();
+      serverScheduler = serverSchedulerPool.getObject();
+      serverStreamTracerFactories = server.getStreamTracerFactories();
+      // Must be semi-initialized; past this point, can begin receiving requests
+      serverTransportListener = server.register(this);
+    }
+    if (serverTransportListener == null) {
+      shutdownStatus = Status.UNAVAILABLE.withDescription("Could not find server: " + address);
+      final Status localShutdownStatus = shutdownStatus;
+      return new Runnable() {
+        @Override
+        public void run() {
+          synchronized (InProcessTransport.this) {
+            notifyShutdown(localShutdownStatus);
+            notifyTerminated();
+          }
+        }
+      };
+    }
+    Attributes serverTransportAttrs = Attributes.newBuilder()
+        .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, address)
+        .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, address)
+        .build();
+    serverStreamAttributes = serverTransportListener.transportReady(serverTransportAttrs);
+    attributes = clientTransportListener.filterTransport(attributes);
+    clientTransportListener.transportReady();
+    return null;
+  }
+
+  @Override
+  public synchronized ClientStream newStream(
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+      ClientStreamTracer[] tracers) {
+    StatsTraceContext statsTraceContext =
+        StatsTraceContext.newClientContext(tracers, getAttributes(), headers);
+    if (shutdownStatus != null) {
+      return failedClientStream(statsTraceContext, shutdownStatus);
+    }
+
+    headers.put(GrpcUtil.USER_AGENT_KEY, userAgent);
+
+    if (serverMaxInboundMetadataSize != Integer.MAX_VALUE) {
+      int metadataSize = metadataSize(headers);
+      if (metadataSize > serverMaxInboundMetadataSize) {
+        // Other transports would compute a status with:
+        //   GrpcUtil.httpStatusToGrpcStatus(431 /* Request Header Fields Too Large */);
+        // However, that isn't handled specially today, so we'd leak HTTP-isms even though we're
+        // in-process. We go ahead and make a Status, which may need to be updated if
+        // statuscodes.md is updated.
+        Status status = Status.RESOURCE_EXHAUSTED.withDescription(
+            String.format(
+                Locale.US,
+                "Request metadata larger than %d: %d",
+                serverMaxInboundMetadataSize,
+                metadataSize));
+        return failedClientStream(statsTraceContext, status);
+      }
+    }
+
+    return new InProcessStream(method, headers, callOptions, authority, statsTraceContext)
+        .clientStream;
+  }
+
+  private ClientStream failedClientStream(
+      final StatsTraceContext statsTraceCtx, final Status status) {
+    return new NoopClientStream() {
+        @Override
+        public void start(ClientStreamListener listener) {
+          statsTraceCtx.clientOutboundHeaders();
+          statsTraceCtx.streamClosed(status);
+          listener.closed(status, RpcProgress.PROCESSED, new Metadata());
+        }
+      };
+  }
+
+  @Override
+  public synchronized void ping(final PingCallback callback, Executor executor) {
+    if (terminated) {
+      final Status shutdownStatus = this.shutdownStatus;
+      executor.execute(new Runnable() {
+        @Override
+        public void run() {
+          callback.onFailure(shutdownStatus);
+        }
+      });
+    } else {
+      executor.execute(new Runnable() {
+        @Override
+        public void run() {
+          callback.onSuccess(0);
+        }
+      });
+    }
+  }
+
+  @Override
+  public synchronized void shutdown(Status reason) {
+    // Can be called multiple times: once for ManagedClientTransport, once for ServerTransport.
+    if (shutdown) {
+      return;
+    }
+    shutdownStatus = reason;
+    notifyShutdown(reason);
+    if (streams.isEmpty()) {
+      notifyTerminated();
+    }
+  }
+
+  @Override
+  public synchronized void shutdown() {
+    shutdown(Status.UNAVAILABLE.withDescription("InProcessTransport shutdown by the server-side"));
+  }
+
+  @Override
+  public void shutdownNow(Status reason) {
+    checkNotNull(reason, "reason");
+    List<InProcessStream> streamsCopy;
+    synchronized (this) {
+      shutdown(reason);
+      if (terminated) {
+        return;
+      }
+      streamsCopy = new ArrayList<>(streams);
+    }
+    for (InProcessStream stream : streamsCopy) {
+      stream.clientStream.cancel(reason);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("logId", logId.getId())
+        .add("address", address)
+        .toString();
+  }
+
+  @Override
+  public InternalLogId getLogId() {
+    return logId;
+  }
+
+  @Override
+  public Attributes getAttributes() {
+    return attributes;
+  }
+
+  @Override
+  public ScheduledExecutorService getScheduledExecutorService() {
+    return serverScheduler;
+  }
+
+  @Override
+  public ListenableFuture<SocketStats> getStats() {
+    SettableFuture<SocketStats> ret = SettableFuture.create();
+    ret.set(null);
+    return ret;
+  }
+
+  private synchronized void notifyShutdown(Status s) {
+    if (shutdown) {
+      return;
+    }
+    shutdown = true;
+    clientTransportListener.transportShutdown(s, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+  }
+
+  private synchronized void notifyTerminated() {
+    if (terminated) {
+      return;
+    }
+    terminated = true;
+    if (serverScheduler != null) {
+      serverScheduler = serverSchedulerPool.returnObject(serverScheduler);
+    }
+    clientTransportListener.transportTerminated();
+    if (serverTransportListener != null) {
+      serverTransportListener.transportTerminated();
+    }
+  }
+
+  private static int metadataSize(Metadata metadata) {
+    byte[][] serialized = InternalMetadata.serialize(metadata);
+    if (serialized == null) {
+      return 0;
+    }
+    // Calculate based on SETTINGS_MAX_HEADER_LIST_SIZE in RFC 7540 §6.5.2. We could use something
+    // different, but it's "sane."
+    long size = 0;
+    for (int i = 0; i < serialized.length; i += 2) {
+      size += 32 + serialized[i].length + serialized[i + 1].length;
+    }
+    size = Math.min(size, Integer.MAX_VALUE);
+    return (int) size;
+  }
+
+  private class InProcessStream {
+    private final InProcessClientStream clientStream;
+    private final InProcessServerStream serverStream;
+    private final CallOptions callOptions;
+    private final Metadata headers;
+    private final MethodDescriptor<?, ?> method;
+    private volatile String authority;
+
+    private InProcessStream(
+        MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+        String authority , StatsTraceContext statsTraceContext) {
+      this.method = checkNotNull(method, "method");
+      this.headers = checkNotNull(headers, "headers");
+      this.callOptions = checkNotNull(callOptions, "callOptions");
+      this.authority = authority;
+      this.clientStream = new InProcessClientStream(callOptions, statsTraceContext);
+      this.serverStream = new InProcessServerStream(method, headers);
+    }
+
+    // Can be called multiple times due to races on both client and server closing at same time.
+    private void streamClosed() {
+      synchronized (InProcessTransport.this) {
+        boolean justRemovedAnElement = streams.remove(this);
+        if (GrpcUtil.shouldBeCountedForInUse(callOptions)) {
+          inUseState.updateObjectInUse(this, false);
+        }
+        if (streams.isEmpty() && justRemovedAnElement) {
+          if (shutdown) {
+            notifyTerminated();
+          }
+        }
+      }
+    }
+
+    private class InProcessServerStream implements ServerStream {
+      final StatsTraceContext statsTraceCtx;
+      // All callbacks must run in syncContext to avoid possibility of deadlock in direct executors
+      private ClientStreamListener clientStreamListener;
+      private final SynchronizationContext syncContext =
+          new SynchronizationContext(uncaughtExceptionHandler);
+      @GuardedBy("this")
+      private int clientRequested;
+      @GuardedBy("this")
+      private ArrayDeque<StreamListener.MessageProducer> clientReceiveQueue =
+          new ArrayDeque<>();
+      @GuardedBy("this")
+      private Status clientNotifyStatus;
+      @GuardedBy("this")
+      private Metadata clientNotifyTrailers;
+      // Only is intended to prevent double-close when client cancels.
+      @GuardedBy("this")
+      private boolean closed;
+      @GuardedBy("this")
+      private int outboundSeqNo;
+
+      InProcessServerStream(MethodDescriptor<?, ?> method, Metadata headers) {
+        statsTraceCtx = StatsTraceContext.newServerContext(
+            serverStreamTracerFactories, method.getFullMethodName(), headers);
+      }
+
+      private synchronized void setListener(ClientStreamListener listener) {
+        clientStreamListener = listener;
+      }
+
+      @Override
+      public void setListener(ServerStreamListener serverStreamListener) {
+        clientStream.setListener(serverStreamListener);
+      }
+
+      @Override
+      public void request(int numMessages) {
+        boolean onReady = clientStream.serverRequested(numMessages);
+        if (onReady) {
+          synchronized (this) {
+            if (!closed) {
+              syncContext.executeLater(() -> clientStreamListener.onReady());
+            }
+          }
+        }
+        syncContext.drain();
+      }
+
+      // This method is the only reason we have to synchronize field accesses.
+      /**
+       * Client requested more messages.
+       *
+       * @return whether onReady should be called on the server
+       */
+      private boolean clientRequested(int numMessages) {
+        boolean previouslyReady;
+        boolean nowReady;
+        synchronized (this) {
+          if (closed) {
+            return false;
+          }
+
+          previouslyReady = clientRequested > 0;
+          clientRequested += numMessages;
+          while (clientRequested > 0 && !clientReceiveQueue.isEmpty()) {
+            clientRequested--;
+            StreamListener.MessageProducer producer = clientReceiveQueue.poll();
+            syncContext.executeLater(() -> clientStreamListener.messagesAvailable(producer));
+          }
+
+          if (clientReceiveQueue.isEmpty() && clientNotifyStatus != null) {
+            closed = true;
+            clientStream.statsTraceCtx.clientInboundTrailers(clientNotifyTrailers);
+            clientStream.statsTraceCtx.streamClosed(clientNotifyStatus);
+            Status notifyStatus = this.clientNotifyStatus;
+            Metadata notifyTrailers = this.clientNotifyTrailers;
+            syncContext.executeLater(() ->
+                clientStreamListener.closed(notifyStatus, RpcProgress.PROCESSED, notifyTrailers));
+          }
+
+          nowReady = clientRequested > 0;
+        }
+
+        syncContext.drain();
+        return !previouslyReady && nowReady;
+      }
+
+      private void clientCancelled(Status status) {
+        internalCancel(status);
+      }
+
+      @Override
+      public void writeMessage(InputStream message) {
+        long messageLength = 0;
+        if (isEnabledSupportTracingMessageSizes) {
+          try {
+            if (assumedMessageSize != -1) {
+              messageLength = assumedMessageSize;
+            } else if (message instanceof KnownLength || message instanceof ByteArrayInputStream) {
+              messageLength = message.available();
+            } else {
+              InputStream oldMessage = message;
+              byte[] payload = ByteStreams.toByteArray(message);
+              messageLength = payload.length;
+              message = new ByteArrayInputStream(payload);
+              oldMessage.close();
+            }
+          } catch (Exception e) {
+            throw new RuntimeException("Error processing the message length", e);
+          }
+        }
+
+        synchronized (this) {
+          if (closed) {
+            return;
+          }
+          statsTraceCtx.outboundMessage(outboundSeqNo);
+          statsTraceCtx.outboundMessageSent(outboundSeqNo, -1, -1);
+          clientStream.statsTraceCtx.inboundMessage(outboundSeqNo);
+          clientStream.statsTraceCtx.inboundMessageRead(outboundSeqNo, -1, -1);
+          if (isEnabledSupportTracingMessageSizes) {
+            statsTraceCtx.outboundUncompressedSize(messageLength);
+            statsTraceCtx.outboundWireSize(messageLength);
+            // messageLength should be same at receiver's end as no actual wire is involved.
+            clientStream.statsTraceCtx.inboundUncompressedSize(messageLength);
+            clientStream.statsTraceCtx.inboundWireSize(messageLength);
+          }
+          outboundSeqNo++;
+          StreamListener.MessageProducer producer = new SingleMessageProducer(message);
+          if (clientRequested > 0) {
+            clientRequested--;
+            syncContext.executeLater(() -> clientStreamListener.messagesAvailable(producer));
+          } else {
+            clientReceiveQueue.add(producer);
+          }
+        }
+        syncContext.drain();
+      }
+
+      @Override
+      public void flush() {}
+
+      @Override
+      public synchronized boolean isReady() {
+        if (closed) {
+          return false;
+        }
+        return clientRequested > 0;
+      }
+
+      @Override
+      public void writeHeaders(Metadata headers, boolean flush) {
+        if (clientMaxInboundMetadataSize != Integer.MAX_VALUE) {
+          int metadataSize = metadataSize(headers);
+          if (metadataSize > clientMaxInboundMetadataSize) {
+            Status serverStatus = Status.CANCELLED.withDescription("Client cancelled the RPC");
+            clientStream.serverClosed(serverStatus, serverStatus);
+            // Other transports provide very little information in this case. We go ahead and make a
+            // Status, which may need to be updated if statuscodes.md is updated.
+            Status failedStatus = Status.RESOURCE_EXHAUSTED.withDescription(
+                String.format(
+                    Locale.US,
+                    "Response header metadata larger than %d: %d",
+                    clientMaxInboundMetadataSize,
+                    metadataSize));
+            notifyClientClose(failedStatus, new Metadata());
+            return;
+          }
+        }
+
+        synchronized (this) {
+          if (closed) {
+            return;
+          }
+
+          clientStream.statsTraceCtx.clientInboundHeaders(headers);
+          syncContext.executeLater(() -> clientStreamListener.headersRead(headers));
+        }
+        syncContext.drain();
+      }
+
+      @Override
+      public void close(Status status, Metadata trailers) {
+        // clientStream.serverClosed must happen before clientStreamListener.closed, otherwise
+        // clientStreamListener.closed can trigger clientStream.cancel (see code in
+        // ClientCalls.blockingUnaryCall), which may race with clientStream.serverClosed as both are
+        // calling internalCancel().
+        clientStream.serverClosed(Status.OK, status);
+
+        if (clientMaxInboundMetadataSize != Integer.MAX_VALUE) {
+          int statusSize = status.getDescription() == null ? 0 : status.getDescription().length();
+          // Go ahead and throw in the status description's length, since that could be very long.
+          int metadataSize = metadataSize(trailers) + statusSize;
+          if (metadataSize > clientMaxInboundMetadataSize) {
+            // Override the status for the client, but not the server. Transports do not guarantee
+            // notifying the server of the failure.
+
+            // Other transports provide very little information in this case. We go ahead and make a
+            // Status, which may need to be updated if statuscodes.md is updated.
+            status = Status.RESOURCE_EXHAUSTED.withDescription(
+                String.format(
+                    Locale.US,
+                    "Response header metadata larger than %d: %d",
+                    clientMaxInboundMetadataSize,
+                    metadataSize));
+            trailers = new Metadata();
+          }
+        }
+
+        notifyClientClose(status, trailers);
+      }
+
+      /** clientStream.serverClosed() must be called before this method. */
+      private void notifyClientClose(Status status, Metadata trailers) {
+        Status clientStatus = cleanStatus(status, includeCauseWithStatus);
+        synchronized (this) {
+          if (closed) {
+            return;
+          }
+          if (clientReceiveQueue.isEmpty()) {
+            closed = true;
+            clientStream.statsTraceCtx.clientInboundTrailers(trailers);
+            clientStream.statsTraceCtx.streamClosed(clientStatus);
+            syncContext.executeLater(
+                () -> clientStreamListener.closed(clientStatus, RpcProgress.PROCESSED, trailers));
+          } else {
+            clientNotifyStatus = clientStatus;
+            clientNotifyTrailers = trailers;
+          }
+        }
+        syncContext.drain();
+        streamClosed();
+      }
+
+      @Override
+      public void cancel(Status status) {
+        if (!internalCancel(Status.CANCELLED.withDescription("server cancelled stream"))) {
+          return;
+        }
+        clientStream.serverClosed(status, status);
+        streamClosed();
+      }
+
+      private boolean internalCancel(Status clientStatus) {
+        synchronized (this) {
+          if (closed) {
+            return false;
+          }
+          closed = true;
+          StreamListener.MessageProducer producer;
+          while ((producer = clientReceiveQueue.poll()) != null) {
+            InputStream message;
+            while ((message = producer.next()) != null) {
+              try {
+                message.close();
+              } catch (Throwable t) {
+                log.log(Level.WARNING, "Exception closing stream", t);
+              }
+            }
+          }
+          clientStream.statsTraceCtx.streamClosed(clientStatus);
+          syncContext.executeLater(
+              () ->
+                  clientStreamListener.closed(clientStatus, RpcProgress.PROCESSED, new Metadata()));
+        }
+        syncContext.drain();
+        return true;
+      }
+
+      @Override
+      public void setMessageCompression(boolean enable) {
+        // noop
+      }
+
+      @Override
+      public void optimizeForDirectExecutor() {}
+
+      @Override
+      public void setCompressor(Compressor compressor) {}
+
+      @Override
+      public void setDecompressor(Decompressor decompressor) {}
+
+      @Override public Attributes getAttributes() {
+        return serverStreamAttributes;
+      }
+
+      @Override
+      public String getAuthority() {
+        return InProcessStream.this.authority;
+      }
+
+      @Override
+      public StatsTraceContext statsTraceContext() {
+        return statsTraceCtx;
+      }
+
+      @Override
+      public int streamId() {
+        return -1;
+      }
+
+      @Override
+      public void setOnReadyThreshold(int numBytes) {
+        // noop
+      }
+    }
+
+    private class InProcessClientStream implements ClientStream {
+      final StatsTraceContext statsTraceCtx;
+      final CallOptions callOptions;
+      // All callbacks must run in syncContext to avoid possibility of deadlock in direct executors
+      private ServerStreamListener serverStreamListener;
+      private final SynchronizationContext syncContext =
+          new SynchronizationContext(uncaughtExceptionHandler);
+      @GuardedBy("this")
+      private int serverRequested;
+      @GuardedBy("this")
+      private ArrayDeque<StreamListener.MessageProducer> serverReceiveQueue =
+          new ArrayDeque<>();
+      @GuardedBy("this")
+      private boolean serverNotifyHalfClose;
+      // Only is intended to prevent double-close when server closes.
+      @GuardedBy("this")
+      private boolean closed;
+      @GuardedBy("this")
+      private int outboundSeqNo;
+
+      InProcessClientStream(
+          CallOptions callOptions, StatsTraceContext statsTraceContext) {
+        this.callOptions = callOptions;
+        statsTraceCtx = statsTraceContext;
+      }
+
+      private synchronized void setListener(ServerStreamListener listener) {
+        this.serverStreamListener = listener;
+      }
+
+      @Override
+      public void request(int numMessages) {
+        boolean onReady = serverStream.clientRequested(numMessages);
+        if (onReady) {
+          synchronized (this) {
+            if (!closed) {
+              syncContext.executeLater(() -> serverStreamListener.onReady());
+            }
+          }
+          syncContext.drain();
+        }
+      }
+
+      // This method is the only reason we have to synchronize field accesses.
+      /**
+       * Client requested more messages.
+       *
+       * @return whether onReady should be called on the server
+       */
+      private boolean serverRequested(int numMessages) {
+        boolean previouslyReady;
+        boolean nowReady;
+        synchronized (this) {
+          if (closed) {
+            return false;
+          }
+          previouslyReady = serverRequested > 0;
+          serverRequested += numMessages;
+
+          while (serverRequested > 0 && !serverReceiveQueue.isEmpty()) {
+            serverRequested--;
+            StreamListener.MessageProducer producer = serverReceiveQueue.poll();
+            syncContext.executeLater(() -> serverStreamListener.messagesAvailable(producer));
+          }
+
+          if (serverReceiveQueue.isEmpty() && serverNotifyHalfClose) {
+            serverNotifyHalfClose = false;
+            syncContext.executeLater(() -> serverStreamListener.halfClosed());
+          }
+          nowReady = serverRequested > 0;
+        }
+        syncContext.drain();
+        return !previouslyReady && nowReady;
+      }
+
+      private void serverClosed(Status serverListenerStatus, Status serverTracerStatus) {
+        internalCancel(serverListenerStatus, serverTracerStatus);
+      }
+
+      @Override
+      public void writeMessage(InputStream message) {
+        long messageLength = 0;
+        if (isEnabledSupportTracingMessageSizes) {
+          try {
+            if (assumedMessageSize != -1) {
+              messageLength = assumedMessageSize;
+            } else if (message instanceof KnownLength || message instanceof ByteArrayInputStream) {
+              messageLength = message.available();
+            } else {
+              InputStream oldMessage = message;
+              byte[] payload = ByteStreams.toByteArray(message);
+              messageLength = payload.length;
+              message = new ByteArrayInputStream(payload);
+              oldMessage.close();
+            }
+          } catch (Exception e) {
+            throw new RuntimeException("Error processing the message length", e);
+          }
+        }
+        synchronized (this) {
+          if (closed) {
+            return;
+          }
+          statsTraceCtx.outboundMessage(outboundSeqNo);
+          statsTraceCtx.outboundMessageSent(outboundSeqNo, -1, -1);
+          serverStream.statsTraceCtx.inboundMessage(outboundSeqNo);
+          serverStream.statsTraceCtx.inboundMessageRead(outboundSeqNo, -1, -1);
+          if (isEnabledSupportTracingMessageSizes) {
+            statsTraceCtx.outboundUncompressedSize(messageLength);
+            statsTraceCtx.outboundWireSize(messageLength);
+            // messageLength should be same at receiver's end as no actual wire is involved.
+            serverStream.statsTraceCtx.inboundUncompressedSize(messageLength);
+            serverStream.statsTraceCtx.inboundWireSize(messageLength);
+          }
+          outboundSeqNo++;
+          StreamListener.MessageProducer producer = new SingleMessageProducer(message);
+          if (serverRequested > 0) {
+            serverRequested--;
+            syncContext.executeLater(() -> serverStreamListener.messagesAvailable(producer));
+          } else {
+            serverReceiveQueue.add(producer);
+          }
+        }
+        syncContext.drain();
+      }
+
+      @Override
+      public void flush() {}
+
+      @Override
+      public synchronized boolean isReady() {
+        if (closed) {
+          return false;
+        }
+        return serverRequested > 0;
+      }
+
+      // Must be thread-safe for shutdownNow()
+      @Override
+      public void cancel(Status reason) {
+        Status serverStatus = cleanStatus(reason, includeCauseWithStatus);
+        if (!internalCancel(serverStatus, serverStatus)) {
+          return;
+        }
+        serverStream.clientCancelled(reason);
+        streamClosed();
+      }
+
+      private boolean internalCancel(
+          Status serverListenerStatus, Status serverTracerStatus) {
+        synchronized (this) {
+          if (closed) {
+            return false;
+          }
+          closed = true;
+
+          StreamListener.MessageProducer producer;
+          while ((producer = serverReceiveQueue.poll()) != null) {
+            InputStream message;
+            while ((message = producer.next()) != null) {
+              try {
+                message.close();
+              } catch (Throwable t) {
+                log.log(Level.WARNING, "Exception closing stream", t);
+              }
+            }
+          }
+          serverStream.statsTraceCtx.streamClosed(serverTracerStatus);
+          syncContext.executeLater(() -> serverStreamListener.closed(serverListenerStatus));
+        }
+        syncContext.drain();
+        return true;
+      }
+
+      @Override
+      public void halfClose() {
+        synchronized (this) {
+          if (closed) {
+            return;
+          }
+          if (serverReceiveQueue.isEmpty()) {
+            syncContext.executeLater(() -> serverStreamListener.halfClosed());
+          } else {
+            serverNotifyHalfClose = true;
+          }
+        }
+        syncContext.drain();
+      }
+
+      @Override
+      public void setMessageCompression(boolean enable) {}
+
+      @Override
+      public void setAuthority(String string) {
+        InProcessStream.this.authority = string;
+      }
+
+      @Override
+      public void start(ClientStreamListener listener) {
+        serverStream.setListener(listener);
+
+        synchronized (InProcessTransport.this) {
+          statsTraceCtx.clientOutboundHeaders();
+          streams.add(InProcessTransport.InProcessStream.this);
+          if (GrpcUtil.shouldBeCountedForInUse(callOptions)) {
+            inUseState.updateObjectInUse(InProcessTransport.InProcessStream.this, true);
+          }
+          serverTransportListener.streamCreated(serverStream, method.getFullMethodName(), headers);
+        }
+      }
+
+      @Override
+      public Attributes getAttributes() {
+        return attributes;
+      }
+
+      @Override
+      public void optimizeForDirectExecutor() {}
+
+      @Override
+      public void setCompressor(Compressor compressor) {}
+
+      @Override
+      public void setFullStreamDecompression(boolean fullStreamDecompression) {}
+
+      @Override
+      public void setDecompressorRegistry(DecompressorRegistry decompressorRegistry) {}
+
+      @Override
+      public void setMaxInboundMessageSize(int maxSize) {}
+
+      @Override
+      public void setMaxOutboundMessageSize(int maxSize) {}
+
+      @Override
+      public void setDeadline(Deadline deadline) {
+        headers.discardAll(TIMEOUT_KEY);
+        headers.put(TIMEOUT_KEY, deadline.timeRemaining(TimeUnit.NANOSECONDS));
+      }
+
+      @Override
+      public void appendTimeoutInsight(InsightBuilder insight) {
+      }
+    }
+  }
+
+  /**
+   * Returns a new status with the same code and description.
+   * If includeCauseWithStatus is true, cause is also included.
+   *
+   * <p>For InProcess transport to behave in the same way as the other transports,
+   * when exchanging statuses between client and server and vice versa,
+   * the cause should be excluded from the status.
+   * For easier debugging, the status may be optionally included.
+   */
+  private static Status cleanStatus(Status status, boolean includeCauseWithStatus) {
+    if (status == null) {
+      return null;
+    }
+    Status clientStatus = Status
+        .fromCodeValue(status.getCode().value())
+        .withDescription(status.getDescription());
+    if (includeCauseWithStatus) {
+      clientStatus = clientStatus.withCause(status.getCause());
+    }
+    return clientStatus;
+  }
+
+  private static class SingleMessageProducer implements StreamListener.MessageProducer {
+    private InputStream message;
+
+    private SingleMessageProducer(InputStream message) {
+      this.message = message;
+    }
+
+    @Nullable
+    @Override
+    public InputStream next() {
+      InputStream messageToReturn = message;
+      message = null;
+      return messageToReturn;
+    }
+  }
+}
diff --git a/inprocess/src/main/java/io/grpc/inprocess/InternalInProcessChannelBuilder.java b/inprocess/src/main/java/io/grpc/inprocess/InternalInProcessChannelBuilder.java
new file mode 100644
index 00000000000..1a017fe564c
--- /dev/null
+++ b/inprocess/src/main/java/io/grpc/inprocess/InternalInProcessChannelBuilder.java
@@ -0,0 +1,33 @@
+/*
+ * 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.inprocess;
+
+import io.grpc.Internal;
+
+/**
+ * Internal {@link InProcessChannelBuilder} accessor.  This is intended for usage internal to the
+ * gRPC team.  If you *really* think you need to use this, contact the gRPC team first.
+ */
+@Internal
+public final class InternalInProcessChannelBuilder {
+
+  public static void setStatsEnabled(InProcessChannelBuilder builder, boolean value) {
+    builder.setStatsEnabled(value);
+  }
+
+  private InternalInProcessChannelBuilder() {}
+}
diff --git a/inprocess/src/main/java/io/grpc/inprocess/InternalInProcessServerBuilder.java b/inprocess/src/main/java/io/grpc/inprocess/InternalInProcessServerBuilder.java
new file mode 100644
index 00000000000..df531707451
--- /dev/null
+++ b/inprocess/src/main/java/io/grpc/inprocess/InternalInProcessServerBuilder.java
@@ -0,0 +1,32 @@
+/*
+ * 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.inprocess;
+
+import io.grpc.Internal;
+
+/**
+ * Internal {@link InProcessServerBuilder} accessor.  This is intended for usage internal to
+ * the gRPC team.  If you *really* think you need to use this, contact the gRPC team first.
+ */
+@Internal
+public class InternalInProcessServerBuilder {
+  public static void setStatsEnabled(InProcessServerBuilder builder, boolean value) {
+    builder.setStatsEnabled(value);
+  }
+
+  private InternalInProcessServerBuilder() {}
+}
diff --git a/inprocess/src/main/java/io/grpc/inprocess/package-info.java b/inprocess/src/main/java/io/grpc/inprocess/package-info.java
new file mode 100644
index 00000000000..56887ad9c68
--- /dev/null
+++ b/inprocess/src/main/java/io/grpc/inprocess/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * The in-process transport which is for when a server is in the same process as the client.
+ */
+package io.grpc.inprocess;
diff --git a/inprocess/src/test/java/io/grpc/inprocess/AnonymousInProcessSocketAddressTest.java b/inprocess/src/test/java/io/grpc/inprocess/AnonymousInProcessSocketAddressTest.java
new file mode 100644
index 00000000000..9c1beb7dde3
--- /dev/null
+++ b/inprocess/src/test/java/io/grpc/inprocess/AnonymousInProcessSocketAddressTest.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright 2021 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.inprocess;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import com.google.common.testing.EqualsTester;
+import io.grpc.ServerStreamTracer;
+import java.io.IOException;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AnonymousInProcessSocketAddress}. */
+@RunWith(JUnit4.class)
+public class AnonymousInProcessSocketAddressTest {
+
+  @Test
+  public void defaultState() {
+    AnonymousInProcessSocketAddress addr = new AnonymousInProcessSocketAddress();
+    assertThat(addr.getServer()).isNull();
+  }
+
+  @Test
+  public void setServer() throws Exception {
+    AnonymousInProcessSocketAddress addr = new AnonymousInProcessSocketAddress();
+    InProcessServer server = createAnonymousServer();
+    addr.setServer(server);
+    assertThat(addr.getServer()).isSameInstanceAs(server);
+  }
+
+  @Test
+  public void setServerTwice() throws Exception {
+    AnonymousInProcessSocketAddress addr = new AnonymousInProcessSocketAddress();
+    InProcessServer server = createAnonymousServer();
+    addr.setServer(server);
+    try {
+      addr.setServer(server);
+      fail("Expected IOException on attempt to set server twice");
+    } catch (IOException ioe) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void clearServer() throws Exception {
+    AnonymousInProcessSocketAddress addr = new AnonymousInProcessSocketAddress();
+    InProcessServer server = createAnonymousServer();
+    addr.setServer(server);
+    addr.clearServer(server);
+    assertThat(addr.getServer()).isNull();
+  }
+
+  @Test
+  public void clearServerWrongInstance() throws Exception {
+    AnonymousInProcessSocketAddress addr = new AnonymousInProcessSocketAddress();
+    addr.setServer(createAnonymousServer());
+    try {
+      addr.clearServer(createAnonymousServer());
+      fail("Expected IllegalStateException on attempt to clear the wrong server");
+    } catch (IllegalStateException ise) {
+      // Expected.
+    }
+  }
+
+  @Test
+  public void equality() throws IOException {
+    AnonymousInProcessSocketAddress addrA = new AnonymousInProcessSocketAddress();
+    AnonymousInProcessSocketAddress addrB = new AnonymousInProcessSocketAddress();
+    AnonymousInProcessSocketAddress addrC = new AnonymousInProcessSocketAddress();
+    InProcessServer server = createAnonymousServer();
+
+    // Ensure two addresses with the same server are still distinct from each other.
+    addrA.setServer(server);
+    addrB.setServer(server);
+    new EqualsTester()
+        .addEqualityGroup(addrA)
+        .addEqualityGroup(addrB)
+        .addEqualityGroup(addrC)
+        .testEquals();
+  }
+
+  private InProcessServer createAnonymousServer() {
+    AnonymousInProcessSocketAddress unused = new AnonymousInProcessSocketAddress();
+    InProcessServerBuilder builder = InProcessServerBuilder.forAddress(unused);
+    return new InProcessServer(builder, Collections.<ServerStreamTracer.Factory>emptyList());
+  }
+}
diff --git a/inprocess/src/test/java/io/grpc/inprocess/AnonymousInProcessTransportTest.java b/inprocess/src/test/java/io/grpc/inprocess/AnonymousInProcessTransportTest.java
new file mode 100644
index 00000000000..7bf884c9ff9
--- /dev/null
+++ b/inprocess/src/test/java/io/grpc/inprocess/AnonymousInProcessTransportTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2021 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.inprocess;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ManagedClientTransport;
+import java.util.List;
+import org.junit.After;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link InProcessTransport} with an anonymous server. */
+@RunWith(JUnit4.class)
+public final class AnonymousInProcessTransportTest extends InProcessTransportTest {
+
+  private AnonymousInProcessSocketAddress address = new AnonymousInProcessSocketAddress();
+
+  @After
+  @Override
+  public void tearDown() throws InterruptedException {
+    super.tearDown();
+    assertThat(address.getServer()).isNull();
+  }
+
+  @Override
+  protected InternalServer newServer(
+      List<ServerStreamTracer.Factory> streamTracerFactories) {
+    InProcessServerBuilder builder = InProcessServerBuilder.forAddress(address)
+        .maxInboundMetadataSize(GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE);
+    return new InProcessServer(builder, streamTracerFactories);
+  }
+
+  @Override
+  protected ManagedClientTransport newClientTransport(InternalServer server) {
+    return new InProcessTransport(
+        address, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE,
+        testAuthority(server), USER_AGENT, eagAttrs(), false, -1);
+  }
+}
diff --git a/inprocess/src/test/java/io/grpc/inprocess/InProcessChannelBuilderTest.java b/inprocess/src/test/java/io/grpc/inprocess/InProcessChannelBuilderTest.java
new file mode 100644
index 00000000000..714d19cc74c
--- /dev/null
+++ b/inprocess/src/test/java/io/grpc/inprocess/InProcessChannelBuilderTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2018 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.inprocess;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.internal.GrpcUtil.TIMER_SERVICE;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.SharedResourceHolder;
+import java.util.concurrent.ScheduledExecutorService;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link InProcessChannelBuilder}.
+ */
+@RunWith(JUnit4.class)
+public class InProcessChannelBuilderTest {
+  @Test
+  public void scheduledExecutorService_default() {
+    InProcessChannelBuilder builder = InProcessChannelBuilder.forName("foo");
+    ClientTransportFactory clientTransportFactory = builder.buildTransportFactory();
+    assertSame(
+        SharedResourceHolder.get(TIMER_SERVICE),
+        clientTransportFactory.getScheduledExecutorService());
+
+    SharedResourceHolder.release(
+        TIMER_SERVICE, clientTransportFactory.getScheduledExecutorService());
+    clientTransportFactory.close();
+  }
+
+  @Test
+  public void scheduledExecutorService_custom() {
+    InProcessChannelBuilder builder = InProcessChannelBuilder.forName("foo");
+    ScheduledExecutorService scheduledExecutorService =
+        new FakeClock().getScheduledExecutorService();
+
+    InProcessChannelBuilder builder1 = builder.scheduledExecutorService(scheduledExecutorService);
+    assertSame(builder, builder1);
+
+    ClientTransportFactory clientTransportFactory = builder1.buildTransportFactory();
+
+    assertSame(scheduledExecutorService, clientTransportFactory.getScheduledExecutorService());
+
+    clientTransportFactory.close();
+  }
+
+  @Test
+  public void transportFactoryDoesNotSupportSwapChannelCreds() {
+    InProcessChannelBuilder builder = InProcessChannelBuilder.forName("foo");
+    ClientTransportFactory transportFactory = builder.buildTransportFactory();
+    assertThat(transportFactory.swapChannelCredentials(mock(ChannelCredentials.class))).isNull();
+  }
+}
diff --git a/inprocess/src/test/java/io/grpc/inprocess/InProcessClientTransportFactoryTest.java b/inprocess/src/test/java/io/grpc/inprocess/InProcessClientTransportFactoryTest.java
new file mode 100644
index 00000000000..1629d741730
--- /dev/null
+++ b/inprocess/src/test/java/io/grpc/inprocess/InProcessClientTransportFactoryTest.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2016 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.inprocess;
+
+import io.grpc.internal.AbstractClientTransportFactoryTest;
+import io.grpc.internal.ClientTransportFactory;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class InProcessClientTransportFactoryTest extends AbstractClientTransportFactoryTest {
+
+  @Override
+  protected ClientTransportFactory newClientTransportFactory() {
+    return InProcessChannelBuilder.forName("test-transport").buildTransportFactory();
+  }
+}
diff --git a/inprocess/src/test/java/io/grpc/inprocess/InProcessServerBuilderTest.java b/inprocess/src/test/java/io/grpc/inprocess/InProcessServerBuilderTest.java
new file mode 100644
index 00000000000..6095e29be77
--- /dev/null
+++ b/inprocess/src/test/java/io/grpc/inprocess/InProcessServerBuilderTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2018 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.inprocess;
+
+import static io.grpc.internal.GrpcUtil.TIMER_SERVICE;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourcePool;
+import java.util.ArrayList;
+import java.util.concurrent.ScheduledExecutorService;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link InProcessServerBuilder}.
+ */
+@RunWith(JUnit4.class)
+public class InProcessServerBuilderTest {
+
+  @Test
+  public void generateName() {
+    String name1 = InProcessServerBuilder.generateName();
+    assertNotNull(name1);
+    assertFalse(name1.isEmpty());
+
+    String name2 = InProcessServerBuilder.generateName();
+    assertNotNull(name2);
+    assertFalse(name2.isEmpty());
+
+    assertNotEquals(name1, name2);
+  }
+
+  @Test
+  public void scheduledExecutorService_default() {
+    InProcessServerBuilder builder = InProcessServerBuilder.forName("foo");
+    InProcessServer server =
+        builder.buildTransportServers(new ArrayList<ServerStreamTracer.Factory>());
+
+    ObjectPool<ScheduledExecutorService> scheduledExecutorServicePool =
+        server.getScheduledExecutorServicePool();
+    ObjectPool<ScheduledExecutorService> expectedPool =
+        SharedResourcePool.forResource(TIMER_SERVICE);
+
+    ScheduledExecutorService expected = expectedPool.getObject();
+    ScheduledExecutorService actual = scheduledExecutorServicePool.getObject();
+    assertSame(expected, actual);
+
+    expectedPool.returnObject(expected);
+    scheduledExecutorServicePool.returnObject(actual);
+  }
+
+  @Test
+  public void scheduledExecutorService_custom() {
+    InProcessServerBuilder builder = InProcessServerBuilder.forName("foo");
+    ScheduledExecutorService scheduledExecutorService =
+        new FakeClock().getScheduledExecutorService();
+
+    InProcessServerBuilder builder1 = builder.scheduledExecutorService(scheduledExecutorService);
+    assertSame(builder, builder1);
+
+    InProcessServer server =
+        builder1.buildTransportServers(new ArrayList<ServerStreamTracer.Factory>());
+    ObjectPool<ScheduledExecutorService> scheduledExecutorServicePool =
+        server.getScheduledExecutorServicePool();
+
+    assertSame(scheduledExecutorService, scheduledExecutorServicePool.getObject());
+
+    scheduledExecutorServicePool.returnObject(scheduledExecutorService);
+  }
+}
diff --git a/inprocess/src/test/java/io/grpc/inprocess/InProcessServerTest.java b/inprocess/src/test/java/io/grpc/inprocess/InProcessServerTest.java
new file mode 100644
index 00000000000..541c4f69857
--- /dev/null
+++ b/inprocess/src/test/java/io/grpc/inprocess/InProcessServerTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2016 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.inprocess;
+
+import com.google.common.truth.Truth;
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.ServerListener;
+import io.grpc.internal.ServerTransport;
+import io.grpc.internal.ServerTransportListener;
+import java.util.Collections;
+import java.util.concurrent.ScheduledExecutorService;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class InProcessServerTest {
+  private InProcessServerBuilder builder = InProcessServerBuilder.forName("name");
+
+  @Test
+  public void getPort_notStarted() throws Exception {
+    InProcessServer s =
+        new InProcessServer(builder, Collections.<ServerStreamTracer.Factory>emptyList());
+
+    Truth.assertThat(s.getListenSocketAddress()).isEqualTo(new InProcessSocketAddress("name"));
+  }
+
+  @Test
+  public void serverHoldsRefToScheduler() throws Exception {
+    final ScheduledExecutorService ses = new FakeClock().getScheduledExecutorService();
+    class RefCountingObjectPool implements ObjectPool<ScheduledExecutorService> {
+      private int count;
+
+      @Override
+      public ScheduledExecutorService getObject() {
+        count++;
+        return ses;
+      }
+
+      @Override
+      public ScheduledExecutorService returnObject(Object returned) {
+        count--;
+        return null;
+      }
+    }
+
+    RefCountingObjectPool pool = new RefCountingObjectPool();
+    builder.schedulerPool = pool;
+    InProcessServer s =
+        new InProcessServer(builder, Collections.<ServerStreamTracer.Factory>emptyList());
+    Truth.assertThat(pool.count).isEqualTo(0);
+    s.start(new ServerListener() {
+      @Override public ServerTransportListener transportCreated(ServerTransport transport) {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override public void serverShutdown() {}
+    });
+    Truth.assertThat(pool.count).isEqualTo(1);
+    s.shutdown();
+    Truth.assertThat(pool.count).isEqualTo(0);
+  }
+}
+
diff --git a/inprocess/src/test/java/io/grpc/inprocess/InProcessSocketAddressTest.java b/inprocess/src/test/java/io/grpc/inprocess/InProcessSocketAddressTest.java
new file mode 100644
index 00000000000..fe1df95b1d3
--- /dev/null
+++ b/inprocess/src/test/java/io/grpc/inprocess/InProcessSocketAddressTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2018 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.inprocess;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.testing.EqualsTester;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class InProcessSocketAddressTest {
+
+  @Test
+  public void equal() {
+    new EqualsTester()
+        .addEqualityGroup(
+            new InProcessSocketAddress("a"),
+            new InProcessSocketAddress(new String("a")))
+        .addEqualityGroup(
+            new InProcessSocketAddress("z"),
+            new InProcessSocketAddress("z"))
+        .addEqualityGroup(
+            new InProcessSocketAddress(""),
+            new InProcessSocketAddress("")
+        )
+        .testEquals();
+  }
+
+  @Test
+  public void hash() {
+    assertThat(new InProcessSocketAddress("a").hashCode())
+        .isEqualTo(new InProcessSocketAddress(new String("a")).hashCode());
+  }
+}
diff --git a/inprocess/src/test/java/io/grpc/inprocess/InProcessTransportTest.java b/inprocess/src/test/java/io/grpc/inprocess/InProcessTransportTest.java
new file mode 100644
index 00000000000..d2220e05114
--- /dev/null
+++ b/inprocess/src/test/java/io/grpc/inprocess/InProcessTransportTest.java
@@ -0,0 +1,248 @@
+/*
+ * Copyright 2016 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.inprocess;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.grpc.CallOptions;
+import io.grpc.ClientCall;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Server;
+import io.grpc.ServerCall;
+import io.grpc.ServerCall.Listener;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.StatusRuntimeException;
+import io.grpc.internal.AbstractTransportTest;
+import io.grpc.internal.ClientStream;
+import io.grpc.internal.ClientStreamListenerBase;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ManagedClientTransport;
+import io.grpc.internal.MockServerTransportListener;
+import io.grpc.internal.MockServerTransportListener.StreamCreation;
+import io.grpc.internal.ServerStream;
+import io.grpc.internal.ServerStreamListenerBase;
+import io.grpc.internal.testing.TestStreamTracer;
+import io.grpc.stub.ClientCalls;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.TestMethodDescriptors;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import org.junit.Assert;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link InProcessTransport}. */
+@RunWith(JUnit4.class)
+public class InProcessTransportTest extends AbstractTransportTest {
+  private static final String TRANSPORT_NAME = "perfect-for-testing";
+  private static final String AUTHORITY = "a-testing-authority";
+  protected static final String USER_AGENT = "a-testing-user-agent";
+  private static final int TIMEOUT_MS = 5000;
+  private static final long TEST_MESSAGE_LENGTH = 100;
+
+  @Rule
+  public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
+
+  @Override
+  protected InternalServer newServer(
+      int port, List<ServerStreamTracer.Factory> streamTracerFactories) {
+    return newServer(streamTracerFactories);
+  }
+
+  @Override
+  protected InternalServer newServer(
+      List<ServerStreamTracer.Factory> streamTracerFactories) {
+    InProcessServerBuilder builder = InProcessServerBuilder
+        .forName(TRANSPORT_NAME)
+        .maxInboundMetadataSize(GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE);
+    return new InProcessServer(builder, streamTracerFactories);
+  }
+
+  @Override
+  protected String testAuthority(InternalServer server) {
+    return AUTHORITY;
+  }
+
+  @Override
+  protected ManagedClientTransport newClientTransport(InternalServer server) {
+    return new InProcessTransport(
+        new InProcessSocketAddress(TRANSPORT_NAME), GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE,
+        testAuthority(server), USER_AGENT, eagAttrs(), false, -1);
+  }
+
+  private ManagedClientTransport newClientTransportWithAssumedMessageSize(InternalServer server) {
+    return new InProcessTransport(
+        new InProcessSocketAddress(TRANSPORT_NAME), GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE,
+        testAuthority(server), USER_AGENT, eagAttrs(), false, TEST_MESSAGE_LENGTH);
+  }
+
+  @Test
+  @Ignore
+  @Override
+  public void socketStats() throws Exception {
+    // test does not apply to in-process
+  }
+
+  @Test
+  public void causeShouldBePropagatedWithStatus() throws Exception {
+    server = null;
+    String failingServerName = "server_foo";
+    String serviceFoo = "service_foo";
+    final Status s = Status.INTERNAL.withCause(new Throwable("failing server exception"));
+    ServerServiceDefinition definition = ServerServiceDefinition.builder(serviceFoo)
+        .addMethod(TestMethodDescriptors.voidMethod(), new ServerCallHandler<Void, Void>() {
+          @Override
+          public ServerCall.Listener<Void> startCall(
+              ServerCall<Void, Void> call, Metadata headers) {
+            call.close(s, new Metadata());
+            return new ServerCall.Listener<Void>() {};
+          }
+        })
+        .build();
+    Server failingServer = InProcessServerBuilder
+        .forName(failingServerName)
+        .addService(definition)
+        .directExecutor()
+        .build()
+        .start();
+    grpcCleanupRule.register(failingServer);
+    ManagedChannel channel = InProcessChannelBuilder
+        .forName(failingServerName)
+        .propagateCauseWithStatus(true)
+        .build();
+    grpcCleanupRule.register(channel);
+    try {
+      ClientCalls.blockingUnaryCall(channel, TestMethodDescriptors.voidMethod(),
+          CallOptions.DEFAULT, null);
+      fail("exception should have been thrown");
+    } catch (StatusRuntimeException e) {
+      // When propagateCauseWithStatus is true, the cause should be sent forward
+      assertEquals(s.getCause(), e.getCause());
+    }
+  }
+
+  @Test
+  public void methodNotFound() throws Exception {
+    server = null;
+    ServerServiceDefinition definition = ServerServiceDefinition.builder("service_foo")
+            .addMethod(TestMethodDescriptors.voidMethod(), new ServerCallHandler<Void, Void>() {
+              @Override
+              public Listener<Void> startCall(ServerCall<Void, Void> call, Metadata headers) {
+                return null;
+              }
+            })
+            .build();
+    Server failingServer = InProcessServerBuilder
+            .forName("nocall-service")
+            .addService(definition)
+            .directExecutor()
+            .build()
+            .start();
+    grpcCleanupRule.register(failingServer);
+    ManagedChannel channel = InProcessChannelBuilder
+            .forName("nocall-service")
+            .propagateCauseWithStatus(true)
+            .build();
+    grpcCleanupRule.register(channel);
+    MethodDescriptor<Void, Void> nonMatchMethod =
+            MethodDescriptor.<Void, Void>newBuilder()
+                    .setType(MethodDescriptor.MethodType.UNKNOWN)
+                    .setFullMethodName("Waiter/serve")
+                    .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+                    .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
+                    .build();
+    ClientCall<Void,Void> call = channel.newCall(nonMatchMethod, CallOptions.DEFAULT);
+    try {
+      ClientCalls.futureUnaryCall(call, null).get(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+      fail("Call should fail.");
+    } catch (ExecutionException ex) {
+      StatusRuntimeException s = (StatusRuntimeException)ex.getCause();
+      assertEquals(Code.UNIMPLEMENTED, s.getStatus().getCode());
+    }
+  }
+
+  @Test
+  public void basicStreamInProcess() throws Exception {
+    InProcessServerBuilder builder = InProcessServerBuilder
+        .forName(TRANSPORT_NAME)
+        .maxInboundMetadataSize(GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE);
+    server = new InProcessServer(builder, Arrays.asList(serverStreamTracerFactory));
+    server.start(serverListener);
+    client = newClientTransportWithAssumedMessageSize(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener
+        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+    // Set up client stream
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), CallOptions.DEFAULT, tracers);
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation
+        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+    ServerStreamListenerBase serverStreamListener = serverStreamCreation.listener;
+    serverStream.request(1);
+    assertTrue(clientStream.isReady());
+    // Send message from client to server
+    clientStream.writeMessage(methodDescriptor.streamRequest("Hello from client"));
+    clientStream.flush();
+    // Verify server received the message and check its size
+    InputStream message =
+        serverStreamListener.messageQueue.poll(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertEquals("Hello from client", methodDescriptor.parseRequest(message));
+    message.close();
+    clientStream.halfClose();
+    assertAssumedMessageSize(clientStreamTracer1, serverStreamTracer1);
+
+    clientStream.request(1);
+    assertTrue(serverStream.isReady());
+    serverStream.writeMessage(methodDescriptor.streamResponse("Hi from server"));
+    serverStream.flush();
+    message = clientStreamListener.messageQueue.poll(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    assertEquals("Hi from server", methodDescriptor.parseResponse(message));
+    assertAssumedMessageSize(serverStreamTracer1, clientStreamTracer1);
+    message.close();
+    Status status = Status.OK.withDescription("That was normal");
+    serverStream.close(status, new Metadata());
+  }
+
+  private void assertAssumedMessageSize(
+      TestStreamTracer streamTracerSender, TestStreamTracer streamTracerReceiver) {
+    if (isEnabledSupportTracingMessageSizes()) {
+      Assert.assertEquals(TEST_MESSAGE_LENGTH, streamTracerSender.getOutboundWireSize());
+      Assert.assertEquals(TEST_MESSAGE_LENGTH, streamTracerSender.getOutboundUncompressedSize());
+      Assert.assertEquals(TEST_MESSAGE_LENGTH, streamTracerReceiver.getInboundWireSize());
+      Assert.assertEquals(TEST_MESSAGE_LENGTH, streamTracerReceiver.getInboundUncompressedSize());
+    }
+  }
+}
diff --git a/interop-testing/build.gradle b/interop-testing/build.gradle
index 29e28355c42..5160759460c 100644
--- a/interop-testing/build.gradle
+++ b/interop-testing/build.gradle
@@ -1,85 +1,184 @@
-apply plugin: 'application'
+plugins {
+    id "application"
+    id "java-library"
+    id "maven-publish"
+
+    id "com.google.protobuf"
+    id "ru.vyarus.animalsniffer"
+}
 
 description = "gRPC: Integration Testing"
-startScripts.enabled = false
 
 dependencies {
-    compile project(':grpc-auth'),
-            project(':grpc-core'),
+    implementation project(path: ':grpc-alts', configuration: 'shadow'),
+            project(':grpc-auth'),
+            project(':grpc-census'),
+            project(':grpc-opentelemetry'),
+            project(':grpc-gcp-csm-observability'),
             project(':grpc-netty'),
             project(':grpc-okhttp'),
-            project(':grpc-protobuf'),
-            project(':grpc-stub'),
+            project(':grpc-services'),
             project(':grpc-testing'),
-            project(':grpc-testing-proto'),
-            libraries.junit,
-            libraries.mockito,
-            libraries.netty_tcnative,
-            libraries.oauth_client
-}
-
-test {
-    // For the automated tests, use Jetty ALPN.
-    jvmArgs "-javaagent:" + configurations.alpnagent.asPath
-}
+            project(':grpc-protobuf-lite'),
+            project(path: ':grpc-xds', configuration: 'shadow'),
+            libraries.hdrhistogram,
+            libraries.truth,
+            libraries.opencensus.contrib.grpc.metrics,
+            libraries.google.auth.oauth2Http,
+            libraries.opentelemetry.sdk.extension.autoconfigure,
+            libraries.guava.jre // Fix checkUpperBoundDeps using -android
+    api project(':grpc-api'),
+            project(':grpc-stub'),
+            project(':grpc-protobuf'),
+            libraries.junit
+    // TODO(sergiitk): replace with com.google.cloud:google-cloud-logging
+    // Used instead of google-cloud-logging because it's failing
+    // due to a circular dependency on grpc.
+    // https://cloud.google.com/logging/docs/setup/java#the_javautillogging_handler
+    // Error example: "java.util.logging.ErrorManager: 1"
+    // Latest failing version com.google.cloud:google-cloud-logging:2.1.2
+    runtimeOnly group: 'io.github.devatherock', name: 'jul-jsonformatter', version: '1.1.0'
+    runtimeOnly libraries.opencensus.impl,
+            libraries.netty.tcnative,
+            libraries.netty.tcnative.classes,
+            libraries.opentelemetry.exporter.prometheus, // For xds interop client
+            project(':grpc-googleapis'),
+            project(':grpc-grpclb'),
+            project(':grpc-rls')
+    testImplementation testFixtures(project(':grpc-api')),
+            testFixtures(project(':grpc-core')),
+            project(':grpc-inprocess'),
+            project(':grpc-core'),
+            libraries.mockito.core,
+            libraries.okhttp
 
-// The application plugin uses the distribution plugin and configures the jars to be
-// placed into the "lib" folder. Since we don't include netty_tcnative as a dependency,
-// we have to manually copy it into the lib folder so that it's available to the scripts.
-distributions {
-    main {
-        contents {
-            from(configurations.tcnative) {
-                into "lib"
-            }
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
         }
     }
 }
 
+configureProtoCompilation()
+
+import net.ltgt.gradle.errorprone.CheckSeverity
+
+tasks.named("compileJava").configure {
+    // This isn't a library; it can use beta APIs
+    options.errorprone.check("BetaApi", CheckSeverity.OFF)
+}
+
 // For the generated scripts, use Netty tcnative (i.e. OpenSSL).
 // Note that OkHttp currently only supports ALPN, so OpenSSL version >= 1.0.2 is required.
 
-task test_client(type: CreateStartScripts) {
-    mainClassName = "io.grpc.testing.integration.TestServiceClient"
+def test_client = tasks.register("test_client", CreateStartScripts) {
+    mainClass = "io.grpc.testing.integration.TestServiceClient"
     applicationName = "test-client"
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = jar.outputs.files + configurations.runtime + configurations.tcnative
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
 }
 
-task test_server(type: CreateStartScripts) {
-    mainClassName = "io.grpc.testing.integration.TestServiceServer"
+def test_server = tasks.register("test_server", CreateStartScripts) {
+    mainClass = "io.grpc.testing.integration.TestServiceServer"
     applicationName = "test-server"
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = jar.outputs.files + configurations.runtime + configurations.tcnative
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
 }
 
-task reconnect_test_client(type: CreateStartScripts) {
-    mainClassName = "io.grpc.testing.integration.ReconnectTestClient"
+def reconnect_test_client = tasks.register("reconnect_test_client", CreateStartScripts) {
+    mainClass = "io.grpc.testing.integration.ReconnectTestClient"
     applicationName = "reconnect-test-client"
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = jar.outputs.files + configurations.runtime + configurations.tcnative
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
 }
 
-task stresstest_client(type: CreateStartScripts) {
-    mainClassName = "io.grpc.testing.integration.StressTestClient"
+def stresstest_client = tasks.register("stresstest_client", CreateStartScripts) {
+    mainClass = "io.grpc.testing.integration.StressTestClient"
     applicationName = "stresstest-client"
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = jar.outputs.files + configurations.runtime + configurations.tcnative
-    defaultJvmOpts = ["-verbose:gc", "-XX:+PrintFlagsFinal"]
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+    defaultJvmOpts = [
+        "-verbose:gc",
+        "-XX:+PrintFlagsFinal"
+    ]
 }
 
-task http2_client(type: CreateStartScripts) {
-    mainClassName = "io.grpc.testing.integration.Http2Client"
+def http2_client = tasks.register("http2_client", CreateStartScripts) {
+    mainClass = "io.grpc.testing.integration.Http2Client"
     applicationName = "http2-client"
-    outputDir = new File(project.buildDir, 'tmp')
-    classpath = jar.outputs.files + configurations.runtime
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
 }
 
-applicationDistribution.into("bin") {
-    from(test_client)
-    from(test_server)
-    from(reconnect_test_client)
-    from(stresstest_client)
-    from(http2_client)
-    fileMode = 0755
+def grpclb_long_lived_affinity_test_client = tasks.register("grpclb_long_lived_affinity_test_client", CreateStartScripts) {
+    mainClass = "io.grpc.testing.integration.GrpclbLongLivedAffinityTestClient"
+    applicationName = "grpclb-long-lived-affinity-test-client"
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+    defaultJvmOpts = [
+        "-Dio.grpc.internal.DnsNameResolverProvider.enable_service_config=true"
+    ]
+}
+
+def grpclb_fallback_test_client = tasks.register("grpclb_fallback_test_client", CreateStartScripts) {
+    mainClass = "io.grpc.testing.integration.GrpclbFallbackTestClient"
+    applicationName = "grpclb-fallback-test-client"
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+    defaultJvmOpts = [
+        "-Dio.grpc.internal.DnsNameResolverProvider.enable_service_config=true"
+    ]
+}
+
+def xds_test_client = tasks.register("xds_test_client", CreateStartScripts) {
+    mainClass = "io.grpc.testing.integration.XdsTestClient"
+    applicationName = "xds-test-client"
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+def xds_test_server = tasks.register("xds_test_server", CreateStartScripts) {
+    mainClass = "io.grpc.testing.integration.XdsTestServer"
+    applicationName = "xds-test-server"
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+def xds_federation_test_client = tasks.register("xds_federation_test_client", CreateStartScripts) {
+    mainClass = "io.grpc.testing.integration.XdsFederationTestClient"
+    applicationName = "xds-federation-test-client"
+    outputDir = new File(project.buildDir, 'tmp/scripts/' + name)
+    classpath = startScripts.classpath
+}
+
+application {
+    applicationDistribution.into("bin") {
+        from(test_client)
+        from(test_server)
+        from(reconnect_test_client)
+        from(stresstest_client)
+        from(http2_client)
+        from(grpclb_long_lived_affinity_test_client)
+        from(grpclb_fallback_test_client)
+        from(xds_test_client)
+        from(xds_test_server)
+        from(xds_federation_test_client)
+        filePermissions {
+            unix(0755)
+        }
+    }
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            artifact distZip
+            artifact distTar
+        }
+    }
 }
diff --git a/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java
new file mode 100644
index 00000000000..22c64d12f33
--- /dev/null
+++ b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/LoadBalancerStatsServiceGrpc.java
@@ -0,0 +1,461 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A service used to obtain stats for verifying LB behavior.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class LoadBalancerStatsServiceGrpc {
+
+  private LoadBalancerStatsServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.LoadBalancerStatsService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerStatsRequest,
+      io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> getGetClientStatsMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetClientStats",
+      requestType = io.grpc.testing.integration.Messages.LoadBalancerStatsRequest.class,
+      responseType = io.grpc.testing.integration.Messages.LoadBalancerStatsResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerStatsRequest,
+      io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> getGetClientStatsMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerStatsRequest, io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> getGetClientStatsMethod;
+    if ((getGetClientStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientStatsMethod) == null) {
+      synchronized (LoadBalancerStatsServiceGrpc.class) {
+        if ((getGetClientStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientStatsMethod) == null) {
+          LoadBalancerStatsServiceGrpc.getGetClientStatsMethod = getGetClientStatsMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.LoadBalancerStatsRequest, io.grpc.testing.integration.Messages.LoadBalancerStatsResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetClientStats"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.LoadBalancerStatsRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.LoadBalancerStatsResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new LoadBalancerStatsServiceMethodDescriptorSupplier("GetClientStats"))
+              .build();
+        }
+      }
+    }
+    return getGetClientStatsMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest,
+      io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> getGetClientAccumulatedStatsMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetClientAccumulatedStats",
+      requestType = io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest.class,
+      responseType = io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest,
+      io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> getGetClientAccumulatedStatsMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest, io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> getGetClientAccumulatedStatsMethod;
+    if ((getGetClientAccumulatedStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientAccumulatedStatsMethod) == null) {
+      synchronized (LoadBalancerStatsServiceGrpc.class) {
+        if ((getGetClientAccumulatedStatsMethod = LoadBalancerStatsServiceGrpc.getGetClientAccumulatedStatsMethod) == null) {
+          LoadBalancerStatsServiceGrpc.getGetClientAccumulatedStatsMethod = getGetClientAccumulatedStatsMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest, io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetClientAccumulatedStats"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new LoadBalancerStatsServiceMethodDescriptorSupplier("GetClientAccumulatedStats"))
+              .build();
+        }
+      }
+    }
+    return getGetClientAccumulatedStatsMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceStub>() {
+        @java.lang.Override
+        public LoadBalancerStatsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerStatsServiceStub(channel, callOptions);
+        }
+      };
+    return LoadBalancerStatsServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static LoadBalancerStatsServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public LoadBalancerStatsServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerStatsServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return LoadBalancerStatsServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static LoadBalancerStatsServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceBlockingStub>() {
+        @java.lang.Override
+        public LoadBalancerStatsServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerStatsServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return LoadBalancerStatsServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static LoadBalancerStatsServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadBalancerStatsServiceFutureStub>() {
+        @java.lang.Override
+        public LoadBalancerStatsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadBalancerStatsServiceFutureStub(channel, callOptions);
+        }
+      };
+    return LoadBalancerStatsServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    default void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetClientStatsMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    default void getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetClientAccumulatedStatsMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static abstract class LoadBalancerStatsServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return LoadBalancerStatsServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static final class LoadBalancerStatsServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<LoadBalancerStatsServiceStub> {
+    private LoadBalancerStatsServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerStatsServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerStatsServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    public void getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetClientStatsMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    public void getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetClientAccumulatedStatsMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static final class LoadBalancerStatsServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<LoadBalancerStatsServiceBlockingV2Stub> {
+    private LoadBalancerStatsServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerStatsServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerStatsServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.LoadBalancerStatsResponse getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetClientStatsMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetClientAccumulatedStatsMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static final class LoadBalancerStatsServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<LoadBalancerStatsServiceBlockingStub> {
+    private LoadBalancerStatsServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerStatsServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerStatsServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.LoadBalancerStatsResponse getClientStats(io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetClientStatsMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse getClientAccumulatedStats(io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetClientAccumulatedStatsMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service LoadBalancerStatsService.
+   * <pre>
+   * A service used to obtain stats for verifying LB behavior.
+   * </pre>
+   */
+  public static final class LoadBalancerStatsServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<LoadBalancerStatsServiceFutureStub> {
+    private LoadBalancerStatsServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadBalancerStatsServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadBalancerStatsServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets the backend distribution for RPCs sent by a test client.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.LoadBalancerStatsResponse> getClientStats(
+        io.grpc.testing.integration.Messages.LoadBalancerStatsRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetClientStatsMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * Gets the accumulated stats for RPCs sent by a test client.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse> getClientAccumulatedStats(
+        io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetClientAccumulatedStatsMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_GET_CLIENT_STATS = 0;
+  private static final int METHODID_GET_CLIENT_ACCUMULATED_STATS = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_GET_CLIENT_STATS:
+          serviceImpl.getClientStats((io.grpc.testing.integration.Messages.LoadBalancerStatsRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerStatsResponse>) responseObserver);
+          break;
+        case METHODID_GET_CLIENT_ACCUMULATED_STATS:
+          serviceImpl.getClientAccumulatedStats((io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getGetClientStatsMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.LoadBalancerStatsRequest,
+              io.grpc.testing.integration.Messages.LoadBalancerStatsResponse>(
+                service, METHODID_GET_CLIENT_STATS)))
+        .addMethod(
+          getGetClientAccumulatedStatsMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest,
+              io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse>(
+                service, METHODID_GET_CLIENT_ACCUMULATED_STATS)))
+        .build();
+  }
+
+  private static abstract class LoadBalancerStatsServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    LoadBalancerStatsServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.testing.integration.Test.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("LoadBalancerStatsService");
+    }
+  }
+
+  private static final class LoadBalancerStatsServiceFileDescriptorSupplier
+      extends LoadBalancerStatsServiceBaseDescriptorSupplier {
+    LoadBalancerStatsServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class LoadBalancerStatsServiceMethodDescriptorSupplier
+      extends LoadBalancerStatsServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    LoadBalancerStatsServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (LoadBalancerStatsServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new LoadBalancerStatsServiceFileDescriptorSupplier())
+              .addMethod(getGetClientStatsMethod())
+              .addMethod(getGetClientAccumulatedStatsMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java
new file mode 100644
index 00000000000..980dee010f1
--- /dev/null
+++ b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java
@@ -0,0 +1,436 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class MetricsServiceGrpc {
+
+  private MetricsServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.MetricsService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.EmptyMessage,
+      io.grpc.testing.integration.Metrics.GaugeResponse> getGetAllGaugesMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetAllGauges",
+      requestType = io.grpc.testing.integration.Metrics.EmptyMessage.class,
+      responseType = io.grpc.testing.integration.Metrics.GaugeResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.EmptyMessage,
+      io.grpc.testing.integration.Metrics.GaugeResponse> getGetAllGaugesMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.EmptyMessage, io.grpc.testing.integration.Metrics.GaugeResponse> getGetAllGaugesMethod;
+    if ((getGetAllGaugesMethod = MetricsServiceGrpc.getGetAllGaugesMethod) == null) {
+      synchronized (MetricsServiceGrpc.class) {
+        if ((getGetAllGaugesMethod = MetricsServiceGrpc.getGetAllGaugesMethod) == null) {
+          MetricsServiceGrpc.getGetAllGaugesMethod = getGetAllGaugesMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Metrics.EmptyMessage, io.grpc.testing.integration.Metrics.GaugeResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetAllGauges"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Metrics.EmptyMessage.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new MetricsServiceMethodDescriptorSupplier("GetAllGauges"))
+              .build();
+        }
+      }
+    }
+    return getGetAllGaugesMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.GaugeRequest,
+      io.grpc.testing.integration.Metrics.GaugeResponse> getGetGaugeMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetGauge",
+      requestType = io.grpc.testing.integration.Metrics.GaugeRequest.class,
+      responseType = io.grpc.testing.integration.Metrics.GaugeResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.GaugeRequest,
+      io.grpc.testing.integration.Metrics.GaugeResponse> getGetGaugeMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.GaugeRequest, io.grpc.testing.integration.Metrics.GaugeResponse> getGetGaugeMethod;
+    if ((getGetGaugeMethod = MetricsServiceGrpc.getGetGaugeMethod) == null) {
+      synchronized (MetricsServiceGrpc.class) {
+        if ((getGetGaugeMethod = MetricsServiceGrpc.getGetGaugeMethod) == null) {
+          MetricsServiceGrpc.getGetGaugeMethod = getGetGaugeMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Metrics.GaugeRequest, io.grpc.testing.integration.Metrics.GaugeResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetGauge"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Metrics.GaugeRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new MetricsServiceMethodDescriptorSupplier("GetGauge"))
+              .build();
+        }
+      }
+    }
+    return getGetGaugeMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static MetricsServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<MetricsServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<MetricsServiceStub>() {
+        @java.lang.Override
+        public MetricsServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new MetricsServiceStub(channel, callOptions);
+        }
+      };
+    return MetricsServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static MetricsServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<MetricsServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<MetricsServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public MetricsServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new MetricsServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return MetricsServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static MetricsServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<MetricsServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<MetricsServiceBlockingStub>() {
+        @java.lang.Override
+        public MetricsServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new MetricsServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return MetricsServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static MetricsServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<MetricsServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<MetricsServiceFutureStub>() {
+        @java.lang.Override
+        public MetricsServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new MetricsServiceFutureStub(channel, callOptions);
+        }
+      };
+    return MetricsServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     * </pre>
+     */
+    default void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetAllGaugesMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    default void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetGaugeMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service MetricsService.
+   */
+  public static abstract class MetricsServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return MetricsServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service MetricsService.
+   */
+  public static final class MetricsServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<MetricsServiceStub> {
+    private MetricsServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected MetricsServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new MetricsServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     * </pre>
+     */
+    public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getGetAllGaugesMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetGaugeMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service MetricsService.
+   */
+  public static final class MetricsServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<MetricsServiceBlockingV2Stub> {
+    private MetricsServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected MetricsServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new MetricsServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<?, io.grpc.testing.integration.Metrics.GaugeResponse>
+        getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request) {
+      return io.grpc.stub.ClientCalls.blockingV2ServerStreamingCall(
+          getChannel(), getGetAllGaugesMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetGaugeMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service MetricsService.
+   */
+  public static final class MetricsServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<MetricsServiceBlockingStub> {
+    private MetricsServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected MetricsServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new MetricsServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Returns the values of all the gauges that are currently being maintained by
+     * the service
+     * </pre>
+     */
+    public java.util.Iterator<io.grpc.testing.integration.Metrics.GaugeResponse> getAllGauges(
+        io.grpc.testing.integration.Metrics.EmptyMessage request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getGetAllGaugesMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetGaugeMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service MetricsService.
+   */
+  public static final class MetricsServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<MetricsServiceFutureStub> {
+    private MetricsServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected MetricsServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new MetricsServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Returns the value of one gauge
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Metrics.GaugeResponse> getGauge(
+        io.grpc.testing.integration.Metrics.GaugeRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetGaugeMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_GET_ALL_GAUGES = 0;
+  private static final int METHODID_GET_GAUGE = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_GET_ALL_GAUGES:
+          serviceImpl.getAllGauges((io.grpc.testing.integration.Metrics.EmptyMessage) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse>) responseObserver);
+          break;
+        case METHODID_GET_GAUGE:
+          serviceImpl.getGauge((io.grpc.testing.integration.Metrics.GaugeRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getGetAllGaugesMethod(),
+          io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Metrics.EmptyMessage,
+              io.grpc.testing.integration.Metrics.GaugeResponse>(
+                service, METHODID_GET_ALL_GAUGES)))
+        .addMethod(
+          getGetGaugeMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Metrics.GaugeRequest,
+              io.grpc.testing.integration.Metrics.GaugeResponse>(
+                service, METHODID_GET_GAUGE)))
+        .build();
+  }
+
+  private static abstract class MetricsServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    MetricsServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.testing.integration.Metrics.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("MetricsService");
+    }
+  }
+
+  private static final class MetricsServiceFileDescriptorSupplier
+      extends MetricsServiceBaseDescriptorSupplier {
+    MetricsServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class MetricsServiceMethodDescriptorSupplier
+      extends MetricsServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    MetricsServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (MetricsServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new MetricsServiceFileDescriptorSupplier())
+              .addMethod(getGetAllGaugesMethod())
+              .addMethod(getGetGaugeMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java
new file mode 100644
index 00000000000..05d46ce8e95
--- /dev/null
+++ b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java
@@ -0,0 +1,431 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A service used to control reconnect server.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class ReconnectServiceGrpc {
+
+  private ReconnectServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.ReconnectService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ReconnectParams,
+      io.grpc.testing.integration.EmptyProtos.Empty> getStartMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Start",
+      requestType = io.grpc.testing.integration.Messages.ReconnectParams.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ReconnectParams,
+      io.grpc.testing.integration.EmptyProtos.Empty> getStartMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ReconnectParams, io.grpc.testing.integration.EmptyProtos.Empty> getStartMethod;
+    if ((getStartMethod = ReconnectServiceGrpc.getStartMethod) == null) {
+      synchronized (ReconnectServiceGrpc.class) {
+        if ((getStartMethod = ReconnectServiceGrpc.getStartMethod) == null) {
+          ReconnectServiceGrpc.getStartMethod = getStartMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.ReconnectParams, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Start"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.ReconnectParams.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setSchemaDescriptor(new ReconnectServiceMethodDescriptorSupplier("Start"))
+              .build();
+        }
+      }
+    }
+    return getStartMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.Messages.ReconnectInfo> getStopMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Stop",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.Messages.ReconnectInfo.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.Messages.ReconnectInfo> getStopMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.Messages.ReconnectInfo> getStopMethod;
+    if ((getStopMethod = ReconnectServiceGrpc.getStopMethod) == null) {
+      synchronized (ReconnectServiceGrpc.class) {
+        if ((getStopMethod = ReconnectServiceGrpc.getStopMethod) == null) {
+          ReconnectServiceGrpc.getStopMethod = getStopMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.Messages.ReconnectInfo>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Stop"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.ReconnectInfo.getDefaultInstance()))
+              .setSchemaDescriptor(new ReconnectServiceMethodDescriptorSupplier("Stop"))
+              .build();
+        }
+      }
+    }
+    return getStopMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static ReconnectServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceStub>() {
+        @java.lang.Override
+        public ReconnectServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReconnectServiceStub(channel, callOptions);
+        }
+      };
+    return ReconnectServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static ReconnectServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public ReconnectServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReconnectServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return ReconnectServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static ReconnectServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceBlockingStub>() {
+        @java.lang.Override
+        public ReconnectServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReconnectServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return ReconnectServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static ReconnectServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReconnectServiceFutureStub>() {
+        @java.lang.Override
+        public ReconnectServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReconnectServiceFutureStub(channel, callOptions);
+        }
+      };
+    return ReconnectServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     */
+    default void start(io.grpc.testing.integration.Messages.ReconnectParams request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStartMethod(), responseObserver);
+    }
+
+    /**
+     */
+    default void stop(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ReconnectInfo> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStopMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static abstract class ReconnectServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return ReconnectServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static final class ReconnectServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<ReconnectServiceStub> {
+    private ReconnectServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReconnectServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReconnectServiceStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public void start(io.grpc.testing.integration.Messages.ReconnectParams request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getStartMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     */
+    public void stop(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ReconnectInfo> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getStopMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static final class ReconnectServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<ReconnectServiceBlockingV2Stub> {
+    private ReconnectServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReconnectServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReconnectServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty start(io.grpc.testing.integration.Messages.ReconnectParams request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getStartMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.Messages.ReconnectInfo stop(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getStopMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static final class ReconnectServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<ReconnectServiceBlockingStub> {
+    private ReconnectServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReconnectServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReconnectServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty start(io.grpc.testing.integration.Messages.ReconnectParams request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getStartMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.Messages.ReconnectInfo stop(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getStopMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service ReconnectService.
+   * <pre>
+   * A service used to control reconnect server.
+   * </pre>
+   */
+  public static final class ReconnectServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ReconnectServiceFutureStub> {
+    private ReconnectServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ReconnectServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReconnectServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> start(
+        io.grpc.testing.integration.Messages.ReconnectParams request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getStartMethod(), getCallOptions()), request);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.ReconnectInfo> stop(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getStopMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_START = 0;
+  private static final int METHODID_STOP = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_START:
+          serviceImpl.start((io.grpc.testing.integration.Messages.ReconnectParams) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        case METHODID_STOP:
+          serviceImpl.stop((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ReconnectInfo>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getStartMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.ReconnectParams,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_START)))
+        .addMethod(
+          getStopMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.Messages.ReconnectInfo>(
+                service, METHODID_STOP)))
+        .build();
+  }
+
+  private static abstract class ReconnectServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    ReconnectServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.testing.integration.Test.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("ReconnectService");
+    }
+  }
+
+  private static final class ReconnectServiceFileDescriptorSupplier
+      extends ReconnectServiceBaseDescriptorSupplier {
+    ReconnectServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class ReconnectServiceMethodDescriptorSupplier
+      extends ReconnectServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    ReconnectServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (ReconnectServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new ReconnectServiceFileDescriptorSupplier())
+              .addMethod(getStartMethod())
+              .addMethod(getStopMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/TestServiceGrpc.java b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/TestServiceGrpc.java
new file mode 100644
index 00000000000..a881c85c150
--- /dev/null
+++ b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/TestServiceGrpc.java
@@ -0,0 +1,1013 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A simple service to test the various types of RPCs and experiment with
+ * performance with various types of payload.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class TestServiceGrpc {
+
+  private TestServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.TestService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getEmptyCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "EmptyCall",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getEmptyCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getEmptyCallMethod;
+    if ((getEmptyCallMethod = TestServiceGrpc.getEmptyCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getEmptyCallMethod = TestServiceGrpc.getEmptyCallMethod) == null) {
+          TestServiceGrpc.getEmptyCallMethod = getEmptyCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "EmptyCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("EmptyCall"))
+              .build();
+        }
+      }
+    }
+    return getEmptyCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest,
+      io.grpc.testing.integration.Messages.SimpleResponse> getUnaryCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UnaryCall",
+      requestType = io.grpc.testing.integration.Messages.SimpleRequest.class,
+      responseType = io.grpc.testing.integration.Messages.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest,
+      io.grpc.testing.integration.Messages.SimpleResponse> getUnaryCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest, io.grpc.testing.integration.Messages.SimpleResponse> getUnaryCallMethod;
+    if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getUnaryCallMethod = TestServiceGrpc.getUnaryCallMethod) == null) {
+          TestServiceGrpc.getUnaryCallMethod = getUnaryCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.SimpleRequest, io.grpc.testing.integration.Messages.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnaryCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("UnaryCall"))
+              .build();
+        }
+      }
+    }
+    return getUnaryCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest,
+      io.grpc.testing.integration.Messages.SimpleResponse> getCacheableUnaryCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "CacheableUnaryCall",
+      requestType = io.grpc.testing.integration.Messages.SimpleRequest.class,
+      responseType = io.grpc.testing.integration.Messages.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest,
+      io.grpc.testing.integration.Messages.SimpleResponse> getCacheableUnaryCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest, io.grpc.testing.integration.Messages.SimpleResponse> getCacheableUnaryCallMethod;
+    if ((getCacheableUnaryCallMethod = TestServiceGrpc.getCacheableUnaryCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getCacheableUnaryCallMethod = TestServiceGrpc.getCacheableUnaryCallMethod) == null) {
+          TestServiceGrpc.getCacheableUnaryCallMethod = getCacheableUnaryCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.SimpleRequest, io.grpc.testing.integration.Messages.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CacheableUnaryCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("CacheableUnaryCall"))
+              .build();
+        }
+      }
+    }
+    return getCacheableUnaryCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getStreamingOutputCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingOutputCall",
+      requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getStreamingOutputCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getStreamingOutputCallMethod;
+    if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getStreamingOutputCallMethod = TestServiceGrpc.getStreamingOutputCallMethod) == null) {
+          TestServiceGrpc.getStreamingOutputCallMethod = getStreamingOutputCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingOutputCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("StreamingOutputCall"))
+              .build();
+        }
+      }
+    }
+    return getStreamingOutputCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingInputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingInputCallResponse> getStreamingInputCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamingInputCall",
+      requestType = io.grpc.testing.integration.Messages.StreamingInputCallRequest.class,
+      responseType = io.grpc.testing.integration.Messages.StreamingInputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingInputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingInputCallResponse> getStreamingInputCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingInputCallRequest, io.grpc.testing.integration.Messages.StreamingInputCallResponse> getStreamingInputCallMethod;
+    if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getStreamingInputCallMethod = TestServiceGrpc.getStreamingInputCallMethod) == null) {
+          TestServiceGrpc.getStreamingInputCallMethod = getStreamingInputCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.StreamingInputCallRequest, io.grpc.testing.integration.Messages.StreamingInputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamingInputCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingInputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingInputCallResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("StreamingInputCall"))
+              .build();
+        }
+      }
+    }
+    return getStreamingInputCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getFullDuplexCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "FullDuplexCall",
+      requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getFullDuplexCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getFullDuplexCallMethod;
+    if ((getFullDuplexCallMethod = TestServiceGrpc.getFullDuplexCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getFullDuplexCallMethod = TestServiceGrpc.getFullDuplexCallMethod) == null) {
+          TestServiceGrpc.getFullDuplexCallMethod = getFullDuplexCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FullDuplexCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("FullDuplexCall"))
+              .build();
+        }
+      }
+    }
+    return getFullDuplexCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getHalfDuplexCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "HalfDuplexCall",
+      requestType = io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class,
+      responseType = io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getHalfDuplexCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse> getHalfDuplexCallMethod;
+    if ((getHalfDuplexCallMethod = TestServiceGrpc.getHalfDuplexCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getHalfDuplexCallMethod = TestServiceGrpc.getHalfDuplexCallMethod) == null) {
+          TestServiceGrpc.getHalfDuplexCallMethod = getHalfDuplexCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "HalfDuplexCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("HalfDuplexCall"))
+              .build();
+        }
+      }
+    }
+    return getHalfDuplexCallMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UnimplementedCall",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod;
+    if ((getUnimplementedCallMethod = TestServiceGrpc.getUnimplementedCallMethod) == null) {
+      synchronized (TestServiceGrpc.class) {
+        if ((getUnimplementedCallMethod = TestServiceGrpc.getUnimplementedCallMethod) == null) {
+          TestServiceGrpc.getUnimplementedCallMethod = getUnimplementedCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnimplementedCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setSchemaDescriptor(new TestServiceMethodDescriptorSupplier("UnimplementedCall"))
+              .build();
+        }
+      }
+    }
+    return getUnimplementedCallMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static TestServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceStub>() {
+        @java.lang.Override
+        public TestServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceStub(channel, callOptions);
+        }
+      };
+    return TestServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static TestServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public TestServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return TestServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static TestServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceBlockingStub>() {
+        @java.lang.Override
+        public TestServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return TestServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static TestServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<TestServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<TestServiceFutureStub>() {
+        @java.lang.Override
+        public TestServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new TestServiceFutureStub(channel, callOptions);
+        }
+      };
+    return TestServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    default void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getEmptyCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    default void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnaryCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    default void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCacheableUnaryCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    default void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStreamingOutputCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallRequest> streamingInputCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamingInputCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full duplexing.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> fullDuplexCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getFullDuplexCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> halfDuplexCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getHalfDuplexCallMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    default void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnimplementedCallMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static abstract class TestServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return TestServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static final class TestServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<TestServiceStub> {
+    private TestServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    public void emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getEmptyCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    public void cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getCacheableUnaryCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getStreamingOutputCallMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallRequest> streamingInputCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncClientStreamingCall(
+          getChannel().newCall(getStreamingInputCallMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full duplexing.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> fullDuplexCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getFullDuplexCallMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> halfDuplexCall(
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getHalfDuplexCallMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static final class TestServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingV2Stub> {
+    private TestServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getEmptyCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.SimpleResponse unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.SimpleResponse cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getCacheableUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<?, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>
+        streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request) {
+      return io.grpc.stub.ClientCalls.blockingV2ServerStreamingCall(
+          getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by one response (streamed upload).
+     * The server returns the aggregated size of client payload as the result.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.integration.Messages.StreamingInputCallRequest, io.grpc.testing.integration.Messages.StreamingInputCallResponse>
+        streamingInputCall() {
+      return io.grpc.stub.ClientCalls.blockingClientStreamingCall(
+          getChannel(), getStreamingInputCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests with each request served by the server immediately.
+     * As one request could lead to multiple responses, this interface
+     * demonstrates the idea of full duplexing.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>
+        fullDuplexCall() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getFullDuplexCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * A sequence of requests followed by a sequence of responses.
+     * The server buffers all the client requests and then serves them in order. A
+     * stream of responses are returned to the client when the server starts with
+     * first request.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.integration.Messages.StreamingOutputCallRequest, io.grpc.testing.integration.Messages.StreamingOutputCallResponse>
+        halfDuplexCall() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getHalfDuplexCallMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static final class TestServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<TestServiceBlockingStub> {
+    private TestServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty emptyCall(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getEmptyCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.SimpleResponse unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.SimpleResponse cacheableUnaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getCacheableUnaryCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by a sequence of responses (streamed download).
+     * The server returns the payload with client desired type and sizes.
+     * </pre>
+     */
+    public java.util.Iterator<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> streamingOutputCall(
+        io.grpc.testing.integration.Messages.StreamingOutputCallRequest request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getStreamingOutputCallMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service TestService.
+   * <pre>
+   * A simple service to test the various types of RPCs and experiment with
+   * performance with various types of payload.
+   * </pre>
+   */
+  public static final class TestServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<TestServiceFutureStub> {
+    private TestServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected TestServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new TestServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * One empty request followed by one empty response.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> emptyCall(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getEmptyCallMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.SimpleResponse> unaryCall(
+        io.grpc.testing.integration.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUnaryCallMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * One request followed by one response. Response has cache control
+     * headers set such that a caching HTTP proxy (such as GFE) can
+     * satisfy subsequent requests.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.SimpleResponse> cacheableUnaryCall(
+        io.grpc.testing.integration.Messages.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getCacheableUnaryCallMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * The test server will not implement this method. It will be used
+     * to test the behavior when clients call unimplemented methods.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> unimplementedCall(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_EMPTY_CALL = 0;
+  private static final int METHODID_UNARY_CALL = 1;
+  private static final int METHODID_CACHEABLE_UNARY_CALL = 2;
+  private static final int METHODID_STREAMING_OUTPUT_CALL = 3;
+  private static final int METHODID_UNIMPLEMENTED_CALL = 4;
+  private static final int METHODID_STREAMING_INPUT_CALL = 5;
+  private static final int METHODID_FULL_DUPLEX_CALL = 6;
+  private static final int METHODID_HALF_DUPLEX_CALL = 7;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_EMPTY_CALL:
+          serviceImpl.emptyCall((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        case METHODID_UNARY_CALL:
+          serviceImpl.unaryCall((io.grpc.testing.integration.Messages.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse>) responseObserver);
+          break;
+        case METHODID_CACHEABLE_UNARY_CALL:
+          serviceImpl.cacheableUnaryCall((io.grpc.testing.integration.Messages.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse>) responseObserver);
+          break;
+        case METHODID_STREAMING_OUTPUT_CALL:
+          serviceImpl.streamingOutputCall((io.grpc.testing.integration.Messages.StreamingOutputCallRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse>) responseObserver);
+          break;
+        case METHODID_UNIMPLEMENTED_CALL:
+          serviceImpl.unimplementedCall((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_STREAMING_INPUT_CALL:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamingInputCall(
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallResponse>) responseObserver);
+        case METHODID_FULL_DUPLEX_CALL:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.fullDuplexCall(
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse>) responseObserver);
+        case METHODID_HALF_DUPLEX_CALL:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.halfDuplexCall(
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse>) responseObserver);
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getEmptyCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_EMPTY_CALL)))
+        .addMethod(
+          getUnaryCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.SimpleRequest,
+              io.grpc.testing.integration.Messages.SimpleResponse>(
+                service, METHODID_UNARY_CALL)))
+        .addMethod(
+          getCacheableUnaryCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.SimpleRequest,
+              io.grpc.testing.integration.Messages.SimpleResponse>(
+                service, METHODID_CACHEABLE_UNARY_CALL)))
+        .addMethod(
+          getStreamingOutputCallMethod(),
+          io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+              io.grpc.testing.integration.Messages.StreamingOutputCallResponse>(
+                service, METHODID_STREAMING_OUTPUT_CALL)))
+        .addMethod(
+          getStreamingInputCallMethod(),
+          io.grpc.stub.ServerCalls.asyncClientStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.StreamingInputCallRequest,
+              io.grpc.testing.integration.Messages.StreamingInputCallResponse>(
+                service, METHODID_STREAMING_INPUT_CALL)))
+        .addMethod(
+          getFullDuplexCallMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+              io.grpc.testing.integration.Messages.StreamingOutputCallResponse>(
+                service, METHODID_FULL_DUPLEX_CALL)))
+        .addMethod(
+          getHalfDuplexCallMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
+              io.grpc.testing.integration.Messages.StreamingOutputCallResponse>(
+                service, METHODID_HALF_DUPLEX_CALL)))
+        .addMethod(
+          getUnimplementedCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_UNIMPLEMENTED_CALL)))
+        .build();
+  }
+
+  private static abstract class TestServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    TestServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.testing.integration.Test.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("TestService");
+    }
+  }
+
+  private static final class TestServiceFileDescriptorSupplier
+      extends TestServiceBaseDescriptorSupplier {
+    TestServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class TestServiceMethodDescriptorSupplier
+      extends TestServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    TestServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (TestServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new TestServiceFileDescriptorSupplier())
+              .addMethod(getEmptyCallMethod())
+              .addMethod(getUnaryCallMethod())
+              .addMethod(getCacheableUnaryCallMethod())
+              .addMethod(getStreamingOutputCallMethod())
+              .addMethod(getStreamingInputCallMethod())
+              .addMethod(getFullDuplexCallMethod())
+              .addMethod(getHalfDuplexCallMethod())
+              .addMethod(getUnimplementedCallMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java
new file mode 100644
index 00000000000..fdd8d5650ed
--- /dev/null
+++ b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java
@@ -0,0 +1,372 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A simple service NOT implemented at servers so clients can test for
+ * that case.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class UnimplementedServiceGrpc {
+
+  private UnimplementedServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.UnimplementedService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UnimplementedCall",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getUnimplementedCallMethod;
+    if ((getUnimplementedCallMethod = UnimplementedServiceGrpc.getUnimplementedCallMethod) == null) {
+      synchronized (UnimplementedServiceGrpc.class) {
+        if ((getUnimplementedCallMethod = UnimplementedServiceGrpc.getUnimplementedCallMethod) == null) {
+          UnimplementedServiceGrpc.getUnimplementedCallMethod = getUnimplementedCallMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnimplementedCall"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setSchemaDescriptor(new UnimplementedServiceMethodDescriptorSupplier("UnimplementedCall"))
+              .build();
+        }
+      }
+    }
+    return getUnimplementedCallMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static UnimplementedServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceStub>() {
+        @java.lang.Override
+        public UnimplementedServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new UnimplementedServiceStub(channel, callOptions);
+        }
+      };
+    return UnimplementedServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static UnimplementedServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public UnimplementedServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new UnimplementedServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return UnimplementedServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static UnimplementedServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceBlockingStub>() {
+        @java.lang.Override
+        public UnimplementedServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new UnimplementedServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return UnimplementedServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static UnimplementedServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<UnimplementedServiceFutureStub>() {
+        @java.lang.Override
+        public UnimplementedServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new UnimplementedServiceFutureStub(channel, callOptions);
+        }
+      };
+    return UnimplementedServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    default void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnimplementedCallMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static abstract class UnimplementedServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return UnimplementedServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static final class UnimplementedServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<UnimplementedServiceStub> {
+    private UnimplementedServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected UnimplementedServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new UnimplementedServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    public void unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static final class UnimplementedServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<UnimplementedServiceBlockingV2Stub> {
+    private UnimplementedServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected UnimplementedServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new UnimplementedServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static final class UnimplementedServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<UnimplementedServiceBlockingStub> {
+    private UnimplementedServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected UnimplementedServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new UnimplementedServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty unimplementedCall(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUnimplementedCallMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service UnimplementedService.
+   * <pre>
+   * A simple service NOT implemented at servers so clients can test for
+   * that case.
+   * </pre>
+   */
+  public static final class UnimplementedServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<UnimplementedServiceFutureStub> {
+    private UnimplementedServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected UnimplementedServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new UnimplementedServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * A call that no server should implement
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> unimplementedCall(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUnimplementedCallMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_UNIMPLEMENTED_CALL = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_UNIMPLEMENTED_CALL:
+          serviceImpl.unimplementedCall((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getUnimplementedCallMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_UNIMPLEMENTED_CALL)))
+        .build();
+  }
+
+  private static abstract class UnimplementedServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    UnimplementedServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.testing.integration.Test.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("UnimplementedService");
+    }
+  }
+
+  private static final class UnimplementedServiceFileDescriptorSupplier
+      extends UnimplementedServiceBaseDescriptorSupplier {
+    UnimplementedServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class UnimplementedServiceMethodDescriptorSupplier
+      extends UnimplementedServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    UnimplementedServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (UnimplementedServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new UnimplementedServiceFileDescriptorSupplier())
+              .addMethod(getUnimplementedCallMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/XdsUpdateClientConfigureServiceGrpc.java b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/XdsUpdateClientConfigureServiceGrpc.java
new file mode 100644
index 00000000000..6c019efefea
--- /dev/null
+++ b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/XdsUpdateClientConfigureServiceGrpc.java
@@ -0,0 +1,365 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A service to dynamically update the configuration of an xDS test client.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class XdsUpdateClientConfigureServiceGrpc {
+
+  private XdsUpdateClientConfigureServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.XdsUpdateClientConfigureService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ClientConfigureRequest,
+      io.grpc.testing.integration.Messages.ClientConfigureResponse> getConfigureMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Configure",
+      requestType = io.grpc.testing.integration.Messages.ClientConfigureRequest.class,
+      responseType = io.grpc.testing.integration.Messages.ClientConfigureResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ClientConfigureRequest,
+      io.grpc.testing.integration.Messages.ClientConfigureResponse> getConfigureMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.ClientConfigureRequest, io.grpc.testing.integration.Messages.ClientConfigureResponse> getConfigureMethod;
+    if ((getConfigureMethod = XdsUpdateClientConfigureServiceGrpc.getConfigureMethod) == null) {
+      synchronized (XdsUpdateClientConfigureServiceGrpc.class) {
+        if ((getConfigureMethod = XdsUpdateClientConfigureServiceGrpc.getConfigureMethod) == null) {
+          XdsUpdateClientConfigureServiceGrpc.getConfigureMethod = getConfigureMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.Messages.ClientConfigureRequest, io.grpc.testing.integration.Messages.ClientConfigureResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Configure"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.ClientConfigureRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.Messages.ClientConfigureResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new XdsUpdateClientConfigureServiceMethodDescriptorSupplier("Configure"))
+              .build();
+        }
+      }
+    }
+    return getConfigureMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static XdsUpdateClientConfigureServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceStub>() {
+        @java.lang.Override
+        public XdsUpdateClientConfigureServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateClientConfigureServiceStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateClientConfigureServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static XdsUpdateClientConfigureServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public XdsUpdateClientConfigureServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateClientConfigureServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return XdsUpdateClientConfigureServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static XdsUpdateClientConfigureServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceBlockingStub>() {
+        @java.lang.Override
+        public XdsUpdateClientConfigureServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateClientConfigureServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateClientConfigureServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static XdsUpdateClientConfigureServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateClientConfigureServiceFutureStub>() {
+        @java.lang.Override
+        public XdsUpdateClientConfigureServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateClientConfigureServiceFutureStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateClientConfigureServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    default void configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ClientConfigureResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getConfigureMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static abstract class XdsUpdateClientConfigureServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return XdsUpdateClientConfigureServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static final class XdsUpdateClientConfigureServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<XdsUpdateClientConfigureServiceStub> {
+    private XdsUpdateClientConfigureServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateClientConfigureServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateClientConfigureServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    public void configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ClientConfigureResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getConfigureMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static final class XdsUpdateClientConfigureServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateClientConfigureServiceBlockingV2Stub> {
+    private XdsUpdateClientConfigureServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateClientConfigureServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateClientConfigureServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.ClientConfigureResponse configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getConfigureMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static final class XdsUpdateClientConfigureServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateClientConfigureServiceBlockingStub> {
+    private XdsUpdateClientConfigureServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateClientConfigureServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateClientConfigureServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    public io.grpc.testing.integration.Messages.ClientConfigureResponse configure(io.grpc.testing.integration.Messages.ClientConfigureRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getConfigureMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service XdsUpdateClientConfigureService.
+   * <pre>
+   * A service to dynamically update the configuration of an xDS test client.
+   * </pre>
+   */
+  public static final class XdsUpdateClientConfigureServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<XdsUpdateClientConfigureServiceFutureStub> {
+    private XdsUpdateClientConfigureServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateClientConfigureServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateClientConfigureServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Update the tes client's configuration.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.ClientConfigureResponse> configure(
+        io.grpc.testing.integration.Messages.ClientConfigureRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getConfigureMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_CONFIGURE = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_CONFIGURE:
+          serviceImpl.configure((io.grpc.testing.integration.Messages.ClientConfigureRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ClientConfigureResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getConfigureMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.Messages.ClientConfigureRequest,
+              io.grpc.testing.integration.Messages.ClientConfigureResponse>(
+                service, METHODID_CONFIGURE)))
+        .build();
+  }
+
+  private static abstract class XdsUpdateClientConfigureServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    XdsUpdateClientConfigureServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.testing.integration.Test.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("XdsUpdateClientConfigureService");
+    }
+  }
+
+  private static final class XdsUpdateClientConfigureServiceFileDescriptorSupplier
+      extends XdsUpdateClientConfigureServiceBaseDescriptorSupplier {
+    XdsUpdateClientConfigureServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class XdsUpdateClientConfigureServiceMethodDescriptorSupplier
+      extends XdsUpdateClientConfigureServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    XdsUpdateClientConfigureServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (XdsUpdateClientConfigureServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new XdsUpdateClientConfigureServiceFileDescriptorSupplier())
+              .addMethod(getConfigureMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/XdsUpdateHealthServiceGrpc.java b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/XdsUpdateHealthServiceGrpc.java
new file mode 100644
index 00000000000..5531033ae5c
--- /dev/null
+++ b/interop-testing/src/generated/main/grpc/io/grpc/testing/integration/XdsUpdateHealthServiceGrpc.java
@@ -0,0 +1,431 @@
+package io.grpc.testing.integration;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A service to remotely control health status of an xDS test server.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class XdsUpdateHealthServiceGrpc {
+
+  private XdsUpdateHealthServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.XdsUpdateHealthService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getSetServingMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "SetServing",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getSetServingMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getSetServingMethod;
+    if ((getSetServingMethod = XdsUpdateHealthServiceGrpc.getSetServingMethod) == null) {
+      synchronized (XdsUpdateHealthServiceGrpc.class) {
+        if ((getSetServingMethod = XdsUpdateHealthServiceGrpc.getSetServingMethod) == null) {
+          XdsUpdateHealthServiceGrpc.getSetServingMethod = getSetServingMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetServing"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setSchemaDescriptor(new XdsUpdateHealthServiceMethodDescriptorSupplier("SetServing"))
+              .build();
+        }
+      }
+    }
+    return getSetServingMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getSetNotServingMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "SetNotServing",
+      requestType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      responseType = io.grpc.testing.integration.EmptyProtos.Empty.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty,
+      io.grpc.testing.integration.EmptyProtos.Empty> getSetNotServingMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty> getSetNotServingMethod;
+    if ((getSetNotServingMethod = XdsUpdateHealthServiceGrpc.getSetNotServingMethod) == null) {
+      synchronized (XdsUpdateHealthServiceGrpc.class) {
+        if ((getSetNotServingMethod = XdsUpdateHealthServiceGrpc.getSetNotServingMethod) == null) {
+          XdsUpdateHealthServiceGrpc.getSetNotServingMethod = getSetNotServingMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.integration.EmptyProtos.Empty, io.grpc.testing.integration.EmptyProtos.Empty>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SetNotServing"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.integration.EmptyProtos.Empty.getDefaultInstance()))
+              .setSchemaDescriptor(new XdsUpdateHealthServiceMethodDescriptorSupplier("SetNotServing"))
+              .build();
+        }
+      }
+    }
+    return getSetNotServingMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static XdsUpdateHealthServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceStub>() {
+        @java.lang.Override
+        public XdsUpdateHealthServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateHealthServiceStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateHealthServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static XdsUpdateHealthServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public XdsUpdateHealthServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateHealthServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return XdsUpdateHealthServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static XdsUpdateHealthServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceBlockingStub>() {
+        @java.lang.Override
+        public XdsUpdateHealthServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateHealthServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateHealthServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static XdsUpdateHealthServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<XdsUpdateHealthServiceFutureStub>() {
+        @java.lang.Override
+        public XdsUpdateHealthServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new XdsUpdateHealthServiceFutureStub(channel, callOptions);
+        }
+      };
+    return XdsUpdateHealthServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     */
+    default void setServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetServingMethod(), responseObserver);
+    }
+
+    /**
+     */
+    default void setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSetNotServingMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static abstract class XdsUpdateHealthServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return XdsUpdateHealthServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static final class XdsUpdateHealthServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<XdsUpdateHealthServiceStub> {
+    private XdsUpdateHealthServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateHealthServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateHealthServiceStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public void setServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getSetServingMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     */
+    public void setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getSetNotServingMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static final class XdsUpdateHealthServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateHealthServiceBlockingV2Stub> {
+    private XdsUpdateHealthServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateHealthServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateHealthServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty setServing(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getSetServingMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getSetNotServingMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static final class XdsUpdateHealthServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<XdsUpdateHealthServiceBlockingStub> {
+    private XdsUpdateHealthServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateHealthServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateHealthServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty setServing(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getSetServingMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.grpc.testing.integration.EmptyProtos.Empty setNotServing(io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getSetNotServingMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service XdsUpdateHealthService.
+   * <pre>
+   * A service to remotely control health status of an xDS test server.
+   * </pre>
+   */
+  public static final class XdsUpdateHealthServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<XdsUpdateHealthServiceFutureStub> {
+    private XdsUpdateHealthServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected XdsUpdateHealthServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new XdsUpdateHealthServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> setServing(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getSetServingMethod(), getCallOptions()), request);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.EmptyProtos.Empty> setNotServing(
+        io.grpc.testing.integration.EmptyProtos.Empty request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getSetNotServingMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_SET_SERVING = 0;
+  private static final int METHODID_SET_NOT_SERVING = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_SET_SERVING:
+          serviceImpl.setServing((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        case METHODID_SET_NOT_SERVING:
+          serviceImpl.setNotServing((io.grpc.testing.integration.EmptyProtos.Empty) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.EmptyProtos.Empty>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getSetServingMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_SET_SERVING)))
+        .addMethod(
+          getSetNotServingMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.integration.EmptyProtos.Empty,
+              io.grpc.testing.integration.EmptyProtos.Empty>(
+                service, METHODID_SET_NOT_SERVING)))
+        .build();
+  }
+
+  private static abstract class XdsUpdateHealthServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    XdsUpdateHealthServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.testing.integration.Test.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("XdsUpdateHealthService");
+    }
+  }
+
+  private static final class XdsUpdateHealthServiceFileDescriptorSupplier
+      extends XdsUpdateHealthServiceBaseDescriptorSupplier {
+    XdsUpdateHealthServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class XdsUpdateHealthServiceMethodDescriptorSupplier
+      extends XdsUpdateHealthServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    XdsUpdateHealthServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (XdsUpdateHealthServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new XdsUpdateHealthServiceFileDescriptorSupplier())
+              .addMethod(getSetServingMethod())
+              .addMethod(getSetNotServingMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/AbstractInteropTest.java b/interop-testing/src/main/java/io/grpc/testing/integration/AbstractInteropTest.java
index 2b8c51b3051..51295281a90 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/AbstractInteropTest.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/AbstractInteropTest.java
@@ -1,87 +1,81 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
 import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.testing.integration.Messages.PayloadType.COMPRESSABLE;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.timeout;
-
-import com.google.auth.oauth2.AccessToken;
-import com.google.auth.oauth2.ComputeEngineCredentials;
-import com.google.auth.oauth2.GoogleCredentials;
-import com.google.auth.oauth2.OAuth2Credentials;
-import com.google.auth.oauth2.ServiceAccountCredentials;
+
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
-import com.google.common.net.HostAndPort;
-import com.google.instrumentation.stats.RpcConstants;
-import com.google.instrumentation.stats.StatsContextFactory;
-import com.google.instrumentation.stats.TagValue;
+import com.google.common.io.ByteStreams;
+import com.google.common.util.concurrent.SettableFuture;
 import com.google.protobuf.ByteString;
-import com.google.protobuf.EmptyProtos.Empty;
 import com.google.protobuf.MessageLite;
+import com.google.protobuf.StringValue;
 import io.grpc.CallOptions;
+import io.grpc.Channel;
 import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Context;
 import io.grpc.Grpc;
 import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
 import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
 import io.grpc.Server;
+import io.grpc.ServerBuilder;
 import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
 import io.grpc.ServerInterceptor;
 import io.grpc.ServerInterceptors;
+import io.grpc.ServerStreamTracer;
 import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
-import io.grpc.auth.MoreCallCredentials;
-import io.grpc.internal.AbstractServerImplBuilder;
+import io.grpc.census.InternalCensusStatsAccessor;
+import io.grpc.census.internal.DeprecatedCensusConstants;
 import io.grpc.internal.GrpcUtil;
-import io.grpc.internal.testing.StatsTestUtils.FakeStatsContextFactory;
+import io.grpc.internal.testing.StatsTestUtils;
+import io.grpc.internal.testing.StatsTestUtils.FakeStatsRecorder;
+import io.grpc.internal.testing.StatsTestUtils.FakeTagContext;
+import io.grpc.internal.testing.StatsTestUtils.FakeTagContextBinarySerializer;
+import io.grpc.internal.testing.StatsTestUtils.FakeTagger;
 import io.grpc.internal.testing.StatsTestUtils.MetricsRecord;
-import io.grpc.protobuf.ProtoUtils;
+import io.grpc.internal.testing.StreamRecorder;
+import io.grpc.internal.testing.TestClientStreamTracer;
+import io.grpc.internal.testing.TestServerStreamTracer;
+import io.grpc.internal.testing.TestStreamTracer;
+import io.grpc.stub.ClientCallStreamObserver;
 import io.grpc.stub.MetadataUtils;
 import io.grpc.stub.StreamObserver;
-import io.grpc.testing.StreamRecorder;
 import io.grpc.testing.TestUtils;
+import io.grpc.testing.integration.EmptyProtos.Empty;
+import io.grpc.testing.integration.Messages.BoolValue;
 import io.grpc.testing.integration.Messages.EchoStatus;
 import io.grpc.testing.integration.Messages.Payload;
-import io.grpc.testing.integration.Messages.PayloadType;
 import io.grpc.testing.integration.Messages.ResponseParameters;
 import io.grpc.testing.integration.Messages.SimpleRequest;
 import io.grpc.testing.integration.Messages.SimpleResponse;
@@ -89,68 +83,178 @@
 import io.grpc.testing.integration.Messages.StreamingInputCallResponse;
 import io.grpc.testing.integration.Messages.StreamingOutputCallRequest;
 import io.grpc.testing.integration.Messages.StreamingOutputCallResponse;
+import io.opencensus.contrib.grpc.metrics.RpcMeasureConstants;
+import io.opencensus.stats.Measure;
+import io.opencensus.stats.Measure.MeasureDouble;
+import io.opencensus.stats.Measure.MeasureLong;
+import io.opencensus.tags.TagKey;
+import io.opencensus.tags.TagValue;
+import io.opencensus.trace.Span;
+import io.opencensus.trace.SpanContext;
+import io.opencensus.trace.Tracing;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.SocketAddress;
 import java.security.cert.Certificate;
 import java.security.cert.X509Certificate;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Locale;
+import java.util.Map;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Pattern;
+import javax.annotation.Nullable;
 import javax.net.ssl.SSLPeerUnverifiedException;
 import javax.net.ssl.SSLSession;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Assume;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
-import org.mockito.verification.VerificationMode;
+import org.junit.rules.DisableOnDebug;
+import org.junit.rules.TestRule;
+import org.junit.rules.Timeout;
 
 /**
  * Abstract base class for all GRPC transport tests.
  *
- * <p> New tests should avoid using Mockito to support running on AppEngine.</p>
+ * <p>New tests should avoid using Mockito to support running on AppEngine.
  */
 public abstract class AbstractInteropTest {
+  private static Logger logger = Logger.getLogger(AbstractInteropTest.class.getName());
+
+  @Rule public final TestRule globalTimeout;
+
   /** Must be at least {@link #unaryPayloadLength()}, plus some to account for encoding overhead. */
   public static final int MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
-  public static final Metadata.Key<Messages.SimpleContext> METADATA_KEY =
-      ProtoUtils.keyForProto(Messages.SimpleContext.getDefaultInstance());
-  private static final AtomicReference<ServerCall<?, ?>> serverCallCapture =
-      new AtomicReference<ServerCall<?, ?>>();
-  private static final AtomicReference<Metadata> requestHeadersCapture =
-      new AtomicReference<Metadata>();
-  private static ScheduledExecutorService testServiceExecutor;
-  private static Server server;
-  private static final FakeStatsContextFactory clientStatsFactory =
-      new FakeStatsContextFactory();
-  private static final FakeStatsContextFactory serverStatsFactory =
-      new FakeStatsContextFactory();
+
+  /**
+   * Use a small flow control to help detect flow control bugs. Don't use 64KiB to test
+   * SETTINGS/WINDOW_UPDATE exchange.
+   */
+  public static final int TEST_FLOW_CONTROL_WINDOW = 65 * 1024;
+  private static final MeasureLong RETRIES_PER_CALL =
+      Measure.MeasureLong.create(
+          "grpc.io/client/retries_per_call", "Number of retries per call", "1");
+  private static final MeasureLong TRANSPARENT_RETRIES_PER_CALL =
+      Measure.MeasureLong.create(
+          "grpc.io/client/transparent_retries_per_call", "Transparent retries per call", "1");
+  private static final MeasureDouble RETRY_DELAY_PER_CALL =
+      Measure.MeasureDouble.create(
+          "grpc.io/client/retry_delay_per_call", "Retry delay per call", "ms");
+
+  private static final FakeTagger tagger = new FakeTagger();
+  private static final FakeTagContextBinarySerializer tagContextBinarySerializer =
+      new FakeTagContextBinarySerializer();
+
+  private final AtomicReference<ServerCall<?, ?>> serverCallCapture =
+      new AtomicReference<>();
+  private final AtomicReference<ClientCall<?, ?>> clientCallCapture =
+      new AtomicReference<>();
+  private final AtomicReference<Metadata> requestHeadersCapture =
+      new AtomicReference<>();
+  private final AtomicReference<Context> contextCapture =
+      new AtomicReference<>();
+  private final FakeStatsRecorder clientStatsRecorder = new FakeStatsRecorder();
+  private final FakeStatsRecorder serverStatsRecorder = new FakeStatsRecorder();
+
+  private ScheduledExecutorService testServiceExecutor;
+  private Server server;
+  private Server handshakerServer;
+
+  private final LinkedBlockingQueue<ServerStreamTracerInfo> serverStreamTracers =
+      new LinkedBlockingQueue<>();
+
+  private static final class ServerStreamTracerInfo {
+    final String fullMethodName;
+    final InteropServerStreamTracer tracer;
+
+    ServerStreamTracerInfo(String fullMethodName, InteropServerStreamTracer tracer) {
+      this.fullMethodName = fullMethodName;
+      this.tracer = tracer;
+    }
+
+    private static final class InteropServerStreamTracer extends TestServerStreamTracer {
+      private volatile Context contextCapture;
+
+      @Override
+      public Context filterContext(Context context) {
+        contextCapture = context;
+        return super.filterContext(context);
+      }
+    }
+  }
+
+  /**
+   * Constructor for tests.
+   */
+  protected AbstractInteropTest() {
+    TestRule timeout = Timeout.seconds(90);
+    try {
+      timeout = new DisableOnDebug(timeout);
+    } catch (Throwable t) {
+      // This can happen on Android, which lacks some standard Java class.
+      // Seen at https://github.com/grpc/grpc-java/pull/5832#issuecomment-499698086
+      logger.log(Level.FINE, "Debugging not disabled.", t);
+    }
+    globalTimeout = timeout;
+  }
+
+  private final ServerStreamTracer.Factory serverStreamTracerFactory =
+      new ServerStreamTracer.Factory() {
+        @Override
+        public ServerStreamTracer newServerStreamTracer(String fullMethodName, Metadata headers) {
+          ServerStreamTracerInfo.InteropServerStreamTracer tracer
+              = new ServerStreamTracerInfo.InteropServerStreamTracer();
+          serverStreamTracers.add(new ServerStreamTracerInfo(fullMethodName, tracer));
+          return tracer;
+        }
+      };
+
   protected static final Empty EMPTY = Empty.getDefaultInstance();
 
-  protected static void startStaticServer(
-      AbstractServerImplBuilder<?> builder, ServerInterceptor ... interceptors) {
+  private void configBuilder(@Nullable ServerBuilder<?> builder) {
+    if (builder == null) {
+      return;
+    }
     testServiceExecutor = Executors.newScheduledThreadPool(2);
 
     List<ServerInterceptor> allInterceptors = ImmutableList.<ServerInterceptor>builder()
-        .add(TestUtils.recordServerCallInterceptor(serverCallCapture))
+        .add(recordServerCallInterceptor(serverCallCapture))
         .add(TestUtils.recordRequestHeadersInterceptor(requestHeadersCapture))
+        .add(recordContextInterceptor(contextCapture))
         .addAll(TestServiceImpl.interceptors())
-        .add(interceptors)
         .build();
 
-    builder.addService(ServerInterceptors.intercept(
-        new TestServiceImpl(testServiceExecutor),
-        allInterceptors));
-    io.grpc.internal.TestingAccessor.setStatsContextFactory(builder, serverStatsFactory);
+    builder
+        .addService(
+            ServerInterceptors.intercept(
+                new TestServiceImpl(testServiceExecutor),
+                allInterceptors))
+        .addStreamTracerFactory(serverStreamTracerFactory);
+  }
+
+  protected void startServer(@Nullable ServerBuilder<?> builder) {
+    maybeStartHandshakerServer();
+    if (builder == null) {
+      server = null;
+      return;
+    }
+
     try {
       server = builder.build().start();
     } catch (IOException ex) {
@@ -158,83 +262,292 @@ protected static void startStaticServer(
     }
   }
 
-  protected static void stopStaticServer() {
-    server.shutdownNow();
-    testServiceExecutor.shutdown();
+  private void maybeStartHandshakerServer() {
+    ServerBuilder<?> handshakerServerBuilder = getHandshakerServerBuilder();
+    if (handshakerServerBuilder != null) {
+      try {
+        handshakerServer = handshakerServerBuilder.build().start();
+      } catch (IOException ex) {
+        throw new RuntimeException(ex);
+      }
+    }
+  }
+
+  private void stopServer() {
+    if (server != null) {
+      server.shutdownNow();
+    }
+    if (testServiceExecutor != null) {
+      testServiceExecutor.shutdown();
+    }
+    if (handshakerServer != null) {
+      handshakerServer.shutdownNow();
+    }
   }
 
   @VisibleForTesting
-  static int getPort() {
-    return server.getPort();
+  final SocketAddress getListenAddress() {
+    return server.getListenSockets().iterator().next();
   }
 
   protected ManagedChannel channel;
   protected TestServiceGrpc.TestServiceBlockingStub blockingStub;
   protected TestServiceGrpc.TestServiceStub asyncStub;
 
+  private final LinkedBlockingQueue<TestClientStreamTracer> clientStreamTracers =
+      new LinkedBlockingQueue<>();
+  private boolean enableClientStreamTracers = true;
+
+  void setEnableClientStreamTracers(boolean enableClientStreamTracers) {
+    this.enableClientStreamTracers = enableClientStreamTracers;
+  }
+
+  private final ClientStreamTracer.Factory clientStreamTracerFactory =
+      new ClientStreamTracer.Factory() {
+        @Override
+        public ClientStreamTracer newClientStreamTracer(
+            ClientStreamTracer.StreamInfo info, Metadata headers) {
+          TestClientStreamTracer tracer = new TestClientStreamTracer();
+          clientStreamTracers.add(tracer);
+          return tracer;
+        }
+      };
+  private final ClientInterceptor tracerSetupInterceptor = new ClientInterceptor() {
+        @Override
+        public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+            MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+          return next.newCall(
+              method, callOptions.withStreamTracerFactory(clientStreamTracerFactory));
+        }
+      };
+
   /**
    * Must be called by the subclass setup method if overridden.
    */
   @Before
   public void setUp() {
+    ServerBuilder<?> serverBuilder = getServerBuilder();
+    configBuilder(serverBuilder);
+    startServer(serverBuilder);
     channel = createChannel();
-    blockingStub = TestServiceGrpc.newBlockingStub(channel);
-    asyncStub = TestServiceGrpc.newStub(channel);
+
+    if (enableClientStreamTracers) {
+      blockingStub =
+          TestServiceGrpc.newBlockingStub(channel).withInterceptors(tracerSetupInterceptor);
+      asyncStub = TestServiceGrpc.newStub(channel).withInterceptors(tracerSetupInterceptor);
+    } else {
+      blockingStub = TestServiceGrpc.newBlockingStub(channel);
+      asyncStub = TestServiceGrpc.newStub(channel);
+    }
+
+    ClientInterceptor[] additionalInterceptors = getAdditionalInterceptors();
+    if (additionalInterceptors != null) {
+      blockingStub = blockingStub.withInterceptors(additionalInterceptors);
+      asyncStub = asyncStub.withInterceptors(additionalInterceptors);
+    }
+
     requestHeadersCapture.set(null);
-    clientStatsFactory.rolloverRecords();
-    serverStatsFactory.rolloverRecords();
   }
 
   /** Clean up. */
   @After
-  public void tearDown() throws Exception {
+  public void tearDown() {
     if (channel != null) {
-      channel.shutdown();
+      channel.shutdownNow();
+      try {
+        channel.awaitTermination(1, TimeUnit.SECONDS);
+      } catch (InterruptedException ie) {
+        logger.log(Level.FINE, "Interrupted while waiting for channel termination", ie);
+        // Best effort. If there is an interruption, we want to continue cleaning up, but quickly
+        Thread.currentThread().interrupt();
+      }
     }
+    stopServer();
+  }
+
+  protected ManagedChannel createChannel() {
+    return createChannelBuilder().build();
   }
 
-  protected abstract ManagedChannel createChannel();
+  protected abstract ManagedChannelBuilder<?> createChannelBuilder();
 
-  protected final StatsContextFactory getClientStatsFactory() {
-    return clientStatsFactory;
+  @Nullable
+  protected ClientInterceptor[] getAdditionalInterceptors() {
+    return null;
   }
 
+  /**
+   * Returns the server builder used to create server for each test run.  Return {@code null} if
+   * it shouldn't start a server in the same process.
+   */
+  @Nullable
+  protected ServerBuilder<?> getServerBuilder() {
+    return null;
+  }
+
+  @Nullable
+  protected ServerBuilder<?> getHandshakerServerBuilder() {
+    return null;
+  }
+
+  protected final ClientInterceptor createCensusStatsClientInterceptor() {
+    return
+        InternalCensusStatsAccessor
+            .getClientInterceptor(
+                tagger, tagContextBinarySerializer, clientStatsRecorder,
+                GrpcUtil.STOPWATCH_SUPPLIER,
+                true, true, true,
+                /* recordRealTimeMetrics= */ false,
+                /* recordRetryMetrics= */ true);
+  }
+
+  protected final ServerStreamTracer.Factory createCustomCensusTracerFactory() {
+    return InternalCensusStatsAccessor.getServerStreamTracerFactory(
+        tagger, tagContextBinarySerializer, serverStatsRecorder,
+        GrpcUtil.STOPWATCH_SUPPLIER,
+        true, true, true, false /* real-time metrics */);
+  }
+
+  /**
+   * Override this when custom census module presence is different from {@link #metricsExpected()}.
+   */
+  protected boolean customCensusModulePresent() {
+    return metricsExpected();
+  }
+
+  /**
+   * Return true if exact metric values should be checked.
+   */
   protected boolean metricsExpected() {
     return true;
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void emptyUnary() throws Exception {
     assertEquals(EMPTY, blockingStub.emptyCall(EMPTY));
   }
 
-  @Test(timeout = 10000)
+  @Test
+  public void emptyUnaryWithRetriableStream() throws Exception {
+    channel.shutdown();
+    channel = createChannelBuilder().enableRetry().build();
+    assertEquals(EMPTY, TestServiceGrpc.newBlockingStub(channel).emptyCall(EMPTY));
+  }
+
+  @Test
   public void largeUnary() throws Exception {
     assumeEnoughMemory();
     final SimpleRequest request = SimpleRequest.newBuilder()
         .setResponseSize(314159)
-        .setResponseType(PayloadType.COMPRESSABLE)
         .setPayload(Payload.newBuilder()
             .setBody(ByteString.copyFrom(new byte[271828])))
         .build();
     final SimpleResponse goldenResponse = SimpleResponse.newBuilder()
         .setPayload(Payload.newBuilder()
-            .setType(PayloadType.COMPRESSABLE)
             .setBody(ByteString.copyFrom(new byte[314159])))
         .build();
 
-    assertEquals(goldenResponse, blockingStub.unaryCall(request));
+    assertResponse(goldenResponse, blockingStub.unaryCall(request));
 
-    if (metricsExpected()) {
-      assertMetrics("grpc.testing.TestService/UnaryCall", Status.Code.OK,
-          Collections.singleton(request), Collections.singleton(goldenResponse));
+    assertStatsTrace("grpc.testing.TestService/UnaryCall", Status.Code.OK,
+        Collections.singleton(request), Collections.singleton(goldenResponse));
+  }
+
+  /**
+   * Tests client per-message compression for unary calls. The Java API does not support inspecting
+   * a message's compression level, so this is primarily intended to run against a gRPC C++ server.
+   */
+  public void clientCompressedUnary(boolean probe) throws Exception {
+    assumeEnoughMemory();
+    final SimpleRequest expectCompressedRequest =
+        SimpleRequest.newBuilder()
+            .setExpectCompressed(BoolValue.newBuilder().setValue(true))
+            .setResponseSize(314159)
+            .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[271828])))
+            .build();
+    final SimpleRequest expectUncompressedRequest =
+        SimpleRequest.newBuilder()
+            .setExpectCompressed(BoolValue.newBuilder().setValue(false))
+            .setResponseSize(314159)
+            .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[271828])))
+            .build();
+    final SimpleResponse goldenResponse =
+        SimpleResponse.newBuilder()
+            .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[314159])))
+            .build();
+
+    if (probe) {
+      // Send a non-compressed message with expectCompress=true. Servers supporting this test case
+      // should return INVALID_ARGUMENT.
+      try {
+        blockingStub.unaryCall(expectCompressedRequest);
+        fail("expected INVALID_ARGUMENT");
+      } catch (StatusRuntimeException e) {
+        assertCodeEquals(Status.Code.INVALID_ARGUMENT, e.getStatus());
+      }
+      assertStatsTrace("grpc.testing.TestService/UnaryCall", Status.Code.INVALID_ARGUMENT);
     }
+
+    assertResponse(
+        goldenResponse, blockingStub.withCompression("gzip").unaryCall(expectCompressedRequest));
+    assertStatsTrace(
+        "grpc.testing.TestService/UnaryCall",
+        Status.Code.OK,
+        Collections.singleton(expectCompressedRequest),
+        Collections.singleton(goldenResponse));
+
+    assertResponse(goldenResponse, blockingStub.unaryCall(expectUncompressedRequest));
+    assertStatsTrace(
+        "grpc.testing.TestService/UnaryCall",
+        Status.Code.OK,
+        Collections.singleton(expectUncompressedRequest),
+        Collections.singleton(goldenResponse));
   }
 
-  @Test(timeout = 10000)
+  /**
+   * Tests if the server can send a compressed unary response. Ideally we would assert that the
+   * responses have the requested compression, but this is not supported by the API. Given a
+   * compliant server, this test will exercise the code path for receiving a compressed response but
+   * cannot itself verify that the response was compressed.
+   */
+  @Test
+  public void serverCompressedUnary() throws Exception {
+    assumeEnoughMemory();
+    final SimpleRequest responseShouldBeCompressed =
+        SimpleRequest.newBuilder()
+            .setResponseCompressed(BoolValue.newBuilder().setValue(true))
+            .setResponseSize(314159)
+            .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[271828])))
+            .build();
+    final SimpleRequest responseShouldBeUncompressed =
+        SimpleRequest.newBuilder()
+            .setResponseCompressed(BoolValue.newBuilder().setValue(false))
+            .setResponseSize(314159)
+            .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[271828])))
+            .build();
+    final SimpleResponse goldenResponse =
+        SimpleResponse.newBuilder()
+            .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[314159])))
+            .build();
+
+    assertResponse(goldenResponse, blockingStub.unaryCall(responseShouldBeCompressed));
+    assertStatsTrace(
+        "grpc.testing.TestService/UnaryCall",
+        Status.Code.OK,
+        Collections.singleton(responseShouldBeCompressed),
+        Collections.singleton(goldenResponse));
+
+    assertResponse(goldenResponse, blockingStub.unaryCall(responseShouldBeUncompressed));
+    assertStatsTrace(
+        "grpc.testing.TestService/UnaryCall",
+        Status.Code.OK,
+        Collections.singleton(responseShouldBeUncompressed),
+        Collections.singleton(goldenResponse));
+  }
+
+  @Test
   public void serverStreaming() throws Exception {
     final StreamingOutputCallRequest request = StreamingOutputCallRequest.newBuilder()
-        .setResponseType(PayloadType.COMPRESSABLE)
         .addResponseParameters(ResponseParameters.newBuilder()
             .setSize(31415))
         .addResponseParameters(ResponseParameters.newBuilder()
@@ -247,22 +560,18 @@ public void serverStreaming() throws Exception {
     final List<StreamingOutputCallResponse> goldenResponses = Arrays.asList(
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-                .setType(PayloadType.COMPRESSABLE)
                 .setBody(ByteString.copyFrom(new byte[31415])))
             .build(),
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-                .setType(PayloadType.COMPRESSABLE)
                 .setBody(ByteString.copyFrom(new byte[9])))
             .build(),
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-                .setType(PayloadType.COMPRESSABLE)
                 .setBody(ByteString.copyFrom(new byte[2653])))
             .build(),
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-                .setType(PayloadType.COMPRESSABLE)
                 .setBody(ByteString.copyFrom(new byte[58979])))
             .build());
 
@@ -270,10 +579,10 @@ public void serverStreaming() throws Exception {
     asyncStub.streamingOutputCall(request, recorder);
     recorder.awaitCompletion();
     assertSuccess(recorder);
-    assertEquals(goldenResponses, recorder.getValues());
+    assertResponses(goldenResponses, recorder.getValues());
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void clientStreaming() throws Exception {
     final List<StreamingInputCallRequest> requests = Arrays.asList(
         StreamingInputCallRequest.newBuilder()
@@ -303,11 +612,100 @@ public void clientStreaming() throws Exception {
       requestObserver.onNext(request);
     }
     requestObserver.onCompleted();
+
     assertEquals(goldenResponse, responseObserver.firstValue().get());
     responseObserver.awaitCompletion();
+    assertThat(responseObserver.getValues()).hasSize(1);
+    Throwable t = responseObserver.getError();
+    if (t != null) {
+      throw new AssertionError(t);
+    }
   }
 
-  @Test(timeout = 10000)
+  /**
+   * Tests client per-message compression for streaming calls. The Java API does not support
+   * inspecting a message's compression level, so this is primarily intended to run against a gRPC
+   * C++ server.
+   */
+  public void clientCompressedStreaming(boolean probe) throws Exception {
+    final StreamingInputCallRequest expectCompressedRequest =
+        StreamingInputCallRequest.newBuilder()
+            .setExpectCompressed(BoolValue.newBuilder().setValue(true))
+            .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[27182])))
+            .build();
+    final StreamingInputCallRequest expectUncompressedRequest =
+        StreamingInputCallRequest.newBuilder()
+            .setExpectCompressed(BoolValue.newBuilder().setValue(false))
+            .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[45904])))
+            .build();
+    final StreamingInputCallResponse goldenResponse =
+        StreamingInputCallResponse.newBuilder().setAggregatedPayloadSize(73086).build();
+
+    StreamRecorder<StreamingInputCallResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<StreamingInputCallRequest> requestObserver =
+        asyncStub.streamingInputCall(responseObserver);
+
+    if (probe) {
+      // Send a non-compressed message with expectCompress=true. Servers supporting this test case
+      // should return INVALID_ARGUMENT.
+      requestObserver.onNext(expectCompressedRequest);
+      responseObserver.awaitCompletion(operationTimeoutMillis(), TimeUnit.MILLISECONDS);
+      Throwable e = responseObserver.getError();
+      assertNotNull("expected INVALID_ARGUMENT", e);
+      assertCodeEquals(Status.Code.INVALID_ARGUMENT, Status.fromThrowable(e));
+    }
+
+    // Start a new stream
+    responseObserver = StreamRecorder.create();
+    @SuppressWarnings("unchecked")
+    ClientCallStreamObserver<StreamingInputCallRequest> clientCallStreamObserver =
+        (ClientCallStreamObserver)
+            asyncStub.withCompression("gzip").streamingInputCall(responseObserver);
+    clientCallStreamObserver.setMessageCompression(true);
+    clientCallStreamObserver.onNext(expectCompressedRequest);
+    clientCallStreamObserver.setMessageCompression(false);
+    clientCallStreamObserver.onNext(expectUncompressedRequest);
+    clientCallStreamObserver.onCompleted();
+    responseObserver.awaitCompletion();
+    assertSuccess(responseObserver);
+    assertEquals(goldenResponse, responseObserver.firstValue().get());
+  }
+
+  /**
+   * Tests server per-message compression in a streaming response. Ideally we would assert that the
+   * responses have the requested compression, but this is not supported by the API. Given a
+   * compliant server, this test will exercise the code path for receiving a compressed response but
+   * cannot itself verify that the response was compressed.
+   */
+  public void serverCompressedStreaming() throws Exception {
+    final StreamingOutputCallRequest request =
+        StreamingOutputCallRequest.newBuilder()
+            .addResponseParameters(
+                ResponseParameters.newBuilder()
+                    .setCompressed(BoolValue.newBuilder().setValue(true))
+                    .setSize(31415))
+            .addResponseParameters(
+                ResponseParameters.newBuilder()
+                    .setCompressed(BoolValue.newBuilder().setValue(false))
+                    .setSize(92653))
+            .build();
+    final List<StreamingOutputCallResponse> goldenResponses =
+        Arrays.asList(
+            StreamingOutputCallResponse.newBuilder()
+                .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[31415])))
+                .build(),
+            StreamingOutputCallResponse.newBuilder()
+                .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[92653])))
+                .build());
+
+    StreamRecorder<StreamingOutputCallResponse> recorder = StreamRecorder.create();
+    asyncStub.streamingOutputCall(request, recorder);
+    recorder.awaitCompletion();
+    assertSuccess(recorder);
+    assertResponses(goldenResponses, recorder.getValues());
+  }
+
+  @Test
   public void pingPong() throws Exception {
     final List<StreamingOutputCallRequest> requests = Arrays.asList(
         StreamingOutputCallRequest.newBuilder()
@@ -337,26 +735,22 @@ public void pingPong() throws Exception {
     final List<StreamingOutputCallResponse> goldenResponses = Arrays.asList(
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-                .setType(PayloadType.COMPRESSABLE)
                 .setBody(ByteString.copyFrom(new byte[31415])))
             .build(),
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-                .setType(PayloadType.COMPRESSABLE)
                 .setBody(ByteString.copyFrom(new byte[9])))
             .build(),
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-                .setType(PayloadType.COMPRESSABLE)
                 .setBody(ByteString.copyFrom(new byte[2653])))
             .build(),
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-                .setType(PayloadType.COMPRESSABLE)
                 .setBody(ByteString.copyFrom(new byte[58979])))
             .build());
 
-    final ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<Object>(5);
+    final ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<>(5);
     StreamObserver<StreamingOutputCallRequest> requestObserver
         = asyncStub.fullDuplexCall(new StreamObserver<StreamingOutputCallResponse>() {
           @Override
@@ -377,23 +771,29 @@ public void onCompleted() {
     for (int i = 0; i < requests.size(); i++) {
       assertNull(queue.peek());
       requestObserver.onNext(requests.get(i));
-      assertEquals(goldenResponses.get(i),
-                   queue.poll(operationTimeoutMillis(), TimeUnit.MILLISECONDS));
+      Object actualResponse = queue.poll(operationTimeoutMillis(), TimeUnit.MILLISECONDS);
+      assertNotNull("Timed out waiting for response", actualResponse);
+      if (actualResponse instanceof Throwable) {
+        throw new AssertionError(actualResponse);
+      }
+      assertResponse(goldenResponses.get(i), (StreamingOutputCallResponse) actualResponse);
     }
     requestObserver.onCompleted();
     assertEquals("Completed", queue.poll(operationTimeoutMillis(), TimeUnit.MILLISECONDS));
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void emptyStream() throws Exception {
     StreamRecorder<StreamingOutputCallResponse> responseObserver = StreamRecorder.create();
     StreamObserver<StreamingOutputCallRequest> requestObserver
         = asyncStub.fullDuplexCall(responseObserver);
     requestObserver.onCompleted();
     responseObserver.awaitCompletion(operationTimeoutMillis(), TimeUnit.MILLISECONDS);
+    assertSuccess(responseObserver);
+    assertTrue("Expected an empty stream", responseObserver.getValues().isEmpty());
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void cancelAfterBegin() throws Exception {
     StreamRecorder<StreamingInputCallResponse> responseObserver = StreamRecorder.create();
     StreamObserver<StreamingInputCallRequest> requestObserver =
@@ -401,16 +801,23 @@ public void cancelAfterBegin() throws Exception {
     requestObserver.onError(new RuntimeException());
     responseObserver.awaitCompletion();
     assertEquals(Arrays.<StreamingInputCallResponse>asList(), responseObserver.getValues());
-    assertEquals(Status.Code.CANCELLED,
-        Status.fromThrowable(responseObserver.getError()).getCode());
+    assertCodeEquals(Status.Code.CANCELLED, Status.fromThrowable(responseObserver.getError()));
 
     if (metricsExpected()) {
-      assertClientMetrics("grpc.testing.TestService/StreamingInputCall", Status.Code.CANCELLED);
+      MetricsRecord clientStartRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      checkStartTags(clientStartRecord, "grpc.testing.TestService/StreamingInputCall", true);
+      // CensusStreamTracerModule record final status in the interceptor, thus is guaranteed to be
+      // recorded.  The tracer stats rely on the stream being created, which is not always the case
+      // in this test.  Therefore we don't check the tracer stats.
+      MetricsRecord clientEndRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      checkEndTags(
+          clientEndRecord, "grpc.testing.TestService/StreamingInputCall",
+          Status.CANCELLED.getCode(), true);
       // Do not check server-side metrics, because the status on the server side is undetermined.
     }
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void cancelAfterFirstResponse() throws Exception {
     final StreamingOutputCallRequest request = StreamingOutputCallRequest.newBuilder()
         .addResponseParameters(ResponseParameters.newBuilder()
@@ -420,7 +827,6 @@ public void cancelAfterFirstResponse() throws Exception {
         .build();
     final StreamingOutputCallResponse goldenResponse = StreamingOutputCallResponse.newBuilder()
         .setPayload(Payload.newBuilder()
-            .setType(PayloadType.COMPRESSABLE)
             .setBody(ByteString.copyFrom(new byte[31415])))
         .build();
 
@@ -428,27 +834,24 @@ public void cancelAfterFirstResponse() throws Exception {
     StreamObserver<StreamingOutputCallRequest> requestObserver
         = asyncStub.fullDuplexCall(responseObserver);
     requestObserver.onNext(request);
-    assertEquals(goldenResponse, responseObserver.firstValue().get());
+    assertResponse(goldenResponse, responseObserver.firstValue().get());
     requestObserver.onError(new RuntimeException());
     responseObserver.awaitCompletion(operationTimeoutMillis(), TimeUnit.MILLISECONDS);
     assertEquals(1, responseObserver.getValues().size());
-    assertEquals(Status.Code.CANCELLED,
-                 Status.fromThrowable(responseObserver.getError()).getCode());
+    assertCodeEquals(Status.Code.CANCELLED, Status.fromThrowable(responseObserver.getError()));
 
-    if (metricsExpected()) {
-      assertMetrics("grpc.testing.TestService/FullDuplexCall", Status.Code.CANCELLED);
-    }
+    assertStatsTrace("grpc.testing.TestService/FullDuplexCall", Status.Code.CANCELLED);
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void fullDuplexCallShouldSucceed() throws Exception {
     // Build the request.
     List<Integer> responseSizes = Arrays.asList(50, 100, 150, 200);
     StreamingOutputCallRequest.Builder streamingOutputBuilder =
         StreamingOutputCallRequest.newBuilder();
-    streamingOutputBuilder.setResponseType(COMPRESSABLE);
     for (Integer size : responseSizes) {
-      streamingOutputBuilder.addResponseParametersBuilder().setSize(size).setIntervalUs(0);
+      streamingOutputBuilder.addResponseParameters(
+          ResponseParameters.newBuilder().setSize(size).setIntervalUs(0));
     }
     final StreamingOutputCallRequest request = streamingOutputBuilder.build();
 
@@ -458,7 +861,7 @@ public void fullDuplexCallShouldSucceed() throws Exception {
 
     final int numRequests = 10;
     List<StreamingOutputCallRequest> requests =
-        new ArrayList<StreamingOutputCallRequest>(numRequests);
+        new ArrayList<>(numRequests);
     for (int ix = numRequests; ix > 0; --ix) {
       requests.add(request);
       requestStream.onNext(request);
@@ -466,30 +869,27 @@ public void fullDuplexCallShouldSucceed() throws Exception {
     requestStream.onCompleted();
     recorder.awaitCompletion();
     assertSuccess(recorder);
-    assertEquals(responseSizes.size() * numRequests, recorder.getValues().size());
+    assertEquals(responseSizes.size() * (long) numRequests, recorder.getValues().size());
     for (int ix = 0; ix < recorder.getValues().size(); ++ix) {
       StreamingOutputCallResponse response = recorder.getValues().get(ix);
-      assertEquals(COMPRESSABLE, response.getPayload().getType());
       int length = response.getPayload().getBody().size();
       int expectedSize = responseSizes.get(ix % responseSizes.size());
       assertEquals("comparison failed at index " + ix, expectedSize, length);
     }
 
-    if (metricsExpected()) {
-      assertMetrics("grpc.testing.TestService/FullDuplexCall", Status.Code.OK, requests,
-          recorder.getValues());
-    }
+    assertStatsTrace("grpc.testing.TestService/FullDuplexCall", Status.Code.OK, requests,
+        recorder.getValues());
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void halfDuplexCallShouldSucceed() throws Exception {
     // Build the request.
     List<Integer> responseSizes = Arrays.asList(50, 100, 150, 200);
     StreamingOutputCallRequest.Builder streamingOutputBuilder =
         StreamingOutputCallRequest.newBuilder();
-    streamingOutputBuilder.setResponseType(COMPRESSABLE);
     for (Integer size : responseSizes) {
-      streamingOutputBuilder.addResponseParametersBuilder().setSize(size).setIntervalUs(0);
+      streamingOutputBuilder.addResponseParameters(
+          ResponseParameters.newBuilder().setSize(size).setIntervalUs(0));
     }
     final StreamingOutputCallRequest request = streamingOutputBuilder.build();
 
@@ -497,47 +897,40 @@ public void halfDuplexCallShouldSucceed() throws Exception {
     StreamObserver<StreamingOutputCallRequest> requestStream = asyncStub.halfDuplexCall(recorder);
 
     final int numRequests = 10;
-    List<StreamingOutputCallRequest> requests =
-        new ArrayList<StreamingOutputCallRequest>(numRequests);
     for (int ix = numRequests; ix > 0; --ix) {
-      requests.add(request);
       requestStream.onNext(request);
     }
     requestStream.onCompleted();
     recorder.awaitCompletion();
     assertSuccess(recorder);
-    assertEquals(responseSizes.size() * numRequests, recorder.getValues().size());
+    assertEquals(responseSizes.size() * (long) numRequests, recorder.getValues().size());
     for (int ix = 0; ix < recorder.getValues().size(); ++ix) {
       StreamingOutputCallResponse response = recorder.getValues().get(ix);
-      assertEquals(COMPRESSABLE, response.getPayload().getType());
       int length = response.getPayload().getBody().size();
       int expectedSize = responseSizes.get(ix % responseSizes.size());
       assertEquals("comparison failed at index " + ix, expectedSize, length);
     }
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void serverStreamingShouldBeFlowControlled() throws Exception {
     final StreamingOutputCallRequest request = StreamingOutputCallRequest.newBuilder()
-        .setResponseType(COMPRESSABLE)
         .addResponseParameters(ResponseParameters.newBuilder().setSize(100000))
         .addResponseParameters(ResponseParameters.newBuilder().setSize(100001))
         .build();
     final List<StreamingOutputCallResponse> goldenResponses = Arrays.asList(
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-                .setType(PayloadType.COMPRESSABLE)
                 .setBody(ByteString.copyFrom(new byte[100000]))).build(),
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-                .setType(PayloadType.COMPRESSABLE)
                 .setBody(ByteString.copyFrom(new byte[100001]))).build());
 
     long start = System.nanoTime();
 
-    final ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<Object>(10);
+    final ArrayBlockingQueue<Object> queue = new ArrayBlockingQueue<>(10);
     ClientCall<StreamingOutputCallRequest, StreamingOutputCallResponse> call =
-        channel.newCall(TestServiceGrpc.METHOD_STREAMING_OUTPUT_CALL, CallOptions.DEFAULT);
+        channel.newCall(TestServiceGrpc.getStreamingOutputCallMethod(), CallOptions.DEFAULT);
     call.start(new ClientCall.Listener<StreamingOutputCallResponse>() {
       @Override
       public void onHeaders(Metadata headers) {}
@@ -557,8 +950,9 @@ public void onClose(Status status, Metadata trailers) {
 
     // Time how long it takes to get the first response.
     call.request(1);
-    assertEquals(goldenResponses.get(0),
-        queue.poll(operationTimeoutMillis(), TimeUnit.MILLISECONDS));
+    Object response = queue.poll(operationTimeoutMillis(), TimeUnit.MILLISECONDS);
+    assertTrue(response instanceof StreamingOutputCallResponse);
+    assertResponse(goldenResponses.get(0), (StreamingOutputCallResponse) response);
     long firstCallDuration = System.nanoTime() - start;
 
     // Without giving additional flow control, make sure that we don't get another response. We wait
@@ -570,92 +964,83 @@ public void onClose(Status status, Metadata trailers) {
 
     // Make sure that everything still completes.
     call.request(1);
-    assertEquals(goldenResponses.get(1),
-        queue.poll(operationTimeoutMillis(), TimeUnit.MILLISECONDS));
+    response = queue.poll(operationTimeoutMillis(), TimeUnit.MILLISECONDS);
+    assertTrue(response instanceof StreamingOutputCallResponse);
+    assertResponse(goldenResponses.get(1), (StreamingOutputCallResponse) response);
     assertEquals(Status.OK, queue.poll(operationTimeoutMillis(), TimeUnit.MILLISECONDS));
   }
 
-  @Test(timeout = 30000)
+  @Test
   public void veryLargeRequest() throws Exception {
     assumeEnoughMemory();
     final SimpleRequest request = SimpleRequest.newBuilder()
         .setPayload(Payload.newBuilder()
-            .setType(PayloadType.COMPRESSABLE)
             .setBody(ByteString.copyFrom(new byte[unaryPayloadLength()])))
         .setResponseSize(10)
-        .setResponseType(PayloadType.COMPRESSABLE)
         .build();
     final SimpleResponse goldenResponse = SimpleResponse.newBuilder()
         .setPayload(Payload.newBuilder()
-            .setType(PayloadType.COMPRESSABLE)
             .setBody(ByteString.copyFrom(new byte[10])))
         .build();
 
-    assertEquals(goldenResponse, blockingStub.unaryCall(request));
+    assertResponse(goldenResponse, blockingStub.unaryCall(request));
   }
 
-  @Test(timeout = 30000)
+  @Test
   public void veryLargeResponse() throws Exception {
     assumeEnoughMemory();
     final SimpleRequest request = SimpleRequest.newBuilder()
         .setResponseSize(unaryPayloadLength())
-        .setResponseType(PayloadType.COMPRESSABLE)
         .build();
     final SimpleResponse goldenResponse = SimpleResponse.newBuilder()
         .setPayload(Payload.newBuilder()
-            .setType(PayloadType.COMPRESSABLE)
             .setBody(ByteString.copyFrom(new byte[unaryPayloadLength()])))
         .build();
 
-    assertEquals(goldenResponse, blockingStub.unaryCall(request));
+    assertResponse(goldenResponse, blockingStub.unaryCall(request));
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void exchangeMetadataUnaryCall() throws Exception {
-    TestServiceGrpc.TestServiceBlockingStub stub =
-        TestServiceGrpc.newBlockingStub(channel);
-
     // Capture the metadata exchange
     Metadata fixedHeaders = new Metadata();
-    // Send a context proto (as it's in the default extension registry)
-    Messages.SimpleContext contextValue =
-        Messages.SimpleContext.newBuilder().setValue("dog").build();
-    fixedHeaders.put(METADATA_KEY, contextValue);
-    stub = MetadataUtils.attachHeaders(stub, fixedHeaders);
+    // Send a metadata proto
+    StringValue metadataValue = StringValue.newBuilder().setValue("dog").build();
+    fixedHeaders.put(Util.METADATA_KEY, metadataValue);
     // .. and expect it to be echoed back in trailers
-    AtomicReference<Metadata> trailersCapture = new AtomicReference<Metadata>();
-    AtomicReference<Metadata> headersCapture = new AtomicReference<Metadata>();
-    stub = MetadataUtils.captureMetadata(stub, headersCapture, trailersCapture);
+    AtomicReference<Metadata> trailersCapture = new AtomicReference<>();
+    AtomicReference<Metadata> headersCapture = new AtomicReference<>();
+    TestServiceGrpc.TestServiceBlockingStub stub = blockingStub.withInterceptors(
+        MetadataUtils.newAttachHeadersInterceptor(fixedHeaders),
+        MetadataUtils.newCaptureMetadataInterceptor(headersCapture, trailersCapture));
 
     assertNotNull(stub.emptyCall(EMPTY));
 
     // Assert that our side channel object is echoed back in both headers and trailers
-    Assert.assertEquals(contextValue, headersCapture.get().get(METADATA_KEY));
-    Assert.assertEquals(contextValue, trailersCapture.get().get(METADATA_KEY));
+    Assert.assertEquals(metadataValue, headersCapture.get().get(Util.METADATA_KEY));
+    Assert.assertEquals(metadataValue, trailersCapture.get().get(Util.METADATA_KEY));
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void exchangeMetadataStreamingCall() throws Exception {
-    TestServiceGrpc.TestServiceStub stub = TestServiceGrpc.newStub(channel);
-
     // Capture the metadata exchange
     Metadata fixedHeaders = new Metadata();
-    // Send a context proto (as it's in the default extension registry)
-    Messages.SimpleContext contextValue =
-        Messages.SimpleContext.newBuilder().setValue("dog").build();
-    fixedHeaders.put(METADATA_KEY, contextValue);
-    stub = MetadataUtils.attachHeaders(stub, fixedHeaders);
+    // Send a metadata proto
+    StringValue metadataValue = StringValue.newBuilder().setValue("dog").build();
+    fixedHeaders.put(Util.METADATA_KEY, metadataValue);
     // .. and expect it to be echoed back in trailers
-    AtomicReference<Metadata> trailersCapture = new AtomicReference<Metadata>();
-    AtomicReference<Metadata> headersCapture = new AtomicReference<Metadata>();
-    stub = MetadataUtils.captureMetadata(stub, headersCapture, trailersCapture);
+    AtomicReference<Metadata> trailersCapture = new AtomicReference<>();
+    AtomicReference<Metadata> headersCapture = new AtomicReference<>();
+    TestServiceGrpc.TestServiceStub stub = asyncStub.withInterceptors(
+        MetadataUtils.newAttachHeadersInterceptor(fixedHeaders),
+        MetadataUtils.newCaptureMetadataInterceptor(headersCapture, trailersCapture));
 
     List<Integer> responseSizes = Arrays.asList(50, 100, 150, 200);
     Messages.StreamingOutputCallRequest.Builder streamingOutputBuilder =
         Messages.StreamingOutputCallRequest.newBuilder();
-    streamingOutputBuilder.setResponseType(COMPRESSABLE);
     for (Integer size : responseSizes) {
-      streamingOutputBuilder.addResponseParametersBuilder().setSize(size).setIntervalUs(0);
+      streamingOutputBuilder.addResponseParameters(
+          ResponseParameters.newBuilder().setSize(size).setIntervalUs(0));
     }
     final Messages.StreamingOutputCallRequest request = streamingOutputBuilder.build();
 
@@ -664,28 +1049,26 @@ public void exchangeMetadataStreamingCall() throws Exception {
         stub.fullDuplexCall(recorder);
 
     final int numRequests = 10;
-    List<StreamingOutputCallRequest> requests =
-        new ArrayList<StreamingOutputCallRequest>(numRequests);
-
     for (int ix = numRequests; ix > 0; --ix) {
-      requests.add(request);
       requestStream.onNext(request);
     }
     requestStream.onCompleted();
     recorder.awaitCompletion();
     assertSuccess(recorder);
-    org.junit.Assert.assertEquals(responseSizes.size() * numRequests, recorder.getValues().size());
+    org.junit.Assert.assertEquals(
+        responseSizes.size() * (long) numRequests, recorder.getValues().size());
 
     // Assert that our side channel object is echoed back in both headers and trailers
-    Assert.assertEquals(contextValue, headersCapture.get().get(METADATA_KEY));
-    Assert.assertEquals(contextValue, trailersCapture.get().get(METADATA_KEY));
+    Assert.assertEquals(metadataValue, headersCapture.get().get(Util.METADATA_KEY));
+    Assert.assertEquals(metadataValue, trailersCapture.get().get(Util.METADATA_KEY));
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void sendsTimeoutHeader() {
+    Assume.assumeTrue("can not capture request headers on server side", server != null);
     long configuredTimeoutMinutes = 100;
-    TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(channel)
-        .withDeadlineAfter(configuredTimeoutMinutes, TimeUnit.MINUTES);
+    TestServiceGrpc.TestServiceBlockingStub stub =
+        blockingStub.withDeadlineAfter(configuredTimeoutMinutes, TimeUnit.MINUTES);
     stub.emptyCall(EMPTY);
     long transferredTimeoutMinutes = TimeUnit.NANOSECONDS.toMinutes(
         requestHeadersCapture.get().get(GrpcUtil.TIMEOUT_KEY));
@@ -700,7 +1083,7 @@ public void sendsTimeoutHeader() {
   public void deadlineNotExceeded() {
     // warm up the channel and JVM
     blockingStub.emptyCall(Empty.getDefaultInstance());
-    TestServiceGrpc.newBlockingStub(channel)
+    blockingStub
         .withDeadlineAfter(10, TimeUnit.SECONDS)
         .streamingOutputCall(StreamingOutputCallRequest.newBuilder()
             .addResponseParameters(ResponseParameters.newBuilder()
@@ -708,154 +1091,246 @@ public void deadlineNotExceeded() {
                 .build()).next();
   }
 
-  @Test(timeout = 10000)
-  public void deadlineExceeded() {
+  @Test
+  public void deadlineExceeded() throws Exception {
     // warm up the channel and JVM
     blockingStub.emptyCall(Empty.getDefaultInstance());
-    TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(channel)
-        .withDeadlineAfter(10, TimeUnit.MILLISECONDS);
+    TestServiceGrpc.TestServiceBlockingStub stub =
+        blockingStub.withDeadlineAfter(1, TimeUnit.SECONDS);
     StreamingOutputCallRequest request = StreamingOutputCallRequest.newBuilder()
         .addResponseParameters(ResponseParameters.newBuilder()
-            .setIntervalUs(20000))
+            .setIntervalUs((int) TimeUnit.SECONDS.toMicros(20)))
         .build();
     try {
       stub.streamingOutputCall(request).next();
       fail("Expected deadline to be exceeded");
     } catch (StatusRuntimeException ex) {
-      assertEquals(Status.DEADLINE_EXCEEDED.getCode(), ex.getStatus().getCode());
+      assertCodeEquals(Status.Code.DEADLINE_EXCEEDED, ex.getStatus());
+      String desc = ex.getStatus().getDescription();
+      assertTrue(desc,
+          // There is a race between client and server-side deadline expiration.
+          // If client expires first, it'd generate this message
+          Pattern.matches("CallOptions deadline exceeded after .*s. \\[.*\\]", desc)
+          // If server expires first, it'd reset the stream and client would generate a different
+          // message
+          || desc.startsWith("ClientCall was cancelled at or after deadline."));
     }
+
+    assertStatsTrace("grpc.testing.TestService/EmptyCall", Status.Code.OK);
     if (metricsExpected()) {
-      assertMetrics("grpc.testing.TestService/EmptyCall", Status.Code.OK);
-      assertClientMetrics("grpc.testing.TestService/StreamingOutputCall",
-          Status.Code.DEADLINE_EXCEEDED);
+      // Stream may not have been created before deadline is exceeded, thus we don't test the tracer
+      // stats.
+      MetricsRecord clientStartRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      checkStartTags(
+          clientStartRecord, "grpc.testing.TestService/StreamingOutputCall", true);
+      MetricsRecord clientEndRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      checkEndTags(
+          clientEndRecord,
+          "grpc.testing.TestService/StreamingOutputCall",
+          Status.Code.DEADLINE_EXCEEDED, true);
       // Do not check server-side metrics, because the status on the server side is undetermined.
     }
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void deadlineExceededServerStreaming() throws Exception {
     // warm up the channel and JVM
     blockingStub.emptyCall(Empty.getDefaultInstance());
+    assertStatsTrace("grpc.testing.TestService/EmptyCall", Status.Code.OK);
     ResponseParameters.Builder responseParameters = ResponseParameters.newBuilder()
         .setSize(1)
         .setIntervalUs(10000);
     StreamingOutputCallRequest request = StreamingOutputCallRequest.newBuilder()
-        .setResponseType(PayloadType.COMPRESSABLE)
         .addResponseParameters(responseParameters)
         .addResponseParameters(responseParameters)
         .addResponseParameters(responseParameters)
         .addResponseParameters(responseParameters)
         .build();
     StreamRecorder<StreamingOutputCallResponse> recorder = StreamRecorder.create();
-    TestServiceGrpc.newStub(channel)
+    asyncStub
         .withDeadlineAfter(30, TimeUnit.MILLISECONDS)
         .streamingOutputCall(request, recorder);
     recorder.awaitCompletion();
-    assertEquals(Status.DEADLINE_EXCEEDED.getCode(),
-        Status.fromThrowable(recorder.getError()).getCode());
+    assertCodeEquals(Status.Code.DEADLINE_EXCEEDED, Status.fromThrowable(recorder.getError()));
     if (metricsExpected()) {
-      assertMetrics("grpc.testing.TestService/EmptyCall", Status.Code.OK);
-      assertClientMetrics("grpc.testing.TestService/StreamingOutputCall",
-          Status.Code.DEADLINE_EXCEEDED);
+      // Stream may not have been created when deadline is exceeded, thus we don't check tracer
+      // stats.
+      MetricsRecord clientStartRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      checkStartTags(
+          clientStartRecord, "grpc.testing.TestService/StreamingOutputCall", true);
+      MetricsRecord clientEndRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      checkEndTags(
+          clientEndRecord,
+          "grpc.testing.TestService/StreamingOutputCall",
+          Status.Code.DEADLINE_EXCEEDED, true);
       // Do not check server-side metrics, because the status on the server side is undetermined.
     }
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void deadlineInPast() throws Exception {
     // Test once with idle channel and once with active channel
     try {
-      TestServiceGrpc.newBlockingStub(channel)
+      blockingStub
           .withDeadlineAfter(-10, TimeUnit.SECONDS)
           .emptyCall(Empty.getDefaultInstance());
       fail("Should have thrown");
     } catch (StatusRuntimeException ex) {
-      assertEquals(Status.Code.DEADLINE_EXCEEDED, ex.getStatus().getCode());
+      assertCodeEquals(Status.Code.DEADLINE_EXCEEDED, ex.getStatus());
+      assertThat(ex.getStatus().getDescription())
+          .startsWith("ClientCall started after CallOptions deadline was exceeded");
     }
+
+    // CensusStreamTracerModule record final status in the interceptor, thus is guaranteed to be
+    // recorded.  The tracer stats rely on the stream being created, which is not the case if
+    // deadline is exceeded before the call is created. Therefore we don't check the tracer stats.
     if (metricsExpected()) {
-      assertClientMetrics("grpc.testing.TestService/EmptyCall", Status.Code.DEADLINE_EXCEEDED);
+      MetricsRecord clientStartRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      checkStartTags(clientStartRecord, "grpc.testing.TestService/EmptyCall", true);
+      MetricsRecord clientEndRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      checkEndTags(
+          clientEndRecord, "grpc.testing.TestService/EmptyCall",
+          Status.DEADLINE_EXCEEDED.getCode(), true);
+      assertZeroRetryRecorded();
     }
 
     // warm up the channel
     blockingStub.emptyCall(Empty.getDefaultInstance());
+    if (metricsExpected()) {
+      // clientStartRecord
+      clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      // clientEndRecord
+      clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      assertZeroRetryRecorded();
+    }
     try {
-      TestServiceGrpc.newBlockingStub(channel)
+      blockingStub
           .withDeadlineAfter(-10, TimeUnit.SECONDS)
           .emptyCall(Empty.getDefaultInstance());
       fail("Should have thrown");
     } catch (StatusRuntimeException ex) {
-      assertEquals(Status.Code.DEADLINE_EXCEEDED, ex.getStatus().getCode());
+      assertCodeEquals(Status.Code.DEADLINE_EXCEEDED, ex.getStatus());
+      assertThat(ex.getStatus().getDescription())
+          .startsWith("ClientCall started after CallOptions deadline was exceeded");
     }
     if (metricsExpected()) {
-      assertMetrics("grpc.testing.TestService/EmptyCall", Status.Code.OK);
-      assertClientMetrics("grpc.testing.TestService/EmptyCall", Status.Code.DEADLINE_EXCEEDED);
+      MetricsRecord clientStartRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      checkStartTags(clientStartRecord, "grpc.testing.TestService/EmptyCall", true);
+      MetricsRecord clientEndRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      checkEndTags(
+          clientEndRecord, "grpc.testing.TestService/EmptyCall",
+          Status.DEADLINE_EXCEEDED.getCode(), true);
+      assertZeroRetryRecorded();
     }
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void maxInboundSize_exact() {
     StreamingOutputCallRequest request = StreamingOutputCallRequest.newBuilder()
         .addResponseParameters(ResponseParameters.newBuilder().setSize(1))
         .build();
-    int size = blockingStub.streamingOutputCall(request).next().getSerializedSize();
 
-    TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(channel)
-        .withMaxInboundMessageSize(size);
+    MethodDescriptor<StreamingOutputCallRequest, StreamingOutputCallResponse> md =
+        TestServiceGrpc.getStreamingOutputCallMethod();
+    ByteSizeMarshaller<StreamingOutputCallResponse> mar =
+        new ByteSizeMarshaller<>(md.getResponseMarshaller());
+    blockingServerStreamingCall(
+        blockingStub.getChannel(),
+        md.toBuilder(md.getRequestMarshaller(), mar).build(),
+        blockingStub.getCallOptions(),
+        request)
+        .next();
+
+    int size = mar.lastInSize;
+
+    TestServiceGrpc.TestServiceBlockingStub stub =
+        blockingStub.withMaxInboundMessageSize(size);
 
     stub.streamingOutputCall(request).next();
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void maxInboundSize_tooBig() {
     StreamingOutputCallRequest request = StreamingOutputCallRequest.newBuilder()
         .addResponseParameters(ResponseParameters.newBuilder().setSize(1))
         .build();
-    int size = blockingStub.streamingOutputCall(request).next().getSerializedSize();
 
-    TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(channel)
-        .withMaxInboundMessageSize(size - 1);
+    MethodDescriptor<StreamingOutputCallRequest, StreamingOutputCallResponse> md =
+        TestServiceGrpc.getStreamingOutputCallMethod();
+    ByteSizeMarshaller<StreamingOutputCallRequest> mar =
+        new ByteSizeMarshaller<>(md.getRequestMarshaller());
+    blockingServerStreamingCall(
+        blockingStub.getChannel(),
+        md.toBuilder(mar, md.getResponseMarshaller()).build(),
+        blockingStub.getCallOptions(),
+        request)
+        .next();
+
+    int size = mar.lastOutSize;
+
+    TestServiceGrpc.TestServiceBlockingStub stub =
+        blockingStub.withMaxInboundMessageSize(size - 1);
 
     try {
       stub.streamingOutputCall(request).next();
       fail();
     } catch (StatusRuntimeException ex) {
-      Status s = ex.getStatus();
-      assertThat(s.getCode()).named(s.toString()).isEqualTo(Status.Code.INTERNAL);
+      assertCodeEquals(Status.Code.RESOURCE_EXHAUSTED, ex.getStatus());
       assertThat(Throwables.getStackTraceAsString(ex)).contains("exceeds maximum");
     }
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void maxOutboundSize_exact() {
-    // warm up the channel and JVM
-    blockingStub.emptyCall(Empty.getDefaultInstance());
-
-    // set at least one field to ensure the size is non-zero.
     StreamingOutputCallRequest request = StreamingOutputCallRequest.newBuilder()
         .addResponseParameters(ResponseParameters.newBuilder().setSize(1))
         .build();
-    TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(channel)
-        .withMaxOutboundMessageSize(request.getSerializedSize());
+
+    MethodDescriptor<StreamingOutputCallRequest, StreamingOutputCallResponse> md =
+        TestServiceGrpc.getStreamingOutputCallMethod();
+    ByteSizeMarshaller<StreamingOutputCallRequest> mar =
+        new ByteSizeMarshaller<>(md.getRequestMarshaller());
+    blockingServerStreamingCall(
+        blockingStub.getChannel(),
+        md.toBuilder(mar, md.getResponseMarshaller()).build(),
+        blockingStub.getCallOptions(),
+        request)
+        .next();
+
+    int size = mar.lastOutSize;
+
+    TestServiceGrpc.TestServiceBlockingStub stub =
+        blockingStub.withMaxOutboundMessageSize(size);
 
     stub.streamingOutputCall(request).next();
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void maxOutboundSize_tooBig() {
-    // warm up the channel and JVM
-    blockingStub.emptyCall(Empty.getDefaultInstance());
     // set at least one field to ensure the size is non-zero.
     StreamingOutputCallRequest request = StreamingOutputCallRequest.newBuilder()
         .addResponseParameters(ResponseParameters.newBuilder().setSize(1))
         .build();
-    TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(channel)
-        .withMaxOutboundMessageSize(request.getSerializedSize() - 1);
+
+
+    MethodDescriptor<StreamingOutputCallRequest, StreamingOutputCallResponse> md =
+        TestServiceGrpc.getStreamingOutputCallMethod();
+    ByteSizeMarshaller<StreamingOutputCallRequest> mar =
+        new ByteSizeMarshaller<>(md.getRequestMarshaller());
+    blockingServerStreamingCall(
+        blockingStub.getChannel(),
+        md.toBuilder(mar, md.getResponseMarshaller()).build(),
+        blockingStub.getCallOptions(),
+        request)
+        .next();
+
+    TestServiceGrpc.TestServiceBlockingStub stub =
+        blockingStub.withMaxOutboundMessageSize(mar.lastOutSize - 1);
     try {
       stub.streamingOutputCall(request).next();
       fail();
     } catch (StatusRuntimeException ex) {
-      Status s = ex.getStatus();
-      assertThat(s.getCode()).named(s.toString()).isEqualTo(Status.Code.CANCELLED);
+      assertCodeEquals(Status.Code.CANCELLED, ex.getStatus());
       assertThat(Throwables.getStackTraceAsString(ex)).contains("message too large");
     }
   }
@@ -865,7 +1340,7 @@ protected int unaryPayloadLength() {
     return 10485760;
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void gracefulShutdown() throws Exception {
     final List<StreamingOutputCallRequest> requests = Arrays.asList(
         StreamingOutputCallRequest.newBuilder()
@@ -889,62 +1364,79 @@ public void gracefulShutdown() throws Exception {
     final List<StreamingOutputCallResponse> goldenResponses = Arrays.asList(
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-                .setType(PayloadType.COMPRESSABLE)
                 .setBody(ByteString.copyFrom(new byte[3])))
             .build(),
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-                .setType(PayloadType.COMPRESSABLE)
                 .setBody(ByteString.copyFrom(new byte[1])))
             .build(),
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-                .setType(PayloadType.COMPRESSABLE)
                 .setBody(ByteString.copyFrom(new byte[4])))
             .build());
 
-    @SuppressWarnings("unchecked")
-    StreamObserver<StreamingOutputCallResponse> responseObserver = mock(StreamObserver.class);
+    final ArrayBlockingQueue<StreamingOutputCallResponse> responses =
+        new ArrayBlockingQueue<>(3);
+    final SettableFuture<Void> completed = SettableFuture.create();
+    final SettableFuture<Void> errorSeen = SettableFuture.create();
+    StreamObserver<StreamingOutputCallResponse> responseObserver =
+        new StreamObserver<StreamingOutputCallResponse>() {
+
+          @Override
+          public void onNext(StreamingOutputCallResponse value) {
+            responses.add(value);
+          }
+
+          @Override
+          public void onError(Throwable t) {
+            errorSeen.set(null);
+          }
+
+          @Override
+          public void onCompleted() {
+            completed.set(null);
+          }
+        };
     StreamObserver<StreamingOutputCallRequest> requestObserver
         = asyncStub.fullDuplexCall(responseObserver);
     requestObserver.onNext(requests.get(0));
-    verify(responseObserver, timeout(operationTimeoutMillis())).onNext(goldenResponses.get(0));
+    assertResponse(
+        goldenResponses.get(0), responses.poll(operationTimeoutMillis(), TimeUnit.MILLISECONDS));
     // Initiate graceful shutdown.
     channel.shutdown();
     requestObserver.onNext(requests.get(1));
-    verify(responseObserver, timeout(operationTimeoutMillis())).onNext(goldenResponses.get(1));
+    assertResponse(
+        goldenResponses.get(1), responses.poll(operationTimeoutMillis(), TimeUnit.MILLISECONDS));
     // The previous ping-pong could have raced with the shutdown, but this one certainly shouldn't.
     requestObserver.onNext(requests.get(2));
-    verify(responseObserver, timeout(operationTimeoutMillis())).onNext(goldenResponses.get(2));
+    assertResponse(
+        goldenResponses.get(2), responses.poll(operationTimeoutMillis(), TimeUnit.MILLISECONDS));
+    assertFalse(completed.isDone());
     requestObserver.onCompleted();
-    verify(responseObserver, timeout(operationTimeoutMillis())).onCompleted();
-    verifyNoMoreInteractions(responseObserver);
+    completed.get(operationTimeoutMillis(), TimeUnit.MILLISECONDS);
+    assertFalse(errorSeen.isDone());
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void customMetadata() throws Exception {
     final int responseSize = 314159;
     final int requestSize = 271828;
     final SimpleRequest request = SimpleRequest.newBuilder()
         .setResponseSize(responseSize)
-        .setResponseType(PayloadType.COMPRESSABLE)
         .setPayload(Payload.newBuilder()
             .setBody(ByteString.copyFrom(new byte[requestSize])))
         .build();
     final StreamingOutputCallRequest streamingRequest = StreamingOutputCallRequest.newBuilder()
         .addResponseParameters(ResponseParameters.newBuilder().setSize(responseSize))
-        .setResponseType(PayloadType.COMPRESSABLE)
         .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[requestSize])))
         .build();
     final SimpleResponse goldenResponse = SimpleResponse.newBuilder()
         .setPayload(Payload.newBuilder()
-            .setType(PayloadType.COMPRESSABLE)
             .setBody(ByteString.copyFrom(new byte[responseSize])))
         .build();
     final StreamingOutputCallResponse goldenStreamingResponse =
         StreamingOutputCallResponse.newBuilder()
             .setPayload(Payload.newBuilder()
-            .setType(PayloadType.COMPRESSABLE)
             .setBody(ByteString.copyFrom(new byte[responseSize])))
         .build();
     final byte[] trailingBytes =
@@ -954,32 +1446,30 @@ public void customMetadata() throws Exception {
     Metadata metadata = new Metadata();
     metadata.put(Util.ECHO_INITIAL_METADATA_KEY, "test_initial_metadata_value");
     metadata.put(Util.ECHO_TRAILING_METADATA_KEY, trailingBytes);
-    TestServiceGrpc.TestServiceBlockingStub blockingStub = TestServiceGrpc.newBlockingStub(channel);
-    blockingStub = MetadataUtils.attachHeaders(blockingStub, metadata);
-    AtomicReference<Metadata> headersCapture = new AtomicReference<Metadata>();
-    AtomicReference<Metadata> trailersCapture = new AtomicReference<Metadata>();
-    blockingStub = MetadataUtils.captureMetadata(blockingStub, headersCapture, trailersCapture);
+    AtomicReference<Metadata> headersCapture = new AtomicReference<>();
+    AtomicReference<Metadata> trailersCapture = new AtomicReference<>();
+    TestServiceGrpc.TestServiceBlockingStub blockingStub = this.blockingStub.withInterceptors(
+        MetadataUtils.newAttachHeadersInterceptor(metadata),
+        MetadataUtils.newCaptureMetadataInterceptor(headersCapture, trailersCapture));
     SimpleResponse response = blockingStub.unaryCall(request);
 
-    assertEquals(goldenResponse, response);
+    assertResponse(goldenResponse, response);
     assertEquals("test_initial_metadata_value",
         headersCapture.get().get(Util.ECHO_INITIAL_METADATA_KEY));
     assertTrue(
         Arrays.equals(trailingBytes, trailersCapture.get().get(Util.ECHO_TRAILING_METADATA_KEY)));
-    if (metricsExpected()) {
-      assertMetrics("grpc.testing.TestService/UnaryCall", Status.Code.OK,
-          Collections.singleton(request), Collections.singleton(goldenResponse));
-    }
+    assertStatsTrace("grpc.testing.TestService/UnaryCall", Status.Code.OK,
+        Collections.singleton(request), Collections.singleton(goldenResponse));
 
     // Test FullDuplexCall
     metadata = new Metadata();
     metadata.put(Util.ECHO_INITIAL_METADATA_KEY, "test_initial_metadata_value");
     metadata.put(Util.ECHO_TRAILING_METADATA_KEY, trailingBytes);
-    TestServiceGrpc.TestServiceStub stub = TestServiceGrpc.newStub(channel);
-    stub = MetadataUtils.attachHeaders(stub, metadata);
-    headersCapture = new AtomicReference<Metadata>();
-    trailersCapture = new AtomicReference<Metadata>();
-    stub = MetadataUtils.captureMetadata(stub, headersCapture, trailersCapture);
+    headersCapture = new AtomicReference<>();
+    trailersCapture = new AtomicReference<>();
+    TestServiceGrpc.TestServiceStub stub = asyncStub.withInterceptors(
+        MetadataUtils.newAttachHeadersInterceptor(metadata),
+        MetadataUtils.newCaptureMetadataInterceptor(headersCapture, trailersCapture));
 
     StreamRecorder<Messages.StreamingOutputCallResponse> recorder = StreamRecorder.create();
     StreamObserver<Messages.StreamingOutputCallRequest> requestStream =
@@ -989,18 +1479,60 @@ public void customMetadata() throws Exception {
     recorder.awaitCompletion();
 
     assertSuccess(recorder);
-    assertEquals(goldenStreamingResponse, recorder.firstValue().get());
+    assertResponse(goldenStreamingResponse, recorder.firstValue().get());
     assertEquals("test_initial_metadata_value",
         headersCapture.get().get(Util.ECHO_INITIAL_METADATA_KEY));
     assertTrue(
         Arrays.equals(trailingBytes, trailersCapture.get().get(Util.ECHO_TRAILING_METADATA_KEY)));
-    if (metricsExpected()) {
-      assertMetrics("grpc.testing.TestService/FullDuplexCall", Status.Code.OK,
-          Collections.singleton(streamingRequest), Collections.singleton(goldenStreamingResponse));
-    }
+    assertStatsTrace("grpc.testing.TestService/FullDuplexCall", Status.Code.OK,
+        Collections.singleton(streamingRequest), Collections.singleton(goldenStreamingResponse));
   }
 
+  @SuppressWarnings("deprecation")
   @Test(timeout = 10000)
+  public void censusContextsPropagated() {
+    Assume.assumeTrue("Skip the test because server is not in the same process.", server != null);
+    Assume.assumeTrue(customCensusModulePresent());
+    Span clientParentSpan = Tracing.getTracer().spanBuilder("Test.interopTest").startSpan();
+    // A valid ID is guaranteed to be unique, so we can verify it is actually propagated.
+    assertTrue(clientParentSpan.getContext().getTraceId().isValid());
+    Context ctx =
+        io.opencensus.tags.unsafe.ContextUtils.withValue(
+            Context.ROOT,
+            tagger
+                .emptyBuilder()
+                .putLocal(StatsTestUtils.EXTRA_TAG, TagValue.create("extra value"))
+                .build());
+    ctx = io.opencensus.trace.unsafe.ContextUtils.withValue(ctx, clientParentSpan);
+    Context origCtx = ctx.attach();
+    try {
+      blockingStub.unaryCall(SimpleRequest.getDefaultInstance());
+      Context serverCtx = contextCapture.get();
+      assertNotNull(serverCtx);
+
+      FakeTagContext statsCtx =
+          (FakeTagContext) io.opencensus.tags.unsafe.ContextUtils.getValue(serverCtx);
+      assertNotNull(statsCtx);
+      Map<TagKey, TagValue> tags = statsCtx.getTags();
+      boolean tagFound = false;
+      for (Map.Entry<TagKey, TagValue> tag : tags.entrySet()) {
+        if (tag.getKey().equals(StatsTestUtils.EXTRA_TAG)) {
+          assertEquals(TagValue.create("extra value"), tag.getValue());
+          tagFound = true;
+        }
+      }
+      assertTrue("tag not found", tagFound);
+
+      Span span = io.opencensus.trace.unsafe.ContextUtils.getValue(serverCtx);
+      assertNotNull(span);
+      SpanContext spanContext = span.getContext();
+      assertEquals(clientParentSpan.getContext().getTraceId(), spanContext.getTraceId());
+    } finally {
+      ctx.detach(origCtx);
+    }
+  }
+
+  @Test
   public void statusCodeAndMessage() throws Exception {
     int errorCode = 2;
     String errorMessage = "test status message";
@@ -1020,274 +1552,202 @@ public void statusCodeAndMessage() throws Exception {
       blockingStub.unaryCall(simpleRequest);
       fail();
     } catch (StatusRuntimeException e) {
-      assertEquals(Status.UNKNOWN.getCode(), e.getStatus().getCode());
+      assertCodeEquals(Status.Code.UNKNOWN, e.getStatus());
       assertEquals(errorMessage, e.getStatus().getDescription());
     }
-    if (metricsExpected()) {
-      assertClientMetrics("grpc.testing.TestService/UnaryCall", Status.Code.UNKNOWN);
-    }
+    assertStatsTrace("grpc.testing.TestService/UnaryCall", Status.Code.UNKNOWN);
 
     // Test FullDuplexCall
-    @SuppressWarnings("unchecked")
-    StreamObserver<StreamingOutputCallResponse> responseObserver =
-        mock(StreamObserver.class);
+    StreamRecorder<StreamingOutputCallResponse> responseObserver = StreamRecorder.create();
     StreamObserver<StreamingOutputCallRequest> requestObserver
         = asyncStub.fullDuplexCall(responseObserver);
     requestObserver.onNext(streamingRequest);
     requestObserver.onCompleted();
 
-    ArgumentCaptor<Throwable> captor = ArgumentCaptor.forClass(Throwable.class);
-    verify(responseObserver, timeout(operationTimeoutMillis())).onError(captor.capture());
-    assertEquals(Status.UNKNOWN.getCode(), Status.fromThrowable(captor.getValue()).getCode());
-    assertEquals(errorMessage, Status.fromThrowable(captor.getValue()).getDescription());
-    verifyNoMoreInteractions(responseObserver);
-    if (metricsExpected()) {
-      assertClientMetrics("grpc.testing.TestService/FullDuplexCall", Status.Code.UNKNOWN);
+    assertThat(responseObserver.awaitCompletion(operationTimeoutMillis(), TimeUnit.MILLISECONDS))
+        .isTrue();
+    assertThat(responseObserver.getError()).isNotNull();
+    Status status = Status.fromThrowable(responseObserver.getError());
+    assertCodeEquals(Status.Code.UNKNOWN, status);
+    assertEquals(errorMessage, status.getDescription());
+    assertStatsTrace("grpc.testing.TestService/FullDuplexCall", Status.Code.UNKNOWN);
+  }
+
+  @Test
+  public void specialStatusMessage() throws Exception {
+    int errorCode = 2;
+    String errorMessage = "\t\ntest with whitespace\r\nand Unicode BMP ☺ and non-BMP 😈\t\n";
+    SimpleRequest simpleRequest = SimpleRequest.newBuilder()
+        .setResponseStatus(EchoStatus.newBuilder()
+            .setCode(errorCode)
+            .setMessage(errorMessage)
+            .build())
+        .build();
+
+    try {
+      blockingStub.unaryCall(simpleRequest);
+      fail();
+    } catch (StatusRuntimeException e) {
+      assertCodeEquals(Status.Code.UNKNOWN, e.getStatus());
+      assertEquals(errorMessage, e.getStatus().getDescription());
     }
+    assertStatsTrace("grpc.testing.TestService/UnaryCall", Status.Code.UNKNOWN);
   }
 
   /** Sends an rpc to an unimplemented method within TestService. */
-  @Test(timeout = 10000)
+  @Test
   public void unimplementedMethod() {
     try {
       blockingStub.unimplementedCall(Empty.getDefaultInstance());
       fail();
     } catch (StatusRuntimeException e) {
-      assertEquals(Status.UNIMPLEMENTED.getCode(), e.getStatus().getCode());
+      assertCodeEquals(Status.Code.UNIMPLEMENTED, e.getStatus());
     }
 
-    if (metricsExpected()) {
-      assertClientMetrics("grpc.testing.TestService/UnimplementedCall",
-          Status.Code.UNIMPLEMENTED);
-    }
+    assertClientStatsTrace("grpc.testing.TestService/UnimplementedCall",
+        Status.Code.UNIMPLEMENTED);
   }
 
   /** Sends an rpc to an unimplemented service on the server. */
-  @Test(timeout = 10000)
+  @Test
   public void unimplementedService() {
     UnimplementedServiceGrpc.UnimplementedServiceBlockingStub stub =
-        UnimplementedServiceGrpc.newBlockingStub(channel);
+        UnimplementedServiceGrpc.newBlockingStub(channel).withInterceptors(tracerSetupInterceptor);
     try {
       stub.unimplementedCall(Empty.getDefaultInstance());
       fail();
     } catch (StatusRuntimeException e) {
-      assertEquals(Status.UNIMPLEMENTED.getCode(), e.getStatus().getCode());
+      assertCodeEquals(Status.Code.UNIMPLEMENTED, e.getStatus());
     }
 
-    if (metricsExpected()) {
-      assertMetrics("grpc.testing.UnimplementedService/UnimplementedCall",
-          Status.Code.UNIMPLEMENTED);
-    }
+    assertStatsTrace("grpc.testing.UnimplementedService/UnimplementedCall",
+        Status.Code.UNIMPLEMENTED);
   }
 
   /** Start a fullDuplexCall which the server will not respond, and verify the deadline expires. */
-  @Test(timeout = 10000)
+  @Test
   public void timeoutOnSleepingServer() throws Exception {
-    TestServiceGrpc.TestServiceStub stub = TestServiceGrpc.newStub(channel)
-        .withDeadlineAfter(1, TimeUnit.MILLISECONDS);
+    TestServiceGrpc.TestServiceStub stub =
+        asyncStub.withDeadlineAfter(1, TimeUnit.MILLISECONDS);
 
     StreamRecorder<StreamingOutputCallResponse> responseObserver = StreamRecorder.create();
     StreamObserver<StreamingOutputCallRequest> requestObserver
         = stub.fullDuplexCall(responseObserver);
 
-    StreamingOutputCallRequest request = StreamingOutputCallRequest.newBuilder()
+    requestObserver.onNext(StreamingOutputCallRequest.newBuilder()
         .setPayload(Payload.newBuilder()
             .setBody(ByteString.copyFrom(new byte[27182])))
-        .build();
-    try {
-      requestObserver.onNext(request);
-    } catch (IllegalStateException expected) {
-      // This can happen if the stream has already been terminated due to deadline exceeded.
-    }
+        .build());
 
-    responseObserver.awaitCompletion(operationTimeoutMillis(), TimeUnit.MILLISECONDS);
+    assertTrue(responseObserver.awaitCompletion(operationTimeoutMillis(), TimeUnit.MILLISECONDS));
     assertEquals(0, responseObserver.getValues().size());
-    assertEquals(Status.DEADLINE_EXCEEDED.getCode(),
-                 Status.fromThrowable(responseObserver.getError()).getCode());
+    assertCodeEquals(
+        Status.Code.DEADLINE_EXCEEDED, Status.fromThrowable(responseObserver.getError()));
 
     if (metricsExpected()) {
-      assertClientMetrics("grpc.testing.TestService/FullDuplexCall", Status.Code.DEADLINE_EXCEEDED);
-      // Do not check server-side metrics, because the status on the server side is undetermined.
+      // CensusStreamTracerModule record final status in the interceptor, thus is guaranteed to be
+      // recorded.  The tracer stats rely on the stream being created, which is not always the case
+      // in this test, thus we will not check that.
+      MetricsRecord clientStartRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      checkStartTags(clientStartRecord, "grpc.testing.TestService/FullDuplexCall", true);
+      MetricsRecord clientEndRecord = clientStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+      checkEndTags(
+          clientEndRecord,
+          "grpc.testing.TestService/FullDuplexCall",
+          Status.DEADLINE_EXCEEDED.getCode(), true);
     }
   }
 
-  /** Sends a large unary rpc with service account credentials. */
-  public void serviceAccountCreds(String jsonKey, InputStream credentialsStream, String authScope)
-      throws Exception {
-    // cast to ServiceAccountCredentials to double-check the right type of object was created.
-    GoogleCredentials credentials =
-        ServiceAccountCredentials.class.cast(GoogleCredentials.fromStream(credentialsStream));
-    credentials = credentials.createScoped(Arrays.<String>asList(authScope));
-    TestServiceGrpc.TestServiceBlockingStub stub = blockingStub
-        .withCallCredentials(MoreCallCredentials.from(credentials));
-    final SimpleRequest request = SimpleRequest.newBuilder()
-        .setFillUsername(true)
-        .setFillOauthScope(true)
-        .setResponseSize(314159)
-        .setResponseType(PayloadType.COMPRESSABLE)
-        .setPayload(Payload.newBuilder()
-            .setBody(ByteString.copyFrom(new byte[271828])))
-        .build();
-
-    final SimpleResponse response = stub.unaryCall(request);
-    assertFalse(response.getUsername().isEmpty());
-    assertTrue("Received username: " + response.getUsername(),
-        jsonKey.contains(response.getUsername()));
-    assertFalse(response.getOauthScope().isEmpty());
-    assertTrue("Received oauth scope: " + response.getOauthScope(),
-        authScope.contains(response.getOauthScope()));
+  /**
+   * Verifies remote server address and local client address are available from ClientCall
+   * Attributes via ClientInterceptor.
+   */
+  @Test
+  public void getServerAddressAndLocalAddressFromClient() {
+    assertNotNull(obtainRemoteServerAddr());
+    assertNotNull(obtainLocalClientAddr());
+  }
 
-    final SimpleResponse goldenResponse = SimpleResponse.newBuilder()
-        .setOauthScope(response.getOauthScope())
-        .setUsername(response.getUsername())
-        .setPayload(Payload.newBuilder()
-            .setType(PayloadType.COMPRESSABLE)
-            .setBody(ByteString.copyFrom(new byte[314159])))
-        .build();
-    assertEquals(goldenResponse, response);
+  private static void assertSuccess(StreamRecorder<?> recorder) {
+    if (recorder.getError() != null) {
+      throw new AssertionError(recorder.getError());
+    }
   }
 
-  /** Sends a large unary rpc with compute engine credentials. */
-  public void computeEngineCreds(String serviceAccount, String oauthScope) throws Exception {
-    ComputeEngineCredentials credentials = new ComputeEngineCredentials();
-    TestServiceGrpc.TestServiceBlockingStub stub = blockingStub
-        .withCallCredentials(MoreCallCredentials.from(credentials));
-    final SimpleRequest request = SimpleRequest.newBuilder()
-        .setFillUsername(true)
-        .setFillOauthScope(true)
-        .setResponseSize(314159)
-        .setResponseType(PayloadType.COMPRESSABLE)
-        .setPayload(Payload.newBuilder()
-            .setBody(ByteString.copyFrom(new byte[271828])))
-        .build();
+  /** Helper for getting remote address from {@link io.grpc.ServerCall#getAttributes()}. */
+  protected SocketAddress obtainRemoteClientAddr() {
+    TestServiceGrpc.TestServiceBlockingStub stub =
+        blockingStub.withDeadlineAfter(5, TimeUnit.SECONDS);
 
-    final SimpleResponse response = stub.unaryCall(request);
-    assertEquals(serviceAccount, response.getUsername());
-    assertFalse(response.getOauthScope().isEmpty());
-    assertTrue("Received oauth scope: " + response.getOauthScope(),
-        oauthScope.contains(response.getOauthScope()));
+    stub.unaryCall(SimpleRequest.getDefaultInstance());
 
-    final SimpleResponse goldenResponse = SimpleResponse.newBuilder()
-        .setOauthScope(response.getOauthScope())
-        .setUsername(response.getUsername())
-        .setPayload(Payload.newBuilder()
-            .setType(PayloadType.COMPRESSABLE)
-            .setBody(ByteString.copyFrom(new byte[314159])))
-        .build();
-    assertEquals(goldenResponse, response);
+    return serverCallCapture.get().getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
   }
 
-  /** Test JWT-based auth. */
-  public void jwtTokenCreds(InputStream serviceAccountJson) throws Exception {
-    final SimpleRequest request = SimpleRequest.newBuilder()
-        .setResponseType(PayloadType.COMPRESSABLE)
-        .setResponseSize(314159)
-        .setPayload(Payload.newBuilder()
-            .setBody(ByteString.copyFrom(new byte[271828])))
-        .setFillUsername(true)
-        .build();
-
-    ServiceAccountCredentials credentials = (ServiceAccountCredentials)
-        GoogleCredentials.fromStream(serviceAccountJson);
+  /** Helper for getting remote address from {@link io.grpc.ClientCall#getAttributes()}. */
+  protected SocketAddress obtainRemoteServerAddr() {
     TestServiceGrpc.TestServiceBlockingStub stub = blockingStub
-        .withCallCredentials(MoreCallCredentials.from(credentials));
-    SimpleResponse response = stub.unaryCall(request);
-    assertEquals(credentials.getClientEmail(), response.getUsername());
-    assertEquals(314159, response.getPayload().getBody().size());
-  }
-
-  /** Sends a unary rpc with raw oauth2 access token credentials. */
-  public void oauth2AuthToken(String jsonKey, InputStream credentialsStream, String authScope)
-      throws Exception {
-    GoogleCredentials utilCredentials =
-        GoogleCredentials.fromStream(credentialsStream);
-    utilCredentials = utilCredentials.createScoped(Arrays.<String>asList(authScope));
-    AccessToken accessToken = utilCredentials.refreshAccessToken();
-
-    // TODO(madongfly): The Auth library may have something like AccessTokenCredentials in the
-    // future, change to the official implementation then.
-    OAuth2Credentials credentials = new OAuth2Credentials(accessToken) {
-      @Override
-      public AccessToken refreshAccessToken() throws IOException {
-        throw new IOException("This credential is based on a certain AccessToken, "
-            + "so you can not refresh AccessToken");
-      }
-    };
+        .withInterceptors(recordClientCallInterceptor(clientCallCapture))
+        .withDeadlineAfter(5, TimeUnit.SECONDS);
 
-    TestServiceGrpc.TestServiceBlockingStub stub = blockingStub
-        .withCallCredentials(MoreCallCredentials.from(credentials));
-    final SimpleRequest request = SimpleRequest.newBuilder()
-        .setFillUsername(true)
-        .setFillOauthScope(true)
-        .build();
+    stub.unaryCall(SimpleRequest.getDefaultInstance());
 
-    final SimpleResponse response = stub.unaryCall(request);
-    assertFalse(response.getUsername().isEmpty());
-    assertTrue("Received username: " + response.getUsername(),
-        jsonKey.contains(response.getUsername()));
-    assertFalse(response.getOauthScope().isEmpty());
-    assertTrue("Received oauth scope: " + response.getOauthScope(),
-        authScope.contains(response.getOauthScope()));
+    return clientCallCapture.get().getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
   }
 
-  /** Sends a unary rpc with "per rpc" raw oauth2 access token credentials. */
-  public void perRpcCreds(String jsonKey, InputStream credentialsStream, String oauthScope)
-      throws Exception {
-    // In gRpc Java, we don't have per Rpc credentials, user can use an intercepted stub only once
-    // for that purpose.
-    // So, this test is identical to oauth2_auth_token test.
-    oauth2AuthToken(jsonKey, credentialsStream, oauthScope);
-  }
+  /** Helper for getting local address from {@link io.grpc.ServerCall#getAttributes()}. */
+  protected SocketAddress obtainLocalServerAddr() {
+    TestServiceGrpc.TestServiceBlockingStub stub =
+        blockingStub.withDeadlineAfter(5, TimeUnit.SECONDS);
 
-  protected static void assertSuccess(StreamRecorder<?> recorder) {
-    if (recorder.getError() != null) {
-      throw new AssertionError(recorder.getError());
-    }
+    stub.unaryCall(SimpleRequest.getDefaultInstance());
+
+    return serverCallCapture.get().getAttributes().get(Grpc.TRANSPORT_ATTR_LOCAL_ADDR);
   }
 
-  /** Helper for asserting remote address {@link io.grpc.ServerCall#getAttributes()} */
-  protected void assertRemoteAddr(String expectedRemoteAddress) {
-    TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(channel)
-            .withDeadlineAfter(5, TimeUnit.SECONDS);
+  /** Helper for getting local address from {@link io.grpc.ClientCall#getAttributes()}. */
+  protected SocketAddress obtainLocalClientAddr() {
+    TestServiceGrpc.TestServiceBlockingStub stub = blockingStub
+        .withInterceptors(recordClientCallInterceptor(clientCallCapture))
+        .withDeadlineAfter(5, TimeUnit.SECONDS);
 
     stub.unaryCall(SimpleRequest.getDefaultInstance());
 
-    HostAndPort remoteAddress = HostAndPort.fromString(serverCallCapture.get().getAttributes()
-            .get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR).toString());
-    assertEquals(expectedRemoteAddress, remoteAddress.getHost());
+    return clientCallCapture.get().getAttributes().get(Grpc.TRANSPORT_ATTR_LOCAL_ADDR);
   }
 
-  /** Helper for asserting TLS info in SSLSession {@link io.grpc.ServerCall#getAttributes()} */
+  /** Helper for asserting TLS info in SSLSession {@link io.grpc.ServerCall#getAttributes()}. */
   protected void assertX500SubjectDn(String tlsInfo) {
-    TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(channel)
-            .withDeadlineAfter(5, TimeUnit.SECONDS);
+    TestServiceGrpc.TestServiceBlockingStub stub =
+        blockingStub.withDeadlineAfter(10, TimeUnit.SECONDS);
 
     stub.unaryCall(SimpleRequest.getDefaultInstance());
 
-    List<Certificate> certificates = Lists.newArrayList();
+    List<Certificate> certificates;
     SSLSession sslSession =
         serverCallCapture.get().getAttributes().get(Grpc.TRANSPORT_ATTR_SSL_SESSION);
     try {
       certificates = Arrays.asList(sslSession.getPeerCertificates());
     } catch (SSLPeerUnverifiedException e) {
-      fail("No cert");
+      // Should never happen
+      throw new AssertionError(e);
     }
 
     X509Certificate x509cert = (X509Certificate) certificates.get(0);
 
     assertEquals(1, certificates.size());
-    assertEquals(tlsInfo, x509cert.getSubjectDN().toString());
+    assertEquals(tlsInfo, x509cert.getSubjectX500Principal().toString());
   }
 
   protected int operationTimeoutMillis() {
-    return 5000;
+    return 7000;
   }
 
   /**
    * Some tests run on memory constrained environments.  Rather than OOM, just give up.  64 is
-   * choosen as a maximum amount of memory a large test would need.
+   * chosen as a maximum amount of memory a large test would need.
    */
-  private static void assumeEnoughMemory() {
+  protected static void assumeEnoughMemory() {
     Runtime r = Runtime.getRuntime();
     long usedMem = r.totalMemory() - r.freeMemory();
     long actuallyFreeMemory = r.maxMemory() - usedMem;
@@ -1296,118 +1756,184 @@ private static void assumeEnoughMemory() {
         actuallyFreeMemory >= 64 * 1024 * 1024);
   }
 
-  /**
-   * Wrapper around {@link Mockito#verify}, to keep log spam down on failure.
-   */
-  private static <T> T verify(T mock, VerificationMode mode) {
-    try {
-      return Mockito.verify(mock, mode);
-    } catch (AssertionError e) {
-      String msg = e.getMessage();
-      if (msg.length() >= 256) {
-        throw new AssertionError(msg.substring(0, 256), e);
-      }
-      throw e;
-    }
-
-  }
-
-  /**
-   * Wrapper around {@link Mockito#verify}, to keep log spam down on failure.
-   */
-  private static void verifyNoMoreInteractions(Object... mocks) {
-    try {
-      Mockito.verifyNoMoreInteractions(mocks);
-    } catch (AssertionError e) {
-      String msg = e.getMessage();
-      if (msg.length() >= 256) {
-        throw new AssertionError(msg.substring(0, 256), e);
-      }
-      throw e;
-    }
-  }
-
   /**
    * Poll the next metrics record and check it against the provided information, including the
    * message sizes.
    */
-  private void assertMetrics(String method, Status.Code status,
+  private void assertStatsTrace(String method, Status.Code status,
       Collection<? extends MessageLite> requests,
       Collection<? extends MessageLite> responses) {
-    assertClientMetrics(method, status, requests, responses);
-    assertServerMetrics(method, status, requests, responses);
+    assertClientStatsTrace(method, status, requests, responses);
+    assertServerStatsTrace(method, status, requests, responses);
   }
 
   /**
    * Poll the next metrics record and check it against the provided information, without checking
    * the message sizes.
    */
-  private void assertMetrics(String method, Status.Code status) {
-    assertMetrics(method, status, null, null);
+  private void assertStatsTrace(String method, Status.Code status) {
+    assertStatsTrace(method, status, null, null);
+  }
+
+  private void assertZeroRetryRecorded() {
+    MetricsRecord retryRecord = clientStatsRecorder.pollRecord();
+    assertThat(retryRecord.getMetric(RETRIES_PER_CALL)).isEqualTo(0);
+    assertThat(retryRecord.getMetric(TRANSPARENT_RETRIES_PER_CALL)).isEqualTo(0);
+    assertThat(retryRecord.getMetric(RETRY_DELAY_PER_CALL)).isEqualTo(0D);
   }
 
-  private void assertClientMetrics(String method, Status.Code status,
+  private void assertClientStatsTrace(String method, Status.Code code,
       Collection<? extends MessageLite> requests, Collection<? extends MessageLite> responses) {
-    MetricsRecord clientRecord = clientStatsFactory.pollRecord();
-    assertNotNull("clientRecord is not null", clientRecord);
-    checkTags(clientRecord, false, method, status);
+    // Tracer-based stats
+    TestClientStreamTracer tracer = clientStreamTracers.poll();
+    assertNotNull(tracer);
+    assertTrue(tracer.getOutboundHeaders());
+    // assertClientStatsTrace() is called right after application receives status,
+    // but streamClosed() may be called slightly later than that.  So we need a timeout.
+    try {
+      assertTrue(tracer.await(5, TimeUnit.SECONDS));
+    } catch (InterruptedException e) {
+      throw new AssertionError(e);
+    }
+    assertEquals(code, tracer.getStatus().getCode());
+
     if (requests != null && responses != null) {
-      checkMetrics(clientRecord, false, requests, responses);
+      checkTracers(tracer, requests, responses);
+    }
+    if (metricsExpected()) {
+      // CensusStreamTracerModule records final status in interceptor, which is guaranteed to be
+      // done before application receives status.
+      MetricsRecord clientStartRecord = clientStatsRecorder.pollRecord();
+      checkStartTags(clientStartRecord, method, true);
+      MetricsRecord clientEndRecord = clientStatsRecorder.pollRecord();
+      checkEndTags(clientEndRecord, method, code, true);
+
+      if (requests != null && responses != null) {
+        checkCensus(clientEndRecord, false, requests, responses);
+      }
+      assertZeroRetryRecorded();
     }
   }
 
-  private void assertClientMetrics(String method, Status.Code status) {
-    assertClientMetrics(method, status, null, null);
+  private void assertClientStatsTrace(String method, Status.Code status) {
+    assertClientStatsTrace(method, status, null, null);
   }
 
-  private void assertServerMetrics(String method, Status.Code status,
+  @SuppressWarnings("AssertionFailureIgnored") // Failure is checked in the end by the passed flag.
+  private void assertServerStatsTrace(String method, Status.Code code,
       Collection<? extends MessageLite> requests, Collection<? extends MessageLite> responses) {
-    AssertionError checkFailure = null;
-    // Because the server doesn't restart between tests, it may still be processing the requests
-    // from the previous tests when a new test starts, thus the test may see metrics from previous
-    // tests.  The best we can do here is to exhaust all records and find one that matches the given
-    // conditions.
-    while (true) {
-      MetricsRecord serverRecord;
+    if (server == null) {
+      // Server is not in the same process.  We can't check server-side stats.
+      return;
+    }
+
+    if (metricsExpected()) {
+      MetricsRecord serverStartRecord;
+      MetricsRecord serverEndRecord;
       try {
-        // On the server, the stats is finalized in ServerStreamListener.closed(), which can be run
-        // after the client receives the final status.  So we use a timeout.
-        serverRecord = serverStatsFactory.pollRecord(1, TimeUnit.SECONDS);
+        // On the server, the stats is finalized in ServerStreamListener.closed(), which can be
+        // run after the client receives the final status.  So we use a timeout.
+        serverStartRecord = serverStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
+        serverEndRecord = serverStatsRecorder.pollRecord(5, TimeUnit.SECONDS);
       } catch (InterruptedException e) {
         throw new RuntimeException(e);
       }
-      if (serverRecord == null) {
-        break;
-      }
-      try {
-        checkTags(serverRecord, true, method, status);
-        if (requests != null && responses != null) {
-          checkMetrics(serverRecord, true, requests, responses);
-        }
-        return;  // passed
-      } catch (AssertionError e) {
-        // May be the fallout from a previous test, continue trying
-        checkFailure = e;
+      assertNotNull(serverStartRecord);
+      assertNotNull(serverEndRecord);
+      checkStartTags(serverStartRecord, method, false);
+      checkEndTags(serverEndRecord, method, code, false);
+      if (requests != null && responses != null) {
+        checkCensus(serverEndRecord, true, requests, responses);
       }
     }
-    if (checkFailure == null) {
-      throw new AssertionError("No record found");
+
+    ServerStreamTracerInfo tracerInfo;
+    tracerInfo = serverStreamTracers.poll();
+    assertNotNull(tracerInfo);
+    assertEquals(method, tracerInfo.fullMethodName);
+    assertNotNull(tracerInfo.tracer.contextCapture);
+    // On the server, streamClosed() may be called after the client receives the final status.
+    // So we use a timeout.
+    try {
+      assertTrue(tracerInfo.tracer.await(1, TimeUnit.SECONDS));
+    } catch (InterruptedException e) {
+      throw new AssertionError(e);
+    }
+    assertEquals(code, tracerInfo.tracer.getStatus().getCode());
+    if (requests != null && responses != null) {
+      checkTracers(tracerInfo.tracer, responses, requests);
     }
-    throw checkFailure;
   }
 
-  private static void checkTags(
-      MetricsRecord record, boolean server, String methodName, Status.Code status) {
-    TagValue methodNameTag = record.tags.get(
-        server ? RpcConstants.RPC_SERVER_METHOD : RpcConstants.RPC_CLIENT_METHOD);
+  private static void checkStartTags(MetricsRecord record, String methodName, boolean clientSide) {
+    assertNotNull("record is not null", record);
+
+    TagKey methodNameTagKey = clientSide
+        ? RpcMeasureConstants.GRPC_CLIENT_METHOD
+        : RpcMeasureConstants.GRPC_SERVER_METHOD;
+    TagValue methodNameTag = record.tags.get(methodNameTagKey);
+    assertNotNull("method name tagged", methodNameTag);
+    assertEquals("method names match", methodName, methodNameTag.asString());
+  }
+
+  private static void checkEndTags(
+      MetricsRecord record, String methodName, Status.Code status, boolean clientSide) {
+    assertNotNull("record is not null", record);
+
+    TagKey methodNameTagKey = clientSide
+        ? RpcMeasureConstants.GRPC_CLIENT_METHOD
+        : RpcMeasureConstants.GRPC_SERVER_METHOD;
+    TagValue methodNameTag = record.tags.get(methodNameTagKey);
     assertNotNull("method name tagged", methodNameTag);
-    assertEquals("method names match", methodName, methodNameTag.toString());
-    TagValue statusTag = record.tags.get(RpcConstants.RPC_STATUS);
+    assertEquals("method names match", methodName, methodNameTag.asString());
+
+    TagKey statusTagKey = clientSide
+        ? RpcMeasureConstants.GRPC_CLIENT_STATUS
+        : RpcMeasureConstants.GRPC_SERVER_STATUS;
+    TagValue statusTag = record.tags.get(statusTagKey);
     assertNotNull("status tagged", statusTag);
-    assertEquals(status.toString(), statusTag.toString());
+    assertEquals(status.toString(), statusTag.asString());
   }
 
-  private static void checkMetrics(MetricsRecord record, boolean server,
+  /**
+   * Check information recorded by tracers.
+   */
+  private void checkTracers(
+      TestStreamTracer tracer,
+      Collection<? extends MessageLite> sentMessages,
+      Collection<? extends MessageLite> receivedMessages) {
+    long uncompressedSentSize = 0;
+    int seqNo = 0;
+    for (MessageLite msg : sentMessages) {
+      assertThat(tracer.nextOutboundEvent())
+          .isEqualTo(String.format(Locale.US, "outboundMessage(%d)", seqNo));
+      assertThat(tracer.nextOutboundEvent()).matches(
+          String.format(Locale.US, "outboundMessageSent\\(%d, -?[0-9]+, -?[0-9]+\\)", seqNo));
+      seqNo++;
+      uncompressedSentSize += msg.getSerializedSize();
+    }
+    assertNull(tracer.nextOutboundEvent());
+    long uncompressedReceivedSize = 0;
+    seqNo = 0;
+    for (MessageLite msg : receivedMessages) {
+      assertThat(tracer.nextInboundEvent())
+          .isEqualTo(String.format(Locale.US, "inboundMessage(%d)", seqNo));
+      assertThat(tracer.nextInboundEvent()).matches(
+          String.format(Locale.US, "inboundMessageRead\\(%d, -?[0-9]+, -?[0-9]+\\)", seqNo));
+      uncompressedReceivedSize += msg.getSerializedSize();
+      seqNo++;
+    }
+    assertNull(tracer.nextInboundEvent());
+    if (metricsExpected()) {
+      assertEquals(uncompressedSentSize, tracer.getOutboundUncompressedSize());
+      assertEquals(uncompressedReceivedSize, tracer.getInboundUncompressedSize());
+    }
+  }
+
+  /**
+   * Check information recorded by Census.
+   */
+  private void checkCensus(MetricsRecord record, boolean isServer,
       Collection<? extends MessageLite> requests, Collection<? extends MessageLite> responses) {
     int uncompressedRequestsSize = 0;
     for (MessageLite request : requests) {
@@ -1417,25 +1943,174 @@ private static void checkMetrics(MetricsRecord record, boolean server,
     for (MessageLite response : responses) {
       uncompressedResponsesSize += response.getSerializedSize();
     }
-    if (server) {
-      assertEquals(uncompressedRequestsSize,
-          record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES));
-      assertEquals(uncompressedResponsesSize,
-          record.getMetricAsLongOrFail(RpcConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES));
+    if (isServer) {
+      assertEquals(
+          requests.size(),
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_RECEIVED_MESSAGES_PER_RPC));
+      assertEquals(
+          responses.size(),
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_SERVER_SENT_MESSAGES_PER_RPC));
+      assertEquals(
+          uncompressedRequestsSize,
+          record.getMetricAsLongOrFail(
+              DeprecatedCensusConstants.RPC_SERVER_UNCOMPRESSED_REQUEST_BYTES));
+      assertEquals(
+          uncompressedResponsesSize,
+          record.getMetricAsLongOrFail(
+              DeprecatedCensusConstants.RPC_SERVER_UNCOMPRESSED_RESPONSE_BYTES));
+      assertNotNull(record.getMetric(RpcMeasureConstants.GRPC_SERVER_SERVER_LATENCY));
       // It's impossible to get the expected wire sizes because it may be compressed, so we just
       // check if they are recorded.
-      assertNotNull(record.getMetric(RpcConstants.RPC_SERVER_REQUEST_BYTES));
-      assertNotNull(record.getMetric(RpcConstants.RPC_SERVER_RESPONSE_BYTES));
+      assertNotNull(record.getMetric(RpcMeasureConstants.GRPC_SERVER_RECEIVED_BYTES_PER_RPC));
+      assertNotNull(record.getMetric(RpcMeasureConstants.GRPC_SERVER_SENT_BYTES_PER_RPC));
     } else {
-      assertEquals(uncompressedRequestsSize,
-          record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
-      assertEquals(uncompressedResponsesSize,
-          record.getMetricAsLongOrFail(RpcConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
-      assertNotNull(record.getMetric(RpcConstants.RPC_CLIENT_SERVER_ELAPSED_TIME));
+      assertEquals(
+          requests.size(),
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_RPC));
+      assertEquals(
+          responses.size(),
+          record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_RPC));
+      assertEquals(
+          uncompressedRequestsSize,
+          record.getMetricAsLongOrFail(
+              DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_REQUEST_BYTES));
+      assertEquals(
+          uncompressedResponsesSize,
+          record.getMetricAsLongOrFail(
+              DeprecatedCensusConstants.RPC_CLIENT_UNCOMPRESSED_RESPONSE_BYTES));
+      assertNotNull(record.getMetric(RpcMeasureConstants.GRPC_CLIENT_ROUNDTRIP_LATENCY));
       // It's impossible to get the expected wire sizes because it may be compressed, so we just
       // check if they are recorded.
-      assertNotNull(record.getMetric(RpcConstants.RPC_CLIENT_REQUEST_BYTES));
-      assertNotNull(record.getMetric(RpcConstants.RPC_CLIENT_RESPONSE_BYTES));
+      assertNotNull(record.getMetric(RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_RPC));
+      assertNotNull(record.getMetric(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_RPC));
+    }
+  }
+
+  // Helper methods for responses containing Payload since proto equals does not ignore deprecated
+  // fields (PayloadType).
+  private void assertResponses(
+      Collection<StreamingOutputCallResponse> expected,
+      Collection<StreamingOutputCallResponse> actual) {
+    assertSame(expected.size(), actual.size());
+    Iterator<StreamingOutputCallResponse> expectedIter = expected.iterator();
+    Iterator<StreamingOutputCallResponse> actualIter = actual.iterator();
+
+    while (expectedIter.hasNext()) {
+      assertResponse(expectedIter.next(), actualIter.next());
+    }
+  }
+
+  private void assertResponse(
+      StreamingOutputCallResponse expected, StreamingOutputCallResponse actual) {
+    if (expected == null || actual == null) {
+      assertEquals(expected, actual);
+    } else {
+      assertPayload(expected.getPayload(), actual.getPayload());
+    }
+  }
+
+  public void assertResponse(SimpleResponse expected, SimpleResponse actual) {
+    assertPayload(expected.getPayload(), actual.getPayload());
+    assertEquals(expected.getUsername(), actual.getUsername());
+    assertEquals(expected.getOauthScope(), actual.getOauthScope());
+  }
+
+  private void assertPayload(Payload expected, Payload actual) {
+    // Compare non deprecated fields in Payload, to make this test forward compatible.
+    if (expected == null || actual == null) {
+      assertEquals(expected, actual);
+    } else {
+      assertEquals(expected.getBody(), actual.getBody());
+    }
+  }
+
+  private static void assertCodeEquals(Status.Code expected, Status actual) {
+    assertWithMessage("Unexpected status: %s", actual).that(actual.getCode()).isEqualTo(expected);
+  }
+
+  /**
+   * Captures the request attributes. Useful for testing ServerCalls.
+   * {@link ServerCall#getAttributes()}
+   */
+  private static ServerInterceptor recordServerCallInterceptor(
+      final AtomicReference<ServerCall<?, ?>> serverCallCapture) {
+    return new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+          ServerCall<ReqT, RespT> call,
+          Metadata requestHeaders,
+          ServerCallHandler<ReqT, RespT> next) {
+        serverCallCapture.set(call);
+        return next.startCall(call, requestHeaders);
+      }
+    };
+  }
+
+  /**
+   * Captures the request attributes. Useful for testing ClientCalls.
+   * {@link ClientCall#getAttributes()}
+   */
+  private static ClientInterceptor recordClientCallInterceptor(
+      final AtomicReference<ClientCall<?, ?>> clientCallCapture) {
+    return new ClientInterceptor() {
+      @Override
+      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+          MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+        ClientCall<ReqT, RespT> clientCall = next.newCall(method,callOptions);
+        clientCallCapture.set(clientCall);
+        return clientCall;
+      }
+    };
+  }
+
+  private static ServerInterceptor recordContextInterceptor(
+      final AtomicReference<Context> contextCapture) {
+    return new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+          ServerCall<ReqT, RespT> call,
+          Metadata requestHeaders,
+          ServerCallHandler<ReqT, RespT> next) {
+        contextCapture.set(Context.current());
+        return next.startCall(call, requestHeaders);
+      }
+    };
+  }
+
+  /**
+   * A marshaller that record input and output sizes.
+   */
+  private static final class ByteSizeMarshaller<T> implements MethodDescriptor.Marshaller<T> {
+
+    private final MethodDescriptor.Marshaller<T> delegate;
+    volatile int lastOutSize;
+    volatile int lastInSize;
+
+    ByteSizeMarshaller(MethodDescriptor.Marshaller<T> delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    public InputStream stream(T value) {
+      InputStream is = delegate.stream(value);
+      ByteArrayOutputStream baos = new ByteArrayOutputStream();
+      try {
+        lastOutSize = (int) ByteStreams.copy(is, baos);
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+      return new ByteArrayInputStream(baos.toByteArray());
+    }
+
+    @Override
+    public T parse(InputStream stream) {
+      ByteArrayOutputStream baos = new ByteArrayOutputStream();
+      try {
+        lastInSize = (int) ByteStreams.copy(stream, baos);
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+      return delegate.parse(new ByteArrayInputStream(baos.toByteArray()));
     }
   }
 }
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/AltsHandshakerTestService.java b/interop-testing/src/main/java/io/grpc/testing/integration/AltsHandshakerTestService.java
new file mode 100644
index 00000000000..89424db849b
--- /dev/null
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/AltsHandshakerTestService.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright 2021 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.testing.integration;
+
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.alts.internal.HandshakerReq.ReqOneofCase.CLIENT_START;
+import static io.grpc.alts.internal.HandshakerReq.ReqOneofCase.NEXT;
+import static io.grpc.alts.internal.HandshakerReq.ReqOneofCase.SERVER_START;
+
+import com.google.protobuf.ByteString;
+import io.grpc.alts.internal.HandshakerReq;
+import io.grpc.alts.internal.HandshakerResp;
+import io.grpc.alts.internal.HandshakerResult;
+import io.grpc.alts.internal.HandshakerServiceGrpc.HandshakerServiceImplBase;
+import io.grpc.alts.internal.Identity;
+import io.grpc.alts.internal.RpcProtocolVersions;
+import io.grpc.alts.internal.RpcProtocolVersions.Version;
+import io.grpc.stub.StreamObserver;
+import java.util.Random;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A fake HandshakeService for ALTS integration testing in non-gcp environments.
+ * */
+public class AltsHandshakerTestService extends HandshakerServiceImplBase {
+  private static final Logger log = Logger.getLogger(AltsHandshakerTestService.class.getName());
+
+  private final Random random = new Random();
+  private static final int FIXED_LENGTH_OUTPUT = 16;
+  private final ByteString fakeOutput = data(FIXED_LENGTH_OUTPUT);
+  private final ByteString secret = data(128);
+  private State expectState = State.CLIENT_INIT;
+
+  @Override
+  public StreamObserver<HandshakerReq> doHandshake(
+      final StreamObserver<HandshakerResp> responseObserver) {
+    return new StreamObserver<HandshakerReq>() {
+      @Override
+      public void onNext(HandshakerReq value) {
+        log.log(Level.FINE, "request received: " + value);
+        synchronized (AltsHandshakerTestService.this) {
+          switch (expectState) {
+            case CLIENT_INIT:
+              checkState(CLIENT_START.equals(value.getReqOneofCase()));
+              HandshakerResp initClient = HandshakerResp.newBuilder()
+                  .setOutFrames(fakeOutput)
+                  .build();
+              log.log(Level.FINE, "init client response " + initClient);
+              responseObserver.onNext(initClient);
+              expectState = State.SERVER_INIT;
+              break;
+            case SERVER_INIT:
+              checkState(SERVER_START.equals(value.getReqOneofCase()));
+              HandshakerResp initServer = HandshakerResp.newBuilder()
+                  .setBytesConsumed(FIXED_LENGTH_OUTPUT)
+                  .setOutFrames(fakeOutput)
+                  .build();
+              log.log(Level.FINE, "init server response" + initServer);
+              responseObserver.onNext(initServer);
+              expectState = State.CLIENT_FINISH;
+              break;
+            case CLIENT_FINISH:
+              checkState(NEXT.equals(value.getReqOneofCase()));
+              HandshakerResp resp = HandshakerResp.newBuilder()
+                  .setResult(getResult())
+                  .setBytesConsumed(FIXED_LENGTH_OUTPUT)
+                  .setOutFrames(fakeOutput)
+                  .build();
+              log.log(Level.FINE, "client finished response " + resp);
+              responseObserver.onNext(resp);
+              expectState = State.SERVER_FINISH;
+              break;
+            case SERVER_FINISH:
+              resp = HandshakerResp.newBuilder()
+                  .setResult(getResult())
+                  .setBytesConsumed(FIXED_LENGTH_OUTPUT)
+                  .build();
+              log.log(Level.FINE, "server finished response " + resp);
+              responseObserver.onNext(resp);
+              expectState = State.CLIENT_INIT;
+              break;
+            default:
+              throw new RuntimeException("unknown state");
+          }
+        }
+      }
+
+      @Override
+      public void onError(Throwable t) {
+        log.log(Level.INFO, "onError " + t);
+      }
+
+      @Override
+      public void onCompleted() {
+        responseObserver.onCompleted();
+      }
+    };
+  }
+
+  private HandshakerResult getResult() {
+    return HandshakerResult.newBuilder().setApplicationProtocol("grpc")
+        .setRecordProtocol("ALTSRP_GCM_AES128_REKEY")
+        .setKeyData(secret)
+        .setMaxFrameSize(131072)
+        .setPeerIdentity(Identity.newBuilder()
+            .setServiceAccount("123456789-compute@developer.gserviceaccount.com")
+            .build())
+        .setPeerRpcVersions(RpcProtocolVersions.newBuilder()
+            .setMaxRpcVersion(Version.newBuilder()
+                .setMajor(2).setMinor(1)
+                .build())
+            .setMinRpcVersion(Version.newBuilder()
+                .setMajor(2).setMinor(1)
+                .build())
+            .build())
+        .build();
+  }
+
+  private ByteString data(int len) {
+    byte[] k = new byte[len];
+    random.nextBytes(k);
+    return ByteString.copyFrom(k);
+  }
+
+  private enum State {
+    CLIENT_INIT,
+    SERVER_INIT,
+    CLIENT_FINISH,
+    SERVER_FINISH
+  }
+}
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/CustomBackendMetricsLoadBalancerProvider.java b/interop-testing/src/main/java/io/grpc/testing/integration/CustomBackendMetricsLoadBalancerProvider.java
new file mode 100644
index 00000000000..b9a89a01e3a
--- /dev/null
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/CustomBackendMetricsLoadBalancerProvider.java
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2022 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.testing.integration;
+
+import static io.grpc.testing.integration.TestServiceClient.ORCA_OOB_REPORT_KEY;
+import static io.grpc.testing.integration.TestServiceClient.ORCA_RPC_REPORT_KEY;
+
+import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.services.MetricReport;
+import io.grpc.testing.integration.Messages.TestOrcaReport;
+import io.grpc.util.ForwardingLoadBalancer;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import io.grpc.xds.orca.OrcaOobUtil;
+import io.grpc.xds.orca.OrcaPerRequestUtil;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * Implements a test LB policy that receives ORCA load reports.
+ */
+final class CustomBackendMetricsLoadBalancerProvider extends LoadBalancerProvider {
+
+  static final String TEST_ORCA_LB_POLICY_NAME = "test_backend_metrics_load_balancer";
+  private volatile TestOrcaReport latestOobReport;
+
+  @Override
+  public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+    return new CustomBackendMetricsLoadBalancer(helper);
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 0;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return TEST_ORCA_LB_POLICY_NAME;
+  }
+
+  private final class CustomBackendMetricsLoadBalancer extends ForwardingLoadBalancer {
+    private LoadBalancer delegate;
+
+    public CustomBackendMetricsLoadBalancer(Helper helper) {
+      this.delegate = LoadBalancerRegistry.getDefaultRegistry()
+          .getProvider("pick_first")
+          .newLoadBalancer(new CustomBackendMetricsLoadBalancerHelper(helper));
+    }
+
+    @Override
+    public LoadBalancer delegate() {
+      return delegate;
+    }
+
+    private final class CustomBackendMetricsLoadBalancerHelper
+        extends ForwardingLoadBalancerHelper {
+      private final Helper orcaHelper;
+
+      public CustomBackendMetricsLoadBalancerHelper(Helper helper) {
+        this.orcaHelper = OrcaOobUtil.newOrcaReportingHelper(helper);
+      }
+
+      @Override
+      public Subchannel createSubchannel(CreateSubchannelArgs args) {
+        Subchannel subchannel = super.createSubchannel(args);
+        OrcaOobUtil.setListener(subchannel, new OrcaOobUtil.OrcaOobReportListener() {
+              @Override
+              public void onLoadReport(MetricReport orcaLoadReport) {
+                latestOobReport = fromCallMetricReport(orcaLoadReport);
+              }
+            },
+            OrcaOobUtil.OrcaReportingConfig.newBuilder()
+                .setReportInterval(1, TimeUnit.SECONDS)
+                .build()
+        );
+        return subchannel;
+      }
+
+      @Override
+      public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+        delegate().updateBalancingState(newState, new MayReportLoadPicker(newPicker));
+      }
+
+      @Override
+      public Helper delegate() {
+        return orcaHelper;
+      }
+    }
+
+    private final class MayReportLoadPicker extends SubchannelPicker {
+      private SubchannelPicker delegate;
+
+      public MayReportLoadPicker(SubchannelPicker delegate) {
+        this.delegate = delegate;
+      }
+
+      @Override
+      public PickResult pickSubchannel(PickSubchannelArgs args) {
+        PickResult result = delegate.pickSubchannel(args);
+        if (result.getSubchannel() == null) {
+          return result;
+        }
+        AtomicReference<TestOrcaReport> reportRef =
+            args.getCallOptions().getOption(ORCA_OOB_REPORT_KEY);
+        if (reportRef != null) {
+          reportRef.set(latestOobReport);
+        }
+
+        return PickResult.withSubchannel(
+            result.getSubchannel(),
+            OrcaPerRequestUtil.getInstance().newOrcaClientStreamTracerFactory(
+                new OrcaPerRequestUtil.OrcaPerRequestReportListener() {
+                  @Override
+                  public void onLoadReport(MetricReport callMetricReport) {
+                    AtomicReference<TestOrcaReport> reportRef =
+                        args.getCallOptions().getOption(ORCA_RPC_REPORT_KEY);
+                    if (reportRef != null) {
+                      reportRef.set(fromCallMetricReport(callMetricReport));
+                    }
+                  }
+                }));
+      }
+    }
+  }
+
+  private static TestOrcaReport fromCallMetricReport(MetricReport callMetricReport) {
+    return TestOrcaReport.newBuilder()
+        .setCpuUtilization(callMetricReport.getCpuUtilization())
+        .setMemoryUtilization(callMetricReport.getMemoryUtilization())
+        .putAllRequestCost(callMetricReport.getRequestCostMetrics())
+        .putAllUtilization(callMetricReport.getUtilizationMetrics())
+        .build();
+  }
+}
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/GrpclbFallbackTestClient.java b/interop-testing/src/main/java/io/grpc/testing/integration/GrpclbFallbackTestClient.java
new file mode 100644
index 00000000000..8ce83f73e6d
--- /dev/null
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/GrpclbFallbackTestClient.java
@@ -0,0 +1,311 @@
+/*
+ * Copyright 2019 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.testing.integration;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.io.CharStreams;
+import io.grpc.Deadline;
+import io.grpc.ManagedChannel;
+import io.grpc.StatusRuntimeException;
+import io.grpc.alts.ComputeEngineChannelBuilder;
+import io.grpc.testing.integration.Messages.GrpclbRouteType;
+import io.grpc.testing.integration.Messages.SimpleRequest;
+import io.grpc.testing.integration.Messages.SimpleResponse;
+import java.io.InputStreamReader;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * Test client that verifies that grpclb failover into fallback mode works under
+ * different failure modes.
+ * This client is suitable for testing fallback with any "grpclb" load-balanced
+ * service, but is particularly meant to implement a set of test cases described
+ * in an internal doc titled "DirectPath Cloud-to-Prod End-to-End Test Cases",
+ * section "gRPC DirectPath-to-CFE fallback".
+ */
+public final class GrpclbFallbackTestClient {
+  private static final Logger logger =
+      Logger.getLogger(GrpclbFallbackTestClient.class.getName());
+
+  /**
+   * Entry point.
+   */
+  public static void main(String[] args) throws Exception {
+    final GrpclbFallbackTestClient client = new GrpclbFallbackTestClient();
+    client.parseArgs(args);
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      @SuppressWarnings("CatchAndPrintStackTrace")
+      public void run() {
+        System.out.println("Shutting down");
+        try {
+          client.tearDown();
+        } catch (Exception e) {
+          e.printStackTrace();
+        }
+      }
+    });
+    try {
+      client.run();
+    } finally {
+      client.tearDown();
+    }
+    System.exit(0);
+  }
+
+  private String induceFallbackCmd = "exit 1";
+  private String serverUri;
+  private String customCredentialsType;
+  private String testCase;
+  private Boolean skipNetCmd = false;
+  private int numWarmupRpcs;
+  private int fallbackDeadlineSeconds = 1;
+
+  private ManagedChannel channel;
+  private TestServiceGrpc.TestServiceBlockingStub blockingStub;
+
+  private void parseArgs(String[] args) {
+    boolean usage = false;
+    for (String arg : args) {
+      if (!arg.startsWith("--")) {
+        System.err.println("All arguments must start with '--': " + arg);
+        usage = true;
+        break;
+      }
+      String[] parts = arg.substring(2).split("=", 2);
+      String key = parts[0];
+      if ("help".equals(key)) {
+        usage = true;
+        break;
+      }
+      if (parts.length != 2) {
+        System.err.println("All arguments must be of the form --arg=value");
+        usage = true;
+        break;
+      }
+      String value = parts[1];
+      if ("server_uri".equals(key)) {
+        serverUri = value;
+      } else if ("test_case".equals(key)) {
+        testCase = value;
+      } else if ("induce_fallback_cmd".equals(key)) {
+        induceFallbackCmd = value;
+      } else if ("custom_credentials_type".equals(key)) {
+        customCredentialsType = value;
+      } else if ("skip_net_cmd".equals(key)) {
+        skipNetCmd = Boolean.valueOf(value);
+      } else if ("num_warmup_rpcs".equals(key)) {
+        numWarmupRpcs = Integer.valueOf(value);
+      } else if ("fallback_deadline_seconds".equals(key)) {
+        fallbackDeadlineSeconds = Integer.valueOf(value);
+      } else {
+        System.err.println("Unknown argument: " + key);
+        usage = true;
+        break;
+      }
+    }
+    if (usage) {
+      GrpclbFallbackTestClient c = new GrpclbFallbackTestClient();
+      System.out.println(
+          "Usage: [ARGS...]"
+          + "\n"
+          + "\n  --server_uri                          Server target. Default: "
+          + c.serverUri
+          + "\n  --custom_credentials_type             Name of Credentials to use. "
+          + "Default: " + c.customCredentialsType
+          + "\n  --induce_fallback_cmd Shell command to induce fallback, e.g. by "
+          + "making LB and/or backend addresses unroutable or black holed. Default: "
+          + c.induceFallbackCmd
+          + "\n  --skip_net_cmd                        Skip unroute and blackhole "
+          + "shell command to allow setting the net config outside of the test "
+          + "client. Default: "
+          + c.skipNetCmd
+          + "\n  --num_warmup_rpcs                     Number of RPCs to perform "
+          + "on a separate warmup channel before the actual test runs (each warmup "
+          + "RPC uses a 1 second deadline). Default: "
+          + c.numWarmupRpcs
+          + "\n  --fallback_deadline_seconds           Number of seconds to wait "
+          + "for fallback to occur after inducing fallback. Default: "
+          + c.fallbackDeadlineSeconds
+          + "\n  --test_case=TEST_CASE        Test case to run. Valid options are:"
+          + "\n      fallback_before_startup : fallback before startup e.g. due to "
+          + "LB/backend addresses being unreachable"
+          + "\n      fallback_after_startup : fallback after startup e.g. due to "
+          + "LB/backend addresses becoming unreachable"
+          + "\n      Default: " + c.testCase
+      );
+      System.exit(1);
+    }
+  }
+
+  private ManagedChannel createChannel() {
+    if (!customCredentialsType.equals("compute_engine_channel_creds")) {
+      throw new AssertionError(
+          "This test currently only supports "
+          + "--custom_credentials_type=compute_engine_channel_creds. "
+          + "TODO: add support for other types.");
+    }
+    ComputeEngineChannelBuilder builder = ComputeEngineChannelBuilder.forTarget(serverUri);
+    builder.keepAliveTime(3600, TimeUnit.SECONDS);
+    builder.keepAliveTimeout(20, TimeUnit.SECONDS);
+    return builder.build();
+  }
+
+  void initStub() {
+    channel = createChannel();
+    blockingStub = TestServiceGrpc.newBlockingStub(channel);
+  }
+
+  private void tearDown() {
+    try {
+      if (channel != null) {
+        channel.shutdownNow();
+        channel.awaitTermination(1, TimeUnit.SECONDS);
+      }
+    } catch (Exception ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+
+  private void runShellCmd(String cmd) throws Exception {
+    if (skipNetCmd) {
+      logger.info("Skip net cmd because --skip_net_cmd is set to true");
+      return;
+    }
+    logger.info("Run shell command: " + cmd);
+    // Do not use bash -c here as bash may not exist in a container
+    ProcessBuilder pb = new ProcessBuilder(cmd.split(" "));
+    pb.redirectErrorStream(true);
+    Process process = pb.start();
+    logger.info("Shell command merged stdout and stderr: "
+        + CharStreams.toString(
+            new InputStreamReader(process.getInputStream(), UTF_8)));
+    int exitCode = process.waitFor();
+    logger.info("Shell command exit code: " + exitCode);
+    assertEquals(0, exitCode);
+  }
+
+  private GrpclbRouteType doRpcAndGetPath(
+      TestServiceGrpc.TestServiceBlockingStub stub, Deadline deadline) {
+    logger.info("doRpcAndGetPath deadline: " + deadline);
+    final SimpleRequest request = SimpleRequest.newBuilder()
+        .setFillGrpclbRouteType(true)
+        .build();
+    GrpclbRouteType result = GrpclbRouteType.GRPCLB_ROUTE_TYPE_UNKNOWN;
+    try {
+      SimpleResponse response = stub
+          .withDeadline(deadline)
+          .unaryCall(request);
+      result = response.getGrpclbRouteType();
+    } catch (StatusRuntimeException ex) {
+      logger.warning("doRpcAndGetPath failed. Status: " + ex);
+      return GrpclbRouteType.GRPCLB_ROUTE_TYPE_UNKNOWN;
+    }
+    logger.info("doRpcAndGetPath. GrpclbRouteType result: " + result);
+    if (result != GrpclbRouteType.GRPCLB_ROUTE_TYPE_FALLBACK
+        && result != GrpclbRouteType.GRPCLB_ROUTE_TYPE_BACKEND) {
+      throw new AssertionError("Received invalid LB route type. This suggests "
+          + "that the server hasn't implemented this test correctly.");
+    }
+    return result;
+  }
+
+  private void waitForFallbackAndDoRpcs(Deadline fallbackDeadline) throws Exception {
+    int fallbackRetryCount = 0;
+    boolean fallBack = false;
+    while (!fallbackDeadline.isExpired()) {
+      GrpclbRouteType grpclbRouteType = doRpcAndGetPath(
+          blockingStub, Deadline.after(1, TimeUnit.SECONDS));
+      if (grpclbRouteType == GrpclbRouteType.GRPCLB_ROUTE_TYPE_BACKEND) {
+        throw new AssertionError("Got grpclb route type backend. Backends are "
+            + "supposed to be unreachable, so this test is broken");
+      }
+      if (grpclbRouteType == GrpclbRouteType.GRPCLB_ROUTE_TYPE_FALLBACK) {
+        logger.info("Made one successful RPC to a fallback. Now expect the "
+            + "same for the rest.");
+        fallBack = true;
+        break;
+      } else {
+        logger.info("Retryable RPC failure on iteration: " + fallbackRetryCount);
+      }
+      fallbackRetryCount++;
+    }
+    if (!fallBack) {
+      throw new AssertionError("Didn't fall back within deadline");
+    }
+    for (int i = 0; i < 30; i++) {
+      assertEquals(
+          GrpclbRouteType.GRPCLB_ROUTE_TYPE_FALLBACK,
+          doRpcAndGetPath(blockingStub, Deadline.after(20, TimeUnit.SECONDS)));
+      Thread.sleep(1000);
+    }
+  }
+
+  private void runFallbackBeforeStartup() throws Exception {
+    runShellCmd(induceFallbackCmd);
+    final Deadline fallbackDeadline = Deadline.after(
+        fallbackDeadlineSeconds, TimeUnit.SECONDS);
+    initStub();
+    waitForFallbackAndDoRpcs(fallbackDeadline);
+  }
+
+  private void runFallbackAfterStartup() throws Exception {
+    initStub();
+    assertEquals(
+        GrpclbRouteType.GRPCLB_ROUTE_TYPE_BACKEND,
+        doRpcAndGetPath(blockingStub, Deadline.after(20, TimeUnit.SECONDS)));
+    runShellCmd(induceFallbackCmd);
+    final Deadline fallbackDeadline = Deadline.after(
+        fallbackDeadlineSeconds, TimeUnit.SECONDS);
+    waitForFallbackAndDoRpcs(fallbackDeadline);
+  }
+
+  // The purpose of this warmup method is to get potentially expensive one-per-process
+  // initialization out of the way, so that we can use aggressive timeouts in the actual
+  // test cases. Note that the warmup phase is done using a separate channel from the
+  // actual test cases, so that we don't affect the states of LB policies in the channel
+  // of the actual test case.
+  private void warmup() throws Exception {
+    logger.info("Begin warmup, performing " + numWarmupRpcs + " RPCs on the warmup channel");
+    ManagedChannel channel = createChannel();
+    TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(channel);
+    for (int i = 0; i < numWarmupRpcs; i++) {
+      doRpcAndGetPath(stub, Deadline.after(1, TimeUnit.SECONDS));
+    }
+    try {
+      channel.shutdownNow();
+      channel.awaitTermination(1, TimeUnit.SECONDS);
+    } catch (Exception ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+
+  private void run() throws Exception {
+    warmup();
+    logger.info("Begin test case: " + testCase);
+    if (testCase.equals("fallback_before_startup")) {
+      runFallbackBeforeStartup();
+    } else if (testCase.equals("fallback_after_startup")) {
+      runFallbackAfterStartup();
+    } else {
+      throw new RuntimeException("invalid testcase: " + testCase);
+    }
+    logger.info("Test case: " + testCase + " done!");
+  }
+}
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/GrpclbLongLivedAffinityTestClient.java b/interop-testing/src/main/java/io/grpc/testing/integration/GrpclbLongLivedAffinityTestClient.java
new file mode 100644
index 00000000000..efda4b99868
--- /dev/null
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/GrpclbLongLivedAffinityTestClient.java
@@ -0,0 +1,217 @@
+/*
+ * Copyright 2019 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.testing.integration;
+
+import com.google.protobuf.ByteString;
+import io.grpc.ManagedChannel;
+import io.grpc.StatusRuntimeException;
+import io.grpc.alts.ComputeEngineChannelBuilder;
+import io.grpc.testing.integration.Messages.Payload;
+import io.grpc.testing.integration.Messages.SimpleRequest;
+import io.grpc.testing.integration.Messages.SimpleResponse;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Test client that verifies all requests are sent to the same server even running for an extended
+ * time, while allowing for occasionally switching server.  This is intended for testing the GRPCLB
+ * pick_first mode in GCE.
+ */
+public final class GrpclbLongLivedAffinityTestClient {
+  private static final Logger logger =
+      Logger.getLogger(GrpclbLongLivedAffinityTestClient.class.getName());
+
+  /**
+   * Entry point.
+   */
+  public static void main(String[] args) throws Exception {
+    final GrpclbLongLivedAffinityTestClient client = new GrpclbLongLivedAffinityTestClient();
+    client.parseArgs(args);
+    client.setUp();
+
+    Runtime.getRuntime().addShutdownHook(new Thread() {
+      @Override
+      @SuppressWarnings("CatchAndPrintStackTrace")
+      public void run() {
+        try {
+          client.shutdown();
+        } catch (Exception e) {
+          // At this moment logger may have stopped working
+          e.printStackTrace();
+        }
+      }
+    });
+
+    try {
+      client.run();
+    } finally {
+      client.shutdown();
+    }
+  }
+
+  private String target = "directpath-grpclb-with-pick-first-test.googleapis.com";
+  private long rpcErrorBudgetIncreaseMinutes = 2;
+  private long affinityBreakageBudgetIncreaseMinutes = 90;
+  private long rpcIntermissionSeconds = 1;
+  private long totalTestSeconds = 60;
+
+  ManagedChannel channel;
+  TestServiceGrpc.TestServiceBlockingStub blockingStub;
+
+  private void parseArgs(String[] args) {
+    boolean usage = false;
+    for (String arg : args) {
+      if (!arg.startsWith("--")) {
+        System.err.println("All arguments must start with '--': " + arg);
+        usage = true;
+        break;
+      }
+      String[] parts = arg.substring(2).split("=", 2);
+      String key = parts[0];
+      if ("help".equals(key)) {
+        usage = true;
+        break;
+      }
+      if (parts.length != 2) {
+        System.err.println("All arguments must be of the form --arg=value");
+        usage = true;
+        break;
+      }
+      String value = parts[1];
+      if ("target".equals(key)) {
+        target = value;
+      } else if ("rpc_error_budget_increase_minutes".equals(key)) {
+        rpcErrorBudgetIncreaseMinutes = Long.parseLong(value);
+      } else if ("affinity_breakage_budget_increase_minutes".equals(key)) {
+        affinityBreakageBudgetIncreaseMinutes = Long.parseLong(value);
+      } else if ("rpc_intermission_seconds".equals(key)) {
+        rpcIntermissionSeconds = Long.parseLong(value);
+      } else if ("total_test_seconds".equals(key)) {
+        totalTestSeconds = Long.parseLong(value);
+      } else {
+        System.err.println("Unknown argument: " + key);
+        usage = true;
+        break;
+      }
+    }
+    if (usage) {
+      GrpclbLongLivedAffinityTestClient c = new GrpclbLongLivedAffinityTestClient();
+      System.out.println(
+          "Usage: [ARGS...]"
+          + "\n"
+          + "\n  --target=TARGET          Server target.             Default " + c.target
+          + "\n  --rpc_error_budget_increase_minutes=MINUTES         Default "
+          + c.rpcErrorBudgetIncreaseMinutes
+          + "\n  --affinity_breakage_budget_increase_minutes=MINUTES Default "
+          + c.affinityBreakageBudgetIncreaseMinutes
+          + "\n  --rpc_intermission_seconds=SECONDS                  Default "
+          + c.rpcIntermissionSeconds
+          + "\n  --total_test_seconds=SECONDS                        Default "
+          + c.totalTestSeconds
+      );
+      System.exit(1);
+    }
+  }
+
+  private void setUp() {
+    channel = createChannel();
+    blockingStub = TestServiceGrpc.newBlockingStub(channel);
+  }
+
+  private void shutdown() {
+    try {
+      if (channel != null) {
+        channel.shutdownNow();
+        channel.awaitTermination(1, TimeUnit.SECONDS);
+      }
+    } catch (Exception ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+
+  private void run() throws Exception {
+    final long startTimeMillis = System.currentTimeMillis();
+    final long endTimeMillis = startTimeMillis + TimeUnit.SECONDS.toMillis(totalTestSeconds);
+    final long rpcIntermissionMillis = TimeUnit.SECONDS.toMillis(rpcIntermissionSeconds);
+    final long rpcErrorBudgetIncreasePeriodMillis =
+        TimeUnit.MINUTES.toMillis(rpcErrorBudgetIncreaseMinutes);
+    final long affinityBreakageBudgetIncreasePeriodMillis =
+        TimeUnit.MINUTES.toMillis(affinityBreakageBudgetIncreaseMinutes);
+    final SimpleRequest request = SimpleRequest.newBuilder()
+        .setResponseSize(314159)
+        .setFillServerId(true)
+        .setPayload(Payload.newBuilder()
+            .setBody(ByteString.copyFrom(new byte[271828])))
+        .build();
+    String lastServerId = null;
+    long rpcErrorBudget = 1;
+    long affinityBreakageBudget = 1;
+    long lastRpcErrorBudgetIncreaseTimeMillis = startTimeMillis;
+    long lastAffinityBreakageBudgetIncreaseTimeMillis = startTimeMillis;
+
+    logger.info("Test started");
+
+    while (true) {
+      try {
+        logger.info("Sending request");
+        SimpleResponse response =
+            blockingStub.withDeadlineAfter(1, TimeUnit.MINUTES).unaryCall(request);
+        logger.info("Received response");
+        String serverId = response.getServerId();
+        if (lastServerId != null && !lastServerId.equals(serverId)) {
+          String msg = "Expected serverId " + lastServerId + ", but got " + serverId;
+          logger.warning(msg + ". affinityBreakageBudget=" + affinityBreakageBudget);
+          affinityBreakageBudget--;
+          if (affinityBreakageBudget < 0) {
+            throw new AssertionError(msg);
+          }
+        }
+      } catch (StatusRuntimeException e) {
+        logger.log(Level.WARNING, "RPC error. rpcErrorBudget=" + rpcErrorBudget, e);
+        rpcErrorBudget--;
+        if (rpcErrorBudget < 0) {
+          throw e;
+        }
+      }
+      Thread.sleep(rpcIntermissionMillis);
+      long nowMillis = System.currentTimeMillis();
+      if (nowMillis > endTimeMillis) {
+        logger.info("Time is up");
+        break;
+      }
+      if (nowMillis > lastRpcErrorBudgetIncreaseTimeMillis + rpcErrorBudgetIncreasePeriodMillis) {
+        lastRpcErrorBudgetIncreaseTimeMillis = nowMillis;
+        rpcErrorBudget = Math.min(20, rpcErrorBudget + 1);
+        logger.info("rpcErrorBudget after refresh: " + rpcErrorBudget);
+      }
+      if (nowMillis > lastAffinityBreakageBudgetIncreaseTimeMillis
+          + affinityBreakageBudgetIncreasePeriodMillis) {
+        lastAffinityBreakageBudgetIncreaseTimeMillis = nowMillis;
+        affinityBreakageBudget = Math.min(3, affinityBreakageBudget + 1);
+        logger.info("affinityBreakageBudget after refresh: " + affinityBreakageBudget);
+      }
+    }
+
+    logger.info("Test passed.");
+  }
+
+  private ManagedChannel createChannel() {
+    return ComputeEngineChannelBuilder.forTarget(target).build();
+  }
+}
+
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/Http2Client.java b/interop-testing/src/main/java/io/grpc/testing/integration/Http2Client.java
index d1683863d9a..2bba0ef0356 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/Http2Client.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/Http2Client.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
@@ -38,21 +23,19 @@
 import com.google.common.util.concurrent.ListeningExecutorService;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.protobuf.ByteString;
+import io.grpc.ChannelCredentials;
+import io.grpc.InsecureChannelCredentials;
 import io.grpc.ManagedChannel;
 import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
-import io.grpc.netty.NegotiationType;
 import io.grpc.netty.NettyChannelBuilder;
 import io.grpc.stub.StreamObserver;
 import io.grpc.testing.integration.Messages.Payload;
-import io.grpc.testing.integration.Messages.PayloadType;
 import io.grpc.testing.integration.Messages.SimpleRequest;
 import io.grpc.testing.integration.Messages.SimpleResponse;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
@@ -100,9 +83,9 @@ public void run() {
   private Tester tester = new Tester();
   private ListeningExecutorService threadpool;
 
-  protected ManagedChannel channel;
-  protected TestServiceGrpc.TestServiceBlockingStub blockingStub;
-  protected TestServiceGrpc.TestServiceStub asyncStub;
+  ManagedChannel channel;
+  TestServiceGrpc.TestServiceBlockingStub blockingStub;
+  TestServiceGrpc.TestServiceStub asyncStub;
 
   private void parseArgs(String[] args) {
     boolean usage = false;
@@ -153,8 +136,8 @@ private void parseArgs(String[] args) {
 
   private void setUp() {
     channel = createChannel();
-    blockingStub = TestServiceGrpc.newBlockingStub(channel).withWaitForReady();
-    asyncStub = TestServiceGrpc.newStub(channel).withWaitForReady();
+    blockingStub = TestServiceGrpc.newBlockingStub(channel);
+    asyncStub = TestServiceGrpc.newStub(channel);
   }
 
   private void shutdown() {
@@ -214,18 +197,16 @@ private void runTest(Http2TestCases testCase) throws Exception {
   }
 
   private class Tester {
-    private final int timeoutSeconds = 5;
+    private final int timeoutSeconds = 180;
 
     private final int responseSize = 314159;
     private final int payloadSize = 271828;
     private final SimpleRequest simpleRequest = SimpleRequest.newBuilder()
         .setResponseSize(responseSize)
-        .setResponseType(PayloadType.COMPRESSABLE)
         .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[payloadSize])))
         .build();
     final SimpleResponse goldenResponse = SimpleResponse.newBuilder()
         .setPayload(Payload.newBuilder()
-            .setType(PayloadType.COMPRESSABLE)
             .setBody(ByteString.copyFrom(new byte[responseSize])))
         .build();
 
@@ -245,13 +226,13 @@ private void rstAfterData() throws Exception {
       if (!responseObserver.awaitCompletion(timeoutSeconds, TimeUnit.SECONDS)) {
         throw new AssertionError("Operation timed out");
       }
-      if (responseObserver.getResponses().size() != 1) {
-        throw new AssertionError("Expected one response");
-      }
       if (responseObserver.getError() == null) {
         throw new AssertionError("Expected call to fail");
       }
       assertRstStreamReceived(Status.fromThrowable(responseObserver.getError()));
+      if (responseObserver.getResponses().size() != 1) {
+        throw new AssertionError("Expected one response");
+      }
     }
 
     private void rstDuringData() throws Exception {
@@ -261,13 +242,13 @@ private void rstDuringData() throws Exception {
       if (!responseObserver.awaitCompletion(timeoutSeconds, TimeUnit.SECONDS)) {
         throw new AssertionError("Operation timed out");
       }
-      if (responseObserver.getResponses().size() != 0) {
-        throw new AssertionError("Expected zero responses");
-      }
       if (responseObserver.getError() == null) {
         throw new AssertionError("Expected call to fail");
       }
       assertRstStreamReceived(Status.fromThrowable(responseObserver.getError()));
+      if (responseObserver.getResponses().size() != 0) {
+        throw new AssertionError("Expected zero responses");
+      }
     }
 
     private void goAway() throws Exception {
@@ -287,9 +268,9 @@ private void maxStreams() throws Exception {
       assertResponseEquals(blockingStub.unaryCall(simpleRequest), goldenResponse);
 
       threadpool = MoreExecutors.listeningDecorator(newFixedThreadPool(numThreads));
-      List<ListenableFuture<?>> workerFutures = new ArrayList<ListenableFuture<?>>();
+      List<ListenableFuture<?>> workerFutures = new ArrayList<>();
       for (int i = 0; i < numThreads; i++) {
-        workerFutures.add(threadpool.submit(new MaxStreamsWorker(i, simpleRequest)));
+        workerFutures.add(threadpool.submit(new MaxStreamsWorker(i)));
       }
       ListenableFuture<?> f = Futures.allAsList(workerFutures);
       f.get(timeoutSeconds, TimeUnit.SECONDS);
@@ -297,7 +278,7 @@ private void maxStreams() throws Exception {
 
     private class RstStreamObserver implements StreamObserver<SimpleResponse> {
       private final CountDownLatch latch = new CountDownLatch(1);
-      private final List<SimpleResponse> responses = new ArrayList<SimpleResponse>();
+      private final List<SimpleResponse> responses = new ArrayList<>();
       private Throwable error;
 
       @Override
@@ -331,11 +312,9 @@ public boolean awaitCompletion(long timeout, TimeUnit unit) throws Exception {
 
     private class MaxStreamsWorker implements Runnable {
       int threadNum;
-      SimpleRequest request;
 
-      MaxStreamsWorker(int threadNum, SimpleRequest request) {
+      MaxStreamsWorker(int threadNum) {
         this.threadNum = threadNum;
-        this.request = request;
       }
 
       @Override
@@ -372,21 +351,14 @@ private void assertResponseEquals(SimpleResponse response, SimpleResponse golden
   }
 
   private ManagedChannel createChannel() {
-    InetAddress address;
-    try {
-      address = InetAddress.getByName(serverHost);
-    } catch (UnknownHostException ex) {
-      throw new RuntimeException(ex);
-    }
-    return NettyChannelBuilder.forAddress(new InetSocketAddress(address, serverPort))
-        .negotiationType(NegotiationType.PLAINTEXT)
-        .build();
+    ChannelCredentials creds = InsecureChannelCredentials.create();
+    return NettyChannelBuilder.forAddress(serverHost, serverPort, creds).build();
   }
 
   private static String validTestCasesHelpText() {
     StringBuilder builder = new StringBuilder();
     for (Http2TestCases testCase : Http2TestCases.values()) {
-      String strTestcase = testCase.name().toLowerCase();
+      String strTestcase = testCase.name().toLowerCase(Locale.ROOT);
       builder.append("\n      ")
           .append(strTestcase)
           .append(": ")
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/Http2TestCases.java b/interop-testing/src/main/java/io/grpc/testing/integration/Http2TestCases.java
index 59cb1edc12a..d79c6798cc2 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/Http2TestCases.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/Http2TestCases.java
@@ -1,37 +1,23 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
 import com.google.common.base.Preconditions;
+import java.util.Locale;
 
 /**
  * Enum of HTTP/2 interop test cases.
@@ -64,7 +50,7 @@ public String description() {
   public static Http2TestCases fromString(String s) {
     Preconditions.checkNotNull(s, "s");
     try {
-      return Http2TestCases.valueOf(s.toUpperCase());
+      return Http2TestCases.valueOf(s.toUpperCase(Locale.ROOT));
     } catch (IllegalArgumentException ex) {
       throw new IllegalArgumentException("Invalid test case: " + s);
     }
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/ReconnectTestClient.java b/interop-testing/src/main/java/io/grpc/testing/integration/ReconnectTestClient.java
index f552d1b41b2..f548a57b270 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/ReconnectTestClient.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/ReconnectTestClient.java
@@ -1,45 +1,31 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
 import static org.junit.Assert.assertTrue;
 
-import com.google.protobuf.EmptyProtos.Empty;
 import io.grpc.ManagedChannel;
 import io.grpc.StatusRuntimeException;
 import io.grpc.netty.NegotiationType;
 import io.grpc.netty.NettyChannelBuilder;
 import io.grpc.okhttp.OkHttpChannelBuilder;
+import io.grpc.testing.integration.EmptyProtos.Empty;
 import io.grpc.testing.integration.Messages.ReconnectInfo;
+import io.grpc.testing.integration.Messages.ReconnectParams;
 
 /**
  * Verifies the client is reconnecting the server with correct backoffs
@@ -85,19 +71,21 @@ private void runTest() throws Exception {
           .negotiationType(NegotiationType.PLAINTEXT).build();
       controlStub = ReconnectServiceGrpc.newBlockingStub(controlChannel);
       if (useOkhttp) {
-        retryChannel = OkHttpChannelBuilder.forAddress("127.0.0.1", serverRetryPort)
-            .negotiationType(io.grpc.okhttp.NegotiationType.TLS).build();
+        retryChannel =
+            OkHttpChannelBuilder.forAddress("127.0.0.1", serverRetryPort)
+                .useTransportSecurity()
+                .build();
       } else {
         retryChannel = NettyChannelBuilder.forAddress("127.0.0.1", serverRetryPort)
             .negotiationType(NegotiationType.TLS).build();
       }
       retryStub = ReconnectServiceGrpc.newBlockingStub(retryChannel);
-      controlStub.start(Empty.getDefaultInstance());
+      controlStub.start(ReconnectParams.getDefaultInstance());
 
       long startTimeStamp = System.currentTimeMillis();
       while ((System.currentTimeMillis() - startTimeStamp) < TEST_TIME_MS) {
         try {
-          retryStub.start(Empty.getDefaultInstance());
+          retryStub.start(ReconnectParams.getDefaultInstance());
         } catch (StatusRuntimeException expected) {
           // Make CheckStyle happy.
         }
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/RpcBehaviorLoadBalancerProvider.java b/interop-testing/src/main/java/io/grpc/testing/integration/RpcBehaviorLoadBalancerProvider.java
new file mode 100644
index 00000000000..65f1c46892b
--- /dev/null
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/RpcBehaviorLoadBalancerProvider.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2022 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.testing.integration;
+
+import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.Metadata;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.JsonUtil;
+import io.grpc.util.ForwardingLoadBalancer;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import java.util.Map;
+import javax.annotation.Nonnull;
+
+/**
+ * Provides a xDS interop test {@link LoadBalancer} designed to work with {@link XdsTestServer}. It
+ * looks for an "rpc_behavior" field in its configuration and includes the value in the
+ * "rpc-behavior" metadata entry that is sent to the server. This will cause the test server to
+ * behave in a predefined way. Endpoint picking logic is delegated to the
+ * io.grpc.util.RoundRobinLoadBalancer.
+ *
+ * <p>Initial use case is to prove that a custom load balancer can be configured by the control
+ * plane via xDS. An interop test will configure this LB and then verify it has been correctly
+ * configured by observing a specific RPC behavior by the server(s).
+ *
+ * <p>For more details on what behaviors can be specified, please see:
+ * https://github.com/grpc/grpc/blob/master/doc/xds-test-descriptions.md#server
+ */
+public class RpcBehaviorLoadBalancerProvider extends LoadBalancerProvider {
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawLoadBalancingPolicyConfig) {
+    String rpcBehavior = JsonUtil.getString(rawLoadBalancingPolicyConfig, "rpcBehavior");
+    if (rpcBehavior == null) {
+      return ConfigOrError.fromError(
+          Status.UNAVAILABLE.withDescription("no 'rpcBehavior' defined"));
+    }
+    return ConfigOrError.fromConfig(new RpcBehaviorConfig(rpcBehavior));
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    RpcBehaviorHelper rpcBehaviorHelper = new RpcBehaviorHelper(helper);
+    return new RpcBehaviorLoadBalancer(rpcBehaviorHelper,
+        LoadBalancerRegistry.getDefaultRegistry().getProvider("round_robin")
+            .newLoadBalancer(rpcBehaviorHelper));
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return "test.RpcBehaviorLoadBalancer";
+  }
+
+  static class RpcBehaviorConfig {
+
+    final String rpcBehavior;
+
+    RpcBehaviorConfig(String rpcBehavior) {
+      this.rpcBehavior = rpcBehavior;
+    }
+  }
+
+  /**
+   * Delegates all calls to another LB and wraps the given helper in {@link RpcBehaviorHelper} that
+   * assures that the rpc-behavior metadata header gets added to all calls.
+   */
+  static class RpcBehaviorLoadBalancer extends ForwardingLoadBalancer {
+
+    private final RpcBehaviorHelper helper;
+    private final LoadBalancer delegateLb;
+
+    RpcBehaviorLoadBalancer(RpcBehaviorHelper helper, LoadBalancer delegateLb) {
+      this.helper = helper;
+      this.delegateLb = delegateLb;
+    }
+
+    @Override
+    protected LoadBalancer delegate() {
+      return delegateLb;
+    }
+
+    @Override
+    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      helper.setRpcBehavior(
+          ((RpcBehaviorConfig) resolvedAddresses.getLoadBalancingPolicyConfig()).rpcBehavior);
+      delegateLb.handleResolvedAddresses(resolvedAddresses);
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      helper.setRpcBehavior(
+          ((RpcBehaviorConfig) resolvedAddresses.getLoadBalancingPolicyConfig()).rpcBehavior);
+      return delegateLb.acceptResolvedAddresses(resolvedAddresses);
+    }
+  }
+
+  /**
+   * Wraps the picker that is provided when the balancing change updates with the {@link
+   * RpcBehaviorPicker} that injects the rpc-behavior metadata entry.
+   */
+  static class RpcBehaviorHelper extends ForwardingLoadBalancerHelper {
+
+    private final Helper delegateHelper;
+    private String rpcBehavior;
+
+    RpcBehaviorHelper(Helper delegateHelper) {
+      this.delegateHelper = delegateHelper;
+    }
+
+    void setRpcBehavior(String rpcBehavior) {
+      this.rpcBehavior = rpcBehavior;
+    }
+
+    @Override
+    protected Helper delegate() {
+      return delegateHelper;
+    }
+
+    @Override
+    public void updateBalancingState(@Nonnull ConnectivityState newState,
+        @Nonnull SubchannelPicker newPicker) {
+      delegateHelper.updateBalancingState(newState, new RpcBehaviorPicker(newPicker, rpcBehavior));
+    }
+  }
+
+  /**
+   * Includes the rpc-behavior metadata entry on each subchannel pick.
+   */
+  static class RpcBehaviorPicker extends SubchannelPicker {
+
+    private static final String RPC_BEHAVIOR_HEADER_KEY = "rpc-behavior";
+
+    private final SubchannelPicker delegatePicker;
+    private final String rpcBehavior;
+
+    RpcBehaviorPicker(SubchannelPicker delegatePicker, String rpcBehavior) {
+      this.delegatePicker = delegatePicker;
+      this.rpcBehavior = rpcBehavior;
+    }
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      args.getHeaders()
+          .put(Metadata.Key.of(RPC_BEHAVIOR_HEADER_KEY, Metadata.ASCII_STRING_MARSHALLER),
+              rpcBehavior);
+      return delegatePicker.pickSubchannel(args);
+    }
+  }
+}
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/SoakClient.java b/interop-testing/src/main/java/io/grpc/testing/integration/SoakClient.java
new file mode 100644
index 00000000000..e119c826f09
--- /dev/null
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/SoakClient.java
@@ -0,0 +1,300 @@
+/*
+ * Copyright 2025 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.testing.integration;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.base.Function;
+import com.google.protobuf.ByteString;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.Grpc;
+import io.grpc.ManagedChannel;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.testing.integration.Messages.Payload;
+import io.grpc.testing.integration.Messages.SimpleRequest;
+import io.grpc.testing.integration.Messages.SimpleResponse;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Logger;
+import org.HdrHistogram.Histogram;
+
+/**
+ * Shared implementation for rpc_soak and channel_soak. Unlike the tests in AbstractInteropTest,
+ * these "test cases" are only intended to be run from the command line. They don't fit the regular
+ * test patterns of AbstractInteropTest.
+ * https://github.com/grpc/grpc/blob/master/doc/interop-test-descriptions.md#rpc_soak
+ */
+final class SoakClient {
+  private static final Logger logger = Logger.getLogger(SoakClient.class.getName());
+
+  private static class SoakIterationResult {
+    public SoakIterationResult(long latencyMs, Status status) {
+      this.latencyMs = latencyMs;
+      this.status = status;
+    }
+
+    public long getLatencyMs() {
+      return latencyMs;
+    }
+
+    public Status getStatus() {
+      return status;
+    }
+
+    private long latencyMs = -1;
+    private Status status = Status.OK;
+  }
+
+  private static class ThreadResults {
+    private int threadFailures = 0;
+    private int iterationsDone = 0;
+    private Histogram latencies = new Histogram(4);
+
+    public int getThreadFailures() {
+      return threadFailures;
+    }
+
+    public int getIterationsDone() {
+      return iterationsDone;
+    }
+
+    public Histogram getLatencies() {
+      return latencies;
+    }
+  }
+
+  private static SoakIterationResult performOneSoakIteration(
+      TestServiceGrpc.TestServiceBlockingStub soakStub, int soakRequestSize, int soakResponseSize)
+      throws InterruptedException {
+    long startNs = System.nanoTime();
+    Status status = Status.OK;
+    try {
+      final SimpleRequest request =
+          SimpleRequest.newBuilder()
+              .setResponseSize(soakResponseSize)
+              .setPayload(
+                  Payload.newBuilder().setBody(ByteString.copyFrom(new byte[soakRequestSize])))
+              .build();
+      final SimpleResponse goldenResponse =
+          SimpleResponse.newBuilder()
+              .setPayload(
+                  Payload.newBuilder().setBody(ByteString.copyFrom(new byte[soakResponseSize])))
+              .build();
+      assertResponse(goldenResponse, soakStub.unaryCall(request));
+    } catch (StatusRuntimeException e) {
+      status = e.getStatus();
+    }
+    long elapsedNs = System.nanoTime() - startNs;
+    return new SoakIterationResult(TimeUnit.NANOSECONDS.toMillis(elapsedNs), status);
+  }
+
+  /**
+   * Runs large unary RPCs in a loop with configurable failure thresholds
+   * and channel creation behavior.
+   */
+  public static void performSoakTest(
+      String serverUri,
+      int soakIterations,
+      int maxFailures,
+      int maxAcceptablePerIterationLatencyMs,
+      int minTimeMsBetweenRpcs,
+      int overallTimeoutSeconds,
+      int soakRequestSize,
+      int soakResponseSize,
+      int numThreads,
+      ManagedChannel sharedChannel,
+      Function<ManagedChannel, ManagedChannel> maybeCreateChannel)
+      throws InterruptedException {
+    if (soakIterations % numThreads != 0) {
+      throw new IllegalArgumentException("soakIterations must be evenly divisible by numThreads.");
+    }
+    long startNs = System.nanoTime();
+    Thread[] threads = new Thread[numThreads];
+    int soakIterationsPerThread = soakIterations / numThreads;
+    List<ThreadResults> threadResultsList = new ArrayList<>(numThreads);
+    for (int i = 0; i < numThreads; i++) {
+      threadResultsList.add(new ThreadResults());
+    }
+    for (int threadInd = 0; threadInd < numThreads; threadInd++) {
+      final int currentThreadInd = threadInd;
+      threads[threadInd] = new Thread(() -> {
+        try {
+          executeSoakTestInThread(
+              soakIterationsPerThread,
+              startNs,
+              minTimeMsBetweenRpcs,
+              soakRequestSize,
+              soakResponseSize,
+              maxAcceptablePerIterationLatencyMs,
+              overallTimeoutSeconds,
+              serverUri,
+              threadResultsList.get(currentThreadInd),
+              sharedChannel,
+              maybeCreateChannel);
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+          throw new RuntimeException("Thread interrupted: " + e.getMessage(), e);
+        }
+      });
+      threads[threadInd].start();
+    }
+    for (Thread thread : threads) {
+      thread.join();
+    }
+
+    int totalFailures = 0;
+    int iterationsDone = 0;
+    Histogram latencies = new Histogram(4);
+    for (ThreadResults threadResult :threadResultsList) {
+      totalFailures += threadResult.getThreadFailures();
+      iterationsDone += threadResult.getIterationsDone();
+      latencies.add(threadResult.getLatencies());
+    }
+    logger.info(
+        String.format(
+            Locale.US,
+            "(server_uri: %s) soak test ran: %d / %d iterations. total failures: %d. "
+                + "p50: %d ms, p90: %d ms, p100: %d ms",
+            serverUri,
+            iterationsDone,
+            soakIterations,
+            totalFailures,
+            latencies.getValueAtPercentile(50),
+            latencies.getValueAtPercentile(90),
+            latencies.getValueAtPercentile(100)));
+    // check if we timed out
+    String timeoutErrorMessage =
+        String.format(
+            Locale.US,
+            "(server_uri: %s) soak test consumed all %d seconds of time and quit early, "
+                + "only having ran %d out of desired %d iterations.",
+            serverUri,
+            overallTimeoutSeconds,
+            iterationsDone,
+            soakIterations);
+    assertEquals(timeoutErrorMessage, iterationsDone, soakIterations);
+    // check if we had too many failures
+    String tooManyFailuresErrorMessage =
+        String.format(
+            Locale.US,
+            "(server_uri: %s) soak test total failures: %d exceeds max failures "
+                + "threshold: %d.",
+            serverUri, totalFailures, maxFailures);
+    assertTrue(tooManyFailuresErrorMessage, totalFailures <= maxFailures);
+    sharedChannel.shutdownNow();
+    sharedChannel.awaitTermination(10, TimeUnit.SECONDS);
+  }
+
+  private static void executeSoakTestInThread(
+      int soakIterationsPerThread,
+      long startNs,
+      int minTimeMsBetweenRpcs,
+      int soakRequestSize,
+      int soakResponseSize,
+      int maxAcceptablePerIterationLatencyMs,
+      int overallTimeoutSeconds,
+      String serverUri,
+      ThreadResults threadResults,
+      ManagedChannel sharedChannel,
+      Function<ManagedChannel, ManagedChannel> maybeCreateChannel) throws InterruptedException {
+    ManagedChannel currentChannel = sharedChannel;
+    for (int i = 0; i < soakIterationsPerThread; i++) {
+      if (System.nanoTime() - startNs >= TimeUnit.SECONDS.toNanos(overallTimeoutSeconds)) {
+        break;
+      }
+      long earliestNextStartNs = System.nanoTime()
+          + TimeUnit.MILLISECONDS.toNanos(minTimeMsBetweenRpcs);
+      // recordClientCallInterceptor takes an AtomicReference.
+      AtomicReference<ClientCall<?, ?>> soakThreadClientCallCapture = new AtomicReference<>();
+      currentChannel = maybeCreateChannel.apply(currentChannel);
+      TestServiceGrpc.TestServiceBlockingStub currentStub = TestServiceGrpc
+          .newBlockingStub(currentChannel)
+              .withInterceptors(recordClientCallInterceptor(soakThreadClientCallCapture));
+      SoakIterationResult result = performOneSoakIteration(currentStub,
+          soakRequestSize, soakResponseSize);
+      SocketAddress peer = soakThreadClientCallCapture
+          .get().getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
+      StringBuilder logStr = new StringBuilder(
+          String.format(
+              Locale.US,
+              "thread id: %d soak iteration: %d elapsed_ms: %d peer: %s server_uri: %s",
+              Thread.currentThread().getId(),
+              i, result.getLatencyMs(), peer != null ? peer.toString() : "null", serverUri));
+      if (!result.getStatus().equals(Status.OK)) {
+        threadResults.threadFailures++;
+        logStr.append(String.format(" failed: %s", result.getStatus()));
+        logger.warning(logStr.toString());
+      } else if (result.getLatencyMs() > maxAcceptablePerIterationLatencyMs) {
+        threadResults.threadFailures++;
+        logStr.append(
+            " exceeds max acceptable latency: " + maxAcceptablePerIterationLatencyMs);
+        logger.warning(logStr.toString());
+      } else {
+        logStr.append(" succeeded");
+        logger.info(logStr.toString());
+      }
+      threadResults.iterationsDone++;
+      threadResults.getLatencies().recordValue(result.getLatencyMs());
+      long remainingNs = earliestNextStartNs - System.nanoTime();
+      if (remainingNs > 0) {
+        TimeUnit.NANOSECONDS.sleep(remainingNs);
+      }
+    }
+  }
+
+  private static void assertResponse(SimpleResponse expected, SimpleResponse actual) {
+    assertPayload(expected.getPayload(), actual.getPayload());
+    assertEquals(expected.getUsername(), actual.getUsername());
+    assertEquals(expected.getOauthScope(), actual.getOauthScope());
+  }
+
+  private static void assertPayload(Payload expected, Payload actual) {
+    // Compare non deprecated fields in Payload, to make this test forward compatible.
+    if (expected == null || actual == null) {
+      assertEquals(expected, actual);
+    } else {
+      assertEquals(expected.getBody(), actual.getBody());
+    }
+  }
+
+  /**
+   * Captures the ClientCall. Useful for testing {@link ClientCall#getAttributes()}
+   */
+  private static ClientInterceptor recordClientCallInterceptor(
+      final AtomicReference<ClientCall<?, ?>> clientCallCapture) {
+    return new ClientInterceptor() {
+      @Override
+      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+          MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+        ClientCall<ReqT, RespT> clientCall = next.newCall(method,callOptions);
+        clientCallCapture.set(clientCall);
+        return clientCall;
+      }
+    };
+  }
+
+}
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/StressTestClient.java b/interop-testing/src/main/java/io/grpc/testing/integration/StressTestClient.java
index 54ec0425f66..7fafe43be05 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/StressTestClient.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/StressTestClient.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
@@ -47,29 +32,34 @@
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListeningExecutorService;
 import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.ChannelCredentials;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
 import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
 import io.grpc.Server;
 import io.grpc.ServerBuilder;
 import io.grpc.Status;
 import io.grpc.StatusException;
-import io.grpc.netty.GrpcSslContexts;
-import io.grpc.netty.NegotiationType;
-import io.grpc.netty.NettyChannelBuilder;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.alts.ComputeEngineChannelCredentials;
+import io.grpc.alts.GoogleDefaultChannelCredentials;
 import io.grpc.stub.StreamObserver;
-import io.grpc.testing.TestUtils;
-import io.netty.handler.ssl.SslContext;
+import io.grpc.testing.TlsTesting;
 import java.io.IOException;
-import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.atomic.AtomicLong;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -100,7 +90,9 @@ public void run() {
     try {
       client.startMetricsService();
       client.runStressTest();
+      client.startMetricsLogging();
       client.blockUntilStressTestComplete();
+      log.log(Level.INFO, "Total calls made: " + client.getTotalCallCount());
     } catch (Exception e) {
       log.log(Level.WARNING, "The stress test client encountered an error!", e);
     } finally {
@@ -112,19 +104,22 @@ public void run() {
 
   private List<InetSocketAddress> addresses =
       singletonList(new InetSocketAddress("localhost", 8080));
-  private List<TestCaseWeightPair> testCaseWeightPairs = new ArrayList<TestCaseWeightPair>();
+  private List<TestCaseWeightPair> testCaseWeightPairs = new ArrayList<>();
 
   private String serverHostOverride;
   private boolean useTls = false;
   private boolean useTestCa = false;
+  private String customCredentialsType;
   private int durationSecs = -1;
   private int channelsPerServer = 1;
   private int stubsPerChannel = 1;
   private int metricsPort = 8081;
+  private int metricsLogRateSecs = -1;
 
   private Server metricsServer;
   private final Map<String, Metrics.GaugeResponse> gauges =
-      new ConcurrentHashMap<String, Metrics.GaugeResponse>();
+      new ConcurrentHashMap<>();
+  private final AtomicLong totalCallCount = new AtomicLong(0);
 
   private volatile boolean shutdown;
 
@@ -132,9 +127,10 @@ public void run() {
    * List of futures that {@link #blockUntilStressTestComplete()} waits for.
    */
   private final List<ListenableFuture<?>> workerFutures =
-      new ArrayList<ListenableFuture<?>>();
-  private final List<ManagedChannel> channels = new ArrayList<ManagedChannel>();
+      new ArrayList<>();
+  private final List<ManagedChannel> channels = new ArrayList<>();
   private ListeningExecutorService threadpool;
+  private ScheduledExecutorService metricsLoggingThreadpool;
 
   @VisibleForTesting
   void parseArgs(String[] args) {
@@ -167,6 +163,8 @@ void parseArgs(String[] args) {
         useTls = Boolean.parseBoolean(value);
       } else if ("use_test_ca".equals(key)) {
         useTestCa = Boolean.parseBoolean(value);
+      } else if ("custom_credentials_type".equals(key)) {
+        customCredentialsType = value;
       } else if ("test_cases".equals(key)) {
         testCaseWeightPairs = parseTestCases(value);
       } else if ("test_duration_secs".equals(key)) {
@@ -177,6 +175,8 @@ void parseArgs(String[] args) {
         stubsPerChannel = Integer.valueOf(value);
       } else if ("metrics_port".equals(key)) {
         metricsPort = Integer.valueOf(value);
+      } else if ("metrics_log_rate_secs".equals(key)) {
+        metricsLogRateSecs = Integer.valueOf(value);
       } else {
         System.err.println("Unknown argument: " + key);
         usage = true;
@@ -207,12 +207,16 @@ void parseArgs(String[] args) {
               + "\n  --use_test_ca=true|false       Whether to trust our fake CA. Requires"
               + " --use_tls=true"
               + "\n                                 to have effect. Default: " + c.useTestCa
+              + "\n  --custom_credentials_type      Custom credentials type to use. Default "
+              + c.customCredentialsType
               + "\n  --test_duration_secs=SECONDS   '-1' for no limit. Default: " + c.durationSecs
               + "\n  --num_channels_per_server=INT  Number of connections to each server address."
               + " Default: " + c.channelsPerServer
               + "\n  --num_stubs_per_channel=INT    Default: " + c.stubsPerChannel
               + "\n  --metrics_port=PORT            Listening port of the metrics server."
               + " Default: " + c.metricsPort
+              + "\n  --metrics_log_rate_secs=INT    The rate (in secs) to log collected metrics"
+              + " Default: " + c.metricsLogRateSecs
       );
       System.exit(1);
     }
@@ -228,6 +232,24 @@ void startMetricsService() throws IOException {
         .start();
   }
 
+  /** Starts logging gauge information at a given rate (if rate > -1). */
+  @SuppressWarnings("FutureReturnValueIgnored")
+  void startMetricsLogging() {
+    if (metricsLogRateSecs > -1) {
+      metricsLoggingThreadpool = Executors.newScheduledThreadPool(1);
+      metricsLoggingThreadpool.scheduleAtFixedRate(() -> {
+        long totalQps = 0;
+        for (Metrics.GaugeResponse gauge : gauges.values()) {
+          log.info("GAUGE: " + gauge);
+          if (gauge.getName().endsWith("/qps")) {
+            totalQps += gauge.getLongValue();
+          }
+        }
+        log.info("TOTAL QPS: " + totalQps);
+      }, metricsLogRateSecs, metricsLogRateSecs, SECONDS);
+    }
+  }
+
   @VisibleForTesting
   void runStressTest() throws Exception {
     Preconditions.checkState(!shutdown, "client was shutdown.");
@@ -245,8 +267,8 @@ void runStressTest() throws Exception {
         ManagedChannel channel = createChannel(address);
         channels.add(channel);
         for (int j = 0; j < stubsPerChannel; j++) {
-          String gaugeName =
-              String.format("/stress_test/server_%d/channel_%d/stub_%d/qps", serverIdx, i, j);
+          String gaugeName = String.format(
+              Locale.US, "/stress_test/server_%d/channel_%d/stub_%d/qps", serverIdx, i, j);
           Worker worker =
               new Worker(channel, testCaseWeightPairs, durationSecs, gaugeName);
 
@@ -286,7 +308,9 @@ void shutdown() {
     }
 
     try {
-      metricsServer.shutdownNow();
+      if (metricsServer != null) {
+        metricsServer.shutdownNow();
+      }
     } catch (Throwable t) {
       log.log(Level.WARNING, "Error shutting down metrics service!", t);
     }
@@ -298,6 +322,14 @@ void shutdown() {
     } catch (Throwable t) {
       log.log(Level.WARNING, "Error shutting down threadpool.", t);
     }
+
+    try {
+      if (metricsLoggingThreadpool != null) {
+        metricsLoggingThreadpool.shutdownNow();
+      }
+    } catch (Throwable t) {
+      log.log(Level.WARNING, "Error shutting down metrics logging threadpool.", t);
+    }
   }
 
   @VisibleForTesting
@@ -306,29 +338,19 @@ int getMetricServerPort() {
   }
 
   private List<InetSocketAddress> parseServerAddresses(String addressesStr) {
-    List<InetSocketAddress> addresses = new ArrayList<InetSocketAddress>();
+    List<InetSocketAddress> addresses = new ArrayList<>();
 
     for (List<String> namePort : parseCommaSeparatedTuples(addressesStr)) {
-      InetAddress address;
       String name = namePort.get(0);
       int port = Integer.valueOf(namePort.get(1));
-      try {
-        address = InetAddress.getByName(name);
-        if (serverHostOverride != null) {
-          // Force the hostname to match the cert the server uses.
-          address = InetAddress.getByAddress(serverHostOverride, address.getAddress());
-        }
-      } catch (UnknownHostException ex) {
-        throw new RuntimeException(ex);
-      }
-      addresses.add(new InetSocketAddress(address, port));
+      addresses.add(new InetSocketAddress(name, port));
     }
 
     return addresses;
   }
 
   private static List<TestCaseWeightPair> parseTestCases(String testCasesStr) {
-    List<TestCaseWeightPair> testCaseWeightPairs = new ArrayList<TestCaseWeightPair>();
+    List<TestCaseWeightPair> testCaseWeightPairs = new ArrayList<>();
 
     for (List<String> nameWeight : parseCommaSeparatedTuples(testCasesStr)) {
       TestCases testCase = TestCases.fromString(nameWeight.get(0));
@@ -340,7 +362,7 @@ private static List<TestCaseWeightPair> parseTestCases(String testCasesStr) {
   }
 
   private static List<List<String>> parseCommaSeparatedTuples(String str) {
-    List<List<String>> tuples = new ArrayList<List<String>>();
+    List<List<String>> tuples = new ArrayList<>();
     for (String tupleStr : Splitter.on(',').split(str)) {
       int splitIdx = tupleStr.lastIndexOf(':');
       if (splitIdx == -1) {
@@ -354,23 +376,51 @@ private static List<List<String>> parseCommaSeparatedTuples(String str) {
   }
 
   private ManagedChannel createChannel(InetSocketAddress address) {
-    SslContext sslContext = null;
-    if (useTestCa) {
-      try {
-        sslContext = GrpcSslContexts.forClient().trustManager(
-            TestUtils.loadCert("ca.pem")).build();
-      } catch (Exception ex) {
-        throw new RuntimeException(ex);
+    ChannelCredentials channelCredentials;
+    if (customCredentialsType != null) {
+      if (customCredentialsType.equals("google_default_credentials")) {
+        channelCredentials = GoogleDefaultChannelCredentials.create();
+      } else if (customCredentialsType.equals("compute_engine_channel_creds")) {
+        channelCredentials = ComputeEngineChannelCredentials.create();
+      } else {
+        throw new IllegalArgumentException(
+            "Unknown custom credentials: " + customCredentialsType);
       }
+    } else if (useTls) {
+      if (useTestCa) {
+        try {
+          channelCredentials = TlsChannelCredentials.newBuilder()
+              .trustManager(TlsTesting.loadCert("ca.pem"))
+              .build();
+        } catch (Exception ex) {
+          throw new RuntimeException(ex);
+        }
+      } else {
+        channelCredentials = TlsChannelCredentials.create();
+      }
+    } else {
+      channelCredentials = InsecureChannelCredentials.create();
+    }
+    ManagedChannelBuilder<?> builder;
+    if (address.getPort() == 0) {
+      builder = Grpc.newChannelBuilder(address.getHostString(), channelCredentials);
+    } else {
+      builder = Grpc.newChannelBuilderForAddress(address.getHostString(), address.getPort(),
+          channelCredentials);
     }
-    return NettyChannelBuilder.forAddress(address)
-        .negotiationType(useTls ? NegotiationType.TLS : NegotiationType.PLAINTEXT)
-        .sslContext(sslContext)
-        .build();
+
+    if (serverHostOverride != null) {
+      builder.overrideAuthority(serverHostOverride);
+    }
+    return builder.build();
+  }
+
+  private long getTotalCallCount() {
+    return totalCallCount.get();
   }
 
   private static String serverAddressesToString(List<InetSocketAddress> addresses) {
-    List<String> tmp = new ArrayList<String>();
+    List<String> tmp = new ArrayList<>();
     for (InetSocketAddress address : addresses) {
       URI uri;
       try {
@@ -386,7 +436,7 @@ private static String serverAddressesToString(List<InetSocketAddress> addresses)
   private static String validTestCasesHelpText() {
     StringBuilder builder = new StringBuilder();
     for (TestCases testCase : TestCases.values()) {
-      String strTestcase = testCase.name().toLowerCase();
+      String strTestcase = testCase.toString();
       builder.append("\n      ")
           .append(strTestcase)
           .append(": ")
@@ -424,7 +474,11 @@ public void run() {
       Thread.currentThread().setName(gaugeName);
 
       Tester tester = new Tester();
+      // The client stream tracers that AbstractInteropTest installs by default would fill up the
+      // heap in no time in a long running stress test with many requests.
+      tester.setEnableClientStreamTracers(false);
       tester.setUp();
+
       WeightedTestCaseSelector testCaseSelector = new WeightedTestCaseSelector(testCaseWeightPairs);
       Long endTime = durationSec == null ? null : System.nanoTime() + SECONDS.toNanos(durationSecs);
       long lastMetricsCollectionTime = initLastMetricsCollectionTime();
@@ -440,6 +494,7 @@ public void run() {
         }
 
         testCasesSinceLastMetricsCollection++;
+        totalCallCount.incrementAndGet();
 
         double durationSecs = computeDurationSecs(lastMetricsCollectionTime);
         if (durationSecs >= METRICS_COLLECTION_INTERVAL_SECS) {
@@ -530,6 +585,11 @@ protected ManagedChannel createChannel() {
         return Worker.this.channel;
       }
 
+      @Override
+      protected ManagedChannelBuilder<?> createChannelBuilder() {
+        throw new UnsupportedOperationException();
+      }
+
       @Override
       protected int operationTimeoutMillis() {
         // Don't enforce a timeout when using the interop tests for the stress test client.
@@ -556,7 +616,7 @@ class WeightedTestCaseSelector {
         Preconditions.checkNotNull(testCaseWeightPairs, "testCaseWeightPairs");
         Preconditions.checkArgument(testCaseWeightPairs.size() > 0);
 
-        List<TestCases> testCases = new ArrayList<TestCases>();
+        List<TestCases> testCases = new ArrayList<>();
         for (TestCaseWeightPair testCaseWeightPair : testCaseWeightPairs) {
           for (int i = 0; i < testCaseWeightPair.weight; i++) {
             testCases.add(testCaseWeightPair.testCase);
@@ -648,6 +708,11 @@ boolean useTestCa() {
     return useTestCa;
   }
 
+  @VisibleForTesting
+  String customCredentialsType() {
+    return customCredentialsType;
+  }
+
   @VisibleForTesting
   List<TestCaseWeightPair> testCaseWeightPairs() {
     return testCaseWeightPairs;
@@ -672,4 +737,9 @@ int stubsPerChannel() {
   int metricsPort() {
     return metricsPort;
   }
+
+  @VisibleForTesting
+  int metricsLogRateSecs() {
+    return metricsLogRateSecs;
+  }
 }
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/TestCases.java b/interop-testing/src/main/java/io/grpc/testing/integration/TestCases.java
index 03faf935ee7..2d16065254a 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/TestCases.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/TestCases.java
@@ -1,60 +1,65 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
 import com.google.common.base.Preconditions;
+import java.util.Locale;
 
 /**
  * Enum of interop test cases.
  */
 public enum TestCases {
   EMPTY_UNARY("empty (zero bytes) request and response"),
+  CACHEABLE_UNARY("cacheable unary rpc sent using GET"),
   LARGE_UNARY("single request and (large) response"),
+  CLIENT_COMPRESSED_UNARY("client compressed unary request"),
+  CLIENT_COMPRESSED_UNARY_NOPROBE(
+      "client compressed unary request (skip initial feature-probing request)"),
+  SERVER_COMPRESSED_UNARY("server compressed unary response"),
   CLIENT_STREAMING("request streaming with single response"),
+  CLIENT_COMPRESSED_STREAMING("client per-message compression on stream"),
+  CLIENT_COMPRESSED_STREAMING_NOPROBE(
+      "client per-message compression on stream (skip initial feature-probing request)"),
   SERVER_STREAMING("single request with response streaming"),
+  SERVER_COMPRESSED_STREAMING("server per-message compression on stream"),
   PING_PONG("full-duplex ping-pong streaming"),
   EMPTY_STREAM("A stream that has zero-messages in both directions"),
   COMPUTE_ENGINE_CREDS("large_unary with service_account auth"),
+  COMPUTE_ENGINE_CHANNEL_CREDENTIALS("large unary with compute engine channel builder"),
   SERVICE_ACCOUNT_CREDS("large_unary with compute engine auth"),
   JWT_TOKEN_CREDS("JWT-based auth"),
   OAUTH2_AUTH_TOKEN("raw oauth2 access token auth"),
   PER_RPC_CREDS("per rpc raw oauth2 access token auth"),
+  GOOGLE_DEFAULT_CREDENTIALS(
+      "google default credentials, i.e. GoogleManagedChannel based auth"),
   CUSTOM_METADATA("unary and full duplex calls with metadata"),
   STATUS_CODE_AND_MESSAGE("request error code and message"),
+  SPECIAL_STATUS_MESSAGE("special characters in status message"),
   UNIMPLEMENTED_METHOD("call an unimplemented RPC method"),
   UNIMPLEMENTED_SERVICE("call an unimplemented RPC service"),
   CANCEL_AFTER_BEGIN("cancel stream after starting it"),
   CANCEL_AFTER_FIRST_RESPONSE("cancel on first response"),
-  TIMEOUT_ON_SLEEPING_SERVER("timeout before receiving a response");
+  TIMEOUT_ON_SLEEPING_SERVER("timeout before receiving a response"),
+  VERY_LARGE_REQUEST("very large request"),
+  PICK_FIRST_UNARY("all requests are sent to one server despite multiple servers are resolved"),
+  RPC_SOAK("sends 'soak_iterations' large_unary rpcs in a loop, each on the same channel"),
+  CHANNEL_SOAK("sends 'soak_iterations' large_unary rpcs in a loop, each on a new channel"),
+  ORCA_PER_RPC("report backend metrics per query"),
+  ORCA_OOB("report backend metrics out-of-band");
 
   private final String description;
 
@@ -75,6 +80,11 @@ public String description() {
    */
   public static TestCases fromString(String s) {
     Preconditions.checkNotNull(s, "s");
-    return TestCases.valueOf(s.toUpperCase());
+    return TestCases.valueOf(s.toUpperCase(Locale.ROOT));
+  }
+
+  @Override
+  public String toString() {
+    return name().toLowerCase(Locale.ROOT);
   }
 }
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceClient.java b/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceClient.java
index e9f2e7d8f80..125d876b705 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceClient.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceClient.java
@@ -1,53 +1,84 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.google.auth.oauth2.AccessToken;
+import com.google.auth.oauth2.ComputeEngineCredentials;
+import com.google.auth.oauth2.GoogleCredentials;
+import com.google.auth.oauth2.OAuth2Credentials;
+import com.google.auth.oauth2.ServiceAccountCredentials;
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.io.Files;
+import com.google.protobuf.ByteString;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ChannelCredentials;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientInterceptors;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
 import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerBuilder;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.alts.AltsChannelCredentials;
+import io.grpc.alts.ComputeEngineChannelCredentials;
+import io.grpc.alts.GoogleDefaultChannelCredentials;
+import io.grpc.auth.MoreCallCredentials;
 import io.grpc.internal.GrpcUtil;
-import io.grpc.netty.GrpcSslContexts;
-import io.grpc.netty.NegotiationType;
+import io.grpc.internal.JsonParser;
+import io.grpc.netty.InsecureFromHttp1ChannelCredentials;
+import io.grpc.netty.InternalNettyChannelBuilder;
 import io.grpc.netty.NettyChannelBuilder;
+import io.grpc.okhttp.InternalOkHttpChannelBuilder;
 import io.grpc.okhttp.OkHttpChannelBuilder;
-import io.grpc.okhttp.internal.Platform;
-import io.grpc.testing.TestUtils;
-import io.netty.handler.ssl.SslContext;
+import io.grpc.stub.ClientCalls;
+import io.grpc.stub.MetadataUtils;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.TlsTesting;
+import io.grpc.testing.integration.Messages.Payload;
+import io.grpc.testing.integration.Messages.ResponseParameters;
+import io.grpc.testing.integration.Messages.SimpleRequest;
+import io.grpc.testing.integration.Messages.SimpleResponse;
+import io.grpc.testing.integration.Messages.StreamingOutputCallRequest;
+import io.grpc.testing.integration.Messages.StreamingOutputCallResponse;
+import io.grpc.testing.integration.Messages.TestOrcaReport;
 import java.io.File;
 import java.io.FileInputStream;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.net.UnknownHostException;
+import java.io.InputStream;
 import java.nio.charset.Charset;
-import javax.net.ssl.SSLSocketFactory;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
 
 /**
  * Application that starts a client for the {@link TestServiceGrpc.TestServiceImplBase} and runs
@@ -57,48 +88,60 @@ public class TestServiceClient {
 
   private static final Charset UTF_8 = Charset.forName("UTF-8");
 
+  static final CallOptions.Key<AtomicReference<TestOrcaReport>>
+      ORCA_RPC_REPORT_KEY = CallOptions.Key.create("orca-rpc-report");
+  static final CallOptions.Key<AtomicReference<TestOrcaReport>>
+      ORCA_OOB_REPORT_KEY = CallOptions.Key.create("orca-oob-report");
+
   /**
    * The main application allowing this client to be launched from the command line.
    */
   public static void main(String[] args) throws Exception {
     final TestServiceClient client = new TestServiceClient();
     client.parseArgs(args);
+    customBackendMetricsLoadBalancerProvider = new CustomBackendMetricsLoadBalancerProvider();
+    LoadBalancerRegistry.getDefaultRegistry().register(customBackendMetricsLoadBalancerProvider);
     client.setUp();
 
-    Runtime.getRuntime().addShutdownHook(new Thread() {
-      @Override
-      public void run() {
-        System.out.println("Shutting down");
-        try {
-          client.tearDown();
-        } catch (Exception e) {
-          e.printStackTrace();
-        }
-      }
-    });
-
     try {
       client.run();
     } finally {
       client.tearDown();
     }
-    System.exit(0);
   }
 
   private String serverHost = "localhost";
   private String serverHostOverride;
   private int serverPort = 8080;
   private String testCase = "empty_unary";
+  private int numTimes = 1;
   private boolean useTls = true;
+  private boolean useAlts = false;
+  private boolean useH2cUpgrade = false;
+  private String customCredentialsType;
   private boolean useTestCa;
   private boolean useOkHttp;
   private String defaultServiceAccount;
   private String serviceAccountKeyFile;
   private String oauthScope;
+  private int localHandshakerPort = -1;
+  private Map<String, ?> serviceConfig = null;
+  private int soakIterations = 10;
+  private int soakMaxFailures = 0;
+  private int soakPerIterationMaxAcceptableLatencyMs = 1000;
+  private int soakMinTimeMsBetweenRpcs = 0;
+  private int soakOverallTimeoutSeconds =
+      soakIterations * soakPerIterationMaxAcceptableLatencyMs / 1000;
+  private int soakRequestSize = 271828;
+  private int soakResponseSize = 314159;
+  private int numThreads = 1;
+  private String additionalMetadata = "";
+  private static LoadBalancerProvider customBackendMetricsLoadBalancerProvider;
 
   private Tester tester = new Tester();
 
-  private void parseArgs(String[] args) {
+  @VisibleForTesting
+  void parseArgs(String[] args) throws Exception {
     boolean usage = false;
     for (String arg : args) {
       if (!arg.startsWith("--")) {
@@ -126,8 +169,16 @@ private void parseArgs(String[] args) {
         serverPort = Integer.parseInt(value);
       } else if ("test_case".equals(key)) {
         testCase = value;
+      } else if ("num_times".equals(key)) {
+        numTimes = Integer.parseInt(value);
       } else if ("use_tls".equals(key)) {
         useTls = Boolean.parseBoolean(value);
+      } else if ("use_upgrade".equals(key)) {
+        useH2cUpgrade = Boolean.parseBoolean(value);
+      } else if ("use_alts".equals(key)) {
+        useAlts = Boolean.parseBoolean(value);
+      } else if ("custom_credentials_type".equals(key)) {
+        customCredentialsType = value;
       } else if ("use_test_ca".equals(key)) {
         useTestCa = Boolean.parseBoolean(value);
       } else if ("use_okhttp".equals(key)) {
@@ -144,12 +195,39 @@ private void parseArgs(String[] args) {
         serviceAccountKeyFile = value;
       } else if ("oauth_scope".equals(key)) {
         oauthScope = value;
+      } else if ("local_handshaker_port".equals(key)) {
+        localHandshakerPort = Integer.parseInt(value);
+      } else if ("service_config_json".equals(key)) {
+        @SuppressWarnings("unchecked")
+        Map<String, ?> map = (Map<String, ?>) JsonParser.parse(value);
+        serviceConfig = map;
+      } else if ("soak_iterations".equals(key)) {
+        soakIterations = Integer.parseInt(value);
+      } else if ("soak_max_failures".equals(key)) {
+        soakMaxFailures = Integer.parseInt(value);
+      } else if ("soak_per_iteration_max_acceptable_latency_ms".equals(key)) {
+        soakPerIterationMaxAcceptableLatencyMs = Integer.parseInt(value);
+      } else if ("soak_min_time_ms_between_rpcs".equals(key)) {
+        soakMinTimeMsBetweenRpcs = Integer.parseInt(value);
+      } else if ("soak_overall_timeout_seconds".equals(key)) {
+        soakOverallTimeoutSeconds = Integer.parseInt(value);
+      } else if ("soak_request_size".equals(key)) {
+        soakRequestSize = Integer.parseInt(value);
+      } else if ("soak_response_size".equals(key)) {
+        soakResponseSize = Integer.parseInt(value);
+      }  else if ("soak_num_threads".equals(key)) {
+        numThreads = Integer.parseInt(value);
+      } else if ("additional_metadata".equals(key)) {
+        additionalMetadata = value;
       } else {
         System.err.println("Unknown argument: " + key);
         usage = true;
         break;
       }
     }
+    if (useAlts || useH2cUpgrade) {
+      useTls = false;
+    }
     if (usage) {
       TestServiceClient c = new TestServiceClient();
       System.out.println(
@@ -162,7 +240,19 @@ private void parseArgs(String[] args) {
           + "\n  --test_case=TESTCASE        Test case to run. Default " + c.testCase
           + "\n    Valid options:"
           + validTestCasesHelpText()
+          + "\n  --num_times=INT             Number of times to run the test case. Default: "
+          + c.numTimes
           + "\n  --use_tls=true|false        Whether to use TLS. Default " + c.useTls
+          + "\n  --use_alts=true|false       Whether to use ALTS. Enable ALTS will disable TLS."
+          + "\n                              Default " + c.useAlts
+          + "\n  --local_handshaker_port=PORT"
+          + "\n                              Use local ALTS handshaker service on the specified "
+          + "\n                              port for testing. Only effective when --use_alts=true."
+          + "\n  --use_upgrade=true|false    Whether to use the h2c Upgrade mechanism."
+          + "\n                              Enabling h2c Upgrade will disable TLS."
+          + "\n                              Default " + c.useH2cUpgrade
+          + "\n  --custom_credentials_type   Custom credentials type to use. Default "
+            + c.customCredentialsType
           + "\n  --use_test_ca=true|false    Whether to trust our fake CA. Requires --use_tls=true "
           + "\n                              to have effect. Default " + c.useTestCa
           + "\n  --use_okhttp=true|false     Whether to use OkHttp instead of Netty. Default "
@@ -172,18 +262,61 @@ private void parseArgs(String[] args) {
           + "\n  --service_account_key_file  Path to service account json key file."
             + c.serviceAccountKeyFile
           + "\n  --oauth_scope               Scope for OAuth tokens. Default " + c.oauthScope
+          + "\n --service_config_json=SERVICE_CONFIG_JSON"
+          + "\n                              Disables service config lookups and sets the provided "
+          + "\n                              string as the default service config."
+          + "\n --soak_iterations            The number of iterations to use for the two soak "
+          + "\n                              tests: rpc_soak and channel_soak. Default "
+            + c.soakIterations
+          + "\n --soak_max_failures          The number of iterations in soak tests that are "
+          + "\n                              allowed to fail (either due to non-OK status code or "
+          + "\n                              exceeding the per-iteration max acceptable latency). "
+          + "\n                              Default " + c.soakMaxFailures
+          + "\n --soak_per_iteration_max_acceptable_latency_ms "
+          + "\n                              The number of milliseconds a single iteration in the "
+          + "\n                              two soak tests (rpc_soak and channel_soak) should "
+          + "\n                              take. Default "
+            + c.soakPerIterationMaxAcceptableLatencyMs
+          + "\n --soak_min_time_ms_between_rpcs "
+          + "\n                              The minimum time in milliseconds between consecutive "
+          + "\n                              RPCs in a soak test (rpc_soak or channel_soak), "
+          + "\n                              useful for limiting QPS. Default: "
+          + c.soakMinTimeMsBetweenRpcs
+          + "\n --soak_overall_timeout_seconds "
+          + "\n                              The overall number of seconds after which a soak test "
+          + "\n                              should stop and fail, if the desired number of "
+          + "\n                              iterations have not yet completed. Default "
+            + c.soakOverallTimeoutSeconds
+          + "\n --soak_request_size "
+          + "\n                              The request size in a soak RPC. Default "
+            + c.soakRequestSize
+          + "\n --soak_response_size "
+          + "\n                              The response size in a soak RPC. Default "
+            + c.soakResponseSize
+          + "\n --soak_num_threads           The number of threads for concurrent execution of the "
+          + "\n                              soak tests (rpc_soak or channel_soak). Default "
+            + c.numThreads
+          + "\n --additional_metadata "
+          + "\n                              Additional metadata to send in each request, as a "
+          + "\n                              semicolon-separated list of key:value pairs. Default "
+            + c.additionalMetadata
       );
       System.exit(1);
     }
   }
 
-  private void setUp() {
+  @VisibleForTesting
+  void setUp() {
     tester.setUp();
   }
 
   private synchronized void tearDown() {
     try {
       tester.tearDown();
+      if (customBackendMetricsLoadBalancerProvider != null) {
+        LoadBalancerRegistry.getDefaultRegistry()
+            .deregister(customBackendMetricsLoadBalancerProvider);
+      }
     } catch (RuntimeException ex) {
       throw ex;
     } catch (Exception ex) {
@@ -194,7 +327,9 @@ private synchronized void tearDown() {
   private void run() {
     System.out.println("Running test " + testCase);
     try {
-      runTest(TestCases.fromString(testCase));
+      for (int i = 0; i < numTimes; i++) {
+        runTest(TestCases.fromString(testCase));
+      }
     } catch (RuntimeException ex) {
       throw ex;
     } catch (Exception ex) {
@@ -209,18 +344,47 @@ private void runTest(TestCases testCase) throws Exception {
         tester.emptyUnary();
         break;
 
+      case CACHEABLE_UNARY: {
+        tester.cacheableUnary();
+        break;
+      }
+
       case LARGE_UNARY:
         tester.largeUnary();
         break;
 
+      case CLIENT_COMPRESSED_UNARY:
+        tester.clientCompressedUnary(true);
+        break;
+
+      case CLIENT_COMPRESSED_UNARY_NOPROBE:
+        tester.clientCompressedUnary(false);
+        break;
+
+      case SERVER_COMPRESSED_UNARY:
+        tester.serverCompressedUnary();
+        break;
+
       case CLIENT_STREAMING:
         tester.clientStreaming();
         break;
 
+      case CLIENT_COMPRESSED_STREAMING:
+        tester.clientCompressedStreaming(true);
+        break;
+
+      case CLIENT_COMPRESSED_STREAMING_NOPROBE:
+        tester.clientCompressedStreaming(false);
+        break;
+
       case SERVER_STREAMING:
         tester.serverStreaming();
         break;
 
+      case SERVER_COMPRESSED_STREAMING:
+        tester.serverCompressedStreaming();
+        break;
+
       case PING_PONG:
         tester.pingPong();
         break;
@@ -233,8 +397,33 @@ private void runTest(TestCases testCase) throws Exception {
         tester.computeEngineCreds(defaultServiceAccount, oauthScope);
         break;
 
+      case COMPUTE_ENGINE_CHANNEL_CREDENTIALS: {
+        ManagedChannelBuilder<?> builder;
+        if (serverPort == 0) {
+          builder = Grpc.newChannelBuilder(serverHost, ComputeEngineChannelCredentials.create());
+        } else {
+          builder =
+              Grpc.newChannelBuilderForAddress(
+                  serverHost, serverPort, ComputeEngineChannelCredentials.create());
+        }
+        if (serviceConfig != null) {
+          builder.disableServiceConfigLookUp();
+          builder.defaultServiceConfig(serviceConfig);
+        }
+        ManagedChannel channel = builder.build();
+        try {
+          TestServiceGrpc.TestServiceBlockingStub computeEngineStub =
+              TestServiceGrpc.newBlockingStub(channel);
+          tester.computeEngineChannelCredentials(defaultServiceAccount, computeEngineStub);
+        } finally {
+          channel.shutdownNow();
+          channel.awaitTermination(5, TimeUnit.SECONDS);
+        }
+        break;
+      }
+
       case SERVICE_ACCOUNT_CREDS: {
-        String jsonKey = Files.toString(new File(serviceAccountKeyFile), UTF_8);
+        String jsonKey = Files.asCharSource(new File(serviceAccountKeyFile), UTF_8).read();
         FileInputStream credentialsStream = new FileInputStream(new File(serviceAccountKeyFile));
         tester.serviceAccountCreds(jsonKey, credentialsStream, oauthScope);
         break;
@@ -247,19 +436,43 @@ private void runTest(TestCases testCase) throws Exception {
       }
 
       case OAUTH2_AUTH_TOKEN: {
-        String jsonKey = Files.toString(new File(serviceAccountKeyFile), UTF_8);
+        String jsonKey = Files.asCharSource(new File(serviceAccountKeyFile), UTF_8).read();
         FileInputStream credentialsStream = new FileInputStream(new File(serviceAccountKeyFile));
         tester.oauth2AuthToken(jsonKey, credentialsStream, oauthScope);
         break;
       }
 
       case PER_RPC_CREDS: {
-        String jsonKey = Files.toString(new File(serviceAccountKeyFile), UTF_8);
+        String jsonKey = Files.asCharSource(new File(serviceAccountKeyFile), UTF_8).read();
         FileInputStream credentialsStream = new FileInputStream(new File(serviceAccountKeyFile));
         tester.perRpcCreds(jsonKey, credentialsStream, oauthScope);
         break;
       }
 
+      case GOOGLE_DEFAULT_CREDENTIALS: {
+        ManagedChannelBuilder<?> builder;
+        if (serverPort == 0) {
+          builder = Grpc.newChannelBuilder(serverHost, GoogleDefaultChannelCredentials.create());
+        } else {
+          builder =
+              Grpc.newChannelBuilderForAddress(
+                  serverHost, serverPort, GoogleDefaultChannelCredentials.create());
+        }
+        if (serviceConfig != null) {
+          builder.disableServiceConfigLookUp();
+          builder.defaultServiceConfig(serviceConfig);
+        }
+        ManagedChannel channel = builder.build();
+        try {
+          TestServiceGrpc.TestServiceBlockingStub googleDefaultStub =
+              TestServiceGrpc.newBlockingStub(channel);
+          tester.googleDefaultCredentials(defaultServiceAccount, googleDefaultStub);
+        } finally {
+          channel.shutdownNow();
+        }
+        break;
+      }
+
       case CUSTOM_METADATA: {
         tester.customMetadata();
         break;
@@ -270,6 +483,10 @@ private void runTest(TestCases testCase) throws Exception {
         break;
       }
 
+      case SPECIAL_STATUS_MESSAGE:
+        tester.specialStatusMessage();
+        break;
+
       case UNIMPLEMENTED_METHOD: {
         tester.unimplementedMethod();
         break;
@@ -295,74 +512,554 @@ private void runTest(TestCases testCase) throws Exception {
         break;
       }
 
+      case VERY_LARGE_REQUEST: {
+        tester.veryLargeRequest();
+        break;
+      }
+
+      case PICK_FIRST_UNARY: {
+        tester.pickFirstUnary();
+        break;
+      }
+
+      case RPC_SOAK: {
+        SoakClient.performSoakTest(
+            serverHost,
+            soakIterations,
+            soakMaxFailures,
+            soakPerIterationMaxAcceptableLatencyMs,
+            soakMinTimeMsBetweenRpcs,
+            soakOverallTimeoutSeconds,
+            soakRequestSize,
+            soakResponseSize,
+            numThreads,
+            tester.createChannelBuilder().build(),
+            (currentChannel) -> currentChannel);
+        break;
+      }
+
+      case CHANNEL_SOAK: {
+        SoakClient.performSoakTest(
+            serverHost,
+            soakIterations,
+            soakMaxFailures,
+            soakPerIterationMaxAcceptableLatencyMs,
+            soakMinTimeMsBetweenRpcs,
+            soakOverallTimeoutSeconds,
+            soakRequestSize,
+            soakResponseSize,
+            numThreads,
+            tester.createChannelBuilder().build(),
+            (currentChannel) -> tester.createNewChannel(currentChannel));
+        break;
+      }
+
+      case ORCA_PER_RPC: {
+        tester.testOrcaPerRpc();
+        break;
+      }
+
+      case ORCA_OOB: {
+        tester.testOrcaOob();
+        break;
+      }
+
       default:
         throw new IllegalArgumentException("Unknown test case: " + testCase);
     }
   }
 
+  /* Parses input string as a semi-colon-separated list of colon-separated key/value pairs.
+   * Allow any character but semicolons in values.
+   * If the string is empty, return null.
+   * Otherwise, return a client interceptor which inserts the provided metadata.
+   */
+  @Nullable
+  private ClientInterceptor maybeCreateAdditionalMetadataInterceptor(
+      String additionalMd)
+      throws IllegalArgumentException {
+    if (additionalMd.length() == 0) {
+      return null;
+    }
+    Metadata metadata = new Metadata();
+    String[] pairs = additionalMd.split(";", -1);
+    for (String pair : pairs) {
+      String[] parts = pair.split(":", 2);
+      if (parts.length != 2) {
+        throw new IllegalArgumentException(
+            "error parsing --additional_metadata string, expected k:v pairs separated by ;");
+      }
+      Metadata.Key<String> key = Metadata.Key.of(parts[0], Metadata.ASCII_STRING_MARSHALLER);
+      metadata.put(key, parts[1]);
+    }
+    return MetadataUtils.newAttachHeadersInterceptor(metadata);
+  }
+
   private class Tester extends AbstractInteropTest {
     @Override
-    protected ManagedChannel createChannel() {
-      if (!useOkHttp) {
-        InetAddress address;
-        try {
-          address = InetAddress.getByName(serverHost);
-          if (serverHostOverride != null) {
-            // Force the hostname to match the cert the server uses.
-            address = InetAddress.getByAddress(serverHostOverride, address.getAddress());
-          }
-        } catch (UnknownHostException ex) {
-          throw new RuntimeException(ex);
+    protected ManagedChannelBuilder<?> createChannelBuilder() {
+      boolean useGeneric = false;
+      ChannelCredentials channelCredentials;
+      if (customCredentialsType != null) {
+        useGeneric = true; // Retain old behavior; avoids erroring if incompatible
+        if (customCredentialsType.equals("google_default_credentials")) {
+          channelCredentials = GoogleDefaultChannelCredentials.create();
+        } else if (customCredentialsType.equals("compute_engine_channel_creds")) {
+          channelCredentials = ComputeEngineChannelCredentials.create();
+        } else {
+          throw new IllegalArgumentException(
+              "Unknown custom credentials: " + customCredentialsType);
+        }
+
+      } else if (useAlts) {
+        useGeneric = true; // Retain old behavior; avoids erroring if incompatible
+        if (localHandshakerPort > -1) {
+          channelCredentials = AltsChannelCredentials.newBuilder()
+              .enableUntrustedAltsForTesting()
+              .setHandshakerAddressForTesting("localhost:" + localHandshakerPort).build();
+        } else {
+          channelCredentials = AltsChannelCredentials.create();
         }
-        SslContext sslContext = null;
-        if (useTestCa) {
+
+      } else if (useTls) {
+        if (!useTestCa) {
+          channelCredentials = TlsChannelCredentials.create();
+        } else {
           try {
-            sslContext = GrpcSslContexts.forClient().trustManager(
-                    TestUtils.loadCert("ca.pem")).build();
+            channelCredentials = TlsChannelCredentials.newBuilder()
+                .trustManager(TlsTesting.loadCert("ca.pem"))
+                .build();
           } catch (Exception ex) {
             throw new RuntimeException(ex);
           }
         }
-        return NettyChannelBuilder.forAddress(new InetSocketAddress(address, serverPort))
-            .flowControlWindow(65 * 1024)
-            .negotiationType(useTls ? NegotiationType.TLS : NegotiationType.PLAINTEXT)
-            .sslContext(sslContext)
-            .build();
+
       } else {
-        OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress(serverHost, serverPort);
+        if (useH2cUpgrade) {
+          if (useOkHttp) {
+            throw new IllegalArgumentException("OkHttp does not support HTTP/1 upgrade");
+          } else {
+            channelCredentials = InsecureFromHttp1ChannelCredentials.create();
+          }
+        } else {
+          channelCredentials = InsecureChannelCredentials.create();
+        }
+      }
+      ClientInterceptor addMdInterceptor = maybeCreateAdditionalMetadataInterceptor(
+          additionalMetadata);
+      if (useGeneric) {
+        ManagedChannelBuilder<?> channelBuilder;
+        if (serverPort == 0) {
+          channelBuilder = Grpc.newChannelBuilder(serverHost, channelCredentials);
+        } else {
+          channelBuilder =
+              Grpc.newChannelBuilderForAddress(serverHost, serverPort, channelCredentials);
+        }
         if (serverHostOverride != null) {
-          // Force the hostname to match the cert the server uses.
-          builder.overrideAuthority(
-              GrpcUtil.authorityFromHostAndPort(serverHostOverride, serverPort));
+          channelBuilder.overrideAuthority(serverHostOverride);
         }
-        if (useTls) {
-          try {
-            SSLSocketFactory factory = useTestCa
-                ? TestUtils.newSslSocketFactoryForCa(Platform.get().getProvider(),
-                    TestUtils.loadCert("ca.pem"))
-                : (SSLSocketFactory) SSLSocketFactory.getDefault();
-            builder.sslSocketFactory(factory);
-          } catch (Exception e) {
-            throw new RuntimeException(e);
-          }
+        if (serviceConfig != null) {
+          channelBuilder.disableServiceConfigLookUp();
+          channelBuilder.defaultServiceConfig(serviceConfig);
+        }
+        if (addMdInterceptor != null) {
+          channelBuilder.intercept(addMdInterceptor);
+        }
+        return channelBuilder;
+      }
+      if (!useOkHttp) {
+        NettyChannelBuilder nettyBuilder;
+        if (serverPort == 0) {
+          nettyBuilder = NettyChannelBuilder.forTarget(serverHost, channelCredentials);
         } else {
-          builder.usePlaintext(true);
+          nettyBuilder = NettyChannelBuilder.forAddress(serverHost, serverPort, channelCredentials);
+        }
+        nettyBuilder.flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW);
+        if (serverHostOverride != null) {
+          nettyBuilder.overrideAuthority(serverHostOverride);
+        }
+        // Disable the default census stats interceptor, use testing interceptor instead.
+        InternalNettyChannelBuilder.setStatsEnabled(nettyBuilder, false);
+        if (serviceConfig != null) {
+          nettyBuilder.disableServiceConfigLookUp();
+          nettyBuilder.defaultServiceConfig(serviceConfig);
+        }
+        if (addMdInterceptor != null) {
+          nettyBuilder.intercept(addMdInterceptor);
         }
-        return builder.build();
+        return nettyBuilder.intercept(createCensusStatsClientInterceptor());
+      }
+
+      OkHttpChannelBuilder okBuilder;
+      if (serverPort == 0) {
+        okBuilder = OkHttpChannelBuilder.forTarget(serverHost, channelCredentials);
+      } else {
+        okBuilder = OkHttpChannelBuilder.forAddress(serverHost, serverPort, channelCredentials);
+      }
+      if (serverHostOverride != null) {
+        // Force the hostname to match the cert the server uses.
+        okBuilder.overrideAuthority(
+            GrpcUtil.authorityFromHostAndPort(serverHostOverride, serverPort));
+      }
+      // Disable the default census stats interceptor, use testing interceptor instead.
+      InternalOkHttpChannelBuilder.setStatsEnabled(okBuilder, false);
+      if (serviceConfig != null) {
+        okBuilder.disableServiceConfigLookUp();
+        okBuilder.defaultServiceConfig(serviceConfig);
       }
+      if (addMdInterceptor != null) {
+        okBuilder.intercept(addMdInterceptor);
+      }
+      return okBuilder.intercept(createCensusStatsClientInterceptor());
+    }
+
+    ManagedChannel createNewChannel(ManagedChannel currentChannel) {
+      currentChannel.shutdownNow();
+      try {
+        currentChannel.awaitTermination(10, TimeUnit.SECONDS);
+      } catch (InterruptedException e) {
+        throw new RuntimeException("Interrupted while creating a new channel", e);
+      }
+      return createChannel();
+    }
+
+    /**
+     * Assuming "pick_first" policy is used, tests that all requests are sent to the same server.
+     */
+    public void pickFirstUnary() throws Exception {
+      SimpleRequest request = SimpleRequest.newBuilder()
+          .setResponseSize(1)
+          .setFillServerId(true)
+          .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[1])))
+          .build();
+
+      SimpleResponse firstResponse = blockingStub.unaryCall(request);
+      // Increase the chance of all servers are connected, in case the channel should be doing
+      // round_robin instead.
+      Thread.sleep(5000);
+      for (int i = 0; i < 100; i++) {
+        SimpleResponse response = blockingStub.unaryCall(request);
+        assertThat(response.getServerId()).isEqualTo(firstResponse.getServerId());
+      }
+    }
+
+    /**
+     * Sends a cacheable unary rpc using GET. Requires that the server is behind a caching proxy.
+     */
+    public void cacheableUnary() {
+      // THIS TEST IS BROKEN. Enabling safe just on the MethodDescriptor does nothing by itself.
+      // This test would need to enable GET on the channel.
+      // Set safe to true.
+      MethodDescriptor<SimpleRequest, SimpleResponse> safeCacheableUnaryCallMethod =
+          TestServiceGrpc.getCacheableUnaryCallMethod().toBuilder().setSafe(true).build();
+      // Set fake user IP since some proxies (GFE) won't cache requests from localhost.
+      Metadata.Key<String> userIpKey =
+          Metadata.Key.of("x-user-ip", Metadata.ASCII_STRING_MARSHALLER);
+      Metadata metadata = new Metadata();
+      metadata.put(userIpKey, "1.2.3.4");
+      Channel channelWithUserIpKey = ClientInterceptors.intercept(
+          channel, MetadataUtils.newAttachHeadersInterceptor(metadata));
+      SimpleRequest requests1And2 =
+          SimpleRequest.newBuilder()
+              .setPayload(
+                  Payload.newBuilder()
+                      .setBody(ByteString.copyFromUtf8(String.valueOf(System.nanoTime()))))
+              .build();
+      SimpleRequest request3 =
+          SimpleRequest.newBuilder()
+              .setPayload(
+                  Payload.newBuilder()
+                      .setBody(ByteString.copyFromUtf8(String.valueOf(System.nanoTime()))))
+              .build();
+
+      SimpleResponse response1 =
+          ClientCalls.blockingUnaryCall(
+              channelWithUserIpKey, safeCacheableUnaryCallMethod, CallOptions.DEFAULT,
+              requests1And2);
+      SimpleResponse response2 =
+          ClientCalls.blockingUnaryCall(
+              channelWithUserIpKey, safeCacheableUnaryCallMethod, CallOptions.DEFAULT,
+              requests1And2);
+      SimpleResponse response3 =
+          ClientCalls.blockingUnaryCall(
+              channelWithUserIpKey, safeCacheableUnaryCallMethod, CallOptions.DEFAULT, request3);
+
+      assertEquals(response1, response2);
+      assertNotEquals(response1, response3);
+      // THIS TEST IS BROKEN. See comment at start of method.
+    }
+
+    /** Sends a large unary rpc with service account credentials. */
+    public void serviceAccountCreds(String jsonKey, InputStream credentialsStream, String authScope)
+        throws Exception {
+      // cast to ServiceAccountCredentials to double-check the right type of object was created.
+      GoogleCredentials credentials =
+          ServiceAccountCredentials.class.cast(GoogleCredentials.fromStream(credentialsStream));
+      credentials = credentials.createScoped(Arrays.asList(authScope));
+      TestServiceGrpc.TestServiceBlockingStub stub = blockingStub
+          .withCallCredentials(MoreCallCredentials.from(credentials));
+      final SimpleRequest request = SimpleRequest.newBuilder()
+          .setFillUsername(true)
+          .setFillOauthScope(true)
+          .setResponseSize(314159)
+          .setPayload(Payload.newBuilder()
+              .setBody(ByteString.copyFrom(new byte[271828])))
+          .build();
+
+      final SimpleResponse response = stub.unaryCall(request);
+      assertFalse(response.getUsername().isEmpty());
+      assertTrue("Received username: " + response.getUsername(),
+          jsonKey.contains(response.getUsername()));
+      assertFalse(response.getOauthScope().isEmpty());
+      assertTrue("Received oauth scope: " + response.getOauthScope(),
+          authScope.contains(response.getOauthScope()));
+
+      final SimpleResponse goldenResponse = SimpleResponse.newBuilder()
+          .setOauthScope(response.getOauthScope())
+          .setUsername(response.getUsername())
+          .setPayload(Payload.newBuilder()
+              .setBody(ByteString.copyFrom(new byte[314159])))
+          .build();
+      assertResponse(goldenResponse, response);
+    }
+
+    /** Sends a large unary rpc with compute engine credentials. */
+    public void computeEngineCreds(String serviceAccount, String oauthScope) throws Exception {
+      ComputeEngineCredentials credentials = ComputeEngineCredentials.create();
+      TestServiceGrpc.TestServiceBlockingStub stub = blockingStub
+          .withCallCredentials(MoreCallCredentials.from(credentials));
+      final SimpleRequest request = SimpleRequest.newBuilder()
+          .setFillUsername(true)
+          .setFillOauthScope(true)
+          .setResponseSize(314159)
+          .setPayload(Payload.newBuilder()
+              .setBody(ByteString.copyFrom(new byte[271828])))
+          .build();
+
+      final SimpleResponse response = stub.unaryCall(request);
+      assertEquals(serviceAccount, response.getUsername());
+      assertFalse(response.getOauthScope().isEmpty());
+      assertTrue("Received oauth scope: " + response.getOauthScope(),
+          oauthScope.contains(response.getOauthScope()));
+
+      final SimpleResponse goldenResponse = SimpleResponse.newBuilder()
+          .setOauthScope(response.getOauthScope())
+          .setUsername(response.getUsername())
+          .setPayload(Payload.newBuilder()
+              .setBody(ByteString.copyFrom(new byte[314159])))
+          .build();
+      assertResponse(goldenResponse, response);
+    }
+
+    /** Sends an unary rpc with ComputeEngineChannelBuilder. */
+    public void computeEngineChannelCredentials(
+        String defaultServiceAccount,
+        TestServiceGrpc.TestServiceBlockingStub computeEngineStub) throws Exception {
+      final SimpleRequest request = SimpleRequest.newBuilder()
+          .setFillUsername(true)
+          .setResponseSize(314159)
+          .setPayload(Payload.newBuilder()
+          .setBody(ByteString.copyFrom(new byte[271828])))
+          .build();
+      final SimpleResponse response = computeEngineStub.unaryCall(request);
+      assertEquals(defaultServiceAccount, response.getUsername());
+      final SimpleResponse goldenResponse = SimpleResponse.newBuilder()
+          .setUsername(defaultServiceAccount)
+          .setPayload(Payload.newBuilder()
+          .setBody(ByteString.copyFrom(new byte[314159])))
+          .build();
+      assertResponse(goldenResponse, response);
+    }
+
+    /** Test JWT-based auth. */
+    public void jwtTokenCreds(InputStream serviceAccountJson) throws Exception {
+      final SimpleRequest request = SimpleRequest.newBuilder()
+          .setResponseSize(314159)
+          .setPayload(Payload.newBuilder()
+              .setBody(ByteString.copyFrom(new byte[271828])))
+          .setFillUsername(true)
+          .build();
+
+      ServiceAccountCredentials credentials = (ServiceAccountCredentials)
+          GoogleCredentials.fromStream(serviceAccountJson);
+      TestServiceGrpc.TestServiceBlockingStub stub = blockingStub
+          .withCallCredentials(MoreCallCredentials.from(credentials));
+      SimpleResponse response = stub.unaryCall(request);
+      assertEquals(credentials.getClientEmail(), response.getUsername());
+      assertEquals(314159, response.getPayload().getBody().size());
+    }
+
+    /** Sends a unary rpc with raw oauth2 access token credentials. */
+    public void oauth2AuthToken(String jsonKey, InputStream credentialsStream, String authScope)
+        throws Exception {
+      GoogleCredentials utilCredentials =
+          GoogleCredentials.fromStream(credentialsStream);
+      utilCredentials = utilCredentials.createScoped(Arrays.asList(authScope));
+      AccessToken accessToken = utilCredentials.refreshAccessToken();
+
+      OAuth2Credentials credentials = OAuth2Credentials.create(accessToken);
+
+      TestServiceGrpc.TestServiceBlockingStub stub = blockingStub
+          .withCallCredentials(MoreCallCredentials.from(credentials));
+      final SimpleRequest request = SimpleRequest.newBuilder()
+          .setFillUsername(true)
+          .setFillOauthScope(true)
+          .build();
+
+      final SimpleResponse response = stub.unaryCall(request);
+      assertFalse(response.getUsername().isEmpty());
+      assertTrue("Received username: " + response.getUsername(),
+          jsonKey.contains(response.getUsername()));
+      assertFalse(response.getOauthScope().isEmpty());
+      assertTrue("Received oauth scope: " + response.getOauthScope(),
+          authScope.contains(response.getOauthScope()));
+    }
+
+    /** Sends a unary rpc with "per rpc" raw oauth2 access token credentials. */
+    public void perRpcCreds(String jsonKey, InputStream credentialsStream, String oauthScope)
+        throws Exception {
+      // In gRpc Java, we don't have per Rpc credentials, user can use an intercepted stub only once
+      // for that purpose.
+      // So, this test is identical to oauth2_auth_token test.
+      oauth2AuthToken(jsonKey, credentialsStream, oauthScope);
+    }
+
+    /** Sends an unary rpc with "google default credentials". */
+    public void googleDefaultCredentials(
+        String defaultServiceAccount,
+        TestServiceGrpc.TestServiceBlockingStub googleDefaultStub) throws Exception {
+      final SimpleRequest request = SimpleRequest.newBuilder()
+          .setFillUsername(true)
+          .setResponseSize(314159)
+          .setPayload(Payload.newBuilder()
+              .setBody(ByteString.copyFrom(new byte[271828])))
+          .build();
+      final SimpleResponse response = googleDefaultStub.unaryCall(request);
+      assertEquals(defaultServiceAccount, response.getUsername());
+
+      final SimpleResponse goldenResponse = SimpleResponse.newBuilder()
+          .setUsername(defaultServiceAccount)
+          .setPayload(Payload.newBuilder()
+              .setBody(ByteString.copyFrom(new byte[314159])))
+          .build();
+      assertResponse(goldenResponse, response);
+    }
+
+    /**
+     *  Test backend metrics per query reporting: expect the test client LB policy to receive load
+     *  reports.
+     */
+    public void testOrcaPerRpc() throws Exception {
+      AtomicReference<TestOrcaReport> reportHolder = new AtomicReference<>();
+      TestOrcaReport answer = TestOrcaReport.newBuilder()
+          .setCpuUtilization(0.8210)
+          .setMemoryUtilization(0.5847)
+          .putRequestCost("cost", 3456.32)
+          .putUtilization("util", 0.30499)
+          .build();
+      blockingStub.withOption(ORCA_RPC_REPORT_KEY, reportHolder).unaryCall(
+          SimpleRequest.newBuilder().setOrcaPerQueryReport(answer).build());
+      assertThat(reportHolder.get()).isEqualTo(answer);
+    }
+
+    /**
+     * Test backend metrics OOB reporting: expect the test client LB policy to receive load reports.
+     */
+    public void testOrcaOob() throws Exception {
+      AtomicReference<TestOrcaReport> reportHolder = new AtomicReference<>();
+      final TestOrcaReport answer = TestOrcaReport.newBuilder()
+          .setCpuUtilization(0.8210)
+          .setMemoryUtilization(0.5847)
+          .putUtilization("util", 0.30499)
+          .build();
+      final TestOrcaReport answer2 = TestOrcaReport.newBuilder()
+          .setCpuUtilization(0.29309)
+          .setMemoryUtilization(0.2)
+          .putUtilization("util", 0.2039)
+          .build();
+
+      final int retryLimit = 5;
+      BlockingQueue<Object> queue = new LinkedBlockingQueue<>();
+      final Object lastItem = new Object();
+      StreamObserver<StreamingOutputCallRequest> streamObserver =
+          asyncStub.fullDuplexCall(new StreamObserver<StreamingOutputCallResponse>() {
+
+            @Override
+            public void onNext(StreamingOutputCallResponse value) {
+              queue.add(value);
+            }
+
+            @Override
+            public void onError(Throwable t) {
+              queue.add(t);
+            }
+
+            @Override
+            public void onCompleted() {
+              queue.add(lastItem);
+            }
+          });
+
+      streamObserver.onNext(StreamingOutputCallRequest.newBuilder()
+          .setOrcaOobReport(answer)
+          .addResponseParameters(ResponseParameters.newBuilder().setSize(1).build()).build());
+      assertThat(queue.take()).isInstanceOf(StreamingOutputCallResponse.class);
+      int i = 0;
+      for (; i < retryLimit; i++) {
+        Thread.sleep(1000);
+        blockingStub.withOption(ORCA_OOB_REPORT_KEY, reportHolder).emptyCall(EMPTY);
+        if (answer.equals(reportHolder.get())) {
+          break;
+        }
+      }
+      assertThat(i).isLessThan(retryLimit);
+      streamObserver.onNext(StreamingOutputCallRequest.newBuilder()
+          .setOrcaOobReport(answer2)
+          .addResponseParameters(ResponseParameters.newBuilder().setSize(1).build()).build());
+      assertThat(queue.take()).isInstanceOf(StreamingOutputCallResponse.class);
+
+      for (i = 0; i < retryLimit; i++) {
+        Thread.sleep(1000);
+        blockingStub.withOption(ORCA_OOB_REPORT_KEY, reportHolder).emptyCall(EMPTY);
+        if (reportHolder.get().equals(answer2)) {
+          break;
+        }
+      }
+      assertThat(i).isLessThan(retryLimit);
+      streamObserver.onCompleted();
+      assertThat(queue.take()).isSameInstanceAs(lastItem);
     }
 
     @Override
     protected boolean metricsExpected() {
-      // Server-side metrics won't be found, because server is a separate process.
+      // Exact message size doesn't match when testing with Go servers:
+      // https://github.com/grpc/grpc-go/issues/1572
+      // TODO(zhangkun83): remove this override once the said issue is fixed.
       return false;
     }
+
+    @Override
+    @Nullable
+    protected ServerBuilder<?> getHandshakerServerBuilder() {
+      if (localHandshakerPort > -1) {
+        return Grpc.newServerBuilderForPort(localHandshakerPort,
+            InsecureServerCredentials.create())
+            .addService(new AltsHandshakerTestService());
+      } else {
+        return null;
+      }
+    }
+
+    @Override
+    protected int operationTimeoutMillis() {
+      return 15000;
+    }
   }
 
   private static String validTestCasesHelpText() {
     StringBuilder builder = new StringBuilder();
     for (TestCases testCase : TestCases.values()) {
-      String strTestcase = testCase.name().toLowerCase();
+      String strTestcase = testCase.toString();
       builder.append("\n      ")
           .append(strTestcase)
           .append(": ")
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceImpl.java b/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceImpl.java
index f23da93b1c7..a9ee9382495 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceImpl.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceImpl.java
@@ -1,50 +1,38 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.Queues;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
 import com.google.protobuf.ByteString;
-import com.google.protobuf.EmptyProtos;
 import io.grpc.ForwardingServerCall.SimpleForwardingServerCall;
 import io.grpc.Metadata;
 import io.grpc.ServerCall;
 import io.grpc.ServerCallHandler;
 import io.grpc.ServerInterceptor;
 import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
 import io.grpc.internal.LogExceptionRunnable;
+import io.grpc.services.CallMetricRecorder;
+import io.grpc.services.MetricRecorder;
 import io.grpc.stub.ServerCallStreamObserver;
 import io.grpc.stub.StreamObserver;
-import io.grpc.testing.integration.Messages.PayloadType;
+import io.grpc.testing.integration.Messages.Payload;
 import io.grpc.testing.integration.Messages.ResponseParameters;
 import io.grpc.testing.integration.Messages.SimpleRequest;
 import io.grpc.testing.integration.Messages.SimpleResponse;
@@ -52,44 +40,54 @@
 import io.grpc.testing.integration.Messages.StreamingInputCallResponse;
 import io.grpc.testing.integration.Messages.StreamingOutputCallRequest;
 import io.grpc.testing.integration.Messages.StreamingOutputCallResponse;
-import java.io.IOException;
-import java.io.InputStream;
+import io.grpc.testing.integration.Messages.TestOrcaReport;
+import io.grpc.testing.integration.TestServiceGrpc.AsyncService;
+import java.util.ArrayDeque;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.HashSet;
-import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 import java.util.Queue;
 import java.util.Random;
 import java.util.Set;
 import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
-import javax.annotation.concurrent.GuardedBy;
 
 /**
  * Implementation of the business logic for the TestService. Uses an executor to schedule chunks
  * sent in response streams.
  */
-public class TestServiceImpl extends TestServiceGrpc.TestServiceImplBase {
-  private static final String UNCOMPRESSABLE_FILE =
-      "/io/grpc/testing/integration/testdata/uncompressable.bin";
+public class TestServiceImpl implements io.grpc.BindableService, AsyncService {
   private final Random random = new Random();
 
   private final ScheduledExecutorService executor;
-  private final ByteString uncompressableBuffer;
   private final ByteString compressableBuffer;
+  private final MetricRecorder metricRecorder;
+  final Semaphore lock = new Semaphore(1);
 
   /**
    * Constructs a controller using the given executor for scheduling response stream chunks.
    */
-  public TestServiceImpl(ScheduledExecutorService executor) {
+  public TestServiceImpl(ScheduledExecutorService executor, MetricRecorder metricRecorder) {
     this.executor = executor;
     this.compressableBuffer = ByteString.copyFrom(new byte[1024]);
-    this.uncompressableBuffer = createBufferFromFile(UNCOMPRESSABLE_FILE);
+    this.metricRecorder = metricRecorder;
+  }
+
+  public TestServiceImpl(ScheduledExecutorService executor) {
+    this(executor, MetricRecorder.newInstance());
+  }
+
+  @Override
+  public final io.grpc.ServerServiceDefinition bindService() {
+    return TestServiceGrpc.bindService(this);
   }
 
   @Override
-  public void emptyCall(EmptyProtos.Empty empty,
+  public void emptyCall(EmptyProtos.Empty request,
       StreamObserver<EmptyProtos.Empty> responseObserver) {
     responseObserver.onNext(EmptyProtos.Empty.getDefaultInstance());
     responseObserver.onCompleted();
@@ -104,22 +102,10 @@ public void unaryCall(SimpleRequest req, StreamObserver<SimpleResponse> response
         (ServerCallStreamObserver<SimpleResponse>) responseObserver;
     SimpleResponse.Builder responseBuilder = SimpleResponse.newBuilder();
     try {
-      switch (req.getResponseCompression()) {
-        case DEFLATE:
-          // fallthrough, just use gzip
-        case GZIP:
-          obs.setCompression("gzip");
-          break;
-        case NONE:
-          obs.setCompression("identity");
-          break;
-        case UNRECOGNIZED:
-          // fallthrough
-        default:
-          obs.onError(Status.INVALID_ARGUMENT
-              .withDescription("Unknown: " + req.getResponseCompression())
-              .asRuntimeException());
-          return;
+      if (req.hasResponseCompressed() && req.getResponseCompressed().getValue()) {
+        obs.setCompression("gzip");
+      } else {
+        obs.setCompression("identity");
       }
     } catch (IllegalArgumentException e) {
       obs.onError(Status.UNIMPLEMENTED
@@ -130,16 +116,13 @@ public void unaryCall(SimpleRequest req, StreamObserver<SimpleResponse> response
     }
 
     if (req.getResponseSize() != 0) {
-      boolean compressable = compressableResponse(req.getResponseType());
-      ByteString dataBuffer = compressable ? compressableBuffer : uncompressableBuffer;
       // For consistency with the c++ TestServiceImpl, use a random offset for unary calls.
       // TODO(wonderfly): whether or not this is a good approach needs further discussion.
-      int offset = random.nextInt(
-          compressable ? compressableBuffer.size() : uncompressableBuffer.size());
-      ByteString payload = generatePayload(dataBuffer, offset, req.getResponseSize());
-      responseBuilder.getPayloadBuilder()
-          .setType(compressable ? PayloadType.COMPRESSABLE : PayloadType.UNCOMPRESSABLE)
-          .setBody(payload);
+      int offset = random.nextInt(compressableBuffer.size());
+      ByteString payload = generatePayload(compressableBuffer, offset, req.getResponseSize());
+      responseBuilder.setPayload(
+          Payload.newBuilder()
+              .setBody(payload));
     }
 
     if (req.hasResponseStatus()) {
@@ -149,10 +132,34 @@ public void unaryCall(SimpleRequest req, StreamObserver<SimpleResponse> response
       return;
     }
 
+    if (req.hasOrcaPerQueryReport()) {
+      echoCallMetricsFromPayload(req.getOrcaPerQueryReport());
+    }
     responseObserver.onNext(responseBuilder.build());
     responseObserver.onCompleted();
   }
 
+  private static void echoCallMetricsFromPayload(TestOrcaReport report) {
+    CallMetricRecorder recorder = CallMetricRecorder.getCurrent()
+        .recordCpuUtilizationMetric(report.getCpuUtilization())
+        .recordMemoryUtilizationMetric(report.getMemoryUtilization());
+    for (Map.Entry<String, Double> entry : report.getUtilizationMap().entrySet()) {
+      recorder.recordUtilizationMetric(entry.getKey(), entry.getValue());
+    }
+    for (Map.Entry<String, Double> entry : report.getRequestCostMap().entrySet()) {
+      recorder.recordRequestCostMetric(entry.getKey(), entry.getValue());
+    }
+  }
+
+  private void echoMetricsFromPayload(TestOrcaReport report) {
+    metricRecorder.setCpuUtilizationMetric(report.getCpuUtilization());
+    metricRecorder.setMemoryUtilizationMetric(report.getMemoryUtilization());
+    metricRecorder.setAllUtilizationMetrics(new HashMap<>());
+    for (Map.Entry<String, Double> entry : report.getUtilizationMap().entrySet()) {
+      metricRecorder.putUtilizationMetric(entry.getKey(), entry.getValue());
+    }
+  }
+
   /**
    * Given a request that specifies chunk size and interval between responses, creates and schedules
    * the response stream.
@@ -202,11 +209,28 @@ public StreamObserver<Messages.StreamingOutputCallRequest> fullDuplexCall(
       final StreamObserver<Messages.StreamingOutputCallResponse> responseObserver) {
     final ResponseDispatcher dispatcher = new ResponseDispatcher(responseObserver);
     return new StreamObserver<StreamingOutputCallRequest>() {
+      boolean oobTestLocked;
+
       @Override
       public void onNext(StreamingOutputCallRequest request) {
+        // to facilitate multiple clients running orca_oob test in parallel, the server allows
+        // only one orca_oob test client to run at a time to avoid conflicts.
+        if (request.hasOrcaOobReport()) {
+          if (!oobTestLocked) {
+            try {
+              lock.acquire();
+            } catch (InterruptedException ex) {
+              responseObserver.onError(new StatusRuntimeException(
+                  Status.ABORTED.withDescription("server service interrupted").withCause(ex)));
+              return;
+            }
+            oobTestLocked = true;
+          }
+          echoMetricsFromPayload(request.getOrcaOobReport());
+        }
         if (request.hasResponseStatus()) {
           dispatcher.cancel();
-          responseObserver.onError(Status.fromCodeValue(request.getResponseStatus().getCode())
+          dispatcher.onError(Status.fromCodeValue(request.getResponseStatus().getCode())
               .withDescription(request.getResponseStatus().getMessage())
               .asRuntimeException());
           return;
@@ -216,6 +240,10 @@ public void onNext(StreamingOutputCallRequest request) {
 
       @Override
       public void onCompleted() {
+        if (oobTestLocked) {
+          lock.release();
+          oobTestLocked = false;
+        }
         if (!dispatcher.isCancelled()) {
           // Tell the dispatcher that all input has been received.
           dispatcher.completeInput();
@@ -224,7 +252,11 @@ public void onCompleted() {
 
       @Override
       public void onError(Throwable cause) {
-        responseObserver.onError(cause);
+        if (oobTestLocked) {
+          lock.release();
+          oobTestLocked = false;
+        }
+        dispatcher.onError(cause);
       }
     };
   }
@@ -236,7 +268,8 @@ public void onError(Throwable cause) {
   @Override
   public StreamObserver<Messages.StreamingOutputCallRequest> halfDuplexCall(
       final StreamObserver<Messages.StreamingOutputCallResponse> responseObserver) {
-    final Queue<Chunk> chunks = new LinkedList<Chunk>();
+    final ResponseDispatcher dispatcher = new ResponseDispatcher(responseObserver);
+    final Queue<Chunk> chunks = new ArrayDeque<>();
     return new StreamObserver<StreamingOutputCallRequest>() {
       @Override
       public void onNext(StreamingOutputCallRequest request) {
@@ -246,12 +279,12 @@ public void onNext(StreamingOutputCallRequest request) {
       @Override
       public void onCompleted() {
         // Dispatch all of the chunks in one shot.
-        new ResponseDispatcher(responseObserver).enqueue(chunks).completeInput();
+        dispatcher.enqueue(chunks).completeInput();
       }
 
       @Override
       public void onError(Throwable cause) {
-        responseObserver.onError(cause);
+        dispatcher.onError(cause);
       }
     };
   }
@@ -262,7 +295,7 @@ public void onError(Throwable cause) {
    * available, the stream is half-closed.
    */
   private class ResponseDispatcher {
-    private final Chunk completionChunk = new Chunk(0, 0, 0, false);
+    private final Chunk completionChunk = new Chunk(0, 0, 0);
     private final Queue<Chunk> chunks;
     private final StreamObserver<StreamingOutputCallResponse> responseStream;
     private boolean scheduled;
@@ -270,6 +303,7 @@ private class ResponseDispatcher {
     private Throwable failure;
     private Runnable dispatchTask = new Runnable() {
       @Override
+      @SuppressWarnings("CatchAndPrintStackTrace")
       public void run() {
         try {
 
@@ -296,6 +330,11 @@ public void run() {
       }
     };
 
+    /**
+     * The {@link StreamObserver} will be used to send the queue of response chunks. Since calls to
+     * {@link StreamObserver} must be synchronized across threads, no further calls should be made
+     * directly on {@code responseStream} after it is provided to the {@link ResponseDispatcher}.
+     */
     public ResponseDispatcher(StreamObserver<StreamingOutputCallResponse> responseStream) {
       this.chunks = Queues.newLinkedBlockingQueue();
       this.responseStream = responseStream;
@@ -336,6 +375,10 @@ public synchronized boolean isCancelled() {
       return cancelled;
     }
 
+    private synchronized void onError(Throwable cause) {
+      responseStream.onError(cause);
+    }
+
     /**
      * Dispatches the current response chunk to the client. This is only called by the executor. At
      * any time, a given dispatch task should only be registered with the executor once.
@@ -377,12 +420,11 @@ private void scheduleNextChunk() {
 
         // Schedule the next response chunk if there is one.
         Chunk nextChunk = chunks.peek();
-        if (nextChunk != null) {
+        if (nextChunk != null && !executor.isShutdown()) {
           scheduled = true;
           // TODO(ejona): cancel future if RPC is cancelled
           Future<?> unused = executor.schedule(new LogExceptionRunnable(dispatchTask),
               nextChunk.delayMicroseconds, TimeUnit.MICROSECONDS);
-          return;
         }
       }
     }
@@ -398,16 +440,13 @@ private void assertNotFailed() {
    * Breaks down the request and creates a queue of response chunks for the given request.
    */
   public Queue<Chunk> toChunkQueue(StreamingOutputCallRequest request) {
-    Queue<Chunk> chunkQueue = new LinkedList<Chunk>();
+    Queue<Chunk> chunkQueue = new ArrayDeque<>();
     int offset = 0;
-    boolean compressable = compressableResponse(request.getResponseType());
     for (ResponseParameters params : request.getResponseParametersList()) {
-      chunkQueue.add(new Chunk(params.getIntervalUs(), offset, params.getSize(), compressable));
+      chunkQueue.add(new Chunk(params.getIntervalUs(), offset, params.getSize()));
 
-      // Increment the offset past this chunk.
-      // Both buffers need to be circular.
-      offset = (offset + params.getSize())
-          % (compressable ? compressableBuffer.size() : uncompressableBuffer.size());
+      // Increment the offset past this chunk. Buffer need to be circular.
+      offset = (offset + params.getSize()) % compressableBuffer.size();
     }
     return chunkQueue;
   }
@@ -415,20 +454,18 @@ public Queue<Chunk> toChunkQueue(StreamingOutputCallRequest request) {
   /**
    * A single chunk of a response stream. Contains delivery information for the dispatcher and can
    * be converted to a streaming response proto. A chunk just references it's payload in the
-   * {@link #uncompressableBuffer} array. The payload isn't actually created until {@link
+   * {@link #compressableBuffer} array. The payload isn't actually created until {@link
    * #toResponse()} is called.
    */
   private class Chunk {
     private final int delayMicroseconds;
     private final int offset;
     private final int length;
-    private final boolean compressable;
 
-    public Chunk(int delayMicroseconds, int offset, int length, boolean compressable) {
+    public Chunk(int delayMicroseconds, int offset, int length) {
       this.delayMicroseconds = delayMicroseconds;
       this.offset = offset;
       this.length = length;
-      this.compressable = compressable;
     }
 
     /**
@@ -437,55 +474,14 @@ public Chunk(int delayMicroseconds, int offset, int length, boolean compressable
     private StreamingOutputCallResponse toResponse() {
       StreamingOutputCallResponse.Builder responseBuilder =
           StreamingOutputCallResponse.newBuilder();
-      ByteString dataBuffer = compressable ? compressableBuffer : uncompressableBuffer;
-      ByteString payload = generatePayload(dataBuffer, offset, length);
-      responseBuilder.getPayloadBuilder()
-          .setType(compressable ? PayloadType.COMPRESSABLE : PayloadType.UNCOMPRESSABLE)
-          .setBody(payload);
+      ByteString payload = generatePayload(compressableBuffer, offset, length);
+      responseBuilder.setPayload(
+          Payload.newBuilder()
+              .setBody(payload));
       return responseBuilder.build();
     }
   }
 
-  /**
-   * Creates a buffer with data read from a file.
-   */
-  private ByteString createBufferFromFile(String fileClassPath) {
-    ByteString buffer = ByteString.EMPTY;
-    InputStream inputStream = getClass().getResourceAsStream(fileClassPath);
-    if (inputStream == null) {
-      throw new IllegalArgumentException("Unable to locate file on classpath: " + fileClassPath);
-    }
-
-    try {
-      buffer = ByteString.readFrom(inputStream);
-    } catch (IOException e) {
-      throw new RuntimeException(e);
-    } finally {
-      try {
-        inputStream.close();
-      } catch (IOException ignorable) {
-        // ignore
-      }
-    }
-    return buffer;
-  }
-
-  /**
-   * Indicates whether or not the response for this type should be compressable. If {@code RANDOM},
-   * picks a random boolean.
-   */
-  private boolean compressableResponse(PayloadType responseType) {
-    switch (responseType) {
-      case COMPRESSABLE:
-        return true;
-      case RANDOM:
-        return random.nextBoolean();
-      case UNCOMPRESSABLE:
-      default:
-        return false;
-    }
-  }
-
   /**
    * Generates a payload of desired type and size. Reads compressableBuffer or
    * uncompressableBuffer as a circular buffer.
@@ -519,7 +515,7 @@ public static List<ServerInterceptor> interceptors() {
    * testing end-to-end metadata propagation.
    */
   private static ServerInterceptor echoRequestHeadersInterceptor(final Metadata.Key<?>... keys) {
-    final Set<Metadata.Key<?>> keySet = new HashSet<Metadata.Key<?>>(Arrays.asList(keys));
+    final Set<Metadata.Key<?>> keySet = new HashSet<>(Arrays.asList(keys));
     return new ServerInterceptor() {
       @Override
       public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
@@ -547,7 +543,7 @@ public void close(Status status, Metadata trailers) {
    * Echoes request headers with the specified key(s) from a client into response headers only.
    */
   private static ServerInterceptor echoRequestMetadataInHeaders(final Metadata.Key<?>... keys) {
-    final Set<Metadata.Key<?>> keySet = new HashSet<Metadata.Key<?>>(Arrays.asList(keys));
+    final Set<Metadata.Key<?>> keySet = new HashSet<>(Arrays.asList(keys));
     return new ServerInterceptor() {
       @Override
       public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
@@ -574,7 +570,7 @@ public void close(Status status, Metadata trailers) {
    * Echoes request headers with the specified key(s) from a client into response trailers only.
    */
   private static ServerInterceptor echoRequestMetadataInTrailers(final Metadata.Key<?>... keys) {
-    final Set<Metadata.Key<?>> keySet = new HashSet<Metadata.Key<?>>(Arrays.asList(keys));
+    final Set<Metadata.Key<?>> keySet = new HashSet<>(Arrays.asList(keys));
     return new ServerInterceptor() {
       @Override
       public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceServer.java b/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceServer.java
index 95d188fa754..fc4cdf9178f 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceServer.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/TestServiceServer.java
@@ -1,76 +1,72 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.BindableService;
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
 import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCredentials;
 import io.grpc.ServerInterceptors;
-import io.grpc.netty.GrpcSslContexts;
+import io.grpc.TlsServerCredentials;
+import io.grpc.alts.AltsServerCredentials;
 import io.grpc.netty.NettyServerBuilder;
-import io.grpc.testing.TestUtils;
-import io.netty.handler.ssl.SslContext;
+import io.grpc.services.MetricRecorder;
+import io.grpc.testing.TlsTesting;
+import io.grpc.xds.orca.OrcaMetricReportingServerInterceptor;
+import io.grpc.xds.orca.OrcaServiceImpl;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.List;
+import java.util.Locale;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 
-/**
- * Server that manages startup/shutdown of a single {@code TestService}.
- */
+/** Server that manages startup/shutdown of a single {@code TestService}. */
 public class TestServiceServer {
-  /**
-   * The main application allowing this server to be launched from the command line.
-   */
+  /** The main application allowing this server to be launched from the command line. */
   public static void main(String[] args) throws Exception {
     final TestServiceServer server = new TestServiceServer();
     server.parseArgs(args);
     if (server.useTls) {
       System.out.println(
           "\nUsing fake CA for TLS certificate. Test clients should expect host\n"
-          + "*.test.google.fr and our test CA. For the Java test client binary, use:\n"
-          + "--server_host_override=foo.test.google.fr --use_test_ca=true\n");
+              + "*.test.google.fr and our test CA. For the Java test client binary, use:\n"
+              + "--server_host_override=foo.test.google.fr --use_test_ca=true\n");
     }
 
-    Runtime.getRuntime().addShutdownHook(new Thread() {
-      @Override
-      public void run() {
-        try {
-          System.out.println("Shutting down");
-          server.stop();
-        } catch (Exception e) {
-          e.printStackTrace();
-        }
-      }
-    });
+    Runtime.getRuntime()
+        .addShutdownHook(
+            new Thread() {
+              @Override
+              @SuppressWarnings("CatchAndPrintStackTrace")
+              public void run() {
+                try {
+                  System.out.println("Shutting down");
+                  server.stop();
+                } catch (Exception e) {
+                  e.printStackTrace();
+                }
+              }
+            });
     server.start();
     System.out.println("Server started on port " + server.port);
     server.blockUntilShutdown();
@@ -78,9 +74,12 @@ public void run() {
 
   private int port = 8080;
   private boolean useTls = true;
+  private boolean useAlts = false;
 
   private ScheduledExecutorService executor;
   private Server server;
+  private int localHandshakerPort = -1;
+  private Util.AddressType addressType = Util.AddressType.IPV4_IPV6;
 
   @VisibleForTesting
   void parseArgs(String[] args) {
@@ -107,6 +106,12 @@ void parseArgs(String[] args) {
         port = Integer.parseInt(value);
       } else if ("use_tls".equals(key)) {
         useTls = Boolean.parseBoolean(value);
+      } else if ("use_alts".equals(key)) {
+        useAlts = Boolean.parseBoolean(value);
+      } else if ("local_handshaker_port".equals(key)) {
+        localHandshakerPort = Integer.parseInt(value);
+      } else if ("address_type".equals(key)) {
+        addressType = Util.AddressType.valueOf(value.toUpperCase(Locale.ROOT));
       } else if ("grpc_version".equals(key)) {
         if (!"2".equals(value)) {
           System.err.println("Only grpc version 2 is supported");
@@ -119,33 +124,92 @@ void parseArgs(String[] args) {
         break;
       }
     }
+    if (useAlts) {
+      useTls = false;
+    }
     if (usage) {
       TestServiceServer s = new TestServiceServer();
       System.out.println(
           "Usage: [ARGS...]"
-          + "\n"
-          + "\n  --port=PORT           Port to connect to. Default " + s.port
-          + "\n  --use_tls=true|false  Whether to use TLS. Default " + s.useTls
+              + "\n"
+              + "\n  --port=PORT           Port to connect to. Default " + s.port
+              + "\n  --use_tls=true|false  Whether to use TLS. Default " + s.useTls
+              + "\n  --use_alts=true|false Whether to use ALTS. Enable ALTS will disable TLS."
+              + "\n                        Default " + s.useAlts
+              + "\n  --local_handshaker_port=PORT"
+              + "\n                        Use local ALTS handshaker service on the specified port "
+              + "\n                        for testing. Only effective when --use_alts=true."
+              + "\n  --address_type=IPV4|IPV6|IPV4_IPV6"
+              + "\n                        What type of addresses to listen on. Default IPV4_IPV6"
       );
       System.exit(1);
     }
   }
 
+  @SuppressWarnings("AddressSelection")
   @VisibleForTesting
   void start() throws Exception {
     executor = Executors.newSingleThreadScheduledExecutor();
-    SslContext sslContext = null;
-    if (useTls) {
-      sslContext = GrpcSslContexts.forServer(
-              TestUtils.loadCert("server1.pem"), TestUtils.loadCert("server1.key")).build();
+    ServerCredentials serverCreds;
+    if (useAlts) {
+      if (localHandshakerPort > -1) {
+        serverCreds = AltsServerCredentials.newBuilder()
+            .enableUntrustedAltsForTesting()
+            .setHandshakerAddressForTesting("localhost:" + localHandshakerPort).build();
+      } else {
+        serverCreds = AltsServerCredentials.create();
+      }
+    } else if (useTls) {
+      serverCreds = TlsServerCredentials.create(
+          TlsTesting.loadCert("server1.pem"), TlsTesting.loadCert("server1.key"));
+    } else {
+      serverCreds = InsecureServerCredentials.create();
     }
-    server = NettyServerBuilder.forPort(port)
-        .sslContext(sslContext)
-        .maxMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
-        .addService(ServerInterceptors.intercept(
-            new TestServiceImpl(executor),
-            TestServiceImpl.interceptors()))
-        .build().start();
+    MetricRecorder metricRecorder = MetricRecorder.newInstance();
+    BindableService orcaOobService =
+        OrcaServiceImpl.createService(executor, metricRecorder, 1, TimeUnit.SECONDS);
+
+    // Create ServerBuilder with appropriate addresses
+    // - IPV4_IPV6: bind to wildcard which covers all addresses on all interfaces of both families
+    // - IPV4: bind to v4 address for local hostname + v4 localhost
+    // - IPV6: bind to all v6 addresses for local hostname + v6 localhost
+    ServerBuilder<?> serverBuilder;
+    switch (addressType) {
+      case IPV4_IPV6:
+        serverBuilder = Grpc.newServerBuilderForPort(port, serverCreds);
+        break;
+      case IPV4:
+        SocketAddress v4Address = Util.getV4Address(port);
+        InetSocketAddress localV4Address = new InetSocketAddress("127.0.0.1", port);
+        serverBuilder =
+            NettyServerBuilder.forAddress(localV4Address, serverCreds);
+        if (v4Address != null && !v4Address.equals(localV4Address)) {
+          ((NettyServerBuilder) serverBuilder).addListenAddress(v4Address);
+        }
+        break;
+      case IPV6:
+        List<SocketAddress> v6Addresses = Util.getV6Addresses(port);
+        InetSocketAddress localV6Address = new InetSocketAddress("::1", port);
+        serverBuilder =
+            NettyServerBuilder.forAddress(localV6Address, serverCreds);
+        for (SocketAddress address : v6Addresses) {
+          if (!address.equals(localV6Address)) {
+            ((NettyServerBuilder) serverBuilder).addListenAddress(address);
+          }
+        }
+        break;
+      default:
+        throw new AssertionError("Unknown address type: " + addressType);
+    }
+    server = serverBuilder
+        .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
+        .addService(
+            ServerInterceptors.intercept(
+                new TestServiceImpl(executor, metricRecorder), TestServiceImpl.interceptors()))
+        .addService(orcaOobService)
+        .intercept(OrcaMetricReportingServerInterceptor.create(metricRecorder))
+        .build()
+        .start();
   }
 
   @VisibleForTesting
@@ -162,12 +226,11 @@ int getPort() {
     return server.getPort();
   }
 
-  /**
-   * Await termination on the main thread since the grpc library uses daemon threads.
-   */
+  /** Await termination on the main thread since the grpc library uses daemon threads. */
   private void blockUntilShutdown() throws InterruptedException {
     if (server != null) {
       server.awaitTermination();
     }
   }
+
 }
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/Util.java b/interop-testing/src/main/java/io/grpc/testing/integration/Util.java
index 02d838135a3..50da0a6373d 100644
--- a/interop-testing/src/main/java/io/grpc/testing/integration/Util.java
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/Util.java
@@ -1,39 +1,32 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.protobuf.MessageLite;
+import com.google.protobuf.StringValue;
 import io.grpc.Metadata;
-import io.grpc.protobuf.ProtoUtils;
+import io.grpc.protobuf.lite.ProtoLiteUtils;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.SocketAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
 import java.util.List;
 import org.junit.Assert;
 
@@ -42,14 +35,17 @@
  */
 public class Util {
 
-  public static final Metadata.Key<Messages.SimpleContext> METADATA_KEY =
-      ProtoUtils.keyForProto(Messages.SimpleContext.getDefaultInstance());
+  public static final Metadata.Key<StringValue> METADATA_KEY =
+      Metadata.Key.of(
+          "google.protobuf.StringValue" + Metadata.BINARY_HEADER_SUFFIX,
+          ProtoLiteUtils.metadataMarshaller(StringValue.getDefaultInstance()));
   public static final Metadata.Key<String> ECHO_INITIAL_METADATA_KEY
       = Metadata.Key.of("x-grpc-test-echo-initial", Metadata.ASCII_STRING_MARSHALLER);
   public static final Metadata.Key<byte[]> ECHO_TRAILING_METADATA_KEY
       = Metadata.Key.of("x-grpc-test-echo-trailing-bin", Metadata.BINARY_BYTE_MARSHALLER);
 
   /** Assert that two messages are equal, producing a useful message if not. */
+  @SuppressWarnings("LiteProtoToString")
   public static void assertEquals(MessageLite expected, MessageLite actual) {
     if (expected == null || actual == null) {
       Assert.assertEquals(expected, actual);
@@ -77,4 +73,51 @@ public static void assertEquals(List<? extends MessageLite> expected,
       }
     }
   }
+
+  static List<SocketAddress> getV6Addresses(int port) throws UnknownHostException {
+    List<SocketAddress> v6addresses = new ArrayList<>();
+    InetAddress[] addresses = InetAddress.getAllByName(InetAddress.getLocalHost().getHostName());
+    for (InetAddress address : addresses) {
+      if (address.getAddress().length != 4) {
+        v6addresses.add(new java.net.InetSocketAddress(address, port));
+      }
+    }
+    return v6addresses;
+  }
+
+  static SocketAddress getV4Address(int port) throws UnknownHostException {
+    InetAddress[] addresses = InetAddress.getAllByName(InetAddress.getLocalHost().getHostName());
+    for (InetAddress address : addresses) {
+      if (address.getAddress().length == 4) {
+        return new java.net.InetSocketAddress(address, port);
+      }
+    }
+    return null; // means it is v6 only
+  }
+
+
+  /**
+   * Picks a port that is not used right at this moment.
+   * Warning: Not thread safe. May see "BindException: Address already in use: bind" if using the
+   * returned port to create a new server socket when other threads/processes are concurrently
+   * creating new sockets without a specific port.
+   */
+  public static int pickUnusedPort() {
+    try {
+      ServerSocket serverSocket = new ServerSocket(0);
+      int port = serverSocket.getLocalPort();
+      serverSocket.close();
+      return port;
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+
+  @VisibleForTesting
+  enum AddressType {
+    IPV4,
+    IPV6,
+    IPV4_IPV6
+  }
 }
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/XdsFederationTestClient.java b/interop-testing/src/main/java/io/grpc/testing/integration/XdsFederationTestClient.java
new file mode 100644
index 00000000000..bba282b7b6f
--- /dev/null
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/XdsFederationTestClient.java
@@ -0,0 +1,319 @@
+/*
+ * Copyright 2023 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.testing.integration;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.junit.Assert.assertTrue;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.alts.ComputeEngineChannelCredentials;
+import java.util.ArrayList;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
+/**
+ * Test client that can be used to verify that XDS federation works. A list of
+ * server URIs (which can each be load balanced by different XDS servers), can
+ * be configured via flags. A separate thread is created for each of these clients
+ * and the configured test (either rpc_soak or channel_soak) is ran for each client
+ * on each thread.
+ */
+public final class XdsFederationTestClient {
+  private static final Logger logger =
+      Logger.getLogger(XdsFederationTestClient.class.getName());
+
+  /**
+   * Entry point.
+   */
+  public static void main(String[] args) throws Exception {
+    final XdsFederationTestClient client = new XdsFederationTestClient();
+    client.parseArgs(args);
+    client.setUp();
+    client.run();
+    System.exit(0);
+  }
+
+  private String serverUris = "";
+  private String credentialsTypes = "";
+  private int soakIterations = 10;
+  private int soakMaxFailures = 0;
+  private int soakPerIterationMaxAcceptableLatencyMs = 1000;
+  private int soakOverallTimeoutSeconds = 10;
+  private int soakMinTimeMsBetweenRpcs = 0;
+  private int soakRequestSize = 271828;
+  private int soakResponseSize = 314159;
+  private String testCase = "rpc_soak";
+  private final ArrayList<InnerClient> clients = new ArrayList<>();
+
+  private void parseArgs(String[] args) {
+    boolean usage = false;
+    for (String arg : args) {
+      if (!arg.startsWith("--")) {
+        System.err.println("All arguments must start with '--': " + arg);
+        usage = true;
+        break;
+      }
+      String[] parts = arg.substring(2).split("=", 2);
+      String key = parts[0];
+      if (key.equals("help")) {
+        usage = true;
+        break;
+      }
+      if (parts.length != 2) {
+        System.err.println("All arguments must be of the form --arg=value");
+        usage = true;
+        break;
+      }
+      String value = parts[1];
+      switch (key) {
+        case "server_uris":
+          serverUris = value;
+          break;
+        case "credentials_types":
+          credentialsTypes = value;
+          break;
+        case "test_case":
+          testCase = value;
+          break;
+        case "soak_iterations":
+          soakIterations = Integer.parseInt(value);
+          break;
+        case "soak_max_failures":
+          soakMaxFailures = Integer.parseInt(value);
+          break;
+        case "soak_per_iteration_max_acceptable_latency_ms":
+          soakPerIterationMaxAcceptableLatencyMs = Integer.parseInt(value);
+          break;
+        case "soak_overall_timeout_seconds":
+          soakOverallTimeoutSeconds = Integer.parseInt(value);
+          break;
+        case "soak_min_time_ms_between_rpcs":
+          soakMinTimeMsBetweenRpcs = Integer.parseInt(value);
+          break;
+        case "soak_request_size":
+          soakRequestSize = Integer.parseInt(value);
+          break;
+        case "soak_response_size":
+          soakResponseSize = Integer.parseInt(value);
+          break;
+        default:
+          System.err.println("Unknown argument: " + key);
+          usage = true;
+          break;
+      }
+    }
+    if (usage) {
+      XdsFederationTestClient c = new XdsFederationTestClient();
+      System.out.println(
+          "Usage: [ARGS...]"
+          + "\n"
+          + "\n  --server_uris                         Comma separated list of server "
+          + "URIs to make RPCs to. Default: "
+          + c.serverUris
+          + "\n  --credentials_types                   Comma-separated list of "
+          + "\n                                        credentials, each entry is used "
+          + "\n                                        for the server of the "
+          + "\n                                        corresponding index in server_uris. "
+          + "\n                                        Supported values: "
+          + "compute_engine_channel_creds,INSECURE_CREDENTIALS. Default: "
+          + c.credentialsTypes
+          + "\n  --soak_iterations                     The number of iterations to use "
+          + "\n                                        for the two tests: rpc_soak and "
+          + "\n                                        channel_soak. Default: "
+          + c.soakIterations
+          + "\n  --soak_max_failures                   The number of iterations in soak "
+          + "\n                                        tests that are allowed to fail "
+          + "\n                                        (either due to non-OK status code "
+          + "\n                                        or exceeding the per-iteration max "
+          + "\n                                        acceptable latency). Default: "
+          + c.soakMaxFailures
+          + "\n  --soak_per_iteration_max_acceptable_latency_ms"
+          + "\n                                        The number of milliseconds a "
+          + "\n                                        single iteration in the two soak "
+          + "\n                                        tests (rpc_soak and channel_soak) "
+          + "\n                                        should take. Default: "
+          + c.soakPerIterationMaxAcceptableLatencyMs
+          + "\n  --soak_overall_timeout_seconds        The overall number of seconds "
+          + "\n                                        after which a soak test should "
+          + "\n                                        stop and fail, if the desired "
+          + "\n                                        number of iterations have not yet "
+          + "\n                                        completed. Default: "
+          + c.soakOverallTimeoutSeconds
+          + "\n  --soak_min_time_ms_between_rpcs       The minimum time in milliseconds "
+          + "\n                                        between consecutive RPCs in a soak "
+          + "\n                                        test (rpc_soak or channel_soak), "
+          + "\n                                        useful for limiting QPS. Default: "
+          + c.soakMinTimeMsBetweenRpcs
+          + "\n  --test_case=TEST_CASE                 Test case to run. Valid options are:"
+          + "\n      rpc_soak: sends --soak_iterations large_unary RPCs"
+          + "\n      channel_soak: sends --soak_iterations RPCs, rebuilding the channel "
+          + "each time."
+          + "\n      Default: " + c.testCase
+          + "\n --soak_request_size "
+          + "\n                                        The request size in a soak RPC. Default "
+          + c.soakRequestSize
+          + "\n"
+          + " --soak_response_size \n"
+          + "                                          The response size in a soak RPC. Default"
+          + " "
+          + c.soakResponseSize
+      );
+      System.exit(1);
+    }
+  }
+
+  void setUp() {
+    String[] uris = serverUris.split(",", -1);
+    String[] creds = credentialsTypes.split(",", -1);
+    if (uris.length == 0) {
+      throw new IllegalArgumentException("--server_uris is empty");
+    }
+    if (uris.length != creds.length) {
+      throw new IllegalArgumentException("Number of entries in --server_uris "
+          + "does not match number of entries in --credentials_types");
+    }
+    for (int i = 0; i < uris.length; i++) {
+      clients.add(new InnerClient(creds[i], uris[i]));
+    }
+  }
+
+  /**
+   * Wraps a single client stub configuration and executes a
+   * soak test case with that configuration.
+   */
+  class InnerClient {
+    private final String credentialsType;
+    private final String serverUri;
+    private boolean runSucceeded = false;
+
+    public InnerClient(String credentialsType, String serverUri) {
+      this.credentialsType = credentialsType;
+      this.serverUri = serverUri;
+    }
+
+    /**
+     * Indicates whether run succeeded or not. This must only be called
+     * after run() has finished.
+     */
+    public boolean runSucceeded() {
+      return runSucceeded;
+    }
+
+    /**
+     * Run the intended soak test.
+     */
+    public void run() throws InterruptedException {
+      try {
+        switch (testCase) {
+          case "rpc_soak": {
+            SoakClient.performSoakTest(
+                serverUri,
+                soakIterations,
+                soakMaxFailures,
+                soakPerIterationMaxAcceptableLatencyMs,
+                soakMinTimeMsBetweenRpcs,
+                soakOverallTimeoutSeconds,
+                soakRequestSize,
+                soakResponseSize,
+                1,
+                createChannel(),
+                (currentChannel) -> currentChannel);
+          }
+              break;
+          case "channel_soak": {
+            SoakClient.performSoakTest(
+                serverUri,
+                soakIterations,
+                soakMaxFailures,
+                soakPerIterationMaxAcceptableLatencyMs,
+                soakMinTimeMsBetweenRpcs,
+                soakOverallTimeoutSeconds,
+                soakRequestSize,
+                soakResponseSize,
+                1,
+                createChannel(),
+                (currentChannel) -> createNewChannel(currentChannel));
+          }
+            break;
+          default:
+            throw new RuntimeException("invalid testcase: " + testCase);
+        }
+
+        logger.info("Test case: " + testCase + " done for server: " + serverUri);
+        runSucceeded = true;
+      } catch (Exception e) {
+        logger.info("Test case: " + testCase + " failed for server: " + serverUri);
+        throw new RuntimeException(e);
+      }
+    }
+
+    ManagedChannel createChannel() {
+      ChannelCredentials channelCredentials;
+      switch (credentialsType) {
+        case "compute_engine_channel_creds":
+          channelCredentials = ComputeEngineChannelCredentials.create();
+          break;
+        case "INSECURE_CREDENTIALS":
+          channelCredentials = InsecureChannelCredentials.create();
+          break;
+        default:
+          throw new IllegalArgumentException("Unknown custom credentials: " + credentialsType);
+      }
+      return Grpc.newChannelBuilder(serverUri, channelCredentials)
+          .keepAliveTime(3600, SECONDS)
+          .keepAliveTimeout(20, SECONDS)
+          .build();
+    }
+
+    ManagedChannel createNewChannel(ManagedChannel currentChannel) {
+      currentChannel.shutdownNow();
+      try {
+        currentChannel.awaitTermination(10, TimeUnit.SECONDS);
+      } catch (InterruptedException e) {
+        throw new RuntimeException("Interrupted while creating a new channel", e);
+      }
+      return createChannel();
+    }
+  }
+
+  private void run() throws InterruptedException {
+    logger.info("Begin test case: " + testCase);
+    ArrayList<Thread> threads = new ArrayList<>();
+    for (InnerClient c : clients) {
+      Thread t = new Thread(() -> {
+        try {
+          c.run();
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt(); // Properly re-interrupt the thread
+          throw new RuntimeException("Thread was interrupted during execution", e);
+        }
+      });
+      t.start();
+      threads.add(t);
+    }
+    for (Thread t : threads) {
+      t.join();
+    }
+    for (InnerClient c : clients) {
+      assertTrue(c.runSucceeded());
+    }
+    logger.info("Test case: " + testCase + " done for all clients!");
+  }
+}
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/XdsTestClient.java b/interop-testing/src/main/java/io/grpc/testing/integration/XdsTestClient.java
new file mode 100644
index 00000000000..89519041a79
--- /dev/null
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/XdsTestClient.java
@@ -0,0 +1,696 @@
+/*
+ * 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.testing.integration;
+
+import com.google.common.base.CaseFormat;
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableScheduledFuture;
+import com.google.common.util.concurrent.ListeningScheduledExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.protobuf.ByteString;
+import io.grpc.BindableService;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Server;
+import io.grpc.Status;
+import io.grpc.gcp.csm.observability.CsmObservability;
+import io.grpc.protobuf.services.ProtoReflectionService;
+import io.grpc.protobuf.services.ProtoReflectionServiceV1;
+import io.grpc.services.AdminInterface;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.integration.Messages.ClientConfigureRequest;
+import io.grpc.testing.integration.Messages.ClientConfigureRequest.RpcType;
+import io.grpc.testing.integration.Messages.ClientConfigureResponse;
+import io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsRequest;
+import io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse;
+import io.grpc.testing.integration.Messages.LoadBalancerAccumulatedStatsResponse.MethodStats;
+import io.grpc.testing.integration.Messages.LoadBalancerStatsRequest;
+import io.grpc.testing.integration.Messages.LoadBalancerStatsResponse;
+import io.grpc.testing.integration.Messages.Payload;
+import io.grpc.testing.integration.Messages.SimpleRequest;
+import io.grpc.testing.integration.Messages.SimpleResponse;
+import io.grpc.xds.XdsChannelCredentials;
+import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+
+/** Client for xDS interop tests. */
+public final class XdsTestClient {
+  private static Logger logger = Logger.getLogger(XdsTestClient.class.getName());
+
+  private final Set<XdsStatsWatcher> watchers = new HashSet<>();
+  private final Object lock = new Object();
+  private final List<ManagedChannel> channels = new ArrayList<>();
+  private final StatsAccumulator statsAccumulator = new StatsAccumulator();
+
+  private int numChannels = 1;
+  private boolean printResponse = false;
+  private int qps = 1;
+  private volatile List<RpcConfig> rpcConfigs;
+  private int rpcTimeoutSec = 20;
+  private boolean secureMode = false;
+  private String server = "localhost:8080";
+  private int requestSize;
+  private int responseSize;
+  private boolean enableCsmObservability;
+  private int statsPort = 8081;
+  private Server statsServer;
+  private long currentRequestId;
+  private ListeningScheduledExecutorService exec;
+  private CsmObservability csmObservability;
+
+  /**
+   * The main application allowing this client to be launched from the command line.
+   */
+  public static void main(String[] args) {
+    final XdsTestClient client = new XdsTestClient();
+    client.parseArgs(args);
+    Runtime.getRuntime()
+        .addShutdownHook(
+            new Thread() {
+              @Override
+              @SuppressWarnings("CatchAndPrintStackTrace")
+              public void run() {
+                try {
+                  client.stop();
+                } catch (Exception e) {
+                  e.printStackTrace();
+                }
+              }
+            });
+    client.run();
+  }
+
+  private void parseArgs(String[] args) {
+    boolean usage = false;
+    List<RpcType> rpcTypes = ImmutableList.of(RpcType.UNARY_CALL);
+    EnumMap<RpcType, Metadata> metadata = new EnumMap<>(RpcType.class);
+    for (String arg : args) {
+      if (!arg.startsWith("--")) {
+        System.err.println("All arguments must start with '--': " + arg);
+        usage = true;
+        break;
+      }
+      String[] parts = arg.substring(2).split("=", 2);
+      String key = parts[0];
+      if ("help".equals(key)) {
+        usage = true;
+        break;
+      }
+      if (parts.length != 2) {
+        System.err.println("All arguments must be of the form --arg=value");
+        usage = true;
+        break;
+      }
+      String value = parts[1];
+      if ("metadata".equals(key)) {
+        metadata = parseMetadata(value);
+      } else if ("num_channels".equals(key)) {
+        numChannels = Integer.valueOf(value);
+      } else if ("print_response".equals(key)) {
+        printResponse = Boolean.valueOf(value);
+      } else if ("qps".equals(key)) {
+        qps = Integer.valueOf(value);
+      } else if ("rpc".equals(key)) {
+        rpcTypes = parseRpcs(value);
+      } else if ("rpc_timeout_sec".equals(key)) {
+        rpcTimeoutSec = Integer.valueOf(value);
+      } else if ("server".equals(key)) {
+        server = value;
+      } else if ("request_payload_size".equals(key)) {
+        requestSize = Integer.valueOf(value);
+      } else if ("response_payload_size".equals(key)) {
+        responseSize = Integer.valueOf(value);
+      } else if ("enable_csm_observability".equals(key)) {
+        enableCsmObservability = Boolean.valueOf(value);
+      } else if ("stats_port".equals(key)) {
+        statsPort = Integer.valueOf(value);
+      } else if ("secure_mode".equals(key)) {
+        secureMode = Boolean.valueOf(value);
+      } else {
+        System.err.println("Unknown argument: " + key);
+        usage = true;
+        break;
+      }
+    }
+    List<RpcConfig> configs = new ArrayList<>();
+    for (RpcType type : rpcTypes) {
+      Metadata md = new Metadata();
+      if (metadata.containsKey(type)) {
+        md = metadata.get(type);
+      }
+      configs.add(new RpcConfig(type, md, rpcTimeoutSec));
+    }
+    rpcConfigs = Collections.unmodifiableList(configs);
+
+    if (usage) {
+      XdsTestClient c = new XdsTestClient();
+      System.err.println(
+          "Usage: [ARGS...]"
+              + "\n"
+              + "\n  --num_channels=INT     Default: "
+              + c.numChannels
+              + "\n  --print_response=BOOL  Write RPC response to stdout. Default: "
+              + c.printResponse
+              + "\n  --qps=INT              Qps per channel, for each type of RPC. Default: "
+              + c.qps
+              + "\n  --rpc=STR              Types of RPCs to make, ',' separated string. RPCs can "
+              + "be EmptyCall or UnaryCall. Default: UnaryCall"
+              + "\n[deprecated] Use XdsUpdateClientConfigureService"
+              + "\n  --metadata=STR         The metadata to send with each RPC, in the format "
+              + "EmptyCall:key1:value1,UnaryCall:key2:value2."
+              + "\n[deprecated] Use XdsUpdateClientConfigureService"
+              + "\n  --rpc_timeout_sec=INT  Per RPC timeout seconds. Default: "
+              + c.rpcTimeoutSec
+              + "\n  --server=host:port     Address of server. Default: "
+              + c.server
+              + "\n  --secure_mode=BOOLEAN  Use true to enable XdsCredentials. Default: "
+              + c.secureMode
+              + "\n  --request_payload_size=INT   Per-request size. Default: " + c.requestSize
+              + "\n  --response_payload_size=INT  Per-response size. Default: " + c.responseSize
+              + "\n  --enable_csm_observability=BOOL  Enable CSM observability reporting. Default: "
+              + c.enableCsmObservability
+              + "\n  --stats_port=INT       Port to expose peer distribution stats service. "
+              + "Default: "
+              + c.statsPort);
+      System.exit(1);
+    }
+  }
+
+  private static List<RpcType> parseRpcs(String rpcArg) {
+    List<RpcType> rpcs = new ArrayList<>();
+    for (String rpc : Splitter.on(',').split(rpcArg)) {
+      rpcs.add(parseRpc(rpc));
+    }
+    return rpcs;
+  }
+
+  private static EnumMap<RpcType, Metadata> parseMetadata(String metadataArg) {
+    EnumMap<RpcType, Metadata> rpcMetadata = new EnumMap<>(RpcType.class);
+    for (String metadata : Splitter.on(',').omitEmptyStrings().split(metadataArg)) {
+      List<String> parts = Splitter.on(':').splitToList(metadata);
+      if (parts.size() != 3) {
+        throw new IllegalArgumentException("Invalid metadata: '" + metadata + "'");
+      }
+      RpcType rpc = parseRpc(parts.get(0));
+      String key = parts.get(1);
+      String value = parts.get(2);
+      Metadata md = new Metadata();
+      md.put(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER), value);
+      if (rpcMetadata.containsKey(rpc)) {
+        rpcMetadata.get(rpc).merge(md);
+      } else {
+        rpcMetadata.put(rpc, md);
+      }
+    }
+    return rpcMetadata;
+  }
+
+  private static RpcType parseRpc(String rpc) {
+    if ("EmptyCall".equals(rpc)) {
+      return RpcType.EMPTY_CALL;
+    } else if ("UnaryCall".equals(rpc)) {
+      return RpcType.UNARY_CALL;
+    } else {
+      throw new IllegalArgumentException("Unknown RPC: '" + rpc + "'");
+    }
+  }
+
+  @IgnoreJRERequirement // OpenTelemetry uses Java 8+ APIs
+  private void run() {
+    if (enableCsmObservability) {
+      csmObservability = CsmObservability.newBuilder()
+          .sdk(AutoConfiguredOpenTelemetrySdk.builder()
+              .addPropertiesSupplier(() -> ImmutableMap.of(
+                  "otel.logs.exporter", "none",
+                  "otel.metrics.exporter", "prometheus",
+                  "otel.traces.exporter", "none"))
+              .build()
+              .getOpenTelemetrySdk())
+          .build();
+      csmObservability.registerGlobal();
+    }
+    @SuppressWarnings("deprecation")
+    BindableService oldReflectionService = ProtoReflectionService.newInstance();
+    statsServer =
+        Grpc.newServerBuilderForPort(statsPort, InsecureServerCredentials.create())
+            .addService(new XdsStatsImpl())
+            .addService(new ConfigureUpdateServiceImpl())
+            .addService(oldReflectionService)
+            .addService(ProtoReflectionServiceV1.newInstance())
+            .addServices(AdminInterface.getStandardServices())
+            .build();
+    try {
+      statsServer.start();
+      for (int i = 0; i < numChannels; i++) {
+        channels.add(
+            Grpc.newChannelBuilder(
+                    server,
+                    secureMode
+                        ? XdsChannelCredentials.create(InsecureChannelCredentials.create())
+                        : InsecureChannelCredentials.create())
+                .enableRetry()
+                .build());
+      }
+      exec = MoreExecutors.listeningDecorator(Executors.newSingleThreadScheduledExecutor());
+      Payload requestPayload = Payload.newBuilder()
+          .setBody(ByteString.copyFrom(new byte[requestSize]))
+          .build();
+      runQps(requestPayload);
+    } catch (Throwable t) {
+      logger.log(Level.SEVERE, "Error running client", t);
+      System.exit(1);
+    }
+  }
+
+  private void stop() throws InterruptedException {
+    if (statsServer != null) {
+      statsServer.shutdownNow();
+      if (!statsServer.awaitTermination(5, TimeUnit.SECONDS)) {
+        System.err.println("Timed out waiting for server shutdown");
+      }
+    }
+    for (ManagedChannel channel : channels) {
+      channel.shutdownNow();
+    }
+    if (exec != null) {
+      exec.shutdownNow();
+    }
+    if (csmObservability != null) {
+      csmObservability.close();
+    }
+  }
+
+
+  private void runQps(Payload requestPayload) throws InterruptedException, ExecutionException {
+    final SettableFuture<Void> failure = SettableFuture.create();
+    final class PeriodicRpc implements Runnable {
+
+      @Override
+      public void run() {
+        List<RpcConfig> configs = rpcConfigs;
+        for (RpcConfig cfg : configs) {
+          makeRpc(cfg);
+        }
+      }
+
+      private void makeRpc(final RpcConfig config) {
+        final long requestId;
+        final Set<XdsStatsWatcher> savedWatchers = new HashSet<>();
+        synchronized (lock) {
+          currentRequestId += 1;
+          requestId = currentRequestId;
+          savedWatchers.addAll(watchers);
+        }
+
+        ManagedChannel channel = channels.get((int) (requestId % channels.size()));
+        TestServiceGrpc.TestServiceStub stub = TestServiceGrpc.newStub(channel);
+        final AtomicReference<ClientCall<?, ?>> clientCallRef = new AtomicReference<>();
+        final AtomicReference<String> hostnameRef = new AtomicReference<>();
+        stub =
+            stub.withDeadlineAfter(config.timeoutSec, TimeUnit.SECONDS)
+                .withInterceptors(
+                    new ClientInterceptor() {
+                      @Override
+                      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+                          MethodDescriptor<ReqT, RespT> method,
+                          CallOptions callOptions,
+                          Channel next) {
+                        ClientCall<ReqT, RespT> call = next.newCall(method, callOptions);
+                        clientCallRef.set(call);
+                        return new SimpleForwardingClientCall<ReqT, RespT>(call) {
+                          @Override
+                          public void start(Listener<RespT> responseListener, Metadata headers) {
+                            headers.merge(config.metadata);
+                            super.start(
+                                new SimpleForwardingClientCallListener<RespT>(responseListener) {
+                                  @Override
+                                  public void onHeaders(Metadata headers) {
+                                    hostnameRef.set(headers.get(XdsTestServer.HOSTNAME_KEY));
+                                    super.onHeaders(headers);
+                                  }
+                                },
+                                headers);
+                          }
+                        };
+                      }
+                    });
+
+        if (config.rpcType == RpcType.EMPTY_CALL) {
+          stub.emptyCall(
+              EmptyProtos.Empty.getDefaultInstance(),
+              new StreamObserver<EmptyProtos.Empty>() {
+                @Override
+                public void onCompleted() {
+                  handleRpcCompleted(requestId, config.rpcType, hostnameRef.get(), savedWatchers);
+                }
+
+                @Override
+                public void onError(Throwable t) {
+                  handleRpcError(requestId, config.rpcType, Status.fromThrowable(t),
+                      savedWatchers);
+                }
+
+                @Override
+                public void onNext(EmptyProtos.Empty response) {}
+              });
+        } else if (config.rpcType == RpcType.UNARY_CALL) {
+          SimpleRequest request = SimpleRequest.newBuilder()
+              .setFillServerId(true)
+              .setPayload(requestPayload)
+              .setResponseSize(responseSize)
+              .build();
+          stub.unaryCall(
+              request,
+              new StreamObserver<SimpleResponse>() {
+                @Override
+                public void onCompleted() {
+                  handleRpcCompleted(requestId, config.rpcType, hostnameRef.get(), savedWatchers);
+                }
+
+                @Override
+                public void onError(Throwable t) {
+                  if (printResponse) {
+                    logger.log(Level.WARNING, "Rpc failed", t);
+                  }
+                  handleRpcError(requestId, config.rpcType, Status.fromThrowable(t),
+                      savedWatchers);
+                }
+
+                @Override
+                public void onNext(SimpleResponse response) {
+                  // TODO(ericgribkoff) Currently some test environments cannot access the stats RPC
+                  // service and rely on parsing stdout.
+                  if (printResponse) {
+                    System.out.println(
+                        "Greeting: Hello world, this is "
+                            + response.getHostname()
+                            + ", from "
+                            + clientCallRef
+                                .get()
+                                .getAttributes()
+                                .get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR));
+                  }
+                  // Use the hostname from the response if not present in the metadata.
+                  // TODO(ericgribkoff) Delete when server is deployed that sets metadata value.
+                  if (hostnameRef.get() == null) {
+                    hostnameRef.set(response.getHostname());
+                  }
+                }
+              });
+        } else {
+          throw new AssertionError("Unknown RPC type: " + config.rpcType);
+        }
+        statsAccumulator.recordRpcStarted(config.rpcType);
+      }
+
+      private void handleRpcCompleted(long requestId, RpcType rpcType, String hostname,
+          Set<XdsStatsWatcher> watchers) {
+        statsAccumulator.recordRpcFinished(rpcType, Status.OK);
+        notifyWatchers(watchers, rpcType, requestId, hostname);
+      }
+
+      private void handleRpcError(long requestId, RpcType rpcType, Status status,
+          Set<XdsStatsWatcher> watchers) {
+        statsAccumulator.recordRpcFinished(rpcType, status);
+        notifyWatchers(watchers, rpcType, requestId, null);
+      }
+    }
+
+    long nanosPerQuery = TimeUnit.SECONDS.toNanos(1) / qps;
+    ListenableScheduledFuture<?> future =
+        exec.scheduleAtFixedRate(new PeriodicRpc(), 0, nanosPerQuery, TimeUnit.NANOSECONDS);
+    Futures.addCallback(
+        future,
+        new FutureCallback<Object>() {
+
+          @Override
+          public void onFailure(Throwable t) {
+            failure.setException(t);
+          }
+
+          @Override
+          public void onSuccess(Object o) {}
+        },
+        MoreExecutors.directExecutor());
+
+    failure.get();
+  }
+
+  private void notifyWatchers(
+      Set<XdsStatsWatcher> watchers, RpcType rpcType, long requestId, String hostname) {
+    for (XdsStatsWatcher watcher : watchers) {
+      watcher.rpcCompleted(rpcType, requestId, hostname);
+    }
+  }
+
+  private final class ConfigureUpdateServiceImpl extends
+      XdsUpdateClientConfigureServiceGrpc.XdsUpdateClientConfigureServiceImplBase {
+    @Override
+    public void configure(ClientConfigureRequest request,
+        StreamObserver<ClientConfigureResponse> responseObserver) {
+      EnumMap<RpcType, Metadata> newMetadata = new EnumMap<>(RpcType.class);
+      for (ClientConfigureRequest.Metadata metadata : request.getMetadataList()) {
+        Metadata md = newMetadata.get(metadata.getType());
+        if (md == null) {
+          md = new Metadata();
+        }
+        md.put(Metadata.Key.of(metadata.getKey(), Metadata.ASCII_STRING_MARSHALLER),
+            metadata.getValue());
+        newMetadata.put(metadata.getType(), md);
+      }
+      List<RpcConfig> configs = new ArrayList<>();
+      for (RpcType type : request.getTypesList()) {
+        Metadata md = newMetadata.containsKey(type) ? newMetadata.get(type) : new Metadata();
+        int timeout = request.getTimeoutSec() != 0 ? request.getTimeoutSec() : rpcTimeoutSec;
+        configs.add(new RpcConfig(type, md, timeout));
+      }
+      rpcConfigs = Collections.unmodifiableList(configs);
+      responseObserver.onNext(ClientConfigureResponse.getDefaultInstance());
+      responseObserver.onCompleted();
+    }
+  }
+
+  private class XdsStatsImpl extends LoadBalancerStatsServiceGrpc.LoadBalancerStatsServiceImplBase {
+    @Override
+    public void getClientStats(
+        LoadBalancerStatsRequest req, StreamObserver<LoadBalancerStatsResponse> responseObserver) {
+      XdsStatsWatcher watcher;
+      synchronized (lock) {
+        long startId = currentRequestId + 1;
+        long endId = startId + req.getNumRpcs();
+        watcher = new XdsStatsWatcher(startId, endId);
+        watchers.add(watcher);
+      }
+      LoadBalancerStatsResponse response = watcher.waitForRpcStats(req.getTimeoutSec());
+      synchronized (lock) {
+        watchers.remove(watcher);
+      }
+      responseObserver.onNext(response);
+      responseObserver.onCompleted();
+    }
+
+    @Override
+    public void getClientAccumulatedStats(LoadBalancerAccumulatedStatsRequest request,
+        StreamObserver<LoadBalancerAccumulatedStatsResponse> responseObserver) {
+      responseObserver.onNext(statsAccumulator.getRpcStats());
+      responseObserver.onCompleted();
+    }
+  }
+
+  /** Configuration applies to the specific type of RPCs. */
+  private static final class RpcConfig {
+    private final RpcType rpcType;
+    private final Metadata metadata;
+    private final int timeoutSec;
+
+    private RpcConfig(RpcType rpcType, Metadata metadata, int timeoutSec) {
+      this.rpcType = rpcType;
+      this.metadata = metadata;
+      this.timeoutSec = timeoutSec;
+    }
+  }
+
+  /** Stats recorder for test RPCs. */
+  @ThreadSafe
+  private static final class StatsAccumulator {
+    private final Map<String, Integer> rpcsStartedByMethod = new HashMap<>();
+    // TODO(chengyuanzhang): delete the following two after corresponding fields deleted in proto.
+    private final Map<String, Integer> rpcsFailedByMethod = new HashMap<>();
+    private final Map<String, Integer> rpcsSucceededByMethod = new HashMap<>();
+    private final Map<String, Map<Integer, Integer>> rpcStatusByMethod = new HashMap<>();
+
+    private synchronized void recordRpcStarted(RpcType rpcType) {
+      String method = getRpcTypeString(rpcType);
+      int count = rpcsStartedByMethod.containsKey(method) ? rpcsStartedByMethod.get(method) : 0;
+      rpcsStartedByMethod.put(method, count + 1);
+    }
+
+    private synchronized void recordRpcFinished(RpcType rpcType, Status status) {
+      String method = getRpcTypeString(rpcType);
+      if (status.isOk()) {
+        int count =
+            rpcsSucceededByMethod.containsKey(method) ? rpcsSucceededByMethod.get(method) : 0;
+        rpcsSucceededByMethod.put(method, count + 1);
+      } else {
+        int count = rpcsFailedByMethod.containsKey(method) ? rpcsFailedByMethod.get(method) : 0;
+        rpcsFailedByMethod.put(method, count + 1);
+      }
+      int statusCode = status.getCode().value();
+      Map<Integer, Integer> statusCounts = rpcStatusByMethod.get(method);
+      if (statusCounts == null) {
+        statusCounts = new HashMap<>();
+        rpcStatusByMethod.put(method, statusCounts);
+      }
+      int count = statusCounts.containsKey(statusCode) ? statusCounts.get(statusCode) : 0;
+      statusCounts.put(statusCode, count + 1);
+    }
+
+    @SuppressWarnings("deprecation")
+    private synchronized LoadBalancerAccumulatedStatsResponse getRpcStats() {
+      LoadBalancerAccumulatedStatsResponse.Builder builder =
+          LoadBalancerAccumulatedStatsResponse.newBuilder();
+      builder.putAllNumRpcsStartedByMethod(rpcsStartedByMethod);
+      builder.putAllNumRpcsSucceededByMethod(rpcsSucceededByMethod);
+      builder.putAllNumRpcsFailedByMethod(rpcsFailedByMethod);
+
+      for (String method : rpcsStartedByMethod.keySet()) {
+        MethodStats.Builder methodStatsBuilder = MethodStats.newBuilder();
+        methodStatsBuilder.setRpcsStarted(rpcsStartedByMethod.get(method));
+        if (rpcStatusByMethod.containsKey(method)) {
+          methodStatsBuilder.putAllResult(rpcStatusByMethod.get(method));
+        }
+        builder.putStatsPerMethod(method, methodStatsBuilder.build());
+      }
+      return builder.build();
+    }
+
+    // e.g., RpcType.UNARY_CALL -> "UNARY_CALL"
+    private static String getRpcTypeString(RpcType rpcType) {
+      return rpcType.name();
+    }
+  }
+
+  /** Records the remote peer distribution for a given range of RPCs. */
+  private static class XdsStatsWatcher {
+    private final CountDownLatch latch;
+    private final long startId;
+    private final long endId;
+    private final Map<String, Integer> rpcsByPeer = new HashMap<>();
+    private final EnumMap<RpcType, Map<String, Integer>> rpcsByTypeAndPeer =
+        new EnumMap<>(RpcType.class);
+    private final Object lock = new Object();
+    private int rpcsFailed;
+
+    private XdsStatsWatcher(long startId, long endId) {
+      latch = new CountDownLatch(Ints.checkedCast(endId - startId));
+      this.startId = startId;
+      this.endId = endId;
+    }
+
+    void rpcCompleted(RpcType rpcType, long requestId, @Nullable String hostname) {
+      synchronized (lock) {
+        if (startId <= requestId && requestId < endId) {
+          if (hostname != null) {
+            if (rpcsByPeer.containsKey(hostname)) {
+              rpcsByPeer.put(hostname, rpcsByPeer.get(hostname) + 1);
+            } else {
+              rpcsByPeer.put(hostname, 1);
+            }
+            if (rpcsByTypeAndPeer.containsKey(rpcType)) {
+              if (rpcsByTypeAndPeer.get(rpcType).containsKey(hostname)) {
+                rpcsByTypeAndPeer
+                    .get(rpcType)
+                    .put(hostname, rpcsByTypeAndPeer.get(rpcType).get(hostname) + 1);
+              } else {
+                rpcsByTypeAndPeer.get(rpcType).put(hostname, 1);
+              }
+            } else {
+              Map<String, Integer> rpcMap = new HashMap<>();
+              rpcMap.put(hostname, 1);
+              rpcsByTypeAndPeer.put(rpcType, rpcMap);
+            }
+          } else {
+            rpcsFailed += 1;
+          }
+          latch.countDown();
+        }
+      }
+    }
+
+    LoadBalancerStatsResponse waitForRpcStats(long timeoutSeconds) {
+      try {
+        boolean success = latch.await(timeoutSeconds, TimeUnit.SECONDS);
+        if (!success) {
+          logger.log(Level.INFO, "Await timed out, returning partial stats");
+        }
+      } catch (InterruptedException e) {
+        logger.log(Level.INFO, "Await interrupted, returning partial stats", e);
+        Thread.currentThread().interrupt();
+      }
+      LoadBalancerStatsResponse.Builder builder = LoadBalancerStatsResponse.newBuilder();
+      synchronized (lock) {
+        builder.putAllRpcsByPeer(rpcsByPeer);
+        for (Map.Entry<RpcType, Map<String, Integer>> entry : rpcsByTypeAndPeer.entrySet()) {
+          LoadBalancerStatsResponse.RpcsByPeer.Builder rpcs =
+              LoadBalancerStatsResponse.RpcsByPeer.newBuilder();
+          rpcs.putAllRpcsByPeer(entry.getValue());
+          builder.putRpcsByMethod(getRpcTypeString(entry.getKey()), rpcs.build());
+        }
+        builder.setNumFailures(rpcsFailed);
+      }
+      return builder.build();
+    }
+
+    // e.g., RpcType.UNARY_CALL -> "UnaryCall"
+    private static String getRpcTypeString(RpcType rpcType) {
+      return CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, rpcType.name());
+    }
+  }
+}
diff --git a/interop-testing/src/main/java/io/grpc/testing/integration/XdsTestServer.java b/interop-testing/src/main/java/io/grpc/testing/integration/XdsTestServer.java
new file mode 100644
index 00000000000..88f1bf468b6
--- /dev/null
+++ b/interop-testing/src/main/java/io/grpc/testing/integration/XdsTestServer.java
@@ -0,0 +1,499 @@
+/*
+ * 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.testing.integration;
+
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.protobuf.ByteString;
+import io.grpc.BindableService;
+import io.grpc.ForwardingServerCall.SimpleForwardingServerCall;
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Metadata;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerCredentials;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerInterceptors;
+import io.grpc.Status;
+import io.grpc.gcp.csm.observability.CsmObservability;
+import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
+import io.grpc.netty.NettyServerBuilder;
+import io.grpc.protobuf.services.HealthStatusManager;
+import io.grpc.protobuf.services.ProtoReflectionService;
+import io.grpc.protobuf.services.ProtoReflectionServiceV1;
+import io.grpc.services.AdminInterface;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.integration.Messages.Payload;
+import io.grpc.testing.integration.Messages.SimpleRequest;
+import io.grpc.testing.integration.Messages.SimpleResponse;
+import io.grpc.xds.XdsServerBuilder;
+import io.grpc.xds.XdsServerCredentials;
+import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+
+/** Interop test server that implements the xDS testing service. */
+public final class XdsTestServer {
+  static final Metadata.Key<String> HOSTNAME_KEY =
+      Metadata.Key.of("hostname", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> CALL_BEHAVIOR_MD_KEY =
+      Metadata.Key.of("rpc-behavior", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> ATTEMPT_NUM =
+      Metadata.Key.of("grpc-previous-rpc-attempts", Metadata.ASCII_STRING_MARSHALLER);
+  private static final String CALL_BEHAVIOR_KEEP_OPEN_VALUE = "keep-open";
+  private static final String CALL_BEHAVIOR_SLEEP_VALUE = "sleep-";
+  private static final String CALL_BEHAVIOR_SUCCEED_ON_RETRY_ATTEMPT_VALUE =
+      "succeed-on-retry-attempt-";
+  private static final String CALL_BEHAVIOR_ERROR_CODE =
+      "error-code-";
+  private static final String CALL_BEHAVIOR_HOSTNAME = "hostname=";
+  private static final Splitter HEADER_VALUE_SPLITTER = Splitter.on(',')
+      .trimResults()
+      .omitEmptyStrings();
+  private static final Splitter HEADER_HOSTNAME_SPLITTER = Splitter.on(' ');
+
+  private static Logger logger = Logger.getLogger(XdsTestServer.class.getName());
+
+  private int port = 8080;
+  private int maintenancePort = 8080;
+  private boolean secureMode = false;
+  private boolean enableCsmObservability;
+  private String serverId = "java_server";
+  private HealthStatusManager health;
+  private Server server;
+  private Server maintenanceServer;
+  private String host;
+  private Util.AddressType addressType = Util.AddressType.IPV4_IPV6;
+  private CsmObservability csmObservability;
+
+  /**
+   * The main application allowing this client to be launched from the command line.
+   */
+  public static void main(String[] args) throws Exception {
+    final XdsTestServer server = new XdsTestServer();
+    server.parseArgs(args);
+    Runtime.getRuntime()
+        .addShutdownHook(
+            new Thread() {
+              @Override
+              @SuppressWarnings("CatchAndPrintStackTrace")
+              public void run() {
+                try {
+                  System.out.println("Shutting down");
+                  server.stop();
+                } catch (Exception e) {
+                  e.printStackTrace();
+                }
+              }
+            });
+    server.start();
+    System.out.println("Server started on port " + server.port);
+    server.blockUntilShutdown();
+  }
+
+  void parseArgs(String[] args) {
+    boolean usage = false;
+    for (String arg : args) {
+      if (!arg.startsWith("--")) {
+        System.err.println("All arguments must start with '--': " + arg);
+        usage = true;
+        break;
+      }
+      String[] parts = arg.substring(2).split("=", 2);
+      String key = parts[0];
+      if ("help".equals(key)) {
+        usage = true;
+        break;
+      }
+      if (parts.length != 2) {
+        System.err.println("All arguments must be of the form --arg=value");
+        usage = true;
+        break;
+      }
+      String value = parts[1];
+      if ("port".equals(key)) {
+        port = Integer.valueOf(value);
+      } else if ("maintenance_port".equals(key)) {
+        maintenancePort = Integer.valueOf(value);
+      } else if ("secure_mode".equals(key)) {
+        secureMode = Boolean.parseBoolean(value);
+      } else if ("enable_csm_observability".equals(key)) {
+        enableCsmObservability = Boolean.valueOf(value);
+      } else if ("server_id".equals(key)) {
+        serverId = value;
+      } else if ("address_type".equals(key)) {
+        addressType = Util.AddressType.valueOf(value.toUpperCase(Locale.ROOT));
+      } else {
+        System.err.println("Unknown argument: " + key);
+        usage = true;
+        break;
+      }
+    }
+
+    if (secureMode && (port == maintenancePort)) {
+      System.err.println(
+          "port and maintenance_port should be different for secure mode: port="
+              + port
+              + ", maintenance_port="
+              + maintenancePort);
+      usage = true;
+    }
+
+    if (usage) {
+      XdsTestServer s = new XdsTestServer();
+      System.err.println(
+          "Usage: [ARGS...]"
+              + "\n"
+              + "\n  --port=INT          listening port for test server."
+              + "\n                      Default: "
+              + s.port
+              + "\n  --maintenance_port=INT      listening port for other servers."
+              + "\n                      Default: "
+              + s.maintenancePort
+              + "\n  --secure_mode=BOOLEAN Use true to enable XdsCredentials."
+              + " port and maintenance_port should be different for secure mode."
+              + "\n                      Default: "
+              + s.secureMode
+              + "\n  --enable_csm_observability=BOOL  Enable CSM observability reporting. Default: "
+              + s.enableCsmObservability
+              + "\n  --server_id=STRING  server ID for response."
+              + "\n                      Default: "
+              + s.serverId
+              + "\n  --address_type=STRING  type of IP address to bind to (IPV4|IPV6|IPV4_IPV6)."
+              + "\n                      Default: "
+              + s.addressType);
+      System.exit(1);
+    }
+  }
+
+  @SuppressWarnings("AddressSelection")
+  @IgnoreJRERequirement // OpenTelemetry uses Java 8+ APIs
+  void start() throws Exception {
+    if (enableCsmObservability) {
+      csmObservability = CsmObservability.newBuilder()
+          .sdk(AutoConfiguredOpenTelemetrySdk.builder()
+              .addPropertiesSupplier(() -> ImmutableMap.of(
+                  "otel.logs.exporter", "none",
+                  "otel.metrics.exporter", "prometheus",
+                  "otel.traces.exporter", "none"))
+              .build()
+              .getOpenTelemetrySdk())
+          .build();
+      csmObservability.registerGlobal();
+    }
+    try {
+      host = InetAddress.getLocalHost().getHostName();
+    } catch (UnknownHostException e) {
+      logger.log(Level.SEVERE, "Failed to get host", e);
+      throw new RuntimeException(e);
+    }
+    health = new HealthStatusManager();
+    @SuppressWarnings("deprecation")
+    BindableService oldReflectionService = ProtoReflectionService.newInstance();
+    if (secureMode) {
+      if (addressType != Util.AddressType.IPV4_IPV6) {
+        throw new IllegalArgumentException("Secure mode only supports IPV4_IPV6 address type");
+      }
+      maintenanceServer =
+          Grpc.newServerBuilderForPort(maintenancePort, InsecureServerCredentials.create())
+              .addService(new XdsUpdateHealthServiceImpl(health))
+              .addService(health.getHealthService())
+              .addService(oldReflectionService)
+              .addService(ProtoReflectionServiceV1.newInstance())
+              .addServices(AdminInterface.getStandardServices())
+              .build();
+      maintenanceServer.start();
+      server =
+          XdsServerBuilder.forPort(
+                  port, XdsServerCredentials.create(InsecureServerCredentials.create()))
+              .addService(
+                  ServerInterceptors.intercept(
+                      new TestServiceImpl(serverId, host), new TestInfoInterceptor(host)))
+              .build();
+      server.start();
+    } else {
+      ServerBuilder<?> serverBuilder;
+      ServerCredentials insecureServerCreds = InsecureServerCredentials.create();
+      switch (addressType) {
+        case IPV4_IPV6:
+          serverBuilder = Grpc.newServerBuilderForPort(port, insecureServerCreds);
+          break;
+        case IPV4:
+          SocketAddress v4Address = Util.getV4Address(port);
+          InetSocketAddress localV4Address = new InetSocketAddress("127.0.0.1", port);
+          serverBuilder = NettyServerBuilder.forAddress(
+                  localV4Address, insecureServerCreds);
+          if (v4Address != null && !v4Address.equals(localV4Address) ) {
+            ((NettyServerBuilder) serverBuilder).addListenAddress(v4Address);
+          }
+          break;
+        case IPV6:
+          List<SocketAddress> v6Addresses = Util.getV6Addresses(port);
+          InetSocketAddress localV6Address = new InetSocketAddress("::1", port);
+          serverBuilder = NettyServerBuilder.forAddress(localV6Address, insecureServerCreds);
+          for (SocketAddress address : v6Addresses) {
+            if (!address.equals(localV6Address)) {
+              ((NettyServerBuilder) serverBuilder).addListenAddress(address);
+            }
+          }
+          break;
+        default:
+          throw new AssertionError("Unknown address type: " + addressType);
+      }
+
+      logger.info("Starting server on port " + port + " with address type " + addressType);
+
+      server =
+          serverBuilder
+              .addService(
+                  ServerInterceptors.intercept(
+                      new TestServiceImpl(serverId, host), new TestInfoInterceptor(host)))
+              .addService(new XdsUpdateHealthServiceImpl(health))
+              .addService(health.getHealthService())
+              .addService(oldReflectionService)
+              .addService(ProtoReflectionServiceV1.newInstance())
+              .addServices(AdminInterface.getStandardServices())
+              .build();
+      server.start();
+      maintenanceServer = null;
+    }
+    health.setStatus("", ServingStatus.SERVING);
+  }
+
+  void stop() throws Exception {
+    server.shutdownNow();
+    if (maintenanceServer != null) {
+      maintenanceServer.shutdownNow();
+    }
+    if (!server.awaitTermination(5, TimeUnit.SECONDS)) {
+      System.err.println("Timed out waiting for server shutdown");
+    }
+    if (maintenanceServer != null && !maintenanceServer.awaitTermination(5, TimeUnit.SECONDS)) {
+      System.err.println("Timed out waiting for maintenanceServer shutdown");
+    }
+    if (csmObservability != null) {
+      csmObservability.close();
+    }
+  }
+
+  private void blockUntilShutdown() throws InterruptedException {
+    if (server != null) {
+      server.awaitTermination();
+    }
+    if (maintenanceServer != null) {
+      maintenanceServer.awaitTermination();
+    }
+  }
+
+  private static class TestServiceImpl extends TestServiceGrpc.TestServiceImplBase {
+    private final String serverId;
+    private final String host;
+
+    private TestServiceImpl(String serverId, String host) {
+      this.serverId = serverId;
+      this.host = host;
+    }
+
+    @Override
+    public void emptyCall(
+        EmptyProtos.Empty req, StreamObserver<EmptyProtos.Empty> responseObserver) {
+      responseObserver.onNext(EmptyProtos.Empty.getDefaultInstance());
+      responseObserver.onCompleted();
+    }
+
+    @Override
+    public void unaryCall(SimpleRequest req, StreamObserver<SimpleResponse> responseObserver) {
+      responseObserver.onNext(SimpleResponse.newBuilder()
+          .setServerId(serverId)
+          .setHostname(host)
+          .setPayload(Payload.newBuilder()
+            .setBody(ByteString.copyFrom(new byte[req.getResponseSize()]))
+            .build())
+          .build());
+      responseObserver.onCompleted();
+    }
+  }
+
+  private static class XdsUpdateHealthServiceImpl
+      extends XdsUpdateHealthServiceGrpc.XdsUpdateHealthServiceImplBase {
+    private HealthStatusManager health;
+
+    private XdsUpdateHealthServiceImpl(HealthStatusManager health) {
+      this.health = health;
+    }
+
+    @Override
+    public void setServing(
+        EmptyProtos.Empty req, StreamObserver<EmptyProtos.Empty> responseObserver) {
+      health.setStatus("", ServingStatus.SERVING);
+      responseObserver.onNext(EmptyProtos.Empty.getDefaultInstance());
+      responseObserver.onCompleted();
+    }
+
+    @Override
+    public void setNotServing(
+        EmptyProtos.Empty req, StreamObserver<EmptyProtos.Empty> responseObserver) {
+      health.setStatus("", ServingStatus.NOT_SERVING);
+      responseObserver.onNext(EmptyProtos.Empty.getDefaultInstance());
+      responseObserver.onCompleted();
+    }
+  }
+
+  private static class TestInfoInterceptor implements ServerInterceptor {
+    private final String host;
+
+    private TestInfoInterceptor(String host) {
+      this.host = host;
+    }
+
+    @Override
+    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+        ServerCall<ReqT, RespT> call,
+        final Metadata requestHeaders,
+        ServerCallHandler<ReqT, RespT> next) {
+      List<String> callBehaviors = getCallBehaviors(requestHeaders);
+      ServerCall<ReqT, RespT> newCall = new SimpleForwardingServerCall<ReqT, RespT>(call) {
+        @Override
+        public void sendHeaders(Metadata responseHeaders) {
+          responseHeaders.put(HOSTNAME_KEY, host);
+          super.sendHeaders(responseHeaders);
+        }
+      };
+      ServerCall.Listener<ReqT> noopListener = new ServerCall.Listener<ReqT>() {};
+
+      int attemptNum = 0;
+      String attemptNumHeader = requestHeaders.get(ATTEMPT_NUM);
+      if (attemptNumHeader != null) {
+        try {
+          attemptNum = Integer.valueOf(attemptNumHeader);
+        } catch (NumberFormatException e) {
+          newCall.close(
+              Status.INVALID_ARGUMENT.withDescription(
+                  "Invalid format for grpc-previous-rpc-attempts header: " + attemptNumHeader),
+              new Metadata());
+          return noopListener;
+        }
+      }
+
+      for (String callBehavior : callBehaviors) {
+        if (callBehavior.startsWith(CALL_BEHAVIOR_HOSTNAME)) {
+          List<String> splitHeader = HEADER_HOSTNAME_SPLITTER.splitToList(callBehavior);
+          if (splitHeader.size() > 1) {
+            if (!splitHeader.get(0).substring(CALL_BEHAVIOR_HOSTNAME.length()).equals(host)) {
+              continue;
+            }
+            callBehavior = splitHeader.get(1);
+          } else {
+            newCall.close(
+                Status.INVALID_ARGUMENT.withDescription(
+                    "Invalid format for rpc-behavior header: " + callBehavior),
+                new Metadata()
+            );
+            return noopListener;
+          }
+        }
+
+        if (callBehavior.startsWith(CALL_BEHAVIOR_SLEEP_VALUE)) {
+          try {
+            int timeout = Integer.parseInt(
+                callBehavior.substring(CALL_BEHAVIOR_SLEEP_VALUE.length()));
+            Thread.sleep(timeout * 1000L);
+          } catch (NumberFormatException e) {
+            newCall.close(
+                Status.INVALID_ARGUMENT.withDescription(
+                    "Invalid format for rpc-behavior header: " + callBehavior),
+                new Metadata());
+            return noopListener;
+          } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            newCall.close(
+                Status.ABORTED.withDescription("execution of server interrupted"),
+                new Metadata());
+            return noopListener;
+          }
+        }
+
+        if (callBehavior.startsWith(CALL_BEHAVIOR_SUCCEED_ON_RETRY_ATTEMPT_VALUE)) {
+          int succeedOnAttemptNum = Integer.MAX_VALUE;
+          try {
+            succeedOnAttemptNum = Integer.parseInt(
+                callBehavior.substring(CALL_BEHAVIOR_SUCCEED_ON_RETRY_ATTEMPT_VALUE.length()));
+          } catch (NumberFormatException e) {
+            newCall.close(
+                Status.INVALID_ARGUMENT.withDescription(
+                    "Invalid format for rpc-behavior header: " + callBehavior),
+                new Metadata());
+            return noopListener;
+          }
+          if (attemptNum == succeedOnAttemptNum) {
+            return next.startCall(newCall, requestHeaders);
+          }
+        }
+
+        // hang if instructed by rpc-behavior
+        if (callBehavior.equals(CALL_BEHAVIOR_KEEP_OPEN_VALUE)) {
+          return noopListener;
+        }
+
+        if (callBehavior.startsWith(CALL_BEHAVIOR_ERROR_CODE)) {
+          try {
+            int codeValue = Integer.valueOf(
+                callBehavior.substring(CALL_BEHAVIOR_ERROR_CODE.length()));
+            newCall.close(
+                Status.fromCodeValue(codeValue).withDescription(
+                    "Rpc failed as per the rpc-behavior header value:" + callBehaviors),
+                new Metadata());
+            return noopListener;
+          } catch (NumberFormatException e) {
+            newCall.close(
+                Status.INVALID_ARGUMENT.withDescription(
+                    "Invalid format for rpc-behavior header: " + callBehavior),
+                new Metadata());
+            return noopListener;
+          }
+        }
+      }
+
+      return next.startCall(newCall, requestHeaders);
+    }
+  }
+
+  private static List<String> getCallBehaviors(Metadata requestHeaders) {
+    List<String> callBehaviors = new ArrayList<>();
+    Iterable<String> values = requestHeaders.getAll(CALL_BEHAVIOR_MD_KEY);
+    if (values == null) {
+      return callBehaviors;
+    }
+    for (String value : values) {
+      Iterables.addAll(callBehaviors, HEADER_VALUE_SPLITTER.split(value));
+    }
+    return callBehaviors;
+  }
+}
diff --git a/interop-testing/src/main/proto/grpc/testing/empty.proto b/interop-testing/src/main/proto/grpc/testing/empty.proto
new file mode 100644
index 00000000000..43779012dc4
--- /dev/null
+++ b/interop-testing/src/main/proto/grpc/testing/empty.proto
@@ -0,0 +1,31 @@
+
+// Copyright 2015 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.
+
+syntax = "proto3";
+
+package grpc.testing;
+
+option java_package = "io.grpc.testing.integration";
+option java_outer_classname = "EmptyProtos";
+
+// An empty message that you can re-use to avoid defining duplicated empty
+// messages in your project. A typical example is to use it as argument or the
+// return value of a service API. For instance:
+//
+//   service Foo {
+//     rpc Bar (grpc.testing.Empty) returns (grpc.testing.Empty) { };
+//   };
+//
+message Empty {}
diff --git a/interop-testing/src/main/proto/grpc/testing/messages.proto b/interop-testing/src/main/proto/grpc/testing/messages.proto
new file mode 100644
index 00000000000..fbcb6b4ce9b
--- /dev/null
+++ b/interop-testing/src/main/proto/grpc/testing/messages.proto
@@ -0,0 +1,288 @@
+
+// Copyright 2015-2016 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.
+
+// Message definitions to be used by integration test service definitions.
+
+syntax = "proto3";
+
+package grpc.testing;
+
+option java_package = "io.grpc.testing.integration";
+
+// TODO(dgq): Go back to using well-known types once
+// https://github.com/grpc/grpc/issues/6980 has been fixed.
+// import "google/protobuf/wrappers.proto";
+message BoolValue {
+  // The bool value.
+  bool value = 1;
+}
+
+// The type of payload that should be returned.
+enum PayloadType {
+  // Compressable text format.
+  COMPRESSABLE = 0;
+}
+
+// A block of data, to simply increase gRPC message size.
+message Payload {
+  // The type of data in body.
+  PayloadType type = 1;
+  // Primary contents of payload.
+  bytes body = 2;
+}
+
+// A protobuf representation for grpc status. This is used by test
+// clients to specify a status that the server should attempt to return.
+message EchoStatus {
+  int32 code = 1;
+  string message = 2;
+}
+
+// The type of route that a client took to reach a server w.r.t. gRPCLB.
+// The server must fill in "fallback" if it detects that the RPC reached
+// the server via the "gRPCLB fallback" path, and "backend" if it detects
+// that the RPC reached the server via "gRPCLB backend" path (i.e. if it got
+// the address of this server from the gRPCLB server BalanceLoad RPC). Exactly
+// how this detection is done is context and server dependent.
+enum GrpclbRouteType {
+  // Server didn't detect the route that a client took to reach it.
+  GRPCLB_ROUTE_TYPE_UNKNOWN = 0;
+  // Indicates that a client reached a server via gRPCLB fallback.
+  GRPCLB_ROUTE_TYPE_FALLBACK = 1;
+  // Indicates that a client reached a server as a gRPCLB-given backend.
+  GRPCLB_ROUTE_TYPE_BACKEND = 2;
+}
+
+// Unary request.
+message SimpleRequest {
+  // Desired payload type in the response from the server.
+  // If response_type is RANDOM, server randomly chooses one from other formats.
+  PayloadType response_type = 1;
+
+  // Desired payload size in the response from the server.
+  int32 response_size = 2;
+
+  // Optional input payload sent along with the request.
+  Payload payload = 3;
+
+  // Whether SimpleResponse should include username.
+  bool fill_username = 4;
+
+  // Whether SimpleResponse should include OAuth scope.
+  bool fill_oauth_scope = 5;
+
+  // Whether to request the server to compress the response. This field is
+  // "nullable" in order to interoperate seamlessly with clients not able to
+  // implement the full compression tests by introspecting the call to verify
+  // the response's compression status.
+  BoolValue response_compressed = 6;
+
+  // Whether server should return a given status
+  EchoStatus response_status = 7;
+
+  // Whether the server should expect this request to be compressed.
+  BoolValue expect_compressed = 8;
+
+  // Whether SimpleResponse should include server_id.
+  bool fill_server_id = 9;
+
+  // Whether SimpleResponse should include grpclb_route_type.
+  bool fill_grpclb_route_type = 10;
+
+  // If set the server should record this metrics report data for the current RPC.
+  TestOrcaReport orca_per_query_report = 11;
+}
+
+// Unary response, as configured by the request.
+message SimpleResponse {
+  // Payload to increase message size.
+  Payload payload = 1;
+  // The user the request came from, for verifying authentication was
+  // successful when the client expected it.
+  string username = 2;
+  // OAuth scope.
+  string oauth_scope = 3;
+
+  // Server ID. This must be unique among different server instances,
+  // but the same across all RPC's made to a particular server instance.
+  string server_id = 4;
+  // gRPCLB Path.
+  GrpclbRouteType grpclb_route_type = 5;
+
+  // Server hostname.
+  string hostname = 6;
+}
+
+// Client-streaming request.
+message StreamingInputCallRequest {
+  // Optional input payload sent along with the request.
+  Payload payload = 1;
+
+  // Whether the server should expect this request to be compressed. This field
+  // is "nullable" in order to interoperate seamlessly with servers not able to
+  // implement the full compression tests by introspecting the call to verify
+  // the request's compression status.
+  BoolValue expect_compressed = 2;
+
+  // Not expecting any payload from the response.
+}
+
+// Client-streaming response.
+message StreamingInputCallResponse {
+  // Aggregated size of payloads received from the client.
+  int32 aggregated_payload_size = 1;
+}
+
+// Configuration for a particular response.
+message ResponseParameters {
+  // Desired payload sizes in responses from the server.
+  int32 size = 1;
+
+  // Desired interval between consecutive responses in the response stream in
+  // microseconds.
+  int32 interval_us = 2;
+
+  // Whether to request the server to compress the response. This field is
+  // "nullable" in order to interoperate seamlessly with clients not able to
+  // implement the full compression tests by introspecting the call to verify
+  // the response's compression status.
+  BoolValue compressed = 3;
+}
+
+// Server-streaming request.
+message StreamingOutputCallRequest {
+  // Desired payload type in the response from the server.
+  // If response_type is RANDOM, the payload from each response in the stream
+  // might be of different types. This is to simulate a mixed type of payload
+  // stream.
+  PayloadType response_type = 1;
+
+  // Configuration for each expected response message.
+  repeated ResponseParameters response_parameters = 2;
+
+  // Optional input payload sent along with the request.
+  Payload payload = 3;
+
+  // Whether server should return a given status
+  EchoStatus response_status = 7;
+
+  // If set the server should update this metrics report data at the OOB server.
+  TestOrcaReport orca_oob_report = 8;
+}
+
+// Server-streaming response, as configured by the request and parameters.
+message StreamingOutputCallResponse {
+  // Payload to increase response size.
+  Payload payload = 1;
+}
+
+// For reconnect interop test only.
+// Client tells server what reconnection parameters it used.
+message ReconnectParams {
+  int32 max_reconnect_backoff_ms = 1;
+}
+
+// For reconnect interop test only.
+// Server tells client whether its reconnects are following the spec and the
+// reconnect backoffs it saw.
+message ReconnectInfo {
+  bool passed = 1;
+  repeated int32 backoff_ms = 2;
+}
+
+message LoadBalancerStatsRequest {
+  // Request stats for the next num_rpcs sent by client.
+  int32 num_rpcs = 1;
+  // If num_rpcs have not completed within timeout_sec, return partial results.
+  int32 timeout_sec = 2;
+}
+
+message LoadBalancerStatsResponse {
+  message RpcsByPeer {
+    // The number of completed RPCs for each peer.
+    map<string, int32> rpcs_by_peer = 1;
+  }
+  // The number of completed RPCs for each peer.
+  map<string, int32> rpcs_by_peer = 1;
+  // The number of RPCs that failed to record a remote peer.
+  int32 num_failures = 2;
+  map<string, RpcsByPeer> rpcs_by_method = 3;
+}
+
+// Request for retrieving a test client's accumulated stats.
+message LoadBalancerAccumulatedStatsRequest {}
+
+// Accumulated stats for RPCs sent by a test client.
+message LoadBalancerAccumulatedStatsResponse {
+  // The total number of RPCs have ever issued for each type.
+  // Deprecated: use stats_per_method.rpcs_started instead.
+  map<string, int32> num_rpcs_started_by_method = 1 [deprecated = true];
+  // The total number of RPCs have ever completed successfully for each type.
+  // Deprecated: use stats_per_method.result instead.
+  map<string, int32> num_rpcs_succeeded_by_method = 2 [deprecated = true];
+  // The total number of RPCs have ever failed for each type.
+  // Deprecated: use stats_per_method.result instead.
+  map<string, int32> num_rpcs_failed_by_method = 3 [deprecated = true];
+
+  message MethodStats {
+    // The number of RPCs that were started for this method.
+    int32 rpcs_started = 1;
+
+    // The number of RPCs that completed with each status for this method.  The
+    // key is the integral value of a google.rpc.Code; the value is the count.
+    map<int32, int32> result = 2;
+  }
+
+  // Per-method RPC statistics.  The key is the RpcType in string form; e.g.
+  // 'EMPTY_CALL' or 'UNARY_CALL'
+  map<string, MethodStats> stats_per_method = 4;
+}
+
+// Configurations for a test client.
+message ClientConfigureRequest {
+  // Type of RPCs to send.
+  enum RpcType {
+    EMPTY_CALL = 0;
+    UNARY_CALL = 1;
+  }
+
+  // Metadata to be attached for the given type of RPCs.
+  message Metadata {
+    RpcType type = 1;
+    string key = 2;
+    string value = 3;
+  }
+
+  // The types of RPCs the client sends.
+  repeated RpcType types = 1;
+  // The collection of custom metadata to be attached to RPCs sent by the client.
+  repeated Metadata metadata = 2;
+  // The deadline to use, in seconds, for all RPCs.  If unset or zero, the
+  // client will use the default from the command-line.
+  int32 timeout_sec = 3;
+}
+
+// Response for updating a test client's configuration.
+message ClientConfigureResponse {}
+
+// Metrics data the server will update and send to the client. It mirrors orca load report
+// https://github.com/cncf/xds/blob/eded343319d09f30032952beda9840bbd3dcf7ac/xds/data/orca/v3/orca_load_report.proto#L15,
+// but avoids orca dependency. Used by both per-query and out-of-band reporting tests.
+message TestOrcaReport {
+  double cpu_utilization = 1;
+  double memory_utilization = 2;
+  map<string, double> request_cost = 3;
+  map<string, double> utilization = 4;
+}
diff --git a/interop-testing/src/main/proto/grpc/testing/metrics.proto b/interop-testing/src/main/proto/grpc/testing/metrics.proto
new file mode 100644
index 00000000000..d6b5b04bf1f
--- /dev/null
+++ b/interop-testing/src/main/proto/grpc/testing/metrics.proto
@@ -0,0 +1,50 @@
+// Copyright 2015-2016 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.
+// Contains the definitions for a metrics service and the type of metrics
+// exposed by the service.
+//
+// Currently, 'Gauge' (i.e a metric that represents the measured value of
+// something at an instant of time) is the only metric type supported by the
+// service.
+syntax = "proto3";
+
+package grpc.testing;
+
+option java_package = "io.grpc.testing.integration";
+
+// Reponse message containing the gauge name and value
+message GaugeResponse {
+  string name = 1;
+  oneof value {
+    int64 long_value = 2;
+    double double_value = 3;
+    string string_value = 4;
+  }
+}
+
+// Request message containing the gauge name
+message GaugeRequest {
+  string name = 1;
+}
+
+message EmptyMessage {}
+
+service MetricsService {
+  // Returns the values of all the gauges that are currently being maintained by
+  // the service
+  rpc GetAllGauges(EmptyMessage) returns (stream GaugeResponse);
+
+  // Returns the value of one gauge
+  rpc GetGauge(GaugeRequest) returns (GaugeResponse);
+}
diff --git a/interop-testing/src/main/proto/grpc/testing/test.proto b/interop-testing/src/main/proto/grpc/testing/test.proto
new file mode 100644
index 00000000000..efe83b88261
--- /dev/null
+++ b/interop-testing/src/main/proto/grpc/testing/test.proto
@@ -0,0 +1,104 @@
+
+// Copyright 2015-2016 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.
+
+// An integration test service that covers all the method signature permutations
+// of unary/streaming requests/responses.
+
+syntax = "proto3";
+
+import "grpc/testing/empty.proto";
+import "grpc/testing/messages.proto";
+
+package grpc.testing;
+
+option java_package = "io.grpc.testing.integration";
+
+// A simple service to test the various types of RPCs and experiment with
+// performance with various types of payload.
+service TestService {
+  // One empty request followed by one empty response.
+  rpc EmptyCall(grpc.testing.Empty) returns (grpc.testing.Empty);
+
+  // One request followed by one response.
+  rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
+
+  // One request followed by one response. Response has cache control
+  // headers set such that a caching HTTP proxy (such as GFE) can
+  // satisfy subsequent requests.
+  rpc CacheableUnaryCall(SimpleRequest) returns (SimpleResponse);
+
+  // One request followed by a sequence of responses (streamed download).
+  // The server returns the payload with client desired type and sizes.
+  rpc StreamingOutputCall(StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+
+  // A sequence of requests followed by one response (streamed upload).
+  // The server returns the aggregated size of client payload as the result.
+  rpc StreamingInputCall(stream StreamingInputCallRequest)
+      returns (StreamingInputCallResponse);
+
+  // A sequence of requests with each request served by the server immediately.
+  // As one request could lead to multiple responses, this interface
+  // demonstrates the idea of full duplexing.
+  rpc FullDuplexCall(stream StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+
+  // A sequence of requests followed by a sequence of responses.
+  // The server buffers all the client requests and then serves them in order. A
+  // stream of responses are returned to the client when the server starts with
+  // first request.
+  rpc HalfDuplexCall(stream StreamingOutputCallRequest)
+      returns (stream StreamingOutputCallResponse);
+
+  // The test server will not implement this method. It will be used
+  // to test the behavior when clients call unimplemented methods.
+  rpc UnimplementedCall(grpc.testing.Empty) returns (grpc.testing.Empty);
+}
+
+// A simple service NOT implemented at servers so clients can test for
+// that case.
+service UnimplementedService {
+  // A call that no server should implement
+  rpc UnimplementedCall(grpc.testing.Empty) returns (grpc.testing.Empty);
+}
+
+// A service used to control reconnect server.
+service ReconnectService {
+  rpc Start(grpc.testing.ReconnectParams) returns (grpc.testing.Empty);
+  rpc Stop(grpc.testing.Empty) returns (grpc.testing.ReconnectInfo);
+}
+
+// A service used to obtain stats for verifying LB behavior.
+service LoadBalancerStatsService {
+  // Gets the backend distribution for RPCs sent by a test client.
+  rpc GetClientStats(LoadBalancerStatsRequest)
+      returns (LoadBalancerStatsResponse) {}
+
+  // Gets the accumulated stats for RPCs sent by a test client.
+  rpc GetClientAccumulatedStats(LoadBalancerAccumulatedStatsRequest)
+      returns (LoadBalancerAccumulatedStatsResponse) {}
+}
+
+// A service to remotely control health status of an xDS test server.
+service XdsUpdateHealthService {
+  rpc SetServing(grpc.testing.Empty) returns (grpc.testing.Empty);
+  rpc SetNotServing(grpc.testing.Empty) returns (grpc.testing.Empty);
+}
+
+// A service to dynamically update the configuration of an xDS test client.
+service XdsUpdateClientConfigureService {
+  // Update the tes client's configuration.
+  rpc Configure(ClientConfigureRequest) returns (ClientConfigureResponse);
+}
diff --git a/interop-testing/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider b/interop-testing/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
new file mode 100644
index 00000000000..3a60a58e533
--- /dev/null
+++ b/interop-testing/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
@@ -0,0 +1 @@
+io.grpc.testing.integration.RpcBehaviorLoadBalancerProvider
diff --git a/interop-testing/src/test/java/io/grpc/ChannelAndServerBuilderTest.java b/interop-testing/src/test/java/io/grpc/ChannelAndServerBuilderTest.java
new file mode 100644
index 00000000000..36ca3d3fd0a
--- /dev/null
+++ b/interop-testing/src/test/java/io/grpc/ChannelAndServerBuilderTest.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2017 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;
+
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.reflect.ClassPath;
+import com.google.common.reflect.ClassPath.ClassInfo;
+import com.google.common.truth.Truth;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+/**
+ * Tests that Channel and Server builders properly hide the static constructors.
+ *
+ * <p>This test does nothing on Java 9.
+ */
+@RunWith(Parameterized.class)
+public class ChannelAndServerBuilderTest {
+
+  @Parameter
+  public Class<?> builderClass;
+
+  /**
+   * Returns the list of classes that have ServerBuilder or ManagedChannelBuilder in their class
+   * hierarchy and need to be checked for proper overrides of the static constructors.
+   */
+  @Parameters(name = "class={0}")
+  public static Collection<Object[]> params() throws Exception {
+    ClassLoader loader = ChannelAndServerBuilderTest.class.getClassLoader();
+    ImmutableSet<ClassInfo> classInfos =
+        ClassPath.from(loader).getTopLevelClassesRecursive("io.grpc");
+
+    // Java 9 doesn't expose the URLClassLoader, which breaks searching through the classpath
+    if (classInfos.isEmpty()) {
+      return new ArrayList<>();
+    }
+
+    // Exceptions from the check classes themselves, and ForwardingChannelBuilder.
+    // ForwardingChannelBuilder is deprecated and was stripped off of unnecessary methods,
+    // which it inherits from ForwardingChannelBuilder2.
+    ImmutableSet<Class<?>> ignoreClasses = ImmutableSet.of(
+        ServerBuilder.class,
+        ManagedChannelBuilder.class,
+        ForwardingChannelBuilder.class);
+
+    List<Object[]> classes = new ArrayList<>();
+    for (ClassInfo classInfo : classInfos) {
+      String className = classInfo.getName();
+      if (className.contains("io.grpc.netty.shaded.io.netty")) {
+        continue;
+      }
+      Class<?> clazz = Class.forName(className, false /*initialize*/, loader);
+      if (ignoreClasses.contains(clazz)) {
+        continue;
+      }
+      if (ServerBuilder.class.isAssignableFrom(clazz)
+          || ManagedChannelBuilder.class.isAssignableFrom(clazz)) {
+        classes.add(new Object[]{clazz});
+      }
+    }
+    Truth.assertWithMessage("Unable to find any builder classes").that(classes).isNotEmpty();
+    return classes;
+  }
+
+  @Test
+  public void serverBuilderHidesMethod_forPort() throws Exception {
+    Assume.assumeTrue(ServerBuilder.class.isAssignableFrom(builderClass));
+    Method method = builderClass.getMethod("forPort", int.class);
+
+    assertTrue(Modifier.isStatic(method.getModifiers()));
+    assertTrue(ServerBuilder.class.isAssignableFrom(method.getReturnType()));
+    assertSame(builderClass, method.getDeclaringClass());
+  }
+
+  @Test
+  public void channelBuilderHidesMethod_forAddress() throws Exception {
+    Assume.assumeTrue(ManagedChannelBuilder.class.isAssignableFrom(builderClass));
+    Method method = builderClass.getMethod("forAddress", String.class, int.class);
+
+    assertTrue(Modifier.isStatic(method.getModifiers()));
+    assertTrue(ManagedChannelBuilder.class.isAssignableFrom(method.getReturnType()));
+    assertSame(builderClass, method.getDeclaringClass());
+  }
+
+  @Test
+  public void channelBuilderHidesMethod_forTarget() throws Exception {
+    Assume.assumeTrue(ManagedChannelBuilder.class.isAssignableFrom(builderClass));
+    Method method = builderClass.getMethod("forTarget", String.class);
+
+    assertTrue(Modifier.isStatic(method.getModifiers()));
+    assertTrue(ManagedChannelBuilder.class.isAssignableFrom(method.getReturnType()));
+    assertSame(builderClass, method.getDeclaringClass());
+  }
+}
diff --git a/interop-testing/src/test/java/io/grpc/stub/StubConfigTest.java b/interop-testing/src/test/java/io/grpc/stub/StubConfigTest.java
index d5b23bbabe7..82e6f3e83a5 100644
--- a/interop-testing/src/test/java/io/grpc/stub/StubConfigTest.java
+++ b/interop-testing/src/test/java/io/grpc/stub/StubConfigTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
@@ -35,8 +20,8 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertNull;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -45,23 +30,26 @@
 import io.grpc.ClientCall;
 import io.grpc.Deadline;
 import io.grpc.MethodDescriptor;
-import io.grpc.testing.NoopClientCall;
+import io.grpc.NoopClientCall;
 import io.grpc.testing.integration.Messages.SimpleRequest;
 import io.grpc.testing.integration.Messages.SimpleResponse;
 import io.grpc.testing.integration.TestServiceGrpc;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /**
  * Tests for stub reconfiguration.
  */
 @RunWith(JUnit4.class)
 public class StubConfigTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
 
   @Mock
   private Channel channel;
@@ -73,11 +61,11 @@ public class StubConfigTest {
    * Sets up mocks.
    */
   @Before public void setUp() {
-    MockitoAnnotations.initMocks(this);
     ClientCall<SimpleRequest, SimpleResponse> call =
-        new NoopClientCall<SimpleRequest, SimpleResponse>();
+        new NoopClientCall<>();
     when(channel.newCall(
-        Mockito.<MethodDescriptor<SimpleRequest, SimpleResponse>>any(), any(CallOptions.class)))
+            ArgumentMatchers.<MethodDescriptor<SimpleRequest, SimpleResponse>>any(),
+            any(CallOptions.class)))
         .thenReturn(call);
   }
 
@@ -101,11 +89,11 @@ public void testStubCallOptionsPopulatedToNewCall() {
     CallOptions options1 = stub.getCallOptions();
     SimpleRequest request = SimpleRequest.getDefaultInstance();
     stub.unaryCall(request, responseObserver);
-    verify(channel).newCall(same(TestServiceGrpc.METHOD_UNARY_CALL), same(options1));
+    verify(channel).newCall(same(TestServiceGrpc.getUnaryCallMethod()), same(options1));
     stub = stub.withDeadlineAfter(2, NANOSECONDS);
     CallOptions options2 = stub.getCallOptions();
     assertNotSame(options1, options2);
     stub.unaryCall(request, responseObserver);
-    verify(channel).newCall(same(TestServiceGrpc.METHOD_UNARY_CALL), same(options2));
+    verify(channel).newCall(same(TestServiceGrpc.getUnaryCallMethod()), same(options2));
   }
 }
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/AltsHandshakerTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/AltsHandshakerTest.java
new file mode 100644
index 00000000000..c6c1d2b3e7e
--- /dev/null
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/AltsHandshakerTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2021 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.testing.integration;
+
+import static org.junit.Assert.assertEquals;
+
+import com.google.protobuf.ByteString;
+import io.grpc.ChannelCredentials;
+import io.grpc.Grpc;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.ServerCredentials;
+import io.grpc.alts.AltsChannelCredentials;
+import io.grpc.alts.AltsServerCredentials;
+import io.grpc.netty.NettyServerBuilder;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.integration.Messages.Payload;
+import io.grpc.testing.integration.Messages.SimpleRequest;
+import io.grpc.testing.integration.Messages.SimpleResponse;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.util.concurrent.DefaultThreadFactory;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class AltsHandshakerTest {
+  @Rule
+  public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+  private Server handshakerServer;
+  private Server testServer;
+  private ManagedChannel channel;
+
+  private void startAltsServer() throws Exception {
+    ServerCredentials serverCredentials = AltsServerCredentials.newBuilder()
+        .enableUntrustedAltsForTesting()
+        .setHandshakerAddressForTesting("localhost:" + handshakerServer.getPort())
+        .build();
+    testServer = grpcCleanup.register(
+        Grpc.newServerBuilderForPort(0, serverCredentials)
+            .addService(new TestServiceGrpc.TestServiceImplBase() {
+              @Override
+              public void unaryCall(SimpleRequest request, StreamObserver<SimpleResponse> so) {
+                so.onNext(SimpleResponse.getDefaultInstance());
+                so.onCompleted();
+              }
+            })
+            .build())
+        .start();
+  }
+
+  @Before
+  public void setup() throws Exception {
+    // create new EventLoopGroups to avoid deadlock at server side handshake negotiation, e.g.
+    // happens when handshakerServer and testServer child channels are on the same eventloop.
+    handshakerServer = grpcCleanup.register(NettyServerBuilder.forPort(0)
+        .bossEventLoopGroup(
+            new NioEventLoopGroup(0, new DefaultThreadFactory("test-alts-boss")))
+        .workerEventLoopGroup(
+            new NioEventLoopGroup(0, new DefaultThreadFactory("test-alts-worker")))
+        .channelType(NioServerSocketChannel.class)
+        .addService(new AltsHandshakerTestService())
+        .build()).start();
+    startAltsServer();
+
+    ChannelCredentials channelCredentials = AltsChannelCredentials.newBuilder()
+        .enableUntrustedAltsForTesting()
+        .setHandshakerAddressForTesting("localhost:" + handshakerServer.getPort()).build();
+    channel = grpcCleanup.register(
+        Grpc.newChannelBuilderForAddress("localhost", testServer.getPort(), channelCredentials)
+            .build());
+  }
+
+  @Test
+  public void testAlts() {
+    TestServiceGrpc.TestServiceBlockingStub blockingStub = TestServiceGrpc.newBlockingStub(channel);
+    final SimpleRequest request = SimpleRequest.newBuilder()
+            .setPayload(Payload.newBuilder().setBody(ByteString.copyFrom(new byte[10])))
+            .build();
+    assertEquals(SimpleResponse.getDefaultInstance(), blockingStub.unaryCall(request));
+  }
+}
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/AutoWindowSizingOnTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/AutoWindowSizingOnTest.java
index a490712a0fe..c240932767c 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/AutoWindowSizingOnTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/AutoWindowSizingOnTest.java
@@ -1,69 +1,51 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
-import io.grpc.ManagedChannel;
-import io.grpc.netty.HandlerSettings;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ServerBuilder;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.InternalNettyServerBuilder;
 import io.grpc.netty.NegotiationType;
 import io.grpc.netty.NettyChannelBuilder;
 import io.grpc.netty.NettyServerBuilder;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
 @RunWith(JUnit4.class)
 public class AutoWindowSizingOnTest extends AbstractInteropTest {
 
-  @BeforeClass
-  public static void turnOnAutoWindow() {
-    HandlerSettings.enable(true);
-    HandlerSettings.autoWindowOn(true);
-    startStaticServer(
-        NettyServerBuilder.forPort(0)
-            .maxMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE));
-  }
-
-  @AfterClass
-  public static void shutdown() {
-    stopStaticServer();
+  @Override
+  protected ServerBuilder<?> getServerBuilder() {
+    NettyServerBuilder builder = NettyServerBuilder.forPort(0, InsecureServerCredentials.create())
+        .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
+    // Disable the default census stats tracer, use testing tracer instead.
+    InternalNettyServerBuilder.setStatsEnabled(builder, false);
+    return builder.addStreamTracerFactory(createCustomCensusTracerFactory());
   }
 
   @Override
-  protected ManagedChannel createChannel() {
-    NettyChannelBuilder builder = NettyChannelBuilder.forAddress("localhost", getPort())
+  protected NettyChannelBuilder createChannelBuilder() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forAddress(getListenAddress())
         .negotiationType(NegotiationType.PLAINTEXT)
-        .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
-    io.grpc.internal.TestingAccessor.setStatsContextFactory(builder, getClientStatsFactory());
-    return builder.build();
+        .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
+        .initialFlowControlWindow(NettyChannelBuilder.DEFAULT_FLOW_CONTROL_WINDOW);
+    // Disable the default census stats interceptor, use testing interceptor instead.
+    InternalNettyChannelBuilder.setStatsEnabled(builder, false);
+    return builder.intercept(createCensusStatsClientInterceptor());
   }
 }
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/CascadingTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/CascadingTest.java
index b409371198d..63320ba8e97 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/CascadingTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/CascadingTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
@@ -44,6 +29,7 @@
 import io.grpc.Deadline;
 import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
+import io.grpc.Server;
 import io.grpc.ServerCall;
 import io.grpc.ServerCallHandler;
 import io.grpc.ServerInterceptor;
@@ -52,7 +38,6 @@
 import io.grpc.StatusRuntimeException;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
-import io.grpc.internal.ServerImpl;
 import io.grpc.stub.ServerCallStreamObserver;
 import io.grpc.stub.StreamObserver;
 import io.grpc.testing.integration.Messages.SimpleRequest;
@@ -67,22 +52,25 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /**
  * Integration test for various forms of cancellation and deadline propagation.
  */
 @RunWith(JUnit4.class)
 public class CascadingTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
 
   @Mock
   TestServiceGrpc.TestServiceImplBase service;
   private ManagedChannel channel;
-  private ServerImpl server;
+  private Server server;
   private CountDownLatch observedCancellations;
   private CountDownLatch receivedCancellations;
   private TestServiceGrpc.TestServiceBlockingStub blockingStub;
@@ -92,7 +80,6 @@ public class CascadingTest {
 
   @Before
   public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
     // Use a cached thread pool as we need a thread for each blocked call
     otherWork = Executors.newCachedThreadPool();
     channel = InProcessChannelBuilder.forName("channel").executor(otherWork).build();
@@ -310,7 +297,9 @@ public void onMessage(final ReqT message) {
                       Context.currentContextExecutor(otherWork).execute(new Runnable() {
                         @Override
                         public void run() {
-                          call.close(Status.ABORTED, new Metadata());
+                          synchronized (call) {
+                            call.close(Status.ABORTED, new Metadata());
+                          }
                         }
                       });
                     } else if (req.getResponseSize() != 0) {
@@ -331,7 +320,9 @@ public void onError(Throwable t) {
                                 }
                                 // Propagate closure upwards.
                                 try {
-                                  call.close(status, new Metadata());
+                                  synchronized (call) {
+                                    call.close(status, new Metadata());
+                                  }
                                 } catch (IllegalStateException t2) {
                                   // Ignore error if already closed.
                                 }
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/CompressionTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/CompressionTest.java
index d37e41cc792..5307c26949b 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/CompressionTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/CompressionTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
@@ -39,6 +24,8 @@
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
 import com.google.protobuf.ByteString;
 import io.grpc.CallOptions;
 import io.grpc.Channel;
@@ -50,8 +37,9 @@
 import io.grpc.DecompressorRegistry;
 import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
 import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
 import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.Server;
@@ -66,8 +54,7 @@
 import io.grpc.testing.integration.Messages.SimpleResponse;
 import io.grpc.testing.integration.TestServiceGrpc.TestServiceBlockingStub;
 import io.grpc.testing.integration.TransportCompressionTest.Fzip;
-import java.util.ArrayList;
-import java.util.Collection;
+import java.nio.charset.Charset;
 import java.util.List;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
@@ -159,25 +146,16 @@ public void tearDown() {
    * Parameters for test.
    */
   @Parameters
-  public static Collection<Object[]> params() {
-    boolean[] bools = new boolean[]{false, true};
-    List<Object[]> combos = new ArrayList<Object[]>(64);
-    for (boolean enableClientMessageCompression : bools) {
-      for (boolean clientAcceptEncoding : bools) {
-        for (boolean clientEncoding : bools) {
-          for (boolean enableServerMessageCompression : bools) {
-            for (boolean serverAcceptEncoding : bools) {
-              for (boolean serverEncoding : bools) {
-                combos.add(new Object[] {
-                    enableClientMessageCompression, clientAcceptEncoding, clientEncoding,
-                    enableServerMessageCompression, serverAcceptEncoding, serverEncoding});
-              }
-            }
-          }
-        }
-      }
-    }
-    return combos;
+  public static Iterable<Object[]> params() {
+    List<Boolean> bools = Lists.newArrayList(false, true);
+    return Iterables.transform(Lists.cartesianProduct(
+        bools, // enableClientMessageCompression
+        bools, // clientAcceptEncoding
+        bools, // clientEncoding
+        bools, // enableServerMessageCompression
+        bools, // serverAcceptEncoding
+        bools  // serverEncoding
+    ), List::toArray);
   }
 
   @Test
@@ -203,11 +181,11 @@ public void compression() throws Exception {
         .build()
         .start();
 
-    channel = ManagedChannelBuilder.forAddress("localhost", server.getPort())
+    channel = Grpc.newChannelBuilder(
+            "localhost:" + server.getPort(), InsecureChannelCredentials.create())
         .decompressorRegistry(clientDecompressors)
         .compressorRegistry(clientCompressors)
         .intercept(new ClientCompressorInterceptor())
-        .usePlaintext(true)
         .build();
     stub = TestServiceGrpc.newBlockingStub(channel);
 
@@ -231,13 +209,13 @@ public void compression() throws Exception {
     }
 
     if (serverAcceptEncoding) {
-      assertEquals("fzip", clientResponseHeaders.get(MESSAGE_ACCEPT_ENCODING_KEY));
+      assertEqualsString("fzip", clientResponseHeaders.get(MESSAGE_ACCEPT_ENCODING_KEY));
     } else {
       assertNull(clientResponseHeaders.get(MESSAGE_ACCEPT_ENCODING_KEY));
     }
 
     if (clientAcceptEncoding) {
-      assertEquals("fzip", serverResponseHeaders.get(MESSAGE_ACCEPT_ENCODING_KEY));
+      assertEqualsString("fzip", serverResponseHeaders.get(MESSAGE_ACCEPT_ENCODING_KEY));
     } else {
       assertNull(serverResponseHeaders.get(MESSAGE_ACCEPT_ENCODING_KEY));
     }
@@ -294,7 +272,7 @@ public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
       }
       ClientCall<ReqT, RespT> call = next.newCall(method, callOptions);
 
-      return new ClientCompressor<ReqT, RespT>(call);
+      return new ClientCompressor<>(call);
     }
   }
 
@@ -305,7 +283,7 @@ protected ClientCompressor(ClientCall<ReqT, RespT> delegate) {
 
     @Override
     public void start(io.grpc.ClientCall.Listener<RespT> responseListener, Metadata headers) {
-      super.start(new ClientHeadersCapture<RespT>(responseListener), headers);
+      super.start(new ClientHeadersCapture<>(responseListener), headers);
       setMessageCompression(enableClientMessageCompression);
     }
   }
@@ -323,4 +301,8 @@ public void onHeaders(Metadata headers) {
       clientResponseHeaders = headersCopy;
     }
   }
+
+  private static void assertEqualsString(String expected, byte[] actual) {
+    assertEquals(expected, new String(actual, Charset.forName("US-ASCII")));
+  }
 }
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/ConcurrencyTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/ConcurrencyTest.java
index 321a34b463f..8e4d7545e1a 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/ConcurrencyTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/ConcurrencyTest.java
@@ -1,57 +1,41 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
-import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.ChannelCredentials;
+import io.grpc.Grpc;
 import io.grpc.ManagedChannel;
 import io.grpc.Server;
-import io.grpc.netty.GrpcSslContexts;
-import io.grpc.netty.NegotiationType;
-import io.grpc.netty.NettyChannelBuilder;
-import io.grpc.netty.NettyServerBuilder;
+import io.grpc.ServerCredentials;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.TlsServerCredentials;
+import io.grpc.internal.testing.TestUtils;
 import io.grpc.stub.StreamObserver;
-import io.grpc.testing.TestUtils;
-import io.grpc.testing.integration.Messages.PayloadType;
+import io.grpc.testing.TlsTesting;
 import io.grpc.testing.integration.Messages.ResponseParameters;
 import io.grpc.testing.integration.Messages.StreamingOutputCallRequest;
 import io.grpc.testing.integration.Messages.StreamingOutputCallResponse;
-import io.netty.handler.ssl.ClientAuth;
-import io.netty.handler.ssl.SslContext;
-import java.io.File;
 import java.io.IOException;
-import java.security.cert.CertificateException;
-import java.security.cert.X509Certificate;
-import java.util.concurrent.CountDownLatch;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.CyclicBarrier;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -74,26 +58,30 @@
 // bidirectional streaming requests also.
 @RunWith(JUnit4.class)
 public class ConcurrencyTest {
+
   /**
-   * A response observer that signals a {@code CountDownLatch} when the proper number of responses
-   * arrives and the server signals that the RPC is complete.
+   * A response observer that completes a {@code ListenableFuture} when the proper number of
+   * responses arrives and the server signals that the RPC is complete.
    */
   private static class SignalingResponseObserver
       implements StreamObserver<StreamingOutputCallResponse> {
-    public SignalingResponseObserver(CountDownLatch responsesDoneSignal) {
-      this.responsesDoneSignal = responsesDoneSignal;
+    public SignalingResponseObserver(SettableFuture<Void> completionFuture) {
+      this.completionFuture = completionFuture;
     }
 
     @Override
     public void onCompleted() {
-      Preconditions.checkState(numResponsesReceived == NUM_RESPONSES_PER_REQUEST);
-      responsesDoneSignal.countDown();
+      if (numResponsesReceived != NUM_RESPONSES_PER_REQUEST) {
+        completionFuture.setException(
+            new IllegalStateException("Wrong number of responses: " + numResponsesReceived));
+      } else {
+        completionFuture.set(null);
+      }
     }
 
     @Override
     public void onError(Throwable error) {
-      // This should never happen. If it does happen, ensure that the error is visible.
-      error.printStackTrace();
+      completionFuture.setException(error);
     }
 
     @Override
@@ -101,27 +89,26 @@ public void onNext(StreamingOutputCallResponse response) {
       numResponsesReceived++;
     }
 
-    private final CountDownLatch responsesDoneSignal;
+    private final SettableFuture<Void> completionFuture;
     private int numResponsesReceived = 0;
   }
 
   /**
    * A client worker task that waits until all client workers are ready, then sends a request for a
-   * server-streaming RPC and arranges for a {@code CountDownLatch} to be signaled when the RPC is
+   * server-streaming RPC and arranges for a {@code ListenableFuture} to be signaled when the RPC is
    * complete.
    */
   private class ClientWorker implements Runnable {
-    public ClientWorker(CyclicBarrier startBarrier, CountDownLatch responsesDoneSignal) {
+    public ClientWorker(CyclicBarrier startBarrier, SettableFuture<Void> completionFuture) {
       this.startBarrier = startBarrier;
-      this.responsesDoneSignal = responsesDoneSignal;
+      this.completionFuture = completionFuture;
     }
 
     @Override
     public void run() {
       try {
         // Prepare the request.
-        StreamingOutputCallRequest.Builder requestBuilder = StreamingOutputCallRequest.newBuilder()
-            .setResponseType(PayloadType.RANDOM);
+        StreamingOutputCallRequest.Builder requestBuilder = StreamingOutputCallRequest.newBuilder();
         for (int i = 0; i < NUM_RESPONSES_PER_REQUEST; i++) {
           requestBuilder.addResponseParameters(ResponseParameters.newBuilder()
               .setSize(1000)
@@ -132,14 +119,17 @@ public void run() {
         // Wait until all client worker threads are poised & ready, then send the request. This way
         // all clients send their requests at approximately the same time.
         startBarrier.await();
-        clientStub.streamingOutputCall(request, new SignalingResponseObserver(responsesDoneSignal));
-      } catch (Exception e) {
-        throw e instanceof RuntimeException ? (RuntimeException) e : new RuntimeException(e);
+        clientStub.streamingOutputCall(request, new SignalingResponseObserver(completionFuture));
+      } catch (InterruptedException ex) {
+        Thread.currentThread().interrupt();
+        completionFuture.setException(ex);
+      } catch (Throwable t) {
+        completionFuture.setException(t);
       }
     }
 
     private final CyclicBarrier startBarrier;
-    private final CountDownLatch responsesDoneSignal;
+    private final SettableFuture<Void> completionFuture;
   }
 
   private static final int NUM_SERVER_THREADS = 10;
@@ -180,59 +170,44 @@ public void tearDown() {
   /**
    * Tests that gRPC can handle concurrent server-streaming RPCs.
    */
-  @Test(timeout = 10000)
+  @Test
   public void serverStreamingTest() throws Exception {
     CyclicBarrier startBarrier = new CyclicBarrier(NUM_CONCURRENT_REQUESTS);
-    CountDownLatch responsesDoneSignal = new CountDownLatch(NUM_CONCURRENT_REQUESTS);
+    List<ListenableFuture<Void>> workerFutures = new ArrayList<>(NUM_CONCURRENT_REQUESTS);
 
     for (int i = 0; i < NUM_CONCURRENT_REQUESTS; i++) {
-      clientExecutor.execute(new ClientWorker(startBarrier, responsesDoneSignal));
+      SettableFuture<Void> future = SettableFuture.create();
+      clientExecutor.execute(new ClientWorker(startBarrier, future));
+      workerFutures.add(future);
     }
 
-    // Wait until the clients all receive their complete RPC response streams.
-    responsesDoneSignal.await();
+    Futures.allAsList(workerFutures).get(60, TimeUnit.SECONDS);
   }
 
   /**
    * Creates and starts a new {@link TestServiceImpl} server.
    */
-  private Server newServer() throws CertificateException, IOException {
-    File serverCertChainFile = TestUtils.loadCert("server1.pem");
-    File serverPrivateKeyFile = TestUtils.loadCert("server1.key");
-    X509Certificate[] serverTrustedCaCerts = {
-      TestUtils.loadX509Cert("ca.pem")
-    };
-
-    SslContext sslContext =
-        GrpcSslContexts.forServer(serverCertChainFile, serverPrivateKeyFile)
-                       .trustManager(serverTrustedCaCerts)
-                       .clientAuth(ClientAuth.REQUIRE)
-                       .build();
-
-    return NettyServerBuilder.forPort(0)
-        .sslContext(sslContext)
+  private Server newServer() throws IOException {
+    ServerCredentials serverCreds = TlsServerCredentials.newBuilder()
+        .keyManager(TlsTesting.loadCert("server1.pem"), TlsTesting.loadCert("server1.key"))
+        .trustManager(TlsTesting.loadCert("ca.pem"))
+        .clientAuth(TlsServerCredentials.ClientAuth.REQUIRE)
+        .build();
+
+    return Grpc.newServerBuilderForPort(0, serverCreds)
         .addService(new TestServiceImpl(serverExecutor))
         .build()
         .start();
   }
 
-  private ManagedChannel newClientChannel() throws CertificateException, IOException {
-    File clientCertChainFile = TestUtils.loadCert("client.pem");
-    File clientPrivateKeyFile = TestUtils.loadCert("client.key");
-    X509Certificate[] clientTrustedCaCerts = {
-      TestUtils.loadX509Cert("ca.pem")
-    };
-
-    SslContext sslContext =
-        GrpcSslContexts.forClient()
-                       .keyManager(clientCertChainFile, clientPrivateKeyFile)
-                       .trustManager(clientTrustedCaCerts)
-                       .build();
+  private ManagedChannel newClientChannel() throws IOException {
+    ChannelCredentials channelCreds = TlsChannelCredentials.newBuilder()
+        .keyManager(TlsTesting.loadCert("client.pem"), TlsTesting.loadCert("client.key"))
+        .trustManager(TlsTesting.loadCert("ca.pem"))
+        .build();
 
-    return NettyChannelBuilder.forAddress("localhost", server.getPort())
+    return Grpc.newChannelBuilder("localhost:" + server.getPort(), channelCreds)
         .overrideAuthority(TestUtils.TEST_SERVER_HOST)
-        .negotiationType(NegotiationType.TLS)
-        .sslContext(sslContext)
         .build();
   }
 }
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/Http2NettyLocalChannelTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/Http2NettyLocalChannelTest.java
index 05d3c8f20f6..6659af68ae0 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/Http2NettyLocalChannelTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/Http2NettyLocalChannelTest.java
@@ -1,45 +1,32 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
-import io.grpc.ManagedChannel;
+import io.grpc.ServerBuilder;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.InternalNettyServerBuilder;
 import io.grpc.netty.NegotiationType;
 import io.grpc.netty.NettyChannelBuilder;
 import io.grpc.netty.NettyServerBuilder;
+import io.netty.channel.DefaultEventLoopGroup;
 import io.netty.channel.local.LocalAddress;
 import io.netty.channel.local.LocalChannel;
 import io.netty.channel.local.LocalServerChannel;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
+import org.junit.After;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
@@ -49,32 +36,41 @@
 @RunWith(JUnit4.class)
 public class Http2NettyLocalChannelTest extends AbstractInteropTest {
 
-  /** Start server. */
-  @BeforeClass
-  public static void startServer() {
-    startStaticServer(
-        NettyServerBuilder
-            .forAddress(new LocalAddress("in-process-1"))
-            .flowControlWindow(65 * 1024)
-            .maxMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
-            .channelType(LocalServerChannel.class));
-  }
+  private DefaultEventLoopGroup eventLoopGroup = new DefaultEventLoopGroup();
 
-  /** Stop server. */
-  @AfterClass
-  public static void stopServer() {
-    stopStaticServer();
+  @Override
+  protected ServerBuilder<?> getServerBuilder() {
+    NettyServerBuilder builder = NettyServerBuilder
+        .forAddress(new LocalAddress("in-process-1"))
+        .flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW)
+        .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
+        .channelType(LocalServerChannel.class)
+        .workerEventLoopGroup(eventLoopGroup)
+        .bossEventLoopGroup(eventLoopGroup);
+    // Disable the default census stats tracer, use testing tracer instead.
+    InternalNettyServerBuilder.setStatsEnabled(builder, false);
+    return builder.addStreamTracerFactory(createCustomCensusTracerFactory());
   }
 
   @Override
-  protected ManagedChannel createChannel() {
+  protected NettyChannelBuilder createChannelBuilder() {
     NettyChannelBuilder builder = NettyChannelBuilder
         .forAddress(new LocalAddress("in-process-1"))
         .negotiationType(NegotiationType.PLAINTEXT)
-        .channelType(LocalChannel.class)
-        .flowControlWindow(65 * 1024)
+        .channelType(LocalChannel.class, LocalAddress.class)
+        .eventLoopGroup(eventLoopGroup)
+        .flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW)
         .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
-    io.grpc.internal.TestingAccessor.setStatsContextFactory(builder, getClientStatsFactory());
-    return builder.build();
+    // Disable the default census stats interceptor, use testing interceptor instead.
+    InternalNettyChannelBuilder.setStatsEnabled(builder, false);
+    return builder.intercept(createCensusStatsClientInterceptor());
+  }
+
+  @Override
+  @After
+  @SuppressWarnings("FutureReturnValueIgnored")
+  public void tearDown() {
+    super.tearDown();
+    eventLoopGroup.shutdownGracefully();
   }
 }
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/Http2NettyTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/Http2NettyTest.java
index 846c584b087..4c8e5b22cc7 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/Http2NettyTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/Http2NettyTest.java
@@ -1,47 +1,34 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
-import io.grpc.ManagedChannel;
-import io.grpc.netty.GrpcSslContexts;
+import io.grpc.ChannelCredentials;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCredentials;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.TlsServerCredentials;
+import io.grpc.internal.testing.TestUtils;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.InternalNettyServerBuilder;
 import io.grpc.netty.NettyChannelBuilder;
 import io.grpc.netty.NettyServerBuilder;
-import io.grpc.testing.TestUtils;
-import io.netty.handler.ssl.ClientAuth;
-import io.netty.handler.ssl.SslProvider;
-import io.netty.handler.ssl.SupportedCipherSuiteFilter;
+import io.grpc.testing.TlsTesting;
 import java.io.IOException;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
+import java.net.InetSocketAddress;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -52,57 +39,47 @@
 @RunWith(JUnit4.class)
 public class Http2NettyTest extends AbstractInteropTest {
 
-  /** Starts the server with HTTPS. */
-  @BeforeClass
-  public static void startServer() {
+  @Override
+  protected ServerBuilder<?> getServerBuilder() {
+    // Starts the server with HTTPS.
     try {
-      startStaticServer(NettyServerBuilder.forPort(0)
-          .flowControlWindow(65 * 1024)
-          .maxMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
-          .sslContext(GrpcSslContexts
-              .forServer(TestUtils.loadCert("server1.pem"), TestUtils.loadCert("server1.key"))
-              .clientAuth(ClientAuth.REQUIRE)
-              .trustManager(TestUtils.loadCert("ca.pem"))
-              .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE)
-              .sslProvider(SslProvider.OPENSSL)
-              .build()));
+      ServerCredentials serverCreds = TlsServerCredentials.newBuilder()
+          .keyManager(TlsTesting.loadCert("server1.pem"), TlsTesting.loadCert("server1.key"))
+          .trustManager(TlsTesting.loadCert("ca.pem"))
+          .clientAuth(TlsServerCredentials.ClientAuth.REQUIRE)
+          .build();
+      NettyServerBuilder builder = NettyServerBuilder.forPort(0, serverCreds)
+          .flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW)
+          .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
+      // Disable the default census stats tracer, use testing tracer instead.
+      InternalNettyServerBuilder.setStatsEnabled(builder, false);
+      return builder.addStreamTracerFactory(createCustomCensusTracerFactory());
     } catch (IOException ex) {
       throw new RuntimeException(ex);
     }
   }
 
-  @AfterClass
-  public static void stopServer() {
-    stopStaticServer();
-  }
-
   @Override
-  protected ManagedChannel createChannel() {
+  protected NettyChannelBuilder createChannelBuilder() {
     try {
+      ChannelCredentials channelCreds = TlsChannelCredentials.newBuilder()
+          .keyManager(TlsTesting.loadCert("client.pem"), TlsTesting.loadCert("client.key"))
+          .trustManager(TlsTesting.loadCert("ca.pem"))
+          .build();
       NettyChannelBuilder builder = NettyChannelBuilder
-          .forAddress(TestUtils.testServerAddress(getPort()))
-          .flowControlWindow(65 * 1024)
-          .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
-          .sslContext(GrpcSslContexts
-              .forClient()
-              .keyManager(TestUtils.loadCert("client.pem"), TestUtils.loadCert("client.key"))
-              .trustManager(TestUtils.loadX509Cert("ca.pem"))
-              .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE)
-              .sslProvider(SslProvider.OPENSSL)
-              .build());
-      io.grpc.internal.TestingAccessor.setStatsContextFactory(builder, getClientStatsFactory());
-      return builder.build();
+          .forAddress("localhost", ((InetSocketAddress) getListenAddress()).getPort(), channelCreds)
+          .overrideAuthority(TestUtils.TEST_SERVER_HOST)
+          .flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW)
+          .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
+      // Disable the default census stats interceptor, use testing interceptor instead.
+      InternalNettyChannelBuilder.setStatsEnabled(builder, false);
+      return builder.intercept(createCensusStatsClientInterceptor());
     } catch (Exception ex) {
       throw new RuntimeException(ex);
     }
   }
 
-  @Test(timeout = 10000)
-  public void remoteAddr() {
-    assertRemoteAddr("/127.0.0.1");
-  }
-
-  @Test(timeout = 10000)
+  @Test
   public void tlsInfo() {
     assertX500SubjectDn("CN=testclient, O=Internet Widgits Pty Ltd, ST=Some-State, C=AU");
   }
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/Http2OkHttpTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/Http2OkHttpTest.java
deleted file mode 100644
index 28d4ed1d047..00000000000
--- a/interop-testing/src/test/java/io/grpc/testing/integration/Http2OkHttpTest.java
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.testing.integration;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-import com.google.common.base.Throwables;
-import com.google.protobuf.EmptyProtos.Empty;
-import com.squareup.okhttp.ConnectionSpec;
-import com.squareup.okhttp.TlsVersion;
-import io.grpc.ManagedChannel;
-import io.grpc.internal.GrpcUtil;
-import io.grpc.netty.GrpcSslContexts;
-import io.grpc.netty.NettyServerBuilder;
-import io.grpc.okhttp.OkHttpChannelBuilder;
-import io.grpc.okhttp.internal.Platform;
-import io.grpc.stub.StreamObserver;
-import io.grpc.testing.StreamRecorder;
-import io.grpc.testing.TestUtils;
-import io.netty.handler.ssl.OpenSsl;
-import io.netty.handler.ssl.SslContext;
-import io.netty.handler.ssl.SslContextBuilder;
-import io.netty.handler.ssl.SslProvider;
-import io.netty.handler.ssl.SupportedCipherSuiteFilter;
-import java.io.IOException;
-import javax.net.ssl.SSLPeerUnverifiedException;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Integration tests for GRPC over Http2 using the OkHttp framework.
- */
-@RunWith(JUnit4.class)
-public class Http2OkHttpTest extends AbstractInteropTest {
-
-  /** Starts the server with HTTPS. */
-  @BeforeClass
-  public static void startServer() throws Exception {
-    try {
-      SslProvider sslProvider = SslContext.defaultServerProvider();
-      if (sslProvider == SslProvider.OPENSSL && !OpenSsl.isAlpnSupported()) {
-        // OkHttp only supports Jetty ALPN on OpenJDK. So if OpenSSL doesn't support ALPN, then we
-        // are forced to use Jetty ALPN for Netty instead of OpenSSL.
-        sslProvider = SslProvider.JDK;
-      }
-      SslContextBuilder contextBuilder = SslContextBuilder
-          .forServer(TestUtils.loadCert("server1.pem"), TestUtils.loadCert("server1.key"));
-      GrpcSslContexts.configure(contextBuilder, sslProvider);
-      contextBuilder.ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE);
-      startStaticServer(NettyServerBuilder.forPort(0)
-          .flowControlWindow(65 * 1024)
-          .maxMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
-          .sslContext(contextBuilder.build()));
-    } catch (IOException ex) {
-      throw new RuntimeException(ex);
-    }
-  }
-
-  @AfterClass
-  public static void stopServer() throws Exception {
-    stopStaticServer();
-  }
-
-  @Override
-  protected ManagedChannel createChannel() {
-    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("127.0.0.1", getPort())
-        .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
-        .connectionSpec(new ConnectionSpec.Builder(OkHttpChannelBuilder.DEFAULT_CONNECTION_SPEC)
-            .cipherSuites(TestUtils.preferredTestCiphers().toArray(new String[0]))
-            .tlsVersions(ConnectionSpec.MODERN_TLS.tlsVersions().toArray(new TlsVersion[0]))
-            .build())
-        .overrideAuthority(GrpcUtil.authorityFromHostAndPort(
-            TestUtils.TEST_SERVER_HOST, getPort()));
-    io.grpc.internal.TestingAccessor.setStatsContextFactory(builder, getClientStatsFactory());
-    try {
-      builder.sslSocketFactory(TestUtils.newSslSocketFactoryForCa(Platform.get().getProvider(),
-              TestUtils.loadCert("ca.pem")));
-    } catch (Exception e) {
-      throw new RuntimeException(e);
-    }
-    return builder.build();
-  }
-
-  @Test(timeout = 10000)
-  public void receivedDataForFinishedStream() throws Exception {
-    Messages.ResponseParameters.Builder responseParameters =
-        Messages.ResponseParameters.newBuilder()
-        .setSize(1);
-    Messages.StreamingOutputCallRequest.Builder requestBuilder =
-        Messages.StreamingOutputCallRequest.newBuilder()
-            .setResponseType(Messages.PayloadType.COMPRESSABLE);
-    for (int i = 0; i < 1000; i++) {
-      requestBuilder.addResponseParameters(responseParameters);
-    }
-
-    StreamRecorder<Messages.StreamingOutputCallResponse> recorder = StreamRecorder.create();
-    StreamObserver<Messages.StreamingOutputCallRequest> requestStream =
-        asyncStub.fullDuplexCall(recorder);
-    Messages.StreamingOutputCallRequest request = requestBuilder.build();
-    requestStream.onNext(request);
-    recorder.firstValue().get();
-    requestStream.onError(new Exception("failed"));
-
-    recorder.awaitCompletion();
-
-    assertEquals(EMPTY, blockingStub.emptyCall(EMPTY));
-  }
-
-  @Test(timeout = 10000)
-  public void wrongHostNameFailHostnameVerification() throws Exception {
-    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("127.0.0.1", getPort())
-        .connectionSpec(new ConnectionSpec.Builder(OkHttpChannelBuilder.DEFAULT_CONNECTION_SPEC)
-            .cipherSuites(TestUtils.preferredTestCiphers().toArray(new String[0]))
-            .tlsVersions(ConnectionSpec.MODERN_TLS.tlsVersions().toArray(new TlsVersion[0]))
-            .build())
-        .overrideAuthority(GrpcUtil.authorityFromHostAndPort(
-            "I.am.a.bad.hostname", getPort()));
-    ManagedChannel channel = builder.sslSocketFactory(
-        TestUtils.newSslSocketFactoryForCa(Platform.get().getProvider(),
-            TestUtils.loadCert("ca.pem"))).build();
-    TestServiceGrpc.TestServiceBlockingStub blockingStub =
-        TestServiceGrpc.newBlockingStub(channel);
-
-    try {
-      blockingStub.emptyCall(Empty.getDefaultInstance());
-      fail("The rpc should have been failed due to hostname verification");
-    } catch (Throwable t) {
-      Throwable cause = Throwables.getRootCause(t);
-      assertTrue("Failed by unexpected exception: " + cause,
-          cause instanceof SSLPeerUnverifiedException);
-    }
-    channel.shutdown();
-  }
-}
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/Http2Test.java b/interop-testing/src/test/java/io/grpc/testing/integration/Http2Test.java
new file mode 100644
index 00000000000..4c0d47be567
--- /dev/null
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/Http2Test.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright 2022 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.testing.integration;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Metadata;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCredentials;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.TlsServerCredentials;
+import io.grpc.internal.testing.TestUtils;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.InternalNettyServerBuilder;
+import io.grpc.netty.NettyChannelBuilder;
+import io.grpc.netty.NettyServerBuilder;
+import io.grpc.okhttp.InternalOkHttpChannelBuilder;
+import io.grpc.okhttp.InternalOkHttpServerBuilder;
+import io.grpc.okhttp.OkHttpChannelBuilder;
+import io.grpc.okhttp.OkHttpServerBuilder;
+import io.grpc.stub.MetadataUtils;
+import io.grpc.testing.TlsTesting;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.util.Arrays;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+/**
+ * Integration tests for GRPC over the various HTTP2 transports.
+ */
+@RunWith(Parameterized.class)
+public class Http2Test extends AbstractInteropTest {
+  enum Transport {
+    NETTY, OKHTTP;
+  }
+
+  /** Parameterized test cases. */
+  @Parameters(name = "client={0},server={1}")
+  public static Iterable<Object[]> data() {
+    return Arrays.asList(new Object[][] {
+      {Transport.NETTY, Transport.NETTY},
+      {Transport.OKHTTP, Transport.OKHTTP},
+      {Transport.OKHTTP, Transport.NETTY},
+      {Transport.NETTY, Transport.OKHTTP},
+    });
+  }
+
+  private final Transport clientType;
+  private final Transport serverType;
+
+  public Http2Test(Transport clientType, Transport serverType) {
+    this.clientType = clientType;
+    this.serverType = serverType;
+  }
+
+  @Override
+  protected ServerBuilder<?> getServerBuilder() {
+    // Starts the server with HTTPS.
+    ServerCredentials serverCreds;
+    try {
+      serverCreds = TlsServerCredentials.create(
+          TlsTesting.loadCert("server1.pem"), TlsTesting.loadCert("server1.key"));
+    } catch (IOException ex) {
+      throw new RuntimeException(ex);
+    }
+    ServerBuilder<?> builder;
+    if (serverType == Transport.NETTY) {
+      NettyServerBuilder nettyBuilder = NettyServerBuilder.forPort(0, serverCreds)
+          .flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW);
+      // Disable the default census stats tracer, use testing tracer instead.
+      InternalNettyServerBuilder.setStatsEnabled(nettyBuilder, false);
+      builder = nettyBuilder;
+    } else {
+      OkHttpServerBuilder okHttpBuilder = OkHttpServerBuilder.forPort(0, serverCreds)
+          .flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW);
+      // Disable the default census stats tracer, use testing tracer instead.
+      InternalOkHttpServerBuilder.setStatsEnabled(okHttpBuilder, false);
+      builder = okHttpBuilder;
+    }
+    return builder
+        .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
+        .addStreamTracerFactory(createCustomCensusTracerFactory());
+  }
+
+  @Override
+  protected ManagedChannelBuilder<?> createChannelBuilder() {
+    ChannelCredentials channelCreds;
+    try {
+      channelCreds = TlsChannelCredentials.newBuilder()
+          .trustManager(TlsTesting.loadCert("ca.pem"))
+          .build();
+    } catch (Exception ex) {
+      throw new RuntimeException(ex);
+    }
+    int port = ((InetSocketAddress) getListenAddress()).getPort();
+    ManagedChannelBuilder<?> builder;
+    if (clientType == Transport.NETTY) {
+      NettyChannelBuilder nettyBuilder = NettyChannelBuilder
+          .forAddress("localhost", port, channelCreds)
+          .flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW);
+      // Disable the default census stats interceptor, use testing interceptor instead.
+      InternalNettyChannelBuilder.setStatsEnabled(nettyBuilder, false);
+      builder = nettyBuilder;
+    } else {
+      OkHttpChannelBuilder okHttpBuilder = OkHttpChannelBuilder
+          .forAddress("localhost", port, channelCreds)
+          .flowControlWindow(AbstractInteropTest.TEST_FLOW_CONTROL_WINDOW);
+      // Disable the default census stats interceptor, use testing interceptor instead.
+      InternalOkHttpChannelBuilder.setStatsEnabled(okHttpBuilder, false);
+      builder = okHttpBuilder;
+    }
+    return builder
+        .overrideAuthority(TestUtils.TEST_SERVER_HOST)
+        .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
+        .intercept(createCensusStatsClientInterceptor());
+  }
+
+  @Test
+  public void remoteAddr() {
+    InetSocketAddress isa = (InetSocketAddress) obtainRemoteClientAddr();
+    assertTrue(isa.getAddress().isLoopbackAddress());
+    // It should not be the same as the server
+    assertNotEquals(((InetSocketAddress) getListenAddress()).getPort(), isa.getPort());
+  }
+
+  @Test
+  public void localAddr() throws Exception {
+    InetSocketAddress isa = (InetSocketAddress) obtainLocalServerAddr();
+    assertTrue(isa.getAddress().isLoopbackAddress());
+    assertEquals(((InetSocketAddress) getListenAddress()).getPort(), isa.getPort());
+  }
+
+  @Test
+  public void contentLengthPermitted() throws Exception {
+    // Some third-party gRPC implementations (e.g., ServiceTalk) include Content-Length. The HTTP/2
+    // code starting in Netty 4.1.60.Final has special-cased handling of Content-Length, and may
+    // call uncommon methods on our custom headers implementation.
+    // https://github.com/grpc/grpc-java/issues/7953
+    Metadata contentLength = new Metadata();
+    contentLength.put(Metadata.Key.of("content-length", Metadata.ASCII_STRING_MARSHALLER), "5");
+    blockingStub
+        .withInterceptors(MetadataUtils.newAttachHeadersInterceptor(contentLength))
+        .emptyCall(EMPTY);
+  }
+}
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/InProcessTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/InProcessTest.java
index dd6c494f957..1ad63ae85d8 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/InProcessTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/InProcessTest.java
@@ -1,41 +1,26 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
-import io.grpc.ManagedChannel;
+import io.grpc.ServerBuilder;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
+import io.grpc.inprocess.InternalInProcessChannelBuilder;
+import io.grpc.inprocess.InternalInProcessServerBuilder;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
@@ -45,21 +30,27 @@ public class InProcessTest extends AbstractInteropTest {
 
   private static final String SERVER_NAME = "test";
 
-  /** Starts the in-process server. */
-  @BeforeClass
-  public static void startServer() {
-    startStaticServer(InProcessServerBuilder.forName(SERVER_NAME));
+  @Override
+  protected ServerBuilder<?> getServerBuilder() {
+    // Starts the in-process server.
+    InProcessServerBuilder builder = InProcessServerBuilder.forName(SERVER_NAME);
+    // Disable the default census stats tracer, use testing tracer instead.
+    InternalInProcessServerBuilder.setStatsEnabled(builder, false);
+    return builder.addStreamTracerFactory(createCustomCensusTracerFactory());
   }
 
-  @AfterClass
-  public static void stopServer() {
-    stopStaticServer();
+  @Override
+  protected InProcessChannelBuilder createChannelBuilder() {
+    InProcessChannelBuilder builder = InProcessChannelBuilder.forName(SERVER_NAME);
+    // Disable the default census stats interceptor, use testing interceptor instead.
+    InternalInProcessChannelBuilder.setStatsEnabled(builder, false);
+    return builder.intercept(createCensusStatsClientInterceptor());
   }
 
   @Override
-  protected ManagedChannel createChannel() {
-    return InProcessChannelBuilder.forName(SERVER_NAME)
-        .statsContextFactory(getClientStatsFactory()).build();
+  protected boolean customCensusModulePresent() {
+    // Metrics values are not expected, but custom census module is still used.
+    return true;
   }
 
   @Override
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/ManagedChannelBuilderSpiTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/ManagedChannelBuilderSpiTest.java
new file mode 100644
index 00000000000..737e5a3894f
--- /dev/null
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/ManagedChannelBuilderSpiTest.java
@@ -0,0 +1,36 @@
+/*
+ * 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.testing.integration;
+
+import io.grpc.ManagedChannelBuilder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for integration between {@link ManagedChannelBuilder} and providers. */
+@RunWith(JUnit4.class)
+public final class ManagedChannelBuilderSpiTest {
+  @Test
+  public void forAddress_isntObviouslyBroken() {
+    ManagedChannelBuilder.forAddress("localhost", 443).build().shutdownNow();
+  }
+
+  @Test
+  public void forTarget_isntObviouslyBroken() {
+    ManagedChannelBuilder.forTarget("localhost:443").build().shutdownNow();
+  }
+}
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/ManagedChannelImplIntegrationTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/ManagedChannelImplIntegrationTest.java
new file mode 100644
index 00000000000..f09f196d7d8
--- /dev/null
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/ManagedChannelImplIntegrationTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2024 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.testing.integration;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.ManagedChannel;
+import io.grpc.ServerInterceptors;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.testing.StreamRecorder;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.integration.EmptyProtos.Empty;
+import io.grpc.testing.integration.Messages.ResponseParameters;
+import io.grpc.testing.integration.Messages.StreamingOutputCallRequest;
+import io.grpc.testing.integration.Messages.StreamingOutputCallResponse;
+import java.util.concurrent.TimeUnit;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for ManagedChannelImpl that use a real transport. */
+@RunWith(JUnit4.class)
+public final class ManagedChannelImplIntegrationTest {
+  private static final String SERVER_NAME = ManagedChannelImplIntegrationTest.class.getName();
+  @Rule
+  public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+  @Test
+  public void idleWhileRpcInTransport_exitsIdleForNewRpc() throws Exception {
+    FakeClock fakeClock = new FakeClock();
+    grpcCleanup.register(InProcessServerBuilder.forName(SERVER_NAME)
+        .directExecutor()
+        .addService(
+            ServerInterceptors.intercept(
+                new TestServiceImpl(fakeClock.getScheduledExecutorService()),
+                TestServiceImpl.interceptors()))
+        .build()
+        .start());
+    ManagedChannel channel = grpcCleanup.register(InProcessChannelBuilder.forName(SERVER_NAME)
+        .directExecutor()
+        .build());
+
+    TestServiceGrpc.TestServiceBlockingStub blockingStub = TestServiceGrpc.newBlockingStub(channel);
+    TestServiceGrpc.TestServiceStub asyncStub = TestServiceGrpc.newStub(channel);
+    StreamRecorder<StreamingOutputCallResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<StreamingOutputCallRequest> requestObserver =
+        asyncStub.fullDuplexCall(responseObserver);
+    requestObserver.onNext(StreamingOutputCallRequest.newBuilder()
+        .addResponseParameters(ResponseParameters.newBuilder()
+            .setIntervalUs(Integer.MAX_VALUE))
+        .build());
+    try {
+      channel.enterIdle();
+      assertThat(blockingStub
+            .withDeadlineAfter(10, TimeUnit.SECONDS)
+            .emptyCall(Empty.getDefaultInstance()))
+          .isEqualTo(Empty.getDefaultInstance());
+    } finally {
+      requestObserver.onError(new RuntimeException("cleanup"));
+    }
+  }
+}
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/MoreInProcessTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/MoreInProcessTest.java
index 23ccd6a5583..d97aa8cd36c 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/MoreInProcessTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/MoreInProcessTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
@@ -65,8 +50,10 @@
 public class MoreInProcessTest {
   private static final String UNIQUE_SERVER_NAME =
       "in-process server for " + MoreInProcessTest.class;
+
+  // Use a fairly large timeout to work around classloading slowness.
   @Rule
-  public final Timeout globalTimeout = new Timeout(1000);
+  public final Timeout globalTimeout = new Timeout(10, TimeUnit.SECONDS);
   // use a mutable service registry for later registering the service impl for each test case.
   private final MutableHandlerRegistry serviceRegistry = new MutableHandlerRegistry();
   private final Server inProcessServer = InProcessServerBuilder.forName(UNIQUE_SERVER_NAME)
@@ -118,8 +105,8 @@ public void onCompleted() {
     // implement a client
     final CountDownLatch finishLatch = new CountDownLatch(1);
     final AtomicReference<StreamingInputCallResponse> responseRef =
-        new AtomicReference<StreamingInputCallResponse>();
-    final AtomicReference<Throwable> throwableRef = new AtomicReference<Throwable>();
+        new AtomicReference<>();
+    final AtomicReference<Throwable> throwableRef = new AtomicReference<>();
     StreamObserver<StreamingInputCallResponse> responseObserver =
         new StreamObserver<StreamingInputCallResponse>() {
           @Override
@@ -177,8 +164,8 @@ public void onCompleted() {
     // implement a client
     final CountDownLatch finishLatch = new CountDownLatch(1);
     final AtomicReference<StreamingInputCallResponse> responseRef =
-        new AtomicReference<StreamingInputCallResponse>();
-    final AtomicReference<Throwable> throwableRef = new AtomicReference<Throwable>();
+        new AtomicReference<>();
+    final AtomicReference<Throwable> throwableRef = new AtomicReference<>();
     StreamObserver<StreamingInputCallResponse> responseObserver =
         new StreamObserver<StreamingInputCallResponse>() {
           @Override
@@ -236,8 +223,8 @@ public void onCompleted() {
     // implement a client
     final CountDownLatch finishLatch = new CountDownLatch(1);
     final AtomicReference<StreamingInputCallResponse> responseRef =
-        new AtomicReference<StreamingInputCallResponse>();
-    final AtomicReference<Throwable> throwableRef = new AtomicReference<Throwable>();
+        new AtomicReference<>();
+    final AtomicReference<Throwable> throwableRef = new AtomicReference<>();
     StreamObserver<StreamingInputCallResponse> responseObserver =
         new StreamObserver<StreamingInputCallResponse>() {
           @Override
@@ -262,7 +249,11 @@ public void onCompleted() {
         .onNext(StreamingInputCallRequest.getDefaultInstance());
 
     assertTrue(finishLatch.await(900, TimeUnit.MILLISECONDS));
-    assertEquals(Status.UNKNOWN, Status.fromThrowable(throwableRef.get()));
+    Status actualStatus = Status.fromThrowable(throwableRef.get());
+    Status expectedStatus = Status.UNKNOWN.withDescription("Application error processing RPC");
+    assertEquals(expectedStatus.getCode(), actualStatus.getCode());
+    assertEquals(expectedStatus.getDescription(), actualStatus.getDescription());
+    assertNull(actualStatus.getCause());
     assertNull(responseRef.get());
   }
 }
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/NettyFlowControlTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/NettyFlowControlTest.java
index e3594de81b7..1c8f3bb4a7d 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/NettyFlowControlTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/NettyFlowControlTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
@@ -39,7 +24,11 @@
 import io.grpc.ServerBuilder;
 import io.grpc.ServerInterceptor;
 import io.grpc.ServerInterceptors;
-import io.grpc.netty.HandlerSettings;
+import io.grpc.netty.GrpcHttp2ConnectionHandler;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.InternalNettyChannelBuilder.ProtocolNegotiatorFactory;
+import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
+import io.grpc.netty.InternalProtocolNegotiators;
 import io.grpc.netty.NegotiationType;
 import io.grpc.netty.NettyChannelBuilder;
 import io.grpc.netty.NettyServerBuilder;
@@ -47,18 +36,18 @@
 import io.grpc.testing.integration.Messages.ResponseParameters;
 import io.grpc.testing.integration.Messages.StreamingOutputCallRequest;
 import io.grpc.testing.integration.Messages.StreamingOutputCallResponse;
-import io.netty.util.concurrent.DefaultThreadFactory;
+import io.netty.channel.ChannelHandler;
+import io.netty.handler.codec.http2.Http2Stream;
+import io.netty.util.AsciiString;
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executors;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 import org.junit.After;
-import org.junit.AfterClass;
 import org.junit.Before;
-import org.junit.BeforeClass;
+import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -78,28 +67,15 @@ public class NettyFlowControlTest {
   private static final int REGULAR_WINDOW = 64 * 1024;
   private static final int MAX_WINDOW = 8 * 1024 * 1024;
 
-  private static ManagedChannel channel;
-  private static Server server;
-  private static TrafficControlProxy proxy;
+  private final CapturingProtocolNegotiationFactory capturingPnFactory
+      = new CapturingProtocolNegotiationFactory();
+  private ManagedChannel channel;
+  private Server server;
+  private TrafficControlProxy proxy;
 
   private int proxyPort;
   private int serverPort;
 
-  private static final ThreadPoolExecutor executor =
-      new ThreadPoolExecutor(1, 10, 1, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(),
-          new DefaultThreadFactory("flowcontrol-test-pool", true));
-
-  @BeforeClass
-  public static void setUp() {
-    HandlerSettings.enable(true);
-    HandlerSettings.autoWindowOn(true);
-  }
-
-  @AfterClass
-  public static void shutDownTests() {
-    executor.shutdown();
-  }
-
   @Before
   public void initTest() {
     startServer(REGULAR_WINDOW);
@@ -108,8 +84,13 @@ public void initTest() {
 
   @After
   public void endTest() throws IOException {
-    proxy.shutDown();
-    server.shutdown();
+    if (proxy != null) {
+      proxy.shutDown();
+    }
+    server.shutdownNow();
+    if (channel != null) {
+      channel.shutdownNow();
+    }
   }
 
   @Test
@@ -117,7 +98,7 @@ public void largeBdp() throws InterruptedException, IOException {
     proxy = new TrafficControlProxy(serverPort, HIGH_BAND, MED_LAT, TimeUnit.MILLISECONDS);
     proxy.start();
     proxyPort = proxy.getPort();
-    resetConnection(REGULAR_WINDOW);
+    createAndStartChannel(REGULAR_WINDOW);
     doTest(HIGH_BAND, MED_LAT);
   }
 
@@ -126,16 +107,17 @@ public void smallBdp() throws InterruptedException, IOException {
     proxy = new TrafficControlProxy(serverPort, LOW_BAND, MED_LAT, TimeUnit.MILLISECONDS);
     proxy.start();
     proxyPort = proxy.getPort();
-    resetConnection(REGULAR_WINDOW);
+    createAndStartChannel(REGULAR_WINDOW);
     doTest(LOW_BAND, MED_LAT);
   }
 
   @Test
+  @Ignore("enable once 2 pings between data is no longer necessary")
   public void verySmallWindowMakesProgress() throws InterruptedException, IOException {
     proxy = new TrafficControlProxy(serverPort, HIGH_BAND, MED_LAT, TimeUnit.MILLISECONDS);
     proxy.start();
     proxyPort = proxy.getPort();
-    resetConnection(TINY_WINDOW);
+    createAndStartChannel(TINY_WINDOW);
     doTest(HIGH_BAND, MED_LAT);
   }
 
@@ -146,7 +128,7 @@ public void verySmallWindowMakesProgress() throws InterruptedException, IOExcept
   private void doTest(int bandwidth, int latency) throws InterruptedException {
 
     int streamSize = 1 * 1024 * 1024;
-    long expectedWindow = (latency * (bandwidth / TimeUnit.SECONDS.toMillis(1)));
+    long expectedWindow = latency * (bandwidth / TimeUnit.SECONDS.toMillis(1));
 
     TestServiceGrpc.TestServiceStub stub = TestServiceGrpc.newStub(channel);
     StreamingOutputCallRequest.Builder builder = StreamingOutputCallRequest.newBuilder()
@@ -157,17 +139,19 @@ private void doTest(int bandwidth, int latency) throws InterruptedException {
         .addResponseParameters(ResponseParameters.newBuilder().setSize(streamSize / 2));
     StreamingOutputCallRequest request = builder.build();
 
-    TestStreamObserver observer = new TestStreamObserver(expectedWindow);
+    TestStreamObserver observer =
+        new TestStreamObserver(capturingPnFactory.grpcHandlerRef, expectedWindow);
     stub.streamingOutputCall(request, observer);
-    int lastWindow = observer.waitFor();
+    int lastWindow = observer.waitFor(5, TimeUnit.SECONDS);
 
     // deal with cases that either don't cause a window update or hit max window
-    expectedWindow = Math.min(MAX_WINDOW, (Math.max(expectedWindow, REGULAR_WINDOW)));
+    expectedWindow = Math.min(MAX_WINDOW, Math.max(expectedWindow, REGULAR_WINDOW));
 
-    // Range looks large, but this allows for only one extra/missed window update
+    // Range looks large, but this allows for only one extra/missed window update plus
+    // bdpPing variations.
     // (one extra update causes a 2x difference and one missed update causes a .5x difference)
     assertTrue("Window was " + lastWindow + " expecting " + expectedWindow,
-        lastWindow < 2 * expectedWindow);
+        lastWindow < 2.2 * expectedWindow);
     assertTrue("Window was " + lastWindow + " expecting " + expectedWindow,
         expectedWindow < 2 * lastWindow);
   }
@@ -175,24 +159,21 @@ private void doTest(int bandwidth, int latency) throws InterruptedException {
   /**
    * Resets client/server and their flow control windows.
    */
-  private void resetConnection(int clientFlowControlWindow)
-      throws InterruptedException {
-    if (channel != null) {
-      if (!channel.isShutdown()) {
-        channel.shutdown();
-        channel.awaitTermination(100, TimeUnit.MILLISECONDS);
-      }
-    }
-    channel = NettyChannelBuilder.forAddress(new InetSocketAddress("localhost", proxyPort))
-        .flowControlWindow(clientFlowControlWindow)
-        .negotiationType(NegotiationType.PLAINTEXT)
-        .build();
+  private void createAndStartChannel(int clientFlowControlWindow) {
+    NettyChannelBuilder channelBuilder =
+        NettyChannelBuilder
+            .forAddress(new InetSocketAddress("localhost", proxyPort))
+            .initialFlowControlWindow(clientFlowControlWindow)
+            .negotiationType(NegotiationType.PLAINTEXT);
+    InternalNettyChannelBuilder.setProtocolNegotiatorFactory(channelBuilder, capturingPnFactory);
+    channel = channelBuilder.build();
   }
 
   private void startServer(int serverFlowControlWindow) {
     ServerBuilder<?> builder =
-        NettyServerBuilder.forAddress(new InetSocketAddress("localhost", 0))
-        .flowControlWindow(serverFlowControlWindow);
+        NettyServerBuilder
+            .forAddress(new InetSocketAddress("localhost", 0))
+            .initialFlowControlWindow(serverFlowControlWindow);
     builder.addService(ServerInterceptors.intercept(
         new TestServiceImpl(Executors.newScheduledThreadPool(2)),
         ImmutableList.<ServerInterceptor>of()));
@@ -208,22 +189,34 @@ private void startServer(int serverFlowControlWindow) {
    */
   private static class TestStreamObserver implements StreamObserver<StreamingOutputCallResponse> {
 
-    long startRequestNanos;
-    long endRequestNanos;
-    private final CountDownLatch latch = new CountDownLatch(1);
-    long expectedWindow;
+    final AtomicReference<GrpcHttp2ConnectionHandler> grpcHandlerRef;
+    final CountDownLatch latch = new CountDownLatch(1);
+    final long expectedWindow;
     int lastWindow;
+    boolean wasCompleted;
 
-    public TestStreamObserver(long window) {
-      startRequestNanos = System.nanoTime();
+    public TestStreamObserver(
+        AtomicReference<GrpcHttp2ConnectionHandler> grpcHandlerRef, long window) {
+      this.grpcHandlerRef = grpcHandlerRef;
       expectedWindow = window;
     }
 
     @Override
     public void onNext(StreamingOutputCallResponse value) {
-      lastWindow = HandlerSettings.getLatestClientWindow();
-      if (lastWindow >= expectedWindow) {
-        onCompleted();
+      GrpcHttp2ConnectionHandler grpcHandler = grpcHandlerRef.get();
+      Http2Stream connectionStream = grpcHandler.connection().connectionStream();
+      int curWindow = grpcHandler.decoder().flowController().initialWindowSize(connectionStream);
+      synchronized (this) {
+        if (curWindow >= expectedWindow) {
+          if (wasCompleted) {
+            return;
+          }
+          wasCompleted = true;
+          lastWindow = curWindow;
+          onCompleted();
+        } else if (!wasCompleted) {
+          lastWindow = curWindow;
+        }
       }
     }
 
@@ -238,13 +231,40 @@ public void onCompleted() {
       latch.countDown();
     }
 
-    public long getElapsedTime() {
-      return endRequestNanos - startRequestNanos;
+    public int waitFor(long duration, TimeUnit unit) throws InterruptedException {
+      latch.await(duration, unit);
+      return lastWindow;
     }
+  }
 
-    public int waitFor() throws InterruptedException {
-      latch.await();
-      return lastWindow;
+  private static class CapturingProtocolNegotiationFactory implements ProtocolNegotiatorFactory {
+
+    AtomicReference<GrpcHttp2ConnectionHandler> grpcHandlerRef = new AtomicReference<>();
+
+    @Override
+    public ProtocolNegotiator buildProtocolNegotiator() {
+      return new CapturingProtocolNegotiator();
+    }
+
+    private class CapturingProtocolNegotiator implements ProtocolNegotiator {
+
+      final ProtocolNegotiator delegate = InternalProtocolNegotiators.plaintext();
+
+      @Override
+      public AsciiString scheme() {
+        return delegate.scheme();
+      }
+
+      @Override
+      public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+        CapturingProtocolNegotiationFactory.this.grpcHandlerRef.set(grpcHandler);
+        return delegate.newHandler(grpcHandler);
+      }
+
+      @Override
+      public void close() {
+        delegate.close();
+      }
     }
   }
 }
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/OpenTelemetryContextPropagationTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/OpenTelemetryContextPropagationTest.java
new file mode 100644
index 00000000000..3884d977a6e
--- /dev/null
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/OpenTelemetryContextPropagationTest.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright 2024 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.testing.integration;
+
+import static org.junit.Assert.assertEquals;
+
+import io.grpc.ForwardingServerCallListener;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Metadata;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.NettyChannelBuilder;
+import io.grpc.netty.NettyServerBuilder;
+import io.grpc.opentelemetry.GrpcOpenTelemetry;
+import io.grpc.opentelemetry.GrpcTraceBinContextPropagator;
+import io.grpc.opentelemetry.InternalGrpcOpenTelemetry;
+import io.grpc.testing.integration.Messages.SimpleRequest;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.Tracer;
+import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.Scope;
+import io.opentelemetry.context.propagation.ContextPropagators;
+import io.opentelemetry.context.propagation.TextMapPropagator;
+import io.opentelemetry.sdk.OpenTelemetrySdk;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class OpenTelemetryContextPropagationTest extends AbstractInteropTest {
+  private final OpenTelemetrySdk openTelemetrySdk;
+  private final Tracer tracer;
+  private final GrpcOpenTelemetry grpcOpenTelemetry;
+  private final AtomicReference<Span> applicationSpan = new AtomicReference<>();
+  private final boolean censusClient;
+
+  @Parameterized.Parameters(name = "ContextPropagator={0}, CensusClient={1}")
+  public static Iterable<Object[]> data() {
+    return Arrays.asList(new Object[][] {
+        {W3CTraceContextPropagator.getInstance(), false},
+        {GrpcTraceBinContextPropagator.defaultInstance(), false},
+        {GrpcTraceBinContextPropagator.defaultInstance(), true}
+    });
+  }
+
+  public OpenTelemetryContextPropagationTest(TextMapPropagator textMapPropagator,
+                                             boolean isCensusClient) {
+    this.openTelemetrySdk = OpenTelemetrySdk.builder()
+        .setTracerProvider(SdkTracerProvider.builder().build())
+        .setPropagators(ContextPropagators.create(TextMapPropagator.composite(
+            textMapPropagator
+        )))
+        .build();
+    this.tracer = openTelemetrySdk
+        .getTracer("grpc-java-interop-test");
+    GrpcOpenTelemetry.Builder grpcOpentelemetryBuilder = GrpcOpenTelemetry.newBuilder()
+        .sdk(openTelemetrySdk);
+    InternalGrpcOpenTelemetry.enableTracing(grpcOpentelemetryBuilder, true);
+    grpcOpenTelemetry = grpcOpentelemetryBuilder.build();
+    this.censusClient = isCensusClient;
+  }
+
+  @Override
+  protected ServerBuilder<?> getServerBuilder() {
+    NettyServerBuilder builder = NettyServerBuilder.forPort(0, InsecureServerCredentials.create())
+        .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
+    builder.intercept(new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+          Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+        ServerCall.Listener<ReqT> listener = next.startCall(call, headers);
+        return new ForwardingServerCallListener<ReqT>() {
+          @Override
+          protected ServerCall.Listener<ReqT> delegate() {
+            return listener;
+          }
+
+          @Override
+          public void onMessage(ReqT request) {
+            applicationSpan.set(tracer.spanBuilder("InteropTest.Application.Span").startSpan());
+            delegate().onMessage(request);
+          }
+
+          @Override
+          public void onHalfClose() {
+            maybeCloseSpan(applicationSpan);
+            delegate().onHalfClose();
+          }
+
+          @Override
+          public void onCancel() {
+            maybeCloseSpan(applicationSpan);
+            delegate().onCancel();
+          }
+
+          @Override
+          public void onComplete() {
+            maybeCloseSpan(applicationSpan);
+            delegate().onComplete();
+          }
+        };
+      }
+    });
+    // To ensure proper propagation of remote spans from gRPC to your application, this interceptor
+    // must be after any application interceptors that interact with spans. This allows the tracing
+    // information to be correctly passed along. However, it's fine for application-level onMessage
+    // handlers to access the span.
+    grpcOpenTelemetry.configureServerBuilder(builder);
+    return builder;
+  }
+
+  private void maybeCloseSpan(AtomicReference<Span> applicationSpan) {
+    Span tmp = applicationSpan.get();
+    if (tmp != null) {
+      tmp.end();
+    }
+  }
+
+  @Override
+  protected boolean metricsExpected() {
+    return false;
+  }
+
+  @Override
+  protected ManagedChannelBuilder<?> createChannelBuilder() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forAddress(getListenAddress())
+        .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
+        .usePlaintext();
+    if (!censusClient) {
+      // Disabling census-tracing is necessary to avoid trace ID mismatches.
+      // This is because census-tracing overrides the grpc-trace-bin header with
+      // OpenTelemetry's GrpcTraceBinPropagator.
+      InternalNettyChannelBuilder.setTracingEnabled(builder, false);
+      grpcOpenTelemetry.configureChannelBuilder(builder);
+    }
+    return builder;
+  }
+
+  @Test
+  public void otelSpanContextPropagation() {
+    Assume.assumeFalse(censusClient);
+    Span parentSpan = tracer.spanBuilder("Test.interopTest").startSpan();
+    try (Scope scope = Context.current().with(parentSpan).makeCurrent()) {
+      blockingStub.unaryCall(SimpleRequest.getDefaultInstance());
+    }
+    assertEquals(parentSpan.getSpanContext().getTraceId(),
+        applicationSpan.get().getSpanContext().getTraceId());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void censusToOtelGrpcTraceBinPropagator() {
+    Assume.assumeTrue(censusClient);
+    io.opencensus.trace.Tracer censusTracer = io.opencensus.trace.Tracing.getTracer();
+    io.opencensus.trace.Span parentSpan = censusTracer.spanBuilder("Test.interopTest")
+        .startSpan();
+    io.grpc.Context context =  io.opencensus.trace.unsafe.ContextUtils.withValue(
+        io.grpc.Context.current(), parentSpan);
+    io.grpc.Context previous = context.attach();
+    try {
+      blockingStub.unaryCall(SimpleRequest.getDefaultInstance());
+      assertEquals(parentSpan.getContext().getTraceId().toLowerBase16(),
+          applicationSpan.get().getSpanContext().getTraceId());
+    } finally {
+      context.detach(previous);
+    }
+  }
+}
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/ProxyTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/ProxyTest.java
index f0a8a008d99..725e98d0fe3 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/ProxyTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/ProxyTest.java
@@ -1,47 +1,34 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
 
 import static org.junit.Assert.assertEquals;
 
+import com.google.common.io.ByteStreams;
 import io.netty.util.concurrent.DefaultThreadFactory;
 import java.io.DataInputStream;
-import java.io.DataOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;
-import java.net.UnknownHostException;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
@@ -75,18 +62,17 @@ public void shutdownTest() throws IOException {
   }
 
   @Test
-  public void smallLatency()
-      throws UnknownHostException, IOException, InterruptedException, ExecutionException {
+  public void smallLatency() throws Exception {
     server = new Server();
     int serverPort = server.init();
     executor.execute(server);
 
     int latency = (int) TimeUnit.MILLISECONDS.toNanos(50);
     proxy = new TrafficControlProxy(serverPort, 1024 * 1024, latency, TimeUnit.NANOSECONDS);
-    startProxy(proxy).get();
+    proxy.start();
     client = new Socket("localhost", proxy.getPort());
     client.setReuseAddress(true);
-    DataOutputStream clientOut = new DataOutputStream(client.getOutputStream());
+    OutputStream clientOut = client.getOutputStream();
     DataInputStream clientIn = new DataInputStream(client.getInputStream());
     byte[] message = new byte[1];
 
@@ -97,27 +83,29 @@ public void smallLatency()
     clientIn.readFully(new byte[5]);
 
     // test
-    long start = System.nanoTime();
-    clientOut.write(message, 0, 1);
-    clientIn.read(message);
-    long stop = System.nanoTime();
-
-    long rtt = (stop - start);
-    assertEquals(latency, rtt, latency);
+    List<Long> rtts = new ArrayList<>();
+    for (int i = 0; i < 3; i++) {
+      long start = System.nanoTime();
+      clientOut.write(message, 0, 1);
+      clientIn.read(message);
+      rtts.add(System.nanoTime() - start);
+    }
+    Collections.sort(rtts);
+    long rtt = rtts.get(0);
+    assertEquals(latency, (double) rtt, .5 * latency);
   }
 
   @Test
-  public void bigLatency()
-      throws UnknownHostException, IOException, InterruptedException, ExecutionException {
+  public void bigLatency() throws Exception {
     server = new Server();
     int serverPort = server.init();
     executor.execute(server);
 
     int latency = (int) TimeUnit.MILLISECONDS.toNanos(250);
     proxy = new TrafficControlProxy(serverPort, 1024 * 1024, latency, TimeUnit.NANOSECONDS);
-    startProxy(proxy).get();
+    proxy.start();
     client = new Socket("localhost", proxy.getPort());
-    DataOutputStream clientOut = new DataOutputStream(client.getOutputStream());
+    OutputStream clientOut = client.getOutputStream();
     DataInputStream clientIn = new DataInputStream(client.getInputStream());
     byte[] message = new byte[1];
 
@@ -128,94 +116,82 @@ public void bigLatency()
     clientIn.readFully(new byte[5]);
 
     // test
-    long start = System.nanoTime();
-    clientOut.write(message, 0, 1);
-    clientIn.read(message);
-    long stop = System.nanoTime();
-
-    long rtt = (stop - start);
-    assertEquals(latency, rtt, latency);
+    List<Long> rtts = new ArrayList<>();
+    for (int i = 0; i < 2; i++) {
+      long start = System.nanoTime();
+      clientOut.write(message, 0, 1);
+      clientIn.read(message);
+      rtts.add(System.nanoTime() - start);
+    }
+    Collections.sort(rtts);
+    long rtt = rtts.get(0);
+    assertEquals(latency, (double) rtt, .5 * latency);
   }
 
   @Test
-  public void smallBandwidth()
-      throws UnknownHostException, IOException, InterruptedException, ExecutionException {
+  public void smallBandwidth() throws Exception {
     server = new Server();
     int serverPort = server.init();
     server.setMode("stream");
     executor.execute(server);
-    assertEquals(server.mode(), "stream");
 
     int bandwidth = 64 * 1024;
     proxy = new TrafficControlProxy(serverPort, bandwidth, 200, TimeUnit.MILLISECONDS);
-    startProxy(proxy).get();
+    proxy.start();
     client = new Socket("localhost", proxy.getPort());
-    DataOutputStream clientOut = new DataOutputStream(client.getOutputStream());
     DataInputStream clientIn = new DataInputStream(client.getInputStream());
 
-    clientOut.write(new byte[1]);
     clientIn.readFully(new byte[100 * 1024]);
-    long start = System.nanoTime();
-    clientIn.readFully(new byte[5 * bandwidth]);
-    long stop = System.nanoTime();
-
-    long bandUsed = ((5 * bandwidth) / ((stop - start) / TimeUnit.SECONDS.toNanos(1)));
+    int sample = bandwidth / 5;
+    List<Double> bandwidths = new ArrayList<>();
+    for (int i = 0; i < 5; i++) {
+      long start = System.nanoTime();
+      clientIn.readFully(new byte[sample]);
+      long duration = System.nanoTime() - start;
+      double actualBandwidth = sample / (((double) duration) / TimeUnit.SECONDS.toNanos(1));
+      bandwidths.add(actualBandwidth);
+    }
+    Collections.sort(bandwidths);
+    double bandUsed = bandwidths.get(bandwidths.size() - 1);
     assertEquals(bandwidth, bandUsed, .5 * bandwidth);
   }
 
   @Test
-  public void largeBandwidth()
-      throws UnknownHostException, IOException, InterruptedException, ExecutionException {
+  public void largeBandwidth() throws Exception {
     server = new Server();
     int serverPort = server.init();
     server.setMode("stream");
     executor.execute(server);
-    assertEquals(server.mode(), "stream");
     int bandwidth = 10 * 1024 * 1024;
     proxy = new TrafficControlProxy(serverPort, bandwidth, 200, TimeUnit.MILLISECONDS);
-    startProxy(proxy).get();
+    proxy.start();
     client = new Socket("localhost", proxy.getPort());
-    DataOutputStream clientOut = new DataOutputStream(client.getOutputStream());
     DataInputStream clientIn = new DataInputStream(client.getInputStream());
 
-    clientOut.write(new byte[1]);
     clientIn.readFully(new byte[100 * 1024]);
-    long start = System.nanoTime();
-    clientIn.readFully(new byte[5 * bandwidth]);
-    long stop = System.nanoTime();
-
-    long bandUsed = ((5 * bandwidth) / ((stop - start) / TimeUnit.SECONDS.toNanos(1)));
+    int sample = bandwidth / 5;
+    List<Double> bandwidths = new ArrayList<>();
+    for (int i = 0; i < 5; i++) {
+      long start = System.nanoTime();
+      clientIn.readFully(new byte[sample]);
+      long duration = System.nanoTime() - start;
+      double actualBandwidth = sample / (((double) duration) / TimeUnit.SECONDS.toNanos(1));
+      bandwidths.add(actualBandwidth);
+    }
+    Collections.sort(bandwidths);
+    double bandUsed = bandwidths.get(bandwidths.size() - 1);
     assertEquals(bandwidth, bandUsed, .5 * bandwidth);
   }
 
-  private Future<?> startProxy(final TrafficControlProxy p) {
-    return executor.submit(new Runnable() {
-      @Override
-      public void run() {
-        try {
-          p.start();
-        } catch (Exception e) {
-          throw new RuntimeException(e);
-        }
-      }
-    });
-  }
-
   // server with echo and streaming modes
-  private class Server implements Runnable {
+  private static class Server implements Runnable {
     private ServerSocket server;
-    private Socket rcv;
-    private boolean shutDown;
     private String mode = "echo";
 
     public void setMode(String mode) {
       this.mode = mode;
     }
 
-    public String mode() {
-      return mode;
-    }
-
     /**
      * Initializes server and returns its listening port.
      */
@@ -224,43 +200,42 @@ public int init() throws IOException {
       return server.getLocalPort();
     }
 
-    public void shutDown() {
-      try {
-        server.close();
-        rcv.close();
-        shutDown = true;
-      } catch (IOException e) {
-        shutDown = true;
-      }
+    public void shutDown() throws IOException {
+      server.close();
     }
 
     @Override
     public void run() {
       try {
-        rcv = server.accept();
-        DataInputStream serverIn = new DataInputStream(rcv.getInputStream());
-        DataOutputStream serverOut = new DataOutputStream(rcv.getOutputStream());
-        byte[] response = new byte[1024];
-        if (mode.equals("echo")) {
-          while (!shutDown) {
-            int readable = serverIn.read(response);
-            serverOut.write(response, 0, readable);
-          }
-        } else if (mode.equals("stream")) {
-          serverIn.read(response);
-          byte[] message = new byte[16 * 1024];
-          while (!shutDown) {
-            serverOut.write(message, 0, message.length);
-          }
-          serverIn.close();
-          serverOut.close();
+        Socket rcv = server.accept();
+        try {
+          handleSocket(rcv);
+        } finally {
           rcv.close();
-        } else {
-          System.out.println("Unknown mode: use 'echo' or 'stream'");
         }
       } catch (IOException e) {
         throw new RuntimeException(e);
       }
     }
+
+    private void handleSocket(Socket rcv) throws IOException {
+      InputStream serverIn = rcv.getInputStream();
+      OutputStream serverOut = rcv.getOutputStream();
+      if (mode.equals("echo")) {
+        ByteStreams.copy(serverIn, serverOut);
+      } else if (mode.equals("stream")) {
+        byte[] message = new byte[1024];
+        while (true) {
+          try {
+            serverOut.write(message);
+          } catch (IOException ignored) {
+            // Client closed
+            break;
+          }
+        }
+      } else {
+        throw new RuntimeException("Unknown mode: use 'echo' or 'stream'");
+      }
+    }
   }
 }
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/RetryTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/RetryTest.java
new file mode 100644
index 00000000000..669ce1c69db
--- /dev/null
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/RetryTest.java
@@ -0,0 +1,574 @@
+/*
+ * Copyright 2021 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.testing.integration;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.ImmutableMap;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ClientStreamTracer.StreamInfo;
+import io.grpc.Deadline;
+import io.grpc.Deadline.Ticker;
+import io.grpc.IntegerMarshaller;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.Server;
+import io.grpc.ServerCall;
+import io.grpc.ServerCall.Listener;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerMethodDefinition;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.StringMarshaller;
+import io.grpc.census.InternalCensusStatsAccessor;
+import io.grpc.census.internal.DeprecatedCensusConstants;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.testing.StatsTestUtils.FakeStatsRecorder;
+import io.grpc.internal.testing.StatsTestUtils.FakeTagContextBinarySerializer;
+import io.grpc.internal.testing.StatsTestUtils.FakeTagger;
+import io.grpc.internal.testing.StatsTestUtils.MetricsRecord;
+import io.grpc.netty.NettyChannelBuilder;
+import io.grpc.netty.NettyServerBuilder;
+import io.grpc.testing.GrpcCleanupRule;
+import io.netty.channel.DefaultEventLoopGroup;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.local.LocalAddress;
+import io.netty.channel.local.LocalChannel;
+import io.netty.channel.local.LocalServerChannel;
+import io.netty.util.concurrent.ScheduledFuture;
+import io.opencensus.contrib.grpc.metrics.RpcMeasureConstants;
+import io.opencensus.stats.Measure;
+import io.opencensus.stats.Measure.MeasureDouble;
+import io.opencensus.stats.Measure.MeasureLong;
+import io.opencensus.tags.TagValue;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.After;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class RetryTest {
+  private static final FakeTagger tagger = new FakeTagger();
+  private static final FakeTagContextBinarySerializer tagContextBinarySerializer =
+      new FakeTagContextBinarySerializer();
+  private static final MeasureLong RETRIES_PER_CALL =
+      Measure.MeasureLong.create(
+          "grpc.io/client/retries_per_call", "Number of retries per call", "1");
+  private static final MeasureLong TRANSPARENT_RETRIES_PER_CALL =
+      Measure.MeasureLong.create(
+          "grpc.io/client/transparent_retries_per_call", "Transparent retries per call", "1");
+  private static final MeasureDouble RETRY_DELAY_PER_CALL =
+      Measure.MeasureDouble.create(
+          "grpc.io/client/retry_delay_per_call", "Retry delay per call", "ms");
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  @Rule
+  public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+  private final FakeClock fakeClock = new FakeClock();
+  private TestListener testCallListener = new TestListener();
+  @SuppressWarnings("unchecked")
+  private ClientCall.Listener<Integer> mockCallListener =
+      mock(ClientCall.Listener.class, delegatesTo(testCallListener));
+
+  private CountDownLatch backoffLatch = new CountDownLatch(1);
+  private final EventLoopGroup clientGroup = new DefaultEventLoopGroup(1) {
+    @SuppressWarnings("FutureReturnValueIgnored")
+    @Override
+    public ScheduledFuture<?> schedule(
+        final Runnable command, final long delay, final TimeUnit unit) {
+      if (!command.getClass().getName().contains("RetryBackoffRunnable")) {
+        return super.schedule(command, delay, unit);
+      }
+      fakeClock.getScheduledExecutorService().schedule(
+          new Runnable() {
+            @Override
+            public void run() {
+              clientGroup.execute(command);
+            }
+          },
+          delay,
+          unit);
+      backoffLatch.countDown();
+      return super.schedule(
+          new Runnable() {
+            @Override
+            public void run() {} // no-op
+          },
+          0,
+          TimeUnit.NANOSECONDS);
+    }
+  };
+  private final EventLoopGroup serverGroup = new DefaultEventLoopGroup(1);
+  private final FakeStatsRecorder clientStatsRecorder = new FakeStatsRecorder();
+  private final ClientInterceptor statsInterceptor =
+      InternalCensusStatsAccessor.getClientInterceptor(
+          tagger, tagContextBinarySerializer, clientStatsRecorder,
+          fakeClock.getStopwatchSupplier(), true, true, true,
+          /* recordRealTimeMetrics= */ true, /* recordRetryMetrics= */ true);
+  private final MethodDescriptor<String, Integer> clientStreamingMethod =
+      MethodDescriptor.<String, Integer>newBuilder()
+          .setType(MethodType.CLIENT_STREAMING)
+          .setFullMethodName("service/method")
+          .setRequestMarshaller(new StringMarshaller())
+          .setResponseMarshaller(new IntegerMarshaller())
+          .build();
+  private final LinkedBlockingQueue<ServerCall<String, Integer>> serverCalls =
+      new LinkedBlockingQueue<>();
+  private final ServerMethodDefinition<String, Integer> methodDefinition =
+      ServerMethodDefinition.create(
+          clientStreamingMethod,
+          new ServerCallHandler<String, Integer>() {
+            @Override
+            public Listener<String> startCall(ServerCall<String, Integer> call, Metadata headers) {
+              serverCalls.offer(call);
+              return new Listener<String>() {};
+            }
+          }
+  );
+  private final ServerServiceDefinition serviceDefinition =
+      ServerServiceDefinition.builder(clientStreamingMethod.getServiceName())
+          .addMethod(methodDefinition)
+          .build();
+  private final LocalAddress localAddress = new LocalAddress(this.getClass().getName());
+  private Server localServer;
+  private ManagedChannel channel;
+  private Map<String, Object> retryPolicy = null;
+  private long bufferLimit = 1L << 20; // 1M
+
+  @After
+  @SuppressWarnings("FutureReturnValueIgnored")
+  public void tearDown() {
+    clientGroup.shutdownGracefully();
+    serverGroup.shutdownGracefully();
+  }
+
+  private void startNewServer() throws Exception {
+    localServer = cleanupRule.register(NettyServerBuilder.forAddress(localAddress)
+        .channelType(LocalServerChannel.class)
+        .bossEventLoopGroup(serverGroup)
+        .workerEventLoopGroup(serverGroup)
+        .addService(serviceDefinition)
+        .build());
+    localServer.start();
+  }
+
+  private void createNewChannel() {
+    Map<String, Object> methodConfig = new HashMap<>();
+    Map<String, Object> name = new HashMap<>();
+    name.put("service", "service");
+    methodConfig.put("name", Arrays.<Object>asList(name));
+    if (retryPolicy != null) {
+      methodConfig.put("retryPolicy", retryPolicy);
+    }
+    Map<String, Object> rawServiceConfig = new HashMap<>();
+    rawServiceConfig.put("methodConfig", Arrays.<Object>asList(methodConfig));
+    channel = cleanupRule.register(
+        NettyChannelBuilder.forAddress(localAddress)
+            .channelType(LocalChannel.class, LocalAddress.class)
+            .eventLoopGroup(clientGroup)
+            .usePlaintext()
+            .enableRetry()
+            .perRpcBufferLimit(bufferLimit)
+            .defaultServiceConfig(rawServiceConfig)
+            .intercept(statsInterceptor)
+            .build());
+  }
+
+  private void elapseBackoff(long time, TimeUnit unit) throws Exception {
+    assertThat(backoffLatch.await(5, SECONDS)).isTrue();
+    backoffLatch = new CountDownLatch(1);
+    fakeClock.forwardTime(time, unit);
+  }
+
+  private void assertRpcStartedRecorded() throws Exception {
+    MetricsRecord record = clientStatsRecorder.pollRecord(5, SECONDS);
+    assertThat(record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_STARTED_RPCS))
+        .isEqualTo(1);
+  }
+
+  private void assertOutboundMessageRecorded() throws Exception {
+    MetricsRecord record = clientStatsRecorder.pollRecord(5, SECONDS);
+    assertThat(
+            record.getMetricAsLongOrFail(
+                RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_METHOD))
+        .isEqualTo(1);
+  }
+
+  private void assertInboundMessageRecorded() throws Exception {
+    MetricsRecord record = clientStatsRecorder.pollRecord(5, SECONDS);
+    assertThat(
+            record.getMetricAsLongOrFail(
+                RpcMeasureConstants.GRPC_CLIENT_RECEIVED_MESSAGES_PER_METHOD))
+        .isEqualTo(1);
+  }
+
+  private void assertOutboundWireSizeRecorded(long length) throws Exception {
+    MetricsRecord record = clientStatsRecorder.pollRecord(5, SECONDS);
+    assertThat(record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_BYTES_PER_METHOD))
+        .isEqualTo(length);
+  }
+
+  private void assertInboundWireSizeRecorded(long length) throws Exception {
+    MetricsRecord record = clientStatsRecorder.pollRecord(5, SECONDS);
+    assertThat(
+            record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_RECEIVED_BYTES_PER_METHOD))
+        .isEqualTo(length);
+  }
+
+  private void assertRpcStatusRecorded(
+      Status.Code code, long roundtripLatencyMs, long outboundMessages) throws Exception {
+    MetricsRecord record = clientStatsRecorder.pollRecord(7, SECONDS);
+    assertNotNull(record);
+    TagValue statusTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_STATUS);
+    assertNotNull(statusTag);
+    assertThat(statusTag.asString()).isEqualTo(code.toString());
+    assertThat(record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_FINISHED_COUNT))
+        .isEqualTo(1);
+    assertThat(record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_ROUNDTRIP_LATENCY))
+        .isEqualTo(roundtripLatencyMs);
+    assertThat(record.getMetricAsLongOrFail(RpcMeasureConstants.GRPC_CLIENT_SENT_MESSAGES_PER_RPC))
+        .isEqualTo(outboundMessages);
+  }
+
+  private void assertRetryStatsRecorded(
+      int numRetries, int numTransparentRetries, long retryDelayMs) throws Exception {
+    MetricsRecord record = clientStatsRecorder.pollRecord(5, SECONDS);
+    assertThat(record.getMetricAsLongOrFail(RETRIES_PER_CALL)).isEqualTo(numRetries);
+    assertThat(record.getMetricAsLongOrFail(TRANSPARENT_RETRIES_PER_CALL))
+        .isEqualTo(numTransparentRetries);
+    assertThat(record.getMetricAsLongOrFail(RETRY_DELAY_PER_CALL)).isEqualTo(retryDelayMs);
+  }
+
+  @Test
+  public void retryUntilBufferLimitExceeded() throws Exception {
+    String message = "String of length 20.";
+
+    startNewServer();
+    bufferLimit = message.length() * 2L - 1; // Can buffer no more than 1 message.
+    retryPolicy = ImmutableMap.<String, Object>builder()
+        .put("maxAttempts", 4D)
+        .put("initialBackoff", "10s")
+        .put("maxBackoff", "10s")
+        .put("backoffMultiplier", 1D)
+        .put("retryableStatusCodes", Arrays.<Object>asList("UNAVAILABLE"))
+        .buildOrThrow();
+    createNewChannel();
+    ClientCall<String, Integer> call = channel.newCall(clientStreamingMethod, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
+    call.sendMessage(message);
+
+    ServerCall<String, Integer> serverCall = serverCalls.poll(5, SECONDS);
+    serverCall.request(2);
+    // trigger retry
+    serverCall.close(
+        Status.UNAVAILABLE.withDescription("original attempt failed"),
+        new Metadata());
+    elapseBackoff(12, SECONDS);
+    // 2nd attempt received
+    serverCall = serverCalls.poll(5, SECONDS);
+    serverCall.request(2);
+    verify(mockCallListener, never()).onClose(any(Status.class), any(Metadata.class));
+    // send one more message, should exceed buffer limit
+    call.sendMessage(message);
+
+    // let attempt fail
+    testCallListener.clear();
+    serverCall.close(
+        Status.UNAVAILABLE.withDescription("2nd attempt failed"),
+        new Metadata());
+    // no more retry
+    testCallListener.verifyDescription("2nd attempt failed", 5000);
+  }
+
+  @Test
+  public void statsRecorded() throws Exception {
+    startNewServer();
+    retryPolicy = ImmutableMap.<String, Object>builder()
+        .put("maxAttempts", 4D)
+        .put("initialBackoff", "10s")
+        .put("maxBackoff", "10s")
+        .put("backoffMultiplier", 1D)
+        .put("retryableStatusCodes", Arrays.<Object>asList("UNAVAILABLE"))
+        .buildOrThrow();
+    createNewChannel();
+
+    ClientCall<String, Integer> call = channel.newCall(clientStreamingMethod, CallOptions.DEFAULT);
+    call.start(mockCallListener, new Metadata());
+    assertRpcStartedRecorded();
+    String message = "String of length 20.";
+    call.sendMessage(message);
+    assertOutboundMessageRecorded();
+    ServerCall<String, Integer> serverCall = serverCalls.poll(5, SECONDS);
+    serverCall.request(2);
+    assertOutboundWireSizeRecorded(message.length());
+    // original attempt latency
+    fakeClock.forwardTime(1, SECONDS);
+    // trigger retry
+    serverCall.close(
+        Status.UNAVAILABLE.withDescription("original attempt failed"),
+        new Metadata());
+    assertRpcStatusRecorded(Status.Code.UNAVAILABLE, 1000, 1);
+    elapseBackoff(12, SECONDS);
+    assertRpcStartedRecorded();
+    assertOutboundMessageRecorded();
+    serverCall = serverCalls.poll(5, SECONDS);
+    serverCall.request(2);
+    assertOutboundWireSizeRecorded(message.length());
+    message = "new message";
+    call.sendMessage(message);
+    assertOutboundMessageRecorded();
+    assertOutboundWireSizeRecorded(message.length());
+    // retry attempt latency
+    fakeClock.forwardTime(2, SECONDS);
+    serverCall.sendHeaders(new Metadata());
+    serverCall.sendMessage(3);
+    serverCall.close(Status.OK, new Metadata());
+    call.request(1);
+    assertInboundMessageRecorded();
+    assertInboundWireSizeRecorded(1);
+    assertRpcStatusRecorded(Status.Code.OK, 14000, 2);
+    assertRetryStatsRecorded(1, 0, 0);
+  }
+
+  @Test
+  public void statsRecorde_callCancelledBeforeCommit() throws Exception {
+    startNewServer();
+    retryPolicy = ImmutableMap.<String, Object>builder()
+        .put("maxAttempts", 4D)
+        .put("initialBackoff", "10s")
+        .put("maxBackoff", "10s")
+        .put("backoffMultiplier", 1D)
+        .put("retryableStatusCodes", Arrays.<Object>asList("UNAVAILABLE"))
+        .buildOrThrow();
+    createNewChannel();
+
+    // We will have streamClosed return at a particular moment that we want.
+    final CountDownLatch streamClosedLatch = new CountDownLatch(1);
+    ClientStreamTracer.Factory streamTracerFactory = new ClientStreamTracer.Factory() {
+      @Override
+      public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+        return new ClientStreamTracer() {
+          @Override
+          public void streamClosed(Status status) {
+            if (status.getCode().equals(Code.CANCELLED)) {
+              try {
+                streamClosedLatch.await();
+              } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                throw new AssertionError("streamClosedLatch interrupted", e);
+              }
+            }
+          }
+        };
+      }
+    };
+    ClientCall<String, Integer> call = channel.newCall(
+        clientStreamingMethod, CallOptions.DEFAULT.withStreamTracerFactory(streamTracerFactory));
+    call.start(mockCallListener, new Metadata());
+    assertRpcStartedRecorded();
+    fakeClock.forwardTime(5, SECONDS);
+    String message = "String of length 20.";
+    call.sendMessage(message);
+    assertOutboundMessageRecorded();
+    ServerCall<String, Integer> serverCall = serverCalls.poll(5, SECONDS);
+    serverCall.request(2);
+    assertOutboundWireSizeRecorded(message.length());
+    // trigger retry
+    serverCall.close(
+        Status.UNAVAILABLE.withDescription("original attempt failed"),
+        new Metadata());
+    assertRpcStatusRecorded(Code.UNAVAILABLE, 5000, 1);
+    elapseBackoff(12, SECONDS);
+    assertRpcStartedRecorded();
+    assertOutboundMessageRecorded();
+    serverCall = serverCalls.poll(5, SECONDS);
+    serverCall.request(2);
+    assertOutboundWireSizeRecorded(message.length());
+    fakeClock.forwardTime(7, SECONDS);
+    // A noop substream will commit. But call is not yet closed.
+    call.cancel("Cancelled before commit", null);
+    // Let the netty substream listener be closed.
+    streamClosedLatch.countDown();
+    // The call listener is closed.
+    verify(mockCallListener, timeout(5000)).onClose(any(Status.class), any(Metadata.class));
+    assertRpcStatusRecorded(Code.CANCELLED, 19_000, 1);
+    assertRetryStatsRecorded(1, 0, 0);
+  }
+
+  @Test
+  public void serverCancelledAndClientDeadlineExceeded() throws Exception {
+    startNewServer();
+    createNewChannel();
+
+    class CloseDelayedTracer extends ClientStreamTracer {
+      @Override
+      public void streamClosed(Status status) {
+        fakeClock.forwardTime(10, SECONDS);
+      }
+    }
+
+    class CloseDelayedTracerFactory extends ClientStreamTracer.Factory {
+      @Override
+      public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+        return new CloseDelayedTracer();
+      }
+    }
+
+    CallOptions callOptions = CallOptions.DEFAULT
+        .withDeadline(Deadline.after(
+            10,
+            SECONDS,
+            new Ticker() {
+              @Override
+              public long nanoTime() {
+                return fakeClock.getTicker().read();
+              }
+            }))
+        .withStreamTracerFactory(new CloseDelayedTracerFactory());
+    ClientCall<String, Integer> call = channel.newCall(clientStreamingMethod, callOptions);
+    call.start(mockCallListener, new Metadata());
+    assertRpcStartedRecorded();
+    ServerCall<String, Integer> serverCall = serverCalls.poll(5, SECONDS);
+    serverCall.close(Status.CANCELLED, new Metadata());
+    assertRpcStatusRecorded(Code.DEADLINE_EXCEEDED, 10_000, 0);
+    assertRetryStatsRecorded(0, 0, 0);
+  }
+
+  @Test
+  public void transparentRetryStatsRecorded() throws Exception {
+    startNewServer();
+    createNewChannel();
+
+    final AtomicBoolean originalAttemptFailed = new AtomicBoolean();
+    class TransparentRetryTriggeringTracer extends ClientStreamTracer {
+
+      @Override
+      public void streamCreated(Attributes transportAttrs, Metadata metadata) {
+        if (originalAttemptFailed.get()) {
+          return;
+        }
+        // Send GOAWAY from server. The client may either receive GOAWAY or create the underlying
+        // netty stream and write headers first, even we await server termination as below.
+        // In the latter case, we rerun the test. We can also call localServer.shutdown() to trigger
+        // GOAWAY, but it takes a lot longer time to gracefully shut down.
+        localServer.shutdownNow();
+        try {
+          localServer.awaitTermination();
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+          throw new AssertionError(e);
+        }
+      }
+
+      @Override
+      public void streamClosed(Status status) {
+        if (originalAttemptFailed.get()) {
+          return;
+        }
+        originalAttemptFailed.set(true);
+        try {
+          startNewServer();
+          channel.resetConnectBackoff();
+        } catch (Exception e) {
+          throw new AssertionError("local server can not be restarted", e);
+        }
+      }
+    }
+
+    class TransparentRetryTracerFactory extends ClientStreamTracer.Factory {
+      @Override
+      public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+        return new TransparentRetryTriggeringTracer();
+      }
+    }
+
+    CallOptions callOptions = CallOptions.DEFAULT
+        .withWaitForReady()
+        .withStreamTracerFactory(new TransparentRetryTracerFactory());
+    while (true) {
+      ClientCall<String, Integer> call = channel.newCall(clientStreamingMethod, callOptions);
+      call.start(mockCallListener, new Metadata());
+      assertRpcStartedRecorded(); // original attempt
+      MetricsRecord record = clientStatsRecorder.pollRecord(5, SECONDS);
+      assertThat(record.getMetricAsLongOrFail(DeprecatedCensusConstants.RPC_CLIENT_FINISHED_COUNT))
+          .isEqualTo(1);
+      TagValue statusTag = record.tags.get(RpcMeasureConstants.GRPC_CLIENT_STATUS);
+      if (statusTag.asString().equals(Code.UNAVAILABLE.toString())) {
+        break;
+      } else {
+        // Due to race condition, GOAWAY is not received/processed before the stream is closed due
+        // to connection error. Rerun the test.
+        assertThat(statusTag.asString()).isEqualTo(Code.UNKNOWN.toString());
+        assertRetryStatsRecorded(0, 0, 0);
+        originalAttemptFailed.set(false);
+      }
+    }
+    assertRpcStartedRecorded(); // retry attempt
+    ServerCall<String, Integer> serverCall = serverCalls.poll(5, SECONDS);
+    serverCall.close(Status.INVALID_ARGUMENT, new Metadata());
+    assertRpcStatusRecorded(Code.INVALID_ARGUMENT, 0, 0);
+    assertRetryStatsRecorded(0, 1, 0);
+  }
+
+  private static class TestListener extends ClientCall.Listener<Integer> {
+    Status status = null;
+    private CountDownLatch closeLatch = new CountDownLatch(1);
+
+    @Override
+    public void onClose(Status status, Metadata trailers) {
+      this.status = status;
+      closeLatch.countDown();
+    }
+
+    void clear() {
+      status = null;
+      closeLatch = new CountDownLatch(1);
+    }
+
+    void verifyDescription(String description, long timeoutMs) throws InterruptedException {
+      closeLatch.await(timeoutMs, TimeUnit.MILLISECONDS);
+      assertNotNull(status);
+      assertThat(status.getDescription()).contains(description);
+    }
+  }
+}
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/RpcBehaviorLoadBalancerProviderTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/RpcBehaviorLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..f17ea059211
--- /dev/null
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/RpcBehaviorLoadBalancerProviderTest.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2022 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.testing.integration;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ConnectivityState;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.internal.PickSubchannelArgsImpl;
+import io.grpc.testing.TestMethodDescriptors;
+import io.grpc.testing.integration.RpcBehaviorLoadBalancerProvider.RpcBehaviorConfig;
+import io.grpc.testing.integration.RpcBehaviorLoadBalancerProvider.RpcBehaviorHelper;
+import io.grpc.testing.integration.RpcBehaviorLoadBalancerProvider.RpcBehaviorLoadBalancer;
+import io.grpc.testing.integration.RpcBehaviorLoadBalancerProvider.RpcBehaviorPicker;
+import java.net.SocketAddress;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Unit tests for {@link RpcBehaviorLoadBalancerProvider}.
+ */
+@RunWith(JUnit4.class)
+public class RpcBehaviorLoadBalancerProviderTest {
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock
+  private LoadBalancer mockDelegateLb;
+
+  @Mock
+  private Helper mockHelper;
+
+  @Mock
+  private SubchannelPicker mockPicker;
+
+  @Test
+  public void parseValidConfig() {
+    assertThat(buildConfig().rpcBehavior).isEqualTo("error-code-15");
+  }
+
+  @Test
+  public void parseInvalidConfig() {
+    Status status = new RpcBehaviorLoadBalancerProvider().parseLoadBalancingPolicyConfig(
+            ImmutableMap.of("foo", "bar")).getError();
+    assertThat(status.getDescription()).contains("rpcBehavior");
+  }
+
+  @Test
+  public void handleResolvedAddressesDelegated() {
+    RpcBehaviorLoadBalancer lb = new RpcBehaviorLoadBalancer(new RpcBehaviorHelper(mockHelper),
+        mockDelegateLb);
+    ResolvedAddresses resolvedAddresses = buildResolvedAddresses(buildConfig());
+    lb.handleResolvedAddresses(resolvedAddresses);
+    verify(mockDelegateLb).handleResolvedAddresses(resolvedAddresses);
+  }
+
+  @Test
+  public void acceptResolvedAddressesDelegated() {
+    RpcBehaviorLoadBalancer lb = new RpcBehaviorLoadBalancer(new RpcBehaviorHelper(mockHelper),
+        mockDelegateLb);
+    ResolvedAddresses resolvedAddresses = buildResolvedAddresses(buildConfig());
+    lb.acceptResolvedAddresses(resolvedAddresses);
+    verify(mockDelegateLb).acceptResolvedAddresses(resolvedAddresses);
+  }
+
+  @Test
+  public void helperWrapsPicker() {
+    RpcBehaviorHelper helper = new RpcBehaviorHelper(mockHelper);
+    helper.setRpcBehavior("error-code-15");
+    helper.updateBalancingState(ConnectivityState.READY, mockPicker);
+
+    verify(mockHelper).updateBalancingState(eq(ConnectivityState.READY),
+        isA(RpcBehaviorPicker.class));
+  }
+
+  @Test
+  public void pickerAddsRpcBehaviorMetadata() {
+    PickSubchannelArgsImpl args = new PickSubchannelArgsImpl(TestMethodDescriptors.voidMethod(),
+        new Metadata(), CallOptions.DEFAULT, new LoadBalancer.PickDetailsConsumer() {});
+    new RpcBehaviorPicker(mockPicker, "error-code-15").pickSubchannel(args);
+
+    assertThat(args.getHeaders()
+        .get(Metadata.Key.of("rpc-behavior", Metadata.ASCII_STRING_MARSHALLER))).isEqualTo(
+        "error-code-15");
+  }
+
+  private RpcBehaviorConfig buildConfig() {
+    RpcBehaviorConfig config = (RpcBehaviorConfig) new RpcBehaviorLoadBalancerProvider()
+        .parseLoadBalancingPolicyConfig(
+            ImmutableMap.of("rpcBehavior", "error-code-15")).getConfig();
+    return config;
+  }
+
+  private ResolvedAddresses buildResolvedAddresses(RpcBehaviorConfig config) {
+    ResolvedAddresses resolvedAddresses = ResolvedAddresses.newBuilder()
+        .setLoadBalancingPolicyConfig(config)
+        .setAddresses(ImmutableList.of(
+            new EquivalentAddressGroup(new SocketAddress() {
+            })))
+        .setAttributes(Attributes.newBuilder().build()).build();
+    return resolvedAddresses;
+  }
+}
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/StressTestClientTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/StressTestClientTest.java
index 4e6000cbf4a..a1a2cb9b5ea 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/StressTestClientTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/StressTestClientTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
@@ -34,11 +19,13 @@
 import static com.google.common.collect.Sets.newHashSet;
 import static java.util.Collections.singletonList;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 
 import com.google.common.collect.ImmutableList;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
 import io.grpc.ManagedChannel;
-import io.grpc.ManagedChannelBuilder;
 import io.grpc.testing.integration.Metrics.EmptyMessage;
 import io.grpc.testing.integration.Metrics.GaugeResponse;
 import io.grpc.testing.integration.StressTestClient.TestCaseWeightPair;
@@ -46,9 +33,9 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Set;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.locks.LockSupport;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.Timeout;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
@@ -56,11 +43,14 @@
 @RunWith(JUnit4.class)
 public class StressTestClientTest {
 
+  @Rule
+  public final Timeout globalTimeout = Timeout.seconds(15);
+
   @Test
   public void ipv6AddressesShouldBeSupported() {
     StressTestClient client = new StressTestClient();
-    client.parseArgs(new String[] {"--server_addresses=[0:0:0:0:0:0:0:1]:8080,"
-        + "[1:2:3:4:f:e:a:b]:8083"});
+    client.parseArgs(new String[] {
+        "--server_addresses=[0:0:0:0:0:0:0:1]:8080,[1:2:3:4:f:e:a:b]:8083"});
 
     assertEquals(2, client.addresses().size());
     assertEquals(new InetSocketAddress("0:0:0:0:0:0:0:1", 8080), client.addresses().get(0));
@@ -76,6 +66,8 @@ public void defaults() {
     assertEquals(1, client.channelsPerServer());
     assertEquals(1, client.stubsPerChannel());
     assertEquals(8081, client.metricsPort());
+    assertEquals(-1, client.metricsLogRateSecs());
+    assertNull(client.customCredentialsType());
   }
 
   @Test
@@ -90,7 +82,9 @@ public void allCommandlineSwitchesAreSupported() {
         "--metrics_port=9090",
         "--server_host_override=foo.test.google.fr",
         "--use_tls=true",
-        "--use_test_ca=true"
+        "--use_test_ca=true",
+        "--custom_credentials_type=google_default_credentials",
+        "--metrics_log_rate_secs=60"
     });
 
     List<InetSocketAddress> addresses = Arrays.asList(new InetSocketAddress("localhost", 8080),
@@ -110,36 +104,30 @@ public void allCommandlineSwitchesAreSupported() {
     assertEquals(10, client.channelsPerServer());
     assertEquals(5, client.stubsPerChannel());
     assertEquals(9090, client.metricsPort());
+    assertEquals("google_default_credentials", client.customCredentialsType());
+    assertEquals(60, client.metricsLogRateSecs());
   }
 
   @Test
-  public void serverHostOverrideShouldBeApplied() {
-    StressTestClient client = new StressTestClient();
-    client.parseArgs(new String[] {
-        "--server_addresses=localhost:8080",
-        "--server_host_override=foo.test.google.fr",
-    });
-
-    assertEquals("foo.test.google.fr", client.addresses().get(0).getHostName());
-  }
-
-  @Test(timeout = 5000)
   public void gaugesShouldBeExported() throws Exception {
 
     TestServiceServer server = new TestServiceServer();
-    server.parseArgs(new String[]{"--port=" + 0, "--use_tls=false"});
+    server.parseArgs(new String[]{"--port=" + 0, "--use_tls=true"});
     server.start();
 
     StressTestClient client = new StressTestClient();
     client.parseArgs(new String[] {"--test_cases=empty_unary:1",
         "--server_addresses=localhost:" + server.getPort(), "--metrics_port=" + 0,
+        "--server_host_override=foo.test.google.fr",
+        "--use_tls=true",
+        "--use_test_ca=true",
         "--num_stubs_per_channel=2"});
     client.startMetricsService();
     client.runStressTest();
 
     // Connect to the metrics service
-    ManagedChannel ch = ManagedChannelBuilder.forAddress("localhost", client.getMetricServerPort())
-        .usePlaintext(true)
+    ManagedChannel ch = Grpc.newChannelBuilder(
+          "localhost:" + client.getMetricServerPort(), InsecureChannelCredentials.create())
         .build();
 
     MetricsServiceGrpc.MetricsServiceBlockingStub stub = MetricsServiceGrpc.newBlockingStub(ch);
@@ -151,7 +139,7 @@ public void gaugesShouldBeExported() throws Exception {
     List<GaugeResponse> allGauges =
         ImmutableList.copyOf(stub.getAllGauges(EmptyMessage.getDefaultInstance()));
     while (allGauges.size() < gaugeNames.size()) {
-      LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(100));
+      Thread.sleep(100);
       allGauges = ImmutableList.copyOf(stub.getAllGauges(EmptyMessage.getDefaultInstance()));
     }
 
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/TestCasesTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/TestCasesTest.java
index fc4759265db..ab32d584e7c 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/TestCasesTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/TestCasesTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
@@ -54,18 +39,56 @@ public void unknownStringThrowsException() {
   @Test
   public void testCaseNamesShouldMapToEnums() {
     // names of testcases as defined in the interop spec
-    String[] testCases = {"empty_unary", "large_unary", "client_streaming", "server_streaming",
-      "ping_pong", "empty_stream", "compute_engine_creds", "service_account_creds",
-      "jwt_token_creds", "oauth2_auth_token", "per_rpc_creds", "custom_metadata",
-      "status_code_and_message", "unimplemented_method", "unimplemented_service",
-      "cancel_after_begin", "cancel_after_first_response", "timeout_on_sleeping_server"};
+    String[] testCases = {
+      "empty_unary",
+      "cacheable_unary",
+      "large_unary",
+      "client_compressed_unary",
+      "server_compressed_unary",
+      "client_streaming",
+      "client_compressed_streaming",
+      "compute_engine_channel_credentials",
+      "server_streaming",
+      "server_compressed_streaming",
+      "ping_pong",
+      "empty_stream",
+      "compute_engine_creds",
+      "service_account_creds",
+      "jwt_token_creds",
+      "oauth2_auth_token",
+      "per_rpc_creds",
+      "google_default_credentials",
+      "custom_metadata",
+      "status_code_and_message",
+      "special_status_message",
+      "unimplemented_method",
+      "unimplemented_service",
+      "cancel_after_begin",
+      "cancel_after_first_response",
+      "timeout_on_sleeping_server",
+      "orca_per_rpc",
+      "orca_oob"
+    };
+
+    // additional test cases
+    String[] additionalTestCases = {
+      "client_compressed_unary_noprobe",
+      "client_compressed_streaming_noprobe",
+      "very_large_request",
+      "pick_first_unary",
+      "channel_soak",
+      "rpc_soak"
+    };
 
-    assertEquals(testCases.length, TestCases.values().length);
+    assertEquals(testCases.length + additionalTestCases.length, TestCases.values().length);
 
-    Set<TestCases> testCaseSet = new HashSet<TestCases>(testCases.length);
+    Set<TestCases> testCaseSet = new HashSet<>(testCases.length);
     for (String testCase : testCases) {
       testCaseSet.add(TestCases.fromString(testCase));
     }
+    for (String testCase : additionalTestCases) {
+      testCaseSet.add(TestCases.fromString(testCase));
+    }
 
     assertEquals(TestCases.values().length, testCaseSet.size());
   }
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/TestServiceClientTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/TestServiceClientTest.java
new file mode 100644
index 00000000000..b9ed63d5a52
--- /dev/null
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/TestServiceClientTest.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2017 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.testing.integration;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link TestServiceClient}. */
+@RunWith(JUnit4.class)
+public class TestServiceClientTest {
+
+  @Test
+  public void emptyArgumentListShouldNotThrowException() throws Exception {
+    TestServiceClient client = new TestServiceClient();
+    client.parseArgs(new String[0]);
+    client.setUp();
+  }
+}
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/TlsTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/TlsTest.java
deleted file mode 100644
index 9163943565f..00000000000
--- a/interop-testing/src/test/java/io/grpc/testing/integration/TlsTest.java
+++ /dev/null
@@ -1,316 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.testing.integration;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-
-import com.google.common.base.Throwables;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.google.protobuf.EmptyProtos.Empty;
-import io.grpc.ManagedChannel;
-import io.grpc.Server;
-import io.grpc.ServerBuilder;
-import io.grpc.Status;
-import io.grpc.StatusRuntimeException;
-import io.grpc.netty.GrpcSslContexts;
-import io.grpc.netty.NegotiationType;
-import io.grpc.netty.NettyChannelBuilder;
-import io.grpc.netty.NettyServerBuilder;
-import io.grpc.testing.TestUtils;
-import io.netty.handler.ssl.ClientAuth;
-import io.netty.handler.ssl.OpenSsl;
-import io.netty.handler.ssl.SslContext;
-import io.netty.handler.ssl.SslContextBuilder;
-import io.netty.handler.ssl.SslProvider;
-import java.io.File;
-import java.io.IOException;
-import java.security.NoSuchAlgorithmException;
-import java.security.cert.X509Certificate;
-import java.util.Arrays;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-import javax.net.ssl.SSLContext;
-import org.junit.After;
-import org.junit.Assume;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
-
-
-/**
- * Integration tests for GRPC's TLS support.
- */
-@RunWith(Parameterized.class)
-public class TlsTest {
-
-  /**
-   * Iterable of various configurations to use for tests.
-   */
-  @Parameters(name = "{0}")
-  public static Iterable<Object[]> data() {
-    return Arrays.asList(new Object[][] {
-      {SslProvider.JDK}, {SslProvider.OPENSSL},
-    });
-  }
-
-  @Parameter(value = 0)
-  public SslProvider sslProvider;
-
-  private ScheduledExecutorService executor;
-  private Server server;
-  private ManagedChannel channel;
-  private SslContextBuilder clientContextBuilder;
-
-  @Before
-  public void setUp() throws NoSuchAlgorithmException {
-    executor = Executors.newSingleThreadScheduledExecutor();
-    if (sslProvider == SslProvider.OPENSSL) {
-      Assume.assumeTrue(OpenSsl.isAvailable());
-    }
-    if (sslProvider == SslProvider.JDK) {
-      Assume.assumeTrue(Arrays.asList(
-          SSLContext.getDefault().getSupportedSSLParameters().getCipherSuites())
-          .contains("TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"));
-
-    }
-    clientContextBuilder = GrpcSslContexts.configure(SslContextBuilder.forClient(), sslProvider);
-  }
-
-  @After
-  public void tearDown() {
-    if (server != null) {
-      server.shutdown();
-    }
-    if (channel != null) {
-      channel.shutdown();
-    }
-    MoreExecutors.shutdownAndAwaitTermination(executor, 5, TimeUnit.SECONDS);
-  }
-
-
-  /**
-   * Tests that a client and a server configured using GrpcSslContexts can successfully
-   * communicate with each other.
-   */
-  @Test
-  public void basicClientServerIntegrationTest() throws Exception {
-    // Create & start a server.
-    File serverCertFile = TestUtils.loadCert("server1.pem");
-    File serverPrivateKeyFile = TestUtils.loadCert("server1.key");
-    X509Certificate[] serverTrustedCaCerts = {
-      TestUtils.loadX509Cert("ca.pem")
-    };
-    server = serverBuilder(0, serverCertFile, serverPrivateKeyFile, serverTrustedCaCerts)
-        .addService(new TestServiceImpl(executor))
-        .build()
-        .start();
-
-    // Create a client.
-    File clientCertChainFile = TestUtils.loadCert("client.pem");
-    File clientPrivateKeyFile = TestUtils.loadCert("client.key");
-    X509Certificate[] clientTrustedCaCerts = {
-      TestUtils.loadX509Cert("ca.pem")
-    };
-    channel = clientChannel(server.getPort(), clientContextBuilder
-        .keyManager(clientCertChainFile, clientPrivateKeyFile)
-        .trustManager(clientTrustedCaCerts)
-        .build());
-    TestServiceGrpc.TestServiceBlockingStub client = TestServiceGrpc.newBlockingStub(channel);
-
-    // Send an actual request, via the full GRPC & network stack, and check that a proper
-    // response comes back.
-    Empty request = Empty.getDefaultInstance();
-    client.emptyCall(request);
-  }
-
-
-  /**
-   * Tests that a server configured to require client authentication refuses to accept connections
-   * from a client that has an untrusted certificate.
-   */
-  @Test
-  public void serverRejectsUntrustedClientCert() throws Exception {
-    // Create & start a server. It requires client authentication and trusts only the test CA.
-    File serverCertFile = TestUtils.loadCert("server1.pem");
-    File serverPrivateKeyFile = TestUtils.loadCert("server1.key");
-    X509Certificate[] serverTrustedCaCerts = {
-      TestUtils.loadX509Cert("ca.pem")
-    };
-    server = serverBuilder(0, serverCertFile, serverPrivateKeyFile, serverTrustedCaCerts)
-        .addService(new TestServiceImpl(executor))
-        .build()
-        .start();
-
-    // Create a client. Its credentials come from a CA that the server does not trust. The client
-    // trusts both test CAs, so we can be sure that the handshake failure is due to the server
-    // rejecting the client's cert, not the client rejecting the server's cert.
-    File clientCertChainFile = TestUtils.loadCert("badclient.pem");
-    File clientPrivateKeyFile = TestUtils.loadCert("badclient.key");
-    X509Certificate[] clientTrustedCaCerts = {
-      TestUtils.loadX509Cert("ca.pem")
-    };
-    channel = clientChannel(server.getPort(), clientContextBuilder
-        .keyManager(clientCertChainFile, clientPrivateKeyFile)
-        .trustManager(clientTrustedCaCerts)
-        .build());
-    TestServiceGrpc.TestServiceBlockingStub client = TestServiceGrpc.newBlockingStub(channel);
-
-    // Check that the TLS handshake fails.
-    Empty request = Empty.getDefaultInstance();
-    try {
-      client.emptyCall(request);
-      fail("TLS handshake should have failed, but didn't; received RPC response");
-    } catch (StatusRuntimeException e) {
-      // GRPC reports this situation by throwing a StatusRuntimeException that wraps either a
-      // javax.net.ssl.SSLHandshakeException or a java.nio.channels.ClosedChannelException.
-      // Thus, reliably detecting the underlying cause is not feasible.
-      assertEquals(
-          Throwables.getStackTraceAsString(e),
-          Status.Code.UNAVAILABLE, e.getStatus().getCode());
-    }
-  }
-
-
-  /**
-   * Tests that a server configured to require client authentication actually does require client
-   * authentication.
-   */
-  @Test
-  public void noClientAuthFailure() throws Exception {
-    // Create & start a server.
-    File serverCertFile = TestUtils.loadCert("server1.pem");
-    File serverPrivateKeyFile = TestUtils.loadCert("server1.key");
-    X509Certificate[] serverTrustedCaCerts = {
-      TestUtils.loadX509Cert("ca.pem")
-    };
-    server = serverBuilder(0, serverCertFile, serverPrivateKeyFile, serverTrustedCaCerts)
-        .addService(new TestServiceImpl(executor))
-        .build()
-        .start();
-
-    // Create a client. It has no credentials.
-    X509Certificate[] clientTrustedCaCerts = {
-      TestUtils.loadX509Cert("ca.pem")
-    };
-    channel = clientChannel(server.getPort(), clientContextBuilder
-        .trustManager(clientTrustedCaCerts)
-        .build());
-    TestServiceGrpc.TestServiceBlockingStub client = TestServiceGrpc.newBlockingStub(channel);
-
-    // Check that the TLS handshake fails.
-    Empty request = Empty.getDefaultInstance();
-    try {
-      client.emptyCall(request);
-      fail("TLS handshake should have failed, but didn't; received RPC response");
-    } catch (StatusRuntimeException e) {
-      // GRPC reports this situation by throwing a StatusRuntimeException that wraps either a
-      // javax.net.ssl.SSLHandshakeException or a java.nio.channels.ClosedChannelException.
-      // Thus, reliably detecting the underlying cause is not feasible.
-      assertEquals(
-          Throwables.getStackTraceAsString(e),
-          Status.Code.UNAVAILABLE, e.getStatus().getCode());
-    }
-  }
-
-
-  /**
-   * Tests that a client configured using GrpcSslContexts refuses to talk to a server that has an
-   * an untrusted certificate.
-   */
-  @Test
-  public void clientRejectsUntrustedServerCert() throws Exception {
-    // Create & start a server.
-    File serverCertFile = TestUtils.loadCert("badserver.pem");
-    File serverPrivateKeyFile = TestUtils.loadCert("badserver.key");
-    X509Certificate[] serverTrustedCaCerts = {
-      TestUtils.loadX509Cert("ca.pem")
-    };
-    server = serverBuilder(0, serverCertFile, serverPrivateKeyFile, serverTrustedCaCerts)
-        .addService(new TestServiceImpl(executor))
-        .build()
-        .start();
-
-    // Create a client.
-    File clientCertChainFile = TestUtils.loadCert("client.pem");
-    File clientPrivateKeyFile = TestUtils.loadCert("client.key");
-    X509Certificate[] clientTrustedCaCerts = {
-      TestUtils.loadX509Cert("ca.pem")
-    };
-    channel = clientChannel(server.getPort(), clientContextBuilder
-        .keyManager(clientCertChainFile, clientPrivateKeyFile)
-        .trustManager(clientTrustedCaCerts)
-        .build());
-    TestServiceGrpc.TestServiceBlockingStub client = TestServiceGrpc.newBlockingStub(channel);
-
-    // Check that the TLS handshake fails.
-    Empty request = Empty.getDefaultInstance();
-    try {
-      client.emptyCall(request);
-      fail("TLS handshake should have failed, but didn't; received RPC response");
-    } catch (StatusRuntimeException e) {
-      // GRPC reports this situation by throwing a StatusRuntimeException that wraps either a
-      // javax.net.ssl.SSLHandshakeException or a java.nio.channels.ClosedChannelException.
-      // Thus, reliably detecting the underlying cause is not feasible.
-      // TODO(carl-mastrangelo): eventually replace this with a hamcrest matcher.
-      assertEquals(
-          Throwables.getStackTraceAsString(e),
-          Status.Code.UNAVAILABLE, e.getStatus().getCode());
-    }
-  }
-
-
-  private ServerBuilder<?> serverBuilder(int port, File serverCertChainFile,
-      File serverPrivateKeyFile, X509Certificate[] serverTrustedCaCerts) throws IOException {
-    SslContextBuilder sslContextBuilder
-        = SslContextBuilder.forServer(serverCertChainFile, serverPrivateKeyFile);
-    GrpcSslContexts.configure(sslContextBuilder, sslProvider);
-    sslContextBuilder.trustManager(serverTrustedCaCerts)
-        .clientAuth(ClientAuth.REQUIRE);
-
-    return NettyServerBuilder.forPort(port)
-        .sslContext(sslContextBuilder.build());
-  }
-
-
-  private static ManagedChannel clientChannel(int port, SslContext sslContext) throws IOException {
-    return NettyChannelBuilder.forAddress("localhost", port)
-        .overrideAuthority(TestUtils.TEST_SERVER_HOST)
-        .negotiationType(NegotiationType.TLS)
-        .sslContext(sslContext)
-        .build();
-  }
-}
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/TrafficControlProxy.java b/interop-testing/src/test/java/io/grpc/testing/integration/TrafficControlProxy.java
index 62927d367c6..a93d51628e4 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/TrafficControlProxy.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/TrafficControlProxy.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
@@ -66,7 +51,7 @@ public final class TrafficControlProxy {
   private Socket serverSock;
   private Socket clientSock;
   private final ThreadPoolExecutor executor =
-      new ThreadPoolExecutor(5, 10, 1, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(),
+      new ThreadPoolExecutor(5, 5, 1, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(),
           new DefaultThreadFactory("proxy-pool", true));
 
   /**
@@ -201,7 +186,7 @@ private class MessageQueue {
     DataInputStream inStream;
     DataOutputStream outStream;
     int bytesQueued;
-    BlockingQueue<Message> queue = new DelayQueue<Message>();
+    BlockingQueue<Message> queue = new DelayQueue<>();
 
     MessageQueue(DataInputStream inputStream, DataOutputStream outputStream) {
       inStream = inputStream;
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/TransportCompressionTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/TransportCompressionTest.java
index 55a007e96bd..b9692383254 100644
--- a/interop-testing/src/test/java/io/grpc/testing/integration/TransportCompressionTest.java
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/TransportCompressionTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing.integration;
@@ -44,19 +29,21 @@
 import io.grpc.DecompressorRegistry;
 import io.grpc.ForwardingClientCall;
 import io.grpc.ForwardingClientCallListener;
-import io.grpc.ManagedChannel;
+import io.grpc.InsecureServerCredentials;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
+import io.grpc.ServerBuilder;
 import io.grpc.ServerCall;
 import io.grpc.ServerCall.Listener;
 import io.grpc.ServerCallHandler;
 import io.grpc.ServerInterceptor;
 import io.grpc.internal.GrpcUtil;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.InternalNettyServerBuilder;
 import io.grpc.netty.NettyChannelBuilder;
 import io.grpc.netty.NettyServerBuilder;
-import io.grpc.testing.integration.Messages.CompressionType;
+import io.grpc.testing.integration.Messages.BoolValue;
 import io.grpc.testing.integration.Messages.Payload;
-import io.grpc.testing.integration.Messages.PayloadType;
 import io.grpc.testing.integration.Messages.SimpleRequest;
 import io.grpc.testing.integration.Messages.SimpleResponse;
 import java.io.FilterInputStream;
@@ -64,7 +51,6 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -92,32 +78,31 @@ public void beforeTests() {
     FZIPPER.anyWritten = false;
   }
 
-  /** Start server. */
   @BeforeClass
-  public static void startServer() {
+  public static void registerCompressors() {
     compressors.register(FZIPPER);
     compressors.register(Codec.Identity.NONE);
-    startStaticServer(
-        NettyServerBuilder.forPort(0)
-            .maxMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
-            .compressorRegistry(compressors)
-            .decompressorRegistry(decompressors),
-        new ServerInterceptor() {
-          @Override
-          public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
-              Metadata headers, ServerCallHandler<ReqT, RespT> next) {
-            Listener<ReqT> listener = next.startCall(call, headers);
-            // TODO(carl-mastrangelo): check that encoding was set.
-            call.setMessageCompression(true);
-            return listener;
-          }
-        });
   }
 
-  /** Stop server. */
-  @AfterClass
-  public static void stopServer() {
-    stopStaticServer();
+  @Override
+  protected ServerBuilder<?> getServerBuilder() {
+    NettyServerBuilder builder = NettyServerBuilder.forPort(0, InsecureServerCredentials.create())
+        .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
+        .compressorRegistry(compressors)
+        .decompressorRegistry(decompressors)
+        .intercept(new ServerInterceptor() {
+            @Override
+            public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+                Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+              Listener<ReqT> listener = next.startCall(call, headers);
+              // TODO(carl-mastrangelo): check that encoding was set.
+              call.setMessageCompression(true);
+              return listener;
+            }
+          });
+    // Disable the default census stats tracer, use testing tracer instead.
+    InternalNettyServerBuilder.setStatsEnabled(builder, false);
+    return builder.addStreamTracerFactory(createCustomCensusTracerFactory());
   }
 
   @Test
@@ -125,14 +110,12 @@ public void compresses() {
     expectFzip = true;
     final SimpleRequest request = SimpleRequest.newBuilder()
         .setResponseSize(314159)
-        .setResponseCompression(CompressionType.GZIP)
-        .setResponseType(PayloadType.COMPRESSABLE)
+        .setResponseCompressed(BoolValue.newBuilder().setValue(true))
         .setPayload(Payload.newBuilder()
             .setBody(ByteString.copyFrom(new byte[271828])))
         .build();
     final SimpleResponse goldenResponse = SimpleResponse.newBuilder()
         .setPayload(Payload.newBuilder()
-            .setType(PayloadType.COMPRESSABLE)
             .setBody(ByteString.copyFrom(new byte[314159])))
         .build();
 
@@ -144,8 +127,8 @@ public void compresses() {
   }
 
   @Override
-  protected ManagedChannel createChannel() {
-    NettyChannelBuilder builder = NettyChannelBuilder.forAddress("localhost", getPort())
+  protected NettyChannelBuilder createChannelBuilder() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forAddress(getListenAddress())
         .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE)
         .decompressorRegistry(decompressors)
         .compressorRegistry(compressors)
@@ -186,9 +169,10 @@ public void onHeaders(Metadata headers) {
             };
           }
         })
-        .usePlaintext(true);
-    io.grpc.internal.TestingAccessor.setStatsContextFactory(builder, getClientStatsFactory());
-    return builder.build();
+        .usePlaintext();
+    // Disable the default census stats interceptor, use testing interceptor instead.
+    InternalNettyChannelBuilder.setStatsEnabled(builder, false);
+    return builder.intercept(createCensusStatsClientInterceptor());
   }
 
   /**
@@ -242,4 +226,3 @@ public int read(byte[] b, int off, int len) throws IOException {
     }
   }
 }
-
diff --git a/interop-testing/src/test/java/io/grpc/testing/integration/XdsTestServerTest.java b/interop-testing/src/test/java/io/grpc/testing/integration/XdsTestServerTest.java
new file mode 100644
index 00000000000..7bfa1a2cd7d
--- /dev/null
+++ b/interop-testing/src/test/java/io/grpc/testing/integration/XdsTestServerTest.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2024 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.testing.integration;
+
+import static org.junit.Assert.assertEquals;
+
+import io.grpc.Channel;
+import io.grpc.ChannelCredentials;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.testing.GrpcCleanupRule;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests to make sure that the {@link XdsTestServer} is working as expected.
+ * Specifically, that for dualstack communication is handled correctly across address families
+ * and that the test server is correctly handling the address_type flag.
+ */
+@RunWith(JUnit4.class)
+public class XdsTestServerTest {
+  protected static final EmptyProtos.Empty EMPTY = EmptyProtos.Empty.getDefaultInstance();
+
+  @Rule
+  public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+
+
+  @Test
+  public void check_ipv4() throws Exception {
+    checkConnectionWorks("127.0.0.1", "--address_type=IPV4");
+  }
+
+  @Test
+  public void check_ipv6() throws Exception {
+    checkConnectionWorks("::1", "--address_type=IPV6");
+  }
+
+  @Test
+  public void check_ipv4_ipv6() throws Exception {
+    checkConnectionWorks("localhost", "--address_type=IPV4_IPV6");
+  }
+
+  @Test
+  public void checkNoAddressType() throws Exception {
+    // This ensures that all of the other xds tests aren't broken by the address_type argument.
+    checkConnectionWorks("localhost", null);
+  }
+
+  // Simple test to ensure that communication with the server works which includes starting and
+  // stopping the server, creating a channel and doing a unary rpc.
+  private void checkConnectionWorks(String targetServer, String addressTypeArg)
+      throws Exception {
+
+    int port = Util.pickUnusedPort();
+
+    XdsTestServer server = getAndStartTestServiceServer(port, addressTypeArg);
+
+    try {
+      ManagedChannel realChannel = createChannel(port, targetServer);
+      Channel channel = cleanupRule.register(realChannel);
+      TestServiceGrpc.TestServiceBlockingStub stub = TestServiceGrpc.newBlockingStub(channel);
+
+      assertEquals(EMPTY, stub.emptyCall(EMPTY));
+    } catch (Exception e) {
+      throw new AssertionError(e);
+    } finally {
+      server.stop();
+    }
+  }
+
+  private static ManagedChannel createChannel(int port, String target) {
+    ChannelCredentials creds = InsecureChannelCredentials.create();
+
+    ManagedChannelBuilder<?> builder;
+    if (port == 0) {
+      builder = Grpc.newChannelBuilder(target, creds);
+    } else {
+      builder = Grpc.newChannelBuilderForAddress(target, port, creds);
+    }
+
+    builder.overrideAuthority("foo.test.google.fr");
+    return builder.build();
+  }
+
+  private static XdsTestServer getAndStartTestServiceServer(int port, String addressTypeArg)
+      throws Exception {
+    XdsTestServer server = new XdsTestServer();
+    String[] args = addressTypeArg != null
+        ? new String[]{"--port=" + port, addressTypeArg}
+        : new String[]{"--port=" + port};
+    server.parseArgs(args);
+    server.start();
+    return server;
+  }
+
+}
diff --git a/istio-interop-testing/build.gradle b/istio-interop-testing/build.gradle
new file mode 100644
index 00000000000..083d8fcb9bf
--- /dev/null
+++ b/istio-interop-testing/build.gradle
@@ -0,0 +1,66 @@
+plugins {
+    id "application"
+    id "java"
+
+    id "com.google.protobuf"
+    id 'com.google.cloud.tools.jib'
+    id "ru.vyarus.animalsniffer"
+}
+
+description = "gRPC: Istio Interop testing"
+
+dependencies {
+    implementation  project(':grpc-core'),
+            project(':grpc-netty'),
+            project(':grpc-protobuf'),
+            project(':grpc-services'),
+            project(':grpc-stub'),
+            project(':grpc-testing'),
+            project(':grpc-xds')
+
+    runtimeOnly libraries.netty.tcnative,
+            libraries.netty.tcnative.classes
+    testImplementation testFixtures(project(':grpc-api')),
+            testFixtures(project(':grpc-core')),
+            libraries.mockito.core,
+            libraries.junit,
+            libraries.truth
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+sourceSets {
+    main {
+        proto {
+            srcDir 'third_party/istio/src/main/proto'
+        }
+    }
+}
+
+configureProtoCompilation()
+
+import net.ltgt.gradle.errorprone.CheckSeverity
+
+tasks.named("compileJava").configure {
+    // This isn't a library; it can use beta APIs
+    options.errorprone.check("BetaApi", CheckSeverity.OFF)
+}
+
+
+// For releasing to Docker Hub
+jib {
+    from.image = "gcr.io/distroless/java17-debian12"
+    container {
+        ports = ['50051']
+        mainClass="io.grpc.testing.istio.EchoTestServer"
+    }
+    outputPaths {
+        tar = 'build/istio-echo-server.tar'
+        digest = 'build/istio-echo-server.digest'
+        imageId = 'build/istio-echo-server.id'
+    }
+}
diff --git a/istio-interop-testing/src/generated/main/grpc/io/istio/test/EchoTestServiceGrpc.java b/istio-interop-testing/src/generated/main/grpc/io/istio/test/EchoTestServiceGrpc.java
new file mode 100644
index 00000000000..61d20d2f7bb
--- /dev/null
+++ b/istio-interop-testing/src/generated/main/grpc/io/istio/test/EchoTestServiceGrpc.java
@@ -0,0 +1,410 @@
+package io.istio.test;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class EchoTestServiceGrpc {
+
+  private EchoTestServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "proto.EchoTestService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.istio.test.Echo.EchoRequest,
+      io.istio.test.Echo.EchoResponse> getEchoMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Echo",
+      requestType = io.istio.test.Echo.EchoRequest.class,
+      responseType = io.istio.test.Echo.EchoResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.istio.test.Echo.EchoRequest,
+      io.istio.test.Echo.EchoResponse> getEchoMethod() {
+    io.grpc.MethodDescriptor<io.istio.test.Echo.EchoRequest, io.istio.test.Echo.EchoResponse> getEchoMethod;
+    if ((getEchoMethod = EchoTestServiceGrpc.getEchoMethod) == null) {
+      synchronized (EchoTestServiceGrpc.class) {
+        if ((getEchoMethod = EchoTestServiceGrpc.getEchoMethod) == null) {
+          EchoTestServiceGrpc.getEchoMethod = getEchoMethod =
+              io.grpc.MethodDescriptor.<io.istio.test.Echo.EchoRequest, io.istio.test.Echo.EchoResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Echo"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.istio.test.Echo.EchoRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.istio.test.Echo.EchoResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new EchoTestServiceMethodDescriptorSupplier("Echo"))
+              .build();
+        }
+      }
+    }
+    return getEchoMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.istio.test.Echo.ForwardEchoRequest,
+      io.istio.test.Echo.ForwardEchoResponse> getForwardEchoMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "ForwardEcho",
+      requestType = io.istio.test.Echo.ForwardEchoRequest.class,
+      responseType = io.istio.test.Echo.ForwardEchoResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.istio.test.Echo.ForwardEchoRequest,
+      io.istio.test.Echo.ForwardEchoResponse> getForwardEchoMethod() {
+    io.grpc.MethodDescriptor<io.istio.test.Echo.ForwardEchoRequest, io.istio.test.Echo.ForwardEchoResponse> getForwardEchoMethod;
+    if ((getForwardEchoMethod = EchoTestServiceGrpc.getForwardEchoMethod) == null) {
+      synchronized (EchoTestServiceGrpc.class) {
+        if ((getForwardEchoMethod = EchoTestServiceGrpc.getForwardEchoMethod) == null) {
+          EchoTestServiceGrpc.getForwardEchoMethod = getForwardEchoMethod =
+              io.grpc.MethodDescriptor.<io.istio.test.Echo.ForwardEchoRequest, io.istio.test.Echo.ForwardEchoResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ForwardEcho"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.istio.test.Echo.ForwardEchoRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.istio.test.Echo.ForwardEchoResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new EchoTestServiceMethodDescriptorSupplier("ForwardEcho"))
+              .build();
+        }
+      }
+    }
+    return getForwardEchoMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static EchoTestServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<EchoTestServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<EchoTestServiceStub>() {
+        @java.lang.Override
+        public EchoTestServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new EchoTestServiceStub(channel, callOptions);
+        }
+      };
+    return EchoTestServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static EchoTestServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<EchoTestServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<EchoTestServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public EchoTestServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new EchoTestServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return EchoTestServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static EchoTestServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<EchoTestServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<EchoTestServiceBlockingStub>() {
+        @java.lang.Override
+        public EchoTestServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new EchoTestServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return EchoTestServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static EchoTestServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<EchoTestServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<EchoTestServiceFutureStub>() {
+        @java.lang.Override
+        public EchoTestServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new EchoTestServiceFutureStub(channel, callOptions);
+        }
+      };
+    return EchoTestServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public interface AsyncService {
+
+    /**
+     */
+    default void echo(io.istio.test.Echo.EchoRequest request,
+        io.grpc.stub.StreamObserver<io.istio.test.Echo.EchoResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getEchoMethod(), responseObserver);
+    }
+
+    /**
+     */
+    default void forwardEcho(io.istio.test.Echo.ForwardEchoRequest request,
+        io.grpc.stub.StreamObserver<io.istio.test.Echo.ForwardEchoResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getForwardEchoMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service EchoTestService.
+   */
+  public static abstract class EchoTestServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return EchoTestServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service EchoTestService.
+   */
+  public static final class EchoTestServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<EchoTestServiceStub> {
+    private EchoTestServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected EchoTestServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new EchoTestServiceStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public void echo(io.istio.test.Echo.EchoRequest request,
+        io.grpc.stub.StreamObserver<io.istio.test.Echo.EchoResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getEchoMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     */
+    public void forwardEcho(io.istio.test.Echo.ForwardEchoRequest request,
+        io.grpc.stub.StreamObserver<io.istio.test.Echo.ForwardEchoResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getForwardEchoMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service EchoTestService.
+   */
+  public static final class EchoTestServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<EchoTestServiceBlockingV2Stub> {
+    private EchoTestServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected EchoTestServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new EchoTestServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.istio.test.Echo.EchoResponse echo(io.istio.test.Echo.EchoRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getEchoMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.istio.test.Echo.ForwardEchoResponse forwardEcho(io.istio.test.Echo.ForwardEchoRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getForwardEchoMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service EchoTestService.
+   */
+  public static final class EchoTestServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<EchoTestServiceBlockingStub> {
+    private EchoTestServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected EchoTestServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new EchoTestServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.istio.test.Echo.EchoResponse echo(io.istio.test.Echo.EchoRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getEchoMethod(), getCallOptions(), request);
+    }
+
+    /**
+     */
+    public io.istio.test.Echo.ForwardEchoResponse forwardEcho(io.istio.test.Echo.ForwardEchoRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getForwardEchoMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service EchoTestService.
+   */
+  public static final class EchoTestServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<EchoTestServiceFutureStub> {
+    private EchoTestServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected EchoTestServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new EchoTestServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.istio.test.Echo.EchoResponse> echo(
+        io.istio.test.Echo.EchoRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getEchoMethod(), getCallOptions()), request);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.istio.test.Echo.ForwardEchoResponse> forwardEcho(
+        io.istio.test.Echo.ForwardEchoRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getForwardEchoMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_ECHO = 0;
+  private static final int METHODID_FORWARD_ECHO = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_ECHO:
+          serviceImpl.echo((io.istio.test.Echo.EchoRequest) request,
+              (io.grpc.stub.StreamObserver<io.istio.test.Echo.EchoResponse>) responseObserver);
+          break;
+        case METHODID_FORWARD_ECHO:
+          serviceImpl.forwardEcho((io.istio.test.Echo.ForwardEchoRequest) request,
+              (io.grpc.stub.StreamObserver<io.istio.test.Echo.ForwardEchoResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getEchoMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.istio.test.Echo.EchoRequest,
+              io.istio.test.Echo.EchoResponse>(
+                service, METHODID_ECHO)))
+        .addMethod(
+          getForwardEchoMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.istio.test.Echo.ForwardEchoRequest,
+              io.istio.test.Echo.ForwardEchoResponse>(
+                service, METHODID_FORWARD_ECHO)))
+        .build();
+  }
+
+  private static abstract class EchoTestServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    EchoTestServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.istio.test.Echo.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("EchoTestService");
+    }
+  }
+
+  private static final class EchoTestServiceFileDescriptorSupplier
+      extends EchoTestServiceBaseDescriptorSupplier {
+    EchoTestServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class EchoTestServiceMethodDescriptorSupplier
+      extends EchoTestServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    EchoTestServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (EchoTestServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new EchoTestServiceFileDescriptorSupplier())
+              .addMethod(getEchoMethod())
+              .addMethod(getForwardEchoMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/istio-interop-testing/src/main/java/io/grpc/testing/istio/EchoTestServer.java b/istio-interop-testing/src/main/java/io/grpc/testing/istio/EchoTestServer.java
new file mode 100644
index 00000000000..2c6ae38d41a
--- /dev/null
+++ b/istio-interop-testing/src/main/java/io/grpc/testing/istio/EchoTestServer.java
@@ -0,0 +1,502 @@
+/*
+ * Copyright 2022 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.testing.istio;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.CharMatcher;
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.ChannelCredentials;
+import io.grpc.Context;
+import io.grpc.Contexts;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Metadata;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerCredentials;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerInterceptors;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.TlsServerCredentials;
+import io.grpc.services.AdminInterface;
+import io.grpc.stub.MetadataUtils;
+import io.grpc.stub.StreamObserver;
+import io.grpc.xds.XdsChannelCredentials;
+import io.grpc.xds.XdsServerCredentials;
+import io.istio.test.Echo.EchoRequest;
+import io.istio.test.Echo.EchoResponse;
+import io.istio.test.Echo.ForwardEchoRequest;
+import io.istio.test.Echo.ForwardEchoResponse;
+import io.istio.test.Echo.Header;
+import io.istio.test.EchoTestServiceGrpc;
+import io.istio.test.EchoTestServiceGrpc.EchoTestServiceFutureStub;
+import io.istio.test.EchoTestServiceGrpc.EchoTestServiceImplBase;
+import java.io.File;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * This class implements the Istio echo server functionality similar to
+ * https://github.com/istio/istio/blob/master/pkg/test/echo/server/endpoint/grpc.go .
+ * Please see Istio framework docs https://github.com/istio/istio/wiki/Istio-Test-Framework .
+ */
+public final class EchoTestServer {
+
+  private static final Logger logger = Logger.getLogger(EchoTestServer.class.getName());
+
+  static final Context.Key<String> CLIENT_ADDRESS_CONTEXT_KEY =
+      Context.key("io.grpc.testing.istio.ClientAddress");
+  static final Context.Key<String> AUTHORITY_CONTEXT_KEY =
+      Context.key("io.grpc.testing.istio.Authority");
+  static final Context.Key<Map<String,String>> REQUEST_HEADERS_CONTEXT_KEY =
+      Context.key("io.grpc.testing.istio.RequestHeaders");
+
+  private static final String REQUEST_ID = "x-request-id";
+  private static final String STATUS_CODE = "StatusCode";
+  private static final String HOST = "Host";
+  private static final String HOSTNAME = "Hostname";
+  private static final String REQUEST_HEADER = "RequestHeader";
+  private static final String IP = "IP";
+
+  @VisibleForTesting List<Server> servers;
+
+  /**
+   * Preprocess args, for:
+   * - merging duplicate flags. So "--grpc=8080 --grpc=9090" becomes
+   * "--grpc=8080,9090".
+   **/
+  @VisibleForTesting
+  static Map<String, List<String>> preprocessArgs(String[] args) {
+    HashMap<String, List<String>> argsMap = new HashMap<>();
+    for (String arg : args) {
+      List<String> keyValue = Splitter.on('=').limit(2).splitToList(arg);
+
+      if (keyValue.size() == 2) {
+        String key = keyValue.get(0);
+        String value = keyValue.get(1);
+        List<String> oldValue = argsMap.get(key);
+        if (oldValue == null) {
+          oldValue = new ArrayList<>();
+        }
+        oldValue.add(value);
+        argsMap.put(key, oldValue);
+      }
+    }
+    return ImmutableMap.<String, List<String>>builder().putAll(argsMap).build();
+  }
+
+  /** Turn ports from a string list to an int list. */
+  @VisibleForTesting
+  static Set<Integer> getPorts(Map<String, List<String>> args, String flagName) {
+    List<String> grpcPorts = args.get(flagName);
+    Set<Integer> grpcPortsInt = new HashSet<>(grpcPorts.size());
+
+    for (String port : grpcPorts) {
+      port = CharMatcher.is('\"').trimFrom(port);
+      grpcPortsInt.add(Integer.parseInt(port));
+    }
+    return grpcPortsInt;
+  }
+
+  private static String determineHostname() {
+    try {
+      return InetAddress.getLocalHost().getHostName();
+    } catch (IOException ex) {
+      logger.log(Level.INFO, "Failed to determine hostname. Will generate one", ex);
+    }
+    // let's make an identifier for ourselves.
+    return "generated-" + new Random().nextInt();
+  }
+
+  /**
+   * The main application allowing this program to be launched from the command line.
+   */
+  public static void main(String[] args) throws Exception {
+    Map<String, List<String>> processedArgs = preprocessArgs(args);
+    Set<Integer> grpcPorts = getPorts(processedArgs, "--grpc");
+    Set<Integer> xdsPorts = getPorts(processedArgs, "--xds-grpc-server");
+    // If an xds port does not exist in gRPC ports set, add it.
+    grpcPorts.addAll(xdsPorts);
+    // which ports are supposed to use tls
+    Set<Integer> tlsPorts = getPorts(processedArgs, "--tls");
+    List<String> forwardingAddress = processedArgs.get("--forwarding-address");
+    if (forwardingAddress.size() > 1) {
+      logger.severe("More than one value for --forwarding-address not allowed");
+      System.exit(1);
+    }
+    if (forwardingAddress.size() == 0) {
+      forwardingAddress.add("0.0.0.0:7072");
+    }
+    List<String> key = processedArgs.get("key");
+    List<String> crt = processedArgs.get("crt");
+
+    if (key.size() > 1 || crt.size() > 1) {
+      logger.severe("More than one value for --key or --crt not allowed");
+      System.exit(1);
+    }
+    if (key.size() != crt.size()) {
+      logger.severe("Both --key or --crt should be present or absent");
+      System.exit(1);
+    }
+    ServerCredentials tlsServerCredentials = null;
+    if (key.size() == 1) {
+      tlsServerCredentials = TlsServerCredentials.create(new File(crt.get(0)),
+          new File(key.get(0)));
+    } else if (!tlsPorts.isEmpty()) {
+      logger.severe("Both --key or --crt should be present if tls ports used");
+      System.exit(1);
+    }
+
+    String hostname = determineHostname();
+    EchoTestServer echoTestServer = new EchoTestServer();
+    echoTestServer.runServers(hostname, grpcPorts, xdsPorts, tlsPorts, forwardingAddress.get(0),
+        tlsServerCredentials);
+    Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+      try {
+        System.out.println("Shutting down");
+        echoTestServer.stopServers();
+      } catch (Exception e) {
+        logger.log(Level.SEVERE, "stopServers", e);
+        throw e;
+      }
+    }));
+    echoTestServer.blockUntilShutdown();
+  }
+
+  void runServers(String hostname, Collection<Integer> grpcPorts, Collection<Integer> xdsPorts,
+      Collection<Integer> tlsPorts, String forwardingAddress,
+      ServerCredentials tlsServerCredentials)
+      throws IOException {
+    ServerServiceDefinition service = ServerInterceptors.intercept(
+        new EchoTestServiceImpl(hostname, forwardingAddress), new EchoTestServerInterceptor());
+    servers = new ArrayList<>(grpcPorts.size() + 1);
+    boolean runAdminServices = Boolean.getBoolean("EXPOSE_GRPC_ADMIN");
+    for (int port : grpcPorts) {
+      ServerCredentials serverCredentials = InsecureServerCredentials.create();
+      String credTypeString = "over plaintext";
+      if (xdsPorts.contains(port)) {
+        serverCredentials = XdsServerCredentials.create(InsecureServerCredentials.create());
+        credTypeString = "over xDS-configured mTLS";
+      } else if (tlsPorts.contains(port)) {
+        serverCredentials = tlsServerCredentials;
+        credTypeString = "over TLS";
+      }
+      servers.add(runServer(port, service, serverCredentials, credTypeString, runAdminServices));
+    }
+  }
+
+  static Server runServer(
+      int port, ServerServiceDefinition service, ServerCredentials serverCredentials,
+      String credTypeString, boolean runAdminServices)
+      throws IOException {
+    logger.log(Level.INFO, "Listening GRPC ({0}) on {1}", new Object[]{credTypeString, port});
+    ServerBuilder<?> builder = Grpc.newServerBuilderForPort(port, serverCredentials)
+        .addService(service);
+    if (runAdminServices) {
+      builder = builder.addServices(AdminInterface.getStandardServices());
+    }
+    return builder.build().start();
+  }
+
+  void stopServers() {
+    for (Server server : servers) {
+      server.shutdownNow();
+    }
+  }
+
+  void blockUntilShutdown() throws InterruptedException {
+    for (Server server : servers) {
+      if (!server.awaitTermination(5, TimeUnit.SECONDS)) {
+        System.err.println("Timed out waiting for server shutdown");
+      }
+    }
+  }
+
+  private static class EchoTestServerInterceptor implements ServerInterceptor {
+
+    @Override
+    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+        final Metadata requestHeaders, ServerCallHandler<ReqT, RespT> next) {
+      final String methodName = call.getMethodDescriptor().getBareMethodName();
+
+      // we need this processing only for Echo
+      if (!"Echo".equals(methodName)) {
+        return next.startCall(call, requestHeaders);
+      }
+      final SocketAddress peerAddress = call.getAttributes()
+          .get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
+
+      Context ctx = Context.current();
+      if (peerAddress instanceof InetSocketAddress) {
+        InetSocketAddress inetPeerAddress = (InetSocketAddress) peerAddress;
+        ctx = ctx.withValue(CLIENT_ADDRESS_CONTEXT_KEY,
+            inetPeerAddress.getAddress().getHostAddress());
+      }
+      ctx = ctx.withValue(AUTHORITY_CONTEXT_KEY, call.getAuthority());
+      Map<String, String> requestHeadersCopy = new HashMap<>();
+      for (String key : requestHeaders.keys()) {
+        if (!key.endsWith("-bin")) {
+          requestHeadersCopy.put(key,
+              requestHeaders.get(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER)));
+        }
+      }
+      ctx = ctx.withValue(REQUEST_HEADERS_CONTEXT_KEY, requestHeadersCopy);
+      return Contexts.interceptCall(
+          ctx,
+          call,
+          requestHeaders,
+          next);
+    }
+  }
+
+  private static class EchoTestServiceImpl extends EchoTestServiceImplBase {
+
+    private final String hostname;
+    private final String forwardingAddress;
+    private final EchoTestServiceGrpc.EchoTestServiceBlockingStub forwardingStub;
+
+    EchoTestServiceImpl(String hostname, String forwardingAddress) {
+      this.hostname = hostname;
+      this.forwardingAddress = forwardingAddress;
+      this.forwardingStub = EchoTestServiceGrpc.newBlockingStub(
+          Grpc.newChannelBuilder(forwardingAddress, InsecureChannelCredentials.create()).build());
+    }
+
+    @Override
+    public void echo(EchoRequest request,
+        io.grpc.stub.StreamObserver<EchoResponse> responseObserver) {
+
+      EchoMessage echoMessage = new EchoMessage();
+      echoMessage.writeKeyValue(HOSTNAME, hostname);
+      echoMessage.writeKeyValue("Echo", request.getMessage());
+      String clientAddress = CLIENT_ADDRESS_CONTEXT_KEY.get();
+      if (clientAddress != null) {
+        echoMessage.writeKeyValue(IP, clientAddress);
+      }
+      Map<String, String> requestHeadersCopy = REQUEST_HEADERS_CONTEXT_KEY.get();
+      for (Map.Entry<String, String> entry : requestHeadersCopy.entrySet()) {
+        echoMessage.writeKeyValueForRequest(REQUEST_HEADER, entry.getKey(), entry.getValue());
+      }
+      echoMessage.writeKeyValue(STATUS_CODE, "200");
+      echoMessage.writeKeyValue(HOST, AUTHORITY_CONTEXT_KEY.get());
+      EchoResponse echoResponse = EchoResponse.newBuilder()
+          .setMessage(echoMessage.toString())
+          .build();
+
+      responseObserver.onNext(echoResponse);
+      responseObserver.onCompleted();
+    }
+
+    @Override
+    public void forwardEcho(ForwardEchoRequest request,
+        StreamObserver<ForwardEchoResponse> responseObserver) {
+      try {
+        responseObserver.onNext(buildEchoResponse(request));
+        responseObserver.onCompleted();
+      } catch (InterruptedException e) {
+        responseObserver.onError(e);
+        Thread.currentThread().interrupt();
+      } catch (Exception e) {
+        responseObserver.onError(e);
+      }
+    }
+
+    private static final class EchoCall {
+      EchoResponse response;
+      Status status;
+    }
+
+    private ForwardEchoResponse buildEchoResponse(ForwardEchoRequest request)
+        throws InterruptedException {
+      ForwardEchoResponse.Builder forwardEchoResponseBuilder
+          = ForwardEchoResponse.newBuilder();
+      String rawUrl = request.getUrl();
+      List<String> urlParts = Splitter.on(':').limit(2).splitToList(rawUrl);
+      if (urlParts.size() < 2) {
+        throw new StatusRuntimeException(
+            Status.INVALID_ARGUMENT.withDescription("No protocol configured for url " + rawUrl));
+      }
+      ChannelCredentials creds;
+      String target = null;
+      if ("grpc".equals(urlParts.get(0))) {
+        // We don't really want to test this but the istio test infrastructure needs
+        // this to be supported. If we ever decide to add support for this properly,
+        // we would need to add support for TLS creds here.
+        creds = InsecureChannelCredentials.create();
+        target = urlParts.get(1).substring(2);
+      } else if ("xds".equals(urlParts.get(0))) {
+        creds = XdsChannelCredentials.create(InsecureChannelCredentials.create());
+        target = rawUrl;
+      } else {
+        logger.log(Level.INFO, "Protocol {0} not supported. Forwarding to {1}",
+            new String[]{urlParts.get(0), forwardingAddress});
+        return forwardingStub.withDeadline(Context.current().getDeadline()).forwardEcho(request);
+      }
+
+      ManagedChannelBuilder<?> channelBuilder = Grpc.newChannelBuilder(target, creds);
+      ManagedChannel channel = channelBuilder.build();
+
+      List<Header> requestHeaders = request.getHeadersList();
+      Metadata metadata = new Metadata();
+
+      for (Header header : requestHeaders) {
+        metadata.put(Metadata.Key.of(header.getKey(), Metadata.ASCII_STRING_MARSHALLER),
+            header.getValue());
+      }
+
+      int count = request.getCount() == 0 ? 1 : request.getCount();
+      // Calculate the amount of time to sleep after each call.
+      Duration durationPerQuery = Duration.ZERO;
+      if (request.getQps() > 0) {
+        durationPerQuery = Duration.ofNanos(
+            Duration.ofSeconds(1).toNanos() / request.getQps());
+      }
+      logger.info("qps=" + request.getQps());
+      logger.info("durationPerQuery=" + durationPerQuery);
+      EchoRequest echoRequest = EchoRequest.newBuilder()
+          .setMessage(request.getMessage())
+          .build();
+      Instant start = Instant.now();
+      logger.info("starting instant=" + start);
+      Duration expected = Duration.ZERO;
+      final CountDownLatch latch = new CountDownLatch(count);
+      EchoCall[] echoCalls = new EchoCall[count];
+      for (int i = 0; i < count; i++) {
+        Metadata currentMetadata = new Metadata();
+        currentMetadata.merge(metadata);
+        currentMetadata.put(
+            Metadata.Key.of(REQUEST_ID, Metadata.ASCII_STRING_MARSHALLER), "" + i);
+        EchoTestServiceGrpc.EchoTestServiceFutureStub stub
+            = EchoTestServiceGrpc.newFutureStub(channel).withInterceptors(
+                MetadataUtils.newAttachHeadersInterceptor(currentMetadata))
+            .withDeadlineAfter(request.getTimeoutMicros(), TimeUnit.MICROSECONDS);
+
+        echoCalls[i] = new EchoCall();
+        callEcho(stub, echoRequest, echoCalls[i], latch);
+        Instant current = Instant.now();
+        logger.info("after rpc instant=" + current);
+        Duration elapsed = Duration.between(start, current);
+        expected = expected.plus(durationPerQuery);
+        Duration timeLeft = expected.minus(elapsed);
+        logger.info("elapsed=" + elapsed + ", expected=" + expected + ", timeLeft=" + timeLeft);
+        if (!timeLeft.isNegative()) {
+          logger.info("sleeping for ms =" + timeLeft);
+          Thread.sleep(timeLeft.toMillis());
+        }
+      }
+      latch.await();
+      for (int i = 0; i < count; i++) {
+        if (Status.OK.equals(echoCalls[i].status)) {
+          forwardEchoResponseBuilder.addOutput(
+              buildForwardEchoStruct(i, echoCalls, request.getMessage()));
+        } else {
+          logger.log(Level.SEVERE, "RPC {0} failed {1}: {2}",
+              new Object[]{i, echoCalls[i].status.getCode(), echoCalls[i].status.getDescription()});
+          forwardEchoResponseBuilder.clear();
+          throw echoCalls[i].status.asRuntimeException();
+        }
+      }
+      return forwardEchoResponseBuilder.build();
+    }
+
+    private static String buildForwardEchoStruct(int i, EchoCall[] echoCalls,
+        String requestMessage) {
+      // The test infrastructure might expect the entire struct instead of
+      // just the message.
+      StringBuilder sb = new StringBuilder();
+      sb.append(String.format("[%d] grpcecho.Echo(%s)\n", i, requestMessage));
+      Iterable<String> iterable = Splitter.on('\n').split(echoCalls[i].response.getMessage());
+      for (String line : iterable) {
+        if (!line.isEmpty()) {
+          sb.append(String.format("[%d body] %s\n", i, line));
+        }
+      }
+      return sb.toString();
+    }
+
+    private void callEcho(EchoTestServiceFutureStub stub,
+        EchoRequest echoRequest, final EchoCall echoCall, CountDownLatch latch) {
+
+      ListenableFuture<EchoResponse> response = stub.echo(echoRequest);
+      Futures.addCallback(
+          response,
+          new FutureCallback<EchoResponse>() {
+            @Override
+            public void onSuccess(@Nullable EchoResponse result) {
+              echoCall.response = result;
+              echoCall.status = Status.OK;
+              latch.countDown();
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+              echoCall.status = Status.fromThrowable(t);
+              latch.countDown();
+            }
+          },
+          MoreExecutors.directExecutor());
+    }
+  }
+
+  private static class EchoMessage {
+    private final StringBuilder sb = new StringBuilder();
+
+    void writeKeyValue(String key, String value) {
+      sb.append(key).append("=").append(value).append("\n");
+    }
+
+    void writeKeyValueForRequest(String requestHeader, String key, String value) {
+      if (value != null) {
+        writeKeyValue(requestHeader, key + ":" + value);
+      }
+    }
+
+    @Override
+    public String toString() {
+      return sb.toString();
+    }
+  }
+}
diff --git a/istio-interop-testing/src/test/java/io/grpc/testing/istio/EchoTestServerTest.java b/istio-interop-testing/src/test/java/io/grpc/testing/istio/EchoTestServerTest.java
new file mode 100644
index 00000000000..091a300b874
--- /dev/null
+++ b/istio-interop-testing/src/test/java/io/grpc/testing/istio/EchoTestServerTest.java
@@ -0,0 +1,388 @@
+/*
+ * Copyright 2022 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.testing.istio;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.fail;
+
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Metadata;
+import io.grpc.Server;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.stub.MetadataUtils;
+import io.grpc.stub.StreamObserver;
+import io.istio.test.Echo.EchoRequest;
+import io.istio.test.Echo.EchoResponse;
+import io.istio.test.Echo.ForwardEchoRequest;
+import io.istio.test.Echo.ForwardEchoResponse;
+import io.istio.test.Echo.Header;
+import io.istio.test.EchoTestServiceGrpc;
+import io.istio.test.EchoTestServiceGrpc.EchoTestServiceImplBase;
+import java.io.IOException;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link EchoTestServer}.
+ */
+@RunWith(JUnit4.class)
+public class EchoTestServerTest {
+
+  private static final String[] EXPECTED_KEY_SET = {
+      "--server_first", "--forwarding-address",
+      "--bind_ip", "--istio-version", "--bind_localhost", "--grpc", "--tls",
+      "--cluster", "--key", "--tcp", "--crt", "--metrics", "--port", "--version"
+  };
+
+  private static final String TEST_ARGS =
+      "--metrics=15014 --cluster=\"cluster-0\" --port=\"18080\" --grpc=\"17070\" --port=\"18085\""
+          + " --tcp=\"19090\" --port=\"18443\" --tls=18443 --tcp=\"16060\" --server_first=16060"
+          + " --tcp=\"19091\" --tcp=\"16061\" --server_first=16061 --port=\"18081\""
+          + " --grpc=\"17071\" --port=\"19443\" --tls=19443 --port=\"18082\" --bind_ip=18082"
+          + " --port=\"18084\" --bind_localhost=18084 --tcp=\"19092\" --port=\"18083\""
+          + " --port=\"8080\" --port=\"3333\" --version=\"v1\" --istio-version=3 --crt=/cert.crt"
+          + " --key=/cert.key --forwarding-address=192.168.1.10:7072";
+
+  private static final String TEST_ARGS_PORTS =
+      "--metrics=15014 --cluster=\"cluster-0\" --port=\"18080\" --grpc=17070 --port=18085"
+          + " --tcp=\"19090\" --port=\"18443\" --tls=18443 --tcp=16060 --server_first=16060"
+          + " --tcp=\"19091\" --tcp=\"16061\" --server_first=16061 --port=\"18081\""
+          + " --grpc=\"17071\" --port=\"19443\" --tls=\"19443\" --port=\"18082\" --bind_ip=18082"
+          + " --port=\"18084\" --bind_localhost=18084 --tcp=\"19092\" --port=\"18083\""
+          + " --port=\"8080\" --port=3333 --version=\"v1\" --istio-version=3 --crt=/cert.crt"
+          + " --key=/cert.key --xds-grpc-server=12034 --xds-grpc-server=\"34012\"";
+
+  @Test
+  public void preprocessArgsTest() {
+    String[] splitArgs = TEST_ARGS.split(" ");
+    Map<String, List<String>> processedArgs = EchoTestServer.preprocessArgs(splitArgs);
+
+    assertEquals(processedArgs.keySet(), ImmutableSet.copyOf(EXPECTED_KEY_SET));
+    assertEquals(processedArgs.get("--server_first"), ImmutableList.of("16060", "16061"));
+    assertEquals(processedArgs.get("--bind_ip"), ImmutableList.of("18082"));
+    assertEquals(processedArgs.get("--bind_localhost"), ImmutableList.of("18084"));
+    assertEquals(processedArgs.get("--grpc"), ImmutableList.of("\"17070\"", "\"17071\""));
+    assertEquals(processedArgs.get("--tls"), ImmutableList.of("18443", "19443"));
+    assertEquals(processedArgs.get("--cluster"), ImmutableList.of("\"cluster-0\""));
+    assertEquals(processedArgs.get("--key"), ImmutableList.of("/cert.key"));
+    assertEquals(processedArgs.get("--tcp"), ImmutableList.of("\"19090\"", "\"16060\"",
+        "\"19091\"","\"16061\"","\"19092\""));
+    assertEquals(processedArgs.get("--istio-version"), ImmutableList.of("3"));
+    assertEquals(processedArgs.get("--crt"), ImmutableList.of("/cert.crt"));
+    assertEquals(processedArgs.get("--metrics"), ImmutableList.of("15014"));
+    assertEquals(ImmutableList.of("192.168.1.10:7072"), processedArgs.get("--forwarding-address"));
+    assertEquals(
+        processedArgs.get("--port"),
+        ImmutableList.of(
+            "\"18080\"",
+            "\"18085\"",
+            "\"18443\"",
+            "\"18081\"",
+            "\"19443\"",
+            "\"18082\"",
+            "\"18084\"",
+            "\"18083\"",
+            "\"8080\"",
+            "\"3333\""));
+  }
+
+  @Test
+  public void preprocessArgsPortsTest() {
+    String[] splitArgs = TEST_ARGS_PORTS.split(" ");
+    Map<String, List<String>> processedArgs = EchoTestServer.preprocessArgs(splitArgs);
+
+    Set<Integer> ports = EchoTestServer.getPorts(processedArgs, "--port");
+    assertThat(ports).containsExactly(18080, 8080, 18081, 18082, 19443, 18083, 18084, 18085,
+        3333, 18443);
+    ports = EchoTestServer.getPorts(processedArgs, "--grpc");
+    assertThat(ports).containsExactly(17070, 17071);
+    ports = EchoTestServer.getPorts(processedArgs, "--tls");
+    assertThat(ports).containsExactly(18443, 19443);
+    ports = EchoTestServer.getPorts(processedArgs, "--xds-grpc-server");
+    assertThat(ports).containsExactly(34012, 12034);
+  }
+
+
+  @Test
+  public void echoTest() throws IOException, InterruptedException {
+    EchoTestServer echoTestServer = new EchoTestServer();
+
+    echoTestServer.runServers(
+        "test-host",
+        ImmutableList.of(0, 0),
+        ImmutableList.of(),
+        ImmutableList.of(),
+        "0.0.0.0:7072",
+        null);
+    assertEquals(2, echoTestServer.servers.size());
+    int port = echoTestServer.servers.get(0).getPort();
+    assertNotEquals(0, port);
+    assertNotEquals(0, echoTestServer.servers.get(1).getPort());
+
+    ManagedChannelBuilder<?> channelBuilder =
+        Grpc.newChannelBuilderForAddress("localhost", port, InsecureChannelCredentials.create());
+    ManagedChannel channel = channelBuilder.build();
+
+    Metadata metadata = new Metadata();
+    metadata.put(Metadata.Key.of("header1", Metadata.ASCII_STRING_MARSHALLER), "value1");
+    metadata.put(Metadata.Key.of("header2", Metadata.ASCII_STRING_MARSHALLER), "value2");
+
+    EchoTestServiceGrpc.EchoTestServiceBlockingStub stub =
+        EchoTestServiceGrpc.newBlockingStub(channel)
+            .withInterceptors(MetadataUtils.newAttachHeadersInterceptor(metadata));
+
+    EchoRequest echoRequest = EchoRequest.newBuilder()
+        .setMessage("test-message1")
+        .build();
+    EchoResponse echoResponse = stub.echo(echoRequest);
+    String echoMessage = echoResponse.getMessage();
+    Set<String> lines = ImmutableSet.copyOf(echoMessage.split("\n"));
+
+    assertThat(lines).contains("RequestHeader=header1:value1");
+    assertThat(lines).contains("RequestHeader=header2:value2");
+    assertThat(lines).contains("Echo=test-message1");
+    assertThat(lines).contains("Hostname=test-host");
+    assertThat(lines).contains("Host=localhost:" + port);
+    assertThat(lines).contains("StatusCode=200");
+
+    echoTestServer.stopServers();
+    echoTestServer.blockUntilShutdown();
+  }
+
+  static final int COUNT_OF_REQUESTS_TO_FORWARD = 60;
+
+  @Test
+  public void forwardEchoTest() throws IOException, InterruptedException {
+    EchoTestServer echoTestServer = new EchoTestServer();
+
+    echoTestServer.runServers(
+        "test-host",
+        ImmutableList.of(0, 0),
+        ImmutableList.of(),
+        ImmutableList.of(),
+        "0.0.0.0:7072",
+        null);
+    assertEquals(2, echoTestServer.servers.size());
+    int port1 = echoTestServer.servers.get(0).getPort();
+    int port2 = echoTestServer.servers.get(1).getPort();
+
+    ManagedChannelBuilder<?> channelBuilder =
+        Grpc.newChannelBuilderForAddress("localhost", port1, InsecureChannelCredentials.create());
+    ManagedChannel channel = channelBuilder.build();
+
+    ForwardEchoRequest forwardEchoRequest =
+        ForwardEchoRequest.newBuilder()
+            .setCount(COUNT_OF_REQUESTS_TO_FORWARD)
+            .setQps(100)
+            .setTimeoutMicros(5000_000L) // 5000 millis
+            .setUrl("grpc://localhost:" + port2)
+            .addHeaders(
+                Header.newBuilder().setKey("test-key1").setValue("test-value1").build())
+            .addHeaders(
+                Header.newBuilder().setKey("test-key2").setValue("test-value2").build())
+            .setMessage("forward-echo-test-message")
+            .build();
+
+    EchoTestServiceGrpc.EchoTestServiceBlockingStub stub =
+        EchoTestServiceGrpc.newBlockingStub(channel);
+
+    Instant start = Instant.now();
+    ForwardEchoResponse forwardEchoResponse = stub.forwardEcho(forwardEchoRequest);
+    Instant end = Instant.now();
+    List<String> outputs = forwardEchoResponse.getOutputList();
+    assertEquals(COUNT_OF_REQUESTS_TO_FORWARD, outputs.size());
+    for (int i = 0; i < COUNT_OF_REQUESTS_TO_FORWARD; i++) {
+      validateOutput(outputs.get(i), i);
+    }
+    long duration = Duration.between(start, end).toMillis();
+    assertThat(duration).isAtLeast(COUNT_OF_REQUESTS_TO_FORWARD * 10L);
+    echoTestServer.stopServers();
+    echoTestServer.blockUntilShutdown();
+  }
+
+  private static void validateOutput(String output, int i) {
+    List<String> content = Splitter.on('\n').splitToList(output);
+    assertThat(content.size()).isAtLeast(7); // see echo implementation
+    assertThat(content.get(0))
+        .isEqualTo(String.format("[%d] grpcecho.Echo(forward-echo-test-message)", i));
+    String prefix = "[" + i + " body] ";
+    assertThat(content).contains(prefix + "RequestHeader=x-request-id:" + i);
+    assertThat(content).contains(prefix + "RequestHeader=test-key1:test-value1");
+    assertThat(content).contains(prefix + "RequestHeader=test-key2:test-value2");
+    assertThat(content).contains(prefix + "Hostname=test-host");
+    assertThat(content).contains(prefix + "StatusCode=200");
+  }
+
+  @Test
+  public void nonGrpcForwardEchoTest() throws IOException, InterruptedException {
+    ForwardServiceForNonGrpcImpl forwardServiceForNonGrpc = new ForwardServiceForNonGrpcImpl();
+    forwardServiceForNonGrpc.receivedRequests = new ArrayList<>();
+    forwardServiceForNonGrpc.responsesToReturn = new ArrayList<>();
+    Server nonGrpcEchoServer =
+        EchoTestServer.runServer(
+            0, forwardServiceForNonGrpc.bindService(), InsecureServerCredentials.create(),
+                "", false);
+    int nonGrpcEchoServerPort = nonGrpcEchoServer.getPort();
+
+    EchoTestServer echoTestServer = new EchoTestServer();
+
+    echoTestServer.runServers(
+        "test-host",
+        ImmutableList.of(0),
+        ImmutableList.of(),
+        ImmutableList.of(),
+        "0.0.0.0:" + nonGrpcEchoServerPort,
+        null);
+    assertEquals(1, echoTestServer.servers.size());
+    int port1 = echoTestServer.servers.get(0).getPort();
+
+    ManagedChannelBuilder<?> channelBuilder =
+        Grpc.newChannelBuilderForAddress("localhost", port1, InsecureChannelCredentials.create());
+    ManagedChannel channel = channelBuilder.build();
+
+    EchoTestServiceGrpc.EchoTestServiceBlockingStub stub =
+        EchoTestServiceGrpc.newBlockingStub(channel);
+
+    forwardServiceForNonGrpc.responsesToReturn.add(
+        ForwardEchoResponse.newBuilder().addOutput("line 1").addOutput("line 2").build());
+
+    ForwardEchoRequest forwardEchoRequest =
+        ForwardEchoRequest.newBuilder()
+            .setCount(COUNT_OF_REQUESTS_TO_FORWARD)
+            .setQps(100)
+            .setTimeoutMicros(2000_000L) // 2000 millis
+            .setUrl("http://www.example.com") // non grpc protocol
+            .addHeaders(
+                Header.newBuilder().setKey("test-key1").setValue("test-value1").build())
+            .addHeaders(
+                Header.newBuilder().setKey("test-key2").setValue("test-value2").build())
+            .setMessage("non-grpc-forward-echo-test-message1")
+            .build();
+
+    ForwardEchoResponse forwardEchoResponse = stub.forwardEcho(forwardEchoRequest);
+    List<String> outputs = forwardEchoResponse.getOutputList();
+    assertEquals(2, outputs.size());
+    assertThat(outputs.get(0)).isEqualTo("line 1");
+    assertThat(outputs.get(1)).isEqualTo("line 2");
+
+    assertThat(forwardServiceForNonGrpc.receivedRequests).hasSize(1);
+    ForwardEchoRequest receivedRequest = forwardServiceForNonGrpc.receivedRequests.remove(0);
+    assertThat(receivedRequest.getUrl()).isEqualTo("http://www.example.com");
+    assertThat(receivedRequest.getMessage()).isEqualTo("non-grpc-forward-echo-test-message1");
+    assertThat(receivedRequest.getCount()).isEqualTo(COUNT_OF_REQUESTS_TO_FORWARD);
+    assertThat(receivedRequest.getQps()).isEqualTo(100);
+
+    forwardServiceForNonGrpc.responsesToReturn.add(
+        Status.UNIMPLEMENTED.asRuntimeException());
+    forwardEchoRequest =
+        ForwardEchoRequest.newBuilder()
+            .setCount(1)
+            .setQps(100)
+            .setTimeoutMicros(2000_000L) // 2000 millis
+            .setUrl("redis://192.168.1.1") // non grpc protocol
+            .addHeaders(
+                Header.newBuilder().setKey("test-key1").setValue("test-value1").build())
+            .setMessage("non-grpc-forward-echo-test-message2")
+            .build();
+
+    try {
+      ForwardEchoResponse unused = stub.forwardEcho(forwardEchoRequest);
+      fail("exception expected");
+    } catch (StatusRuntimeException e) {
+      assertThat(e.getStatus()).isEqualTo(Status.UNIMPLEMENTED);
+    }
+
+    assertThat(forwardServiceForNonGrpc.receivedRequests).hasSize(1);
+    receivedRequest = forwardServiceForNonGrpc.receivedRequests.remove(0);
+    assertThat(receivedRequest.getUrl()).isEqualTo("redis://192.168.1.1");
+    assertThat(receivedRequest.getMessage()).isEqualTo("non-grpc-forward-echo-test-message2");
+    assertThat(receivedRequest.getCount()).isEqualTo(1);
+
+    forwardServiceForNonGrpc.responsesToReturn.add(
+        ForwardEchoResponse.newBuilder().addOutput("line 3").build());
+
+    forwardEchoRequest =
+        ForwardEchoRequest.newBuilder()
+            .setCount(1)
+            .setQps(100)
+            .setTimeoutMicros(2000_000L) // 2000 millis
+            .setUrl("http2://192.168.1.1") // non grpc protocol
+            .addHeaders(
+                Header.newBuilder().setKey("test-key3").setValue("test-value3").build())
+            .setMessage("non-grpc-forward-echo-test-message3")
+            .build();
+    forwardEchoResponse = stub.forwardEcho(forwardEchoRequest);
+    outputs = forwardEchoResponse.getOutputList();
+    assertEquals(1, outputs.size());
+    assertThat(outputs.get(0)).isEqualTo("line 3");
+
+    assertThat(forwardServiceForNonGrpc.receivedRequests).hasSize(1);
+    receivedRequest = forwardServiceForNonGrpc.receivedRequests.remove(0);
+    assertThat(receivedRequest.getUrl()).isEqualTo("http2://192.168.1.1");
+    assertThat(receivedRequest.getMessage()).isEqualTo("non-grpc-forward-echo-test-message3");
+    List<Header> headers = receivedRequest.getHeadersList();
+    assertThat(headers).hasSize(1);
+    assertThat(headers.get(0).getKey()).isEqualTo("test-key3");
+    assertThat(headers.get(0).getValue()).isEqualTo("test-value3");
+
+    echoTestServer.stopServers();
+    echoTestServer.blockUntilShutdown();
+    nonGrpcEchoServer.shutdown();
+    nonGrpcEchoServer.awaitTermination(5, TimeUnit.SECONDS);
+  }
+
+  /**
+   * Emulate the Go Echo server that receives the non-grpc protocol requests.
+   */
+  private static class ForwardServiceForNonGrpcImpl extends EchoTestServiceImplBase {
+
+    List<ForwardEchoRequest> receivedRequests;
+    List<Object> responsesToReturn;
+
+    @Override
+    public void forwardEcho(ForwardEchoRequest request,
+        StreamObserver<ForwardEchoResponse> responseObserver) {
+      receivedRequests.add(request);
+      Object response = responsesToReturn.remove(0);
+      if (response instanceof Throwable) {
+        responseObserver.onError((Throwable) response);
+      } else if (response instanceof ForwardEchoResponse) {
+        responseObserver.onNext((ForwardEchoResponse) response);
+        responseObserver.onCompleted();
+      }
+      responseObserver.onError(new IllegalArgumentException("Unknown type in responsesToReturn"));
+    }
+  }
+}
diff --git a/istio-interop-testing/third_party/istio/LICENSE b/istio-interop-testing/third_party/istio/LICENSE
new file mode 100644
index 00000000000..56e48aa37f6
--- /dev/null
+++ b/istio-interop-testing/third_party/istio/LICENSE
@@ -0,0 +1,202 @@
+
+                                Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2016-2020 Istio 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.
diff --git a/istio-interop-testing/third_party/istio/import.sh b/istio-interop-testing/third_party/istio/import.sh
new file mode 100755
index 00000000000..739c3c20fce
--- /dev/null
+++ b/istio-interop-testing/third_party/istio/import.sh
@@ -0,0 +1,58 @@
+#!/bin/bash
+# Copyright 2018 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.
+
+# Update VERSION then in this directory run ./import.sh
+
+set -e
+BRANCH=master
+# import VERSION from the istio repository
+VERSION=cbee1999ad8b0f1ec790ec47f9ea33fed887f4a7
+GIT_REPO="https://github.com/istio/istio.git"
+GIT_BASE_DIR=istio
+SOURCE_PROTO_BASE_DIR=istio/pkg
+TARGET_PROTO_BASE_DIR=src/main/proto
+# Sorted alphabetically.
+FILES=(
+test/echo/proto/echo.proto
+)
+
+pushd `git rev-parse --show-toplevel`/istio-interop-testing/third_party/istio
+
+# clone the istio github repo in a tmp directory
+tmpdir="$(mktemp -d)"
+trap "rm -rf ${tmpdir}" EXIT
+
+pushd "${tmpdir}"
+git clone -b $BRANCH $GIT_REPO
+trap "rm -rf $GIT_BASE_DIR" EXIT
+cd "$GIT_BASE_DIR"
+git checkout $VERSION
+popd
+
+cp -p "${tmpdir}/${GIT_BASE_DIR}/LICENSE" LICENSE
+
+rm -rf "${TARGET_PROTO_BASE_DIR}"
+mkdir -p "${TARGET_PROTO_BASE_DIR}"
+pushd "${TARGET_PROTO_BASE_DIR}"
+
+# copy proto files to project directory
+for file in "${FILES[@]}"
+do
+  mkdir -p "$(dirname "${file}")"
+  cp -p "${tmpdir}/${SOURCE_PROTO_BASE_DIR}/${file}" "${file}"
+done
+popd
+
+popd
diff --git a/istio-interop-testing/third_party/istio/src/main/proto/test/echo/proto/echo.proto b/istio-interop-testing/third_party/istio/src/main/proto/test/echo/proto/echo.proto
new file mode 100644
index 00000000000..7e931b13b99
--- /dev/null
+++ b/istio-interop-testing/third_party/istio/src/main/proto/test/echo/proto/echo.proto
@@ -0,0 +1,93 @@
+// Copyright Istio 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.
+
+syntax = "proto3";
+
+import "google/protobuf/wrappers.proto";
+
+// Generate with protoc --go_out=. echo.proto -I /work/common-protos/ -I.
+package proto;
+option go_package="../proto";
+option java_package = "io.istio.test";
+option java_outer_classname = "Echo";
+
+service EchoTestService {
+  rpc Echo (EchoRequest) returns (EchoResponse);
+  rpc ForwardEcho (ForwardEchoRequest) returns (ForwardEchoResponse);
+}
+
+message EchoRequest {
+  string message = 1;
+}
+
+message EchoResponse {
+  string message = 1;
+}
+
+message Header {
+  string key = 1;
+  string value = 2;
+}
+
+message ForwardEchoRequest {
+  int32 count = 1;
+  int32 qps = 2;
+  int64 timeout_micros = 3;
+  string url = 4;
+  repeated Header headers = 5;
+  string message = 6;
+  // Method for the request. Valid only for HTTP
+  string method = 9;
+  // If true, requests will be sent using h2c prior knowledge
+  bool http2 = 7;
+  // If true, requests will be sent using http3
+  bool http3 = 15;
+  // If true, requests will not be sent until magic string is received
+  bool serverFirst = 8;
+  // If true, 301 redirects will be followed
+  bool followRedirects = 14;
+  // If non-empty, make the request with the corresponding cert and key.
+  string cert = 10;
+  string key = 11;
+  // If non-empty, verify the server CA
+  string caCert = 12;
+  // If non-empty, make the request with the corresponding cert and key file.
+  string certFile = 16;
+  string keyFile = 17;
+  // If non-empty, verify the server CA with the ca cert file.
+  string caCertFile = 18;
+  // Skip verifying peer's certificate.
+  bool insecureSkipVerify = 19;
+  // List of ALPNs to present. If not set, this will be automatically be set based on the protocol
+  Alpn alpn = 13;
+  // Server name (SNI) to present in TLS connections. If not set, Host will be used for http requests.
+  string serverName = 20;
+  // Expected response determines what string to look for in the response to validate TCP requests succeeded.
+  // If not set, defaults to "StatusCode=200"
+  google.protobuf.StringValue expectedResponse = 21;
+  // If set, a new connection will be made to the server for each individual request. If false, an attempt
+  // will be made to re-use the connection for the life of the forward request. This is automatically
+  // set for DNS, TCP, TLS, and WebSocket protocols.
+  bool newConnectionPerRequest = 22;
+  // If set, each request will force a DNS lookup. Only applies if newConnectionPerRequest is set.
+  bool forceDNSLookup = 23;
+}
+
+message Alpn {
+  repeated string value = 1;
+}
+
+message ForwardEchoResponse {
+  repeated string output = 1;
+}
diff --git a/java_grpc_library.bzl b/java_grpc_library.bzl
new file mode 100644
index 00000000000..e6afc028883
--- /dev/null
+++ b/java_grpc_library.bzl
@@ -0,0 +1,246 @@
+"""Build rule for java_grpc_library."""
+
+load("@com_google_protobuf//bazel/common:proto_info.bzl", "ProtoInfo")
+load("@rules_java//java:defs.bzl", "JavaInfo", "JavaPluginInfo", "java_common")
+
+_JavaRpcToolchainInfo = provider(
+    fields = [
+        "java_toolchain",
+        "java_plugins",
+        "plugin",
+        "plugin_arg",
+        "protoc",
+        "runtime",
+    ],
+)
+
+def _java_rpc_toolchain_impl(ctx):
+    return [
+        _JavaRpcToolchainInfo(
+            java_toolchain = ctx.attr._java_toolchain,
+            java_plugins = ctx.attr.java_plugins,
+            plugin = ctx.attr.plugin,
+            plugin_arg = ctx.attr.plugin_arg,
+            protoc = ctx.attr._protoc,
+            runtime = ctx.attr.runtime,
+        ),
+        platform_common.ToolchainInfo(),  # Magic for b/78647825
+    ]
+
+java_rpc_toolchain = rule(
+    attrs = {
+        # This attribute has a "magic" name recognized by the native DexArchiveAspect (b/78647825).
+        "runtime": attr.label_list(
+            cfg = "target",
+            providers = [JavaInfo],
+        ),
+        "plugin": attr.label(
+            cfg = "exec",
+            executable = True,
+        ),
+        "plugin_arg": attr.string(),
+        "_protoc": attr.label(
+            cfg = "exec",
+            default = Label("@com_google_protobuf//:protoc"),
+            executable = True,
+        ),
+        "java_plugins": attr.label_list(
+            default = [],
+            providers = [JavaPluginInfo],
+        ),
+        "_java_toolchain": attr.label(
+            default = Label("@bazel_tools//tools/jdk:current_java_toolchain"),
+        ),
+    },
+    provides = [
+        _JavaRpcToolchainInfo,
+        platform_common.ToolchainInfo,
+    ],
+    implementation = _java_rpc_toolchain_impl,
+)
+
+# "repository" here is for Bazel builds that span multiple WORKSPACES.
+def _path_ignoring_repository(f):
+    # Bazel creates a _virtual_imports directory in case the .proto source files
+    # need to be accessed at a path that's different from their source path:
+    # https://github.com/bazelbuild/bazel/blob/0.27.1/src/main/java/com/google/devtools/build/lib/rules/proto/ProtoCommon.java#L289
+    #
+    # In that case, the import path of the .proto file is the path relative to
+    # the virtual imports directory of the rule in question.
+    virtual_imports = "/_virtual_imports/"
+    if virtual_imports in f.path:
+        return f.path.split(virtual_imports)[1].split("/", 1)[1]
+    elif len(f.owner.workspace_root) == 0:
+        # |f| is in the main repository
+        return f.short_path
+    else:
+        # If |f| is a generated file, it will have "bazel-out/*/genfiles" prefix
+        # before "external/workspace", so we need to add the starting index of "external/workspace"
+        return f.path[f.path.find(f.owner.workspace_root) + len(f.owner.workspace_root) + 1:]
+
+def _java_rpc_library_impl(ctx):
+    if len(ctx.attr.srcs) != 1:
+        fail("Exactly one src value supported", "srcs")
+    if ctx.attr.srcs[0].label.package != ctx.label.package:
+        print(("in srcs attribute of {0}: Proto source with label {1} should be in " +
+               "same package as consuming rule").format(ctx.label, ctx.attr.srcs[0].label))
+
+    toolchain = ctx.attr._toolchain[_JavaRpcToolchainInfo]
+    srcs = ctx.attr.srcs[0][ProtoInfo].direct_sources
+    descriptor_set_in = ctx.attr.srcs[0][ProtoInfo].transitive_descriptor_sets
+
+    srcjar = ctx.actions.declare_file("%s-proto-gensrc.jar" % ctx.label.name)
+
+    args = ctx.actions.args()
+    args.add(toolchain.plugin[DefaultInfo].files_to_run.executable, format = "--plugin=protoc-gen-rpc-plugin=%s")
+    args.add("--rpc-plugin_out={0}:{1}".format(toolchain.plugin_arg, srcjar.path))
+    args.add_joined("--descriptor_set_in", descriptor_set_in, join_with = ctx.configuration.host_path_separator)
+    args.add_all(srcs, map_each = _path_ignoring_repository)
+
+    ctx.actions.run(
+        inputs = depset(srcs, transitive = [descriptor_set_in, toolchain.plugin[DefaultInfo].files]),
+        outputs = [srcjar],
+        executable = toolchain.protoc[DefaultInfo].files_to_run,
+        arguments = [args],
+        use_default_shell_env = True,
+        toolchain = None,
+    )
+
+    deps_java_info = java_common.merge([dep[JavaInfo] for dep in ctx.attr.deps])
+
+    java_info = java_common.compile(
+        ctx,
+        java_toolchain = toolchain.java_toolchain[java_common.JavaToolchainInfo],
+        source_jars = [srcjar],
+        output = ctx.outputs.jar,
+        output_source_jar = ctx.outputs.srcjar,
+        plugins = [plugin[JavaPluginInfo] for plugin in toolchain.java_plugins],
+        deps = [
+            java_common.make_non_strict(deps_java_info),
+        ] + [dep[JavaInfo] for dep in toolchain.runtime],
+    )
+
+    return [java_info]
+
+_java_grpc_library = rule(
+    attrs = {
+        "srcs": attr.label_list(
+            mandatory = True,
+            allow_empty = False,
+            providers = [ProtoInfo],
+        ),
+        "deps": attr.label_list(
+            mandatory = True,
+            allow_empty = False,
+            providers = [JavaInfo],
+        ),
+        "_toolchain": attr.label(
+            default = Label("//compiler:java_grpc_library_toolchain"),
+        ),
+    },
+    toolchains = ["@bazel_tools//tools/jdk:toolchain_type"],
+    fragments = ["java"],
+    outputs = {
+        "jar": "lib%{name}.jar",
+        "srcjar": "lib%{name}-src.jar",
+    },
+    provides = [JavaInfo],
+    implementation = _java_rpc_library_impl,
+)
+
+# A copy of _java_grpc_library, except with a neverlink=1 _toolchain
+INTERNAL_java_grpc_library_for_xds = rule(
+    attrs = {
+        "srcs": attr.label_list(
+            mandatory = True,
+            allow_empty = False,
+            providers = [ProtoInfo],
+        ),
+        "deps": attr.label_list(
+            mandatory = True,
+            allow_empty = False,
+            providers = [JavaInfo],
+        ),
+        "_toolchain": attr.label(
+            default = Label("//xds:java_grpc_library_toolchain"),
+        ),
+    },
+    toolchains = ["@bazel_tools//tools/jdk:toolchain_type"],
+    fragments = ["java"],
+    outputs = {
+        "jar": "lib%{name}.jar",
+        "srcjar": "lib%{name}-src.jar",
+    },
+    provides = [JavaInfo],
+    implementation = _java_rpc_library_impl,
+)
+
+_java_lite_grpc_library = rule(
+    attrs = {
+        "srcs": attr.label_list(
+            mandatory = True,
+            allow_empty = False,
+            providers = [ProtoInfo],
+        ),
+        "deps": attr.label_list(
+            mandatory = True,
+            allow_empty = False,
+            providers = [JavaInfo],
+        ),
+        # This attribute has a "magic" name recognized by the native DexArchiveAspect (b/78647825).
+        "_toolchain": attr.label(
+            default = Label("//compiler:java_lite_grpc_library_toolchain"),
+        ),
+    },
+    toolchains = ["@bazel_tools//tools/jdk:toolchain_type"],
+    fragments = ["java"],
+    outputs = {
+        "jar": "lib%{name}.jar",
+        "srcjar": "lib%{name}-src.jar",
+    },
+    provides = [JavaInfo],
+    implementation = _java_rpc_library_impl,
+)
+
+def java_grpc_library(
+        name,
+        srcs,
+        deps,
+        flavor = None,
+        **kwargs):
+    """Generates gRPC Java code for services in a `proto_library`.
+
+    This rule only generates code for services; it does not generate code for
+    messages. You will need a separate java_proto_library or
+    java_lite_proto_library rule.
+
+    Args:
+      name: A unique name for this rule.
+      srcs: (List of `labels`) a single proto_library target that contains the
+        schema of the service.
+      deps: (List of `labels`) a single java_proto_library or
+        java_lite_proto_library target for the proto_library in srcs.
+      flavor: (str) "normal" (default) for normal proto runtime. "lite"
+        for the lite runtime.
+      **kwargs: Other common attributes
+    """
+
+    if len(deps) > 1:
+        print("Multiple values in 'deps' is deprecated in " + name)
+
+    if flavor == None or flavor == "normal":
+        _java_grpc_library(
+            name = name,
+            srcs = srcs,
+            deps = deps,
+            **kwargs
+        )
+    elif flavor == "lite":
+        _java_lite_grpc_library(
+            name = name,
+            srcs = srcs,
+            deps = deps,
+            **kwargs
+        )
+    else:
+        fail("Flavor must be normal or lite")
diff --git a/lint.xml b/lint.xml
new file mode 100644
index 00000000000..5b35a8d151b
--- /dev/null
+++ b/lint.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<lint>
+    <!--
+      Suppress temporarily due to AAPT2 failures with SDK 35/36 on AGP 7.x.
+      Remove after AGP upgrade.
+    -->
+    <issue id="OldTargetApi" severity="ignore" />
+
+    <!--
+    Suppress temporarily 'VisibleForTests' warnings - exposed for testing purposes
+    -->
+    <issue id="VisibleForTests" severity="ignore" />
+</lint>
diff --git a/netty/BUILD.bazel b/netty/BUILD.bazel
new file mode 100644
index 00000000000..8253d1f5bff
--- /dev/null
+++ b/netty/BUILD.bazel
@@ -0,0 +1,45 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "netty",
+    srcs = glob([
+        "src/main/java/**/*.java",
+    ]),
+    resources = glob([
+        "src/main/resources/**",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api",
+        "//core:internal",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+        artifact("io.netty:netty-buffer"),
+        artifact("io.netty:netty-codec"),
+        artifact("io.netty:netty-codec-http"),
+        artifact("io.netty:netty-codec-http2"),
+        artifact("io.netty:netty-codec-socks"),
+        artifact("io.netty:netty-common"),
+        artifact("io.netty:netty-handler"),
+        artifact("io.netty:netty-handler-proxy"),
+        artifact("io.netty:netty-resolver"),
+        artifact("io.netty:netty-transport"),
+        artifact("io.netty:netty-transport-native-unix-common"),
+        artifact("io.perfmark:perfmark-api"),
+        artifact("org.codehaus.mojo:animal-sniffer-annotations"),
+    ],
+)
+
+# Mirrors the dependencies included in the artifact on Maven Central for usage
+# with maven_install's override_targets. Should only be used as a dep for
+# pre-compiled binaries on Maven Central.
+#
+# Not actually shaded; libraries should not be referencing unstable APIs so
+# there should not be any references to the shaded package.
+java_library(
+    name = "shaded_maven",
+    visibility = ["//visibility:public"],
+    runtime_deps = ["//netty/shaded"],
+)
diff --git a/netty/build.gradle b/netty/build.gradle
index 11603c6022b..cb97ae10b55 100644
--- a/netty/build.gradle
+++ b/netty/build.gradle
@@ -1,17 +1,105 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "me.champeau.gradle.japicmp"
+    id "me.champeau.jmh"
+    id "ru.vyarus.animalsniffer"
+}
+
 description = "gRPC: Netty"
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.netty')
+    }
+}
+
 dependencies {
-    compile project(':grpc-core'),
-            libraries.netty,
-            libraries.netty_proxy_handler
+    api project(':grpc-api'),
+            libraries.animalsniffer.annotations,
+            libraries.netty.codec.http2
+    implementation project(':grpc-core'),
+            libs.netty.handler.proxy,
+            libraries.guava,
+            libraries.errorprone.annotations,
+            libraries.perfmark.api,
+            libraries.netty.unix.common
+    runtimeOnly project(":grpc-util")  // need grpc-util to pull in round robin
 
     // Tests depend on base class defined by core module.
-    testCompile project(':grpc-core').sourceSets.test.output,
-                project(':grpc-testing')
-    signature "org.codehaus.mojo.signature:java17:+@signature"
+    testImplementation testFixtures(project(':grpc-core')),
+            testFixtures(project(':grpc-api')),
+            project(':grpc-testing'),
+            project(':grpc-testing-proto'),
+            libraries.conscrypt,
+            libraries.netty.transport.epoll
+    testRuntimeOnly libraries.netty.tcnative,
+            libraries.netty.tcnative.classes
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "linux-x86_64"
+        }
+    }
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "linux-aarch_64"
+        }
+    }
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "osx-x86_64"
+        }
+    }
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "osx-aarch_64"
+        }
+    }
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "windows-x86_64"
+        }
+    }
+    testRuntimeOnly (libraries.netty.transport.epoll) {
+        artifact {
+            classifier = "linux-x86_64"
+        }
+    }
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
-test {
-    jvmArgs "-javaagent:" + configurations.alpnagent.asPath
+import net.ltgt.gradle.errorprone.CheckSeverity
+
+[tasks.named("compileJava"), tasks.named("compileTestJava")]*.configure {
+    // Netty returns a lot of futures that we mostly don't care about.
+    options.errorprone.check("FutureReturnValueIgnored", CheckSeverity.OFF)
+}
+
+tasks.named("javadoc").configure {
+    options.linksOffline 'https://netty.io/4.1/api/',
+        "${rootProject.projectDir}/gradle/javadoc/netty.io-4.1-api/"
+    exclude 'io/grpc/netty/*Provider.java'
+    exclude 'io/grpc/netty/GrpcHttp2ConnectionHandler.java'
+    exclude 'io/grpc/netty/Internal*'
+    exclude 'io/grpc/netty/ProtocolNegotiationEvent.java'
 }
 
-javadoc.options.links 'http://netty.io/4.1/api/'
+tasks.named("jmh").configure {
+    // Workaround
+    // https://github.com/melix/jmh-gradle-plugin/issues/97#issuecomment-316664026
+    includeTests = true
+}
+
+tasks.named("checkstyleMain").configure {
+    source = source.minus(fileTree(dir: "src/main", include: "**/Http2ControlFrameLimitEncoder.java"))
+}
diff --git a/netty/shaded/BUILD.bazel b/netty/shaded/BUILD.bazel
new file mode 100644
index 00000000000..0a93907bd2f
--- /dev/null
+++ b/netty/shaded/BUILD.bazel
@@ -0,0 +1,15 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+# Publicly exposed in //netty package. Purposefully does not export any symbols.
+java_library(
+    name = "shaded",
+    visibility = ["//netty:__pkg__"],
+    runtime_deps = [
+        "//netty",
+        artifact("io.netty:netty-tcnative-boringssl-static"),
+        artifact("io.netty:netty-tcnative-classes"),
+        artifact("io.netty:netty-transport-native-unix-common"),
+        artifact("io.netty:netty-transport-native-epoll_linux_x86_64"),
+    ],
+)
diff --git a/netty/shaded/build.gradle b/netty/shaded/build.gradle
new file mode 100644
index 00000000000..27816f9380b
--- /dev/null
+++ b/netty/shaded/build.gradle
@@ -0,0 +1,186 @@
+import com.github.jengelman.gradle.plugins.shadow.transformers.Transformer
+import com.github.jengelman.gradle.plugins.shadow.transformers.CacheableTransformer
+import com.github.jengelman.gradle.plugins.shadow.transformers.TransformerContext
+import org.apache.tools.zip.ZipOutputStream
+import org.apache.tools.zip.ZipEntry
+import org.gradle.api.file.FileTreeElement
+
+plugins {
+    id "java"
+    id "maven-publish"
+
+    id "com.gradleup.shadow"
+    id "ru.vyarus.animalsniffer"
+}
+
+description = "gRPC: Netty Shaded"
+
+sourceSets { testShadow {} }
+
+evaluationDependsOn(':grpc-netty')
+
+dependencies {
+    implementation project(':grpc-netty')
+    runtimeOnly libraries.netty.tcnative,
+            libraries.netty.tcnative.classes
+    runtimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "linux-x86_64"
+        }
+    }
+    runtimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "linux-aarch_64"
+        }
+    }
+    runtimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "osx-x86_64"
+        }
+    }
+    runtimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "osx-aarch_64"
+        }
+    }
+    runtimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "windows-x86_64"
+        }
+    }
+    runtimeOnly (libraries.netty.transport.epoll) {
+        artifact {
+            classifier = "linux-x86_64"
+        }
+    }
+    runtimeOnly (libraries.netty.transport.epoll) {
+        artifact {
+            classifier = "linux-aarch_64"
+        }
+    }
+    testShadowImplementation files(shadowJar),
+            project(':grpc-testing-proto'),
+            project(':grpc-testing'),
+            libraries.truth
+    shadow project(':grpc-netty').configurations.runtimeClasspath.allDependencies.matching {
+        it.group != 'io.netty'
+    }
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+tasks.named("jar").configure {
+    // Must use a different archiveClassifier to avoid conflicting with shadowJar
+    archiveClassifier = 'original'
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.netty.shaded')
+    }
+}
+
+tasks.named("shadowJar").configure {
+    archiveClassifier = null
+    dependencies {
+        include(project(':grpc-netty'))
+        include(dependency('io.netty:'))
+    }
+    exclude 'META-INF/maven/**'
+    relocate 'io.grpc.netty', 'io.grpc.netty.shaded.io.grpc.netty'
+    relocate 'io.netty', 'io.grpc.netty.shaded.io.netty'
+    // We have to be careful with these replacements as they must not match any
+    // string in NativeLibraryLoader, else they cause corruption. Note that
+    // this includes concatenation of string literals and constants.
+    relocate 'META-INF/native/libnetty', 'META-INF/native/libio_grpc_netty_shaded_netty'
+    relocate 'META-INF/native/netty', 'META-INF/native/io_grpc_netty_shaded_netty'
+    transform(NettyResourceTransformer.class)
+    mergeServiceFiles()
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            project.shadow.component(it)
+
+            // Empty jars are not published via withJavadocJar() and withSourcesJar()
+            artifact javadocJar
+            artifact sourcesJar
+
+            // Avoid confusing error message "class file for
+            // io.grpc.internal.AbstractServerImplBuilder not found"
+            // (https://github.com/grpc/grpc-java/issues/5881). This can be
+            // removed after https://github.com/grpc/grpc-java/issues/7211 is
+            // resolved.
+            pom.withXml {
+                asNode().dependencies.'*'.findAll() { dep ->
+                    dep.artifactId.text() == 'grpc-core'
+                }.each() { core ->
+                    core.scope*.value = "compile"
+                }
+            }
+        }
+    }
+}
+
+tasks.register("testShadow", Test) {
+    testClassesDirs = sourceSets.testShadow.output.classesDirs
+    classpath = sourceSets.testShadow.runtimeClasspath
+}
+tasks.named("compileTestShadowJava").configure {
+    options.compilerArgs = compileTestJava.options.compilerArgs
+    options.encoding = compileTestJava.options.encoding
+}
+
+tasks.named("test").configure {
+    dependsOn tasks.named("testShadow")
+}
+
+/**
+ * A Transformer which updates the Netty JAR META-INF/ resources to accurately
+ * reference shaded class names.
+ */
+@CacheableTransformer
+class NettyResourceTransformer implements Transformer {
+
+    // A map of resource file paths to be modified
+    private Map<String, String> resources = [:]
+
+    @Override
+    boolean canTransformResource(FileTreeElement fileTreeElement) {
+        // io.netty.versions.properties can't actually be shaded successfully,
+        // as io.netty.util.Version still looks for the unshaded name. But we
+        // keep the file for manual inspection.
+        fileTreeElement.name.startsWith("META-INF/native-image/io.netty") ||
+            fileTreeElement.name.startsWith("META-INF/io.netty.versions.properties")
+    }
+
+    @Override
+    void transform(TransformerContext context) {
+        String updatedPath = context.path.replace("io.netty", "io.grpc.netty.shaded.io.netty")
+        String updatedContent = context.is.getText().replace("io.netty", "io.grpc.netty.shaded.io.netty")
+        resources.put(updatedPath, updatedContent)
+    }
+
+    @Override
+    boolean hasTransformedResource() {
+        resources.size() > 0
+    }
+
+    @Override
+    void modifyOutputStream(ZipOutputStream outputStream, boolean preserveFileTimestamps) {
+        for (resourceEntry in resources) {
+            ZipEntry entry = new ZipEntry(resourceEntry.key)
+            entry.time = TransformerContext.getEntryTimestamp(preserveFileTimestamps, entry.time)
+
+            outputStream.putNextEntry(entry)
+            outputStream.write(resourceEntry.value.getBytes())
+            outputStream.closeEntry()
+        }
+    }
+}
diff --git a/netty/shaded/src/testShadow/java/io/grpc/netty/shaded/ShadingTest.java b/netty/shaded/src/testShadow/java/io/grpc/netty/shaded/ShadingTest.java
new file mode 100644
index 00000000000..89803998925
--- /dev/null
+++ b/netty/shaded/src/testShadow/java/io/grpc/netty/shaded/ShadingTest.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2017 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.netty.shaded;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.ServerCredentials;
+import io.grpc.TlsServerCredentials;
+import io.grpc.netty.shaded.io.grpc.netty.GrpcSslContexts;
+import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;
+import io.grpc.netty.shaded.io.grpc.netty.NettyServerBuilder;
+import io.grpc.netty.shaded.io.grpc.netty.NettySslContextChannelCredentials;
+import io.grpc.netty.shaded.io.netty.handler.ssl.SslContextBuilder;
+import io.grpc.netty.shaded.io.netty.handler.ssl.SslProvider;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.TlsTesting;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import io.grpc.testing.protobuf.SimpleServiceGrpc.SimpleServiceBlockingStub;
+import io.grpc.testing.protobuf.SimpleServiceGrpc.SimpleServiceImplBase;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Scanner;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for shaded gRPC Netty. */
+@RunWith(JUnit4.class)
+public final class ShadingTest {
+  private ManagedChannel channel;
+  private Server server;
+
+  @After
+  public void tearDown() throws Exception {
+    if (channel != null) {
+      channel.shutdownNow();
+      channel.awaitTermination(1, TimeUnit.SECONDS);
+    }
+    if (server != null) {
+      server.shutdownNow();
+      server.awaitTermination(1, TimeUnit.SECONDS);
+    }
+  }
+
+  /** Verify that normal Netty didn't leak into the test runtime. */
+  @Test(expected = ClassNotFoundException.class)
+  public void noNormalNetty() throws Exception {
+    Class.forName("io.grpc.netty.NettyServerBuilder");
+  }
+
+  /** Verify that resources under META-INF/native-image reference shaded class names. */
+  @Test
+  public void nettyResourcesUpdated() throws IOException {
+    InputStream inputStream = NettyChannelBuilder.class.getClassLoader()
+        .getResourceAsStream(
+            "META-INF/native-image/io.grpc.netty.shaded.io.netty/netty-transport/"
+                + "reflect-config.json");
+    assertThat(inputStream).isNotNull();
+
+    Scanner s = new Scanner(inputStream, StandardCharsets.UTF_8.name()).useDelimiter("\\A");
+    String reflectionConfig = s.hasNext() ? s.next() : "";
+
+    assertThat(reflectionConfig).contains("io.grpc.netty.shaded.io.netty");
+  }
+
+  @Test
+  public void serviceLoaderFindsNetty() throws Exception {
+    assertThat(Grpc.newServerBuilderForPort(0, InsecureServerCredentials.create()))
+        .isInstanceOf(NettyServerBuilder.class);
+    assertThat(Grpc.newChannelBuilder("localhost:1234", InsecureChannelCredentials.create()))
+        .isInstanceOf(NettyChannelBuilder.class);
+  }
+
+  @Test
+  public void basic() throws Exception {
+    server = Grpc.newServerBuilderForPort(0, InsecureServerCredentials.create())
+        .addService(new SimpleServiceImpl())
+        .build().start();
+    channel = Grpc.newChannelBuilder(
+          "localhost:" + server.getPort(), InsecureChannelCredentials.create())
+        .build();
+    SimpleServiceBlockingStub stub = SimpleServiceGrpc.newBlockingStub(channel);
+    assertThat(SimpleResponse.getDefaultInstance())
+        .isEqualTo(stub.unaryRpc(SimpleRequest.getDefaultInstance()));
+  }
+
+  @Test
+  public void tcnative() throws Exception {
+    ServerCredentials serverCreds = TlsServerCredentials.create(
+        TlsTesting.loadCert("server1.pem"), TlsTesting.loadCert("server1.key"));
+    server = Grpc.newServerBuilderForPort(0, serverCreds)
+        .addService(new SimpleServiceImpl())
+        .build().start();
+    ChannelCredentials creds = NettySslContextChannelCredentials.create(
+        GrpcSslContexts.configure(SslContextBuilder.forClient(), SslProvider.OPENSSL)
+            .trustManager(TlsTesting.loadCert("ca.pem")).build());
+    channel = Grpc.newChannelBuilder("localhost:" + server.getPort(), creds)
+        .overrideAuthority("foo.test.google.fr")
+        .build();
+    SimpleServiceBlockingStub stub = SimpleServiceGrpc.newBlockingStub(channel);
+    assertThat(SimpleResponse.getDefaultInstance())
+        .isEqualTo(stub.unaryRpc(SimpleRequest.getDefaultInstance()));
+  }
+
+  private static class SimpleServiceImpl extends SimpleServiceImplBase {
+    @Override public void unaryRpc(SimpleRequest req, StreamObserver<SimpleResponse> obs) {
+      obs.onNext(SimpleResponse.getDefaultInstance());
+      obs.onCompleted();
+    }
+  }
+}
diff --git a/netty/src/jmh/java/io/grpc/netty/InboundHeadersBenchmark.java b/netty/src/jmh/java/io/grpc/netty/InboundHeadersBenchmark.java
new file mode 100644
index 00000000000..504f4ec27d7
--- /dev/null
+++ b/netty/src/jmh/java/io/grpc/netty/InboundHeadersBenchmark.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright 2016 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.netty;
+
+import static io.grpc.netty.Utils.CONTENT_TYPE_HEADER;
+import static io.grpc.netty.Utils.TE_TRAILERS;
+
+import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2RequestHeaders;
+import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2ResponseHeaders;
+import io.netty.handler.codec.http2.DefaultHttp2Headers;
+import io.netty.handler.codec.http2.Http2Headers;
+import io.netty.util.AsciiString;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.CompilerControl;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.infra.Blackhole;
+
+/**
+ * Benchmarks for {@link GrpcHttp2RequestHeaders} and {@link GrpcHttp2ResponseHeaders}.
+ */
+@State(Scope.Thread)
+public class InboundHeadersBenchmark {
+
+  private static AsciiString[] requestHeaders;
+  private static AsciiString[] responseHeaders;
+
+  static {
+    setupRequestHeaders();
+    setupResponseHeaders();
+  }
+
+  // Headers taken from the gRPC spec.
+  private static void setupRequestHeaders() {
+    requestHeaders = new AsciiString[18];
+    int i = 0;
+    requestHeaders[i++] = AsciiString.of(":method");
+    requestHeaders[i++] = AsciiString.of("POST");
+    requestHeaders[i++] = AsciiString.of(":scheme");
+    requestHeaders[i++] = AsciiString.of("http");
+    requestHeaders[i++] = AsciiString.of(":path");
+    requestHeaders[i++] = AsciiString.of("/google.pubsub.v2.PublisherService/CreateTopic");
+    requestHeaders[i++] = AsciiString.of(":authority");
+    requestHeaders[i++] = AsciiString.of("pubsub.googleapis.com");
+    requestHeaders[i++] = AsciiString.of("te");
+    requestHeaders[i++] = AsciiString.of("trailers");
+    requestHeaders[i++] = AsciiString.of("grpc-timeout");
+    requestHeaders[i++] = AsciiString.of("1S");
+    requestHeaders[i++] = AsciiString.of("content-type");
+    requestHeaders[i++] = AsciiString.of("application/grpc+proto");
+    requestHeaders[i++] = AsciiString.of("grpc-encoding");
+    requestHeaders[i++] = AsciiString.of("gzip");
+    requestHeaders[i++] = AsciiString.of("authorization");
+    requestHeaders[i] = AsciiString.of("Bearer y235.wef315yfh138vh31hv93hv8h3v");
+  }
+
+  private static void setupResponseHeaders() {
+    responseHeaders = new AsciiString[4];
+    int i = 0;
+    responseHeaders[i++] = AsciiString.of(":status");
+    responseHeaders[i++] = AsciiString.of("200");
+    responseHeaders[i++] = AsciiString.of("grpc-encoding");
+    responseHeaders[i] = AsciiString.of("gzip");
+  }
+
+  /**
+   * Checkstyle.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.AverageTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public void grpcHeaders_serverHandler(Blackhole bh) {
+    serverHandler(bh, new GrpcHttp2RequestHeaders(4));
+  }
+
+  /**
+   * Checkstyle.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.AverageTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public void defaultHeaders_serverHandler(Blackhole bh) {
+    serverHandler(bh, new DefaultHttp2Headers(true, 9));
+  }
+
+  /**
+   *  Checkstyle.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.AverageTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public void grpcHeaders_clientHandler(Blackhole bh) {
+    clientHandler(bh, new GrpcHttp2ResponseHeaders(2));
+  }
+
+  /**
+   * Checkstyle.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.AverageTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public void defaultHeaders_clientHandler(Blackhole bh) {
+    clientHandler(bh, new DefaultHttp2Headers(true, 2));
+  }
+
+  @CompilerControl(CompilerControl.Mode.INLINE)
+  private static void serverHandler(Blackhole bh, Http2Headers headers) {
+    for (int i = 0; i < requestHeaders.length; i += 2) {
+      bh.consume(headers.add(requestHeaders[i], requestHeaders[i + 1]));
+    }
+
+    // Sequence of headers accessed in NettyServerHandler
+    bh.consume(headers.get(TE_TRAILERS));
+    bh.consume(headers.get(CONTENT_TYPE_HEADER));
+    bh.consume(headers.method());
+    bh.consume(headers.get(CONTENT_TYPE_HEADER));
+    bh.consume(headers.path());
+
+    bh.consume(Utils.convertHeaders(headers));
+  }
+
+  @CompilerControl(CompilerControl.Mode.INLINE)
+  private static void clientHandler(Blackhole bh, Http2Headers headers) {
+    // NettyClientHandler does not directly access headers, but convert to Metadata immediately.
+
+    bh.consume(headers.add(responseHeaders[0], responseHeaders[1]));
+    bh.consume(headers.add(responseHeaders[2], responseHeaders[3]));
+
+    bh.consume(Utils.convertHeaders(headers));
+  }
+
+  ///**
+  // * Prints the size of the header objects in bytes. Needs JOL (Java Object Layout) as a
+  // * dependency.
+  // */
+  //public static void main(String... args) {
+  //  Http2Headers grpcRequestHeaders = new GrpcHttp2RequestHeaders(4);
+  //  Http2Headers defaultRequestHeaders = new DefaultHttp2Headers(true, 9);
+  //  for (int i = 0; i < requestHeaders.length; i += 2) {
+  //    grpcRequestHeaders.add(requestHeaders[i], requestHeaders[i + 1]);
+  //    defaultRequestHeaders.add(requestHeaders[i], requestHeaders[i + 1]);
+  //  }
+  //  long c = 10L;
+  //  int m = ((int) c) / 20;
+
+  //  long grpcRequestHeadersBytes = GraphLayout.parseInstance(grpcRequestHeaders).totalSize();
+  //  long defaultRequestHeadersBytes =
+  //      GraphLayout.parseInstance(defaultRequestHeaders).totalSize();
+
+  //  System.out.printf("gRPC Request Headers: %d bytes%nNetty Request Headers: %d bytes%n",
+  //      grpcRequestHeadersBytes, defaultRequestHeadersBytes);
+
+  //  Http2Headers grpcResponseHeaders = new GrpcHttp2RequestHeaders(4);
+  //  Http2Headers defaultResponseHeaders = new DefaultHttp2Headers(true, 9);
+  //  for (int i = 0; i < responseHeaders.length; i += 2) {
+  //    grpcResponseHeaders.add(responseHeaders[i], responseHeaders[i + 1]);
+  //    defaultResponseHeaders.add(responseHeaders[i], responseHeaders[i + 1]);
+  //  }
+
+  //  long grpcResponseHeadersBytes = GraphLayout.parseInstance(grpcResponseHeaders).totalSize();
+  //  long defaultResponseHeadersBytes =
+  //      GraphLayout.parseInstance(defaultResponseHeaders).totalSize();
+
+  //  System.out.printf("gRPC Response Headers: %d bytes%nNetty Response Headers: %d bytes%n",
+  //      grpcResponseHeadersBytes, defaultResponseHeadersBytes);
+  //}
+}
diff --git a/netty/src/jmh/java/io/grpc/netty/MethodDescriptorBenchmark.java b/netty/src/jmh/java/io/grpc/netty/MethodDescriptorBenchmark.java
new file mode 100644
index 00000000000..96844016c5c
--- /dev/null
+++ b/netty/src/jmh/java/io/grpc/netty/MethodDescriptorBenchmark.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2016 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.netty;
+
+import io.grpc.InternalKnownTransport;
+import io.grpc.InternalMethodDescriptor;
+import io.grpc.MethodDescriptor;
+import io.netty.util.AsciiString;
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+
+/**
+ * Benchmark for Method Descriptors.
+ */
+@State(Scope.Benchmark)
+public class MethodDescriptorBenchmark {
+
+  private static final MethodDescriptor.Marshaller<Void> marshaller =
+      new MethodDescriptor.Marshaller<Void>() {
+        @Override
+        public InputStream stream(Void value) {
+          return new ByteArrayInputStream(new byte[]{});
+        }
+
+        @Override
+        public Void parse(InputStream stream) {
+          return null;
+        }
+      };
+
+  MethodDescriptor<Void, Void> method = MethodDescriptor.<Void, Void>newBuilder()
+      .setType(MethodDescriptor.MethodType.UNARY)
+      .setFullMethodName("Service/Method")
+      .setRequestMarshaller(marshaller)
+      .setResponseMarshaller(marshaller)
+      .build();
+
+  InternalMethodDescriptor imd = new InternalMethodDescriptor(InternalKnownTransport.NETTY);
+
+  byte[] directBytes = new AsciiString("/" + method.getFullMethodName()).toByteArray();
+
+  /** Foo bar. */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public AsciiString old() {
+    return new AsciiString("/" + method.getFullMethodName());
+  }
+
+  /** Foo bar. */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public AsciiString transportSpecific() {
+    AsciiString path;
+    if ((path = (AsciiString) imd.geRawMethodName(method)) != null) {
+      path = new AsciiString("/" + method.getFullMethodName());
+      imd.setRawMethodName(method, path);
+    }
+    return path;
+  }
+
+  /** Foo bar. */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public AsciiString direct() {
+    return new AsciiString(directBytes, false);
+  }
+}
+
diff --git a/netty/src/jmh/java/io/grpc/netty/OutboundHeadersBenchmark.java b/netty/src/jmh/java/io/grpc/netty/OutboundHeadersBenchmark.java
new file mode 100644
index 00000000000..5bfc7390b4b
--- /dev/null
+++ b/netty/src/jmh/java/io/grpc/netty/OutboundHeadersBenchmark.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2016 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.netty;
+
+import io.grpc.Metadata;
+import io.grpc.Metadata.AsciiMarshaller;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.UnpooledByteBufAllocator;
+import io.netty.handler.codec.http2.DefaultHttp2HeadersEncoder;
+import io.netty.handler.codec.http2.Http2Headers;
+import io.netty.handler.codec.http2.Http2HeadersEncoder;
+import io.netty.util.AsciiString;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+
+/**
+ * Header encoding benchmark.
+ */
+@State(Scope.Benchmark)
+public class OutboundHeadersBenchmark {
+  @Param({"1", "5", "10", "20"})
+  public int headerCount;
+
+  private final AsciiMarshaller<String> keyMarshaller = new AsciiMarshaller<String>() {
+    @Override
+    public String toAsciiString(String value) {
+      return value;
+    }
+
+    @Override
+    public String parseAsciiString(String serialized) {
+      return serialized;
+    }
+  };
+
+  private final Metadata metadata = new Metadata();
+  private final AsciiString scheme = new AsciiString("https");
+  private final AsciiString defaultPath = new AsciiString("/Service.MethodMethodMethod");
+  private final AsciiString authority = new AsciiString("authority.googleapis.bogus");
+  private final AsciiString userAgent = new AsciiString("grpc-java-netty");
+  private final Http2HeadersEncoder headersEncoder = new DefaultHttp2HeadersEncoder();
+  private final ByteBuf scratchBuffer = UnpooledByteBufAllocator.DEFAULT.buffer(4096);
+
+  @Setup
+  public void setUp() throws Exception {
+    for (int i = 0; i < headerCount; i++) {
+      metadata.put(Metadata.Key.of("key-" + i, keyMarshaller), UUID.randomUUID().toString());
+    }
+  }
+
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public Http2Headers convertClientHeaders() {
+    return Utils.convertClientHeaders(metadata, scheme, defaultPath, authority, Utils.HTTP_METHOD,
+        userAgent);
+  }
+
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public Http2Headers convertServerHeaders() {
+    return Utils.convertServerHeaders(metadata);
+  }
+
+  /**
+   * This will encode the random metadata fields, and repeatedly lookup the default other headers.
+   */
+  @Benchmark
+  @BenchmarkMode(Mode.SampleTime)
+  @OutputTimeUnit(TimeUnit.NANOSECONDS)
+  public ByteBuf encodeClientHeaders() throws Exception {
+    scratchBuffer.clear();
+    Http2Headers headers =
+        Utils.convertClientHeaders(metadata, scheme, defaultPath, authority, Utils.HTTP_METHOD,
+            userAgent);
+    headersEncoder.encodeHeaders(1, headers, scratchBuffer);
+    return scratchBuffer;
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/AbstractHttp2Headers.java b/netty/src/main/java/io/grpc/netty/AbstractHttp2Headers.java
index 3abe76b26ef..00395acda53 100644
--- a/netty/src/main/java/io/grpc/netty/AbstractHttp2Headers.java
+++ b/netty/src/main/java/io/grpc/netty/AbstractHttp2Headers.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -35,11 +20,16 @@
 import io.netty.handler.codec.http2.Http2Headers;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map.Entry;
+import java.util.Map;
 import java.util.Set;
 
 abstract class AbstractHttp2Headers implements Http2Headers {
 
+  @Override
+  public Iterator<CharSequence> valueIterator(CharSequence name) {
+    throw new UnsupportedOperationException();
+  }
+
   @Override
   public int size() {
     throw new UnsupportedOperationException();
@@ -47,7 +37,7 @@ public int size() {
 
   @Override
   public boolean isEmpty() {
-    throw new UnsupportedOperationException();
+    return size() == 0;
   }
 
   @Override
@@ -275,6 +265,11 @@ public boolean contains(CharSequence name, CharSequence value) {
     throw new UnsupportedOperationException();
   }
 
+  @Override
+  public boolean contains(CharSequence name, CharSequence value, boolean caseInsensitive) {
+    throw new UnsupportedOperationException();
+  }
+
   @Override
   public boolean containsObject(CharSequence name, Object value) {
     throw new UnsupportedOperationException();
@@ -501,7 +496,7 @@ public Http2Headers clear() {
   }
 
   @Override
-  public Iterator<Entry<CharSequence, CharSequence>> iterator() {
+  public Iterator<Map.Entry<CharSequence, CharSequence>> iterator() {
     throw new UnsupportedOperationException();
   }
 
diff --git a/netty/src/main/java/io/grpc/netty/AbstractNettyHandler.java b/netty/src/main/java/io/grpc/netty/AbstractNettyHandler.java
index 69759680264..c4ec5913cde 100644
--- a/netty/src/main/java/io/grpc/netty/AbstractNettyHandler.java
+++ b/netty/src/main/java/io/grpc/netty/AbstractNettyHandler.java
@@ -1,44 +1,30 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
-import static io.netty.buffer.Unpooled.directBuffer;
-import static io.netty.buffer.Unpooled.unreleasableBuffer;
+import static com.google.common.base.Preconditions.checkNotNull;
 import static io.netty.handler.codec.http2.Http2CodecUtil.getEmbeddedHttp2Exception;
-import static java.util.concurrent.TimeUnit.SECONDS;
 
 import com.google.common.annotations.VisibleForTesting;
-import io.netty.buffer.ByteBuf;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Ticker;
+import io.grpc.ChannelLogger;
 import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
 import io.netty.handler.codec.http2.Http2ConnectionDecoder;
 import io.netty.handler.codec.http2.Http2ConnectionEncoder;
 import io.netty.handler.codec.http2.Http2Exception;
@@ -52,27 +38,47 @@
  * shutdown the connection) as well as sending the initial connection window at startup.
  */
 abstract class AbstractNettyHandler extends GrpcHttp2ConnectionHandler {
-  private static long GRACEFUL_SHUTDOWN_TIMEOUT = SECONDS.toMillis(5);
-  private boolean autoTuneFlowControlOn = false;
-  private int initialConnectionWindow;
+  private static final long GRACEFUL_SHUTDOWN_NO_TIMEOUT = -1;
+
+  private final int initialConnectionWindow;
+  private final FlowControlPinger flowControlPing;
+  protected final int maxHeaderListSize;
+  protected final int softLimitHeaderListSize;
+  private boolean autoTuneFlowControlOn;
   private ChannelHandlerContext ctx;
-  private final FlowControlPinger flowControlPing = new FlowControlPinger();
+  private boolean initialWindowSent = false;
+  private final Ticker ticker;
 
-  private static final int BDP_MEASUREMENT_PING = 1234;
-  private static final ByteBuf payloadBuf =
-      unreleasableBuffer(directBuffer(8).writeLong(BDP_MEASUREMENT_PING));
+  private static final long BDP_MEASUREMENT_PING = 1234;
+  protected static final int MIN_ALLOCATED_CHUNK = 16 * 1024;
 
-  AbstractNettyHandler(Http2ConnectionDecoder decoder,
-                       Http2ConnectionEncoder encoder,
-                       Http2Settings initialSettings) {
-    super(decoder, encoder, initialSettings);
+  AbstractNettyHandler(
+      ChannelPromise channelUnused,
+      Http2ConnectionDecoder decoder,
+      Http2ConnectionEncoder encoder,
+      Http2Settings initialSettings,
+      ChannelLogger negotiationLogger,
+      boolean autoFlowControl,
+      PingLimiter pingLimiter,
+      Ticker ticker,
+      int maxHeaderListSize,
+      int softLimitHeaderListSize) {
+    super(channelUnused, decoder, encoder, initialSettings, negotiationLogger);
 
-    // Set the timeout for graceful shutdown.
-    gracefulShutdownTimeoutMillis(GRACEFUL_SHUTDOWN_TIMEOUT);
+    // During a graceful shutdown, wait until all streams are closed.
+    gracefulShutdownTimeoutMillis(GRACEFUL_SHUTDOWN_NO_TIMEOUT);
 
     // Extract the connection window from the settings if it was set.
     this.initialConnectionWindow = initialSettings.initialWindowSize() == null ? -1 :
-            initialSettings.initialWindowSize();
+        initialSettings.initialWindowSize();
+    this.autoTuneFlowControlOn = autoFlowControl;
+    if (pingLimiter == null) {
+      pingLimiter = new AllowPingLimiter();
+    }
+    this.flowControlPing = new FlowControlPinger(pingLimiter);
+    this.ticker = checkNotNull(ticker, "ticker");
+    this.maxHeaderListSize = maxHeaderListSize;
+    this.softLimitHeaderListSize = softLimitHeaderListSize;
   }
 
   @Override
@@ -96,7 +102,7 @@ public final void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) th
     if (embedded == null) {
       // There was no embedded Http2Exception, assume it's a connection error. Subclasses are
       // responsible for storing the appropriate status and shutting down the connection.
-      onError(ctx, cause);
+      onError(ctx, /* outbound= */ false, cause);
     } else {
       super.exceptionCaught(ctx, cause);
     }
@@ -110,12 +116,12 @@ protected final ChannelHandlerContext ctx() {
    * Sends initial connection window to the remote endpoint if necessary.
    */
   private void sendInitialConnectionWindow() throws Http2Exception {
-    if (ctx.channel().isActive() && initialConnectionWindow > 0) {
+    if (!initialWindowSent && ctx.channel().isActive()) {
       Http2Stream connectionStream = connection().connectionStream();
       int currentSize = connection().local().flowController().windowSize(connectionStream);
       int delta = initialConnectionWindow - currentSize;
       decoder().flowController().incrementWindowSize(connectionStream, delta);
-      initialConnectionWindow = -1;
+      initialWindowSent = true;
       ctx.flush();
     }
   }
@@ -136,14 +142,24 @@ void setAutoTuneFlowControl(boolean isOn) {
   final class FlowControlPinger {
 
     private static final int MAX_WINDOW_SIZE = 8 * 1024 * 1024;
+    public static final int MAX_BACKOFF = 10;
+
+    private final PingLimiter pingLimiter;
     private int pingCount;
     private int pingReturn;
     private boolean pinging;
     private int dataSizeSincePing;
-    private float lastBandwidth; // bytes per second
+    private long lastBandwidth; // bytes per nanosecond
     private long lastPingTime;
+    private int lastTargetWindow;
+    private int pingFrequencyMultiplier;
 
-    public int payload() {
+    public FlowControlPinger(PingLimiter pingLimiter) {
+      Preconditions.checkNotNull(pingLimiter, "pingLimiter");
+      this.pingLimiter = pingLimiter;
+    }
+
+    public long payload() {
       return BDP_MEASUREMENT_PING;
     }
 
@@ -155,10 +171,24 @@ public void onDataRead(int dataLength, int paddingLength) {
       if (!autoTuneFlowControlOn) {
         return;
       }
-      if (!isPinging()) {
+
+      // Note that we are double counting around the ping initiation as the current data will be
+      // added at the end of this method, so will be available in the next check.  This at worst
+      // causes us to send a ping one data packet earlier, but makes startup faster if there are
+      // small packets before big ones.
+      int dataForCheck = getDataSincePing() + dataLength + paddingLength;
+      // Need to double the data here to account for targetWindow being set to twice the data below
+      if (!isPinging() && pingLimiter.isPingAllowed()
+          && dataForCheck * 2 >= lastTargetWindow * pingFrequencyMultiplier) {
         setPinging(true);
         sendPing(ctx());
       }
+
+      if (lastTargetWindow == 0) {
+        lastTargetWindow =
+            decoder().flowController().initialWindowSize(connection().connectionStream());
+      }
+
       incrementDataSincePing(dataLength + paddingLength);
     }
 
@@ -167,26 +197,32 @@ public void updateWindow() throws Http2Exception {
         return;
       }
       pingReturn++;
-      long elapsedTime = (System.nanoTime() - lastPingTime);
+      setPinging(false);
+
+      long elapsedTime = (ticker.read() - lastPingTime);
       if (elapsedTime == 0) {
         elapsedTime = 1;
       }
+
       long bandwidth = (getDataSincePing() * TimeUnit.SECONDS.toNanos(1)) / elapsedTime;
-      Http2LocalFlowController fc = decoder().flowController();
       // Calculate new window size by doubling the observed BDP, but cap at max window
       int targetWindow = Math.min(getDataSincePing() * 2, MAX_WINDOW_SIZE);
-      setPinging(false);
+      Http2LocalFlowController fc = decoder().flowController();
       int currentWindow = fc.initialWindowSize(connection().connectionStream());
-      if (targetWindow > currentWindow && bandwidth > lastBandwidth) {
-        lastBandwidth = bandwidth;
-        int increase = targetWindow - currentWindow;
-        fc.incrementWindowSize(connection().connectionStream(), increase);
-        fc.initialWindowSize(targetWindow);
-        Http2Settings settings = new Http2Settings();
-        settings.initialWindowSize(targetWindow);
-        frameWriter().writeSettings(ctx(), settings, ctx().newPromise());
+      if (bandwidth <= lastBandwidth || targetWindow <= currentWindow) {
+        pingFrequencyMultiplier = Math.min(pingFrequencyMultiplier + 1, MAX_BACKOFF);
+        return;
       }
 
+      pingFrequencyMultiplier = 0; // react quickly when size is changing
+      lastBandwidth = bandwidth;
+      lastTargetWindow = targetWindow;
+      int increase = targetWindow - currentWindow;
+      fc.incrementWindowSize(connection().connectionStream(), increase);
+      fc.initialWindowSize(targetWindow);
+      Http2Settings settings = new Http2Settings();
+      settings.initialWindowSize(targetWindow);
+      frameWriter().writeSettings(ctx(), settings, ctx().newPromise());
     }
 
     private boolean isPinging() {
@@ -199,8 +235,8 @@ private void setPinging(boolean pingOut) {
 
     private void sendPing(ChannelHandlerContext ctx) {
       setDataSizeSincePing(0);
-      lastPingTime = System.nanoTime();
-      encoder().writePing(ctx, false, payloadBuf.slice(), ctx.newPromise());
+      lastPingTime = ticker.read();
+      encoder().writePing(ctx, false, BDP_MEASUREMENT_PING, ctx.newPromise());
       pingCount++;
     }
 
@@ -224,9 +260,27 @@ int getDataSincePing() {
       return dataSizeSincePing;
     }
 
-    @VisibleForTesting
-    void setDataSizeSincePing(int dataSize) {
+    private void setDataSizeSincePing(int dataSize) {
       dataSizeSincePing = dataSize;
     }
+
+    // Only used in testing
+    @VisibleForTesting
+    void setDataSizeAndSincePing(int dataSize) {
+      setDataSizeSincePing(dataSize);
+      pingFrequencyMultiplier = 1;
+      lastPingTime = ticker.read() ;
+    }
+  }
+
+  /** Controls whether PINGs like those for BDP are permitted to be sent at the current time. */
+  public interface PingLimiter {
+    boolean isPingAllowed();
+  }
+
+  private static final class AllowPingLimiter implements PingLimiter {
+    @Override public boolean isPingAllowed() {
+      return true;
+    }
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/CancelClientStreamCommand.java b/netty/src/main/java/io/grpc/netty/CancelClientStreamCommand.java
index 249c724b2a7..8ccb3faee5c 100644
--- a/netty/src/main/java/io/grpc/netty/CancelClientStreamCommand.java
+++ b/netty/src/main/java/io/grpc/netty/CancelClientStreamCommand.java
@@ -1,50 +1,36 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
 import com.google.common.base.Preconditions;
 import io.grpc.Status;
+import javax.annotation.Nullable;
 
 /**
  * Command sent from a Netty client stream to the handler to cancel the stream.
  */
 class CancelClientStreamCommand extends WriteQueue.AbstractQueuedCommand {
   private final NettyClientStream.TransportState stream;
-  private final Status reason;
+  @Nullable private final Status reason;
 
   CancelClientStreamCommand(NettyClientStream.TransportState stream, Status reason) {
     this.stream = Preconditions.checkNotNull(stream, "stream");
-    Preconditions.checkNotNull(reason, "reason");
-    Preconditions.checkArgument(!reason.isOk(), "Should not cancel with OK status");
+    Preconditions.checkArgument(
+        reason == null || !reason.isOk(), "Should not cancel with OK status");
     this.reason = reason;
   }
 
@@ -52,6 +38,7 @@ NettyClientStream.TransportState stream() {
     return stream;
   }
 
+  @Nullable
   Status reason() {
     return reason;
   }
diff --git a/netty/src/main/java/io/grpc/netty/CancelServerStreamCommand.java b/netty/src/main/java/io/grpc/netty/CancelServerStreamCommand.java
index bc27a379338..a3b29457670 100644
--- a/netty/src/main/java/io/grpc/netty/CancelServerStreamCommand.java
+++ b/netty/src/main/java/io/grpc/netty/CancelServerStreamCommand.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -39,13 +24,26 @@
 /**
  * Command sent from a Netty server stream to the handler to cancel the stream.
  */
-class CancelServerStreamCommand extends WriteQueue.AbstractQueuedCommand {
+final class CancelServerStreamCommand extends WriteQueue.AbstractQueuedCommand {
   private final NettyServerStream.TransportState stream;
   private final Status reason;
+  private final PeerNotify peerNotify;
 
-  CancelServerStreamCommand(NettyServerStream.TransportState stream, Status reason) {
+  private CancelServerStreamCommand(
+          NettyServerStream.TransportState stream, Status reason, PeerNotify peerNotify) {
     this.stream = Preconditions.checkNotNull(stream, "stream");
     this.reason = Preconditions.checkNotNull(reason, "reason");
+    this.peerNotify = Preconditions.checkNotNull(peerNotify, "peerNotify");
+  }
+
+  static CancelServerStreamCommand withReset(
+          NettyServerStream.TransportState stream, Status reason) {
+    return new CancelServerStreamCommand(stream, reason, PeerNotify.RESET);
+  }
+
+  static CancelServerStreamCommand withReason(
+          NettyServerStream.TransportState stream, Status reason) {
+    return new CancelServerStreamCommand(stream, reason, PeerNotify.BEST_EFFORT_STATUS);
   }
 
   NettyServerStream.TransportState stream() {
@@ -56,6 +54,10 @@ Status reason() {
     return reason;
   }
 
+  boolean wantsHeaders() {
+    return peerNotify == PeerNotify.BEST_EFFORT_STATUS;
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {
@@ -67,13 +69,14 @@ public boolean equals(Object o) {
 
     CancelServerStreamCommand that = (CancelServerStreamCommand) o;
 
-    return Objects.equal(this.stream, that.stream)
-        && Objects.equal(this.reason, that.reason);
+    return this.stream.equals(that.stream)
+        && this.reason.equals(that.reason)
+        && this.peerNotify.equals(that.peerNotify);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hashCode(stream, reason);
+    return Objects.hashCode(stream, reason, peerNotify);
   }
 
   @Override
@@ -81,6 +84,14 @@ public String toString() {
     return MoreObjects.toStringHelper(this)
         .add("stream", stream)
         .add("reason", reason)
+        .add("peerNotify", peerNotify)
         .toString();
   }
+
+  private enum PeerNotify {
+    /** Notify the peer by sending a RST_STREAM with no other information. */
+    RESET,
+    /** Notify the peer about the {@link #reason} by sending structured headers, if possible. */
+    BEST_EFFORT_STATUS,
+  }
 }
diff --git a/netty/src/main/java/io/grpc/netty/ClientTransportLifecycleManager.java b/netty/src/main/java/io/grpc/netty/ClientTransportLifecycleManager.java
index 2637b84b4b5..01e7bc3ed12 100644
--- a/netty/src/main/java/io/grpc/netty/ClientTransportLifecycleManager.java
+++ b/netty/src/main/java/io/grpc/netty/ClientTransportLifecycleManager.java
@@ -1,37 +1,25 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import io.grpc.Attributes;
 import io.grpc.Status;
+import io.grpc.internal.DisconnectError;
 import io.grpc.internal.ManagedClientTransport;
 
 /** Maintainer of transport lifecycle status. */
@@ -43,13 +31,19 @@ final class ClientTransportLifecycleManager {
   /** null iff !transportShutdown. */
   private Status shutdownStatus;
   /** null iff !transportShutdown. */
-  private Throwable shutdownThrowable;
   private boolean transportTerminated;
 
   public ClientTransportLifecycleManager(ManagedClientTransport.Listener listener) {
     this.listener = listener;
   }
 
+  public Attributes filterAttributes(Attributes attributes) {
+    if (transportReady || transportShutdown) {
+      return attributes;
+    }
+    return listener.filterTransport(attributes);
+  }
+
   public void notifyReady() {
     if (transportReady || transportShutdown) {
       return;
@@ -58,14 +52,27 @@ public void notifyReady() {
     listener.transportReady();
   }
 
-  public void notifyShutdown(Status s) {
+  /**
+   * Marks transport as shutdown, but does not set the error status. This must eventually be
+   * followed by a call to notifyShutdown.
+   */
+  public void notifyGracefulShutdown(Status s, DisconnectError disconnectError) {
     if (transportShutdown) {
       return;
     }
     transportShutdown = true;
+    listener.transportShutdown(s, disconnectError);
+  }
+
+  /** Returns {@code true} if was the first shutdown. */
+  @CanIgnoreReturnValue
+  public boolean notifyShutdown(Status s, DisconnectError disconnectError) {
+    notifyGracefulShutdown(s, disconnectError);
+    if (shutdownStatus != null) {
+      return false;
+    }
     shutdownStatus = s;
-    shutdownThrowable = s.asException();
-    listener.transportShutdown(s);
+    return true;
   }
 
   public void notifyInUse(boolean inUse) {
@@ -76,12 +83,12 @@ public void notifyInUse(boolean inUse) {
     listener.transportInUse(inUse);
   }
 
-  public void notifyTerminated(Status s) {
+  public void notifyTerminated(Status s, DisconnectError disconnectError) {
     if (transportTerminated) {
       return;
     }
     transportTerminated = true;
-    notifyShutdown(s);
+    notifyShutdown(s, disconnectError);
     listener.transportTerminated();
   }
 
@@ -89,7 +96,4 @@ public Status getShutdownStatus() {
     return shutdownStatus;
   }
 
-  public Throwable getShutdownThrowable() {
-    return shutdownThrowable;
-  }
 }
diff --git a/netty/src/main/java/io/grpc/netty/CreateStreamCommand.java b/netty/src/main/java/io/grpc/netty/CreateStreamCommand.java
index d79144e6387..f5cfcf35c29 100644
--- a/netty/src/main/java/io/grpc/netty/CreateStreamCommand.java
+++ b/netty/src/main/java/io/grpc/netty/CreateStreamCommand.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -41,11 +26,17 @@
 class CreateStreamCommand extends WriteQueue.AbstractQueuedCommand {
   private final Http2Headers headers;
   private final NettyClientStream.TransportState stream;
+  private final boolean shouldBeCountedForInUse;
+  private final boolean get;
 
-  CreateStreamCommand(Http2Headers headers,
-                      NettyClientStream.TransportState stream) {
+  CreateStreamCommand(
+      Http2Headers headers,
+      NettyClientStream.TransportState stream,
+      boolean shouldBeCountedForInUse, boolean get) {
     this.stream = Preconditions.checkNotNull(stream, "stream");
     this.headers = Preconditions.checkNotNull(headers, "headers");
+    this.shouldBeCountedForInUse = shouldBeCountedForInUse;
+    this.get = get;
   }
 
   NettyClientStream.TransportState stream() {
@@ -55,4 +46,12 @@ NettyClientStream.TransportState stream() {
   Http2Headers headers() {
     return headers;
   }
+
+  boolean shouldBeCountedForInUse() {
+    return shouldBeCountedForInUse;
+  }
+
+  boolean isGet() {
+    return get;
+  }
 }
diff --git a/netty/src/main/java/io/grpc/netty/FixedKeyManagerFactory.java b/netty/src/main/java/io/grpc/netty/FixedKeyManagerFactory.java
new file mode 100644
index 00000000000..ee360c84e76
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/FixedKeyManagerFactory.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2021 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.netty;
+
+import java.security.KeyStore;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.KeyManagerFactorySpi;
+import javax.net.ssl.ManagerFactoryParameters;
+
+/** A KeyManagerFactory that returns a fixed list of key managers. */
+final class FixedKeyManagerFactory extends KeyManagerFactory {
+  public FixedKeyManagerFactory(List<KeyManager> keyManagers) {
+    super(new FixedKeyManagerFactorySpi(keyManagers), new UnhelpfulSecurityProvider(),
+        "FakeAlgorithm");
+  }
+
+  private static final class FixedKeyManagerFactorySpi extends KeyManagerFactorySpi {
+    private final List<KeyManager> keyManagers;
+
+    public FixedKeyManagerFactorySpi(List<KeyManager> keyManagers) {
+      this.keyManagers = Collections.unmodifiableList(new ArrayList<>(keyManagers));
+    }
+
+    @Override
+    protected KeyManager[] engineGetKeyManagers() {
+      return keyManagers.toArray(new KeyManager[0]);
+    }
+
+    @Override
+    protected void engineInit(KeyStore ks, char[] password) {}
+
+    @Override
+    protected void engineInit(ManagerFactoryParameters spec) {}
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/FixedTrustManagerFactory.java b/netty/src/main/java/io/grpc/netty/FixedTrustManagerFactory.java
new file mode 100644
index 00000000000..8cab8844ee7
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/FixedTrustManagerFactory.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2021 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.netty;
+
+import java.security.KeyStore;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import javax.net.ssl.ManagerFactoryParameters;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.TrustManagerFactorySpi;
+
+/** A TrustManagerFactory that returns a fixed list of trust managers. */
+final class FixedTrustManagerFactory extends TrustManagerFactory {
+  public FixedTrustManagerFactory(List<TrustManager> trustManagers) {
+    super(new FixedTrustManagerFactorySpi(trustManagers), new UnhelpfulSecurityProvider(),
+        "FakeAlgorithm");
+  }
+
+  private static final class FixedTrustManagerFactorySpi extends TrustManagerFactorySpi {
+    private final List<TrustManager> trustManagers;
+
+    public FixedTrustManagerFactorySpi(List<TrustManager> trustManagers) {
+      this.trustManagers = Collections.unmodifiableList(new ArrayList<>(trustManagers));
+    }
+
+    @Override
+    protected TrustManager[] engineGetTrustManagers() {
+      return trustManagers.toArray(new TrustManager[0]);
+    }
+
+    @Override
+    protected void engineInit(KeyStore ks) {}
+
+    @Override
+    protected void engineInit(ManagerFactoryParameters spec) {}
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/ForcefulCloseCommand.java b/netty/src/main/java/io/grpc/netty/ForcefulCloseCommand.java
index 21012c33756..94bc0888f7f 100644
--- a/netty/src/main/java/io/grpc/netty/ForcefulCloseCommand.java
+++ b/netty/src/main/java/io/grpc/netty/ForcefulCloseCommand.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
diff --git a/netty/src/main/java/io/grpc/netty/GracefulCloseCommand.java b/netty/src/main/java/io/grpc/netty/GracefulCloseCommand.java
index a8d815a86eb..7c87aa7281e 100644
--- a/netty/src/main/java/io/grpc/netty/GracefulCloseCommand.java
+++ b/netty/src/main/java/io/grpc/netty/GracefulCloseCommand.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
diff --git a/netty/src/main/java/io/grpc/netty/GracefulServerCloseCommand.java b/netty/src/main/java/io/grpc/netty/GracefulServerCloseCommand.java
new file mode 100644
index 00000000000..97904687548
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/GracefulServerCloseCommand.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2021 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.netty;
+
+import com.google.common.base.Preconditions;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A command to trigger close and allow streams naturally close.
+ */
+class GracefulServerCloseCommand extends WriteQueue.AbstractQueuedCommand {
+  private final String goAwayDebugString;
+  private final long graceTime;
+  private final TimeUnit graceTimeUnit;
+
+  public GracefulServerCloseCommand(String goAwayDebugString) {
+    this(goAwayDebugString, -1, null);
+  }
+
+  public GracefulServerCloseCommand(
+      String goAwayDebugString, long graceTime, TimeUnit graceTimeUnit) {
+    this.goAwayDebugString = Preconditions.checkNotNull(goAwayDebugString, "goAwayDebugString");
+    this.graceTime = graceTime;
+    this.graceTimeUnit = graceTimeUnit;
+  }
+
+  public String getGoAwayDebugString() {
+    return goAwayDebugString;
+  }
+
+  /** Has no meaning if {@code getGraceTimeUnit() == null}. */
+  public long getGraceTime() {
+    return graceTime;
+  }
+
+  public TimeUnit getGraceTimeUnit() {
+    return graceTimeUnit;
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/GrpcHttp2ConnectionHandler.java b/netty/src/main/java/io/grpc/netty/GrpcHttp2ConnectionHandler.java
index 23eb83d61ae..ee5227484fb 100644
--- a/netty/src/main/java/io/grpc/netty/GrpcHttp2ConnectionHandler.java
+++ b/netty/src/main/java/io/grpc/netty/GrpcHttp2ConnectionHandler.java
@@ -1,52 +1,66 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import static com.google.common.base.Preconditions.checkState;
+
 import io.grpc.Attributes;
+import io.grpc.ChannelLogger;
 import io.grpc.Internal;
+import io.grpc.InternalChannelz;
+import io.netty.channel.ChannelPromise;
 import io.netty.handler.codec.http2.Http2ConnectionDecoder;
 import io.netty.handler.codec.http2.Http2ConnectionEncoder;
 import io.netty.handler.codec.http2.Http2ConnectionHandler;
 import io.netty.handler.codec.http2.Http2Settings;
+import javax.annotation.Nullable;
 
 /**
  * gRPC wrapper for {@link Http2ConnectionHandler}.
  */
 @Internal
 public abstract class GrpcHttp2ConnectionHandler extends Http2ConnectionHandler {
-  public GrpcHttp2ConnectionHandler(Http2ConnectionDecoder decoder,
+  @Nullable
+  protected final ChannelPromise channelUnused;
+  private final ChannelLogger negotiationLogger;
+
+  @SuppressWarnings("this-escape")
+  protected GrpcHttp2ConnectionHandler(
+      ChannelPromise channelUnused,
+      Http2ConnectionDecoder decoder,
       Http2ConnectionEncoder encoder,
-      Http2Settings initialSettings) {
+      Http2Settings initialSettings,
+      ChannelLogger negotiationLogger) {
     super(decoder, encoder, initialSettings);
+    this.channelUnused = channelUnused;
+    this.negotiationLogger = negotiationLogger;
+  }
+
+  /**
+   * Same as {@link #handleProtocolNegotiationCompleted(
+   *   Attributes, io.grpc.InternalChannelz.Security)}
+   * but with no {@link io.grpc.InternalChannelz.Security}.
+   *
+   * @deprecated Use the two argument method instead.
+   */
+  @Deprecated
+  @SuppressWarnings("InlineMeSuggester") // the caller should consider providing securityInfo
+  public void handleProtocolNegotiationCompleted(Attributes attrs) {
+    handleProtocolNegotiationCompleted(attrs, /*securityInfo=*/ null);
   }
 
   /**
@@ -56,7 +70,42 @@ public GrpcHttp2ConnectionHandler(Http2ConnectionDecoder decoder,
    * channel.
    *
    * @param attrs arbitrary attributes passed after protocol negotiation (eg. SSLSession).
+   * @param securityInfo informs channelz about the security protocol.
    */
-  public void handleProtocolNegotiationCompleted(Attributes attrs) {
+  public void handleProtocolNegotiationCompleted(
+      Attributes attrs, InternalChannelz.Security securityInfo) {
+  }
+
+  /**
+   * Returns the channel logger for the given channel context.
+   */
+  public ChannelLogger getNegotiationLogger() {
+    checkState(negotiationLogger != null, "NegotiationLogger must not be null");
+    return negotiationLogger;
+  }
+
+  /**
+   * Calling this method indicates that the channel will no longer be used.  This method is roughly
+   * the same as calling {@link #close} on the channel, but leaving the channel alive.  This is
+   * useful if the channel will soon be deregistered from the executor and used in a non-Netty
+   * context.
+   */
+  @SuppressWarnings("FutureReturnValueIgnored")
+  public void notifyUnused() {
+    channelUnused.setSuccess(null);
+  }
+
+  /** Get the attributes of the EquivalentAddressGroup used to create this transport. */
+  public Attributes getEagAttributes() {
+    return Attributes.EMPTY;
+  }
+
+  /**
+   * Returns the authority of the server. Only available on the client-side.
+   *
+   * @throws UnsupportedOperationException if on server-side
+   */
+  public String getAuthority() {
+    throw new UnsupportedOperationException();
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/GrpcHttp2HeadersDecoder.java b/netty/src/main/java/io/grpc/netty/GrpcHttp2HeadersDecoder.java
deleted file mode 100644
index e3183d1e747..00000000000
--- a/netty/src/main/java/io/grpc/netty/GrpcHttp2HeadersDecoder.java
+++ /dev/null
@@ -1,527 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * Copyright 2014 The Netty Project
- *
- * The Netty Project licenses this file to you 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.netty;
-
-import static com.google.common.base.Charsets.US_ASCII;
-import static com.google.common.base.Preconditions.checkArgument;
-import static io.grpc.netty.Utils.TE_HEADER;
-import static io.netty.handler.codec.http2.Http2Error.PROTOCOL_ERROR;
-import static io.netty.handler.codec.http2.Http2Exception.connectionError;
-import static io.netty.util.AsciiString.isUpperCase;
-
-import com.google.common.io.BaseEncoding;
-import io.grpc.Metadata;
-import io.netty.buffer.ByteBuf;
-import io.netty.handler.codec.http2.DefaultHttp2HeadersDecoder;
-import io.netty.handler.codec.http2.Http2Exception;
-import io.netty.handler.codec.http2.Http2Headers;
-import io.netty.handler.codec.http2.Http2HeadersDecoder;
-import io.netty.handler.codec.http2.internal.hpack.Decoder;
-import io.netty.util.AsciiString;
-import io.netty.util.internal.PlatformDependent;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * A {@link Http2HeadersDecoder} that allows to use custom {@link Http2Headers} implementations.
- *
- * <p>Some of the code is copied from Netty's {@link DefaultHttp2HeadersDecoder}.
- */
-abstract class GrpcHttp2HeadersDecoder implements Http2HeadersDecoder,
-    Http2HeadersDecoder.Configuration {
-
-  private static final float HEADERS_COUNT_WEIGHT_NEW = 1 / 5f;
-  private static final float HEADERS_COUNT_WEIGHT_HISTORICAL = 1 - HEADERS_COUNT_WEIGHT_NEW;
-
-  private final Decoder decoder;
-  private float numHeadersGuess = 8;
-
-  GrpcHttp2HeadersDecoder(long maxHeaderListSize) {
-    decoder = new Decoder(maxHeaderListSize, 32 /* same as default */);
-  }
-
-  @Override
-  public Http2Headers decodeHeaders(int streamId, ByteBuf headerBlock) throws Http2Exception {
-    GrpcHttp2InboundHeaders headers = newHeaders(1 + (int) numHeadersGuess);
-    decoder.decode(streamId, headerBlock, headers);
-
-    numHeadersGuess = HEADERS_COUNT_WEIGHT_NEW * headers.numHeaders()
-        + HEADERS_COUNT_WEIGHT_HISTORICAL * numHeadersGuess;
-
-    return headers;
-  }
-
-  abstract GrpcHttp2InboundHeaders newHeaders(int numHeadersGuess);
-
-  @Override
-  public Configuration configuration() {
-    return this;
-  }
-
-  @Override
-  public long maxHeaderListSize() {
-    return decoder.getMaxHeaderListSize();
-  }
-
-  @Override
-  public void maxHeaderListSize(long maxHeaderListSize, long maxHeaderListSizeGoAway)
-      throws Http2Exception {
-    decoder.setMaxHeaderListSize(maxHeaderListSize, maxHeaderListSizeGoAway);
-  }
-
-  @Override
-  public long maxHeaderListSizeGoAway() {
-    return decoder.getMaxHeaderListSizeGoAway();
-  }
-
-  @Override
-  public long maxHeaderTableSize() {
-    return decoder.getMaxHeaderTableSize();
-  }
-
-  @Override
-  public void maxHeaderTableSize(long max) throws Http2Exception {
-    decoder.setMaxHeaderTableSize(max);
-  }
-
-  static final class GrpcHttp2ServerHeadersDecoder extends GrpcHttp2HeadersDecoder {
-
-    GrpcHttp2ServerHeadersDecoder(long maxHeaderListSize) {
-      super(maxHeaderListSize);
-    }
-
-    @Override
-    GrpcHttp2InboundHeaders newHeaders(int numHeadersGuess) {
-      return new GrpcHttp2RequestHeaders(numHeadersGuess);
-    }
-  }
-
-  static final class GrpcHttp2ClientHeadersDecoder extends GrpcHttp2HeadersDecoder {
-
-    GrpcHttp2ClientHeadersDecoder(long maxHeaderListSize) {
-      super(maxHeaderListSize);
-    }
-
-    @Override
-    GrpcHttp2InboundHeaders newHeaders(int numHeadersGuess) {
-      return new GrpcHttp2ResponseHeaders(numHeadersGuess);
-    }
-  }
-
-  /**
-   * A {@link Http2Headers} implementation optimized for inbound/received headers.
-   *
-   * <p>Header names and values are stored in simple arrays, which makes insert run in O(1)
-   * and retrievial a O(n). Header name equality is not determined by the equals implementation of
-   * {@link CharSequence} type, but by comparing two names byte to byte.
-   *
-   * <p>All {@link CharSequence} input parameters and return values are required to be of type
-   * {@link AsciiString}.
-   */
-  abstract static class GrpcHttp2InboundHeaders extends AbstractHttp2Headers {
-
-    private static final AsciiString binaryHeaderSuffix =
-        new AsciiString(Metadata.BINARY_HEADER_SUFFIX.getBytes(US_ASCII));
-
-    private byte[][] namesAndValues;
-    private AsciiString[] values;
-    private int namesAndValuesIdx;
-
-    GrpcHttp2InboundHeaders(int numHeadersGuess) {
-      checkArgument(numHeadersGuess > 0, "numHeadersGuess needs to be gt zero.");
-      namesAndValues = new byte[numHeadersGuess * 2][];
-      values = new AsciiString[numHeadersGuess];
-    }
-
-    protected Http2Headers add(AsciiString name, AsciiString value) {
-      if (namesAndValuesIdx == namesAndValues.length) {
-        expandHeadersAndValues();
-      }
-      byte[] nameBytes = bytes(name);
-      byte[] valueBytes = toBinaryValue(name, value);
-      values[namesAndValuesIdx / 2] = value;
-      namesAndValues[namesAndValuesIdx] = nameBytes;
-      namesAndValuesIdx++;
-      namesAndValues[namesAndValuesIdx] = valueBytes;
-      namesAndValuesIdx++;
-      return this;
-    }
-
-    protected CharSequence get(AsciiString name) {
-      for (int i = 0; i < namesAndValuesIdx; i += 2) {
-        if (equals(name, namesAndValues[i])) {
-          return values[i / 2];
-        }
-      }
-      return null;
-    }
-
-    @Override
-    public List<CharSequence> getAll(CharSequence csName) {
-      AsciiString name = requireAsciiString(csName);
-      List<CharSequence> returnValues = new ArrayList<CharSequence>(4);
-      for (int i = 0; i < namesAndValuesIdx; i += 2) {
-        if (equals(name, namesAndValues[i])) {
-          returnValues.add(values[i / 2]);
-        }
-      }
-      return returnValues;
-    }
-
-    /**
-     * Returns the header names and values as bytes. An even numbered index contains the
-     * {@code byte[]} representation of a header name (in insertion order), and the subsequent
-     * odd index number contains the corresponding header value.
-     *
-     * <p>The values of binary headers (with a -bin suffix), are already base64 decoded.
-     *
-     * <p>The array may contain several {@code null} values at the end. A {@code null} value an
-     * index means that all higher numbered indices also contain {@code null} values.
-     */
-    byte[][] namesAndValues() {
-      return namesAndValues;
-    }
-
-    /**
-     * Returns the number of none-null headers in {@link #namesAndValues()}.
-     */
-    protected int numHeaders() {
-      return namesAndValuesIdx / 2;
-    }
-
-    protected static boolean equals(AsciiString str0, byte[] str1) {
-      return equals(str0.array(), str0.arrayOffset(), str0.length(), str1, 0, str1.length);
-    }
-
-    protected static boolean equals(AsciiString str0, AsciiString str1) {
-      return equals(str0.array(), str0.arrayOffset(), str0.length(), str1.array(),
-          str1.arrayOffset(), str1.length());
-    }
-
-    protected static boolean equals(byte[] bytes0, int offset0, int length0, byte[] bytes1,
-        int offset1, int length1) {
-      if (length0 != length1) {
-        return false;
-      }
-      return PlatformDependent.equals(bytes0, offset0, bytes1, offset1, length0);
-    }
-
-    private static byte[] toBinaryValue(AsciiString name, AsciiString value) {
-      return name.endsWith(binaryHeaderSuffix)
-          ? BaseEncoding.base64().decode(value)
-          : bytes(value);
-    }
-
-    protected static byte[] bytes(AsciiString str) {
-      return str.isEntireArrayUsed() ? str.array() : str.toByteArray();
-    }
-
-    protected static AsciiString requireAsciiString(CharSequence cs) {
-      if (!(cs instanceof AsciiString)) {
-        throw new IllegalArgumentException("AsciiString expected. Was: " + cs.getClass().getName());
-      }
-      return (AsciiString) cs;
-    }
-
-    protected static boolean isPseudoHeader(AsciiString str) {
-      return !str.isEmpty() && str.charAt(0) == ':';
-    }
-
-    protected AsciiString validateName(AsciiString str) {
-      int offset = str.arrayOffset();
-      int length = str.length();
-      final byte[] data = str.array();
-      for (int i = offset; i < offset + length; i++) {
-        if (isUpperCase(data[i])) {
-          PlatformDependent.throwException(connectionError(PROTOCOL_ERROR,
-              "invalid header name '%s'", str));
-        }
-      }
-      return str;
-    }
-
-    private void expandHeadersAndValues() {
-      int newValuesLen = Math.max(2, values.length + values.length / 2);
-      int newNamesAndValuesLen = newValuesLen * 2;
-
-      byte[][] newNamesAndValues = new byte[newNamesAndValuesLen][];
-      AsciiString[] newValues = new AsciiString[newValuesLen];
-      System.arraycopy(namesAndValues, 0, newNamesAndValues, 0, namesAndValues.length);
-      System.arraycopy(values, 0, newValues, 0, values.length);
-      namesAndValues = newNamesAndValues;
-      values = newValues;
-    }
-
-    @Override
-    public int size() {
-      return numHeaders();
-    }
-
-    protected static void appendNameAndValue(StringBuilder builder, CharSequence name,
-        CharSequence value, boolean prependSeparator) {
-      if (prependSeparator) {
-        builder.append(", ");
-      }
-      builder.append(name).append(": ").append(value);
-    }
-
-    protected final String namesAndValuesToString() {
-      StringBuilder builder = new StringBuilder();
-      boolean prependSeparator = false;
-      for (int i = 0; i < namesAndValuesIdx; i += 2) {
-        String name = new String(namesAndValues[i], US_ASCII);
-        // If binary headers, the value is base64 encoded.
-        AsciiString value = values[i / 2];
-        appendNameAndValue(builder, name, value, prependSeparator);
-        prependSeparator = true;
-      }
-      return builder.toString();
-    }
-  }
-
-  /**
-   * A {@link GrpcHttp2InboundHeaders} implementation, optimized for HTTP/2 request headers. That
-   * is, HTTP/2 request pseudo headers are stored in dedicated fields and are NOT part of the
-   * array returned by {@link #namesAndValues()}.
-   *
-   * <p>This class only implements the methods used by {@link NettyServerHandler} and tests. All
-   * other methods throw an {@link UnsupportedOperationException}.
-   */
-  static final class GrpcHttp2RequestHeaders extends GrpcHttp2InboundHeaders {
-
-    private static final AsciiString PATH_HEADER = AsciiString.of(":path");
-    private static final AsciiString AUTHORITY_HEADER = AsciiString.of(":authority");
-    private static final AsciiString METHOD_HEADER = AsciiString.of(":method");
-    private static final AsciiString SCHEME_HEADER = AsciiString.of(":scheme");
-
-    private AsciiString path;
-    private AsciiString authority;
-    private AsciiString method;
-    private AsciiString scheme;
-    private AsciiString te;
-
-    GrpcHttp2RequestHeaders(int numHeadersGuess) {
-      super(numHeadersGuess);
-    }
-
-    @Override
-    public Http2Headers add(CharSequence csName, CharSequence csValue) {
-      AsciiString name = validateName(requireAsciiString(csName));
-      AsciiString value = requireAsciiString(csValue);
-      if (isPseudoHeader(name)) {
-        addPseudoHeader(name, value);
-        return this;
-      }
-      if (equals(TE_HEADER, name)) {
-        te = value;
-        return this;
-      }
-      return add(name, value);
-    }
-
-    @Override
-    public CharSequence get(CharSequence csName) {
-      AsciiString name = requireAsciiString(csName);
-      checkArgument(!isPseudoHeader(name), "Use direct accessor methods for pseudo headers.");
-      if (equals(TE_HEADER, name)) {
-        return te;
-      }
-      return get(name);
-    }
-
-    private void addPseudoHeader(CharSequence csName, CharSequence csValue) {
-      AsciiString name = requireAsciiString(csName);
-      AsciiString value = requireAsciiString(csValue);
-
-      if (equals(PATH_HEADER, name)) {
-        path = value;
-      } else if (equals(AUTHORITY_HEADER, name)) {
-        authority = value;
-      } else if (equals(METHOD_HEADER, name)) {
-        method = value;
-      } else if (equals(SCHEME_HEADER, name)) {
-        scheme = value;
-      } else {
-        PlatformDependent.throwException(
-            connectionError(PROTOCOL_ERROR, "Illegal pseudo-header '%s' in request.", name));
-      }
-    }
-
-    @Override
-    public CharSequence path() {
-      return path;
-    }
-
-    @Override
-    public CharSequence authority() {
-      return authority;
-    }
-
-    @Override
-    public CharSequence method() {
-      return method;
-    }
-
-    @Override
-    public CharSequence scheme() {
-      return scheme;
-    }
-
-    /**
-     * This method is called in tests only.
-     */
-    @Override
-    public List<CharSequence> getAll(CharSequence csName) {
-      AsciiString name = requireAsciiString(csName);
-      if (isPseudoHeader(name)) {
-        // This code should never be reached.
-        throw new IllegalArgumentException("Use direct accessor methods for pseudo headers.");
-      }
-      if (equals(TE_HEADER, name)) {
-        return Collections.singletonList((CharSequence) te);
-      }
-      return super.getAll(csName);
-    }
-
-    /**
-     * This method is called in tests only.
-     */
-    @Override
-    public int size() {
-      int size = 0;
-      if (path != null) {
-        size++;
-      }
-      if (authority != null) {
-        size++;
-      }
-      if (method != null) {
-        size++;
-      }
-      if (scheme != null) {
-        size++;
-      }
-      if (te != null) {
-        size++;
-      }
-      size += super.size();
-      return size;
-    }
-
-    @Override
-    public String toString() {
-      StringBuilder builder = new StringBuilder(getClass().getSimpleName()).append('[');
-      boolean prependSeparator = false;
-
-      if (path != null) {
-        appendNameAndValue(builder, PATH_HEADER, path, prependSeparator);
-        prependSeparator = true;
-      }
-      if (authority != null) {
-        appendNameAndValue(builder, AUTHORITY_HEADER, authority, prependSeparator);
-        prependSeparator = true;
-      }
-      if (method != null) {
-        appendNameAndValue(builder, METHOD_HEADER, method, prependSeparator);
-        prependSeparator = true;
-      }
-      if (scheme != null) {
-        appendNameAndValue(builder, SCHEME_HEADER, scheme, prependSeparator);
-        prependSeparator = true;
-      }
-      if (te != null) {
-        appendNameAndValue(builder, TE_HEADER, te, prependSeparator);
-      }
-
-      String namesAndValues = namesAndValuesToString();
-
-      if (builder.length() > 0 && namesAndValues.length() > 0) {
-        builder.append(", ");
-      }
-
-      builder.append(namesAndValues);
-      builder.append(']');
-
-      return builder.toString();
-    }
-  }
-
-  /**
-   * This class only implements the methods used by {@link NettyClientHandler} and tests. All
-   * other methods throw an {@link UnsupportedOperationException}.
-   *
-   * <p>Unlike in {@link GrpcHttp2ResponseHeaders} the {@code :status} pseudo-header is not treated
-   * special and is part of {@link #namesAndValues}.
-   */
-  static final class GrpcHttp2ResponseHeaders extends GrpcHttp2InboundHeaders {
-
-    GrpcHttp2ResponseHeaders(int numHeadersGuess) {
-      super(numHeadersGuess);
-    }
-
-    @Override
-    public Http2Headers add(CharSequence csName, CharSequence csValue) {
-      AsciiString name = validateName(requireAsciiString(csName));
-      AsciiString value = requireAsciiString(csValue);
-      return add(name, value);
-    }
-
-    @Override
-    public CharSequence get(CharSequence csName) {
-      AsciiString name = requireAsciiString(csName);
-      return get(name);
-    }
-
-    @Override
-    public String toString() {
-      StringBuilder builder = new StringBuilder(getClass().getSimpleName()).append('[');
-      builder.append(namesAndValuesToString()).append(']');
-      return builder.toString();
-    }
-  }
-}
diff --git a/netty/src/main/java/io/grpc/netty/GrpcHttp2HeadersUtils.java b/netty/src/main/java/io/grpc/netty/GrpcHttp2HeadersUtils.java
new file mode 100644
index 00000000000..96c4310ae3d
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/GrpcHttp2HeadersUtils.java
@@ -0,0 +1,568 @@
+/*
+ * Copyright 2016 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.
+ */
+
+/*
+ * Copyright 2014 The Netty Project
+ *
+ * The Netty Project licenses this file to you 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.netty;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static io.grpc.netty.Utils.TE_HEADER;
+import static io.netty.handler.codec.http2.Http2Error.PROTOCOL_ERROR;
+import static io.netty.handler.codec.http2.Http2Exception.connectionError;
+import static io.netty.util.AsciiString.isUpperCase;
+import static java.nio.charset.StandardCharsets.US_ASCII;
+
+import com.google.common.io.BaseEncoding;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import io.grpc.Metadata;
+import io.netty.handler.codec.CharSequenceValueConverter;
+import io.netty.handler.codec.http2.DefaultHttp2HeadersDecoder;
+import io.netty.handler.codec.http2.Http2Headers;
+import io.netty.util.AsciiString;
+import io.netty.util.internal.PlatformDependent;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A headers utils providing custom gRPC implementations of {@link DefaultHttp2HeadersDecoder}.
+ */
+class GrpcHttp2HeadersUtils {
+  static final class GrpcHttp2ServerHeadersDecoder extends DefaultHttp2HeadersDecoder {
+
+    GrpcHttp2ServerHeadersDecoder(long maxHeaderListSize) {
+      super(true, maxHeaderListSize);
+    }
+
+    @Override
+    protected GrpcHttp2InboundHeaders newHeaders() {
+      return new GrpcHttp2RequestHeaders(numberOfHeadersGuess());
+    }
+  }
+
+  static final class GrpcHttp2ClientHeadersDecoder extends DefaultHttp2HeadersDecoder {
+
+    GrpcHttp2ClientHeadersDecoder(long maxHeaderListSize) {
+      super(true, maxHeaderListSize);
+    }
+
+    @Override
+    protected GrpcHttp2InboundHeaders newHeaders() {
+      return new GrpcHttp2ResponseHeaders(numberOfHeadersGuess());
+    }
+  }
+
+  /**
+   * A {@link Http2Headers} implementation optimized for inbound/received headers.
+   *
+   * <p>Header names and values are stored in simple arrays, which makes insert run in O(1)
+   * and retrievial a O(n). Header name equality is not determined by the equals implementation of
+   * {@link CharSequence} type, but by comparing two names byte to byte.
+   *
+   * <p>All {@link CharSequence} input parameters and return values are required to be of type
+   * {@link AsciiString}.
+   */
+  abstract static class GrpcHttp2InboundHeaders extends AbstractHttp2Headers {
+
+    private static final AsciiString binaryHeaderSuffix =
+        new AsciiString(Metadata.BINARY_HEADER_SUFFIX.getBytes(US_ASCII));
+
+    private byte[][] namesAndValues;
+    private AsciiString[] values;
+    private int namesAndValuesIdx;
+
+    GrpcHttp2InboundHeaders(int numHeadersGuess) {
+      checkArgument(numHeadersGuess > 0, "numHeadersGuess needs to be positive: %s",
+          numHeadersGuess);
+      namesAndValues = new byte[numHeadersGuess * 2][];
+      values = new AsciiString[numHeadersGuess];
+    }
+
+    protected Http2Headers add(AsciiString name, AsciiString value) {
+      byte[] nameBytes = bytes(name);
+      byte[] valueBytes;
+      if (!name.endsWith(binaryHeaderSuffix)) {
+        valueBytes = bytes(value);
+        addHeader(value, nameBytes, valueBytes);
+        return this;
+      }
+      int startPos = 0;
+      int endPos = -1;
+      while (endPos < value.length()) {
+        int indexOfComma = value.indexOf(',', startPos);
+        endPos = indexOfComma == AsciiString.INDEX_NOT_FOUND ? value.length() : indexOfComma;
+        AsciiString curVal = value.subSequence(startPos, endPos, false);
+        valueBytes = BaseEncoding.base64().decode(curVal);
+        startPos = indexOfComma + 1;
+        addHeader(curVal, nameBytes, valueBytes);
+      }
+      return this;
+    }
+
+    private void addHeader(AsciiString value, byte[] nameBytes, byte[] valueBytes) {
+      if (namesAndValuesIdx == namesAndValues.length) {
+        expandHeadersAndValues();
+      }
+      values[namesAndValuesIdx / 2] = value;
+      namesAndValues[namesAndValuesIdx] = nameBytes;
+      namesAndValuesIdx++;
+      namesAndValues[namesAndValuesIdx] = valueBytes;
+      namesAndValuesIdx++;
+    }
+
+    protected CharSequence get(AsciiString name) {
+      for (int i = 0; i < namesAndValuesIdx; i += 2) {
+        if (equals(name, namesAndValues[i])) {
+          return values[i / 2];
+        }
+      }
+      return null;
+    }
+
+    @Override
+    public boolean contains(CharSequence name) {
+      return get(name) != null;
+    }
+
+    @Override
+    public CharSequence status() {
+      return get(Http2Headers.PseudoHeaderName.STATUS.value());
+    }
+
+    @Override
+    public List<CharSequence> getAll(CharSequence csName) {
+      AsciiString name = requireAsciiString(csName);
+      List<CharSequence> returnValues = new ArrayList<>(4);
+      for (int i = 0; i < namesAndValuesIdx; i += 2) {
+        if (equals(name, namesAndValues[i])) {
+          returnValues.add(values[i / 2]);
+        }
+      }
+      return returnValues;
+    }
+
+    @CanIgnoreReturnValue
+    @Override
+    public boolean remove(CharSequence csName) {
+      AsciiString name = requireAsciiString(csName);
+      int i = 0;
+      for (; i < namesAndValuesIdx; i += 2) {
+        if (equals(name, namesAndValues[i])) {
+          break;
+        }
+      }
+      if (i >= namesAndValuesIdx) {
+        return false;
+      }
+      int dest = i;
+      for (; i < namesAndValuesIdx; i += 2) {
+        if (equals(name, namesAndValues[i])) {
+          continue;
+        }
+        values[dest / 2] = values[i / 2];
+        namesAndValues[dest] = namesAndValues[i];
+        namesAndValues[dest + 1] = namesAndValues[i + 1];
+        dest += 2;
+      }
+      namesAndValuesIdx = dest;
+      return true;
+    }
+
+    @Override
+    public Http2Headers set(CharSequence name, CharSequence value) {
+      remove(name);
+      return add(name, value);
+    }
+
+    @Override
+    public Http2Headers setLong(CharSequence name, long value) {
+      return set(name, AsciiString.of(CharSequenceValueConverter.INSTANCE.convertLong(value)));
+    }
+
+    /**
+     * Returns the header names and values as bytes. An even numbered index contains the
+     * {@code byte[]} representation of a header name (in insertion order), and the subsequent
+     * odd index number contains the corresponding header value.
+     *
+     * <p>The values of binary headers (with a -bin suffix), are already base64 decoded.
+     *
+     * <p>The array may contain several {@code null} values at the end. A {@code null} value an
+     * index means that all higher numbered indices also contain {@code null} values.
+     */
+    byte[][] namesAndValues() {
+      return namesAndValues;
+    }
+
+    /**
+     * Returns the number of none-null headers in {@link #namesAndValues()}.
+     */
+    protected int numHeaders() {
+      return namesAndValuesIdx / 2;
+    }
+
+    protected static boolean equals(AsciiString str0, byte[] str1) {
+      return equals(str0.array(), str0.arrayOffset(), str0.length(), str1, 0, str1.length);
+    }
+
+    protected static boolean equals(AsciiString str0, AsciiString str1) {
+      return equals(str0.array(), str0.arrayOffset(), str0.length(), str1.array(),
+          str1.arrayOffset(), str1.length());
+    }
+
+    protected static boolean equals(byte[] bytes0, int offset0, int length0, byte[] bytes1,
+        int offset1, int length1) {
+      if (length0 != length1) {
+        return false;
+      }
+      return PlatformDependent.equals(bytes0, offset0, bytes1, offset1, length0);
+    }
+
+    protected static byte[] bytes(AsciiString str) {
+      return str.isEntireArrayUsed() ? str.array() : str.toByteArray();
+    }
+
+    protected static AsciiString requireAsciiString(CharSequence cs) {
+      if (!(cs instanceof AsciiString)) {
+        throw new IllegalArgumentException("AsciiString expected. Was: " + cs.getClass().getName());
+      }
+      return (AsciiString) cs;
+    }
+
+    protected static boolean isPseudoHeader(AsciiString str) {
+      return !str.isEmpty() && str.charAt(0) == ':';
+    }
+
+    protected AsciiString validateName(AsciiString str) {
+      int offset = str.arrayOffset();
+      int length = str.length();
+      final byte[] data = str.array();
+      for (int i = offset; i < offset + length; i++) {
+        if (isUpperCase(data[i])) {
+          PlatformDependent.throwException(connectionError(PROTOCOL_ERROR,
+              "invalid header name '%s'", str));
+        }
+      }
+      return str;
+    }
+
+    private void expandHeadersAndValues() {
+      int newValuesLen = Math.max(2, values.length + values.length / 2);
+      int newNamesAndValuesLen = newValuesLen * 2;
+
+      byte[][] newNamesAndValues = new byte[newNamesAndValuesLen][];
+      AsciiString[] newValues = new AsciiString[newValuesLen];
+      System.arraycopy(namesAndValues, 0, newNamesAndValues, 0, namesAndValues.length);
+      System.arraycopy(values, 0, newValues, 0, values.length);
+      namesAndValues = newNamesAndValues;
+      values = newValues;
+    }
+
+    @Override
+    public int size() {
+      return numHeaders();
+    }
+
+    @Override
+    public Iterator<Map.Entry<CharSequence, CharSequence>> iterator() {
+      return namesAndValuesToImmutableList().iterator();
+    }
+
+    protected static void appendNameAndValue(StringBuilder builder, CharSequence name,
+        CharSequence value, boolean prependSeparator) {
+      if (prependSeparator) {
+        builder.append(", ");
+      }
+      builder.append(name).append(": ").append(value);
+    }
+
+    private List<Map.Entry<CharSequence, CharSequence>> namesAndValuesToImmutableList() {
+      ArrayList<Map.Entry<CharSequence, CharSequence>> list = new ArrayList<>(values.length);
+      for (int i = 0; i < namesAndValuesIdx; i += 2) {
+        String name = new String(namesAndValues[i], US_ASCII);
+        // If binary headers, the value is base64 encoded.
+        AsciiString value = values[i / 2];
+        list.add(new AbstractMap.SimpleImmutableEntry<CharSequence, CharSequence>(name, value));
+      }
+      return Collections.unmodifiableList(list);
+    }
+
+    protected final String namesAndValuesToString() {
+      StringBuilder builder = new StringBuilder();
+      boolean prependSeparator = false;
+      for (Map.Entry<CharSequence, CharSequence> entry : namesAndValuesToImmutableList()) {
+        appendNameAndValue(builder, entry.getKey(), entry.getValue(), prependSeparator);
+        prependSeparator = true;
+      }
+      return builder.toString();
+    }
+  }
+
+  /**
+   * A {@link GrpcHttp2InboundHeaders} implementation, optimized for HTTP/2 request headers. That
+   * is, HTTP/2 request pseudo headers are stored in dedicated fields and are NOT part of the
+   * array returned by {@link #namesAndValues()}.
+   *
+   * <p>This class only implements the methods used by {@link NettyServerHandler} and tests. All
+   * other methods throw an {@link UnsupportedOperationException}.
+   */
+  static final class GrpcHttp2RequestHeaders extends GrpcHttp2InboundHeaders {
+
+    private static final AsciiString PATH_HEADER = AsciiString.of(":path");
+    private static final AsciiString AUTHORITY_HEADER = AsciiString.of(":authority");
+    private static final AsciiString METHOD_HEADER = AsciiString.of(":method");
+    private static final AsciiString SCHEME_HEADER = AsciiString.of(":scheme");
+
+    private AsciiString path;
+    private AsciiString authority;
+    private AsciiString method;
+    private AsciiString scheme;
+    private AsciiString te;
+
+    GrpcHttp2RequestHeaders(int numHeadersGuess) {
+      super(numHeadersGuess);
+    }
+
+    @Override
+    public Http2Headers add(CharSequence csName, CharSequence csValue) {
+      AsciiString name = validateName(requireAsciiString(csName));
+      AsciiString value = requireAsciiString(csValue);
+      if (isPseudoHeader(name)) {
+        AsciiString previous = getPseudoHeader(name);
+        if (previous != null) {
+          PlatformDependent.throwException(
+              connectionError(PROTOCOL_ERROR, "Duplicate %s header", name));
+        }
+        setPseudoHeader(name, value);
+        return this;
+      }
+      if (equals(TE_HEADER, name)) {
+        te = value;
+        return this;
+      }
+      return add(name, value);
+    }
+
+    @Override
+    public CharSequence get(CharSequence csName) {
+      AsciiString name = requireAsciiString(csName);
+      if (isPseudoHeader(name)) {
+        return getPseudoHeader(name);
+      }
+      if (equals(TE_HEADER, name)) {
+        return te;
+      }
+      return get(name);
+    }
+
+    private AsciiString getPseudoHeader(AsciiString name) {
+      if (equals(PATH_HEADER, name)) {
+        return path;
+      } else if (equals(AUTHORITY_HEADER, name)) {
+        return authority;
+      } else if (equals(METHOD_HEADER, name)) {
+        return method;
+      } else if (equals(SCHEME_HEADER, name)) {
+        return scheme;
+      } else {
+        return null;
+      }
+    }
+
+    private void setPseudoHeader(AsciiString name, AsciiString value) {
+      if (equals(PATH_HEADER, name)) {
+        path = value;
+      } else if (equals(AUTHORITY_HEADER, name)) {
+        authority = value;
+      } else if (equals(METHOD_HEADER, name)) {
+        method = value;
+      } else if (equals(SCHEME_HEADER, name)) {
+        scheme = value;
+      } else {
+        PlatformDependent.throwException(
+            connectionError(PROTOCOL_ERROR, "Illegal pseudo-header '%s' in request.", name));
+        throw new AssertionError(); // Make flow control obvious to javac
+      }
+    }
+
+    @Override
+    public CharSequence path() {
+      return path;
+    }
+
+    @Override
+    public CharSequence authority() {
+      return authority;
+    }
+
+    @Override
+    public CharSequence method() {
+      return method;
+    }
+
+    @Override
+    public CharSequence scheme() {
+      return scheme;
+    }
+
+    @Override
+    public List<CharSequence> getAll(CharSequence csName) {
+      AsciiString name = requireAsciiString(csName);
+      if (isPseudoHeader(name)) {
+        AsciiString value = getPseudoHeader(name);
+        if (value == null) {
+          return Collections.emptyList();
+        } else {
+          return Collections.singletonList(value);
+        }
+      }
+      if (equals(TE_HEADER, name)) {
+        return Collections.singletonList((CharSequence) te);
+      }
+      return super.getAll(csName);
+    }
+
+    @Override
+    public boolean remove(CharSequence csName) {
+      AsciiString name = requireAsciiString(csName);
+      if (isPseudoHeader(name)) {
+        if (getPseudoHeader(name) == null) {
+          return false;
+        } else {
+          setPseudoHeader(name, null);
+          return true;
+        }
+      }
+      if (equals(TE_HEADER, name)) {
+        boolean wasPresent = te != null;
+        te = null;
+        return wasPresent;
+      }
+      return super.remove(name);
+    }
+
+    /**
+     * This method is called in tests only.
+     */
+    @Override
+    public int size() {
+      int size = 0;
+      if (path != null) {
+        size++;
+      }
+      if (authority != null) {
+        size++;
+      }
+      if (method != null) {
+        size++;
+      }
+      if (scheme != null) {
+        size++;
+      }
+      if (te != null) {
+        size++;
+      }
+      size += super.size();
+      return size;
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder builder = new StringBuilder(getClass().getSimpleName()).append('[');
+      boolean prependSeparator = false;
+
+      if (path != null) {
+        appendNameAndValue(builder, PATH_HEADER, path, prependSeparator);
+        prependSeparator = true;
+      }
+      if (authority != null) {
+        appendNameAndValue(builder, AUTHORITY_HEADER, authority, prependSeparator);
+        prependSeparator = true;
+      }
+      if (method != null) {
+        appendNameAndValue(builder, METHOD_HEADER, method, prependSeparator);
+        prependSeparator = true;
+      }
+      if (scheme != null) {
+        appendNameAndValue(builder, SCHEME_HEADER, scheme, prependSeparator);
+        prependSeparator = true;
+      }
+      if (te != null) {
+        appendNameAndValue(builder, TE_HEADER, te, prependSeparator);
+      }
+
+      String namesAndValues = namesAndValuesToString();
+
+      if (builder.length() > 0 && namesAndValues.length() > 0) {
+        builder.append(", ");
+      }
+
+      builder.append(namesAndValues);
+      builder.append(']');
+
+      return builder.toString();
+    }
+  }
+
+  /**
+   * This class only implements the methods used by {@link NettyClientHandler} and tests. All
+   * other methods throw an {@link UnsupportedOperationException}.
+   *
+   * <p>Unlike in {@link GrpcHttp2ResponseHeaders} the {@code :status} pseudo-header is not treated
+   * special and is part of {@link #namesAndValues}.
+   */
+  static final class GrpcHttp2ResponseHeaders extends GrpcHttp2InboundHeaders {
+
+    GrpcHttp2ResponseHeaders(int numHeadersGuess) {
+      super(numHeadersGuess);
+    }
+
+    @Override
+    public Http2Headers add(CharSequence csName, CharSequence csValue) {
+      AsciiString name = validateName(requireAsciiString(csName));
+      AsciiString value = requireAsciiString(csValue);
+      return add(name, value);
+    }
+
+    @Override
+    public CharSequence get(CharSequence csName) {
+      AsciiString name = requireAsciiString(csName);
+      return get(name);
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder builder = new StringBuilder(getClass().getSimpleName()).append('[');
+      builder.append(namesAndValuesToString()).append(']');
+      return builder.toString();
+    }
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/GrpcHttp2OutboundHeaders.java b/netty/src/main/java/io/grpc/netty/GrpcHttp2OutboundHeaders.java
index 5314e93771c..aabcd4fbaaa 100644
--- a/netty/src/main/java/io/grpc/netty/GrpcHttp2OutboundHeaders.java
+++ b/netty/src/main/java/io/grpc/netty/GrpcHttp2OutboundHeaders.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -34,7 +19,7 @@
 import io.netty.handler.codec.http2.Http2Headers;
 import io.netty.util.AsciiString;
 import java.util.Iterator;
-import java.util.Map.Entry;
+import java.util.Map;
 import java.util.NoSuchElementException;
 
 /**
@@ -82,7 +67,27 @@ private GrpcHttp2OutboundHeaders(AsciiString[] preHeaders, byte[][] serializedMe
   }
 
   @Override
-  public Iterator<Entry<CharSequence, CharSequence>> iterator() {
+  public CharSequence authority() {
+    for (int i = 0; i < preHeaders.length / 2; i++) {
+      if (preHeaders[i * 2].equals(Http2Headers.PseudoHeaderName.AUTHORITY.value())) {
+        return preHeaders[i * 2 + 1];
+      }
+    }
+    return null;
+  }
+
+  @Override
+  @SuppressWarnings("ReferenceEquality") // STATUS.value() never changes.
+  public CharSequence status() {
+    // preHeaders is never null.  It has status as the first element or not at all.
+    if (preHeaders.length >= 2 && preHeaders[0] == Http2Headers.PseudoHeaderName.STATUS.value()) {
+      return preHeaders[1];
+    }
+    return null;
+  }
+
+  @Override
+  public Iterator<Map.Entry<CharSequence, CharSequence>> iterator() {
     return new Itr();
   }
 
@@ -91,8 +96,8 @@ public int size() {
     return (normalHeaders.length + preHeaders.length) / 2;
   }
 
-  private class Itr implements Entry<CharSequence, CharSequence>,
-      Iterator<Entry<CharSequence, CharSequence>> {
+  private class Itr implements Map.Entry<CharSequence, CharSequence>,
+      Iterator<Map.Entry<CharSequence, CharSequence>> {
     private int idx;
     private AsciiString[] current = preHeaders.length != 0 ? preHeaders : normalHeaders;
     private AsciiString key;
@@ -109,7 +114,7 @@ public boolean hasNext() {
      * speeds before and after.
      */
     @Override
-    public Entry<CharSequence, CharSequence> next() {
+    public Map.Entry<CharSequence, CharSequence> next() {
       if (hasNext()) {
         key = current[idx];
         value = current[idx + 1];
@@ -149,7 +154,7 @@ public void remove() {
   public String toString() {
     StringBuilder builder = new StringBuilder(getClass().getSimpleName()).append('[');
     String separator = "";
-    for (Entry<CharSequence, CharSequence> e : this) {
+    for (Map.Entry<CharSequence, CharSequence> e : this) {
       CharSequence name = e.getKey();
       CharSequence value = e.getValue();
       builder.append(separator);
diff --git a/netty/src/main/java/io/grpc/netty/GrpcSslContexts.java b/netty/src/main/java/io/grpc/netty/GrpcSslContexts.java
index d87615fb3b6..f1f2c8aed71 100644
--- a/netty/src/main/java/io/grpc/netty/GrpcSslContexts.java
+++ b/netty/src/main/java/io/grpc/netty/GrpcSslContexts.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -35,47 +20,44 @@
 
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import io.grpc.ExperimentalApi;
+import io.grpc.internal.ConscryptLoader;
 import io.netty.handler.codec.http2.Http2SecurityUtil;
 import io.netty.handler.ssl.ApplicationProtocolConfig;
 import io.netty.handler.ssl.ApplicationProtocolConfig.Protocol;
 import io.netty.handler.ssl.ApplicationProtocolConfig.SelectedListenerFailureBehavior;
 import io.netty.handler.ssl.ApplicationProtocolConfig.SelectorFailureBehavior;
-import io.netty.handler.ssl.ApplicationProtocolNegotiator;
 import io.netty.handler.ssl.OpenSsl;
 import io.netty.handler.ssl.SslContextBuilder;
 import io.netty.handler.ssl.SslProvider;
 import io.netty.handler.ssl.SupportedCipherSuiteFilter;
 import java.io.File;
+import java.io.InputStream;
+import java.security.Provider;
+import java.security.Security;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 /**
  * Utility for configuring SslContext for gRPC.
  */
+@SuppressWarnings("deprecation")
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1784")
 public class GrpcSslContexts {
-  private GrpcSslContexts() {}
+  private static final Logger logger = Logger.getLogger(GrpcSslContexts.class.getName());
 
-  /*
-   * The experimental "grpc-exp" string identifies gRPC (and by implication
-   * HTTP/2) when used over TLS. This indicates to the server that the client
-   * will only send gRPC traffic on the h2 connection and is negotiated in
-   * preference to h2 when the client and server support it, but is not
-   * standardized. Support for this may be removed at any time.
-   */
-  private static final String GRPC_EXP_VERSION = "grpc-exp";
+  private GrpcSslContexts() {}
 
   // The "h2" string identifies HTTP/2 when used over TLS
   private static final String HTTP2_VERSION = "h2";
 
   /*
-   * List of ALPN/NPN protocols in order of preference. GRPC_EXP_VERSION
-   * requires that HTTP2_VERSION be present and that GRPC_EXP_VERSION should be
-   * preferenced over HTTP2_VERSION.
+   * List of ALPN/NPN protocols in order of preference.
    */
-  static final List<String> NEXT_PROTOCOL_VERSIONS =
-      Collections.unmodifiableList(Arrays.asList(GRPC_EXP_VERSION, HTTP2_VERSION));
+  private static final List<String> NEXT_PROTOCOL_VERSIONS =
+      Collections.unmodifiableList(Arrays.asList(HTTP2_VERSION));
 
   /*
    * These configs use ACCEPT due to limited support in OpenSSL.  Actual protocol enforcement is
@@ -99,8 +81,13 @@ private GrpcSslContexts() {}
       SelectedListenerFailureBehavior.ACCEPT,
       NEXT_PROTOCOL_VERSIONS);
 
+  private static final String SUN_PROVIDER_NAME = "SunJSSE";
+  private static final String IBM_PROVIDER_NAME = "IBMJSSE2";
+  private static final String OPENJSSE_PROVIDER_NAME = "OpenJSSE";
+  private static final String BCJSSE_PROVIDER_NAME = "BCJSSE";
+
   /**
-   * Creates a SslContextBuilder with ciphers and APN appropriate for gRPC.
+   * Creates an SslContextBuilder with ciphers and APN appropriate for gRPC.
    *
    * @see SslContextBuilder#forClient()
    * @see #configure(SslContextBuilder)
@@ -110,7 +97,7 @@ public static SslContextBuilder forClient() {
   }
 
   /**
-   * Creates a SslContextBuilder with ciphers and APN appropriate for gRPC.
+   * Creates an SslContextBuilder with ciphers and APN appropriate for gRPC.
    *
    * @see SslContextBuilder#forServer(File, File)
    * @see #configure(SslContextBuilder)
@@ -120,7 +107,7 @@ public static SslContextBuilder forServer(File keyCertChainFile, File keyFile) {
   }
 
   /**
-   * Creates a SslContextBuilder with ciphers and APN appropriate for gRPC.
+   * Creates an SslContextBuilder with ciphers and APN appropriate for gRPC.
    *
    * @see SslContextBuilder#forServer(File, File, String)
    * @see #configure(SslContextBuilder)
@@ -130,6 +117,27 @@ public static SslContextBuilder forServer(
     return configure(SslContextBuilder.forServer(keyCertChainFile, keyFile, keyPassword));
   }
 
+  /**
+   * Creates an SslContextBuilder with ciphers and APN appropriate for gRPC.
+   *
+   * @see SslContextBuilder#forServer(InputStream, InputStream)
+   * @see #configure(SslContextBuilder)
+   */
+  public static SslContextBuilder forServer(InputStream keyCertChain, InputStream key) {
+    return configure(SslContextBuilder.forServer(keyCertChain, key));
+  }
+
+  /**
+   * Creates an SslContextBuilder with ciphers and APN appropriate for gRPC.
+   *
+   * @see SslContextBuilder#forServer(InputStream, InputStream, String)
+   * @see #configure(SslContextBuilder)
+   */
+  public static SslContextBuilder forServer(
+      InputStream keyCertChain, InputStream key, String keyPassword) {
+    return configure(SslContextBuilder.forServer(keyCertChain, key, keyPassword));
+  }
+
   /**
    * Set ciphers and APN appropriate for gRPC. Precisely what is set is permitted to change, so if
    * an application requires particular settings it should override the options set here.
@@ -146,50 +154,127 @@ public static SslContextBuilder configure(SslContextBuilder builder) {
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1784")
   @CanIgnoreReturnValue
   public static SslContextBuilder configure(SslContextBuilder builder, SslProvider provider) {
-    return builder.sslProvider(provider)
-                  .ciphers(Http2SecurityUtil.CIPHERS, SupportedCipherSuiteFilter.INSTANCE)
-                  .applicationProtocolConfig(selectApplicationProtocolConfig(provider));
-  }
-
-  /**
-   * Returns OpenSSL if available, otherwise returns the JDK provider.
-   */
-  private static SslProvider defaultSslProvider() {
-    return OpenSsl.isAvailable() ? SslProvider.OPENSSL : SslProvider.JDK;
-  }
-
-  /**
-   * Attempts to select the best {@link ApplicationProtocolConfig} for the given
-   * {@link SslProvider}.
-   */
-  private static ApplicationProtocolConfig selectApplicationProtocolConfig(SslProvider provider) {
     switch (provider) {
       case JDK: {
-        if (JettyTlsUtil.isJettyAlpnConfigured()) {
-          return ALPN;
-        }
-        if (JettyTlsUtil.isJettyNpnConfigured()) {
-          return NPN;
+        Provider jdkProvider = findJdkProvider();
+        if (jdkProvider == null) {
+          throw new IllegalArgumentException(
+              "Could not find Jetty NPN/ALPN or Conscrypt as installed JDK providers");
         }
-        throw new IllegalArgumentException("Jetty ALPN/NPN has not been properly configured.");
+        return configure(builder, jdkProvider);
       }
       case OPENSSL: {
-        if (!OpenSsl.isAvailable()) {
-          throw new IllegalArgumentException("OpenSSL is not installed on the system.");
-        }
-
+        ApplicationProtocolConfig apc;
         if (OpenSsl.isAlpnSupported()) {
-          return NPN_AND_ALPN;
+          apc = NPN_AND_ALPN;
         } else {
-          return NPN;
+          apc = NPN;
         }
+        return builder
+            .sslProvider(SslProvider.OPENSSL)
+            .ciphers(Http2SecurityUtil.CIPHERS, SupportedCipherSuiteFilter.INSTANCE)
+            .applicationProtocolConfig(apc);
       }
       default:
         throw new IllegalArgumentException("Unsupported provider: " + provider);
     }
   }
 
-  static void ensureAlpnAndH2Enabled(ApplicationProtocolNegotiator alpnNegotiator) {
+  /**
+   * Set ciphers and APN appropriate for gRPC. Precisely what is set is permitted to change, so if
+   * an application requires particular settings it should override the options set here.
+   */
+  @CanIgnoreReturnValue
+  public static SslContextBuilder configure(SslContextBuilder builder, Provider jdkProvider) {
+    ApplicationProtocolConfig apc;
+    if (SUN_PROVIDER_NAME.equals(jdkProvider.getName())) {
+      // Jetty ALPN/NPN only supports one of NPN or ALPN
+      if (JettyTlsUtil.isJettyAlpnConfigured()) {
+        apc = ALPN;
+      } else if (JettyTlsUtil.isJettyNpnConfigured()) {
+        apc = NPN;
+      } else if (JettyTlsUtil.isJava9AlpnAvailable()) {
+        apc = ALPN;
+      } else {
+        throw new IllegalArgumentException(
+            jdkProvider.getName() + " selected, but Java 9+ and Jetty NPN/ALPN unavailable");
+      }
+    } else if (IBM_PROVIDER_NAME.equals(jdkProvider.getName())
+        || OPENJSSE_PROVIDER_NAME.equals(jdkProvider.getName())
+        || BCJSSE_PROVIDER_NAME.equals(jdkProvider.getName())) {
+      if (JettyTlsUtil.isJava9AlpnAvailable()) {
+        apc = ALPN;
+      } else {
+        throw new IllegalArgumentException(
+            jdkProvider.getName() + " selected, but Java 9+ ALPN unavailable");
+      }
+    } else if (ConscryptLoader.isConscrypt(jdkProvider)) {
+      apc = ALPN;
+      // TODO: Conscrypt triggers failures in the TrustManager.
+      // https://github.com/grpc/grpc-java/issues/7765
+      builder.protocols("TLSv1.2");
+    } else {
+      throw new IllegalArgumentException("Unknown provider; can't configure: " + jdkProvider);
+    }
+    return builder
+        .sslProvider(SslProvider.JDK)
+        .ciphers(Http2SecurityUtil.CIPHERS, SupportedCipherSuiteFilter.INSTANCE)
+        .applicationProtocolConfig(apc)
+        .sslContextProvider(jdkProvider);
+  }
+
+  /**
+   * Returns OpenSSL if available, otherwise returns the JDK provider.
+   */
+  private static SslProvider defaultSslProvider() {
+    if (OpenSsl.isAvailable()) {
+      logger.log(Level.FINE, "Selecting OPENSSL");
+      return SslProvider.OPENSSL;
+    }
+    Provider provider = findJdkProvider();
+    if (provider != null) {
+      logger.log(Level.FINE, "Selecting JDK with provider {0}", provider);
+      return SslProvider.JDK;
+    }
+    logger.log(Level.INFO, "Java 9 ALPN API unavailable (this may be normal)");
+    logger.log(Level.INFO, "netty-tcnative unavailable (this may be normal)",
+        OpenSsl.unavailabilityCause());
+    logger.log(Level.INFO, "Conscrypt not found (this may be normal)",
+        ConscryptHolder.UNAVAILABILITY_CAUSE);
+    logger.log(Level.INFO, "Jetty ALPN unavailable (this may be normal)",
+        JettyTlsUtil.getJettyAlpnUnavailabilityCause());
+    throw new IllegalStateException(
+        "Could not find TLS ALPN provider; "
+        + "no working netty-tcnative, Conscrypt, or Jetty NPN/ALPN available");
+  }
+
+  private static Provider findJdkProvider() {
+    for (Provider provider : Security.getProviders("SSLContext.TLS")) {
+      if (SUN_PROVIDER_NAME.equals(provider.getName())) {
+        if (JettyTlsUtil.isJettyAlpnConfigured()
+            || JettyTlsUtil.isJettyNpnConfigured()
+            || JettyTlsUtil.isJava9AlpnAvailable()) {
+          return provider;
+        }
+      } else if (IBM_PROVIDER_NAME.equals(provider.getName())
+          || OPENJSSE_PROVIDER_NAME.equals(provider.getName())
+          || BCJSSE_PROVIDER_NAME.equals(provider.getName())) {
+        if (JettyTlsUtil.isJava9AlpnAvailable()) {
+          return provider;
+        }
+      } else if (ConscryptLoader.isConscrypt(provider)) {
+        return provider;
+      }
+    }
+    if (ConscryptHolder.PROVIDER != null) {
+      return ConscryptHolder.PROVIDER;
+    }
+    return null;
+  }
+
+  @SuppressWarnings("deprecation")
+  static void ensureAlpnAndH2Enabled(
+      io.netty.handler.ssl.ApplicationProtocolNegotiator alpnNegotiator) {
     checkArgument(alpnNegotiator != null, "ALPN must be configured");
     checkArgument(alpnNegotiator.protocols() != null && !alpnNegotiator.protocols().isEmpty(),
         "ALPN must be enabled and list HTTP/2 as a supported protocol.");
@@ -199,4 +284,23 @@ static void ensureAlpnAndH2Enabled(ApplicationProtocolNegotiator alpnNegotiator)
         HTTP2_VERSION,
         alpnNegotiator.protocols());
   }
+
+  private static class ConscryptHolder {
+    static final Provider PROVIDER;
+    static final Throwable UNAVAILABILITY_CAUSE;
+
+    static {
+      Provider provider;
+      Throwable cause;
+      try {
+        provider = ConscryptLoader.newProvider();
+        cause = null;
+      } catch (Throwable t) {
+        provider = null;
+        cause = t;
+      }
+      PROVIDER = provider;
+      UNAVAILABILITY_CAUSE = cause;
+    }
+  }
 }
diff --git a/netty/src/main/java/io/grpc/netty/HandlerSettings.java b/netty/src/main/java/io/grpc/netty/HandlerSettings.java
deleted file mode 100644
index b37722b771b..00000000000
--- a/netty/src/main/java/io/grpc/netty/HandlerSettings.java
+++ /dev/null
@@ -1,89 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.netty;
-
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
-
-/**
- * Allows autoFlowControl to be turned on and off from interop testing and flow control windows to
- * be accessed.
- */
-@VisibleForTesting
-public final class HandlerSettings {
-
-  private static volatile boolean enabled;
-
-  private static boolean autoFlowControlOn;
-  // These will be the most recently created handlers created using NettyClientTransport and
-  // NettyServerTransport
-  private static AbstractNettyHandler clientHandler;
-  private static AbstractNettyHandler serverHandler;
-
-  static void setAutoWindow(AbstractNettyHandler handler) {
-    if (!enabled) {
-      return;
-    }
-    synchronized (HandlerSettings.class) {
-      handler.setAutoTuneFlowControl(autoFlowControlOn);
-      if (handler instanceof NettyClientHandler) {
-        clientHandler = handler;
-      } else if (handler instanceof NettyServerHandler) {
-        serverHandler = handler;
-      } else {
-        throw new RuntimeException("Expecting NettyClientHandler or NettyServerHandler");
-      }
-    }
-  }
-
-  public static void enable(boolean enable) {
-    enabled = enable;
-  }
-
-  public static synchronized void autoWindowOn(boolean autoFlowControl) {
-    autoFlowControlOn = autoFlowControl;
-  }
-
-  public static synchronized int getLatestClientWindow() {
-    return getLatestWindow(clientHandler);
-  }
-
-  public static synchronized int getLatestServerWindow() {
-    return getLatestWindow(serverHandler);
-  }
-
-  private static synchronized int getLatestWindow(AbstractNettyHandler handler) {
-    Preconditions.checkNotNull(handler);
-    return handler.decoder().flowController()
-        .initialWindowSize(handler.connection().connectionStream());
-  }
-}
diff --git a/netty/src/main/java/io/grpc/netty/Http2ControlFrameLimitEncoder.java b/netty/src/main/java/io/grpc/netty/Http2ControlFrameLimitEncoder.java
new file mode 100644
index 00000000000..f8d0e659b81
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/Http2ControlFrameLimitEncoder.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2019 The Netty Project
+ *
+ * The Netty Project licenses this file to you 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.netty;
+
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import io.netty.handler.codec.http2.DecoratingHttp2ConnectionEncoder;
+import io.netty.handler.codec.http2.Http2ConnectionEncoder;
+import io.netty.handler.codec.http2.Http2Error;
+import io.netty.handler.codec.http2.Http2Exception;
+import io.netty.handler.codec.http2.Http2LifecycleManager;
+import io.netty.util.internal.ObjectUtil;
+import io.netty.util.internal.logging.InternalLogger;
+import io.netty.util.internal.logging.InternalLoggerFactory;
+
+/**
+ * {@link DecoratingHttp2ConnectionEncoder} which guards against a remote peer that will trigger a massive amount
+ * of control frames but will not consume our responses to these.
+ * This encoder will tear-down the connection once we reached the configured limit to reduce the risk of DDOS.
+ */
+final class Http2ControlFrameLimitEncoder extends DecoratingHttp2ConnectionEncoder {
+    private static final InternalLogger logger = InternalLoggerFactory.getInstance(Http2ControlFrameLimitEncoder.class);
+
+    private final int maxOutstandingControlFrames;
+    private final ChannelFutureListener outstandingControlFramesListener = new ChannelFutureListener() {
+        @Override
+        public void operationComplete(ChannelFuture future) {
+            outstandingControlFrames--;
+        }
+    };
+    private Http2LifecycleManager lifecycleManager;
+    private int outstandingControlFrames;
+    private boolean limitReached;
+
+    Http2ControlFrameLimitEncoder(Http2ConnectionEncoder delegate, int maxOutstandingControlFrames) {
+        super(delegate);
+        this.maxOutstandingControlFrames = ObjectUtil.checkPositive(maxOutstandingControlFrames,
+                "maxOutstandingControlFrames");
+    }
+
+    @Override
+    public void lifecycleManager(Http2LifecycleManager lifecycleManager) {
+        this.lifecycleManager = lifecycleManager;
+        super.lifecycleManager(lifecycleManager);
+    }
+
+    @Override
+    public ChannelFuture writeSettingsAck(ChannelHandlerContext ctx, ChannelPromise promise) {
+        ChannelPromise newPromise = handleOutstandingControlFrames(ctx, promise);
+        if (newPromise == null) {
+            return promise;
+        }
+        return super.writeSettingsAck(ctx, newPromise);
+    }
+
+    @Override
+    public ChannelFuture writePing(ChannelHandlerContext ctx, boolean ack, long data, ChannelPromise promise) {
+        // Only apply the limit to ping acks.
+        if (ack) {
+            ChannelPromise newPromise = handleOutstandingControlFrames(ctx, promise);
+            if (newPromise == null) {
+                return promise;
+            }
+            return super.writePing(ctx, ack, data, newPromise);
+        }
+        return super.writePing(ctx, ack, data, promise);
+    }
+
+    @Override
+    public ChannelFuture writeRstStream(
+            ChannelHandlerContext ctx, int streamId, long errorCode, ChannelPromise promise) {
+        ChannelPromise newPromise = handleOutstandingControlFrames(ctx, promise);
+        if (newPromise == null) {
+            return promise;
+        }
+        return super.writeRstStream(ctx, streamId, errorCode, newPromise);
+    }
+
+    private ChannelPromise handleOutstandingControlFrames(ChannelHandlerContext ctx, ChannelPromise promise) {
+        if (!limitReached) {
+            if (outstandingControlFrames == maxOutstandingControlFrames) {
+                // Let's try to flush once as we may be able to flush some of the control frames.
+                ctx.flush();
+            }
+            if (outstandingControlFrames == maxOutstandingControlFrames) {
+                limitReached = true;
+                Http2Exception exception = Http2Exception.connectionError(Http2Error.ENHANCE_YOUR_CALM,
+                        "Maximum number %d of outstanding control frames reached", maxOutstandingControlFrames);
+                logger.info("Maximum number {} of outstanding control frames reached. Closing channel {}",
+                        maxOutstandingControlFrames, ctx.channel(), exception);
+
+                // First notify the Http2LifecycleManager and then close the connection.
+                lifecycleManager.onError(ctx, true, exception);
+                ctx.close();
+            }
+            outstandingControlFrames++;
+
+            // We did not reach the limit yet, add the listener to decrement the number of outstanding control frames
+            // once the promise was completed
+            return promise.unvoid().addListener(outstandingControlFramesListener);
+        }
+        return promise;
+    }
+}
diff --git a/netty/src/main/java/io/grpc/netty/InsecureFromHttp1ChannelCredentials.java b/netty/src/main/java/io/grpc/netty/InsecureFromHttp1ChannelCredentials.java
new file mode 100644
index 00000000000..658f0f11831
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/InsecureFromHttp1ChannelCredentials.java
@@ -0,0 +1,31 @@
+/*
+ * 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.netty;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.ExperimentalApi;
+
+/** An insecure credential that upgrades from HTTP/1 to HTTP/2. */
+@ExperimentalApi("There is no plan to make this API stable, given transport API instability")
+public final class InsecureFromHttp1ChannelCredentials {
+  private InsecureFromHttp1ChannelCredentials() {}
+
+  /** Creates an insecure credential that will upgrade from HTTP/1 to HTTP/2. */
+  public static ChannelCredentials create() {
+    return NettyChannelCredentials.create(ProtocolNegotiators.plaintextUpgradeClientFactory());
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/InternalGracefulServerCloseCommand.java b/netty/src/main/java/io/grpc/netty/InternalGracefulServerCloseCommand.java
new file mode 100644
index 00000000000..deb72373ac7
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/InternalGracefulServerCloseCommand.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2021 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.netty;
+
+import io.grpc.Internal;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Internal accessor for {@link GracefulServerCloseCommand}.
+ */
+@Internal
+public final class InternalGracefulServerCloseCommand {
+  private InternalGracefulServerCloseCommand() {}
+
+  public static Object create(String goAwayDebugString) {
+    return new GracefulServerCloseCommand(goAwayDebugString);
+  }
+
+  public static Object create(String goAwayDebugString, long graceTime, TimeUnit graceTimeUnit) {
+    return new GracefulServerCloseCommand(goAwayDebugString, graceTime, graceTimeUnit);
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/InternalNettyChannelBuilder.java b/netty/src/main/java/io/grpc/netty/InternalNettyChannelBuilder.java
index 52ce0f5410c..1848b475d59 100644
--- a/netty/src/main/java/io/grpc/netty/InternalNettyChannelBuilder.java
+++ b/netty/src/main/java/io/grpc/netty/InternalNettyChannelBuilder.java
@@ -1,38 +1,29 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import com.google.common.annotations.VisibleForTesting;
 import io.grpc.Internal;
-import java.net.SocketAddress;
+import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.internal.TransportTracer;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import java.net.InetSocketAddress;
 
 /**
  * Internal {@link NettyChannelBuilder} accessor.  This is intended for usage internal to the gRPC
@@ -41,38 +32,88 @@
 @Internal
 public final class InternalNettyChannelBuilder {
 
+  public static void disableCheckAuthority(NettyChannelBuilder builder) {
+    builder.disableCheckAuthority();
+  }
+
+  public static void enableCheckAuthority(NettyChannelBuilder builder) {
+    builder.enableCheckAuthority();
+  }
+
+  /** A class that provides a Netty handler to control protocol negotiation. */
+  public interface ProtocolNegotiatorFactory {
+    InternalProtocolNegotiator.ProtocolNegotiator buildProtocolNegotiator();
+  }
+
   /**
-   * Checks authority upon channel construction.  The purpose of this interface is to raise the
-   * visibility of {@link NettyChannelBuilder.OverrideAuthorityChecker}.
+   * Sets the {@link ProtocolNegotiatorFactory} to be used. Overrides any specified negotiation type
+   * and {@code SslContext}.
    */
-  public interface OverrideAuthorityChecker extends NettyChannelBuilder.OverrideAuthorityChecker {}
+  public static void setProtocolNegotiatorFactory(
+      NettyChannelBuilder builder, final ProtocolNegotiatorFactory protocolNegotiator) {
+    builder.protocolNegotiatorFactory(new ProtocolNegotiator.ClientFactory() {
+      @Override public ProtocolNegotiator newNegotiator() {
+        return protocolNegotiator.buildProtocolNegotiator();
+      }
 
-  public static void overrideAuthorityChecker(
-      NettyChannelBuilder channelBuilder, OverrideAuthorityChecker authorityChecker) {
-    channelBuilder.overrideAuthorityChecker(authorityChecker);
+      @Override public int getDefaultPort() {
+        return GrpcUtil.DEFAULT_PORT_SSL;
+      }
+    });
   }
 
   /**
-   * Interface to create netty dynamic parameters.
+   * Sets the {@link ProtocolNegotiatorFactory} to be used. Overrides any specified negotiation type
+   * and {@code SslContext}.
    */
-  public interface TransportCreationParamsFilterFactory
-      extends NettyChannelBuilder.TransportCreationParamsFilterFactory {
-    @Override
-    TransportCreationParamsFilter create(
-        SocketAddress targetServerAddress, String authority, String userAgent);
+  public static void setProtocolNegotiatorFactory(
+      NettyChannelBuilder builder, InternalProtocolNegotiator.ClientFactory protocolNegotiator) {
+    builder.protocolNegotiatorFactory(protocolNegotiator);
+  }
+
+  public static void setStatsEnabled(NettyChannelBuilder builder, boolean value) {
+    builder.setStatsEnabled(value);
+  }
+
+  public static void setTracingEnabled(NettyChannelBuilder builder, boolean value) {
+    builder.setTracingEnabled(value);
+  }
+
+  public static void setStatsRecordStartedRpcs(NettyChannelBuilder builder, boolean value) {
+    builder.setStatsRecordStartedRpcs(value);
+  }
+
+  public static void setStatsRecordFinishedRpcs(NettyChannelBuilder builder, boolean value) {
+    builder.setStatsRecordFinishedRpcs(value);
+  }
+
+  public static void setStatsRecordRealTimeMetrics(NettyChannelBuilder builder, boolean value) {
+    builder.setStatsRecordRealTimeMetrics(value);
+  }
+
+  public static void setStatsRecordRetryMetrics(NettyChannelBuilder builder, boolean value) {
+    builder.setStatsRecordRetryMetrics(value);
   }
 
   /**
-   * {@link TransportCreationParamsFilter} are those that may depend on late-known information about
-   * a client transport.  This interface can be used to dynamically alter params based on the
-   * params of {@code ClientTransportFactory#newClientTransport}.
+   * Sets {@link io.grpc.Channel} and {@link io.netty.channel.EventLoopGroup} to Nio. A major
+   * benefit over using setters is gRPC will manage the life cycle of {@link
+   * io.netty.channel.EventLoopGroup}.
    */
-  public interface TransportCreationParamsFilter
-      extends NettyChannelBuilder.TransportCreationParamsFilter {}
+  public static void useNioTransport(NettyChannelBuilder builder) {
+    builder.channelType(NioSocketChannel.class, InetSocketAddress.class);
+    builder
+        .eventLoopGroupPool(SharedResourcePool.forResource(Utils.NIO_WORKER_EVENT_LOOP_GROUP));
+  }
+
+  public static ClientTransportFactory buildTransportFactory(NettyChannelBuilder builder) {
+    return builder.buildTransportFactory();
+  }
 
-  public static void setDynamicTransportParamsFactory(
-      NettyChannelBuilder builder, TransportCreationParamsFilterFactory factory) {
-    builder.setDynamicParamsFactory(factory);
+  @VisibleForTesting
+  public static void setTransportTracerFactory(
+      NettyChannelBuilder builder, TransportTracer.Factory factory) {
+    builder.setTransportTracerFactory(factory);
   }
 
   private InternalNettyChannelBuilder() {}
diff --git a/netty/src/main/java/io/grpc/netty/InternalNettyChannelCredentials.java b/netty/src/main/java/io/grpc/netty/InternalNettyChannelCredentials.java
new file mode 100644
index 00000000000..ab962e59d59
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/InternalNettyChannelCredentials.java
@@ -0,0 +1,63 @@
+/*
+ * 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.netty;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.Internal;
+
+/**
+ * Internal {@link NettyChannelCredentials} accessor.  This is intended for usage internal to the
+ * gRPC team. If you *really* think you need to use this, contact the gRPC team first.
+ */
+@Internal
+public final class InternalNettyChannelCredentials {
+  private InternalNettyChannelCredentials() {}
+
+  /** Creates a {@link ChannelCredentials} that will use the provided {@code negotiator}. */
+  public static ChannelCredentials create(InternalProtocolNegotiator.ClientFactory negotiator) {
+    return NettyChannelCredentials.create(negotiator);
+  }
+
+  /**
+   * Converts a {@link ChannelCredentials} to a negotiator, in similar fashion as for a new channel.
+   *
+   * @throws IllegalArgumentException if unable to convert
+   */
+  public static InternalProtocolNegotiator.ClientFactory toNegotiator(
+      ChannelCredentials channelCredentials) {
+    final ProtocolNegotiators.FromChannelCredentialsResult result =
+        ProtocolNegotiators.from(channelCredentials);
+    if (result.error != null) {
+      throw new IllegalArgumentException(result.error);
+    }
+    final class ClientFactory implements InternalProtocolNegotiator.ClientFactory {
+
+      @Override
+      public InternalProtocolNegotiator.ProtocolNegotiator newNegotiator() {
+        return new InternalProtocolNegotiator.ProtocolNegotiatorAdapter(
+            result.negotiator.newNegotiator());
+      }
+
+      @Override
+      public int getDefaultPort() {
+        return result.negotiator.getDefaultPort();
+      }
+    }
+
+    return new ClientFactory();
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/InternalNettyServerBuilder.java b/netty/src/main/java/io/grpc/netty/InternalNettyServerBuilder.java
new file mode 100644
index 00000000000..1a0809feebe
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/InternalNettyServerBuilder.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2016 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.netty;
+
+import io.grpc.Attributes;
+import io.grpc.Internal;
+import io.grpc.internal.SharedResourcePool;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+
+/**
+ * Internal {@link NettyServerBuilder} accessor.  This is intended for usage internal to
+ * the gRPC team.  If you *really* think you need to use this, contact the gRPC team first.
+ */
+@Internal
+public final class InternalNettyServerBuilder {
+  public static void setStatsEnabled(NettyServerBuilder builder, boolean value) {
+    builder.setStatsEnabled(value);
+  }
+
+  public static void setStatsRecordStartedRpcs(NettyServerBuilder builder, boolean value) {
+    builder.setStatsRecordStartedRpcs(value);
+  }
+
+  public static void setStatsRecordRealTimeMetrics(NettyServerBuilder builder, boolean value) {
+    builder.setStatsRecordRealTimeMetrics(value);
+  }
+
+  public static void setTracingEnabled(NettyServerBuilder builder, boolean value) {
+    builder.setTracingEnabled(value);
+  }
+
+  public static void setForceHeapBuffer(NettyServerBuilder builder, boolean value) {
+    builder.setForceHeapBuffer(value);
+  }
+
+  /**
+   * Sets {@link io.grpc.Channel} and {@link io.netty.channel.EventLoopGroup}s to Nio. A major
+   * benefit over using existing setters is gRPC will manage the life cycle of {@link
+   * io.netty.channel.EventLoopGroup}s.
+   */
+  public static void useNioTransport(NettyServerBuilder builder) {
+    builder.channelType(NioServerSocketChannel.class);
+    builder
+        .bossEventLoopGroupPool(SharedResourcePool.forResource(Utils.NIO_BOSS_EVENT_LOOP_GROUP));
+    builder
+        .workerEventLoopGroupPool(
+            SharedResourcePool.forResource(Utils.NIO_WORKER_EVENT_LOOP_GROUP));
+  }
+
+  /** Sets the EAG attributes available to protocol negotiators. */
+  public static void eagAttributes(NettyServerBuilder builder, Attributes eagAttributes) {
+    builder.eagAttributes(eagAttributes);
+  }
+
+  private InternalNettyServerBuilder() {}
+}
diff --git a/netty/src/main/java/io/grpc/netty/InternalNettyServerCredentials.java b/netty/src/main/java/io/grpc/netty/InternalNettyServerCredentials.java
new file mode 100644
index 00000000000..3f56344527f
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/InternalNettyServerCredentials.java
@@ -0,0 +1,69 @@
+/*
+ * 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.netty;
+
+import io.grpc.Internal;
+import io.grpc.ServerCredentials;
+import io.grpc.internal.ObjectPool;
+import java.util.concurrent.Executor;
+
+/**
+ * Internal {@link NettyServerCredentials} accessor.  This is intended for usage internal to the
+ * gRPC team. If you *really* think you need to use this, contact the gRPC team first.
+ */
+@Internal
+public final class InternalNettyServerCredentials {
+  private InternalNettyServerCredentials() {}
+
+  /** Creates a {@link ServerCredentials} that will use the provided {@code negotiator}. */
+  public static ServerCredentials create(InternalProtocolNegotiator.ProtocolNegotiator negotiator) {
+    return NettyServerCredentials.create(ProtocolNegotiators.fixedServerFactory(negotiator));
+  }
+
+  /**
+   * Creates a {@link ServerCredentials} that will use the provided {@code negotiator}. Use of
+   * {@link #create(io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator)} is preferred over
+   * this method when possible.
+   */
+  public static ServerCredentials create(InternalProtocolNegotiator.ServerFactory negotiator) {
+    return NettyServerCredentials.create(negotiator);
+  }
+
+  /**
+   * Converts a {@link ServerCredentials} to a negotiator, in similar fashion as for a new server.
+   *
+   * @throws IllegalArgumentException if unable to convert
+   */
+  public static InternalProtocolNegotiator.ServerFactory toNegotiator(
+      ServerCredentials serverCredentials) {
+    final ProtocolNegotiators.FromServerCredentialsResult result =
+        ProtocolNegotiators.from(serverCredentials);
+    if (result.error != null) {
+      throw new IllegalArgumentException(result.error);
+    }
+    final class ServerFactory implements InternalProtocolNegotiator.ServerFactory {
+      @Override
+      public InternalProtocolNegotiator.ProtocolNegotiator newNegotiator(
+          ObjectPool<? extends Executor> offloadExecutorPool) {
+        return new InternalProtocolNegotiator.ProtocolNegotiatorAdapter(
+            result.negotiator.newNegotiator(offloadExecutorPool));
+      }
+    }
+
+    return new ServerFactory();
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/InternalNettySocketSupport.java b/netty/src/main/java/io/grpc/netty/InternalNettySocketSupport.java
new file mode 100644
index 00000000000..2c34cfe167b
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/InternalNettySocketSupport.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2018 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.netty;
+
+import io.grpc.Internal;
+import io.grpc.InternalChannelz.TcpInfo;
+import java.util.Map;
+
+/**
+ * An internal accessor. Do not use.
+ */
+@Internal
+public final class InternalNettySocketSupport {
+
+  public interface InternalHelper extends NettySocketSupport.Helper {
+    @Override
+    InternalNativeSocketOptions getNativeSocketOptions(io.netty.channel.Channel ch);
+  }
+
+  public static final class InternalNativeSocketOptions
+      extends NettySocketSupport.NativeSocketOptions {
+    public InternalNativeSocketOptions(TcpInfo tcpInfo, Map<String, String> otherInfo) {
+      super(tcpInfo, otherInfo);
+    }
+  }
+
+  public static void setHelper(InternalHelper helper) {
+    NettySocketSupport.setHelper(helper);
+  }
+
+  private InternalNettySocketSupport() {}
+}
diff --git a/netty/src/main/java/io/grpc/netty/InternalProtocolNegotiationEvent.java b/netty/src/main/java/io/grpc/netty/InternalProtocolNegotiationEvent.java
new file mode 100644
index 00000000000..3ddeff98b28
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/InternalProtocolNegotiationEvent.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2019 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.netty;
+
+import io.grpc.Attributes;
+import io.grpc.Internal;
+import io.grpc.InternalChannelz.Security;
+import javax.annotation.Nullable;
+
+/**
+ * Internal accessor for {@link ProtocolNegotiationEvent}.
+ */
+@Internal
+public final class InternalProtocolNegotiationEvent {
+  private InternalProtocolNegotiationEvent() {}
+
+  public static ProtocolNegotiationEvent getDefault() {
+    return ProtocolNegotiationEvent.DEFAULT;
+  }
+
+  public static ProtocolNegotiationEvent withAttributes(
+      ProtocolNegotiationEvent event, Attributes attributes) {
+    return event.withAttributes(attributes);
+  }
+
+  public static ProtocolNegotiationEvent withSecurity(
+      ProtocolNegotiationEvent event, @Nullable Security security) {
+    return event.withSecurity(security);
+  }
+
+  public static Attributes getAttributes(ProtocolNegotiationEvent event) {
+    return event.getAttributes();
+  }
+
+  @Nullable
+  public static Security getSecurity(ProtocolNegotiationEvent event) {
+    return event.getSecurity();
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/InternalProtocolNegotiator.java b/netty/src/main/java/io/grpc/netty/InternalProtocolNegotiator.java
new file mode 100644
index 00000000000..1863ec07ced
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/InternalProtocolNegotiator.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2019 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.netty;
+
+import com.google.common.base.Preconditions;
+import io.grpc.Internal;
+import io.grpc.internal.ObjectPool;
+import io.netty.channel.ChannelHandler;
+import io.netty.util.AsciiString;
+import java.util.concurrent.Executor;
+
+/**
+ * Internal accessor for {@link ProtocolNegotiator}.
+ */
+@Internal
+public final class InternalProtocolNegotiator {
+
+  private InternalProtocolNegotiator() {}
+
+  public interface ProtocolNegotiator extends io.grpc.netty.ProtocolNegotiator {}
+
+  static final class ProtocolNegotiatorAdapter
+      implements InternalProtocolNegotiator.ProtocolNegotiator {
+    private final io.grpc.netty.ProtocolNegotiator negotiator;
+
+    public ProtocolNegotiatorAdapter(io.grpc.netty.ProtocolNegotiator negotiator) {
+      this.negotiator = Preconditions.checkNotNull(negotiator, "negotiator");
+    }
+
+    @Override
+    public AsciiString scheme() {
+      return negotiator.scheme();
+    }
+
+    @Override
+    public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+      return negotiator.newHandler(grpcHandler);
+    }
+
+    @Override
+    public void close() {
+      negotiator.close();
+    }
+  }
+
+  public interface ClientFactory extends io.grpc.netty.ProtocolNegotiator.ClientFactory {
+    @Override ProtocolNegotiator newNegotiator();
+  }
+
+  public interface ServerFactory extends io.grpc.netty.ProtocolNegotiator.ServerFactory {
+    @Override ProtocolNegotiator newNegotiator(ObjectPool<? extends Executor> offloadExecutorPool);
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/InternalProtocolNegotiators.java b/netty/src/main/java/io/grpc/netty/InternalProtocolNegotiators.java
new file mode 100644
index 00000000000..35dc1bbc2e8
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/InternalProtocolNegotiators.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright 2019 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.netty;
+
+import com.google.common.base.Optional;
+import io.grpc.ChannelLogger;
+import io.grpc.internal.ObjectPool;
+import io.grpc.netty.ProtocolNegotiators.ClientTlsHandler;
+import io.grpc.netty.ProtocolNegotiators.GrpcNegotiationHandler;
+import io.grpc.netty.ProtocolNegotiators.WaitUntilActiveHandler;
+import io.netty.channel.ChannelHandler;
+import io.netty.handler.ssl.SslContext;
+import io.netty.util.AsciiString;
+import java.util.concurrent.Executor;
+import javax.net.ssl.X509TrustManager;
+
+/**
+ * Internal accessor for {@link ProtocolNegotiators}.
+ */
+public final class InternalProtocolNegotiators {
+
+  private InternalProtocolNegotiators() {}
+
+  /**
+   * Returns a {@link ProtocolNegotiator} that ensures the pipeline is set up so that TLS will
+   * be negotiated, the {@code handler} is added and writes to the {@link io.netty.channel.Channel}
+   * may happen immediately, even before the TLS Handshake is complete.
+   * @param executorPool a dedicated {@link Executor} pool for time-consuming TLS tasks
+   */
+  public static InternalProtocolNegotiator.ProtocolNegotiator tls(SslContext sslContext,
+          ObjectPool<? extends Executor> executorPool,
+          Optional<Runnable> handshakeCompleteRunnable,
+          X509TrustManager extendedX509TrustManager,
+          String sni) {
+    final io.grpc.netty.ProtocolNegotiator negotiator = ProtocolNegotiators.tls(sslContext,
+        executorPool, handshakeCompleteRunnable, extendedX509TrustManager, sni);
+    final class TlsNegotiator implements InternalProtocolNegotiator.ProtocolNegotiator {
+
+      @Override
+      public AsciiString scheme() {
+        return negotiator.scheme();
+      }
+
+      @Override
+      public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+        return negotiator.newHandler(grpcHandler);
+      }
+
+      @Override
+      public void close() {
+        negotiator.close();
+      }
+    }
+
+    return new TlsNegotiator();
+  }
+
+  /**
+   * Returns a {@link ProtocolNegotiator} that ensures the pipeline is set up so that TLS will
+   * be negotiated, the {@code handler} is added and writes to the {@link io.netty.channel.Channel}
+   * may happen immediately, even before the TLS Handshake is complete.
+   */
+  public static InternalProtocolNegotiator.ProtocolNegotiator tls(
+      SslContext sslContext, String sni,
+      X509TrustManager extendedX509TrustManager) {
+    return tls(sslContext, null, Optional.absent(), extendedX509TrustManager, sni);
+  }
+
+  /**
+   * Returns a {@link ProtocolNegotiator} that ensures the pipeline is set up so that TLS will be
+   * negotiated, the server TLS {@code handler} is added and writes to the {@link
+   * io.netty.channel.Channel} may happen immediately, even before the TLS Handshake is complete.
+   */
+  public static InternalProtocolNegotiator.ProtocolNegotiator serverTls(SslContext sslContext) {
+    final io.grpc.netty.ProtocolNegotiator negotiator = ProtocolNegotiators.serverTls(sslContext);
+    final class ServerTlsNegotiator implements InternalProtocolNegotiator.ProtocolNegotiator {
+
+      @Override
+      public AsciiString scheme() {
+        return negotiator.scheme();
+      }
+
+      @Override
+      public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+        return negotiator.newHandler(grpcHandler);
+      }
+
+      @Override
+      public void close() {
+        negotiator.close();
+      }
+    }
+
+    return new ServerTlsNegotiator();
+  }
+
+  /** Returns a {@link ProtocolNegotiator} for plaintext client channel. */
+  public static InternalProtocolNegotiator.ProtocolNegotiator plaintext() {
+    final io.grpc.netty.ProtocolNegotiator negotiator = ProtocolNegotiators.plaintext();
+    final class PlaintextNegotiator implements InternalProtocolNegotiator.ProtocolNegotiator {
+
+      @Override
+      public AsciiString scheme() {
+        return negotiator.scheme();
+      }
+
+      @Override
+      public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+        return negotiator.newHandler(grpcHandler);
+      }
+
+      @Override
+      public void close() {
+        negotiator.close();
+      }
+    }
+
+    return new PlaintextNegotiator();
+  }
+
+  /** Returns a {@link ProtocolNegotiator} for plaintext server channel. */
+  public static InternalProtocolNegotiator.ProtocolNegotiator serverPlaintext() {
+    final io.grpc.netty.ProtocolNegotiator negotiator = ProtocolNegotiators.serverPlaintext();
+    final class ServerPlaintextNegotiator implements InternalProtocolNegotiator.ProtocolNegotiator {
+
+      @Override
+      public AsciiString scheme() {
+        return negotiator.scheme();
+      }
+
+      @Override
+      public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+        return negotiator.newHandler(grpcHandler);
+      }
+
+      @Override
+      public void close() {
+        negotiator.close();
+      }
+    }
+
+    return new ServerPlaintextNegotiator();
+  }
+
+  /**
+   * Internal version of {@link WaitUntilActiveHandler}.
+   */
+  public static ChannelHandler waitUntilActiveHandler(ChannelHandler next,
+      ChannelLogger negotiationLogger) {
+    return new WaitUntilActiveHandler(next, negotiationLogger);
+  }
+
+  /**
+   * Internal version of {@link GrpcNegotiationHandler}.
+   */
+  public static ChannelHandler grpcNegotiationHandler(GrpcHttp2ConnectionHandler next) {
+    return new GrpcNegotiationHandler(next);
+  }
+
+  public static ChannelHandler clientTlsHandler(
+      ChannelHandler next, SslContext sslContext, String authority,
+      ChannelLogger negotiationLogger) {
+    return new ClientTlsHandler(next, sslContext, authority, null, negotiationLogger,
+        Optional.absent(), null, null);
+  }
+
+  public static class ProtocolNegotiationHandler
+      extends ProtocolNegotiators.ProtocolNegotiationHandler {
+
+    protected ProtocolNegotiationHandler(ChannelHandler next, String negotiatorName,
+        ChannelLogger negotiationLogger) {
+      super(next, negotiatorName, negotiationLogger);
+    }
+
+    protected ProtocolNegotiationHandler(ChannelHandler next, ChannelLogger negotiationLogger) {
+      super(next, negotiationLogger);
+    }
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/InternalWriteBufferingAndExceptionHandlerUtils.java b/netty/src/main/java/io/grpc/netty/InternalWriteBufferingAndExceptionHandlerUtils.java
new file mode 100644
index 00000000000..0e09590c0ae
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/InternalWriteBufferingAndExceptionHandlerUtils.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2019 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.netty;
+
+import io.grpc.Internal;
+import io.netty.channel.Channel;
+
+/** Utility class for {@link WriteBufferingAndExceptionHandler}. */
+@Internal
+public final class InternalWriteBufferingAndExceptionHandlerUtils {
+
+  /**
+   * Writes buffered data and removes {@link WriteBufferingAndExceptionHandler} from {@link
+   * io.netty.channel.ChannelPipeline}.
+   *
+   * <p>Internal use only. Do not use.
+   */
+  public static void writeBufferingAndRemove(Channel channel) {
+    NettyClientHandler.writeBufferingAndRemove(channel);
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/JettyTlsUtil.java b/netty/src/main/java/io/grpc/netty/JettyTlsUtil.java
index f40c4ee2d53..2f5e3db1387 100644
--- a/netty/src/main/java/io/grpc/netty/JettyTlsUtil.java
+++ b/netty/src/main/java/io/grpc/netty/JettyTlsUtil.java
@@ -1,36 +1,25 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import java.lang.reflect.Method;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLEngine;
+
 /**
  * Utility class for determining support for Jetty TLS ALPN/NPN.
  */
@@ -38,27 +27,78 @@ final class JettyTlsUtil {
   private JettyTlsUtil() {
   }
 
-  /**
-   * Indicates whether or not the Jetty ALPN jar is installed in the boot classloader.
-   */
-  static boolean isJettyAlpnConfigured() {
+  private static Throwable jettyAlpnUnavailabilityCause;
+  private static Throwable jettyNpnUnavailabilityCause;
+
+  private static class Java9AlpnUnavailabilityCauseHolder {
+
+    @SuppressWarnings("StaticAssignmentOfThrowable")
+    static final Throwable cause = checkAlpnAvailability();
+
+    static Throwable checkAlpnAvailability() {
+      try {
+        SSLContext context = SSLContext.getInstance("TLS");
+        context.init(null, null, null);
+        SSLEngine engine = context.createSSLEngine();
+        Method getApplicationProtocol = SSLEngine.class.getMethod("getApplicationProtocol");
+        getApplicationProtocol.invoke(engine);
+        return null;
+      } catch (Throwable t) {
+        return t;
+      }
+    }
+  }
+
+  /** Indicates whether or not the Jetty ALPN jar is installed in the boot classloader. */
+  @SuppressWarnings("StaticAssignmentOfThrowable")
+  static synchronized boolean isJettyAlpnConfigured() {
     try {
       Class.forName("org.eclipse.jetty.alpn.ALPN", true, null);
       return true;
     } catch (ClassNotFoundException e) {
+      jettyAlpnUnavailabilityCause = e;
       return false;
     }
   }
 
-  /**
-   * Indicates whether or not the Jetty NPN jar is installed in the boot classloader.
-   */
-  static boolean isJettyNpnConfigured() {
+  static synchronized Throwable getJettyAlpnUnavailabilityCause() {
+    // This case should be unlikely
+    if (jettyAlpnUnavailabilityCause == null) {
+      @SuppressWarnings("UnusedVariable")
+      boolean discard = isJettyAlpnConfigured();
+    }
+    return jettyAlpnUnavailabilityCause;
+  }
+
+  /** Indicates whether or not the Jetty NPN jar is installed in the boot classloader. */
+  @SuppressWarnings("StaticAssignmentOfThrowable")
+  static synchronized boolean isJettyNpnConfigured() {
     try {
       Class.forName("org.eclipse.jetty.npn.NextProtoNego", true, null);
       return true;
     } catch (ClassNotFoundException e) {
+      jettyNpnUnavailabilityCause = e;
       return false;
     }
   }
+
+  static synchronized Throwable getJettyNpnUnavailabilityCause() {
+    // This case should be unlikely
+    if (jettyNpnUnavailabilityCause == null) {
+      @SuppressWarnings("UnusedVariable")
+      boolean discard = isJettyNpnConfigured();
+    }
+    return jettyNpnUnavailabilityCause;
+  }
+
+  /**
+   * Indicates whether Java 9 ALPN is available.
+   */
+  static boolean isJava9AlpnAvailable() {
+    return getJava9AlpnUnavailabilityCause() == null;
+  }
+
+  static Throwable getJava9AlpnUnavailabilityCause() {
+    return Java9AlpnUnavailabilityCauseHolder.cause;
+  }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NegotiationType.java b/netty/src/main/java/io/grpc/netty/NegotiationType.java
index a1a99fcda8f..e6d86b9c7ec 100644
--- a/netty/src/main/java/io/grpc/netty/NegotiationType.java
+++ b/netty/src/main/java/io/grpc/netty/NegotiationType.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
diff --git a/netty/src/main/java/io/grpc/netty/NettyAdaptiveCumulator.java b/netty/src/main/java/io/grpc/netty/NettyAdaptiveCumulator.java
new file mode 100644
index 00000000000..a1fe3fc2c38
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/NettyAdaptiveCumulator.java
@@ -0,0 +1,228 @@
+/*
+ * 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.netty;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.CompositeByteBuf;
+import io.netty.handler.codec.ByteToMessageDecoder.Cumulator;
+
+
+/**
+ * "Adaptive" cumulator: cumulate {@link ByteBuf}s by dynamically switching between merge and
+ * compose strategies.
+ */
+
+class NettyAdaptiveCumulator implements Cumulator {
+  private final int composeMinSize;
+
+  /**
+   * "Adaptive" cumulator: cumulate {@link ByteBuf}s by dynamically switching between merge and
+   * compose strategies.
+   *
+   * @param composeMinSize Determines the minimal size of the buffer that should be composed (added
+   *                       as a new component of the {@link CompositeByteBuf}). If the total size
+   *                       of the last component (tail) and the incoming buffer is below this value,
+   *                       the incoming buffer is appended to the tail, and the new component is not
+   *                       added.
+   */
+  NettyAdaptiveCumulator(int composeMinSize) {
+    Preconditions.checkArgument(composeMinSize >= 0, "composeMinSize must be non-negative");
+    this.composeMinSize = composeMinSize;
+  }
+
+  /**
+   * "Adaptive" cumulator: cumulate {@link ByteBuf}s by dynamically switching between merge and
+   * compose strategies.
+   *
+   * <p>This cumulator applies a heuristic to make a decision whether to track a reference to the
+   * buffer with bytes received from the network stack in an array ("zero-copy"), or to merge into
+   * the last component (the tail) by performing a memory copy.
+   *
+   * <p>It is necessary as a protection from a potential attack on the {@link
+   * io.netty.handler.codec.ByteToMessageDecoder#COMPOSITE_CUMULATOR}. Consider a pathological case
+   * when an attacker sends TCP packages containing a single byte of data, and forcing the cumulator
+   * to track each one in a separate buffer. The cost is memory overhead for each buffer, and extra
+   * compute to read the cumulation.
+   *
+   * <p>Implemented heuristic establishes a minimal threshold for the total size of the tail and
+   * incoming buffer, below which they are merged. The sum of the tail and the incoming buffer is
+   * used to avoid a case where attacker alternates the size of data packets to trick the cumulator
+   * into always selecting compose strategy.
+   *
+   * <p>Merging strategy attempts to minimize unnecessary memory writes. When possible, it expands
+   * the tail capacity and only copies the incoming buffer into available memory. Otherwise, when
+   * both tail and the buffer must be copied, the tail is reallocated (or fully replaced) with a new
+   * buffer of exponentially increasing capacity (bounded to {@link #composeMinSize}) to ensure
+   * runtime {@code O(n^2)} is amortized to {@code O(n)}.
+   */
+  @Override
+  @SuppressWarnings("ReferenceEquality")
+  public final ByteBuf cumulate(ByteBufAllocator alloc, ByteBuf cumulation, ByteBuf in) {
+    if (!cumulation.isReadable()) {
+      cumulation.release();
+      return in;
+    }
+    CompositeByteBuf composite = null;
+    try {
+      if (cumulation instanceof CompositeByteBuf && cumulation.refCnt() == 1) {
+        composite = (CompositeByteBuf) cumulation;
+        // Writer index must equal capacity if we are going to "write"
+        // new components to the end
+        if (composite.writerIndex() != composite.capacity()) {
+          composite.capacity(composite.writerIndex());
+        }
+      } else {
+        composite = alloc.compositeBuffer(Integer.MAX_VALUE)
+            .addFlattenedComponents(true, cumulation);
+      }
+      addInput(alloc, composite, in);
+      in = null;
+      return composite;
+    } finally {
+      if (in != null) {
+        // We must release if the ownership was not transferred as otherwise it may produce a leak
+        in.release();
+        // Also release any new buffer allocated if we're not returning it
+        if (composite != null && composite != cumulation) {
+          composite.release();
+        }
+      }
+    }
+  }
+
+  @VisibleForTesting
+  void addInput(ByteBufAllocator alloc, CompositeByteBuf composite, ByteBuf in) {
+    if (shouldCompose(composite, in, composeMinSize)) {
+      composite.addFlattenedComponents(true, in);
+    } else {
+      // The total size of the new data and the last component are below the threshold. Merge them.
+      mergeWithCompositeTail(alloc, composite, in);
+    }
+  }
+
+  @VisibleForTesting
+  static boolean shouldCompose(CompositeByteBuf composite, ByteBuf in, int composeMinSize) {
+    int componentCount = composite.numComponents();
+    if (composite.numComponents() == 0) {
+      return true;
+    }
+    int inputSize = in.readableBytes();
+    int tailStart = composite.toByteIndex(componentCount - 1);
+    int tailSize = composite.writerIndex() - tailStart;
+    return tailSize + inputSize >= composeMinSize;
+  }
+
+  /**
+   * Append the given {@link ByteBuf} {@code in} to {@link CompositeByteBuf} {@code composite} by
+   * expanding or replacing the tail component of the {@link CompositeByteBuf}.
+   *
+   * <p>The goal is to prevent {@code O(n^2)} runtime in a pathological case, that forces copying
+   * the tail component into a new buffer, for each incoming single-byte buffer. We append the new
+   * bytes to the tail, when a write (or a fast write) is possible.
+   *
+   * <p>Otherwise, the tail is replaced with a new buffer, with the capacity increased enough to
+   * achieve runtime amortization.
+   *
+   * <p>We assume that implementations of {@link ByteBufAllocator#calculateNewCapacity(int, int)},
+   * are similar to {@link io.netty.buffer.AbstractByteBufAllocator#calculateNewCapacity(int, int)},
+   * which doubles buffer capacity by normalizing it to the closest power of two. This assumption
+   * is verified in unit tests for this method.
+   */
+  @VisibleForTesting
+  static void mergeWithCompositeTail(
+      ByteBufAllocator alloc, CompositeByteBuf composite, ByteBuf in) {
+    int inputSize = in.readableBytes();
+    int tailComponentIndex = composite.numComponents() - 1;
+    int tailStart = composite.toByteIndex(tailComponentIndex);
+    int tailSize = composite.writerIndex() - tailStart;
+    int newTailSize = inputSize + tailSize;
+    ByteBuf tail = composite.component(tailComponentIndex);
+    ByteBuf newTail = null;
+    try {
+      if (tail.refCnt() == 1 && !tail.isReadOnly() && newTailSize <= tail.maxCapacity()) {
+        // Ideal case: the tail isn't shared, and can be expanded to the required capacity.
+
+        // Take ownership of the tail.
+        newTail = tail.retain();
+
+        // TODO(https://github.com/netty/netty/issues/12844): remove when we use Netty with
+        //   the issue fixed.
+        // In certain cases, removing the CompositeByteBuf component, and then adding it back
+        // isn't idempotent. An example is provided in https://github.com/netty/netty/issues/12844.
+        // This happens because the buffer returned by composite.component() has out-of-sync
+        // indexes. Under the hood the CompositeByteBuf returns a duplicate() of the underlying
+        // buffer, but doesn't set the indexes.
+        //
+        // To get the right indexes we use the fact that composite.internalComponent() returns
+        // the slice() into the readable portion of the underlying buffer.
+        // We use this implementation detail (internalComponent() returning a *SlicedByteBuf),
+        // and combine it with the fact that SlicedByteBuf duplicates have their indexes
+        // adjusted so they correspond to the to the readable portion of the slice.
+        //
+        // Hence composite.internalComponent().duplicate() returns a buffer with the
+        // indexes that should've been on the composite.component() in the first place.
+        // Until the issue is fixed, we manually adjust the indexes of the removed component.
+        ByteBuf sliceDuplicate = composite.internalComponent(tailComponentIndex).duplicate();
+        newTail.setIndex(sliceDuplicate.readerIndex(), sliceDuplicate.writerIndex());
+
+        /*
+         * The tail is a readable non-composite buffer, so writeBytes() handles everything for us.
+         *
+         * - ensureWritable() performs a fast resize when possible (f.e. PooledByteBuf simply
+         *   updates its boundary to the end of consecutive memory run assigned to this buffer)
+         * - when the required size doesn't fit into writableBytes(), a new buffer is
+         *   allocated, and the capacity calculated with alloc.calculateNewCapacity()
+         * - note that maxFastWritableBytes() would normally allow a fast expansion of PooledByteBuf
+         *   is not called because CompositeByteBuf.component() returns a duplicate, wrapped buffer.
+         *   Unwrapping buffers is unsafe, and potential benefit of fast writes may not be
+         *   as pronounced because the capacity is doubled with each reallocation.
+         */
+        newTail.writeBytes(in);
+
+      } else {
+        // The tail is shared, or not expandable. Replace it with a new buffer of desired capacity.
+        newTail = alloc.buffer(alloc.calculateNewCapacity(newTailSize, Integer.MAX_VALUE));
+        newTail.setBytes(0, composite, tailStart, tailSize)
+            .setBytes(tailSize, in, in.readerIndex(), inputSize)
+            .writerIndex(newTailSize);
+        in.readerIndex(in.writerIndex());
+      }
+
+      // Store readerIndex to avoid out of bounds writerIndex during component replacement.
+      int prevReader = composite.readerIndex();
+      // Remove the old tail, reset writer index.
+      composite.removeComponent(tailComponentIndex).setIndex(0, tailStart);
+      // Add back the new tail.
+      composite.addFlattenedComponents(true, newTail);
+      // New tail's ownership transferred to the composite buf.
+      newTail = null;
+      composite.readerIndex(prevReader);
+      // Input buffer was successfully merged with the tail.
+      // Must be the last line in the try because we release it only on success.
+      in.release();
+    } finally {
+      // If new tail's ownership isn't transferred to the composite buf.
+      // Release it to prevent a leak.
+      if (newTail != null) {
+        newTail.release();
+      }
+    }
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/NettyChannelBuilder.java b/netty/src/main/java/io/grpc/netty/NettyChannelBuilder.java
index a0fb0733d9d..258aa15b005 100644
--- a/netty/src/main/java/io/grpc/netty/NettyChannelBuilder.java
+++ b/netty/src/main/java/io/grpc/netty/NettyChannelBuilder.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -34,31 +19,54 @@
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
-import static io.grpc.internal.GrpcUtil.DEFAULT_KEEPALIVE_DELAY_NANOS;
 import static io.grpc.internal.GrpcUtil.DEFAULT_KEEPALIVE_TIMEOUT_NANOS;
+import static io.grpc.internal.GrpcUtil.KEEPALIVE_TIME_NANOS_DISABLED;
 
 import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
+import com.google.common.base.Optional;
+import com.google.common.base.Ticker;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.CheckReturnValue;
+import com.google.errorprone.annotations.InlineMe;
 import io.grpc.Attributes;
+import io.grpc.CallCredentials;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.EquivalentAddressGroup;
 import io.grpc.ExperimentalApi;
-import io.grpc.NameResolver;
-import io.grpc.internal.AbstractManagedChannelImplBuilder;
+import io.grpc.ForwardingChannelBuilder2;
+import io.grpc.HttpConnectProxiedSocketAddress;
+import io.grpc.Internal;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.internal.AtomicBackoff;
 import io.grpc.internal.ClientTransportFactory;
 import io.grpc.internal.ConnectionClientTransport;
+import io.grpc.internal.FixedObjectPool;
 import io.grpc.internal.GrpcUtil;
-import io.grpc.internal.SharedResourceHolder;
+import io.grpc.internal.KeepAliveManager;
+import io.grpc.internal.ManagedChannelImplBuilder;
+import io.grpc.internal.ManagedChannelImplBuilder.ChannelBuilderDefaultPortProvider;
+import io.grpc.internal.ManagedChannelImplBuilder.ClientTransportFactoryBuilder;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.internal.TransportTracer;
+import io.grpc.netty.ProtocolNegotiators.FromChannelCredentialsResult;
 import io.netty.channel.Channel;
+import io.netty.channel.ChannelFactory;
 import io.netty.channel.ChannelOption;
 import io.netty.channel.EventLoopGroup;
+import io.netty.channel.ReflectiveChannelFactory;
 import io.netty.channel.socket.nio.NioSocketChannel;
 import io.netty.handler.ssl.SslContext;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
-import javax.annotation.CheckReturnValue;
 import javax.annotation.Nullable;
 import javax.net.ssl.SSLException;
 
@@ -66,72 +74,173 @@
  * A builder to help simplify construction of channels using the Netty transport.
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1784")
-@CanIgnoreReturnValue
-public final class NettyChannelBuilder
-    extends AbstractManagedChannelImplBuilder<NettyChannelBuilder> {
-  public static final int DEFAULT_FLOW_CONTROL_WINDOW = 1048576; // 1MiB
+@CheckReturnValue
+public final class NettyChannelBuilder extends ForwardingChannelBuilder2<NettyChannelBuilder> {
+
+  // 1MiB.
+  public static final int DEFAULT_FLOW_CONTROL_WINDOW = 1024 * 1024;
+  private static final boolean DEFAULT_AUTO_FLOW_CONTROL;
+
+  private static final long AS_LARGE_AS_INFINITE = TimeUnit.DAYS.toNanos(1000L);
 
-  private final Map<ChannelOption<?>, Object> channelOptions =
-      new HashMap<ChannelOption<?>, Object>();
+  private static final ChannelFactory<? extends Channel> DEFAULT_CHANNEL_FACTORY =
+      new ReflectiveChannelFactory<>(Utils.DEFAULT_CLIENT_CHANNEL_TYPE);
+  private static final ObjectPool<? extends EventLoopGroup> DEFAULT_EVENT_LOOP_GROUP_POOL =
+      SharedResourcePool.forResource(Utils.DEFAULT_WORKER_EVENT_LOOP_GROUP);
 
-  private NegotiationType negotiationType = NegotiationType.TLS;
-  private OverrideAuthorityChecker authorityChecker;
-  private Class<? extends Channel> channelType = NioSocketChannel.class;
+  static {
+    String autoFlowControl = System.getenv("GRPC_EXPERIMENTAL_AUTOFLOWCONTROL");
+    if (autoFlowControl == null) {
+      autoFlowControl = "true";
+    }
+    DEFAULT_AUTO_FLOW_CONTROL = Boolean.parseBoolean(autoFlowControl);
+  }
 
-  @Nullable
-  private EventLoopGroup eventLoopGroup;
-  private SslContext sslContext;
+  private final ManagedChannelImplBuilder managedChannelImplBuilder;
+  private TransportTracer.Factory transportTracerFactory = TransportTracer.getDefaultFactory();
+  private final Map<ChannelOption<?>, Object> channelOptions = new HashMap<>();
+  private ChannelFactory<? extends Channel> channelFactory = DEFAULT_CHANNEL_FACTORY;
+  private ObjectPool<? extends EventLoopGroup> eventLoopGroupPool = DEFAULT_EVENT_LOOP_GROUP_POOL;
+  private boolean autoFlowControl = DEFAULT_AUTO_FLOW_CONTROL;
   private int flowControlWindow = DEFAULT_FLOW_CONTROL_WINDOW;
   private int maxHeaderListSize = GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE;
-  private boolean enableKeepAlive;
-  private long keepAliveDelayNanos;
-  private long keepAliveTimeoutNanos;
-  private TransportCreationParamsFilterFactory dynamicParamsFactory;
+  private int softLimitHeaderListSize = GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE;
+  private int maxInboundMessageSize = GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
+  private long keepAliveTimeNanos = KEEPALIVE_TIME_NANOS_DISABLED;
+  private long keepAliveTimeoutNanos = DEFAULT_KEEPALIVE_TIMEOUT_NANOS;
+  private boolean keepAliveWithoutCalls;
+  private ProtocolNegotiator.ClientFactory protocolNegotiatorFactory
+      = new DefaultProtocolNegotiator();
+  private final boolean freezeProtocolNegotiatorFactory;
+  private LocalSocketPicker localSocketPicker;
+
+  /**
+   * If true, indicates that the transport may use the GET method for RPCs, and may include the
+   * request body in the query params.
+   */
+  private final boolean useGetForSafeMethods = false;
+
+  private Class<? extends SocketAddress> transportSocketType = InetSocketAddress.class;
 
   /**
    * Creates a new builder with the given server address. This factory method is primarily intended
    * for using Netty Channel types other than SocketChannel. {@link #forAddress(String, int)} should
    * generally be preferred over this method, since that API permits delaying DNS lookups and
-   * noticing changes to DNS.
+   * noticing changes to DNS. If an unresolved InetSocketAddress is passed in, then it will remain
+   * unresolved.
    */
-  @CheckReturnValue
   public static NettyChannelBuilder forAddress(SocketAddress serverAddress) {
     return new NettyChannelBuilder(serverAddress);
   }
 
+  /**
+   * Creates a new builder with the given server address. This factory method is primarily intended
+   * for using Netty Channel types other than SocketChannel.
+   * {@link #forAddress(String, int, ChannelCredentials)} should generally be preferred over this
+   * method, since that API permits delaying DNS lookups and noticing changes to DNS. If an
+   * unresolved InetSocketAddress is passed in, then it will remain unresolved.
+   */
+  public static NettyChannelBuilder forAddress(SocketAddress serverAddress,
+      ChannelCredentials creds) {
+    FromChannelCredentialsResult result = ProtocolNegotiators.from(creds);
+    if (result.error != null) {
+      throw new IllegalArgumentException(result.error);
+    }
+    return new NettyChannelBuilder(serverAddress, creds, result.callCredentials, result.negotiator);
+  }
+
   /**
    * Creates a new builder with the given host and port.
    */
-  @CheckReturnValue
   public static NettyChannelBuilder forAddress(String host, int port) {
-    return new NettyChannelBuilder(host, port);
+    return forTarget(GrpcUtil.authorityFromHostAndPort(host, port));
+  }
+
+  /**
+   * Creates a new builder with the given host and port.
+   */
+  public static NettyChannelBuilder forAddress(String host, int port, ChannelCredentials creds) {
+    return forTarget(GrpcUtil.authorityFromHostAndPort(host, port), creds);
   }
 
   /**
    * Creates a new builder with the given target string that will be resolved by
    * {@link io.grpc.NameResolver}.
    */
-  @CheckReturnValue
   public static NettyChannelBuilder forTarget(String target) {
     return new NettyChannelBuilder(target);
   }
 
-  @CheckReturnValue
-  NettyChannelBuilder(String host, int port) {
-    this(GrpcUtil.authorityFromHostAndPort(host, port));
+  /**
+   * Creates a new builder with the given target string that will be resolved by
+   * {@link io.grpc.NameResolver}.
+   */
+  public static NettyChannelBuilder forTarget(String target, ChannelCredentials creds) {
+    FromChannelCredentialsResult result = ProtocolNegotiators.from(creds);
+    if (result.error != null) {
+      throw new IllegalArgumentException(result.error);
+    }
+    return new NettyChannelBuilder(target, creds, result.callCredentials, result.negotiator);
+  }
+
+  private final class NettyChannelTransportFactoryBuilder implements ClientTransportFactoryBuilder {
+    @Override
+    public ClientTransportFactory buildClientTransportFactory() {
+      return buildTransportFactory();
+    }
+  }
+
+  private final class NettyChannelDefaultPortProvider implements ChannelBuilderDefaultPortProvider {
+    @Override
+    public int getDefaultPort() {
+      return protocolNegotiatorFactory.getDefaultPort();
+    }
   }
 
-  @CheckReturnValue
   NettyChannelBuilder(String target) {
-    super(target);
+    managedChannelImplBuilder = new ManagedChannelImplBuilder(target,
+        new NettyChannelTransportFactoryBuilder(),
+        new NettyChannelDefaultPortProvider());
+    this.freezeProtocolNegotiatorFactory = false;
+  }
+
+  NettyChannelBuilder(
+      String target, ChannelCredentials channelCreds, CallCredentials callCreds,
+      ProtocolNegotiator.ClientFactory negotiator) {
+    managedChannelImplBuilder = new ManagedChannelImplBuilder(
+        target, channelCreds, callCreds,
+        new NettyChannelTransportFactoryBuilder(),
+        new NettyChannelDefaultPortProvider());
+    this.protocolNegotiatorFactory = checkNotNull(negotiator, "negotiator");
+    this.freezeProtocolNegotiatorFactory = true;
   }
 
-  @CheckReturnValue
   NettyChannelBuilder(SocketAddress address) {
-    super(address, getAuthorityFromAddress(address));
+    managedChannelImplBuilder = new ManagedChannelImplBuilder(address,
+        getAuthorityFromAddress(address),
+        new NettyChannelTransportFactoryBuilder(),
+        new NettyChannelDefaultPortProvider());
+    this.freezeProtocolNegotiatorFactory = false;
+  }
+
+  NettyChannelBuilder(
+      SocketAddress address, ChannelCredentials channelCreds, CallCredentials callCreds,
+      ProtocolNegotiator.ClientFactory negotiator) {
+    managedChannelImplBuilder = new ManagedChannelImplBuilder(address,
+        getAuthorityFromAddress(address),
+        channelCreds, callCreds,
+        new NettyChannelTransportFactoryBuilder(),
+        new NettyChannelDefaultPortProvider());
+    this.protocolNegotiatorFactory = checkNotNull(negotiator, "negotiator");
+    this.freezeProtocolNegotiatorFactory = true;
+  }
+
+  @Internal
+  @Override
+  protected ManagedChannelBuilder<?> delegate() {
+    return managedChannelImplBuilder;
   }
 
-  @CheckReturnValue
   private static String getAuthorityFromAddress(SocketAddress address) {
     if (address instanceof InetSocketAddress) {
       InetSocketAddress inetAddress = (InetSocketAddress) address;
@@ -142,10 +251,71 @@ private static String getAuthorityFromAddress(SocketAddress address) {
   }
 
   /**
-   * Specifies the channel type to use, by default we use {@link NioSocketChannel}.
+   * Specifies the channel type to use, by default we use {@code EpollSocketChannel} if available,
+   * otherwise using {@link NioSocketChannel}.
+   *
+   * <p>You either use this or {@link #channelFactory(io.netty.channel.ChannelFactory)} if your
+   * {@link Channel} implementation has no no-args constructor.
+   *
+   * <p>It's an optional parameter. If the user has not provided an Channel type or ChannelFactory
+   * when the channel is built, the builder will use the default one which is static.
+   *
+   * <p>You must also provide corresponding {@link #eventLoopGroup(EventLoopGroup)}. For example,
+   * {@link NioSocketChannel} must use {@link io.netty.channel.nio.NioEventLoopGroup}, otherwise
+   * your application won't start.
    */
+  @CanIgnoreReturnValue
   public NettyChannelBuilder channelType(Class<? extends Channel> channelType) {
-    this.channelType = Preconditions.checkNotNull(channelType, "channelType");
+    return channelType(channelType, null);
+  }
+
+  /**
+   * Similar to {@link #channelType(Class)} above but allows the
+   * caller to specify the socket-type associated with the channelType.
+   *
+   * @param channelType the type of {@link Channel} to use.
+   * @param transportSocketType the associated {@link SocketAddress} type. If {@code null}, then
+   *     no compatibility check is performed between channel transport and name-resolver addresses.
+   */
+  @CanIgnoreReturnValue
+  public NettyChannelBuilder channelType(Class<? extends Channel> channelType,
+      @Nullable Class<? extends SocketAddress> transportSocketType) {
+    checkNotNull(channelType, "channelType");
+    return channelFactory(new ReflectiveChannelFactory<>(channelType),
+        transportSocketType);
+  }
+
+  /**
+   * Specifies the {@link ChannelFactory} to create {@link Channel} instances. This method is
+   * usually only used if the specific {@code Channel} requires complex logic which requires
+   * additional information to create the {@code Channel}. Otherwise, recommend to use {@link
+   * #channelType(Class)}.
+   *
+   * <p>It's an optional parameter. If the user has not provided an Channel type or ChannelFactory
+   * when the channel is built, the builder will use the default one which is static.
+   *
+   * <p>You must also provide corresponding {@link #eventLoopGroup(EventLoopGroup)}. For example,
+   * {@link NioSocketChannel} based {@link ChannelFactory} must use {@link
+   * io.netty.channel.nio.NioEventLoopGroup}, otherwise your application won't start.
+   */
+  @CanIgnoreReturnValue
+  public NettyChannelBuilder channelFactory(ChannelFactory<? extends Channel> channelFactory) {
+    return channelFactory(channelFactory, null);
+  }
+
+  /**
+   * Similar to {@link #channelFactory(ChannelFactory)} above but allows the
+   * caller to specify the socket-type associated with the channelFactory.
+   *
+   * @param channelFactory the {@link ChannelFactory} to use.
+   * @param transportSocketType the associated {@link SocketAddress} type. If {@code null}, then
+   *     no compatibility check is performed between channel transport and name-resolver addresses.
+   */
+  @CanIgnoreReturnValue
+  public NettyChannelBuilder channelFactory(ChannelFactory<? extends Channel> channelFactory,
+      @Nullable Class<? extends SocketAddress> transportSocketType) {
+    this.channelFactory = checkNotNull(channelFactory, "channelFactory");
+    this.transportSocketType = transportSocketType;
     return this;
   }
 
@@ -153,6 +323,7 @@ public NettyChannelBuilder channelType(Class<? extends Channel> channelType) {
    * Specifies a channel option. As the underlying channel as well as network implementation may
    * ignore this value applications should consider it a hint.
    */
+  @CanIgnoreReturnValue
   public <T> NettyChannelBuilder withOption(ChannelOption<T> option, T value) {
     channelOptions.put(option, value);
     return this;
@@ -163,8 +334,15 @@ public <T> NettyChannelBuilder withOption(ChannelOption<T> option, T value) {
    *
    * <p>Default: <code>TLS</code>
    */
+  @CanIgnoreReturnValue
   public NettyChannelBuilder negotiationType(NegotiationType type) {
-    negotiationType = type;
+    checkState(!freezeProtocolNegotiatorFactory,
+               "Cannot change security when using ChannelCredentials");
+    if (!(protocolNegotiatorFactory instanceof DefaultProtocolNegotiator)) {
+      // Do nothing for compatibility
+      return this;
+    }
+    ((DefaultProtocolNegotiator) protocolNegotiatorFactory).negotiationType = type;
     return this;
   }
 
@@ -174,11 +352,24 @@ public NettyChannelBuilder negotiationType(NegotiationType type) {
    * <p>It's an optional parameter. If the user has not provided an EventGroupLoop when the channel
    * is built, the builder will use the default one which is static.
    *
+   * <p>You must also provide corresponding {@link #channelType(Class)} or {@link
+   * #channelFactory(ChannelFactory)} corresponding to the given {@code EventLoopGroup}. For
+   * example, {@link io.netty.channel.nio.NioEventLoopGroup} requires {@link NioSocketChannel}
+   *
    * <p>The channel won't take ownership of the given EventLoopGroup. It's caller's responsibility
    * to shut it down when it's desired.
    */
+  @CanIgnoreReturnValue
   public NettyChannelBuilder eventLoopGroup(@Nullable EventLoopGroup eventLoopGroup) {
-    this.eventLoopGroup = eventLoopGroup;
+    if (eventLoopGroup != null) {
+      return eventLoopGroupPool(new FixedObjectPool<>(eventLoopGroup));
+    }
+    return eventLoopGroupPool(DEFAULT_EVENT_LOOP_GROUP_POOL);
+  }
+
+  @CanIgnoreReturnValue
+  NettyChannelBuilder eventLoopGroupPool(ObjectPool<? extends EventLoopGroup> eventLoopGroupPool) {
+    this.eventLoopGroupPool = checkNotNull(eventLoopGroupPool, "eventLoopGroupPool");
     return this;
   }
 
@@ -186,273 +377,522 @@ public NettyChannelBuilder eventLoopGroup(@Nullable EventLoopGroup eventLoopGrou
    * SSL/TLS context to use instead of the system default. It must have been configured with {@link
    * GrpcSslContexts}, but options could have been overridden.
    */
+  @CanIgnoreReturnValue
   public NettyChannelBuilder sslContext(SslContext sslContext) {
+    checkState(!freezeProtocolNegotiatorFactory,
+               "Cannot change security when using ChannelCredentials");
     if (sslContext != null) {
       checkArgument(sslContext.isClient(),
           "Server SSL context can not be used for client channel");
       GrpcSslContexts.ensureAlpnAndH2Enabled(sslContext.applicationProtocolNegotiator());
     }
-    this.sslContext = sslContext;
+    if (!(protocolNegotiatorFactory instanceof DefaultProtocolNegotiator)) {
+      // Do nothing for compatibility
+      return this;
+    }
+    ((DefaultProtocolNegotiator) protocolNegotiatorFactory).sslContext = sslContext;
+    return this;
+  }
+
+  /**
+   * Sets the initial flow control window in bytes. Setting initial flow control window enables auto
+   * flow control tuning using bandwidth-delay product algorithm. To disable auto flow control
+   * tuning, use {@link #flowControlWindow(int)}. By default, auto flow control is enabled with
+   * initial flow control window size of {@link #DEFAULT_FLOW_CONTROL_WINDOW}.
+   */
+  @CanIgnoreReturnValue
+  public NettyChannelBuilder initialFlowControlWindow(int initialFlowControlWindow) {
+    checkArgument(initialFlowControlWindow > 0, "initialFlowControlWindow must be positive");
+    this.flowControlWindow = initialFlowControlWindow;
+    this.autoFlowControl = true;
     return this;
   }
 
   /**
-   * Sets the flow control window in bytes. If not called, the default value
-   * is {@link #DEFAULT_FLOW_CONTROL_WINDOW}).
+   * Sets the flow control window in bytes. Setting flowControlWindow disables auto flow control
+   * tuning; use {@link #initialFlowControlWindow(int)} to enable auto flow control tuning. If not
+   * called, the default value is {@link #DEFAULT_FLOW_CONTROL_WINDOW}) with auto flow control
+   * tuning.
    */
+  @CanIgnoreReturnValue
   public NettyChannelBuilder flowControlWindow(int flowControlWindow) {
     checkArgument(flowControlWindow > 0, "flowControlWindow must be positive");
     this.flowControlWindow = flowControlWindow;
+    this.autoFlowControl = false;
     return this;
   }
 
   /**
-   * Sets the max message size.
+   * Sets the maximum size of header list allowed to be received. This is cumulative size of the
+   * headers with some overhead, as defined for
+   * <a href="http://httpwg.org/specs/rfc7540.html#rfc.section.6.5.2">
+   * HTTP/2's SETTINGS_MAX_HEADER_LIST_SIZE</a>. The default is 8 KiB.
    *
-   * @deprecated Use {@link #maxInboundMessageSize} instead
+   * @deprecated Use {@link #maxInboundMetadataSize} instead
    */
+  @CanIgnoreReturnValue
   @Deprecated
-  public NettyChannelBuilder maxMessageSize(int maxMessageSize) {
-    maxInboundMessageSize(maxMessageSize);
+  @InlineMe(replacement = "this.maxInboundMetadataSize(maxHeaderListSize)")
+  public NettyChannelBuilder maxHeaderListSize(int maxHeaderListSize) {
+    return maxInboundMetadataSize(maxHeaderListSize);
+  }
+
+  /**
+   * Sets the maximum size of metadata allowed to be received. This is cumulative size of the
+   * entries with some overhead, as defined for
+   * <a href="http://httpwg.org/specs/rfc7540.html#rfc.section.6.5.2">
+   * HTTP/2's SETTINGS_MAX_HEADER_LIST_SIZE</a>. The default is 8 KiB.
+   *
+   * @param bytes the maximum size of received metadata
+   * @return this
+   * @throws IllegalArgumentException if bytes is non-positive
+   * @since 1.17.0
+   */
+  @CanIgnoreReturnValue
+  @Override
+  public NettyChannelBuilder maxInboundMetadataSize(int bytes) {
+    checkArgument(bytes > 0, "maxInboundMetadataSize must be > 0");
+    this.maxHeaderListSize = bytes;
+    // Clear the soft limit setting, by setting soft limit to maxInboundMetadataSize. The
+    // maxInboundMetadataSize will take precedence be applied before soft limit check.
+    this.softLimitHeaderListSize = bytes;
     return this;
   }
 
   /**
-   * Sets the maximum size of header list allowed to be received on the channel. If not called,
-   * defaults to {@link GrpcUtil#DEFAULT_MAX_HEADER_LIST_SIZE}.
+   * Sets the size of metadata that clients are advised to not exceed. When a metadata with size
+   * larger than the soft limit is encountered there will be a probability the RPC will fail. The
+   * chance of failing increases as the metadata size approaches the hard limit.
+   * {@code Integer.MAX_VALUE} disables the enforcement. The default is implementation-dependent,
+   * but is not generally less than 8 KiB and may be unlimited.
+   *
+   * <p>This is cumulative size of the metadata. The precise calculation is
+   * implementation-dependent, but implementations are encouraged to follow the calculation used
+   * for
+   * <a href="http://httpwg.org/specs/rfc7540.html#rfc.section.6.5.2">HTTP/2's
+   * SETTINGS_MAX_HEADER_LIST_SIZE</a>. It sums the bytes from each entry's key and value, plus 32
+   * bytes of overhead per entry.
+   *
+   * @param soft the soft size limit of received metadata
+   * @param max the hard size limit of received metadata
+   * @return this
+   * @throws IllegalArgumentException if soft and/or max is non-positive, or max smaller than
+   *     soft
+   * @since 1.68.0
    */
-  public NettyChannelBuilder maxHeaderListSize(int maxHeaderListSize) {
-    checkArgument(maxHeaderListSize > 0, "maxHeaderListSize must be > 0");
-    this.maxHeaderListSize = maxHeaderListSize;
+  @CanIgnoreReturnValue
+  public NettyChannelBuilder maxInboundMetadataSize(int soft, int max) {
+    checkArgument(soft > 0, "softLimitHeaderListSize must be > 0");
+    checkArgument(max > soft,
+        "maxInboundMetadataSize must be greater than softLimitHeaderListSize");
+    this.softLimitHeaderListSize = soft;
+    this.maxHeaderListSize = max;
     return this;
   }
 
   /**
-   * Equivalent to using {@link #negotiationType(NegotiationType)} with {@code PLAINTEXT} or
-   * {@code PLAINTEXT_UPGRADE}.
+   * Equivalent to using {@link #negotiationType(NegotiationType)} with {@code PLAINTEXT}.
    */
+  @CanIgnoreReturnValue
   @Override
-  public NettyChannelBuilder usePlaintext(boolean skipNegotiation) {
-    if (skipNegotiation) {
-      negotiationType(NegotiationType.PLAINTEXT);
-    } else {
-      negotiationType(NegotiationType.PLAINTEXT_UPGRADE);
-    }
+  public NettyChannelBuilder usePlaintext() {
+    negotiationType(NegotiationType.PLAINTEXT);
     return this;
   }
 
-
   /**
-   * Enable keepalive with default delay and timeout.
+   * Equivalent to using {@link #negotiationType(NegotiationType)} with {@code TLS}.
    */
-  public final NettyChannelBuilder enableKeepAlive(boolean enable) {
-    enableKeepAlive = enable;
-    if (enable) {
-      keepAliveDelayNanos = DEFAULT_KEEPALIVE_DELAY_NANOS;
-      keepAliveTimeoutNanos = DEFAULT_KEEPALIVE_TIMEOUT_NANOS;
-    }
+  @CanIgnoreReturnValue
+  @Override
+  public NettyChannelBuilder useTransportSecurity() {
+    negotiationType(NegotiationType.TLS);
     return this;
   }
 
   /**
-   * Enable keepalive with custom delay and timeout.
+   * {@inheritDoc}
+   *
+   * @since 1.3.0
    */
-  public final NettyChannelBuilder enableKeepAlive(boolean enable, long keepAliveDelay,
-      TimeUnit delayUnit, long keepAliveTimeout, TimeUnit timeoutUnit) {
-    enableKeepAlive = enable;
-    if (enable) {
-      keepAliveDelayNanos = delayUnit.toNanos(keepAliveDelay);
-      keepAliveTimeoutNanos = timeoutUnit.toNanos(keepAliveTimeout);
+  @CanIgnoreReturnValue
+  @Override
+  public NettyChannelBuilder keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    checkArgument(keepAliveTime > 0L, "keepalive time must be positive");
+    keepAliveTimeNanos = timeUnit.toNanos(keepAliveTime);
+    keepAliveTimeNanos = KeepAliveManager.clampKeepAliveTimeInNanos(keepAliveTimeNanos);
+    if (keepAliveTimeNanos >= AS_LARGE_AS_INFINITE) {
+      // Bump keepalive time to infinite. This disables keepalive.
+      keepAliveTimeNanos = KEEPALIVE_TIME_NANOS_DISABLED;
     }
     return this;
   }
 
+  /**
+   * {@inheritDoc}
+   *
+   * @since 1.3.0
+   */
+  @CanIgnoreReturnValue
   @Override
-  @CheckReturnValue
-  protected ClientTransportFactory buildTransportFactory() {
-    return new NettyTransportFactory(dynamicParamsFactory, channelType, channelOptions,
-        negotiationType, sslContext, eventLoopGroup, flowControlWindow, maxInboundMessageSize(),
-        maxHeaderListSize, enableKeepAlive, keepAliveDelayNanos, keepAliveTimeoutNanos);
+  public NettyChannelBuilder keepAliveTimeout(long keepAliveTimeout, TimeUnit timeUnit) {
+    checkArgument(keepAliveTimeout > 0L, "keepalive timeout must be positive");
+    keepAliveTimeoutNanos = timeUnit.toNanos(keepAliveTimeout);
+    keepAliveTimeoutNanos = KeepAliveManager.clampKeepAliveTimeoutInNanos(keepAliveTimeoutNanos);
+    return this;
   }
 
+  /**
+   * {@inheritDoc}
+   *
+   * @since 1.3.0
+   */
+  @CanIgnoreReturnValue
   @Override
-  @CheckReturnValue
-  protected Attributes getNameResolverParams() {
-    int defaultPort;
-    switch (negotiationType) {
-      case PLAINTEXT:
-      case PLAINTEXT_UPGRADE:
-        defaultPort = GrpcUtil.DEFAULT_PORT_PLAINTEXT;
-        break;
-      case TLS:
-        defaultPort = GrpcUtil.DEFAULT_PORT_SSL;
-        break;
-      default:
-        throw new AssertionError(negotiationType + " not handled");
+  public NettyChannelBuilder keepAliveWithoutCalls(boolean enable) {
+    keepAliveWithoutCalls = enable;
+    return this;
+  }
+
+
+  /**
+   * If non-{@code null}, attempts to create connections bound to a local port.
+   */
+  @CanIgnoreReturnValue
+  public NettyChannelBuilder localSocketPicker(@Nullable LocalSocketPicker localSocketPicker) {
+    this.localSocketPicker = localSocketPicker;
+    return this;
+  }
+
+  /**
+   * This class is meant to be overriden with a custom implementation of
+   * {@link #createSocketAddress}.  The default implementation is a no-op.
+   *
+   * @since 1.16.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4917")
+  public static class LocalSocketPicker {
+
+    /**
+     * Called by gRPC to pick local socket to bind to.  This may be called multiple times.
+     * Subclasses are expected to override this method.
+     *
+     * @param remoteAddress the remote address to connect to.
+     * @param attrs the Attributes present on the {@link io.grpc.EquivalentAddressGroup} associated
+     *        with the address.
+     * @return a {@link SocketAddress} suitable for binding, or else {@code null}.
+     * @since 1.16.0
+     */
+    @Nullable
+    public SocketAddress createSocketAddress(
+        SocketAddress remoteAddress, @EquivalentAddressGroup.Attr Attributes attrs) {
+      return null;
     }
-    return Attributes.newBuilder()
-        .set(NameResolver.Factory.PARAMS_DEFAULT_PORT, defaultPort).build();
   }
 
-  void overrideAuthorityChecker(@Nullable OverrideAuthorityChecker authorityChecker) {
-    this.authorityChecker = authorityChecker;
+  /**
+   * Sets the maximum message size allowed for a single gRPC frame. If an inbound messages larger
+   * than this limit is received it will not be processed and the RPC will fail with
+   * RESOURCE_EXHAUSTED.
+   */
+  @CanIgnoreReturnValue
+  @Override
+  public NettyChannelBuilder maxInboundMessageSize(int max) {
+    checkArgument(max >= 0, "negative max");
+    maxInboundMessageSize = max;
+    return this;
+  }
+
+  ClientTransportFactory buildTransportFactory() {
+    assertEventLoopAndChannelType();
+
+    ProtocolNegotiator negotiator = protocolNegotiatorFactory.newNegotiator();
+    return new NettyTransportFactory(
+        negotiator,
+        channelFactory,
+        channelOptions,
+        eventLoopGroupPool,
+        autoFlowControl,
+        flowControlWindow,
+        maxInboundMessageSize,
+        maxHeaderListSize,
+        softLimitHeaderListSize,
+        keepAliveTimeNanos,
+        keepAliveTimeoutNanos,
+        keepAliveWithoutCalls,
+        transportTracerFactory,
+        localSocketPicker,
+        useGetForSafeMethods,
+        transportSocketType);
   }
 
   @VisibleForTesting
-  @CheckReturnValue
-  static ProtocolNegotiator createProtocolNegotiator(
-      String authority,
-      NegotiationType negotiationType,
-      SslContext sslContext) {
-    ProtocolNegotiator negotiator =
-        createProtocolNegotiatorByType(authority, negotiationType, sslContext);
-    String proxy = System.getenv("GRPC_PROXY_EXP");
-    if (proxy != null) {
-      String[] parts = proxy.split(":", 2);
-      int port = 80;
-      if (parts.length > 1) {
-        port = Integer.parseInt(parts[1]);
-      }
-      InetSocketAddress proxyAddress = new InetSocketAddress(parts[0], port);
-      negotiator = ProtocolNegotiators.httpProxy(proxyAddress, null, null, negotiator);
-    }
-    return negotiator;
+  void assertEventLoopAndChannelType() {
+    boolean bothProvided = channelFactory != DEFAULT_CHANNEL_FACTORY
+        && eventLoopGroupPool != DEFAULT_EVENT_LOOP_GROUP_POOL;
+    boolean nonProvided = channelFactory == DEFAULT_CHANNEL_FACTORY
+        && eventLoopGroupPool == DEFAULT_EVENT_LOOP_GROUP_POOL;
+    checkState(
+        bothProvided || nonProvided,
+        "Both EventLoopGroup and ChannelType should be provided or neither should be");
+  }
+
+  int getDefaultPort() {
+    return protocolNegotiatorFactory.getDefaultPort();
   }
 
-  @CheckReturnValue
-  private static ProtocolNegotiator createProtocolNegotiatorByType(
-      String authority,
+  @VisibleForTesting
+  static ProtocolNegotiator createProtocolNegotiatorByType(
       NegotiationType negotiationType,
-      SslContext sslContext) {
+      SslContext sslContext,
+      ObjectPool<? extends Executor> executorPool) {
     switch (negotiationType) {
       case PLAINTEXT:
         return ProtocolNegotiators.plaintext();
       case PLAINTEXT_UPGRADE:
         return ProtocolNegotiators.plaintextUpgrade();
       case TLS:
-        if (sslContext == null) {
-          try {
-            sslContext = GrpcSslContexts.forClient().build();
-          } catch (SSLException ex) {
-            throw new RuntimeException(ex);
-          }
-        }
-        return ProtocolNegotiators.tls(sslContext, authority);
+        return ProtocolNegotiators.tls(sslContext, executorPool, Optional.absent(), null, null);
       default:
         throw new IllegalArgumentException("Unsupported negotiationType: " + negotiationType);
     }
   }
 
-  @CheckReturnValue
-  interface OverrideAuthorityChecker {
-    String checkAuthority(String authority);
+  @CanIgnoreReturnValue
+  NettyChannelBuilder disableCheckAuthority() {
+    this.managedChannelImplBuilder.disableCheckAuthority();
+    return this;
   }
 
-  @Override
-  @CheckReturnValue
-  protected String checkAuthority(String authority) {
-    if (authorityChecker != null) {
-      return authorityChecker.checkAuthority(authority);
-    }
-    return super.checkAuthority(authority);
+  @CanIgnoreReturnValue
+  NettyChannelBuilder enableCheckAuthority() {
+    this.managedChannelImplBuilder.enableCheckAuthority();
+    return this;
+  }
+
+  void protocolNegotiatorFactory(ProtocolNegotiator.ClientFactory protocolNegotiatorFactory) {
+    checkState(!freezeProtocolNegotiatorFactory,
+               "Cannot change security when using ChannelCredentials");
+    this.protocolNegotiatorFactory
+        = checkNotNull(protocolNegotiatorFactory, "protocolNegotiatorFactory");
+  }
+
+  void setTracingEnabled(boolean value) {
+    this.managedChannelImplBuilder.setTracingEnabled(value);
+  }
+
+  void setStatsEnabled(boolean value) {
+    this.managedChannelImplBuilder.setStatsEnabled(value);
   }
 
-  void setDynamicParamsFactory(TransportCreationParamsFilterFactory factory) {
-    this.dynamicParamsFactory = checkNotNull(factory, "factory");
+  void setStatsRecordStartedRpcs(boolean value) {
+    this.managedChannelImplBuilder.setStatsRecordStartedRpcs(value);
   }
 
-  interface TransportCreationParamsFilterFactory {
-    @CheckReturnValue
-    TransportCreationParamsFilter create(
-        SocketAddress targetServerAddress, String authority, @Nullable String userAgent);
+  void setStatsRecordFinishedRpcs(boolean value) {
+    this.managedChannelImplBuilder.setStatsRecordFinishedRpcs(value);
   }
 
-  @CheckReturnValue
-  interface TransportCreationParamsFilter {
-    SocketAddress getTargetServerAddress();
+  void setStatsRecordRealTimeMetrics(boolean value) {
+    this.managedChannelImplBuilder.setStatsRecordRealTimeMetrics(value);
+  }
 
-    String getAuthority();
+  void setStatsRecordRetryMetrics(boolean value) {
+    this.managedChannelImplBuilder.setStatsRecordRetryMetrics(value);
+  }
 
-    @Nullable String getUserAgent();
+  @CanIgnoreReturnValue
+  @VisibleForTesting
+  NettyChannelBuilder setTransportTracerFactory(TransportTracer.Factory transportTracerFactory) {
+    this.transportTracerFactory = transportTracerFactory;
+    return this;
+  }
+
+  static Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+    return Collections.singleton(InetSocketAddress.class);
+  }
+
+  private final class DefaultProtocolNegotiator implements ProtocolNegotiator.ClientFactory {
+    private NegotiationType negotiationType = NegotiationType.TLS;
+    private SslContext sslContext;
+
+    @Override
+    public ProtocolNegotiator newNegotiator() {
+      SslContext localSslContext = sslContext;
+      if (negotiationType == NegotiationType.TLS && localSslContext == null) {
+        try {
+          localSslContext = GrpcSslContexts.forClient().build();
+        } catch (SSLException ex) {
+          throw new RuntimeException(ex);
+        }
+      }
+      return createProtocolNegotiatorByType(negotiationType, localSslContext,
+          managedChannelImplBuilder.getOffloadExecutorPool());
+    }
 
-    ProtocolNegotiator getProtocolNegotiator();
+    @Override
+    public int getDefaultPort() {
+      switch (negotiationType) {
+        case PLAINTEXT:
+        case PLAINTEXT_UPGRADE:
+          return GrpcUtil.DEFAULT_PORT_PLAINTEXT;
+        case TLS:
+          return GrpcUtil.DEFAULT_PORT_SSL;
+        default:
+          throw new AssertionError(negotiationType + " not handled");
+      }
+    }
   }
 
   /**
    * Creates Netty transports. Exposed for internal use, as it should be private.
    */
-  @CheckReturnValue
   private static final class NettyTransportFactory implements ClientTransportFactory {
-    private final TransportCreationParamsFilterFactory transportCreationParamsFilterFactory;
-    private final Class<? extends Channel> channelType;
+    private final ProtocolNegotiator protocolNegotiator;
+    private final ChannelFactory<? extends Channel> channelFactory;
     private final Map<ChannelOption<?>, ?> channelOptions;
-    private final NegotiationType negotiationType;
-    private final SslContext sslContext;
+    private final ObjectPool<? extends EventLoopGroup> groupPool;
     private final EventLoopGroup group;
-    private final boolean usingSharedGroup;
+    private final boolean autoFlowControl;
     private final int flowControlWindow;
     private final int maxMessageSize;
     private final int maxHeaderListSize;
-    private final boolean enableKeepAlive;
-    private final long keepAliveDelayNanos;
+    private final int softLimitHeaderListSize;
+    private final long keepAliveTimeNanos;
+    private final AtomicBackoff keepAliveBackoff;
     private final long keepAliveTimeoutNanos;
+    private final boolean keepAliveWithoutCalls;
+    private final TransportTracer.Factory transportTracerFactory;
+    private final LocalSocketPicker localSocketPicker;
+    private final boolean useGetForSafeMethods;
 
     private boolean closed;
-
-    NettyTransportFactory(TransportCreationParamsFilterFactory transportCreationParamsFilterFactory,
-        Class<? extends Channel> channelType, Map<ChannelOption<?>, ?> channelOptions,
-        NegotiationType negotiationType, SslContext sslContext, EventLoopGroup group,
-        int flowControlWindow, int maxMessageSize, int maxHeaderListSize, boolean enableKeepAlive,
-        long keepAliveDelayNanos, long keepAliveTimeoutNanos) {
-      this.channelType = channelType;
-      this.negotiationType = negotiationType;
+    private final Class<? extends SocketAddress> transportSocketType;
+
+    NettyTransportFactory(
+        ProtocolNegotiator protocolNegotiator,
+        ChannelFactory<? extends Channel> channelFactory,
+        Map<ChannelOption<?>, ?> channelOptions,
+        ObjectPool<? extends EventLoopGroup> groupPool,
+        boolean autoFlowControl,
+        int flowControlWindow,
+        int maxMessageSize,
+        int maxHeaderListSize,
+        int softLimitHeaderListSize,
+        long keepAliveTimeNanos,
+        long keepAliveTimeoutNanos,
+        boolean keepAliveWithoutCalls,
+        TransportTracer.Factory transportTracerFactory,
+        LocalSocketPicker localSocketPicker,
+        boolean useGetForSafeMethods,
+        Class<? extends SocketAddress> transportSocketType) {
+      this.protocolNegotiator = checkNotNull(protocolNegotiator, "protocolNegotiator");
+      this.channelFactory = channelFactory;
       this.channelOptions = new HashMap<ChannelOption<?>, Object>(channelOptions);
-      this.sslContext = sslContext;
-
-      if (transportCreationParamsFilterFactory == null) {
-        transportCreationParamsFilterFactory = new TransportCreationParamsFilterFactory() {
-          @Override
-          public TransportCreationParamsFilter create(
-              SocketAddress targetServerAddress, String authority, String userAgent) {
-            return new DynamicNettyTransportParams(targetServerAddress, authority, userAgent);
-          }
-        };
-      }
-      this.transportCreationParamsFilterFactory = transportCreationParamsFilterFactory;
-
+      this.groupPool = groupPool;
+      this.group = groupPool.getObject();
+      this.autoFlowControl = autoFlowControl;
       this.flowControlWindow = flowControlWindow;
       this.maxMessageSize = maxMessageSize;
       this.maxHeaderListSize = maxHeaderListSize;
-      this.enableKeepAlive = enableKeepAlive;
-      this.keepAliveDelayNanos = keepAliveDelayNanos;
+      this.softLimitHeaderListSize = softLimitHeaderListSize;
+      this.keepAliveTimeNanos = keepAliveTimeNanos;
+      this.keepAliveBackoff = new AtomicBackoff("keepalive time nanos", keepAliveTimeNanos);
       this.keepAliveTimeoutNanos = keepAliveTimeoutNanos;
-      usingSharedGroup = group == null;
-      if (usingSharedGroup) {
-        // The group was unspecified, using the shared group.
-        this.group = SharedResourceHolder.get(Utils.DEFAULT_WORKER_EVENT_LOOP_GROUP);
-      } else {
-        this.group = group;
-      }
+      this.keepAliveWithoutCalls = keepAliveWithoutCalls;
+      this.transportTracerFactory = transportTracerFactory;
+      this.localSocketPicker =
+          localSocketPicker != null ? localSocketPicker : new LocalSocketPicker();
+      this.useGetForSafeMethods = useGetForSafeMethods;
+      this.transportSocketType = transportSocketType;
     }
 
     @Override
     public ConnectionClientTransport newClientTransport(
-        SocketAddress serverAddress, String authority, @Nullable String userAgent) {
+        SocketAddress serverAddress, ClientTransportOptions options, ChannelLogger channelLogger) {
       checkState(!closed, "The transport factory is closed.");
 
-      TransportCreationParamsFilter dparams =
-          transportCreationParamsFilterFactory.create(serverAddress, authority, userAgent);
-
-      NettyClientTransport transport = new NettyClientTransport(
-          dparams.getTargetServerAddress(), channelType, channelOptions, group,
-          dparams.getProtocolNegotiator(), flowControlWindow,
-          maxMessageSize, maxHeaderListSize, dparams.getAuthority(), dparams.getUserAgent());
-      if (enableKeepAlive) {
-        transport.enableKeepAlive(true, keepAliveDelayNanos, keepAliveTimeoutNanos);
+      ProtocolNegotiator localNegotiator = protocolNegotiator;
+      HttpConnectProxiedSocketAddress proxiedAddr = options.getHttpConnectProxiedSocketAddress();
+      if (proxiedAddr != null) {
+        serverAddress = proxiedAddr.getTargetAddress();
+        localNegotiator = ProtocolNegotiators.httpProxy(
+            proxiedAddr.getProxyAddress(),
+            proxiedAddr.getHeaders(),
+            proxiedAddr.getUsername(),
+            proxiedAddr.getPassword(),
+            protocolNegotiator);
       }
+
+      final AtomicBackoff.State keepAliveTimeNanosState = keepAliveBackoff.getState();
+      Runnable tooManyPingsRunnable = new Runnable() {
+        @Override
+        public void run() {
+          keepAliveTimeNanosState.backoff();
+        }
+      };
+
+      // TODO(carl-mastrangelo): Pass channelLogger in.
+      NettyClientTransport transport =
+          new NettyClientTransport(
+              serverAddress,
+              channelFactory,
+              channelOptions,
+              group,
+              localNegotiator,
+              autoFlowControl,
+              flowControlWindow,
+              maxMessageSize,
+              maxHeaderListSize,
+              softLimitHeaderListSize,
+              keepAliveTimeNanosState.get(),
+              keepAliveTimeoutNanos,
+              keepAliveWithoutCalls,
+              options.getAuthority(),
+              options.getUserAgent(),
+              tooManyPingsRunnable,
+              transportTracerFactory.create(),
+              options.getEagAttributes(),
+              localSocketPicker,
+              channelLogger,
+              useGetForSafeMethods,
+              Ticker.systemTicker());
       return transport;
     }
 
+    @Override
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return group;
+    }
+
+    @Override
+    public SwapChannelCredentialsResult swapChannelCredentials(ChannelCredentials channelCreds) {
+      checkNotNull(channelCreds, "channelCreds");
+      FromChannelCredentialsResult result = ProtocolNegotiators.from(channelCreds);
+      if (result.error != null) {
+        return null;
+      }
+      ClientTransportFactory factory =
+          new NettyTransportFactory(
+              result.negotiator.newNegotiator(),
+              channelFactory,
+              channelOptions,
+              groupPool,
+              autoFlowControl,
+              flowControlWindow,
+              maxMessageSize,
+              maxHeaderListSize,
+              softLimitHeaderListSize,
+              keepAliveTimeNanos,
+              keepAliveTimeoutNanos,
+              keepAliveWithoutCalls,
+              transportTracerFactory,
+              localSocketPicker,
+              useGetForSafeMethods,
+              transportSocketType);
+      return new SwapChannelCredentialsResult(factory, result.callCredentials);
+    }
+
     @Override
     public void close() {
       if (closed) {
@@ -460,44 +900,14 @@ public void close() {
       }
       closed = true;
 
-      if (usingSharedGroup) {
-        SharedResourceHolder.release(Utils.DEFAULT_WORKER_EVENT_LOOP_GROUP, group);
-      }
+      protocolNegotiator.close();
+      groupPool.returnObject(group);
     }
 
-    @CheckReturnValue
-    private final class DynamicNettyTransportParams implements TransportCreationParamsFilter {
-
-      private final SocketAddress targetServerAddress;
-      private final String authority;
-      @Nullable private final String userAgent;
-
-      private DynamicNettyTransportParams(
-          SocketAddress targetServerAddress, String authority, String userAgent) {
-        this.targetServerAddress = targetServerAddress;
-        this.authority = authority;
-        this.userAgent = userAgent;
-      }
-
-      @Override
-      public SocketAddress getTargetServerAddress() {
-        return targetServerAddress;
-      }
-
-      @Override
-      public String getAuthority() {
-        return authority;
-      }
-
-      @Override
-      public String getUserAgent() {
-        return userAgent;
-      }
-
-      @Override
-      public ProtocolNegotiator getProtocolNegotiator() {
-        return createProtocolNegotiator(authority, negotiationType, sslContext);
-      }
+    @Override
+    public Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+      return transportSocketType == null ? null
+          : Collections.singleton(transportSocketType);
     }
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NettyChannelCredentials.java b/netty/src/main/java/io/grpc/netty/NettyChannelCredentials.java
new file mode 100644
index 00000000000..d71ca1dc018
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/NettyChannelCredentials.java
@@ -0,0 +1,42 @@
+/*
+ * 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.netty;
+
+import com.google.common.base.Preconditions;
+import io.grpc.ChannelCredentials;
+
+/** A credential with full control over the security handshake. */
+final class NettyChannelCredentials extends ChannelCredentials {
+  public static ChannelCredentials create(ProtocolNegotiator.ClientFactory negotiator) {
+    return new NettyChannelCredentials(negotiator);
+  }
+
+  private final ProtocolNegotiator.ClientFactory negotiator;
+
+  private NettyChannelCredentials(ProtocolNegotiator.ClientFactory negotiator) {
+    this.negotiator = Preconditions.checkNotNull(negotiator, "negotiator");
+  }
+
+  public ProtocolNegotiator.ClientFactory getNegotiator() {
+    return negotiator;
+  }
+
+  @Override
+  public ChannelCredentials withoutBearerTokens() {
+    return this;
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/NettyChannelProvider.java b/netty/src/main/java/io/grpc/netty/NettyChannelProvider.java
index beb14c8f6a3..1b22a95a44b 100644
--- a/netty/src/main/java/io/grpc/netty/NettyChannelProvider.java
+++ b/netty/src/main/java/io/grpc/netty/NettyChannelProvider.java
@@ -1,38 +1,26 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import io.grpc.ChannelCredentials;
 import io.grpc.Internal;
 import io.grpc.ManagedChannelProvider;
+import java.net.SocketAddress;
+import java.util.Collection;
 
 /** Provider for {@link NettyChannelBuilder} instances. */
 @Internal
@@ -56,4 +44,19 @@ public NettyChannelBuilder builderForAddress(String name, int port) {
   public NettyChannelBuilder builderForTarget(String target) {
     return NettyChannelBuilder.forTarget(target);
   }
+
+  @Override
+  public NewChannelBuilderResult newChannelBuilder(String target, ChannelCredentials creds) {
+    ProtocolNegotiators.FromChannelCredentialsResult result = ProtocolNegotiators.from(creds);
+    if (result.error != null) {
+      return NewChannelBuilderResult.error(result.error);
+    }
+    return NewChannelBuilderResult.channelBuilder(
+        new NettyChannelBuilder(target, creds, result.callCredentials, result.negotiator));
+  }
+
+  @Override
+  protected Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+    return NettyChannelBuilder.getSupportedSocketAddressTypes();
+  }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NettyClientHandler.java b/netty/src/main/java/io/grpc/netty/NettyClientHandler.java
index 0028f0b2ad7..8ebf89842ad 100644
--- a/netty/src/main/java/io/grpc/netty/NettyClientHandler.java
+++ b/netty/src/main/java/io/grpc/netty/NettyClientHandler.java
@@ -1,52 +1,49 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
 import static io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.DEFAULT_WINDOW_UPDATE_RATIO;
 import static io.netty.util.CharsetUtil.UTF_8;
+import static io.netty.util.internal.ObjectUtil.checkNotNull;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
 import com.google.common.base.Ticker;
 import io.grpc.Attributes;
+import io.grpc.ChannelLogger;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalStatus;
 import io.grpc.Metadata;
 import io.grpc.Status;
 import io.grpc.StatusException;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
 import io.grpc.internal.ClientTransport.PingCallback;
+import io.grpc.internal.DisconnectError;
+import io.grpc.internal.GoAwayDisconnectError;
+import io.grpc.internal.GrpcAttributes;
 import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.Http2Ping;
+import io.grpc.internal.InUseStateAggregator;
 import io.grpc.internal.KeepAliveManager;
-import io.grpc.netty.GrpcHttp2HeadersDecoder.GrpcHttp2ClientHeadersDecoder;
+import io.grpc.internal.SimpleDisconnectError;
+import io.grpc.internal.TransportTracer;
+import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2ClientHeadersDecoder;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufUtil;
 import io.netty.buffer.Unpooled;
@@ -55,15 +52,20 @@
 import io.netty.channel.ChannelFutureListener;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelPromise;
+import io.netty.handler.codec.http2.DecoratingHttp2FrameWriter;
 import io.netty.handler.codec.http2.DefaultHttp2Connection;
 import io.netty.handler.codec.http2.DefaultHttp2ConnectionDecoder;
 import io.netty.handler.codec.http2.DefaultHttp2ConnectionEncoder;
 import io.netty.handler.codec.http2.DefaultHttp2FrameReader;
 import io.netty.handler.codec.http2.DefaultHttp2FrameWriter;
+import io.netty.handler.codec.http2.DefaultHttp2HeadersEncoder;
 import io.netty.handler.codec.http2.DefaultHttp2LocalFlowController;
+import io.netty.handler.codec.http2.DefaultHttp2RemoteFlowController;
+import io.netty.handler.codec.http2.Http2CodecUtil;
 import io.netty.handler.codec.http2.Http2Connection;
 import io.netty.handler.codec.http2.Http2ConnectionAdapter;
 import io.netty.handler.codec.http2.Http2ConnectionDecoder;
+import io.netty.handler.codec.http2.Http2ConnectionEncoder;
 import io.netty.handler.codec.http2.Http2Error;
 import io.netty.handler.codec.http2.Http2Exception;
 import io.netty.handler.codec.http2.Http2FrameAdapter;
@@ -72,14 +74,21 @@
 import io.netty.handler.codec.http2.Http2FrameWriter;
 import io.netty.handler.codec.http2.Http2Headers;
 import io.netty.handler.codec.http2.Http2HeadersDecoder;
+import io.netty.handler.codec.http2.Http2HeadersEncoder;
 import io.netty.handler.codec.http2.Http2InboundFrameLogger;
 import io.netty.handler.codec.http2.Http2OutboundFrameLogger;
 import io.netty.handler.codec.http2.Http2Settings;
 import io.netty.handler.codec.http2.Http2Stream;
 import io.netty.handler.codec.http2.Http2StreamVisitor;
 import io.netty.handler.codec.http2.StreamBufferingEncoder;
+import io.netty.handler.codec.http2.UniformStreamByteDistributor;
 import io.netty.handler.logging.LogLevel;
+import io.perfmark.PerfMark;
+import io.perfmark.Tag;
+import io.perfmark.TaskCloseable;
 import java.nio.channels.ClosedChannelException;
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.concurrent.Executor;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -91,6 +100,8 @@
  */
 class NettyClientHandler extends AbstractNettyHandler {
   private static final Logger logger = Logger.getLogger(NettyClientHandler.class.getName());
+  static boolean enablePerRpcAuthorityCheck =
+      GrpcUtil.getFlag("GRPC_ENABLE_PER_RPC_AUTHORITY_CHECK", false);
 
   /**
    * A message that simply passes through the channel without any real processing. It is useful to
@@ -108,42 +119,124 @@ class NettyClientHandler extends AbstractNettyHandler {
   private final Http2Connection.PropertyKey streamKey;
   private final ClientTransportLifecycleManager lifecycleManager;
   private final KeepAliveManager keepAliveManager;
-  private final Ticker ticker;
+  // Returns new unstarted stopwatches
+  private final Supplier<Stopwatch> stopwatchFactory;
+  private final TransportTracer transportTracer;
+  private final Attributes eagAttributes;
+  private final String authority;
+  private final InUseStateAggregator<Http2Stream> inUseState =
+      new InUseStateAggregator<Http2Stream>() {
+        @Override
+        protected void handleInUse() {
+          lifecycleManager.notifyInUse(true);
+        }
+
+        @Override
+        protected void handleNotInUse() {
+          lifecycleManager.notifyInUse(false);
+        }
+      };
+  private final Map<String, Status> peerVerificationResults =
+      new LinkedHashMap<String, Status>() {
+        @Override
+        protected boolean removeEldestEntry(Map.Entry<String, Status> eldest) {
+          return size() > 100;
+        }
+      };
+
   private WriteQueue clientWriteQueue;
   private Http2Ping ping;
-  private Attributes attributes = Attributes.EMPTY;
-
-  static NettyClientHandler newHandler(ClientTransportLifecycleManager lifecycleManager,
-      @Nullable KeepAliveManager keepAliveManager, int flowControlWindow, int maxHeaderListSize,
+  private Attributes attributes;
+  private InternalChannelz.Security securityInfo;
+  private Status abruptGoAwayStatus;
+  private Status channelInactiveReason;
+
+  static NettyClientHandler newHandler(
+      ClientTransportLifecycleManager lifecycleManager,
+      @Nullable KeepAliveManager keepAliveManager,
+      boolean autoFlowControl,
+      int flowControlWindow,
+      int maxHeaderListSize,
+      int softLimitHeaderListSize,
+      Supplier<Stopwatch> stopwatchFactory,
+      Runnable tooManyPingsRunnable,
+      TransportTracer transportTracer,
+      Attributes eagAttributes,
+      String authority,
+      ChannelLogger negotiationLogger,
       Ticker ticker) {
     Preconditions.checkArgument(maxHeaderListSize > 0, "maxHeaderListSize must be positive");
     Http2HeadersDecoder headersDecoder = new GrpcHttp2ClientHeadersDecoder(maxHeaderListSize);
     Http2FrameReader frameReader = new DefaultHttp2FrameReader(headersDecoder);
-    Http2FrameWriter frameWriter = new DefaultHttp2FrameWriter();
+    Http2HeadersEncoder encoder = new DefaultHttp2HeadersEncoder(
+        Http2HeadersEncoder.NEVER_SENSITIVE, false, 16, Integer.MAX_VALUE);
+    Http2FrameWriter frameWriter = new DefaultHttp2FrameWriter(encoder);
     Http2Connection connection = new DefaultHttp2Connection(false);
-
-    return newHandler(connection, frameReader, frameWriter, lifecycleManager, keepAliveManager,
-        flowControlWindow, maxHeaderListSize, ticker);
+    UniformStreamByteDistributor dist = new UniformStreamByteDistributor(connection);
+    dist.minAllocationChunk(MIN_ALLOCATED_CHUNK); // Increased for benchmarks performance.
+    DefaultHttp2RemoteFlowController controller =
+        new DefaultHttp2RemoteFlowController(connection, dist);
+    connection.remote().flowController(controller);
+
+    return newHandler(
+        connection,
+        frameReader,
+        frameWriter,
+        lifecycleManager,
+        keepAliveManager,
+        autoFlowControl,
+        flowControlWindow,
+        maxHeaderListSize,
+        softLimitHeaderListSize,
+        stopwatchFactory,
+        tooManyPingsRunnable,
+        transportTracer,
+        eagAttributes,
+        authority,
+        negotiationLogger,
+        ticker);
   }
 
   @VisibleForTesting
-  static NettyClientHandler newHandler(Http2Connection connection, Http2FrameReader frameReader,
-      Http2FrameWriter frameWriter, ClientTransportLifecycleManager lifecycleManager,
-      KeepAliveManager keepAliveManager, int flowControlWindow, int maxHeaderListSize,
+  static NettyClientHandler newHandler(
+      final Http2Connection connection,
+      Http2FrameReader frameReader,
+      Http2FrameWriter frameWriter,
+      ClientTransportLifecycleManager lifecycleManager,
+      KeepAliveManager keepAliveManager,
+      boolean autoFlowControl,
+      int flowControlWindow,
+      int maxHeaderListSize,
+      int softLimitHeaderListSize,
+      Supplier<Stopwatch> stopwatchFactory,
+      Runnable tooManyPingsRunnable,
+      TransportTracer transportTracer,
+      Attributes eagAttributes,
+      String authority,
+      ChannelLogger negotiationLogger,
       Ticker ticker) {
     Preconditions.checkNotNull(connection, "connection");
     Preconditions.checkNotNull(frameReader, "frameReader");
     Preconditions.checkNotNull(lifecycleManager, "lifecycleManager");
     Preconditions.checkArgument(flowControlWindow > 0, "flowControlWindow must be positive");
     Preconditions.checkArgument(maxHeaderListSize > 0, "maxHeaderListSize must be positive");
-    Preconditions.checkNotNull(ticker, "ticker");
+    Preconditions.checkArgument(softLimitHeaderListSize > 0,
+        "softLimitHeaderListSize must be positive");
+    Preconditions.checkNotNull(stopwatchFactory, "stopwatchFactory");
+    Preconditions.checkNotNull(tooManyPingsRunnable, "tooManyPingsRunnable");
+    Preconditions.checkNotNull(eagAttributes, "eagAttributes");
+    Preconditions.checkNotNull(authority, "authority");
 
     Http2FrameLogger frameLogger = new Http2FrameLogger(LogLevel.DEBUG, NettyClientHandler.class);
     frameReader = new Http2InboundFrameLogger(frameReader, frameLogger);
     frameWriter = new Http2OutboundFrameLogger(frameWriter, frameLogger);
 
-    StreamBufferingEncoder encoder = new StreamBufferingEncoder(
-        new DefaultHttp2ConnectionEncoder(connection, frameWriter));
+    PingCountingFrameWriter pingCounter;
+    frameWriter = pingCounter = new PingCountingFrameWriter(frameWriter);
+
+    StreamBufferingEncoder encoder =
+        new StreamBufferingEncoder(
+            new DefaultHttp2ConnectionEncoder(connection, frameWriter));
 
     // Create the local flow controller configured to auto-refill the connection window.
     connection.local().flowController(
@@ -152,23 +245,69 @@ static NettyClientHandler newHandler(Http2Connection connection, Http2FrameReade
     Http2ConnectionDecoder decoder = new DefaultHttp2ConnectionDecoder(connection, encoder,
         frameReader);
 
+    transportTracer.setFlowControlWindowReader(new Utils.FlowControlReader(connection));
+
     Http2Settings settings = new Http2Settings();
     settings.pushEnabled(false);
     settings.initialWindowSize(flowControlWindow);
     settings.maxConcurrentStreams(0);
     settings.maxHeaderListSize(maxHeaderListSize);
 
-    return new NettyClientHandler(decoder, encoder, settings, lifecycleManager, keepAliveManager,
-        ticker);
+    return new NettyClientHandler(
+        decoder,
+        encoder,
+        settings,
+        negotiationLogger,
+        lifecycleManager,
+        keepAliveManager,
+        stopwatchFactory,
+        tooManyPingsRunnable,
+        transportTracer,
+        eagAttributes,
+        authority,
+        autoFlowControl,
+        pingCounter,
+        ticker,
+        maxHeaderListSize,
+        softLimitHeaderListSize);
   }
 
-  private NettyClientHandler(Http2ConnectionDecoder decoder, StreamBufferingEncoder encoder,
-      Http2Settings settings, ClientTransportLifecycleManager lifecycleManager,
-      KeepAliveManager keepAliveManager, Ticker ticker) {
-    super(decoder, encoder, settings);
+  private NettyClientHandler(
+      Http2ConnectionDecoder decoder,
+      Http2ConnectionEncoder encoder,
+      Http2Settings settings,
+      ChannelLogger negotiationLogger,
+      ClientTransportLifecycleManager lifecycleManager,
+      KeepAliveManager keepAliveManager,
+      Supplier<Stopwatch> stopwatchFactory,
+      final Runnable tooManyPingsRunnable,
+      TransportTracer transportTracer,
+      Attributes eagAttributes,
+      String authority,
+      boolean autoFlowControl,
+      PingLimiter pingLimiter,
+      Ticker ticker,
+      int maxHeaderListSize,
+      int softLimitHeaderListSize) {
+    super(
+        /* channelUnused= */ null,
+        decoder,
+        encoder,
+        settings,
+        negotiationLogger,
+        autoFlowControl,
+        pingLimiter,
+        ticker,
+        maxHeaderListSize,
+        softLimitHeaderListSize);
     this.lifecycleManager = lifecycleManager;
     this.keepAliveManager = keepAliveManager;
-    this.ticker = ticker;
+    this.stopwatchFactory = stopwatchFactory;
+    this.transportTracer = Preconditions.checkNotNull(transportTracer);
+    this.eagAttributes = eagAttributes;
+    this.authority = authority;
+    this.attributes = Attributes.newBuilder()
+        .set(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS, eagAttributes).build();
 
     // Set the frame listener on the decoder.
     decoder().frameListener(new FrameListener());
@@ -179,33 +318,34 @@ private NettyClientHandler(Http2ConnectionDecoder decoder, StreamBufferingEncode
     connection.addListener(new Http2ConnectionAdapter() {
       @Override
       public void onGoAwayReceived(int lastStreamId, long errorCode, ByteBuf debugData) {
-        goingAway(statusFromGoAway(errorCode, ByteBufUtil.getBytes(debugData)));
-      }
-
-      @Override
-      public void onStreamAdded(Http2Stream stream) {
-        NettyClientHandler.this.lifecycleManager.notifyInUse(true);
-      }
-
-      @Override
-      public void onStreamRemoved(Http2Stream stream) {
-        if (connection().numActiveStreams() == 0) {
-          NettyClientHandler.this.lifecycleManager.notifyInUse(false);
+        byte[] debugDataBytes = ByteBufUtil.getBytes(debugData);
+        goingAway(errorCode, debugDataBytes);
+        if (errorCode == Http2Error.ENHANCE_YOUR_CALM.code()) {
+          String data = new String(debugDataBytes, UTF_8);
+          logger.log(
+              Level.WARNING, "Received GOAWAY with ENHANCE_YOUR_CALM. Debug data: {0}", data);
+          if ("too_many_pings".equals(data)) {
+            tooManyPingsRunnable.run();
+          }
         }
       }
 
       @Override
       public void onStreamActive(Http2Stream stream) {
-        if (NettyClientHandler.this.keepAliveManager != null
-            && connection().numActiveStreams() == 1) {
+        if (connection().numActiveStreams() == 1
+            && NettyClientHandler.this.keepAliveManager != null) {
           NettyClientHandler.this.keepAliveManager.onTransportActive();
         }
       }
 
       @Override
       public void onStreamClosed(Http2Stream stream) {
-        if (NettyClientHandler.this.keepAliveManager != null
-            && connection().numActiveStreams() == 0) {
+        // Although streams with CALL_OPTIONS_RPC_OWNED_BY_BALANCER are not marked as "in-use" in
+        // the first place, we don't propagate that option here, and it's safe to reset the in-use
+        // state for them, which will be a cheap no-op.
+        inUseState.updateObjectInUse(stream, false);
+        if (connection().numActiveStreams() == 0
+            && NettyClientHandler.this.keepAliveManager != null) {
           NettyClientHandler.this.keepAliveManager.onTransportIdle();
         }
       }
@@ -253,6 +393,10 @@ WriteQueue getWriteQueue() {
     return clientWriteQueue;
   }
 
+  ClientTransportLifecycleManager getLifecycleManager() {
+    return lifecycleManager;
+  }
+
   /**
    * Returns the given processed bytes back to inbound flow control.
    */
@@ -265,8 +409,35 @@ void returnProcessedBytes(Http2Stream stream, int bytes) {
   }
 
   private void onHeadersRead(int streamId, Http2Headers headers, boolean endStream) {
-    NettyClientStream.TransportState stream = clientStream(requireHttp2Stream(streamId));
-    stream.transportHeadersReceived(headers, endStream);
+    // Stream 1 is reserved for the Upgrade response, so we should ignore its headers here:
+    if (streamId != Http2CodecUtil.HTTP_UPGRADE_STREAM_ID) {
+      NettyClientStream.TransportState stream = clientStream(requireHttp2Stream(streamId));
+      PerfMark.event("NettyClientHandler.onHeadersRead", stream.tag());
+      // check metadata size vs soft limit
+      int h2HeadersSize = Utils.getH2HeadersSize(headers);
+      boolean shouldFail =
+          Utils.shouldRejectOnMetadataSizeSoftLimitExceeded(
+              h2HeadersSize, softLimitHeaderListSize, maxHeaderListSize);
+      if (shouldFail && endStream) {
+        stream.transportReportStatus(Status.RESOURCE_EXHAUSTED
+            .withDescription(
+                String.format(
+                    "Server Status + Trailers of size %d exceeded Metadata size soft limit: %d",
+                    h2HeadersSize,
+                    softLimitHeaderListSize)), true, new Metadata());
+        return;
+      } else if (shouldFail) {
+        stream.transportReportStatus(Status.RESOURCE_EXHAUSTED
+            .withDescription(
+                String.format(
+                    "Server Headers of size %d exceeded Metadata size soft limit: %d",
+                    h2HeadersSize,
+                    softLimitHeaderListSize)), true, new Metadata());
+        return;
+      }
+      stream.transportHeadersReceived(headers, endStream);
+    }
+
     if (keepAliveManager != null) {
       keepAliveManager.onDataReceived();
     }
@@ -278,22 +449,27 @@ private void onHeadersRead(int streamId, Http2Headers headers, boolean endStream
   private void onDataRead(int streamId, ByteBuf data, int padding, boolean endOfStream) {
     flowControlPing().onDataRead(data.readableBytes(), padding);
     NettyClientStream.TransportState stream = clientStream(requireHttp2Stream(streamId));
+    PerfMark.event("NettyClientHandler.onDataRead", stream.tag());
     stream.transportDataReceived(data, endOfStream);
     if (keepAliveManager != null) {
       keepAliveManager.onDataReceived();
     }
   }
 
-
   /**
    * Handler for an inbound HTTP/2 RST_STREAM frame, terminating a stream.
    */
   private void onRstStreamRead(int streamId, long errorCode) {
     NettyClientStream.TransportState stream = clientStream(connection().stream(streamId));
     if (stream != null) {
-      Status status = GrpcUtil.Http2Error.statusForCode((int) errorCode)
-          .augmentDescription("Received Rst Stream");
-      stream.transportReportStatus(status, false /*stop delivery*/, new Metadata());
+      PerfMark.event("NettyClientHandler.onRstStreamRead", stream.tag());
+      Status status = statusFromH2Error(null, "RST_STREAM closed stream", errorCode, null);
+      stream.transportReportStatus(
+          status,
+          errorCode == Http2Error.REFUSED_STREAM.code()
+              ? RpcProgress.REFUSED : RpcProgress.PROCESSED,
+          false /*stop delivery*/,
+          new Metadata());
       if (keepAliveManager != null) {
         keepAliveManager.onDataReceived();
       }
@@ -303,8 +479,11 @@ private void onRstStreamRead(int streamId, long errorCode) {
   @Override
   public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
     logger.fine("Network channel being closed by the application.");
-    lifecycleManager.notifyShutdown(
-        Status.UNAVAILABLE.withDescription("Transport closed for unknown reason"));
+    if (ctx.channel().isActive()) { // Ignore notification that the socket was closed
+      lifecycleManager.notifyShutdown(
+          Status.UNAVAILABLE.withDescription("Transport closed for unknown reason"),
+          SimpleDisconnectError.UNKNOWN);
+    }
     super.close(ctx, promise);
   }
 
@@ -315,47 +494,84 @@ public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exce
   public void channelInactive(ChannelHandlerContext ctx) throws Exception {
     try {
       logger.fine("Network channel is closed");
-      lifecycleManager.notifyShutdown(
-          Status.UNAVAILABLE.withDescription("Network closed for unknown reason"));
-      cancelPing(lifecycleManager.getShutdownThrowable());
-      // Report status to the application layer for any open streams
-      connection().forEachActiveStream(new Http2StreamVisitor() {
-        @Override
-        public boolean visit(Http2Stream stream) throws Http2Exception {
-          NettyClientStream.TransportState clientStream = clientStream(stream);
-          if (clientStream != null) {
-            clientStream.transportReportStatus(
-                lifecycleManager.getShutdownStatus(), false, new Metadata());
+      Status status = Status.UNAVAILABLE.withDescription("Network closed for unknown reason");
+      lifecycleManager.notifyShutdown(status, SimpleDisconnectError.UNKNOWN);
+      final Status streamStatus;
+      if (channelInactiveReason != null) {
+        streamStatus = channelInactiveReason;
+      } else {
+        streamStatus = lifecycleManager.getShutdownStatus();
+      }
+      try {
+        cancelPing(lifecycleManager.getShutdownStatus());
+        // Report status to the application layer for any open streams
+        connection().forEachActiveStream(new Http2StreamVisitor() {
+          @Override
+          public boolean visit(Http2Stream stream) throws Http2Exception {
+            NettyClientStream.TransportState clientStream = clientStream(stream);
+            if (clientStream != null) {
+              clientStream.transportReportStatus(streamStatus, false, new Metadata());
+            }
+            return true;
           }
-          return true;
-        }
-      });
+        });
+      } finally {
+        lifecycleManager.notifyTerminated(status, SimpleDisconnectError.UNKNOWN);
+      }
     } finally {
       // Close any open streams
       super.channelInactive(ctx);
       if (keepAliveManager != null) {
-        keepAliveManager.onTransportShutdown();
+        keepAliveManager.onTransportTermination();
       }
     }
   }
 
   @Override
-  public void handleProtocolNegotiationCompleted(Attributes attributes) {
-    this.attributes = attributes;
-    super.handleProtocolNegotiationCompleted(attributes);
+  public void handleProtocolNegotiationCompleted(
+      Attributes attributes, InternalChannelz.Security securityInfo) {
+    this.attributes = this.attributes.toBuilder().setAll(attributes).build();
+    this.securityInfo = securityInfo;
+    super.handleProtocolNegotiationCompleted(attributes, securityInfo);
+    writeBufferingAndRemove(ctx().channel());
+  }
+
+  static void writeBufferingAndRemove(Channel channel) {
+    checkNotNull(channel, "channel");
+    ChannelHandlerContext handlerCtx =
+        channel.pipeline().context(WriteBufferingAndExceptionHandler.class);
+    if (handlerCtx == null) {
+      return;
+    }
+    ((WriteBufferingAndExceptionHandler) handlerCtx.handler()).writeBufferedAndRemove(handlerCtx);
+  }
+
+  @Override
+  public Attributes getEagAttributes() {
+    return eagAttributes;
+  }
+
+  @Override
+  public String getAuthority() {
+    return authority;
+  }
+
+  InternalChannelz.Security getSecurityInfo() {
+    return securityInfo;
   }
 
   @Override
-  protected void onConnectionError(ChannelHandlerContext ctx, Throwable cause,
+  protected void onConnectionError(ChannelHandlerContext ctx,  boolean outbound, Throwable cause,
       Http2Exception http2Ex) {
     logger.log(Level.FINE, "Caught a connection error", cause);
-    lifecycleManager.notifyShutdown(Utils.statusFromThrowable(cause));
+    lifecycleManager.notifyShutdown(Utils.statusFromThrowable(cause),
+        SimpleDisconnectError.SOCKET_ERROR);
     // Parent class will shut down the Channel
-    super.onConnectionError(ctx, cause, http2Ex);
+    super.onConnectionError(ctx, outbound, cause, http2Ex);
   }
 
   @Override
-  protected void onStreamError(ChannelHandlerContext ctx, Throwable cause,
+  protected void onStreamError(ChannelHandlerContext ctx, boolean outbound, Throwable cause,
       Http2Exception.StreamException http2Ex) {
     // Close the stream with a status that contains the cause.
     NettyClientStream.TransportState stream = clientStream(connection().stream(http2Ex.streamId()));
@@ -366,7 +582,7 @@ protected void onStreamError(ChannelHandlerContext ctx, Throwable cause,
     }
 
     // Delegate to the base class to send a RST_STREAM.
-    super.onStreamError(ctx, cause, http2Ex);
+    super.onStreamError(ctx, outbound, cause, http2Ex);
   }
 
   @Override
@@ -380,19 +596,75 @@ protected boolean isGracefulShutdownComplete() {
    * Attempts to create a new stream from the given command. If there are too many active streams,
    * the creation request is queued.
    */
-  private void createStream(CreateStreamCommand command, final ChannelPromise promise)
+  private void createStream(CreateStreamCommand command, ChannelPromise promise)
           throws Exception {
-    if (lifecycleManager.getShutdownThrowable() != null) {
-      // The connection is going away, just terminate the stream now.
-      promise.setFailure(lifecycleManager.getShutdownThrowable());
+    if (lifecycleManager.getShutdownStatus() != null) {
+      command.stream().setNonExistent();
+      // The connection is going away (it is really the GOAWAY case),
+      // just terminate the stream now.
+      command.stream().transportReportStatus(
+          lifecycleManager.getShutdownStatus(), RpcProgress.MISCARRIED, true, new Metadata());
+      promise.setFailure(InternalStatus.asRuntimeExceptionWithoutStacktrace(
+              lifecycleManager.getShutdownStatus(), null));
       return;
     }
 
+    CharSequence authorityHeader = command.headers().authority();
+    if (authorityHeader == null) {
+      Status authorityVerificationStatus = Status.UNAVAILABLE.withDescription(
+              "Missing authority header");
+      command.stream().setNonExistent();
+      command.stream().transportReportStatus(
+              Status.UNAVAILABLE, RpcProgress.PROCESSED, true, new Metadata());
+      promise.setFailure(InternalStatus.asRuntimeExceptionWithoutStacktrace(
+              authorityVerificationStatus, null));
+      return;
+    }
+    // No need to verify authority for the rpc outgoing header if it is same as the authority
+    // for the transport
+    if (!authority.contentEquals(authorityHeader)) {
+      Status authorityVerificationStatus = peerVerificationResults.get(
+              authorityHeader.toString());
+      if (authorityVerificationStatus == null) {
+        if (attributes.get(GrpcAttributes.ATTR_AUTHORITY_VERIFIER) == null) {
+          authorityVerificationStatus = Status.UNAVAILABLE.withDescription(
+                  "Authority verifier not found to verify authority");
+          command.stream().setNonExistent();
+          command.stream().transportReportStatus(
+                  authorityVerificationStatus, RpcProgress.PROCESSED, true, new Metadata());
+          promise.setFailure(InternalStatus.asRuntimeExceptionWithoutStacktrace(
+                  authorityVerificationStatus, null));
+          return;
+        }
+        authorityVerificationStatus = attributes.get(GrpcAttributes.ATTR_AUTHORITY_VERIFIER)
+                .verifyAuthority(authorityHeader.toString());
+        peerVerificationResults.put(authorityHeader.toString(), authorityVerificationStatus);
+        if (!authorityVerificationStatus.isOk() && !enablePerRpcAuthorityCheck) {
+          logger.log(Level.WARNING, String.format("%s.%s",
+                          authorityVerificationStatus.getDescription(),
+                          enablePerRpcAuthorityCheck
+                                  ? "" : " This will be an error in the future."),
+                  InternalStatus.asRuntimeExceptionWithoutStacktrace(
+                          authorityVerificationStatus, null));
+        }
+      }
+      if (!authorityVerificationStatus.isOk()) {
+        if (enablePerRpcAuthorityCheck) {
+          command.stream().setNonExistent();
+          command.stream().transportReportStatus(
+                  authorityVerificationStatus, RpcProgress.PROCESSED, true, new Metadata());
+          promise.setFailure(InternalStatus.asRuntimeExceptionWithoutStacktrace(
+                  authorityVerificationStatus, null));
+          return;
+        }
+      }
+    }
     // Get the stream ID for the new stream.
-    final int streamId;
+    int streamId;
     try {
       streamId = incrementAndGetNextStreamId();
     } catch (StatusException e) {
+      command.stream().setNonExistent();
       // Stream IDs have been exhausted for this connection. Fail the promise immediately.
       promise.setFailure(e);
 
@@ -400,54 +672,125 @@ private void createStream(CreateStreamCommand command, final ChannelPromise prom
       if (!connection().goAwaySent()) {
         logger.fine("Stream IDs have been exhausted for this connection. "
                 + "Initiating graceful shutdown of the connection.");
-        lifecycleManager.notifyShutdown(e.getStatus());
+        lifecycleManager.notifyShutdown(e.getStatus(), SimpleDisconnectError.UNKNOWN);
         close(ctx(), ctx().newPromise());
       }
       return;
     }
+    if (connection().goAwayReceived()) {
+      Status s = abruptGoAwayStatus;
+      int maxActiveStreams = connection().local().maxActiveStreams();
+      int lastStreamId = connection().local().lastStreamKnownByPeer();
+      if (s == null) {
+        // Should be impossible, but handle pseudo-gracefully
+        s = Status.INTERNAL.withDescription(
+            "Failed due to abrupt GOAWAY, but can't find GOAWAY details");
+      } else if (streamId > lastStreamId) {
+        s = s.augmentDescription(
+            "stream id: " + streamId + ", GOAWAY Last-Stream-ID:" + lastStreamId);
+      } else if (connection().local().numActiveStreams() == maxActiveStreams) {
+        s = s.augmentDescription("At MAX_CONCURRENT_STREAMS limit. limit: " + maxActiveStreams);
+      }
+      if (streamId > lastStreamId || connection().local().numActiveStreams() == maxActiveStreams) {
+        // This should only be reachable during onGoAwayReceived, as otherwise
+        // getShutdownThrowable() != null
+        command.stream().setNonExistent();
+        command.stream().transportReportStatus(s, RpcProgress.MISCARRIED, true, new Metadata());
+        promise.setFailure(s.asRuntimeException());
+        return;
+      }
+    }
 
-    final NettyClientStream.TransportState stream = command.stream();
-    final Http2Headers headers = command.headers();
+    NettyClientStream.TransportState stream = command.stream();
+    Http2Headers headers = command.headers();
     stream.setId(streamId);
 
+    try (TaskCloseable ignore = PerfMark.traceTask("NettyClientHandler.createStream")) {
+      PerfMark.linkIn(command.getLink());
+      PerfMark.attachTag(stream.tag());
+      createStreamTraced(
+          streamId, stream, headers, command.isGet(), command.shouldBeCountedForInUse(), promise);
+    }
+  }
+
+  private void createStreamTraced(
+      final int streamId,
+      final NettyClientStream.TransportState stream,
+      final Http2Headers headers,
+      boolean isGet,
+      final boolean shouldBeCountedForInUse,
+      final ChannelPromise promise) {
     // Create an intermediate promise so that we can intercept the failure reported back to the
     // application.
     ChannelPromise tempPromise = ctx().newPromise();
-    encoder().writeHeaders(ctx(), streamId, headers, 0, false, tempPromise)
-            .addListener(new ChannelFutureListener() {
-              @Override
-              public void operationComplete(ChannelFuture future) throws Exception {
-                if (future.isSuccess()) {
-                  // The http2Stream will be null in case a stream buffered in the encoder
-                  // was canceled via RST_STREAM.
-                  Http2Stream http2Stream = connection().stream(streamId);
-                  if (http2Stream != null) {
-                    stream.getStatsTraceContext().clientHeadersSent();
-                    http2Stream.setProperty(streamKey, stream);
-
-                    // Attach the client stream to the HTTP/2 stream object as user data.
-                    stream.setHttp2Stream(http2Stream);
-                  }
-                  // Otherwise, the stream has been cancelled and Netty is sending a
-                  // RST_STREAM frame which causes it to purge pending writes from the
-                  // flow-controller and delete the http2Stream. The stream listener has already
-                  // been notified of cancellation so there is nothing to do.
-
-                  // Just forward on the success status to the original promise.
-                  promise.setSuccess();
-                } else {
-                  final Throwable cause = future.cause();
-                  if (cause instanceof StreamBufferingEncoder.Http2GoAwayException) {
-                    StreamBufferingEncoder.Http2GoAwayException e =
-                        (StreamBufferingEncoder.Http2GoAwayException) cause;
-                    lifecycleManager.notifyShutdown(statusFromGoAway(e.errorCode(), e.debugData()));
-                    promise.setFailure(lifecycleManager.getShutdownThrowable());
-                  } else {
-                    promise.setFailure(cause);
-                  }
+    encoder().writeHeaders(ctx(), streamId, headers, 0, isGet, tempPromise)
+        .addListener(new ChannelFutureListener() {
+          @Override
+          public void operationComplete(ChannelFuture future) throws Exception {
+            if (future.isSuccess()) {
+              // The http2Stream will be null in case a stream buffered in the encoder
+              // was canceled via RST_STREAM.
+              Http2Stream http2Stream = connection().stream(streamId);
+              if (http2Stream != null) {
+                stream.getStatsTraceContext().clientOutboundHeaders();
+                http2Stream.setProperty(streamKey, stream);
+
+                // This delays the in-use state until the I/O completes, which technically may
+                // be later than we would like.
+                if (shouldBeCountedForInUse) {
+                  inUseState.updateObjectInUse(http2Stream, true);
+                }
+
+                // Attach the client stream to the HTTP/2 stream object as user data.
+                stream.setHttp2Stream(http2Stream);
+                promise.setSuccess();
+              } else {
+                // Otherwise, the stream has been cancelled and Netty is sending a
+                // RST_STREAM frame which causes it to purge pending writes from the
+                // flow-controller and delete the http2Stream. The stream listener has already
+                // been notified of cancellation so there is nothing to do.
+                //
+                // This process has been observed to fail in some circumstances, leaving listeners
+                // unanswered. Ensure that some exception has been delivered consistent with the
+                // implied RST_STREAM result above.
+                Status status = Status.INTERNAL.withDescription("unknown stream for connection");
+                promise.setFailure(status.asRuntimeException());
+              }
+            } else {
+              Throwable cause = future.cause();
+              if (cause instanceof StreamBufferingEncoder.Http2GoAwayException) {
+                StreamBufferingEncoder.Http2GoAwayException e =
+                    (StreamBufferingEncoder.Http2GoAwayException) cause;
+                Status status = statusFromH2Error(
+                    Status.Code.UNAVAILABLE, "GOAWAY closed buffered stream",
+                    e.errorCode(), e.debugData());
+                cause = status.asRuntimeException();
+                stream.transportReportStatus(status, RpcProgress.MISCARRIED, true, new Metadata());
+              } else if (cause instanceof StreamBufferingEncoder.Http2ChannelClosedException) {
+                Status status = lifecycleManager.getShutdownStatus();
+                if (status == null) {
+                  status = Status.UNAVAILABLE.withCause(cause)
+                      .withDescription("Connection closed while stream is buffered");
                 }
+                stream.transportReportStatus(status, RpcProgress.MISCARRIED, true, new Metadata());
               }
-            });
+              promise.setFailure(cause);
+            }
+          }
+        });
+    // When the HEADERS are not buffered because of MAX_CONCURRENT_STREAMS in
+    // StreamBufferingEncoder, the stream is created immediately even if the bytes of the HEADERS
+    // are delayed because the OS may have too much buffered and isn't accepting the write. The
+    // write promise is also delayed until flush(). However, we need to associate the netty stream
+    // with the transport state so that goingAway() and forcefulClose() and able to notify the
+    // stream of failures.
+    //
+    // This leaves a hole when MAX_CONCURRENT_STREAMS is reached, as http2Stream will be null, but
+    // it is better than nothing.
+    Http2Stream http2Stream = connection().stream(streamId);
+    if (http2Stream != null) {
+      http2Stream.setProperty(streamKey, stream);
+    }
   }
 
   /**
@@ -456,8 +799,19 @@ public void operationComplete(ChannelFuture future) throws Exception {
   private void cancelStream(ChannelHandlerContext ctx, CancelClientStreamCommand cmd,
       ChannelPromise promise) {
     NettyClientStream.TransportState stream = cmd.stream();
-    stream.transportReportStatus(cmd.reason(), true, new Metadata());
-    encoder().writeRstStream(ctx, stream.id(), Http2Error.CANCEL.code(), promise);
+    try (TaskCloseable ignore = PerfMark.traceTask("NettyClientHandler.cancelStream")) {
+      PerfMark.attachTag(stream.tag());
+      PerfMark.linkIn(cmd.getLink());
+      Status reason = cmd.reason();
+      if (reason != null) {
+        stream.transportReportStatus(reason, true, new Metadata());
+      }
+      if (!cmd.stream().isNonExistent()) {
+        encoder().writeRstStream(ctx, stream.id(), Http2Error.CANCEL.code(), promise);
+      } else {
+        promise.setSuccess();
+      }
+    }
   }
 
   /**
@@ -465,16 +819,28 @@ private void cancelStream(ChannelHandlerContext ctx, CancelClientStreamCommand c
    */
   private void sendGrpcFrame(ChannelHandlerContext ctx, SendGrpcFrameCommand cmd,
       ChannelPromise promise) {
-    // Call the base class to write the HTTP/2 DATA frame.
-    // Note: no need to flush since this is handled by the outbound flow controller.
-    encoder().writeData(ctx, cmd.streamId(), cmd.content(), 0, cmd.endStream(), promise);
+    try (TaskCloseable ignore = PerfMark.traceTask("NettyClientHandler.sendGrpcFrame")) {
+      PerfMark.attachTag(cmd.stream().tag());
+      PerfMark.linkIn(cmd.getLink());
+      // Call the base class to write the HTTP/2 DATA frame.
+      // Note: no need to flush since this is handled by the outbound flow controller.
+      encoder().writeData(ctx, cmd.stream().id(), cmd.content(), 0, cmd.endStream(), promise);
+    }
+  }
+
+  private void sendPingFrame(ChannelHandlerContext ctx, SendPingCommand msg,
+      ChannelPromise promise) {
+    try (TaskCloseable ignore = PerfMark.traceTask("NettyClientHandler.sendPingFrame")) {
+      PerfMark.linkIn(msg.getLink());
+      sendPingFrameTraced(ctx, msg, promise);
+    }
   }
 
   /**
    * Sends a PING frame. If a ping operation is already outstanding, the callback in the message is
    * registered to be called when the existing operation completes, and no new frame is sent.
    */
-  private void sendPingFrame(ChannelHandlerContext ctx, SendPingCommand msg,
+  private void sendPingFrameTraced(ChannelHandlerContext ctx, SendPingCommand msg,
       ChannelPromise promise) {
     // Don't check lifecycleManager.getShutdownStatus() since we want to allow pings after shutdown
     // but before termination. After termination, messages will no longer arrive because the
@@ -497,31 +863,34 @@ private void sendPingFrame(ChannelHandlerContext ctx, SendPingCommand msg,
     promise = ctx().newPromise();
     // set outstanding operation
     long data = USER_PING_PAYLOAD;
-    ByteBuf buffer = ctx.alloc().buffer(8);
-    buffer.writeLong(data);
-    Stopwatch stopwatch = Stopwatch.createStarted(ticker);
+    Stopwatch stopwatch = stopwatchFactory.get();
+    stopwatch.start();
     ping = new Http2Ping(data, stopwatch);
     ping.addCallback(callback, executor);
     // and then write the ping
-    encoder().writePing(ctx, false, buffer, promise);
+    encoder().writePing(ctx, false, USER_PING_PAYLOAD, promise);
     ctx.flush();
     final Http2Ping finalPing = ping;
     promise.addListener(new ChannelFutureListener() {
       @Override
       public void operationComplete(ChannelFuture future) throws Exception {
-        if (!future.isSuccess()) {
-          Throwable cause = future.cause();
-          if (cause instanceof ClosedChannelException) {
-            cause = lifecycleManager.getShutdownThrowable();
-            if (cause == null) {
-              cause = Status.UNKNOWN.withDescription("Ping failed but for unknown reason.")
-                  .withCause(future.cause()).asException();
-            }
-          }
-          finalPing.failed(cause);
-          if (ping == finalPing) {
-            ping = null;
+        if (future.isSuccess()) {
+          transportTracer.reportKeepAliveSent();
+          return;
+        }
+        Throwable cause = future.cause();
+        Status status = lifecycleManager.getShutdownStatus();
+        if (cause instanceof ClosedChannelException) {
+          if (status == null) {
+            status = Status.UNKNOWN.withDescription("Ping failed but for unknown reason.")
+                    .withCause(future.cause());
           }
+        } else {
+          status = Utils.statusFromThrowable(cause);
+        }
+        finalPing.failed(status);
+        if (ping == finalPing) {
+          ping = null;
         }
       }
     });
@@ -529,7 +898,7 @@ public void operationComplete(ChannelFuture future) throws Exception {
 
   private void gracefulClose(ChannelHandlerContext ctx, GracefulCloseCommand msg,
       ChannelPromise promise) throws Exception {
-    lifecycleManager.notifyShutdown(msg.getStatus());
+    lifecycleManager.notifyShutdown(msg.getStatus(), SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
     // Explicitly flush to create any buffered streams before sending GOAWAY.
     // TODO(ejona): determine if the need to flush is a bug in Netty
     flush(ctx);
@@ -538,30 +907,63 @@ private void gracefulClose(ChannelHandlerContext ctx, GracefulCloseCommand msg,
 
   private void forcefulClose(final ChannelHandlerContext ctx, final ForcefulCloseCommand msg,
       ChannelPromise promise) throws Exception {
-    lifecycleManager.notifyShutdown(
-        Status.UNAVAILABLE.withDescription("Channel requested transport to shut down"));
-    close(ctx, promise);
     connection().forEachActiveStream(new Http2StreamVisitor() {
       @Override
       public boolean visit(Http2Stream stream) throws Http2Exception {
         NettyClientStream.TransportState clientStream = clientStream(stream);
-        if (clientStream != null) {
-          clientStream.transportReportStatus(msg.getStatus(), true, new Metadata());
-          resetStream(ctx, stream.id(), Http2Error.CANCEL.code(), ctx.newPromise());
+        Tag tag = clientStream != null ? clientStream.tag() : PerfMark.createTag();
+        try (TaskCloseable ignore = PerfMark.traceTask("NettyClientHandler.forcefulClose")) {
+          PerfMark.linkIn(msg.getLink());
+          PerfMark.attachTag(tag);
+          if (clientStream != null) {
+            clientStream.transportReportStatus(msg.getStatus(), true, new Metadata());
+            resetStream(ctx, stream.id(), Http2Error.CANCEL.code(), ctx.newPromise());
+          }
+          stream.close();
+          return true;
         }
-        stream.close();
-        return true;
       }
     });
+    close(ctx, promise);
   }
 
   /**
-   * Handler for a GOAWAY being either sent or received. Fails any streams created after the
-   * last known stream.
+   * Handler for a GOAWAY being received. Fails any streams created after the
+   * last known stream. May only be called during a read.
    */
-  private void goingAway(Status status) {
-    lifecycleManager.notifyShutdown(status);
-    final Status goAwayStatus = lifecycleManager.getShutdownStatus();
+  private void goingAway(long errorCode, byte[] debugData) {
+    Status finalStatus = statusFromH2Error(
+        Status.Code.UNAVAILABLE, "GOAWAY shut down transport", errorCode, debugData);
+    DisconnectError disconnectError = new GoAwayDisconnectError(
+        GrpcUtil.Http2Error.forCode(errorCode));
+    lifecycleManager.notifyGracefulShutdown(finalStatus, disconnectError);
+    abruptGoAwayStatus = statusFromH2Error(
+        Status.Code.UNAVAILABLE, "Abrupt GOAWAY closed unsent stream", errorCode, debugData);
+    // While this _should_ be UNAVAILABLE, Netty uses the wrong stream id in the GOAWAY when it
+    // fails streams due to HPACK failures (e.g., header list too large). To be more conservative,
+    // we assume any sent streams may be related to the GOAWAY. This should rarely impact users
+    // since the main time servers should use abrupt GOAWAYs if there is a protocol error, and if
+    // there wasn't a protocol error the error code was probably NO_ERROR which is mapped to
+    // UNAVAILABLE. https://github.com/netty/netty/issues/10670
+    final Status abruptGoAwayStatusConservative = statusFromH2Error(
+        null, "Abrupt GOAWAY closed sent stream", errorCode, debugData);
+    final boolean mayBeHittingNettyBug = errorCode != Http2Error.NO_ERROR.code();
+    // Try to allocate as many in-flight streams as possible, to reduce race window of
+    // https://github.com/grpc/grpc-java/issues/2562 . To be of any help, the server has to
+    // gracefully shut down the connection with two GOAWAYs. gRPC servers generally send a PING
+    // after the first GOAWAY, so they can very precisely detect when the GOAWAY has been
+    // processed and thus this processing must be in-line before processing additional reads.
+
+    // This can cause reentrancy, but should be minor since it is normal to handle writes in
+    // response to a read. Also, the call stack is rather shallow at this point
+    clientWriteQueue.drainNow();
+    if (lifecycleManager.notifyShutdown(finalStatus, disconnectError)) {
+      // This is for the only RPCs that are actually covered by the GOAWAY error code. All other
+      // RPCs were not observed by the remote and so should be UNAVAILABLE.
+      channelInactiveReason = statusFromH2Error(
+          null, "Connection closed after GOAWAY", errorCode, debugData);
+    }
+
     final int lastKnownStream = connection().local().lastStreamKnownByPeer();
     try {
       connection().forEachActiveStream(new Http2StreamVisitor() {
@@ -570,7 +972,14 @@ public boolean visit(Http2Stream stream) throws Http2Exception {
           if (stream.id() > lastKnownStream) {
             NettyClientStream.TransportState clientStream = clientStream(stream);
             if (clientStream != null) {
-              clientStream.transportReportStatus(goAwayStatus, false, new Metadata());
+              // RpcProgress _should_ be REFUSED, but are being conservative. See comment for
+              // abruptGoAwayStatusConservative. This does reduce our ability to perform transparent
+              // retries, but only if something else caused a connection failure.
+              RpcProgress progress = mayBeHittingNettyBug
+                  ? RpcProgress.PROCESSED
+                  : RpcProgress.REFUSED;
+              clientStream.transportReportStatus(
+                  abruptGoAwayStatusConservative, progress, false, new Metadata());
             }
             stream.close();
           }
@@ -582,22 +991,27 @@ public boolean visit(Http2Stream stream) throws Http2Exception {
     }
   }
 
-  private void cancelPing(Throwable t) {
+  private void cancelPing(Status s) {
     if (ping != null) {
-      ping.failed(t);
+      ping.failed(s);
       ping = null;
     }
   }
 
-  private Status statusFromGoAway(long errorCode, byte[] debugData) {
-    Status status = GrpcUtil.Http2Error.statusForCode((int) errorCode)
-        .augmentDescription("Received Goaway");
+  /** If {@code statusCode} is non-null, it will be used instead of the http2 error code mapping. */
+  private Status statusFromH2Error(
+      Status.Code statusCode, String context, long errorCode, byte[] debugData) {
+    Status status = GrpcUtil.Http2Error.statusForCode(errorCode);
+    if (statusCode == null) {
+      statusCode = status.getCode();
+    }
+    String debugString = "";
     if (debugData != null && debugData.length > 0) {
       // If a debug message was provided, use it.
-      String msg = new String(debugData, UTF_8);
-      status = status.augmentDescription(msg);
+      debugString = ", debug data: " + new String(debugData, UTF_8);
     }
-    return status;
+    return statusCode.toStatus()
+        .withDescription(context + ". " + status.getDescription() + debugString);
   }
 
   /**
@@ -633,6 +1047,7 @@ private class FrameListener extends Http2FrameAdapter {
     public void onSettingsRead(ChannelHandlerContext ctx, Http2Settings settings) {
       if (firstSettings) {
         firstSettings = false;
+        attributes = lifecycleManager.filterAttributes(attributes);
         lifecycleManager.notifyReady();
       }
     }
@@ -663,22 +1078,20 @@ public void onRstStreamRead(ChannelHandlerContext ctx, int streamId, long errorC
     }
 
     @Override
-    public void onPingAckRead(ChannelHandlerContext ctx, ByteBuf data) throws Http2Exception {
+    public void onPingAckRead(ChannelHandlerContext ctx, long ackPayload) throws Http2Exception {
       Http2Ping p = ping;
-      if (data.getLong(data.readerIndex()) == flowControlPing().payload()) {
+      if (ackPayload == flowControlPing().payload()) {
         flowControlPing().updateWindow();
-        if (logger.isLoggable(Level.FINE)) {
-          logger.log(Level.FINE, String.format("Window: %d",
-              decoder().flowController().initialWindowSize(connection().connectionStream())));
-        }
+        logger.log(Level.FINE, "Window: {0}",
+            decoder().flowController().initialWindowSize(connection().connectionStream()));
       } else if (p != null) {
-        long ackPayload = data.readLong();
         if (p.payload() == ackPayload) {
           p.complete();
           ping = null;
         } else {
-          logger.log(Level.WARNING, String.format(
-              "Received unexpected ping ack. Expecting %d, got %d", p.payload(), ackPayload));
+          logger.log(Level.WARNING,
+              "Received unexpected ping ack. Expecting {0}, got {1}",
+              new Object[] {p.payload(), ackPayload});
         }
       } else {
         logger.warning("Received unexpected ping ack. No ping outstanding");
@@ -689,10 +1102,69 @@ public void onPingAckRead(ChannelHandlerContext ctx, ByteBuf data) throws Http2E
     }
 
     @Override
-    public void onPingRead(ChannelHandlerContext ctx, ByteBuf data) throws Http2Exception {
+    public void onPingRead(ChannelHandlerContext ctx, long data) throws Http2Exception {
       if (keepAliveManager != null) {
         keepAliveManager.onDataReceived();
       }
     }
   }
+
+  private static class PingCountingFrameWriter extends DecoratingHttp2FrameWriter
+      implements AbstractNettyHandler.PingLimiter {
+    private int pingCount;
+
+    public PingCountingFrameWriter(Http2FrameWriter delegate) {
+      super(delegate);
+    }
+
+    @Override
+    public boolean isPingAllowed() {
+      // "3 strikes" may cause the server to complain, so we limit ourselves to 2 or below.
+      return pingCount < 2;
+    }
+
+    @Override
+    public ChannelFuture writeHeaders(
+        ChannelHandlerContext ctx, int streamId, Http2Headers headers,
+        int padding, boolean endStream, ChannelPromise promise) {
+      pingCount = 0;
+      return super.writeHeaders(ctx, streamId, headers, padding, endStream, promise);
+    }
+
+    @Override
+    public ChannelFuture writeHeaders(
+        ChannelHandlerContext ctx, int streamId, Http2Headers headers,
+        int streamDependency, short weight, boolean exclusive,
+        int padding, boolean endStream, ChannelPromise promise) {
+      pingCount = 0;
+      return super.writeHeaders(ctx, streamId, headers, streamDependency, weight, exclusive,
+          padding, endStream, promise);
+    }
+
+    @Override
+    public ChannelFuture writeWindowUpdate(
+        ChannelHandlerContext ctx, int streamId, int windowSizeIncrement, ChannelPromise promise) {
+      pingCount = 0;
+      return super.writeWindowUpdate(ctx, streamId, windowSizeIncrement, promise);
+    }
+
+    @Override
+    public ChannelFuture writePing(
+        ChannelHandlerContext ctx, boolean ack, long data, ChannelPromise promise) {
+      if (!ack) {
+        pingCount++;
+      }
+      return super.writePing(ctx, ack, data, promise);
+    }
+
+    @Override
+    public ChannelFuture writeData(
+        ChannelHandlerContext ctx, int streamId, ByteBuf data, int padding, boolean endStream,
+        ChannelPromise promise) {
+      if (data.isReadable()) {
+        pingCount = 0;
+      }
+      return super.writeData(ctx, streamId, data, padding, endStream, promise);
+    }
+  }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NettyClientStream.java b/netty/src/main/java/io/grpc/netty/NettyClientStream.java
index ac96c78d6ab..2939eed2e37 100644
--- a/netty/src/main/java/io/grpc/netty/NettyClientStream.java
+++ b/netty/src/main/java/io/grpc/netty/NettyClientStream.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -36,56 +21,74 @@
 import static com.google.common.base.Preconditions.checkState;
 import static io.netty.buffer.Unpooled.EMPTY_BUFFER;
 
+import com.google.common.base.Preconditions;
+import com.google.common.io.BaseEncoding;
 import io.grpc.Attributes;
+import io.grpc.CallOptions;
 import io.grpc.InternalKnownTransport;
 import io.grpc.InternalMethodDescriptor;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.Status;
-import io.grpc.internal.AbstractClientStream2;
-import io.grpc.internal.ClientStreamListener;
-import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.AbstractClientStream;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
 import io.grpc.internal.Http2ClientStreamTransportState;
 import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.TransportTracer;
 import io.grpc.internal.WritableBuffer;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.EventLoop;
 import io.netty.handler.codec.http2.Http2Headers;
 import io.netty.handler.codec.http2.Http2Stream;
 import io.netty.util.AsciiString;
+import io.perfmark.PerfMark;
+import io.perfmark.Tag;
+import io.perfmark.TaskCloseable;
 import javax.annotation.Nullable;
 
 /**
  * Client stream for a Netty transport. Must only be called from the sending application
  * thread.
  */
-class NettyClientStream extends AbstractClientStream2 {
+class NettyClientStream extends AbstractClientStream {
   private static final InternalMethodDescriptor methodDescriptorAccessor =
-      new InternalMethodDescriptor(InternalKnownTransport.NETTY);
+      new InternalMethodDescriptor(
+          NettyClientTransport.class.getName().contains("grpc.netty.shaded")
+              ? InternalKnownTransport.NETTY_SHADED : InternalKnownTransport.NETTY);
 
   private final Sink sink = new Sink();
   private final TransportState state;
   private final WriteQueue writeQueue;
   private final MethodDescriptor<?, ?> method;
-  /** {@code null} after start. */
-  private Metadata headers;
-  private final Channel channel;
   private AsciiString authority;
   private final AsciiString scheme;
   private final AsciiString userAgent;
 
   NettyClientStream(
-      TransportState state, MethodDescriptor<?, ?> method, Metadata headers,
-      Channel channel, AsciiString authority, AsciiString scheme, AsciiString userAgent,
-      StatsTraceContext statsTraceCtx) {
-    super(new NettyWritableBufferAllocator(channel.alloc()), statsTraceCtx);
+      TransportState state,
+      MethodDescriptor<?, ?> method,
+      Metadata headers,
+      Channel channel,
+      AsciiString authority,
+      AsciiString scheme,
+      AsciiString userAgent,
+      StatsTraceContext statsTraceCtx,
+      TransportTracer transportTracer,
+      CallOptions callOptions,
+      boolean useGetForSafeMethods) {
+    super(
+        new NettyWritableBufferAllocator(channel.alloc()),
+        statsTraceCtx,
+        transportTracer,
+        headers,
+        callOptions,
+        useGetForSafeMethods && method.isSafe());
     this.state = checkNotNull(state, "transportState");
     this.writeQueue = state.handler.getWriteQueue();
     this.method = checkNotNull(method, "method");
-    this.headers = checkNotNull(headers, "headers");
-    this.channel = checkNotNull(channel, "channel");
     this.authority = checkNotNull(authority, "authority");
     this.scheme = checkNotNull(scheme, "scheme");
     this.userAgent = userAgent;
@@ -103,114 +106,160 @@ protected Sink abstractClientStreamSink() {
 
   @Override
   public void setAuthority(String authority) {
-    checkState(headers != null, "must be call before start");
     this.authority = AsciiString.of(checkNotNull(authority, "authority"));
   }
 
-  @Override
-  public void start(ClientStreamListener listener) {
-    super.start(listener);
-
-    // Convert the headers into Netty HTTP/2 headers.
-    AsciiString defaultPath = (AsciiString) methodDescriptorAccessor.geRawMethodName(method);
-    if (defaultPath == null) {
-      defaultPath = new AsciiString("/" + method.getFullMethodName());
-      methodDescriptorAccessor.setRawMethodName(method, defaultPath);
-    }
-    headers.discardAll(GrpcUtil.USER_AGENT_KEY);
-    Http2Headers http2Headers
-        = Utils.convertClientHeaders(headers, scheme, defaultPath, authority, userAgent);
-    headers = null;
-
-    ChannelFutureListener failureListener = new ChannelFutureListener() {
-      @Override
-      public void operationComplete(ChannelFuture future) throws Exception {
-        if (!future.isSuccess()) {
-          // Stream creation failed. Close the stream if not already closed.
-          Status s = transportState().statusFromFailedFuture(future);
-          transportState().transportReportStatus(s, true, new Metadata());
-        }
-      }
-    };
-
-    // Write the command requesting the creation of the stream.
-    writeQueue.enqueue(new CreateStreamCommand(http2Headers, transportState()),
-        !method.getType().clientSendsOneMessage()).addListener(failureListener);
-  }
-
   @Override
   public Attributes getAttributes() {
     return state.handler.getAttributes();
   }
 
-  private class Sink implements AbstractClientStream2.Sink {
+  private class Sink implements AbstractClientStream.Sink {
+
     @Override
-    public void writeFrame(WritableBuffer frame, boolean endOfStream, boolean flush) {
-      ByteBuf bytebuf = frame == null ? EMPTY_BUFFER : ((NettyWritableBuffer) frame).bytebuf();
+    public void writeHeaders(Metadata headers, byte[] requestPayload) {
+      try (TaskCloseable ignore =
+               PerfMark.traceTask("NettyClientStream$Sink.writeHeaders")) {
+        writeHeadersInternal(headers, requestPayload);
+      }
+    }
+
+    private void writeHeadersInternal(Metadata headers, byte[] requestPayload) {
+      // Convert the headers into Netty HTTP/2 headers.
+      AsciiString defaultPath = (AsciiString) methodDescriptorAccessor.geRawMethodName(method);
+      if (defaultPath == null) {
+        defaultPath = new AsciiString("/" + method.getFullMethodName());
+        methodDescriptorAccessor.setRawMethodName(method, defaultPath);
+      }
+      boolean get = (requestPayload != null);
+      AsciiString httpMethod;
+      if (get) {
+        // Forge the query string
+        // TODO(ericgribkoff) Add the key back to the query string
+        defaultPath =
+            new AsciiString(defaultPath + "?" + BaseEncoding.base64().encode(requestPayload));
+        httpMethod = Utils.HTTP_GET_METHOD;
+      } else {
+        httpMethod = Utils.HTTP_METHOD;
+      }
+      Http2Headers http2Headers = Utils.convertClientHeaders(headers, scheme, defaultPath,
+          authority, httpMethod, userAgent);
+
+      ChannelFutureListener failureListener = new ChannelFutureListener() {
+        @Override
+        public void operationComplete(ChannelFuture future) throws Exception {
+          if (!future.isSuccess()) {
+            // Stream creation failed. Close the stream if not already closed.
+            // When the channel is shutdown, the lifecycle manager has a better view of the failure,
+            // especially before negotiation completes (because the negotiator commonly doesn't
+            // receive the exceptionCaught because NettyClientHandler does not propagate it).
+            Status s = transportState().handler.getLifecycleManager().getShutdownStatus();
+            if (s == null) {
+              s = transportState().statusFromFailedFuture(future);
+            }
+            if (transportState().isNonExistent()) {
+              transportState().transportReportStatus(
+                  s, RpcProgress.MISCARRIED, true, new Metadata());
+            } else {
+              transportState().transportReportStatus(
+                  s, RpcProgress.PROCESSED, true, new Metadata());
+            }
+          }
+        }
+      };
+      // Write the command requesting the creation of the stream.
+      writeQueue.enqueue(
+          new CreateStreamCommand(http2Headers, transportState(), shouldBeCountedForInUse(), get),
+          !method.getType().clientSendsOneMessage() || get).addListener(failureListener);
+    }
+
+    private void writeFrameInternal(
+        WritableBuffer frame, boolean endOfStream, boolean flush, final int numMessages) {
+      Preconditions.checkArgument(numMessages >= 0);
+      ByteBuf bytebuf =
+          frame == null ? EMPTY_BUFFER : ((NettyWritableBuffer) frame).bytebuf().touch();
       final int numBytes = bytebuf.readableBytes();
       if (numBytes > 0) {
         // Add the bytes to outbound flow control.
         onSendingBytes(numBytes);
-        writeQueue.enqueue(
-            new SendGrpcFrameCommand(transportState(), bytebuf, endOfStream),
-            channel.newPromise().addListener(new ChannelFutureListener() {
-              @Override
-              public void operationComplete(ChannelFuture future) throws Exception {
-                if (future.isSuccess()) {
-                  // Remove the bytes from outbound flow control, optionally notifying
-                  // the client that they can send more bytes.
-                  transportState().onSentBytes(numBytes);
-                }
-              }
-            }), flush);
+        ChannelFutureListener failureListener =
+            future -> transportState().onWriteFrameData(future, numMessages, numBytes);
+        writeQueue.enqueue(new SendGrpcFrameCommand(transportState(), bytebuf, endOfStream), flush)
+            .addListener(failureListener);
       } else {
         // The frame is empty and will not impact outbound flow control. Just send it.
-        writeQueue.enqueue(new SendGrpcFrameCommand(transportState(), bytebuf, endOfStream), flush);
+        writeQueue.enqueue(
+            new SendGrpcFrameCommand(transportState(), bytebuf, endOfStream), flush);
       }
     }
 
     @Override
-    public void request(final int numMessages) {
-      if (channel.eventLoop().inEventLoop()) {
-        // Processing data read in the event loop so can call into the deframer immediately
-        transportState().requestMessagesFromDeframer(numMessages);
-      } else {
-        channel.eventLoop().execute(new Runnable() {
-          @Override
-          public void run() {
-            transportState().requestMessagesFromDeframer(numMessages);
-          }
-        });
+    public void writeFrame(
+        WritableBuffer frame, boolean endOfStream, boolean flush, int numMessages) {
+      try (TaskCloseable ignore = PerfMark.traceTask("NettyClientStream$Sink.writeFrame")) {
+        writeFrameInternal(frame, endOfStream, flush, numMessages);
       }
     }
 
     @Override
     public void cancel(Status status) {
-      writeQueue.enqueue(new CancelClientStreamCommand(transportState(), status), true);
+      try (TaskCloseable ignore = PerfMark.traceTask("NettyClientStream$Sink.cancel")) {
+        writeQueue.enqueue(new CancelClientStreamCommand(transportState(), status), true);
+      }
     }
   }
 
-  /** This should only called from the transport thread. */
+  /** This should only be called from the transport thread. */
   public abstract static class TransportState extends Http2ClientStreamTransportState
       implements StreamIdHolder {
+    private static final int NON_EXISTENT_ID = -1;
+
+    private final String methodName;
     private final NettyClientHandler handler;
+    private final EventLoop eventLoop;
     private int id;
     private Http2Stream http2Stream;
+    private Tag tag;
 
-    public TransportState(NettyClientHandler handler, int maxMessageSize,
-        StatsTraceContext statsTraceCtx) {
-      super(maxMessageSize, statsTraceCtx);
+    protected TransportState(
+        NettyClientHandler handler,
+        EventLoop eventLoop,
+        int maxMessageSize,
+        StatsTraceContext statsTraceCtx,
+        TransportTracer transportTracer,
+        String methodName,
+        CallOptions options) {
+      super(maxMessageSize, statsTraceCtx, transportTracer, options);
+      this.methodName = checkNotNull(methodName, "methodName");
       this.handler = checkNotNull(handler, "handler");
+      this.eventLoop = checkNotNull(eventLoop, "eventLoop");
+      tag = PerfMark.createTag(methodName);
     }
 
     @Override
     public int id() {
+      // id should be positive
       return id;
     }
 
     public void setId(int id) {
-      checkArgument(id > 0, "id must be positive");
+      checkArgument(id > 0, "id must be positive %s", id);
+      checkState(this.id == 0, "id has been previously set: %s", this.id);
       this.id = id;
+      this.tag = PerfMark.createTag(methodName, id);
+    }
+
+    /**
+     * Marks the stream state as if it had never existed.  This can happen if the stream is
+     * cancelled after it is created, but before it has been started.
+     */
+    void setNonExistent() {
+      checkState(this.id == 0, "Id has been previously set: %s", this.id);
+      this.id = NON_EXISTENT_ID;
+    }
+
+    boolean isNonExistent() {
+      return this.id == NON_EXISTENT_ID || this.id == 0;
     }
 
     /**
@@ -225,6 +274,7 @@ public void setHttp2Stream(Http2Stream http2Stream) {
       // Now that the stream has actually been initialized, call the listener's onReady callback if
       // appropriate.
       onStreamAllocated();
+      getTransportTracer().reportLocalStreamStarted();
     }
 
     /**
@@ -236,17 +286,49 @@ public Http2Stream http2Stream() {
     }
 
     /**
-     * Intended to be overriden by NettyClientTransport, which has more information about failures.
+     * Intended to be overridden by NettyClientTransport, which has more information about failures.
      * May only be called from event loop.
      */
     protected abstract Status statusFromFailedFuture(ChannelFuture f);
 
     @Override
-    protected void http2ProcessingFailed(Status status, Metadata trailers) {
-      transportReportStatus(status, false, trailers);
+    protected void http2ProcessingFailed(Status status, boolean stopDelivery, Metadata trailers) {
+      transportReportStatus(status, stopDelivery, trailers);
       handler.getWriteQueue().enqueue(new CancelClientStreamCommand(this, status), true);
     }
 
+    private void onWriteFrameData(ChannelFuture future, int numMessages, int numBytes) {
+      // If the future succeeds when http2stream is null, the stream has been cancelled
+      // before it began and Netty is purging pending writes from the flow-controller.
+      if (future.isSuccess() && http2Stream() == null) {
+        return;
+      }
+
+      if (future.isSuccess()) {
+        // Remove the bytes from outbound flow control, optionally notifying
+        // the client that they can send more bytes.
+        onSentBytes(numBytes);
+        getTransportTracer().reportMessageSent(numMessages);
+      } else if (!isStreamDeallocated()) {
+        // Future failed, fail RPC.
+        // Normally we don't need to do anything here because the cause of a failed future
+        // while writing DATA frames would be an IO error and the stream is already closed.
+        // However, we still need handle any unexpected failures raised in Netty.
+        // Note: isStreamDeallocated() protects from spamming stream resets by scheduling multiple
+        // CancelClientStreamCommand commands.
+        http2ProcessingFailed(statusFromFailedFuture(future), true, new Metadata());
+      }
+    }
+
+    @Override
+    public void runOnTransportThread(final Runnable r) {
+      if (eventLoop.inEventLoop()) {
+        r.run();
+      } else {
+        eventLoop.execute(r);
+      }
+    }
+
     @Override
     public void bytesRead(int processedBytes) {
       handler.returnProcessedBytes(http2Stream, processedBytes);
@@ -254,12 +336,15 @@ public void bytesRead(int processedBytes) {
     }
 
     @Override
-    protected void deframeFailed(Throwable cause) {
-      http2ProcessingFailed(Status.fromThrowable(cause), new Metadata());
+    public void deframeFailed(Throwable cause) {
+      http2ProcessingFailed(Status.fromThrowable(cause), true, new Metadata());
     }
 
     void transportHeadersReceived(Http2Headers headers, boolean endOfStream) {
       if (endOfStream) {
+        if (!isOutboundClosed()) {
+          handler.getWriteQueue().enqueue(new CancelClientStreamCommand(this, null), true);
+        }
         transportTrailersReceived(Utils.convertTrailers(headers));
       } else {
         transportHeadersReceived(Utils.convertHeaders(headers));
@@ -269,5 +354,10 @@ void transportHeadersReceived(Http2Headers headers, boolean endOfStream) {
     void transportDataReceived(ByteBuf frame, boolean endOfStream) {
       transportDataReceived(new NettyReadableBuffer(frame.retain()), endOfStream);
     }
+
+    @Override
+    public final Tag tag() {
+      return tag;
+    }
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NettyClientTransport.java b/netty/src/main/java/io/grpc/netty/NettyClientTransport.java
index 0be1e1f509d..53914b3c877 100644
--- a/netty/src/main/java/io/grpc/netty/NettyClientTransport.java
+++ b/netty/src/main/java/io/grpc/netty/NettyClientTransport.java
@@ -1,125 +1,178 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import static io.grpc.internal.GrpcUtil.KEEPALIVE_TIME_NANOS_DISABLED;
+import static io.netty.channel.ChannelOption.ALLOCATOR;
 import static io.netty.channel.ChannelOption.SO_KEEPALIVE;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Ticker;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
 import io.grpc.Attributes;
 import io.grpc.CallOptions;
+import io.grpc.ChannelLogger;
+import io.grpc.ClientStreamTracer;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalLogId;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.Status;
 import io.grpc.internal.ClientStream;
 import io.grpc.internal.ConnectionClientTransport;
+import io.grpc.internal.DisconnectError;
+import io.grpc.internal.FailingClientStream;
 import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.Http2Ping;
 import io.grpc.internal.KeepAliveManager;
-import io.grpc.internal.LogId;
+import io.grpc.internal.KeepAliveManager.ClientKeepAlivePinger;
+import io.grpc.internal.SimpleDisconnectError;
 import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.TransportTracer;
+import io.grpc.netty.NettyChannelBuilder.LocalSocketPicker;
 import io.netty.bootstrap.Bootstrap;
 import io.netty.channel.Channel;
+import io.netty.channel.ChannelFactory;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelFutureListener;
-import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelOption;
+import io.netty.channel.EventLoop;
 import io.netty.channel.EventLoopGroup;
-import io.netty.channel.socket.nio.NioSocketChannel;
 import io.netty.handler.codec.http2.StreamBufferingEncoder.Http2ChannelClosedException;
 import io.netty.util.AsciiString;
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.GenericFutureListener;
 import java.net.SocketAddress;
 import java.nio.channels.ClosedChannelException;
 import java.util.Map;
 import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
 import javax.annotation.Nullable;
 
 /**
  * A Netty-based {@link ConnectionClientTransport} implementation.
  */
-class NettyClientTransport implements ConnectionClientTransport {
-  private final LogId logId = LogId.allocate(getClass().getName());
+class NettyClientTransport implements ConnectionClientTransport,
+    ClientKeepAlivePinger.TransportWithDisconnectReason {
+
+  private final InternalLogId logId;
   private final Map<ChannelOption<?>, ?> channelOptions;
-  private final SocketAddress address;
-  private final Class<? extends Channel> channelType;
+  private final SocketAddress remoteAddress;
+  private final ChannelFactory<? extends Channel> channelFactory;
   private final EventLoopGroup group;
   private final ProtocolNegotiator negotiator;
+  private final String authorityString;
   private final AsciiString authority;
   private final AsciiString userAgent;
+  private final boolean autoFlowControl;
   private final int flowControlWindow;
   private final int maxMessageSize;
   private final int maxHeaderListSize;
+  private final int softLimitHeaderListSize;
   private KeepAliveManager keepAliveManager;
-  private boolean enableKeepAlive;
-  private long keepAliveDelayNanos;
-  private long keepAliveTimeoutNanos;
-
-  private ProtocolNegotiator.Handler negotiationHandler;
+  private final long keepAliveTimeNanos;
+  private final long keepAliveTimeoutNanos;
+  private final boolean keepAliveWithoutCalls;
+  private final AsciiString negotiationScheme;
+  private final Runnable tooManyPingsRunnable;
   private NettyClientHandler handler;
   // We should not send on the channel until negotiation completes. This is a hard requirement
   // by SslHandler but is appropriate for HTTP/1.1 Upgrade as well.
   private Channel channel;
+  /** If {@link #start} has been called, non-{@code null} if channel is {@code null}. */
+  private Status statusExplainingWhyTheChannelIsNull;
   /** Since not thread-safe, may only be used from event loop. */
   private ClientTransportLifecycleManager lifecycleManager;
+  /** Since not thread-safe, may only be used from event loop. */
+  private final TransportTracer transportTracer;
+  private final Attributes eagAttributes;
+  private final LocalSocketPicker localSocketPicker;
+  private final ChannelLogger channelLogger;
+  private final boolean useGetForSafeMethods;
+  private final Ticker ticker;
+
 
   NettyClientTransport(
-      SocketAddress address, Class<? extends Channel> channelType,
-      Map<ChannelOption<?>, ?> channelOptions, EventLoopGroup group,
-      ProtocolNegotiator negotiator, int flowControlWindow, int maxMessageSize,
-      int maxHeaderListSize, String authority, @Nullable String userAgent) {
+      SocketAddress address,
+      ChannelFactory<? extends Channel> channelFactory,
+      Map<ChannelOption<?>, ?> channelOptions,
+      EventLoopGroup group,
+      ProtocolNegotiator negotiator,
+      boolean autoFlowControl,
+      int flowControlWindow,
+      int maxMessageSize,
+      int maxHeaderListSize,
+      int softLimitHeaderListSize,
+      long keepAliveTimeNanos,
+      long keepAliveTimeoutNanos,
+      boolean keepAliveWithoutCalls,
+      String authority,
+      @Nullable String userAgent,
+      Runnable tooManyPingsRunnable,
+      TransportTracer transportTracer,
+      Attributes eagAttributes,
+      LocalSocketPicker localSocketPicker,
+      ChannelLogger channelLogger,
+      boolean useGetForSafeMethods,
+      Ticker ticker) {
+
     this.negotiator = Preconditions.checkNotNull(negotiator, "negotiator");
-    this.address = Preconditions.checkNotNull(address, "address");
+    this.negotiationScheme = this.negotiator.scheme();
+    this.remoteAddress = Preconditions.checkNotNull(address, "address");
     this.group = Preconditions.checkNotNull(group, "group");
-    this.channelType = Preconditions.checkNotNull(channelType, "channelType");
+    this.channelFactory = channelFactory;
     this.channelOptions = Preconditions.checkNotNull(channelOptions, "channelOptions");
+    this.autoFlowControl = autoFlowControl;
     this.flowControlWindow = flowControlWindow;
     this.maxMessageSize = maxMessageSize;
     this.maxHeaderListSize = maxHeaderListSize;
+    this.softLimitHeaderListSize = softLimitHeaderListSize;
+    this.keepAliveTimeNanos = keepAliveTimeNanos;
+    this.keepAliveTimeoutNanos = keepAliveTimeoutNanos;
+    this.keepAliveWithoutCalls = keepAliveWithoutCalls;
+    this.authorityString = authority;
     this.authority = new AsciiString(authority);
     this.userAgent = new AsciiString(GrpcUtil.getGrpcUserAgent("netty", userAgent));
-  }
-
-  /**
-   * Enable keepalive with custom delay and timeout.
-   */
-  void enableKeepAlive(boolean enable, long keepAliveDelayNanos, long keepAliveTimeoutNanos) {
-    enableKeepAlive = enable;
-    this.keepAliveDelayNanos = keepAliveDelayNanos;
-    this.keepAliveTimeoutNanos = keepAliveTimeoutNanos;
+    this.tooManyPingsRunnable =
+        Preconditions.checkNotNull(tooManyPingsRunnable, "tooManyPingsRunnable");
+    this.transportTracer = Preconditions.checkNotNull(transportTracer, "transportTracer");
+    this.eagAttributes = Preconditions.checkNotNull(eagAttributes, "eagAttributes");
+    this.localSocketPicker = Preconditions.checkNotNull(localSocketPicker, "localSocketPicker");
+    this.logId = InternalLogId.allocate(getClass(), remoteAddress.toString());
+    this.channelLogger = Preconditions.checkNotNull(channelLogger, "channelLogger");
+    this.useGetForSafeMethods = useGetForSafeMethods;
+    this.ticker = Preconditions.checkNotNull(ticker, "ticker");
   }
 
   @Override
   public void ping(final PingCallback callback, final Executor executor) {
+    if (channel == null) {
+      executor.execute(new Runnable() {
+        @Override
+        public void run() {
+          callback.onFailure(statusExplainingWhyTheChannelIsNull);
+        }
+      });
+      return;
+    }
     // The promise and listener always succeed in NettyClientHandler. So this listener handles the
     // error case, when the channel is closed and the NettyClientHandler no longer in the pipeline.
     ChannelFutureListener failureListener = new ChannelFutureListener() {
@@ -127,7 +180,7 @@ public void ping(final PingCallback callback, final Executor executor) {
       public void operationComplete(ChannelFuture future) throws Exception {
         if (!future.isSuccess()) {
           Status s = statusFromFailedFuture(future);
-          Http2Ping.notifyFailed(callback, executor, s.asException());
+          Http2Ping.notifyFailed(callback, executor, s);
         }
       }
     };
@@ -139,24 +192,38 @@ public void operationComplete(ChannelFuture future) throws Exception {
   @Override
   public ClientStream newStream(
       MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
-      StatsTraceContext statsTraceCtx) {
+      ClientStreamTracer[] tracers) {
     Preconditions.checkNotNull(method, "method");
     Preconditions.checkNotNull(headers, "headers");
-    Preconditions.checkNotNull(statsTraceCtx, "statsTraceCtx");
+    if (channel == null) {
+      return new FailingClientStream(statusExplainingWhyTheChannelIsNull, tracers);
+    }
+    StatsTraceContext statsTraceCtx =
+        StatsTraceContext.newClientContext(tracers, getAttributes(), headers);
     return new NettyClientStream(
-        new NettyClientStream.TransportState(handler, maxMessageSize, statsTraceCtx) {
+        new NettyClientStream.TransportState(
+            handler,
+            channel.eventLoop(),
+            maxMessageSize,
+            statsTraceCtx,
+            transportTracer,
+            method.getFullMethodName(),
+            callOptions) {
           @Override
           protected Status statusFromFailedFuture(ChannelFuture f) {
             return NettyClientTransport.this.statusFromFailedFuture(f);
           }
         },
-        method, headers, channel, authority, negotiationHandler.scheme(), userAgent,
-        statsTraceCtx);
-  }
-
-  @Override
-  public ClientStream newStream(MethodDescriptor<?, ?> method, Metadata headers) {
-    return newStream(method, headers, CallOptions.DEFAULT, StatsTraceContext.NOOP);
+        method,
+        headers,
+        channel,
+        authority,
+        negotiationScheme,
+        userAgent,
+        statsTraceCtx,
+        transportTracer,
+        callOptions,
+        useGetForSafeMethods);
   }
 
   @SuppressWarnings("unchecked")
@@ -164,18 +231,36 @@ public ClientStream newStream(MethodDescriptor<?, ?> method, Metadata headers) {
   public Runnable start(Listener transportListener) {
     lifecycleManager = new ClientTransportLifecycleManager(
         Preconditions.checkNotNull(transportListener, "listener"));
+    EventLoop eventLoop = group.next();
+    if (keepAliveTimeNanos != KEEPALIVE_TIME_NANOS_DISABLED) {
+      keepAliveManager = new KeepAliveManager(
+          new ClientKeepAlivePinger(this), eventLoop, keepAliveTimeNanos,
+          keepAliveTimeoutNanos, keepAliveWithoutCalls);
+    }
 
-    handler = newHandler();
-    HandlerSettings.setAutoWindow(handler);
+    handler = NettyClientHandler.newHandler(
+            lifecycleManager,
+            keepAliveManager,
+            autoFlowControl,
+            flowControlWindow,
+            maxHeaderListSize,
+            softLimitHeaderListSize,
+            GrpcUtil.STOPWATCH_SUPPLIER,
+            tooManyPingsRunnable,
+            transportTracer,
+            eagAttributes,
+            authorityString,
+            channelLogger,
+            ticker);
 
-    negotiationHandler = negotiator.newHandler(handler);
+    ChannelHandler negotiationHandler = negotiator.newHandler(handler);
 
     Bootstrap b = new Bootstrap();
-    b.group(group);
-    b.channel(channelType);
-    if (NioSocketChannel.class.isAssignableFrom(channelType)) {
-      b.option(SO_KEEPALIVE, true);
-    }
+    b.option(ALLOCATOR, Utils.getByteBufAllocator(false));
+    b.group(eventLoop);
+    b.channelFactory(channelFactory);
+    // For non-socket based channel, the option will be ignored.
+    b.option(SO_KEEPALIVE, true);
     for (Map.Entry<ChannelOption<?>, ?> entry : channelOptions.entrySet()) {
       // Every entry in the map is obtained from
       // NettyChannelBuilder#withOption(ChannelOption<T> option, T value)
@@ -183,93 +268,172 @@ public Runnable start(Listener transportListener) {
       b.option((ChannelOption<Object>) entry.getKey(), entry.getValue());
     }
 
-    /**
+    ChannelHandler bufferingHandler = new WriteBufferingAndExceptionHandler(negotiationHandler);
+
+    /*
      * We don't use a ChannelInitializer in the client bootstrap because its "initChannel" method
      * is executed in the event loop and we need this handler to be in the pipeline immediately so
      * that it may begin buffering writes.
      */
-    b.handler(negotiationHandler);
-    channel = b.register().channel();
-    // Start the connection operation to the server.
-    channel.connect(address).addListener(new ChannelFutureListener() {
-      @Override
-      public void operationComplete(ChannelFuture future) throws Exception {
-        if (!future.isSuccess()) {
-          ChannelHandlerContext ctx = future.channel().pipeline().context(handler);
-          if (ctx != null) {
-            // NettyClientHandler doesn't propagate exceptions, but the negotiator will need the
-            // exception to fail any writes. Note that this fires after handler, because it is as if
-            // handler was propagating the notification.
-            ctx.fireExceptionCaught(future.cause());
-          }
-          future.channel().pipeline().fireExceptionCaught(future.cause());
+    b.handler(bufferingHandler);
+    ChannelFuture regFuture = b.register();
+    if (regFuture.isDone() && !regFuture.isSuccess()) {
+      channel = null;
+      // Initialization has failed badly. All new streams should be made to fail.
+      Throwable t = regFuture.cause();
+      if (t == null) {
+        t = new IllegalStateException("Channel is null, but future doesn't have a cause");
+      }
+      statusExplainingWhyTheChannelIsNull = Utils.statusFromThrowable(t);
+      // Use a Runnable since lifecycleManager calls transportListener
+      return new Runnable() {
+        @Override
+        public void run() {
+          // NOTICE: we not are calling lifecycleManager from the event loop. But there isn't really
+          // an event loop in this case, so nothing should be accessing the lifecycleManager. We
+          // could use GlobalEventExecutor (which is what regFuture would use for notifying
+          // listeners in this case), but avoiding on-demand thread creation in an error case seems
+          // a good idea and is probably clearer threading.
+          lifecycleManager.notifyTerminated(statusExplainingWhyTheChannelIsNull,
+              SimpleDisconnectError.UNKNOWN);
+        }
+      };
+    }
+    channel = regFuture.channel();
+    // For non-epoll based channel, the option will be ignored.
+    try {
+      if (keepAliveTimeNanos != KEEPALIVE_TIME_NANOS_DISABLED
+              && Class.forName("io.netty.channel.epoll.AbstractEpollChannel").isInstance(channel)) {
+        ChannelOption<Integer> tcpUserTimeout = Utils.maybeGetTcpUserTimeoutOption();
+        if (tcpUserTimeout != null) {
+          int tcpUserTimeoutMs = (int) TimeUnit.NANOSECONDS.toMillis(keepAliveTimeoutNanos);
+          channel.config().setOption(tcpUserTimeout, tcpUserTimeoutMs);
         }
       }
-    });
+    } catch (ClassNotFoundException ignored) {
+      // JVM did not load AbstractEpollChannel, so the current channel will not be of epoll type,
+      // so there is no need to set TCP_USER_TIMEOUT
+    }
     // Start the write queue as soon as the channel is constructed
     handler.startWriteQueue(channel);
     // This write will have no effect, yet it will only complete once the negotiationHandler
-    // flushes any pending writes.
-    channel.write(NettyClientHandler.NOOP_MESSAGE).addListener(new ChannelFutureListener() {
+    // flushes any pending writes. We need it to be staged *before* the `connect` so that
+    // the channel can't have been closed yet, removing all handlers. This write will sit in the
+    // AbstractBufferingHandler's buffer, and will either be flushed on a successful connection,
+    // or failed if the connection fails.
+    channel.writeAndFlush(NettyClientHandler.NOOP_MESSAGE).addListener(new ChannelFutureListener() {
       @Override
       public void operationComplete(ChannelFuture future) throws Exception {
         if (!future.isSuccess()) {
           // Need to notify of this failure, because NettyClientHandler may not have been added to
           // the pipeline before the error occurred.
-          lifecycleManager.notifyTerminated(Utils.statusFromThrowable(future.cause()));
+          lifecycleManager.notifyTerminated(Utils.statusFromThrowable(future.cause()),
+              SimpleDisconnectError.UNKNOWN);
         }
       }
     });
-    // Handle transport shutdown when the channel is closed.
-    channel.closeFuture().addListener(new ChannelFutureListener() {
-      @Override
-      public void operationComplete(ChannelFuture future) throws Exception {
-        // Typically we should have noticed shutdown before this point.
-        lifecycleManager.notifyTerminated(
-            Status.INTERNAL.withDescription("Connection closed with unknown cause"));
-      }
-    });
+    // Start the connection operation to the server.
+    SocketAddress localAddress =
+        localSocketPicker.createSocketAddress(remoteAddress, eagAttributes);
+    if (localAddress != null) {
+      channel.connect(remoteAddress, localAddress);
+    } else {
+      channel.connect(remoteAddress);
+    }
 
-    if (enableKeepAlive) {
-      keepAliveManager = new KeepAliveManager(this, channel.eventLoop(), keepAliveDelayNanos,
-          keepAliveTimeoutNanos);
+    if (keepAliveManager != null) {
+      keepAliveManager.onTransportStarted();
     }
 
     return null;
   }
 
   @Override
-  public void shutdown() {
+  public void shutdown(Status reason) {
+    // start() could have failed
+    if (channel == null) {
+      return;
+    }
     // Notifying of termination is automatically done when the channel closes.
     if (channel.isOpen()) {
-      Status status
-          = Status.UNAVAILABLE.withDescription("Channel requested transport to shut down");
-      handler.getWriteQueue().enqueue(new GracefulCloseCommand(status), true);
+      handler.getWriteQueue().enqueue(new GracefulCloseCommand(reason), true);
     }
   }
 
   @Override
-  public void shutdownNow(Status reason) {
+  public void shutdownNow(final Status reason) {
+    shutdownNow(reason, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+  }
+
+  @Override
+  public void shutdownNow(final Status reason, DisconnectError disconnectError) {
     // Notifying of termination is automatically done when the channel closes.
     if (channel != null && channel.isOpen()) {
-      handler.getWriteQueue().enqueue(new ForcefulCloseCommand(reason), true);
+      handler.getWriteQueue().enqueue(new Runnable() {
+        @Override
+        public void run() {
+          lifecycleManager.notifyShutdown(reason, disconnectError);
+          channel.write(new ForcefulCloseCommand(reason));
+        }
+      }, true);
     }
   }
 
   @Override
   public String toString() {
-    return getLogId() + "(" + address + ")";
+    return MoreObjects.toStringHelper(this)
+        .add("logId", logId.getId())
+        .add("remoteAddress", remoteAddress)
+        .add("channel", channel)
+        .toString();
   }
 
   @Override
-  public LogId getLogId() {
+  public InternalLogId getLogId() {
     return logId;
   }
 
   @Override
   public Attributes getAttributes() {
-    // TODO(zhangkun83): fill channel security attributes
-    return Attributes.EMPTY;
+    return handler.getAttributes();
+  }
+
+  @Override
+  public ListenableFuture<SocketStats> getStats() {
+    final SettableFuture<SocketStats> result = SettableFuture.create();
+    if (channel.eventLoop().inEventLoop()) {
+      // This is necessary, otherwise we will block forever if we get the future from inside
+      // the event loop.
+      result.set(getStatsHelper(channel));
+      return result;
+    }
+    channel.eventLoop().submit(
+        new Runnable() {
+          @Override
+          public void run() {
+            result.set(getStatsHelper(channel));
+          }
+        })
+        .addListener(
+            new GenericFutureListener<Future<Object>>() {
+              @Override
+              public void operationComplete(Future<Object> future) throws Exception {
+                if (!future.isSuccess()) {
+                  result.setException(future.cause());
+                }
+              }
+            });
+    return result;
+  }
+
+  private SocketStats getStatsHelper(Channel ch) {
+    assert ch.eventLoop().inEventLoop();
+    return new SocketStats(
+        transportTracer.getStats(),
+        channel.localAddress(),
+        channel.remoteAddress(),
+        Utils.getSocketOptions(ch),
+        handler == null ? null : handler.getSecurityInfo());
   }
 
   @VisibleForTesting
@@ -298,15 +462,11 @@ private Status statusFromFailedFuture(ChannelFuture f) {
         || t instanceof Http2ChannelClosedException) {
       Status shutdownStatus = lifecycleManager.getShutdownStatus();
       if (shutdownStatus == null) {
-        return Status.UNKNOWN.withDescription("Channel closed but for unknown reason");
+        return Status.UNKNOWN.withDescription("Channel closed but for unknown reason")
+            .withCause(new ClosedChannelException().initCause(t));
       }
       return shutdownStatus;
     }
     return Utils.statusFromThrowable(t);
   }
-
-  private NettyClientHandler newHandler() {
-    return NettyClientHandler.newHandler(lifecycleManager, keepAliveManager, flowControlWindow,
-        maxHeaderListSize, Ticker.systemTicker());
-  }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NettyReadableBuffer.java b/netty/src/main/java/io/grpc/netty/NettyReadableBuffer.java
index 79d74f17a50..af5ec8d8bad 100644
--- a/netty/src/main/java/io/grpc/netty/NettyReadableBuffer.java
+++ b/netty/src/main/java/io/grpc/netty/NettyReadableBuffer.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -75,11 +60,6 @@ public void readBytes(byte[] dest, int index, int length) {
     buffer.readBytes(dest, index, length);
   }
 
-  @Override
-  public void readBytes(ByteBuffer dest) {
-    buffer.readBytes(dest);
-  }
-
   @Override
   public void readBytes(OutputStream dest, int length) {
     try {
@@ -109,6 +89,36 @@ public int arrayOffset() {
     return buffer.arrayOffset() + buffer.readerIndex();
   }
 
+  @Override
+  public void touch() {
+    buffer.touch();
+  }
+
+  @Override
+  public boolean markSupported() {
+    return true;
+  }
+
+  @Override
+  public void mark() {
+    buffer.markReaderIndex();
+  }
+
+  @Override
+  public void reset() {
+    buffer.resetReaderIndex();
+  }
+
+  @Override
+  public boolean byteBufferSupported() {
+    return buffer.nioBufferCount() > 0;
+  }
+
+  @Override
+  public ByteBuffer getByteBuffer() {
+    return buffer.nioBufferCount() == 1 ? buffer.nioBuffer() : buffer.nioBuffers()[0];
+  }
+
   /**
    * If the first call to close, calls {@link ByteBuf#release} to release the internal Netty buffer.
    */
diff --git a/netty/src/main/java/io/grpc/netty/NettyServer.java b/netty/src/main/java/io/grpc/netty/NettyServer.java
index 9eca274296b..1cf67ea25ca 100644
--- a/netty/src/main/java/io/grpc/netty/NettyServer.java
+++ b/netty/src/main/java/io/grpc/netty/NettyServer.java
@@ -1,207 +1,413 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
 import static com.google.common.base.Preconditions.checkNotNull;
-import static io.netty.channel.ChannelOption.SO_BACKLOG;
+import static io.grpc.netty.NettyServerBuilder.MAX_CONNECTION_AGE_NANOS_DISABLED;
+import static io.netty.channel.ChannelOption.ALLOCATOR;
 import static io.netty.channel.ChannelOption.SO_KEEPALIVE;
 
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.Attributes;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.InternalLogId;
+import io.grpc.InternalWithLogId;
+import io.grpc.ServerStreamTracer;
 import io.grpc.internal.InternalServer;
+import io.grpc.internal.ObjectPool;
 import io.grpc.internal.ServerListener;
 import io.grpc.internal.ServerTransportListener;
-import io.grpc.internal.SharedResourceHolder;
+import io.grpc.internal.TransportTracer;
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.Channel;
+import io.netty.channel.ChannelFactory;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelFutureListener;
 import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelOption;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.EventLoop;
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.ServerChannel;
-import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.channel.group.ChannelGroup;
+import io.netty.channel.group.ChannelGroupFuture;
+import io.netty.channel.group.ChannelGroupFutureListener;
+import io.netty.channel.group.DefaultChannelGroup;
 import io.netty.util.AbstractReferenceCounted;
 import io.netty.util.ReferenceCounted;
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.GenericFutureListener;
 import java.io.IOException;
-import java.net.InetSocketAddress;
 import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import javax.annotation.Nullable;
 
 /**
  * Netty-based server implementation.
  */
-class NettyServer implements InternalServer {
+class NettyServer implements InternalServer, InternalWithLogId {
   private static final Logger log = Logger.getLogger(InternalServer.class.getName());
 
-  private final SocketAddress address;
-  private final Class<? extends ServerChannel> channelType;
+  private final InternalLogId logId;
+  private final List<? extends SocketAddress> addresses;
+  private final ChannelFactory<? extends ServerChannel> channelFactory;
+  private final Map<ChannelOption<?>, ?> channelOptions;
+  private final Map<ChannelOption<?>, ?> childChannelOptions;
   private final ProtocolNegotiator protocolNegotiator;
   private final int maxStreamsPerConnection;
-  private final boolean usingSharedBossGroup;
-  private final boolean usingSharedWorkerGroup;
+  private final ObjectPool<? extends EventLoopGroup> bossGroupPool;
+  private final ObjectPool<? extends EventLoopGroup> workerGroupPool;
+  private final boolean forceHeapBuffer;
   private EventLoopGroup bossGroup;
   private EventLoopGroup workerGroup;
   private ServerListener listener;
-  private Channel channel;
+  private final ChannelGroup channelGroup;
+  private final boolean autoFlowControl;
   private final int flowControlWindow;
   private final int maxMessageSize;
   private final int maxHeaderListSize;
-  private final ReferenceCounted eventLoopReferenceCounter = new EventLoopReferenceCounter();
-
-  NettyServer(SocketAddress address, Class<? extends ServerChannel> channelType,
-              @Nullable EventLoopGroup bossGroup, @Nullable EventLoopGroup workerGroup,
-              ProtocolNegotiator protocolNegotiator, int maxStreamsPerConnection,
-              int flowControlWindow, int maxMessageSize, int maxHeaderListSize) {
-    this.address = address;
-    this.channelType = checkNotNull(channelType, "channelType");
-    this.bossGroup = bossGroup;
-    this.workerGroup = workerGroup;
+  private final int softLimitHeaderListSize;
+  private final long keepAliveTimeInNanos;
+  private final long keepAliveTimeoutInNanos;
+  private final long maxConnectionIdleInNanos;
+  private final long maxConnectionAgeInNanos;
+  private final long maxConnectionAgeGraceInNanos;
+  private final boolean permitKeepAliveWithoutCalls;
+  private final long permitKeepAliveTimeInNanos;
+  private final int maxRstCount;
+  private final long maxRstPeriodNanos;
+  private final Attributes eagAttributes;
+  private final ReferenceCounted sharedResourceReferenceCounter =
+      new SharedResourceReferenceCounter();
+  private final List<? extends ServerStreamTracer.Factory> streamTracerFactories;
+  private final TransportTracer.Factory transportTracerFactory;
+  private final InternalChannelz channelz;
+  private volatile List<InternalInstrumented<SocketStats>> listenSocketStatsList =
+      Collections.emptyList();
+  private volatile boolean terminated;
+  private final EventLoop bossExecutor;
+
+  NettyServer(
+      List<? extends SocketAddress> addresses,
+      ChannelFactory<? extends ServerChannel> channelFactory,
+      Map<ChannelOption<?>, ?> channelOptions,
+      Map<ChannelOption<?>, ?> childChannelOptions,
+      ObjectPool<? extends EventLoopGroup> bossGroupPool,
+      ObjectPool<? extends EventLoopGroup> workerGroupPool,
+      boolean forceHeapBuffer,
+      ProtocolNegotiator protocolNegotiator,
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+      TransportTracer.Factory transportTracerFactory,
+      int maxStreamsPerConnection,
+      boolean autoFlowControl,
+      int flowControlWindow,
+      int maxMessageSize,
+      int maxHeaderListSize,
+      int softLimitHeaderListSize,
+      long keepAliveTimeInNanos,
+      long keepAliveTimeoutInNanos,
+      long maxConnectionIdleInNanos,
+      long maxConnectionAgeInNanos, long maxConnectionAgeGraceInNanos,
+      boolean permitKeepAliveWithoutCalls, long permitKeepAliveTimeInNanos,
+      int maxRstCount, long maxRstPeriodNanos,
+      Attributes eagAttributes, InternalChannelz channelz) {
+    this.addresses = checkNotNull(addresses, "addresses");
+    this.channelFactory = checkNotNull(channelFactory, "channelFactory");
+    checkNotNull(channelOptions, "channelOptions");
+    this.channelOptions = new HashMap<ChannelOption<?>, Object>(channelOptions);
+    checkNotNull(childChannelOptions, "childChannelOptions");
+    this.childChannelOptions = new HashMap<ChannelOption<?>, Object>(childChannelOptions);
+    this.bossGroupPool = checkNotNull(bossGroupPool, "bossGroupPool");
+    this.workerGroupPool = checkNotNull(workerGroupPool, "workerGroupPool");
+    this.forceHeapBuffer = forceHeapBuffer;
+    this.bossGroup = bossGroupPool.getObject();
+    this.bossExecutor = bossGroup.next();
+    this.channelGroup = new DefaultChannelGroup(this.bossExecutor);
+    this.workerGroup = workerGroupPool.getObject();
     this.protocolNegotiator = checkNotNull(protocolNegotiator, "protocolNegotiator");
-    this.usingSharedBossGroup = bossGroup == null;
-    this.usingSharedWorkerGroup = workerGroup == null;
+    this.streamTracerFactories = checkNotNull(streamTracerFactories, "streamTracerFactories");
+    this.transportTracerFactory = transportTracerFactory;
     this.maxStreamsPerConnection = maxStreamsPerConnection;
+    this.autoFlowControl = autoFlowControl;
     this.flowControlWindow = flowControlWindow;
     this.maxMessageSize = maxMessageSize;
     this.maxHeaderListSize = maxHeaderListSize;
+    this.softLimitHeaderListSize = softLimitHeaderListSize;
+    this.keepAliveTimeInNanos = keepAliveTimeInNanos;
+    this.keepAliveTimeoutInNanos = keepAliveTimeoutInNanos;
+    this.maxConnectionIdleInNanos = maxConnectionIdleInNanos;
+    this.maxConnectionAgeInNanos = maxConnectionAgeInNanos;
+    this.maxConnectionAgeGraceInNanos = maxConnectionAgeGraceInNanos;
+    this.permitKeepAliveWithoutCalls = permitKeepAliveWithoutCalls;
+    this.permitKeepAliveTimeInNanos = permitKeepAliveTimeInNanos;
+    this.maxRstCount = maxRstCount;
+    this.maxRstPeriodNanos = maxRstPeriodNanos;
+    this.eagAttributes = checkNotNull(eagAttributes, "eagAttributes");
+    this.channelz = Preconditions.checkNotNull(channelz);
+    this.logId = InternalLogId.allocate(getClass(), addresses.isEmpty() ? "No address" :
+        String.valueOf(addresses));
   }
 
   @Override
-  public int getPort() {
-    if (channel == null) {
-      return -1;
+  public SocketAddress getListenSocketAddress() {
+    Iterator<Channel> it = channelGroup.iterator();
+    if (it.hasNext()) {
+      return it.next().localAddress();
+    } else {
+      // server is not listening/bound yet, just return the original port.
+      return addresses.isEmpty() ? null : addresses.get(0);
     }
-    SocketAddress localAddr = channel.localAddress();
-    if (!(localAddr instanceof InetSocketAddress)) {
-      return -1;
+  }
+
+  @Override
+  public List<SocketAddress> getListenSocketAddresses() {
+    List<SocketAddress> listenSocketAddresses = new ArrayList<>();
+    for (Channel c: channelGroup) {
+      listenSocketAddresses.add(c.localAddress());
     }
-    return ((InetSocketAddress) localAddr).getPort();
+    // server is not listening/bound yet, just return the original ports.
+    if (listenSocketAddresses.isEmpty())  {
+      listenSocketAddresses.addAll(addresses);
+    }
+    return listenSocketAddresses;
+  }
+
+  @Override
+  public InternalInstrumented<SocketStats> getListenSocketStats() {
+    List<InternalInstrumented<SocketStats>> savedListenSocketStatsList = listenSocketStatsList;
+    return savedListenSocketStatsList.isEmpty() ? null : savedListenSocketStatsList.get(0);
+  }
+
+  @Override
+  public List<InternalInstrumented<SocketStats>> getListenSocketStatsList() {
+    return listenSocketStatsList;
   }
 
   @Override
   public void start(ServerListener serverListener) throws IOException {
     listener = checkNotNull(serverListener, "serverListener");
 
-    // If using the shared groups, get references to them.
-    allocateSharedGroups();
+    final ServerBootstrap b = new ServerBootstrap();
+    b.option(ALLOCATOR, Utils.getByteBufAllocator(forceHeapBuffer));
+    b.childOption(ALLOCATOR, Utils.getByteBufAllocator(forceHeapBuffer));
+    b.group(bossExecutor, workerGroup);
+    b.channelFactory(channelFactory);
+    // For non-socket based channel, the option will be ignored.
+    b.childOption(SO_KEEPALIVE, true);
+
+    if (channelOptions != null) {
+      for (Map.Entry<ChannelOption<?>, ?> entry : channelOptions.entrySet()) {
+        @SuppressWarnings("unchecked")
+        ChannelOption<Object> key = (ChannelOption<Object>) entry.getKey();
+        b.option(key, entry.getValue());
+      }
+    }
 
-    ServerBootstrap b = new ServerBootstrap();
-    b.group(bossGroup, workerGroup);
-    b.channel(channelType);
-    if (NioServerSocketChannel.class.isAssignableFrom(channelType)) {
-      b.option(SO_BACKLOG, 128);
-      b.childOption(SO_KEEPALIVE, true);
+    if (childChannelOptions != null) {
+      for (Map.Entry<ChannelOption<?>, ?> entry : childChannelOptions.entrySet()) {
+        @SuppressWarnings("unchecked")
+        ChannelOption<Object> key = (ChannelOption<Object>) entry.getKey();
+        b.childOption(key, entry.getValue());
+      }
     }
+
     b.childHandler(new ChannelInitializer<Channel>() {
       @Override
-      public void initChannel(Channel ch) throws Exception {
-        NettyServerTransport transport = new NettyServerTransport(ch, protocolNegotiator,
-            maxStreamsPerConnection, flowControlWindow, maxMessageSize, maxHeaderListSize);
+      public void initChannel(Channel ch) {
+
+        ChannelPromise channelDone = ch.newPromise();
+
+        long maxConnectionAgeInNanos = NettyServer.this.maxConnectionAgeInNanos;
+        if (maxConnectionAgeInNanos != MAX_CONNECTION_AGE_NANOS_DISABLED) {
+          // apply a random jitter of +/-10% to max connection age
+          maxConnectionAgeInNanos =
+              (long) ((.9D + Math.random() * .2D) * maxConnectionAgeInNanos);
+        }
+
+            NettyServerTransport transport =
+                new NettyServerTransport(
+                    ch,
+                    channelDone,
+                    protocolNegotiator,
+                    streamTracerFactories,
+                    transportTracerFactory.create(),
+                    maxStreamsPerConnection,
+                    autoFlowControl,
+                    flowControlWindow,
+                    maxMessageSize,
+                    maxHeaderListSize,
+                    softLimitHeaderListSize,
+                    keepAliveTimeInNanos,
+                    keepAliveTimeoutInNanos,
+                    maxConnectionIdleInNanos,
+                    maxConnectionAgeInNanos,
+                    maxConnectionAgeGraceInNanos,
+                    permitKeepAliveWithoutCalls,
+                    permitKeepAliveTimeInNanos,
+                    maxRstCount,
+                    maxRstPeriodNanos,
+                    eagAttributes);
         ServerTransportListener transportListener;
         // This is to order callbacks on the listener, not to guard access to channel.
         synchronized (NettyServer.this) {
-          if (channel != null && !channel.isOpen()) {
-            // Server already shutdown.
+          if (terminated) {
+            // Server already terminated.
             ch.close();
             return;
           }
           // `channel` shutdown can race with `ch` initialization, so this is only safe to increment
           // inside the lock.
-          eventLoopReferenceCounter.retain();
+          sharedResourceReferenceCounter.retain();
           transportListener = listener.transportCreated(transport);
         }
-        transport.start(transportListener);
-        ch.closeFuture().addListener(new ChannelFutureListener() {
+
+        /* Releases the event loop if the channel is "done", possibly due to the channel closing. */
+        final class LoopReleaser implements ChannelFutureListener {
+          private boolean done;
+
           @Override
-          public void operationComplete(ChannelFuture future) {
-            eventLoopReferenceCounter.release();
+          public void operationComplete(ChannelFuture future) throws Exception {
+            if (!done) {
+              done = true;
+              sharedResourceReferenceCounter.release();
+            }
           }
-        });
+        }
+
+        transport.start(transportListener);
+        ChannelFutureListener loopReleaser = new LoopReleaser();
+        channelDone.addListener(loopReleaser);
+        ch.closeFuture().addListener(loopReleaser);
       }
     });
-    // Bind and start to accept incoming connections.
-    ChannelFuture future = b.bind(address);
-    try {
-      future.await();
-    } catch (InterruptedException ex) {
-      Thread.currentThread().interrupt();
-      throw new RuntimeException("Interrupted waiting for bind");
+    Future<Map<ChannelFuture, SocketAddress>> bindCallFuture =
+        bossExecutor.submit(
+            new Callable<Map<ChannelFuture, SocketAddress>>() {
+          @Override
+          public Map<ChannelFuture, SocketAddress> call() {
+            Map<ChannelFuture, SocketAddress> bindFutures = new HashMap<>();
+            for (SocketAddress address: addresses) {
+                ChannelFuture future = b.bind(address);
+                channelGroup.add(future.channel());
+                bindFutures.put(future, address);
+            }
+            return bindFutures;
+          }
+        }
+    );
+    Map<ChannelFuture, SocketAddress> channelFutures =
+        bindCallFuture.awaitUninterruptibly().getNow();
+
+    if (!bindCallFuture.isSuccess()) {
+      channelGroup.close().awaitUninterruptibly();
+      throw new IOException(String.format("Failed to bind to addresses %s",
+          addresses), bindCallFuture.cause());
     }
-    if (!future.isSuccess()) {
-      throw new IOException("Failed to bind", future.cause());
+    final List<InternalInstrumented<SocketStats>> socketStats = new ArrayList<>();
+    for (Map.Entry<ChannelFuture, SocketAddress> entry: channelFutures.entrySet()) {
+      // We'd love to observe interruption, but if interrupted we will need to close the channel,
+      // which itself would need an await() to guarantee the port is not used when the method
+      // returns. See #6850
+      final ChannelFuture future = entry.getKey();
+      if (!future.awaitUninterruptibly().isSuccess()) {
+        channelGroup.close().awaitUninterruptibly();
+        throw new IOException(String.format("Failed to bind to address %s",
+            entry.getValue()), future.cause());
+      }
+      final InternalInstrumented<SocketStats> listenSocketStats =
+          new ListenSocket(future.channel());
+      channelz.addListenSocket(listenSocketStats);
+      socketStats.add(listenSocketStats);
+      future.channel().closeFuture().addListener(new ChannelFutureListener() {
+        @Override
+        public void operationComplete(ChannelFuture future) throws Exception {
+          channelz.removeListenSocket(listenSocketStats);
+        }
+      });
     }
-    channel = future.channel();
+    listenSocketStatsList = Collections.unmodifiableList(socketStats);
   }
 
   @Override
   public void shutdown() {
-    if (channel == null || !channel.isOpen()) {
-      // Already closed.
+    if (terminated) {
       return;
     }
-    channel.close().addListener(new ChannelFutureListener() {
-      @Override
-      public void operationComplete(ChannelFuture future) throws Exception {
-        if (!future.isSuccess()) {
-          log.log(Level.WARNING, "Error shutting down server", future.cause());
-        }
-        synchronized (NettyServer.this) {
-          listener.serverShutdown();
-        }
-        eventLoopReferenceCounter.release();
-      }
-    });
+    ChannelGroupFuture groupFuture = channelGroup.close()
+        .addListener(new ChannelGroupFutureListener() {
+            @Override
+            public void operationComplete(ChannelGroupFuture future) throws Exception {
+              if (!future.isSuccess()) {
+                log.log(Level.WARNING, "Error closing server channel group", future.cause());
+              }
+              sharedResourceReferenceCounter.release();
+              protocolNegotiator.close();
+              listenSocketStatsList = Collections.emptyList();
+              synchronized (NettyServer.this) {
+                listener.serverShutdown();
+                terminated = true;
+              }
+            }
+        });
+    try {
+      groupFuture.await();
+    } catch (InterruptedException e) {
+      log.log(Level.FINE, "Interrupted while shutting down", e);
+      Thread.currentThread().interrupt();
+    }
   }
 
-  private void allocateSharedGroups() {
-    if (bossGroup == null) {
-      bossGroup = SharedResourceHolder.get(Utils.DEFAULT_BOSS_EVENT_LOOP_GROUP);
-    }
-    if (workerGroup == null) {
-      workerGroup = SharedResourceHolder.get(Utils.DEFAULT_WORKER_EVENT_LOOP_GROUP);
-    }
+  @Override
+  public InternalLogId getLogId() {
+    return logId;
   }
 
-  class EventLoopReferenceCounter extends AbstractReferenceCounted {
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("logId", logId.getId())
+        .add("addresses", addresses)
+        .toString();
+  }
+
+  class SharedResourceReferenceCounter extends AbstractReferenceCounted {
     @Override
     protected void deallocate() {
       try {
-        if (usingSharedBossGroup && bossGroup != null) {
-          SharedResourceHolder.release(Utils.DEFAULT_BOSS_EVENT_LOOP_GROUP, bossGroup);
+        if (bossGroup != null) {
+          bossGroupPool.returnObject(bossGroup);
         }
       } finally {
         bossGroup = null;
         try {
-          if (usingSharedWorkerGroup && workerGroup != null) {
-            SharedResourceHolder.release(Utils.DEFAULT_WORKER_EVENT_LOOP_GROUP, workerGroup);
+          if (workerGroup != null) {
+            workerGroupPool.returnObject(workerGroup);
           }
         } finally {
           workerGroup = null;
@@ -214,4 +420,69 @@ public ReferenceCounted touch(Object hint) {
       return this;
     }
   }
+
+  /**
+   * A class that can answer channelz queries about the server listen sockets.
+   */
+  private static final class ListenSocket implements InternalInstrumented<SocketStats> {
+    private final InternalLogId id;
+    private final Channel ch;
+
+    ListenSocket(Channel ch) {
+      this.ch = ch;
+      this.id = InternalLogId.allocate(getClass(), String.valueOf(ch.localAddress()));
+    }
+
+    @Override
+    public ListenableFuture<SocketStats> getStats() {
+      final SettableFuture<SocketStats> ret = SettableFuture.create();
+      if (ch.eventLoop().inEventLoop()) {
+        // This is necessary, otherwise we will block forever if we get the future from inside
+        // the event loop.
+        ret.set(new SocketStats(
+            /*data=*/ null,
+            ch.localAddress(),
+            /*remote=*/ null,
+            Utils.getSocketOptions(ch),
+            /*security=*/ null));
+        return ret;
+      }
+      ch.eventLoop()
+          .submit(
+              new Runnable() {
+                @Override
+                public void run() {
+                  ret.set(new SocketStats(
+                      /*data=*/ null,
+                      ch.localAddress(),
+                      /*remote=*/ null,
+                      Utils.getSocketOptions(ch),
+                      /*security=*/ null));
+                }
+              })
+          .addListener(
+              new GenericFutureListener<Future<Object>>() {
+                @Override
+                public void operationComplete(Future<Object> future) throws Exception {
+                  if (!future.isSuccess()) {
+                    ret.setException(future.cause());
+                  }
+                }
+              });
+      return ret;
+    }
+
+    @Override
+    public InternalLogId getLogId() {
+      return id;
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("logId", id.getId())
+          .add("channel", ch)
+          .toString();
+    }
+  }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NettyServerBuilder.java b/netty/src/main/java/io/grpc/netty/NettyServerBuilder.java
index fae56650d96..eb3a6d9b538 100644
--- a/netty/src/main/java/io/grpc/netty/NettyServerBuilder.java
+++ b/netty/src/main/java/io/grpc/netty/NettyServerBuilder.java
@@ -1,76 +1,121 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
 import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
 import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
+import static io.grpc.internal.GrpcUtil.DEFAULT_SERVER_KEEPALIVE_TIMEOUT_NANOS;
+import static io.grpc.internal.GrpcUtil.DEFAULT_SERVER_KEEPALIVE_TIME_NANOS;
+import static io.grpc.internal.GrpcUtil.SERVER_KEEPALIVE_TIME_NANOS_DISABLED;
 
-import com.google.common.base.Preconditions;
+import com.google.common.annotations.VisibleForTesting;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.CheckReturnValue;
+import com.google.errorprone.annotations.InlineMe;
+import io.grpc.Attributes;
 import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingServerBuilder;
 import io.grpc.Internal;
-import io.grpc.internal.AbstractServerImplBuilder;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCredentials;
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.FixedObjectPool;
 import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.KeepAliveManager;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.ServerImplBuilder;
+import io.grpc.internal.ServerImplBuilder.ClientTransportServersBuilder;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.internal.TransportTracer;
+import io.netty.channel.ChannelFactory;
+import io.netty.channel.ChannelOption;
 import io.netty.channel.EventLoopGroup;
+import io.netty.channel.ReflectiveChannelFactory;
 import io.netty.channel.ServerChannel;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.handler.ssl.SslContext;
 import java.io.File;
+import java.io.InputStream;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
-import javax.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
 import javax.net.ssl.SSLException;
 
 /**
  * A builder to help simplify the construction of a Netty-based GRPC server.
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1784")
-@CanIgnoreReturnValue
-public final class NettyServerBuilder extends AbstractServerImplBuilder<NettyServerBuilder> {
-  public static final int DEFAULT_FLOW_CONTROL_WINDOW = 1048576; // 1MiB
-
-  private final SocketAddress address;
-  private Class<? extends ServerChannel> channelType = NioServerSocketChannel.class;
-  @Nullable
-  private EventLoopGroup bossEventLoopGroup;
-  @Nullable
-  private EventLoopGroup workerEventLoopGroup;
-  private SslContext sslContext;
-  private ProtocolNegotiator protocolNegotiator;
+@CheckReturnValue
+public final class NettyServerBuilder extends ForwardingServerBuilder<NettyServerBuilder> {
+
+  // 1MiB
+  public static final int DEFAULT_FLOW_CONTROL_WINDOW = 1024 * 1024;
+
+  static final long MAX_CONNECTION_IDLE_NANOS_DISABLED = Long.MAX_VALUE;
+  static final long MAX_CONNECTION_AGE_NANOS_DISABLED = Long.MAX_VALUE;
+  static final long MAX_CONNECTION_AGE_GRACE_NANOS_INFINITE = Long.MAX_VALUE;
+  static final int MAX_RST_COUNT_DISABLED = 0;
+
+  private static final long MIN_MAX_CONNECTION_IDLE_NANO = TimeUnit.SECONDS.toNanos(1L);
+  private static final long MIN_MAX_CONNECTION_AGE_NANO = TimeUnit.SECONDS.toNanos(1L);
+  private static final long AS_LARGE_AS_INFINITE = TimeUnit.DAYS.toNanos(1000L);
+  private static final ObjectPool<? extends EventLoopGroup> DEFAULT_BOSS_EVENT_LOOP_GROUP_POOL =
+      SharedResourcePool.forResource(Utils.DEFAULT_BOSS_EVENT_LOOP_GROUP);
+  private static final ObjectPool<? extends EventLoopGroup> DEFAULT_WORKER_EVENT_LOOP_GROUP_POOL =
+      SharedResourcePool.forResource(Utils.DEFAULT_WORKER_EVENT_LOOP_GROUP);
+
+  private final ServerImplBuilder serverImplBuilder;
+  private final List<SocketAddress> listenAddresses = new ArrayList<>();
+
+  private TransportTracer.Factory transportTracerFactory = TransportTracer.getDefaultFactory();
+  private ChannelFactory<? extends ServerChannel> channelFactory =
+      Utils.DEFAULT_SERVER_CHANNEL_FACTORY;
+  private final Map<ChannelOption<?>, Object> channelOptions = new HashMap<>();
+  private final Map<ChannelOption<?>, Object> childChannelOptions = new HashMap<>();
+  private ObjectPool<? extends EventLoopGroup> bossEventLoopGroupPool =
+      DEFAULT_BOSS_EVENT_LOOP_GROUP_POOL;
+  private ObjectPool<? extends EventLoopGroup> workerEventLoopGroupPool =
+      DEFAULT_WORKER_EVENT_LOOP_GROUP_POOL;
+  private boolean forceHeapBuffer;
+  private ProtocolNegotiator.ServerFactory protocolNegotiatorFactory;
+  private final boolean freezeProtocolNegotiatorFactory;
   private int maxConcurrentCallsPerConnection = Integer.MAX_VALUE;
+  private boolean autoFlowControl = true;
   private int flowControlWindow = DEFAULT_FLOW_CONTROL_WINDOW;
   private int maxMessageSize = DEFAULT_MAX_MESSAGE_SIZE;
   private int maxHeaderListSize = GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE;
+  private int softLimitHeaderListSize = GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE;
+  private long keepAliveTimeInNanos = DEFAULT_SERVER_KEEPALIVE_TIME_NANOS;
+  private long keepAliveTimeoutInNanos = DEFAULT_SERVER_KEEPALIVE_TIMEOUT_NANOS;
+  private long maxConnectionIdleInNanos = MAX_CONNECTION_IDLE_NANOS_DISABLED;
+  private long maxConnectionAgeInNanos = MAX_CONNECTION_AGE_NANOS_DISABLED;
+  private long maxConnectionAgeGraceInNanos = MAX_CONNECTION_AGE_GRACE_NANOS_INFINITE;
+  private boolean permitKeepAliveWithoutCalls;
+  private long permitKeepAliveTimeInNanos = TimeUnit.MINUTES.toNanos(5);
+  private int maxRstCount;
+  private long maxRstPeriodNanos;
+  private Attributes eagAttributes = Attributes.EMPTY;
 
   /**
    * Creates a server builder that will bind to the given port.
@@ -78,9 +123,18 @@ public final class NettyServerBuilder extends AbstractServerImplBuilder<NettySer
    * @param port the port on which the server is to be bound.
    * @return the server builder.
    */
-  @CheckReturnValue
   public static NettyServerBuilder forPort(int port) {
-    return new NettyServerBuilder(port);
+    return forAddress(new InetSocketAddress(port));
+  }
+
+  /**
+   * Creates a server builder that will bind to the given port.
+   *
+   * @param port the port on which the server is to be bound.
+   * @return the server builder.
+   */
+  public static NettyServerBuilder forPort(int port, ServerCredentials creds) {
+    return forAddress(new InetSocketAddress(port), creds);
   }
 
   /**
@@ -89,26 +143,125 @@ public static NettyServerBuilder forPort(int port) {
    * @param address the socket address on which the server is to be bound.
    * @return the server builder
    */
-  @CheckReturnValue
   public static NettyServerBuilder forAddress(SocketAddress address) {
     return new NettyServerBuilder(address);
   }
 
-  @CheckReturnValue
-  private NettyServerBuilder(int port) {
-    this.address = new InetSocketAddress(port);
+  /**
+   * Creates a server builder configured with the given {@link SocketAddress}.
+   *
+   * @param address the socket address on which the server is to be bound.
+   * @return the server builder
+   */
+  public static NettyServerBuilder forAddress(SocketAddress address, ServerCredentials creds) {
+    ProtocolNegotiators.FromServerCredentialsResult result = ProtocolNegotiators.from(creds);
+    if (result.error != null) {
+      throw new IllegalArgumentException(result.error);
+    }
+    return new NettyServerBuilder(address, result.negotiator);
+  }
+
+  private final class NettyClientTransportServersBuilder implements ClientTransportServersBuilder {
+    @Override
+    public InternalServer buildClientTransportServers(
+        List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+      return buildTransportServers(streamTracerFactories);
+    }
   }
 
-  @CheckReturnValue
   private NettyServerBuilder(SocketAddress address) {
-    this.address = address;
+    serverImplBuilder = new ServerImplBuilder(new NettyClientTransportServersBuilder());
+    this.listenAddresses.add(address);
+    this.protocolNegotiatorFactory = ProtocolNegotiators.serverPlaintextFactory();
+    this.freezeProtocolNegotiatorFactory = false;
+  }
+
+  NettyServerBuilder(SocketAddress address, ProtocolNegotiator.ServerFactory negotiatorFactory) {
+    serverImplBuilder = new ServerImplBuilder(new NettyClientTransportServersBuilder());
+    this.listenAddresses.add(address);
+    this.protocolNegotiatorFactory = checkNotNull(negotiatorFactory, "negotiatorFactory");
+    this.freezeProtocolNegotiatorFactory = true;
+  }
+
+  @Internal
+  @Override
+  protected ServerBuilder<?> delegate() {
+    return serverImplBuilder;
   }
 
   /**
-   * Specify the channel type to use, by default we use {@link NioServerSocketChannel}.
+   * Adds an additional address for this server to listen on.  Callers must ensure that all socket
+   * addresses are compatible with the Netty channel type, and that they don't conflict with each
+   * other.
    */
+  @CanIgnoreReturnValue
+  public NettyServerBuilder addListenAddress(SocketAddress listenAddress) {
+    this.listenAddresses.add(checkNotNull(listenAddress, "listenAddress"));
+    return this;
+  }
+
+  /**
+   * Specifies the channel type to use, by default we use {@code EpollServerSocketChannel} if
+   * available, otherwise using {@link NioServerSocketChannel}.
+   *
+   * <p>You either use this or {@link #channelFactory(io.netty.channel.ChannelFactory)} if your
+   * {@link ServerChannel} implementation has no no-args constructor.
+   *
+   * <p>It's an optional parameter. If the user has not provided an Channel type or ChannelFactory
+   * when the channel is built, the builder will use the default one which is static.
+   *
+   * <p>You must also provide corresponding {@link EventLoopGroup} using {@link
+   * #workerEventLoopGroup(EventLoopGroup)} and {@link #bossEventLoopGroup(EventLoopGroup)}. For
+   * example, {@link NioServerSocketChannel} must use {@link
+   * io.netty.channel.nio.NioEventLoopGroup}, otherwise your server won't start.
+   */
+  @CanIgnoreReturnValue
   public NettyServerBuilder channelType(Class<? extends ServerChannel> channelType) {
-    this.channelType = Preconditions.checkNotNull(channelType, "channelType");
+    checkNotNull(channelType, "channelType");
+    return channelFactory(new ReflectiveChannelFactory<>(channelType));
+  }
+
+  /**
+   * Specifies the {@link ChannelFactory} to create {@link ServerChannel} instances. This method is
+   * usually only used if the specific {@code ServerChannel} requires complex logic which requires
+   * additional information to create the {@code ServerChannel}. Otherwise, recommend to use {@link
+   * #channelType(Class)}.
+   *
+   * <p>It's an optional parameter. If the user has not provided an Channel type or ChannelFactory
+   * when the channel is built, the builder will use the default one which is static.
+   *
+   * <p>You must also provide corresponding {@link EventLoopGroup} using {@link
+   * #workerEventLoopGroup(EventLoopGroup)} and {@link #bossEventLoopGroup(EventLoopGroup)}. For
+   * example, if the factory creates {@link NioServerSocketChannel} you must use {@link
+   * io.netty.channel.nio.NioEventLoopGroup}, otherwise your server won't start.
+   */
+  @CanIgnoreReturnValue
+  public NettyServerBuilder channelFactory(ChannelFactory<? extends ServerChannel> channelFactory) {
+    this.channelFactory = checkNotNull(channelFactory, "channelFactory");
+    return this;
+  }
+
+  /**
+   * Specifies a channel option. As the underlying channel as well as network implementation may
+   * ignore this value applications should consider it a hint.
+   *
+   * @since 1.30.0
+   */
+  @CanIgnoreReturnValue
+  public <T> NettyServerBuilder withOption(ChannelOption<T> option, T value) {
+    this.channelOptions.put(option, value);
+    return this;
+  }
+
+  /**
+   * Specifies a child channel option. As the underlying channel as well as network implementation
+   * may ignore this value applications should consider it a hint.
+   *
+   * @since 1.9.0
+   */
+  @CanIgnoreReturnValue
+  public <T> NettyServerBuilder withChildOption(ChannelOption<T> option, T value) {
+    this.childChannelOptions.put(option, value);
     return this;
   }
 
@@ -118,6 +271,11 @@ public NettyServerBuilder channelType(Class<? extends ServerChannel> channelType
    * <p>It's an optional parameter. If the user has not provided one when the server is built, the
    * builder will use the default one which is static.
    *
+   * <p>You must also provide corresponding {@link io.netty.channel.Channel} type using {@link
+   * #channelType(Class)} and {@link #workerEventLoopGroup(EventLoopGroup)}. For example, {@link
+   * NioServerSocketChannel} must use {@link io.netty.channel.nio.NioEventLoopGroup} for both boss
+   * and worker {@link EventLoopGroup}, otherwise your server won't start.
+   *
    * <p>The server won't take ownership of the given EventLoopGroup. It's caller's responsibility
    * to shut it down when it's desired.
    *
@@ -130,8 +288,18 @@ public NettyServerBuilder channelType(Class<? extends ServerChannel> channelType
    * A simple solution to this problem is to call {@link io.grpc.Server#awaitTermination()} to
    * keep the main thread alive until the server has terminated.
    */
+  @CanIgnoreReturnValue
   public NettyServerBuilder bossEventLoopGroup(EventLoopGroup group) {
-    this.bossEventLoopGroup = group;
+    if (group != null) {
+      return bossEventLoopGroupPool(new FixedObjectPool<>(group));
+    }
+    return bossEventLoopGroupPool(DEFAULT_BOSS_EVENT_LOOP_GROUP_POOL);
+  }
+
+  @CanIgnoreReturnValue
+  NettyServerBuilder bossEventLoopGroupPool(
+      ObjectPool<? extends EventLoopGroup> bossEventLoopGroupPool) {
+    this.bossEventLoopGroupPool = checkNotNull(bossEventLoopGroupPool, "bossEventLoopGroupPool");
     return this;
   }
 
@@ -141,6 +309,11 @@ public NettyServerBuilder bossEventLoopGroup(EventLoopGroup group) {
    * <p>It's an optional parameter. If the user has not provided one when the server is built, the
    * builder will create one.
    *
+   * <p>You must also provide corresponding {@link io.netty.channel.Channel} type using {@link
+   * #channelType(Class)} and {@link #bossEventLoopGroup(EventLoopGroup)}. For example, {@link
+   * NioServerSocketChannel} must use {@link io.netty.channel.nio.NioEventLoopGroup} for both boss
+   * and worker {@link EventLoopGroup}, otherwise your server won't start.
+   *
    * <p>The server won't take ownership of the given EventLoopGroup. It's caller's responsibility
    * to shut it down when it's desired.
    *
@@ -153,42 +326,82 @@ public NettyServerBuilder bossEventLoopGroup(EventLoopGroup group) {
    * A simple solution to this problem is to call {@link io.grpc.Server#awaitTermination()} to
    * keep the main thread alive until the server has terminated.
    */
+  @CanIgnoreReturnValue
   public NettyServerBuilder workerEventLoopGroup(EventLoopGroup group) {
-    this.workerEventLoopGroup = group;
+    if (group != null) {
+      return workerEventLoopGroupPool(new FixedObjectPool<>(group));
+    }
+    return workerEventLoopGroupPool(DEFAULT_WORKER_EVENT_LOOP_GROUP_POOL);
+  }
+
+  @CanIgnoreReturnValue
+  NettyServerBuilder workerEventLoopGroupPool(
+      ObjectPool<? extends EventLoopGroup> workerEventLoopGroupPool) {
+    this.workerEventLoopGroupPool =
+        checkNotNull(workerEventLoopGroupPool, "workerEventLoopGroupPool");
     return this;
   }
 
+  /**
+   * Force using heap buffer when custom allocator is enabled.
+   */
+  void setForceHeapBuffer(boolean value) {
+    forceHeapBuffer = value;
+  }
+
   /**
    * Sets the TLS context to use for encryption. Providing a context enables encryption. It must
    * have been configured with {@link GrpcSslContexts}, but options could have been overridden.
    */
+  @CanIgnoreReturnValue
   public NettyServerBuilder sslContext(SslContext sslContext) {
+    checkState(!freezeProtocolNegotiatorFactory,
+               "Cannot change security when using ServerCredentials");
     if (sslContext != null) {
       checkArgument(sslContext.isServer(),
           "Client SSL context can not be used for server");
       GrpcSslContexts.ensureAlpnAndH2Enabled(sslContext.applicationProtocolNegotiator());
+      protocolNegotiatorFactory = ProtocolNegotiators.serverTlsFactory(sslContext);
+    } else {
+      protocolNegotiatorFactory = ProtocolNegotiators.serverPlaintextFactory();
     }
-    this.sslContext = sslContext;
     return this;
   }
 
   /**
-   * Sets the {@link ProtocolNegotiator} to be used. If non-{@code null}, overrides the value
-   * specified in {@link #sslContext(SslContext)}.
-   *
-   * <p>Default: {@code null}.
+   * Sets the {@link ProtocolNegotiator} to be used. Overrides the value specified in {@link
+   * #sslContext(SslContext)}.
    */
+  @CanIgnoreReturnValue
   @Internal
-  public final NettyServerBuilder protocolNegotiator(
-          @Nullable ProtocolNegotiator protocolNegotiator) {
-    this.protocolNegotiator = protocolNegotiator;
+  public final NettyServerBuilder protocolNegotiator(ProtocolNegotiator protocolNegotiator) {
+    checkState(!freezeProtocolNegotiatorFactory,
+               "Cannot change security when using ServerCredentials");
+    this.protocolNegotiatorFactory = ProtocolNegotiators.fixedServerFactory(protocolNegotiator);
     return this;
   }
 
+  void setTracingEnabled(boolean value) {
+    this.serverImplBuilder.setTracingEnabled(value);
+  }
+
+  void setStatsEnabled(boolean value) {
+    this.serverImplBuilder.setStatsEnabled(value);
+  }
+
+  void setStatsRecordStartedRpcs(boolean value) {
+    this.serverImplBuilder.setStatsRecordStartedRpcs(value);
+  }
+
+  void setStatsRecordRealTimeMetrics(boolean value) {
+    this.serverImplBuilder.setStatsRecordRealTimeMetrics(value);
+  }
+
   /**
    * The maximum number of concurrent calls permitted for each incoming connection. Defaults to no
    * limit.
    */
+  @CanIgnoreReturnValue
   public NettyServerBuilder maxConcurrentCallsPerConnection(int maxCalls) {
     checkArgument(maxCalls > 0, "max must be positive: %s", maxCalls);
     this.maxConcurrentCallsPerConnection = maxCalls;
@@ -196,12 +409,31 @@ public NettyServerBuilder maxConcurrentCallsPerConnection(int maxCalls) {
   }
 
   /**
-   * Sets the HTTP/2 flow control window. If not called, the default value
-   * is {@link #DEFAULT_FLOW_CONTROL_WINDOW}).
+   * Sets the initial flow control window in bytes. Setting initial flow control window enables auto
+   * flow control tuning using bandwidth-delay product algorithm. To disable auto flow control
+   * tuning, use {@link #flowControlWindow(int)}. By default, auto flow control is enabled with
+   * initial flow control window size of {@link #DEFAULT_FLOW_CONTROL_WINDOW}.
+   */
+  @CanIgnoreReturnValue
+  public NettyServerBuilder initialFlowControlWindow(int initialFlowControlWindow) {
+    checkArgument(initialFlowControlWindow > 0, "initialFlowControlWindow must be positive");
+    this.flowControlWindow = initialFlowControlWindow;
+    this.autoFlowControl = true;
+    return this;
+  }
+
+  /**
+   * Sets the flow control window in bytes. Setting flowControlWindow disables auto flow control
+   * tuning; use {@link #initialFlowControlWindow(int)} to enable auto flow control tuning. If not
+   * called, the default value is {@link #DEFAULT_FLOW_CONTROL_WINDOW}) with auto flow control
+   * tuning.
    */
+  @CanIgnoreReturnValue
   public NettyServerBuilder flowControlWindow(int flowControlWindow) {
-    checkArgument(flowControlWindow > 0, "flowControlWindow must be positive");
+    checkArgument(flowControlWindow > 0, "flowControlWindow must be positive: %s",
+        flowControlWindow);
     this.flowControlWindow = flowControlWindow;
+    this.autoFlowControl = false;
     return this;
   }
 
@@ -210,44 +442,353 @@ public NettyServerBuilder flowControlWindow(int flowControlWindow) {
    * defaults to 4 MiB. The default provides protection to services who haven't considered the
    * possibility of receiving large messages while trying to be large enough to not be hit in normal
    * usage.
+   *
+   * @deprecated Call {@link #maxInboundMessageSize} instead. This method will be removed in a
+   *     future release.
    */
+  @CanIgnoreReturnValue
+  @Deprecated
+  @InlineMe(replacement = "this.maxInboundMessageSize(maxMessageSize)")
   public NettyServerBuilder maxMessageSize(int maxMessageSize) {
-    checkArgument(maxMessageSize >= 0, "maxMessageSize must be >= 0");
-    this.maxMessageSize = maxMessageSize;
+    return maxInboundMessageSize(maxMessageSize);
+  }
+
+  /** {@inheritDoc} */
+  @CanIgnoreReturnValue
+  @Override
+  public NettyServerBuilder maxInboundMessageSize(int bytes) {
+    checkArgument(bytes >= 0, "bytes must be non-negative: %s", bytes);
+    this.maxMessageSize = bytes;
     return this;
   }
 
   /**
-   * Sets the maximum size of header list allowed to be received on the server. If not called,
-   * defaults to {@link GrpcUtil#DEFAULT_MAX_HEADER_LIST_SIZE}.
+   * Sets the maximum size of header list allowed to be received. This is cumulative size of the
+   * headers with some overhead, as defined for
+   * <a href="http://httpwg.org/specs/rfc7540.html#rfc.section.6.5.2">
+   * HTTP/2's SETTINGS_MAX_HEADER_LIST_SIZE</a>. The default is 8 KiB.
+   *
+   * @deprecated Use {@link #maxInboundMetadataSize} instead
    */
+  @CanIgnoreReturnValue
+  @Deprecated
+  @InlineMe(replacement = "this.maxInboundMetadataSize(maxHeaderListSize)")
   public NettyServerBuilder maxHeaderListSize(int maxHeaderListSize) {
-    checkArgument(maxHeaderListSize > 0, "maxHeaderListSize must be > 0");
-    this.maxHeaderListSize = maxHeaderListSize;
+    return maxInboundMetadataSize(maxHeaderListSize);
+  }
+
+  /**
+   * Sets the maximum size of metadata allowed to be received. This is cumulative size of the
+   * entries with some overhead, as defined for
+   * <a href="http://httpwg.org/specs/rfc7540.html#rfc.section.6.5.2">
+   * HTTP/2's SETTINGS_MAX_HEADER_LIST_SIZE</a>. The default is 8 KiB.
+   *
+   * @param bytes the maximum size of received metadata
+   * @return this
+   * @throws IllegalArgumentException if bytes is non-positive
+   * @since 1.17.0
+   */
+  @CanIgnoreReturnValue
+  @Override
+  public NettyServerBuilder maxInboundMetadataSize(int bytes) {
+    checkArgument(bytes > 0, "maxInboundMetadataSize must be positive: %s", bytes);
+    this.maxHeaderListSize = bytes;
+    // Clear the soft limit setting, by setting soft limit to maxInboundMetadataSize. The
+    // maxInboundMetadataSize will take precedence over soft limit check.
+    this.softLimitHeaderListSize = bytes;
+    return this;
+  }
+
+  /**
+   * Sets the size of metadata that clients are advised to not exceed. When a metadata with size
+   * larger than the soft limit is encountered there will be a probability the RPC will fail. The
+   * chance of failing increases as the metadata size approaches the hard limit.
+   * {@code Integer.MAX_VALUE} disables the enforcement. The default is implementation-dependent,
+   * but is not generally less than 8 KiB and may be unlimited.
+   *
+   * <p>This is cumulative size of the metadata. The precise calculation is
+   * implementation-dependent, but implementations are encouraged to follow the calculation used
+   * for
+   * <a href="http://httpwg.org/specs/rfc7540.html#rfc.section.6.5.2">HTTP/2's
+   * SETTINGS_MAX_HEADER_LIST_SIZE</a>. It sums the bytes from each entry's key and value, plus 32
+   * bytes of overhead per entry.
+   *
+   * @param soft the soft size limit of received metadata
+   * @param max the hard size limit of received metadata
+   * @return this
+   * @throws IllegalArgumentException if soft and/or max is non-positive, or max smaller than soft
+   * @since 1.68.0
+   */
+  @CanIgnoreReturnValue
+  public NettyServerBuilder maxInboundMetadataSize(int soft, int max) {
+    checkArgument(soft > 0, "softLimitHeaderListSize must be positive: %s", soft);
+    checkArgument(max > soft,
+        "maxInboundMetadataSize: %s must be greater than softLimitHeaderListSize: %s", max, soft);
+    this.softLimitHeaderListSize = soft;
+    this.maxHeaderListSize = max;
+    return this;
+  }
+
+  /**
+   * Sets a custom keepalive time, the delay time for sending next keepalive ping. An unreasonably
+   * small value might be increased, and {@code Long.MAX_VALUE} nano seconds or an unreasonably
+   * large value will disable keepalive.
+   *
+   * @since 1.3.0
+   */
+  @CanIgnoreReturnValue
+  @Override
+  public NettyServerBuilder keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    checkArgument(keepAliveTime > 0L, "keepalive time must be positive：%s", keepAliveTime);
+    keepAliveTimeInNanos = timeUnit.toNanos(keepAliveTime);
+    keepAliveTimeInNanos = KeepAliveManager.clampKeepAliveTimeInNanos(keepAliveTimeInNanos);
+    if (keepAliveTimeInNanos >= AS_LARGE_AS_INFINITE) {
+      // Bump keepalive time to infinite. This disables keep alive.
+      keepAliveTimeInNanos = SERVER_KEEPALIVE_TIME_NANOS_DISABLED;
+    }
+    return this;
+  }
+
+  /**
+   * Sets a custom keepalive timeout, the timeout for keepalive ping requests. An unreasonably small
+   * value might be increased.
+   *
+   * @since 1.3.0
+   */
+  @CanIgnoreReturnValue
+  @Override
+  public NettyServerBuilder keepAliveTimeout(long keepAliveTimeout, TimeUnit timeUnit) {
+    checkArgument(keepAliveTimeout > 0L, "keepalive timeout must be positive: %s",
+        keepAliveTimeout);
+    keepAliveTimeoutInNanos = timeUnit.toNanos(keepAliveTimeout);
+    keepAliveTimeoutInNanos =
+        KeepAliveManager.clampKeepAliveTimeoutInNanos(keepAliveTimeoutInNanos);
     return this;
   }
 
+  /**
+   * Sets a custom max connection idle time, connection being idle for longer than which will be
+   * gracefully terminated. Idleness duration is defined since the most recent time the number of
+   * outstanding RPCs became zero or the connection establishment. An unreasonably small value might
+   * be increased. {@code Long.MAX_VALUE} nano seconds or an unreasonably large value will disable
+   * max connection idle.
+   *
+   * @since 1.4.0
+   */
+  @CanIgnoreReturnValue
   @Override
-  @CheckReturnValue
-  protected NettyServer buildTransportServer() {
-    ProtocolNegotiator negotiator = protocolNegotiator;
-    if (negotiator == null) {
-      negotiator = sslContext != null ? ProtocolNegotiators.serverTls(sslContext) :
-              ProtocolNegotiators.serverPlaintext();
+  public NettyServerBuilder maxConnectionIdle(long maxConnectionIdle, TimeUnit timeUnit) {
+    checkArgument(maxConnectionIdle > 0L, "max connection idle must be positive: %s",
+        maxConnectionIdle);
+    maxConnectionIdleInNanos = timeUnit.toNanos(maxConnectionIdle);
+    if (maxConnectionIdleInNanos >= AS_LARGE_AS_INFINITE) {
+      maxConnectionIdleInNanos = MAX_CONNECTION_IDLE_NANOS_DISABLED;
+    }
+    if (maxConnectionIdleInNanos < MIN_MAX_CONNECTION_IDLE_NANO) {
+      maxConnectionIdleInNanos = MIN_MAX_CONNECTION_IDLE_NANO;
     }
-    return new NettyServer(address, channelType, bossEventLoopGroup, workerEventLoopGroup,
-        negotiator, maxConcurrentCallsPerConnection, flowControlWindow, maxMessageSize,
-        maxHeaderListSize);
+    return this;
   }
 
+  /**
+   * Sets a custom max connection age, connection lasting longer than which will be gracefully
+   * terminated. An unreasonably small value might be increased.  A random jitter of +/-10% will be
+   * added to it. {@code Long.MAX_VALUE} nano seconds or an unreasonably large value will disable
+   * max connection age.
+   *
+   * @since 1.3.0
+   */
+  @CanIgnoreReturnValue
+  @Override
+  public NettyServerBuilder maxConnectionAge(long maxConnectionAge, TimeUnit timeUnit) {
+    checkArgument(maxConnectionAge > 0L, "max connection age must be positive: %s",
+        maxConnectionAge);
+    maxConnectionAgeInNanos = timeUnit.toNanos(maxConnectionAge);
+    if (maxConnectionAgeInNanos >= AS_LARGE_AS_INFINITE) {
+      maxConnectionAgeInNanos = MAX_CONNECTION_AGE_NANOS_DISABLED;
+    }
+    if (maxConnectionAgeInNanos < MIN_MAX_CONNECTION_AGE_NANO) {
+      maxConnectionAgeInNanos = MIN_MAX_CONNECTION_AGE_NANO;
+    }
+    return this;
+  }
+
+  /**
+   * Sets a custom grace time for the graceful connection termination. Once the max connection age
+   * is reached, RPCs have the grace time to complete. RPCs that do not complete in time will be
+   * cancelled, allowing the connection to terminate. {@code Long.MAX_VALUE} nano seconds or an
+   * unreasonably large value are considered infinite.
+   *
+   * @see #maxConnectionAge(long, TimeUnit)
+   * @since 1.3.0
+   */
+  @CanIgnoreReturnValue
+  @Override
+  public NettyServerBuilder maxConnectionAgeGrace(long maxConnectionAgeGrace, TimeUnit timeUnit) {
+    checkArgument(maxConnectionAgeGrace >= 0L, "max connection age grace must be non-negative: %s",
+        maxConnectionAgeGrace);
+    maxConnectionAgeGraceInNanos = timeUnit.toNanos(maxConnectionAgeGrace);
+    if (maxConnectionAgeGraceInNanos >= AS_LARGE_AS_INFINITE) {
+      maxConnectionAgeGraceInNanos = MAX_CONNECTION_AGE_GRACE_NANOS_INFINITE;
+    }
+    return this;
+  }
+
+  /**
+   * Specify the most aggressive keep-alive time clients are permitted to configure. The server will
+   * try to detect clients exceeding this rate and when detected will forcefully close the
+   * connection. The default is 5 minutes.
+   *
+   * <p>Even though a default is defined that allows some keep-alives, clients must not use
+   * keep-alive without approval from the service owner. Otherwise, they may experience failures in
+   * the future if the service becomes more restrictive. When unthrottled, keep-alives can cause a
+   * significant amount of traffic and CPU usage, so clients and servers should be conservative in
+   * what they use and accept.
+   *
+   * @see #permitKeepAliveWithoutCalls(boolean)
+   * @since 1.3.0
+   */
+  @CanIgnoreReturnValue
+  @Override
+  public NettyServerBuilder permitKeepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    checkArgument(keepAliveTime >= 0, "permit keepalive time must be non-negative: %s",
+        keepAliveTime);
+    permitKeepAliveTimeInNanos = timeUnit.toNanos(keepAliveTime);
+    return this;
+  }
+
+  /**
+   * Sets whether to allow clients to send keep-alive HTTP/2 PINGs even if there are no outstanding
+   * RPCs on the connection. Defaults to {@code false}.
+   *
+   * @see #permitKeepAliveTime(long, TimeUnit)
+   * @since 1.3.0
+   */
+  @CanIgnoreReturnValue
+  @Override
+  public NettyServerBuilder permitKeepAliveWithoutCalls(boolean permit) {
+    permitKeepAliveWithoutCalls = permit;
+    return this;
+  }
+
+  /**
+   * Limits the rate of incoming RST_STREAM frames per connection to maxRstStream per
+   * secondsPerWindow. When exceeded on a connection, the connection is closed. This can reduce the
+   * impact of an attacker continually resetting RPCs before they complete, when combined with TLS
+   * and {@link #maxConcurrentCallsPerConnection(int)}.
+   *
+   * <p>gRPC clients send RST_STREAM when they cancel RPCs, so some RST_STREAMs are normal and
+   * setting this too low can cause errors for legimitate clients.
+   *
+   * <p>By default there is no limit.
+   *
+   * @param maxRstStream the positive limit of RST_STREAM frames per connection per period, or
+   *     {@code Integer.MAX_VALUE} for unlimited
+   * @param secondsPerWindow the positive number of seconds per period
+   */
+  @CanIgnoreReturnValue
+  public NettyServerBuilder maxRstFramesPerWindow(int maxRstStream, int secondsPerWindow) {
+    checkArgument(maxRstStream > 0, "maxRstStream must be positive");
+    checkArgument(secondsPerWindow > 0, "secondsPerWindow must be positive");
+    if (maxRstStream == Integer.MAX_VALUE) {
+      maxRstStream = MAX_RST_COUNT_DISABLED;
+    }
+    this.maxRstCount = maxRstStream;
+    this.maxRstPeriodNanos = TimeUnit.SECONDS.toNanos(secondsPerWindow);
+    return this;
+  }
+
+  /** Sets the EAG attributes available to protocol negotiators. Not for general use. */
+  void eagAttributes(Attributes eagAttributes) {
+    this.eagAttributes = checkNotNull(eagAttributes, "eagAttributes");
+  }
+
+  NettyServer buildTransportServers(
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+    assertEventLoopsAndChannelType();
+
+    ProtocolNegotiator negotiator = protocolNegotiatorFactory.newNegotiator(
+        this.serverImplBuilder.getExecutorPool());
+
+    return new NettyServer(
+        listenAddresses,
+        channelFactory,
+        channelOptions,
+        childChannelOptions,
+        bossEventLoopGroupPool,
+        workerEventLoopGroupPool,
+        forceHeapBuffer,
+        negotiator,
+        streamTracerFactories,
+        transportTracerFactory,
+        maxConcurrentCallsPerConnection,
+        autoFlowControl,
+        flowControlWindow,
+        maxMessageSize,
+        maxHeaderListSize,
+        softLimitHeaderListSize,
+        keepAliveTimeInNanos,
+        keepAliveTimeoutInNanos,
+        maxConnectionIdleInNanos,
+        maxConnectionAgeInNanos,
+        maxConnectionAgeGraceInNanos,
+        permitKeepAliveWithoutCalls,
+        permitKeepAliveTimeInNanos,
+        maxRstCount,
+        maxRstPeriodNanos,
+        eagAttributes,
+        this.serverImplBuilder.getChannelz());
+  }
+
+  @VisibleForTesting
+  void assertEventLoopsAndChannelType() {
+    boolean allProvided = channelFactory != Utils.DEFAULT_SERVER_CHANNEL_FACTORY
+        && bossEventLoopGroupPool != DEFAULT_BOSS_EVENT_LOOP_GROUP_POOL
+        && workerEventLoopGroupPool != DEFAULT_WORKER_EVENT_LOOP_GROUP_POOL;
+    boolean nonProvided = channelFactory == Utils.DEFAULT_SERVER_CHANNEL_FACTORY
+        && bossEventLoopGroupPool == DEFAULT_BOSS_EVENT_LOOP_GROUP_POOL
+        && workerEventLoopGroupPool == DEFAULT_WORKER_EVENT_LOOP_GROUP_POOL;
+    checkState(
+        allProvided || nonProvided,
+        "All of BossEventLoopGroup, WorkerEventLoopGroup and ChannelType should be provided or "
+            + "neither should be");
+  }
+
+  @CanIgnoreReturnValue
+  NettyServerBuilder setTransportTracerFactory(TransportTracer.Factory transportTracerFactory) {
+    this.transportTracerFactory = transportTracerFactory;
+    return this;
+  }
+
+  @CanIgnoreReturnValue
   @Override
   public NettyServerBuilder useTransportSecurity(File certChain, File privateKey) {
+    checkState(!freezeProtocolNegotiatorFactory,
+               "Cannot change security when using ServerCredentials");
+    SslContext sslContext;
+    try {
+      sslContext = GrpcSslContexts.forServer(certChain, privateKey).build();
+    } catch (SSLException e) {
+      // This should likely be some other, easier to catch exception.
+      throw new RuntimeException(e);
+    }
+    protocolNegotiatorFactory = ProtocolNegotiators.serverTlsFactory(sslContext);
+    return this;
+  }
+
+  @CanIgnoreReturnValue
+  @Override
+  public NettyServerBuilder useTransportSecurity(InputStream certChain, InputStream privateKey) {
+    checkState(!freezeProtocolNegotiatorFactory,
+               "Cannot change security when using ServerCredentials");
+    SslContext sslContext;
     try {
       sslContext = GrpcSslContexts.forServer(certChain, privateKey).build();
     } catch (SSLException e) {
       // This should likely be some other, easier to catch exception.
       throw new RuntimeException(e);
     }
+    protocolNegotiatorFactory = ProtocolNegotiators.serverTlsFactory(sslContext);
     return this;
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NettyServerCredentials.java b/netty/src/main/java/io/grpc/netty/NettyServerCredentials.java
new file mode 100644
index 00000000000..bc8b4f5f621
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/NettyServerCredentials.java
@@ -0,0 +1,37 @@
+/*
+ * 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.netty;
+
+import com.google.common.base.Preconditions;
+import io.grpc.ServerCredentials;
+
+/** A credential with full control over the security handshake. */
+final class NettyServerCredentials extends ServerCredentials {
+  public static ServerCredentials create(ProtocolNegotiator.ServerFactory negotiator) {
+    return new NettyServerCredentials(negotiator);
+  }
+
+  private final ProtocolNegotiator.ServerFactory negotiator;
+
+  private NettyServerCredentials(ProtocolNegotiator.ServerFactory negotiator) {
+    this.negotiator = Preconditions.checkNotNull(negotiator, "negotiator");
+  }
+
+  public ProtocolNegotiator.ServerFactory getNegotiator() {
+    return negotiator;
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/NettyServerHandler.java b/netty/src/main/java/io/grpc/netty/NettyServerHandler.java
index d89b1ce81ac..036fde55e2c 100644
--- a/netty/src/main/java/io/grpc/netty/NettyServerHandler.java
+++ b/netty/src/main/java/io/grpc/netty/NettyServerHandler.java
@@ -1,65 +1,80 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.internal.GrpcUtil.SERVER_KEEPALIVE_TIME_NANOS_DISABLED;
+import static io.grpc.netty.NettyServerBuilder.MAX_CONNECTION_AGE_GRACE_NANOS_INFINITE;
+import static io.grpc.netty.NettyServerBuilder.MAX_CONNECTION_AGE_NANOS_DISABLED;
+import static io.grpc.netty.NettyServerBuilder.MAX_CONNECTION_IDLE_NANOS_DISABLED;
 import static io.grpc.netty.Utils.CONTENT_TYPE_HEADER;
 import static io.grpc.netty.Utils.HTTP_METHOD;
 import static io.grpc.netty.Utils.TE_HEADER;
 import static io.grpc.netty.Utils.TE_TRAILERS;
+import static io.netty.handler.codec.http.HttpHeaderNames.CONNECTION;
+import static io.netty.handler.codec.http.HttpHeaderNames.HOST;
 import static io.netty.handler.codec.http2.DefaultHttp2LocalFlowController.DEFAULT_WINDOW_UPDATE_RATIO;
+import static io.netty.handler.codec.http2.Http2Headers.PseudoHeaderName.AUTHORITY;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import com.google.common.base.Ticker;
 import io.grpc.Attributes;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalMetadata;
+import io.grpc.InternalStatus;
 import io.grpc.Metadata;
+import io.grpc.ServerStreamTracer;
 import io.grpc.Status;
 import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.KeepAliveEnforcer;
+import io.grpc.internal.KeepAliveManager;
+import io.grpc.internal.LogExceptionRunnable;
+import io.grpc.internal.MaxConnectionIdleManager;
 import io.grpc.internal.ServerTransportListener;
 import io.grpc.internal.StatsTraceContext;
-import io.grpc.netty.GrpcHttp2HeadersDecoder.GrpcHttp2ServerHeadersDecoder;
+import io.grpc.internal.TransportTracer;
+import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2ServerHeadersDecoder;
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufUtil;
+import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelFutureListener;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelPromise;
+import io.netty.handler.codec.http.HttpHeaderNames;
+import io.netty.handler.codec.http2.DecoratingHttp2ConnectionEncoder;
+import io.netty.handler.codec.http2.DecoratingHttp2FrameWriter;
 import io.netty.handler.codec.http2.DefaultHttp2Connection;
 import io.netty.handler.codec.http2.DefaultHttp2ConnectionDecoder;
 import io.netty.handler.codec.http2.DefaultHttp2ConnectionEncoder;
 import io.netty.handler.codec.http2.DefaultHttp2FrameReader;
 import io.netty.handler.codec.http2.DefaultHttp2FrameWriter;
+import io.netty.handler.codec.http2.DefaultHttp2Headers;
+import io.netty.handler.codec.http2.DefaultHttp2HeadersEncoder;
 import io.netty.handler.codec.http2.DefaultHttp2LocalFlowController;
+import io.netty.handler.codec.http2.DefaultHttp2RemoteFlowController;
+import io.netty.handler.codec.http2.EmptyHttp2Headers;
 import io.netty.handler.codec.http2.Http2Connection;
+import io.netty.handler.codec.http2.Http2ConnectionAdapter;
 import io.netty.handler.codec.http2.Http2ConnectionDecoder;
 import io.netty.handler.codec.http2.Http2ConnectionEncoder;
 import io.netty.handler.codec.http2.Http2Error;
@@ -71,17 +86,28 @@
 import io.netty.handler.codec.http2.Http2FrameWriter;
 import io.netty.handler.codec.http2.Http2Headers;
 import io.netty.handler.codec.http2.Http2HeadersDecoder;
+import io.netty.handler.codec.http2.Http2HeadersEncoder;
 import io.netty.handler.codec.http2.Http2InboundFrameLogger;
+import io.netty.handler.codec.http2.Http2LifecycleManager;
 import io.netty.handler.codec.http2.Http2OutboundFrameLogger;
 import io.netty.handler.codec.http2.Http2Settings;
 import io.netty.handler.codec.http2.Http2Stream;
 import io.netty.handler.codec.http2.Http2StreamVisitor;
+import io.netty.handler.codec.http2.UniformStreamByteDistributor;
 import io.netty.handler.logging.LogLevel;
 import io.netty.util.AsciiString;
 import io.netty.util.ReferenceCountUtil;
-
+import io.perfmark.PerfMark;
+import io.perfmark.Tag;
+import io.perfmark.TaskCloseable;
+import java.text.MessageFormat;
+import java.util.List;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import javax.annotation.CheckForNull;
 import javax.annotation.Nullable;
 
 /**
@@ -89,53 +115,160 @@
  * the context of the Netty Channel thread.
  */
 class NettyServerHandler extends AbstractNettyHandler {
-  private static Logger logger = Logger.getLogger(NettyServerHandler.class.getName());
+  private static final Logger logger = Logger.getLogger(NettyServerHandler.class.getName());
+  private static final long KEEPALIVE_PING = 0xDEADL;
+  @VisibleForTesting
+  static final long GRACEFUL_SHUTDOWN_PING = 0x97ACEF001L;
+  private static final long GRACEFUL_SHUTDOWN_PING_TIMEOUT_NANOS = TimeUnit.SECONDS.toNanos(10);
+  /** Temporary workaround for #8674. Fine to delete after v1.45 release, and maybe earlier. */
+  private static final boolean DISABLE_CONNECTION_HEADER_CHECK = Boolean.parseBoolean(
+      System.getProperty("io.grpc.netty.disableConnectionHeaderCheck", "false"));
 
   private final Http2Connection.PropertyKey streamKey;
   private final ServerTransportListener transportListener;
   private final int maxMessageSize;
+  private final long keepAliveTimeInNanos;
+  private final long keepAliveTimeoutInNanos;
+  private final long maxConnectionAgeInNanos;
+  private final long maxConnectionAgeGraceInNanos;
+  private final RstStreamCounter rstStreamCounter;
+  private final List<? extends ServerStreamTracer.Factory> streamTracerFactories;
+  private final TransportTracer transportTracer;
+  private final KeepAliveEnforcer keepAliveEnforcer;
+  private final Attributes eagAttributes;
+  /** Incomplete attributes produced by negotiator. */
+  private Attributes negotiationAttributes;
+  private InternalChannelz.Security securityInfo;
+  /** Completed attributes produced by transportReady. */
   private Attributes attributes;
   private Throwable connectionError;
   private boolean teWarningLogged;
   private WriteQueue serverWriteQueue;
   private AsciiString lastKnownAuthority;
+  @CheckForNull
+  private KeepAliveManager keepAliveManager;
+  @CheckForNull
+  private MaxConnectionIdleManager maxConnectionIdleManager;
+  @CheckForNull
+  private ScheduledFuture<?> maxConnectionAgeMonitor;
+  @CheckForNull
+  private GracefulShutdown gracefulShutdown;
 
-  static NettyServerHandler newHandler(ServerTransportListener transportListener,
-                                       int maxStreams,
-                                       int flowControlWindow,
-                                       int maxHeaderListSize,
-                                       int maxMessageSize) {
-    Preconditions.checkArgument(maxHeaderListSize > 0, "maxHeaderListSize must be positive");
+  static NettyServerHandler newHandler(
+      ServerTransportListener transportListener,
+      ChannelPromise channelUnused,
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+      TransportTracer transportTracer,
+      int maxStreams,
+      boolean autoFlowControl,
+      int flowControlWindow,
+      int maxHeaderListSize,
+      int softLimitHeaderListSize,
+      int maxMessageSize,
+      long keepAliveTimeInNanos,
+      long keepAliveTimeoutInNanos,
+      long maxConnectionIdleInNanos,
+      long maxConnectionAgeInNanos,
+      long maxConnectionAgeGraceInNanos,
+      boolean permitKeepAliveWithoutCalls,
+      long permitKeepAliveTimeInNanos,
+      int maxRstCount,
+      long maxRstPeriodNanos,
+      Attributes eagAttributes) {
+    Preconditions.checkArgument(maxHeaderListSize > 0, "maxHeaderListSize must be positive: %s",
+        maxHeaderListSize);
     Http2FrameLogger frameLogger = new Http2FrameLogger(LogLevel.DEBUG, NettyServerHandler.class);
     Http2HeadersDecoder headersDecoder = new GrpcHttp2ServerHeadersDecoder(maxHeaderListSize);
     Http2FrameReader frameReader = new Http2InboundFrameLogger(
         new DefaultHttp2FrameReader(headersDecoder), frameLogger);
+    Http2HeadersEncoder encoder = new DefaultHttp2HeadersEncoder(
+        Http2HeadersEncoder.NEVER_SENSITIVE, false, 16, Integer.MAX_VALUE);
     Http2FrameWriter frameWriter =
-        new Http2OutboundFrameLogger(new DefaultHttp2FrameWriter(), frameLogger);
-    return newHandler(frameReader, frameWriter, transportListener, maxStreams, flowControlWindow,
-        maxHeaderListSize, maxMessageSize);
+        new Http2OutboundFrameLogger(new DefaultHttp2FrameWriter(encoder), frameLogger);
+    return newHandler(
+        channelUnused,
+        frameReader,
+        frameWriter,
+        transportListener,
+        streamTracerFactories,
+        transportTracer,
+        maxStreams,
+        autoFlowControl,
+        flowControlWindow,
+        maxHeaderListSize,
+        softLimitHeaderListSize,
+        maxMessageSize,
+        keepAliveTimeInNanos,
+        keepAliveTimeoutInNanos,
+        maxConnectionIdleInNanos,
+        maxConnectionAgeInNanos,
+        maxConnectionAgeGraceInNanos,
+        permitKeepAliveWithoutCalls,
+        permitKeepAliveTimeInNanos,
+        maxRstCount,
+        maxRstPeriodNanos,
+        eagAttributes,
+        Ticker.systemTicker());
   }
 
-  @VisibleForTesting
-  static NettyServerHandler newHandler(Http2FrameReader frameReader, Http2FrameWriter frameWriter,
-                                       ServerTransportListener transportListener,
-                                       int maxStreams,
-                                       int flowControlWindow,
-                                       int maxHeaderListSize,
-                                       int maxMessageSize) {
-    Preconditions.checkArgument(maxStreams > 0, "maxStreams must be positive");
-    Preconditions.checkArgument(flowControlWindow > 0, "flowControlWindow must be positive");
-    Preconditions.checkArgument(maxHeaderListSize > 0, "maxHeaderListSize must be positive");
-    Preconditions.checkArgument(maxMessageSize > 0, "maxMessageSize must be positive");
-
-    Http2Connection connection = new DefaultHttp2Connection(true);
+  static NettyServerHandler newHandler(
+      ChannelPromise channelUnused,
+      Http2FrameReader frameReader,
+      Http2FrameWriter frameWriter,
+      ServerTransportListener transportListener,
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+      TransportTracer transportTracer,
+      int maxStreams,
+      boolean autoFlowControl,
+      int flowControlWindow,
+      int maxHeaderListSize,
+      int softLimitHeaderListSize,
+      int maxMessageSize,
+      long keepAliveTimeInNanos,
+      long keepAliveTimeoutInNanos,
+      long maxConnectionIdleInNanos,
+      long maxConnectionAgeInNanos,
+      long maxConnectionAgeGraceInNanos,
+      boolean permitKeepAliveWithoutCalls,
+      long permitKeepAliveTimeInNanos,
+      int maxRstCount,
+      long maxRstPeriodNanos,
+      Attributes eagAttributes,
+      Ticker ticker) {
+    Preconditions.checkArgument(maxStreams > 0, "maxStreams must be positive: %s", maxStreams);
+    Preconditions.checkArgument(flowControlWindow > 0, "flowControlWindow must be positive: %s",
+        flowControlWindow);
+    Preconditions.checkArgument(maxHeaderListSize > 0, "maxHeaderListSize must be positive: %s",
+        maxHeaderListSize);
+    Preconditions.checkArgument(
+        softLimitHeaderListSize > 0, "softLimitHeaderListSize must be positive: %s",
+        softLimitHeaderListSize);
+    Preconditions.checkArgument(maxMessageSize > 0, "maxMessageSize must be positive: %s",
+        maxMessageSize);
 
+    final Http2Connection connection = new DefaultHttp2Connection(true);
+    UniformStreamByteDistributor dist = new UniformStreamByteDistributor(connection);
+    dist.minAllocationChunk(MIN_ALLOCATED_CHUNK); // Increased for benchmarks performance.
+    DefaultHttp2RemoteFlowController controller =
+        new DefaultHttp2RemoteFlowController(connection, dist);
+    connection.remote().flowController(controller);
+    final KeepAliveEnforcer keepAliveEnforcer = new KeepAliveEnforcer(
+        permitKeepAliveWithoutCalls, permitKeepAliveTimeInNanos, TimeUnit.NANOSECONDS);
+
+    if (ticker == null) {
+      ticker = Ticker.systemTicker();
+    }
+
+    RstStreamCounter rstStreamCounter
+        = new RstStreamCounter(maxRstCount, maxRstPeriodNanos, ticker);
     // Create the local flow controller configured to auto-refill the connection window.
     connection.local().flowController(
         new DefaultHttp2LocalFlowController(connection, DEFAULT_WINDOW_UPDATE_RATIO, true));
-
-
-    Http2ConnectionEncoder encoder = new DefaultHttp2ConnectionEncoder(connection, frameWriter);
+    frameWriter = new WriteMonitoringFrameWriter(frameWriter, keepAliveEnforcer);
+    Http2ConnectionEncoder encoder =
+        new DefaultHttp2ConnectionEncoder(connection, frameWriter);
+    encoder = new Http2ControlFrameLimitEncoder(encoder, 10000);
+    encoder = new Http2RstCounterEncoder(encoder, rstStreamCounter);
     Http2ConnectionDecoder decoder = new DefaultHttp2ConnectionDecoder(connection, encoder,
         frameReader);
 
@@ -144,20 +277,104 @@ static NettyServerHandler newHandler(Http2FrameReader frameReader, Http2FrameWri
     settings.maxConcurrentStreams(maxStreams);
     settings.maxHeaderListSize(maxHeaderListSize);
 
-    return new NettyServerHandler(transportListener, decoder, encoder, settings, maxMessageSize);
+    return new NettyServerHandler(
+        channelUnused,
+        connection,
+        transportListener,
+        streamTracerFactories,
+        transportTracer,
+        decoder, encoder, settings,
+        maxMessageSize,
+        maxHeaderListSize,
+        softLimitHeaderListSize,
+        keepAliveTimeInNanos,
+        keepAliveTimeoutInNanos,
+        maxConnectionIdleInNanos,
+        maxConnectionAgeInNanos, maxConnectionAgeGraceInNanos,
+        keepAliveEnforcer,
+        autoFlowControl,
+        rstStreamCounter,
+        eagAttributes, ticker);
   }
 
-  private NettyServerHandler(ServerTransportListener transportListener,
-                             Http2ConnectionDecoder decoder,
-                             Http2ConnectionEncoder encoder, Http2Settings settings,
-                             int maxMessageSize) {
-    super(decoder, encoder, settings);
-    checkArgument(maxMessageSize >= 0, "maxMessageSize must be >= 0");
+  private NettyServerHandler(
+      ChannelPromise channelUnused,
+      final Http2Connection connection,
+      ServerTransportListener transportListener,
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+      TransportTracer transportTracer,
+      Http2ConnectionDecoder decoder,
+      Http2ConnectionEncoder encoder,
+      Http2Settings settings,
+      int maxMessageSize,
+      int maxHeaderListSize,
+      int softLimitHeaderListSize,
+      long keepAliveTimeInNanos,
+      long keepAliveTimeoutInNanos,
+      long maxConnectionIdleInNanos,
+      long maxConnectionAgeInNanos,
+      long maxConnectionAgeGraceInNanos,
+      final KeepAliveEnforcer keepAliveEnforcer,
+      boolean autoFlowControl,
+      RstStreamCounter rstStreamCounter,
+      Attributes eagAttributes,
+      Ticker ticker) {
+    super(
+        channelUnused,
+        decoder,
+        encoder,
+        settings,
+        new ServerChannelLogger(),
+        autoFlowControl,
+        null,
+        ticker,
+        maxHeaderListSize,
+        softLimitHeaderListSize);
+
+    final MaxConnectionIdleManager maxConnectionIdleManager;
+    if (maxConnectionIdleInNanos == MAX_CONNECTION_IDLE_NANOS_DISABLED) {
+      maxConnectionIdleManager = null;
+    } else {
+      maxConnectionIdleManager = new MaxConnectionIdleManager(maxConnectionIdleInNanos);
+    }
+
+    connection.addListener(new Http2ConnectionAdapter() {
+      @Override
+      public void onStreamActive(Http2Stream stream) {
+        if (connection.numActiveStreams() == 1) {
+          keepAliveEnforcer.onTransportActive();
+          if (maxConnectionIdleManager != null) {
+            maxConnectionIdleManager.onTransportActive();
+          }
+        }
+      }
+
+      @Override
+      public void onStreamClosed(Http2Stream stream) {
+        if (connection.numActiveStreams() == 0) {
+          keepAliveEnforcer.onTransportIdle();
+          if (maxConnectionIdleManager != null) {
+            maxConnectionIdleManager.onTransportIdle();
+          }
+        }
+      }
+    });
+
+    checkArgument(maxMessageSize >= 0, "maxMessageSize must be non-negative: %s", maxMessageSize);
     this.maxMessageSize = maxMessageSize;
+    this.keepAliveTimeInNanos = keepAliveTimeInNanos;
+    this.keepAliveTimeoutInNanos = keepAliveTimeoutInNanos;
+    this.maxConnectionIdleManager = maxConnectionIdleManager;
+    this.maxConnectionAgeInNanos = maxConnectionAgeInNanos;
+    this.maxConnectionAgeGraceInNanos = maxConnectionAgeGraceInNanos;
+    this.keepAliveEnforcer = checkNotNull(keepAliveEnforcer, "keepAliveEnforcer");
+    this.rstStreamCounter = rstStreamCounter;
+    this.eagAttributes = checkNotNull(eagAttributes, "eagAttributes");
 
     streamKey = encoder.connection().newKey();
     this.transportListener = checkNotNull(transportListener, "transportListener");
-
+    this.streamTracerFactories = checkNotNull(streamTracerFactories, "streamTracerFactories");
+    this.transportTracer = checkNotNull(transportTracer, "transportTracer");
     // Set the frame listener on the decoder.
     decoder().frameListener(new FrameListener());
   }
@@ -168,24 +385,130 @@ Throwable connectionError() {
   }
 
   @Override
-  public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+  public void handlerAdded(final ChannelHandlerContext ctx) throws Exception {
     serverWriteQueue = new WriteQueue(ctx.channel());
+
+    // init max connection age monitor
+    if (maxConnectionAgeInNanos != MAX_CONNECTION_AGE_NANOS_DISABLED) {
+      maxConnectionAgeMonitor = ctx.executor().schedule(
+          new LogExceptionRunnable(new Runnable() {
+            @Override
+            public void run() {
+              if (gracefulShutdown == null) {
+                gracefulShutdown = new GracefulShutdown("max_age", maxConnectionAgeGraceInNanos);
+                gracefulShutdown.start(ctx);
+                ctx.flush();
+              }
+            }
+          }),
+          maxConnectionAgeInNanos,
+          TimeUnit.NANOSECONDS);
+    }
+
+    if (maxConnectionIdleManager != null) {
+      maxConnectionIdleManager.start(new Runnable() {
+        @Override
+        public void run() {
+          if (gracefulShutdown == null) {
+            gracefulShutdown = new GracefulShutdown("max_idle", null);
+            gracefulShutdown.start(ctx);
+            ctx.flush();
+          }
+        }
+      }, ctx.executor());
+    }
+
+    if (keepAliveTimeInNanos != SERVER_KEEPALIVE_TIME_NANOS_DISABLED) {
+      keepAliveManager = new KeepAliveManager(new KeepAlivePinger(ctx), ctx.executor(),
+          keepAliveTimeInNanos, keepAliveTimeoutInNanos, true /* keepAliveDuringTransportIdle */);
+      keepAliveManager.onTransportStarted();
+    }
+
+    assert encoder().connection().equals(decoder().connection());
+    transportTracer.setFlowControlWindowReader(new Utils.FlowControlReader(encoder().connection()));
+
     super.handlerAdded(ctx);
   }
 
   private void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers)
       throws Http2Exception {
-    if (!teWarningLogged && !TE_TRAILERS.equals(headers.get(TE_HEADER))) {
-      logger.warning(String.format("Expected header TE: %s, but %s is received. This means "
-            + "some intermediate proxy may not support trailers",
-            TE_TRAILERS, headers.get(TE_HEADER)));
-      teWarningLogged = true;
-    }
-
     try {
+      // Connection-specific header fields makes a request malformed. Ideally this would be handled
+      // by Netty. RFC 7540 section 8.1.2.2
+      if (!DISABLE_CONNECTION_HEADER_CHECK && headers.contains(CONNECTION)) {
+        resetStream(ctx, streamId, Http2Error.PROTOCOL_ERROR.code(), ctx.newPromise());
+        return;
+      }
+
+      if (headers.authority() == null) {
+        List<CharSequence> hosts = headers.getAll(HOST);
+        if (hosts.size() > 1) {
+          // RFC 7230 section 5.4
+          respondWithHttpError(ctx, streamId, 400, Status.Code.INTERNAL,
+              "Multiple host headers");
+          return;
+        }
+        if (!hosts.isEmpty()) {
+          headers.add(AUTHORITY.value(), hosts.get(0));
+        }
+      }
+      headers.remove(HOST);
+
+      // Remove the leading slash of the path and get the fully qualified method name
+      CharSequence path = headers.path();
+
+      if (path == null) {
+        respondWithHttpError(ctx, streamId, 404, Status.Code.UNIMPLEMENTED,
+            "Expected path but is missing");
+        return;
+      }
+
+      if (path.charAt(0) != '/') {
+        respondWithHttpError(ctx, streamId, 404, Status.Code.UNIMPLEMENTED,
+            String.format("Expected path to start with /: %s", path));
+        return;
+      }
+
+      String method = path.subSequence(1, path.length()).toString();
+
       // Verify that the Content-Type is correct in the request.
-      verifyContentType(streamId, headers);
-      String method = determineMethod(streamId, headers);
+      CharSequence contentType = headers.get(CONTENT_TYPE_HEADER);
+      if (contentType == null) {
+        respondWithHttpError(
+            ctx, streamId, 415, Status.Code.INTERNAL, "Content-Type is missing from the request");
+        return;
+      }
+      String contentTypeString = contentType.toString();
+      if (!GrpcUtil.isGrpcContentType(contentTypeString)) {
+        respondWithHttpError(ctx, streamId, 415, Status.Code.INTERNAL,
+            String.format("Content-Type '%s' is not supported", contentTypeString));
+        return;
+      }
+
+      if (!HTTP_METHOD.contentEquals(headers.method())) {
+        Http2Headers extraHeaders = new DefaultHttp2Headers();
+        extraHeaders.add(HttpHeaderNames.ALLOW, HTTP_METHOD);
+        respondWithHttpError(ctx, streamId, 405, Status.Code.INTERNAL,
+            String.format("Method '%s' is not supported", headers.method()), extraHeaders);
+        return;
+      }
+
+      int h2HeadersSize = Utils.getH2HeadersSize(headers);
+      if (Utils.shouldRejectOnMetadataSizeSoftLimitExceeded(
+              h2HeadersSize, softLimitHeaderListSize, maxHeaderListSize)) {
+        respondWithHttpError(ctx, streamId, 431, Status.Code.RESOURCE_EXHAUSTED, String.format(
+                "Client Headers of size %d exceeded Metadata size soft limit: %d",
+                h2HeadersSize,
+                softLimitHeaderListSize));
+        return;
+      }
+
+      if (!teWarningLogged && !TE_TRAILERS.contentEquals(headers.get(TE_HEADER))) {
+        logger.warning(String.format("Expected header TE: %s, but %s is received. This means "
+                + "some intermediate proxy may not support trailers",
+            TE_TRAILERS, headers.get(TE_HEADER)));
+        teWarningLogged = true;
+      }
 
       // The Http2Stream object was put by AbstractHttp2ConnectionHandler before calling this
       // method.
@@ -193,19 +516,31 @@ private void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers
 
       Metadata metadata = Utils.convertHeaders(headers);
       StatsTraceContext statsTraceCtx =
-          checkNotNull(transportListener.methodDetermined(method, metadata), "statsTraceCtx");
+          StatsTraceContext.newServerContext(streamTracerFactories, method, metadata);
+
       NettyServerStream.TransportState state = new NettyServerStream.TransportState(
-          this, http2Stream, maxMessageSize, statsTraceCtx);
-      String authority = getOrUpdateAuthority((AsciiString)headers.authority());
-      NettyServerStream stream = new NettyServerStream(ctx.channel(), state, attributes,
-          authority, statsTraceCtx);
-      transportListener.streamCreated(stream, method, metadata);
-      state.onStreamAllocated();
-      http2Stream.setProperty(streamKey, state);
+          this,
+          ctx.channel().eventLoop(),
+          http2Stream,
+          maxMessageSize,
+          statsTraceCtx,
+          transportTracer,
+          method);
 
-    } catch (Http2Exception e) {
-      throw e;
-    } catch (Throwable e) {
+      try (TaskCloseable ignore = PerfMark.traceTask("NettyServerHandler.onHeadersRead")) {
+        PerfMark.attachTag(state.tag());
+        String authority = getOrUpdateAuthority((AsciiString) headers.authority());
+        NettyServerStream stream = new NettyServerStream(
+            ctx.channel(),
+            state,
+            attributes,
+            authority,
+            statsTraceCtx);
+        transportListener.streamCreated(stream, method, metadata);
+        state.onStreamAllocated();
+        http2Stream.setProperty(streamKey, state);
+      }
+    } catch (Exception e) {
       logger.log(Level.WARNING, "Exception in onHeadersRead()", e);
       // Throw an exception that will get handled by onStreamError.
       throw newStreamException(streamId, e);
@@ -229,7 +564,13 @@ private void onDataRead(int streamId, ByteBuf data, int padding, boolean endOfSt
     flowControlPing().onDataRead(data.readableBytes(), padding);
     try {
       NettyServerStream.TransportState stream = serverStream(requireHttp2Stream(streamId));
-      stream.inboundDataReceived(data, endOfStream);
+      if (stream == null) {
+        return;
+      }
+      try (TaskCloseable ignore = PerfMark.traceTask("NettyServerHandler.onDataRead")) {
+        PerfMark.attachTag(stream.tag());
+        stream.inboundDataReceived(data, endOfStream);
+      }
     } catch (Throwable e) {
       logger.log(Level.WARNING, "Exception in onDataRead()", e);
       // Throw an exception that will get handled by onStreamError.
@@ -237,11 +578,20 @@ private void onDataRead(int streamId, ByteBuf data, int padding, boolean endOfSt
     }
   }
 
-  private void onRstStreamRead(int streamId) throws Http2Exception {
+  private void onRstStreamRead(int streamId, long errorCode) throws Http2Exception {
+    Http2Exception tooManyRstStream = rstStreamCounter.countRstStream();
+    if (tooManyRstStream != null) {
+      throw tooManyRstStream;
+    }
+
     try {
       NettyServerStream.TransportState stream = serverStream(connection().stream(streamId));
       if (stream != null) {
-        stream.transportReportStatus(Status.CANCELLED);
+        try (TaskCloseable ignore = PerfMark.traceTask("NettyServerHandler.onRstStreamRead")) {
+          PerfMark.attachTag(stream.tag());
+          stream.transportReportStatus(
+              Status.CANCELLED.withDescription("RST_STREAM received for code " + errorCode));
+        }
       }
     } catch (Throwable e) {
       logger.log(Level.WARNING, "Exception in onRstStreamRead()", e);
@@ -251,30 +601,61 @@ private void onRstStreamRead(int streamId) throws Http2Exception {
   }
 
   @Override
-  protected void onConnectionError(ChannelHandlerContext ctx, Throwable cause,
+  protected void onConnectionError(ChannelHandlerContext ctx, boolean outbound, Throwable cause,
       Http2Exception http2Ex) {
-    logger.log(Level.WARNING, "Connection Error", cause);
+    logger.log(Level.FINE, "Connection Error", cause);
     connectionError = cause;
-    super.onConnectionError(ctx, cause, http2Ex);
+    super.onConnectionError(ctx, outbound, cause, http2Ex);
   }
 
   @Override
-  protected void onStreamError(ChannelHandlerContext ctx, Throwable cause,
+  protected void onStreamError(ChannelHandlerContext ctx, boolean outbound, Throwable cause,
       StreamException http2Ex) {
-    logger.log(Level.WARNING, "Stream Error", cause);
     NettyServerStream.TransportState serverStream = serverStream(
         connection().stream(Http2Exception.streamId(http2Ex)));
-    if (serverStream != null) {
-      serverStream.transportReportStatus(Utils.statusFromThrowable(cause));
+    Level level = Level.WARNING;
+    if (serverStream == null && http2Ex.error() == Http2Error.STREAM_CLOSED) {
+      level = Level.FINE;
+    }
+    logger.log(level, "Stream Error", cause);
+    Tag tag = serverStream != null ? serverStream.tag() : PerfMark.createTag();
+    try (TaskCloseable ignore = PerfMark.traceTask("NettyServerHandler.onStreamError")) {
+      PerfMark.attachTag(tag);
+      if (serverStream != null) {
+        serverStream.transportReportStatus(Utils.statusFromThrowable(cause));
+      }
+      // TODO(ejona): Abort the stream by sending headers to help the client with debugging.
+      // Delegate to the base class to send a RST_STREAM.
+      super.onStreamError(ctx, outbound, cause, http2Ex);
     }
-    // TODO(ejona): Abort the stream by sending headers to help the client with debugging.
-    // Delegate to the base class to send a RST_STREAM.
-    super.onStreamError(ctx, cause, http2Ex);
   }
 
   @Override
-  public void handleProtocolNegotiationCompleted(Attributes attrs) {
-    attributes = transportListener.transportReady(attrs);
+  public void handleProtocolNegotiationCompleted(
+      Attributes attrs, InternalChannelz.Security securityInfo) {
+    negotiationAttributes = attrs;
+    this.securityInfo = securityInfo;
+    super.handleProtocolNegotiationCompleted(attrs, securityInfo);
+    NettyClientHandler.writeBufferingAndRemove(ctx().channel());
+  }
+
+  @Override
+  public Attributes getEagAttributes() {
+    return eagAttributes;
+  }
+
+  InternalChannelz.Security getSecurityInfo() {
+    return securityInfo;
+  }
+
+  @VisibleForTesting
+  KeepAliveManager getKeepAliveManagerForTest() {
+    return keepAliveManager;
+  }
+
+  @VisibleForTesting
+  void setKeepAliveManagerForTest(KeepAliveManager keepAliveManager) {
+    this.keepAliveManager = keepAliveManager;
   }
 
   /**
@@ -283,6 +664,15 @@ public void handleProtocolNegotiationCompleted(Attributes attrs) {
   @Override
   public void channelInactive(ChannelHandlerContext ctx) throws Exception {
     try {
+      if (keepAliveManager != null) {
+        keepAliveManager.onTransportTermination();
+      }
+      if (maxConnectionIdleManager != null) {
+        maxConnectionIdleManager.onTransportTermination();
+      }
+      if (maxConnectionAgeMonitor != null) {
+        maxConnectionAgeMonitor.cancel(false);
+      }
       final Status status =
           Status.UNAVAILABLE.withDescription("connection terminated for unknown reason");
       // Any streams that are still active must be closed
@@ -305,9 +695,7 @@ WriteQueue getWriteQueue() {
     return serverWriteQueue;
   }
 
-  /**
-   * Handler for commands sent from the stream.
-   */
+  /** Handler for commands sent from the stream. */
   @Override
   public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
       throws Exception {
@@ -317,6 +705,8 @@ public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
       sendResponseHeaders(ctx, (SendResponseHeadersCommand) msg, promise);
     } else if (msg instanceof CancelServerStreamCommand) {
       cancelStream(ctx, (CancelServerStreamCommand) msg, promise);
+    } else if (msg instanceof GracefulServerCloseCommand) {
+      gracefulClose(ctx, (GracefulServerCloseCommand) msg, promise);
     } else if (msg instanceof ForcefulCloseCommand) {
       forcefulClose(ctx, (ForcefulCloseCommand) msg, promise);
     } else {
@@ -328,6 +718,12 @@ public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
     }
   }
 
+  @Override
+  public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
+    gracefulClose(ctx, new GracefulServerCloseCommand("app_requested"), promise);
+    ctx.flush();
+  }
+
   /**
    * Returns the given processed bytes back to inbound flow control.
    */
@@ -339,26 +735,47 @@ void returnProcessedBytes(Http2Stream http2Stream, int bytes) {
     }
   }
 
-  private void closeStreamWhenDone(ChannelPromise promise, int streamId) throws Http2Exception {
-    final NettyServerStream.TransportState stream = serverStream(requireHttp2Stream(streamId));
-    promise.addListener(new ChannelFutureListener() {
-      @Override
-      public void operationComplete(ChannelFuture future) {
-        stream.complete();
-      }
-    });
+  private void closeStreamWhenDone(ChannelPromise promise, Http2Stream stream) {
+    promise.addListener(
+        new ChannelFutureListener() {
+          @Override
+          public void operationComplete(ChannelFuture future) {
+            serverStream(stream).complete();
+          }
+        });
   }
 
-  /**
-   * Sends the given gRPC frame to the client.
-   */
-  private void sendGrpcFrame(ChannelHandlerContext ctx, SendGrpcFrameCommand cmd,
-      ChannelPromise promise) throws Http2Exception {
-    if (cmd.endStream()) {
-      closeStreamWhenDone(promise, cmd.streamId());
+  private static void streamGone(int streamId, ChannelPromise promise) {
+    promise.setFailure(
+        new IllegalStateException(
+            "attempting to write to stream " + streamId + " that no longer exists") {
+          @Override
+          public synchronized Throwable fillInStackTrace() {
+            return this;
+          }
+        });
+  }
+
+  /** Sends the given gRPC frame to the client. */
+  private void sendGrpcFrame(
+      ChannelHandlerContext ctx, SendGrpcFrameCommand cmd, ChannelPromise promise)
+      throws Http2Exception {
+    try (TaskCloseable ignore = PerfMark.traceTask("NettyServerHandler.sendGrpcFrame")) {
+      PerfMark.attachTag(cmd.stream().tag());
+      PerfMark.linkIn(cmd.getLink());
+      int streamId = cmd.stream().id();
+      Http2Stream stream = connection().stream(streamId);
+      if (stream == null) {
+        cmd.release();
+        streamGone(streamId, promise);
+        return;
+      }
+      if (cmd.endStream()) {
+        closeStreamWhenDone(promise, stream);
+      }
+      // Call the base class to write the HTTP/2 DATA frame.
+      encoder().writeData(ctx, streamId, cmd.content(), 0, cmd.endStream(), promise);
     }
-    // Call the base class to write the HTTP/2 DATA frame.
-    encoder().writeData(ctx, cmd.streamId(), cmd.content(), 0, cmd.endStream(), promise);
   }
 
   /**
@@ -366,38 +783,91 @@ private void sendGrpcFrame(ChannelHandlerContext ctx, SendGrpcFrameCommand cmd,
    */
   private void sendResponseHeaders(ChannelHandlerContext ctx, SendResponseHeadersCommand cmd,
       ChannelPromise promise) throws Http2Exception {
-    // TODO(carl-mastrangelo): remove this check once https://github.com/netty/netty/issues/6296 is
-    // fixed.
-    int streamId = cmd.stream().id();
-    Http2Stream stream = connection().stream(streamId);
-    if (stream == null) {
-      resetStream(ctx, streamId, Http2Error.CANCEL.code(), promise);
-      return;
-    }
-    if (cmd.endOfStream()) {
-      closeStreamWhenDone(promise, streamId);
+    try (TaskCloseable ignore = PerfMark.traceTask("NettyServerHandler.sendResponseHeaders")) {
+      PerfMark.attachTag(cmd.stream().tag());
+      PerfMark.linkIn(cmd.getLink());
+      int streamId = cmd.stream().id();
+      Http2Stream stream = connection().stream(streamId);
+      if (stream == null) {
+        streamGone(streamId, promise);
+        return;
+      }
+      if (cmd.endOfStream()) {
+        closeStreamWhenDone(promise, stream);
+      }
+      encoder().writeHeaders(ctx, streamId, cmd.headers(), 0, cmd.endOfStream(), promise);
     }
-    encoder().writeHeaders(ctx, streamId, cmd.headers(), 0, cmd.endOfStream(), promise);
   }
 
   private void cancelStream(ChannelHandlerContext ctx, CancelServerStreamCommand cmd,
       ChannelPromise promise) {
-    // Notify the listener if we haven't already.
-    cmd.stream().transportReportStatus(cmd.reason());
-    // Terminate the stream.
-    encoder().writeRstStream(ctx, cmd.stream().id(), Http2Error.CANCEL.code(), promise);
+    try (TaskCloseable ignore = PerfMark.traceTask("NettyServerHandler.cancelStream")) {
+      PerfMark.attachTag(cmd.stream().tag());
+      PerfMark.linkIn(cmd.getLink());
+      // Notify the listener if we haven't already.
+      cmd.stream().transportReportStatus(cmd.reason());
+
+      // Now we need to decide how we're going to notify the peer that this stream is closed.
+      // If possible, it's nice to inform the peer _why_ this stream was cancelled by sending
+      // a structured headers frame.
+      if (shouldCloseStreamWithHeaders(cmd, connection())) {
+        Metadata md = new Metadata();
+        md.put(InternalStatus.CODE_KEY, cmd.reason());
+        if (cmd.reason().getDescription() != null) {
+          md.put(InternalStatus.MESSAGE_KEY, cmd.reason().getDescription());
+        }
+        Http2Headers headers = Utils.convertServerHeaders(md);
+        encoder().writeHeaders(
+            ctx, cmd.stream().id(), headers, /* padding = */ 0, /* endStream = */ true, promise);
+      } else {
+        // Terminate the stream.
+        encoder().writeRstStream(ctx, cmd.stream().id(), Http2Error.CANCEL.code(), promise);
+      }
+    }
+  }
+
+  // Determine whether a CancelServerStreamCommand should try to close the stream with a
+  // HEADERS or a RST_STREAM frame. The caller has some influence over this (they can
+  // configure cmd.wantsHeaders()). The state of the stream also has an influence: we
+  // only try to send HEADERS if the stream exists and hasn't already sent any headers.
+  private static boolean shouldCloseStreamWithHeaders(
+          CancelServerStreamCommand cmd, Http2Connection conn) {
+    if (!cmd.wantsHeaders()) {
+      return false;
+    }
+    Http2Stream stream = conn.stream(cmd.stream().id());
+    return stream != null && !stream.isHeadersSent();
+  }
+
+  private void gracefulClose(final ChannelHandlerContext ctx, final GracefulServerCloseCommand msg,
+      ChannelPromise promise) throws Exception {
+    // Ideally we'd adjust a pre-existing graceful shutdown's grace period to at least what is
+    // requested here. But that's an edge case and seems bug-prone.
+    if (gracefulShutdown == null) {
+      Long graceTimeInNanos = null;
+      if (msg.getGraceTimeUnit() != null) {
+        graceTimeInNanos = msg.getGraceTimeUnit().toNanos(msg.getGraceTime());
+      }
+      gracefulShutdown = new GracefulShutdown(msg.getGoAwayDebugString(), graceTimeInNanos);
+      gracefulShutdown.start(ctx);
+    }
+    promise.setSuccess();
   }
 
   private void forcefulClose(final ChannelHandlerContext ctx, final ForcefulCloseCommand msg,
       ChannelPromise promise) throws Exception {
-    close(ctx, promise);
+    super.close(ctx, promise);
     connection().forEachActiveStream(new Http2StreamVisitor() {
       @Override
       public boolean visit(Http2Stream stream) throws Http2Exception {
         NettyServerStream.TransportState serverStream = serverStream(stream);
         if (serverStream != null) {
-          serverStream.transportReportStatus(msg.getStatus());
-          resetStream(ctx, stream.id(), Http2Error.CANCEL.code(), ctx.newPromise());
+          try (TaskCloseable ignore = PerfMark.traceTask("NettyServerHandler.forcefulClose")) {
+            PerfMark.attachTag(serverStream.tag());
+            PerfMark.linkIn(msg.getLink());
+            serverStream.transportReportStatus(msg.getStatus());
+            resetStream(ctx, stream.id(), Http2Error.CANCEL.code(), ctx.newPromise());
+          }
         }
         stream.close();
         return true;
@@ -405,17 +875,29 @@ public boolean visit(Http2Stream stream) throws Http2Exception {
     });
   }
 
-  private void verifyContentType(int streamId, Http2Headers headers) throws Http2Exception {
-    CharSequence contentType = headers.get(CONTENT_TYPE_HEADER);
-    if (contentType == null) {
-      throw Http2Exception.streamError(streamId, Http2Error.REFUSED_STREAM,
-          "Content-Type is missing from the request");
-    }
-    String contentTypeString = contentType.toString();
-    if (!GrpcUtil.isGrpcContentType(contentTypeString)) {
-      throw Http2Exception.streamError(streamId, Http2Error.REFUSED_STREAM,
-          "Content-Type '%s' is not supported", contentTypeString);
+  private void respondWithHttpError(
+      ChannelHandlerContext ctx, int streamId, int code, Status.Code statusCode, String msg) {
+    respondWithHttpError(ctx, streamId, code, statusCode, msg, EmptyHttp2Headers.INSTANCE);
+  }
+
+  private void respondWithHttpError(
+      ChannelHandlerContext ctx, int streamId, int code, Status.Code statusCode, String msg,
+      Http2Headers extraHeaders) {
+    Metadata metadata = new Metadata();
+    metadata.put(InternalStatus.CODE_KEY, statusCode.toStatus());
+    metadata.put(InternalStatus.MESSAGE_KEY, msg);
+    byte[][] serialized = InternalMetadata.serialize(metadata);
+
+    Http2Headers headers = new DefaultHttp2Headers(true, serialized.length / 2)
+        .status("" + code)
+        .set(CONTENT_TYPE_HEADER, "text/plain; charset=utf-8");
+    for (int i = 0; i < serialized.length; i += 2) {
+      headers.add(new AsciiString(serialized[i], false), new AsciiString(serialized[i + 1], false));
     }
+    headers.add(extraHeaders);
+    encoder().writeHeaders(ctx, streamId, headers, 0, false, ctx.newPromise());
+    ByteBuf msgBuf = ByteBufUtil.writeUtf8(ctx.alloc(), msg);
+    encoder().writeData(ctx, streamId, msgBuf, 0, true, ctx.newPromise());
   }
 
   private Http2Stream requireHttp2Stream(int streamId) {
@@ -427,20 +909,6 @@ private Http2Stream requireHttp2Stream(int streamId) {
     return stream;
   }
 
-  private String determineMethod(int streamId, Http2Headers headers) throws Http2Exception {
-    if (!HTTP_METHOD.equals(headers.method())) {
-      throw Http2Exception.streamError(streamId, Http2Error.REFUSED_STREAM,
-          "Method '%s' is not supported", headers.method());
-    }
-    // Remove the leading slash of the path and get the fully qualified method name
-    CharSequence path = headers.path();
-    if (path.charAt(0) != '/') {
-      throw Http2Exception.streamError(streamId, Http2Error.REFUSED_STREAM,
-          "Malformatted path: %s", path);
-    }
-    return path.subSequence(1, path.length()).toString();
-  }
-
   /**
    * Returns the server stream associated to the given HTTP/2 stream object.
    */
@@ -450,14 +918,28 @@ private NettyServerStream.TransportState serverStream(Http2Stream stream) {
 
   private Http2Exception newStreamException(int streamId, Throwable cause) {
     return Http2Exception.streamError(
-        streamId, Http2Error.INTERNAL_ERROR, cause, cause.getMessage());
+        streamId, Http2Error.INTERNAL_ERROR, cause, Strings.nullToEmpty(cause.getMessage()));
   }
 
   private class FrameListener extends Http2FrameAdapter {
+    private boolean firstSettings = true;
+
+    @Override
+    public void onSettingsRead(ChannelHandlerContext ctx, Http2Settings settings) {
+      if (firstSettings) {
+        firstSettings = false;
+        // Delay transportReady until we see the client's HTTP handshake, for coverage with
+        // handshakeTimeout
+        attributes = transportListener.transportReady(negotiationAttributes);
+      }
+    }
 
     @Override
     public int onDataRead(ChannelHandlerContext ctx, int streamId, ByteBuf data, int padding,
         boolean endOfStream) throws Http2Exception {
+      if (keepAliveManager != null) {
+        keepAliveManager.onDataReceived();
+      }
       NettyServerHandler.this.onDataRead(streamId, data, padding, endOfStream);
       return padding;
     }
@@ -471,26 +953,326 @@ public void onHeadersRead(ChannelHandlerContext ctx,
         boolean exclusive,
         int padding,
         boolean endStream) throws Http2Exception {
+      if (keepAliveManager != null) {
+        keepAliveManager.onDataReceived();
+      }
       NettyServerHandler.this.onHeadersRead(ctx, streamId, headers);
+      if (endStream) {
+        NettyServerHandler.this.onDataRead(streamId, Unpooled.EMPTY_BUFFER, 0, endStream);
+      }
     }
 
     @Override
     public void onRstStreamRead(ChannelHandlerContext ctx, int streamId, long errorCode)
         throws Http2Exception {
-      NettyServerHandler.this.onRstStreamRead(streamId);
+      if (keepAliveManager != null) {
+        keepAliveManager.onDataReceived();
+      }
+      NettyServerHandler.this.onRstStreamRead(streamId, errorCode);
+    }
+
+    @Override
+    public void onPingRead(ChannelHandlerContext ctx, long data) throws Http2Exception {
+      if (keepAliveManager != null) {
+        keepAliveManager.onDataReceived();
+      }
+      if (!keepAliveEnforcer.pingAcceptable()) {
+        ByteBuf debugData = ByteBufUtil.writeAscii(ctx.alloc(), "too_many_pings");
+        goAway(ctx, connection().remote().lastStreamCreated(), Http2Error.ENHANCE_YOUR_CALM.code(),
+            debugData, ctx.newPromise());
+        Status status = Status.RESOURCE_EXHAUSTED.withDescription("Too many pings from client");
+        try {
+          forcefulClose(ctx, new ForcefulCloseCommand(status), ctx.newPromise());
+        } catch (Exception ex) {
+          onError(ctx, /* outbound= */ true, ex);
+        }
+      }
     }
 
     @Override
-    public void onPingAckRead(ChannelHandlerContext ctx, ByteBuf data) throws Http2Exception {
-      if (data.getLong(data.readerIndex()) == flowControlPing().payload()) {
+    public void onPingAckRead(ChannelHandlerContext ctx, long data) throws Http2Exception {
+      if (keepAliveManager != null) {
+        keepAliveManager.onDataReceived();
+      }
+      if (data == flowControlPing().payload()) {
         flowControlPing().updateWindow();
-        if (logger.isLoggable(Level.FINE)) {
-          logger.log(Level.FINE, String.format("Window: %d",
-              decoder().flowController().initialWindowSize(connection().connectionStream())));
+        logger.log(Level.FINE, "Window: {0}",
+            decoder().flowController().initialWindowSize(connection().connectionStream()));
+      } else if (data == GRACEFUL_SHUTDOWN_PING) {
+        if (gracefulShutdown == null) {
+          // this should never happen
+          logger.warning("Received GRACEFUL_SHUTDOWN_PING Ack but gracefulShutdown is null");
+        } else {
+          gracefulShutdown.secondGoAwayAndClose(ctx);
         }
-      } else {
+      } else if (data != KEEPALIVE_PING) {
         logger.warning("Received unexpected ping ack. No ping outstanding");
       }
     }
   }
+
+  private final class KeepAlivePinger implements KeepAliveManager.KeepAlivePinger {
+    final ChannelHandlerContext ctx;
+
+    KeepAlivePinger(ChannelHandlerContext ctx) {
+      this.ctx = ctx;
+    }
+
+    @Override
+    public void ping() {
+      ChannelFuture pingFuture = encoder().writePing(
+          ctx, false /* isAck */, KEEPALIVE_PING, ctx.newPromise());
+      ctx.flush();
+      pingFuture.addListener(new ChannelFutureListener() {
+        @Override
+        public void operationComplete(ChannelFuture future) throws Exception {
+          if (future.isSuccess()) {
+            transportTracer.reportKeepAliveSent();
+          }
+        }
+      });
+    }
+
+    @Override
+    public void onPingTimeout() {
+      try {
+        forcefulClose(
+            ctx,
+            new ForcefulCloseCommand(Status.UNAVAILABLE
+                .withDescription("Keepalive failed. The connection is likely gone")),
+            ctx.newPromise());
+      } catch (Exception ex) {
+        try {
+          exceptionCaught(ctx, ex);
+        } catch (Exception ex2) {
+          logger.log(Level.WARNING, "Exception while propagating exception", ex2);
+          logger.log(Level.WARNING, "Original failure", ex);
+        }
+      }
+    }
+  }
+
+  private final class GracefulShutdown {
+    String goAwayMessage;
+
+    /**
+     * The grace time between starting graceful shutdown and closing the netty channel,
+     * {@code null} is unspecified.
+     */
+    @CheckForNull
+    Long graceTimeInNanos;
+
+    /**
+     * True if ping is Acked or ping is timeout.
+     */
+    boolean pingAckedOrTimeout;
+
+    Future<?> pingFuture;
+
+    GracefulShutdown(String goAwayMessage,
+        @Nullable Long graceTimeInNanos) {
+      this.goAwayMessage = goAwayMessage;
+      this.graceTimeInNanos = graceTimeInNanos;
+    }
+
+    /**
+     * Sends out first GOAWAY and ping, and schedules second GOAWAY and close.
+     */
+    void start(final ChannelHandlerContext ctx) {
+      goAway(
+          ctx,
+          Integer.MAX_VALUE,
+          Http2Error.NO_ERROR.code(),
+          ByteBufUtil.writeAscii(ctx.alloc(), goAwayMessage),
+          ctx.newPromise());
+
+      pingFuture = ctx.executor().schedule(
+          new Runnable() {
+            @Override
+            public void run() {
+              secondGoAwayAndClose(ctx);
+            }
+          },
+          GRACEFUL_SHUTDOWN_PING_TIMEOUT_NANOS,
+          TimeUnit.NANOSECONDS);
+
+      encoder().writePing(ctx, false /* isAck */, GRACEFUL_SHUTDOWN_PING, ctx.newPromise());
+    }
+
+    void secondGoAwayAndClose(ChannelHandlerContext ctx) {
+      if (pingAckedOrTimeout) {
+        return;
+      }
+      pingAckedOrTimeout = true;
+
+      checkNotNull(pingFuture, "pingFuture");
+      pingFuture.cancel(false);
+
+      // send the second GOAWAY with last stream id
+      goAway(
+          ctx,
+          connection().remote().lastStreamCreated(),
+          Http2Error.NO_ERROR.code(),
+          ByteBufUtil.writeAscii(ctx.alloc(), goAwayMessage),
+          ctx.newPromise());
+
+      // gracefully shutdown with specified grace time
+      long savedGracefulShutdownTimeMillis = gracefulShutdownTimeoutMillis();
+      long overriddenGraceTime = graceTimeOverrideMillis(savedGracefulShutdownTimeMillis);
+      try {
+        gracefulShutdownTimeoutMillis(overriddenGraceTime);
+        NettyServerHandler.super.close(ctx, ctx.newPromise());
+      } catch (Exception e) {
+        onError(ctx, /* outbound= */ true, e);
+      } finally {
+        gracefulShutdownTimeoutMillis(savedGracefulShutdownTimeMillis);
+      }
+    }
+
+    private long graceTimeOverrideMillis(long originalMillis) {
+      if (graceTimeInNanos == null) {
+        return originalMillis;
+      }
+      if (graceTimeInNanos == MAX_CONNECTION_AGE_GRACE_NANOS_INFINITE) {
+        // netty treats -1 as "no timeout"
+        return -1L;
+      }
+      return TimeUnit.NANOSECONDS.toMillis(graceTimeInNanos);
+    }
+  }
+
+  // Use a frame writer so that we know when frames are through flow control and actually being
+  // written.
+  private static class WriteMonitoringFrameWriter extends DecoratingHttp2FrameWriter {
+    private final KeepAliveEnforcer keepAliveEnforcer;
+
+    public WriteMonitoringFrameWriter(Http2FrameWriter delegate,
+        KeepAliveEnforcer keepAliveEnforcer) {
+      super(delegate);
+      this.keepAliveEnforcer = keepAliveEnforcer;
+    }
+
+    @Override
+    public ChannelFuture writeData(ChannelHandlerContext ctx, int streamId, ByteBuf data,
+        int padding, boolean endStream, ChannelPromise promise) {
+      keepAliveEnforcer.resetCounters();
+      return super.writeData(ctx, streamId, data, padding, endStream, promise);
+    }
+
+    @Override
+    public ChannelFuture writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers,
+        int padding, boolean endStream, ChannelPromise promise) {
+      keepAliveEnforcer.resetCounters();
+      return super.writeHeaders(ctx, streamId, headers, padding, endStream, promise);
+    }
+
+    @Override
+    public ChannelFuture writeHeaders(ChannelHandlerContext ctx, int streamId, Http2Headers headers,
+        int streamDependency, short weight, boolean exclusive, int padding, boolean endStream,
+        ChannelPromise promise) {
+      keepAliveEnforcer.resetCounters();
+      return super.writeHeaders(ctx, streamId, headers, streamDependency, weight, exclusive,
+          padding, endStream, promise);
+    }
+  }
+
+  private static final class Http2RstCounterEncoder extends DecoratingHttp2ConnectionEncoder {
+    private final RstStreamCounter rstStreamCounter;
+    private Http2LifecycleManager lifecycleManager;
+
+    Http2RstCounterEncoder(Http2ConnectionEncoder encoder, RstStreamCounter rstStreamCounter) {
+      super(encoder);
+      this.rstStreamCounter = rstStreamCounter;
+    }
+
+    @Override
+    public void lifecycleManager(Http2LifecycleManager lifecycleManager) {
+      this.lifecycleManager = lifecycleManager;
+      super.lifecycleManager(lifecycleManager);
+    }
+
+    @Override
+    public ChannelFuture writeRstStream(
+        ChannelHandlerContext ctx, int streamId, long errorCode, ChannelPromise promise) {
+      ChannelFuture future = super.writeRstStream(ctx, streamId, errorCode, promise);
+      // We want to count "induced" RST_STREAM, where the server sent a reset because of a malformed
+      // frame.
+      boolean normalRst
+          = errorCode == Http2Error.NO_ERROR.code() || errorCode == Http2Error.CANCEL.code();
+      if (!normalRst) {
+        Http2Exception tooManyRstStream = rstStreamCounter.countRstStream();
+        if (tooManyRstStream != null) {
+          lifecycleManager.onError(ctx, true, tooManyRstStream);
+          ctx.close();
+        }
+      }
+      return future;
+    }
+  }
+
+  private static final class RstStreamCounter {
+    private final int maxRstCount;
+    private final long maxRstPeriodNanos;
+    private final Ticker ticker;
+    private int rstCount;
+    private long lastRstNanoTime;
+
+    RstStreamCounter(int maxRstCount, long maxRstPeriodNanos, Ticker ticker) {
+      checkArgument(maxRstCount >= 0, "maxRstCount must be non-negative: %s", maxRstCount);
+      this.maxRstCount = maxRstCount;
+      this.maxRstPeriodNanos = maxRstPeriodNanos;
+      this.ticker = checkNotNull(ticker, "ticker");
+      this.lastRstNanoTime = ticker.read();
+    }
+
+    /** Returns non-{@code null} when the connection should be killed by the caller. */
+    private Http2Exception countRstStream() {
+      if (maxRstCount == 0) {
+        return null;
+      }
+      long now = ticker.read();
+      if (now - lastRstNanoTime > maxRstPeriodNanos) {
+        lastRstNanoTime = now;
+        rstCount = 1;
+      } else {
+        rstCount++;
+        if (rstCount > maxRstCount) {
+          return new Http2Exception(Http2Error.ENHANCE_YOUR_CALM, "too_many_rststreams") {
+            @SuppressWarnings("UnsynchronizedOverridesSynchronized") // No memory accesses
+            @Override
+            public Throwable fillInStackTrace() {
+              // Avoid the CPU cycles, since the resets may be a CPU consumption attack
+              return this;
+            }
+          };
+        }
+      }
+      return null;
+    }
+  }
+
+  private static class ServerChannelLogger extends ChannelLogger {
+    private static final Logger log = Logger.getLogger(ChannelLogger.class.getName());
+
+    @Override
+    public void log(ChannelLogLevel level, String message) {
+      log.log(toJavaLogLevel(level), message);
+    }
+
+    @Override
+    public void log(ChannelLogLevel level, String messageFormat, Object... args) {
+      log(level, MessageFormat.format(messageFormat, args));
+    }
+  }
+
+  private static Level toJavaLogLevel(ChannelLogLevel level) {
+    switch (level) {
+      case ERROR:
+        return Level.FINE;
+      case WARNING:
+        return Level.FINER;
+      default:
+        return Level.FINEST;
+    }
+  }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NettyServerProvider.java b/netty/src/main/java/io/grpc/netty/NettyServerProvider.java
index 87d99697b8f..42d075d05cb 100644
--- a/netty/src/main/java/io/grpc/netty/NettyServerProvider.java
+++ b/netty/src/main/java/io/grpc/netty/NettyServerProvider.java
@@ -1,41 +1,27 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
 import io.grpc.Internal;
+import io.grpc.ServerCredentials;
 import io.grpc.ServerProvider;
+import java.net.InetSocketAddress;
 
-
-/** Provider for {@link NettyChannelBuilder} instances. */
+/** Provider for {@link NettyServerBuilder} instances. */
 @Internal
 public final class NettyServerProvider extends ServerProvider {
 
@@ -53,5 +39,15 @@ protected int priority() {
   protected NettyServerBuilder builderForPort(int port) {
     return NettyServerBuilder.forPort(port);
   }
+
+  @Override
+  protected NewServerBuilderResult newServerBuilderForPort(int port, ServerCredentials creds) {
+    ProtocolNegotiators.FromServerCredentialsResult result = ProtocolNegotiators.from(creds);
+    if (result.error != null) {
+      return NewServerBuilderResult.error(result.error);
+    }
+    return NewServerBuilderResult.serverBuilder(
+        new NettyServerBuilder(new InetSocketAddress(port), result.negotiator));
+  }
 }
 
diff --git a/netty/src/main/java/io/grpc/netty/NettyServerStream.java b/netty/src/main/java/io/grpc/netty/NettyServerStream.java
index 8e888af10d6..836f39ddf19 100644
--- a/netty/src/main/java/io/grpc/netty/NettyServerStream.java
+++ b/netty/src/main/java/io/grpc/netty/NettyServerStream.java
@@ -1,50 +1,42 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
+import com.google.common.base.Preconditions;
 import io.grpc.Attributes;
 import io.grpc.Metadata;
 import io.grpc.Status;
 import io.grpc.internal.AbstractServerStream;
 import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.TransportTracer;
 import io.grpc.internal.WritableBuffer;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.EventLoop;
 import io.netty.handler.codec.http2.Http2Headers;
 import io.netty.handler.codec.http2.Http2Stream;
+import io.perfmark.Link;
+import io.perfmark.PerfMark;
+import io.perfmark.Tag;
+import io.perfmark.TaskCloseable;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -57,19 +49,24 @@ class NettyServerStream extends AbstractServerStream {
 
   private final Sink sink = new Sink();
   private final TransportState state;
-  private final Channel channel;
   private final WriteQueue writeQueue;
   private final Attributes attributes;
   private final String authority;
-
-  public NettyServerStream(Channel channel, TransportState state, Attributes transportAttrs,
-      String authority, StatsTraceContext statsTraceCtx) {
+  private final int streamId;
+
+  public NettyServerStream(
+      Channel channel,
+      TransportState state,
+      Attributes transportAttrs,
+      String authority,
+      StatsTraceContext statsTraceCtx) {
     super(new NettyWritableBufferAllocator(channel.alloc()), statsTraceCtx);
     this.state = checkNotNull(state, "transportState");
-    this.channel = checkNotNull(channel, "channel");
     this.writeQueue = state.handler.getWriteQueue();
     this.attributes = checkNotNull(transportAttrs);
     this.authority = authority;
+    // Read the id early to avoid reading transportState later.
+    this.streamId = transportState().id();
   }
 
   @Override
@@ -94,73 +91,91 @@ public String getAuthority() {
 
   private class Sink implements AbstractServerStream.Sink {
     @Override
-    public void request(final int numMessages) {
-      if (channel.eventLoop().inEventLoop()) {
-        // Processing data read in the event loop so can call into the deframer immediately
-        transportState().requestMessagesFromDeframer(numMessages);
-      } else {
-        channel.eventLoop().execute(new Runnable() {
-          @Override
-          public void run() {
-            transportState().requestMessagesFromDeframer(numMessages);
-          }
-        });
+    public void writeHeaders(Metadata headers, boolean flush) {
+      try (TaskCloseable ignore = PerfMark.traceTask("NettyServerStream$Sink.writeHeaders")) {
+        Http2Headers http2headers = Utils.convertServerHeaders(headers);
+        SendResponseHeadersCommand headersCommand =
+            SendResponseHeadersCommand.createHeaders(transportState(), http2headers);
+        writeQueue.enqueue(headersCommand, flush)
+            .addListener((ChannelFutureListener) transportState()::handleWriteFutureFailures);
       }
     }
 
     @Override
-    public void writeHeaders(Metadata headers) {
-      writeQueue.enqueue(new SendResponseHeadersCommand(transportState(),
-          Utils.convertServerHeaders(headers), false),
-          true);
-    }
-
-    @Override
-    public void writeFrame(WritableBuffer frame, boolean flush) {
-      if (frame == null) {
-        writeQueue.scheduleFlush();
-        return;
+    public void writeFrame(WritableBuffer frame, boolean flush, final int numMessages) {
+      try (TaskCloseable ignore = PerfMark.traceTask("NettyServerStream$Sink.writeFrame")) {
+        Preconditions.checkArgument(numMessages >= 0);
+        ByteBuf bytebuf = ((NettyWritableBuffer) frame).bytebuf().touch();
+        final int numBytes = bytebuf.readableBytes();
+        // Add the bytes to outbound flow control.
+        onSendingBytes(numBytes);
+        ChannelFutureListener failureListener =
+            future -> transportState().onWriteFrameData(future, numMessages, numBytes);
+        writeQueue.enqueue(new SendGrpcFrameCommand(transportState(), bytebuf, false), flush)
+            .addListener(failureListener);
       }
-      ByteBuf bytebuf = ((NettyWritableBuffer) frame).bytebuf();
-      final int numBytes = bytebuf.readableBytes();
-      // Add the bytes to outbound flow control.
-      onSendingBytes(numBytes);
-      writeQueue.enqueue(
-          new SendGrpcFrameCommand(transportState(), bytebuf, false),
-          channel.newPromise().addListener(new ChannelFutureListener() {
-            @Override
-            public void operationComplete(ChannelFuture future) throws Exception {
-              // Remove the bytes from outbound flow control, optionally notifying
-              // the client that they can send more bytes.
-              transportState().onSentBytes(numBytes);
-            }
-          }), flush);
     }
 
     @Override
-    public void writeTrailers(Metadata trailers, boolean headersSent) {
-      Http2Headers http2Trailers = Utils.convertTrailers(trailers, headersSent);
-      writeQueue.enqueue(
-          new SendResponseHeadersCommand(transportState(), http2Trailers, true), true);
+    public void writeTrailers(Metadata trailers, boolean headersSent, Status status) {
+      try (TaskCloseable ignore = PerfMark.traceTask("NettyServerStream$Sink.writeTrailers")) {
+        Http2Headers http2Trailers = Utils.convertTrailers(trailers, headersSent);
+        SendResponseHeadersCommand trailersCommand =
+            SendResponseHeadersCommand.createTrailers(transportState(), http2Trailers, status);
+        writeQueue.enqueue(trailersCommand, true)
+            .addListener((ChannelFutureListener) transportState()::handleWriteFutureFailures);
+      }
     }
 
     @Override
     public void cancel(Status status) {
-      writeQueue.enqueue(new CancelServerStreamCommand(transportState(), status), true);
+      try (TaskCloseable ignore = PerfMark.traceTask("NettyServerStream$Sink.cancel")) {
+        writeQueue.enqueue(CancelServerStreamCommand.withReset(transportState(), status), true);
+      }
     }
   }
 
-  /** This should only called from the transport thread. */
+  /** This should only be called from the transport thread. */
   public static class TransportState extends AbstractServerStream.TransportState
       implements StreamIdHolder {
     private final Http2Stream http2Stream;
     private final NettyServerHandler handler;
-
-    public TransportState(NettyServerHandler handler, Http2Stream http2Stream, int maxMessageSize,
-        StatsTraceContext statsTraceCtx) {
-      super(maxMessageSize, statsTraceCtx);
+    private final EventLoop eventLoop;
+    private final Tag tag;
+
+    public TransportState(
+        NettyServerHandler handler,
+        EventLoop eventLoop,
+        Http2Stream http2Stream,
+        int maxMessageSize,
+        StatsTraceContext statsTraceCtx,
+        TransportTracer transportTracer,
+        String methodName) {
+      super(maxMessageSize, statsTraceCtx, transportTracer);
       this.http2Stream = checkNotNull(http2Stream, "http2Stream");
       this.handler = checkNotNull(handler, "handler");
+      this.eventLoop = eventLoop;
+      this.tag = PerfMark.createTag(methodName, http2Stream.id());
+    }
+
+    @Override
+    public void runOnTransportThread(final Runnable r) {
+      if (eventLoop.inEventLoop()) {
+        r.run();
+      } else {
+        final Link link = PerfMark.linkOut();
+        eventLoop.execute(new Runnable() {
+          @Override
+          public void run() {
+            try (TaskCloseable ignore =
+                     PerfMark.traceTask("NettyServerStream$TransportState.runOnTransportThread")) {
+              PerfMark.attachTag(tag);
+              PerfMark.linkIn(link);
+              r.run();
+            }
+          }
+        });
+      }
     }
 
     @Override
@@ -170,11 +185,44 @@ public void bytesRead(int processedBytes) {
     }
 
     @Override
-    protected void deframeFailed(Throwable cause) {
+    public void deframeFailed(Throwable cause) {
       log.log(Level.WARNING, "Exception processing message", cause);
       Status status = Status.fromThrowable(cause);
       transportReportStatus(status);
-      handler.getWriteQueue().enqueue(new CancelServerStreamCommand(this, status), true);
+      handler.getWriteQueue().enqueue(CancelServerStreamCommand.withReason(this, status), true);
+    }
+
+    private void onWriteFrameData(ChannelFuture future, int numMessages, int numBytes) {
+      // Remove the bytes from outbound flow control, optionally notifying
+      // the client that they can send more bytes.
+      if (future.isSuccess()) {
+        onSentBytes(numBytes);
+        getTransportTracer().reportMessageSent(numMessages);
+      } else {
+        handleWriteFutureFailures(future);
+      }
+    }
+
+    private void handleWriteFutureFailures(ChannelFuture future) {
+      // isStreamDeallocated() check protects from spamming stream resets by scheduling multiple
+      // CancelServerStreamCommand commands.
+      if (future.isSuccess() || isStreamDeallocated()) {
+        return;
+      }
+
+      // Future failed, fail RPC.
+      // Normally we don't need to do anything on frame write failures because the cause of
+      // the failed future would be an IO error that closed the stream.
+      // However, we still need handle any unexpected failures raised in Netty.
+      http2ProcessingFailed(Utils.statusFromThrowable(future.cause()));
+    }
+
+    /**
+     * Called to process a failure in HTTP/2 processing.
+     */
+    protected void http2ProcessingFailed(Status status) {
+      transportReportStatus(status);
+      handler.getWriteQueue().enqueue(CancelServerStreamCommand.withReset(this, status), true);
     }
 
     void inboundDataReceived(ByteBuf frame, boolean endOfStream) {
@@ -185,5 +233,15 @@ void inboundDataReceived(ByteBuf frame, boolean endOfStream) {
     public int id() {
       return http2Stream.id();
     }
+
+    @Override
+    public Tag tag() {
+      return tag;
+    }
+  }
+
+  @Override
+  public int streamId() {
+    return streamId;
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NettyServerTransport.java b/netty/src/main/java/io/grpc/netty/NettyServerTransport.java
index 52a8a31073a..758ffeee5b1 100644
--- a/netty/src/main/java/io/grpc/netty/NettyServerTransport.java
+++ b/netty/src/main/java/io/grpc/netty/NettyServerTransport.java
@@ -1,45 +1,47 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
 import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.Attributes;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalLogId;
+import io.grpc.ServerStreamTracer;
 import io.grpc.Status;
-import io.grpc.internal.LogId;
 import io.grpc.internal.ServerTransport;
 import io.grpc.internal.ServerTransportListener;
+import io.grpc.internal.TransportTracer;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelFutureListener;
 import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelPromise;
+import io.netty.util.concurrent.Future;
+import io.netty.util.concurrent.GenericFutureListener;
+import java.io.IOException;
+import java.net.SocketAddress;
+import java.net.SocketException;
+import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -47,26 +49,87 @@
  * The Netty-based server transport.
  */
 class NettyServerTransport implements ServerTransport {
-  private static final Logger log = Logger.getLogger(NettyServerTransport.class.getName());
+  // connectionLog is for connection related messages only
+  private static final Logger connectionLog = Logger.getLogger(
+      String.format("%s.connections", NettyServerTransport.class.getName()));
+
+  // Some exceptions are not very useful and add too much noise to the log
+  private static final ImmutableList<String> QUIET_EXCEPTIONS = ImmutableList.of(
+      "NativeIoException" /* Netty exceptions */);
 
-  private final LogId logId = LogId.allocate(getClass().getName());
+  private final InternalLogId logId;
   private final Channel channel;
+  private final ChannelPromise channelUnused;
   private final ProtocolNegotiator protocolNegotiator;
   private final int maxStreams;
+  // only accessed from channel event loop
+  private NettyServerHandler grpcHandler;
   private ServerTransportListener listener;
   private boolean terminated;
+  private final boolean autoFlowControl;
   private final int flowControlWindow;
   private final int maxMessageSize;
   private final int maxHeaderListSize;
+  private final int softLimitHeaderListSize;
+  private final long keepAliveTimeInNanos;
+  private final long keepAliveTimeoutInNanos;
+  private final long maxConnectionIdleInNanos;
+  private final long maxConnectionAgeInNanos;
+  private final long maxConnectionAgeGraceInNanos;
+  private final boolean permitKeepAliveWithoutCalls;
+  private final long permitKeepAliveTimeInNanos;
+  private final int maxRstCount;
+  private final long maxRstPeriodNanos;
+  private final Attributes eagAttributes;
+  private final List<? extends ServerStreamTracer.Factory> streamTracerFactories;
+  private final TransportTracer transportTracer;
 
-  NettyServerTransport(Channel channel, ProtocolNegotiator protocolNegotiator, int maxStreams,
-      int flowControlWindow, int maxMessageSize, int maxHeaderListSize) {
+  NettyServerTransport(
+      Channel channel,
+      ChannelPromise channelUnused,
+      ProtocolNegotiator protocolNegotiator,
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+      TransportTracer transportTracer,
+      int maxStreams,
+      boolean autoFlowControl,
+      int flowControlWindow,
+      int maxMessageSize,
+      int maxHeaderListSize,
+      int softLimitHeaderListSize,
+      long keepAliveTimeInNanos,
+      long keepAliveTimeoutInNanos,
+      long maxConnectionIdleInNanos,
+      long maxConnectionAgeInNanos,
+      long maxConnectionAgeGraceInNanos,
+      boolean permitKeepAliveWithoutCalls,
+      long permitKeepAliveTimeInNanos,
+      int maxRstCount,
+      long maxRstPeriodNanos,
+      Attributes eagAttributes) {
     this.channel = Preconditions.checkNotNull(channel, "channel");
+    this.channelUnused = channelUnused;
     this.protocolNegotiator = Preconditions.checkNotNull(protocolNegotiator, "protocolNegotiator");
+    this.streamTracerFactories =
+        Preconditions.checkNotNull(streamTracerFactories, "streamTracerFactories");
+    this.transportTracer = Preconditions.checkNotNull(transportTracer, "transportTracer");
     this.maxStreams = maxStreams;
+    this.autoFlowControl = autoFlowControl;
     this.flowControlWindow = flowControlWindow;
     this.maxMessageSize = maxMessageSize;
     this.maxHeaderListSize = maxHeaderListSize;
+    this.softLimitHeaderListSize = softLimitHeaderListSize;
+    this.keepAliveTimeInNanos = keepAliveTimeInNanos;
+    this.keepAliveTimeoutInNanos = keepAliveTimeoutInNanos;
+    this.maxConnectionIdleInNanos = maxConnectionIdleInNanos;
+    this.maxConnectionAgeInNanos = maxConnectionAgeInNanos;
+    this.maxConnectionAgeGraceInNanos = maxConnectionAgeGraceInNanos;
+    this.permitKeepAliveWithoutCalls = permitKeepAliveWithoutCalls;
+    this.permitKeepAliveTimeInNanos = permitKeepAliveTimeInNanos;
+    this.maxRstCount = maxRstCount;
+    this.maxRstPeriodNanos = maxRstPeriodNanos;
+    this.eagAttributes = Preconditions.checkNotNull(eagAttributes, "eagAttributes");
+    SocketAddress remote = channel.remoteAddress();
+    this.logId = InternalLogId.allocate(getClass(), remote != null ? remote.toString() : null);
   }
 
   public void start(ServerTransportListener listener) {
@@ -74,19 +137,34 @@ public void start(ServerTransportListener listener) {
     this.listener = listener;
 
     // Create the Netty handler for the pipeline.
-    final NettyServerHandler grpcHandler = createHandler(listener);
-    HandlerSettings.setAutoWindow(grpcHandler);
+    grpcHandler = createHandler(listener, channelUnused);
 
     // Notify when the channel closes.
-    channel.closeFuture().addListener(new ChannelFutureListener() {
+    final class TerminationNotifier implements ChannelFutureListener {
+      boolean done;
+
       @Override
       public void operationComplete(ChannelFuture future) throws Exception {
-        notifyTerminated(grpcHandler.connectionError());
+        if (!done) {
+          done = true;
+          notifyTerminated(grpcHandler.connectionError());
+        }
       }
-    });
+    }
 
     ChannelHandler negotiationHandler = protocolNegotiator.newHandler(grpcHandler);
-    channel.pipeline().addLast(negotiationHandler);
+    ChannelHandler bufferingHandler = new WriteBufferingAndExceptionHandler(negotiationHandler);
+
+    ChannelFutureListener terminationNotifier = new TerminationNotifier();
+    channelUnused.addListener(terminationNotifier);
+    channel.closeFuture().addListener(terminationNotifier);
+
+    channel.pipeline().addLast(bufferingHandler);
+  }
+
+  @Override
+  public ScheduledExecutorService getScheduledExecutorService() {
+    return channel.eventLoop();
   }
 
   @Override
@@ -104,7 +182,7 @@ public void shutdownNow(Status reason) {
   }
 
   @Override
-  public LogId getLogId() {
+  public InternalLogId getLogId() {
     return logId;
   }
 
@@ -115,9 +193,23 @@ Channel channel() {
     return channel;
   }
 
+  /**
+   * Accepts a throwable and returns the appropriate logging level. Uninteresting exceptions
+   * should not clutter the log.
+   */
+  @VisibleForTesting
+  static Level getLogLevel(Throwable t) {
+    if (t.getClass().equals(IOException.class)
+        || t.getClass().equals(SocketException.class)
+        || QUIET_EXCEPTIONS.contains(t.getClass().getSimpleName())) {
+      return Level.FINE;
+    }
+    return Level.INFO;
+  }
+
   private void notifyTerminated(Throwable t) {
     if (t != null) {
-      log.log(Level.SEVERE, "Transport failed", t);
+      connectionLog.log(getLogLevel(t), "Transport failed", t);
     }
     if (!terminated) {
       terminated = true;
@@ -125,11 +217,78 @@ private void notifyTerminated(Throwable t) {
     }
   }
 
+  @Override
+  public ListenableFuture<SocketStats> getStats() {
+    final SettableFuture<SocketStats> result = SettableFuture.create();
+    if (channel.eventLoop().inEventLoop()) {
+      // This is necessary, otherwise we will block forever if we get the future from inside
+      // the event loop.
+      result.set(getStatsHelper(channel));
+      return result;
+    }
+    channel.eventLoop().submit(
+        new Runnable() {
+          @Override
+          public void run() {
+            result.set(getStatsHelper(channel));
+          }
+        })
+        .addListener(
+            new GenericFutureListener<Future<Object>>() {
+              @Override
+              public void operationComplete(Future<Object> future) throws Exception {
+                if (!future.isSuccess()) {
+                  result.setException(future.cause());
+                }
+              }
+            });
+    return result;
+  }
+
+  private SocketStats getStatsHelper(Channel ch) {
+    Preconditions.checkState(ch.eventLoop().inEventLoop());
+    return new SocketStats(
+        transportTracer.getStats(),
+        channel.localAddress(),
+        channel.remoteAddress(),
+        Utils.getSocketOptions(ch),
+        grpcHandler == null ? null : grpcHandler.getSecurityInfo());
+
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("logId", logId.getId())
+        .add("channel", channel)
+        .toString();
+  }
+
   /**
    * Creates the Netty handler to be used in the channel pipeline.
    */
-  private NettyServerHandler createHandler(ServerTransportListener transportListener) {
-    return NettyServerHandler.newHandler(transportListener, maxStreams, flowControlWindow,
-        maxHeaderListSize, maxMessageSize);
+  private NettyServerHandler createHandler(
+      ServerTransportListener transportListener, ChannelPromise channelUnused) {
+    return NettyServerHandler.newHandler(
+        transportListener,
+        channelUnused,
+        streamTracerFactories,
+        transportTracer,
+        maxStreams,
+        autoFlowControl,
+        flowControlWindow,
+        maxHeaderListSize,
+        softLimitHeaderListSize,
+        maxMessageSize,
+        keepAliveTimeInNanos,
+        keepAliveTimeoutInNanos,
+        maxConnectionIdleInNanos,
+        maxConnectionAgeInNanos,
+        maxConnectionAgeGraceInNanos,
+        permitKeepAliveWithoutCalls,
+        permitKeepAliveTimeInNanos,
+        maxRstCount,
+        maxRstPeriodNanos,
+        eagAttributes);
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NettySocketSupport.java b/netty/src/main/java/io/grpc/netty/NettySocketSupport.java
new file mode 100644
index 00000000000..528a3978ce9
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/NettySocketSupport.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2018 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.netty;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.InternalChannelz.TcpInfo;
+import io.netty.channel.Channel;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/**
+ * An class for getting low level socket info.
+ */
+final class NettySocketSupport {
+  private static volatile Helper instance = new NettySocketHelperImpl();
+
+  interface Helper {
+    /**
+     * Returns the info on the socket if possible. Returns null if the info can not be discovered.
+     */
+    @Nullable
+    NativeSocketOptions getNativeSocketOptions(Channel ch);
+  }
+
+  /**
+   * A TcpInfo and additional other info that will be turned into channelz socket options.
+   */
+  public static class NativeSocketOptions {
+    @Nullable
+    public final TcpInfo tcpInfo;
+    public final ImmutableMap<String, String> otherInfo;
+
+    /** Creates an instance. */
+    public NativeSocketOptions(
+        TcpInfo tcpInfo,
+        Map<String, String> otherInfo) {
+      Preconditions.checkNotNull(otherInfo);
+      this.tcpInfo = tcpInfo;
+      this.otherInfo = ImmutableMap.copyOf(otherInfo);
+    }
+  }
+
+  public static NativeSocketOptions getNativeSocketOptions(Channel ch) {
+    return instance.getNativeSocketOptions(ch);
+  }
+
+  static void setHelper(Helper helper) {
+    instance = Preconditions.checkNotNull(helper);
+  }
+
+  private static final class NettySocketHelperImpl implements Helper {
+    @Override
+    public NativeSocketOptions getNativeSocketOptions(Channel ch) {
+      // TODO(zpencer): if netty-epoll, use reflection to call EpollSocketChannel.tcpInfo()
+      // And/or if some other low level socket support library is available, call it now.
+      return null;
+    }
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/NettySslContextChannelCredentials.java b/netty/src/main/java/io/grpc/netty/NettySslContextChannelCredentials.java
new file mode 100644
index 00000000000..3d3fdc67e8e
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/NettySslContextChannelCredentials.java
@@ -0,0 +1,39 @@
+/*
+ * 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.netty;
+
+import com.google.common.base.Preconditions;
+import io.grpc.ChannelCredentials;
+import io.grpc.ExperimentalApi;
+import io.netty.handler.ssl.SslContext;
+
+/** A credential that performs TLS with Netty's SslContext as configuration. */
+@ExperimentalApi("There is no plan to make this API stable, given transport API instability")
+public final class NettySslContextChannelCredentials {
+  private NettySslContextChannelCredentials() {}
+
+  /**
+   * Create a credential using Netty's SslContext as configuration. It must have been configured
+   * with {@link GrpcSslContexts}, but options could have been overridden.
+   */
+  public static ChannelCredentials create(SslContext sslContext) {
+    Preconditions.checkArgument(sslContext.isClient(),
+        "Server SSL context can not be used for client channel");
+    GrpcSslContexts.ensureAlpnAndH2Enabled(sslContext.applicationProtocolNegotiator());
+    return NettyChannelCredentials.create(ProtocolNegotiators.tlsClientFactory(sslContext, null));
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/NettySslContextServerCredentials.java b/netty/src/main/java/io/grpc/netty/NettySslContextServerCredentials.java
new file mode 100644
index 00000000000..9396cabdd23
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/NettySslContextServerCredentials.java
@@ -0,0 +1,39 @@
+/*
+ * 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.netty;
+
+import com.google.common.base.Preconditions;
+import io.grpc.ExperimentalApi;
+import io.grpc.ServerCredentials;
+import io.netty.handler.ssl.SslContext;
+
+/** A credential that performs TLS with Netty's SslContext as configuration. */
+@ExperimentalApi("There is no plan to make this API stable, given transport API instability")
+public final class NettySslContextServerCredentials {
+  private NettySslContextServerCredentials() {}
+
+  /**
+   * Create a credential using Netty's SslContext as configuration. It must have been configured
+   * with {@link GrpcSslContexts}, but options could have been overridden.
+   */
+  public static ServerCredentials create(SslContext sslContext) {
+    Preconditions.checkArgument(sslContext.isServer(),
+        "Client SSL context can not be used for server");
+    GrpcSslContexts.ensureAlpnAndH2Enabled(sslContext.applicationProtocolNegotiator());
+    return NettyServerCredentials.create(ProtocolNegotiators.serverTlsFactory(sslContext));
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/NettyWritableBuffer.java b/netty/src/main/java/io/grpc/netty/NettyWritableBuffer.java
index 30a97a1ab1c..b274057d648 100644
--- a/netty/src/main/java/io/grpc/netty/NettyWritableBuffer.java
+++ b/netty/src/main/java/io/grpc/netty/NettyWritableBuffer.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
diff --git a/netty/src/main/java/io/grpc/netty/NettyWritableBufferAllocator.java b/netty/src/main/java/io/grpc/netty/NettyWritableBufferAllocator.java
index e9abb227576..40b84717160 100644
--- a/netty/src/main/java/io/grpc/netty/NettyWritableBufferAllocator.java
+++ b/netty/src/main/java/io/grpc/netty/NettyWritableBufferAllocator.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -48,10 +33,7 @@
  */
 class NettyWritableBufferAllocator implements WritableBufferAllocator {
 
-  // Use 4k as our minimum buffer size.
-  private static final int MIN_BUFFER = 4096;
-
-  // Set the maximum buffer size to 1MB
+  // Set the maximum buffer size to 1MB.
   private static final int MAX_BUFFER = 1024 * 1024;
 
   private final ByteBufAllocator allocator;
@@ -62,7 +44,7 @@ class NettyWritableBufferAllocator implements WritableBufferAllocator {
 
   @Override
   public WritableBuffer allocate(int capacityHint) {
-    capacityHint = Math.min(MAX_BUFFER, Math.max(MIN_BUFFER, capacityHint));
+    capacityHint = Math.min(MAX_BUFFER, capacityHint);
     return new NettyWritableBuffer(allocator.buffer(capacityHint, capacityHint));
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/NoopSslEngine.java b/netty/src/main/java/io/grpc/netty/NoopSslEngine.java
new file mode 100644
index 00000000000..7e14dbf0e79
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/NoopSslEngine.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright 2024 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.netty;
+
+import java.nio.ByteBuffer;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.SSLEngineResult;
+import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLSession;
+
+/**
+ * A no-op implementation of SslEngine, to facilitate overriding only the required methods in
+ * specific implementations.
+ */
+class NoopSslEngine extends SSLEngine {
+  @Override
+  public SSLEngineResult wrap(ByteBuffer[] srcs, int offset, int length, ByteBuffer dst)
+          throws SSLException {
+    return null;
+  }
+
+  @Override
+  public SSLEngineResult unwrap(ByteBuffer src, ByteBuffer[] dsts, int offset, int length)
+          throws SSLException {
+    return null;
+  }
+
+  @Override
+  public Runnable getDelegatedTask() {
+    return null;
+  }
+
+  @Override
+  public void closeInbound() throws SSLException {
+
+  }
+
+  @Override
+  public boolean isInboundDone() {
+    return false;
+  }
+
+  @Override
+  public void closeOutbound() {
+
+  }
+
+  @Override
+  public boolean isOutboundDone() {
+    return false;
+  }
+
+  @Override
+  public String[] getSupportedCipherSuites() {
+    return new String[0];
+  }
+
+  @Override
+  public String[] getEnabledCipherSuites() {
+    return new String[0];
+  }
+
+  @Override
+  public void setEnabledCipherSuites(String[] suites) {
+
+  }
+
+  @Override
+  public String[] getSupportedProtocols() {
+    return new String[0];
+  }
+
+  @Override
+  public String[] getEnabledProtocols() {
+    return new String[0];
+  }
+
+  @Override
+  public void setEnabledProtocols(String[] protocols) {
+
+  }
+
+  @Override
+  public SSLSession getSession() {
+    return null;
+  }
+
+  @Override
+  public void beginHandshake() throws SSLException {
+
+  }
+
+  @Override
+  public SSLEngineResult.HandshakeStatus getHandshakeStatus() {
+    return null;
+  }
+
+  @Override
+  public void setUseClientMode(boolean mode) {
+
+  }
+
+  @Override
+  public boolean getUseClientMode() {
+    return false;
+  }
+
+  @Override
+  public void setNeedClientAuth(boolean need) {
+
+  }
+
+  @Override
+  public boolean getNeedClientAuth() {
+    return false;
+  }
+
+  @Override
+  public void setWantClientAuth(boolean want) {
+
+  }
+
+  @Override
+  public boolean getWantClientAuth() {
+    return false;
+  }
+
+  @Override
+  public void setEnableSessionCreation(boolean flag) {
+
+  }
+
+  @Override
+  public boolean getEnableSessionCreation() {
+    return false;
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/ProtocolNegotiationEvent.java b/netty/src/main/java/io/grpc/netty/ProtocolNegotiationEvent.java
new file mode 100644
index 00000000000..8103a2dc79f
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/ProtocolNegotiationEvent.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2019 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.netty;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.Attributes;
+import io.grpc.Internal;
+import io.grpc.InternalChannelz.Security;
+import javax.annotation.Nullable;
+
+/**
+ * Represents a completion of a protocol negotiation stage.
+ */
+@CheckReturnValue
+@Internal
+public final class ProtocolNegotiationEvent {
+
+  static final ProtocolNegotiationEvent DEFAULT =
+      new ProtocolNegotiationEvent(Attributes.EMPTY, /*security=*/ null);
+
+  private final Attributes attributes;
+  @Nullable
+  private final Security security;
+
+  private ProtocolNegotiationEvent(Attributes attributes, @Nullable Security security) {
+    this.attributes = checkNotNull(attributes, "attributes");
+    this.security = security;
+  }
+
+  @Nullable
+  Security getSecurity() {
+    return security;
+  }
+
+  Attributes getAttributes() {
+    return attributes;
+  }
+
+  ProtocolNegotiationEvent withAttributes(Attributes attributes) {
+    return new ProtocolNegotiationEvent(attributes, this.security);
+  }
+
+  ProtocolNegotiationEvent withSecurity(@Nullable Security security) {
+    return new ProtocolNegotiationEvent(this.attributes, security);
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("attributes", attributes)
+        .add("security", security)
+        .toString();
+  }
+
+  /**
+   * This method is not efficient and is intended for testing.
+   */
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(attributes, security);
+  }
+
+  @Override
+  public boolean equals(Object other) {
+    if (!(other instanceof ProtocolNegotiationEvent)) {
+      return false;
+    }
+    ProtocolNegotiationEvent that = (ProtocolNegotiationEvent) other;
+    return Objects.equal(this.attributes, that.attributes)
+        && Objects.equal(this.security, that.security);
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/ProtocolNegotiator.java b/netty/src/main/java/io/grpc/netty/ProtocolNegotiator.java
index fffd59604ab..4332fdf2919 100644
--- a/netty/src/main/java/io/grpc/netty/ProtocolNegotiator.java
+++ b/netty/src/main/java/io/grpc/netty/ProtocolNegotiator.java
@@ -1,55 +1,35 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
-import io.grpc.Internal;
+import io.grpc.internal.ObjectPool;
 import io.netty.channel.ChannelHandler;
 import io.netty.util.AsciiString;
+import java.util.concurrent.Executor;
 
 /**
- * A class that provides a Netty handler to control protocol negotiation.
+ * An class that provides a Netty handler to control protocol negotiation.
  */
-@Internal
-public interface ProtocolNegotiator {
+interface ProtocolNegotiator {
 
   /**
-   * The Netty handler to control the protocol negotiation.
+   * The HTTP/2 scheme to be used when sending {@code HEADERS}.
    */
-  interface Handler extends ChannelHandler {
-    /**
-     * The HTTP/2 scheme to be used when sending {@code HEADERS}.
-     */
-    AsciiString scheme();
-  }
+  AsciiString scheme();
 
   /**
    * Creates a new handler to control the protocol negotiation. Once the negotiation has completed
@@ -57,5 +37,31 @@ interface Handler extends ChannelHandler {
    * grpcHandler.onHandleProtocolNegotiationCompleted()} at certain point if the negotiation has
    * completed successfully.
    */
-  Handler newHandler(GrpcHttp2ConnectionHandler grpcHandler);
+  ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler);
+
+  /**
+   * Releases resources held by this negotiator. Called when the Channel transitions to terminated
+   * or when InternalServer is shutdown (depending on client or server). That means handlers
+   * returned by {@link #newHandler} can outlive their parent negotiator on server-side, but not
+   * on client-side.
+   */
+  void close();
+
+  interface ClientFactory {
+    /** Creates a new negotiator. */
+    ProtocolNegotiator newNegotiator();
+
+    /** Returns the implicit port to use if no port was specified explicitly by the user. */
+    int getDefaultPort();
+  }
+
+  interface ServerFactory {
+    /**
+     * Creates a new negotiator.
+     *
+     * @param offloadExecutorPool an executor pool for time-consuming tasks
+     */
+    ProtocolNegotiator newNegotiator(ObjectPool<? extends Executor> offloadExecutorPool);
+  }
+
 }
diff --git a/netty/src/main/java/io/grpc/netty/ProtocolNegotiators.java b/netty/src/main/java/io/grpc/netty/ProtocolNegotiators.java
index 6311831bb5e..8faf3d0fae8 100644
--- a/netty/src/main/java/io/grpc/netty/ProtocolNegotiators.java
+++ b/netty/src/main/java/io/grpc/netty/ProtocolNegotiators.java
@@ -1,116 +1,415 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
-import static com.google.common.base.Preconditions.checkNotNull;
-import static io.grpc.netty.GrpcSslContexts.NEXT_PROTOCOL_VERSIONS;
+import static com.google.common.base.Preconditions.checkState;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
 import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.ForOverride;
 import io.grpc.Attributes;
+import io.grpc.CallCredentials;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.ChoiceChannelCredentials;
+import io.grpc.ChoiceServerCredentials;
+import io.grpc.CompositeCallCredentials;
+import io.grpc.CompositeChannelCredentials;
 import io.grpc.Grpc;
-import io.grpc.Internal;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.InternalChannelz.Security;
+import io.grpc.InternalChannelz.Tls;
+import io.grpc.SecurityLevel;
+import io.grpc.ServerCredentials;
 import io.grpc.Status;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.TlsServerCredentials;
+import io.grpc.internal.CertificateUtils;
+import io.grpc.internal.GrpcAttributes;
 import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.NoopSslSession;
+import io.grpc.internal.ObjectPool;
 import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelFutureListener;
 import io.netty.channel.ChannelHandler;
-import io.netty.channel.ChannelHandlerAdapter;
 import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelInboundHandler;
 import io.netty.channel.ChannelInboundHandlerAdapter;
-import io.netty.channel.ChannelPipeline;
-import io.netty.channel.ChannelPromise;
+import io.netty.handler.codec.http.DefaultHttpHeaders;
 import io.netty.handler.codec.http.DefaultHttpRequest;
 import io.netty.handler.codec.http.HttpClientCodec;
 import io.netty.handler.codec.http.HttpClientUpgradeHandler;
+import io.netty.handler.codec.http.HttpHeaderNames;
+import io.netty.handler.codec.http.HttpHeaders;
 import io.netty.handler.codec.http.HttpMethod;
 import io.netty.handler.codec.http.HttpVersion;
 import io.netty.handler.codec.http2.Http2ClientUpgradeCodec;
 import io.netty.handler.proxy.HttpProxyHandler;
 import io.netty.handler.proxy.ProxyConnectionEvent;
-import io.netty.handler.proxy.ProxyHandler;
 import io.netty.handler.ssl.OpenSsl;
 import io.netty.handler.ssl.OpenSslEngine;
 import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslContextBuilder;
 import io.netty.handler.ssl.SslHandler;
 import io.netty.handler.ssl.SslHandshakeCompletionEvent;
+import io.netty.handler.ssl.SslProvider;
 import io.netty.util.AsciiString;
-import io.netty.util.ReferenceCountUtil;
+import java.io.ByteArrayInputStream;
 import java.net.SocketAddress;
 import java.net.URI;
-import java.util.ArrayDeque;
+import java.nio.channels.ClosedChannelException;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
 import java.util.Arrays;
-import java.util.Queue;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Executor;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
 import javax.net.ssl.SSLEngine;
+import javax.net.ssl.SSLException;
 import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
 
 /**
  * Common {@link ProtocolNegotiator}s used by gRPC.
  */
-@Internal
-public final class ProtocolNegotiators {
+final class ProtocolNegotiators {
   private static final Logger log = Logger.getLogger(ProtocolNegotiators.class.getName());
+  private static final EnumSet<TlsChannelCredentials.Feature> understoodTlsFeatures =
+      EnumSet.of(
+          TlsChannelCredentials.Feature.MTLS, TlsChannelCredentials.Feature.CUSTOM_MANAGERS);
+  private static final EnumSet<TlsServerCredentials.Feature> understoodServerTlsFeatures =
+      EnumSet.of(
+          TlsServerCredentials.Feature.MTLS, TlsServerCredentials.Feature.CUSTOM_MANAGERS);
 
   private ProtocolNegotiators() {
   }
 
+  public static FromChannelCredentialsResult from(ChannelCredentials creds) {
+    if (creds instanceof TlsChannelCredentials) {
+      TlsChannelCredentials tlsCreds = (TlsChannelCredentials) creds;
+      Set<TlsChannelCredentials.Feature> incomprehensible =
+          tlsCreds.incomprehensible(understoodTlsFeatures);
+      if (!incomprehensible.isEmpty()) {
+        return FromChannelCredentialsResult.error(
+            "TLS features not understood: " + incomprehensible);
+      }
+      SslContextBuilder builder = GrpcSslContexts.forClient();
+      if (tlsCreds.getKeyManagers() != null) {
+        builder.keyManager(new FixedKeyManagerFactory(tlsCreds.getKeyManagers()));
+      } else if (tlsCreds.getPrivateKey() != null) {
+        builder.keyManager(
+            new ByteArrayInputStream(tlsCreds.getCertificateChain()),
+            new ByteArrayInputStream(tlsCreds.getPrivateKey()),
+            tlsCreds.getPrivateKeyPassword());
+      }
+      try {
+        List<TrustManager> trustManagers;
+        if (tlsCreds.getTrustManagers() != null) {
+          trustManagers = tlsCreds.getTrustManagers();
+        } else if (tlsCreds.getRootCertificates() != null) {
+          trustManagers = Arrays.asList(CertificateUtils.createTrustManager(
+                  new ByteArrayInputStream(tlsCreds.getRootCertificates())));
+        } else { // else use system default
+          TrustManagerFactory tmf = TrustManagerFactory.getInstance(
+              TrustManagerFactory.getDefaultAlgorithm());
+          tmf.init((KeyStore) null);
+          trustManagers = Arrays.asList(tmf.getTrustManagers());
+        }
+        builder.trustManager(new FixedTrustManagerFactory(trustManagers));
+        TrustManager x509ExtendedTrustManager =
+            CertificateUtils.getX509ExtendedTrustManager(trustManagers);
+        return FromChannelCredentialsResult.negotiator(tlsClientFactory(builder.build(),
+                (X509TrustManager) x509ExtendedTrustManager));
+      } catch (SSLException | GeneralSecurityException ex) {
+        log.log(Level.FINE, "Exception building SslContext", ex);
+        return FromChannelCredentialsResult.error(
+            "Unable to create SslContext: " + ex.getMessage());
+      }
+
+    } else if (creds instanceof InsecureChannelCredentials) {
+      return FromChannelCredentialsResult.negotiator(plaintextClientFactory());
+
+    } else if (creds instanceof CompositeChannelCredentials) {
+      CompositeChannelCredentials compCreds = (CompositeChannelCredentials) creds;
+      return from(compCreds.getChannelCredentials())
+          .withCallCredentials(compCreds.getCallCredentials());
+
+    } else if (creds instanceof NettyChannelCredentials) {
+      NettyChannelCredentials nettyCreds = (NettyChannelCredentials) creds;
+      return FromChannelCredentialsResult.negotiator(nettyCreds.getNegotiator());
+
+    } else if (creds instanceof ChoiceChannelCredentials) {
+      ChoiceChannelCredentials choiceCreds = (ChoiceChannelCredentials) creds;
+      StringBuilder error = new StringBuilder();
+      for (ChannelCredentials innerCreds : choiceCreds.getCredentialsList()) {
+        FromChannelCredentialsResult result = from(innerCreds);
+        if (result.error == null) {
+          return result;
+        }
+        error.append(", ");
+        error.append(result.error);
+      }
+      return FromChannelCredentialsResult.error(error.substring(2));
+
+    } else {
+      return FromChannelCredentialsResult.error(
+          "Unsupported credential type: " + creds.getClass().getName());
+    }
+  }
+
+  public static FromServerCredentialsResult from(ServerCredentials creds) {
+    if (creds instanceof TlsServerCredentials) {
+      TlsServerCredentials tlsCreds = (TlsServerCredentials) creds;
+      Set<TlsServerCredentials.Feature> incomprehensible =
+          tlsCreds.incomprehensible(understoodServerTlsFeatures);
+      if (!incomprehensible.isEmpty()) {
+        return FromServerCredentialsResult.error(
+            "TLS features not understood: " + incomprehensible);
+      }
+      SslContextBuilder builder;
+      if (tlsCreds.getKeyManagers() != null) {
+        builder = GrpcSslContexts.configure(SslContextBuilder.forServer(
+            new FixedKeyManagerFactory(tlsCreds.getKeyManagers())));
+      } else if (tlsCreds.getPrivateKey() != null) {
+        builder = GrpcSslContexts.forServer(
+            new ByteArrayInputStream(tlsCreds.getCertificateChain()),
+            new ByteArrayInputStream(tlsCreds.getPrivateKey()),
+            tlsCreds.getPrivateKeyPassword());
+      } else {
+        throw new AssertionError("BUG! No key");
+      }
+      if (tlsCreds.getTrustManagers() != null) {
+        builder.trustManager(new FixedTrustManagerFactory(tlsCreds.getTrustManagers()));
+      } else if (tlsCreds.getRootCertificates() != null) {
+        builder.trustManager(new ByteArrayInputStream(tlsCreds.getRootCertificates()));
+      } // else use system default
+      switch (tlsCreds.getClientAuth()) {
+        case OPTIONAL:
+          builder.clientAuth(io.netty.handler.ssl.ClientAuth.OPTIONAL);
+          break;
+
+        case REQUIRE:
+          builder.clientAuth(io.netty.handler.ssl.ClientAuth.REQUIRE);
+          break;
+
+        case NONE:
+          builder.clientAuth(io.netty.handler.ssl.ClientAuth.NONE);
+          break;
+
+        default:
+          return FromServerCredentialsResult.error(
+              "Unknown TlsServerCredentials.ClientAuth value: " + tlsCreds.getClientAuth());
+      }
+      SslContext sslContext;
+      try {
+        sslContext = builder.build();
+      } catch (SSLException ex) {
+        throw new IllegalArgumentException(
+            "Unexpected error converting ServerCredentials to Netty SslContext", ex);
+      }
+      return FromServerCredentialsResult.negotiator(serverTlsFactory(sslContext));
+
+    } else if (creds instanceof InsecureServerCredentials) {
+      return FromServerCredentialsResult.negotiator(serverPlaintextFactory());
+
+    } else if (creds instanceof NettyServerCredentials) {
+      NettyServerCredentials nettyCreds = (NettyServerCredentials) creds;
+      return FromServerCredentialsResult.negotiator(nettyCreds.getNegotiator());
+
+    } else if (creds instanceof ChoiceServerCredentials) {
+      ChoiceServerCredentials choiceCreds = (ChoiceServerCredentials) creds;
+      StringBuilder error = new StringBuilder();
+      for (ServerCredentials innerCreds : choiceCreds.getCredentialsList()) {
+        FromServerCredentialsResult result = from(innerCreds);
+        if (result.error == null) {
+          return result;
+        }
+        error.append(", ");
+        error.append(result.error);
+      }
+      return FromServerCredentialsResult.error(error.substring(2));
+
+    } else {
+      return FromServerCredentialsResult.error(
+          "Unsupported credential type: " + creds.getClass().getName());
+    }
+  }
+
+  public static final class FromChannelCredentialsResult {
+    public final ProtocolNegotiator.ClientFactory negotiator;
+    public final CallCredentials callCredentials;
+    public final String error;
+
+    private FromChannelCredentialsResult(ProtocolNegotiator.ClientFactory negotiator,
+        CallCredentials creds, String error) {
+      this.negotiator = negotiator;
+      this.callCredentials = creds;
+      this.error = error;
+    }
+
+    public static FromChannelCredentialsResult error(String error) {
+      return new FromChannelCredentialsResult(
+          null, null, Preconditions.checkNotNull(error, "error"));
+    }
+
+    public static FromChannelCredentialsResult negotiator(
+        ProtocolNegotiator.ClientFactory factory) {
+      return new FromChannelCredentialsResult(
+          Preconditions.checkNotNull(factory, "factory"), null, null);
+    }
+
+    public FromChannelCredentialsResult withCallCredentials(CallCredentials callCreds) {
+      Preconditions.checkNotNull(callCreds, "callCreds");
+      if (error != null) {
+        return this;
+      }
+      if (this.callCredentials != null) {
+        callCreds = new CompositeCallCredentials(this.callCredentials, callCreds);
+      }
+      return new FromChannelCredentialsResult(negotiator, callCreds, null);
+    }
+  }
+
+  public static final class FromServerCredentialsResult {
+    public final ProtocolNegotiator.ServerFactory negotiator;
+    public final String error;
+
+    private FromServerCredentialsResult(ProtocolNegotiator.ServerFactory negotiator, String error) {
+      this.negotiator = negotiator;
+      this.error = error;
+    }
+
+    public static FromServerCredentialsResult error(String error) {
+      return new FromServerCredentialsResult(null, Preconditions.checkNotNull(error, "error"));
+    }
+
+    public static FromServerCredentialsResult negotiator(ProtocolNegotiator.ServerFactory factory) {
+      return new FromServerCredentialsResult(Preconditions.checkNotNull(factory, "factory"), null);
+    }
+  }
+
+  public static ProtocolNegotiator.ServerFactory fixedServerFactory(
+      ProtocolNegotiator negotiator) {
+    return new FixedProtocolNegotiatorServerFactory(negotiator);
+  }
+
+  private static final class FixedProtocolNegotiatorServerFactory
+      implements ProtocolNegotiator.ServerFactory {
+    private final ProtocolNegotiator protocolNegotiator;
+
+    public FixedProtocolNegotiatorServerFactory(ProtocolNegotiator protocolNegotiator) {
+      this.protocolNegotiator =
+          Preconditions.checkNotNull(protocolNegotiator, "protocolNegotiator");
+    }
+
+    @Override
+    public ProtocolNegotiator newNegotiator(ObjectPool<? extends Executor> offloadExecutorPool) {
+      return protocolNegotiator;
+    }
+  }
+
   /**
    * Create a server plaintext handler for gRPC.
    */
   public static ProtocolNegotiator serverPlaintext() {
+    return new PlaintextProtocolNegotiator();
+  }
+
+  /**
+   * Create a server plaintext handler factory for gRPC.
+   */
+  public static ProtocolNegotiator.ServerFactory serverPlaintextFactory() {
+    return new PlaintextProtocolNegotiatorServerFactory();
+  }
+
+  @VisibleForTesting
+  static final class PlaintextProtocolNegotiatorServerFactory
+      implements ProtocolNegotiator.ServerFactory {
+    @Override
+    public ProtocolNegotiator newNegotiator(ObjectPool<? extends Executor> offloadExecutorPool) {
+      return serverPlaintext();
+    }
+  }
+
+  public static ProtocolNegotiator.ServerFactory serverTlsFactory(SslContext sslContext) {
+    return new TlsProtocolNegotiatorServerFactory(sslContext);
+  }
+
+  @VisibleForTesting
+  static final class TlsProtocolNegotiatorServerFactory
+      implements ProtocolNegotiator.ServerFactory {
+    private final SslContext sslContext;
+
+    public TlsProtocolNegotiatorServerFactory(SslContext sslContext) {
+      this.sslContext = Preconditions.checkNotNull(sslContext, "sslContext");
+    }
+
+    @Override
+    public ProtocolNegotiator newNegotiator(ObjectPool<? extends Executor> offloadExecutorPool) {
+      return serverTls(sslContext, offloadExecutorPool);
+    }
+  }
+
+  /**
+   * Create a server TLS handler for HTTP/2 capable of using ALPN/NPN.
+   * @param executorPool a dedicated {@link Executor} pool for time-consuming TLS tasks
+   */
+  public static ProtocolNegotiator serverTls(final SslContext sslContext,
+      final ObjectPool<? extends Executor> executorPool) {
+    Preconditions.checkNotNull(sslContext, "sslContext");
+    final Executor executor;
+    if (executorPool != null) {
+      // The handlers here can out-live the {@link ProtocolNegotiator}.
+      // To keep their own reference to executor from executorPool, we use an extra (unused)
+      // reference here forces the executor to stay alive, which prevents it from being re-created
+      // for every connection.
+      executor = executorPool.getObject();
+    } else {
+      executor = null;
+    }
     return new ProtocolNegotiator() {
       @Override
-      public Handler newHandler(final GrpcHttp2ConnectionHandler handler) {
-        class PlaintextHandler extends ChannelHandlerAdapter implements Handler {
-          @Override
-          public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
-            // Set sttributes before replace to be sure we pass it before accepting any requests.
-            handler.handleProtocolNegotiationCompleted(Attributes.newBuilder()
-                .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, ctx.channel().remoteAddress())
-                .build());
-            // Just replace this handler with the gRPC handler.
-            ctx.pipeline().replace(this, null, handler);
-          }
+      public ChannelHandler newHandler(GrpcHttp2ConnectionHandler handler) {
+        ChannelHandler gnh = new GrpcNegotiationHandler(handler);
+        ChannelHandler sth = new ServerTlsHandler(gnh, sslContext, executorPool);
+        return new WaitUntilActiveHandler(sth, handler.getNegotiationLogger());
+      }
 
-          @Override
-          public AsciiString scheme() {
-            return Utils.HTTP;
-          }
+      @Override
+      public void close() {
+        if (executorPool != null && executor != null) {
+          executorPool.returnObject(executor);
         }
+      }
 
-        return new PlaintextHandler();
+      @Override
+      public AsciiString scheme() {
+        return Utils.HTTPS;
       }
     };
   }
@@ -119,78 +418,68 @@ public AsciiString scheme() {
    * Create a server TLS handler for HTTP/2 capable of using ALPN/NPN.
    */
   public static ProtocolNegotiator serverTls(final SslContext sslContext) {
-    Preconditions.checkNotNull(sslContext, "sslContext");
-    return new ProtocolNegotiator() {
-      @Override
-      public Handler newHandler(GrpcHttp2ConnectionHandler handler) {
-        return new ServerTlsHandler(sslContext, handler);
-      }
-    };
+    return serverTls(sslContext, null);
   }
 
-  @VisibleForTesting
-  static final class ServerTlsHandler extends ChannelInboundHandlerAdapter
-      implements ProtocolNegotiator.Handler {
-    private final GrpcHttp2ConnectionHandler grpcHandler;
+  static final class ServerTlsHandler extends ChannelInboundHandlerAdapter {
+    private Executor executor;
+    private final ChannelHandler next;
     private final SslContext sslContext;
 
-    ServerTlsHandler(SslContext sslContext, GrpcHttp2ConnectionHandler grpcHandler) {
-      this.sslContext = sslContext;
-      this.grpcHandler = grpcHandler;
+    private ProtocolNegotiationEvent pne = ProtocolNegotiationEvent.DEFAULT;
+
+    ServerTlsHandler(ChannelHandler next,
+        SslContext sslContext,
+        final ObjectPool<? extends Executor> executorPool) {
+      this.sslContext = Preconditions.checkNotNull(sslContext, "sslContext");
+      this.next = Preconditions.checkNotNull(next, "next");
+      if (executorPool != null) {
+        this.executor = executorPool.getObject();
+      }
     }
 
     @Override
     public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
       super.handlerAdded(ctx);
-
       SSLEngine sslEngine = sslContext.newEngine(ctx.alloc());
-      ctx.pipeline().addFirst(new SslHandler(sslEngine, false));
-    }
-
-    @Override
-    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
-      fail(ctx, cause);
+      ctx.pipeline().addBefore(ctx.name(), /* name= */ null, this.executor != null
+          ? new SslHandler(sslEngine, false, this.executor)
+          : new SslHandler(sslEngine, false));
     }
 
     @Override
     public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
-      if (evt instanceof SslHandshakeCompletionEvent) {
+      if (evt instanceof ProtocolNegotiationEvent) {
+        pne = (ProtocolNegotiationEvent) evt;
+      } else if (evt instanceof SslHandshakeCompletionEvent) {
         SslHandshakeCompletionEvent handshakeEvent = (SslHandshakeCompletionEvent) evt;
-        if (handshakeEvent.isSuccess()) {
-          if (NEXT_PROTOCOL_VERSIONS.contains(sslHandler(ctx.pipeline()).applicationProtocol())) {
-            // Successfully negotiated the protocol.
-            // Notify about completion and pass down SSLSession in attributes.
-            grpcHandler.handleProtocolNegotiationCompleted(
-                Attributes.newBuilder()
-                    .set(Grpc.TRANSPORT_ATTR_SSL_SESSION,
-                        sslHandler(ctx.pipeline()).engine().getSession())
-                    .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, ctx.channel().remoteAddress())
-                    .build());
-            // Replace this handler with the GRPC handler.
-            ctx.pipeline().replace(this, null, grpcHandler);
-          } else {
-            fail(ctx, new Exception(
-                "Failed protocol negotiation: Unable to find compatible protocol."));
-          }
-        } else {
-          fail(ctx, handshakeEvent.cause());
+        if (!handshakeEvent.isSuccess()) {
+          logSslEngineDetails(Level.FINE, ctx, "TLS negotiation failed for new client.", null);
+          ctx.fireExceptionCaught(handshakeEvent.cause());
+          return;
+        }
+        SslHandler sslHandler = ctx.pipeline().get(SslHandler.class);
+        if (!sslContext.applicationProtocolNegotiator().protocols().contains(
+                sslHandler.applicationProtocol())) {
+          logSslEngineDetails(Level.FINE, ctx, "TLS negotiation failed for new client.", null);
+          ctx.fireExceptionCaught(unavailableException(
+              "Failed protocol negotiation: Unable to find compatible protocol"));
+          return;
         }
+        ctx.pipeline().replace(ctx.name(), null, next);
+        fireProtocolNegotiationEvent(ctx, sslHandler.engine().getSession());
+      } else {
+        super.userEventTriggered(ctx, evt);
       }
-      super.userEventTriggered(ctx, evt);
     }
 
-    private SslHandler sslHandler(ChannelPipeline pipeline) {
-      return pipeline.get(SslHandler.class);
-    }
-
-    private void fail(ChannelHandlerContext ctx, Throwable exception) {
-      logSslEngineDetails(Level.FINE, ctx, "TLS negotiation failed for new client.", exception);
-      ctx.close();
-    }
-
-    @Override
-    public AsciiString scheme() {
-      return Utils.HTTPS;
+    private void fireProtocolNegotiationEvent(ChannelHandlerContext ctx, SSLSession session) {
+      Security security = new Security(new Tls(session));
+      Attributes attrs = pne.getAttributes().toBuilder()
+          .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.PRIVACY_AND_INTEGRITY)
+          .set(Grpc.TRANSPORT_ATTR_SSL_SESSION, session)
+          .build();
+      ctx.fireUserEventTriggered(pne.withAttributes(attrs).withSecurity(security));
     }
   }
 
@@ -198,21 +487,33 @@ public AsciiString scheme() {
    * Returns a {@link ProtocolNegotiator} that does HTTP CONNECT proxy negotiation.
    */
   public static ProtocolNegotiator httpProxy(final SocketAddress proxyAddress,
-      final @Nullable String proxyUsername, final @Nullable String proxyPassword,
+      final @Nullable Map<String, String> headers, final @Nullable String proxyUsername,
+      final @Nullable String proxyPassword,
       final ProtocolNegotiator negotiator) {
-    Preconditions.checkNotNull(proxyAddress, "proxyAddress");
     Preconditions.checkNotNull(negotiator, "negotiator");
+    Preconditions.checkNotNull(proxyAddress, "proxyAddress");
+    final AsciiString scheme = negotiator.scheme();
     class ProxyNegotiator implements ProtocolNegotiator {
       @Override
-      public Handler newHandler(GrpcHttp2ConnectionHandler http2Handler) {
-        HttpProxyHandler proxyHandler;
-        if (proxyUsername == null || proxyPassword == null) {
-          proxyHandler = new HttpProxyHandler(proxyAddress);
-        } else {
-          proxyHandler = new HttpProxyHandler(proxyAddress, proxyUsername, proxyPassword);
-        }
-        return new BufferUntilProxyTunnelledHandler(
-            proxyHandler, negotiator.newHandler(http2Handler));
+      public ChannelHandler newHandler(GrpcHttp2ConnectionHandler http2Handler) {
+        ChannelHandler protocolNegotiationHandler = negotiator.newHandler(http2Handler);
+        ChannelLogger negotiationLogger = http2Handler.getNegotiationLogger();
+        HttpHeaders httpHeaders = toHttpHeaders(headers);
+        return new ProxyProtocolNegotiationHandler(
+            proxyAddress, httpHeaders, proxyUsername, proxyPassword, protocolNegotiationHandler,
+            negotiationLogger);
+      }
+
+      @Override
+      public AsciiString scheme() {
+        return scheme;
+      }
+
+      // This method is not normally called, because we use httpProxy on a per-connection basis in
+      // NettyChannelBuilder. Instead, we expect `negotiator' to be closed by NettyTransportFactory.
+      @Override
+      public void close() {
+        negotiator.close();
       }
     }
 
@@ -220,54 +521,230 @@ public Handler newHandler(GrpcHttp2ConnectionHandler http2Handler) {
   }
 
   /**
-   * Buffers all writes until the HTTP CONNECT tunnel is established.
+   * Converts generic Map of headers to Netty's HttpHeaders.
+   * Returns null if the map is null or empty.
    */
-  static final class BufferUntilProxyTunnelledHandler extends AbstractBufferingHandler
-      implements ProtocolNegotiator.Handler {
-    private final ProtocolNegotiator.Handler originalHandler;
+  @Nullable
+  private static HttpHeaders toHttpHeaders(@Nullable Map<String, String> headers) {
+    if (headers == null || headers.isEmpty()) {
+      return null;
+    }
+    HttpHeaders httpHeaders = new DefaultHttpHeaders();
+    for (Map.Entry<String, String> entry : headers.entrySet()) {
+      httpHeaders.add(entry.getKey(), entry.getValue());
+    }
+    return httpHeaders;
+  }
+
+  /**
+   * A Proxy handler follows {@link ProtocolNegotiationHandler} pattern. Upon successful proxy
+   * connection, this handler will install {@code next} handler which should be a handler from
+   * other type of {@link ProtocolNegotiator} to continue negotiating protocol using proxy.
+   */
+  static final class ProxyProtocolNegotiationHandler extends ProtocolNegotiationHandler {
+
+    private final SocketAddress address;
+    @Nullable private final HttpHeaders httpHeaders;
+    @Nullable private final String userName;
+    @Nullable private final String password;
+
+    public ProxyProtocolNegotiationHandler(
+        SocketAddress address,
+        @Nullable HttpHeaders httpHeaders,
+        @Nullable String userName,
+        @Nullable String password,
+        ChannelHandler next,
+        ChannelLogger negotiationLogger) {
+      super(next, negotiationLogger);
+      this.address = Preconditions.checkNotNull(address, "address");
+      this.httpHeaders = httpHeaders;
+      this.userName = userName;
+      this.password = password;
+    }
+
+    @Override
+    protected void protocolNegotiationEventTriggered(ChannelHandlerContext ctx) {
+      HttpProxyHandler nettyProxyHandler;
+      if (userName == null || password == null) {
+        nettyProxyHandler = new HttpProxyHandler(address, httpHeaders);
+      } else {
+        nettyProxyHandler = new HttpProxyHandler(address, userName, password, httpHeaders);
+      }
+      ctx.pipeline().addBefore(ctx.name(), /* name= */ null, nettyProxyHandler);
+    }
 
-    public BufferUntilProxyTunnelledHandler(
-        ProxyHandler proxyHandler, ProtocolNegotiator.Handler handler) {
-      super(proxyHandler, handler);
-      this.originalHandler = handler;
+    @Override
+    protected void userEventTriggered0(ChannelHandlerContext ctx, Object evt) throws Exception {
+      if (evt instanceof ProxyConnectionEvent) {
+        fireProtocolNegotiationEvent(ctx);
+      } else {
+        super.userEventTriggered(ctx, evt);
+      }
+    }
+  }
+
+  static final class ClientTlsProtocolNegotiator implements ProtocolNegotiator {
+
+    public ClientTlsProtocolNegotiator(SslContext sslContext,
+        ObjectPool<? extends Executor> executorPool, Optional<Runnable> handshakeCompleteRunnable,
+        X509TrustManager x509ExtendedTrustManager, String sni) {
+      this.sslContext = Preconditions.checkNotNull(sslContext, "sslContext");
+      this.executorPool = executorPool;
+      if (this.executorPool != null) {
+        this.executor = this.executorPool.getObject();
+      }
+      this.handshakeCompleteRunnable = handshakeCompleteRunnable;
+      this.x509ExtendedTrustManager = x509ExtendedTrustManager;
+      this.sni = sni;
     }
 
+    private final SslContext sslContext;
+    private final ObjectPool<? extends Executor> executorPool;
+    private final Optional<Runnable> handshakeCompleteRunnable;
+    private final X509TrustManager x509ExtendedTrustManager;
+    private final String sni;
+    private Executor executor;
 
     @Override
     public AsciiString scheme() {
-      return originalHandler.scheme();
+      return Utils.HTTPS;
     }
 
     @Override
-    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
-      if (evt instanceof ProxyConnectionEvent) {
-        writeBufferedAndRemove(ctx);
+    public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+      ChannelHandler gnh = new GrpcNegotiationHandler(grpcHandler);
+      ChannelLogger negotiationLogger = grpcHandler.getNegotiationLogger();
+      String authority;
+      if ("".equals(sni)) {
+        authority = null;
+      } else if (sni != null) {
+        authority = sni;
+      } else {
+        authority = grpcHandler.getAuthority();
       }
-      super.userEventTriggered(ctx, evt);
+      ChannelHandler cth = new ClientTlsHandler(gnh, sslContext,
+          authority, this.executor, negotiationLogger, handshakeCompleteRunnable, this,
+          x509ExtendedTrustManager);
+      return new WaitUntilActiveHandler(cth, negotiationLogger);
     }
 
     @Override
-    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
-      fail(ctx, unavailableException("Connection broken while trying to CONNECT through proxy"));
-      super.channelInactive(ctx);
+    public void close() {
+      if (this.executorPool != null && this.executor != null) {
+        this.executorPool.returnObject(this.executor);
+      }
+    }
+
+    @VisibleForTesting
+    boolean hasX509ExtendedTrustManager() {
+      return x509ExtendedTrustManager != null;
+    }
+  }
+
+  static final class ClientTlsHandler extends ProtocolNegotiationHandler {
+
+    private final SslContext sslContext;
+    private final String host;
+    private final int port;
+    private Executor executor;
+    private final Optional<Runnable> handshakeCompleteRunnable;
+    private final X509TrustManager x509TrustManager;
+    private SSLEngine sslEngine;
+
+    ClientTlsHandler(ChannelHandler next, SslContext sslContext, String authority,
+        Executor executor, ChannelLogger negotiationLogger,
+        Optional<Runnable> handshakeCompleteRunnable,
+        ClientTlsProtocolNegotiator clientTlsProtocolNegotiator,
+        X509TrustManager x509TrustManager) {
+      super(next, negotiationLogger);
+      this.sslContext = Preconditions.checkNotNull(sslContext, "sslContext");
+      if (authority != null) {
+        HostPort hostPort = parseAuthority(authority);
+        this.host = hostPort.host;
+        this.port = hostPort.port;
+      } else {
+        this.host = null;
+        this.port = 0;
+      }
+      this.executor = executor;
+      this.handshakeCompleteRunnable = handshakeCompleteRunnable;
+      this.x509TrustManager = x509TrustManager;
     }
 
     @Override
-    public void close(ChannelHandlerContext ctx, ChannelPromise future) throws Exception {
-      if (ctx.channel().isActive()) { // This may be a notification that the socket was closed
-        fail(ctx, unavailableException("Channel closed while trying to CONNECT through proxy"));
+    @IgnoreJRERequirement
+    protected void handlerAdded0(ChannelHandlerContext ctx) {
+      if (host != null) {
+        sslEngine = sslContext.newEngine(ctx.alloc(), host, port);
+      } else {
+        sslEngine = sslContext.newEngine(ctx.alloc());
       }
-      super.close(ctx, future);
+      SSLParameters sslParams = sslEngine.getSSLParameters();
+      sslParams.setEndpointIdentificationAlgorithm("HTTPS");
+      sslEngine.setSSLParameters(sslParams);
+      ctx.pipeline().addBefore(ctx.name(), /* name= */ null, this.executor != null
+          ? new SslHandler(sslEngine, false, this.executor)
+          : new SslHandler(sslEngine, false));
+    }
+
+    @Override
+    protected void userEventTriggered0(ChannelHandlerContext ctx, Object evt) throws Exception {
+      if (evt instanceof SslHandshakeCompletionEvent) {
+        SslHandshakeCompletionEvent handshakeEvent = (SslHandshakeCompletionEvent) evt;
+        if (handshakeEvent.isSuccess()) {
+          SslHandler handler = ctx.pipeline().get(SslHandler.class);
+          if (sslContext.applicationProtocolNegotiator().protocols()
+              .contains(handler.applicationProtocol())) {
+            // Successfully negotiated the protocol.
+            logSslEngineDetails(Level.FINER, ctx, "TLS negotiation succeeded.", null);
+            propagateTlsComplete(ctx, handler.engine().getSession());
+          } else {
+            Exception ex =
+                unavailableException("Failed ALPN negotiation: Unable to find compatible protocol");
+            logSslEngineDetails(Level.FINE, ctx, "TLS negotiation failed.", ex);
+            ctx.fireExceptionCaught(ex);
+          }
+        } else {
+          Throwable t = handshakeEvent.cause();
+          if (t instanceof ClosedChannelException) {
+            // On channelInactive(), SslHandler creates its own ClosedChannelException and
+            // propagates it before the actual channelInactive(). So we assume here that any
+            // such exception is from channelInactive() and emulate the normal behavior of
+            // WriteBufferingAndExceptionHandler
+            t = Status.UNAVAILABLE
+                .withDescription("Connection closed while performing TLS negotiation")
+                .withCause(t)
+                .asRuntimeException();
+          }
+          ctx.fireExceptionCaught(t);
+        }
+        if (handshakeCompleteRunnable.isPresent()) {
+          handshakeCompleteRunnable.get().run();
+        }
+      } else {
+        super.userEventTriggered0(ctx, evt);
+      }
+    }
+
+    private void propagateTlsComplete(ChannelHandlerContext ctx, SSLSession session) {
+      Security security = new Security(new Tls(session));
+      ProtocolNegotiationEvent existingPne = getProtocolNegotiationEvent();
+      Attributes attrs = existingPne.getAttributes().toBuilder()
+          .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.PRIVACY_AND_INTEGRITY)
+          .set(Grpc.TRANSPORT_ATTR_SSL_SESSION, session)
+          .set(GrpcAttributes.ATTR_AUTHORITY_VERIFIER, new X509AuthorityVerifier(
+              sslEngine, x509TrustManager))
+          .build();
+      replaceProtocolNegotiationEvent(existingPne.withAttributes(attrs).withSecurity(security));
+      if (handshakeCompleteRunnable.isPresent()) {
+        handshakeCompleteRunnable.get().run();
+      }
+      fireProtocolNegotiationEvent(ctx);
     }
   }
 
-  /**
-   * Returns a {@link ProtocolNegotiator} that ensures the pipeline is set up so that TLS will
-   * be negotiated, the {@code handler} is added and writes to the {@link io.netty.channel.Channel}
-   * may happen immediately, even before the TLS Handshake is complete.
-   */
-  public static ProtocolNegotiator tls(SslContext sslContext, String authority) {
-    Preconditions.checkNotNull(sslContext, "sslContext");
+  @VisibleForTesting
+  static HostPort parseAuthority(String authority) {
     URI uri = GrpcUtil.authorityToUri(Preconditions.checkNotNull(authority, "authority"));
     String host;
     int port;
@@ -276,54 +753,78 @@ public static ProtocolNegotiator tls(SslContext sslContext, String authority) {
       port = uri.getPort();
     } else {
       /*
-       * Implementation note: We pick -1 as the port here rather than deriving it from the original
-       * socket address.  The SSL engine doens't use this port number when contacting the remote
-       * server, but rather it is used for other things like SSL Session caching.  When an invalid
-       * authority is provided (like "bad_cert"), picking the original port and passing it in would
-       * mean that the port might used under the assumption that it was correct.   By using -1 here,
-       * it forces the SSL implementation to treat it as invalid.
+       * Implementation note: We pick -1 as the port here rather than deriving it from the
+       * original socket address.  The SSL engine doesn't use this port number when contacting the
+       * remote server, but rather it is used for other things like SSL Session caching.  When an
+       * invalid authority is provided (like "bad_cert"), picking the original port and passing it
+       * in would mean that the port might used under the assumption that it was correct.   By
+       * using -1 here, it forces the SSL implementation to treat it as invalid.
        */
       host = authority;
       port = -1;
     }
+    return new HostPort(host, port);
+  }
+
+  /**
+   * Returns a {@link ProtocolNegotiator} that ensures the pipeline is set up so that TLS will
+   * be negotiated, the {@code handler} is added and writes to the {@link io.netty.channel.Channel}
+   * may happen immediately, even before the TLS Handshake is complete.
+   *
+   * @param executorPool a dedicated {@link Executor} pool for time-consuming TLS tasks
+   */
+  public static ProtocolNegotiator tls(SslContext sslContext,
+      ObjectPool<? extends Executor> executorPool, Optional<Runnable> handshakeCompleteRunnable,
+      X509TrustManager x509ExtendedTrustManager, String sni) {
+    return new ClientTlsProtocolNegotiator(sslContext, executorPool, handshakeCompleteRunnable,
+        x509ExtendedTrustManager, sni);
+  }
+
+  /**
+   * Returns a {@link ProtocolNegotiator} that ensures the pipeline is set up so that TLS will
+   * be negotiated, the {@code handler} is added and writes to the {@link io.netty.channel.Channel}
+   * may happen immediately, even before the TLS Handshake is complete.
+   */
+  public static ProtocolNegotiator tls(SslContext sslContext,
+      X509TrustManager x509ExtendedTrustManager) {
+    return tls(sslContext, null, Optional.absent(), x509ExtendedTrustManager, null);
+  }
 
-    return new TlsNegotiator(sslContext, host, port);
+  public static ProtocolNegotiator.ClientFactory tlsClientFactory(SslContext sslContext,
+      X509TrustManager x509ExtendedTrustManager) {
+    return new TlsProtocolNegotiatorClientFactory(sslContext, x509ExtendedTrustManager);
   }
 
-  static final class TlsNegotiator implements ProtocolNegotiator {
+  @VisibleForTesting
+  static final class TlsProtocolNegotiatorClientFactory
+      implements ProtocolNegotiator.ClientFactory {
     private final SslContext sslContext;
-    private final String host;
-    private final int port;
+    private final X509TrustManager x509ExtendedTrustManager;
 
-    TlsNegotiator(SslContext sslContext, String host, int port) {
-      this.sslContext = checkNotNull(sslContext, "sslContext");
-      this.host = checkNotNull(host, "host");
-      this.port = port;
+    public TlsProtocolNegotiatorClientFactory(SslContext sslContext,
+                                              X509TrustManager x509ExtendedTrustManager) {
+      this.sslContext = Preconditions.checkNotNull(sslContext, "sslContext");
+      this.x509ExtendedTrustManager = x509ExtendedTrustManager;
     }
 
-    @VisibleForTesting
-    String getHost() {
-      return host;
+    @Override public ProtocolNegotiator newNegotiator() {
+      return tls(sslContext, x509ExtendedTrustManager);
     }
 
-    @VisibleForTesting
-    int getPort() {
-      return port;
+    @Override public int getDefaultPort() {
+      return GrpcUtil.DEFAULT_PORT_SSL;
     }
+  }
 
-    @Override
-    public Handler newHandler(GrpcHttp2ConnectionHandler handler) {
-      ChannelHandler sslBootstrap = new ChannelHandlerAdapter() {
-        @Override
-        public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
-          SSLEngine sslEngine = sslContext.newEngine(ctx.alloc(), host, port);
-          SSLParameters sslParams = new SSLParameters();
-          sslParams.setEndpointIdentificationAlgorithm("HTTPS");
-          sslEngine.setSSLParameters(sslParams);
-          ctx.pipeline().replace(this, null, new SslHandler(sslEngine, false));
-        }
-      };
-      return new BufferUntilTlsNegotiatedHandler(sslBootstrap, handler);
+  /** A tuple of (host, port). */
+  @VisibleForTesting
+  static final class HostPort {
+    final String host;
+    final int port;
+
+    public HostPort(String host, int port) {
+      this.host = host;
+      this.port = port;
     }
   }
 
@@ -331,34 +832,124 @@ public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
    * Returns a {@link ProtocolNegotiator} used for upgrading to HTTP/2 from HTTP/1.x.
    */
   public static ProtocolNegotiator plaintextUpgrade() {
-    return new PlaintextUpgradeNegotiator();
+    return new PlaintextUpgradeProtocolNegotiator();
+  }
+
+  public static ProtocolNegotiator.ClientFactory plaintextUpgradeClientFactory() {
+    return new PlaintextUpgradeProtocolNegotiatorClientFactory();
+  }
+
+  private static final class PlaintextUpgradeProtocolNegotiatorClientFactory
+      implements ProtocolNegotiator.ClientFactory {
+    @Override public ProtocolNegotiator newNegotiator() {
+      return plaintextUpgrade();
+    }
+
+    @Override public int getDefaultPort() {
+      return GrpcUtil.DEFAULT_PORT_PLAINTEXT;
+    }
+  }
+
+  static final class PlaintextUpgradeProtocolNegotiator implements ProtocolNegotiator {
+
+    @Override
+    public AsciiString scheme() {
+      return Utils.HTTP;
+    }
+
+    @Override
+    public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+      ChannelHandler upgradeHandler =
+          new Http2UpgradeAndGrpcHandler(grpcHandler.getAuthority(), grpcHandler);
+      ChannelHandler plaintextHandler =
+          new PlaintextHandler(upgradeHandler, grpcHandler.getNegotiationLogger());
+      return new WaitUntilActiveHandler(plaintextHandler, grpcHandler.getNegotiationLogger());
+    }
+
+    @Override
+    public void close() {}
   }
 
-  static final class PlaintextUpgradeNegotiator implements ProtocolNegotiator {
+  /**
+   * Acts as a combination of Http2Upgrade and {@link GrpcNegotiationHandler}.  Unfortunately,
+   * this negotiator doesn't follow the pattern of "just one handler doing negotiation at a time."
+   * This is due to the tight coupling between the upgrade handler and the HTTP/2 handler.
+   */
+  static final class Http2UpgradeAndGrpcHandler extends ChannelInboundHandlerAdapter {
+
+    private final String authority;
+    private final GrpcHttp2ConnectionHandler next;
+    private final ChannelLogger negotiationLogger;
+
+    private ProtocolNegotiationEvent pne;
+
+    Http2UpgradeAndGrpcHandler(String authority, GrpcHttp2ConnectionHandler next) {
+      this.authority = Preconditions.checkNotNull(authority, "authority");
+      this.next = Preconditions.checkNotNull(next, "next");
+      this.negotiationLogger = next.getNegotiationLogger();
+    }
+
     @Override
-    public Handler newHandler(GrpcHttp2ConnectionHandler handler) {
-      // Register the plaintext upgrader
-      Http2ClientUpgradeCodec upgradeCodec = new Http2ClientUpgradeCodec(handler);
+    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+      negotiationLogger.log(ChannelLogLevel.INFO, "Http2Upgrade started");
       HttpClientCodec httpClientCodec = new HttpClientCodec();
-      final HttpClientUpgradeHandler upgrader =
-          new HttpClientUpgradeHandler(httpClientCodec, upgradeCodec, 1000);
-      return new BufferingHttp2UpgradeHandler(upgrader);
+      ctx.pipeline().addBefore(ctx.name(), null, httpClientCodec);
+
+      Http2ClientUpgradeCodec upgradeCodec = new Http2ClientUpgradeCodec(next);
+      HttpClientUpgradeHandler upgrader =
+          new HttpClientUpgradeHandler(httpClientCodec, upgradeCodec, /*maxContentLength=*/ 1000);
+      ctx.pipeline().addBefore(ctx.name(), null, upgrader);
+
+      // Trigger the HTTP/1.1 plaintext upgrade protocol by issuing an HTTP request
+      // which causes the upgrade headers to be added
+      DefaultHttpRequest upgradeTrigger =
+          new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/");
+      upgradeTrigger.headers().add(HttpHeaderNames.HOST, authority);
+      ctx.writeAndFlush(upgradeTrigger).addListener(
+          ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE);
+      super.handlerAdded(ctx);
+    }
+
+    @Override
+    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+      if (evt instanceof ProtocolNegotiationEvent) {
+        checkState(pne == null, "negotiation already started");
+        pne = (ProtocolNegotiationEvent) evt;
+      } else if (evt == HttpClientUpgradeHandler.UpgradeEvent.UPGRADE_SUCCESSFUL) {
+        checkState(pne != null, "negotiation not yet complete");
+        negotiationLogger.log(ChannelLogLevel.INFO, "Http2Upgrade finished");
+        ctx.pipeline().remove(ctx.name());
+        next.handleProtocolNegotiationCompleted(pne.getAttributes(), pne.getSecurity());
+      } else if (evt == HttpClientUpgradeHandler.UpgradeEvent.UPGRADE_REJECTED) {
+        ctx.fireExceptionCaught(unavailableException("HTTP/2 upgrade rejected"));
+      } else {
+        super.userEventTriggered(ctx, evt);
+      }
     }
   }
 
   /**
-   * Returns a {@link ChannelHandler} that ensures that the {@code handler} is added to the
-   * pipeline writes to the {@link io.netty.channel.Channel} may happen immediately, even before it
-   * is active.
+   * Returns a {@link io.netty.channel.ChannelHandler} that ensures that the {@code handler} is
+   * added to the pipeline writes to the {@link io.netty.channel.Channel} may happen immediately,
+   * even before it is active.
    */
   public static ProtocolNegotiator plaintext() {
-    return new PlaintextNegotiator();
+    return new PlaintextProtocolNegotiator();
   }
 
-  static final class PlaintextNegotiator implements ProtocolNegotiator {
-    @Override
-    public Handler newHandler(GrpcHttp2ConnectionHandler handler) {
-      return new BufferUntilChannelActiveHandler(handler);
+  public static ProtocolNegotiator.ClientFactory plaintextClientFactory() {
+    return new PlaintextProtocolNegotiatorClientFactory();
+  }
+
+  @VisibleForTesting
+  static final class PlaintextProtocolNegotiatorClientFactory
+      implements ProtocolNegotiator.ClientFactory {
+    @Override public ProtocolNegotiator newNegotiator() {
+      return plaintext();
+    }
+
+    @Override public int getDefaultPort() {
+      return GrpcUtil.DEFAULT_PORT_PLAINTEXT;
     }
   }
 
@@ -368,7 +959,7 @@ private static RuntimeException unavailableException(String msg) {
 
   @VisibleForTesting
   static void logSslEngineDetails(Level level, ChannelHandlerContext ctx, String msg,
-                                                @Nullable Throwable t) {
+      @Nullable Throwable t) {
     if (!log.isLoggable(level)) {
       return;
     }
@@ -382,11 +973,13 @@ static void logSslEngineDetails(Level level, ChannelHandlerContext ctx, String m
       builder.append("    OpenSSL, ");
       builder.append("Version: 0x").append(Integer.toHexString(OpenSsl.version()));
       builder.append(" (").append(OpenSsl.versionString()).append("), ");
-      builder.append("ALPN supported: ").append(OpenSsl.isAlpnSupported());
+      builder.append("ALPN supported: ").append(SslProvider.isAlpnSupported(SslProvider.OPENSSL));
     } else if (JettyTlsUtil.isJettyAlpnConfigured()) {
       builder.append("    Jetty ALPN");
     } else if (JettyTlsUtil.isJettyNpnConfigured()) {
       builder.append("    Jetty NPN");
+    } else if (JettyTlsUtil.isJava9AlpnAvailable()) {
+      builder.append("    JDK9 ALPN");
     }
     builder.append("\n    TLS Protocol: ");
     builder.append(engine.getSession().getProtocol());
@@ -410,274 +1003,247 @@ static void logSslEngineDetails(Level level, ChannelHandlerContext ctx, String m
   }
 
   /**
-   * Buffers all writes until either {@link #writeBufferedAndRemove(ChannelHandlerContext)} or
-   * {@link #fail(ChannelHandlerContext, Throwable)} is called. This handler allows us to
-   * write to a {@link io.netty.channel.Channel} before we are allowed to write to it officially
-   * i.e.  before it's active or the TLS Handshake is complete.
+   * Adapts a {@link ProtocolNegotiationEvent} to the {@link GrpcHttp2ConnectionHandler}.
    */
-  public abstract static class AbstractBufferingHandler extends ChannelDuplexHandler {
-
-    private ChannelHandler[] handlers;
-    private Queue<ChannelWrite> bufferedWrites = new ArrayDeque<ChannelWrite>();
-    private boolean writing;
-    private boolean flushRequested;
-    private Throwable failCause;
+  static final class GrpcNegotiationHandler extends ChannelInboundHandlerAdapter {
+    private final GrpcHttp2ConnectionHandler next;
 
-    /**
-     * @param handlers the ChannelHandlers are added to the pipeline on channelRegistered and
-     *                 before this handler.
-     */
-    protected AbstractBufferingHandler(ChannelHandler... handlers) {
-      this.handlers = handlers;
+    public GrpcNegotiationHandler(GrpcHttp2ConnectionHandler next) {
+      this.next = Preconditions.checkNotNull(next, "next");
     }
 
     @Override
-    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
-      /**
-       * This check is necessary as a channel may be registered with different event loops during it
-       * lifetime and we only want to configure it once.
-       */
-      if (handlers != null) {
-        for (ChannelHandler handler : handlers) {
-          ctx.pipeline().addBefore(ctx.name(), null, handler);
-        }
-        ChannelHandler handler0 = handlers[0];
-        ChannelHandlerContext handler0Ctx = ctx.pipeline().context(handlers[0]);
-        handlers = null;
-        if (handler0Ctx != null) { // The handler may have removed itself immediately
-          if (handler0 instanceof ChannelInboundHandler) {
-            ((ChannelInboundHandler) handler0).channelRegistered(handler0Ctx);
-          } else {
-            handler0Ctx.fireChannelRegistered();
-          }
-        }
+    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+      if (evt instanceof ProtocolNegotiationEvent) {
+        ProtocolNegotiationEvent protocolNegotiationEvent = (ProtocolNegotiationEvent) evt;
+        ctx.pipeline().replace(ctx.name(), null, next);
+        next.handleProtocolNegotiationCompleted(
+            protocolNegotiationEvent.getAttributes(), protocolNegotiationEvent.getSecurity());
       } else {
-        super.channelRegistered(ctx);
+        super.userEventTriggered(ctx, evt);
       }
     }
+  }
+
+  /*
+   * Common {@link ProtocolNegotiator}s used by gRPC.  Protocol negotiation follows a pattern to
+   * simplify the pipeline.   The pipeline should look like:
+   *
+   * 1.  {@link ProtocolNegotiator#newHandler() PN.H}, created.
+   * 2.  [Tail], {@link WriteBufferingAndExceptionHandler WBAEH}, [Head]
+   * 3.  [Tail], WBAEH, PN.H, [Head]
+   *
+   * <p>Typically, PN.H with be an instance of {@link InitHandler IH}, which is a trivial handler
+   * that can return the {@code scheme()} of the negotiation.  IH, and each handler after,
+   * replaces itself with a "next" handler once its part of negotiation is complete.  This keeps
+   * the pipeline small, and limits the interaction between handlers.
+   *
+   * <p>Additionally, each handler may fire a {@link ProtocolNegotiationEvent PNE} just after
+   * replacing itself.  Handlers should capture user events of type PNE, and re-trigger the events
+   * once that handler's part of negotiation is complete.  This can be seen in the
+   * {@link WaitUntilActiveHandler WUAH}, which waits until the channel is active.  Once active, it
+   * replaces itself with the next handler, and fires a PNE containing the addresses.  Continuing
+   * with IH and WUAH:
+   *
+   * 3.  [Tail], WBAEH, IH, [Head]
+   * 4.  [Tail], WBAEH, WUAH, [Head]
+   * 5.  [Tail], WBAEH, {@link GrpcNegotiationHandler}, [Head]
+   * 6a. [Tail], WBAEH, {@link GrpcHttp2ConnectionHandler GHCH}, [Head]
+   * 6b. [Tail], GHCH, [Head]
+   */
+
+  /**
+   * A negotiator that only does plain text.
+   */
+  static final class PlaintextProtocolNegotiator implements ProtocolNegotiator {
 
     @Override
-    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
-      fail(ctx, cause);
+    public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+      ChannelHandler grpcNegotiationHandler = new GrpcNegotiationHandler(grpcHandler);
+      ChannelHandler plaintextHandler =
+          new PlaintextHandler(grpcNegotiationHandler, grpcHandler.getNegotiationLogger());
+      ChannelHandler activeHandler = new WaitUntilActiveHandler(plaintextHandler,
+          grpcHandler.getNegotiationLogger());
+      return activeHandler;
     }
 
     @Override
-    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
-      fail(ctx, unavailableException("Connection broken while performing protocol negotiation"));
-      super.channelInactive(ctx);
-    }
+    public void close() {}
 
     @Override
-    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
-        throws Exception {
-      /**
-       * This check handles a race condition between Channel.write (in the calling thread) and the
-       * removal of this handler (in the event loop thread).
-       * The problem occurs in e.g. this sequence:
-       * 1) [caller thread] The write method identifies the context for this handler
-       * 2) [event loop] This handler removes itself from the pipeline
-       * 3) [caller thread] The write method delegates to the invoker to call the write method in
-       *    the event loop thread. When this happens, we identify that this handler has been
-       *    removed with "bufferedWrites == null".
-       */
-      if (failCause != null) {
-        promise.setFailure(failCause);
-        ReferenceCountUtil.release(msg);
-      } else if (bufferedWrites == null) {
-        super.write(ctx, msg, promise);
-      } else {
-        bufferedWrites.add(new ChannelWrite(msg, promise));
-      }
+    public AsciiString scheme() {
+      return Utils.HTTP;
     }
+  }
 
-    @Override
-    public void flush(ChannelHandlerContext ctx) {
-      /**
-       * Swallowing any flushes is not only an optimization but also required
-       * for the SslHandler to work correctly. If the SslHandler receives multiple
-       * flushes while the handshake is still ongoing, then the handshake "randomly"
-       * times out. Not sure at this point why this is happening. Doing a single flush
-       * seems to work but multiple flushes don't ...
-       */
-      if (bufferedWrites == null) {
-        ctx.flush();
-      } else {
-        flushRequested = true;
-      }
+  static final class PlaintextHandler extends ProtocolNegotiationHandler {
+    PlaintextHandler(ChannelHandler next, ChannelLogger negotiationLogger) {
+      super(next, negotiationLogger);
     }
 
     @Override
-    public void close(ChannelHandlerContext ctx, ChannelPromise future) throws Exception {
-      if (ctx.channel().isActive()) { // This may be a notification that the socket was closed
-        fail(ctx, unavailableException("Channel closed while performing protocol negotiation"));
-      }
-      super.close(ctx, future);
+    protected void protocolNegotiationEventTriggered(ChannelHandlerContext ctx) {
+      ProtocolNegotiationEvent existingPne = getProtocolNegotiationEvent();
+      Attributes attrs = existingPne.getAttributes().toBuilder()
+              .set(GrpcAttributes.ATTR_AUTHORITY_VERIFIER, (authority) -> Status.OK)
+              .build();
+      replaceProtocolNegotiationEvent(existingPne.withAttributes(attrs));
+      fireProtocolNegotiationEvent(ctx);
     }
+  }
 
-    protected final void fail(ChannelHandlerContext ctx, Throwable cause) {
-      if (failCause == null) {
-        failCause = cause;
-      }
-      if (bufferedWrites != null) {
-        while (!bufferedWrites.isEmpty()) {
-          ChannelWrite write = bufferedWrites.poll();
-          write.promise.setFailure(cause);
-          ReferenceCountUtil.release(write.msg);
-        }
-        bufferedWrites = null;
-      }
+  /**
+   * Waits for the channel to be active, and then installs the next Handler.  Using this allows
+   * subsequent handlers to assume the channel is active and ready to send.  Additionally, this a
+   * {@link ProtocolNegotiationEvent}, with the connection addresses.
+   */
+  static final class WaitUntilActiveHandler extends ProtocolNegotiationHandler {
 
-      /**
-       * In case something goes wrong ensure that the channel gets closed as the
-       * NettyClientTransport relies on the channel's close future to get completed.
-       */
-      ctx.close();
+    boolean protocolNegotiationEventReceived;
+
+    WaitUntilActiveHandler(ChannelHandler next, ChannelLogger negotiationLogger) {
+      super(next, negotiationLogger);
     }
 
-    protected final void writeBufferedAndRemove(ChannelHandlerContext ctx) {
-      if (!ctx.channel().isActive() || writing) {
-        return;
-      }
-      // Make sure that method can't be reentered, so that the ordering
-      // in the queue can't be messed up.
-      writing = true;
-      while (!bufferedWrites.isEmpty()) {
-        ChannelWrite write = bufferedWrites.poll();
-        ctx.write(write.msg, write.promise);
-      }
-      assert bufferedWrites.isEmpty();
-      bufferedWrites = null;
-      if (flushRequested) {
-        ctx.flush();
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+      if (protocolNegotiationEventReceived) {
+        replaceOnActive(ctx);
+        fireProtocolNegotiationEvent(ctx);
       }
-      // Removal has to happen last as the above writes will likely trigger
-      // new writes that have to be added to the end of queue in order to not
-      // mess up the ordering.
-      ctx.pipeline().remove(this);
+      // Still propagate channelActive to the new handler.
+      super.channelActive(ctx);
     }
 
-    private static class ChannelWrite {
-      Object msg;
-      ChannelPromise promise;
-
-      ChannelWrite(Object msg, ChannelPromise promise) {
-        this.msg = msg;
-        this.promise = promise;
+    @Override
+    protected void protocolNegotiationEventTriggered(ChannelHandlerContext ctx) {
+      protocolNegotiationEventReceived = true;
+      if (ctx.channel().isActive()) {
+        replaceOnActive(ctx);
+        fireProtocolNegotiationEvent(ctx);
       }
     }
+
+    private void replaceOnActive(ChannelHandlerContext ctx) {
+      ProtocolNegotiationEvent existingPne = getProtocolNegotiationEvent();
+      Attributes attrs = existingPne.getAttributes().toBuilder()
+          .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, ctx.channel().localAddress())
+          .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, ctx.channel().remoteAddress())
+          // Later handlers are expected to overwrite this.
+          .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.NONE)
+          .build();
+      replaceProtocolNegotiationEvent(existingPne.withAttributes(attrs));
+    }
   }
 
   /**
-   * Buffers all writes until the TLS Handshake is complete.
+   * ProtocolNegotiationHandler is a convenience handler that makes it easy to follow the rules for
+   * protocol negotiation.  Handlers should strongly consider extending this handler.
    */
-  private static class BufferUntilTlsNegotiatedHandler extends AbstractBufferingHandler
-      implements ProtocolNegotiator.Handler {
-
-    private final GrpcHttp2ConnectionHandler grpcHandler;
+  static class ProtocolNegotiationHandler extends ChannelDuplexHandler {
+
+    private final ChannelHandler next;
+    private final String negotiatorName;
+    private ProtocolNegotiationEvent pne;
+    private final ChannelLogger negotiationLogger;
+
+    protected ProtocolNegotiationHandler(ChannelHandler next, String negotiatorName,
+        ChannelLogger negotiationLogger) {
+      this.next = Preconditions.checkNotNull(next, "next");
+      this.negotiatorName = negotiatorName;
+      this.negotiationLogger = Preconditions.checkNotNull(negotiationLogger, "negotiationLogger");
+    }
 
-    BufferUntilTlsNegotiatedHandler(
-        ChannelHandler bootstrapHandler, GrpcHttp2ConnectionHandler grpcHandler) {
-      super(bootstrapHandler, grpcHandler);
-      this.grpcHandler = grpcHandler;
+    protected ProtocolNegotiationHandler(ChannelHandler next, ChannelLogger negotiationLogger) {
+      this.next = Preconditions.checkNotNull(next, "next");
+      this.negotiatorName = getClass().getSimpleName().replace("Handler", "");
+      this.negotiationLogger = Preconditions.checkNotNull(negotiationLogger, "negotiationLogger");
     }
 
     @Override
-    public AsciiString scheme() {
-      return Utils.HTTPS;
+    public final void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+      negotiationLogger.log(ChannelLogLevel.DEBUG, "{0} started", negotiatorName);
+      handlerAdded0(ctx);
     }
 
-    @Override
-    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
-      if (evt instanceof SslHandshakeCompletionEvent) {
-        SslHandshakeCompletionEvent handshakeEvent = (SslHandshakeCompletionEvent) evt;
-        if (handshakeEvent.isSuccess()) {
-          SslHandler handler = ctx.pipeline().get(SslHandler.class);
-          if (NEXT_PROTOCOL_VERSIONS.contains(handler.applicationProtocol())) {
-            // Successfully negotiated the protocol.
-            logSslEngineDetails(Level.FINER, ctx, "TLS negotiation succeeded.", null);
+    @ForOverride
+    protected void handlerAdded0(ChannelHandlerContext ctx) throws Exception {
+      super.handlerAdded(ctx);
+    }
 
-            // Successfully negotiated the protocol.
-            // Notify about completion and pass down SSLSession in attributes.
-            grpcHandler.handleProtocolNegotiationCompleted(
-                Attributes.newBuilder()
-                    .set(Grpc.TRANSPORT_ATTR_SSL_SESSION, handler.engine().getSession())
-                    .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, ctx.channel().remoteAddress())
-                    .build());
-            writeBufferedAndRemove(ctx);
-          } else {
-            Exception ex = new Exception(
-                "Failed ALPN negotiation: Unable to find compatible protocol.");
-            logSslEngineDetails(Level.FINE, ctx, "TLS negotiation failed.", ex);
-            fail(ctx, ex);
-          }
-        } else {
-          fail(ctx, handshakeEvent.cause());
-        }
+    @Override
+    public final void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+      if (evt instanceof ProtocolNegotiationEvent) {
+        checkState(pne == null, "pre-existing negotiation: %s < %s", pne, evt);
+        pne = (ProtocolNegotiationEvent) evt;
+        protocolNegotiationEventTriggered(ctx);
+      } else {
+        userEventTriggered0(ctx, evt);
       }
-      super.userEventTriggered(ctx, evt);
     }
-  }
 
-  /**
-   * Buffers all writes until the {@link io.netty.channel.Channel} is active.
-   */
-  private static class BufferUntilChannelActiveHandler extends AbstractBufferingHandler
-      implements ProtocolNegotiator.Handler {
+    protected void userEventTriggered0(ChannelHandlerContext ctx, Object evt) throws Exception {
+      super.userEventTriggered(ctx, evt);
+    }
 
-    BufferUntilChannelActiveHandler(ChannelHandler... handlers) {
-      super(handlers);
+    @ForOverride
+    protected void protocolNegotiationEventTriggered(ChannelHandlerContext ctx) {
+      // no-op
     }
 
-    @Override
-    public AsciiString scheme() {
-      return Utils.HTTP;
+    protected final ProtocolNegotiationEvent getProtocolNegotiationEvent() {
+      checkState(pne != null, "previous protocol negotiation event hasn't triggered");
+      return pne;
     }
 
-    @Override
-    public void handlerAdded(ChannelHandlerContext ctx) {
-      writeBufferedAndRemove(ctx);
+    protected final void replaceProtocolNegotiationEvent(ProtocolNegotiationEvent pne) {
+      checkState(this.pne != null, "previous protocol negotiation event hasn't triggered");
+      this.pne = Preconditions.checkNotNull(pne);
     }
 
-    @Override
-    public void channelActive(ChannelHandlerContext ctx) throws Exception {
-      writeBufferedAndRemove(ctx);
-      super.channelActive(ctx);
+    protected final void fireProtocolNegotiationEvent(ChannelHandlerContext ctx) {
+      checkState(pne != null, "previous protocol negotiation event hasn't triggered");
+      negotiationLogger.log(ChannelLogLevel.INFO, "{0} completed", negotiatorName);
+      ctx.pipeline().replace(ctx.name(), /* newName= */ null, next);
+      ctx.fireUserEventTriggered(pne);
     }
   }
 
-  /**
-   * Buffers all writes until the HTTP to HTTP/2 upgrade is complete.
-   */
-  private static class BufferingHttp2UpgradeHandler extends AbstractBufferingHandler
-      implements ProtocolNegotiator.Handler {
+  static final class SslEngineWrapper extends NoopSslEngine {
+    private final SSLEngine sslEngine;
+    private final String peerHost;
 
-    BufferingHttp2UpgradeHandler(ChannelHandler... handlers) {
-      super(handlers);
+    SslEngineWrapper(SSLEngine sslEngine, String peerHost) {
+      this.sslEngine = sslEngine;
+      this.peerHost = peerHost;
     }
 
     @Override
-    public AsciiString scheme() {
-      return Utils.HTTP;
+    public String getPeerHost() {
+      return peerHost;
     }
 
     @Override
-    public void channelActive(ChannelHandlerContext ctx) throws Exception {
-      // Trigger the HTTP/1.1 plaintext upgrade protocol by issuing an HTTP request
-      // which causes the upgrade headers to be added
-      DefaultHttpRequest upgradeTrigger =
-          new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/");
-      ctx.writeAndFlush(upgradeTrigger);
-      super.channelActive(ctx);
+    public SSLSession getHandshakeSession() {
+      return new FakeSslSession(peerHost);
     }
 
     @Override
-    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
-      if (evt == HttpClientUpgradeHandler.UpgradeEvent.UPGRADE_SUCCESSFUL) {
-        writeBufferedAndRemove(ctx);
-      } else if (evt == HttpClientUpgradeHandler.UpgradeEvent.UPGRADE_REJECTED) {
-        fail(ctx, unavailableException("HTTP/2 upgrade rejected"));
-      }
-      super.userEventTriggered(ctx, evt);
+    public SSLParameters getSSLParameters() {
+      return sslEngine.getSSLParameters();
+    }
+  }
+
+  static final class FakeSslSession extends NoopSslSession {
+    private final String peerHost;
+
+    FakeSslSession(String peerHost) {
+      this.peerHost = peerHost;
+    }
+
+    @Override
+    public String getPeerHost() {
+      return peerHost;
     }
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/SendGrpcFrameCommand.java b/netty/src/main/java/io/grpc/netty/SendGrpcFrameCommand.java
index 90f5e96bffa..9c2507e3686 100644
--- a/netty/src/main/java/io/grpc/netty/SendGrpcFrameCommand.java
+++ b/netty/src/main/java/io/grpc/netty/SendGrpcFrameCommand.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -34,14 +19,18 @@
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufHolder;
 import io.netty.buffer.DefaultByteBufHolder;
+import io.netty.channel.Channel;
 import io.netty.channel.ChannelPromise;
+import io.perfmark.Link;
+import io.perfmark.PerfMark;
 
 /**
  * Command sent from the transport to the Netty channel to send a GRPC frame to the remote endpoint.
  */
-class SendGrpcFrameCommand extends DefaultByteBufHolder implements WriteQueue.QueuedCommand {
+final class SendGrpcFrameCommand extends DefaultByteBufHolder implements WriteQueue.QueuedCommand {
   private final StreamIdHolder stream;
   private final boolean endStream;
+  private final Link link;
 
   private ChannelPromise promise;
 
@@ -49,48 +38,25 @@ class SendGrpcFrameCommand extends DefaultByteBufHolder implements WriteQueue.Qu
     super(content);
     this.stream = stream;
     this.endStream = endStream;
-  }
-
-  int streamId() {
-    return stream.id();
-  }
-
-  boolean endStream() {
-    return endStream;
-  }
-
-  @Override
-  public ByteBufHolder copy() {
-    return new SendGrpcFrameCommand(stream, content().copy(), endStream);
+    this.link = PerfMark.linkOut();
   }
 
   @Override
-  public ByteBufHolder duplicate() {
-    return new SendGrpcFrameCommand(stream, content().duplicate(), endStream);
+  public Link getLink() {
+    return link;
   }
 
-  @Override
-  public SendGrpcFrameCommand retain() {
-    super.retain();
-    return this;
+  StreamIdHolder stream() {
+    return stream;
   }
 
-  @Override
-  public SendGrpcFrameCommand retain(int increment) {
-    super.retain(increment);
-    return this;
-  }
-
-  @Override
-  public SendGrpcFrameCommand touch() {
-    super.touch();
-    return this;
+  boolean endStream() {
+    return endStream;
   }
 
   @Override
-  public SendGrpcFrameCommand touch(Object hint) {
-    super.touch(hint);
-    return this;
+  public ByteBufHolder replace(ByteBuf content) {
+    return new SendGrpcFrameCommand(stream, content, endStream);
   }
 
   @Override
@@ -105,7 +71,7 @@ public boolean equals(Object that) {
 
   @Override
   public String toString() {
-    return getClass().getSimpleName() + "(streamId=" + streamId()
+    return getClass().getSimpleName() + "(streamId=" + stream.id()
         + ", endStream=" + endStream + ", content=" + content()
         + ")";
   }
@@ -129,4 +95,9 @@ public ChannelPromise promise() {
   public void promise(ChannelPromise promise) {
     this.promise = promise;
   }
+
+  @Override
+  public final void run(Channel channel) {
+    channel.write(this, promise);
+  }
 }
diff --git a/netty/src/main/java/io/grpc/netty/SendPingCommand.java b/netty/src/main/java/io/grpc/netty/SendPingCommand.java
index 7fe4426a21e..44545e044cf 100644
--- a/netty/src/main/java/io/grpc/netty/SendPingCommand.java
+++ b/netty/src/main/java/io/grpc/netty/SendPingCommand.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
diff --git a/netty/src/main/java/io/grpc/netty/SendResponseHeadersCommand.java b/netty/src/main/java/io/grpc/netty/SendResponseHeadersCommand.java
index b0a4ea4d93e..b649385bdc2 100644
--- a/netty/src/main/java/io/grpc/netty/SendResponseHeadersCommand.java
+++ b/netty/src/main/java/io/grpc/netty/SendResponseHeadersCommand.java
@@ -1,51 +1,48 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import com.google.common.base.Objects;
 import com.google.common.base.Preconditions;
+import io.grpc.Status;
 import io.netty.handler.codec.http2.Http2Headers;
 
 /**
  * Command sent from the transport to the Netty channel to send response headers to the client.
  */
-class SendResponseHeadersCommand extends WriteQueue.AbstractQueuedCommand {
+final class SendResponseHeadersCommand extends WriteQueue.AbstractQueuedCommand {
   private final StreamIdHolder stream;
   private final Http2Headers headers;
-  private final boolean endOfStream;
+  private final Status status;
 
-  SendResponseHeadersCommand(StreamIdHolder stream, Http2Headers headers, boolean endOfStream) {
+  private SendResponseHeadersCommand(StreamIdHolder stream, Http2Headers headers, Status status) {
     this.stream = Preconditions.checkNotNull(stream, "stream");
     this.headers = Preconditions.checkNotNull(headers, "headers");
-    this.endOfStream = endOfStream;
+    this.status = status;
+  }
+
+  static SendResponseHeadersCommand createHeaders(StreamIdHolder stream, Http2Headers headers) {
+    return new SendResponseHeadersCommand(stream, headers, null);
+  }
+
+  static SendResponseHeadersCommand createTrailers(
+      StreamIdHolder stream, Http2Headers headers, Status status) {
+    return new SendResponseHeadersCommand(
+        stream, headers, Preconditions.checkNotNull(status, "status"));
   }
 
   StreamIdHolder stream() {
@@ -57,7 +54,11 @@ Http2Headers headers() {
   }
 
   boolean endOfStream() {
-    return endOfStream;
+    return status != null;
+  }
+
+  Status status() {
+    return status;
   }
 
   @Override
@@ -68,17 +69,17 @@ public boolean equals(Object that) {
     SendResponseHeadersCommand thatCmd = (SendResponseHeadersCommand) that;
     return thatCmd.stream.equals(stream)
         && thatCmd.headers.equals(headers)
-        && thatCmd.endOfStream == endOfStream;
+        && thatCmd.status.equals(status);
   }
 
   @Override
   public String toString() {
     return getClass().getSimpleName() + "(stream=" + stream.id() + ", headers=" + headers
-        + ", endOfStream=" + endOfStream + ")";
+        + ", status=" + status + ")";
   }
 
   @Override
   public int hashCode() {
-    return stream.hashCode();
+    return Objects.hashCode(stream, status);
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/StreamIdHolder.java b/netty/src/main/java/io/grpc/netty/StreamIdHolder.java
index 0ba526d9b66..65203c721d8 100644
--- a/netty/src/main/java/io/grpc/netty/StreamIdHolder.java
+++ b/netty/src/main/java/io/grpc/netty/StreamIdHolder.java
@@ -1,40 +1,29 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import io.perfmark.Tag;
+
 /** Container for stream ids. */
 interface StreamIdHolder {
   /**
-   * Returns the id or {@link io.grpc.internal.AbstractStream#ABSENT_ID}.
+   * Returns the id.
    */
   int id();
+
+  Tag tag();
 }
diff --git a/netty/src/main/java/io/grpc/netty/UdsNameResolver.java b/netty/src/main/java/io/grpc/netty/UdsNameResolver.java
new file mode 100644
index 00000000000..de14dc8b460
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/UdsNameResolver.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2022 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.netty;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Preconditions;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.StatusOr;
+import io.netty.channel.unix.DomainSocketAddress;
+import java.util.ArrayList;
+import java.util.List;
+
+final class UdsNameResolver extends NameResolver {
+  private NameResolver.Listener2 listener;
+  private final String authority;
+
+  UdsNameResolver(String authority, String targetPath, Args args) {
+    checkArgument(authority == null, "non-null authority not supported");
+    this.authority = targetPath;
+  }
+
+  @Override
+  public String getServiceAuthority() {
+    return this.authority;
+  }
+
+  @Override
+  public void start(Listener2 listener) {
+    Preconditions.checkState(this.listener == null, "already started");
+    this.listener = checkNotNull(listener, "listener");
+    resolve();
+  }
+
+  @Override
+  public void refresh() {
+    resolve();
+  }
+
+  private void resolve() {
+    ResolutionResult.Builder resolutionResultBuilder = ResolutionResult.newBuilder();
+    List<EquivalentAddressGroup> servers = new ArrayList<>(1);
+    servers.add(new EquivalentAddressGroup(new DomainSocketAddress(authority)));
+    resolutionResultBuilder.setAddressesOrError(StatusOr.fromValue(servers));
+    listener.onResult2(resolutionResultBuilder.build());
+  }
+
+  @Override
+  public void shutdown() {}
+}
diff --git a/netty/src/main/java/io/grpc/netty/UdsNameResolverProvider.java b/netty/src/main/java/io/grpc/netty/UdsNameResolverProvider.java
new file mode 100644
index 00000000000..fe6300057fd
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/UdsNameResolverProvider.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2022 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.netty;
+
+import com.google.common.base.Preconditions;
+import io.grpc.Internal;
+import io.grpc.NameResolver;
+import io.grpc.NameResolverProvider;
+import io.netty.channel.unix.DomainSocketAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.Collection;
+import java.util.Collections;
+
+@Internal
+public final class UdsNameResolverProvider extends NameResolverProvider {
+
+  private static final String SCHEME = "unix";
+
+  @Override
+  public UdsNameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+    if (SCHEME.equals(targetUri.getScheme())) {
+      return new UdsNameResolver(targetUri.getAuthority(), getTargetPathFromUri(targetUri), args);
+    } else {
+      return null;
+    }
+  }
+
+  static String getTargetPathFromUri(URI targetUri) {
+    Preconditions.checkArgument(SCHEME.equals(targetUri.getScheme()), "scheme must be " + SCHEME);
+    String targetPath = targetUri.getPath();
+    if (targetPath == null) {
+      targetPath = Preconditions.checkNotNull(targetUri.getSchemeSpecificPart(), "targetPath");
+    }
+    return targetPath;
+  }
+
+  @Override
+  public String getDefaultScheme() {
+    return SCHEME;
+  }
+
+  @Override
+  protected boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  protected int priority() {
+    return 3;
+  }
+
+  @Override
+  public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+    return Collections.singleton(DomainSocketAddress.class);
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/UdsNettyChannelProvider.java b/netty/src/main/java/io/grpc/netty/UdsNettyChannelProvider.java
new file mode 100644
index 00000000000..4e9895da0a8
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/UdsNettyChannelProvider.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2015 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.netty;
+
+import com.google.common.base.Preconditions;
+import io.grpc.ChannelCredentials;
+import io.grpc.Internal;
+import io.grpc.ManagedChannelProvider;
+import io.grpc.internal.SharedResourcePool;
+import io.netty.channel.unix.DomainSocketAddress;
+import java.net.SocketAddress;
+import java.util.Collection;
+import java.util.Collections;
+
+/** Provider for {@link NettyChannelBuilder} instances for UDS channels. */
+@Internal
+public final class UdsNettyChannelProvider extends ManagedChannelProvider {
+
+  @Override
+  public boolean isAvailable() {
+    return (Utils.EPOLL_DOMAIN_CLIENT_CHANNEL_TYPE != null);
+  }
+
+  @Override
+  public int priority() {
+    return 3;
+  }
+
+  @Override
+  public NettyChannelBuilder builderForAddress(String name, int port) {
+    throw new AssertionError("NettyChannelProvider shadows this implementation");
+  }
+
+  @Override
+  public NettyChannelBuilder builderForTarget(String target) {
+    throw new AssertionError("NettyChannelProvider shadows this implementation");
+  }
+
+  @Override
+  public NewChannelBuilderResult newChannelBuilder(String target, ChannelCredentials creds) {
+    Preconditions.checkState(isAvailable());
+    NewChannelBuilderResult result = new NettyChannelProvider().newChannelBuilder(target, creds);
+    if (result.getChannelBuilder() != null) {
+      ((NettyChannelBuilder) result.getChannelBuilder())
+          .eventLoopGroupPool(SharedResourcePool.forResource(Utils.DEFAULT_WORKER_EVENT_LOOP_GROUP))
+          .channelType(Utils.EPOLL_DOMAIN_CLIENT_CHANNEL_TYPE, DomainSocketAddress.class);
+    }
+    return result;
+  }
+
+  @Override
+  protected Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+    return Collections.singleton(DomainSocketAddress.class);
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/UnhelpfulSecurityProvider.java b/netty/src/main/java/io/grpc/netty/UnhelpfulSecurityProvider.java
new file mode 100644
index 00000000000..dca8987a80d
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/UnhelpfulSecurityProvider.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2021 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.netty;
+
+import java.security.Provider;
+
+/**
+ * A stand-in provider when you must provide a provider but you don't actually have one.
+ */
+final class UnhelpfulSecurityProvider extends Provider {
+  private static final long serialVersionUID = 0;
+
+  @SuppressWarnings("deprecation") // double-based constructor deprecated in Java 9
+  public UnhelpfulSecurityProvider() {
+    super("UnhelpfulSecurityProvider", 0.0, "A Provider that provides nothing");
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/Utils.java b/netty/src/main/java/io/grpc/netty/Utils.java
index 5546db394bb..386df20ba0b 100644
--- a/netty/src/main/java/io/grpc/netty/Utils.java
+++ b/netty/src/main/java/io/grpc/netty/Utils.java
@@ -1,86 +1,194 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import static com.google.common.base.Preconditions.checkState;
 import static io.grpc.internal.GrpcUtil.CONTENT_TYPE_KEY;
-import static io.grpc.internal.GrpcUtil.USER_AGENT_KEY;
 import static io.grpc.internal.TransportFrameUtil.toHttp2Headers;
 import static io.grpc.internal.TransportFrameUtil.toRawSerializedHeaders;
+import static io.netty.channel.ChannelOption.SO_LINGER;
+import static io.netty.channel.ChannelOption.SO_TIMEOUT;
 import static io.netty.util.CharsetUtil.UTF_8;
+import static java.nio.charset.StandardCharsets.US_ASCII;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.InternalChannelz;
 import io.grpc.InternalMetadata;
 import io.grpc.Metadata;
 import io.grpc.Status;
 import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.SharedResourceHolder.Resource;
-import io.grpc.netty.GrpcHttp2HeadersDecoder.GrpcHttp2InboundHeaders;
+import io.grpc.internal.TransportTracer;
+import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2InboundHeaders;
+import io.grpc.netty.NettySocketSupport.NativeSocketOptions;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.PooledByteBufAllocator;
+import io.netty.buffer.UnpooledByteBufAllocator;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelConfig;
+import io.netty.channel.ChannelFactory;
+import io.netty.channel.ChannelOption;
 import io.netty.channel.EventLoopGroup;
+import io.netty.channel.ReflectiveChannelFactory;
+import io.netty.channel.ServerChannel;
 import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.handler.codec.DecoderException;
+import io.netty.handler.codec.http2.Http2Connection;
 import io.netty.handler.codec.http2.Http2Exception;
+import io.netty.handler.codec.http2.Http2FlowController;
 import io.netty.handler.codec.http2.Http2Headers;
+import io.netty.handler.codec.http2.Http2Stream;
 import io.netty.util.AsciiString;
+import io.netty.util.NettyRuntime;
 import io.netty.util.concurrent.DefaultThreadFactory;
 import java.io.IOException;
+import java.lang.reflect.Constructor;
 import java.nio.channels.ClosedChannelException;
+import java.nio.channels.UnresolvedAddressException;
+import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.net.ssl.SSLException;
 
 /**
  * Common utility methods.
  */
-@VisibleForTesting
 class Utils {
+  private static final Logger logger = Logger.getLogger(Utils.class.getName());
 
   public static final AsciiString STATUS_OK = AsciiString.of("200");
   public static final AsciiString HTTP_METHOD = AsciiString.of(GrpcUtil.HTTP_METHOD);
+  public static final AsciiString HTTP_GET_METHOD = AsciiString.of("GET");
   public static final AsciiString HTTPS = AsciiString.of("https");
   public static final AsciiString HTTP = AsciiString.of("http");
   public static final AsciiString CONTENT_TYPE_HEADER = AsciiString.of(CONTENT_TYPE_KEY.name());
   public static final AsciiString CONTENT_TYPE_GRPC = AsciiString.of(GrpcUtil.CONTENT_TYPE_GRPC);
-  public static final AsciiString TE_HEADER = AsciiString.of("te");
+  public static final AsciiString TE_HEADER = AsciiString.of(GrpcUtil.TE_HEADER.name());
   public static final AsciiString TE_TRAILERS = AsciiString.of(GrpcUtil.TE_TRAILERS);
-  public static final AsciiString USER_AGENT = AsciiString.of(USER_AGENT_KEY.name());
+  public static final AsciiString USER_AGENT = AsciiString.of(GrpcUtil.USER_AGENT_KEY.name());
+  public static final Resource<EventLoopGroup> NIO_BOSS_EVENT_LOOP_GROUP
+      = new DefaultEventLoopGroupResource(1, "grpc-nio-boss-ELG", EventLoopGroupType.NIO);
+  public static final Resource<EventLoopGroup> NIO_WORKER_EVENT_LOOP_GROUP
+      = new DefaultEventLoopGroupResource(0, "grpc-nio-worker-ELG", EventLoopGroupType.NIO);
+  private static final int HEADER_ENTRY_OVERHEAD = 32;
+  private static final byte[] binaryHeaderSuffixBytes =
+      Metadata.BINARY_HEADER_SUFFIX.getBytes(US_ASCII);
+  public static final Resource<EventLoopGroup> DEFAULT_BOSS_EVENT_LOOP_GROUP;
+  public static final Resource<EventLoopGroup> DEFAULT_WORKER_EVENT_LOOP_GROUP;
+
+  // This class is initialized on first use, thus provides delayed allocator creation.
+  private static final class ByteBufAllocatorPreferDirectHolder {
+    private static final ByteBufAllocator allocator = createByteBufAllocator(true);
+  }
 
-  public static final Resource<EventLoopGroup> DEFAULT_BOSS_EVENT_LOOP_GROUP =
-      new DefaultEventLoopGroupResource(1, "grpc-default-boss-ELG");
+  // This class is initialized on first use, thus provides delayed allocator creation.
+  private static final class ByteBufAllocatorPreferHeapHolder {
+    private static final ByteBufAllocator allocator = createByteBufAllocator(false);
+  }
 
-  public static final Resource<EventLoopGroup> DEFAULT_WORKER_EVENT_LOOP_GROUP =
-      new DefaultEventLoopGroupResource(0, "grpc-default-worker-ELG");
+  public static final ChannelFactory<? extends ServerChannel> DEFAULT_SERVER_CHANNEL_FACTORY;
+  public static final Class<? extends Channel> DEFAULT_CLIENT_CHANNEL_TYPE;
+  public static final Class<? extends Channel> EPOLL_DOMAIN_CLIENT_CHANNEL_TYPE;
 
-  @VisibleForTesting
-  static boolean validateHeaders = false;
+  @Nullable
+  private static final Constructor<? extends EventLoopGroup> EPOLL_EVENT_LOOP_GROUP_CONSTRUCTOR;
+
+  static {
+    // Decide default channel types and EventLoopGroup based on Epoll availability
+    if (isEpollAvailable()) {
+      DEFAULT_CLIENT_CHANNEL_TYPE = epollChannelType();
+      EPOLL_DOMAIN_CLIENT_CHANNEL_TYPE = epollDomainSocketChannelType();
+      DEFAULT_SERVER_CHANNEL_FACTORY = new ReflectiveChannelFactory<>(epollServerChannelType());
+      EPOLL_EVENT_LOOP_GROUP_CONSTRUCTOR = epollEventLoopGroupConstructor();
+      DEFAULT_BOSS_EVENT_LOOP_GROUP = new DefaultEventLoopGroupResource(
+          1, "grpc-default-boss-ELG", EventLoopGroupType.EPOLL);
+      DEFAULT_WORKER_EVENT_LOOP_GROUP = new DefaultEventLoopGroupResource(
+          0, "grpc-default-worker-ELG", EventLoopGroupType.EPOLL);
+    } else {
+      logger.log(Level.FINE, "Epoll is not available, using Nio.", getEpollUnavailabilityCause());
+      DEFAULT_SERVER_CHANNEL_FACTORY = nioServerChannelFactory();
+      DEFAULT_CLIENT_CHANNEL_TYPE = NioSocketChannel.class;
+      EPOLL_DOMAIN_CLIENT_CHANNEL_TYPE = null;
+      DEFAULT_BOSS_EVENT_LOOP_GROUP = NIO_BOSS_EVENT_LOOP_GROUP;
+      DEFAULT_WORKER_EVENT_LOOP_GROUP = NIO_WORKER_EVENT_LOOP_GROUP;
+      EPOLL_EVENT_LOOP_GROUP_CONSTRUCTOR = null;
+    }
+  }
+
+  public static ByteBufAllocator getByteBufAllocator(boolean forceHeapBuffer) {
+    if (Boolean.parseBoolean(
+            System.getProperty("io.grpc.netty.useCustomAllocator", "true"))) {
+
+      String allocType = System.getProperty("io.netty.allocator.type", "pooled");
+      if (allocType.toLowerCase(Locale.ROOT).equals("unpooled")) {
+        logger.log(Level.FINE, "Using unpooled allocator");
+        return UnpooledByteBufAllocator.DEFAULT;
+      }
+
+      boolean defaultPreferDirect = PooledByteBufAllocator.defaultPreferDirect();
+      logger.log(
+          Level.FINE,
+          "Using custom allocator: forceHeapBuffer={0}, defaultPreferDirect={1}",
+          new Object[] { forceHeapBuffer, defaultPreferDirect });
+      if (forceHeapBuffer || !defaultPreferDirect) {
+        return ByteBufAllocatorPreferHeapHolder.allocator;
+      } else {
+        return ByteBufAllocatorPreferDirectHolder.allocator;
+      }
+    } else {
+      logger.log(Level.FINE, "Using default allocator");
+      return ByteBufAllocator.DEFAULT;
+    }
+  }
+
+  private static ByteBufAllocator createByteBufAllocator(boolean preferDirect) {
+    int maxOrder;
+    logger.log(Level.FINE, "Creating allocator, preferDirect=" + preferDirect);
+    if (System.getProperty("io.netty.allocator.maxOrder") == null) {
+      // See the implementation of PooledByteBufAllocator.  DEFAULT_MAX_ORDER in there is
+      // 11, which makes chunk size to be 8192 << 11 = 16 MiB.  We want the chunk size to be
+      // 2MiB, thus reducing the maxOrder to 8.
+      maxOrder = 8;
+      logger.log(Level.FINE, "Forcing maxOrder=" + maxOrder);
+    } else {
+      maxOrder = PooledByteBufAllocator.defaultMaxOrder();
+      logger.log(Level.FINE, "Using default maxOrder=" + maxOrder);
+    }
+    return new PooledByteBufAllocator(
+        preferDirect,
+        PooledByteBufAllocator.defaultNumHeapArena(),
+        // Assuming neither gRPC nor netty are using allocator.directBuffer() to request
+        // specifically for direct buffers, which is true as I just checked, setting arenas to 0
+        // will make sure no direct buffer is ever created.
+        preferDirect ? PooledByteBufAllocator.defaultNumDirectArena() : 0,
+        PooledByteBufAllocator.defaultPageSize(),
+        maxOrder,
+        PooledByteBufAllocator.defaultSmallCacheSize(),
+        PooledByteBufAllocator.defaultNormalCacheSize(),
+        PooledByteBufAllocator.defaultUseCacheForAllThreads());
+  }
 
   public static Metadata convertHeaders(Http2Headers http2Headers) {
     if (http2Headers instanceof GrpcHttp2InboundHeaders) {
@@ -90,6 +198,62 @@ public static Metadata convertHeaders(Http2Headers http2Headers) {
     return InternalMetadata.newMetadata(convertHeadersToArray(http2Headers));
   }
 
+  public static int getH2HeadersSize(Http2Headers http2Headers) {
+    if (http2Headers instanceof GrpcHttp2InboundHeaders) {
+      GrpcHttp2InboundHeaders h = (GrpcHttp2InboundHeaders) http2Headers;
+      int size = 0;
+      for (int i = 0; i < h.numHeaders(); i++) {
+        size += h.namesAndValues()[2 * i].length;
+        size +=
+            maybeAddBinaryHeaderOverhead(h.namesAndValues()[2 * i], h.namesAndValues()[2 * i + 1]);
+        size += HEADER_ENTRY_OVERHEAD;
+      }
+      return size;
+    }
+
+    // the binary header is not decoded yet, no need to add overhead.
+    int size = 0;
+    for (Map.Entry<CharSequence, CharSequence> entry : http2Headers) {
+      size += entry.getKey().length();
+      size += entry.getValue().length();
+      size += HEADER_ENTRY_OVERHEAD;
+    }
+    return size;
+  }
+
+  private static int maybeAddBinaryHeaderOverhead(byte[] name, byte[] value) {
+    if (endsWith(name, binaryHeaderSuffixBytes)) {
+      return value.length * 4 / 3;
+    }
+    return value.length;
+  }
+
+  private static boolean endsWith(byte[] bytes, byte[] suffix) {
+    if (bytes == null || suffix == null || bytes.length < suffix.length) {
+      return false;
+    }
+
+    for (int i = 0; i < suffix.length; i++) {
+      if (bytes[bytes.length - suffix.length + i] != suffix[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  public static boolean shouldRejectOnMetadataSizeSoftLimitExceeded(
+      int h2HeadersSize, int softLimitHeaderListSize, int maxHeaderListSize) {
+    if (h2HeadersSize < softLimitHeaderListSize) {
+      return false;
+    }
+    double failProbability =
+        (double) (h2HeadersSize - softLimitHeaderListSize) / (double) (maxHeaderListSize
+            - softLimitHeaderListSize);
+    return Math.random() < failProbability;
+  }
+
+  @CheckReturnValue
   private static byte[][] convertHeadersToArray(Http2Headers http2Headers) {
     // The Netty AsciiString class is really just a wrapper around a byte[] and supports
     // arbitrary binary data, not just ASCII.
@@ -116,20 +280,32 @@ public static Http2Headers convertClientHeaders(Metadata headers,
       AsciiString scheme,
       AsciiString defaultPath,
       AsciiString authority,
+      AsciiString method,
       AsciiString userAgent) {
     Preconditions.checkNotNull(defaultPath, "defaultPath");
     Preconditions.checkNotNull(authority, "authority");
+    Preconditions.checkNotNull(method, "method");
+
+    // Discard any application supplied duplicates of the reserved headers
+    headers.discardAll(CONTENT_TYPE_KEY);
+    headers.discardAll(GrpcUtil.TE_HEADER);
+    headers.discardAll(GrpcUtil.USER_AGENT_KEY);
 
     return GrpcHttp2OutboundHeaders.clientRequestHeaders(
         toHttp2Headers(headers),
         authority,
         defaultPath,
-        HTTP_METHOD,
+        method,
         scheme,
         userAgent);
   }
 
   public static Http2Headers convertServerHeaders(Metadata headers) {
+    // Discard any application supplied duplicates of the reserved headers
+    headers.discardAll(CONTENT_TYPE_KEY);
+    headers.discardAll(GrpcUtil.TE_HEADER);
+    headers.discardAll(GrpcUtil.USER_AGENT_KEY);
+
     return GrpcHttp2OutboundHeaders.serverResponseHeaders(toHttp2Headers(headers));
   }
 
@@ -154,37 +330,195 @@ public static Status statusFromThrowable(Throwable t) {
       return s;
     }
     if (t instanceof ClosedChannelException) {
-      // ClosedChannelException is used any time the Netty channel is closed. Proper error
-      // processing requires remembering the error that occurred before this one and using it
-      // instead.
-      return Status.UNKNOWN.withCause(t);
+      if (t.getCause() != null) {
+        // If the remote closes the connection while the event loop is processing, then a write or
+        // flush can be the first operation to notice the closure. Those exceptions are a
+        // ClosedChannelException, with a cause that provides more information, which is exactly
+        // what we'd hope for.
+        return Status.UNAVAILABLE.withDescription("channel closed").withCause(t);
+      }
+      // ClosedChannelException is used for all operations after the Netty channel is closed. But it
+      // doesn't have the original closure information. Proper error processing requires remembering
+      // the error that occurred before this one and using it instead.
+      //
+      // Netty uses an exception that has no stack trace, while we would never hope to show this to
+      // users, if it happens having the extra information may provide a small hint of where to
+      // look.
+      ClosedChannelException extraT = new ClosedChannelException();
+      extraT.initCause(t);
+      return Status.UNKNOWN.withDescription("channel closed").withCause(extraT);
+    }
+    if (t instanceof DecoderException && t.getCause() instanceof SSLException) {
+      return Status.UNAVAILABLE.withDescription("ssl exception").withCause(t);
     }
     if (t instanceof IOException) {
-      return Status.UNAVAILABLE.withCause(t);
+      return Status.UNAVAILABLE.withDescription("io exception").withCause(t);
+    }
+    if (t instanceof UnresolvedAddressException) {
+      return Status.UNAVAILABLE.withDescription("unresolved address").withCause(t);
     }
     if (t instanceof Http2Exception) {
-      return Status.INTERNAL.withCause(t);
+      return Status.INTERNAL.withDescription("http2 exception").withCause(t);
     }
     return s;
   }
 
-  private static class DefaultEventLoopGroupResource implements Resource<EventLoopGroup> {
+  @VisibleForTesting
+  static boolean isEpollAvailable() {
+    try {
+      return (boolean) (Boolean)
+          Class
+              .forName("io.netty.channel.epoll.Epoll")
+              .getDeclaredMethod("isAvailable")
+              .invoke(null);
+    } catch (ClassNotFoundException e) {
+      // this is normal if netty-epoll runtime dependency doesn't exist.
+      return false;
+    } catch (Exception e) {
+      throw new RuntimeException("Exception while checking Epoll availability", e);
+    }
+  }
+
+  private static Throwable getEpollUnavailabilityCause() {
+    try {
+      return (Throwable)
+          Class
+              .forName("io.netty.channel.epoll.Epoll")
+              .getDeclaredMethod("unavailabilityCause")
+              .invoke(null);
+    } catch (Exception e) {
+      return e;
+    }
+  }
+
+  // Must call when epoll is available
+  private static Class<? extends Channel> epollChannelType() {
+    try {
+      Class<? extends Channel> channelType = Class
+          .forName("io.netty.channel.epoll.EpollSocketChannel").asSubclass(Channel.class);
+      return channelType;
+    } catch (ClassNotFoundException e) {
+      throw new RuntimeException("Cannot load EpollSocketChannel", e);
+    }
+  }
+
+  // Must call when epoll is available
+  private static Class<? extends Channel> epollDomainSocketChannelType() {
+    try {
+      Class<? extends Channel> channelType = Class
+          .forName("io.netty.channel.epoll.EpollDomainSocketChannel").asSubclass(Channel.class);
+      return channelType;
+    } catch (ClassNotFoundException e) {
+      throw new RuntimeException("Cannot load EpollDomainSocketChannel", e);
+    }
+  }
+
+  // Must call when epoll is available
+  private static Constructor<? extends EventLoopGroup> epollEventLoopGroupConstructor() {
+    try {
+      return Class
+          .forName("io.netty.channel.epoll.EpollEventLoopGroup").asSubclass(EventLoopGroup.class)
+          .getConstructor(Integer.TYPE, ThreadFactory.class);
+    } catch (ClassNotFoundException e) {
+      throw new RuntimeException("Cannot load EpollEventLoopGroup", e);
+    } catch (NoSuchMethodException e) {
+      throw new RuntimeException("EpollEventLoopGroup constructor not found", e);
+    }
+  }
+
+  // Must call when epoll is available
+  private static Class<? extends ServerChannel> epollServerChannelType() {
+    try {
+      Class<? extends ServerChannel> serverSocketChannel =
+          Class
+              .forName("io.netty.channel.epoll.EpollServerSocketChannel")
+              .asSubclass(ServerChannel.class);
+      return serverSocketChannel;
+    } catch (ClassNotFoundException e) {
+      throw new RuntimeException("Cannot load EpollServerSocketChannel", e);
+    }
+  }
+
+  private static EventLoopGroup createEpollEventLoopGroup(
+      int parallelism,
+      ThreadFactory threadFactory) {
+    checkState(EPOLL_EVENT_LOOP_GROUP_CONSTRUCTOR != null, "Epoll is not available");
+
+    try {
+      return EPOLL_EVENT_LOOP_GROUP_CONSTRUCTOR
+          .newInstance(parallelism, threadFactory);
+    } catch (Exception e) {
+      throw new RuntimeException("Cannot create Epoll EventLoopGroup", e);
+    }
+  }
+
+  private static ChannelFactory<ServerChannel> nioServerChannelFactory() {
+    return new ChannelFactory<ServerChannel>() {
+      @Override
+      public ServerChannel newChannel() {
+        return new NioServerSocketChannel();
+      }
+    };
+  }
+
+  /**
+   * Returns TCP_USER_TIMEOUT channel option for Epoll channel if Epoll is available, otherwise
+   * null.
+   */
+  @Nullable
+  static ChannelOption<Integer> maybeGetTcpUserTimeoutOption() {
+    return getEpollChannelOption("TCP_USER_TIMEOUT");
+  }
+
+  @Nullable
+  @SuppressWarnings("unchecked")
+  private static <T> ChannelOption<T> getEpollChannelOption(String optionName) {
+    if (isEpollAvailable()) {
+      try {
+        return
+            (ChannelOption<T>) Class.forName("io.netty.channel.epoll.EpollChannelOption")
+                .getField(optionName)
+                .get(null);
+      } catch (Exception e) {
+        throw new RuntimeException("ChannelOption(" + optionName + ") is not available", e);
+      }
+    }
+    return null;
+  }
+
+  private static final class DefaultEventLoopGroupResource implements Resource<EventLoopGroup> {
     private final String name;
     private final int numEventLoops;
+    private final EventLoopGroupType eventLoopGroupType;
 
-    DefaultEventLoopGroupResource(int numEventLoops, String name) {
+    DefaultEventLoopGroupResource(
+        int numEventLoops, String name, EventLoopGroupType eventLoopGroupType) {
       this.name = name;
-      this.numEventLoops = numEventLoops;
+      // See the implementation of MultithreadEventLoopGroup.  DEFAULT_EVENT_LOOP_THREADS there
+      // defaults to NettyRuntime.availableProcessors() * 2.  We don't think we need that many
+      // threads.  The overhead of a thread includes file descriptors and at least one chunk
+      // allocation from PooledByteBufAllocator.  Here we reduce the default number of threads by
+      // half.
+      if (numEventLoops == 0 && System.getProperty("io.netty.eventLoopThreads") == null) {
+        this.numEventLoops = NettyRuntime.availableProcessors();
+      } else {
+        this.numEventLoops = numEventLoops;
+      }
+      this.eventLoopGroupType = eventLoopGroupType;
     }
 
     @Override
     public EventLoopGroup create() {
       // Use Netty's DefaultThreadFactory in order to get the benefit of FastThreadLocal.
-      boolean useDaemonThreads = true;
-      ThreadFactory threadFactory = new DefaultThreadFactory(name, useDaemonThreads);
-      int parallelism = numEventLoops == 0
-          ? Runtime.getRuntime().availableProcessors() * 2 : numEventLoops;
-      return new NioEventLoopGroup(parallelism, threadFactory);
+      ThreadFactory threadFactory = new DefaultThreadFactory(name, /* daemon= */ true);
+      switch (eventLoopGroupType) {
+        case NIO:
+          return new NioEventLoopGroup(numEventLoops, threadFactory);
+        case EPOLL:
+          return createEpollEventLoopGroup(numEventLoops, threadFactory);
+        default:
+          throw new AssertionError("Unknown/Unsupported EventLoopGroupType: " + eventLoopGroupType);
+      }
     }
 
     @Override
@@ -198,6 +532,72 @@ public String toString() {
     }
   }
 
+  static final class FlowControlReader implements TransportTracer.FlowControlReader {
+    private final Http2Stream connectionStream;
+    private final Http2FlowController local;
+    private final Http2FlowController remote;
+
+    FlowControlReader(Http2Connection connection) {
+      // 'local' in Netty is the _controller_ that controls inbound data. 'local' in Channelz is
+      // the _present window_ provided by the remote that allows data to be sent. They are
+      // opposites.
+      local = connection.remote().flowController();
+      remote = connection.local().flowController();
+      connectionStream = connection.connectionStream();
+    }
+
+    @Override
+    public TransportTracer.FlowControlWindows read() {
+      return new TransportTracer.FlowControlWindows(
+          local.windowSize(connectionStream),
+          remote.windowSize(connectionStream));
+    }
+  }
+
+  static InternalChannelz.SocketOptions getSocketOptions(Channel channel) {
+    ChannelConfig config = channel.config();
+    InternalChannelz.SocketOptions.Builder b = new InternalChannelz.SocketOptions.Builder();
+
+    // The API allows returning null but not sure if it can happen in practice.
+    // Let's be paranoid and do null checking just in case.
+    Integer lingerSeconds = config.getOption(SO_LINGER);
+    if (lingerSeconds != null) {
+      b.setSocketOptionLingerSeconds(lingerSeconds);
+    }
+
+    Integer timeoutMillis = config.getOption(SO_TIMEOUT);
+    if (timeoutMillis != null) {
+      // in java, SO_TIMEOUT only applies to receiving
+      b.setSocketOptionTimeoutMillis(timeoutMillis);
+    }
+
+    for (Map.Entry<ChannelOption<?>, Object> opt : config.getOptions().entrySet()) {
+      ChannelOption<?> key = opt.getKey();
+      // Constants are pooled, so there should only be one instance of each constant
+      if (key.equals(SO_LINGER) || key.equals(SO_TIMEOUT)) {
+        continue;
+      }
+      Object value = opt.getValue();
+      // zpencer: Can a netty option be null?
+      b.addOption(key.name(), String.valueOf(value));
+    }
+
+    NativeSocketOptions nativeOptions
+        = NettySocketSupport.getNativeSocketOptions(channel);
+    if (nativeOptions != null) {
+      b.setTcpInfo(nativeOptions.tcpInfo); // may be null
+      for (Map.Entry<String, String> entry : nativeOptions.otherInfo.entrySet()) {
+        b.addOption(entry.getKey(), entry.getValue());
+      }
+    }
+    return b.build();
+  }
+
+  private enum EventLoopGroupType {
+    NIO,
+    EPOLL
+  }
+
   private Utils() {
     // Prevents instantiation
   }
diff --git a/netty/src/main/java/io/grpc/netty/WriteBufferingAndExceptionHandler.java b/netty/src/main/java/io/grpc/netty/WriteBufferingAndExceptionHandler.java
new file mode 100644
index 00000000000..2799dfccb61
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/WriteBufferingAndExceptionHandler.java
@@ -0,0 +1,257 @@
+/*
+ * Copyright 2019 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.netty;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.Status;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufUtil;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import io.netty.util.ReferenceCountUtil;
+import java.net.SocketAddress;
+import java.util.ArrayDeque;
+import java.util.Queue;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Buffers all writes until either {@link #writeBufferedAndRemove(ChannelHandlerContext)} or
+ * {@link #failWrites(Throwable)} is called. This handler allows us to
+ * write to a {@link io.netty.channel.Channel} before we are allowed to write to it officially
+ * i.e.  before it's active or the TLS Handshake is complete.
+ */
+final class WriteBufferingAndExceptionHandler extends ChannelDuplexHandler {
+  private static final Logger logger =
+      Logger.getLogger(WriteBufferingAndExceptionHandler.class.getName());
+
+  private final Queue<ChannelWrite> bufferedWrites = new ArrayDeque<>();
+  private final ChannelHandler next;
+  private boolean writing;
+  private boolean flushRequested;
+  private Throwable failCause;
+
+  WriteBufferingAndExceptionHandler(ChannelHandler next) {
+    this.next = checkNotNull(next, "next");
+  }
+
+  @Override
+  public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+    ctx.pipeline().addBefore(ctx.name(), null, next);
+    super.handlerAdded(ctx);
+    // kick off protocol negotiation.
+    ctx.pipeline().fireUserEventTriggered(ProtocolNegotiationEvent.DEFAULT);
+  }
+
+  @Override
+  public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
+    if (!bufferedWrites.isEmpty()) {
+      Status status = Status.INTERNAL.withDescription("Buffer removed before draining writes");
+      failWrites(status.asRuntimeException());
+    }
+    super.handlerRemoved(ctx);
+  }
+
+  /**
+   * If this channel becomes inactive, then notify all buffered writes that we failed.
+   */
+  @Override
+  public void channelInactive(ChannelHandlerContext ctx) {
+    Status status = Status.UNAVAILABLE.withDescription(
+        "Connection closed while performing protocol negotiation for " + ctx.pipeline().names());
+    failWrites(status.asRuntimeException());
+  }
+
+  @Override
+  public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+    assert cause != null;
+    Throwable previousFailure = failCause;
+    Status status = Utils.statusFromThrowable(cause)
+        .augmentDescription("Channel Pipeline: " + ctx.pipeline().names());
+    failWrites(status.asRuntimeException());
+    // Check to see if the channel is active and this is the first failure.  If a downstream
+    // handler triggers an exception in close(), avoid being reentrant.  This is not obviously
+    // correct, so here are the cases and how they are correctly handled:
+    // 1. !active, prev==null: the channel is inactive, no-op
+    // 2. !active, prev!=null: the channel is inactive, no-op
+    // 3.  active, prev==null: this is the first error, close
+    // 4a. active, prev!=null[channelInactive]: impossible, no-op
+    // 4b. active, prev!=null[close]: close() cannot succeed, no point in calling ctx.close().
+    // 4c. active, prev!=null[handlerRemoved]: channel will be closed out-of-band by buffered write.
+    // 4d. active, prev!=null[connect]: impossible, channel can't be active after a failed connect.
+    if (ctx.channel().isActive() && previousFailure == null) {
+      final class LogOnFailure implements ChannelFutureListener {
+        @Override
+        public void operationComplete(ChannelFuture future) {
+          if (!future.isSuccess()) {
+            logger.log(Level.FINE, "Failed closing channel", future.cause());
+          }
+        }
+      }
+
+      ctx.close().addListener(new LogOnFailure());
+    }
+  }
+
+  /**
+   * Buffers the write until either {@link #writeBufferedAndRemove(ChannelHandlerContext)} is
+   * called, or we have somehow failed. If we have already failed in the past, then the write
+   * will fail immediately.
+   */
+  @Override
+  @SuppressWarnings("FutureReturnValueIgnored")
+  public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {
+    if (failCause != null) {
+      promise.setFailure(failCause);
+      ReferenceCountUtil.release(msg);
+    } else {
+      // Do not special case GracefulServerCloseCommand, as we don't want to cause handshake
+      // failures.
+      if (msg instanceof GracefulCloseCommand || msg instanceof ForcefulCloseCommand) {
+        // No point in continuing negotiation
+        ctx.close();
+        // Still enqueue the command in case the HTTP/2 handler is already on the pipeline
+      }
+      bufferedWrites.add(new ChannelWrite(msg, promise));
+    }
+  }
+
+  /**
+   * Connect failures do not show up as {@link #channelInactive} or {@link #exceptionCaught}, so
+   * it needs to be watched.
+   */
+  @Override
+  public void connect(
+      ChannelHandlerContext ctx,
+      SocketAddress remoteAddress,
+      SocketAddress localAddress,
+      ChannelPromise promise) throws Exception {
+    final class ConnectListener implements ChannelFutureListener {
+      @Override
+      public void operationComplete(ChannelFuture future) {
+        if (!future.isSuccess()) {
+          failWrites(future.cause());
+        }
+      }
+    }
+
+    super.connect(ctx, remoteAddress, localAddress, promise);
+    promise.addListener(new ConnectListener());
+  }
+
+  @Override
+  public void channelRead(ChannelHandlerContext ctx, Object msg) {
+    try {
+      if (logger.isLoggable(Level.FINE)) {
+        Object loggedMsg = msg instanceof ByteBuf ? ByteBufUtil.hexDump((ByteBuf) msg) : msg;
+        logger.log(
+            Level.FINE,
+            "Unexpected channelRead()->{0} reached end of pipeline {1}",
+            new Object[] {loggedMsg, ctx.pipeline().names()});
+      }
+      exceptionCaught(
+          ctx,
+          Status.INTERNAL.withDescription(
+              "channelRead() missed by ProtocolNegotiator handler: " + msg)
+              .asRuntimeException());
+    } finally {
+      ReferenceCountUtil.safeRelease(msg);
+    }
+  }
+
+  /**
+   * Calls to this method will not trigger an immediate flush. The flush will be deferred until
+   * {@link #writeBufferedAndRemove(ChannelHandlerContext)}.
+   */
+  @Override
+  public void flush(ChannelHandlerContext ctx) {
+    /*
+     * Swallowing any flushes is not only an optimization but also required
+     * for the SslHandler to work correctly. If the SslHandler receives multiple
+     * flushes while the handshake is still ongoing, then the handshake "randomly"
+     * times out. Not sure at this point why this is happening. Doing a single flush
+     * seems to work but multiple flushes don't ...
+     */
+    flushRequested = true;
+  }
+
+  /**
+   * If we are still performing protocol negotiation, then this will propagate failures to all
+   * buffered writes.
+   */
+  @Override
+  public void close(ChannelHandlerContext ctx, ChannelPromise future) throws Exception {
+    Status status = Status.UNAVAILABLE.withDescription(
+        "Connection closing while performing protocol negotiation for " + ctx.pipeline().names());
+    failWrites(status.asRuntimeException());
+    super.close(ctx, future);
+  }
+
+  @SuppressWarnings("FutureReturnValueIgnored")
+  final void writeBufferedAndRemove(ChannelHandlerContext ctx) {
+    // TODO(carl-mastrangelo): remove the isActive check and just fail if not yet ready.
+    if (!ctx.channel().isActive() || writing) {
+      return;
+    }
+    // Make sure that method can't be reentered, so that the ordering
+    // in the queue can't be messed up.
+    writing = true;
+    while (!bufferedWrites.isEmpty()) {
+      ChannelWrite write = bufferedWrites.poll();
+      ctx.write(write.msg, write.promise);
+    }
+    if (flushRequested) {
+      ctx.flush();
+    }
+    // Removal has to happen last as the above writes will likely trigger
+    // new writes that have to be added to the end of queue in order to not
+    // mess up the ordering.
+    ctx.pipeline().remove(this);
+  }
+
+  /**
+   * Propagate failures to all buffered writes.
+   */
+  @SuppressWarnings("FutureReturnValueIgnored")
+  private void failWrites(Throwable cause) {
+    if (failCause == null) {
+      failCause = cause;
+    } else {
+      logger.log(Level.FINE, "Ignoring duplicate failure", cause);
+    }
+    while (!bufferedWrites.isEmpty()) {
+      ChannelWrite write = bufferedWrites.poll();
+      write.promise.setFailure(cause);
+      ReferenceCountUtil.release(write.msg);
+    }
+  }
+
+  private static final class ChannelWrite {
+    final Object msg;
+    final ChannelPromise promise;
+
+    ChannelWrite(Object msg, ChannelPromise promise) {
+      this.msg = msg;
+      this.promise = promise;
+    }
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/WriteQueue.java b/netty/src/main/java/io/grpc/netty/WriteQueue.java
index 2b3f77e6c6e..a96b7defac8 100644
--- a/netty/src/main/java/io/grpc/netty/WriteQueue.java
+++ b/netty/src/main/java/io/grpc/netty/WriteQueue.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -37,6 +22,9 @@
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelPromise;
+import io.perfmark.Link;
+import io.perfmark.PerfMark;
+import io.perfmark.TaskCloseable;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -66,7 +54,7 @@ public void run() {
 
   public WriteQueue(Channel channel) {
     this.channel = Preconditions.checkNotNull(channel, "channel");
-    queue = new ConcurrentLinkedQueue<QueuedCommand>();
+    queue = new ConcurrentLinkedQueue<>();
   }
 
   /**
@@ -90,22 +78,10 @@ void scheduleFlush() {
    */
   @CanIgnoreReturnValue
   ChannelFuture enqueue(QueuedCommand command, boolean flush) {
-    return enqueue(command, channel.newPromise(), flush);
-  }
-
-  /**
-   * Enqueue a write command with a completion listener.
-   *
-   * @param command a write to be executed on the channel.
-   * @param promise to be marked on the completion of the write.
-   * @param flush true if a flush of the write should be schedule, false if a later call to
-   *              enqueue will schedule the flush.
-   */
-  @CanIgnoreReturnValue
-  ChannelFuture enqueue(QueuedCommand command, ChannelPromise promise, boolean flush) {
     // Detect erroneous code that tries to reuse command objects.
     Preconditions.checkArgument(command.promise() == null, "promise must not be set on command");
 
+    ChannelPromise promise = channel.newPromise();
     command.promise(promise);
     queue.add(command);
     if (flush) {
@@ -114,29 +90,58 @@ ChannelFuture enqueue(QueuedCommand command, ChannelPromise promise, boolean flu
     return promise;
   }
 
+  /**
+   * Enqueue the runnable. It is not safe for another thread to queue an Runnable directly to the
+   * event loop, because it will be out-of-order with writes. This method allows the Runnable to be
+   * processed in-order with writes.
+   */
+  void enqueue(Runnable runnable, boolean flush) {
+    queue.add(new RunnableCommand(runnable));
+    if (flush) {
+      scheduleFlush();
+    }
+  }
+
+  /**
+   * Executes enqueued work directly on the current thread. This can be used to trigger writes
+   * before performing additional reads. Must be called from the event loop. This method makes no
+   * guarantee that the work queue is empty when it returns.
+   */
+  void drainNow() {
+    Preconditions.checkState(channel.eventLoop().inEventLoop(), "must be on the event loop");
+    if (queue.peek() == null) {
+      return;
+    }
+    flush();
+  }
+
   /**
    * Process the queue of commands and dispatch them to the stream. This method is only
    * called in the event loop
    */
   private void flush() {
-    try {
+    try (TaskCloseable ignore = PerfMark.traceTask("WriteQueue.periodicFlush")) {
       QueuedCommand cmd;
       int i = 0;
       boolean flushedOnce = false;
       while ((cmd = queue.poll()) != null) {
-        channel.write(cmd, cmd.promise());
+        cmd.run(channel);
         if (++i == DEQUE_CHUNK_SIZE) {
           i = 0;
           // Flush each chunk so we are releasing buffers periodically. In theory this loop
           // might never end as new events are continuously added to the queue, if we never
           // flushed in that case we would be guaranteed to OOM.
-          channel.flush();
+          try (TaskCloseable ignore2 = PerfMark.traceTask("WriteQueue.flush0")) {
+            channel.flush();
+          }
           flushedOnce = true;
         }
       }
       // Must flush at least once, even if there were no writes.
       if (i != 0 || !flushedOnce) {
-        channel.flush();
+        try (TaskCloseable ignore2 = PerfMark.traceTask("WriteQueue.flush1")) {
+          channel.flush();
+        }
       }
     } finally {
       // Mark the write as done, if the queue is non-empty after marking trigger a new write.
@@ -147,9 +152,44 @@ private void flush() {
     }
   }
 
+  private static class RunnableCommand implements QueuedCommand {
+    private final Runnable runnable;
+    private final Link link;
+
+    public RunnableCommand(Runnable runnable) {
+      this.link = PerfMark.linkOut();
+      this.runnable = runnable;
+    }
+
+    @Override
+    public final void promise(ChannelPromise promise) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public final ChannelPromise promise() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public final void run(Channel channel) {
+      runnable.run();
+    }
+
+    @Override
+    public Link getLink() {
+      return link;
+    }
+  }
+
   abstract static class AbstractQueuedCommand implements QueuedCommand {
 
     private ChannelPromise promise;
+    private final Link link;
+
+    AbstractQueuedCommand() {
+      this.link = PerfMark.linkOut();
+    }
 
     @Override
     public final void promise(ChannelPromise promise) {
@@ -160,6 +200,16 @@ public final void promise(ChannelPromise promise) {
     public final ChannelPromise promise() {
       return promise;
     }
+
+    @Override
+    public final void run(Channel channel) {
+      channel.write(this, promise);
+    }
+
+    @Override
+    public Link getLink() {
+      return link;
+    }
   }
 
   /**
@@ -175,5 +225,9 @@ interface QueuedCommand {
      * Sets the promise.
      */
     void promise(ChannelPromise promise);
+
+    void run(Channel channel);
+
+    Link getLink();
   }
 }
diff --git a/netty/src/main/java/io/grpc/netty/X509AuthorityVerifier.java b/netty/src/main/java/io/grpc/netty/X509AuthorityVerifier.java
new file mode 100644
index 00000000000..a2df3dbc431
--- /dev/null
+++ b/netty/src/main/java/io/grpc/netty/X509AuthorityVerifier.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2025 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.netty;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.Status;
+import io.grpc.internal.AuthorityVerifier;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import javax.annotation.Nonnull;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.X509TrustManager;
+
+final class X509AuthorityVerifier implements AuthorityVerifier {
+  private final SSLEngine sslEngine;
+  private final X509TrustManager x509ExtendedTrustManager;
+
+  private static final Method checkServerTrustedMethod;
+
+  static {
+    Method method = null;
+    try {
+      Class<?> x509ExtendedTrustManagerClass =
+              Class.forName("javax.net.ssl.X509ExtendedTrustManager");
+      method = x509ExtendedTrustManagerClass.getMethod("checkServerTrusted",
+              X509Certificate[].class, String.class, SSLEngine.class);
+    } catch (ClassNotFoundException e) {
+      // Per-rpc authority overriding via call options will be disallowed.
+    } catch (NoSuchMethodException e) {
+      // Should never happen since X509ExtendedTrustManager was introduced in Android API level 24
+      // along with checkServerTrusted.
+    }
+    checkServerTrustedMethod = method;
+  }
+
+  public X509AuthorityVerifier(SSLEngine sslEngine, X509TrustManager x509ExtendedTrustManager) {
+    this.sslEngine = checkNotNull(sslEngine, "sslEngine");
+    this.x509ExtendedTrustManager = x509ExtendedTrustManager;
+  }
+
+  @Override
+  public Status verifyAuthority(@Nonnull String authority) {
+    if (x509ExtendedTrustManager == null) {
+      return Status.UNAVAILABLE.withDescription(
+              "Can't allow authority override in rpc when X509ExtendedTrustManager"
+                      + " is not available");
+    }
+    Status peerVerificationStatus;
+    try {
+      // Because the authority pseudo-header can contain a port number:
+      // https://www.rfc-editor.org/rfc/rfc7540#section-8.1.2.3
+      verifyAuthorityAllowedForPeerCert(removeAnyPortNumber(authority));
+      peerVerificationStatus = Status.OK;
+    } catch (SSLPeerUnverifiedException | CertificateException | InvocationTargetException
+             | IllegalAccessException | IllegalStateException e) {
+      peerVerificationStatus = Status.UNAVAILABLE.withDescription(
+              String.format("Peer hostname verification during rpc failed for authority '%s'",
+                      authority)).withCause(e);
+    }
+    return peerVerificationStatus;
+  }
+
+  private String removeAnyPortNumber(String authority) {
+    int closingSquareBracketIndex = authority.lastIndexOf(']');
+    int portNumberSeperatorColonIndex = authority.lastIndexOf(':');
+    if (portNumberSeperatorColonIndex > closingSquareBracketIndex) {
+      return authority.substring(0, portNumberSeperatorColonIndex);
+    }
+    return authority;
+  }
+
+  private void verifyAuthorityAllowedForPeerCert(String authority)
+          throws SSLPeerUnverifiedException, CertificateException, InvocationTargetException,
+          IllegalAccessException {
+    SSLEngine sslEngineWrapper = new ProtocolNegotiators.SslEngineWrapper(sslEngine, authority);
+    // The typecasting of Certificate to X509Certificate should work because this method will only
+    // be called when using TLS and thus X509.
+    Certificate[] peerCertificates = sslEngine.getSession().getPeerCertificates();
+    X509Certificate[] x509PeerCertificates = new X509Certificate[peerCertificates.length];
+    for (int i = 0; i < peerCertificates.length; i++) {
+      x509PeerCertificates[i] = (X509Certificate) peerCertificates[i];
+    }
+    if (checkServerTrustedMethod == null) {
+      throw new IllegalStateException("checkServerTrustedMethod not found");
+    }
+    checkServerTrustedMethod.invoke(
+            x509ExtendedTrustManager, x509PeerCertificates, "UNKNOWN", sslEngineWrapper);
+  }
+}
diff --git a/netty/src/main/java/io/grpc/netty/package-info.java b/netty/src/main/java/io/grpc/netty/package-info.java
index cc7805e0732..d1d7b87cf51 100644
--- a/netty/src/main/java/io/grpc/netty/package-info.java
+++ b/netty/src/main/java/io/grpc/netty/package-info.java
@@ -1,37 +1,22 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.
  */
 
 /**
  * The main transport implementation based on <a target="_blank" href="http://netty.io">Netty</a>,
  * for both the client and the server.
  */
-@javax.annotation.CheckReturnValue
+@com.google.errorprone.annotations.CheckReturnValue
 package io.grpc.netty;
diff --git a/netty/src/main/resources/META-INF/services/io.grpc.ManagedChannelProvider b/netty/src/main/resources/META-INF/services/io.grpc.ManagedChannelProvider
index ebd1bcdf024..e7b37ea49ac 100644
--- a/netty/src/main/resources/META-INF/services/io.grpc.ManagedChannelProvider
+++ b/netty/src/main/resources/META-INF/services/io.grpc.ManagedChannelProvider
@@ -1 +1,2 @@
 io.grpc.netty.NettyChannelProvider
+io.grpc.netty.UdsNettyChannelProvider
diff --git a/netty/src/main/resources/META-INF/services/io.grpc.NameResolverProvider b/netty/src/main/resources/META-INF/services/io.grpc.NameResolverProvider
new file mode 100644
index 00000000000..ec775013c1e
--- /dev/null
+++ b/netty/src/main/resources/META-INF/services/io.grpc.NameResolverProvider
@@ -0,0 +1 @@
+io.grpc.netty.UdsNameResolverProvider
diff --git a/netty/src/test/java/io/grpc/netty/AbstractHttp2HeadersTest.java b/netty/src/test/java/io/grpc/netty/AbstractHttp2HeadersTest.java
index 6dad4bc07bd..b9b7ffc6f15 100644
--- a/netty/src/test/java/io/grpc/netty/AbstractHttp2HeadersTest.java
+++ b/netty/src/test/java/io/grpc/netty/AbstractHttp2HeadersTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -65,8 +50,8 @@ public void allMethodsAreUnsupported() {
       } catch (InvocationTargetException ex) {
         assertEquals("For method: " + method,
             UnsupportedOperationException.class, ex.getCause().getClass());
-      } catch (Throwable t) {
-        throw new RuntimeException("Failure with method: " + method, t);
+      } catch (Exception ex) {
+        throw new AssertionError("Failure with method: " + method, ex);
       }
     }
   }
diff --git a/netty/src/test/java/io/grpc/netty/AdvancedTlsTest.java b/netty/src/test/java/io/grpc/netty/AdvancedTlsTest.java
new file mode 100644
index 00000000000..f34e336553b
--- /dev/null
+++ b/netty/src/test/java/io/grpc/netty/AdvancedTlsTest.java
@@ -0,0 +1,525 @@
+/*
+ * Copyright 2021 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.netty;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.fail;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.ChannelCredentials;
+import io.grpc.Grpc;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.ServerCredentials;
+import io.grpc.StatusRuntimeException;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.TlsServerCredentials;
+import io.grpc.TlsServerCredentials.ClientAuth;
+import io.grpc.internal.testing.TestUtils;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.TlsTesting;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import io.grpc.util.AdvancedTlsX509KeyManager;
+import io.grpc.util.AdvancedTlsX509TrustManager;
+import io.grpc.util.AdvancedTlsX509TrustManager.SslSocketAndEnginePeerVerifier;
+import io.grpc.util.AdvancedTlsX509TrustManager.Verification;
+import io.grpc.util.CertificateUtils;
+import java.io.Closeable;
+import java.io.File;
+import java.net.Socket;
+import java.security.GeneralSecurityException;
+import java.security.PrivateKey;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import javax.net.ssl.SSLEngine;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class AdvancedTlsTest {
+  private static final String SERVER_0_KEY_FILE = "server0.key";
+  private static final String SERVER_0_PEM_FILE = "server0.pem";
+  private static final String CLIENT_0_KEY_FILE = "client.key";
+  private static final String CLIENT_0_PEM_FILE = "client.pem";
+  private static final String CA_PEM_FILE = "ca.pem";
+  private static final String SERVER_BAD_KEY_FILE = "badserver.key";
+  private static final String SERVER_BAD_PEM_FILE = "badserver.pem";
+
+  private ScheduledExecutorService executor;
+  private Server server;
+  private ManagedChannel channel;
+
+  private File caCertFile;
+  private File serverKey0File;
+  private File serverCert0File;
+  private File clientKey0File;
+  private File clientCert0File;
+  private X509Certificate[] caCert;
+  private PrivateKey serverKey0;
+  private X509Certificate[] serverCert0;
+  private PrivateKey clientKey0;
+  private X509Certificate[] clientCert0;
+  private PrivateKey serverKeyBad;
+  private X509Certificate[] serverCertBad;
+
+  @Before
+  public void setUp()
+      throws Exception {
+    executor = Executors.newSingleThreadScheduledExecutor();
+    caCertFile = TestUtils.loadCert(CA_PEM_FILE);
+    serverKey0File = TestUtils.loadCert(SERVER_0_KEY_FILE);
+    serverCert0File = TestUtils.loadCert(SERVER_0_PEM_FILE);
+    clientKey0File = TestUtils.loadCert(CLIENT_0_KEY_FILE);
+    clientCert0File = TestUtils.loadCert(CLIENT_0_PEM_FILE);
+    caCert = CertificateUtils.getX509Certificates(TlsTesting.loadCert(CA_PEM_FILE));
+    serverKey0 = CertificateUtils.getPrivateKey(TlsTesting.loadCert(SERVER_0_KEY_FILE));
+    serverCert0 = CertificateUtils.getX509Certificates(TlsTesting.loadCert(SERVER_0_PEM_FILE));
+    clientKey0 = CertificateUtils.getPrivateKey(TlsTesting.loadCert(CLIENT_0_KEY_FILE));
+    clientCert0 = CertificateUtils.getX509Certificates(TlsTesting.loadCert(CLIENT_0_PEM_FILE));
+    serverKeyBad = CertificateUtils.getPrivateKey(TlsTesting.loadCert(SERVER_BAD_KEY_FILE));
+    serverCertBad = CertificateUtils.getX509Certificates(TlsTesting.loadCert(SERVER_BAD_PEM_FILE));
+  }
+
+  @After
+  public void tearDown() {
+    if (server != null) {
+      server.shutdown();
+    }
+    if (channel != null) {
+      channel.shutdown();
+    }
+    MoreExecutors.shutdownAndAwaitTermination(executor, 5, TimeUnit.SECONDS);
+  }
+
+  @Test
+  public void basicMutualTlsTest() throws Exception {
+    // Create & start a server.
+    ServerCredentials serverCredentials = TlsServerCredentials.newBuilder()
+        .keyManager(serverCert0File, serverKey0File).trustManager(caCertFile)
+        .clientAuth(ClientAuth.REQUIRE).build();
+    server = Grpc.newServerBuilderForPort(0, serverCredentials).addService(
+        new SimpleServiceImpl()).build().start();
+    // Create a client to connect.
+    ChannelCredentials channelCredentials = TlsChannelCredentials.newBuilder()
+        .keyManager(clientCert0File, clientKey0File).trustManager(caCertFile).build();
+    channel = Grpc.newChannelBuilderForAddress("localhost", server.getPort(), channelCredentials)
+        .overrideAuthority("foo.test.google.com.au").build();
+    // Start the connection.
+    try {
+      SimpleServiceGrpc.SimpleServiceBlockingStub client =
+          SimpleServiceGrpc.newBlockingStub(channel);
+      // Send an actual request, via the full GRPC & network stack, and check that a proper
+      // response comes back.
+      client.unaryRpc(SimpleRequest.getDefaultInstance());
+    } catch (StatusRuntimeException e) {
+      e.printStackTrace();
+      fail("Failed to make a connection");
+      e.printStackTrace();
+    }
+  }
+
+  @Test
+  public void advancedTlsKeyManagerTrustManagerMutualTlsTest() throws Exception {
+    // Create a server with the key manager and trust manager.
+    AdvancedTlsX509KeyManager serverKeyManager = new AdvancedTlsX509KeyManager();
+    serverKeyManager.updateIdentityCredentials(serverCert0, serverKey0);
+    AdvancedTlsX509TrustManager serverTrustManager = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.CERTIFICATE_ONLY_VERIFICATION)
+        .build();
+    serverTrustManager.updateTrustCredentials(caCert);
+    ServerCredentials serverCredentials = TlsServerCredentials.newBuilder()
+        .keyManager(serverKeyManager).trustManager(serverTrustManager)
+        .clientAuth(ClientAuth.REQUIRE).build();
+    server = Grpc.newServerBuilderForPort(0, serverCredentials).addService(
+        new SimpleServiceImpl()).build().start();
+    // Create a client with the key manager and trust manager.
+    AdvancedTlsX509KeyManager clientKeyManager = new AdvancedTlsX509KeyManager();
+    clientKeyManager.updateIdentityCredentials(clientCert0, clientKey0);
+    AdvancedTlsX509TrustManager clientTrustManager = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.CERTIFICATE_AND_HOST_NAME_VERIFICATION)
+        .build();
+    clientTrustManager.updateTrustCredentials(caCert);
+    ChannelCredentials channelCredentials = TlsChannelCredentials.newBuilder()
+        .keyManager(clientKeyManager).trustManager(clientTrustManager).build();
+    channel = Grpc.newChannelBuilderForAddress("localhost", server.getPort(), channelCredentials)
+        .overrideAuthority("foo.test.google.com.au").build();
+    // Start the connection.
+    try {
+      SimpleServiceGrpc.SimpleServiceBlockingStub client =
+          SimpleServiceGrpc.newBlockingStub(channel);
+      client.unaryRpc(SimpleRequest.getDefaultInstance());
+    } catch (StatusRuntimeException e) {
+      fail("Failed to make a connection");
+      e.printStackTrace();
+    }
+  }
+
+  @Test
+  public void trustManagerCustomVerifierMutualTlsTest() throws Exception {
+    AdvancedTlsX509KeyManager serverKeyManager = new AdvancedTlsX509KeyManager();
+    serverKeyManager.updateIdentityCredentials(serverCert0, serverKey0);
+    // Set server's custom verification based on the information of clientCert0.
+    AdvancedTlsX509TrustManager serverTrustManager = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.CERTIFICATE_ONLY_VERIFICATION)
+        .setSslSocketAndEnginePeerVerifier(
+            new SslSocketAndEnginePeerVerifier() {
+              @Override
+              public void verifyPeerCertificate(X509Certificate[] peerCertChain, String authType,
+                  Socket socket) throws CertificateException {
+                if (peerCertChain == null || peerCertChain.length == 0) {
+                  throw new CertificateException("peerCertChain is empty");
+                }
+                X509Certificate leafCert = peerCertChain[0];
+                if (!leafCert.getSubjectX500Principal().getName().contains("testclient")) {
+                  throw new CertificateException("SslSocketAndEnginePeerVerifier failed");
+                }
+              }
+
+              @Override
+              public void verifyPeerCertificate(X509Certificate[] peerCertChain, String authType,
+                  SSLEngine engine) throws CertificateException {
+                if (peerCertChain == null || peerCertChain.length == 0) {
+                  throw new CertificateException("peerCertChain is empty");
+                }
+                X509Certificate leafCert = peerCertChain[0];
+                if (!leafCert.getSubjectX500Principal().getName().contains("testclient")) {
+                  throw new CertificateException("SslSocketAndEnginePeerVerifier failed");
+                }
+              }
+            })
+        .build();
+    serverTrustManager.updateTrustCredentials(caCert);
+    ServerCredentials serverCredentials = TlsServerCredentials.newBuilder()
+        .keyManager(serverKeyManager).trustManager(serverTrustManager)
+        .clientAuth(ClientAuth.REQUIRE).build();
+    server = Grpc.newServerBuilderForPort(0, serverCredentials).addService(
+        new SimpleServiceImpl()).build().start();
+
+    AdvancedTlsX509KeyManager clientKeyManager = new AdvancedTlsX509KeyManager();
+    clientKeyManager.updateIdentityCredentials(clientCert0, clientKey0);
+    // Set client's custom verification based on the information of serverCert0.
+    AdvancedTlsX509TrustManager clientTrustManager = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.CERTIFICATE_ONLY_VERIFICATION)
+        .setSslSocketAndEnginePeerVerifier(
+            new SslSocketAndEnginePeerVerifier() {
+              @Override
+              public void verifyPeerCertificate(X509Certificate[] peerCertChain, String authType,
+                  Socket socket) throws CertificateException {
+                if (peerCertChain == null || peerCertChain.length == 0) {
+                  throw new CertificateException("peerCertChain is empty");
+                }
+                X509Certificate leafCert = peerCertChain[0];
+                if (!leafCert.getSubjectX500Principal().getName()
+                    .contains("*.test.google.com.au")) {
+                  throw new CertificateException("SslSocketAndEnginePeerVerifier failed");
+                }
+              }
+              
+              @Override
+              public void verifyPeerCertificate(X509Certificate[] peerCertChain, String authType,
+                  SSLEngine engine) throws CertificateException {
+                if (peerCertChain == null || peerCertChain.length == 0) {
+                  throw new CertificateException("peerCertChain is empty");
+                }
+                X509Certificate leafCert = peerCertChain[0];
+                if (!leafCert.getSubjectX500Principal().getName()
+                    .contains("*.test.google.com.au")) {
+                  throw new CertificateException("SslSocketAndEnginePeerVerifier failed");
+                }
+              }
+            })
+        .build();
+    clientTrustManager.updateTrustCredentials(caCert);
+    ChannelCredentials channelCredentials = TlsChannelCredentials.newBuilder()
+        .keyManager(clientKeyManager).trustManager(clientTrustManager).build();
+    channel = Grpc.newChannelBuilderForAddress(
+        "localhost", server.getPort(), channelCredentials).build();
+    // Start the connection.
+    try {
+      SimpleServiceGrpc.SimpleServiceBlockingStub client =
+          SimpleServiceGrpc.newBlockingStub(channel);
+      client.unaryRpc(SimpleRequest.getDefaultInstance());
+    } catch (StatusRuntimeException e) {
+      fail("Failed to make a connection");
+      e.printStackTrace();
+    }
+  }
+
+  @Test
+  public void trustManagerInsecurelySkipAllTest() throws Exception {
+    AdvancedTlsX509KeyManager serverKeyManager = new AdvancedTlsX509KeyManager();
+    // Even if we provide bad credentials for the server, the test should still pass, because we
+    // will configure the client to skip all checks later.
+    serverKeyManager.updateIdentityCredentials(serverCertBad, serverKeyBad);
+    AdvancedTlsX509TrustManager serverTrustManager = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.CERTIFICATE_ONLY_VERIFICATION)
+        .setSslSocketAndEnginePeerVerifier(
+            new SslSocketAndEnginePeerVerifier() {
+              @Override
+              public void verifyPeerCertificate(X509Certificate[] peerCertChain, String authType,
+                  Socket socket) { }
+
+              @Override
+              public void verifyPeerCertificate(X509Certificate[] peerCertChain, String authType,
+                  SSLEngine engine) { }
+            })
+        .build();
+    serverTrustManager.updateTrustCredentials(caCert);
+    ServerCredentials serverCredentials = TlsServerCredentials.newBuilder()
+        .keyManager(serverKeyManager).trustManager(serverTrustManager)
+        .clientAuth(ClientAuth.REQUIRE).build();
+    server = Grpc.newServerBuilderForPort(0, serverCredentials).addService(
+        new SimpleServiceImpl()).build().start();
+
+    AdvancedTlsX509KeyManager clientKeyManager = new AdvancedTlsX509KeyManager();
+    clientKeyManager.updateIdentityCredentials(clientCert0, clientKey0);
+    // Set the client to skip all checks, including traditional certificate verification.
+    // Note this is very dangerous in production environment - only do so if you are confident on
+    // what you are doing!
+    AdvancedTlsX509TrustManager clientTrustManager = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.INSECURELY_SKIP_ALL_VERIFICATION)
+        .setSslSocketAndEnginePeerVerifier(
+            new SslSocketAndEnginePeerVerifier() {
+              @Override
+              public void verifyPeerCertificate(X509Certificate[] peerCertChain, String authType,
+                  Socket socket) { }
+
+              @Override
+              public void verifyPeerCertificate(X509Certificate[] peerCertChain, String authType,
+                  SSLEngine engine) { }
+            })
+        .build();
+    clientTrustManager.updateTrustCredentials(caCert);
+    ChannelCredentials channelCredentials = TlsChannelCredentials.newBuilder()
+        .keyManager(clientKeyManager).trustManager(clientTrustManager).build();
+    channel = Grpc.newChannelBuilderForAddress(
+        "localhost", server.getPort(), channelCredentials).build();
+    // Start the connection.
+    try {
+      SimpleServiceGrpc.SimpleServiceBlockingStub client =
+          SimpleServiceGrpc.newBlockingStub(channel);
+      client.unaryRpc(SimpleRequest.getDefaultInstance());
+    } catch (StatusRuntimeException e) {
+      fail("Failed to make a connection");
+      e.printStackTrace();
+    }
+  }
+
+  @Test
+  public void onFileReloadingKeyManagerTrustManagerTest() throws Exception {
+    // Create & start a server.
+    AdvancedTlsX509KeyManager serverKeyManager = new AdvancedTlsX509KeyManager();
+    Closeable serverKeyShutdown = serverKeyManager.updateIdentityCredentials(serverCert0File,
+        serverKey0File, 100, TimeUnit.MILLISECONDS, executor);
+    AdvancedTlsX509TrustManager serverTrustManager = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.CERTIFICATE_ONLY_VERIFICATION)
+        .build();
+    Closeable serverTrustShutdown = serverTrustManager.updateTrustCredentials(caCertFile,
+        100, TimeUnit.MILLISECONDS, executor);
+    ServerCredentials serverCredentials = TlsServerCredentials.newBuilder()
+        .keyManager(serverKeyManager).trustManager(serverTrustManager)
+        .clientAuth(ClientAuth.REQUIRE).build();
+    server = Grpc.newServerBuilderForPort(0, serverCredentials).addService(
+        new SimpleServiceImpl()).build().start();
+    // Create a client to connect.
+    AdvancedTlsX509KeyManager clientKeyManager = new AdvancedTlsX509KeyManager();
+    Closeable clientKeyShutdown = clientKeyManager.updateIdentityCredentials(clientCert0File,
+        clientKey0File, 100, TimeUnit.MILLISECONDS, executor);
+    AdvancedTlsX509TrustManager clientTrustManager = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.CERTIFICATE_AND_HOST_NAME_VERIFICATION)
+        .build();
+    Closeable clientTrustShutdown = clientTrustManager.updateTrustCredentials(caCertFile,
+        100, TimeUnit.MILLISECONDS, executor);
+    ChannelCredentials channelCredentials = TlsChannelCredentials.newBuilder()
+        .keyManager(clientKeyManager).trustManager(clientTrustManager).build();
+    channel = Grpc.newChannelBuilderForAddress("localhost", server.getPort(), channelCredentials)
+        .overrideAuthority("foo.test.google.com.au").build();
+    // Start the connection.
+    try {
+      SimpleServiceGrpc.SimpleServiceBlockingStub client =
+          SimpleServiceGrpc.newBlockingStub(channel);
+      // Send an actual request, via the full GRPC & network stack, and check that a proper
+      // response comes back.
+      client.unaryRpc(SimpleRequest.getDefaultInstance());
+    } catch (StatusRuntimeException e) {
+      e.printStackTrace();
+      fail("Find error: " + e.getMessage());
+    }
+    // Clean up.
+    serverKeyShutdown.close();
+    serverTrustShutdown.close();
+    clientKeyShutdown.close();
+    clientTrustShutdown.close();
+  }
+
+  @Test
+  public void onFileLoadingKeyManagerTrustManagerTest() throws Exception {
+    // Create & start a server.
+    AdvancedTlsX509KeyManager serverKeyManager = new AdvancedTlsX509KeyManager();
+    serverKeyManager.updateIdentityCredentials(serverCert0File, serverKey0File);
+    AdvancedTlsX509TrustManager serverTrustManager = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.CERTIFICATE_ONLY_VERIFICATION)
+        .build();
+    serverTrustManager.updateTrustCredentials(caCertFile);
+    ServerCredentials serverCredentials = TlsServerCredentials.newBuilder()
+        .keyManager(serverKeyManager).trustManager(serverTrustManager)
+        .clientAuth(ClientAuth.REQUIRE).build();
+    server = Grpc.newServerBuilderForPort(0, serverCredentials).addService(
+        new SimpleServiceImpl()).build().start();
+    // Create a client to connect.
+    AdvancedTlsX509KeyManager clientKeyManager = new AdvancedTlsX509KeyManager();
+    clientKeyManager.updateIdentityCredentials(clientCert0File, clientKey0File);
+    AdvancedTlsX509TrustManager clientTrustManager = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.CERTIFICATE_AND_HOST_NAME_VERIFICATION)
+        .build();
+    clientTrustManager.updateTrustCredentials(caCertFile);
+    ChannelCredentials channelCredentials = TlsChannelCredentials.newBuilder()
+        .keyManager(clientKeyManager).trustManager(clientTrustManager).build();
+    channel = Grpc.newChannelBuilderForAddress("localhost", server.getPort(), channelCredentials)
+        .overrideAuthority("foo.test.google.com.au").build();
+    // Start the connection.
+    try {
+      SimpleServiceGrpc.SimpleServiceBlockingStub client =
+          SimpleServiceGrpc.newBlockingStub(channel);
+      // Send an actual request, via the full GRPC & network stack, and check that a proper
+      // response comes back.
+      client.unaryRpc(SimpleRequest.getDefaultInstance());
+    } catch (StatusRuntimeException e) {
+      e.printStackTrace();
+      fail("Find error: " + e.getMessage());
+    }
+  }
+
+  @Test
+  public void onFileReloadingKeyManagerBadInitialContentTest() {
+    AdvancedTlsX509KeyManager keyManager = new AdvancedTlsX509KeyManager();
+    // We swap the order of key and certificates to intentionally create an exception.
+    assertThrows(GeneralSecurityException.class,
+        () -> keyManager.updateIdentityCredentials(serverKey0File, serverCert0File,
+          100, TimeUnit.MILLISECONDS, executor));
+  }
+
+  @Test
+  public void onFileReloadingTrustManagerBadInitialContentTest() throws Exception {
+    AdvancedTlsX509TrustManager trustManager = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.CERTIFICATE_ONLY_VERIFICATION)
+        .build();
+    // We pass in a key as the trust certificates to intentionally create an exception.
+    assertThrows(GeneralSecurityException.class,
+        () -> trustManager.updateTrustCredentials(serverKey0File, 100, TimeUnit.MILLISECONDS,
+            executor));
+  }
+
+  @Test
+  public void keyManagerAliasesTest() {
+    AdvancedTlsX509KeyManager km = new AdvancedTlsX509KeyManager();
+    assertArrayEquals(
+        new String[] {"default"}, km.getClientAliases("", null));
+    assertEquals(
+        "default", km.chooseClientAlias(new String[] {"default"}, null, null));
+    assertArrayEquals(
+        new String[] {"default"}, km.getServerAliases("", null));
+    assertEquals(
+        "default", km.chooseServerAlias("default", null, null));
+  }
+
+  @Test
+  public void trustManagerCheckTrustedWithSocketTest() throws Exception {
+    AdvancedTlsX509TrustManager tm = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.INSECURELY_SKIP_ALL_VERIFICATION).build();
+    tm.updateTrustCredentials(caCert);
+    tm.checkClientTrusted(serverCert0, "RSA", new Socket());
+    tm.useSystemDefaultTrustCerts();
+    tm.checkServerTrusted(clientCert0, "RSA", new Socket());
+  }
+
+  @Test
+  public void trustManagerCheckClientTrustedWithoutParameterTest() throws Exception {
+    AdvancedTlsX509TrustManager tm = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.INSECURELY_SKIP_ALL_VERIFICATION).build();
+    CertificateException ex =
+        assertThrows(CertificateException.class, () -> tm.checkClientTrusted(serverCert0, "RSA"));
+    assertThat(ex).hasMessageThat()
+        .isEqualTo("Not enough information to validate peer. SSLEngine or Socket required.");
+  }
+
+  @Test
+  public void trustManagerCheckServerTrustedWithoutParameterTest() throws Exception {
+    AdvancedTlsX509TrustManager tm = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.INSECURELY_SKIP_ALL_VERIFICATION).build();
+    CertificateException ex =
+        assertThrows(CertificateException.class, () -> tm.checkServerTrusted(serverCert0, "RSA"));
+    assertThat(ex).hasMessageThat()
+        .isEqualTo("Not enough information to validate peer. SSLEngine or Socket required.");
+  }
+
+  @Test
+  public void trustManagerEmptyChainTest() throws Exception {
+    AdvancedTlsX509TrustManager tm = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.CERTIFICATE_ONLY_VERIFICATION)
+        .build();
+    tm.updateTrustCredentials(caCert);
+    IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+        () -> tm.checkClientTrusted(null, "RSA", (SSLEngine) null));
+    assertThat(ex).hasMessageThat()
+        .isEqualTo("Want certificate verification but got null or empty certificates");
+  }
+
+  @Test
+  public void trustManagerBadCustomVerificationTest() throws Exception {
+    AdvancedTlsX509TrustManager tm = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.CERTIFICATE_ONLY_VERIFICATION)
+        .setSslSocketAndEnginePeerVerifier(
+            new SslSocketAndEnginePeerVerifier() {
+              @Override
+              public void verifyPeerCertificate(X509Certificate[] peerCertChain, String authType,
+                  Socket socket) throws CertificateException {
+                throw new CertificateException("Bad Custom Verification");
+              }
+
+              @Override
+              public void verifyPeerCertificate(X509Certificate[] peerCertChain, String authType,
+                  SSLEngine engine) throws CertificateException {
+                throw new CertificateException("Bad Custom Verification");
+              }
+            }).build();
+    tm.updateTrustCredentials(caCert);
+    CertificateException ex = assertThrows(
+        CertificateException.class,
+        () -> tm.checkClientTrusted(serverCert0, "RSA", new Socket()));
+    assertThat(ex).hasMessageThat().isEqualTo("Bad Custom Verification");
+  }
+
+  private static class SimpleServiceImpl extends SimpleServiceGrpc.SimpleServiceImplBase {
+    @Override
+    public void unaryRpc(SimpleRequest req, StreamObserver<SimpleResponse> respOb) {
+      respOb.onNext(SimpleResponse.getDefaultInstance());
+      respOb.onCompleted();
+    }
+  }
+}
diff --git a/netty/src/test/java/io/grpc/netty/GrpcHttp2HeadersDecoderTest.java b/netty/src/test/java/io/grpc/netty/GrpcHttp2HeadersDecoderTest.java
deleted file mode 100644
index 72304c6b926..00000000000
--- a/netty/src/test/java/io/grpc/netty/GrpcHttp2HeadersDecoderTest.java
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.netty;
-
-import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE;
-import static io.netty.util.AsciiString.of;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertThat;
-
-import io.grpc.netty.GrpcHttp2HeadersDecoder.GrpcHttp2ClientHeadersDecoder;
-import io.grpc.netty.GrpcHttp2HeadersDecoder.GrpcHttp2ServerHeadersDecoder;
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.Unpooled;
-import io.netty.handler.codec.http2.DefaultHttp2Headers;
-import io.netty.handler.codec.http2.DefaultHttp2HeadersEncoder;
-import io.netty.handler.codec.http2.Http2Exception;
-import io.netty.handler.codec.http2.Http2Headers;
-import io.netty.handler.codec.http2.Http2HeadersDecoder;
-import io.netty.handler.codec.http2.Http2HeadersEncoder;
-import io.netty.handler.codec.http2.Http2HeadersEncoder.SensitivityDetector;
-import org.junit.After;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Tests for {@link GrpcHttp2HeadersDecoder}.
- */
-@RunWith(JUnit4.class)
-public class GrpcHttp2HeadersDecoderTest {
-
-  private static final SensitivityDetector NEVER_SENSITIVE = new SensitivityDetector() {
-    @Override
-    public boolean isSensitive(CharSequence name, CharSequence value) {
-      return false;
-    }
-  };
-
-  private ByteBuf encodedHeaders;
-
-  @After
-  public void tearDown() {
-    if (encodedHeaders != null) {
-      encodedHeaders.release();
-    }
-  }
-
-  @Test
-  public void decode_requestHeaders() throws Http2Exception {
-    Http2HeadersDecoder decoder = new GrpcHttp2ServerHeadersDecoder(DEFAULT_MAX_HEADER_LIST_SIZE);
-    Http2HeadersEncoder encoder =
-        new DefaultHttp2HeadersEncoder(NEVER_SENSITIVE);
-
-    Http2Headers headers = new DefaultHttp2Headers(false);
-    headers.add(of(":scheme"), of("https")).add(of(":method"), of("GET"))
-        .add(of(":path"), of("index.html")).add(of(":authority"), of("foo.grpc.io"))
-        .add(of("custom"), of("header"));
-    encodedHeaders = Unpooled.buffer();
-    encoder.encodeHeaders(1 /* randomly chosen */, headers, encodedHeaders);
-
-    Http2Headers decodedHeaders = decoder.decodeHeaders(3 /* randomly chosen */, encodedHeaders);
-    assertEquals(headers.get(of(":scheme")), decodedHeaders.scheme());
-    assertEquals(headers.get(of(":method")), decodedHeaders.method());
-    assertEquals(headers.get(of(":path")), decodedHeaders.path());
-    assertEquals(headers.get(of(":authority")), decodedHeaders.authority());
-    assertEquals(headers.get(of("custom")), decodedHeaders.get(of("custom")));
-    assertEquals(headers.size(), decodedHeaders.size());
-
-    String toString = decodedHeaders.toString();
-    assertContainsKeyAndValue(toString, ":scheme", decodedHeaders.scheme());
-    assertContainsKeyAndValue(toString, ":method", decodedHeaders.method());
-    assertContainsKeyAndValue(toString, ":path", decodedHeaders.path());
-    assertContainsKeyAndValue(toString, ":authority", decodedHeaders.authority());
-    assertContainsKeyAndValue(toString, "custom", decodedHeaders.get(of("custom")));
-  }
-
-  @Test
-  public void decode_responseHeaders() throws Http2Exception {
-    Http2HeadersDecoder decoder = new GrpcHttp2ClientHeadersDecoder(DEFAULT_MAX_HEADER_LIST_SIZE);
-    Http2HeadersEncoder encoder =
-        new DefaultHttp2HeadersEncoder(NEVER_SENSITIVE);
-
-    Http2Headers headers = new DefaultHttp2Headers(false);
-    headers.add(of(":status"), of("200")).add(of("custom"), of("header"));
-    encodedHeaders = Unpooled.buffer();
-    encoder.encodeHeaders(1 /* randomly chosen */, headers, encodedHeaders);
-
-    Http2Headers decodedHeaders = decoder.decodeHeaders(3 /* randomly chosen */, encodedHeaders);
-    assertEquals(headers.get(of(":status")), decodedHeaders.get(of(":status")));
-    assertEquals(headers.get(of("custom")), decodedHeaders.get(of("custom")));
-    assertEquals(headers.size(), decodedHeaders.size());
-
-    String toString = decodedHeaders.toString();
-    assertContainsKeyAndValue(toString, ":status", decodedHeaders.get(of(":status")));
-    assertContainsKeyAndValue(toString, "custom", decodedHeaders.get(of("custom")));
-  }
-
-  @Test
-  public void decode_emptyHeaders() throws Http2Exception {
-    Http2HeadersDecoder decoder = new GrpcHttp2ClientHeadersDecoder(8192);
-    Http2HeadersEncoder encoder =
-        new DefaultHttp2HeadersEncoder(NEVER_SENSITIVE);
-
-    ByteBuf encodedHeaders = Unpooled.buffer();
-    encoder.encodeHeaders(1 /* randomly chosen */, new DefaultHttp2Headers(false), encodedHeaders);
-
-    Http2Headers decodedHeaders = decoder.decodeHeaders(3 /* randomly chosen */, encodedHeaders);
-    assertEquals(0, decodedHeaders.size());
-    assertThat(decodedHeaders.toString(), containsString("[]"));
-  }
-
-  private static void assertContainsKeyAndValue(String str, CharSequence key, CharSequence value) {
-    assertThat(str, containsString(key.toString()));
-    assertThat(str, containsString(value.toString()));
-  }
-}
diff --git a/netty/src/test/java/io/grpc/netty/GrpcHttp2HeadersUtilsTest.java b/netty/src/test/java/io/grpc/netty/GrpcHttp2HeadersUtilsTest.java
new file mode 100644
index 00000000000..653b44a9d2d
--- /dev/null
+++ b/netty/src/test/java/io/grpc/netty/GrpcHttp2HeadersUtilsTest.java
@@ -0,0 +1,382 @@
+/*
+ * Copyright 2016 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.netty;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.Metadata.BINARY_BYTE_MARSHALLER;
+import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE;
+import static io.netty.util.AsciiString.of;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.Iterables;
+import com.google.common.io.BaseEncoding;
+import io.grpc.Metadata;
+import io.grpc.Metadata.Key;
+import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2ClientHeadersDecoder;
+import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2RequestHeaders;
+import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2ServerHeadersDecoder;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import io.netty.handler.codec.http2.DefaultHttp2Headers;
+import io.netty.handler.codec.http2.DefaultHttp2HeadersEncoder;
+import io.netty.handler.codec.http2.Http2Exception;
+import io.netty.handler.codec.http2.Http2Headers;
+import io.netty.handler.codec.http2.Http2HeadersDecoder;
+import io.netty.handler.codec.http2.Http2HeadersEncoder;
+import io.netty.handler.codec.http2.Http2HeadersEncoder.SensitivityDetector;
+import io.netty.util.AsciiString;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Map;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link GrpcHttp2HeadersUtils}.
+ */
+@RunWith(JUnit4.class)
+@SuppressWarnings({ "BadImport", "UndefinedEquals" }) // AsciiString.of and AsciiString.equals
+public class GrpcHttp2HeadersUtilsTest {
+
+  private static final SensitivityDetector NEVER_SENSITIVE = new SensitivityDetector() {
+    @Override
+    public boolean isSensitive(CharSequence name, CharSequence value) {
+      return false;
+    }
+  };
+
+  private ByteBuf encodedHeaders;
+
+  @After
+  public void tearDown() {
+    if (encodedHeaders != null) {
+      encodedHeaders.release();
+    }
+  }
+
+  @Test
+  public void decode_requestHeaders() throws Http2Exception {
+    Http2HeadersDecoder decoder = new GrpcHttp2ServerHeadersDecoder(DEFAULT_MAX_HEADER_LIST_SIZE);
+    Http2HeadersEncoder encoder =
+        new DefaultHttp2HeadersEncoder(NEVER_SENSITIVE);
+
+    Http2Headers headers = new DefaultHttp2Headers(false);
+    headers.add(of(":scheme"), of("https")).add(of(":method"), of("GET"))
+        .add(of(":path"), of("index.html")).add(of(":authority"), of("foo.grpc.io"))
+        .add(of("custom"), of("header"));
+    encodedHeaders = Unpooled.buffer();
+    encoder.encodeHeaders(1 /* randomly chosen */, headers, encodedHeaders);
+
+    Http2Headers decodedHeaders = decoder.decodeHeaders(3 /* randomly chosen */, encodedHeaders);
+    assertEquals(headers.get(of(":scheme")), decodedHeaders.scheme());
+    assertEquals(headers.get(of(":method")), decodedHeaders.method());
+    assertEquals(headers.get(of(":path")), decodedHeaders.path());
+    assertEquals(headers.get(of(":authority")), decodedHeaders.authority());
+    assertEquals(headers.get(of("custom")), decodedHeaders.get(of("custom")));
+    assertEquals(headers.size(), decodedHeaders.size());
+
+    String toString = decodedHeaders.toString();
+    assertContainsKeyAndValue(toString, ":scheme", decodedHeaders.scheme());
+    assertContainsKeyAndValue(toString, ":method", decodedHeaders.method());
+    assertContainsKeyAndValue(toString, ":path", decodedHeaders.path());
+    assertContainsKeyAndValue(toString, ":authority", decodedHeaders.authority());
+    assertContainsKeyAndValue(toString, "custom", decodedHeaders.get(of("custom")));
+  }
+
+  @Test
+  public void decode_responseHeaders() throws Http2Exception {
+    Http2HeadersDecoder decoder = new GrpcHttp2ClientHeadersDecoder(DEFAULT_MAX_HEADER_LIST_SIZE);
+    Http2HeadersEncoder encoder =
+        new DefaultHttp2HeadersEncoder(NEVER_SENSITIVE);
+
+    Http2Headers headers = new DefaultHttp2Headers(false);
+    headers.add(of(":status"), of("200")).add(of("custom"), of("header"));
+    encodedHeaders = Unpooled.buffer();
+    encoder.encodeHeaders(1 /* randomly chosen */, headers, encodedHeaders);
+
+    Http2Headers decodedHeaders = decoder.decodeHeaders(3 /* randomly chosen */, encodedHeaders);
+    assertEquals(headers.get(of(":status")), decodedHeaders.get(of(":status")));
+    assertEquals(headers.get(of("custom")), decodedHeaders.get(of("custom")));
+    assertEquals(headers.size(), decodedHeaders.size());
+
+    String toString = decodedHeaders.toString();
+    assertContainsKeyAndValue(toString, ":status", decodedHeaders.get(of(":status")));
+    assertContainsKeyAndValue(toString, "custom", decodedHeaders.get(of("custom")));
+  }
+
+  @Test
+  public void decode_emptyHeaders() throws Http2Exception {
+    Http2HeadersDecoder decoder = new GrpcHttp2ClientHeadersDecoder(8192);
+    Http2HeadersEncoder encoder =
+        new DefaultHttp2HeadersEncoder(NEVER_SENSITIVE);
+
+    ByteBuf encodedHeaders = Unpooled.buffer();
+    encoder.encodeHeaders(1 /* randomly chosen */, new DefaultHttp2Headers(false), encodedHeaders);
+
+    Http2Headers decodedHeaders = decoder.decodeHeaders(3 /* randomly chosen */, encodedHeaders);
+    assertEquals(0, decodedHeaders.size());
+    assertThat(decodedHeaders.toString()).contains("[]");
+  }
+
+  // contains() is used by Netty 4.1.75+. https://github.com/grpc/grpc-java/issues/8981
+  // Just implement everything pseudo headers for all methods; too many recent breakages.
+  @Test
+  public void grpcHttp2RequestHeaders_pseudoHeaders_notPresent() {
+    Http2Headers http2Headers = new GrpcHttp2RequestHeaders(2);
+    assertThat(http2Headers.get(AsciiString.of(":path"))).isNull();
+    assertThat(http2Headers.get(AsciiString.of(":authority"))).isNull();
+    assertThat(http2Headers.get(AsciiString.of(":method"))).isNull();
+    assertThat(http2Headers.get(AsciiString.of(":scheme"))).isNull();
+    assertThat(http2Headers.get(AsciiString.of(":status"))).isNull();
+
+    assertThat(http2Headers.getAll(AsciiString.of(":path"))).isEmpty();
+    assertThat(http2Headers.getAll(AsciiString.of(":authority"))).isEmpty();
+    assertThat(http2Headers.getAll(AsciiString.of(":method"))).isEmpty();
+    assertThat(http2Headers.getAll(AsciiString.of(":scheme"))).isEmpty();
+    assertThat(http2Headers.getAll(AsciiString.of(":status"))).isEmpty();
+
+    assertThat(http2Headers.contains(AsciiString.of(":path"))).isFalse();
+    assertThat(http2Headers.contains(AsciiString.of(":authority"))).isFalse();
+    assertThat(http2Headers.contains(AsciiString.of(":method"))).isFalse();
+    assertThat(http2Headers.contains(AsciiString.of(":scheme"))).isFalse();
+    assertThat(http2Headers.contains(AsciiString.of(":status"))).isFalse();
+
+    assertThat(http2Headers.remove(AsciiString.of(":path"))).isFalse();
+    assertThat(http2Headers.remove(AsciiString.of(":authority"))).isFalse();
+    assertThat(http2Headers.remove(AsciiString.of(":method"))).isFalse();
+    assertThat(http2Headers.remove(AsciiString.of(":scheme"))).isFalse();
+    assertThat(http2Headers.remove(AsciiString.of(":status"))).isFalse();
+  }
+
+  @Test
+  public void grpcHttp2RequestHeaders_pseudoHeaders_present() {
+    Http2Headers http2Headers = new GrpcHttp2RequestHeaders(2);
+    http2Headers.add(AsciiString.of(":path"), AsciiString.of("mypath"));
+    http2Headers.add(AsciiString.of(":authority"), AsciiString.of("myauthority"));
+    http2Headers.add(AsciiString.of(":method"), AsciiString.of("mymethod"));
+    http2Headers.add(AsciiString.of(":scheme"), AsciiString.of("myscheme"));
+
+    assertThat(http2Headers.get(AsciiString.of(":path"))).isEqualTo(AsciiString.of("mypath"));
+    assertThat(http2Headers.get(AsciiString.of(":authority")))
+        .isEqualTo(AsciiString.of("myauthority"));
+    assertThat(http2Headers.get(AsciiString.of(":method"))).isEqualTo(AsciiString.of("mymethod"));
+    assertThat(http2Headers.get(AsciiString.of(":scheme"))).isEqualTo(AsciiString.of("myscheme"));
+
+    assertThat(http2Headers.getAll(AsciiString.of(":path")))
+        .containsExactly(AsciiString.of("mypath"));
+    assertThat(http2Headers.getAll(AsciiString.of(":authority")))
+        .containsExactly(AsciiString.of("myauthority"));
+    assertThat(http2Headers.getAll(AsciiString.of(":method")))
+        .containsExactly(AsciiString.of("mymethod"));
+    assertThat(http2Headers.getAll(AsciiString.of(":scheme")))
+        .containsExactly(AsciiString.of("myscheme"));
+
+    assertThat(http2Headers.contains(AsciiString.of(":path"))).isTrue();
+    assertThat(http2Headers.contains(AsciiString.of(":authority"))).isTrue();
+    assertThat(http2Headers.contains(AsciiString.of(":method"))).isTrue();
+    assertThat(http2Headers.contains(AsciiString.of(":scheme"))).isTrue();
+
+    assertThat(http2Headers.remove(AsciiString.of(":path"))).isTrue();
+    assertThat(http2Headers.remove(AsciiString.of(":authority"))).isTrue();
+    assertThat(http2Headers.remove(AsciiString.of(":method"))).isTrue();
+    assertThat(http2Headers.remove(AsciiString.of(":scheme"))).isTrue();
+
+    assertThat(http2Headers.contains(AsciiString.of(":path"))).isFalse();
+    assertThat(http2Headers.contains(AsciiString.of(":authority"))).isFalse();
+    assertThat(http2Headers.contains(AsciiString.of(":method"))).isFalse();
+    assertThat(http2Headers.contains(AsciiString.of(":scheme"))).isFalse();
+  }
+
+  @Test
+  public void grpcHttp2RequestHeaders_pseudoHeaders_set() {
+    Http2Headers http2Headers = new GrpcHttp2RequestHeaders(2);
+    http2Headers.set(AsciiString.of(":path"), AsciiString.of("mypath"));
+    http2Headers.set(AsciiString.of(":authority"), AsciiString.of("myauthority"));
+    http2Headers.set(AsciiString.of(":method"), AsciiString.of("mymethod"));
+    http2Headers.set(AsciiString.of(":scheme"), AsciiString.of("myscheme"));
+
+    assertThat(http2Headers.getAll(AsciiString.of(":path")))
+        .containsExactly(AsciiString.of("mypath"));
+    assertThat(http2Headers.getAll(AsciiString.of(":authority")))
+        .containsExactly(AsciiString.of("myauthority"));
+    assertThat(http2Headers.getAll(AsciiString.of(":method")))
+        .containsExactly(AsciiString.of("mymethod"));
+    assertThat(http2Headers.getAll(AsciiString.of(":scheme")))
+        .containsExactly(AsciiString.of("myscheme"));
+
+    http2Headers.set(AsciiString.of(":path"), AsciiString.of("mypath2"));
+    http2Headers.set(AsciiString.of(":authority"), AsciiString.of("myauthority2"));
+    http2Headers.set(AsciiString.of(":method"), AsciiString.of("mymethod2"));
+    http2Headers.set(AsciiString.of(":scheme"), AsciiString.of("myscheme2"));
+
+    assertThat(http2Headers.getAll(AsciiString.of(":path")))
+        .containsExactly(AsciiString.of("mypath2"));
+    assertThat(http2Headers.getAll(AsciiString.of(":authority")))
+        .containsExactly(AsciiString.of("myauthority2"));
+    assertThat(http2Headers.getAll(AsciiString.of(":method")))
+        .containsExactly(AsciiString.of("mymethod2"));
+    assertThat(http2Headers.getAll(AsciiString.of(":scheme")))
+        .containsExactly(AsciiString.of("myscheme2"));
+  }
+
+  @Test
+  public void grpcHttp2RequestHeaders_pseudoHeaders_addWhenPresent_throws() {
+    Http2Headers http2Headers = new GrpcHttp2RequestHeaders(2);
+    http2Headers.add(AsciiString.of(":path"), AsciiString.of("mypath"));
+    try {
+      http2Headers.add(AsciiString.of(":path"), AsciiString.of("mypath2"));
+      fail("Expected exception");
+    } catch (Exception ex) {
+      // expected
+    }
+  }
+
+  @Test
+  public void grpcHttp2RequestHeaders_pseudoHeaders_addInvalid_throws() {
+    Http2Headers http2Headers = new GrpcHttp2RequestHeaders(2);
+    try {
+      http2Headers.add(AsciiString.of(":status"), AsciiString.of("mystatus"));
+      fail("Expected exception");
+    } catch (Exception ex) {
+      // expected
+    }
+  }
+
+  @Test
+  public void dupBinHeadersWithComma() {
+    Key<byte[]> key = Key.of("bytes-bin", BINARY_BYTE_MARSHALLER);
+    Http2Headers http2Headers = new GrpcHttp2RequestHeaders(2);
+    http2Headers.add(AsciiString.of("bytes-bin"), AsciiString.of("BaS,e6,,4+,padding=="));
+    http2Headers.add(AsciiString.of("bytes-bin"), AsciiString.of("more"));
+    http2Headers.add(AsciiString.of("bytes-bin"), AsciiString.of(""));
+    Metadata recoveredHeaders = Utils.convertHeaders(http2Headers);
+    byte[][] values = Iterables.toArray(recoveredHeaders.getAll(key), byte[].class);
+
+    assertTrue(Arrays.deepEquals(
+        new byte[][] {
+            BaseEncoding.base64().decode("BaS"),
+            BaseEncoding.base64().decode("e6"),
+            BaseEncoding.base64().decode(""),
+            BaseEncoding.base64().decode("4+"),
+            BaseEncoding.base64().decode("padding"),
+            BaseEncoding.base64().decode("more"),
+            BaseEncoding.base64().decode("")},
+        values));
+  }
+
+  @Test
+  public void headerGetAll_notPresent() {
+    Http2Headers http2Headers = new GrpcHttp2RequestHeaders(2);
+    http2Headers.add(AsciiString.of("notit"), AsciiString.of("val"));
+    assertThat(http2Headers.getAll(AsciiString.of("dont-care"))).isEmpty();
+  }
+
+  @Test
+  public void headerGetAll_multiplePresent() {
+    // getAll is used by Netty 4.1.60+. https://github.com/grpc/grpc-java/issues/7953
+    Http2Headers http2Headers = new GrpcHttp2RequestHeaders(2);
+    http2Headers.add(AsciiString.of("notit1"), AsciiString.of("val1"));
+    http2Headers.add(AsciiString.of("multiple"), AsciiString.of("value1"));
+    http2Headers.add(AsciiString.of("notit2"), AsciiString.of("val2"));
+    http2Headers.add(AsciiString.of("multiple"), AsciiString.of("value2"));
+    http2Headers.add(AsciiString.of("notit3"), AsciiString.of("val3"));
+    assertThat(http2Headers.size()).isEqualTo(5);
+    assertThat(http2Headers.getAll(AsciiString.of("multiple")))
+        .containsExactly(AsciiString.of("value1"), AsciiString.of("value2"));
+  }
+
+  @Test
+  public void headerIterator_empty() {
+    Http2Headers http2Headers = new GrpcHttp2RequestHeaders(2);
+    Iterator<Map.Entry<CharSequence, CharSequence>> it = http2Headers.iterator();
+    assertThat(it.hasNext()).isFalse();
+  }
+
+  @Test
+  public void headerIteartor_nonEmpty() {
+    Http2Headers http2Headers = new GrpcHttp2RequestHeaders(2);
+    http2Headers.add(AsciiString.of("notit1"), AsciiString.of("val1"));
+    http2Headers.add(AsciiString.of("multiple"), AsciiString.of("value1"));
+    http2Headers.add(AsciiString.of("notit2"), AsciiString.of("val2"));
+    http2Headers.add(AsciiString.of("multiple"), AsciiString.of("value2"));
+    http2Headers.add(AsciiString.of("notit3"), AsciiString.of("val3"));
+    Iterator<Map.Entry<CharSequence, CharSequence>> it = http2Headers.iterator();
+
+    assertNextEntry(it, "notit1", AsciiString.of("val1"));
+    assertNextEntry(it, "multiple", AsciiString.of("value1"));
+    assertNextEntry(it, "notit2", AsciiString.of("val2"));
+    assertNextEntry(it, "multiple", AsciiString.of("value2"));
+    assertNextEntry(it, "notit3", AsciiString.of("val3"));
+    assertThat(it.hasNext()).isFalse();
+  }
+
+  private static void assertNextEntry(
+      Iterator<Map.Entry<CharSequence, CharSequence>> it, CharSequence key, CharSequence value) {
+    Map.Entry<CharSequence, CharSequence> entry = it.next();
+    assertThat(entry.getKey()).isEqualTo(key);
+    assertThat(entry.getValue()).isEqualTo(value);
+  }
+
+  @Test
+  public void headerRemove_notPresent() {
+    Http2Headers http2Headers = new GrpcHttp2RequestHeaders(2);
+    http2Headers.add(AsciiString.of("dont-care"), AsciiString.of("value"));
+    assertThat(http2Headers.remove(AsciiString.of("not-seen"))).isFalse();
+    assertThat(http2Headers.size()).isEqualTo(1);
+    assertThat(http2Headers.getAll(AsciiString.of("dont-care")))
+        .containsExactly(AsciiString.of("value"));
+  }
+
+  @Test
+  public void headerRemove_multiplePresent() {
+    Http2Headers http2Headers = new GrpcHttp2RequestHeaders(2);
+    http2Headers.add(AsciiString.of("notit1"), AsciiString.of("val1"));
+    http2Headers.add(AsciiString.of("multiple"), AsciiString.of("value1"));
+    http2Headers.add(AsciiString.of("notit2"), AsciiString.of("val2"));
+    http2Headers.add(AsciiString.of("multiple"), AsciiString.of("value2"));
+    http2Headers.add(AsciiString.of("notit3"), AsciiString.of("val3"));
+    assertThat(http2Headers.remove(AsciiString.of("multiple"))).isTrue();
+    assertThat(http2Headers.size()).isEqualTo(3);
+    assertThat(http2Headers.getAll(AsciiString.of("notit1")))
+        .containsExactly(AsciiString.of("val1"));
+    assertThat(http2Headers.getAll(AsciiString.of("notit2")))
+        .containsExactly(AsciiString.of("val2"));
+    assertThat(http2Headers.getAll(AsciiString.of("notit3")))
+        .containsExactly(AsciiString.of("val3"));
+  }
+
+  @Test
+  public void headerSetLong() {
+    // setLong is used by Netty 4.1.60+. https://github.com/grpc/grpc-java/issues/7953
+    Http2Headers http2Headers = new GrpcHttp2RequestHeaders(2);
+    http2Headers.add(AsciiString.of("long-header"), AsciiString.of("1"));
+    http2Headers.add(AsciiString.of("long-header"), AsciiString.of("2"));
+    http2Headers.setLong(AsciiString.of("long-header"), 3);
+    assertThat(http2Headers.size()).isEqualTo(1);
+    assertThat(http2Headers.getAll(AsciiString.of("long-header")))
+        .containsExactly(AsciiString.of("3"));
+  }
+
+  private static void assertContainsKeyAndValue(String str, CharSequence key, CharSequence value) {
+    assertThat(str).contains(key.toString());
+    assertThat(str).contains(value.toString());
+  }
+}
diff --git a/netty/src/test/java/io/grpc/netty/GrpcHttp2InboundHeadersTest.java b/netty/src/test/java/io/grpc/netty/GrpcHttp2InboundHeadersTest.java
index 971c23a9359..62c2012895a 100644
--- a/netty/src/test/java/io/grpc/netty/GrpcHttp2InboundHeadersTest.java
+++ b/netty/src/test/java/io/grpc/netty/GrpcHttp2InboundHeadersTest.java
@@ -1,45 +1,30 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import static io.grpc.InternalMetadata.BASE64_ENCODING_OMIT_PADDING;
 import static io.netty.util.AsciiString.of;
 import static junit.framework.TestCase.assertNotSame;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 
-import com.google.common.io.BaseEncoding;
-import io.grpc.netty.GrpcHttp2HeadersDecoder.GrpcHttp2InboundHeaders;
-import io.grpc.netty.GrpcHttp2HeadersDecoder.GrpcHttp2RequestHeaders;
-import io.grpc.netty.GrpcHttp2HeadersDecoder.GrpcHttp2ResponseHeaders;
+import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2InboundHeaders;
+import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2RequestHeaders;
+import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2ResponseHeaders;
 import io.netty.handler.codec.http2.Http2Headers;
 import io.netty.util.AsciiString;
 import java.util.Random;
@@ -51,6 +36,7 @@
  * Tests for {@link GrpcHttp2RequestHeaders} and {@link GrpcHttp2ResponseHeaders}.
  */
 @RunWith(JUnit4.class)
+@SuppressWarnings({ "BadImport", "UndefinedEquals" }) // AsciiString.of and AsciiString.equals
 public class GrpcHttp2InboundHeadersTest {
 
   @Test
@@ -83,7 +69,7 @@ public void binaryHeadersShouldBeBase64Decoded() {
 
     byte[] data = new byte[100];
     new Random().nextBytes(data);
-    headers.add(of("foo-bin"), of(BaseEncoding.base64().encode(data)));
+    headers.add(of("foo-bin"), of(BASE64_ENCODING_OMIT_PADDING.encode(data)));
 
     assertEquals(1, headers.size());
 
diff --git a/netty/src/test/java/io/grpc/netty/GrpcSslContextsTest.java b/netty/src/test/java/io/grpc/netty/GrpcSslContextsTest.java
deleted file mode 100644
index 52a6d23646d..00000000000
--- a/netty/src/test/java/io/grpc/netty/GrpcSslContextsTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.netty;
-
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link io.grpc.netty.GrpcSslContexts}. */
-@RunWith(JUnit4.class)
-public class GrpcSslContextsTest {
-  @Test public void selectApplicationProtocolConfig_grpcExp() {
-    assertTrue(
-        GrpcSslContexts.NEXT_PROTOCOL_VERSIONS.indexOf("grpc-exp") == -1
-            || GrpcSslContexts.NEXT_PROTOCOL_VERSIONS.indexOf("grpc-exp")
-                < GrpcSslContexts.NEXT_PROTOCOL_VERSIONS.indexOf("h2"));
-  }
-}
diff --git a/netty/src/test/java/io/grpc/netty/NettyAdaptiveCumulatorTest.java b/netty/src/test/java/io/grpc/netty/NettyAdaptiveCumulatorTest.java
new file mode 100644
index 00000000000..b19f247b5cf
--- /dev/null
+++ b/netty/src/test/java/io/grpc/netty/NettyAdaptiveCumulatorTest.java
@@ -0,0 +1,658 @@
+/*
+ * 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.netty;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static com.google.common.truth.TruthJUnit.assume;
+import static io.netty.util.CharsetUtil.US_ASCII;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.ByteBufUtil;
+import io.netty.buffer.CompositeByteBuf;
+import io.netty.buffer.PooledByteBufAllocator;
+import io.netty.buffer.UnpooledByteBufAllocator;
+import java.util.Collection;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Enclosed.class)
+public class NettyAdaptiveCumulatorTest {
+  private static boolean usingPre4_1_111_Netty() {
+    return false;  // Disabled detection because it was unreliable
+  }
+
+  private static Collection<Object[]> cartesianProductParams(List<?>... lists) {
+    return Lists.transform(Lists.cartesianProduct(lists), List::toArray);
+  }
+
+  @RunWith(JUnit4.class)
+  public static class CumulateTests {
+    // Represent data as immutable ASCII Strings for easy and readable ByteBuf equality assertions.
+    private static final String DATA_INITIAL = "0123";
+    private static final String DATA_INCOMING = "456789";
+    private static final String DATA_CUMULATED = "0123456789";
+
+    private static final ByteBufAllocator alloc = new UnpooledByteBufAllocator(false);
+    private NettyAdaptiveCumulator cumulator;
+    private NettyAdaptiveCumulator throwingCumulator;
+    private final UnsupportedOperationException throwingCumulatorError =
+        new UnsupportedOperationException();
+
+    // Buffers for testing
+    private final ByteBuf contiguous = ByteBufUtil.writeAscii(alloc, DATA_INITIAL);
+    private final ByteBuf in = ByteBufUtil.writeAscii(alloc, DATA_INCOMING);
+
+    @Before
+    public void setUp() {
+      cumulator = new NettyAdaptiveCumulator(0) {
+        @Override
+        void addInput(ByteBufAllocator alloc, CompositeByteBuf composite, ByteBuf in) {
+          // To limit the testing scope to NettyAdaptiveCumulator.cumulate(), always compose
+          composite.addFlattenedComponents(true, in);
+        }
+      };
+
+      // Throws an error on adding incoming buffer.
+      throwingCumulator = new NettyAdaptiveCumulator(0) {
+        @Override
+        void addInput(ByteBufAllocator alloc, CompositeByteBuf composite, ByteBuf in) {
+          throw throwingCumulatorError;
+        }
+      };
+    }
+
+    @Test
+    public void cumulate_notReadableCumulation_replacedWithInputAndReleased() {
+      contiguous.readerIndex(contiguous.writerIndex());
+      assertFalse(contiguous.isReadable());
+      ByteBuf cumulation = cumulator.cumulate(alloc, contiguous, in);
+      assertEquals(DATA_INCOMING, cumulation.toString(US_ASCII));
+      assertEquals(0, contiguous.refCnt());
+      // In retained by cumulation.
+      assertEquals(1, in.refCnt());
+      assertEquals(1, cumulation.refCnt());
+      cumulation.release();
+    }
+
+    @Test
+    public void cumulate_contiguousCumulation_newCompositeFromContiguousAndInput() {
+      CompositeByteBuf cumulation = (CompositeByteBuf) cumulator.cumulate(alloc, contiguous, in);
+      assertEquals(DATA_INITIAL, cumulation.component(0).toString(US_ASCII));
+      assertEquals(DATA_INCOMING, cumulation.component(1).toString(US_ASCII));
+      assertEquals(DATA_CUMULATED, cumulation.toString(US_ASCII));
+      // Both in and contiguous are retained by cumulation.
+      assertEquals(1, contiguous.refCnt());
+      assertEquals(1, in.refCnt());
+      assertEquals(1, cumulation.refCnt());
+      cumulation.release();
+    }
+
+    @Test
+    public void cumulate_compositeCumulation_inputAppendedAsANewComponent() {
+      CompositeByteBuf composite = alloc.compositeBuffer().addFlattenedComponents(true, contiguous);
+      assertSame(composite, cumulator.cumulate(alloc, composite, in));
+      assertEquals(DATA_INITIAL, composite.component(0).toString(US_ASCII));
+      assertEquals(DATA_INCOMING, composite.component(1).toString(US_ASCII));
+      assertEquals(DATA_CUMULATED, composite.toString(US_ASCII));
+      // Both in and contiguous are retained by cumulation.
+      assertEquals(1, contiguous.refCnt());
+      assertEquals(1, in.refCnt());
+      assertEquals(1, composite.refCnt());
+      composite.release();
+    }
+
+    @Test
+    public void cumulate_compositeCumulation_inputReleasedOnError() {
+      CompositeByteBuf composite = alloc.compositeBuffer().addFlattenedComponents(true, contiguous);
+      try {
+        throwingCumulator.cumulate(alloc, composite, in);
+        fail("Cumulator didn't throw");
+      } catch (UnsupportedOperationException actualError) {
+        assertSame(throwingCumulatorError, actualError);
+        // Input must be released unless its ownership has been to the composite cumulation.
+        assertEquals(0, in.refCnt());
+        // Initial composite cumulation owned by the caller in this case, so it isn't released.
+        assertEquals(1, composite.refCnt());
+        // Contiguous still managed by the cumulation
+        assertEquals(1, contiguous.refCnt());
+      } finally {
+        composite.release();
+      }
+    }
+
+    @Test
+    public void cumulate_contiguousCumulation_inputAndNewCompositeReleasedOnError() {
+      // Return our instance of new composite to ensure it's released.
+      CompositeByteBuf newComposite = alloc.compositeBuffer(Integer.MAX_VALUE);
+      ByteBufAllocator mockAlloc = mock(ByteBufAllocator.class);
+      when(mockAlloc.compositeBuffer(anyInt())).thenReturn(newComposite);
+
+      try {
+        // Previous cumulation is non-composite, so cumulator will create anew composite and add
+        // both buffers to it.
+        throwingCumulator.cumulate(mockAlloc, contiguous, in);
+        fail("Cumulator didn't throw");
+      } catch (UnsupportedOperationException actualError) {
+        assertSame(throwingCumulatorError, actualError);
+        // Input must be released unless its ownership has been to the composite cumulation.
+        assertEquals(0, in.refCnt());
+        // New composite cumulation hasn't been returned to the caller, so it must be released.
+        assertEquals(0, newComposite.refCnt());
+        // Previous cumulation released because it was owned by the new composite cumulation.
+        assertEquals(0, contiguous.refCnt());
+      }
+    }
+  }
+
+  @RunWith(Parameterized.class)
+  public static class ShouldComposeTests {
+    // Represent data as immutable ASCII Strings for easy and readable ByteBuf equality assertions.
+    private static final String DATA_INITIAL = "0123";
+    private static final String DATA_INCOMING = "456789";
+
+    /**
+     * Cartesian product of the test values.
+     */
+    @Parameters(name = "composeMinSize={0}, tailData=\"{1}\", inData=\"{2}\"")
+    public static Collection<Object[]> params() {
+      List<?> composeMinSize = ImmutableList.of(0, 9, 10, 11, Integer.MAX_VALUE);
+      List<?> tailData = ImmutableList.of("", DATA_INITIAL);
+      List<?> inData = ImmutableList.of("", DATA_INCOMING);
+      return cartesianProductParams(composeMinSize, tailData, inData);
+    }
+
+    @Parameter public int composeMinSize;
+    @Parameter(1) public String tailData;
+    @Parameter(2) public String inData;
+
+    private CompositeByteBuf composite;
+    private ByteBuf tail;
+    private ByteBuf in;
+
+    @Before
+    public void setUp() {
+      ByteBufAllocator alloc = new UnpooledByteBufAllocator(false);
+      in = ByteBufUtil.writeAscii(alloc, inData);
+      tail = ByteBufUtil.writeAscii(alloc, tailData);
+      composite = alloc.compositeBuffer(Integer.MAX_VALUE);
+      // Note that addFlattenedComponents() will not add a new component when tail is not readable.
+      composite.addFlattenedComponents(true, tail);
+    }
+
+    @After
+    public void tearDown() {
+      in.release();
+      composite.release();
+    }
+
+    @Test
+    public void shouldCompose_emptyComposite() {
+      assume().that(composite.numComponents()).isEqualTo(0);
+      assertTrue(NettyAdaptiveCumulator.shouldCompose(composite, in, composeMinSize));
+    }
+
+    @Test
+    public void shouldCompose_composeMinSizeReached() {
+      assume().that(composite.numComponents()).isGreaterThan(0);
+      assume().that(tail.readableBytes() + in.readableBytes()).isAtLeast(composeMinSize);
+      assertTrue(NettyAdaptiveCumulator.shouldCompose(composite, in, composeMinSize));
+    }
+
+    @Test
+    public void shouldCompose_composeMinSizeNotReached() {
+      assume().that(composite.numComponents()).isGreaterThan(0);
+      assume().that(tail.readableBytes() + in.readableBytes()).isLessThan(composeMinSize);
+      assertFalse(NettyAdaptiveCumulator.shouldCompose(composite, in, composeMinSize));
+    }
+  }
+
+  @RunWith(Parameterized.class)
+  public static class MergeWithCompositeTailTests {
+    private static final String INCOMING_DATA_READABLE = "+incoming";
+    private static final String INCOMING_DATA_DISCARDABLE = "discard";
+
+    private static final String TAIL_DATA_DISCARDABLE = "---";
+    private static final String TAIL_DATA_READABLE = "tail";
+    private static final String TAIL_DATA =  TAIL_DATA_DISCARDABLE + TAIL_DATA_READABLE;
+    private static final int TAIL_READER_INDEX = TAIL_DATA_DISCARDABLE.length();
+    private static final int TAIL_MAX_CAPACITY = 128;
+
+    // DRY sacrificed to improve readability.
+    private static final String EXPECTED_TAIL_DATA = "tail+incoming";
+
+    /**
+     * Cartesian product of the test values.
+     *
+     * <p>Test cases when the cumulation contains components, other than tail, and could be
+     * partially read. This is needed to verify the correctness if reader and writer indexes of the
+     * composite cumulation after the merge.
+     */
+    @Parameters(name = "compositeHeadData=\"{0}\", compositeReaderIndex={1}")
+    public static Collection<Object[]> params() {
+      String headData = "head";
+
+      List<?> compositeHeadData = ImmutableList.of(
+          // Test without the "head" component. Empty string is equivalent of fully read buffer,
+          // so it's not added to the composite byte buf. The tail is added as the first component.
+          "",
+          // Test with the "head" component, so the tail is added as the second component.
+          headData
+      );
+
+      // After the tail is added to the composite cumulator, advance the reader index to
+      // cover different cases.
+      // The reader index only looks at what's readable in the composite byte buf, so
+      // discardable bytes of head and tail doesn't count.
+      List<?> compositeReaderIndex = ImmutableList.of(
+          // Reader in the beginning
+          0,
+          // Within the head (when present) or the tail
+          headData.length() - 2,
+          // Within the tail, even if the head is present
+          headData.length() + 2
+      );
+      return cartesianProductParams(compositeHeadData, compositeReaderIndex);
+    }
+
+    @Parameter public String compositeHeadData;
+    @Parameter(1) public int compositeReaderIndex;
+
+    // Use pooled allocator to have maxFastWritableBytes() behave differently than writableBytes().
+    private final ByteBufAllocator alloc = new PooledByteBufAllocator();
+
+    // Composite buffer to be used in tests.
+    private CompositeByteBuf composite;
+    private ByteBuf tail;
+    private ByteBuf in;
+
+    @Before
+    public void setUp() {
+      composite = alloc.compositeBuffer();
+
+      // The "head" component. It represents existing data in the cumulator.
+      // Note that addFlattenedComponents() does not add completely read buffer, which covers
+      // the case when compositeHeadData parameter is an empty string.
+      ByteBuf head = alloc.buffer().writeBytes(compositeHeadData.getBytes(US_ASCII));
+      composite.addFlattenedComponents(true, head);
+
+      // The "tail" component. It also represents existing data in the cumulator, but it's
+      // not added to the cumulator during setUp() stage. It is to be manipulated by tests to
+      // produce different buffer write scenarios based on different tail's capacity.
+      // After tail is changes for each test scenario, it's added to the composite buffer.
+      //
+      // The default state of the tail before each test: tail is full, but expandable (the data uses
+      // all initial capacity, but not maximum capacity).
+      // Tail data and indexes:
+      // ----tail
+      //     r   w
+      tail = alloc.buffer(TAIL_DATA.length(), TAIL_MAX_CAPACITY)
+          .writeBytes(TAIL_DATA.getBytes(US_ASCII))
+          .readerIndex(TAIL_READER_INDEX);
+
+      // Incoming data and indexes:
+      // discard+incoming
+      //        r        w
+      in = alloc.buffer()
+          .writeBytes(INCOMING_DATA_DISCARDABLE.getBytes(US_ASCII))
+          .writeBytes(INCOMING_DATA_READABLE.getBytes(US_ASCII))
+          .readerIndex(INCOMING_DATA_DISCARDABLE.length());
+    }
+
+    @After
+    public void tearDown() {
+      composite.release();
+    }
+
+    @Test
+    public void mergeWithCompositeTail_tailExpandable_write() {
+      // Make incoming data fit into tail capacity.
+      int fitCapacity = tail.capacity() + INCOMING_DATA_READABLE.length();
+      tail.capacity(fitCapacity);
+      // Confirm it fits.
+      assertThat(in.readableBytes()).isAtMost(tail.writableBytes());
+
+      // All fits, so tail capacity must stay the same.
+      composite.addFlattenedComponents(true, tail);
+      assertTailExpanded(EXPECTED_TAIL_DATA, fitCapacity);
+    }
+
+    @Test
+    public void mergeWithCompositeTail_tailExpandable_fastWrite() {
+      // Confirm that the tail can be expanded fast to fit the incoming data.
+      assertThat(in.readableBytes()).isAtMost(tail.maxFastWritableBytes());
+
+      // To avoid undesirable buffer unwrapping, at the moment adaptive cumulator is set not
+      // apply fastWrite technique. Even when fast write is possible, it will fall back to
+      // reallocating a larger buffer.
+      // int tailFastCapacity = tail.writerIndex() + tail.maxFastWritableBytes();
+      int tailFastCapacity =
+          alloc.calculateNewCapacity(EXPECTED_TAIL_DATA.length(), Integer.MAX_VALUE);
+
+      // Tail capacity is extended to its fast capacity.
+      composite.addFlattenedComponents(true, tail);
+      assertTailExpanded(EXPECTED_TAIL_DATA, tailFastCapacity);
+    }
+
+    @Test
+    public void mergeWithCompositeTail_tailExpandable_reallocateInMemory() {
+      int tailFastCapacity = tail.writerIndex() + tail.maxFastWritableBytes();
+      @SuppressWarnings("InlineMeInliner") // Requires Java 11
+      String inSuffixOverFastBytes = Strings.repeat("a", tailFastCapacity + 1);
+      int newTailSize =  tail.readableBytes() + inSuffixOverFastBytes.length();
+      composite.addFlattenedComponents(true, tail);
+
+      // Make input larger than tailFastCapacity
+      in.writeCharSequence(inSuffixOverFastBytes, US_ASCII);
+      // Confirm that the tail can only fit incoming data via reallocation.
+      assertThat(in.readableBytes()).isGreaterThan(tail.maxFastWritableBytes());
+      assertThat(in.readableBytes()).isAtMost(tail.maxWritableBytes());
+
+      // Confirm the assumption that new capacity is produced by alloc.calculateNewCapacity().
+      int expectedTailCapacity = alloc.calculateNewCapacity(newTailSize, Integer.MAX_VALUE);
+      assertTailExpanded(EXPECTED_TAIL_DATA.concat(inSuffixOverFastBytes), expectedTailCapacity);
+    }
+
+    private void assertTailExpanded(String expectedTailReadableData, int expectedNewTailCapacity) {
+      assume().withMessage("Netty 4.1.111 doesn't work with NettyAdaptiveCumulator")
+          .that(usingPre4_1_111_Netty()).isTrue();
+      int originalNumComponents = composite.numComponents();
+
+      // Handle the case when reader index is beyond all readable bytes of the cumulation.
+      int compositeReaderIndexBounded = Math.min(compositeReaderIndex, composite.writerIndex());
+      composite.readerIndex(compositeReaderIndexBounded);
+
+      // Execute the merge logic.
+      NettyAdaptiveCumulator.mergeWithCompositeTail(alloc, composite, in);
+
+      // Composite component count shouldn't change.
+      assertWithMessage(
+          "When tail is expanded, the number of components in the cumulation must not change")
+          .that(composite.numComponents()).isEqualTo(originalNumComponents);
+
+      ByteBuf newTail = composite.component(composite.numComponents() - 1);
+
+      // Verify the readable part of the expanded tail:
+      // 1. Initial readable bytes of the tail not changed
+      // 2. Discardable bytes (0 < discardable < readerIndex) of the incoming buffer are discarded.
+      // 3. Readable bytes of the incoming buffer are fully read and appended to the tail.
+      assertEquals(expectedTailReadableData, newTail.toString(US_ASCII));
+      // Verify expanded capacity.
+      assertEquals(expectedNewTailCapacity, newTail.capacity());
+
+      // Discardable bytes (0 < discardable < readerIndex) of the tail are kept as is.
+      String newTailDataDiscardable = newTail.toString(0, newTail.readerIndex(), US_ASCII);
+      assertWithMessage("After tail expansion, its discardable bytes should be unchanged")
+          .that(newTailDataDiscardable).isEqualTo(TAIL_DATA_DISCARDABLE);
+
+      // Reader index must stay where it was
+      assertEquals(TAIL_READER_INDEX, newTail.readerIndex());
+      // Writer index at the end
+      assertEquals(TAIL_READER_INDEX + expectedTailReadableData.length(),
+          newTail.writerIndex());
+
+      // Verify resulting cumulation.
+      assertExpectedCumulation(newTail, expectedTailReadableData, compositeReaderIndexBounded);
+
+      // Verify incoming buffer.
+      assertWithMessage("Incoming buffer is fully read").that(in.isReadable()).isFalse();
+      assertWithMessage("Incoming buffer is released").that(in.refCnt()).isEqualTo(0);
+    }
+
+    @Test
+    public void mergeWithCompositeTail_tailNotExpandable_maxCapacityReached() {
+      // Fill in tail to the maxCapacity.
+      @SuppressWarnings("InlineMeInliner") // Requires Java 11
+      String tailSuffixFullCapacity = Strings.repeat("a", tail.maxWritableBytes());
+      tail.writeCharSequence(tailSuffixFullCapacity, US_ASCII);
+      composite.addFlattenedComponents(true, tail);
+      assertTailReplaced();
+    }
+
+    @Test
+    public void mergeWithCompositeTail_tailNotExpandable_shared() {
+      tail.retain();
+      composite.addFlattenedComponents(true, tail);
+      assertTailReplaced();
+      tail.release();
+    }
+
+    @Test
+    public void mergeWithCompositeTail_tailNotExpandable_readOnly() {
+      composite.addFlattenedComponents(true, tail.asReadOnly());
+      assertTailReplaced();
+    }
+
+    private void assertTailReplaced() {
+      int cumulationOriginalComponentsNum = composite.numComponents();
+      int taiOriginalRefCount = tail.refCnt();
+      String expectedTailReadable = tail.toString(US_ASCII) + in.toString(US_ASCII);
+      int expectedReallocatedTailCapacity = alloc
+          .calculateNewCapacity(expectedTailReadable.length(), Integer.MAX_VALUE);
+
+      int compositeReaderIndexBounded = Math.min(compositeReaderIndex, composite.writerIndex());
+      composite.readerIndex(compositeReaderIndexBounded);
+      NettyAdaptiveCumulator.mergeWithCompositeTail(alloc, composite, in);
+
+      // Composite component count shouldn't change.
+      assertEquals(cumulationOriginalComponentsNum, composite.numComponents());
+      ByteBuf replacedTail = composite.component(composite.numComponents() - 1);
+
+      // Verify the readable part of the expanded tail:
+      // 1. Discardable bytes (0 < discardable < readerIndex) of the tail are discarded.
+      // 2. Readable bytes of the tail are kept as is
+      // 3. Discardable bytes (0 < discardable < readerIndex) of the incoming buffer are discarded.
+      // 4. Readable bytes of the incoming buffer are fully read and appended to the tail.
+      assertEquals(0, in.readableBytes());
+      assertEquals(expectedTailReadable, replacedTail.toString(US_ASCII));
+
+      // Since tail discardable bytes are discarded, new reader index must be reset to 0.
+      assertEquals(0, replacedTail.readerIndex());
+      // And new writer index at the new data's length.
+      assertEquals(expectedTailReadable.length(), replacedTail.writerIndex());
+      // Verify the capacity of reallocated tail.
+      assertEquals(expectedReallocatedTailCapacity, replacedTail.capacity());
+
+      // Verify resulting cumulation.
+      assertExpectedCumulation(replacedTail, expectedTailReadable, compositeReaderIndexBounded);
+
+      // Verify incoming buffer.
+      assertWithMessage("Incoming buffer is fully read").that(in.isReadable()).isFalse();
+      assertWithMessage("Incoming buffer is released").that(in.refCnt()).isEqualTo(0);
+
+      // The old tail must be released once (have one less reference).
+      assertWithMessage("Replaced tail released once.")
+          .that(tail.refCnt()).isEqualTo(taiOriginalRefCount - 1);
+    }
+
+    private void assertExpectedCumulation(
+        ByteBuf newTail, String expectedTailReadable, int expectedReaderIndex) {
+      // Verify the readable part of the cumulation:
+      // 1. Readable composite head (initial) data
+      // 2. Readable part of the tail
+      // 3. Readable part of the incoming data
+      String expectedCumulationData =
+          compositeHeadData.concat(expectedTailReadable).substring(expectedReaderIndex);
+      assertEquals(expectedCumulationData, composite.toString(US_ASCII));
+
+      // Cumulation capacity includes:
+      // 1. Full composite head, including discardable bytes
+      // 2. Expanded tail readable bytes
+      int expectedCumulationCapacity = compositeHeadData.length() + expectedTailReadable.length();
+      assertEquals(expectedCumulationCapacity, composite.capacity());
+
+      // Composite Reader index must stay where it was.
+      assertEquals(expectedReaderIndex, composite.readerIndex());
+      // Composite writer index must be at the end.
+      assertEquals(expectedCumulationCapacity, composite.writerIndex());
+
+      // Composite cumulation is retained and owns the new tail.
+      assertEquals(1, composite.refCnt());
+      assertEquals(1, newTail.refCnt());
+    }
+
+    @Test
+    public void mergeWithCompositeTail_tailExpandable_mergedReleaseOnThrow() {
+      final UnsupportedOperationException expectedError = new UnsupportedOperationException();
+      CompositeByteBuf compositeThrows = new CompositeByteBuf(alloc, false, Integer.MAX_VALUE,
+          tail) {
+        @Override
+        public CompositeByteBuf addFlattenedComponents(boolean increaseWriterIndex,
+                                                       ByteBuf buffer) {
+          throw expectedError;
+        }
+      };
+
+      try {
+        NettyAdaptiveCumulator.mergeWithCompositeTail(alloc, compositeThrows, in);
+        in = null; // On success it would be released
+        fail("Cumulator didn't throw");
+      } catch (UnsupportedOperationException actualError) {
+        assertSame(expectedError, actualError);
+        // Because of error, ownership shouldn't have changed so should not have been released.
+        assertEquals(1, in.refCnt());
+        // Tail released
+        assertEquals(0, tail.refCnt());
+        // Composite cumulation is retained
+        assertEquals(1, compositeThrows.refCnt());
+        // Composite cumulation loses the tail
+        assertEquals(0, compositeThrows.numComponents());
+      } finally {
+        if (in != null) {
+          in.release();
+        }
+        compositeThrows.release();
+      }
+    }
+
+    @Test
+    public void mergeWithCompositeTail_tailNotExpandable_mergedReleaseOnThrow() {
+      final UnsupportedOperationException expectedError = new UnsupportedOperationException();
+      CompositeByteBuf compositeRo = new CompositeByteBuf(alloc, false, Integer.MAX_VALUE,
+          tail.asReadOnly()) {
+        @Override
+        public CompositeByteBuf addFlattenedComponents(boolean increaseWriterIndex,
+                                                       ByteBuf buffer) {
+          throw expectedError;
+        }
+      };
+
+      // Return our instance of the new buffer to ensure it's released.
+      int newTailSize = tail.readableBytes() + in.readableBytes();
+      ByteBuf newTail = alloc.buffer(alloc.calculateNewCapacity(newTailSize, Integer.MAX_VALUE));
+      ByteBufAllocator mockAlloc = mock(ByteBufAllocator.class);
+      when(mockAlloc.buffer(anyInt())).thenReturn(newTail);
+
+      try {
+        NettyAdaptiveCumulator.mergeWithCompositeTail(mockAlloc, compositeRo, in);
+        in = null; // On success it would be released
+        fail("Cumulator didn't throw");
+      } catch (UnsupportedOperationException actualError) {
+        assertSame(expectedError, actualError);
+        // Because of error, ownership shouldn't have changed so should not have been released.
+        assertEquals(1, in.refCnt());
+        // New buffer released
+        assertEquals(0, newTail.refCnt());
+        // Composite cumulation is retained
+        assertEquals(1, compositeRo.refCnt());
+        // Composite cumulation loses the tail
+        assertEquals(0, compositeRo.numComponents());
+      } finally {
+        if (in != null) {
+          in.release();
+        }
+        compositeRo.release();
+      }
+    }
+  }
+
+  /**
+   * Miscellaneous tests for {@link NettyAdaptiveCumulator#mergeWithCompositeTail} that don't
+   * fit into {@link MergeWithCompositeTailTests}, and require custom-crafted scenarios.
+   */
+  @RunWith(JUnit4.class)
+  public static class MergeWithCompositeTailMiscTests {
+    private final ByteBufAllocator alloc = new PooledByteBufAllocator();
+
+    /**
+     * Test the issue with {@link CompositeByteBuf#component(int)} returning a ByteBuf with
+     * the indexes out-of-sync with {@code CompositeByteBuf.Component} offsets.
+     */
+    @Test
+    public void mergeWithCompositeTail_outOfSyncComposite() {
+      NettyAdaptiveCumulator cumulator = new NettyAdaptiveCumulator(1024);
+
+      // Create underlying buffer spacious enough for the test data.
+      ByteBuf buf = alloc.buffer(32).writeBytes("---01234".getBytes(US_ASCII));
+
+      // Start with a regular cumulation and add the buf as the only component.
+      CompositeByteBuf composite1 = alloc.compositeBuffer(8).addFlattenedComponents(true, buf);
+      // Read composite1 buf to the beginning of the numbers.
+      assertThat(composite1.readCharSequence(3, US_ASCII).toString()).isEqualTo("---");
+
+      // Wrap composite1 into another cumulation. This is similar to
+      // what NettyAdaptiveCumulator.cumulate() does in the case the cumulation has refCnt != 1.
+      CompositeByteBuf composite2 =
+          alloc.compositeBuffer(8).addFlattenedComponents(true, composite1);
+      assertThat(composite2.toString(US_ASCII)).isEqualTo("01234");
+
+      assume().withMessage("Netty 4.1.111 doesn't work with NettyAdaptiveCumulator")
+          .that(usingPre4_1_111_Netty()).isTrue();
+
+      // The previous operation does not adjust the read indexes of the underlying buffers,
+      // only the internal Component offsets. When the cumulator attempts to append the input to
+      // the tail buffer, it extracts it from the cumulation, writes to it, and then adds it back.
+      // Because the readerIndex on the tail buffer is not adjusted during the read operation
+      // on the CompositeByteBuf, adding the tail back results in the discarded bytes of the tail
+      // to be added back to the cumulator as if they were never read.
+      //
+      // If the reader index of the tail is not manually corrected, the resulting
+      // cumulation will contain the discarded part of the tail: "---".
+      // If it's corrected, it will only contain the numbers.
+      CompositeByteBuf cumulation = (CompositeByteBuf) cumulator.cumulate(alloc, composite2,
+          ByteBufUtil.writeAscii(alloc, "56789"));
+      assertThat(cumulation.toString(US_ASCII)).isEqualTo("0123456789");
+
+      // Correctness check: we still have a single component, and this component is still the
+      // original underlying buffer.
+      assertThat(cumulation.numComponents()).isEqualTo(1);
+      // Replace '2' with '*', and '8' with '$'.
+      buf.setByte(5, '*').setByte(11, '$');
+      assertThat(cumulation.toString(US_ASCII)).isEqualTo("01*34567$9");
+    }
+  }
+}
diff --git a/netty/src/test/java/io/grpc/netty/NettyChannelBuilderTest.java b/netty/src/test/java/io/grpc/netty/NettyChannelBuilderTest.java
index f1871eb8677..95d54d13b82 100644
--- a/netty/src/test/java/io/grpc/netty/NettyChannelBuilderTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyChannelBuilderTest.java
@@ -1,78 +1,118 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.mock;
 
-import io.grpc.netty.InternalNettyChannelBuilder.OverrideAuthorityChecker;
-import io.grpc.netty.ProtocolNegotiators.TlsNegotiator;
+import io.grpc.ChannelCredentials;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.ClientTransportFactory.SwapChannelCredentialsResult;
+import io.grpc.netty.NettyTestUtil.TrackingObjectPoolForTest;
+import io.grpc.netty.ProtocolNegotiators.PlaintextProtocolNegotiatorClientFactory;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFactory;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.local.LocalAddress;
+import io.netty.channel.local.LocalChannel;
 import io.netty.handler.ssl.SslContext;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
+import java.util.concurrent.TimeUnit;
 import javax.net.ssl.SSLException;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
 @RunWith(JUnit4.class)
 public class NettyChannelBuilderTest {
 
-  @Rule public final ExpectedException thrown = ExpectedException.none();
   private final SslContext noSslContext = null;
 
+  private void shutdown(ManagedChannel mc) throws Exception {
+    mc.shutdownNow();
+    assertTrue(mc.awaitTermination(1, TimeUnit.SECONDS));
+  }
+
   @Test
-  public void overrideAllowsInvalidAuthority() {
-    NettyChannelBuilder builder = new NettyChannelBuilder(new SocketAddress(){});
-    InternalNettyChannelBuilder.overrideAuthorityChecker(builder, new OverrideAuthorityChecker() {
-      @Override
-      public String checkAuthority(String authority) {
-        return authority;
-      }
-    });
-    Object unused = builder.overrideAuthority("[invalidauthority")
-        .negotiationType(NegotiationType.PLAINTEXT)
-        .buildTransportFactory();
+  public void authorityIsReadable() throws Exception {
+    NettyChannelBuilder builder = NettyChannelBuilder.forAddress("original", 1234);
+
+    ManagedChannel b = builder.build();
+    try {
+      assertEquals("original:1234", b.authority());
+    } finally {
+      shutdown(b);
+    }
+  }
+
+  @Test
+  public void overrideAuthorityIsReadableForAddress() throws Exception {
+    NettyChannelBuilder builder = NettyChannelBuilder.forAddress("original", 1234);
+    overrideAuthorityIsReadableHelper(builder, "override:5678");
+  }
+
+  @Test
+  public void overrideAuthorityIsReadableForTarget() throws Exception {
+    NettyChannelBuilder builder = NettyChannelBuilder.forTarget("original:1234");
+    overrideAuthorityIsReadableHelper(builder, "override:5678");
+  }
+
+  private static SocketAddress getTestSocketAddress() {
+    return new InetSocketAddress("1.1.1.1", 80);
+  }
+
+  @Test
+  public void overrideAuthorityIsReadableForSocketAddress() throws Exception {
+    NettyChannelBuilder builder = NettyChannelBuilder.forAddress(
+        getTestSocketAddress());
+    overrideAuthorityIsReadableHelper(builder, "override:5678");
+  }
+
+  private void overrideAuthorityIsReadableHelper(NettyChannelBuilder builder,
+      String overrideAuthority) throws Exception {
+    builder.overrideAuthority(overrideAuthority);
+    ManagedChannel channel = builder.build();
+    try {
+      assertEquals(overrideAuthority, channel.authority());
+    } finally {
+      shutdown(channel);
+    }
   }
 
   @Test
   public void failOverrideInvalidAuthority() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid authority:");
+    NettyChannelBuilder builder = new NettyChannelBuilder(getTestSocketAddress());
+
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.overrideAuthority("[invalidauthority"));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid authority: [invalidauthority");
+  }
 
-    NettyChannelBuilder builder = new NettyChannelBuilder(new SocketAddress(){});
+  @Test
+  public void disableCheckAuthorityAllowsInvalidAuthority() {
+    NettyChannelBuilder builder = new NettyChannelBuilder(getTestSocketAddress())
+        .disableCheckAuthority();
 
     Object unused = builder.overrideAuthority("[invalidauthority")
         .negotiationType(NegotiationType.PLAINTEXT)
@@ -80,89 +120,211 @@ public void failOverrideInvalidAuthority() {
   }
 
   @Test
-  public void failInvalidAuthority() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid host or port");
+  public void enableCheckAuthorityFailOverrideInvalidAuthority() {
+    NettyChannelBuilder builder = new NettyChannelBuilder(getTestSocketAddress())
+        .disableCheckAuthority()
+        .enableCheckAuthority();
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.overrideAuthority("[invalidauthority"));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid authority: [invalidauthority");
+  }
 
-    NettyChannelBuilder.forAddress(new InetSocketAddress("invalid_authority", 1234));
+  @Test
+  public void failInvalidAuthority() {
+    @SuppressWarnings("AddressSelection") // We actually expect zero addresses!
+    InetSocketAddress address = new InetSocketAddress("invalid_authority", 1234);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> NettyChannelBuilder.forAddress(address));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid host or port: invalid_authority 1234");
   }
 
   @Test
   public void sslContextCanBeNull() {
-    NettyChannelBuilder builder = new NettyChannelBuilder(new SocketAddress(){});
+    NettyChannelBuilder builder = new NettyChannelBuilder(getTestSocketAddress());
     builder.sslContext(null);
   }
 
   @Test
   public void failIfSslContextIsNotClient() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Server SSL context can not be used for client channel");
-
     SslContext sslContext = mock(SslContext.class);
+    NettyChannelBuilder builder = new NettyChannelBuilder(getTestSocketAddress());
+
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.sslContext(sslContext));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Server SSL context can not be used for client channel");
+  }
+
+  @Test
+  public void failNegotiationTypeWithChannelCredentials_target() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forTarget(
+        "fakeTarget", InsecureChannelCredentials.create());
 
-    NettyChannelBuilder builder = new NettyChannelBuilder(new SocketAddress(){});
-    builder.sslContext(sslContext);
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        () -> builder.negotiationType(NegotiationType.TLS));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Cannot change security when using ChannelCredentials");
   }
 
   @Test
-  public void createProtocolNegotiator_plaintext() {
-    ProtocolNegotiator negotiator = NettyChannelBuilder.createProtocolNegotiator(
-        "authority",
+  public void failNegotiationTypeWithChannelCredentials_socketAddress() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forAddress(
+        getTestSocketAddress(), InsecureChannelCredentials.create());
+
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        () -> builder.negotiationType(NegotiationType.TLS));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Cannot change security when using ChannelCredentials");
+  }
+
+  @Test
+  public void createProtocolNegotiatorByType_plaintext() {
+    ProtocolNegotiator negotiator = NettyChannelBuilder.createProtocolNegotiatorByType(
         NegotiationType.PLAINTEXT,
-        noSslContext);
+        noSslContext, null);
     // just check that the classes are the same, and that negotiator is not null.
-    assertTrue(negotiator instanceof ProtocolNegotiators.PlaintextNegotiator);
+    assertTrue(negotiator instanceof ProtocolNegotiators.PlaintextProtocolNegotiator);
+    negotiator.close();
   }
 
   @Test
-  public void createProtocolNegotiator_plaintextUpgrade() {
-    ProtocolNegotiator negotiator = NettyChannelBuilder.createProtocolNegotiator(
-        "authority",
+  public void createProtocolNegotiatorByType_plaintextUpgrade() {
+    ProtocolNegotiator negotiator = NettyChannelBuilder.createProtocolNegotiatorByType(
         NegotiationType.PLAINTEXT_UPGRADE,
-        noSslContext);
+        noSslContext, null);
     // just check that the classes are the same, and that negotiator is not null.
-    assertTrue(negotiator instanceof ProtocolNegotiators.PlaintextUpgradeNegotiator);
+    assertTrue(negotiator instanceof ProtocolNegotiators.PlaintextUpgradeProtocolNegotiator);
+    negotiator.close();
+  }
+
+  @Test
+  public void createProtocolNegotiatorByType_tlsWithNoContext() {
+    assertThrows(NullPointerException.class,
+        () -> NettyChannelBuilder.createProtocolNegotiatorByType(
+            NegotiationType.TLS, noSslContext, null));
   }
 
   @Test
-  public void createProtocolNegotiator_tlsWithNoContext() {
-    ProtocolNegotiator negotiator = NettyChannelBuilder.createProtocolNegotiator(
-        "authority:1234",
+  public void createProtocolNegotiatorByType_tlsWithExecutor() throws Exception {
+    TrackingObjectPoolForTest executorPool = new TrackingObjectPoolForTest();
+    assertEquals(false, executorPool.isInUse());
+    SslContext localSslContext = GrpcSslContexts.forClient().build();
+    ProtocolNegotiator negotiator = NettyChannelBuilder.createProtocolNegotiatorByType(
         NegotiationType.TLS,
-        noSslContext);
+        localSslContext, executorPool);
+    assertEquals(true, executorPool.isInUse());
+    assertNotNull(negotiator);
+    negotiator.close();
+    assertEquals(false, executorPool.isInUse());
+  }
 
-    assertTrue(negotiator instanceof ProtocolNegotiators.TlsNegotiator);
-    ProtocolNegotiators.TlsNegotiator n = (TlsNegotiator) negotiator;
+  @Test
+  public void createProtocolNegotiatorByType_tlsWithClientContext() throws SSLException {
+    ProtocolNegotiators.HostPort hostPort = ProtocolNegotiators.parseAuthority("authority:1234");
 
-    assertEquals("authority", n.getHost());
-    assertEquals(1234, n.getPort());
+    assertEquals("authority", hostPort.host);
+    assertEquals(1234, hostPort.port);
   }
 
   @Test
-  public void createProtocolNegotiator_tlsWithClientContext() throws SSLException {
-    ProtocolNegotiator negotiator = NettyChannelBuilder.createProtocolNegotiator(
-        "authority:1234",
-        NegotiationType.TLS,
-        GrpcSslContexts.forClient().build());
+  public void createProtocolNegotiatorByType_tlsWithAuthorityFallback() throws SSLException {
+    ProtocolNegotiators.HostPort hostPort = ProtocolNegotiators.parseAuthority("bad_authority");
 
-    assertTrue(negotiator instanceof ProtocolNegotiators.TlsNegotiator);
-    ProtocolNegotiators.TlsNegotiator n = (TlsNegotiator) negotiator;
+    assertEquals("bad_authority", hostPort.host);
+    assertEquals(-1, hostPort.port);
+  }
+
+  @Test
+  public void negativeKeepAliveTime() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forTarget("fakeTarget");
 
-    assertEquals("authority", n.getHost());
-    assertEquals(1234, n.getPort());
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.keepAliveTime(-1L, TimeUnit.HOURS));
+    assertThat(e).hasMessageThat().isEqualTo("keepalive time must be positive");
   }
 
   @Test
-  public void createProtocolNegotiator_tlsWithAuthorityFallback() {
-    ProtocolNegotiator negotiator = NettyChannelBuilder.createProtocolNegotiator(
-        "bad_authority",
-        NegotiationType.TLS,
-        noSslContext);
+  public void negativeKeepAliveTimeout() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forTarget("fakeTarget");
+
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.keepAliveTimeout(-1L, TimeUnit.HOURS));
+    assertThat(e).hasMessageThat().isEqualTo("keepalive timeout must be positive");
+  }
+
+  @Test
+  public void assertEventLoopAndChannelType_onlyGroupProvided() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forTarget("fakeTarget");
+    builder.eventLoopGroup(mock(EventLoopGroup.class));
+
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        builder::assertEventLoopAndChannelType);
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Both EventLoopGroup and ChannelType should be provided or neither should be");
+  }
+
+  @Test
+  public void assertEventLoopAndChannelType_onlyTypeProvided() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forTarget("fakeTarget");
+    builder.channelType(LocalChannel.class, LocalAddress.class);
+
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        builder::assertEventLoopAndChannelType);
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Both EventLoopGroup and ChannelType should be provided or neither should be");
+  }
+
+  @Test
+  public void assertEventLoopAndChannelType_onlyFactoryProvided() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forTarget("fakeTarget");
+    builder.channelFactory(new ChannelFactory<Channel>() {
+      @Override
+      public Channel newChannel() {
+        return null;
+      }
+    });
+
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        builder::assertEventLoopAndChannelType);
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Both EventLoopGroup and ChannelType should be provided or neither should be");
+  }
+
+  @Test
+  public void assertEventLoopAndChannelType_usingDefault() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forTarget("fakeTarget");
+
+    builder.assertEventLoopAndChannelType();
+  }
+
+  @Test
+  public void assertEventLoopAndChannelType_bothProvided() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forTarget("fakeTarget");
+    builder.eventLoopGroup(mock(EventLoopGroup.class));
+    builder.channelType(LocalChannel.class, LocalAddress.class);
+
+    builder.assertEventLoopAndChannelType();
+  }
+
+  @Test
+  public void useNioTransport_shouldNotFallBack() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forTarget("fakeTarget");
+    InternalNettyChannelBuilder.useNioTransport(builder);
+
+    builder.assertEventLoopAndChannelType();
+  }
+
+  @Test
+  public void transportFactorySupportsNettyChannelCreds() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forTarget("foo");
+    ClientTransportFactory transportFactory = builder.buildTransportFactory();
 
-    assertTrue(negotiator instanceof ProtocolNegotiators.TlsNegotiator);
-    ProtocolNegotiators.TlsNegotiator n = (TlsNegotiator) negotiator;
+    SwapChannelCredentialsResult result = transportFactory.swapChannelCredentials(
+        mock(ChannelCredentials.class));
+    assertThat(result).isNull();
 
-    assertEquals("bad_authority", n.getHost());
-    assertEquals(-1, n.getPort());
+    result = transportFactory.swapChannelCredentials(
+        NettyChannelCredentials.create(new PlaintextProtocolNegotiatorClientFactory()));
+    assertThat(result).isNotNull();
   }
 }
diff --git a/netty/src/test/java/io/grpc/netty/NettyChannelCredentialsTest.java b/netty/src/test/java/io/grpc/netty/NettyChannelCredentialsTest.java
new file mode 100644
index 00000000000..33ad8212a67
--- /dev/null
+++ b/netty/src/test/java/io/grpc/netty/NettyChannelCredentialsTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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.netty;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.netty.ProtocolNegotiator.ClientFactory;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link NettyChannelCredentials}. */
+@RunWith(JUnit4.class)
+public class NettyChannelCredentialsTest {
+  @Test
+  public void withoutBearTokenGivesItself() {
+    ChannelCredentials nettyChannelCreds =
+        NettyChannelCredentials.create(mock(ClientFactory.class));
+    assertThat(nettyChannelCreds.withoutBearerTokens()).isEqualTo(nettyChannelCreds);
+  }
+}
diff --git a/netty/src/test/java/io/grpc/netty/NettyChannelProviderTest.java b/netty/src/test/java/io/grpc/netty/NettyChannelProviderTest.java
index dbd034b633e..86c1389f002 100644
--- a/netty/src/test/java/io/grpc/netty/NettyChannelProviderTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyChannelProviderTest.java
@@ -1,42 +1,32 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import io.grpc.InternalServiceProviders;
 import io.grpc.ManagedChannelProvider;
+import io.grpc.ManagedChannelProvider.NewChannelBuilderResult;
+import io.grpc.ManagedChannelRegistryAccessor;
+import io.grpc.TlsChannelCredentials;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -49,7 +39,8 @@ public class NettyChannelProviderTest {
   @Test
   public void provided() {
     for (ManagedChannelProvider current
-        : ManagedChannelProvider.getCandidatesViaServiceLoader(getClass().getClassLoader())) {
+        : InternalServiceProviders.getCandidatesViaServiceLoader(
+            ManagedChannelProvider.class, getClass().getClassLoader())) {
       if (current instanceof NettyChannelProvider) {
         return;
       }
@@ -59,9 +50,8 @@ public void provided() {
 
   @Test
   public void providedHardCoded() {
-    for (ManagedChannelProvider current
-        : ManagedChannelProvider.getCandidatesViaHardCoded(getClass().getClassLoader())) {
-      if (current instanceof NettyChannelProvider) {
+    for (Class<?> current : ManagedChannelRegistryAccessor.getHardCodedClasses()) {
+      if (current == NettyChannelProvider.class) {
         return;
       }
     }
@@ -78,4 +68,23 @@ public void basicMethods() {
   public void builderIsANettyBuilder() {
     assertSame(NettyChannelBuilder.class, provider.builderForAddress("localhost", 443).getClass());
   }
+
+  @Test
+  public void builderForTarget() {
+    assertThat(provider.builderForTarget("localhost:443")).isInstanceOf(NettyChannelBuilder.class);
+  }
+
+  @Test
+  public void newChannelBuilder_success() {
+    NewChannelBuilderResult result =
+        provider.newChannelBuilder("localhost:443", TlsChannelCredentials.create());
+    assertThat(result.getChannelBuilder()).isInstanceOf(NettyChannelBuilder.class);
+  }
+
+  @Test
+  public void newChannelBuilder_fail() {
+    NewChannelBuilderResult result = provider.newChannelBuilder("localhost:443",
+        TlsChannelCredentials.newBuilder().requireFakeFeature().build());
+    assertThat(result.getError()).contains("FAKE");
+  }
 }
diff --git a/netty/src/test/java/io/grpc/netty/NettyClientHandlerTest.java b/netty/src/test/java/io/grpc/netty/NettyClientHandlerTest.java
index 9149a13f1bc..53598727efd 100644
--- a/netty/src/test/java/io/grpc/netty/NettyClientHandlerTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyClientHandlerTest.java
@@ -1,37 +1,25 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
-import static com.google.common.base.Charsets.UTF_8;
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.MISCARRIED;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.REFUSED;
 import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
 import static io.grpc.netty.Utils.CONTENT_TYPE_GRPC;
 import static io.grpc.netty.Utils.CONTENT_TYPE_HEADER;
@@ -40,43 +28,58 @@
 import static io.grpc.netty.Utils.STATUS_OK;
 import static io.grpc.netty.Utils.TE_HEADER;
 import static io.grpc.netty.Utils.TE_TRAILERS;
-import static io.netty.handler.codec.http2.Http2CodecUtil.DEFAULT_PRIORITY_WEIGHT;
-import static io.netty.handler.codec.http2.Http2CodecUtil.DEFAULT_WINDOW_SIZE;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.notNull;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Strings;
+import com.google.common.base.Supplier;
 import com.google.common.base.Ticker;
 import com.google.common.collect.ImmutableList;
 import com.google.common.io.ByteStreams;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
 import io.grpc.Metadata;
 import io.grpc.Status;
-import io.grpc.StatusException;
+import io.grpc.internal.AbstractStream;
 import io.grpc.internal.ClientStreamListener;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
 import io.grpc.internal.ClientTransport;
 import io.grpc.internal.ClientTransport.PingCallback;
+import io.grpc.internal.GrpcAttributes;
 import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.KeepAliveManager;
+import io.grpc.internal.ManagedClientTransport;
+import io.grpc.internal.SimpleDisconnectError;
 import io.grpc.internal.StatsTraceContext;
-import io.grpc.netty.GrpcHttp2HeadersDecoder.GrpcHttp2ClientHeadersDecoder;
+import io.grpc.internal.StreamListener;
+import io.grpc.internal.TransportTracer;
+import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2ClientHeadersDecoder;
+import io.grpc.testing.TestMethodDescriptors;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufUtil;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelPromise;
+import io.netty.channel.EventLoop;
 import io.netty.handler.codec.http2.DefaultHttp2Connection;
 import io.netty.handler.codec.http2.DefaultHttp2Headers;
 import io.netty.handler.codec.http2.Http2Connection;
@@ -88,48 +91,112 @@
 import io.netty.handler.codec.http2.Http2Stream;
 import io.netty.util.AsciiString;
 import java.io.InputStream;
+import java.security.cert.CertificateException;
+import java.text.MessageFormat;
+import java.util.LinkedList;
 import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TestName;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
 
 /**
  * Tests for {@link NettyClientHandler}.
  */
 @RunWith(JUnit4.class)
 public class NettyClientHandlerTest extends NettyHandlerTestBase<NettyClientHandler> {
+
   private NettyClientStream.TransportState streamTransportState;
   private Http2Headers grpcHeaders;
   private long nanoTime; // backs a ticker, for testing ping round-trip time measurement
-  private int flowControlWindow = DEFAULT_WINDOW_SIZE;
   private int maxHeaderListSize = Integer.MAX_VALUE;
-  private int streamId = 3;
+  private int softLimitHeaderListSize = Integer.MAX_VALUE;
+  private int streamId = STREAM_ID;
   private ClientTransportLifecycleManager lifecycleManager;
   private KeepAliveManager mockKeepAliveManager = null;
   private List<String> setKeepaliveManagerFor = ImmutableList.of("cancelShouldSucceed",
       "sendFrameShouldSucceed", "channelShutdownShouldCancelBufferedStreams",
       "createIncrementsIdsForActualAndBufferdStreams", "dataPingAckIsRecognized");
+  private Runnable tooManyPingsRunnable = new Runnable() {
+    @Override public void run() {}
+  };
 
   @Rule
   public TestName testNameRule = new TestName();
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
   @Mock
-  private NettyClientTransport.Listener listener;
+  private ManagedClientTransport.Listener listener;
   @Mock
   private ClientStreamListener streamListener;
 
+  private final Queue<InputStream> streamListenerMessageQueue = new LinkedList<>();
+  private NettyClientStream stream;
+
+  @Override
+  protected void manualSetUp() throws Exception {
+    setUp();
+  }
+
+  @Override
+  protected AbstractStream stream() throws Exception {
+    if (stream == null) {
+      stream = new NettyClientStream(streamTransportState,
+          TestMethodDescriptors.voidMethod(),
+          new Metadata(),
+          channel(),
+          AsciiString.of("localhost"),
+          AsciiString.of("http"),
+          AsciiString.of("agent"),
+          StatsTraceContext.NOOP,
+          transportTracer,
+          CallOptions.DEFAULT,
+          false);
+    }
+    return stream;
+  }
+
   /**
    * Set up for test.
    */
   @Before
   public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
+    doAnswer(
+          new Answer<Void>() {
+            @Override
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+              StreamListener.MessageProducer producer =
+                  (StreamListener.MessageProducer) invocation.getArguments()[0];
+              InputStream message;
+              while ((message = producer.next()) != null) {
+                streamListenerMessageQueue.add(message);
+              }
+              return null;
+            }
+          })
+        .when(streamListener)
+        .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
+    doAnswer((attributes) -> Attributes.newBuilder().set(
+            GrpcAttributes.ATTR_AUTHORITY_VERIFIER,
+            (authority) -> Status.OK).build())
+          .when(listener)
+          .filterTransport(ArgumentMatchers.any(Attributes.class));
     lifecycleManager = new ClientTransportLifecycleManager(listener);
     // This mocks the keepalive manager only for there's in which we verify it. For other tests
     // it'll be null which will be testing if we behave correctly when it's not present.
@@ -138,7 +205,11 @@ public void setUp() throws Exception {
     }
 
     initChannel(new GrpcHttp2ClientHeadersDecoder(GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE));
-    streamTransportState = new TransportStateImpl(handler(), DEFAULT_MAX_MESSAGE_SIZE);
+    streamTransportState = new TransportStateImpl(
+        handler(),
+        channel().eventLoop(),
+        DEFAULT_MAX_MESSAGE_SIZE,
+        transportTracer);
     streamTransportState.setListener(streamListener);
 
     grpcHeaders = new DefaultHttp2Headers()
@@ -153,6 +224,37 @@ public void setUp() throws Exception {
     // Simulate receipt of initial remote settings.
     ByteBuf serializedSettings = serializeSettings(new Http2Settings());
     channelRead(serializedSettings);
+    channel().releaseOutbound();
+  }
+
+  @Test
+  @SuppressWarnings("InlineMeInliner")
+  public void sendLargerThanSoftLimitHeaderMayFail() throws Exception {
+    maxHeaderListSize = 8000;
+    softLimitHeaderListSize = 2000;
+    manualSetUp();
+
+    createStream();
+    // total head size of 7999, soft limit = 2000 and max = 8000.
+    // This header has 5999/6000 chance to be rejected.
+    Http2Headers headers = new DefaultHttp2Headers()
+        .scheme(HTTPS)
+        .authority(as("www.fake.com"))
+        .path(as("/fakemethod"))
+        .method(HTTP_METHOD)
+        .add(as("auth"), as("sometoken"))
+        .add(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC)
+        .add(TE_HEADER, TE_TRAILERS)
+        .add("large-field", Strings.repeat("a", 7620)); // String.repeat() requires Java 11
+
+    ByteBuf headersFrame = headersFrame(STREAM_ID, headers);
+    channelRead(headersFrame);
+    ArgumentCaptor<Status> statusArgumentCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(streamListener).closed(statusArgumentCaptor.capture(), eq(PROCESSED),
+        any(Metadata.class));
+    assertThat(statusArgumentCaptor.getValue().getCode()).isEqualTo(Status.Code.RESOURCE_EXHAUSTED);
+    assertThat(statusArgumentCaptor.getValue().getDescription()).contains(
+        "exceeded Metadata size soft limit");
   }
 
   @Test
@@ -161,20 +263,20 @@ public void cancelBufferedStreamShouldChangeClientStreamStatus() throws Exceptio
     receiveMaxConcurrentStreams(0);
     // Create a new stream with id 3.
     ChannelFuture createFuture = enqueue(
-        new CreateStreamCommand(grpcHeaders, streamTransportState));
-    assertEquals(3, streamTransportState.id());
+        newCreateStreamCommand(grpcHeaders, streamTransportState));
+    assertEquals(STREAM_ID, streamTransportState.id());
     // Cancel the stream.
     cancelStream(Status.CANCELLED);
 
-    assertTrue(createFuture.isSuccess());
-    verify(streamListener).closed(eq(Status.CANCELLED), any(Metadata.class));
+    assertFalse(createFuture.isSuccess());
+    verify(streamListener).closed(eq(Status.CANCELLED), same(PROCESSED), any(Metadata.class));
   }
 
   @Test
   public void createStreamShouldSucceed() throws Exception {
     createStream();
-    verifyWrite().writeHeaders(eq(ctx()), eq(3), eq(grpcHeaders), eq(0),
-        eq(DEFAULT_PRIORITY_WEIGHT), eq(false), eq(0), eq(false), any(ChannelPromise.class));
+    verifyWrite().writeHeaders(eq(ctx()), eq(STREAM_ID), eq(grpcHeaders), eq(0),
+        eq(false), any(ChannelPromise.class));
   }
 
   @Test
@@ -182,7 +284,7 @@ public void cancelShouldSucceed() throws Exception {
     createStream();
     cancelStream(Status.CANCELLED);
 
-    verifyWrite().writeRstStream(eq(ctx()), eq(3), eq(Http2Error.CANCEL.code()),
+    verifyWrite().writeRstStream(eq(ctx()), eq(STREAM_ID), eq(Http2Error.CANCEL.code()),
         any(ChannelPromise.class));
     verify(mockKeepAliveManager, times(1)).onTransportActive(); // onStreamActive
     verify(mockKeepAliveManager, times(1)).onTransportIdle(); // onStreamClosed
@@ -194,7 +296,7 @@ public void cancelDeadlineExceededShouldSucceed() throws Exception {
     createStream();
     cancelStream(Status.DEADLINE_EXCEEDED);
 
-    verifyWrite().writeRstStream(eq(ctx()), eq(3), eq(Http2Error.CANCEL.code()),
+    verifyWrite().writeRstStream(eq(ctx()), eq(STREAM_ID), eq(Http2Error.CANCEL.code()),
         any(ChannelPromise.class));
   }
 
@@ -209,7 +311,7 @@ public void cancelWhileBufferedShouldSucceed() throws Exception {
     ChannelFuture cancelFuture = cancelStream(Status.CANCELLED);
     assertTrue(cancelFuture.isSuccess());
     assertTrue(createFuture.isDone());
-    assertTrue(createFuture.isSuccess());
+    assertFalse(createFuture.isSuccess());
   }
 
   /**
@@ -223,7 +325,7 @@ public void cancelTwiceShouldSucceed() throws Exception {
 
     cancelStream(Status.CANCELLED);
 
-    verifyWrite().writeRstStream(any(ChannelHandlerContext.class), eq(3),
+    verifyWrite().writeRstStream(any(ChannelHandlerContext.class), eq(STREAM_ID),
         eq(Http2Error.CANCEL.code()), any(ChannelPromise.class));
 
     ChannelFuture future = cancelStream(Status.CANCELLED);
@@ -236,7 +338,7 @@ public void cancelTwiceDifferentReasons() throws Exception {
 
     cancelStream(Status.DEADLINE_EXCEEDED);
 
-    verifyWrite().writeRstStream(eq(ctx()), eq(3), eq(Http2Error.CANCEL.code()),
+    verifyWrite().writeRstStream(eq(ctx()), eq(STREAM_ID), eq(Http2Error.CANCEL.code()),
         any(ChannelPromise.class));
 
     ChannelFuture future = cancelStream(Status.CANCELLED);
@@ -248,10 +350,12 @@ public void sendFrameShouldSucceed() throws Exception {
     createStream();
 
     // Send a frame and verify that it was written.
-    ChannelFuture future = enqueue(new SendGrpcFrameCommand(streamTransportState, content(), true));
+    ByteBuf content = content();
+    ChannelFuture future
+        = enqueue(new SendGrpcFrameCommand(streamTransportState, content, true));
 
     assertTrue(future.isSuccess());
-    verifyWrite().writeData(eq(ctx()), eq(3), eq(content()), eq(0), eq(true),
+    verifyWrite().writeData(eq(ctx()), eq(STREAM_ID), same(content), eq(0), eq(true),
         any(ChannelPromise.class));
     verify(mockKeepAliveManager, times(1)).onTransportActive(); // onStreamActive
     verifyNoMoreInteractions(mockKeepAliveManager);
@@ -259,7 +363,8 @@ public void sendFrameShouldSucceed() throws Exception {
 
   @Test
   public void sendForUnknownStreamShouldFail() throws Exception {
-    ChannelFuture future = enqueue(new SendGrpcFrameCommand(streamTransportState, content(), true));
+    ChannelFuture future
+        = enqueue(new SendGrpcFrameCommand(streamTransportState, content(), true));
     assertTrue(future.isDone());
     assertFalse(future.isSuccess());
   }
@@ -272,101 +377,308 @@ public void inboundShouldForwardToStream() throws Exception {
     Http2Headers headers = new DefaultHttp2Headers().status(STATUS_OK)
         .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC)
         .set(as("magic"), as("value"));
-    ByteBuf headersFrame = headersFrame(3, headers);
+    ByteBuf headersFrame = headersFrame(STREAM_ID, headers);
     channelRead(headersFrame);
     ArgumentCaptor<Metadata> captor = ArgumentCaptor.forClass(Metadata.class);
     verify(streamListener).headersRead(captor.capture());
     assertEquals("value",
         captor.getValue().get(Metadata.Key.of("magic", Metadata.ASCII_STRING_MARSHALLER)));
 
-    streamTransportState.requestMessagesFromDeframer(1);
+    streamTransportState.requestMessagesFromDeframerForTesting(1);
 
     // Create a data frame and then trigger the handler to read it.
-    ByteBuf frame = grpcDataFrame(3, false, contentAsArray());
+    ByteBuf frame = grpcDataFrame(STREAM_ID, false, contentAsArray());
     channelRead(frame);
-    ArgumentCaptor<InputStream> isCaptor = ArgumentCaptor.forClass(InputStream.class);
-    verify(streamListener).messageRead(isCaptor.capture());
-    assertArrayEquals(ByteBufUtil.getBytes(content()),
-        ByteStreams.toByteArray(isCaptor.getValue()));
-    isCaptor.getValue().close();
+    InputStream message = streamListenerMessageQueue.poll();
+    assertArrayEquals(ByteBufUtil.getBytes(content()), ByteStreams.toByteArray(message));
+    message.close();
+    assertNull("no additional message expected", streamListenerMessageQueue.poll());
   }
 
   @Test
-  public void receivedGoAwayShouldCancelBufferedStream() throws Exception {
-    // Force the stream to be buffered.
-    receiveMaxConcurrentStreams(0);
-    ChannelFuture future = enqueue(new CreateStreamCommand(grpcHeaders, streamTransportState));
-    channelRead(goAwayFrame(0));
+  public void receivedGoAwayNoErrorShouldRefuseLaterStreamId() throws Exception {
+    ChannelFuture future = enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
+    channelRead(goAwayFrame(streamId - 1));
+    verify(streamListener).closed(any(Status.class), eq(REFUSED), any(Metadata.class));
+    assertTrue(future.isDone());
+  }
+
+  @Test
+  public void receivedGoAwayErrorShouldRefuseLaterStreamId() throws Exception {
+    ChannelFuture future = enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
+    channelRead(
+        goAwayFrame(streamId - 1, (int) Http2Error.PROTOCOL_ERROR.code(), Unpooled.EMPTY_BUFFER));
+    // This _should_ be REFUSED, but we purposefully use PROCESSED. See comment for
+    // abruptGoAwayStatusConservative in NettyClientHandler
+    verify(streamListener).closed(any(Status.class), eq(PROCESSED), any(Metadata.class));
+    assertTrue(future.isDone());
+  }
+
+  @Test
+  public void receivedGoAwayShouldNotAffectEarlyStreamId() throws Exception {
+    ChannelFuture future = enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
+    channelRead(goAwayFrame(streamId));
+    verify(streamListener, never())
+        .closed(any(Status.class), any(RpcProgress.class), any(Metadata.class));
+    assertTrue(future.isDone());
+  }
+
+  @Test
+  public void receivedGoAwayShouldNotAffectRacingQueuedStreamId() throws Exception {
+    // This command has not actually been executed yet
+    ChannelFuture future = writeQueue().enqueue(
+        newCreateStreamCommand(grpcHeaders, streamTransportState), true);
+    channelRead(goAwayFrame(streamId));
+    verify(streamListener, never())
+        .closed(any(Status.class), any(RpcProgress.class), any(Metadata.class));
+    assertTrue(future.isDone());
+  }
+
+  @Test
+  public void receivedAbruptGoAwayShouldFailRacingQueuedStreamid() throws Exception {
+    // This command has not actually been executed yet
+    ChannelFuture future = writeQueue().enqueue(
+        newCreateStreamCommand(grpcHeaders, streamTransportState), true);
+    // Read a GOAWAY that indicates our stream can't be sent
+    channelRead(goAwayFrame(0, 8 /* Cancel */, Unpooled.copiedBuffer("this is a test", UTF_8)));
+
+    ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
+    verify(streamListener).closed(captor.capture(), same(MISCARRIED),
+        ArgumentMatchers.<Metadata>notNull());
+    assertEquals(Status.UNAVAILABLE.getCode(), captor.getValue().getCode());
+    assertEquals(
+        "Abrupt GOAWAY closed unsent stream. HTTP/2 error code: CANCEL, "
+          + "debug data: this is a test\nstream id: 3, GOAWAY Last-Stream-ID:0",
+        captor.getValue().getDescription());
+    assertTrue(future.isDone());
+  }
+
+  @Test
+  public void receivedAbruptGoAwayShouldFailRacingQueuedIoStreamid() throws Exception {
+    // Purposefully avoid flush(), since we want the write to not actually complete.
+    // EmbeddedChannel doesn't support flow control, so this is the next closest approximation.
+    ChannelFuture future = channel().write(
+        newCreateStreamCommand(grpcHeaders, streamTransportState));
+    // Read a GOAWAY that indicates our stream can't be sent
+    channelRead(goAwayFrame(0, 0 /* NO_ERROR */, Unpooled.copiedBuffer("this is a test", UTF_8)));
+
+    ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
+    verify(streamListener).closed(captor.capture(), same(REFUSED),
+        ArgumentMatchers.<Metadata>notNull());
+    assertEquals(Status.UNAVAILABLE.getCode(), captor.getValue().getCode());
+    assertEquals(
+        "Abrupt GOAWAY closed sent stream. HTTP/2 error code: NO_ERROR, "
+          + "debug data: this is a test",
+        captor.getValue().getDescription());
+    assertTrue(future.isDone());
+  }
+
+  @Test
+  public void receivedGoAway_shouldFailBufferedStreamsExceedingMaxConcurrentStreams()
+      throws Exception {
+    NettyClientStream.TransportState streamTransportState1 = new TransportStateImpl(
+        handler(),
+        channel().eventLoop(),
+        DEFAULT_MAX_MESSAGE_SIZE,
+        transportTracer);
+    streamTransportState1.setListener(mock(ClientStreamListener.class));
+    NettyClientStream.TransportState streamTransportState2 = new TransportStateImpl(
+        handler(),
+        channel().eventLoop(),
+        DEFAULT_MAX_MESSAGE_SIZE,
+        transportTracer);
+    streamTransportState2.setListener(mock(ClientStreamListener.class));
+    receiveMaxConcurrentStreams(1);
+    ChannelFuture future1 = writeQueue().enqueue(
+        newCreateStreamCommand(grpcHeaders, streamTransportState1), true);
+    ChannelFuture future2 = writeQueue().enqueue(
+        newCreateStreamCommand(grpcHeaders, streamTransportState2), true);
+
+    // GOAWAY
+    channelRead(goAwayFrame(Integer.MAX_VALUE));
+    assertTrue(future1.isSuccess());
+    assertTrue(future2.isDone());
+    assertThat(Status.fromThrowable(future2.cause()).getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(future2.cause().getMessage()).contains(
+        "Abrupt GOAWAY closed unsent stream. HTTP/2 error code: NO_ERROR");
+    assertThat(future2.cause().getMessage()).contains(
+        "At MAX_CONCURRENT_STREAMS limit");
+  }
+
+  @Test
+  public void receivedResetWithRefuseCode() throws Exception {
+    ChannelFuture future = enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
+    channelRead(rstStreamFrame(streamId, (int) Http2Error.REFUSED_STREAM.code() ));
+    verify(streamListener).closed(any(Status.class), eq(REFUSED), any(Metadata.class));
+    assertTrue(future.isDone());
+  }
+
+  @Test
+  public void receivedResetWithCanceCode() throws Exception {
+    ChannelFuture future = enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
+    channelRead(rstStreamFrame(streamId, (int) Http2Error.CANCEL.code()));
+    verify(streamListener).closed(any(Status.class), eq(PROCESSED), any(Metadata.class));
     assertTrue(future.isDone());
-    assertFalse(future.isSuccess());
-    Status status = Status.fromThrowable(future.cause());
-    assertEquals(Status.Code.UNAVAILABLE, status.getCode());
-    assertEquals("HTTP/2 error code: NO_ERROR\nReceived Goaway", status.getDescription());
   }
 
   @Test
   public void receivedGoAwayShouldFailUnknownStreams() throws Exception {
-    enqueue(new CreateStreamCommand(grpcHeaders, streamTransportState));
+    enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
 
     // Read a GOAWAY that indicates our stream was never processed by the server.
     channelRead(goAwayFrame(0, 8 /* Cancel */, Unpooled.copiedBuffer("this is a test", UTF_8)));
     ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
-    verify(streamListener).closed(captor.capture(), notNull(Metadata.class));
+    // See comment for abruptGoAwayStatusConservative in NettyClientHandler
+    verify(streamListener).closed(captor.capture(), same(PROCESSED),
+        ArgumentMatchers.<Metadata>notNull());
     assertEquals(Status.CANCELLED.getCode(), captor.getValue().getCode());
-    assertEquals("HTTP/2 error code: CANCEL\nReceived Goaway\nthis is a test",
+    assertEquals(
+        "Abrupt GOAWAY closed sent stream. HTTP/2 error code: CANCEL, "
+          + "debug data: this is a test",
         captor.getValue().getDescription());
   }
 
   @Test
-  public void receivedGoAwayShouldFailUnknownBufferedStreams() throws Exception {
+  public void receivedGoAwayShouldFailBufferedStreams() throws Exception {
     receiveMaxConcurrentStreams(0);
 
-    ChannelFuture future = enqueue(new CreateStreamCommand(grpcHeaders, streamTransportState));
+    ChannelFuture future = enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
 
     // Read a GOAWAY that indicates our stream was never processed by the server.
     channelRead(goAwayFrame(0, 8 /* Cancel */, Unpooled.copiedBuffer("this is a test", UTF_8)));
     assertTrue(future.isDone());
     assertFalse(future.isSuccess());
     Status status = Status.fromThrowable(future.cause());
-    assertEquals(Status.CANCELLED.getCode(), status.getCode());
-    assertEquals("HTTP/2 error code: CANCEL\nReceived Goaway\nthis is a test",
+    assertEquals(Status.UNAVAILABLE.getCode(), status.getCode());
+    assertEquals(
+        "GOAWAY closed buffered stream. HTTP/2 error code: CANCEL, "
+          + "debug data: this is a test",
         status.getDescription());
   }
 
+  @Test
+  public void channelClosureShouldFailBufferedStreams() throws Exception {
+    receiveMaxConcurrentStreams(0);
+
+    ChannelFuture future = enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
+    channel().pipeline().fireChannelInactive();
+
+    assertTrue(future.isDone());
+    assertFalse(future.isSuccess());
+    ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
+    verify(streamListener).closed(captor.capture(), same(MISCARRIED), ArgumentMatchers.notNull());
+    assertEquals(Status.UNAVAILABLE.getCode(), captor.getValue().getCode());
+  }
+
   @Test
   public void receivedGoAwayShouldFailNewStreams() throws Exception {
     // Read a GOAWAY that indicates our stream was never processed by the server.
     channelRead(goAwayFrame(0, 8 /* Cancel */, Unpooled.copiedBuffer("this is a test", UTF_8)));
 
     // Now try to create a stream.
-    ChannelFuture future = enqueue(new CreateStreamCommand(grpcHeaders, streamTransportState));
+    ChannelFuture future = enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
     assertTrue(future.isDone());
     assertFalse(future.isSuccess());
     Status status = Status.fromThrowable(future.cause());
-    assertEquals(Status.CANCELLED.getCode(), status.getCode());
-    assertEquals("HTTP/2 error code: CANCEL\nReceived Goaway\nthis is a test",
+    assertEquals(Status.UNAVAILABLE.getCode(), status.getCode());
+    assertEquals(
+        "GOAWAY shut down transport. HTTP/2 error code: CANCEL, "
+          + "debug data: this is a test",
         status.getDescription());
   }
 
+  // This test is not as useful as it looks, because the HTTP/2 Netty code catches and doesn't
+  // propagate exceptions during the onGoAwayReceived callback.
+  @Test
+  public void receivedGoAway_notUtf8() throws Exception {
+    // 0xFF is never permitted in UTF-8. 0xF0 should have 3 continuations following, and 0x0a isn't
+    // a continuation.
+    channelRead(goAwayFrame(0, 11 /* ENHANCE_YOUR_CALM */,
+          Unpooled.copiedBuffer(new byte[] {(byte) 0xFF, (byte) 0xF0, (byte) 0x0a})));
+  }
+
+  @Test
+  public void receivedGoAway_enhanceYourCalmWithoutTooManyPings() throws Exception {
+    final AtomicBoolean b = new AtomicBoolean();
+    tooManyPingsRunnable = new Runnable() {
+      @Override
+      public void run() {
+        b.set(true);
+      }
+    };
+    setUp();
+
+    channelRead(goAwayFrame(0, 11 /* ENHANCE_YOUR_CALM */,
+          Unpooled.copiedBuffer("not_many_pings", UTF_8)));
+    assertFalse(b.get());
+  }
+
+  @Test
+  public void receivedGoAway_enhanceYourCalmWithTooManyPings() throws Exception {
+    final AtomicBoolean b = new AtomicBoolean();
+    tooManyPingsRunnable = new Runnable() {
+      @Override
+      public void run() {
+        b.set(true);
+      }
+    };
+    setUp();
+
+    channelRead(goAwayFrame(0, 11 /* ENHANCE_YOUR_CALM */,
+          Unpooled.copiedBuffer("too_many_pings", UTF_8)));
+    assertTrue(b.get());
+  }
+
+  @Test
+  public void receivedGoAway_enhanceYourCalmShouldLogDebugData() throws Exception {
+    final AtomicReference<LogRecord> logRef = new AtomicReference<>();
+    Handler handler = new Handler() {
+      @Override
+      public void publish(LogRecord record) {
+        logRef.set(record);
+      }
+
+      @Override
+      public void flush() {
+      }
+
+      @Override
+      public void close() throws SecurityException {
+      }
+    };
+    Logger logger = Logger.getLogger(NettyClientHandler.class.getName());
+    try {
+      logger.addHandler(handler);
+      enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
+      channelRead(goAwayFrame(0, 11 /* Enhance your calm */,
+          Unpooled.copiedBuffer("this is a test", UTF_8)));
+      assertNotNull(logRef.get());
+      assertTrue(MessageFormat.format(logRef.get().getMessage(), logRef.get().getParameters())
+          .contains("Debug data: this is a test"));
+    } finally {
+      logger.removeHandler(handler);
+    }
+  }
+
   @Test
   public void cancelStreamShouldCreateAndThenFailBufferedStream() throws Exception {
     receiveMaxConcurrentStreams(0);
-    enqueue(new CreateStreamCommand(grpcHeaders, streamTransportState));
-    assertEquals(3, streamTransportState.id());
+    enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
+    assertEquals(STREAM_ID, streamTransportState.id());
     cancelStream(Status.CANCELLED);
-    verify(streamListener).closed(eq(Status.CANCELLED), any(Metadata.class));
+    verify(streamListener).closed(eq(Status.CANCELLED), same(PROCESSED), any(Metadata.class));
   }
 
   @Test
   public void channelShutdownShouldCancelBufferedStreams() throws Exception {
     // Force a stream to get added to the pending queue.
     receiveMaxConcurrentStreams(0);
-    ChannelFuture future = enqueue(new CreateStreamCommand(grpcHeaders, streamTransportState));
+    ChannelFuture future = enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
 
     handler().channelInactive(ctx());
     assertTrue(future.isDone());
     assertFalse(future.isSuccess());
-    verify(mockKeepAliveManager, times(1)).onTransportShutdown(); // channelInactive
+    verify(mockKeepAliveManager, times(1)).onTransportTermination(); // channelInactive
     verifyNoMoreInteractions(mockKeepAliveManager);
   }
 
@@ -376,12 +688,12 @@ public void channelShutdownShouldFailInFlightStreams() throws Exception {
 
     handler().channelInactive(ctx());
     ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
-    verify(streamListener).closed(captor.capture(), notNull(Metadata.class));
+    verify(streamListener).closed(captor.capture(), same(PROCESSED),
+        ArgumentMatchers.<Metadata>notNull());
     assertEquals(Status.UNAVAILABLE.getCode(), captor.getValue().getCode());
   }
 
   @Test
-  @Ignore("Re-enable once https://github.com/grpc/grpc-java/issues/1175 is fixed")
   public void connectionWindowShouldBeOverridden() throws Exception {
     flowControlWindow = 1048576; // 1MiB
     setUp();
@@ -398,17 +710,25 @@ public void connectionWindowShouldBeOverridden() throws Exception {
   @Test
   public void createIncrementsIdsForActualAndBufferdStreams() throws Exception {
     receiveMaxConcurrentStreams(2);
-    enqueue(new CreateStreamCommand(grpcHeaders, streamTransportState));
-    assertEquals(3, streamTransportState.id());
-
-    streamTransportState = new TransportStateImpl(handler(), DEFAULT_MAX_MESSAGE_SIZE);
+    enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
+    assertEquals(STREAM_ID, streamTransportState.id());
+
+    streamTransportState = new TransportStateImpl(
+        handler(),
+        channel().eventLoop(),
+        DEFAULT_MAX_MESSAGE_SIZE,
+        transportTracer);
     streamTransportState.setListener(streamListener);
-    enqueue(new CreateStreamCommand(grpcHeaders, streamTransportState));
+    enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
     assertEquals(5, streamTransportState.id());
 
-    streamTransportState = new TransportStateImpl(handler(), DEFAULT_MAX_MESSAGE_SIZE);
+    streamTransportState = new TransportStateImpl(
+        handler(),
+        channel().eventLoop(),
+        DEFAULT_MAX_MESSAGE_SIZE,
+        transportTracer);
     streamTransportState.setListener(streamListener);
-    enqueue(new CreateStreamCommand(grpcHeaders, streamTransportState));
+    enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
     assertEquals(7, streamTransportState.id());
 
     verify(mockKeepAliveManager, times(1)).onTransportActive(); // onStreamActive
@@ -425,8 +745,14 @@ public void exhaustedStreamsShouldFail() throws Exception {
     ChannelFuture future = createStream();
     assertTrue(future.isSuccess());
 
+    TransportStateImpl newStreamTransportState = new TransportStateImpl(
+        handler(),
+        channel().eventLoop(),
+        DEFAULT_MAX_MESSAGE_SIZE,
+        transportTracer);
+
     // This should fail - out of stream IDs.
-    future = createStream();
+    future = enqueue(newCreateStreamCommand(grpcHeaders, newStreamTransportState));
     assertTrue(future.isDone());
     assertFalse(future.isSuccess());
     Status status = lifecycleManager.getShutdownStatus();
@@ -435,22 +761,41 @@ public void exhaustedStreamsShouldFail() throws Exception {
         status.getDescription().contains("exhausted"));
   }
 
+  @Test
+  public void nonExistentStream() throws Exception {
+    Status status = Status.INTERNAL.withDescription("zz");
+
+    lifecycleManager.notifyShutdown(status, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+    // Stream creation can race with the transport shutting down, with the create command already
+    // enqueued.
+    ChannelFuture future1 = createStream();
+    future1.await();
+    assertNotNull(future1.cause());
+    assertThat(Status.fromThrowable(future1.cause()).getCode()).isEqualTo(status.getCode());
+
+    ChannelFuture future2 = enqueue(new CancelClientStreamCommand(streamTransportState, status));
+    future2.sync();
+  }
+
   @Test
   public void ping() throws Exception {
     PingCallbackImpl callback1 = new PingCallbackImpl();
+    assertEquals(0, transportTracer.getStats().keepAlivesSent);
     sendPing(callback1);
+    assertEquals(1, transportTracer.getStats().keepAlivesSent);
     // add'l ping will be added as listener to outstanding operation
     PingCallbackImpl callback2 = new PingCallbackImpl();
     sendPing(callback2);
+    assertEquals(1, transportTracer.getStats().keepAlivesSent);
 
-    ArgumentCaptor<ByteBuf> captor = ArgumentCaptor.forClass(ByteBuf.class);
+    ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(long.class);
     verifyWrite().writePing(eq(ctx()), eq(false), captor.capture(),
         any(ChannelPromise.class));
 
     // getting a bad ack won't cause the callback to be invoked
-    ByteBuf pingPayload = captor.getValue();
+    long pingPayload = captor.getValue();
     // to compute bad payload, read the good payload and subtract one
-    ByteBuf badPingPayload = Unpooled.copyLong(pingPayload.slice().readLong() - 1);
+    long badPingPayload = pingPayload - 1;
 
     channelRead(pingFrame(true, badPingPayload));
     // operation not complete because ack was wrong
@@ -471,7 +816,9 @@ public void ping() throws Exception {
 
     // now that previous ping is done, next request starts a new operation
     callback1 = new PingCallbackImpl();
+    assertEquals(1, transportTracer.getStats().keepAlivesSent);
     sendPing(callback1);
+    assertEquals(2, transportTracer.getStats().keepAlivesSent);
     assertEquals(0, callback1.invocationCount);
   }
 
@@ -484,9 +831,9 @@ public void ping_failsWhenChannelCloses() throws Exception {
     handler().channelInactive(ctx());
     // ping failed on channel going inactive
     assertEquals(1, callback.invocationCount);
-    assertTrue(callback.failureCause instanceof StatusException);
-    assertEquals(Status.Code.UNAVAILABLE,
-        ((StatusException) callback.failureCause).getStatus().getCode());
+    assertEquals(Status.Code.UNAVAILABLE, callback.failureCause.getCode());
+    // A failed ping is still counted
+    assertEquals(1, transportTracer.getStats().keepAlivesSent);
   }
 
   @Test
@@ -495,15 +842,15 @@ public void oustandingUserPingShouldNotInteractWithDataPing() throws Exception {
     handler().setAutoTuneFlowControl(true);
 
     PingCallbackImpl callback = new PingCallbackImpl();
+    assertEquals(0, transportTracer.getStats().keepAlivesSent);
     sendPing(callback);
-    ArgumentCaptor<ByteBuf> captor = ArgumentCaptor.forClass(ByteBuf.class);
+    assertEquals(1, transportTracer.getStats().keepAlivesSent);
+    ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(long.class);
     verifyWrite().writePing(eq(ctx()), eq(false), captor.capture(), any(ChannelPromise.class));
-    ByteBuf payload = captor.getValue();
-    channelRead(grpcDataFrame(3, false, contentAsArray()));
+    long payload = captor.getValue();
+    channelRead(grpcDataFrame(STREAM_ID, false, contentAsArray()));
     long pingData = handler().flowControlPing().payload();
-    ByteBuf buffer = handler().ctx().alloc().buffer(8);
-    buffer.writeLong(pingData);
-    channelRead(pingFrame(true, buffer));
+    channelRead(pingFrame(true, pingData));
 
     assertEquals(1, handler().flowControlPing().getPingReturn());
     assertEquals(0, callback.invocationCount);
@@ -512,13 +859,77 @@ public void oustandingUserPingShouldNotInteractWithDataPing() throws Exception {
 
     assertEquals(1, handler().flowControlPing().getPingReturn());
     assertEquals(1, callback.invocationCount);
+    assertEquals(1, transportTracer.getStats().keepAlivesSent);
+  }
+
+  @Test
+  public void bdpPingAvoidsTooManyPingsOnSpecialServers() throws Exception {
+    // gRPC servers limit PINGs based on what they _send_. Some servers limit PINGs based on what is
+    // _received_.
+    createStream();
+    handler().setAutoTuneFlowControl(true);
+
+    Http2Headers headers = new DefaultHttp2Headers().status(STATUS_OK)
+        .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC);
+    channelRead(headersFrame(STREAM_ID, headers));
+    channelRead(dataFrame(STREAM_ID, false, content()));
+    verifyWrite().writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
+    channelRead(pingFrame(true, 1234));
+
+    channelRead(dataFrame(STREAM_ID, false, content()));
+    verifyWrite(times(1)).writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
+    channelRead(pingFrame(true, 1234));
+
+    channelRead(dataFrame(STREAM_ID, false, content()));
+    // No ping was sent
+    verifyWrite(times(1)).writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
+  }
+
+  @Test
+  public void bdpPingAllowedAfterSendingData() throws Exception {
+    // gRPC servers limit PINGs based on what they _send_. Some servers limit PINGs based on what is
+    // _received_.
+    flowControlWindow = 64 * 1024;
+    manualSetUp();
+    createStream();
+    handler().setAutoTuneFlowControl(true);
+
+    ByteBuf content = Unpooled.buffer(64 * 1024 + 1024);
+    content.writerIndex(content.capacity());
+    ChannelFuture future
+        = enqueue(new SendGrpcFrameCommand(streamTransportState, content, false));
+    assertFalse(future.isDone()); // flow control limits send
+
+    Http2Headers headers = new DefaultHttp2Headers().status(STATUS_OK)
+        .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC);
+    channelRead(headersFrame(STREAM_ID, headers));
+    channelRead(dataFrame(STREAM_ID, false, content()));
+    verifyWrite().writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
+    channelRead(pingFrame(true, 1234));
+
+    channelRead(dataFrame(STREAM_ID, false, content()));
+    verifyWrite(times(1)).writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
+    channelRead(pingFrame(true, 1234));
+
+    channelRead(dataFrame(STREAM_ID, false, content()));
+    // No ping was sent
+    verifyWrite(times(1)).writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
+
+    channelRead(windowUpdate(0, 2024));
+    channelRead(windowUpdate(STREAM_ID, 2024));
+    assertTrue(future.isDone());
+    assertTrue(future.isSuccess());
+    // But now one is sent
+    channelRead(dataFrame(STREAM_ID, false, content()));
+    verifyWrite(times(1)).writePing(eq(ctx()), eq(false), eq(1234L), any(ChannelPromise.class));
   }
 
   @Override
   public void dataPingAckIsRecognized() throws Exception {
     super.dataPingAckIsRecognized();
     verify(mockKeepAliveManager, times(1)).onTransportActive(); // onStreamActive
-    verify(mockKeepAliveManager, times(2)).onDataReceived(); // onDataRead, onPingAckRead
+    // onHeadersRead, onDataRead, onPingAckRead
+    verify(mockKeepAliveManager, times(3)).onDataReceived();
     verifyNoMoreInteractions(mockKeepAliveManager);
   }
 
@@ -533,9 +944,168 @@ public void exceptionCaughtShouldCloseConnection() throws Exception {
     assertFalse(channel().isOpen());
   }
 
+  @Test
+  public void missingAuthorityHeader_streamCreationShouldFail() throws Exception {
+    Http2Headers grpcHeadersWithoutAuthority = new DefaultHttp2Headers()
+            .scheme(HTTPS)
+            .path(as("/fakemethod"))
+            .method(HTTP_METHOD)
+            .add(as("auth"), as("sometoken"))
+            .add(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC)
+            .add(TE_HEADER, TE_TRAILERS);
+    ChannelFuture channelFuture = enqueue(newCreateStreamCommand(
+            grpcHeadersWithoutAuthority, streamTransportState));
+    try {
+      channelFuture.get();
+      fail("Expected stream creation failure");
+    } catch (ExecutionException e) {
+      assertThat(e.getCause().getMessage()).isEqualTo("UNAVAILABLE: Missing authority header");
+    }
+  }
+
+  @Test
+  public void missingAuthorityVerifierInAttributes_streamCreationShouldFail() throws Exception {
+    doAnswer(new Answer<Void>() {
+      @Override
+      public Void answer(InvocationOnMock invocation) throws Throwable {
+        StreamListener.MessageProducer producer =
+                (StreamListener.MessageProducer) invocation.getArguments()[0];
+        InputStream message;
+        while ((message = producer.next()) != null) {
+          streamListenerMessageQueue.add(message);
+        }
+        return null;
+      }
+    })
+        .when(streamListener)
+        .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
+    doAnswer((attributes) -> Attributes.EMPTY)
+        .when(listener)
+        .filterTransport(ArgumentMatchers.any(Attributes.class));
+    lifecycleManager = new ClientTransportLifecycleManager(listener);
+    // This mocks the keepalive manager only for there's in which we verify it. For other tests
+    // it'll be null which will be testing if we behave correctly when it's not present.
+    if (setKeepaliveManagerFor.contains(testNameRule.getMethodName())) {
+      mockKeepAliveManager = mock(KeepAliveManager.class);
+    }
+
+    initChannel(new GrpcHttp2ClientHeadersDecoder(GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE));
+    streamTransportState = new TransportStateImpl(
+            handler(),
+            channel().eventLoop(),
+            DEFAULT_MAX_MESSAGE_SIZE,
+            transportTracer);
+    streamTransportState.setListener(streamListener);
+
+    grpcHeaders = new DefaultHttp2Headers()
+            .scheme(HTTPS)
+            .authority(as("www.fake.com"))
+            .path(as("/fakemethod"))
+            .method(HTTP_METHOD)
+            .add(as("auth"), as("sometoken"))
+            .add(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC)
+            .add(TE_HEADER, TE_TRAILERS);
+
+    // Simulate receipt of initial remote settings.
+    ByteBuf serializedSettings = serializeSettings(new Http2Settings());
+    channelRead(serializedSettings);
+    channel().releaseOutbound();
+
+    ChannelFuture channelFuture = createStream();
+    try {
+      channelFuture.get();
+      fail("Expected stream creation failure");
+    } catch (ExecutionException e) {
+      assertThat(e.getCause().getMessage()).isEqualTo(
+              "UNAVAILABLE: Authority verifier not found to verify authority");
+    }
+  }
+
+  @Test
+  public void authorityVerificationSuccess_streamCreationSucceeds() throws Exception {
+    NettyClientHandler.enablePerRpcAuthorityCheck = true;
+    try {
+      ChannelFuture channelFuture = createStream();
+      channelFuture.get();
+    } finally {
+      NettyClientHandler.enablePerRpcAuthorityCheck = false;
+    }
+  }
+
+  @Test
+  public void authorityVerificationFailure_streamCreationFails() throws Exception {
+    NettyClientHandler.enablePerRpcAuthorityCheck = true;
+    try {
+      doAnswer(new Answer<Void>() {
+        @Override
+        public Void answer(InvocationOnMock invocation) throws Throwable {
+          StreamListener.MessageProducer producer =
+                  (StreamListener.MessageProducer) invocation.getArguments()[0];
+          InputStream message;
+          while ((message = producer.next()) != null) {
+            streamListenerMessageQueue.add(message);
+          }
+          return null;
+        }
+      })
+          .when(streamListener)
+          .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
+      doAnswer((attributes) -> Attributes.newBuilder().set(
+          GrpcAttributes.ATTR_AUTHORITY_VERIFIER,
+          (authority) -> Status.UNAVAILABLE.withCause(
+                  new CertificateException("Peer verification failed"))).build())
+          .when(listener)
+          .filterTransport(ArgumentMatchers.any(Attributes.class));
+      lifecycleManager = new ClientTransportLifecycleManager(listener);
+      // This mocks the keepalive manager only for there's in which we verify it. For other tests
+      // it'll be null which will be testing if we behave correctly when it's not present.
+      if (setKeepaliveManagerFor.contains(testNameRule.getMethodName())) {
+        mockKeepAliveManager = mock(KeepAliveManager.class);
+      }
+
+      initChannel(new GrpcHttp2ClientHeadersDecoder(GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE));
+      streamTransportState = new TransportStateImpl(
+              handler(),
+              channel().eventLoop(),
+              DEFAULT_MAX_MESSAGE_SIZE,
+              transportTracer);
+      streamTransportState.setListener(streamListener);
+
+      grpcHeaders = new DefaultHttp2Headers()
+              .scheme(HTTPS)
+              .authority(as("www.fake.com"))
+              .path(as("/fakemethod"))
+              .method(HTTP_METHOD)
+              .add(as("auth"), as("sometoken"))
+              .add(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC)
+              .add(TE_HEADER, TE_TRAILERS);
+
+      // Simulate receipt of initial remote settings.
+      ByteBuf serializedSettings = serializeSettings(new Http2Settings());
+      channelRead(serializedSettings);
+      channel().releaseOutbound();
+
+      ChannelFuture channelFuture = createStream();
+      try {
+        channelFuture.get();
+        fail("Expected stream creation failure");
+      } catch (ExecutionException e) {
+        assertThat(e.getMessage()).isEqualTo("io.grpc.InternalStatusRuntimeException: UNAVAILABLE");
+      }
+    } finally {
+      NettyClientHandler.enablePerRpcAuthorityCheck = false;
+    }
+  }
+
   @Override
   protected void makeStream() throws Exception {
     createStream();
+    // The tests in NettyServerHandlerTest expect the header to already be read, since they work on
+    // both client- and server-side.
+    Http2Headers headers = new DefaultHttp2Headers().status(STATUS_OK)
+        .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC);
+    ByteBuf headersFrame = headersFrame(STREAM_ID, headers);
+    channelRead(headersFrame);
   }
 
   @CanIgnoreReturnValue
@@ -550,7 +1120,7 @@ private void receiveMaxConcurrentStreams(int max) throws Exception {
 
   @CanIgnoreReturnValue
   private ChannelFuture createStream() throws Exception {
-    ChannelFuture future = enqueue(new CreateStreamCommand(grpcHeaders, streamTransportState));
+    ChannelFuture future = enqueue(newCreateStreamCommand(grpcHeaders, streamTransportState));
     return future;
   }
 
@@ -567,15 +1137,35 @@ protected NettyClientHandler newHandler() throws Http2Exception {
     Http2Stream stream = connection.local().createStream(streamId - 2, true);
     stream.close();
 
-    Ticker ticker = new Ticker() {
+    final Ticker ticker = new Ticker() {
       @Override
       public long read() {
         return nanoTime;
       }
     };
-
-    return NettyClientHandler.newHandler(connection, frameReader(), frameWriter(),
-        lifecycleManager, mockKeepAliveManager, flowControlWindow, maxHeaderListSize, ticker);
+    Supplier<Stopwatch> stopwatchSupplier = new Supplier<Stopwatch>() {
+      @Override
+      public Stopwatch get() {
+        return Stopwatch.createUnstarted(ticker);
+      }
+    };
+    return NettyClientHandler.newHandler(
+        connection,
+        frameReader(),
+        frameWriter(),
+        lifecycleManager,
+        mockKeepAliveManager,
+        false,
+        flowControlWindow,
+        maxHeaderListSize,
+        softLimitHeaderListSize,
+        stopwatchSupplier,
+        tooManyPingsRunnable,
+        transportTracer,
+        Attributes.EMPTY,
+        "someauthority",
+        null,
+        fakeClock().getTicker());
   }
 
   @Override
@@ -588,10 +1178,15 @@ private AsciiString as(String string) {
     return new AsciiString(string);
   }
 
+  private static CreateStreamCommand newCreateStreamCommand(
+      Http2Headers headers, NettyClientStream.TransportState stream) {
+    return new CreateStreamCommand(headers, stream, true, false);
+  }
+
   private static class PingCallbackImpl implements ClientTransport.PingCallback {
     int invocationCount;
     long roundTripTime;
-    Throwable failureCause;
+    Status failureCause;
 
     @Override
     public void onSuccess(long roundTripTimeNanos) {
@@ -600,15 +1195,26 @@ public void onSuccess(long roundTripTimeNanos) {
     }
 
     @Override
-    public void onFailure(Throwable cause) {
+    public void onFailure(Status cause) {
       invocationCount++;
       this.failureCause = cause;
     }
   }
 
   private static class TransportStateImpl extends NettyClientStream.TransportState {
-    public TransportStateImpl(NettyClientHandler handler, int maxMessageSize) {
-      super(handler, maxMessageSize, StatsTraceContext.NOOP);
+    public TransportStateImpl(
+        NettyClientHandler handler,
+        EventLoop eventLoop,
+        int maxMessageSize,
+        TransportTracer transportTracer) {
+      super(
+          handler,
+          eventLoop,
+          maxMessageSize,
+          StatsTraceContext.NOOP,
+          transportTracer,
+          "methodName",
+          CallOptions.DEFAULT);
     }
 
     @Override
diff --git a/netty/src/test/java/io/grpc/netty/NettyClientStreamTest.java b/netty/src/test/java/io/grpc/netty/NettyClientStreamTest.java
index 136265d7c90..4dd24c3fd4d 100644
--- a/netty/src/test/java/io/grpc/netty/NettyClientStreamTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyClientStreamTest.java
@@ -1,51 +1,42 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
 import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
 import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
 import static io.grpc.netty.NettyTestUtil.messageFrame;
 import static io.grpc.netty.Utils.CONTENT_TYPE_GRPC;
 import static io.grpc.netty.Utils.CONTENT_TYPE_HEADER;
 import static io.grpc.netty.Utils.STATUS_OK;
+import static io.netty.handler.codec.http2.Http2Error.PROTOCOL_ERROR;
+import static io.netty.handler.codec.http2.Http2Exception.connectionError;
 import static io.netty.util.CharsetUtil.UTF_8;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyBoolean;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Matchers.same;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
@@ -55,27 +46,41 @@
 import static org.mockito.Mockito.when;
 
 import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.Iterables;
+import com.google.common.io.BaseEncoding;
+import io.grpc.CallOptions;
+import io.grpc.InternalStatus;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.Status;
 import io.grpc.internal.ClientStreamListener;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
 import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.StreamListener;
+import io.grpc.internal.TransportTracer;
 import io.grpc.netty.WriteQueue.QueuedCommand;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelPromise;
+import io.netty.channel.DefaultChannelPromise;
 import io.netty.handler.codec.http2.DefaultHttp2Headers;
+import io.netty.handler.codec.http2.Http2Exception;
 import io.netty.handler.codec.http2.Http2Headers;
 import io.netty.util.AsciiString;
 import java.io.BufferedInputStream;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
+import java.util.LinkedList;
+import java.util.Queue;
+import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.invocation.InvocationOnMock;
@@ -94,21 +99,51 @@ public class NettyClientStreamTest extends NettyStreamTestBase<NettyClientStream
 
   @SuppressWarnings("unchecked")
   private MethodDescriptor.Marshaller<Void> marshaller = mock(MethodDescriptor.Marshaller.class);
+  private final Queue<InputStream> listenerMessageQueue = new LinkedList<>();
 
   // Must be initialized before @Before, because it is used by createStream()
   private MethodDescriptor<?, ?> methodDescriptor = MethodDescriptor.<Void, Void>newBuilder()
       .setType(MethodDescriptor.MethodType.UNARY)
-      .setFullMethodName("/testService/test")
+      .setFullMethodName("testService/test")
       .setRequestMarshaller(marshaller)
       .setResponseMarshaller(marshaller)
       .build();
 
+  private final TransportTracer transportTracer = new TransportTracer();
+
+  /** Set up for test. */
+  @Before
+  @Override
+  public void setUp() {
+    super.setUp();
+
+    doAnswer(
+          new Answer<Void>() {
+            @Override
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+              StreamListener.MessageProducer producer =
+                  (StreamListener.MessageProducer) invocation.getArguments()[0];
+              InputStream message;
+              while ((message = producer.next()) != null) {
+                listenerMessageQueue.add(message);
+              }
+              return null;
+            }
+          })
+        .when(listener)
+        .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
+  }
 
   @Override
   protected ClientStreamListener listener() {
     return listener;
   }
 
+  @Override
+  protected Queue<InputStream> listenerMessageQueue() {
+    return listenerMessageQueue;
+  }
+
   @Test
   public void closeShouldSucceed() {
     // Force stream creation.
@@ -154,7 +189,6 @@ public void writeMessageShouldSendRequest() throws Exception {
     stream.flush();
     verify(writeQueue).enqueue(
         eq(new SendGrpcFrameCommand(stream.transportState(), messageFrame(MESSAGE), false)),
-        any(ChannelPromise.class),
         eq(true));
   }
 
@@ -166,30 +200,75 @@ public void writeMessageShouldSendRequestUnknownLength() throws Exception {
     stream.writeMessage(new BufferedInputStream(new ByteArrayInputStream(msg)));
     stream.flush();
     // Two writes occur, one for the GRPC frame header and the second with the payload
+    // The framer reports the message count when the payload is completely written
     verify(writeQueue).enqueue(
             eq(new SendGrpcFrameCommand(
                 stream.transportState(), messageFrame(MESSAGE).slice(0, 5), false)),
-            any(ChannelPromise.class),
             eq(false));
     verify(writeQueue).enqueue(
         eq(new SendGrpcFrameCommand(
             stream.transportState(), messageFrame(MESSAGE).slice(5, 11), false)),
-        any(ChannelPromise.class),
         eq(true));
   }
 
+  @Test
+  public void writeFrameFutureFailedShouldCancelRpc() {
+    Http2Exception h2Error = connectionError(PROTOCOL_ERROR, "Stream does not exist %d", STREAM_ID);
+    // Fail all SendGrpcFrameCommands command sent to the queue.
+    when(writeQueue.enqueue(any(SendGrpcFrameCommand.class), anyBoolean())).thenReturn(
+        new DefaultChannelPromise(channel).setFailure(h2Error));
+
+    // Write multiple messages to ensure multiple SendGrpcFrameCommand are enqueued. We set up all
+    // of them to fail, which allows us to assert that only a single cancel is sent, and the stream
+    // isn't spammed with multiple RST_STREAM.
+    stream().transportState().setId(STREAM_ID);
+    stream.writeMessage(new ByteArrayInputStream(smallMessage()));
+    stream.writeMessage(new ByteArrayInputStream(largeMessage()));
+    stream.flush();
+
+    InOrder inOrder = Mockito.inOrder(writeQueue);
+    // Normal stream create and write frame.
+    inOrder.verify(writeQueue).enqueue(any(CreateStreamCommand.class), eq(false));
+    inOrder.verify(writeQueue).enqueue(any(SendGrpcFrameCommand.class), eq(false));
+    // Verify that failed SendGrpcFrameCommand results in immediate CancelClientStreamCommand.
+    inOrder.verify(writeQueue).enqueue(any(CancelClientStreamCommand.class), eq(true));
+    // Verify that any other failures do not produce another CancelClientStreamCommand in the queue.
+    inOrder.verify(writeQueue, atLeast(0)).enqueue(any(SendGrpcFrameCommand.class), eq(false));
+    inOrder.verify(writeQueue).enqueue(any(SendGrpcFrameCommand.class), eq(true));
+    inOrder.verifyNoMoreInteractions();
+
+    // Get the CancelClientStreamCommand written to the queue. Above we verified that there is
+    // only one CancelClientStreamCommand enqueued, and is the third enqueued command (create,
+    // frame write failure, cancel).
+    CancelClientStreamCommand cancelCommand = Iterables.get(
+        Iterables.filter(
+          Mockito.mockingDetails(writeQueue).getInvocations(),
+          // Get enqueue() innovations only
+          invocation -> invocation.getMethod().getName().equals("enqueue")),
+        // Get the third invocation of enqueue()
+        2)
+        // Get the first argument (QueuedCommand command)
+        .getArgument(0);
+
+    Status cancelReason = cancelCommand.reason();
+    assertThat(cancelReason.getCode()).isEqualTo(Status.INTERNAL.getCode());
+    assertThat(cancelReason.getCause()).isEqualTo(h2Error);
+    // Verify listener closed.
+    verify(listener).closed(same(cancelReason), eq(PROCESSED), any(Metadata.class));
+  }
+
   @Test
   public void setStatusWithOkShouldCloseStream() {
     stream().transportState().setId(STREAM_ID);
     stream().transportState().transportReportStatus(Status.OK, true, new Metadata());
-    verify(listener).closed(same(Status.OK), any(Metadata.class));
+    verify(listener).closed(same(Status.OK), same(PROCESSED), any(Metadata.class));
   }
 
   @Test
   public void setStatusWithErrorShouldCloseStream() {
     Status errorStatus = Status.INTERNAL;
     stream().transportState().transportReportStatus(errorStatus, true, new Metadata());
-    verify(listener).closed(eq(errorStatus), any(Metadata.class));
+    verify(listener).closed(eq(errorStatus), same(PROCESSED), any(Metadata.class));
   }
 
   @Test
@@ -197,7 +276,7 @@ public void setStatusWithOkShouldNotOverrideError() {
     Status errorStatus = Status.INTERNAL;
     stream().transportState().transportReportStatus(errorStatus, true, new Metadata());
     stream().transportState().transportReportStatus(Status.OK, true, new Metadata());
-    verify(listener).closed(any(Status.class), any(Metadata.class));
+    verify(listener).closed(any(Status.class), same(PROCESSED), any(Metadata.class));
   }
 
   @Test
@@ -206,7 +285,7 @@ public void setStatusWithErrorShouldNotOverridePreviousError() {
     stream().transportState().transportReportStatus(errorStatus, true, new Metadata());
     stream().transportState().transportReportStatus(
         Status.fromThrowable(new RuntimeException("fake")), true, new Metadata());
-    verify(listener).closed(any(Status.class), any(Metadata.class));
+    verify(listener).closed(any(Status.class), same(PROCESSED), any(Metadata.class));
   }
 
   @Override
@@ -234,6 +313,28 @@ public void inboundTrailersClosesCall() throws Exception {
     stream().transportState().transportHeadersReceived(grpcResponseTrailers(Status.OK), true);
   }
 
+  @Test
+  public void inboundTrailersBeforeHalfCloseSendsRstStream() {
+    stream().transportState().setId(STREAM_ID);
+    stream().transportState().transportHeadersReceived(grpcResponseHeaders(), false);
+    stream().transportState().transportHeadersReceived(grpcResponseTrailers(Status.OK), true);
+
+    // Verify a cancel stream with reason=null is sent to the handler.
+    ArgumentCaptor<CancelClientStreamCommand> captor = ArgumentCaptor
+        .forClass(CancelClientStreamCommand.class);
+    verify(writeQueue).enqueue(captor.capture(), eq(true));
+    assertNull(captor.getValue().reason());
+  }
+
+  @Test
+  public void inboundTrailersAfterHalfCloseDoesNotSendRstStream() {
+    stream().transportState().setId(STREAM_ID);
+    stream().transportState().transportHeadersReceived(grpcResponseHeaders(), false);
+    stream.halfClose();
+    stream().transportState().transportHeadersReceived(grpcResponseTrailers(Status.OK), true);
+    verify(writeQueue, never()).enqueue(isA(CancelClientStreamCommand.class), eq(true));
+  }
+
   @Test
   public void inboundStatusShouldSetStatus() throws Exception {
     stream().transportState().setId(STREAM_ID);
@@ -243,7 +344,7 @@ public void inboundStatusShouldSetStatus() throws Exception {
 
     stream().transportState().transportHeadersReceived(grpcResponseTrailers(Status.INTERNAL), true);
     ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
-    verify(listener).closed(captor.capture(), any(Metadata.class));
+    verify(listener).closed(captor.capture(), same(PROCESSED), any(Metadata.class));
     assertEquals(Status.INTERNAL.getCode(), captor.getValue().getCode());
   }
 
@@ -256,7 +357,8 @@ public void invalidInboundHeadersCancelStream() throws Exception {
     // Remove once b/16290036 is fixed.
     headers.status(new AsciiString("500"));
     stream().transportState().transportHeadersReceived(headers, false);
-    verify(listener, never()).closed(any(Status.class), any(Metadata.class));
+    verify(listener, never()).closed(
+        any(Status.class), any(RpcProgress.class), any(Metadata.class));
 
     // We are now waiting for 100 bytes of error context on the stream, cancel has not yet been
     // sent
@@ -266,10 +368,10 @@ public void invalidInboundHeadersCancelStream() throws Exception {
     stream().transportState().transportDataReceived(Unpooled.buffer(1000).writeZero(1000), false);
 
     // Now verify that cancel is sent and an error is reported to the listener
-    verify(writeQueue).enqueue(any(CancelClientStreamCommand.class), eq(true));
+    verify(writeQueue).enqueue(isA(CancelClientStreamCommand.class), eq(true));
     ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
     ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
-    verify(listener).closed(captor.capture(), metadataCaptor.capture());
+    verify(listener).closed(captor.capture(), same(PROCESSED), metadataCaptor.capture());
     assertEquals(Status.UNKNOWN.getCode(), captor.getValue().getCode());
     assertEquals("4", metadataCaptor.getValue()
         .get(Metadata.Key.of("random", Metadata.ASCII_STRING_MARSHALLER)));
@@ -288,7 +390,7 @@ public void invalidInboundContentTypeShouldCancelStream() {
     stream().transportState().transportHeadersReceived(trailers, true);
     ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
     ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
-    verify(listener).closed(captor.capture(), metadataCaptor.capture());
+    verify(listener).closed(captor.capture(), same(PROCESSED), metadataCaptor.capture());
     Status status = captor.getValue();
     assertEquals(Status.Code.UNKNOWN, status.getCode());
     assertTrue(status.getDescription().contains("content-type"));
@@ -300,7 +402,7 @@ public void invalidInboundContentTypeShouldCancelStream() {
   public void nonGrpcResponseShouldSetStatus() throws Exception {
     stream().transportState().transportDataReceived(Unpooled.copiedBuffer(MESSAGE, UTF_8), true);
     ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
-    verify(listener).closed(captor.capture(), any(Metadata.class));
+    verify(listener).closed(captor.capture(), same(PROCESSED), any(Metadata.class));
     assertEquals(Status.Code.INTERNAL, captor.getValue().getCode());
   }
 
@@ -324,7 +426,8 @@ public void deframedDataAfterCancelShouldBeIgnored() throws Exception {
     stream().transportState().transportHeadersReceived(grpcResponseTrailers(Status.INTERNAL), true);
 
     // Verify that the first was delivered.
-    verify(listener).messageRead(any(InputStream.class));
+    assertNotNull("message expected", listenerMessageQueue.poll());
+    assertNull("no additional message expected", listenerMessageQueue.poll());
 
     // Now set the error status.
     Metadata trailers = Utils.convertTrailers(grpcResponseTrailers(Status.CANCELLED));
@@ -334,8 +437,8 @@ public void deframedDataAfterCancelShouldBeIgnored() throws Exception {
     stream().request(1);
 
     // Verify that the listener was only notified of the first message, not the second.
-    verify(listener).messageRead(any(InputStream.class));
-    verify(listener).closed(eq(Status.CANCELLED), eq(trailers));
+    assertNull("no additional message expected", listenerMessageQueue.poll());
+    verify(listener).closed(eq(Status.CANCELLED), same(PROCESSED), eq(trailers));
   }
 
   @Test
@@ -350,10 +453,11 @@ public void dataFrameWithEosShouldDeframeAndThenFail() {
     stream().transportState().transportDataReceived(simpleGrpcFrame(), true);
 
     // Verify that the message was delivered.
-    verify(listener).messageRead(any(InputStream.class));
+    assertNotNull("message expected", listenerMessageQueue.poll());
+    assertNull("no additional message expected", listenerMessageQueue.poll());
 
     ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
-    verify(listener).closed(captor.capture(), any(Metadata.class));
+    verify(listener).closed(captor.capture(), same(PROCESSED), any(Metadata.class));
     assertEquals(Status.Code.INTERNAL, captor.getValue().getCode());
   }
 
@@ -362,8 +466,16 @@ public void setHttp2StreamShouldNotifyReady() {
     listener = mock(ClientStreamListener.class);
 
     stream = new NettyClientStream(new TransportStateImpl(handler, DEFAULT_MAX_MESSAGE_SIZE),
-        methodDescriptor, new Metadata(), channel, AsciiString.of("localhost"),
-        AsciiString.of("http"), AsciiString.of("agent"), StatsTraceContext.NOOP);
+        methodDescriptor,
+        new Metadata(),
+        channel,
+        AsciiString.of("localhost"),
+        AsciiString.of("http"),
+        AsciiString.of("agent"),
+        StatsTraceContext.NOOP,
+        transportTracer,
+        CallOptions.DEFAULT,
+        false);
     stream.start(listener);
     stream().transportState().setId(STREAM_ID);
     verify(listener, never()).onReady();
@@ -379,11 +491,22 @@ public void removeUserAgentFromApplicationHeaders() {
     metadata.put(GrpcUtil.USER_AGENT_KEY, "bad agent");
     listener = mock(ClientStreamListener.class);
     Mockito.reset(writeQueue);
-    when(writeQueue.enqueue(any(QueuedCommand.class), any(boolean.class))).thenReturn(future);
-
-    stream = new NettyClientStream(new TransportStateImpl(handler, DEFAULT_MAX_MESSAGE_SIZE),
-        methodDescriptor, new Metadata(), channel, AsciiString.of("localhost"),
-        AsciiString.of("http"), AsciiString.of("good agent"), StatsTraceContext.NOOP);
+    ChannelPromise completedPromise = new DefaultChannelPromise(channel)
+        .setSuccess();
+    when(writeQueue.enqueue(any(QueuedCommand.class), anyBoolean())).thenReturn(completedPromise);
+
+    stream = new NettyClientStream(
+        new TransportStateImpl(handler, DEFAULT_MAX_MESSAGE_SIZE),
+        methodDescriptor,
+        new Metadata(),
+        channel,
+        AsciiString.of("localhost"),
+        AsciiString.of("http"),
+        AsciiString.of("good agent"),
+        StatsTraceContext.NOOP,
+        transportTracer,
+        CallOptions.DEFAULT,
+        false);
     stream.start(listener);
 
     ArgumentCaptor<CreateStreamCommand> cmdCap = ArgumentCaptor.forClass(CreateStreamCommand.class);
@@ -392,25 +515,64 @@ methodDescriptor, new Metadata(), channel, AsciiString.of("localhost"),
         .containsEntry(Utils.USER_AGENT, AsciiString.of("good agent"));
   }
 
+  @Test
+  public void getRequestSentThroughHeader() {
+    // Creating a GET method
+    MethodDescriptor<?, ?> descriptor = MethodDescriptor.<Void, Void>newBuilder()
+        .setType(MethodDescriptor.MethodType.UNARY)
+        .setFullMethodName("testService/test")
+        .setRequestMarshaller(marshaller)
+        .setResponseMarshaller(marshaller)
+        .setIdempotent(true)
+        .setSafe(true)
+        .build();
+    NettyClientStream stream = new NettyClientStream(
+        new TransportStateImpl(handler, DEFAULT_MAX_MESSAGE_SIZE),
+        descriptor,
+        new Metadata(),
+        channel,
+        AsciiString.of("localhost"),
+        AsciiString.of("http"),
+        AsciiString.of("agent"),
+        StatsTraceContext.NOOP,
+        transportTracer,
+        CallOptions.DEFAULT,
+        true);
+    stream.start(listener);
+    stream.transportState().setId(STREAM_ID);
+    stream.transportState().setHttp2Stream(http2Stream);
+
+    byte[] msg = smallMessage();
+    stream.writeMessage(new ByteArrayInputStream(msg));
+    stream.flush();
+    stream.halfClose();
+    ArgumentCaptor<CreateStreamCommand> cmdCap = ArgumentCaptor.forClass(CreateStreamCommand.class);
+    verify(writeQueue).enqueue(cmdCap.capture(), eq(true));
+    ImmutableListMultimap<CharSequence, CharSequence> headers =
+        ImmutableListMultimap.copyOf(cmdCap.getValue().headers());
+    assertThat(headers).containsEntry(AsciiString.of(":method"), Utils.HTTP_GET_METHOD);
+    assertThat(headers)
+        .containsEntry(
+            AsciiString.of(":path"),
+            AsciiString.of("/testService/test?" + BaseEncoding.base64().encode(msg)));
+  }
+
   @Override
   protected NettyClientStream createStream() {
     when(handler.getWriteQueue()).thenReturn(writeQueue);
-    doAnswer(new Answer<Object>() {
-      @Override
-      public Object answer(InvocationOnMock invocation) throws Throwable {
-        if (future.isDone()) {
-          ((ChannelPromise) invocation.getArguments()[1]).trySuccess();
-        }
-        return null;
-      }
-    }).when(writeQueue).enqueue(any(QueuedCommand.class), any(ChannelPromise.class), anyBoolean());
-    when(writeQueue.enqueue(any(QueuedCommand.class), anyBoolean())).thenReturn(future);
     NettyClientStream stream = new NettyClientStream(
-        new TransportStateImpl(handler, DEFAULT_MAX_MESSAGE_SIZE), methodDescriptor, new Metadata(),
-        channel, AsciiString.of("localhost"), AsciiString.of("http"), AsciiString.of("agent"),
-        StatsTraceContext.NOOP);
+        new TransportStateImpl(handler, DEFAULT_MAX_MESSAGE_SIZE),
+        methodDescriptor,
+        new Metadata(),
+        channel,
+        AsciiString.of("localhost"),
+        AsciiString.of("http"),
+        AsciiString.of("agent"),
+        StatsTraceContext.NOOP,
+        transportTracer,
+        CallOptions.DEFAULT,
+        false);
     stream.start(listener);
-    stream.transportState().setId(STREAM_ID);
     stream.transportState().setHttp2Stream(http2Stream);
     reset(listener);
     return stream;
@@ -440,13 +602,21 @@ private Http2Headers grpcResponseHeaders() {
 
   private Http2Headers grpcResponseTrailers(Status status) {
     Metadata trailers = new Metadata();
-    trailers.put(Status.CODE_KEY, status);
+    trailers.put(InternalStatus.CODE_KEY, status);
     return Utils.convertTrailers(trailers, true);
   }
 
-  private static class TransportStateImpl extends NettyClientStream.TransportState {
+  private class TransportStateImpl extends NettyClientStream.TransportState {
+    @SuppressWarnings("DirectInvocationOnMock")
     public TransportStateImpl(NettyClientHandler handler, int maxMessageSize) {
-      super(handler, maxMessageSize, StatsTraceContext.NOOP);
+      super(
+          handler,
+          channel.eventLoop(),
+          maxMessageSize,
+          StatsTraceContext.NOOP,
+          transportTracer,
+          "methodName",
+          CallOptions.DEFAULT);
     }
 
     @Override
diff --git a/netty/src/test/java/io/grpc/netty/NettyClientTransportFactoryTest.java b/netty/src/test/java/io/grpc/netty/NettyClientTransportFactoryTest.java
index f6dc9d3491e..621afd98281 100644
--- a/netty/src/test/java/io/grpc/netty/NettyClientTransportFactoryTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyClientTransportFactoryTest.java
@@ -1,38 +1,23 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import io.grpc.internal.AbstractClientTransportFactoryTest;
 import io.grpc.internal.ClientTransportFactory;
-import io.grpc.internal.testing.AbstractClientTransportFactoryTest;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
diff --git a/netty/src/test/java/io/grpc/netty/NettyClientTransportTest.java b/netty/src/test/java/io/grpc/netty/NettyClientTransportTest.java
index ed8827d7767..db44c8f50fd 100644
--- a/netty/src/test/java/io/grpc/netty/NettyClientTransportTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyClientTransportTest.java
@@ -1,60 +1,72 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
-import static com.google.common.base.Charsets.UTF_8;
-import static io.grpc.Status.Code.INTERNAL;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.TruthJUnit.assume;
 import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
+import static io.grpc.internal.GrpcUtil.DEFAULT_SERVER_KEEPALIVE_TIMEOUT_NANOS;
+import static io.grpc.internal.GrpcUtil.DEFAULT_SERVER_KEEPALIVE_TIME_NANOS;
+import static io.grpc.internal.GrpcUtil.KEEPALIVE_TIME_NANOS_DISABLED;
 import static io.grpc.internal.GrpcUtil.USER_AGENT_KEY;
+import static io.grpc.netty.NettyServerBuilder.MAX_CONNECTION_AGE_GRACE_NANOS_INFINITE;
+import static io.grpc.netty.NettyServerBuilder.MAX_CONNECTION_AGE_NANOS_DISABLED;
+import static io.grpc.netty.NettyServerBuilder.MAX_CONNECTION_IDLE_NANOS_DISABLED;
+import static io.grpc.netty.NettyServerBuilder.MAX_RST_COUNT_DISABLED;
 import static io.netty.handler.codec.http2.Http2CodecUtil.DEFAULT_WINDOW_SIZE;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Strings;
+import com.google.common.base.Ticker;
 import com.google.common.io.ByteStreams;
 import com.google.common.util.concurrent.SettableFuture;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
 import io.grpc.Attributes;
-import io.grpc.Context;
+import io.grpc.CallOptions;
+import io.grpc.ChannelLogger;
+import io.grpc.ClientStreamTracer;
 import io.grpc.Grpc;
+import io.grpc.InternalChannelz;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.Marshaller;
+import io.grpc.ServerStreamTracer;
 import io.grpc.Status;
+import io.grpc.Status.Code;
 import io.grpc.StatusException;
+import io.grpc.TlsChannelCredentials;
 import io.grpc.internal.ClientStream;
 import io.grpc.internal.ClientStreamListener;
+import io.grpc.internal.ClientTransport;
+import io.grpc.internal.DisconnectError;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.FixedObjectPool;
 import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.ManagedClientTransport;
 import io.grpc.internal.ServerListener;
@@ -62,50 +74,103 @@
 import io.grpc.internal.ServerStreamListener;
 import io.grpc.internal.ServerTransport;
 import io.grpc.internal.ServerTransportListener;
-import io.grpc.internal.StatsTraceContext;
-import io.grpc.testing.TestUtils;
+import io.grpc.internal.TransportTracer;
+import io.grpc.internal.testing.TestUtils;
+import io.grpc.netty.NettyChannelBuilder.LocalSocketPicker;
+import io.grpc.netty.NettyTestUtil.TrackingObjectPoolForTest;
+import io.grpc.testing.TlsTesting;
+import io.grpc.util.CertificateUtils;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.Channel;
 import io.netty.channel.ChannelConfig;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelFactory;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelOption;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.DefaultEventLoopGroup;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.ReflectiveChannelFactory;
+import io.netty.channel.local.LocalChannel;
 import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.SocketChannelConfig;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.channel.socket.nio.NioSocketChannel;
 import io.netty.handler.codec.http2.StreamBufferingEncoder;
+import io.netty.handler.ssl.ClientAuth;
 import io.netty.handler.ssl.SslContext;
-import io.netty.handler.ssl.SupportedCipherSuiteFilter;
+import io.netty.util.AsciiString;
+import io.netty.util.ReferenceCountUtil;
 import java.io.ByteArrayInputStream;
-import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.lang.reflect.InvocationTargetException;
 import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import javax.annotation.Nullable;
+import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLHandshakeException;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509ExtendedTrustManager;
+import javax.net.ssl.X509TrustManager;
+import javax.security.auth.x500.X500Principal;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /**
  * Tests for {@link NettyClientTransport}.
  */
 @RunWith(JUnit4.class)
+@IgnoreJRERequirement
 public class NettyClientTransportTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private static final SslContext SSL_CONTEXT = createSslContext();
+
+  @SuppressWarnings("InlineMeInliner") // Requires Java 11
+  private static final String LONG_STRING_OF_A = Strings.repeat("a", 128);
 
   @Mock
   private ManagedClientTransport.Listener clientTransportListener;
 
-  private final List<NettyClientTransport> transports = new ArrayList<NettyClientTransport>();
+  private final List<NettyClientTransport> transports = new ArrayList<>();
+  private final LinkedBlockingQueue<Attributes> serverTransportAttributesList =
+      new LinkedBlockingQueue<>();
   private final NioEventLoopGroup group = new NioEventLoopGroup(1);
   private final EchoServerListener serverListener = new EchoServerListener();
+  private final InternalChannelz channelz = new InternalChannelz();
+  private Runnable tooManyPingsRunnable = new Runnable() {
+    // Throwing is useless in this method, because Netty doesn't propagate the exception
+    @Override public void run() {}
+  };
+  private Attributes eagAttributes = Attributes.EMPTY;
+
+  private ProtocolNegotiator negotiator = ProtocolNegotiators.serverTls(SSL_CONTEXT);
 
   private InetSocketAddress address;
   private String authority;
@@ -113,14 +178,13 @@ public class NettyClientTransportTest {
 
   @Before
   public void setup() {
-    MockitoAnnotations.initMocks(this);
+    when(clientTransportListener.filterTransport(any())).thenAnswer(i -> i.getArguments()[0]);
   }
 
   @After
   public void teardown() throws Exception {
-    Context.ROOT.attach();
     for (NettyClientTransport transport : transports) {
-      transport.shutdown();
+      transport.shutdown(Status.UNAVAILABLE);
     }
 
     if (server != null) {
@@ -132,7 +196,7 @@ public void teardown() throws Exception {
 
   @Test
   public void testToString() throws Exception {
-    address = TestUtils.testServerAddress(12345);
+    address = TestUtils.testServerAddress(new InetSocketAddress(12345));
     authority = GrpcUtil.authorityFromHostAndPort(address.getHostString(), address.getPort());
     String s = newTransport(newNegotiator()).toString();
     transports.clear();
@@ -145,6 +209,7 @@ public void addDefaultUserAgent() throws Exception {
     startServer();
     NettyClientTransport transport = newTransport(newNegotiator());
     callMeMaybe(transport.start(clientTransportListener));
+    verify(clientTransportListener, timeout(5000)).transportReady();
 
     // Send a single RPC and wait for the response.
     new Rpc(transport).halfClose().waitForResponse();
@@ -157,16 +222,36 @@ public void addDefaultUserAgent() throws Exception {
   }
 
   @Test
-  public void setSoLingerChannelOption() throws IOException {
+  public void setSoLingerChannelOption() throws IOException, GeneralSecurityException {
     startServer();
-    Map<ChannelOption<?>, Object> channelOptions = new HashMap<ChannelOption<?>, Object>();
+    Map<ChannelOption<?>, Object> channelOptions = new HashMap<>();
     // set SO_LINGER option
     int soLinger = 123;
     channelOptions.put(ChannelOption.SO_LINGER, soLinger);
-    NettyClientTransport transport = new NettyClientTransport(
-        address, NioSocketChannel.class, channelOptions, group, newNegotiator(),
-        DEFAULT_WINDOW_SIZE, DEFAULT_MAX_MESSAGE_SIZE, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE,
-        authority, null /* user agent */);
+    NettyClientTransport transport =
+        new NettyClientTransport(
+            address,
+            new ReflectiveChannelFactory<>(NioSocketChannel.class),
+            channelOptions,
+            group,
+            newNegotiator(),
+            false,
+            DEFAULT_WINDOW_SIZE,
+            DEFAULT_MAX_MESSAGE_SIZE,
+            GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE,
+            GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE,
+            KEEPALIVE_TIME_NANOS_DISABLED,
+            1L,
+            false,
+            authority,
+            null /* user agent */,
+            tooManyPingsRunnable,
+            new TransportTracer(),
+            Attributes.EMPTY,
+            new SocketPicker(),
+            new FakeChannelLogger(),
+            false,
+            Ticker.systemTicker());
     transports.add(transport);
     callMeMaybe(transport.start(clientTransportListener));
 
@@ -182,6 +267,7 @@ public void overrideDefaultUserAgent() throws Exception {
     NettyClientTransport transport = newTransport(newNegotiator(),
         DEFAULT_MAX_MESSAGE_SIZE, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE, "testUserAgent", true);
     callMeMaybe(transport.start(clientTransportListener));
+    verify(clientTransportListener, timeout(5000)).transportReady();
 
     new Rpc(transport, new Metadata()).halfClose().waitForResponse();
 
@@ -199,6 +285,7 @@ public void maxMessageSizeShouldBeEnforced() throws Throwable {
     NettyClientTransport transport = newTransport(newNegotiator(),
         1, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE, null, true);
     callMeMaybe(transport.start(clientTransportListener));
+    verify(clientTransportListener, timeout(5000)).transportReady();
 
     try {
       // Send a single RPC and wait for the response.
@@ -206,7 +293,7 @@ public void maxMessageSizeShouldBeEnforced() throws Throwable {
       fail("Expected the stream to fail.");
     } catch (ExecutionException e) {
       Status status = Status.fromThrowable(e);
-      assertEquals(INTERNAL, status.getCode());
+      assertEquals(Code.RESOURCE_EXHAUSTED, status.getCode());
       assertTrue("Missing exceeds maximum from: " + status.getDescription(),
           status.getDescription().contains("exceeds maximum"));
     }
@@ -225,9 +312,10 @@ public void creatingMultipleTlsTransportsShouldSucceed() throws Exception {
       NettyClientTransport transport = newTransport(negotiator);
       callMeMaybe(transport.start(clientTransportListener));
     }
+    verify(clientTransportListener, timeout(5000).times(2)).transportReady();
 
     // Send a single RPC on each transport.
-    final List<Rpc> rpcs = new ArrayList<Rpc>(transports.size());
+    final List<Rpc> rpcs = new ArrayList<>(transports.size());
     for (NettyClientTransport transport : transports) {
       rpcs.add(new Rpc(transport).halfClose());
     }
@@ -238,6 +326,131 @@ public void creatingMultipleTlsTransportsShouldSucceed() throws Exception {
     }
   }
 
+  @Test
+  public void negotiationFailurePropagatesToStatus() throws Exception {
+    negotiator = ProtocolNegotiators.serverPlaintext();
+    startServer();
+
+    final NoopProtocolNegotiator negotiator = new NoopProtocolNegotiator();
+    final NettyClientTransport transport = newTransport(negotiator);
+    callMeMaybe(transport.start(clientTransportListener));
+    final Status failureStatus = Status.UNAVAILABLE.withDescription("oh noes!");
+    transport.channel().eventLoop().execute(new Runnable() {
+      @Override
+      public void run() {
+        negotiator.handler.fail(transport.channel().pipeline().context(negotiator.handler),
+            failureStatus.asRuntimeException());
+      }
+    });
+    verify(clientTransportListener, timeout(5000)).transportTerminated();
+
+    Rpc rpc = new Rpc(transport).halfClose();
+    try {
+      rpc.waitForClose();
+      fail("expected exception");
+    } catch (ExecutionException ex) {
+      Status actual = ((StatusException) ex.getCause()).getStatus();
+      assertSame(failureStatus.getCode(), actual.getCode());
+      assertThat(actual.getDescription()).contains(failureStatus.getDescription());
+    }
+  }
+
+  @Test
+  public void tlsNegotiationFailurePropagatesToStatus() throws Exception {
+    InputStream serverCert = TlsTesting.loadCert("server1.pem");
+    InputStream serverKey = TlsTesting.loadCert("server1.key");
+    // Don't trust ca.pem, so that client auth fails
+    SslContext sslContext = GrpcSslContexts.forServer(serverCert, serverKey)
+        .clientAuth(ClientAuth.REQUIRE)
+        .build();
+    negotiator = ProtocolNegotiators.serverTls(sslContext);
+    startServer();
+
+    InputStream caCert = TlsTesting.loadCert("ca.pem");
+    InputStream clientCert = TlsTesting.loadCert("client.pem");
+    InputStream clientKey = TlsTesting.loadCert("client.key");
+    SslContext clientContext = GrpcSslContexts.forClient()
+        .trustManager(caCert)
+        .keyManager(clientCert, clientKey)
+        .build();
+    ProtocolNegotiator negotiator = ProtocolNegotiators.tls(clientContext, null);
+    final NettyClientTransport transport = newTransport(negotiator);
+    callMeMaybe(transport.start(clientTransportListener));
+    verify(clientTransportListener, timeout(5000)).transportTerminated();
+
+    Rpc rpc = new Rpc(transport).halfClose();
+    try {
+      rpc.waitForClose();
+      fail("expected exception");
+    } catch (ExecutionException ex) {
+      StatusException sre = (StatusException) ex.getCause();
+      assertEquals(Status.Code.UNAVAILABLE, sre.getStatus().getCode());
+      if (sre.getCause() instanceof SSLHandshakeException) {
+        assertThat(sre).hasCauseThat().isInstanceOf(SSLHandshakeException.class);
+        assertThat(sre).hasCauseThat().hasMessageThat().contains("SSLV3_ALERT_HANDSHAKE_FAILURE");
+      } else {
+        // Client cert verification is after handshake in TLSv1.3
+        assertThat(sre).hasCauseThat().hasCauseThat().isInstanceOf(SSLException.class);
+        assertThat(sre).hasCauseThat().hasMessageThat().contains("CERTIFICATE_REQUIRED");
+      }
+    }
+  }
+
+  @Test
+  public void channelExceptionDuringNegotiatonPropagatesToStatus() throws Exception {
+    negotiator = ProtocolNegotiators.serverPlaintext();
+    startServer();
+
+    NoopProtocolNegotiator negotiator = new NoopProtocolNegotiator();
+    NettyClientTransport transport = newTransport(negotiator);
+    callMeMaybe(transport.start(clientTransportListener));
+    final Status failureStatus = Status.UNAVAILABLE.withDescription("oh noes!");
+    transport.channel().pipeline().fireExceptionCaught(failureStatus.asRuntimeException());
+    verify(clientTransportListener, timeout(5000)).transportTerminated();
+
+    Rpc rpc = new Rpc(transport).halfClose();
+    try {
+      rpc.waitForClose();
+      fail("expected exception");
+    } catch (ExecutionException ex) {
+      assertSame(failureStatus, ((StatusException) ex.getCause()).getStatus());
+    }
+  }
+
+  @Test
+  public void handlerExceptionDuringNegotiatonPropagatesToStatus() throws Exception {
+    negotiator = ProtocolNegotiators.serverPlaintext();
+    startServer();
+
+    final NoopProtocolNegotiator negotiator = new NoopProtocolNegotiator();
+    final NettyClientTransport transport = newTransport(negotiator);
+    callMeMaybe(transport.start(clientTransportListener));
+    final Status failureStatus = Status.UNAVAILABLE.withDescription("oh noes!");
+    transport.channel().eventLoop().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          negotiator.handler.exceptionCaught(
+              transport.channel().pipeline().context(negotiator.handler),
+              failureStatus.asRuntimeException());
+        } catch (Exception ex) {
+          throw new RuntimeException(ex);
+        }
+      }
+    });
+    verify(clientTransportListener, timeout(5000)).transportTerminated();
+
+    Rpc rpc = new Rpc(transport).halfClose();
+    try {
+      rpc.waitForClose();
+      fail("expected exception");
+    } catch (ExecutionException ex) {
+      Status actual = ((StatusException) ex.getCause()).getStatus();
+      assertSame(failureStatus.getCode(), actual.getCode());
+      assertThat(actual.getDescription()).contains(failureStatus.getDescription());
+    }
+  }
+
   @Test
   public void bufferedStreamsShouldBeClosedWhenConnectionTerminates() throws Exception {
     // Only allow a single stream active at a time.
@@ -245,6 +458,7 @@ public void bufferedStreamsShouldBeClosedWhenConnectionTerminates() throws Excep
 
     NettyClientTransport transport = newTransport(newNegotiator());
     callMeMaybe(transport.start(clientTransportListener));
+    verify(clientTransportListener, timeout(5000)).transportReady();
 
     // Send a dummy RPC in order to ensure that the updated SETTINGS_MAX_CONCURRENT_STREAMS
     // has been received by the remote endpoint.
@@ -274,6 +488,121 @@ public void bufferedStreamsShouldBeClosedWhenConnectionTerminates() throws Excep
     }
   }
 
+  public static class CantConstructChannel extends NioSocketChannel {
+    /** Constructor. It doesn't work. Feel free to try. But it doesn't work. */
+    public CantConstructChannel() {
+      // Use an Error because we've seen cases of channels failing to construct due to classloading
+      // problems (like mixing different versions of Netty), and those involve Errors.
+      throw new CantConstructChannelError();
+    }
+  }
+
+  private static class CantConstructChannelError extends Error {}
+
+  @Test
+  public void failingToConstructChannelShouldFailGracefully() throws Exception {
+    address = TestUtils.testServerAddress(new InetSocketAddress(12345));
+    authority = GrpcUtil.authorityFromHostAndPort(address.getHostString(), address.getPort());
+    NettyClientTransport transport =
+        new NettyClientTransport(
+            address,
+            new ReflectiveChannelFactory<>(CantConstructChannel.class),
+            new HashMap<ChannelOption<?>, Object>(),
+            group,
+            newNegotiator(),
+            false,
+            DEFAULT_WINDOW_SIZE,
+            DEFAULT_MAX_MESSAGE_SIZE,
+            GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE,
+            GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE,
+            KEEPALIVE_TIME_NANOS_DISABLED,
+            1,
+            false,
+            authority,
+            null,
+            tooManyPingsRunnable,
+            new TransportTracer(),
+            Attributes.EMPTY,
+            new SocketPicker(),
+            new FakeChannelLogger(),
+            false,
+            Ticker.systemTicker());
+    transports.add(transport);
+
+    // Should not throw
+    callMeMaybe(transport.start(clientTransportListener));
+
+    // And RPCs and PINGs should fail cleanly, reporting the failure
+    Rpc rpc = new Rpc(transport);
+    try {
+      rpc.waitForResponse();
+      fail("Expected exception");
+    } catch (Exception ex) {
+      if (!(getRootCause(ex) instanceof CantConstructChannelError)) {
+        throw new AssertionError("Could not find expected error", ex);
+      }
+    }
+
+    final SettableFuture<Object> pingResult = SettableFuture.create();
+    FakeClock clock = new FakeClock();
+    ClientTransport.PingCallback pingCallback = new ClientTransport.PingCallback() {
+      @Override
+      public void onSuccess(long roundTripTimeNanos) {
+        pingResult.set(roundTripTimeNanos);
+      }
+
+      @Override
+      public void onFailure(Status cause) {
+        pingResult.setException(cause.asException());
+      }
+    };
+    transport.ping(pingCallback, clock.getScheduledExecutorService());
+    assertFalse(pingResult.isDone());
+    clock.runDueTasks();
+    assertTrue(pingResult.isDone());
+    try {
+      pingResult.get();
+      fail("Expected exception");
+    } catch (Exception ex) {
+      if (!(getRootCause(ex) instanceof CantConstructChannelError)) {
+        throw new AssertionError("Could not find expected error", ex);
+      }
+    }
+  }
+
+  @Test
+  public void channelFactoryShouldSetSocketOptionKeepAlive() throws Exception {
+    startServer();
+    NettyClientTransport transport = newTransport(newNegotiator(),
+        DEFAULT_MAX_MESSAGE_SIZE, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE, "testUserAgent", true,
+        TimeUnit.SECONDS.toNanos(10L), TimeUnit.SECONDS.toNanos(1L),
+        new ReflectiveChannelFactory<>(NioSocketChannel.class), group);
+
+    callMeMaybe(transport.start(clientTransportListener));
+
+    assertThat(transport.channel().config().getOption(ChannelOption.SO_KEEPALIVE))
+        .isTrue();
+  }
+
+  @Test
+  public void channelFactoryShouldNNotSetSocketOptionKeepAlive() throws Exception {
+    startServer();
+    DefaultEventLoopGroup group = new DefaultEventLoopGroup(1);
+    try {
+      NettyClientTransport transport = newTransport(newNegotiator(),
+          DEFAULT_MAX_MESSAGE_SIZE, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE, "testUserAgent", true,
+          TimeUnit.SECONDS.toNanos(10L), TimeUnit.SECONDS.toNanos(1L),
+          new ReflectiveChannelFactory<>(LocalChannel.class), group);
+
+      callMeMaybe(transport.start(clientTransportListener));
+
+      assertThat(transport.channel().config().getOption(ChannelOption.SO_KEEPALIVE))
+          .isNull();
+    } finally {
+      group.shutdownGracefully(0, 10, TimeUnit.SECONDS);
+    }
+  }
+
   @Test
   public void maxHeaderListSizeShouldBeEnforcedOnClient() throws Exception {
     startServer();
@@ -281,6 +610,7 @@ public void maxHeaderListSizeShouldBeEnforcedOnClient() throws Exception {
     NettyClientTransport transport =
         newTransport(newNegotiator(), DEFAULT_MAX_MESSAGE_SIZE, 1, null, true);
     callMeMaybe(transport.start(clientTransportListener));
+    verify(clientTransportListener, timeout(5000)).transportReady();
 
     try {
       // Send a single RPC and wait for the response.
@@ -291,17 +621,98 @@ public void maxHeaderListSizeShouldBeEnforcedOnClient() throws Exception {
       Throwable rootCause = getRootCause(e);
       Status status = ((StatusException) rootCause).getStatus();
       assertEquals(Status.Code.INTERNAL, status.getCode());
-      assertEquals("HTTP/2 error code: PROTOCOL_ERROR\nReceived Rst Stream",
+      assertEquals("RST_STREAM closed stream. HTTP/2 error code: PROTOCOL_ERROR",
           status.getDescription());
     }
   }
 
+  @Test
+  public void huffmanCodingShouldNotBePerformed() throws Exception {
+    negotiator = ProtocolNegotiators.serverPlaintext();
+    startServer();
+
+    NettyClientTransport transport = newTransport(ProtocolNegotiators.plaintext(),
+        DEFAULT_MAX_MESSAGE_SIZE, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE, null, false,
+        TimeUnit.SECONDS.toNanos(10L), TimeUnit.SECONDS.toNanos(1L),
+        new ReflectiveChannelFactory<>(NioSocketChannel.class), group);
+
+    Metadata headers = new Metadata();
+    headers.put(Metadata.Key.of("test", Metadata.ASCII_STRING_MARSHALLER),
+        LONG_STRING_OF_A);
+
+    callMeMaybe(transport.start(clientTransportListener));
+    verify(clientTransportListener, timeout(5000)).transportReady();
+
+    AtomicBoolean foundExpectedHeaderBytes = new AtomicBoolean(false);
+
+    transport.channel().pipeline().addFirst(new ChannelDuplexHandler() {
+      @Override
+      public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
+          throws Exception {
+        if (msg instanceof ByteBuf) {
+          if (((ByteBuf) msg).toString(StandardCharsets.UTF_8).contains(LONG_STRING_OF_A)) {
+            foundExpectedHeaderBytes.set(true);
+          }
+        }
+        super.write(ctx, msg, promise);
+      }
+    });
+
+    new Rpc(transport, headers).halfClose().waitForResponse();
+
+    if (!foundExpectedHeaderBytes.get()) {
+      fail("expected to find UTF-8 encoded 'a's in the header");
+    }
+  }
+
+  @Test
+  public void huffmanCodingShouldNotBePerformedOnServer() throws Exception {
+    negotiator = ProtocolNegotiators.serverPlaintext();
+
+    Metadata responseHeaders = new Metadata();
+    responseHeaders.put(Metadata.Key.of("test", Metadata.ASCII_STRING_MARSHALLER),
+        LONG_STRING_OF_A);
+
+    startServer(new EchoServerListener(responseHeaders));
+
+    NettyClientTransport transport = newTransport(ProtocolNegotiators.plaintext(),
+        DEFAULT_MAX_MESSAGE_SIZE, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE, null, false,
+        TimeUnit.SECONDS.toNanos(10L), TimeUnit.SECONDS.toNanos(1L),
+        new ReflectiveChannelFactory<>(NioSocketChannel.class), group);
+
+    callMeMaybe(transport.start(clientTransportListener));
+    verify(clientTransportListener, timeout(5000)).transportReady();
+
+    AtomicBoolean foundExpectedHeaderBytes = new AtomicBoolean(false);
+
+    // Add a handler to the client pipeline to inspect server's response
+    transport.channel().pipeline().addFirst(new ChannelDuplexHandler() {
+      @Override
+      public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        if (msg instanceof ByteBuf) {
+          String data = ((ByteBuf) msg).toString(StandardCharsets.UTF_8);
+          if (data.contains(LONG_STRING_OF_A)) {
+            foundExpectedHeaderBytes.set(true);
+          }
+        }
+        super.channelRead(ctx, msg);
+      }
+    });
+
+    new Rpc(transport).halfClose().waitForResponse();
+
+    if (!foundExpectedHeaderBytes.get()) {
+      fail("expected to find UTF-8 encoded 'a's in the response header sent by the server");
+    }
+  }
+
   @Test
   public void maxHeaderListSizeShouldBeEnforcedOnServer() throws Exception {
     startServer(100, 1);
 
     NettyClientTransport transport = newTransport(newNegotiator());
     callMeMaybe(transport.start(clientTransportListener));
+    verify(clientTransportListener, timeout(5000)).transportReady();
 
     try {
       // Send a single RPC and wait for the response.
@@ -309,28 +720,36 @@ public void maxHeaderListSizeShouldBeEnforcedOnServer() throws Exception {
       fail("The stream should have been failed due to server received header exceeds header list"
           + " size limit!");
     } catch (Exception e) {
-      Throwable rootCause = getRootCause(e);
-      Status status = ((StatusException) rootCause).getStatus();
+      Status status = Status.fromThrowable(e);
       assertEquals(status.toString(), Status.Code.INTERNAL, status.getCode());
     }
   }
 
   @Test
   public void getAttributes_negotiatorHandler() throws Exception {
-    address = TestUtils.testServerAddress(12345);
+    address = TestUtils.testServerAddress(new InetSocketAddress(12345));
     authority = GrpcUtil.authorityFromHostAndPort(address.getHostString(), address.getPort());
 
-    NettyClientTransport transport = newTransport(
-        new ProtocolNegotiator() {
-          @Override
-          public Handler newHandler(GrpcHttp2ConnectionHandler handler) {
-            return null;
-          }
-        });
+    NettyClientTransport transport = newTransport(new NoopProtocolNegotiator());
+    callMeMaybe(transport.start(clientTransportListener));
 
-    assertEquals(Attributes.EMPTY, transport.getAttributes());
+    assertNotNull(transport.getAttributes());
+  }
 
-    transports.clear();
+  @Test
+  public void getEagAttributes_negotiatorHandler() throws Exception {
+    address = TestUtils.testServerAddress(new InetSocketAddress(12345));
+    authority = GrpcUtil.authorityFromHostAndPort(address.getHostString(), address.getPort());
+
+    NoopProtocolNegotiator npn = new NoopProtocolNegotiator();
+    eagAttributes = Attributes.newBuilder()
+        .set(Attributes.Key.create("trash"), "value")
+        .build();
+    NettyClientTransport transport = newTransport(npn);
+    callMeMaybe(transport.start(clientTransportListener));
+
+    // EAG Attributes are available before the negotiation is complete
+    assertSame(eagAttributes, npn.grpcHandler.getEagAttributes());
   }
 
   @Test
@@ -338,11 +757,17 @@ public void clientStreamGetsAttributes() throws Exception {
     startServer();
     NettyClientTransport transport = newTransport(newNegotiator());
     callMeMaybe(transport.start(clientTransportListener));
+    verify(clientTransportListener, timeout(5000)).transportReady();
     Rpc rpc = new Rpc(transport).halfClose();
     rpc.waitForResponse();
 
     assertNotNull(rpc.stream.getAttributes().get(Grpc.TRANSPORT_ATTR_SSL_SESSION));
     assertEquals(address, rpc.stream.getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR));
+    Attributes serverTransportAttrs = serverTransportAttributesList.poll(1, TimeUnit.SECONDS);
+    assertNotNull(serverTransportAttrs);
+    SocketAddress clientAddr = serverTransportAttrs.get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
+    assertNotNull(clientAddr);
+    assertEquals(clientAddr, rpc.stream.getAttributes().get(Grpc.TRANSPORT_ATTR_LOCAL_ADDR));
   }
 
   @Test
@@ -351,6 +776,7 @@ public void keepAliveEnabled() throws Exception {
     NettyClientTransport transport = newTransport(newNegotiator(), DEFAULT_MAX_MESSAGE_SIZE,
         GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE, null /* user agent */, true /* keep alive */);
     callMeMaybe(transport.start(clientTransportListener));
+    verify(clientTransportListener, timeout(5000)).transportReady();
     Rpc rpc = new Rpc(transport).halfClose();
     rpc.waitForResponse();
 
@@ -363,12 +789,283 @@ public void keepAliveDisabled() throws Exception {
     NettyClientTransport transport = newTransport(newNegotiator(), DEFAULT_MAX_MESSAGE_SIZE,
         GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE, null /* user agent */, false /* keep alive */);
     callMeMaybe(transport.start(clientTransportListener));
+    verify(clientTransportListener, timeout(5000)).transportReady();
     Rpc rpc = new Rpc(transport).halfClose();
     rpc.waitForResponse();
 
     assertNull(transport.keepAliveManager());
   }
 
+  @Test
+  public void keepAliveEnabled_shouldSetTcpUserTimeout() throws Exception {
+    assume().that(Utils.isEpollAvailable()).isTrue();
+
+    startServer();
+    EventLoopGroup epollGroup = Utils.DEFAULT_WORKER_EVENT_LOOP_GROUP.create();
+    int keepAliveTimeMillis = 12345670;
+    int keepAliveTimeoutMillis = 1234567;
+    try {
+      NettyClientTransport transport = newTransport(newNegotiator(), DEFAULT_MAX_MESSAGE_SIZE,
+          GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE, null /* user agent */, true /* keep alive */,
+          TimeUnit.MILLISECONDS.toNanos(keepAliveTimeMillis),
+          TimeUnit.MILLISECONDS.toNanos(keepAliveTimeoutMillis),
+          new ReflectiveChannelFactory<>(Utils.DEFAULT_CLIENT_CHANNEL_TYPE), epollGroup);
+
+      callMeMaybe(transport.start(clientTransportListener));
+
+      ChannelOption<Integer> tcpUserTimeoutOption = Utils.maybeGetTcpUserTimeoutOption();
+      assertThat(tcpUserTimeoutOption).isNotNull();
+      // on some linux based system, the integer value may have error (usually +-1)
+      assertThat((double) transport.channel().config().getOption(tcpUserTimeoutOption))
+          .isWithin(5.0).of((double) keepAliveTimeoutMillis);
+    } finally {
+      epollGroup.shutdownGracefully();
+    }
+  }
+
+  @Test
+  public void keepAliveDisabled_shouldNotSetTcpUserTimeout() throws Exception {
+    assume().that(Utils.isEpollAvailable()).isTrue();
+
+    startServer();
+    EventLoopGroup epollGroup = Utils.DEFAULT_WORKER_EVENT_LOOP_GROUP.create();
+    int keepAliveTimeMillis = 12345670;
+    try {
+      long keepAliveTimeNanos = TimeUnit.MILLISECONDS.toNanos(keepAliveTimeMillis);
+      NettyClientTransport transport = newTransport(newNegotiator(), DEFAULT_MAX_MESSAGE_SIZE,
+          GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE, null /* user agent */, false /* keep alive */,
+          keepAliveTimeNanos, keepAliveTimeNanos,
+          new ReflectiveChannelFactory<>(Utils.DEFAULT_CLIENT_CHANNEL_TYPE), epollGroup);
+
+      callMeMaybe(transport.start(clientTransportListener));
+
+      ChannelOption<Integer> tcpUserTimeoutOption = Utils.maybeGetTcpUserTimeoutOption();
+      assertThat(tcpUserTimeoutOption).isNotNull();
+      // default TCP_USER_TIMEOUT=0 (use the system default)
+      assertThat(transport.channel().config().getOption(tcpUserTimeoutOption)).isEqualTo(0);
+    } finally {
+      epollGroup.shutdownGracefully();
+    }
+  }
+
+  /**
+   * Verifies that we can successfully build a server and client negotiator with tls and the
+   * executor passing in, and without resource leak after closing the negotiator.
+   */
+  @Test
+  public void tlsNegotiationServerExecutorShouldSucceed() throws Exception {
+    // initialize the client and server Executor pool
+    TrackingObjectPoolForTest serverExecutorPool = new TrackingObjectPoolForTest();
+    TrackingObjectPoolForTest clientExecutorPool = new TrackingObjectPoolForTest();
+    assertEquals(false, serverExecutorPool.isInUse());
+    assertEquals(false, clientExecutorPool.isInUse());
+
+    InputStream serverCert = TlsTesting.loadCert("server1.pem");
+    InputStream serverKey = TlsTesting.loadCert("server1.key");
+    SslContext sslContext = GrpcSslContexts.forServer(serverCert, serverKey)
+        .clientAuth(ClientAuth.NONE)
+        .build();
+    negotiator = ProtocolNegotiators.serverTls(sslContext, serverExecutorPool);
+    startServer();
+    // after starting the server, the Executor in the server pool should be used
+    assertEquals(true, serverExecutorPool.isInUse());
+
+    InputStream caCert = TlsTesting.loadCert("ca.pem");
+    InputStream clientCert = TlsTesting.loadCert("client.pem");
+    InputStream clientKey = TlsTesting.loadCert("client.key");
+    SslContext clientContext = GrpcSslContexts.forClient()
+        .trustManager(caCert)
+        .keyManager(clientCert, clientKey)
+        .build();
+    ProtocolNegotiator negotiator = ProtocolNegotiators.tls(clientContext, clientExecutorPool,
+        Optional.absent(), null, null);
+    // after starting the client, the Executor in the client pool should be used
+    assertEquals(true, clientExecutorPool.isInUse());
+    final NettyClientTransport transport = newTransport(negotiator);
+    callMeMaybe(transport.start(clientTransportListener));
+    verify(clientTransportListener, timeout(5000)).transportReady();
+    Rpc rpc = new Rpc(transport).halfClose();
+    rpc.waitForResponse();
+    // closing the negotiators should return the executors back to pool, and release the resource
+    negotiator.close();
+    assertEquals(false, clientExecutorPool.isInUse());
+    this.negotiator.close();
+    assertEquals(false, serverExecutorPool.isInUse());
+  }
+
+  /**
+   * This test tests the case of TlsCredentials passed to ProtocolNegotiators not having an instance
+   * of X509ExtendedTrustManager (this is not testable in ProtocolNegotiatorsTest without creating
+   * accessors for the internal state of negotiator whether it has a X509ExtendedTrustManager,
+   * hence the need to test it in this class instead). To establish a successful handshake we create
+   * a fake X509TrustManager not implementing X509ExtendedTrustManager but wraps the real
+   * X509ExtendedTrustManager.
+   */
+  @Test
+  public void authorityOverrideInCallOptions_noX509ExtendedTrustManager_newStreamCreationFails()
+          throws IOException, InterruptedException, GeneralSecurityException, ExecutionException,
+          TimeoutException {
+    NettyClientHandler.enablePerRpcAuthorityCheck = true;
+    try {
+      startServer();
+      InputStream caCert = TlsTesting.loadCert("ca.pem");
+      X509TrustManager x509ExtendedTrustManager =
+              (X509TrustManager) getX509ExtendedTrustManager(caCert);
+      ProtocolNegotiators.FromChannelCredentialsResult result =
+              ProtocolNegotiators.from(TlsChannelCredentials.newBuilder()
+                      .trustManager(new FakeTrustManager(x509ExtendedTrustManager)).build());
+      NettyClientTransport transport = newTransport(result.negotiator.newNegotiator());
+      SettableFuture<Void> connected = SettableFuture.create();
+      FakeClientTransportListener fakeClientTransportListener =
+              new FakeClientTransportListener(connected);
+      callMeMaybe(transport.start(fakeClientTransportListener));
+      connected.get(10, TimeUnit.SECONDS);
+      assertThat(fakeClientTransportListener.isConnected()).isTrue();
+
+      Rpc rpc = new Rpc(transport, new Metadata(), "foo.test.google.in");
+      try {
+        rpc.waitForClose();
+        fail("Expected exception in starting stream");
+      } catch (ExecutionException ex) {
+        Status status = ((StatusException) ex.getCause()).getStatus();
+        assertThat(status.getDescription()).isEqualTo("Can't allow authority override in rpc "
+                + "when X509ExtendedTrustManager is not available");
+        assertThat(status.getCode()).isEqualTo(Code.UNAVAILABLE);
+      }
+    } finally {
+      NettyClientHandler.enablePerRpcAuthorityCheck = false;
+    }
+  }
+
+  @Test
+  public void authorityOverrideInCallOptions_doesntMatchServerPeerHost_newStreamCreationFails()
+          throws IOException, InterruptedException, GeneralSecurityException, ExecutionException,
+          TimeoutException {
+    NettyClientHandler.enablePerRpcAuthorityCheck = true;
+    try {
+      startServer();
+      NettyClientTransport transport = newTransport(newNegotiator());
+      SettableFuture<Void> connected = SettableFuture.create();
+      FakeClientTransportListener fakeClientTransportListener =
+              new FakeClientTransportListener(connected);
+      callMeMaybe(transport.start(fakeClientTransportListener));
+      connected.get(10, TimeUnit.SECONDS);
+      assertThat(fakeClientTransportListener.isConnected()).isTrue();
+
+      Rpc rpc = new Rpc(transport, new Metadata(), "foo.test.google.in");
+      try {
+        rpc.waitForClose();
+        fail("Expected exception in starting stream");
+      } catch (ExecutionException ex) {
+        Status status = ((StatusException) ex.getCause()).getStatus();
+        assertThat(status.getDescription()).isEqualTo("Peer hostname verification during rpc "
+                + "failed for authority 'foo.test.google.in'");
+        assertThat(status.getCode()).isEqualTo(Code.UNAVAILABLE);
+        assertThat(((InvocationTargetException) ex.getCause().getCause()).getTargetException())
+                .isInstanceOf(CertificateException.class);
+        assertThat(((InvocationTargetException) ex.getCause().getCause()).getTargetException()
+                .getMessage()).isEqualTo(
+                "No subject alternative DNS name matching foo.test.google.in found.");
+      }
+    } finally {
+      NettyClientHandler.enablePerRpcAuthorityCheck = false;
+    }
+  }
+
+  @Test
+  public void authorityOverrideInCallOptions_matchesServerPeerHost_newStreamCreationSucceeds()
+          throws IOException, InterruptedException, GeneralSecurityException, ExecutionException,
+          TimeoutException {
+    NettyClientHandler.enablePerRpcAuthorityCheck = true;
+    try {
+      startServer();
+      NettyClientTransport transport = newTransport(newNegotiator());
+      SettableFuture<Void> connected = SettableFuture.create();
+      FakeClientTransportListener fakeClientTransportListener =
+              new FakeClientTransportListener(connected);
+      callMeMaybe(transport.start(fakeClientTransportListener));
+      connected.get(10, TimeUnit.SECONDS);
+      assertThat(fakeClientTransportListener.isConnected()).isTrue();
+
+      new Rpc(transport, new Metadata(), "foo.test.google.fr").waitForResponse();
+    } finally {
+      NettyClientHandler.enablePerRpcAuthorityCheck = false;;
+    }
+  }
+
+  // Without removing the port number part that {@link X509AuthorityVerifier} does, there will be a
+  // java.security.cert.CertificateException: Illegal given domain name: foo.test.google.fr:12345
+  @Test
+  public void authorityOverrideInCallOptions_portNumberInAuthority_isStrippedForPeerVerification()
+      throws IOException, InterruptedException, GeneralSecurityException, ExecutionException,
+      TimeoutException {
+    NettyClientHandler.enablePerRpcAuthorityCheck = true;
+    try {
+      startServer();
+      NettyClientTransport transport = newTransport(newNegotiator());
+      SettableFuture<Void> connected = SettableFuture.create();
+      FakeClientTransportListener fakeClientTransportListener =
+          new FakeClientTransportListener(connected);
+      callMeMaybe(transport.start(fakeClientTransportListener));
+      connected.get(10, TimeUnit.SECONDS);
+      assertThat(fakeClientTransportListener.isConnected()).isTrue();
+
+      new Rpc(transport, new Metadata(), "foo.test.google.fr:12345").waitForResponse();
+    } finally {
+      NettyClientHandler.enablePerRpcAuthorityCheck = false;;
+    }
+  }
+
+  @Test
+  public void authorityOverrideInCallOptions_portNumberAndIpv6_isStrippedForPeerVerification()
+      throws IOException, InterruptedException, GeneralSecurityException, ExecutionException,
+      TimeoutException {
+    NettyClientHandler.enablePerRpcAuthorityCheck = true;
+    try {
+      startServer();
+      NettyClientTransport transport = newTransport(newNegotiator());
+      SettableFuture<Void> connected = SettableFuture.create();
+      FakeClientTransportListener fakeClientTransportListener =
+          new FakeClientTransportListener(connected);
+      callMeMaybe(transport.start(fakeClientTransportListener));
+      connected.get(10, TimeUnit.SECONDS);
+      assertThat(fakeClientTransportListener.isConnected()).isTrue();
+
+      new Rpc(transport, new Metadata(), "[2001:db8:3333:4444:5555:6666:1.2.3.4]:12345")
+          .waitForResponse();
+    } catch (ExecutionException ex) {
+      Status status = ((StatusException) ex.getCause()).getStatus();
+      assertThat(status.getDescription()).isEqualTo("Peer hostname verification during rpc "
+          + "failed for authority '[2001:db8:3333:4444:5555:6666:1.2.3.4]:12345'");
+      assertThat(status.getCode()).isEqualTo(Code.UNAVAILABLE);
+      assertThat(((InvocationTargetException) ex.getCause().getCause()).getTargetException())
+          .isInstanceOf(CertificateException.class);
+      // Port number is removed by {@link X509AuthorityVerifier}.
+      assertThat(((InvocationTargetException) ex.getCause().getCause()).getTargetException()
+          .getMessage()).isEqualTo(
+          "No subject alternative names matching IP address 2001:db8:3333:4444:5555:6666:1.2.3.4 "
+              + "found");
+    } finally {
+      NettyClientHandler.enablePerRpcAuthorityCheck = false;;
+    }
+  }
+
+  @Test
+  public void authorityOverrideInCallOptions_notMatches_flagDisabled_createsStream()
+          throws IOException, InterruptedException, GeneralSecurityException, ExecutionException,
+          TimeoutException {
+    startServer();
+    NettyClientTransport transport = newTransport(newNegotiator());
+    SettableFuture<Void> connected = SettableFuture.create();
+    FakeClientTransportListener fakeClientTransportListener =
+            new FakeClientTransportListener(connected);
+    callMeMaybe(transport.start(fakeClientTransportListener));
+    connected.get(10, TimeUnit.SECONDS);
+    assertThat(fakeClientTransportListener.isConnected()).isTrue();
+
+    new Rpc(transport, new Metadata(), "foo.test.google.in").waitForResponse();
+  }
+
   private Throwable getRootCause(Throwable t) {
     if (t.getCause() == null) {
       return t;
@@ -376,11 +1073,37 @@ private Throwable getRootCause(Throwable t) {
     return getRootCause(t.getCause());
   }
 
-  private ProtocolNegotiator newNegotiator() throws IOException {
-    File clientCert = TestUtils.loadCert("ca.pem");
-    SslContext clientContext = GrpcSslContexts.forClient().trustManager(clientCert)
-        .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE).build();
-    return ProtocolNegotiators.tls(clientContext, authority);
+  private ProtocolNegotiator newNegotiator() throws IOException, GeneralSecurityException {
+    InputStream caCert = TlsTesting.loadCert("ca.pem");
+    SslContext clientContext = GrpcSslContexts.forClient().trustManager(caCert).build();
+    return ProtocolNegotiators.tls(clientContext,
+        (X509TrustManager) getX509ExtendedTrustManager(TlsTesting.loadCert("ca.pem")));
+  }
+
+  private static TrustManager getX509ExtendedTrustManager(InputStream rootCerts)
+      throws GeneralSecurityException {
+    KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
+    try {
+      ks.load(null, null);
+    } catch (IOException ex) {
+      // Shouldn't really happen, as we're not loading any data.
+      throw new GeneralSecurityException(ex);
+    }
+    X509Certificate[] certs = CertificateUtils.getX509Certificates(rootCerts);
+    for (X509Certificate cert : certs) {
+      X500Principal principal = cert.getSubjectX500Principal();
+      ks.setCertificateEntry(principal.getName("RFC2253"), cert);
+    }
+
+    TrustManagerFactory trustManagerFactory =
+        TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+    trustManagerFactory.init(ks);
+    for (TrustManager trustManager : trustManagerFactory.getTrustManagers()) {
+      if (trustManager instanceof X509ExtendedTrustManager) {
+        return trustManager;
+      }
+    }
+    return null;
   }
 
   private NettyClientTransport newTransport(ProtocolNegotiator negotiator) {
@@ -390,12 +1113,42 @@ private NettyClientTransport newTransport(ProtocolNegotiator negotiator) {
 
   private NettyClientTransport newTransport(ProtocolNegotiator negotiator, int maxMsgSize,
       int maxHeaderListSize, String userAgent, boolean enableKeepAlive) {
-    NettyClientTransport transport = new NettyClientTransport(
-        address, NioSocketChannel.class, new HashMap<ChannelOption<?>, Object>(), group, negotiator,
-        DEFAULT_WINDOW_SIZE, maxMsgSize, maxHeaderListSize, authority, userAgent);
-    if (enableKeepAlive) {
-      transport.enableKeepAlive(true, 1000, 1000);
+    return newTransport(negotiator, maxMsgSize, maxHeaderListSize, userAgent, enableKeepAlive,
+        TimeUnit.SECONDS.toNanos(10L), TimeUnit.SECONDS.toNanos(1L),
+        new ReflectiveChannelFactory<>(NioSocketChannel.class), group);
+  }
+
+  private NettyClientTransport newTransport(ProtocolNegotiator negotiator, int maxMsgSize,
+      int maxHeaderListSize, String userAgent, boolean enableKeepAlive, long keepAliveTimeNano,
+      long keepAliveTimeoutNano, ChannelFactory<? extends Channel> channelFactory,
+      EventLoopGroup group) {
+    if (!enableKeepAlive) {
+      keepAliveTimeNano = KEEPALIVE_TIME_NANOS_DISABLED;
     }
+    NettyClientTransport transport =
+        new NettyClientTransport(
+            address,
+            channelFactory,
+            new HashMap<ChannelOption<?>, Object>(),
+            group,
+            negotiator,
+            false,
+            DEFAULT_WINDOW_SIZE,
+            maxMsgSize,
+            maxHeaderListSize,
+            maxHeaderListSize,
+            keepAliveTimeNano,
+            keepAliveTimeoutNano,
+            false,
+            authority,
+            userAgent,
+            tooManyPingsRunnable,
+            new TransportTracer(),
+            eagAttributes,
+            new SocketPicker(),
+            new FakeChannelLogger(),
+            false,
+            Ticker.systemTicker());
     transports.add(transport);
     return transport;
   }
@@ -404,17 +1157,47 @@ private void startServer() throws IOException {
     startServer(100, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE);
   }
 
+  private void startServer(ServerListener serverListener) throws IOException {
+    startServer(100, GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE, serverListener);
+  }
+
   private void startServer(int maxStreamsPerConnection, int maxHeaderListSize) throws IOException {
-    File serverCert = TestUtils.loadCert("server1.pem");
-    File key = TestUtils.loadCert("server1.key");
-    SslContext serverContext = GrpcSslContexts.forServer(serverCert, key)
-        .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE).build();
-    ProtocolNegotiator negotiator = ProtocolNegotiators.serverTls(serverContext);
-    server = new NettyServer(TestUtils.testServerAddress(0),
-        NioServerSocketChannel.class, group, group, negotiator,
-        maxStreamsPerConnection, DEFAULT_WINDOW_SIZE, DEFAULT_MAX_MESSAGE_SIZE, maxHeaderListSize);
+    startServer(maxStreamsPerConnection, maxHeaderListSize, serverListener);
+  }
+
+  private void startServer(int maxStreamsPerConnection, int maxHeaderListSize,
+      ServerListener serverListener) throws IOException {
+    server =
+        new NettyServer(
+            TestUtils.testServerAddresses(new InetSocketAddress(0)),
+            new ReflectiveChannelFactory<>(NioServerSocketChannel.class),
+            new HashMap<ChannelOption<?>, Object>(),
+            new HashMap<ChannelOption<?>, Object>(),
+            new FixedObjectPool<>(group),
+            new FixedObjectPool<>(group),
+            false,
+            negotiator,
+            Collections.<ServerStreamTracer.Factory>emptyList(),
+            TransportTracer.getDefaultFactory(),
+            maxStreamsPerConnection,
+            false,
+            DEFAULT_WINDOW_SIZE,
+            DEFAULT_MAX_MESSAGE_SIZE,
+            maxHeaderListSize,
+            maxHeaderListSize,
+            DEFAULT_SERVER_KEEPALIVE_TIME_NANOS,
+            DEFAULT_SERVER_KEEPALIVE_TIMEOUT_NANOS,
+            MAX_CONNECTION_IDLE_NANOS_DISABLED,
+            MAX_CONNECTION_AGE_NANOS_DISABLED,
+            MAX_CONNECTION_AGE_GRACE_NANOS_INFINITE,
+            true,
+            0,
+            MAX_RST_COUNT_DISABLED,
+            0,
+            Attributes.EMPTY,
+            channelz);
     server.start(serverListener);
-    address = TestUtils.testServerAddress(server.getPort());
+    address = TestUtils.testServerAddress((InetSocketAddress) server.getListenSocketAddress());
     authority = GrpcUtil.authorityFromHostAndPort(address.getHostString(), address.getPort());
   }
 
@@ -424,12 +1207,22 @@ private void callMeMaybe(Runnable r) {
     }
   }
 
+  private static SslContext createSslContext() {
+    try {
+      InputStream serverCert = TlsTesting.loadCert("server1.pem");
+      InputStream key = TlsTesting.loadCert("server1.key");
+      return GrpcSslContexts.forServer(serverCert, key).build();
+    } catch (IOException ex) {
+      throw new RuntimeException(ex);
+    }
+  }
+
   private static class Rpc {
     static final String MESSAGE = "hello";
     static final MethodDescriptor<String, String> METHOD =
         MethodDescriptor.<String, String>newBuilder()
             .setType(MethodDescriptor.MethodType.UNARY)
-            .setFullMethodName("/testService/test")
+            .setFullMethodName("testService/test")
             .setRequestMarshaller(StringMarshaller.INSTANCE)
             .setResponseMarshaller(StringMarshaller.INSTANCE)
             .build();
@@ -438,11 +1231,20 @@ private static class Rpc {
     final TestClientStreamListener listener = new TestClientStreamListener();
 
     Rpc(NettyClientTransport transport) {
-      this(transport, new Metadata());
+      this(transport, new Metadata(), null);
     }
 
     Rpc(NettyClientTransport transport, Metadata headers) {
-      stream = transport.newStream(METHOD, headers);
+      this(transport, headers, null);
+    }
+
+    Rpc(NettyClientTransport transport, Metadata headers, String authorityOverride) {
+      stream = transport.newStream(
+          METHOD, headers, CallOptions.DEFAULT,
+          new ClientStreamTracer[]{ new ClientStreamTracer() {} });
+      if (authorityOverride != null) {
+        stream.setAuthority(authorityOverride);
+      }
       stream.start(listener);
       stream.request(1);
       stream.writeMessage(new ByteArrayInputStream(MESSAGE.getBytes(UTF_8)));
@@ -472,7 +1274,7 @@ public void headersRead(Metadata headers) {
     }
 
     @Override
-    public void closed(Status status, Metadata trailers) {
+    public void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {
       if (status.isOk()) {
         closedFuture.set(null);
       } else {
@@ -483,8 +1285,10 @@ public void closed(Status status, Metadata trailers) {
     }
 
     @Override
-    public void messageRead(InputStream message) {
-      responseFuture.set(null);
+    public void messagesAvailable(MessageProducer producer) {
+      if (producer.next() != null) {
+        responseFuture.set(null);
+      }
     }
 
     @Override
@@ -494,22 +1298,21 @@ public void onReady() {
 
   private static final class EchoServerStreamListener implements ServerStreamListener {
     final ServerStream stream;
-    final String method;
     final Metadata headers;
 
-    EchoServerStreamListener(ServerStream stream, String method, Metadata headers) {
+    EchoServerStreamListener(ServerStream stream, Metadata headers) {
       this.stream = stream;
-      this.method = method;
       this.headers = headers;
-      stream.writeHeaders(new Metadata());
-      stream.request(1);
     }
 
     @Override
-    public void messageRead(InputStream message) {
-      // Just echo back the message.
-      stream.writeMessage(message);
-      stream.flush();
+    public void messagesAvailable(MessageProducer producer) {
+      InputStream message;
+      while ((message = producer.next()) != null) {
+        // Just echo back the message.
+        stream.writeMessage(message);
+        stream.flush();
+      }
     }
 
     @Override
@@ -527,35 +1330,41 @@ public void closed(Status status) {
     }
   }
 
-  private static final class EchoServerListener implements ServerListener {
-    final List<NettyServerTransport> transports = new ArrayList<NettyServerTransport>();
+  private final class EchoServerListener implements ServerListener {
+    final List<NettyServerTransport> transports = new ArrayList<>();
     final List<EchoServerStreamListener> streamListeners =
             Collections.synchronizedList(new ArrayList<EchoServerStreamListener>());
+    Metadata responseHeaders;
+
+    public EchoServerListener() {
+      this(new Metadata());
+    }
+
+    public EchoServerListener(Metadata responseHeaders) {
+      this.responseHeaders = responseHeaders;
+    }
 
     @Override
     public ServerTransportListener transportCreated(final ServerTransport transport) {
       transports.add((NettyServerTransport) transport);
       return new ServerTransportListener() {
-        @Override
-        public StatsTraceContext methodDetermined(String method, Metadata headers) {
-          return StatsTraceContext.NOOP;
-        }
-
         @Override
         public void streamCreated(ServerStream stream, String method, Metadata headers) {
-          EchoServerStreamListener listener = new EchoServerStreamListener(stream, method, headers);
+          EchoServerStreamListener listener = new EchoServerStreamListener(stream, headers);
           stream.setListener(listener);
+          stream.writeHeaders(responseHeaders, true);
+          stream.request(1);
           streamListeners.add(listener);
         }
 
         @Override
         public Attributes transportReady(Attributes transportAttrs) {
+          serverTransportAttributesList.add(transportAttrs);
           return transportAttrs;
         }
 
         @Override
-        public void transportTerminated() {
-        }
+        public void transportTerminated() {}
       };
     }
 
@@ -581,4 +1390,123 @@ public String parse(InputStream stream) {
       }
     }
   }
+
+  private static class NoopHandler extends ChannelDuplexHandler {
+
+    private final GrpcHttp2ConnectionHandler grpcHandler;
+
+    public NoopHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+      this.grpcHandler = grpcHandler;
+    }
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) {
+      // Prevent any data being passed to NettyClientHandler
+      ReferenceCountUtil.release(msg);
+    }
+
+    @Override
+    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
+      ctx.pipeline().addAfter(ctx.name(), null, grpcHandler);
+    }
+
+    public void fail(ChannelHandlerContext ctx, Throwable cause) {
+      ctx.fireExceptionCaught(cause);
+    }
+  }
+
+  private static class NoopProtocolNegotiator implements ProtocolNegotiator {
+    GrpcHttp2ConnectionHandler grpcHandler;
+    NoopHandler handler;
+
+    @Override
+    public ChannelHandler newHandler(final GrpcHttp2ConnectionHandler grpcHandler) {
+      this.grpcHandler = grpcHandler;
+      return handler = new NoopHandler(grpcHandler);
+    }
+
+    @Override
+    public AsciiString scheme() {
+      return Utils.HTTP;
+    }
+
+    @Override
+    public void close() {}
+  }
+
+  private static final class SocketPicker extends LocalSocketPicker {
+
+    @Nullable
+    @Override
+    public SocketAddress createSocketAddress(SocketAddress remoteAddress, Attributes attrs) {
+      return null;
+    }
+  }
+
+  private static final class FakeChannelLogger extends ChannelLogger {
+
+    @Override
+    public void log(ChannelLogLevel level, String message) {}
+
+    @Override
+    public void log(ChannelLogLevel level, String messageFormat, Object... args) {}
+  }
+
+  static class FakeClientTransportListener implements ManagedClientTransport.Listener {
+    private final SettableFuture<Void> connected;
+
+    @GuardedBy("this")
+    private boolean isConnected = false;
+
+    public FakeClientTransportListener(SettableFuture<Void> connected) {
+      this.connected = connected;
+    }
+
+    @Override
+    public void transportShutdown(Status s, DisconnectError e) {}
+
+    @Override
+    public void transportTerminated() {}
+
+    @Override
+    public void transportReady() {
+      synchronized (this) {
+        isConnected = true;
+      }
+      connected.set(null);
+    }
+
+    synchronized boolean isConnected() {
+      return isConnected;
+    }
+
+    @Override
+    public void transportInUse(boolean inUse) {}
+  }
+
+  private static class FakeTrustManager implements X509TrustManager {
+
+    private final X509TrustManager delegate;
+
+    public FakeTrustManager(X509TrustManager x509ExtendedTrustManager) {
+      this.delegate = x509ExtendedTrustManager;
+    }
+
+    @Override
+    public void checkClientTrusted(X509Certificate[] x509Certificates, String s)
+        throws CertificateException {
+      delegate.checkClientTrusted(x509Certificates, s);
+    }
+
+    @Override
+    public void checkServerTrusted(X509Certificate[] x509Certificates, String s)
+        throws CertificateException {
+      delegate.checkServerTrusted(x509Certificates, s);
+    }
+
+    @Override
+    public X509Certificate[] getAcceptedIssuers() {
+      return delegate.getAcceptedIssuers();
+    }
+  }
 }
diff --git a/netty/src/test/java/io/grpc/netty/NettyHandlerTestBase.java b/netty/src/test/java/io/grpc/netty/NettyHandlerTestBase.java
index a16db1413d3..c971294fbb6 100644
--- a/netty/src/test/java/io/grpc/netty/NettyHandlerTestBase.java
+++ b/netty/src/test/java/io/grpc/netty/NettyHandlerTestBase.java
@@ -1,76 +1,80 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
-import static com.google.common.base.Charsets.UTF_8;
+import static io.netty.handler.codec.http2.Http2CodecUtil.DEFAULT_WINDOW_SIZE;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import io.grpc.InternalChannelz.TransportStats;
+import io.grpc.internal.AbstractStream;
+import io.grpc.internal.FakeClock;
 import io.grpc.internal.MessageFramer;
 import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.TransportTracer;
 import io.grpc.internal.WritableBuffer;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
-import io.netty.buffer.ByteBufUtil;
 import io.netty.buffer.CompositeByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.buffer.UnpooledByteBufAllocator;
 import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelPromise;
 import io.netty.channel.EventLoop;
 import io.netty.channel.embedded.EmbeddedChannel;
 import io.netty.handler.codec.http2.DefaultHttp2FrameReader;
 import io.netty.handler.codec.http2.DefaultHttp2FrameWriter;
+import io.netty.handler.codec.http2.Http2CodecUtil;
 import io.netty.handler.codec.http2.Http2Connection;
 import io.netty.handler.codec.http2.Http2ConnectionHandler;
 import io.netty.handler.codec.http2.Http2Exception;
 import io.netty.handler.codec.http2.Http2FrameReader;
 import io.netty.handler.codec.http2.Http2FrameWriter;
 import io.netty.handler.codec.http2.Http2Headers;
+import io.netty.handler.codec.http2.Http2HeadersDecoder;
 import io.netty.handler.codec.http2.Http2LocalFlowController;
 import io.netty.handler.codec.http2.Http2Settings;
 import io.netty.handler.codec.http2.Http2Stream;
+import io.netty.util.concurrent.DefaultPromise;
+import io.netty.util.concurrent.Promise;
+import io.netty.util.concurrent.ScheduledFuture;
 import java.io.ByteArrayInputStream;
+import java.nio.ByteBuffer;
+import java.util.concurrent.Delayed;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
 import org.mockito.verification.VerificationMode;
 
 /**
@@ -79,7 +83,7 @@
 @RunWith(JUnit4.class)
 public abstract class NettyHandlerTestBase<T extends Http2ConnectionHandler> {
 
-  private ByteBuf content;
+  protected static final int STREAM_ID = 3;
 
   private EmbeddedChannel channel;
 
@@ -93,22 +97,126 @@ public abstract class NettyHandlerTestBase<T extends Http2ConnectionHandler> {
 
   private WriteQueue writeQueue;
 
+  /**
+   * Does additional setup jobs. Call it manually when necessary.
+   */
+  protected void manualSetUp() throws Exception {}
+
+  protected final TransportTracer transportTracer = new TransportTracer();
+  protected int flowControlWindow = DEFAULT_WINDOW_SIZE;
+  protected boolean autoFlowControl = false;
+  private final FakeClock fakeClock = new FakeClock();
+
+  FakeClock fakeClock() {
+    return fakeClock;
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    if (channel() != null) {
+      channel().releaseInbound();
+      channel().releaseOutbound();
+    }
+  }
+
   /**
    * Must be called by subclasses to initialize the handler and channel.
    */
-  protected final void initChannel(GrpcHttp2HeadersDecoder headersDecoder) throws Exception {
-    content = Unpooled.copiedBuffer("hello world", UTF_8);
-    frameWriter = spy(new DefaultHttp2FrameWriter());
+  protected final void initChannel(Http2HeadersDecoder headersDecoder) throws Exception {
+    frameWriter = mock(Http2FrameWriter.class, delegatesTo(new DefaultHttp2FrameWriter()));
     frameReader = new DefaultHttp2FrameReader(headersDecoder);
 
+    channel = new FakeClockSupportedChanel();
     handler = newHandler();
-
-    channel = new EmbeddedChannel(handler);
+    channel.pipeline().addLast(handler);
     ctx = channel.pipeline().context(handler);
 
     writeQueue = initWriteQueue();
   }
 
+  private final class FakeClockSupportedChanel extends EmbeddedChannel {
+    EventLoop eventLoop;
+
+    FakeClockSupportedChanel(ChannelHandler... handlers) {
+      super(handlers);
+    }
+
+    @Override
+    public EventLoop eventLoop() {
+      if (eventLoop == null) {
+        createEventLoop();
+      }
+      return eventLoop;
+    }
+
+    void createEventLoop() {
+      EventLoop realEventLoop = super.eventLoop();
+      if (realEventLoop == null) {
+        return;
+      }
+      eventLoop = mock(EventLoop.class, delegatesTo(realEventLoop));
+      doAnswer(
+          new Answer<ScheduledFuture<Void>>() {
+            @Override
+            public ScheduledFuture<Void> answer(InvocationOnMock invocation) throws Throwable {
+              Runnable command = (Runnable) invocation.getArguments()[0];
+              Long delay = (Long) invocation.getArguments()[1];
+              TimeUnit timeUnit = (TimeUnit) invocation.getArguments()[2];
+              return new FakeClockScheduledNettyFuture(eventLoop, command, delay, timeUnit);
+            }
+          }).when(eventLoop).schedule(any(Runnable.class), anyLong(), any(TimeUnit.class));
+    }
+  }
+
+  private final class FakeClockScheduledNettyFuture extends DefaultPromise<Void>
+      implements ScheduledFuture<Void> {
+    final java.util.concurrent.ScheduledFuture<?> future;
+
+    FakeClockScheduledNettyFuture(
+        EventLoop eventLoop, final Runnable command, long delay, TimeUnit timeUnit) {
+      super(eventLoop);
+      Runnable wrap = new Runnable() {
+        @Override
+        public void run() {
+          try {
+            command.run();
+          } catch (Throwable t) {
+            setFailure(t);
+            return;
+          }
+          if (!isDone()) {
+            Promise<Void> unused = setSuccess(null);
+          }
+          // else: The command itself, such as a shutdown task, might have cancelled all the
+          // scheduled tasks already.
+        }
+      };
+      future = fakeClock.getScheduledExecutorService().schedule(wrap, delay, timeUnit);
+    }
+
+    @Override
+    public boolean cancel(boolean mayInterruptIfRunning) {
+      if (future.cancel(mayInterruptIfRunning)) {
+        return super.cancel(mayInterruptIfRunning);
+      }
+      return false;
+    }
+
+    @Override
+    public long getDelay(TimeUnit unit) {
+      return Math.max(future.getDelay(unit), 1L); // never return zero or negative delay.
+    }
+
+    @Override
+    public int compareTo(Delayed o) {
+      return future.compareTo(o);
+    }
+  }
+
+  protected final WriteQueue writeQueue() {
+    return writeQueue;
+  }
+
   protected final T handler() {
     return handler;
   }
@@ -130,11 +238,11 @@ protected final Http2FrameReader frameReader() {
   }
 
   protected final ByteBuf content() {
-    return content;
+    return Unpooled.copiedBuffer(contentAsArray());
   }
 
   protected final byte[] contentAsArray() {
-    return ByteBufUtil.getBytes(content());
+    return "\000\000\000\000\rhello world".getBytes(UTF_8);
   }
 
   protected final Http2FrameWriter verifyWrite() {
@@ -146,41 +254,41 @@ protected final Http2FrameWriter verifyWrite(VerificationMode verificationMode)
   }
 
   protected final void channelRead(Object obj) throws Exception {
-    handler().channelRead(ctx, obj);
+    channel.writeInbound(obj);
   }
 
-  protected ByteBuf grpcDataFrame(int streamId, boolean endStream, byte[] content) {
-    final ByteBuf compressionFrame = Unpooled.buffer(content.length);
-    MessageFramer framer = new MessageFramer(new MessageFramer.Sink() {
-      @Override
-      public void deliverFrame(WritableBuffer frame, boolean endOfStream, boolean flush) {
-        if (frame != null) {
-          ByteBuf bytebuf = ((NettyWritableBuffer) frame).bytebuf();
-          compressionFrame.writeBytes(bytebuf);
-        }
-      }
-    }, new NettyWritableBufferAllocator(ByteBufAllocator.DEFAULT), StatsTraceContext.NOOP);
-    framer.writePayload(new ByteArrayInputStream(content));
-    framer.flush();
-    ChannelHandlerContext ctx = newMockContext();
-    new DefaultHttp2FrameWriter().writeData(ctx, streamId, compressionFrame, 0, endStream,
-        newPromise());
-    return captureWrite(ctx);
+  protected ByteBuf grpcFrame(byte[] message) {
+    final ByteBuf compressionFrame = Unpooled.buffer(message.length);
+    MessageFramer framer = new MessageFramer(
+        new MessageFramer.Sink() {
+          @Override
+          public void deliverFrame(
+              WritableBuffer frame, boolean endOfStream, boolean flush, int numMessages) {
+            if (frame != null) {
+              ByteBuf bytebuf = ((NettyWritableBuffer) frame).bytebuf();
+              compressionFrame.writeBytes(bytebuf);
+              bytebuf.release();
+            }
+          }
+        },
+        new NettyWritableBufferAllocator(ByteBufAllocator.DEFAULT),
+        StatsTraceContext.NOOP);
+    framer.writePayload(new ByteArrayInputStream(message));
+    framer.close();
+    return compressionFrame;
   }
 
-  protected final ByteBuf dataFrame(int streamId, boolean endStream, ByteBuf content) {
-    // Need to retain the content since the frameWriter releases it.
-    content.retain();
+  protected final ByteBuf grpcDataFrame(int streamId, boolean endStream, byte[] content) {
+    return dataFrame(streamId, endStream, grpcFrame(content));
+  }
 
+  protected final ByteBuf dataFrame(int streamId, boolean endStream, ByteBuf content) {
     ChannelHandlerContext ctx = newMockContext();
     new DefaultHttp2FrameWriter().writeData(ctx, streamId, content, 0, endStream, newPromise());
     return captureWrite(ctx);
   }
 
-  protected final ByteBuf pingFrame(boolean ack, ByteBuf payload) {
-    // Need to retain the content since the frameWriter releases it.
-    payload.retain();
-
+  protected final ByteBuf pingFrame(boolean ack, long payload) {
     ChannelHandlerContext ctx = newMockContext();
     new DefaultHttp2FrameWriter().writePing(ctx, ack, payload, newPromise());
     return captureWrite(ctx);
@@ -214,6 +322,12 @@ protected final ByteBuf serializeSettings(Http2Settings settings) {
     return captureWrite(ctx);
   }
 
+  protected final ByteBuf windowUpdate(int streamId, int delta) {
+    ChannelHandlerContext ctx = newMockContext();
+    new DefaultHttp2FrameWriter().writeWindowUpdate(ctx, streamId, delta, newPromise());
+    return captureWrite(ctx);
+  }
+
   protected final ChannelPromise newPromise() {
     return channel.newPromise();
   }
@@ -222,18 +336,21 @@ protected final Http2Connection connection() {
     return handler().connection();
   }
 
+  protected abstract AbstractStream stream() throws Exception;
+
   @CanIgnoreReturnValue
   protected final ChannelFuture enqueue(WriteQueue.QueuedCommand command) {
-    ChannelFuture future = writeQueue.enqueue(command, newPromise(), true);
+    ChannelFuture future = writeQueue.enqueue(command, true);
     channel.runPendingTasks();
     return future;
   }
 
   protected final ChannelHandlerContext newMockContext() {
-    ChannelHandlerContext ctx = Mockito.mock(ChannelHandlerContext.class);
+    ChannelHandlerContext ctx = mock(ChannelHandlerContext.class);
     when(ctx.alloc()).thenReturn(UnpooledByteBufAllocator.DEFAULT);
-    EventLoop eventLoop = Mockito.mock(EventLoop.class);
+    EventLoop eventLoop = mock(EventLoop.class);
     when(ctx.executor()).thenReturn(eventLoop);
+    when(ctx.channel()).thenReturn(channel);
     return ctx;
   }
 
@@ -256,6 +373,7 @@ protected final ByteBuf captureWrite(ChannelHandlerContext ctx) {
 
   @Test
   public void dataPingSentOnHeaderRecieved() throws Exception {
+    manualSetUp();
     makeStream();
     AbstractNettyHandler handler = (AbstractNettyHandler) handler();
     handler.setAutoTuneFlowControl(true);
@@ -267,15 +385,14 @@ public void dataPingSentOnHeaderRecieved() throws Exception {
 
   @Test
   public void dataPingAckIsRecognized() throws Exception {
+    manualSetUp();
     makeStream();
     AbstractNettyHandler handler = (AbstractNettyHandler) handler();
     handler.setAutoTuneFlowControl(true);
 
     channelRead(dataFrame(3, false, content()));
     long pingData = handler.flowControlPing().payload();
-    ByteBuf payload = handler.ctx().alloc().buffer(8);
-    payload.writeLong(pingData);
-    channelRead(pingFrame(true, payload));
+    channelRead(pingFrame(true, pingData));
 
     assertEquals(1, handler.flowControlPing().getPingCount());
     assertEquals(1, handler.flowControlPing().getPingReturn());
@@ -283,6 +400,7 @@ public void dataPingAckIsRecognized() throws Exception {
 
   @Test
   public void dataSizeSincePingAccumulates() throws Exception {
+    manualSetUp();
     makeStream();
     AbstractNettyHandler handler = (AbstractNettyHandler) handler();
     handler.setAutoTuneFlowControl(true);
@@ -296,33 +414,30 @@ public void dataSizeSincePingAccumulates() throws Exception {
     channelRead(dataFrame(3, false, buff.copy()));
 
     assertEquals(length * 3, handler.flowControlPing().getDataSincePing());
+    buff.release();
   }
 
   @Test
   public void windowUpdateMatchesTarget() throws Exception {
+    manualSetUp();
     Http2Stream connectionStream = connection().connectionStream();
     Http2LocalFlowController localFlowController = connection().local().flowController();
     makeStream();
     AbstractNettyHandler handler = (AbstractNettyHandler) handler();
     handler.setAutoTuneFlowControl(true);
 
-    ByteBuf data = ctx().alloc().buffer(1024);
-    while (data.isWritable()) {
-      data.writeLong(1111);
-    }
-    int length = data.readableBytes();
-    ByteBuf frame = dataFrame(3, false, data.copy());
+    byte[] data = initXkbBuffer(1);
+    int wireSize = data.length + 5; // 5 is the size of the header
+    ByteBuf frame = grpcDataFrame(3, false, data);
     channelRead(frame);
-    int accumulator = length;
+    int accumulator = wireSize;
     // 40 is arbitrary, any number large enough to trigger a window update would work
     for (int i = 0; i < 40; i++) {
-      channelRead(dataFrame(3, false, data.copy()));
-      accumulator += length;
+      channelRead(grpcDataFrame(3, false, data));
+      accumulator += wireSize;
     }
     long pingData = handler.flowControlPing().payload();
-    ByteBuf buffer = handler.ctx().alloc().buffer(8);
-    buffer.writeLong(pingData);
-    channelRead(pingFrame(true, buffer));
+    channelRead(pingFrame(true, pingData));
 
     assertEquals(accumulator, handler.flowControlPing().getDataSincePing());
     assertEquals(2 * accumulator, localFlowController.initialWindowSize(connectionStream));
@@ -330,20 +445,192 @@ public void windowUpdateMatchesTarget() throws Exception {
 
   @Test
   public void windowShouldNotExceedMaxWindowSize() throws Exception {
+    manualSetUp();
     makeStream();
     AbstractNettyHandler handler = (AbstractNettyHandler) handler();
     handler.setAutoTuneFlowControl(true);
     Http2Stream connectionStream = connection().connectionStream();
     Http2LocalFlowController localFlowController = connection().local().flowController();
     int maxWindow = handler.flowControlPing().maxWindow();
+    fakeClock.forwardTime(10, TimeUnit.SECONDS);
 
-    handler.flowControlPing().setDataSizeSincePing(maxWindow);
-    int payload = handler.flowControlPing().payload();
-    ByteBuf buffer = handler.ctx().alloc().buffer(8);
-    buffer.writeLong(payload);
-    channelRead(pingFrame(true, buffer));
+    handler.flowControlPing().setDataSizeAndSincePing(maxWindow);
+    fakeClock.forwardTime(1, TimeUnit.SECONDS);
+    long payload = handler.flowControlPing().payload();
+    channelRead(pingFrame(true, payload));
 
     assertEquals(maxWindow, localFlowController.initialWindowSize(connectionStream));
   }
 
+  @Test
+  public void transportTracer_windowSizeDefault() throws Exception {
+    manualSetUp();
+    TransportStats transportStats = transportTracer.getStats();
+    assertEquals(Http2CodecUtil.DEFAULT_WINDOW_SIZE, transportStats.localFlowControlWindow);
+    assertEquals(flowControlWindow, transportStats.remoteFlowControlWindow);
+  }
+
+  @Test
+  public void transportTracer_windowSize() throws Exception {
+    flowControlWindow = 1024 * 1024;
+    manualSetUp();
+    TransportStats transportStats = transportTracer.getStats();
+    assertEquals(Http2CodecUtil.DEFAULT_WINDOW_SIZE, transportStats.localFlowControlWindow);
+    assertEquals(flowControlWindow, transportStats.remoteFlowControlWindow);
+  }
+
+  @Test
+  public void transportTracer_windowUpdate_remote() throws Exception {
+    manualSetUp();
+    TransportStats before = transportTracer.getStats();
+    assertEquals(Http2CodecUtil.DEFAULT_WINDOW_SIZE, before.localFlowControlWindow);
+    assertEquals(Http2CodecUtil.DEFAULT_WINDOW_SIZE, before.remoteFlowControlWindow);
+
+    ByteBuf serializedSettings = windowUpdate(0, 1000);
+    channelRead(serializedSettings);
+    TransportStats after = transportTracer.getStats();
+    assertEquals(Http2CodecUtil.DEFAULT_WINDOW_SIZE + 1000,
+        after.localFlowControlWindow);
+    assertEquals(flowControlWindow, after.remoteFlowControlWindow);
+  }
+
+  @Test
+  public void transportTracer_windowUpdate_local() throws Exception {
+    manualSetUp();
+    TransportStats before = transportTracer.getStats();
+    assertEquals(Http2CodecUtil.DEFAULT_WINDOW_SIZE, before.localFlowControlWindow);
+    assertEquals(flowControlWindow, before.remoteFlowControlWindow);
+
+    // If the window size is below a certain threshold, netty will wait to apply the update.
+    // Use a large increment to be sure that it exceeds the threshold.
+    connection().local().flowController().incrementWindowSize(
+        connection().connectionStream(), 8 * Http2CodecUtil.DEFAULT_WINDOW_SIZE);
+
+    TransportStats after = transportTracer.getStats();
+    assertEquals(Http2CodecUtil.DEFAULT_WINDOW_SIZE, after.localFlowControlWindow);
+    assertEquals(flowControlWindow + 8 * Http2CodecUtil.DEFAULT_WINDOW_SIZE,
+        connection().local().flowController().windowSize(connection().connectionStream()));
+  }
+
+  private AbstractNettyHandler setupPingTest() throws Exception {
+    this.flowControlWindow = 1024 * 64;
+    manualSetUp();
+    makeStream();
+
+    AbstractNettyHandler handler = (AbstractNettyHandler) handler();
+    handler.setAutoTuneFlowControl(true);
+    return handler;
+  }
+
+  @Test
+  public void bdpPingLimitOutstanding() throws Exception {
+    AbstractNettyHandler handler = setupPingTest();
+    long pingData = handler.flowControlPing().payload();
+
+    byte[] data1KbBuf = initXkbBuffer(1);
+    byte[] data40KbBuf = initXkbBuffer(40);
+
+    readXCopies(1, data1KbBuf); // should initiate a ping
+
+    readXCopies(1, data40KbBuf); // no ping, already active
+    fakeClock().forwardTime(20, TimeUnit.MILLISECONDS);
+    readPingAck(pingData);
+    assertEquals(1, handler.flowControlPing().getPingCount());
+    assertEquals(1, handler.flowControlPing().getPingReturn());
+
+    readXCopies(4, data40KbBuf); // initiate ping
+    assertEquals(2, handler.flowControlPing().getPingCount());
+    fakeClock.forwardTime(1, TimeUnit.MILLISECONDS);
+    readPingAck(pingData);
+
+    readXCopies(1, data1KbBuf); // ping again since had 160K data since last ping started
+    assertEquals(3, handler.flowControlPing().getPingCount());
+    fakeClock.forwardTime(1, TimeUnit.MILLISECONDS);
+    readPingAck(pingData);
+
+    fakeClock.forwardTime(1, TimeUnit.MILLISECONDS);
+    readXCopies(1, data1KbBuf); // no ping, too little data
+    assertEquals(3, handler.flowControlPing().getPingCount());
+  }
+
+  @Test
+  public void testPingBackoff() throws Exception {
+    AbstractNettyHandler handler = setupPingTest();
+    long pingData = handler.flowControlPing().payload();
+    byte[] data40KbBuf = initXkbBuffer(40);
+
+    handler.flowControlPing().setDataSizeAndSincePing(200000);
+
+    for (int i = 0; i <= 10; i++) {
+      int beforeCount = handler.flowControlPing().getPingCount();
+      // should resize on 0
+      readXCopies(6, data40KbBuf); // initiate ping on i= {0, 1, 3, 6, 10}
+      int afterCount = handler.flowControlPing().getPingCount();
+      fakeClock().forwardNanos(200);
+      if (afterCount > beforeCount) {
+        readPingAck(pingData); // should increase backoff multiplier
+      }
+    }
+    assertEquals(6, handler.flowControlPing().getPingCount());
+  }
+
+  @Test
+  public void bdpPingWindowResizing() throws Exception {
+    this.flowControlWindow = 1024 * 8;
+    manualSetUp();
+    makeStream();
+
+    AbstractNettyHandler handler = (AbstractNettyHandler) handler();
+    handler.setAutoTuneFlowControl(true);
+    Http2LocalFlowController localFlowController = connection().local().flowController();
+    long pingData = handler.flowControlPing().payload();
+    int initialWindowSize = localFlowController.initialWindowSize();
+    byte[] data1Kb = initXkbBuffer(1);
+    byte[] data10Kb = initXkbBuffer(10);
+
+    readXCopies(1, data1Kb); // initiate ping
+    fakeClock().forwardNanos(2);
+    readPingAck(pingData); // should not resize window because of small target window
+    assertEquals(initialWindowSize, localFlowController.initialWindowSize());
+
+    readXCopies(2, data10Kb); // initiate ping on first
+    fakeClock().forwardNanos(200);
+    readPingAck(pingData); // should resize window
+    int windowSizeA = localFlowController.initialWindowSize();
+    Assert.assertNotEquals(initialWindowSize, windowSizeA);
+
+    readXCopies(3, data10Kb); // initiate ping w/ first 10K packet
+    fakeClock().forwardNanos(5000);
+    readPingAck(pingData); // should not resize window as bandwidth didn't increase
+    Assert.assertEquals(windowSizeA, localFlowController.initialWindowSize());
+
+    readXCopies(6, data10Kb); // initiate ping with fist packet
+    fakeClock().forwardNanos(100);
+    readPingAck(pingData); // should resize window
+    int windowSizeB = localFlowController.initialWindowSize();
+    Assert.assertNotEquals(windowSizeA, windowSizeB);
+  }
+
+  private void readPingAck(long pingData) throws Exception {
+    channelRead(pingFrame(true, pingData));
+    channel().releaseOutbound();
+  }
+
+  private void readXCopies(int copies, byte[] data) throws Exception {
+    for (int i = 0; i < copies; i++) {
+      channelRead(grpcDataFrame(STREAM_ID, false, data)); // buffer it
+      stream().request(1); // consume it
+      channel().releaseOutbound();
+    }
+  }
+
+  private byte[] initXkbBuffer(int multiple) {
+    ByteBuffer data = ByteBuffer.allocate(1024 * multiple);
+
+    for (int i = 0; i < multiple * 1024 / 4; i++) {
+      data.putInt(4 * i, 1111);
+    }
+    return data.array();
+  }
+
 }
diff --git a/netty/src/test/java/io/grpc/netty/NettyReadableBufferTest.java b/netty/src/test/java/io/grpc/netty/NettyReadableBufferTest.java
index d426ee93f86..4f10504c07d 100644
--- a/netty/src/test/java/io/grpc/netty/NettyReadableBufferTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyReadableBufferTest.java
@@ -1,42 +1,32 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
-import static com.google.common.base.Charsets.UTF_8;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
+import com.google.common.base.Splitter;
 import io.grpc.internal.ReadableBuffer;
 import io.grpc.internal.ReadableBufferTestBase;
+import io.netty.buffer.CompositeByteBuf;
 import io.netty.buffer.Unpooled;
+import java.nio.ByteBuffer;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -67,6 +57,29 @@ public void closeMultipleTimesShouldReleaseBufferOnce() {
     assertEquals(0, buffer.buffer().refCnt());
   }
 
+  @Test
+  public void getByteBufferFromSingleNioBufferBackedBuffer() {
+    assertTrue(buffer.byteBufferSupported());
+    ByteBuffer byteBuffer = buffer.getByteBuffer();
+    byte[] arr = new byte[byteBuffer.remaining()];
+    byteBuffer.get(arr);
+    assertArrayEquals(msg.getBytes(UTF_8), arr);
+  }
+
+  @Test
+  public void getByteBufferFromCompositeBufferReturnsOnlyFirstComponent() {
+    CompositeByteBuf composite = Unpooled.compositeBuffer(10);
+    int chunks = 4;
+    int chunkLen = msg.length() / chunks;
+    for (String chunk : Splitter.fixedLength(chunkLen).split(msg)) {
+      composite.addComponent(true, Unpooled.copiedBuffer(chunk.getBytes(UTF_8)));
+    }
+    buffer = new NettyReadableBuffer(composite);
+    byte[] array = new byte[chunkLen];
+    buffer.getByteBuffer().get(array);
+    assertArrayEquals(msg.substring(0, chunkLen).getBytes(UTF_8), array);
+  }
+
   @Override
   protected ReadableBuffer buffer() {
     return buffer;
diff --git a/netty/src/test/java/io/grpc/netty/NettyServerBuilderTest.java b/netty/src/test/java/io/grpc/netty/NettyServerBuilderTest.java
index b7cf46d79d9..797cfa95c0e 100644
--- a/netty/src/test/java/io/grpc/netty/NettyServerBuilderTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyServerBuilderTest.java
@@ -1,70 +1,192 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
+import com.google.common.collect.ImmutableList;
+import io.grpc.ServerStreamTracer;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.local.LocalServerChannel;
 import io.netty.handler.ssl.SslContext;
-import org.junit.Rule;
+import java.net.InetSocketAddress;
+import java.util.concurrent.TimeUnit;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
-
 /**
  * Unit tests for {@link NettyServerBuilder}.
  */
 @RunWith(JUnit4.class)
 public class NettyServerBuilderTest {
 
-  @Rule public final ExpectedException thrown = ExpectedException.none();
+  private NettyServerBuilder builder = NettyServerBuilder.forPort(8080);
+
+  @Test
+  public void addMultipleListenAddresses() {
+    builder.addListenAddress(new InetSocketAddress(8081));
+    NettyServer server =
+        builder.buildTransportServers(ImmutableList.<ServerStreamTracer.Factory>of());
+
+    assertThat(server.getListenSocketAddresses()).hasSize(2);
+  }
 
   @Test
   public void sslContextCanBeNull() {
-    NettyServerBuilder builder = NettyServerBuilder.forPort(8080);
     builder.sslContext(null);
   }
 
   @Test
   public void failIfSslContextIsNotServer() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Client SSL context can not be used for server");
-
     SslContext sslContext = mock(SslContext.class);
     when(sslContext.isClient()).thenReturn(true);
 
-    NettyServerBuilder builder = NettyServerBuilder.forPort(8080);;
-    builder.sslContext(sslContext);
+    IllegalArgumentException e = assertThrows(
+        IllegalArgumentException.class, () -> builder.sslContext(sslContext));
+    assertThat(e).hasMessageThat().isEqualTo("Client SSL context can not be used for server");
+  }
+
+  @Test
+  public void failIfKeepAliveTimeNegative() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.keepAliveTime(-10L, TimeUnit.HOURS));
+    assertThat(e).hasMessageThat().isEqualTo("keepalive time must be positive：-10");
+  }
+
+  @Test
+  public void failIfKeepAliveTimeoutNegative() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.keepAliveTimeout(-10L, TimeUnit.HOURS));
+    assertThat(e).hasMessageThat().isEqualTo("keepalive timeout must be positive: -10");
+  }
+
+  @Test
+  public void failIfMaxConcurrentCallsPerConnectionNegative() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.maxConcurrentCallsPerConnection(0));
+    assertThat(e).hasMessageThat().isEqualTo("max must be positive: 0");
+  }
+
+  @Test
+  public void failIfMaxInboundMetadataSizeNonPositive() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.maxInboundMetadataSize(0));
+    assertThat(e).hasMessageThat().isEqualTo("maxInboundMetadataSize must be positive: 0");
+  }
+
+  @Test
+  public void failIfSoftInboundMetadataSizeNonPositive() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.maxInboundMetadataSize(0, 100));
+    assertThat(e).hasMessageThat().isEqualTo("softLimitHeaderListSize must be positive: 0");
+  }
+
+  @Test
+  public void failIfMaxInboundMetadataSizeSmallerThanSoft() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.maxInboundMetadataSize(100, 80));
+    assertThat(e).hasMessageThat().isEqualTo("maxInboundMetadataSize: 80 "
+        + "must be greater than softLimitHeaderListSize: 100");
+  }
+
+  @Test
+  public void failIfMaxConnectionIdleNegative() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.maxConnectionIdle(-1, TimeUnit.HOURS));
+    assertThat(e).hasMessageThat().isEqualTo("max connection idle must be positive: -1");
+  }
+
+  @Test
+  public void failIfMaxConnectionAgeNegative() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.maxConnectionAge(-1, TimeUnit.HOURS));
+    assertThat(e).hasMessageThat().isEqualTo("max connection age must be positive: -1");
+  }
+
+  @Test
+  public void failIfMaxConnectionAgeGraceNegative() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.maxConnectionAgeGrace(-1, TimeUnit.HOURS));
+    assertThat(e).hasMessageThat().isEqualTo("max connection age grace must be non-negative: -1");
+  }
+
+  @Test
+  public void failIfPermitKeepAliveTimeNegative() {
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.permitKeepAliveTime(-1, TimeUnit.HOURS));
+    assertThat(e).hasMessageThat().isEqualTo("permit keepalive time must be non-negative: -1");
+  }
+
+  @Test
+  public void assertEventLoopsAndChannelType_onlyBossGroupProvided() {
+    EventLoopGroup mockEventLoopGroup = mock(EventLoopGroup.class);
+    builder.bossEventLoopGroup(mockEventLoopGroup);
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        builder::assertEventLoopsAndChannelType);
+    assertThat(e).hasMessageThat().isEqualTo(
+        "All of BossEventLoopGroup, WorkerEventLoopGroup and ChannelType should be provided "
+            + "or neither should be");
+  }
+
+  @Test
+  public void assertEventLoopsAndChannelType_onlyWorkerGroupProvided() {
+    EventLoopGroup mockEventLoopGroup = mock(EventLoopGroup.class);
+    builder.workerEventLoopGroup(mockEventLoopGroup);
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        builder::assertEventLoopsAndChannelType);
+    assertThat(e).hasMessageThat().isEqualTo(
+        "All of BossEventLoopGroup, WorkerEventLoopGroup and ChannelType should be provided "
+            + "or neither should be");
+  }
+
+  @Test
+  public void assertEventLoopsAndChannelType_onlyTypeProvided() {
+    builder.channelType(LocalServerChannel.class);
+    IllegalStateException e = assertThrows(IllegalStateException.class,
+        builder::assertEventLoopsAndChannelType);
+    assertThat(e).hasMessageThat().isEqualTo(
+        "All of BossEventLoopGroup, WorkerEventLoopGroup and ChannelType should be provided "
+            + "or neither should be");
+  }
+
+  @Test
+  public void assertEventLoopsAndChannelType_usingDefault() {
+    builder.assertEventLoopsAndChannelType();
+  }
+
+  @Test
+  public void assertEventLoopsAndChannelType_allProvided() {
+    EventLoopGroup mockEventLoopGroup = mock(EventLoopGroup.class);
+
+    builder.bossEventLoopGroup(mockEventLoopGroup);
+    builder.workerEventLoopGroup(mockEventLoopGroup);
+    builder.channelType(LocalServerChannel.class);
+
+    builder.assertEventLoopsAndChannelType();
+  }
+
+  @Test
+  public void useNioTransport_shouldNotThrow() {
+    InternalNettyServerBuilder.useNioTransport(builder);
+
+    builder.assertEventLoopsAndChannelType();
   }
 }
diff --git a/netty/src/test/java/io/grpc/netty/NettyServerHandlerTest.java b/netty/src/test/java/io/grpc/netty/NettyServerHandlerTest.java
index 0e3c83aaf83..0d5a9bab176 100644
--- a/netty/src/test/java/io/grpc/netty/NettyServerHandlerTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyServerHandlerTest.java
@@ -1,74 +1,84 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
-import static com.google.common.base.Charsets.UTF_8;
 import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
+import static io.grpc.internal.GrpcUtil.DEFAULT_SERVER_KEEPALIVE_TIMEOUT_NANOS;
+import static io.grpc.internal.GrpcUtil.DEFAULT_SERVER_KEEPALIVE_TIME_NANOS;
+import static io.grpc.netty.NettyServerBuilder.MAX_CONNECTION_AGE_GRACE_NANOS_INFINITE;
+import static io.grpc.netty.NettyServerBuilder.MAX_CONNECTION_AGE_NANOS_DISABLED;
+import static io.grpc.netty.NettyServerBuilder.MAX_CONNECTION_IDLE_NANOS_DISABLED;
+import static io.grpc.netty.NettyServerBuilder.MAX_RST_COUNT_DISABLED;
 import static io.grpc.netty.Utils.CONTENT_TYPE_GRPC;
 import static io.grpc.netty.Utils.CONTENT_TYPE_HEADER;
 import static io.grpc.netty.Utils.HTTP_METHOD;
 import static io.grpc.netty.Utils.TE_HEADER;
 import static io.grpc.netty.Utils.TE_TRAILERS;
-import static io.netty.handler.codec.http2.Http2CodecUtil.DEFAULT_WINDOW_SIZE;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
 
 import com.google.common.io.ByteStreams;
+import com.google.common.truth.Truth;
 import io.grpc.Attributes;
+import io.grpc.InternalStatus;
 import io.grpc.Metadata;
+import io.grpc.ServerStreamTracer;
 import io.grpc.Status;
 import io.grpc.Status.Code;
+import io.grpc.StreamTracer;
+import io.grpc.internal.AbstractStream;
 import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.KeepAliveEnforcer;
+import io.grpc.internal.KeepAliveManager;
 import io.grpc.internal.ServerStream;
 import io.grpc.internal.ServerStreamListener;
 import io.grpc.internal.ServerTransportListener;
 import io.grpc.internal.StatsTraceContext;
-import io.grpc.netty.GrpcHttp2HeadersDecoder.GrpcHttp2ServerHeadersDecoder;
+import io.grpc.internal.StreamListener;
+import io.grpc.internal.testing.TestServerStreamTracer;
+import io.grpc.netty.GrpcHttp2HeadersUtils.GrpcHttp2ServerHeadersDecoder;
 import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufUtil;
-import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelPromise;
+import io.netty.handler.codec.http.HttpHeaderNames;
 import io.netty.handler.codec.http2.DefaultHttp2Headers;
 import io.netty.handler.codec.http2.Http2CodecUtil;
 import io.netty.handler.codec.http2.Http2Error;
@@ -78,14 +88,28 @@
 import io.netty.handler.codec.http2.Http2Stream;
 import io.netty.util.AsciiString;
 import java.io.InputStream;
+import java.nio.channels.ClosedChannelException;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.concurrent.TimeUnit;
 import org.junit.Before;
-import org.junit.Ignore;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.DisableOnDebug;
+import org.junit.rules.TestRule;
+import org.junit.rules.Timeout;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
 
 /**
  * Unit tests for {@link NettyServerHandler}.
@@ -93,28 +117,37 @@
 @RunWith(JUnit4.class)
 public class NettyServerHandlerTest extends NettyHandlerTestBase<NettyServerHandler> {
 
-  private static final int STREAM_ID = 3;
-
+  @Rule
+  public final TestRule globalTimeout = new DisableOnDebug(Timeout.seconds(10));
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  private static final AsciiString HTTP_FAKE_METHOD = AsciiString.of("FAKE");
   @Mock
   private ServerStreamListener streamListener;
-
-  private final ServerTransportListener transportListener = spy(new ServerTransportListenerImpl());
-
-  private final StatsTraceContext statsTraceCtx = StatsTraceContext.NOOP;
-
+  @Mock
+  private ServerStreamTracer.Factory streamTracerFactory;
+  private final ServerTransportListener transportListener =
+      mock(ServerTransportListener.class, delegatesTo(new ServerTransportListenerImpl()));
+  private final TestServerStreamTracer streamTracer = new TestServerStreamTracer();
   private NettyServerStream stream;
+  private KeepAliveManager spyKeepAliveManager;
+  final Queue<InputStream> streamListenerMessageQueue = new LinkedList<>();
 
-  private int flowControlWindow = DEFAULT_WINDOW_SIZE;
   private int maxConcurrentStreams = Integer.MAX_VALUE;
   private int maxHeaderListSize = Integer.MAX_VALUE;
+  private int softLimitHeaderListSize = Integer.MAX_VALUE;
+  private boolean permitKeepAliveWithoutCalls = true;
+  private long permitKeepAliveTimeInNanos = 0;
+  private long maxConnectionIdleInNanos = MAX_CONNECTION_IDLE_NANOS_DISABLED;
+  private long maxConnectionAgeInNanos = MAX_CONNECTION_AGE_NANOS_DISABLED;
+  private long maxConnectionAgeGraceInNanos = MAX_CONNECTION_AGE_GRACE_NANOS_INFINITE;
+  private long keepAliveTimeInNanos = DEFAULT_SERVER_KEEPALIVE_TIME_NANOS;
+  private long keepAliveTimeoutInNanos = DEFAULT_SERVER_KEEPALIVE_TIMEOUT_NANOS;
+  private int maxRstCount = MAX_RST_COUNT_DISABLED;
+  private long maxRstPeriodNanos;
 
   private class ServerTransportListenerImpl implements ServerTransportListener {
 
-    @Override
-    public StatsTraceContext methodDetermined(String methodName, Metadata headers) {
-      return statsTraceCtx;
-    }
-
     @Override
     public void streamCreated(ServerStream stream, String method, Metadata headers) {
       stream.setListener(streamListener);
@@ -131,38 +164,95 @@ public void transportTerminated() {
   }
 
   @Before
-  public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
+  public void setUp() {
+    when(streamTracerFactory.newServerStreamTracer(anyString(), any(Metadata.class)))
+        .thenReturn(streamTracer);
+
+    doAnswer(
+          new Answer<Void>() {
+            @Override
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+              StreamListener.MessageProducer producer =
+                  (StreamListener.MessageProducer) invocation.getArguments()[0];
+              InputStream message;
+              while ((message = producer.next()) != null) {
+                streamListenerMessageQueue.add(message);
+              }
+              return null;
+            }
+          })
+        .when(streamListener)
+        .messagesAvailable(any(StreamListener.MessageProducer.class));
+  }
+
+  @Override
+  protected void manualSetUp() throws Exception {
+    assertNull("manualSetUp should not run more than once", handler());
 
     initChannel(new GrpcHttp2ServerHeadersDecoder(GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE));
 
+    // replace the keepAliveManager with spyKeepAliveManager
+    spyKeepAliveManager =
+        mock(KeepAliveManager.class, delegatesTo(handler().getKeepAliveManagerForTest()));
+    handler().setKeepAliveManagerForTest(spyKeepAliveManager);
+
     // Simulate receipt of the connection preface
-    handler().handleProtocolNegotiationCompleted(Attributes.EMPTY);
+    handler().handleProtocolNegotiationCompleted(Attributes.EMPTY, /*securityInfo=*/ null);
     channelRead(Http2CodecUtil.connectionPrefaceBuf());
     // Simulate receipt of initial remote settings.
     ByteBuf serializedSettings = serializeSettings(new Http2Settings());
     channelRead(serializedSettings);
+    channel().releaseOutbound();
+  }
+
+  @Test
+  public void transportReadyDelayedUntilConnectionPreface() throws Exception {
+    initChannel(new GrpcHttp2ServerHeadersDecoder(GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE));
+
+    handler().handleProtocolNegotiationCompleted(Attributes.EMPTY, /*securityInfo=*/ null);
+    verify(transportListener, never()).transportReady(any(Attributes.class));
+
+    // Simulate receipt of the connection preface
+    channelRead(Http2CodecUtil.connectionPrefaceBuf());
+    channelRead(serializeSettings(new Http2Settings()));
+    verify(transportListener).transportReady(any(Attributes.class));
   }
 
   @Test
   public void sendFrameShouldSucceed() throws Exception {
+    manualSetUp();
     createStream();
 
     // Send a frame and verify that it was written.
+    ByteBuf content = content();
     ChannelFuture future = enqueue(
-        new SendGrpcFrameCommand(stream.transportState(), content(), false));
+        new SendGrpcFrameCommand(stream.transportState(), content, false));
     assertTrue(future.isSuccess());
-    verifyWrite().writeData(eq(ctx()), eq(STREAM_ID), eq(content()), eq(0), eq(false),
+    verifyWrite().writeData(eq(ctx()), eq(STREAM_ID), same(content), eq(0), eq(false),
         any(ChannelPromise.class));
   }
 
+  @Test
+  public void streamTracerCreated() throws Exception {
+    manualSetUp();
+    createStream();
+
+    verify(streamTracerFactory).newServerStreamTracer(eq("foo/bar"), any(Metadata.class));
+    StatsTraceContext statsTraceCtx = stream.statsTraceContext();
+    List<StreamTracer> tracers = statsTraceCtx.getTracersForTest();
+    assertEquals(1, tracers.size());
+    assertSame(streamTracer, tracers.get(0));
+  }
+
   @Test
   public void inboundDataWithEndStreamShouldForwardToStreamListener() throws Exception {
+    manualSetUp();
     inboundDataShouldForwardToStreamListener(true);
   }
 
   @Test
   public void inboundDataShouldForwardToStreamListener() throws Exception {
+    manualSetUp();
     inboundDataShouldForwardToStreamListener(false);
   }
 
@@ -173,10 +263,13 @@ private void inboundDataShouldForwardToStreamListener(boolean endStream) throws
     // Create a data frame and then trigger the handler to read it.
     ByteBuf frame = grpcDataFrame(STREAM_ID, endStream, contentAsArray());
     channelRead(frame);
-    ArgumentCaptor<InputStream> captor = ArgumentCaptor.forClass(InputStream.class);
-    verify(streamListener).messageRead(captor.capture());
-    assertArrayEquals(ByteBufUtil.getBytes(content()), ByteStreams.toByteArray(captor.getValue()));
-    captor.getValue().close();
+    channel().releaseOutbound();
+    verify(streamListener, atLeastOnce())
+        .messagesAvailable(any(StreamListener.MessageProducer.class));
+    InputStream message = streamListenerMessageQueue.poll();
+    assertArrayEquals(contentAsArray(), ByteStreams.toByteArray(message));
+    message.close();
+    assertNull("no additional message expected", streamListenerMessageQueue.poll());
 
     if (endStream) {
       verify(streamListener).halfClosed();
@@ -187,13 +280,17 @@ private void inboundDataShouldForwardToStreamListener(boolean endStream) throws
 
   @Test
   public void clientHalfCloseShouldForwardToStreamListener() throws Exception {
+    manualSetUp();
     createStream();
     stream.request(1);
 
     channelRead(emptyGrpcFrame(STREAM_ID, true));
-    ArgumentCaptor<InputStream> captor = ArgumentCaptor.forClass(InputStream.class);
-    verify(streamListener).messageRead(captor.capture());
-    assertArrayEquals(new byte[0], ByteStreams.toByteArray(captor.getValue()));
+
+    verify(streamListener, atLeastOnce())
+        .messagesAvailable(any(StreamListener.MessageProducer.class));
+    InputStream message = streamListenerMessageQueue.poll();
+    assertArrayEquals(new byte[0], ByteStreams.toByteArray(message));
+    assertNull("no additional message expected", streamListenerMessageQueue.poll());
     verify(streamListener).halfClosed();
     verify(streamListener, atLeastOnce()).onReady();
     verifyNoMoreInteractions(streamListener);
@@ -201,24 +298,29 @@ public void clientHalfCloseShouldForwardToStreamListener() throws Exception {
 
   @Test
   public void clientCancelShouldForwardToStreamListener() throws Exception {
+    manualSetUp();
     createStream();
 
     channelRead(rstStreamFrame(STREAM_ID, (int) Http2Error.CANCEL.code()));
-    verify(streamListener, never()).messageRead(any(InputStream.class));
-    verify(streamListener).closed(Status.CANCELLED);
+
+    ArgumentCaptor<Status> statusCap = ArgumentCaptor.forClass(Status.class);
+    verify(streamListener).closed(statusCap.capture());
+    assertEquals(Code.CANCELLED, statusCap.getValue().getCode());
+    Truth.assertThat(statusCap.getValue().getDescription()).contains("RST_STREAM");
     verify(streamListener, atLeastOnce()).onReady();
-    verifyNoMoreInteractions(streamListener);
+    assertNull("no messages expected", streamListenerMessageQueue.poll());
   }
 
   @Test
   public void streamErrorShouldNotCloseChannel() throws Exception {
+    manualSetUp();
     createStream();
     stream.request(1);
 
     // When a DATA frame is read, throw an exception. It will be converted into an
     // Http2StreamException.
     RuntimeException e = new RuntimeException("Fake Exception");
-    doThrow(e).when(streamListener).messageRead(any(InputStream.class));
+    doThrow(e).when(streamListener).messagesAvailable(any(StreamListener.MessageProducer.class));
 
     // Read a DATA frame to trigger the exception.
     channelRead(emptyGrpcFrame(STREAM_ID, true));
@@ -234,18 +336,79 @@ public void streamErrorShouldNotCloseChannel() throws Exception {
   }
 
   @Test
-  public void closeShouldCloseChannel() throws Exception {
+  public void closeShouldGracefullyCloseChannel() throws Exception {
+    manualSetUp();
     handler().close(ctx(), newPromise());
 
+    verifyWrite().writeGoAway(eq(ctx()), eq(Integer.MAX_VALUE), eq(Http2Error.NO_ERROR.code()),
+        isA(ByteBuf.class), any(ChannelPromise.class));
+    verifyWrite().writePing(
+        eq(ctx()),
+        eq(false),
+        eq(NettyServerHandler.GRACEFUL_SHUTDOWN_PING),
+        isA(ChannelPromise.class));
+    channelRead(pingFrame(/*ack=*/ true , NettyServerHandler.GRACEFUL_SHUTDOWN_PING));
+
+    verifyWrite().writeGoAway(eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()),
+        isA(ByteBuf.class), any(ChannelPromise.class));
+
+    // Verify that the channel was closed.
+    assertFalse(channel().isOpen());
+  }
+
+  @Test
+  public void gracefulCloseShouldGracefullyCloseChannel() throws Exception {
+    manualSetUp();
+    handler()
+        .write(ctx(), new GracefulServerCloseCommand("test", 1, TimeUnit.MINUTES), newPromise());
+
+    verifyWrite().writeGoAway(eq(ctx()), eq(Integer.MAX_VALUE), eq(Http2Error.NO_ERROR.code()),
+        isA(ByteBuf.class), any(ChannelPromise.class));
+    verifyWrite().writePing(
+        eq(ctx()),
+        eq(false),
+        eq(NettyServerHandler.GRACEFUL_SHUTDOWN_PING),
+        isA(ChannelPromise.class));
+    channelRead(pingFrame(/*ack=*/ true , NettyServerHandler.GRACEFUL_SHUTDOWN_PING));
+
     verifyWrite().writeGoAway(eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()),
-        eq(Unpooled.EMPTY_BUFFER), any(ChannelPromise.class));
+        isA(ByteBuf.class), any(ChannelPromise.class));
 
     // Verify that the channel was closed.
     assertFalse(channel().isOpen());
   }
 
+  @Test
+  public void secondGracefulCloseIsSafe() throws Exception {
+    manualSetUp();
+    handler().write(ctx(), new GracefulServerCloseCommand("test"), newPromise());
+
+    verifyWrite().writeGoAway(eq(ctx()), eq(Integer.MAX_VALUE), eq(Http2Error.NO_ERROR.code()),
+        isA(ByteBuf.class), any(ChannelPromise.class));
+    verifyWrite().writePing(
+        eq(ctx()),
+        eq(false),
+        eq(NettyServerHandler.GRACEFUL_SHUTDOWN_PING),
+        isA(ChannelPromise.class));
+
+    handler().write(ctx(), new GracefulServerCloseCommand("test2"), newPromise());
+
+    channel().runPendingTasks();
+    // No additional GOAWAYs.
+    verifyWrite().writeGoAway(any(ChannelHandlerContext.class), any(Integer.class), any(Long.class),
+        any(ByteBuf.class), any(ChannelPromise.class));
+    channel().checkException();
+    assertTrue(channel().isOpen());
+
+    channelRead(pingFrame(/*ack=*/ true , NettyServerHandler.GRACEFUL_SHUTDOWN_PING));
+    verifyWrite().writeGoAway(eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()),
+        isA(ByteBuf.class), any(ChannelPromise.class));
+    assertFalse(channel().isOpen());
+  }
+
   @Test
   public void exceptionCaughtShouldCloseConnection() throws Exception {
+    manualSetUp();
     handler().exceptionCaught(ctx(), new RuntimeException("fake exception"));
 
     // TODO(nmittler): EmbeddedChannel does not currently invoke the channelInactive processing,
@@ -257,6 +420,7 @@ public void exceptionCaughtShouldCloseConnection() throws Exception {
 
   @Test
   public void channelInactiveShouldCloseStreams() throws Exception {
+    manualSetUp();
     createStream();
     handler().channelInactive(ctx());
     ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
@@ -267,32 +431,31 @@ public void channelInactiveShouldCloseStreams() throws Exception {
   @Test
   public void shouldAdvertiseMaxConcurrentStreams() throws Exception {
     maxConcurrentStreams = 314;
-    setUp();
+    manualSetUp();
 
     ArgumentCaptor<Http2Settings> captor = ArgumentCaptor.forClass(Http2Settings.class);
     verifyWrite().writeSettings(
         any(ChannelHandlerContext.class), captor.capture(), any(ChannelPromise.class));
 
-    assertEquals(maxConcurrentStreams, captor.getValue().maxConcurrentStreams().intValue());
+    assertEquals(maxConcurrentStreams, captor.getValue().maxConcurrentStreams().longValue());
   }
 
   @Test
   public void shouldAdvertiseMaxHeaderListSize() throws Exception {
     maxHeaderListSize = 123;
-    setUp();
+    manualSetUp();
 
     ArgumentCaptor<Http2Settings> captor = ArgumentCaptor.forClass(Http2Settings.class);
     verifyWrite().writeSettings(
         any(ChannelHandlerContext.class), captor.capture(), any(ChannelPromise.class));
 
-    assertEquals(maxHeaderListSize, captor.getValue().maxHeaderListSize().intValue());
+    assertEquals(maxHeaderListSize, captor.getValue().maxHeaderListSize().longValue());
   }
 
   @Test
-  @Ignore("Re-enable once https://github.com/grpc/grpc-java/issues/1175 is fixed")
   public void connectionWindowShouldBeOverridden() throws Exception {
     flowControlWindow = 1048576; // 1MiB
-    setUp();
+    manualSetUp();
 
     Http2Stream connectionStream = connection().connectionStream();
     Http2LocalFlowController localFlowController = connection().local().flowController();
@@ -304,27 +467,147 @@ public void connectionWindowShouldBeOverridden() throws Exception {
 
   @Test
   public void cancelShouldSendRstStream() throws Exception {
+    manualSetUp();
     createStream();
-    enqueue(new CancelServerStreamCommand(stream.transportState(), Status.DEADLINE_EXCEEDED));
+    enqueue(CancelServerStreamCommand.withReset(stream.transportState(), Status.DEADLINE_EXCEEDED));
     verifyWrite().writeRstStream(eq(ctx()), eq(stream.transportState().id()),
         eq(Http2Error.CANCEL.code()), any(ChannelPromise.class));
   }
 
+  @Test
+  public void cancelWithNotify_shouldSendHeaders() throws Exception {
+    manualSetUp();
+    createStream();
+
+    enqueue(CancelServerStreamCommand.withReason(
+            stream.transportState(),
+            Status.RESOURCE_EXHAUSTED.withDescription("my custom description")
+    ));
+
+    ArgumentCaptor<Http2Headers> captor = ArgumentCaptor.forClass(Http2Headers.class);
+    verifyWrite()
+            .writeHeaders(
+                    eq(ctx()),
+                    eq(STREAM_ID),
+                    captor.capture(),
+                    eq(0),
+                    eq(true),
+                    any(ChannelPromise.class));
+
+    // For arcane reasons, the specific implementation of Http2Headers here doesn't actually support
+    // methods like `get(...)`, so we have to manually convert it into a map.
+    Map<String, String> actualHeaders = new HashMap<>();
+    for (Map.Entry<CharSequence, CharSequence> entry : captor.getValue()) {
+      actualHeaders.put(entry.getKey().toString(), entry.getValue().toString());
+    }
+    assertEquals("8", actualHeaders.get(InternalStatus.CODE_KEY.name()));
+    assertEquals("my custom description", actualHeaders.get(InternalStatus.MESSAGE_KEY.name()));
+  }
+
   @Test
   public void headersWithInvalidContentTypeShouldFail() throws Exception {
+    manualSetUp();
     Http2Headers headers = new DefaultHttp2Headers()
-            .method(HTTP_METHOD)
-            .set(CONTENT_TYPE_HEADER, new AsciiString("application/bad", UTF_8))
-            .set(TE_HEADER, TE_TRAILERS)
-            .path(new AsciiString("/foo/bar"));
+        .method(HTTP_METHOD)
+        .set(CONTENT_TYPE_HEADER, new AsciiString("application/bad", UTF_8))
+        .set(TE_HEADER, TE_TRAILERS)
+        .path(new AsciiString("/foo/bar"));
     ByteBuf headersFrame = headersFrame(STREAM_ID, headers);
     channelRead(headersFrame);
-    verifyWrite().writeRstStream(eq(ctx()), eq(STREAM_ID), eq(Http2Error.REFUSED_STREAM.code()),
-        any(ChannelPromise.class));
+    Http2Headers responseHeaders = new DefaultHttp2Headers()
+        .set(InternalStatus.CODE_KEY.name(), String.valueOf(Code.INTERNAL.value()))
+        .set(InternalStatus.MESSAGE_KEY.name(), "Content-Type 'application/bad' is not supported")
+        .status("" + 415)
+        .set(CONTENT_TYPE_HEADER, "text/plain; charset=utf-8");
+
+    verifyWrite()
+        .writeHeaders(
+            eq(ctx()),
+            eq(STREAM_ID),
+            eq(responseHeaders),
+            eq(0),
+            eq(false),
+            any(ChannelPromise.class));
+  }
+
+  @Test
+  public void headersWithInvalidMethodShouldFail() throws Exception {
+    manualSetUp();
+    Http2Headers headers = new DefaultHttp2Headers()
+        .method(HTTP_FAKE_METHOD)
+        .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC)
+        .path(new AsciiString("/foo/bar"));
+    ByteBuf headersFrame = headersFrame(STREAM_ID, headers);
+    channelRead(headersFrame);
+    Http2Headers responseHeaders = new DefaultHttp2Headers()
+        .set(InternalStatus.CODE_KEY.name(), String.valueOf(Code.INTERNAL.value()))
+        .set(InternalStatus.MESSAGE_KEY.name(), "Method 'FAKE' is not supported")
+        .status("" + 405)
+        .set(CONTENT_TYPE_HEADER, "text/plain; charset=utf-8")
+        .set(HttpHeaderNames.ALLOW, HTTP_METHOD);
+
+    verifyWrite()
+        .writeHeaders(
+            eq(ctx()),
+            eq(STREAM_ID),
+            eq(responseHeaders),
+            eq(0),
+            eq(false),
+            any(ChannelPromise.class));
+  }
+
+  @Test
+  public void headersWithMissingPathShouldFail() throws Exception {
+    manualSetUp();
+    Http2Headers headers = new DefaultHttp2Headers()
+        .method(HTTP_METHOD)
+        .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC);
+    ByteBuf headersFrame = headersFrame(STREAM_ID, headers);
+    channelRead(headersFrame);
+    Http2Headers responseHeaders = new DefaultHttp2Headers()
+        .set(InternalStatus.CODE_KEY.name(), String.valueOf(Code.UNIMPLEMENTED.value()))
+        .set(InternalStatus.MESSAGE_KEY.name(), "Expected path but is missing")
+        .status("" + 404)
+        .set(CONTENT_TYPE_HEADER, "text/plain; charset=utf-8");
+
+    verifyWrite()
+        .writeHeaders(
+            eq(ctx()),
+            eq(STREAM_ID),
+            eq(responseHeaders),
+            eq(0),
+            eq(false),
+            any(ChannelPromise.class));
+  }
+
+  @Test
+  public void headersWithInvalidPathShouldFail() throws Exception {
+    manualSetUp();
+    Http2Headers headers = new DefaultHttp2Headers()
+        .method(HTTP_METHOD)
+        .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC)
+        .path(new AsciiString("foo/bar"));
+    ByteBuf headersFrame = headersFrame(STREAM_ID, headers);
+    channelRead(headersFrame);
+    Http2Headers responseHeaders = new DefaultHttp2Headers()
+        .set(InternalStatus.CODE_KEY.name(), String.valueOf(Code.UNIMPLEMENTED.value()))
+        .set(InternalStatus.MESSAGE_KEY.name(), "Expected path to start with /: foo/bar")
+        .status("" + 404)
+        .set(CONTENT_TYPE_HEADER, "text/plain; charset=utf-8");
+
+    verifyWrite()
+        .writeHeaders(
+            eq(ctx()),
+            eq(STREAM_ID),
+            eq(responseHeaders),
+            eq(0),
+            eq(false),
+            any(ChannelPromise.class));
   }
 
   @Test
   public void headersSupportExtensionContentType() throws Exception {
+    manualSetUp();
     Http2Headers headers = new DefaultHttp2Headers()
         .method(HTTP_METHOD)
         .set(CONTENT_TYPE_HEADER, new AsciiString("application/grpc+json", UTF_8))
@@ -341,6 +624,751 @@ public void headersSupportExtensionContentType() throws Exception {
     stream = streamCaptor.getValue();
   }
 
+  @Test
+  public void headersWithConnectionHeaderShouldFail() throws Exception {
+    manualSetUp();
+    Http2Headers headers = new DefaultHttp2Headers()
+        .method(HTTP_METHOD)
+        .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC)
+        .set(AsciiString.of("connection"), CONTENT_TYPE_GRPC)
+        .path(new AsciiString("/foo/bar"));
+    ByteBuf headersFrame = headersFrame(STREAM_ID, headers);
+    channelRead(headersFrame);
+
+    verifyWrite()
+        .writeRstStream(
+            eq(ctx()),
+            eq(STREAM_ID),
+            eq(Http2Error.PROTOCOL_ERROR.code()),
+            any(ChannelPromise.class));
+  }
+
+  @Test
+  public void headersWithMultipleHostsShouldFail() throws Exception {
+    manualSetUp();
+    Http2Headers headers = new DefaultHttp2Headers()
+        .method(HTTP_METHOD)
+        .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC)
+        .add(AsciiString.of("host"), AsciiString.of("example.com"))
+        .add(AsciiString.of("host"), AsciiString.of("bad.com"))
+        .path(new AsciiString("/foo/bar"));
+    ByteBuf headersFrame = headersFrame(STREAM_ID, headers);
+    channelRead(headersFrame);
+    Http2Headers responseHeaders = new DefaultHttp2Headers()
+        .set(InternalStatus.CODE_KEY.name(), String.valueOf(Code.INTERNAL.value()))
+        .set(InternalStatus.MESSAGE_KEY.name(), "Multiple host headers")
+        .status("" + 400)
+        .set(CONTENT_TYPE_HEADER, "text/plain; charset=utf-8");
+
+    verifyWrite()
+        .writeHeaders(
+            eq(ctx()),
+            eq(STREAM_ID),
+            eq(responseHeaders),
+            eq(0),
+            eq(false),
+            any(ChannelPromise.class));
+  }
+
+  @Test
+  public void headersWithErrAndEndStreamReturnErrorButNotThrowNpe() throws Exception {
+    manualSetUp();
+    Http2Headers headers = new DefaultHttp2Headers()
+        .method(HTTP_METHOD)
+        .add(AsciiString.of("host"), AsciiString.of("example.com"))
+        .path(new AsciiString("/foo/bar"));
+    ByteBuf headersFrame = headersFrame(STREAM_ID, headers);
+    channelRead(headersFrame);
+    channelRead(emptyGrpcFrame(STREAM_ID, true));
+
+    Http2Headers responseHeaders = new DefaultHttp2Headers()
+        .set(InternalStatus.CODE_KEY.name(), String.valueOf(Code.INTERNAL.value()))
+        .set(InternalStatus.MESSAGE_KEY.name(), "Content-Type is missing from the request")
+        .status("" + 415)
+        .set(CONTENT_TYPE_HEADER, "text/plain; charset=utf-8");
+
+    verifyWrite()
+        .writeHeaders(
+            eq(ctx()),
+            eq(STREAM_ID),
+            eq(responseHeaders),
+            eq(0),
+            eq(false),
+            any(ChannelPromise.class));
+
+  }
+
+  @Test
+  public void headersWithAuthorityAndHostUsesAuthority() throws Exception {
+    manualSetUp();
+    Http2Headers headers = new DefaultHttp2Headers()
+        .method(HTTP_METHOD)
+        .authority("example.com")
+        .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC)
+        .add(AsciiString.of("host"), AsciiString.of("bad.com"))
+        .path(new AsciiString("/foo/bar"));
+    ByteBuf headersFrame = headersFrame(STREAM_ID, headers);
+    channelRead(headersFrame);
+    Metadata.Key<String> hostKey = Metadata.Key.of("host", Metadata.ASCII_STRING_MARSHALLER);
+
+    ArgumentCaptor<NettyServerStream> streamCaptor =
+        ArgumentCaptor.forClass(NettyServerStream.class);
+    ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
+    verify(transportListener).streamCreated(streamCaptor.capture(), eq("foo/bar"),
+        metadataCaptor.capture());
+    Truth.assertThat(streamCaptor.getValue().getAuthority()).isEqualTo("example.com");
+    Truth.assertThat(metadataCaptor.getValue().get(hostKey)).isNull();
+  }
+
+  @Test
+  public void headersWithOnlyHostBecomesAuthority() throws Exception {
+    manualSetUp();
+    // No authority header
+    Http2Headers headers = new DefaultHttp2Headers()
+        .method(HTTP_METHOD)
+        .set(CONTENT_TYPE_HEADER, CONTENT_TYPE_GRPC)
+        .add(AsciiString.of("host"), AsciiString.of("example.com"))
+        .path(new AsciiString("/foo/bar"));
+    ByteBuf headersFrame = headersFrame(STREAM_ID, headers);
+    channelRead(headersFrame);
+    Metadata.Key<String> hostKey = Metadata.Key.of("host", Metadata.ASCII_STRING_MARSHALLER);
+
+    ArgumentCaptor<NettyServerStream> streamCaptor =
+        ArgumentCaptor.forClass(NettyServerStream.class);
+    ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
+    verify(transportListener).streamCreated(streamCaptor.capture(), eq("foo/bar"),
+        metadataCaptor.capture());
+    Truth.assertThat(streamCaptor.getValue().getAuthority()).isEqualTo("example.com");
+    Truth.assertThat(metadataCaptor.getValue().get(hostKey)).isNull();
+  }
+
+  @Test
+  public void keepAliveManagerOnDataReceived_headersRead() throws Exception {
+    manualSetUp();
+    ByteBuf headersFrame = headersFrame(STREAM_ID, new DefaultHttp2Headers());
+    channelRead(headersFrame);
+
+    verify(spyKeepAliveManager).onDataReceived();
+    verify(spyKeepAliveManager, never()).onTransportTermination();
+  }
+
+  @Test
+  public void keepAliveManagerOnDataReceived_dataRead() throws Exception {
+    manualSetUp();
+    createStream();
+    verify(spyKeepAliveManager).onDataReceived(); // received headers
+
+    channelRead(grpcDataFrame(STREAM_ID, false, contentAsArray()));
+
+    verify(spyKeepAliveManager, times(2)).onDataReceived();
+
+    channelRead(grpcDataFrame(STREAM_ID, false, contentAsArray()));
+
+    verify(spyKeepAliveManager, times(3)).onDataReceived();
+    verify(spyKeepAliveManager, never()).onTransportTermination();
+  }
+
+  @Test
+  public void keepAliveManagerOnDataReceived_rstStreamRead() throws Exception {
+    manualSetUp();
+    createStream();
+    verify(spyKeepAliveManager).onDataReceived(); // received headers
+
+    channelRead(rstStreamFrame(STREAM_ID, (int) Http2Error.CANCEL.code()));
+
+    verify(spyKeepAliveManager, times(2)).onDataReceived();
+    verify(spyKeepAliveManager, never()).onTransportTermination();
+  }
+
+  @Test
+  public void keepAliveManagerOnDataReceived_pingRead() throws Exception {
+    manualSetUp();
+    channelRead(pingFrame(false /* isAck */, 1234L));
+
+    verify(spyKeepAliveManager).onDataReceived();
+    verify(spyKeepAliveManager, never()).onTransportTermination();
+  }
+
+  @Test
+  public void keepAliveManagerOnDataReceived_pingActRead() throws Exception {
+    manualSetUp();
+    channelRead(pingFrame(true /* isAck */, 1234L));
+
+    verify(spyKeepAliveManager).onDataReceived();
+    verify(spyKeepAliveManager, never()).onTransportTermination();
+  }
+
+  @Test
+  public void keepAliveManagerOnTransportTermination() throws Exception {
+    manualSetUp();
+    handler().channelInactive(handler().ctx());
+
+    verify(spyKeepAliveManager).onTransportTermination();
+  }
+
+  @Test
+  public void keepAliveManager_pingSent() throws Exception {
+    keepAliveTimeInNanos = TimeUnit.MILLISECONDS.toNanos(10L);
+    keepAliveTimeoutInNanos = TimeUnit.MINUTES.toNanos(30L);
+    manualSetUp();
+
+    assertEquals(0, transportTracer.getStats().keepAlivesSent);
+    fakeClock().forwardNanos(keepAliveTimeInNanos);
+    assertEquals(1, transportTracer.getStats().keepAlivesSent);
+
+    verifyWrite().writePing(eq(ctx()), eq(false), eq(0xDEADL), any(ChannelPromise.class));
+
+    spyKeepAliveManager.onDataReceived();
+    fakeClock().forwardTime(10L, TimeUnit.MILLISECONDS);
+
+    verifyWrite(times(2))
+        .writePing(eq(ctx()), eq(false), eq(0xDEADL), any(ChannelPromise.class));
+    assertTrue(channel().isOpen());
+  }
+
+  @Test
+  public void keepAliveManager_pingTimeout() throws Exception {
+    keepAliveTimeInNanos = 123L /* nanoseconds */;
+    keepAliveTimeoutInNanos = 456L /* nanoseconds */;
+    manualSetUp();
+
+    fakeClock().forwardNanos(keepAliveTimeInNanos);
+
+    assertTrue(channel().isOpen());
+
+    fakeClock().forwardNanos(keepAliveTimeoutInNanos);
+
+    assertFalse(channel().isOpen());
+  }
+
+  @Test
+  public void keepAliveEnforcer_enforcesPings() throws Exception {
+    permitKeepAliveWithoutCalls = false;
+    permitKeepAliveTimeInNanos = TimeUnit.HOURS.toNanos(1);
+    manualSetUp();
+
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES + 1; i++) {
+      channelRead(pingFrame(false /* isAck */, 1L));
+    }
+    verifyWrite().writeGoAway(eq(ctx()), eq(0), eq(Http2Error.ENHANCE_YOUR_CALM.code()),
+        any(ByteBuf.class), any(ChannelPromise.class));
+    assertFalse(channel().isActive());
+  }
+
+  @Test
+  public void keepAliveEnforcer_sendingDataResetsCounters() throws Exception {
+    permitKeepAliveWithoutCalls = false;
+    permitKeepAliveTimeInNanos = TimeUnit.HOURS.toNanos(1);
+    manualSetUp();
+
+    createStream();
+    Http2Headers headers = Utils.convertServerHeaders(new Metadata());
+    ChannelFuture future = enqueue(
+        SendResponseHeadersCommand.createHeaders(stream.transportState(), headers));
+    future.get();
+    for (int i = 0; i < 10; i++) {
+      future = enqueue(
+          new SendGrpcFrameCommand(stream.transportState(), content(), false));
+      future.get();
+      channel().releaseOutbound();
+      channelRead(pingFrame(false /* isAck */, 1L));
+    }
+    verifyWrite(never()).writeGoAway(eq(ctx()), eq(STREAM_ID),
+        eq(Http2Error.ENHANCE_YOUR_CALM.code()), any(ByteBuf.class), any(ChannelPromise.class));
+  }
+
+  @Test
+  public void keepAliveEnforcer_initialIdle() throws Exception {
+    permitKeepAliveWithoutCalls = false;
+    permitKeepAliveTimeInNanos = 0;
+    manualSetUp();
+
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES + 1; i++) {
+      channelRead(pingFrame(false /* isAck */, 1L));
+    }
+    verifyWrite().writeGoAway(eq(ctx()), eq(0),
+        eq(Http2Error.ENHANCE_YOUR_CALM.code()), any(ByteBuf.class), any(ChannelPromise.class));
+    assertFalse(channel().isActive());
+  }
+
+  @Test
+  public void keepAliveEnforcer_noticesActive() throws Exception {
+    permitKeepAliveWithoutCalls = false;
+    permitKeepAliveTimeInNanos = 0;
+    manualSetUp();
+
+    createStream();
+    for (int i = 0; i < 10; i++) {
+      channelRead(pingFrame(false /* isAck */, 1L));
+    }
+    verifyWrite(never()).writeGoAway(eq(ctx()), eq(STREAM_ID),
+        eq(Http2Error.ENHANCE_YOUR_CALM.code()), any(ByteBuf.class), any(ChannelPromise.class));
+  }
+
+  @Test
+  public void keepAliveEnforcer_noticesInactive() throws Exception {
+    permitKeepAliveWithoutCalls = false;
+    permitKeepAliveTimeInNanos = 0;
+    manualSetUp();
+
+    createStream();
+    channelRead(rstStreamFrame(STREAM_ID, (int) Http2Error.CANCEL.code()));
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES + 1; i++) {
+      channelRead(pingFrame(false /* isAck */, 1L));
+    }
+    verifyWrite().writeGoAway(eq(ctx()), eq(STREAM_ID),
+        eq(Http2Error.ENHANCE_YOUR_CALM.code()), any(ByteBuf.class), any(ChannelPromise.class));
+    assertFalse(channel().isActive());
+  }
+
+  @Test
+  public void noGoAwaySentBeforeMaxConnectionIdleReached() throws Exception {
+    maxConnectionIdleInNanos = TimeUnit.MINUTES.toNanos(30L);
+    manualSetUp();
+
+    fakeClock().forwardTime(20, TimeUnit.MINUTES);
+
+    // GO_AWAY not sent yet
+    verifyWrite(never())
+        .writeGoAway(
+            any(ChannelHandlerContext.class),
+            anyInt(),
+            anyLong(),
+            any(ByteBuf.class),
+            any(ChannelPromise.class));
+    assertTrue(channel().isOpen());
+  }
+
+  @Test
+  public void maxConnectionIdle_goAwaySent_pingAck() throws Exception {
+    maxConnectionIdleInNanos = TimeUnit.MILLISECONDS.toNanos(10L);
+    manualSetUp();
+    assertTrue(channel().isOpen());
+
+    fakeClock().forwardNanos(maxConnectionIdleInNanos);
+
+    // first GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(Integer.MAX_VALUE), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // ping sent
+    verifyWrite().writePing(
+        eq(ctx()), eq(false), eq(0x97ACEF001L), any(ChannelPromise.class));
+    verifyWrite(never()).writeGoAway(
+        eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+
+    channelRead(pingFrame(true /* isAck */, 0xDEADL)); // irrelevant ping Ack
+    verifyWrite(never()).writeGoAway(
+        eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    assertTrue(channel().isOpen());
+
+    channelRead(pingFrame(true /* isAck */, 0x97ACEF001L));
+
+    // second GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // channel closed
+    assertFalse(channel().isOpen());
+  }
+
+  @Test
+  public void maxConnectionIdle_goAwaySent_pingTimeout() throws Exception {
+    maxConnectionIdleInNanos = TimeUnit.MILLISECONDS.toNanos(10L);
+    manualSetUp();
+    assertTrue(channel().isOpen());
+
+    fakeClock().forwardNanos(maxConnectionIdleInNanos);
+
+    // first GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(Integer.MAX_VALUE), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // ping sent
+    verifyWrite().writePing(
+        eq(ctx()), eq(false), eq(0x97ACEF001L), any(ChannelPromise.class));
+    verifyWrite(never()).writeGoAway(
+        eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    assertTrue(channel().isOpen());
+
+    fakeClock().forwardTime(10, TimeUnit.SECONDS);
+
+    // second GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // channel closed
+    assertFalse(channel().isOpen());
+  }
+
+  @Test
+  public void maxConnectionIdle_activeThenRst_pingAck() throws Exception {
+    maxConnectionIdleInNanos = TimeUnit.MILLISECONDS.toNanos(10L);
+    manualSetUp();
+    createStream();
+
+    fakeClock().forwardNanos(maxConnectionIdleInNanos);
+
+    // GO_AWAY not sent when active
+    verifyWrite(never())
+        .writeGoAway(
+            any(ChannelHandlerContext.class),
+            anyInt(),
+            anyLong(),
+            any(ByteBuf.class),
+            any(ChannelPromise.class));
+    assertTrue(channel().isOpen());
+
+    channelRead(rstStreamFrame(STREAM_ID, (int) Http2Error.CANCEL.code()));
+
+    fakeClock().forwardNanos(maxConnectionIdleInNanos);
+
+    // first GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(Integer.MAX_VALUE), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // ping sent
+    verifyWrite().writePing(
+        eq(ctx()), eq(false), eq(0x97ACEF001L), any(ChannelPromise.class));
+    verifyWrite(never()).writeGoAway(
+        eq(ctx()), eq(STREAM_ID), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    assertTrue(channel().isOpen());
+
+    fakeClock().forwardTime(10, TimeUnit.SECONDS);
+
+    // second GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(STREAM_ID), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // channel closed
+    assertFalse(channel().isOpen());
+  }
+
+  @Test
+  public void maxConnectionIdle_activeThenRst_pingTimeoutk() throws Exception {
+    maxConnectionIdleInNanos = TimeUnit.MILLISECONDS.toNanos(10L);
+    manualSetUp();
+    createStream();
+
+    fakeClock().forwardNanos(maxConnectionIdleInNanos);
+
+    // GO_AWAY not sent when active
+    verifyWrite(never())
+        .writeGoAway(
+            any(ChannelHandlerContext.class),
+            anyInt(),
+            anyLong(),
+            any(ByteBuf.class),
+            any(ChannelPromise.class));
+    assertTrue(channel().isOpen());
+
+    channelRead(rstStreamFrame(STREAM_ID, (int) Http2Error.CANCEL.code()));
+
+    fakeClock().forwardNanos(maxConnectionIdleInNanos);
+
+    // first GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(Integer.MAX_VALUE), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // ping sent
+    verifyWrite().writePing(
+        eq(ctx()), eq(false), eq(0x97ACEF001L), any(ChannelPromise.class));
+    verifyWrite(never()).writeGoAway(
+        eq(ctx()), eq(STREAM_ID), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    assertTrue(channel().isOpen());
+
+    channelRead(pingFrame(true /* isAck */, 0x97ACEF001L));
+
+    // second GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(STREAM_ID), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // channel closed
+    assertFalse(channel().isOpen());
+  }
+
+  @Test
+  public void noGoAwaySentBeforeMaxConnectionAgeReached() throws Exception {
+    maxConnectionAgeInNanos = TimeUnit.MINUTES.toNanos(30L);
+    manualSetUp();
+
+    fakeClock().forwardTime(20, TimeUnit.MINUTES);
+
+    // GO_AWAY not sent yet
+    verifyWrite(never())
+        .writeGoAway(
+            any(ChannelHandlerContext.class),
+            anyInt(),
+            anyLong(),
+            any(ByteBuf.class),
+            any(ChannelPromise.class));
+    assertTrue(channel().isOpen());
+  }
+
+  @Test
+  public void maxConnectionAge_goAwaySent_pingAck() throws Exception {
+
+    maxConnectionAgeInNanos = TimeUnit.MILLISECONDS.toNanos(10L);
+    manualSetUp();
+    assertTrue(channel().isOpen());
+
+    fakeClock().forwardNanos(maxConnectionAgeInNanos);
+
+    // first GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(Integer.MAX_VALUE), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // ping sent
+    verifyWrite().writePing(
+        eq(ctx()), eq(false), eq(0x97ACEF001L), any(ChannelPromise.class));
+    verifyWrite(never()).writeGoAway(
+        eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+
+    channelRead(pingFrame(true /* isAck */, 0xDEADL)); // irrelevant ping Ack
+    verifyWrite(never()).writeGoAway(
+        eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    assertTrue(channel().isOpen());
+
+    channelRead(pingFrame(true /* isAck */, 0x97ACEF001L));
+
+    // second GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // channel closed
+    assertFalse(channel().isOpen());
+  }
+
+  @Test
+  public void maxConnectionAge_goAwaySent_pingTimeout() throws Exception {
+
+    maxConnectionAgeInNanos = TimeUnit.MILLISECONDS.toNanos(10L);
+    manualSetUp();
+    assertTrue(channel().isOpen());
+
+    fakeClock().forwardNanos(maxConnectionAgeInNanos);
+
+    // first GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(Integer.MAX_VALUE), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // ping sent
+    verifyWrite().writePing(
+        eq(ctx()), eq(false), eq(0x97ACEF001L), any(ChannelPromise.class));
+    verifyWrite(never()).writeGoAway(
+        eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    assertTrue(channel().isOpen());
+
+    fakeClock().forwardTime(10, TimeUnit.SECONDS);
+
+    // second GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(0), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // channel closed
+    assertFalse(channel().isOpen());
+  }
+
+  @Test
+  public void maxConnectionAgeGrace_channelStillOpenDuringGracePeriod() throws Exception {
+    maxConnectionAgeInNanos = TimeUnit.MILLISECONDS.toNanos(10L);
+    maxConnectionAgeGraceInNanos = TimeUnit.MINUTES.toNanos(30L);
+    manualSetUp();
+    createStream();
+
+    fakeClock().forwardNanos(maxConnectionAgeInNanos);
+
+    // first GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(Integer.MAX_VALUE), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // ping sent
+    verifyWrite().writePing(
+        eq(ctx()), eq(false), eq(0x97ACEF001L), any(ChannelPromise.class));
+    verifyWrite(never()).writeGoAway(
+        eq(ctx()), eq(STREAM_ID), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+
+    fakeClock().forwardTime(20, TimeUnit.MINUTES);
+
+    // second GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(STREAM_ID), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // channel not closed yet
+    assertTrue(channel().isOpen());
+  }
+
+  @Test
+  public void maxConnectionAgeGrace_channelClosedAfterGracePeriod_withPingTimeout()
+      throws Exception {
+    maxConnectionAgeInNanos = TimeUnit.MILLISECONDS.toNanos(10L);
+    maxConnectionAgeGraceInNanos = TimeUnit.MINUTES.toNanos(30L); // greater than ping timeout
+    manualSetUp();
+    createStream();
+
+    fakeClock().forwardNanos(maxConnectionAgeInNanos);
+
+    // first GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(Integer.MAX_VALUE), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // ping sent
+    verifyWrite().writePing(
+        eq(ctx()), eq(false), eq(0x97ACEF001L), any(ChannelPromise.class));
+    verifyWrite(never()).writeGoAway(
+        eq(ctx()), eq(STREAM_ID), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+
+    fakeClock().forwardNanos(TimeUnit.SECONDS.toNanos(10));
+
+    // second GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(STREAM_ID), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+
+    fakeClock().forwardNanos(maxConnectionAgeGraceInNanos - 2);
+
+    assertTrue(channel().isOpen());
+
+    fakeClock().forwardTime(2, TimeUnit.MILLISECONDS);
+
+    // channel closed
+    assertFalse(channel().isOpen());
+  }
+
+  @Test
+  public void maxConnectionAgeGrace_channelClosedAfterGracePeriod_withPingAck()
+      throws Exception {
+    maxConnectionAgeInNanos = TimeUnit.MILLISECONDS.toNanos(10L);
+    maxConnectionAgeGraceInNanos = TimeUnit.MINUTES.toNanos(30L); // greater than ping timeout
+    manualSetUp();
+    createStream();
+
+    fakeClock().forwardNanos(maxConnectionAgeInNanos);
+
+    // first GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(Integer.MAX_VALUE), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+    // ping sent
+    verifyWrite().writePing(
+        eq(ctx()), eq(false), eq(0x97ACEF001L), any(ChannelPromise.class));
+    verifyWrite(never()).writeGoAway(
+        eq(ctx()), eq(STREAM_ID), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+
+    long pingRoundTripMillis = 100;  // less than ping timeout
+    fakeClock().forwardTime(pingRoundTripMillis, TimeUnit.MILLISECONDS);
+    channelRead(pingFrame(true /* isAck */, 0x97ACEF001L));
+
+    // second GO_AWAY sent
+    verifyWrite().writeGoAway(
+        eq(ctx()), eq(STREAM_ID), eq(Http2Error.NO_ERROR.code()), any(ByteBuf.class),
+        any(ChannelPromise.class));
+
+    fakeClock().forwardNanos(maxConnectionAgeGraceInNanos - TimeUnit.MILLISECONDS.toNanos(2));
+
+    assertTrue(channel().isOpen());
+
+    fakeClock().forwardTime(2, TimeUnit.MILLISECONDS);
+
+    // channel closed
+    assertFalse(channel().isOpen());
+  }
+
+  @Test
+  public void maxRstCount_withinLimit_succeeds() throws Exception {
+    maxRstCount = 10;
+    maxRstPeriodNanos = TimeUnit.MILLISECONDS.toNanos(100);
+    manualSetUp();
+    rapidReset(maxRstCount);
+
+    assertTrue(channel().isOpen());
+  }
+
+  @Test
+  public void maxRstCount_exceedsLimit_fails() throws Exception {
+    maxRstCount = 10;
+    maxRstPeriodNanos = TimeUnit.MILLISECONDS.toNanos(100);
+    manualSetUp();
+    assertThrows(ClosedChannelException.class, () -> rapidReset(maxRstCount + 1));
+
+    assertFalse(channel().isOpen());
+  }
+
+  private void rapidReset(int burstSize) throws Exception {
+    when(streamTracerFactory.newServerStreamTracer(anyString(), any(Metadata.class)))
+        .thenAnswer((args) -> new TestServerStreamTracer());
+    Http2Headers headers = new DefaultHttp2Headers()
+        .method(HTTP_METHOD)
+        .set(CONTENT_TYPE_HEADER, new AsciiString("application/grpc", UTF_8))
+        .set(TE_HEADER, TE_TRAILERS)
+        .path(new AsciiString("/foo/bar"));
+    int streamId = 1;
+    long rpcTimeNanos = maxRstPeriodNanos / 2 / burstSize;
+    for (int period = 0; period < 3; period++) {
+      for (int i = 0; i < burstSize; i++) {
+        channelRead(headersFrame(streamId, headers));
+        channelRead(rstStreamFrame(streamId, (int) Http2Error.CANCEL.code()));
+        streamId += 2;
+        fakeClock().forwardNanos(rpcTimeNanos);
+      }
+      while (channel().readOutbound() != null) {}
+      fakeClock().forwardNanos(maxRstPeriodNanos - rpcTimeNanos * burstSize + 1);
+    }
+  }
+
+  @Test
+  public void maxRstCountSent_withinLimit_succeeds() throws Exception {
+    maxRstCount = 10;
+    maxRstPeriodNanos = TimeUnit.MILLISECONDS.toNanos(100);
+    manualSetUp();
+    madeYouReset(maxRstCount);
+
+    assertTrue(channel().isOpen());
+  }
+
+  @Test
+  public void maxRstCountSent_exceedsLimit_fails() throws Exception {
+    maxRstCount = 10;
+    maxRstPeriodNanos = TimeUnit.MILLISECONDS.toNanos(100);
+    manualSetUp();
+    assertThrows(ClosedChannelException.class, () -> madeYouReset(maxRstCount + 1));
+
+    assertFalse(channel().isOpen());
+  }
+
+  private void madeYouReset(int burstSize) throws Exception {
+    when(streamTracerFactory.newServerStreamTracer(anyString(), any(Metadata.class)))
+        .thenAnswer((args) -> new TestServerStreamTracer());
+    Http2Headers headers = new DefaultHttp2Headers()
+        .method(HTTP_METHOD)
+        .set(CONTENT_TYPE_HEADER, new AsciiString("application/grpc", UTF_8))
+        .set(TE_HEADER, TE_TRAILERS)
+        .path(new AsciiString("/foo/bar"));
+    int streamId = 1;
+    long rpcTimeNanos = maxRstPeriodNanos / 2 / burstSize;
+    for (int period = 0; period < 3; period++) {
+      for (int i = 0; i < burstSize; i++) {
+        channelRead(headersFrame(streamId, headers));
+        channelRead(windowUpdate(streamId, 0));
+        streamId += 2;
+        fakeClock().forwardNanos(rpcTimeNanos);
+      }
+      while (channel().readOutbound() != null) {}
+      fakeClock().forwardNanos(maxRstPeriodNanos - rpcTimeNanos * burstSize + 1);
+    }
+  }
+
   private void createStream() throws Exception {
     Http2Headers headers = new DefaultHttp2Headers()
         .method(HTTP_METHOD)
@@ -360,17 +1388,35 @@ private void createStream() throws Exception {
 
   private ByteBuf emptyGrpcFrame(int streamId, boolean endStream) throws Exception {
     ByteBuf buf = NettyTestUtil.messageFrame("");
-    try {
-      return dataFrame(streamId, endStream, buf);
-    } finally {
-      buf.release();
-    }
+    return dataFrame(streamId, endStream, buf);
   }
 
   @Override
   protected NettyServerHandler newHandler() {
-    return NettyServerHandler.newHandler(frameReader(), frameWriter(), transportListener,
-        maxConcurrentStreams, flowControlWindow, maxHeaderListSize, DEFAULT_MAX_MESSAGE_SIZE);
+    return NettyServerHandler.newHandler(
+        /* channelUnused= */ channel().newPromise(),
+        frameReader(),
+        frameWriter(),
+        transportListener,
+        Arrays.asList(streamTracerFactory),
+        transportTracer,
+        maxConcurrentStreams,
+        autoFlowControl,
+        flowControlWindow,
+        maxHeaderListSize,
+        softLimitHeaderListSize,
+        DEFAULT_MAX_MESSAGE_SIZE,
+        keepAliveTimeInNanos,
+        keepAliveTimeoutInNanos,
+        maxConnectionIdleInNanos,
+        maxConnectionAgeInNanos,
+        maxConnectionAgeGraceInNanos,
+        permitKeepAliveWithoutCalls,
+        permitKeepAliveTimeInNanos,
+        maxRstCount,
+        maxRstPeriodNanos,
+        Attributes.EMPTY,
+        fakeClock().getTicker());
   }
 
   @Override
@@ -382,4 +1428,14 @@ protected WriteQueue initWriteQueue() {
   protected void makeStream() throws Exception {
     createStream();
   }
+
+  @Override
+  protected AbstractStream stream() throws Exception {
+    if (stream == null) {
+      makeStream();
+    }
+
+    return stream;
+  }
+
 }
diff --git a/netty/src/test/java/io/grpc/netty/NettyServerProviderTest.java b/netty/src/test/java/io/grpc/netty/NettyServerProviderTest.java
index 16214ac016e..6301ca51bef 100644
--- a/netty/src/test/java/io/grpc/netty/NettyServerProviderTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyServerProviderTest.java
@@ -1,40 +1,28 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ServerCredentials;
 import io.grpc.ServerProvider;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -60,4 +48,20 @@ public void basicMethods() {
   public void builderIsANettyBuilder() {
     assertSame(NettyServerBuilder.class, provider.builderForPort(443).getClass());
   }
+
+  @Test
+  public void newServerBuilderForPort_success() {
+    ServerProvider.NewServerBuilderResult result =
+        provider.newServerBuilderForPort(80, InsecureServerCredentials.create());
+    assertThat(result.getServerBuilder()).isInstanceOf(NettyServerBuilder.class);
+  }
+
+  @Test
+  public void newServerBuilderForPort_fail() {
+    ServerProvider.NewServerBuilderResult result = provider.newServerBuilderForPort(
+        80, new FakeServerCredentials());
+    assertThat(result.getError()).contains("FakeServerCredentials");
+  }
+
+  private static final class FakeServerCredentials extends ServerCredentials {}
 }
diff --git a/netty/src/test/java/io/grpc/netty/NettyServerStreamTest.java b/netty/src/test/java/io/grpc/netty/NettyServerStreamTest.java
index 5de28f801e4..2f2933ae103 100644
--- a/netty/src/test/java/io/grpc/netty/NettyServerStreamTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyServerStreamTest.java
@@ -1,79 +1,81 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
 import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
+import static com.google.common.truth.Truth.assertWithMessage;
 import static io.grpc.netty.NettyTestUtil.messageFrame;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyBoolean;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.isA;
-import static org.mockito.Matchers.same;
+import static io.netty.handler.codec.http2.Http2Error.PROTOCOL_ERROR;
+import static io.netty.handler.codec.http2.Http2Exception.connectionError;
+import static org.junit.Assert.assertNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
 import static org.mockito.Mockito.when;
 
+import com.google.common.base.Strings;
 import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.Iterables;
 import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Lists;
 import io.grpc.Attributes;
 import io.grpc.Metadata;
 import io.grpc.Status;
 import io.grpc.internal.ServerStreamListener;
 import io.grpc.internal.StatsTraceContext;
-import io.grpc.netty.WriteQueue.QueuedCommand;
+import io.grpc.internal.StreamListener;
+import io.grpc.internal.TransportTracer;
 import io.netty.buffer.EmptyByteBuf;
 import io.netty.buffer.UnpooledByteBufAllocator;
-import io.netty.channel.ChannelPromise;
+import io.netty.channel.DefaultChannelPromise;
 import io.netty.handler.codec.http2.DefaultHttp2Headers;
+import io.netty.handler.codec.http2.Http2Exception;
 import io.netty.util.AsciiString;
 import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.InOrder;
 import org.mockito.Mock;
+import org.mockito.Mockito;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
 /** Unit tests for {@link NettyServerStream}. */
 @RunWith(JUnit4.class)
 public class NettyServerStreamTest extends NettyStreamTestBase<NettyServerStream> {
+  private static final int TEST_MAX_MESSAGE_SIZE = 128;
+
   @Mock
   protected ServerStreamListener serverListener;
 
@@ -81,6 +83,7 @@ public class NettyServerStreamTest extends NettyStreamTestBase<NettyServerStream
   private NettyServerHandler handler;
 
   private Metadata trailers = new Metadata();
+  private final Queue<InputStream> listenerMessageQueue = new LinkedList<>();
 
   @Before
   @Override
@@ -90,6 +93,22 @@ public void setUp() {
     // Verify onReady notification and then reset it.
     verify(listener()).onReady();
     reset(listener());
+
+    doAnswer(
+          new Answer<Void>() {
+            @Override
+            public Void answer(InvocationOnMock invocation) throws Throwable {
+              StreamListener.MessageProducer producer =
+                  (StreamListener.MessageProducer) invocation.getArguments()[0];
+              InputStream message;
+              while ((message = producer.next()) != null) {
+                listenerMessageQueue.add(message);
+              }
+              return null;
+            }
+          })
+        .when(serverListener)
+        .messagesAvailable(ArgumentMatchers.<StreamListener.MessageProducer>any());
   }
 
   @Test
@@ -99,13 +118,13 @@ public void writeMessageShouldSendResponse() throws Exception {
             .status(Utils.STATUS_OK)
             .set(Utils.CONTENT_TYPE_HEADER, Utils.CONTENT_TYPE_GRPC));
 
-    stream.writeHeaders(new Metadata());
+    stream.writeHeaders(new Metadata(), true);
 
     ArgumentCaptor<SendResponseHeadersCommand> sendHeadersCap =
         ArgumentCaptor.forClass(SendResponseHeadersCommand.class);
     verify(writeQueue).enqueue(sendHeadersCap.capture(), eq(true));
     SendResponseHeadersCommand sendHeaders = sendHeadersCap.getValue();
-    assertThat(sendHeaders.stream()).isSameAs(stream.transportState());
+    assertThat(sendHeaders.stream()).isSameInstanceAs(stream.transportState());
     assertThat(ImmutableListMultimap.copyOf(sendHeaders.headers()))
         .containsExactlyEntriesIn(expectedHeaders);
     assertThat(sendHeaders.endOfStream()).isFalse();
@@ -116,23 +135,116 @@ public void writeMessageShouldSendResponse() throws Exception {
 
     verify(writeQueue).enqueue(
         eq(new SendGrpcFrameCommand(stream.transportState(), messageFrame(MESSAGE), false)),
-        isA(ChannelPromise.class),
         eq(true));
   }
 
+  @Test
+  public void writeFrameFutureFailedShouldCancelRpc() {
+    Http2Exception h2Error = connectionError(PROTOCOL_ERROR, "Stream does not exist %d", STREAM_ID);
+    when(writeQueue.enqueue(any(SendGrpcFrameCommand.class), anyBoolean())).thenReturn(
+        new DefaultChannelPromise(channel).setFailure(h2Error));
+
+    // Write multiple messages to ensure multiple SendGrpcFrameCommand are enqueued. We set up all
+    // of them to fail, which allows us to assert that only a single cancel is sent, and the stream
+    // isn't spammed with multiple RST_STREAM.
+    stream.writeMessage(new ByteArrayInputStream(smallMessage()));
+    stream.writeMessage(new ByteArrayInputStream(largeMessage()));
+    stream.flush();
+
+    verifyWriteFutureFailure(h2Error);
+    // Verify CancelServerStreamCommand enqueued once, right after first SendGrpcFrameCommand.
+    InOrder inOrder = Mockito.inOrder(writeQueue);
+    inOrder.verify(writeQueue).enqueue(any(SendGrpcFrameCommand.class), eq(false));
+    // Verify that failed SendGrpcFrameCommand results in immediate CancelServerStreamCommand.
+    inOrder.verify(writeQueue).enqueue(any(CancelServerStreamCommand.class), eq(true));
+    // Verify that any other failures do not produce another CancelServerStreamCommand in the queue.
+    inOrder.verify(writeQueue, atLeast(0)).enqueue(any(SendGrpcFrameCommand.class), eq(false));
+    inOrder.verify(writeQueue).enqueue(any(SendGrpcFrameCommand.class), eq(true));
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void writeHeadersFutureFailedShouldCancelRpc() {
+    Http2Exception h2Error = connectionError(PROTOCOL_ERROR, "Stream does not exist %d", STREAM_ID);
+    Class<SendResponseHeadersCommand> headersCommandClass = SendResponseHeadersCommand.class;
+    when(writeQueue.enqueue(any(headersCommandClass), anyBoolean())).thenReturn(
+        new DefaultChannelPromise(channel).setFailure(h2Error));
+
+    // Prepare different headers to make it easier to distinguish in the error message.
+    Metadata headers1 = new Metadata();
+    headers1.put(Metadata.Key.of("writeHeaders", Metadata.ASCII_STRING_MARSHALLER), "1");
+    Metadata headers2 = new Metadata();
+    headers2.put(Metadata.Key.of("writeHeaders", Metadata.ASCII_STRING_MARSHALLER), "2");
+    Metadata headers3 = new Metadata();
+    headers3.put(Metadata.Key.of("writeHeaders", Metadata.ASCII_STRING_MARSHALLER), "3");
+
+    // Note writeHeaders flush argument shouldn't matter for this test.
+    stream().writeHeaders(headers1, false);
+    stream().writeHeaders(headers2, false);
+    stream().writeHeaders(headers3, true);
+    stream.flush();
+
+    verifyWriteFutureFailure(h2Error);
+    // Verify CancelServerStreamCommand enqueued once, right after first SendResponseHeadersCommand.
+    InOrder inOrder = Mockito.inOrder(writeQueue);
+    inOrder.verify(writeQueue).enqueue(any(headersCommandClass), anyBoolean());
+    inOrder.verify(writeQueue).enqueue(any(CancelServerStreamCommand.class), eq(true));
+    inOrder.verify(writeQueue, atLeast(1)).enqueue(any(headersCommandClass), anyBoolean());
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void writeTrailersFutureFailedShouldCancelRpc() {
+    Http2Exception h2Error = connectionError(PROTOCOL_ERROR, "Stream does not exist %d", STREAM_ID);
+    when(writeQueue.enqueue(any(SendResponseHeadersCommand.class), eq(true))).thenReturn(
+        new DefaultChannelPromise(channel).setFailure(h2Error));
+
+    stream().close(Status.OK, trailers);
+
+    verifyWriteFutureFailure(h2Error);
+    verify(writeQueue).enqueue(any(CancelServerStreamCommand.class), eq(true));
+  }
+
+  private void verifyWriteFutureFailure(Http2Exception h2Error) {
+    // Check the error that caused the future write failure propagated via Status.
+    Status cancelReason = findCancelServerStreamCommand().reason();
+    assertThat(cancelReason.getCode()).isEqualTo(Status.INTERNAL.getCode());
+    assertThat(cancelReason.getCause()).isEqualTo(h2Error);
+    // Verify the listener has closed.
+    verify(serverListener).closed(same(cancelReason));
+  }
+
+  private CancelServerStreamCommand findCancelServerStreamCommand() {
+    // Ensure there's no CancelServerStreamCommand enqueued with flush=false.
+    verify(writeQueue, never()).enqueue(any(CancelServerStreamCommand.class), eq(false));
+
+    List<CancelServerStreamCommand> commands = Lists.newArrayList(
+        Iterables.transform(
+          Iterables.filter(
+            Mockito.mockingDetails(writeQueue).getInvocations(),
+            // Get enqueue() innovations only
+            invocation -> invocation.getMethod().getName().equals("enqueue")
+              // Find the cancel commands.
+              && invocation.getArgument(0) instanceof CancelServerStreamCommand),
+          invocation -> invocation.getArgument(0, CancelServerStreamCommand.class)));
+
+    assertWithMessage("Expected exactly one CancelClientStreamCommand").that(commands).hasSize(1);
+    return commands.get(0);
+  }
+
   @Test
   public void writeHeadersShouldSendHeaders() throws Exception {
     Metadata headers = new Metadata();
     ListMultimap<CharSequence, CharSequence> expectedHeaders =
         ImmutableListMultimap.copyOf(Utils.convertServerHeaders(headers));
 
-    stream().writeHeaders(headers);
+    stream().writeHeaders(headers, true);
 
     ArgumentCaptor<SendResponseHeadersCommand> sendHeadersCap =
         ArgumentCaptor.forClass(SendResponseHeadersCommand.class);
     verify(writeQueue).enqueue(sendHeadersCap.capture(), eq(true));
     SendResponseHeadersCommand sendHeaders = sendHeadersCap.getValue();
-    assertThat(sendHeaders.stream()).isSameAs(stream.transportState());
+    assertThat(sendHeaders.stream()).isSameInstanceAs(stream.transportState());
     assertThat(ImmutableListMultimap.copyOf(sendHeaders.headers()))
         .containsExactlyEntriesIn(expectedHeaders);
     assertThat(sendHeaders.endOfStream()).isFalse();
@@ -152,17 +264,17 @@ public void closeBeforeClientHalfCloseShouldSucceed() throws Exception {
         ArgumentCaptor.forClass(SendResponseHeadersCommand.class);
     verify(writeQueue).enqueue(sendHeadersCap.capture(), eq(true));
     SendResponseHeadersCommand sendHeaders = sendHeadersCap.getValue();
-    assertThat(sendHeaders.stream()).isSameAs(stream.transportState());
+    assertThat(sendHeaders.stream()).isSameInstanceAs(stream.transportState());
     assertThat(ImmutableListMultimap.copyOf(sendHeaders.headers()))
         .containsExactlyEntriesIn(expectedHeaders);
     assertThat(sendHeaders.endOfStream()).isTrue();
-    verifyZeroInteractions(serverListener);
+    verifyNoInteractions(serverListener);
 
     // Sending complete. Listener gets closed()
     stream().transportState().complete();
 
     verify(serverListener).closed(Status.OK);
-    verifyZeroInteractions(serverListener);
+    assertNull("no message expected", listenerMessageQueue.poll());
   }
 
   @Test
@@ -180,16 +292,16 @@ public void closeWithErrorBeforeClientHalfCloseShouldSucceed() throws Exception
         ArgumentCaptor.forClass(SendResponseHeadersCommand.class);
     verify(writeQueue).enqueue(sendHeadersCap.capture(), eq(true));
     SendResponseHeadersCommand sendHeaders = sendHeadersCap.getValue();
-    assertThat(sendHeaders.stream()).isSameAs(stream.transportState());
+    assertThat(sendHeaders.stream()).isSameInstanceAs(stream.transportState());
     assertThat(ImmutableListMultimap.copyOf(sendHeaders.headers()))
         .containsExactlyEntriesIn(expectedHeaders);
     assertThat(sendHeaders.endOfStream()).isTrue();
-    verifyZeroInteractions(serverListener);
+    verifyNoInteractions(serverListener);
 
     // Sending complete. Listener gets closed()
     stream().transportState().complete();
     verify(serverListener).closed(Status.OK);
-    verifyZeroInteractions(serverListener);
+    assertNull("no message expected", listenerMessageQueue.poll());
   }
 
   @Test
@@ -208,13 +320,13 @@ public void closeAfterClientHalfCloseShouldSucceed() throws Exception {
 
     // Server closes. Status sent
     stream().close(Status.OK, trailers);
-    verifyNoMoreInteractions(serverListener);
+    assertNull("no message expected", listenerMessageQueue.poll());
 
     ArgumentCaptor<SendResponseHeadersCommand> cmdCap =
         ArgumentCaptor.forClass(SendResponseHeadersCommand.class);
     verify(writeQueue).enqueue(cmdCap.capture(), eq(true));
     SendResponseHeadersCommand cmd = cmdCap.getValue();
-    assertThat(cmd.stream()).isSameAs(stream.transportState());
+    assertThat(cmd.stream()).isSameInstanceAs(stream.transportState());
     assertThat(ImmutableListMultimap.copyOf(cmd.headers()))
         .containsExactlyEntriesIn(expectedHeaders);
     assertThat(cmd.endOfStream()).isTrue();
@@ -222,7 +334,7 @@ public void closeAfterClientHalfCloseShouldSucceed() throws Exception {
     // Sending and receiving complete. Listener gets closed()
     stream().transportState().complete();
     verify(serverListener).closed(Status.OK);
-    verifyNoMoreInteractions(serverListener);
+    assertNull("no message expected", listenerMessageQueue.poll());
   }
 
   @Test
@@ -232,7 +344,7 @@ public void abortStreamAndNotSendStatus() throws Exception {
     verify(serverListener).closed(same(status));
     verify(channel, never()).writeAndFlush(any(SendResponseHeadersCommand.class));
     verify(channel, never()).writeAndFlush(any(SendGrpcFrameCommand.class));
-    verifyNoMoreInteractions(serverListener);
+    assertNull("no message expected", listenerMessageQueue.poll());
   }
 
   @Test
@@ -245,7 +357,7 @@ public void abortStreamAfterClientHalfCloseShouldCallClose() {
     // Abort from the transport layer
     stream().transportState().transportReportStatus(status);
     verify(serverListener).closed(same(status));
-    verifyNoMoreInteractions(serverListener);
+    assertNull("no message expected", listenerMessageQueue.poll());
   }
 
   @Test
@@ -262,7 +374,7 @@ public void emptyFramerShouldSendNoPayload() {
 
     verify(writeQueue).enqueue(cmdCap.capture(), eq(true));
     SendResponseHeadersCommand cmd = cmdCap.getValue();
-    assertThat(cmd.stream()).isSameAs(stream.transportState());
+    assertThat(cmd.stream()).isSameInstanceAs(stream.transportState());
     assertThat(ImmutableListMultimap.copyOf(cmd.headers()))
         .containsExactlyEntriesIn(expectedHeaders);
     assertThat(cmd.endOfStream()).isTrue();
@@ -272,26 +384,40 @@ public void emptyFramerShouldSendNoPayload() {
   public void cancelStreamShouldSucceed() {
     stream().cancel(Status.DEADLINE_EXCEEDED);
     verify(writeQueue).enqueue(
-        new CancelServerStreamCommand(stream().transportState(), Status.DEADLINE_EXCEEDED),
+        CancelServerStreamCommand.withReset(stream().transportState(), Status.DEADLINE_EXCEEDED),
         true);
   }
 
+  @Test
+  public void oversizedMessagesResultInResourceExhaustedTrailers() throws Exception {
+    @SuppressWarnings("InlineMeInliner") // Requires Java 11
+    String oversizedMsg = Strings.repeat("a", TEST_MAX_MESSAGE_SIZE + 1);
+    stream.request(1);
+    stream.transportState().inboundDataReceived(messageFrame(oversizedMsg), false);
+    assertNull("message should have caused a deframer error", listenerMessageQueue().poll());
+
+    ArgumentCaptor<CancelServerStreamCommand> cancelCmdCap =
+            ArgumentCaptor.forClass(CancelServerStreamCommand.class);
+    verify(writeQueue).enqueue(cancelCmdCap.capture(), eq(true));
+
+    Status status = Status.RESOURCE_EXHAUSTED
+            .withDescription("gRPC message exceeds maximum size 128: 129");
+
+    CancelServerStreamCommand actualCmd = cancelCmdCap.getValue();
+    assertThat(actualCmd.reason().getCode()).isEqualTo(status.getCode());
+    assertThat(actualCmd.reason().getDescription()).isEqualTo(status.getDescription());
+    assertThat(actualCmd.wantsHeaders()).isTrue();
+  }
+
   @Override
+  @SuppressWarnings("DirectInvocationOnMock")
   protected NettyServerStream createStream() {
     when(handler.getWriteQueue()).thenReturn(writeQueue);
-    doAnswer(new Answer<Object>() {
-      @Override
-      public Object answer(InvocationOnMock invocation) throws Throwable {
-        if (future.isDone()) {
-          ((ChannelPromise) invocation.getArguments()[1]).setSuccess();
-        }
-        return null;
-      }
-    }).when(writeQueue).enqueue(any(QueuedCommand.class), any(ChannelPromise.class), anyBoolean());
-    when(writeQueue.enqueue(any(QueuedCommand.class), anyBoolean())).thenReturn(future);
     StatsTraceContext statsTraceCtx = StatsTraceContext.NOOP;
+    TransportTracer transportTracer = new TransportTracer();
     NettyServerStream.TransportState state = new NettyServerStream.TransportState(
-        handler, http2Stream, DEFAULT_MAX_MESSAGE_SIZE, statsTraceCtx);
+        handler, channel.eventLoop(), http2Stream, TEST_MAX_MESSAGE_SIZE, statsTraceCtx,
+        transportTracer, "method");
     NettyServerStream stream = new NettyServerStream(channel, state, Attributes.EMPTY,
         "test-authority", statsTraceCtx);
     stream.transportState().setListener(serverListener);
@@ -303,7 +429,7 @@ public Object answer(InvocationOnMock invocation) throws Throwable {
 
   @Override
   protected void sendHeadersIfServer() {
-    stream.writeHeaders(new Metadata());
+    stream.writeHeaders(new Metadata(), true);
   }
 
   @Override
@@ -316,6 +442,11 @@ protected ServerStreamListener listener() {
     return serverListener;
   }
 
+  @Override
+  protected Queue<InputStream> listenerMessageQueue() {
+    return listenerMessageQueue;
+  }
+
   private NettyServerStream stream() {
     return stream;
   }
diff --git a/netty/src/test/java/io/grpc/netty/NettyServerTest.java b/netty/src/test/java/io/grpc/netty/NettyServerTest.java
index caa62de3aa3..f9bda4c5af1 100644
--- a/netty/src/test/java/io/grpc/netty/NettyServerTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyServerTest.java
@@ -1,94 +1,664 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
 import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.InternalChannelz.id;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.Attributes;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.Metadata;
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.FixedObjectPool;
 import io.grpc.internal.ServerListener;
+import io.grpc.internal.ServerStream;
 import io.grpc.internal.ServerTransport;
 import io.grpc.internal.ServerTransportListener;
+import io.grpc.internal.TransportTracer;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFactory;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerAdapter;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelOption;
+import io.netty.channel.EventLoop;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.ReflectiveChannelFactory;
+import io.netty.channel.WriteBufferWaterMark;
+import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.util.AsciiString;
+import io.netty.util.concurrent.Future;
+import java.io.IOException;
 import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.net.SocketAddress;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 @RunWith(JUnit4.class)
 public class NettyServerTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private final InternalChannelz channelz = new InternalChannelz();
+  private final NioEventLoopGroup eventLoop = new NioEventLoopGroup(1);
+  private final ChannelFactory<NioServerSocketChannel> channelFactory =
+      new ReflectiveChannelFactory<>(NioServerSocketChannel.class);
+
+  @Mock
+  EventLoopGroup mockEventLoopGroup;
+  @Mock
+  EventLoop mockEventLoop;
+  @Mock
+  Future<Map<ChannelFuture, SocketAddress>> bindFuture;
+
+  @Before
+  public void setup() throws Exception {
+    when(mockEventLoopGroup.next()).thenReturn(mockEventLoop);
+    when(mockEventLoop
+        .submit(ArgumentMatchers.<Callable<Map<ChannelFuture, SocketAddress>>>any()))
+        .thenReturn(bindFuture);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    eventLoop.shutdownGracefully(0, 0, TimeUnit.SECONDS);
+    eventLoop.awaitTermination(5, TimeUnit.SECONDS);
+  }
 
   @Test
-  public void getPort() throws Exception {
+  public void startStop() throws Exception {
     InetSocketAddress addr = new InetSocketAddress(0);
-    NettyServer ns = new NettyServer(
-        addr,
-        NioServerSocketChannel.class,
-        null, // no boss group
-        null, // no event group
-        new ProtocolNegotiators.PlaintextNegotiator(),
-        1, // ignore
-        1, // ignore
-        1, // ignore
-        1); // ignore
+
+    class NoHandlerProtocolNegotiator implements ProtocolNegotiator {
+      boolean closed;
+
+      @Override public ChannelHandler newHandler(GrpcHttp2ConnectionHandler handler) {
+        throw new UnsupportedOperationException();
+      }
+
+      @Override public void close() {
+        closed = true;
+      }
+
+      @Override public AsciiString scheme() {
+        return Utils.HTTP;
+      }
+    }
+
+    NoHandlerProtocolNegotiator protocolNegotiator = new NoHandlerProtocolNegotiator();
+    NettyServer ns =
+        new NettyServer(
+            Arrays.asList(addr),
+            new ReflectiveChannelFactory<>(NioServerSocketChannel.class),
+            new HashMap<ChannelOption<?>, Object>(),
+            new HashMap<ChannelOption<?>, Object>(),
+            new FixedObjectPool<>(eventLoop),
+            new FixedObjectPool<>(eventLoop),
+            false,
+            protocolNegotiator,
+            Collections.<ServerStreamTracer.Factory>emptyList(),
+            TransportTracer.getDefaultFactory(),
+            1, // ignore
+            false, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1,
+            1, // ignore
+            1,
+            1, // ignore
+            true,
+            0, // ignore
+            0,
+            0, // ignore
+            Attributes.EMPTY,
+            channelz);
+    final SettableFuture<Void> serverShutdownCalled = SettableFuture.create();
     ns.start(new ServerListener() {
       @Override
       public ServerTransportListener transportCreated(ServerTransport transport) {
-        return null;
+        return new NoopServerTransportListener();
       }
 
       @Override
-      public void serverShutdown() {}
+      public void serverShutdown() {
+        serverShutdownCalled.set(null);
+      }
     });
 
     // Check that we got an actual port.
-    assertThat(ns.getPort()).isGreaterThan(0);
+    assertThat(((InetSocketAddress) ns.getListenSocketAddress()).getPort()).isGreaterThan(0);
 
     // Cleanup
     ns.shutdown();
+    // serverShutdown() signals that resources are freed
+    serverShutdownCalled.get(1, TimeUnit.SECONDS);
+    assertThat(protocolNegotiator.closed).isTrue();
+  }
+
+  @Test
+  public void multiPortStartStopGet() throws Exception {
+    InetSocketAddress addr1 = new InetSocketAddress(0);
+    InetSocketAddress addr2 = new InetSocketAddress(0);
+
+    NettyServer ns =
+        new NettyServer(
+            Arrays.asList(addr1, addr2),
+            new ReflectiveChannelFactory<>(NioServerSocketChannel.class),
+            new HashMap<ChannelOption<?>, Object>(),
+            new HashMap<ChannelOption<?>, Object>(),
+            new FixedObjectPool<>(eventLoop),
+            new FixedObjectPool<>(eventLoop),
+            false,
+            ProtocolNegotiators.plaintext(),
+            Collections.<ServerStreamTracer.Factory>emptyList(),
+            TransportTracer.getDefaultFactory(),
+            1, // ignore
+            false, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1,
+            1, // ignore
+            1,
+            1, // ignore
+            true,
+            0, // ignore
+            0,
+            0, // ignore
+            Attributes.EMPTY,
+            channelz);
+    final SettableFuture<Void> shutdownCompleted = SettableFuture.create();
+    ns.start(new ServerListener() {
+      @Override
+      public ServerTransportListener transportCreated(ServerTransport transport) {
+        return new NoopServerTransportListener();
+      }
+
+      @Override
+      public void serverShutdown() {
+        shutdownCompleted.set(null);
+      }
+    });
+
+    // SocketStats won't be available until the event loop task of adding SocketStats created by
+    // ns.start() complete. So submit a noop task and await until it's drained.
+    eventLoop.submit(new Runnable() {
+      @Override
+      public void run() {}
+    }).await(5, TimeUnit.SECONDS);
+
+    assertEquals(2, ns.getListenSocketAddresses().size());
+    for (SocketAddress address: ns.getListenSocketAddresses()) {
+      assertThat(((InetSocketAddress) address).getPort()).isGreaterThan(0);
+    }
+
+    List<InternalInstrumented<SocketStats>> stats = ns.getListenSocketStatsList();
+    assertEquals(2, ns.getListenSocketStatsList().size());
+    for (InternalInstrumented<SocketStats> listenSocket : stats) {
+      assertSame(listenSocket, channelz.getSocket(id(listenSocket)));
+      // very basic sanity check of the contents
+      SocketStats socketStats = listenSocket.getStats().get();
+      assertThat(ns.getListenSocketAddresses()).contains(socketStats.local);
+      assertNull(socketStats.remote);
+    }
+
+    // Cleanup
+    ns.shutdown();
+    shutdownCompleted.get();
+
+    // listen socket is removed
+    for (InternalInstrumented<SocketStats> listenSocket : stats) {
+      assertNull(channelz.getSocket(id(listenSocket)));
+    }
+  }
+
+  @Test(timeout = 60000)
+  public void multiPortConnections() throws Exception {
+    InetSocketAddress addr1 = new InetSocketAddress(0);
+    InetSocketAddress addr2 = new InetSocketAddress(0);
+    final CountDownLatch allPortsConnectedCountDown = new CountDownLatch(2);
+
+    NettyServer ns =
+        new NettyServer(
+            Arrays.asList(addr1, addr2),
+            new ReflectiveChannelFactory<>(NioServerSocketChannel.class),
+            new HashMap<ChannelOption<?>, Object>(),
+            new HashMap<ChannelOption<?>, Object>(),
+            new FixedObjectPool<>(eventLoop),
+            new FixedObjectPool<>(eventLoop),
+            false,
+            ProtocolNegotiators.plaintext(),
+            Collections.<ServerStreamTracer.Factory>emptyList(),
+            TransportTracer.getDefaultFactory(),
+            1, // ignore
+            false, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1,
+            1, // ignore
+            1,
+            1, // ignore
+            true,
+            0, // ignore
+            0,
+            0, // ignore
+            Attributes.EMPTY,
+            channelz);
+    final SettableFuture<Void> shutdownCompleted = SettableFuture.create();
+    ns.start(new ServerListener() {
+      @Override
+      public ServerTransportListener transportCreated(ServerTransport transport) {
+        allPortsConnectedCountDown.countDown();
+        return new NoopServerTransportListener();
+      }
+
+      @Override
+      public void serverShutdown() {
+        shutdownCompleted.set(null);
+      }
+    });
+
+    // SocketStats won't be available until the event loop task of adding SocketStats created by
+    // ns.start() complete. So submit a noop task and await until it's drained.
+    eventLoop.submit(new Runnable() {
+      @Override
+      public void run() {}
+    }).await(5, TimeUnit.SECONDS);
+
+    List<SocketAddress> serverSockets = ns.getListenSocketAddresses();
+    assertEquals(2, serverSockets.size());
+
+    for (int i = 0; i < 2; i++) {
+      Socket socket = new Socket();
+      socket.connect(serverSockets.get(i), /* timeout= */ 8000);
+      socket.close();
+    }
+    allPortsConnectedCountDown.await();
+    // Cleanup
+    ns.shutdown();
+    shutdownCompleted.get();
+  }
+
+  @Test
+  public void getPort_notStarted() {
+    InetSocketAddress addr = new InetSocketAddress(0);
+    List<InetSocketAddress> addresses = Collections.singletonList(addr);
+    NettyServer ns =
+        new NettyServer(
+            addresses,
+            new ReflectiveChannelFactory<>(NioServerSocketChannel.class),
+            new HashMap<ChannelOption<?>, Object>(),
+            new HashMap<ChannelOption<?>, Object>(),
+            new FixedObjectPool<>(eventLoop),
+            new FixedObjectPool<>(eventLoop),
+            false,
+            ProtocolNegotiators.plaintext(),
+            Collections.<ServerStreamTracer.Factory>emptyList(),
+            TransportTracer.getDefaultFactory(),
+            1, // ignore
+            false, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1,
+            1, // ignore
+            1,
+            1, // ignore
+            true,
+            0, // ignore
+            0,
+            0, // ignore
+            Attributes.EMPTY,
+            channelz);
+
+    assertThat(ns.getListenSocketAddress()).isEqualTo(addr);
+    assertThat(ns.getListenSocketAddresses()).isEqualTo(addresses);
+  }
+
+  @Test(timeout = 60000)
+  public void connectionSettingsPropagated() throws Exception {
+    final int originalLowWaterMark = 2097169;
+    final int originalHighWaterMark = 2097211;
+
+    Map<ChannelOption<?>, Object> childChannelOptions = new HashMap<>();
+    childChannelOptions.put(ChannelOption.WRITE_BUFFER_WATER_MARK,
+        new WriteBufferWaterMark(originalLowWaterMark, originalHighWaterMark));
+
+    class TestChannelHandler extends ChannelHandlerAdapter {
+      CountDownLatch countDownLatch = new CountDownLatch(1);
+      int lowWaterMark;
+      int highWaterMark;
+
+      @Override public void handlerAdded(ChannelHandlerContext ctx) {
+        Channel channel = ctx.channel();
+        WriteBufferWaterMark writeBufferWaterMark = channel.config()
+            .getOption(ChannelOption.WRITE_BUFFER_WATER_MARK);
+        lowWaterMark = writeBufferWaterMark.low();
+        highWaterMark = writeBufferWaterMark.high();
+
+        countDownLatch.countDown();
+      }
+    }
+
+    final TestChannelHandler channelHandler = new TestChannelHandler();
+
+    class TestProtocolNegotiator implements ProtocolNegotiator {
+      Attributes eagAttributes;
+
+      @Override public ChannelHandler newHandler(GrpcHttp2ConnectionHandler handler) {
+        eagAttributes = handler.getEagAttributes();
+        return channelHandler;
+      }
+
+      @Override public void close() {}
+
+      @Override public AsciiString scheme() {
+        return Utils.HTTP;
+      }
+    }
+
+    Attributes eagAttributes = Attributes.newBuilder()
+        .set(Attributes.Key.create("foo"), "bar")
+        .build();
+    TestProtocolNegotiator protocolNegotiator = new TestProtocolNegotiator();
+    InetSocketAddress addr = new InetSocketAddress(0);
+    NettyServer ns =
+        new NettyServer(
+            Arrays.asList(addr),
+            new ReflectiveChannelFactory<>(NioServerSocketChannel.class),
+            new HashMap<ChannelOption<?>, Object>(),
+            childChannelOptions,
+            new FixedObjectPool<>(eventLoop),
+            new FixedObjectPool<>(eventLoop),
+            false,
+            protocolNegotiator,
+            Collections.<ServerStreamTracer.Factory>emptyList(),
+            TransportTracer.getDefaultFactory(),
+            1, // ignore
+            false, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1,
+            1, // ignore
+            1,
+            1, // ignore
+            true,
+            0, // ignore
+            0,
+            0, // ignore
+            eagAttributes,
+            channelz);
+    ns.start(new ServerListener() {
+      @Override
+      public ServerTransportListener transportCreated(ServerTransport transport) {
+        return new NoopServerTransportListener();
+      }
+
+      @Override
+      public void serverShutdown() {}
+    });
+
+    Socket socket = new Socket();
+    socket.connect(ns.getListenSocketAddress(), /* timeout= */ 8000);
+    channelHandler.countDownLatch.await();
+    socket.close();
+
+    assertThat(protocolNegotiator.eagAttributes).isSameInstanceAs(eagAttributes);
+    assertThat(channelHandler.lowWaterMark).isEqualTo(originalLowWaterMark);
+    assertThat(channelHandler.highWaterMark).isEqualTo(originalHighWaterMark);
+
+    ns.shutdown();
   }
 
   @Test
-  public void getPort_notStarted() throws Exception {
+  public void channelzListenSocket() throws Exception {
     InetSocketAddress addr = new InetSocketAddress(0);
-    NettyServer ns = new NettyServer(
+    NettyServer ns =
+        new NettyServer(
+            Arrays.asList(addr),
+            new ReflectiveChannelFactory<>(NioServerSocketChannel.class),
+            new HashMap<ChannelOption<?>, Object>(),
+            new HashMap<ChannelOption<?>, Object>(),
+            new FixedObjectPool<>(eventLoop),
+            new FixedObjectPool<>(eventLoop),
+            false,
+            ProtocolNegotiators.plaintext(),
+            Collections.<ServerStreamTracer.Factory>emptyList(),
+            TransportTracer.getDefaultFactory(),
+            1, // ignore
+            false, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1, // ignore
+            1,
+            1, // ignore
+            1,
+            1, // ignore
+            true,
+            0, // ignore
+            0,
+            0, // ignore
+            Attributes.EMPTY,
+            channelz);
+    final SettableFuture<Void> shutdownCompleted = SettableFuture.create();
+    ns.start(new ServerListener() {
+      @Override
+      public ServerTransportListener transportCreated(ServerTransport transport) {
+        return new NoopServerTransportListener();
+      }
+
+      @Override
+      public void serverShutdown() {
+        shutdownCompleted.set(null);
+      }
+    });
+
+    assertThat(((InetSocketAddress) ns.getListenSocketAddress()).getPort()).isGreaterThan(0);
+
+    // SocketStats won't be available until the event loop task of adding SocketStats created by
+    // ns.start() complete. So submit a noop task and await until it's drained.
+    eventLoop.submit(new Runnable() {
+      @Override
+      public void run() {}
+    }).await(5, TimeUnit.SECONDS);
+    InternalInstrumented<SocketStats> listenSocket = ns.getListenSocketStats();
+    assertSame(listenSocket, channelz.getSocket(id(listenSocket)));
+
+    // very basic sanity check of the contents
+    SocketStats socketStats = listenSocket.getStats().get();
+    assertEquals(ns.getListenSocketAddress(), socketStats.local);
+    assertNull(socketStats.remote);
+
+    // by default, there are some socket options set on the listen socket
+    assertThat(socketStats.socketOptions.others).isNotEmpty();
+
+    // Cleanup
+    ns.shutdown();
+    shutdownCompleted.get();
+
+    // listen socket is removed
+    assertNull(channelz.getSocket(id(listenSocket)));
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void testBindScheduleFailure() throws Exception {
+    when(bindFuture.awaitUninterruptibly()).thenReturn(bindFuture);
+    when(bindFuture.isSuccess()).thenReturn(false);
+    when(bindFuture.getNow()).thenReturn(null);
+    Throwable mockCause = mock(Throwable.class);
+    when(bindFuture.cause()).thenReturn(mockCause);
+    Future<Void> mockFuture = (Future<Void>) mock(Future.class);
+    doReturn(mockFuture).when(mockEventLoopGroup).submit(any(Runnable.class));
+    SocketAddress addr = new InetSocketAddress(0);
+    verifyServerNotStart(Collections.singletonList(addr), mockEventLoopGroup,
+        IOException.class, "Failed to bind to addresses " + Arrays.asList(addr));
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void testBindFailure() throws Exception {
+    when(bindFuture.awaitUninterruptibly()).thenReturn(bindFuture);
+    ChannelFuture future = mock(ChannelFuture.class);
+    when(future.awaitUninterruptibly()).thenReturn(future);
+    when(future.isSuccess()).thenReturn(false);
+    Channel channel = channelFactory.newChannel();
+    eventLoop.register(channel);
+    when(future.channel()).thenReturn(channel);
+    Throwable mockCause = mock(Throwable.class);
+    when(future.cause()).thenReturn(mockCause);
+    SocketAddress addr = new InetSocketAddress(0);
+    Map<ChannelFuture, SocketAddress> map = ImmutableMap.of(future, addr);
+    when(bindFuture.getNow()).thenReturn(map);
+    when(bindFuture.isSuccess()).thenReturn(true);
+    Future<Void> mockFuture = (Future<Void>) mock(Future.class);
+    doReturn(mockFuture).when(mockEventLoopGroup).submit(any(Runnable.class));
+    verifyServerNotStart(Collections.singletonList(addr), mockEventLoopGroup,
+        IOException.class, "Failed to bind to address " + addr);
+  }
+
+  @Test
+  public void testBindPartialFailure() throws Exception {
+    SocketAddress add1 = new InetSocketAddress(0);
+    SocketAddress add2 = new InetSocketAddress(2);
+    SocketAddress add3 = new InetSocketAddress(2);
+    verifyServerNotStart(ImmutableList.of(add1, add2, add3), eventLoop,
+        IOException.class, "Failed to bind to address " + add3);
+  }
+
+  private void verifyServerNotStart(List<SocketAddress> addr, EventLoopGroup ev,
+      Class<?> expectedException, String expectedMessage)
+      throws Exception {
+    NettyServer ns = getServer(addr, ev);
+    try {
+      ns.start(new ServerListener() {
+        @Override
+        public ServerTransportListener transportCreated(ServerTransport transport) {
+          return new NoopServerTransportListener();
+        }
+
+        @Override
+        public void serverShutdown() {
+        }
+      });
+    } catch (Exception ex) {
+      assertTrue(expectedException.isInstance(ex));
+      assertThat(ex.getMessage()).isEqualTo(expectedMessage);
+      assertFalse(addr.isEmpty());
+      // Listener tasks are executed on the event loop, so await until noop task is drained.
+      ev.submit(new Runnable() {
+        @Override
+        public void run() {}
+      }).await(5, TimeUnit.SECONDS);
+      assertThat(ns.getListenSocketAddress()).isEqualTo(addr.get(0));
+      assertThat(ns.getListenSocketAddresses()).isEqualTo(addr);
+      assertTrue(ns.getListenSocketStatsList().isEmpty());
+      assertNull(ns.getListenSocketStats());
+      return;
+    }
+    fail();
+  }
+
+  private NettyServer getServer(List<SocketAddress> addr, EventLoopGroup ev) {
+    return new NettyServer(
         addr,
-        NioServerSocketChannel.class,
-        null, // no boss group
-        null, // no event group
-        new ProtocolNegotiators.PlaintextNegotiator(),
+        new ReflectiveChannelFactory<>(NioServerSocketChannel.class),
+        new HashMap<ChannelOption<?>, Object>(),
+        new HashMap<ChannelOption<?>, Object>(),
+        new FixedObjectPool<>(ev),
+        new FixedObjectPool<>(ev),
+        false,
+        ProtocolNegotiators.plaintext(),
+        Collections.<ServerStreamTracer.Factory>emptyList(),
+        TransportTracer.getDefaultFactory(),
         1, // ignore
+        false, // ignore
         1, // ignore
         1, // ignore
-        1); // ignore
+        1, // ignore
+        1, // ignore
+        1, // ignore
+        1,
+        1, // ignore
+        1,
+        1, // ignore
+        true,
+        0, // ignore
+        0,
+        0, // ignore
+        Attributes.EMPTY,
+        channelz);
+  }
+
+  private static class NoopServerTransportListener implements ServerTransportListener {
+    @Override public void streamCreated(ServerStream stream, String method, Metadata headers) {}
+
+    @Override public Attributes transportReady(Attributes attributes) {
+      return attributes;
+    }
 
-    assertThat(ns.getPort()).isEqualTo(-1);
+    @Override public void transportTerminated() {}
   }
 }
diff --git a/netty/src/test/java/io/grpc/netty/NettyServerTransportTest.java b/netty/src/test/java/io/grpc/netty/NettyServerTransportTest.java
new file mode 100644
index 00000000000..c4e0b4a2e26
--- /dev/null
+++ b/netty/src/test/java/io/grpc/netty/NettyServerTransportTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2017 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.netty;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.netty.NettyServerTransport.getLogLevel;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import java.io.IOException;
+import java.net.SocketException;
+import java.util.logging.Level;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class NettyServerTransportTest {
+  @Test
+  public void unknownException() {
+    assertEquals(Level.INFO, getLogLevel(new Exception()));
+  }
+
+  @Test
+  public void socketException() {
+    assertEquals(Level.FINE, getLogLevel(new SocketException("Connection reset")));
+  }
+
+  @Test
+  public void ioException() {
+    assertEquals(Level.FINE, getLogLevel(new IOException("Connection reset by peer")));
+    assertEquals(Level.FINE, getLogLevel(new IOException(
+        "An existing connection was forcibly closed by the remote host")));
+  }
+
+  @Test
+  public void ioException_nullMessage() {
+    IOException e = new IOException();
+    assertNull(e.getMessage());
+    assertEquals(Level.FINE, getLogLevel(e));
+  }
+
+  @Test
+  public void extendedIoException() {
+    class ExtendedIoException extends IOException {}
+
+    ExtendedIoException e = new ExtendedIoException();
+    assertThat(e.getMessage()).isNull();
+    assertThat(getLogLevel(e)).isEqualTo(Level.INFO);
+  }
+
+  @Test
+  public void fakeNettyNativeIoException() {
+    class NativeIoException extends IOException {}
+
+    NativeIoException fakeNativeIoException = new NativeIoException();
+
+    assertThat(getLogLevel(fakeNativeIoException)).isEqualTo(Level.FINE);
+  }
+}
diff --git a/netty/src/test/java/io/grpc/netty/NettyStreamTestBase.java b/netty/src/test/java/io/grpc/netty/NettyStreamTestBase.java
index d35b908593c..ce42e3d25df 100644
--- a/netty/src/test/java/io/grpc/netty/NettyStreamTestBase.java
+++ b/netty/src/test/java/io/grpc/netty/NettyStreamTestBase.java
@@ -1,53 +1,39 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
 import static io.grpc.netty.NettyTestUtil.messageFrame;
+import static java.nio.charset.StandardCharsets.US_ASCII;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyLong;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import io.grpc.internal.Stream;
 import io.grpc.internal.StreamListener;
+import io.grpc.netty.WriteQueue.QueuedCommand;
 import io.netty.buffer.UnpooledByteBufAllocator;
 import io.netty.channel.Channel;
-import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.ChannelPromise;
@@ -57,13 +43,14 @@
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.util.concurrent.TimeUnit;
+import java.util.Queue;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
-import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
 import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.mockito.stubbing.Answer;
 
 /**
@@ -73,6 +60,9 @@ public abstract class NettyStreamTestBase<T extends Stream> {
   protected static final String MESSAGE = "hello world";
   protected static final int STREAM_ID = 1;
 
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
   @Mock
   protected Channel channel;
 
@@ -82,12 +72,11 @@ public abstract class NettyStreamTestBase<T extends Stream> {
   @Mock
   private ChannelPipeline pipeline;
 
-  @Mock
-  protected ChannelFuture future;
-
   @Mock
   protected EventLoop eventLoop;
 
+  // ChannelPromise has too many methods to implement; we stubbed all necessary methods of Future.
+  @SuppressWarnings("DoNotMock")
   @Mock
   protected ChannelPromise promise;
 
@@ -102,16 +91,16 @@ public abstract class NettyStreamTestBase<T extends Stream> {
   /** Set up for test. */
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
-
-    mockFuture(true);
-    when(channel.write(any())).thenReturn(future);
-    when(channel.writeAndFlush(any())).thenReturn(future);
     when(channel.alloc()).thenReturn(UnpooledByteBufAllocator.DEFAULT);
     when(channel.pipeline()).thenReturn(pipeline);
     when(channel.eventLoop()).thenReturn(eventLoop);
     when(channel.newPromise()).thenReturn(new DefaultChannelPromise(channel));
     when(channel.voidPromise()).thenReturn(new DefaultChannelPromise(channel));
+    ChannelPromise completedPromise = new DefaultChannelPromise(channel)
+        .setSuccess();
+    when(channel.write(any())).thenReturn(completedPromise);
+    when(channel.writeAndFlush(any())).thenReturn(completedPromise);
+    when(writeQueue.enqueue(any(QueuedCommand.class), anyBoolean())).thenReturn(completedPromise);
     when(pipeline.firstContext()).thenReturn(ctx);
     when(eventLoop.inEventLoop()).thenReturn(true);
     when(http2Stream.id()).thenReturn(STREAM_ID);
@@ -139,11 +128,12 @@ public void inboundMessageShouldCallListener() throws Exception {
       ((NettyClientStream) stream).transportState()
           .transportDataReceived(messageFrame(MESSAGE), false);
     }
-    ArgumentCaptor<InputStream> captor = ArgumentCaptor.forClass(InputStream.class);
-    verify(listener()).messageRead(captor.capture());
+
+    InputStream message = listenerMessageQueue().poll();
 
     // Verify that inbound flow control window update has been disabled for the stream.
-    assertEquals(MESSAGE, NettyTestUtil.toString(captor.getValue()));
+    assertEquals(MESSAGE, NettyTestUtil.toString(message));
+    assertNull("no additional message expected", listenerMessageQueue().poll());
   }
 
   @Test
@@ -151,19 +141,13 @@ public void shouldBeImmediatelyReadyForData() {
     assertTrue(stream.isReady());
   }
 
-  @Test
-  public void closedShouldNotBeReady() throws IOException {
-    assertTrue(stream.isReady());
-    closeStream();
-    assertFalse(stream.isReady());
-  }
-
   @Test
   public void notifiedOnReadyAfterWriteCompletes() throws IOException {
     sendHeadersIfServer();
     assertTrue(stream.isReady());
     byte[] msg = largeMessage();
-    // The future is set up to automatically complete, indicating that the write is done.
+    // The channel.write future is set up to automatically complete, indicating that the write is
+    // done.
     stream.writeMessage(new ByteArrayInputStream(msg));
     stream.flush();
     assertTrue(stream.isReady());
@@ -174,7 +158,8 @@ public void notifiedOnReadyAfterWriteCompletes() throws IOException {
   public void shouldBeReadyForDataAfterWritingSmallMessage() throws IOException {
     sendHeadersIfServer();
     // Make sure the writes don't complete so we "back up"
-    reset(future);
+    ChannelPromise uncompletedPromise = new DefaultChannelPromise(channel);
+    when(writeQueue.enqueue(any(QueuedCommand.class), anyBoolean())).thenReturn(uncompletedPromise);
 
     assertTrue(stream.isReady());
     byte[] msg = smallMessage();
@@ -188,7 +173,8 @@ public void shouldBeReadyForDataAfterWritingSmallMessage() throws IOException {
   public void shouldNotBeReadyForDataAfterWritingLargeMessage() throws IOException {
     sendHeadersIfServer();
     // Make sure the writes don't complete so we "back up"
-    reset(future);
+    ChannelPromise uncompletedPromise = new DefaultChannelPromise(channel);
+    when(writeQueue.enqueue(any(QueuedCommand.class), anyBoolean())).thenReturn(uncompletedPromise);
 
     assertTrue(stream.isReady());
     byte[] msg = largeMessage();
@@ -199,7 +185,7 @@ public void shouldNotBeReadyForDataAfterWritingLargeMessage() throws IOException
   }
 
   protected byte[] smallMessage() {
-    return MESSAGE.getBytes();
+    return MESSAGE.getBytes(US_ASCII);
   }
 
   protected byte[] largeMessage() {
@@ -218,15 +204,7 @@ protected byte[] largeMessage() {
 
   protected abstract StreamListener listener();
 
-  protected abstract void closeStream();
+  protected abstract Queue<InputStream> listenerMessageQueue();
 
-  private void mockFuture(boolean succeeded) {
-    when(future.isDone()).thenReturn(true);
-    when(future.isCancelled()).thenReturn(false);
-    when(future.isSuccess()).thenReturn(succeeded);
-    when(future.awaitUninterruptibly(anyLong(), any(TimeUnit.class))).thenReturn(true);
-    if (!succeeded) {
-      when(future.cause()).thenReturn(new Exception("fake"));
-    }
-  }
+  protected abstract void closeStream();
 }
diff --git a/netty/src/test/java/io/grpc/netty/NettyTestUtil.java b/netty/src/test/java/io/grpc/netty/NettyTestUtil.java
index b8ee3bb6b44..802a6efcd58 100644
--- a/netty/src/test/java/io/grpc/netty/NettyTestUtil.java
+++ b/netty/src/test/java/io/grpc/netty/NettyTestUtil.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -34,11 +19,13 @@
 import static io.netty.util.CharsetUtil.UTF_8;
 
 import com.google.common.io.ByteStreams;
+import io.grpc.internal.ObjectPool;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import java.io.ByteArrayOutputStream;
 import java.io.DataOutputStream;
 import java.io.InputStream;
+import java.util.concurrent.Executor;
 
 /**
  * Utility methods for supporting Netty tests.
@@ -68,4 +55,32 @@ static ByteBuf compressionFrame(byte[] data) {
     buf.writeBytes(data);
     return buf;
   }
+
+  // A simple implementation of ObjectPool<Executor> that could track if the resource is returned.
+  public static class TrackingObjectPoolForTest implements ObjectPool<Executor> {
+    private boolean inUse;
+
+    public TrackingObjectPoolForTest() { }
+
+    @Override
+    public Executor getObject() {
+      inUse = true;
+      return new Executor() {
+        @Override
+        public void execute(Runnable var1) {
+          var1.run();
+        }
+      };
+    }
+
+    @Override
+    public Executor returnObject(Object object) {
+      inUse = false;
+      return null;
+    }
+
+    public boolean isInUse() {
+      return this.inUse;
+    }
+  }
 }
diff --git a/netty/src/test/java/io/grpc/netty/NettyTransportTest.java b/netty/src/test/java/io/grpc/netty/NettyTransportTest.java
index 7fb1c43c245..b779dfbe980 100644
--- a/netty/src/test/java/io/grpc/netty/NettyTransportTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyTransportTest.java
@@ -1,43 +1,40 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.Attributes;
+import io.grpc.ChannelLogger;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.internal.AbstractTransportTest;
 import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.DisconnectError;
+import io.grpc.internal.FakeClock;
 import io.grpc.internal.InternalServer;
 import io.grpc.internal.ManagedClientTransport;
-import io.grpc.internal.testing.AbstractTransportTest;
 import java.net.InetSocketAddress;
+import java.nio.channels.UnresolvedAddressException;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
 import org.junit.After;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -45,54 +42,126 @@
 /** Unit tests for Netty transport. */
 @RunWith(JUnit4.class)
 public class NettyTransportTest extends AbstractTransportTest {
+  private final FakeClock fakeClock = new FakeClock();
   // Avoid LocalChannel for testing because LocalChannel can fail with
   // io.netty.channel.ChannelException instead of java.net.ConnectException which breaks
   // serverNotListening test.
-  private ClientTransportFactory clientFactory = NettyChannelBuilder
+  private final ClientTransportFactory clientFactory = NettyChannelBuilder
       // Although specified here, address is ignored because we never call build.
       .forAddress("localhost", 0)
-      .flowControlWindow(65 * 1024)
+      .flowControlWindow(AbstractTransportTest.TEST_FLOW_CONTROL_WINDOW)
       .negotiationType(NegotiationType.PLAINTEXT)
+      .setTransportTracerFactory(fakeClockTransportTracer)
       .buildTransportFactory();
 
+  @Override
+  protected boolean haveTransportTracer() {
+    return true;
+  }
+
   @After
   public void releaseClientFactory() {
     clientFactory.close();
   }
 
   @Override
-  protected InternalServer newServer() {
+  protected InternalServer newServer(
+      List<ServerStreamTracer.Factory> streamTracerFactories) {
     return NettyServerBuilder
-        .forPort(0)
-        .flowControlWindow(65 * 1024)
-        .buildTransportServer();
+        .forAddress(new InetSocketAddress("localhost", 0))
+        .flowControlWindow(AbstractTransportTest.TEST_FLOW_CONTROL_WINDOW)
+        .setTransportTracerFactory(fakeClockTransportTracer)
+        .buildTransportServers(streamTracerFactories);
   }
 
   @Override
-  protected InternalServer newServer(InternalServer server) {
-    int port = server.getPort();
+  protected InternalServer newServer(
+      int port, List<ServerStreamTracer.Factory> streamTracerFactories) {
     return NettyServerBuilder
-        .forPort(port)
-        .flowControlWindow(65 * 1024)
-        .buildTransportServer();
+        .forAddress(new InetSocketAddress("localhost", port))
+        .flowControlWindow(AbstractTransportTest.TEST_FLOW_CONTROL_WINDOW)
+        .setTransportTracerFactory(fakeClockTransportTracer)
+        .buildTransportServers(streamTracerFactories);
   }
 
   @Override
   protected String testAuthority(InternalServer server) {
-    return "localhost:" + server.getPort();
+    return "localhost:" + server.getListenSocketAddress();
+  }
+
+  @Override
+  protected void advanceClock(long offset, TimeUnit unit) {
+    fakeClock.forwardNanos(unit.toNanos(offset));
+  }
+
+  @Override
+  protected long fakeCurrentTimeNanos() {
+    return fakeClock.getTicker().read();
   }
 
   @Override
   protected ManagedClientTransport newClientTransport(InternalServer server) {
-    int port = server.getPort();
+
     return clientFactory.newClientTransport(
-        new InetSocketAddress("localhost", port),
-        testAuthority(server),
-        null /* agent */);
+        server.getListenSocketAddress(),
+        new ClientTransportFactory.ClientTransportOptions()
+            .setAuthority(testAuthority(server))
+            .setEagAttributes(eagAttrs()),
+        transportLogger());
   }
 
-  @Test
-  @Ignore("flaky")
+  @org.junit.Ignore
+  @org.junit.Test
   @Override
-  public void flowControlPushBack() {}
+  public void clientChecksInboundMetadataSize_trailer() throws Exception {
+    // Server-side is flaky due to https://github.com/netty/netty/pull/8332
+  }
+
+  @Test
+  public void channelHasUnresolvedHostname() throws Exception {
+    server = null;
+    final SettableFuture<Status> future = SettableFuture.create();
+    ChannelLogger logger = transportLogger();
+    ManagedClientTransport transport = clientFactory.newClientTransport(
+        InetSocketAddress.createUnresolved("invalid", 1234),
+        new ClientTransportFactory.ClientTransportOptions()
+            .setChannelLogger(logger), logger);
+    Runnable runnable = transport.start(new ManagedClientTransport.Listener() {
+      @Override
+      public void transportShutdown(Status s, DisconnectError e) {
+        future.set(s);
+      }
+
+      @Override
+      public void transportTerminated() {}
+
+      @Override
+      public void transportReady() {
+        Throwable t = new Throwable("transport should have failed and shutdown but didnt");
+        future.setException(t);
+      }
+
+      @Override
+      public void transportInUse(boolean inUse) {
+        Throwable t = new Throwable("transport should have failed and shutdown but didnt");
+        future.setException(t);
+      }
+
+      @Override
+      public Attributes filterTransport(Attributes attributes) {
+        return attributes;
+      }
+    });
+    if (runnable != null) {
+      runnable.run();
+    }
+    try {
+      Status status = future.get();
+      assertEquals(Status.Code.UNAVAILABLE, status.getCode());
+      assertThat(status.getCause()).isInstanceOf(UnresolvedAddressException.class);
+      assertEquals("unresolved address", status.getDescription());
+    } finally {
+      transport.shutdown(Status.UNAVAILABLE.withDescription("test shutdown"));
+    }
+  }
 }
diff --git a/netty/src/test/java/io/grpc/netty/NettyWritableBufferAllocatorTest.java b/netty/src/test/java/io/grpc/netty/NettyWritableBufferAllocatorTest.java
index 5b6658f050d..0b741ae24b3 100644
--- a/netty/src/test/java/io/grpc/netty/NettyWritableBufferAllocatorTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyWritableBufferAllocatorTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
@@ -55,13 +40,6 @@ protected WritableBufferAllocator allocator() {
     return allocator;
   }
 
-  @Test
-  public void testCapacityHasMinimum() {
-    WritableBuffer buffer = allocator().allocate(100);
-    assertEquals(0, buffer.readableBytes());
-    assertEquals(4096, buffer.writableBytes());
-  }
-
   @Test
   public void testCapacityIsExactAboveMinimum() {
     WritableBuffer buffer = allocator().allocate(9000);
diff --git a/netty/src/test/java/io/grpc/netty/NettyWritableBufferTest.java b/netty/src/test/java/io/grpc/netty/NettyWritableBufferTest.java
index ba69e962bfc..b5f0f76d50b 100644
--- a/netty/src/test/java/io/grpc/netty/NettyWritableBufferTest.java
+++ b/netty/src/test/java/io/grpc/netty/NettyWritableBufferTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
diff --git a/netty/src/test/java/io/grpc/netty/ProtocolNegotiatorsTest.java b/netty/src/test/java/io/grpc/netty/ProtocolNegotiatorsTest.java
index 6d41f38108c..80438532172 100644
--- a/netty/src/test/java/io/grpc/netty/ProtocolNegotiatorsTest.java
+++ b/netty/src/test/java/io/grpc/netty/ProtocolNegotiatorsTest.java
@@ -1,85 +1,160 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
-import static com.google.common.base.Charsets.UTF_8;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 
+import com.google.common.base.Optional;
+import io.grpc.Attributes;
+import io.grpc.CallCredentials;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.ChoiceChannelCredentials;
+import io.grpc.ChoiceServerCredentials;
+import io.grpc.CompositeChannelCredentials;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.Security;
+import io.grpc.Metadata;
+import io.grpc.SecurityLevel;
+import io.grpc.ServerCredentials;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.StatusRuntimeException;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.TlsServerCredentials;
+import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.DisconnectError;
+import io.grpc.internal.GrpcAttributes;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ManagedClientTransport;
+import io.grpc.internal.ServerListener;
+import io.grpc.internal.ServerStream;
+import io.grpc.internal.ServerTransport;
+import io.grpc.internal.ServerTransportListener;
+import io.grpc.internal.TestUtils.NoopChannelLogger;
+import io.grpc.internal.testing.TestUtils;
+import io.grpc.netty.ProtocolNegotiators.ClientTlsHandler;
+import io.grpc.netty.ProtocolNegotiators.ClientTlsProtocolNegotiator;
+import io.grpc.netty.ProtocolNegotiators.HostPort;
 import io.grpc.netty.ProtocolNegotiators.ServerTlsHandler;
-import io.grpc.netty.ProtocolNegotiators.TlsNegotiator;
-import io.grpc.testing.TestUtils;
+import io.grpc.netty.ProtocolNegotiators.WaitUntilActiveHandler;
+import io.grpc.testing.TlsTesting;
+import io.grpc.util.CertificateUtils;
 import io.netty.bootstrap.Bootstrap;
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufUtil;
 import io.netty.channel.Channel;
+import io.netty.channel.ChannelDuplexHandler;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerAdapter;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandler;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelOutboundHandlerAdapter;
 import io.netty.channel.ChannelPipeline;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.DefaultEventLoop;
 import io.netty.channel.DefaultEventLoopGroup;
+import io.netty.channel.EventLoopGroup;
 import io.netty.channel.embedded.EmbeddedChannel;
 import io.netty.channel.local.LocalAddress;
 import io.netty.channel.local.LocalChannel;
 import io.netty.channel.local.LocalServerChannel;
+import io.netty.handler.codec.http.HttpServerCodec;
+import io.netty.handler.codec.http.HttpServerUpgradeHandler;
+import io.netty.handler.codec.http.HttpServerUpgradeHandler.UpgradeCodec;
+import io.netty.handler.codec.http.HttpServerUpgradeHandler.UpgradeCodecFactory;
+import io.netty.handler.codec.http2.DefaultHttp2Connection;
+import io.netty.handler.codec.http2.DefaultHttp2ConnectionDecoder;
+import io.netty.handler.codec.http2.DefaultHttp2ConnectionEncoder;
+import io.netty.handler.codec.http2.DefaultHttp2FrameReader;
+import io.netty.handler.codec.http2.DefaultHttp2FrameWriter;
+import io.netty.handler.codec.http2.Http2ConnectionDecoder;
+import io.netty.handler.codec.http2.Http2ConnectionEncoder;
+import io.netty.handler.codec.http2.Http2ServerUpgradeCodec;
+import io.netty.handler.codec.http2.Http2Settings;
+import io.netty.handler.proxy.ProxyConnectException;
+import io.netty.handler.ssl.ApplicationProtocolConfig;
 import io.netty.handler.ssl.SslContext;
 import io.netty.handler.ssl.SslHandler;
 import io.netty.handler.ssl.SslHandshakeCompletionEvent;
-import io.netty.handler.ssl.SupportedCipherSuiteFilter;
 import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.logging.Filter;
 import java.util.logging.Level;
 import java.util.logging.LogRecord;
 import java.util.logging.Logger;
+import javax.net.ssl.KeyManagerFactory;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLEngine;
 import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLHandshakeException;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.TrustManagerFactory;
+import org.junit.After;
 import org.junit.Before;
+import org.junit.BeforeClass;
 import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
+import org.junit.rules.DisableOnDebug;
+import org.junit.rules.TestRule;
+import org.junit.rules.Timeout;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
 import org.mockito.Mockito;
 
 @RunWith(JUnit4.class)
@@ -88,49 +163,567 @@ public class ProtocolNegotiatorsTest {
     @Override public void run() {}
   };
 
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
+  private static File server1Cert;
+  private static File server1Key;
+  private static File caCert;
+
+  @BeforeClass
+  public static void loadCerts() throws Exception {
+    server1Cert = TestUtils.loadCert("server1.pem");
+    server1Key = TestUtils.loadCert("server1.key");
+    caCert = TestUtils.loadCert("ca.pem");
+  }
+
+  private static final int TIMEOUT_SECONDS = 60;
+  @Rule public final TestRule globalTimeout = new DisableOnDebug(Timeout.seconds(TIMEOUT_SECONDS));
 
-  private GrpcHttp2ConnectionHandler grpcHandler = mock(GrpcHttp2ConnectionHandler.class);
+  private final EventLoopGroup group = new DefaultEventLoop();
+  private Channel chan;
+  private Channel server;
+
+  private final GrpcHttp2ConnectionHandler grpcHandler =
+      FakeGrpcHttp2ConnectionHandler.newHandler();
 
   private EmbeddedChannel channel = new EmbeddedChannel();
   private ChannelPipeline pipeline = channel.pipeline();
   private SslContext sslContext;
   private SSLEngine engine;
   private ChannelHandlerContext channelHandlerCtx;
+  private static ChannelLogger noopLogger = new NoopChannelLogger();
 
   @Before
   public void setUp() throws Exception {
-    File serverCert = TestUtils.loadCert("server1.pem");
-    File key = TestUtils.loadCert("server1.key");
-    sslContext = GrpcSslContexts.forServer(serverCert, key)
-        .ciphers(TestUtils.preferredTestCiphers(), SupportedCipherSuiteFilter.INSTANCE).build();
+    InputStream serverCert = TlsTesting.loadCert("server1.pem");
+    InputStream key = TlsTesting.loadCert("server1.key");
+    sslContext = GrpcSslContexts.forServer(serverCert, key).build();
     engine = SSLContext.getDefault().createSSLEngine();
+    engine.setUseClientMode(true);
+  }
+
+  @After
+  public void tearDown() {
+    if (server != null) {
+      server.close();
+    }
+    if (chan != null) {
+      chan.close();
+    }
+    group.shutdownGracefully();
+  }
+
+  @Test
+  public void fromClient_unknown() {
+    ProtocolNegotiators.FromChannelCredentialsResult result =
+        ProtocolNegotiators.from(new ChannelCredentials() {
+          @Override
+          public ChannelCredentials withoutBearerTokens() {
+            throw new UnsupportedOperationException();
+          }
+        });
+    assertThat(result.error).isNotNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.negotiator).isNull();
+  }
+
+  @Test
+  public void fromClient_tls_trustManager()
+      throws KeyStoreException, CertificateException, IOException, NoSuchAlgorithmException {
+    KeyStore certStore = KeyStore.getInstance(KeyStore.getDefaultType());
+    certStore.load(null);
+    TrustManagerFactory trustManagerFactory =
+        TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+    try (InputStream ca = TlsTesting.loadCert("ca.pem")) {
+      for (X509Certificate cert : CertificateUtils.getX509Certificates(ca)) {
+        certStore.setCertificateEntry(cert.getSubjectX500Principal().getName("RFC2253"), cert);
+      }
+    }
+    trustManagerFactory.init(certStore);
+    ProtocolNegotiators.FromChannelCredentialsResult result =
+        ProtocolNegotiators.from(TlsChannelCredentials.newBuilder()
+            .trustManager(trustManagerFactory.getTrustManagers()).build());
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.negotiator)
+        .isInstanceOf(ProtocolNegotiators.TlsProtocolNegotiatorClientFactory.class);
+    assertThat(((ClientTlsProtocolNegotiator) result.negotiator.newNegotiator())
+        .hasX509ExtendedTrustManager()).isTrue();
+  }
+
+  @Test
+  public void fromClient_tls_CaCertsInputStream() throws IOException {
+    ProtocolNegotiators.FromChannelCredentialsResult result =
+        ProtocolNegotiators.from(TlsChannelCredentials.newBuilder()
+            .trustManager(TlsTesting.loadCert("ca.pem")).build());
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.negotiator)
+        .isInstanceOf(ProtocolNegotiators.TlsProtocolNegotiatorClientFactory.class);
+    assertThat(((ClientTlsProtocolNegotiator) result.negotiator.newNegotiator())
+        .hasX509ExtendedTrustManager()).isTrue();
+  }
+
+  @Test
+  public void fromClient_tls_systemDefault() {
+    ProtocolNegotiators.FromChannelCredentialsResult result =
+        ProtocolNegotiators.from(TlsChannelCredentials.create());
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.negotiator)
+        .isInstanceOf(ProtocolNegotiators.TlsProtocolNegotiatorClientFactory.class);
+    assertThat(((ClientTlsProtocolNegotiator) result.negotiator.newNegotiator())
+        .hasX509ExtendedTrustManager()).isTrue();
+  }
+
+  @Test
+  public void fromClient_unsupportedTls() {
+    ProtocolNegotiators.FromChannelCredentialsResult result =
+        ProtocolNegotiators.from(TlsChannelCredentials.newBuilder().requireFakeFeature().build());
+    assertThat(result.error).contains("FAKE");
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.negotiator).isNull();
+  }
+
+  @Test
+  public void fromClient_insecure() {
+    ProtocolNegotiators.FromChannelCredentialsResult result =
+        ProtocolNegotiators.from(InsecureChannelCredentials.create());
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.negotiator)
+        .isInstanceOf(ProtocolNegotiators.PlaintextProtocolNegotiatorClientFactory.class);
+  }
+
+  @Test
+  public void fromClient_composite() {
+    CallCredentials callCredentials = mock(CallCredentials.class);
+    ProtocolNegotiators.FromChannelCredentialsResult result =
+        ProtocolNegotiators.from(CompositeChannelCredentials.create(
+          TlsChannelCredentials.create(), callCredentials));
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isSameInstanceAs(callCredentials);
+    assertThat(result.negotiator)
+        .isInstanceOf(ProtocolNegotiators.TlsProtocolNegotiatorClientFactory.class);
+
+    result = ProtocolNegotiators.from(CompositeChannelCredentials.create(
+          InsecureChannelCredentials.create(), callCredentials));
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isSameInstanceAs(callCredentials);
+    assertThat(result.negotiator)
+        .isInstanceOf(ProtocolNegotiators.PlaintextProtocolNegotiatorClientFactory.class);
+  }
+
+  @Test
+  public void fromClient_netty() {
+    ProtocolNegotiator.ClientFactory factory = mock(ProtocolNegotiator.ClientFactory.class);
+    ProtocolNegotiators.FromChannelCredentialsResult result =
+        ProtocolNegotiators.from(NettyChannelCredentials.create(factory));
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.negotiator).isSameInstanceAs(factory);
+  }
+
+  @Test
+  public void fromClient_choice() {
+    ProtocolNegotiators.FromChannelCredentialsResult result =
+        ProtocolNegotiators.from(ChoiceChannelCredentials.create(
+          new ChannelCredentials() {
+            @Override
+            public ChannelCredentials withoutBearerTokens() {
+              throw new UnsupportedOperationException();
+            }
+          },
+          TlsChannelCredentials.create(),
+          InsecureChannelCredentials.create()));
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.negotiator)
+        .isInstanceOf(ProtocolNegotiators.TlsProtocolNegotiatorClientFactory.class);
+
+    result = ProtocolNegotiators.from(ChoiceChannelCredentials.create(
+          InsecureChannelCredentials.create(),
+          new ChannelCredentials() {
+            @Override
+            public ChannelCredentials withoutBearerTokens() {
+              throw new UnsupportedOperationException();
+            }
+          },
+          TlsChannelCredentials.create()));
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.negotiator)
+        .isInstanceOf(ProtocolNegotiators.PlaintextProtocolNegotiatorClientFactory.class);
+  }
+
+  @Test
+  public void fromClient_choice_unknown() {
+    ProtocolNegotiators.FromChannelCredentialsResult result =
+        ProtocolNegotiators.from(ChoiceChannelCredentials.create(
+          new ChannelCredentials() {
+            @Override
+            public ChannelCredentials withoutBearerTokens() {
+              throw new UnsupportedOperationException();
+            }
+          }));
+    assertThat(result.error).isNotNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.negotiator).isNull();
+  }
+
+  private InternalChannelz.Tls expectSuccessfulHandshake(
+      ChannelCredentials channelCreds, ServerCredentials serverCreds) throws Exception {
+    return (InternalChannelz.Tls) expectHandshake(channelCreds, serverCreds, true);
+  }
+
+  private Status expectFailedHandshake(
+      ChannelCredentials channelCreds, ServerCredentials serverCreds) throws Exception {
+    return (Status) expectHandshake(channelCreds, serverCreds, false);
+  }
+
+  private Object expectHandshake(
+      ChannelCredentials channelCreds, ServerCredentials serverCreds, boolean expectSuccess)
+      throws Exception {
+    MockServerListener serverListener = new MockServerListener();
+    ClientTransportFactory clientFactory = NettyChannelBuilder
+        // Although specified here, address is ignored because we never call build.
+        .forAddress("localhost", 0, channelCreds)
+        .buildTransportFactory();
+    InternalServer server = NettyServerBuilder
+        .forPort(0, serverCreds)
+        .buildTransportServers(Collections.<ServerStreamTracer.Factory>emptyList());
+    server.start(serverListener);
+
+    ManagedClientTransport.Listener clientTransportListener =
+        mock(ManagedClientTransport.Listener.class);
+    ManagedClientTransport client = clientFactory.newClientTransport(
+        server.getListenSocketAddress(),
+        new ClientTransportFactory.ClientTransportOptions()
+          .setAuthority(TestUtils.TEST_SERVER_HOST),
+        mock(ChannelLogger.class));
+    callMeMaybe(client.start(clientTransportListener));
+    Object result;
+    if (expectSuccess) {
+      verify(clientTransportListener, timeout(TIMEOUT_SECONDS * 1000)).transportReady();
+      InternalChannelz.SocketStats stats = serverListener.transports.poll().getStats().get();
+      assertThat(stats.security).isNotNull();
+      assertThat(stats.security.tls).isNotNull();
+      result = stats.security.tls;
+    } else {
+      ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
+      verify(clientTransportListener, timeout(TIMEOUT_SECONDS * 1000))
+          .transportShutdown(captor.capture(), any(DisconnectError.class));
+      result = captor.getValue();
+    }
+
+    client.shutdownNow(Status.UNAVAILABLE.withDescription("trash it"));
+    server.shutdown();
+    assertTrue(
+        serverListener.waitForShutdown(TIMEOUT_SECONDS * 1000, TimeUnit.MILLISECONDS));
+    verify(clientTransportListener, timeout(TIMEOUT_SECONDS * 1000)).transportTerminated();
+    clientFactory.close();
+    return result;
+  }
+
+  @Test
+  public void from_tls_clientAuthNone_noClientCert() throws Exception {
+    // Use convenience API to better match most user's usage
+    ServerCredentials serverCreds = TlsServerCredentials.create(server1Cert, server1Key);
+    ChannelCredentials channelCreds = TlsChannelCredentials.newBuilder()
+        .trustManager(caCert)
+        .build();
+    InternalChannelz.Tls tls = expectSuccessfulHandshake(channelCreds, serverCreds);
+    assertThat(tls.remoteCert).isNull();
+  }
+
+  @Test
+  public void from_tls_clientAuthNone_clientCert() throws Exception {
+    ServerCredentials serverCreds = TlsServerCredentials.newBuilder()
+        .keyManager(server1Cert, server1Key)
+        .trustManager(caCert)
+        .build();
+    ChannelCredentials channelCreds = TlsChannelCredentials.newBuilder()
+        .keyManager(server1Cert, server1Key)
+        .trustManager(caCert)
+        .build();
+    InternalChannelz.Tls tls = expectSuccessfulHandshake(channelCreds, serverCreds);
+    assertThat(tls.remoteCert).isNull();
+  }
+
+  @Test
+  public void from_tls_clientAuthRequire_noClientCert() throws Exception {
+    ServerCredentials serverCreds = TlsServerCredentials.newBuilder()
+        .keyManager(server1Cert, server1Key)
+        .trustManager(caCert)
+        .clientAuth(TlsServerCredentials.ClientAuth.REQUIRE)
+        .build();
+    ChannelCredentials channelCreds = TlsChannelCredentials.newBuilder()
+        .trustManager(caCert)
+        .build();
+    Status status = expectFailedHandshake(channelCreds, serverCreds);
+    assertEquals(Status.Code.UNAVAILABLE, status.getCode());
+    StatusException sre = status.asException();
+    // because of netty/netty#11604 we need to check for both TLSv1.2 and v1.3 behaviors
+    if (sre.getCause() instanceof SSLHandshakeException) {
+      assertThat(sre).hasCauseThat().isInstanceOf(SSLHandshakeException.class);
+      assertThat(sre).hasCauseThat().hasMessageThat().contains("SSLV3_ALERT_HANDSHAKE_FAILURE");
+    } else {
+      // Client cert verification is after handshake in TLSv1.3
+      assertThat(sre).hasCauseThat().hasCauseThat().isInstanceOf(SSLException.class);
+      assertThat(sre).hasCauseThat().hasMessageThat().contains("CERTIFICATE_REQUIRED");
+    }
+  }
+
+  @Test
+  public void from_tls_clientAuthRequire_clientCert() throws Exception {
+    ServerCredentials serverCreds = TlsServerCredentials.newBuilder()
+        .keyManager(server1Cert, server1Key)
+        .trustManager(caCert)
+        .clientAuth(TlsServerCredentials.ClientAuth.REQUIRE)
+        .build();
+    ChannelCredentials channelCreds = TlsChannelCredentials.newBuilder()
+        .keyManager(server1Cert, server1Key)
+        .trustManager(caCert)
+        .build();
+    InternalChannelz.Tls tls = expectSuccessfulHandshake(channelCreds, serverCreds);
+    assertThat(((X509Certificate) tls.remoteCert).getSubjectX500Principal().getName())
+        .contains("CN=*.test.google.com");
+  }
+
+  @Test
+  public void from_tls_clientAuthOptional_noClientCert() throws Exception {
+    ServerCredentials serverCreds = TlsServerCredentials.newBuilder()
+        .keyManager(server1Cert, server1Key)
+        .trustManager(caCert)
+        .clientAuth(TlsServerCredentials.ClientAuth.OPTIONAL)
+        .build();
+    ChannelCredentials channelCreds = TlsChannelCredentials.newBuilder()
+        .trustManager(caCert)
+        .build();
+    InternalChannelz.Tls tls = expectSuccessfulHandshake(channelCreds, serverCreds);
+    assertThat(tls.remoteCert).isNull();
+  }
+
+  @Test
+  public void from_tls_clientAuthOptional_clientCert() throws Exception {
+    ServerCredentials serverCreds = TlsServerCredentials.newBuilder()
+        .keyManager(server1Cert, server1Key)
+        .trustManager(caCert)
+        .clientAuth(TlsServerCredentials.ClientAuth.OPTIONAL)
+        .build();
+    ChannelCredentials channelCreds = TlsChannelCredentials.newBuilder()
+        .keyManager(server1Cert, server1Key)
+        .trustManager(caCert)
+        .build();
+    InternalChannelz.Tls tls = expectSuccessfulHandshake(channelCreds, serverCreds);
+    assertThat(((X509Certificate) tls.remoteCert).getSubjectX500Principal().getName())
+        .contains("CN=*.test.google.com");
+  }
+
+  @Test
+  public void from_tls_managers() throws Exception {
+    KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
+    keyStore.load(null);
+    try (InputStream server1Chain = TlsTesting.loadCert("server1.pem");
+         InputStream server1Key = TlsTesting.loadCert("server1.key")) {
+      X509Certificate[] chain = CertificateUtils.getX509Certificates(server1Chain);
+      keyStore.setKeyEntry("key", CertificateUtils.getPrivateKey(server1Key), new char[0], chain);
+    }
+    KeyManagerFactory keyManagerFactory =
+        KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+    keyManagerFactory.init(keyStore, new char[0]);
+
+    KeyStore certStore = KeyStore.getInstance(KeyStore.getDefaultType());
+    certStore.load(null);
+    TrustManagerFactory trustManagerFactory =
+        TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+    try (InputStream ca = TlsTesting.loadCert("ca.pem")) {
+      for (X509Certificate cert : CertificateUtils.getX509Certificates(ca)) {
+        certStore.setCertificateEntry(cert.getSubjectX500Principal().getName("RFC2253"), cert);
+      }
+    }
+    trustManagerFactory.init(certStore);
+
+    ServerCredentials serverCreds = TlsServerCredentials.newBuilder()
+        .keyManager(keyManagerFactory.getKeyManagers())
+        .trustManager(trustManagerFactory.getTrustManagers())
+        .clientAuth(TlsServerCredentials.ClientAuth.REQUIRE)
+        .build();
+    ChannelCredentials channelCreds = TlsChannelCredentials.newBuilder()
+        .keyManager(keyManagerFactory.getKeyManagers())
+        .trustManager(trustManagerFactory.getTrustManagers())
+        .build();
+    InternalChannelz.Tls tls = expectSuccessfulHandshake(channelCreds, serverCreds);
+    assertThat(((X509Certificate) tls.remoteCert).getSubjectX500Principal().getName())
+        .isEqualTo("CN=*.test.google.com,O=Example\\, Co.,L=Chicago,ST=Illinois,C=US");
+  }
+
+  @Test
+  public void fromServer_unknown() {
+    ProtocolNegotiators.FromServerCredentialsResult result =
+        ProtocolNegotiators.from(new ServerCredentials() {});
+    assertThat(result.error).isNotNull();
+    assertThat(result.negotiator).isNull();
+  }
+
+  @Test
+  public void fromServer_tls() throws Exception {
+    ProtocolNegotiators.FromServerCredentialsResult result =
+        ProtocolNegotiators.from(TlsServerCredentials.create(server1Cert, server1Key));
+    assertThat(result.error).isNull();
+    assertThat(result.negotiator)
+        .isInstanceOf(ProtocolNegotiators.TlsProtocolNegotiatorServerFactory.class);
+  }
+
+  @Test
+  public void fromServer_unsupportedTls() throws Exception {
+    ProtocolNegotiators.FromServerCredentialsResult result = ProtocolNegotiators.from(
+        TlsServerCredentials.newBuilder()
+          .keyManager(server1Cert, server1Key)
+          .requireFakeFeature()
+          .build());
+    assertThat(result.error).contains("FAKE");
+    assertThat(result.negotiator).isNull();
+  }
+
+  @Test
+  public void fromServer_insecure() {
+    ProtocolNegotiators.FromServerCredentialsResult result =
+        ProtocolNegotiators.from(InsecureServerCredentials.create());
+    assertThat(result.error).isNull();
+    assertThat(result.negotiator)
+        .isInstanceOf(ProtocolNegotiators.PlaintextProtocolNegotiatorServerFactory.class);
+  }
+
+  @Test
+  public void fromServer_netty() {
+    ProtocolNegotiator.ServerFactory factory = mock(ProtocolNegotiator.ServerFactory.class);
+    ProtocolNegotiators.FromServerCredentialsResult result =
+        ProtocolNegotiators.from(NettyServerCredentials.create(factory));
+    assertThat(result.error).isNull();
+    assertThat(result.negotiator).isSameInstanceAs(factory);
+  }
+
+  @Test
+  public void fromServer_choice() throws Exception {
+    ProtocolNegotiators.FromServerCredentialsResult result =
+        ProtocolNegotiators.from(ChoiceServerCredentials.create(
+          new ServerCredentials() {},
+          TlsServerCredentials.create(server1Cert, server1Key),
+          InsecureServerCredentials.create()));
+    assertThat(result.error).isNull();
+    assertThat(result.negotiator)
+        .isInstanceOf(ProtocolNegotiators.TlsProtocolNegotiatorServerFactory.class);
+
+    result = ProtocolNegotiators.from(ChoiceServerCredentials.create(
+          InsecureServerCredentials.create(),
+          new ServerCredentials() {},
+          TlsServerCredentials.create(server1Cert, server1Key)));
+    assertThat(result.error).isNull();
+    assertThat(result.negotiator)
+        .isInstanceOf(ProtocolNegotiators.PlaintextProtocolNegotiatorServerFactory.class);
   }
 
   @Test
-  public void tlsHandler_failsOnNullEngine() throws Exception {
-    thrown.expect(NullPointerException.class);
-    thrown.expectMessage("ssl");
+  public void fromServer_choice_unknown() {
+    ProtocolNegotiators.FromServerCredentialsResult result =
+        ProtocolNegotiators.from(ChoiceServerCredentials.create(
+          new ServerCredentials() {}));
+    assertThat(result.error).isNotNull();
+    assertThat(result.negotiator).isNull();
+  }
+
+
+  @Test
+  public void waitUntilActiveHandler_handlerAdded() throws Exception {
+    final CountDownLatch latch = new CountDownLatch(1);
 
-    ProtocolNegotiators.serverTls(null);
+    final WaitUntilActiveHandler handler =
+        new WaitUntilActiveHandler(new ChannelHandlerAdapter() {
+          @Override
+          public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+            assertTrue(ctx.channel().isActive());
+            latch.countDown();
+            super.handlerAdded(ctx);
+          }
+        }, noopLogger);
+
+    ChannelHandler lateAddingHandler = new ChannelInboundHandlerAdapter() {
+      @Override
+      public void channelActive(ChannelHandlerContext ctx) throws Exception {
+        ctx.pipeline().addLast(handler);
+        ctx.pipeline().fireUserEventTriggered(ProtocolNegotiationEvent.DEFAULT);
+        // do not propagate channelActive().
+      }
+    };
+
+    LocalAddress addr = new LocalAddress("local");
+    ChannelFuture cf = new Bootstrap()
+        .channel(LocalChannel.class)
+        .handler(lateAddingHandler)
+        .group(group)
+        .register();
+    chan = cf.channel();
+    ChannelFuture sf = new ServerBootstrap()
+        .channel(LocalServerChannel.class)
+        .childHandler(new ChannelHandlerAdapter() {})
+        .group(group)
+        .bind(addr);
+    server = sf.channel();
+    sf.sync();
+
+    assertEquals(1, latch.getCount());
+
+    chan.connect(addr).sync();
+    assertTrue(latch.await(TIMEOUT_SECONDS, TimeUnit.SECONDS));
+    assertNull(chan.pipeline().context(WaitUntilActiveHandler.class));
   }
 
   @Test
-  public void tlsAdapter_exceptionClosesChannel() throws Exception {
-    ChannelHandler handler = new ServerTlsHandler(sslContext, grpcHandler);
+  public void waitUntilActiveHandler_channelActive() throws Exception {
+    final CountDownLatch latch = new CountDownLatch(1);
+    WaitUntilActiveHandler handler =
+        new WaitUntilActiveHandler(new ChannelHandlerAdapter() {
+          @Override
+          public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+            assertTrue(ctx.channel().isActive());
+            latch.countDown();
+            super.handlerAdded(ctx);
+          }
+        }, noopLogger);
 
-    // Use addFirst due to the funny error handling in EmbeddedChannel.
-    pipeline.addFirst(handler);
+    LocalAddress addr = new LocalAddress("local");
+    ChannelFuture cf = new Bootstrap()
+        .channel(LocalChannel.class)
+        .handler(handler)
+        .group(group)
+        .register();
+    chan = cf.channel();
+    ChannelFuture sf = new ServerBootstrap()
+        .channel(LocalServerChannel.class)
+        .childHandler(new ChannelHandlerAdapter() {})
+        .group(group)
+        .bind(addr);
+    server = sf.channel();
+    sf.sync();
 
-    pipeline.fireExceptionCaught(new Exception("bad"));
+    assertEquals(1, latch.getCount());
 
-    assertFalse(channel.isOpen());
+    chan.connect(addr).sync();
+    chan.pipeline().fireUserEventTriggered(ProtocolNegotiationEvent.DEFAULT);
+    assertTrue(latch.await(TIMEOUT_SECONDS, TimeUnit.SECONDS));
+    assertNull(chan.pipeline().context(WaitUntilActiveHandler.class));
   }
 
+  @Test
+  public void tlsHandler_failsOnNullEngine() {
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> ProtocolNegotiators.serverTls(null));
+    assertThat(e).hasMessageThat().isEqualTo("sslContext");
+  }
+
+
   @Test
   public void tlsHandler_handlerAddedAddsSslHandler() throws Exception {
-    ChannelHandler handler = new ServerTlsHandler(sslContext, grpcHandler);
+    ChannelHandler handler = new ServerTlsHandler(grpcHandler, sslContext, null);
 
     pipeline.addLast(handler);
 
@@ -139,7 +732,7 @@ public void tlsHandler_handlerAddedAddsSslHandler() throws Exception {
 
   @Test
   public void tlsHandler_userEventTriggeredNonSslEvent() throws Exception {
-    ChannelHandler handler = new ServerTlsHandler(sslContext, grpcHandler);
+    ChannelHandler handler = new ServerTlsHandler(grpcHandler, sslContext, null);
     pipeline.addLast(handler);
     channelHandlerCtx = pipeline.context(handler);
     Object nonSslEvent = new Object();
@@ -160,32 +753,52 @@ public String applicationProtocol() {
       }
     };
 
-    ChannelHandler handler = new ServerTlsHandler(sslContext, grpcHandler);
+    ChannelHandler handler = new ServerTlsHandler(grpcHandler, sslContext, null);
     pipeline.addLast(handler);
 
+    final AtomicReference<Throwable> error = new AtomicReference<>();
+    ChannelHandler errorCapture = new ChannelInboundHandlerAdapter() {
+      @Override
+      public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+        error.set(cause);
+      }
+    };
+
+    pipeline.addLast(errorCapture);
+
     pipeline.replace(SslHandler.class, null, badSslHandler);
     channelHandlerCtx = pipeline.context(handler);
     Object sslEvent = SslHandshakeCompletionEvent.SUCCESS;
 
     pipeline.fireUserEventTriggered(sslEvent);
 
-    // No h2 protocol was specified, so this should be closed.
-    assertFalse(channel.isOpen());
+    // No h2 protocol was specified, so there should be an error, (normally handled by WBAEH)
+    assertThat(error.get()).hasMessageThat().contains("Unable to find compatible protocol");
     ChannelHandlerContext grpcHandlerCtx = pipeline.context(grpcHandler);
     assertNull(grpcHandlerCtx);
   }
 
   @Test
   public void tlsHandler_userEventTriggeredSslEvent_handshakeFailure() throws Exception {
-    ChannelHandler handler = new ServerTlsHandler(sslContext, grpcHandler);
+    ChannelHandler handler = new ServerTlsHandler(grpcHandler, sslContext, null);
     pipeline.addLast(handler);
     channelHandlerCtx = pipeline.context(handler);
     Object sslEvent = new SslHandshakeCompletionEvent(new RuntimeException("bad"));
 
+    final AtomicReference<Throwable> error = new AtomicReference<>();
+    ChannelHandler errorCapture = new ChannelInboundHandlerAdapter() {
+      @Override
+      public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+        error.set(cause);
+      }
+    };
+
+    pipeline.addLast(errorCapture);
+
     pipeline.fireUserEventTriggered(sslEvent);
 
-    // No h2 protocol was specified, so this should be closed.
-    assertFalse(channel.isOpen());
+    // No h2 protocol was specified, so there should be an error, (normally handled by WBAEH)
+    assertThat(error.get()).hasMessageThat().contains("bad");
     ChannelHandlerContext grpcHandlerCtx = pipeline.context(grpcHandler);
     assertNull(grpcHandlerCtx);
   }
@@ -199,7 +812,7 @@ public String applicationProtocol() {
       }
     };
 
-    ChannelHandler handler = new ServerTlsHandler(sslContext, grpcHandler);
+    ChannelHandler handler = new ServerTlsHandler(grpcHandler, sslContext, null);
     pipeline.addLast(handler);
 
     pipeline.replace(SslHandler.class, null, goodSslHandler);
@@ -214,15 +827,28 @@ public String applicationProtocol() {
   }
 
   @Test
-  public void tlsHandler_userEventTriggeredSslEvent_supportedProtocolGrpcExp() throws Exception {
+  public void serverTlsHandler_userEventTriggeredSslEvent_supportedProtocolCustom()
+      throws Exception {
     SslHandler goodSslHandler = new SslHandler(engine, false) {
       @Override
       public String applicationProtocol() {
-        return "grpc-exp";
+        return "managed_mtls";
       }
     };
 
-    ChannelHandler handler = new ServerTlsHandler(sslContext, grpcHandler);
+    InputStream serverCert = TlsTesting.loadCert("server1.pem");
+    InputStream key = TlsTesting.loadCert("server1.key");
+    List<String> alpnList = Arrays.asList("managed_mtls", "h2");
+    ApplicationProtocolConfig apn = new ApplicationProtocolConfig(
+        ApplicationProtocolConfig.Protocol.ALPN,
+        ApplicationProtocolConfig.SelectorFailureBehavior.NO_ADVERTISE,
+        ApplicationProtocolConfig.SelectedListenerFailureBehavior.ACCEPT,
+        alpnList);
+
+    sslContext = GrpcSslContexts.forServer(serverCert, key)
+        .applicationProtocolConfig(apn).build();
+
+    ChannelHandler handler = new ServerTlsHandler(grpcHandler, sslContext, null);
     pipeline.addLast(handler);
 
     pipeline.replace(SslHandler.class, null, goodSslHandler);
@@ -236,9 +862,178 @@ public String applicationProtocol() {
     assertNotNull(grpcHandlerCtx);
   }
 
+  @Test
+  public void serverTlsHandler_userEventTriggeredSslEvent_unsupportedProtocolCustom()
+      throws Exception {
+    SslHandler badSslHandler = new SslHandler(engine, false) {
+      @Override
+      public String applicationProtocol() {
+        return "badprotocol";
+      }
+    };
+
+    InputStream serverCert = TlsTesting.loadCert("server1.pem");
+    InputStream key = TlsTesting.loadCert("server1.key");
+    List<String> alpnList = Arrays.asList("managed_mtls", "h2");
+    ApplicationProtocolConfig apn = new ApplicationProtocolConfig(
+        ApplicationProtocolConfig.Protocol.ALPN,
+        ApplicationProtocolConfig.SelectorFailureBehavior.NO_ADVERTISE,
+        ApplicationProtocolConfig.SelectedListenerFailureBehavior.ACCEPT,
+        alpnList);
+
+    sslContext = GrpcSslContexts.forServer(serverCert, key)
+        .applicationProtocolConfig(apn).build();
+    ChannelHandler handler = new ServerTlsHandler(grpcHandler, sslContext, null);
+    pipeline.addLast(handler);
+
+    final AtomicReference<Throwable> error = new AtomicReference<>();
+    ChannelHandler errorCapture = new ChannelInboundHandlerAdapter() {
+      @Override
+      public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+        error.set(cause);
+      }
+    };
+
+    pipeline.addLast(errorCapture);
+
+    pipeline.replace(SslHandler.class, null, badSslHandler);
+    channelHandlerCtx = pipeline.context(handler);
+    Object sslEvent = SslHandshakeCompletionEvent.SUCCESS;
+
+    pipeline.fireUserEventTriggered(sslEvent);
+
+    // No h2 protocol was specified, so there should be an error, (normally handled by WBAEH)
+    assertThat(error.get()).hasMessageThat().contains("Unable to find compatible protocol");
+    ChannelHandlerContext grpcHandlerCtx = pipeline.context(grpcHandler);
+    assertNull(grpcHandlerCtx);
+  }
+
+  @Test
+  public void clientTlsHandler_userEventTriggeredSslEvent_supportedProtocolH2() throws Exception {
+    SslHandler goodSslHandler = new SslHandler(engine, false) {
+      @Override
+      public String applicationProtocol() {
+        return "h2";
+      }
+    };
+    DefaultEventLoopGroup elg = new DefaultEventLoopGroup(1);
+
+    ClientTlsHandler handler = new ClientTlsHandler(grpcHandler, sslContext,
+        "authority", elg, noopLogger, Optional.absent(),
+        getClientTlsProtocolNegotiator(), null);
+    pipeline.addLast(handler);
+    pipeline.replace(SslHandler.class, null, goodSslHandler);
+    pipeline.fireUserEventTriggered(ProtocolNegotiationEvent.DEFAULT);
+    channelHandlerCtx = pipeline.context(handler);
+    Object sslEvent = SslHandshakeCompletionEvent.SUCCESS;
+
+    pipeline.fireUserEventTriggered(sslEvent);
+
+    ChannelHandlerContext grpcHandlerCtx = pipeline.context(grpcHandler);
+    assertNotNull(grpcHandlerCtx);
+  }
+
+  @Test
+  public void clientTlsHandler_userEventTriggeredSslEvent_supportedProtocolCustom()
+      throws Exception {
+    SslHandler goodSslHandler = new SslHandler(engine, false) {
+      @Override
+      public String applicationProtocol() {
+        return "managed_mtls";
+      }
+    };
+    DefaultEventLoopGroup elg = new DefaultEventLoopGroup(1);
+
+    InputStream clientCert = TlsTesting.loadCert("client.pem");
+    InputStream key = TlsTesting.loadCert("client.key");
+    List<String> alpnList = Arrays.asList("managed_mtls", "h2");
+    ApplicationProtocolConfig apn = new ApplicationProtocolConfig(
+        ApplicationProtocolConfig.Protocol.ALPN,
+        ApplicationProtocolConfig.SelectorFailureBehavior.NO_ADVERTISE,
+        ApplicationProtocolConfig.SelectedListenerFailureBehavior.ACCEPT,
+        alpnList);
+
+    sslContext = GrpcSslContexts.forClient()
+        .keyManager(clientCert, key)
+        .applicationProtocolConfig(apn).build();
+
+    ClientTlsHandler handler = new ClientTlsHandler(grpcHandler, sslContext,
+        "authority", elg, noopLogger, Optional.absent(),
+        getClientTlsProtocolNegotiator(), null);
+    pipeline.addLast(handler);
+    pipeline.replace(SslHandler.class, null, goodSslHandler);
+    pipeline.fireUserEventTriggered(ProtocolNegotiationEvent.DEFAULT);
+    channelHandlerCtx = pipeline.context(handler);
+    Object sslEvent = SslHandshakeCompletionEvent.SUCCESS;
+
+    pipeline.fireUserEventTriggered(sslEvent);
+
+    ChannelHandlerContext grpcHandlerCtx = pipeline.context(grpcHandler);
+    assertNotNull(grpcHandlerCtx);
+  }
+
+  @Test
+  public void clientTlsHandler_userEventTriggeredSslEvent_unsupportedProtocol() throws Exception {
+    SslHandler goodSslHandler = new SslHandler(engine, false) {
+      @Override
+      public String applicationProtocol() {
+        return "badproto";
+      }
+    };
+    DefaultEventLoopGroup elg = new DefaultEventLoopGroup(1);
+
+    ClientTlsHandler handler = new ClientTlsHandler(grpcHandler, sslContext,
+        "authority", elg, noopLogger, Optional.absent(),
+        getClientTlsProtocolNegotiator(), null);
+    pipeline.addLast(handler);
+
+    final AtomicReference<Throwable> error = new AtomicReference<>();
+    ChannelHandler errorCapture = new ChannelInboundHandlerAdapter() {
+      @Override
+      public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+        error.set(cause);
+      }
+    };
+
+    pipeline.addLast(errorCapture);
+    pipeline.replace(SslHandler.class, null, goodSslHandler);
+    pipeline.fireUserEventTriggered(ProtocolNegotiationEvent.DEFAULT);
+    channelHandlerCtx = pipeline.context(handler);
+    Object sslEvent = SslHandshakeCompletionEvent.SUCCESS;
+
+    pipeline.fireUserEventTriggered(sslEvent);
+
+    // Bad protocol was specified, so there should be an error, (normally handled by WBAEH)
+    assertThat(error.get()).hasMessageThat().contains("Unable to find compatible protocol");
+    ChannelHandlerContext grpcHandlerCtx = pipeline.context(grpcHandler);
+    assertNull(grpcHandlerCtx);
+  }
+
+  @Test
+  public void clientTlsHandler_closeDuringNegotiation() throws Exception {
+    ClientTlsHandler handler = new ClientTlsHandler(grpcHandler, sslContext,
+        "authority", null, noopLogger, Optional.absent(),
+        getClientTlsProtocolNegotiator(), null);
+    pipeline.addLast(new WriteBufferingAndExceptionHandler(handler));
+    ChannelFuture pendingWrite = channel.writeAndFlush(NettyClientHandler.NOOP_MESSAGE);
+
+    // SslHandler fires userEventTriggered() before channelInactive()
+    pipeline.fireChannelInactive();
+
+    assertThat(pendingWrite.cause()).isInstanceOf(StatusRuntimeException.class);
+    assertThat(Status.fromThrowable(pendingWrite.cause()).getCode())
+        .isEqualTo(Status.Code.UNAVAILABLE);
+  }
+
+  private ClientTlsProtocolNegotiator getClientTlsProtocolNegotiator() throws SSLException {
+    return new ClientTlsProtocolNegotiator(GrpcSslContexts.forClient().trustManager(
+        TlsTesting.loadCert("ca.pem")).build(),
+        null, Optional.absent(), null, "");
+  }
+
   @Test
   public void engineLog() {
-    ChannelHandler handler = new ServerTlsHandler(sslContext, grpcHandler);
+    ChannelHandler handler = new ServerTlsHandler(grpcHandler, sslContext, null);
     pipeline.addLast(handler);
     channelHandlerCtx = pipeline.context(handler);
 
@@ -262,61 +1057,58 @@ public boolean isLoggable(LogRecord record) {
 
   @Test
   public void tls_failsOnNullSslContext() {
-    thrown.expect(NullPointerException.class);
-
-    ProtocolNegotiators.tls(null, "authority");
+    assertThrows(NullPointerException.class,
+        () -> ProtocolNegotiators.tls(null, null));
   }
 
   @Test
-  public void tls_hostAndPort() throws SSLException {
-    SslContext ctx = GrpcSslContexts.forClient().build();
-    TlsNegotiator negotiator = (TlsNegotiator) ProtocolNegotiators.tls(ctx, "authority:1234");
+  public void tls_hostAndPort() {
+    HostPort hostPort = ProtocolNegotiators.parseAuthority("authority:1234");
 
-    assertEquals("authority", negotiator.getHost());
-    assertEquals(1234, negotiator.getPort());
+    assertEquals("authority", hostPort.host);
+    assertEquals(1234, hostPort.port);
   }
 
   @Test
-  public void tls_host() throws SSLException {
-    SslContext ctx = GrpcSslContexts.forClient().build();
-    TlsNegotiator negotiator = (TlsNegotiator) ProtocolNegotiators.tls(ctx, "[::1]");
+  public void tls_host() {
+    HostPort hostPort = ProtocolNegotiators.parseAuthority("[::1]");
 
-    assertEquals("[::1]", negotiator.getHost());
-    assertEquals(-1, negotiator.getPort());
+    assertEquals("[::1]", hostPort.host);
+    assertEquals(-1, hostPort.port);
   }
 
   @Test
   public void tls_invalidHost() throws SSLException {
-    SslContext ctx = GrpcSslContexts.forClient().build();
-    TlsNegotiator negotiator = (TlsNegotiator) ProtocolNegotiators.tls(ctx, "bad_host:1234");
+    HostPort hostPort = ProtocolNegotiators.parseAuthority("bad_host:1234");
 
     // Even though it looks like a port, we treat it as part of the authority, since the host is
     // invalid.
-    assertEquals("bad_host:1234", negotiator.getHost());
-    assertEquals(-1, negotiator.getPort());
+    assertEquals("bad_host:1234", hostPort.host);
+    assertEquals(-1, hostPort.port);
   }
 
   @Test
-  public void httpProxy_nullAddressNpe() throws Exception {
-    thrown.expect(NullPointerException.class);
-    ProtocolNegotiators.httpProxy(null, "user", "pass", ProtocolNegotiators.plaintext());
+  public void httpProxy_nullAddressNpe() {
+    assertThrows(NullPointerException.class,
+        () -> ProtocolNegotiators.httpProxy(null, null, "user", "pass", 
+            ProtocolNegotiators.plaintext()));
   }
 
   @Test
-  public void httpProxy_nullNegotiatorNpe() throws Exception {
-    thrown.expect(NullPointerException.class);
-    ProtocolNegotiators.httpProxy(
-        InetSocketAddress.createUnresolved("localhost", 80), "user", "pass", null);
+  public void httpProxy_nullNegotiatorNpe() {
+    assertThrows(NullPointerException.class,
+        () -> ProtocolNegotiators.httpProxy(
+            InetSocketAddress.createUnresolved("localhost", 80), null, "user", "pass", null));
   }
 
   @Test
   public void httpProxy_nullUserPassNoException() throws Exception {
     assertNotNull(ProtocolNegotiators.httpProxy(
-        InetSocketAddress.createUnresolved("localhost", 80), null, null,
+        InetSocketAddress.createUnresolved("localhost", 80), null, null, null,
         ProtocolNegotiators.plaintext()));
   }
 
-  @Test(timeout = 5000)
+  @Test
   public void httpProxy_completes() throws Exception {
     DefaultEventLoopGroup elg = new DefaultEventLoopGroup(1);
     // ProxyHandler is incompatible with EmbeddedChannel because when channelRegistered() is called
@@ -330,17 +1122,16 @@ public void httpProxy_completes() throws Exception {
         .bind(proxy).sync().channel();
 
     ProtocolNegotiator nego =
-        ProtocolNegotiators.httpProxy(proxy, null, null, ProtocolNegotiators.plaintext());
-    ChannelHandler handler = nego.newHandler(grpcHandler);
+        ProtocolNegotiators.httpProxy(proxy, null, null, null, ProtocolNegotiators.plaintext());
+    // normally NettyClientTransport will add WBAEH which kick start the ProtocolNegotiation,
+    // mocking the behavior using KickStartHandler.
+    ChannelHandler handler =
+        new KickStartHandler(nego.newHandler(FakeGrpcHttp2ConnectionHandler.noopHandler()));
     Channel channel = new Bootstrap().group(elg).channel(LocalChannel.class).handler(handler)
         .register().sync().channel();
     pipeline = channel.pipeline();
     // Wait for initialization to complete
     channel.eventLoop().submit(NOOP_RUNNABLE).sync();
-    // The grpcHandler must be in the pipeline, but we don't actually want it during our test
-    // because it will consume all events since it is a mock. We only use it because it is required
-    // to construct the Handler.
-    pipeline.remove(grpcHandler);
     channel.connect(host).sync();
     serverChannel.close();
     ArgumentCaptor<ChannelHandlerContext> contextCaptor =
@@ -355,7 +1146,7 @@ public void httpProxy_completes() throws Exception {
     channel.eventLoop().submit(NOOP_RUNNABLE).sync();
     ArgumentCaptor<Object> objectCaptor = ArgumentCaptor.forClass(Object.class);
     Mockito.verify(mockHandler)
-        .channelRead(any(ChannelHandlerContext.class), objectCaptor.capture());
+        .channelRead(ArgumentMatchers.<ChannelHandlerContext>any(), objectCaptor.capture());
     ByteBuf b = (ByteBuf) objectCaptor.getValue();
     String request = b.toString(UTF_8);
     b.release();
@@ -368,9 +1159,9 @@ public void httpProxy_completes() throws Exception {
     negotiationFuture.sync();
 
     channel.eventLoop().submit(NOOP_RUNNABLE).sync();
-    objectCaptor.getAllValues().clear();
+    objectCaptor = ArgumentCaptor.forClass(Object.class);
     Mockito.verify(mockHandler, times(2))
-        .channelRead(any(ChannelHandlerContext.class), objectCaptor.capture());
+        .channelRead(ArgumentMatchers.<ChannelHandlerContext>any(), objectCaptor.capture());
     b = (ByteBuf) objectCaptor.getAllValues().get(1);
     // If we were using the real grpcHandler, this would have been the HTTP/2 preface
     String preface = b.toString(UTF_8);
@@ -380,7 +1171,423 @@ public void httpProxy_completes() throws Exception {
     channel.close();
   }
 
+  @Test
+  public void httpProxy_500() throws Exception {
+    DefaultEventLoopGroup elg = new DefaultEventLoopGroup(1);
+    // ProxyHandler is incompatible with EmbeddedChannel because when channelRegistered() is called
+    // the channel is already active.
+    LocalAddress proxy = new LocalAddress("httpProxy_500");
+    SocketAddress host = InetSocketAddress.createUnresolved("specialHost", 314);
+
+    ChannelInboundHandler mockHandler = mock(ChannelInboundHandler.class);
+    Channel serverChannel = new ServerBootstrap().group(elg).channel(LocalServerChannel.class)
+        .childHandler(mockHandler)
+        .bind(proxy).sync().channel();
+
+    ProtocolNegotiator nego =
+        ProtocolNegotiators.httpProxy(proxy, null, null, null, ProtocolNegotiators.plaintext());
+    // normally NettyClientTransport will add WBAEH which kick start the ProtocolNegotiation,
+    // mocking the behavior using KickStartHandler.
+    ChannelHandler handler =
+        new KickStartHandler(nego.newHandler(FakeGrpcHttp2ConnectionHandler.noopHandler()));
+    Channel channel = new Bootstrap().group(elg).channel(LocalChannel.class).handler(handler)
+        .register().sync().channel();
+    pipeline = channel.pipeline();
+    // Wait for initialization to complete
+    channel.eventLoop().submit(NOOP_RUNNABLE).sync();
+    channel.connect(host).sync();
+    serverChannel.close();
+    ArgumentCaptor<ChannelHandlerContext> contextCaptor =
+        ArgumentCaptor.forClass(ChannelHandlerContext.class);
+    Mockito.verify(mockHandler).channelActive(contextCaptor.capture());
+    ChannelHandlerContext serverContext = contextCaptor.getValue();
+
+    final String golden = "isThisThingOn?";
+    ChannelFuture negotiationFuture = channel.writeAndFlush(bb(golden, channel));
+
+    // Wait for sending initial request to complete
+    channel.eventLoop().submit(NOOP_RUNNABLE).sync();
+    ArgumentCaptor<Object> objectCaptor = ArgumentCaptor.forClass(Object.class);
+    Mockito.verify(mockHandler)
+        .channelRead(any(ChannelHandlerContext.class), objectCaptor.capture());
+    ByteBuf request = (ByteBuf) objectCaptor.getValue();
+    request.release();
+
+    assertFalse(negotiationFuture.isDone());
+    String response = "HTTP/1.1 500 OMG\r\nContent-Length: 4\r\n\r\noops";
+    serverContext.writeAndFlush(bb(response, serverContext.channel())).sync();
+    try {
+      assertThrows(ProxyConnectException.class, negotiationFuture::sync);
+    } finally {
+      channel.close();
+    }
+  }
+
+  @Test
+  public void httpProxy_customHeaders() throws Exception {
+    DefaultEventLoopGroup elg = new DefaultEventLoopGroup(1);
+    // ProxyHandler is incompatible with EmbeddedChannel because when channelRegistered() is called
+    // the channel is already active.
+    LocalAddress proxy = new LocalAddress("httpProxy_customHeaders");
+    SocketAddress host = InetSocketAddress.createUnresolved("example.com", 443);
+
+    ChannelInboundHandler mockHandler = mock(ChannelInboundHandler.class);
+    Channel serverChannel = new ServerBootstrap().group(elg).channel(LocalServerChannel.class)
+        .childHandler(mockHandler)
+        .bind(proxy).sync().channel();
+
+    Map<String, String> headers = new java.util.HashMap<>();
+    headers.put("X-Custom-Header", "custom-value");
+    headers.put("Proxy-Authorization", "Bearer token123");
+
+    ProtocolNegotiator nego = ProtocolNegotiators.httpProxy(
+        proxy, headers, null, null, ProtocolNegotiators.plaintext());
+    // normally NettyClientTransport will add WBAEH which kick start the ProtocolNegotiation,
+    // mocking the behavior using KickStartHandler.
+    ChannelHandler handler =
+        new KickStartHandler(nego.newHandler(FakeGrpcHttp2ConnectionHandler.noopHandler()));
+    Channel channel = new Bootstrap().group(elg).channel(LocalChannel.class).handler(handler)
+        .register().sync().channel();
+    pipeline = channel.pipeline();
+    // Wait for initialization to complete
+    channel.eventLoop().submit(NOOP_RUNNABLE).sync();
+    channel.connect(host).sync();
+    serverChannel.close();
+    ArgumentCaptor<ChannelHandlerContext> contextCaptor =
+        ArgumentCaptor.forClass(ChannelHandlerContext.class);
+    Mockito.verify(mockHandler).channelActive(contextCaptor.capture());
+    ChannelHandlerContext serverContext = contextCaptor.getValue();
+
+    final String golden = "testData";
+    ChannelFuture negotiationFuture = channel.writeAndFlush(bb(golden, channel));
+
+    // Wait for sending initial request to complete
+    channel.eventLoop().submit(NOOP_RUNNABLE).sync();
+    ArgumentCaptor<Object> objectCaptor = ArgumentCaptor.forClass(Object.class);
+    Mockito.verify(mockHandler)
+        .channelRead(ArgumentMatchers.<ChannelHandlerContext>any(), objectCaptor.capture());
+    ByteBuf b = (ByteBuf) objectCaptor.getValue();
+    String request = b.toString(UTF_8);
+    b.release();
+
+    // Verify custom headers are present in the CONNECT request
+    assertTrue("No trailing newline: " + request, request.endsWith("\r\n\r\n"));
+    assertTrue("No CONNECT: " + request, request.startsWith("CONNECT example.com:443 "));
+    assertTrue("No custom header: " + request, 
+        request.contains("X-Custom-Header: custom-value"));
+    assertTrue("No proxy authorization: " + request,
+        request.contains("Proxy-Authorization: Bearer token123"));
+
+    assertFalse(negotiationFuture.isDone());
+    serverContext.writeAndFlush(bb("HTTP/1.1 200 OK\r\n\r\n", serverContext.channel())).sync();
+    negotiationFuture.sync();
+
+    channel.eventLoop().submit(NOOP_RUNNABLE).sync();
+    objectCaptor = ArgumentCaptor.forClass(Object.class);
+    Mockito.verify(mockHandler, times(2))
+        .channelRead(ArgumentMatchers.<ChannelHandlerContext>any(), objectCaptor.capture());
+    b = (ByteBuf) objectCaptor.getAllValues().get(1);
+    String preface = b.toString(UTF_8);
+    b.release();
+    assertEquals(golden, preface);
+
+    channel.close();
+  }
+
+  @Test
+  public void waitUntilActiveHandler_firesNegotiation() throws Exception {
+    EventLoopGroup elg = new DefaultEventLoopGroup(1);
+    SocketAddress addr = new LocalAddress("addr");
+    final AtomicReference<Object> event = new AtomicReference<>();
+    ChannelHandler next = new ChannelInboundHandlerAdapter() {
+      @Override
+      public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
+        event.set(evt);
+        ctx.close();
+      }
+    };
+    Channel s = new ServerBootstrap()
+        .childHandler(new ChannelInboundHandlerAdapter())
+        .group(elg)
+        .channel(LocalServerChannel.class)
+        .bind(addr)
+        .sync()
+        .channel();
+    Channel c = new Bootstrap()
+        .handler(new WaitUntilActiveHandler(next, noopLogger))
+        .channel(LocalChannel.class).group(group)
+        .connect(addr)
+        .sync()
+        .channel();
+    c.pipeline().fireUserEventTriggered(ProtocolNegotiationEvent.DEFAULT);
+    SocketAddress localAddr = c.localAddress();
+    ProtocolNegotiationEvent expectedEvent = ProtocolNegotiationEvent.DEFAULT
+        .withAttributes(
+            Attributes.newBuilder()
+                .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, localAddr)
+                .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, addr)
+                .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.NONE)
+                .build());
+
+    c.closeFuture().sync();
+    assertThat(event.get()).isInstanceOf(ProtocolNegotiationEvent.class);
+    ProtocolNegotiationEvent actual = (ProtocolNegotiationEvent) event.get();
+    assertThat(actual).isEqualTo(expectedEvent);
+
+    s.close();
+    elg.shutdownGracefully();
+  }
+
+  @Test
+  public void clientTlsHandler_firesNegotiation() throws Exception {
+    SslContext clientSslContext;
+    try (InputStream ca = TlsTesting.loadCert("ca.pem")) {
+      clientSslContext = GrpcSslContexts.forClient().trustManager(ca).build();
+    }
+    SslContext serverSslContext;
+    try (InputStream server1Key = TlsTesting.loadCert("server1.key");
+        InputStream server1Chain = TlsTesting.loadCert("server1.pem")) {
+      serverSslContext = GrpcSslContexts.forServer(server1Chain, server1Key).build();
+    }
+    FakeGrpcHttp2ConnectionHandler gh = FakeGrpcHttp2ConnectionHandler.newHandler();
+    ClientTlsProtocolNegotiator pn = new ClientTlsProtocolNegotiator(clientSslContext,
+        null, Optional.absent(), null, null);
+    WriteBufferingAndExceptionHandler clientWbaeh =
+        new WriteBufferingAndExceptionHandler(pn.newHandler(gh));
+
+    SocketAddress addr = new LocalAddress("addr");
+
+    ChannelHandler sh =
+        ProtocolNegotiators.serverTls(serverSslContext)
+            .newHandler(FakeGrpcHttp2ConnectionHandler.noopHandler());
+    WriteBufferingAndExceptionHandler serverWbaeh = new WriteBufferingAndExceptionHandler(sh);
+    Channel s = new ServerBootstrap()
+        .childHandler(serverWbaeh)
+        .group(group)
+        .channel(LocalServerChannel.class)
+        .bind(addr)
+        .sync()
+        .channel();
+    Channel c = new Bootstrap()
+        .handler(clientWbaeh)
+        .channel(LocalChannel.class)
+        .group(group)
+        .register()
+        .sync()
+        .channel();
+    ChannelFuture write = c.writeAndFlush(NettyClientHandler.NOOP_MESSAGE);
+    c.connect(addr).sync();
+    write.sync();
+
+    boolean completed = gh.negotiated.await(TIMEOUT_SECONDS, TimeUnit.SECONDS);
+    if (!completed) {
+      assertTrue("failed to negotiated", write.await(TIMEOUT_SECONDS, TimeUnit.SECONDS));
+      // sync should fail if we are in this block.
+      write.sync();
+      throw new AssertionError("neither wrote nor negotiated");
+    }
+    c.close();
+    s.close();
+    pn.close();
+
+    assertThat(gh.securityInfo).isNotNull();
+    assertThat(gh.securityInfo.tls).isNotNull();
+    assertThat(gh.attrs.get(GrpcAttributes.ATTR_SECURITY_LEVEL))
+        .isEqualTo(SecurityLevel.PRIVACY_AND_INTEGRITY);
+    assertThat(gh.attrs.get(Grpc.TRANSPORT_ATTR_SSL_SESSION)).isInstanceOf(SSLSession.class);
+    // This is not part of the ClientTls negotiation, but shows that the negotiation event happens
+    // in the right order.
+    assertThat(gh.attrs.get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR)).isEqualTo(addr);
+  }
+
+  @Test
+  public void plaintextUpgradeNegotiator() throws Exception {
+    LocalAddress addr = new LocalAddress("plaintextUpgradeNegotiator");
+    UpgradeCodecFactory ucf = new UpgradeCodecFactory() {
+
+      @Override
+      public UpgradeCodec newUpgradeCodec(CharSequence protocol) {
+        return new Http2ServerUpgradeCodec(FakeGrpcHttp2ConnectionHandler.newHandler());
+      }
+    };
+    final HttpServerCodec serverCodec = new HttpServerCodec();
+    final HttpServerUpgradeHandler serverUpgradeHandler =
+        new HttpServerUpgradeHandler(serverCodec, ucf);
+    Channel serverChannel = new ServerBootstrap()
+        .group(group)
+        .channel(LocalServerChannel.class)
+        .childHandler(new ChannelInitializer<Channel>() {
+
+          @Override
+          protected void initChannel(Channel ch) throws Exception {
+            ch.pipeline().addLast(serverCodec, serverUpgradeHandler);
+          }
+        })
+        .bind(addr)
+        .sync()
+        .channel();
+
+    FakeGrpcHttp2ConnectionHandler gh = FakeGrpcHttp2ConnectionHandler.newHandler();
+    ProtocolNegotiator nego = ProtocolNegotiators.plaintextUpgrade();
+    ChannelHandler ch = nego.newHandler(gh);
+    WriteBufferingAndExceptionHandler wbaeh = new WriteBufferingAndExceptionHandler(ch);
+
+    Channel channel = new Bootstrap()
+        .group(group)
+        .channel(LocalChannel.class)
+        .handler(wbaeh)
+        .register()
+        .sync()
+        .channel();
+
+    ChannelFuture write = channel.writeAndFlush(NettyClientHandler.NOOP_MESSAGE);
+    channel.connect(serverChannel.localAddress());
+
+    boolean completed = gh.negotiated.await(TIMEOUT_SECONDS, TimeUnit.SECONDS);
+    if (!completed) {
+      assertTrue("failed to negotiated", write.await(TIMEOUT_SECONDS, TimeUnit.SECONDS));
+      // sync should fail if we are in this block.
+      write.sync();
+      throw new AssertionError("neither wrote nor negotiated");
+    }
+
+    channel.close().sync();
+    serverChannel.close();
+
+    assertThat(gh.securityInfo).isNull();
+    assertThat(gh.attrs.get(GrpcAttributes.ATTR_SECURITY_LEVEL)).isEqualTo(SecurityLevel.NONE);
+    assertThat(gh.attrs.get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR)).isEqualTo(addr);
+  }
+
+  private static void callMeMaybe(Runnable runnable) {
+    if (runnable != null) {
+      runnable.run();
+    }
+  }
+
+  private static class FakeGrpcHttp2ConnectionHandler extends GrpcHttp2ConnectionHandler {
+
+    static FakeGrpcHttp2ConnectionHandler noopHandler() {
+      return newHandler(true);
+    }
+
+    static FakeGrpcHttp2ConnectionHandler newHandler() {
+      return newHandler(false);
+    }
+
+    private static FakeGrpcHttp2ConnectionHandler newHandler(boolean noop) {
+      DefaultHttp2Connection conn = new DefaultHttp2Connection(/*server=*/ false);
+      DefaultHttp2ConnectionEncoder encoder =
+          new DefaultHttp2ConnectionEncoder(conn, new DefaultHttp2FrameWriter());
+      DefaultHttp2ConnectionDecoder decoder =
+          new DefaultHttp2ConnectionDecoder(conn, encoder, new DefaultHttp2FrameReader());
+      Http2Settings settings = new Http2Settings();
+      return new FakeGrpcHttp2ConnectionHandler(
+          /*channelUnused=*/ null, decoder, encoder, settings, noop, noopLogger);
+    }
+
+    private final boolean noop;
+    private Attributes attrs;
+    private Security securityInfo;
+    private final CountDownLatch negotiated = new CountDownLatch(1);
+    private ChannelHandlerContext ctx;
+
+    FakeGrpcHttp2ConnectionHandler(ChannelPromise channelUnused,
+        Http2ConnectionDecoder decoder,
+        Http2ConnectionEncoder encoder,
+        Http2Settings initialSettings,
+        boolean noop,
+        ChannelLogger negotiationLogger) {
+      super(channelUnused, decoder, encoder, initialSettings, negotiationLogger);
+      this.noop = noop;
+    }
+
+    @Override
+    public void handleProtocolNegotiationCompleted(Attributes attrs, Security securityInfo) {
+      checkNotNull(ctx, "handleProtocolNegotiationCompleted cannot be called before handlerAdded");
+      super.handleProtocolNegotiationCompleted(attrs, securityInfo);
+      this.attrs = attrs;
+      this.securityInfo = securityInfo;
+      // Add a temp handler that verifies first message is a NOOP_MESSAGE
+      ctx.pipeline().addBefore(ctx.name(), null, new ChannelOutboundHandlerAdapter() {
+        @Override
+        public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
+            throws Exception {
+          checkState(
+              msg == NettyClientHandler.NOOP_MESSAGE, "First message should be NOOP_MESSAGE");
+          promise.trySuccess();
+          ctx.pipeline().remove(this);
+        }
+      });
+      NettyClientHandler.writeBufferingAndRemove(ctx.channel());
+      negotiated.countDown();
+    }
+
+    @Override
+    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+      if (noop) {
+        ctx.pipeline().remove(ctx.name());
+      } else {
+        super.handlerAdded(ctx);
+      }
+      this.ctx = ctx;
+    }
+
+    @Override
+    public String getAuthority() {
+      return "foo.test.google.fr";
+    }
+  }
+
   private static ByteBuf bb(String s, Channel c) {
     return ByteBufUtil.writeUtf8(c.alloc(), s);
   }
+
+  private static final class KickStartHandler extends ChannelDuplexHandler {
+
+    private final ChannelHandler next;
+
+    public KickStartHandler(ChannelHandler next) {
+      this.next = checkNotNull(next, "next");
+    }
+
+    @Override
+    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+      ctx.pipeline().replace(ctx.name(), null, next);
+      ctx.pipeline().fireUserEventTriggered(ProtocolNegotiationEvent.DEFAULT);
+    }
+  }
+
+  private static class MockServerListener implements ServerListener {
+    private final CountDownLatch latch = new CountDownLatch(1);
+    public Queue<ServerTransport> transports = new ArrayDeque<>();
+
+    @Override
+    public ServerTransportListener transportCreated(ServerTransport transport) {
+      transports.add(transport);
+      return new MockServerTransportListener();
+    }
+
+    @Override
+    public void serverShutdown() {
+      latch.countDown();
+    }
+
+    public boolean waitForShutdown(long timeout, TimeUnit unit) throws InterruptedException {
+      return latch.await(timeout, unit);
+    }
+  }
+
+  private static class MockServerTransportListener implements ServerTransportListener {
+    @Override
+    public void streamCreated(ServerStream stream, String method, Metadata headers) {}
+
+    @Override
+    public Attributes transportReady(Attributes attributes) {
+      return attributes;
+    }
+
+    @Override
+    public void transportTerminated() {}
+  }
 }
diff --git a/netty/src/test/java/io/grpc/netty/TlsTest.java b/netty/src/test/java/io/grpc/netty/TlsTest.java
new file mode 100644
index 00000000000..c5b46563878
--- /dev/null
+++ b/netty/src/test/java/io/grpc/netty/TlsTest.java
@@ -0,0 +1,420 @@
+/*
+ * Copyright 2015 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.netty;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import com.google.common.base.Throwables;
+import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.ConnectivityState;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.internal.testing.TestUtils;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import io.netty.handler.ssl.ClientAuth;
+import io.netty.handler.ssl.OpenSsl;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslContextBuilder;
+import io.netty.handler.ssl.SslProvider;
+import java.io.File;
+import java.io.IOException;
+import java.security.NoSuchAlgorithmException;
+import java.security.Provider;
+import java.security.Security;
+import java.security.cert.X509Certificate;
+import java.util.Arrays;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLHandshakeException;
+import org.junit.After;
+import org.junit.Assume;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+
+/**
+ * Integration tests for Netty's TLS support.
+ */
+@RunWith(Parameterized.class)
+public class TlsTest {
+
+  public static enum TlsImpl {
+    TCNATIVE, JDK, CONSCRYPT;
+  }
+
+  /**
+   * Iterable of various configurations to use for tests.
+   */
+  @Parameters(name = "{0}")
+  public static Iterable<Object[]> data() {
+    return Arrays.asList(new Object[][] {
+      {TlsImpl.TCNATIVE}, {TlsImpl.JDK}, {TlsImpl.CONSCRYPT},
+    });
+  }
+
+  @Parameter(value = 0)
+  public TlsImpl tlsImpl;
+
+  private ScheduledExecutorService executor;
+  private Server server;
+  private ManagedChannel channel;
+  private SslProvider sslProvider;
+  private Provider jdkProvider;
+  private SslContextBuilder clientContextBuilder;
+
+  @BeforeClass
+  public static void loadConscrypt() {
+    TestUtils.installConscryptIfAvailable();
+  }
+
+  @Before
+  public void setUp() throws NoSuchAlgorithmException {
+    executor = Executors.newSingleThreadScheduledExecutor();
+    switch (tlsImpl) {
+      case TCNATIVE:
+        Assume.assumeTrue(OpenSsl.isAvailable());
+        sslProvider = SslProvider.OPENSSL;
+        break;
+      case JDK:
+        Assume.assumeTrue(Arrays.asList(
+            SSLContext.getDefault().getSupportedSSLParameters().getCipherSuites())
+            .contains("TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256"));
+        sslProvider = SslProvider.JDK;
+        jdkProvider = Security.getProvider("SunJSSE");
+        Assume.assumeNotNull(jdkProvider);
+        try {
+          // Check for presence of an (ironic) class added in Java 9
+          Class.forName("java.lang.Runtime$Version");
+          // Java 9+
+        } catch (ClassNotFoundException ignored) {
+          // Before Java 9
+          try {
+            GrpcSslContexts.configure(SslContextBuilder.forClient(), jdkProvider);
+          } catch (IllegalArgumentException ex) {
+            Assume.assumeNoException("Not Java 9+ and Jetty ALPN does not seem available", ex);
+          }
+        }
+        break;
+      case CONSCRYPT:
+        sslProvider = SslProvider.JDK;
+        jdkProvider = Security.getProvider("Conscrypt");
+        Assume.assumeNotNull(jdkProvider);
+        break;
+      default:
+        throw new AssertionError();
+    }
+    clientContextBuilder = SslContextBuilder.forClient();
+    if (sslProvider == SslProvider.JDK) {
+      GrpcSslContexts.configure(clientContextBuilder, jdkProvider);
+    } else {
+      GrpcSslContexts.configure(clientContextBuilder, sslProvider);
+    }
+  }
+
+  @After
+  public void tearDown() {
+    if (server != null) {
+      server.shutdown();
+    }
+    if (channel != null) {
+      channel.shutdown();
+    }
+    MoreExecutors.shutdownAndAwaitTermination(executor, 5, TimeUnit.SECONDS);
+  }
+
+
+  /**
+   * Tests that a client and a server configured using GrpcSslContexts can successfully
+   * communicate with each other.
+   */
+  @Test
+  public void basicClientServerIntegrationTest() throws Exception {
+    // Create & start a server.
+    File serverCertFile = TestUtils.loadCert("server1.pem");
+    File serverPrivateKeyFile = TestUtils.loadCert("server1.key");
+    X509Certificate[] serverTrustedCaCerts = {
+      TestUtils.loadX509Cert("ca.pem")
+    };
+    server = serverBuilder(0, serverCertFile, serverPrivateKeyFile, serverTrustedCaCerts)
+        .addService(new SimpleServiceImpl())
+        .build()
+        .start();
+
+    // Create a client.
+    File clientCertChainFile = TestUtils.loadCert("client.pem");
+    File clientPrivateKeyFile = TestUtils.loadCert("client.key");
+    X509Certificate[] clientTrustedCaCerts = {
+      TestUtils.loadX509Cert("ca.pem")
+    };
+    channel = clientChannel(server.getPort(), clientContextBuilder
+        .keyManager(clientCertChainFile, clientPrivateKeyFile)
+        .trustManager(clientTrustedCaCerts)
+        .build());
+    SimpleServiceGrpc.SimpleServiceBlockingStub client = SimpleServiceGrpc.newBlockingStub(channel);
+
+    // Send an actual request, via the full GRPC & network stack, and check that a proper
+    // response comes back.
+    client.unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+
+  /**
+   * Test that a client fails to send requests over TLS to a server with an unexpected hostname
+   * listed in an otherwise valid certificate.
+   */
+  @Test
+  public void clientRejectedMismatchedHostname() throws Exception {
+    // Create & start a server.
+    File serverCertFile = TestUtils.loadCert("server1.pem");
+    File serverPrivateKeyFile = TestUtils.loadCert("server1.key");
+    X509Certificate[] serverTrustedCaCerts = {
+        TestUtils.loadX509Cert("ca.pem")
+    };
+    server = serverBuilder(0, serverCertFile, serverPrivateKeyFile, serverTrustedCaCerts)
+        .addService(new SimpleServiceImpl())
+        .build()
+        .start();
+
+    // Create a client.
+    File clientCertChainFile = TestUtils.loadCert("client.pem");
+    File clientPrivateKeyFile = TestUtils.loadCert("client.key");
+    X509Certificate[] clientTrustedCaCerts = {
+        TestUtils.loadX509Cert("ca.pem")
+    };
+
+    // Override authority on the client to trigger a hostname verification failure
+    channel = NettyChannelBuilder.forAddress("localhost", server.getPort())
+        .overrideAuthority("i.am.a.bad.hostname")
+        .negotiationType(NegotiationType.TLS)
+        .sslContext(clientContextBuilder
+            .keyManager(clientCertChainFile, clientPrivateKeyFile)
+            .trustManager(clientTrustedCaCerts)
+            .build()
+        )
+        .build();
+    SimpleServiceGrpc.SimpleServiceBlockingStub client = SimpleServiceGrpc.newBlockingStub(channel);
+
+    // Send an actual request, via the full GRPC & network stack, and check that a proper
+    // response comes back.
+    try {
+      client.unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("TLS handshake should have failed, but didn't; received RPC response");
+    } catch (StatusRuntimeException e) {
+      assertEquals(Throwables.getStackTraceAsString(e), Status.Code.UNAVAILABLE,
+          e.getStatus().getCode());
+      // The root of the failure should be a CertificateException, but it is wrapped by a varying
+      // number of SSLHandshakeExceptions. Thus, reliably detecting the underlying cause is not
+      // feasible.
+      assertThat(e.getCause()).isInstanceOf(SSLHandshakeException.class);
+    }
+  }
+
+  /**
+   * Tests that a server configured to require client authentication refuses to accept connections
+   * from a client that has an untrusted certificate.
+   */
+  @Test
+  public void serverRejectsUntrustedClientCert() throws Exception {
+    // Create & start a server. It requires client authentication and trusts only the test CA.
+    File serverCertFile = TestUtils.loadCert("server1.pem");
+    File serverPrivateKeyFile = TestUtils.loadCert("server1.key");
+    X509Certificate[] serverTrustedCaCerts = {
+      TestUtils.loadX509Cert("ca.pem")
+    };
+    server = serverBuilder(0, serverCertFile, serverPrivateKeyFile, serverTrustedCaCerts)
+        .addService(new SimpleServiceImpl())
+        .build()
+        .start();
+
+    // Create a client. Its credentials come from a CA that the server does not trust. The client
+    // trusts both test CAs, so we can be sure that the handshake failure is due to the server
+    // rejecting the client's cert, not the client rejecting the server's cert.
+    File clientCertChainFile = TestUtils.loadCert("badclient.pem");
+    File clientPrivateKeyFile = TestUtils.loadCert("badclient.key");
+    X509Certificate[] clientTrustedCaCerts = {
+      TestUtils.loadX509Cert("ca.pem")
+    };
+    channel = clientChannel(server.getPort(), clientContextBuilder
+        .keyManager(clientCertChainFile, clientPrivateKeyFile)
+        .trustManager(clientTrustedCaCerts)
+        .build());
+    SimpleServiceGrpc.SimpleServiceBlockingStub client = SimpleServiceGrpc.newBlockingStub(channel);
+
+    // Check that the TLS handshake fails.
+    try {
+      client.unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("TLS handshake should have failed, but didn't; received RPC response");
+    } catch (StatusRuntimeException e) {
+      // GRPC reports this situation by throwing a StatusRuntimeException that wraps either a
+      // javax.net.ssl.SSLHandshakeException or a java.nio.channels.ClosedChannelException.
+      // Thus, reliably detecting the underlying cause is not feasible.
+      assertEquals(
+          Throwables.getStackTraceAsString(e),
+          Status.Code.UNAVAILABLE, e.getStatus().getCode());
+    }
+    // We really want to see TRANSIENT_FAILURE here, but if the test runs slowly the 1s backoff
+    // may be exceeded by the time the failure happens (since it counts from the start of the
+    // attempt). Even so, CONNECTING is a strong indicator that the handshake failed; otherwise we'd
+    // expect READY or IDLE.
+    assertThat(channel.getState(false))
+        .isAnyOf(ConnectivityState.TRANSIENT_FAILURE, ConnectivityState.CONNECTING);
+  }
+
+
+  /**
+   * Tests that a server configured to require client authentication actually does require client
+   * authentication.
+   */
+  @Test
+  public void noClientAuthFailure() throws Exception {
+    // Create & start a server.
+    File serverCertFile = TestUtils.loadCert("server1.pem");
+    File serverPrivateKeyFile = TestUtils.loadCert("server1.key");
+    X509Certificate[] serverTrustedCaCerts = {
+      TestUtils.loadX509Cert("ca.pem")
+    };
+    server = serverBuilder(0, serverCertFile, serverPrivateKeyFile, serverTrustedCaCerts)
+        .addService(new SimpleServiceImpl())
+        .build()
+        .start();
+
+    // Create a client. It has no credentials.
+    X509Certificate[] clientTrustedCaCerts = {
+      TestUtils.loadX509Cert("ca.pem")
+    };
+    channel = clientChannel(server.getPort(), clientContextBuilder
+        .trustManager(clientTrustedCaCerts)
+        .build());
+    SimpleServiceGrpc.SimpleServiceBlockingStub client = SimpleServiceGrpc.newBlockingStub(channel);
+
+    // Check that the TLS handshake fails.
+    try {
+      client.unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("TLS handshake should have failed, but didn't; received RPC response");
+    } catch (StatusRuntimeException e) {
+      // GRPC reports this situation by throwing a StatusRuntimeException that wraps either a
+      // javax.net.ssl.SSLHandshakeException or a java.nio.channels.ClosedChannelException.
+      // Thus, reliably detecting the underlying cause is not feasible.
+      assertEquals(
+          Throwables.getStackTraceAsString(e),
+          Status.Code.UNAVAILABLE, e.getStatus().getCode());
+    }
+    // We really want to see TRANSIENT_FAILURE here, but if the test runs slowly the 1s backoff
+    // may be exceeded by the time the failure happens (since it counts from the start of the
+    // attempt). Even so, CONNECTING is a strong indicator that the handshake failed; otherwise we'd
+    assertThat(channel.getState(false))
+        .isAnyOf(ConnectivityState.TRANSIENT_FAILURE, ConnectivityState.CONNECTING);
+  }
+
+
+  /**
+   * Tests that a client configured using GrpcSslContexts refuses to talk to a server that has an
+   * an untrusted certificate.
+   */
+  @Test
+  public void clientRejectsUntrustedServerCert() throws Exception {
+    // Create & start a server.
+    File serverCertFile = TestUtils.loadCert("badserver.pem");
+    File serverPrivateKeyFile = TestUtils.loadCert("badserver.key");
+    X509Certificate[] serverTrustedCaCerts = {
+      TestUtils.loadX509Cert("ca.pem")
+    };
+    server = serverBuilder(0, serverCertFile, serverPrivateKeyFile, serverTrustedCaCerts)
+        .addService(new SimpleServiceImpl())
+        .build()
+        .start();
+
+    // Create a client.
+    File clientCertChainFile = TestUtils.loadCert("client.pem");
+    File clientPrivateKeyFile = TestUtils.loadCert("client.key");
+    X509Certificate[] clientTrustedCaCerts = {
+      TestUtils.loadX509Cert("ca.pem")
+    };
+    channel = clientChannel(server.getPort(), clientContextBuilder
+        .keyManager(clientCertChainFile, clientPrivateKeyFile)
+        .trustManager(clientTrustedCaCerts)
+        .build());
+    SimpleServiceGrpc.SimpleServiceBlockingStub client = SimpleServiceGrpc.newBlockingStub(channel);
+
+    // Check that the TLS handshake fails.
+    try {
+      client.unaryRpc(SimpleRequest.getDefaultInstance());
+      fail("TLS handshake should have failed, but didn't; received RPC response");
+    } catch (StatusRuntimeException e) {
+      // GRPC reports this situation by throwing a StatusRuntimeException that wraps either a
+      // javax.net.ssl.SSLHandshakeException or a java.nio.channels.ClosedChannelException.
+      // Thus, reliably detecting the underlying cause is not feasible.
+      // TODO(carl-mastrangelo): eventually replace this with a hamcrest matcher.
+      assertEquals(
+          Throwables.getStackTraceAsString(e),
+          Status.Code.UNAVAILABLE, e.getStatus().getCode());
+    }
+    // We really want to see TRANSIENT_FAILURE here, but if the test runs slowly the 1s backoff
+    // may be exceeded by the time the failure happens (since it counts from the start of the
+    // attempt). Even so, CONNECTING is a strong indicator that the handshake failed; otherwise we'd
+    assertThat(channel.getState(false))
+        .isAnyOf(ConnectivityState.TRANSIENT_FAILURE, ConnectivityState.CONNECTING);
+  }
+
+
+  private ServerBuilder<?> serverBuilder(int port, File serverCertChainFile,
+      File serverPrivateKeyFile, X509Certificate[] serverTrustedCaCerts) throws IOException {
+    SslContextBuilder sslContextBuilder
+        = SslContextBuilder.forServer(serverCertChainFile, serverPrivateKeyFile);
+    if (sslProvider == SslProvider.JDK) {
+      GrpcSslContexts.configure(sslContextBuilder, jdkProvider);
+    } else {
+      GrpcSslContexts.configure(sslContextBuilder, sslProvider);
+    }
+    sslContextBuilder.trustManager(serverTrustedCaCerts)
+        .clientAuth(ClientAuth.REQUIRE);
+
+    return NettyServerBuilder.forPort(port)
+        .sslContext(sslContextBuilder.build());
+  }
+
+
+  private static ManagedChannel clientChannel(int port, SslContext sslContext) throws IOException {
+    return NettyChannelBuilder.forAddress("localhost", port)
+        .overrideAuthority(TestUtils.TEST_SERVER_HOST)
+        .negotiationType(NegotiationType.TLS)
+        .sslContext(sslContext)
+        .build();
+  }
+
+  private static class SimpleServiceImpl extends SimpleServiceGrpc.SimpleServiceImplBase {
+    @Override
+    public void unaryRpc(SimpleRequest req, StreamObserver<SimpleResponse> respOb) {
+      respOb.onNext(SimpleResponse.getDefaultInstance());
+      respOb.onCompleted();
+    }
+  }
+}
diff --git a/netty/src/test/java/io/grpc/netty/UdsNameResolverProviderTest.java b/netty/src/test/java/io/grpc/netty/UdsNameResolverProviderTest.java
new file mode 100644
index 00000000000..9dacf00cfad
--- /dev/null
+++ b/netty/src/test/java/io/grpc/netty/UdsNameResolverProviderTest.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2015 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.netty;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.ChannelLogger;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GrpcUtil;
+import io.netty.channel.unix.DomainSocketAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.List;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for {@link UdsNameResolverProvider}. */
+@RunWith(JUnit4.class)
+public class UdsNameResolverProviderTest {
+  private static final int DEFAULT_PORT = 887;
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock
+  private NameResolver.Listener2 mockListener;
+
+  @Captor
+  private ArgumentCaptor<NameResolver.ResolutionResult> resultCaptor;
+
+  UdsNameResolverProvider udsNameResolverProvider = new UdsNameResolverProvider();
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      (t, e) -> {
+        throw new AssertionError(e);
+      });
+  private final FakeClock fakeExecutor = new FakeClock();
+  private final NameResolver.Args args = NameResolver.Args.newBuilder()
+      .setDefaultPort(DEFAULT_PORT)
+      .setProxyDetector(GrpcUtil.DEFAULT_PROXY_DETECTOR)
+      .setSynchronizationContext(syncContext)
+      .setServiceConfigParser(mock(ServiceConfigParser.class))
+      .setChannelLogger(mock(ChannelLogger.class))
+      .setScheduledExecutorService(fakeExecutor.getScheduledExecutorService())
+      .build();
+
+  @Test
+  public void testUnixRelativePath() {
+    UdsNameResolver udsNameResolver =
+        udsNameResolverProvider.newNameResolver(URI.create("unix:sock.sock"), args);
+    assertThat(udsNameResolver).isNotNull();
+    udsNameResolver.start(mockListener);
+    verify(mockListener).onResult2(resultCaptor.capture());
+    NameResolver.ResolutionResult result = resultCaptor.getValue();
+    List<EquivalentAddressGroup> list = result.getAddressesOrError().getValue();
+    assertThat(list).isNotNull();
+    assertThat(list).hasSize(1);
+    EquivalentAddressGroup eag = list.get(0);
+    assertThat(eag).isNotNull();
+    List<SocketAddress> addresses = eag.getAddresses();
+    assertThat(addresses).hasSize(1);
+    assertThat(addresses.get(0)).isInstanceOf(DomainSocketAddress.class);
+    DomainSocketAddress domainSocketAddress = (DomainSocketAddress) addresses.get(0);
+    assertThat(domainSocketAddress.path()).isEqualTo("sock.sock");
+  }
+
+  @Test
+  public void testUnixAbsolutePath() {
+    UdsNameResolver udsNameResolver =
+        udsNameResolverProvider.newNameResolver(URI.create("unix:/sock.sock"), args);
+    assertThat(udsNameResolver).isNotNull();
+    udsNameResolver.start(mockListener);
+    verify(mockListener).onResult2(resultCaptor.capture());
+    NameResolver.ResolutionResult result = resultCaptor.getValue();
+    List<EquivalentAddressGroup> list = result.getAddressesOrError().getValue();
+    assertThat(list).isNotNull();
+    assertThat(list).hasSize(1);
+    EquivalentAddressGroup eag = list.get(0);
+    assertThat(eag).isNotNull();
+    List<SocketAddress> addresses = eag.getAddresses();
+    assertThat(addresses).hasSize(1);
+    assertThat(addresses.get(0)).isInstanceOf(DomainSocketAddress.class);
+    DomainSocketAddress domainSocketAddress = (DomainSocketAddress) addresses.get(0);
+    assertThat(domainSocketAddress.path()).isEqualTo("/sock.sock");
+  }
+
+  @Test
+  public void testUnixAbsoluteAlternatePath() {
+    UdsNameResolver udsNameResolver =
+        udsNameResolverProvider.newNameResolver(URI.create("unix:///sock.sock"), args);
+    assertThat(udsNameResolver).isNotNull();
+    udsNameResolver.start(mockListener);
+    verify(mockListener).onResult2(resultCaptor.capture());
+    NameResolver.ResolutionResult result = resultCaptor.getValue();
+    List<EquivalentAddressGroup> list = result.getAddressesOrError().getValue();
+    assertThat(list).isNotNull();
+    assertThat(list).hasSize(1);
+    EquivalentAddressGroup eag = list.get(0);
+    assertThat(eag).isNotNull();
+    List<SocketAddress> addresses = eag.getAddresses();
+    assertThat(addresses).hasSize(1);
+    assertThat(addresses.get(0)).isInstanceOf(DomainSocketAddress.class);
+    DomainSocketAddress domainSocketAddress = (DomainSocketAddress) addresses.get(0);
+    assertThat(domainSocketAddress.path()).isEqualTo("/sock.sock");
+  }
+
+  @Test
+  public void testUnixPathWithAuthority() {
+    try {
+      udsNameResolverProvider.newNameResolver(URI.create("unix://localhost/sock.sock"), args);
+      fail("exception expected");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().isEqualTo("non-null authority not supported");
+    }
+  }
+}
diff --git a/netty/src/test/java/io/grpc/netty/UdsNameResolverTest.java b/netty/src/test/java/io/grpc/netty/UdsNameResolverTest.java
new file mode 100644
index 00000000000..22790a41c77
--- /dev/null
+++ b/netty/src/test/java/io/grpc/netty/UdsNameResolverTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2015 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.netty;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.ChannelLogger;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GrpcUtil;
+import io.netty.channel.unix.DomainSocketAddress;
+import java.net.SocketAddress;
+import java.util.List;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for {@link UdsNameResolver}. */
+@RunWith(JUnit4.class)
+public class UdsNameResolverTest {
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  private static final int DEFAULT_PORT = 887;
+  private final FakeClock fakeExecutor = new FakeClock();
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      (t, e) -> {
+        throw new AssertionError(e);
+      });
+  private final NameResolver.Args args = NameResolver.Args.newBuilder()
+      .setDefaultPort(DEFAULT_PORT)
+      .setProxyDetector(GrpcUtil.DEFAULT_PROXY_DETECTOR)
+      .setSynchronizationContext(syncContext)
+      .setServiceConfigParser(mock(ServiceConfigParser.class))
+      .setChannelLogger(mock(ChannelLogger.class))
+      .setScheduledExecutorService(fakeExecutor.getScheduledExecutorService())
+      .build();
+  @Mock
+  private NameResolver.Listener2 mockListener;
+
+  @Captor
+  private ArgumentCaptor<NameResolver.ResolutionResult> resultCaptor;
+
+  private UdsNameResolver udsNameResolver;
+
+  @Test
+  public void testValidTargetPath() {
+    udsNameResolver = new UdsNameResolver(null, "sock.sock", args);
+    udsNameResolver.start(mockListener);
+    verify(mockListener).onResult2(resultCaptor.capture());
+    NameResolver.ResolutionResult result = resultCaptor.getValue();
+    List<EquivalentAddressGroup> list = result.getAddressesOrError().getValue();
+    assertThat(list).isNotNull();
+    assertThat(list).hasSize(1);
+    EquivalentAddressGroup eag = list.get(0);
+    assertThat(eag).isNotNull();
+    List<SocketAddress> addresses = eag.getAddresses();
+    assertThat(addresses).hasSize(1);
+    assertThat(addresses.get(0)).isInstanceOf(DomainSocketAddress.class);
+    DomainSocketAddress domainSocketAddress = (DomainSocketAddress) addresses.get(0);
+    assertThat(domainSocketAddress.path()).isEqualTo("sock.sock");
+    assertThat(udsNameResolver.getServiceAuthority()).isEqualTo("sock.sock");
+  }
+
+  @Test
+  public void testNonNullAuthority() {
+    try {
+      udsNameResolver = new UdsNameResolver("authority", "sock.sock", args);
+      fail("exception expected");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().isEqualTo("non-null authority not supported");
+    }
+  }
+}
diff --git a/netty/src/test/java/io/grpc/netty/UdsNettyChannelProviderTest.java b/netty/src/test/java/io/grpc/netty/UdsNettyChannelProviderTest.java
new file mode 100644
index 00000000000..e0c3d5a8525
--- /dev/null
+++ b/netty/src/test/java/io/grpc/netty/UdsNettyChannelProviderTest.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2015 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.netty;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InternalServiceProviders;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.ManagedChannelProvider;
+import io.grpc.ManagedChannelProvider.NewChannelBuilderResult;
+import io.grpc.ManagedChannelRegistryAccessor;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.epoll.EpollEventLoopGroup;
+import io.netty.channel.epoll.EpollServerDomainSocketChannel;
+import io.netty.channel.unix.DomainSocketAddress;
+import java.io.IOException;
+import org.junit.After;
+import org.junit.Assume;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link UdsNettyChannelProvider}. */
+@RunWith(JUnit4.class)
+public class UdsNettyChannelProviderTest {
+
+  @Rule public TemporaryFolder tempFolder = new TemporaryFolder();
+
+  @Rule
+  public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+
+
+  private UdsNettyChannelProvider provider = new UdsNettyChannelProvider();
+
+  private EventLoopGroup elg;
+  private EventLoopGroup boss;
+
+  @After
+  public void tearDown() {
+    if (elg != null) {
+      elg.shutdownGracefully();
+    }
+    if (boss != null) {
+      boss.shutdownGracefully();
+    }
+  }
+
+  @Test
+  public void provided() {
+    for (ManagedChannelProvider current
+        : InternalServiceProviders.getCandidatesViaServiceLoader(
+            ManagedChannelProvider.class, getClass().getClassLoader())) {
+      if (current instanceof UdsNettyChannelProvider) {
+        return;
+      }
+    }
+    fail("ServiceLoader unable to load UdsNettyChannelProvider");
+  }
+
+  @Test
+  public void providedHardCoded() {
+    for (Class<?> current : ManagedChannelRegistryAccessor.getHardCodedClasses()) {
+      if (current == UdsNettyChannelProvider.class) {
+        return;
+      }
+    }
+    fail("Hard coded unable to load UdsNettyChannelProvider");
+  }
+
+  @Test
+  public void basicMethods() {
+    Assume.assumeTrue(provider.isAvailable());
+    assertEquals(3, provider.priority());
+  }
+
+  @Test
+  public void newChannelBuilder_success() {
+    Assume.assumeTrue(Utils.isEpollAvailable());
+    NewChannelBuilderResult result =
+        provider.newChannelBuilder("unix:sock.sock", TlsChannelCredentials.create());
+    assertThat(result.getChannelBuilder()).isInstanceOf(NettyChannelBuilder.class);
+  }
+
+  @Test
+  public void managedChannelRegistry_newChannelBuilder() {
+    Assume.assumeTrue(Utils.isEpollAvailable());
+    ManagedChannelBuilder<?> managedChannelBuilder
+            = Grpc.newChannelBuilder("unix:///sock.sock", InsecureChannelCredentials.create());
+    assertThat(managedChannelBuilder).isNotNull();
+    ManagedChannel channel = managedChannelBuilder.build();
+    assertThat(channel).isNotNull();
+    assertThat(channel.authority()).isEqualTo("/sock.sock");
+    channel.shutdownNow();
+  }
+
+  @Test
+  public void udsClientServerTestUsingProvider() throws IOException {
+    Assume.assumeTrue(Utils.isEpollAvailable());
+    String socketPath = tempFolder.getRoot().getAbsolutePath() + "/test.socket";
+    createUdsServer(socketPath);
+    ManagedChannelBuilder<?> channelBuilder =
+        Grpc.newChannelBuilder("unix://" + socketPath, InsecureChannelCredentials.create());
+    SimpleServiceGrpc.SimpleServiceBlockingStub stub =
+        SimpleServiceGrpc.newBlockingStub(cleanupRule.register(channelBuilder.build()));
+    assertThat(unaryRpc("buddy", stub)).isEqualTo("Hello buddy");
+  }
+
+  /** Say hello to server. */
+  private static String unaryRpc(
+      String requestMessage, SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub) {
+    SimpleRequest request = SimpleRequest.newBuilder().setRequestMessage(requestMessage).build();
+    SimpleResponse response = blockingStub.unaryRpc(request);
+    return response.getResponseMessage();
+  }
+
+  private void createUdsServer(String name) throws IOException {
+    elg = new EpollEventLoopGroup();
+    boss = new EpollEventLoopGroup(1);
+    cleanupRule.register(
+        NettyServerBuilder.forAddress(new DomainSocketAddress(name))
+            .bossEventLoopGroup(boss)
+            .workerEventLoopGroup(elg)
+            .channelType(EpollServerDomainSocketChannel.class)
+            .addService(new SimpleServiceImpl())
+            .directExecutor()
+            .build()
+            .start());
+  }
+
+  private static class SimpleServiceImpl extends SimpleServiceGrpc.SimpleServiceImplBase {
+
+    @Override
+    public void unaryRpc(SimpleRequest req, StreamObserver<SimpleResponse> responseObserver) {
+      SimpleResponse response =
+          SimpleResponse.newBuilder()
+              .setResponseMessage("Hello " + req.getRequestMessage())
+              .build();
+      responseObserver.onNext(response);
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/netty/src/test/java/io/grpc/netty/UtilsTest.java b/netty/src/test/java/io/grpc/netty/UtilsTest.java
index ce442b4ca1b..95f57732117 100644
--- a/netty/src/test/java/io/grpc/netty/UtilsTest.java
+++ b/netty/src/test/java/io/grpc/netty/UtilsTest.java
@@ -1,43 +1,51 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.TruthJUnit.assume;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 
+import com.google.common.base.MoreObjects;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.SocketOptions;
+import io.grpc.Metadata;
 import io.grpc.Status;
+import io.grpc.internal.GrpcUtil;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFactory;
+import io.netty.channel.ChannelOption;
 import io.netty.channel.ConnectTimeoutException;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.ServerChannel;
+import io.netty.channel.WriteBufferWaterMark;
+import io.netty.channel.embedded.EmbeddedChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.handler.codec.http2.DefaultHttp2Headers;
 import io.netty.handler.codec.http2.Http2Error;
 import io.netty.handler.codec.http2.Http2Exception;
+import io.netty.handler.codec.http2.Http2Headers;
+import io.netty.util.AsciiString;
+import java.nio.channels.UnresolvedAddressException;
+import java.util.Map;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -45,6 +53,10 @@
 /** Unit tests for {@link Utils}. */
 @RunWith(JUnit4.class)
 public class UtilsTest {
+  private final Metadata.Key<String> userKey =
+      Metadata.Key.of("user-key", Metadata.ASCII_STRING_MARSHALLER);
+  private final String userValue =  "user-value";
+
   @Test
   public void testStatusFromThrowable() {
     Status s = Status.CANCELLED.withDescription("msg");
@@ -52,15 +64,181 @@ public void testStatusFromThrowable() {
     Throwable t;
     t = new ConnectTimeoutException("msg");
     assertStatusEquals(Status.UNAVAILABLE.withCause(t), Utils.statusFromThrowable(t));
+    t = new UnresolvedAddressException();
+    assertStatusEquals(Status.UNAVAILABLE.withCause(t), Utils.statusFromThrowable(t));
     t = new Http2Exception(Http2Error.INTERNAL_ERROR, "msg");
     assertStatusEquals(Status.INTERNAL.withCause(t), Utils.statusFromThrowable(t));
     t = new Exception("msg");
     assertStatusEquals(Status.UNKNOWN.withCause(t), Utils.statusFromThrowable(t));
   }
 
+  @Test
+  public void testGetBufferAllocator() {
+    ByteBufAllocator heapAllocator = Utils.getByteBufAllocator(true);
+    ByteBufAllocator directAllocator = Utils.getByteBufAllocator(false);
+    assertNotEquals(heapAllocator, directAllocator);
+
+    System.setProperty("io.netty.allocator.type", "unpooled");
+    ByteBufAllocator unpooled1 = Utils.getByteBufAllocator(false);
+    assertThat(unpooled1.getClass().getName()).isNotEqualTo("UnpooledByteBufAllocator");
+
+    System.setProperty("io.netty.allocator.type", "pooled");
+    ByteBufAllocator unpooled2 = Utils.getByteBufAllocator(false);
+    assertEquals(directAllocator, unpooled2);
+  }
+
+  @Test
+  public void convertClientHeaders_sanitizes() {
+    Metadata metaData = new Metadata();
+
+    // Intentionally being explicit here rather than relying on any pre-defined lists of headers,
+    // since the goal of this test is to validate the correctness of such lists in the first place.
+    metaData.put(GrpcUtil.CONTENT_TYPE_KEY, "to-be-removed");
+    metaData.put(GrpcUtil.USER_AGENT_KEY, "to-be-removed");
+    metaData.put(GrpcUtil.TE_HEADER, "to-be-removed");
+    metaData.put(userKey, userValue);
+
+    String scheme = "https";
+    String userAgent = "user-agent";
+    String method = "POST";
+    String authority = "authority";
+    String path = "//testService/test";
+
+    Http2Headers output =
+        Utils.convertClientHeaders(
+            metaData,
+            new AsciiString(scheme),
+            new AsciiString(path),
+            new AsciiString(authority),
+            new AsciiString(method),
+            new AsciiString(userAgent));
+    DefaultHttp2Headers headers = new DefaultHttp2Headers();
+    for (Map.Entry<CharSequence, CharSequence> entry : output) {
+      headers.add(entry.getKey(), entry.getValue());
+    }
+
+    // 7 reserved headers, 1 user header
+    assertEquals(7 + 1, headers.size());
+    // Check the 3 reserved headers that are non pseudo
+    // Users can not create pseudo headers keys so no need to check for them here
+    assertEquals(GrpcUtil.CONTENT_TYPE_GRPC,
+        headers.get(GrpcUtil.CONTENT_TYPE_KEY.name()).toString());
+    assertEquals(userAgent, headers.get(GrpcUtil.USER_AGENT_KEY.name()).toString());
+    assertEquals(GrpcUtil.TE_TRAILERS, headers.get(GrpcUtil.TE_HEADER.name()).toString());
+    // Check the user header is in tact
+    assertEquals(userValue, headers.get(userKey.name()).toString());
+  }
+
+  @Test
+  @SuppressWarnings("UndefinedEquals") // AsciiString.equals
+  public void convertServerHeaders_sanitizes() {
+    Metadata metaData = new Metadata();
+
+    // Intentionally being explicit here rather than relying on any pre-defined lists of headers,
+    // since the goal of this test is to validate the correctness of such lists in the first place.
+    metaData.put(GrpcUtil.CONTENT_TYPE_KEY, "to-be-removed");
+    metaData.put(GrpcUtil.TE_HEADER, "to-be-removed");
+    metaData.put(GrpcUtil.USER_AGENT_KEY, "to-be-removed");
+    metaData.put(userKey, userValue);
+
+    Http2Headers output = Utils.convertServerHeaders(metaData);
+    DefaultHttp2Headers headers = new DefaultHttp2Headers();
+    for (Map.Entry<CharSequence, CharSequence> entry : output) {
+      headers.add(entry.getKey(), entry.getValue());
+    }
+    // 2 reserved headers, 1 user header
+    assertEquals(2 + 1, headers.size());
+    assertEquals(Utils.CONTENT_TYPE_GRPC, headers.get(GrpcUtil.CONTENT_TYPE_KEY.name()));
+  }
+
+  @Test
+  public void channelOptionsTest_noLinger() {
+    Channel channel = new EmbeddedChannel();
+    assertNull(channel.config().getOption(ChannelOption.SO_LINGER));
+    InternalChannelz.SocketOptions socketOptions = Utils.getSocketOptions(channel);
+    assertNull(socketOptions.lingerSeconds);
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void channelOptionsTest_oio() {
+    Channel channel = new io.netty.channel.socket.oio.OioSocketChannel();
+    SocketOptions socketOptions = setAndValidateGeneric(channel);
+    assertEquals(250, (int) socketOptions.soTimeoutMillis);
+  }
+
+  @Test
+  public void channelOptionsTest_nio() {
+    Channel channel = new NioSocketChannel();
+    SocketOptions socketOptions = setAndValidateGeneric(channel);
+    assertNull(socketOptions.soTimeoutMillis);
+  }
+
+  private static InternalChannelz.SocketOptions setAndValidateGeneric(Channel channel) {
+    channel.config().setOption(ChannelOption.SO_LINGER, 3);
+    // only applicable for OIO channels:
+    channel.config().setOption(ChannelOption.SO_TIMEOUT, 250);
+    // Test some arbitrarily chosen options with a non numeric values
+    channel.config().setOption(ChannelOption.SO_KEEPALIVE, true);
+    WriteBufferWaterMark writeBufWaterMark = new WriteBufferWaterMark(10, 20);
+    channel.config().setOption(ChannelOption.WRITE_BUFFER_WATER_MARK, writeBufWaterMark);
+
+    InternalChannelz.SocketOptions socketOptions = Utils.getSocketOptions(channel);
+    assertEquals(3, (int) socketOptions.lingerSeconds);
+    assertEquals("true", socketOptions.others.get("SO_KEEPALIVE"));
+    assertEquals(
+        writeBufWaterMark.toString(),
+        socketOptions.others.get(ChannelOption.WRITE_BUFFER_WATER_MARK.toString()));
+    return socketOptions;
+  }
+
   private static void assertStatusEquals(Status expected, Status actual) {
     assertEquals(expected.getCode(), actual.getCode());
-    assertEquals(expected.getDescription(), actual.getDescription());
+    assertThat(MoreObjects.firstNonNull(actual.getDescription(), ""))
+        .contains(MoreObjects.firstNonNull(expected.getDescription(), ""));
     assertEquals(expected.getCause(), actual.getCause());
   }
+
+  @Test
+  public void defaultEventLoopGroup_whenEpollIsAvailable() {
+    assume().that(Utils.isEpollAvailable()).isTrue();
+
+    EventLoopGroup defaultBossGroup = Utils.DEFAULT_BOSS_EVENT_LOOP_GROUP.create();
+    EventLoopGroup defaultWorkerGroup = Utils.DEFAULT_WORKER_EVENT_LOOP_GROUP.create();
+
+    assertThat(defaultBossGroup.getClass().getName())
+        .isEqualTo("io.netty.channel.epoll.EpollEventLoopGroup");
+    assertThat(defaultWorkerGroup.getClass().getName())
+        .isEqualTo("io.netty.channel.epoll.EpollEventLoopGroup");
+
+    defaultBossGroup.shutdownGracefully();
+    defaultWorkerGroup.shutdownGracefully();
+  }
+
+  @Test
+  public void defaultClientChannelType_whenEpollIsAvailable() {
+    assume().that(Utils.isEpollAvailable()).isTrue();
+
+    Class<? extends Channel> clientChannelType = Utils.DEFAULT_CLIENT_CHANNEL_TYPE;
+
+    assertThat(clientChannelType.getName())
+        .isEqualTo("io.netty.channel.epoll.EpollSocketChannel");
+  }
+
+  @Test
+  public void defaultServerChannelFactory_whenEpollIsAvailable() {
+    assume().that(Utils.isEpollAvailable()).isTrue();
+
+    ChannelFactory<? extends ServerChannel> channelFactory = Utils.DEFAULT_SERVER_CHANNEL_FACTORY;
+
+    assertThat(channelFactory.toString())
+        .isEqualTo("ReflectiveChannelFactory(EpollServerSocketChannel.class)");
+  }
+
+  @Test
+  public void maybeGetTcpUserTimeoutOption() {
+    assume().that(Utils.isEpollAvailable()).isTrue();
+
+    assertThat(Utils.maybeGetTcpUserTimeoutOption()).isNotNull();
+  }
 }
diff --git a/netty/src/test/java/io/grpc/netty/WriteBufferingAndExceptionHandlerTest.java b/netty/src/test/java/io/grpc/netty/WriteBufferingAndExceptionHandlerTest.java
new file mode 100644
index 00000000000..b99a9386fcf
--- /dev/null
+++ b/netty/src/test/java/io/grpc/netty/WriteBufferingAndExceptionHandlerTest.java
@@ -0,0 +1,384 @@
+/*
+ * Copyright 2019 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.netty;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.netty.bootstrap.Bootstrap;
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelHandlerAdapter;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelOutboundHandlerAdapter;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.DefaultEventLoop;
+import io.netty.channel.EventLoop;
+import io.netty.channel.local.LocalAddress;
+import io.netty.channel.local.LocalChannel;
+import io.netty.channel.local.LocalServerChannel;
+import java.net.ConnectException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.After;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.DisableOnDebug;
+import org.junit.rules.TestRule;
+import org.junit.rules.Timeout;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link WriteBufferingAndExceptionHandler}.
+ */
+@RunWith(JUnit4.class)
+public class WriteBufferingAndExceptionHandlerTest {
+
+  private static final long TIMEOUT_SECONDS = 10;
+
+  @Rule
+  public final TestRule timeout = new DisableOnDebug(Timeout.seconds(TIMEOUT_SECONDS));
+
+  private final EventLoop group = new DefaultEventLoop();
+  private Channel chan;
+  private Channel server;
+
+  @After
+  public void tearDown() throws InterruptedException {
+    if (server != null) {
+      server.close().sync();
+    }
+    if (chan != null) {
+      chan.close().sync();
+    }
+    group.shutdownGracefully(0, 10, TimeUnit.SECONDS).sync();
+  }
+
+  @Test
+  public void connectionFailuresPropagated() throws Exception {
+    WriteBufferingAndExceptionHandler handler =
+        new WriteBufferingAndExceptionHandler(new ChannelHandlerAdapter() {});
+    ChannelFuture cf = new Bootstrap()
+        .channel(LocalChannel.class)
+        .handler(handler)
+        .group(group)
+        .register();
+    chan = cf.channel();
+    cf.sync();
+    // Write before connect.  In the event connect fails, the pipeline is torn down and the handler
+    // won't be able to fail the writes with the correct exception.
+    ChannelFuture wf = chan.writeAndFlush(new Object());
+    chan.connect(new LocalAddress("bogus"));
+
+    try {
+      wf.sync();
+      fail();
+    } catch (Exception e) {
+      assertThat(e).isInstanceOf(ConnectException.class);
+      assertThat(e).hasMessageThat().contains("connection refused");
+    }
+  }
+
+  @Test
+  public void channelInactiveFailuresPropagated() throws Exception {
+    WriteBufferingAndExceptionHandler handler =
+        new WriteBufferingAndExceptionHandler(new ChannelHandlerAdapter() {});
+    LocalAddress addr = new LocalAddress("local");
+    ChannelFuture cf = new Bootstrap()
+        .channel(LocalChannel.class)
+        .handler(handler)
+        .group(group)
+        .register();
+    chan = cf.channel();
+    cf.sync();
+    ChannelFuture sf = new ServerBootstrap()
+        .channel(LocalServerChannel.class)
+        .childHandler(new ChannelHandlerAdapter() {})
+        .group(group)
+        .bind(addr);
+    server = sf.channel();
+    sf.sync();
+
+    ChannelFuture wf = chan.writeAndFlush(new Object());
+    chan.connect(addr);
+    chan.pipeline().fireChannelInactive();
+
+    try {
+      wf.sync();
+      fail();
+    } catch (Exception e) {
+      Status status = Status.fromThrowable(e);
+      assertThat(status.getCode()).isEqualTo(Code.UNAVAILABLE);
+      assertThat(status.getDescription())
+          .contains("Connection closed while performing protocol negotiation");
+    }
+  }
+
+  @Test
+  public void channelCloseFailuresPropagated() throws Exception {
+    WriteBufferingAndExceptionHandler handler =
+        new WriteBufferingAndExceptionHandler(new ChannelHandlerAdapter() {});
+    LocalAddress addr = new LocalAddress("local");
+    ChannelFuture cf = new Bootstrap()
+        .channel(LocalChannel.class)
+        .handler(handler)
+        .group(group)
+        .register();
+    chan = cf.channel();
+    cf.sync();
+    ChannelFuture sf = new ServerBootstrap()
+        .channel(LocalServerChannel.class)
+        .childHandler(new ChannelHandlerAdapter() {})
+        .group(group)
+        .bind(addr);
+    server = sf.channel();
+    sf.sync();
+
+    ChannelFuture wf = chan.writeAndFlush(new Object());
+    chan.connect(addr);
+    chan.close();
+
+    try {
+      wf.sync();
+      fail();
+    } catch (Exception e) {
+      Status status = Status.fromThrowable(e);
+      assertThat(status.getCode()).isEqualTo(Code.UNAVAILABLE);
+      assertThat(status.getDescription())
+          .contains("Connection closing while performing protocol negotiation");
+    }
+  }
+
+  @Test
+  public void uncaughtExceptionFailuresPropagated() throws Exception {
+    WriteBufferingAndExceptionHandler handler =
+        new WriteBufferingAndExceptionHandler(new ChannelHandlerAdapter() {});
+    LocalAddress addr = new LocalAddress("local");
+    ChannelFuture cf = new Bootstrap()
+        .channel(LocalChannel.class)
+        .handler(handler)
+        .group(group)
+        .register();
+    chan = cf.channel();
+    cf.sync();
+    ChannelFuture sf = new ServerBootstrap()
+        .channel(LocalServerChannel.class)
+        .childHandler(new ChannelHandlerAdapter() {})
+        .group(group)
+        .bind(addr);
+    server = sf.channel();
+    sf.sync();
+
+    ChannelFuture wf = chan.writeAndFlush(new Object());
+    chan.connect(addr);
+    chan.pipeline().fireExceptionCaught(Status.ABORTED.withDescription("zap").asRuntimeException());
+
+    try {
+      wf.sync();
+      fail();
+    } catch (Exception e) {
+      Status status = Status.fromThrowable(e);
+      assertThat(status.getCode()).isEqualTo(Code.ABORTED);
+      assertThat(status.getDescription()).contains("zap");
+    }
+  }
+
+  @Test
+  public void uncaughtException_closeAtMostOnce() throws Exception {
+    final AtomicInteger closes = new AtomicInteger();
+    WriteBufferingAndExceptionHandler handler =
+        new WriteBufferingAndExceptionHandler(new ChannelDuplexHandler() {
+          @Override
+          public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
+            closes.getAndIncrement();
+            // Simulates a loop between this handler and the WriteBufferingAndExceptionHandler.
+            ctx.fireExceptionCaught(Status.ABORTED.withDescription("zap").asRuntimeException());
+            super.close(ctx, promise);
+          }
+        });
+    LocalAddress addr = new LocalAddress("local");
+    ChannelFuture cf = new Bootstrap()
+        .channel(LocalChannel.class)
+        .handler(handler)
+        .group(group)
+        .register();
+    chan = cf.channel();
+    cf.sync();
+    ChannelFuture sf = new ServerBootstrap()
+        .channel(LocalServerChannel.class)
+        .childHandler(new ChannelHandlerAdapter() {})
+        .group(group)
+        .bind(addr);
+    server = sf.channel();
+    sf.sync();
+
+    chan.connect(addr).sync();
+    chan.close().sync();
+    assertEquals(1, closes.get());
+  }
+
+  @Test
+  public void handlerRemovedFailuresPropagated() throws Exception {
+    WriteBufferingAndExceptionHandler handler =
+        new WriteBufferingAndExceptionHandler(new ChannelHandlerAdapter() {
+          @Override
+          public void handlerRemoved(ChannelHandlerContext ctx) {
+            ctx.pipeline().remove(
+                ctx.pipeline().context(WriteBufferingAndExceptionHandler.class).name());
+          }
+        });
+    LocalAddress addr = new LocalAddress("local");
+    ChannelFuture cf = new Bootstrap()
+        .channel(LocalChannel.class)
+        .handler(handler)
+        .group(group)
+        .register();
+    chan = cf.channel();
+    cf.sync();
+    ChannelFuture sf = new ServerBootstrap()
+        .channel(LocalServerChannel.class)
+        .childHandler(new ChannelHandlerAdapter() {})
+        .group(group)
+        .bind(addr);
+    server = sf.channel();
+    sf.sync();
+
+    chan.connect(addr);
+    ChannelFuture wf = chan.writeAndFlush(new Object());
+    chan.pipeline().removeFirst();
+
+    try {
+      wf.sync();
+      fail();
+    } catch (Exception e) {
+      Status status = Status.fromThrowable(e);
+      assertThat(status.getCode()).isEqualTo(Code.INTERNAL);
+      assertThat(status.getDescription()).contains("Buffer removed");
+    }
+  }
+
+  @Test
+  public void writesBuffered() throws Exception {
+    final AtomicBoolean handlerAdded = new AtomicBoolean();
+    final AtomicBoolean flush = new AtomicBoolean();
+    final AtomicReference<Object> write = new AtomicReference<>();
+    final WriteBufferingAndExceptionHandler handler =
+        new WriteBufferingAndExceptionHandler(new ChannelOutboundHandlerAdapter() {
+          @Override
+          public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+            assertFalse(handlerAdded.getAndSet(true));
+            super.handlerAdded(ctx);
+          }
+
+          @Override
+          public void flush(ChannelHandlerContext ctx) throws Exception {
+            assertFalse(flush.getAndSet(true));
+            super.flush(ctx);
+          }
+
+          @Override
+          public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {
+            assertNull(write.getAndSet(msg));
+            promise.setSuccess();
+          }
+        });
+    LocalAddress addr = new LocalAddress("local");
+    ChannelFuture cf = new Bootstrap()
+        .channel(LocalChannel.class)
+        .handler(handler)
+        .group(group)
+        .register();
+    chan = cf.channel();
+    cf.sync();
+    ChannelFuture sf = new ServerBootstrap()
+        .channel(LocalServerChannel.class)
+        .childHandler(new ChannelHandlerAdapter() {})
+        .group(group)
+        .bind(addr);
+    server = sf.channel();
+    sf.sync();
+
+    assertTrue(handlerAdded.get());
+
+    chan.write(new Object());
+    chan.connect(addr).sync();
+    assertNull(write.get());
+
+    chan.flush();
+    assertNull(write.get());
+    assertFalse(flush.get());
+
+    assertThat(chan.pipeline().context(handler)).isNotNull();
+    chan.eventLoop().submit(new Runnable() {
+      @Override
+      public void run() {
+        handler.writeBufferedAndRemove(chan.pipeline().context(handler));
+      }
+    }).sync();
+
+    assertThat(chan.pipeline().context(handler)).isNull();
+    assertThat(write.get().getClass()).isSameInstanceAs(Object.class);
+    assertTrue(flush.get());
+    assertThat(chan.pipeline().toMap().values()).doesNotContain(handler);
+  }
+
+  @Test
+  public void uncaughtReadFails() throws Exception {
+    WriteBufferingAndExceptionHandler handler =
+        new WriteBufferingAndExceptionHandler(new ChannelHandlerAdapter() {});
+    LocalAddress addr = new LocalAddress("local");
+    ChannelFuture cf = new Bootstrap()
+        .channel(LocalChannel.class)
+        .handler(handler)
+        .group(group)
+        .register();
+    chan = cf.channel();
+    cf.sync();
+    ChannelFuture sf = new ServerBootstrap()
+        .channel(LocalServerChannel.class)
+        .childHandler(new ChannelHandlerAdapter() {})
+        .group(group)
+        .bind(addr);
+    server = sf.channel();
+    sf.sync();
+
+    ChannelFuture wf = chan.writeAndFlush(new Object());
+    chan.connect(addr);
+    chan.pipeline().fireChannelRead(Unpooled.copiedBuffer(new byte[] {'a'}));
+
+    try {
+      wf.sync();
+      fail();
+    } catch (Exception e) {
+      Status status = Status.fromThrowable(e);
+      assertThat(status.getCode()).isEqualTo(Code.INTERNAL);
+      assertThat(status.getDescription()).contains("channelRead() missed");
+    }
+  }
+}
diff --git a/netty/src/test/java/io/grpc/netty/WriteQueueTest.java b/netty/src/test/java/io/grpc/netty/WriteQueueTest.java
index 6c2ab2c3d84..a83822fd70a 100644
--- a/netty/src/test/java/io/grpc/netty/WriteQueueTest.java
+++ b/netty/src/test/java/io/grpc/netty/WriteQueueTest.java
@@ -1,40 +1,25 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.netty;
 
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.isA;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -48,18 +33,26 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicBoolean;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.Timeout;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
 import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.mockito.stubbing.Answer;
 
 @RunWith(JUnit4.class)
 public class WriteQueueTest {
 
+  @Rule
+  public final Timeout globalTimeout = Timeout.seconds(60);
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
   private final Object lock = new Object();
 
   @Mock
@@ -76,7 +69,6 @@ public class WriteQueueTest {
    */
   @Before
   public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
     when(channel.newPromise()).thenReturn(promise);
 
     EventLoop eventLoop = Mockito.mock(EventLoop.class);
@@ -153,7 +145,7 @@ public void maxWritesBeforeFlushShouldBeEnforced() {
     verify(channel, times(2)).flush();
   }
 
-  @Test(timeout = 10000)
+  @Test
   public void concurrentWriteAndFlush() throws Throwable {
     final WriteQueue queue = new WriteQueue(channel);
     final CountDownLatch flusherStarted = new CountDownLatch(1);
diff --git a/okhttp/BUILD.bazel b/okhttp/BUILD.bazel
new file mode 100644
index 00000000000..74a9f7a4300
--- /dev/null
+++ b/okhttp/BUILD.bazel
@@ -0,0 +1,25 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "okhttp",
+    srcs = glob([
+        "third_party/okhttp/main/java/**/*.java",
+        "src/main/java/**/*.java",
+    ]),
+    resources = glob([
+        "src/main/resources/**",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api",
+        "//core:internal",
+        "//util",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+        artifact("com.squareup.okhttp:okhttp"),
+        artifact("com.squareup.okio:okio"),
+        artifact("io.perfmark:perfmark-api"),
+    ],
+)
diff --git a/okhttp/build.gradle b/okhttp/build.gradle
index bdff55aec62..6c542feec9c 100644
--- a/okhttp/build.gradle
+++ b/okhttp/build.gradle
@@ -1,25 +1,70 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "me.champeau.gradle.japicmp"
+    id "ru.vyarus.animalsniffer"
+}
+
 description = "gRPC: OkHttp"
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.okhttp')
+    }
+}
+
 dependencies {
-    compile project(':grpc-core'),
-            libraries.okhttp,
-            libraries.okio
+    api project(':grpc-api')
+    implementation project(':grpc-util'),
+            project(':grpc-core'),
+            libraries.okio,
+            libraries.guava,
+            libraries.perfmark.api
+    // Make okhttp dependencies compile only
+    compileOnly libraries.okhttp
 
     // Tests depend on base class defined by core module.
-    testCompile project(':grpc-core').sourceSets.test.output,
-                project(':grpc-testing'),
-                project(':grpc-netty')
-    signature "org.codehaus.mojo.signature:java16:+@signature"
+    testImplementation testFixtures(project(':grpc-core')),
+            testFixtures(project(':grpc-api')),
+            project(':grpc-testing'),
+            project(':grpc-testing-proto'),
+            libraries.netty.codec.http2,
+            libraries.okhttp
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
 project.sourceSets {
-    main {
-        java {
-            srcDir "${projectDir}/third_party/okhttp/java"
-        }
-    }
+    main { java { srcDir "${projectDir}/third_party/okhttp/main/java" } }
+    test { java { srcDir "${projectDir}/third_party/okhttp/test/java" } }
 }
 
-checkstyleMain.exclude '**/io/grpc/okhttp/internal/**'
+tasks.named("checkstyleMain").configure {
+    exclude '**/io/grpc/okhttp/internal/**'
+}
 
-javadoc.exclude 'io/grpc/okhttp/internal/**'
-javadoc.options.links 'http://square.github.io/okhttp/2.x/okhttp/'
+tasks.named("javadoc").configure {
+    options.linksOffline 'https://square.github.io/okhttp/2.x/okhttp/',
+        "${rootProject.projectDir}/gradle/javadoc/square.github.io-okhttp-2.x-okhttp/"
+    exclude 'io/grpc/okhttp/Internal*'
+    exclude 'io/grpc/okhttp/*Provider.java'
+    exclude 'io/grpc/okhttp/internal/**'
+}
+
+tasks.named("jacocoTestReport").configure {
+    classDirectories.from = sourceSets.main.output.collect {
+        fileTree(dir: it,
+        exclude: [
+                '**/io/grpc/okhttp/internal/**',
+        ])
+    }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/AsyncFrameWriter.java b/okhttp/src/main/java/io/grpc/okhttp/AsyncFrameWriter.java
deleted file mode 100644
index 0995a9226b9..00000000000
--- a/okhttp/src/main/java/io/grpc/okhttp/AsyncFrameWriter.java
+++ /dev/null
@@ -1,251 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.okhttp;
-
-import com.google.common.base.Preconditions;
-import io.grpc.internal.SerializingExecutor;
-import io.grpc.okhttp.internal.framed.ErrorCode;
-import io.grpc.okhttp.internal.framed.FrameWriter;
-import io.grpc.okhttp.internal.framed.Header;
-import io.grpc.okhttp.internal.framed.Settings;
-import java.io.IOException;
-import java.net.Socket;
-import java.util.List;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import okio.Buffer;
-
-class AsyncFrameWriter implements FrameWriter {
-  private static final Logger log = Logger.getLogger(OkHttpClientTransport.class.getName());
-  private FrameWriter frameWriter;
-  private Socket socket;
-  // Although writes are thread-safe, we serialize them to prevent consuming many Threads that are
-  // just waiting on each other.
-  private final SerializingExecutor executor;
-  private final OkHttpClientTransport transport;
-
-  public AsyncFrameWriter(OkHttpClientTransport transport, SerializingExecutor executor) {
-    this.transport = transport;
-    this.executor = executor;
-  }
-
-  /**
-   * Set the real frameWriter and the corresponding underlying socket, the socket is needed for
-   * closing.
-   *
-   * <p>should only be called by thread of executor.
-   */
-  void becomeConnected(FrameWriter frameWriter, Socket socket) {
-    Preconditions.checkState(this.frameWriter == null,
-        "AsyncFrameWriter's setFrameWriter() should only be called once.");
-    this.frameWriter = Preconditions.checkNotNull(frameWriter, "frameWriter");
-    this.socket = Preconditions.checkNotNull(socket, "socket");
-  }
-
-  @Override
-  public void connectionPreface() {
-    executor.execute(new WriteRunnable() {
-      @Override
-      public void doRun() throws IOException {
-        frameWriter.connectionPreface();
-      }
-    });
-  }
-
-  @Override
-  public void ackSettings(final Settings peerSettings) {
-    executor.execute(new WriteRunnable() {
-      @Override
-      public void doRun() throws IOException {
-        frameWriter.ackSettings(peerSettings);
-      }
-    });
-  }
-
-  @Override
-  public void pushPromise(final int streamId, final int promisedStreamId,
-      final List<Header> requestHeaders) {
-    executor.execute(new WriteRunnable() {
-      @Override
-      public void doRun() throws IOException {
-        frameWriter.pushPromise(streamId, promisedStreamId, requestHeaders);
-      }
-    });
-  }
-
-  @Override
-  public void flush() {
-    executor.execute(new WriteRunnable() {
-      @Override
-      public void doRun() throws IOException {
-        frameWriter.flush();
-      }
-    });
-  }
-
-  @Override
-  public void synStream(final boolean outFinished, final boolean inFinished, final int streamId,
-      final int associatedStreamId, final List<Header> headerBlock) {
-    executor.execute(new WriteRunnable() {
-      @Override
-      public void doRun() throws IOException {
-        frameWriter.synStream(outFinished, inFinished, streamId, associatedStreamId, headerBlock);
-      }
-    });
-  }
-
-  @Override
-  public void synReply(final boolean outFinished, final int streamId,
-      final List<Header> headerBlock) {
-    executor.execute(new WriteRunnable() {
-      @Override
-      public void doRun() throws IOException {
-        frameWriter.synReply(outFinished, streamId, headerBlock);
-      }
-    });
-  }
-
-  @Override
-  public void headers(final int streamId, final List<Header> headerBlock) {
-    executor.execute(new WriteRunnable() {
-      @Override
-      public void doRun() throws IOException {
-        frameWriter.headers(streamId, headerBlock);
-      }
-    });
-  }
-
-  @Override
-  public void rstStream(final int streamId, final ErrorCode errorCode) {
-    executor.execute(new WriteRunnable() {
-      @Override
-      public void doRun() throws IOException {
-        frameWriter.rstStream(streamId, errorCode);
-      }
-    });
-  }
-
-  @Override
-  public void data(final boolean outFinished, final int streamId, final Buffer source,
-      final int byteCount) {
-    executor.execute(new WriteRunnable() {
-      @Override
-      public void doRun() throws IOException {
-        frameWriter.data(outFinished, streamId, source, byteCount);
-      }
-    });
-  }
-
-  @Override
-  public void settings(final Settings okHttpSettings) {
-    executor.execute(new WriteRunnable() {
-      @Override
-      public void doRun() throws IOException {
-        frameWriter.settings(okHttpSettings);
-      }
-    });
-  }
-
-  @Override
-  public void ping(final boolean ack, final int payload1, final int payload2) {
-    executor.execute(new WriteRunnable() {
-      @Override
-      public void doRun() throws IOException {
-        frameWriter.ping(ack, payload1, payload2);
-      }
-    });
-  }
-
-  @Override
-  public void goAway(final int lastGoodStreamId, final ErrorCode errorCode,
-      final byte[] debugData) {
-    executor.execute(new WriteRunnable() {
-      @Override
-      public void doRun() throws IOException {
-        frameWriter.goAway(lastGoodStreamId, errorCode, debugData);
-        // Flush it since after goAway, we are likely to close this writer.
-        frameWriter.flush();
-      }
-    });
-  }
-
-  @Override
-  public void windowUpdate(final int streamId, final long windowSizeIncrement) {
-    executor.execute(new WriteRunnable() {
-      @Override
-      public void doRun() throws IOException {
-        frameWriter.windowUpdate(streamId, windowSizeIncrement);
-      }
-    });
-  }
-
-  @Override
-  public void close() {
-    executor.execute(new Runnable() {
-      @Override
-      public void run() {
-        if (frameWriter != null) {
-          try {
-            frameWriter.close();
-            socket.close();
-          } catch (IOException e) {
-            log.log(Level.WARNING, "Failed closing connection", e);
-          }
-        }
-      }
-    });
-  }
-
-  private abstract class WriteRunnable implements Runnable {
-    @Override
-    public final void run() {
-      try {
-        if (frameWriter == null) {
-          throw new IOException("Unable to perform write due to unavailable frameWriter.");
-        }
-        doRun();
-      } catch (RuntimeException e) {
-        transport.onException(e);
-      } catch (Exception e) {
-        transport.onException(e);
-      }
-    }
-
-    public abstract void doRun() throws IOException;
-  }
-
-  @Override
-  public int maxDataLength() {
-    return frameWriter == null ? 0x4000 /* 16384, the minimum required by the HTTP/2 spec */
-        : frameWriter.maxDataLength();
-  }
-}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/AsyncSink.java b/okhttp/src/main/java/io/grpc/okhttp/AsyncSink.java
new file mode 100644
index 00000000000..01ee23b905c
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/AsyncSink.java
@@ -0,0 +1,266 @@
+/*
+ * Copyright 2018 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.okhttp;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.internal.SerializingExecutor;
+import io.grpc.okhttp.ExceptionHandlingFrameWriter.TransportExceptionHandler;
+import io.grpc.okhttp.internal.framed.ErrorCode;
+import io.grpc.okhttp.internal.framed.FrameWriter;
+import io.grpc.okhttp.internal.framed.Settings;
+import io.perfmark.Link;
+import io.perfmark.PerfMark;
+import io.perfmark.TaskCloseable;
+import java.io.IOException;
+import java.net.Socket;
+import javax.annotation.Nullable;
+import okio.Buffer;
+import okio.Sink;
+import okio.Timeout;
+
+/**
+ * A sink that asynchronously write / flushes a buffer internally. AsyncSink provides flush
+ * coalescing to minimize network packing transmit. Because I/O is handled asynchronously, most I/O
+ * exceptions will be delivered via a callback.
+ */
+final class AsyncSink implements Sink {
+
+  private final Object lock = new Object();
+  private final Buffer buffer = new Buffer();
+  private final SerializingExecutor serializingExecutor;
+  private final TransportExceptionHandler transportExceptionHandler;
+  private final int maxQueuedControlFrames;
+
+  @GuardedBy("lock")
+  private boolean writeEnqueued = false;
+  @GuardedBy("lock")
+  private boolean flushEnqueued = false;
+  private boolean closed = false;
+  @Nullable
+  private Sink sink;
+  @Nullable
+  private Socket socket;
+  private boolean controlFramesExceeded;
+  private int controlFramesInWrite;
+  @GuardedBy("lock")
+  private int queuedControlFrames;
+
+  private AsyncSink(SerializingExecutor executor, TransportExceptionHandler exceptionHandler,
+      int maxQueuedControlFrames) {
+    this.serializingExecutor = checkNotNull(executor, "executor");
+    this.transportExceptionHandler = checkNotNull(exceptionHandler, "exceptionHandler");
+    this.maxQueuedControlFrames = maxQueuedControlFrames;
+  }
+
+  /**
+   * {@code maxQueuedControlFrames} is only effective for frames written with
+   * {@link #limitControlFramesWriter(FrameWriter)}.
+   */
+  static AsyncSink sink(
+      SerializingExecutor executor, TransportExceptionHandler exceptionHandler,
+      int maxQueuedControlFrames) {
+    return new AsyncSink(executor, exceptionHandler, maxQueuedControlFrames);
+  }
+
+  /**
+   * Sets the actual sink. It is allowed to call write / flush operations on the sink iff calling
+   * this method is scheduled in the executor. The socket is needed for closing.
+   *
+   * <p>should only be called once by thread of executor.
+   */
+  void becomeConnected(Sink sink, Socket socket) {
+    checkState(this.sink == null, "AsyncSink's becomeConnected should only be called once.");
+    this.sink = checkNotNull(sink, "sink");
+    this.socket = checkNotNull(socket, "socket");
+  }
+
+  FrameWriter limitControlFramesWriter(FrameWriter delegate) {
+    return new LimitControlFramesWriter(delegate);
+  }
+
+  @Override
+  public void write(Buffer source, long byteCount) throws IOException {
+    checkNotNull(source, "source");
+    if (closed) {
+      throw new IOException("closed");
+    }
+    try (TaskCloseable ignore = PerfMark.traceTask("AsyncSink.write")) {
+      boolean closeSocket = false;
+      synchronized (lock) {
+        buffer.write(source, byteCount);
+
+        queuedControlFrames += controlFramesInWrite;
+        controlFramesInWrite = 0;
+        if (!controlFramesExceeded && queuedControlFrames > maxQueuedControlFrames) {
+          controlFramesExceeded = true;
+          closeSocket = true;
+        } else {
+          if (writeEnqueued || flushEnqueued || buffer.completeSegmentByteCount() <= 0) {
+            return;
+          }
+          writeEnqueued = true;
+        }
+      }
+      if (closeSocket) {
+        try {
+          socket.close();
+        } catch (IOException e) {
+          transportExceptionHandler.onException(e);
+        }
+        return;
+      }
+      serializingExecutor.execute(new WriteRunnable() {
+        final Link link = PerfMark.linkOut();
+        @Override
+        public void doRun() throws IOException {
+          Buffer buf = new Buffer();
+          try (TaskCloseable ignore = PerfMark.traceTask("WriteRunnable.runWrite")) {
+            PerfMark.linkIn(link);
+            int writingControlFrames;
+            synchronized (lock) {
+              buf.write(buffer, buffer.completeSegmentByteCount());
+              writeEnqueued = false;
+              // Imprecise because we only tranfer complete segments, but not by much and error
+              // won't accumulate over time
+              writingControlFrames = queuedControlFrames;
+            }
+            sink.write(buf, buf.size());
+            synchronized (lock) {
+              queuedControlFrames -= writingControlFrames;
+            }
+          }
+        }
+      });
+    }
+  }
+
+  @Override
+  public void flush() throws IOException {
+    if (closed) {
+      throw new IOException("closed");
+    }
+    try (TaskCloseable ignore = PerfMark.traceTask("AsyncSink.flush")) {
+      synchronized (lock) {
+        if (flushEnqueued) {
+          return;
+        }
+        flushEnqueued = true;
+      }
+      serializingExecutor.execute(new WriteRunnable() {
+        final Link link = PerfMark.linkOut();
+        @Override
+        public void doRun() throws IOException {
+          Buffer buf = new Buffer();
+          try (TaskCloseable ignore = PerfMark.traceTask("WriteRunnable.runFlush")) {
+            PerfMark.linkIn(link);
+            synchronized (lock) {
+              buf.write(buffer, buffer.size());
+              flushEnqueued = false;
+            }
+            sink.write(buf, buf.size());
+            sink.flush();
+          }
+        }
+      });
+    }
+  }
+
+  @Override
+  public Timeout timeout() {
+    return Timeout.NONE;
+  }
+
+  @Override
+  public void close() {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    serializingExecutor.execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          if (sink != null && buffer.size() > 0) {
+            sink.write(buffer, buffer.size());
+          }
+        } catch (IOException e) {
+          transportExceptionHandler.onException(e);
+        }
+        buffer.close();
+        try {
+          if (sink != null) {
+            sink.close();
+          }
+        } catch (IOException e) {
+          transportExceptionHandler.onException(e);
+        }
+        try {
+          if (socket != null) {
+            socket.close();
+          }
+        } catch (IOException e) {
+          transportExceptionHandler.onException(e);
+        }
+      }
+    });
+  }
+
+  private abstract class WriteRunnable implements Runnable {
+    @Override
+    public final void run() {
+      try {
+        if (sink == null) {
+          throw new IOException("Unable to perform write due to unavailable sink.");
+        }
+        doRun();
+      } catch (Exception e) {
+        transportExceptionHandler.onException(e);
+      }
+    }
+
+    public abstract void doRun() throws IOException;
+  }
+
+  private class LimitControlFramesWriter extends ForwardingFrameWriter {
+    public LimitControlFramesWriter(FrameWriter delegate) {
+      super(delegate);
+    }
+
+    @Override
+    public void ackSettings(Settings peerSettings) throws IOException {
+      controlFramesInWrite++;
+      super.ackSettings(peerSettings);
+    }
+
+    @Override
+    public void rstStream(int streamId, ErrorCode errorCode) throws IOException {
+      controlFramesInWrite++;
+      super.rstStream(streamId, errorCode);
+    }
+
+    @Override
+    public void ping(boolean ack, int payload1, int payload2) throws IOException {
+      if (ack) {
+        controlFramesInWrite++;
+      }
+      super.ping(ack, payload1, payload2);
+    }
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/ExceptionHandlingFrameWriter.java b/okhttp/src/main/java/io/grpc/okhttp/ExceptionHandlingFrameWriter.java
new file mode 100644
index 00000000000..2e21b1547d8
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/ExceptionHandlingFrameWriter.java
@@ -0,0 +1,234 @@
+/*
+ * Copyright 2018 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.okhttp;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import io.grpc.okhttp.internal.framed.ErrorCode;
+import io.grpc.okhttp.internal.framed.FrameWriter;
+import io.grpc.okhttp.internal.framed.Header;
+import io.grpc.okhttp.internal.framed.Settings;
+import java.io.IOException;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import okio.Buffer;
+import okio.ByteString;
+
+/**
+ * FrameWriter that propagates IOExceptions via callback instead of throwing. This allows
+ * centralized handling of errors. Exceptions only impact the single call that throws them; callers
+ * should be sure to kill the connection after an exception (potentially after sending a GOAWAY) as
+ * otherwise additional frames after the failed/omitted one could cause HTTP/2 confusion.
+ */
+final class ExceptionHandlingFrameWriter implements FrameWriter {
+
+  private static final Logger log = Logger.getLogger(OkHttpClientTransport.class.getName());
+
+  private final TransportExceptionHandler transportExceptionHandler;
+
+  private final FrameWriter frameWriter;
+
+  private final OkHttpFrameLogger frameLogger =
+      new OkHttpFrameLogger(Level.FINE, OkHttpClientTransport.class);
+
+  ExceptionHandlingFrameWriter(
+      TransportExceptionHandler transportExceptionHandler, FrameWriter frameWriter) {
+    this.transportExceptionHandler =
+        checkNotNull(transportExceptionHandler, "transportExceptionHandler");
+    this.frameWriter = Preconditions.checkNotNull(frameWriter, "frameWriter");
+  }
+
+  @Override
+  public void connectionPreface() {
+    try {
+      frameWriter.connectionPreface();
+    } catch (IOException e) {
+      transportExceptionHandler.onException(e);
+    }
+  }
+
+  @Override
+  public void ackSettings(Settings peerSettings) {
+    frameLogger.logSettingsAck(OkHttpFrameLogger.Direction.OUTBOUND);
+    try {
+      frameWriter.ackSettings(peerSettings);
+    } catch (IOException e) {
+      transportExceptionHandler.onException(e);
+    }
+  }
+
+  @Override
+  public void pushPromise(int streamId, int promisedStreamId, List<Header> requestHeaders) {
+    frameLogger.logPushPromise(OkHttpFrameLogger.Direction.OUTBOUND,
+        streamId, promisedStreamId, requestHeaders);
+    try {
+      frameWriter.pushPromise(streamId, promisedStreamId, requestHeaders);
+    } catch (IOException e) {
+      transportExceptionHandler.onException(e);
+    }
+  }
+
+  @Override
+  public void flush() {
+    try {
+      frameWriter.flush();
+    } catch (IOException e) {
+      transportExceptionHandler.onException(e);
+    }
+  }
+
+  @Override
+  public void synStream(
+      boolean outFinished,
+      boolean inFinished,
+      int streamId,
+      int associatedStreamId,
+      List<Header> headerBlock) {
+    try {
+      frameWriter.synStream(outFinished, inFinished, streamId, associatedStreamId, headerBlock);
+    } catch (IOException e) {
+      transportExceptionHandler.onException(e);
+    }
+  }
+
+  @Override
+  public void synReply(boolean outFinished, int streamId,
+      List<Header> headerBlock) {
+    try {
+      frameWriter.synReply(outFinished, streamId, headerBlock);
+    } catch (IOException e) {
+      transportExceptionHandler.onException(e);
+    }
+  }
+
+  @Override
+  public void headers(int streamId, List<Header> headerBlock) {
+    frameLogger.logHeaders(OkHttpFrameLogger.Direction.OUTBOUND, streamId, headerBlock, false);
+    try {
+      frameWriter.headers(streamId, headerBlock);
+    } catch (IOException e) {
+      transportExceptionHandler.onException(e);
+    }
+  }
+
+  @Override
+  public void rstStream(int streamId, ErrorCode errorCode) {
+    frameLogger.logRstStream(OkHttpFrameLogger.Direction.OUTBOUND, streamId, errorCode);
+    try {
+      frameWriter.rstStream(streamId, errorCode);
+    } catch (IOException e) {
+      transportExceptionHandler.onException(e);
+    }
+  }
+
+  @Override
+  public int maxDataLength() {
+    return frameWriter.maxDataLength();
+  }
+
+  @Override
+  public void data(boolean outFinished, int streamId, Buffer source, int byteCount) {
+    frameLogger.logData(OkHttpFrameLogger.Direction.OUTBOUND,
+        streamId, source.buffer(), byteCount, outFinished);
+    try {
+      frameWriter.data(outFinished, streamId, source, byteCount);
+    } catch (IOException e) {
+      transportExceptionHandler.onException(e);
+    }
+  }
+
+  @Override
+  public void settings(Settings okHttpSettings) {
+    frameLogger.logSettings(OkHttpFrameLogger.Direction.OUTBOUND, okHttpSettings);
+    try {
+      frameWriter.settings(okHttpSettings);
+    } catch (IOException e) {
+      transportExceptionHandler.onException(e);
+    }
+  }
+
+  @Override
+  public void ping(boolean ack, int payload1, int payload2) {
+    if (ack) {
+      frameLogger.logPingAck(OkHttpFrameLogger.Direction.OUTBOUND,
+          ((long) payload1 << 32) | (payload2 & 0xFFFFFFFFL));
+    } else {
+      frameLogger.logPing(OkHttpFrameLogger.Direction.OUTBOUND,
+          ((long) payload1 << 32) | (payload2 & 0xFFFFFFFFL));
+    }
+    try {
+      frameWriter.ping(ack, payload1, payload2);
+    } catch (IOException e) {
+      transportExceptionHandler.onException(e);
+    }
+  }
+
+  @Override
+  public void goAway(int lastGoodStreamId, ErrorCode errorCode,
+      byte[] debugData) {
+    frameLogger.logGoAway(OkHttpFrameLogger.Direction.OUTBOUND,
+        lastGoodStreamId, errorCode, ByteString.of(debugData));
+    try {
+      frameWriter.goAway(lastGoodStreamId, errorCode, debugData);
+      // Flush it since after goAway, we are likely to close this writer.
+      frameWriter.flush();
+    } catch (IOException e) {
+      transportExceptionHandler.onException(e);
+    }
+  }
+
+  @Override
+  public void windowUpdate(int streamId, long windowSizeIncrement) {
+    frameLogger.logWindowsUpdate(OkHttpFrameLogger.Direction.OUTBOUND,
+        streamId, windowSizeIncrement);
+    try {
+      frameWriter.windowUpdate(streamId, windowSizeIncrement);
+    } catch (IOException e) {
+      transportExceptionHandler.onException(e);
+    }
+  }
+
+  @Override
+  public void close() {
+    try {
+      frameWriter.close();
+    } catch (IOException e) {
+      log.log(getLogLevel(e), "Failed closing connection", e);
+    }
+  }
+
+  /**
+   * Accepts a throwable and returns the appropriate logging level. Uninteresting exceptions
+   * should not clutter the log.
+   */
+  @VisibleForTesting
+  static Level getLogLevel(Throwable t) {
+    if (t.getClass().equals(IOException.class)) {
+      return Level.FINE;
+    }
+    return Level.INFO;
+  }
+
+  /** A class that handles transport exception. */
+  interface TransportExceptionHandler {
+    /** Handles exception. */
+    void onException(Throwable throwable);
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/ForwardingFrameWriter.java b/okhttp/src/main/java/io/grpc/okhttp/ForwardingFrameWriter.java
new file mode 100644
index 00000000000..ae173376e8d
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/ForwardingFrameWriter.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2022 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.okhttp;
+
+import com.google.common.base.Preconditions;
+import io.grpc.okhttp.internal.framed.ErrorCode;
+import io.grpc.okhttp.internal.framed.FrameWriter;
+import io.grpc.okhttp.internal.framed.Header;
+import io.grpc.okhttp.internal.framed.Settings;
+import java.io.IOException;
+import java.util.List;
+import okio.Buffer;
+
+
+/** FrameWriter that forwards all calls to a delegate. */
+abstract class ForwardingFrameWriter implements FrameWriter {
+  private final FrameWriter delegate;
+
+  public ForwardingFrameWriter(FrameWriter delegate) {
+    this.delegate = Preconditions.checkNotNull(delegate, "delegate");
+  }
+
+  @Override
+  public void close() throws IOException {
+    delegate.close();
+  }
+
+  @Override
+  public void connectionPreface() throws IOException {
+    delegate.connectionPreface();
+  }
+
+  @Override
+  public void ackSettings(Settings peerSettings) throws IOException {
+    delegate.ackSettings(peerSettings);
+  }
+
+  @Override
+  public void pushPromise(int streamId, int promisedStreamId, List<Header> requestHeaders)
+      throws IOException {
+    delegate.pushPromise(streamId, promisedStreamId, requestHeaders);
+  }
+
+  @Override
+  public void flush() throws IOException {
+    delegate.flush();
+  }
+
+  @Override
+  public void synStream(boolean outFinished, boolean inFinished, int streamId,
+      int associatedStreamId, List<Header> headerBlock) throws IOException {
+    delegate.synStream(outFinished, inFinished, streamId, associatedStreamId, headerBlock);
+  }
+
+  @Override
+  public void synReply(boolean outFinished, int streamId, List<Header> headerBlock)
+      throws IOException {
+    delegate.synReply(outFinished, streamId, headerBlock);
+  }
+
+  @Override
+  public void headers(int streamId, List<Header> headerBlock) throws IOException {
+    delegate.headers(streamId, headerBlock);
+  }
+
+  @Override
+  public void rstStream(int streamId, ErrorCode errorCode) throws IOException {
+    delegate.rstStream(streamId, errorCode);
+  }
+
+  @Override
+  public int maxDataLength() {
+    return delegate.maxDataLength();
+  }
+
+  @Override
+  public void data(boolean outFinished, int streamId, Buffer source, int byteCount)
+      throws IOException {
+    delegate.data(outFinished, streamId, source, byteCount);
+  }
+
+  @Override
+  public void settings(Settings okHttpSettings) throws IOException {
+    delegate.settings(okHttpSettings);
+  }
+
+  @Override
+  public void ping(boolean ack, int payload1, int payload2) throws IOException {
+    delegate.ping(ack, payload1, payload2);
+  }
+
+  @Override
+  public void goAway(int lastGoodStreamId, ErrorCode errorCode, byte[] debugData)
+      throws IOException {
+    delegate.goAway(lastGoodStreamId, errorCode, debugData);
+  }
+
+  @Override
+  public void windowUpdate(int streamId, long windowSizeIncrement) throws IOException {
+    delegate.windowUpdate(streamId, windowSizeIncrement);
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/HandshakerSocketFactory.java b/okhttp/src/main/java/io/grpc/okhttp/HandshakerSocketFactory.java
new file mode 100644
index 00000000000..a6cf8db9b4f
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/HandshakerSocketFactory.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2022 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.okhttp;
+
+import com.google.common.base.Preconditions;
+import io.grpc.Attributes;
+import io.grpc.InternalChannelz;
+import java.io.IOException;
+import java.net.Socket;
+
+/** Handshakes new connections. */
+interface HandshakerSocketFactory {
+  /** When the returned socket is closed, {@code socket} must be closed. */
+  HandshakeResult handshake(Socket socket, Attributes attributes) throws IOException;
+
+  static final class HandshakeResult {
+    public final Socket socket;
+    public final Attributes attributes;
+    public final InternalChannelz.Security securityInfo;
+
+    public HandshakeResult(
+        Socket socket, Attributes attributes, InternalChannelz.Security securityInfo) {
+      this.socket = Preconditions.checkNotNull(socket, "socket");
+      this.attributes = Preconditions.checkNotNull(attributes, "attributes");
+      this.securityInfo = securityInfo;
+    }
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/Headers.java b/okhttp/src/main/java/io/grpc/okhttp/Headers.java
index e1f43b0b9d4..ff2033b35be 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/Headers.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/Headers.java
@@ -1,40 +1,23 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
-import static io.grpc.internal.GrpcUtil.CONTENT_TYPE_KEY;
-import static io.grpc.internal.GrpcUtil.USER_AGENT_KEY;
-
 import com.google.common.base.Preconditions;
+import io.grpc.InternalMetadata;
 import io.grpc.Metadata;
 import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.TransportFrameUtil;
@@ -46,12 +29,14 @@
 /**
  * Constants for request/response headers.
  */
-public class Headers {
+class Headers {
 
-  public static final Header SCHEME_HEADER = new Header(Header.TARGET_SCHEME, "https");
+  public static final Header HTTPS_SCHEME_HEADER = new Header(Header.TARGET_SCHEME, "https");
+  public static final Header HTTP_SCHEME_HEADER = new Header(Header.TARGET_SCHEME, "http");
   public static final Header METHOD_HEADER = new Header(Header.TARGET_METHOD, GrpcUtil.HTTP_METHOD);
+  public static final Header METHOD_GET_HEADER = new Header(Header.TARGET_METHOD, "GET");
   public static final Header CONTENT_TYPE_HEADER =
-      new Header(CONTENT_TYPE_KEY.name(), GrpcUtil.CONTENT_TYPE_GRPC);
+      new Header(GrpcUtil.CONTENT_TYPE_KEY.name(), GrpcUtil.CONTENT_TYPE_GRPC);
   public static final Header TE_HEADER = new Header("te", GrpcUtil.TE_TRAILERS);
 
   /**
@@ -59,18 +44,33 @@ public class Headers {
    * creating a stream. Since this serializes the headers, this method should be called in the
    * application thread context.
    */
-  public static List<Header> createRequestHeaders(Metadata headers, String defaultPath,
-      String authority, String userAgent) {
+  public static List<Header> createRequestHeaders(
+      Metadata headers,
+      String defaultPath,
+      String authority,
+      String userAgent,
+      boolean useGet,
+      boolean usePlaintext) {
     Preconditions.checkNotNull(headers, "headers");
     Preconditions.checkNotNull(defaultPath, "defaultPath");
     Preconditions.checkNotNull(authority, "authority");
 
+    stripNonApplicationHeaders(headers);
+
     // 7 is the number of explicit add calls below.
-    List<Header> okhttpHeaders = new ArrayList<Header>(7 + headers.headerCount());
+    List<Header> okhttpHeaders = new ArrayList<>(7 + InternalMetadata.headerCount(headers));
 
     // Set GRPC-specific headers.
-    okhttpHeaders.add(SCHEME_HEADER);
-    okhttpHeaders.add(METHOD_HEADER);
+    if (usePlaintext) {
+      okhttpHeaders.add(HTTP_SCHEME_HEADER);
+    } else {
+      okhttpHeaders.add(HTTPS_SCHEME_HEADER);
+    }
+    if (useGet) {
+      okhttpHeaders.add(METHOD_GET_HEADER);
+    } else {
+      okhttpHeaders.add(METHOD_HEADER);
+    }
 
     okhttpHeaders.add(new Header(Header.TARGET_AUTHORITY, authority));
     String path = defaultPath;
@@ -83,27 +83,72 @@ public static List<Header> createRequestHeaders(Metadata headers, String default
     okhttpHeaders.add(TE_HEADER);
 
     // Now add any application-provided headers.
-    byte[][] serializedHeaders = TransportFrameUtil.toHttp2Headers(headers);
+    return addMetadata(okhttpHeaders, headers);
+  }
+
+  /**
+   * Serializes the given headers and creates a list of OkHttp {@link Header}s to be used when
+   * starting a response. Since this serializes the headers, this method should be called in the
+   * application thread context.
+   */
+  public static List<Header> createResponseHeaders(Metadata headers) {
+    stripNonApplicationHeaders(headers);
+
+    // 2 is the number of explicit add calls below.
+    List<Header> okhttpHeaders = new ArrayList<>(2 + InternalMetadata.headerCount(headers));
+    okhttpHeaders.add(new Header(Header.RESPONSE_STATUS, "200"));
+    // All non-pseudo headers must come after pseudo headers.
+    okhttpHeaders.add(CONTENT_TYPE_HEADER);
+    return addMetadata(okhttpHeaders, headers);
+  }
+
+  /**
+   * Serializes the given headers and creates a list of OkHttp {@link Header}s to be used when
+   * finishing a response. Since this serializes the headers, this method should be called in the
+   * application thread context.
+   */
+  public static List<Header> createResponseTrailers(Metadata trailers, boolean headersSent) {
+    if (!headersSent) {
+      return createResponseHeaders(trailers);
+    }
+    stripNonApplicationHeaders(trailers);
+
+    List<Header> okhttpTrailers = new ArrayList<>(InternalMetadata.headerCount(trailers));
+    return addMetadata(okhttpTrailers, trailers);
+  }
+
+  /**
+   * Serializes the given headers and creates a list of OkHttp {@link Header}s to be used when
+   * failing with an HTTP response.
+   */
+  public static List<Header> createHttpResponseHeaders(
+      int httpCode, String contentType, Metadata headers) {
+    // 2 is the number of explicit add calls below.
+    List<Header> okhttpHeaders = new ArrayList<>(2 + InternalMetadata.headerCount(headers));
+    okhttpHeaders.add(new Header(Header.RESPONSE_STATUS, "" + httpCode));
+    // All non-pseudo headers must come after pseudo headers.
+    okhttpHeaders.add(new Header(GrpcUtil.CONTENT_TYPE_KEY.name(), contentType));
+    return addMetadata(okhttpHeaders, headers);
+  }
+
+  private static List<Header> addMetadata(List<Header> okhttpHeaders, Metadata toAdd) {
+    byte[][] serializedHeaders = TransportFrameUtil.toHttp2Headers(toAdd);
     for (int i = 0; i < serializedHeaders.length; i += 2) {
       ByteString key = ByteString.of(serializedHeaders[i]);
-      String keyString = key.utf8();
-      if (isApplicationHeader(keyString)) {
-        ByteString value = ByteString.of(serializedHeaders[i + 1]);
-        okhttpHeaders.add(new Header(key, value));
+      // Don't allow HTTP/2 pseudo headers to be added by the application.
+      if (key.size() == 0 || key.getByte(0) == ':') {
+        continue;
       }
+      ByteString value = ByteString.of(serializedHeaders[i + 1]);
+      okhttpHeaders.add(new Header(key, value));
     }
-
     return okhttpHeaders;
   }
 
-  /**
-   * Returns {@code true} if the given header is an application-provided header. Otherwise, returns
-   * {@code false} if the header is reserved by GRPC.
-   */
-  private static boolean isApplicationHeader(String key) {
-    // Don't allow HTTP/2 pseudo headers or content-type to be added by the application.
-    return (!key.startsWith(":")
-            && !CONTENT_TYPE_KEY.name().equalsIgnoreCase(key))
-            && !USER_AGENT_KEY.name().equalsIgnoreCase(key);
+  /** Strips all non-pseudo headers reserved by gRPC, to avoid duplicates and misinterpretation. */
+  private static void stripNonApplicationHeaders(Metadata headers) {
+    headers.discardAll(GrpcUtil.CONTENT_TYPE_KEY);
+    headers.discardAll(GrpcUtil.TE_HEADER);
+    headers.discardAll(GrpcUtil.USER_AGENT_KEY);
   }
 }
diff --git a/okhttp/src/main/java/io/grpc/okhttp/InternalOkHttpChannelBuilder.java b/okhttp/src/main/java/io/grpc/okhttp/InternalOkHttpChannelBuilder.java
new file mode 100644
index 00000000000..a4bd1c03020
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/InternalOkHttpChannelBuilder.java
@@ -0,0 +1,41 @@
+/*
+ * 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.okhttp;
+
+import io.grpc.Internal;
+
+/**
+ * Internal {@link OkHttpChannelBuilder} accessor.  This is intended for usage internal to the gRPC
+ * team.  If you *really* think you need to use this, contact the gRPC team first.
+ */
+@Internal
+public final class InternalOkHttpChannelBuilder {
+
+  public static void setStatsEnabled(OkHttpChannelBuilder builder, boolean value) {
+    builder.setStatsEnabled(value);
+  }
+
+  public static void disableCheckAuthority(OkHttpChannelBuilder builder) {
+    builder.disableCheckAuthority();
+  }
+
+  public static void enableCheckAuthority(OkHttpChannelBuilder builder) {
+    builder.enableCheckAuthority();
+  }
+
+  private InternalOkHttpChannelBuilder() {}
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/InternalOkHttpServerBuilder.java b/okhttp/src/main/java/io/grpc/okhttp/InternalOkHttpServerBuilder.java
new file mode 100644
index 00000000000..78a409a3f85
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/InternalOkHttpServerBuilder.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2022 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.okhttp;
+
+import io.grpc.Internal;
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.TransportTracer;
+import java.util.List;
+
+/**
+ * Internal {@link OkHttpServerBuilder} accessor.  This is intended for usage internal to
+ * the gRPC team.  If you *really* think you need to use this, contact the gRPC team first.
+ */
+@Internal
+public final class InternalOkHttpServerBuilder {
+  public static InternalServer buildTransportServers(OkHttpServerBuilder builder,
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+    return builder.buildTransportServers(streamTracerFactories);
+  }
+
+  public static void setTransportTracerFactory(OkHttpServerBuilder builder,
+      TransportTracer.Factory transportTracerFactory) {
+    builder.setTransportTracerFactory(transportTracerFactory);
+  }
+
+  public static void setStatsEnabled(OkHttpServerBuilder builder, boolean value) {
+    builder.setStatsEnabled(value);
+  }
+
+  private InternalOkHttpServerBuilder() {}
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/NegotiationType.java b/okhttp/src/main/java/io/grpc/okhttp/NegotiationType.java
index a3da2d2d7c5..ebd8fd93d9a 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/NegotiationType.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/NegotiationType.java
@@ -1,39 +1,29 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
 /**
  * Identifies the negotiation used for starting up HTTP/2.
+ *
+ * @deprecated use {@link OkHttpChannelBuilder#usePlaintext()} or {@link
+ *     OkHttpChannelBuilder#useTransportSecurity()} directly rather than {@link
+ *     OkHttpChannelBuilder#negotiationType(NegotiationType)}.
  */
+@Deprecated
 public enum NegotiationType {
   /**
    * Uses TLS ALPN/NPN negotiation, assumes an SSL connection.
diff --git a/okhttp/src/main/java/io/grpc/okhttp/NoopSslSocket.java b/okhttp/src/main/java/io/grpc/okhttp/NoopSslSocket.java
new file mode 100644
index 00000000000..6e6a6f12a39
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/NoopSslSocket.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2024 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.okhttp;
+
+import java.io.IOException;
+import javax.net.ssl.HandshakeCompletedListener;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSocket;
+
+/** A no-op ssl socket, to facilitate overriding only the required methods in specific
+ * implementations.
+ */
+class NoopSslSocket extends SSLSocket {
+  @Override
+  public String[] getSupportedCipherSuites() {
+    return new String[0];
+  }
+
+  @Override
+  public String[] getEnabledCipherSuites() {
+    return new String[0];
+  }
+
+  @Override
+  public void setEnabledCipherSuites(String[] suites) {
+
+  }
+
+  @Override
+  public String[] getSupportedProtocols() {
+    return new String[0];
+  }
+
+  @Override
+  public String[] getEnabledProtocols() {
+    return new String[0];
+  }
+
+  @Override
+  public void setEnabledProtocols(String[] protocols) {
+
+  }
+
+  @Override
+  public SSLSession getSession() {
+    return null;
+  }
+
+  @Override
+  public void addHandshakeCompletedListener(HandshakeCompletedListener listener) {
+
+  }
+
+  @Override
+  public void removeHandshakeCompletedListener(HandshakeCompletedListener listener) {
+
+  }
+
+  @Override
+  public void startHandshake() throws IOException {
+
+  }
+
+  @Override
+  public void setUseClientMode(boolean mode) {
+
+  }
+
+  @Override
+  public boolean getUseClientMode() {
+    return false;
+  }
+
+  @Override
+  public void setNeedClientAuth(boolean need) {
+
+  }
+
+  @Override
+  public boolean getNeedClientAuth() {
+    return false;
+  }
+
+  @Override
+  public void setWantClientAuth(boolean want) {
+
+  }
+
+  @Override
+  public boolean getWantClientAuth() {
+    return false;
+  }
+
+  @Override
+  public void setEnableSessionCreation(boolean flag) {
+
+  }
+
+  @Override
+  public boolean getEnableSessionCreation() {
+    return false;
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelBuilder.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelBuilder.java
index 7bf39d4bfff..98f764132fe 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelBuilder.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelBuilder.java
@@ -1,105 +1,161 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
-import static io.grpc.internal.GrpcUtil.DEFAULT_KEEPALIVE_DELAY_NANOS;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.internal.CertificateUtils.createTrustManager;
 import static io.grpc.internal.GrpcUtil.DEFAULT_KEEPALIVE_TIMEOUT_NANOS;
+import static io.grpc.internal.GrpcUtil.KEEPALIVE_TIME_NANOS_DISABLED;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
-import com.squareup.okhttp.CipherSuite;
-import com.squareup.okhttp.ConnectionSpec;
-import com.squareup.okhttp.TlsVersion;
-import io.grpc.Attributes;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.CallCredentials;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.ChoiceChannelCredentials;
+import io.grpc.CompositeCallCredentials;
+import io.grpc.CompositeChannelCredentials;
 import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingChannelBuilder2;
+import io.grpc.InsecureChannelCredentials;
 import io.grpc.Internal;
-import io.grpc.NameResolver;
-import io.grpc.internal.AbstractManagedChannelImplBuilder;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.internal.AtomicBackoff;
 import io.grpc.internal.ClientTransportFactory;
 import io.grpc.internal.ConnectionClientTransport;
+import io.grpc.internal.FixedObjectPool;
 import io.grpc.internal.GrpcUtil;
-import io.grpc.internal.SharedResourceHolder;
+import io.grpc.internal.KeepAliveManager;
+import io.grpc.internal.ManagedChannelImplBuilder;
+import io.grpc.internal.ManagedChannelImplBuilder.ChannelBuilderDefaultPortProvider;
+import io.grpc.internal.ManagedChannelImplBuilder.ClientTransportFactoryBuilder;
+import io.grpc.internal.ObjectPool;
 import io.grpc.internal.SharedResourceHolder.Resource;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.internal.TransportTracer;
+import io.grpc.okhttp.internal.CipherSuite;
+import io.grpc.okhttp.internal.ConnectionSpec;
 import io.grpc.okhttp.internal.Platform;
+import io.grpc.okhttp.internal.TlsVersion;
+import io.grpc.util.CertificateUtils;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
 import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.PrivateKey;
+import java.security.cert.X509Certificate;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Set;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 import javax.annotation.Nullable;
+import javax.net.SocketFactory;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.KeyManagerFactory;
 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
 
 /** Convenience class for building channels with the OkHttp transport. */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1785")
-public class OkHttpChannelBuilder extends
-        AbstractManagedChannelImplBuilder<OkHttpChannelBuilder> {
+public final class OkHttpChannelBuilder extends ForwardingChannelBuilder2<OkHttpChannelBuilder> {
+  private static final Logger log = Logger.getLogger(OkHttpChannelBuilder.class.getName());
+  public static final int DEFAULT_FLOW_CONTROL_WINDOW = 65535;
+
+  private final ManagedChannelImplBuilder managedChannelImplBuilder;
+  private final ChannelCredentials channelCredentials;
+  private TransportTracer.Factory transportTracerFactory = TransportTracer.getDefaultFactory();
+
+
+  /** Identifies the negotiation used for starting up HTTP/2. */
+  private enum NegotiationType {
+    /** Uses TLS ALPN/NPN negotiation, assumes an SSL connection. */
+    TLS,
 
-  public static final ConnectionSpec DEFAULT_CONNECTION_SPEC =
+    /**
+     * Just assume the connection is plaintext (non-SSL) and the remote endpoint supports HTTP/2
+     * directly without an upgrade.
+     */
+    PLAINTEXT
+  }
+
+  // @VisibleForTesting
+  static final ConnectionSpec INTERNAL_DEFAULT_CONNECTION_SPEC =
       new ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
           .cipherSuites(
               // The following items should be sync with Netty's Http2SecurityUtil.CIPHERS.
-              CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
               CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-              CipherSuite.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
               CipherSuite.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-              CipherSuite.TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
-              CipherSuite.TLS_DHE_DSS_WITH_AES_128_GCM_SHA256,
-              CipherSuite.TLS_DHE_RSA_WITH_AES_256_GCM_SHA384,
-              CipherSuite.TLS_DHE_DSS_WITH_AES_256_GCM_SHA384)
-          .tlsVersions(TlsVersion.TLS_1_2)
+              CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+              CipherSuite.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+              CipherSuite.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
+              CipherSuite.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256
+
+              // TLS 1.3 does not work so far. See issues:
+              // https://github.com/grpc/grpc-java/issues/7765
+              //
+              // TLS 1.3
+              //CipherSuite.TLS_AES_128_GCM_SHA256,
+              //CipherSuite.TLS_AES_256_GCM_SHA384,
+              //CipherSuite.TLS_CHACHA20_POLY1305_SHA256
+              )
+          .tlsVersions(/*TlsVersion.TLS_1_3,*/ TlsVersion.TLS_1_2)
           .supportsTlsExtensions(true)
           .build();
 
-  private static final Resource<ExecutorService> SHARED_EXECUTOR =
-      new Resource<ExecutorService>() {
+  private static final long AS_LARGE_AS_INFINITE = TimeUnit.DAYS.toNanos(1000L);
+  private static final Resource<Executor> SHARED_EXECUTOR =
+      new Resource<Executor>() {
         @Override
-        public ExecutorService create() {
+        public Executor create() {
           return Executors.newCachedThreadPool(GrpcUtil.getThreadFactory("grpc-okhttp-%d", true));
         }
 
         @Override
-        public void close(ExecutorService executor) {
-          executor.shutdown();
+        public void close(Executor executor) {
+          ((ExecutorService) executor).shutdown();
         }
       };
+  static final ObjectPool<Executor> DEFAULT_TRANSPORT_EXECUTOR_POOL =
+      SharedResourcePool.forResource(SHARED_EXECUTOR);
 
   /** Creates a new builder for the given server host and port. */
   public static OkHttpChannelBuilder forAddress(String host, int port) {
     return new OkHttpChannelBuilder(host, port);
   }
 
+  /** Creates a new builder with the given host and port. */
+  public static OkHttpChannelBuilder forAddress(String host, int port, ChannelCredentials creds) {
+    return forTarget(GrpcUtil.authorityFromHostAndPort(host, port), creds);
+  }
+
   /**
    * Creates a new builder for the given target that will be resolved by
    * {@link io.grpc.NameResolver}.
@@ -108,21 +164,92 @@ public static OkHttpChannelBuilder forTarget(String target) {
     return new OkHttpChannelBuilder(target);
   }
 
-  private Executor transportExecutor;
+  /**
+   * Creates a new builder for the given target that will be resolved by
+   * {@link io.grpc.NameResolver}.
+   */
+  public static OkHttpChannelBuilder forTarget(String target, ChannelCredentials creds) {
+    SslSocketFactoryResult result = sslSocketFactoryFrom(creds);
+    if (result.error != null) {
+      throw new IllegalArgumentException(result.error);
+    }
+    return new OkHttpChannelBuilder(target, creds, result.callCredentials, result.factory);
+  }
 
+  private ObjectPool<Executor> transportExecutorPool = DEFAULT_TRANSPORT_EXECUTOR_POOL;
+  private ObjectPool<ScheduledExecutorService> scheduledExecutorServicePool =
+      SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE);
+
+  private SocketFactory socketFactory;
   private SSLSocketFactory sslSocketFactory;
-  private ConnectionSpec connectionSpec = DEFAULT_CONNECTION_SPEC;
+  private final boolean freezeSecurityConfiguration;
+  private HostnameVerifier hostnameVerifier;
+  private ConnectionSpec connectionSpec = INTERNAL_DEFAULT_CONNECTION_SPEC;
   private NegotiationType negotiationType = NegotiationType.TLS;
-  private boolean enableKeepAlive;
-  private long keepAliveDelayNanos;
-  private long keepAliveTimeoutNanos;
+  private long keepAliveTimeNanos = KEEPALIVE_TIME_NANOS_DISABLED;
+  private long keepAliveTimeoutNanos = DEFAULT_KEEPALIVE_TIMEOUT_NANOS;
+  private int flowControlWindow = DEFAULT_FLOW_CONTROL_WINDOW;
+  private boolean keepAliveWithoutCalls;
+  private int maxInboundMessageSize = GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
+  private int maxInboundMetadataSize = Integer.MAX_VALUE;
+
+  /**
+   * If true, indicates that the transport may use the GET method for RPCs, and may include the
+   * request body in the query params.
+   */
+  private final boolean useGetForSafeMethods = false;
 
-  protected OkHttpChannelBuilder(String host, int port) {
+  private OkHttpChannelBuilder(String host, int port) {
     this(GrpcUtil.authorityFromHostAndPort(host, port));
   }
 
   private OkHttpChannelBuilder(String target) {
-    super(target);
+    managedChannelImplBuilder = new ManagedChannelImplBuilder(target,
+        new OkHttpChannelTransportFactoryBuilder(),
+        new OkHttpChannelDefaultPortProvider());
+    this.freezeSecurityConfiguration = false;
+    this.channelCredentials = null;
+  }
+
+  OkHttpChannelBuilder(
+      String target, ChannelCredentials channelCreds, CallCredentials callCreds,
+      SSLSocketFactory factory) {
+    managedChannelImplBuilder = new ManagedChannelImplBuilder(
+        target, channelCreds, callCreds,
+        new OkHttpChannelTransportFactoryBuilder(),
+        new OkHttpChannelDefaultPortProvider());
+    this.sslSocketFactory = factory;
+    this.negotiationType = factory == null ? NegotiationType.PLAINTEXT : NegotiationType.TLS;
+    this.freezeSecurityConfiguration = true;
+    this.channelCredentials = channelCreds;
+  }
+
+  private final class OkHttpChannelTransportFactoryBuilder
+      implements ClientTransportFactoryBuilder {
+    @Override
+    public ClientTransportFactory buildClientTransportFactory() {
+      return buildTransportFactory();
+    }
+  }
+
+  private final class OkHttpChannelDefaultPortProvider
+      implements ChannelBuilderDefaultPortProvider {
+    @Override
+    public int getDefaultPort() {
+      return OkHttpChannelBuilder.this.getDefaultPort();
+    }
+  }
+
+  @Internal
+  @Override
+  protected ManagedChannelBuilder<?> delegate() {
+    return managedChannelImplBuilder;
+  }
+
+  @VisibleForTesting
+  OkHttpChannelBuilder setTransportTracerFactory(TransportTracer.Factory transportTracerFactory) {
+    this.transportTracerFactory = transportTracerFactory;
+    return this;
   }
 
   /**
@@ -131,8 +258,23 @@ private OkHttpChannelBuilder(String target) {
    * <p>The channel does not take ownership of the given executor. It is the caller' responsibility
    * to shutdown the executor when appropriate.
    */
-  public final OkHttpChannelBuilder transportExecutor(@Nullable Executor transportExecutor) {
-    this.transportExecutor = transportExecutor;
+  public OkHttpChannelBuilder transportExecutor(@Nullable Executor transportExecutor) {
+    if (transportExecutor == null) {
+      this.transportExecutorPool = DEFAULT_TRANSPORT_EXECUTOR_POOL;
+    } else {
+      this.transportExecutorPool = new FixedObjectPool<>(transportExecutor);
+    }
+    return this;
+  }
+
+  /**
+   * Override the default {@link SocketFactory} used to create sockets. If the socket factory is not
+   * set or set to null, a default one will be used.
+   *
+   * @since 1.20.0
+   */
+  public OkHttpChannelBuilder socketFactory(@Nullable SocketFactory socketFactory) {
+    this.socketFactory = socketFactory;
     return this;
   }
 
@@ -145,48 +287,114 @@ public final OkHttpChannelBuilder transportExecutor(@Nullable Executor transport
    * {@link #sslSocketFactory} to override the socket factory used.
    *
    * <p>Default: <code>TLS</code>
+   *
+   * @deprecated use {@link #usePlaintext()} or {@link #useTransportSecurity()} instead.
    */
-  public final OkHttpChannelBuilder negotiationType(NegotiationType type) {
-    negotiationType = Preconditions.checkNotNull(type, "type");
+  @Deprecated
+  public OkHttpChannelBuilder negotiationType(io.grpc.okhttp.NegotiationType type) {
+    Preconditions.checkState(!freezeSecurityConfiguration,
+        "Cannot change security when using ChannelCredentials");
+    Preconditions.checkNotNull(type, "type");
+    switch (type) {
+      case TLS:
+        negotiationType = NegotiationType.TLS;
+        break;
+      case PLAINTEXT:
+        negotiationType = NegotiationType.PLAINTEXT;
+        break;
+      default:
+        throw new AssertionError("Unknown negotiation type: " + type);
+    }
     return this;
   }
 
   /**
-   * Enable keepalive with default delay and timeout.
+   * {@inheritDoc}
+   *
+   * @since 1.3.0
    */
-  public final OkHttpChannelBuilder enableKeepAlive(boolean enable) {
-    enableKeepAlive = enable;
-    if (enable) {
-      keepAliveDelayNanos = DEFAULT_KEEPALIVE_DELAY_NANOS;
-      keepAliveTimeoutNanos = DEFAULT_KEEPALIVE_TIMEOUT_NANOS;
+  @Override
+  public OkHttpChannelBuilder keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    Preconditions.checkArgument(keepAliveTime > 0L, "keepalive time must be positive");
+    keepAliveTimeNanos = timeUnit.toNanos(keepAliveTime);
+    keepAliveTimeNanos = KeepAliveManager.clampKeepAliveTimeInNanos(keepAliveTimeNanos);
+    if (keepAliveTimeNanos >= AS_LARGE_AS_INFINITE) {
+      // Bump keepalive time to infinite. This disables keepalive.
+      keepAliveTimeNanos = KEEPALIVE_TIME_NANOS_DISABLED;
     }
     return this;
   }
 
   /**
-   * Enable keepalive with custom delay and timeout.
+   * {@inheritDoc}
+   *
+   * @since 1.3.0
    */
-  public final OkHttpChannelBuilder enableKeepAlive(boolean enable, long keepAliveDelay,
-      TimeUnit delayUnit, long keepAliveTimeout, TimeUnit timeoutUnit) {
-    enableKeepAlive = enable;
-    if (enable) {
-      keepAliveDelayNanos = delayUnit.toNanos(keepAliveDelay);
-      keepAliveTimeoutNanos = timeoutUnit.toNanos(keepAliveTimeout);
-    }
+  @Override
+  public OkHttpChannelBuilder keepAliveTimeout(long keepAliveTimeout, TimeUnit timeUnit) {
+    Preconditions.checkArgument(keepAliveTimeout > 0L, "keepalive timeout must be positive");
+    keepAliveTimeoutNanos = timeUnit.toNanos(keepAliveTimeout);
+    keepAliveTimeoutNanos = KeepAliveManager.clampKeepAliveTimeoutInNanos(keepAliveTimeoutNanos);
     return this;
   }
 
   /**
-   * Override the default {@link SSLSocketFactory} and enable {@link NegotiationType#TLS}
-   * negotiation.
-   *
-   * <p>By default, when TLS is enabled, <code>SSLSocketFactory.getDefault()</code> will be used.
+   * Sets the flow control window in bytes. If not called, the default value
+   * is {@link #DEFAULT_FLOW_CONTROL_WINDOW}).
+   */
+  public OkHttpChannelBuilder flowControlWindow(int flowControlWindow) {
+    Preconditions.checkState(flowControlWindow > 0, "flowControlWindow must be positive");
+    this.flowControlWindow = flowControlWindow;
+    return this;
+  }
+
+  /**
+   * {@inheritDoc}
    *
-   * <p>{@link NegotiationType#TLS} will be applied by calling this method.
+   * @since 1.3.0
+   * @see #keepAliveTime(long, TimeUnit)
+   */
+  @Override
+  public OkHttpChannelBuilder keepAliveWithoutCalls(boolean enable) {
+    keepAliveWithoutCalls = enable;
+    return this;
+  }
+
+  /**
+   * Override the default {@link SSLSocketFactory} and enable TLS negotiation.
    */
-  public final OkHttpChannelBuilder sslSocketFactory(SSLSocketFactory factory) {
+  public OkHttpChannelBuilder sslSocketFactory(SSLSocketFactory factory) {
+    Preconditions.checkState(!freezeSecurityConfiguration,
+        "Cannot change security when using ChannelCredentials");
     this.sslSocketFactory = factory;
-    negotiationType(NegotiationType.TLS);
+    negotiationType = NegotiationType.TLS;
+    return this;
+  }
+
+  /**
+   * Set the hostname verifier to use when using TLS negotiation. The hostnameVerifier is only used
+   * if using TLS negotiation. If the hostname verifier is not set, a default hostname verifier is
+   * used.
+   *
+   * <p>Be careful when setting a custom hostname verifier! By setting a non-null value, you are
+   * replacing all default verification behavior. If the hostname verifier you supply does not
+   * effectively supply the same checks, you may be removing the security assurances that TLS aims
+   * to provide.</p>
+   *
+   * <p>This method should not be used to avoid hostname verification, even during testing, since
+   * {@link #overrideAuthority} is a safer alternative as it does not disable any security checks.
+   * </p>
+   *
+   * @see io.grpc.okhttp.internal.OkHostnameVerifier
+   *
+   * @since 1.6.0
+   * @return this
+   *
+   */
+  public OkHttpChannelBuilder hostnameVerifier(@Nullable HostnameVerifier hostnameVerifier) {
+    Preconditions.checkState(!freezeSecurityConfiguration,
+        "Cannot change security when using ChannelCredentials");
+    this.hostnameVerifier = hostnameVerifier;
     return this;
   }
 
@@ -194,60 +402,174 @@ public final OkHttpChannelBuilder sslSocketFactory(SSLSocketFactory factory) {
    * For secure connection, provides a ConnectionSpec to specify Cipher suite and
    * TLS versions.
    *
-   * <p>By default {@link #DEFAULT_CONNECTION_SPEC} will be used.
+   * <p>By default a modern, HTTP/2-compatible spec will be used.
    *
    * <p>This method is only used when building a secure connection. For plaintext
-   * connection, use {@link #usePlaintext} instead.
+   * connection, use {@link #usePlaintext()} instead.
    *
    * @throws IllegalArgumentException
    *         If {@code connectionSpec} is not with TLS
    */
-  public final OkHttpChannelBuilder connectionSpec(ConnectionSpec connectionSpec) {
+  public OkHttpChannelBuilder connectionSpec(
+      com.squareup.okhttp.ConnectionSpec connectionSpec) {
+    Preconditions.checkState(!freezeSecurityConfiguration,
+        "Cannot change security when using ChannelCredentials");
     Preconditions.checkArgument(connectionSpec.isTls(), "plaintext ConnectionSpec is not accepted");
-    this.connectionSpec = connectionSpec;
+    this.connectionSpec = Utils.convertSpec(connectionSpec);
     return this;
   }
 
   /**
-   * Equivalent to using {@link #negotiationType(NegotiationType)} with {@code PLAINTEXT}.
+   * Sets the connection specification used for secure connections.
+   *
+   * <p>By default a modern, HTTP/2-compatible spec will be used.
+   *
+   * <p>This method is only used when building a secure connection. For plaintext
+   * connection, use {@link #usePlaintext()} instead.
+   *
+   * @param tlsVersions List of tls versions.
+   * @param cipherSuites List of cipher suites.
+   *
+   * @since  1.43.0
    */
+  public OkHttpChannelBuilder tlsConnectionSpec(
+          String[] tlsVersions, String[] cipherSuites) {
+    Preconditions.checkState(!freezeSecurityConfiguration,
+            "Cannot change security when using ChannelCredentials");
+    Preconditions.checkNotNull(tlsVersions, "tls versions must not null");
+    Preconditions.checkNotNull(cipherSuites, "ciphers must not null");
+
+    this.connectionSpec = new ConnectionSpec.Builder(true)
+            .supportsTlsExtensions(true)
+            .tlsVersions(tlsVersions)
+            .cipherSuites(cipherSuites)
+            .build();
+    return this;
+  }
+
+  /** Sets the negotiation type for the HTTP/2 connection to plaintext. */
   @Override
-  public final OkHttpChannelBuilder usePlaintext(boolean skipNegotiation) {
-    if (skipNegotiation) {
-      negotiationType(NegotiationType.PLAINTEXT);
-    } else {
-      throw new IllegalArgumentException("Plaintext negotiation not currently supported");
-    }
+  public OkHttpChannelBuilder usePlaintext() {
+    Preconditions.checkState(!freezeSecurityConfiguration,
+        "Cannot change security when using ChannelCredentials");
+    negotiationType = NegotiationType.PLAINTEXT;
+    return this;
+  }
+
+  /**
+   * Sets the negotiation type for the HTTP/2 connection to TLS (this is the default).
+   *
+   * <p>With TLS enabled, a default {@link SSLSocketFactory} is created using the best {@link
+   * java.security.Provider} available and is NOT based on {@link SSLSocketFactory#getDefault}. To
+   * more precisely control the TLS configuration call {@link #sslSocketFactory(SSLSocketFactory)}
+   * to override the socket factory used.
+   */
+  @Override
+  public OkHttpChannelBuilder useTransportSecurity() {
+    Preconditions.checkState(!freezeSecurityConfiguration,
+        "Cannot change security when using ChannelCredentials");
+    negotiationType = NegotiationType.TLS;
     return this;
   }
 
+  /**
+   * Provides a custom scheduled executor service.
+   *
+   * <p>It's an optional parameter. If the user has not provided a scheduled executor service when
+   * the channel is built, the builder will use a static cached thread pool.
+   *
+   * @return this
+   *
+   * @since 1.11.0
+   */
+  public OkHttpChannelBuilder scheduledExecutorService(
+      ScheduledExecutorService scheduledExecutorService) {
+    this.scheduledExecutorServicePool =
+        new FixedObjectPool<>(checkNotNull(scheduledExecutorService, "scheduledExecutorService"));
+    return this;
+  }
+
+  /**
+   * Sets the maximum size of metadata allowed to be received. {@code Integer.MAX_VALUE} disables
+   * the enforcement. Defaults to no limit ({@code Integer.MAX_VALUE}).
+   *
+   * <p>The implementation does not currently limit memory usage; this value is checked only after
+   * the metadata is decoded from the wire. It does prevent large metadata from being passed to the
+   * application.
+   *
+   * @param bytes the maximum size of received metadata
+   * @return this
+   * @throws IllegalArgumentException if bytes is non-positive
+   * @since 1.17.0
+   */
   @Override
-  protected final ClientTransportFactory buildTransportFactory() {
-    return new OkHttpTransportFactory(transportExecutor,
-        createSocketFactory(), connectionSpec, maxInboundMessageSize(), enableKeepAlive,
-        keepAliveDelayNanos, keepAliveTimeoutNanos);
+  public OkHttpChannelBuilder maxInboundMetadataSize(int bytes) {
+    Preconditions.checkArgument(bytes > 0, "maxInboundMetadataSize must be > 0");
+    this.maxInboundMetadataSize = bytes;
+    return this;
   }
 
+  /**
+   * Sets the maximum message size allowed for a single gRPC frame. If an inbound messages
+   * larger than this limit is received it will not be processed and the RPC will fail with
+   * RESOURCE_EXHAUSTED.
+   */
   @Override
-  protected Attributes getNameResolverParams() {
-    int defaultPort;
+  public OkHttpChannelBuilder maxInboundMessageSize(int max) {
+    Preconditions.checkArgument(max >= 0, "negative max");
+    maxInboundMessageSize = max;
+    return this;
+  }
+
+  OkHttpTransportFactory buildTransportFactory() {
+    boolean enableKeepAlive = keepAliveTimeNanos != KEEPALIVE_TIME_NANOS_DISABLED;
+    return new OkHttpTransportFactory(
+        transportExecutorPool,
+        scheduledExecutorServicePool,
+        socketFactory,
+        createSslSocketFactory(),
+        hostnameVerifier,
+        connectionSpec,
+        maxInboundMessageSize,
+        enableKeepAlive,
+        keepAliveTimeNanos,
+        keepAliveTimeoutNanos,
+        flowControlWindow,
+        keepAliveWithoutCalls,
+        maxInboundMetadataSize,
+        transportTracerFactory,
+        useGetForSafeMethods,
+        channelCredentials);
+  }
+
+  OkHttpChannelBuilder disableCheckAuthority() {
+    this.managedChannelImplBuilder.disableCheckAuthority();
+    return this;
+  }
+
+  OkHttpChannelBuilder enableCheckAuthority() {
+    this.managedChannelImplBuilder.enableCheckAuthority();
+    return this;
+  }
+
+  int getDefaultPort() {
     switch (negotiationType) {
       case PLAINTEXT:
-        defaultPort = GrpcUtil.DEFAULT_PORT_PLAINTEXT;
-        break;
+        return GrpcUtil.DEFAULT_PORT_PLAINTEXT;
       case TLS:
-        defaultPort = GrpcUtil.DEFAULT_PORT_SSL;
-        break;
+        return GrpcUtil.DEFAULT_PORT_SSL;
       default:
         throw new AssertionError(negotiationType + " not handled");
     }
-    return Attributes.newBuilder()
-        .set(NameResolver.Factory.PARAMS_DEFAULT_PORT, defaultPort).build();
+  }
+
+  void setStatsEnabled(boolean value) {
+    this.managedChannelImplBuilder.setStatsEnabled(value);
   }
 
   @VisibleForTesting
   @Nullable
-  SSLSocketFactory createSocketFactory() {
+  SSLSocketFactory createSslSocketFactory() {
     switch (negotiationType) {
       case TLS:
         try {
@@ -266,71 +588,307 @@ SSLSocketFactory createSocketFactory() {
     }
   }
 
+  private static final EnumSet<TlsChannelCredentials.Feature> understoodTlsFeatures =
+      EnumSet.of(
+          TlsChannelCredentials.Feature.MTLS, TlsChannelCredentials.Feature.CUSTOM_MANAGERS);
+
+  static SslSocketFactoryResult sslSocketFactoryFrom(ChannelCredentials creds) {
+    if (creds instanceof TlsChannelCredentials) {
+      TlsChannelCredentials tlsCreds = (TlsChannelCredentials) creds;
+      Set<TlsChannelCredentials.Feature> incomprehensible =
+          tlsCreds.incomprehensible(understoodTlsFeatures);
+      if (!incomprehensible.isEmpty()) {
+        return SslSocketFactoryResult.error(
+            "TLS features not understood: " + incomprehensible);
+      }
+      KeyManager[] km = null;
+      if (tlsCreds.getKeyManagers() != null) {
+        km = tlsCreds.getKeyManagers().toArray(new KeyManager[0]);
+      } else if (tlsCreds.getPrivateKey() != null) {
+        if (tlsCreds.getPrivateKeyPassword() != null) {
+          return SslSocketFactoryResult.error("byte[]-based private key with password unsupported. "
+              + "Use unencrypted file or KeyManager");
+        }
+        try {
+          km = createKeyManager(tlsCreds.getCertificateChain(), tlsCreds.getPrivateKey());
+        } catch (GeneralSecurityException gse) {
+          log.log(Level.FINE, "Exception loading private key from credential", gse);
+          return SslSocketFactoryResult.error("Unable to load private key: " + gse.getMessage());
+        }
+      } // else don't have a client cert
+      TrustManager[] tm = null;
+      if (tlsCreds.getTrustManagers() != null) {
+        tm = tlsCreds.getTrustManagers().toArray(new TrustManager[0]);
+      } else if (tlsCreds.getRootCertificates() != null) {
+        try {
+          tm = createTrustManager(tlsCreds.getRootCertificates());
+        } catch (GeneralSecurityException gse) {
+          log.log(Level.FINE, "Exception loading root certificates from credential", gse);
+          return SslSocketFactoryResult.error(
+              "Unable to load root certificates: " + gse.getMessage());
+        }
+      } // else use system default
+      SSLContext sslContext;
+      try {
+        sslContext = SSLContext.getInstance("TLS", Platform.get().getProvider());
+        sslContext.init(km, tm, null);
+      } catch (GeneralSecurityException gse) {
+        throw new RuntimeException("TLS Provider failure", gse);
+      }
+      return SslSocketFactoryResult.factory(sslContext.getSocketFactory());
+
+    } else if (creds instanceof InsecureChannelCredentials) {
+      return SslSocketFactoryResult.plaintext();
+
+    } else if (creds instanceof CompositeChannelCredentials) {
+      CompositeChannelCredentials compCreds = (CompositeChannelCredentials) creds;
+      return sslSocketFactoryFrom(compCreds.getChannelCredentials())
+          .withCallCredentials(compCreds.getCallCredentials());
+
+    } else if (creds instanceof SslSocketFactoryChannelCredentials.ChannelCredentials) {
+      SslSocketFactoryChannelCredentials.ChannelCredentials factoryCreds =
+          (SslSocketFactoryChannelCredentials.ChannelCredentials) creds;
+      return SslSocketFactoryResult.factory(factoryCreds.getFactory());
+
+    } else if (creds instanceof ChoiceChannelCredentials) {
+      ChoiceChannelCredentials choiceCreds = (ChoiceChannelCredentials) creds;
+      StringBuilder error = new StringBuilder();
+      for (ChannelCredentials innerCreds : choiceCreds.getCredentialsList()) {
+        SslSocketFactoryResult result = sslSocketFactoryFrom(innerCreds);
+        if (result.error == null) {
+          return result;
+        }
+        error.append(", ");
+        error.append(result.error);
+      }
+      return SslSocketFactoryResult.error(error.substring(2));
+
+    } else {
+      return SslSocketFactoryResult.error(
+          "Unsupported credential type: " + creds.getClass().getName());
+    }
+  }
+
+  static KeyManager[] createKeyManager(byte[] certChain, byte[] privateKey)
+      throws GeneralSecurityException {
+    InputStream certChainStream = new ByteArrayInputStream(certChain);
+    InputStream privateKeyStream = new ByteArrayInputStream(privateKey);
+    try {
+      return createKeyManager(certChainStream, privateKeyStream);
+    } finally {
+      GrpcUtil.closeQuietly(certChainStream);
+      GrpcUtil.closeQuietly(privateKeyStream);
+    }
+  }
+
+  static KeyManager[] createKeyManager(InputStream certChain, InputStream privateKey)
+      throws GeneralSecurityException {
+    X509Certificate[] chain = CertificateUtils.getX509Certificates(certChain);
+    PrivateKey key;
+    try {
+      key = CertificateUtils.getPrivateKey(privateKey);
+    } catch (IOException uee) {
+      throw new GeneralSecurityException("Unable to decode private key", uee);
+    }
+    KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
+    try {
+      ks.load(null, null);
+    } catch (IOException ex) {
+      // Shouldn't really happen, as we're not loading any data.
+      throw new GeneralSecurityException(ex);
+    }
+    ks.setKeyEntry("key", key, new char[0], chain);
+
+    KeyManagerFactory keyManagerFactory =
+        KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+    keyManagerFactory.init(ks, new char[0]);
+    return keyManagerFactory.getKeyManagers();
+  }
+
+  static TrustManager[] createTrustManager(byte[] rootCerts) throws GeneralSecurityException {
+    InputStream rootCertsStream = new ByteArrayInputStream(rootCerts);
+    try {
+      return io.grpc.internal.CertificateUtils.createTrustManager(rootCertsStream);
+    } finally {
+      GrpcUtil.closeQuietly(rootCertsStream);
+    }
+  }
+
+  static Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+    return Collections.singleton(InetSocketAddress.class);
+  }
+
+  static final class SslSocketFactoryResult {
+    /** {@code null} implies plaintext if {@code error == null}. */
+    public final SSLSocketFactory factory;
+    public final CallCredentials callCredentials;
+    public final String error;
+
+    private SslSocketFactoryResult(SSLSocketFactory factory, CallCredentials creds, String error) {
+      this.factory = factory;
+      this.callCredentials = creds;
+      this.error = error;
+    }
+
+    public static SslSocketFactoryResult error(String error) {
+      return new SslSocketFactoryResult(
+          null, null, Preconditions.checkNotNull(error, "error"));
+    }
+
+    public static SslSocketFactoryResult plaintext() {
+      return new SslSocketFactoryResult(null, null, null);
+    }
+
+    public static SslSocketFactoryResult factory(
+        SSLSocketFactory factory) {
+      return new SslSocketFactoryResult(
+          Preconditions.checkNotNull(factory, "factory"), null, null);
+    }
+
+    public SslSocketFactoryResult withCallCredentials(CallCredentials callCreds) {
+      Preconditions.checkNotNull(callCreds, "callCreds");
+      if (error != null) {
+        return this;
+      }
+      if (this.callCredentials != null) {
+        callCreds = new CompositeCallCredentials(this.callCredentials, callCreds);
+      }
+      return new SslSocketFactoryResult(factory, callCreds, null);
+    }
+  }
+
+
   /**
    * Creates OkHttp transports. Exposed for internal use, as it should be private.
    */
   @Internal
   static final class OkHttpTransportFactory implements ClientTransportFactory {
-    private final Executor executor;
-    private final boolean usingSharedExecutor;
+    private final ObjectPool<Executor> executorPool;
+    final Executor executor;
+    private final ObjectPool<ScheduledExecutorService> scheduledExecutorServicePool;
+    final ScheduledExecutorService scheduledExecutorService;
+    final TransportTracer.Factory transportTracerFactory;
+    final SocketFactory socketFactory;
+    @Nullable final SSLSocketFactory sslSocketFactory;
     @Nullable
-    private final SSLSocketFactory socketFactory;
-    private final ConnectionSpec connectionSpec;
-    private final int maxMessageSize;
-    private boolean enableKeepAlive;
-    private long keepAliveDelayNanos;
-    private long keepAliveTimeoutNanos;
+    final HostnameVerifier hostnameVerifier;
+    final ConnectionSpec connectionSpec;
+    final int maxMessageSize;
+    private final boolean enableKeepAlive;
+    private final long keepAliveTimeNanos;
+    private final AtomicBackoff keepAliveBackoff;
+    private final long keepAliveTimeoutNanos;
+    final int flowControlWindow;
+    private final boolean keepAliveWithoutCalls;
+    final int maxInboundMetadataSize;
+    final boolean useGetForSafeMethods;
+    private final ChannelCredentials channelCredentials;
     private boolean closed;
 
-    private OkHttpTransportFactory(Executor executor,
-        @Nullable SSLSocketFactory socketFactory,
+    private OkHttpTransportFactory(
+        ObjectPool<Executor> executorPool,
+        ObjectPool<ScheduledExecutorService> scheduledExecutorServicePool,
+        @Nullable SocketFactory socketFactory,
+        @Nullable SSLSocketFactory sslSocketFactory,
+        @Nullable HostnameVerifier hostnameVerifier,
         ConnectionSpec connectionSpec,
         int maxMessageSize,
         boolean enableKeepAlive,
-        long keepAliveDelayNanos,
-        long keepAliveTimeoutNanos) {
+        long keepAliveTimeNanos,
+        long keepAliveTimeoutNanos,
+        int flowControlWindow,
+        boolean keepAliveWithoutCalls,
+        int maxInboundMetadataSize,
+        TransportTracer.Factory transportTracerFactory,
+        boolean useGetForSafeMethods,
+        ChannelCredentials channelCredentials) {
+      this.executorPool = executorPool;
+      this.executor = executorPool.getObject();
+      this.scheduledExecutorServicePool = scheduledExecutorServicePool;
+      this.scheduledExecutorService = scheduledExecutorServicePool.getObject();
       this.socketFactory = socketFactory;
+      this.sslSocketFactory = sslSocketFactory;
+      this.hostnameVerifier = hostnameVerifier;
       this.connectionSpec = connectionSpec;
       this.maxMessageSize = maxMessageSize;
       this.enableKeepAlive = enableKeepAlive;
-      this.keepAliveDelayNanos = keepAliveDelayNanos;
+      this.keepAliveTimeNanos = keepAliveTimeNanos;
+      this.keepAliveBackoff = new AtomicBackoff("keepalive time nanos", keepAliveTimeNanos);
       this.keepAliveTimeoutNanos = keepAliveTimeoutNanos;
+      this.flowControlWindow = flowControlWindow;
+      this.keepAliveWithoutCalls = keepAliveWithoutCalls;
+      this.maxInboundMetadataSize = maxInboundMetadataSize;
+      this.useGetForSafeMethods = useGetForSafeMethods;
+      this.channelCredentials = channelCredentials;
 
-      usingSharedExecutor = executor == null;
-      if (usingSharedExecutor) {
-        // The executor was unspecified, using the shared executor.
-        this.executor = SharedResourceHolder.get(SHARED_EXECUTOR);
-      } else {
-        this.executor = executor;
-      }
+      this.transportTracerFactory =
+          Preconditions.checkNotNull(transportTracerFactory, "transportTracerFactory");
     }
 
     @Override
     public ConnectionClientTransport newClientTransport(
-        SocketAddress addr, String authority, @Nullable String userAgent) {
+        SocketAddress addr, ClientTransportOptions options, ChannelLogger channelLogger) {
       if (closed) {
         throw new IllegalStateException("The transport factory is closed.");
       }
-      InetSocketAddress proxyAddress = null;
-      String proxy = System.getenv("GRPC_PROXY_EXP");
-      if (proxy != null) {
-        String[] parts = proxy.split(":", 2);
-        int port = 80;
-        if (parts.length > 1) {
-          port = Integer.parseInt(parts[1]);
+      final AtomicBackoff.State keepAliveTimeNanosState = keepAliveBackoff.getState();
+      Runnable tooManyPingsRunnable = new Runnable() {
+        @Override
+        public void run() {
+          keepAliveTimeNanosState.backoff();
         }
-        proxyAddress = new InetSocketAddress(parts[0], port);
-      }
+      };
       InetSocketAddress inetSocketAddr = (InetSocketAddress) addr;
-      OkHttpClientTransport transport = new OkHttpClientTransport(inetSocketAddr, authority,
-          userAgent, executor, socketFactory, Utils.convertSpec(connectionSpec), maxMessageSize,
-          proxyAddress, null, null);
+      // TODO(carl-mastrangelo): Pass channelLogger in.
+      OkHttpClientTransport transport = new OkHttpClientTransport(
+          this,
+          inetSocketAddr,
+          options.getAuthority(),
+          options.getUserAgent(),
+          options.getEagAttributes(),
+          options.getHttpConnectProxiedSocketAddress(),
+          tooManyPingsRunnable,
+          channelCredentials);
       if (enableKeepAlive) {
-        transport.enableKeepAlive(true, keepAliveDelayNanos, keepAliveTimeoutNanos);
+        transport.enableKeepAlive(
+            true, keepAliveTimeNanosState.get(), keepAliveTimeoutNanos, keepAliveWithoutCalls);
       }
       return transport;
     }
 
+    @Override
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return scheduledExecutorService;
+    }
+
+    @Nullable
+    @CheckReturnValue
+    @Override
+    public SwapChannelCredentialsResult swapChannelCredentials(ChannelCredentials channelCreds) {
+      SslSocketFactoryResult result = sslSocketFactoryFrom(channelCreds);
+      if (result.error != null) {
+        return null;
+      }
+      ClientTransportFactory factory = new OkHttpTransportFactory(
+          executorPool,
+          scheduledExecutorServicePool,
+          socketFactory,
+          result.factory,
+          hostnameVerifier,
+          connectionSpec,
+          maxMessageSize,
+          enableKeepAlive,
+          keepAliveTimeNanos,
+          keepAliveTimeoutNanos,
+          flowControlWindow,
+          keepAliveWithoutCalls,
+          maxInboundMetadataSize,
+          transportTracerFactory,
+          useGetForSafeMethods,
+          channelCredentials);
+      return new SwapChannelCredentialsResult(factory, result.callCredentials);
+    }
+
     @Override
     public void close() {
       if (closed) {
@@ -338,9 +896,13 @@ public void close() {
       }
       closed = true;
 
-      if (usingSharedExecutor) {
-        SharedResourceHolder.release(SHARED_EXECUTOR, (ExecutorService) executor);
-      }
+      executorPool.returnObject(executor);
+      scheduledExecutorServicePool.returnObject(scheduledExecutorService);
+    }
+
+    @Override
+    public Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+      return OkHttpChannelBuilder.getSupportedSocketAddressTypes();
     }
   }
 }
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelProvider.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelProvider.java
index f98780fc480..bf2a9be6fee 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelProvider.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpChannelProvider.java
@@ -1,39 +1,27 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
+import io.grpc.ChannelCredentials;
 import io.grpc.Internal;
+import io.grpc.InternalServiceProviders;
 import io.grpc.ManagedChannelProvider;
-import io.grpc.internal.GrpcUtil;
+import java.net.SocketAddress;
+import java.util.Collection;
 
 /**
  * Provider for {@link OkHttpChannelBuilder} instances.
@@ -48,7 +36,7 @@ public boolean isAvailable() {
 
   @Override
   public int priority() {
-    return (GrpcUtil.IS_RESTRICTED_APPENGINE || isAndroid()) ? 8 : 3;
+    return InternalServiceProviders.isAndroid(getClass().getClassLoader()) ? 8 : 3;
   }
 
   @Override
@@ -60,4 +48,20 @@ public OkHttpChannelBuilder builderForAddress(String name, int port) {
   public OkHttpChannelBuilder builderForTarget(String target) {
     return OkHttpChannelBuilder.forTarget(target);
   }
+
+  @Override
+  public NewChannelBuilderResult newChannelBuilder(String target, ChannelCredentials creds) {
+    OkHttpChannelBuilder.SslSocketFactoryResult result =
+        OkHttpChannelBuilder.sslSocketFactoryFrom(creds);
+    if (result.error != null) {
+      return NewChannelBuilderResult.error(result.error);
+    }
+    return NewChannelBuilderResult.channelBuilder(new OkHttpChannelBuilder(
+        target, creds, result.callCredentials, result.factory));
+  }
+
+  @Override
+  protected Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+    return OkHttpChannelBuilder.getSupportedSocketAddressTypes();
+  }
 }
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientStream.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientStream.java
index 465db93a45a..8dd55d9f23e 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientStream.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientStream.java
@@ -1,113 +1,116 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
 
+import com.google.common.io.BaseEncoding;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
 import io.grpc.Attributes;
+import io.grpc.CallOptions;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.Status;
-import io.grpc.internal.ClientStreamListener;
-import io.grpc.internal.GrpcUtil;
-import io.grpc.internal.Http2ClientStream;
+import io.grpc.internal.AbstractClientStream;
+import io.grpc.internal.Http2ClientStreamTransportState;
 import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.TransportTracer;
 import io.grpc.internal.WritableBuffer;
 import io.grpc.okhttp.internal.framed.ErrorCode;
 import io.grpc.okhttp.internal.framed.Header;
-import java.util.ArrayDeque;
+import io.perfmark.PerfMark;
+import io.perfmark.Tag;
+import io.perfmark.TaskCloseable;
 import java.util.List;
-import java.util.Queue;
-import javax.annotation.concurrent.GuardedBy;
 import okio.Buffer;
 
 /**
  * Client stream for the okhttp transport.
  */
-class OkHttpClientStream extends Http2ClientStream {
-
-  private static final int WINDOW_UPDATE_THRESHOLD = Utils.DEFAULT_WINDOW_SIZE / 2;
+class OkHttpClientStream extends AbstractClientStream {
 
   private static final Buffer EMPTY_BUFFER = new Buffer();
 
-  @GuardedBy("lock")
-  private int window = Utils.DEFAULT_WINDOW_SIZE;
-  @GuardedBy("lock")
-  private int processedWindow = Utils.DEFAULT_WINDOW_SIZE;
+  public static final int ABSENT_ID = -1;
+
   private final MethodDescriptor<?, ?> method;
-  /** {@code null} iff start has been called. */
-  private Metadata headers;
-  private final AsyncFrameWriter frameWriter;
-  private final OutboundFlowController outboundFlow;
-  private final OkHttpClientTransport transport;
-  private final Object lock;
+
   private final String userAgent;
   private final StatsTraceContext statsTraceCtx;
   private String authority;
-  private Object outboundFlowState;
-  private volatile int id = ABSENT_ID;
-  @GuardedBy("lock")
-  private List<Header> requestHeaders;
-  /**
-   * Null iff {@link #requestHeaders} is null.  Non-null iff neither {@link #sendCancel} nor
-   * {@link #start(int)} have been called.
-   */
-  @GuardedBy("lock")
-  private Queue<PendingData> pendingData = new ArrayDeque<PendingData>();
-  @GuardedBy("lock")
-  private boolean cancelSent = false;
+  private final TransportState state;
+  private final Sink sink = new Sink();
+  private final Attributes attributes;
+
+  private boolean useGet = false;
 
   OkHttpClientStream(
       MethodDescriptor<?, ?> method,
       Metadata headers,
-      AsyncFrameWriter frameWriter,
+      ExceptionHandlingFrameWriter frameWriter,
       OkHttpClientTransport transport,
       OutboundFlowController outboundFlow,
       Object lock,
       int maxMessageSize,
+      int initialWindowSize,
       String authority,
       String userAgent,
-      StatsTraceContext statsTraceCtx) {
-    super(new OkHttpWritableBufferAllocator(), maxMessageSize, statsTraceCtx);
+      StatsTraceContext statsTraceCtx,
+      TransportTracer transportTracer,
+      CallOptions callOptions,
+      boolean useGetForSafeMethods) {
+    super(
+        new OkHttpWritableBufferAllocator(),
+        statsTraceCtx,
+        transportTracer,
+        headers,
+        callOptions,
+        useGetForSafeMethods && method.isSafe());
     this.statsTraceCtx = checkNotNull(statsTraceCtx, "statsTraceCtx");
     this.method = method;
-    this.headers = headers;
-    this.frameWriter = frameWriter;
-    this.transport = transport;
-    this.outboundFlow = outboundFlow;
-    this.lock = lock;
     this.authority = authority;
     this.userAgent = userAgent;
+    // OkHttpClientStream is only created after the transport has finished connecting,
+    // so it is safe to read the transport attributes.
+    // We make a copy here for convenience, even though we can ask the transport.
+    this.attributes = transport.getAttributes();
+    this.state =
+        new TransportState(
+            maxMessageSize,
+            statsTraceCtx,
+            lock,
+            frameWriter,
+            outboundFlow,
+            transport,
+            initialWindowSize,
+            method.getFullMethodName(),
+            callOptions);
+  }
+
+  @Override
+  protected TransportState transportState() {
+    return state;
+  }
+
+  @Override
+  protected Sink abstractClientStreamSink() {
+    return sink;
   }
 
   /**
@@ -117,206 +120,310 @@ public MethodDescriptor.MethodType getType() {
     return method.getType();
   }
 
-  @Override
-  public void request(final int numMessages) {
-    synchronized (lock) {
-      requestMessagesFromDeframer(numMessages);
-    }
-  }
-
-  @Override
-  public int id() {
-    return id;
+  /**
+   * Returns whether the stream uses GET. This is not known until after {@link Sink#writeHeaders} is
+   * invoked.
+   */
+  boolean useGet() {
+    return useGet;
   }
 
   @Override
   public void setAuthority(String authority) {
-    checkState(listener() == null, "must be call before start");
     this.authority = checkNotNull(authority, "authority");
   }
 
   @Override
   public Attributes getAttributes() {
-    return Attributes.EMPTY;
+    return attributes;
   }
 
-  @Override
-  public void start(ClientStreamListener listener) {
-    super.start(listener);
-    String defaultPath = "/" + method.getFullMethodName();
-    headers.discardAll(GrpcUtil.USER_AGENT_KEY);
-    List<Header> requestHeaders =
-        Headers.createRequestHeaders(headers, defaultPath, authority, userAgent);
-    headers = null;
-    synchronized (lock) {
-      this.requestHeaders = requestHeaders;
-      transport.streamReadyToStart(this);
+  class Sink implements AbstractClientStream.Sink {
+    @Override
+    public void writeHeaders(Metadata metadata, byte[] payload) {
+      try (TaskCloseable ignore = PerfMark.traceTask("OkHttpClientStream$Sink.writeHeaders")) {
+        String defaultPath = "/" + method.getFullMethodName();
+        if (payload != null) {
+          useGet = true;
+          defaultPath += "?" + BaseEncoding.base64().encode(payload);
+        }
+        synchronized (state.lock) {
+          state.streamReady(metadata, defaultPath);
+        }
+      }
     }
-  }
 
-  @GuardedBy("lock")
-  public void start(int id) {
-    checkState(this.id == ABSENT_ID, "the stream has been started with id %s", this.id);
-    this.id = id;
-
-    if (pendingData != null) {
-      // Only happens when the stream has neither been started nor cancelled.
-      frameWriter.synStream(false, false, id, 0, requestHeaders);
-      statsTraceCtx.clientHeadersSent();
-      requestHeaders = null;
-
-      boolean flush = false;
-      while (!pendingData.isEmpty()) {
-        PendingData data = pendingData.poll();
-        outboundFlow.data(data.endOfStream, id, data.buffer, false);
-        if (data.flush) {
-          flush = true;
+    @Override
+    public void writeFrame(
+        WritableBuffer frame, boolean endOfStream, boolean flush, int numMessages) {
+      try (TaskCloseable ignore = PerfMark.traceTask("OkHttpClientStream$Sink.writeFrame")) {
+        Buffer buffer;
+        if (frame == null) {
+          buffer = EMPTY_BUFFER;
+        } else {
+          buffer = ((OkHttpWritableBuffer) frame).buffer();
+          int size = (int) buffer.size();
+          if (size > 0) {
+            onSendingBytes(size);
+          }
+        }
+
+        synchronized (state.lock) {
+          state.sendBuffer(buffer, endOfStream, flush);
+          getTransportTracer().reportMessageSent(numMessages);
         }
       }
-      if (flush) {
-        outboundFlow.flush();
+    }
+
+    @Override
+    public void cancel(Status reason) {
+      try (TaskCloseable ignore = PerfMark.traceTask("OkHttpClientStream$Sink.cancel")) {
+        synchronized (state.lock) {
+          state.cancel(reason, true, null);
+        }
       }
-      pendingData = null;
     }
   }
 
-  /**
-   * Notification that this stream was allocated for the connection. This means the stream has
-   * passed through any delay caused by MAX_CONCURRENT_STREAMS.
-   */
-  public void allocated() {
-    // Now that the stream has actually been initialized, call the listener's onReady callback if
-    // appropriate.
-    onStreamAllocated();
-  }
+  class TransportState extends Http2ClientStreamTransportState
+      implements OutboundFlowController.Stream {
+    private final int initialWindowSize;
+    private final Object lock;
+    @GuardedBy("lock")
+    private List<Header> requestHeaders;
+    @GuardedBy("lock")
+    private Buffer pendingData = new Buffer();
+    private boolean pendingDataHasEndOfStream = false;
+    private boolean flushPendingData = false;
+    @GuardedBy("lock")
+    private boolean cancelSent = false;
+    @GuardedBy("lock")
+    private int window;
+    @GuardedBy("lock")
+    private int processedWindow;
+    @GuardedBy("lock")
+    private final ExceptionHandlingFrameWriter frameWriter;
+    @GuardedBy("lock")
+    private final OutboundFlowController outboundFlow;
+    @GuardedBy("lock")
+    private final OkHttpClientTransport transport;
+    /** True iff neither {@link #cancel} nor {@link #start(int)} have been called. */
+    @GuardedBy("lock")
+    private boolean canStart = true;
+    private final Tag tag;
+    @GuardedBy("lock")
+    private OutboundFlowController.StreamState outboundFlowState;
+    private int id = ABSENT_ID;
 
-  void onStreamSentBytes(int numBytes) {
-    onSentBytes(numBytes);
-  }
+    public TransportState(
+        int maxMessageSize,
+        StatsTraceContext statsTraceCtx,
+        Object lock,
+        ExceptionHandlingFrameWriter frameWriter,
+        OutboundFlowController outboundFlow,
+        OkHttpClientTransport transport,
+        int initialWindowSize,
+        String methodName,
+        CallOptions options) {
+      super(maxMessageSize, statsTraceCtx, OkHttpClientStream.this.getTransportTracer(), options);
+      this.lock = checkNotNull(lock, "lock");
+      this.frameWriter = frameWriter;
+      this.outboundFlow = outboundFlow;
+      this.transport = transport;
+      this.window = initialWindowSize;
+      this.processedWindow = initialWindowSize;
+      this.initialWindowSize = initialWindowSize;
+      tag = PerfMark.createTag(methodName);
+    }
 
-  /**
-   * Must be called with holding the transport lock.
-   */
-  @GuardedBy("lock")
-  public void transportHeadersReceived(List<Header> headers, boolean endOfStream) {
-    if (endOfStream) {
-      transportTrailersReceived(Utils.convertTrailers(headers));
-    } else {
-      transportHeadersReceived(Utils.convertHeaders(headers));
+    @SuppressWarnings("GuardedBy")
+    @GuardedBy("lock")
+    public void start(int streamId) {
+      checkState(id == ABSENT_ID, "the stream has been started with id %s", streamId);
+      id = streamId;
+      outboundFlowState = outboundFlow.createState(this, streamId);
+      // TODO(b/145386688): This access should be guarded by 'OkHttpClientStream.this.state.lock';
+      // instead found: 'this.lock'
+      state.onStreamAllocated();
+
+      if (canStart) {
+        // Only happens when the stream has neither been started nor cancelled.
+        frameWriter.synStream(useGet, false, id, 0, requestHeaders);
+        statsTraceCtx.clientOutboundHeaders();
+        requestHeaders = null;
+
+        if (pendingData.size() > 0) {
+          outboundFlow.data(
+              pendingDataHasEndOfStream, outboundFlowState, pendingData, flushPendingData);
+
+        }
+        canStart = false;
+      }
     }
-  }
 
-  /**
-   * Must be called with holding the transport lock.
-   */
-  @GuardedBy("lock")
-  public void transportDataReceived(okio.Buffer frame, boolean endOfStream) {
-    long length = frame.size();
-    window -= length;
-    if (window < 0) {
-      frameWriter.rstStream(id(), ErrorCode.FLOW_CONTROL_ERROR);
-      transport.finishStream(id(), Status.INTERNAL.withDescription(
-          "Received data size exceeded our receiving window size"), null);
-      return;
+    @GuardedBy("lock")
+    @Override
+    protected void onStreamAllocated() {
+      super.onStreamAllocated();
+      getTransportTracer().reportLocalStreamStarted();
     }
-    super.transportDataReceived(new OkHttpReadableBuffer(frame), endOfStream);
-  }
 
-  @Override
-  protected void sendFrame(WritableBuffer frame, boolean endOfStream, boolean flush) {
-    Buffer buffer;
-    if (frame == null) {
-      buffer = EMPTY_BUFFER;
-    } else {
-      buffer = ((OkHttpWritableBuffer) frame).buffer();
-      int size = (int) buffer.size();
-      if (size > 0) {
-        onSendingBytes(size);
-      }
+    @GuardedBy("lock")
+    @Override
+    protected void http2ProcessingFailed(Status status, boolean stopDelivery, Metadata trailers) {
+      cancel(status, stopDelivery, trailers);
     }
 
-    synchronized (lock) {
-      if (cancelSent) {
-        return;
-      }
-      if (pendingData != null) {
-        // Stream is pending start, queue the data.
-        pendingData.add(new PendingData(buffer, endOfStream, flush));
-      } else {
-        checkState(id() != ABSENT_ID, "streamId should be set");
-        // If buffer > frameWriter.maxDataLength() the flow-controller will ensure that it is
-        // properly chunked.
-        outboundFlow.data(endOfStream, id(), buffer, flush);
-      }
+    @Override
+    @GuardedBy("lock")
+    public void deframeFailed(Throwable cause) {
+      http2ProcessingFailed(Status.fromThrowable(cause), true, new Metadata());
     }
-  }
 
-  @Override
-  protected void returnProcessedBytes(int processedBytes) {
-    synchronized (lock) {
+    @Override
+    @GuardedBy("lock")
+    public void bytesRead(int processedBytes) {
       processedWindow -= processedBytes;
-      if (processedWindow <= WINDOW_UPDATE_THRESHOLD) {
-        int delta = Utils.DEFAULT_WINDOW_SIZE - processedWindow;
+      if (processedWindow <= initialWindowSize * Utils.DEFAULT_WINDOW_UPDATE_RATIO) {
+        int delta = initialWindowSize - processedWindow;
         window += delta;
         processedWindow += delta;
         frameWriter.windowUpdate(id(), delta);
       }
     }
-  }
 
-  @Override
-  protected void sendCancel(Status reason) {
-    synchronized (lock) {
+    @Override
+    @GuardedBy("lock")
+    public void deframerClosed(boolean hasPartialMessage) {
+      onEndOfStream();
+      super.deframerClosed(hasPartialMessage);
+    }
+
+    @Override
+    @GuardedBy("lock")
+    public void runOnTransportThread(final Runnable r) {
+      synchronized (lock) {
+        r.run();
+      }
+    }
+
+    /**
+     * Must be called with holding the transport lock.
+     */
+    @GuardedBy("lock")
+    public void transportHeadersReceived(List<Header> headers, boolean endOfStream) {
+      if (endOfStream) {
+        transportTrailersReceived(Utils.convertTrailers(headers));
+      } else {
+        transportHeadersReceived(Utils.convertHeaders(headers));
+      }
+    }
+
+    /**
+     * Must be called with holding the transport lock.
+     */
+    @GuardedBy("lock")
+    public void transportDataReceived(okio.Buffer frame, boolean endOfStream, int paddingLen) {
+      // We only support 16 KiB frames, and the max permitted in HTTP/2 is 16 MiB. This is verified
+      // in OkHttp's Http2 deframer. In addition, this code is after the data has been read.
+      int length = (int) frame.size();
+      window -= length + paddingLen;
+      processedWindow -= paddingLen;
+      if (window < 0) {
+        frameWriter.rstStream(id(), ErrorCode.FLOW_CONTROL_ERROR);
+        transport.finishStream(
+            id(),
+            Status.INTERNAL.withDescription(
+                "Received data size exceeded our receiving window size"),
+            PROCESSED, false, null, null);
+        return;
+      }
+      super.transportDataReceived(new OkHttpReadableBuffer(frame), endOfStream);
+    }
+
+    @GuardedBy("lock")
+    private void onEndOfStream() {
+      if (!isOutboundClosed()) {
+        // If server's end-of-stream is received before client sends end-of-stream, we just send a
+        // reset to server to fully close the server side stream.
+        transport.finishStream(id(),null, PROCESSED, false, ErrorCode.CANCEL, null);
+      } else {
+        transport.finishStream(id(), null, PROCESSED, false, null, null);
+      }
+    }
+
+    @SuppressWarnings("GuardedBy")
+    @GuardedBy("lock")
+    private void cancel(Status reason, boolean stopDelivery, Metadata trailers) {
       if (cancelSent) {
         return;
       }
       cancelSent = true;
-      if (pendingData != null) {
+      if (canStart) {
         // stream is pending.
-        transport.removePendingStream(this);
+        // TODO(b/145386688): This access should be guarded by 'this.transport.lock'; instead found:
+        // 'this.lock'
+        transport.removePendingStream(OkHttpClientStream.this);
         // release holding data, so they can be GCed or returned to pool earlier.
         requestHeaders = null;
-        for (PendingData data : pendingData) {
-          data.buffer.clear();
-        }
-        pendingData = null;
-        transportReportStatus(reason, true, new Metadata());
+        pendingData.clear();
+        canStart = false;
+        transportReportStatus(reason, true, trailers != null ? trailers : new Metadata());
       } else {
         // If pendingData is null, start must have already been called, which means synStream has
         // been called as well.
-        transport.finishStream(id(), reason, ErrorCode.CANCEL);
+        transport.finishStream(
+            id(), reason, PROCESSED, stopDelivery, ErrorCode.CANCEL, trailers);
       }
     }
-  }
 
-  @Override
-  public void remoteEndClosed() {
-    super.remoteEndClosed();
-    if (canSend()) {
-      // If server's end-of-stream is received before client sends end-of-stream, we just send a
-      // reset to server to fully close the server side stream.
-      frameWriter.rstStream(id(), ErrorCode.CANCEL);
+    @GuardedBy("lock")
+    private void sendBuffer(Buffer buffer, boolean endOfStream, boolean flush) {
+      if (cancelSent) {
+        return;
+      }
+      if (canStart) {
+        // Stream is pending start, queue the data.
+        int dataSize = (int) buffer.size();
+        pendingData.write(buffer, dataSize);
+        pendingDataHasEndOfStream |= endOfStream;
+        flushPendingData |= flush;
+      } else {
+        checkState(id() != ABSENT_ID, "streamId should be set");
+        // If buffer > frameWriter.maxDataLength() the flow-controller will ensure that it is
+        // properly chunked.
+        outboundFlow.data(endOfStream, outboundFlowState, buffer, flush);
+      }
     }
-    transport.finishStream(id(), null, null);
-  }
 
-  void setOutboundFlowState(Object outboundFlowState) {
-    this.outboundFlowState = outboundFlowState;
-  }
+    @SuppressWarnings("GuardedBy")
+    @GuardedBy("lock")
+    private void streamReady(Metadata metadata, String path) {
+      requestHeaders =
+          Headers.createRequestHeaders(
+              metadata,
+              path,
+              authority,
+              userAgent,
+              useGet,
+              transport.isUsingPlaintext());
+      // TODO(b/145386688): This access should be guarded by 'this.transport.lock'; instead found:
+      // 'this.lock'
+      transport.streamReadyToStart(OkHttpClientStream.this, authority);
+    }
 
-  Object getOutboundFlowState() {
-    return outboundFlowState;
-  }
+    Tag tag() {
+      return tag;
+    }
 
-  private static class PendingData {
-    Buffer buffer;
-    boolean endOfStream;
-    boolean flush;
+    int id() {
+      return id;
+    }
 
-    PendingData(Buffer buffer, boolean endOfStream, boolean flush) {
-      this.buffer = buffer;
-      this.endOfStream = endOfStream;
-      this.flush = flush;
+    OutboundFlowController.StreamState getOutboundFlowState() {
+      synchronized (lock) {
+        return outboundFlowState;
+      }
     }
   }
 }
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientTransport.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientTransport.java
index 225216a497c..4764a6a1387 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientTransport.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpClientTransport.java
@@ -1,65 +1,72 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
 import static com.google.common.base.Preconditions.checkState;
-import static io.grpc.internal.GrpcUtil.TIMER_SERVICE;
+import static io.grpc.okhttp.Utils.DEFAULT_WINDOW_SIZE;
+import static io.grpc.okhttp.Utils.DEFAULT_WINDOW_UPDATE_RATIO;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
 import com.google.common.base.Preconditions;
 import com.google.common.base.Stopwatch;
-import com.google.common.base.Ticker;
+import com.google.common.base.Supplier;
+import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.SettableFuture;
-import com.squareup.okhttp.Credentials;
-import com.squareup.okhttp.HttpUrl;
-import com.squareup.okhttp.Request;
-import com.squareup.okhttp.internal.http.StatusLine;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
 import io.grpc.Attributes;
 import io.grpc.CallOptions;
+import io.grpc.ChannelCredentials;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Grpc;
+import io.grpc.HttpConnectProxiedSocketAddress;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalLogId;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.SecurityLevel;
 import io.grpc.Status;
 import io.grpc.Status.Code;
 import io.grpc.StatusException;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.internal.CertificateUtils;
+import io.grpc.internal.ClientStreamListener.RpcProgress;
 import io.grpc.internal.ConnectionClientTransport;
+import io.grpc.internal.DisconnectError;
+import io.grpc.internal.GoAwayDisconnectError;
+import io.grpc.internal.GrpcAttributes;
 import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.Http2Ping;
+import io.grpc.internal.InUseStateAggregator;
 import io.grpc.internal.KeepAliveManager;
-import io.grpc.internal.LogId;
+import io.grpc.internal.KeepAliveManager.ClientKeepAlivePinger;
+import io.grpc.internal.NoopSslSession;
 import io.grpc.internal.SerializingExecutor;
-import io.grpc.internal.SharedResourceHolder;
+import io.grpc.internal.SimpleDisconnectError;
 import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.TransportTracer;
+import io.grpc.okhttp.ExceptionHandlingFrameWriter.TransportExceptionHandler;
+import io.grpc.okhttp.OkHttpChannelBuilder.OkHttpTransportFactory;
 import io.grpc.okhttp.internal.ConnectionSpec;
+import io.grpc.okhttp.internal.Credentials;
+import io.grpc.okhttp.internal.OkHostnameVerifier;
+import io.grpc.okhttp.internal.StatusLine;
 import io.grpc.okhttp.internal.framed.ErrorCode;
 import io.grpc.okhttp.internal.framed.FrameReader;
 import io.grpc.okhttp.internal.framed.FrameWriter;
@@ -68,26 +75,51 @@
 import io.grpc.okhttp.internal.framed.Http2;
 import io.grpc.okhttp.internal.framed.Settings;
 import io.grpc.okhttp.internal.framed.Variant;
+import io.grpc.okhttp.internal.proxy.HttpUrl;
+import io.grpc.okhttp.internal.proxy.Request;
+import io.perfmark.PerfMark;
 import java.io.EOFException;
 import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.net.InetSocketAddress;
 import java.net.Socket;
 import java.net.URI;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
 import java.util.Collections;
+import java.util.Deque;
 import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Random;
+import java.util.concurrent.BrokenBarrierException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.CyclicBarrier;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
+import javax.net.SocketFactory;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSocket;
 import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
 import okio.Buffer;
 import okio.BufferedSink;
 import okio.BufferedSource;
@@ -99,13 +131,19 @@
 /**
  * A okhttp-based {@link ConnectionClientTransport} implementation.
  */
-class OkHttpClientTransport implements ConnectionClientTransport {
+class OkHttpClientTransport implements ConnectionClientTransport, TransportExceptionHandler,
+      OutboundFlowController.Transport, ClientKeepAlivePinger.TransportWithDisconnectReason {
   private static final Map<ErrorCode, Status> ERROR_CODE_TO_STATUS = buildErrorCodeToStatusMap();
   private static final Logger log = Logger.getLogger(OkHttpClientTransport.class.getName());
-  private static final OkHttpClientStream[] EMPTY_STREAM_ARRAY = new OkHttpClientStream[0];
+  private static final String GRPC_ENABLE_PER_RPC_AUTHORITY_CHECK =
+          "GRPC_ENABLE_PER_RPC_AUTHORITY_CHECK";
+  static boolean enablePerRpcAuthorityCheck =
+          GrpcUtil.getFlag(GRPC_ENABLE_PER_RPC_AUTHORITY_CHECK, false);
+  private Socket sock;
+  private SSLSession sslSession;
 
   private static Map<ErrorCode, Status> buildErrorCodeToStatusMap() {
-    Map<ErrorCode, Status> errorToStatus = new EnumMap<ErrorCode, Status>(ErrorCode.class);
+    Map<ErrorCode, Status> errorToStatus = new EnumMap<>(ErrorCode.class);
     errorToStatus.put(ErrorCode.NO_ERROR,
         Status.INTERNAL.withDescription("No error: A GRPC status of OK should have been sent"));
     errorToStatus.put(ErrorCode.PROTOCOL_ERROR,
@@ -133,28 +171,53 @@ private static Map<ErrorCode, Status> buildErrorCodeToStatusMap() {
     return Collections.unmodifiableMap(errorToStatus);
   }
 
+  private static final Class<?> x509ExtendedTrustManagerClass;
+  private static final Method checkServerTrustedMethod;
+
+  static {
+    Class<?> x509ExtendedTrustManagerClass1 = null;
+    Method checkServerTrustedMethod1 = null;
+    try {
+      x509ExtendedTrustManagerClass1 = Class.forName("javax.net.ssl.X509ExtendedTrustManager");
+      checkServerTrustedMethod1 = x509ExtendedTrustManagerClass1.getMethod("checkServerTrusted",
+              X509Certificate[].class, String.class, Socket.class);
+    } catch (ClassNotFoundException e) {
+      // Per-rpc authority override via call options will be disallowed.
+    } catch (NoSuchMethodException e) {
+      // Should never happen since X509ExtendedTrustManager was introduced in Android API level 24
+      // along with checkServerTrusted.
+    }
+    x509ExtendedTrustManagerClass = x509ExtendedTrustManagerClass1;
+    checkServerTrustedMethod = checkServerTrustedMethod1;
+  }
+
   private final InetSocketAddress address;
   private final String defaultAuthority;
   private final String userAgent;
   private final Random random = new Random();
-  private final Ticker ticker;
+  // Returns new unstarted stopwatches
+  private final Supplier<Stopwatch> stopwatchFactory;
+  private final int initialWindowSize;
+  private final Variant variant;
   private Listener listener;
-  private FrameReader testFrameReader;
-  private AsyncFrameWriter frameWriter;
+  @GuardedBy("lock")
+  private ExceptionHandlingFrameWriter frameWriter;
   private OutboundFlowController outboundFlow;
   private final Object lock = new Object();
-  private final LogId logId = LogId.allocate(getClass().getName());
+  private final InternalLogId logId;
   @GuardedBy("lock")
   private int nextStreamId;
   @GuardedBy("lock")
-  private final Map<Integer, OkHttpClientStream> streams =
-      new HashMap<Integer, OkHttpClientStream>();
+  private final Map<Integer, OkHttpClientStream> streams = new HashMap<>();
   private final Executor executor;
   // Wrap on executor, to guarantee some operations be executed serially.
   private final SerializingExecutor serializingExecutor;
+  private final ScheduledExecutorService scheduler;
   private final int maxMessageSize;
   private int connectionUnacknowledgedBytesRead;
   private ClientFrameHandler clientFrameHandler;
+  // Caution: Not synchronized, new value can only be safely read after the connection is complete.
+  private Attributes attributes;
   /**
    * Indicates the transport is in go-away state: no new streams will be processed, but existing
    * streams may continue.
@@ -168,100 +231,216 @@ private static Map<ErrorCode, Status> buildErrorCodeToStatusMap() {
   @GuardedBy("lock")
   private boolean stopped;
   @GuardedBy("lock")
-  private boolean inUse;
+  private boolean hasStream;
+  private final SocketFactory socketFactory;
   private SSLSocketFactory sslSocketFactory;
+  private HostnameVerifier hostnameVerifier;
   private Socket socket;
   @GuardedBy("lock")
   private int maxConcurrentStreams = 0;
+  @SuppressWarnings("JdkObsolete") // Usage is bursty; want low memory usage when empty
   @GuardedBy("lock")
-  private LinkedList<OkHttpClientStream> pendingStreams = new LinkedList<OkHttpClientStream>();
+  private final Deque<OkHttpClientStream> pendingStreams = new LinkedList<>();
   private final ConnectionSpec connectionSpec;
-  private FrameWriter testFrameWriter;
-  private ScheduledExecutorService scheduler;
   private KeepAliveManager keepAliveManager;
   private boolean enableKeepAlive;
-  private long keepAliveDelayNanos;
+  private long keepAliveTimeNanos;
   private long keepAliveTimeoutNanos;
+  private boolean keepAliveWithoutCalls;
+  private final Runnable tooManyPingsRunnable;
+  private final int maxInboundMetadataSize;
+  private final boolean useGetForSafeMethods;
+  @GuardedBy("lock")
+  private final TransportTracer transportTracer;
+  private final TrustManager x509TrustManager;
+
+  @SuppressWarnings("serial")
+  private static class LruCache<T> extends LinkedHashMap<String, T> {
+    @Override
+    protected boolean removeEldestEntry(Map.Entry<String, T> eldest) {
+      return size() > 100;
+    }
+  }
+
+  @GuardedBy("lock")
+  private final Map<String, Status> authorityVerificationResults = new LruCache<>();
+
+  @GuardedBy("lock")
+  private final InUseStateAggregator<OkHttpClientStream> inUseState =
+      new InUseStateAggregator<OkHttpClientStream>() {
+        @Override
+        protected void handleInUse() {
+          listener.transportInUse(true);
+        }
+
+        @Override
+        protected void handleNotInUse() {
+          listener.transportInUse(false);
+        }
+      };
+  @GuardedBy("lock")
+  private InternalChannelz.Security securityInfo;
+
+  @VisibleForTesting
   @Nullable
-  private final InetSocketAddress proxyAddress;
-  @Nullable
-  private final String proxyUsername;
-  @Nullable
-  private final String proxyPassword;
+  final HttpConnectProxiedSocketAddress proxiedAddr;
+
+  @VisibleForTesting
+  int proxySocketTimeout = 30000;
 
   // The following fields should only be used for test.
   Runnable connectingCallback;
   SettableFuture<Void> connectedFuture;
 
-  OkHttpClientTransport(InetSocketAddress address, String authority, @Nullable String userAgent,
-      Executor executor, @Nullable SSLSocketFactory sslSocketFactory, ConnectionSpec connectionSpec,
-      int maxMessageSize, @Nullable InetSocketAddress proxyAddress, @Nullable String proxyUsername,
-      @Nullable String proxyPassword) {
+  public OkHttpClientTransport(
+          OkHttpTransportFactory transportFactory,
+          InetSocketAddress address,
+          String authority,
+          @Nullable String userAgent,
+          Attributes eagAttrs,
+          @Nullable HttpConnectProxiedSocketAddress proxiedAddr,
+          Runnable tooManyPingsRunnable,
+          ChannelCredentials channelCredentials) {
+    this(
+        transportFactory,
+        address,
+        authority,
+        userAgent,
+        eagAttrs,
+        GrpcUtil.STOPWATCH_SUPPLIER,
+        new Http2(),
+        proxiedAddr,
+        tooManyPingsRunnable,
+        channelCredentials);
+  }
+
+  private OkHttpClientTransport(
+          OkHttpTransportFactory transportFactory,
+          InetSocketAddress address,
+          String authority,
+          @Nullable String userAgent,
+          Attributes eagAttrs,
+          Supplier<Stopwatch> stopwatchFactory,
+          Variant variant,
+          @Nullable HttpConnectProxiedSocketAddress proxiedAddr,
+          Runnable tooManyPingsRunnable,
+          ChannelCredentials channelCredentials) {
     this.address = Preconditions.checkNotNull(address, "address");
     this.defaultAuthority = authority;
-    this.maxMessageSize = maxMessageSize;
-    this.executor = Preconditions.checkNotNull(executor, "executor");
-    serializingExecutor = new SerializingExecutor(executor);
+    this.maxMessageSize = transportFactory.maxMessageSize;
+    this.initialWindowSize = transportFactory.flowControlWindow;
+    this.executor = Preconditions.checkNotNull(transportFactory.executor, "executor");
+    serializingExecutor = new SerializingExecutor(transportFactory.executor);
+    this.scheduler = Preconditions.checkNotNull(
+        transportFactory.scheduledExecutorService, "scheduledExecutorService");
     // Client initiated streams are odd, server initiated ones are even. Server should not need to
     // use it. We start clients at 3 to avoid conflicting with HTTP negotiation.
     nextStreamId = 3;
-    this.sslSocketFactory = sslSocketFactory;
-    this.connectionSpec = Preconditions.checkNotNull(connectionSpec, "connectionSpec");
-    this.ticker = Ticker.systemTicker();
+    this.socketFactory = transportFactory.socketFactory == null
+        ? SocketFactory.getDefault() : transportFactory.socketFactory;
+    this.sslSocketFactory = transportFactory.sslSocketFactory;
+    this.hostnameVerifier = transportFactory.hostnameVerifier != null
+        ? transportFactory.hostnameVerifier : OkHostnameVerifier.INSTANCE;
+    this.connectionSpec = Preconditions.checkNotNull(
+        transportFactory.connectionSpec, "connectionSpec");
+    this.stopwatchFactory = Preconditions.checkNotNull(stopwatchFactory, "stopwatchFactory");
+    this.variant = Preconditions.checkNotNull(variant, "variant");
     this.userAgent = GrpcUtil.getGrpcUserAgent("okhttp", userAgent);
-    this.proxyAddress = proxyAddress;
-    this.proxyUsername = proxyUsername;
-    this.proxyPassword = proxyPassword;
+    this.proxiedAddr = proxiedAddr;
+    this.tooManyPingsRunnable =
+        Preconditions.checkNotNull(tooManyPingsRunnable, "tooManyPingsRunnable");
+    this.maxInboundMetadataSize = transportFactory.maxInboundMetadataSize;
+    this.transportTracer = transportFactory.transportTracerFactory.create();
+    this.logId = InternalLogId.allocate(getClass(), address.toString());
+    this.attributes = Attributes.newBuilder()
+        .set(GrpcAttributes.ATTR_CLIENT_EAG_ATTRS, eagAttrs).build();
+    this.useGetForSafeMethods = transportFactory.useGetForSafeMethods;
+    initTransportTracer();
+    TrustManager tempX509TrustManager;
+    if (channelCredentials instanceof TlsChannelCredentials
+        && x509ExtendedTrustManagerClass != null) {
+      try {
+        tempX509TrustManager = getTrustManager(
+                (TlsChannelCredentials) channelCredentials);
+      } catch (GeneralSecurityException e) {
+        tempX509TrustManager = null;
+        log.log(Level.WARNING, "Obtaining X509ExtendedTrustManager for the transport failed."
+            + "Per-rpc authority overrides will be disallowed.", e);
+      }
+    } else {
+      tempX509TrustManager = null;
+    }
+    x509TrustManager = tempX509TrustManager;
   }
 
   /**
    * Create a transport connected to a fake peer for test.
    */
+  @SuppressWarnings("AddressSelection") // An IP address always returns one address
   @VisibleForTesting
-  OkHttpClientTransport(String userAgent, Executor executor, FrameReader frameReader,
-      FrameWriter testFrameWriter, int nextStreamId, Socket socket, Ticker ticker,
-      @Nullable Runnable connectingCallback, SettableFuture<Void> connectedFuture,
-      int maxMessageSize) {
-    address = null;
-    this.maxMessageSize = maxMessageSize;
-    defaultAuthority = "notarealauthority:80";
-    this.userAgent = GrpcUtil.getGrpcUserAgent("okhttp", userAgent);
-    this.executor = Preconditions.checkNotNull(executor, "executor");
-    serializingExecutor = new SerializingExecutor(executor);
-    this.testFrameReader = Preconditions.checkNotNull(frameReader, "frameReader");
-    this.testFrameWriter = Preconditions.checkNotNull(testFrameWriter, "testFrameWriter");
-    this.socket = Preconditions.checkNotNull(socket, "socket");
-    this.nextStreamId = nextStreamId;
-    this.ticker = ticker;
-    this.connectionSpec = null;
+  OkHttpClientTransport(
+      OkHttpTransportFactory transportFactory,
+      String userAgent,
+      Supplier<Stopwatch> stopwatchFactory,
+      Variant variant,
+      @Nullable Runnable connectingCallback,
+      SettableFuture<Void> connectedFuture,
+      Runnable tooManyPingsRunnable) {
+    this(
+        transportFactory,
+        new InetSocketAddress("127.0.0.1", 80),
+        "notarealauthority:80",
+        userAgent,
+        Attributes.EMPTY,
+        stopwatchFactory,
+        variant,
+        null,
+        tooManyPingsRunnable,
+        null);
     this.connectingCallback = connectingCallback;
     this.connectedFuture = Preconditions.checkNotNull(connectedFuture, "connectedFuture");
-    this.proxyAddress = null;
-    this.proxyUsername = null;
-    this.proxyPassword = null;
+  }
+
+  // sslSocketFactory is set to null when use plaintext.
+  boolean isUsingPlaintext() {
+    return sslSocketFactory == null;
+  }
+
+  private void initTransportTracer() {
+    synchronized (lock) { // to make @GuardedBy linter happy
+      transportTracer.setFlowControlWindowReader(new TransportTracer.FlowControlReader() {
+        @Override
+        public TransportTracer.FlowControlWindows read() {
+          synchronized (lock) {
+            long local = outboundFlow == null ? -1 : outboundFlow.windowUpdate(null, 0);
+            // connectionUnacknowledgedBytesRead is only readable by ClientFrameHandler, so we
+            // provide a lower bound.
+            long remote = (long) (initialWindowSize * DEFAULT_WINDOW_UPDATE_RATIO);
+            return new TransportTracer.FlowControlWindows(local, remote);
+          }
+        }
+      });
+    }
   }
 
   /**
    * Enable keepalive with custom delay and timeout.
    */
-  void enableKeepAlive(boolean enable, long keepAliveDelayNanos,
-      long keepAliveTimeoutNanos) {
+  void enableKeepAlive(boolean enable, long keepAliveTimeNanos,
+      long keepAliveTimeoutNanos, boolean keepAliveWithoutCalls) {
     enableKeepAlive = enable;
-    this.keepAliveDelayNanos = keepAliveDelayNanos;
+    this.keepAliveTimeNanos = keepAliveTimeNanos;
     this.keepAliveTimeoutNanos = keepAliveTimeoutNanos;
-  }
-
-  private boolean isForTest() {
-    return address == null;
+    this.keepAliveWithoutCalls = keepAliveWithoutCalls;
   }
 
   @Override
   public void ping(final PingCallback callback, Executor executor) {
-    checkState(frameWriter != null);
     long data = 0;
     Http2Ping p;
     boolean writePing;
     synchronized (lock) {
+      checkState(frameWriter != null);
       if (stopped) {
         Http2Ping.notifyFailed(callback, executor, getPingFailure());
         return;
@@ -274,12 +453,15 @@ public void ping(final PingCallback callback, Executor executor) {
       } else {
         // set outstanding operation and then write the ping after releasing lock
         data = random.nextLong();
-        p = ping = new Http2Ping(data, Stopwatch.createStarted(ticker));
+        Stopwatch stopwatch = stopwatchFactory.get();
+        stopwatch.start();
+        p = ping = new Http2Ping(data, stopwatch);
         writePing = true;
+        transportTracer.reportKeepAliveSent();
+      }
+      if (writePing) {
+        frameWriter.ping(false, (int) (data >>> 32), (int) data);
       }
-    }
-    if (writePing) {
-      frameWriter.ping(false, (int) (data >>> 32), (int) data);
     }
     // If transport concurrently failed/stopped since we released the lock above, this could
     // immediately invoke callback (which we shouldn't do while holding a lock)
@@ -287,46 +469,153 @@ public void ping(final PingCallback callback, Executor executor) {
   }
 
   @Override
-  public OkHttpClientStream newStream(final MethodDescriptor<?, ?> method,
-      final Metadata headers, CallOptions callOptions, StatsTraceContext statsTraceCtx) {
+  public OkHttpClientStream newStream(
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions,
+      ClientStreamTracer[] tracers) {
     Preconditions.checkNotNull(method, "method");
     Preconditions.checkNotNull(headers, "headers");
-    Preconditions.checkNotNull(statsTraceCtx, "statsTraceCtx");
-    return new OkHttpClientStream(method, headers, frameWriter, OkHttpClientTransport.this,
-        outboundFlow, lock, maxMessageSize, defaultAuthority, userAgent, statsTraceCtx);
+    StatsTraceContext statsTraceContext =
+        StatsTraceContext.newClientContext(tracers, getAttributes(), headers);
+
+    // FIXME: it is likely wrong to pass the transportTracer here as it'll exit the lock's scope
+    synchronized (lock) { // to make @GuardedBy linter happy
+      return new OkHttpClientStream(
+          method,
+          headers,
+          frameWriter,
+          OkHttpClientTransport.this,
+          outboundFlow,
+          lock,
+          maxMessageSize,
+          initialWindowSize,
+          defaultAuthority,
+          userAgent,
+          statsTraceContext,
+          transportTracer,
+          callOptions,
+          useGetForSafeMethods);
+    }
   }
 
-  @Override
-  public OkHttpClientStream newStream(final MethodDescriptor<?, ?> method, final Metadata
-      headers) {
-    return newStream(method, headers, CallOptions.DEFAULT, StatsTraceContext.NOOP);
+  private TrustManager getTrustManager(TlsChannelCredentials tlsCreds)
+      throws GeneralSecurityException {
+    TrustManager[] tm;
+    // Using the same way of creating TrustManager from OkHttpChannelBuilder.sslSocketFactoryFrom()
+    if (tlsCreds.getTrustManagers() != null) {
+      tm = tlsCreds.getTrustManagers().toArray(new TrustManager[0]);
+    } else if (tlsCreds.getRootCertificates() != null) {
+      tm = CertificateUtils.createTrustManager(tlsCreds.getRootCertificates());
+    } else { // else use system default
+      TrustManagerFactory tmf = TrustManagerFactory.getInstance(
+          TrustManagerFactory.getDefaultAlgorithm());
+      tmf.init((KeyStore) null);
+      tm = tmf.getTrustManagers();
+    }
+    for (TrustManager trustManager: tm) {
+      if (trustManager instanceof X509TrustManager) {
+        return trustManager;
+      }
+    }
+    return null;
   }
 
   @GuardedBy("lock")
-  void streamReadyToStart(OkHttpClientStream clientStream) {
-    synchronized (lock) {
-      if (goAwayStatus != null) {
-        clientStream.transportReportStatus(goAwayStatus, true, new Metadata());
-      } else if (streams.size() >= maxConcurrentStreams) {
+  void streamReadyToStart(OkHttpClientStream clientStream, String authority) {
+    if (goAwayStatus != null) {
+      clientStream.transportState().transportReportStatus(
+          goAwayStatus, RpcProgress.MISCARRIED, true, new Metadata());
+    } else {
+      if (socket instanceof SSLSocket && !authority.equals(defaultAuthority)) {
+        Status authorityVerificationResult;
+        if (authorityVerificationResults.containsKey(authority)) {
+          authorityVerificationResult = authorityVerificationResults.get(authority);
+        } else {
+          authorityVerificationResult = verifyAuthority(authority);
+          authorityVerificationResults.put(authority, authorityVerificationResult);
+        }
+        if (!authorityVerificationResult.isOk()) {
+          if (enablePerRpcAuthorityCheck) {
+            clientStream.transportState().transportReportStatus(
+                    authorityVerificationResult, RpcProgress.PROCESSED, true, new Metadata());
+            return;
+          }
+        }
+      }
+      if (streams.size() >= maxConcurrentStreams) {
         pendingStreams.add(clientStream);
-        setInUse();
+        setInUse(clientStream);
       } else {
         startStream(clientStream);
       }
     }
   }
 
+  private Status verifyAuthority(String authority) {
+    Status authorityVerificationResult;
+    if (hostnameVerifier.verify(authority, ((SSLSocket) socket).getSession())) {
+      authorityVerificationResult = Status.OK;
+    } else {
+      authorityVerificationResult = Status.UNAVAILABLE.withDescription(String.format(
+              "HostNameVerifier verification failed for authority '%s'",
+              authority));
+    }
+    if (!authorityVerificationResult.isOk() && !enablePerRpcAuthorityCheck) {
+      log.log(Level.WARNING, String.format("HostNameVerifier verification failed for "
+                      + "authority '%s'. This will be an error in the future.",
+              authority));
+    }
+    if (authorityVerificationResult.isOk()) {
+      // The status is trivially assigned in this case, but we are still making use of the
+      // cache to keep track that a warning log had been logged for the authority when
+      // enablePerRpcAuthorityCheck is false. When we permanently enable the feature, the
+      // status won't need to be cached for case when x509TrustManager is null.
+      if (x509TrustManager == null) {
+        authorityVerificationResult = Status.UNAVAILABLE.withDescription(
+                String.format("Could not verify authority '%s' for the rpc with no "
+                                + "X509TrustManager available",
+                        authority));
+      } else if (x509ExtendedTrustManagerClass.isInstance(x509TrustManager)) {
+        try {
+          Certificate[] peerCertificates = sslSession.getPeerCertificates();
+          X509Certificate[] x509PeerCertificates =
+                  new X509Certificate[peerCertificates.length];
+          for (int i = 0; i < peerCertificates.length; i++) {
+            x509PeerCertificates[i] = (X509Certificate) peerCertificates[i];
+          }
+          checkServerTrustedMethod.invoke(x509TrustManager, x509PeerCertificates,
+                  "RSA", new SslSocketWrapper((SSLSocket) socket, authority));
+          authorityVerificationResult = Status.OK;
+        } catch (SSLPeerUnverifiedException | InvocationTargetException
+                 | IllegalAccessException e) {
+          authorityVerificationResult = Status.UNAVAILABLE.withCause(e).withDescription(
+                  "Peer verification failed");
+        }
+        if (authorityVerificationResult.getCause() != null) {
+          log.log(Level.WARNING, authorityVerificationResult.getDescription()
+                          + ". This will be an error in the future.",
+                  authorityVerificationResult.getCause());
+        } else {
+          log.log(Level.WARNING, authorityVerificationResult.getDescription()
+                  + ". This will be an error in the future.");
+        }
+      }
+    }
+    return authorityVerificationResult;
+  }
+
+  @SuppressWarnings("GuardedBy")
   @GuardedBy("lock")
   private void startStream(OkHttpClientStream stream) {
-    Preconditions.checkState(
-        stream.id() == OkHttpClientStream.ABSENT_ID, "StreamId already assigned");
+    checkState(
+        stream.transportState().id() == OkHttpClientStream.ABSENT_ID, "StreamId already assigned");
     streams.put(nextStreamId, stream);
-    setInUse();
-    stream.start(nextStreamId);
-    stream.allocated();
+    setInUse(stream);
+    // TODO(b/145386688): This access should be guarded by 'stream.transportState().lock'; instead
+    // found: 'this.lock'
+    stream.transportState().start(nextStreamId);
     // For unary and server streaming, there will be a data frame soon, no need to flush the header.
-    if (stream.getType() != MethodType.UNARY
-        && stream.getType() != MethodType.SERVER_STREAMING) {
+    if ((stream.getType() != MethodType.UNARY && stream.getType() != MethodType.SERVER_STREAMING)
+        || stream.useGet()) {
       frameWriter.flush();
     }
     if (nextStreamId >= Integer.MAX_VALUE - 2) {
@@ -360,7 +649,7 @@ private boolean startPendingStreams() {
   @GuardedBy("lock")
   void removePendingStream(OkHttpClientStream pendingStream) {
     pendingStreams.remove(pendingStream);
-    maybeClearInUse();
+    maybeClearInUse(pendingStream);
   }
 
   @Override
@@ -368,34 +657,38 @@ public Runnable start(Listener listener) {
     this.listener = Preconditions.checkNotNull(listener, "listener");
 
     if (enableKeepAlive) {
-      scheduler = SharedResourceHolder.get(TIMER_SERVICE);
-      keepAliveManager = new KeepAliveManager(this, scheduler, keepAliveDelayNanos,
-          keepAliveTimeoutNanos);
+      keepAliveManager = new KeepAliveManager(
+          new ClientKeepAlivePinger(this), scheduler, keepAliveTimeNanos, keepAliveTimeoutNanos,
+          keepAliveWithoutCalls);
+      keepAliveManager.onTransportStarted();
     }
 
-    frameWriter = new AsyncFrameWriter(this, serializingExecutor);
-    outboundFlow = new OutboundFlowController(this, frameWriter);
+    int maxQueuedControlFrames = 10000;
+    final AsyncSink asyncSink = AsyncSink.sink(serializingExecutor, this, maxQueuedControlFrames);
+    FrameWriter rawFrameWriter = asyncSink.limitControlFramesWriter(
+        variant.newWriter(Okio.buffer(asyncSink), true));
 
+    synchronized (lock) {
+      // Handle FrameWriter exceptions centrally, since there are many callers. Note that errors
+      // coming from rawFrameWriter are generally broken invariants/bugs, as AsyncSink does not
+      // propagate syscall errors through the FrameWriter. But we handle the AsyncSink failures with
+      // the same TransportExceptionHandler instance so it is all mixed back together.
+      frameWriter = new ExceptionHandlingFrameWriter(this, rawFrameWriter);
+      outboundFlow = new OutboundFlowController(this, frameWriter);
+    }
+    final CountDownLatch latch = new CountDownLatch(1);
+    final CountDownLatch latchForExtraThread = new CountDownLatch(1);
+    // The transport needs up to two threads to function once started,
+    // but only needs one during handshaking. Start another thread during handshaking
+    // to make sure there's still a free thread available. If the number of threads is exhausted,
+    // it is better to kill the transport than for all the transports to hang unable to send.
+    CyclicBarrier barrier = new CyclicBarrier(2);
     // Connecting in the serializingExecutor, so that some stream operations like synStream
     // will be executed after connected.
+
     serializingExecutor.execute(new Runnable() {
       @Override
       public void run() {
-        if (isForTest()) {
-          if (connectingCallback != null) {
-            connectingCallback.run();
-          }
-          clientFrameHandler = new ClientFrameHandler(testFrameReader);
-          executor.execute(clientFrameHandler);
-          synchronized (lock) {
-            maxConcurrentStreams = Integer.MAX_VALUE;
-            startPendingStreams();
-          }
-          frameWriter.becomeConnected(testFrameWriter, socket);
-          connectedFuture.set(null);
-          return;
-        }
-
         // Use closed source on failure so that the reader immediately shuts down.
         BufferedSource source = Okio.buffer(new Source() {
           @Override
@@ -409,25 +702,61 @@ public Timeout timeout() {
           }
 
           @Override
-          public void close() {}
+          public void close() {
+          }
         });
-        Variant variant = new Http2();
-        BufferedSink sink;
-        Socket sock;
         try {
-          if (proxyAddress == null) {
-            sock = new Socket(address.getAddress(), address.getPort());
-          } else {
-            sock = createHttpProxySocket(address, proxyAddress, proxyUsername, proxyPassword);
+          // This is a hack to make sure the connection preface and initial settings to be sent out
+          // without blocking the start. By doing this essentially prevents potential deadlock when
+          // network is not available during startup while another thread holding lock to send the
+          // initial preface.
+          try {
+            latch.await();
+            barrier.await(1000, TimeUnit.MILLISECONDS);
+          } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+          } catch (TimeoutException | BrokenBarrierException e) {
+            startGoAway(0, ErrorCode.INTERNAL_ERROR, Status.UNAVAILABLE
+                .withDescription("Timed out waiting for second handshake thread. "
+                    + "The transport executor pool may have run out of threads"));
+            return;
           }
 
+          if (proxiedAddr == null) {
+            sock = socketFactory.createSocket(address.getAddress(), address.getPort());
+          } else {
+            if (proxiedAddr.getProxyAddress() instanceof InetSocketAddress) {
+              sock = createHttpProxySocket(
+                  proxiedAddr.getTargetAddress(),
+                  (InetSocketAddress) proxiedAddr.getProxyAddress(),
+                  proxiedAddr.getUsername(),
+                  proxiedAddr.getPassword()
+              );
+            } else {
+              throw Status.INTERNAL.withDescription(
+                  "Unsupported SocketAddress implementation "
+                  + proxiedAddr.getProxyAddress().getClass()).asException();
+            }
+          }
           if (sslSocketFactory != null) {
-            sock = OkHttpTlsUpgrader.upgrade(
-                sslSocketFactory, sock, getOverridenHost(), getOverridenPort(), connectionSpec);
+            SSLSocket sslSocket = OkHttpTlsUpgrader.upgrade(
+                sslSocketFactory, hostnameVerifier, sock, getOverridenHost(), getOverridenPort(),
+                connectionSpec);
+            sslSession = sslSocket.getSession();
+            sock = sslSocket;
           }
           sock.setTcpNoDelay(true);
           source = Okio.buffer(Okio.source(sock));
-          sink = Okio.buffer(Okio.sink(sock));
+          asyncSink.becomeConnected(Okio.sink(sock), sock);
+
+          // The return value of OkHttpTlsUpgrader.upgrade is an SSLSocket that has this info
+          attributes = attributes.toBuilder()
+              .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, sock.getRemoteSocketAddress())
+              .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, sock.getLocalSocketAddress())
+              .set(Grpc.TRANSPORT_ATTR_SSL_SESSION, sslSession)
+              .set(GrpcAttributes.ATTR_SECURITY_LEVEL,
+                  sslSession == null ? SecurityLevel.NONE : SecurityLevel.PRIVACY_AND_INTEGRITY)
+              .build();
         } catch (StatusException e) {
           startGoAway(0, ErrorCode.INTERNAL_ERROR, e.getStatus());
           return;
@@ -436,39 +765,92 @@ public void close() {}
           return;
         } finally {
           clientFrameHandler = new ClientFrameHandler(variant.newReader(source, true));
-          executor.execute(clientFrameHandler);
+          latchForExtraThread.countDown();
         }
-
-        FrameWriter rawFrameWriter;
         synchronized (lock) {
-          socket = sock;
-          maxConcurrentStreams = Integer.MAX_VALUE;
-          startPendingStreams();
+          socket = Preconditions.checkNotNull(sock, "socket");
+          if (sslSession != null) {
+            securityInfo = new InternalChannelz.Security(new InternalChannelz.Tls(sslSession));
+          }
         }
+      }
+    });
 
-        rawFrameWriter = variant.newWriter(sink, true);
-        frameWriter.becomeConnected(rawFrameWriter, socket);
-
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
         try {
-          // Do these with the raw FrameWriter, so that they will be done in this thread,
-          // and before any possible pending stream operations.
-          rawFrameWriter.connectionPreface();
-          Settings settings = new Settings();
-          rawFrameWriter.settings(settings);
-        } catch (Exception e) {
-          onException(e);
-          return;
+          barrier.await(1000, TimeUnit.MILLISECONDS);
+          latchForExtraThread.await();
+        } catch (BrokenBarrierException | TimeoutException e) {
+          // Something bad happened, maybe too few threads available!
+          // This will be handled in the handshake thread.
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+        }
+      }
+    });
+    // Schedule to send connection preface & settings before any other write.
+    try {
+      sendConnectionPrefaceAndSettings();
+    } finally {
+      latch.countDown();
+    }
+
+    serializingExecutor.execute(new Runnable() {
+      @Override
+      public void run() {
+        if (connectingCallback != null) {
+          connectingCallback.run();
+        }
+        synchronized (lock) {
+          maxConcurrentStreams = Integer.MAX_VALUE;
+          checkState(pendingStreams.isEmpty(),
+              "Pending streams detected during transport start."
+                  + " RPCs should not be started before transport is ready.");
+        }
+        // ClientFrameHandler need to be started after connectionPreface / settings, otherwise it
+        // may send goAway immediately.
+        executor.execute(clientFrameHandler);
+        if (connectedFuture != null) {
+          connectedFuture.set(null);
         }
       }
     });
     return null;
   }
 
+  /**
+   * Should only be called once when the transport is first established.
+   */
+  private void sendConnectionPrefaceAndSettings() {
+    synchronized (lock) {
+      frameWriter.connectionPreface();
+      Settings settings = new Settings();
+      OkHttpSettingsUtil.set(settings, OkHttpSettingsUtil.INITIAL_WINDOW_SIZE, initialWindowSize);
+      frameWriter.settings(settings);
+      if (initialWindowSize > DEFAULT_WINDOW_SIZE) {
+        frameWriter.windowUpdate(
+                Utils.CONNECTION_STREAM_ID, initialWindowSize - DEFAULT_WINDOW_SIZE);
+      }
+    }
+  }
+
   private Socket createHttpProxySocket(InetSocketAddress address, InetSocketAddress proxyAddress,
-      String proxyUsername, String proxyPassword) throws IOException, StatusException {
+      String proxyUsername, String proxyPassword) throws StatusException {
+    Socket sock = null;
     try {
-      Socket sock = new Socket(proxyAddress.getAddress(), proxyAddress.getPort());
+      // The proxy address may not be resolved
+      if (proxyAddress.getAddress() != null) {
+        sock = socketFactory.createSocket(proxyAddress.getAddress(), proxyAddress.getPort());
+      } else {
+        sock =
+            socketFactory.createSocket(proxyAddress.getHostName(), proxyAddress.getPort());
+      }
       sock.setTcpNoDelay(true);
+      // A socket timeout is needed because lost network connectivity while reading from the proxy,
+      // can cause reading from the socket to hang.
+      sock.setSoTimeout(proxySocketTimeout);
 
       Source source = Okio.source(sock);
       BufferedSink sink = Okio.buffer(Okio.sink(sock));
@@ -476,7 +858,8 @@ private Socket createHttpProxySocket(InetSocketAddress address, InetSocketAddres
       // Prepare headers and request method line
       Request proxyRequest = createHttpProxyRequest(address, proxyUsername, proxyPassword);
       HttpUrl url = proxyRequest.httpUrl();
-      String requestLine = String.format("CONNECT %s:%d HTTP/1.1", url.host(), url.port());
+      String requestLine =
+          String.format(Locale.US, "CONNECT %s:%d HTTP/1.1", url.host(), url.port());
 
       // Write request to socket
       sink.writeUtf8(requestLine).writeUtf8("\r\n");
@@ -508,25 +891,32 @@ private Socket createHttpProxySocket(InetSocketAddress address, InetSocketAddres
           // ignored
         }
         String message = String.format(
+            Locale.US,
             "Response returned from proxy was not successful (expected 2xx, got %d %s). "
               + "Response body:\n%s",
             statusLine.code, statusLine.message, body.readUtf8());
         throw Status.UNAVAILABLE.withDescription(message).asException();
       }
+      // As the socket will be used for RPCs from here on, we want the socket timeout back to zero.
+      sock.setSoTimeout(0);
       return sock;
     } catch (IOException e) {
+      if (sock != null) {
+        GrpcUtil.closeQuietly(sock);
+      }
       throw Status.UNAVAILABLE.withDescription("Failed trying to connect with proxy").withCause(e)
           .asException();
     }
   }
 
   private Request createHttpProxyRequest(InetSocketAddress address, String proxyUsername,
-      String proxyPassword) {
+                                         String proxyPassword) {
     HttpUrl tunnelUrl = new HttpUrl.Builder()
         .scheme("https")
         .host(address.getHostName())
         .port(address.getPort())
         .build();
+
     Request.Builder request = new Request.Builder()
         .url(tunnelUrl)
         .header("Host", tunnelUrl.host() + ":" + tunnelUrl.port())
@@ -553,16 +943,19 @@ private static String readUtf8LineStrictUnbuffered(Source source) throws IOExcep
 
   @Override
   public String toString() {
-    return getLogId() + "(" + address + ")";
+    return MoreObjects.toStringHelper(this)
+        .add("logId", logId.getId())
+        .add("address", address)
+        .toString();
   }
 
   @Override
-  public LogId getLogId() {
+  public InternalLogId getLogId() {
     return logId;
   }
 
   /**
-   * Gets the overriden authority hostname.  If the authority is overriden to be an invalid
+   * Gets the overridden authority hostname.  If the authority is overridden to be an invalid
    * authority, uri.getHost() will (rightly) return null, since the authority is no longer
    * an actual service.  This method overrides the behavior for practical reasons.  For example,
    * if an authority is in the form "invalid_authority" (note the "_"), rather than return null,
@@ -595,39 +988,43 @@ int getOverridenPort() {
   }
 
   @Override
-  public void shutdown() {
+  public void shutdown(Status reason) {
     synchronized (lock) {
       if (goAwayStatus != null) {
         return;
       }
 
-      goAwayStatus = Status.UNAVAILABLE.withDescription("Transport stopped");
-      listener.transportShutdown(goAwayStatus);
+      goAwayStatus = reason;
+      listener.transportShutdown(goAwayStatus, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
       stopIfNecessary();
-      if (keepAliveManager != null) {
-        keepAliveManager.onTransportShutdown();
-        // KeepAliveManager should stop using the scheduler after onTransportShutdown gets called.
-        scheduler = SharedResourceHolder.release(TIMER_SERVICE, scheduler);
-      }
     }
   }
 
   @Override
   public void shutdownNow(Status reason) {
-    shutdown();
+    shutdownNow(reason, SimpleDisconnectError.SUBCHANNEL_SHUTDOWN);
+  }
+
+  @Override
+  public void shutdownNow(Status reason, DisconnectError disconnectError) {
+    shutdown(reason);
     synchronized (lock) {
       Iterator<Map.Entry<Integer, OkHttpClientStream>> it = streams.entrySet().iterator();
       while (it.hasNext()) {
         Map.Entry<Integer, OkHttpClientStream> entry = it.next();
         it.remove();
-        entry.getValue().transportReportStatus(reason, false, new Metadata());
+        entry.getValue().transportState().transportReportStatus(reason, false, new Metadata());
+        maybeClearInUse(entry.getValue());
       }
 
       for (OkHttpClientStream stream : pendingStreams) {
-        stream.transportReportStatus(reason, true, new Metadata());
+        // in cases such as the connection fails to ACK keep-alive, pending streams should have a
+        // chance to retry and be routed to another connection.
+        stream.transportState().transportReportStatus(
+            reason, RpcProgress.MISCARRIED, true, new Metadata());
+        maybeClearInUse(stream);
       }
       pendingStreams.clear();
-      maybeClearInUse();
 
       stopIfNecessary();
     }
@@ -635,16 +1032,22 @@ public void shutdownNow(Status reason) {
 
   @Override
   public Attributes getAttributes() {
-    // TODO(zhangkun83): fill channel security attributes
-    return Attributes.EMPTY;
+    return attributes;
   }
 
   /**
    * Gets all active streams as an array.
    */
-  OkHttpClientStream[] getActiveStreams() {
+  @Override
+  public OutboundFlowController.StreamState[] getActiveStreams() {
     synchronized (lock) {
-      return streams.values().toArray(EMPTY_STREAM_ARRAY);
+      OutboundFlowController.StreamState[] flowStreams =
+          new OutboundFlowController.StreamState[streams.size()];
+      int i = 0;
+      for (OkHttpClientStream stream : streams.values()) {
+        flowStreams[i++] = stream.transportState().getOutboundFlowState();
+      }
+      return flowStreams;
     }
   }
 
@@ -653,6 +1056,11 @@ ClientFrameHandler getHandler() {
     return clientFrameHandler;
   }
 
+  @VisibleForTesting
+  SocketFactory getSocketFactory() {
+    return socketFactory;
+  }
+
   @VisibleForTesting
   int getPendingStreamSize() {
     synchronized (lock) {
@@ -660,10 +1068,18 @@ int getPendingStreamSize() {
     }
   }
 
+  @VisibleForTesting
+  void setNextStreamId(int nextStreamId) {
+    synchronized (lock) {
+      this.nextStreamId = nextStreamId;
+    }
+  }
+
   /**
    * Finish all active streams due to an IOException, then close the transport.
    */
-  void onException(Throwable failureCause) {
+  @Override
+  public void onException(Throwable failureCause) {
     Preconditions.checkNotNull(failureCause, "failureCause");
     Status status = Status.UNAVAILABLE.withCause(failureCause);
     startGoAway(0, ErrorCode.INTERNAL_ERROR, status);
@@ -680,7 +1096,13 @@ private void startGoAway(int lastKnownStreamId, ErrorCode errorCode, Status stat
     synchronized (lock) {
       if (goAwayStatus == null) {
         goAwayStatus = status;
-        listener.transportShutdown(status);
+        GrpcUtil.Http2Error http2Error;
+        if (errorCode == null) {
+          http2Error = GrpcUtil.Http2Error.NO_ERROR;
+        } else {
+          http2Error = GrpcUtil.Http2Error.forCode(errorCode.httpCode);
+        }
+        listener.transportShutdown(status, new GoAwayDisconnectError(http2Error));
       }
       if (errorCode != null && !goAwaySent) {
         // Send GOAWAY with lastGoodStreamId of 0, since we don't expect any server-initiated
@@ -694,22 +1116,25 @@ private void startGoAway(int lastKnownStreamId, ErrorCode errorCode, Status stat
         Map.Entry<Integer, OkHttpClientStream> entry = it.next();
         if (entry.getKey() > lastKnownStreamId) {
           it.remove();
-          entry.getValue().transportReportStatus(status, false, new Metadata());
+          entry.getValue().transportState().transportReportStatus(
+              status, RpcProgress.REFUSED, false, new Metadata());
+          maybeClearInUse(entry.getValue());
         }
       }
 
       for (OkHttpClientStream stream : pendingStreams) {
-        stream.transportReportStatus(status, true, new Metadata());
+        stream.transportState().transportReportStatus(
+            status, RpcProgress.MISCARRIED, true, new Metadata());
+        maybeClearInUse(stream);
       }
       pendingStreams.clear();
-      maybeClearInUse();
 
       stopIfNecessary();
     }
   }
 
   /**
-   * Called when a stream is closed, we do things like:
+   * Called when a stream is closed. We do things like:
    * <ul>
    * <li>Removing the stream from the map.
    * <li>Optionally reporting the status.
@@ -719,9 +1144,17 @@ private void startGoAway(int lastKnownStreamId, ErrorCode errorCode, Status stat
    *
    * @param streamId the Id of the stream.
    * @param status the final status of this stream, null means no need to report.
+   * @param stopDelivery interrupt queued messages in the deframer
    * @param errorCode reset the stream with this ErrorCode if not null.
+   * @param trailers the trailers received if not null
    */
-  void finishStream(int streamId, @Nullable Status status, @Nullable ErrorCode errorCode) {
+  void finishStream(
+      int streamId,
+      @Nullable Status status,
+      RpcProgress rpcProgress,
+      boolean stopDelivery,
+      @Nullable ErrorCode errorCode,
+      @Nullable Metadata trailers) {
     synchronized (lock) {
       OkHttpClientStream stream = streams.remove(streamId);
       if (stream != null) {
@@ -729,14 +1162,18 @@ void finishStream(int streamId, @Nullable Status status, @Nullable ErrorCode err
           frameWriter.rstStream(streamId, ErrorCode.CANCEL);
         }
         if (status != null) {
-          boolean isCancelled = (status.getCode() == Code.CANCELLED
-              || status.getCode() == Code.DEADLINE_EXCEEDED);
-          stream.transportReportStatus(status, isCancelled, new Metadata());
+          stream
+              .transportState()
+              .transportReportStatus(
+                  status,
+                  rpcProgress,
+                  stopDelivery,
+                  trailers != null ? trailers : new Metadata());
         }
         if (!startPendingStreams()) {
           stopIfNecessary();
-          maybeClearInUse();
         }
+        maybeClearInUse(stream);
       }
     }
   }
@@ -745,7 +1182,7 @@ void finishStream(int streamId, @Nullable Status status, @Nullable ErrorCode err
    * When the transport is in goAway state, we should stop it once all active streams finish.
    */
   @GuardedBy("lock")
-  void stopIfNecessary() {
+  private void stopIfNecessary() {
     if (!(goAwayStatus != null && streams.isEmpty() && pendingStreams.isEmpty())) {
       return;
     }
@@ -754,6 +1191,10 @@ void stopIfNecessary() {
     }
     stopped = true;
 
+    if (keepAliveManager != null) {
+      keepAliveManager.onTransportTermination();
+    }
+
     if (ping != null) {
       ping.failed(getPingFailure());
       ping = null;
@@ -772,11 +1213,10 @@ void stopIfNecessary() {
   }
 
   @GuardedBy("lock")
-  private void maybeClearInUse() {
-    if (inUse) {
+  private void maybeClearInUse(OkHttpClientStream stream) {
+    if (hasStream) {
       if (pendingStreams.isEmpty() && streams.isEmpty()) {
-        inUse = false;
-        listener.transportInUse(false);
+        hasStream = false;
         if (keepAliveManager != null) {
           // We don't have any active streams. No need to do keepalives any more.
           // Again, we have to call this inside the lock to avoid the race between onTransportIdle
@@ -785,13 +1225,15 @@ private void maybeClearInUse() {
         }
       }
     }
+    if (stream.shouldBeCountedForInUse()) {
+      inUseState.updateObjectInUse(stream, false);
+    }
   }
 
   @GuardedBy("lock")
-  private void setInUse() {
-    if (!inUse) {
-      inUse = true;
-      listener.transportInUse(true);
+  private void setInUse(OkHttpClientStream stream) {
+    if (!hasStream) {
+      hasStream = true;
       if (keepAliveManager != null) {
         // We have a new stream. We might need to do keepalives now.
         // Note that we have to do this inside the lock to avoid calling
@@ -800,14 +1242,17 @@ private void setInUse() {
         keepAliveManager.onTransportActive();
       }
     }
+    if (stream.shouldBeCountedForInUse()) {
+      inUseState.updateObjectInUse(stream, true);
+    }
   }
 
-  private Throwable getPingFailure() {
+  private Status getPingFailure() {
     synchronized (lock) {
       if (goAwayStatus != null) {
-        return goAwayStatus.asException();
+        return goAwayStatus;
       } else {
-        return Status.UNAVAILABLE.withDescription("Connection closed").asException();
+        return Status.UNAVAILABLE.withDescription("Connection closed");
       }
     }
   }
@@ -834,11 +1279,36 @@ static Status toGrpcStatus(ErrorCode code) {
         "Unknown http2 error code: " + code.httpCode);
   }
 
+  @Override
+  public ListenableFuture<SocketStats> getStats() {
+    SettableFuture<SocketStats> ret = SettableFuture.create();
+    synchronized (lock) {
+      if (socket == null) {
+        ret.set(new SocketStats(
+            transportTracer.getStats(),
+            /*local=*/ null,
+            /*remote=*/ null,
+            new InternalChannelz.SocketOptions.Builder().build(),
+            /*security=*/ null));
+      } else {
+        ret.set(new SocketStats(
+            transportTracer.getStats(),
+            socket.getLocalSocketAddress(),
+            socket.getRemoteSocketAddress(),
+            Utils.getSocketOptions(socket),
+            securityInfo));
+      }
+      return ret;
+    }
+  }
+
   /**
    * Runnable which reads frames and dispatches them to in flight calls.
    */
-  @VisibleForTesting
   class ClientFrameHandler implements FrameReader.Handler, Runnable {
+
+    private final OkHttpFrameLogger logger =
+        new OkHttpFrameLogger(Level.FINE, OkHttpClientTransport.class);
     FrameReader frameReader;
     boolean firstSettings = true;
 
@@ -847,11 +1317,10 @@ class ClientFrameHandler implements FrameReader.Handler, Runnable {
     }
 
     @Override
+    @SuppressWarnings("Finally")
     public void run() {
       String threadName = Thread.currentThread().getName();
-      if (!GrpcUtil.IS_RESTRICTED_APPENGINE) {
-        Thread.currentThread().setName("OkHttpClientTransport");
-      }
+      Thread.currentThread().setName("OkHttpClientTransport");
       try {
         // Read until the underlying socket closes.
         while (frameReader.nextFrame(this)) {
@@ -862,35 +1331,56 @@ public void run() {
         // frameReader.nextFrame() returns false when the underlying read encounters an IOException,
         // it may be triggered by the socket closing, in such case, the startGoAway() will do
         // nothing, otherwise, we finish all streams since it's a real IO issue.
-        startGoAway(0, ErrorCode.INTERNAL_ERROR,
-            Status.UNAVAILABLE.withDescription("End of stream or IOException"));
+        Status status;
+        synchronized (lock) {
+          status = goAwayStatus;
+        }
+        if (status == null) {
+          status = Status.UNAVAILABLE.withDescription("End of stream or IOException");
+        }
+        startGoAway(0, ErrorCode.INTERNAL_ERROR, status);
       } catch (Throwable t) {
         // TODO(madongfly): Send the exception message to the server.
-        startGoAway(0, ErrorCode.PROTOCOL_ERROR, Status.UNAVAILABLE.withCause(t));
+        startGoAway(
+            0,
+            ErrorCode.PROTOCOL_ERROR,
+            Status.INTERNAL.withDescription("error in frame handler").withCause(t));
       } finally {
         try {
           frameReader.close();
         } catch (IOException ex) {
           log.log(Level.INFO, "Exception closing frame reader", ex);
+        } catch (RuntimeException e) {
+          // This same check is done in okhttp proper:
+          // https://github.com/square/okhttp/blob/3cc0f4917cbda03cb31617f8ead1e0aeb19de2fb/okhttp/src/main/kotlin/okhttp3/internal/-UtilJvm.kt#L270
+
+          // Conscrypt in Android 10 and 11 may throw closing an SSLSocket. This is safe to ignore.
+          // https://issuetracker.google.com/issues/177450597
+          if (!"bio == null".equals(e.getMessage())) {
+            throw e;
+          }
         }
         listener.transportTerminated();
-        if (!GrpcUtil.IS_RESTRICTED_APPENGINE) {
-          // Restore the original thread name.
-          Thread.currentThread().setName(threadName);
-        }
+        Thread.currentThread().setName(threadName);
       }
     }
 
     /**
-     * Handle a HTTP2 DATA frame.
+     * Handle an HTTP2 DATA frame.
      */
+    @SuppressWarnings("GuardedBy")
     @Override
-    public void data(boolean inFinished, int streamId, BufferedSource in, int length)
+    public void data(boolean inFinished, int streamId, BufferedSource in, int length,
+                     int paddedLength)
         throws IOException {
+      logger.logData(OkHttpFrameLogger.Direction.INBOUND,
+          streamId, in.getBuffer(), length, inFinished);
       OkHttpClientStream stream = getStream(streamId);
       if (stream == null) {
         if (mayHaveCreatedStream(streamId)) {
-          frameWriter.rstStream(streamId, ErrorCode.INVALID_STREAM);
+          synchronized (lock) {
+            frameWriter.rstStream(streamId, ErrorCode.STREAM_CLOSED);
+          }
           in.skip(length);
         } else {
           onError(ErrorCode.PROTOCOL_ERROR, "Received data for unknown stream: " + streamId);
@@ -901,16 +1391,22 @@ public void data(boolean inFinished, int streamId, BufferedSource in, int length
         in.require(length);
 
         Buffer buf = new Buffer();
-        buf.write(in.buffer(), length);
+        buf.write(in.getBuffer(), length);
+        PerfMark.event("OkHttpClientTransport$ClientFrameHandler.data",
+            stream.transportState().tag());
         synchronized (lock) {
-          stream.transportDataReceived(buf, inFinished);
+          // TODO(b/145386688): This access should be guarded by 'stream.transportState().lock';
+          // instead found: 'OkHttpClientTransport.this.lock'
+          stream.transportState().transportDataReceived(buf, inFinished, paddedLength - length);
         }
       }
 
       // connection window update
-      connectionUnacknowledgedBytesRead += length;
-      if (connectionUnacknowledgedBytesRead >= Utils.DEFAULT_WINDOW_SIZE / 2) {
-        frameWriter.windowUpdate(0, connectionUnacknowledgedBytesRead);
+      connectionUnacknowledgedBytesRead += paddedLength;
+      if (connectionUnacknowledgedBytesRead >= initialWindowSize * DEFAULT_WINDOW_UPDATE_RATIO) {
+        synchronized (lock) {
+          frameWriter.windowUpdate(0, connectionUnacknowledgedBytesRead);
+        }
         connectionUnacknowledgedBytesRead = 0;
       }
     }
@@ -918,6 +1414,7 @@ public void data(boolean inFinished, int streamId, BufferedSource in, int length
     /**
      * Handle HTTP2 HEADER and CONTINUATION frames.
      */
+    @SuppressWarnings("GuardedBy")
     @Override
     public void headers(boolean outFinished,
         boolean inFinished,
@@ -925,17 +1422,42 @@ public void headers(boolean outFinished,
         int associatedStreamId,
         List<Header> headerBlock,
         HeadersMode headersMode) {
+      logger.logHeaders(OkHttpFrameLogger.Direction.INBOUND, streamId, headerBlock, inFinished);
       boolean unknownStream = false;
+      Status failedStatus = null;
+      if (maxInboundMetadataSize != Integer.MAX_VALUE) {
+        int metadataSize = headerBlockSize(headerBlock);
+        if (metadataSize > maxInboundMetadataSize) {
+          failedStatus = Status.RESOURCE_EXHAUSTED.withDescription(
+              String.format(
+                  Locale.US,
+                  "Response %s metadata larger than %d: %d",
+                  inFinished ? "trailer" : "header",
+                  maxInboundMetadataSize,
+                  metadataSize));
+        }
+      }
       synchronized (lock) {
         OkHttpClientStream stream = streams.get(streamId);
         if (stream == null) {
           if (mayHaveCreatedStream(streamId)) {
-            frameWriter.rstStream(streamId, ErrorCode.INVALID_STREAM);
+            frameWriter.rstStream(streamId, ErrorCode.STREAM_CLOSED);
           } else {
             unknownStream = true;
           }
         } else {
-          stream.transportHeadersReceived(headerBlock, inFinished);
+          if (failedStatus == null) {
+            PerfMark.event("OkHttpClientTransport$ClientFrameHandler.headers",
+                stream.transportState().tag());
+            // TODO(b/145386688): This access should be guarded by 'stream.transportState().lock';
+            // instead found: 'OkHttpClientTransport.this.lock'
+            stream.transportState().transportHeadersReceived(headerBlock, inFinished);
+          } else {
+            if (!inFinished) {
+              frameWriter.rstStream(streamId, ErrorCode.CANCEL);
+            }
+            stream.transportState().transportReportStatus(failedStatus, false, new Metadata());
+          }
         }
       }
       if (unknownStream) {
@@ -944,13 +1466,40 @@ public void headers(boolean outFinished,
       }
     }
 
+    private int headerBlockSize(List<Header> headerBlock) {
+      // Calculate as defined for SETTINGS_MAX_HEADER_LIST_SIZE in RFC 7540 §6.5.2.
+      long size = 0;
+      for (int i = 0; i < headerBlock.size(); i++) {
+        Header header = headerBlock.get(i);
+        size += 32 + header.name.size() + header.value.size();
+      }
+      size = Math.min(size, Integer.MAX_VALUE);
+      return (int) size;
+    }
+
     @Override
     public void rstStream(int streamId, ErrorCode errorCode) {
-      finishStream(streamId, toGrpcStatus(errorCode).augmentDescription("Rst Stream"), null);
+      logger.logRstStream(OkHttpFrameLogger.Direction.INBOUND, streamId, errorCode);
+      Status status = toGrpcStatus(errorCode).augmentDescription("Rst Stream");
+      boolean stopDelivery =
+          (status.getCode() == Code.CANCELLED || status.getCode() == Code.DEADLINE_EXCEEDED);
+      synchronized (lock) {
+        OkHttpClientStream stream = streams.get(streamId);
+        if (stream != null) {
+          PerfMark.event("OkHttpClientTransport$ClientFrameHandler.rstStream",
+              stream.transportState().tag());
+          finishStream(
+              streamId, status,
+              errorCode == ErrorCode.REFUSED_STREAM ? RpcProgress.REFUSED : RpcProgress.PROCESSED,
+              stopDelivery, null, null);
+        }
+      }
     }
 
     @Override
     public void settings(boolean clearPrevious, Settings settings) {
+      logger.logSettings(OkHttpFrameLogger.Direction.INBOUND, settings);
+      boolean outboundWindowSizeIncreased = false;
       synchronized (lock) {
         if (OkHttpSettingsUtil.isSet(settings, OkHttpSettingsUtil.MAX_CONCURRENT_STREAMS)) {
           int receivedMaxConcurrentStreams = OkHttpSettingsUtil.get(
@@ -961,33 +1510,46 @@ public void settings(boolean clearPrevious, Settings settings) {
         if (OkHttpSettingsUtil.isSet(settings, OkHttpSettingsUtil.INITIAL_WINDOW_SIZE)) {
           int initialWindowSize = OkHttpSettingsUtil.get(
               settings, OkHttpSettingsUtil.INITIAL_WINDOW_SIZE);
-          outboundFlow.initialOutboundWindowSize(initialWindowSize);
+          outboundWindowSizeIncreased = outboundFlow.initialOutboundWindowSize(initialWindowSize);
         }
         if (firstSettings) {
+          attributes = listener.filterTransport(attributes);
           listener.transportReady();
           firstSettings = false;
         }
+
+        // The changed settings are not finalized until SETTINGS acknowledgment frame is sent. Any
+        // writes due to update in settings must be sent after SETTINGS acknowledgment frame,
+        // otherwise it will cause a stream error (RST_STREAM).
+        frameWriter.ackSettings(settings);
+
+        // send any pending bytes / streams
+        if (outboundWindowSizeIncreased) {
+          outboundFlow.writeStreams();
+        }
         startPendingStreams();
       }
-
-      frameWriter.ackSettings(settings);
     }
 
     @Override
     public void ping(boolean ack, int payload1, int payload2) {
+      long ackPayload = (((long) payload1) << 32) | (payload2 & 0xffffffffL);
+      logger.logPing(OkHttpFrameLogger.Direction.INBOUND, ackPayload);
       if (!ack) {
-        frameWriter.ping(true, payload1, payload2);
+        synchronized (lock) {
+          frameWriter.ping(true, payload1, payload2);
+        }
       } else {
         Http2Ping p = null;
-        long ackPayload = (((long) payload1) << 32) | (payload2 & 0xffffffffL);
         synchronized (lock) {
           if (ping != null) {
             if (ping.payload() == ackPayload) {
               p = ping;
               ping = null;
             } else {
-              log.log(Level.WARNING, String.format("Received unexpected ping ack. "
-                  + "Expecting %d, got %d", ping.payload(), ackPayload));
+              log.log(Level.WARNING, String.format(
+                  Locale.US, "Received unexpected ping ack. Expecting %d, got %d",
+                  ping.payload(), ackPayload));
             }
           } else {
             log.warning("Received unexpected ping ack. No ping outstanding");
@@ -1007,9 +1569,18 @@ public void ackSettings() {
 
     @Override
     public void goAway(int lastGoodStreamId, ErrorCode errorCode, ByteString debugData) {
+      logger.logGoAway(OkHttpFrameLogger.Direction.INBOUND, lastGoodStreamId, errorCode, debugData);
+      if (errorCode == ErrorCode.ENHANCE_YOUR_CALM) {
+        String data = debugData.utf8();
+        log.log(Level.WARNING, String.format(
+            "%s: Received GOAWAY with ENHANCE_YOUR_CALM. Debug data: %s", this, data));
+        if ("too_many_pings".equals(data)) {
+          tooManyPingsRunnable.run();
+        }
+      }
       Status status = GrpcUtil.Http2Error.statusForCode(errorCode.httpCode)
           .augmentDescription("Received Goaway");
-      if (debugData != null && debugData.size() > 0) {
+      if (debugData.size() > 0) {
         // If a debug message was provided, use it.
         status = status.augmentDescription(debugData.utf8());
       }
@@ -1019,19 +1590,25 @@ public void goAway(int lastGoodStreamId, ErrorCode errorCode, ByteString debugDa
     @Override
     public void pushPromise(int streamId, int promisedStreamId, List<Header> requestHeaders)
         throws IOException {
+      logger.logPushPromise(OkHttpFrameLogger.Direction.INBOUND,
+          streamId, promisedStreamId, requestHeaders);
       // We don't accept server initiated stream.
-      frameWriter.rstStream(streamId, ErrorCode.PROTOCOL_ERROR);
+      synchronized (lock) {
+        frameWriter.rstStream(streamId, ErrorCode.PROTOCOL_ERROR);
+      }
     }
 
     @Override
     public void windowUpdate(int streamId, long delta) {
+      logger.logWindowsUpdate(OkHttpFrameLogger.Direction.INBOUND, streamId, delta);
       if (delta == 0) {
         String errorMsg = "Received 0 flow control window increment.";
         if (streamId == 0) {
           onError(ErrorCode.PROTOCOL_ERROR, errorMsg);
         } else {
-          finishStream(streamId,
-              Status.INTERNAL.withDescription(errorMsg), ErrorCode.PROTOCOL_ERROR);
+          finishStream(
+              streamId, Status.INTERNAL.withDescription(errorMsg), RpcProgress.PROCESSED, false,
+              ErrorCode.PROTOCOL_ERROR, null);
         }
         return;
       }
@@ -1045,7 +1622,7 @@ public void windowUpdate(int streamId, long delta) {
 
         OkHttpClientStream stream = streams.get(streamId);
         if (stream != null) {
-          outboundFlow.windowUpdate(stream, (int) delta);
+          outboundFlow.windowUpdate(stream.transportState().getOutboundFlowState(), (int) delta);
         } else if (!mayHaveCreatedStream(streamId)) {
           unknownStream = true;
         }
@@ -1068,4 +1645,50 @@ public void alternateService(int streamId, String origin, ByteString protocol, S
       // TODO(madongfly): Deal with alternateService propagation
     }
   }
+
+  /**
+   * SSLSocket wrapper that provides a fake SSLSession for handshake session.
+   */
+  static final class SslSocketWrapper extends NoopSslSocket {
+
+    private final SSLSession sslSession;
+    private final SSLSocket sslSocket;
+
+    SslSocketWrapper(SSLSocket sslSocket, String peerHost) {
+      this.sslSocket = sslSocket;
+      this.sslSession = new FakeSslSession(peerHost);
+    }
+
+    @Override
+    public SSLSession getHandshakeSession() {
+      return this.sslSession;
+    }
+
+    @Override
+    public boolean isConnected() {
+      return sslSocket.isConnected();
+    }
+
+    @Override
+    public SSLParameters getSSLParameters() {
+      return sslSocket.getSSLParameters();
+    }
+  }
+
+  /**
+   * Fake SSLSession instance that provides the peer host name to verify for per-rpc check.
+   */
+  static class FakeSslSession extends NoopSslSession {
+
+    private final String peerHost;
+
+    FakeSslSession(String peerHost) {
+      this.peerHost = peerHost;
+    }
+
+    @Override
+    public String getPeerHost() {
+      return peerHost;
+    }
+  }
 }
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpFrameLogger.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpFrameLogger.java
new file mode 100644
index 00000000000..e54c1018111
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpFrameLogger.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright 2019 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.okhttp;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.okhttp.internal.framed.ErrorCode;
+import io.grpc.okhttp.internal.framed.Header;
+import io.grpc.okhttp.internal.framed.Settings;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import okio.Buffer;
+import okio.ByteString;
+
+class OkHttpFrameLogger {
+  private static final int BUFFER_LENGTH_THRESHOLD = 64;
+  private final Logger logger;
+  private final Level level;
+
+  OkHttpFrameLogger(Level level, Class<?> clazz) {
+    this(level, Logger.getLogger(clazz.getName()));
+  }
+
+  @VisibleForTesting
+  OkHttpFrameLogger(Level level, Logger logger) {
+    this.level = checkNotNull(level, "level");
+    this.logger = checkNotNull(logger, "logger");
+  }
+
+  private static String toString(Settings settings) {
+    EnumMap<SettingParams, Integer> map = new EnumMap<>(SettingParams.class);
+    for (SettingParams p : SettingParams.values()) {
+      // Only log set parameters.
+      if (settings.isSet(p.getBit())) {
+        map.put(p, settings.get(p.getBit()));
+      }
+    }
+    return map.toString();
+  }
+
+  private static String toString(Buffer buf) {
+    if (buf.size() <= BUFFER_LENGTH_THRESHOLD) {
+      // Log the entire buffer.
+      return buf.snapshot().hex();
+    }
+
+    // Otherwise just log the first 64 bytes.
+    int length = (int) Math.min(buf.size(), BUFFER_LENGTH_THRESHOLD);
+    return buf.snapshot(length).hex() + "...";
+  }
+
+  private boolean isEnabled() {
+    return logger.isLoggable(level);
+  }
+
+  void logData(Direction direction, int streamId, Buffer data, int length, boolean endStream) {
+    if (isEnabled()) {
+      logger.log(
+          level,
+          direction
+              + " DATA: streamId="
+              + streamId
+              + " endStream="
+              + endStream
+              + " length="
+              + length
+              + " bytes="
+              + toString(data));
+    }
+  }
+
+  void logHeaders(Direction direction, int streamId, List<Header> headers, boolean endStream) {
+    if (isEnabled()) {
+      logger.log(
+          level,
+          direction
+              + " HEADERS: streamId="
+              + streamId
+              + " headers="
+              + headers
+              + " endStream="
+              + endStream);
+    }
+  }
+
+  public void logPriority(
+      Direction direction, int streamId, int streamDependency, int weight, boolean exclusive) {
+    if (isEnabled()) {
+      logger.log(
+          level,
+          direction
+              + " PRIORITY: streamId="
+              + streamId
+              + " streamDependency="
+              + streamDependency
+              + " weight="
+              + weight
+              + " exclusive="
+              + exclusive);
+    }
+  }
+
+  void logRstStream(Direction direction, int streamId, ErrorCode errorCode) {
+    if (isEnabled()) {
+      logger.log(
+          level, direction + " RST_STREAM: streamId=" + streamId + " errorCode=" + errorCode);
+    }
+  }
+
+  void logSettingsAck(Direction direction) {
+    if (isEnabled()) {
+      logger.log(level, direction + " SETTINGS: ack=true");
+    }
+  }
+
+  void logSettings(Direction direction, Settings settings) {
+    if (isEnabled()) {
+      logger.log(level, direction + " SETTINGS: ack=false settings=" + toString(settings));
+    }
+  }
+
+  void logPing(Direction direction, long data) {
+    if (isEnabled()) {
+      logger.log(level, direction + " PING: ack=false bytes=" + data);
+    }
+  }
+
+  void logPingAck(Direction direction, long data) {
+    if (isEnabled()) {
+      logger.log(level, direction + " PING: ack=true bytes=" + data);
+    }
+  }
+
+  void logPushPromise(
+      Direction direction, int streamId, int promisedStreamId, List<Header> headers) {
+    if (isEnabled()) {
+      logger.log(
+          level,
+          direction
+              + " PUSH_PROMISE: streamId="
+              + streamId
+              + " promisedStreamId="
+              + promisedStreamId
+              + " headers="
+              + headers);
+    }
+  }
+
+  void logGoAway(Direction direction, int lastStreamId, ErrorCode errorCode, ByteString debugData) {
+    if (isEnabled()) {
+      logger.log(
+          level,
+          direction
+              + " GO_AWAY: lastStreamId="
+              + lastStreamId
+              + " errorCode="
+              + errorCode
+              + " length="
+              + debugData.size()
+              + " bytes="
+              + toString(new Buffer().write(debugData)));
+    }
+  }
+
+  void logWindowsUpdate(Direction direction, int streamId, long windowSizeIncrement) {
+    if (isEnabled()) {
+      logger.log(
+          level,
+          direction
+              + " WINDOW_UPDATE: streamId="
+              + streamId
+              + " windowSizeIncrement="
+              + windowSizeIncrement);
+    }
+  }
+
+  enum Direction {
+    INBOUND,
+    OUTBOUND
+  }
+
+  // Note the set bits in OkHttp's Settings are different from HTTP2 Specifications.
+  private enum SettingParams {
+    HEADER_TABLE_SIZE(1),
+    ENABLE_PUSH(2),
+    MAX_CONCURRENT_STREAMS(4),
+    MAX_FRAME_SIZE(5),
+    MAX_HEADER_LIST_SIZE(6),
+    INITIAL_WINDOW_SIZE(7);
+
+    private final int bit;
+
+    SettingParams(int bit) {
+      this.bit = bit;
+    }
+
+    public int getBit() {
+      return this.bit;
+    }
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpProtocolNegotiator.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpProtocolNegotiator.java
index b719ef6d932..0706a39d028 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpProtocolNegotiator.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpProtocolNegotiator.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
@@ -34,27 +19,39 @@
 import static com.google.common.base.Preconditions.checkNotNull;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.net.HostAndPort;
+import com.google.common.net.InetAddresses;
+import io.grpc.internal.GrpcUtil;
 import io.grpc.okhttp.internal.OptionalMethod;
 import io.grpc.okhttp.internal.Platform;
+import io.grpc.okhttp.internal.Platform.TlsExtensionType;
 import io.grpc.okhttp.internal.Protocol;
 import io.grpc.okhttp.internal.Util;
 import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.net.Socket;
-import java.security.Provider;
-import java.security.Security;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 import javax.annotation.Nullable;
+import javax.net.ssl.SSLParameters;
 import javax.net.ssl.SSLSocket;
 
 /**
  * A helper class located in package com.squareup.okhttp.internal for TLS negotiation.
  */
 class OkHttpProtocolNegotiator {
+  private static final Logger logger = Logger.getLogger(OkHttpProtocolNegotiator.class.getName());
   private static final Platform DEFAULT_PLATFORM = Platform.get();
   private static OkHttpProtocolNegotiator NEGOTIATOR =
       createNegotiator(OkHttpProtocolNegotiator.class.getClassLoader());
 
-  private final Platform platform;
+  protected final Platform platform;
 
   @VisibleForTesting
   OkHttpProtocolNegotiator(Platform platform) {
@@ -74,16 +71,18 @@ static OkHttpProtocolNegotiator createNegotiator(ClassLoader loader) {
     try {
       // Attempt to find Android 2.3+ APIs.
       loader.loadClass("com.android.org.conscrypt.OpenSSLSocketImpl");
-    } catch (ClassNotFoundException ignored) {
+    } catch (ClassNotFoundException e1) {
+      logger.log(Level.FINE, "Unable to find Conscrypt. Skipping", e1);
       try {
         // Older platform before being unbundled.
         loader.loadClass("org.apache.harmony.xnet.provider.jsse.OpenSSLSocketImpl");
-      } catch (ClassNotFoundException ignored2) {
+      } catch (ClassNotFoundException e2) {
+        logger.log(Level.FINE, "Unable to find any OpenSSLSocketImpl. Skipping", e2);
         android = false;
       }
     }
     return android
-        ? new AndroidNegotiator(DEFAULT_PLATFORM, AndroidNegotiator.DEFAULT_TLS_EXTENSION_TYPE)
+        ? new AndroidNegotiator(DEFAULT_PLATFORM)
         : new OkHttpProtocolNegotiator(DEFAULT_PLATFORM);
   }
 
@@ -104,7 +103,7 @@ public String negotiate(
 
       String negotiatedProtocol = getSelectedProtocol(sslSocket);
       if (negotiatedProtocol == null) {
-        throw new RuntimeException("protocol negotiation failed");
+        throw new RuntimeException("TLS ALPN negotiation failed with protocols: " + protocols);
       }
       return negotiatedProtocol;
     } finally {
@@ -127,36 +126,88 @@ public String getSelectedProtocol(SSLSocket socket) {
   static final class AndroidNegotiator extends OkHttpProtocolNegotiator {
     // setUseSessionTickets(boolean)
     private static final OptionalMethod<Socket> SET_USE_SESSION_TICKETS =
-        new OptionalMethod<Socket>(null, "setUseSessionTickets", Boolean.TYPE);
+        new OptionalMethod<>(null, "setUseSessionTickets", Boolean.TYPE);
     // setHostname(String)
     private static final OptionalMethod<Socket> SET_HOSTNAME =
-        new OptionalMethod<Socket>(null, "setHostname", String.class);
+        new OptionalMethod<>(null, "setHostname", String.class);
     // byte[] getAlpnSelectedProtocol()
     private static final OptionalMethod<Socket> GET_ALPN_SELECTED_PROTOCOL =
-        new OptionalMethod<Socket>(byte[].class, "getAlpnSelectedProtocol");
+        new OptionalMethod<>(byte[].class, "getAlpnSelectedProtocol");
     // setAlpnProtocol(byte[])
     private static final OptionalMethod<Socket> SET_ALPN_PROTOCOLS =
-        new OptionalMethod<Socket>(null, "setAlpnProtocols", byte[].class);
+        new OptionalMethod<>(null, "setAlpnProtocols", byte[].class);
     // byte[] getNpnSelectedProtocol()
     private static final OptionalMethod<Socket> GET_NPN_SELECTED_PROTOCOL =
-        new OptionalMethod<Socket>(byte[].class, "getNpnSelectedProtocol");
+        new OptionalMethod<>(byte[].class, "getNpnSelectedProtocol");
     // setNpnProtocol(byte[])
     private static final OptionalMethod<Socket> SET_NPN_PROTOCOLS =
-        new OptionalMethod<Socket>(null, "setNpnProtocols", byte[].class);
+        new OptionalMethod<>(null, "setNpnProtocols", byte[].class);
 
-    private static final TlsExtensionType DEFAULT_TLS_EXTENSION_TYPE =
-        pickTlsExtensionType(AndroidNegotiator.class.getClassLoader());
+    // Non-null on Android 10.0+.
+    // SSLSockets.isSupportedSocket(SSLSocket)
+    private static final Method SSL_SOCKETS_IS_SUPPORTED_SOCKET;
+    // SSLSockets.setUseSessionTickets(SSLSocket, boolean)
+    private static final Method SSL_SOCKETS_SET_USE_SESSION_TICKET;
+    // SSLParameters.setApplicationProtocols(String[])
+    private static final Method SET_APPLICATION_PROTOCOLS;
+    // SSLParameters.getApplicationProtocols()
+    private static final Method GET_APPLICATION_PROTOCOLS;
+    // SSLSocket.getApplicationProtocol()
+    private static final Method GET_APPLICATION_PROTOCOL;
 
-    enum TlsExtensionType {
-      ALPN_AND_NPN,
-      NPN,
-    }
+    // Non-null on Android 7.0+.
+    // SSLParameters.setServerNames(List<SNIServerName>)
+    private static final Method SET_SERVER_NAMES;
+    // SNIHostName(String)
+    private static final Constructor<?> SNI_HOST_NAME;
+
+    static {
+      // Attempt to find Android 10.0+ APIs.
+      Method setApplicationProtocolsMethod = null;
+      Method getApplicationProtocolsMethod = null;
+      Method getApplicationProtocolMethod = null;
+      Method sslSocketsIsSupportedSocketMethod = null;
+      Method sslSocketsSetUseSessionTicketsMethod = null;
+      try {
+        Class<?> sslParameters = SSLParameters.class;
+        setApplicationProtocolsMethod =
+            sslParameters.getMethod("setApplicationProtocols", String[].class);
+        getApplicationProtocolsMethod = sslParameters.getMethod("getApplicationProtocols");
+        getApplicationProtocolMethod = SSLSocket.class.getMethod("getApplicationProtocol");
+        Class<?> sslSockets = Class.forName("android.net.ssl.SSLSockets");
+        sslSocketsIsSupportedSocketMethod =
+            sslSockets.getMethod("isSupportedSocket", SSLSocket.class);
+        sslSocketsSetUseSessionTicketsMethod =
+            sslSockets.getMethod("setUseSessionTickets", SSLSocket.class, boolean.class);
+      } catch (ClassNotFoundException e) {
+        logger.log(Level.FINER, "Failed to find Android 10.0+ APIs", e);
+      } catch (NoSuchMethodException e) {
+        logger.log(Level.FINER, "Failed to find Android 10.0+ APIs", e);
+      }
+      SET_APPLICATION_PROTOCOLS = setApplicationProtocolsMethod;
+      GET_APPLICATION_PROTOCOLS = getApplicationProtocolsMethod;
+      GET_APPLICATION_PROTOCOL = getApplicationProtocolMethod;
+      SSL_SOCKETS_IS_SUPPORTED_SOCKET = sslSocketsIsSupportedSocketMethod;
+      SSL_SOCKETS_SET_USE_SESSION_TICKET = sslSocketsSetUseSessionTicketsMethod;
 
-    private final TlsExtensionType tlsExtensionType;
+      // Attempt to find Android 7.0+ APIs.
+      Method setServerNamesMethod = null;
+      Constructor<?> sniHostNameConstructor = null;
+      try {
+        setServerNamesMethod = SSLParameters.class.getMethod("setServerNames", List.class);
+        sniHostNameConstructor =
+            Class.forName("javax.net.ssl.SNIHostName").getConstructor(String.class);
+      } catch (ClassNotFoundException e) {
+        logger.log(Level.FINER, "Failed to find Android 7.0+ APIs", e);
+      } catch (NoSuchMethodException e) {
+        logger.log(Level.FINER, "Failed to find Android 7.0+ APIs", e);
+      }
+      SET_SERVER_NAMES = setServerNamesMethod;
+      SNI_HOST_NAME = sniHostNameConstructor;
+    }
 
-    AndroidNegotiator(Platform platform, TlsExtensionType tlsExtensionType) {
+    AndroidNegotiator(Platform platform) {
       super(platform);
-      this.tlsExtensionType = checkNotNull(tlsExtensionType, "Unable to pick a TLS extension");
     }
 
     @Override
@@ -174,22 +225,82 @@ public String negotiate(SSLSocket sslSocket, String hostname, List<Protocol> pro
     /**
      * Override {@link Platform}'s configureTlsExtensions for Android older than 5.0, since OkHttp
      * (2.3+) only support such function for Android 5.0+.
+     *
+     * <p>Note: Prior to Android Q, the standard way of accessing some Conscrypt features was to
+     * use reflection to call hidden APIs. Beginning in Q, there is public API for all of these
+     * features. We attempt to use the public API where possible. Otherwise, fall back to use the
+     * old reflective API.
      */
     @Override
     protected void configureTlsExtensions(
         SSLSocket sslSocket, String hostname, List<Protocol> protocols) {
-      // Enable SNI and session tickets.
-      if (hostname != null) {
-        SET_USE_SESSION_TICKETS.invokeOptionalWithoutCheckedException(sslSocket, true);
-        SET_HOSTNAME.invokeOptionalWithoutCheckedException(sslSocket, hostname);
+      String[] protocolNames = protocolIds(protocols);
+      SSLParameters sslParams = sslSocket.getSSLParameters();
+      try {
+        // Enable SNI and session tickets.
+        // Hostname is normally validated in the builder (see checkAuthority) and it should
+        // virtually always succeed. Check again here to avoid troubles (e.g., hostname with
+        // underscore) enabling SNI, which works around cases where checkAuthority is disabled.
+        // See b/154375837.
+        if (hostname != null && isValidHostName(hostname)) {
+          if (SSL_SOCKETS_IS_SUPPORTED_SOCKET != null
+              && (boolean) SSL_SOCKETS_IS_SUPPORTED_SOCKET.invoke(null, sslSocket)) {
+            SSL_SOCKETS_SET_USE_SESSION_TICKET.invoke(null, sslSocket, true);
+          } else {
+            SET_USE_SESSION_TICKETS.invokeOptionalWithoutCheckedException(sslSocket, true);
+          }
+          if (SET_SERVER_NAMES != null
+              && SNI_HOST_NAME != null
+              && !InetAddresses.isInetAddress(HostAndPort.fromString(hostname).getHost())) {
+            SET_SERVER_NAMES
+                .invoke(sslParams, Collections.singletonList(SNI_HOST_NAME.newInstance(hostname)));
+          } else {
+            SET_HOSTNAME.invokeOptionalWithoutCheckedException(sslSocket, hostname);
+          }
+        }
+        boolean alpnEnabled = false;
+        if (GET_APPLICATION_PROTOCOL != null) {
+          try {
+            // If calling SSLSocket.getApplicationProtocol() throws UnsupportedOperationException,
+            // the underlying provider does not implement operations for enabling
+            // ALPN in the fashion of SSLParameters.setApplicationProtocols(). Fall back to
+            // use old hidden methods.
+            GET_APPLICATION_PROTOCOL.invoke(sslSocket);
+            SET_APPLICATION_PROTOCOLS.invoke(sslParams, (Object) protocolNames);
+            alpnEnabled = true;
+          } catch (InvocationTargetException e) {
+            Throwable targetException = e.getTargetException();
+            if (targetException instanceof UnsupportedOperationException) {
+              logger.log(Level.FINER, "setApplicationProtocol unsupported, will try old methods");
+            } else {
+              throw e;
+            }
+          }
+        }
+        sslSocket.setSSLParameters(sslParams);
+        // Check application protocols are configured correctly. If not, configure again with
+        // old methods.
+        // Workaround for Conscrypt bug: https://github.com/google/conscrypt/issues/832
+        if (alpnEnabled && GET_APPLICATION_PROTOCOLS != null) {
+          String[] configuredProtocols =
+              (String[]) GET_APPLICATION_PROTOCOLS.invoke(sslSocket.getSSLParameters());
+          if (Arrays.equals(protocolNames, configuredProtocols)) {
+            return;
+          }
+        }
+      } catch (IllegalAccessException e) {
+        throw new RuntimeException(e);
+      } catch (InvocationTargetException e) {
+        throw new RuntimeException(e);
+      } catch (InstantiationException e) {
+        throw new RuntimeException(e);
       }
 
       Object[] parameters = {Platform.concatLengthPrefixed(protocols)};
-      if (tlsExtensionType == TlsExtensionType.ALPN_AND_NPN) {
+      if (platform.getTlsExtensionType() == TlsExtensionType.ALPN_AND_NPN) {
         SET_ALPN_PROTOCOLS.invokeWithoutCheckedException(sslSocket, parameters);
       }
-
-      if (tlsExtensionType != null) {
+      if (platform.getTlsExtensionType() != TlsExtensionType.NONE) {
         SET_NPN_PROTOCOLS.invokeWithoutCheckedException(sslSocket, parameters);
       } else {
         throw new RuntimeException("We can not do TLS handshake on this Android version, please"
@@ -199,7 +310,24 @@ protected void configureTlsExtensions(
 
     @Override
     public String getSelectedProtocol(SSLSocket socket) {
-      if (tlsExtensionType == TlsExtensionType.ALPN_AND_NPN) {
+      if (GET_APPLICATION_PROTOCOL != null) {
+        try {
+          return (String) GET_APPLICATION_PROTOCOL.invoke(socket);
+        } catch (IllegalAccessException e) {
+          throw new RuntimeException(e);
+        } catch (InvocationTargetException e) {
+          Throwable targetException = e.getTargetException();
+          if (targetException instanceof UnsupportedOperationException) {
+            logger.log(
+                Level.FINER,
+                "Socket unsupported for getApplicationProtocol, will try old methods");
+          } else {
+            throw new RuntimeException(e);
+          }
+        }
+      }
+
+      if (platform.getTlsExtensionType() == TlsExtensionType.ALPN_AND_NPN) {
         try {
           byte[] alpnResult =
               (byte[]) GET_ALPN_SELECTED_PROTOCOL.invokeWithoutCheckedException(socket);
@@ -207,12 +335,13 @@ public String getSelectedProtocol(SSLSocket socket) {
             return new String(alpnResult, Util.UTF_8);
           }
         } catch (Exception e) {
+          logger.log(Level.FINE, "Failed calling getAlpnSelectedProtocol()", e);
           // In some implementations, querying selected protocol before the handshake will fail with
           // exception.
         }
       }
 
-      if (tlsExtensionType != null) {
+      if (platform.getTlsExtensionType() != TlsExtensionType.NONE) {
         try {
           byte[] npnResult =
               (byte[]) GET_NPN_SELECTED_PROTOCOL.invokeWithoutCheckedException(socket);
@@ -220,46 +349,36 @@ public String getSelectedProtocol(SSLSocket socket) {
             return new String(npnResult, Util.UTF_8);
           }
         } catch (Exception e) {
+          logger.log(Level.FINE, "Failed calling getNpnSelectedProtocol()", e);
           // In some implementations, querying selected protocol before the handshake will fail with
           // exception.
         }
       }
       return null;
     }
+  }
 
-    @VisibleForTesting
-    static TlsExtensionType pickTlsExtensionType(ClassLoader loader) {
-      // Decide which TLS Extension (APLN and NPN) we will use, follow the rules:
-      // 1. If Google Play Services Security Provider is installed, use both
-      // 2. If on Android 5.0 or later, use both, else
-      // 3. If on Android 4.1 or later, use NPN, else
-      // 4. Fail.
-      // TODO(madongfly): Logging.
-
-      // Check if Google Play Services Security Provider is installed.
-      Provider provider = Security.getProvider("GmsCore_OpenSSL");
-      if (provider != null) {
-        return TlsExtensionType.ALPN_AND_NPN;
-      }
-
-      // Check if on Android 5.0 or later.
-      try {
-        loader.loadClass("android.net.Network"); // Arbitrary class added in Android 5.0.
-        return TlsExtensionType.ALPN_AND_NPN;
-      } catch (ClassNotFoundException ignored) {
-        // making checkstyle happy.
-      }
-
-      // Check if on Android 4.1 or later.
-      try {
-        loader.loadClass("android.app.ActivityOptions"); // Arbitrary class added in Android 4.1.
-        return TlsExtensionType.NPN;
-      } catch (ClassNotFoundException ignored) {
-        // making checkstyle happy.
-      }
+  private static String[] protocolIds(List<Protocol> protocols) {
+    List<String> result = new ArrayList<>();
+    for (Protocol protocol : protocols) {
+      result.add(protocol.toString());
+    }
+    return result.toArray(new String[0]);
+  }
 
-      // This will be caught by the constructor.
-      return null;
+  @VisibleForTesting
+  static boolean isValidHostName(String name) {
+    // GrpcUtil.checkAuthority() depends on URI implementation, while Android's URI implementation
+    // allows underscore in hostname. Manually disallow hostname with underscore to avoid troubles.
+    // See b/154375837.
+    if (name.contains("_")) {
+      return false;
+    }
+    try {
+      GrpcUtil.checkAuthority(name);
+      return true;
+    } catch (IllegalArgumentException e) {
+      return false;
     }
   }
 }
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpReadableBuffer.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpReadableBuffer.java
index a1d77e17e94..d65453722f0 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpReadableBuffer.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpReadableBuffer.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
@@ -36,7 +21,6 @@
 import java.io.EOFException;
 import java.io.IOException;
 import java.io.OutputStream;
-import java.nio.ByteBuffer;
 
 /**
  * A {@link ReadableBuffer} implementation that is backed by an {@link okio.Buffer}.
@@ -55,9 +39,16 @@ public int readableBytes() {
 
   @Override
   public int readUnsignedByte() {
-    return buffer.readByte() & 0x000000FF;
+    try {
+      fakeEofExceptionMethod(); // Okio 2.x can throw EOFException from readByte()
+      return buffer.readByte() & 0x000000FF;
+    } catch (EOFException e) {
+      throw new IndexOutOfBoundsException(e.getMessage());
+    }
   }
 
+  private void fakeEofExceptionMethod() throws EOFException {}
+
   @Override
   public void skipBytes(int length) {
     try {
@@ -79,12 +70,6 @@ public void readBytes(byte[] dest, int destOffset, int length) {
     }
   }
 
-  @Override
-  public void readBytes(ByteBuffer dest) {
-    // We are not using it.
-    throw new UnsupportedOperationException();
-  }
-
   @Override
   public void readBytes(OutputStream dest, int length) throws IOException {
     buffer.writeTo(dest, length);
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpServer.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpServer.java
new file mode 100644
index 00000000000..f63950e4a03
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpServer.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright 2022 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.okhttp;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalInstrumented;
+import io.grpc.InternalLogId;
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.ServerListener;
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketAddress;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.net.ServerSocketFactory;
+
+final class OkHttpServer implements InternalServer {
+  private static final Logger log = Logger.getLogger(OkHttpServer.class.getName());
+
+  private final SocketAddress originalListenAddress;
+  private final ServerSocketFactory socketFactory;
+  private final ObjectPool<Executor> transportExecutorPool;
+  private final ObjectPool<ScheduledExecutorService> scheduledExecutorServicePool;
+  private final OkHttpServerTransport.Config transportConfig;
+  private final InternalChannelz channelz;
+  private ServerSocket serverSocket;
+  private SocketAddress actualListenAddress;
+  private InternalInstrumented<InternalChannelz.SocketStats> listenInstrumented;
+  private Executor transportExecutor;
+  private ScheduledExecutorService scheduledExecutorService;
+  private ServerListener listener;
+  private boolean shutdown;
+
+  public OkHttpServer(
+      OkHttpServerBuilder builder,
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+      InternalChannelz channelz) {
+    this.originalListenAddress = Preconditions.checkNotNull(builder.listenAddress, "listenAddress");
+    this.socketFactory = Preconditions.checkNotNull(builder.socketFactory, "socketFactory");
+    this.transportExecutorPool =
+        Preconditions.checkNotNull(builder.transportExecutorPool, "transportExecutorPool");
+    this.scheduledExecutorServicePool =
+        Preconditions.checkNotNull(
+            builder.scheduledExecutorServicePool, "scheduledExecutorServicePool");
+    this.transportConfig = new OkHttpServerTransport.Config(builder, streamTracerFactories);
+    this.channelz = Preconditions.checkNotNull(channelz, "channelz");
+  }
+
+  @Override
+  public void start(ServerListener listener) throws IOException {
+    this.listener = Preconditions.checkNotNull(listener, "listener");
+    ServerSocket serverSocket = socketFactory.createServerSocket();
+    try {
+      serverSocket.bind(originalListenAddress);
+    } catch (IOException t) {
+      serverSocket.close();
+      throw t;
+    }
+
+    this.serverSocket = serverSocket;
+    this.actualListenAddress = serverSocket.getLocalSocketAddress();
+    this.listenInstrumented = new ListenSocket(serverSocket);
+    this.transportExecutor = transportExecutorPool.getObject();
+    // Keep reference alive to avoid frequent re-creation by server transports
+    this.scheduledExecutorService = scheduledExecutorServicePool.getObject();
+    channelz.addListenSocket(this.listenInstrumented);
+    transportExecutor.execute(this::acceptConnections);
+  }
+
+  private void acceptConnections() {
+    try {
+      while (true) {
+        Socket socket;
+        try {
+          socket = serverSocket.accept();
+        } catch (IOException ex) {
+          if (shutdown) {
+            break;
+          }
+          throw ex;
+        }
+        OkHttpServerTransport transport = new OkHttpServerTransport(transportConfig, socket);
+        transport.start(listener.transportCreated(transport));
+      }
+    } catch (Throwable t) {
+      log.log(Level.SEVERE, "Accept loop failed", t);
+    }
+    listener.serverShutdown();
+  }
+
+  @Override
+  public void shutdown() {
+    if (shutdown) {
+      return;
+    }
+    shutdown = true;
+
+    if (serverSocket == null) {
+      return;
+    }
+    channelz.removeListenSocket(this.listenInstrumented);
+    try {
+      serverSocket.close();
+    } catch (IOException ex) {
+      log.log(Level.WARNING, "Failed closing server socket", serverSocket);
+    }
+    transportExecutor = transportExecutorPool.returnObject(transportExecutor);
+    scheduledExecutorService = scheduledExecutorServicePool.returnObject(scheduledExecutorService);
+  }
+
+  @Override
+  public SocketAddress getListenSocketAddress() {
+    return actualListenAddress;
+  }
+
+  @Override
+  public InternalInstrumented<InternalChannelz.SocketStats> getListenSocketStats() {
+    return listenInstrumented;
+  }
+
+  @Override
+  public List<? extends SocketAddress> getListenSocketAddresses() {
+    return Collections.singletonList(getListenSocketAddress());
+  }
+
+  @Override
+  public List<InternalInstrumented<InternalChannelz.SocketStats>> getListenSocketStatsList() {
+    return Collections.singletonList(getListenSocketStats());
+  }
+
+  private static final class ListenSocket
+      implements InternalInstrumented<InternalChannelz.SocketStats> {
+    private final InternalLogId id;
+    private final ServerSocket socket;
+
+    public ListenSocket(ServerSocket socket) {
+      this.socket = socket;
+      this.id = InternalLogId.allocate(getClass(), String.valueOf(socket.getLocalSocketAddress()));
+    }
+
+    @Override
+    public ListenableFuture<InternalChannelz.SocketStats> getStats() {
+      return Futures.immediateFuture(new InternalChannelz.SocketStats(
+          /*data=*/ null,
+          socket.getLocalSocketAddress(),
+          /*remote=*/ null,
+          new InternalChannelz.SocketOptions.Builder().build(),
+          /*security=*/ null));
+    }
+
+    @Override
+    public InternalLogId getLogId() {
+      return id;
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("logId", id.getId())
+          .add("socket", socket)
+          .toString();
+    }
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpServerBuilder.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpServerBuilder.java
new file mode 100644
index 00000000000..8daeed42a8c
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpServerBuilder.java
@@ -0,0 +1,566 @@
+/*
+ * Copyright 2022 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.okhttp;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static io.grpc.internal.CertificateUtils.createTrustManager;
+
+import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.errorprone.annotations.DoNotCall;
+import io.grpc.ChoiceServerCredentials;
+import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingServerBuilder;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Internal;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCredentials;
+import io.grpc.ServerStreamTracer;
+import io.grpc.TlsServerCredentials;
+import io.grpc.internal.FixedObjectPool;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.KeepAliveManager;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.ServerImplBuilder;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.internal.TransportTracer;
+import io.grpc.okhttp.internal.Platform;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.net.SocketAddress;
+import java.security.GeneralSecurityException;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.net.ServerSocketFactory;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+
+/**
+ * Build servers with the OkHttp transport.
+ *
+ * @since 1.49.0
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1785")
+public final class OkHttpServerBuilder extends ForwardingServerBuilder<OkHttpServerBuilder> {
+  private static final Logger log = Logger.getLogger(OkHttpServerBuilder.class.getName());
+  private static final int DEFAULT_FLOW_CONTROL_WINDOW = 65535;
+
+  static final long MAX_CONNECTION_IDLE_NANOS_DISABLED = Long.MAX_VALUE;
+  private static final long MIN_MAX_CONNECTION_IDLE_NANO = TimeUnit.SECONDS.toNanos(1L);
+  static final long MAX_CONNECTION_AGE_NANOS_DISABLED = Long.MAX_VALUE;
+  static final long MAX_CONNECTION_AGE_GRACE_NANOS_INFINITE = Long.MAX_VALUE;
+  static final int MAX_CONCURRENT_STREAMS = Integer.MAX_VALUE;
+  private static final long MIN_MAX_CONNECTION_AGE_NANO = TimeUnit.SECONDS.toNanos(1L);
+
+  private static final long AS_LARGE_AS_INFINITE = TimeUnit.DAYS.toNanos(1000L);
+  private static final ObjectPool<Executor> DEFAULT_TRANSPORT_EXECUTOR_POOL =
+      OkHttpChannelBuilder.DEFAULT_TRANSPORT_EXECUTOR_POOL;
+
+  /**
+   * Always throws, to shadow {@code ServerBuilder.forPort()}.
+   *
+   * @deprecated Use {@link #forPort(int, ServerCredentials)} instead
+   */
+  @DoNotCall("Always throws. Use forPort(int, ServerCredentials) instead")
+  @Deprecated
+  public static OkHttpServerBuilder forPort(int port) {
+    throw new UnsupportedOperationException("Use forPort(int, ServerCredentials) instead");
+  }
+
+  /**
+   * Creates a builder for a server listening on {@code port}.
+   */
+  public static OkHttpServerBuilder forPort(int port, ServerCredentials creds) {
+    return forPort(new InetSocketAddress(port), creds);
+  }
+
+  /**
+   * Creates a builder for a server listening on {@code address}.
+   */
+  public static OkHttpServerBuilder forPort(SocketAddress address, ServerCredentials creds) {
+    HandshakerSocketFactoryResult result = handshakerSocketFactoryFrom(creds);
+    if (result.error != null) {
+      throw new IllegalArgumentException(result.error);
+    }
+    return new OkHttpServerBuilder(address, result.factory);
+  }
+
+  final ServerImplBuilder serverImplBuilder = new ServerImplBuilder(this::buildTransportServers);
+  final SocketAddress listenAddress;
+  final HandshakerSocketFactory handshakerSocketFactory;
+  TransportTracer.Factory transportTracerFactory = TransportTracer.getDefaultFactory();
+
+  ObjectPool<Executor> transportExecutorPool = DEFAULT_TRANSPORT_EXECUTOR_POOL;
+  ObjectPool<ScheduledExecutorService> scheduledExecutorServicePool =
+      SharedResourcePool.forResource(GrpcUtil.TIMER_SERVICE);
+
+  ServerSocketFactory socketFactory = ServerSocketFactory.getDefault();
+  long keepAliveTimeNanos = GrpcUtil.DEFAULT_SERVER_KEEPALIVE_TIME_NANOS;
+  long keepAliveTimeoutNanos = GrpcUtil.DEFAULT_SERVER_KEEPALIVE_TIMEOUT_NANOS;
+  int flowControlWindow = DEFAULT_FLOW_CONTROL_WINDOW;
+  int maxInboundMetadataSize = GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE;
+  int maxInboundMessageSize = GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
+  long maxConnectionIdleInNanos = MAX_CONNECTION_IDLE_NANOS_DISABLED;
+  boolean permitKeepAliveWithoutCalls;
+  long permitKeepAliveTimeInNanos = TimeUnit.MINUTES.toNanos(5);
+  long maxConnectionAgeInNanos = MAX_CONNECTION_AGE_NANOS_DISABLED;
+  long maxConnectionAgeGraceInNanos = MAX_CONNECTION_AGE_GRACE_NANOS_INFINITE;
+  int maxConcurrentCallsPerConnection = MAX_CONCURRENT_STREAMS;
+
+  OkHttpServerBuilder(
+      SocketAddress address, HandshakerSocketFactory handshakerSocketFactory) {
+    this.listenAddress = Preconditions.checkNotNull(address, "address");
+    this.handshakerSocketFactory =
+        Preconditions.checkNotNull(handshakerSocketFactory, "handshakerSocketFactory");
+  }
+
+  @Internal
+  @Override
+  protected ServerBuilder<?> delegate() {
+    return serverImplBuilder;
+  }
+
+  // @VisibleForTesting
+  OkHttpServerBuilder setTransportTracerFactory(TransportTracer.Factory transportTracerFactory) {
+    this.transportTracerFactory = transportTracerFactory;
+    return this;
+  }
+
+  /**
+   * Override the default executor necessary for internal transport use.
+   *
+   * <p>The channel does not take ownership of the given executor. It is the caller' responsibility
+   * to shutdown the executor when appropriate.
+   */
+  public OkHttpServerBuilder transportExecutor(Executor transportExecutor) {
+    if (transportExecutor == null) {
+      this.transportExecutorPool = DEFAULT_TRANSPORT_EXECUTOR_POOL;
+    } else {
+      this.transportExecutorPool = new FixedObjectPool<>(transportExecutor);
+    }
+    return this;
+  }
+
+  /**
+   * Override the default {@link ServerSocketFactory} used to listen. If the socket factory is not
+   * set or set to null, a default one will be used.
+   */
+  public OkHttpServerBuilder socketFactory(ServerSocketFactory socketFactory) {
+    if (socketFactory == null) {
+      this.socketFactory = ServerSocketFactory.getDefault();
+    } else {
+      this.socketFactory = socketFactory;
+    }
+    return this;
+  }
+
+  /**
+   * Sets the time without read activity before sending a keepalive ping. An unreasonably small
+   * value might be increased, and {@code Long.MAX_VALUE} nano seconds or an unreasonably large
+   * value will disable keepalive. Defaults to two hours.
+   *
+   * @throws IllegalArgumentException if time is not positive
+   */
+  @Override
+  public OkHttpServerBuilder keepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    Preconditions.checkArgument(keepAliveTime > 0L, "keepalive time must be positive");
+    keepAliveTimeNanos = timeUnit.toNanos(keepAliveTime);
+    keepAliveTimeNanos = KeepAliveManager.clampKeepAliveTimeInNanos(keepAliveTimeNanos);
+    if (keepAliveTimeNanos >= AS_LARGE_AS_INFINITE) {
+      // Bump keepalive time to infinite. This disables keepalive.
+      keepAliveTimeNanos = GrpcUtil.KEEPALIVE_TIME_NANOS_DISABLED;
+    }
+    return this;
+  }
+
+  /**
+   * Sets a custom max connection idle time, connection being idle for longer than which will be
+   * gracefully terminated. Idleness duration is defined since the most recent time the number of
+   * outstanding RPCs became zero or the connection establishment. An unreasonably small value might
+   * be increased. {@code Long.MAX_VALUE} nano seconds or an unreasonably large value will disable
+   * max connection idle.
+   */
+  @Override
+  public OkHttpServerBuilder maxConnectionIdle(long maxConnectionIdle, TimeUnit timeUnit) {
+    checkArgument(maxConnectionIdle > 0L, "max connection idle must be positive: %s",
+        maxConnectionIdle);
+    maxConnectionIdleInNanos = timeUnit.toNanos(maxConnectionIdle);
+    if (maxConnectionIdleInNanos >= AS_LARGE_AS_INFINITE) {
+      maxConnectionIdleInNanos = MAX_CONNECTION_IDLE_NANOS_DISABLED;
+    }
+    if (maxConnectionIdleInNanos < MIN_MAX_CONNECTION_IDLE_NANO) {
+      maxConnectionIdleInNanos = MIN_MAX_CONNECTION_IDLE_NANO;
+    }
+    return this;
+  }
+
+  /**
+   * Sets a custom max connection age, connection lasting longer than which will be gracefully
+   * terminated. An unreasonably small value might be increased.  A random jitter of +/-10% will be
+   * added to it. {@code Long.MAX_VALUE} nano seconds or an unreasonably large value will disable
+   * max connection age.
+   */
+  @Override
+  public OkHttpServerBuilder maxConnectionAge(long maxConnectionAge, TimeUnit timeUnit) {
+    checkArgument(maxConnectionAge > 0L, "max connection age must be positive: %s",
+        maxConnectionAge);
+    maxConnectionAgeInNanos = timeUnit.toNanos(maxConnectionAge);
+    if (maxConnectionAgeInNanos >= AS_LARGE_AS_INFINITE) {
+      maxConnectionAgeInNanos = MAX_CONNECTION_AGE_NANOS_DISABLED;
+    }
+    if (maxConnectionAgeInNanos < MIN_MAX_CONNECTION_AGE_NANO) {
+      maxConnectionAgeInNanos = MIN_MAX_CONNECTION_AGE_NANO;
+    }
+    return this;
+  }
+
+  /**
+   * Sets a custom grace time for the graceful connection termination. Once the max connection age
+   * is reached, RPCs have the grace time to complete. RPCs that do not complete in time will be
+   * cancelled, allowing the connection to terminate. {@code Long.MAX_VALUE} nano seconds or an
+   * unreasonably large value are considered infinite.
+   *
+   * @see #maxConnectionAge(long, TimeUnit)
+   */
+  @Override
+  public OkHttpServerBuilder maxConnectionAgeGrace(long maxConnectionAgeGrace, TimeUnit timeUnit) {
+    checkArgument(maxConnectionAgeGrace >= 0L, "max connection age grace must be non-negative: %s",
+        maxConnectionAgeGrace);
+    maxConnectionAgeGraceInNanos = timeUnit.toNanos(maxConnectionAgeGrace);
+    if (maxConnectionAgeGraceInNanos >= AS_LARGE_AS_INFINITE) {
+      maxConnectionAgeGraceInNanos = MAX_CONNECTION_AGE_GRACE_NANOS_INFINITE;
+    }
+    return this;
+  }
+
+  /**
+   * Sets a time waiting for read activity after sending a keepalive ping. If the time expires
+   * without any read activity on the connection, the connection is considered dead. An unreasonably
+   * small value might be increased. Defaults to 20 seconds.
+   *
+   * <p>This value should be at least multiple times the RTT to allow for lost packets.
+   *
+   * @throws IllegalArgumentException if timeout is not positive
+   */
+  @Override
+  public OkHttpServerBuilder keepAliveTimeout(long keepAliveTimeout, TimeUnit timeUnit) {
+    Preconditions.checkArgument(keepAliveTimeout > 0L, "keepalive timeout must be positive");
+    keepAliveTimeoutNanos = timeUnit.toNanos(keepAliveTimeout);
+    keepAliveTimeoutNanos = KeepAliveManager.clampKeepAliveTimeoutInNanos(keepAliveTimeoutNanos);
+    return this;
+  }
+
+  /**
+   * Specify the most aggressive keep-alive time clients are permitted to configure. The server will
+   * try to detect clients exceeding this rate and when detected will forcefully close the
+   * connection. The default is 5 minutes.
+   *
+   * <p>Even though a default is defined that allows some keep-alives, clients must not use
+   * keep-alive without approval from the service owner. Otherwise, they may experience failures in
+   * the future if the service becomes more restrictive. When unthrottled, keep-alives can cause a
+   * significant amount of traffic and CPU usage, so clients and servers should be conservative in
+   * what they use and accept.
+   *
+   * @see #permitKeepAliveWithoutCalls(boolean)
+   */
+  @CanIgnoreReturnValue
+  @Override
+  public OkHttpServerBuilder permitKeepAliveTime(long keepAliveTime, TimeUnit timeUnit) {
+    checkArgument(keepAliveTime >= 0, "permit keepalive time must be non-negative: %s",
+        keepAliveTime);
+    permitKeepAliveTimeInNanos = timeUnit.toNanos(keepAliveTime);
+    return this;
+  }
+
+  /**
+   * Sets whether to allow clients to send keep-alive HTTP/2 PINGs even if there are no outstanding
+   * RPCs on the connection. Defaults to {@code false}.
+   *
+   * @see #permitKeepAliveTime(long, TimeUnit)
+   */
+  @CanIgnoreReturnValue
+  @Override
+  public OkHttpServerBuilder permitKeepAliveWithoutCalls(boolean permit) {
+    permitKeepAliveWithoutCalls = permit;
+    return this;
+  }
+
+  /**
+   * Sets the flow control window in bytes. If not called, the default value is 64 KiB.
+   */
+  public OkHttpServerBuilder flowControlWindow(int flowControlWindow) {
+    Preconditions.checkState(flowControlWindow > 0, "flowControlWindow must be positive");
+    this.flowControlWindow = flowControlWindow;
+    return this;
+  }
+
+  /**
+   * Provides a custom scheduled executor service.
+   *
+   * <p>It's an optional parameter. If the user has not provided a scheduled executor service when
+   * the channel is built, the builder will use a static thread pool.
+   *
+   * @return this
+   */
+  public OkHttpServerBuilder scheduledExecutorService(
+      ScheduledExecutorService scheduledExecutorService) {
+    this.scheduledExecutorServicePool = new FixedObjectPool<>(
+        Preconditions.checkNotNull(scheduledExecutorService, "scheduledExecutorService"));
+    return this;
+  }
+
+  /**
+   * Sets the maximum size of metadata allowed to be received. Defaults to 8 KiB.
+   *
+   * <p>The implementation does not currently limit memory usage; this value is checked only after
+   * the metadata is decoded from the wire. It does prevent large metadata from being passed to the
+   * application.
+   *
+   * @param bytes the maximum size of received metadata
+   * @return this
+   * @throws IllegalArgumentException if bytes is non-positive
+   */
+  @Override
+  public OkHttpServerBuilder maxInboundMetadataSize(int bytes) {
+    Preconditions.checkArgument(bytes > 0, "maxInboundMetadataSize must be > 0");
+    this.maxInboundMetadataSize = bytes;
+    return this;
+  }
+
+  /**
+   * The maximum number of concurrent calls permitted for each incoming connection. Defaults to no
+   * limit.
+   */
+  @CanIgnoreReturnValue
+  public OkHttpServerBuilder maxConcurrentCallsPerConnection(int maxConcurrentCallsPerConnection) {
+    checkArgument(maxConcurrentCallsPerConnection > 0,
+        "max must be positive: %s", maxConcurrentCallsPerConnection);
+    this.maxConcurrentCallsPerConnection = maxConcurrentCallsPerConnection;
+    return this;
+  }
+
+  /**
+   * Sets the maximum message size allowed to be received on the server. If not called, defaults to
+   * defaults to 4 MiB. The default provides protection to servers who haven't considered the
+   * possibility of receiving large messages while trying to be large enough to not be hit in normal
+   * usage.
+   *
+   * @param bytes the maximum number of bytes a single message can be.
+   * @return this
+   * @throws IllegalArgumentException if bytes is negative.
+   */
+  @Override
+  public OkHttpServerBuilder maxInboundMessageSize(int bytes) {
+    Preconditions.checkArgument(bytes >= 0, "negative max bytes");
+    maxInboundMessageSize = bytes;
+    return this;
+  }
+
+  void setStatsEnabled(boolean value) {
+    this.serverImplBuilder.setStatsEnabled(value);
+  }
+
+  InternalServer buildTransportServers(
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+    return new OkHttpServer(this, streamTracerFactories, serverImplBuilder.getChannelz());
+  }
+
+  private static final EnumSet<TlsServerCredentials.Feature> understoodTlsFeatures =
+      EnumSet.of(
+          TlsServerCredentials.Feature.MTLS, TlsServerCredentials.Feature.CUSTOM_MANAGERS);
+
+  static HandshakerSocketFactoryResult handshakerSocketFactoryFrom(ServerCredentials creds) {
+    if (creds instanceof TlsServerCredentials) {
+      TlsServerCredentials tlsCreds = (TlsServerCredentials) creds;
+      Set<TlsServerCredentials.Feature> incomprehensible =
+          tlsCreds.incomprehensible(understoodTlsFeatures);
+      if (!incomprehensible.isEmpty()) {
+        return HandshakerSocketFactoryResult.error(
+            "TLS features not understood: " + incomprehensible);
+      }
+      KeyManager[] km = null;
+      if (tlsCreds.getKeyManagers() != null) {
+        km = tlsCreds.getKeyManagers().toArray(new KeyManager[0]);
+      } else if (tlsCreds.getPrivateKey() != null) {
+        if (tlsCreds.getPrivateKeyPassword() != null) {
+          return HandshakerSocketFactoryResult.error("byte[]-based private key with password "
+              + "unsupported. Use unencrypted file or KeyManager");
+        }
+        try {
+          km = OkHttpChannelBuilder.createKeyManager(
+              tlsCreds.getCertificateChain(), tlsCreds.getPrivateKey());
+        } catch (GeneralSecurityException gse) {
+          log.log(Level.FINE, "Exception loading private key from credential", gse);
+          return HandshakerSocketFactoryResult.error(
+              "Unable to load private key: " + gse.getMessage());
+        }
+      } // else don't have a client cert
+      TrustManager[] tm = null;
+      if (tlsCreds.getTrustManagers() != null) {
+        tm = tlsCreds.getTrustManagers().toArray(new TrustManager[0]);
+      } else if (tlsCreds.getRootCertificates() != null) {
+        try {
+          tm = createTrustManager(tlsCreds.getRootCertificates());
+        } catch (GeneralSecurityException gse) {
+          log.log(Level.FINE, "Exception loading root certificates from credential", gse);
+          return HandshakerSocketFactoryResult.error(
+              "Unable to load root certificates: " + gse.getMessage());
+        }
+      } // else use system default
+      SSLContext sslContext;
+      try {
+        sslContext = SSLContext.getInstance("TLS", Platform.get().getProvider());
+        sslContext.init(km, tm, null);
+      } catch (GeneralSecurityException gse) {
+        throw new RuntimeException("TLS Provider failure", gse);
+      }
+      SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
+      switch (tlsCreds.getClientAuth()) {
+        case OPTIONAL:
+          sslSocketFactory = new ClientCertRequestingSocketFactory(sslSocketFactory, false);
+          break;
+
+        case REQUIRE:
+          sslSocketFactory = new ClientCertRequestingSocketFactory(sslSocketFactory, true);
+          break;
+
+        case NONE:
+          // NOOP; this is the SSLContext default
+          break;
+
+        default:
+          return HandshakerSocketFactoryResult.error(
+              "Unknown TlsServerCredentials.ClientAuth value: " + tlsCreds.getClientAuth());
+      }
+      return HandshakerSocketFactoryResult.factory(new TlsServerHandshakerSocketFactory(
+          new SslSocketFactoryServerCredentials.ServerCredentials(sslSocketFactory)));
+
+    } else if (creds instanceof InsecureServerCredentials) {
+      return HandshakerSocketFactoryResult.factory(new PlaintextHandshakerSocketFactory());
+
+    } else if (creds instanceof SslSocketFactoryServerCredentials.ServerCredentials) {
+      SslSocketFactoryServerCredentials.ServerCredentials factoryCreds =
+          (SslSocketFactoryServerCredentials.ServerCredentials) creds;
+      return HandshakerSocketFactoryResult.factory(
+          new TlsServerHandshakerSocketFactory(factoryCreds));
+
+    } else if (creds instanceof ChoiceServerCredentials) {
+      ChoiceServerCredentials choiceCreds = (ChoiceServerCredentials) creds;
+      StringBuilder error = new StringBuilder();
+      for (ServerCredentials innerCreds : choiceCreds.getCredentialsList()) {
+        HandshakerSocketFactoryResult result = handshakerSocketFactoryFrom(innerCreds);
+        if (result.error == null) {
+          return result;
+        }
+        error.append(", ");
+        error.append(result.error);
+      }
+      return HandshakerSocketFactoryResult.error(error.substring(2));
+
+    } else {
+      return HandshakerSocketFactoryResult.error(
+          "Unsupported credential type: " + creds.getClass().getName());
+    }
+  }
+
+  static final class HandshakerSocketFactoryResult {
+    public final HandshakerSocketFactory factory;
+    public final String error;
+
+    private HandshakerSocketFactoryResult(HandshakerSocketFactory factory, String error) {
+      this.factory = factory;
+      this.error = error;
+    }
+
+    public static HandshakerSocketFactoryResult error(String error) {
+      return new HandshakerSocketFactoryResult(
+          null, Preconditions.checkNotNull(error, "error"));
+    }
+
+    public static HandshakerSocketFactoryResult factory(HandshakerSocketFactory factory) {
+      return new HandshakerSocketFactoryResult(
+          Preconditions.checkNotNull(factory, "factory"), null);
+    }
+  }
+
+  static final class ClientCertRequestingSocketFactory extends SSLSocketFactory {
+    private final SSLSocketFactory socketFactory;
+    private final boolean required;
+
+    public ClientCertRequestingSocketFactory(SSLSocketFactory socketFactory, boolean required) {
+      this.socketFactory = Preconditions.checkNotNull(socketFactory, "socketFactory");
+      this.required = required;
+    }
+
+    private Socket apply(Socket s) throws IOException {
+      if (!(s instanceof SSLSocket)) {
+        throw new IOException(
+            "SocketFactory " + socketFactory + " did not produce an SSLSocket: " + s.getClass());
+      }
+      SSLSocket sslSocket = (SSLSocket) s;
+      if (required) {
+        sslSocket.setNeedClientAuth(true);
+      } else {
+        sslSocket.setWantClientAuth(true);
+      }
+      return sslSocket;
+    }
+
+    @Override public Socket createSocket(Socket s, String host, int port, boolean autoClose)
+        throws IOException {
+      return apply(socketFactory.createSocket(s, host, port, autoClose));
+    }
+
+    @Override public Socket createSocket(String host, int port) throws IOException {
+      return apply(socketFactory.createSocket(host, port));
+    }
+
+    @Override public Socket createSocket(
+        String host, int port, InetAddress localHost, int localPort) throws IOException {
+      return apply(socketFactory.createSocket(host, port, localHost, localPort));
+    }
+
+    @Override public Socket createSocket(InetAddress host, int port) throws IOException {
+      return apply(socketFactory.createSocket(host, port));
+    }
+
+    @Override public Socket createSocket(
+        InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException {
+      return apply(socketFactory.createSocket(host, port, localAddress, localPort));
+    }
+
+    @Override public String[] getDefaultCipherSuites() {
+      return socketFactory.getDefaultCipherSuites();
+    }
+
+    @Override public String[] getSupportedCipherSuites() {
+      return socketFactory.getSupportedCipherSuites();
+    }
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpServerProvider.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpServerProvider.java
new file mode 100644
index 00000000000..ef2fae4338d
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpServerProvider.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2023 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.okhttp;
+
+import io.grpc.Internal;
+import io.grpc.ServerCredentials;
+import io.grpc.ServerProvider;
+import java.net.InetSocketAddress;
+
+/** Provider for {@link OkHttpServerBuilder} instances. */
+@Internal
+public final class OkHttpServerProvider extends ServerProvider {
+
+  @Override
+  protected boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  protected int priority() {
+    // Use a priority less than Netty since builderForPort() always throws.
+    return 4;
+  }
+
+  @Override
+  protected OkHttpServerBuilder builderForPort(int port) {
+    throw new UnsupportedOperationException("Use Grpc.newServerBuilderForPort() instead");
+  }
+
+  @Override
+  protected NewServerBuilderResult newServerBuilderForPort(int port, ServerCredentials creds) {
+    OkHttpServerBuilder.HandshakerSocketFactoryResult result =
+        OkHttpServerBuilder.handshakerSocketFactoryFrom(creds);
+    if (result.error != null) {
+      return NewServerBuilderResult.error(result.error);
+    }
+    return NewServerBuilderResult.serverBuilder(
+        new OkHttpServerBuilder(new InetSocketAddress(port), result.factory));
+  }
+}
+
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpServerStream.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpServerStream.java
new file mode 100644
index 00000000000..d1f1a3f4fe0
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpServerStream.java
@@ -0,0 +1,296 @@
+/*
+ * Copyright 2022 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.okhttp;
+
+import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.internal.AbstractServerStream;
+import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.TransportTracer;
+import io.grpc.internal.WritableBuffer;
+import io.grpc.okhttp.internal.framed.ErrorCode;
+import io.grpc.okhttp.internal.framed.Header;
+import io.perfmark.PerfMark;
+import io.perfmark.Tag;
+import io.perfmark.TaskCloseable;
+import java.util.List;
+import okio.Buffer;
+
+/**
+ * Server stream for the okhttp transport.
+ */
+class OkHttpServerStream extends AbstractServerStream {
+  private final String authority;
+  private final TransportState state;
+  private final Sink sink = new Sink();
+  private final TransportTracer transportTracer;
+  private final Attributes attributes;
+
+  public OkHttpServerStream(
+      TransportState state,
+      Attributes transportAttrs,
+      String authority,
+      StatsTraceContext statsTraceCtx,
+      TransportTracer transportTracer) {
+    super(new OkHttpWritableBufferAllocator(), statsTraceCtx);
+    this.state = Preconditions.checkNotNull(state, "state");
+    this.attributes = Preconditions.checkNotNull(transportAttrs, "transportAttrs");
+    this.authority = authority;
+    this.transportTracer = Preconditions.checkNotNull(transportTracer, "transportTracer");
+  }
+
+  @Override
+  protected TransportState transportState() {
+    return state;
+  }
+
+  @Override
+  protected Sink abstractServerStreamSink() {
+    return sink;
+  }
+
+  @Override
+  public int streamId() {
+    return state.streamId;
+  }
+
+  @Override
+  public String getAuthority() {
+    return authority;
+  }
+
+  @Override
+  public Attributes getAttributes() {
+    return attributes;
+  }
+
+  class Sink implements AbstractServerStream.Sink {
+    @Override
+    public void writeHeaders(Metadata metadata, boolean flush) {
+      try (TaskCloseable ignore =
+               PerfMark.traceTask("OkHttpServerStream$Sink.writeHeaders")) {
+        List<Header> responseHeaders = Headers.createResponseHeaders(metadata);
+        synchronized (state.lock) {
+          state.sendHeaders(responseHeaders);
+        }
+      }
+    }
+
+    @Override
+    public void writeFrame(WritableBuffer frame, boolean flush, int numMessages) {
+      try (TaskCloseable ignore =
+               PerfMark.traceTask("OkHttpServerStream$Sink.writeFrame")) {
+        Buffer buffer = ((OkHttpWritableBuffer) frame).buffer();
+        int size = (int) buffer.size();
+        if (size > 0) {
+          onSendingBytes(size);
+        }
+        synchronized (state.lock) {
+          state.sendBuffer(buffer, flush);
+          transportTracer.reportMessageSent(numMessages);
+        }
+      }
+    }
+
+    @Override
+    public void writeTrailers(Metadata trailers, boolean headersSent, Status status) {
+      try (TaskCloseable ignore =
+               PerfMark.traceTask("OkHttpServerStream$Sink.writeTrailers")) {
+        List<Header> responseTrailers = Headers.createResponseTrailers(trailers, headersSent);
+        synchronized (state.lock) {
+          state.sendTrailers(responseTrailers);
+        }
+      }
+    }
+
+    @Override
+    public void cancel(Status reason) {
+      try (TaskCloseable ignore =
+               PerfMark.traceTask("OkHttpServerStream$Sink.cancel")) {
+        synchronized (state.lock) {
+          state.cancel(ErrorCode.CANCEL, reason);
+        }
+      }
+    }
+  }
+
+  static class TransportState extends AbstractServerStream.TransportState
+      implements OutboundFlowController.Stream, OkHttpServerTransport.StreamState {
+    @GuardedBy("lock")
+    private final OkHttpServerTransport transport;
+    private final int streamId;
+    private final int initialWindowSize;
+    private final Object lock;
+    @GuardedBy("lock")
+    private boolean cancelSent = false;
+    @GuardedBy("lock")
+    private int window;
+    @GuardedBy("lock")
+    private int processedWindow;
+    @GuardedBy("lock")
+    private final ExceptionHandlingFrameWriter frameWriter;
+    @GuardedBy("lock")
+    private final OutboundFlowController outboundFlow;
+    @GuardedBy("lock")
+    private boolean receivedEndOfStream;
+    private final Tag tag;
+    private final OutboundFlowController.StreamState outboundFlowState;
+
+    public TransportState(
+        OkHttpServerTransport transport,
+        int streamId,
+        int maxMessageSize,
+        StatsTraceContext statsTraceCtx,
+        Object lock,
+        ExceptionHandlingFrameWriter frameWriter,
+        OutboundFlowController outboundFlow,
+        int initialWindowSize,
+        TransportTracer transportTracer,
+        String methodName) {
+      super(maxMessageSize, statsTraceCtx, transportTracer);
+      this.transport = Preconditions.checkNotNull(transport, "transport");
+      this.streamId = streamId;
+      this.lock = Preconditions.checkNotNull(lock, "lock");
+      this.frameWriter = frameWriter;
+      this.outboundFlow = outboundFlow;
+      this.window = initialWindowSize;
+      this.processedWindow = initialWindowSize;
+      this.initialWindowSize = initialWindowSize;
+      tag = PerfMark.createTag(methodName);
+      outboundFlowState = outboundFlow.createState(this, streamId);
+    }
+
+    @Override
+    @GuardedBy("lock")
+    public void deframeFailed(Throwable cause) {
+      cancel(ErrorCode.INTERNAL_ERROR, Status.fromThrowable(cause));
+    }
+
+    @Override
+    @GuardedBy("lock")
+    public void bytesRead(int processedBytes) {
+      processedWindow -= processedBytes;
+      if (processedWindow <= initialWindowSize * Utils.DEFAULT_WINDOW_UPDATE_RATIO) {
+        int delta = initialWindowSize - processedWindow;
+        window += delta;
+        processedWindow += delta;
+        frameWriter.windowUpdate(streamId, delta);
+        frameWriter.flush();
+      }
+    }
+
+    @Override
+    @GuardedBy("lock")
+    public void runOnTransportThread(final Runnable r) {
+      synchronized (lock) {
+        r.run();
+      }
+    }
+
+    /**
+     * Must be called with holding the transport lock.
+     */
+    @Override
+    public void inboundDataReceived(okio.Buffer frame, int dataLength, int paddingLength,
+                                    boolean endOfStream) {
+      synchronized (lock) {
+        PerfMark.event("OkHttpServerTransport$FrameHandler.data", tag);
+        if (endOfStream) {
+          this.receivedEndOfStream = true;
+        }
+        window -= dataLength + paddingLength;
+        processedWindow -= paddingLength;
+        super.inboundDataReceived(new OkHttpReadableBuffer(frame), endOfStream);
+      }
+    }
+
+    /** Must be called with holding the transport lock. */
+    @Override
+    public void inboundRstReceived(Status status) {
+      PerfMark.event("OkHttpServerTransport$FrameHandler.rstStream", tag);
+      transportReportStatus(status);
+    }
+
+    /** Must be called with holding the transport lock. */
+    @Override
+    public boolean hasReceivedEndOfStream() {
+      synchronized (lock) {
+        return receivedEndOfStream;
+      }
+    }
+
+    /** Must be called with holding the transport lock. */
+    @Override
+    public int inboundWindowAvailable() {
+      synchronized (lock) {
+        return window;
+      }
+    }
+
+    @GuardedBy("lock")
+    private void sendBuffer(Buffer buffer, boolean flush) {
+      if (cancelSent) {
+        return;
+      }
+      // If buffer > frameWriter.maxDataLength() the flow-controller will ensure that it is
+      // properly chunked.
+      outboundFlow.data(false, outboundFlowState, buffer, flush);
+    }
+
+    @GuardedBy("lock")
+    private void sendHeaders(List<Header> responseHeaders) {
+      frameWriter.synReply(false, streamId, responseHeaders);
+      frameWriter.flush();
+    }
+
+    @GuardedBy("lock")
+    private void sendTrailers(List<Header> responseTrailers) {
+      outboundFlow.notifyWhenNoPendingData(
+          outboundFlowState, () -> sendTrailersAfterFlowControlled(responseTrailers));
+    }
+
+    private void sendTrailersAfterFlowControlled(List<Header> responseTrailers) {
+      synchronized (lock) {
+        frameWriter.synReply(true, streamId, responseTrailers);
+        if (!receivedEndOfStream) {
+          frameWriter.rstStream(streamId, ErrorCode.NO_ERROR);
+        }
+        transport.streamClosed(streamId, /*flush=*/ true);
+        complete();
+      }
+    }
+
+    @GuardedBy("lock")
+    private void cancel(ErrorCode http2Error, Status reason) {
+      if (cancelSent) {
+        return;
+      }
+      cancelSent = true;
+      frameWriter.rstStream(streamId, http2Error);
+      transportReportStatus(reason);
+      transport.streamClosed(streamId, /*flush=*/ true);
+    }
+
+    @Override
+    public OutboundFlowController.StreamState getOutboundFlowState() {
+      return outboundFlowState;
+    }
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpServerTransport.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpServerTransport.java
new file mode 100644
index 00000000000..7d192b16943
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpServerTransport.java
@@ -0,0 +1,1230 @@
+/*
+ * Copyright 2022 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.okhttp;
+
+import static io.grpc.okhttp.OkHttpServerBuilder.MAX_CONNECTION_AGE_NANOS_DISABLED;
+import static io.grpc.okhttp.OkHttpServerBuilder.MAX_CONNECTION_IDLE_NANOS_DISABLED;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Attributes;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalLogId;
+import io.grpc.InternalStatus;
+import io.grpc.Metadata;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.KeepAliveEnforcer;
+import io.grpc.internal.KeepAliveManager;
+import io.grpc.internal.LogExceptionRunnable;
+import io.grpc.internal.MaxConnectionIdleManager;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SerializingExecutor;
+import io.grpc.internal.ServerTransport;
+import io.grpc.internal.ServerTransportListener;
+import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.TransportTracer;
+import io.grpc.okhttp.internal.framed.ErrorCode;
+import io.grpc.okhttp.internal.framed.FrameReader;
+import io.grpc.okhttp.internal.framed.FrameWriter;
+import io.grpc.okhttp.internal.framed.Header;
+import io.grpc.okhttp.internal.framed.HeadersMode;
+import io.grpc.okhttp.internal.framed.Http2;
+import io.grpc.okhttp.internal.framed.Settings;
+import io.grpc.okhttp.internal.framed.Variant;
+import java.io.IOException;
+import java.net.Socket;
+import java.net.SocketException;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import okio.Buffer;
+import okio.BufferedSource;
+import okio.ByteString;
+import okio.Okio;
+
+/**
+ * OkHttp-based server transport.
+ */
+final class OkHttpServerTransport implements ServerTransport,
+      ExceptionHandlingFrameWriter.TransportExceptionHandler, OutboundFlowController.Transport {
+  private static final Logger log = Logger.getLogger(OkHttpServerTransport.class.getName());
+  private static final int GRACEFUL_SHUTDOWN_PING = 0x1111;
+
+  private static final long GRACEFUL_SHUTDOWN_PING_TIMEOUT_NANOS = TimeUnit.SECONDS.toNanos(1);
+
+  private static final int KEEPALIVE_PING = 0xDEAD;
+  private static final ByteString HTTP_METHOD = ByteString.encodeUtf8(":method");
+  private static final ByteString CONNECT_METHOD = ByteString.encodeUtf8("CONNECT");
+  private static final ByteString POST_METHOD = ByteString.encodeUtf8("POST");
+  private static final ByteString SCHEME = ByteString.encodeUtf8(":scheme");
+  private static final ByteString PATH = ByteString.encodeUtf8(":path");
+  private static final ByteString AUTHORITY = ByteString.encodeUtf8(":authority");
+  private static final ByteString CONNECTION = ByteString.encodeUtf8("connection");
+  private static final ByteString HOST = ByteString.encodeUtf8("host");
+  private static final ByteString TE = ByteString.encodeUtf8("te");
+  private static final ByteString TE_TRAILERS = ByteString.encodeUtf8("trailers");
+  private static final ByteString CONTENT_TYPE = ByteString.encodeUtf8("content-type");
+  private static final ByteString CONTENT_LENGTH = ByteString.encodeUtf8("content-length");
+  private static final ByteString ALLOW = ByteString.encodeUtf8("allow");
+
+  private final Config config;
+  private final Variant variant = new Http2();
+  private final TransportTracer tracer;
+  private final InternalLogId logId;
+  private Socket socket;
+  private ServerTransportListener listener;
+  private Executor transportExecutor;
+  private ScheduledExecutorService scheduledExecutorService;
+  private Attributes attributes;
+  private KeepAliveManager keepAliveManager;
+  private MaxConnectionIdleManager maxConnectionIdleManager;
+  private ScheduledFuture<?> maxConnectionAgeMonitor;
+  private final KeepAliveEnforcer keepAliveEnforcer;
+
+  private final Object lock = new Object();
+  @GuardedBy("lock")
+  private boolean abruptShutdown;
+  @GuardedBy("lock")
+  private boolean gracefulShutdown;
+  @GuardedBy("lock")
+  private boolean handshakeShutdown;
+  @GuardedBy("lock")
+  private InternalChannelz.Security securityInfo;
+  @GuardedBy("lock")
+  private ExceptionHandlingFrameWriter frameWriter;
+  @GuardedBy("lock")
+  private OutboundFlowController outboundFlow;
+  @GuardedBy("lock")
+  private final Map<Integer, StreamState> streams = new TreeMap<>();
+  @GuardedBy("lock")
+  private int lastStreamId;
+  @GuardedBy("lock")
+  private int goAwayStreamId = Integer.MAX_VALUE;
+  /**
+   * Indicates the transport is in go-away state: no new streams will be processed, but existing
+   * streams may continue.
+   */
+  @GuardedBy("lock")
+  private Status goAwayStatus;
+  /** Non-{@code null} when gracefully shutting down and have not yet sent second GOAWAY. */
+  @GuardedBy("lock")
+  private ScheduledFuture<?> secondGoawayTimer;
+  /** Non-{@code null} when waiting for forceful close GOAWAY to be sent. */
+  @GuardedBy("lock")
+  private ScheduledFuture<?> forcefulCloseTimer;
+  @GuardedBy("lock")
+  private Long gracefulShutdownPeriod = null;
+
+  public OkHttpServerTransport(Config config, Socket bareSocket) {
+    this.config = Preconditions.checkNotNull(config, "config");
+    this.socket = Preconditions.checkNotNull(bareSocket, "bareSocket");
+
+    tracer = config.transportTracerFactory.create();
+    tracer.setFlowControlWindowReader(this::readFlowControlWindow);
+    logId = InternalLogId.allocate(getClass(), socket.getRemoteSocketAddress().toString());
+    transportExecutor = config.transportExecutorPool.getObject();
+    scheduledExecutorService = config.scheduledExecutorServicePool.getObject();
+    keepAliveEnforcer = new KeepAliveEnforcer(config.permitKeepAliveWithoutCalls,
+        config.permitKeepAliveTimeInNanos, TimeUnit.NANOSECONDS);
+  }
+
+  public void start(ServerTransportListener listener) {
+    this.listener = Preconditions.checkNotNull(listener, "listener");
+
+    SerializingExecutor serializingExecutor = new SerializingExecutor(transportExecutor);
+    serializingExecutor.execute(() -> startIo(serializingExecutor));
+  }
+
+  private void startIo(SerializingExecutor serializingExecutor) {
+    try {
+      // The socket implementation is lazily initialized, but had broken thread-safety 
+      // for that laziness https://bugs.openjdk.org/browse/JDK-8278326. 
+      // As a workaround, we lock to synchronize initialization with shutdown().
+      synchronized (lock) {
+        socket.setTcpNoDelay(true);
+      }
+      HandshakerSocketFactory.HandshakeResult result =
+          config.handshakerSocketFactory.handshake(socket, Attributes.EMPTY);
+      synchronized (lock) {
+        if (socket.isClosed()) {
+          // The wrapped socket may not handle the underlying socket being closed by shutdown(). In
+          // particular, SSLSocket hangs future reads if the underlying socket is already closed at
+          // this point, even if you call sslSocket.close() later.
+          result.socket.close();
+          throw new SocketException("Socket close raced with handshake");
+        }
+        this.socket = result.socket;
+      }
+      this.attributes = result.attributes;
+
+      int maxQueuedControlFrames = 10000;
+      AsyncSink asyncSink = AsyncSink.sink(serializingExecutor, this, maxQueuedControlFrames);
+      asyncSink.becomeConnected(Okio.sink(socket), socket);
+      FrameWriter rawFrameWriter = asyncSink.limitControlFramesWriter(
+          variant.newWriter(Okio.buffer(asyncSink), false));
+      FrameWriter writeMonitoringFrameWriter = new ForwardingFrameWriter(rawFrameWriter) {
+        @Override
+        public void synReply(boolean outFinished, int streamId, List<Header> headerBlock)
+            throws IOException {
+          keepAliveEnforcer.resetCounters();
+          super.synReply(outFinished, streamId, headerBlock);
+        }
+
+        @Override
+        public void headers(int streamId, List<Header> headerBlock) throws IOException {
+          keepAliveEnforcer.resetCounters();
+          super.headers(streamId, headerBlock);
+        }
+
+        @Override
+        public void data(boolean outFinished, int streamId, Buffer source, int byteCount)
+            throws IOException {
+          keepAliveEnforcer.resetCounters();
+          super.data(outFinished, streamId, source, byteCount);
+        }
+      };
+      synchronized (lock) {
+        this.securityInfo = result.securityInfo;
+
+        // Handle FrameWriter exceptions centrally, since there are many callers. Note that
+        // errors coming from rawFrameWriter are generally broken invariants/bugs, as AsyncSink
+        // does not propagate syscall errors through the FrameWriter. But we handle the
+        // AsyncSink failures with the same TransportExceptionHandler instance so it is all
+        // mixed back together.
+        frameWriter = new ExceptionHandlingFrameWriter(this, writeMonitoringFrameWriter);
+        outboundFlow = new OutboundFlowController(this, frameWriter);
+
+        // These writes will be queued in the serializingExecutor waiting for this function to
+        // return.
+        frameWriter.connectionPreface();
+        Settings settings = new Settings();
+        OkHttpSettingsUtil.set(settings,
+            OkHttpSettingsUtil.INITIAL_WINDOW_SIZE, config.flowControlWindow);
+        OkHttpSettingsUtil.set(settings,
+            OkHttpSettingsUtil.MAX_HEADER_LIST_SIZE, config.maxInboundMetadataSize);
+        if (config.maxConcurrentStreams != Integer.MAX_VALUE) {
+          OkHttpSettingsUtil.set(settings,
+              OkHttpSettingsUtil.MAX_CONCURRENT_STREAMS, config.maxConcurrentStreams);
+        }
+        frameWriter.settings(settings);
+        if (config.flowControlWindow > Utils.DEFAULT_WINDOW_SIZE) {
+          frameWriter.windowUpdate(
+              Utils.CONNECTION_STREAM_ID, config.flowControlWindow - Utils.DEFAULT_WINDOW_SIZE);
+        }
+        frameWriter.flush();
+      }
+
+      if (config.keepAliveTimeNanos != GrpcUtil.KEEPALIVE_TIME_NANOS_DISABLED) {
+        keepAliveManager = new KeepAliveManager(
+            new KeepAlivePinger(), scheduledExecutorService, config.keepAliveTimeNanos,
+            config.keepAliveTimeoutNanos, true);
+        keepAliveManager.onTransportStarted();
+      }
+
+      if (config.maxConnectionIdleNanos != MAX_CONNECTION_IDLE_NANOS_DISABLED) {
+        maxConnectionIdleManager = new MaxConnectionIdleManager(config.maxConnectionIdleNanos);
+        maxConnectionIdleManager.start(this::shutdown, scheduledExecutorService);
+      }
+
+      if (config.maxConnectionAgeInNanos != MAX_CONNECTION_AGE_NANOS_DISABLED) {
+        long maxConnectionAgeInNanos =
+            (long) ((.9D + Math.random() * .2D) * config.maxConnectionAgeInNanos);
+        maxConnectionAgeMonitor = scheduledExecutorService.schedule(
+            new LogExceptionRunnable(() -> shutdown(config.maxConnectionAgeGraceInNanos)),
+            maxConnectionAgeInNanos,
+            TimeUnit.NANOSECONDS);
+      }
+
+      transportExecutor.execute(new FrameHandler(
+          variant.newReader(Okio.buffer(Okio.source(socket)), false)));
+    } catch (Error | IOException | RuntimeException ex) {
+      synchronized (lock) {
+        if (!handshakeShutdown) {
+          log.log(Level.INFO, "Socket failed to handshake", ex);
+        }
+      }
+      GrpcUtil.closeQuietly(socket);
+      terminated();
+    }
+  }
+
+  @Override
+  public void shutdown() {
+    shutdown(null);
+  }
+
+  private void shutdown(@Nullable Long gracefulShutdownPeriod) {
+    synchronized (lock) {
+      if (gracefulShutdown || abruptShutdown) {
+        return;
+      }
+      gracefulShutdown = true;
+      this.gracefulShutdownPeriod = gracefulShutdownPeriod;
+      if (frameWriter == null) {
+        handshakeShutdown = true;
+        GrpcUtil.closeQuietly(socket);
+      } else {
+        // RFC7540 §6.8. Begin double-GOAWAY graceful shutdown. To wait one RTT we use a PING, but
+        // we also set a timer to limit the upper bound in case the PING is excessively stalled or
+        // the client is malicious.
+        secondGoawayTimer = scheduledExecutorService.schedule(
+            this::triggerGracefulSecondGoaway,
+            GRACEFUL_SHUTDOWN_PING_TIMEOUT_NANOS, TimeUnit.NANOSECONDS);
+        frameWriter.goAway(Integer.MAX_VALUE, ErrorCode.NO_ERROR, new byte[0]);
+        frameWriter.ping(false, 0, GRACEFUL_SHUTDOWN_PING);
+        frameWriter.flush();
+      }
+    }
+  }
+
+  private void triggerGracefulSecondGoaway() {
+    synchronized (lock) {
+      if (secondGoawayTimer == null) {
+        return;
+      }
+      secondGoawayTimer.cancel(false);
+      secondGoawayTimer = null;
+      frameWriter.goAway(lastStreamId, ErrorCode.NO_ERROR, new byte[0]);
+      goAwayStreamId = lastStreamId;
+      if (streams.isEmpty()) {
+        frameWriter.close();
+      } else {
+        frameWriter.flush();
+      }
+      if (gracefulShutdownPeriod != null) {
+        forcefulCloseTimer = scheduledExecutorService.schedule(
+            this::triggerForcefulClose, gracefulShutdownPeriod, TimeUnit.NANOSECONDS);
+      }
+    }
+  }
+
+  @Override
+  public void shutdownNow(Status reason) {
+    synchronized (lock) {
+      if (frameWriter == null) {
+        handshakeShutdown = true;
+        GrpcUtil.closeQuietly(socket);
+        return;
+      }
+    }
+    abruptShutdown(ErrorCode.NO_ERROR, "", reason, true);
+  }
+
+  /**
+   * Finish all active streams due to an IOException, then close the transport.
+   */
+  @Override
+  public void onException(Throwable failureCause) {
+    Preconditions.checkNotNull(failureCause, "failureCause");
+    Status status = Status.UNAVAILABLE.withCause(failureCause);
+    abruptShutdown(ErrorCode.INTERNAL_ERROR, "I/O failure", status, false);
+  }
+
+  private void abruptShutdown(
+      ErrorCode errorCode, String moreDetail, Status reason, boolean rstStreams) {
+    synchronized (lock) {
+      if (abruptShutdown) {
+        return;
+      }
+      abruptShutdown = true;
+      goAwayStatus = reason;
+
+      if (secondGoawayTimer != null) {
+        secondGoawayTimer.cancel(false);
+        secondGoawayTimer = null;
+      }
+      for (Map.Entry<Integer, StreamState> entry : streams.entrySet()) {
+        if (rstStreams) {
+          frameWriter.rstStream(entry.getKey(), ErrorCode.CANCEL);
+        }
+        entry.getValue().transportReportStatus(reason);
+      }
+      streams.clear();
+
+      // RFC7540 §5.4.1. Attempt to inform the client what went wrong. We try to write the GOAWAY
+      // _and then_ close our side of the connection. But place an upper-bound for how long we wait
+      // for I/O with a timer, which forcefully closes the socket.
+      frameWriter.goAway(lastStreamId, errorCode, moreDetail.getBytes(GrpcUtil.US_ASCII));
+      goAwayStreamId = lastStreamId;
+      frameWriter.close();
+      forcefulCloseTimer = scheduledExecutorService.schedule(
+          this::triggerForcefulClose, 1, TimeUnit.SECONDS);
+    }
+  }
+
+  private void triggerForcefulClose() {
+    // Safe to do unconditionally; no need to check if timer cancellation raced
+    GrpcUtil.closeQuietly(socket);
+  }
+
+  private void terminated() {
+    synchronized (lock) {
+      if (forcefulCloseTimer != null) {
+        forcefulCloseTimer.cancel(false);
+        forcefulCloseTimer = null;
+      }
+    }
+    if (keepAliveManager != null) {
+      keepAliveManager.onTransportTermination();
+    }
+    if (maxConnectionIdleManager != null) {
+      maxConnectionIdleManager.onTransportTermination();
+    }
+
+    if (maxConnectionAgeMonitor != null) {
+      maxConnectionAgeMonitor.cancel(false);
+    }
+    transportExecutor = config.transportExecutorPool.returnObject(transportExecutor);
+    scheduledExecutorService =
+        config.scheduledExecutorServicePool.returnObject(scheduledExecutorService);
+    listener.transportTerminated();
+  }
+
+  @Override
+  public ScheduledExecutorService getScheduledExecutorService() {
+    return scheduledExecutorService;
+  }
+
+  @Override
+  public ListenableFuture<InternalChannelz.SocketStats> getStats() {
+    synchronized (lock) {
+      return Futures.immediateFuture(new InternalChannelz.SocketStats(
+          tracer.getStats(),
+          socket.getLocalSocketAddress(),
+          socket.getRemoteSocketAddress(),
+          Utils.getSocketOptions(socket),
+          securityInfo));
+    }
+  }
+
+  private TransportTracer.FlowControlWindows readFlowControlWindow() {
+    synchronized (lock) {
+      long local = outboundFlow == null ? -1 : outboundFlow.windowUpdate(null, 0);
+      // connectionUnacknowledgedBytesRead is only readable by FrameHandler, so we provide a lower
+      // bound.
+      long remote = (long) (config.flowControlWindow * Utils.DEFAULT_WINDOW_UPDATE_RATIO);
+      return new TransportTracer.FlowControlWindows(local, remote);
+    }
+  }
+
+  @Override
+  public InternalLogId getLogId() {
+    return logId;
+  }
+
+  @Override
+  public OutboundFlowController.StreamState[] getActiveStreams() {
+    synchronized (lock) {
+      OutboundFlowController.StreamState[] flowStreams =
+          new OutboundFlowController.StreamState[streams.size()];
+      int i = 0;
+      for (StreamState stream : streams.values()) {
+        flowStreams[i++] = stream.getOutboundFlowState();
+      }
+      return flowStreams;
+    }
+  }
+
+  /**
+   * Notify the transport that the stream was closed. Any frames for the stream must be enqueued
+   * before calling.
+   */
+  void streamClosed(int streamId, boolean flush) {
+    synchronized (lock) {
+      streams.remove(streamId);
+      if (streams.isEmpty()) {
+        keepAliveEnforcer.onTransportIdle();
+        if (maxConnectionIdleManager != null) {
+          maxConnectionIdleManager.onTransportIdle();
+        }
+      }
+      if (gracefulShutdown && streams.isEmpty()) {
+        frameWriter.close();
+      } else {
+        if (flush) {
+          frameWriter.flush();
+        }
+      }
+    }
+  }
+
+  private static String asciiString(ByteString value) {
+    // utf8() string is cached in ByteString, so we prefer it when the contents are ASCII. This
+    // provides benefit if the header was reused via HPACK.
+    for (int i = 0; i < value.size(); i++) {
+      if (value.getByte(i) < 0) {
+        return value.string(GrpcUtil.US_ASCII);
+      }
+    }
+    return value.utf8();
+  }
+
+  private static int headerFind(List<Header> header, ByteString key, int startIndex) {
+    for (int i = startIndex; i < header.size(); i++) {
+      if (header.get(i).name.equals(key)) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  private static boolean headerContains(List<Header> header, ByteString key) {
+    return headerFind(header, key, 0) != -1;
+  }
+
+  private static void headerRemove(List<Header> header, ByteString key) {
+    int i = 0;
+    while ((i = headerFind(header, key, i)) != -1) {
+      header.remove(i);
+    }
+  }
+
+  /** Assumes that caller requires this field, so duplicates are treated as missing. */
+  private static ByteString headerGetRequiredSingle(List<Header> header, ByteString key) {
+    int i = headerFind(header, key, 0);
+    if (i == -1) {
+      return null;
+    }
+    if (headerFind(header, key, i + 1) != -1) {
+      return null;
+    }
+    return header.get(i).value;
+  }
+
+  static final class Config {
+    final List<? extends ServerStreamTracer.Factory> streamTracerFactories;
+    final ObjectPool<Executor> transportExecutorPool;
+    final ObjectPool<ScheduledExecutorService> scheduledExecutorServicePool;
+    final TransportTracer.Factory transportTracerFactory;
+    final HandshakerSocketFactory handshakerSocketFactory;
+    final long keepAliveTimeNanos;
+    final long keepAliveTimeoutNanos;
+    final int flowControlWindow;
+    final int maxInboundMessageSize;
+    final int maxInboundMetadataSize;
+    final long maxConnectionIdleNanos;
+    final boolean permitKeepAliveWithoutCalls;
+    final long permitKeepAliveTimeInNanos;
+    final long maxConnectionAgeInNanos;
+    final long maxConnectionAgeGraceInNanos;
+    final int maxConcurrentStreams;
+
+    public Config(
+        OkHttpServerBuilder builder,
+        List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+      this.streamTracerFactories = Preconditions.checkNotNull(
+          streamTracerFactories, "streamTracerFactories");
+      transportExecutorPool = Preconditions.checkNotNull(
+          builder.transportExecutorPool, "transportExecutorPool");
+      scheduledExecutorServicePool = Preconditions.checkNotNull(
+          builder.scheduledExecutorServicePool, "scheduledExecutorServicePool");
+      transportTracerFactory = Preconditions.checkNotNull(
+          builder.transportTracerFactory, "transportTracerFactory");
+      handshakerSocketFactory = Preconditions.checkNotNull(
+          builder.handshakerSocketFactory, "handshakerSocketFactory");
+      keepAliveTimeNanos = builder.keepAliveTimeNanos;
+      keepAliveTimeoutNanos = builder.keepAliveTimeoutNanos;
+      flowControlWindow = builder.flowControlWindow;
+      maxInboundMessageSize = builder.maxInboundMessageSize;
+      maxInboundMetadataSize = builder.maxInboundMetadataSize;
+      maxConnectionIdleNanos = builder.maxConnectionIdleInNanos;
+      permitKeepAliveWithoutCalls = builder.permitKeepAliveWithoutCalls;
+      permitKeepAliveTimeInNanos = builder.permitKeepAliveTimeInNanos;
+      maxConnectionAgeInNanos = builder.maxConnectionAgeInNanos;
+      maxConnectionAgeGraceInNanos = builder.maxConnectionAgeGraceInNanos;
+      maxConcurrentStreams = builder.maxConcurrentCallsPerConnection;
+    }
+  }
+
+  /**
+   * Runnable which reads frames and dispatches them to in flight calls.
+   */
+  class FrameHandler implements FrameReader.Handler, Runnable {
+    private final OkHttpFrameLogger frameLogger =
+        new OkHttpFrameLogger(Level.FINE, OkHttpServerTransport.class);
+    private final FrameReader frameReader;
+    private boolean receivedSettings;
+    private int connectionUnacknowledgedBytesRead;
+
+    public FrameHandler(FrameReader frameReader) {
+      this.frameReader = frameReader;
+    }
+
+    @Override
+    public void run() {
+      String threadName = Thread.currentThread().getName();
+      Thread.currentThread().setName("OkHttpServerTransport");
+      try {
+        frameReader.readConnectionPreface();
+        if (!frameReader.nextFrame(this)) {
+          connectionError(ErrorCode.INTERNAL_ERROR, "Failed to read initial SETTINGS");
+          return;
+        }
+        if (!receivedSettings) {
+          connectionError(ErrorCode.PROTOCOL_ERROR,
+              "First HTTP/2 frame must be SETTINGS. RFC7540 section 3.5");
+          return;
+        }
+        // Read until the underlying socket closes.
+        while (frameReader.nextFrame(this)) {
+          if (keepAliveManager != null) {
+            keepAliveManager.onDataReceived();
+          }
+        }
+        // frameReader.nextFrame() returns false when the underlying read encounters an IOException,
+        // it may be triggered by the socket closing, in such case, the startGoAway() will do
+        // nothing, otherwise, we finish all streams since it's a real IO issue.
+        Status status;
+        synchronized (lock) {
+          status = goAwayStatus;
+        }
+        if (status == null) {
+          status = Status.UNAVAILABLE.withDescription("TCP connection closed or IOException");
+        }
+        abruptShutdown(ErrorCode.INTERNAL_ERROR, "I/O failure", status, false);
+      } catch (Throwable t) {
+        log.log(Level.WARNING, "Error decoding HTTP/2 frames", t);
+        abruptShutdown(ErrorCode.INTERNAL_ERROR, "Error in frame decoder",
+            Status.INTERNAL.withDescription("Error decoding HTTP/2 frames").withCause(t), false);
+      } finally {
+        // Wait for the abrupt shutdown to be processed by AsyncSink and close the socket
+        try {
+          GrpcUtil.exhaust(socket.getInputStream());
+        } catch (IOException ex) {
+          // Unable to wait, so just proceed to tear-down. The socket is probably already closed so
+          // the GOAWAY can't be sent anyway.
+        }
+        GrpcUtil.closeQuietly(socket);
+        terminated();
+        Thread.currentThread().setName(threadName);
+      }
+    }
+
+    /**
+     * Handle HTTP2 HEADER and CONTINUATION frames.
+     */
+    @Override
+    public void headers(boolean outFinished,
+        boolean inFinished,
+        int streamId,
+        int associatedStreamId,
+        List<Header> headerBlock,
+        HeadersMode headersMode) {
+      frameLogger.logHeaders(
+          OkHttpFrameLogger.Direction.INBOUND, streamId, headerBlock, inFinished);
+      // streamId == 0 checking is in HTTP/2 decoder
+      if ((streamId & 1) == 0) {
+        // The server doesn't use PUSH_PROMISE, so all even streams are IDLE
+        connectionError(ErrorCode.PROTOCOL_ERROR,
+            "Clients cannot open even numbered streams. RFC7540 section 5.1.1");
+        return;
+      }
+      boolean newStream;
+      synchronized (lock) {
+        if (streamId > goAwayStreamId) {
+          return;
+        }
+        newStream = streamId > lastStreamId;
+        if (newStream) {
+          lastStreamId = streamId;
+          if (config.maxConcurrentStreams <= streams.size()) {
+            streamError(streamId, ErrorCode.REFUSED_STREAM,
+                "Max concurrent stream reached. RFC7540 section 5.1.2");
+            return;
+          }
+        }
+      }
+
+      int metadataSize = headerBlockSize(headerBlock);
+      if (metadataSize > config.maxInboundMetadataSize) {
+        respondWithHttpError(streamId, inFinished, 431, Status.Code.RESOURCE_EXHAUSTED,
+            String.format(
+                Locale.US,
+                "Request metadata larger than %d: %d",
+                config.maxInboundMetadataSize,
+                metadataSize));
+        return;
+      }
+
+      headerRemove(headerBlock, ByteString.EMPTY);
+
+      ByteString httpMethod = null;
+      ByteString scheme = null;
+      ByteString path = null;
+      ByteString authority = null;
+      while (headerBlock.size() > 0 && headerBlock.get(0).name.getByte(0) == ':') {
+        Header header = headerBlock.remove(0);
+        if (HTTP_METHOD.equals(header.name) && httpMethod == null) {
+          httpMethod = header.value;
+        } else if (SCHEME.equals(header.name) && scheme == null) {
+          scheme = header.value;
+        } else if (PATH.equals(header.name) && path == null) {
+          path = header.value;
+        } else if (AUTHORITY.equals(header.name) && authority == null) {
+          authority = header.value;
+        } else {
+          streamError(streamId, ErrorCode.PROTOCOL_ERROR,
+              "Unexpected pseudo header. RFC7540 section 8.1.2.1");
+          return;
+        }
+      }
+      for (int i = 0; i < headerBlock.size(); i++) {
+        if (headerBlock.get(i).name.getByte(0) == ':') {
+          streamError(streamId, ErrorCode.PROTOCOL_ERROR,
+              "Pseudo header not before regular headers. RFC7540 section 8.1.2.1");
+          return;
+        }
+      }
+      if (!CONNECT_METHOD.equals(httpMethod)
+          && newStream
+          && (httpMethod == null || scheme == null || path == null)) {
+        streamError(streamId, ErrorCode.PROTOCOL_ERROR,
+            "Missing required pseudo header. RFC7540 section 8.1.2.3");
+        return;
+      }
+      if (headerContains(headerBlock, CONNECTION)) {
+        streamError(streamId, ErrorCode.PROTOCOL_ERROR,
+            "Connection-specific headers not permitted. RFC7540 section 8.1.2.2");
+        return;
+      }
+
+      if (!newStream) {
+        if (inFinished) {
+          synchronized (lock) {
+            StreamState stream = streams.get(streamId);
+            if (stream == null) {
+              streamError(streamId, ErrorCode.STREAM_CLOSED, "Received headers for closed stream");
+              return;
+            }
+            if (stream.hasReceivedEndOfStream()) {
+              streamError(streamId, ErrorCode.STREAM_CLOSED,
+                  "Received HEADERS for half-closed (remote) stream. RFC7540 section 5.1");
+              return;
+            }
+            // Ignore the trailers, but still half-close the stream
+            stream.inboundDataReceived(new Buffer(), 0, 0, true);
+            return;
+          }
+        } else {
+          streamError(streamId, ErrorCode.PROTOCOL_ERROR,
+              "Headers disallowed in the middle of the stream. RFC7540 section 8.1");
+          return;
+        }
+      }
+
+      if (authority == null) {
+        int i = headerFind(headerBlock, HOST, 0);
+        if (i != -1) {
+          if (headerFind(headerBlock, HOST, i + 1) != -1) {
+            respondWithHttpError(streamId, inFinished, 400, Status.Code.INTERNAL,
+                "Multiple host headers disallowed. RFC7230 section 5.4");
+            return;
+          }
+          authority = headerBlock.get(i).value;
+        }
+      }
+      headerRemove(headerBlock, HOST);
+
+      // Remove the leading slash of the path and get the fully qualified method name
+      if (path.size() == 0 || path.getByte(0) != '/') {
+        respondWithHttpError(streamId, inFinished, 404, Status.Code.UNIMPLEMENTED,
+            "Expected path to start with /: " + asciiString(path));
+        return;
+      }
+      String method = asciiString(path).substring(1);
+
+      ByteString contentType = headerGetRequiredSingle(headerBlock, CONTENT_TYPE);
+      if (contentType == null) {
+        respondWithHttpError(streamId, inFinished, 415, Status.Code.INTERNAL,
+            "Content-Type is missing or duplicated");
+        return;
+      }
+      String contentTypeString = asciiString(contentType);
+      if (!GrpcUtil.isGrpcContentType(contentTypeString)) {
+        respondWithHttpError(streamId, inFinished, 415, Status.Code.INTERNAL,
+            "Content-Type is not supported: " + contentTypeString);
+        return;
+      }
+
+      if (!POST_METHOD.equals(httpMethod)) {
+        List<Header> extraHeaders = Lists.newArrayList(new Header(ALLOW, POST_METHOD));
+        respondWithHttpError(streamId, inFinished, 405, Status.Code.INTERNAL,
+            "HTTP Method is not supported: " + asciiString(httpMethod), extraHeaders);
+        return;
+      }
+
+      ByteString te = headerGetRequiredSingle(headerBlock, TE);
+      if (!TE_TRAILERS.equals(te)) {
+        respondWithGrpcError(streamId, inFinished, Status.Code.INTERNAL,
+            String.format("Expected header TE: %s, but %s is received. "
+              + "Some intermediate proxy may not support trailers",
+              asciiString(TE_TRAILERS), te == null ? "<missing>" : asciiString(te)));
+        return;
+      }
+      headerRemove(headerBlock, CONTENT_LENGTH);
+
+      Metadata metadata = Utils.convertHeaders(headerBlock);
+      StatsTraceContext statsTraceCtx =
+          StatsTraceContext.newServerContext(config.streamTracerFactories, method, metadata);
+      synchronized (lock) {
+        OkHttpServerStream.TransportState stream = new OkHttpServerStream.TransportState(
+            OkHttpServerTransport.this,
+            streamId,
+            config.maxInboundMessageSize,
+            statsTraceCtx,
+            lock,
+            frameWriter,
+            outboundFlow,
+            config.flowControlWindow,
+            tracer,
+            method);
+        OkHttpServerStream streamForApp = new OkHttpServerStream(
+            stream,
+            attributes,
+            authority == null ? null : asciiString(authority),
+            statsTraceCtx,
+            tracer);
+        if (streams.isEmpty()) {
+          keepAliveEnforcer.onTransportActive();
+          if (maxConnectionIdleManager != null) {
+            maxConnectionIdleManager.onTransportActive();
+          }
+        }
+        streams.put(streamId, stream);
+        listener.streamCreated(streamForApp, method, metadata);
+        stream.onStreamAllocated();
+        if (inFinished) {
+          stream.inboundDataReceived(new Buffer(), 0, 0, inFinished);
+        }
+      }
+    }
+
+    private int headerBlockSize(List<Header> headerBlock) {
+      // Calculate as defined for SETTINGS_MAX_HEADER_LIST_SIZE in RFC 7540 §6.5.2.
+      long size = 0;
+      for (int i = 0; i < headerBlock.size(); i++) {
+        Header header = headerBlock.get(i);
+        size += 32 + header.name.size() + header.value.size();
+      }
+      size = Math.min(size, Integer.MAX_VALUE);
+      return (int) size;
+    }
+
+    /**
+     * Handle an HTTP2 DATA frame.
+     */
+    @Override
+    public void data(boolean inFinished, int streamId, BufferedSource in, int length,
+                     int paddedLength)
+        throws IOException {
+      frameLogger.logData(
+          OkHttpFrameLogger.Direction.INBOUND, streamId, in.getBuffer(), length, inFinished);
+      if (streamId == 0) {
+        connectionError(ErrorCode.PROTOCOL_ERROR,
+            "Stream 0 is reserved for control messages. RFC7540 section 5.1.1");
+        return;
+      }
+      if ((streamId & 1) == 0) {
+        // The server doesn't use PUSH_PROMISE, so all even streams are IDLE
+        connectionError(ErrorCode.PROTOCOL_ERROR,
+            "Clients cannot open even numbered streams. RFC7540 section 5.1.1");
+        return;
+      }
+
+      // Wait until the frame is complete. We only support 16 KiB frames, and the max permitted in
+      // HTTP/2 is 16 MiB. This is verified in OkHttp's Http2 deframer, so we don't need to be
+      // concerned with the window being exceeded at this point.
+      in.require(length);
+
+      synchronized (lock) {
+        StreamState stream = streams.get(streamId);
+        if (stream == null) {
+          in.skip(length);
+          streamError(streamId, ErrorCode.STREAM_CLOSED, "Received data for closed stream");
+          return;
+        }
+        if (stream.hasReceivedEndOfStream()) {
+          in.skip(length);
+          streamError(streamId, ErrorCode.STREAM_CLOSED,
+              "Received DATA for half-closed (remote) stream. RFC7540 section 5.1");
+          return;
+        }
+        if (stream.inboundWindowAvailable() < paddedLength) {
+          in.skip(length);
+          streamError(streamId, ErrorCode.FLOW_CONTROL_ERROR,
+              "Received DATA size exceeded window size. RFC7540 section 6.9");
+          return;
+        }
+        Buffer buf = new Buffer();
+        buf.write(in.getBuffer(), length);
+        stream.inboundDataReceived(buf, length, paddedLength - length, inFinished);
+      }
+
+      // connection window update
+      connectionUnacknowledgedBytesRead += paddedLength;
+      if (connectionUnacknowledgedBytesRead
+          >= config.flowControlWindow * Utils.DEFAULT_WINDOW_UPDATE_RATIO) {
+        synchronized (lock) {
+          frameWriter.windowUpdate(0, connectionUnacknowledgedBytesRead);
+          frameWriter.flush();
+        }
+        connectionUnacknowledgedBytesRead = 0;
+      }
+    }
+
+    @Override
+    public void rstStream(int streamId, ErrorCode errorCode) {
+      frameLogger.logRstStream(OkHttpFrameLogger.Direction.INBOUND, streamId, errorCode);
+      // streamId == 0 checking is in HTTP/2 decoder
+
+      if (!(ErrorCode.NO_ERROR.equals(errorCode)
+            || ErrorCode.CANCEL.equals(errorCode)
+            || ErrorCode.STREAM_CLOSED.equals(errorCode))) {
+        log.log(Level.INFO, "Received RST_STREAM: " + errorCode);
+      }
+      Status status = GrpcUtil.Http2Error.statusForCode(errorCode.httpCode)
+          .withDescription("RST_STREAM");
+      synchronized (lock) {
+        StreamState stream = streams.get(streamId);
+        if (stream != null) {
+          stream.inboundRstReceived(status);
+          streamClosed(streamId, /*flush=*/ false);
+        }
+      }
+    }
+
+    @Override
+    public void settings(boolean clearPrevious, Settings settings) {
+      frameLogger.logSettings(OkHttpFrameLogger.Direction.INBOUND, settings);
+      synchronized (lock) {
+        boolean outboundWindowSizeIncreased = false;
+        if (OkHttpSettingsUtil.isSet(settings, OkHttpSettingsUtil.INITIAL_WINDOW_SIZE)) {
+          int initialWindowSize = OkHttpSettingsUtil.get(
+              settings, OkHttpSettingsUtil.INITIAL_WINDOW_SIZE);
+          outboundWindowSizeIncreased = outboundFlow.initialOutboundWindowSize(initialWindowSize);
+        }
+
+        // The changed settings are not finalized until SETTINGS acknowledgment frame is sent. Any
+        // writes due to update in settings must be sent after SETTINGS acknowledgment frame,
+        // otherwise it will cause a stream error (RST_STREAM).
+        frameWriter.ackSettings(settings);
+        frameWriter.flush();
+        if (!receivedSettings) {
+          receivedSettings = true;
+          attributes = listener.transportReady(attributes);
+        }
+
+        // send any pending bytes / streams
+        if (outboundWindowSizeIncreased) {
+          outboundFlow.writeStreams();
+        }
+      }
+    }
+
+    @Override
+    public void ping(boolean ack, int payload1, int payload2) {
+      long payload = (((long) payload1) << 32) | (payload2 & 0xffffffffL);
+      if (!ack) {
+        if (!keepAliveEnforcer.pingAcceptable()) {
+          abruptShutdown(ErrorCode.ENHANCE_YOUR_CALM, "too_many_pings",
+              Status.RESOURCE_EXHAUSTED.withDescription("Too many pings from client"), false);
+          return;
+        }
+        frameLogger.logPing(OkHttpFrameLogger.Direction.INBOUND, payload);
+        synchronized (lock) {
+          frameWriter.ping(true, payload1, payload2);
+          frameWriter.flush();
+        }
+      } else {
+        frameLogger.logPingAck(OkHttpFrameLogger.Direction.INBOUND, payload);
+        if (KEEPALIVE_PING == payload) {
+          return;
+        }
+        if (GRACEFUL_SHUTDOWN_PING == payload) {
+          triggerGracefulSecondGoaway();
+          return;
+        }
+        log.log(Level.INFO, "Received unexpected ping ack: " + payload);
+      }
+    }
+
+    @Override
+    public void ackSettings() {}
+
+    @Override
+    public void goAway(int lastGoodStreamId, ErrorCode errorCode, ByteString debugData) {
+      frameLogger.logGoAway(
+          OkHttpFrameLogger.Direction.INBOUND, lastGoodStreamId, errorCode, debugData);
+      String description = String.format("Received GOAWAY: %s '%s'", errorCode, debugData.utf8());
+      Status status = GrpcUtil.Http2Error.statusForCode(errorCode.httpCode)
+          .withDescription(description);
+      if (!ErrorCode.NO_ERROR.equals(errorCode)) {
+        log.log(
+            Level.WARNING, "Received GOAWAY: {0} {1}", new Object[] {errorCode, debugData.utf8()});
+      }
+      synchronized (lock) {
+        goAwayStatus = status;
+      }
+    }
+
+    @Override
+    public void pushPromise(int streamId, int promisedStreamId, List<Header> requestHeaders)
+        throws IOException {
+      frameLogger.logPushPromise(OkHttpFrameLogger.Direction.INBOUND,
+          streamId, promisedStreamId, requestHeaders);
+      // streamId == 0 checking is in HTTP/2 decoder.
+      // The server doesn't use PUSH_PROMISE, so all even streams are IDLE, and odd streams are not
+      // peer-initiated.
+      connectionError(ErrorCode.PROTOCOL_ERROR,
+          "PUSH_PROMISE only allowed on peer-initiated streams. RFC7540 section 6.6");
+    }
+
+    @Override
+    public void windowUpdate(int streamId, long delta) {
+      frameLogger.logWindowsUpdate(OkHttpFrameLogger.Direction.INBOUND, streamId, delta);
+      // delta == 0 checking is in HTTP/2 decoder. And it isn't quite right, as it will always cause
+      // a GOAWAY. RFC7540 section 6.9 says to use RST_STREAM if the stream id isn't 0. Doesn't
+      // matter much though.
+      synchronized (lock) {
+        if (streamId == Utils.CONNECTION_STREAM_ID) {
+          outboundFlow.windowUpdate(null, (int) delta);
+        } else {
+          StreamState stream = streams.get(streamId);
+          if (stream != null) {
+            outboundFlow.windowUpdate(stream.getOutboundFlowState(), (int) delta);
+          }
+        }
+      }
+    }
+
+    @Override
+    public void priority(int streamId, int streamDependency, int weight, boolean exclusive) {
+      frameLogger.logPriority(
+          OkHttpFrameLogger.Direction.INBOUND, streamId, streamDependency, weight, exclusive);
+      // streamId == 0 checking is in HTTP/2 decoder.
+      // Ignore priority change.
+    }
+
+    @Override
+    public void alternateService(int streamId, String origin, ByteString protocol, String host,
+        int port, long maxAge) {}
+
+    /**
+     * Send GOAWAY to the server, then finish all streams and close the transport. RFC7540 §5.4.1.
+     */
+    private void connectionError(ErrorCode errorCode, String moreDetail) {
+      Status status = GrpcUtil.Http2Error.statusForCode(errorCode.httpCode)
+          .withDescription(String.format("HTTP2 connection error: %s '%s'", errorCode, moreDetail));
+      abruptShutdown(errorCode, moreDetail, status, false);
+    }
+
+    /**
+     * Respond with RST_STREAM, making sure to kill the associated stream if it exists. Reason will
+     * rarely be seen. RFC7540 §5.4.2.
+     */
+    private void streamError(int streamId, ErrorCode errorCode, String reason) {
+      if (errorCode == ErrorCode.PROTOCOL_ERROR) {
+        log.log(
+            Level.FINE, "Responding with RST_STREAM {0}: {1}", new Object[] {errorCode, reason});
+      }
+      synchronized (lock) {
+        frameWriter.rstStream(streamId, errorCode);
+        frameWriter.flush();
+        StreamState stream = streams.get(streamId);
+        if (stream != null) {
+          stream.transportReportStatus(
+              Status.INTERNAL.withDescription(
+                  String.format("Responded with RST_STREAM %s: %s", errorCode, reason)));
+          streamClosed(streamId, /*flush=*/ false);
+        }
+      }
+    }
+
+    private void respondWithHttpError(
+        int streamId, boolean inFinished, int httpCode, Status.Code statusCode, String msg) {
+      respondWithHttpError(streamId, inFinished, httpCode, statusCode, msg,
+              Collections.emptyList());
+    }
+
+    private void respondWithHttpError(
+        int streamId, boolean inFinished, int httpCode, Status.Code statusCode, String msg,
+        List<Header> extraHeaders) {
+      Metadata metadata = new Metadata();
+      metadata.put(InternalStatus.CODE_KEY, statusCode.toStatus());
+      metadata.put(InternalStatus.MESSAGE_KEY, msg);
+      List<Header> headers =
+          Headers.createHttpResponseHeaders(httpCode, "text/plain; charset=utf-8", metadata);
+      headers.addAll(extraHeaders);
+      Buffer data = new Buffer().writeUtf8(msg);
+
+      synchronized (lock) {
+        Http2ErrorStreamState stream =
+            new Http2ErrorStreamState(streamId, lock, outboundFlow, config.flowControlWindow);
+        if (streams.isEmpty()) {
+          keepAliveEnforcer.onTransportActive();
+          if (maxConnectionIdleManager != null) {
+            maxConnectionIdleManager.onTransportActive();
+          }
+        }
+        streams.put(streamId, stream);
+        if (inFinished) {
+          stream.inboundDataReceived(new Buffer(), 0, 0, true);
+        }
+        frameWriter.headers(streamId, headers);
+        outboundFlow.data(
+            /*outFinished=*/true, stream.getOutboundFlowState(), data, /*flush=*/true);
+        outboundFlow.notifyWhenNoPendingData(
+            stream.getOutboundFlowState(), () -> rstOkAtEndOfHttpError(stream));
+      }
+    }
+
+    private void rstOkAtEndOfHttpError(Http2ErrorStreamState stream) {
+      synchronized (lock) {
+        if (!stream.hasReceivedEndOfStream()) {
+          frameWriter.rstStream(stream.streamId, ErrorCode.NO_ERROR);
+        }
+        streamClosed(stream.streamId, /*flush=*/ true);
+      }
+    }
+
+    private void respondWithGrpcError(
+        int streamId, boolean inFinished, Status.Code statusCode, String msg) {
+      Metadata metadata = new Metadata();
+      metadata.put(InternalStatus.CODE_KEY, statusCode.toStatus());
+      metadata.put(InternalStatus.MESSAGE_KEY, msg);
+      List<Header> headers = Headers.createResponseTrailers(metadata, false);
+
+      synchronized (lock) {
+        frameWriter.synReply(true, streamId, headers);
+        if (!inFinished) {
+          frameWriter.rstStream(streamId, ErrorCode.NO_ERROR);
+        }
+        frameWriter.flush();
+      }
+    }
+  }
+
+  private final class KeepAlivePinger implements KeepAliveManager.KeepAlivePinger {
+    @Override
+    public void ping() {
+      synchronized (lock) {
+        frameWriter.ping(false, 0, KEEPALIVE_PING);
+        frameWriter.flush();
+      }
+      tracer.reportKeepAliveSent();
+    }
+
+    @Override
+    public void onPingTimeout() {
+      synchronized (lock) {
+        goAwayStatus = Status.UNAVAILABLE
+            .withDescription("Keepalive failed. Considering connection dead");
+        GrpcUtil.closeQuietly(socket);
+      }
+    }
+  }
+
+  interface StreamState {
+    /** Must be holding 'lock' when calling. */
+    void inboundDataReceived(Buffer frame, int dataLength, int paddingLength, boolean endOfStream);
+
+    /** Must be holding 'lock' when calling. */
+    boolean hasReceivedEndOfStream();
+
+    /** Must be holding 'lock' when calling. */
+    int inboundWindowAvailable();
+
+    /** Must be holding 'lock' when calling. */
+    void transportReportStatus(Status status);
+
+    /** Must be holding 'lock' when calling. */
+    void inboundRstReceived(Status status);
+
+    OutboundFlowController.StreamState getOutboundFlowState();
+  }
+
+  static class Http2ErrorStreamState implements StreamState, OutboundFlowController.Stream {
+    private final int streamId;
+    private final Object lock;
+    private final OutboundFlowController.StreamState outboundFlowState;
+    @GuardedBy("lock")
+    private int window;
+    @GuardedBy("lock")
+    private boolean receivedEndOfStream;
+
+    Http2ErrorStreamState(
+        int streamId, Object lock, OutboundFlowController outboundFlow, int initialWindowSize) {
+      this.streamId = streamId;
+      this.lock = lock;
+      this.outboundFlowState = outboundFlow.createState(this, streamId);
+      this.window = initialWindowSize;
+    }
+
+    @Override public void onSentBytes(int frameBytes) {}
+
+    @Override public void inboundDataReceived(
+        Buffer frame, int dataLength, int paddingLength, boolean endOfStream) {
+      synchronized (lock) {
+        if (endOfStream) {
+          receivedEndOfStream = true;
+        }
+        window -= dataLength + paddingLength;
+        try {
+          frame.skip(frame.size()); // Recycle segments
+        } catch (IOException ex) {
+          throw new AssertionError(ex);
+        }
+      }
+    }
+
+    @Override public boolean hasReceivedEndOfStream() {
+      synchronized (lock) {
+        return receivedEndOfStream;
+      }
+    }
+
+    @Override public int inboundWindowAvailable() {
+      synchronized (lock) {
+        return window;
+      }
+    }
+
+    @Override public void transportReportStatus(Status status) {}
+
+    @Override public void inboundRstReceived(Status status) {}
+
+    @Override public OutboundFlowController.StreamState getOutboundFlowState() {
+      synchronized (lock) {
+        return outboundFlowState;
+      }
+    }
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpSettingsUtil.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpSettingsUtil.java
index b0862f49fb2..1406b39adfd 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpSettingsUtil.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpSettingsUtil.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
@@ -39,6 +24,8 @@
 class OkHttpSettingsUtil {
   public static final int MAX_CONCURRENT_STREAMS = Settings.MAX_CONCURRENT_STREAMS;
   public static final int INITIAL_WINDOW_SIZE = Settings.INITIAL_WINDOW_SIZE;
+  public static final int MAX_HEADER_LIST_SIZE = Settings.MAX_HEADER_LIST_SIZE;
+  public static final int ENABLE_PUSH = Settings.ENABLE_PUSH;
 
   public static boolean isSet(Settings settings, int id) {
     return settings.isSet(id);
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpTlsUpgrader.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpTlsUpgrader.java
index b98fd20b39a..a8b038c91f4 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpTlsUpgrader.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpTlsUpgrader.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
@@ -34,13 +19,14 @@
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
 import io.grpc.okhttp.internal.ConnectionSpec;
-import io.grpc.okhttp.internal.OkHostnameVerifier;
 import io.grpc.okhttp.internal.Protocol;
 import java.io.IOException;
 import java.net.Socket;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import javax.annotation.Nonnull;
+import javax.net.ssl.HostnameVerifier;
 import javax.net.ssl.SSLPeerUnverifiedException;
 import javax.net.ssl.SSLSocket;
 import javax.net.ssl.SSLSocketFactory;
@@ -57,16 +43,17 @@ final class OkHttpTlsUpgrader {
    */
   @VisibleForTesting
   static final List<Protocol> TLS_PROTOCOLS =
-      Collections.unmodifiableList(Arrays.<Protocol>asList(Protocol.GRPC_EXP, Protocol.HTTP_2));
+      Collections.unmodifiableList(Arrays.asList(Protocol.HTTP_2));
 
   /**
-   * Upgrades given Socket to be a SSLSocket.
+   * Upgrades given Socket to be an SSLSocket.
    *
    * @throws IOException if an IO error was encountered during the upgrade handshake.
    * @throws RuntimeException if the upgrade negotiation failed.
    */
   public static SSLSocket upgrade(SSLSocketFactory sslSocketFactory,
-      Socket socket, String host, int port, ConnectionSpec spec) throws IOException {
+      @Nonnull HostnameVerifier hostnameVerifier, Socket socket, String host, int port,
+      ConnectionSpec spec) throws IOException {
     Preconditions.checkNotNull(sslSocketFactory, "sslSocketFactory");
     Preconditions.checkNotNull(socket, "socket");
     Preconditions.checkNotNull(spec, "spec");
@@ -80,9 +67,28 @@ public static SSLSocket upgrade(SSLSocketFactory sslSocketFactory,
         "Only " + TLS_PROTOCOLS + " are supported, but negotiated protocol is %s",
         negotiatedProtocol);
 
-    if (!OkHostnameVerifier.INSTANCE.verify(host, sslSocket.getSession())) {
+    if (!hostnameVerifier.verify(canonicalizeHost(host), sslSocket.getSession())) {
       throw new SSLPeerUnverifiedException("Cannot verify hostname: " + host);
     }
     return sslSocket;
   }
+
+  /**
+   * Converts a host from URI to X509 format.
+   *
+   * <p>IPv6 host addresses derived from URIs are enclosed in square brackets per RFC2732, but
+   * omit these brackets in X509 certificate subjectAltName extensions per RFC5280.
+   *
+   * @see <a href="https://www.ietf.org/rfc/rfc2732.txt">RFC2732</a>
+   * @see <a href="https://tools.ietf.org/html/rfc5280#section-4.2.1.6">RFC5280</a>
+   *
+   * @return {@code host} in a form consistent with X509 certificates
+   */
+  @VisibleForTesting
+  static String canonicalizeHost(String host) {
+    if (host.startsWith("[") && host.endsWith("]")) {
+      return host.substring(1, host.length() - 1);
+    }
+    return host;
+  }
 }
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpWritableBuffer.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpWritableBuffer.java
index 98013f7ede9..9cb553d0e35 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpWritableBuffer.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpWritableBuffer.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OkHttpWritableBufferAllocator.java b/okhttp/src/main/java/io/grpc/okhttp/OkHttpWritableBufferAllocator.java
index 2256c356193..58896a5dbb0 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OkHttpWritableBufferAllocator.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OkHttpWritableBufferAllocator.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
@@ -42,11 +27,9 @@
  */
 class OkHttpWritableBufferAllocator implements WritableBufferAllocator {
 
-  // Use 4k as our minimum buffer size.
-  private static final int MIN_BUFFER = 4096;
-
   // Set the maximum buffer size to 1MB
   private static final int MAX_BUFFER = 1024 * 1024;
+  public static final int SEGMENT_SIZE_COPY = 8192; // Should equal Segment.SIZE
 
   /**
    * Construct a new instance.
@@ -60,7 +43,9 @@ class OkHttpWritableBufferAllocator implements WritableBufferAllocator {
    */
   @Override
   public WritableBuffer allocate(int capacityHint) {
-    capacityHint = Math.min(MAX_BUFFER, Math.max(MIN_BUFFER, capacityHint));
+    // okio buffer uses fixed size Segments, round capacityHint up
+    capacityHint = Math.min(MAX_BUFFER,
+        (capacityHint + SEGMENT_SIZE_COPY - 1) / SEGMENT_SIZE_COPY * SEGMENT_SIZE_COPY);
     return new OkHttpWritableBuffer(new Buffer(), capacityHint);
   }
 }
diff --git a/okhttp/src/main/java/io/grpc/okhttp/OutboundFlowController.java b/okhttp/src/main/java/io/grpc/okhttp/OutboundFlowController.java
index a6f0aae0207..2c959ee0768 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/OutboundFlowController.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/OutboundFlowController.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
@@ -40,8 +25,8 @@
 import com.google.common.base.Preconditions;
 import io.grpc.okhttp.internal.framed.FrameWriter;
 import java.io.IOException;
-import java.util.ArrayDeque;
-import java.util.Queue;
+import java.util.Arrays;
+import java.util.Collections;
 import javax.annotation.Nullable;
 import okio.Buffer;
 
@@ -50,57 +35,56 @@
  * streams.
  */
 class OutboundFlowController {
-  private final OkHttpClientTransport transport;
+  private final Transport transport;
   private final FrameWriter frameWriter;
-  private int initialWindowSize = DEFAULT_WINDOW_SIZE;
-  private final OutboundFlowState connectionState = new OutboundFlowState(CONNECTION_STREAM_ID);
+  private int initialWindowSize;
+  private final StreamState connectionState;
 
-  OutboundFlowController(OkHttpClientTransport transport, FrameWriter frameWriter) {
+  public OutboundFlowController(Transport transport, FrameWriter frameWriter) {
     this.transport = Preconditions.checkNotNull(transport, "transport");
     this.frameWriter = Preconditions.checkNotNull(frameWriter, "frameWriter");
+    this.initialWindowSize = DEFAULT_WINDOW_SIZE;
+    connectionState = new StreamState(CONNECTION_STREAM_ID, DEFAULT_WINDOW_SIZE, null);
   }
 
   /**
-   * Must be called with holding transport lock.
+   * Adjusts outbound window size requested by peer. When window size is increased, it does not send
+   * any pending frames. If this method returns {@code true}, the caller should call {@link
+   * #writeStreams()} after settings ack.
+   *
+   * <p>Must be called with holding transport lock.
+   *
+   * @return true, if new window size is increased, false otherwise.
    */
-  void initialOutboundWindowSize(int newWindowSize) {
+  public boolean initialOutboundWindowSize(int newWindowSize) {
     if (newWindowSize < 0) {
       throw new IllegalArgumentException("Invalid initial window size: " + newWindowSize);
     }
 
     int delta = newWindowSize - initialWindowSize;
     initialWindowSize = newWindowSize;
-    for (OkHttpClientStream stream : transport.getActiveStreams()) {
-      OutboundFlowState state = (OutboundFlowState) stream.getOutboundFlowState();
-      if (state == null) {
-        // Create the OutboundFlowState with the new window size.
-        state = new OutboundFlowState(stream);
-        stream.setOutboundFlowState(state);
-      } else {
-        state.incrementStreamWindow(delta);
-      }
+    for (StreamState state : transport.getActiveStreams()) {
+      state.incrementStreamWindow(delta);
     }
 
-    if (delta > 0) {
-      // The window size increased, send any pending frames for all streams.
-      writeStreams();
-    }
+    return delta > 0;
   }
 
   /**
-   * Update the outbound window for given stream, or for the connection if stream is null.
+   * Update the outbound window for given stream, or for the connection if stream is null. Returns
+   * the new value of the window size.
    *
    * <p>Must be called with holding transport lock.
    */
-  void windowUpdate(@Nullable OkHttpClientStream stream, int delta) {
-    if (stream == null) {
+  public int windowUpdate(@Nullable StreamState state, int delta) {
+    final int updatedWindow;
+    if (state == null) {
       // Update the connection window and write any pending frames for all streams.
-      connectionState.incrementStreamWindow(delta);
+      updatedWindow = connectionState.incrementStreamWindow(delta);
       writeStreams();
     } else {
       // Update the stream window and write any pending frames for the stream.
-      OutboundFlowState state = state(stream);
-      state.incrementStreamWindow(delta);
+      updatedWindow = state.incrementStreamWindow(delta);
 
       WriteStatus writeStatus = new WriteStatus();
       state.writeBytes(state.writableWindow(), writeStatus);
@@ -108,55 +92,49 @@ void windowUpdate(@Nullable OkHttpClientStream stream, int delta) {
         flush();
       }
     }
+    return updatedWindow;
   }
 
   /**
    * Must be called with holding transport lock.
    */
-  void data(boolean outFinished, int streamId, Buffer source, boolean flush) {
+  public void data(boolean outFinished, StreamState state, Buffer source, boolean flush) {
     Preconditions.checkNotNull(source, "source");
 
-    OkHttpClientStream stream = transport.getStream(streamId);
-    if (stream == null) {
-      // This is possible for a stream that has received end-of-stream from server (but hasn't sent
-      // end-of-stream), and was removed from the transport stream map.
-      // In such case, we just throw away the data.
-      return;
-    }
-
-    OutboundFlowState state = state(stream);
     int window = state.writableWindow();
-    boolean framesAlreadyQueued = state.hasFrame();
+    boolean framesAlreadyQueued = state.hasPendingData();
+    int size = (int) source.size();
 
-    OutboundFlowState.Frame frame = state.newFrame(source, outFinished);
-    if (!framesAlreadyQueued && window >= frame.size()) {
+    if (!framesAlreadyQueued && window >= size) {
       // Window size is large enough to send entire data frame
-      frame.write();
-      if (flush) {
-        flush();
-      }
-      return;
-    }
-
-    // Enqueue the frame to be written when the window size permits.
-    frame.enqueue();
-
-    if (framesAlreadyQueued || window <= 0) {
-      // Stream already has frames pending or is stalled, don't send anything now.
-      if (flush) {
-        flush();
+      state.write(source, size, outFinished);
+    } else {
+      // send partial data
+      if (!framesAlreadyQueued && window > 0) {
+        state.write(source, window, false);
       }
-      return;
+      // Queue remaining data in the buffer
+      state.enqueueData(source, (int) source.size(), outFinished);
     }
 
-    // Create and send a partial frame up to the window size.
-    frame.split(window).write();
     if (flush) {
       flush();
     }
   }
 
-  void flush() {
+  /**
+   * Transport lock must be held when calling.
+   */
+  public void notifyWhenNoPendingData(StreamState state, Runnable noPendingDataRunnable) {
+    Preconditions.checkNotNull(noPendingDataRunnable, "noPendingDataRunnable");
+    if (state.hasPendingData()) {
+      state.notifyWhenNoPendingData(noPendingDataRunnable);
+    } else {
+      noPendingDataRunnable.run();
+    }
+  }
+
+  public void flush() {
     try {
       frameWriter.flush();
     } catch (IOException e) {
@@ -164,27 +142,25 @@ void flush() {
     }
   }
 
-  private OutboundFlowState state(OkHttpClientStream stream) {
-    OutboundFlowState state = (OutboundFlowState) stream.getOutboundFlowState();
-    if (state == null) {
-      state = new OutboundFlowState(stream);
-      stream.setOutboundFlowState(state);
-    }
-    return state;
+  public StreamState createState(Stream stream, int streamId) {
+    return new StreamState(
+        streamId, initialWindowSize, Preconditions.checkNotNull(stream, "stream"));
   }
 
   /**
    * Writes as much data for all the streams as possible given the current flow control windows.
+   *
+   * <p>Must be called with holding transport lock.
    */
-  private void writeStreams() {
-    OkHttpClientStream[] streams = transport.getActiveStreams();
+  public void writeStreams() {
+    StreamState[] states = transport.getActiveStreams();
+    Collections.shuffle(Arrays.asList(states));
     int connectionWindow = connectionState.window();
-    for (int numStreams = streams.length; numStreams > 0 && connectionWindow > 0;) {
+    for (int numStreams = states.length; numStreams > 0 && connectionWindow > 0;) {
       int nextNumStreams = 0;
       int windowSlice = (int) ceil(connectionWindow / (float) numStreams);
       for (int index = 0; index < numStreams && connectionWindow > 0; ++index) {
-        OkHttpClientStream stream = streams[index];
-        OutboundFlowState state = state(stream);
+        StreamState state = states[index];
 
         int bytesForStream = min(connectionWindow, min(state.unallocatedBytes(), windowSlice));
         if (bytesForStream > 0) {
@@ -195,7 +171,7 @@ private void writeStreams() {
         if (state.unallocatedBytes() > 0) {
           // There is more data to process for this stream. Add it to the next
           // pass.
-          streams[nextNumStreams++] = stream;
+          states[nextNumStreams++] = state;
         }
       }
       numStreams = nextNumStreams;
@@ -203,8 +179,7 @@ private void writeStreams() {
 
     // Now take one last pass through all of the streams and write any allocated bytes.
     WriteStatus writeStatus = new WriteStatus();
-    for (OkHttpClientStream stream : transport.getActiveStreams()) {
-      OutboundFlowState state = state(stream);
+    for (StreamState state : transport.getActiveStreams()) {
       state.writeBytes(state.allocatedBytes(), writeStatus);
       state.clearAllocatedBytes();
     }
@@ -217,7 +192,7 @@ private void writeStreams() {
   /**
    * Simple status that keeps track of the number of writes performed.
    */
-  private final class WriteStatus {
+  private static final class WriteStatus {
     int numWrites;
 
     void incrementNumWrites() {
@@ -229,24 +204,29 @@ boolean hasWritten() {
     }
   }
 
+  public interface Transport {
+    StreamState[] getActiveStreams();
+  }
+
+  public interface Stream {
+    void onSentBytes(int frameBytes);
+  }
+
   /**
    * The outbound flow control state for a single stream.
    */
-  private final class OutboundFlowState {
-    final Queue<Frame> pendingWriteQueue;
-    final int streamId;
-    int queuedBytes;
-    int window = initialWindowSize;
-    int allocatedBytes;
-    OkHttpClientStream stream;
-
-    OutboundFlowState(int streamId) {
+  public final class StreamState {
+    private final Buffer pendingWriteBuffer = new Buffer();
+    private Runnable noPendingDataRunnable;
+    private final int streamId;
+    private int window;
+    private int allocatedBytes;
+    private final Stream stream;
+    private boolean pendingBufferHasEndOfStream = false;
+
+    StreamState(int streamId, int initialWindowSize, Stream stream) {
       this.streamId = streamId;
-      pendingWriteQueue = new ArrayDeque<Frame>(2);
-    }
-
-    OutboundFlowState(OkHttpClientStream stream) {
-      this(stream.id());
+      window = initialWindowSize;
       this.stream = stream;
     }
 
@@ -291,28 +271,14 @@ int writableWindow() {
     }
 
     int streamableBytes() {
-      return max(0, min(window, queuedBytes));
-    }
-
-    /**
-     * Creates a new frame with the given values but does not add it to the pending queue.
-     */
-    Frame newFrame(Buffer data, boolean endStream) {
-      return new Frame(data, endStream);
+      return max(0, min(window, (int) pendingWriteBuffer.size()));
     }
 
     /**
      * Indicates whether or not there are frames in the pending queue.
      */
-    boolean hasFrame() {
-      return !pendingWriteQueue.isEmpty();
-    }
-
-    /**
-     * Returns the the head of the pending queue, or {@code null} if empty.
-     */
-    private Frame peek() {
-      return pendingWriteQueue.peek();
+    boolean hasPendingData() {
+      return pendingWriteBuffer.size() > 0;
     }
 
     /**
@@ -321,122 +287,60 @@ private Frame peek() {
     int writeBytes(int bytes, WriteStatus writeStatus) {
       int bytesAttempted = 0;
       int maxBytes = min(bytes, writableWindow());
-      while (hasFrame()) {
-        Frame pendingWrite = peek();
-        if (maxBytes >= pendingWrite.size()) {
+      while (hasPendingData() && maxBytes > 0) {
+        if (maxBytes >= pendingWriteBuffer.size()) {
           // Window size is large enough to send entire data frame
-          writeStatus.incrementNumWrites();
-          bytesAttempted += pendingWrite.size();
-          pendingWrite.write();
-        } else if (maxBytes <= 0) {
-          // No data from the current frame can be written - we're done.
-          // We purposely check this after first testing the size of the
-          // pending frame to properly handle zero-length frame.
-          break;
+          bytesAttempted += (int) pendingWriteBuffer.size();
+          write(pendingWriteBuffer, (int) pendingWriteBuffer.size(), pendingBufferHasEndOfStream);
         } else {
-          // We can send a partial frame
-          Frame partialFrame = pendingWrite.split(maxBytes);
-          writeStatus.incrementNumWrites();
-          bytesAttempted += partialFrame.size();
-          partialFrame.write();
+          bytesAttempted += maxBytes;
+          write(pendingWriteBuffer, maxBytes, false);
         }
-
+        writeStatus.incrementNumWrites();
         // Update the threshold.
         maxBytes = min(bytes - bytesAttempted, writableWindow());
       }
+      if (!hasPendingData() && noPendingDataRunnable != null) {
+        noPendingDataRunnable.run();
+        noPendingDataRunnable = null;
+      }
       return bytesAttempted;
     }
 
     /**
-     * A wrapper class around the content of a data frame.
+     * Writes the frame and decrements the stream and connection window sizes. If the frame is in
+     * the pending queue, the written bytes are removed from this branch of the priority tree. If
+     * the window size is smaller than the frame, it sends partial frame.
      */
-    private final class Frame {
-      final Buffer data;
-      final boolean endStream;
-      boolean enqueued;
-
-      Frame(Buffer data, boolean endStream) {
-        this.data = data;
-        this.endStream = endStream;
-      }
-
-      /**
-       * Gets the total size (in bytes) of this frame including the data and padding.
-       */
-      int size() {
-        return (int) data.size();
-      }
-
-      void enqueue() {
-        if (!enqueued) {
-          enqueued = true;
-          pendingWriteQueue.offer(this);
-
-          // Increment the number of pending bytes for this stream.
-          queuedBytes += size();
+    void write(Buffer buffer, int bytesToSend, boolean endOfStream) {
+      int bytesToWrite = bytesToSend;
+      // Using a do/while loop because if the buffer is empty we still need to call
+      // the writer once to send the empty frame.
+      do {
+        int frameBytes = min(bytesToWrite, frameWriter.maxDataLength());
+        connectionState.incrementStreamWindow(-frameBytes);
+        incrementStreamWindow(-frameBytes);
+        try {
+          // endOfStream is set for the last chunk of data marked as endOfStream
+          boolean isEndOfStream = buffer.size() == frameBytes && endOfStream;
+          frameWriter.data(isEndOfStream, streamId, buffer, frameBytes);
+        } catch (IOException e) {
+          throw new RuntimeException(e);
         }
-      }
-
-      /**
-       * Writes the frame and decrements the stream and connection window sizes. If the frame is in
-       * the pending queue, the written bytes are removed from this branch of the priority tree.
-       */
-      void write() {
-        // Using a do/while loop because if the buffer is empty we still need to call
-        // the writer once to send the empty frame.
-        do {
-          int bytesToWrite = size();
-          int frameBytes = min(bytesToWrite, frameWriter.maxDataLength());
-          if (frameBytes == bytesToWrite) {
-            // All the bytes fit into a single HTTP/2 frame, just send it all.
-            connectionState.incrementStreamWindow(-bytesToWrite);
-            incrementStreamWindow(-bytesToWrite);
-            try {
-              frameWriter.data(endStream, streamId, data, bytesToWrite);
-            } catch (IOException e) {
-              throw new RuntimeException(e);
-            }
-            stream.onStreamSentBytes(bytesToWrite);
-
-            if (enqueued) {
-              // It's enqueued - remove it from the head of the pending write queue.
-              queuedBytes -= bytesToWrite;
-              pendingWriteQueue.remove(this);
-            }
-            return;
-          }
-
-          // Split a chunk that will fit into a single HTTP/2 frame and write it.
-          Frame frame = split(frameBytes);
-          frame.write();
-        } while (size() > 0);
-      }
-
-      /**
-       * Creates a new frame that is a view of this frame's data. The {@code maxBytes} are first
-       * split from the data buffer. If not all the requested bytes are available, the remaining
-       * bytes are then split from the padding (if available).
-       *
-       * @param maxBytes the maximum number of bytes that is allowed in the created frame.
-       * @return the partial frame.
-       */
-      Frame split(int maxBytes) {
-        // The requested maxBytes should always be less than the size of this frame.
-        assert maxBytes < size() : "Attempting to split a frame for the full size.";
-
-        // Get the portion of the data buffer to be split. Limit to the readable bytes.
-        int dataSplit = min(maxBytes, (int) data.size());
-
-        Buffer splitSlice = new Buffer();
-        splitSlice.write(data, dataSplit);
+        stream.onSentBytes(frameBytes);
+        bytesToWrite -= frameBytes;
+      } while (bytesToWrite > 0);
+    }
 
-        Frame frame = new Frame(splitSlice, false);
+    void enqueueData(Buffer buffer, int size, boolean endOfStream) {
+      this.pendingWriteBuffer.write(buffer, size);
+      this.pendingBufferHasEndOfStream |= endOfStream;
+    }
 
-        if (enqueued) {
-          queuedBytes -= dataSplit;
-        }
-        return frame;
-      }
+    void notifyWhenNoPendingData(Runnable noPendingDataRunnable) {
+      Preconditions.checkState(
+          this.noPendingDataRunnable == null, "pending data notification already requested");
+      this.noPendingDataRunnable = noPendingDataRunnable;
     }
   }
 }
diff --git a/okhttp/src/main/java/io/grpc/okhttp/PlaintextHandshakerSocketFactory.java b/okhttp/src/main/java/io/grpc/okhttp/PlaintextHandshakerSocketFactory.java
new file mode 100644
index 00000000000..5338536213f
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/PlaintextHandshakerSocketFactory.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2022 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.okhttp;
+
+import io.grpc.Attributes;
+import io.grpc.Grpc;
+import io.grpc.SecurityLevel;
+import io.grpc.internal.GrpcAttributes;
+import java.io.IOException;
+import java.net.Socket;
+
+/**
+ * No-thrills plaintext handshaker.
+ */
+final class PlaintextHandshakerSocketFactory implements HandshakerSocketFactory {
+  @Override
+  public HandshakeResult handshake(Socket socket, Attributes attributes) throws IOException {
+    attributes = attributes.toBuilder()
+        .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, socket.getLocalSocketAddress())
+        .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, socket.getRemoteSocketAddress())
+        .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.NONE)
+        .build();
+    return new HandshakeResult(socket, attributes, null);
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/SslSocketFactoryChannelCredentials.java b/okhttp/src/main/java/io/grpc/okhttp/SslSocketFactoryChannelCredentials.java
new file mode 100644
index 00000000000..059a0972e49
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/SslSocketFactoryChannelCredentials.java
@@ -0,0 +1,49 @@
+/*
+ * 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.okhttp;
+
+import com.google.common.base.Preconditions;
+import io.grpc.ExperimentalApi;
+import javax.net.ssl.SSLSocketFactory;
+
+/** A credential with full control over the SSLSocketFactory. */
+@ExperimentalApi("There is no plan to make this API stable, given transport API instability")
+public final class SslSocketFactoryChannelCredentials {
+  private SslSocketFactoryChannelCredentials() {}
+
+  public static io.grpc.ChannelCredentials create(SSLSocketFactory factory) {
+    return new ChannelCredentials(factory);
+  }
+
+  // Hide implementation detail of how these credentials operate
+  static final class ChannelCredentials extends io.grpc.ChannelCredentials {
+    private final SSLSocketFactory factory;
+
+    private ChannelCredentials(SSLSocketFactory factory) {
+      this.factory = Preconditions.checkNotNull(factory, "factory");
+    }
+
+    public SSLSocketFactory getFactory() {
+      return factory;
+    }
+
+    @Override
+    public io.grpc.ChannelCredentials withoutBearerTokens() {
+      return this;
+    }
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/SslSocketFactoryServerCredentials.java b/okhttp/src/main/java/io/grpc/okhttp/SslSocketFactoryServerCredentials.java
new file mode 100644
index 00000000000..63c6f33ff79
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/SslSocketFactoryServerCredentials.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2022 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.okhttp;
+
+import com.google.common.base.Preconditions;
+import io.grpc.ExperimentalApi;
+import io.grpc.okhttp.internal.ConnectionSpec;
+import javax.net.ssl.SSLSocketFactory;
+
+/** A credential with full control over the SSLSocketFactory. */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1785")
+public final class SslSocketFactoryServerCredentials {
+  private SslSocketFactoryServerCredentials() {}
+
+  public static io.grpc.ServerCredentials create(SSLSocketFactory factory) {
+    return new ServerCredentials(factory);
+  }
+
+  public static io.grpc.ServerCredentials create(
+      SSLSocketFactory factory, com.squareup.okhttp.ConnectionSpec connectionSpec) {
+    return new ServerCredentials(factory, Utils.convertSpec(connectionSpec));
+  }
+
+  // Hide implementation detail of how these credentials operate
+  static final class ServerCredentials extends io.grpc.ServerCredentials {
+    private final SSLSocketFactory factory;
+    private final ConnectionSpec connectionSpec;
+
+    ServerCredentials(SSLSocketFactory factory) {
+      this(factory, OkHttpChannelBuilder.INTERNAL_DEFAULT_CONNECTION_SPEC);
+    }
+
+    ServerCredentials(SSLSocketFactory factory, ConnectionSpec connectionSpec) {
+      this.factory = Preconditions.checkNotNull(factory, "factory");
+      this.connectionSpec = Preconditions.checkNotNull(connectionSpec, "connectionSpec");
+    }
+
+    public SSLSocketFactory getFactory() {
+      return factory;
+    }
+
+    public ConnectionSpec getConnectionSpec() {
+      return connectionSpec;
+    }
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/TlsServerHandshakerSocketFactory.java b/okhttp/src/main/java/io/grpc/okhttp/TlsServerHandshakerSocketFactory.java
new file mode 100644
index 00000000000..c375d6246cc
--- /dev/null
+++ b/okhttp/src/main/java/io/grpc/okhttp/TlsServerHandshakerSocketFactory.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2022 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.okhttp;
+
+import io.grpc.Attributes;
+import io.grpc.Grpc;
+import io.grpc.InternalChannelz;
+import io.grpc.SecurityLevel;
+import io.grpc.internal.GrpcAttributes;
+import io.grpc.okhttp.internal.ConnectionSpec;
+import io.grpc.okhttp.internal.Protocol;
+import java.io.IOException;
+import java.net.Socket;
+import java.util.Arrays;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+/**
+ * TLS handshaker.
+ */
+final class TlsServerHandshakerSocketFactory implements HandshakerSocketFactory {
+  private final PlaintextHandshakerSocketFactory delegate = new PlaintextHandshakerSocketFactory();
+  private final SSLSocketFactory socketFactory;
+  private final ConnectionSpec connectionSpec;
+
+  public TlsServerHandshakerSocketFactory(
+      SslSocketFactoryServerCredentials.ServerCredentials credentials) {
+    this.socketFactory = credentials.getFactory();
+    this.connectionSpec = credentials.getConnectionSpec();
+  }
+
+  @Override
+  public HandshakeResult handshake(Socket socket, Attributes attributes) throws IOException {
+    HandshakeResult result = delegate.handshake(socket, attributes);
+    socket = socketFactory.createSocket(result.socket, null, -1, true);
+    if (!(socket instanceof SSLSocket)) {
+      throw new IOException(
+          "SocketFactory " + socketFactory + " did not produce an SSLSocket: " + socket.getClass());
+    }
+    SSLSocket sslSocket = (SSLSocket) socket;
+    sslSocket.setUseClientMode(false);
+    connectionSpec.apply(sslSocket, false);
+    Protocol expectedProtocol = Protocol.HTTP_2;
+    String negotiatedProtocol = OkHttpProtocolNegotiator.get().negotiate(
+        sslSocket,
+        null,
+        connectionSpec.supportsTlsExtensions() ? Arrays.asList(expectedProtocol) : null);
+    if (!expectedProtocol.toString().equals(negotiatedProtocol)) {
+      throw new IOException("Expected NPN/ALPN " + expectedProtocol + ": " + negotiatedProtocol);
+    }
+    attributes = result.attributes.toBuilder()
+        .set(GrpcAttributes.ATTR_SECURITY_LEVEL, SecurityLevel.PRIVACY_AND_INTEGRITY)
+        .set(Grpc.TRANSPORT_ATTR_SSL_SESSION, sslSocket.getSession())
+        .build();
+    return new HandshakeResult(socket, attributes,
+        new InternalChannelz.Security(new InternalChannelz.Tls(sslSocket.getSession())));
+  }
+}
diff --git a/okhttp/src/main/java/io/grpc/okhttp/Utils.java b/okhttp/src/main/java/io/grpc/okhttp/Utils.java
index 5742e8d6058..4546143cf3b 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/Utils.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/Utils.java
@@ -1,49 +1,47 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
 import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.InternalChannelz;
 import io.grpc.InternalMetadata;
 import io.grpc.Metadata;
 import io.grpc.internal.TransportFrameUtil;
 import io.grpc.okhttp.internal.CipherSuite;
 import io.grpc.okhttp.internal.ConnectionSpec;
 import io.grpc.okhttp.internal.framed.Header;
+import java.net.Socket;
+import java.net.SocketException;
 import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 /**
  * Common utility methods for OkHttp transport.
  */
 class Utils {
+  private static final Logger log = Logger.getLogger(Utils.class.getName());
+
+  /**
+   * The default ratio of window size to initial window size below which a {@code WINDOW_UPDATE}
+   * is sent to expand the window.
+   */
+  static final float DEFAULT_WINDOW_UPDATE_RATIO = 0.5f;
   static final int DEFAULT_WINDOW_SIZE = 65535;
   static final int CONNECTION_STREAM_ID = 0;
 
@@ -55,6 +53,7 @@ public static Metadata convertTrailers(List<Header> http2Headers) {
     return InternalMetadata.newMetadata(convertHeadersToArray(http2Headers));
   }
 
+  @CheckReturnValue
   private static byte[][] convertHeadersToArray(List<Header> http2Headers) {
     byte[][] headerValues = new byte[http2Headers.size() * 2][];
     int i = 0;
@@ -94,6 +93,78 @@ static ConnectionSpec convertSpec(com.squareup.okhttp.ConnectionSpec spec) {
         .build();
   }
 
+  /**
+   * Attempts to capture all known socket options and return the results as a
+   * {@link InternalChannelz.SocketOptions}. If getting a socket option threw an exception,
+   * log the error to the logger and report the value as an error in the response.
+   */
+  static InternalChannelz.SocketOptions getSocketOptions(Socket socket) {
+    InternalChannelz.SocketOptions.Builder builder = new InternalChannelz.SocketOptions.Builder();
+    try {
+      builder.setSocketOptionLingerSeconds(socket.getSoLinger());
+    } catch (SocketException e) {
+      log.log(Level.SEVERE, "Exception caught while reading socket option", e);
+      builder.addOption("SO_LINGER", "channelz_internal_error");
+    }
+
+    try {
+      builder.setSocketOptionTimeoutMillis(socket.getSoTimeout());
+    } catch (Exception e) {
+      log.log(Level.SEVERE, "Exception caught while reading socket option", e);
+      builder.addOption("SO_TIMEOUT", "channelz_internal_error");
+    }
+
+    try {
+      builder.addOption("TCP_NODELAY", socket.getTcpNoDelay());
+    } catch (SocketException e) {
+      log.log(Level.SEVERE, "Exception caught while reading socket option", e);
+      builder.addOption("TCP_NODELAY", "channelz_internal_error");
+    }
+
+    try {
+      builder.addOption("SO_REUSEADDR", socket.getReuseAddress());
+    } catch (SocketException e) {
+      log.log(Level.SEVERE, "Exception caught while reading socket option", e);
+      builder.addOption("SO_REUSEADDR", "channelz_internal_error");
+    }
+
+    try {
+      builder.addOption("SO_SNDBUF", socket.getSendBufferSize());
+    } catch (SocketException e) {
+      log.log(Level.SEVERE, "Exception caught while reading socket option", e);
+      builder.addOption("SO_SNDBUF", "channelz_internal_error");
+    }
+
+    try {
+      builder.addOption("SO_RECVBUF", socket.getReceiveBufferSize());
+    } catch (SocketException e) {
+      log.log(Level.SEVERE, "Exception caught while reading socket option", e);
+      builder.addOption("SO_RECVBUF", "channelz_internal_error");
+    }
+
+    try {
+      builder.addOption("SO_KEEPALIVE", socket.getKeepAlive());
+    } catch (SocketException e) {
+      log.log(Level.SEVERE, "Exception caught while reading socket option", e);
+      builder.addOption("SO_KEEPALIVE", "channelz_internal_error");
+    }
+
+    try {
+      builder.addOption("SO_OOBINLINE", socket.getOOBInline());
+    } catch (SocketException e) {
+      log.log(Level.SEVERE, "Exception caught while reading socket option", e);
+      builder.addOption("SO_OOBINLINE", "channelz_internal_error");
+    }
+
+    try {
+      builder.addOption("IP_TOS", socket.getTrafficClass());
+    } catch (SocketException e) {
+      log.log(Level.SEVERE, "Exception caught while reading socket option", e);
+      builder.addOption("IP_TOS", "channelz_internal_error");
+    }
+    return builder.build();
+  }
+
   private Utils() {
     // Prevents instantiation
   }
diff --git a/okhttp/src/main/java/io/grpc/okhttp/package-info.java b/okhttp/src/main/java/io/grpc/okhttp/package-info.java
index daaf21268ed..126bd83c3ff 100644
--- a/okhttp/src/main/java/io/grpc/okhttp/package-info.java
+++ b/okhttp/src/main/java/io/grpc/okhttp/package-info.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.
  */
 
 /**
diff --git a/okhttp/src/main/resources/META-INF/services/io.grpc.ServerProvider b/okhttp/src/main/resources/META-INF/services/io.grpc.ServerProvider
new file mode 100644
index 00000000000..263ea4b68f6
--- /dev/null
+++ b/okhttp/src/main/resources/META-INF/services/io.grpc.ServerProvider
@@ -0,0 +1 @@
+io.grpc.okhttp.OkHttpServerProvider
diff --git a/okhttp/src/test/java/io/grpc/internal/AccessProtectedHack.java b/okhttp/src/test/java/io/grpc/internal/AccessProtectedHack.java
deleted file mode 100644
index bd3a05ffc27..00000000000
--- a/okhttp/src/test/java/io/grpc/internal/AccessProtectedHack.java
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-/** A hack to access protected methods from io.grpc.internal. */
-public final class AccessProtectedHack {
-  public static InternalServer serverBuilderBuildTransportServer(
-      AbstractServerImplBuilder<?> builder) {
-    return builder.buildTransportServer();
-  }
-
-  private AccessProtectedHack() {}
-}
diff --git a/okhttp/src/test/java/io/grpc/okhttp/AsyncSinkTest.java b/okhttp/src/test/java/io/grpc/okhttp/AsyncSinkTest.java
new file mode 100644
index 00000000000..478e18d0a2b
--- /dev/null
+++ b/okhttp/src/test/java/io/grpc/okhttp/AsyncSinkTest.java
@@ -0,0 +1,326 @@
+/*
+ * Copyright 2018 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.okhttp;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.CALLS_REAL_METHODS;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.internal.SerializingExecutor;
+import io.grpc.okhttp.ExceptionHandlingFrameWriter.TransportExceptionHandler;
+import java.io.IOException;
+import java.net.Socket;
+import java.nio.charset.StandardCharsets;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.Executor;
+import okio.Buffer;
+import okio.Sink;
+import okio.Timeout;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InOrder;
+
+/** Tests for {@link AsyncSink}. */
+@RunWith(JUnit4.class)
+public class AsyncSinkTest {
+
+  private final Socket socket = mock(Socket.class);
+  private final Sink mockedSink = mock(VoidSink.class, CALLS_REAL_METHODS);
+  private final QueueingExecutor queueingExecutor = new QueueingExecutor();
+  private final TransportExceptionHandler exceptionHandler = mock(TransportExceptionHandler.class);
+  private final AsyncSink sink =
+      AsyncSink.sink(new SerializingExecutor(queueingExecutor), exceptionHandler, 10000);
+
+  @Test
+  public void noCoalesceRequired() throws IOException {
+    Buffer buffer = new Buffer();
+    sink.becomeConnected(mockedSink, socket);
+    sink.write(buffer.writeUtf8("hello"), buffer.size());
+    sink.flush();
+    queueingExecutor.runAll();
+
+    InOrder inOrder = inOrder(mockedSink);
+    inOrder.verify(mockedSink).write(any(Buffer.class), anyLong());
+    inOrder.verify(mockedSink).flush();
+  }
+
+  @Test
+  public void flushCoalescing_shouldNotMergeTwoDistinctFlushes() throws IOException {
+    byte[] firstData = "a string".getBytes(StandardCharsets.UTF_8);
+    byte[] secondData = "a longer string".getBytes(StandardCharsets.UTF_8);
+
+    sink.becomeConnected(mockedSink, socket);
+    Buffer buffer = new Buffer();
+    sink.write(buffer.write(firstData), buffer.size());
+    sink.flush();
+    queueingExecutor.runAll();
+
+    sink.write(buffer.write(secondData), buffer.size());
+    sink.flush();
+    queueingExecutor.runAll();
+
+    InOrder inOrder = inOrder(mockedSink);
+    inOrder.verify(mockedSink).write(any(Buffer.class), anyLong());
+    inOrder.verify(mockedSink).flush();
+    inOrder.verify(mockedSink).write(any(Buffer.class), anyLong());
+    inOrder.verify(mockedSink).flush();
+  }
+
+  @Test
+  public void flushCoalescing_shouldMergeTwoQueuedFlushesAndWrites() throws IOException {
+    byte[] firstData = "a string".getBytes(StandardCharsets.UTF_8);
+    byte[] secondData = "a longer string".getBytes(StandardCharsets.UTF_8);
+    Buffer buffer = new Buffer().write(firstData);
+    sink.becomeConnected(mockedSink, socket);
+    sink.write(buffer, buffer.size());
+    sink.flush();
+    buffer = new Buffer().write(secondData);
+    sink.write(buffer, buffer.size());
+    sink.flush();
+
+    queueingExecutor.runAll();
+
+    InOrder inOrder = inOrder(mockedSink);
+    inOrder.verify(mockedSink)
+        .write(any(Buffer.class), eq((long) firstData.length + secondData.length));
+    inOrder.verify(mockedSink).flush();
+  }
+
+  @Test
+  public void flushCoalescing_shouldMergeWrites() throws IOException {
+    byte[] firstData = "a string".getBytes(StandardCharsets.UTF_8);
+    byte[] secondData = "a longer string".getBytes(StandardCharsets.UTF_8);
+    Buffer buffer = new Buffer();
+    sink.becomeConnected(mockedSink, socket);
+    sink.write(buffer.write(firstData), buffer.size());
+    sink.write(buffer.write(secondData), buffer.size());
+    sink.flush();
+    queueingExecutor.runAll();
+
+    InOrder inOrder = inOrder(mockedSink);
+    inOrder.verify(mockedSink)
+        .write(any(Buffer.class), eq((long) firstData.length + secondData.length));
+    inOrder.verify(mockedSink).flush();
+  }
+
+  @Test
+  public void write_shouldCachePreviousException() throws IOException {
+    Exception ioException = new IOException("some exception");
+    doThrow(ioException)
+        .when(mockedSink).write(any(Buffer.class), anyLong());
+    Buffer buffer = new Buffer();
+    buffer.writeUtf8("any message");
+    sink.becomeConnected(mockedSink, socket);
+    sink.write(buffer, buffer.size());
+    sink.flush();
+    queueingExecutor.runAll();
+    sink.write(buffer, buffer.size());
+    queueingExecutor.runAll();
+
+    verify(exceptionHandler, timeout(1000)).onException(ioException);
+  }
+
+  @Test
+  public void close_writeShouldThrowException() {
+    sink.close();
+    queueingExecutor.runAll();
+    try {
+      sink.write(new Buffer(), 0);
+      fail("should throw ioException");
+    } catch (IOException e) {
+      assertThat(e).hasMessageThat().contains("closed");
+    }
+  }
+
+  @Test
+  public void write_shouldThrowIfAlreadyClosed() throws IOException {
+    Exception ioException = new IOException("some exception");
+    doThrow(ioException)
+        .when(mockedSink).write(any(Buffer.class), anyLong());
+    Buffer buffer = new Buffer();
+    buffer.writeUtf8("any message");
+    sink.becomeConnected(mockedSink, socket);
+    sink.write(buffer, buffer.size());
+    sink.close();
+    queueingExecutor.runAll();
+    try {
+      sink.write(buffer, buffer.size());
+      queueingExecutor.runAll();
+      fail("should throw ioException");
+    } catch (IOException e) {
+      assertThat(e).hasMessageThat().contains("closed");
+    }
+  }
+
+  @Test
+  public void close_flushShouldThrowException() throws IOException {
+    sink.becomeConnected(mockedSink, socket);
+    sink.close();
+    queueingExecutor.runAll();
+    try {
+      sink.flush();
+      queueingExecutor.runAll();
+      fail("should fail");
+    } catch (IOException e) {
+      assertThat(e).hasMessageThat().contains("closed");
+    }
+  }
+
+  @Test
+  public void flush_shouldThrowIfAlreadyClosed() throws IOException {
+    Buffer buffer = new Buffer();
+    buffer.writeUtf8("any message");
+    sink.becomeConnected(mockedSink, socket);
+    sink.write(buffer, buffer.size());
+    sink.close();
+    queueingExecutor.runAll();
+    try {
+      sink.flush();
+      queueingExecutor.runAll();
+      fail("should fail");
+    } catch (IOException e) {
+      assertThat(e).hasMessageThat().contains("closed");
+    }
+  }
+
+  @Test
+  public void write_callSinkIfBufferIsLargerThanSegmentSize() throws IOException {
+    Buffer buffer = new Buffer();
+    sink.becomeConnected(mockedSink, socket);
+    // OkHttp is using 8192 as segment size.
+    int payloadSize = 8192 * 2 - 1;
+    int padding = 10;
+    buffer.write(new byte[payloadSize]);
+
+    int completeSegmentBytes = (int) buffer.completeSegmentByteCount();
+    assertThat(completeSegmentBytes).isLessThan(payloadSize);
+
+    // first trying to send of all complete segments, but not the padding
+    sink.write(buffer, completeSegmentBytes + padding);
+    queueingExecutor.runAll();
+    verify(mockedSink).write(any(Buffer.class), eq((long) completeSegmentBytes));
+    verify(mockedSink, never()).flush();
+    assertThat(buffer.size()).isEqualTo((long) (payloadSize - completeSegmentBytes - padding));
+
+    // writing smaller than completed segment, shouldn't trigger write to Sink.
+    reset(mockedSink);
+    sink.write(buffer, buffer.size());
+    queueingExecutor.runAll();
+    verify(mockedSink, never()).write(any(Buffer.class), anyLong());
+    verify(mockedSink, never()).flush();
+    assertThat(buffer.exhausted()).isTrue();
+
+    // flush should write everything.
+    sink.flush();
+    queueingExecutor.runAll();
+    verify(mockedSink).write(any(Buffer.class), eq((long) payloadSize - completeSegmentBytes));
+    verify(mockedSink).flush();
+  }
+
+  @Test
+  public void writeAndFlush_beforeConnected() throws IOException {
+    Buffer buffer = new Buffer();
+    sink.write(buffer.writeUtf8("hello"), buffer.size());
+    sink.flush();
+    queueingExecutor.runAll();
+
+    verify(mockedSink, never()).write(any(Buffer.class), anyLong());
+    verify(mockedSink, never()).flush();
+
+    ArgumentCaptor<Throwable> captor = ArgumentCaptor.forClass(Throwable.class);
+
+    verify(exceptionHandler).onException(captor.capture());
+
+    Throwable t = captor.getValue();
+    assertThat(t).isInstanceOf(IOException.class);
+    assertThat(t).hasMessageThat().contains("unavailable sink");
+  }
+
+  @Test
+  public void close_multipleCloseShouldNotThrow() throws IOException {
+    sink.becomeConnected(mockedSink, socket);
+
+    sink.close();
+    queueingExecutor.runAll();
+
+    verify(exceptionHandler, never()).onException(any(Throwable.class));
+
+    sink.close();
+    queueingExecutor.runAll();
+
+    verify(exceptionHandler, never()).onException(any(Throwable.class));
+  }
+
+  /**
+   * Executor queues incoming runnables instead of running it. Runnables can be invoked via {@link
+   * QueueingExecutor#runAll} in serial order.
+   */
+  private static class QueueingExecutor implements Executor {
+
+    private final Queue<Runnable> runnables = new ConcurrentLinkedQueue<>();
+
+    @Override
+    public void execute(Runnable command) {
+      runnables.add(command);
+    }
+
+    public void runAll() {
+      Runnable r;
+      while ((r = runnables.poll()) != null) {
+        r.run();
+      }
+    }
+  }
+
+  /** Test sink to mimic real Sink behavior since write has a side effect. */
+  private static class VoidSink implements Sink {
+
+    @Override
+    public void write(Buffer source, long byteCount) throws IOException {
+      // removes byteCount bytes from source.
+      source.read(new byte[(int) byteCount], 0, (int) byteCount);
+    }
+
+    @Override
+    public void flush() throws IOException {
+      // do nothing
+    }
+
+    @Override
+    public Timeout timeout() {
+      return Timeout.NONE;
+    }
+
+    @Override
+    public void close() throws IOException {
+      // do nothing
+    }
+  }
+}
diff --git a/okhttp/src/test/java/io/grpc/okhttp/ExceptionHandlingFrameWriterTest.java b/okhttp/src/test/java/io/grpc/okhttp/ExceptionHandlingFrameWriterTest.java
new file mode 100644
index 00000000000..8829abac034
--- /dev/null
+++ b/okhttp/src/test/java/io/grpc/okhttp/ExceptionHandlingFrameWriterTest.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright 2018 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.okhttp;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.okhttp.ExceptionHandlingFrameWriter.getLogLevel;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.okhttp.ExceptionHandlingFrameWriter.TransportExceptionHandler;
+import io.grpc.okhttp.OkHttpFrameLogger.Direction;
+import io.grpc.okhttp.internal.framed.ErrorCode;
+import io.grpc.okhttp.internal.framed.FrameWriter;
+import io.grpc.okhttp.internal.framed.Header;
+import io.grpc.okhttp.internal.framed.Settings;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import okio.Buffer;
+import okio.ByteString;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ExceptionHandlingFrameWriterTest {
+
+  private static final Logger logger = Logger.getLogger(OkHttpClientTransport.class.getName());
+  private final FrameWriter mockedFrameWriter = mock(FrameWriter.class);
+  private final TransportExceptionHandler transportExceptionHandler =
+      mock(TransportExceptionHandler.class);
+  private final ExceptionHandlingFrameWriter exceptionHandlingFrameWriter =
+      new ExceptionHandlingFrameWriter(transportExceptionHandler, mockedFrameWriter);
+
+  @Test
+  public void exception() throws IOException {
+    IOException exception = new IOException("some exception");
+    doThrow(exception).when(mockedFrameWriter)
+        .synReply(false, 100, new ArrayList<Header>());
+
+    exceptionHandlingFrameWriter.synReply(false, 100, new ArrayList<Header>());
+
+    verify(transportExceptionHandler).onException(exception);
+    verify(mockedFrameWriter).synReply(false, 100, new ArrayList<Header>());
+  }
+
+  @Test
+  public void unknownException() {
+    assertThat(getLogLevel(new Exception())).isEqualTo(Level.INFO);
+  }
+
+  @Test
+  public void ioException() {
+    assertThat(getLogLevel(new IOException("Socket closed"))).isEqualTo(Level.FINE);
+  }
+
+  @Test
+  public void ioException_nullMessage() {
+    IOException e = new IOException();
+    assertThat(e.getMessage()).isNull();
+    assertThat(getLogLevel(e)).isEqualTo(Level.FINE);
+  }
+
+  @Test
+  public void extendedIoException() {
+    class ExtendedIoException extends IOException {}
+
+    ExtendedIoException e = new ExtendedIoException();
+    assertThat(e.getMessage()).isNull();
+    assertThat(getLogLevel(e)).isEqualTo(Level.INFO);
+  }
+
+  private static Buffer createMessageFrame(String message) {
+    return createMessageFrame(message.getBytes(UTF_8));
+  }
+
+  private static Buffer createMessageFrame(byte[] message) {
+    Buffer buffer = new Buffer();
+    buffer.writeByte(0 /* UNCOMPRESSED */);
+    buffer.writeInt(message.length);
+    buffer.write(message);
+    return buffer;
+  }
+
+  /**
+   * Test logging is functioning correctly for client sent Http/2 frames. Not intended to test
+   * actual frame content being logged.
+   */
+  @Test
+  public void testFrameLogger() {
+    final List<LogRecord> logs = new ArrayList<>();
+    Handler handler = new Handler() {
+      @Override
+      public void publish(LogRecord record) {
+        logs.add(record);
+      }
+
+      @Override
+      public void flush() {
+      }
+
+      @Override
+      public void close() throws SecurityException {
+      }
+    };
+    logger.addHandler(handler);
+    logger.setLevel(Level.ALL);
+
+    exceptionHandlingFrameWriter.headers(100, new ArrayList<Header>());
+    assertThat(logs).hasSize(1);
+    LogRecord log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " HEADERS: streamId=" + 100);
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    final String message = "Hello Server";
+    Buffer buffer = createMessageFrame(message);
+    exceptionHandlingFrameWriter.data(false, 100, buffer, (int) buffer.size());
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " DATA: streamId=" + 100);
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    // At most 64 bytes of data frame will be logged.
+    exceptionHandlingFrameWriter
+        .data(false, 3, createMessageFrame(new String(new char[1000])), 1000);
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    String data = log.getMessage();
+    assertThat(data).endsWith("...");
+    assertThat(data.substring(data.indexOf("bytes="), data.indexOf("..."))).hasLength(64 * 2 + 6);
+
+    exceptionHandlingFrameWriter.ackSettings(new Settings());
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " SETTINGS: ack=true");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    exceptionHandlingFrameWriter.settings(new Settings());
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " SETTINGS: ack=false");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    exceptionHandlingFrameWriter.ping(false, 0, 0);
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " PING: ack=false");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    exceptionHandlingFrameWriter.pushPromise(100, 100, new ArrayList<Header>());
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " PUSH_PROMISE");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    exceptionHandlingFrameWriter.rstStream(100, ErrorCode.CANCEL);
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " RST_STREAM");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    exceptionHandlingFrameWriter.goAway(100, ErrorCode.CANCEL, ByteString.EMPTY.toByteArray());
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " GO_AWAY");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    exceptionHandlingFrameWriter.windowUpdate(100, 32);
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " WINDOW_UPDATE");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    logger.removeHandler(handler);
+  }
+}
diff --git a/okhttp/src/test/java/io/grpc/okhttp/HeadersTest.java b/okhttp/src/test/java/io/grpc/okhttp/HeadersTest.java
new file mode 100644
index 00000000000..e0662b16117
--- /dev/null
+++ b/okhttp/src/test/java/io/grpc/okhttp/HeadersTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2017 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.okhttp;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import io.grpc.Metadata;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.okhttp.internal.framed.Header;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class HeadersTest {
+  @Test
+  public void createRequestHeaders_sanitizes() {
+    Metadata metaData = new Metadata();
+
+    // Intentionally being explicit here rather than relying on any pre-defined lists of headers,
+    // since the goal of this test is to validate the correctness of such lists in the first place.
+    metaData.put(GrpcUtil.CONTENT_TYPE_KEY, "to-be-removed");
+    metaData.put(GrpcUtil.USER_AGENT_KEY, "to-be-removed");
+    metaData.put(GrpcUtil.TE_HEADER, "to-be-removed");
+
+
+    Metadata.Key<String> userKey = Metadata.Key.of("user-key", Metadata.ASCII_STRING_MARSHALLER);
+    String userValue = "user-value";
+    metaData.put(userKey, userValue);
+
+    String path = "//testServerice/test";
+    String authority = "localhost";
+    String userAgent = "useragent";
+
+    List<Header> headers = Headers.createRequestHeaders(
+        metaData,
+        path,
+        authority,
+        userAgent,
+        false,
+        false);
+
+    // 7 reserved headers, 1 user header
+    assertEquals(7 + 1, headers.size());
+    // Check the 3 reserved headers that are non pseudo
+    // Users can not create pseudo headers keys so no need to check for them here
+    assertThat(headers).contains(Headers.CONTENT_TYPE_HEADER);
+    assertThat(headers).contains(new Header(GrpcUtil.USER_AGENT_KEY.name(), userAgent));
+    assertThat(headers).contains(new Header(GrpcUtil.TE_HEADER.name(), GrpcUtil.TE_TRAILERS));
+    // Check the user header is in tact
+    assertThat(headers).contains(new Header(userKey.name(), userValue));
+  }
+}
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpChannelBuilderTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpChannelBuilderTest.java
index 1034b81d62d..89d37536b70 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpChannelBuilderTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpChannelBuilderTest.java
@@ -1,47 +1,63 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.internal.GrpcUtil.TIMER_SERVICE;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.mock;
 
+import com.google.common.util.concurrent.SettableFuture;
 import com.squareup.okhttp.ConnectionSpec;
-import io.grpc.NameResolver;
+import io.grpc.CallCredentials;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.ChoiceChannelCredentials;
+import io.grpc.CompositeChannelCredentials;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.internal.CertificateUtils;
+import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.ClientTransportFactory.SwapChannelCredentialsResult;
+import io.grpc.internal.FakeClock;
 import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.SharedResourceHolder;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.TlsTesting;
+import java.io.InputStream;
+import java.net.InetAddress;
 import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.util.concurrent.ScheduledExecutorService;
+import javax.net.SocketFactory;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLServerSocket;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+import javax.security.auth.x500.X500Principal;
 import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
@@ -51,47 +67,335 @@
 @RunWith(JUnit4.class)
 public class OkHttpChannelBuilderTest {
 
-  @Rule public final ExpectedException thrown = ExpectedException.none();
+  @Rule public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
 
   @Test
-  public void overrideAllowsInvalidAuthority() {
-    OkHttpChannelBuilder builder = new OkHttpChannelBuilder("good", 1234) {
-      @Override
-      protected String checkAuthority(String authority) {
-        return authority;
-      }
-    };
+  public void authorityIsReadable() {
+    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("original", 1234);
+    ManagedChannel channel = grpcCleanupRule.register(builder.build());
+    assertEquals("original:1234", channel.authority());
+  }
 
-    builder.overrideAuthority("[invalidauthority")
-        .negotiationType(NegotiationType.PLAINTEXT)
-        .buildTransportFactory();
+  @Test
+  public void overrideAuthorityIsReadableForAddress() {
+    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("original", 1234);
+    overrideAuthorityIsReadableHelper(builder, "override:5678");
+  }
+
+  @Test
+  public void overrideAuthorityIsReadableForTarget() {
+    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forTarget("original:1234");
+    overrideAuthorityIsReadableHelper(builder, "override:5678");
+  }
+
+  private void overrideAuthorityIsReadableHelper(OkHttpChannelBuilder builder,
+      String overrideAuthority) {
+    builder.overrideAuthority(overrideAuthority);
+    ManagedChannel channel = grpcCleanupRule.register(builder.build());
+    assertEquals(overrideAuthority, channel.authority());
   }
 
   @Test
   public void failOverrideInvalidAuthority() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid authority:");
-    OkHttpChannelBuilder builder = new OkHttpChannelBuilder("good", 1234);
+    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("good", 1234);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.overrideAuthority("[invalidauthority"));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid authority: [invalidauthority");
+  }
 
-    builder.overrideAuthority("[invalidauthority")
-        .negotiationType(NegotiationType.PLAINTEXT)
-        .buildTransportFactory();
+  @Test
+  public void disableCheckAuthorityAllowsInvalidAuthority() {
+    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("good", 1234)
+        .disableCheckAuthority();
+    builder.overrideAuthority("[invalidauthority").usePlaintext().buildTransportFactory();
+  }
+
+  @Test
+  public void enableCheckAuthorityFailOverrideInvalidAuthority() {
+    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("good", 1234)
+        .disableCheckAuthority()
+        .enableCheckAuthority();
+
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.overrideAuthority("[invalidauthority"));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid authority: [invalidauthority");
   }
 
   @Test
   public void failInvalidAuthority() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("Invalid host or port");
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> OkHttpChannelBuilder.forAddress("invalid_authority", 1234));
+    assertThat(e.getMessage()).isEqualTo("Invalid host or port: invalid_authority 1234");
+  }
 
-    OkHttpChannelBuilder.forAddress("invalid_authority", 1234);
+  @Test
+  public void sslSocketFactoryFrom_unknown() {
+    OkHttpChannelBuilder.SslSocketFactoryResult result =
+        OkHttpChannelBuilder.sslSocketFactoryFrom(new ChannelCredentials() {
+          @Override
+          public ChannelCredentials withoutBearerTokens() {
+            throw new UnsupportedOperationException();
+          }
+        });
+    assertThat(result.error).isNotNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.factory).isNull();
   }
 
   @Test
-  public void failForUsingClearTextSpecDirectly() {
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("plaintext ConnectionSpec is not accepted");
+  public void sslSocketFactoryFrom_tls() {
+    OkHttpChannelBuilder.SslSocketFactoryResult result =
+        OkHttpChannelBuilder.sslSocketFactoryFrom(TlsChannelCredentials.create());
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.factory).isNotNull();
+  }
+
+  @Test
+  public void sslSocketFactoryFrom_unsupportedTls() {
+    OkHttpChannelBuilder.SslSocketFactoryResult result = OkHttpChannelBuilder.sslSocketFactoryFrom(
+        TlsChannelCredentials.newBuilder().requireFakeFeature().build());
+    assertThat(result.error).contains("FAKE");
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.factory).isNull();
+  }
+
+  @Test
+  public void sslSocketFactoryFrom_tls_customRoots() throws Exception {
+    SSLContext serverContext = SSLContext.getInstance("TLS");
+    try (InputStream server1Chain = TlsTesting.loadCert("server1.pem");
+         InputStream server1Key = TlsTesting.loadCert("server1.key")) {
+      serverContext.init(
+          OkHttpChannelBuilder.createKeyManager(server1Chain, server1Key), null, null);
+    }
+    final SSLServerSocket serverListenSocket =
+        (SSLServerSocket) serverContext.getServerSocketFactory().createServerSocket(0);
+    final SettableFuture<SSLSocket> serverSocket = SettableFuture.create();
+    new Thread(new Runnable() {
+      @Override public void run() {
+        try {
+          SSLSocket socket = (SSLSocket) serverListenSocket.accept();
+          socket.getSession(); // Force handshake
+          serverSocket.set(socket);
+          serverListenSocket.close();
+        } catch (Throwable t) {
+          serverSocket.setException(t);
+        }
+      }
+    }).start();
+
+    ChannelCredentials creds;
+    try (InputStream ca = TlsTesting.loadCert("ca.pem")) {
+      creds = TlsChannelCredentials.newBuilder()
+        .trustManager(ca)
+        .build();
+    }
+    OkHttpChannelBuilder.SslSocketFactoryResult result =
+        OkHttpChannelBuilder.sslSocketFactoryFrom(creds);
+    SSLSocket socket =
+        (SSLSocket) result.factory.createSocket("localhost", serverListenSocket.getLocalPort());
+    socket.getSession(); // Force handshake
+    socket.close();
+    serverSocket.get().close();
+  }
+
+  @Test
+  public void sslSocketFactoryFrom_tls_mtls() throws Exception {
+    KeyManager[] keyManagers;
+    try (InputStream server1Chain = TlsTesting.loadCert("server1.pem");
+         InputStream server1Key = TlsTesting.loadCert("server1.key")) {
+      keyManagers = OkHttpChannelBuilder.createKeyManager(server1Chain, server1Key);
+    }
+
+    TrustManager[] trustManagers;
+    try (InputStream ca = TlsTesting.loadCert("ca.pem")) {
+      trustManagers = CertificateUtils.createTrustManager(ca);
+    }
+
+    SSLContext serverContext = SSLContext.getInstance("TLS");
+    serverContext.init(keyManagers, trustManagers, null);
+    final SSLServerSocket serverListenSocket =
+        (SSLServerSocket) serverContext.getServerSocketFactory().createServerSocket(0);
+    serverListenSocket.setNeedClientAuth(true);
+    final SettableFuture<SSLSocket> serverSocket = SettableFuture.create();
+    new Thread(new Runnable() {
+      @Override public void run() {
+        try {
+          SSLSocket socket = (SSLSocket) serverListenSocket.accept();
+          socket.getSession(); // Force handshake
+          serverSocket.set(socket);
+          serverListenSocket.close();
+        } catch (Throwable t) {
+          serverSocket.setException(t);
+        }
+      }
+    }).start();
+
+    ChannelCredentials creds = TlsChannelCredentials.newBuilder()
+        .keyManager(keyManagers)
+        .trustManager(trustManagers)
+        .build();
+    OkHttpChannelBuilder.SslSocketFactoryResult result =
+        OkHttpChannelBuilder.sslSocketFactoryFrom(creds);
+    SSLSocket socket =
+        (SSLSocket) result.factory.createSocket("localhost", serverListenSocket.getLocalPort());
+    socket.getSession(); // Force handshake
+    assertThat(((X500Principal) serverSocket.get().getSession().getPeerPrincipal()).getName())
+        .isEqualTo("CN=*.test.google.com,O=Example\\, Co.,L=Chicago,ST=Illinois,C=US");
+    socket.close();
+    serverSocket.get().close();
+  }
+
+  @Test
+  public void sslSocketFactoryFrom_tls_mtls_keyFile() throws Exception {
+    SSLContext serverContext = SSLContext.getInstance("TLS");
+    try (InputStream server1Chain = TlsTesting.loadCert("server1.pem");
+         InputStream server1Key = TlsTesting.loadCert("server1.key");
+         InputStream ca = TlsTesting.loadCert("ca.pem")) {
+      serverContext.init(
+          OkHttpChannelBuilder.createKeyManager(server1Chain, server1Key),
+          CertificateUtils.createTrustManager(ca),
+          null);
+    }
+    final SSLServerSocket serverListenSocket =
+        (SSLServerSocket) serverContext.getServerSocketFactory().createServerSocket(0);
+    serverListenSocket.setNeedClientAuth(true);
+    final SettableFuture<SSLSocket> serverSocket = SettableFuture.create();
+    new Thread(new Runnable() {
+      @Override public void run() {
+        try {
+          SSLSocket socket = (SSLSocket) serverListenSocket.accept();
+          socket.getSession(); // Force handshake
+          serverSocket.set(socket);
+          serverListenSocket.close();
+        } catch (Throwable t) {
+          serverSocket.setException(t);
+        }
+      }
+    }).start();
+
+    ChannelCredentials creds;
+    try (InputStream server1Chain = TlsTesting.loadCert("server1.pem");
+         InputStream server1Key = TlsTesting.loadCert("server1.key");
+         InputStream ca = TlsTesting.loadCert("ca.pem")) {
+      creds = TlsChannelCredentials.newBuilder()
+          .keyManager(server1Chain, server1Key)
+          .trustManager(ca)
+          .build();
+    }
+    OkHttpChannelBuilder.SslSocketFactoryResult result =
+        OkHttpChannelBuilder.sslSocketFactoryFrom(creds);
+    SSLSocket socket =
+        (SSLSocket) result.factory.createSocket("localhost", serverListenSocket.getLocalPort());
+    socket.getSession(); // Force handshake
+    assertThat(((X500Principal) serverSocket.get().getSession().getPeerPrincipal()).getName())
+        .isEqualTo("CN=*.test.google.com,O=Example\\, Co.,L=Chicago,ST=Illinois,C=US");
+    socket.close();
+    serverSocket.get().close();
+  }
+
+  @Test
+  public void sslSocketFactoryFrom_tls_mtls_passwordUnsupported() throws Exception {
+    ChannelCredentials creds = TlsChannelCredentials.newBuilder()
+        .keyManager(
+            TlsTesting.loadCert("server1.pem"), TlsTesting.loadCert("server1.key"), "password")
+        .build();
+    OkHttpChannelBuilder.SslSocketFactoryResult result =
+        OkHttpChannelBuilder.sslSocketFactoryFrom(creds);
+    assertThat(result.error).contains("unsupported");
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.factory).isNull();
+  }
+
+  @Test
+  public void sslSocketFactoryFrom_insecure() {
+    OkHttpChannelBuilder.SslSocketFactoryResult result =
+        OkHttpChannelBuilder.sslSocketFactoryFrom(InsecureChannelCredentials.create());
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.factory).isNull();
+  }
+
+  @Test
+  public void sslSocketFactoryFrom_composite() {
+    CallCredentials callCredentials = mock(CallCredentials.class);
+    OkHttpChannelBuilder.SslSocketFactoryResult result =
+        OkHttpChannelBuilder.sslSocketFactoryFrom(CompositeChannelCredentials.create(
+          TlsChannelCredentials.create(), callCredentials));
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isSameInstanceAs(callCredentials);
+    assertThat(result.factory).isNotNull();
+
+    result = OkHttpChannelBuilder.sslSocketFactoryFrom(CompositeChannelCredentials.create(
+          InsecureChannelCredentials.create(), callCredentials));
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isSameInstanceAs(callCredentials);
+    assertThat(result.factory).isNull();
+  }
 
-    OkHttpChannelBuilder.forAddress("host", 1234).connectionSpec(ConnectionSpec.CLEARTEXT);
+  @Test
+  public void sslSocketFactoryFrom_okHttp() throws Exception {
+    SSLContext sslContext = SSLContext.getInstance("TLS");
+    sslContext.init(null, null, null);
+    SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();
+    OkHttpChannelBuilder.SslSocketFactoryResult result = OkHttpChannelBuilder.sslSocketFactoryFrom(
+        SslSocketFactoryChannelCredentials.create(sslSocketFactory));
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.factory).isSameInstanceAs(sslSocketFactory);
+  }
+
+  @Test
+  public void sslSocketFactoryFrom_choice() {
+    OkHttpChannelBuilder.SslSocketFactoryResult result =
+        OkHttpChannelBuilder.sslSocketFactoryFrom(ChoiceChannelCredentials.create(
+          new ChannelCredentials() {
+            @Override
+            public ChannelCredentials withoutBearerTokens() {
+              throw new UnsupportedOperationException();
+            }
+          },
+          TlsChannelCredentials.create(),
+          InsecureChannelCredentials.create()));
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.factory).isNotNull();
+
+    result = OkHttpChannelBuilder.sslSocketFactoryFrom(ChoiceChannelCredentials.create(
+          InsecureChannelCredentials.create(),
+          new ChannelCredentials() {
+            @Override
+            public ChannelCredentials withoutBearerTokens() {
+              throw new UnsupportedOperationException();
+            }
+          },
+          TlsChannelCredentials.create()));
+    assertThat(result.error).isNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.factory).isNull();
+  }
+
+  @Test
+  public void sslSocketFactoryFrom_choice_unknown() {
+    OkHttpChannelBuilder.SslSocketFactoryResult result =
+        OkHttpChannelBuilder.sslSocketFactoryFrom(ChoiceChannelCredentials.create(
+          new ChannelCredentials() {
+            @Override
+            public ChannelCredentials withoutBearerTokens() {
+              throw new UnsupportedOperationException();
+            }
+          }));
+    assertThat(result.error).isNotNull();
+    assertThat(result.callCredentials).isNull();
+    assertThat(result.factory).isNull();
+  }
+
+  @Test
+  public void failForUsingClearTextSpecDirectly() {
+    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("host", 1234);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> builder.connectionSpec(ConnectionSpec.CLEARTEXT));
+    assertThat(e).hasMessageThat().isEqualTo("plaintext ConnectionSpec is not accepted");
   }
 
   @Test
@@ -101,25 +405,136 @@ public void allowUsingTlsConnectionSpec() {
 
   @Test
   public void usePlaintext_newClientTransportAllowed() {
-    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("host", 1234).usePlaintext(true);
-    builder.buildTransportFactory().newClientTransport(new InetSocketAddress(5678),
-        "dummy_authority", "dummy_userAgent");
+    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("host", 1234).usePlaintext();
+    builder.buildTransportFactory().newClientTransport(
+        new InetSocketAddress(5678),
+        new ClientTransportFactory.ClientTransportOptions(), new FakeChannelLogger());
   }
 
   @Test
   public void usePlaintextDefaultPort() {
-    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("host", 1234).usePlaintext(true);
-    assertEquals(GrpcUtil.DEFAULT_PORT_PLAINTEXT,
-        builder.getNameResolverParams().get(NameResolver.Factory.PARAMS_DEFAULT_PORT).intValue());
+    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("host", 1234).usePlaintext();
+    assertEquals(GrpcUtil.DEFAULT_PORT_PLAINTEXT, builder.getDefaultPort());
   }
 
   @Test
   public void usePlaintextCreatesNullSocketFactory() {
     OkHttpChannelBuilder builder = OkHttpChannelBuilder.forAddress("host", 1234);
-    assertNotNull(builder.createSocketFactory());
+    assertNotNull(builder.createSslSocketFactory());
 
-    builder.usePlaintext(true);
-    assertNull(builder.createSocketFactory());
+    builder.usePlaintext();
+    assertNull(builder.createSslSocketFactory());
+  }
+
+  @Test
+  public void scheduledExecutorService_default() {
+    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forTarget("foo");
+    ClientTransportFactory clientTransportFactory = builder.buildTransportFactory();
+    assertSame(
+        SharedResourceHolder.get(TIMER_SERVICE),
+        clientTransportFactory.getScheduledExecutorService());
+
+    SharedResourceHolder.release(
+        TIMER_SERVICE, clientTransportFactory.getScheduledExecutorService());
+    clientTransportFactory.close();
+  }
+
+  @Test
+  public void scheduledExecutorService_custom() {
+    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forTarget("foo");
+    ScheduledExecutorService scheduledExecutorService =
+        new FakeClock().getScheduledExecutorService();
+
+    OkHttpChannelBuilder builder1 = builder.scheduledExecutorService(scheduledExecutorService);
+    assertSame(builder, builder1);
+
+    ClientTransportFactory clientTransportFactory = builder1.buildTransportFactory();
+
+    assertSame(scheduledExecutorService, clientTransportFactory.getScheduledExecutorService());
+
+    clientTransportFactory.close();
   }
-}
 
+  @Test
+  public void socketFactory_default() {
+    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forTarget("foo");
+    ClientTransportFactory transportFactory = builder.buildTransportFactory();
+    OkHttpClientTransport transport =
+        (OkHttpClientTransport)
+            transportFactory.newClientTransport(
+                new InetSocketAddress(5678),
+                new ClientTransportFactory.ClientTransportOptions(),
+                new FakeChannelLogger());
+
+    assertSame(SocketFactory.getDefault(), transport.getSocketFactory());
+
+    transportFactory.close();
+  }
+
+  @Test
+  public void socketFactory_custom() {
+    SocketFactory socketFactory =
+        new SocketFactory() {
+          @Override
+          public Socket createSocket(String s, int i) {
+            return null;
+          }
+
+          @Override
+          public Socket createSocket(String s, int i, InetAddress inetAddress, int i1) {
+            return null;
+          }
+
+          @Override
+          public Socket createSocket(InetAddress inetAddress, int i) {
+            return null;
+          }
+
+          @Override
+          public Socket createSocket(
+              InetAddress inetAddress, int i, InetAddress inetAddress1, int i1) {
+            return null;
+          }
+        };
+    OkHttpChannelBuilder builder =
+        OkHttpChannelBuilder.forTarget("foo").socketFactory(socketFactory);
+    ClientTransportFactory transportFactory = builder.buildTransportFactory();
+    OkHttpClientTransport transport =
+        (OkHttpClientTransport)
+            transportFactory.newClientTransport(
+                new InetSocketAddress(5678),
+                new ClientTransportFactory.ClientTransportOptions(),
+                new FakeChannelLogger());
+
+    assertSame(socketFactory, transport.getSocketFactory());
+
+    transportFactory.close();
+  }
+
+  @Test
+  public void transportFactorySupportsOkHttpChannelCreds() {
+    OkHttpChannelBuilder builder = OkHttpChannelBuilder.forTarget("foo");
+    ClientTransportFactory transportFactory = builder.buildTransportFactory();
+
+    SwapChannelCredentialsResult result = transportFactory.swapChannelCredentials(
+        mock(ChannelCredentials.class));
+    assertThat(result).isNull();
+
+    result = transportFactory.swapChannelCredentials(
+        SslSocketFactoryChannelCredentials.create(mock(SSLSocketFactory.class)));
+    assertThat(result).isNotNull();
+  }
+
+  private static final class FakeChannelLogger extends ChannelLogger {
+
+    @Override
+    public void log(ChannelLogLevel level, String message) {
+
+    }
+
+    @Override
+    public void log(ChannelLogLevel level, String messageFormat, Object... args) {
+
+    }
+  }
+}
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpChannelProviderTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpChannelProviderTest.java
index 868cc35237a..363f11e71eb 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpChannelProviderTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpChannelProviderTest.java
@@ -1,41 +1,31 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import io.grpc.InternalServiceProviders;
 import io.grpc.ManagedChannelProvider;
+import io.grpc.ManagedChannelProvider.NewChannelBuilderResult;
+import io.grpc.ManagedChannelRegistryAccessor;
+import io.grpc.TlsChannelCredentials;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -48,7 +38,8 @@ public class OkHttpChannelProviderTest {
   @Test
   public void provided() {
     for (ManagedChannelProvider current
-        : ManagedChannelProvider.getCandidatesViaServiceLoader(getClass().getClassLoader())) {
+        : InternalServiceProviders.getCandidatesViaServiceLoader(
+            ManagedChannelProvider.class, getClass().getClassLoader())) {
       if (current instanceof OkHttpChannelProvider) {
         return;
       }
@@ -58,9 +49,8 @@ public void provided() {
 
   @Test
   public void providedHardCoded() {
-    for (ManagedChannelProvider current
-        : ManagedChannelProvider.getCandidatesViaHardCoded(getClass().getClassLoader())) {
-      if (current instanceof OkHttpChannelProvider) {
+    for (Class<?> current : ManagedChannelRegistryAccessor.getHardCodedClasses()) {
+      if (current == OkHttpChannelProvider.class) {
         return;
       }
     }
@@ -76,4 +66,23 @@ public void isAvailable() {
   public void builderIsAOkHttpBuilder() {
     assertSame(OkHttpChannelBuilder.class, provider.builderForAddress("localhost", 443).getClass());
   }
+
+  @Test
+  public void builderForTarget() {
+    assertThat(provider.builderForTarget("localhost:443")).isInstanceOf(OkHttpChannelBuilder.class);
+  }
+
+  @Test
+  public void newChannelBuilder_success() {
+    NewChannelBuilderResult result =
+        provider.newChannelBuilder("localhost:443", TlsChannelCredentials.create());
+    assertThat(result.getChannelBuilder()).isInstanceOf(OkHttpChannelBuilder.class);
+  }
+
+  @Test
+  public void newChannelBuilder_fail() {
+    NewChannelBuilderResult result = provider.newChannelBuilder("localhost:443",
+        TlsChannelCredentials.newBuilder().requireFakeFeature().build());
+    assertThat(result.getError()).contains("FAKE");
+  }
 }
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientStreamTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientStreamTest.java
index 73406327a2b..1c98d6ee30d 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientStreamTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientStreamTest.java
@@ -1,56 +1,53 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
 import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
 
+import com.google.common.io.BaseEncoding;
+import io.grpc.CallOptions;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.MethodType;
 import io.grpc.Status;
-import io.grpc.internal.ClientStreamListener;
 import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.NoopClientStreamListener;
 import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.TransportTracer;
 import io.grpc.okhttp.internal.framed.ErrorCode;
+import io.grpc.okhttp.internal.framed.FrameWriter;
 import io.grpc.okhttp.internal.framed.Header;
-import java.io.InputStream;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.charset.Charset;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -58,37 +55,57 @@
 import org.mockito.Captor;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
 import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 import org.mockito.stubbing.Answer;
 
 @RunWith(JUnit4.class)
 public class OkHttpClientStreamTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
   private static final int MAX_MESSAGE_SIZE = 100;
+  private static final int INITIAL_WINDOW_SIZE = 65535;
 
   @Mock private MethodDescriptor.Marshaller<Void> marshaller;
-  @Mock private AsyncFrameWriter frameWriter;
+  @Mock private FrameWriter mockedFrameWriter;
+  private ExceptionHandlingFrameWriter frameWriter;
   @Mock private OkHttpClientTransport transport;
   @Mock private OutboundFlowController flowController;
   @Captor private ArgumentCaptor<List<Header>> headersCaptor;
 
   private final Object lock = new Object();
+  private final TransportTracer transportTracer = new TransportTracer();
 
   private MethodDescriptor<?, ?> methodDescriptor;
   private OkHttpClientStream stream;
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
     methodDescriptor = MethodDescriptor.<Void, Void>newBuilder()
         .setType(MethodDescriptor.MethodType.UNARY)
-        .setFullMethodName("/testService/test")
+        .setFullMethodName("testService/test")
         .setRequestMarshaller(marshaller)
         .setResponseMarshaller(marshaller)
         .build();
 
-    stream = new OkHttpClientStream(methodDescriptor, new Metadata(), frameWriter, transport,
-        flowController, lock, MAX_MESSAGE_SIZE, "localhost", "userAgent", StatsTraceContext.NOOP);
+    frameWriter =
+        new ExceptionHandlingFrameWriter(transport, mockedFrameWriter);
+    stream = new OkHttpClientStream(
+        methodDescriptor,
+        new Metadata(),
+        frameWriter,
+        transport,
+        flowController,
+        lock,
+        MAX_MESSAGE_SIZE,
+        INITIAL_WINDOW_SIZE,
+        "localhost",
+        "userAgent",
+        StatsTraceContext.NOOP,
+        transportTracer,
+        CallOptions.DEFAULT,
+        false);
   }
 
   @Test
@@ -97,76 +114,84 @@ public void getType() {
   }
 
   @Test
-  public void sendCancel_notStarted() {
-    final AtomicReference<Status> statusRef = new AtomicReference<Status>();
+  public void cancel_notStarted() {
+    final AtomicReference<Status> statusRef = new AtomicReference<>();
     stream.start(new BaseClientStreamListener() {
       @Override
-      public void closed(Status status, Metadata trailers) {
+      public void closed(
+          Status status, RpcProgress rpcProgress, Metadata trailers) {
         statusRef.set(status);
         assertTrue(Thread.holdsLock(lock));
       }
     });
 
-    stream.sendCancel(Status.CANCELLED);
+    stream.cancel(Status.CANCELLED);
 
     assertEquals(Status.Code.CANCELLED, statusRef.get().getCode());
   }
 
   @Test
-  public void sendCancel_started() {
+  @SuppressWarnings("GuardedBy")
+  public void cancel_started() {
     stream.start(new BaseClientStreamListener());
-    stream.start(1234);
+    stream.transportState().start(1234);
     Mockito.doAnswer(new Answer<Void>() {
       @Override
       public Void answer(InvocationOnMock invocation) throws Throwable {
         assertTrue(Thread.holdsLock(lock));
         return null;
       }
-    }).when(transport).finishStream(1234, Status.CANCELLED, ErrorCode.CANCEL);
+    }).when(transport).finishStream(
+        1234, Status.CANCELLED, PROCESSED, true, ErrorCode.CANCEL, null);
 
-    stream.sendCancel(Status.CANCELLED);
+    stream.cancel(Status.CANCELLED);
 
-    verify(transport).finishStream(1234, Status.CANCELLED, ErrorCode.CANCEL);
+    verify(transport).finishStream(1234, Status.CANCELLED, PROCESSED,true, ErrorCode.CANCEL, null);
   }
 
   @Test
+  @SuppressWarnings("GuardedBy")
   public void start_alreadyCancelled() {
     stream.start(new BaseClientStreamListener());
-    stream.sendCancel(Status.CANCELLED);
+    stream.cancel(Status.CANCELLED);
 
-    stream.start(1234);
+    stream.transportState().start(1234);
 
-    verifyNoMoreInteractions(frameWriter);
+    verifyNoMoreInteractions(mockedFrameWriter);
   }
 
   @Test
-  public void start_userAgentRemoved() {
+  @SuppressWarnings("GuardedBy")
+  public void start_userAgentRemoved() throws IOException {
     Metadata metaData = new Metadata();
     metaData.put(GrpcUtil.USER_AGENT_KEY, "misbehaving-application");
     stream = new OkHttpClientStream(methodDescriptor, metaData, frameWriter, transport,
-        flowController, lock, MAX_MESSAGE_SIZE, "localhost", "good-application",
-        StatsTraceContext.NOOP);
+        flowController, lock, MAX_MESSAGE_SIZE, INITIAL_WINDOW_SIZE, "localhost",
+        "good-application", StatsTraceContext.NOOP, transportTracer, CallOptions.DEFAULT, false);
     stream.start(new BaseClientStreamListener());
-    stream.start(3);
+    stream.transportState().start(3);
 
-    verify(frameWriter).synStream(eq(false), eq(false), eq(3), eq(0), headersCaptor.capture());
+    verify(mockedFrameWriter)
+        .synStream(eq(false), eq(false), eq(3), eq(0), headersCaptor.capture());
     assertThat(headersCaptor.getValue())
         .contains(new Header(GrpcUtil.USER_AGENT_KEY.name(), "good-application"));
   }
 
   @Test
-  public void start_headerFieldOrder() {
+  @SuppressWarnings("GuardedBy")
+  public void start_headerFieldOrder() throws IOException {
     Metadata metaData = new Metadata();
     metaData.put(GrpcUtil.USER_AGENT_KEY, "misbehaving-application");
     stream = new OkHttpClientStream(methodDescriptor, metaData, frameWriter, transport,
-        flowController, lock, MAX_MESSAGE_SIZE, "localhost", "good-application",
-        StatsTraceContext.NOOP);
+        flowController, lock, MAX_MESSAGE_SIZE, INITIAL_WINDOW_SIZE, "localhost",
+        "good-application", StatsTraceContext.NOOP, transportTracer, CallOptions.DEFAULT, false);
     stream.start(new BaseClientStreamListener());
-    stream.start(3);
+    stream.transportState().start(3);
 
-    verify(frameWriter).synStream(eq(false), eq(false), eq(3), eq(0), headersCaptor.capture());
+    verify(mockedFrameWriter)
+        .synStream(eq(false), eq(false), eq(3), eq(0), headersCaptor.capture());
     assertThat(headersCaptor.getValue()).containsExactly(
-        Headers.SCHEME_HEADER,
+        Headers.HTTPS_SCHEME_HEADER,
         Headers.METHOD_HEADER,
         new Header(Header.TARGET_AUTHORITY, "localhost"),
         new Header(Header.TARGET_PATH, "/" + methodDescriptor.getFullMethodName()),
@@ -176,20 +201,75 @@ public void start_headerFieldOrder() {
             .inOrder();
   }
 
-  // TODO(carl-mastrangelo): extract this out into a testing/ directory and remove other definitions
-  // of it.
-  private static class BaseClientStreamListener implements ClientStreamListener {
-    @Override
-    public void onReady() {}
+  @Test
+  @SuppressWarnings("GuardedBy")
+  public void start_headerPlaintext() throws IOException {
+    Metadata metaData = new Metadata();
+    metaData.put(GrpcUtil.USER_AGENT_KEY, "misbehaving-application");
+    when(transport.isUsingPlaintext()).thenReturn(true);
+    stream = new OkHttpClientStream(methodDescriptor, metaData, frameWriter, transport,
+        flowController, lock, MAX_MESSAGE_SIZE, INITIAL_WINDOW_SIZE, "localhost",
+        "good-application", StatsTraceContext.NOOP, transportTracer, CallOptions.DEFAULT, false);
+    stream.start(new BaseClientStreamListener());
+    stream.transportState().start(3);
 
-    @Override
-    public void messageRead(InputStream message) {}
+    verify(mockedFrameWriter)
+        .synStream(eq(false), eq(false), eq(3), eq(0), headersCaptor.capture());
+    assertThat(headersCaptor.getValue()).containsExactly(
+        Headers.HTTP_SCHEME_HEADER,
+        Headers.METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "localhost"),
+        new Header(Header.TARGET_PATH, "/" + methodDescriptor.getFullMethodName()),
+        new Header(GrpcUtil.USER_AGENT_KEY.name(), "good-application"),
+        Headers.CONTENT_TYPE_HEADER,
+        Headers.TE_HEADER)
+        .inOrder();
+  }
 
-    @Override
-    public void headersRead(Metadata headers) {}
+  @Test
+  @SuppressWarnings("GuardedBy")
+  public void getUnaryRequest() throws IOException {
+    MethodDescriptor<?, ?> getMethod = MethodDescriptor.<Void, Void>newBuilder()
+        .setType(MethodDescriptor.MethodType.UNARY)
+        .setFullMethodName("service/method")
+        .setIdempotent(true)
+        .setSafe(true)
+        .setRequestMarshaller(marshaller)
+        .setResponseMarshaller(marshaller)
+        .build();
+    stream = new OkHttpClientStream(getMethod, new Metadata(), frameWriter, transport,
+        flowController, lock, MAX_MESSAGE_SIZE, INITIAL_WINDOW_SIZE, "localhost",
+        "good-application", StatsTraceContext.NOOP, transportTracer, CallOptions.DEFAULT, true);
+    stream.start(new BaseClientStreamListener());
+
+    // GET streams send headers after halfClose is called.
+    verify(mockedFrameWriter, times(0)).synStream(
+        eq(false), eq(false), eq(3), eq(0), headersCaptor.capture());
+    verify(transport, times(0)).streamReadyToStart(isA(OkHttpClientStream.class),
+            isA(String.class));
+
+    byte[] msg = "request".getBytes(Charset.forName("UTF-8"));
+    stream.writeMessage(new ByteArrayInputStream(msg));
+    stream.halfClose();
+    verify(transport).streamReadyToStart(eq(stream), any(String.class));
+    stream.transportState().start(3);
+
+    verify(mockedFrameWriter)
+        .synStream(eq(true), eq(false), eq(3), eq(0), headersCaptor.capture());
+    assertThat(headersCaptor.getValue()).contains(Headers.METHOD_GET_HEADER);
+    assertThat(headersCaptor.getValue()).contains(
+        new Header(Header.TARGET_PATH, "/" + getMethod.getFullMethodName() + "?"
+            + BaseEncoding.base64().encode(msg)));
+  }
+
+  // TODO(carl-mastrangelo): extract this out into a testing/ directory and remove other definitions
+  // of it.
+  private static class BaseClientStreamListener extends NoopClientStreamListener {
 
     @Override
-    public void closed(Status status, Metadata trailers) {}
+    public void messagesAvailable(MessageProducer producer) {
+      while (producer.next() != null) {}
+    }
   }
 }
 
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportFactoryTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportFactoryTest.java
index 1f0141e6a25..dea99174c96 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportFactoryTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportFactoryTest.java
@@ -1,38 +1,23 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
+import io.grpc.internal.AbstractClientTransportFactoryTest;
 import io.grpc.internal.ClientTransportFactory;
-import io.grpc.internal.testing.AbstractClientTransportFactoryTest;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportTest.java
index 92380223958..f87912c44ea 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpClientTransportTest.java
@@ -1,118 +1,145 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
-import static com.google.common.base.Charsets.UTF_8;
 import static com.google.common.truth.Truth.assertThat;
-import static io.grpc.Status.Code.INTERNAL;
-import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.MISCARRIED;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.PROCESSED;
+import static io.grpc.internal.ClientStreamListener.RpcProgress.REFUSED;
 import static io.grpc.okhttp.Headers.CONTENT_TYPE_HEADER;
+import static io.grpc.okhttp.Headers.HTTP_SCHEME_HEADER;
 import static io.grpc.okhttp.Headers.METHOD_HEADER;
-import static io.grpc.okhttp.Headers.SCHEME_HEADER;
 import static io.grpc.okhttp.Headers.TE_HEADER;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyBoolean;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.isA;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.reset;
 import static org.mockito.Mockito.timeout;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.verifyNoInteractions;
 
+import com.google.common.base.Preconditions;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
 import com.google.common.base.Ticker;
 import com.google.common.collect.ImmutableList;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.HttpConnectProxiedSocketAddress;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalChannelz.TransportStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.InternalStatus;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.MethodType;
 import io.grpc.Status;
 import io.grpc.Status.Code;
-import io.grpc.StatusException;
 import io.grpc.internal.AbstractStream;
+import io.grpc.internal.ClientStream;
 import io.grpc.internal.ClientStreamListener;
 import io.grpc.internal.ClientTransport;
+import io.grpc.internal.DisconnectError;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GoAwayDisconnectError;
 import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.ManagedClientTransport;
+import io.grpc.internal.SimpleDisconnectError;
 import io.grpc.okhttp.OkHttpClientTransport.ClientFrameHandler;
-import io.grpc.okhttp.internal.ConnectionSpec;
+import io.grpc.okhttp.OkHttpFrameLogger.Direction;
+import io.grpc.okhttp.internal.Protocol;
 import io.grpc.okhttp.internal.framed.ErrorCode;
 import io.grpc.okhttp.internal.framed.FrameReader;
 import io.grpc.okhttp.internal.framed.FrameWriter;
 import io.grpc.okhttp.internal.framed.Header;
 import io.grpc.okhttp.internal.framed.HeadersMode;
 import io.grpc.okhttp.internal.framed.Settings;
+import io.grpc.okhttp.internal.framed.Variant;
 import io.grpc.testing.TestMethodDescriptors;
 import java.io.BufferedReader;
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PipedInputStream;
+import java.io.PipedOutputStream;
+import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.ServerSocket;
 import java.net.Socket;
+import java.net.SocketAddress;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Queue;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
 import javax.annotation.Nullable;
+import javax.net.SocketFactory;
+import javax.net.ssl.HandshakeCompletedListener;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSocket;
 import okio.Buffer;
+import okio.BufferedSink;
+import okio.BufferedSource;
+import okio.ByteString;
 import org.junit.After;
-import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.Timeout;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
+import org.mockito.AdditionalAnswers;
 import org.mockito.ArgumentCaptor;
-import org.mockito.Matchers;
+import org.mockito.ArgumentMatchers;
+import org.mockito.InOrder;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /**
  * Tests for {@link OkHttpClientTransport}.
@@ -120,36 +147,48 @@
 @RunWith(JUnit4.class)
 public class OkHttpClientTransportTest {
   private static final int TIME_OUT_MS = 2000;
+  private static final int INITIAL_WINDOW_SIZE = 65535;
   private static final String NETWORK_ISSUE_MESSAGE = "network issue";
   private static final String ERROR_MESSAGE = "simulated error";
   // The gRPC header length, which includes 1 byte compression flag and 4 bytes message length.
   private static final int HEADER_LENGTH = 5;
-
-  @Rule
-  public Timeout globalTimeout = new Timeout(10 * 1000);
-
-  @Mock
-  private FrameWriter frameWriter;
+  private static final Status SHUTDOWN_REASON = Status.UNAVAILABLE.withDescription("for test");
+  private static final HttpConnectProxiedSocketAddress NO_PROXY = null;
+  private static final int DEFAULT_START_STREAM_ID = 3;
+  private static final Attributes EAG_ATTRS = Attributes.EMPTY;
+  private static final Logger logger = Logger.getLogger(OkHttpClientTransport.class.getName());
+  private static final ClientStreamTracer[] tracers = new ClientStreamTracer[] {
+      new ClientStreamTracer() {}
+  };
+
+  @Rule public final Timeout globalTimeout = Timeout.seconds(10);
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
 
   private MethodDescriptor<Void, Void> method = TestMethodDescriptors.voidMethod();
 
   @Mock
   private ManagedClientTransport.Listener transportListener;
+
+  private final Queue<Buffer> capturedBuffer = new ArrayDeque<>();
   private OkHttpClientTransport clientTransport;
-  private MockFrameReader frameReader;
-  private ExecutorService executor;
+  private final MockFrameReader frameReader = new MockFrameReader();
+  private final Socket socket = new MockSocket(frameReader);
+  private final FrameWriter frameWriter = mock(FrameWriter.class, AdditionalAnswers.delegatesTo(
+      new MockFrameWriter(socket, capturedBuffer)));
+  private ExecutorService executor = Executors.newCachedThreadPool();
   private long nanoTime; // backs a ticker, for testing ping round-trip time measurement
   private SettableFuture<Void> connectedFuture;
-  private DelayConnectedCallback delayConnectedCallback;
-
-  /** Set up for test. */
-  @Before
-  public void setUp() {
-    MockitoAnnotations.initMocks(this);
-    executor = Executors.newCachedThreadPool();
-    when(frameWriter.maxDataLength()).thenReturn(Integer.MAX_VALUE);
-    frameReader = new MockFrameReader();
-  }
+  private Runnable tooManyPingsRunnable = new Runnable() {
+    @Override public void run() {
+      throw new AssertionError();
+    }
+  };
+  private OkHttpChannelBuilder channelBuilder = OkHttpChannelBuilder.forAddress("127.0.0.1", 1234)
+      .usePlaintext()
+      .executor(new FakeClock().getScheduledExecutorService()) // Executor unused
+      .scheduledExecutorService(new FakeClock().getScheduledExecutorService()) // Executor unused
+      .transportExecutor(executor)
+      .flowControlWindow(INITIAL_WINDOW_SIZE);
 
   @After
   public void tearDown() {
@@ -157,55 +196,224 @@ public void tearDown() {
   }
 
   private void initTransport() throws Exception {
-    startTransport(3, null, true, DEFAULT_MAX_MESSAGE_SIZE, null);
+    startTransport(
+        DEFAULT_START_STREAM_ID, null, true, null, null);
   }
 
   private void initTransport(int startId) throws Exception {
-    startTransport(startId, null, true, DEFAULT_MAX_MESSAGE_SIZE, null);
+    startTransport(startId, null, true, null, null);
   }
 
-  private void initTransportAndDelayConnected() throws Exception {
-    delayConnectedCallback = new DelayConnectedCallback();
-    startTransport(3, delayConnectedCallback, false, DEFAULT_MAX_MESSAGE_SIZE, null);
+  private void startTransport(int startId, @Nullable Runnable connectingCallback,
+                              boolean waitingForConnected, String userAgent,
+                              HostnameVerifier hostnameVerifier) throws Exception {
+    startTransport(startId, connectingCallback, waitingForConnected, userAgent, hostnameVerifier,
+            false);
   }
 
   private void startTransport(int startId, @Nullable Runnable connectingCallback,
-      boolean waitingForConnected, int maxMessageSize, String userAgent) throws Exception {
+                              boolean waitingForConnected, String userAgent,
+                              HostnameVerifier hostnameVerifier, boolean useSslSocket)
+          throws Exception {
     connectedFuture = SettableFuture.create();
-    Ticker ticker = new Ticker() {
+    final Ticker ticker = new Ticker() {
       @Override
       public long read() {
         return nanoTime;
       }
     };
-    clientTransport = new OkHttpClientTransport(userAgent, executor, frameReader,
-        frameWriter, startId, new MockSocket(frameReader), ticker, connectingCallback,
-        connectedFuture, maxMessageSize);
+    Supplier<Stopwatch> stopwatchSupplier = new Supplier<Stopwatch>() {
+      @Override
+      public Stopwatch get() {
+        return Stopwatch.createUnstarted(ticker);
+      }
+    };
+    channelBuilder.socketFactory(
+            new FakeSocketFactory(useSslSocket ? new MockSslSocket(socket) : socket));
+    if (hostnameVerifier != null) {
+      channelBuilder = channelBuilder.hostnameVerifier(hostnameVerifier);
+    }
+    clientTransport = new OkHttpClientTransport(
+        channelBuilder.buildTransportFactory(),
+        userAgent,
+        stopwatchSupplier,
+        new FakeVariant(frameReader, frameWriter),
+        connectingCallback,
+        connectedFuture,
+        tooManyPingsRunnable);
     clientTransport.start(transportListener);
     if (waitingForConnected) {
       connectedFuture.get(TIME_OUT_MS, TimeUnit.MILLISECONDS);
     }
+    if (startId != DEFAULT_START_STREAM_ID) {
+      clientTransport.setNextStreamId(startId);
+    }
   }
 
   @Test
   public void testToString() throws Exception {
     InetSocketAddress address = InetSocketAddress.createUnresolved("hostname", 31415);
     clientTransport = new OkHttpClientTransport(
-        address, "hostname", null /* agent */, executor, null,
-        Utils.convertSpec(OkHttpChannelBuilder.DEFAULT_CONNECTION_SPEC), DEFAULT_MAX_MESSAGE_SIZE,
-        null, null, null);
+        channelBuilder.buildTransportFactory(),
+        address,
+        "hostname",
+        /*userAgent=*/ null,
+        EAG_ATTRS,
+        NO_PROXY,
+        tooManyPingsRunnable,
+        null);
     String s = clientTransport.toString();
     assertTrue("Unexpected: " + s, s.contains("OkHttpClientTransport"));
     assertTrue("Unexpected: " + s, s.contains(address.toString()));
   }
 
+  @Test
+  public void testTransportExecutorWithTooFewThreads() throws Exception {
+    ExecutorService fixedPoolExecutor = Executors.newFixedThreadPool(1);
+    channelBuilder.transportExecutor(fixedPoolExecutor);
+    InetSocketAddress address = InetSocketAddress.createUnresolved("hostname", 31415);
+    clientTransport = new OkHttpClientTransport(
+        channelBuilder.buildTransportFactory(),
+        address,
+        "hostname",
+        null,
+        EAG_ATTRS,
+        NO_PROXY,
+        tooManyPingsRunnable,
+        null);
+    clientTransport.start(transportListener);
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(transportListener, timeout(TIME_OUT_MS)).transportShutdown(statusCaptor.capture(),
+        eq(new GoAwayDisconnectError(GrpcUtil.Http2Error.INTERNAL_ERROR)));
+    Status capturedStatus = statusCaptor.getValue();
+    assertEquals("Timed out waiting for second handshake thread. "
+        + "The transport executor pool may have run out of threads",
+        capturedStatus.getDescription());
+  }
+
+  /**
+   * Test logging is functioning correctly for client received Http/2 frames. Not intended to test
+   * actual frame content being logged.
+   */
+  @Test
+  public void testClientHandlerFrameLogger() throws Exception {
+    final List<LogRecord> logs = new ArrayList<>();
+    Handler handler = new Handler() {
+      @Override
+      public void publish(LogRecord record) {
+        logs.add(record);
+      }
+
+      @Override
+      public void flush() {
+      }
+
+      @Override
+      public void close() throws SecurityException {
+      }
+    };
+    logger.addHandler(handler);
+    logger.setLevel(Level.ALL);
+
+    initTransport();
+    assertThat(logs).hasSize(1);
+    LogRecord log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " SETTINGS: ack=false");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    MockStreamListener listener = new MockStreamListener();
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream.start(listener);
+    stream.request(1);
+
+    frameHandler().headers(false, false, 3, 0, grpcResponseHeaders(), HeadersMode.HTTP_20_HEADERS);
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.INBOUND + " HEADERS: streamId=" + 3);
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    final String message = "Hello Client";
+    Buffer buffer = createMessageFrame(message);
+    frameHandler().data(false, 3, buffer, (int) buffer.size(),
+        (int) buffer.size());
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.INBOUND + " DATA: streamId=" + 3);
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    // At most 64 bytes of data frame will be logged.
+    frameHandler().data(false, 3, createMessageFrame(new String(new char[1000])),
+        1000, 1000);
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    String data = log.getMessage();
+    assertThat(data).endsWith("...");
+    assertThat(data.substring(data.indexOf("bytes="), data.indexOf("..."))).hasLength(64 * 2 + 6);
+
+    // A SETTINGS ACK frame is sent out after receiving SETTINGS frame.
+    frameHandler().settings(false, new Settings());
+    assertThat(logs).hasSize(2);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.INBOUND + " SETTINGS: ack=false");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " SETTINGS: ack=true");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    // A PING ACK frame is sent out after receiving PING frame.
+    frameHandler().ping(false, 0, 0);
+    assertThat(logs).hasSize(2);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.INBOUND + " PING: ack=false");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " PING: ack=true");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    // As server push is not supported, a RST_STREAM is sent out after receiving PUSH_PROMISE frame.
+    frameHandler().pushPromise(3, 3, grpcResponseHeaders());
+    assertThat(logs).hasSize(2);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.INBOUND + " PUSH_PROMISE");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " RST_STREAM");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    frameHandler().rstStream(3, ErrorCode.CANCEL);
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.INBOUND + " RST_STREAM");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    // Outbound GO_AWAY is responded after receiving inbound GO_AWAY frame.
+    frameHandler().goAway(3, ErrorCode.CANCEL, ByteString.EMPTY);
+    assertThat(logs).hasSize(2);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.INBOUND + " GO_AWAY");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.OUTBOUND + " GO_AWAY");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    frameHandler().windowUpdate(3, 32);
+    assertThat(logs).hasSize(1);
+    log = logs.remove(0);
+    assertThat(log.getMessage()).startsWith(Direction.INBOUND + " WINDOW_UPDATE");
+    assertThat(log.getLevel()).isEqualTo(Level.FINE);
+
+    logger.removeHandler(handler);
+  }
+
   @Test
   public void maxMessageSizeShouldBeEnforced() throws Exception {
-    // Allow the response payloads of up to 1 byte.
-    startTransport(3, null, true, 1, null);
+    channelBuilder.maxInboundMessageSize(1);
+    initTransport();
 
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
     assertContainStream(3);
@@ -215,13 +423,40 @@ public void maxMessageSizeShouldBeEnforced() throws Exception {
     // Receive the message.
     final String message = "Hello Client";
     Buffer buffer = createMessageFrame(message);
-    frameHandler().data(false, 3, buffer, (int) buffer.size());
+    frameHandler().data(false, 3, buffer, (int) buffer.size(),
+        (int) buffer.size());
 
     listener.waitUntilStreamClosed();
-    assertEquals(INTERNAL, listener.status.getCode());
+    assertEquals(Code.RESOURCE_EXHAUSTED, listener.status.getCode());
     shutdownAndVerify();
   }
 
+  @Test
+  public void includeInitialWindowSizeInFirstSettings() throws Exception {
+    channelBuilder.flowControlWindow(65535);
+    initTransport();
+
+    ArgumentCaptor<Settings> settings = ArgumentCaptor.forClass(Settings.class);
+    verify(frameWriter, timeout(TIME_OUT_MS)).settings(settings.capture());
+    assertEquals(65535, settings.getValue().get(7));
+  }
+
+  /**
+   * A "large" window size is anything over 65535 (the starting size for any connection-level
+   * flow control value).
+   */
+  @Test
+  public void includeInitialWindowSizeInFirstSettings_largeWindowSize() throws Exception {
+    channelBuilder.flowControlWindow(75535); // 65535 + 10000
+    initTransport();
+
+    ArgumentCaptor<Settings> settings = ArgumentCaptor.forClass(Settings.class);
+    verify(frameWriter, timeout(TIME_OUT_MS)).settings(settings.capture());
+    assertEquals(75535, settings.getValue().get(7));
+
+    verify(frameWriter, timeout(TIME_OUT_MS)).windowUpdate(0, 10000);
+  }
+
   /**
    * When nextFrame throws IOException, the transport should be aborted.
    */
@@ -230,10 +465,12 @@ public void nextFrameThrowIoException() throws Exception {
     initTransport();
     MockStreamListener listener1 = new MockStreamListener();
     MockStreamListener listener2 = new MockStreamListener();
-    OkHttpClientStream stream1 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream1.start(listener1);
     stream1.request(1);
-    OkHttpClientStream stream2 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
     stream2.request(1);
     assertEquals(2, activeStreamCount());
@@ -244,11 +481,12 @@ public void nextFrameThrowIoException() throws Exception {
     listener2.waitUntilStreamClosed();
 
     assertEquals(0, activeStreamCount());
-    assertEquals(Status.UNAVAILABLE.getCode(), listener1.status.getCode());
+    assertEquals(Status.INTERNAL.getCode(), listener1.status.getCode());
     assertEquals(NETWORK_ISSUE_MESSAGE, listener1.status.getCause().getMessage());
-    assertEquals(Status.UNAVAILABLE.getCode(), listener2.status.getCode());
+    assertEquals(Status.INTERNAL.getCode(), listener2.status.getCode());
     assertEquals(NETWORK_ISSUE_MESSAGE, listener2.status.getCause().getMessage());
-    verify(transportListener, timeout(TIME_OUT_MS)).transportShutdown(isA(Status.class));
+    verify(transportListener, timeout(TIME_OUT_MS)).transportShutdown(isA(Status.class),
+        any(DisconnectError.class));
     verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
     shutdownAndVerify();
   }
@@ -262,7 +500,8 @@ public void nextFrameThrowIoException() throws Exception {
   public void nextFrameThrowsError() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
     assertEquals(1, activeStreamCount());
@@ -271,9 +510,10 @@ public void nextFrameThrowsError() throws Exception {
     listener.waitUntilStreamClosed();
 
     assertEquals(0, activeStreamCount());
-    assertEquals(Status.UNAVAILABLE.getCode(), listener.status.getCode());
+    assertEquals(Status.INTERNAL.getCode(), listener.status.getCode());
     assertEquals(ERROR_MESSAGE, listener.status.getCause().getMessage());
-    verify(transportListener, timeout(TIME_OUT_MS)).transportShutdown(isA(Status.class));
+    verify(transportListener, timeout(TIME_OUT_MS)).transportShutdown(isA(Status.class),
+        any(DisconnectError.class));
     verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
     shutdownAndVerify();
   }
@@ -282,13 +522,15 @@ public void nextFrameThrowsError() throws Exception {
   public void nextFrameReturnFalse() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
     frameReader.nextFrameAtEndOfStream();
     listener.waitUntilStreamClosed();
     assertEquals(Status.UNAVAILABLE.getCode(), listener.status.getCode());
-    verify(transportListener, timeout(TIME_OUT_MS)).transportShutdown(isA(Status.class));
+    verify(transportListener, timeout(TIME_OUT_MS)).transportShutdown(isA(Status.class),
+        any(DisconnectError.class));
     verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
     shutdownAndVerify();
   }
@@ -299,7 +541,8 @@ public void readMessages() throws Exception {
     final int numMessages = 10;
     final String message = "Hello Client";
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(numMessages);
     assertContainStream(3);
@@ -307,7 +550,8 @@ public void readMessages() throws Exception {
     assertNotNull(listener.headers);
     for (int i = 0; i < numMessages; i++) {
       Buffer buffer = createMessageFrame(message + i);
-      frameHandler().data(false, 3, buffer, (int) buffer.size());
+      frameHandler().data(false, 3, buffer, (int) buffer.size(),
+          (int) buffer.size());
     }
     frameHandler().headers(true, true, 3, 0, grpcResponseTrailers(), HeadersMode.HTTP_20_HEADERS);
     listener.waitUntilStreamClosed();
@@ -328,7 +572,8 @@ public void receivedHeadersForInvalidStreamShouldKillConnection() throws Excepti
         HeadersMode.HTTP_20_HEADERS);
     verify(frameWriter, timeout(TIME_OUT_MS))
         .goAway(eq(0), eq(ErrorCode.PROTOCOL_ERROR), any(byte[].class));
-    verify(transportListener).transportShutdown(isA(Status.class));
+    verify(transportListener).transportShutdown(isA(Status.class),
+        any(DisconnectError.class));
     verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
     shutdownAndVerify();
   }
@@ -336,10 +581,12 @@ public void receivedHeadersForInvalidStreamShouldKillConnection() throws Excepti
   @Test
   public void receivedDataForInvalidStreamShouldKillConnection() throws Exception {
     initTransport();
-    frameHandler().data(false, 3, createMessageFrame(new String(new char[1000])), 1000);
+    frameHandler().data(false, 3, createMessageFrame(new String(new char[1000])),
+        1000, 1000);
     verify(frameWriter, timeout(TIME_OUT_MS))
         .goAway(eq(0), eq(ErrorCode.PROTOCOL_ERROR), any(byte[].class));
-    verify(transportListener).transportShutdown(isA(Status.class));
+    verify(transportListener).transportShutdown(isA(Status.class),
+        any(DisconnectError.class));
     verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
     shutdownAndVerify();
   }
@@ -348,7 +595,8 @@ public void receivedDataForInvalidStreamShouldKillConnection() throws Exception
   public void invalidInboundHeadersCancelStream() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
     assertContainStream(3);
@@ -357,7 +605,8 @@ public void invalidInboundHeadersCancelStream() throws Exception {
         HeadersMode.HTTP_20_HEADERS);
     // Now wait to receive 1000 bytes of data so we can have a better error message before
     // cancelling the streaam.
-    frameHandler().data(false, 3, createMessageFrame(new String(new char[1000])), 1000);
+    frameHandler().data(false, 3,
+        createMessageFrame(new String(new char[1000])), 1000, 1000);
     verify(frameWriter, timeout(TIME_OUT_MS)).rstStream(eq(3), eq(ErrorCode.CANCEL));
     assertNull(listener.headers);
     assertEquals(Status.INTERNAL.getCode(), listener.status.getCode());
@@ -371,7 +620,8 @@ public void invalidInboundHeadersCancelStream() throws Exception {
   public void invalidInboundTrailersPropagateToMetadata() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
     assertContainStream(3);
@@ -390,7 +640,8 @@ public void invalidInboundTrailersPropagateToMetadata() throws Exception {
   public void readStatus() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     assertContainStream(3);
     frameHandler().headers(true, true, 3, 0, grpcResponseTrailers(), HeadersMode.HTTP_20_HEADERS);
@@ -403,7 +654,8 @@ public void readStatus() throws Exception {
   public void receiveReset() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     assertContainStream(3);
     frameHandler().rstStream(3, ErrorCode.PROTOCOL_ERROR);
@@ -414,11 +666,34 @@ public void receiveReset() throws Exception {
     shutdownAndVerify();
   }
 
+
+  @Test
+  public void receiveResetNoError() throws Exception {
+    initTransport();
+    MockStreamListener listener = new MockStreamListener();
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream.start(listener);
+    assertContainStream(3);
+    frameHandler().headers(false, false, 3, 0, grpcResponseHeaders(), HeadersMode.HTTP_20_HEADERS);
+    Buffer buffer = createMessageFrame("a message");
+    frameHandler().data(false, 3, buffer, (int) buffer.size(),
+        (int) buffer.size());
+    frameHandler().headers(true, true, 3, 0, grpcResponseTrailers(), HeadersMode.HTTP_20_HEADERS);
+    frameHandler().rstStream(3, ErrorCode.NO_ERROR);
+    stream.request(1);
+    listener.waitUntilStreamClosed();
+
+    assertTrue(listener.status.isOk());
+    shutdownAndVerify();
+  }
+
   @Test
   public void cancelStream() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     getStream(3).cancel(Status.CANCELLED);
     verify(frameWriter, timeout(TIME_OUT_MS)).rstStream(eq(3), eq(ErrorCode.CANCEL));
@@ -432,11 +707,12 @@ public void cancelStream() throws Exception {
   public void addDefaultUserAgent() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     Header userAgentHeader = new Header(GrpcUtil.USER_AGENT_KEY.name(),
             GrpcUtil.getGrpcUserAgent("okhttp", null));
-    List<Header> expectedHeaders = Arrays.asList(SCHEME_HEADER, METHOD_HEADER,
+    List<Header> expectedHeaders = Arrays.asList(HTTP_SCHEME_HEADER, METHOD_HEADER,
             new Header(Header.TARGET_AUTHORITY, "notarealauthority:80"),
             new Header(Header.TARGET_PATH, "/" + method.getFullMethodName()),
             userAgentHeader, CONTENT_TYPE_HEADER, TE_HEADER);
@@ -448,11 +724,12 @@ public void addDefaultUserAgent() throws Exception {
 
   @Test
   public void overrideDefaultUserAgent() throws Exception {
-    startTransport(3, null, true, DEFAULT_MAX_MESSAGE_SIZE, "fakeUserAgent");
+    startTransport(3, null, true, "fakeUserAgent", null);
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
-    List<Header> expectedHeaders = Arrays.asList(SCHEME_HEADER, METHOD_HEADER,
+    List<Header> expectedHeaders = Arrays.asList(HTTP_SCHEME_HEADER, METHOD_HEADER,
         new Header(Header.TARGET_AUTHORITY, "notarealauthority:80"),
         new Header(Header.TARGET_PATH, "/" + method.getFullMethodName()),
         new Header(GrpcUtil.USER_AGENT_KEY.name(),
@@ -468,7 +745,8 @@ public void overrideDefaultUserAgent() throws Exception {
   public void cancelStreamForDeadlineExceeded() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     getStream(3).cancel(Status.DEADLINE_EXCEEDED);
     verify(frameWriter, timeout(TIME_OUT_MS)).rstStream(eq(3), eq(ErrorCode.CANCEL));
@@ -481,31 +759,113 @@ public void writeMessage() throws Exception {
     initTransport();
     final String message = "Hello Server";
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     InputStream input = new ByteArrayInputStream(message.getBytes(UTF_8));
     assertEquals(12, input.available());
     stream.writeMessage(input);
     stream.flush();
-    ArgumentCaptor<Buffer> captor = ArgumentCaptor.forClass(Buffer.class);
     verify(frameWriter, timeout(TIME_OUT_MS))
-        .data(eq(false), eq(3), captor.capture(), eq(12 + HEADER_LENGTH));
-    Buffer sentFrame = captor.getValue();
+        .data(eq(false), eq(3), any(Buffer.class), eq(12 + HEADER_LENGTH));
+    Buffer sentFrame = capturedBuffer.poll();
     assertEquals(createMessageFrame(message), sentFrame);
     stream.cancel(Status.CANCELLED);
     shutdownAndVerify();
   }
 
+  @Test
+  public void perRpcAuthoritySpecified_verificationSkippedInPlainTextConnection()
+          throws Exception {
+    initTransport();
+    final String message = "Hello Server";
+    MockStreamListener listener = new MockStreamListener();
+    ClientStream stream =
+            clientTransport.newStream(method, new Metadata(),
+                    CallOptions.DEFAULT.withAuthority("some-authority"), tracers);
+    stream.start(listener);
+    InputStream input = new ByteArrayInputStream(message.getBytes(UTF_8));
+    assertEquals(12, input.available());
+    stream.writeMessage(input);
+    stream.flush();
+    verify(frameWriter, timeout(TIME_OUT_MS))
+            .data(eq(false), eq(3), any(Buffer.class), eq(12 + HEADER_LENGTH));
+    Buffer sentFrame = capturedBuffer.poll();
+    assertEquals(createMessageFrame(message), sentFrame);
+    stream.cancel(Status.CANCELLED);
+    shutdownAndVerify();
+  }
+
+  @Test
+  public void perRpcAuthoritySpecified_hostnameVerification_ignoredForNonSslSocket()
+          throws Exception {
+    startTransport(
+            DEFAULT_START_STREAM_ID, null, true, null,
+            (hostname, session) -> false, false);
+    ClientStream unused =
+            clientTransport.newStream(method, new Metadata(),
+                    CallOptions.DEFAULT.withAuthority("some-authority"), tracers);
+    shutdownAndVerify();
+  }
+
+  @Test
+  public void perRpcAuthoritySpecified_hostnameVerification_SslSocket_successCase()
+          throws Exception {
+    startTransport(
+            DEFAULT_START_STREAM_ID, null, true, null,
+            (hostname, session) -> true, true);
+    ClientStream unused =
+            clientTransport.newStream(method, new Metadata(),
+                    CallOptions.DEFAULT.withAuthority("some-authority"), tracers);
+    shutdownAndVerify();
+  }
+
+  @Test
+  public void perRpcAuthoritySpecified_hostnameVerification_SslSocket_flagDisabled()
+          throws Exception {
+    startTransport(
+            DEFAULT_START_STREAM_ID, null, true, null,
+            (hostname, session) -> false, true);
+    ClientStream clientStream =
+            clientTransport.newStream(method, new Metadata(),
+                    CallOptions.DEFAULT.withAuthority("some-authority"), tracers);
+    assertThat(clientStream).isInstanceOf(OkHttpClientStream.class);
+    shutdownAndVerify();
+  }
+
+  @Test
+  public void transportTracer_windowSizeDefault() throws Exception {
+    initTransport();
+    TransportStats stats = getTransportStats(clientTransport);
+    assertEquals(INITIAL_WINDOW_SIZE / 2, stats.remoteFlowControlWindow); // Lower bound
+    assertEquals(INITIAL_WINDOW_SIZE, stats.localFlowControlWindow);
+  }
+
+  @Test
+  public void transportTracer_windowSize_remote() throws Exception {
+    initTransport();
+    TransportStats before = getTransportStats(clientTransport);
+    assertEquals(INITIAL_WINDOW_SIZE / 2, before.remoteFlowControlWindow); // Lower bound
+    assertEquals(INITIAL_WINDOW_SIZE, before.localFlowControlWindow);
+
+    frameHandler().windowUpdate(0, 1000);
+    TransportStats after = getTransportStats(clientTransport);
+    assertEquals(INITIAL_WINDOW_SIZE / 2, after.remoteFlowControlWindow);
+    assertEquals(INITIAL_WINDOW_SIZE + 1000, after.localFlowControlWindow);
+  }
+
   @Test
   public void windowUpdate() throws Exception {
     initTransport();
     MockStreamListener listener1 = new MockStreamListener();
     MockStreamListener listener2 = new MockStreamListener();
-    OkHttpClientStream stream1 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream1.start(listener1);
     stream1.request(2);
 
-    OkHttpClientStream stream2 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
     stream2.request(2);
     assertEquals(2, activeStreamCount());
@@ -515,17 +875,20 @@ public void windowUpdate() throws Exception {
     frameHandler().headers(false, false, 3, 0, grpcResponseHeaders(), HeadersMode.HTTP_20_HEADERS);
     frameHandler().headers(false, false, 5, 0, grpcResponseHeaders(), HeadersMode.HTTP_20_HEADERS);
 
-    int messageLength = Utils.DEFAULT_WINDOW_SIZE / 4;
+    int messageLength = INITIAL_WINDOW_SIZE / 4;
     byte[] fakeMessage = new byte[messageLength];
+    int paddingLength = 2;
 
     // Stream 1 receives a message
-    Buffer buffer = createMessageFrame(fakeMessage);
+    Buffer buffer = createMessageFrame(fakeMessage, paddingLength);
     int messageFrameLength = (int) buffer.size();
-    frameHandler().data(false, 3, buffer, messageFrameLength);
+    frameHandler().data(false, 3, buffer, messageFrameLength - paddingLength,
+        messageFrameLength);
 
     // Stream 2 receives a message
-    buffer = createMessageFrame(fakeMessage);
-    frameHandler().data(false, 5, buffer, messageFrameLength);
+    buffer = createMessageFrame(fakeMessage, paddingLength);
+    frameHandler().data(false, 5, buffer, messageFrameLength - paddingLength,
+        messageFrameLength);
 
     verify(frameWriter, timeout(TIME_OUT_MS))
         .windowUpdate(eq(0), eq((long) 2 * messageFrameLength));
@@ -533,17 +896,18 @@ public void windowUpdate() throws Exception {
 
     // Stream 1 receives another message
     buffer = createMessageFrame(fakeMessage);
-    frameHandler().data(false, 3, buffer, messageFrameLength);
+    messageFrameLength = (int) buffer.size();
+    frameHandler().data(false, 3, buffer, messageFrameLength, messageFrameLength);
 
     verify(frameWriter, timeout(TIME_OUT_MS))
-        .windowUpdate(eq(3), eq((long) 2 * messageFrameLength));
+        .windowUpdate(eq(3), eq((long) 2 * messageFrameLength + paddingLength));
 
     // Stream 2 receives another message
     buffer = createMessageFrame(fakeMessage);
-    frameHandler().data(false, 5, buffer, messageFrameLength);
+    frameHandler().data(false, 5, buffer, messageFrameLength, messageFrameLength);
 
     verify(frameWriter, timeout(TIME_OUT_MS))
-        .windowUpdate(eq(5), eq((long) 2 * messageFrameLength));
+        .windowUpdate(eq(5), eq((long) 2 * messageFrameLength + paddingLength));
     verify(frameWriter, timeout(TIME_OUT_MS))
         .windowUpdate(eq(0), eq((long) 2 * messageFrameLength));
 
@@ -565,15 +929,17 @@ public void windowUpdate() throws Exception {
   public void windowUpdateWithInboundFlowControl() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
-    int messageLength = Utils.DEFAULT_WINDOW_SIZE / 2 + 1;
+    int messageLength = INITIAL_WINDOW_SIZE / 2 + 1;
     byte[] fakeMessage = new byte[messageLength];
 
     frameHandler().headers(false, false, 3, 0, grpcResponseHeaders(), HeadersMode.HTTP_20_HEADERS);
     Buffer buffer = createMessageFrame(fakeMessage);
     long messageFrameLength = buffer.size();
-    frameHandler().data(false, 3, buffer, (int) messageFrameLength);
+    frameHandler().data(false, 3, buffer, (int) messageFrameLength,
+        (int) messageFrameLength);
     ArgumentCaptor<Integer> idCaptor = ArgumentCaptor.forClass(Integer.class);
     verify(frameWriter, timeout(TIME_OUT_MS)).windowUpdate(
         idCaptor.capture(), eq(messageFrameLength));
@@ -593,33 +959,39 @@ public void windowUpdateWithInboundFlowControl() throws Exception {
     shutdownAndVerify();
   }
 
+  /**
+   * Outbound flow control where the initial flow control window stays at the default size of 65535.
+   */
   @Test
   public void outboundFlowControl() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
+
+    // Outbound window always starts at 65535 until changed by Settings.INITIAL_WINDOW_SIZE
+    int initialOutboundWindowSize = 65535;
+    int messageLength = initialOutboundWindowSize / 2 + 1;
+
     // The first message should be sent out.
-    int messageLength = Utils.DEFAULT_WINDOW_SIZE / 2 + 1;
     InputStream input = new ByteArrayInputStream(new byte[messageLength]);
     stream.writeMessage(input);
     stream.flush();
     verify(frameWriter, timeout(TIME_OUT_MS)).data(
         eq(false), eq(3), any(Buffer.class), eq(messageLength + HEADER_LENGTH));
 
-
     // The second message should be partially sent out.
     input = new ByteArrayInputStream(new byte[messageLength]);
     stream.writeMessage(input);
     stream.flush();
-    int partiallySentSize =
-        Utils.DEFAULT_WINDOW_SIZE - messageLength - HEADER_LENGTH;
+    int partiallySentSize = initialOutboundWindowSize - messageLength - HEADER_LENGTH;
     verify(frameWriter, timeout(TIME_OUT_MS))
         .data(eq(false), eq(3), any(Buffer.class), eq(partiallySentSize));
 
-    // Get more credit, the rest data should be sent out.
-    frameHandler().windowUpdate(3, Utils.DEFAULT_WINDOW_SIZE);
-    frameHandler().windowUpdate(0, Utils.DEFAULT_WINDOW_SIZE);
+    // Get more credit so the rest of the data should be sent out.
+    frameHandler().windowUpdate(3, initialOutboundWindowSize);
+    frameHandler().windowUpdate(0, initialOutboundWindowSize);
     verify(frameWriter, timeout(TIME_OUT_MS)).data(
         eq(false), eq(3), any(Buffer.class),
         eq(messageLength + HEADER_LENGTH - partiallySentSize));
@@ -629,11 +1001,98 @@ public void outboundFlowControl() throws Exception {
     shutdownAndVerify();
   }
 
+  /**
+   * Outbound flow control where the initial window size is reduced before a stream is started.
+   */
+  @Test
+  public void outboundFlowControl_smallWindowSize() throws Exception {
+    initTransport();
+
+    int initialOutboundWindowSize = 100;
+    setInitialWindowSize(initialOutboundWindowSize);
+
+    MockStreamListener listener = new MockStreamListener();
+    ClientStream stream =
+            clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream.start(listener);
+
+    int messageLength = 75;
+    // The first message should be sent out.
+    InputStream input = new ByteArrayInputStream(new byte[messageLength]);
+    stream.writeMessage(input);
+    stream.flush();
+    verify(frameWriter, timeout(TIME_OUT_MS)).data(
+            eq(false), eq(3), any(Buffer.class), eq(messageLength + HEADER_LENGTH));
+
+    // The second message should be partially sent out.
+    input = new ByteArrayInputStream(new byte[messageLength]);
+    stream.writeMessage(input);
+    stream.flush();
+    int partiallySentSize = initialOutboundWindowSize - messageLength - HEADER_LENGTH;
+    verify(frameWriter, timeout(TIME_OUT_MS))
+            .data(eq(false), eq(3), any(Buffer.class), eq(partiallySentSize));
+
+    // Get more credit so the rest of the data should be sent out.
+    frameHandler().windowUpdate(3, initialOutboundWindowSize);
+    verify(frameWriter, timeout(TIME_OUT_MS)).data(
+            eq(false), eq(3), any(Buffer.class),
+            eq(messageLength + HEADER_LENGTH - partiallySentSize));
+
+    stream.cancel(Status.CANCELLED);
+    listener.waitUntilStreamClosed();
+    shutdownAndVerify();
+  }
+
+  /**
+   * Outbound flow control where the initial window size is increased before a stream is started.
+   */
+  @Test
+  public void outboundFlowControl_bigWindowSize() throws Exception {
+    initTransport();
+
+    int initialOutboundWindowSize = 131070; // 65535 * 2
+    setInitialWindowSize(initialOutboundWindowSize);
+    frameHandler().windowUpdate(0, 65535);
+
+    MockStreamListener listener = new MockStreamListener();
+    ClientStream stream =
+            clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream.start(listener);
+
+    int messageLength = 100000;
+    // The first message should be sent out.
+    InputStream input = new ByteArrayInputStream(new byte[messageLength]);
+    stream.writeMessage(input);
+    stream.flush();
+    verify(frameWriter, timeout(TIME_OUT_MS)).data(
+            eq(false), eq(3), any(Buffer.class), eq(messageLength + HEADER_LENGTH));
+
+    // The second message should be partially sent out.
+    input = new ByteArrayInputStream(new byte[messageLength]);
+    stream.writeMessage(input);
+    stream.flush();
+    int partiallySentSize = initialOutboundWindowSize - messageLength - HEADER_LENGTH;
+    verify(frameWriter, timeout(TIME_OUT_MS))
+            .data(eq(false), eq(3), any(Buffer.class), eq(partiallySentSize));
+
+    // Get more credit so the rest of the data should be sent out.
+    frameHandler().windowUpdate(0, initialOutboundWindowSize);
+    frameHandler().windowUpdate(3, initialOutboundWindowSize);
+    verify(frameWriter, timeout(TIME_OUT_MS)).data(
+            eq(false), eq(3), any(Buffer.class),
+            eq(messageLength + HEADER_LENGTH - partiallySentSize));
+
+    stream.cancel(Status.CANCELLED);
+    listener.waitUntilStreamClosed();
+    shutdownAndVerify();
+  }
+
   @Test
   public void outboundFlowControlWithInitialWindowSizeChange() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     int messageLength = 20;
     setInitialWindowSize(HEADER_LENGTH + 10);
@@ -674,20 +1133,57 @@ public void outboundFlowControlWithInitialWindowSizeChange() throws Exception {
     shutdownAndVerify();
   }
 
+  @Test
+  public void outboundFlowControlWithInitialWindowSizeChangeInMiddleOfStream() throws Exception {
+    initTransport();
+    MockStreamListener listener = new MockStreamListener();
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream.start(listener);
+    int messageLength = 20;
+    setInitialWindowSize(HEADER_LENGTH + 10);
+    InputStream input = new ByteArrayInputStream(new byte[messageLength]);
+    stream.writeMessage(input);
+    stream.flush();
+    // part of the message can be sent.
+    verify(frameWriter, timeout(TIME_OUT_MS))
+        .data(eq(false), eq(3), any(Buffer.class), eq(HEADER_LENGTH + 10));
+    // Avoid connection flow control.
+    frameHandler().windowUpdate(0, HEADER_LENGTH + 20);
+
+    // Increase initial window size
+    setInitialWindowSize(HEADER_LENGTH + 20);
+
+    // wait until pending frames sent (inOrder doesn't support timeout)
+    verify(frameWriter, timeout(TIME_OUT_MS).atLeastOnce())
+        .data(eq(false), eq(3), any(Buffer.class), eq(10));
+    // It should ack the settings, then send remaining message.
+    InOrder inOrder = inOrder(frameWriter);
+    inOrder.verify(frameWriter).ackSettings(any(Settings.class));
+    inOrder.verify(frameWriter).data(eq(false), eq(3), any(Buffer.class), eq(10));
+
+    stream.cancel(Status.CANCELLED);
+    listener.waitUntilStreamClosed();
+    shutdownAndVerify();
+  }
+
   @Test
   public void stopNormally() throws Exception {
     initTransport();
     MockStreamListener listener1 = new MockStreamListener();
     MockStreamListener listener2 = new MockStreamListener();
-    OkHttpClientStream stream1 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream1.start(listener1);
-    OkHttpClientStream stream2 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
     assertEquals(2, activeStreamCount());
-    clientTransport.shutdown();
+    clientTransport.shutdown(SHUTDOWN_REASON);
 
     assertEquals(2, activeStreamCount());
-    verify(transportListener).transportShutdown(isA(Status.class));
+    verify(transportListener).transportShutdown(same(SHUTDOWN_REASON),
+        eq(SimpleDisconnectError.SUBCHANNEL_SHUTDOWN));
 
     stream1.cancel(Status.CANCELLED);
     stream2.cancel(Status.CANCELLED);
@@ -707,19 +1203,22 @@ public void receiveGoAway() throws Exception {
     // start 2 streams.
     MockStreamListener listener1 = new MockStreamListener();
     MockStreamListener listener2 = new MockStreamListener();
-    OkHttpClientStream stream1 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream1.start(listener1);
     stream1.request(1);
-    OkHttpClientStream stream2 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
     stream2.request(1);
     assertEquals(2, activeStreamCount());
 
     // Receive goAway, max good id is 3.
-    frameHandler().goAway(3, ErrorCode.CANCEL, null);
+    frameHandler().goAway(3, ErrorCode.CANCEL, ByteString.EMPTY);
 
     // Transport should be in STOPPING state.
-    verify(transportListener).transportShutdown(isA(Status.class));
+    verify(transportListener).transportShutdown(isA(Status.class),
+        any(DisconnectError.class));
     verify(transportListener, never()).transportTerminated();
 
     // Stream 2 should be closed.
@@ -732,23 +1231,22 @@ public void receiveGoAway() throws Exception {
 
     // But stream 1 should be able to send.
     final String sentMessage = "Should I also go away?";
-    OkHttpClientStream stream = getStream(3);
+    ClientStream stream = getStream(3);
     InputStream input = new ByteArrayInputStream(sentMessage.getBytes(UTF_8));
     assertEquals(22, input.available());
     stream.writeMessage(input);
     stream.flush();
-    ArgumentCaptor<Buffer> captor =
-        ArgumentCaptor.forClass(Buffer.class);
     verify(frameWriter, timeout(TIME_OUT_MS))
-        .data(eq(false), eq(3), captor.capture(), eq(22 + HEADER_LENGTH));
-    Buffer sentFrame = captor.getValue();
+        .data(eq(false), eq(3), any(Buffer.class), eq(22 + HEADER_LENGTH));
+    Buffer sentFrame = capturedBuffer.poll();
     assertEquals(createMessageFrame(sentMessage), sentFrame);
 
     // And read.
     frameHandler().headers(false, false, 3, 0, grpcResponseHeaders(), HeadersMode.HTTP_20_HEADERS);
     final String receivedMessage = "No, you are fine.";
     Buffer buffer = createMessageFrame(receivedMessage);
-    frameHandler().data(false, 3, buffer, (int) buffer.size());
+    frameHandler().data(false, 3, buffer, (int) buffer.size(),
+        (int) buffer.size());
     frameHandler().headers(true, true, 3, 0, grpcResponseTrailers(), HeadersMode.HTTP_20_HEADERS);
     listener1.waitUntilStreamClosed();
     assertEquals(1, listener1.messages.size());
@@ -765,7 +1263,8 @@ public void streamIdExhausted() throws Exception {
     initTransport(startId);
 
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
 
@@ -778,18 +1277,19 @@ public void streamIdExhausted() throws Exception {
     assertNotNull(listener.headers);
     String message = "hello";
     Buffer buffer = createMessageFrame(message);
-    frameHandler().data(false, startId, buffer, (int) buffer.size());
+    frameHandler().data(false, startId, buffer, (int) buffer.size(), (int) buffer.size());
 
     getStream(startId).cancel(Status.CANCELLED);
     // Receives the second message after be cancelled.
     buffer = createMessageFrame(message);
-    frameHandler().data(false, startId, buffer, (int) buffer.size());
+    frameHandler().data(false, startId, buffer, (int) buffer.size(), (int) buffer.size());
 
     listener.waitUntilStreamClosed();
     // Should only have the first message delivered.
     assertEquals(message, listener.messages.get(0));
     verify(frameWriter, timeout(TIME_OUT_MS)).rstStream(eq(startId), eq(ErrorCode.CANCEL));
-    verify(transportListener).transportShutdown(isA(Status.class));
+    verify(transportListener).transportShutdown(isA(Status.class),
+        any(DisconnectError.class));
     verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
     shutdownAndVerify();
   }
@@ -800,10 +1300,12 @@ public void pendingStreamSucceed() throws Exception {
     setMaxConcurrentStreams(1);
     final MockStreamListener listener1 = new MockStreamListener();
     final MockStreamListener listener2 = new MockStreamListener();
-    OkHttpClientStream stream1 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream1.start(listener1);
     // The second stream should be pending.
-    OkHttpClientStream stream2 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
     String sentMessage = "hello";
     InputStream input = new ByteArrayInputStream(sentMessage.getBytes(UTF_8));
@@ -822,13 +1324,11 @@ public void pendingStreamSucceed() throws Exception {
     // The second stream should be active now, and the pending data should be sent out.
     assertEquals(1, activeStreamCount());
     assertEquals(0, clientTransport.getPendingStreamSize());
-    ArgumentCaptor<Buffer> captor = ArgumentCaptor.forClass(Buffer.class);
     verify(frameWriter, timeout(TIME_OUT_MS))
-        .data(eq(false), eq(5), captor.capture(), eq(5 + HEADER_LENGTH));
-    Buffer sentFrame = captor.getValue();
+        .data(eq(true), eq(5), any(Buffer.class), eq(5 + HEADER_LENGTH));
+    Buffer sentFrame = capturedBuffer.poll();
     assertEquals(createMessageFrame(sentMessage), sentFrame);
-    verify(frameWriter, timeout(TIME_OUT_MS)).data(eq(true), eq(5), any(Buffer.class), eq(0));
-    stream2.sendCancel(Status.CANCELLED);
+    stream2.cancel(Status.CANCELLED);
     shutdownAndVerify();
   }
 
@@ -837,12 +1337,13 @@ public void pendingStreamCancelled() throws Exception {
     initTransport();
     setMaxConcurrentStreams(0);
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     waitForStreamPending(1);
-    stream.sendCancel(Status.CANCELLED);
+    stream.cancel(Status.CANCELLED);
     // The second cancel should be an no-op.
-    stream.sendCancel(Status.UNKNOWN);
+    stream.cancel(Status.UNKNOWN);
     listener.waitUntilStreamClosed();
     assertEquals(0, clientTransport.getPendingStreamSize());
     assertEquals(Status.CANCELLED.getCode(), listener.status.getCode());
@@ -855,17 +1356,19 @@ public void pendingStreamFailedByGoAway() throws Exception {
     setMaxConcurrentStreams(1);
     final MockStreamListener listener1 = new MockStreamListener();
     final MockStreamListener listener2 = new MockStreamListener();
-    OkHttpClientStream stream1 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream1.start(listener1);
     // The second stream should be pending.
-    OkHttpClientStream stream2 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
 
     waitForStreamPending(1);
     assertEquals(1, activeStreamCount());
 
     // Receives GO_AWAY.
-    frameHandler().goAway(99, ErrorCode.CANCEL, null);
+    frameHandler().goAway(99, ErrorCode.CANCEL, ByteString.EMPTY);
 
     listener2.waitUntilStreamClosed();
     assertEquals(Status.CANCELLED.getCode(), listener2.status.getCode());
@@ -873,7 +1376,7 @@ public void pendingStreamFailedByGoAway() throws Exception {
 
     // active stream should not be affected.
     assertEquals(1, activeStreamCount());
-    getStream(3).sendCancel(Status.CANCELLED);
+    getStream(3).cancel(Status.CANCELLED);
     shutdownAndVerify();
   }
 
@@ -883,16 +1386,17 @@ public void pendingStreamSucceedAfterShutdown() throws Exception {
     setMaxConcurrentStreams(0);
     final MockStreamListener listener = new MockStreamListener();
     // The second stream should be pending.
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     waitForStreamPending(1);
 
-    clientTransport.shutdown();
+    clientTransport.shutdown(SHUTDOWN_REASON);
     setMaxConcurrentStreams(1);
     verify(frameWriter, timeout(TIME_OUT_MS))
         .synStream(anyBoolean(), anyBoolean(), eq(3), anyInt(), anyListHeader());
     assertEquals(1, activeStreamCount());
-    stream.sendCancel(Status.CANCELLED);
+    stream.cancel(Status.CANCELLED);
     shutdownAndVerify();
   }
 
@@ -906,13 +1410,16 @@ public void pendingStreamFailedByIdExhausted() throws Exception {
     final MockStreamListener listener2 = new MockStreamListener();
     final MockStreamListener listener3 = new MockStreamListener();
 
-    OkHttpClientStream stream1 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream1.start(listener1);
 
     // The second and third stream should be pending.
-    OkHttpClientStream stream2 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream2.start(listener2);
-    OkHttpClientStream stream3 = clientTransport.newStream(method, new Metadata());
+    ClientStream stream3 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream3.start(listener3);
 
     waitForStreamPending(2);
@@ -935,17 +1442,18 @@ public void pendingStreamFailedByIdExhausted() throws Exception {
   public void receivingWindowExceeded() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
 
     frameHandler().headers(false, false, 3, 0, grpcResponseHeaders(), HeadersMode.HTTP_20_HEADERS);
 
-    int messageLength = Utils.DEFAULT_WINDOW_SIZE + 1;
+    int messageLength = INITIAL_WINDOW_SIZE + 1;
     byte[] fakeMessage = new byte[messageLength];
     Buffer buffer = createMessageFrame(fakeMessage);
     int messageFrameLength = (int) buffer.size();
-    frameHandler().data(false, 3, buffer, messageFrameLength);
+    frameHandler().data(false, 3, buffer, messageFrameLength, messageFrameLength);
 
     listener.waitUntilStreamClosed();
     assertEquals(Status.INTERNAL.getCode(), listener.status.getCode());
@@ -986,10 +1494,11 @@ public void duplexStreamingHeadersShouldNotBeFlushed() throws Exception {
   private void shouldHeadersBeFlushed(boolean shouldBeFlushed) throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     verify(frameWriter, timeout(TIME_OUT_MS)).synStream(
-        eq(false), eq(false), eq(3), eq(0), Matchers.anyListOf(Header.class));
+        eq(false), eq(false), eq(3), eq(0), ArgumentMatchers.<Header>anyList());
     if (shouldBeFlushed) {
       verify(frameWriter, timeout(TIME_OUT_MS)).flush();
     } else {
@@ -1002,11 +1511,13 @@ private void shouldHeadersBeFlushed(boolean shouldBeFlushed) throws Exception {
   public void receiveDataWithoutHeader() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
     Buffer buffer = createMessageFrame(new byte[1]);
-    frameHandler().data(false, 3, buffer, (int) buffer.size());
+    frameHandler().data(false, 3, buffer, (int) buffer.size(),
+        (int) buffer.size());
 
     // Trigger the failure by a trailer.
     frameHandler().headers(
@@ -1014,7 +1525,7 @@ public void receiveDataWithoutHeader() throws Exception {
 
     listener.waitUntilStreamClosed();
     assertEquals(Status.INTERNAL.getCode(), listener.status.getCode());
-    assertTrue(listener.status.getDescription().startsWith("no headers received prior to data"));
+    assertTrue(listener.status.getDescription().startsWith("headers not received before payload"));
     assertEquals(0, listener.messages.size());
     shutdownAndVerify();
   }
@@ -1023,19 +1534,22 @@ public void receiveDataWithoutHeader() throws Exception {
   public void receiveDataWithoutHeaderAndTrailer() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
     Buffer buffer = createMessageFrame(new byte[1]);
-    frameHandler().data(false, 3, buffer, (int) buffer.size());
+    frameHandler().data(false, 3, buffer, (int) buffer.size(),
+        (int) buffer.size());
 
     // Trigger the failure by a data frame.
     buffer = createMessageFrame(new byte[1]);
-    frameHandler().data(true, 3, buffer, (int) buffer.size());
+    frameHandler().data(true, 3, buffer, (int) buffer.size(),
+        (int) buffer.size());
 
     listener.waitUntilStreamClosed();
     assertEquals(Status.INTERNAL.getCode(), listener.status.getCode());
-    assertTrue(listener.status.getDescription().startsWith("no headers received prior to data"));
+    assertTrue(listener.status.getDescription().startsWith("headers not received before payload"));
     assertEquals(0, listener.messages.size());
     shutdownAndVerify();
   }
@@ -1044,18 +1558,20 @@ public void receiveDataWithoutHeaderAndTrailer() throws Exception {
   public void receiveLongEnoughDataWithoutHeaderAndTrailer() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.request(1);
     Buffer buffer = createMessageFrame(new byte[1000]);
-    frameHandler().data(false, 3, buffer, (int) buffer.size());
+    frameHandler().data(false, 3, buffer, (int) buffer.size(),
+        (int) buffer.size());
 
     // Once we receive enough detail, we cancel the stream. so we should have sent cancel.
     verify(frameWriter, timeout(TIME_OUT_MS)).rstStream(eq(3), eq(ErrorCode.CANCEL));
 
     listener.waitUntilStreamClosed();
     assertEquals(Status.INTERNAL.getCode(), listener.status.getCode());
-    assertTrue(listener.status.getDescription().startsWith("no headers received prior to data"));
+    assertTrue(listener.status.getDescription().startsWith("headers not received before payload"));
     assertEquals(0, listener.messages.size());
     shutdownAndVerify();
   }
@@ -1064,24 +1580,28 @@ public void receiveLongEnoughDataWithoutHeaderAndTrailer() throws Exception {
   public void receiveDataForUnknownStreamUpdateConnectionWindow() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.cancel(Status.CANCELLED);
 
     Buffer buffer = createMessageFrame(
-        new byte[Utils.DEFAULT_WINDOW_SIZE / 2 + 1]);
-    frameHandler().data(false, 3, buffer, (int) buffer.size());
+        new byte[INITIAL_WINDOW_SIZE / 2 + 1]);
+    frameHandler().data(false, 3, buffer, (int) buffer.size(),
+        (int) buffer.size());
     // Should still update the connection window even stream 3 is gone.
     verify(frameWriter, timeout(TIME_OUT_MS)).windowUpdate(0,
-        HEADER_LENGTH + Utils.DEFAULT_WINDOW_SIZE / 2 + 1);
+        HEADER_LENGTH + INITIAL_WINDOW_SIZE / 2 + 1);
     buffer = createMessageFrame(
-        new byte[Utils.DEFAULT_WINDOW_SIZE / 2 + 1]);
+        new byte[INITIAL_WINDOW_SIZE / 2 + 1]);
 
     // This should kill the connection, since we never created stream 5.
-    frameHandler().data(false, 5, buffer, (int) buffer.size());
+    frameHandler().data(false, 5, buffer, (int) buffer.size(),
+        (int) buffer.size());
     verify(frameWriter, timeout(TIME_OUT_MS))
         .goAway(eq(0), eq(ErrorCode.PROTOCOL_ERROR), any(byte[].class));
-    verify(transportListener).transportShutdown(isA(Status.class));
+    verify(transportListener).transportShutdown(isA(Status.class),
+        any(DisconnectError.class));
     verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
     shutdownAndVerify();
   }
@@ -1090,7 +1610,8 @@ public void receiveDataForUnknownStreamUpdateConnectionWindow() throws Exception
   public void receiveWindowUpdateForUnknownStream() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     stream.cancel(Status.CANCELLED);
     // This should be ignored.
@@ -1100,7 +1621,8 @@ public void receiveWindowUpdateForUnknownStream() throws Exception {
     frameHandler().windowUpdate(5, 73);
     verify(frameWriter, timeout(TIME_OUT_MS))
         .goAway(eq(0), eq(ErrorCode.PROTOCOL_ERROR), any(byte[].class));
-    verify(transportListener).transportShutdown(isA(Status.class));
+    verify(transportListener).transportShutdown(isA(Status.class),
+        any(DisconnectError.class));
     verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
     shutdownAndVerify();
   }
@@ -1109,7 +1631,8 @@ public void receiveWindowUpdateForUnknownStream() throws Exception {
   public void shouldBeInitiallyReady() throws Exception {
     initTransport();
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     assertTrue(stream.isReady());
     assertTrue(listener.isOnReadyCalled());
@@ -1122,10 +1645,12 @@ public void shouldBeInitiallyReady() throws Exception {
   public void notifyOnReady() throws Exception {
     initTransport();
     // exactly one byte below the threshold
-    int messageLength = AbstractStream.DEFAULT_ONREADY_THRESHOLD - HEADER_LENGTH - 1;
+    int messageLength =
+        AbstractStream.TransportState.DEFAULT_ONREADY_THRESHOLD - HEADER_LENGTH - 1;
     setInitialWindowSize(0);
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     assertTrue(stream.isReady());
     // Be notified at the beginning.
@@ -1166,7 +1691,7 @@ public void notifyOnReady() throws Exception {
   @Test
   public void transportReady() throws Exception {
     initTransport();
-    verifyZeroInteractions(transportListener);
+    verifyNoInteractions(transportListener);
     frameHandler().settings(false, new Settings());
     verify(transportListener).transportReady();
     shutdownAndVerify();
@@ -1177,9 +1702,11 @@ public void ping() throws Exception {
     initTransport();
     PingCallbackImpl callback1 = new PingCallbackImpl();
     clientTransport.ping(callback1, MoreExecutors.directExecutor());
+    assertEquals(1, getTransportStats(clientTransport).keepAlivesSent);
     // add'l ping will be added as listener to outstanding operation
     PingCallbackImpl callback2 = new PingCallbackImpl();
     clientTransport.ping(callback2, MoreExecutors.directExecutor());
+    assertEquals(1, getTransportStats(clientTransport).keepAlivesSent);
 
     ArgumentCaptor<Integer> captor1 = ArgumentCaptor.forClass(int.class);
     ArgumentCaptor<Integer> captor2 = ArgumentCaptor.forClass(int.class);
@@ -1212,6 +1739,7 @@ public void ping() throws Exception {
     // now that previous ping is done, next request returns a different future
     callback1 = new PingCallbackImpl();
     clientTransport.ping(callback1, MoreExecutors.directExecutor());
+    assertEquals(2, getTransportStats(clientTransport).keepAlivesSent);
     assertEquals(0, callback1.invocationCount);
     shutdownAndVerify();
   }
@@ -1221,22 +1749,20 @@ public void ping_failsWhenTransportShutdown() throws Exception {
     initTransport();
     PingCallbackImpl callback = new PingCallbackImpl();
     clientTransport.ping(callback, MoreExecutors.directExecutor());
+    assertEquals(1, getTransportStats(clientTransport).keepAlivesSent);
     assertEquals(0, callback.invocationCount);
 
-    clientTransport.shutdown();
+    clientTransport.shutdown(SHUTDOWN_REASON);
     // ping failed on channel shutdown
     assertEquals(1, callback.invocationCount);
-    assertTrue(callback.failureCause instanceof StatusException);
-    assertEquals(Status.Code.UNAVAILABLE,
-        ((StatusException) callback.failureCause).getStatus().getCode());
+    assertSame(SHUTDOWN_REASON, callback.failureCause);
 
     // now that handler is in terminal state, all future pings fail immediately
     callback = new PingCallbackImpl();
     clientTransport.ping(callback, MoreExecutors.directExecutor());
+    assertEquals(1, getTransportStats(clientTransport).keepAlivesSent);
     assertEquals(1, callback.invocationCount);
-    assertTrue(callback.failureCause instanceof StatusException);
-    assertEquals(Status.Code.UNAVAILABLE,
-        ((StatusException) callback.failureCause).getStatus().getCode());
+    assertSame(SHUTDOWN_REASON, callback.failureCause);
     shutdownAndVerify();
   }
 
@@ -1245,100 +1771,47 @@ public void ping_failsIfTransportFails() throws Exception {
     initTransport();
     PingCallbackImpl callback = new PingCallbackImpl();
     clientTransport.ping(callback, MoreExecutors.directExecutor());
+    assertEquals(1, getTransportStats(clientTransport).keepAlivesSent);
     assertEquals(0, callback.invocationCount);
 
     clientTransport.onException(new IOException());
     // ping failed on error
     assertEquals(1, callback.invocationCount);
-    assertTrue(callback.failureCause instanceof StatusException);
-    assertEquals(Status.Code.UNAVAILABLE,
-        ((StatusException) callback.failureCause).getStatus().getCode());
+    assertEquals(Status.Code.UNAVAILABLE, callback.failureCause.getCode());
 
     // now that handler is in terminal state, all future pings fail immediately
     callback = new PingCallbackImpl();
     clientTransport.ping(callback, MoreExecutors.directExecutor());
+    assertEquals(1, getTransportStats(clientTransport).keepAlivesSent);
     assertEquals(1, callback.invocationCount);
-    assertTrue(callback.failureCause instanceof StatusException);
-    assertEquals(Status.Code.UNAVAILABLE,
-        ((StatusException) callback.failureCause).getStatus().getCode());
-    shutdownAndVerify();
-  }
-
-  @Test
-  public void writeBeforeConnected() throws Exception {
-    initTransportAndDelayConnected();
-    final String message = "Hello Server";
-    MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
-    stream.start(listener);
-    InputStream input = new ByteArrayInputStream(message.getBytes(UTF_8));
-    stream.writeMessage(input);
-    stream.flush();
-    // The message should be queued.
-    verifyNoMoreInteractions(frameWriter);
-
-    allowTransportConnected();
-
-    // The queued message should be sent out.
-    ArgumentCaptor<Buffer> captor = ArgumentCaptor.forClass(Buffer.class);
-    verify(frameWriter, timeout(TIME_OUT_MS))
-        .data(eq(false), eq(3), captor.capture(), eq(12 + HEADER_LENGTH));
-    Buffer sentFrame = captor.getValue();
-    assertEquals(createMessageFrame(message), sentFrame);
-    stream.cancel(Status.CANCELLED);
-    shutdownAndVerify();
-  }
-
-  @Test
-  public void cancelBeforeConnected() throws Exception {
-    initTransportAndDelayConnected();
-    final String message = "Hello Server";
-    MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
-    stream.start(listener);
-    InputStream input = new ByteArrayInputStream(message.getBytes(UTF_8));
-    stream.writeMessage(input);
-    stream.flush();
-    stream.cancel(Status.CANCELLED);
-    verifyNoMoreInteractions(frameWriter);
-
-    allowTransportConnected();
-    verifyNoMoreInteractions(frameWriter);
+    assertEquals(Status.Code.UNAVAILABLE, callback.failureCause.getCode());
     shutdownAndVerify();
   }
 
   @Test
   public void shutdownDuringConnecting() throws Exception {
-    initTransportAndDelayConnected();
-    MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
-    stream.start(listener);
-    clientTransport.shutdown();
-    allowTransportConnected();
-
-    // The new stream should be failed, but not the pending stream.
-    assertNewStreamFail();
-    verify(frameWriter, timeout(TIME_OUT_MS))
-        .synStream(anyBoolean(), anyBoolean(), eq(3), anyInt(), anyListHeader());
-    assertEquals(1, activeStreamCount());
-    stream.cancel(Status.CANCELLED);
-    listener.waitUntilStreamClosed();
-    assertEquals(Status.CANCELLED.getCode(), listener.status.getCode());
+    SettableFuture<Void> delayed = SettableFuture.create();
+    Runnable connectingCallback = () -> Futures.getUnchecked(delayed);
+    startTransport(
+        DEFAULT_START_STREAM_ID,
+        connectingCallback,
+        false,
+        null, null);
+    clientTransport.shutdown(SHUTDOWN_REASON);
+    delayed.set(null);
     shutdownAndVerify();
   }
 
   @Test
   public void invalidAuthorityPropagates() {
     clientTransport = new OkHttpClientTransport(
-        new InetSocketAddress("host", 1234),
+        channelBuilder.buildTransportFactory(),
+        new InetSocketAddress("localhost", 1234),
         "invalid_authority",
         "userAgent",
-        executor,
-        null,
-        ConnectionSpec.CLEARTEXT,
-        DEFAULT_MAX_MESSAGE_SIZE,
-        null,
-        null,
+        EAG_ATTRS,
+        NO_PROXY,
+        tooManyPingsRunnable,
         null);
 
     String host = clientTransport.getOverridenHost();
@@ -1351,44 +1824,72 @@ public void invalidAuthorityPropagates() {
   @Test
   public void unreachableServer() throws Exception {
     clientTransport = new OkHttpClientTransport(
+        channelBuilder.buildTransportFactory(),
         new InetSocketAddress("localhost", 0),
         "authority",
         "userAgent",
-        executor,
-        null,
-        ConnectionSpec.CLEARTEXT,
-        DEFAULT_MAX_MESSAGE_SIZE,
-        null,
-        null,
+        EAG_ATTRS,
+        NO_PROXY,
+        tooManyPingsRunnable,
         null);
 
     ManagedClientTransport.Listener listener = mock(ManagedClientTransport.Listener.class);
     clientTransport.start(listener);
-    ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
-    verify(listener, timeout(TIME_OUT_MS)).transportShutdown(captor.capture());
-    Status status = captor.getValue();
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(listener, timeout(TIME_OUT_MS)).transportShutdown(statusCaptor.capture(),
+        eq(new GoAwayDisconnectError(GrpcUtil.Http2Error.INTERNAL_ERROR)));
+    Status status = statusCaptor.getValue();
     assertEquals(Status.UNAVAILABLE.getCode(), status.getCode());
     assertTrue(status.getCause().toString(), status.getCause() instanceof IOException);
 
     MockStreamListener streamListener = new MockStreamListener();
-    clientTransport.newStream(method, new Metadata()).start(streamListener);
+    clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers)
+        .start(streamListener);
     streamListener.waitUntilStreamClosed();
     assertEquals(Status.UNAVAILABLE.getCode(), streamListener.status.getCode());
   }
 
   @Test
-  public void proxy_200() throws Exception {
-    ServerSocket serverSocket = new ServerSocket(0);
-    clientTransport = new OkHttpClientTransport(
-        InetSocketAddress.createUnresolved("theservice", 80),
-        "authority",
-        "userAgent",
-        executor,
-        null,
-        ConnectionSpec.CLEARTEXT,
-        DEFAULT_MAX_MESSAGE_SIZE,
-        (InetSocketAddress) serverSocket.getLocalSocketAddress(),
-        null,
+  public void customSocketFactory() throws Exception {
+    RuntimeException exception = new RuntimeException("thrown by socket factory");
+    SocketFactory socketFactory = new RuntimeExceptionThrowingSocketFactory(exception);
+
+    clientTransport =
+        new OkHttpClientTransport(
+            channelBuilder.socketFactory(socketFactory).buildTransportFactory(),
+            new InetSocketAddress("localhost", 0),
+            "authority",
+            "userAgent",
+            EAG_ATTRS,
+            NO_PROXY,
+            tooManyPingsRunnable,
+            null);
+
+    ManagedClientTransport.Listener listener = mock(ManagedClientTransport.Listener.class);
+    clientTransport.start(listener);
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(listener, timeout(TIME_OUT_MS)).transportShutdown(statusCaptor.capture(),
+        eq(new GoAwayDisconnectError(GrpcUtil.Http2Error.INTERNAL_ERROR)));
+    Status status = statusCaptor.getValue();
+    assertEquals(Status.UNAVAILABLE.getCode(), status.getCode());
+    assertSame(exception, status.getCause());
+  }
+
+  @Test
+  public void proxy_200() throws Exception {
+    ServerSocket serverSocket = new ServerSocket(0);
+    InetSocketAddress targetAddress = InetSocketAddress.createUnresolved("theservice", 80);
+    clientTransport = new OkHttpClientTransport(
+        channelBuilder.buildTransportFactory(),
+        targetAddress,
+        "authority",
+        "userAgent",
+        EAG_ATTRS,
+        HttpConnectProxiedSocketAddress.newBuilder()
+            .setTargetAddress(targetAddress)
+            .setProxyAddress(new InetSocketAddress("localhost", serverSocket.getLocalPort()))
+            .build(),
+        tooManyPingsRunnable,
         null);
     clientTransport.start(transportListener);
 
@@ -1418,7 +1919,8 @@ public void proxy_200() throws Exception {
     });
     sock.getOutputStream().flush();
 
-    verify(transportListener, timeout(TIME_OUT_MS)).transportShutdown(isA(Status.class));
+    verify(transportListener, timeout(TIME_OUT_MS)).transportShutdown(isA(Status.class),
+        any(DisconnectError.class));
     while (sock.getInputStream().read() != -1) {}
     verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
     sock.close();
@@ -1427,16 +1929,18 @@ public void proxy_200() throws Exception {
   @Test
   public void proxy_500() throws Exception {
     ServerSocket serverSocket = new ServerSocket(0);
+    InetSocketAddress targetAddress = InetSocketAddress.createUnresolved("theservice", 80);
     clientTransport = new OkHttpClientTransport(
-        InetSocketAddress.createUnresolved("theservice", 80),
+        channelBuilder.buildTransportFactory(),
+        targetAddress,
         "authority",
         "userAgent",
-        executor,
-        null,
-        ConnectionSpec.CLEARTEXT,
-        DEFAULT_MAX_MESSAGE_SIZE,
-        (InetSocketAddress) serverSocket.getLocalSocketAddress(),
-        null,
+        EAG_ATTRS,
+        HttpConnectProxiedSocketAddress.newBuilder()
+            .setTargetAddress(targetAddress)
+            .setProxyAddress(new InetSocketAddress("localhost", serverSocket.getLocalPort()))
+            .build(),
+        tooManyPingsRunnable,
         null);
     clientTransport.start(transportListener);
 
@@ -1456,17 +1960,18 @@ public void proxy_500() throws Exception {
 
     assertEquals(-1, sock.getInputStream().read());
 
-    ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
-    verify(transportListener, timeout(TIME_OUT_MS)).transportShutdown(captor.capture());
-    Status error = captor.getValue();
-    assertTrue("Status didn't contain error code: " + captor.getValue(),
-        error.getDescription().contains("500"));
-    assertTrue("Status didn't contain error description: " + captor.getValue(),
-        error.getDescription().contains("OH NO"));
-    assertTrue("Status didn't contain error text: " + captor.getValue(),
-        error.getDescription().contains(errorText));
-    assertEquals("Not UNAVAILABLE: " + captor.getValue(),
-        Status.UNAVAILABLE.getCode(), error.getCode());
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(transportListener, timeout(TIME_OUT_MS)).transportShutdown(statusCaptor.capture(),
+        eq(new GoAwayDisconnectError(GrpcUtil.Http2Error.INTERNAL_ERROR)));
+    Status status = statusCaptor.getValue();
+    assertTrue("Status didn't contain error code: " + statusCaptor.getValue(),
+        status.getDescription().contains("500"));
+    assertTrue("Status didn't contain error description: " + statusCaptor.getValue(),
+        status.getDescription().contains("OH NO"));
+    assertTrue("Status didn't contain error text: " + statusCaptor.getValue(),
+        status.getDescription().contains(errorText));
+    assertEquals("Not UNAVAILABLE: " + statusCaptor.getValue(),
+        Status.UNAVAILABLE.getCode(), status.getCode());
     sock.close();
     verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
   }
@@ -1474,16 +1979,18 @@ public void proxy_500() throws Exception {
   @Test
   public void proxy_immediateServerClose() throws Exception {
     ServerSocket serverSocket = new ServerSocket(0);
+    InetSocketAddress targetAddress = InetSocketAddress.createUnresolved("theservice", 80);
     clientTransport = new OkHttpClientTransport(
-        InetSocketAddress.createUnresolved("theservice", 80),
+        channelBuilder.buildTransportFactory(),
+        targetAddress,
         "authority",
         "userAgent",
-        executor,
-        null,
-        ConnectionSpec.CLEARTEXT,
-        DEFAULT_MAX_MESSAGE_SIZE,
-        (InetSocketAddress) serverSocket.getLocalSocketAddress(),
-        null,
+        EAG_ATTRS,
+        HttpConnectProxiedSocketAddress.newBuilder()
+            .setTargetAddress(targetAddress)
+            .setProxyAddress(new InetSocketAddress("localhost", serverSocket.getLocalPort()))
+            .build(),
+        tooManyPingsRunnable,
         null);
     clientTransport.start(transportListener);
 
@@ -1491,14 +1998,226 @@ public void proxy_immediateServerClose() throws Exception {
     serverSocket.close();
     sock.close();
 
-    ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
-    verify(transportListener, timeout(TIME_OUT_MS)).transportShutdown(captor.capture());
-    Status error = captor.getValue();
-    assertTrue("Status didn't contain proxy: " + captor.getValue(),
-        error.getDescription().contains("proxy"));
-    assertEquals("Not UNAVAILABLE: " + captor.getValue(),
-        Status.UNAVAILABLE.getCode(), error.getCode());
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(transportListener, timeout(TIME_OUT_MS)).transportShutdown(statusCaptor.capture(),
+        eq(new GoAwayDisconnectError(GrpcUtil.Http2Error.INTERNAL_ERROR)));
+    Status status = statusCaptor.getValue();
+    assertTrue("Status didn't contain proxy: " + statusCaptor.getValue(),
+        status.getDescription().contains("proxy"));
+    assertEquals("Not UNAVAILABLE: " + statusCaptor.getValue(),
+        Status.UNAVAILABLE.getCode(), status.getCode());
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+  }
+
+  @Test
+  public void proxy_serverHangs() throws Exception {
+    ServerSocket serverSocket = new ServerSocket(0);
+    InetSocketAddress targetAddress = InetSocketAddress.createUnresolved("theservice", 80);
+    clientTransport = new OkHttpClientTransport(
+        channelBuilder.buildTransportFactory(),
+        targetAddress,
+        "authority",
+        "userAgent",
+        EAG_ATTRS,
+        HttpConnectProxiedSocketAddress.newBuilder()
+            .setTargetAddress(targetAddress)
+            .setProxyAddress(new InetSocketAddress("localhost", serverSocket.getLocalPort()))
+            .build(),
+        tooManyPingsRunnable,
+        null);
+    clientTransport.proxySocketTimeout = 10;
+    clientTransport.start(transportListener);
+
+    Socket sock = serverSocket.accept();
+    serverSocket.close();
+
+    BufferedReader reader = new BufferedReader(new InputStreamReader(sock.getInputStream(), UTF_8));
+    assertEquals("CONNECT theservice:80 HTTP/1.1", reader.readLine());
+    assertEquals("Host: theservice:80", reader.readLine());
+    while (!"".equals(reader.readLine())) {}
+
+    verify(transportListener, timeout(200)).transportShutdown(any(Status.class),
+        any(DisconnectError.class));
     verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+    sock.close();
+  }
+
+  @Test
+  public void goAway_notUtf8() throws Exception {
+    initTransport();
+    // 0xFF is never permitted in UTF-8. 0xF0 should have 3 continuations following, and 0x0a isn't
+    // a continuation.
+    frameHandler().goAway(
+        0, ErrorCode.ENHANCE_YOUR_CALM, ByteString.of((byte) 0xFF, (byte) 0xF0, (byte) 0x0a));
+
+    shutdownAndVerify();
+  }
+
+  @Test
+  public void goAway_notTooManyPings() throws Exception {
+    final AtomicBoolean run = new AtomicBoolean();
+    tooManyPingsRunnable = new Runnable() {
+      @Override
+      public void run() {
+        run.set(true);
+      }
+    };
+    initTransport();
+    frameHandler().goAway(0, ErrorCode.ENHANCE_YOUR_CALM, ByteString.encodeUtf8("not_many_pings"));
+    assertFalse(run.get());
+
+    shutdownAndVerify();
+  }
+
+  @Test
+  public void goAway_tooManyPings() throws Exception {
+    final AtomicBoolean run = new AtomicBoolean();
+    tooManyPingsRunnable = new Runnable() {
+      @Override
+      public void run() {
+        run.set(true);
+      }
+    };
+    initTransport();
+    frameHandler().goAway(0, ErrorCode.ENHANCE_YOUR_CALM, ByteString.encodeUtf8("too_many_pings"));
+    assertTrue(run.get());
+
+    shutdownAndVerify();
+  }
+
+  @Test
+  public void goAway_streamListenerRpcProgress() throws Exception {
+    initTransport();
+    setMaxConcurrentStreams(2);
+    MockStreamListener listener1 = new MockStreamListener();
+    MockStreamListener listener2 = new MockStreamListener();
+    MockStreamListener listener3 = new MockStreamListener();
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream1.start(listener1);
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream2.start(listener2);
+    ClientStream stream3 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream3.start(listener3);
+    waitForStreamPending(1);
+
+    assertEquals(2, activeStreamCount());
+    assertContainStream(DEFAULT_START_STREAM_ID);
+    assertContainStream(DEFAULT_START_STREAM_ID + 2);
+
+    frameHandler()
+        .goAway(DEFAULT_START_STREAM_ID, ErrorCode.CANCEL, ByteString.encodeUtf8("blablabla"));
+
+    listener2.waitUntilStreamClosed();
+    listener3.waitUntilStreamClosed();
+    assertNull(listener1.rpcProgress);
+    assertEquals(REFUSED, listener2.rpcProgress);
+    assertEquals(MISCARRIED, listener3.rpcProgress);
+    assertEquals(1, activeStreamCount());
+    assertContainStream(DEFAULT_START_STREAM_ID);
+
+    getStream(DEFAULT_START_STREAM_ID).cancel(Status.CANCELLED);
+
+    listener1.waitUntilStreamClosed();
+    assertEquals(PROCESSED, listener1.rpcProgress);
+
+    shutdownAndVerify();
+  }
+
+  @Test
+  public void reset_streamListenerRpcProgress() throws Exception {
+    initTransport();
+    MockStreamListener listener1 = new MockStreamListener();
+    MockStreamListener listener2 = new MockStreamListener();
+    MockStreamListener listener3 = new MockStreamListener();
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream1.start(listener1);
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream2.start(listener2);
+    ClientStream stream3 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream3.start(listener3);
+
+    assertEquals(3, activeStreamCount());
+    assertContainStream(DEFAULT_START_STREAM_ID);
+    assertContainStream(DEFAULT_START_STREAM_ID + 2);
+    assertContainStream(DEFAULT_START_STREAM_ID + 4);
+
+    frameHandler().rstStream(DEFAULT_START_STREAM_ID + 2, ErrorCode.REFUSED_STREAM);
+
+    listener2.waitUntilStreamClosed();
+    assertNull(listener1.rpcProgress);
+    assertEquals(REFUSED, listener2.rpcProgress);
+    assertNull(listener3.rpcProgress);
+
+    frameHandler().rstStream(DEFAULT_START_STREAM_ID, ErrorCode.CANCEL);
+    listener1.waitUntilStreamClosed();
+    assertEquals(PROCESSED, listener1.rpcProgress);
+    assertNull(listener3.rpcProgress);
+
+    getStream(DEFAULT_START_STREAM_ID + 4).cancel(Status.CANCELLED);
+
+    listener3.waitUntilStreamClosed();
+    assertEquals(PROCESSED, listener3.rpcProgress);
+
+    shutdownAndVerify();
+  }
+
+  @Test
+  public void shutdownNow_streamListenerRpcProgress() throws Exception {
+    initTransport();
+    setMaxConcurrentStreams(2);
+    MockStreamListener listener1 = new MockStreamListener();
+    MockStreamListener listener2 = new MockStreamListener();
+    MockStreamListener listener3 = new MockStreamListener();
+    ClientStream stream1 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream1.start(listener1);
+    ClientStream stream2 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream2.start(listener2);
+    ClientStream stream3 =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream3.start(listener3);
+    waitForStreamPending(1);
+
+    assertEquals(2, activeStreamCount());
+    assertContainStream(DEFAULT_START_STREAM_ID);
+    assertContainStream(DEFAULT_START_STREAM_ID + 2);
+
+    clientTransport.shutdownNow(Status.INTERNAL);
+
+    listener1.waitUntilStreamClosed();
+    listener2.waitUntilStreamClosed();
+    listener3.waitUntilStreamClosed();
+
+    assertEquals(PROCESSED, listener1.rpcProgress);
+    assertEquals(PROCESSED, listener2.rpcProgress);
+    assertEquals(MISCARRIED, listener3.rpcProgress);
+  }
+
+  @Test
+  public void finishedStreamRemovedFromInUseState() throws Exception {
+    initTransport();
+    setMaxConcurrentStreams(1);
+    final MockStreamListener listener = new MockStreamListener();
+    OkHttpClientStream stream = clientTransport.newStream(
+            method, new Metadata(), CallOptions.DEFAULT, tracers);
+    stream.start(listener);
+    OkHttpClientStream pendingStream = clientTransport.newStream(
+            method, new Metadata(), CallOptions.DEFAULT, tracers);
+    pendingStream.start(listener);
+    waitForStreamPending(1);
+    clientTransport.finishStream(stream.transportState().id(), Status.OK, PROCESSED,
+        false, null, null);
+    verify(transportListener).transportInUse(true);
+    clientTransport.finishStream(pendingStream.transportState().id(), Status.OK, PROCESSED,
+        false, null, null);
+    verify(transportListener).transportInUse(false);
   }
 
   private int activeStreamCount() {
@@ -1530,7 +2249,8 @@ private void waitForStreamPending(int expected) throws Exception {
 
   private void assertNewStreamFail() throws Exception {
     MockStreamListener listener = new MockStreamListener();
-    OkHttpClientStream stream = clientTransport.newStream(method, new Metadata());
+    ClientStream stream =
+        clientTransport.newStream(method, new Metadata(), CallOptions.DEFAULT, tracers);
     stream.start(listener);
     listener.waitUntilStreamClosed();
     assertFalse(listener.status.isOk());
@@ -1553,10 +2273,15 @@ private static Buffer createMessageFrame(String message) {
   }
 
   private static Buffer createMessageFrame(byte[] message) {
+    return createMessageFrame(message,0);
+  }
+
+  private static Buffer createMessageFrame(byte[] message, int paddingLength) {
     Buffer buffer = new Buffer();
     buffer.writeByte(0 /* UNCOMPRESSED */);
     buffer.writeInt(message.length);
     buffer.write(message);
+    buffer.write(new byte[paddingLength]);
     return buffer;
   }
 
@@ -1568,7 +2293,7 @@ private List<Header> grpcResponseHeaders() {
 
   private List<Header> grpcResponseTrailers() {
     return ImmutableList.of(
-        new Header(Status.CODE_KEY.name(), "0"),
+        new Header(InternalStatus.CODE_KEY.name(), "0"),
         // Adding Content-Type and :status for testing responses with only a single HEADERS frame.
         new Header(":status", "200"),
         CONTENT_TYPE_HEADER);
@@ -1587,7 +2312,7 @@ enum Result {
       THROW_ERROR
     }
 
-    final LinkedBlockingQueue<Result> nextResults = new LinkedBlockingQueue<Result>();
+    final LinkedBlockingQueue<Result> nextResults = new LinkedBlockingQueue<>();
 
     @Override
     public void close() throws IOException {
@@ -1605,8 +2330,10 @@ void assertClosed() {
       }
     }
 
+    // The wait is safe; nextFrame is called in a loop and can have spurious wakeups
+    @SuppressWarnings("WaitNotInLoop")
     @Override
-    public boolean nextFrame(Handler handler) throws IOException {
+    public boolean nextFrame(FrameReader.Handler handler) throws IOException {
       Result result;
       try {
         result = nextResults.take();
@@ -1648,8 +2375,9 @@ private static class MockStreamListener implements ClientStreamListener {
     Status status;
     Metadata headers;
     Metadata trailers;
+    RpcProgress rpcProgress;
     CountDownLatch closed = new CountDownLatch(1);
-    ArrayList<String> messages = new ArrayList<String>();
+    ArrayList<String> messages = new ArrayList<>();
     boolean onReadyCalled;
 
     MockStreamListener() {
@@ -1661,17 +2389,21 @@ public void headersRead(Metadata headers) {
     }
 
     @Override
-    public void messageRead(InputStream message) {
-      String msg = getContent(message);
-      if (msg != null) {
-        messages.add(msg);
+    public void messagesAvailable(MessageProducer producer) {
+      InputStream inputStream;
+      while ((inputStream = producer.next()) != null) {
+        String msg = getContent(inputStream);
+        if (msg != null) {
+          messages.add(msg);
+        }
       }
     }
 
     @Override
-    public void closed(Status status, Metadata trailers) {
+    public void closed(Status status, RpcProgress rpcProgress, Metadata trailers) {
       this.status = status;
       this.trailers = trailers;
+      this.rpcProgress = rpcProgress;
       closed.countDown();
     }
 
@@ -1692,6 +2424,7 @@ void waitUntilStreamClosed() throws InterruptedException {
       }
     }
 
+    @SuppressWarnings("Finally") // We don't care about suppressed exceptions in the test
     static String getContent(InputStream message) {
       BufferedReader br = new BufferedReader(new InputStreamReader(message, UTF_8));
       try {
@@ -1710,22 +2443,165 @@ static String getContent(InputStream message) {
   }
 
   private static class MockSocket extends Socket {
-    MockFrameReader frameReader;
+    final MockFrameReader frameReader;
+    private final PipedOutputStream outputStream = new PipedOutputStream();
+    private final PipedInputStream outputStreamSink = new PipedInputStream();
+    private final PipedOutputStream inputStreamSource = new PipedOutputStream();
+    private final PipedInputStream inputStream = new PipedInputStream();
 
     MockSocket(MockFrameReader frameReader) {
       this.frameReader = frameReader;
+      try {
+        outputStreamSink.connect(outputStream);
+        inputStream.connect(inputStreamSource);
+      } catch (IOException ex) {
+        throw new AssertionError(ex);
+      }
     }
 
     @Override
     public synchronized void close() {
       frameReader.nextFrameAtEndOfStream();
     }
+
+    @Override
+    public SocketAddress getLocalSocketAddress() {
+      return InetSocketAddress.createUnresolved("localhost", 4000);
+    }
+
+    @Override
+    public OutputStream getOutputStream() {
+      return outputStream;
+    }
+
+    @Override
+    public InputStream getInputStream() {
+      return inputStream;
+    }
+  }
+
+  private static class MockSslSocket extends SSLSocket {
+    private Socket delegate;
+
+    MockSslSocket(Socket socket) {
+      delegate = socket;
+    }
+
+    @Override
+    public String[] getSupportedCipherSuites() {
+      return new String[0];
+    }
+
+    @Override
+    public String[] getEnabledCipherSuites() {
+      return new String[0];
+    }
+
+    @Override
+    public void setEnabledCipherSuites(String[] suites) {
+
+    }
+
+    @Override
+    public String[] getSupportedProtocols() {
+      return new String[0];
+    }
+
+    @Override
+    public String[] getEnabledProtocols() {
+      return new String[0];
+    }
+
+    @Override
+    public void setEnabledProtocols(String[] protocols) {
+
+    }
+
+    @Override
+    public SSLSession getSession() {
+      return null;
+    }
+
+    @Override
+    public void addHandshakeCompletedListener(HandshakeCompletedListener listener) {
+
+    }
+
+    @Override
+    public void removeHandshakeCompletedListener(HandshakeCompletedListener listener) {
+
+    }
+
+    @Override
+    public void startHandshake() throws IOException {
+
+    }
+
+    @Override
+    public void setUseClientMode(boolean mode) {
+
+    }
+
+    @Override
+    public boolean getUseClientMode() {
+      return false;
+    }
+
+    @Override
+    public void setNeedClientAuth(boolean need) {
+
+    }
+
+    @Override
+    public boolean getNeedClientAuth() {
+      return false;
+    }
+
+    @Override
+    public void setWantClientAuth(boolean want) {
+
+    }
+
+    @Override
+    public boolean getWantClientAuth() {
+      return false;
+    }
+
+    @Override
+    public void setEnableSessionCreation(boolean flag) {
+
+    }
+
+    @Override
+    public boolean getEnableSessionCreation() {
+      return false;
+    }
+
+    @Override
+    public synchronized void close() throws IOException {
+      delegate.close();
+    }
+
+    @Override
+    public SocketAddress getLocalSocketAddress() {
+      return delegate.getLocalSocketAddress();
+    }
+
+    @Override
+    public OutputStream getOutputStream() throws IOException {
+      return delegate.getOutputStream();
+    }
+
+    @Override
+    public InputStream getInputStream() throws IOException {
+      return delegate.getInputStream();
+    }
   }
 
   static class PingCallbackImpl implements ClientTransport.PingCallback {
     int invocationCount;
     long roundTripTime;
-    Throwable failureCause;
+    Status failureCause;
 
     @Override
     public void onSuccess(long roundTripTimeNanos) {
@@ -1734,38 +2610,189 @@ public void onSuccess(long roundTripTimeNanos) {
     }
 
     @Override
-    public void onFailure(Throwable cause) {
+    public void onFailure(Status cause) {
       invocationCount++;
       this.failureCause = cause;
     }
   }
 
-  private void allowTransportConnected() {
-    delayConnectedCallback.allowConnected();
-  }
-
   private void shutdownAndVerify() {
-    clientTransport.shutdown();
+    clientTransport.shutdown(SHUTDOWN_REASON);
     assertEquals(0, activeStreamCount());
     try {
       verify(frameWriter, timeout(TIME_OUT_MS)).close();
     } catch (IOException e) {
       throw new RuntimeException(e);
-
     }
     frameReader.assertClosed();
   }
 
-  private static class DelayConnectedCallback implements Runnable {
-    SettableFuture<Void> delayed = SettableFuture.create();
+  private static TransportStats getTransportStats(InternalInstrumented<SocketStats> obj)
+      throws ExecutionException, InterruptedException {
+    return obj.getStats().get().data;
+  }
+
+  /** A FrameWriter to mock with CALL_REAL_METHODS option. */
+  private static class MockFrameWriter implements FrameWriter {
+
+    private Socket socket;
+    private final Queue<Buffer> capturedBuffer;
+
+    public MockFrameWriter(Socket socket, Queue<Buffer> capturedBuffer) {
+      // Sets a socket to close. Some tests assumes that FrameWriter will close underlying sink
+      // which will eventually close the socket.
+      this.socket = socket;
+      this.capturedBuffer = capturedBuffer;
+    }
+
+    @Override
+    public void close() throws IOException {
+      socket.close();
+    }
+
+    @Override
+    public int maxDataLength() {
+      return Integer.MAX_VALUE;
+    }
+
+    @Override
+    public void data(boolean outFinished, int streamId, Buffer source, int byteCount)
+        throws IOException {
+      // simulate the side effect, and captures to internal queue.
+      Buffer capture = new Buffer();
+      capture.write(source, byteCount);
+      capturedBuffer.add(capture);
+    }
+
+    // rest of methods are unimplemented
+
+    @Override
+    public void connectionPreface() throws IOException {}
+
+    @Override
+    public void ackSettings(Settings peerSettings) throws IOException {}
 
     @Override
-    public void run() {
-      Futures.getUnchecked(delayed);
+    public void pushPromise(int streamId, int promisedStreamId, List<Header> requestHeaders)
+        throws IOException {}
+
+    @Override
+    public void flush() throws IOException {}
+
+    @Override
+    public void synStream(boolean outFinished, boolean inFinished, int streamId,
+        int associatedStreamId, List<Header> headerBlock) throws IOException {}
+
+    @Override
+    public void synReply(boolean outFinished, int streamId, List<Header> headerBlock)
+        throws IOException {}
+
+    @Override
+    public void headers(int streamId, List<Header> headerBlock) throws IOException {}
+
+    @Override
+    public void rstStream(int streamId, ErrorCode errorCode) throws IOException {}
+
+    @Override
+    public void settings(Settings okHttpSettings) throws IOException {}
+
+    @Override
+    public void ping(boolean ack, int payload1, int payload2) throws IOException {}
+
+    @Override
+    public void goAway(int lastGoodStreamId, ErrorCode errorCode, byte[] debugData)
+        throws IOException {}
+
+    @Override
+    public void windowUpdate(int streamId, long windowSizeIncrement) throws IOException {}
+  }
+
+  private static class RuntimeExceptionThrowingSocketFactory extends SocketFactory {
+    RuntimeException exception;
+
+    private RuntimeExceptionThrowingSocketFactory(RuntimeException exception) {
+      this.exception = exception;
+    }
+
+    @Override
+    public Socket createSocket(String s, int i) {
+      throw exception;
+    }
+
+    @Override
+    public Socket createSocket(String s, int i, InetAddress inetAddress, int i1) {
+      throw exception;
+    }
+
+    @Override
+    public Socket createSocket(InetAddress inetAddress, int i) {
+      throw exception;
+    }
+
+    @Override
+    public Socket createSocket(InetAddress inetAddress, int i, InetAddress inetAddress1, int i1) {
+      throw exception;
+    }
+  }
+
+  static class FakeSocketFactory extends SocketFactory {
+    private Socket socket;
+
+    public FakeSocketFactory(Socket socket) {
+      this.socket = Preconditions.checkNotNull(socket, "socket");
+    }
+
+    @Override public Socket createSocket() {
+      Preconditions.checkNotNull(this.socket, "socket");
+      Socket socket = this.socket;
+      this.socket = null;
+      return socket;
+    }
+
+    @Override public Socket createSocket(InetAddress host, int port) {
+      return createSocket();
+    }
+
+    @Override public Socket createSocket(
+        InetAddress host, int port, InetAddress localAddress, int localPort) {
+      return createSocket();
+    }
+
+    @Override public Socket createSocket(String host, int port) {
+      return createSocket();
+    }
+
+    @Override public Socket createSocket(
+        String host, int port, InetAddress localHost, int localPort) {
+      return createSocket();
+    }
+  }
+
+  static class FakeVariant implements Variant {
+    private FrameReader frameReader;
+    private FrameWriter frameWriter;
+
+    public FakeVariant(FrameReader frameReader, FrameWriter frameWriter) {
+      this.frameReader = frameReader;
+      this.frameWriter = frameWriter;
+    }
+
+    @Override public Protocol getProtocol() {
+      return Protocol.HTTP_2;
+    }
+
+    @Override public FrameReader newReader(BufferedSource source, boolean client) {
+      Preconditions.checkNotNull(this.frameReader, "frameReader");
+      FrameReader frameReader = this.frameReader;
+      this.frameReader = null;
+      return frameReader;
     }
 
-    void allowConnected() {
-      delayed.set(null);
+    @Override public FrameWriter newWriter(BufferedSink sink, boolean client) {
+      Preconditions.checkNotNull(this.frameWriter, "frameWriter");
+      FrameWriter frameWriter = this.frameWriter;
+      this.frameWriter = null;
+      return frameWriter;
     }
   }
 }
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpProtocolNegotiatorTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpProtocolNegotiatorTest.java
index 1596cb95d43..4353dc2597b 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpProtocolNegotiatorTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpProtocolNegotiatorTest.java
@@ -1,40 +1,28 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
-import static com.google.common.base.Charsets.UTF_8;
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
@@ -43,46 +31,27 @@
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.ImmutableList;
 import io.grpc.okhttp.OkHttpProtocolNegotiator.AndroidNegotiator;
-import io.grpc.okhttp.OkHttpProtocolNegotiator.AndroidNegotiator.TlsExtensionType;
 import io.grpc.okhttp.internal.Platform;
+import io.grpc.okhttp.internal.Platform.TlsExtensionType;
 import io.grpc.okhttp.internal.Protocol;
 import java.io.IOException;
-import java.security.Provider;
-import java.security.Security;
 import javax.net.ssl.HandshakeCompletedListener;
+import javax.net.ssl.SSLParameters;
 import javax.net.ssl.SSLSession;
 import javax.net.ssl.SSLSocket;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
-import org.mockito.Mockito;
+import org.mockito.ArgumentMatchers;
 
 /**
  * Tests for {@link OkHttpProtocolNegotiator}.
  */
 @RunWith(JUnit4.class)
 public class OkHttpProtocolNegotiatorTest {
-  @Rule public final ExpectedException thrown = ExpectedException.none();
-
-  private final Provider fakeSecurityProvider = new Provider("GmsCore_OpenSSL", 1.0, "info") {};
   private final SSLSocket sock = mock(SSLSocket.class);
   private final Platform platform = mock(Platform.class);
 
-  @Before
-  public void setUp() {
-    // Tests that depend on android need this to know which protocol negotiation to use.
-    Security.addProvider(fakeSecurityProvider);
-  }
-
-  @After
-  public void tearDown() {
-    Security.removeProvider(fakeSecurityProvider.getName());
-  }
-
   @Test
   public void createNegotiator_isAndroid() {
     ClassLoader cl = new ClassLoader(this.getClass().getClassLoader()) {
@@ -142,28 +111,28 @@ public void negotiatorNotNull() {
 
   @Test
   public void negotiate_handshakeFails() throws IOException {
+    SSLParameters parameters = new SSLParameters();
     OkHttpProtocolNegotiator negotiator = OkHttpProtocolNegotiator.get();
+    doReturn(parameters).when(sock).getSSLParameters();
     doThrow(new IOException()).when(sock).startHandshake();
-    thrown.expect(IOException.class);
-
-    negotiator.negotiate(sock, "hostname", ImmutableList.of(Protocol.HTTP_2));
+    assertThrows(IOException.class,
+        () -> negotiator.negotiate(sock, "hostname", ImmutableList.of(Protocol.HTTP_2)));
   }
 
   @Test
-  public void negotiate_noSelectedProtocol() throws Exception {
+  public void negotiate_noSelectedProtocol() {
     Platform platform = mock(Platform.class);
 
     OkHttpProtocolNegotiator negotiator = new OkHttpProtocolNegotiator(platform);
 
-    thrown.expect(RuntimeException.class);
-    thrown.expectMessage("protocol negotiation failed");
-
-    negotiator.negotiate(sock, "hostname", ImmutableList.of(Protocol.HTTP_2));
+    RuntimeException e = assertThrows(RuntimeException.class,
+        () -> negotiator.negotiate(sock, "hostname", ImmutableList.of(Protocol.HTTP_2)));
+    assertThat(e).hasMessageThat().isEqualTo("TLS ALPN negotiation failed with protocols: [h2]");
   }
 
   @Test
   public void negotiate_success() throws Exception {
-    when(platform.getSelectedProtocol(Mockito.<SSLSocket>any())).thenReturn("h2");
+    when(platform.getSelectedProtocol(ArgumentMatchers.<SSLSocket>any())).thenReturn("h2");
     OkHttpProtocolNegotiator negotiator = new OkHttpProtocolNegotiator(platform);
 
     String actual = negotiator.negotiate(sock, "hostname", ImmutableList.of(Protocol.HTTP_2));
@@ -174,98 +143,11 @@ public void negotiate_success() throws Exception {
     verify(platform).afterHandshake(sock);
   }
 
-  @Test
-  public void negotiate_preferGrpcExp() throws Exception {
-    // This test doesn't actually verify that grpc-exp is preferred, since the
-    // mocking of getSelectedProtocol() causes the protocol list to be ignored.
-    // The main usefulness of the test is for future changes to
-    // OkHttpProtocolNegotiator, where we can catch any change that would affect
-    // grpc-exp preference.
-    when(platform.getSelectedProtocol(Mockito.<SSLSocket>any())).thenReturn("grpc-exp");
-    OkHttpProtocolNegotiator negotiator = new OkHttpProtocolNegotiator(platform);
-
-    String actual =
-        negotiator.negotiate(sock, "hostname",
-                ImmutableList.of(Protocol.GRPC_EXP, Protocol.HTTP_2));
-
-    assertEquals("grpc-exp", actual);
-    verify(sock).startHandshake();
-    verify(platform).getSelectedProtocol(sock);
-    verify(platform).afterHandshake(sock);
-  }
-
-  @Test
-  public void pickTlsExtensionType_securityProvider() throws Exception {
-    assertNotNull(Security.getProvider(fakeSecurityProvider.getName()));
-
-    AndroidNegotiator.TlsExtensionType tlsExtensionType =
-        AndroidNegotiator.pickTlsExtensionType(getClass().getClassLoader());
-
-    assertEquals(TlsExtensionType.ALPN_AND_NPN, tlsExtensionType);
-  }
-
-  @Test
-  public void pickTlsExtensionType_android50() throws Exception {
-    Security.removeProvider(fakeSecurityProvider.getName());
-    ClassLoader cl = new ClassLoader(this.getClass().getClassLoader()) {
-      @Override
-      protected Class<?> findClass(String name) throws ClassNotFoundException {
-        // Just don't throw.
-        if ("android.net.Network".equals(name)) {
-          return null;
-        }
-        return super.findClass(name);
-      }
-    };
-
-    AndroidNegotiator.TlsExtensionType tlsExtensionType =
-        AndroidNegotiator.pickTlsExtensionType(cl);
-
-    assertEquals(TlsExtensionType.ALPN_AND_NPN, tlsExtensionType);
-  }
-
-  @Test
-  public void pickTlsExtensionType_android41() throws Exception {
-    Security.removeProvider(fakeSecurityProvider.getName());
-    ClassLoader cl = new ClassLoader(this.getClass().getClassLoader()) {
-      @Override
-      protected Class<?> findClass(String name) throws ClassNotFoundException {
-        // Just don't throw.
-        if ("android.app.ActivityOptions".equals(name)) {
-          return null;
-        }
-        return super.findClass(name);
-      }
-    };
-
-    AndroidNegotiator.TlsExtensionType tlsExtensionType =
-        AndroidNegotiator.pickTlsExtensionType(cl);
-
-    assertEquals(TlsExtensionType.NPN, tlsExtensionType);
-  }
-
-  @Test
-  public void pickTlsExtensionType_none() throws Exception {
-    Security.removeProvider(fakeSecurityProvider.getName());
-
-    AndroidNegotiator.TlsExtensionType tlsExtensionType =
-        AndroidNegotiator.pickTlsExtensionType(getClass().getClassLoader());
-
-    assertNull(tlsExtensionType);
-  }
-
-  @Test
-  public void androidNegotiator_failsOnNull() {
-    thrown.expect(NullPointerException.class);
-    thrown.expectMessage("Unable to pick a TLS extension");
-
-    new AndroidNegotiator(platform, null);
-  }
-
   // Checks that the super class is properly invoked.
   @Test
-  public void negotiate_android_handshakeFails() throws Exception {
-    AndroidNegotiator negotiator = new AndroidNegotiator(platform, TlsExtensionType.ALPN_AND_NPN);
+  public void negotiate_android_handshakeFails() {
+    when(platform.getTlsExtensionType()).thenReturn(TlsExtensionType.ALPN_AND_NPN);
+    AndroidNegotiator negotiator = new AndroidNegotiator(platform);
 
     FakeAndroidSslSocket androidSock = new FakeAndroidSslSocket() {
       @Override
@@ -274,10 +156,9 @@ public void startHandshake() throws IOException {
       }
     };
 
-    thrown.expect(IOException.class);
-    thrown.expectMessage("expected");
-
-    negotiator.negotiate(androidSock, "hostname", ImmutableList.of(Protocol.HTTP_2));
+    IOException e = assertThrows(IOException.class,
+        () -> negotiator.negotiate(androidSock, "hostname", ImmutableList.of(Protocol.HTTP_2)));
+    assertThat(e).hasMessageThat().isEqualTo("expected");
   }
 
   @VisibleForTesting
@@ -290,7 +171,8 @@ public byte[] getAlpnSelectedProtocol() {
 
   @Test
   public void getSelectedProtocol_alpn() throws Exception {
-    AndroidNegotiator negotiator = new AndroidNegotiator(platform, TlsExtensionType.ALPN_AND_NPN);
+    when(platform.getTlsExtensionType()).thenReturn(TlsExtensionType.ALPN_AND_NPN);
+    AndroidNegotiator negotiator = new AndroidNegotiator(platform);
     FakeAndroidSslSocket androidSock = new FakeAndroidSslSocketAlpn();
 
     String actual = negotiator.getSelectedProtocol(androidSock);
@@ -308,7 +190,8 @@ public byte[] getNpnSelectedProtocol() {
 
   @Test
   public void getSelectedProtocol_npn() throws Exception {
-    AndroidNegotiator negotiator = new AndroidNegotiator(platform, TlsExtensionType.NPN);
+    when(platform.getTlsExtensionType()).thenReturn(TlsExtensionType.NPN);
+    AndroidNegotiator negotiator = new AndroidNegotiator(platform);
     FakeAndroidSslSocket androidSock = new FakeAndroidSslSocketNpn();
 
     String actual = negotiator.getSelectedProtocol(androidSock);
@@ -408,4 +291,9 @@ public void setWantClientAuth(boolean want) {}
     @Override
     public void startHandshake() throws IOException {}
   }
+
+  @Test
+  public void isValidHostName_withUnderscore() {
+    assertFalse(OkHttpProtocolNegotiator.isValidHostName("test_cert_2"));
+  }
 }
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpReadableBufferTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpReadableBufferTest.java
index d3095afb9f0..be8dbf0e62b 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpReadableBufferTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpReadableBufferTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
@@ -61,13 +46,13 @@ public void setup() {
 
   @Override
   @Test
-  public void readToByteBufferShouldSucceed() {
+  public void markAndResetWithReadShouldSucceed() {
     // Not supported.
   }
 
   @Override
   @Test
-  public void partialReadToByteBufferShouldSucceed() {
+  public void markAndResetWithReadToReadableBufferShouldSucceed() {
     // Not supported.
   }
 
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpServerProviderTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpServerProviderTest.java
new file mode 100644
index 00000000000..93354f01e25
--- /dev/null
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpServerProviderTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2023 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.okhttp;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ServerCredentials;
+import io.grpc.ServerProvider;
+import io.grpc.ServerRegistryAccessor;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link OkHttpServerProvider}. */
+@RunWith(JUnit4.class)
+public class OkHttpServerProviderTest {
+  private OkHttpServerProvider provider = new OkHttpServerProvider();
+
+  @Test
+  public void provided() {
+    assertThat(ServerProvider.provider()).isInstanceOf(OkHttpServerProvider.class);
+  }
+
+  @Test
+  public void providedHardCoded() {
+    assertThat(ServerRegistryAccessor.getHardCodedClasses()).contains(OkHttpServerProvider.class);
+  }
+
+  @Test
+  public void basicMethods() {
+    assertThat(provider.isAvailable()).isTrue();
+    assertThat(provider.priority()).isEqualTo(4);
+  }
+
+  @Test
+  public void builderIsAOkHttpBuilder() {
+    assertThrows(UnsupportedOperationException.class, () -> provider.builderForPort(80));
+  }
+
+  @Test
+  public void newServerBuilderForPort_success() {
+    ServerProvider.NewServerBuilderResult result =
+        provider.newServerBuilderForPort(80, InsecureServerCredentials.create());
+    assertThat(result.getServerBuilder()).isInstanceOf(OkHttpServerBuilder.class);
+  }
+
+  @Test
+  public void newServerBuilderForPort_fail() {
+    ServerProvider.NewServerBuilderResult result = provider.newServerBuilderForPort(
+        80, new FakeServerCredentials());
+    assertThat(result.getError()).contains("FakeServerCredentials");
+  }
+
+  private static final class FakeServerCredentials extends ServerCredentials {}
+}
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpServerTransportTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpServerTransportTest.java
new file mode 100644
index 00000000000..00db6e1d339
--- /dev/null
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpServerTransportTest.java
@@ -0,0 +1,1574 @@
+/*
+ * Copyright 2022 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.okhttp;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.okhttp.Headers.CONTENT_TYPE_HEADER;
+import static io.grpc.okhttp.Headers.HTTP_SCHEME_HEADER;
+import static io.grpc.okhttp.Headers.METHOD_HEADER;
+import static io.grpc.okhttp.Headers.TE_HEADER;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.mockito.AdditionalAnswers.answerVoid;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.Lists;
+import com.google.common.io.ByteStreams;
+import io.grpc.Attributes;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.KeepAliveEnforcer;
+import io.grpc.internal.ServerStream;
+import io.grpc.internal.ServerStreamListener;
+import io.grpc.internal.ServerTransportListener;
+import io.grpc.okhttp.internal.framed.ErrorCode;
+import io.grpc.okhttp.internal.framed.FrameReader;
+import io.grpc.okhttp.internal.framed.FrameWriter;
+import io.grpc.okhttp.internal.framed.Header;
+import io.grpc.okhttp.internal.framed.HeadersMode;
+import io.grpc.okhttp.internal.framed.Http2;
+import io.grpc.okhttp.internal.framed.Settings;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetSocketAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import okio.Buffer;
+import okio.BufferedSink;
+import okio.BufferedSource;
+import okio.ByteString;
+import okio.Okio;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.Timeout;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+
+/**
+ * Tests for {@link OkHttpServerTransport}.
+ */
+@RunWith(JUnit4.class)
+public class OkHttpServerTransportTest {
+  private static final int TIME_OUT_MS = 2000;
+  private static final int INITIAL_WINDOW_SIZE = 65535;
+  private static final long MAX_CONNECTION_IDLE = TimeUnit.SECONDS.toNanos(1);
+  private static final byte FLAG_NONE = 0x0;
+  private static final byte FLAG_PADDED = 0x8;
+  private static final byte FLAG_END_STREAM = 0x1;
+  private static final byte TYPE_DATA = 0x0;
+  private MockServerTransportListener mockTransportListener = new MockServerTransportListener();
+  private ServerTransportListener transportListener
+      = mock(ServerTransportListener.class, delegatesTo(mockTransportListener));
+  private OkHttpServerTransport serverTransport;
+  private final ExecutorService threadPool = Executors.newCachedThreadPool();
+  private final SocketPair socketPair = SocketPair.create(threadPool);
+  private final BufferedSink clientWriterSink = Okio.buffer(
+      Okio.sink(socketPair.getClientOutputStream()));
+  private final FrameWriter clientFrameWriter = new Http2().newWriter(clientWriterSink, true);
+  private final FrameReader clientFrameReader
+      = new Http2().newReader(Okio.buffer(Okio.source(socketPair.getClientInputStream())), true);
+  private final FrameReader.Handler clientFramesRead = mock(FrameReader.Handler.class);
+  private final DataFrameHandler clientDataFrames = mock(DataFrameHandler.class);
+  private HandshakerSocketFactory handshakerSocketFactory
+      = mock(HandshakerSocketFactory.class, delegatesTo(new PlaintextHandshakerSocketFactory()));
+  private final FakeClock fakeClock = new FakeClock();
+  private OkHttpServerBuilder serverBuilder
+      = new OkHttpServerBuilder(new InetSocketAddress(1234), handshakerSocketFactory)
+      .executor(new FakeClock().getScheduledExecutorService()) // Executor unused
+      .scheduledExecutorService(fakeClock.getScheduledExecutorService())
+      .transportExecutor(new Executor() {
+        @Override public void execute(Runnable runnable) {
+          if (runnable instanceof OkHttpServerTransport.FrameHandler) {
+            threadPool.execute(runnable);
+          } else {
+            // Writing is buffered in the PipeSocket, so AsyncSinc can be executed immediately
+            runnable.run();
+          }
+        }
+      })
+      .flowControlWindow(INITIAL_WINDOW_SIZE)
+      .maxConnectionIdle(MAX_CONNECTION_IDLE, TimeUnit.NANOSECONDS)
+      .permitKeepAliveWithoutCalls(true)
+      .permitKeepAliveTime(0, TimeUnit.SECONDS);
+
+  @Rule public final Timeout globalTimeout = Timeout.seconds(10);
+
+  @Before
+  @SuppressWarnings("DirectInvocationOnMock")
+  public void setUp() throws Exception {
+    doAnswer(answerVoid((Boolean outDone, Integer streamId, BufferedSource in, Integer length) -> {
+      in.require(length);
+      Buffer buf = new Buffer();
+      buf.write(in.getBuffer(), length);
+      clientDataFrames.data(outDone, streamId, buf);
+    })).when(clientFramesRead).data(anyBoolean(), anyInt(), any(BufferedSource.class), anyInt(),
+        anyInt());
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    threadPool.shutdownNow();
+    try {
+      socketPair.client.close();
+    } finally {
+      socketPair.server.close();
+    }
+  }
+
+  @Test
+  public void startThenShutdown() throws Exception {
+    initTransport();
+    handshake();
+    shutdownAndTerminate(/*lastStreamId=*/ 0);
+  }
+
+  @Test
+  public void maxConnectionAge() throws Exception {
+    serverBuilder.maxConnectionAge(5, TimeUnit.SECONDS)
+        .maxConnectionAgeGrace(3, TimeUnit.SECONDS);
+    initTransport();
+    handshake();
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.synStream(true, false, 1, -1, Arrays.asList(
+        new Header("some-client-sent-trailer", "trailer-value")));
+    pingPong();
+    fakeClock.forwardNanos(TimeUnit.SECONDS.toNanos(6)); // > 1.1 * 5
+    verifyGracefulShutdown(1);
+    pingPong();
+    fakeClock.forwardNanos(TimeUnit.SECONDS.toNanos(3));
+    assertThat(socketPair.server.isClosed()).isTrue();
+  }
+
+  @Test
+  public void maxConnectionAge_shutdown() throws Exception {
+    serverBuilder.maxConnectionAge(5, TimeUnit.SECONDS)
+        .maxConnectionAgeGrace(3, TimeUnit.SECONDS);
+    initTransport();
+    handshake();
+    shutdownAndTerminate(0);
+    assertThat(fakeClock.numPendingTasks()).isEqualTo(0);
+  }
+
+  @Test
+  public void maxConnectionIdleTimer() throws Exception {
+    initTransport();
+    handshake();
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.synStream(true, false, 1, -1, Arrays.asList(
+        new Header("some-client-sent-trailer", "trailer-value")));
+    pingPong();
+
+    MockStreamListener streamListener = mockTransportListener.newStreams.pop();
+    assertThat(streamListener.messages.peek()).isNull();
+    assertThat(streamListener.halfClosedCalled).isTrue();
+
+    streamListener.stream.close(Status.OK, new Metadata());
+
+    List<Header> responseTrailers = Arrays.asList(
+        new Header(":status", "200"),
+        CONTENT_TYPE_HEADER,
+        new Header("grpc-status", "0"));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead)
+        .headers(false, true, 1, -1, responseTrailers, HeadersMode.HTTP_20_HEADERS);
+
+    fakeClock.forwardNanos(MAX_CONNECTION_IDLE);
+    fakeClock.forwardNanos(MAX_CONNECTION_IDLE);
+    verifyGracefulShutdown(1);
+  }
+
+  @Test
+  public void maxConnectionIdleTimer_respondWithError() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER,
+        new Header("host", "example.com:80"),
+        new Header("host", "example.com:80")));
+    clientFrameWriter.flush();
+
+    verifyHttpError(
+        1, 400, Status.Code.INTERNAL, "Multiple host headers disallowed. RFC7230 section 5.4");
+
+    pingPong();
+    fakeClock.forwardNanos(MAX_CONNECTION_IDLE);
+    fakeClock.forwardNanos(MAX_CONNECTION_IDLE);
+    verifyGracefulShutdown(1);
+  }
+
+  @Test
+  public void startThenShutdownTwice() throws Exception {
+    initTransport();
+    handshake();
+    serverTransport.shutdown();
+    shutdownAndTerminate(/*lastStreamId=*/ 0);
+  }
+
+  @Test
+  public void shutdownDuringHandshake() throws Exception {
+    doAnswer(invocation -> {
+      ((Socket) invocation.getArguments()[0]).getInputStream().read();
+      throw new IOException("handshake purposefully failed");
+    }).when(handshakerSocketFactory).handshake(any(Socket.class), any(Attributes.class));
+    serverBuilder.transportExecutor(threadPool);
+    initTransport();
+    serverTransport.shutdown();
+
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+    verify(transportListener, never()).transportReady(any(Attributes.class));
+  }
+
+  @Test
+  public void shutdownNowDuringHandshake() throws Exception {
+    doAnswer(invocation -> {
+      ((Socket) invocation.getArguments()[0]).getInputStream().read();
+      throw new IOException("handshake purposefully failed");
+    }).when(handshakerSocketFactory).handshake(any(Socket.class), any(Attributes.class));
+    serverBuilder.transportExecutor(threadPool);
+    initTransport();
+    serverTransport.shutdownNow(Status.UNAVAILABLE.withDescription("shutdown now"));
+
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+    verify(transportListener, never()).transportReady(any(Attributes.class));
+  }
+
+  @Test
+  public void clientCloseDuringHandshake() throws Exception {
+    doAnswer(invocation -> {
+      ((Socket) invocation.getArguments()[0]).getInputStream().read();
+      throw new IOException("handshake purposefully failed");
+    }).when(handshakerSocketFactory).handshake(any(Socket.class), any(Attributes.class));
+    serverBuilder.transportExecutor(threadPool);
+    initTransport();
+    socketPair.client.close();
+
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+    verify(transportListener, never()).transportReady(any(Attributes.class));
+  }
+
+  @Test
+  public void closeDuringHttp2Preface() throws Exception {
+    initTransport();
+    socketPair.client.close();
+
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+    verify(transportListener, never()).transportReady(any(Attributes.class));
+  }
+
+  @Test
+  public void noSettingsDuringHttp2HandshakeSettings() throws Exception {
+    initTransport();
+    clientFrameWriter.connectionPreface();
+    clientFrameWriter.flush();
+    socketPair.client.close();
+
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+    verify(transportListener, never()).transportReady(any(Attributes.class));
+  }
+
+  @Test
+  public void noSettingsDuringHttp2Handshake() throws Exception {
+    initTransport();
+    clientFrameWriter.connectionPreface();
+    clientFrameWriter.ping(false, 0, 0x1234);
+    clientFrameWriter.flush();
+
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+    verify(transportListener, never()).transportReady(any(Attributes.class));
+  }
+
+  @Test
+  public void startThenClientDisconnect() throws Exception {
+    initTransport();
+    handshake();
+
+    socketPair.client.close();
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+  }
+
+  @Test
+  public void basicRpc_succeeds() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER,
+        new Header("some-metadata", "this could be anything")));
+    Buffer requestMessageFrame = createMessageFrame("Hello server");
+    clientFrameWriter.data(true, 1, requestMessageFrame, (int) requestMessageFrame.size());
+    pingPong();
+
+    MockStreamListener streamListener = mockTransportListener.newStreams.pop();
+    assertThat(streamListener.stream.getAuthority()).isEqualTo("example.com:80");
+    assertThat(streamListener.method).isEqualTo("com.example/SimpleService.doit");
+    assertThat(streamListener.headers.get(
+          Metadata.Key.of("Some-Metadata", Metadata.ASCII_STRING_MARSHALLER)))
+        .isEqualTo("this could be anything");
+    streamListener.stream.request(1);
+    pingPong();
+    assertThat(streamListener.messages.pop()).isEqualTo("Hello server");
+    assertThat(streamListener.halfClosedCalled).isTrue();
+
+    streamListener.stream.writeHeaders(metadata("User-Data", "best data"), false);
+    streamListener.stream.writeMessage(new ByteArrayInputStream("Howdy client".getBytes(UTF_8)));
+    streamListener.stream.close(Status.OK, metadata("End-Metadata", "bye"));
+
+    List<Header> responseHeaders = Arrays.asList(
+        new Header(":status", "200"),
+        CONTENT_TYPE_HEADER,
+        new Header("user-data", "best data"));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead)
+        .headers(false, false, 1, -1, responseHeaders, HeadersMode.HTTP_20_HEADERS);
+
+    Buffer responseMessageFrame = createMessageFrame("Howdy client");
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead)
+        .data(eq(false), eq(1), any(BufferedSource.class), eq((int) responseMessageFrame.size()),
+            eq((int) responseMessageFrame.size()));
+    verify(clientDataFrames).data(false, 1, responseMessageFrame);
+
+    List<Header> responseTrailers = Arrays.asList(
+        new Header("end-metadata", "bye"),
+        new Header("grpc-status", "0"));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead)
+        .headers(false, true, 1, -1, responseTrailers, HeadersMode.HTTP_20_HEADERS);
+
+    SocketStats stats = serverTransport.getStats().get();
+    assertThat(stats.data.streamsStarted).isEqualTo(1);
+    assertThat(stats.data.streamsSucceeded).isEqualTo(1);
+    assertThat(stats.data.streamsFailed).isEqualTo(0);
+    assertThat(stats.data.messagesSent).isEqualTo(1);
+    assertThat(stats.data.messagesReceived).isEqualTo(1);
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void activeRpc_delaysShutdownTermination() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER,
+        new Header("some-metadata", "this could be anything")));
+    Buffer requestMessageFrame = createMessageFrame("Hello server");
+    clientFrameWriter.data(true, 1, requestMessageFrame, (int) requestMessageFrame.size());
+    pingPong();
+
+    serverTransport.shutdown();
+    verifyGracefulShutdown(1);
+    verify(transportListener, never()).transportTerminated();
+
+    MockStreamListener streamListener = mockTransportListener.newStreams.pop();
+    streamListener.stream.request(1);
+    pingPong();
+    assertThat(streamListener.messages.pop()).isEqualTo("Hello server");
+    assertThat(streamListener.halfClosedCalled).isTrue();
+
+    streamListener.stream.writeHeaders(new Metadata(), false);
+    streamListener.stream.writeMessage(new ByteArrayInputStream("Howdy client".getBytes(UTF_8)));
+    streamListener.stream.flush();
+
+    List<Header> responseHeaders = Arrays.asList(
+        new Header(":status", "200"),
+        CONTENT_TYPE_HEADER);
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead)
+        .headers(false, false, 1, -1, responseHeaders, HeadersMode.HTTP_20_HEADERS);
+
+    Buffer responseMessageFrame = createMessageFrame("Howdy client");
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead)
+        .data(eq(false), eq(1), any(BufferedSource.class), eq((int) responseMessageFrame.size()),
+            eq((int) responseMessageFrame.size()));
+    verify(clientDataFrames).data(false, 1, responseMessageFrame);
+    pingPong();
+    assertThat(serverTransport.getActiveStreams().length).isEqualTo(1);
+    verify(transportListener, never()).transportTerminated();
+
+    streamListener.stream.close(Status.OK, new Metadata());
+    List<Header> responseTrailers = Arrays.asList(
+        new Header("grpc-status", "0"));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead)
+        .headers(false, true, 1, -1, responseTrailers, HeadersMode.HTTP_20_HEADERS);
+
+    assertThat(serverTransport.getActiveStreams().length).isEqualTo(0);
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+  }
+
+  @Test
+  public void headersForStream0_failsWithGoAway() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(0, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).goAway(
+        0, ErrorCode.INTERNAL_ERROR,
+        ByteString.encodeUtf8("Error in frame decoder"));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isFalse();
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+  }
+
+  @Test
+  public void headersForEvenStream_failsWithGoAway() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(2, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).goAway(
+        0, ErrorCode.PROTOCOL_ERROR,
+        ByteString.encodeUtf8("Clients cannot open even numbered streams. RFC7540 section 5.1.1"));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isFalse();
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+  }
+
+  @Test
+  public void headersTooLarge_failsWith431() throws Exception {
+    initTransport();
+    handshake();
+
+    StringBuilder largeString = new StringBuilder();
+    for (int i = 0; i < 100; i++) {
+      largeString.append(
+          "Row, row, row your boat, gently down the stream. Merrily, merrily, merrily, merrily, "
+          + "life is but a dream. ");
+    }
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER,
+        new Header("too-large", largeString.toString())));
+    clientFrameWriter.flush();
+
+    verifyHttpError(
+        1, 431, Status.Code.RESOURCE_EXHAUSTED, "Request metadata larger than 8192: 10953");
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void invalidPseudoHeader_failsWithRst() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        new Header(":status", "999"), // Invalid for requests
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).rstStream(1, ErrorCode.PROTOCOL_ERROR);
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void multipleAuthorityHeaders_failsWithRst() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_AUTHORITY, "example.com:8080"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).rstStream(1, ErrorCode.PROTOCOL_ERROR);
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void pseudoHeaderAfterRegularHeader_failsWithRst() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        CONTENT_TYPE_HEADER,
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        TE_HEADER));
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).rstStream(1, ErrorCode.PROTOCOL_ERROR);
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void missingSchemeHeader_failsWithRst() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).rstStream(1, ErrorCode.PROTOCOL_ERROR);
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void connectionHeader_failsWithRst() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        new Header("connection", "content-type"),
+        TE_HEADER));
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).rstStream(1, ErrorCode.PROTOCOL_ERROR);
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void trailersAfterEndStream_failsWithRst() throws Exception {
+    initTransport();
+    handshake();
+
+    List<Header> headers = Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER);
+    clientFrameWriter.synStream(true, false, 1, -1, headers);
+    clientFrameWriter.synStream(true, false, 1, -1, headers);
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).rstStream(1, ErrorCode.STREAM_CLOSED);
+    pingPong();
+
+    MockStreamListener streamListener = mockTransportListener.newStreams.pop();
+    assertThat(streamListener.status).isNotNull();
+    assertThat(streamListener.status.getCode()).isNotEqualTo(Status.Code.OK);
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void trailers_endStream() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.synStream(true, false, 1, -1, Arrays.asList(
+        new Header("some-client-sent-trailer", "trailer-value")));
+    pingPong();
+
+    MockStreamListener streamListener = mockTransportListener.newStreams.pop();
+    assertThat(streamListener.messages.peek()).isNull();
+    assertThat(streamListener.halfClosedCalled).isTrue();
+
+    streamListener.stream.close(Status.OK, new Metadata());
+
+    List<Header> responseTrailers = Arrays.asList(
+        new Header(":status", "200"),
+        CONTENT_TYPE_HEADER,
+        new Header("grpc-status", "0"));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead)
+        .headers(false, true, 1, -1, responseTrailers, HeadersMode.HTTP_20_HEADERS);
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void headersInMiddleOfRequest_failsWithRst() throws Exception {
+    initTransport();
+    handshake();
+
+    List<Header> headers = Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER);
+    clientFrameWriter.headers(1, headers);
+    clientFrameWriter.headers(1, headers);
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).rstStream(1, ErrorCode.PROTOCOL_ERROR);
+    pingPong();
+
+    MockStreamListener streamListener = mockTransportListener.newStreams.pop();
+    assertThat(streamListener.status).isNotNull();
+    assertThat(streamListener.status.getCode()).isNotEqualTo(Status.Code.OK);
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void multipleHostHeaders_failsWith400() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER,
+        new Header("host", "example.com:80"),
+        new Header("host", "example.com:80")));
+    clientFrameWriter.flush();
+
+    verifyHttpError(
+        1, 400, Status.Code.INTERNAL, "Multiple host headers disallowed. RFC7230 section 5.4");
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void hostWithoutAuthority_usesHost() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        new Header("host", "example.com:80"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.rstStream(1, ErrorCode.CANCEL);
+    pingPong();
+
+    MockStreamListener streamListener = mockTransportListener.newStreams.pop();
+    assertThat(streamListener.stream.getAuthority()).isEqualTo("example.com:80");
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void authorityAndHost_usesAuthority() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        new Header("host", "example2.com:8080"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.rstStream(1, ErrorCode.CANCEL);
+    pingPong();
+
+    MockStreamListener streamListener = mockTransportListener.newStreams.pop();
+    assertThat(streamListener.stream.getAuthority()).isEqualTo("example.com:80");
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void missingAuthorityAndHost_hasNullAuthority() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.rstStream(1, ErrorCode.CANCEL);
+    pingPong();
+
+    MockStreamListener streamListener = mockTransportListener.newStreams.pop();
+    assertThat(streamListener.stream.getAuthority()).isNull();
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void emptyPath_failsWith404() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, ""),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.flush();
+
+    verifyHttpError(1, 404, Status.Code.UNIMPLEMENTED, "Expected path to start with /: ");
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void nonAbsolutePath_failsWith404() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "https://example.com/"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.flush();
+
+    verifyHttpError(
+        1, 404, Status.Code.UNIMPLEMENTED, "Expected path to start with /: https://example.com/");
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void missingContentType_failsWith415() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        TE_HEADER));
+    clientFrameWriter.flush();
+
+    verifyHttpError(1, 415, Status.Code.INTERNAL, "Content-Type is missing or duplicated");
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void repeatedContentType_failsWith415() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.flush();
+
+    verifyHttpError(1, 415, Status.Code.INTERNAL, "Content-Type is missing or duplicated");
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void textContentType_failsWith415() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        new Header("content-type", "text/plain"),
+        TE_HEADER));
+    clientFrameWriter.flush();
+
+    verifyHttpError(1, 415, Status.Code.INTERNAL, "Content-Type is not supported: text/plain");
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void httpGet_failsWith405() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        new Header(":method", "GET"),
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.flush();
+    List<Header> extraHeaders = Lists.newArrayList(new Header("allow", "POST"));
+    verifyHttpError(1, 405, Status.Code.INTERNAL, "HTTP Method is not supported: GET",
+        extraHeaders);
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void missingTeTrailers_failsWithInternal() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER));
+    clientFrameWriter.flush();
+
+    List<Header> responseHeaders = Arrays.asList(
+        new Header(":status", "200"),
+        new Header("content-type", "application/grpc"),
+        new Header("grpc-status", "" + Status.Code.INTERNAL.value()),
+        new Header("grpc-message", "Expected header TE: trailers, but <missing> is received. "
+          + "Some intermediate proxy may not support trailers"));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead)
+        .headers(false, true, 1, -1, responseHeaders, HeadersMode.HTTP_20_HEADERS);
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).rstStream(1, ErrorCode.NO_ERROR);
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void httpErrorsAdhereToFlowControl() throws Exception {
+    Settings settings = new Settings();
+    OkHttpSettingsUtil.set(settings, OkHttpSettingsUtil.INITIAL_WINDOW_SIZE, 1);
+
+    initTransport();
+    handshake(settings);
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        new Header(":method", "GET"), // Invalid
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER));
+    clientFrameWriter.flush();
+
+    String errorDescription = "HTTP Method is not supported: GET";
+    List<Header> responseHeaders = Arrays.asList(
+        new Header(":status", "405"),
+        new Header("content-type", "text/plain; charset=utf-8"),
+        new Header("grpc-status", "" + Status.Code.INTERNAL.value()),
+        new Header("grpc-message", errorDescription),
+        new Header("allow", "POST"));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead)
+        .headers(false, false, 1, -1, responseHeaders, HeadersMode.HTTP_20_HEADERS);
+
+    Buffer responseDataFrame = new Buffer().writeUtf8(errorDescription.substring(0, 1));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).data(
+        eq(false), eq(1), any(BufferedSource.class), eq((int) responseDataFrame.size()),
+        eq((int) responseDataFrame.size()));
+    verify(clientDataFrames).data(false, 1, responseDataFrame);
+
+    clientFrameWriter.windowUpdate(1, 1000);
+    clientFrameWriter.flush();
+
+    responseDataFrame = new Buffer().writeUtf8(errorDescription.substring(1));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).data(
+        eq(true), eq(1), any(BufferedSource.class), eq((int) responseDataFrame.size()),
+        eq((int) responseDataFrame.size()));
+    verify(clientDataFrames).data(true, 1, responseDataFrame);
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).rstStream(1, ErrorCode.NO_ERROR);
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void windowUpdate() throws Exception {
+    serverBuilder.flowControlWindow(100);
+    initTransport();
+    handshake();
+
+    List<Header> headers = Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER,
+        new Header("some-metadata", "this could be anything"));
+    clientFrameWriter.headers(1, new ArrayList<>(headers));
+    clientFrameWriter.headers(3, new ArrayList<>(headers));
+    String message = "Hello Server Pad Me!"; // length = 20, add buffer length = 5
+    writeDataDirectly(clientWriterSink, FLAG_NONE, 1, message, 0);
+    pingPong();
+
+    MockStreamListener streamListener = mockTransportListener.newStreams.pop();
+    MockStreamListener streamListener2 = mockTransportListener.newStreams.pop();
+    assertThat(streamListener.stream.getAuthority()).isEqualTo("example.com:80");
+    assertThat(streamListener.method).isEqualTo("com.example/SimpleService.doit");
+    assertThat(streamListener.headers.get(
+        Metadata.Key.of("Some-Metadata", Metadata.ASCII_STRING_MARSHALLER)))
+        .isEqualTo("this could be anything");
+    streamListener.stream.request(1);
+    pingPong();
+    assertThat(streamListener.messages.pop()).isEqualTo("Hello Server Pad Me!");
+    streamListener.stream.writeHeaders(metadata("User-Data", "best data"), false);
+    streamListener.stream.writeMessage(new ByteArrayInputStream("Howdy client".getBytes(UTF_8)));
+    List<Header> responseHeaders = Arrays.asList(
+        new Header(":status", "200"),
+        CONTENT_TYPE_HEADER,
+        new Header("user-data", "best data"));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead)
+        .headers(false, false, 1, -1, responseHeaders, HeadersMode.HTTP_20_HEADERS);
+
+    writeDataDirectly(clientWriterSink, FLAG_PADDED, 1, message, 10);
+    writeDataDirectly(clientWriterSink, FLAG_PADDED | FLAG_END_STREAM, 3, message, 40);
+    clientFrameWriter.flush();
+
+    int expectedConsumed = message.length() + 5;
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).windowUpdate(0, expectedConsumed * 2 + 10);
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).windowUpdate(0, expectedConsumed  + 40);
+    streamListener.stream.request(2);
+    streamListener2.stream.request(1);
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).windowUpdate(1, expectedConsumed * 2 + 10);
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).windowUpdate(3, expectedConsumed + 40);
+
+    writeDataDirectly(clientWriterSink, FLAG_PADDED | FLAG_END_STREAM, 1, message, 100);
+    clientFrameWriter.flush();
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).rstStream(eq(1), eq(ErrorCode.FLOW_CONTROL_ERROR));
+    clientFrameWriter.rstStream(3, ErrorCode.CANCEL);
+    pingPong();
+    shutdownAndTerminate(/*lastStreamId=*/ 3);
+  }
+
+  @Test
+  public void dataForStream0_failsWithGoAway() throws Exception {
+    initTransport();
+    handshake();
+
+    Buffer requestMessageFrame = createMessageFrame("Nope");
+    clientFrameWriter.data(true, 0, requestMessageFrame, (int) requestMessageFrame.size());
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).goAway(
+        0, ErrorCode.PROTOCOL_ERROR,
+        ByteString.encodeUtf8("Stream 0 is reserved for control messages. RFC7540 section 5.1.1"));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isFalse();
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+  }
+
+  @Test
+  public void dataForEvenStream_failsWithGoAway() throws Exception {
+    initTransport();
+    handshake();
+
+    Buffer requestMessageFrame = createMessageFrame("Nope");
+    clientFrameWriter.data(true, 2, requestMessageFrame, (int) requestMessageFrame.size());
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).goAway(
+        0, ErrorCode.PROTOCOL_ERROR,
+        ByteString.encodeUtf8("Clients cannot open even numbered streams. RFC7540 section 5.1.1"));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isFalse();
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+  }
+
+  @Test
+  public void dataAfterHalfClose_failsWithRst() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER,
+        new Header("some-metadata", "this could be anything")));
+    Buffer requestMessageFrame = createMessageFrame("Hello server");
+    clientFrameWriter.data(true, 1, requestMessageFrame, (int) requestMessageFrame.size());
+    requestMessageFrame = createMessageFrame("oh, I forgot");
+    clientFrameWriter.data(true, 1, requestMessageFrame, (int) requestMessageFrame.size());
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).rstStream(1, ErrorCode.STREAM_CLOSED);
+    MockStreamListener streamListener = mockTransportListener.newStreams.pop();
+    pingPong();
+    assertThat(streamListener.status).isNotNull();
+    assertThat(streamListener.status.getCode()).isNotEqualTo(Status.Code.OK);
+
+    shutdownAndTerminate(/*lastStreamId=*/ 1);
+  }
+
+  @Test
+  public void pushPromise_failsWithGoAway() throws Exception {
+    initTransport();
+    handshake();
+
+    clientFrameWriter.pushPromise(2, 3, Arrays.asList());
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).goAway(
+        0, ErrorCode.PROTOCOL_ERROR,
+        ByteString.encodeUtf8(
+            "PUSH_PROMISE only allowed on peer-initiated streams. RFC7540 section 6.6"));
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isFalse();
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+  }
+
+  @Test
+  public void channelzStats() throws Exception {
+    serverBuilder.flowControlWindow(60000);
+    initTransport();
+    handshake();
+    clientFrameWriter.windowUpdate(0, 1000); // connection stream id
+    pingPong();
+
+    SocketStats stats = serverTransport.getStats().get();
+    assertThat(stats.data.streamsStarted).isEqualTo(0);
+    assertThat(stats.data.streamsSucceeded).isEqualTo(0);
+    assertThat(stats.data.streamsFailed).isEqualTo(0);
+    assertThat(stats.data.messagesSent).isEqualTo(0);
+    assertThat(stats.data.messagesReceived).isEqualTo(0);
+    assertThat(stats.data.remoteFlowControlWindow).isEqualTo(30000); // Lower bound
+    assertThat(stats.data.localFlowControlWindow).isEqualTo(66535);
+    assertThat(stats.local).isEqualTo(socketPair.server.getLocalSocketAddress());
+    assertThat(stats.remote).isEqualTo(socketPair.server.getRemoteSocketAddress());
+  }
+
+  @Test
+  public void keepAliveEnforcer_enforcesPings() throws Exception {
+    serverBuilder.permitKeepAliveTime(1, TimeUnit.HOURS)
+            .permitKeepAliveWithoutCalls(false);
+    initTransport();
+    handshake();
+
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES; i++) {
+      pingPong();
+    }
+    pingPongId++;
+    clientFrameWriter.ping(false, pingPongId, 0);
+    clientFrameWriter.flush();
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).goAway(0, ErrorCode.ENHANCE_YOUR_CALM,
+        ByteString.encodeString("too_many_pings", GrpcUtil.US_ASCII));
+  }
+
+  @Test
+  public void keepAliveEnforcer_sendingDataResetsCounters() throws Exception {
+    serverBuilder.permitKeepAliveTime(1, TimeUnit.HOURS)
+        .permitKeepAliveWithoutCalls(false);
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER,
+        new Header("some-metadata", "this could be anything")));
+    Buffer requestMessageFrame = createMessageFrame("Hello server");
+    clientFrameWriter.data(false, 1, requestMessageFrame, (int) requestMessageFrame.size());
+    pingPong();
+    MockStreamListener streamListener = mockTransportListener.newStreams.pop();
+
+    streamListener.stream.request(1);
+    pingPong();
+    assertThat(streamListener.messages.pop()).isEqualTo("Hello server");
+
+    streamListener.stream.writeHeaders(metadata("User-Data", "best data"), false);
+    streamListener.stream.writeMessage(new ByteArrayInputStream("Howdy client".getBytes(UTF_8)));
+    streamListener.stream.flush();
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+
+    for (int i = 0; i < 10; i++) {
+      assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+      pingPong();
+      streamListener.stream.writeMessage(new ByteArrayInputStream("Howdy client".getBytes(UTF_8)));
+      streamListener.stream.flush();
+    }
+  }
+
+  @Test
+  public void keepAliveEnforcer_initialIdle() throws Exception {
+    serverBuilder.permitKeepAliveTime(0, TimeUnit.SECONDS)
+        .permitKeepAliveWithoutCalls(false);
+    initTransport();
+    handshake();
+
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES; i++) {
+      pingPong();
+    }
+    pingPongId++;
+    clientFrameWriter.ping(false, pingPongId, 0);
+    clientFrameWriter.flush();
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).goAway(0, ErrorCode.ENHANCE_YOUR_CALM,
+        ByteString.encodeString("too_many_pings", GrpcUtil.US_ASCII));
+  }
+
+  @Test
+  public void keepAliveEnforcer_noticesActive() throws Exception {
+    serverBuilder.permitKeepAliveTime(0, TimeUnit.SECONDS)
+        .permitKeepAliveWithoutCalls(false);
+    initTransport();
+    handshake();
+
+    clientFrameWriter.headers(1, Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService.doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER,
+        new Header("some-metadata", "this could be anything")));
+    for (int i = 0; i < 10; i++) {
+      pingPong();
+    }
+    verify(clientFramesRead, never()).goAway(anyInt(), eq(ErrorCode.ENHANCE_YOUR_CALM),
+        eq(ByteString.encodeString("too_many_pings", GrpcUtil.US_ASCII)));
+  }
+
+  @Test
+  public void keepAliveEnforcer_doesNotEnforcePingAcks() throws Exception {
+    serverBuilder.permitKeepAliveTime(1, TimeUnit.HOURS)
+        .permitKeepAliveWithoutCalls(true);
+    initTransport();
+    handshake();
+
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES + 2; i++) {
+      int serverPingId = 0xDEAD + i;
+      clientFrameWriter.ping(true, serverPingId, 0);
+      clientFrameWriter.flush();
+    }
+
+    for (int i = 0; i < KeepAliveEnforcer.MAX_PING_STRIKES; i++) {
+      pingPong();
+    }
+
+    pingPongId++;
+    clientFrameWriter.ping(false, pingPongId, 0);
+    clientFrameWriter.flush();
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).goAway(0, ErrorCode.ENHANCE_YOUR_CALM,
+        ByteString.encodeString("too_many_pings", GrpcUtil.US_ASCII));
+  }
+
+  @Test
+  public void maxConcurrentCallsPerConnection_failsWithRst() throws Exception {
+    int maxConcurrentCallsPerConnection = 1;
+    serverBuilder.maxConcurrentCallsPerConnection(maxConcurrentCallsPerConnection);
+    initTransport();
+    handshake();
+
+    ArgumentCaptor<Settings> settingsCaptor = ArgumentCaptor.forClass(Settings.class);
+    verify(clientFramesRead).settings(eq(false), settingsCaptor.capture());
+    final Settings settings = settingsCaptor.getValue();
+    assertThat(OkHttpSettingsUtil.get(settings, OkHttpSettingsUtil.MAX_CONCURRENT_STREAMS))
+        .isEqualTo(maxConcurrentCallsPerConnection);
+
+    final List<Header> headers = Arrays.asList(
+        HTTP_SCHEME_HEADER,
+        METHOD_HEADER,
+        new Header(Header.TARGET_AUTHORITY, "example.com:80"),
+        new Header(Header.TARGET_PATH, "/com.example/SimpleService/doit"),
+        CONTENT_TYPE_HEADER,
+        TE_HEADER);
+
+    clientFrameWriter.headers(1, headers);
+    clientFrameWriter.headers(3, headers);
+    clientFrameWriter.flush();
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).rstStream(3, ErrorCode.REFUSED_STREAM);
+  }
+
+  private void initTransport() throws Exception {
+    serverTransport = new OkHttpServerTransport(
+        new OkHttpServerTransport.Config(serverBuilder, Arrays.asList()),
+        socketPair.server);
+    serverTransport.start(transportListener);
+  }
+
+  private void handshake() throws Exception {
+    handshake(new Settings());
+  }
+
+  private void handshake(Settings settings) throws Exception {
+    clientFrameWriter.connectionPreface();
+    clientFrameWriter.settings(settings);
+    clientFrameWriter.flush();
+    clientFrameReader.readConnectionPreface();
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    ArgumentCaptor<Settings> settingsCaptor = ArgumentCaptor.forClass(Settings.class);
+    verify(clientFramesRead).settings(eq(false), settingsCaptor.capture());
+    clientFrameWriter.ackSettings(settingsCaptor.getValue());
+    clientFrameWriter.flush();
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).ackSettings();
+    verify(transportListener, timeout(TIME_OUT_MS)).transportReady(any(Attributes.class));
+  }
+
+  private static Buffer createMessageFrame(String stringMessage) {
+    byte[] message = stringMessage.getBytes(UTF_8);
+    Buffer buffer = new Buffer();
+    buffer.writeByte(0 /* UNCOMPRESSED */);
+    buffer.writeInt(message.length);
+    buffer.write(message);
+    return buffer;
+  }
+
+  private void writeDataDirectly(BufferedSink sink, int flag, int streamId, String message,
+                                 int paddingLength) throws IOException {
+    Buffer buffer = createMessageFrame(message);
+    int bufferLengthWithPadding = (int) buffer.size();
+    if ((flag & FLAG_PADDED) != 0) {
+      bufferLengthWithPadding += paddingLength;
+    }
+    writeLength(sink, bufferLengthWithPadding);
+    sink.writeByte(TYPE_DATA);
+    sink.writeByte(flag & 0xff);
+    sink.writeInt(streamId & 0x7fffffff);
+    if ((flag & FLAG_PADDED) != 0) {
+      sink.writeByte((short)(paddingLength - 1));
+      char[] value = new char[paddingLength - 1];
+      Arrays.fill(value, '!');
+      buffer.write(new String(value).getBytes(UTF_8));
+    }
+    sink.write(buffer, buffer.size());
+  }
+
+  private void writeLength(BufferedSink sink, int length) throws IOException {
+    sink.writeByte((length >>> 16 ) & 0xff);
+    sink.writeByte((length >>> 8 ) & 0xff);
+    sink.writeByte(length & 0xff);
+  }
+
+  private Metadata metadata(String... keysAndValues) {
+    Metadata metadata = new Metadata();
+    assertThat(keysAndValues.length % 2).isEqualTo(0);
+    for (int i = 0; i < keysAndValues.length; i += 2) {
+      metadata.put(
+          Metadata.Key.of(keysAndValues[i], Metadata.ASCII_STRING_MARSHALLER),
+          keysAndValues[i + 1]);
+    }
+    return metadata;
+  }
+
+  private void verifyGracefulShutdown(int lastStreamId)
+      throws IOException {
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).goAway(2147483647, ErrorCode.NO_ERROR, ByteString.EMPTY);
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).ping(false, 0, 0x1111);
+    clientFrameWriter.ping(true, 0, 0x1111);
+    clientFrameWriter.flush();
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).goAway(lastStreamId, ErrorCode.NO_ERROR, ByteString.EMPTY);
+  }
+
+  private void shutdownAndTerminate(int lastStreamId) throws IOException {
+    assertThat(serverTransport.getActiveStreams().length).isEqualTo(0);
+    serverTransport.shutdown();
+    verifyGracefulShutdown(lastStreamId);
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isFalse();
+    verify(transportListener, timeout(TIME_OUT_MS)).transportTerminated();
+  }
+
+  private int pingPongId = 0;
+
+  /** Send a ping and wait for the ping ack. */
+  private void pingPong() throws IOException {
+    pingPongId++;
+    clientFrameWriter.ping(false, pingPongId, 0);
+    clientFrameWriter.flush();
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).ping(true, pingPongId, 0);
+  }
+
+  private void verifyHttpError(
+      int streamId, int httpCode, Status.Code grpcCode, String errorDescription) throws Exception {
+    verifyHttpError(streamId, httpCode, grpcCode, errorDescription, Collections.emptyList());
+  }
+
+  private void verifyHttpError(
+      int streamId, int httpCode, Status.Code grpcCode, String errorDescription,
+      List<Header> extraHeaders) throws Exception {
+    List<Header> responseHeaders = Lists.newArrayList(
+        new Header(":status", "" + httpCode),
+        new Header("content-type", "text/plain; charset=utf-8"),
+        new Header("grpc-status", "" + grpcCode.value()),
+        new Header("grpc-message", errorDescription));
+    responseHeaders.addAll(extraHeaders);
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead)
+        .headers(false, false, streamId, -1, responseHeaders, HeadersMode.HTTP_20_HEADERS);
+
+    Buffer responseDataFrame = new Buffer().writeUtf8(errorDescription);
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).data(
+        eq(true), eq(streamId), any(BufferedSource.class),
+        eq((int) responseDataFrame.size()), eq((int) responseDataFrame.size()));
+    verify(clientDataFrames).data(true, streamId, responseDataFrame);
+
+    assertThat(clientFrameReader.nextFrame(clientFramesRead)).isTrue();
+    verify(clientFramesRead).rstStream(streamId, ErrorCode.NO_ERROR);
+  }
+
+  private static class MockServerTransportListener implements ServerTransportListener {
+    Deque<MockStreamListener> newStreams = new ArrayDeque<>();
+
+    @Override public void streamCreated(ServerStream stream, String method, Metadata headers) {
+      MockStreamListener streamListener = new MockStreamListener(stream, method, headers);
+      stream.setListener(streamListener);
+      newStreams.add(streamListener);
+    }
+
+    @Override public Attributes transportReady(Attributes attributes) {
+      return attributes;
+    }
+
+    @Override public void transportTerminated() {}
+  }
+
+  private static class MockStreamListener implements ServerStreamListener {
+    final ServerStream stream;
+    final String method;
+    final Metadata headers;
+
+    Deque<String> messages = new ArrayDeque<>();
+    boolean halfClosedCalled;
+    Status status;
+    CountDownLatch closed = new CountDownLatch(1);
+
+    MockStreamListener(ServerStream stream, String method, Metadata headers) {
+      this.stream = stream;
+      this.method = method;
+      this.headers = headers;
+    }
+
+    @Override
+    public void messagesAvailable(MessageProducer producer) {
+      InputStream inputStream;
+      while ((inputStream = producer.next()) != null) {
+        try {
+          String msg = getContent(inputStream);
+          if (msg != null) {
+            messages.add(msg);
+          }
+        } catch (IOException ex) {
+          while ((inputStream = producer.next()) != null) {
+            GrpcUtil.closeQuietly(inputStream);
+          }
+          throw new RuntimeException(ex);
+        }
+      }
+    }
+
+    @Override
+    public void halfClosed() {
+      halfClosedCalled = true;
+    }
+
+    @Override
+    public void closed(Status status) {
+      this.status = status;
+      closed.countDown();
+    }
+
+    @Override
+    public void onReady() {
+    }
+
+    static String getContent(InputStream message) throws IOException {
+      try {
+        return new String(ByteStreams.toByteArray(message), UTF_8);
+      } finally {
+        message.close();
+      }
+    }
+  }
+
+  private static class SocketPair {
+    public final Socket client;
+    public final Socket server;
+
+    public SocketPair(Socket client, Socket server) {
+      this.client = client;
+      this.server = server;
+    }
+
+    public InputStream getClientInputStream() {
+      try {
+        return client.getInputStream();
+      } catch (IOException ex) {
+        throw new RuntimeException(ex);
+      }
+    }
+
+    public OutputStream getClientOutputStream() {
+      try {
+        return client.getOutputStream();
+      } catch (IOException ex) {
+        throw new RuntimeException(ex);
+      }
+    }
+
+    public static SocketPair create(ExecutorService threadPool) {
+      try {
+        try (ServerSocket serverSocket = new ServerSocket(0)) {
+          Future<Socket> serverFuture = threadPool.submit(() -> serverSocket.accept());
+          Socket client = new Socket();
+          client.connect(serverSocket.getLocalSocketAddress());
+          Socket server = serverFuture.get();
+          return new SocketPair(client, server);
+        }
+      } catch (Exception ex) {
+        throw new RuntimeException(ex);
+      }
+    }
+  }
+
+  private interface DataFrameHandler {
+    void data(boolean inFinished, int streamId, Buffer payload);
+  }
+}
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpTlsUpgraderTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpTlsUpgraderTest.java
index f68740793d8..6346ab8e8fc 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpTlsUpgraderTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpTlsUpgraderTest.java
@@ -1,39 +1,24 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
-import static org.junit.Assert.assertTrue;
+import static io.grpc.okhttp.OkHttpTlsUpgrader.canonicalizeHost;
+import static org.junit.Assert.assertEquals;
 
-import io.grpc.okhttp.internal.Protocol;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -41,10 +26,14 @@
 /** Unit tests for {@link io.grpc.okhttp.OkHttpTlsUpgrader}. */
 @RunWith(JUnit4.class)
 public class OkHttpTlsUpgraderTest {
-  @Test public void upgrade_grpcExp() {
-    assertTrue(
-        OkHttpTlsUpgrader.TLS_PROTOCOLS.indexOf(Protocol.GRPC_EXP) == -1
-            || OkHttpTlsUpgrader.TLS_PROTOCOLS.indexOf(Protocol.GRPC_EXP)
-                < OkHttpTlsUpgrader.TLS_PROTOCOLS.indexOf(Protocol.HTTP_2));
+
+  @Test public void canonicalizeHosts() {
+    assertEquals("::1", canonicalizeHost("::1"));
+    assertEquals("::1", canonicalizeHost("[::1]"));
+    assertEquals("127.0.0.1", canonicalizeHost("127.0.0.1"));
+    assertEquals("some.long.url.com", canonicalizeHost("some.long.url.com"));
+
+    // Extra square brackets in a malformed URI are retained
+    assertEquals("[::1]", canonicalizeHost("[[::1]]"));
   }
 }
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpTransportTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpTransportTest.java
index db918392db3..076eea3349a 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpTransportTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpTransportTest.java
@@ -1,57 +1,48 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
-import io.grpc.internal.AccessProtectedHack;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.AbstractTransportTest;
 import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GrpcUtil;
 import io.grpc.internal.InternalServer;
 import io.grpc.internal.ManagedClientTransport;
-import io.grpc.internal.testing.AbstractTransportTest;
-import io.grpc.netty.NettyServerBuilder;
 import java.net.InetSocketAddress;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
 import org.junit.After;
-import org.junit.Ignore;
-import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
 /** Unit tests for OkHttp transport. */
 @RunWith(JUnit4.class)
 public class OkHttpTransportTest extends AbstractTransportTest {
-  private ClientTransportFactory clientFactory = OkHttpChannelBuilder
-      // Although specified here, address is ignored because we never call build.
-      .forAddress("127.0.0.1", 0)
-      .negotiationType(NegotiationType.PLAINTEXT)
-      .buildTransportFactory();
+  private final FakeClock fakeClock = new FakeClock();
+  private ClientTransportFactory clientFactory =
+      OkHttpChannelBuilder
+          // Although specified here, address is ignored because we never call build.
+          .forAddress("localhost", 0)
+          .usePlaintext()
+          .setTransportTracerFactory(fakeClockTransportTracer)
+          .maxInboundMetadataSize(GrpcUtil.DEFAULT_MAX_HEADER_LIST_SIZE)
+          .buildTransportFactory();
 
   @After
   public void releaseClientFactory() {
@@ -59,39 +50,49 @@ public void releaseClientFactory() {
   }
 
   @Override
-  protected InternalServer newServer() {
-    return AccessProtectedHack.serverBuilderBuildTransportServer(
-        NettyServerBuilder
-          .forPort(0)
-          .flowControlWindow(65 * 1024));
+  protected InternalServer newServer(
+      List<ServerStreamTracer.Factory> streamTracerFactories) {
+    return newServer(0, streamTracerFactories);
   }
 
   @Override
-  protected InternalServer newServer(InternalServer server) {
-    int port = server.getPort();
-    return AccessProtectedHack.serverBuilderBuildTransportServer(
-        NettyServerBuilder
-            .forPort(port)
-            .flowControlWindow(65 * 1024));
+  protected InternalServer newServer(
+      int port, List<ServerStreamTracer.Factory> streamTracerFactories) {
+    return OkHttpServerBuilder
+        .forPort(port, InsecureServerCredentials.create())
+        .flowControlWindow(AbstractTransportTest.TEST_FLOW_CONTROL_WINDOW)
+        .setTransportTracerFactory(fakeClockTransportTracer)
+        .buildTransportServers(streamTracerFactories);
   }
 
   @Override
   protected String testAuthority(InternalServer server) {
-    return "127.0.0.1:" + server.getPort();
+    return "thebestauthority:" + server.getListenSocketAddress();
   }
 
   @Override
   protected ManagedClientTransport newClientTransport(InternalServer server) {
-    int port = server.getPort();
+    int port = ((InetSocketAddress) server.getListenSocketAddress()).getPort();
     return clientFactory.newClientTransport(
-        new InetSocketAddress("127.0.0.1", port),
-        testAuthority(server),
-        null /* agent */);
+        new InetSocketAddress("localhost", port),
+        new ClientTransportFactory.ClientTransportOptions()
+          .setAuthority(testAuthority(server))
+          .setEagAttributes(eagAttrs()),
+        transportLogger());
+  }
+
+  @Override
+  protected void advanceClock(long offset, TimeUnit unit) {
+    fakeClock.forwardNanos(unit.toNanos(offset));
   }
 
-  // TODO(ejona): Flaky/Broken
-  @Test
-  @Ignore
   @Override
-  public void flowControlPushBack() {}
+  protected long fakeCurrentTimeNanos() {
+    return fakeClock.getTicker().read();
+  }
+
+  @Override
+  protected boolean haveTransportTracer() {
+    return true;
+  }
 }
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpWritableBufferAllocatorTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpWritableBufferAllocatorTest.java
index 10576488470..c19224822a8 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpWritableBufferAllocatorTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpWritableBufferAllocatorTest.java
@@ -1,41 +1,28 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
+import static io.grpc.okhttp.OkHttpWritableBufferAllocator.SEGMENT_SIZE_COPY;
 import static org.junit.Assert.assertEquals;
 
 import io.grpc.internal.WritableBuffer;
 import io.grpc.internal.WritableBufferAllocator;
 import io.grpc.internal.WritableBufferAllocatorTestBase;
+import okio.Segment;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -53,11 +40,12 @@ protected WritableBufferAllocator allocator() {
     return allocator;
   }
 
+  @SuppressWarnings("KotlinInternal")
   @Test
   public void testCapacity() {
     WritableBuffer buffer = allocator().allocate(4096);
     assertEquals(0, buffer.readableBytes());
-    assertEquals(4096, buffer.writableBytes());
+    assertEquals(SEGMENT_SIZE_COPY, buffer.writableBytes());
   }
 
   @Test
@@ -69,8 +57,14 @@ public void testInitialCapacityHasMaximum() {
 
   @Test
   public void testIsExactBelowMaxCapacity() {
-    WritableBuffer buffer = allocator().allocate(4097);
+    WritableBuffer buffer = allocator().allocate(SEGMENT_SIZE_COPY + 1);
     assertEquals(0, buffer.readableBytes());
-    assertEquals(4097, buffer.writableBytes());
+    assertEquals(SEGMENT_SIZE_COPY * 2, buffer.writableBytes());
+  }
+
+  @SuppressWarnings("KotlinInternal")
+  @Test
+  public void testSegmentSizeMatchesKotlin() {
+    assertEquals(Segment.SIZE, SEGMENT_SIZE_COPY);
   }
 }
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OkHttpWritableBufferTest.java b/okhttp/src/test/java/io/grpc/okhttp/OkHttpWritableBufferTest.java
index 6160cc38e5f..98b7703a06d 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/OkHttpWritableBufferTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/OkHttpWritableBufferTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
diff --git a/okhttp/src/test/java/io/grpc/okhttp/OptionalMethodTest.java b/okhttp/src/test/java/io/grpc/okhttp/OptionalMethodTest.java
new file mode 100644
index 00000000000..dedf6bc8e44
--- /dev/null
+++ b/okhttp/src/test/java/io/grpc/okhttp/OptionalMethodTest.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2017 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.okhttp;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import io.grpc.okhttp.internal.OptionalMethod;
+import java.lang.reflect.InvocationTargetException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for OptionalMethod.
+ */
+@RunWith(JUnit4.class)
+public class OptionalMethodTest {
+
+  public static class DefaultClass {
+    public String testMethod(String arg) {
+      return arg;
+    }
+  }
+
+  public abstract static class PublicParent {
+    public abstract String testMethod(String arg);
+  }
+
+  private static class PrivateImpl extends PublicParent {
+    @Override
+    public String testMethod(String arg) {
+      return arg;
+    }
+  }
+
+  private static class PrivateClass {
+    @SuppressWarnings("UnusedMethod")
+    public String testMethod(String arg) {
+      return arg;
+    }
+  }
+
+  @Test
+  public void isSupported() {
+    OptionalMethod<DefaultClass> defaultClassMethod = new OptionalMethod<>(
+        String.class, "testMethod", String.class);
+    assertTrue(defaultClassMethod.isSupported(new DefaultClass()));
+
+    OptionalMethod<PublicParent> privateImpl = new OptionalMethod<>(
+        String.class, "testMethod", String.class);
+    assertTrue(privateImpl.isSupported(new PrivateImpl()));
+
+    OptionalMethod<PrivateClass> privateClass = new OptionalMethod<>(
+        String.class, "testMethod", String.class);
+    assertFalse(privateClass.isSupported(new PrivateClass()));
+  }
+
+  @Test
+  public void invokeOptional() throws InvocationTargetException {
+    OptionalMethod<DefaultClass> defaultClassMethod = new OptionalMethod<>(
+        String.class, "testMethod", String.class);
+    assertEquals("testArg", defaultClassMethod.invokeOptional(new DefaultClass(), "testArg"));
+
+    OptionalMethod<PublicParent> privateImpl = new OptionalMethod<>(
+        String.class, "testMethod", String.class);
+    assertEquals("testArg", privateImpl.invokeOptional(new PrivateImpl(), "testArg"));
+
+    OptionalMethod<PrivateClass> privateClass = new OptionalMethod<>(
+        String.class, "testMethod", String.class);
+    assertEquals(null, privateClass.invokeOptional(new PrivateClass(), "testArg"));
+  }
+}
diff --git a/okhttp/src/test/java/io/grpc/okhttp/SslSocketFactoryChannelCredentialsTest.java b/okhttp/src/test/java/io/grpc/okhttp/SslSocketFactoryChannelCredentialsTest.java
new file mode 100644
index 00000000000..2e87b5af715
--- /dev/null
+++ b/okhttp/src/test/java/io/grpc/okhttp/SslSocketFactoryChannelCredentialsTest.java
@@ -0,0 +1,37 @@
+/*
+ * 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.okhttp;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.ChannelCredentials;
+import javax.net.ssl.SSLSocketFactory;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link SslSocketFactoryChannelCredentials}. */
+@RunWith(JUnit4.class)
+public class SslSocketFactoryChannelCredentialsTest {
+  @Test
+  public void withoutBearTokenGivesItself() {
+    ChannelCredentials sslSocketFactoryCreds =
+        SslSocketFactoryChannelCredentials.create(mock(SSLSocketFactory.class));
+    assertThat(sslSocketFactoryCreds.withoutBearerTokens()).isEqualTo(sslSocketFactoryCreds);
+  }
+}
diff --git a/okhttp/src/test/java/io/grpc/okhttp/TlsTest.java b/okhttp/src/test/java/io/grpc/okhttp/TlsTest.java
new file mode 100644
index 00000000000..20a2f1a5ca7
--- /dev/null
+++ b/okhttp/src/test/java/io/grpc/okhttp/TlsTest.java
@@ -0,0 +1,791 @@
+/*
+ * Copyright 2015 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.okhttp;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static org.junit.Assert.fail;
+
+import com.google.common.base.Throwables;
+import io.grpc.CallOptions;
+import io.grpc.ChannelCredentials;
+import io.grpc.ConnectivityState;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Server;
+import io.grpc.ServerCredentials;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.TlsServerCredentials;
+import io.grpc.internal.testing.TestUtils;
+import io.grpc.okhttp.internal.Platform;
+import io.grpc.stub.ClientCalls;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.TlsTesting;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import io.grpc.util.CertificateUtils;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.Socket;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.Arrays;
+import java.util.Optional;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509ExtendedTrustManager;
+import javax.net.ssl.X509TrustManager;
+import javax.security.auth.x500.X500Principal;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+import org.junit.Assume;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Verify OkHttp's TLS integration. */
+@RunWith(JUnit4.class)
+@IgnoreJRERequirement
+public class TlsTest {
+  @Rule
+  public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
+
+  @Before
+  public void checkForAlpnApi() throws Exception {
+    // This checks for the "Java 9 ALPN API" which was backported to Java 8u252. The Kokoro Windows
+    // CI is on too old of a JDK for us to assume this is available.
+    SSLContext context = SSLContext.getInstance("TLS");
+    context.init(null, null, null);
+    SSLEngine engine = context.createSSLEngine();
+    try {
+      SSLEngine.class.getMethod("getApplicationProtocol").invoke(engine);
+    } catch (NoSuchMethodException | UnsupportedOperationException ex) {
+      Assume.assumeNoException(ex);
+    }
+  }
+
+  @Test
+  public void basicTls_succeeds() throws Exception {
+    ServerCredentials serverCreds;
+    try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+         InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+      serverCreds = TlsServerCredentials.newBuilder()
+          .keyManager(serverCert, serverPrivateKey)
+          .build();
+    }
+    ChannelCredentials channelCreds;
+    try (InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+      channelCreds = TlsChannelCredentials.newBuilder()
+          .trustManager(caCert)
+          .build();
+    }
+    Server server = grpcCleanupRule.register(server(serverCreds));
+    ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+    SimpleServiceGrpc.newBlockingStub(channel).unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+
+  @Test
+  public void perRpcAuthorityOverride_hostnameVerifier_goodAuthority_succeeds() throws Exception {
+    OkHttpClientTransport.enablePerRpcAuthorityCheck = true;
+    try {
+      ServerCredentials serverCreds;
+      try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+           InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+        serverCreds = TlsServerCredentials.newBuilder()
+                .keyManager(serverCert, serverPrivateKey)
+                .build();
+      }
+      ChannelCredentials channelCreds;
+      try (InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+        channelCreds = TlsChannelCredentials.newBuilder()
+            .trustManager(caCert)
+            .build();
+      }
+      Server server = grpcCleanupRule.register(server(serverCreds));
+      ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+      ClientCalls.blockingUnaryCall(channel, SimpleServiceGrpc.getUnaryRpcMethod(),
+              CallOptions.DEFAULT.withAuthority("good.test.google.fr"),
+              SimpleRequest.getDefaultInstance());
+    } finally {
+      OkHttpClientTransport.enablePerRpcAuthorityCheck = false;
+    }
+  }
+
+  @Test
+  public void perRpcAuthorityOverride_hostnameVerifier_badAuthority_fails()
+          throws Exception {
+    OkHttpClientTransport.enablePerRpcAuthorityCheck = true;
+    try {
+      ServerCredentials serverCreds;
+      try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+           InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+        serverCreds = TlsServerCredentials.newBuilder()
+                .keyManager(serverCert, serverPrivateKey)
+                .build();
+      }
+      ChannelCredentials channelCreds;
+      try (InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+        channelCreds = TlsChannelCredentials.newBuilder()
+            .trustManager(caCert)
+            .build();
+      }
+      Server server = grpcCleanupRule.register(server(serverCreds));
+      ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+      try {
+        ClientCalls.blockingUnaryCall(channel, SimpleServiceGrpc.getUnaryRpcMethod(),
+              CallOptions.DEFAULT.withAuthority("disallowed.name.com"),
+              SimpleRequest.getDefaultInstance());
+        fail("Expected exception for hostname verifier failure.");
+      } catch (StatusRuntimeException ex) {
+        assertThat(ex.getStatus().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+        assertThat(ex.getStatus().getDescription()).isEqualTo(
+                "HostNameVerifier verification failed for authority 'disallowed.name.com'");
+      }
+    } finally {
+      OkHttpClientTransport.enablePerRpcAuthorityCheck = false;
+    }
+  }
+
+  @Test
+  public void perRpcAuthorityOverride_hostnameVerifier_badAuthority_flagDisabled_succeeds()
+          throws Exception {
+    ServerCredentials serverCreds;
+    try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+         InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+      serverCreds = TlsServerCredentials.newBuilder()
+              .keyManager(serverCert, serverPrivateKey)
+              .build();
+    }
+    ChannelCredentials channelCreds;
+    try (InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+      channelCreds = TlsChannelCredentials.newBuilder()
+          .trustManager(caCert)
+          .build();
+    }
+    Server server = grpcCleanupRule.register(server(serverCreds));
+    ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+    ClientCalls.blockingUnaryCall(channel, SimpleServiceGrpc.getUnaryRpcMethod(),
+            CallOptions.DEFAULT.withAuthority("disallowed.name.com"),
+            SimpleRequest.getDefaultInstance());
+  }
+
+  @Test
+  public void perRpcAuthorityOverride_noTlsCredentialsUsedToBuildChannel_fails() throws Exception {
+    OkHttpClientTransport.enablePerRpcAuthorityCheck = true;
+    try {
+      ServerCredentials serverCreds;
+      try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+           InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+        serverCreds = TlsServerCredentials.newBuilder()
+                .keyManager(serverCert, serverPrivateKey)
+                .build();
+      }
+      Server server = grpcCleanupRule.register(server(serverCreds));
+      SSLSocketFactory sslSocketFactory = TestUtils.newSslSocketFactoryForCa(
+              Platform.get().getProvider(), TestUtils.loadCert("ca.pem"));
+      ManagedChannel channel = grpcCleanupRule.register(
+              OkHttpChannelBuilder.forAddress("localhost", server.getPort())
+                      .overrideAuthority(TestUtils.TEST_SERVER_HOST)
+                      .directExecutor()
+                      .sslSocketFactory(sslSocketFactory)
+                      .build());
+
+      try {
+        ClientCalls.blockingUnaryCall(channel, SimpleServiceGrpc.getUnaryRpcMethod(),
+            CallOptions.DEFAULT.withAuthority("bar.test.google.fr"),
+            SimpleRequest.getDefaultInstance());
+        fail("Expected exception for authority verification failure.");
+      } catch (StatusRuntimeException ex) {
+        assertThat(ex.getStatus().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+        assertThat(ex.getStatus().getDescription()).isEqualTo(
+                "Could not verify authority 'bar.test.google.fr' for the rpc with no "
+                        + "X509TrustManager available");
+      }
+    } finally {
+      OkHttpClientTransport.enablePerRpcAuthorityCheck = false;
+    }
+  }
+
+  @Test
+  public void perRpcAuthorityOverride_trustManager_permitted_succeeds() throws Exception {
+    OkHttpClientTransport.enablePerRpcAuthorityCheck = true;
+    try {
+      ServerCredentials serverCreds;
+      try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+           InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+        serverCreds = TlsServerCredentials.newBuilder()
+                .keyManager(serverCert, serverPrivateKey)
+                .build();
+      }
+      ChannelCredentials channelCreds;
+      try (InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+        X509ExtendedTrustManager regularTrustManager =
+                (X509ExtendedTrustManager) getX509ExtendedTrustManager(caCert).get();
+        channelCreds = TlsChannelCredentials.newBuilder()
+                .trustManager(new HostnameCheckingX509ExtendedTrustManager(regularTrustManager))
+                .build();
+      }
+      Server server = grpcCleanupRule.register(server(serverCreds));
+      ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+      ClientCalls.blockingUnaryCall(channel, SimpleServiceGrpc.getUnaryRpcMethod(),
+              CallOptions.DEFAULT.withAuthority("good.test.google.fr"),
+              SimpleRequest.getDefaultInstance());
+    } finally {
+      OkHttpClientTransport.enablePerRpcAuthorityCheck = false;
+    }
+  }
+
+  @Test
+  public void perRpcAuthorityOverride_trustManager_denied_fails() throws Exception {
+    OkHttpClientTransport.enablePerRpcAuthorityCheck = true;
+    try {
+      ServerCredentials serverCreds;
+      try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+           InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+        serverCreds = TlsServerCredentials.newBuilder()
+                .keyManager(serverCert, serverPrivateKey)
+                .build();
+      }
+      ChannelCredentials channelCreds;
+      try (InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+        X509ExtendedTrustManager regularTrustManager =
+                (X509ExtendedTrustManager) getX509ExtendedTrustManager(caCert).get();
+        channelCreds = TlsChannelCredentials.newBuilder()
+                .trustManager(new HostnameCheckingX509ExtendedTrustManager(regularTrustManager))
+                .build();
+      }
+      Server server = grpcCleanupRule.register(server(serverCreds));
+      ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+      try {
+        ClientCalls.blockingUnaryCall(channel, SimpleServiceGrpc.getUnaryRpcMethod(),
+                CallOptions.DEFAULT.withAuthority("bad.test.google.fr"),
+                SimpleRequest.getDefaultInstance());
+        fail("Expected exception for authority verification failure.");
+      } catch (StatusRuntimeException ex) {
+        assertThat(ex.getStatus().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+        assertThat(ex.getCause().getCause()).isInstanceOf(CertificateException.class);
+      }
+    } finally {
+      OkHttpClientTransport.enablePerRpcAuthorityCheck = false;
+    }
+  }
+
+  @Test
+  public void perRpcAuthorityOverride_trustManager_denied_flagDisabled_succeeds()
+          throws Exception {
+    ServerCredentials serverCreds;
+    try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+         InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+      serverCreds = TlsServerCredentials.newBuilder()
+              .keyManager(serverCert, serverPrivateKey)
+              .build();
+    }
+    ChannelCredentials channelCreds;
+    try (InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+      X509ExtendedTrustManager regularTrustManager =
+              (X509ExtendedTrustManager) getX509ExtendedTrustManager(caCert).get();
+      channelCreds = TlsChannelCredentials.newBuilder()
+              .trustManager(new HostnameCheckingX509ExtendedTrustManager(regularTrustManager))
+              .build();
+    }
+    Server server = grpcCleanupRule.register(server(serverCreds));
+    ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+    ClientCalls.blockingUnaryCall(channel, SimpleServiceGrpc.getUnaryRpcMethod(),
+            CallOptions.DEFAULT.withAuthority("bad.test.google.fr"),
+            SimpleRequest.getDefaultInstance());
+  }
+
+  /**
+   * This test simulates the absence of X509ExtendedTrustManager while still using the
+   * real trust manager for the connection handshake to happen. When the TrustManager is not an
+   * X509ExtendedTrustManager, the per-rpc check ignores the trust manager. However, the
+   * HostnameVerifier is still used, so only valid authorities are permitted.
+   */
+  @Test
+  public void perRpcAuthorityOverride_notX509ExtendedTrustManager_goodAuthority_succeeds()
+          throws Exception {
+    OkHttpClientTransport.enablePerRpcAuthorityCheck = true;
+    try {
+      ServerCredentials serverCreds;
+      try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+           InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+        serverCreds = TlsServerCredentials.newBuilder()
+                .keyManager(serverCert, serverPrivateKey)
+                .build();
+      }
+      ChannelCredentials channelCreds;
+      try (InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+        X509TrustManager x509ExtendedTrustManager =
+                (X509TrustManager) getX509ExtendedTrustManager(caCert).get();
+        channelCreds = TlsChannelCredentials.newBuilder()
+                .trustManager(new FakeTrustManager(x509ExtendedTrustManager))
+                .build();
+      }
+      Server server = grpcCleanupRule.register(server(serverCreds));
+      ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+      ClientCalls.blockingUnaryCall(channel, SimpleServiceGrpc.getUnaryRpcMethod(),
+              CallOptions.DEFAULT.withAuthority("foo.test.google.fr"),
+              SimpleRequest.getDefaultInstance());
+    } finally {
+      OkHttpClientTransport.enablePerRpcAuthorityCheck = false;
+    }
+  }
+
+  @Test
+  public void perRpcAuthorityOverride_notX509ExtendedTrustManager_badAuthority_fails()
+          throws Exception {
+    OkHttpClientTransport.enablePerRpcAuthorityCheck = true;
+    try {
+      ServerCredentials serverCreds;
+      try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+           InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+        serverCreds = TlsServerCredentials.newBuilder()
+                .keyManager(serverCert, serverPrivateKey)
+                .build();
+      }
+      ChannelCredentials channelCreds;
+      try (InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+        X509TrustManager x509ExtendedTrustManager =
+                (X509TrustManager) getX509ExtendedTrustManager(caCert).get();
+        channelCreds = TlsChannelCredentials.newBuilder()
+                .trustManager(new FakeTrustManager(x509ExtendedTrustManager))
+                .build();
+      }
+      Server server = grpcCleanupRule.register(server(serverCreds));
+      ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+      try {
+        ClientCalls.blockingUnaryCall(channel, SimpleServiceGrpc.getUnaryRpcMethod(),
+                CallOptions.DEFAULT.withAuthority("disallowed.name.com"),
+                SimpleRequest.getDefaultInstance());
+        fail("Expected exception for authority verification failure.");
+      } catch (StatusRuntimeException ex) {
+        assertThat(ex.getStatus().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+        assertThat(ex.getStatus().getDescription())
+            .isEqualTo("HostNameVerifier verification failed for authority 'disallowed.name.com'");
+      }
+    } finally {
+      OkHttpClientTransport.enablePerRpcAuthorityCheck = false;
+    }
+  }
+
+  @Test
+  public void
+      perRpcAuthorityOverride_notX509ExtendedTrustManager_badAuthority_flagDisabled_succeeds()
+      throws Exception {
+    ServerCredentials serverCreds;
+    try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+         InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+      serverCreds = TlsServerCredentials.newBuilder()
+              .keyManager(serverCert, serverPrivateKey)
+              .build();
+    }
+    ChannelCredentials channelCreds;
+    try (InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+      X509TrustManager x509ExtendedTrustManager =
+              (X509TrustManager) getX509ExtendedTrustManager(caCert).get();
+      channelCreds = TlsChannelCredentials.newBuilder()
+              .trustManager(new FakeTrustManager(x509ExtendedTrustManager))
+              .build();
+    }
+    Server server = grpcCleanupRule.register(server(serverCreds));
+    ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+    ClientCalls.blockingUnaryCall(channel, SimpleServiceGrpc.getUnaryRpcMethod(),
+            CallOptions.DEFAULT.withAuthority("disallowed.name.com"),
+            SimpleRequest.getDefaultInstance());
+  }
+
+  @Test
+  public void mtls_succeeds() throws Exception {
+    ServerCredentials serverCreds;
+    try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+         InputStream serverPrivateKey = TlsTesting.loadCert("server1.key");
+         InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+      serverCreds = TlsServerCredentials.newBuilder()
+          .keyManager(serverCert, serverPrivateKey)
+          .trustManager(caCert)
+          .clientAuth(TlsServerCredentials.ClientAuth.REQUIRE)
+          .build();
+    }
+    ChannelCredentials channelCreds;
+    try (InputStream clientCertChain = TlsTesting.loadCert("client.pem");
+         InputStream clientPrivateKey = TlsTesting.loadCert("client.key");
+         InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+      channelCreds = TlsChannelCredentials.newBuilder()
+          .keyManager(clientCertChain, clientPrivateKey)
+          .trustManager(caCert)
+          .build();
+    }
+    Server server = grpcCleanupRule.register(server(serverCreds));
+    ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+    SimpleServiceGrpc.newBlockingStub(channel).unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+
+  @Test
+  public void untrustedClient_fails() throws Exception {
+    ServerCredentials serverCreds;
+    try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+         InputStream serverPrivateKey = TlsTesting.loadCert("server1.key");
+         InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+      serverCreds = TlsServerCredentials.newBuilder()
+          .keyManager(serverCert, serverPrivateKey)
+          .trustManager(caCert)
+          .clientAuth(TlsServerCredentials.ClientAuth.REQUIRE)
+          .build();
+    }
+    ChannelCredentials channelCreds;
+    try (InputStream clientCertChain = TlsTesting.loadCert("badclient.pem");
+         InputStream clientPrivateKey = TlsTesting.loadCert("badclient.key");
+         InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+      channelCreds = TlsChannelCredentials.newBuilder()
+          .keyManager(clientCertChain, clientPrivateKey)
+          .trustManager(caCert)
+          .build();
+    }
+    Server server = grpcCleanupRule.register(server(serverCreds));
+    ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+    assertRpcFails(channel);
+  }
+
+  @Test
+  public void missingOptionalClientCert_succeeds() throws Exception {
+    ServerCredentials serverCreds;
+    try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+         InputStream serverPrivateKey = TlsTesting.loadCert("server1.key");
+         InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+      serverCreds = TlsServerCredentials.newBuilder()
+          .keyManager(serverCert, serverPrivateKey)
+          .trustManager(caCert)
+          .clientAuth(TlsServerCredentials.ClientAuth.OPTIONAL)
+          .build();
+    }
+    ChannelCredentials channelCreds;
+    try (InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+      channelCreds = TlsChannelCredentials.newBuilder()
+          .trustManager(caCert)
+          .build();
+    }
+    Server server = grpcCleanupRule.register(server(serverCreds));
+    ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+    SimpleServiceGrpc.newBlockingStub(channel).unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+
+  @Test
+  public void missingRequiredClientCert_fails() throws Exception {
+    ServerCredentials serverCreds;
+    try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+         InputStream serverPrivateKey = TlsTesting.loadCert("server1.key");
+         InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+      serverCreds = TlsServerCredentials.newBuilder()
+          .keyManager(serverCert, serverPrivateKey)
+          .trustManager(caCert)
+          .clientAuth(TlsServerCredentials.ClientAuth.REQUIRE)
+          .build();
+    }
+    ChannelCredentials channelCreds;
+    try (InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+      channelCreds = TlsChannelCredentials.newBuilder()
+          .trustManager(caCert)
+          .build();
+    }
+    Server server = grpcCleanupRule.register(server(serverCreds));
+    ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+    assertRpcFails(channel);
+  }
+
+  @Test
+  public void untrustedServer_fails() throws Exception {
+    ServerCredentials serverCreds;
+    try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+         InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+      serverCreds = TlsServerCredentials.newBuilder()
+          .keyManager(serverCert, serverPrivateKey)
+          .build();
+    }
+    ChannelCredentials channelCreds = TlsChannelCredentials.create();
+    Server server = grpcCleanupRule.register(server(serverCreds));
+    ManagedChannel channel = grpcCleanupRule.register(clientChannel(server, channelCreds));
+
+    assertRpcFails(channel);
+  }
+
+  @Test
+  public void unmatchedServerSubjectAlternativeNames_fails() throws Exception {
+    ServerCredentials serverCreds;
+    try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+         InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+      serverCreds = TlsServerCredentials.newBuilder()
+          .keyManager(serverCert, serverPrivateKey)
+          .build();
+    }
+    ChannelCredentials channelCreds;
+    try (InputStream caCert = TlsTesting.loadCert("ca.pem")) {
+      channelCreds = TlsChannelCredentials.newBuilder()
+          .trustManager(caCert)
+          .build();
+    }
+    Server server = grpcCleanupRule.register(server(serverCreds));
+    ManagedChannel channel = grpcCleanupRule.register(clientChannelBuilder(server, channelCreds)
+        .overrideAuthority("notgonnamatch.example.com")
+        .build());
+
+    assertRpcFails(channel);
+  }
+
+  @Test
+  public void hostnameVerifierTrusts_succeeds()
+      throws Exception {
+    ServerCredentials serverCreds;
+    try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+         InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+      serverCreds = TlsServerCredentials.newBuilder()
+          .keyManager(serverCert, serverPrivateKey)
+          .build();
+    }
+    SSLSocketFactory sslSocketFactory = TestUtils.newSslSocketFactoryForCa(
+        Platform.get().getProvider(), TestUtils.loadCert("ca.pem"));
+    Server server = grpcCleanupRule.register(server(serverCreds));
+    ManagedChannel channel = grpcCleanupRule.register(
+        OkHttpChannelBuilder.forAddress("localhost", server.getPort())
+          .directExecutor()
+          .overrideAuthority("notgonnamatch.example.com")
+          .sslSocketFactory(sslSocketFactory)
+          .hostnameVerifier((hostname, session) -> true)
+          .build());
+
+    SimpleServiceGrpc.newBlockingStub(channel).unaryRpc(SimpleRequest.getDefaultInstance());
+  }
+
+  @Test
+  public void hostnameVerifierFails_fails()
+      throws Exception {
+    ServerCredentials serverCreds;
+    try (InputStream serverCert = TlsTesting.loadCert("server1.pem");
+         InputStream serverPrivateKey = TlsTesting.loadCert("server1.key")) {
+      serverCreds = TlsServerCredentials.newBuilder()
+          .keyManager(serverCert, serverPrivateKey)
+          .build();
+    }
+    SSLSocketFactory sslSocketFactory = TestUtils.newSslSocketFactoryForCa(
+        Platform.get().getProvider(), TestUtils.loadCert("ca.pem"));
+    Server server = grpcCleanupRule.register(server(serverCreds));
+    ManagedChannel channel = grpcCleanupRule.register(
+        OkHttpChannelBuilder.forAddress("localhost", server.getPort())
+          .directExecutor()
+          .overrideAuthority(TestUtils.TEST_SERVER_HOST)
+          .sslSocketFactory(sslSocketFactory)
+          .hostnameVerifier((hostname, session) -> false)
+          .build());
+
+    Status status = assertRpcFails(channel);
+    assertThat(status.getCause()).isInstanceOf(SSLPeerUnverifiedException.class);
+  }
+
+  /** Used to simulate the case of X509ExtendedTrustManager not present. */
+  private static class FakeTrustManager implements X509TrustManager {
+
+    private final X509TrustManager delegate;
+
+    public FakeTrustManager(X509TrustManager x509ExtendedTrustManager) {
+      this.delegate = x509ExtendedTrustManager;
+    }
+
+    @Override
+    public void checkClientTrusted(X509Certificate[] x509Certificates, String s)
+            throws CertificateException {
+      delegate.checkClientTrusted(x509Certificates, s);
+    }
+
+    @Override
+    public void checkServerTrusted(X509Certificate[] x509Certificates, String s)
+            throws CertificateException {
+      delegate.checkServerTrusted(x509Certificates, s);
+    }
+
+    @Override
+    public X509Certificate[] getAcceptedIssuers() {
+      return delegate.getAcceptedIssuers();
+    }
+  }
+
+  /**
+   * Checks against a limited set of hostnames. In production, EndpointIdentificationAlgorithm is
+   * unset so the default trust manager will not fail based on the hostname. This class is used to
+   * test user-provided trust managers that may have their own behavior.
+   */
+  private static class HostnameCheckingX509ExtendedTrustManager
+      extends ForwardingX509ExtendedTrustManager {
+    public HostnameCheckingX509ExtendedTrustManager(X509ExtendedTrustManager tm) {
+      super(tm);
+    }
+
+    @Override
+    public void checkServerTrusted(X509Certificate[] chain, String authType, Socket socket)
+        throws CertificateException {
+      String peer = ((SSLSocket) socket).getHandshakeSession().getPeerHost();
+      if (!"foo.test.google.fr".equals(peer) && !"good.test.google.fr".equals(peer)) {
+        throw new CertificateException("Peer verification failed.");
+      }
+      super.checkServerTrusted(chain, authType, socket);
+    }
+  }
+
+  @IgnoreJRERequirement
+  private static class ForwardingX509ExtendedTrustManager extends X509ExtendedTrustManager {
+    private final X509ExtendedTrustManager delegate;
+
+    private ForwardingX509ExtendedTrustManager(X509ExtendedTrustManager delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    public void checkServerTrusted(X509Certificate[] chain, String authType, Socket socket)
+            throws CertificateException {
+      delegate.checkServerTrusted(chain, authType, socket);
+    }
+
+    @Override
+    public void checkServerTrusted(X509Certificate[] chain, String authType, SSLEngine engine)
+            throws CertificateException {
+      delegate.checkServerTrusted(chain, authType, engine);
+    }
+
+    @Override
+    public void checkServerTrusted(X509Certificate[] chain, String authType)
+            throws CertificateException {
+      delegate.checkServerTrusted(chain, authType);
+    }
+
+    @Override
+    public void checkClientTrusted(X509Certificate[] chain, String authType, SSLEngine engine)
+            throws CertificateException {
+      delegate.checkClientTrusted(chain, authType, engine);
+    }
+
+    @Override
+    public void checkClientTrusted(X509Certificate[] chain, String authType)
+            throws CertificateException {
+      delegate.checkClientTrusted(chain, authType);
+    }
+
+    @Override
+    public void checkClientTrusted(X509Certificate[] chain, String authType, Socket socket)
+            throws CertificateException {
+      delegate.checkClientTrusted(chain, authType, socket);
+    }
+
+    @Override
+    public X509Certificate[] getAcceptedIssuers() {
+      return delegate.getAcceptedIssuers();
+    }
+  }
+
+  private static Optional<TrustManager> getX509ExtendedTrustManager(InputStream rootCerts)
+          throws GeneralSecurityException {
+    KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
+    try {
+      ks.load(null, null);
+    } catch (IOException ex) {
+      // Shouldn't really happen, as we're not loading any data.
+      throw new GeneralSecurityException(ex);
+    }
+    X509Certificate[] certs = CertificateUtils.getX509Certificates(rootCerts);
+    for (X509Certificate cert : certs) {
+      X500Principal principal = cert.getSubjectX500Principal();
+      ks.setCertificateEntry(principal.getName("RFC2253"), cert);
+    }
+
+    TrustManagerFactory trustManagerFactory =
+            TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+    trustManagerFactory.init(ks);
+    return Arrays.stream(trustManagerFactory.getTrustManagers())
+            .filter(trustManager -> trustManager instanceof X509ExtendedTrustManager).findFirst();
+  }
+
+  private static Server server(ServerCredentials creds) throws IOException {
+    return OkHttpServerBuilder.forPort(0, creds)
+        .directExecutor()
+        .addService(new SimpleServiceImpl())
+        .build()
+        .start();
+  }
+
+  private static ManagedChannelBuilder<?> clientChannelBuilder(
+      Server server, ChannelCredentials creds) {
+    return OkHttpChannelBuilder.forAddress("localhost", server.getPort(), creds)
+        .directExecutor()
+        .overrideAuthority(TestUtils.TEST_SERVER_HOST);
+  }
+
+  private static ManagedChannel clientChannel(Server server, ChannelCredentials creds) {
+    return clientChannelBuilder(server, creds).build();
+  }
+
+  private static Status assertRpcFails(ManagedChannel channel) {
+    Status status = null;
+    SimpleServiceGrpc.SimpleServiceBlockingStub stub = SimpleServiceGrpc.newBlockingStub(channel);
+    try {
+      stub.unaryRpc(SimpleRequest.getDefaultInstance());
+      assertWithMessage("TLS handshake should have failed, but didn't; received RPC response")
+          .fail();
+    } catch (StatusRuntimeException e) {
+      assertWithMessage(Throwables.getStackTraceAsString(e))
+          .that(e.getStatus().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+      status = e.getStatus();
+    }
+    // We really want to see TRANSIENT_FAILURE here, but if the test runs slowly the 1s backoff
+    // may be exceeded by the time the failure happens (since it counts from the start of the
+    // attempt). Even so, CONNECTING is a strong indicator that the handshake failed; otherwise we'd
+    // expect READY or IDLE.
+    assertThat(channel.getState(false))
+        .isAnyOf(ConnectivityState.TRANSIENT_FAILURE, ConnectivityState.CONNECTING);
+    return status;
+  }
+
+  private static final class SimpleServiceImpl extends SimpleServiceGrpc.SimpleServiceImplBase {
+    @Override
+    public void unaryRpc(SimpleRequest req, StreamObserver<SimpleResponse> respOb) {
+      respOb.onNext(SimpleResponse.getDefaultInstance());
+      respOb.onCompleted();
+    }
+  }
+}
diff --git a/okhttp/src/test/java/io/grpc/okhttp/UtilsTest.java b/okhttp/src/test/java/io/grpc/okhttp/UtilsTest.java
index 5907fb2fee1..1c97e027b4a 100644
--- a/okhttp/src/test/java/io/grpc/okhttp/UtilsTest.java
+++ b/okhttp/src/test/java/io/grpc/okhttp/UtilsTest.java
@@ -1,46 +1,34 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.okhttp;
 
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
+import io.grpc.InternalChannelz.SocketOptions;
 import io.grpc.okhttp.internal.CipherSuite;
 import io.grpc.okhttp.internal.ConnectionSpec;
 import io.grpc.okhttp.internal.TlsVersion;
+import java.net.Socket;
 import java.util.List;
-import org.junit.Rule;
+import java.util.Locale;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
@@ -50,15 +38,12 @@
 @RunWith(JUnit4.class)
 public class UtilsTest {
 
-  @Rule
-  public final ExpectedException thrown = ExpectedException.none();
-
   @Test
   public void convertSpecRejectsPlaintext() {
     com.squareup.okhttp.ConnectionSpec plaintext = com.squareup.okhttp.ConnectionSpec.CLEARTEXT;
-    thrown.expect(IllegalArgumentException.class);
-    thrown.expectMessage("plaintext ConnectionSpec is not accepted");
-    Utils.convertSpec(plaintext);
+    IllegalArgumentException e = assertThrows(IllegalArgumentException.class,
+        () -> Utils.convertSpec(plaintext));
+    assertThat(e).hasMessageThat().isEqualTo("plaintext ConnectionSpec is not accepted");
   }
 
   @Test
@@ -84,4 +69,32 @@ public void convertSpecKeepsAllData() {
       assertEquals(CipherSuite.forJavaName(squareCipherSuites.get(i).name()), cipherSuites.get(i));
     }
   }
+
+  @Test
+  public void getSocketOptions() throws Exception {
+    Socket socket = new Socket();
+    socket.setSoLinger(true, 2);
+    socket.setSoTimeout(3);
+    socket.setTcpNoDelay(true);
+    socket.setReuseAddress(true);
+    socket.setReceiveBufferSize(4000);
+    socket.setSendBufferSize(5000);
+    socket.setKeepAlive(true);
+    socket.setOOBInline(true);
+    socket.setTrafficClass(8); // note: see javadoc for valid input values
+
+    SocketOptions socketOptions = Utils.getSocketOptions(socket);
+    assertEquals(2, (int) socketOptions.lingerSeconds);
+    assertEquals(3, (int) socketOptions.soTimeoutMillis);
+    assertEquals("true", socketOptions.others.get("TCP_NODELAY"));
+    assertEquals("true", socketOptions.others.get("SO_REUSEADDR"));
+    assertEquals("4000", socketOptions.others.get("SO_RECVBUF"));
+    assertEquals("5000", socketOptions.others.get("SO_SNDBUF"));
+    assertEquals("true", socketOptions.others.get("SO_KEEPALIVE"));
+    assertEquals("true", socketOptions.others.get("SO_OOBINLINE"));
+    String osName = System.getProperty("os.name").toLowerCase(Locale.ENGLISH);
+    if (!osName.startsWith("windows")) {
+      assertEquals("8", socketOptions.others.get("IP_TOS"));
+    }
+  }
 }
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/Platform.java b/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/Platform.java
deleted file mode 100644
index e1d9c26236f..00000000000
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/Platform.java
+++ /dev/null
@@ -1,435 +0,0 @@
-/*
- * Copyright (C) 2012 Square, Inc.
- * Copyright (C) 2012 The Android Open Source Project
- *
- * 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.
- */
-/*
- * Forked from OkHttp 2.5.0
- */
-
-package io.grpc.okhttp.internal;
-
-import io.grpc.internal.GrpcUtil;
-import java.io.IOException;
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
-import java.net.InetSocketAddress;
-import java.net.Socket;
-import java.net.SocketException;
-import java.security.NoSuchAlgorithmException;
-import java.security.Provider;
-import java.security.Security;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import javax.net.ssl.SSLContext;
-import javax.net.ssl.SSLSocket;
-import okio.Buffer;
-
-/**
- * Access to platform-specific features.
- *
- * <h3>Server name indication (SNI)</h3>
- * Supported on Android 2.3+.
- *
- * <h3>Session Tickets</h3>
- * Supported on Android 2.3+.
- *
- * <h3>Android Traffic Stats (Socket Tagging)</h3>
- * Supported on Android 4.0+.
- *
- * <h3>ALPN (Application Layer Protocol Negotiation)</h3>
- * Supported on Android 5.0+. The APIs were present in Android 4.4, but that implementation was
- * unstable.
- *
- * Supported on OpenJDK 7 and 8 (via the JettyALPN-boot library).
- */
-public class Platform {
-  public static final Logger logger = Logger.getLogger(Platform.class.getName());
-
-  /**
-   * List of security providers to use in order of preference.
-   */
-  private static final String[] ANDROID_SECURITY_PROVIDERS = new String[]{
-      // See https://developer.android.com/training/articles/security-gms-provider.html
-      "com.google.android.gms.org.conscrypt.OpenSSLProvider",
-      "com.android.org.conscrypt.OpenSSLProvider",
-      "org.conscrypt.OpenSSLProvider",
-      "org.apache.harmony.xnet.provider.jsse.OpenSSLProvider"};
-
-  private static final Platform PLATFORM = findPlatform();
-
-  public static Platform get() {
-    return PLATFORM;
-  }
-
-  private final Provider sslProvider;
-
-  public Platform(Provider sslProvider) {
-    this.sslProvider = sslProvider;
-  }
-
-  /** Prefix used on custom headers. */
-  public String getPrefix() {
-    return "OkHttp";
-  }
-
-  public void logW(String warning) {
-    System.out.println(warning);
-  }
-
-  public void tagSocket(Socket socket) throws SocketException {
-  }
-
-  public void untagSocket(Socket socket) throws SocketException {
-  }
-
-  public Provider getProvider() {
-    return sslProvider;
-  }
-
-  /**
-   * Configure TLS extensions on {@code sslSocket} for {@code route}.
-   *
-   * @param hostname non-null for client-side handshakes; null for
-   *     server-side handshakes.
-   */
-  public void configureTlsExtensions(SSLSocket sslSocket, String hostname,
-      List<Protocol> protocols) {
-  }
-
-  /**
-   * Called after the TLS handshake to release resources allocated by {@link
-   * #configureTlsExtensions}.
-   */
-  public void afterHandshake(SSLSocket sslSocket) {
-  }
-
-  /** Returns the negotiated protocol, or null if no protocol was negotiated. */
-  public String getSelectedProtocol(SSLSocket socket) {
-    return null;
-  }
-
-  public void connectSocket(Socket socket, InetSocketAddress address,
-      int connectTimeout) throws IOException {
-    socket.connect(address, connectTimeout);
-  }
-
-  /** Attempt to match the host runtime to a capable Platform implementation. */
-  private static Platform findPlatform() {
-    Provider sslProvider = GrpcUtil.IS_RESTRICTED_APPENGINE ?
-        getAppEngineProvider()
-        : getAndroidSecurityProvider();
-    if (sslProvider != null) {
-      // Attempt to find Android 2.3+ APIs.
-      OptionalMethod<Socket> setUseSessionTickets
-          = new OptionalMethod<Socket>(null, "setUseSessionTickets", boolean.class);
-      OptionalMethod<Socket> setHostname
-          = new OptionalMethod<Socket>(null, "setHostname", String.class);
-      Method trafficStatsTagSocket = null;
-      Method trafficStatsUntagSocket = null;
-      OptionalMethod<Socket> getAlpnSelectedProtocol =
-          new OptionalMethod<Socket>(byte[].class, "getAlpnSelectedProtocol");
-      OptionalMethod<Socket> setAlpnProtocols =
-          new OptionalMethod<Socket>(null, "setAlpnProtocols", byte[].class);
-
-      // Attempt to find Android 4.0+ APIs.
-      try {
-        Class<?> trafficStats = Class.forName("android.net.TrafficStats");
-        trafficStatsTagSocket = trafficStats.getMethod("tagSocket", Socket.class);
-        trafficStatsUntagSocket = trafficStats.getMethod("untagSocket", Socket.class);
-      } catch (ClassNotFoundException ignored) {
-      } catch (NoSuchMethodException ignored) {
-      }
-      return new Android(setUseSessionTickets, setHostname, trafficStatsTagSocket,
-          trafficStatsUntagSocket, getAlpnSelectedProtocol, setAlpnProtocols, sslProvider);
-    }
-    try {
-      sslProvider = SSLContext.getDefault().getProvider();
-    } catch (NoSuchAlgorithmException nsae) {
-      throw new RuntimeException(nsae);
-    }
-
-    // Find Jetty's ALPN extension for OpenJDK.
-    try {
-      String negoClassName = "org.eclipse.jetty.alpn.ALPN";
-      Class<?> negoClass = Class.forName(negoClassName);
-      Class<?> providerClass = Class.forName(negoClassName + "$Provider");
-      Class<?> clientProviderClass = Class.forName(negoClassName + "$ClientProvider");
-      Class<?> serverProviderClass = Class.forName(negoClassName + "$ServerProvider");
-      Method putMethod = negoClass.getMethod("put", SSLSocket.class, providerClass);
-      Method getMethod = negoClass.getMethod("get", SSLSocket.class);
-      Method removeMethod = negoClass.getMethod("remove", SSLSocket.class);
-      return new JdkWithJettyBootPlatform(
-          putMethod, getMethod, removeMethod, clientProviderClass, serverProviderClass,
-          sslProvider);
-    } catch (ClassNotFoundException ignored) {
-    } catch (NoSuchMethodException ignored) {
-    }
-
-    return new Platform(sslProvider);
-  }
-
-  /**
-   * Forcibly load the conscrypt security provider on AppEngine if it's available. If not fail.
-   */
-  private static Provider getAppEngineProvider() {
-    try {
-      // Forcibly load conscrypt as it is unlikely to be an installed provider on AppEngine
-      return (Provider) Class.forName("org.conscrypt.OpenSSLProvider").newInstance();
-    } catch (Throwable t) {
-      throw new RuntimeException("Unable to load conscrypt security provider", t);
-    }
-  }
-
-  /**
-   * Select from the available security providers in preference order. If a preferred provider
-   * is not found then warn but continue.
-   */
-  private static Provider getAndroidSecurityProvider() {
-    for (String providerClassName : ANDROID_SECURITY_PROVIDERS) {
-      Provider[] providers = Security.getProviders();
-      for (Provider availableProvider : providers) {
-        if (providerClassName.equals(availableProvider.getClass().getName())) {
-          logger.log(Level.FINE, "Found registered provider {0}", providerClassName);
-          return availableProvider;
-        }
-      }
-    }
-    logger.log(Level.WARNING, "Unable to find Conscrypt");
-    return null;
-  }
-
-  /** Android 2.3 or better. */
-  private static class Android extends Platform {
-
-    private final OptionalMethod<Socket> setUseSessionTickets;
-    private final OptionalMethod<Socket> setHostname;
-
-    // Non-null on Android 4.0+.
-    private final Method trafficStatsTagSocket;
-    private final Method trafficStatsUntagSocket;
-
-    // Non-null on Android 5.0+.
-    private final OptionalMethod<Socket> getAlpnSelectedProtocol;
-    private final OptionalMethod<Socket> setAlpnProtocols;
-
-    public Android(OptionalMethod<Socket> setUseSessionTickets, OptionalMethod<Socket> setHostname,
-        Method trafficStatsTagSocket, Method trafficStatsUntagSocket,
-        OptionalMethod<Socket> getAlpnSelectedProtocol, OptionalMethod<Socket> setAlpnProtocols,
-        Provider provider) {
-      super(provider);
-      this.setUseSessionTickets = setUseSessionTickets;
-      this.setHostname = setHostname;
-      this.trafficStatsTagSocket = trafficStatsTagSocket;
-      this.trafficStatsUntagSocket = trafficStatsUntagSocket;
-      this.getAlpnSelectedProtocol = getAlpnSelectedProtocol;
-      this.setAlpnProtocols = setAlpnProtocols;
-    }
-
-    @Override public void connectSocket(Socket socket, InetSocketAddress address,
-        int connectTimeout) throws IOException {
-      try {
-        socket.connect(address, connectTimeout);
-      } catch (SecurityException se) {
-        // Before android 4.3, socket.connect could throw a SecurityException
-        // if opening a socket resulted in an EACCES error.
-        IOException ioException = new IOException("Exception in connect");
-        ioException.initCause(se);
-        throw ioException;
-      }
-    }
-
-    @Override public void configureTlsExtensions(
-        SSLSocket sslSocket, String hostname, List<Protocol> protocols) {
-      // Enable SNI and session tickets.
-      if (hostname != null) {
-        setUseSessionTickets.invokeOptionalWithoutCheckedException(sslSocket, true);
-        setHostname.invokeOptionalWithoutCheckedException(sslSocket, hostname);
-      }
-
-      // Enable ALPN.
-      if (setAlpnProtocols.isSupported(sslSocket)) {
-        Object[] parameters = { concatLengthPrefixed(protocols) };
-        setAlpnProtocols.invokeWithoutCheckedException(sslSocket, parameters);
-      }
-    }
-
-    @Override public String getSelectedProtocol(SSLSocket socket) {
-      if (!getAlpnSelectedProtocol.isSupported(socket)) return null;
-
-      byte[] alpnResult = (byte[]) getAlpnSelectedProtocol.invokeWithoutCheckedException(socket);
-      return alpnResult != null ? new String(alpnResult, Util.UTF_8) : null;
-    }
-
-    @Override public void tagSocket(Socket socket) throws SocketException {
-      if (trafficStatsTagSocket == null) return;
-
-      try {
-        trafficStatsTagSocket.invoke(null, socket);
-      } catch (IllegalAccessException e) {
-        throw new RuntimeException(e);
-      } catch (InvocationTargetException e) {
-        throw new RuntimeException(e.getCause());
-      }
-    }
-
-    @Override public void untagSocket(Socket socket) throws SocketException {
-      if (trafficStatsUntagSocket == null) return;
-
-      try {
-        trafficStatsUntagSocket.invoke(null, socket);
-      } catch (IllegalAccessException e) {
-        throw new RuntimeException(e);
-      } catch (InvocationTargetException e) {
-        throw new RuntimeException(e.getCause());
-      }
-    }
-  }
-
-  /**
-   * OpenJDK 7+ with {@code org.mortbay.jetty.alpn/alpn-boot} in the boot class path.
-   */
-  private static class JdkWithJettyBootPlatform extends Platform {
-    private final Method putMethod;
-    private final Method getMethod;
-    private final Method removeMethod;
-    private final Class<?> clientProviderClass;
-    private final Class<?> serverProviderClass;
-
-    public JdkWithJettyBootPlatform(Method putMethod, Method getMethod, Method removeMethod,
-        Class<?> clientProviderClass, Class<?> serverProviderClass, Provider provider) {
-      super(provider);
-      this.putMethod = putMethod;
-      this.getMethod = getMethod;
-      this.removeMethod = removeMethod;
-      this.clientProviderClass = clientProviderClass;
-      this.serverProviderClass = serverProviderClass;
-    }
-
-    @Override public void configureTlsExtensions(
-        SSLSocket sslSocket, String hostname, List<Protocol> protocols) {
-      List<String> names = new ArrayList<String>(protocols.size());
-      for (int i = 0, size = protocols.size(); i < size; i++) {
-        Protocol protocol = protocols.get(i);
-        if (protocol == Protocol.HTTP_1_0) continue; // No HTTP/1.0 for ALPN.
-        names.add(protocol.toString());
-      }
-      try {
-        Object provider = Proxy.newProxyInstance(Platform.class.getClassLoader(),
-            new Class<?>[] { clientProviderClass, serverProviderClass }, new JettyNegoProvider(names));
-        putMethod.invoke(null, sslSocket, provider);
-      } catch (InvocationTargetException e) {
-        throw new AssertionError(e);
-      } catch (IllegalAccessException e) {
-        throw new AssertionError(e);
-      }
-    }
-
-    @Override public void afterHandshake(SSLSocket sslSocket) {
-      try {
-        removeMethod.invoke(null, sslSocket);
-      } catch (IllegalAccessException ignored) {
-        throw new AssertionError();
-      } catch (InvocationTargetException ignored) {
-      }
-    }
-
-    @Override public String getSelectedProtocol(SSLSocket socket) {
-      try {
-        JettyNegoProvider provider =
-            (JettyNegoProvider) Proxy.getInvocationHandler(getMethod.invoke(null, socket));
-        if (!provider.unsupported && provider.selected == null) {
-          logger.log(Level.INFO, "ALPN callback dropped: SPDY and HTTP/2 are disabled. "
-              + "Is alpn-boot on the boot class path?");
-          return null;
-        }
-        return provider.unsupported ? null : provider.selected;
-      } catch (InvocationTargetException e) {
-        throw new AssertionError();
-      } catch (IllegalAccessException e) {
-        throw new AssertionError();
-      }
-    }
-  }
-
-  /**
-   * Handle the methods of ALPN's ClientProvider and ServerProvider
-   * without a compile-time dependency on those interfaces.
-   */
-  private static class JettyNegoProvider implements InvocationHandler {
-    /** This peer's supported protocols. */
-    private final List<String> protocols;
-    /** Set when remote peer notifies ALPN is unsupported. */
-    private boolean unsupported;
-    /** The protocol the server selected. */
-    private String selected;
-
-    public JettyNegoProvider(List<String> protocols) {
-      this.protocols = protocols;
-    }
-
-    @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-      String methodName = method.getName();
-      Class<?> returnType = method.getReturnType();
-      if (args == null) {
-        args = Util.EMPTY_STRING_ARRAY;
-      }
-      if (methodName.equals("supports") && boolean.class == returnType) {
-        return true; // ALPN is supported.
-      } else if (methodName.equals("unsupported") && void.class == returnType) {
-        this.unsupported = true; // Peer doesn't support ALPN.
-        return null;
-      } else if (methodName.equals("protocols") && args.length == 0) {
-        return protocols; // Client advertises these protocols.
-      } else if ((methodName.equals("selectProtocol") || methodName.equals("select"))
-          && String.class == returnType && args.length == 1 && args[0] instanceof List) {
-        @SuppressWarnings("unchecked")
-        List<String> peerProtocols = (List) args[0];
-        // Pick the first known protocol the peer advertises.
-        for (int i = 0, size = peerProtocols.size(); i < size; i++) {
-          if (protocols.contains(peerProtocols.get(i))) {
-            return selected = peerProtocols.get(i);
-          }
-        }
-        return selected = protocols.get(0); // On no intersection, try peer's first protocol.
-      } else if ((methodName.equals("protocolSelected") || methodName.equals("selected"))
-          && args.length == 1) {
-        this.selected = (String) args[0]; // Server selected this protocol.
-        return null;
-      } else {
-        return method.invoke(this, args);
-      }
-    }
-  }
-
-  /**
-   * Returns the concatenation of 8-bit, length prefixed protocol names.
-   * http://tools.ietf.org/html/draft-agl-tls-nextprotoneg-04#page-4
-   */
-  public static byte[] concatLengthPrefixed(List<Protocol> protocols) {
-    Buffer result = new Buffer();
-    for (int i = 0, size = protocols.size(); i < size; i++) {
-      Protocol protocol = protocols.get(i);
-      if (protocol == Protocol.HTTP_1_0) continue; // No HTTP/1.0 for ALPN.
-      result.writeByte(protocol.toString().length());
-      result.writeUtf8(protocol.toString());
-    }
-    return result.readByteArray();
-  }
-}
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/Util.java b/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/Util.java
deleted file mode 100644
index 7501c441d94..00000000000
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/Util.java
+++ /dev/null
@@ -1,290 +0,0 @@
-/*
- * Copyright (C) 2012 The Android Open Source Project
- *
- * 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.
- */
-/*
- * Forked from OkHttp 2.5.0
- */
-
-package io.grpc.okhttp.internal;
-
-import java.io.Closeable;
-import java.io.IOException;
-import java.io.InterruptedIOException;
-import java.io.UnsupportedEncodingException;
-import java.lang.reflect.Array;
-import java.net.ServerSocket;
-import java.net.Socket;
-import java.nio.charset.Charset;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.TimeUnit;
-import okio.Buffer;
-import okio.ByteString;
-import okio.Source;
-
-/** Junk drawer of utility methods. */
-public final class Util {
-  public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
-  public static final String[] EMPTY_STRING_ARRAY = new String[0];
-
-  /** A cheap and type-safe constant for the UTF-8 Charset. */
-  public static final Charset UTF_8 = Charset.forName("UTF-8");
-
-  private Util() {
-  }
-
-  public static void checkOffsetAndCount(long arrayLength, long offset, long count) {
-    if ((offset | count) < 0 || offset > arrayLength || arrayLength - offset < count) {
-      throw new ArrayIndexOutOfBoundsException();
-    }
-  }
-
-  /** Returns true if two possibly-null objects are equal. */
-  public static boolean equal(Object a, Object b) {
-    return a == b || (a != null && a.equals(b));
-  }
-
-  /**
-   * Closes {@code closeable}, ignoring any checked exceptions. Does nothing
-   * if {@code closeable} is null.
-   */
-  public static void closeQuietly(Closeable closeable) {
-    if (closeable != null) {
-      try {
-        closeable.close();
-      } catch (RuntimeException rethrown) {
-        throw rethrown;
-      } catch (Exception ignored) {
-      }
-    }
-  }
-
-  /**
-   * Closes {@code socket}, ignoring any checked exceptions. Does nothing if
-   * {@code socket} is null.
-   */
-  public static void closeQuietly(Socket socket) {
-    if (socket != null) {
-      try {
-        socket.close();
-      } catch (AssertionError e) {
-        if (!isAndroidGetsocknameError(e)) throw e;
-      } catch (RuntimeException rethrown) {
-        throw rethrown;
-      } catch (Exception ignored) {
-      }
-    }
-  }
-
-  /**
-   * Closes {@code serverSocket}, ignoring any checked exceptions. Does nothing if
-   * {@code serverSocket} is null.
-   */
-  public static void closeQuietly(ServerSocket serverSocket) {
-    if (serverSocket != null) {
-      try {
-        serverSocket.close();
-      } catch (RuntimeException rethrown) {
-        throw rethrown;
-      } catch (Exception ignored) {
-      }
-    }
-  }
-
-  /**
-   * Closes {@code a} and {@code b}. If either close fails, this completes
-   * the other close and rethrows the first encountered exception.
-   */
-  public static void closeAll(Closeable a, Closeable b) throws IOException {
-    Throwable thrown = null;
-    try {
-      a.close();
-    } catch (Throwable e) {
-      thrown = e;
-    }
-    try {
-      b.close();
-    } catch (Throwable e) {
-      if (thrown == null) thrown = e;
-    }
-    if (thrown == null) return;
-    if (thrown instanceof IOException) throw (IOException) thrown;
-    if (thrown instanceof RuntimeException) throw (RuntimeException) thrown;
-    if (thrown instanceof Error) throw (Error) thrown;
-    throw new AssertionError(thrown);
-  }
-
-  /**
-   * Attempts to exhaust {@code source}, returning true if successful. This is useful when reading
-   * a complete source is helpful, such as when doing so completes a cache body or frees a socket
-   * connection for reuse.
-   */
-  public static boolean discard(Source source, int timeout, TimeUnit timeUnit) {
-    try {
-      return skipAll(source, timeout, timeUnit);
-    } catch (IOException e) {
-      return false;
-    }
-  }
-
-  /**
-   * Reads until {@code in} is exhausted or the deadline has been reached. This is careful to not
-   * extend the deadline if one exists already.
-   */
-  public static boolean skipAll(Source source, int duration, TimeUnit timeUnit) throws IOException {
-    long now = System.nanoTime();
-    long originalDuration = source.timeout().hasDeadline()
-        ? source.timeout().deadlineNanoTime() - now
-        : Long.MAX_VALUE;
-    source.timeout().deadlineNanoTime(now + Math.min(originalDuration, timeUnit.toNanos(duration)));
-    try {
-      Buffer skipBuffer = new Buffer();
-      while (source.read(skipBuffer, 2048) != -1) {
-        skipBuffer.clear();
-      }
-      return true; // Success! The source has been exhausted.
-    } catch (InterruptedIOException e) {
-      return false; // We ran out of time before exhausting the source.
-    } finally {
-      if (originalDuration == Long.MAX_VALUE) {
-        source.timeout().clearDeadline();
-      } else {
-        source.timeout().deadlineNanoTime(now + originalDuration);
-      }
-    }
-  }
-
-  /** Returns a 32 character string containing an MD5 hash of {@code s}. */
-  public static String md5Hex(String s) {
-    try {
-      MessageDigest messageDigest = MessageDigest.getInstance("MD5");
-      byte[] md5bytes = messageDigest.digest(s.getBytes("UTF-8"));
-      return ByteString.of(md5bytes).hex();
-    } catch (NoSuchAlgorithmException e) {
-      throw new AssertionError(e);
-    } catch (UnsupportedEncodingException e) {
-      throw new AssertionError(e);
-    }
-  }
-
-  /** Returns a Base 64-encoded string containing a SHA-1 hash of {@code s}. */
-  public static String shaBase64(String s) {
-    try {
-      MessageDigest messageDigest = MessageDigest.getInstance("SHA-1");
-      byte[] sha1Bytes = messageDigest.digest(s.getBytes("UTF-8"));
-      return ByteString.of(sha1Bytes).base64();
-    } catch (NoSuchAlgorithmException e) {
-      throw new AssertionError(e);
-    } catch (UnsupportedEncodingException e) {
-      throw new AssertionError(e);
-    }
-  }
-
-  /** Returns a SHA-1 hash of {@code s}. */
-  public static ByteString sha1(ByteString s) {
-    try {
-      MessageDigest messageDigest = MessageDigest.getInstance("SHA-1");
-      byte[] sha1Bytes = messageDigest.digest(s.toByteArray());
-      return ByteString.of(sha1Bytes);
-    } catch (NoSuchAlgorithmException e) {
-      throw new AssertionError(e);
-    }
-  }
-
-  /** Returns an immutable copy of {@code list}. */
-  public static <T> List<T> immutableList(List<T> list) {
-    return Collections.unmodifiableList(new ArrayList<T>(list));
-  }
-
-  /** Returns an immutable list containing {@code elements}. */
-  public static <T> List<T> immutableList(T... elements) {
-    return Collections.unmodifiableList(Arrays.asList(elements.clone()));
-  }
-
-  /** Returns an immutable copy of {@code map}. */
-  public static <K, V> Map<K, V> immutableMap(Map<K, V> map) {
-    return Collections.unmodifiableMap(new LinkedHashMap<K, V>(map));
-  }
-
-  public static ThreadFactory threadFactory(final String name, final boolean daemon) {
-    return new ThreadFactory() {
-      @Override public Thread newThread(Runnable runnable) {
-        Thread result = new Thread(runnable, name);
-        result.setDaemon(daemon);
-        return result;
-      }
-    };
-  }
-
-  /**
-   * Returns an array containing containing only elements found in {@code first}  and also in
-   * {@code second}. The returned elements are in the same order as in {@code first}.
-   */
-  @SuppressWarnings("unchecked")
-  public static <T> T[] intersect(Class<T> arrayType, T[] first, T[] second) {
-    List<T> result = intersect(first, second);
-    return result.toArray((T[]) Array.newInstance(arrayType, result.size()));
-  }
-
-  /**
-   * Returns a list containing containing only elements found in {@code first}  and also in
-   * {@code second}. The returned elements are in the same order as in {@code first}.
-   */
-  private static <T> List<T> intersect(T[] first, T[] second) {
-    List<T> result = new ArrayList<T>();
-    for (T a : first) {
-      for (T b : second) {
-        if (a.equals(b)) {
-          result.add(b);
-          break;
-        }
-      }
-    }
-    return result;
-  }
-
-  /** Returns {@code s} with control characters and non-ASCII characters replaced with '?'. */
-  public static String toHumanReadableAscii(String s) {
-    for (int i = 0, length = s.length(), c; i < length; i += Character.charCount(c)) {
-      c = s.codePointAt(i);
-      if (c > '\u001f' && c < '\u007f') continue;
-
-      Buffer buffer = new Buffer();
-      buffer.writeUtf8(s, 0, i);
-      for (int j = i; j < length; j += Character.charCount(c)) {
-        c = s.codePointAt(j);
-        buffer.writeUtf8CodePoint(c > '\u001f' && c < '\u007f' ? c : '?');
-      }
-      return buffer.readUtf8();
-    }
-    return s;
-  }
-
-  /**
-   * Returns true if {@code e} is due to a firmware bug fixed after Android 4.2.2.
-   * https://code.google.com/p/android/issues/detail?id=54072
-   */
-  public static boolean isAndroidGetsocknameError(AssertionError e) {
-    return e.getCause() != null && e.getMessage() != null
-        && e.getMessage().contains("getsockname failed");
-  }
-}
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Hpack.java b/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Hpack.java
deleted file mode 100644
index 940735abe3a..00000000000
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Hpack.java
+++ /dev/null
@@ -1,441 +0,0 @@
-/*
- * Copyright (C) 2013 Square, Inc.
- *
- * 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.
- */
-/*
- * Forked from OkHttp 2.5.0
- */
-
-package io.grpc.okhttp.internal.framed;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
-import okio.Buffer;
-import okio.BufferedSource;
-import okio.ByteString;
-import okio.Okio;
-import okio.Source;
-
-/**
- * Read and write HPACK v10.
- *
- * http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12
- *
- * This implementation uses an array for the dynamic table and a list for
- * indexed entries.  Dynamic entries are added to the array, starting in the
- * last position moving forward.  When the array fills, it is doubled.
- */
-final class Hpack {
-  private static final int PREFIX_4_BITS = 0x0f;
-  private static final int PREFIX_5_BITS = 0x1f;
-  private static final int PREFIX_6_BITS = 0x3f;
-  private static final int PREFIX_7_BITS = 0x7f;
-
-  private static final io.grpc.okhttp.internal.framed.Header[] STATIC_HEADER_TABLE = new io.grpc.okhttp.internal.framed.Header[] {
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_AUTHORITY, ""),
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_METHOD, "GET"),
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_METHOD, "POST"),
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_PATH, "/"),
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_PATH, "/index.html"),
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_SCHEME, "http"),
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_SCHEME, "https"),
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "200"),
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "204"),
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "206"),
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "304"),
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "400"),
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "404"),
-      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "500"),
-      new io.grpc.okhttp.internal.framed.Header("accept-charset", ""),
-      new io.grpc.okhttp.internal.framed.Header("accept-encoding", "gzip, deflate"),
-      new io.grpc.okhttp.internal.framed.Header("accept-language", ""),
-      new io.grpc.okhttp.internal.framed.Header("accept-ranges", ""),
-      new io.grpc.okhttp.internal.framed.Header("accept", ""),
-      new io.grpc.okhttp.internal.framed.Header("access-control-allow-origin", ""),
-      new io.grpc.okhttp.internal.framed.Header("age", ""),
-      new io.grpc.okhttp.internal.framed.Header("allow", ""),
-      new io.grpc.okhttp.internal.framed.Header("authorization", ""),
-      new io.grpc.okhttp.internal.framed.Header("cache-control", ""),
-      new io.grpc.okhttp.internal.framed.Header("content-disposition", ""),
-      new io.grpc.okhttp.internal.framed.Header("content-encoding", ""),
-      new io.grpc.okhttp.internal.framed.Header("content-language", ""),
-      new io.grpc.okhttp.internal.framed.Header("content-length", ""),
-      new io.grpc.okhttp.internal.framed.Header("content-location", ""),
-      new io.grpc.okhttp.internal.framed.Header("content-range", ""),
-      new io.grpc.okhttp.internal.framed.Header("content-type", ""),
-      new io.grpc.okhttp.internal.framed.Header("cookie", ""),
-      new io.grpc.okhttp.internal.framed.Header("date", ""),
-      new io.grpc.okhttp.internal.framed.Header("etag", ""),
-      new io.grpc.okhttp.internal.framed.Header("expect", ""),
-      new io.grpc.okhttp.internal.framed.Header("expires", ""),
-      new io.grpc.okhttp.internal.framed.Header("from", ""),
-      new io.grpc.okhttp.internal.framed.Header("host", ""),
-      new io.grpc.okhttp.internal.framed.Header("if-match", ""),
-      new io.grpc.okhttp.internal.framed.Header("if-modified-since", ""),
-      new io.grpc.okhttp.internal.framed.Header("if-none-match", ""),
-      new io.grpc.okhttp.internal.framed.Header("if-range", ""),
-      new io.grpc.okhttp.internal.framed.Header("if-unmodified-since", ""),
-      new io.grpc.okhttp.internal.framed.Header("last-modified", ""),
-      new io.grpc.okhttp.internal.framed.Header("link", ""),
-      new io.grpc.okhttp.internal.framed.Header("location", ""),
-      new io.grpc.okhttp.internal.framed.Header("max-forwards", ""),
-      new io.grpc.okhttp.internal.framed.Header("proxy-authenticate", ""),
-      new io.grpc.okhttp.internal.framed.Header("proxy-authorization", ""),
-      new io.grpc.okhttp.internal.framed.Header("range", ""),
-      new io.grpc.okhttp.internal.framed.Header("referer", ""),
-      new io.grpc.okhttp.internal.framed.Header("refresh", ""),
-      new io.grpc.okhttp.internal.framed.Header("retry-after", ""),
-      new io.grpc.okhttp.internal.framed.Header("server", ""),
-      new io.grpc.okhttp.internal.framed.Header("set-cookie", ""),
-      new io.grpc.okhttp.internal.framed.Header("strict-transport-security", ""),
-      new io.grpc.okhttp.internal.framed.Header("transfer-encoding", ""),
-      new io.grpc.okhttp.internal.framed.Header("user-agent", ""),
-      new io.grpc.okhttp.internal.framed.Header("vary", ""),
-      new io.grpc.okhttp.internal.framed.Header("via", ""),
-      new io.grpc.okhttp.internal.framed.Header("www-authenticate", "")
-  };
-
-  private Hpack() {
-  }
-
-  // http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#section-3.1
-  static final class Reader {
-
-    private final List<io.grpc.okhttp.internal.framed.Header> headerList = new ArrayList<io.grpc.okhttp.internal.framed.Header>();
-    private final BufferedSource source;
-
-    private int headerTableSizeSetting;
-    private int maxDynamicTableByteCount;
-    // Visible for testing.
-    io.grpc.okhttp.internal.framed.Header[] dynamicTable = new io.grpc.okhttp.internal.framed.Header[8];
-    // Array is populated back to front, so new entries always have lowest index.
-    int nextHeaderIndex = dynamicTable.length - 1;
-    int headerCount = 0;
-    int dynamicTableByteCount = 0;
-
-    Reader(int headerTableSizeSetting, Source source) {
-      this.headerTableSizeSetting = headerTableSizeSetting;
-      this.maxDynamicTableByteCount = headerTableSizeSetting;
-      this.source = Okio.buffer(source);
-    }
-
-    int maxDynamicTableByteCount() {
-      return maxDynamicTableByteCount;
-    }
-
-    /**
-     * Called by the reader when the peer sent {@link Settings#HEADER_TABLE_SIZE}.
-     * While this establishes the maximum dynamic table size, the
-     * {@link #maxDynamicTableByteCount} set during processing may limit the
-     * table size to a smaller amount.
-     * <p> Evicts entries or clears the table as needed.
-     */
-    void headerTableSizeSetting(int headerTableSizeSetting) {
-      this.headerTableSizeSetting = headerTableSizeSetting;
-      this.maxDynamicTableByteCount = headerTableSizeSetting;
-      adjustDynamicTableByteCount();
-    }
-
-    private void adjustDynamicTableByteCount() {
-      if (maxDynamicTableByteCount < dynamicTableByteCount) {
-        if (maxDynamicTableByteCount == 0) {
-          clearDynamicTable();
-        } else {
-          evictToRecoverBytes(dynamicTableByteCount - maxDynamicTableByteCount);
-        }
-      }
-    }
-
-    private void clearDynamicTable() {
-      headerList.clear();
-      Arrays.fill(dynamicTable, null);
-      nextHeaderIndex = dynamicTable.length - 1;
-      headerCount = 0;
-      dynamicTableByteCount = 0;
-    }
-
-    /** Returns the count of entries evicted. */
-    private int evictToRecoverBytes(int bytesToRecover) {
-      int entriesToEvict = 0;
-      if (bytesToRecover > 0) {
-        // determine how many headers need to be evicted.
-        for (int j = dynamicTable.length - 1; j >= nextHeaderIndex && bytesToRecover > 0; j--) {
-          bytesToRecover -= dynamicTable[j].hpackSize;
-          dynamicTableByteCount -= dynamicTable[j].hpackSize;
-          headerCount--;
-          entriesToEvict++;
-        }
-        System.arraycopy(dynamicTable, nextHeaderIndex + 1, dynamicTable,
-            nextHeaderIndex + 1 + entriesToEvict, headerCount);
-        nextHeaderIndex += entriesToEvict;
-      }
-      return entriesToEvict;
-    }
-
-    /**
-     * Read {@code byteCount} bytes of headers from the source stream. This
-     * implementation does not propagate the never indexed flag of a header.
-     */
-    void readHeaders() throws IOException {
-      while (!source.exhausted()) {
-        int b = source.readByte() & 0xff;
-        if (b == 0x80) { // 10000000
-          throw new IOException("index == 0");
-        } else if ((b & 0x80) == 0x80) { // 1NNNNNNN
-          int index = readInt(b, PREFIX_7_BITS);
-          readIndexedHeader(index - 1);
-        } else if (b == 0x40) { // 01000000
-          readLiteralHeaderWithIncrementalIndexingNewName();
-        } else if ((b & 0x40) == 0x40) {  // 01NNNNNN
-          int index = readInt(b, PREFIX_6_BITS);
-          readLiteralHeaderWithIncrementalIndexingIndexedName(index - 1);
-        } else if ((b & 0x20) == 0x20) {  // 001NNNNN
-          maxDynamicTableByteCount = readInt(b, PREFIX_5_BITS);
-          if (maxDynamicTableByteCount < 0
-              || maxDynamicTableByteCount > headerTableSizeSetting) {
-            throw new IOException("Invalid dynamic table size update " + maxDynamicTableByteCount);
-          }
-          adjustDynamicTableByteCount();
-        } else if (b == 0x10 || b == 0) { // 000?0000 - Ignore never indexed bit.
-          readLiteralHeaderWithoutIndexingNewName();
-        } else { // 000?NNNN - Ignore never indexed bit.
-          int index = readInt(b, PREFIX_4_BITS);
-          readLiteralHeaderWithoutIndexingIndexedName(index - 1);
-        }
-      }
-    }
-
-    public List<io.grpc.okhttp.internal.framed.Header> getAndResetHeaderList() {
-      List<io.grpc.okhttp.internal.framed.Header> result = new ArrayList<io.grpc.okhttp.internal.framed.Header>(headerList);
-      headerList.clear();
-      return result;
-    }
-
-    private void readIndexedHeader(int index) throws IOException {
-      if (isStaticHeader(index)) {
-        io.grpc.okhttp.internal.framed.Header staticEntry = STATIC_HEADER_TABLE[index];
-        headerList.add(staticEntry);
-      } else {
-        int dynamicTableIndex = dynamicTableIndex(index - STATIC_HEADER_TABLE.length);
-        if (dynamicTableIndex < 0 || dynamicTableIndex > dynamicTable.length - 1) {
-          throw new IOException("Header index too large " + (index + 1));
-        }
-        headerList.add(dynamicTable[dynamicTableIndex]);
-      }
-    }
-
-    // referencedHeaders is relative to nextHeaderIndex + 1.
-    private int dynamicTableIndex(int index) {
-      return nextHeaderIndex + 1 + index;
-    }
-
-    private void readLiteralHeaderWithoutIndexingIndexedName(int index) throws IOException {
-      ByteString name = getName(index);
-      ByteString value = readByteString();
-      headerList.add(new io.grpc.okhttp.internal.framed.Header(name, value));
-    }
-
-    private void readLiteralHeaderWithoutIndexingNewName() throws IOException {
-      ByteString name = checkLowercase(readByteString());
-      ByteString value = readByteString();
-      headerList.add(new io.grpc.okhttp.internal.framed.Header(name, value));
-    }
-
-    private void readLiteralHeaderWithIncrementalIndexingIndexedName(int nameIndex)
-        throws IOException {
-      ByteString name = getName(nameIndex);
-      ByteString value = readByteString();
-      insertIntoDynamicTable(-1, new io.grpc.okhttp.internal.framed.Header(name, value));
-    }
-
-    private void readLiteralHeaderWithIncrementalIndexingNewName() throws IOException {
-      ByteString name = checkLowercase(readByteString());
-      ByteString value = readByteString();
-      insertIntoDynamicTable(-1, new io.grpc.okhttp.internal.framed.Header(name, value));
-    }
-
-    private ByteString getName(int index) {
-      if (isStaticHeader(index)) {
-        return STATIC_HEADER_TABLE[index].name;
-      } else {
-        return dynamicTable[dynamicTableIndex(index - STATIC_HEADER_TABLE.length)].name;
-      }
-    }
-
-    private boolean isStaticHeader(int index) {
-      return index >= 0 && index <= STATIC_HEADER_TABLE.length - 1;
-    }
-
-    /** index == -1 when new. */
-    private void insertIntoDynamicTable(int index, io.grpc.okhttp.internal.framed.Header entry) {
-      headerList.add(entry);
-
-      int delta = entry.hpackSize;
-      if (index != -1) { // Index -1 == new header.
-        delta -= dynamicTable[dynamicTableIndex(index)].hpackSize;
-      }
-
-      // if the new or replacement header is too big, drop all entries.
-      if (delta > maxDynamicTableByteCount) {
-        clearDynamicTable();
-        return;
-      }
-
-      // Evict headers to the required length.
-      int bytesToRecover = (dynamicTableByteCount + delta) - maxDynamicTableByteCount;
-      int entriesEvicted = evictToRecoverBytes(bytesToRecover);
-
-      if (index == -1) { // Adding a value to the dynamic table.
-        if (headerCount + 1 > dynamicTable.length) { // Need to grow the dynamic table.
-          io.grpc.okhttp.internal.framed.Header[] doubled = new io.grpc.okhttp.internal.framed.Header[dynamicTable.length * 2];
-          System.arraycopy(dynamicTable, 0, doubled, dynamicTable.length, dynamicTable.length);
-          nextHeaderIndex = dynamicTable.length - 1;
-          dynamicTable = doubled;
-        }
-        index = nextHeaderIndex--;
-        dynamicTable[index] = entry;
-        headerCount++;
-      } else { // Replace value at same position.
-        index += dynamicTableIndex(index) + entriesEvicted;
-        dynamicTable[index] = entry;
-      }
-      dynamicTableByteCount += delta;
-    }
-
-    private int readByte() throws IOException {
-      return source.readByte() & 0xff;
-    }
-
-    int readInt(int firstByte, int prefixMask) throws IOException {
-      int prefix = firstByte & prefixMask;
-      if (prefix < prefixMask) {
-        return prefix; // This was a single byte value.
-      }
-
-      // This is a multibyte value. Read 7 bits at a time.
-      int result = prefixMask;
-      int shift = 0;
-      while (true) {
-        int b = readByte();
-        if ((b & 0x80) != 0) { // Equivalent to (b >= 128) since b is in [0..255].
-          result += (b & 0x7f) << shift;
-          shift += 7;
-        } else {
-          result += b << shift; // Last byte.
-          break;
-        }
-      }
-      return result;
-    }
-
-    /** Reads a potentially Huffman encoded byte string. */
-    ByteString readByteString() throws IOException {
-      int firstByte = readByte();
-      boolean huffmanDecode = (firstByte & 0x80) == 0x80; // 1NNNNNNN
-      int length = readInt(firstByte, PREFIX_7_BITS);
-
-      if (huffmanDecode) {
-        return ByteString.of(io.grpc.okhttp.internal.framed.Huffman.get().decode(source.readByteArray(length)));
-      } else {
-        return source.readByteString(length);
-      }
-    }
-  }
-
-  private static final Map<ByteString, Integer> NAME_TO_FIRST_INDEX = nameToFirstIndex();
-
-  private static Map<ByteString, Integer> nameToFirstIndex() {
-    Map<ByteString, Integer> result =
-        new LinkedHashMap<ByteString, Integer>(STATIC_HEADER_TABLE.length);
-    for (int i = 0; i < STATIC_HEADER_TABLE.length; i++) {
-      if (!result.containsKey(STATIC_HEADER_TABLE[i].name)) {
-        result.put(STATIC_HEADER_TABLE[i].name, i);
-      }
-    }
-    return Collections.unmodifiableMap(result);
-  }
-
-  static final class Writer {
-    private final Buffer out;
-
-    Writer(Buffer out) {
-      this.out = out;
-    }
-
-    /** This does not use "never indexed" semantics for sensitive headers. */
-    // http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#section-6.2.3
-    void writeHeaders(List<io.grpc.okhttp.internal.framed.Header> headerBlock) throws IOException {
-      // TODO: implement index tracking
-      for (int i = 0, size = headerBlock.size(); i < size; i++) {
-        ByteString name = headerBlock.get(i).name.toAsciiLowercase();
-        Integer staticIndex = NAME_TO_FIRST_INDEX.get(name);
-        if (staticIndex != null) {
-          // Literal Header Field without Indexing - Indexed Name.
-          writeInt(staticIndex + 1, PREFIX_4_BITS, 0);
-          writeByteString(headerBlock.get(i).value);
-        } else {
-          out.writeByte(0x00); // Literal Header without Indexing - New Name.
-          writeByteString(name);
-          writeByteString(headerBlock.get(i).value);
-        }
-      }
-    }
-
-    // http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#section-4.1.1
-    void writeInt(int value, int prefixMask, int bits) throws IOException {
-      // Write the raw value for a single byte value.
-      if (value < prefixMask) {
-        out.writeByte(bits | value);
-        return;
-      }
-
-      // Write the mask to start a multibyte value.
-      out.writeByte(bits | prefixMask);
-      value -= prefixMask;
-
-      // Write 7 bits at a time 'til we're done.
-      while (value >= 0x80) {
-        int b = value & 0x7f;
-        out.writeByte(b | 0x80);
-        value >>>= 7;
-      }
-      out.writeByte(value);
-    }
-
-    void writeByteString(ByteString data) throws IOException {
-      writeInt(data.size(), PREFIX_7_BITS, 0);
-      out.write(data);
-    }
-  }
-
-  /**
-   * An HTTP/2 response cannot contain uppercase header characters and must
-   * be treated as malformed.
-   */
-  private static ByteString checkLowercase(ByteString name) throws IOException {
-    for (int i = 0, length = name.size(); i < length; i++) {
-      byte c = name.getByte(i);
-      if (c >= 'A' && c <= 'Z') {
-        throw new IOException("PROTOCOL_ERROR response malformed: mixed case name: " + name.utf8());
-      }
-    }
-    return name;
-  }
-}
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/CipherSuite.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/CipherSuite.java
similarity index 96%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/CipherSuite.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/CipherSuite.java
index bc2a9b7f0f3..1a9aab284bb 100644
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/CipherSuite.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/CipherSuite.java
@@ -354,6 +354,22 @@ public enum CipherSuite {
   // TLS_ECDHE_ECDSA_WITH_AES_256_CCM("TLS_ECDHE_ECDSA_WITH_AES_256_CCM", 0xc0ad, 7251, MAX_VALUE, MAX_VALUE),
   // TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8("TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8", 0xc0ae, 7251, MAX_VALUE, MAX_VALUE),
   // TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8("TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8", 0xc0af, 7251, MAX_VALUE, MAX_VALUE),
+
+  TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256("TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256", 0xcca8),
+  TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256("TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256", 0xcca9),
+  TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256("TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256", 0xccaa),
+  // TLS_PSK_WITH_CHACHA20_POLY1305_SHA256("TLS_PSK_WITH_CHACHA20_POLY1305_SHA256", 0xccab),
+  TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256("TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256", 0xccac),
+  // TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256("TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256", 0xccad),
+  // TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256("TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256", 0xccae),
+
+  // TLS 1.3 https://tools.ietf.org/html/rfc8446
+  TLS_AES_128_GCM_SHA256("TLS_AES_128_GCM_SHA256", 0x1301),
+  TLS_AES_256_GCM_SHA384("TLS_AES_256_GCM_SHA384", 0x1302),
+  TLS_CHACHA20_POLY1305_SHA256("TLS_CHACHA20_POLY1305_SHA256", 0x1303),
+  TLS_AES_128_CCM_SHA256("TLS_AES_128_CCM_SHA256", 0x1304),
+  TLS_AES_128_CCM_8_SHA256("TLS_AES_128_CCM_8_SHA256", 0x1305),
+
   ;
 
   final String javaName;
@@ -366,11 +382,18 @@ public enum CipherSuite {
    * @param sinceJavaVersion the first major Java release supporting this cipher suite.
    * @param sinceAndroidVersion the first Android SDK version supporting this cipher suite.
    */
+  @SuppressWarnings("UnusedVariable")
   private CipherSuite(
       String javaName, int value, int rfc, int sinceJavaVersion, int sinceAndroidVersion) {
     this.javaName = javaName;
   }
 
+  @SuppressWarnings("UnusedVariable")
+  private CipherSuite(
+          String javaName, int value) {
+    this.javaName = javaName;
+  }
+
   public static CipherSuite forJavaName(String javaName) {
     return javaName.startsWith("SSL_")
         ? valueOf("TLS_" + javaName.substring(4))
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/ConnectionSpec.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/ConnectionSpec.java
similarity index 88%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/ConnectionSpec.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/ConnectionSpec.java
index 457e9c301f3..b84a1ff94ee 100644
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/ConnectionSpec.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/ConnectionSpec.java
@@ -30,40 +30,43 @@
  */
 public final class ConnectionSpec {
 
-  // This is a subset of the cipher suites supported in Chrome 37, current as of 2014-10-5.
-  // All of these suites are available on Android 5.0; earlier releases support a subset of
-  // these suites. https://github.com/square/okhttp/issues/330
+  // This is nearly equal to the cipher suites supported in Chrome 72, current as of 2019-02-24.
+  // See https://tinyurl.com/okhttp-cipher-suites for availability.
   private static final CipherSuite[] APPROVED_CIPHER_SUITES = new CipherSuite[] {
-      CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-      CipherSuite.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-      CipherSuite.TLS_DHE_RSA_WITH_AES_128_GCM_SHA256,
-
-      // Note that the following cipher suites are all on HTTP/2's bad cipher suites list. We'll
-      // continue to include them until better suites are commonly available. For example, none
-      // of the better cipher suites listed above shipped with Android 4.4 or Java 7.
-      CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
-      CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
-      CipherSuite.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
-      CipherSuite.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
-      CipherSuite.TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
-      CipherSuite.TLS_DHE_DSS_WITH_AES_128_CBC_SHA,
-      CipherSuite.TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
-      CipherSuite.TLS_RSA_WITH_AES_128_GCM_SHA256,
-      CipherSuite.TLS_RSA_WITH_AES_128_CBC_SHA,
-      CipherSuite.TLS_RSA_WITH_AES_256_CBC_SHA,
-      CipherSuite.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
+          // TLSv1.3.
+          CipherSuite.TLS_AES_128_GCM_SHA256,
+          CipherSuite.TLS_AES_256_GCM_SHA384,
+          CipherSuite.TLS_CHACHA20_POLY1305_SHA256,
+
+          // TLSv1.0, TLSv1.1, TLSv1.2.
+          CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
+          CipherSuite.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
+          CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
+          CipherSuite.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
+          CipherSuite.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256,
+          CipherSuite.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+
+          // Note that the following cipher suites are all on HTTP/2's bad cipher suites list. We'll
+          // continue to include them until better suites are commonly available.
+          CipherSuite.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
+          CipherSuite.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
+          CipherSuite.TLS_RSA_WITH_AES_128_GCM_SHA256,
+          CipherSuite.TLS_RSA_WITH_AES_256_GCM_SHA384,
+          CipherSuite.TLS_RSA_WITH_AES_128_CBC_SHA,
+          CipherSuite.TLS_RSA_WITH_AES_256_CBC_SHA,
+          CipherSuite.TLS_RSA_WITH_3DES_EDE_CBC_SHA
   };
 
   /** A modern TLS connection with extensions like SNI and ALPN available. */
   public static final ConnectionSpec MODERN_TLS = new Builder(true)
       .cipherSuites(APPROVED_CIPHER_SUITES)
-      .tlsVersions(TlsVersion.TLS_1_2, TlsVersion.TLS_1_1, TlsVersion.TLS_1_0)
+      .tlsVersions(TlsVersion.TLS_1_3, TlsVersion.TLS_1_2)
       .supportsTlsExtensions(true)
       .build();
 
   /** A backwards-compatible fallback connection for interop with obsolete servers. */
   public static final ConnectionSpec COMPATIBLE_TLS = new Builder(MODERN_TLS)
-      .tlsVersions(TlsVersion.TLS_1_0)
+      .tlsVersions(TlsVersion.TLS_1_3, TlsVersion.TLS_1_2, TlsVersion.TLS_1_1, TlsVersion.TLS_1_0)
       .supportsTlsExtensions(true)
       .build();
 
diff --git a/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Credentials.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Credentials.java
new file mode 100644
index 00000000000..04ad6d5f533
--- /dev/null
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Credentials.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2014 Square, Inc.
+ *
+ * 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.
+ */
+/*
+ * Forked from OkHttp 2.7.0
+ */
+package io.grpc.okhttp.internal;
+
+import java.io.UnsupportedEncodingException;
+import okio.ByteString;
+
+/** Factory for HTTP authorization credentials. */
+public final class Credentials {
+  private Credentials() {
+  }
+
+  /** Returns an auth credential for the Basic scheme. */
+  @SuppressWarnings("StringCharset") // Changing old code doesn't fix any bugs and using
+                                     // Charsets/StandardCharsets adds bloat
+  public static String basic(String userName, String password) {
+    try {
+      String usernameAndPassword = userName + ":" + password;
+      byte[] bytes = usernameAndPassword.getBytes("ISO-8859-1");
+      String encoded = ByteString.of(bytes).base64();
+      return "Basic " + encoded;
+    } catch (UnsupportedEncodingException e) {
+      throw new AssertionError();
+    }
+  }
+}
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/DistinguishedNameParser.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/DistinguishedNameParser.java
similarity index 99%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/DistinguishedNameParser.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/DistinguishedNameParser.java
index dd6deb297ea..166b0979434 100644
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/DistinguishedNameParser.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/DistinguishedNameParser.java
@@ -137,6 +137,7 @@ private String quotedAV() {
   }
 
   // gets hex string attribute value: "#" hexstring
+  @SuppressWarnings("NarrowingCompoundAssignment")
   private String hexAV() {
     if (pos + 4 >= length) {
       // encoded byte array  must be not less then 4 c
diff --git a/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Headers.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Headers.java
new file mode 100644
index 00000000000..115f9964008
--- /dev/null
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Headers.java
@@ -0,0 +1,155 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You 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.
+ */
+/*
+ * Forked from OkHttp 2.7.0 com.squareup.okhttp.Headers
+ */
+package io.grpc.okhttp.internal;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+/**
+ * The header fields of a single HTTP message. Values are uninterpreted strings;
+ *
+ * <p>This class trims whitespace from values. It never returns values with
+ * leading or trailing whitespace.
+ *
+ * <p>Instances of this class are immutable. Use {@link Builder} to create
+ * instances.
+ */
+public final class Headers {
+  private final String[] namesAndValues;
+
+  private Headers(Builder builder) {
+    this.namesAndValues = builder.namesAndValues.toArray(new String[builder.namesAndValues.size()]);
+  }
+
+  /** Returns the last value corresponding to the specified field, or null. */
+  public String get(String name) {
+    return get(namesAndValues, name);
+  }
+
+  /** Returns the number of field values. */
+  public int size() {
+    return namesAndValues.length / 2;
+  }
+
+  /** Returns the field at {@code position} or null if that is out of range. */
+  public String name(int index) {
+    int nameIndex = index * 2;
+    if (nameIndex < 0 || nameIndex >= namesAndValues.length) {
+      return null;
+    }
+    return namesAndValues[nameIndex];
+  }
+
+  /** Returns the value at {@code index} or null if that is out of range. */
+  public String value(int index) {
+    int valueIndex = index * 2 + 1;
+    if (valueIndex < 0 || valueIndex >= namesAndValues.length) {
+      return null;
+    }
+    return namesAndValues[valueIndex];
+  }
+
+  public Builder newBuilder() {
+    Builder result = new Builder();
+    Collections.addAll(result.namesAndValues, namesAndValues);
+    return result;
+  }
+
+  @Override public String toString() {
+    StringBuilder result = new StringBuilder();
+    for (int i = 0, size = size(); i < size; i++) {
+      result.append(name(i)).append(": ").append(value(i)).append("\n");
+    }
+    return result.toString();
+  }
+
+  private static String get(String[] namesAndValues, String name) {
+    for (int i = namesAndValues.length - 2; i >= 0; i -= 2) {
+      if (name.equalsIgnoreCase(namesAndValues[i])) {
+        return namesAndValues[i + 1];
+      }
+    }
+    return null;
+  }
+
+  public static final class Builder {
+    private final List<String> namesAndValues = new ArrayList<>(20);
+
+    /**
+     * Add a field with the specified value without any validation. Only
+     * appropriate for headers from the remote peer or cache.
+     */
+    Builder addLenient(String name, String value) {
+      namesAndValues.add(name);
+      namesAndValues.add(value.trim());
+      return this;
+    }
+
+    public Builder removeAll(String name) {
+      for (int i = 0; i < namesAndValues.size(); i += 2) {
+        if (name.equalsIgnoreCase(namesAndValues.get(i))) {
+          namesAndValues.remove(i); // name
+          namesAndValues.remove(i); // value
+          i -= 2;
+        }
+      }
+      return this;
+    }
+
+    /**
+     * Set a field with the specified value. If the field is not found, it is
+     * added. If the field is found, the existing values are replaced.
+     */
+    public Builder set(String name, String value) {
+      checkNameAndValue(name, value);
+      removeAll(name);
+      addLenient(name, value);
+      return this;
+    }
+
+    private void checkNameAndValue(String name, String value) {
+      if (name == null) throw new IllegalArgumentException("name == null");
+      if (name.isEmpty()) throw new IllegalArgumentException("name is empty");
+      for (int i = 0, length = name.length(); i < length; i++) {
+        char c = name.charAt(i);
+        if (c <= '\u001f' || c >= '\u007f') {
+          throw new IllegalArgumentException(String.format(
+              Locale.US,
+              "Unexpected char %#04x at %d in header name: %s", (int) c, i, name));
+        }
+      }
+      if (value == null) throw new IllegalArgumentException("value == null");
+      for (int i = 0, length = value.length(); i < length; i++) {
+        char c = value.charAt(i);
+        if (c <= '\u001f' || c >= '\u007f') {
+          throw new IllegalArgumentException(String.format(
+              Locale.US,
+              "Unexpected char %#04x at %d in header value: %s", (int) c, i, value));
+        }
+      }
+    }
+
+    public Headers build() {
+      return new Headers(this);
+    }
+  }
+}
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/OkHostnameVerifier.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/OkHostnameVerifier.java
similarity index 87%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/OkHostnameVerifier.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/OkHostnameVerifier.java
index b7b1d5367f2..f6efb2d90e7 100644
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/OkHostnameVerifier.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/OkHostnameVerifier.java
@@ -29,10 +29,13 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.regex.Pattern;
+import java.nio.charset.StandardCharsets;
 import javax.net.ssl.HostnameVerifier;
 import javax.net.ssl.SSLException;
 import javax.net.ssl.SSLSession;
 import javax.security.auth.x500.X500Principal;
+import com.google.common.base.Utf8;
+import com.google.common.base.Ascii;
 
 /**
  * A HostnameVerifier consistent with <a
@@ -63,6 +66,9 @@ private OkHostnameVerifier() {
 
   @Override
   public boolean verify(String host, SSLSession session) {
+    if (!isAscii(host)) {
+      return false;
+    }
     try {
       Certificate[] certificates = session.getPeerCertificates();
       return verify(host, (X509Certificate) certificates[0]);
@@ -71,7 +77,7 @@ public boolean verify(String host, SSLSession session) {
     }
   }
 
-  public boolean verify(String host, X509Certificate certificate) {
+  private boolean verify(String host, X509Certificate certificate) {
     return verifyAsIpAddress(host)
         ? verifyIpAddress(host, certificate)
         : verifyHostName(host, certificate);
@@ -98,7 +104,7 @@ private boolean verifyIpAddress(String ipAddress, X509Certificate certificate) {
    * Returns true if {@code certificate} matches {@code hostName}.
    */
   private boolean verifyHostName(String hostName, X509Certificate certificate) {
-    hostName = hostName.toLowerCase(Locale.US);
+    hostName = Ascii.toLowerCase(hostName);
     boolean hasDns = false;
     List<String> altNames = getSubjectAltNames(certificate, ALT_DNS_NAME);
     for (int i = 0, size = altNames.size(); i < size; i++) {
@@ -120,17 +126,19 @@ private boolean verifyHostName(String hostName, X509Certificate certificate) {
     return false;
   }
 
+  @SuppressWarnings("MixedMutabilityReturnType")
   public static List<String> allSubjectAltNames(X509Certificate certificate) {
     List<String> altIpaNames = getSubjectAltNames(certificate, ALT_IPA_NAME);
     List<String> altDnsNames = getSubjectAltNames(certificate, ALT_DNS_NAME);
-    List<String> result = new ArrayList<String>(altIpaNames.size() + altDnsNames.size());
+    List<String> result = new ArrayList<>(altIpaNames.size() + altDnsNames.size());
     result.addAll(altIpaNames);
     result.addAll(altDnsNames);
     return result;
   }
 
+  @SuppressWarnings("MixedMutabilityReturnType")
   private static List<String> getSubjectAltNames(X509Certificate certificate, int type) {
-    List<String> result = new ArrayList<String>();
+    List<String> result = new ArrayList<>();
     try {
       Collection<?> subjectAltNames = certificate.getSubjectAlternativeNames();
       if (subjectAltNames == null) {
@@ -168,13 +176,13 @@ private static List<String> getSubjectAltNames(X509Certificate certificate, int
   private boolean verifyHostName(String hostName, String pattern) {
     // Basic sanity checks
     // Check length == 0 instead of .isEmpty() to support Java 5.
-    if ((hostName == null) || (hostName.length() == 0) || (hostName.startsWith("."))
-        || (hostName.endsWith(".."))) {
+    if (hostName == null || hostName.length() == 0 || hostName.startsWith(".")
+        || hostName.endsWith("..")) {
       // Invalid domain name
       return false;
     }
-    if ((pattern == null) || (pattern.length() == 0) || (pattern.startsWith("."))
-        || (pattern.endsWith(".."))) {
+    if (pattern == null || pattern.length() == 0 || pattern.startsWith(".")
+        || pattern.endsWith("..")) {
       // Invalid pattern/domain name
       return false;
     }
@@ -196,7 +204,7 @@ private boolean verifyHostName(String hostName, String pattern) {
     }
     // hostName and pattern are now absolute domain names.
 
-    pattern = pattern.toLowerCase(Locale.US);
+    pattern = Ascii.toLowerCase(pattern);
     // hostName and pattern are now in lower case -- domain names are case-insensitive.
 
     if (!pattern.contains("*")) {
@@ -215,7 +223,7 @@ private boolean verifyHostName(String hostName, String pattern) {
     //    sub.test.example.com.
     // 3. Wildcard patterns for single-label domain names are not permitted.
 
-    if ((!pattern.startsWith("*.")) || (pattern.indexOf('*', 1) != -1)) {
+    if (!pattern.startsWith("*.") || pattern.indexOf('*', 1) != -1) {
       // Asterisk (*) is only permitted in the left-most domain name label and must be the only
       // character in that label
       return false;
@@ -243,8 +251,8 @@ private boolean verifyHostName(String hostName, String pattern) {
 
     // Check that asterisk did not match across domain name labels.
     int suffixStartIndexInHostName = hostName.length() - suffix.length();
-    if ((suffixStartIndexInHostName > 0)
-        && (hostName.lastIndexOf('.', suffixStartIndexInHostName - 1) != -1)) {
+    if (suffixStartIndexInHostName > 0
+        && hostName.lastIndexOf('.', suffixStartIndexInHostName - 1) != -1) {
       // Asterisk is matching across domain name labels -- not permitted.
       return false;
     }
@@ -252,4 +260,13 @@ private boolean verifyHostName(String hostName, String pattern) {
     // hostName matches pattern
     return true;
   }
+
+  /**
+   * Returns true if {@code input} is an ASCII string.
+   * @param input the string to check.
+   */
+  private static boolean isAscii(String input) {
+    // Only ASCII characters are 1 byte in UTF-8.
+    return Utf8.encodedLength(input) == input.length();
+  }
 }
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/OptionalMethod.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/OptionalMethod.java
similarity index 96%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/OptionalMethod.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/OptionalMethod.java
index cb9357fb157..a93c8384f2b 100644
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/OptionalMethod.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/OptionalMethod.java
@@ -169,6 +169,12 @@ private Method getMethod(Class<?> clazz) {
   private static Method getPublicMethod(Class<?> clazz, String methodName, Class[] parameterTypes) {
     Method method = null;
     try {
+      if (clazz == null) {
+        return null;
+      }
+      if ((clazz.getModifiers() & Modifier.PUBLIC) == 0) {
+        return getPublicMethod(clazz.getSuperclass(), methodName, parameterTypes);
+      }
       method = clazz.getMethod(methodName, parameterTypes);
       if ((method.getModifiers() & Modifier.PUBLIC) == 0) {
         method = null;
diff --git a/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Platform.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Platform.java
new file mode 100644
index 00000000000..29ea8055b26
--- /dev/null
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Platform.java
@@ -0,0 +1,588 @@
+/*
+ * Copyright (C) 2012 Square, Inc.
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * 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.
+ */
+/*
+ * Forked from OkHttp 2.5.0
+ */
+
+package io.grpc.okhttp.internal;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.net.SocketException;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.security.Provider;
+import java.security.Security;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSocket;
+import okio.Buffer;
+
+/**
+ * Access to platform-specific features.
+ *
+ * <h3>Server name indication (SNI)</h3>
+ *
+ * Supported on Android 2.3+.
+ *
+ * <h3>Session Tickets</h3>
+ *
+ * Supported on Android 2.3+.
+ *
+ * <h3>Android Traffic Stats (Socket Tagging)</h3>
+ *
+ * Supported on Android 4.0+.
+ *
+ * <h3>ALPN (Application Layer Protocol Negotiation)</h3>
+ *
+ * Supported on Android 5.0+. The APIs were present in Android 4.4, but that implementation was
+ * unstable.
+ *
+ * <p>Supported on OpenJDK 9+.
+ *
+ * <p>Supported on OpenJDK 7 and 8 (via the JettyALPN-boot library).
+ */
+public class Platform {
+  public static final Logger logger = Logger.getLogger(Platform.class.getName());
+
+  public enum TlsExtensionType {
+    ALPN_AND_NPN,
+    NPN,
+    NONE,
+  }
+
+  /**
+   * List of recognized security providers. The first recognized security provider according to the
+   * preference order returned by {@link Security#getProviders} will be selected.
+   */
+  private static final String[] ANDROID_SECURITY_PROVIDERS =
+      new String[] {
+        // See https://developer.android.com/training/articles/security-gms-provider.html
+        "com.google.android.gms.org.conscrypt.OpenSSLProvider",
+        "org.conscrypt.OpenSSLProvider",
+        "com.android.org.conscrypt.OpenSSLProvider",
+        "org.apache.harmony.xnet.provider.jsse.OpenSSLProvider",
+        "com.google.android.libraries.stitch.sslguard.SslGuardProvider"
+      };
+
+  private static final Platform PLATFORM = findPlatform();
+
+  public static Platform get() {
+    return PLATFORM;
+  }
+
+  private final Provider sslProvider;
+
+  public Platform(Provider sslProvider) {
+    this.sslProvider = sslProvider;
+  }
+
+  /** Prefix used on custom headers. */
+  public String getPrefix() {
+    return "OkHttp";
+  }
+
+  public void logW(String warning) {
+    System.out.println(warning);
+  }
+
+  public void tagSocket(Socket socket) throws SocketException {
+  }
+
+  public void untagSocket(Socket socket) throws SocketException {
+  }
+
+  public Provider getProvider() {
+    return sslProvider;
+  }
+
+  /** Returns the TLS extension type available (ALPN and NPN, NPN, or None). */
+  public TlsExtensionType getTlsExtensionType() {
+    return TlsExtensionType.NONE;
+  }
+
+  /**
+   * Configure TLS extensions on {@code sslSocket} for {@code route}.
+   *
+   * @param hostname non-null for client-side handshakes; null for
+   *     server-side handshakes.
+   */
+  public void configureTlsExtensions(SSLSocket sslSocket, String hostname,
+      List<Protocol> protocols) {
+  }
+
+  /**
+   * Called after the TLS handshake to release resources allocated by {@link
+   * #configureTlsExtensions}.
+   */
+  public void afterHandshake(SSLSocket sslSocket) {
+  }
+
+  /** Returns the negotiated protocol, or null if no protocol was negotiated. */
+  public String getSelectedProtocol(SSLSocket socket) {
+    return null;
+  }
+
+  public void connectSocket(Socket socket, InetSocketAddress address,
+      int connectTimeout) throws IOException {
+    socket.connect(address, connectTimeout);
+  }
+
+  /** Attempt to match the host runtime to a capable Platform implementation. */
+  private static Platform findPlatform() {
+    Provider androidOrAppEngineProvider = getAndroidSecurityProvider();
+    if (androidOrAppEngineProvider != null) {
+      // Attempt to find Android 2.3+ APIs.
+      OptionalMethod<Socket> setUseSessionTickets
+          = new OptionalMethod<>(null, "setUseSessionTickets", boolean.class);
+      OptionalMethod<Socket> setHostname
+          = new OptionalMethod<>(null, "setHostname", String.class);
+      Method trafficStatsTagSocket = null;
+      Method trafficStatsUntagSocket = null;
+      OptionalMethod<Socket> getAlpnSelectedProtocol =
+          new OptionalMethod<>(byte[].class, "getAlpnSelectedProtocol");
+      OptionalMethod<Socket> setAlpnProtocols =
+          new OptionalMethod<>(null, "setAlpnProtocols", byte[].class);
+
+      // Attempt to find Android 4.0+ APIs.
+      try {
+        Class<?> trafficStats = Class.forName("android.net.TrafficStats");
+        trafficStatsTagSocket = trafficStats.getMethod("tagSocket", Socket.class);
+        trafficStatsUntagSocket = trafficStats.getMethod("untagSocket", Socket.class);
+      } catch (ClassNotFoundException ignored) {
+        // On older Android
+      } catch (NoSuchMethodException ignored) {
+        // On older Android
+      }
+
+      TlsExtensionType tlsExtensionType;
+      if (androidOrAppEngineProvider.getName().equals("GmsCore_OpenSSL")
+          || androidOrAppEngineProvider.getName().equals("Conscrypt")
+          || androidOrAppEngineProvider.getName().equals("Ssl_Guard")) {
+        tlsExtensionType = TlsExtensionType.ALPN_AND_NPN;
+      } else if (isAtLeastAndroid5()) {
+        tlsExtensionType = TlsExtensionType.ALPN_AND_NPN;
+      } else if (isAtLeastAndroid41()) {
+        tlsExtensionType = TlsExtensionType.NPN;
+      } else {
+        tlsExtensionType = TlsExtensionType.NONE;
+      }
+      return new Android(
+          setUseSessionTickets,
+          setHostname,
+          trafficStatsTagSocket,
+          trafficStatsUntagSocket,
+          getAlpnSelectedProtocol,
+          setAlpnProtocols,
+          androidOrAppEngineProvider,
+          tlsExtensionType);
+    }
+    Provider sslProvider;
+    try {
+      sslProvider = SSLContext.getDefault().getProvider();
+    } catch (NoSuchAlgorithmException nsae) {
+      throw new RuntimeException(nsae);
+    }
+
+    // Find JDK9+ ALPN support
+    try {
+      // getApplicationProtocol() may throw UnsupportedOperationException, so first construct a
+      // dummy SSLEngine and verify the method does not throw.
+      SSLContext context = SSLContext.getInstance("TLS", sslProvider);
+      context.init(null, null, null);
+      SSLEngine engine = context.createSSLEngine();
+      Method getEngineApplicationProtocol = SSLEngine.class.getMethod("getApplicationProtocol");
+      getEngineApplicationProtocol.invoke(engine);
+
+      Method setApplicationProtocols =
+          SSLParameters.class.getMethod("setApplicationProtocols", String[].class);
+      Method getApplicationProtocol = SSLSocket.class.getMethod("getApplicationProtocol");
+      return new JdkAlpnPlatform(sslProvider, setApplicationProtocols, getApplicationProtocol);
+    } catch (NoSuchAlgorithmException ignored) {
+      // On older Java
+    } catch (KeyManagementException ignored) {
+      // On older Java
+    } catch (IllegalAccessException ignored) {
+      // On older Java
+    } catch (NoSuchMethodException ignored) {
+      // On older Java
+    } catch (InvocationTargetException ignored) {
+      // On older Java
+    }
+
+    // Find Jetty's ALPN extension for OpenJDK.
+    try {
+      String negoClassName = "org.eclipse.jetty.alpn.ALPN";
+      Class<?> negoClass = Class.forName(negoClassName);
+      Class<?> providerClass = Class.forName(negoClassName + "$Provider");
+      Class<?> clientProviderClass = Class.forName(negoClassName + "$ClientProvider");
+      Class<?> serverProviderClass = Class.forName(negoClassName + "$ServerProvider");
+      Method putMethod = negoClass.getMethod("put", SSLSocket.class, providerClass);
+      Method getMethod = negoClass.getMethod("get", SSLSocket.class);
+      Method removeMethod = negoClass.getMethod("remove", SSLSocket.class);
+      return new JdkWithJettyBootPlatform(
+          putMethod, getMethod, removeMethod, clientProviderClass, serverProviderClass,
+          sslProvider);
+    } catch (ClassNotFoundException ignored) {
+      // No Jetty ALPN
+    } catch (NoSuchMethodException ignored) {
+      // Weird Jetty ALPN
+    }
+
+    // TODO(ericgribkoff) Return null here
+    return new Platform(sslProvider);
+  }
+
+  private static boolean isAtLeastAndroid5() {
+    try {
+      Platform.class
+          .getClassLoader()
+          .loadClass("android.net.Network"); // Arbitrary class added in Android 5.0.
+      return true;
+    } catch (ClassNotFoundException e) {
+      logger.log(Level.FINE, "Can't find class", e);
+    }
+    return false;
+  }
+
+  private static boolean isAtLeastAndroid41() {
+    try {
+      Platform.class
+          .getClassLoader()
+          .loadClass("android.app.ActivityOptions"); // Arbitrary class added in Android 4.1.
+      return true;
+    } catch (ClassNotFoundException e) {
+      logger.log(Level.FINE, "Can't find class", e);
+    }
+    return false;
+  }
+
+  /**
+   * Select the first recognized security provider according to the preference order returned by
+   * {@link Security#getProviders}.
+   */
+  private static Provider getAndroidSecurityProvider() {
+    Provider[] providers = Security.getProviders();
+    for (Provider availableProvider : providers) {
+      for (String providerClassName : ANDROID_SECURITY_PROVIDERS) {
+        if (providerClassName.equals(availableProvider.getClass().getName())) {
+          logger.log(Level.FINE, "Found registered provider {0}", providerClassName);
+          return availableProvider;
+        }
+      }
+    }
+    return null;
+  }
+
+  /** Android 2.3 or better, or AppEngine with Conscrypt. */
+  private static class Android extends Platform {
+
+    private final OptionalMethod<Socket> setUseSessionTickets;
+    private final OptionalMethod<Socket> setHostname;
+
+    // Non-null on Android 4.0+.
+    private final Method trafficStatsTagSocket;
+    private final Method trafficStatsUntagSocket;
+
+    // Non-null on Android 5.0+.
+    private final OptionalMethod<Socket> getAlpnSelectedProtocol;
+    private final OptionalMethod<Socket> setAlpnProtocols;
+
+    private final TlsExtensionType tlsExtensionType;
+
+    public Android(
+        OptionalMethod<Socket> setUseSessionTickets,
+        OptionalMethod<Socket> setHostname,
+        Method trafficStatsTagSocket,
+        Method trafficStatsUntagSocket,
+        OptionalMethod<Socket> getAlpnSelectedProtocol,
+        OptionalMethod<Socket> setAlpnProtocols,
+        Provider provider,
+        TlsExtensionType tlsExtensionType) {
+      super(provider);
+      this.setUseSessionTickets = setUseSessionTickets;
+      this.setHostname = setHostname;
+      this.trafficStatsTagSocket = trafficStatsTagSocket;
+      this.trafficStatsUntagSocket = trafficStatsUntagSocket;
+      this.getAlpnSelectedProtocol = getAlpnSelectedProtocol;
+      this.setAlpnProtocols = setAlpnProtocols;
+      this.tlsExtensionType = tlsExtensionType;
+    }
+
+    @Override
+    public TlsExtensionType getTlsExtensionType() {
+      return tlsExtensionType;
+    }
+
+    @Override public void connectSocket(Socket socket, InetSocketAddress address,
+        int connectTimeout) throws IOException {
+      try {
+        socket.connect(address, connectTimeout);
+      } catch (SecurityException se) {
+        // Before android 4.3, socket.connect could throw a SecurityException
+        // if opening a socket resulted in an EACCES error.
+        IOException ioException = new IOException("Exception in connect");
+        ioException.initCause(se);
+        throw ioException;
+      }
+    }
+
+    @Override public void configureTlsExtensions(
+        SSLSocket sslSocket, String hostname, List<Protocol> protocols) {
+      // Enable SNI and session tickets.
+      if (hostname != null) {
+        setUseSessionTickets.invokeOptionalWithoutCheckedException(sslSocket, true);
+        setHostname.invokeOptionalWithoutCheckedException(sslSocket, hostname);
+      }
+
+      // Enable ALPN.
+      if (setAlpnProtocols.isSupported(sslSocket)) {
+        Object[] parameters = { concatLengthPrefixed(protocols) };
+        setAlpnProtocols.invokeWithoutCheckedException(sslSocket, parameters);
+      }
+    }
+
+    @Override public String getSelectedProtocol(SSLSocket socket) {
+      if (!getAlpnSelectedProtocol.isSupported(socket)) return null;
+
+      byte[] alpnResult = (byte[]) getAlpnSelectedProtocol.invokeWithoutCheckedException(socket);
+      return alpnResult != null ? new String(alpnResult, Util.UTF_8) : null;
+    }
+
+    @Override public void tagSocket(Socket socket) throws SocketException {
+      if (trafficStatsTagSocket == null) return;
+
+      try {
+        trafficStatsTagSocket.invoke(null, socket);
+      } catch (IllegalAccessException e) {
+        throw new RuntimeException(e);
+      } catch (InvocationTargetException e) {
+        throw new RuntimeException(e.getCause());
+      }
+    }
+
+    @Override public void untagSocket(Socket socket) throws SocketException {
+      if (trafficStatsUntagSocket == null) return;
+
+      try {
+        trafficStatsUntagSocket.invoke(null, socket);
+      } catch (IllegalAccessException e) {
+        throw new RuntimeException(e);
+      } catch (InvocationTargetException e) {
+        throw new RuntimeException(e.getCause());
+      }
+    }
+  }
+
+  /** OpenJDK 9+. */
+  private static class JdkAlpnPlatform extends Platform {
+    private final Method setApplicationProtocols;
+    private final Method getApplicationProtocol;
+
+    private JdkAlpnPlatform(
+        Provider provider, Method setApplicationProtocols, Method getApplicationProtocol) {
+      super(provider);
+      this.setApplicationProtocols = setApplicationProtocols;
+      this.getApplicationProtocol = getApplicationProtocol;
+    }
+
+    @Override
+    public TlsExtensionType getTlsExtensionType() {
+      return TlsExtensionType.ALPN_AND_NPN;
+    }
+
+    @Override
+    public void configureTlsExtensions(
+        SSLSocket sslSocket, String hostname, List<Protocol> protocols) {
+      SSLParameters parameters = sslSocket.getSSLParameters();
+      List<String> names = new ArrayList<>(protocols.size());
+      for (Protocol protocol : protocols) {
+        if (protocol == Protocol.HTTP_1_0) continue; // No HTTP/1.0 for ALPN.
+        names.add(protocol.toString());
+      }
+      try {
+        setApplicationProtocols.invoke(
+            parameters, new Object[] {names.toArray(new String[names.size()])});
+      } catch (IllegalAccessException e) {
+        throw new RuntimeException(e);
+      } catch (InvocationTargetException e) {
+        throw new RuntimeException(e);
+      }
+      sslSocket.setSSLParameters(parameters);
+    }
+
+    /** Returns the negotiated protocol, or null if no protocol was negotiated. */
+    @Override
+    public String getSelectedProtocol(SSLSocket socket) {
+      try {
+        return (String) getApplicationProtocol.invoke(socket);
+      } catch (IllegalAccessException e) {
+        throw new RuntimeException(e);
+      } catch (InvocationTargetException e) {
+        throw new RuntimeException(e);
+      }
+    }
+  }
+
+  /**
+   * OpenJDK 7+ with {@code org.mortbay.jetty.alpn/alpn-boot} in the boot class path.
+   */
+  private static class JdkWithJettyBootPlatform extends Platform {
+    private final Method putMethod;
+    private final Method getMethod;
+    private final Method removeMethod;
+    private final Class<?> clientProviderClass;
+    private final Class<?> serverProviderClass;
+
+    public JdkWithJettyBootPlatform(Method putMethod, Method getMethod, Method removeMethod,
+        Class<?> clientProviderClass, Class<?> serverProviderClass, Provider provider) {
+      super(provider);
+      this.putMethod = putMethod;
+      this.getMethod = getMethod;
+      this.removeMethod = removeMethod;
+      this.clientProviderClass = clientProviderClass;
+      this.serverProviderClass = serverProviderClass;
+    }
+
+    @Override
+    public TlsExtensionType getTlsExtensionType() {
+      return TlsExtensionType.ALPN_AND_NPN;
+    }
+
+    @Override public void configureTlsExtensions(
+        SSLSocket sslSocket, String hostname, List<Protocol> protocols) {
+      List<String> names = new ArrayList<>(protocols.size());
+      for (int i = 0, size = protocols.size(); i < size; i++) {
+        Protocol protocol = protocols.get(i);
+        if (protocol == Protocol.HTTP_1_0) continue; // No HTTP/1.0 for ALPN.
+        names.add(protocol.toString());
+      }
+      try {
+        Object provider = Proxy.newProxyInstance(Platform.class.getClassLoader(),
+            new Class<?>[] { clientProviderClass, serverProviderClass }, new JettyNegoProvider(names));
+        putMethod.invoke(null, sslSocket, provider);
+      } catch (InvocationTargetException e) {
+        throw new AssertionError(e);
+      } catch (IllegalAccessException e) {
+        throw new AssertionError(e);
+      }
+    }
+
+    @Override public void afterHandshake(SSLSocket sslSocket) {
+      try {
+        removeMethod.invoke(null, sslSocket);
+      } catch (IllegalAccessException ignored) {
+        throw new AssertionError();
+      } catch (InvocationTargetException ex) {
+        // This would be very surprising and there's not much to do about it
+        logger.log(Level.FINE, "Failed to remove SSLSocket from Jetty ALPN", ex);
+      }
+    }
+
+    @Override public String getSelectedProtocol(SSLSocket socket) {
+      try {
+        JettyNegoProvider provider =
+            (JettyNegoProvider) Proxy.getInvocationHandler(getMethod.invoke(null, socket));
+        if (!provider.unsupported && provider.selected == null) {
+          logger.log(Level.INFO, "ALPN callback dropped: SPDY and HTTP/2 are disabled. "
+              + "Is alpn-boot on the boot class path?");
+          return null;
+        }
+        return provider.unsupported ? null : provider.selected;
+      } catch (InvocationTargetException e) {
+        throw new AssertionError();
+      } catch (IllegalAccessException e) {
+        throw new AssertionError();
+      }
+    }
+  }
+
+  /**
+   * Handle the methods of ALPN's ClientProvider and ServerProvider
+   * without a compile-time dependency on those interfaces.
+   */
+  private static class JettyNegoProvider implements InvocationHandler {
+    /** This peer's supported protocols. */
+    private final List<String> protocols;
+    /** Set when remote peer notifies ALPN is unsupported. */
+    private boolean unsupported;
+    /** The protocol the server selected. */
+    private String selected;
+
+    public JettyNegoProvider(List<String> protocols) {
+      this.protocols = protocols;
+    }
+
+    @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+      String methodName = method.getName();
+      Class<?> returnType = method.getReturnType();
+      if (args == null) {
+        args = Util.EMPTY_STRING_ARRAY;
+      }
+      if (methodName.equals("supports") && boolean.class == returnType) {
+        return true; // ALPN is supported.
+      } else if (methodName.equals("unsupported") && void.class == returnType) {
+        this.unsupported = true; // Peer doesn't support ALPN.
+        return null;
+      } else if (methodName.equals("protocols") && args.length == 0) {
+        return protocols; // Client advertises these protocols.
+      } else if ((methodName.equals("selectProtocol") || methodName.equals("select"))
+          && String.class == returnType && args.length == 1 && args[0] instanceof List) {
+        @SuppressWarnings("unchecked")
+        List<String> peerProtocols = (List) args[0];
+        // Pick the first known protocol the peer advertises.
+        for (int i = 0, size = peerProtocols.size(); i < size; i++) {
+          if (protocols.contains(peerProtocols.get(i))) {
+            return selected = peerProtocols.get(i);
+          }
+        }
+        return selected = protocols.get(0); // On no intersection, try peer's first protocol.
+      } else if ((methodName.equals("protocolSelected") || methodName.equals("selected"))
+          && args.length == 1) {
+        this.selected = (String) args[0]; // Server selected this protocol.
+        return null;
+      } else {
+        return method.invoke(this, args);
+      }
+    }
+  }
+
+  /**
+   * Returns the concatenation of 8-bit, length prefixed protocol names.
+   * http://tools.ietf.org/html/draft-agl-tls-nextprotoneg-04#page-4
+   */
+  public static byte[] concatLengthPrefixed(List<Protocol> protocols) {
+    Buffer result = new Buffer();
+    for (int i = 0, size = protocols.size(); i < size; i++) {
+      Protocol protocol = protocols.get(i);
+      if (protocol == Protocol.HTTP_1_0) continue; // No HTTP/1.0 for ALPN.
+      result.writeByte(protocol.toString().length());
+      result.writeUtf8(protocol.toString());
+    }
+    return result.readByteArray();
+  }
+}
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/Protocol.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Protocol.java
similarity index 87%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/Protocol.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Protocol.java
index 7b5a3ae76a3..0c9244607f3 100644
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/Protocol.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Protocol.java
@@ -70,16 +70,7 @@ public enum Protocol {
    * , present in Java 8+ and Android 5+. Servers that enforce this may send an
    * exception message including the string {@code INADEQUATE_SECURITY}.
    */
-  HTTP_2("h2"),
-
-  /**
-   * The experimental "grpc-exp" string identifies gRPC (and by implication
-   * HTTP/2) when used over TLS. This indicates to the server that the client
-   * will only send gRPC traffic on the h2 connection and is negotiated in
-   * preference to h2 when the client and server support it, but is not
-   * standardized. Support for this may be removed at any time.
-   */
-  GRPC_EXP("grpc-exp");
+  HTTP_2("h2");
 
   private final String protocol;
 
@@ -96,7 +87,6 @@ public static Protocol get(String protocol) throws IOException {
     if (protocol.equals(HTTP_1_0.protocol)) return HTTP_1_0;
     if (protocol.equals(HTTP_1_1.protocol)) return HTTP_1_1;
     if (protocol.equals(HTTP_2.protocol)) return HTTP_2;
-    if (protocol.equals(GRPC_EXP.protocol)) return GRPC_EXP;
     if (protocol.equals(SPDY_3.protocol)) return SPDY_3;
     throw new IOException("Unexpected protocol: " + protocol);
   }
diff --git a/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/StatusLine.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/StatusLine.java
new file mode 100644
index 00000000000..ab72ee2d294
--- /dev/null
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/StatusLine.java
@@ -0,0 +1,87 @@
+/*
+ * Forked from OkHttp 2.7.0
+ */
+package io.grpc.okhttp.internal;
+
+import java.io.IOException;
+import java.net.ProtocolException;
+
+/** An HTTP response status line like "HTTP/1.1 200 OK". */
+public final class StatusLine {
+  /** Numeric status code, 307: Temporary Redirect. */
+  public static final int HTTP_TEMP_REDIRECT = 307;
+  public static final int HTTP_PERM_REDIRECT = 308;
+  public static final int HTTP_CONTINUE = 100;
+
+  public final Protocol protocol;
+  public final int code;
+  public final String message;
+
+  public StatusLine(Protocol protocol, int code, String message) {
+    this.protocol = protocol;
+    this.code = code;
+    this.message = message;
+  }
+
+  public static StatusLine parse(String statusLine) throws IOException {
+    // H T T P / 1 . 1   2 0 0   T e m p o r a r y   R e d i r e c t
+    // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
+
+    // Parse protocol like "HTTP/1.1" followed by a space.
+    int codeStart;
+    Protocol protocol;
+    if (statusLine.startsWith("HTTP/1.")) {
+      if (statusLine.length() < 9 || statusLine.charAt(8) != ' ') {
+        throw new ProtocolException("Unexpected status line: " + statusLine);
+      }
+      int httpMinorVersion = statusLine.charAt(7) - '0';
+      codeStart = 9;
+      if (httpMinorVersion == 0) {
+        protocol = Protocol.HTTP_1_0;
+      } else if (httpMinorVersion == 1) {
+        protocol = Protocol.HTTP_1_1;
+      } else {
+        throw new ProtocolException("Unexpected status line: " + statusLine);
+      }
+    } else if (statusLine.startsWith("ICY ")) {
+      // Shoutcast uses ICY instead of "HTTP/1.0".
+      protocol = Protocol.HTTP_1_0;
+      codeStart = 4;
+    } else {
+      throw new ProtocolException("Unexpected status line: " + statusLine);
+    }
+
+    // Parse response code like "200". Always 3 digits.
+    if (statusLine.length() < codeStart + 3) {
+      throw new ProtocolException("Unexpected status line: " + statusLine);
+    }
+    int code;
+    try {
+      code = Integer.parseInt(statusLine.substring(codeStart, codeStart + 3));
+    } catch (NumberFormatException e) {
+      throw new ProtocolException("Unexpected status line: " + statusLine);
+    }
+
+    // Parse an optional response message like "OK" or "Not Modified". If it
+    // exists, it is separated from the response code by a space.
+    String message = "";
+    if (statusLine.length() > codeStart + 3) {
+      if (statusLine.charAt(codeStart + 3) != ' ') {
+        throw new ProtocolException("Unexpected status line: " + statusLine);
+      }
+      message = statusLine.substring(codeStart + 4);
+    }
+
+    return new StatusLine(protocol, code, message);
+  }
+
+  @Override public String toString() {
+    StringBuilder result = new StringBuilder();
+    result.append(protocol == Protocol.HTTP_1_0 ? "HTTP/1.0" : "HTTP/1.1");
+    result.append(' ').append(code);
+    if (message != null) {
+      result.append(' ').append(message);
+    }
+    return result.toString();
+  }
+}
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/TlsVersion.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/TlsVersion.java
similarity index 91%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/TlsVersion.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/TlsVersion.java
index 548f4acbc5b..6692c80fad4 100644
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/TlsVersion.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/TlsVersion.java
@@ -26,6 +26,7 @@
  * {@link SSLSocket#setEnabledProtocols}.
  */
 public enum TlsVersion {
+  TLS_1_3("TLSv1.3"), // 2016.
   TLS_1_2("TLSv1.2"), // 2008.
   TLS_1_1("TLSv1.1"), // 2006.
   TLS_1_0("TLSv1"),   // 1999.
@@ -39,7 +40,9 @@ private TlsVersion(String javaName) {
   }
 
   public static TlsVersion forJavaName(String javaName) {
-    if ("TLSv1.2".equals(javaName)) {
+    if ("TLSv1.3".equals(javaName)) {
+      return TLS_1_3;
+    } else if ("TLSv1.2".equals(javaName)) {
       return TLS_1_2;
     } else if ("TLSv1.1".equals(javaName)) {
       return TLS_1_1;
diff --git a/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Util.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Util.java
new file mode 100644
index 00000000000..cad74a026b1
--- /dev/null
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/Util.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * 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.
+ */
+/*
+ * Forked from OkHttp 2.5.0
+ */
+
+package io.grpc.okhttp.internal;
+
+import java.lang.reflect.Array;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/** Junk drawer of utility methods. */
+public final class Util {
+  public static final String[] EMPTY_STRING_ARRAY = new String[0];
+
+  /** A cheap and type-safe constant for the UTF-8 Charset. */
+  public static final Charset UTF_8 = Charset.forName("UTF-8");
+
+  private Util() {
+  }
+
+  /** Returns true if two possibly-null objects are equal. */
+  public static boolean equal(Object a, Object b) {
+    return a == b || (a != null && a.equals(b));
+  }
+
+  /** Returns an immutable list containing {@code elements}. */
+  public static <T> List<T> immutableList(T[] elements) {
+    return Collections.unmodifiableList(Arrays.asList(elements.clone()));
+  }
+
+  /**
+   * Returns an array containing containing only elements found in {@code first}  and also in
+   * {@code second}. The returned elements are in the same order as in {@code first}.
+   */
+  @SuppressWarnings("unchecked")
+  public static <T> T[] intersect(Class<T> arrayType, T[] first, T[] second) {
+    List<T> result = intersect(first, second);
+    return result.toArray((T[]) Array.newInstance(arrayType, result.size()));
+  }
+
+  /**
+   * Returns a list containing containing only elements found in {@code first}  and also in
+   * {@code second}. The returned elements are in the same order as in {@code first}.
+   */
+  private static <T> List<T> intersect(T[] first, T[] second) {
+    List<T> result = new ArrayList<>();
+    for (T a : first) {
+      for (T b : second) {
+        if (a.equals(b)) {
+          result.add(b);
+          break;
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/ErrorCode.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/ErrorCode.java
similarity index 100%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/ErrorCode.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/ErrorCode.java
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/FrameReader.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/FrameReader.java
similarity index 98%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/FrameReader.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/FrameReader.java
index 20c50f7cca2..490673eff6a 100644
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/FrameReader.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/FrameReader.java
@@ -32,7 +32,7 @@ public interface FrameReader extends Closeable {
   boolean nextFrame(Handler handler) throws IOException;
 
   interface Handler {
-    void data(boolean inFinished, int streamId, BufferedSource source, int length)
+    void data(boolean inFinished, int streamId, BufferedSource source, int length, int paddedLength)
         throws IOException;
 
     /**
@@ -111,7 +111,7 @@ void headers(boolean outFinished, boolean inFinished, int streamId, int associat
      * @param promisedStreamId server-initiated stream ID.  Must be an even
      * number.
      * @param requestHeaders minimally includes {@code :method}, {@code :scheme},
-     * {@code :authority}, and (@code :path}.
+     * {@code :authority}, and {@code :path}.
      */
     void pushPromise(int streamId, int promisedStreamId, List<io.grpc.okhttp.internal.framed.Header> requestHeaders)
         throws IOException;
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/FrameWriter.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/FrameWriter.java
similarity index 98%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/FrameWriter.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/FrameWriter.java
index 333e06c86f2..26087f3ce1c 100644
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/FrameWriter.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/FrameWriter.java
@@ -45,7 +45,7 @@ public interface FrameWriter extends Closeable {
    * @param promisedStreamId server-initiated stream ID.  Must be an even
    * number.
    * @param requestHeaders minimally includes {@code :method}, {@code :scheme},
-   * {@code :authority}, and (@code :path}.
+   * {@code :authority}, and {@code :path}.
    */
   void pushPromise(int streamId, int promisedStreamId, List<Header> requestHeaders)
       throws IOException;
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Header.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Header.java
similarity index 100%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Header.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Header.java
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/HeadersMode.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/HeadersMode.java
similarity index 100%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/HeadersMode.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/HeadersMode.java
diff --git a/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Hpack.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Hpack.java
new file mode 100644
index 00000000000..484cc5673dc
--- /dev/null
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Hpack.java
@@ -0,0 +1,629 @@
+/*
+ * Copyright (C) 2013 Square, Inc.
+ *
+ * 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.
+ */
+/*
+ * Forked from OkHttp 2.5.0
+ */
+
+package io.grpc.okhttp.internal.framed;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import okio.Buffer;
+import okio.BufferedSource;
+import okio.ByteString;
+import okio.Okio;
+import okio.Source;
+
+/**
+ * Read and write HPACK v10.
+ *
+ * http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12
+ *
+ * This implementation uses an array for the dynamic table and a list for
+ * indexed entries.  Dynamic entries are added to the array, starting in the
+ * last position moving forward.  When the array fills, it is doubled.
+ */
+final class Hpack {
+  private static final int PREFIX_4_BITS = 0x0f;
+  private static final int PREFIX_5_BITS = 0x1f;
+  private static final int PREFIX_6_BITS = 0x3f;
+  private static final int PREFIX_7_BITS = 0x7f;
+
+  private static final ByteString PSEUDO_PREFIX = ByteString.encodeUtf8(":");
+
+  private static final int SETTINGS_HEADER_TABLE_SIZE = 4_096;
+
+  /**
+   * The decoder has ultimate control of the maximum size of the dynamic table but we can choose
+   * to use less. We'll put a cap at 16K. This is arbitrary but should be enough for most purposes.
+   */
+  private static final int SETTINGS_HEADER_TABLE_SIZE_LIMIT = 16_384;
+
+  private static final io.grpc.okhttp.internal.framed.Header[] STATIC_HEADER_TABLE = new io.grpc.okhttp.internal.framed.Header[] {
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_AUTHORITY, ""),
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_METHOD, "GET"),
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_METHOD, "POST"),
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_PATH, "/"),
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_PATH, "/index.html"),
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_SCHEME, "http"),
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.TARGET_SCHEME, "https"),
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "200"),
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "204"),
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "206"),
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "304"),
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "400"),
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "404"),
+      new io.grpc.okhttp.internal.framed.Header(io.grpc.okhttp.internal.framed.Header.RESPONSE_STATUS, "500"),
+      new io.grpc.okhttp.internal.framed.Header("accept-charset", ""),
+      new io.grpc.okhttp.internal.framed.Header("accept-encoding", "gzip, deflate"),
+      new io.grpc.okhttp.internal.framed.Header("accept-language", ""),
+      new io.grpc.okhttp.internal.framed.Header("accept-ranges", ""),
+      new io.grpc.okhttp.internal.framed.Header("accept", ""),
+      new io.grpc.okhttp.internal.framed.Header("access-control-allow-origin", ""),
+      new io.grpc.okhttp.internal.framed.Header("age", ""),
+      new io.grpc.okhttp.internal.framed.Header("allow", ""),
+      new io.grpc.okhttp.internal.framed.Header("authorization", ""),
+      new io.grpc.okhttp.internal.framed.Header("cache-control", ""),
+      new io.grpc.okhttp.internal.framed.Header("content-disposition", ""),
+      new io.grpc.okhttp.internal.framed.Header("content-encoding", ""),
+      new io.grpc.okhttp.internal.framed.Header("content-language", ""),
+      new io.grpc.okhttp.internal.framed.Header("content-length", ""),
+      new io.grpc.okhttp.internal.framed.Header("content-location", ""),
+      new io.grpc.okhttp.internal.framed.Header("content-range", ""),
+      new io.grpc.okhttp.internal.framed.Header("content-type", ""),
+      new io.grpc.okhttp.internal.framed.Header("cookie", ""),
+      new io.grpc.okhttp.internal.framed.Header("date", ""),
+      new io.grpc.okhttp.internal.framed.Header("etag", ""),
+      new io.grpc.okhttp.internal.framed.Header("expect", ""),
+      new io.grpc.okhttp.internal.framed.Header("expires", ""),
+      new io.grpc.okhttp.internal.framed.Header("from", ""),
+      new io.grpc.okhttp.internal.framed.Header("host", ""),
+      new io.grpc.okhttp.internal.framed.Header("if-match", ""),
+      new io.grpc.okhttp.internal.framed.Header("if-modified-since", ""),
+      new io.grpc.okhttp.internal.framed.Header("if-none-match", ""),
+      new io.grpc.okhttp.internal.framed.Header("if-range", ""),
+      new io.grpc.okhttp.internal.framed.Header("if-unmodified-since", ""),
+      new io.grpc.okhttp.internal.framed.Header("last-modified", ""),
+      new io.grpc.okhttp.internal.framed.Header("link", ""),
+      new io.grpc.okhttp.internal.framed.Header("location", ""),
+      new io.grpc.okhttp.internal.framed.Header("max-forwards", ""),
+      new io.grpc.okhttp.internal.framed.Header("proxy-authenticate", ""),
+      new io.grpc.okhttp.internal.framed.Header("proxy-authorization", ""),
+      new io.grpc.okhttp.internal.framed.Header("range", ""),
+      new io.grpc.okhttp.internal.framed.Header("referer", ""),
+      new io.grpc.okhttp.internal.framed.Header("refresh", ""),
+      new io.grpc.okhttp.internal.framed.Header("retry-after", ""),
+      new io.grpc.okhttp.internal.framed.Header("server", ""),
+      new io.grpc.okhttp.internal.framed.Header("set-cookie", ""),
+      new io.grpc.okhttp.internal.framed.Header("strict-transport-security", ""),
+      new io.grpc.okhttp.internal.framed.Header("transfer-encoding", ""),
+      new io.grpc.okhttp.internal.framed.Header("user-agent", ""),
+      new io.grpc.okhttp.internal.framed.Header("vary", ""),
+      new io.grpc.okhttp.internal.framed.Header("via", ""),
+      new io.grpc.okhttp.internal.framed.Header("www-authenticate", "")
+  };
+
+  private Hpack() {
+  }
+
+  // http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#section-3.1
+  static final class Reader {
+
+    private final List<io.grpc.okhttp.internal.framed.Header> headerList = new ArrayList<>();
+    private final BufferedSource source;
+
+    private int headerTableSizeSetting;
+    private int maxDynamicTableByteCount;
+    // Visible for testing.
+    io.grpc.okhttp.internal.framed.Header[] dynamicTable = new io.grpc.okhttp.internal.framed.Header[8];
+    // Array is populated back to front, so new entries always have lowest index.
+    int nextDynamicTableIndex = dynamicTable.length - 1;
+    int dynamicTableHeaderCount = 0;
+    int dynamicTableByteCount = 0;
+
+    Reader(int headerTableSizeSetting, Source source) {
+      this(headerTableSizeSetting, headerTableSizeSetting, source);
+    }
+
+    // Visible for testing.
+    Reader(int headerTableSizeSetting, int maxDynamicTableByteCount, Source source) {
+      this.headerTableSizeSetting = headerTableSizeSetting;
+      this.maxDynamicTableByteCount = maxDynamicTableByteCount;
+      this.source = Okio.buffer(source);
+    }
+
+    int maxDynamicTableByteCount() {
+      return maxDynamicTableByteCount;
+    }
+
+    /**
+     * Called by the reader when the peer sent {@link Settings#HEADER_TABLE_SIZE}.
+     * While this establishes the maximum dynamic table size, the
+     * {@link #maxDynamicTableByteCount} set during processing may limit the
+     * table size to a smaller amount.
+     * <p> Evicts entries or clears the table as needed.
+     */
+    void headerTableSizeSetting(int headerTableSizeSetting) {
+      this.headerTableSizeSetting = headerTableSizeSetting;
+      this.maxDynamicTableByteCount = headerTableSizeSetting;
+      adjustDynamicTableByteCount();
+    }
+
+    private void adjustDynamicTableByteCount() {
+      if (maxDynamicTableByteCount < dynamicTableByteCount) {
+        if (maxDynamicTableByteCount == 0) {
+          clearDynamicTable();
+        } else {
+          evictToRecoverBytes(dynamicTableByteCount - maxDynamicTableByteCount);
+        }
+      }
+    }
+
+    private void clearDynamicTable() {
+      Arrays.fill(dynamicTable, null);
+      nextDynamicTableIndex = dynamicTable.length - 1;
+      dynamicTableHeaderCount = 0;
+      dynamicTableByteCount = 0;
+    }
+
+    /** Returns the count of entries evicted. */
+    private int evictToRecoverBytes(int bytesToRecover) {
+      int entriesToEvict = 0;
+      if (bytesToRecover > 0) {
+        // determine how many headers need to be evicted.
+        for (int j = dynamicTable.length - 1; j >= nextDynamicTableIndex && bytesToRecover > 0; j--) {
+          bytesToRecover -= dynamicTable[j].hpackSize;
+          dynamicTableByteCount -= dynamicTable[j].hpackSize;
+          dynamicTableHeaderCount--;
+          entriesToEvict++;
+        }
+        System.arraycopy(dynamicTable, nextDynamicTableIndex + 1, dynamicTable,
+            nextDynamicTableIndex + 1 + entriesToEvict, dynamicTableHeaderCount);
+        nextDynamicTableIndex += entriesToEvict;
+      }
+      return entriesToEvict;
+    }
+
+    /**
+     * Read {@code byteCount} bytes of headers from the source stream. This
+     * implementation does not propagate the never indexed flag of a header.
+     */
+    void readHeaders() throws IOException {
+      while (!source.exhausted()) {
+        int b = source.readByte() & 0xff;
+        if (b == 0x80) { // 10000000
+          throw new IOException("index == 0");
+        } else if ((b & 0x80) == 0x80) { // 1NNNNNNN
+          int index = readInt(b, PREFIX_7_BITS);
+          readIndexedHeader(index - 1);
+        } else if (b == 0x40) { // 01000000
+          readLiteralHeaderWithIncrementalIndexingNewName();
+        } else if ((b & 0x40) == 0x40) {  // 01NNNNNN
+          int index = readInt(b, PREFIX_6_BITS);
+          readLiteralHeaderWithIncrementalIndexingIndexedName(index - 1);
+        } else if ((b & 0x20) == 0x20) {  // 001NNNNN
+          maxDynamicTableByteCount = readInt(b, PREFIX_5_BITS);
+          if (maxDynamicTableByteCount < 0
+              || maxDynamicTableByteCount > headerTableSizeSetting) {
+            throw new IOException("Invalid dynamic table size update " + maxDynamicTableByteCount);
+          }
+          adjustDynamicTableByteCount();
+        } else if (b == 0x10 || b == 0) { // 000?0000 - Ignore never indexed bit.
+          readLiteralHeaderWithoutIndexingNewName();
+        } else { // 000?NNNN - Ignore never indexed bit.
+          int index = readInt(b, PREFIX_4_BITS);
+          readLiteralHeaderWithoutIndexingIndexedName(index - 1);
+        }
+      }
+    }
+
+    public List<io.grpc.okhttp.internal.framed.Header> getAndResetHeaderList() {
+      List<io.grpc.okhttp.internal.framed.Header> result = new ArrayList<>(headerList);
+      headerList.clear();
+      return result;
+    }
+
+    private void readIndexedHeader(int index) throws IOException {
+      if (isStaticHeader(index)) {
+        io.grpc.okhttp.internal.framed.Header staticEntry = STATIC_HEADER_TABLE[index];
+        headerList.add(staticEntry);
+      } else {
+        int dynamicTableIndex = dynamicTableIndex(index - STATIC_HEADER_TABLE.length);
+        if (dynamicTableIndex < 0 || dynamicTableIndex > dynamicTable.length - 1) {
+          throw new IOException("Header index too large " + (index + 1));
+        }
+        headerList.add(dynamicTable[dynamicTableIndex]);
+      }
+    }
+
+    // referencedHeaders is relative to nextDynamicTableIndex + 1.
+    private int dynamicTableIndex(int index) {
+      return nextDynamicTableIndex + 1 + index;
+    }
+
+    private void readLiteralHeaderWithoutIndexingIndexedName(int index) throws IOException {
+      ByteString name = getName(index);
+      ByteString value = readByteString();
+      headerList.add(new io.grpc.okhttp.internal.framed.Header(name, value));
+    }
+
+    private void readLiteralHeaderWithoutIndexingNewName() throws IOException {
+      ByteString name = checkLowercase(readByteString());
+      ByteString value = readByteString();
+      headerList.add(new io.grpc.okhttp.internal.framed.Header(name, value));
+    }
+
+    private void readLiteralHeaderWithIncrementalIndexingIndexedName(int nameIndex)
+        throws IOException {
+      ByteString name = getName(nameIndex);
+      ByteString value = readByteString();
+      insertIntoDynamicTable(-1, new io.grpc.okhttp.internal.framed.Header(name, value));
+    }
+
+    private void readLiteralHeaderWithIncrementalIndexingNewName() throws IOException {
+      ByteString name = checkLowercase(readByteString());
+      ByteString value = readByteString();
+      insertIntoDynamicTable(-1, new io.grpc.okhttp.internal.framed.Header(name, value));
+    }
+
+    private ByteString getName(int index) throws IOException {
+      if (isStaticHeader(index)) {
+        return STATIC_HEADER_TABLE[index].name;
+      } else {
+        int dynamicTableIndex = dynamicTableIndex(index - STATIC_HEADER_TABLE.length);
+        if (dynamicTableIndex < 0 || dynamicTableIndex >= dynamicTable.length) {
+          throw new IOException("Header index too large " + (index + 1));
+        }
+        return dynamicTable[dynamicTableIndex].name;
+      }
+    }
+
+    private boolean isStaticHeader(int index) {
+      return index >= 0 && index <= STATIC_HEADER_TABLE.length - 1;
+    }
+
+    /** index == -1 when new. */
+    private void insertIntoDynamicTable(int index, io.grpc.okhttp.internal.framed.Header entry) {
+      headerList.add(entry);
+
+      int delta = entry.hpackSize;
+      if (index != -1) { // Index -1 == new header.
+        delta -= dynamicTable[dynamicTableIndex(index)].hpackSize;
+      }
+
+      // if the new or replacement header is too big, drop all entries.
+      if (delta > maxDynamicTableByteCount) {
+        clearDynamicTable();
+        return;
+      }
+
+      // Evict headers to the required length.
+      int bytesToRecover = (dynamicTableByteCount + delta) - maxDynamicTableByteCount;
+      int entriesEvicted = evictToRecoverBytes(bytesToRecover);
+
+      if (index == -1) { // Adding a value to the dynamic table.
+        if (dynamicTableHeaderCount + 1 > dynamicTable.length) { // Need to grow the dynamic table.
+          io.grpc.okhttp.internal.framed.Header[] doubled = new io.grpc.okhttp.internal.framed.Header[dynamicTable.length * 2];
+          System.arraycopy(dynamicTable, 0, doubled, dynamicTable.length, dynamicTable.length);
+          nextDynamicTableIndex = dynamicTable.length - 1;
+          dynamicTable = doubled;
+        }
+        index = nextDynamicTableIndex--;
+        dynamicTable[index] = entry;
+        dynamicTableHeaderCount++;
+      } else { // Replace value at same position.
+        index += dynamicTableIndex(index) + entriesEvicted;
+        dynamicTable[index] = entry;
+      }
+      dynamicTableByteCount += delta;
+    }
+
+    private int readByte() throws IOException {
+      return source.readByte() & 0xff;
+    }
+
+    int readInt(int firstByte, int prefixMask) throws IOException {
+      int prefix = firstByte & prefixMask;
+      if (prefix < prefixMask) {
+        return prefix; // This was a single byte value.
+      }
+
+      // This is a multibyte value. Read 7 bits at a time.
+      int result = prefixMask;
+      int shift = 0;
+      while (true) {
+        int b = readByte();
+        if ((b & 0x80) != 0) { // Equivalent to (b >= 128) since b is in [0..255].
+          result += (b & 0x7f) << shift;
+          shift += 7;
+        } else {
+          result += b << shift; // Last byte.
+          break;
+        }
+      }
+      return result;
+    }
+
+    /** Reads a potentially Huffman encoded byte string. */
+    ByteString readByteString() throws IOException {
+      int firstByte = readByte();
+      boolean huffmanDecode = (firstByte & 0x80) == 0x80; // 1NNNNNNN
+      int length = readInt(firstByte, PREFIX_7_BITS);
+
+      if (huffmanDecode) {
+        return ByteString.of(io.grpc.okhttp.internal.framed.Huffman.get().decode(source.readByteArray(length)));
+      } else {
+        return source.readByteString(length);
+      }
+    }
+  }
+
+  private static final Map<ByteString, Integer> NAME_TO_FIRST_INDEX = nameToFirstIndex();
+
+  private static Map<ByteString, Integer> nameToFirstIndex() {
+    Map<ByteString, Integer> result =
+        new LinkedHashMap<>(STATIC_HEADER_TABLE.length);
+    for (int i = 0; i < STATIC_HEADER_TABLE.length; i++) {
+      if (!result.containsKey(STATIC_HEADER_TABLE[i].name)) {
+        result.put(STATIC_HEADER_TABLE[i].name, i);
+      }
+    }
+    return Collections.unmodifiableMap(result);
+  }
+
+  static final class Writer {
+    private final Buffer out;
+    private boolean useCompression;
+    // Visible for testing.
+    int headerTableSizeSetting;
+
+    /**
+     * In the scenario where the dynamic table size changes multiple times between transmission of
+     * header blocks, we need to keep track of the smallest value in that interval.
+     */
+    private int smallestHeaderTableSizeSetting = Integer.MAX_VALUE;
+    private boolean emitDynamicTableSizeUpdate;
+    private int maxDynamicTableByteCount;
+
+    // Visible for testing.
+    io.grpc.okhttp.internal.framed.Header[] dynamicTable = new io.grpc.okhttp.internal.framed.Header[8];
+    // Visible for testing.
+    int dynamicTableHeaderCount;
+
+    // Array is populated back to front, so new entries always have lowest index.
+    private int nextDynamicTableIndex = dynamicTable.length - 1;
+    private int dynamicTableByteCount;
+
+    // Disable Huffman encoding as for the CPU vs bandwidth trade-off.
+    Writer(Buffer out) {
+      this(SETTINGS_HEADER_TABLE_SIZE, false, out);
+    }
+
+    // Visible for testing.
+    Writer(int headerTableSizeSetting, boolean useCompression, Buffer out) {
+      this.headerTableSizeSetting = headerTableSizeSetting;
+      this.maxDynamicTableByteCount = headerTableSizeSetting;
+      this.useCompression = useCompression;
+      this.out = out;
+    }
+
+    /** This does not use "never indexed" semantics for sensitive headers. */
+    // http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#section-6.2.3
+    void writeHeaders(List<io.grpc.okhttp.internal.framed.Header> headerBlock) throws IOException {
+      if (emitDynamicTableSizeUpdate) {
+        if (smallestHeaderTableSizeSetting < maxDynamicTableByteCount) {
+          // Multiple dynamic table size updates!
+          writeInt(smallestHeaderTableSizeSetting, PREFIX_5_BITS, 0x20);
+        }
+        emitDynamicTableSizeUpdate = false;
+        smallestHeaderTableSizeSetting = Integer.MAX_VALUE;
+        writeInt(maxDynamicTableByteCount, PREFIX_5_BITS, 0x20);
+      }
+
+      for (int i = 0, size = headerBlock.size(); i < size; i++) {
+        io.grpc.okhttp.internal.framed.Header header = headerBlock.get(i);
+        ByteString name = header.name.toAsciiLowercase();
+        ByteString value = header.value;
+        int headerIndex = -1;
+        int headerNameIndex = -1;
+
+        Integer staticIndex = NAME_TO_FIRST_INDEX.get(name);
+        if (staticIndex != null) {
+          headerNameIndex = staticIndex + 1;
+          if (headerNameIndex >= 2 && headerNameIndex <= 7) {
+            // Only search a subset of the static header table. Most entries have an empty value, so
+            // it's unnecessary to waste cycles looking at them. This check is built on the
+            // observation that the header entries we care about are in adjacent pairs, and we
+            // always know the first index of the pair.
+            if (STATIC_HEADER_TABLE[headerNameIndex - 1].value.equals(value)) {
+              headerIndex = headerNameIndex;
+            } else if (STATIC_HEADER_TABLE[headerNameIndex].value.equals(value)) {
+              headerIndex = headerNameIndex + 1;
+            }
+          }
+        }
+
+        if (headerIndex == -1) {
+          for (int j = nextDynamicTableIndex + 1; j < dynamicTable.length; j++) {
+            if (dynamicTable[j].name.equals(name)) {
+              if (dynamicTable[j].value.equals(value)) {
+                headerIndex = j - nextDynamicTableIndex + STATIC_HEADER_TABLE.length;
+                break;
+              } else if (headerNameIndex == -1) {
+                headerNameIndex = j - nextDynamicTableIndex + STATIC_HEADER_TABLE.length;
+              }
+            }
+          }
+        }
+
+        if (headerIndex != -1) {
+          // Indexed Header Field.
+          writeInt(headerIndex, PREFIX_7_BITS, 0x80);
+        } else if (headerNameIndex == -1) {
+          // Literal Header Field with Incremental Indexing - New Name.
+          out.writeByte(0x40);
+          writeByteString(name);
+          writeByteString(value);
+          insertIntoDynamicTable(header);
+        } else if (name.startsWith(PSEUDO_PREFIX) && !io.grpc.okhttp.internal.framed.Header.TARGET_AUTHORITY.equals(name)) {
+          // Follow Chromes lead - only include the :authority pseudo header, but exclude all other
+          // pseudo headers. Literal Header Field without Indexing - Indexed Name.
+          writeInt(headerNameIndex, PREFIX_4_BITS, 0);
+          writeByteString(value);
+        } else {
+          // Literal Header Field with Incremental Indexing - Indexed Name.
+          writeInt(headerNameIndex, PREFIX_6_BITS, 0x40);
+          writeByteString(value);
+          insertIntoDynamicTable(header);
+        }
+      }
+    }
+
+    // http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#section-4.1.1
+    void writeInt(int value, int prefixMask, int bits) throws IOException {
+      // Write the raw value for a single byte value.
+      if (value < prefixMask) {
+        out.writeByte(bits | value);
+        return;
+      }
+
+      // Write the mask to start a multibyte value.
+      out.writeByte(bits | prefixMask);
+      value -= prefixMask;
+
+      // Write 7 bits at a time 'til we're done.
+      while (value >= 0x80) {
+        int b = value & 0x7f;
+        out.writeByte(b | 0x80);
+        value >>>= 7;
+      }
+      out.writeByte(value);
+    }
+
+    void writeByteString(ByteString data) throws IOException {
+      if (useCompression && io.grpc.okhttp.internal.framed.Huffman.get().encodedLength(data.toByteArray()) < data.size()) {
+        Buffer huffmanBuffer = new Buffer();
+        io.grpc.okhttp.internal.framed.Huffman.get().encode(data.toByteArray(), huffmanBuffer.outputStream());
+        ByteString huffmanBytes = huffmanBuffer.readByteString();
+        writeInt(huffmanBytes.size(), PREFIX_7_BITS, 0x80);
+        out.write(huffmanBytes);
+      } else {
+        writeInt(data.size(), PREFIX_7_BITS, 0);
+        out.write(data);
+      }
+    }
+
+    int maxDynamicTableByteCount() {
+      return maxDynamicTableByteCount;
+    }
+
+    private void clearDynamicTable() {
+      Arrays.fill(dynamicTable, null);
+      nextDynamicTableIndex = dynamicTable.length - 1;
+      dynamicTableHeaderCount = 0;
+      dynamicTableByteCount = 0;
+    }
+
+    /** Returns the count of entries evicted. */
+    private int evictToRecoverBytes(int bytesToRecover) {
+      int entriesToEvict = 0;
+      if (bytesToRecover > 0) {
+        // determine how many headers need to be evicted.
+        for (int j = dynamicTable.length - 1; j >= nextDynamicTableIndex && bytesToRecover > 0; j--) {
+          bytesToRecover -= dynamicTable[j].hpackSize;
+          dynamicTableByteCount -= dynamicTable[j].hpackSize;
+          dynamicTableHeaderCount--;
+          entriesToEvict++;
+        }
+        System.arraycopy(dynamicTable, nextDynamicTableIndex + 1, dynamicTable,
+            nextDynamicTableIndex + 1 + entriesToEvict, dynamicTableHeaderCount);
+        nextDynamicTableIndex += entriesToEvict;
+      }
+      return entriesToEvict;
+    }
+
+    private void insertIntoDynamicTable(io.grpc.okhttp.internal.framed.Header entry) {
+      int delta = entry.hpackSize;
+
+      // if the new or replacement header is too big, drop all entries.
+      if (delta > maxDynamicTableByteCount) {
+        clearDynamicTable();
+        return;
+      }
+
+      // Evict headers to the required length.
+      int bytesToRecover = dynamicTableByteCount + delta - maxDynamicTableByteCount;
+      evictToRecoverBytes(bytesToRecover);
+
+      if (dynamicTableHeaderCount + 1 > dynamicTable.length) { // Need to grow the dynamic table.
+        io.grpc.okhttp.internal.framed.Header[] doubled = new io.grpc.okhttp.internal.framed.Header[dynamicTable.length * 2];
+        System.arraycopy(dynamicTable, 0, doubled, dynamicTable.length, dynamicTable.length);
+        nextDynamicTableIndex = dynamicTable.length - 1;
+        dynamicTable = doubled;
+      }
+      int index = nextDynamicTableIndex--;
+      dynamicTable[index] = entry;
+      dynamicTableHeaderCount++;
+      dynamicTableByteCount += delta;
+    }
+
+    void resizeHeaderTable(int headerTableSizeSetting) {
+      this.headerTableSizeSetting = headerTableSizeSetting;
+      int effectiveHeaderTableSize = Math.min(headerTableSizeSetting, SETTINGS_HEADER_TABLE_SIZE_LIMIT);
+
+      if (maxDynamicTableByteCount == effectiveHeaderTableSize) { // No change.
+        return;
+      }
+
+      if (effectiveHeaderTableSize < maxDynamicTableByteCount) {
+        smallestHeaderTableSizeSetting =
+            Math.min(smallestHeaderTableSizeSetting, effectiveHeaderTableSize);
+      }
+      emitDynamicTableSizeUpdate = true;
+      maxDynamicTableByteCount = effectiveHeaderTableSize;
+      adjustDynamicTableByteCount();
+    }
+
+    private void adjustDynamicTableByteCount() {
+      if (maxDynamicTableByteCount < dynamicTableByteCount) {
+        if (maxDynamicTableByteCount == 0) {
+          clearDynamicTable();
+        } else {
+          evictToRecoverBytes(dynamicTableByteCount - maxDynamicTableByteCount);
+        }
+      }
+    }
+  }
+
+  /**
+   * An HTTP/2 response cannot contain uppercase header characters and must
+   * be treated as malformed.
+   */
+  private static ByteString checkLowercase(ByteString name) throws IOException {
+    for (int i = 0, length = name.size(); i < length; i++) {
+      byte c = name.getByte(i);
+      if (c >= 'A' && c <= 'Z') {
+        throw new IOException("PROTOCOL_ERROR response malformed: mixed case name: " + name.utf8());
+      }
+    }
+    return name;
+  }
+}
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Http2.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Http2.java
similarity index 95%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Http2.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Http2.java
index 0ad535fab77..0eb49b9f076 100644
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Http2.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Http2.java
@@ -19,9 +19,11 @@
 
 package io.grpc.okhttp.internal.framed;
 
+import com.google.errorprone.annotations.FormatMethod;
 import io.grpc.okhttp.internal.Protocol;
 import java.io.IOException;
 import java.util.List;
+import java.util.Locale;
 import java.util.logging.Logger;
 
 import okio.Buffer;
@@ -218,7 +220,7 @@ private List<Header> readHeaderBlock(int length, short padding, byte flags, int
       return hpackReader.getAndResetHeaderList();
     }
 
-    private void readData(Handler handler, int length, byte flags, int streamId)
+    private void readData(Handler handler, int paddedLength, byte flags, int streamId)
         throws IOException {
       // TODO: checkState open or half-closed (local) or raise STREAM_CLOSED
       boolean inFinished = (flags & FLAG_END_STREAM) != 0;
@@ -228,13 +230,15 @@ private void readData(Handler handler, int length, byte flags, int streamId)
       }
 
       short padding = (flags & FLAG_PADDED) != 0 ? (short) (source.readByte() & 0xff) : 0;
-      length = lengthWithoutPadding(length, flags, padding);
+      int length = lengthWithoutPadding(paddedLength, flags, padding);
 
-      handler.data(inFinished, streamId, source, length);
+      // FIXME: pass padding length to handler because it should be included for flow control
+      handler.data(inFinished, streamId, source, length, paddedLength);
       source.skip(padding);
     }
 
-    private void readPriority(Handler handler, int length, byte flags, int streamId)
+    private void readPriority(
+        Handler handler, int length, @SuppressWarnings("UnusedVariable") byte flags, int streamId)
         throws IOException {
       if (length != 5) throw ioException("TYPE_PRIORITY length: %d != 5", length);
       if (streamId == 0) throw ioException("TYPE_PRIORITY streamId == 0");
@@ -249,7 +253,8 @@ private void readPriority(Handler handler, int streamId) throws IOException {
       handler.priority(streamId, streamDependency, weight, exclusive);
     }
 
-    private void readRstStream(Handler handler, int length, byte flags, int streamId)
+    private void readRstStream(
+        Handler handler, int length, @SuppressWarnings("UnusedVariable") byte flags, int streamId)
         throws IOException {
       if (length != 4) throw ioException("TYPE_RST_STREAM length: %d != 4", length);
       if (streamId == 0) throw ioException("TYPE_RST_STREAM streamId == 0");
@@ -301,7 +306,8 @@ private void readSettings(Handler handler, int length, byte flags, int streamId)
           case 6: // SETTINGS_MAX_HEADER_LIST_SIZE
             break; // Advisory only, so ignored.
           default:
-            throw ioException("PROTOCOL_ERROR invalid settings id: %s", id);
+            // Implementations MUST ignore any unknown or unsupported identifier.
+            continue;
         }
         settings.set(id, 0, value);
       }
@@ -334,7 +340,8 @@ private void readPing(Handler handler, int length, byte flags, int streamId)
       handler.ping(ack, payload1, payload2);
     }
 
-    private void readGoAway(Handler handler, int length, byte flags, int streamId)
+    private void readGoAway(
+        Handler handler, int length, @SuppressWarnings("UnusedVariable") byte flags, int streamId)
         throws IOException {
       if (length < 8) throw ioException("TYPE_GOAWAY length < 8: %s", length);
       if (streamId != 0) throw ioException("TYPE_GOAWAY streamId != 0");
@@ -352,11 +359,12 @@ private void readGoAway(Handler handler, int length, byte flags, int streamId)
       handler.goAway(lastStreamId, errorCode, debugData);
     }
 
-    private void readWindowUpdate(Handler handler, int length, byte flags, int streamId)
+    private void readWindowUpdate(
+        Handler handler, int length, @SuppressWarnings("UnusedVariable") byte flags, int streamId)
         throws IOException {
       if (length != 4) throw ioException("TYPE_WINDOW_UPDATE length !=4: %s", length);
       long increment = (source.readInt() & 0x7fffffffL);
-      if (increment == 0) throw ioException("windowSizeIncrement was 0", increment);
+      if (increment == 0) throw ioException("windowSizeIncrement was 0");
       handler.windowUpdate(streamId, increment);
     }
 
@@ -581,12 +589,14 @@ void frameHeader(int streamId, int length, byte type, byte flags) throws IOExcep
     }
   }
 
+  @FormatMethod
   private static IllegalArgumentException illegalArgument(String message, Object... args) {
-    throw new IllegalArgumentException(format(message, args));
+    throw new IllegalArgumentException(format(Locale.US, message, args));
   }
 
+  @FormatMethod
   private static IOException ioException(String message, Object... args) throws IOException {
-    throw new IOException(format(message, args));
+    throw new IOException(format(Locale.US, message, args));
   }
 
   /**
@@ -619,7 +629,7 @@ public ContinuationSource(BufferedSource source) {
 
       long read = source.read(sink, Math.min(byteCount, left));
       if (read == -1) return -1;
-      left -= read;
+      left -= (int) read;
       return read;
     }
 
@@ -675,7 +685,7 @@ static final class FrameLogger {
     static String formatHeader(boolean inbound, int streamId, int length, byte type, byte flags) {
       String formattedType = type < TYPES.length ? TYPES[type] : format("0x%02x", type);
       String formattedFlags = formatFlags(type, flags);
-      return format("%s 0x%08x %5d %-13s %s", inbound ? "<<" : ">>", streamId, length,
+      return format(Locale.US, "%s 0x%08x %5d %-13s %s", inbound ? "<<" : ">>", streamId, length,
           formattedType, formattedFlags);
     }
 
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Huffman.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Huffman.java
similarity index 99%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Huffman.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Huffman.java
index 11370ddbb8f..5eb4a88c257 100644
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Huffman.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Huffman.java
@@ -171,6 +171,7 @@ private void buildTree() {
     }
   }
 
+  @SuppressWarnings("NarrowingCompoundAssignment")
   private void addCode(int sym, int code, byte len) {
     Node terminal = new Node(sym, len);
 
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Settings.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Settings.java
similarity index 98%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Settings.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Settings.java
index 0d0ecce9982..591b59129ed 100644
--- a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Settings.java
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Settings.java
@@ -46,7 +46,7 @@ public final class Settings {
   /** spdy/3: Sender's estimate of max outgoing kbps. */
   static final int DOWNLOAD_BANDWIDTH = 2;
   /** HTTP/2: The peer must not send a PUSH_PROMISE frame when this is 0. */
-  static final int ENABLE_PUSH = 2;
+  public static final int ENABLE_PUSH = 2;
   /** spdy/3: Sender's estimate of millis between sending a request and receiving a response. */
   static final int ROUND_TRIP_TIME = 3;
   /** Sender's maximum number of concurrent streams. */
@@ -58,7 +58,7 @@ public final class Settings {
   /** spdy/3: Retransmission rate. Percentage */
   static final int DOWNLOAD_RETRANS_RATE = 6;
   /** HTTP/2: Advisory only. Size in bytes of the largest header list the sender will accept. */
-  static final int MAX_HEADER_LIST_SIZE = 6;
+  public static final int MAX_HEADER_LIST_SIZE = 6;
   /** Window size in bytes. */
   public static final int INITIAL_WINDOW_SIZE = 7;
   /** spdy/3: Size of the client certificate vector. Unsupported. */
diff --git a/okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Variant.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Variant.java
similarity index 100%
rename from okhttp/third_party/okhttp/java/io/grpc/okhttp/internal/framed/Variant.java
rename to okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/framed/Variant.java
diff --git a/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/proxy/HttpUrl.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/proxy/HttpUrl.java
new file mode 100644
index 00000000000..1a03812f26c
--- /dev/null
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/proxy/HttpUrl.java
@@ -0,0 +1,477 @@
+/*
+ * Copyright (C) 2015 Square, Inc.
+ *
+ * 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.
+ */
+/*
+ * Forked from OkHttp 2.7.0 com.squareup.okhttp.HttpUrl
+ */
+package io.grpc.okhttp.internal.proxy;
+
+import java.io.EOFException;
+import java.net.IDN;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.Arrays;
+import java.util.Locale;
+import okio.Buffer;
+
+/**
+ * Helper class to build a proxy URL.
+ */
+public final class HttpUrl {
+  private static final char[] HEX_DIGITS =
+      { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+
+  /** Either "http" or "https". */
+  private final String scheme;
+
+  /** Canonical hostname. */
+  private final String host;
+
+  /** Either 80, 443 or a user-specified port. In range [1..65535]. */
+  private final int port;
+
+  /** Canonical URL. */
+  private final String url;
+
+  private HttpUrl(Builder builder) {
+    this.scheme = builder.scheme;
+    this.host = builder.host;
+    this.port = builder.effectivePort();
+    this.url = builder.toString();
+  }
+
+  /** Returns either "http" or "https". */
+  public String scheme() {
+    return scheme;
+  }
+
+  public boolean isHttps() {
+    return scheme.equals("https");
+  }
+
+  /**
+   * Returns the host address suitable for use with {@link InetAddress#getAllByName(String)}. May
+   * be:
+   * <ul>
+   *   <li>A regular host name, like {@code android.com}.
+   *   <li>An IPv4 address, like {@code 127.0.0.1}.
+   *   <li>An IPv6 address, like {@code ::1}. Note that there are no square braces.
+   *   <li>An encoded IDN, like {@code xn--n3h.net}.
+   * </ul>
+   */
+  public String host() {
+    return host;
+  }
+
+  /**
+   * Returns the explicitly-specified port if one was provided, or the default port for this URL's
+   * scheme. For example, this returns 8443 for {@code https://square.com:8443/} and 443 for {@code
+   * https://square.com/}. The result is in {@code [1..65535]}.
+   */
+  public int port() {
+    return port;
+  }
+
+  /**
+   * Returns 80 if {@code scheme.equals("http")}, 443 if {@code scheme.equals("https")} and -1
+   * otherwise.
+   */
+  public static int defaultPort(String scheme) {
+    if (scheme.equals("http")) {
+      return 80;
+    } else if (scheme.equals("https")) {
+      return 443;
+    } else {
+      return -1;
+    }
+  }
+
+  public Builder newBuilder() {
+    Builder result = new Builder();
+    result.scheme = scheme;
+    result.host = host;
+    // If we're set to a default port, unset it in case of a scheme change.
+    result.port = port != defaultPort(scheme) ? port : -1;
+    return result;
+  }
+
+  @Override public boolean equals(Object o) {
+    return o instanceof HttpUrl && ((HttpUrl) o).url.equals(url);
+  }
+
+  @Override public int hashCode() {
+    return url.hashCode();
+  }
+
+  @Override public String toString() {
+    return url;
+  }
+
+  public static final class Builder {
+    String scheme;
+    String host;
+    int port = -1;
+
+    public Builder() {
+    }
+
+    public Builder scheme(String scheme) {
+      if (scheme == null) {
+        throw new IllegalArgumentException("scheme == null");
+      } else if (scheme.equalsIgnoreCase("http")) {
+        this.scheme = "http";
+      } else if (scheme.equalsIgnoreCase("https")) {
+        this.scheme = "https";
+      } else {
+        throw new IllegalArgumentException("unexpected scheme: " + scheme);
+      }
+      return this;
+    }
+
+    /**
+     * @param host either a regular hostname, International Domain Name, IPv4 address, or IPv6
+     *     address.
+     */
+    public Builder host(String host) {
+      if (host == null) throw new IllegalArgumentException("host == null");
+      String encoded = canonicalizeHost(host, 0, host.length());
+      if (encoded == null) throw new IllegalArgumentException("unexpected host: " + host);
+      this.host = encoded;
+      return this;
+    }
+
+    public Builder port(int port) {
+      if (port <= 0 || port > 65535) throw new IllegalArgumentException("unexpected port: " + port);
+      this.port = port;
+      return this;
+    }
+
+    int effectivePort() {
+      return port != -1 ? port : defaultPort(scheme);
+    }
+
+    public HttpUrl build() {
+      if (scheme == null) throw new IllegalStateException("scheme == null");
+      if (host == null) throw new IllegalStateException("host == null");
+      return new HttpUrl(this);
+    }
+
+    @Override public String toString() {
+      StringBuilder result = new StringBuilder();
+      result.append(scheme);
+      result.append("://");
+
+      if (host.indexOf(':') != -1) {
+        // Host is an IPv6 address.
+        result.append('[');
+        result.append(host);
+        result.append(']');
+      } else {
+        result.append(host);
+      }
+
+      int effectivePort = effectivePort();
+      if (effectivePort != defaultPort(scheme)) {
+        result.append(':');
+        result.append(effectivePort);
+      }
+
+      return result.toString();
+    }
+
+
+    private static String canonicalizeHost(String input, int pos, int limit) {
+      // Start by percent decoding the host. The WHATWG spec suggests doing this only after we've
+      // checked for IPv6 square braces. But Chrome does it first, and that's more lenient.
+      String percentDecoded = percentDecode(input, pos, limit, false);
+
+      // If the input is encased in square braces "[...]", drop 'em. We have an IPv6 address.
+      if (percentDecoded.startsWith("[") && percentDecoded.endsWith("]")) {
+        InetAddress inetAddress = decodeIpv6(percentDecoded, 1, percentDecoded.length() - 1);
+        if (inetAddress == null) return null;
+        byte[] address = inetAddress.getAddress();
+        if (address.length == 16) return inet6AddressToAscii(address);
+        throw new AssertionError();
+      }
+
+      return domainToAscii(percentDecoded);
+    }
+
+    /** Decodes an IPv6 address like 1111:2222:3333:4444:5555:6666:7777:8888 or ::1. */
+    private static InetAddress decodeIpv6(String input, int pos, int limit) {
+      byte[] address = new byte[16];
+      int b = 0;
+      int compress = -1;
+      int groupOffset = -1;
+
+      for (int i = pos; i < limit; ) {
+        if (b == address.length) return null; // Too many groups.
+
+        // Read a delimiter.
+        if (i + 2 <= limit && input.regionMatches(i, "::", 0, 2)) {
+          // Compression "::" delimiter, which is anywhere in the input, including its prefix.
+          if (compress != -1) return null; // Multiple "::" delimiters.
+          i += 2;
+          b += 2;
+          compress = b;
+          if (i == limit) break;
+        } else if (b != 0) {
+          // Group separator ":" delimiter.
+          if (input.regionMatches(i, ":", 0, 1)) {
+            i++;
+          } else if (input.regionMatches(i, ".", 0, 1)) {
+            // If we see a '.', rewind to the beginning of the previous group and parse as IPv4.
+            if (!decodeIpv4Suffix(input, groupOffset, limit, address, b - 2)) return null;
+            b += 2; // We rewound two bytes and then added four.
+            break;
+          } else {
+            return null; // Wrong delimiter.
+          }
+        }
+
+        // Read a group, one to four hex digits.
+        int value = 0;
+        groupOffset = i;
+        for (; i < limit; i++) {
+          char c = input.charAt(i);
+          int hexDigit = decodeHexDigit(c);
+          if (hexDigit == -1) break;
+          value = (value << 4) + hexDigit;
+        }
+        int groupLength = i - groupOffset;
+        if (groupLength == 0 || groupLength > 4) return null; // Group is the wrong size.
+
+        // We've successfully read a group. Assign its value to our byte array.
+        address[b++] = (byte) ((value >>> 8) & 0xff);
+        address[b++] = (byte) (value & 0xff);
+      }
+
+      // All done. If compression happened, we need to move bytes to the right place in the
+      // address. Here's a sample:
+      //
+      //      input: "1111:2222:3333::7777:8888"
+      //     before: { 11, 11, 22, 22, 33, 33, 00, 00, 77, 77, 88, 88, 00, 00, 00, 00  }
+      //   compress: 6
+      //          b: 10
+      //      after: { 11, 11, 22, 22, 33, 33, 00, 00, 00, 00, 00, 00, 77, 77, 88, 88 }
+      //
+      if (b != address.length) {
+        if (compress == -1) return null; // Address didn't have compression or enough groups.
+        System.arraycopy(address, compress, address, address.length - (b - compress), b - compress);
+        Arrays.fill(address, compress, compress + (address.length - b), (byte) 0);
+      }
+
+      try {
+        return InetAddress.getByAddress(address);
+      } catch (UnknownHostException e) {
+        throw new AssertionError();
+      }
+    }
+
+    /** Decodes an IPv4 address suffix of an IPv6 address, like 1111::5555:6666:192.168.0.1. */
+    private static boolean decodeIpv4Suffix(
+            String input, int pos, int limit, byte[] address, int addressOffset) {
+      int b = addressOffset;
+
+      for (int i = pos; i < limit; ) {
+        if (b == address.length) return false; // Too many groups.
+
+        // Read a delimiter.
+        if (b != addressOffset) {
+          if (input.charAt(i) != '.') return false; // Wrong delimiter.
+          i++;
+        }
+
+        // Read 1 or more decimal digits for a value in 0..255.
+        int value = 0;
+        int groupOffset = i;
+        for (; i < limit; i++) {
+          char c = input.charAt(i);
+          if (c < '0' || c > '9') break;
+          if (value == 0 && groupOffset != i) return false; // Reject unnecessary leading '0's.
+          value = (value * 10) + c - '0';
+          if (value > 255) return false; // Value out of range.
+        }
+        int groupLength = i - groupOffset;
+        if (groupLength == 0) return false; // No digits.
+
+        // We've successfully read a byte.
+        address[b++] = (byte) value;
+      }
+
+      if (b != addressOffset + 4) return false; // Too few groups. We wanted exactly four.
+      return true; // Success.
+    }
+
+    /**
+     * Performs IDN ToASCII encoding and canonicalize the result to lowercase. e.g. This converts
+     * {@code ☃.net} to {@code xn--n3h.net}, and {@code WwW.GoOgLe.cOm} to {@code www.google.com}.
+     * {@code null} will be returned if the input cannot be ToASCII encoded or if the result
+     * contains unsupported ASCII characters.
+     */
+    private static String domainToAscii(String input) {
+      try {
+        String result = IDN.toASCII(input).toLowerCase(Locale.US);
+        if (result.isEmpty()) return null;
+
+        // Confirm that the IDN ToASCII result doesn't contain any illegal characters.
+        if (containsInvalidHostnameAsciiCodes(result)) {
+          return null;
+        }
+        // TODO: implement all label limits.
+        return result;
+      } catch (IllegalArgumentException e) {
+        return null;
+      }
+    }
+
+    private static boolean containsInvalidHostnameAsciiCodes(String hostnameAscii) {
+      for (int i = 0; i < hostnameAscii.length(); i++) {
+        char c = hostnameAscii.charAt(i);
+        // The WHATWG Host parsing rules accepts some character codes which are invalid by
+        // definition for OkHttp's host header checks (and the WHATWG Host syntax definition). Here
+        // we rule out characters that would cause problems in host headers.
+        if (c <= '\u001f' || c >= '\u007f') {
+          return true;
+        }
+        // Check for the characters mentioned in the WHATWG Host parsing spec:
+        // U+0000, U+0009, U+000A, U+000D, U+0020, "#", "%", "/", ":", "?", "@", "[", "\", and "]"
+        // (excluding the characters covered above).
+        if (" #%/:?@[\\]".indexOf(c) != -1) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    private static String inet6AddressToAscii(byte[] address) {
+      // Go through the address looking for the longest run of 0s. Each group is 2-bytes.
+      int longestRunOffset = -1;
+      int longestRunLength = 0;
+      for (int i = 0; i < address.length; i += 2) {
+        int currentRunOffset = i;
+        while (i < 16 && address[i] == 0 && address[i + 1] == 0) {
+          i += 2;
+        }
+        int currentRunLength = i - currentRunOffset;
+        if (currentRunLength > longestRunLength) {
+          longestRunOffset = currentRunOffset;
+          longestRunLength = currentRunLength;
+        }
+      }
+
+      // Emit each 2-byte group in hex, separated by ':'. The longest run of zeroes is "::".
+      Buffer result = new Buffer();
+      for (int i = 0; i < address.length; ) {
+        if (i == longestRunOffset) {
+          result.writeByte(':');
+          i += longestRunLength;
+          if (i == 16) result.writeByte(':');
+        } else {
+          if (i > 0) result.writeByte(':');
+          int group = (address[i] & 0xff) << 8 | (address[i + 1] & 0xff);
+          result.writeHexadecimalUnsignedLong(group);
+          i += 2;
+        }
+      }
+      return result.readUtf8();
+    }
+  }
+
+  static String percentDecode(String encoded, int pos, int limit, boolean plusIsSpace) {
+    for (int i = pos; i < limit; i++) {
+      char c = encoded.charAt(i);
+      if (c == '%' || (c == '+' && plusIsSpace)) {
+        // Slow path: the character at i requires decoding!
+        Buffer out = new Buffer();
+        out.writeUtf8(encoded, pos, i);
+        percentDecode(out, encoded, i, limit, plusIsSpace);
+        return out.readUtf8();
+      }
+    }
+
+    // Fast path: no characters in [pos..limit) required decoding.
+    return encoded.substring(pos, limit);
+  }
+
+  static void percentDecode(Buffer out, String encoded, int pos, int limit, boolean plusIsSpace) {
+    int codePoint;
+    for (int i = pos; i < limit; i += Character.charCount(codePoint)) {
+      codePoint = encoded.codePointAt(i);
+      if (codePoint == '%' && i + 2 < limit) {
+        int d1 = decodeHexDigit(encoded.charAt(i + 1));
+        int d2 = decodeHexDigit(encoded.charAt(i + 2));
+        if (d1 != -1 && d2 != -1) {
+          out.writeByte((d1 << 4) + d2);
+          i += 2;
+          continue;
+        }
+      } else if (codePoint == '+' && plusIsSpace) {
+        out.writeByte(' ');
+        continue;
+      }
+      out.writeUtf8CodePoint(codePoint);
+    }
+  }
+
+  static int decodeHexDigit(char c) {
+    if (c >= '0' && c <= '9') return c - '0';
+    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+    return -1;
+  }
+
+  static void canonicalize(Buffer out, String input, int pos, int limit,
+                           String encodeSet, boolean alreadyEncoded, boolean plusIsSpace, boolean asciiOnly) {
+    Buffer utf8Buffer = null; // Lazily allocated.
+    int codePoint;
+    for (int i = pos; i < limit; i += Character.charCount(codePoint)) {
+      codePoint = input.codePointAt(i);
+      if (alreadyEncoded
+              && (codePoint == '\t' || codePoint == '\n' || codePoint == '\f' || codePoint == '\r')) {
+        // Skip this character.
+      } else if (codePoint == '+' && plusIsSpace) {
+        // Encode '+' as '%2B' since we permit ' ' to be encoded as either '+' or '%20'.
+        out.writeUtf8(alreadyEncoded ? "+" : "%2B");
+      } else if (codePoint < 0x20
+              || codePoint == 0x7f
+              || (codePoint >= 0x80 && asciiOnly)
+              || encodeSet.indexOf(codePoint) != -1
+              || (codePoint == '%' && !alreadyEncoded)) {
+        // Percent encode this character.
+        if (utf8Buffer == null) {
+          utf8Buffer = new Buffer();
+        }
+        utf8Buffer.writeUtf8CodePoint(codePoint);
+        while (!utf8Buffer.exhausted()) {
+          try {
+            fakeEofExceptionMethod(); // Okio 2.x can throw EOFException from readByte()
+            int b = utf8Buffer.readByte() & 0xff;
+            out.writeByte('%');
+            out.writeByte(HEX_DIGITS[(b >> 4) & 0xf]);
+            out.writeByte(HEX_DIGITS[b & 0xf]);
+          } catch (EOFException e) {
+            throw new IndexOutOfBoundsException(e.getMessage());
+          }
+        }
+      } else {
+        // This character doesn't need encoding. Just copy it over.
+        out.writeUtf8CodePoint(codePoint);
+      }
+    }
+  }
+
+  private static void fakeEofExceptionMethod() throws EOFException {}
+}
diff --git a/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/proxy/Request.java b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/proxy/Request.java
new file mode 100644
index 00000000000..aef4f3783d5
--- /dev/null
+++ b/okhttp/third_party/okhttp/main/java/io/grpc/okhttp/internal/proxy/Request.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2013 Square, Inc.
+ *
+ * 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.
+ */
+/*
+ * Forked from OkHttp 2.7.0 com.squareup.okhttp.Request
+ */
+package io.grpc.okhttp.internal.proxy;
+
+import io.grpc.okhttp.internal.Headers;
+
+/**
+ * An HTTP ProxyRequest. Instances of this class are immutable.
+ */
+public final class Request {
+  private final HttpUrl url;
+  private final Headers headers;
+
+  private Request(Builder builder) {
+    this.url = builder.url;
+    this.headers = builder.headers.build();
+  }
+
+  public HttpUrl httpUrl() {
+    return url;
+  }
+
+  public Headers headers() {
+    return headers;
+  }
+
+  public Builder newBuilder() {
+    return new Builder();
+  }
+
+
+  @Override public String toString() {
+    return "Request{"
+        + "url=" + url +
+        '}';
+  }
+
+  public static class Builder {
+    private HttpUrl url;
+    private Headers.Builder headers;
+
+    public Builder() {
+     this.headers = new Headers.Builder();
+    }
+
+    public Builder url(HttpUrl url) {
+      if (url == null) throw new IllegalArgumentException("url == null");
+      this.url = url;
+      return this;
+    }
+
+    /**
+     * Sets the header named {@code name} to {@code value}. If this request
+     * already has any headers with that name, they are all replaced.
+     */
+    public Builder header(String name, String value) {
+      headers.set(name, value);
+      return this;
+    }
+
+    public Request build() {
+      if (url == null) throw new IllegalStateException("url == null");
+      return new Request(this);
+    }
+  }
+}
diff --git a/okhttp/third_party/okhttp/test/java/io/grpc/okhttp/internal/framed/HpackTest.java b/okhttp/third_party/okhttp/test/java/io/grpc/okhttp/internal/framed/HpackTest.java
new file mode 100644
index 00000000000..26580f85e54
--- /dev/null
+++ b/okhttp/third_party/okhttp/test/java/io/grpc/okhttp/internal/framed/HpackTest.java
@@ -0,0 +1,1153 @@
+/*
+ * Copyright (C) 2013 Square, Inc.
+ *
+ * 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.okhttp.internal.framed;
+
+import static okio.ByteString.decodeHex;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import okio.Buffer;
+import okio.ByteString;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class HpackTest {
+
+  private static List<Header> headerEntries(String... elements) {
+    List<Header> result = new ArrayList<>(elements.length / 2);
+    for (int i = 0; i < elements.length; i += 2) {
+      result.add(new Header(elements[i], elements[i + 1]));
+    }
+    return result;
+  }
+
+  private final Buffer bytesIn = new Buffer();
+  private Hpack.Reader hpackReader;
+  private Buffer bytesOut = new Buffer();
+  private Hpack.Writer hpackWriter;
+
+  @Before public void reset() {
+    hpackReader = newReader(bytesIn);
+    hpackWriter = new Hpack.Writer(4096, false, bytesOut);
+  }
+
+  /**
+   * Variable-length quantity special cases strings which are longer than 127
+   * bytes.  Values such as cookies can be 4KiB, and should be possible to send.
+   *
+   * <p> http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#section-5.2
+   */
+  @Test public void largeHeaderValue() throws IOException {
+    char[] value = new char[4096];
+    Arrays.fill(value, '!');
+    List<Header> headerBlock = headerEntries("cookie", new String(value));
+
+    hpackWriter.writeHeaders(headerBlock);
+    bytesIn.writeAll(bytesOut);
+    hpackReader.readHeaders();
+
+    assertEquals(0, hpackReader.dynamicTableHeaderCount);
+
+    assertEquals(headerBlock, hpackReader.getAndResetHeaderList());
+  }
+
+  /**
+   * HPACK has a max header table size, which can be smaller than the max header message.
+   * Ensure the larger header content is not lost.
+   */
+  @Test public void tooLargeToHPackIsStillEmitted() throws IOException {
+    bytesIn.writeByte(0x21); // Dynamic table size update (size = 1).
+    bytesIn.writeByte(0x00); // Literal indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-key");
+
+    bytesIn.writeByte(0x0d); // Literal value (len = 13)
+    bytesIn.writeUtf8("custom-header");
+
+    hpackReader.headerTableSizeSetting(1);
+    hpackReader.readHeaders();
+
+    assertEquals(0, hpackReader.dynamicTableHeaderCount);
+
+    assertEquals(headerEntries("custom-key", "custom-header"), hpackReader.getAndResetHeaderList());
+  }
+
+  @Test public void setMaxDynamicTableToZeroDoesNotClearHeaderList() throws IOException {
+    bytesIn.writeByte(0x40); // Literal indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-key");
+
+    bytesIn.writeByte(0x0d); // Literal value (len = 13)
+    bytesIn.writeUtf8("custom-header");
+
+    bytesIn.writeByte(0x20); // Set max table size to 0
+
+    hpackReader.readHeaders();
+
+    assertEquals(0, hpackReader.maxDynamicTableByteCount());
+    assertEquals(headerEntries("custom-key", "custom-header"), hpackReader.getAndResetHeaderList());
+  }
+
+  /** Oldest entries are evicted to support newer ones. */
+  @Test
+  public void writerEviction() throws IOException {
+    List<Header> headerBlock =
+        headerEntries(
+            "custom-foo", "custom-header",
+            "custom-bar", "custom-header",
+            "custom-baz", "custom-header");
+
+    bytesIn.writeByte(0x40); // Literal indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-foo");
+
+    bytesIn.writeByte(0x0d); // Literal value (len = 13)
+    bytesIn.writeUtf8("custom-header");
+
+    bytesIn.writeByte(0x40); // Literal indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-bar");
+
+    bytesIn.writeByte(0x0d); // Literal value (len = 13)
+    bytesIn.writeUtf8("custom-header");
+
+    bytesIn.writeByte(0x40); // Literal indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-baz");
+
+    bytesIn.writeByte(0x0d); // Literal value (len = 13)
+    bytesIn.writeUtf8("custom-header");
+
+    // Set to only support 110 bytes (enough for 2 headers).
+    // Use a new Writer because we don't support change the dynamic table
+    // size after Writer constructed.
+    Hpack.Writer writer = new Hpack.Writer(110, false, bytesOut);
+    writer.writeHeaders(headerBlock);
+
+    assertEquals(bytesIn, bytesOut);
+    assertEquals(2, writer.dynamicTableHeaderCount);
+
+    int tableLength = writer.dynamicTable.length;
+    Header entry = writer.dynamicTable[tableLength - 1];
+    checkEntry(entry, "custom-bar", "custom-header", 55);
+
+    entry = writer.dynamicTable[tableLength - 2];
+    checkEntry(entry, "custom-baz", "custom-header", 55);
+  }
+
+  @Test
+  public void readerEviction() throws IOException {
+    List<Header> headerBlock =
+        headerEntries(
+            "custom-foo", "custom-header",
+            "custom-bar", "custom-header",
+            "custom-baz", "custom-header");
+
+    // Set to only support 110 bytes (enough for 2 headers).
+    bytesIn.writeByte(0x3F); // Dynamic table size update (size = 110).
+    bytesIn.writeByte(0x4F);
+
+    bytesIn.writeByte(0x40); // Literal indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-foo");
+
+    bytesIn.writeByte(0x0d); // Literal value (len = 13)
+    bytesIn.writeUtf8("custom-header");
+
+    bytesIn.writeByte(0x40); // Literal indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-bar");
+
+    bytesIn.writeByte(0x0d); // Literal value (len = 13)
+    bytesIn.writeUtf8("custom-header");
+
+    bytesIn.writeByte(0x40); // Literal indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-baz");
+
+    bytesIn.writeByte(0x0d); // Literal value (len = 13)
+    bytesIn.writeUtf8("custom-header");
+
+    hpackReader.readHeaders();
+
+    assertEquals(2, hpackReader.dynamicTableHeaderCount);
+
+    Header entry1 = hpackReader.dynamicTable[readerHeaderTableLength() - 1];
+    checkEntry(entry1, "custom-bar", "custom-header", 55);
+
+    Header entry2 = hpackReader.dynamicTable[readerHeaderTableLength() - 2];
+    checkEntry(entry2, "custom-baz", "custom-header", 55);
+
+    // Once a header field is decoded and added to the reconstructed header
+    // list, it cannot be removed from it. Hence, foo is here.
+    assertEquals(headerBlock, hpackReader.getAndResetHeaderList());
+
+    // Simulate receiving a small dynamic table size update, that implies eviction.
+    bytesIn.writeByte(0x3F); // Dynamic table size update (size = 55).
+    bytesIn.writeByte(0x18);
+    hpackReader.readHeaders();
+    assertEquals(1, hpackReader.dynamicTableHeaderCount);
+  }
+
+  /** Header table backing array is initially 8 long, let's ensure it grows. */
+  @Test public void dynamicallyGrowsBeyond64Entries() throws IOException {
+    // Lots of headers need more room!
+    hpackReader = new Hpack.Reader(16384, 4096, bytesIn);
+    bytesIn.writeByte(0x3F); // Dynamic table size update (size = 16384).
+    bytesIn.writeByte(0xE1);
+    bytesIn.writeByte(0x7F);
+
+    for (int i = 0; i < 256; i++) {
+      bytesIn.writeByte(0x40); // Literal indexed
+      bytesIn.writeByte(0x0a); // Literal name (len = 10)
+      bytesIn.writeUtf8("custom-foo");
+
+      bytesIn.writeByte(0x0d); // Literal value (len = 13)
+      bytesIn.writeUtf8("custom-header");
+    }
+
+    hpackReader.readHeaders();
+
+    assertEquals(256, hpackReader.dynamicTableHeaderCount);
+  }
+
+  @Test public void huffmanDecodingSupported() throws IOException {
+    bytesIn.writeByte(0x44); // == Literal indexed ==
+    // Indexed name (idx = 4) -> :path
+    bytesIn.writeByte(0x8c); // Literal value Huffman encoded 12 bytes
+    // decodes to www.example.com which is length 15
+    bytesIn.write(decodeHex("f1e3c2e5f23a6ba0ab90f4ff"));
+
+    hpackReader.readHeaders();
+
+    assertEquals(1, hpackReader.dynamicTableHeaderCount);
+    assertEquals(52, hpackReader.dynamicTableByteCount);
+
+    Header entry = hpackReader.dynamicTable[readerHeaderTableLength() - 1];
+    checkEntry(entry, ":path", "www.example.com", 52);
+  }
+
+  /**
+   * http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#appendix-C.2.1
+   */
+  @Test public void readLiteralHeaderFieldWithIndexing() throws IOException {
+    bytesIn.writeByte(0x40); // Literal indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-key");
+
+    bytesIn.writeByte(0x0d); // Literal value (len = 13)
+    bytesIn.writeUtf8("custom-header");
+
+    hpackReader.readHeaders();
+
+    assertEquals(1, hpackReader.dynamicTableHeaderCount);
+    assertEquals(55, hpackReader.dynamicTableByteCount);
+
+    Header entry = hpackReader.dynamicTable[readerHeaderTableLength() - 1];
+    checkEntry(entry, "custom-key", "custom-header", 55);
+
+    assertEquals(headerEntries("custom-key", "custom-header"), hpackReader.getAndResetHeaderList());
+  }
+
+  /**
+   * http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#appendix-C.2.2
+   */
+  @Test public void literalHeaderFieldWithoutIndexingIndexedName() throws IOException {
+    List<Header> headerBlock = headerEntries(":path", "/sample/path");
+
+    bytesIn.writeByte(0x04); // == Literal not indexed ==
+    // Indexed name (idx = 4) -> :path
+    bytesIn.writeByte(0x0c); // Literal value (len = 12)
+    bytesIn.writeUtf8("/sample/path");
+
+    hpackWriter.writeHeaders(headerBlock);
+    assertEquals(bytesIn, bytesOut);
+
+    hpackReader.readHeaders();
+
+    assertEquals(0, hpackReader.dynamicTableHeaderCount);
+
+    assertEquals(headerBlock, hpackReader.getAndResetHeaderList());
+  }
+
+  @Test public void literalHeaderFieldWithoutIndexingNewName() throws IOException {
+    List<Header> headerBlock = headerEntries("custom-key", "custom-header");
+
+    bytesIn.writeByte(0x00); // Not indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-key");
+
+    bytesIn.writeByte(0x0d); // Literal value (len = 13)
+    bytesIn.writeUtf8("custom-header");
+
+    hpackReader.readHeaders();
+
+    assertEquals(0, hpackReader.dynamicTableHeaderCount);
+
+    assertEquals(headerBlock, hpackReader.getAndResetHeaderList());
+  }
+
+  @Test public void literalHeaderFieldNeverIndexedIndexedName() throws IOException {
+    bytesIn.writeByte(0x14); // == Literal never indexed ==
+    // Indexed name (idx = 4) -> :path
+    bytesIn.writeByte(0x0c); // Literal value (len = 12)
+    bytesIn.writeUtf8("/sample/path");
+
+    hpackReader.readHeaders();
+
+    assertEquals(0, hpackReader.dynamicTableHeaderCount);
+
+    assertEquals(headerEntries(":path", "/sample/path"), hpackReader.getAndResetHeaderList());
+  }
+
+  @Test public void literalHeaderFieldNeverIndexedNewName() throws IOException {
+    bytesIn.writeByte(0x10); // Never indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-key");
+
+    bytesIn.writeByte(0x0d); // Literal value (len = 13)
+    bytesIn.writeUtf8("custom-header");
+
+    hpackReader.readHeaders();
+
+    assertEquals(0, hpackReader.dynamicTableHeaderCount);
+
+    assertEquals(headerEntries("custom-key", "custom-header"), hpackReader.getAndResetHeaderList());
+  }
+
+  @Test
+  public void literalHeaderFieldWithIncrementalIndexingIndexedName() throws IOException {
+    List<Header> headerBlock = headerEntries(":path", "/sample/path");
+
+    bytesIn.writeByte(0x44); // Indexed name (idx = 4) -> :path
+    bytesIn.writeByte(0x0c); // Literal value (len = 12)
+    bytesIn.writeUtf8("/sample/path");
+
+    hpackReader.readHeaders();
+
+    assertEquals(1, hpackReader.dynamicTableHeaderCount);
+
+    assertEquals(headerBlock, hpackReader.getAndResetHeaderList());
+  }
+
+  @Test
+  public void literalHeaderFieldWithIncrementalIndexingNewName() throws IOException {
+    List<Header> headerBlock = headerEntries("custom-key", "custom-header");
+
+    bytesIn.writeByte(0x40); // Never indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-key");
+
+    bytesIn.writeByte(0x0d); // Literal value (len = 13)
+    bytesIn.writeUtf8("custom-header");
+
+    hpackWriter.writeHeaders(headerBlock);
+    assertEquals(bytesIn, bytesOut);
+
+    assertEquals(1, hpackWriter.dynamicTableHeaderCount);
+
+    Header entry = hpackWriter.dynamicTable[hpackWriter.dynamicTable.length - 1];
+    checkEntry(entry, "custom-key", "custom-header", 55);
+
+    hpackReader.readHeaders();
+
+    assertEquals(1, hpackWriter.dynamicTableHeaderCount);
+
+    assertEquals(headerBlock, hpackReader.getAndResetHeaderList());
+  }
+
+  @Test
+  public void theSameHeaderAfterOneIncrementalIndexed() throws IOException {
+    List<Header> headerBlock =
+        headerEntries(
+            "custom-key", "custom-header",
+            "custom-key", "custom-header");
+
+    bytesIn.writeByte(0x40); // Never indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-key");
+
+    bytesIn.writeByte(0x0d); // Literal value (len = 13)
+    bytesIn.writeUtf8("custom-header");
+
+    bytesIn.writeByte(0xbe); // Indexed name and value (idx = 63)
+
+    hpackWriter.writeHeaders(headerBlock);
+    assertEquals(bytesIn, bytesOut);
+
+    assertEquals(1, hpackWriter.dynamicTableHeaderCount);
+
+    Header entry = hpackWriter.dynamicTable[hpackWriter.dynamicTable.length - 1];
+    checkEntry(entry, "custom-key", "custom-header", 55);
+
+    hpackReader.readHeaders();
+
+    assertEquals(1, hpackReader.dynamicTableHeaderCount);
+
+    assertEquals(headerBlock, hpackReader.getAndResetHeaderList());
+  }
+
+  @Test public void staticHeaderIsNotCopiedIntoTheIndexedTable() throws IOException {
+    bytesIn.writeByte(0x82); // == Indexed - Add ==
+    // idx = 2 -> :method: GET
+
+    hpackReader.readHeaders();
+
+    assertEquals(0, hpackReader.dynamicTableHeaderCount);
+    assertEquals(0, hpackReader.dynamicTableByteCount);
+
+    assertEquals(null, hpackReader.dynamicTable[readerHeaderTableLength() - 1]);
+
+    assertEquals(headerEntries(":method", "GET"), hpackReader.getAndResetHeaderList());
+  }
+
+  // Example taken from twitter/hpack DecoderTest.testUnusedIndex
+  @Test public void readIndexedHeaderFieldIndex0() throws IOException {
+    bytesIn.writeByte(0x80); // == Indexed - Add idx = 0
+
+    try {
+      hpackReader.readHeaders();
+      fail();
+    } catch (IOException e) {
+      assertEquals("index == 0", e.getMessage());
+    }
+  }
+
+  // Example taken from twitter/hpack DecoderTest.testIllegalIndex
+  @Test public void readIndexedHeaderFieldTooLargeIndex() throws IOException {
+    bytesIn.writeShort(0xff00); // == Indexed - Add idx = 127
+
+    try {
+      hpackReader.readHeaders();
+      fail();
+    } catch (IOException e) {
+      assertEquals("Header index too large 127", e.getMessage());
+    }
+  }
+
+  // Example taken from twitter/hpack DecoderTest.testInsidiousIndex
+  @Test public void readIndexedHeaderFieldInsidiousIndex() throws IOException {
+    bytesIn.writeByte(0xff); // == Indexed - Add ==
+    bytesIn.write(decodeHex("8080808008")); // idx = -2147483521
+
+    try {
+      hpackReader.readHeaders();
+      fail();
+    } catch (IOException e) {
+      assertEquals("Header index too large -2147483521", e.getMessage());
+    }
+  }
+
+  // Example taken from twitter/hpack DecoderTest.testHeaderTableSizeUpdate
+  @Test public void minMaxHeaderTableSize() throws IOException {
+    bytesIn.writeByte(0x20);
+    hpackReader.readHeaders();
+
+    assertEquals(0, hpackReader.maxDynamicTableByteCount());
+
+    bytesIn.writeByte(0x3f); // encode size 4096
+    bytesIn.writeByte(0xe1);
+    bytesIn.writeByte(0x1f);
+    hpackReader.readHeaders();
+
+    assertEquals(4096, hpackReader.maxDynamicTableByteCount());
+  }
+
+  // Example taken from twitter/hpack DecoderTest.testIllegalHeaderTableSizeUpdate
+  @Test public void cannotSetTableSizeLargerThanSettingsValue() throws IOException {
+    bytesIn.writeByte(0x3f); // encode size 4097
+    bytesIn.writeByte(0xe2);
+    bytesIn.writeByte(0x1f);
+
+    try {
+      hpackReader.readHeaders();
+      fail();
+    } catch (IOException e) {
+      assertEquals("Invalid dynamic table size update 4097", e.getMessage());
+    }
+  }
+
+  // Example taken from twitter/hpack DecoderTest.testInsidiousMaxHeaderSize
+  @Test public void readHeaderTableStateChangeInsidiousMaxHeaderByteCount() throws IOException {
+    bytesIn.writeByte(0x3f);
+    bytesIn.write(decodeHex("e1ffffff07")); // count = -2147483648
+
+    try {
+      hpackReader.readHeaders();
+      fail();
+    } catch (IOException e) {
+      assertEquals("Invalid dynamic table size update -2147483648", e.getMessage());
+    }
+  }
+
+  /**
+   * http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#appendix-C.2.4
+   */
+  @Test public void readIndexedHeaderFieldFromStaticTableWithoutBuffering() throws IOException {
+    bytesIn.writeByte(0x20); // Dynamic table size update (size = 0).
+    bytesIn.writeByte(0x82); // == Indexed - Add ==
+    // idx = 2 -> :method: GET
+
+    hpackReader.readHeaders();
+
+    // Not buffered in header table.
+    assertEquals(0, hpackReader.dynamicTableHeaderCount);
+
+    assertEquals(headerEntries(":method", "GET"), hpackReader.getAndResetHeaderList());
+  }
+
+  @Test
+  public void readLiteralHeaderWithIncrementalIndexingStaticName() throws IOException {
+    bytesIn.writeByte(0x7d); // == Literal indexed ==
+    // Indexed name (idx = 60) -> "www-authenticate"
+    bytesIn.writeByte(0x05); // Literal value (len = 5)
+    bytesIn.writeUtf8("Basic");
+
+    hpackReader.readHeaders();
+
+    assertEquals(headerEntries("www-authenticate", "Basic"),
+        hpackReader.getAndResetHeaderList());
+  }
+
+  @Test
+  public void readLiteralHeaderWithIncrementalIndexingDynamicName() throws IOException {
+    bytesIn.writeByte(0x40);
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-foo");
+    bytesIn.writeByte(0x05); // Literal value (len = 5)
+    bytesIn.writeUtf8("Basic");
+
+    bytesIn.writeByte(0x7e);
+    bytesIn.writeByte(0x06); // Literal value (len = 6)
+    bytesIn.writeUtf8("Basic2");
+
+    hpackReader.readHeaders();
+
+    assertEquals(headerEntries("custom-foo", "Basic", "custom-foo", "Basic2"),
+        hpackReader.getAndResetHeaderList());
+  }
+
+
+  /**
+   * http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#appendix-C.2
+   */
+  @Test public void readRequestExamplesWithoutHuffman() throws IOException {
+    firstRequestWithoutHuffman();
+    hpackReader.readHeaders();
+    checkReadFirstRequestWithoutHuffman();
+
+    secondRequestWithoutHuffman();
+    hpackReader.readHeaders();
+    checkReadSecondRequestWithoutHuffman();
+
+    thirdRequestWithoutHuffman();
+    hpackReader.readHeaders();
+    checkReadThirdRequestWithoutHuffman();
+  }
+
+  @Test
+  public void readFailingRequestExample() throws IOException {
+    bytesIn.writeByte(0x82); // == Indexed - Add ==
+    // idx = 2 -> :method: GET
+    bytesIn.writeByte(0x86); // == Indexed - Add ==
+    // idx = 7 -> :scheme: http
+    bytesIn.writeByte(0x84); // == Indexed - Add ==
+
+    bytesIn.writeByte(0x7f); // == Bad index! ==
+
+    // Indexed name (idx = 4) -> :authority
+    bytesIn.writeByte(0x0f); // Literal value (len = 15)
+    bytesIn.writeUtf8("www.example.com");
+
+    try {
+      hpackReader.readHeaders();
+      fail();
+    } catch (IOException e) {
+      assertEquals("Header index too large 78", e.getMessage());
+    }
+  }
+
+  private void firstRequestWithoutHuffman() {
+    bytesIn.writeByte(0x82); // == Indexed - Add ==
+    // idx = 2 -> :method: GET
+    bytesIn.writeByte(0x86); // == Indexed - Add ==
+    // idx = 7 -> :scheme: http
+    bytesIn.writeByte(0x84); // == Indexed - Add ==
+    // idx = 6 -> :path: /
+    bytesIn.writeByte(0x41); // == Literal indexed ==
+    // Indexed name (idx = 4) -> :authority
+    bytesIn.writeByte(0x0f); // Literal value (len = 15)
+    bytesIn.writeUtf8("www.example.com");
+  }
+
+  private void checkReadFirstRequestWithoutHuffman() {
+    assertEquals(1, hpackReader.dynamicTableHeaderCount);
+
+    // [  1] (s =  57) :authority: www.example.com
+    Header entry = hpackReader.dynamicTable[readerHeaderTableLength() - 1];
+    checkEntry(entry, ":authority", "www.example.com", 57);
+
+    // Table size: 57
+    assertEquals(57, hpackReader.dynamicTableByteCount);
+
+    // Decoded header list:
+    assertEquals(headerEntries(
+        ":method", "GET",
+        ":scheme", "http",
+        ":path", "/",
+        ":authority", "www.example.com"), hpackReader.getAndResetHeaderList());
+  }
+
+  private void secondRequestWithoutHuffman() {
+    bytesIn.writeByte(0x82); // == Indexed - Add ==
+    // idx = 2 -> :method: GET
+    bytesIn.writeByte(0x86); // == Indexed - Add ==
+    // idx = 7 -> :scheme: http
+    bytesIn.writeByte(0x84); // == Indexed - Add ==
+    // idx = 6 -> :path: /
+    bytesIn.writeByte(0xbe); // == Indexed - Add ==
+    // Indexed name (idx = 62) -> :authority: www.example.com
+    bytesIn.writeByte(0x58); // == Literal indexed ==
+    // Indexed name (idx = 24) -> cache-control
+    bytesIn.writeByte(0x08); // Literal value (len = 8)
+    bytesIn.writeUtf8("no-cache");
+  }
+
+  private void checkReadSecondRequestWithoutHuffman() {
+    assertEquals(2, hpackReader.dynamicTableHeaderCount);
+
+    // [  1] (s =  53) cache-control: no-cache
+    Header entry = hpackReader.dynamicTable[readerHeaderTableLength() - 2];
+    checkEntry(entry, "cache-control", "no-cache", 53);
+
+    // [  2] (s =  57) :authority: www.example.com
+    entry = hpackReader.dynamicTable[readerHeaderTableLength() - 1];
+    checkEntry(entry, ":authority", "www.example.com", 57);
+
+    // Table size: 110
+    assertEquals(110, hpackReader.dynamicTableByteCount);
+
+    // Decoded header list:
+    assertEquals(headerEntries(
+        ":method", "GET",
+        ":scheme", "http",
+        ":path", "/",
+        ":authority", "www.example.com",
+        "cache-control", "no-cache"), hpackReader.getAndResetHeaderList());
+  }
+
+  private void thirdRequestWithoutHuffman() {
+    bytesIn.writeByte(0x82); // == Indexed - Add ==
+    // idx = 2 -> :method: GET
+    bytesIn.writeByte(0x87); // == Indexed - Add ==
+    // idx = 7 -> :scheme: http
+    bytesIn.writeByte(0x85); // == Indexed - Add ==
+    // idx = 5 -> :path: /index.html
+    bytesIn.writeByte(0xbf); // == Indexed - Add ==
+    // Indexed name (idx = 63) -> :authority: www.example.com
+    bytesIn.writeByte(0x40); // Literal indexed
+    bytesIn.writeByte(0x0a); // Literal name (len = 10)
+    bytesIn.writeUtf8("custom-key");
+    bytesIn.writeByte(0x0c); // Literal value (len = 12)
+    bytesIn.writeUtf8("custom-value");
+  }
+
+  private void checkReadThirdRequestWithoutHuffman() {
+    assertEquals(3, hpackReader.dynamicTableHeaderCount);
+
+    // [  1] (s =  54) custom-key: custom-value
+    Header entry = hpackReader.dynamicTable[readerHeaderTableLength() - 3];
+    checkEntry(entry, "custom-key", "custom-value", 54);
+
+    // [  2] (s =  53) cache-control: no-cache
+    entry = hpackReader.dynamicTable[readerHeaderTableLength() - 2];
+    checkEntry(entry, "cache-control", "no-cache", 53);
+
+    // [  3] (s =  57) :authority: www.example.com
+    entry = hpackReader.dynamicTable[readerHeaderTableLength() - 1];
+    checkEntry(entry, ":authority", "www.example.com", 57);
+
+    // Table size: 164
+    assertEquals(164, hpackReader.dynamicTableByteCount);
+
+    // Decoded header list:
+    assertEquals(headerEntries(
+        ":method", "GET",
+        ":scheme", "https",
+        ":path", "/index.html",
+        ":authority", "www.example.com",
+        "custom-key", "custom-value"), hpackReader.getAndResetHeaderList());
+  }
+
+  /**
+   * http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-12#appendix-C.4
+   */
+  @Test public void readRequestExamplesWithHuffman() throws IOException {
+    firstRequestWithHuffman();
+    hpackReader.readHeaders();
+    checkReadFirstRequestWithHuffman();
+
+    secondRequestWithHuffman();
+    hpackReader.readHeaders();
+    checkReadSecondRequestWithHuffman();
+
+    thirdRequestWithHuffman();
+    hpackReader.readHeaders();
+    checkReadThirdRequestWithHuffman();
+  }
+
+  private void firstRequestWithHuffman() {
+    bytesIn.writeByte(0x82); // == Indexed - Add ==
+    // idx = 2 -> :method: GET
+    bytesIn.writeByte(0x86); // == Indexed - Add ==
+    // idx = 6 -> :scheme: http
+    bytesIn.writeByte(0x84); // == Indexed - Add ==
+    // idx = 4 -> :path: /
+    bytesIn.writeByte(0x41); // == Literal indexed ==
+    // Indexed name (idx = 1) -> :authority
+    bytesIn.writeByte(0x8c); // Literal value Huffman encoded 12 bytes
+    // decodes to www.example.com which is length 15
+    bytesIn.write(decodeHex("f1e3c2e5f23a6ba0ab90f4ff"));
+  }
+
+  private void checkReadFirstRequestWithHuffman() {
+    assertEquals(1, hpackReader.dynamicTableHeaderCount);
+
+    // [  1] (s =  57) :authority: www.example.com
+    Header entry = hpackReader.dynamicTable[readerHeaderTableLength() - 1];
+    checkEntry(entry, ":authority", "www.example.com", 57);
+
+    // Table size: 57
+    assertEquals(57, hpackReader.dynamicTableByteCount);
+
+    // Decoded header list:
+    assertEquals(headerEntries(
+        ":method", "GET",
+        ":scheme", "http",
+        ":path", "/",
+        ":authority", "www.example.com"), hpackReader.getAndResetHeaderList());
+  }
+
+  private void secondRequestWithHuffman() {
+    bytesIn.writeByte(0x82); // == Indexed - Add ==
+    // idx = 2 -> :method: GET
+    bytesIn.writeByte(0x86); // == Indexed - Add ==
+    // idx = 6 -> :scheme: http
+    bytesIn.writeByte(0x84); // == Indexed - Add ==
+    // idx = 4 -> :path: /
+    bytesIn.writeByte(0xbe); // == Indexed - Add ==
+    // idx = 62 -> :authority: www.example.com
+    bytesIn.writeByte(0x58); // == Literal indexed ==
+    // Indexed name (idx = 24) -> cache-control
+    bytesIn.writeByte(0x86); // Literal value Huffman encoded 6 bytes
+    // decodes to no-cache which is length 8
+    bytesIn.write(decodeHex("a8eb10649cbf"));
+  }
+
+  private void checkReadSecondRequestWithHuffman() {
+    assertEquals(2, hpackReader.dynamicTableHeaderCount);
+
+    // [  1] (s =  53) cache-control: no-cache
+    Header entry = hpackReader.dynamicTable[readerHeaderTableLength() - 2];
+    checkEntry(entry, "cache-control", "no-cache", 53);
+
+    // [  2] (s =  57) :authority: www.example.com
+    entry = hpackReader.dynamicTable[readerHeaderTableLength() - 1];
+    checkEntry(entry, ":authority", "www.example.com", 57);
+
+    // Table size: 110
+    assertEquals(110, hpackReader.dynamicTableByteCount);
+
+    // Decoded header list:
+    assertEquals(headerEntries(
+        ":method", "GET",
+        ":scheme", "http",
+        ":path", "/",
+        ":authority", "www.example.com",
+        "cache-control", "no-cache"), hpackReader.getAndResetHeaderList());
+  }
+
+  private void thirdRequestWithHuffman() {
+    bytesIn.writeByte(0x82); // == Indexed - Add ==
+    // idx = 2 -> :method: GET
+    bytesIn.writeByte(0x87); // == Indexed - Add ==
+    // idx = 7 -> :scheme: https
+    bytesIn.writeByte(0x85); // == Indexed - Add ==
+    // idx = 5 -> :path: /index.html
+    bytesIn.writeByte(0xbf); // == Indexed - Add ==
+    // idx = 63 -> :authority: www.example.com
+    bytesIn.writeByte(0x40); // Literal indexed
+    bytesIn.writeByte(0x88); // Literal name Huffman encoded 8 bytes
+    // decodes to custom-key which is length 10
+    bytesIn.write(decodeHex("25a849e95ba97d7f"));
+    bytesIn.writeByte(0x89); // Literal value Huffman encoded 9 bytes
+    // decodes to custom-value which is length 12
+    bytesIn.write(decodeHex("25a849e95bb8e8b4bf"));
+  }
+
+  private void checkReadThirdRequestWithHuffman() {
+    assertEquals(3, hpackReader.dynamicTableHeaderCount);
+
+    // [  1] (s =  54) custom-key: custom-value
+    Header entry = hpackReader.dynamicTable[readerHeaderTableLength() - 3];
+    checkEntry(entry, "custom-key", "custom-value", 54);
+
+    // [  2] (s =  53) cache-control: no-cache
+    entry = hpackReader.dynamicTable[readerHeaderTableLength() - 2];
+    checkEntry(entry, "cache-control", "no-cache", 53);
+
+    // [  3] (s =  57) :authority: www.example.com
+    entry = hpackReader.dynamicTable[readerHeaderTableLength() - 1];
+    checkEntry(entry, ":authority", "www.example.com", 57);
+
+    // Table size: 164
+    assertEquals(164, hpackReader.dynamicTableByteCount);
+
+    // Decoded header list:
+    assertEquals(headerEntries(
+        ":method", "GET",
+        ":scheme", "https",
+        ":path", "/index.html",
+        ":authority", "www.example.com",
+        "custom-key", "custom-value"), hpackReader.getAndResetHeaderList());
+  }
+
+  @Test public void readSingleByteInt() throws IOException {
+    assertEquals(10, newReader(byteStream()).readInt(10, 31));
+    assertEquals(10, newReader(byteStream()).readInt(0xe0 | 10, 31));
+  }
+
+  @Test public void readMultibyteInt() throws IOException {
+    assertEquals(1337, newReader(byteStream(154, 10)).readInt(31, 31));
+  }
+
+  @Test public void writeSingleByteInt() throws IOException {
+    hpackWriter.writeInt(10, 31, 0);
+    assertBytes(10);
+    hpackWriter.writeInt(10, 31, 0xe0);
+    assertBytes(0xe0 | 10);
+  }
+
+  @Test public void writeMultibyteInt() throws IOException {
+    hpackWriter.writeInt(1337, 31, 0);
+    assertBytes(31, 154, 10);
+    hpackWriter.writeInt(1337, 31, 0xe0);
+    assertBytes(0xe0 | 31, 154, 10);
+  }
+
+  @Test public void max31BitValue() throws IOException {
+    hpackWriter.writeInt(0x7fffffff, 31, 0);
+    assertBytes(31, 224, 255, 255, 255, 7);
+    assertEquals(0x7fffffff,
+        newReader(byteStream(224, 255, 255, 255, 7)).readInt(31, 31));
+  }
+
+  @Test public void prefixMask() throws IOException {
+    hpackWriter.writeInt(31, 31, 0);
+    assertBytes(31, 0);
+    assertEquals(31, newReader(byteStream(0)).readInt(31, 31));
+  }
+
+  @Test public void prefixMaskMinusOne() throws IOException {
+    hpackWriter.writeInt(30, 31, 0);
+    assertBytes(30);
+    assertEquals(31, newReader(byteStream(0)).readInt(31, 31));
+  }
+
+  @Test public void zero() throws IOException {
+    hpackWriter.writeInt(0, 31, 0);
+    assertBytes(0);
+    assertEquals(0, newReader(byteStream()).readInt(0, 31));
+  }
+
+  @Test public void lowercaseHeaderNameBeforeEmit() throws IOException {
+    hpackWriter.writeHeaders(Arrays.asList(new Header("FoO", "BaR")));
+    assertBytes(0x40, 3, 'f', 'o', 'o', 3, 'B', 'a', 'R');
+  }
+
+  @Test public void mixedCaseHeaderNameIsMalformed() throws IOException {
+    try {
+      newReader(byteStream(0, 3, 'F', 'o', 'o', 3, 'B', 'a', 'R')).readHeaders();
+      fail();
+    } catch (IOException e) {
+      assertEquals("PROTOCOL_ERROR response malformed: mixed case name: Foo", e.getMessage());
+    }
+  }
+
+  @Test public void emptyHeaderName() throws IOException {
+    hpackWriter.writeByteString(ByteString.encodeUtf8(""));
+    assertBytes(0);
+    assertEquals(ByteString.EMPTY, newReader(byteStream(0)).readByteString());
+  }
+
+  @Test
+  public void emitsDynamicTableSizeUpdate() throws IOException {
+    hpackWriter.resizeHeaderTable(2048);
+    hpackWriter.writeHeaders(Arrays.asList(new Header("foo", "bar")));
+    assertBytes(
+        0x3F, 0xE1, 0xF, // Dynamic table size update (size = 2048).
+        0x40, 3, 'f', 'o', 'o', 3, 'b', 'a', 'r');
+
+    hpackWriter.resizeHeaderTable(8192);
+    hpackWriter.writeHeaders(Arrays.asList(new Header("bar", "foo")));
+    assertBytes(
+        0x3F, 0xE1, 0x3F, // Dynamic table size update (size = 8192).
+        0x40, 3, 'b', 'a', 'r', 3, 'f', 'o', 'o');
+
+    // No more dynamic table updates should be emitted.
+    hpackWriter.writeHeaders(Arrays.asList(new Header("far", "boo")));
+    assertBytes(0x40, 3, 'f', 'a', 'r', 3, 'b', 'o', 'o');
+  }
+
+  @Test
+  public void noDynamicTableSizeUpdateWhenSizeIsEqual() throws IOException {
+    int currentSize = hpackWriter.headerTableSizeSetting;
+    hpackWriter.resizeHeaderTable(currentSize);
+    hpackWriter.writeHeaders(Arrays.asList(new Header("foo", "bar")));
+
+    assertBytes(0x40, 3, 'f', 'o', 'o', 3, 'b', 'a', 'r');
+  }
+
+  @Test
+  public void growDynamicTableSize() throws IOException {
+    hpackWriter.resizeHeaderTable(8192);
+    hpackWriter.resizeHeaderTable(16384);
+    hpackWriter.writeHeaders(Arrays.asList(new Header("foo", "bar")));
+
+    assertBytes(
+        0x3F, 0xE1, 0x7F, // Dynamic table size update (size = 16384).
+        0x40, 3, 'f', 'o', 'o', 3, 'b', 'a', 'r');
+  }
+
+  @Test
+  public void shrinkDynamicTableSize() throws IOException {
+    hpackWriter.resizeHeaderTable(2048);
+    hpackWriter.resizeHeaderTable(0);
+    hpackWriter.writeHeaders(Arrays.asList(new Header("foo", "bar")));
+
+    assertBytes(
+        0x20, // Dynamic size update (size = 0).
+        0x40, 3, 'f', 'o', 'o', 3, 'b', 'a', 'r');
+  }
+
+  @Test
+  public void manyDynamicTableSizeChanges() throws IOException {
+    hpackWriter.resizeHeaderTable(16384);
+    hpackWriter.resizeHeaderTable(8096);
+    hpackWriter.resizeHeaderTable(0);
+    hpackWriter.resizeHeaderTable(4096);
+    hpackWriter.resizeHeaderTable(2048);
+    hpackWriter.writeHeaders(Arrays.asList(new Header("foo", "bar")));
+
+    assertBytes(
+        0x20, // Dynamic size update (size = 0).
+        0x3F, 0xE1, 0xF, // Dynamic size update (size = 2048).
+        0x40, 3, 'f', 'o', 'o', 3, 'b', 'a', 'r');
+  }
+
+  @Test
+  public void dynamicTableEvictionWhenSizeLowered() throws IOException {
+    List<Header> headerBlock =
+        headerEntries(
+            "custom-key1", "custom-header",
+            "custom-key2", "custom-header");
+    hpackWriter.writeHeaders(headerBlock);
+    assertEquals(2, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.resizeHeaderTable(56);
+    assertEquals(1, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.resizeHeaderTable(0);
+    assertEquals(0, hpackWriter.dynamicTableHeaderCount);
+  }
+
+  @Test
+  public void noEvictionOnDynamicTableSizeIncrease() throws IOException {
+    List<Header> headerBlock =
+        headerEntries(
+            "custom-key1", "custom-header",
+            "custom-key2", "custom-header");
+    hpackWriter.writeHeaders(headerBlock);
+    assertEquals(2, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.resizeHeaderTable(8192);
+    assertEquals(2, hpackWriter.dynamicTableHeaderCount);
+  }
+
+  @Test
+  public void dynamicTableSizeHasAnUpperBound() {
+    hpackWriter.resizeHeaderTable(1048576);
+    assertEquals(16384, hpackWriter.maxDynamicTableByteCount());
+  }
+
+  @Test
+  public void huffmanEncode() throws IOException {
+    hpackWriter = new Hpack.Writer(4096, true, bytesOut);
+    hpackWriter.writeHeaders(headerEntries("foo", "bar"));
+
+    ByteString expected = new Buffer()
+        .writeByte(0x40) // Literal header, new name.
+        .writeByte(0x82) // String literal is Huffman encoded (len = 2).
+        .writeByte(0x94) // 'foo' Huffman encoded.
+        .writeByte(0xE7)
+        .writeByte(3) // String literal not Huffman encoded (len = 3).
+        .writeByte('b')
+        .writeByte('a')
+        .writeByte('r')
+        .readByteString();
+
+    ByteString actual = bytesOut.readByteString();
+    assertEquals(expected, actual);
+  }
+
+  @Test
+  public void staticTableIndexedHeaders() throws IOException {
+    hpackWriter.writeHeaders(headerEntries(":method", "GET"));
+    assertBytes(0x82);
+    assertEquals(0, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.writeHeaders(headerEntries(":method", "POST"));
+    assertBytes(0x83);
+    assertEquals(0, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.writeHeaders(headerEntries(":path", "/"));
+    assertBytes(0x84);
+    assertEquals(0, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.writeHeaders(headerEntries(":path", "/index.html"));
+    assertBytes(0x85);
+    assertEquals(0, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.writeHeaders(headerEntries(":scheme", "http"));
+    assertBytes(0x86);
+    assertEquals(0, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.writeHeaders(headerEntries(":scheme", "https"));
+    assertBytes(0x87);
+    assertEquals(0, hpackWriter.dynamicTableHeaderCount);
+  }
+
+  @Test
+  public void dynamicTableIndexedHeader() throws IOException {
+    hpackWriter.writeHeaders(headerEntries("custom-key", "custom-header"));
+    assertBytes(0x40,
+        10, 'c', 'u', 's', 't', 'o', 'm', '-', 'k', 'e', 'y',
+        13, 'c', 'u', 's', 't', 'o', 'm', '-', 'h', 'e', 'a', 'd', 'e', 'r');
+    assertEquals(1, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.writeHeaders(headerEntries("custom-key", "custom-header"));
+    assertBytes(0xbe);
+    assertEquals(1, hpackWriter.dynamicTableHeaderCount);
+  }
+
+  @Test
+  public void doNotIndexPseudoHeaders() throws IOException {
+    hpackWriter.writeHeaders(headerEntries(":method", "PUT"));
+    assertBytes(0x02, 3, 'P', 'U', 'T');
+    assertEquals(0, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.writeHeaders(headerEntries(":path", "/okhttp"));
+    assertBytes(0x04, 7, '/', 'o', 'k', 'h', 't', 't', 'p');
+    assertEquals(0, hpackWriter.dynamicTableHeaderCount);
+  }
+
+  @Test
+  public void incrementalIndexingWithAuthorityPseudoHeader() throws IOException {
+    hpackWriter.writeHeaders(headerEntries(":authority", "foo.com"));
+    assertBytes(0x41, 7, 'f', 'o', 'o', '.', 'c', 'o', 'm');
+    assertEquals(1, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.writeHeaders(headerEntries(":authority", "foo.com"));
+    assertBytes(0xbe);
+    assertEquals(1, hpackWriter.dynamicTableHeaderCount);
+
+    // If the :authority header somehow changes, it should be re-added to the dynamic table.
+    hpackWriter.writeHeaders(headerEntries(":authority", "bar.com"));
+    assertBytes(0x41, 7, 'b', 'a', 'r', '.', 'c', 'o', 'm');
+    assertEquals(2, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.writeHeaders(headerEntries(":authority", "bar.com"));
+    assertBytes(0xbe);
+    assertEquals(2, hpackWriter.dynamicTableHeaderCount);
+  }
+
+  @Test
+  public void incrementalIndexingWithStaticTableIndexedName() throws IOException {
+    hpackWriter.writeHeaders(headerEntries("accept-encoding", "gzip"));
+    assertBytes(0x50, 4, 'g', 'z', 'i', 'p');
+    assertEquals(1, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.writeHeaders(headerEntries("accept-encoding", "gzip"));
+    assertBytes(0xbe);
+    assertEquals(1, hpackWriter.dynamicTableHeaderCount);
+  }
+
+  @Test
+  public void incrementalIndexingWithDynamcTableIndexedName() throws IOException {
+    hpackWriter.writeHeaders(headerEntries("foo", "bar"));
+    assertBytes(0x40, 3, 'f', 'o', 'o', 3, 'b', 'a', 'r');
+    assertEquals(1, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.writeHeaders(headerEntries("foo", "bar1"));
+    assertBytes(0x7e, 4, 'b', 'a', 'r', '1');
+    assertEquals(2, hpackWriter.dynamicTableHeaderCount);
+
+    hpackWriter.writeHeaders(headerEntries("foo", "bar1"));
+    assertBytes(0xbe);
+    assertEquals(2, hpackWriter.dynamicTableHeaderCount);
+  }
+
+
+  private Hpack.Reader newReader(Buffer source) {
+    return new Hpack.Reader(4096, source);
+  }
+
+  private Buffer byteStream(int... bytes) {
+    return new Buffer().write(intArrayToByteArray(bytes));
+  }
+
+  private void checkEntry(Header entry, String name, String value, int size) {
+    assertEquals(name, entry.name.utf8());
+    assertEquals(value, entry.value.utf8());
+    assertEquals(size, entry.hpackSize);
+  }
+
+  private void assertBytes(int... bytes) throws IOException {
+    ByteString expected = intArrayToByteArray(bytes);
+    ByteString actual = bytesOut.readByteString();
+    assertEquals(expected, actual);
+  }
+
+  private ByteString intArrayToByteArray(int[] bytes) {
+    byte[] data = new byte[bytes.length];
+    for (int i = 0; i < bytes.length; i++) {
+      data[i] = (byte) bytes[i];
+    }
+    return ByteString.of(data);
+  }
+
+  private int readerHeaderTableLength() {
+    return hpackReader.dynamicTable.length;
+  }
+}
diff --git a/okhttp/third_party/okhttp/test/java/io/grpc/okhttp/internal/framed/Http2Test.java b/okhttp/third_party/okhttp/test/java/io/grpc/okhttp/internal/framed/Http2Test.java
new file mode 100644
index 00000000000..5631a18515d
--- /dev/null
+++ b/okhttp/third_party/okhttp/test/java/io/grpc/okhttp/internal/framed/Http2Test.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2023 Square, Inc.
+ *
+ * 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.okhttp.internal.framed;
+
+import static io.grpc.okhttp.internal.framed.Http2.FLAG_NONE;
+import static io.grpc.okhttp.internal.framed.Http2.FLAG_PADDED;
+import static io.grpc.okhttp.internal.framed.Http2.TYPE_DATA;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.verify;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import okio.Buffer;
+import okio.BufferedSink;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class Http2Test {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  private FrameReader http2FrameReader;
+  @Mock
+  private FrameReader.Handler mockHandler;
+  private final int STREAM_ID = 6;
+
+  @Test
+  public void dataFrameNoPadding() throws IOException {
+    Buffer bufferIn = createData(FLAG_NONE, 3239, 0 );
+    http2FrameReader = new Http2.Reader(bufferIn, 100, true);
+    http2FrameReader.nextFrame(mockHandler);
+
+    verify(mockHandler).data(eq(false), eq(STREAM_ID), eq(bufferIn), eq(3239), eq(3239));
+    assertEquals(3239, bufferIn.size());
+  }
+
+  @Test
+  public void dataFrameOneLengthPadding() throws IOException {
+    Buffer bufferIn = createData(FLAG_PADDED, 1876, 0);
+    http2FrameReader = new Http2.Reader(bufferIn, 100, true);
+    http2FrameReader.nextFrame(mockHandler);
+
+    verify(mockHandler).data(eq(false), eq(STREAM_ID), eq(bufferIn), eq(1875), eq(1876));
+    assertEquals(1876, bufferIn.size());
+  }
+
+  @Test
+  public void dataFramePadding() throws IOException {
+    Buffer bufferIn = createData(FLAG_PADDED, 2037, 125);
+    http2FrameReader = new Http2.Reader(bufferIn, 100, true);
+    http2FrameReader.nextFrame(mockHandler);
+
+    verify(mockHandler).data(eq(false), eq(STREAM_ID), eq(bufferIn), eq(2037 - 126), eq(2037));
+    assertEquals(2037 - 125, bufferIn.size());
+  }
+
+  private Buffer createData(int flag, int length, int paddingLength) throws IOException {
+    Buffer sink = new Buffer();
+    writeLength(sink, length);
+    sink.writeByte(TYPE_DATA);
+    sink.writeByte(flag);
+    sink.writeInt(STREAM_ID);
+    if ((flag & FLAG_PADDED) != 0) {
+      sink.writeByte((short)paddingLength);
+    }
+    char[] value = new char[length];
+    Arrays.fill(value, '!');
+    sink.write(new String(value).getBytes(StandardCharsets.UTF_8));
+    return sink;
+  }
+
+  private void writeLength(BufferedSink sink, int length) throws IOException {
+    sink.writeByte((length >>> 16 ) & 0xff);
+    sink.writeByte((length >>> 8 ) & 0xff);
+    sink.writeByte(length & 0xff);
+  }
+}
diff --git a/opentelemetry/build.gradle b/opentelemetry/build.gradle
new file mode 100644
index 00000000000..594686294f0
--- /dev/null
+++ b/opentelemetry/build.gradle
@@ -0,0 +1,59 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "ru.vyarus.animalsniffer"
+}
+
+description = 'gRPC: OpenTelemetry'
+
+dependencies {
+    api project(':grpc-api')
+    implementation libraries.guava,
+            project(':grpc-core'),
+            libraries.opentelemetry.api,
+            libraries.auto.value.annotations,
+            libraries.animalsniffer.annotations
+
+    testImplementation project(':grpc-testing'),
+            project(':grpc-testing-proto'),
+            project(':grpc-inprocess'),
+            testFixtures(project(':grpc-core')),
+            testFixtures(project(':grpc-api')),
+            libraries.opentelemetry.sdk.testing,
+            libraries.assertj.core // opentelemetry.sdk.testing uses compileOnly for assertj
+
+    annotationProcessor libraries.auto.value
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.opentelemetry')
+    }
+}
+
+tasks.named("compileJava").configure {
+    it.options.compilerArgs += [
+            // only has AutoValue annotation processor
+            "-Xlint:-processing"
+    ]
+    appendToProperty(
+            it.options.errorprone.excludedPaths,
+            ".*/build/generated/sources/annotationProcessor/java/.*",
+            "|")
+}
+
+tasks.named("javadoc").configure {
+    exclude 'io/grpc/opentelemetry/internal/**'
+}
diff --git a/opentelemetry/src/main/java/io/grpc/opentelemetry/BinaryFormat.java b/opentelemetry/src/main/java/io/grpc/opentelemetry/BinaryFormat.java
new file mode 100644
index 00000000000..cdf27875903
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/BinaryFormat.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.Metadata;
+import io.opentelemetry.api.trace.SpanContext;
+import io.opentelemetry.api.trace.SpanId;
+import io.opentelemetry.api.trace.TraceFlags;
+import io.opentelemetry.api.trace.TraceId;
+import io.opentelemetry.api.trace.TraceState;
+import java.util.Arrays;
+
+/**
+ *  Binary encoded {@link SpanContext} for context propagation. This is adapted from OpenCensus
+ *  binary format.
+ *
+ * <p>BinaryFormat format:
+ *
+ * <ul>
+ *   <li>Binary value: &lt;version_id&gt;&lt;version_format&gt;
+ *   <li>version_id: 1-byte representing the version id.
+ *   <li>For version_id = 0:
+ *       <ul>
+ *         <li>version_format: &lt;field&gt;&lt;field&gt;
+ *         <li>field_format: &lt;field_id&gt;&lt;field_format&gt;
+ *         <li>Fields:
+ *             <ul>
+ *               <li>TraceId: (field_id = 0, len = 16, default = &#34;0000000000000000&#34;) -
+ *                   16-byte array representing the trace_id.
+ *               <li>SpanId: (field_id = 1, len = 8, default = &#34;00000000&#34;) - 8-byte array
+ *                   representing the span_id.
+ *               <li>TraceFlags: (field_id = 2, len = 1, default = &#34;0&#34;) - 1-byte array
+ *                   representing the trace_flags.
+ *             </ul>
+ *         <li>Fields MUST be encoded using the field id order (smaller to higher).
+ *         <li>Valid value example:
+ *             <ul>
+ *               <li>{0, 0, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 1, 97,
+ *                   98, 99, 100, 101, 102, 103, 104, 2, 1}
+ *               <li>version_id = 0;
+ *               <li>trace_id = {64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79}
+ *               <li>span_id = {97, 98, 99, 100, 101, 102, 103, 104};
+ *               <li>trace_flags = {1};
+ *             </ul>
+ *       </ul>
+ * </ul>
+ */
+final class BinaryFormat implements Metadata.BinaryMarshaller<SpanContext> {
+  private static final byte VERSION_ID = 0;
+  private static final int VERSION_ID_OFFSET = 0;
+  private static final byte ID_SIZE = 1;
+  private static final byte TRACE_ID_FIELD_ID = 0;
+
+  private static final int TRACE_ID_FIELD_ID_OFFSET = VERSION_ID_OFFSET + ID_SIZE;
+  private static final int TRACE_ID_OFFSET = TRACE_ID_FIELD_ID_OFFSET + ID_SIZE;
+  private static final int TRACE_ID_SIZE = TraceId.getLength() / 2;
+
+  private static final byte SPAN_ID_FIELD_ID = 1;
+  private static final int SPAN_ID_FIELD_ID_OFFSET = TRACE_ID_OFFSET + TRACE_ID_SIZE;
+  private static final int SPAN_ID_OFFSET = SPAN_ID_FIELD_ID_OFFSET + ID_SIZE;
+  private static final int SPAN_ID_SIZE = SpanId.getLength() / 2;
+
+  private static final byte TRACE_FLAG_FIELD_ID = 2;
+  private static final int TRACE_FLAG_FIELD_ID_OFFSET = SPAN_ID_OFFSET + SPAN_ID_SIZE;
+  private static final int TRACE_FLAG_OFFSET = TRACE_FLAG_FIELD_ID_OFFSET + ID_SIZE;
+  private static final int REQUIRED_FORMAT_LENGTH = 3 * ID_SIZE + TRACE_ID_SIZE + SPAN_ID_SIZE;
+  private static final int TRACE_FLAG_SIZE = TraceFlags.getLength() / 2;
+  private static final int ALL_FORMAT_LENGTH = REQUIRED_FORMAT_LENGTH + ID_SIZE + TRACE_FLAG_SIZE;
+
+  private static final BinaryFormat INSTANCE = new BinaryFormat();
+
+  public static BinaryFormat getInstance() {
+    return INSTANCE;
+  }
+
+  @Override
+  public byte[] toBytes(SpanContext spanContext) {
+    checkNotNull(spanContext, "spanContext");
+    byte[] bytes = new byte[ALL_FORMAT_LENGTH];
+    bytes[VERSION_ID_OFFSET] = VERSION_ID;
+    bytes[TRACE_ID_FIELD_ID_OFFSET] = TRACE_ID_FIELD_ID;
+    System.arraycopy(spanContext.getTraceIdBytes(), 0, bytes, TRACE_ID_OFFSET, TRACE_ID_SIZE);
+    bytes[SPAN_ID_FIELD_ID_OFFSET] = SPAN_ID_FIELD_ID;
+    System.arraycopy(spanContext.getSpanIdBytes(), 0, bytes, SPAN_ID_OFFSET, SPAN_ID_SIZE);
+    bytes[TRACE_FLAG_FIELD_ID_OFFSET] = TRACE_FLAG_FIELD_ID;
+    bytes[TRACE_FLAG_OFFSET] = spanContext.getTraceFlags().asByte();
+    return bytes;
+  }
+
+
+  @Override
+  public SpanContext parseBytes(byte[] serialized) {
+    checkNotNull(serialized, "bytes");
+    if (serialized.length == 0 || serialized[0] != VERSION_ID) {
+      throw new IllegalArgumentException("Unsupported version.");
+    }
+    if (serialized.length < REQUIRED_FORMAT_LENGTH) {
+      throw new IllegalArgumentException("Invalid input: truncated");
+    }
+    String traceId;
+    String spanId;
+    TraceFlags traceFlags = TraceFlags.getDefault();
+    int pos = 1;
+    if (serialized[pos] == TRACE_ID_FIELD_ID) {
+      traceId = TraceId.fromBytes(
+          Arrays.copyOfRange(serialized, pos + ID_SIZE, pos + ID_SIZE + TRACE_ID_SIZE));
+      pos += ID_SIZE + TRACE_ID_SIZE;
+    } else {
+      throw new IllegalArgumentException("Invalid input: expected trace ID at offset " + pos);
+    }
+    if (serialized[pos] == SPAN_ID_FIELD_ID) {
+      spanId = SpanId.fromBytes(
+          Arrays.copyOfRange(serialized, pos + ID_SIZE, pos + ID_SIZE + SPAN_ID_SIZE));
+      pos += ID_SIZE + SPAN_ID_SIZE;
+    } else {
+      throw new IllegalArgumentException("Invalid input: expected span ID at offset " + pos);
+    }
+    if (serialized.length > pos && serialized[pos] == TRACE_FLAG_FIELD_ID) {
+      if (serialized.length < ALL_FORMAT_LENGTH) {
+        throw new IllegalArgumentException("Invalid input: truncated");
+      }
+      traceFlags = TraceFlags.fromByte(serialized[pos + ID_SIZE]);
+    }
+    return SpanContext.create(traceId, spanId, traceFlags, TraceState.getDefault());
+  }
+}
diff --git a/opentelemetry/src/main/java/io/grpc/opentelemetry/GrpcOpenTelemetry.java b/opentelemetry/src/main/java/io/grpc/opentelemetry/GrpcOpenTelemetry.java
new file mode 100644
index 00000000000..6904340ac74
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/GrpcOpenTelemetry.java
@@ -0,0 +1,470 @@
+/*
+ * Copyright 2023 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.opentelemetry;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.internal.GrpcUtil.IMPLEMENTATION_VERSION;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.HEDGE_BUCKETS;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.LATENCY_BUCKETS;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.RETRY_BUCKETS;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.SIZE_BUCKETS;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.TRANSPARENT_RETRY_BUCKETS;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.ExperimentalApi;
+import io.grpc.InternalConfigurator;
+import io.grpc.InternalConfiguratorRegistry;
+import io.grpc.InternalManagedChannelBuilder;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.MetricSink;
+import io.grpc.ServerBuilder;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.opentelemetry.internal.OpenTelemetryConstants;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.api.metrics.MeterProvider;
+import io.opentelemetry.api.trace.Tracer;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Predicate;
+import javax.annotation.Nullable;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+
+/**
+ *  The entrypoint for OpenTelemetry metrics functionality in gRPC.
+ *
+ *  <p>GrpcOpenTelemetry uses {@link io.opentelemetry.api.OpenTelemetry} APIs for instrumentation.
+ *  When no SDK is explicitly added no telemetry data will be collected. See
+ *  {@code io.opentelemetry.sdk.OpenTelemetrySdk} for information on how to construct the SDK.
+ *
+ */
+public final class GrpcOpenTelemetry {
+
+  private static final Supplier<Stopwatch> STOPWATCH_SUPPLIER = new Supplier<Stopwatch>() {
+    @Override
+    public Stopwatch get() {
+      return Stopwatch.createUnstarted();
+    }
+  };
+
+  @VisibleForTesting
+  static boolean ENABLE_OTEL_TRACING =
+      GrpcUtil.getFlag("GRPC_EXPERIMENTAL_ENABLE_OTEL_TRACING", false);
+
+  private final OpenTelemetry openTelemetrySdk;
+  private final MeterProvider meterProvider;
+  private final Meter meter;
+  private final Map<String, Boolean> enableMetrics;
+  private final boolean disableDefault;
+  private final OpenTelemetryMetricsResource resource;
+  private final OpenTelemetryMetricsModule openTelemetryMetricsModule;
+  private final OpenTelemetryTracingModule openTelemetryTracingModule;
+  private final List<String> optionalLabels;
+  private final MetricSink sink;
+
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  private GrpcOpenTelemetry(Builder builder) {
+    this.openTelemetrySdk = checkNotNull(builder.openTelemetrySdk, "openTelemetrySdk");
+    this.meterProvider = checkNotNull(openTelemetrySdk.getMeterProvider(), "meterProvider");
+    this.meter = this.meterProvider
+        .meterBuilder(OpenTelemetryConstants.INSTRUMENTATION_SCOPE)
+        .setInstrumentationVersion(IMPLEMENTATION_VERSION)
+        .build();
+    this.enableMetrics = ImmutableMap.copyOf(builder.enableMetrics);
+    this.disableDefault = builder.disableAll;
+    this.resource = createMetricInstruments(meter, enableMetrics, disableDefault);
+    this.optionalLabels = ImmutableList.copyOf(builder.optionalLabels);
+    this.openTelemetryMetricsModule = new OpenTelemetryMetricsModule(
+        STOPWATCH_SUPPLIER, resource, optionalLabels, builder.plugins,
+        builder.targetFilter);
+    this.openTelemetryTracingModule = new OpenTelemetryTracingModule(openTelemetrySdk);
+    this.sink = new OpenTelemetryMetricSink(meter, enableMetrics, disableDefault, optionalLabels);
+  }
+
+  @VisibleForTesting
+  OpenTelemetry getOpenTelemetryInstance() {
+    return this.openTelemetrySdk;
+  }
+
+  @VisibleForTesting
+  MeterProvider getMeterProvider() {
+    return this.meterProvider;
+  }
+
+  @VisibleForTesting
+  Meter getMeter() {
+    return this.meter;
+  }
+
+  @VisibleForTesting
+  OpenTelemetryMetricsResource getResource() {
+    return this.resource;
+  }
+
+  @VisibleForTesting
+  Map<String, Boolean> getEnableMetrics() {
+    return this.enableMetrics;
+  }
+
+  @VisibleForTesting
+  List<String> getOptionalLabels() {
+    return optionalLabels;
+  }
+
+  MetricSink getSink() {
+    return sink;
+  }
+
+  @VisibleForTesting
+  Tracer getTracer() {
+    return this.openTelemetryTracingModule.getTracer();
+  }
+
+  @VisibleForTesting
+  TargetFilter getTargetAttributeFilter() {
+    return this.openTelemetryMetricsModule.getTargetAttributeFilter();
+  }
+
+  /**
+   * Registers GrpcOpenTelemetry globally, applying its configuration to all subsequently created
+   * gRPC channels and servers.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10591")
+  public void registerGlobal() {
+    InternalConfiguratorRegistry.setConfigurators(Collections.singletonList(
+        new InternalConfigurator() {
+          @Override
+          public void configureChannelBuilder(ManagedChannelBuilder<?> channelBuilder) {
+            GrpcOpenTelemetry.this.configureChannelBuilder(channelBuilder);
+          }
+
+          @Override
+          public void configureServerBuilder(ServerBuilder<?> serverBuilder) {
+            GrpcOpenTelemetry.this.configureServerBuilder(serverBuilder);
+          }
+        }));
+  }
+
+  /**
+   * Configures the given {@link ManagedChannelBuilder} with OpenTelemetry metrics instrumentation.
+   */
+  public void configureChannelBuilder(ManagedChannelBuilder<?> builder) {
+    InternalManagedChannelBuilder.addMetricSink(builder, sink);
+    InternalManagedChannelBuilder.interceptWithTarget(
+        builder, openTelemetryMetricsModule::getClientInterceptor);
+    if (ENABLE_OTEL_TRACING) {
+      builder.intercept(openTelemetryTracingModule.getClientInterceptor());
+    }
+  }
+
+  /**
+   * Configures the given {@link ServerBuilder} with OpenTelemetry metrics instrumentation.
+   *
+   * @param serverBuilder the server builder to configure
+   */
+  public void configureServerBuilder(ServerBuilder<?> serverBuilder) {
+    /* To ensure baggage propagation to metrics, we need the tracing
+    tracers to be initialised before metrics */
+    if (ENABLE_OTEL_TRACING) {
+      serverBuilder.addStreamTracerFactory(
+          openTelemetryTracingModule.getServerTracerFactory());
+      serverBuilder.intercept(openTelemetryTracingModule.getServerSpanPropagationInterceptor());
+    }
+    serverBuilder.addStreamTracerFactory(openTelemetryMetricsModule.getServerTracerFactory());
+  }
+
+  @VisibleForTesting
+  static OpenTelemetryMetricsResource createMetricInstruments(Meter meter,
+      Map<String, Boolean> enableMetrics, boolean disableDefault) {
+    OpenTelemetryMetricsResource.Builder builder = OpenTelemetryMetricsResource.builder();
+
+    if (isMetricEnabled("grpc.client.call.duration", enableMetrics, disableDefault)) {
+      builder.clientCallDurationCounter(
+          meter.histogramBuilder("grpc.client.call.duration")
+              .setUnit("s")
+              .setDescription(
+                  "Time taken by gRPC to complete an RPC from application's perspective")
+              .setExplicitBucketBoundariesAdvice(LATENCY_BUCKETS)
+              .build());
+    }
+
+    if (isMetricEnabled("grpc.client.attempt.started", enableMetrics, disableDefault)) {
+      builder.clientAttemptCountCounter(
+          meter.counterBuilder("grpc.client.attempt.started")
+              .setUnit("{attempt}")
+              .setDescription("Number of client call attempts started")
+              .build());
+    }
+
+    if (isMetricEnabled("grpc.client.attempt.duration", enableMetrics, disableDefault)) {
+      builder.clientAttemptDurationCounter(
+          meter.histogramBuilder(
+                  "grpc.client.attempt.duration")
+              .setUnit("s")
+              .setDescription("Time taken to complete a client call attempt")
+              .setExplicitBucketBoundariesAdvice(LATENCY_BUCKETS)
+              .build());
+    }
+
+    if (isMetricEnabled("grpc.client.attempt.sent_total_compressed_message_size", enableMetrics,
+        disableDefault)) {
+      builder.clientTotalSentCompressedMessageSizeCounter(
+          meter.histogramBuilder(
+                  "grpc.client.attempt.sent_total_compressed_message_size")
+              .setUnit("By")
+              .setDescription("Compressed message bytes sent per client call attempt")
+              .ofLongs()
+              .setExplicitBucketBoundariesAdvice(SIZE_BUCKETS)
+              .build());
+    }
+
+    if (isMetricEnabled("grpc.client.attempt.rcvd_total_compressed_message_size", enableMetrics,
+        disableDefault)) {
+      builder.clientTotalReceivedCompressedMessageSizeCounter(
+          meter.histogramBuilder(
+                  "grpc.client.attempt.rcvd_total_compressed_message_size")
+              .setUnit("By")
+              .setDescription("Compressed message bytes received per call attempt")
+              .ofLongs()
+              .setExplicitBucketBoundariesAdvice(SIZE_BUCKETS)
+              .build());
+    }
+
+    if (isMetricEnabled("grpc.client.call.retries", enableMetrics, disableDefault)) {
+      builder.clientCallRetriesCounter(
+          meter.histogramBuilder(
+                  "grpc.client.call.retries")
+              .setUnit("{retry}")
+              .setDescription("Number of retries during the client call. "
+                  + "If there were no retries, 0 is not reported.")
+              .ofLongs()
+              .setExplicitBucketBoundariesAdvice(RETRY_BUCKETS)
+              .build());
+    }
+
+    if (isMetricEnabled("grpc.client.call.transparent_retries", enableMetrics,
+        disableDefault)) {
+      builder.clientCallTransparentRetriesCounter(
+          meter.histogramBuilder(
+                  "grpc.client.call.transparent_retries")
+              .setUnit("{transparent_retry}")
+              .setDescription("Number of transparent retries during the client call. "
+                  + "If there were no transparent retries, 0 is not reported.")
+              .ofLongs()
+              .setExplicitBucketBoundariesAdvice(TRANSPARENT_RETRY_BUCKETS)
+              .build());
+    }
+
+    if (isMetricEnabled("grpc.client.call.hedges", enableMetrics, disableDefault)) {
+      builder.clientCallHedgesCounter(
+          meter.histogramBuilder(
+                  "grpc.client.call.hedges")
+              .setUnit("{hedge}")
+              .setDescription("Number of hedges during the client call. "
+                  + "If there were no hedges, 0 is not reported.")
+              .ofLongs()
+              .setExplicitBucketBoundariesAdvice(HEDGE_BUCKETS)
+              .build());
+    }
+
+    if (isMetricEnabled("grpc.client.call.retry_delay", enableMetrics, disableDefault)) {
+      builder.clientCallRetryDelayCounter(
+          meter.histogramBuilder(
+                  "grpc.client.call.retry_delay")
+              .setUnit("s")
+              .setDescription("Total time of delay while there is no active attempt during the "
+                  + "client call")
+              .setExplicitBucketBoundariesAdvice(LATENCY_BUCKETS)
+              .build());
+    }
+
+    if (isMetricEnabled("grpc.server.call.started", enableMetrics, disableDefault)) {
+      builder.serverCallCountCounter(
+          meter.counterBuilder("grpc.server.call.started")
+              .setUnit("{call}")
+              .setDescription("Number of server calls started")
+              .build());
+    }
+
+    if (isMetricEnabled("grpc.server.call.duration", enableMetrics, disableDefault)) {
+      builder.serverCallDurationCounter(
+          meter.histogramBuilder("grpc.server.call.duration")
+              .setUnit("s")
+              .setDescription(
+                  "Time taken to complete a call from server transport's perspective")
+              .setExplicitBucketBoundariesAdvice(LATENCY_BUCKETS)
+              .build());
+    }
+
+    if (isMetricEnabled("grpc.server.call.sent_total_compressed_message_size",
+        enableMetrics, disableDefault)) {
+      builder.serverTotalSentCompressedMessageSizeCounter(
+          meter.histogramBuilder(
+                  "grpc.server.call.sent_total_compressed_message_size")
+              .setUnit("By")
+              .setDescription("Compressed message bytes sent per server call")
+              .ofLongs()
+              .setExplicitBucketBoundariesAdvice(SIZE_BUCKETS)
+              .build());
+    }
+
+    if (isMetricEnabled("grpc.server.call.rcvd_total_compressed_message_size",
+        enableMetrics, disableDefault)) {
+      builder.serverTotalReceivedCompressedMessageSizeCounter(
+          meter.histogramBuilder(
+                  "grpc.server.call.rcvd_total_compressed_message_size")
+              .setUnit("By")
+              .setDescription("Compressed message bytes received per server call")
+              .ofLongs()
+              .setExplicitBucketBoundariesAdvice(SIZE_BUCKETS)
+              .build());
+    }
+
+    return builder.build();
+  }
+
+  static boolean isMetricEnabled(String metricName, Map<String, Boolean> enableMetrics,
+      boolean disableDefault) {
+    Boolean explicitlyEnabled = enableMetrics.get(metricName);
+    if (explicitlyEnabled != null) {
+      return explicitlyEnabled;
+    }
+    return OpenTelemetryMetricsModule.DEFAULT_PER_CALL_METRICS_SET.contains(metricName)
+        && !disableDefault;
+  }
+
+  /**
+   * Internal interface to avoid storing a {@link java.util.function.Predicate} directly, ensuring
+   * compatibility with Android devices (API level < 24) that do not use library desugaring.
+   */
+  interface TargetFilter {
+    boolean test(String target);
+  }
+
+  /**
+   * Builder for configuring {@link GrpcOpenTelemetry}.
+   */
+  public static class Builder {
+    private OpenTelemetry openTelemetrySdk = OpenTelemetry.noop();
+    private final List<OpenTelemetryPlugin> plugins = new ArrayList<>();
+    private final Collection<String> optionalLabels = new ArrayList<>();
+    private final Map<String, Boolean> enableMetrics = new HashMap<>();
+    private boolean disableAll;
+    @Nullable
+    private TargetFilter targetFilter;
+
+    private Builder() {}
+
+    /**
+     * Sets the {@link io.opentelemetry.api.OpenTelemetry} entrypoint to use. This can be used to
+     * configure OpenTelemetry by returning the instance created by a
+     * {@code io.opentelemetry.sdk.OpenTelemetrySdkBuilder}.
+     */
+    public Builder sdk(OpenTelemetry sdk) {
+      this.openTelemetrySdk = sdk;
+      return this;
+    }
+
+    Builder plugin(OpenTelemetryPlugin plugin) {
+      plugins.add(checkNotNull(plugin, "plugin"));
+      return this;
+    }
+
+    /**
+     * Adds optionalLabelKey to all the metrics that can provide value for the
+     * optionalLabelKey.
+     */
+    public Builder addOptionalLabel(String optionalLabelKey) {
+      this.optionalLabels.add(optionalLabelKey);
+      return this;
+    }
+
+    /**
+     * Enables the specified metrics for collection and export. By default, only a subset of
+     * metrics are enabled.
+     */
+    public Builder enableMetrics(Collection<String> enableMetrics) {
+      for (String metric : enableMetrics) {
+        this.enableMetrics.put(metric, true);
+      }
+      return this;
+    }
+
+    /**
+     * Disables the specified metrics from being collected and exported.
+     */
+    public Builder disableMetrics(Collection<String> disableMetrics) {
+      for (String metric : disableMetrics) {
+        this.enableMetrics.put(metric, false);
+      }
+      return this;
+    }
+
+    /**
+     * Disable all metrics. If set to true all metrics must be explicitly enabled.
+     */
+    public Builder disableAllMetrics() {
+      this.enableMetrics.clear();
+      this.disableAll = true;
+      return this;
+    }
+
+    Builder enableTracing(boolean enable) {
+      ENABLE_OTEL_TRACING = enable;
+      return this;
+    }
+
+    /**
+     * Sets an optional filter to control recording of the {@code grpc.target} metric
+     * attribute.
+     *
+     * <p>If the predicate returns {@code true}, the original target is recorded. Otherwise,
+     * the target is recorded as {@code "other"} to limit metric cardinality.
+     *
+     * <p>If unset, all targets are recorded as-is.
+     */
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/12595")
+    @IgnoreJRERequirement
+    public Builder targetAttributeFilter(@Nullable Predicate<String> filter) {
+      if (filter == null) {
+        this.targetFilter = null;
+      } else {
+        this.targetFilter = filter::test;
+      }
+      return this;
+    }
+
+    /**
+     * Returns a new {@link GrpcOpenTelemetry} built with the configuration of this {@link
+     * Builder}.
+     */
+    public GrpcOpenTelemetry build() {
+      return new GrpcOpenTelemetry(this);
+    }
+  }
+}
diff --git a/opentelemetry/src/main/java/io/grpc/opentelemetry/GrpcTraceBinContextPropagator.java b/opentelemetry/src/main/java/io/grpc/opentelemetry/GrpcTraceBinContextPropagator.java
new file mode 100644
index 00000000000..4825b203529
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/GrpcTraceBinContextPropagator.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.InternalMetadata.BASE64_ENCODING_OMIT_PADDING;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.io.BaseEncoding;
+import io.grpc.ExperimentalApi;
+import io.grpc.Metadata;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanContext;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.propagation.TextMapGetter;
+import io.opentelemetry.context.propagation.TextMapPropagator;
+import io.opentelemetry.context.propagation.TextMapSetter;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ *  A {@link TextMapPropagator} for transmitting "grpc-trace-bin" span context.
+ *
+ *  <p>This propagator can transmit the "grpc-trace-bin" context in either binary or Base64-encoded
+ * text format, depending on the capabilities of the provided {@link TextMapGetter} and
+ * {@link TextMapSetter}.
+ *
+ *  <p>If the {@code TextMapGetter} and {@code TextMapSetter} only support text format, Base64
+ *  encoding and decoding will be used when communicating with the carrier API. But gRPC uses
+ *  it with gRPC's metadata-based getter/setter, and the propagator can directly transmit the binary
+ *  header, avoiding the need for Base64 encoding.
+ */
+
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/11400")
+public final class GrpcTraceBinContextPropagator implements TextMapPropagator {
+  private static final Logger log = Logger.getLogger(GrpcTraceBinContextPropagator.class.getName());
+  public static final String GRPC_TRACE_BIN_HEADER = "grpc-trace-bin";
+  private final Metadata.BinaryMarshaller<SpanContext> binaryFormat;
+  private static final GrpcTraceBinContextPropagator INSTANCE =
+      new GrpcTraceBinContextPropagator(BinaryFormat.getInstance());
+
+  public static GrpcTraceBinContextPropagator defaultInstance() {
+    return INSTANCE;
+  }
+
+  @VisibleForTesting
+  GrpcTraceBinContextPropagator(Metadata.BinaryMarshaller<SpanContext> binaryFormat) {
+    this.binaryFormat = checkNotNull(binaryFormat, "binaryFormat");
+  }
+
+  @Override
+  public Collection<String> fields() {
+    return Collections.singleton(GRPC_TRACE_BIN_HEADER);
+  }
+
+  @Override
+  public <C> void inject(Context context, @Nullable C carrier, TextMapSetter<C> setter) {
+    if (context == null || setter == null) {
+      return;
+    }
+    SpanContext spanContext = Span.fromContext(context).getSpanContext();
+    if (!spanContext.isValid()) {
+      return;
+    }
+    try {
+      byte[] b = binaryFormat.toBytes(spanContext);
+      if (setter instanceof MetadataSetter) {
+        ((MetadataSetter) setter).set((Metadata) carrier, GRPC_TRACE_BIN_HEADER, b);
+      } else {
+        setter.set(carrier, GRPC_TRACE_BIN_HEADER, BASE64_ENCODING_OMIT_PADDING.encode(b));
+      }
+    } catch (Exception e) {
+      log.log(Level.FINE, "Set grpc-trace-bin spanContext failed", e);
+    }
+  }
+
+  @Override
+  public <C> Context extract(Context context, @Nullable C carrier, TextMapGetter<C> getter) {
+    if (context == null) {
+      return Context.root();
+    }
+    if (getter == null) {
+      return context;
+    }
+    byte[] b;
+    if (getter instanceof MetadataGetter) {
+      try {
+        b = ((MetadataGetter) getter).getBinary((Metadata) carrier, GRPC_TRACE_BIN_HEADER);
+        if (b == null) {
+          log.log(Level.FINE, "No grpc-trace-bin present in carrier");
+          return context;
+        }
+      } catch (Exception e) {
+        log.log(Level.FINE, "Get 'grpc-trace-bin' from MetadataGetter failed", e);
+        return context;
+      }
+    } else {
+      String value;
+      try {
+        value = getter.get(carrier, GRPC_TRACE_BIN_HEADER);
+        if (value == null) {
+          log.log(Level.FINE, "No grpc-trace-bin present in carrier");
+          return context;
+        }
+      } catch (Exception e) {
+        log.log(Level.FINE, "Get 'grpc-trace-bin' from getter failed", e);
+        return context;
+      }
+      try {
+        b = BaseEncoding.base64().decode(value);
+      } catch (Exception e) {
+        log.log(Level.FINE, "Base64-decode spanContext bytes failed", e);
+        return context;
+      }
+    }
+
+    SpanContext spanContext;
+    try {
+      spanContext = binaryFormat.parseBytes(b);
+    } catch (Exception e) {
+      log.log(Level.FINE, "Failed to parse tracing header", e);
+      return context;
+    }
+    if (!spanContext.isValid()) {
+      return context;
+    }
+    return context.with(Span.wrap(spanContext));
+  }
+}
diff --git a/opentelemetry/src/main/java/io/grpc/opentelemetry/InternalGrpcOpenTelemetry.java b/opentelemetry/src/main/java/io/grpc/opentelemetry/InternalGrpcOpenTelemetry.java
new file mode 100644
index 00000000000..ea1e7ab803f
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/InternalGrpcOpenTelemetry.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+import io.grpc.Internal;
+
+/**
+ * Internal accessor for {@link GrpcOpenTelemetry}.
+ */
+@Internal
+public final class InternalGrpcOpenTelemetry {
+  private InternalGrpcOpenTelemetry() {}
+
+  public static void builderPlugin(
+      GrpcOpenTelemetry.Builder builder, InternalOpenTelemetryPlugin plugin) {
+    builder.plugin(plugin);
+  }
+
+  public static void enableTracing(GrpcOpenTelemetry.Builder builder, boolean enable) {
+    builder.enableTracing(enable);
+  }
+}
diff --git a/opentelemetry/src/main/java/io/grpc/opentelemetry/InternalOpenTelemetryPlugin.java b/opentelemetry/src/main/java/io/grpc/opentelemetry/InternalOpenTelemetryPlugin.java
new file mode 100644
index 00000000000..38275506e1a
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/InternalOpenTelemetryPlugin.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+import io.grpc.Internal;
+
+/**
+ * Accessors for making plugins.
+ */
+@Internal
+public interface InternalOpenTelemetryPlugin extends OpenTelemetryPlugin {
+  @Override
+  ClientCallPlugin newClientCallPlugin();
+
+  interface ClientCallPlugin extends OpenTelemetryPlugin.ClientCallPlugin {
+    @Override
+    ClientStreamPlugin newClientStreamPlugin();
+  }
+
+  interface ClientStreamPlugin extends OpenTelemetryPlugin.ClientStreamPlugin {
+  }
+}
diff --git a/opentelemetry/src/main/java/io/grpc/opentelemetry/MetadataGetter.java b/opentelemetry/src/main/java/io/grpc/opentelemetry/MetadataGetter.java
new file mode 100644
index 00000000000..f49c029f2fb
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/MetadataGetter.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+
+import static io.grpc.InternalMetadata.BASE64_ENCODING_OMIT_PADDING;
+
+import io.grpc.Metadata;
+import io.opentelemetry.context.propagation.TextMapGetter;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ *  A TextMapGetter that reads value from gRPC {@link Metadata}. Supports both text and binary
+ *  headers. Supporting binary header is an optimization path for GrpcTraceBinContextPropagator
+ *  to work around the lack of binary propagator API and thus avoid
+ *  base64 (de)encoding when passing data between propagator API interfaces.
+ */
+final class MetadataGetter implements TextMapGetter<Metadata> {
+  private static final Logger logger = Logger.getLogger(MetadataGetter.class.getName());
+  private static final MetadataGetter INSTANCE = new MetadataGetter();
+
+  public static MetadataGetter getInstance() {
+    return INSTANCE;
+  }
+
+  @Override
+  public Iterable<String> keys(Metadata carrier) {
+    return carrier.keys();
+  }
+
+  @Nullable
+  @Override
+  public String get(@Nullable Metadata carrier, String key) {
+    if (carrier == null) {
+      logger.log(Level.FINE, "Carrier is null, getting no data");
+      return null;
+    }
+    try {
+      if (key.equals("grpc-trace-bin")) {
+        byte[] value = carrier.get(Metadata.Key.of(key, Metadata.BINARY_BYTE_MARSHALLER));
+        if (value == null) {
+          return null;
+        }
+        return BASE64_ENCODING_OMIT_PADDING.encode(value);
+      } else {
+        return carrier.get(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER));
+      }
+    } catch (Exception e) {
+      logger.log(Level.FINE, String.format("Failed to get metadata key %s", key), e);
+      return null;
+    }
+  }
+
+  @Nullable
+  public byte[] getBinary(@Nullable Metadata carrier, String key) {
+    if (carrier == null) {
+      logger.log(Level.FINE, "Carrier is null, getting no data");
+      return null;
+    }
+    if (!key.equals("grpc-trace-bin")) {
+      logger.log(Level.FINE, "Only support 'grpc-trace-bin' binary header. Get no data");
+      return null;
+    }
+    try {
+      return carrier.get(Metadata.Key.of(key, Metadata.BINARY_BYTE_MARSHALLER));
+    } catch (Exception e) {
+      logger.log(Level.FINE, String.format("Failed to get metadata key %s", key), e);
+      return null;
+    }
+  }
+}
diff --git a/opentelemetry/src/main/java/io/grpc/opentelemetry/MetadataSetter.java b/opentelemetry/src/main/java/io/grpc/opentelemetry/MetadataSetter.java
new file mode 100644
index 00000000000..5892c7accfe
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/MetadataSetter.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+
+import com.google.common.io.BaseEncoding;
+import io.grpc.Metadata;
+import io.opentelemetry.context.propagation.TextMapSetter;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ *  A {@link TextMapSetter} that sets value to gRPC {@link Metadata}. Supports both text and binary
+ *  headers. Supporting binary header is an optimization path for GrpcTraceBinContextPropagator
+ *  to work around the lack of binary propagator API and thus avoid
+ *  base64 (de)encoding when passing data between propagator API interfaces.
+ */
+final class MetadataSetter implements TextMapSetter<Metadata> {
+  private static final Logger logger = Logger.getLogger(MetadataSetter.class.getName());
+  private static final MetadataSetter INSTANCE = new MetadataSetter();
+
+  public static MetadataSetter getInstance() {
+    return INSTANCE;
+  }
+
+  @Override
+  public void set(@Nullable Metadata carrier, String key, String value) {
+    if (carrier == null) {
+      logger.log(Level.FINE, "Carrier is null, setting no data");
+      return;
+    }
+    try {
+      if (key.equals("grpc-trace-bin")) {
+        carrier.put(Metadata.Key.of(key, Metadata.BINARY_BYTE_MARSHALLER),
+            BaseEncoding.base64().decode(value));
+      } else {
+        carrier.put(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER), value);
+      }
+    } catch (Exception e) {
+      logger.log(Level.INFO, String.format("Failed to set metadata, key=%s", key), e);
+    }
+  }
+
+  void set(@Nullable Metadata carrier, String key, byte[] value) {
+    if (carrier == null) {
+      logger.log(Level.FINE, "Carrier is null, setting no data");
+      return;
+    }
+    if (!key.equals("grpc-trace-bin")) {
+      logger.log(Level.INFO, "Only support 'grpc-trace-bin' binary header. Set no data");
+      return;
+    }
+    try {
+      carrier.put(Metadata.Key.of(key, Metadata.BINARY_BYTE_MARSHALLER), value);
+    } catch (Exception e) {
+      logger.log(Level.INFO, String.format("Failed to set metadata key=%s", key), e);
+    }
+  }
+}
diff --git a/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryMetricSink.java b/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryMetricSink.java
new file mode 100644
index 00000000000..fd8af7f998f
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryMetricSink.java
@@ -0,0 +1,338 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import io.grpc.CallbackMetricInstrument;
+import io.grpc.DoubleCounterMetricInstrument;
+import io.grpc.DoubleHistogramMetricInstrument;
+import io.grpc.LongCounterMetricInstrument;
+import io.grpc.LongGaugeMetricInstrument;
+import io.grpc.LongHistogramMetricInstrument;
+import io.grpc.LongUpDownCounterMetricInstrument;
+import io.grpc.MetricInstrument;
+import io.grpc.MetricSink;
+import io.opentelemetry.api.common.Attributes;
+import io.opentelemetry.api.common.AttributesBuilder;
+import io.opentelemetry.api.metrics.BatchCallback;
+import io.opentelemetry.api.metrics.DoubleCounter;
+import io.opentelemetry.api.metrics.DoubleHistogram;
+import io.opentelemetry.api.metrics.LongCounter;
+import io.opentelemetry.api.metrics.LongHistogram;
+import io.opentelemetry.api.metrics.LongUpDownCounter;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.api.metrics.ObservableLongMeasurement;
+import io.opentelemetry.api.metrics.ObservableMeasurement;
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+final class OpenTelemetryMetricSink implements MetricSink {
+  private static final Logger logger = Logger.getLogger(OpenTelemetryMetricSink.class.getName());
+  private final Object lock = new Object();
+  private final Meter openTelemetryMeter;
+  private final Map<String, Boolean> enableMetrics;
+  private final boolean disableDefaultMetrics;
+  private final Set<String> optionalLabels;
+  private volatile List<MeasuresData> measures = new ArrayList<>();
+
+  OpenTelemetryMetricSink(Meter meter, Map<String, Boolean> enableMetrics,
+      boolean disableDefaultMetrics, List<String> optionalLabels) {
+    this.openTelemetryMeter = checkNotNull(meter, "meter");
+    this.enableMetrics = ImmutableMap.copyOf(enableMetrics);
+    this.disableDefaultMetrics = disableDefaultMetrics;
+    this.optionalLabels = ImmutableSet.copyOf(optionalLabels);
+  }
+
+  @Override
+  public Map<String, Boolean> getEnabledMetrics() {
+    return enableMetrics;
+  }
+
+  @Override
+  public Set<String> getOptionalLabels() {
+    return optionalLabels;
+  }
+
+  @Override
+  public int getMeasuresSize() {
+    return measures.size();
+  }
+
+  @VisibleForTesting
+  List<MeasuresData> getMeasures() {
+    synchronized (lock) {
+      return Collections.unmodifiableList(measures);
+    }
+  }
+
+  @Override
+  public void addDoubleCounter(DoubleCounterMetricInstrument metricInstrument, double value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+    MeasuresData instrumentData = measures.get(metricInstrument.getIndex());
+    if (instrumentData == null) {
+      // Disabled metric
+      return;
+    }
+    Attributes attributes = createAttributes(metricInstrument.getRequiredLabelKeys(),
+        metricInstrument.getOptionalLabelKeys(), requiredLabelValues, optionalLabelValues,
+        instrumentData.getOptionalLabelsBitSet());
+    DoubleCounter counter = (DoubleCounter) instrumentData.getMeasure();
+    counter.add(value, attributes);
+  }
+
+  @Override
+  public void addLongCounter(LongCounterMetricInstrument metricInstrument, long value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+    MeasuresData instrumentData = measures.get(metricInstrument.getIndex());
+    if (instrumentData == null) {
+      // Disabled metric
+      return;
+    }
+    Attributes attributes = createAttributes(metricInstrument.getRequiredLabelKeys(),
+        metricInstrument.getOptionalLabelKeys(), requiredLabelValues, optionalLabelValues,
+        instrumentData.getOptionalLabelsBitSet());
+    LongCounter counter = (LongCounter) instrumentData.getMeasure();
+    counter.add(value, attributes);
+  }
+
+  @Override
+  public void addLongUpDownCounter(LongUpDownCounterMetricInstrument metricInstrument, long value,
+                                   List<String> requiredLabelValues,
+                                   List<String> optionalLabelValues) {
+    MeasuresData instrumentData = measures.get(metricInstrument.getIndex());
+    if (instrumentData == null) {
+      // Disabled metric
+      return;
+    }
+    Attributes attributes = createAttributes(metricInstrument.getRequiredLabelKeys(),
+        metricInstrument.getOptionalLabelKeys(), requiredLabelValues, optionalLabelValues,
+        instrumentData.getOptionalLabelsBitSet());
+    LongUpDownCounter counter = (LongUpDownCounter) instrumentData.getMeasure();
+    counter.add(value, attributes);
+  }
+
+  @Override
+  public void recordDoubleHistogram(DoubleHistogramMetricInstrument metricInstrument, double value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+    MeasuresData instrumentData = measures.get(metricInstrument.getIndex());
+    if (instrumentData == null) {
+      // Disabled metric
+      return;
+    }
+    Attributes attributes = createAttributes(metricInstrument.getRequiredLabelKeys(),
+        metricInstrument.getOptionalLabelKeys(), requiredLabelValues, optionalLabelValues,
+        instrumentData.getOptionalLabelsBitSet());
+    DoubleHistogram histogram = (DoubleHistogram) instrumentData.getMeasure();
+    histogram.record(value, attributes);
+  }
+
+  @Override
+  public void recordLongHistogram(LongHistogramMetricInstrument metricInstrument, long value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+    MeasuresData instrumentData = measures.get(metricInstrument.getIndex());
+    if (instrumentData == null) {
+      // Disabled metric
+      return;
+    }
+    Attributes attributes = createAttributes(metricInstrument.getRequiredLabelKeys(),
+        metricInstrument.getOptionalLabelKeys(), requiredLabelValues, optionalLabelValues,
+        instrumentData.getOptionalLabelsBitSet());
+    LongHistogram histogram = (LongHistogram) instrumentData.getMeasure();
+    histogram.record(value, attributes);
+  }
+
+  @Override
+  public void recordLongGauge(LongGaugeMetricInstrument metricInstrument, long value,
+      List<String> requiredLabelValues, List<String> optionalLabelValues) {
+    MeasuresData instrumentData = measures.get(metricInstrument.getIndex());
+    if (instrumentData == null) {
+      // Disabled metric
+      return;
+    }
+    Attributes attributes = createAttributes(metricInstrument.getRequiredLabelKeys(),
+        metricInstrument.getOptionalLabelKeys(), requiredLabelValues, optionalLabelValues,
+        instrumentData.getOptionalLabelsBitSet());
+    ObservableLongMeasurement gauge = (ObservableLongMeasurement) instrumentData.getMeasure();
+    gauge.record(value, attributes);
+  }
+
+  @Override
+  public Registration registerBatchCallback(Runnable callback,
+      CallbackMetricInstrument... metricInstruments) {
+    List<ObservableMeasurement> measurements = new ArrayList<>(metricInstruments.length);
+    for (CallbackMetricInstrument metricInstrument: metricInstruments) {
+      MeasuresData instrumentData = measures.get(metricInstrument.getIndex());
+      if (instrumentData == null) {
+        // Disabled metric
+        continue;
+      }
+      if (!(instrumentData.getMeasure() instanceof ObservableMeasurement)) {
+        logger.log(Level.FINE, "Unsupported metric instrument type : {0} {1}",
+            new Object[] {metricInstrument, instrumentData.getMeasure().getClass()});
+        continue;
+      }
+      measurements.add((ObservableMeasurement) instrumentData.getMeasure());
+    }
+    if (measurements.isEmpty()) {
+      return () -> { };
+    }
+    ObservableMeasurement first = measurements.get(0);
+    measurements.remove(0);
+    BatchCallback closeable = openTelemetryMeter.batchCallback(
+        callback, first, measurements.toArray(new ObservableMeasurement[0]));
+    return closeable::close;
+  }
+
+  @Override
+  public void updateMeasures(List<MetricInstrument> instruments) {
+    synchronized (lock) {
+      if (measures.size() >= instruments.size()) {
+        // Already up-to-date
+        return;
+      }
+
+      List<MeasuresData> newMeasures = new ArrayList<>(instruments.size());
+      // Reuse existing measures
+      newMeasures.addAll(measures);
+
+      for (int i = measures.size(); i < instruments.size(); i++) {
+        MetricInstrument instrument = instruments.get(i);
+        // Check if the metric is disabled
+        if (!shouldEnableMetric(instrument)) {
+          // Adding null measure for disabled Metric
+          newMeasures.add(null);
+          continue;
+        }
+
+        BitSet bitSet = new BitSet(instrument.getOptionalLabelKeys().size());
+        if (optionalLabels.isEmpty()) {
+          // initialize an empty list
+        } else {
+          List<String> labels = instrument.getOptionalLabelKeys();
+          for (int j = 0; j < labels.size(); j++) {
+            if (optionalLabels.contains(labels.get(j))) {
+              bitSet.set(j);
+            }
+          }
+        }
+
+        int index = instrument.getIndex();
+        String name = instrument.getName();
+        String unit = instrument.getUnit();
+        String description = instrument.getDescription();
+
+        Object openTelemetryMeasure;
+        if (instrument instanceof DoubleCounterMetricInstrument) {
+          openTelemetryMeasure = openTelemetryMeter.counterBuilder(name)
+              .setUnit(unit)
+              .setDescription(description)
+              .ofDoubles()
+              .build();
+        } else if (instrument instanceof LongCounterMetricInstrument) {
+          openTelemetryMeasure = openTelemetryMeter.counterBuilder(name)
+              .setUnit(unit)
+              .setDescription(description)
+              .build();
+        } else if (instrument instanceof DoubleHistogramMetricInstrument) {
+          openTelemetryMeasure = openTelemetryMeter.histogramBuilder(name)
+              .setUnit(unit)
+              .setDescription(description)
+              .build();
+        } else if (instrument instanceof LongHistogramMetricInstrument) {
+          openTelemetryMeasure = openTelemetryMeter.histogramBuilder(name)
+              .setUnit(unit)
+              .setDescription(description)
+              .ofLongs()
+              .build();
+        } else if (instrument instanceof LongGaugeMetricInstrument) {
+          openTelemetryMeasure = openTelemetryMeter.gaugeBuilder(name)
+              .setUnit(unit)
+              .setDescription(description)
+              .ofLongs()
+              .buildObserver();
+        } else if (instrument instanceof LongUpDownCounterMetricInstrument) {
+          openTelemetryMeasure = openTelemetryMeter.upDownCounterBuilder(name)
+              .setUnit(unit)
+              .setDescription(description)
+              .build();
+        } else {
+          logger.log(Level.FINE, "Unsupported metric instrument type : {0}", instrument);
+          openTelemetryMeasure = null;
+        }
+        newMeasures.add(index, new MeasuresData(bitSet, openTelemetryMeasure));
+      }
+
+      measures = newMeasures;
+    }
+  }
+
+  private boolean shouldEnableMetric(MetricInstrument instrument) {
+    Boolean explicitlyEnabled = enableMetrics.get(instrument.getName());
+    if (explicitlyEnabled != null) {
+      return explicitlyEnabled;
+    }
+    return instrument.isEnableByDefault() && !disableDefaultMetrics;
+  }
+
+
+  private Attributes createAttributes(List<String> requiredLabelKeys,
+      List<String> optionalLabelKeys,
+      List<String> requiredLabelValues, List<String> optionalLabelValues, BitSet bitSet) {
+    AttributesBuilder builder = Attributes.builder();
+    // Required Labels
+    for (int i = 0; i < requiredLabelKeys.size(); i++) {
+      builder.put(requiredLabelKeys.get(i), requiredLabelValues.get(i));
+    }
+    // Optional labels
+    for (int i = bitSet.nextSetBit(0); i >= 0; i = bitSet.nextSetBit(i + 1)) {
+      if (i == Integer.MAX_VALUE) {
+        break; // or (i+1) would overflow
+      }
+      builder.put(optionalLabelKeys.get(i), optionalLabelValues.get(i));
+    }
+    return builder.build();
+  }
+
+  static final class MeasuresData {
+    final BitSet optionalLabelsIndices;
+    final Object measure;
+
+    MeasuresData(BitSet optionalLabelsIndices, Object measure) {
+      this.optionalLabelsIndices = optionalLabelsIndices;
+      this.measure = measure;
+    }
+
+    public BitSet getOptionalLabelsBitSet() {
+      return optionalLabelsIndices;
+    }
+
+    public Object getMeasure() {
+      return measure;
+    }
+  }
+
+}
diff --git a/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryMetricsModule.java b/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryMetricsModule.java
new file mode 100644
index 00000000000..b05884305dc
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryMetricsModule.java
@@ -0,0 +1,719 @@
+/*
+ * Copyright 2023 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.opentelemetry;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.BACKEND_SERVICE_KEY;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.BAGGAGE_KEY;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.LOCALITY_KEY;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.METHOD_KEY;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.STATUS_KEY;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.TARGET_KEY;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ClientStreamTracer.StreamInfo;
+import io.grpc.Deadline;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.StreamTracer;
+import io.grpc.opentelemetry.GrpcOpenTelemetry.TargetFilter;
+import io.opentelemetry.api.baggage.Baggage;
+import io.opentelemetry.api.common.AttributesBuilder;
+import io.opentelemetry.context.Context;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicLongFieldUpdater;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * Provides factories for {@link StreamTracer} that records metrics to OpenTelemetry.
+ *
+ * <p>On the client-side, a factory is created for each call, and the factory creates a stream
+ * tracer for each attempt. If there is no stream created when the call is ended, we still create a
+ * tracer. It's the tracer that reports per-attempt stats, and the factory that reports the stats
+ * of the overall RPC, such as RETRIES_PER_CALL, to OpenTelemetry.
+ *
+ * <p>This module optionally applies a target attribute filter to limit the cardinality of
+ * the {@code grpc.target} attribute in client-side metrics by mapping disallowed targets
+ * to a stable placeholder value.
+ *
+ * <p>On the server-side, there is only one ServerStream per each ServerCall, and ServerStream
+ * starts earlier than the ServerCall. Therefore, only one tracer is created per stream/call, and
+ * it's the tracer that reports the summary to OpenTelemetry.
+ */
+final class OpenTelemetryMetricsModule {
+  private static final Logger logger = Logger.getLogger(OpenTelemetryMetricsModule.class.getName());
+  public static final ImmutableSet<String> DEFAULT_PER_CALL_METRICS_SET =
+      ImmutableSet.of(
+          "grpc.client.attempt.started",
+          "grpc.client.attempt.duration",
+          "grpc.client.attempt.sent_total_compressed_message_size",
+          "grpc.client.attempt.rcvd_total_compressed_message_size",
+          "grpc.client.call.duration",
+          "grpc.server.call.started",
+          "grpc.server.call.duration",
+          "grpc.server.call.sent_total_compressed_message_size",
+          "grpc.server.call.rcvd_total_compressed_message_size");
+
+  // Using floating point because TimeUnit.NANOSECONDS.toSeconds would discard
+  // fractional seconds.
+  private static final double SECONDS_PER_NANO = 1e-9;
+
+  private final OpenTelemetryMetricsResource resource;
+  private final Supplier<Stopwatch> stopwatchSupplier;
+  private final boolean localityEnabled;
+  private final boolean backendServiceEnabled;
+  private final ImmutableList<OpenTelemetryPlugin> plugins;
+  @Nullable
+  private final TargetFilter targetAttributeFilter;
+
+  OpenTelemetryMetricsModule(Supplier<Stopwatch> stopwatchSupplier,
+                             OpenTelemetryMetricsResource resource,
+                             Collection<String> optionalLabels, List<OpenTelemetryPlugin> plugins) {
+    this(stopwatchSupplier, resource, optionalLabels, plugins, null);
+  }
+
+  OpenTelemetryMetricsModule(Supplier<Stopwatch> stopwatchSupplier,
+      OpenTelemetryMetricsResource resource,
+      Collection<String> optionalLabels, List<OpenTelemetryPlugin> plugins,
+      @Nullable TargetFilter targetAttributeFilter) {
+    this.resource = checkNotNull(resource, "resource");
+    this.stopwatchSupplier = checkNotNull(stopwatchSupplier, "stopwatchSupplier");
+    this.localityEnabled = optionalLabels.contains(LOCALITY_KEY.getKey());
+    this.backendServiceEnabled = optionalLabels.contains(BACKEND_SERVICE_KEY.getKey());
+    this.plugins = ImmutableList.copyOf(plugins);
+    this.targetAttributeFilter = targetAttributeFilter;
+  }
+
+  @VisibleForTesting
+  TargetFilter getTargetAttributeFilter() {
+    return targetAttributeFilter;
+  }
+
+  /**
+   * Returns the server tracer factory.
+   */
+  ServerStreamTracer.Factory getServerTracerFactory() {
+    return new ServerTracerFactory();
+  }
+
+  /**
+   * Returns the client interceptor that facilitates OpenTelemetry metrics reporting.
+   */
+  ClientInterceptor getClientInterceptor(String target) {
+    ImmutableList.Builder<OpenTelemetryPlugin> pluginBuilder =
+        ImmutableList.builderWithExpectedSize(plugins.size());
+    for (OpenTelemetryPlugin plugin : plugins) {
+      if (plugin.enablePluginForChannel(target)) {
+        pluginBuilder.add(plugin);
+      }
+    }
+    String filteredTarget = recordTarget(target);
+    return new MetricsClientInterceptor(filteredTarget, pluginBuilder.build());
+  }
+
+  String recordTarget(String target) {
+    if (targetAttributeFilter == null || target == null) {
+      return target;
+    }
+    return targetAttributeFilter.test(target) ? target : "other";
+  }
+
+  static String recordMethodName(String fullMethodName, boolean isGeneratedMethod) {
+    return isGeneratedMethod ? fullMethodName : "other";
+  }
+
+  private static Context otelContextWithBaggage() {
+    Baggage baggage = BAGGAGE_KEY.get();
+    if (baggage == null) {
+      return Context.current();
+    }
+    return Context.current().with(baggage);
+  }
+
+  private static final class ClientTracer extends ClientStreamTracer {
+    @Nullable private static final AtomicLongFieldUpdater<ClientTracer> outboundWireSizeUpdater;
+    @Nullable private static final AtomicLongFieldUpdater<ClientTracer> inboundWireSizeUpdater;
+
+    /*
+     * When using Atomic*FieldUpdater, some Samsung Android 5.0.x devices encounter a bug in their
+     * JDK reflection API that triggers a NoSuchFieldException. When this occurs, we fall back to
+     * (potentially racy) direct updates of the volatile variables.
+     */
+    static {
+      AtomicLongFieldUpdater<ClientTracer> tmpOutboundWireSizeUpdater;
+      AtomicLongFieldUpdater<ClientTracer> tmpInboundWireSizeUpdater;
+      try {
+        tmpOutboundWireSizeUpdater =
+            AtomicLongFieldUpdater.newUpdater(ClientTracer.class, "outboundWireSize");
+        tmpInboundWireSizeUpdater =
+            AtomicLongFieldUpdater.newUpdater(ClientTracer.class, "inboundWireSize");
+      } catch (Throwable t) {
+        logger.log(Level.SEVERE, "Creating atomic field updaters failed", t);
+        tmpOutboundWireSizeUpdater = null;
+        tmpInboundWireSizeUpdater = null;
+      }
+      outboundWireSizeUpdater = tmpOutboundWireSizeUpdater;
+      inboundWireSizeUpdater = tmpInboundWireSizeUpdater;
+    }
+
+    final Stopwatch stopwatch;
+    final CallAttemptsTracerFactory attemptsState;
+    final OpenTelemetryMetricsModule module;
+    final StreamInfo info;
+    final String target;
+    final String fullMethodName;
+    final List<OpenTelemetryPlugin.ClientStreamPlugin> streamPlugins;
+    volatile long outboundWireSize;
+    volatile long inboundWireSize;
+    volatile String locality;
+    volatile String backendService;
+    long attemptNanos;
+    Code statusCode;
+
+    ClientTracer(CallAttemptsTracerFactory attemptsState, OpenTelemetryMetricsModule module,
+        StreamInfo info, String target, String fullMethodName,
+        List<OpenTelemetryPlugin.ClientStreamPlugin> streamPlugins) {
+      this.attemptsState = attemptsState;
+      this.module = module;
+      this.info = info;
+      this.target = target;
+      this.fullMethodName = fullMethodName;
+      this.streamPlugins = streamPlugins;
+      this.stopwatch = module.stopwatchSupplier.get().start();
+    }
+
+    @Override
+    public void inboundHeaders(Metadata headers) {
+      for (OpenTelemetryPlugin.ClientStreamPlugin plugin : streamPlugins) {
+        plugin.inboundHeaders(headers);
+      }
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void outboundWireSize(long bytes) {
+      if (outboundWireSizeUpdater != null) {
+        outboundWireSizeUpdater.getAndAdd(this, bytes);
+      } else {
+        outboundWireSize += bytes;
+      }
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void inboundWireSize(long bytes) {
+      if (inboundWireSizeUpdater != null) {
+        inboundWireSizeUpdater.getAndAdd(this, bytes);
+      } else {
+        inboundWireSize += bytes;
+      }
+    }
+
+    @Override
+    public void addOptionalLabel(String key, String value) {
+      if ("grpc.lb.locality".equals(key)) {
+        locality = value;
+      }
+      if ("grpc.lb.backend_service".equals(key)) {
+        backendService = value;
+      }
+    }
+
+    @Override
+    public void inboundTrailers(Metadata trailers) {
+      for (OpenTelemetryPlugin.ClientStreamPlugin plugin : streamPlugins) {
+        plugin.inboundTrailers(trailers);
+      }
+    }
+
+    @Override
+    public void streamClosed(Status status) {
+      stopwatch.stop();
+      attemptNanos = stopwatch.elapsed(TimeUnit.NANOSECONDS);
+      Deadline deadline = info.getCallOptions().getDeadline();
+      statusCode = status.getCode();
+      if (statusCode == Code.CANCELLED && deadline != null) {
+        // When the server's deadline expires, it can only reset the stream with CANCEL and no
+        // description. Since our timer may be delayed in firing, we double-check the deadline and
+        // turn the failure into the likely more helpful DEADLINE_EXCEEDED status.
+        if (deadline.isExpired()) {
+          statusCode = Code.DEADLINE_EXCEEDED;
+        }
+      }
+      attemptsState.attemptEnded();
+      recordFinishedAttempt();
+    }
+
+    void recordFinishedAttempt() {
+      Context otelContext = otelContextWithBaggage();
+      AttributesBuilder builder = io.opentelemetry.api.common.Attributes.builder()
+          .put(METHOD_KEY, fullMethodName)
+          .put(TARGET_KEY, target)
+          .put(STATUS_KEY, statusCode.toString());
+      if (module.localityEnabled) {
+        String savedLocality = locality;
+        if (savedLocality == null) {
+          savedLocality = "";
+        }
+        builder.put(LOCALITY_KEY, savedLocality);
+      }
+      if (module.backendServiceEnabled) {
+        String savedBackendService = backendService;
+        if (savedBackendService == null) {
+          savedBackendService = "";
+        }
+        builder.put(BACKEND_SERVICE_KEY, savedBackendService);
+      }
+      for (OpenTelemetryPlugin.ClientStreamPlugin plugin : streamPlugins) {
+        plugin.addLabels(builder);
+      }
+      io.opentelemetry.api.common.Attributes attribute = builder.build();
+
+      if (module.resource.clientAttemptDurationCounter() != null ) {
+        module.resource.clientAttemptDurationCounter()
+            .record(attemptNanos * SECONDS_PER_NANO, attribute, otelContext);
+      }
+      if (module.resource.clientTotalSentCompressedMessageSizeCounter() != null) {
+        module.resource.clientTotalSentCompressedMessageSizeCounter()
+            .record(outboundWireSize, attribute, otelContext);
+      }
+      if (module.resource.clientTotalReceivedCompressedMessageSizeCounter() != null) {
+        module.resource.clientTotalReceivedCompressedMessageSizeCounter()
+            .record(inboundWireSize, attribute, otelContext);
+      }
+    }
+  }
+
+  @VisibleForTesting
+  static final class CallAttemptsTracerFactory extends ClientStreamTracer.Factory {
+    private final OpenTelemetryMetricsModule module;
+    private final String target;
+    private final Stopwatch attemptDelayStopwatch;
+    private final Stopwatch callStopWatch;
+    @GuardedBy("lock")
+    private boolean callEnded;
+    private final String fullMethodName;
+    private final List<OpenTelemetryPlugin.ClientCallPlugin> callPlugins;
+    private Status status;
+    private long retryDelayNanos;
+    private long callLatencyNanos;
+    private final Object lock = new Object();
+    private final AtomicLong attemptsPerCall = new AtomicLong();
+    private final AtomicLong hedgedAttemptsPerCall = new AtomicLong();
+    private final AtomicLong transparentRetriesPerCall = new AtomicLong();
+    @GuardedBy("lock")
+    private int activeStreams;
+    @GuardedBy("lock")
+    private boolean finishedCallToBeRecorded;
+
+    CallAttemptsTracerFactory(
+        OpenTelemetryMetricsModule module,
+        String target,
+        String fullMethodName,
+        List<OpenTelemetryPlugin.ClientCallPlugin> callPlugins) {
+      this.module = checkNotNull(module, "module");
+      this.target = checkNotNull(target, "target");
+      this.fullMethodName = checkNotNull(fullMethodName, "fullMethodName");
+      this.callPlugins = checkNotNull(callPlugins, "callPlugins");
+      this.attemptDelayStopwatch = module.stopwatchSupplier.get();
+      this.callStopWatch = module.stopwatchSupplier.get().start();
+
+      io.opentelemetry.api.common.Attributes attribute = io.opentelemetry.api.common.Attributes.of(
+          METHOD_KEY, fullMethodName,
+          TARGET_KEY, target);
+
+      // Record here in case mewClientStreamTracer() would never be called.
+      if (module.resource.clientAttemptCountCounter() != null) {
+        module.resource.clientAttemptCountCounter().add(1, attribute);
+      }
+    }
+
+    @Override
+    public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata metadata) {
+      synchronized (lock) {
+        if (finishedCallToBeRecorded) {
+          // This can be the case when the call is cancelled but a retry attempt is created.
+          return new ClientStreamTracer() {};
+        }
+        if (++activeStreams == 1 && attemptDelayStopwatch.isRunning()) {
+          attemptDelayStopwatch.stop();
+          retryDelayNanos = attemptDelayStopwatch.elapsed(TimeUnit.NANOSECONDS);
+        }
+      }
+      // Skip recording for the first time, since it is already recorded in
+      // CallAttemptsTracerFactory constructor. attemptsPerCall will be non-zero after the first
+      // attempt, as first attempt cannot be a transparent retry.
+      if (attemptsPerCall.get() > 0) {
+        io.opentelemetry.api.common.Attributes attribute =
+            io.opentelemetry.api.common.Attributes.of(METHOD_KEY, fullMethodName,
+                TARGET_KEY, target);
+        if (module.resource.clientAttemptCountCounter() != null) {
+          module.resource.clientAttemptCountCounter().add(1, attribute);
+        }
+      }
+      if (info.isTransparentRetry()) {
+        transparentRetriesPerCall.incrementAndGet();
+      } else if (info.isHedging()) {
+        hedgedAttemptsPerCall.incrementAndGet();
+      } else {
+        attemptsPerCall.incrementAndGet();
+      }
+      return newClientTracer(info);
+    }
+
+    private ClientTracer newClientTracer(StreamInfo info) {
+      List<OpenTelemetryPlugin.ClientStreamPlugin> streamPlugins = Collections.emptyList();
+      if (!callPlugins.isEmpty()) {
+        streamPlugins = new ArrayList<>(callPlugins.size());
+        for (OpenTelemetryPlugin.ClientCallPlugin plugin : callPlugins) {
+          streamPlugins.add(plugin.newClientStreamPlugin());
+        }
+        streamPlugins = Collections.unmodifiableList(streamPlugins);
+      }
+      return new ClientTracer(this, module, info, target, fullMethodName, streamPlugins);
+    }
+
+    // Called whenever each attempt is ended.
+    void attemptEnded() {
+      boolean shouldRecordFinishedCall = false;
+      synchronized (lock) {
+        if (--activeStreams == 0) {
+          attemptDelayStopwatch.start();
+          if (callEnded && !finishedCallToBeRecorded) {
+            shouldRecordFinishedCall = true;
+            finishedCallToBeRecorded = true;
+          }
+        }
+      }
+      if (shouldRecordFinishedCall) {
+        recordFinishedCall();
+      }
+    }
+
+    void callEnded(Status status) {
+      callStopWatch.stop();
+      this.status = status;
+      boolean shouldRecordFinishedCall = false;
+      synchronized (lock) {
+        if (callEnded) {
+          // TODO(https://github.com/grpc/grpc-java/issues/7921): this shouldn't happen
+          return;
+        }
+        callEnded = true;
+        if (activeStreams == 0 && !finishedCallToBeRecorded) {
+          shouldRecordFinishedCall = true;
+          finishedCallToBeRecorded = true;
+        }
+      }
+      if (shouldRecordFinishedCall) {
+        recordFinishedCall();
+      }
+    }
+
+    void recordFinishedCall() {
+      Context otelContext = otelContextWithBaggage();
+      if (attemptsPerCall.get() == 0) {
+        ClientTracer tracer = newClientTracer(null);
+        tracer.attemptNanos = attemptDelayStopwatch.elapsed(TimeUnit.NANOSECONDS);
+        tracer.statusCode = status.getCode();
+        tracer.recordFinishedAttempt();
+      }
+      callLatencyNanos = callStopWatch.elapsed(TimeUnit.NANOSECONDS);
+
+      // Base attributes
+      io.opentelemetry.api.common.Attributes baseAttributes =
+          io.opentelemetry.api.common.Attributes.of(
+              METHOD_KEY, fullMethodName,
+              TARGET_KEY, target
+          );
+
+      // Duration
+      if (module.resource.clientCallDurationCounter() != null) {
+        module.resource.clientCallDurationCounter().record(
+            callLatencyNanos * SECONDS_PER_NANO,
+            baseAttributes.toBuilder()
+                .put(STATUS_KEY, status.getCode().toString())
+                .build(),
+            otelContext
+        );
+      }
+
+      // Retry counts
+      if (module.resource.clientCallRetriesCounter() != null) {
+        long retriesPerCall = Math.max(attemptsPerCall.get() - 1, 0);
+        if (retriesPerCall > 0) {
+          module.resource.clientCallRetriesCounter()
+              .record(retriesPerCall, baseAttributes, otelContext);
+        }
+      }
+
+      // Hedge counts
+      if (module.resource.clientCallHedgesCounter() != null) {
+        long hedges = hedgedAttemptsPerCall.get();
+        if (hedges > 0) {
+          module.resource.clientCallHedgesCounter()
+              .record(hedges, baseAttributes, otelContext);
+        }
+      }
+
+      // Transparent Retry counts
+      if (module.resource.clientCallTransparentRetriesCounter() != null) {
+        long transparentRetries = transparentRetriesPerCall.get();
+        if (transparentRetries > 0) {
+          module.resource.clientCallTransparentRetriesCounter()
+              .record(transparentRetries, baseAttributes, otelContext);
+        }
+      }
+
+      // Retry delay
+      if (module.resource.clientCallRetryDelayCounter() != null) {
+        module.resource.clientCallRetryDelayCounter().record(
+            retryDelayNanos * SECONDS_PER_NANO,
+            baseAttributes,
+            otelContext
+        );
+      }
+    }
+  }
+
+  private static final class ServerTracer extends ServerStreamTracer {
+    @Nullable private static final AtomicIntegerFieldUpdater<ServerTracer> streamClosedUpdater;
+    @Nullable private static final AtomicLongFieldUpdater<ServerTracer> outboundWireSizeUpdater;
+    @Nullable private static final AtomicLongFieldUpdater<ServerTracer> inboundWireSizeUpdater;
+
+    /*
+     * When using Atomic*FieldUpdater, some Samsung Android 5.0.x devices encounter a bug in their
+     * JDK reflection API that triggers a NoSuchFieldException. When this occurs, we fall back to
+     * (potentially racy) direct updates of the volatile variables.
+     */
+    static {
+      AtomicIntegerFieldUpdater<ServerTracer> tmpStreamClosedUpdater;
+      AtomicLongFieldUpdater<ServerTracer> tmpOutboundWireSizeUpdater;
+      AtomicLongFieldUpdater<ServerTracer> tmpInboundWireSizeUpdater;
+      try {
+        tmpStreamClosedUpdater =
+            AtomicIntegerFieldUpdater.newUpdater(ServerTracer.class, "streamClosed");
+        tmpOutboundWireSizeUpdater =
+            AtomicLongFieldUpdater.newUpdater(ServerTracer.class, "outboundWireSize");
+        tmpInboundWireSizeUpdater =
+            AtomicLongFieldUpdater.newUpdater(ServerTracer.class, "inboundWireSize");
+      } catch (Throwable t) {
+        logger.log(Level.SEVERE, "Creating atomic field updaters failed", t);
+        tmpStreamClosedUpdater = null;
+        tmpOutboundWireSizeUpdater = null;
+        tmpInboundWireSizeUpdater = null;
+      }
+      streamClosedUpdater = tmpStreamClosedUpdater;
+      outboundWireSizeUpdater = tmpOutboundWireSizeUpdater;
+      inboundWireSizeUpdater = tmpInboundWireSizeUpdater;
+    }
+
+    private final OpenTelemetryMetricsModule module;
+    private final String fullMethodName;
+    private final List<OpenTelemetryPlugin.ServerStreamPlugin> streamPlugins;
+    private volatile boolean isGeneratedMethod;
+    private volatile int streamClosed;
+    private final Stopwatch stopwatch;
+    private volatile long outboundWireSize;
+    private volatile long inboundWireSize;
+
+    ServerTracer(OpenTelemetryMetricsModule module, String fullMethodName,
+        List<OpenTelemetryPlugin.ServerStreamPlugin> streamPlugins) {
+      this.module = checkNotNull(module, "module");
+      this.fullMethodName = fullMethodName;
+      this.streamPlugins = checkNotNull(streamPlugins, "streamPlugins");
+      this.stopwatch = module.stopwatchSupplier.get().start();
+    }
+
+    @Override
+    public void serverCallStarted(ServerCallInfo<?, ?> callInfo) {
+      // Only record method name as an attribute if isSampledToLocalTracing is set to true,
+      // which is true for all generated methods. Otherwise, programmatically
+      // created methods result in high cardinality metrics.
+      boolean isSampledToLocalTracing = callInfo.getMethodDescriptor().isSampledToLocalTracing();
+      isGeneratedMethod = isSampledToLocalTracing;
+      io.opentelemetry.api.common.Attributes attribute =
+          io.opentelemetry.api.common.Attributes.of(
+              METHOD_KEY, recordMethodName(fullMethodName, isSampledToLocalTracing));
+
+      if (module.resource.serverCallCountCounter() != null) {
+        module.resource.serverCallCountCounter().add(1, attribute);
+      }
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void outboundWireSize(long bytes) {
+      if (outboundWireSizeUpdater != null) {
+        outboundWireSizeUpdater.getAndAdd(this, bytes);
+      } else {
+        outboundWireSize += bytes;
+      }
+    }
+
+    @Override
+    @SuppressWarnings("NonAtomicVolatileUpdate")
+    public void inboundWireSize(long bytes) {
+      if (inboundWireSizeUpdater != null) {
+        inboundWireSizeUpdater.getAndAdd(this, bytes);
+      } else {
+        inboundWireSize += bytes;
+      }
+    }
+
+    /**
+     * Record a finished stream and mark the current time as the end time.
+     *
+     * <p>Can be called from any thread without synchronization.  Calling it the second time or more
+     * is a no-op.
+     */
+    @Override
+    public void streamClosed(Status status) {
+      Context otelContext = otelContextWithBaggage();
+      if (streamClosedUpdater != null) {
+        if (streamClosedUpdater.getAndSet(this, 1) != 0) {
+          return;
+        }
+      } else {
+        if (streamClosed != 0) {
+          return;
+        }
+        streamClosed = 1;
+      }
+      stopwatch.stop();
+      long elapsedTimeNanos = stopwatch.elapsed(TimeUnit.NANOSECONDS);
+      AttributesBuilder builder = io.opentelemetry.api.common.Attributes.builder()
+          .put(METHOD_KEY, recordMethodName(fullMethodName, isGeneratedMethod))
+          .put(STATUS_KEY, status.getCode().toString());
+      for (OpenTelemetryPlugin.ServerStreamPlugin plugin : streamPlugins) {
+        plugin.addLabels(builder);
+      }
+      io.opentelemetry.api.common.Attributes attributes = builder.build();
+
+      if (module.resource.serverCallDurationCounter() != null) {
+        module.resource.serverCallDurationCounter()
+            .record(elapsedTimeNanos * SECONDS_PER_NANO, attributes, otelContext);
+      }
+      if (module.resource.serverTotalSentCompressedMessageSizeCounter() != null) {
+        module.resource.serverTotalSentCompressedMessageSizeCounter()
+            .record(outboundWireSize, attributes, otelContext);
+      }
+      if (module.resource.serverTotalReceivedCompressedMessageSizeCounter() != null) {
+        module.resource.serverTotalReceivedCompressedMessageSizeCounter()
+            .record(inboundWireSize, attributes, otelContext);
+      }
+    }
+  }
+
+  @VisibleForTesting
+  final class ServerTracerFactory extends ServerStreamTracer.Factory {
+    @Override
+    public ServerStreamTracer newServerStreamTracer(String fullMethodName, Metadata headers) {
+      final List<OpenTelemetryPlugin.ServerStreamPlugin> streamPlugins;
+      if (plugins.isEmpty()) {
+        streamPlugins = Collections.emptyList();
+      } else {
+        List<OpenTelemetryPlugin.ServerStreamPlugin> streamPluginsMutable =
+            new ArrayList<>(plugins.size());
+        for (OpenTelemetryPlugin plugin : plugins) {
+          streamPluginsMutable.add(plugin.newServerStreamPlugin(headers));
+        }
+        streamPlugins = Collections.unmodifiableList(streamPluginsMutable);
+      }
+      return new ServerTracer(OpenTelemetryMetricsModule.this, fullMethodName, streamPlugins);
+    }
+  }
+
+  @VisibleForTesting
+  final class MetricsClientInterceptor implements ClientInterceptor {
+    private final String target;
+    private final ImmutableList<OpenTelemetryPlugin> plugins;
+
+    MetricsClientInterceptor(String target, ImmutableList<OpenTelemetryPlugin> plugins) {
+      this.target = checkNotNull(target, "target");
+      this.plugins = checkNotNull(plugins, "plugins");
+    }
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+      final List<OpenTelemetryPlugin.ClientCallPlugin> callPlugins;
+      if (plugins.isEmpty()) {
+        callPlugins = Collections.emptyList();
+      } else {
+        List<OpenTelemetryPlugin.ClientCallPlugin> callPluginsMutable =
+            new ArrayList<>(plugins.size());
+        for (OpenTelemetryPlugin plugin : plugins) {
+          callPluginsMutable.add(plugin.newClientCallPlugin());
+        }
+        callPlugins = Collections.unmodifiableList(callPluginsMutable);
+        for (OpenTelemetryPlugin.ClientCallPlugin plugin : callPlugins) {
+          callOptions = plugin.filterCallOptions(callOptions);
+        }
+      }
+      // Only record method name as an attribute if isSampledToLocalTracing is set to true,
+      // which is true for all generated methods. Otherwise, programatically
+      // created methods result in high cardinality metrics.
+      final CallAttemptsTracerFactory tracerFactory = new CallAttemptsTracerFactory(
+          OpenTelemetryMetricsModule.this, target,
+          recordMethodName(method.getFullMethodName(), method.isSampledToLocalTracing()),
+          callPlugins);
+      ClientCall<ReqT, RespT> call =
+          next.newCall(method, callOptions.withStreamTracerFactory(tracerFactory));
+      return new SimpleForwardingClientCall<ReqT, RespT>(call) {
+        @Override
+        public void start(Listener<RespT> responseListener, Metadata headers) {
+          for (OpenTelemetryPlugin.ClientCallPlugin plugin : callPlugins) {
+            plugin.addMetadata(headers);
+          }
+          delegate().start(
+              new SimpleForwardingClientCallListener<RespT>(responseListener) {
+                @Override
+                public void onClose(Status status, Metadata trailers) {
+                  tracerFactory.callEnded(status);
+                  super.onClose(status, trailers);
+                }
+              },
+              headers);
+        }
+      };
+    }
+  }
+}
diff --git a/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryMetricsResource.java b/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryMetricsResource.java
new file mode 100644
index 00000000000..d32ae1e67f5
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryMetricsResource.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2023 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.opentelemetry;
+
+import com.google.auto.value.AutoValue;
+import io.opentelemetry.api.metrics.DoubleHistogram;
+import io.opentelemetry.api.metrics.LongCounter;
+import io.opentelemetry.api.metrics.LongHistogram;
+import javax.annotation.Nullable;
+
+@AutoValue
+abstract class OpenTelemetryMetricsResource {
+
+  /* Client Metrics */
+  @Nullable
+  abstract DoubleHistogram clientCallDurationCounter();
+
+  @Nullable
+  abstract LongCounter clientAttemptCountCounter();
+
+  @Nullable
+  abstract DoubleHistogram clientAttemptDurationCounter();
+
+  @Nullable
+  abstract LongHistogram clientTotalSentCompressedMessageSizeCounter();
+
+  @Nullable
+  abstract LongHistogram clientTotalReceivedCompressedMessageSizeCounter();
+
+  @Nullable
+  abstract LongHistogram clientCallRetriesCounter();
+
+  @Nullable
+  abstract LongHistogram clientCallTransparentRetriesCounter();
+
+  @Nullable
+  abstract LongHistogram clientCallHedgesCounter();
+
+  @Nullable
+  abstract DoubleHistogram clientCallRetryDelayCounter();
+
+  /* Server Metrics */
+  @Nullable
+  abstract LongCounter serverCallCountCounter();
+
+  @Nullable
+  abstract DoubleHistogram serverCallDurationCounter();
+
+  @Nullable
+  abstract LongHistogram serverTotalSentCompressedMessageSizeCounter();
+
+  @Nullable
+  abstract LongHistogram serverTotalReceivedCompressedMessageSizeCounter();
+
+  static Builder builder() {
+    return new AutoValue_OpenTelemetryMetricsResource.Builder();
+  }
+
+  @AutoValue.Builder
+  abstract static class Builder {
+
+    abstract Builder clientCallDurationCounter(DoubleHistogram counter);
+
+    abstract Builder clientAttemptCountCounter(LongCounter counter);
+
+    abstract Builder clientAttemptDurationCounter(DoubleHistogram counter);
+
+    abstract Builder clientTotalSentCompressedMessageSizeCounter(LongHistogram counter);
+
+    abstract Builder clientTotalReceivedCompressedMessageSizeCounter(
+        LongHistogram counter);
+
+    abstract Builder clientCallRetriesCounter(LongHistogram counter);
+
+    abstract Builder clientCallTransparentRetriesCounter(LongHistogram counter);
+
+    abstract Builder clientCallHedgesCounter(LongHistogram counter);
+
+    abstract Builder clientCallRetryDelayCounter(DoubleHistogram counter);
+
+    abstract Builder serverCallCountCounter(LongCounter counter);
+
+    abstract Builder serverCallDurationCounter(DoubleHistogram counter);
+
+    abstract Builder serverTotalSentCompressedMessageSizeCounter(LongHistogram counter);
+
+    abstract Builder serverTotalReceivedCompressedMessageSizeCounter(
+        LongHistogram counter);
+
+    abstract OpenTelemetryMetricsResource build();
+  }
+}
diff --git a/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryPlugin.java b/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryPlugin.java
new file mode 100644
index 00000000000..3705b4b65e1
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryPlugin.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+import io.grpc.CallOptions;
+import io.grpc.Metadata;
+import io.opentelemetry.api.common.AttributesBuilder;
+
+/**
+ * Injects behavior into {@link GrpcOpenTelemetry}.
+ */
+interface OpenTelemetryPlugin {
+  /**
+   * Limited ability to disable the plugin based on the target. This only has an effect for
+   * per-call metrics.
+   *
+   * <p>Ideally this method wouldn't exist and it'd be handled by wrapping GrpcOpenTelemetry and
+   * conditionally delegating to it. But this is needed by CSM until ChannelBuilders have a
+   * consistent target over their life; currently specifying nameResolverFactory can change the
+   * target's scheme.
+   */
+  default boolean enablePluginForChannel(String target) {
+    return true;
+  }
+
+  ClientCallPlugin newClientCallPlugin();
+
+  ServerStreamPlugin newServerStreamPlugin(Metadata inboundMetadata);
+
+  interface ClientCallPlugin {
+    ClientStreamPlugin newClientStreamPlugin();
+
+    default void addMetadata(Metadata toMetadata) {}
+
+    default CallOptions filterCallOptions(CallOptions options) {
+      return options;
+    }
+  }
+
+  interface ClientStreamPlugin {
+    default void inboundHeaders(Metadata headers) {}
+
+    default void inboundTrailers(Metadata trailers) {}
+
+    default void addLabels(AttributesBuilder to) {}
+  }
+
+  interface ServerStreamPlugin {
+    default void addLabels(AttributesBuilder to) {}
+  }
+}
diff --git a/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryTracingModule.java b/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryTracingModule.java
new file mode 100644
index 00000000000..d214e99bd75
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/OpenTelemetryTracingModule.java
@@ -0,0 +1,505 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.ClientStreamTracer.NAME_RESOLUTION_DELAYED;
+import static io.grpc.internal.GrpcUtil.IMPLEMENTATION_VERSION;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.BAGGAGE_KEY;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
+import io.grpc.ForwardingServerCallListener;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.opentelemetry.internal.OpenTelemetryConstants;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.baggage.Baggage;
+import io.opentelemetry.api.common.AttributesBuilder;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.api.trace.Tracer;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.Scope;
+import io.opentelemetry.context.propagation.ContextPropagators;
+import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * Provides factories for {@link io.grpc.StreamTracer} that records tracing to OpenTelemetry.
+ */
+final class OpenTelemetryTracingModule {
+  private static final Logger logger = Logger.getLogger(OpenTelemetryTracingModule.class.getName());
+
+  @VisibleForTesting
+  final io.grpc.Context.Key<Span> otelSpan = io.grpc.Context.key("opentelemetry-span-key");
+
+  @Nullable
+  private static final AtomicIntegerFieldUpdater<CallAttemptsTracerFactory> callEndedUpdater;
+  @Nullable
+  private static final AtomicIntegerFieldUpdater<ServerTracer> streamClosedUpdater;
+
+  /*
+   * When using Atomic*FieldUpdater, some Samsung Android 5.0.x devices encounter a bug in their JDK
+   * reflection API that triggers a NoSuchFieldException. When this occurs, we fallback to
+   * (potentially racy) direct updates of the volatile variables.
+   */
+  static {
+    AtomicIntegerFieldUpdater<CallAttemptsTracerFactory> tmpCallEndedUpdater;
+    AtomicIntegerFieldUpdater<ServerTracer> tmpStreamClosedUpdater;
+    try {
+      tmpCallEndedUpdater =
+          AtomicIntegerFieldUpdater.newUpdater(CallAttemptsTracerFactory.class, "callEnded");
+      tmpStreamClosedUpdater =
+          AtomicIntegerFieldUpdater.newUpdater(ServerTracer.class, "streamClosed");
+    } catch (Throwable t) {
+      logger.log(Level.SEVERE, "Creating atomic field updaters failed", t);
+      tmpCallEndedUpdater = null;
+      tmpStreamClosedUpdater = null;
+    }
+    callEndedUpdater = tmpCallEndedUpdater;
+    streamClosedUpdater = tmpStreamClosedUpdater;
+  }
+
+  private final Tracer otelTracer;
+  private final ContextPropagators contextPropagators;
+  private final MetadataGetter metadataGetter = MetadataGetter.getInstance();
+  private final MetadataSetter metadataSetter = MetadataSetter.getInstance();
+  private final TracingClientInterceptor clientInterceptor = new TracingClientInterceptor();
+  private final ServerInterceptor serverSpanPropagationInterceptor =
+      new TracingServerSpanPropagationInterceptor();
+  private final ServerTracerFactory serverTracerFactory = new ServerTracerFactory();
+
+  OpenTelemetryTracingModule(OpenTelemetry openTelemetry) {
+    this.otelTracer = checkNotNull(openTelemetry.getTracerProvider(), "tracerProvider")
+        .tracerBuilder(OpenTelemetryConstants.INSTRUMENTATION_SCOPE)
+        .setInstrumentationVersion(IMPLEMENTATION_VERSION)
+        .build();
+    this.contextPropagators = checkNotNull(openTelemetry.getPropagators(), "contextPropagators");
+  }
+
+  @VisibleForTesting
+  Tracer getTracer() {
+    return otelTracer;
+  }
+
+  /**
+   * Creates a {@link CallAttemptsTracerFactory} for a new call.
+   */
+  @VisibleForTesting
+  CallAttemptsTracerFactory newClientCallTracer(Span clientSpan, MethodDescriptor<?, ?> method) {
+    return new CallAttemptsTracerFactory(clientSpan, method);
+  }
+
+  /**
+   * Returns the server tracer factory.
+   */
+  ServerStreamTracer.Factory getServerTracerFactory() {
+    return serverTracerFactory;
+  }
+
+  /**
+   * Returns the client interceptor that facilitates otel tracing reporting.
+   */
+  ClientInterceptor getClientInterceptor() {
+    return clientInterceptor;
+  }
+
+  ServerInterceptor getServerSpanPropagationInterceptor() {
+    return serverSpanPropagationInterceptor;
+  }
+
+  @VisibleForTesting
+  final class CallAttemptsTracerFactory extends ClientStreamTracer.Factory {
+    volatile int callEnded;
+    private final Span clientSpan;
+    private final String fullMethodName;
+
+    CallAttemptsTracerFactory(Span clientSpan, MethodDescriptor<?, ?> method) {
+      checkNotNull(method, "method");
+      this.fullMethodName = checkNotNull(method.getFullMethodName(), "fullMethodName");
+      this.clientSpan = checkNotNull(clientSpan, "clientSpan");
+    }
+
+    @Override
+    public ClientStreamTracer newClientStreamTracer(
+        ClientStreamTracer.StreamInfo info, Metadata headers) {
+      Span attemptSpan = otelTracer.spanBuilder(
+              "Attempt." + fullMethodName.replace('/', '.'))
+          .setParent(Context.current().with(clientSpan))
+          .startSpan();
+      attemptSpan.setAttribute(
+          "previous-rpc-attempts", info.getPreviousAttempts());
+      attemptSpan.setAttribute(
+          "transparent-retry",info.isTransparentRetry());
+      if (info.getCallOptions().getOption(NAME_RESOLUTION_DELAYED) != null) {
+        clientSpan.addEvent("Delayed name resolution complete");
+      }
+      return new ClientTracer(attemptSpan, clientSpan);
+    }
+
+    /**
+     * Record a finished call and mark the current time as the end time.
+     *
+     * <p>Can be called from any thread without synchronization.  Calling it the second time or more
+     * is a no-op.
+     */
+    void callEnded(io.grpc.Status status) {
+      if (callEndedUpdater != null) {
+        if (callEndedUpdater.getAndSet(this, 1) != 0) {
+          return;
+        }
+      } else {
+        if (callEnded != 0) {
+          return;
+        }
+        callEnded = 1;
+      }
+      endSpanWithStatus(clientSpan, status);
+    }
+  }
+
+  private final class ClientTracer extends ClientStreamTracer {
+    private final Span span;
+    private final Span parentSpan;
+    volatile int seqNo;
+    boolean isPendingStream;
+
+    ClientTracer(Span span, Span parentSpan) {
+      this.span = checkNotNull(span, "span");
+      this.parentSpan = checkNotNull(parentSpan, "parent span");
+    }
+
+    @Override
+    public void streamCreated(Attributes transportAtts, Metadata headers) {
+      contextPropagators.getTextMapPropagator().inject(Context.current().with(span), headers,
+          metadataSetter);
+      if (isPendingStream) {
+        span.addEvent("Delayed LB pick complete");
+      }
+    }
+
+    @Override
+    public void createPendingStream() {
+      isPendingStream = true;
+    }
+
+    @Override
+    public void outboundMessageSent(
+        int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+      recordOutboundMessageSentEvent(span, seqNo, optionalWireSize, optionalUncompressedSize);
+    }
+
+    @Override
+    public void inboundMessageRead(
+        int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+      if (optionalWireSize != optionalUncompressedSize) {
+        recordInboundCompressedMessage(span, seqNo, optionalWireSize);
+      }
+    }
+
+    @Override
+    public void inboundMessage(int seqNo) {
+      this.seqNo = seqNo;
+    }
+
+    @Override
+    public void inboundUncompressedSize(long bytes) {
+      recordInboundMessageSize(parentSpan, seqNo, bytes);
+    }
+
+    @Override
+    public void streamClosed(io.grpc.Status status) {
+      endSpanWithStatus(span, status);
+    }
+  }
+
+  private final class ServerTracer extends ServerStreamTracer {
+    private final Span span;
+    volatile int streamClosed;
+    private int seqNo;
+    private Baggage baggage;
+
+    ServerTracer(String fullMethodName, @Nullable Span remoteSpan, Baggage baggage) {
+      checkNotNull(fullMethodName, "fullMethodName");
+      this.span =
+          otelTracer.spanBuilder(generateTraceSpanName(true, fullMethodName))
+              .setParent(remoteSpan == null ? null : Context.current().with(remoteSpan))
+              .startSpan();
+      this.baggage = baggage;
+    }
+
+    /**
+     * Record a finished stream and mark the current time as the end time.
+     *
+     * <p>Can be called from any thread without synchronization.  Calling it the second time or more
+     * is a no-op.
+     */
+    @Override
+    public void streamClosed(io.grpc.Status status) {
+      if (streamClosedUpdater != null) {
+        if (streamClosedUpdater.getAndSet(this, 1) != 0) {
+          return;
+        }
+      } else {
+        if (streamClosed != 0) {
+          return;
+        }
+        streamClosed = 1;
+      }
+      endSpanWithStatus(span, status);
+    }
+
+    @Override
+    public io.grpc.Context filterContext(io.grpc.Context context) {
+      return context
+          .withValue(otelSpan, span)
+          .withValue(BAGGAGE_KEY, baggage);
+    }
+
+    @Override
+    public void outboundMessageSent(
+        int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+      recordOutboundMessageSentEvent(span, seqNo, optionalWireSize, optionalUncompressedSize);
+    }
+
+    @Override
+    public void inboundMessageRead(
+        int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+      if (optionalWireSize != optionalUncompressedSize) {
+        recordInboundCompressedMessage(span, seqNo, optionalWireSize);
+      }
+    }
+
+    @Override
+    public void inboundMessage(int seqNo) {
+      this.seqNo = seqNo;
+    }
+
+    @Override
+    public void inboundUncompressedSize(long bytes) {
+      recordInboundMessageSize(span, seqNo, bytes);
+    }
+  }
+
+  @VisibleForTesting
+  final class ServerTracerFactory extends ServerStreamTracer.Factory {
+    @SuppressWarnings("ReferenceEquality")
+    @Override
+    public ServerStreamTracer newServerStreamTracer(String fullMethodName, Metadata headers) {
+      Context context = contextPropagators.getTextMapPropagator().extract(
+          Context.current(), headers, metadataGetter
+      );
+      Span remoteSpan = Span.fromContext(context);
+      if (remoteSpan == Span.getInvalid()) {
+        remoteSpan = null;
+      }
+      Baggage baggage = Baggage.fromContext(context);
+      return new ServerTracer(fullMethodName, remoteSpan, baggage);
+    }
+  }
+
+  @VisibleForTesting
+  final class TracingServerSpanPropagationInterceptor implements ServerInterceptor {
+    @Override
+    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+        Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+      Span span = otelSpan.get(io.grpc.Context.current());
+      if (span == null) {
+        logger.log(Level.FINE, "Server span not found. ServerTracerFactory for server "
+            + "tracing must be set.");
+        return next.startCall(call, headers);
+      }
+      Context serverCallContext = Context.current();
+      serverCallContext = serverCallContext.with(span);
+      Baggage baggage = BAGGAGE_KEY.get();
+      if (baggage != null) {
+        serverCallContext = serverCallContext.with(baggage);
+      } else {
+        logger.log(Level.WARNING, "Server baggage not found which is unexpected, "
+            + "as it is being added unconditionally in filterContext().");
+      }
+      try (Scope scope = serverCallContext.makeCurrent()) {
+        return new ContextServerCallListener<>(next.startCall(call, headers), serverCallContext);
+      }
+    }
+  }
+
+  private static class ContextServerCallListener<ReqT> extends
+      ForwardingServerCallListener.SimpleForwardingServerCallListener<ReqT> {
+    private final Context context;
+
+    protected ContextServerCallListener(ServerCall.Listener<ReqT> delegate, Context context) {
+      super(delegate);
+      this.context = checkNotNull(context, "context");
+    }
+
+    @Override
+    public void onMessage(ReqT message) {
+      try (Scope scope = context.makeCurrent()) {
+        delegate().onMessage(message);
+      }
+    }
+
+    @Override
+    public void onHalfClose() {
+      try (Scope scope = context.makeCurrent()) {
+        delegate().onHalfClose();
+      }
+    }
+
+    @Override
+    public void onCancel() {
+      try (Scope scope = context.makeCurrent()) {
+        delegate().onCancel();
+      }
+    }
+
+    @Override
+    public void onComplete() {
+      try (Scope scope = context.makeCurrent()) {
+        delegate().onComplete();
+      }
+    }
+
+    @Override
+    public void onReady() {
+      try (Scope scope = context.makeCurrent()) {
+        delegate().onReady();
+      }
+    }
+  }
+
+  @VisibleForTesting
+  final class TracingClientInterceptor implements ClientInterceptor {
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+      Span clientSpan = otelTracer.spanBuilder(
+          generateTraceSpanName(false, method.getFullMethodName()))
+          .startSpan();
+
+      final CallAttemptsTracerFactory tracerFactory = newClientCallTracer(clientSpan, method);
+      ClientCall<ReqT, RespT> call =
+          next.newCall(
+              method,
+              callOptions.withStreamTracerFactory(tracerFactory));
+      return new SimpleForwardingClientCall<ReqT, RespT>(call) {
+        @Override
+        public void start(Listener<RespT> responseListener, Metadata headers) {
+          delegate().start(
+              new SimpleForwardingClientCallListener<RespT>(responseListener) {
+                @Override
+                public void onClose(io.grpc.Status status, Metadata trailers) {
+                  tracerFactory.callEnded(status);
+                  super.onClose(status, trailers);
+                }
+              },
+              headers);
+        }
+      };
+    }
+  }
+
+  // Attribute named "message-size" always means the message size the application sees.
+  // If there was compression, additional event reports "message-size-compressed".
+  //
+  // An example trace with message compression:
+  //
+  // Sending:
+  // |-- Event 'Outbound message sent', attributes('sequence-numer' = 0, 'message-size' = 7854,
+  //                                               'message-size-compressed' = 5493) ----|
+  //
+  // Receiving:
+  // |-- Event 'Inbound compressed message', attributes('sequence-numer' = 0,
+  //                                                    'message-size-compressed' = 5493 ) ----|
+  // |-- Event 'Inbound message received', attributes('sequence-numer' = 0,
+  //                                                  'message-size' = 7854) ----|
+  //
+  // An example trace with no message compression:
+  //
+  // Sending:
+  // |-- Event 'Outbound message sent', attributes('sequence-numer' = 0, 'message-size' = 7854) ---|
+  //
+  // Receiving:
+  // |-- Event 'Inbound message received', attributes('sequence-numer' = 0,
+  //                                                  'message-size' = 7854) ----|
+  private void recordOutboundMessageSentEvent(Span span,
+      int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+    AttributesBuilder attributesBuilder = io.opentelemetry.api.common.Attributes.builder();
+    attributesBuilder.put("sequence-number", seqNo);
+    if (optionalUncompressedSize != -1) {
+      attributesBuilder.put("message-size", optionalUncompressedSize);
+    }
+    if (optionalWireSize != -1 && optionalWireSize != optionalUncompressedSize) {
+      attributesBuilder.put("message-size-compressed", optionalWireSize);
+    }
+    span.addEvent("Outbound message", attributesBuilder.build());
+  }
+
+  private void recordInboundCompressedMessage(Span span, int seqNo, long optionalWireSize) {
+    AttributesBuilder attributesBuilder = io.opentelemetry.api.common.Attributes.builder();
+    attributesBuilder.put("sequence-number", seqNo);
+    attributesBuilder.put("message-size-compressed", optionalWireSize);
+    span.addEvent("Inbound compressed message", attributesBuilder.build());
+  }
+
+  private void recordInboundMessageSize(Span span, int seqNo, long bytes) {
+    AttributesBuilder attributesBuilder = io.opentelemetry.api.common.Attributes.builder();
+    attributesBuilder.put("sequence-number", seqNo);
+    attributesBuilder.put("message-size", bytes);
+    span.addEvent("Inbound message", attributesBuilder.build());
+  }
+
+  private void endSpanWithStatus(Span span, io.grpc.Status status) {
+    if (status.isOk()) {
+      span.setStatus(StatusCode.OK);
+    } else {
+      span.setStatus(StatusCode.ERROR, GrpcUtil.statusToPrettyString(status));
+    }
+    span.end();
+  }
+
+  /**
+   * Convert a full method name to a tracing span name.
+   *
+   * @param isServer {@code false} if the span is on the client-side, {@code true} if on the
+   *                 server-side
+   * @param fullMethodName the method name as returned by
+   *        {@link MethodDescriptor#getFullMethodName}.
+   */
+  @VisibleForTesting
+  static String generateTraceSpanName(boolean isServer, String fullMethodName) {
+    String prefix = isServer ? "Recv" : "Sent";
+    return prefix + "." + fullMethodName.replace('/', '.');
+  }
+}
diff --git a/opentelemetry/src/main/java/io/grpc/opentelemetry/internal/OpenTelemetryConstants.java b/opentelemetry/src/main/java/io/grpc/opentelemetry/internal/OpenTelemetryConstants.java
new file mode 100644
index 00000000000..2c7123198c4
--- /dev/null
+++ b/opentelemetry/src/main/java/io/grpc/opentelemetry/internal/OpenTelemetryConstants.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2023 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.opentelemetry.internal;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import io.opentelemetry.api.baggage.Baggage;
+import io.opentelemetry.api.common.AttributeKey;
+import java.util.List;
+
+public final class OpenTelemetryConstants {
+
+  public static final String INSTRUMENTATION_SCOPE = "grpc-java";
+
+  public static final AttributeKey<String> METHOD_KEY = AttributeKey.stringKey("grpc.method");
+
+  public static final AttributeKey<String> STATUS_KEY = AttributeKey.stringKey("grpc.status");
+
+  public static final AttributeKey<String> TARGET_KEY = AttributeKey.stringKey("grpc.target");
+
+  public static final AttributeKey<String> LOCALITY_KEY =
+      AttributeKey.stringKey("grpc.lb.locality");
+
+  public static final AttributeKey<String> BACKEND_SERVICE_KEY =
+      AttributeKey.stringKey("grpc.lb.backend_service");
+
+  public static final AttributeKey<String> DISCONNECT_ERROR_KEY =
+      AttributeKey.stringKey("grpc.disconnect_error");
+
+  public static final AttributeKey<String> SECURITY_LEVEL_KEY =
+      AttributeKey.stringKey("grpc.security_level");
+
+  @VisibleForTesting
+  public static final io.grpc.Context.Key<Baggage> BAGGAGE_KEY =
+      io.grpc.Context.key("opentelemetry-baggage-key");
+
+  public static final List<Double> LATENCY_BUCKETS =
+      ImmutableList.of(
+          0d,     0.00001d, 0.00005d, 0.0001d, 0.0003d, 0.0006d, 0.0008d, 0.001d, 0.002d,
+          0.003d, 0.004d,   0.005d,   0.006d,  0.008d,  0.01d,   0.013d,  0.016d, 0.02d,
+          0.025d, 0.03d,    0.04d,    0.05d,   0.065d,  0.08d,   0.1d,    0.13d,  0.16d,
+          0.2d,   0.25d,    0.3d,     0.4d,    0.5d,    0.65d,   0.8d,    1d,     2d,
+          5d,     10d,      20d,      50d,     100d);
+
+  public static final List<Long> SIZE_BUCKETS =
+      ImmutableList.of(
+          0L, 1024L, 2048L, 4096L, 16384L, 65536L, 262144L, 1048576L, 4194304L, 16777216L,
+          67108864L, 268435456L, 1073741824L, 4294967296L);
+
+  public static final List<Long> RETRY_BUCKETS = ImmutableList.of(1L, 2L, 3L, 4L, 5L);
+
+  public static final List<Long> TRANSPARENT_RETRY_BUCKETS =
+      ImmutableList.of(1L, 2L, 3L, 4L, 5L, 10L);
+
+  public static final List<Long> HEDGE_BUCKETS = ImmutableList.of(1L, 2L, 3L, 4L, 5L);
+
+  private OpenTelemetryConstants() {
+  }
+}
diff --git a/opentelemetry/src/test/java/io/grpc/opentelemetry/GrpcOpenTelemetryTest.java b/opentelemetry/src/test/java/io/grpc/opentelemetry/GrpcOpenTelemetryTest.java
new file mode 100644
index 00000000000..16cb02c61c2
--- /dev/null
+++ b/opentelemetry/src/test/java/io/grpc/opentelemetry/GrpcOpenTelemetryTest.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright 2023 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.opentelemetry;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.ClientInterceptor;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.MetricSink;
+import io.grpc.ServerBuilder;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.opentelemetry.GrpcOpenTelemetry.TargetFilter;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.sdk.OpenTelemetrySdk;
+import io.opentelemetry.sdk.metrics.SdkMeterProvider;
+import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader;
+import io.opentelemetry.sdk.trace.SdkTracerProvider;
+import java.util.Arrays;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class GrpcOpenTelemetryTest {
+  private final InMemoryMetricReader inMemoryMetricReader = InMemoryMetricReader.create();
+  private final SdkMeterProvider meterProvider =
+      SdkMeterProvider.builder().registerMetricReader(inMemoryMetricReader).build();
+  private final SdkTracerProvider tracerProvider = SdkTracerProvider.builder().build();
+  private final OpenTelemetry noopOpenTelemetry = OpenTelemetry.noop();
+  private boolean originalEnableOtelTracing;
+
+  @Before
+  public void setup() {
+    originalEnableOtelTracing = GrpcOpenTelemetry.ENABLE_OTEL_TRACING;
+  }
+
+  @After
+  public void tearDown() {
+    GrpcOpenTelemetry.ENABLE_OTEL_TRACING = originalEnableOtelTracing;
+  }
+
+  @Test
+  public void build() {
+    OpenTelemetrySdk sdk =
+        OpenTelemetrySdk.builder().setMeterProvider(meterProvider).build();
+
+    GrpcOpenTelemetry openTelemetryModule = GrpcOpenTelemetry.newBuilder()
+        .sdk(sdk)
+        .addOptionalLabel("version")
+        .build();
+
+    assertThat(openTelemetryModule.getOpenTelemetryInstance()).isSameInstanceAs(sdk);
+    assertThat(openTelemetryModule.getMeterProvider()).isNotNull();
+    assertThat(openTelemetryModule.getMeter()).isSameInstanceAs(
+        meterProvider.meterBuilder("grpc-java")
+            .setInstrumentationVersion(GrpcUtil.IMPLEMENTATION_VERSION)
+            .build());
+    assertThat(openTelemetryModule.getOptionalLabels()).isEqualTo(ImmutableList.of("version"));
+  }
+
+  @Test
+  public void buildTracer() {
+    OpenTelemetrySdk sdk =
+        OpenTelemetrySdk.builder().setTracerProvider(tracerProvider).build();
+
+    GrpcOpenTelemetry grpcOpenTelemetry = GrpcOpenTelemetry.newBuilder()
+        .enableTracing(true)
+        .sdk(sdk).build();
+
+    assertThat(grpcOpenTelemetry.getOpenTelemetryInstance()).isSameInstanceAs(sdk);
+    assertThat(grpcOpenTelemetry.getTracer()).isSameInstanceAs(
+        tracerProvider.tracerBuilder("grpc-java")
+            .setInstrumentationVersion(GrpcUtil.IMPLEMENTATION_VERSION)
+            .build());
+    ServerBuilder<?> mockServerBuiler = mock(ServerBuilder.class);
+    grpcOpenTelemetry.configureServerBuilder(mockServerBuiler);
+    verify(mockServerBuiler, times(2)).addStreamTracerFactory(any());
+    verify(mockServerBuiler).intercept(any());
+    verifyNoMoreInteractions(mockServerBuiler);
+
+    ManagedChannelBuilder<?> mockChannelBuilder = mock(ManagedChannelBuilder.class);
+    grpcOpenTelemetry.configureChannelBuilder(mockChannelBuilder);
+    verify(mockChannelBuilder).intercept(any(ClientInterceptor.class));
+  }
+
+  @Test
+  public void builderDefaults() {
+    GrpcOpenTelemetry module = GrpcOpenTelemetry.newBuilder().build();
+
+    assertThat(module.getOpenTelemetryInstance()).isNotNull();
+    assertThat(module.getOpenTelemetryInstance()).isSameInstanceAs(noopOpenTelemetry);
+    assertThat(module.getMeterProvider()).isNotNull();
+    assertThat(module.getMeterProvider())
+        .isSameInstanceAs(noopOpenTelemetry.getMeterProvider());
+    assertThat(module.getMeter()).isSameInstanceAs(noopOpenTelemetry
+        .getMeterProvider()
+        .meterBuilder("grpc-java")
+        .setInstrumentationVersion(GrpcUtil.IMPLEMENTATION_VERSION)
+        .build());
+    assertThat(module.getEnableMetrics()).isEmpty();
+    assertThat(module.getOptionalLabels()).isEmpty();
+    assertThat(module.getSink()).isInstanceOf(MetricSink.class);
+
+    assertThat(module.getTracer()).isSameInstanceAs(noopOpenTelemetry
+        .getTracerProvider()
+        .tracerBuilder("grpc-java")
+        .setInstrumentationVersion(GrpcUtil.IMPLEMENTATION_VERSION)
+        .build()
+    );
+  }
+
+  @Test
+  public void builderTargetAttributeFilter() {
+    GrpcOpenTelemetry module = GrpcOpenTelemetry.newBuilder()
+        .targetAttributeFilter(t -> t.contains("allowed.com"))
+        .build();
+
+    TargetFilter internalFilter = module.getTargetAttributeFilter();
+
+    assertThat(internalFilter.test("allowed.com")).isTrue();
+    assertThat(internalFilter.test("example.com")).isFalse();
+  }
+
+  @Test
+  public void enableDisableMetrics() {
+    GrpcOpenTelemetry.Builder builder = GrpcOpenTelemetry.newBuilder();
+    builder.enableMetrics(Arrays.asList("metric1", "metric4"));
+    builder.disableMetrics(Arrays.asList("metric2", "metric3"));
+
+    GrpcOpenTelemetry module = builder.build();
+
+    assertThat(module.getEnableMetrics().get("metric1")).isTrue();
+    assertThat(module.getEnableMetrics().get("metric4")).isTrue();
+    assertThat(module.getEnableMetrics().get("metric2")).isFalse();
+    assertThat(module.getEnableMetrics().get("metric3")).isFalse();
+  }
+
+  @Test
+  public void disableAllMetrics() {
+    GrpcOpenTelemetry.Builder builder = GrpcOpenTelemetry.newBuilder();
+    builder.enableMetrics(Arrays.asList("metric1", "metric4"));
+    builder.disableMetrics(Arrays.asList("metric2", "metric3"));
+    builder.disableAllMetrics();
+
+    GrpcOpenTelemetry module = builder.build();
+
+    assertThat(module.getEnableMetrics()).isEmpty();
+  }
+
+  // TODO(dnvindhya): Add tests for configurator
+
+}
diff --git a/opentelemetry/src/test/java/io/grpc/opentelemetry/GrpcTraceBinContextPropagatorTest.java b/opentelemetry/src/test/java/io/grpc/opentelemetry/GrpcTraceBinContextPropagatorTest.java
new file mode 100644
index 00000000000..f85b8067c26
--- /dev/null
+++ b/opentelemetry/src/test/java/io/grpc/opentelemetry/GrpcTraceBinContextPropagatorTest.java
@@ -0,0 +1,313 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.InternalMetadata.BASE64_ENCODING_OMIT_PADDING;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.collect.ImmutableMap;
+import io.grpc.Metadata;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanContext;
+import io.opentelemetry.api.trace.TraceFlags;
+import io.opentelemetry.api.trace.TraceState;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.propagation.TextMapGetter;
+import io.opentelemetry.context.propagation.TextMapSetter;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class GrpcTraceBinContextPropagatorTest {
+  private static final String TRACE_ID_BASE16 = "e384981d65129fa3e384981d65129fa3";
+  private static final String SPAN_ID_BASE16 = "e384981d65129fa3";
+  private static final String TRACE_HEADER_SAMPLED =
+      "0000" + TRACE_ID_BASE16 + "01" + SPAN_ID_BASE16 + "0201";
+  private static final String TRACE_HEADER_NOT_SAMPLED =
+      "0000" + TRACE_ID_BASE16 + "01" + SPAN_ID_BASE16 + "0200";
+  private final String goldenHeaderEncodedSampled = encode(TRACE_HEADER_SAMPLED);
+  private final String goldenHeaderEncodedNotSampled = encode(TRACE_HEADER_NOT_SAMPLED);
+  private static final TextMapSetter<Map<String, String>> setter = Map::put;
+  private static final TextMapGetter<Map<String, String>> getter =
+      new TextMapGetter<Map<String, String>>() {
+        @Override
+        public Iterable<String> keys(Map<String, String> carrier) {
+          return carrier.keySet();
+        }
+
+        @Nullable
+        @Override
+        public String get(Map<String, String> carrier, String key) {
+          return carrier.get(key);
+        }
+      };
+  private final GrpcTraceBinContextPropagator grpcTraceBinContextPropagator =
+      GrpcTraceBinContextPropagator.defaultInstance();
+
+  private static Context withSpanContext(SpanContext spanContext, Context context) {
+    return context.with(Span.wrap(spanContext));
+  }
+
+  private static SpanContext getSpanContext(Context context) {
+    return Span.fromContext(context).getSpanContext();
+  }
+
+  @Test
+  public void inject_map_Nothing() {
+    Map<String, String> carrier = new HashMap<>();
+    grpcTraceBinContextPropagator.inject(Context.current(), carrier, setter);
+    assertThat(carrier).hasSize(0);
+  }
+
+  @Test
+  public void inject_map_invalidSpan() {
+    Map<String, String> carrier = new HashMap<>();
+    Context context = withSpanContext(SpanContext.getInvalid(), Context.current());
+    grpcTraceBinContextPropagator.inject(context, carrier, setter);
+    assertThat(carrier).isEmpty();
+  }
+
+  @Test
+  public void inject_map_nullCarrier() {
+    Map<String, String> carrier = new HashMap<>();
+    Context context =
+        withSpanContext(
+            SpanContext.create(
+                TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getSampled(), TraceState.getDefault()),
+            Context.current());
+    grpcTraceBinContextPropagator.inject(context, null,
+        (TextMapSetter<Map<String, String>>) (ignored, key, value) -> carrier.put(key, value));
+    assertThat(carrier)
+        .containsExactly(
+            GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, goldenHeaderEncodedSampled);
+  }
+
+  @Test
+  public void inject_map_nullContext() {
+    Map<String, String> carrier = new HashMap<>();
+    grpcTraceBinContextPropagator.inject(null, carrier, setter);
+    assertThat(carrier).isEmpty();
+  }
+
+  @Test
+  public void inject_map_invalidBinaryFormat() {
+    GrpcTraceBinContextPropagator propagator = new GrpcTraceBinContextPropagator(
+        new Metadata.BinaryMarshaller<SpanContext>() {
+          @Override
+          public byte[] toBytes(SpanContext value) {
+            throw new IllegalArgumentException("failed to byte");
+          }
+
+          @Override
+          public SpanContext parseBytes(byte[] serialized) {
+            return null;
+          }
+        });
+    Map<String, String> carrier = new HashMap<>();
+    Context context =
+        withSpanContext(
+            SpanContext.create(
+                TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getSampled(), TraceState.getDefault()),
+            Context.current());
+    propagator.inject(context, carrier, setter);
+    assertThat(carrier).hasSize(0);
+  }
+
+  @Test
+  public void inject_map_SampledContext() {
+    verify_inject_map(TraceFlags.getSampled(), goldenHeaderEncodedSampled);
+  }
+
+  @Test
+  public void inject_map_NotSampledContext() {
+    verify_inject_map(TraceFlags.getDefault(), goldenHeaderEncodedNotSampled);
+  }
+
+  private void verify_inject_map(TraceFlags traceFlags, String goldenHeader) {
+    Map<String, String> carrier = new HashMap<>();
+    Context context =
+        withSpanContext(
+            SpanContext.create(
+                TRACE_ID_BASE16, SPAN_ID_BASE16, traceFlags, TraceState.getDefault()),
+            Context.current());
+    grpcTraceBinContextPropagator.inject(context, carrier, setter);
+    assertThat(carrier)
+        .containsExactly(
+            GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, goldenHeader);
+  }
+
+  @Test
+  public void extract_map_nothing() {
+    Map<String, String> carrier = new HashMap<>();
+    assertThat(grpcTraceBinContextPropagator.extract(Context.current(), carrier, getter))
+        .isSameInstanceAs(Context.current());
+  }
+
+  @Test
+  public void extract_map_SampledContext() {
+    verify_extract_map(TraceFlags.getSampled(), goldenHeaderEncodedSampled);
+  }
+
+  @Test
+  public void extract_map_NotSampledContext() {
+    verify_extract_map(TraceFlags.getDefault(), goldenHeaderEncodedNotSampled);
+  }
+
+  private void verify_extract_map(TraceFlags traceFlags, String goldenHeader) {
+    Map<String, String> carrier = ImmutableMap.of(
+        GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, goldenHeader);
+    Context result = grpcTraceBinContextPropagator.extract(Context.current(), carrier, getter);
+    assertThat(getSpanContext(result)).isEqualTo(SpanContext.create(
+        TRACE_ID_BASE16, SPAN_ID_BASE16, traceFlags, TraceState.getDefault()));
+  }
+
+  @Test
+  public void inject_metadata_Nothing() {
+    Metadata carrier = new Metadata();
+    grpcTraceBinContextPropagator.inject(Context.current(), carrier, MetadataSetter.getInstance());
+    assertThat(carrier.keys()).isEmpty();
+  }
+
+  @Test
+  public void inject_metadata_nullCarrier() {
+    Context context =
+        withSpanContext(
+            SpanContext.create(
+                TRACE_ID_BASE16, SPAN_ID_BASE16, TraceFlags.getSampled(), TraceState.getDefault()),
+            Context.current());
+    grpcTraceBinContextPropagator.inject(context, null, MetadataSetter.getInstance());
+  }
+
+  @Test
+  public void inject_metadata_invalidSpan() {
+    Metadata carrier = new Metadata();
+    Context context = withSpanContext(SpanContext.getInvalid(), Context.current());
+    grpcTraceBinContextPropagator.inject(context, carrier, MetadataSetter.getInstance());
+    assertThat(carrier.keys()).isEmpty();
+  }
+
+  @Test
+  public void inject_metadata_SampledContext() {
+    verify_inject_metadata(TraceFlags.getSampled(), hexStringToByteArray(TRACE_HEADER_SAMPLED));
+  }
+
+  @Test
+  public void inject_metadataSetter_NotSampledContext() {
+    verify_inject_metadata(TraceFlags.getDefault(), hexStringToByteArray(TRACE_HEADER_NOT_SAMPLED));
+  }
+
+  private void verify_inject_metadata(TraceFlags traceFlags, byte[] bytes) {
+    Metadata metadata = new Metadata();
+    Context context =
+        withSpanContext(
+            SpanContext.create(
+                TRACE_ID_BASE16, SPAN_ID_BASE16, traceFlags, TraceState.getDefault()),
+            Context.current());
+    grpcTraceBinContextPropagator.inject(context, metadata, MetadataSetter.getInstance());
+    byte[] injected = metadata.get(Metadata.Key.of(
+        GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, Metadata.BINARY_BYTE_MARSHALLER));
+    assertTrue(Arrays.equals(injected, bytes));
+  }
+
+  @Test
+  public void extract_metadata_nothing() {
+    assertThat(grpcTraceBinContextPropagator.extract(
+        Context.current(), new Metadata(), MetadataGetter.getInstance()))
+        .isSameInstanceAs(Context.current());
+  }
+
+  @Test
+  public void extract_metadata_nullCarrier() {
+    assertThat(grpcTraceBinContextPropagator.extract(
+        Context.current(), null, MetadataGetter.getInstance()))
+        .isSameInstanceAs(Context.current());
+  }
+
+  @Test
+  public void extract_metadata_SampledContext() {
+    verify_extract_metadata(TraceFlags.getSampled(), TRACE_HEADER_SAMPLED);
+  }
+
+  @Test
+  public void extract_metadataGetter_NotSampledContext() {
+    verify_extract_metadata(TraceFlags.getDefault(), TRACE_HEADER_NOT_SAMPLED);
+  }
+
+  private void verify_extract_metadata(TraceFlags traceFlags, String hex) {
+    Metadata carrier = new Metadata();
+    carrier.put(Metadata.Key.of(
+            GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, Metadata.BINARY_BYTE_MARSHALLER),
+        hexStringToByteArray(hex));
+    Context result = grpcTraceBinContextPropagator.extract(Context.current(), carrier,
+        MetadataGetter.getInstance());
+    assertThat(getSpanContext(result)).isEqualTo(SpanContext.create(
+        TRACE_ID_BASE16, SPAN_ID_BASE16, traceFlags, TraceState.getDefault()));
+  }
+
+  @Test
+  public void extract_metadata_invalidBinaryFormat() {
+    GrpcTraceBinContextPropagator propagator = new GrpcTraceBinContextPropagator(
+        new Metadata.BinaryMarshaller<SpanContext>() {
+          @Override
+          public byte[] toBytes(SpanContext value) {
+            return new byte[0];
+          }
+
+          @Override
+          public SpanContext parseBytes(byte[] serialized) {
+            throw new IllegalArgumentException("failed to byte");
+          }
+        });
+    Metadata carrier = new Metadata();
+    carrier.put(Metadata.Key.of(
+            GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, Metadata.BINARY_BYTE_MARSHALLER),
+        hexStringToByteArray(TRACE_HEADER_SAMPLED));
+    assertThat(propagator.extract(Context.current(), carrier, MetadataGetter.getInstance()))
+        .isSameInstanceAs(Context.current());
+  }
+
+  @Test
+  public void extract_metadata_invalidBinaryFormatVersion() {
+    Metadata carrier = new Metadata();
+    carrier.put(Metadata.Key.of(
+            GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, Metadata.BINARY_BYTE_MARSHALLER),
+        hexStringToByteArray("0100" + TRACE_ID_BASE16 + "01" + SPAN_ID_BASE16 + "0201"));
+    assertThat(grpcTraceBinContextPropagator.extract(
+        Context.current(), carrier, MetadataGetter.getInstance()))
+        .isSameInstanceAs(Context.current());
+  }
+
+  private static String encode(String hex) {
+    return BASE64_ENCODING_OMIT_PADDING.encode(hexStringToByteArray(hex));
+  }
+
+  private static byte[] hexStringToByteArray(String s) {
+    int len = s.length();
+    byte[] data = new byte[len / 2];
+    for (int i = 0; i < len; i += 2) {
+      data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
+          + Character.digit(s.charAt(i + 1), 16));
+    }
+    return data;
+  }
+}
diff --git a/opentelemetry/src/test/java/io/grpc/opentelemetry/MetadataGetterTest.java b/opentelemetry/src/test/java/io/grpc/opentelemetry/MetadataGetterTest.java
new file mode 100644
index 00000000000..5934240e5c2
--- /dev/null
+++ b/opentelemetry/src/test/java/io/grpc/opentelemetry/MetadataGetterTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+import static io.grpc.InternalMetadata.BASE64_ENCODING_OMIT_PADDING;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import io.grpc.Metadata;
+import java.nio.charset.Charset;
+import java.util.Iterator;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class MetadataGetterTest {
+  private final MetadataGetter metadataGetter = MetadataGetter.getInstance();
+
+  @Test
+  public void getBinaryGrpcTraceBin() {
+    Metadata metadata = new Metadata();
+    byte[] b = "generated".getBytes(Charset.defaultCharset());
+    Metadata.Key<byte[]> grpc_trace_bin_key =
+        Metadata.Key.of("grpc-trace-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    metadata.put(grpc_trace_bin_key, b);
+    assertArrayEquals(b, metadataGetter.getBinary(metadata, "grpc-trace-bin"));
+  }
+
+  @Test
+  public void getBinaryEmptyMetadata() {
+    assertNull(metadataGetter.getBinary(new Metadata(), "grpc-trace-bin"));
+  }
+
+  @Test
+  public void getBinaryNotGrpcTraceBin() {
+    Metadata metadata = new Metadata();
+    byte[] b = "generated".getBytes(Charset.defaultCharset());
+    Metadata.Key<byte[]> grpc_trace_bin_key =
+        Metadata.Key.of("another-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    metadata.put(grpc_trace_bin_key, b);
+    assertNull(metadataGetter.getBinary(metadata, "another-bin"));
+  }
+
+  @Test
+  public void getTextEmptyMetadata() {
+    assertNull(metadataGetter.get(new Metadata(), "a-key"));
+  }
+
+  @Test
+  public void getTextBinHeader() {
+    assertNull(metadataGetter.get(new Metadata(), "a-key-bin"));
+  }
+
+  @Test
+  public void getTestGrpcTraceBin() {
+    Metadata metadata = new Metadata();
+    byte[] b = "generated".getBytes(Charset.defaultCharset());
+    Metadata.Key<byte[]> grpc_trace_bin_key =
+        Metadata.Key.of("grpc-trace-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    metadata.put(grpc_trace_bin_key, b);
+    assertEquals(BASE64_ENCODING_OMIT_PADDING.encode(b),
+        metadataGetter.get(metadata, "grpc-trace-bin"));
+  }
+
+  @Test
+  public void getText() {
+    Metadata metadata = new Metadata();
+    Metadata.Key<String> other_key =
+        Metadata.Key.of("other", Metadata.ASCII_STRING_MARSHALLER);
+    metadata.put(other_key, "header-value");
+    assertEquals("header-value", metadataGetter.get(metadata, "other"));
+
+    Iterator<String> iterator = metadataGetter.keys(metadata).iterator();
+    assertTrue(iterator.hasNext());
+    assertEquals("other", iterator.next());
+    assertFalse(iterator.hasNext());
+  }
+}
diff --git a/opentelemetry/src/test/java/io/grpc/opentelemetry/MetadataSetterTest.java b/opentelemetry/src/test/java/io/grpc/opentelemetry/MetadataSetterTest.java
new file mode 100644
index 00000000000..fcd85480bb9
--- /dev/null
+++ b/opentelemetry/src/test/java/io/grpc/opentelemetry/MetadataSetterTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+import static io.grpc.InternalMetadata.BASE64_ENCODING_OMIT_PADDING;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import io.grpc.Metadata;
+import java.nio.charset.Charset;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class MetadataSetterTest {
+  private final MetadataSetter metadataSetter = MetadataSetter.getInstance();
+
+  @Test
+  public void setGrpcTraceBin() {
+    Metadata metadata = new Metadata();
+    byte[] b = "generated".getBytes(Charset.defaultCharset());
+    Metadata.Key<byte[]> grpc_trace_bin_key =
+        Metadata.Key.of("grpc-trace-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    metadataSetter.set(metadata, "grpc-trace-bin", b);
+    assertArrayEquals(b, metadata.get(grpc_trace_bin_key));
+  }
+
+  @Test
+  public void setOtherBinaryKey() {
+    Metadata metadata = new Metadata();
+    byte[] b = "generated".getBytes(Charset.defaultCharset());
+    Metadata.Key<byte[]> other_key =
+        Metadata.Key.of("for-test-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    metadataSetter.set(metadata, other_key.name(), b);
+    assertNull(metadata.get(other_key));
+  }
+
+  @Test
+  public void setText() {
+    Metadata metadata = new Metadata();
+    String v = "generated";
+    Metadata.Key<String> textKey =
+        Metadata.Key.of("text-key", Metadata.ASCII_STRING_MARSHALLER);
+    metadataSetter.set(metadata, textKey.name(), v);
+    assertEquals(metadata.get(textKey), v);
+  }
+
+  @Test
+  public void setTextBin() {
+    Metadata metadata = new Metadata();
+    Metadata.Key<byte[]> other_key =
+        Metadata.Key.of("for-test-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    metadataSetter.set(metadata, other_key.name(), "generated");
+    assertNull(metadata.get(other_key));
+  }
+
+  @Test
+  public void setTextGrpcTraceBin() {
+    Metadata metadata = new Metadata();
+    byte[] b = "generated".getBytes(Charset.defaultCharset());
+    metadataSetter.set(metadata, "grpc-trace-bin", BASE64_ENCODING_OMIT_PADDING.encode(b));
+
+    Metadata.Key<byte[]> grpc_trace_bin_key =
+        Metadata.Key.of("grpc-trace-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    assertArrayEquals(metadata.get(grpc_trace_bin_key), b);
+  }
+}
diff --git a/opentelemetry/src/test/java/io/grpc/opentelemetry/OpenTelemetryMetricSinkTest.java b/opentelemetry/src/test/java/io/grpc/opentelemetry/OpenTelemetryMetricSinkTest.java
new file mode 100644
index 00000000000..cced4de3cb4
--- /dev/null
+++ b/opentelemetry/src/test/java/io/grpc/opentelemetry/OpenTelemetryMetricSinkTest.java
@@ -0,0 +1,480 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.DoubleCounterMetricInstrument;
+import io.grpc.DoubleHistogramMetricInstrument;
+import io.grpc.LongCounterMetricInstrument;
+import io.grpc.LongGaugeMetricInstrument;
+import io.grpc.LongHistogramMetricInstrument;
+import io.grpc.LongUpDownCounterMetricInstrument;
+import io.grpc.MetricInstrument;
+import io.grpc.MetricSink;
+import io.grpc.opentelemetry.internal.OpenTelemetryConstants;
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.metrics.DoubleCounter;
+import io.opentelemetry.api.metrics.DoubleHistogram;
+import io.opentelemetry.api.metrics.LongCounter;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
+import io.opentelemetry.sdk.testing.junit4.OpenTelemetryRule;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class OpenTelemetryMetricSinkTest {
+
+  @Rule
+  public final OpenTelemetryRule openTelemetryTesting = OpenTelemetryRule.create();
+
+  private final Meter testMeter = openTelemetryTesting.getOpenTelemetry()
+      .getMeter(OpenTelemetryConstants.INSTRUMENTATION_SCOPE);
+
+  private OpenTelemetryMetricSink sink;
+
+  @Test
+  public void updateMeasures_enabledMetrics() {
+    Map<String, Boolean> enabledMetrics = new HashMap<>();
+    enabledMetrics.put("client_calls_started", true);
+    enabledMetrics.put("server_calls_started", true);
+
+    List<String> optionalLabels = Arrays.asList("status");
+
+    List<MetricInstrument> instruments = Arrays.asList(
+        new DoubleCounterMetricInstrument(0, "client_calls_started",
+            "Number of client calls started", "count", Collections.emptyList(),
+            Collections.emptyList(),
+            true),
+        new LongCounterMetricInstrument(1, "server_calls_started", "Number of server calls started",
+            "count", Collections.emptyList(), Collections.emptyList(), false),
+        new DoubleHistogramMetricInstrument(2, "client_message_size", "Sent message size", "bytes",
+            Collections.emptyList(),
+            Collections.emptyList(), Collections.emptyList(), true)
+    );
+
+    // Create sink
+    sink = new OpenTelemetryMetricSink(testMeter, enabledMetrics, false, optionalLabels);
+
+    // Invoke updateMeasures
+    sink.updateMeasures(instruments);
+
+    com.google.common.truth.Truth.assertThat(sink.getMeasuresSize()).isEqualTo(3);
+    // Metric is explicitly enabled for sink
+    com.google.common.truth.Truth.assertThat(sink.getMeasures().get(0).getMeasure())
+        .isInstanceOf(DoubleCounter.class);
+    // Metric is explicitly enabled for sink
+    com.google.common.truth.Truth.assertThat(sink.getMeasures().get(1).getMeasure())
+        .isInstanceOf(LongCounter.class);
+    // Metric is enabled by default
+    com.google.common.truth.Truth.assertThat(sink.getMeasures().get(2).getMeasure())
+        .isInstanceOf(DoubleHistogram.class);
+
+  }
+
+  @Test
+  public void updateMeasure_disabledMetrics() {
+    Map<String, Boolean> enabledMetrics = new HashMap<>();
+    enabledMetrics.put("client_calls_started", false);
+    enabledMetrics.put("server_calls_started", false);
+
+    List<String> optionalLabels = Arrays.asList("status");
+
+    List<MetricInstrument> instruments = Arrays.asList(
+        new DoubleCounterMetricInstrument(0, "client_calls_started",
+            "Number of client calls started", "count", Collections.emptyList(),
+            Collections.emptyList(), true),
+        new LongCounterMetricInstrument(1, "server_calls_started", "Number of server calls started",
+            "count", Collections.emptyList(), Collections.emptyList(), true),
+        new DoubleHistogramMetricInstrument(2, "client_message_size", "Sent message size", "bytes",
+            Collections.emptyList(),
+            Collections.emptyList(), Collections.emptyList(), true)
+    );
+
+    // Create sink
+    sink = new OpenTelemetryMetricSink(testMeter, enabledMetrics, true, optionalLabels);
+
+    // Invoke updateMeasures
+    sink.updateMeasures(instruments);
+
+    com.google.common.truth.Truth.assertThat(sink.getMeasuresSize()).isEqualTo(3);
+    // Metric is explicitly disabled
+    com.google.common.truth.Truth.assertThat(sink.getMeasures().get(0)).isNull();
+    // Metric is explicitly disabled
+    com.google.common.truth.Truth.assertThat(sink.getMeasures().get(1)).isNull();
+    // Metric is enabled by default, but all default metrics are disabled
+    com.google.common.truth.Truth.assertThat(sink.getMeasures().get(2)).isNull();
+
+  }
+
+  @Test
+  public void addCounter_enabledMetric() {
+    // set up sink with disabled metric
+    Map<String, Boolean> enabledMetrics = new HashMap<>();
+    enabledMetrics.put("client_latency", true);
+
+    LongCounterMetricInstrument longCounterInstrument =
+        new LongCounterMetricInstrument(0, "client_latency", "Client latency", "s",
+            Collections.emptyList(),
+            Collections.emptyList(), false);
+    DoubleCounterMetricInstrument doubleCounterInstrument =
+        new DoubleCounterMetricInstrument(1, "client_calls_started",
+            "Number of client calls started", "count", Collections.emptyList(),
+            Collections.emptyList(),
+            true);
+    LongUpDownCounterMetricInstrument longUpDownCounterInstrument =
+        new LongUpDownCounterMetricInstrument(2, "active_carrier_pigeons",
+            "Active Carrier Pigeons", "pigeons",
+            Collections.emptyList(),
+            Collections.emptyList(), true);
+
+    // Create sink
+    sink = new OpenTelemetryMetricSink(testMeter, enabledMetrics, false, Collections.emptyList());
+
+    // Invoke updateMeasures
+    sink.updateMeasures(Arrays.asList(longCounterInstrument, doubleCounterInstrument,
+        longUpDownCounterInstrument));
+
+    sink.addLongCounter(longCounterInstrument, 123L, Collections.emptyList(),
+        Collections.emptyList());
+    sink.addDoubleCounter(doubleCounterInstrument, 12.0, Collections.emptyList(),
+        Collections.emptyList());
+    sink.addLongUpDownCounter(longUpDownCounterInstrument, -3L, Collections.emptyList(),
+        Collections.emptyList());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName("client_latency")
+                    .hasDescription("Client latency")
+                    .hasUnit("s")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasValue(123L))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName("client_calls_started")
+                    .hasDescription("Number of client calls started")
+                    .hasUnit("count")
+                    .hasDoubleSumSatisfying(
+                        doubleSum ->
+                            doubleSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasValue(12.0D))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName("active_carrier_pigeons")
+                    .hasDescription("Active Carrier Pigeons")
+                    .hasUnit("pigeons")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasValue(-3L))));
+  }
+
+  @Test
+  public void addCounter_disabledMetric() {
+    // set up sink with disabled metric
+    Map<String, Boolean> enabledMetrics = new HashMap<>();
+    enabledMetrics.put("client_latency", false);
+    enabledMetrics.put("active_carrier_pigeons", false);
+
+    LongCounterMetricInstrument instrument =
+        new LongCounterMetricInstrument(0, "client_latency", "Client latency", "s",
+            Collections.emptyList(),
+            Collections.emptyList(), true);
+    LongUpDownCounterMetricInstrument longUpDownCounterInstrument =
+        new LongUpDownCounterMetricInstrument(1, "active_carrier_pigeons",
+            "Active Carrier Pigeons", "pigeons",
+            Collections.emptyList(),
+            Collections.emptyList(), false);
+
+    // Create sink
+    sink = new OpenTelemetryMetricSink(testMeter, enabledMetrics, true, Collections.emptyList());
+
+    // Invoke updateMeasures
+    sink.updateMeasures(Arrays.asList(instrument, longUpDownCounterInstrument));
+
+    sink.addLongCounter(instrument, 123L, Collections.emptyList(), Collections.emptyList());
+    sink.addLongUpDownCounter(longUpDownCounterInstrument, -13L, Collections.emptyList(),
+        Collections.emptyList());
+
+    assertThat(openTelemetryTesting.getMetrics()).isEmpty();
+  }
+
+  @Test
+  public void addHistogram_enabledMetric() {
+    // set up sink with disabled metric
+    Map<String, Boolean> enabledMetrics = new HashMap<>();
+    enabledMetrics.put("client_message_size", true);
+    enabledMetrics.put("server_message_size", true);
+
+    DoubleHistogramMetricInstrument doubleHistogramInstrument =
+        new DoubleHistogramMetricInstrument(0, "client_message_size", "Sent message size", "bytes",
+            Collections.emptyList(),
+            Collections.emptyList(), Collections.emptyList(), false);
+    LongHistogramMetricInstrument longHistogramInstrument =
+        new LongHistogramMetricInstrument(1, "server_message_size", "Received message size",
+            "bytes",
+            Collections.emptyList(),
+            Collections.emptyList(), Collections.emptyList(), true);
+
+    // Create sink
+    sink = new OpenTelemetryMetricSink(testMeter, enabledMetrics, false, Collections.emptyList());
+
+    // Invoke updateMeasures
+    sink.updateMeasures(Arrays.asList(doubleHistogramInstrument, longHistogramInstrument));
+
+    sink.recordDoubleHistogram(doubleHistogramInstrument, 12.0, Collections.emptyList(),
+        Collections.emptyList());
+    sink.recordLongHistogram(longHistogramInstrument, 123L, Collections.emptyList(),
+        Collections.emptyList());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName("client_message_size")
+                    .hasDescription("Sent message size")
+                    .hasUnit("bytes")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(12.0))),
+
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName("server_message_size")
+                    .hasDescription("Received message size")
+                    .hasUnit("bytes")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(123L))));
+  }
+
+  @Test
+  public void addHistogram_disabledMetric() {
+    // set up sink with disabled metric
+    Map<String, Boolean> enabledMetrics = new HashMap<>();
+    enabledMetrics.put("client_message_size", false);
+    enabledMetrics.put("server_message_size", false);
+
+    DoubleHistogramMetricInstrument doubleHistogramInstrument =
+        new DoubleHistogramMetricInstrument(0, "client_message_size", "Sent message size", "bytes",
+            Collections.emptyList(),
+            Collections.emptyList(), Collections.emptyList(), false);
+    LongHistogramMetricInstrument longHistogramInstrument =
+        new LongHistogramMetricInstrument(1, "server_message_size", "Received message size",
+            "bytes",
+            Collections.emptyList(),
+            Collections.emptyList(), Collections.emptyList(), true);
+
+    // Create sink
+    sink = new OpenTelemetryMetricSink(testMeter, enabledMetrics, false, Collections.emptyList());
+
+    // Invoke updateMeasures
+    sink.updateMeasures(Arrays.asList(doubleHistogramInstrument, longHistogramInstrument));
+
+    sink.recordDoubleHistogram(doubleHistogramInstrument, 12.0, Collections.emptyList(),
+        Collections.emptyList());
+    sink.recordLongHistogram(longHistogramInstrument, 123L, Collections.emptyList(),
+        Collections.emptyList());
+
+    assertThat(openTelemetryTesting.getMetrics()).isEmpty();
+  }
+
+  @Test
+  public void registerBatchCallback_allDisabled() {
+    // set up sink with disabled metric
+    Map<String, Boolean> enabledMetrics = new HashMap<>();
+
+    LongGaugeMetricInstrument longGaugeInstrumentDisabled =
+        new LongGaugeMetricInstrument(0, "disk", "Amount of disk used", "By",
+            Collections.emptyList(), Collections.emptyList(), false);
+
+    // Create sink
+    sink = new OpenTelemetryMetricSink(testMeter, enabledMetrics, false, Collections.emptyList());
+
+    // Invoke updateMeasures
+    sink.updateMeasures(Arrays.asList(longGaugeInstrumentDisabled));
+
+    MetricSink.Registration registration = sink.registerBatchCallback(() -> {
+      sink.recordLongGauge(
+          longGaugeInstrumentDisabled, 999, Collections.emptyList(), Collections.emptyList());
+    }, longGaugeInstrumentDisabled);
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder();
+    registration.close();
+  }
+
+  @Test
+  public void registerBatchCallback_bothEnabledAndDisabled() {
+    // set up sink with disabled metric
+    Map<String, Boolean> enabledMetrics = new HashMap<>();
+    enabledMetrics.put("memory", true);
+
+    LongGaugeMetricInstrument longGaugeInstrumentEnabled =
+        new LongGaugeMetricInstrument(0, "memory", "Amount of memory used", "By",
+            Collections.emptyList(), Collections.emptyList(), false);
+    LongGaugeMetricInstrument longGaugeInstrumentDisabled =
+        new LongGaugeMetricInstrument(1, "disk", "Amount of disk used", "By",
+            Collections.emptyList(), Collections.emptyList(), false);
+
+    // Create sink
+    sink = new OpenTelemetryMetricSink(testMeter, enabledMetrics, false, Collections.emptyList());
+
+    // Invoke updateMeasures
+    sink.updateMeasures(Arrays.asList(longGaugeInstrumentEnabled, longGaugeInstrumentDisabled));
+
+    MetricSink.Registration registration = sink.registerBatchCallback(() -> {
+      sink.recordLongGauge(
+          longGaugeInstrumentEnabled, 99, Collections.emptyList(), Collections.emptyList());
+      sink.recordLongGauge(
+          longGaugeInstrumentDisabled, 999, Collections.emptyList(), Collections.emptyList());
+    }, longGaugeInstrumentEnabled, longGaugeInstrumentDisabled);
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName("memory")
+                    .hasDescription("Amount of memory used")
+                    .hasUnit("By")
+                    .hasLongGaugeSatisfying(
+                        gauge ->
+                            gauge.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasValue(99))));
+
+    // Gauge goes away after close
+    registration.close();
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder();
+  }
+
+  @Test
+  public void recordLabels() {
+    Map<String, Boolean> enabledMetrics = new HashMap<>();
+    enabledMetrics.put("client_latency", true);
+    enabledMetrics.put("ghosts_in_the_wire", true);
+
+    List<String> optionalLabels = Arrays.asList("optional_label_key_2");
+
+    LongCounterMetricInstrument longCounterInstrument =
+        new LongCounterMetricInstrument(0, "client_latency", "Client latency", "s",
+            ImmutableList.of("required_label_key_1", "required_label_key_2"),
+            ImmutableList.of("optional_label_key_1", "optional_label_key_2"), false);
+    LongUpDownCounterMetricInstrument longUpDownCounterInstrument =
+        new LongUpDownCounterMetricInstrument(1, "ghosts_in_the_wire",
+            "Number of Ghosts Haunting the Wire", "{ghosts}",
+            ImmutableList.of("required_label_key_1", "required_label_key_2"),
+            ImmutableList.of("optional_label_key_1", "optional_label_key_2"), false);
+
+    // Create sink
+    sink = new OpenTelemetryMetricSink(testMeter, enabledMetrics, false, optionalLabels);
+
+    // Invoke updateMeasures
+    sink.updateMeasures(Arrays.asList(longCounterInstrument, longUpDownCounterInstrument));
+
+    sink.addLongCounter(longCounterInstrument, 123L,
+        ImmutableList.of("required_label_value_1", "required_label_value_2"),
+        ImmutableList.of("optional_label_value_1", "optional_label_value_2"));
+    sink.addLongUpDownCounter(longUpDownCounterInstrument, -400L,
+        ImmutableList.of("required_label_value_1", "required_label_value_2"),
+        ImmutableList.of("optional_label_value_1", "optional_label_value_2"));
+
+    io.opentelemetry.api.common.Attributes expectedAtrributes
+        = io.opentelemetry.api.common.Attributes.of(
+        AttributeKey.stringKey("required_label_key_1"), "required_label_value_1",
+        AttributeKey.stringKey("required_label_key_2"), "required_label_value_2",
+        AttributeKey.stringKey("optional_label_key_2"), "optional_label_value_2");
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName("client_latency")
+                    .hasDescription("Client latency")
+                    .hasUnit("s")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasAttributes(expectedAtrributes)
+                                            .hasValue(123L))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName("ghosts_in_the_wire")
+                    .hasDescription("Number of Ghosts Haunting the Wire")
+                    .hasUnit("{ghosts}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasAttributes(expectedAtrributes)
+                                            .hasValue(-400L))));
+
+  }
+}
diff --git a/opentelemetry/src/test/java/io/grpc/opentelemetry/OpenTelemetryMetricsModuleTest.java b/opentelemetry/src/test/java/io/grpc/opentelemetry/OpenTelemetryMetricsModuleTest.java
new file mode 100644
index 00000000000..391f94cefea
--- /dev/null
+++ b/opentelemetry/src/test/java/io/grpc/opentelemetry/OpenTelemetryMetricsModuleTest.java
@@ -0,0 +1,1904 @@
+/*
+ * Copyright 2023 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.opentelemetry;
+
+import static io.grpc.ClientStreamTracer.NAME_RESOLUTION_DELAYED;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.LOCALITY_KEY;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.METHOD_KEY;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.STATUS_KEY;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.TARGET_KEY;
+import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
+import static java.util.Collections.emptyList;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyDouble;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.ImmutableMap;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientInterceptors;
+import io.grpc.ClientStreamTracer;
+import io.grpc.KnownLength;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.ServerStreamTracer;
+import io.grpc.ServerStreamTracer.ServerCallInfo;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.FakeClock;
+import io.grpc.opentelemetry.GrpcOpenTelemetry.TargetFilter;
+import io.grpc.opentelemetry.OpenTelemetryMetricsModule.CallAttemptsTracerFactory;
+import io.grpc.opentelemetry.internal.OpenTelemetryConstants;
+import io.grpc.stub.MetadataUtils;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcServerRule;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.baggage.Baggage;
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.metrics.DoubleHistogram;
+import io.opentelemetry.api.metrics.Meter;
+import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
+import io.opentelemetry.sdk.metrics.data.MetricData;
+import io.opentelemetry.sdk.testing.junit4.OpenTelemetryRule;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Test for {@link OpenTelemetryMetricsModule}.
+ */
+@RunWith(JUnit4.class)
+public class OpenTelemetryMetricsModuleTest {
+
+  private static final CallOptions.Key<String> CUSTOM_OPTION =
+      CallOptions.Key.createWithDefault("option1", "default");
+  private static final CallOptions CALL_OPTIONS =
+      CallOptions.DEFAULT.withOption(CUSTOM_OPTION, "customvalue");
+  private static final ClientStreamTracer.StreamInfo STREAM_INFO =
+      ClientStreamTracer.StreamInfo.newBuilder()
+          .setCallOptions(CallOptions.DEFAULT.withOption(NAME_RESOLUTION_DELAYED, 10L)).build();
+  private static final String CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME = "grpc.client.attempt.started";
+  private static final String CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME
+      = "grpc.client.attempt.duration";
+  private static final String CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE
+      = "grpc.client.attempt.sent_total_compressed_message_size";
+  private static final String CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE
+      = "grpc.client.attempt.rcvd_total_compressed_message_size";
+  private static final String CLIENT_CALL_DURATION = "grpc.client.call.duration";
+  private static final String CLIENT_CALL_RETRIES = "grpc.client.call.retries";
+  private static final String CLIENT_CALL_TRANSPARENT_RETRIES =
+      "grpc.client.call.transparent_retries";
+  private static final String CLIENT_CALL_HEDGES = "grpc.client.call.hedges";
+  private static final String CLIENT_CALL_RETRY_DELAY = "grpc.client.call.retry_delay";
+  private static final String SERVER_CALL_COUNT = "grpc.server.call.started";
+  private static final String SERVER_CALL_DURATION = "grpc.server.call.duration";
+  private static final String SERVER_CALL_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE
+      = "grpc.server.call.sent_total_compressed_message_size";
+  private static final String SERVER_CALL_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE
+      = "grpc.server.call.rcvd_total_compressed_message_size";
+  private static final double[] latencyBuckets =
+      {   0d,     0.00001d, 0.00005d, 0.0001d, 0.0003d, 0.0006d, 0.0008d, 0.001d, 0.002d,
+          0.003d, 0.004d,   0.005d,   0.006d,  0.008d,  0.01d,   0.013d,  0.016d, 0.02d,
+          0.025d, 0.03d,    0.04d,    0.05d,   0.065d,  0.08d,   0.1d,    0.13d,  0.16d,
+          0.2d,   0.25d,    0.3d,     0.4d,    0.5d,    0.65d,   0.8d,    1d,     2d,
+          5d,     10d,      20d,      50d,     100d };
+  private static final double[] sizeBuckets =
+      { 0L, 1024L, 2048L, 4096L, 16384L, 65536L, 262144L, 1048576L, 4194304L, 16777216L,
+      67108864L, 268435456L, 1073741824L, 4294967296L };
+
+  private static final class StringInputStream extends InputStream implements KnownLength {
+    final String string;
+
+    StringInputStream(String string) {
+      this.string = string;
+    }
+
+    @Override
+    public int read() {
+      throw new UnsupportedOperationException("should not be called");
+    }
+
+    @Override
+    public int available() throws IOException {
+      return string == null ? 0 : string.length();
+    }
+  }
+
+  private static final MethodDescriptor.Marshaller<String> MARSHALLER =
+      new MethodDescriptor.Marshaller<String>() {
+        @Override
+        public InputStream stream(String value) {
+          return new StringInputStream(value);
+        }
+
+        @Override
+        public String parse(InputStream stream) {
+          return ((StringInputStream) stream).string;
+        }
+      };
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  @Rule
+  public final GrpcServerRule grpcServerRule = new GrpcServerRule().directExecutor();
+  @Rule
+  public final OpenTelemetryRule openTelemetryTesting = OpenTelemetryRule.create();
+  @Mock
+  private ClientCall.Listener<String> mockClientCallListener;
+  @Mock
+  private ServerCall.Listener<String> mockServerCallListener;
+  @Captor
+  private ArgumentCaptor<Status> statusCaptor;
+  @Mock
+  private DoubleHistogram mockServerCallDurationHistogram;
+  @Captor
+  private ArgumentCaptor<io.opentelemetry.context.Context> contextCaptor;
+  private io.grpc.Server server;
+  private io.grpc.ManagedChannel channel;
+  private OpenTelemetryMetricsResource resource;
+  private final String serverName = "E2ETestServer-" + Math.random();
+
+  private final FakeClock fakeClock = new FakeClock();
+  private final MethodDescriptor<String, String> method =
+      MethodDescriptor.<String, String>newBuilder()
+          .setType(MethodDescriptor.MethodType.UNKNOWN)
+          .setRequestMarshaller(MARSHALLER)
+          .setResponseMarshaller(MARSHALLER)
+          .setFullMethodName("package1.service2/method3")
+          .setSampledToLocalTracing(true)
+          .build();
+  private Meter testMeter;
+  private final Map<String, Boolean> enabledMetricsMap = ImmutableMap.of();
+
+  private final boolean disableDefaultMetrics = false;
+
+  @Before
+  public void setUp() throws Exception {
+    testMeter = openTelemetryTesting.getOpenTelemetry()
+        .getMeter(OpenTelemetryConstants.INSTRUMENTATION_SCOPE);
+    resource = OpenTelemetryMetricsResource.builder()
+        .serverCallDurationCounter(mockServerCallDurationHistogram)
+        .build();
+  }
+
+  @After
+  public void tearDown() {
+    if (channel != null) {
+      channel.shutdownNow();
+    }
+    if (server != null) {
+      server.shutdownNow();
+    }
+  }
+
+  @Test
+  public void testClientInterceptors() {
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource);
+    grpcServerRule.getServiceRegistry().addService(
+        ServerServiceDefinition.builder("package1.service2").addMethod(
+            method, new ServerCallHandler<String, String>() {
+              @Override
+              public ServerCall.Listener<String> startCall(
+                  ServerCall<String, String> call, Metadata headers) {
+                call.sendHeaders(new Metadata());
+                call.sendMessage("Hello");
+                call.close(
+                    Status.PERMISSION_DENIED.withDescription("No you don't"), new Metadata());
+                return mockServerCallListener;
+              }
+            }).build());
+
+    final AtomicReference<CallOptions> capturedCallOptions = new AtomicReference<>();
+    ClientInterceptor callOptionsCaptureInterceptor = new ClientInterceptor() {
+      @Override
+      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+          MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+        capturedCallOptions.set(callOptions);
+        return next.newCall(method, callOptions);
+      }
+    };
+    Channel interceptedChannel =
+        ClientInterceptors.intercept(
+            grpcServerRule.getChannel(), callOptionsCaptureInterceptor,
+            module.getClientInterceptor("target:///"));
+    ClientCall<String, String> call;
+    call = interceptedChannel.newCall(method, CALL_OPTIONS);
+
+    assertEquals("customvalue", capturedCallOptions.get().getOption(CUSTOM_OPTION));
+    assertEquals(1, capturedCallOptions.get().getStreamTracerFactories().size());
+    assertTrue(
+        capturedCallOptions.get().getStreamTracerFactories().get(0)
+            instanceof OpenTelemetryMetricsModule.CallAttemptsTracerFactory);
+
+    // Make the call
+    Metadata headers = new Metadata();
+    call.start(mockClientCallListener, headers);
+
+    // End the call
+    call.halfClose();
+    call.request(1);
+
+    verify(mockClientCallListener).onClose(statusCaptor.capture(), any(Metadata.class));
+    Status status = statusCaptor.getValue();
+    assertEquals(Status.Code.PERMISSION_DENIED, status.getCode());
+    assertEquals("No you don't", status.getDescription());
+  }
+
+  @Test
+  public void clientBasicMetrics() {
+    String target = "target:///";
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource);
+    OpenTelemetryMetricsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CallAttemptsTracerFactory(module, target, method.getFullMethodName(), emptyList());
+    Metadata headers = new Metadata();
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, headers);
+    io.opentelemetry.api.common.Attributes attributes = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactly(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasUnit("{attempt}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasAttributes(attributes)
+                                            .hasValue(1))));
+
+    tracer.addOptionalLabel("grpc.lb.locality", "should-be-ignored");
+
+    fakeClock.forwardTime(30, TimeUnit.MILLISECONDS);
+    tracer.outboundHeaders();
+
+    fakeClock.forwardTime(100, TimeUnit.MILLISECONDS);
+    tracer.outboundMessage(0);
+    tracer.outboundWireSize(1028);
+
+    fakeClock.forwardTime(16, TimeUnit.MILLISECONDS);
+
+    tracer.inboundMessage(0);
+    tracer.inboundMessage(33);
+    tracer.outboundMessage(1);
+    tracer.outboundWireSize(99);
+
+    fakeClock.forwardTime(24, TimeUnit.MILLISECONDS);
+    tracer.inboundMessage(1);
+    tracer.inboundWireSize(154);
+    tracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK);
+
+    io.opentelemetry.api.common.Attributes clientAttributes
+        = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName(),
+        STATUS_KEY, Status.Code.OK.toString());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasUnit("{attempt}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasAttributes(attributes)
+                                            .hasValue(1))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME)
+                    .hasUnit("s")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0.03 + 0.1 + 0.016 + 0.024)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(latencyBuckets)
+                                        .hasBucketCounts(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+                                            0, 0, 0, 0, 0, 0, 0, 0, 0))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(1028L + 99)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(sizeBuckets)
+                                        .hasBucketCounts(0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                            0))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram
+                                .isCumulative()
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasCount(1)
+                                            .hasSum(154)
+                                            .hasAttributes(clientAttributes)
+                                            .hasBucketCounts(0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                                0, 0))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_CALL_DURATION)
+                    .hasUnit("s")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0.03 + 0.1 + 0.016 + 0.024)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(latencyBuckets)
+                                        .hasBucketCounts(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,
+                                            0, 0, 0, 0, 0, 0, 0, 0, 0))));
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .extracting("name")
+        .doesNotContain(
+            CLIENT_CALL_RETRIES,
+            CLIENT_CALL_TRANSPARENT_RETRIES,
+            CLIENT_CALL_HEDGES,
+            CLIENT_CALL_RETRY_DELAY);
+  }
+
+  @Test
+  public void clientBasicMetrics_withRetryMetricsEnabled_shouldRecordZeroOrBeAbsent() {
+    // Explicitly enable the retry metrics
+    Map<String, Boolean> enabledMetrics = ImmutableMap.of(
+        CLIENT_CALL_RETRIES, true,
+        CLIENT_CALL_TRANSPARENT_RETRIES, true,
+        CLIENT_CALL_HEDGES, true,
+        CLIENT_CALL_RETRY_DELAY, true
+    );
+
+    String target = "target:///";
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetrics, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource);
+    OpenTelemetryMetricsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CallAttemptsTracerFactory(module, target, method.getFullMethodName(), emptyList());
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+
+    fakeClock.forwardTime(30, TimeUnit.MILLISECONDS);
+    tracer.outboundHeaders();
+    fakeClock.forwardTime(100, TimeUnit.MILLISECONDS);
+    tracer.outboundMessage(0);
+    tracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK);
+
+    io.opentelemetry.api.common.Attributes finalAttributes
+        = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric -> assertThat(metric).hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME),
+            metric -> assertThat(metric).hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME),
+            metric -> assertThat(metric).hasName(CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE),
+            metric -> assertThat(metric).hasName(CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE),
+            metric -> assertThat(metric).hasName(CLIENT_CALL_DURATION),
+            metric -> assertThat(metric)
+                .hasName(CLIENT_CALL_RETRY_DELAY)
+                .hasHistogramSatisfying(
+                    histogram ->
+                        histogram.hasPointsSatisfying(
+                            point ->
+                                point
+                                    .hasSum(0)
+                                    .hasCount(1)
+                                    .hasAttributes(finalAttributes)))
+
+        );
+
+    List<String> optionalMetricNames = Arrays.asList(
+        CLIENT_CALL_RETRIES,
+        CLIENT_CALL_TRANSPARENT_RETRIES,
+        CLIENT_CALL_HEDGES);
+
+    for (String metricName : optionalMetricNames) {
+      Optional<MetricData> metric = openTelemetryTesting.getMetrics().stream()
+          .filter(m -> m.getName().equals(metricName))
+          .findFirst();
+      if (metric.isPresent()) {
+        assertThat(metric.get())
+            .hasHistogramSatisfying(
+                histogram ->
+                    histogram.hasPointsSatisfying(
+                        point ->
+                            point
+                                .hasSum(0)
+                                .hasCount(1)
+                                .hasAttributes(finalAttributes)));
+      }
+    }
+  }
+
+  // This test is only unit-testing the metrics recording logic. The retry behavior is faked.
+  @Test
+  public void recordAttemptMetrics() {
+    String target = "dns:///example.com";
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource);
+    OpenTelemetryMetricsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new OpenTelemetryMetricsModule.CallAttemptsTracerFactory(module, target,
+            method.getFullMethodName(), emptyList());
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+
+    io.opentelemetry.api.common.Attributes attributes = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactly(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasUnit("{attempt}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasAttributes(attributes)
+                                            .hasValue(1))));
+
+    fakeClock.forwardTime(30, TimeUnit.MILLISECONDS);
+    tracer.outboundHeaders();
+    fakeClock.forwardTime(100, TimeUnit.MILLISECONDS);
+    tracer.outboundMessage(0);
+    tracer.outboundMessage(1);
+    tracer.outboundWireSize(1028);
+    fakeClock.forwardTime(24, TimeUnit.MILLISECONDS);
+    tracer.streamClosed(Status.UNAVAILABLE);
+
+    io.opentelemetry.api.common.Attributes clientAttributes
+        = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName(),
+        STATUS_KEY, Code.UNAVAILABLE.toString());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasUnit("{attempt}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasAttributes(attributes)
+                                            .hasValue(1))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME)
+                    .hasUnit("s")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0.03 + 0.1 + 0.024)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(latencyBuckets))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(1028L)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(sizeBuckets))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram
+                                .isCumulative()
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasCount(1)
+                                            .hasSum(0)
+                                            .hasAttributes(clientAttributes)
+                                            .hasBucketBoundaries(sizeBuckets))));
+
+
+    // faking retry
+    fakeClock.forwardTime(1000, TimeUnit.MILLISECONDS);
+    tracer = callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+
+    tracer.outboundHeaders();
+    tracer.outboundMessage(0);
+    tracer.outboundMessage(1);
+    tracer.outboundWireSize(1028);
+    fakeClock.forwardTime(100, TimeUnit.MILLISECONDS);
+    tracer.streamClosed(Status.NOT_FOUND);
+
+    io.opentelemetry.api.common.Attributes clientAttributes1
+        = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName(),
+        STATUS_KEY, Code.NOT_FOUND.toString());
+
+    // Histograms are cumulative by default.
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasUnit("{attempt}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasValue(2)
+                                            .hasAttributes(attributes))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME)
+                    .hasUnit("s")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0.1)
+                                        .hasAttributes(clientAttributes1)
+                                        .hasBucketBoundaries(latencyBuckets),
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0.154)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(latencyBuckets))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram
+                                .isCumulative()
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasCount(1)
+                                            .hasSum(0)
+                                            .hasAttributes(clientAttributes1)
+                                            .hasBucketBoundaries(sizeBuckets),
+                                    point ->
+                                        point
+                                            .hasCount(1)
+                                            .hasSum(0)
+                                            .hasAttributes(clientAttributes)
+                                            .hasBucketBoundaries(sizeBuckets))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(1028L)
+                                        .hasAttributes(clientAttributes1)
+                                        .hasBucketBoundaries(sizeBuckets),
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(1028L)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(sizeBuckets))));
+
+    // fake transparent retry
+    fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+    tracer = callAttemptsTracerFactory.newClientStreamTracer(
+        STREAM_INFO.toBuilder().setIsTransparentRetry(true).build(), new Metadata());
+    fakeClock.forwardTime(32, MILLISECONDS);
+    tracer.streamClosed(Status.UNAVAILABLE);
+
+
+    // Histograms are cumulative by default.
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasUnit("{attempt}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasValue(3)
+                                            .hasAttributes(attributes))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME)
+                    .hasUnit("s")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0.1)
+                                        .hasAttributes(clientAttributes1)
+                                        .hasBucketBoundaries(latencyBuckets),
+                                point ->
+                                    point
+                                        .hasCount(2)
+                                        .hasSum(0.154 + 0.032)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(latencyBuckets))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram
+                                .isCumulative()
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasCount(1)
+                                            .hasSum(0)
+                                            .hasAttributes(clientAttributes1)
+                                            .hasBucketBoundaries(sizeBuckets),
+                                    point ->
+                                        point
+                                            .hasCount(2)
+                                            .hasSum(0 + 0)
+                                            .hasAttributes(clientAttributes)
+                                            .hasBucketBoundaries(sizeBuckets))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(1028L)
+                                        .hasAttributes(clientAttributes1)
+                                        .hasBucketBoundaries(sizeBuckets),
+                                point ->
+                                    point
+                                        .hasCount(2)
+                                        .hasSum(1028L + 0)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(sizeBuckets))));
+
+    // fake another transparent retry
+    fakeClock.forwardTime(10, MILLISECONDS);
+    tracer = callAttemptsTracerFactory.newClientStreamTracer(
+        STREAM_INFO.toBuilder().setIsTransparentRetry(true).build(), new Metadata());
+    tracer.outboundHeaders();
+    tracer.outboundMessage(0);
+    tracer.outboundMessage(1);
+    tracer.outboundWireSize(1028);
+    tracer.inboundMessage(0);
+    tracer.inboundWireSize(33);
+    fakeClock.forwardTime(24, MILLISECONDS);
+    // RPC succeeded
+    tracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK);
+
+    io.opentelemetry.api.common.Attributes clientAttributes2
+        = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName(),
+        STATUS_KEY, Code.OK.toString());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasUnit("{attempt}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasValue(4)
+                                            .hasAttributes(attributes))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(1028L)
+                                        .hasAttributes(clientAttributes1)
+                                        .hasBucketBoundaries(sizeBuckets),
+                                point ->
+                                    point
+                                        .hasCount(2)
+                                        .hasSum(1028L + 0)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(sizeBuckets),
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(1028L)
+                                        .hasAttributes(clientAttributes2)
+                                        .hasBucketBoundaries(sizeBuckets))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_CALL_DURATION)
+                    .hasUnit("s")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0.03 + 0.1 + 0.024 + 1 + 0.1 + 0.01 + 0.032 + 0.01
+                                            + 0.024)
+                                        .hasAttributes(clientAttributes2)
+                                        .hasBucketBoundaries(latencyBuckets))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME)
+                    .hasUnit("s")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0.100)
+                                        .hasAttributes(clientAttributes1)
+                                        .hasBucketBoundaries(latencyBuckets),
+                                point ->
+                                    point
+                                        .hasCount(2)
+                                        .hasSum(0.154 + 0.032)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(latencyBuckets),
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0.024)
+                                        .hasAttributes(clientAttributes2)
+                                        .hasBucketBoundaries(latencyBuckets))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram
+                                .isCumulative()
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasCount(1)
+                                            .hasSum(0)
+                                            .hasAttributes(clientAttributes1)
+                                            .hasBucketBoundaries(sizeBuckets),
+                                    point ->
+                                        point
+                                            .hasCount(2)
+                                            .hasSum(0 + 0)
+                                            .hasAttributes(clientAttributes)
+                                            .hasBucketBoundaries(sizeBuckets),
+                                    point ->
+                                        point
+                                            .hasCount(1)
+                                            .hasSum(33D)
+                                            .hasAttributes(clientAttributes2)
+                                            .hasBucketBoundaries(sizeBuckets))));
+  }
+
+  @Test
+  public void recordAttemptMetrics_withRetryMetricsEnabled() {
+    Map<String, Boolean> enabledMetrics = ImmutableMap.of(
+        CLIENT_CALL_RETRIES, true,
+        CLIENT_CALL_TRANSPARENT_RETRIES, true,
+        CLIENT_CALL_HEDGES, true,
+        CLIENT_CALL_RETRY_DELAY, true
+    );
+
+    String target = "dns:///example.com";
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetrics, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource);
+    OpenTelemetryMetricsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new OpenTelemetryMetricsModule.CallAttemptsTracerFactory(module, target,
+            method.getFullMethodName(), emptyList());
+
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+    fakeClock.forwardTime(154, TimeUnit.MILLISECONDS);
+    tracer.streamClosed(Status.UNAVAILABLE);
+
+    fakeClock.forwardTime(1000, TimeUnit.MILLISECONDS);
+    tracer = callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+    fakeClock.forwardTime(100, TimeUnit.MILLISECONDS);
+    tracer.streamClosed(Status.NOT_FOUND);
+
+    fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+    tracer = callAttemptsTracerFactory.newClientStreamTracer(
+        STREAM_INFO.toBuilder().setIsTransparentRetry(true).build(), new Metadata());
+    fakeClock.forwardTime(32, MILLISECONDS);
+    tracer.streamClosed(Status.UNAVAILABLE);
+
+    fakeClock.forwardTime(10, MILLISECONDS);
+    tracer = callAttemptsTracerFactory.newClientStreamTracer(
+        STREAM_INFO.toBuilder().setIsTransparentRetry(true).build(), new Metadata());
+    tracer.inboundWireSize(33);
+    fakeClock.forwardTime(24, MILLISECONDS);
+    tracer.streamClosed(Status.OK); // RPC succeeded
+
+    // --- The overall call ends ---
+    callAttemptsTracerFactory.callEnded(Status.OK);
+
+    // Define attributes for assertions
+    io.opentelemetry.api.common.Attributes finalAttributes
+        = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName());
+
+    // FINAL ASSERTION BLOCK
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            // Default metrics
+            metric -> assertThat(metric).hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME),
+            metric -> assertThat(metric).hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME),
+            metric -> assertThat(metric).hasName(CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE),
+            metric -> assertThat(metric).hasName(CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE),
+            metric -> assertThat(metric).hasName(CLIENT_CALL_DURATION),
+
+            // --- Assertions for the retry metrics ---
+            metric -> assertThat(metric)
+                .hasName(CLIENT_CALL_RETRIES)
+                .hasUnit("{retry}")
+                .hasHistogramSatisfying(histogram -> histogram.hasPointsSatisfying(
+                    point -> point
+                        .hasCount(1)
+                        .hasSum(1) // We faked one standard retry
+                        .hasAttributes(finalAttributes))),
+            metric -> assertThat(metric)
+                .hasName(CLIENT_CALL_TRANSPARENT_RETRIES)
+                .hasUnit("{transparent_retry}")
+                .hasHistogramSatisfying(histogram -> histogram.hasPointsSatisfying(
+                    point -> point
+                        .hasCount(1)
+                        .hasSum(2) // We faked two transparent retries
+                        .hasAttributes(finalAttributes))),
+            metric -> assertThat(metric)
+                .hasName(CLIENT_CALL_RETRY_DELAY)
+                .hasUnit("s")
+                .hasHistogramSatisfying(histogram -> histogram.hasPointsSatisfying(
+                    point -> point
+                        .hasCount(1)
+                        .hasSum(1.02) // 1000ms + 10ms + 10ms
+                        .hasAttributes(finalAttributes)))
+        );
+  }
+
+  @Test
+  public void recordAttemptMetrics_withHedgedCalls() {
+    // Enable the retry metrics, including hedges
+    Map<String, Boolean> enabledMetrics = ImmutableMap.of(
+        CLIENT_CALL_RETRIES, true,
+        CLIENT_CALL_TRANSPARENT_RETRIES, true,
+        CLIENT_CALL_HEDGES, true,
+        CLIENT_CALL_RETRY_DELAY, true
+    );
+
+    String target = "dns:///example.com";
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetrics, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource);
+    OpenTelemetryMetricsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new OpenTelemetryMetricsModule.CallAttemptsTracerFactory(module, target,
+            method.getFullMethodName(), emptyList());
+
+    // Create a StreamInfo specifically for hedged attempts
+    final ClientStreamTracer.StreamInfo hedgedStreamInfo =
+        STREAM_INFO.toBuilder().setIsHedging(true).build();
+
+    // --- First attempt starts ---
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+
+    // --- Faking a hedged attempt ---
+    fakeClock.forwardTime(10, TimeUnit.MILLISECONDS); // Hedging delay
+    ClientStreamTracer hedgeTracer1 =
+        callAttemptsTracerFactory.newClientStreamTracer(hedgedStreamInfo, new Metadata());
+
+    // --- Faking a second hedged attempt ---
+    fakeClock.forwardTime(20, TimeUnit.MILLISECONDS); // Another hedging delay
+    ClientStreamTracer hedgeTracer2 =
+        callAttemptsTracerFactory.newClientStreamTracer(hedgedStreamInfo, new Metadata());
+
+    // --- Let the attempts resolve ---
+    fakeClock.forwardTime(50, TimeUnit.MILLISECONDS);
+    // Initial attempt is cancelled because a hedge will succeed
+    tracer.streamClosed(Status.CANCELLED);
+    hedgeTracer1.streamClosed(Status.UNAVAILABLE); // First hedge fails
+
+    fakeClock.forwardTime(30, TimeUnit.MILLISECONDS);
+    hedgeTracer2.streamClosed(Status.OK); // Second hedge succeeds
+
+    // --- The overall call ends ---
+    callAttemptsTracerFactory.callEnded(Status.OK);
+
+    // Define attributes for assertions
+    io.opentelemetry.api.common.Attributes finalAttributes
+        = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName());
+
+    // FINAL ASSERTION BLOCK
+    // We expect 7 metrics: 5 default + hedges + retry_delay.
+    // Retries and transparent_retries are 0 and will not be reported.
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            // Default metrics
+            metric -> assertThat(metric).hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME),
+            metric -> assertThat(metric).hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME),
+            metric -> assertThat(metric).hasName(CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE),
+            metric -> assertThat(metric).hasName(CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE),
+            metric -> assertThat(metric).hasName(CLIENT_CALL_DURATION),
+
+            // --- Assertions for the NEW metrics ---
+            metric -> assertThat(metric)
+                .hasName(CLIENT_CALL_HEDGES)
+                .hasUnit("{hedge}")
+                .hasHistogramSatisfying(histogram -> histogram.hasPointsSatisfying(
+                    point -> point
+                        .hasCount(1)
+                        .hasSum(2)
+                        .hasAttributes(finalAttributes))),
+            metric -> assertThat(metric)
+                .hasName(CLIENT_CALL_RETRY_DELAY)
+                .hasUnit("s")
+                .hasHistogramSatisfying(
+                    histogram ->
+                        histogram.hasPointsSatisfying(
+                            point ->
+                                point
+                                    .hasCount(1)
+                                    .hasSum(0)
+                                    .hasAttributes(finalAttributes)))
+        );
+  }
+
+  @Test
+  public void clientStreamNeverCreatedStillRecordMetrics() {
+    String target = "dns:///foo.example.com";
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource);
+    OpenTelemetryMetricsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new OpenTelemetryMetricsModule.CallAttemptsTracerFactory(module, target,
+            method.getFullMethodName(), emptyList());
+    fakeClock.forwardTime(3000, MILLISECONDS);
+    Status status = Status.DEADLINE_EXCEEDED.withDescription("5 seconds");
+    callAttemptsTracerFactory.callEnded(status);
+
+    io.opentelemetry.api.common.Attributes attemptStartedAttributes
+        = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName());
+
+    io.opentelemetry.api.common.Attributes clientAttributes
+        = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName(),
+        STATUS_KEY,
+        Code.DEADLINE_EXCEEDED.toString());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasUnit("{attempt}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasValue(1)
+                                            .hasAttributes(attemptStartedAttributes))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(sizeBuckets))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_CALL_DURATION)
+                    .hasUnit("s")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(3D)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(latencyBuckets))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME)
+                    .hasUnit("s")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0)
+                                        .hasAttributes(clientAttributes)
+                                        .hasBucketBoundaries(latencyBuckets))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram
+                                .isCumulative()
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasCount(1)
+                                            .hasSum(0)
+                                            .hasAttributes(clientAttributes)
+                                            .hasBucketBoundaries(sizeBuckets))));
+
+  }
+
+  @Test
+  public void clientLocalityMetrics_present() {
+    String target = "target:///";
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = new OpenTelemetryMetricsModule(
+        fakeClock.getStopwatchSupplier(), resource, Arrays.asList("grpc.lb.locality"), emptyList());
+    OpenTelemetryMetricsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CallAttemptsTracerFactory(module, target, method.getFullMethodName(), emptyList());
+
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+    tracer.addOptionalLabel("grpc.lb.foo", "unimportant");
+    tracer.addOptionalLabel("grpc.lb.locality", "should-be-overwritten");
+    tracer.addOptionalLabel("grpc.lb.locality", "the-moon");
+    tracer.addOptionalLabel("grpc.lb.foo", "thats-no-moon");
+    tracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK);
+
+    io.opentelemetry.api.common.Attributes attributes = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName());
+
+    io.opentelemetry.api.common.Attributes clientAttributes
+        = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName(),
+        STATUS_KEY, Status.Code.OK.toString());
+
+    io.opentelemetry.api.common.Attributes clientAttributesWithLocality
+        = clientAttributes.toBuilder()
+        .put(LOCALITY_KEY, "the-moon")
+        .build();
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasLongSumSatisfying(
+                        longSum -> longSum.hasPointsSatisfying(
+                            point -> point.hasAttributes(attributes))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributesWithLocality))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributesWithLocality))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributesWithLocality))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_CALL_DURATION)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributes))));
+  }
+
+  @Test
+  public void clientLocalityMetrics_missing() {
+    String target = "target:///";
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = new OpenTelemetryMetricsModule(
+        fakeClock.getStopwatchSupplier(), resource, Arrays.asList("grpc.lb.locality"), emptyList());
+    OpenTelemetryMetricsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CallAttemptsTracerFactory(module, target, method.getFullMethodName(), emptyList());
+
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+    tracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK);
+
+    io.opentelemetry.api.common.Attributes attributes = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName());
+
+    io.opentelemetry.api.common.Attributes clientAttributes
+        = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName(),
+        STATUS_KEY, Status.Code.OK.toString());
+
+    io.opentelemetry.api.common.Attributes clientAttributesWithLocality
+        = clientAttributes.toBuilder()
+        .put(LOCALITY_KEY, "")
+        .build();
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasLongSumSatisfying(
+                        longSum -> longSum.hasPointsSatisfying(
+                            point -> point.hasAttributes(attributes))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributesWithLocality))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributesWithLocality))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributesWithLocality))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_CALL_DURATION)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributes))));
+  }
+
+  @Test
+  public void clientBackendServiceMetrics_present() {
+    String target = "target:///";
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = new OpenTelemetryMetricsModule(
+        fakeClock.getStopwatchSupplier(), resource, Arrays.asList("grpc.lb.backend_service"),
+        emptyList());
+    OpenTelemetryMetricsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CallAttemptsTracerFactory(module, target, method.getFullMethodName(), emptyList());
+
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+    tracer.addOptionalLabel("grpc.lb.foo", "unimportant");
+    tracer.addOptionalLabel("grpc.lb.backend_service", "should-be-overwritten");
+    tracer.addOptionalLabel("grpc.lb.backend_service", "the-moon");
+    tracer.addOptionalLabel("grpc.lb.foo", "thats-no-moon");
+    tracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK);
+
+    io.opentelemetry.api.common.Attributes attributes = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName());
+
+    io.opentelemetry.api.common.Attributes clientAttributes
+        = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName(),
+        STATUS_KEY, Status.Code.OK.toString());
+
+    io.opentelemetry.api.common.Attributes clientAttributesWithBackendService
+        = clientAttributes.toBuilder()
+        .put(AttributeKey.stringKey("grpc.lb.backend_service"), "the-moon")
+        .build();
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasLongSumSatisfying(
+                        longSum -> longSum.hasPointsSatisfying(
+                            point -> point.hasAttributes(attributes))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributesWithBackendService))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributesWithBackendService))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributesWithBackendService))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_CALL_DURATION)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributes))));
+  }
+
+  @Test
+  public void clientBackendServiceMetrics_missing() {
+    String target = "target:///";
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = new OpenTelemetryMetricsModule(
+        fakeClock.getStopwatchSupplier(), resource, Arrays.asList("grpc.lb.backend_service"),
+        emptyList());
+    OpenTelemetryMetricsModule.CallAttemptsTracerFactory callAttemptsTracerFactory =
+        new CallAttemptsTracerFactory(module, target, method.getFullMethodName(), emptyList());
+
+    ClientStreamTracer tracer =
+        callAttemptsTracerFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+    tracer.streamClosed(Status.OK);
+    callAttemptsTracerFactory.callEnded(Status.OK);
+
+    io.opentelemetry.api.common.Attributes attributes = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName());
+
+    io.opentelemetry.api.common.Attributes clientAttributes
+        = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName(),
+        STATUS_KEY, Status.Code.OK.toString());
+
+    io.opentelemetry.api.common.Attributes clientAttributesWithBackendService
+        = clientAttributes.toBuilder()
+        .put(AttributeKey.stringKey("grpc.lb.backend_service"), "")
+        .build();
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasLongSumSatisfying(
+                        longSum -> longSum.hasPointsSatisfying(
+                            point -> point.hasAttributes(attributes))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_DURATION_INSTRUMENT_NAME)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributesWithBackendService))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributesWithBackendService))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_ATTEMPT_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributesWithBackendService))),
+            metric ->
+                assertThat(metric)
+                    .hasName(CLIENT_CALL_DURATION)
+                    .hasHistogramSatisfying(
+                        histogram -> histogram.hasPointsSatisfying(
+                            point -> point.hasAttributes(clientAttributes))));
+  }
+
+  @Test
+  public void serverBasicMetrics() {
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource);
+    ServerStreamTracer.Factory tracerFactory = module.getServerTracerFactory();
+    ServerStreamTracer tracer =
+        tracerFactory.newServerStreamTracer(method.getFullMethodName(), new Metadata());
+    tracer.serverCallStarted(
+        new CallInfo<>(method, Attributes.EMPTY, null));
+
+    io.opentelemetry.api.common.Attributes attributes = io.opentelemetry.api.common.Attributes.of(
+        METHOD_KEY, method.getFullMethodName());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactly(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(SERVER_CALL_COUNT)
+                    .hasUnit("{call}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasAttributes(attributes)
+                                            .hasValue(1))));
+
+    tracer.inboundMessage(0);
+    tracer.inboundWireSize(34);
+    fakeClock.forwardTime(100, MILLISECONDS);
+    tracer.outboundMessage(0);
+    tracer.outboundWireSize(1028);
+    fakeClock.forwardTime(16, MILLISECONDS);
+    tracer.inboundMessage(1);
+    tracer.inboundWireSize(154);
+    tracer.outboundMessage(1);
+    tracer.outboundWireSize(99);
+    fakeClock.forwardTime(24, MILLISECONDS);
+    tracer.streamClosed(Status.CANCELLED);
+
+    io.opentelemetry.api.common.Attributes serverAttributes
+        = io.opentelemetry.api.common.Attributes.of(
+        METHOD_KEY, method.getFullMethodName(),
+        STATUS_KEY, Code.CANCELLED.toString());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .satisfiesExactlyInAnyOrder(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        SERVER_CALL_SENT_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(1028L + 99)
+                                        .hasAttributes(serverAttributes)
+                                        .hasBucketBoundaries(sizeBuckets)
+                                        .hasBucketCounts(0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                            0))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(SERVER_CALL_COUNT)
+                    .hasUnit("{call}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasAttributes(attributes)
+                                            .hasValue(1))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(SERVER_CALL_DURATION)
+                    .hasUnit("s")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram.hasPointsSatisfying(
+                                point ->
+                                    point
+                                        .hasCount(1)
+                                        .hasSum(0.1 + 0.016 + 0.024)
+                                        .hasAttributes(serverAttributes)
+                                        .hasBucketBoundaries(latencyBuckets)
+                                        .hasBucketCounts(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
+                                            0, 0, 0, 0, 0, 0, 0, 0, 0))),
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(
+                        SERVER_CALL_RECV_TOTAL_COMPRESSED_MESSAGE_SIZE)
+                    .hasUnit("By")
+                    .hasHistogramSatisfying(
+                        histogram ->
+                            histogram
+                                .isCumulative()
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasCount(1)
+                                            .hasSum(34L + 154)
+                                            .hasAttributes(serverAttributes)
+                                            .hasBucketBoundaries(sizeBuckets)
+                                            .hasBucketCounts(0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                                0, 0))));
+
+  }
+
+  @Test
+  public void serverBaggagePropagationToMetrics() {
+    // 1. Create module and tracer factory using the mock resource
+    OpenTelemetryMetricsModule module = new OpenTelemetryMetricsModule(
+        fakeClock.getStopwatchSupplier(), resource, emptyList(), emptyList());
+    ServerStreamTracer.Factory tracerFactory = module.getServerTracerFactory();
+    ServerStreamTracer tracer =
+        tracerFactory.newServerStreamTracer(method.getFullMethodName(), new Metadata());
+
+    // 2. Define the test baggage and gRPC context
+    Baggage testBaggage = Baggage.builder()
+        .put("user-id", "67")
+        .build();
+
+    // This simulates the context that the Tracing module would have created
+    io.grpc.Context grpcContext = io.grpc.Context.current()
+        .withValue(OpenTelemetryConstants.BAGGAGE_KEY, testBaggage);
+
+    // 3. Attach the gRPC context, trigger metric recording, and detach
+    io.grpc.Context previousContext = grpcContext.attach();
+    try {
+      tracer.streamClosed(Status.OK);
+    } finally {
+      grpcContext.detach(previousContext);
+    }
+
+    // 4. Verify the record call and capture the OTel Context
+    verify(mockServerCallDurationHistogram).record(
+        anyDouble(),
+        any(io.opentelemetry.api.common.Attributes.class),
+        contextCaptor.capture());
+
+    // 5. Assert on the captured OTel Context
+    io.opentelemetry.context.Context capturedOtelContext = contextCaptor.getValue();
+    Baggage capturedBaggage = Baggage.fromContext(capturedOtelContext);
+
+    assertEquals("67", capturedBaggage.getEntryValue("user-id"));
+  }
+
+  @Test
+  public void targetAttributeFilter_notSet_usesOriginalTarget() {
+    // Test that when no filter is set, the original target is used
+    String target = "dns:///example.com";
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource);
+
+    Channel interceptedChannel =
+        ClientInterceptors.intercept(
+            grpcServerRule.getChannel(), module.getClientInterceptor(target));
+
+    ClientCall<String, String> call = interceptedChannel.newCall(method, CALL_OPTIONS);
+
+    // Make the call
+    Metadata headers = new Metadata();
+    call.start(mockClientCallListener, headers);
+
+    // End the call
+    call.halfClose();
+    call.request(1);
+
+    io.opentelemetry.api.common.Attributes attributes = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .anySatisfy(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasUnit("{attempt}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasAttributes(attributes))));
+  }
+
+  @Test
+  public void targetAttributeFilter_allowsTarget_usesOriginalTarget() {
+    // Test that when filter allows the target, the original target is used
+    String target = "dns:///example.com";
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource,
+        t -> t.contains("example.com"));
+
+    Channel interceptedChannel =
+        ClientInterceptors.intercept(
+            grpcServerRule.getChannel(), module.getClientInterceptor(target));
+
+    ClientCall<String, String> call = interceptedChannel.newCall(method, CALL_OPTIONS);
+
+    // Make the call
+    Metadata headers = new Metadata();
+    call.start(mockClientCallListener, headers);
+
+    // End the call
+    call.halfClose();
+    call.request(1);
+
+    io.opentelemetry.api.common.Attributes attributes = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, target,
+        METHOD_KEY, method.getFullMethodName());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .anySatisfy(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasUnit("{attempt}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasAttributes(attributes))));
+  }
+
+  @Test
+  public void targetAttributeFilter_rejectsTarget_mapsToOther() {
+    // Test that when filter rejects the target, it is mapped to "other"
+    String target = "dns:///example.com";
+    OpenTelemetryMetricsResource resource = GrpcOpenTelemetry.createMetricInstruments(testMeter,
+        enabledMetricsMap, disableDefaultMetrics);
+    OpenTelemetryMetricsModule module = newOpenTelemetryMetricsModule(resource,
+        t -> t.contains("allowed.com"));
+
+    Channel interceptedChannel =
+        ClientInterceptors.intercept(
+            grpcServerRule.getChannel(), module.getClientInterceptor(target));
+
+    ClientCall<String, String> call = interceptedChannel.newCall(method, CALL_OPTIONS);
+
+    // Make the call
+    Metadata headers = new Metadata();
+    call.start(mockClientCallListener, headers);
+
+    // End the call
+    call.halfClose();
+    call.request(1);
+
+    io.opentelemetry.api.common.Attributes attributes = io.opentelemetry.api.common.Attributes.of(
+        TARGET_KEY, "other",
+        METHOD_KEY, method.getFullMethodName());
+
+    assertThat(openTelemetryTesting.getMetrics())
+        .anySatisfy(
+            metric ->
+                assertThat(metric)
+                    .hasInstrumentationScope(InstrumentationScopeInfo.create(
+                        OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+                    .hasName(CLIENT_ATTEMPT_COUNT_INSTRUMENT_NAME)
+                    .hasUnit("{attempt}")
+                    .hasLongSumSatisfying(
+                        longSum ->
+                            longSum
+                                .hasPointsSatisfying(
+                                    point ->
+                                        point
+                                            .hasAttributes(attributes))));
+  }
+
+  private OpenTelemetryMetricsModule newOpenTelemetryMetricsModule(
+      OpenTelemetryMetricsResource resource) {
+    return new OpenTelemetryMetricsModule(
+        fakeClock.getStopwatchSupplier(), resource, emptyList(), emptyList());
+  }
+
+  private OpenTelemetryMetricsModule newOpenTelemetryMetricsModule(
+      OpenTelemetryMetricsResource resource, TargetFilter filter) {
+    return new OpenTelemetryMetricsModule(
+        fakeClock.getStopwatchSupplier(), resource, emptyList(), emptyList(), filter);
+  }
+
+  static class CallInfo<ReqT, RespT> extends ServerCallInfo<ReqT, RespT> {
+    private final MethodDescriptor<ReqT, RespT> methodDescriptor;
+    private final Attributes attributes;
+    private final String authority;
+
+    CallInfo(
+        MethodDescriptor<ReqT, RespT> methodDescriptor,
+        Attributes attributes,
+        @Nullable String authority) {
+      this.methodDescriptor = methodDescriptor;
+      this.attributes = attributes;
+      this.authority = authority;
+    }
+
+    @Override
+    public MethodDescriptor<ReqT, RespT> getMethodDescriptor() {
+      return methodDescriptor;
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return attributes;
+    }
+
+    @Nullable
+    @Override
+    public String getAuthority() {
+      return authority;
+    }
+  }
+
+  @Test
+  public void serverBaggagePropagation_EndToEnd() throws Exception {
+    // 1. Create Both Modules
+    OpenTelemetry otel = openTelemetryTesting.getOpenTelemetry();
+    OpenTelemetryTracingModule tracingModule = new OpenTelemetryTracingModule(otel);
+    OpenTelemetryMetricsModule metricsModule = new OpenTelemetryMetricsModule(
+        fakeClock.getStopwatchSupplier(), resource, emptyList(), emptyList());
+
+    // 2. Create Server with *both* tracer factories
+    server = InProcessServerBuilder.forName(serverName)
+        .addService(new SimpleServiceImpl()) // <-- Uses the helper class below
+        .addStreamTracerFactory(tracingModule.getServerTracerFactory())
+        .addStreamTracerFactory(metricsModule.getServerTracerFactory())
+        .build()
+        .start();
+
+    // 3. Create Client Channel
+    channel = InProcessChannelBuilder.forName(serverName).directExecutor().build();
+
+    // 4. Manually create baggage headers
+    Metadata headers = new Metadata();
+    headers.put(Metadata.Key.of("baggage", Metadata.ASCII_STRING_MARSHALLER),
+        "choice=red_pill_or_blue_pill");
+
+    // 5. Make the gRPC call with these headers
+    ClientInterceptor headerAttachingInterceptor =
+        MetadataUtils.newAttachHeadersInterceptor(headers);
+
+    // Now, create the stub and apply that interceptor
+    SimpleServiceGrpc.SimpleServiceBlockingStub stub =
+        SimpleServiceGrpc.newBlockingStub(channel)
+            .withInterceptors(headerAttachingInterceptor);
+
+    // Use the imported SimpleRequest
+    stub.unaryRpc(SimpleRequest.getDefaultInstance());
+
+    // 6. Verify the Mock
+    verify(mockServerCallDurationHistogram).record(
+        anyDouble(),
+        any(io.opentelemetry.api.common.Attributes.class),
+        contextCaptor.capture());
+
+    // 7. Assert on the captured Context
+    io.opentelemetry.context.Context capturedOtelContext = contextCaptor.getValue();
+    Baggage capturedBaggage = Baggage.fromContext(capturedOtelContext);
+
+    assertEquals("red_pill_or_blue_pill", capturedBaggage.getEntryValue("choice"));
+  }
+
+  /**
+   * A simple service implementation for the E2E test.
+   */
+  private static class SimpleServiceImpl extends SimpleServiceGrpc.SimpleServiceImplBase {
+    @Override
+    public void unaryRpc(SimpleRequest request, StreamObserver<SimpleResponse> responseObserver) {
+      responseObserver.onNext(SimpleResponse.getDefaultInstance());
+      responseObserver.onCompleted();
+    }
+  }
+}
diff --git a/opentelemetry/src/test/java/io/grpc/opentelemetry/OpenTelemetryTracingModuleTest.java b/opentelemetry/src/test/java/io/grpc/opentelemetry/OpenTelemetryTracingModuleTest.java
new file mode 100644
index 00000000000..e6759aadb1e
--- /dev/null
+++ b/opentelemetry/src/test/java/io/grpc/opentelemetry/OpenTelemetryTracingModuleTest.java
@@ -0,0 +1,878 @@
+/*
+ * Copyright 2024 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.opentelemetry;
+
+import static io.grpc.ClientStreamTracer.NAME_RESOLUTION_DELAYED;
+import static io.grpc.opentelemetry.internal.OpenTelemetryConstants.BAGGAGE_KEY;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableSet;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientInterceptors;
+import io.grpc.ClientStreamTracer;
+import io.grpc.KnownLength;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.NoopServerCall;
+import io.grpc.Server;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerInterceptors;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.opentelemetry.OpenTelemetryTracingModule.CallAttemptsTracerFactory;
+import io.grpc.opentelemetry.internal.OpenTelemetryConstants;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.GrpcServerRule;
+import io.opentelemetry.api.OpenTelemetry;
+import io.opentelemetry.api.baggage.Baggage;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanBuilder;
+import io.opentelemetry.api.trace.SpanContext;
+import io.opentelemetry.api.trace.SpanId;
+import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.api.trace.TraceFlags;
+import io.opentelemetry.api.trace.TraceId;
+import io.opentelemetry.api.trace.TraceState;
+import io.opentelemetry.api.trace.Tracer;
+import io.opentelemetry.api.trace.TracerBuilder;
+import io.opentelemetry.api.trace.TracerProvider;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.Scope;
+import io.opentelemetry.context.propagation.ContextPropagators;
+import io.opentelemetry.context.propagation.TextMapPropagator;
+import io.opentelemetry.sdk.testing.junit4.OpenTelemetryRule;
+import io.opentelemetry.sdk.trace.data.EventData;
+import io.opentelemetry.sdk.trace.data.SpanData;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class OpenTelemetryTracingModuleTest {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private static final ClientStreamTracer.StreamInfo STREAM_INFO =
+      ClientStreamTracer.StreamInfo.newBuilder()
+          .setCallOptions(CallOptions.DEFAULT.withOption(NAME_RESOLUTION_DELAYED, 10L)).build();
+  private static final CallOptions.Key<String> CUSTOM_OPTION =
+      CallOptions.Key.createWithDefault("option1", "default");
+  private static final CallOptions CALL_OPTIONS =
+      CallOptions.DEFAULT.withOption(CUSTOM_OPTION, "customvalue");
+
+  private static class StringInputStream extends InputStream implements KnownLength {
+    final String string;
+
+    StringInputStream(String string) {
+      this.string = string;
+    }
+
+    @Override
+    public int read() {
+      // InProcessTransport doesn't actually read bytes from the InputStream. The InputStream is
+      // passed to the InProcess server and consumed by MARSHALLER.parse().
+      throw new UnsupportedOperationException("Should not be called");
+    }
+
+    @Override
+    public int available() throws IOException {
+      return string == null ? 0 : string.length();
+    }
+  }
+
+  private static final MethodDescriptor.Marshaller<String> MARSHALLER =
+      new MethodDescriptor.Marshaller<String>() {
+        @Override
+        public InputStream stream(String value) {
+          return new StringInputStream(value);
+        }
+
+        @Override
+        public String parse(InputStream stream) {
+          return ((StringInputStream) stream).string;
+        }
+      };
+
+  private final MethodDescriptor<String, String> method =
+      MethodDescriptor.<String, String>newBuilder()
+          .setType(MethodDescriptor.MethodType.UNKNOWN)
+          .setRequestMarshaller(MARSHALLER)
+          .setResponseMarshaller(MARSHALLER)
+          .setFullMethodName("package1.service2/method3")
+          .build();
+
+  @Rule
+  public final OpenTelemetryRule openTelemetryRule = OpenTelemetryRule.create();
+  @Rule
+  public final GrpcServerRule grpcServerRule = new GrpcServerRule().directExecutor();
+  @Rule
+  public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
+  private Tracer tracerRule;
+  @Mock
+  private Tracer mockTracer;
+  @Mock
+  TextMapPropagator mockPropagator;
+  @Mock
+  private Span mockClientSpan;
+  @Mock
+  private Span mockAttemptSpan;
+  @Mock
+  private ServerCall.Listener<String> mockServerCallListener;
+  @Mock
+  private ClientCall.Listener<String> mockClientCallListener;
+  @Mock
+  private SpanBuilder mockSpanBuilder;
+  @Mock
+  private OpenTelemetry mockOpenTelemetry;
+  @Captor
+  private ArgumentCaptor<String> eventNameCaptor;
+  @Captor
+  private ArgumentCaptor<io.opentelemetry.api.common.Attributes> attributesCaptor;
+  @Captor
+  private ArgumentCaptor<Status> statusCaptor;
+
+  @Before
+  public void setUp() {
+    tracerRule = openTelemetryRule.getOpenTelemetry().getTracer(
+        OpenTelemetryConstants.INSTRUMENTATION_SCOPE);
+    TracerProvider mockTracerProvider = mock(TracerProvider.class);
+    when(mockOpenTelemetry.getTracerProvider()).thenReturn(mockTracerProvider);
+    TracerBuilder mockTracerBuilder = mock(TracerBuilder.class);
+    when(mockTracerProvider.tracerBuilder(OpenTelemetryConstants.INSTRUMENTATION_SCOPE))
+        .thenReturn(mockTracerBuilder);
+    when(mockTracerBuilder.setInstrumentationVersion(any())).thenReturn(mockTracerBuilder);
+    when(mockTracerBuilder.build()).thenReturn(mockTracer);
+    when(mockOpenTelemetry.getPropagators()).thenReturn(ContextPropagators.create(mockPropagator));
+    when(mockSpanBuilder.startSpan()).thenReturn(mockAttemptSpan);
+    when(mockSpanBuilder.setParent(any())).thenReturn(mockSpanBuilder);
+    when(mockTracer.spanBuilder(any())).thenReturn(mockSpanBuilder);
+  }
+
+  // Use mock instead of OpenTelemetryRule to verify inOrder and propagator.
+  @Test
+  public void clientBasicTracingMocking() {
+    OpenTelemetryTracingModule tracingModule = new OpenTelemetryTracingModule(mockOpenTelemetry);
+    CallAttemptsTracerFactory callTracer =
+        tracingModule.newClientCallTracer(mockClientSpan, method);
+    Metadata headers = new Metadata();
+    ClientStreamTracer clientStreamTracer = callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    clientStreamTracer.createPendingStream();
+    clientStreamTracer.streamCreated(Attributes.EMPTY, headers);
+
+    verify(mockTracer).spanBuilder(eq("Attempt.package1.service2.method3"));
+    verify(mockPropagator).inject(any(), eq(headers), eq(MetadataSetter.getInstance()));
+    verify(mockClientSpan, never()).end();
+    verify(mockAttemptSpan, never()).end();
+
+    clientStreamTracer.outboundMessage(0);
+    clientStreamTracer.outboundMessageSent(0, 882, -1);
+    clientStreamTracer.inboundMessage(0);
+    clientStreamTracer.outboundMessage(1);
+    clientStreamTracer.outboundMessageSent(1, -1, 27);
+    clientStreamTracer.inboundMessageRead(0, 255, 90);
+
+    clientStreamTracer.streamClosed(Status.OK);
+    callTracer.callEnded(Status.OK);
+
+    InOrder inOrder = inOrder(mockClientSpan, mockAttemptSpan);
+    inOrder.verify(mockAttemptSpan)
+        .setAttribute("previous-rpc-attempts", 0);
+    inOrder.verify(mockAttemptSpan)
+        .setAttribute("transparent-retry", false);
+    inOrder.verify(mockClientSpan).addEvent("Delayed name resolution complete");
+    inOrder.verify(mockAttemptSpan).addEvent("Delayed LB pick complete");
+    inOrder.verify(mockAttemptSpan, times(3)).addEvent(
+        eventNameCaptor.capture(), attributesCaptor.capture()
+    );
+    List<String> events = eventNameCaptor.getAllValues();
+    List<io.opentelemetry.api.common.Attributes> attributes = attributesCaptor.getAllValues();
+    assertEquals(
+        "Outbound message" ,
+        events.get(0));
+    assertEquals(
+        io.opentelemetry.api.common.Attributes.builder()
+            .put("sequence-number", 0)
+            .put("message-size-compressed", 882)
+            .build(),
+        attributes.get(0));
+
+    assertEquals(
+        "Outbound message" ,
+        events.get(1));
+    assertEquals(
+        io.opentelemetry.api.common.Attributes.builder()
+            .put("sequence-number", 1)
+            .put("message-size", 27)
+            .build(),
+        attributes.get(1));
+
+    assertEquals(
+        "Inbound compressed message" ,
+        events.get(2));
+    assertEquals(
+        io.opentelemetry.api.common.Attributes.builder()
+            .put("sequence-number", 0)
+            .put("message-size-compressed", 255)
+            .build(),
+        attributes.get(2));
+
+    inOrder.verify(mockAttemptSpan).setStatus(StatusCode.OK);
+    inOrder.verify(mockAttemptSpan).end();
+    inOrder.verify(mockClientSpan).setStatus(StatusCode.OK);
+    inOrder.verify(mockClientSpan).end();
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void clientBasicTracingRule() {
+    OpenTelemetryTracingModule tracingModule = new OpenTelemetryTracingModule(
+        openTelemetryRule.getOpenTelemetry());
+    Span clientSpan = tracerRule.spanBuilder("test-client-span").startSpan();
+    CallAttemptsTracerFactory callTracer =
+        tracingModule.newClientCallTracer(clientSpan, method);
+    Metadata headers = new Metadata();
+    ClientStreamTracer clientStreamTracer = callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    clientStreamTracer.createPendingStream();
+    clientStreamTracer.streamCreated(Attributes.EMPTY, headers);
+    clientStreamTracer.outboundMessage(0);
+    clientStreamTracer.outboundMessageSent(0, 882, -1);
+    clientStreamTracer.inboundMessage(0);
+    clientStreamTracer.outboundMessage(1);
+    clientStreamTracer.outboundMessageSent(1, -1, 27);
+    clientStreamTracer.inboundMessageRead(0, 255, -1);
+    clientStreamTracer.inboundUncompressedSize(288);
+    clientStreamTracer.inboundMessageRead(1, 128, 128);
+    clientStreamTracer.inboundMessage(1);
+    clientStreamTracer.inboundUncompressedSize(128);
+
+    clientStreamTracer.streamClosed(Status.OK);
+    callTracer.callEnded(Status.OK);
+
+    List<SpanData> spans = openTelemetryRule.getSpans();
+    assertEquals(spans.size(), 2);
+    SpanData attemptSpanData = spans.get(0);
+    SpanData clientSpanData = spans.get(1);
+    assertEquals(attemptSpanData.getName(), "Attempt.package1.service2.method3");
+    assertEquals(clientSpanData.getName(), "test-client-span");
+    assertEquals(headers.keys(), ImmutableSet.of("traceparent"));
+    String spanContext = headers.get(
+        Metadata.Key.of("traceparent", Metadata.ASCII_STRING_MARSHALLER));
+    assertEquals(spanContext.substring(3, 3 + TraceId.getLength()),
+        spans.get(1).getSpanContext().getTraceId());
+
+    // parent(client) span data
+    List<EventData> clientSpanEvents = clientSpanData.getEvents();
+    assertEquals(clientSpanEvents.size(), 3);
+    assertEquals(
+        "Delayed name resolution complete",
+        clientSpanEvents.get(0).getName());
+    assertTrue(clientSpanEvents.get(0).getAttributes().isEmpty());
+
+    assertEquals(
+        "Inbound message" ,
+        clientSpanEvents.get(1).getName());
+    assertEquals(
+        io.opentelemetry.api.common.Attributes.builder()
+            .put("sequence-number", 0)
+            .put("message-size", 288)
+            .build(),
+        clientSpanEvents.get(1).getAttributes());
+
+    assertEquals(
+        "Inbound message" ,
+        clientSpanEvents.get(2).getName());
+    assertEquals(
+        io.opentelemetry.api.common.Attributes.builder()
+            .put("sequence-number", 1)
+            .put("message-size", 128)
+            .build(),
+        clientSpanEvents.get(2).getAttributes());
+    assertEquals(clientSpanData.hasEnded(), true);
+
+    // child(attempt) span data
+    List<EventData> attemptSpanEvents = attemptSpanData.getEvents();
+    assertEquals(clientSpanEvents.size(), 3);
+    assertEquals(
+        "Delayed LB pick complete",
+        attemptSpanEvents.get(0).getName());
+    assertTrue(clientSpanEvents.get(0).getAttributes().isEmpty());
+
+    assertEquals(
+        "Outbound message" ,
+        attemptSpanEvents.get(1).getName());
+    assertEquals(
+        io.opentelemetry.api.common.Attributes.builder()
+            .put("sequence-number", 0)
+            .put("message-size-compressed", 882)
+            .build(),
+        attemptSpanEvents.get(1).getAttributes());
+
+    assertEquals(
+        "Outbound message" ,
+        attemptSpanEvents.get(2).getName());
+    assertEquals(
+        io.opentelemetry.api.common.Attributes.builder()
+            .put("sequence-number", 1)
+            .put("message-size", 27)
+            .build(),
+        attemptSpanEvents.get(2).getAttributes());
+
+    assertEquals(
+        "Inbound compressed message" ,
+        attemptSpanEvents.get(3).getName());
+    assertEquals(
+        io.opentelemetry.api.common.Attributes.builder()
+            .put("sequence-number", 0)
+            .put("message-size-compressed", 255)
+            .build(),
+        attemptSpanEvents.get(3).getAttributes());
+
+    assertEquals(attemptSpanData.hasEnded(), true);
+  }
+
+  @Test
+  public void clientInterceptor() {
+    testClientInterceptors(false);
+  }
+
+  @Test
+  public void clientInterceptorNonDefaultOtelContext() {
+    testClientInterceptors(true);
+  }
+
+  private void testClientInterceptors(boolean nonDefaultOtelContext) {
+    final AtomicReference<Metadata> capturedMetadata = new AtomicReference<>();
+    grpcServerRule.getServiceRegistry().addService(
+        ServerServiceDefinition.builder("package1.service2").addMethod(
+            method, new ServerCallHandler<String, String>() {
+              @Override
+              public ServerCall.Listener<String> startCall(
+                  ServerCall<String, String> call, Metadata headers) {
+                capturedMetadata.set(headers);
+                call.sendHeaders(new Metadata());
+                call.sendMessage("Hello");
+                call.close(
+                    Status.PERMISSION_DENIED.withDescription("No you don't"), new Metadata());
+                return mockServerCallListener;
+              }
+            }).build());
+
+    final AtomicReference<CallOptions> capturedCallOptions = new AtomicReference<>();
+    ClientInterceptor callOptionsCaptureInterceptor = new ClientInterceptor() {
+      @Override
+      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+          MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+        capturedCallOptions.set(callOptions);
+        return next.newCall(method, callOptions);
+      }
+    };
+    OpenTelemetryTracingModule tracingModule = new OpenTelemetryTracingModule(
+        openTelemetryRule.getOpenTelemetry());
+    Channel interceptedChannel =
+        ClientInterceptors.intercept(
+            grpcServerRule.getChannel(), callOptionsCaptureInterceptor,
+            tracingModule.getClientInterceptor());
+    Span parentSpan = tracerRule.spanBuilder("test-parent-span").startSpan();
+    ClientCall<String, String> call;
+
+    if (nonDefaultOtelContext) {
+      try (Scope scope = io.opentelemetry.context.Context.current().with(parentSpan)
+          .makeCurrent()) {
+        call = interceptedChannel.newCall(method, CALL_OPTIONS);
+      }
+    } else {
+      call = interceptedChannel.newCall(method, CALL_OPTIONS);
+    }
+    assertEquals("customvalue", capturedCallOptions.get().getOption(CUSTOM_OPTION));
+    assertEquals(1, capturedCallOptions.get().getStreamTracerFactories().size());
+    assertTrue(
+        capturedCallOptions.get().getStreamTracerFactories().get(0)
+            instanceof CallAttemptsTracerFactory);
+
+    // Make the call
+    Metadata headers = new Metadata();
+    call.start(mockClientCallListener, headers);
+
+    // End the call
+    call.halfClose();
+    call.request(1);
+    parentSpan.end();
+
+    verify(mockClientCallListener).onClose(statusCaptor.capture(), any(Metadata.class));
+    Status status = statusCaptor.getValue();
+    assertEquals(Status.Code.PERMISSION_DENIED, status.getCode());
+    assertEquals("No you don't", status.getDescription());
+
+    List<SpanData> spans = openTelemetryRule.getSpans();
+    assertEquals(spans.size(), 3);
+
+    SpanData clientSpan = spans.get(1);
+    SpanData attemptSpan = spans.get(0);
+    if (nonDefaultOtelContext) {
+      assertEquals(clientSpan.getParentSpanContext(), parentSpan.getSpanContext());
+    } else {
+      assertEquals(clientSpan.getParentSpanContext(),
+          Span.fromContext(Context.root()).getSpanContext());
+    }
+    String spanContext = capturedMetadata.get().get(
+        Metadata.Key.of("traceparent", Metadata.ASCII_STRING_MARSHALLER));
+    // W3C format: 00-<trace id>-<span id>-<trace flag>
+    assertEquals(spanContext.substring(3, 3 + TraceId.getLength()),
+        attemptSpan.getSpanContext().getTraceId());
+    assertEquals(spanContext.substring(3 + TraceId.getLength() + 1,
+        3 + TraceId.getLength() + 1 + SpanId.getLength()),
+        attemptSpan.getSpanContext().getSpanId());
+
+    assertEquals(attemptSpan.getParentSpanContext(), clientSpan.getSpanContext());
+    assertTrue(clientSpan.hasEnded());
+    assertEquals(clientSpan.getStatus().getStatusCode(), StatusCode.ERROR);
+    assertEquals(clientSpan.getStatus().getDescription(), "PERMISSION_DENIED: No you don't");
+    assertTrue(attemptSpan.hasEnded());
+    assertTrue(attemptSpan.hasEnded());
+    assertEquals(attemptSpan.getStatus().getStatusCode(), StatusCode.ERROR);
+    assertEquals(attemptSpan.getStatus().getDescription(), "PERMISSION_DENIED: No you don't");
+  }
+
+  @Test
+  public void clientStreamNeverCreatedStillRecordTracing() {
+    OpenTelemetryTracingModule tracingModule = new OpenTelemetryTracingModule(
+        openTelemetryRule.getOpenTelemetry());
+    CallAttemptsTracerFactory callTracer =
+        tracingModule.newClientCallTracer(mockClientSpan, method);
+
+    callTracer.callEnded(Status.DEADLINE_EXCEEDED.withDescription("3 seconds"));
+    verify(mockClientSpan).end();
+    verify(mockClientSpan).setStatus(eq(StatusCode.ERROR),
+        eq("DEADLINE_EXCEEDED: 3 seconds"));
+    verifyNoMoreInteractions(mockClientSpan);
+  }
+
+  @Test
+  public void serverBasicTracingNoHeaders() {
+    OpenTelemetryTracingModule tracingModule = new OpenTelemetryTracingModule(
+        openTelemetryRule.getOpenTelemetry());
+    ServerStreamTracer.Factory tracerFactory = tracingModule.getServerTracerFactory();
+    ServerStreamTracer serverStreamTracer =
+        tracerFactory.newServerStreamTracer(method.getFullMethodName(), new Metadata());
+    assertSame(Span.fromContext(Context.current()), Span.getInvalid());
+
+    serverStreamTracer.outboundMessage(0);
+    serverStreamTracer.outboundMessageSent(0, 882, 998);
+    serverStreamTracer.inboundMessage(0);
+    serverStreamTracer.outboundMessage(1);
+    serverStreamTracer.outboundMessageSent(1, -1, 27);
+    serverStreamTracer.inboundMessageRead(0, 90, -1);
+    serverStreamTracer.inboundUncompressedSize(255);
+
+    serverStreamTracer.streamClosed(Status.CANCELLED);
+
+    List<SpanData> spans = openTelemetryRule.getSpans();
+    assertEquals(spans.size(), 1);
+    assertEquals(spans.get(0).getName(), "Recv.package1.service2.method3");
+    assertEquals(spans.get(0).getParentSpanContext(), Span.getInvalid().getSpanContext());
+
+    List<EventData> events = spans.get(0).getEvents();
+    assertEquals(events.size(), 4);
+    assertEquals(
+        "Outbound message" ,
+        events.get(0).getName());
+    assertEquals(
+        io.opentelemetry.api.common.Attributes.builder()
+            .put("sequence-number", 0)
+            .put("message-size-compressed", 882)
+            .put("message-size", 998)
+            .build(),
+        events.get(0).getAttributes());
+
+    assertEquals(
+        "Outbound message" ,
+        events.get(1).getName());
+    assertEquals(
+        io.opentelemetry.api.common.Attributes.builder()
+            .put("sequence-number", 1)
+            .put("message-size", 27)
+            .build(),
+        events.get(1).getAttributes());
+
+    assertEquals(
+        "Inbound compressed message" ,
+        events.get(2).getName());
+    assertEquals(
+        io.opentelemetry.api.common.Attributes.builder()
+            .put("sequence-number", 0)
+            .put("message-size-compressed", 90)
+            .build(),
+        events.get(2).getAttributes());
+
+    assertEquals(
+        "Inbound message" ,
+        events.get(3).getName());
+    assertEquals(
+        io.opentelemetry.api.common.Attributes.builder()
+            .put("sequence-number", 0)
+            .put("message-size", 255)
+            .build(),
+        events.get(3).getAttributes());
+
+    assertEquals(spans.get(0).hasEnded(), true);
+  }
+
+  @Test
+  public void grpcTraceBinPropagator() {
+    when(mockOpenTelemetry.getPropagators()).thenReturn(
+        ContextPropagators.create(GrpcTraceBinContextPropagator.defaultInstance()));
+    ArgumentCaptor<Context> contextArgumentCaptor = ArgumentCaptor.forClass(Context.class);
+    OpenTelemetryTracingModule tracingModule = new OpenTelemetryTracingModule(mockOpenTelemetry);
+    Span testClientSpan = tracerRule.spanBuilder("test-client-span").startSpan();
+    CallAttemptsTracerFactory callTracer =
+        tracingModule.newClientCallTracer(testClientSpan, method);
+    Span testAttemptSpan = tracerRule.spanBuilder("test-attempt-span").startSpan();
+    when(mockSpanBuilder.startSpan()).thenReturn(testAttemptSpan);
+
+    Metadata headers = new Metadata();
+    ClientStreamTracer clientStreamTracer = callTracer.newClientStreamTracer(STREAM_INFO, headers);
+    clientStreamTracer.streamCreated(Attributes.EMPTY, headers);
+    clientStreamTracer.streamClosed(Status.CANCELLED);
+
+    Metadata.Key<byte[]> key = Metadata.Key.of(
+        GrpcTraceBinContextPropagator.GRPC_TRACE_BIN_HEADER, Metadata.BINARY_BYTE_MARSHALLER);
+    assertTrue(Arrays.equals(BinaryFormat.getInstance().toBytes(testAttemptSpan.getSpanContext()),
+        headers.get(key)
+    ));
+    verify(mockSpanBuilder).setParent(contextArgumentCaptor.capture());
+    assertEquals(testClientSpan, Span.fromContext(contextArgumentCaptor.getValue()));
+
+    Span serverSpan = tracerRule.spanBuilder("test-server-span").startSpan();
+    when(mockSpanBuilder.startSpan()).thenReturn(serverSpan);
+    ServerStreamTracer.Factory tracerFactory = tracingModule.getServerTracerFactory();
+    ServerStreamTracer serverStreamTracer =
+        tracerFactory.newServerStreamTracer(method.getFullMethodName(), headers);
+    serverStreamTracer.streamClosed(Status.CANCELLED);
+
+    verify(mockSpanBuilder, times(2))
+        .setParent(contextArgumentCaptor.capture());
+    assertEquals(testAttemptSpan.getSpanContext(),
+        Span.fromContext(contextArgumentCaptor.getValue()).getSpanContext());
+  }
+
+  @Test
+  public void testServerParentSpanPropagation() throws Exception {
+    final AtomicReference<Span> applicationSpan = new AtomicReference<>();
+    OpenTelemetryTracingModule tracingModule = new OpenTelemetryTracingModule(
+        openTelemetryRule.getOpenTelemetry());
+    ServerServiceDefinition serviceDefinition =
+        ServerServiceDefinition.builder("package1.service2").addMethod(
+            method, new ServerCallHandler<String, String>() {
+              @Override
+              public ServerCall.Listener<String> startCall(
+                  ServerCall<String, String> call, Metadata headers) {
+                applicationSpan.set(Span.fromContext(Context.current()));
+                call.sendHeaders(new Metadata());
+                call.sendMessage("Hello");
+                call.close(
+                    Status.PERMISSION_DENIED.withDescription("No you don't"), new Metadata());
+                return mockServerCallListener;
+              }
+            }).build();
+
+    Server server = InProcessServerBuilder.forName("test-server-span")
+        .addService(
+            ServerInterceptors.intercept(serviceDefinition,
+                tracingModule.getServerSpanPropagationInterceptor()))
+        .addStreamTracerFactory(tracingModule.getServerTracerFactory())
+        .directExecutor().build().start();
+    grpcCleanupRule.register(server);
+
+    ManagedChannel channel = InProcessChannelBuilder.forName("test-server-span")
+        .directExecutor().build();
+    grpcCleanupRule.register(channel);
+
+    Span parentSpan = tracerRule.spanBuilder("test-parent-span").startSpan();
+    try (Scope scope = Context.current().with(parentSpan).makeCurrent()) {
+      Channel interceptedChannel =
+          ClientInterceptors.intercept(
+              channel, tracingModule.getClientInterceptor());
+      ClientCall<String, String> call = interceptedChannel.newCall(method, CALL_OPTIONS);
+      Metadata headers = new Metadata();
+      call.start(mockClientCallListener, headers);
+
+      // End the call
+      call.halfClose();
+      call.request(1);
+      parentSpan.end();
+    }
+
+    verify(mockClientCallListener).onClose(statusCaptor.capture(), any(Metadata.class));
+    Status rpcStatus = statusCaptor.getValue();
+    assertEquals(rpcStatus.getCode(), Status.Code.PERMISSION_DENIED);
+    assertEquals(rpcStatus.getDescription(), "No you don't");
+    assertEquals(applicationSpan.get().getSpanContext().getTraceId(),
+        parentSpan.getSpanContext().getTraceId());
+
+    List<SpanData> spans = openTelemetryRule.getSpans();
+    assertEquals(spans.size(), 4);
+    SpanData clientSpan = spans.get(2);
+    SpanData attemptSpan = spans.get(1);
+
+    assertEquals(clientSpan.getName(), "Sent.package1.service2.method3");
+    assertTrue(clientSpan.hasEnded());
+    assertEquals(clientSpan.getStatus().getStatusCode(), StatusCode.ERROR);
+    assertEquals(clientSpan.getStatus().getDescription(), "PERMISSION_DENIED: No you don't");
+
+    assertEquals(attemptSpan.getName(), "Attempt.package1.service2.method3");
+    assertTrue(attemptSpan.hasEnded());
+    assertEquals(attemptSpan.getStatus().getStatusCode(), StatusCode.ERROR);
+    assertEquals(attemptSpan.getStatus().getDescription(), "PERMISSION_DENIED: No you don't");
+
+    SpanData serverSpan = spans.get(0);
+    assertEquals(serverSpan.getName(), "Recv.package1.service2.method3");
+    assertTrue(serverSpan.hasEnded());
+    assertEquals(serverSpan.getStatus().getStatusCode(), StatusCode.ERROR);
+    assertEquals(serverSpan.getStatus().getDescription(), "PERMISSION_DENIED: No you don't");
+  }
+
+  @Test
+  public void serverSpanPropagationInterceptor() throws Exception {
+    OpenTelemetryTracingModule tracingModule = new OpenTelemetryTracingModule(
+        openTelemetryRule.getOpenTelemetry());
+    Server server = InProcessServerBuilder.forName("test-span-propagation-interceptor")
+        .directExecutor().build().start();
+    grpcCleanupRule.register(server);
+    final AtomicReference<Span> callbackSpan = new AtomicReference<>();
+    ServerCall.Listener<Integer> getContextListener = new ServerCall.Listener<Integer>() {
+      @Override
+      public void onMessage(Integer message) {
+        callbackSpan.set(Span.fromContext(Context.current()));
+      }
+
+      @Override
+      public void onHalfClose() {
+        callbackSpan.set(Span.fromContext(Context.current()));
+      }
+
+      @Override
+      public void onCancel() {
+        callbackSpan.set(Span.fromContext(Context.current()));
+      }
+
+      @Override
+      public void onComplete() {
+        callbackSpan.set(Span.fromContext(Context.current()));
+      }
+    };
+    ServerInterceptor interceptor = tracingModule.getServerSpanPropagationInterceptor();
+    @SuppressWarnings("unchecked")
+    ServerCallHandler<Integer, Integer> handler = mock(ServerCallHandler.class);
+    when(handler.startCall(any(), any())).thenReturn(getContextListener);
+    ServerCall<Integer, Integer> call = new NoopServerCall<>();
+    Metadata metadata = new Metadata();
+    ServerCall.Listener<Integer> listener = interceptor.interceptCall(call, metadata, handler);
+    verify(handler).startCall(same(call), same(metadata));
+    listener.onMessage(1);
+    assertEquals(callbackSpan.get(), Span.getInvalid());
+    listener.onReady();
+    assertEquals(callbackSpan.get(), Span.getInvalid());
+    listener.onCancel();
+    assertEquals(callbackSpan.get(), Span.getInvalid());
+    listener.onHalfClose();
+    assertEquals(callbackSpan.get(), Span.getInvalid());
+    listener.onComplete();
+    assertEquals(callbackSpan.get(), Span.getInvalid());
+
+    Span parentSpan = tracerRule.spanBuilder("parent-span").startSpan();
+    io.grpc.Context context = io.grpc.Context.current().withValue(
+        tracingModule.otelSpan, parentSpan);
+    io.grpc.Context previous = context.attach();
+    try {
+      listener = interceptor.interceptCall(call, metadata, handler);
+      verify(handler, times(2)).startCall(same(call), same(metadata));
+      listener.onMessage(1);
+      assertEquals(callbackSpan.get().getSpanContext().getTraceId(),
+          parentSpan.getSpanContext().getTraceId());
+      listener.onReady();
+      assertEquals(callbackSpan.get().getSpanContext().getTraceId(),
+          parentSpan.getSpanContext().getTraceId());
+      listener.onCancel();
+      assertEquals(callbackSpan.get().getSpanContext().getTraceId(),
+          parentSpan.getSpanContext().getTraceId());
+      listener.onHalfClose();
+      assertEquals(callbackSpan.get().getSpanContext().getTraceId(),
+          parentSpan.getSpanContext().getTraceId());
+      listener.onComplete();
+      assertEquals(callbackSpan.get().getSpanContext().getTraceId(),
+          parentSpan.getSpanContext().getTraceId());
+    } finally {
+      context.detach(previous);
+    }
+  }
+
+  /**
+   * Tests that baggage from the initial context is propagated
+   * to the context active during the next handler's execution.
+   */
+  @Test
+  public void testBaggageIsPropagatedToHandlerContext() {
+    // 1. ARRANGE
+    OpenTelemetryTracingModule tracingModule = new OpenTelemetryTracingModule(
+        openTelemetryRule.getOpenTelemetry());
+    ServerInterceptor interceptor = tracingModule.getServerSpanPropagationInterceptor();
+
+    // Create mocks for the gRPC call chain
+    @SuppressWarnings("unchecked")
+    ServerCallHandler<String, String> mockHandler = mock(ServerCallHandler.class);
+    @SuppressWarnings("unchecked")
+    ServerCall.Listener<String> mockListener = mock(ServerCall.Listener.class);
+    ServerCall<String, String> mockCall = new NoopServerCall<>();
+    Metadata mockHeaders = new Metadata();
+
+    // Create a non-null Span (required to pass the first 'if' check)
+    Span testSpan = Span.wrap(
+        SpanContext.create("time-period", "star-wars",
+            TraceFlags.getSampled(), TraceState.getDefault()));
+
+    // Create the test Baggage
+    Baggage testBaggage = Baggage.builder().put("best-bot", "R2D2").build();
+
+    // Create the initial gRPC context that the interceptor will read from
+    io.grpc.Context initialGrpcContext = io.grpc.Context.current()
+        .withValue(tracingModule.otelSpan, testSpan)
+        .withValue(BAGGAGE_KEY, testBaggage);
+
+    // This AtomicReference will capture the Baggage from *within* the handler
+    final AtomicReference<Baggage> capturedBaggage = new AtomicReference<>();
+
+    // Stub the handler to capture the *current* context when it's called
+    doAnswer(invocation -> {
+      // Baggage.current() gets baggage from io.opentelemetry.context.Context.current()
+      capturedBaggage.set(Baggage.current());
+      return mockListener;
+    }).when(mockHandler).startCall(any(), any());
+
+    // 2. ACT
+    // Run the interceptCall method within the prepared context
+    io.grpc.Context previous = initialGrpcContext.attach();
+    try {
+      interceptor.interceptCall(mockCall, mockHeaders, mockHandler);
+    } finally {
+      initialGrpcContext.detach(previous);
+    }
+
+    // 3. ASSERT
+    // Verify the next handler was called
+    verify(mockHandler).startCall(same(mockCall), same(mockHeaders));
+
+    // Check the baggage that was captured
+    assertNotNull("Baggage should not be null in handler context", capturedBaggage.get());
+    assertEquals("Baggage was not correctly propagated to the handler's context",
+        "R2D2", capturedBaggage.get().getEntryValue("best-bot"));
+  }
+
+  /**
+   * Tests that the interceptor proceeds correctly if baggage is null or empty.
+   */
+  @Test
+  public void testNullBaggageIsHandledGracefully() {
+    // 1. ARRANGE
+    OpenTelemetryTracingModule tracingModule = new OpenTelemetryTracingModule(
+        openTelemetryRule.getOpenTelemetry());
+    ServerInterceptor interceptor = tracingModule.getServerSpanPropagationInterceptor();
+
+    @SuppressWarnings("unchecked")
+    ServerCallHandler<String, String> mockHandler = mock(ServerCallHandler.class);
+    @SuppressWarnings("unchecked")
+    ServerCall.Listener<String> mockListener = mock(ServerCall.Listener.class);
+    ServerCall<String, String> mockCall = new NoopServerCall<>();
+    Metadata mockHeaders = new Metadata();
+
+    Span testSpan = Span.getInvalid(); // A non-null span
+
+    // No baggage is set in the context
+    io.grpc.Context initialGrpcContext = io.grpc.Context.current()
+        .withValue(tracingModule.otelSpan, testSpan);
+
+    final AtomicReference<Baggage> capturedBaggage = new AtomicReference<>();
+
+    // Stub the handler to capture the *current* context when it's called
+    doAnswer(invocation -> {
+      // Baggage.current() gets baggage from io.opentelemetry.context.Context.current()
+      capturedBaggage.set(Baggage.current());
+      return mockListener;
+    }).when(mockHandler).startCall(any(), any());
+
+    // 2. ACT
+    io.grpc.Context previous = initialGrpcContext.attach();
+    try {
+      interceptor.interceptCall(mockCall, mockHeaders, mockHandler);
+    } finally {
+      initialGrpcContext.detach(previous);
+    }
+
+    // 3. ASSERT
+    verify(mockHandler).startCall(same(mockCall), same(mockHeaders));
+
+    // Baggage should be null in the downstream context
+    assertEquals("Baggage should be empty when not provided",
+        Baggage.empty(), capturedBaggage.get());
+  }
+
+  @Test
+  public void generateTraceSpanName() {
+    assertEquals(
+        "Sent.io.grpc.Foo", OpenTelemetryTracingModule.generateTraceSpanName(
+            false, "io.grpc/Foo"));
+    assertEquals(
+        "Recv.io.grpc.Bar", OpenTelemetryTracingModule.generateTraceSpanName(
+            true, "io.grpc/Bar"));
+  }
+}
diff --git a/protobuf-lite/BUILD.bazel b/protobuf-lite/BUILD.bazel
new file mode 100644
index 00000000000..97a5e492d80
--- /dev/null
+++ b/protobuf-lite/BUILD.bazel
@@ -0,0 +1,29 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "protobuf-lite",
+    srcs = glob([
+        "src/main/java/**/*.java",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
+    ] + select({
+        ":android": ["@com_google_protobuf//:protobuf_javalite"],
+        "//conditions:default": ["@com_google_protobuf//:protobuf_java"],
+    }),
+)
+
+# This config is not fully-reliable. If it breaks, it is probably because you
+# are changing --android_crosstool_top. Instead of doing that, you can bind
+# your own toolchain on top of the default android/crosstool, as mentioned at
+# https://github.com/bazelbuild/bazel/issues/3924#issuecomment-338704582
+config_setting(
+    name = "android",
+    values = {
+        "crosstool_top": "//external:android/crosstool",
+    },
+)
diff --git a/protobuf-lite/build.gradle b/protobuf-lite/build.gradle
index 9d55933ee5c..c1e5b51ae35 100644
--- a/protobuf-lite/build.gradle
+++ b/protobuf-lite/build.gradle
@@ -1,57 +1,60 @@
-buildscript {
-    repositories {
-        mavenCentral()
-        mavenLocal()
-    }
-    dependencies {
-        classpath libraries.protobuf_plugin
-    }
-}
+plugins {
+    id "java-library"
+    id "maven-publish"
 
-apply plugin: 'com.google.protobuf'
+    id "com.google.protobuf"
+    id "me.champeau.gradle.japicmp"
+    id "ru.vyarus.animalsniffer"
+}
 
 description = 'gRPC: Protobuf Lite'
 
 dependencies {
-    compile project(':grpc-core'),
-            libraries.protobuf_lite,
+    api project(':grpc-api'),
+            libraries.protobuf.javalite
+    implementation libraries.jsr305,
             libraries.guava
 
-    testProtobuf libraries.protobuf
+    testImplementation project(':grpc-core')
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
 
-    signature "org.codehaus.mojo.signature:java16:+@signature"
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.protobuf.lite')
+    }
 }
 
-compileTestJava {
-  // Protobuf-generated Lite produces quite a few warnings.
-  options.compilerArgs += ["-Xlint:-rawtypes", "-Xlint:-unchecked", "-Xlint:-fallthrough"]
+tasks.named("compileTestJava").configure {
+    options.compilerArgs += [
+        "-Xlint:-cast"
+    ]
+    options.errorprone.excludedPaths = ".*/build/generated/sources/proto/.*"
 }
 
 protobuf {
-  protoc {
-    if (project.hasProperty('protoc')) {
-      path = project.protoc
-    } else {
-      artifact = "com.google.protobuf:protoc:${protobufVersion}"
-    }
-  }
-  plugins {
-    javalite {
-      if (project.hasProperty('protoc-gen-javalite')) {
-        path = project['protoc-gen-javalite']
-      } else {
-        artifact = libraries.protoc_lite
-      }
+    protoc {
+        if (project.hasProperty('protoc')) {
+            path = project.protoc
+        } else {
+            artifact = libs.protobuf.protoc.get()
+        }
     }
-  }
-  generateProtoTasks {
-    ofSourceSet('test')*.each { task ->
-      task.builtins {
-        remove java
-      }
-      task.plugins {
-        javalite {}
-      }
+    generateProtoTasks {
+        ofSourceSet('test')*.each { task ->
+            task.builtins {
+                java { option 'lite' }
+            }
+        }
     }
-  }
 }
diff --git a/protobuf-lite/src/main/java/io/grpc/protobuf/lite/ProtoInputStream.java b/protobuf-lite/src/main/java/io/grpc/protobuf/lite/ProtoInputStream.java
index f4fe781e4d6..f885a1ece33 100644
--- a/protobuf-lite/src/main/java/io/grpc/protobuf/lite/ProtoInputStream.java
+++ b/protobuf-lite/src/main/java/io/grpc/protobuf/lite/ProtoInputStream.java
@@ -1,37 +1,21 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.protobuf.lite;
 
-import com.google.common.io.ByteStreams;
 import com.google.protobuf.CodedOutputStream;
 import com.google.protobuf.MessageLite;
 import com.google.protobuf.Parser;
@@ -46,7 +30,7 @@
 /**
  * An {@link InputStream} backed by a protobuf.
  */
-class ProtoInputStream extends InputStream implements Drainable, KnownLength {
+final class ProtoInputStream extends InputStream implements Drainable, KnownLength {
 
   // ProtoInputStream is first initialized with a *message*. *partial* is initially null.
   // Once there has been a read operation on this stream, *message* is serialized to *partial* and
@@ -55,7 +39,7 @@ class ProtoInputStream extends InputStream implements Drainable, KnownLength {
   private final Parser<?> parser;
   @Nullable private ByteArrayInputStream partial;
 
-  public ProtoInputStream(MessageLite message, Parser<?> parser) {
+  ProtoInputStream(MessageLite message, Parser<?> parser) {
     this.message = message;
     this.parser = parser;
   }
@@ -68,7 +52,7 @@ public int drainTo(OutputStream target) throws IOException {
       message.writeTo(target);
       message = null;
     } else if (partial != null) {
-      written = (int) ByteStreams.copy(partial, target);
+      written = (int) ProtoLiteUtils.copy(partial, target);
       partial = null;
     } else {
       written = 0;
@@ -77,7 +61,7 @@ public int drainTo(OutputStream target) throws IOException {
   }
 
   @Override
-  public int read() throws IOException {
+  public int read() {
     if (message != null) {
       partial = new ByteArrayInputStream(message.toByteArray());
       message = null;
@@ -119,7 +103,7 @@ public int read(byte[] b, int off, int len) throws IOException {
   }
 
   @Override
-  public int available() throws IOException {
+  public int available() {
     if (message != null) {
       return message.getSerializedSize();
     } else if (partial != null) {
diff --git a/protobuf-lite/src/main/java/io/grpc/protobuf/lite/ProtoLiteUtils.java b/protobuf-lite/src/main/java/io/grpc/protobuf/lite/ProtoLiteUtils.java
index fd8aad5261b..ef4b16bd476 100644
--- a/protobuf-lite/src/main/java/io/grpc/protobuf/lite/ProtoLiteUtils.java
+++ b/protobuf-lite/src/main/java/io/grpc/protobuf/lite/ProtoLiteUtils.java
@@ -1,38 +1,24 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.protobuf.lite;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.protobuf.CodedInputStream;
 import com.google.protobuf.ExtensionRegistryLite;
 import com.google.protobuf.InvalidProtocolBufferException;
@@ -44,21 +30,34 @@
 import io.grpc.MethodDescriptor.Marshaller;
 import io.grpc.MethodDescriptor.PrototypeMarshaller;
 import io.grpc.Status;
-import io.grpc.internal.GrpcUtil;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
 import java.lang.ref.Reference;
 import java.lang.ref.WeakReference;
 
 /**
  * Utility methods for using protobuf with grpc.
+ *
+ * <p>Note that this class will remain experimental for the foreseeable future as the proto lite
+ * API, which this class depends on, is not guaranteed to be stable. This is explained in protobuf
+ * documentation at: https://github.com/protocolbuffers/protobuf/blob/main/java/lite.md
  */
-@ExperimentalApi("Experimental until Lite is stable in protobuf")
-public class ProtoLiteUtils {
+@ExperimentalApi("Will remain experimental as protobuf lite API is not stable")
+public final class ProtoLiteUtils {
 
-  private static volatile ExtensionRegistryLite globalRegistry =
+  // default visibility to avoid synthetic accessors
+  static volatile ExtensionRegistryLite globalRegistry =
       ExtensionRegistryLite.getEmptyRegistry();
 
+  private static final int BUF_SIZE = 8192;
+
+  /**
+   * The same value as {@link io.grpc.internal.GrpcUtil#DEFAULT_MAX_MESSAGE_SIZE}.
+   */
+  @VisibleForTesting
+  static final int DEFAULT_MAX_MESSAGE_SIZE = 4 * 1024 * 1024;
+
   /**
    * Sets the global registry for proto marshalling shared across all servers and clients.
    *
@@ -70,146 +69,211 @@ public class ProtoLiteUtils {
    * {@link #setExtensionRegistry}, but not to modify the underlying object.
    *
    * <p>If you need custom parsing behavior for protos, you will need to make your own
-   * {@code MethodDescriptor.Marhsaller} for the time being.
+   * {@code MethodDescriptor.Marshaller} for the time being.
    *
+   * @since 1.0.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1787")
   public static void setExtensionRegistry(ExtensionRegistryLite newRegistry) {
     globalRegistry = checkNotNull(newRegistry, "newRegistry");
   }
 
-  private static final ThreadLocal<Reference<byte[]>> bufs = new ThreadLocal<Reference<byte[]>>() {
+  /**
+   * Creates a {@link Marshaller} for protos of the same type as {@code defaultInstance}.
+   *
+   * @since 1.0.0
+   */
+  public static <T extends MessageLite> Marshaller<T> marshaller(T defaultInstance) {
+    // TODO(ejona): consider changing return type to PrototypeMarshaller (assuming ABI safe)
+    return new MessageMarshaller<>(defaultInstance, -1);
+  }
+
+  /**
+   * Creates a {@link Marshaller} for protos of the same type as {@code defaultInstance} and a
+   * custom limit for the recursion depth. Any negative number will leave the limit as its default
+   * value as defined by the protobuf library.
+   *
+   * @since 1.56.0
+   */
+  public static <T extends MessageLite> Marshaller<T> marshallerWithRecursionLimit(
+      T defaultInstance, int recursionLimit) {
+    return new MessageMarshaller<>(defaultInstance, recursionLimit);
+  }
 
-    @Override
-    protected Reference<byte[]> initialValue() {
-      return new WeakReference<byte[]>(new byte[4096]); // Picked at random.
+  /**
+   * Produce a metadata marshaller for a protobuf type.
+   *
+   * @since 1.0.0
+   */
+  public static <T extends MessageLite> Metadata.BinaryMarshaller<T> metadataMarshaller(
+      T defaultInstance) {
+    return new MetadataMarshaller<>(defaultInstance);
+  }
+
+  /** Copies the data from input stream to output stream. */
+  static long copy(InputStream from, OutputStream to) throws IOException {
+    // Copied from guava com.google.common.io.ByteStreams because its API is unstable (beta)
+    checkNotNull(from, "inputStream cannot be null!");
+    checkNotNull(to, "outputStream cannot be null!");
+    byte[] buf = new byte[BUF_SIZE];
+    long total = 0;
+    while (true) {
+      int r = from.read(buf);
+      if (r == -1) {
+        break;
+      }
+      to.write(buf, 0, r);
+      total += r;
     }
-  };
+    return total;
+  }
+
+  private ProtoLiteUtils() {
+  }
+
+  private static final class MessageMarshaller<T extends MessageLite>
+      implements PrototypeMarshaller<T> {
+
+    private static final ThreadLocal<Reference<byte[]>> bufs = new ThreadLocal<>();
+
+    private final Parser<T> parser;
+    private final T defaultInstance;
+    private final int recursionLimit;
 
-  /** Create a {@code Marshaller} for protos of the same type as {@code defaultInstance}. */
-  public static <T extends MessageLite> Marshaller<T> marshaller(final T defaultInstance) {
     @SuppressWarnings("unchecked")
-    final Parser<T> parser = (Parser<T>) defaultInstance.getParserForType();
-    // TODO(ejona): consider changing return type to PrototypeMarshaller (assuming ABI safe)
-    return new PrototypeMarshaller<T>() {
-      @SuppressWarnings("unchecked")
-      @Override
-      public Class<T> getMessageClass() {
-        // Precisely T since protobuf doesn't let messages extend other messages.
-        return (Class<T>) defaultInstance.getClass();
-      }
+    MessageMarshaller(T defaultInstance, int recursionLimit) {
+      this.defaultInstance = checkNotNull(defaultInstance, "defaultInstance cannot be null");
+      this.parser = (Parser<T>) defaultInstance.getParserForType();
+      this.recursionLimit = recursionLimit;
+    }
 
-      @Override
-      public T getMessagePrototype() {
-        return defaultInstance;
-      }
+    @SuppressWarnings("unchecked")
+    @Override
+    public Class<T> getMessageClass() {
+      // Precisely T since protobuf doesn't let messages extend other messages.
+      return (Class<T>) defaultInstance.getClass();
+    }
 
-      @Override
-      public InputStream stream(T value) {
-        return new ProtoInputStream(value, parser);
-      }
+    @Override
+    public T getMessagePrototype() {
+      return defaultInstance;
+    }
 
-      @Override
-      public T parse(InputStream stream) {
-        if (stream instanceof ProtoInputStream) {
-          ProtoInputStream protoStream = (ProtoInputStream) stream;
-          // Optimization for in-memory transport. Returning provided object is safe since protobufs
-          // are immutable.
-          //
-          // However, we can't assume the types match, so we have to verify the parser matches.
-          // Today the parser is always the same for a given proto, but that isn't guaranteed. Even
-          // if not, using the same MethodDescriptor would ensure the parser matches and permit us
-          // to enable this optimization.
-          if (protoStream.parser() == parser) {
-            try {
-              @SuppressWarnings("unchecked")
-              T message = (T) ((ProtoInputStream) stream).message();
-              return message;
-            } catch (IllegalStateException ex) {
-              // Stream must have been read from, which is a strange state. Since the point of this
-              // optimization is to be transparent, instead of throwing an error we'll continue,
-              // even though it seems likely there's a bug.
-            }
+    @Override
+    public InputStream stream(T value) {
+      return new ProtoInputStream(value, parser);
+    }
+
+    @Override
+    public T parse(InputStream stream) {
+      if (stream instanceof ProtoInputStream) {
+        ProtoInputStream protoStream = (ProtoInputStream) stream;
+        // Optimization for in-memory transport. Returning provided object is safe since protobufs
+        // are immutable.
+        //
+        // However, we can't assume the types match, so we have to verify the parser matches.
+        // Today the parser is always the same for a given proto, but that isn't guaranteed. Even
+        // if not, using the same MethodDescriptor would ensure the parser matches and permit us
+        // to enable this optimization.
+        if (protoStream.parser() == parser) {
+          try {
+            @SuppressWarnings("unchecked")
+            T message = (T) ((ProtoInputStream) stream).message();
+            return message;
+          } catch (IllegalStateException ignored) {
+            // Stream must have been read from, which is a strange state. Since the point of this
+            // optimization is to be transparent, instead of throwing an error we'll continue,
+            // even though it seems likely there's a bug.
           }
         }
-        CodedInputStream cis = null;
-        try {
-          if (stream instanceof KnownLength) {
-            int size = stream.available();
-            if (size > 0 && size <= GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE) {
-              // buf should not be used after this method has returned.
-              byte[] buf = bufs.get().get();
-              if (buf == null || buf.length < size) {
-                buf = new byte[size];
-                bufs.set(new WeakReference<byte[]>(buf));
-              }
-              int chunkSize;
-              int position = 0;
-              while ((chunkSize = stream.read(buf, position, size - position)) != -1) {
-                position += chunkSize;
-              }
-              if (size != position) {
-                throw new RuntimeException("size inaccurate: " + size + " != " + position);
+      }
+      CodedInputStream cis = null;
+      try {
+        if (stream instanceof KnownLength) {
+          int size = stream.available();
+          if (size > 0 && size <= DEFAULT_MAX_MESSAGE_SIZE) {
+            Reference<byte[]> ref;
+            // buf should not be used after this method has returned.
+            byte[] buf;
+            if ((ref = bufs.get()) == null || (buf = ref.get()) == null || buf.length < size) {
+              buf = new byte[size];
+              bufs.set(new WeakReference<>(buf));
+            }
+
+            int remaining = size;
+            while (remaining > 0) {
+              int position = size - remaining;
+              int count = stream.read(buf, position, remaining);
+              if (count == -1) {
+                break;
               }
-              cis = CodedInputStream.newInstance(buf, 0, size);
-            } else if (size == 0) {
-              return defaultInstance;
+              remaining -= count;
             }
+
+            if (remaining != 0) {
+              int position = size - remaining;
+              throw new RuntimeException("size inaccurate: " + size + " != " + position);
+            }
+            cis = CodedInputStream.newInstance(buf, 0, size);
+          } else if (size == 0) {
+            return defaultInstance;
           }
-        } catch (IOException e) {
-          throw new RuntimeException(e);
-        }
-        if (cis == null) {
-          cis = CodedInputStream.newInstance(stream);
-        }
-        // Pre-create the CodedInputStream so that we can remove the size limit restriction
-        // when parsing.
-        cis.setSizeLimit(Integer.MAX_VALUE);
-
-        try {
-          return parseFrom(cis);
-        } catch (InvalidProtocolBufferException ipbe) {
-          throw Status.INTERNAL.withDescription("Invalid protobuf byte sequence")
-            .withCause(ipbe).asRuntimeException();
         }
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+      if (cis == null) {
+        cis = CodedInputStream.newInstance(stream);
       }
+      // Pre-create the CodedInputStream so that we can remove the size limit restriction
+      // when parsing.
+      cis.setSizeLimit(Integer.MAX_VALUE);
 
-      private T parseFrom(CodedInputStream stream) throws InvalidProtocolBufferException {
-        T message = parser.parseFrom(stream, globalRegistry);
-        try {
-          stream.checkLastTagWas(0);
-          return message;
-        } catch (InvalidProtocolBufferException e) {
-          e.setUnfinishedMessage(message);
-          throw e;
-        }
+      if (recursionLimit >= 0) {
+        cis.setRecursionLimit(recursionLimit);
       }
-    };
-  }
 
-  /**
-   * Produce a metadata marshaller for a protobuf type.
-   */
-  public static <T extends MessageLite> Metadata.BinaryMarshaller<T> metadataMarshaller(
-      final T instance) {
-    return new Metadata.BinaryMarshaller<T>() {
-      @Override
-      public byte[] toBytes(T value) {
-        return value.toByteArray();
+      try {
+        return parseFrom(cis);
+      } catch (InvalidProtocolBufferException ipbe) {
+        throw Status.INTERNAL.withDescription("Invalid protobuf byte sequence")
+            .withCause(ipbe).asRuntimeException();
       }
+    }
 
-      @Override
-      @SuppressWarnings("unchecked")
-      public T parseBytes(byte[] serialized) {
-        try {
-          return (T) instance.getParserForType().parseFrom(serialized, globalRegistry);
-        } catch (InvalidProtocolBufferException ipbe) {
-          throw new IllegalArgumentException(ipbe);
-        }
+    private T parseFrom(CodedInputStream stream) throws InvalidProtocolBufferException {
+      T message = parser.parseFrom(stream, globalRegistry);
+      try {
+        stream.checkLastTagWas(0);
+        return message;
+      } catch (InvalidProtocolBufferException e) {
+        e.setUnfinishedMessage(message);
+        throw e;
       }
-    };
+    }
   }
 
-  private ProtoLiteUtils() {
+  private static final class MetadataMarshaller<T extends MessageLite>
+      implements Metadata.BinaryMarshaller<T> {
+
+    private final T defaultInstance;
+
+    MetadataMarshaller(T defaultInstance) {
+      this.defaultInstance = defaultInstance;
+    }
+
+    @Override
+    public byte[] toBytes(T value) {
+      return value.toByteArray();
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public T parseBytes(byte[] serialized) {
+      try {
+        return (T) defaultInstance.getParserForType().parseFrom(serialized, globalRegistry);
+      } catch (InvalidProtocolBufferException ipbe) {
+        throw new IllegalArgumentException(ipbe);
+      }
+    }
   }
 }
diff --git a/protobuf-lite/src/main/java/io/grpc/protobuf/lite/package-info.java b/protobuf-lite/src/main/java/io/grpc/protobuf/lite/package-info.java
new file mode 100644
index 00000000000..ceee6691147
--- /dev/null
+++ b/protobuf-lite/src/main/java/io/grpc/protobuf/lite/package-info.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2017 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.
+ */
+
+/**
+ * API for gRPC over Protocol Buffers with proto message classes generated by the Lite Runtime
+ * library.
+ */
+
+package io.grpc.protobuf.lite;
diff --git a/protobuf-lite/src/test/java/io/grpc/protobuf/lite/ProtoLiteUtilsTest.java b/protobuf-lite/src/test/java/io/grpc/protobuf/lite/ProtoLiteUtilsTest.java
index 7c88ee92e30..204264b016d 100644
--- a/protobuf-lite/src/test/java/io/grpc/protobuf/lite/ProtoLiteUtilsTest.java
+++ b/protobuf-lite/src/test/java/io/grpc/protobuf/lite/ProtoLiteUtilsTest.java
@@ -1,40 +1,27 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.protobuf.lite;
 
+import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.fail;
 
 import com.google.common.io.ByteStreams;
@@ -44,19 +31,20 @@
 import com.google.protobuf.InvalidProtocolBufferException;
 import com.google.protobuf.Type;
 import io.grpc.Drainable;
+import io.grpc.KnownLength;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor.Marshaller;
 import io.grpc.MethodDescriptor.PrototypeMarshaller;
 import io.grpc.Status;
 import io.grpc.StatusRuntimeException;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.testing.protobuf.SimpleRecursiveMessage;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Arrays;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 
@@ -64,9 +52,7 @@
 @RunWith(JUnit4.class)
 public class ProtoLiteUtilsTest {
 
-  @Rule public final ExpectedException thrown = ExpectedException.none();
-
-  private Marshaller<Type> marshaller = ProtoLiteUtils.marshaller(Type.getDefaultInstance());
+  private final Marshaller<Type> marshaller = ProtoLiteUtils.marshaller(Type.getDefaultInstance());
   private Type proto = Type.newBuilder().setName("name").build();
 
   @Test
@@ -97,7 +83,7 @@ public void testInvalidatedMessage() throws Exception {
   }
 
   @Test
-  public void parseInvalid() throws Exception {
+  public void parseInvalid() {
     InputStream is = new ByteArrayInputStream(new byte[] {-127});
     try {
       marshaller.parse(is);
@@ -109,7 +95,7 @@ public void parseInvalid() throws Exception {
   }
 
   @Test
-  public void testMismatch() throws Exception {
+  public void testMismatch() {
     Marshaller<Enum> enumMarshaller = ProtoLiteUtils.marshaller(Enum.getDefaultInstance());
     // Enum's name and Type's name are both strings with tag 1.
     Enum altProto = Enum.newBuilder().setName(proto.getName()).build();
@@ -117,7 +103,7 @@ public void testMismatch() throws Exception {
   }
 
   @Test
-  public void introspection() throws Exception {
+  public void introspection() {
     Marshaller<Enum> enumMarshaller = ProtoLiteUtils.marshaller(Enum.getDefaultInstance());
     PrototypeMarshaller<Enum> prototypeMarshaller = (PrototypeMarshaller<Enum>) enumMarshaller;
     assertSame(Enum.getDefaultInstance(), prototypeMarshaller.getMessagePrototype());
@@ -194,7 +180,6 @@ public void testDrainTo_partial() throws Exception {
 
   @Test
   public void testDrainTo_none() throws Exception {
-    byte[] golden = ByteStreams.toByteArray(marshaller.stream(proto));
     InputStream is = marshaller.stream(proto);
     byte[] unused = ByteStreams.toByteArray(is);
     Drainable d = (Drainable) is;
@@ -225,9 +210,130 @@ public void metadataMarshaller_invalid() {
 
   @Test
   public void extensionRegistry_notNull() {
-    thrown.expect(NullPointerException.class);
-    thrown.expectMessage("newRegistry");
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> ProtoLiteUtils.setExtensionRegistry(null));
+    assertThat(e).hasMessageThat().isEqualTo("newRegistry");
+  }
+
+  @Test
+  public void parseFromKnowLengthInputStream() {
+    Marshaller<Type> marshaller = ProtoLiteUtils.marshaller(Type.getDefaultInstance());
+    Type expect = Type.newBuilder().setName("expected name").build();
+
+    Type result = marshaller.parse(new CustomKnownLengthInputStream(expect.toByteArray()));
+    assertEquals(expect, result);
+  }
+
+  @Test
+  public void defaultMaxMessageSize() {
+    assertEquals(GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE, ProtoLiteUtils.DEFAULT_MAX_MESSAGE_SIZE);
+  }
+
+  @Test
+  public void testNullDefaultInstance() {
+    String expectedMessage = "defaultInstance cannot be null";
+    assertThrows(expectedMessage, NullPointerException.class,
+        () -> ProtoLiteUtils.marshaller(null));
+
+    assertThrows(expectedMessage, NullPointerException.class,
+        () -> ProtoLiteUtils.marshallerWithRecursionLimit(null, 10)
+    );
+  }
+
+  @Test
+  public void givenPositiveLimit_testRecursionLimitExceeded() throws IOException {
+    Marshaller<SimpleRecursiveMessage> marshaller = ProtoLiteUtils.marshallerWithRecursionLimit(
+        SimpleRecursiveMessage.getDefaultInstance(), 10);
+    SimpleRecursiveMessage message = buildRecursiveMessage(12);
+
+    assertRecursionLimitExceeded(marshaller, message);
+  }
+
+  @Test
+  public void givenZeroLimit_testRecursionLimitExceeded() throws IOException {
+    Marshaller<SimpleRecursiveMessage> marshaller = ProtoLiteUtils.marshallerWithRecursionLimit(
+        SimpleRecursiveMessage.getDefaultInstance(), 0);
+    SimpleRecursiveMessage message = buildRecursiveMessage(1);
+
+    assertRecursionLimitExceeded(marshaller, message);
+  }
+
+  @Test
+  public void givenPositiveLimit_testRecursionLimitNotExceeded() throws IOException {
+    Marshaller<SimpleRecursiveMessage> marshaller = ProtoLiteUtils.marshallerWithRecursionLimit(
+        SimpleRecursiveMessage.getDefaultInstance(), 15);
+    SimpleRecursiveMessage message = buildRecursiveMessage(12);
+
+    assertRecursionLimitNotExceeded(marshaller, message);
+  }
 
-    ProtoLiteUtils.setExtensionRegistry(null);
+  @Test
+  public void givenZeroLimit_testRecursionLimitNotExceeded() throws IOException {
+    Marshaller<SimpleRecursiveMessage> marshaller = ProtoLiteUtils.marshallerWithRecursionLimit(
+        SimpleRecursiveMessage.getDefaultInstance(), 0);
+    SimpleRecursiveMessage message = buildRecursiveMessage(0);
+
+    assertRecursionLimitNotExceeded(marshaller, message);
+  }
+
+  @Test
+  public void testDefaultRecursionLimit() throws IOException {
+    Marshaller<SimpleRecursiveMessage> marshaller = ProtoLiteUtils.marshaller(
+        SimpleRecursiveMessage.getDefaultInstance());
+    SimpleRecursiveMessage message = buildRecursiveMessage(100);
+
+    assertRecursionLimitNotExceeded(marshaller, message);
+  }
+
+  private static void assertRecursionLimitExceeded(Marshaller<SimpleRecursiveMessage> marshaller,
+      SimpleRecursiveMessage message) throws IOException {
+    InputStream is = marshaller.stream(message);
+    ByteArrayInputStream bais = new ByteArrayInputStream(ByteStreams.toByteArray(is));
+
+    assertThrows(StatusRuntimeException.class, () -> marshaller.parse(bais));
+  }
+
+  private static void assertRecursionLimitNotExceeded(Marshaller<SimpleRecursiveMessage> marshaller,
+      SimpleRecursiveMessage message) throws IOException {
+    InputStream is = marshaller.stream(message);
+    ByteArrayInputStream bais = new ByteArrayInputStream(ByteStreams.toByteArray(is));
+
+    assertEquals(message, marshaller.parse(bais));
+  }
+
+  private static SimpleRecursiveMessage buildRecursiveMessage(int depth) {
+    SimpleRecursiveMessage.Builder builder = SimpleRecursiveMessage.newBuilder()
+        .setValue("depth-" + depth);
+    for (int i = depth; i > 0; i--) {
+      builder = SimpleRecursiveMessage.newBuilder()
+          .setValue("depth-" + i)
+          .setMessage(builder.build());
+    }
+
+    return builder.build();
+  }
+
+  private static class CustomKnownLengthInputStream extends InputStream implements KnownLength {
+
+    private int position = 0;
+    private final byte[] source;
+
+    private CustomKnownLengthInputStream(byte[] source) {
+      this.source = source;
+    }
+
+    @Override
+    public int available() {
+      return source.length - position;
+    }
+
+    @Override
+    public int read() {
+      if (position == source.length) {
+        return -1;
+      }
+
+      return source[position++];
+    }
   }
 }
diff --git a/protobuf-lite/src/test/proto/simple_recursive.proto b/protobuf-lite/src/test/proto/simple_recursive.proto
new file mode 100644
index 00000000000..e3ff0f55634
--- /dev/null
+++ b/protobuf-lite/src/test/proto/simple_recursive.proto
@@ -0,0 +1,13 @@
+syntax = "proto3";
+
+package grpc.testing;
+
+option java_package = "io.grpc.testing.protobuf";
+option java_outer_classname = "SimpleRecursiveProto";
+option java_multiple_files = true;
+
+// A simple recursive message for testing purposes
+message SimpleRecursiveMessage {
+  string value = 1;
+  SimpleRecursiveMessage message = 2;
+}
diff --git a/protobuf-nano/build.gradle b/protobuf-nano/build.gradle
deleted file mode 100644
index e577fcbcd88..00000000000
--- a/protobuf-nano/build.gradle
+++ /dev/null
@@ -1,41 +0,0 @@
-// Add dependency on the protobuf plugin
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-    dependencies {
-        classpath libraries.protobuf_plugin
-    }
-}
-
-description = 'gRPC: Protobuf Nano'
-
-dependencies {
-    compile project(':grpc-core'),
-            libraries.protobuf_nano,
-            libraries.guava
-    signature "org.codehaus.mojo.signature:java16:+@signature"
-}
-
-configureProtoCompilation()
-
-if (project.hasProperty('protobuf')) {
-  protobuf {
-    generateProtoTasks {
-      all().each { task ->
-        task.builtins {
-          remove java
-          javanano {
-            option 'ignore_services=true'
-          }
-        }
-      }
-    }
-  }
-}
-
-idea {
-    module {
-        sourceDirs += file("${projectDir}/src/generated/test/javanano");
-    }
-}
diff --git a/protobuf-nano/src/generated/test/javanano/io/grpc/protobuf/nano/Messages.java b/protobuf-nano/src/generated/test/javanano/io/grpc/protobuf/nano/Messages.java
deleted file mode 100644
index 91915c9ecf7..00000000000
--- a/protobuf-nano/src/generated/test/javanano/io/grpc/protobuf/nano/Messages.java
+++ /dev/null
@@ -1,136 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-
-package io.grpc.protobuf.nano;
-
-@SuppressWarnings("hiding")
-public interface Messages {
-
-  public static final class Message extends
-      com.google.protobuf.nano.MessageNano {
-
-    private static volatile Message[] _emptyArray;
-    public static Message[] emptyArray() {
-      // Lazily initializes the empty array
-      if (_emptyArray == null) {
-        synchronized (
-            com.google.protobuf.nano.InternalNano.LAZY_INIT_LOCK) {
-          if (_emptyArray == null) {
-            _emptyArray = new Message[0];
-          }
-        }
-      }
-      return _emptyArray;
-    }
-
-    // int32 i = 1;
-    public int i;
-
-    // bool b = 2;
-    public boolean b;
-
-    // string s = 3;
-    public java.lang.String s;
-
-    // bytes bs = 4;
-    public byte[] bs;
-
-    public Message() {
-      clear();
-    }
-
-    public Message clear() {
-      i = 0;
-      b = false;
-      s = "";
-      bs = com.google.protobuf.nano.WireFormatNano.EMPTY_BYTES;
-      cachedSize = -1;
-      return this;
-    }
-
-    @Override
-    public void writeTo(com.google.protobuf.nano.CodedOutputByteBufferNano output)
-        throws java.io.IOException {
-      if (this.i != 0) {
-        output.writeInt32(1, this.i);
-      }
-      if (this.b != false) {
-        output.writeBool(2, this.b);
-      }
-      if (!this.s.equals("")) {
-        output.writeString(3, this.s);
-      }
-      if (!java.util.Arrays.equals(this.bs, com.google.protobuf.nano.WireFormatNano.EMPTY_BYTES)) {
-        output.writeBytes(4, this.bs);
-      }
-      super.writeTo(output);
-    }
-
-    @Override
-    protected int computeSerializedSize() {
-      int size = super.computeSerializedSize();
-      if (this.i != 0) {
-        size += com.google.protobuf.nano.CodedOutputByteBufferNano
-            .computeInt32Size(1, this.i);
-      }
-      if (this.b != false) {
-        size += com.google.protobuf.nano.CodedOutputByteBufferNano
-            .computeBoolSize(2, this.b);
-      }
-      if (!this.s.equals("")) {
-        size += com.google.protobuf.nano.CodedOutputByteBufferNano
-            .computeStringSize(3, this.s);
-      }
-      if (!java.util.Arrays.equals(this.bs, com.google.protobuf.nano.WireFormatNano.EMPTY_BYTES)) {
-        size += com.google.protobuf.nano.CodedOutputByteBufferNano
-            .computeBytesSize(4, this.bs);
-      }
-      return size;
-    }
-
-    @Override
-    public Message mergeFrom(
-            com.google.protobuf.nano.CodedInputByteBufferNano input)
-        throws java.io.IOException {
-      while (true) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            return this;
-          default: {
-            if (!com.google.protobuf.nano.WireFormatNano.parseUnknownField(input, tag)) {
-              return this;
-            }
-            break;
-          }
-          case 8: {
-            this.i = input.readInt32();
-            break;
-          }
-          case 16: {
-            this.b = input.readBool();
-            break;
-          }
-          case 26: {
-            this.s = input.readString();
-            break;
-          }
-          case 34: {
-            this.bs = input.readBytes();
-            break;
-          }
-        }
-      }
-    }
-
-    public static Message parseFrom(byte[] data)
-        throws com.google.protobuf.nano.InvalidProtocolBufferNanoException {
-      return com.google.protobuf.nano.MessageNano.mergeFrom(new Message(), data);
-    }
-
-    public static Message parseFrom(
-            com.google.protobuf.nano.CodedInputByteBufferNano input)
-        throws java.io.IOException {
-      return new Message().mergeFrom(input);
-    }
-  }
-}
diff --git a/protobuf-nano/src/main/java/io/grpc/protobuf/nano/MessageNanoFactory.java b/protobuf-nano/src/main/java/io/grpc/protobuf/nano/MessageNanoFactory.java
deleted file mode 100644
index 76892c9441a..00000000000
--- a/protobuf-nano/src/main/java/io/grpc/protobuf/nano/MessageNanoFactory.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.protobuf.nano;
-
-import com.google.protobuf.nano.MessageNano;
-
-/**
- * Produce new message instances. Used by a marshaller to deserialize incoming messages.
- *
- * <p>Should be implemented by generated code.
- */
-public interface MessageNanoFactory<T extends MessageNano> {
-  T newInstance();
-}
diff --git a/protobuf-nano/src/main/java/io/grpc/protobuf/nano/NanoProtoInputStream.java b/protobuf-nano/src/main/java/io/grpc/protobuf/nano/NanoProtoInputStream.java
deleted file mode 100644
index a5375255da4..00000000000
--- a/protobuf-nano/src/main/java/io/grpc/protobuf/nano/NanoProtoInputStream.java
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.protobuf.nano;
-
-import com.google.protobuf.nano.CodedOutputByteBufferNano;
-import com.google.protobuf.nano.MessageNano;
-import io.grpc.KnownLength;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import javax.annotation.Nullable;
-
-/**
- * An {@link InputStream} backed by a nano proto.
- */
-class NanoProtoInputStream extends InputStream implements KnownLength {
-
-  // NanoProtoInputStream is first initialized with a *message*. *partial* is initially null.
-  // Once there has been a read operation on this stream, *message* is serialized to *partial* and
-  // set to null.
-  @Nullable private MessageNano message;
-  @Nullable private ByteArrayInputStream partial;
-
-  public NanoProtoInputStream(MessageNano message) {
-    this.message = message;
-  }
-
-  private void toPartial() {
-    if (message != null) {
-      partial = new ByteArrayInputStream(MessageNano.toByteArray(message));
-      message = null;
-    }
-  }
-
-  @Override
-  public int read() throws IOException {
-    toPartial();
-    if (partial != null) {
-      return partial.read();
-    }
-    return -1;
-  }
-
-  @Override
-  public int read(byte[] b, int off, int len) throws IOException {
-    if (message != null) {
-      int size = message.getSerializedSize();
-      if (size == 0) {
-        message = null;
-        partial = null;
-        return -1;
-      }
-      if (len >= size) {
-        // This is the only case that is zero-copy.
-        CodedOutputByteBufferNano output = CodedOutputByteBufferNano.newInstance(b, off, size);
-        message.writeTo(output);
-        output.checkNoSpaceLeft();
-
-        message = null;
-        partial = null;
-        return size;
-      }
-
-      toPartial();
-    }
-    if (partial != null) {
-      return partial.read(b, off, len);
-    }
-    return -1;
-  }
-
-  @Override
-  public int available() throws IOException {
-    if (message != null) {
-      return message.getSerializedSize();
-    } else if (partial != null) {
-      return partial.available();
-    }
-    return 0;
-  }
-}
diff --git a/protobuf-nano/src/main/java/io/grpc/protobuf/nano/NanoUtils.java b/protobuf-nano/src/main/java/io/grpc/protobuf/nano/NanoUtils.java
deleted file mode 100644
index 47f98b82eaf..00000000000
--- a/protobuf-nano/src/main/java/io/grpc/protobuf/nano/NanoUtils.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright 2014, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.protobuf.nano;
-
-import com.google.common.io.ByteStreams;
-import com.google.protobuf.nano.CodedInputByteBufferNano;
-import com.google.protobuf.nano.MessageNano;
-import io.grpc.MethodDescriptor.Marshaller;
-import io.grpc.Status;
-import java.io.IOException;
-import java.io.InputStream;
-
-/**
- * Utility methods for using nano proto with grpc.
- */
-public class NanoUtils {
-
-  private NanoUtils() {}
-
-  /** Adapt {@code parser} to a {@code Marshaller}. */
-  public static <T extends MessageNano> Marshaller<T> marshaller(
-      final MessageNanoFactory<T> factory) {
-    return new Marshaller<T>() {
-      @Override
-      public InputStream stream(T value) {
-        return new NanoProtoInputStream(value);
-      }
-
-      @Override
-      public T parse(InputStream stream) {
-        try {
-          // TODO(simonma): Investigate whether we can do 0-copy here. 
-          CodedInputByteBufferNano input =
-              CodedInputByteBufferNano.newInstance(ByteStreams.toByteArray(stream));
-          input.setSizeLimit(Integer.MAX_VALUE);
-          T message = factory.newInstance();
-          message.mergeFrom(input);
-          return message;
-        } catch (IOException ipbe) {
-          throw Status.INTERNAL.withDescription("Failed parsing nano proto message").withCause(ipbe)
-              .asRuntimeException();
-        }
-      }
-    };
-  }
-}
diff --git a/protobuf-nano/src/test/java/io/grpc/protobuf/nano/NanoUtilsTest.java b/protobuf-nano/src/test/java/io/grpc/protobuf/nano/NanoUtilsTest.java
deleted file mode 100644
index f188781be71..00000000000
--- a/protobuf-nano/src/test/java/io/grpc/protobuf/nano/NanoUtilsTest.java
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright 2015, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.protobuf.nano;
-
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-import com.google.protobuf.nano.InvalidProtocolBufferNanoException;
-import com.google.protobuf.nano.MessageNano;
-import io.grpc.MethodDescriptor.Marshaller;
-import io.grpc.Status;
-import io.grpc.StatusRuntimeException;
-import io.grpc.protobuf.nano.Messages.Message;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link NanoUtils}. */
-@RunWith(JUnit4.class)
-public class NanoUtilsTest {
-  private Marshaller<Message> marshaller = NanoUtils.marshaller(new MessageNanoFactory<Message>() {
-    @Override
-    public Message newInstance() {
-      return new Message();
-    }
-  });
-
-  @Test
-  public void testRoundTrip() {
-    Message m = new Message();
-    m.i = 2;
-    m.b = true;
-    m.s = "string";
-    Message m2 = marshaller.parse(marshaller.stream(m));
-    assertNotSame(m, m2);
-    assertEquals(2, m2.i);
-    assertEquals(true, m2.b);
-    assertEquals("string", m2.s);
-    assertTrue(MessageNano.messageNanoEquals(m, m2));
-  }
-
-  @Test
-  public void parseInvalid() throws Exception {
-    InputStream is = new ByteArrayInputStream(new byte[] {-127});
-    try {
-      marshaller.parse(is);
-      fail("Expected exception");
-    } catch (StatusRuntimeException ex) {
-      assertEquals(Status.Code.INTERNAL, ex.getStatus().getCode());
-      assertTrue(ex.getCause() instanceof InvalidProtocolBufferNanoException);
-    }
-  }
-
-  @Test
-  public void testLarge() {
-    Message m = new Message();
-    // The default limit is 64MB. Using a larger proto to verify that the limit is not enforced.
-    m.bs = new byte[70 * 1024 * 1024];
-    Message m2 = marshaller.parse(marshaller.stream(m));
-    assertNotSame(m, m2);
-    // TODO(carl-mastrangelo): assertArrayEquals is REALLY slow, and been fixed in junit4.12.
-    // Eventually switch back to it once we are using 4.12 everywhere.
-    // assertArrayEquals(m.bs, m2.bs);
-    assertEquals(m.bs.length, m2.bs.length);
-    for (int i = 0; i < m.bs.length; i++) {
-      assertEquals(m.bs[i], m2.bs[i]);
-    }
-  }
-
-  @Test
-  public void testAvailable() throws Exception {
-    Message m = new Message();
-    m.s = "string";
-    InputStream is = marshaller.stream(m);
-    assertEquals(m.getSerializedSize(), is.available());
-    is.read();
-    assertEquals(m.getSerializedSize() - 1, is.available());
-    while (is.read() != -1) {}
-    assertEquals(-1, is.read());
-    assertEquals(0, is.available());
-  }
-
-  @Test
-  public void testEmpty() throws IOException {
-    InputStream is = marshaller.stream(new Message());
-    assertEquals(0, is.available());
-    byte[] b = new byte[10];
-    assertEquals(-1, is.read(b));
-    assertArrayEquals(new byte[10], b);
-    // Do the same thing again, because the internal state may be different
-    assertEquals(-1, is.read(b));
-    assertArrayEquals(new byte[10], b);
-    assertEquals(-1, is.read());
-    assertEquals(0, is.available());
-  }
-}
diff --git a/protobuf-nano/src/test/proto/messages.proto b/protobuf-nano/src/test/proto/messages.proto
deleted file mode 100644
index 59d64e97315..00000000000
--- a/protobuf-nano/src/test/proto/messages.proto
+++ /dev/null
@@ -1,42 +0,0 @@
-
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package grpc;
-
-option java_package = "io.grpc.protobuf";
-
-message Message {
-  int32 i = 1;
-  bool b = 2;
-  string s = 3;
-  bytes bs = 4;
-}
diff --git a/protobuf/BUILD.bazel b/protobuf/BUILD.bazel
new file mode 100644
index 00000000000..a31f8b6f6f5
--- /dev/null
+++ b/protobuf/BUILD.bazel
@@ -0,0 +1,19 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "protobuf",
+    srcs = glob([
+        "src/main/java/**/*.java",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api",
+        "//protobuf-lite",
+        "@com_google_protobuf//:protobuf_java",
+        artifact("com.google.api.grpc:proto-google-common-protos"),
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+    ],
+)
diff --git a/protobuf/build.gradle b/protobuf/build.gradle
index d0c5f7229df..c477e41dceb 100644
--- a/protobuf/build.gradle
+++ b/protobuf/build.gradle
@@ -1,14 +1,49 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "com.google.protobuf"
+    id "me.champeau.gradle.japicmp"
+    id "ru.vyarus.animalsniffer"
+}
+
 description = 'gRPC: Protobuf'
 
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.protobuf')
+    }
+}
+
 dependencies {
-    compile project(':grpc-core'),
-            libraries.protobuf,
-            libraries.guava,
-            libraries.protobuf_util
+    api project(':grpc-api'),
+            libraries.jsr305,
+            libraries.protobuf.java
+    implementation libraries.guava
 
-    compile (project(':grpc-protobuf-lite')) {
-        exclude group: 'com.google.protobuf', module: 'protobuf-lite'
+    api (libraries.google.api.protos) {
+        // 'com.google.api:api-common' transitively depends on auto-value, which breaks our
+        // annotations.
+        exclude group: 'com.google.api', module: 'api-common'
     }
 
-    signature "org.codehaus.mojo.signature:java16:+@signature"
+    implementation (project(':grpc-protobuf-lite')) {
+        exclude group: 'com.google.protobuf', module: 'protobuf-javalite'
+    }
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+tasks.named("javadoc").configure {
+    options.linksOffline 'https://protobuf.dev/reference/java/api-docs/',
+        "${rootProject.projectDir}/gradle/javadoc/protobuf.dev-reference-java-api-docs/"
 }
diff --git a/protobuf/src/main/java/io/grpc/protobuf/ProtoFileDescriptorSupplier.java b/protobuf/src/main/java/io/grpc/protobuf/ProtoFileDescriptorSupplier.java
index 9338b0ea077..b87cf333ce9 100644
--- a/protobuf/src/main/java/io/grpc/protobuf/ProtoFileDescriptorSupplier.java
+++ b/protobuf/src/main/java/io/grpc/protobuf/ProtoFileDescriptorSupplier.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.protobuf;
@@ -35,7 +20,12 @@
 
 /**
  * Provides access to the underlying proto file descriptor.
+ *
+ * @since 1.1.0
  */
 public interface ProtoFileDescriptorSupplier {
+  /**
+   * Returns file descriptor to the underlying proto file.
+   */
   FileDescriptor getFileDescriptor();
 }
diff --git a/protobuf/src/main/java/io/grpc/protobuf/ProtoMethodDescriptorSupplier.java b/protobuf/src/main/java/io/grpc/protobuf/ProtoMethodDescriptorSupplier.java
new file mode 100644
index 00000000000..e7cd3ed336f
--- /dev/null
+++ b/protobuf/src/main/java/io/grpc/protobuf/ProtoMethodDescriptorSupplier.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2017 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.protobuf;
+
+import com.google.errorprone.annotations.CheckReturnValue;
+import com.google.protobuf.Descriptors.MethodDescriptor;
+
+/**
+ * Provides access to the underlying proto service method descriptor.
+ *
+ * @since 1.7.0
+ */
+public interface ProtoMethodDescriptorSupplier extends ProtoServiceDescriptorSupplier {
+  /**
+   * Returns method descriptor to the proto service method.
+   */
+  @CheckReturnValue
+  MethodDescriptor getMethodDescriptor();
+}
diff --git a/protobuf/src/main/java/io/grpc/protobuf/ProtoServiceDescriptorSupplier.java b/protobuf/src/main/java/io/grpc/protobuf/ProtoServiceDescriptorSupplier.java
new file mode 100644
index 00000000000..b37150eeed3
--- /dev/null
+++ b/protobuf/src/main/java/io/grpc/protobuf/ProtoServiceDescriptorSupplier.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2017 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.protobuf;
+
+import com.google.protobuf.Descriptors.ServiceDescriptor;
+
+/**
+ * Provides access to the underlying proto service descriptor.
+ *
+ * @since 1.7.0
+ */
+public interface ProtoServiceDescriptorSupplier extends ProtoFileDescriptorSupplier {
+  /**
+   * Returns service descriptor to the proto service.
+   */
+  ServiceDescriptor getServiceDescriptor();
+}
diff --git a/protobuf/src/main/java/io/grpc/protobuf/ProtoUtils.java b/protobuf/src/main/java/io/grpc/protobuf/ProtoUtils.java
index a49dc8285a0..d403789eb5f 100644
--- a/protobuf/src/main/java/io/grpc/protobuf/ProtoUtils.java
+++ b/protobuf/src/main/java/io/grpc/protobuf/ProtoUtils.java
@@ -1,130 +1,90 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.protobuf;
 
-import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.ExtensionRegistry;
 import com.google.protobuf.Message;
-import com.google.protobuf.Message.Builder;
-import com.google.protobuf.util.JsonFormat;
-import com.google.protobuf.util.JsonFormat.Parser;
-import com.google.protobuf.util.JsonFormat.Printer;
-import io.grpc.ExperimentalApi;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor.Marshaller;
-import io.grpc.Status;
 import io.grpc.protobuf.lite.ProtoLiteUtils;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.Reader;
-import java.nio.charset.Charset;
 
 /**
  * Utility methods for using protobuf with grpc.
  */
-public class ProtoUtils {
+public final class ProtoUtils {
 
-  /** Create a {@code Marshaller} for protos of the same type as {@code defaultInstance}. */
-  public static <T extends Message> Marshaller<T> marshaller(final T defaultInstance) {
-    return ProtoLiteUtils.marshaller(defaultInstance);
+  /**
+   * Sets the global registry for proto marshalling shared across all servers and clients.
+   *
+   * <p>Warning:  This API will likely change over time.  It is not possible to have separate
+   * registries per Process, Server, Channel, Service, or Method.  This is intentional until there
+   * is a more appropriate API to set them.
+   *
+   * <p>Warning:  Do NOT modify the extension registry after setting it.  It is thread safe to call
+   * {@link #setExtensionRegistry}, but not to modify the underlying object.
+   *
+   * <p>If you need custom parsing behavior for protos, you will need to make your own
+   * {@code MethodDescriptor.Marshaller} for the time being.
+   *
+   * @since 1.16.0
+   */
+  public static void setExtensionRegistry(ExtensionRegistry registry) {
+    ProtoLiteUtils.setExtensionRegistry(registry);
   }
 
   /**
-   * Create a {@code Marshaller} for json protos of the same type as {@code defaultInstance}.
+   * Create a {@link Marshaller} for protos of the same type as {@code defaultInstance}.
    *
-   * <p>This is an unstable API and has not been optimized yet for performance.
+   * @since 1.0.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1786")
-  public static <T extends Message> Marshaller<T> jsonMarshaller(final T defaultInstance) {
-    final Parser parser = JsonFormat.parser();
-    final Printer printer = JsonFormat.printer();
-    return jsonMarshaller(defaultInstance, parser, printer);
+  public static <T extends Message> Marshaller<T> marshaller(final T defaultInstance) {
+    return ProtoLiteUtils.marshaller(defaultInstance);
   }
 
   /**
-   * Create a {@code Marshaller} for json protos of the same type as {@code defaultInstance}.
+   * Creates a {@link Marshaller} for protos of the same type as {@code defaultInstance} and a
+   * custom limit for the recursion depth. Any negative number will leave the limit as its default
+   * value as defined by the protobuf library.
    *
-   * <p>This is an unstable API and has not been optimized yet for performance.
+   * @since 1.56.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1786")
-  public static <T extends Message> Marshaller<T> jsonMarshaller(
-      final T defaultInstance, final Parser parser, final Printer printer) {
-
-    final Charset charset = Charset.forName("UTF-8");
-
-    return new Marshaller<T>() {
-      @Override
-      public InputStream stream(T value) {
-        try {
-          return new ByteArrayInputStream(printer.print(value).getBytes(charset));
-        } catch (InvalidProtocolBufferException e) {
-          throw Status.INTERNAL
-              .withCause(e)
-              .withDescription("Unable to print json proto")
-              .asRuntimeException();
-        }
-      }
-
-      @SuppressWarnings("unchecked")
-      @Override
-      public T parse(InputStream stream) {
-        Builder builder = defaultInstance.newBuilderForType();
-        Reader reader = new InputStreamReader(stream, charset);
-        T proto;
-        try {
-          parser.merge(reader, builder);
-          proto = (T) builder.build();
-          reader.close();
-        } catch (InvalidProtocolBufferException e) {
-          throw Status.INTERNAL.withDescription("Invalid protobuf byte sequence")
-              .withCause(e).asRuntimeException();
-        } catch (IOException e) {
-          // Same for now, might be unavailable
-          throw Status.INTERNAL.withDescription("Invalid protobuf byte sequence")
-              .withCause(e).asRuntimeException();
-        }
-        return proto;
-      }
-    };
+  public static <T extends Message> Marshaller<T> marshallerWithRecursionLimit(T defaultInstance,
+      int recursionLimit) {
+    return ProtoLiteUtils.marshallerWithRecursionLimit(defaultInstance, recursionLimit);
   }
 
   /**
    * Produce a metadata key for a generated protobuf type.
+   *
+   * @since 1.0.0
    */
   public static <T extends Message> Metadata.Key<T> keyForProto(T instance) {
     return Metadata.Key.of(
         instance.getDescriptorForType().getFullName() + Metadata.BINARY_HEADER_SUFFIX,
-        ProtoLiteUtils.metadataMarshaller(instance));
+        metadataMarshaller(instance));
+  }
+
+  /**
+   * Produce a metadata marshaller for a protobuf type.
+   *
+   * @since 1.13.0
+   */
+  public static <T extends Message> Metadata.BinaryMarshaller<T> metadataMarshaller(T instance) {
+    return ProtoLiteUtils.metadataMarshaller(instance);
   }
 
   private ProtoUtils() {
diff --git a/protobuf/src/main/java/io/grpc/protobuf/StatusProto.java b/protobuf/src/main/java/io/grpc/protobuf/StatusProto.java
new file mode 100644
index 00000000000..0ebc1e714f6
--- /dev/null
+++ b/protobuf/src/main/java/io/grpc/protobuf/StatusProto.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright 2017 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.protobuf;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.ExperimentalApi;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.StatusRuntimeException;
+import io.grpc.protobuf.lite.ProtoLiteUtils;
+import javax.annotation.Nullable;
+
+/** Utility methods for working with {@link com.google.rpc.Status}. */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4695")
+public final class StatusProto {
+  private StatusProto() {}
+
+  private static final Metadata.Key<com.google.rpc.Status> STATUS_DETAILS_KEY =
+      Metadata.Key.of(
+          "grpc-status-details-bin",
+          ProtoLiteUtils.metadataMarshaller(com.google.rpc.Status.getDefaultInstance()));
+
+  /**
+   * Convert a {@link com.google.rpc.Status} instance to a {@link StatusRuntimeException}.
+   *
+   * <p>The returned {@link StatusRuntimeException} will wrap a {@link Status} whose code and
+   * description are set from the code and message in {@code statusProto}. {@code statusProto} will
+   * be serialized and placed into the metadata of the returned {@link StatusRuntimeException}.
+   *
+   * @throws IllegalArgumentException if the value of {@code statusProto.getCode()} is not a valid
+   *     gRPC status code.
+   * @since 1.3.0
+   */
+  public static StatusRuntimeException toStatusRuntimeException(com.google.rpc.Status statusProto) {
+    return toStatus(statusProto).asRuntimeException(toMetadata(statusProto));
+  }
+
+  /**
+   * Convert a {@link com.google.rpc.Status} instance to a {@link StatusRuntimeException} with
+   * additional metadata.
+   *
+   * <p>The returned {@link StatusRuntimeException} will wrap a {@link Status} whose code and
+   * description are set from the code and message in {@code statusProto}. {@code statusProto} will
+   * be serialized and added to {@code metadata}. {@code metadata} will be set as the metadata of
+   * the returned {@link StatusRuntimeException}.
+   *
+   * @throws IllegalArgumentException if the value of {@code statusProto.getCode()} is not a valid
+   *     gRPC status code.
+   * @since 1.3.0
+   */
+  public static StatusRuntimeException toStatusRuntimeException(
+      com.google.rpc.Status statusProto, Metadata metadata) {
+    return toStatus(statusProto).asRuntimeException(toMetadata(statusProto, metadata));
+  }
+
+  /**
+   * Convert a {@link com.google.rpc.Status} instance to a {@link StatusException}.
+   *
+   * <p>The returned {@link StatusException} will wrap a {@link Status} whose code and description
+   * are set from the code and message in {@code statusProto}. {@code statusProto} will be
+   * serialized and placed into the metadata of the returned {@link StatusException}.
+   *
+   * @throws IllegalArgumentException if the value of {@code statusProto.getCode()} is not a valid
+   *     gRPC status code.
+   * @since 1.3.0
+   */
+  public static StatusException toStatusException(com.google.rpc.Status statusProto) {
+    return toStatus(statusProto).asException(toMetadata(statusProto));
+  }
+
+  /**
+   * Convert a {@link com.google.rpc.Status} instance to a {@link StatusException} with additional
+   * metadata.
+   *
+   * <p>The returned {@link StatusException} will wrap a {@link Status} whose code and description
+   * are set from the code and message in {@code statusProto}. {@code statusProto} will be
+   * serialized and added to {@code metadata}. {@code metadata} will be set as the metadata of the
+   * returned {@link StatusException}.
+   *
+   * @throws IllegalArgumentException if the value of {@code statusProto.getCode()} is not a valid
+   *     gRPC status code.
+   * @since 1.3.0
+   */
+  public static StatusException toStatusException(
+      com.google.rpc.Status statusProto, Metadata metadata) {
+    return toStatus(statusProto).asException(toMetadata(statusProto, metadata));
+  }
+
+  /**
+   * Convert a {@link com.google.rpc.Status} instance to a {@link StatusException} with additional
+   * metadata and the root exception thrown. The exception isn't propagated over the wire.
+   *
+   * <p>The returned {@link StatusException} will wrap a {@link Status} whose code and description
+   * are set from the code and message in {@code statusProto}. {@code statusProto} will be
+   * serialized and added to {@code metadata}. {@code metadata} will be set as the metadata of the
+   * returned {@link StatusException}. The {@link Throwable} is the exception that is set as the
+   * {@code cause} of the returned {@link StatusException}.
+   *
+   * @throws IllegalArgumentException if the value of {@code statusProto.getCode()} is not a valid
+   *     gRPC status code.
+   * @since 1.3.0
+   */
+  public static StatusException toStatusException(
+      com.google.rpc.Status statusProto, Metadata metadata, Throwable cause) {
+    return toStatus(statusProto).withCause(cause).asException(toMetadata(statusProto, metadata));
+  }
+
+  private static Status toStatus(com.google.rpc.Status statusProto) {
+    Status status = Status.fromCodeValue(statusProto.getCode());
+    checkArgument(status.getCode().value() == statusProto.getCode(), "invalid status code");
+    return status.withDescription(statusProto.getMessage());
+  }
+
+  private static Metadata toMetadata(com.google.rpc.Status statusProto) {
+    Metadata metadata = new Metadata();
+    metadata.put(STATUS_DETAILS_KEY, statusProto);
+    return metadata;
+  }
+
+  private static Metadata toMetadata(com.google.rpc.Status statusProto, Metadata metadata) {
+    checkNotNull(metadata, "metadata must not be null");
+    metadata.discardAll(STATUS_DETAILS_KEY);
+    metadata.put(STATUS_DETAILS_KEY, statusProto);
+    return metadata;
+  }
+
+  /**
+   * Extract a {@link com.google.rpc.Status} instance from the causal chain of a {@link Throwable}.
+   *
+   * @return the extracted {@link com.google.rpc.Status} instance, or {@code null} if none exists.
+   * @throws IllegalArgumentException if an embedded {@link com.google.rpc.Status} is found and its
+   *     code does not match the gRPC {@link Status} code.
+   * @since 1.3.0
+   */
+  @Nullable
+  public static com.google.rpc.Status fromThrowable(Throwable t) {
+    Throwable cause = checkNotNull(t, "t");
+    while (cause != null) {
+      if (cause instanceof StatusException) {
+        StatusException e = (StatusException) cause;
+        return fromStatusAndTrailers(e.getStatus(), e.getTrailers());
+      } else if (cause instanceof StatusRuntimeException) {
+        StatusRuntimeException e = (StatusRuntimeException) cause;
+        return fromStatusAndTrailers(e.getStatus(), e.getTrailers());
+      }
+      cause = cause.getCause();
+    }
+    return null;
+  }
+
+  /**
+   * Extracts the {@code google.rpc.Status} from trailers, and makes sure they match the gRPC
+   * {@code status}. If the trailers do not contain a {@code google.rpc.Status}, it uses
+   * {@code status} param to generate a {@code google.rpc.Status}.
+   *
+   * @return the embedded google.rpc.Status
+   * @since 1.11.0
+   */
+  public static com.google.rpc.Status fromStatusAndTrailers(
+      Status status, @Nullable Metadata trailers) {
+    checkNotNull(status, "status");
+    if (trailers != null) {
+      com.google.rpc.Status statusProto = trailers.get(STATUS_DETAILS_KEY);
+      if (statusProto != null) {
+        checkArgument(
+            status.getCode().value() == statusProto.getCode(),
+            "com.google.rpc.Status code must match gRPC status code");
+        return statusProto;
+      }
+    }
+    // fall-back to status, this is useful if the error is local. e.g. Server is unavailable.
+    com.google.rpc.Status.Builder statusBuilder = com.google.rpc.Status.newBuilder()
+        .setCode(status.getCode().value());
+    if (status.getDescription() != null) {
+      statusBuilder.setMessage(status.getDescription());
+    }
+    return statusBuilder.build();
+  }
+}
diff --git a/protobuf/src/main/java/io/grpc/protobuf/package-info.java b/protobuf/src/main/java/io/grpc/protobuf/package-info.java
new file mode 100644
index 00000000000..c73d24f9480
--- /dev/null
+++ b/protobuf/src/main/java/io/grpc/protobuf/package-info.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright 2017 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.
+ */
+
+/**
+ * API for gRPC over Protocol Buffers, including tools for serializing and de-serializing protobuf
+ * messages.
+ */
+package io.grpc.protobuf;
diff --git a/protobuf/src/test/java/io/grpc/protobuf/ProtoUtilsTest.java b/protobuf/src/test/java/io/grpc/protobuf/ProtoUtilsTest.java
index 540b9923eab..74707c9103c 100644
--- a/protobuf/src/test/java/io/grpc/protobuf/ProtoUtilsTest.java
+++ b/protobuf/src/test/java/io/grpc/protobuf/ProtoUtilsTest.java
@@ -1,49 +1,28 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.protobuf;
 
 import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.fail;
 
 import com.google.common.io.ByteStreams;
 import com.google.protobuf.Type;
 import io.grpc.MethodDescriptor.Marshaller;
-import io.grpc.Status;
-import io.grpc.StatusRuntimeException;
 import java.io.ByteArrayInputStream;
-import java.io.IOException;
 import java.io.InputStream;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -66,63 +45,4 @@ public void keyForProto() {
     assertEquals("google.protobuf.Type-bin",
         ProtoUtils.keyForProto(Type.getDefaultInstance()).originalName());
   }
-
-  @Test
-  public void testJsonRoundtrip() throws Exception {
-    Marshaller<Type> marshaller = ProtoUtils.jsonMarshaller(Type.getDefaultInstance());
-    InputStream is = marshaller.stream(proto);
-    is = new ByteArrayInputStream(ByteStreams.toByteArray(is));
-    assertEquals(proto, marshaller.parse(is));
-  }
-
-  @Test
-  public void testJsonRepresentation() throws Exception {
-    Marshaller<Type> marshaller = ProtoUtils.jsonMarshaller(Type.getDefaultInstance());
-    InputStream is = marshaller.stream(proto);
-    String s = new String(ByteStreams.toByteArray(is), "UTF-8");
-    assertEquals("{\"name\":\"value\"}", s.replaceAll("\\s", ""));
-  }
-
-  @Ignore("https://github.com/google/protobuf/issues/1470")
-  @Test
-  public void testJsonInvalid() throws Exception {
-    Marshaller<Type> marshaller = ProtoUtils.jsonMarshaller(Type.getDefaultInstance());
-    try {
-      marshaller.parse(new ByteArrayInputStream("{]".getBytes("UTF-8")));
-      fail("Expected exception");
-    } catch (StatusRuntimeException ex) {
-      assertEquals(Status.Code.INTERNAL, ex.getStatus().getCode());
-      assertNotNull(ex.getCause());
-    }
-  }
-
-  @Test
-  public void testJsonInvalidProto() throws Exception {
-    Marshaller<Type> marshaller = ProtoUtils.jsonMarshaller(Type.getDefaultInstance());
-    try {
-      marshaller.parse(new ByteArrayInputStream("{\"\":3}".getBytes("UTF-8")));
-      fail("Expected exception");
-    } catch (StatusRuntimeException ex) {
-      assertEquals(Status.Code.INTERNAL, ex.getStatus().getCode());
-      assertNotNull(ex.getCause());
-    }
-  }
-
-  @Test
-  public void testJsonIoException() throws Exception {
-    Marshaller<Type> marshaller = ProtoUtils.jsonMarshaller(Type.getDefaultInstance());
-    final IOException ioe = new IOException();
-    try {
-      marshaller.parse(new ByteArrayInputStream("{}".getBytes("UTF-8")) {
-        @Override
-        public void close() throws IOException {
-          throw ioe;
-        }
-      });
-      fail("Exception expected");
-    } catch (StatusRuntimeException ex) {
-      assertEquals(Status.Code.INTERNAL, ex.getStatus().getCode());
-      assertEquals(ioe, ex.getCause());
-    }
-  }
 }
diff --git a/protobuf/src/test/java/io/grpc/protobuf/StatusProtoTest.java b/protobuf/src/test/java/io/grpc/protobuf/StatusProtoTest.java
new file mode 100644
index 00000000000..47c045bf952
--- /dev/null
+++ b/protobuf/src/test/java/io/grpc/protobuf/StatusProtoTest.java
@@ -0,0 +1,203 @@
+/*
+ * Copyright 2017 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.protobuf;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.StatusRuntimeException;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link StatusProto}. */
+@RunWith(JUnit4.class)
+public class StatusProtoTest {
+  private Metadata metadata;
+
+  @Before
+  public void setup() {
+    metadata = new Metadata();
+    metadata.put(METADATA_KEY, METADATA_VALUE);
+  }
+
+  @Test
+  public void toStatusRuntimeException() throws Exception {
+    StatusRuntimeException sre = StatusProto.toStatusRuntimeException(STATUS_PROTO);
+    com.google.rpc.Status extractedStatusProto = StatusProto.fromThrowable(sre);
+
+    assertEquals(STATUS_PROTO.getCode(), sre.getStatus().getCode().value());
+    assertEquals(STATUS_PROTO.getMessage(), sre.getStatus().getDescription());
+    assertEquals(STATUS_PROTO, extractedStatusProto);
+  }
+
+  @Test
+  public void toStatusRuntimeExceptionWithMetadata_shouldIncludeMetadata() throws Exception {
+    StatusRuntimeException sre = StatusProto.toStatusRuntimeException(STATUS_PROTO, metadata);
+    com.google.rpc.Status extractedStatusProto = StatusProto.fromThrowable(sre);
+
+    assertEquals(STATUS_PROTO.getCode(), sre.getStatus().getCode().value());
+    assertEquals(STATUS_PROTO.getMessage(), sre.getStatus().getDescription());
+    assertEquals(STATUS_PROTO, extractedStatusProto);
+    assertNotNull(sre.getTrailers());
+    assertEquals(METADATA_VALUE, sre.getTrailers().get(METADATA_KEY));
+  }
+
+  @Test
+  public void toStatusRuntimeExceptionWithMetadata_shouldThrowIfMetadataIsNull() throws Exception {
+    try {
+      StatusProto.toStatusRuntimeException(STATUS_PROTO, null);
+      fail("NullPointerException expected");
+    } catch (NullPointerException npe) {
+      assertEquals("metadata must not be null", npe.getMessage());
+    }
+  }
+
+  @Test
+  public void toStatusRuntimeException_shouldThrowIfStatusCodeInvalid() throws Exception {
+    try {
+      StatusProto.toStatusRuntimeException(INVALID_STATUS_PROTO);
+      fail("IllegalArgumentException expected");
+    } catch (IllegalArgumentException expectedException) {
+      assertEquals("invalid status code", expectedException.getMessage());
+    }
+  }
+
+  @Test
+  public void toStatusException() throws Exception {
+    StatusException se = StatusProto.toStatusException(STATUS_PROTO);
+    com.google.rpc.Status extractedStatusProto = StatusProto.fromThrowable(se);
+
+    assertEquals(STATUS_PROTO.getCode(), se.getStatus().getCode().value());
+    assertEquals(STATUS_PROTO.getMessage(), se.getStatus().getDescription());
+    assertEquals(STATUS_PROTO, extractedStatusProto);
+  }
+
+  @Test
+  public void toStatusExceptionWithMetadata_shouldIncludeMetadata() throws Exception {
+    StatusException se = StatusProto.toStatusException(STATUS_PROTO, metadata);
+    com.google.rpc.Status extractedStatusProto = StatusProto.fromThrowable(se);
+
+    assertEquals(STATUS_PROTO.getCode(), se.getStatus().getCode().value());
+    assertEquals(STATUS_PROTO.getMessage(), se.getStatus().getDescription());
+    assertEquals(STATUS_PROTO, extractedStatusProto);
+    assertNotNull(se.getTrailers());
+    assertEquals(METADATA_VALUE, se.getTrailers().get(METADATA_KEY));
+  }
+
+  @Test
+  public void toStatusExceptionWithMetadata_shouldThrowIfMetadataIsNull() throws Exception {
+    try {
+      StatusProto.toStatusException(STATUS_PROTO, null);
+      fail("NullPointerException expected");
+    } catch (NullPointerException npe) {
+      assertEquals("metadata must not be null", npe.getMessage());
+    }
+  }
+
+  @Test
+  public void toStatusException_shouldThrowIfStatusCodeInvalid() throws Exception {
+    try {
+      StatusProto.toStatusException(INVALID_STATUS_PROTO);
+      fail("IllegalArgumentException expected");
+    } catch (IllegalArgumentException expectedException) {
+      assertEquals("invalid status code", expectedException.getMessage());
+    }
+  }
+
+  @Test
+  public void fromThrowable_runtimeException_shouldReturnDerivedStatusIfTrailersAreNull() {
+    Status status = Status.UNAVAILABLE.withDescription("not available");
+
+    com.google.rpc.Status statusFromThrowable =
+        StatusProto.fromThrowable(status.asRuntimeException());
+
+    assertEquals(statusFromThrowable.getCode(), status.getCode().value());
+    assertEquals(statusFromThrowable.getMessage(), status.getDescription());
+  }
+
+  @Test
+  public void fromThrowable_exception_shouldReturnDerivedStatusIfTrailersAreNull() {
+    Status status = Status.UNAVAILABLE.withDescription("not available");
+
+    com.google.rpc.Status statusFromThrowable =
+        StatusProto.fromThrowable(status.asException());
+
+    assertEquals(statusFromThrowable.getCode(), status.getCode().value());
+    assertEquals(statusFromThrowable.getMessage(), status.getDescription());
+  }
+
+  @Test
+  public void fromThrowableWithNestedStatusRuntimeException() {
+    StatusRuntimeException sre = StatusProto.toStatusRuntimeException(STATUS_PROTO);
+    Throwable nestedSre = new Throwable(sre);
+
+    com.google.rpc.Status extractedStatusProto = StatusProto.fromThrowable(sre);
+    com.google.rpc.Status extractedStatusProtoFromNestedSre = StatusProto.fromThrowable(nestedSre);
+
+    assertEquals(extractedStatusProto, extractedStatusProtoFromNestedSre);
+  }
+
+  @Test
+  public void fromThrowableWithNestedStatusException() {
+    StatusException se = StatusProto.toStatusException(STATUS_PROTO);
+    Throwable nestedSe = new Throwable(se);
+
+    com.google.rpc.Status extractedStatusProto = StatusProto.fromThrowable(se);
+    com.google.rpc.Status extractedStatusProtoFromNestedSe = StatusProto.fromThrowable(nestedSe);
+
+    assertEquals(extractedStatusProto, extractedStatusProtoFromNestedSe);
+  }
+
+  @Test
+  public void fromThrowable_shouldReturnNullIfNoEmbeddedStatus() {
+    Throwable nestedSe = new Throwable(new Throwable("no status found"));
+
+    assertNull(StatusProto.fromThrowable(nestedSe));
+  }
+
+  @Test
+  public void toStatusExceptionWithMetadataAndCause_shouldCaptureCause() {
+    RuntimeException exc = new RuntimeException("This is a test exception.");
+    StatusException se = StatusProto.toStatusException(STATUS_PROTO, new Metadata(), exc);
+
+    assertEquals(exc, se.getCause());
+  }
+
+  private static final Metadata.Key<String> METADATA_KEY =
+      Metadata.Key.of("test-metadata", Metadata.ASCII_STRING_MARSHALLER);
+  private static final String METADATA_VALUE = "test metadata value";
+  private static final com.google.rpc.Status STATUS_PROTO =
+      com.google.rpc.Status.newBuilder()
+          .setCode(2)
+          .setMessage("status message")
+          .addDetails(
+              com.google.protobuf.Any.pack(
+                  com.google.rpc.Status.newBuilder()
+                      .setCode(13)
+                      .setMessage("nested message")
+                      .build()))
+          .build();
+  private static final com.google.rpc.Status INVALID_STATUS_PROTO =
+      com.google.rpc.Status.newBuilder().setCode(-1).build();
+}
diff --git a/repositories.bzl b/repositories.bzl
new file mode 100644
index 00000000000..c89e1bdff32
--- /dev/null
+++ b/repositories.bzl
@@ -0,0 +1,130 @@
+"""External dependencies for grpc-java."""
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+# For use with maven_install's artifacts.
+# maven_install(
+#     ...
+#     artifacts = [
+#         # Your own deps
+#     ] + IO_GRPC_GRPC_JAVA_ARTIFACTS,
+# )
+# GRPC_DEPS_START
+IO_GRPC_GRPC_JAVA_ARTIFACTS = [
+    "com.google.android:annotations:4.1.1.4",
+    "com.google.api.grpc:proto-google-common-protos:2.63.2",
+    "com.google.auth:google-auth-library-credentials:1.41.0",
+    "com.google.auth:google-auth-library-oauth2-http:1.41.0",
+    "com.google.auto.value:auto-value-annotations:1.11.0",
+    "com.google.auto.value:auto-value:1.11.0",
+    "com.google.code.findbugs:jsr305:3.0.2",
+    "com.google.code.gson:gson:2.12.1",
+    "com.google.errorprone:error_prone_annotations:2.45.0",
+    "com.google.guava:failureaccess:1.0.1",
+    "com.google.guava:guava:33.5.0-android",
+    "com.google.re2j:re2j:1.8",
+    "com.google.s2a.proto.v2:s2a-proto:0.1.3",
+    "com.google.truth:truth:1.4.5",
+    "com.squareup.okhttp:okhttp:2.7.5",
+    "com.squareup.okio:okio:2.10.0",  # 3.0+ needs swapping to -jvm; need work to avoid flag-day
+    "io.netty:netty-buffer:4.1.130.Final",
+    "io.netty:netty-codec-http2:4.1.130.Final",
+    "io.netty:netty-codec-http:4.1.130.Final",
+    "io.netty:netty-codec-socks:4.1.130.Final",
+    "io.netty:netty-codec:4.1.130.Final",
+    "io.netty:netty-common:4.1.130.Final",
+    "io.netty:netty-handler-proxy:4.1.130.Final",
+    "io.netty:netty-handler:4.1.130.Final",
+    "io.netty:netty-resolver:4.1.130.Final",
+    "io.netty:netty-tcnative-boringssl-static:2.0.74.Final",
+    "io.netty:netty-tcnative-classes:2.0.74.Final",
+    "io.netty:netty-transport-native-epoll:jar:linux-x86_64:4.1.130.Final",
+    "io.netty:netty-transport-native-unix-common:4.1.130.Final",
+    "io.netty:netty-transport:4.1.130.Final",
+    "io.opencensus:opencensus-api:0.31.0",
+    "io.opencensus:opencensus-contrib-grpc-metrics:0.31.0",
+    "io.perfmark:perfmark-api:0.27.0",
+    "junit:junit:4.13.2",
+    "org.checkerframework:checker-qual:3.49.5",
+    "org.codehaus.mojo:animal-sniffer-annotations:1.26",
+]
+# GRPC_DEPS_END
+
+# For use with maven_install's override_targets.
+# maven_install(
+#     ...
+#     override_targets = IO_GRPC_GRPC_JAVA_OVERRIDE_TARGETS,
+# )
+#
+# If you have your own overrides as well, you can use:
+#     override_targets = {
+#         "your.target:artifact": "@//third_party/artifact",
+#     } | IO_GRPC_GRPC_JAVA_OVERRIDE_TARGETS,
+IO_GRPC_GRPC_JAVA_OVERRIDE_TARGETS = {
+    "com.google.protobuf:protobuf-java": "@com_google_protobuf//:protobuf_java",
+    "com.google.protobuf:protobuf-java-util": "@com_google_protobuf//:protobuf_java_util",
+    "com.google.protobuf:protobuf-javalite": "@com_google_protobuf//:protobuf_javalite",
+    "io.grpc:grpc-alts": "@io_grpc_grpc_java//alts",
+    "io.grpc:grpc-api": "@io_grpc_grpc_java//api",
+    "io.grpc:grpc-auth": "@io_grpc_grpc_java//auth",
+    "io.grpc:grpc-census": "@io_grpc_grpc_java//census",
+    "io.grpc:grpc-context": "@io_grpc_grpc_java//context",
+    "io.grpc:grpc-core": "@io_grpc_grpc_java//core:core_maven",
+    "io.grpc:grpc-googleapis": "@io_grpc_grpc_java//googleapis",
+    "io.grpc:grpc-grpclb": "@io_grpc_grpc_java//grpclb",
+    "io.grpc:grpc-inprocess": "@io_grpc_grpc_java//inprocess",
+    "io.grpc:grpc-netty": "@io_grpc_grpc_java//netty",
+    "io.grpc:grpc-netty-shaded": "@io_grpc_grpc_java//netty:shaded_maven",
+    "io.grpc:grpc-okhttp": "@io_grpc_grpc_java//okhttp",
+    "io.grpc:grpc-protobuf": "@io_grpc_grpc_java//protobuf",
+    "io.grpc:grpc-protobuf-lite": "@io_grpc_grpc_java//protobuf-lite",
+    "io.grpc:grpc-rls": "@io_grpc_grpc_java//rls",
+    "io.grpc:grpc-services": "@io_grpc_grpc_java//services:services_maven",
+    "io.grpc:grpc-stub": "@io_grpc_grpc_java//stub",
+    "io.grpc:grpc-s2a": "@io_grpc_grpc_java//s2a",
+    "io.grpc:grpc-testing": "@io_grpc_grpc_java//testing",
+    "io.grpc:grpc-xds": "@io_grpc_grpc_java//xds:xds_maven",
+    "io.grpc:grpc-util": "@io_grpc_grpc_java//util",
+}
+
+def grpc_java_repositories():
+    """Imports dependencies for grpc-java."""
+    if not native.existing_rule("com_google_protobuf"):
+        com_google_protobuf()
+    if not native.existing_rule("com_google_googleapis"):
+        http_archive(
+            name = "com_google_googleapis",
+            sha256 = "49930468563dd48283e8301e8d4e71436bf6d27ac27c235224cc1a098710835d",
+            strip_prefix = "googleapis-ca1372c6d7bcb199638ebfdb40d2b2660bab7b88",
+            urls = [
+                "https://github.com/googleapis/googleapis/archive/ca1372c6d7bcb199638ebfdb40d2b2660bab7b88.tar.gz",
+            ],
+        )
+    if not native.existing_rule("io_grpc_grpc_proto"):
+        io_grpc_grpc_proto()
+    if not native.existing_rule("bazel_jar_jar"):
+        http_archive(
+            name = "bazel_jar_jar",
+            sha256 = "3117f913c732142a795551f530d02c9157b9ea895e6b2de0fbb5af54f03040a5",
+            strip_prefix = "bazel_jar_jar-0.1.6",
+            url = "https://github.com/bazeltools/bazel_jar_jar/releases/download/v0.1.6/bazel_jar_jar-v0.1.6.tar.gz",
+        )
+
+def com_google_protobuf():
+    # proto_library rules implicitly depend on @com_google_protobuf//:protoc,
+    # which is the proto-compiler.
+    # This statement defines the @com_google_protobuf repo.
+    http_archive(
+        name = "com_google_protobuf",
+        sha256 = "bc670a4e34992c175137ddda24e76562bb928f849d712a0e3c2fb2e19249bea1",
+        strip_prefix = "protobuf-33.4",
+        urls = ["https://github.com/protocolbuffers/protobuf/releases/download/v33.4/protobuf-33.4.tar.gz"],
+    )
+
+def io_grpc_grpc_proto():
+    http_archive(
+        name = "io_grpc_grpc_proto",
+        sha256 = "729ac127a003836d539ed9da72a21e094aac4c4609e0481d6fc9e28a844e11af",
+        strip_prefix = "grpc-proto-4f245d272a28a680606c0739753506880cf33b5f",
+        urls = ["https://github.com/grpc/grpc-proto/archive/4f245d272a28a680606c0739753506880cf33b5f.zip"],
+    )
diff --git a/rls/BUILD.bazel b/rls/BUILD.bazel
new file mode 100644
index 00000000000..70c17a9c8b6
--- /dev/null
+++ b/rls/BUILD.bazel
@@ -0,0 +1,32 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+load("//:java_grpc_library.bzl", "java_grpc_library")
+
+java_library(
+    name = "rls",
+    srcs = glob([
+        "src/main/java/io/grpc/rls/*.java",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        ":rls_java_grpc",
+        "//:auto_value_annotations",
+        "//api",
+        "//core",
+        "//core:internal",
+        "//stub",
+        "//util",
+        "@io_grpc_grpc_proto//:rls_config_java_proto",
+        "@io_grpc_grpc_proto//:rls_java_proto",
+        artifact("com.google.auto.value:auto-value-annotations"),
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+    ],
+)
+
+java_grpc_library(
+    name = "rls_java_grpc",
+    srcs = ["@io_grpc_grpc_proto//:rls_proto"],
+    deps = ["@io_grpc_grpc_proto//:rls_java_proto"],
+)
diff --git a/rls/build.gradle b/rls/build.gradle
new file mode 100644
index 00000000000..10b1d5fc371
--- /dev/null
+++ b/rls/build.gradle
@@ -0,0 +1,65 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+    id "com.google.protobuf"
+    id "jacoco"
+    id "ru.vyarus.animalsniffer"
+}
+
+description = "gRPC: RouteLookupService Loadbalancing plugin"
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.rls')
+    }
+}
+
+dependencies {
+    implementation project(':grpc-util'),
+            project(':grpc-core'),
+            project(':grpc-protobuf'),
+            project(':grpc-stub'),
+            libraries.auto.value.annotations,
+            libraries.guava
+    annotationProcessor libraries.auto.value
+    testImplementation libraries.truth,
+            project(':grpc-grpclb'),
+            project(':grpc-inprocess'),
+            project(':grpc-testing'),
+            project(':grpc-testing-proto'),
+            testFixtures(project(':grpc-api')),
+            testFixtures(project(':grpc-core'))
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+tasks.named("compileJava").configure {
+    it.options.compilerArgs += [
+            // only has AutoValue annotation processor
+            "-Xlint:-processing",
+    ]
+    appendToProperty(
+            it.options.errorprone.excludedPaths,
+            ".*/build/generated/sources/annotationProcessor/java/.*",
+            "|")
+}
+
+tasks.named("javadoc").configure {
+    // Do not publish javadoc since currently there is no public API.
+    failOnError = false  // no public or protected classes found to document
+    exclude 'io/grpc/lookup/v1/**'
+    exclude 'io/grpc/rls/*Provider.java'
+    exclude 'io/grpc/rls/internal/**'
+    exclude 'io/grpc/rls/Internal*'
+}
+
+tasks.named("jacocoTestReport").configure {
+    classDirectories.from = sourceSets.main.output.collect {
+        fileTree(dir: it, exclude: ['**/io/grpc/lookup/**'])
+    }
+}
+
+configureProtoCompilation()
diff --git a/rls/src/generated/main/grpc/io/grpc/lookup/v1/RouteLookupServiceGrpc.java b/rls/src/generated/main/grpc/io/grpc/lookup/v1/RouteLookupServiceGrpc.java
new file mode 100644
index 00000000000..be060e576a4
--- /dev/null
+++ b/rls/src/generated/main/grpc/io/grpc/lookup/v1/RouteLookupServiceGrpc.java
@@ -0,0 +1,344 @@
+package io.grpc.lookup.v1;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class RouteLookupServiceGrpc {
+
+  private RouteLookupServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.lookup.v1.RouteLookupService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.lookup.v1.RouteLookupRequest,
+      io.grpc.lookup.v1.RouteLookupResponse> getRouteLookupMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "RouteLookup",
+      requestType = io.grpc.lookup.v1.RouteLookupRequest.class,
+      responseType = io.grpc.lookup.v1.RouteLookupResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.lookup.v1.RouteLookupRequest,
+      io.grpc.lookup.v1.RouteLookupResponse> getRouteLookupMethod() {
+    io.grpc.MethodDescriptor<io.grpc.lookup.v1.RouteLookupRequest, io.grpc.lookup.v1.RouteLookupResponse> getRouteLookupMethod;
+    if ((getRouteLookupMethod = RouteLookupServiceGrpc.getRouteLookupMethod) == null) {
+      synchronized (RouteLookupServiceGrpc.class) {
+        if ((getRouteLookupMethod = RouteLookupServiceGrpc.getRouteLookupMethod) == null) {
+          RouteLookupServiceGrpc.getRouteLookupMethod = getRouteLookupMethod =
+              io.grpc.MethodDescriptor.<io.grpc.lookup.v1.RouteLookupRequest, io.grpc.lookup.v1.RouteLookupResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "RouteLookup"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.lookup.v1.RouteLookupRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.lookup.v1.RouteLookupResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new RouteLookupServiceMethodDescriptorSupplier("RouteLookup"))
+              .build();
+        }
+      }
+    }
+    return getRouteLookupMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static RouteLookupServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<RouteLookupServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<RouteLookupServiceStub>() {
+        @java.lang.Override
+        public RouteLookupServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new RouteLookupServiceStub(channel, callOptions);
+        }
+      };
+    return RouteLookupServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static RouteLookupServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<RouteLookupServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<RouteLookupServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public RouteLookupServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new RouteLookupServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return RouteLookupServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static RouteLookupServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<RouteLookupServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<RouteLookupServiceBlockingStub>() {
+        @java.lang.Override
+        public RouteLookupServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new RouteLookupServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return RouteLookupServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static RouteLookupServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<RouteLookupServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<RouteLookupServiceFutureStub>() {
+        @java.lang.Override
+        public RouteLookupServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new RouteLookupServiceFutureStub(channel, callOptions);
+        }
+      };
+    return RouteLookupServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Lookup returns a target for a single key.
+     * </pre>
+     */
+    default void routeLookup(io.grpc.lookup.v1.RouteLookupRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.lookup.v1.RouteLookupResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRouteLookupMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service RouteLookupService.
+   */
+  public static abstract class RouteLookupServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return RouteLookupServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service RouteLookupService.
+   */
+  public static final class RouteLookupServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<RouteLookupServiceStub> {
+    private RouteLookupServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected RouteLookupServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new RouteLookupServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Lookup returns a target for a single key.
+     * </pre>
+     */
+    public void routeLookup(io.grpc.lookup.v1.RouteLookupRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.lookup.v1.RouteLookupResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getRouteLookupMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service RouteLookupService.
+   */
+  public static final class RouteLookupServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<RouteLookupServiceBlockingV2Stub> {
+    private RouteLookupServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected RouteLookupServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new RouteLookupServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Lookup returns a target for a single key.
+     * </pre>
+     */
+    public io.grpc.lookup.v1.RouteLookupResponse routeLookup(io.grpc.lookup.v1.RouteLookupRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getRouteLookupMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service RouteLookupService.
+   */
+  public static final class RouteLookupServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<RouteLookupServiceBlockingStub> {
+    private RouteLookupServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected RouteLookupServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new RouteLookupServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Lookup returns a target for a single key.
+     * </pre>
+     */
+    public io.grpc.lookup.v1.RouteLookupResponse routeLookup(io.grpc.lookup.v1.RouteLookupRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getRouteLookupMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service RouteLookupService.
+   */
+  public static final class RouteLookupServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<RouteLookupServiceFutureStub> {
+    private RouteLookupServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected RouteLookupServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new RouteLookupServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Lookup returns a target for a single key.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.lookup.v1.RouteLookupResponse> routeLookup(
+        io.grpc.lookup.v1.RouteLookupRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getRouteLookupMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_ROUTE_LOOKUP = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_ROUTE_LOOKUP:
+          serviceImpl.routeLookup((io.grpc.lookup.v1.RouteLookupRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.lookup.v1.RouteLookupResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getRouteLookupMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.lookup.v1.RouteLookupRequest,
+              io.grpc.lookup.v1.RouteLookupResponse>(
+                service, METHODID_ROUTE_LOOKUP)))
+        .build();
+  }
+
+  private static abstract class RouteLookupServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    RouteLookupServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.lookup.v1.RlsProto.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("RouteLookupService");
+    }
+  }
+
+  private static final class RouteLookupServiceFileDescriptorSupplier
+      extends RouteLookupServiceBaseDescriptorSupplier {
+    RouteLookupServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class RouteLookupServiceMethodDescriptorSupplier
+      extends RouteLookupServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    RouteLookupServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (RouteLookupServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new RouteLookupServiceFileDescriptorSupplier())
+              .addMethod(getRouteLookupMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/rls/src/main/java/io/grpc/rls/AdaptiveThrottler.java b/rls/src/main/java/io/grpc/rls/AdaptiveThrottler.java
new file mode 100644
index 00000000000..576b234b0c3
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/AdaptiveThrottler.java
@@ -0,0 +1,343 @@
+/*
+ * 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.rls;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Ticker;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLongFieldUpdater;
+import java.util.concurrent.atomic.AtomicReferenceArray;
+
+/**
+ * Implementation of {@link Throttler} that keeps track of recent history (the duration of which is
+ * specified to the constructor) and throttles requests at the client side based on the number of
+ * requests that the
+ * backend has accepted and the total number of requests generated. A given request will be
+ * throttled with a probability
+ * <pre>
+ *   throttleProbability = (requests - ratio_for_accepts * accepts) / (requests + requests_padding)
+ * </pre>
+ * where requests is the total number of requests, accepts is the total number of requests that the
+ * backend has accepted and ratio_for_accepts is just a constant multiplier passed to the
+ * constructor (see the description of ratio_for_accepts for more information).
+ */
+final class AdaptiveThrottler implements Throttler {
+
+  private static final int DEFAULT_HISTORY_SECONDS = 30;
+  private static final int DEFAULT_REQUEST_PADDING = 8;
+  private static final float DEFAULT_RATIO_FOR_ACCEPT = 2.0f;
+
+  /**
+   * The duration of history of calls used by Adaptive Throttler.
+   */
+  private final int historySeconds;
+  /**
+   * A magic number to tune the aggressiveness of the throttling. High numbers throttle less. The
+   * default is 8.
+   */
+  private final int requestsPadding;
+  /**
+   * The ratio by which the Adaptive Throttler will attempt to send requests above what the server
+   * is currently accepting.
+   */
+  private final float ratioForAccepts;
+  private final Ticker ticker;
+  /**
+   * The number of requests attempted by the client during the Adaptive Throttler instance's
+   * history of calls. This includes requests throttled at the client. The history period defaults
+   * to 30 seconds.
+   */
+  @VisibleForTesting
+  final TimeBasedAccumulator requestStat;
+  /**
+   * Counter for the total number of requests that were throttled by either the client (this class)
+   * or the backend in recent history.
+   */
+  @VisibleForTesting
+  final TimeBasedAccumulator throttledStat;
+
+  private AdaptiveThrottler(Builder builder) {
+    this.historySeconds = builder.historySeconds;
+    this.requestsPadding = builder.requestsPadding;
+    this.ratioForAccepts = builder.ratioForAccepts;
+    this.ticker = builder.ticker;
+    long internalNanos = TimeUnit.SECONDS.toNanos(historySeconds);
+    this.requestStat = new TimeBasedAccumulator(internalNanos, ticker);
+    this.throttledStat = new TimeBasedAccumulator(internalNanos, ticker);
+  }
+
+  @Override
+  public boolean shouldThrottle() {
+    return shouldThrottle(randomFloat());
+  }
+
+  @VisibleForTesting
+  boolean shouldThrottle(float random) {
+    long nowNanos = ticker.read();
+    if (getThrottleProbability(nowNanos) <= random) {
+      return false;
+    }
+    requestStat.increment(nowNanos);
+    throttledStat.increment(nowNanos);
+    return true;
+  }
+
+  /**
+   * Calculates throttleProbability.
+   * <pre>
+   * throttleProbability = (requests - ratio_for_accepts * accepts) / (requests + requests_padding)
+   * </pre>
+   */
+  @VisibleForTesting
+  float getThrottleProbability(long nowNanos) {
+    long requests = this.requestStat.get(nowNanos);
+    long accepts = requests - throttledStat.get(nowNanos);
+    // It's possible that this probability will be negative, which means that no throttling should
+    // take place.
+    return (requests - ratioForAccepts * accepts) / (requests + requestsPadding);
+  }
+
+  @Override
+  public void registerBackendResponse(boolean throttled) {
+    long now = ticker.read();
+    requestStat.increment(now);
+    if (throttled) {
+      throttledStat.increment(now);
+    }
+  }
+
+  private static float randomFloat() {
+    return ThreadLocalRandom.current().nextFloat();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("historySeconds", historySeconds)
+        .add("requestsPadding", requestsPadding)
+        .add("ratioForAccepts", ratioForAccepts)
+        .add("requestStat", requestStat)
+        .add("throttledStat", throttledStat)
+        .toString();
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  /** Builder for {@link AdaptiveThrottler}. */
+  static final class Builder {
+
+    private float ratioForAccepts = DEFAULT_RATIO_FOR_ACCEPT;
+    private int historySeconds = DEFAULT_HISTORY_SECONDS;
+    private int requestsPadding = DEFAULT_REQUEST_PADDING;
+    private Ticker ticker = Ticker.systemTicker();
+
+    public Builder setRatioForAccepts(float ratioForAccepts) {
+      this.ratioForAccepts = ratioForAccepts;
+      return this;
+    }
+
+    public Builder setHistorySeconds(int historySeconds) {
+      this.historySeconds = historySeconds;
+      return this;
+    }
+
+    public Builder setRequestsPadding(int requestsPadding) {
+      this.requestsPadding = requestsPadding;
+      return this;
+    }
+
+    public Builder setTicker(Ticker ticker) {
+      this.ticker = checkNotNull(ticker, "ticker");
+      return this;
+    }
+
+    public AdaptiveThrottler build() {
+      return new AdaptiveThrottler(this);
+    }
+  }
+
+  static final class TimeBasedAccumulator {
+    /**
+     * The number of slots. This value determines the accuracy of the get() method to interval /
+     * NUM_SLOTS.
+     */
+    private static final int NUM_SLOTS = 50;
+
+    /** Holds the data for each slot (amount and end timestamp). */
+    private static final class Slot {
+      static final AtomicLongFieldUpdater<Slot> ATOMIC_COUNT =
+          AtomicLongFieldUpdater.newUpdater(Slot.class, "count");
+
+      // The count of statistics for the time range represented by this slot.
+      volatile long count;
+      // The nearest 0 modulo slot boundary in nanoseconds. The slot boundary
+      // is exclusive. [previous_slot.end, end)
+      final long endNanos;
+
+      Slot(long endNanos) {
+        this.endNanos = endNanos;
+        this.count = 0;
+      }
+
+      void increment() {
+        ATOMIC_COUNT.incrementAndGet(this);
+      }
+    }
+
+    /** The array of slots. */
+    private final AtomicReferenceArray<Slot> slots = new AtomicReferenceArray<>(NUM_SLOTS);
+
+    /** The time interval this statistic is concerned with. */
+    private final long interval;
+
+    /** The number of nanoseconds in each slot. */
+    private final long slotNanos;
+
+    /**
+     * The current index into the slot array. {@code currentIndex} may be safely read without
+     * synchronization, but all writes must be performed inside of a {@code synchronized(this){}}
+     * block.
+     */
+    private volatile int currentIndex;
+
+    private final Ticker ticker;
+
+    /**
+     * Interval constructor.
+     *
+     * @param internalNanos is the stat interval in nanoseconds
+     * @throws IllegalArgumentException if the supplied interval is too small to be effective
+     */
+    TimeBasedAccumulator(long internalNanos, Ticker ticker) {
+      checkArgument(
+          internalNanos >= NUM_SLOTS,
+          "Interval must be greater than %s",
+          NUM_SLOTS);
+      this.interval = internalNanos;
+      this.slotNanos = internalNanos / NUM_SLOTS;
+      this.currentIndex = 0;
+      this.ticker = checkNotNull(ticker, "ticker");
+    }
+
+    /** Gets the current slot. */
+    private Slot getSlot(long now) {
+      Slot currentSlot = slots.get(currentIndex);
+      if (currentSlot != null && now - currentSlot.endNanos < 0) {
+        return currentSlot;
+      } else {
+        long slotBoundary = getSlotEndTime(now);
+        synchronized (this) {
+          int index = currentIndex;
+          currentSlot = slots.get(index);
+          if (currentSlot != null && now - currentSlot.endNanos < 0) {
+            return currentSlot;
+          }
+          int newIndex = (index == NUM_SLOTS - 1) ? 0 : index + 1;
+          Slot nextSlot = new Slot(slotBoundary);
+          slots.set(newIndex, nextSlot);
+          // Set currentIndex only after assigning the new slot to slots, otherwise
+          // racing readers will see null or an old slot.
+          currentIndex = newIndex;
+          return nextSlot;
+        }
+      }
+    }
+
+    /**
+     * Computes the end boundary since the last bucket can be partial size.
+     *
+     * @param time the time for which to find the nearest slot boundary
+     * @return the nearest slot boundary in nanos
+     */
+    private long getSlotEndTime(long time) {
+      return (time / slotNanos + 1) * slotNanos;
+    }
+
+    /**
+     * Returns the interval used by this statistic.
+     *
+     * @return the interval
+     */
+    long getInterval() {
+      return this.interval;
+    }
+
+    /**
+     * Increments the count of the statistic by the specified amount for the specified time.
+     *
+     * @param now is the time used to increment the count
+     */
+    void increment(long now) {
+      getSlot(now).increment();
+    }
+
+    /**
+     * Returns the count of the statistic using the specified time value as the current time.
+     *
+     * @param now the current time
+     * @return the statistic count
+     */
+    long get(long now) {
+      long intervalEnd = getSlotEndTime(now);
+      long intervalStart = intervalEnd - interval;
+      // This is the point at which increments to new slots will be ignored.
+      int index = currentIndex;
+
+      long accumulated = 0L;
+      Long prevSlotEnd = null;
+      for (int i = 0; i < NUM_SLOTS; i++) {
+        if (index < 0) {
+          index = NUM_SLOTS - 1;
+        }
+        Slot currentSlot = slots.get(index);
+        index--;
+        if (currentSlot == null) {
+          continue;
+        }
+
+        long currentSlotEnd = currentSlot.endNanos;
+
+        if (currentSlotEnd - intervalStart <= 0
+            || (prevSlotEnd != null && currentSlotEnd - prevSlotEnd > 0)) {
+          break;
+        }
+        prevSlotEnd = currentSlotEnd;
+
+        if (currentSlotEnd - intervalEnd > 0) {
+          continue;
+        }
+        accumulated = accumulated + currentSlot.count;
+      }
+      return accumulated;
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("interval", interval)
+          .add("current_count", get(ticker.read()))
+          .toString();
+    }
+  }
+}
diff --git a/rls/src/main/java/io/grpc/rls/CachingRlsLbClient.java b/rls/src/main/java/io/grpc/rls/CachingRlsLbClient.java
new file mode 100644
index 00000000000..83e9d482bc5
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/CachingRlsLbClient.java
@@ -0,0 +1,1096 @@
+/*
+ * 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.rls;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Converter;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.MoreObjects.ToStringHelper;
+import com.google.common.base.Ticker;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.errorprone.annotations.CheckReturnValue;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LongCounterMetricInstrument;
+import io.grpc.LongGaugeMetricInstrument;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Metadata;
+import io.grpc.MetricInstrumentRegistry;
+import io.grpc.MetricRecorder.BatchCallback;
+import io.grpc.MetricRecorder.BatchRecorder;
+import io.grpc.MetricRecorder.Registration;
+import io.grpc.Status;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.ExponentialBackoffPolicy;
+import io.grpc.lookup.v1.RouteLookupServiceGrpc;
+import io.grpc.lookup.v1.RouteLookupServiceGrpc.RouteLookupServiceStub;
+import io.grpc.rls.ChildLoadBalancerHelper.ChildLoadBalancerHelperProvider;
+import io.grpc.rls.LbPolicyConfiguration.ChildPolicyWrapper;
+import io.grpc.rls.LbPolicyConfiguration.RefCountedChildPolicyWrapperFactory;
+import io.grpc.rls.LruCache.EvictionListener;
+import io.grpc.rls.LruCache.EvictionType;
+import io.grpc.rls.RlsProtoConverters.RouteLookupResponseConverter;
+import io.grpc.rls.RlsProtoData.RouteLookupConfig;
+import io.grpc.rls.RlsProtoData.RouteLookupRequest;
+import io.grpc.rls.RlsProtoData.RouteLookupRequestKey;
+import io.grpc.rls.RlsProtoData.RouteLookupResponse;
+import io.grpc.stub.StreamObserver;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A CachingRlsLbClient is a core implementation of RLS loadbalancer supports dynamic request
+ * routing by fetching the decision from route lookup server. Every single request is routed by
+ * the server's decision. To reduce the performance penalty, {@link LruCache} is used.
+ */
+@ThreadSafe
+final class CachingRlsLbClient {
+
+  private static final Converter<RouteLookupRequest, io.grpc.lookup.v1.RouteLookupRequest>
+      REQUEST_CONVERTER = new RlsProtoConverters.RouteLookupRequestConverter().reverse();
+  private static final Converter<RouteLookupResponse, io.grpc.lookup.v1.RouteLookupResponse>
+      RESPONSE_CONVERTER = new RouteLookupResponseConverter().reverse();
+  public static final long MIN_EVICTION_TIME_DELTA_NANOS = TimeUnit.SECONDS.toNanos(5);
+  public static final int BYTES_PER_CHAR = 2;
+  public static final int STRING_OVERHEAD_BYTES = 38;
+  /** Minimum bytes for a Java Object. */
+  public static final int OBJ_OVERHEAD_B = 16;
+
+  private static final LongCounterMetricInstrument DEFAULT_TARGET_PICKS_COUNTER;
+  private static final LongCounterMetricInstrument TARGET_PICKS_COUNTER;
+  private static final LongCounterMetricInstrument FAILED_PICKS_COUNTER;
+  private static final LongGaugeMetricInstrument CACHE_ENTRIES_GAUGE;
+  private static final LongGaugeMetricInstrument CACHE_SIZE_GAUGE;
+  private final Registration gaugeRegistration;
+  private final String metricsInstanceUuid = UUID.randomUUID().toString();
+
+  // All cache status changes (pending, backoff, success) must be under this lock
+  private final Object lock = new Object();
+  // LRU cache based on access order (BACKOFF and actual data will be here)
+  @GuardedBy("lock")
+  private final RlsAsyncLruCache linkedHashLruCache;
+  private final Future<?> periodicCleaner;
+  // any RPC on the fly will cached in this map
+  @GuardedBy("lock")
+  private final Map<RouteLookupRequestKey, PendingCacheEntry> pendingCallCache = new HashMap<>();
+
+  private final ScheduledExecutorService scheduledExecutorService;
+  private final Ticker ticker;
+  private final Throttler throttler;
+
+  private final LbPolicyConfiguration lbPolicyConfig;
+  private final BackoffPolicy.Provider backoffProvider;
+  private final long maxAgeNanos;
+  private final long staleAgeNanos;
+  private final long callTimeoutNanos;
+
+  private final RlsLbHelper helper;
+  private final ManagedChannel rlsChannel;
+  private final RouteLookupServiceStub rlsStub;
+  private final RlsPicker rlsPicker;
+  private final ResolvedAddressFactory childLbResolvedAddressFactory;
+  @GuardedBy("lock")
+  private final RefCountedChildPolicyWrapperFactory refCountedChildPolicyWrapperFactory;
+  private final ChannelLogger logger;
+  private final ChildPolicyWrapper fallbackChildPolicyWrapper;
+
+  static {
+    MetricInstrumentRegistry metricInstrumentRegistry
+        = MetricInstrumentRegistry.getDefaultRegistry();
+    DEFAULT_TARGET_PICKS_COUNTER = metricInstrumentRegistry.registerLongCounter(
+        "grpc.lb.rls.default_target_picks",
+        "EXPERIMENTAL. Number of LB picks sent to the default target", "{pick}",
+        Arrays.asList("grpc.target", "grpc.lb.rls.server_target",
+            "grpc.lb.rls.data_plane_target", "grpc.lb.pick_result"), Collections.emptyList(),
+        false);
+    TARGET_PICKS_COUNTER = metricInstrumentRegistry.registerLongCounter("grpc.lb.rls.target_picks",
+        "EXPERIMENTAL. Number of LB picks sent to each RLS target. Note that if the default "
+            + "target is also returned by the RLS server, RPCs sent to that target from the cache "
+            + "will be counted in this metric, not in grpc.rls.default_target_picks.", "{pick}",
+        Arrays.asList("grpc.target", "grpc.lb.rls.server_target", "grpc.lb.rls.data_plane_target",
+            "grpc.lb.pick_result"), Collections.emptyList(),
+        false);
+    FAILED_PICKS_COUNTER = metricInstrumentRegistry.registerLongCounter("grpc.lb.rls.failed_picks",
+        "EXPERIMENTAL. Number of LB picks failed due to either a failed RLS request or the "
+            + "RLS channel being throttled", "{pick}",
+        Arrays.asList("grpc.target", "grpc.lb.rls.server_target"),
+        Collections.emptyList(), false);
+    CACHE_ENTRIES_GAUGE = metricInstrumentRegistry.registerLongGauge("grpc.lb.rls.cache_entries",
+        "EXPERIMENTAL. Number of entries in the RLS cache", "{entry}",
+        Arrays.asList("grpc.target", "grpc.lb.rls.server_target", "grpc.lb.rls.instance_uuid"),
+        Collections.emptyList(), false);
+    CACHE_SIZE_GAUGE = metricInstrumentRegistry.registerLongGauge("grpc.lb.rls.cache_size",
+        "EXPERIMENTAL. The current size of the RLS cache", "By",
+        Arrays.asList("grpc.target", "grpc.lb.rls.server_target", "grpc.lb.rls.instance_uuid"),
+        Collections.emptyList(), false);
+  }
+
+  private CachingRlsLbClient(Builder builder) {
+    helper = new RlsLbHelper(checkNotNull(builder.helper, "helper"));
+    scheduledExecutorService = helper.getScheduledExecutorService();
+    lbPolicyConfig = checkNotNull(builder.lbPolicyConfig, "lbPolicyConfig");
+    RouteLookupConfig rlsConfig = lbPolicyConfig.getRouteLookupConfig();
+    maxAgeNanos = rlsConfig.maxAgeInNanos();
+    staleAgeNanos = rlsConfig.staleAgeInNanos();
+    callTimeoutNanos = rlsConfig.lookupServiceTimeoutInNanos();
+    ticker = checkNotNull(builder.ticker, "ticker");
+    throttler = checkNotNull(builder.throttler, "throttler");
+    linkedHashLruCache =
+        new RlsAsyncLruCache(
+            rlsConfig.cacheSizeBytes(),
+            new AutoCleaningEvictionListener(builder.evictionListener),
+            ticker,
+            helper);
+    periodicCleaner =
+        scheduledExecutorService.scheduleAtFixedRate(this::periodicClean, 1, 1, TimeUnit.MINUTES);
+    logger = helper.getChannelLogger();
+    String serverHost = null;
+    try {
+      serverHost = new URI(null, helper.getAuthority(), null, null, null).getHost();
+    } catch (URISyntaxException ignore) {
+      // handled by the following null check
+    }
+    if (serverHost == null) {
+      logger.log(
+          ChannelLogLevel.DEBUG, "Can not get hostname from authority: {0}", helper.getAuthority());
+      serverHost = helper.getAuthority();
+    }
+    RlsRequestFactory requestFactory = new RlsRequestFactory(
+        lbPolicyConfig.getRouteLookupConfig(), serverHost);
+    rlsPicker = new RlsPicker(requestFactory, rlsConfig.lookupService());
+    // It is safe to use helper.getUnsafeChannelCredentials() because the client authenticates the
+    // RLS server using the same authority as the backends, even though the RLS server’s addresses
+    // will be looked up differently than the backends; overrideAuthority(helper.getAuthority()) is
+    // called to impose the authority security restrictions.
+    ManagedChannelBuilder<?> rlsChannelBuilder = helper.createResolvingOobChannelBuilder(
+        rlsConfig.lookupService(), helper.getUnsafeChannelCredentials());
+    rlsChannelBuilder.overrideAuthority(helper.getAuthority());
+    Map<String, ?> routeLookupChannelServiceConfig =
+        lbPolicyConfig.getRouteLookupChannelServiceConfig();
+    if (routeLookupChannelServiceConfig != null) {
+      logger.log(
+          ChannelLogLevel.DEBUG,
+          "RLS channel service config: {0}",
+          routeLookupChannelServiceConfig);
+      rlsChannelBuilder.defaultServiceConfig(routeLookupChannelServiceConfig);
+      rlsChannelBuilder.disableServiceConfigLookUp();
+    }
+    rlsChannel = rlsChannelBuilder.build();
+    Runnable rlsServerConnectivityStateChangeHandler = new Runnable() {
+      private boolean wasInTransientFailure;
+      @Override
+      public void run() {
+        ConnectivityState currentState = rlsChannel.getState(false);
+        if (currentState == ConnectivityState.TRANSIENT_FAILURE) {
+          wasInTransientFailure = true;
+        } else if (wasInTransientFailure && currentState == ConnectivityState.READY) {
+          wasInTransientFailure = false;
+          synchronized (lock) {
+            boolean anyBackoffsCanceled = false;
+            for (CacheEntry value : linkedHashLruCache.values()) {
+              if (value instanceof BackoffCacheEntry) {
+                if (((BackoffCacheEntry) value).scheduledFuture.cancel(false)) {
+                  anyBackoffsCanceled = true;
+                }
+              }
+            }
+            if (anyBackoffsCanceled) {
+              // Cache updated. updateBalancingState() to reattempt picks
+              helper.triggerPendingRpcProcessing();
+            }
+          }
+        }
+        rlsChannel.notifyWhenStateChanged(currentState, this);
+      }
+    };
+    rlsChannel.notifyWhenStateChanged(
+        ConnectivityState.IDLE, rlsServerConnectivityStateChangeHandler);
+    rlsStub = RouteLookupServiceGrpc.newStub(rlsChannel);
+    childLbResolvedAddressFactory =
+        checkNotNull(builder.resolvedAddressFactory, "resolvedAddressFactory");
+    backoffProvider = builder.backoffProvider;
+    ChildLoadBalancerHelperProvider childLbHelperProvider =
+        new ChildLoadBalancerHelperProvider(helper, new SubchannelStateManagerImpl(), rlsPicker);
+    refCountedChildPolicyWrapperFactory =
+        new RefCountedChildPolicyWrapperFactory(
+            lbPolicyConfig.getLoadBalancingPolicy(), childLbResolvedAddressFactory,
+            childLbHelperProvider);
+    // TODO(creamsoup) wait until lb is ready
+    String defaultTarget = lbPolicyConfig.getRouteLookupConfig().defaultTarget();
+    if (defaultTarget != null && !defaultTarget.isEmpty()) {
+      fallbackChildPolicyWrapper = refCountedChildPolicyWrapperFactory.createOrGet(defaultTarget);
+    } else {
+      fallbackChildPolicyWrapper = null;
+    }
+
+    gaugeRegistration = helper.getMetricRecorder()
+        .registerBatchCallback(new BatchCallback() {
+          @Override
+          public void accept(BatchRecorder recorder) {
+            int estimatedSize;
+            long estimatedSizeBytes;
+            synchronized (lock) {
+              estimatedSize = linkedHashLruCache.estimatedSize();
+              estimatedSizeBytes = linkedHashLruCache.estimatedSizeBytes();
+            }
+            recorder.recordLongGauge(CACHE_ENTRIES_GAUGE, estimatedSize,
+                Arrays.asList(helper.getChannelTarget(), rlsConfig.lookupService(),
+                    metricsInstanceUuid), Collections.emptyList());
+            recorder.recordLongGauge(CACHE_SIZE_GAUGE, estimatedSizeBytes,
+                Arrays.asList(helper.getChannelTarget(), rlsConfig.lookupService(),
+                    metricsInstanceUuid), Collections.emptyList());
+          }
+        }, CACHE_ENTRIES_GAUGE, CACHE_SIZE_GAUGE);
+
+    logger.log(ChannelLogLevel.DEBUG, "CachingRlsLbClient created");
+  }
+
+  void init() {
+    synchronized (lock) {
+      refCountedChildPolicyWrapperFactory.init();
+    }
+  }
+
+  Status acceptResolvedAddressFactory(ResolvedAddressFactory childLbResolvedAddressFactory) {
+    synchronized (lock) {
+      return refCountedChildPolicyWrapperFactory.acceptResolvedAddressFactory(
+          childLbResolvedAddressFactory);
+    }
+  }
+
+  /**
+   * Convert the status to UNAVAILABLE and enhance the error message.
+   * @param status status as provided by server
+   * @param serverName Used for error description
+   * @return Transformed status
+   */
+  static Status convertRlsServerStatus(Status status, String serverName) {
+    return Status.UNAVAILABLE.withCause(status.getCause()).withDescription(
+        String.format("Unable to retrieve RLS targets from RLS server %s.  "
+                + "RLS server returned: %s: %s",
+            serverName, status.getCode(), status.getDescription()));
+  }
+
+  private void periodicClean() {
+    synchronized (lock) {
+      linkedHashLruCache.cleanupExpiredEntries();
+    }
+  }
+
+  /** Populates async cache entry for new request. */
+  @GuardedBy("lock")
+  private CachedRouteLookupResponse asyncRlsCall(
+      RouteLookupRequestKey routeLookupRequestKey, @Nullable BackoffPolicy backoffPolicy,
+      RouteLookupRequest.Reason routeLookupReason) {
+    if (throttler.shouldThrottle()) {
+      logger.log(ChannelLogLevel.DEBUG, "[RLS Entry {0}] Throttled RouteLookup",
+          routeLookupRequestKey);
+      // Cache updated, but no need to call updateBalancingState because no RPCs were queued waiting
+      // on this result
+      return CachedRouteLookupResponse.backoffEntry(createBackOffEntry(
+          routeLookupRequestKey, Status.RESOURCE_EXHAUSTED.withDescription("RLS throttled"),
+          backoffPolicy));
+    }
+    final SettableFuture<RouteLookupResponse> response = SettableFuture.create();
+    io.grpc.lookup.v1.RouteLookupRequest routeLookupRequest = REQUEST_CONVERTER.convert(
+        RouteLookupRequest.create(routeLookupRequestKey.keyMap(), routeLookupReason));
+    logger.log(ChannelLogLevel.DEBUG,
+        "[RLS Entry {0}] Starting RouteLookup: {1}", routeLookupRequestKey, routeLookupRequest);
+    rlsStub.withDeadlineAfter(callTimeoutNanos, TimeUnit.NANOSECONDS)
+        .routeLookup(
+            routeLookupRequest,
+            new StreamObserver<io.grpc.lookup.v1.RouteLookupResponse>() {
+              @Override
+              public void onNext(io.grpc.lookup.v1.RouteLookupResponse value) {
+                logger.log(ChannelLogLevel.DEBUG,
+                    "[RLS Entry {0}] RouteLookup succeeded: {1}", routeLookupRequestKey, value);
+                response.set(RESPONSE_CONVERTER.reverse().convert(value));
+              }
+
+              @Override
+              public void onError(Throwable t) {
+                logger.log(ChannelLogLevel.DEBUG,
+                    "[RLS Entry {0}] RouteLookup failed: {1}", routeLookupRequestKey, t);
+                response.setException(t);
+                throttler.registerBackendResponse(true);
+              }
+
+              @Override
+              public void onCompleted() {
+                throttler.registerBackendResponse(false);
+              }
+            });
+    return CachedRouteLookupResponse.pendingResponse(
+        createPendingEntry(routeLookupRequestKey, response, backoffPolicy));
+  }
+
+  /**
+   * Returns async response of the {@code request}. The returned value can be in 3 different states;
+   * cached, pending and backed-off due to error. The result remains same even if the status is
+   * changed after the return.
+   */
+  @CheckReturnValue
+  final CachedRouteLookupResponse get(final RouteLookupRequestKey routeLookupRequestKey) {
+    synchronized (lock) {
+      final CacheEntry cacheEntry;
+      cacheEntry = linkedHashLruCache.read(routeLookupRequestKey);
+      if (cacheEntry == null
+          || (cacheEntry instanceof BackoffCacheEntry
+          && !((BackoffCacheEntry) cacheEntry).isInBackoffPeriod())) {
+        PendingCacheEntry pendingEntry = pendingCallCache.get(routeLookupRequestKey);
+        if (pendingEntry != null) {
+          return CachedRouteLookupResponse.pendingResponse(pendingEntry);
+        }
+        return asyncRlsCall(routeLookupRequestKey, cacheEntry instanceof BackoffCacheEntry
+            ? ((BackoffCacheEntry) cacheEntry).backoffPolicy : null,
+            RouteLookupRequest.Reason.REASON_MISS);
+      }
+
+      if (cacheEntry instanceof DataCacheEntry) {
+        // cache hit, initiate async-refresh if entry is staled
+        DataCacheEntry dataEntry = ((DataCacheEntry) cacheEntry);
+        if (dataEntry.isStaled(ticker.read())) {
+          dataEntry.maybeRefresh();
+        }
+        return CachedRouteLookupResponse.dataEntry((DataCacheEntry) cacheEntry);
+      }
+      return CachedRouteLookupResponse.backoffEntry((BackoffCacheEntry) cacheEntry);
+    }
+  }
+
+  /** Performs any pending maintenance operations needed by the cache. */
+  void close() {
+    logger.log(ChannelLogLevel.DEBUG, "CachingRlsLbClient closed");
+    synchronized (lock) {
+      periodicCleaner.cancel(false);
+      // all childPolicyWrapper will be returned via AutoCleaningEvictionListener
+      linkedHashLruCache.close();
+      // TODO(creamsoup) maybe cancel all pending requests
+      pendingCallCache.clear();
+      rlsChannel.shutdownNow();
+      rlsPicker.close();
+      gaugeRegistration.close();
+    }
+  }
+
+  void requestConnection() {
+    rlsChannel.getState(true);
+  }
+
+  @GuardedBy("lock")
+  private PendingCacheEntry createPendingEntry(
+      RouteLookupRequestKey routeLookupRequestKey,
+      ListenableFuture<RouteLookupResponse> pendingCall,
+      @Nullable BackoffPolicy backoffPolicy) {
+    PendingCacheEntry entry = new PendingCacheEntry(routeLookupRequestKey, pendingCall,
+        backoffPolicy);
+    // Add the entry to the map before adding the Listener, because the listener removes the
+    // entry from the map
+    pendingCallCache.put(routeLookupRequestKey, entry);
+    // Beware that the listener can run immediately on the current thread
+    pendingCall.addListener(() -> pendingRpcComplete(entry), MoreExecutors.directExecutor());
+    return entry;
+  }
+
+  private void pendingRpcComplete(PendingCacheEntry entry) {
+    synchronized (lock) {
+      boolean clientClosed = pendingCallCache.remove(entry.routeLookupRequestKey) == null;
+      if (clientClosed) {
+        return;
+      }
+
+      try {
+        createDataEntry(entry.routeLookupRequestKey, Futures.getDone(entry.pendingCall));
+        // Cache updated. DataCacheEntry constructor indirectly calls updateBalancingState() to
+        // reattempt picks when the child LB is done connecting
+      } catch (Exception e) {
+        createBackOffEntry(entry.routeLookupRequestKey, Status.fromThrowable(e),
+            entry.backoffPolicy);
+        // Cache updated. updateBalancingState() to reattempt picks
+        helper.triggerPendingRpcProcessing();
+      }
+    }
+  }
+
+  @GuardedBy("lock")
+  private DataCacheEntry createDataEntry(
+      RouteLookupRequestKey routeLookupRequestKey, RouteLookupResponse routeLookupResponse) {
+    logger.log(
+        ChannelLogLevel.DEBUG,
+        "[RLS Entry {0}] Transition to data cache: routeLookupResponse={1}",
+        routeLookupRequestKey, routeLookupResponse);
+    DataCacheEntry entry = new DataCacheEntry(routeLookupRequestKey, routeLookupResponse);
+    // Constructor for DataCacheEntry causes updateBalancingState, but the picks can't happen until
+    // this cache update because the lock is held
+    linkedHashLruCache.cacheAndClean(routeLookupRequestKey, entry);
+    return entry;
+  }
+
+  @GuardedBy("lock")
+  private BackoffCacheEntry createBackOffEntry(RouteLookupRequestKey routeLookupRequestKey,
+      Status status, @Nullable BackoffPolicy backoffPolicy) {
+    if (backoffPolicy == null) {
+      backoffPolicy = backoffProvider.get();
+    }
+    long delayNanos = backoffPolicy.nextBackoffNanos();
+    logger.log(
+        ChannelLogLevel.DEBUG,
+        "[RLS Entry {0}] Transition to back off: status={1}, delayNanos={2}",
+        routeLookupRequestKey, status, delayNanos);
+    BackoffCacheEntry entry = new BackoffCacheEntry(routeLookupRequestKey, status, backoffPolicy,
+        ticker.read() + delayNanos * 2);
+    // Lock is held, so the task can't execute before the assignment
+    entry.scheduledFuture = scheduledExecutorService.schedule(
+        () -> refreshBackoffEntry(entry), delayNanos, TimeUnit.NANOSECONDS);
+    linkedHashLruCache.cacheAndClean(routeLookupRequestKey, entry);
+    return entry;
+  }
+
+  private void refreshBackoffEntry(BackoffCacheEntry entry) {
+    synchronized (lock) {
+      // This checks whether the task has been cancelled and prevents a second execution.
+      if (!entry.scheduledFuture.cancel(false)) {
+        // Future was previously cancelled
+        return;
+      }
+      // Cache updated. updateBalancingState() to reattempt picks
+      helper.triggerPendingRpcProcessing();
+    }
+  }
+
+  private static final class RlsLbHelper extends ForwardingLoadBalancerHelper {
+
+    final Helper helper;
+    private ConnectivityState state;
+    private SubchannelPicker picker;
+
+    RlsLbHelper(Helper helper) {
+      this.helper = helper;
+    }
+
+    @Override
+    protected Helper delegate() {
+      return helper;
+    }
+
+    @Override
+    public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+      state = newState;
+      picker = newPicker;
+      super.updateBalancingState(newState, newPicker);
+    }
+
+    void triggerPendingRpcProcessing() {
+      checkState(state != null, "updateBalancingState hasn't yet been called");
+      helper.getSynchronizationContext().execute(
+          () -> super.updateBalancingState(state, picker));
+    }
+  }
+
+  /**
+   * Viewer class for cached {@link RouteLookupResponse} and associated {@link ChildPolicyWrapper}.
+   */
+  static final class CachedRouteLookupResponse {
+    // Should only have 1 of following 3 cache entries
+    @Nullable
+    private final DataCacheEntry dataCacheEntry;
+    @Nullable
+    private final PendingCacheEntry pendingCacheEntry;
+    @Nullable
+    private final BackoffCacheEntry backoffCacheEntry;
+
+    CachedRouteLookupResponse(
+        DataCacheEntry dataCacheEntry,
+        PendingCacheEntry pendingCacheEntry,
+        BackoffCacheEntry backoffCacheEntry) {
+      this.dataCacheEntry = dataCacheEntry;
+      this.pendingCacheEntry = pendingCacheEntry;
+      this.backoffCacheEntry = backoffCacheEntry;
+      checkState((dataCacheEntry != null ^ pendingCacheEntry != null ^ backoffCacheEntry != null)
+          && !(dataCacheEntry != null && pendingCacheEntry != null && backoffCacheEntry != null),
+          "Expected only 1 cache entry value provided");
+    }
+
+    static CachedRouteLookupResponse pendingResponse(PendingCacheEntry pendingEntry) {
+      return new CachedRouteLookupResponse(null, pendingEntry, null);
+    }
+
+    static CachedRouteLookupResponse backoffEntry(BackoffCacheEntry backoffEntry) {
+      return new CachedRouteLookupResponse(null, null, backoffEntry);
+    }
+
+    static CachedRouteLookupResponse dataEntry(DataCacheEntry dataEntry) {
+      return new CachedRouteLookupResponse(dataEntry, null, null);
+    }
+
+    boolean hasData() {
+      return dataCacheEntry != null;
+    }
+
+    @Nullable
+    ChildPolicyWrapper getChildPolicyWrapper() {
+      if (!hasData()) {
+        return null;
+      }
+      return dataCacheEntry.getChildPolicyWrapper();
+    }
+
+    @VisibleForTesting
+    @Nullable
+    ChildPolicyWrapper getChildPolicyWrapper(String target) {
+      if (!hasData()) {
+        return null;
+      }
+      return dataCacheEntry.getChildPolicyWrapper(target);
+    }
+
+    @Nullable
+    String getHeaderData() {
+      if (!hasData()) {
+        return null;
+      }
+      return dataCacheEntry.getHeaderData();
+    }
+
+    boolean hasError() {
+      return backoffCacheEntry != null;
+    }
+
+    boolean isPending() {
+      return pendingCacheEntry != null;
+    }
+
+    @Nullable
+    Status getStatus() {
+      if (!hasError()) {
+        return null;
+      }
+      return backoffCacheEntry.getStatus();
+    }
+
+    @Override
+    public String toString() {
+      ToStringHelper toStringHelper = MoreObjects.toStringHelper(this);
+      if (dataCacheEntry != null) {
+        toStringHelper.add("dataCacheEntry", dataCacheEntry);
+      }
+      if (pendingCacheEntry != null) {
+        toStringHelper.add("pendingCacheEntry", pendingCacheEntry);
+      }
+      if (backoffCacheEntry != null) {
+        toStringHelper.add("backoffCacheEntry", backoffCacheEntry);
+      }
+      return toStringHelper.toString();
+    }
+  }
+
+  /** A pending cache entry when the async RouteLookup RPC is still on the fly. */
+  static final class PendingCacheEntry {
+    private final ListenableFuture<RouteLookupResponse> pendingCall;
+    private final RouteLookupRequestKey routeLookupRequestKey;
+    @Nullable
+    private final BackoffPolicy backoffPolicy;
+
+    PendingCacheEntry(
+        RouteLookupRequestKey routeLookupRequestKey,
+        ListenableFuture<RouteLookupResponse> pendingCall,
+        @Nullable BackoffPolicy backoffPolicy) {
+      this.routeLookupRequestKey = checkNotNull(routeLookupRequestKey, "request");
+      this.pendingCall = checkNotNull(pendingCall, "pendingCall");
+      this.backoffPolicy = backoffPolicy;
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("routeLookupRequestKey", routeLookupRequestKey)
+          .toString();
+    }
+  }
+
+  /** Common cache entry data for {@link RlsAsyncLruCache}. */
+  abstract static class CacheEntry {
+
+    protected final RouteLookupRequestKey routeLookupRequestKey;
+
+    CacheEntry(RouteLookupRequestKey routeLookupRequestKey) {
+      this.routeLookupRequestKey = checkNotNull(routeLookupRequestKey, "request");
+    }
+
+    abstract int getSizeBytes();
+
+    abstract boolean isExpired(long now);
+
+    abstract void cleanup();
+
+    protected boolean isOldEnoughToBeEvicted(long now) {
+      return true;
+    }
+  }
+
+  /** Implementation of {@link CacheEntry} contains valid data. */
+  final class DataCacheEntry extends CacheEntry {
+    private final RouteLookupResponse response;
+    private final long minEvictionTime;
+    private final long expireTime;
+    private final long staleTime;
+    private final List<ChildPolicyWrapper> childPolicyWrappers;
+
+    // GuardedBy CachingRlsLbClient.lock
+    DataCacheEntry(RouteLookupRequestKey routeLookupRequestKey,
+        final RouteLookupResponse response) {
+      super(routeLookupRequestKey);
+      this.response = checkNotNull(response, "response");
+      checkState(!response.targets().isEmpty(), "No targets returned by RLS");
+      childPolicyWrappers =
+          refCountedChildPolicyWrapperFactory
+              .createOrGet(response.targets());
+      long now = ticker.read();
+      minEvictionTime = now + MIN_EVICTION_TIME_DELTA_NANOS;
+      expireTime = now + maxAgeNanos;
+      staleTime = now + staleAgeNanos;
+    }
+
+    /**
+     * Refreshes cache entry by creating {@link PendingCacheEntry}. When the {@code
+     * PendingCacheEntry} received data from RLS server, it will replace the data entry if valid
+     * data still exists. Flow looks like following.
+     *
+     * <pre>
+     * Timeline                       | async refresh
+     *                                V put new cache (entry2)
+     * entry1: Pending | hasValue | staled  |
+     * entry2:                        | OV* | pending | hasValue | staled |
+     *
+     * OV: old value
+     * </pre>
+     */
+    void maybeRefresh() {
+      synchronized (lock) { // Lock is already held, but ErrorProne can't tell
+        if (pendingCallCache.containsKey(routeLookupRequestKey)) {
+          // pending already requested
+          return;
+        }
+        logger.log(ChannelLogLevel.DEBUG,
+            "[RLS Entry {0}] Cache entry is stale, refreshing", routeLookupRequestKey);
+        asyncRlsCall(routeLookupRequestKey, /* backoffPolicy= */ null,
+            RouteLookupRequest.Reason.REASON_STALE);
+      }
+    }
+
+    @VisibleForTesting
+    ChildPolicyWrapper getChildPolicyWrapper(String target) {
+      for (ChildPolicyWrapper childPolicyWrapper : childPolicyWrappers) {
+        if (childPolicyWrapper.getTarget().equals(target)) {
+          return childPolicyWrapper;
+        }
+      }
+
+      throw new RuntimeException("Target not found:" + target);
+    }
+
+    @Nullable
+    ChildPolicyWrapper getChildPolicyWrapper() {
+      for (ChildPolicyWrapper childPolicyWrapper : childPolicyWrappers) {
+        if (childPolicyWrapper.getState() != ConnectivityState.TRANSIENT_FAILURE) {
+          return childPolicyWrapper;
+        }
+      }
+      return childPolicyWrappers.get(0);
+    }
+
+    String getHeaderData() {
+      return response.getHeaderData();
+    }
+
+    // Assume UTF-16 (2 bytes) and overhead of a String object is 38 bytes
+    int calcStringSize(String target) {
+      return target.length() * BYTES_PER_CHAR + STRING_OVERHEAD_BYTES;
+    }
+
+    @Override
+    int getSizeBytes() {
+      int targetSize = 0;
+      for (String target : response.targets()) {
+        targetSize += calcStringSize(target);
+      }
+      return targetSize + calcStringSize(response.getHeaderData()) + OBJ_OVERHEAD_B // response size
+          + Long.SIZE * 2 + OBJ_OVERHEAD_B; // Other fields
+    }
+
+    @Override
+    boolean isExpired(long now) {
+      return expireTime - now <= 0;
+    }
+
+    boolean isStaled(long now) {
+      return staleTime - now <= 0;
+    }
+
+    @Override
+    protected boolean isOldEnoughToBeEvicted(long now) {
+      return minEvictionTime - now <= 0;
+    }
+
+    @Override
+    void cleanup() {
+      synchronized (lock) {
+        for (ChildPolicyWrapper policyWrapper : childPolicyWrappers) {
+          refCountedChildPolicyWrapperFactory.release(policyWrapper);
+        }
+      }
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("request", routeLookupRequestKey)
+          .add("response", response)
+          .add("expireTime", expireTime)
+          .add("staleTime", staleTime)
+          .add("childPolicyWrappers", childPolicyWrappers)
+          .toString();
+    }
+  }
+
+  /**
+   * Implementation of {@link CacheEntry} contains error. This entry will transition to pending
+   * status when the backoff time is expired.
+   */
+  private static final class BackoffCacheEntry extends CacheEntry {
+
+    private final Status status;
+    private final BackoffPolicy backoffPolicy;
+    private final long expiryTimeNanos;
+    private Future<?> scheduledFuture;
+
+    BackoffCacheEntry(RouteLookupRequestKey routeLookupRequestKey, Status status,
+        BackoffPolicy backoffPolicy, long expiryTimeNanos) {
+      super(routeLookupRequestKey);
+      this.status = checkNotNull(status, "status");
+      this.backoffPolicy = checkNotNull(backoffPolicy, "backoffPolicy");
+      this.expiryTimeNanos = expiryTimeNanos;
+    }
+
+    Status getStatus() {
+      return status;
+    }
+
+    @Override
+    int getSizeBytes() {
+      return OBJ_OVERHEAD_B * 3 + Long.SIZE + 8; // 3 java objects, 1 long and a boolean
+    }
+
+    boolean isInBackoffPeriod() {
+      return !scheduledFuture.isDone();
+    }
+
+    @Override
+    boolean isExpired(long nowNanos) {
+      return nowNanos > expiryTimeNanos;
+    }
+
+    @Override
+    void cleanup() {
+      scheduledFuture.cancel(false);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("request", routeLookupRequestKey)
+          .add("status", status)
+          .toString();
+    }
+  }
+
+  /** Returns a Builder for {@link CachingRlsLbClient}. */
+  static Builder newBuilder() {
+    return new Builder();
+  }
+
+  /** A Builder for {@link CachingRlsLbClient}. */
+  static final class Builder {
+
+    private Helper helper;
+    private LbPolicyConfiguration lbPolicyConfig;
+    private Throttler throttler = new HappyThrottler();
+    private ResolvedAddressFactory resolvedAddressFactory;
+    private Ticker ticker = Ticker.systemTicker();
+    private EvictionListener<RouteLookupRequestKey, CacheEntry> evictionListener;
+    private BackoffPolicy.Provider backoffProvider = new ExponentialBackoffPolicy.Provider();
+
+    Builder setHelper(Helper helper) {
+      this.helper = checkNotNull(helper, "helper");
+      return this;
+    }
+
+    Builder setLbPolicyConfig(LbPolicyConfiguration lbPolicyConfig) {
+      this.lbPolicyConfig = checkNotNull(lbPolicyConfig, "lbPolicyConfig");
+      return this;
+    }
+
+    Builder setThrottler(Throttler throttler) {
+      this.throttler = checkNotNull(throttler, "throttler");
+      return this;
+    }
+
+    /**
+     * Sets a factory to create {@link ResolvedAddresses} for child load balancer.
+     */
+    Builder setResolvedAddressesFactory(
+        ResolvedAddressFactory resolvedAddressFactory) {
+      this.resolvedAddressFactory =
+          checkNotNull(resolvedAddressFactory, "resolvedAddressFactory");
+      return this;
+    }
+
+    Builder setTicker(Ticker ticker) {
+      this.ticker = checkNotNull(ticker, "ticker");
+      return this;
+    }
+
+    Builder setEvictionListener(
+        @Nullable EvictionListener<RouteLookupRequestKey, CacheEntry> evictionListener) {
+      this.evictionListener = evictionListener;
+      return this;
+    }
+
+    Builder setBackoffProvider(BackoffPolicy.Provider provider) {
+      this.backoffProvider = checkNotNull(provider, "provider");
+      return this;
+    }
+
+    CachingRlsLbClient build() {
+      CachingRlsLbClient client = new CachingRlsLbClient(this);
+      client.init();
+      return client;
+    }
+  }
+
+  /**
+   * When any {@link CacheEntry} is evicted from {@link LruCache}, it performs {@link
+   * CacheEntry#cleanup()} after original {@link EvictionListener} is finished.
+   */
+  private static final class AutoCleaningEvictionListener
+      implements EvictionListener<RouteLookupRequestKey, CacheEntry> {
+
+    private final EvictionListener<RouteLookupRequestKey, CacheEntry> delegate;
+
+    AutoCleaningEvictionListener(
+        @Nullable EvictionListener<RouteLookupRequestKey, CacheEntry> delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    public void onEviction(RouteLookupRequestKey key, CacheEntry value, EvictionType cause) {
+      if (delegate != null) {
+        delegate.onEviction(key, value, cause);
+      }
+      // performs cleanup after delegation
+      value.cleanup();
+    }
+  }
+
+  /** A Throttler never throttles. */
+  private static final class HappyThrottler implements Throttler {
+
+    @Override
+    public boolean shouldThrottle() {
+      return false;
+    }
+
+    @Override
+    public void registerBackendResponse(boolean throttled) {
+      // no-op
+    }
+  }
+
+  /** Implementation of {@link LinkedHashLruCache} for RLS. */
+  private static final class RlsAsyncLruCache
+      extends LinkedHashLruCache<RouteLookupRequestKey, CacheEntry> {
+    private final RlsLbHelper helper;
+
+    RlsAsyncLruCache(long maxEstimatedSizeBytes,
+        @Nullable EvictionListener<RouteLookupRequestKey, CacheEntry> evictionListener,
+        Ticker ticker, RlsLbHelper helper) {
+      super(maxEstimatedSizeBytes, evictionListener, ticker);
+      this.helper = checkNotNull(helper, "helper");
+    }
+
+    @Override
+    protected boolean isExpired(RouteLookupRequestKey key, CacheEntry value, long nowNanos) {
+      return value.isExpired(nowNanos);
+    }
+
+    @Override
+    protected int estimateSizeOf(RouteLookupRequestKey key, CacheEntry value) {
+      return value.getSizeBytes();
+    }
+
+    @Override
+    protected boolean shouldInvalidateEldestEntry(
+        RouteLookupRequestKey eldestKey, CacheEntry eldestValue, long now) {
+      if (!eldestValue.isOldEnoughToBeEvicted(now)) {
+        return false;
+      }
+
+      // eldest entry should be evicted if size limit exceeded
+      return this.estimatedSizeBytes() > this.estimatedMaxSizeBytes();
+    }
+
+    public CacheEntry cacheAndClean(RouteLookupRequestKey key, CacheEntry value) {
+      CacheEntry newEntry = cache(key, value);
+
+      // force cleanup if new entry pushed cache over max size (in bytes)
+      if (fitToLimit()) {
+        helper.triggerPendingRpcProcessing();
+      }
+      return newEntry;
+    }
+  }
+
+  /** A header will be added when RLS server respond with additional header data. */
+  @VisibleForTesting
+  static final Metadata.Key<String> RLS_DATA_KEY =
+      Metadata.Key.of("X-Google-RLS-Data", Metadata.ASCII_STRING_MARSHALLER);
+
+  final class RlsPicker extends SubchannelPicker {
+
+    private final RlsRequestFactory requestFactory;
+    private final String lookupService;
+
+    RlsPicker(RlsRequestFactory requestFactory, String lookupService) {
+      this.requestFactory = checkNotNull(requestFactory, "requestFactory");
+      this.lookupService = checkNotNull(lookupService, "rlsConfig");
+    }
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      String serviceName = args.getMethodDescriptor().getServiceName();
+      String methodName = args.getMethodDescriptor().getBareMethodName();
+      RlsProtoData.RouteLookupRequestKey lookupRequestKey =
+          requestFactory.create(serviceName, methodName, args.getHeaders());
+      final CachedRouteLookupResponse response = CachingRlsLbClient.this.get(lookupRequestKey);
+
+      if (response.getHeaderData() != null && !response.getHeaderData().isEmpty()) {
+        Metadata headers = args.getHeaders();
+        headers.discardAll(RLS_DATA_KEY);
+        headers.put(RLS_DATA_KEY, response.getHeaderData());
+      }
+      String defaultTarget = lbPolicyConfig.getRouteLookupConfig().defaultTarget();
+      boolean hasFallback = defaultTarget != null && !defaultTarget.isEmpty();
+      if (response.hasData()) {
+        ChildPolicyWrapper childPolicyWrapper = response.getChildPolicyWrapper();
+        SubchannelPicker picker =
+            (childPolicyWrapper != null) ? childPolicyWrapper.getPicker() : null;
+        if (picker == null) {
+          return PickResult.withNoResult();
+        }
+        // Happy path
+        PickResult pickResult = picker.pickSubchannel(args);
+        if (pickResult.hasResult()) {
+          helper.getMetricRecorder().addLongCounter(TARGET_PICKS_COUNTER, 1,
+              Arrays.asList(helper.getChannelTarget(), lookupService,
+                  childPolicyWrapper.getTarget(), determineMetricsPickResult(pickResult)),
+              Collections.emptyList());
+        }
+        return pickResult;
+      } else if (response.hasError()) {
+        if (hasFallback) {
+          return useFallback(args);
+        }
+        helper.getMetricRecorder().addLongCounter(FAILED_PICKS_COUNTER, 1,
+            Arrays.asList(helper.getChannelTarget(), lookupService), Collections.emptyList());
+        return PickResult.withError(
+            convertRlsServerStatus(response.getStatus(),
+                lbPolicyConfig.getRouteLookupConfig().lookupService()));
+      } else {
+        return PickResult.withNoResult();
+      }
+    }
+
+    /** Uses Subchannel connected to default target. */
+    private PickResult useFallback(PickSubchannelArgs args) {
+      SubchannelPicker picker = fallbackChildPolicyWrapper.getPicker();
+      if (picker == null) {
+        return PickResult.withNoResult();
+      }
+      PickResult pickResult = picker.pickSubchannel(args);
+      if (pickResult.hasResult()) {
+        helper.getMetricRecorder().addLongCounter(DEFAULT_TARGET_PICKS_COUNTER, 1,
+            Arrays.asList(helper.getChannelTarget(), lookupService,
+                fallbackChildPolicyWrapper.getTarget(), determineMetricsPickResult(pickResult)),
+            Collections.emptyList());
+      }
+      return pickResult;
+    }
+
+    private String determineMetricsPickResult(PickResult pickResult) {
+      if (pickResult.getStatus().isOk()) {
+        return "complete";
+      } else if (pickResult.isDrop()) {
+        return "drop";
+      } else {
+        return "fail";
+      }
+    }
+
+    // GuardedBy CachingRlsLbClient.lock
+    void close() {
+      synchronized (lock) { // Lock is already held, but ErrorProne can't tell
+        if (fallbackChildPolicyWrapper != null) {
+          refCountedChildPolicyWrapperFactory.release(fallbackChildPolicyWrapper);
+        }
+      }
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("target", lbPolicyConfig.getRouteLookupConfig().lookupService())
+          .toString();
+    }
+  }
+
+}
diff --git a/rls/src/main/java/io/grpc/rls/ChildLbResolvedAddressFactory.java b/rls/src/main/java/io/grpc/rls/ChildLbResolvedAddressFactory.java
new file mode 100644
index 00000000000..73b2e7591e4
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/ChildLbResolvedAddressFactory.java
@@ -0,0 +1,47 @@
+/*
+ * 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.rls;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import java.util.Collections;
+import java.util.List;
+
+/** Factory to create {@link io.grpc.LoadBalancer.ResolvedAddresses} from child load-balancers. */
+final class ChildLbResolvedAddressFactory implements ResolvedAddressFactory {
+
+  private final List<EquivalentAddressGroup> addresses;
+  private final Attributes attributes;
+
+  ChildLbResolvedAddressFactory(
+      List<EquivalentAddressGroup> addresses, Attributes attributes) {
+    this.addresses = Collections.unmodifiableList(checkNotNull(addresses, "addresses"));
+    this.attributes = checkNotNull(attributes, "attributes");
+  }
+
+  @Override
+  public ResolvedAddresses create(Object childLbConfig) {
+    return ResolvedAddresses.newBuilder()
+        .setAddresses(addresses)
+        .setAttributes(attributes)
+        .setLoadBalancingPolicyConfig(childLbConfig)
+        .build();
+  }
+}
diff --git a/rls/src/main/java/io/grpc/rls/ChildLoadBalancerHelper.java b/rls/src/main/java/io/grpc/rls/ChildLoadBalancerHelper.java
new file mode 100644
index 00000000000..7a5d5dcc645
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/ChildLoadBalancerHelper.java
@@ -0,0 +1,88 @@
+/*
+ * 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.rls;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import javax.annotation.Nonnull;
+
+/**
+ * A delegating {@link Helper} for the child load blanacer. The child load-balancer notifies the
+ * higher level load-blancer with aggregated status instead of each individual child load-blanacer's
+ * state.
+ */
+final class ChildLoadBalancerHelper extends ForwardingLoadBalancerHelper {
+
+  private final String target;
+  private final Helper rlsHelper;
+  private final SubchannelStateManager subchannelStateManager;
+  private final SubchannelPicker picker;
+
+  private ChildLoadBalancerHelper(
+      String target,
+      Helper rlsHelper,
+      SubchannelStateManager subchannelStateManager,
+      SubchannelPicker picker) {
+    this.target = checkNotNull(target, "target");
+    this.rlsHelper = checkNotNull(rlsHelper, "rlsHelper");
+    this.subchannelStateManager = checkNotNull(subchannelStateManager, "subchannelStateManager");
+    this.picker = checkNotNull(picker, "picker");
+  }
+
+  @Override
+  protected Helper delegate() {
+    return rlsHelper;
+  }
+
+  /**
+   * Updates balancing state from one or more subchannels tracked in the {@link
+   * SubchannelStateManager}. The passed picker will be ignored, instead the picker which governs
+   * many subchannels/pickers will be reported to the parent load-balancer.
+   */
+  @Override
+  public void updateBalancingState(
+      @Nonnull ConnectivityState newState,
+      @Nonnull SubchannelPicker unused) {
+    subchannelStateManager.updateState(target, newState);
+    super.updateBalancingState(subchannelStateManager.getAggregatedState(), picker);
+  }
+
+  static final class ChildLoadBalancerHelperProvider {
+    private final Helper helper;
+    private final SubchannelStateManager subchannelStateManager;
+    private final SubchannelPicker picker;
+
+    ChildLoadBalancerHelperProvider(
+        Helper helper, SubchannelStateManager subchannelStateManager, SubchannelPicker picker) {
+      this.helper = checkNotNull(helper, "helper");
+      this.subchannelStateManager = checkNotNull(subchannelStateManager, "subchannelStateManager");
+      this.picker = checkNotNull(picker, "picker");
+    }
+
+    void init() {
+      helper.updateBalancingState(ConnectivityState.CONNECTING, picker);
+    }
+
+    ChildLoadBalancerHelper forTarget(String target) {
+      return new ChildLoadBalancerHelper(target, helper, subchannelStateManager, picker);
+    }
+  }
+}
diff --git a/rls/src/main/java/io/grpc/rls/LbPolicyConfiguration.java b/rls/src/main/java/io/grpc/rls/LbPolicyConfiguration.java
new file mode 100644
index 00000000000..77ed080e654
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/LbPolicyConfiguration.java
@@ -0,0 +1,475 @@
+/*
+ * 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.rls;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.ObjectPool;
+import io.grpc.rls.ChildLoadBalancerHelper.ChildLoadBalancerHelperProvider;
+import io.grpc.rls.RlsProtoData.RouteLookupConfig;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import javax.annotation.Nullable;
+
+/** Configuration for RLS load balancing policy. */
+final class LbPolicyConfiguration {
+
+  private final RouteLookupConfig routeLookupConfig;
+  @Nullable
+  private final Map<String, ?> routeLookupChannelServiceConfig;
+  private final ChildLoadBalancingPolicy policy;
+
+  LbPolicyConfiguration(
+      RouteLookupConfig routeLookupConfig, @Nullable Map<String, ?> routeLookupChannelServiceConfig,
+      ChildLoadBalancingPolicy policy) {
+    this.routeLookupConfig = checkNotNull(routeLookupConfig, "routeLookupConfig");
+    this.routeLookupChannelServiceConfig = routeLookupChannelServiceConfig;
+    this.policy = checkNotNull(policy, "policy");
+  }
+
+  RouteLookupConfig getRouteLookupConfig() {
+    return routeLookupConfig;
+  }
+
+  @Nullable
+  Map<String, ?> getRouteLookupChannelServiceConfig() {
+    return routeLookupChannelServiceConfig;
+  }
+
+  ChildLoadBalancingPolicy getLoadBalancingPolicy() {
+    return policy;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    LbPolicyConfiguration that = (LbPolicyConfiguration) o;
+    return Objects.equals(routeLookupConfig, that.routeLookupConfig)
+        && Objects.equals(routeLookupChannelServiceConfig, that.routeLookupChannelServiceConfig)
+        && Objects.equals(policy, that.policy);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(routeLookupConfig, routeLookupChannelServiceConfig, policy);
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("routeLookupConfig", routeLookupConfig)
+        .add("routeLookupChannelServiceConfig", routeLookupChannelServiceConfig)
+        .add("policy", policy)
+        .toString();
+  }
+
+  /** ChildLoadBalancingPolicy is an elected child policy to delegate requests. */
+  static final class ChildLoadBalancingPolicy {
+
+    private final Map<String, Object> effectiveRawChildPolicy;
+    private final LoadBalancerProvider effectiveLbProvider;
+    private final String targetFieldName;
+
+    @VisibleForTesting
+    ChildLoadBalancingPolicy(
+        String targetFieldName,
+        Map<String, Object> effectiveRawChildPolicy,
+        LoadBalancerProvider effectiveLbProvider) {
+      checkArgument(
+          targetFieldName != null && !targetFieldName.isEmpty(),
+          "targetFieldName cannot be empty or null");
+      this.targetFieldName = targetFieldName;
+      this.effectiveRawChildPolicy =
+          checkNotNull(effectiveRawChildPolicy, "effectiveRawChildPolicy");
+      this.effectiveLbProvider = checkNotNull(effectiveLbProvider, "effectiveLbProvider");
+    }
+
+    /** Creates ChildLoadBalancingPolicy. */
+    @SuppressWarnings("unchecked")
+    static ChildLoadBalancingPolicy create(
+        String childPolicyConfigTargetFieldName, List<Map<String, ?>> childPolicies)
+        throws InvalidChildPolicyConfigException {
+      Map<String, Object> effectiveChildPolicy = null;
+      LoadBalancerProvider effectiveLbProvider = null;
+      List<String> policyTried = new ArrayList<>();
+
+      LoadBalancerRegistry lbRegistry = LoadBalancerRegistry.getDefaultRegistry();
+      for (Map<String, ?> childPolicy : childPolicies) {
+        if (childPolicy.isEmpty()) {
+          continue;
+        }
+        if (childPolicy.size() != 1) {
+          throw
+              new InvalidChildPolicyConfigException(
+                  "childPolicy should have exactly one loadbalancing policy");
+        }
+        String policyName = childPolicy.keySet().iterator().next();
+        LoadBalancerProvider provider = lbRegistry.getProvider(policyName);
+        if (provider != null) {
+          effectiveLbProvider = provider;
+          effectiveChildPolicy = Collections.unmodifiableMap(childPolicy);
+          break;
+        }
+        policyTried.add(policyName);
+      }
+      if (effectiveChildPolicy == null) {
+        throw
+            new InvalidChildPolicyConfigException(
+                String.format("no valid childPolicy found, policy tried: %s", policyTried));
+      }
+      return
+          new ChildLoadBalancingPolicy(
+              childPolicyConfigTargetFieldName,
+              (Map<String, Object>) effectiveChildPolicy.values().iterator().next(),
+              effectiveLbProvider);
+    }
+
+    /** Creates a child load balancer config for given target from elected raw child policy. */
+    Map<String, ?> getEffectiveChildPolicy(String target) {
+      Map<String, Object> childPolicy = new HashMap<>(effectiveRawChildPolicy);
+      childPolicy.put(targetFieldName, target);
+      return childPolicy;
+    }
+
+    /** Returns the elected child {@link LoadBalancerProvider}. */
+    LoadBalancerProvider getEffectiveLbProvider() {
+      return effectiveLbProvider;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      ChildLoadBalancingPolicy that = (ChildLoadBalancingPolicy) o;
+      return Objects.equals(effectiveRawChildPolicy, that.effectiveRawChildPolicy)
+          && Objects.equals(effectiveLbProvider, that.effectiveLbProvider)
+          && Objects.equals(targetFieldName, that.targetFieldName);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(effectiveRawChildPolicy, effectiveLbProvider, targetFieldName);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("effectiveRawChildPolicy", effectiveRawChildPolicy)
+          .add("effectiveLbProvider", effectiveLbProvider)
+          .add("childPolicyConfigTargetFieldName", targetFieldName)
+          .toString();
+    }
+  }
+
+  /** Factory for {@link ChildPolicyWrapper}. Not thread-safe. */
+  static final class RefCountedChildPolicyWrapperFactory {
+    @VisibleForTesting
+    final Map<String /* target */, RefCountedChildPolicyWrapper> childPolicyMap =
+        new HashMap<>();
+
+    private final ChildLoadBalancerHelperProvider childLbHelperProvider;
+    private final ChildLoadBalancingPolicy childPolicy;
+    private ResolvedAddressFactory childLbResolvedAddressFactory;
+
+    public RefCountedChildPolicyWrapperFactory(
+        ChildLoadBalancingPolicy childPolicy,
+        ResolvedAddressFactory childLbResolvedAddressFactory,
+        ChildLoadBalancerHelperProvider childLbHelperProvider) {
+      this.childPolicy = checkNotNull(childPolicy, "childPolicy");
+      this.childLbResolvedAddressFactory =
+          checkNotNull(childLbResolvedAddressFactory, "childLbResolvedAddressFactory");
+      this.childLbHelperProvider = checkNotNull(childLbHelperProvider, "childLbHelperProvider");
+    }
+
+    void init() {
+      childLbHelperProvider.init();
+    }
+
+    Status acceptResolvedAddressFactory(ResolvedAddressFactory childLbResolvedAddressFactory) {
+      this.childLbResolvedAddressFactory = childLbResolvedAddressFactory;
+      Status status = Status.OK;
+      for (RefCountedChildPolicyWrapper wrapper : childPolicyMap.values()) {
+        Status newStatus =
+            wrapper.childPolicyWrapper.acceptResolvedAddressFactory(childLbResolvedAddressFactory);
+        if (!newStatus.isOk()) {
+          status = newStatus;
+        }
+      }
+      return status;
+    }
+
+    ChildPolicyWrapper createOrGet(String target) {
+      // TODO(creamsoup) check if the target is valid or not
+      RefCountedChildPolicyWrapper pooledChildPolicyWrapper = childPolicyMap.get(target);
+      if (pooledChildPolicyWrapper == null) {
+        ChildPolicyWrapper childPolicyWrapper = new ChildPolicyWrapper(
+            target, childPolicy, childLbHelperProvider);
+        pooledChildPolicyWrapper = RefCountedChildPolicyWrapper.of(childPolicyWrapper);
+        childPolicyMap.put(target, pooledChildPolicyWrapper);
+        childPolicyWrapper.start(childLbResolvedAddressFactory);
+        return pooledChildPolicyWrapper.getObject();
+      } else {
+        ChildPolicyWrapper childPolicyWrapper = pooledChildPolicyWrapper.getObject();
+        if (childPolicyWrapper.getPicker() != null) {
+          childPolicyWrapper.refreshState();
+        }
+        return childPolicyWrapper;
+      }
+    }
+
+    List<ChildPolicyWrapper> createOrGet(List<String> targets) {
+      List<ChildPolicyWrapper> retVal = new ArrayList<>();
+      for (String target : targets) {
+        retVal.add(createOrGet(target));
+      }
+      return retVal;
+    }
+
+    void release(ChildPolicyWrapper childPolicyWrapper) {
+      checkNotNull(childPolicyWrapper, "childPolicyWrapper");
+      String target = childPolicyWrapper.getTarget();
+      RefCountedChildPolicyWrapper existing = childPolicyMap.get(target);
+      checkState(existing != null, "Cannot access already released object");
+      existing.returnObject(childPolicyWrapper);
+      if (existing.isReleased()) {
+        childPolicyMap.remove(target);
+      }
+    }
+  }
+
+  /**
+   * ChildPolicyWrapper is a wrapper class for child load balancing policy with associated helper /
+   * utility classes to manage the child policy.
+   */
+  static final class ChildPolicyWrapper {
+
+    private final String target;
+    private final ChildPolicyReportingHelper helper;
+    private final LoadBalancer lb;
+    private final Object childLbConfig;
+    private volatile SubchannelPicker picker;
+    private ConnectivityState state;
+
+    public ChildPolicyWrapper(
+        String target,
+        ChildLoadBalancingPolicy childPolicy,
+        ChildLoadBalancerHelperProvider childLbHelperProvider) {
+      this.target = target;
+      this.helper = new ChildPolicyReportingHelper(childLbHelperProvider);
+      LoadBalancerProvider lbProvider = childPolicy.getEffectiveLbProvider();
+      final ConfigOrError lbConfig =
+          lbProvider
+              .parseLoadBalancingPolicyConfig(
+                  childPolicy.getEffectiveChildPolicy(target));
+      this.lb = lbProvider.newLoadBalancer(helper);
+      this.childLbConfig = lbConfig.getConfig();
+      helper.getChannelLogger().log(
+          ChannelLogLevel.DEBUG, "RLS child lb created. config: {0}", childLbConfig);
+    }
+
+    void start(ResolvedAddressFactory childLbResolvedAddressFactory) {
+      helper.getSynchronizationContext().execute(
+          new Runnable() {
+            @Override
+            public void run() {
+              if (!acceptResolvedAddressFactory(childLbResolvedAddressFactory).isOk()) {
+                helper.refreshNameResolution();
+              }
+              lb.requestConnection();
+            }
+          });
+    }
+
+    Status acceptResolvedAddressFactory(ResolvedAddressFactory childLbResolvedAddressFactory) {
+      helper.getSynchronizationContext().throwIfNotInThisSynchronizationContext();
+      return lb.acceptResolvedAddresses(childLbResolvedAddressFactory.create(childLbConfig));
+    }
+
+    String getTarget() {
+      return target;
+    }
+
+    SubchannelPicker getPicker() {
+      return picker;
+    }
+
+    ChildPolicyReportingHelper getHelper() {
+      return helper;
+    }
+
+    public ConnectivityState getState() {
+      return state;
+    }
+
+    void refreshState() {
+      helper.getSynchronizationContext().execute(
+          new Runnable() {
+            @Override
+            public void run() {
+              helper.updateBalancingState(state, picker);
+            }
+          }
+      );
+    }
+
+    void shutdown() {
+      helper.getSynchronizationContext().execute(
+          new Runnable() {
+            @Override
+            public void run() {
+              lb.shutdown();
+            }
+          }
+      );
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("target", target)
+          .add("picker", picker)
+          .add("state", state)
+          .toString();
+    }
+
+    /**
+     * A delegating {@link io.grpc.LoadBalancer.Helper} maintains status of {@link
+     * ChildPolicyWrapper} when {@link Subchannel} status changed. This helper is used between child
+     * policy and parent load-balancer where each picker in child policy is governed by a governing
+     * picker (RlsPicker). The governing picker will be reported back to the parent load-balancer.
+     */
+    final class ChildPolicyReportingHelper extends ForwardingLoadBalancerHelper {
+
+      private final ChildLoadBalancerHelper delegate;
+
+      ChildPolicyReportingHelper(
+          ChildLoadBalancerHelperProvider childHelperProvider) {
+        checkNotNull(childHelperProvider, "childHelperProvider");
+        this.delegate = childHelperProvider.forTarget(getTarget());
+      }
+
+      @Override
+      protected Helper delegate() {
+        return delegate;
+      }
+
+      @Override
+      public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+        picker = newPicker;
+        state = newState;
+        super.updateBalancingState(newState, newPicker);
+      }
+    }
+  }
+
+  private static final class RefCountedChildPolicyWrapper
+      implements ObjectPool<ChildPolicyWrapper> {
+
+    private long refCnt;
+    @Nullable
+    private ChildPolicyWrapper childPolicyWrapper;
+
+    private RefCountedChildPolicyWrapper(ChildPolicyWrapper childPolicyWrapper) {
+      this.childPolicyWrapper = checkNotNull(childPolicyWrapper, "childPolicyWrapper");
+    }
+
+    @Override
+    public ChildPolicyWrapper getObject() {
+      checkState(!isReleased(), "ChildPolicyWrapper is already released");
+      refCnt++;
+      return childPolicyWrapper;
+    }
+
+    @Override
+    @Nullable
+    public ChildPolicyWrapper returnObject(Object object) {
+      checkState(
+          !isReleased(),
+          "cannot return already released ChildPolicyWrapper, this is possibly a bug.");
+      checkState(
+          childPolicyWrapper == object,
+          "returned object doesn't match the pooled childPolicyWrapper");
+      long newCnt = --refCnt;
+      checkState(newCnt != -1, "Cannot return never pooled childPolicyWrapper");
+      if (newCnt == 0) {
+        childPolicyWrapper.shutdown();
+        childPolicyWrapper = null;
+      }
+      return null;
+    }
+
+    boolean isReleased() {
+      return childPolicyWrapper == null;
+    }
+
+    static RefCountedChildPolicyWrapper of(ChildPolicyWrapper childPolicyWrapper) {
+      return new RefCountedChildPolicyWrapper(childPolicyWrapper);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("object", childPolicyWrapper)
+          .add("refCnt", refCnt)
+          .toString();
+    }
+  }
+
+  /** Exception thrown when attempting to parse child policy encountered parsing issue. */
+  static final class InvalidChildPolicyConfigException extends Exception {
+
+    private static final long serialVersionUID = 0L;
+
+    InvalidChildPolicyConfigException(String message) {
+      super(message);
+    }
+
+    @Override
+    public synchronized Throwable fillInStackTrace() {
+      // no stack trace above this point
+      return this;
+    }
+  }
+}
diff --git a/rls/src/main/java/io/grpc/rls/LinkedHashLruCache.java b/rls/src/main/java/io/grpc/rls/LinkedHashLruCache.java
new file mode 100644
index 00000000000..9a961759693
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/LinkedHashLruCache.java
@@ -0,0 +1,329 @@
+/*
+ * 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.rls;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Ticker;
+import com.google.errorprone.annotations.CheckReturnValue;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import javax.annotation.Nullable;
+
+/**
+ * A LinkedHashLruCache implements least recently used caching where it supports access order lru
+ * cache eviction while allowing entry level expiration time. When the cache reaches max capacity,
+ * LruCache try to remove up to one already expired entries. If it doesn't find any expired entries,
+ * it will remove based on access order of entry. To proactively clean up expired entries, call
+ * {@link #cleanupExpiredEntries()} (e.g., via a recurring timer).
+ */
+abstract class LinkedHashLruCache<K, V> implements LruCache<K, V> {
+
+  private final LinkedHashMap<K, SizedValue> delegate;
+  private final Ticker ticker;
+  @Nullable
+  private final EvictionListener<K, V> evictionListener;
+  private long estimatedSizeBytes;
+  private long estimatedMaxSizeBytes;
+
+  LinkedHashLruCache(
+      final long estimatedMaxSizeBytes,
+      @Nullable final EvictionListener<K, V> evictionListener,
+      final Ticker ticker) {
+    checkState(estimatedMaxSizeBytes > 0, "max estimated cache size should be positive");
+    this.estimatedMaxSizeBytes = estimatedMaxSizeBytes;
+    this.evictionListener = evictionListener;
+    this.ticker = checkNotNull(ticker, "ticker");
+    delegate = new LinkedHashMap<K, SizedValue>(
+        // rough estimate or minimum hashmap default
+        Math.max((int) (estimatedMaxSizeBytes / 1000), 16),
+        /* loadFactor= */ 0.75f,
+        /* accessOrder= */ true) {
+      @Override
+      protected boolean removeEldestEntry(Map.Entry<K, SizedValue> eldest) {
+        if (estimatedSizeBytes <= LinkedHashLruCache.this.estimatedMaxSizeBytes) {
+          return false;
+        }
+
+        // first, remove at most 1 expired entry
+        boolean removed = cleanupExpiredEntries(1, ticker.read());
+        // handles size based eviction if necessary no expired entry
+        boolean shouldRemove = !removed
+            && shouldInvalidateEldestEntry(eldest.getKey(), eldest.getValue().value, ticker.read());
+        if (shouldRemove) {
+          // remove entry by us to make sure lruIterator and cache is in sync
+          LinkedHashLruCache.this.invalidate(eldest.getKey(), EvictionType.SIZE);
+        }
+        return false;
+      }
+    };
+  }
+
+  /**
+   * Determines if the eldest entry should be kept or not when the cache size limit is reached. Note
+   * that LruCache is access level and the eldest is determined by access pattern.
+   */
+  @SuppressWarnings("unused")
+  protected boolean shouldInvalidateEldestEntry(K eldestKey, V eldestValue, long now) {
+    return true;
+  }
+
+  /** Determines if the entry is already expired or not. */
+  protected abstract boolean isExpired(K key, V value, long nowNanos);
+
+  /**
+   * Returns estimated size of entry to keep track. If it always returns 1, the max size bytes
+   * behaves like max number of entry (default behavior).
+   */
+  @SuppressWarnings("unused")
+  protected int estimateSizeOf(K key, V value) {
+    return 1;
+  }
+
+  protected long estimatedMaxSizeBytes() {
+    return estimatedMaxSizeBytes;
+  }
+
+  /** Updates size for given key if entry exists. It is useful if the cache value is mutated. */
+  public void updateEntrySize(K key) {
+    SizedValue entry = readInternal(key);
+    if (entry == null) {
+      return;
+    }
+    int prevSize = entry.size;
+    int newSize = estimateSizeOf(key, entry.value);
+    entry.size = newSize;
+    estimatedSizeBytes += newSize - prevSize;
+  }
+
+  /**
+   * Returns estimated cache size bytes. Each entry size is calculated by {@link
+   * #estimateSizeOf(java.lang.Object, java.lang.Object)}.
+   */
+  public long estimatedSizeBytes() {
+    return estimatedSizeBytes;
+  }
+
+  @Override
+  @Nullable
+  public final V cache(K key, V value) {
+    checkNotNull(key, "key");
+    checkNotNull(value, "value");
+    SizedValue existing;
+    int size = estimateSizeOf(key, value);
+    estimatedSizeBytes += size;
+    existing = delegate.put(key, new SizedValue(size, value));
+    if (existing != null) {
+      fireOnEviction(key, existing, EvictionType.REPLACED);
+    }
+    return existing == null ? null : existing.value;
+  }
+
+  @Override
+  @Nullable
+  @CheckReturnValue
+  public final V read(K key) {
+    SizedValue entry = readInternal(key);
+    if (entry != null) {
+      return entry.value;
+    }
+    return null;
+  }
+
+  @Nullable
+  @CheckReturnValue
+  private SizedValue readInternal(K key) {
+    checkNotNull(key, "key");
+    SizedValue existing = delegate.get(key);
+    if (existing != null && isExpired(key, existing.value, ticker.read())) {
+      return null;
+    }
+    return existing;
+  }
+
+  @Override
+  @Nullable
+  public final V invalidate(K key) {
+    return invalidate(key, EvictionType.EXPLICIT);
+  }
+
+  @Nullable
+  private V invalidate(K key, EvictionType cause) {
+    checkNotNull(key, "key");
+    checkNotNull(cause, "cause");
+    SizedValue existing = delegate.remove(key);
+    if (existing != null) {
+      fireOnEviction(key, existing, cause);
+    }
+    return existing == null ? null : existing.value;
+  }
+
+  @Override
+  public final void invalidateAll() {
+    Iterator<Map.Entry<K, SizedValue>> iterator = delegate.entrySet().iterator();
+    while (iterator.hasNext()) {
+      Map.Entry<K, SizedValue> entry = iterator.next();
+      if (entry.getValue() != null) {
+        fireOnEviction(entry.getKey(), entry.getValue(), EvictionType.EXPLICIT);
+      }
+      iterator.remove();
+    }
+  }
+
+  @Override
+  @CheckReturnValue
+  public final boolean hasCacheEntry(K key) {
+    // call readInternal to filter already expired entry in the cache
+    return readInternal(key) != null;
+  }
+
+  /** Returns shallow copied values in the cache. */
+  public final List<V> values() {
+    List<V> list = new ArrayList<>(delegate.size());
+    for (SizedValue value : delegate.values()) {
+      list.add(value.value);
+    }
+    return Collections.unmodifiableList(list);
+  }
+
+  /**
+   * Cleans up cache if needed to fit into max size bytes by
+   * removing expired entries and removing oldest entries by LRU order.
+   * Returns TRUE if any unexpired entries were removed
+   */
+  protected final boolean fitToLimit() {
+    boolean removedAnyUnexpired = false;
+    if (estimatedSizeBytes <= estimatedMaxSizeBytes) {
+      return false;
+    }
+    // cleanup expired entries
+    long now = ticker.read();
+    cleanupExpiredEntries(now);
+
+    // cleanup eldest entry until the size of all entries fits within the limit
+    Iterator<Map.Entry<K, SizedValue>> lruIter = delegate.entrySet().iterator();
+    while (lruIter.hasNext() && estimatedMaxSizeBytes < this.estimatedSizeBytes) {
+      Map.Entry<K, SizedValue> entry = lruIter.next();
+      if (!shouldInvalidateEldestEntry(entry.getKey(), entry.getValue().value, now)) {
+        break; // Violates some constraint like minimum age so stop our cleanup
+      }
+      lruIter.remove();
+      // fireOnEviction will update the estimatedSizeBytes
+      fireOnEviction(entry.getKey(), entry.getValue(), EvictionType.SIZE);
+      removedAnyUnexpired = true;
+    }
+    return removedAnyUnexpired;
+  }
+
+  /**
+   * Resizes cache. If new size is smaller than current estimated size, it will free up space by
+   * removing expired entries and removing oldest entries by LRU order.
+   */
+  public final void resize(long newSizeBytes) {
+    this.estimatedMaxSizeBytes = newSizeBytes;
+    fitToLimit();
+  }
+
+  @Override
+  @CheckReturnValue
+  public final int estimatedSize() {
+    return delegate.size();
+  }
+
+  /** Returns {@code true} if any entries were removed. */
+  public final boolean cleanupExpiredEntries() {
+    return cleanupExpiredEntries(ticker.read());
+  }
+
+  private boolean cleanupExpiredEntries(long now) {
+    return cleanupExpiredEntries(Integer.MAX_VALUE, now);
+  }
+
+  // maxExpiredEntries is by number of entries
+  private boolean cleanupExpiredEntries(int maxExpiredEntries, long now) {
+    checkArgument(maxExpiredEntries > 0, "maxExpiredEntries must be positive");
+    boolean removedAny = false;
+    Iterator<Map.Entry<K, SizedValue>> lruIter = delegate.entrySet().iterator();
+    while (lruIter.hasNext() && maxExpiredEntries > 0) {
+      Map.Entry<K, SizedValue> entry = lruIter.next();
+      if (isExpired(entry.getKey(), entry.getValue().value, now)) {
+        lruIter.remove();
+        fireOnEviction(entry.getKey(), entry.getValue(), EvictionType.EXPIRED);
+        removedAny = true;
+        maxExpiredEntries--;
+      }
+    }
+    return removedAny;
+  }
+
+  @Override
+  public final void close() {
+    invalidateAll();
+  }
+
+  private void fireOnEviction(K key, SizedValue value, EvictionType cause) {
+    estimatedSizeBytes -= value.size;
+    if (evictionListener != null) {
+      evictionListener.onEviction(key, value.value, cause);
+    }
+  }
+
+  private final class SizedValue {
+    volatile int size;
+    final V value;
+
+    SizedValue(int size, V value) {
+      this.size = size;
+      this.value = value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      // NOTE: the size doesn't affect equality
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      LinkedHashLruCache<?, ?>.SizedValue that = (LinkedHashLruCache<?, ?>.SizedValue) o;
+      return Objects.equals(value, that.value);
+    }
+
+    @Override
+    public int hashCode() {
+      // NOTE: the size doesn't affect hashCode
+      return Objects.hash(value);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("size", size)
+          .add("value", value)
+          .toString();
+    }
+  }
+}
diff --git a/rls/src/main/java/io/grpc/rls/LruCache.java b/rls/src/main/java/io/grpc/rls/LruCache.java
new file mode 100644
index 00000000000..8fc4ae98472
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/LruCache.java
@@ -0,0 +1,95 @@
+/*
+ * 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.rls;
+
+import com.google.errorprone.annotations.CheckReturnValue;
+import javax.annotation.Nullable;
+
+/** An LruCache is a cache with least recently used eviction. */
+interface LruCache<K, V> {
+
+  /**
+   * Populates a cache entry. If the cache entry for given key already exists, the value will be
+   * replaced to the new value.
+   *
+   * @return the previous value associated with key, otherwise {@code null}
+   */
+  @Nullable
+  V cache(K key, V value);
+
+  /**
+   * Returns cached value for given key if exists, otherwise {@code null}. This operation doesn't
+   * return already expired cache entry.
+   */
+  @Nullable
+  @CheckReturnValue
+  V read(K key);
+
+  /**
+   * Invalidates an entry for given key if exists. This operation will trigger {@link
+   * EvictionListener} with {@link EvictionType#EXPLICIT}.
+   *
+   * @return the previous value associated with key, otherwise {@code null}
+   */
+  @Nullable
+  V invalidate(K key);
+
+  /**
+   * Invalidates cache entries for all keys. This operation will trigger {@link EvictionListener}
+   * with {@link EvictionType#EXPLICIT}.
+   */
+  void invalidateAll();
+
+  /** Returns {@code true} if given key is cached. */
+  @CheckReturnValue
+  boolean hasCacheEntry(K key);
+
+  /**
+   * Returns the estimated number of entry of the cache. Note that the size can be larger than its
+   * true size, because there might be already expired cache.
+   */
+  @CheckReturnValue
+  int estimatedSize();
+
+  /** Closes underlying resources. */
+  void close();
+
+  /** A Listener notifies cache eviction events. */
+  interface EvictionListener<K, V> {
+
+    /**
+     * Notifies the listener when any cache entry is evicted. Implementation can assume that this
+     * method is called serially. Implementation should be non blocking, for long running task
+     * consider offloading the task to {@link java.util.concurrent.Executor}.
+     */
+    void onEviction(K key, V value, EvictionType cause);
+  }
+
+  /** Type of cache eviction. */
+  enum EvictionType {
+    /** Explicitly removed by user. */
+    EXPLICIT,
+    /** Evicted due to size limit. */
+    SIZE,
+    /** Evicted due to entry expired. */
+    EXPIRED,
+    /** Removed due to error. */
+    ERROR,
+    /** Evicted by replacement. */
+    REPLACED
+  }
+}
diff --git a/rls/src/main/java/io/grpc/rls/ResolvedAddressFactory.java b/rls/src/main/java/io/grpc/rls/ResolvedAddressFactory.java
new file mode 100644
index 00000000000..f4cdcc95032
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/ResolvedAddressFactory.java
@@ -0,0 +1,26 @@
+/*
+ * 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.rls;
+
+import io.grpc.LoadBalancer.ResolvedAddresses;
+
+/** A factory to create {@link ResolvedAddresses}. */
+interface ResolvedAddressFactory {
+
+  /** Creates ResolvedAddress with given childLbConfig. */
+  ResolvedAddresses create(Object childLbConfig);
+}
diff --git a/rls/src/main/java/io/grpc/rls/RlsLoadBalancer.java b/rls/src/main/java/io/grpc/rls/RlsLoadBalancer.java
new file mode 100644
index 00000000000..848199f50a8
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/RlsLoadBalancer.java
@@ -0,0 +1,130 @@
+/*
+ * 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.rls;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer;
+import io.grpc.Status;
+import javax.annotation.Nullable;
+
+/**
+ * Implementation of {@link LoadBalancer} backed by route lookup service.
+ */
+final class RlsLoadBalancer extends LoadBalancer {
+
+  private final ChannelLogger logger;
+  private final Helper helper;
+  @VisibleForTesting
+  CachingRlsLbClientBuilderProvider cachingRlsLbClientBuilderProvider =
+      new DefaultCachingRlsLbClientBuilderProvider();
+  @Nullable
+  private LbPolicyConfiguration lbPolicyConfiguration;
+  @Nullable
+  private CachingRlsLbClient routeLookupClient;
+
+  RlsLoadBalancer(Helper helper) {
+    this.helper = checkNotNull(helper, "helper");
+    logger = helper.getChannelLogger();
+    logger.log(ChannelLogLevel.DEBUG, "Rls lb created. Authority: {0}", helper.getAuthority());
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    LbPolicyConfiguration lbPolicyConfiguration =
+        (LbPolicyConfiguration) resolvedAddresses.getLoadBalancingPolicyConfig();
+    checkNotNull(lbPolicyConfiguration, "Missing RLS LB config");
+    if (!lbPolicyConfiguration.equals(this.lbPolicyConfiguration)) {
+      logger.log(ChannelLogLevel.DEBUG, "A new RLS LB config received: {0}", lbPolicyConfiguration);
+      boolean needToConnect = this.lbPolicyConfiguration == null
+          || !this.lbPolicyConfiguration.getRouteLookupConfig().lookupService().equals(
+          lbPolicyConfiguration.getRouteLookupConfig().lookupService());
+      if (needToConnect) {
+        logger.log(ChannelLogLevel.DEBUG, "RLS lookup service changed, need to connect");
+        if (routeLookupClient != null) {
+          routeLookupClient.close();
+        }
+        routeLookupClient =
+            cachingRlsLbClientBuilderProvider
+                .get()
+                .setHelper(helper)
+                .setLbPolicyConfig(lbPolicyConfiguration)
+                .setResolvedAddressesFactory(
+                    new ChildLbResolvedAddressFactory(
+                        resolvedAddresses.getAddresses(), resolvedAddresses.getAttributes()))
+                .build();
+        logger.log(
+            ChannelLogLevel.DEBUG, "LbPolicyConfiguration updated to {0}", lbPolicyConfiguration);
+      }
+      // TODO(creamsoup) allow incremental service config update. for initial use case, it is 
+      //  not required.
+      this.lbPolicyConfiguration = lbPolicyConfiguration;
+    }
+    return routeLookupClient.acceptResolvedAddressFactory(
+        new ChildLbResolvedAddressFactory(
+            resolvedAddresses.getAddresses(), resolvedAddresses.getAttributes()));
+  }
+
+  @Override
+  public void requestConnection() {
+    if (routeLookupClient != null) {
+      routeLookupClient.requestConnection();
+    }
+  }
+
+  @Override
+  public void handleNameResolutionError(final Status error) {
+    if (routeLookupClient != null) {
+      logger.log(ChannelLogLevel.DEBUG, "closing the routeLookupClient on a name resolution error");
+      routeLookupClient.close();
+      routeLookupClient = null;
+      lbPolicyConfiguration = null;
+    }
+    helper.updateBalancingState(
+        ConnectivityState.TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
+  }
+
+  @Override
+  public void shutdown() {
+    if (routeLookupClient != null) {
+      logger.log(ChannelLogLevel.DEBUG, "closing the routeLookupClient because of RLS LB shutdown");
+      routeLookupClient.close();
+      routeLookupClient = null;
+    }
+  }
+
+  /**
+   * Provides {@link CachingRlsLbClient.Builder} with default settings. This is useful for
+   * testing.
+   */
+  interface CachingRlsLbClientBuilderProvider {
+    CachingRlsLbClient.Builder get();
+  }
+
+  static final class DefaultCachingRlsLbClientBuilderProvider
+      implements CachingRlsLbClientBuilderProvider {
+
+    @Override
+    public CachingRlsLbClient.Builder get() {
+      return CachingRlsLbClient.newBuilder().setThrottler(AdaptiveThrottler.builder().build());
+    }
+  }
+}
diff --git a/rls/src/main/java/io/grpc/rls/RlsLoadBalancerProvider.java b/rls/src/main/java/io/grpc/rls/RlsLoadBalancerProvider.java
new file mode 100644
index 00000000000..d78f2d67fc0
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/RlsLoadBalancerProvider.java
@@ -0,0 +1,81 @@
+/*
+ * 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.rls;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.JsonUtil;
+import io.grpc.rls.LbPolicyConfiguration.ChildLoadBalancingPolicy;
+import io.grpc.rls.RlsProtoConverters.RouteLookupConfigConverter;
+import io.grpc.rls.RlsProtoData.RouteLookupConfig;
+import java.util.Map;
+
+/**
+ * The provider for the "rls_experimental" balancing policy.  This class should not be directly
+ * referenced in code.  The policy should be accessed through {@link
+ * io.grpc.LoadBalancerRegistry#getProvider} with the name "rls_experimental".
+ */
+@Internal
+public final class RlsLoadBalancerProvider extends LoadBalancerProvider {
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 6;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return "rls_experimental";
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+    return new RlsLoadBalancer(helper);
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawLoadBalancingConfigPolicy) {
+    try {
+      RouteLookupConfig routeLookupConfig = new RouteLookupConfigConverter()
+          .convert(JsonUtil.getObject(rawLoadBalancingConfigPolicy, "routeLookupConfig"));
+      Map<String, ?> routeLookupChannelServiceConfig =
+          JsonUtil.getObject(rawLoadBalancingConfigPolicy, "routeLookupChannelServiceConfig");
+      ChildLoadBalancingPolicy lbPolicy = ChildLoadBalancingPolicy
+          .create(
+              JsonUtil.getString(rawLoadBalancingConfigPolicy, "childPolicyConfigTargetFieldName"),
+              JsonUtil.checkObjectList(
+                  checkNotNull(JsonUtil.getList(rawLoadBalancingConfigPolicy, "childPolicy"))));
+      return ConfigOrError.fromConfig(
+          new LbPolicyConfiguration(routeLookupConfig, routeLookupChannelServiceConfig, lbPolicy));
+    } catch (Exception e) {
+      return ConfigOrError.fromError(
+          Status.UNAVAILABLE
+              .withDescription("can't parse config: " + e.getMessage())
+              .withCause(e));
+    }
+  }
+}
diff --git a/rls/src/main/java/io/grpc/rls/RlsProtoConverters.java b/rls/src/main/java/io/grpc/rls/RlsProtoConverters.java
new file mode 100644
index 00000000000..70f9fb4d891
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/RlsProtoConverters.java
@@ -0,0 +1,275 @@
+/*
+ * 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.rls;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.concurrent.TimeUnit.MINUTES;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import com.google.common.base.Converter;
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.internal.JsonUtil;
+import io.grpc.lookup.v1.RouteLookupRequest;
+import io.grpc.lookup.v1.RouteLookupResponse;
+import io.grpc.rls.RlsProtoData.ExtraKeys;
+import io.grpc.rls.RlsProtoData.GrpcKeyBuilder;
+import io.grpc.rls.RlsProtoData.GrpcKeyBuilder.Name;
+import io.grpc.rls.RlsProtoData.NameMatcher;
+import io.grpc.rls.RlsProtoData.RouteLookupConfig;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.Nullable;
+
+/**
+ * RlsProtoConverters is a collection of {@link Converter} between RouteLookupService proto / json
+ * messages to internal representation in {@link RlsProtoData}.
+ */
+final class RlsProtoConverters {
+
+  private static final long MAX_AGE_NANOS = MINUTES.toNanos(5);
+  private static final long MAX_CACHE_SIZE = 5 * 1024 * 1024; // 5MiB
+  private static final long DEFAULT_LOOKUP_SERVICE_TIMEOUT = SECONDS.toNanos(10);
+  private static final ImmutableList<String> EXTRA_KEY_NAMES =
+      ImmutableList.of("host", "service", "method");
+
+  /**
+   * RouteLookupRequestConverter converts between {@link RouteLookupRequest} and {@link
+   * RlsProtoData.RouteLookupRequest}.
+   */
+  static final class RouteLookupRequestConverter
+      extends Converter<RouteLookupRequest, RlsProtoData.RouteLookupRequest> {
+
+    @Override
+    protected RlsProtoData.RouteLookupRequest doForward(RouteLookupRequest routeLookupRequest) {
+      return RlsProtoData.RouteLookupRequest.create(
+          ImmutableMap.copyOf(routeLookupRequest.getKeyMapMap()),
+          RlsProtoData.RouteLookupRequest.Reason.valueOf(routeLookupRequest.getReason().name())
+      );
+    }
+
+    @Override
+    protected RouteLookupRequest doBackward(RlsProtoData.RouteLookupRequest routeLookupRequest) {
+      return
+          RouteLookupRequest.newBuilder()
+              .setTargetType("grpc")
+              .setReason(RouteLookupRequest.Reason.valueOf(routeLookupRequest.reason().name()))
+              .putAllKeyMap(routeLookupRequest.keyMap())
+              .build();
+    }
+  }
+
+  /**
+   * RouteLookupResponseConverter converts between {@link RouteLookupResponse} and {@link
+   * RlsProtoData.RouteLookupResponse}.
+   */
+  static final class RouteLookupResponseConverter
+      extends Converter<RouteLookupResponse, RlsProtoData.RouteLookupResponse> {
+
+    @Override
+    protected RlsProtoData.RouteLookupResponse doForward(RouteLookupResponse routeLookupResponse) {
+      return
+          RlsProtoData.RouteLookupResponse.create(
+              ImmutableList.copyOf(routeLookupResponse.getTargetsList()),
+              routeLookupResponse.getHeaderData());
+    }
+
+    @Override
+    protected RouteLookupResponse doBackward(RlsProtoData.RouteLookupResponse routeLookupResponse) {
+      return RouteLookupResponse.newBuilder()
+          .addAllTargets(routeLookupResponse.targets())
+          .setHeaderData(routeLookupResponse.getHeaderData())
+          .build();
+    }
+  }
+
+  /**
+   * RouteLookupConfigConverter converts between json map to {@link RouteLookupConfig}.
+   */
+  static final class RouteLookupConfigConverter
+      extends Converter<Map<String, ?>, RouteLookupConfig> {
+
+    @Override
+    protected RouteLookupConfig doForward(Map<String, ?> json) {
+      ImmutableList<GrpcKeyBuilder> grpcKeybuilders =
+          GrpcKeyBuilderConverter.covertAll(
+              checkNotNull(JsonUtil.getListOfObjects(json, "grpcKeybuilders"), "grpcKeybuilders"));
+
+      // Validate grpc_keybuilders
+      checkArgument(!grpcKeybuilders.isEmpty(), "must have at least one GrpcKeyBuilder");
+      Set<Name> names = new HashSet<>();
+      for (GrpcKeyBuilder keyBuilder : grpcKeybuilders) {
+        for (Name name : keyBuilder.names()) {
+          checkArgument(names.add(name), "duplicate names in grpc_keybuilders: " + name);
+        }
+
+        Set<String> keys = new HashSet<>();
+        for (NameMatcher header : keyBuilder.headers()) {
+          checkKeys(keys, header.key(), "header");
+        }
+        for (String key : keyBuilder.constantKeys().keySet()) {
+          checkKeys(keys, key, "constant");
+        }
+        String extraKeyStr = keyToString(keyBuilder.extraKeys());
+        checkArgument(keys.add(extraKeyStr),
+            "duplicate extra key in grpc_keybuilders: " + extraKeyStr);
+      }
+
+      // Validate lookup_service
+      String lookupService = JsonUtil.getString(json, "lookupService");
+      checkArgument(!Strings.isNullOrEmpty(lookupService), "lookupService must not be empty");
+      try {
+        URI unused = new URI(lookupService);
+      } catch (URISyntaxException e) {
+        throw new IllegalArgumentException(
+            "The lookupService field is not valid URI: " + lookupService, e);
+      }
+      long timeout = orDefault(
+          JsonUtil.getStringAsDuration(json, "lookupServiceTimeout"),
+          DEFAULT_LOOKUP_SERVICE_TIMEOUT);
+      checkArgument(timeout > 0, "lookupServiceTimeout should be positive");
+      Long maxAge = JsonUtil.getStringAsDuration(json, "maxAge");
+      Long staleAge = JsonUtil.getStringAsDuration(json, "staleAge");
+      if (maxAge == null) {
+        checkArgument(staleAge == null, "to specify staleAge, must have maxAge");
+        maxAge = MAX_AGE_NANOS;
+      }
+      // If staleAge is not set, clamp maxAge to <= 5.
+      if (staleAge == null && maxAge > MAX_AGE_NANOS) {
+        maxAge = MAX_AGE_NANOS;
+      }
+      // Clamp staleAge to <= 5
+      if (staleAge == null || staleAge > MAX_AGE_NANOS) {
+        staleAge = MAX_AGE_NANOS;
+      }
+      // Ignore staleAge if greater than maxAge.
+      staleAge = Math.min(staleAge, maxAge);
+      long cacheSize = orDefault(JsonUtil.getNumberAsLong(json, "cacheSizeBytes"), MAX_CACHE_SIZE);
+      checkArgument(cacheSize > 0, "cacheSize must be positive");
+      cacheSize = Math.min(cacheSize, MAX_CACHE_SIZE);
+      String defaultTarget = Strings.emptyToNull(JsonUtil.getString(json, "defaultTarget"));
+      return RouteLookupConfig.builder()
+          .grpcKeybuilders(grpcKeybuilders)
+          .lookupService(lookupService)
+          .lookupServiceTimeoutInNanos(timeout)
+          .maxAgeInNanos(maxAge)
+          .staleAgeInNanos(staleAge)
+          .cacheSizeBytes(cacheSize)
+          .defaultTarget(defaultTarget)
+          .build();
+    }
+
+    private static String keyToString(ExtraKeys extraKeys) {
+      return String.format("host: %s, service: %s, method: %s",
+          extraKeys.host(), extraKeys.service(), extraKeys.method());
+    }
+
+    private static <T> T orDefault(@Nullable T value, T defaultValue) {
+      if (value == null) {
+        return checkNotNull(defaultValue, "defaultValue");
+      }
+      return value;
+    }
+
+    @Override
+    protected Map<String, Object> doBackward(RouteLookupConfig routeLookupConfig) {
+      throw new UnsupportedOperationException();
+    }
+  }
+
+  private static void checkKeys(Set<String> keys, String key, String keyType) {
+    checkArgument(key != null, "unset " + keyType + "  key");
+    checkArgument(!key.isEmpty(), "Empty string for " + keyType + " key");
+    checkArgument(keys.add(key), "duplicate " + keyType + " key in grpc_keybuilders: " + key);
+  }
+
+  private static final class GrpcKeyBuilderConverter {
+    public static ImmutableList<GrpcKeyBuilder> covertAll(List<Map<String, ?>> keyBuilders) {
+      ImmutableList.Builder<GrpcKeyBuilder> keyBuilderList = ImmutableList.builder();
+      for (Map<String, ?> keyBuilder : keyBuilders) {
+        keyBuilderList.add(convert(keyBuilder));
+      }
+      return keyBuilderList.build();
+    }
+
+    @SuppressWarnings("unchecked")
+    static GrpcKeyBuilder convert(Map<String, ?> keyBuilder) {
+      List<?> rawRawNames = JsonUtil.getList(keyBuilder, "names");
+      checkArgument(
+          rawRawNames != null && !rawRawNames.isEmpty(),
+          "each keyBuilder must have at least one name");
+      List<Map<String, ?>> rawNames = JsonUtil.checkObjectList(rawRawNames);
+      ImmutableList.Builder<Name> namesBuilder = ImmutableList.builder();
+      for (Map<String, ?> rawName : rawNames) {
+        String serviceName = JsonUtil.getString(rawName, "service");
+        checkArgument(!Strings.isNullOrEmpty(serviceName), "service must not be empty or null");
+        namesBuilder.add(Name.create(serviceName, JsonUtil.getString(rawName, "method")));
+      }
+      List<?> rawRawHeaders = JsonUtil.getList(keyBuilder, "headers");
+      List<Map<String, ?>> rawHeaders =
+          rawRawHeaders == null
+              ? new ArrayList<Map<String, ?>>() : JsonUtil.checkObjectList(rawRawHeaders);
+      ImmutableList.Builder<NameMatcher> nameMatchersBuilder = ImmutableList.builder();
+      for (Map<String, ?> rawHeader : rawHeaders) {
+        Boolean requiredMatch = JsonUtil.getBoolean(rawHeader, "requiredMatch");
+        checkArgument(
+            requiredMatch == null || !requiredMatch,
+            "requiredMatch shouldn't be specified for gRPC");
+        NameMatcher matcher = NameMatcher.create(
+            JsonUtil.getString(rawHeader, "key"),
+            ImmutableList.copyOf((List<String>) rawHeader.get("names")));
+        nameMatchersBuilder.add(matcher);
+      }
+      ExtraKeys extraKeys = ExtraKeys.DEFAULT;
+      Map<String, String> rawExtraKeys =
+          (Map<String, String>) JsonUtil.getObject(keyBuilder,  "extraKeys");
+      if (rawExtraKeys != null) {
+        extraKeys = ExtraKeys.create(
+            rawExtraKeys.get("host"), rawExtraKeys.get("service"), rawExtraKeys.get("method"));
+      }
+      Map<String, String> constantKeys =
+          (Map<String, String>) JsonUtil.getObject(keyBuilder,  "constantKeys");
+      if (constantKeys == null) {
+        constantKeys = ImmutableMap.of();
+      }
+      ImmutableList<NameMatcher> nameMatchers = nameMatchersBuilder.build();
+      checkUniqueKey(nameMatchers, constantKeys.keySet());
+      return GrpcKeyBuilder.create(
+          namesBuilder.build(), nameMatchers, extraKeys, ImmutableMap.copyOf(constantKeys));
+    }
+  }
+
+  private static void checkUniqueKey(List<NameMatcher> nameMatchers, Set<String> constantKeys) {
+    Set<String> keys = new HashSet<>(constantKeys);
+    keys.addAll(EXTRA_KEY_NAMES);
+    for (NameMatcher nameMatcher :  nameMatchers) {
+      keys.add(nameMatcher.key());
+    }
+    if (keys.size() != nameMatchers.size() + constantKeys.size() + EXTRA_KEY_NAMES.size()) {
+      throw new IllegalArgumentException("keys in KeyBuilder must be unique");
+    }
+  }
+
+  private RlsProtoConverters() {}
+}
diff --git a/rls/src/main/java/io/grpc/rls/RlsProtoData.java b/rls/src/main/java/io/grpc/rls/RlsProtoData.java
new file mode 100644
index 00000000000..39c404870f9
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/RlsProtoData.java
@@ -0,0 +1,253 @@
+/*
+ * 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.rls;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.Immutable;
+
+/** RlsProtoData is a collection of internal representation of RouteLookupService proto messages. */
+final class RlsProtoData {
+
+  private RlsProtoData() {}
+
+  /** A key object for the Rls route lookup data cache. */
+  @AutoValue
+  @Immutable
+  abstract static class RouteLookupRequestKey {
+
+    /** Returns a map of key values extracted via key builders for the gRPC or HTTP request. */
+    abstract ImmutableMap<String, String> keyMap();
+
+    static RouteLookupRequestKey create(ImmutableMap<String, String> keyMap) {
+      return new AutoValue_RlsProtoData_RouteLookupRequestKey(keyMap);
+    }
+  }
+
+  /** A request object sent to route lookup service. */
+  @AutoValue
+  @Immutable
+  abstract static class RouteLookupRequest {
+
+    /** Names should match those in {@link io.grpc.lookup.v1.RouteLookupRequest.Reason}. */
+    enum Reason {
+      /** Unused. */
+      REASON_UNKNOWN,
+      /** No data available in local cache. */
+      REASON_MISS,
+      /** Data in local cache is stale. */
+      REASON_STALE;
+    }
+
+    /** Reason for making this request. */
+    abstract Reason reason();
+
+    /** Returns a map of key values extracted via key builders for the gRPC or HTTP request. */
+    abstract ImmutableMap<String, String> keyMap();
+
+    static RouteLookupRequest create(ImmutableMap<String, String> keyMap, Reason reason) {
+      return new AutoValue_RlsProtoData_RouteLookupRequest(reason, keyMap);
+    }
+  }
+
+  /** A response from route lookup service. */
+  @AutoValue
+  @Immutable
+  abstract static class RouteLookupResponse {
+
+    /**
+     * Returns list of targets. Prioritized list (best one first) of addressable entities to use for
+     * routing, using syntax requested by the request target_type. The targets will be tried in
+     * order until a healthy one is found.
+     */
+    abstract ImmutableList<String> targets();
+
+    /**
+     * Returns optional header data to pass along to AFE in the X-Google-RLS-Data header. Cached
+     * with "target" and sent with all requests that match the request key. Allows the RLS to pass
+     * its work product to the eventual target.
+     */
+    abstract String getHeaderData();
+
+    static RouteLookupResponse create(ImmutableList<String> targets, String getHeaderData) {
+      return new AutoValue_RlsProtoData_RouteLookupResponse(targets, getHeaderData);
+    }
+  }
+
+  /** A config object for gRPC RouteLookupService. */
+  @AutoValue
+  @Immutable
+  abstract static class RouteLookupConfig {
+
+    /**
+     * Returns unordered specifications for constructing keys for gRPC requests. All GrpcKeyBuilders
+     * on this list must have unique "name" fields so that the client is free to prebuild a hash map
+     * keyed by name. If no GrpcKeyBuilder matches, an empty key_map will be sent to the lookup
+     * service; it should likely reply with a global default route and raise an alert.
+     */
+    abstract ImmutableList<GrpcKeyBuilder> grpcKeybuilders();
+
+    /**
+     * Returns the name of the lookup service as a gRPC URI. Typically, this will be a subdomain of
+     * the target, such as "lookup.datastore.googleapis.com".
+     */
+    abstract String lookupService();
+
+    /** Returns the timeout value for lookup service requests. */
+    abstract long lookupServiceTimeoutInNanos();
+
+    /** Returns the maximum age the result will be cached. */
+    abstract long maxAgeInNanos();
+
+    /**
+     * Returns the time when an entry will be in a staled status. When cache is accessed whgen the
+     * entry is in staled status, it will
+     */
+    abstract long staleAgeInNanos();
+
+    /**
+     * Returns a rough indicator of amount of memory to use for the client cache. Some of the data
+     * structure overhead is not accounted for, so actual memory consumed will be somewhat greater
+     * than this value.  If this field is omitted or set to zero, a client default will be used.
+     * The value may be capped to a lower amount based on client configuration.
+     */
+    abstract long cacheSizeBytes();
+
+    /**
+     * Returns the default target to use if needed.  If nonempty (implies request processing
+     * strategy SYNC_LOOKUP_DEFAULT_TARGET_ON_ERROR is set), it will be used if RLS returns an
+     * error.  Note that requests can be routed only to a subdomain of the original target,
+     * {@literal e.g.} "us_east_1.cloudbigtable.googleapis.com".
+     */
+    @Nullable
+    abstract String defaultTarget();
+
+    static Builder builder() {
+      return new AutoValue_RlsProtoData_RouteLookupConfig.Builder();
+    }
+
+    @AutoValue.Builder
+    abstract static class Builder {
+
+      abstract Builder grpcKeybuilders(ImmutableList<GrpcKeyBuilder> grpcKeybuilders);
+
+      abstract Builder lookupService(String lookupService);
+
+      abstract Builder lookupServiceTimeoutInNanos(long lookupServiceTimeoutInNanos);
+
+      abstract Builder maxAgeInNanos(long maxAgeInNanos);
+
+      abstract Builder staleAgeInNanos(long staleAgeInNanos);
+
+      abstract Builder cacheSizeBytes(long cacheSizeBytes);
+
+      abstract Builder defaultTarget(@Nullable String defaultTarget);
+
+      abstract RouteLookupConfig build();
+    }
+  }
+
+  /**
+   * NameMatcher extract a key based on a given name (e.g. header name or query parameter name).
+   * The name must match one of the names listed in the "name" field. If the "required_match" field
+   * is true, one of the specified names must be present for the keybuilder to match.
+   */
+  @AutoValue
+  @Immutable
+  abstract static class NameMatcher {
+
+    /** The name that will be used in the RLS key_map to refer to this value. */
+    abstract String key();
+
+    /** Returns ordered list of names; the first non-empty value will be used. */
+    abstract ImmutableList<String> names();
+
+    static NameMatcher create(String key, ImmutableList<String> names) {
+      return new AutoValue_RlsProtoData_NameMatcher(key, names);
+    }
+  }
+
+  /** GrpcKeyBuilder is a configuration to construct headers consumed by route lookup service. */
+  @AutoValue
+  @Immutable
+  abstract static class GrpcKeyBuilder {
+
+    /**
+     * Returns names. To match, one of the given Name fields must match; the service and method
+     * fields are specified as fixed strings. The service name is required and includes the proto
+     * package name. The method name may be omitted, in which case any method on the given service
+     * is matched.
+     */
+    abstract ImmutableList<Name> names();
+
+    /**
+     * Returns a list of NameMatchers for header. Extract keys from all listed headers. For gRPC, it
+     * is an error to specify "required_match" on the NameMatcher protos, and we ignore it if set.
+     */
+    abstract ImmutableList<NameMatcher> headers();
+
+    abstract ExtraKeys extraKeys();
+
+    abstract ImmutableMap<String, String> constantKeys();
+
+    static GrpcKeyBuilder create(
+        ImmutableList<Name> names,
+        ImmutableList<NameMatcher> headers,
+        ExtraKeys extraKeys, ImmutableMap<String, String> constantKeys) {
+      return new AutoValue_RlsProtoData_GrpcKeyBuilder(names, headers, extraKeys, constantKeys);
+    }
+
+    /**
+     * Name represents a method for a given service. To match, one of the given Name fields must
+     * match; the service and method fields are specified as fixed strings. The service name is
+     * required and includes the proto package name. The method name may be omitted, in which case
+     * any method on the given service is matched.
+     */
+    @AutoValue
+    @Immutable
+    abstract static class Name {
+
+      abstract String service();
+
+      @Nullable
+      abstract String method();
+
+      static Name create(String service, @Nullable String method) {
+        return new AutoValue_RlsProtoData_GrpcKeyBuilder_Name(service, method);
+      }
+    }
+  }
+
+  @AutoValue
+  @Immutable
+  abstract static class ExtraKeys {
+    static final ExtraKeys DEFAULT = create(null, null, null);
+
+    @Nullable abstract String host();
+
+    @Nullable abstract String service();
+
+    @Nullable abstract String method();
+
+    static ExtraKeys create(
+        @Nullable String host, @Nullable String service, @Nullable String method) {
+      return new AutoValue_RlsProtoData_ExtraKeys(host, service, method);
+    }
+  }
+}
diff --git a/rls/src/main/java/io/grpc/rls/RlsRequestFactory.java b/rls/src/main/java/io/grpc/rls/RlsRequestFactory.java
new file mode 100644
index 00000000000..1fed78f4df3
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/RlsRequestFactory.java
@@ -0,0 +1,120 @@
+/*
+ * 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.rls;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.ImmutableMap;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.Metadata;
+import io.grpc.rls.RlsProtoData.ExtraKeys;
+import io.grpc.rls.RlsProtoData.GrpcKeyBuilder;
+import io.grpc.rls.RlsProtoData.GrpcKeyBuilder.Name;
+import io.grpc.rls.RlsProtoData.NameMatcher;
+import io.grpc.rls.RlsProtoData.RouteLookupConfig;
+import io.grpc.rls.RlsProtoData.RouteLookupRequestKey;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A RlsRequestFactory creates {@link RouteLookupRequestKey} using key builder map from {@link
+ * RouteLookupConfig}.
+ */
+final class RlsRequestFactory {
+
+  private final String target;
+  private final Map<String, GrpcKeyBuilder> keyBuilderTable;
+
+  RlsRequestFactory(RouteLookupConfig rlsConfig, String target) {
+    checkNotNull(rlsConfig, "rlsConfig");
+    this.target = checkNotNull(target, "target");
+    this.keyBuilderTable = createKeyBuilderTable(rlsConfig);
+  }
+
+  private static Map<String, GrpcKeyBuilder> createKeyBuilderTable(
+      RouteLookupConfig config) {
+    Map<String, GrpcKeyBuilder> table = new HashMap<>();
+    for (GrpcKeyBuilder grpcKeyBuilder : config.grpcKeybuilders()) {
+      for (Name name : grpcKeyBuilder.names()) {
+        boolean noMethod = name.method() == null || name.method().isEmpty();
+        String method = noMethod ? "*" : name.method();
+        String path = "/" + name.service() + "/" + method;
+        table.put(path, grpcKeyBuilder);
+      }
+    }
+    return table;
+  }
+
+  /** Creates a {@link RouteLookupRequestKey} for the given request lookup metadata. */
+  @CheckReturnValue
+  RouteLookupRequestKey create(String service, String method, Metadata metadata) {
+    checkNotNull(service, "service");
+    checkNotNull(method, "method");
+    String path = "/" + service + "/" + method;
+    GrpcKeyBuilder grpcKeyBuilder = keyBuilderTable.get(path);
+    if (grpcKeyBuilder == null) {
+      // if no matching keyBuilder found, fall back to wildcard match (ServiceName/*)
+      grpcKeyBuilder = keyBuilderTable.get("/" + service + "/*");
+    }
+    if (grpcKeyBuilder == null) {
+      return RouteLookupRequestKey.create(ImmutableMap.of());
+    }
+    ImmutableMap.Builder<String, String> rlsRequestHeaders =
+        createRequestHeaders(metadata, grpcKeyBuilder.headers());
+    ExtraKeys extraKeys = grpcKeyBuilder.extraKeys();
+    Map<String, String> constantKeys = grpcKeyBuilder.constantKeys();
+    if (extraKeys.host() != null) {
+      rlsRequestHeaders.put(extraKeys.host(), target);
+    }
+    if (extraKeys.service() != null) {
+      rlsRequestHeaders.put(extraKeys.service(), service);
+    }
+    if (extraKeys.method() != null) {
+      rlsRequestHeaders.put(extraKeys.method(), method);
+    }
+    rlsRequestHeaders.putAll(constantKeys);
+    return RouteLookupRequestKey.create(rlsRequestHeaders.buildOrThrow());
+  }
+
+  private ImmutableMap.Builder<String, String> createRequestHeaders(
+      Metadata metadata, List<NameMatcher> keyBuilder) {
+    ImmutableMap.Builder<String, String> rlsRequestHeaders = ImmutableMap.builder();
+    for (NameMatcher nameMatcher : keyBuilder) {
+      String value = null;
+      for (String requestHeaderName : nameMatcher.names()) {
+        value = metadata.get(Metadata.Key.of(requestHeaderName, Metadata.ASCII_STRING_MARSHALLER));
+        if (value != null) {
+          break;
+        }
+      }
+      if (value != null) {
+        rlsRequestHeaders.put(nameMatcher.key(), value);
+      }
+    }
+    return rlsRequestHeaders;
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("target", target)
+        .add("keyBuilderTable", keyBuilderTable)
+        .toString();
+  }
+}
diff --git a/rls/src/main/java/io/grpc/rls/SubchannelStateManager.java b/rls/src/main/java/io/grpc/rls/SubchannelStateManager.java
new file mode 100644
index 00000000000..041d2a817ab
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/SubchannelStateManager.java
@@ -0,0 +1,44 @@
+/*
+ * 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.rls;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.ConnectivityState;
+import javax.annotation.Nullable;
+
+/**
+ * SubchannelStateManager manages {@link ConnectivityState} of child subchannels.
+ */
+interface SubchannelStateManager {
+
+  /**
+   * Registers and updates state for given subchannel. {@link ConnectivityState#SHUTDOWN}
+   * unregisters the subchannel.
+   */
+  void updateState(String name, ConnectivityState newState);
+
+  /**
+   * Returns current subchannel state for given subchannel name if exists, otherwise returns
+   * {@code null}.
+   */
+  @Nullable
+  @VisibleForTesting
+  ConnectivityState getState(String name);
+
+  /** Returns representative subchannel status from all registered subchannels. */
+  ConnectivityState getAggregatedState();
+}
diff --git a/rls/src/main/java/io/grpc/rls/SubchannelStateManagerImpl.java b/rls/src/main/java/io/grpc/rls/SubchannelStateManagerImpl.java
new file mode 100644
index 00000000000..f2d6d612fd6
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/SubchannelStateManagerImpl.java
@@ -0,0 +1,82 @@
+/*
+ * 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.rls;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.HashMultiset;
+import com.google.common.collect.Multiset;
+import io.grpc.ConnectivityState;
+import java.util.HashMap;
+import javax.annotation.Nullable;
+
+/** Implementation of {@link SubchannelStateManager}. */
+final class SubchannelStateManagerImpl implements SubchannelStateManager {
+
+  private final HashMap<String, ConnectivityState> stateMap = new HashMap<>();
+  private final Multiset<ConnectivityState> stateMultiset = HashMultiset.create();
+  private ConnectivityState currentState;
+
+  @Override
+  public void updateState(String name, ConnectivityState newState) {
+    checkNotNull(name, "name");
+    checkNotNull(newState, "newState");
+    ConnectivityState existing;
+    if (newState == ConnectivityState.SHUTDOWN) {
+      existing = stateMap.remove(name);
+    } else {
+      existing = stateMap.put(name, newState);
+      stateMultiset.add(newState);
+    }
+    if (existing != null) {
+      stateMultiset.remove(existing);
+    }
+  }
+
+  @Override
+  @Nullable
+  public ConnectivityState getState(String name) {
+    return stateMap.get(checkNotNull(name, "name"));
+  }
+
+  @Override
+  public ConnectivityState getAggregatedState() {
+    if (stateMultiset.contains(ConnectivityState.READY)) {
+      currentState = ConnectivityState.READY;
+    } else if (stateMultiset.contains(ConnectivityState.CONNECTING)) {
+      if (currentState != ConnectivityState.TRANSIENT_FAILURE) {
+        currentState = ConnectivityState.CONNECTING;
+      }
+    } else if (stateMultiset.contains(ConnectivityState.IDLE)) {
+      currentState = ConnectivityState.IDLE;
+    } else if (stateMultiset.contains(ConnectivityState.TRANSIENT_FAILURE)) {
+      currentState = ConnectivityState.TRANSIENT_FAILURE;
+    } else {
+      // empty or shutdown
+      currentState = ConnectivityState.IDLE;
+    }
+    return currentState;
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("stateMap", stateMap)
+        .toString();
+  }
+}
diff --git a/rls/src/main/java/io/grpc/rls/Throttler.java b/rls/src/main/java/io/grpc/rls/Throttler.java
new file mode 100644
index 00000000000..96d17e70adf
--- /dev/null
+++ b/rls/src/main/java/io/grpc/rls/Throttler.java
@@ -0,0 +1,45 @@
+/*
+ * 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.rls;
+
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A strategy for deciding when to throttle requests at the client.
+ */
+@ThreadSafe
+interface Throttler {
+
+  /**
+   * Checks if a given request should be throttled by the client. This should be called for every
+   * request before allowing it to hit the network. If the returned value is true, the request
+   * should be aborted immediately (as if it had been throttled by the server).
+   *
+   * <p>This updates internal state and should be called exactly once for each request.
+   */
+  boolean shouldThrottle();
+
+  /**
+   * Registers a response received from the backend for a request allowed by shouldThrottle. This
+   * should be called for every response received from the backend (i.e., once for each request for
+   * which ShouldThrottle returned false). This updates the internal statistics used by
+   * shouldThrottle.
+   *
+   * @param throttled specifies whether the request was throttled by the backend.
+   */
+  void registerBackendResponse(boolean throttled);
+}
diff --git a/rls/src/main/proto/grpc/lookup/v1/rls.proto b/rls/src/main/proto/grpc/lookup/v1/rls.proto
new file mode 100644
index 00000000000..7d1735289d5
--- /dev/null
+++ b/rls/src/main/proto/grpc/lookup/v1/rls.proto
@@ -0,0 +1,62 @@
+// 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.
+
+syntax = "proto3";
+
+package grpc.lookup.v1;
+
+option go_package = "google.golang.org/grpc/lookup/grpc_lookup_v1";
+option java_multiple_files = true;
+option java_package = "io.grpc.lookup.v1";
+option java_outer_classname = "RlsProto";
+
+message RouteLookupRequest {
+  // Target type allows the client to specify what kind of target format it
+  // would like from RLS to allow it to find the regional server, e.g. "grpc".
+  string target_type = 3;
+  // Possible reasons for making a request.
+  enum Reason {
+    REASON_UNKNOWN = 0;  // Unused
+    REASON_MISS = 1;     // No data available in local cache
+    REASON_STALE = 2;    // Data in local cache is stale
+  }
+  // Reason for making this request.
+  Reason reason = 5;
+  // For REASON_STALE, the header_data from the stale response, if any.
+  string stale_header_data = 6;
+  // Map of key values extracted via key builders for the gRPC or HTTP request.
+  map<string, string> key_map = 4;
+
+  reserved 1, 2;
+  reserved "server", "path";
+}
+
+message RouteLookupResponse {
+  // Prioritized list (best one first) of addressable entities to use
+  // for routing, using syntax requested by the request target_type.
+  // The targets will be tried in order until a healthy one is found.
+  repeated string targets = 3;
+  // Optional header value to pass along to AFE in the X-Google-RLS-Data header.
+  // Cached with "target" and sent with all requests that match the request key.
+  // Allows the RLS to pass its work product to the eventual target.
+  string header_data = 2;
+
+  reserved 1;
+  reserved "target";
+}
+
+service RouteLookupService {
+  // Lookup returns a target for a single key.
+  rpc RouteLookup(RouteLookupRequest) returns (RouteLookupResponse) {}
+}
diff --git a/rls/src/main/proto/grpc/lookup/v1/rls_config.proto b/rls/src/main/proto/grpc/lookup/v1/rls_config.proto
new file mode 100644
index 00000000000..9d2b6c54cfb
--- /dev/null
+++ b/rls/src/main/proto/grpc/lookup/v1/rls_config.proto
@@ -0,0 +1,225 @@
+// 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.
+
+syntax = "proto3";
+
+package grpc.lookup.v1;
+
+import "google/protobuf/duration.proto";
+
+option go_package = "google.golang.org/grpc/lookup/grpc_lookup_v1";
+option java_multiple_files = true;
+option java_package = "io.grpc.lookup.v1";
+option java_outer_classname = "RlsConfigProto";
+
+// Extract a key based on a given name (e.g. header name or query parameter
+// name).  The name must match one of the names listed in the "name" field.  If
+// the "required_match" field is true, one of the specified names must be
+// present for the keybuilder to match.
+message NameMatcher {
+  // The name that will be used in the RLS key_map to refer to this value.
+  // If required_match is true, you may omit this field or set it to an empty
+  // string, in which case the matcher will require a match, but won't update
+  // the key_map.
+  string key = 1;
+
+  // Ordered list of names (headers or query parameter names) that can supply
+  // this value; the first one with a non-empty value is used.
+  repeated string names = 2;
+
+  // If true, make this extraction required; the key builder will not match
+  // if no value is found.
+  bool required_match = 3;
+}
+
+// A GrpcKeyBuilder applies to a given gRPC service, name, and headers.
+message GrpcKeyBuilder {
+  // To match, one of the given Name fields must match; the service and method
+  // fields are specified as fixed strings.  The service name is required and
+  // includes the proto package name.  The method name may be omitted, in
+  // which case any method on the given service is matched.
+  message Name {
+    string service = 1;
+    string method = 2;
+  }
+  repeated Name names = 1;
+
+  // If you wish to include the host, service, or method names as keys in the
+  // generated RouteLookupRequest, specify key names to use in the extra_keys
+  // submessage. If a key name is empty, no key will be set for that value.
+  // If this submessage is specified, the normal host/path fields will be left
+  // unset in the RouteLookupRequest. We are deprecating host/path in the
+  // RouteLookupRequest, so services should migrate to the ExtraKeys approach.
+  message ExtraKeys {
+    string host = 1;
+    string service = 2;
+    string method = 3;
+  }
+  ExtraKeys extra_keys = 3;
+
+  // Extract keys from all listed headers.
+  // For gRPC, it is an error to specify "required_match" on the NameMatcher
+  // protos.
+  repeated NameMatcher headers = 2;
+
+  // You can optionally set one or more specific key/value pairs to be added to
+  // the key_map.  This can be useful to identify which builder built the key,
+  // for example if you are suppressing the actual method, but need to
+  // separately cache and request all the matched methods.
+  map<string, string> constant_keys = 4;
+}
+
+// An HttpKeyBuilder applies to a given HTTP URL and headers.
+//
+// Path and host patterns use the matching syntax from gRPC transcoding to
+// extract named key/value pairs from the path and host components of the URL:
+// https://github.com/googleapis/googleapis/blob/master/google/api/http.proto
+//
+// It is invalid to specify the same key name in multiple places in a pattern.
+//
+// For a service where the project id can be expressed either as a subdomain or
+// in the path, separate HttpKeyBuilders must be used:
+//     host_pattern: 'example.com' path_pattern: '/{id}/{object}/**'
+//     host_pattern: '{id}.example.com' path_pattern: '/{object}/**'
+// If the host is exactly 'example.com', the first path segment will be used as
+// the id and the second segment as the object. If the host has a subdomain, the
+// subdomain will be used as the id and the first segment as the object. If
+// neither pattern matches, no keys will be extracted.
+message HttpKeyBuilder {
+  // host_pattern is an ordered list of host template patterns for the desired
+  // value.  If any host_pattern values are specified, then at least one must
+  // match, and the last one wins and sets any specified variables.  A host
+  // consists of labels separated by dots. Each label is matched against the
+  // label in the pattern as follows:
+  //   - "*": Matches any single label.
+  //   - "**": Matches zero or more labels (first or last part of host only).
+  //   - "{<name>=...}": One or more label capture, where "..." can be any
+  //      template that does not include a capture.
+  //   - "{<name>}": A single label capture. Identical to {<name>=*}.
+  //
+  // Examples:
+  //   - "example.com": Only applies to the exact host example.com.
+  //   - "*.example.com": Matches subdomains of example.com.
+  //   - "**.example.com": matches example.com, and all levels of subdomains.
+  //   - "{project}.example.com": Extracts the third level subdomain.
+  //   - "{project=**}.example.com": Extracts the third level+ subdomains.
+  //   - "{project=**}": Extracts the entire host.
+  repeated string host_patterns = 1;
+
+  // path_pattern is an ordered list of path template patterns for the desired
+  // value.  If any path_pattern values are specified, then at least one must
+  // match, and the last one wins and sets any specified variables.  A path
+  // consists of segments separated by slashes. Each segment is matched against
+  // the segment in the pattern as follows:
+  //   - "*": Matches any single segment.
+  //   - "**": Matches zero or more segments (first or last part of path only).
+  //   - "{<name>=...}": One or more segment capture, where "..." can be any
+  //      template that does not include a capture.
+  //   - "{<name>}": A single segment capture. Identical to {<name>=*}.
+  // A custom method may also be specified by appending ":" and the custom
+  // method name or "*" to indicate any custom method (including no custom
+  // method).  For example, "/*/projects/{project_id}/**:*" extracts
+  // `{project_id}` for any version, resource and custom method that includes
+  // it.  By default, any custom method will be matched.
+  //
+  // Examples:
+  //   - "/v1/{name=messages/*}": extracts a name like "messages/12345".
+  //   - "/v1/messages/{message_id}": extracts a message_id like "12345".
+  //   - "/v1/users/{user_id}/messages/{message_id}": extracts two key values.
+  repeated string path_patterns = 2;
+
+  // List of query parameter names to try to match.
+  // For example: ["parent", "name", "resource.name"]
+  // We extract all the specified query_parameters (case-sensitively).  If any
+  // are marked as "required_match" and are not present, this keybuilder fails
+  // to match.  If a given parameter appears multiple times (?foo=a&foo=b) we
+  // will report it as a comma-separated string (foo=a,b).
+  repeated NameMatcher query_parameters = 3;
+
+  // List of headers to try to match.
+  // We extract all the specified header values (case-insensitively).  If any
+  // are marked as "required_match" and are not present, this keybuilder fails
+  // to match.  If a given header appears multiple times in the request we will
+  // report it as a comma-separated string, in standard HTTP fashion.
+  repeated NameMatcher headers = 4;
+
+  // You can optionally set one or more specific key/value pairs to be added to
+  // the key_map.  This can be useful to identify which builder built the key,
+  // for example if you are suppressing a lot of information from the URL, but
+  // need to separately cache and request URLs with that content.
+  map<string, string> constant_keys = 5;
+}
+
+message RouteLookupConfig {
+  // Ordered specifications for constructing keys for HTTP requests.  Last
+  // match wins.  If no HttpKeyBuilder matches, an empty key_map will be sent to
+  // the lookup service; it should likely reply with a global default route
+  // and raise an alert.
+  repeated HttpKeyBuilder http_keybuilders = 1;
+
+  // Unordered specifications for constructing keys for gRPC requests.  All
+  // GrpcKeyBuilders on this list must have unique "name" fields so that the
+  // client is free to prebuild a hash map keyed by name.  If no GrpcKeyBuilder
+  // matches, an empty key_map will be sent to the lookup service; it should
+  // likely reply with a global default route and raise an alert.
+  repeated GrpcKeyBuilder grpc_keybuilders = 2;
+
+  // The name of the lookup service as a gRPC URI.  Typically, this will be
+  // a subdomain of the target, such as "lookup.datastore.googleapis.com".
+  string lookup_service = 3;
+
+  // Configure a timeout value for lookup service requests.
+  // Defaults to 10 seconds if not specified.
+  google.protobuf.Duration lookup_service_timeout = 4;
+
+  // How long are responses valid for (like HTTP Cache-Control).
+  // If omitted or zero, the longest valid cache time is used.
+  // This value is clamped to 5 minutes to avoid unflushable bad responses.
+  google.protobuf.Duration max_age = 5;
+
+  // After a response has been in the client cache for this amount of time
+  // and is re-requested, start an asynchronous RPC to re-validate it.
+  // This value should be less than max_age by at least the length of a
+  // typical RTT to the Route Lookup Service to fully mask the RTT latency.
+  // If omitted, keys are only re-requested after they have expired.
+  google.protobuf.Duration stale_age = 6;
+
+  // Rough indicator of amount of memory to use for the client cache.  Some of
+  // the data structure overhead is not accounted for, so actual memory consumed
+  // will be somewhat greater than this value.  If this field is omitted or set
+  // to zero, a client default will be used.  The value may be capped to a lower
+  // amount based on client configuration.
+  int64 cache_size_bytes = 7;
+
+  // This is a list of all the possible targets that can be returned by the
+  // lookup service.  If a target not on this list is returned, it will be
+  // treated the same as an unhealthy target.
+  repeated string valid_targets = 8;
+
+  // This value provides a default target to use if needed.  If set, it will be
+  // used if RLS returns an error, times out, or returns an invalid response.
+  // Note that requests can be routed only to a subdomain of the original
+  // target, e.g. "us_east_1.cloudbigtable.googleapis.com".
+  string default_target = 9;
+
+  reserved 10;
+  reserved "request_processing_strategy";
+}
+
+// RouteLookupClusterSpecifier is used in xDS to represent a cluster specifier
+// plugin for RLS.
+message RouteLookupClusterSpecifier {
+  // The RLS config for this cluster specifier plugin instance.
+  RouteLookupConfig route_lookup_config = 1;
+}
diff --git a/rls/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider b/rls/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
new file mode 100644
index 00000000000..e12cb137091
--- /dev/null
+++ b/rls/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
@@ -0,0 +1 @@
+io.grpc.rls.RlsLoadBalancerProvider
diff --git a/rls/src/test/java/io/grpc/rls/AdaptiveThrottlerTest.java b/rls/src/test/java/io/grpc/rls/AdaptiveThrottlerTest.java
new file mode 100644
index 00000000000..6852b2479d5
--- /dev/null
+++ b/rls/src/test/java/io/grpc/rls/AdaptiveThrottlerTest.java
@@ -0,0 +1,124 @@
+/*
+ * 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.rls;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.base.Ticker;
+import io.grpc.internal.FakeClock;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class AdaptiveThrottlerTest {
+  private static final float TOLERANCE = 0.0001f;
+
+  private final FakeClock fakeClock = new FakeClock();
+  private final Ticker fakeTicker = fakeClock.getTicker();
+  private final AdaptiveThrottler throttler =
+      new AdaptiveThrottler.Builder()
+          .setHistorySeconds(1)
+          .setRatioForAccepts(1.0f)
+          .setRequestsPadding(1)
+          .setTicker(fakeTicker)
+          .build();
+
+  @Test
+  public void shouldThrottle() {
+    long startTime = fakeClock.currentTimeMillis();
+
+    // initial states
+    assertThat(throttler.requestStat.get(fakeTicker.read())).isEqualTo(0L);
+    assertThat(throttler.throttledStat.get(fakeTicker.read())).isEqualTo(0L);
+    assertThat(throttler.getThrottleProbability(fakeTicker.read()))
+        .isWithin(TOLERANCE).of(0.0f);
+
+    // Request 1, allowed by all.
+    assertThat(throttler.shouldThrottle(0.4f)).isFalse();
+    fakeClock.forwardTime(1L, TimeUnit.MILLISECONDS);
+    throttler.registerBackendResponse(false);
+
+    assertThat(throttler.requestStat.get(fakeTicker.read()))
+        .isEqualTo(1L);
+    assertThat(throttler.throttledStat.get(fakeTicker.read())).isEqualTo(0L);
+    assertThat(throttler.getThrottleProbability(fakeTicker.read()))
+        .isWithin(TOLERANCE).of(0.0f);
+
+    // Request 2, throttled by backend
+    assertThat(throttler.shouldThrottle(0.4f)).isFalse();
+    fakeClock.forwardTime(1L, TimeUnit.MILLISECONDS);
+    throttler.registerBackendResponse(true);
+
+    assertThat(throttler.requestStat.get(fakeTicker.read()))
+        .isEqualTo(2L);
+    assertThat(throttler.throttledStat.get(fakeTicker.read()))
+        .isEqualTo(1L);
+    assertThat(throttler.getThrottleProbability(fakeTicker.read()))
+        .isWithin(TOLERANCE)
+        .of(1.0f / 3.0f);
+
+    // Skip to half second mark from the beginning (half the duration).
+    fakeClock.forwardTime(500 - (fakeClock.currentTimeMillis() - startTime),
+        TimeUnit.MILLISECONDS);
+
+    // Request 3, throttled by backend
+    assertThat(throttler.shouldThrottle(0.4f)).isFalse();
+    fakeClock.forwardTime(1L, TimeUnit.MILLISECONDS);
+    throttler.registerBackendResponse(true);
+
+    assertThat(throttler.requestStat.get(fakeTicker.read())).isEqualTo(3L);
+    assertThat(throttler.throttledStat.get(fakeTicker.read())).isEqualTo(2L);
+    assertThat(throttler.getThrottleProbability(fakeTicker.read()))
+        .isWithin(TOLERANCE)
+        .of(2.0f / 4.0f);
+
+    // Request 4, throttled by client.
+    assertThat(throttler.shouldThrottle(0.4f)).isTrue();
+    fakeClock.forwardTime(1L, TimeUnit.MILLISECONDS);
+
+    assertThat(throttler.requestStat.get(fakeTicker.read())).isEqualTo(4L);
+    assertThat(throttler.throttledStat.get(fakeTicker.read())).isEqualTo(3L);
+    assertThat(throttler.getThrottleProbability(fakeTicker.read()))
+        .isWithin(TOLERANCE)
+        .of(3.0f / 5.0f);
+
+    // Skip to the point where only requests 3 and 4 are visible.
+    fakeClock.forwardTime(
+        1250 - (fakeClock.currentTimeMillis() - startTime), TimeUnit.MILLISECONDS);
+
+    assertThat(throttler.requestStat.get(fakeTicker.read())).isEqualTo(2L);
+    assertThat(throttler.throttledStat.get(fakeTicker.read())).isEqualTo(2L);
+    assertThat(throttler.getThrottleProbability(fakeTicker.read()))
+        .isWithin(TOLERANCE)
+        .of(2.0f / 3.0f);
+  }
+
+  /**
+   * Check that when the ticker returns a negative value for now that the slot detection logic
+   * is correctly handled and then when the value transitions from negative to positive that things
+   * continue to work correctly.
+   */
+  @Test
+  public void negativeTickerValues() {
+    long rewindAmount = TimeUnit.MILLISECONDS.toNanos(300) + fakeClock.getTicker().read();
+    fakeClock.forwardTime(-1 * rewindAmount, TimeUnit.NANOSECONDS);
+    assertThat(fakeClock.getTicker().read()).isEqualTo(TimeUnit.MILLISECONDS.toNanos(-300));
+    shouldThrottle();
+  }
+}
diff --git a/rls/src/test/java/io/grpc/rls/CachingRlsLbClientTest.java b/rls/src/test/java/io/grpc/rls/CachingRlsLbClientTest.java
new file mode 100644
index 00000000000..b349aecdbf3
--- /dev/null
+++ b/rls/src/test/java/io/grpc/rls/CachingRlsLbClientTest.java
@@ -0,0 +1,1237 @@
+/*
+ * 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.rls;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static io.grpc.rls.CachingRlsLbClient.RLS_DATA_KEY;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Converter;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.ConnectivityState;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.ForwardingChannelBuilder2;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickDetailsConsumer;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LongGaugeMetricInstrument;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Metadata;
+import io.grpc.MetricRecorder;
+import io.grpc.MetricRecorder.BatchCallback;
+import io.grpc.MetricRecorder.BatchRecorder;
+import io.grpc.MetricRecorder.Registration;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Server;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.PickSubchannelArgsImpl;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.lookup.v1.RouteLookupServiceGrpc;
+import io.grpc.rls.CachingRlsLbClient.CacheEntry;
+import io.grpc.rls.CachingRlsLbClient.CachedRouteLookupResponse;
+import io.grpc.rls.CachingRlsLbClient.RlsPicker;
+import io.grpc.rls.LbPolicyConfiguration.ChildLoadBalancingPolicy;
+import io.grpc.rls.LbPolicyConfiguration.ChildPolicyWrapper;
+import io.grpc.rls.LruCache.EvictionListener;
+import io.grpc.rls.LruCache.EvictionType;
+import io.grpc.rls.RlsProtoConverters.RouteLookupResponseConverter;
+import io.grpc.rls.RlsProtoData.ExtraKeys;
+import io.grpc.rls.RlsProtoData.GrpcKeyBuilder;
+import io.grpc.rls.RlsProtoData.GrpcKeyBuilder.Name;
+import io.grpc.rls.RlsProtoData.NameMatcher;
+import io.grpc.rls.RlsProtoData.RouteLookupConfig;
+import io.grpc.rls.RlsProtoData.RouteLookupRequest;
+import io.grpc.rls.RlsProtoData.RouteLookupResponse;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.TestMethodDescriptors;
+import java.io.IOException;
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import javax.annotation.Nonnull;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class CachingRlsLbClientTest {
+
+  private static final RouteLookupConfig ROUTE_LOOKUP_CONFIG = getRouteLookupConfig();
+  private static final int SERVER_LATENCY_MILLIS = 10;
+  private static final String DEFAULT_TARGET = "fallback.cloudbigtable.googleapis.com";
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  @Rule
+  public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
+
+  @Mock
+  private EvictionListener<RlsProtoData.RouteLookupRequestKey, CacheEntry> evictionListener;
+  @Mock
+  private SocketAddress socketAddress;
+  @Mock
+  private MetricRecorder mockMetricRecorder;
+  @Mock
+  private BatchRecorder mockBatchRecorder;
+  @Mock
+  private Registration mockGaugeRegistration;
+  @Captor
+  private ArgumentCaptor<BatchCallback> gaugeBatchCallbackCaptor;
+
+
+  private final SynchronizationContext syncContext =
+      new SynchronizationContext(new UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new RuntimeException(e);
+        }
+      });
+  private final FakeBackoffProvider fakeBackoffProvider = new FakeBackoffProvider();
+  private final ResolvedAddressFactory resolvedAddressFactory =
+      new ChildLbResolvedAddressFactory(
+          ImmutableList.of(new EquivalentAddressGroup(socketAddress)), Attributes.EMPTY);
+  private final TestLoadBalancerProvider lbProvider = new TestLoadBalancerProvider();
+  private final FakeClock fakeClock = new FakeClock();
+  private final StaticFixedDelayRlsServerImpl rlsServerImpl =
+      new StaticFixedDelayRlsServerImpl(
+          TimeUnit.MILLISECONDS.toNanos(SERVER_LATENCY_MILLIS),
+          fakeClock.getScheduledExecutorService());
+  private final ChildLoadBalancingPolicy childLbPolicy =
+      new ChildLoadBalancingPolicy("target", Collections.<String, Object>emptyMap(), lbProvider);
+  private final FakeHelper fakeHelper = new FakeHelper();
+  private final Helper helper =
+      mock(Helper.class, delegatesTo(fakeHelper));
+  private final FakeThrottler fakeThrottler = new FakeThrottler();
+  private final LbPolicyConfiguration lbPolicyConfiguration =
+      new LbPolicyConfiguration(ROUTE_LOOKUP_CONFIG, null, childLbPolicy);
+
+  private CachingRlsLbClient rlsLbClient;
+  private Map<String, ?> rlsChannelServiceConfig;
+  private String rlsChannelOverriddenAuthority;
+
+  private void setUpRlsLbClient() {
+    fakeThrottler.resetCounts();
+    rlsLbClient =
+        CachingRlsLbClient.newBuilder()
+            .setBackoffProvider(fakeBackoffProvider)
+            .setResolvedAddressesFactory(resolvedAddressFactory)
+            .setEvictionListener(evictionListener)
+            .setHelper(helper)
+            .setLbPolicyConfig(lbPolicyConfiguration)
+            .setThrottler(fakeThrottler)
+            .setTicker(fakeClock.getTicker())
+            .build();
+  }
+
+  @Before
+  public void setUpMockMetricRecorder() {
+    when(mockMetricRecorder.registerBatchCallback(any(), any())).thenReturn(mockGaugeRegistration);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    if (rlsLbClient != null) {
+      rlsLbClient.close();
+    }
+    assertWithMessage(
+            "On client shut down, RlsLoadBalancer must shut down with all its child loadbalancers.")
+        .that(lbProvider.loadBalancers).isEmpty();
+  }
+
+  private CachedRouteLookupResponse getInSyncContext(
+      final RlsProtoData.RouteLookupRequestKey routeLookupRequestKey)
+      throws ExecutionException, InterruptedException, TimeoutException {
+    final SettableFuture<CachedRouteLookupResponse> responseSettableFuture =
+        SettableFuture.create();
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        responseSettableFuture.set(rlsLbClient.get(routeLookupRequestKey));
+      }
+    });
+    return responseSettableFuture.get(5, TimeUnit.SECONDS);
+  }
+
+  @Test
+  public void get_noError_lifeCycle() throws Exception {
+    setUpRlsLbClient();
+    InOrder inOrder = inOrder(evictionListener);
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of(
+            "server", "bigtable.googleapis.com", "service-key", "foo", "method-key", "bar"));
+    rlsServerImpl.setLookupTable(
+        ImmutableMap.of(
+            routeLookupRequestKey,
+            RouteLookupResponse.create(ImmutableList.of("target"), "header")));
+
+    // initial request
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.isPending()).isTrue();
+
+    // server response
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+
+    resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.hasData()).isTrue();
+
+    // cache hit for staled entry
+    fakeClock.forwardTime(ROUTE_LOOKUP_CONFIG.staleAgeInNanos(), TimeUnit.NANOSECONDS);
+
+    rlsServerImpl.routeLookupReason = null;
+    resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.hasData()).isTrue();
+
+    // async refresh finishes
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+    inOrder
+        .verify(evictionListener)
+        .onEviction(eq(routeLookupRequestKey), any(CacheEntry.class), eq(EvictionType.REPLACED));
+
+    resp = getInSyncContext(routeLookupRequestKey);
+
+    assertThat(rlsServerImpl.routeLookupReason).isEqualTo(
+        io.grpc.lookup.v1.RouteLookupRequest.Reason.REASON_STALE);
+    assertThat(resp.hasData()).isTrue();
+
+    // existing cache expired
+    fakeClock.forwardTime(ROUTE_LOOKUP_CONFIG.maxAgeInNanos(), TimeUnit.NANOSECONDS);
+
+    resp = getInSyncContext(routeLookupRequestKey);
+
+    assertThat(resp.isPending()).isTrue();
+    inOrder
+        .verify(evictionListener)
+        .onEviction(eq(routeLookupRequestKey), any(CacheEntry.class), eq(EvictionType.EXPIRED));
+
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void rls_withCustomRlsChannelServiceConfig() throws Exception {
+    Map<String, ?> routeLookupChannelServiceConfig =
+        ImmutableMap.of(
+            "loadBalancingConfig",
+            ImmutableList.of(ImmutableMap.of(
+                "grpclb",
+                ImmutableMap.of(
+                    "childPolicy",
+                    ImmutableList.of(ImmutableMap.of("pick_first", ImmutableMap.of())),
+                    "serviceName",
+                    "service1"))));
+    LbPolicyConfiguration lbPolicyConfiguration = new LbPolicyConfiguration(
+        ROUTE_LOOKUP_CONFIG, routeLookupChannelServiceConfig, childLbPolicy);
+    rlsLbClient =
+        CachingRlsLbClient.newBuilder()
+            .setBackoffProvider(fakeBackoffProvider)
+            .setResolvedAddressesFactory(resolvedAddressFactory)
+            .setEvictionListener(evictionListener)
+            .setHelper(helper)
+            .setLbPolicyConfig(lbPolicyConfiguration)
+            .setThrottler(fakeThrottler)
+            .setTicker(fakeClock.getTicker())
+            .build();
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of(
+            "server", "bigtable.googleapis.com", "service-key", "foo", "method-key", "bar"));
+    rlsServerImpl.setLookupTable(
+        ImmutableMap.of(
+            routeLookupRequestKey,
+            RouteLookupResponse.create(ImmutableList.of("target"), "header")));
+
+    rlsServerImpl.routeLookupReason = null;
+    // initial request
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.isPending()).isTrue();
+
+    // server response
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+
+    resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.hasData()).isTrue();
+    assertThat(rlsServerImpl.routeLookupReason).isEqualTo(
+        io.grpc.lookup.v1.RouteLookupRequest.Reason.REASON_MISS);
+
+    assertThat(rlsChannelOverriddenAuthority).isEqualTo("bigtable.googleapis.com:443");
+    assertThat(rlsChannelServiceConfig).isEqualTo(routeLookupChannelServiceConfig);
+  }
+
+  @Test
+  public void backoffTimerEnd_updatesPicker() throws Exception {
+    setUpRlsLbClient();
+    InOrder inOrder = inOrder(helper);
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of(
+                "server", "bigtable.googleapis.com", "service-key", "foo", "method-key", "bar"));
+    rlsServerImpl.setLookupTable(
+        ImmutableMap.of(
+            routeLookupRequestKey,
+            RouteLookupResponse.create(ImmutableList.of("target"), "header")));
+
+    fakeThrottler.nextResult = true;
+    fakeBackoffProvider.nextPolicy = createBackoffPolicy(10, TimeUnit.MILLISECONDS);
+
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.hasError()).isTrue();
+
+    fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+    // Assert that Rls LB policy picker was updated which picks the fallback target
+    ArgumentCaptor<SubchannelPicker> pickerCaptor = ArgumentCaptor.forClass(SubchannelPicker.class);
+    ArgumentCaptor<ConnectivityState> stateCaptor =
+        ArgumentCaptor.forClass(ConnectivityState.class);
+
+    inOrder.verify(helper, times(3))
+        .updateBalancingState(stateCaptor.capture(), pickerCaptor.capture());
+    assertThat(new HashSet<>(pickerCaptor.getAllValues())).hasSize(1);
+    assertThat(stateCaptor.getAllValues())
+        .containsExactly(ConnectivityState.TRANSIENT_FAILURE, ConnectivityState.CONNECTING,
+            ConnectivityState.CONNECTING);
+    Metadata headers = new Metadata();
+    PickResult pickResult = getPickResultForCreate(pickerCaptor, headers);
+    assertThat(pickResult.getStatus().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(pickResult.getStatus().getDescription()).isEqualTo("fallback not available");
+  }
+
+  @Test
+  public void get_throttledTwice_usesSameBackoffpolicy() throws Exception {
+    setUpRlsLbClient();
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of(
+            "server", "bigtable.googleapis.com", "service-key", "foo", "method-key", "bar"));
+    rlsServerImpl.setLookupTable(
+        ImmutableMap.of(
+            routeLookupRequestKey,
+            RouteLookupResponse.create(ImmutableList.of("target"), "header")));
+
+    fakeThrottler.nextResult = true;
+    fakeBackoffProvider.nextPolicy = createBackoffPolicy(10, TimeUnit.MILLISECONDS);
+
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
+
+    assertThat(resp.hasError()).isTrue();
+
+    fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+
+    // Assert that the same backoff policy is still in effect for the cache entry.
+    // The below provider should not get used, so the back off time will still be set to 10ms.
+    fakeBackoffProvider.nextPolicy = createBackoffPolicy(20, TimeUnit.MILLISECONDS);
+    // let it be throttled again
+    resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.hasError()).isTrue();
+
+    fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+
+    // Backoff entry's backoff timer has gone off, so next rpc should not be backed off.
+    fakeThrottler.nextResult = false;
+    resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.isPending()).isTrue();
+
+    rlsServerImpl.routeLookupReason = null;
+    // server responses
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+    assertThat(rlsServerImpl.routeLookupReason).isEqualTo(
+        io.grpc.lookup.v1.RouteLookupRequest.Reason.REASON_MISS);
+  }
+
+  @Test
+  public void get_errorResponseTwice_usesSameBackoffPolicy() throws Exception {
+    setUpRlsLbClient();
+    RlsProtoData.RouteLookupRequestKey invalidRouteLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(ImmutableMap.of());
+    CachedRouteLookupResponse resp = getInSyncContext(invalidRouteLookupRequestKey);
+    assertThat(resp.isPending()).isTrue();
+    fakeBackoffProvider.nextPolicy = createBackoffPolicy(10, TimeUnit.MILLISECONDS);
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+    assertThat(rlsServerImpl.routeLookupReason).isEqualTo(
+        io.grpc.lookup.v1.RouteLookupRequest.Reason.REASON_MISS);
+
+    resp = getInSyncContext(invalidRouteLookupRequestKey);
+    assertThat(resp.hasError()).isTrue();
+
+    // Backoff time expiry
+    fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+    resp = getInSyncContext(invalidRouteLookupRequestKey);
+    assertThat(resp.isPending()).isTrue();
+    // Assert that the same backoff policy is still in effect for the cache entry.
+    // The below provider should not get used, so the back off time will still be set to 10ms.
+    fakeBackoffProvider.nextPolicy = createBackoffPolicy(20, TimeUnit.MILLISECONDS);
+    // Gets error again and backed off again
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+
+    resp = getInSyncContext(invalidRouteLookupRequestKey);
+    assertThat(resp.hasError()).isTrue();
+
+    // Backoff time expiry
+    fakeClock.forwardTime(10, TimeUnit.MILLISECONDS);
+    resp = getInSyncContext(invalidRouteLookupRequestKey);
+    assertThat(resp.isPending()).isTrue();
+
+    rlsServerImpl.routeLookupReason = null;
+    // server responses
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+    assertThat(rlsServerImpl.routeLookupReason).isEqualTo(
+        io.grpc.lookup.v1.RouteLookupRequest.Reason.REASON_MISS);
+  }
+
+  @Test
+  public void controlPlaneTransientToReady_backOffEntriesRemovedAndPickerUpdated()
+      throws Exception {
+    setUpRlsLbClient();
+    InOrder inOrder = inOrder(helper);
+    final ConnectivityState[] rlsChannelState = new ConnectivityState[1];
+    Runnable channelStateListener = new Runnable() {
+      @Override
+      public void run() {
+        rlsChannelState[0] = fakeHelper.oobChannel.getState(false);
+        fakeHelper.oobChannel.notifyWhenStateChanged(rlsChannelState[0], this);
+        synchronized (this) {
+          notify();
+        }
+      }
+    };
+    fakeHelper.oobChannel.notifyWhenStateChanged(fakeHelper.oobChannel.getState(false),
+        channelStateListener);
+
+    fakeHelper.server.shutdown();
+    // Channel goes to IDLE state from the shutdown listener handling.
+    try {
+      if (!fakeHelper.server.awaitTermination(10, TimeUnit.SECONDS)) {
+        fakeHelper.server.shutdownNow(); // Forceful shutdown if graceful timeout expires
+      }
+    } catch (InterruptedException e) {
+      fakeHelper.server.shutdownNow();
+    }
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(ImmutableMap.of(
+        "server", "bigtable.googleapis.com", "service-key", "foo", "method-key", "bar"));
+    // Rls channel will go to TRANSIENT_FAILURE (connection back-off).
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.isPending()).isTrue();
+    assertThat(rlsChannelState[0]).isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+    // Throttle the next rpc call.
+    fakeThrottler.nextResult = true;
+    fakeBackoffProvider.nextPolicy = createBackoffPolicy(10, TimeUnit.MILLISECONDS);
+
+    // Cause two cache misses by using new request keys. This will create back-off Rls cache
+    // entries. RLS control plane state transitioning to READY should reset both back-offs but
+    // update picker only once.
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey2 =
+        RlsProtoData.RouteLookupRequestKey.create(ImmutableMap.of(
+        "server", "bigtable.googleapis.com", "service-key", "foo2", "method-key", "bar"));
+    resp = getInSyncContext(routeLookupRequestKey2);
+    assertThat(resp.hasError()).isTrue();
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey3 =
+        RlsProtoData.RouteLookupRequestKey.create(ImmutableMap.of(
+            "server", "bigtable.googleapis.com", "service-key", "foo3", "method-key", "bar"));
+    resp = getInSyncContext(routeLookupRequestKey3);
+    assertThat(resp.hasError()).isTrue();
+
+    fakeHelper.createServerAndRegister("service1");
+    // Wait for Rls control plane channel back-off expiry and its moving to READY
+    synchronized (channelStateListener) {
+      channelStateListener.wait(2000);
+    }
+    assertThat(rlsChannelState[0]).isEqualTo(ConnectivityState.READY);
+    final ObjectPool<? extends Executor> defaultExecutorPool =
+        SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR);
+    AtomicBoolean isSuccess = new AtomicBoolean(false);
+    ((ExecutorService) defaultExecutorPool.getObject()).submit(() -> {
+      // Assert that Rls LB policy picker was updated which picks the fallback target
+      ArgumentCaptor<SubchannelPicker> pickerCaptor =
+          ArgumentCaptor.forClass(SubchannelPicker.class);
+      ArgumentCaptor<ConnectivityState> stateCaptor =
+          ArgumentCaptor.forClass(ConnectivityState.class);
+
+      inOrder.verify(helper, times(4))
+          .updateBalancingState(stateCaptor.capture(), pickerCaptor.capture());
+      assertThat(new HashSet<>(pickerCaptor.getAllValues())).hasSize(1);
+      assertThat(stateCaptor.getAllValues())
+          .containsExactly(ConnectivityState.TRANSIENT_FAILURE, ConnectivityState.CONNECTING,
+              ConnectivityState.CONNECTING, ConnectivityState.CONNECTING);
+      Metadata headers = new Metadata();
+      PickResult pickResult = getPickResultForCreate(pickerCaptor, headers);
+      assertThat(pickResult.getStatus().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+      assertThat(pickResult.getStatus().getDescription()).isEqualTo("fallback not available");
+      isSuccess.set(true);
+    }).get();
+    assertThat(isSuccess.get()).isTrue();
+
+    fakeThrottler.nextResult = false;
+    // Rpcs are not backed off now.
+    assertThat(getInSyncContext(routeLookupRequestKey2).isPending()).isTrue();
+    assertThat(getInSyncContext(routeLookupRequestKey3).isPending()).isTrue();
+  }
+
+  @Test
+  public void get_updatesLbState() throws Exception {
+    setUpRlsLbClient();
+    InOrder inOrder = inOrder(helper);
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of(
+            "server", "bigtable.googleapis.com", "service-key", "service1",
+                "method-key", "create"));
+    rlsServerImpl.setLookupTable(
+        ImmutableMap.of(
+            routeLookupRequestKey,
+            RouteLookupResponse.create(
+                ImmutableList.of("primary.cloudbigtable.googleapis.com"),
+                "header-rls-data-value")));
+
+    // valid channel
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.isPending()).isTrue();
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+
+    resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.hasData()).isTrue();
+
+    ArgumentCaptor<SubchannelPicker> pickerCaptor = ArgumentCaptor.forClass(SubchannelPicker.class);
+    ArgumentCaptor<ConnectivityState> stateCaptor =
+        ArgumentCaptor.forClass(ConnectivityState.class);
+    inOrder.verify(helper, times(3))
+        .updateBalancingState(stateCaptor.capture(), pickerCaptor.capture());
+
+    assertThat(new HashSet<>(pickerCaptor.getAllValues())).hasSize(1);
+    // TRANSIENT_FAILURE is because the test setup pretends fallback is not available.
+    assertThat(stateCaptor.getAllValues())
+        .containsExactly(ConnectivityState.TRANSIENT_FAILURE, ConnectivityState.CONNECTING,
+            ConnectivityState.READY);
+    Metadata headers = new Metadata();
+    PickResult pickResult = getPickResultForCreate(pickerCaptor, headers);
+    assertThat(pickResult.getStatus().isOk()).isTrue();
+    assertThat(pickResult.getSubchannel()).isNotNull();
+    assertThat(headers.get(RLS_DATA_KEY)).isEqualTo("header-rls-data-value");
+    assertThat(fakeThrottler.getNumThrottled()).isEqualTo(0);
+    assertThat(fakeThrottler.getNumUnthrottled()).isEqualTo(1);
+
+    // move backoff further back to only test error behavior
+    fakeBackoffProvider.nextPolicy = createBackoffPolicy(100, TimeUnit.MILLISECONDS);
+    // try to get invalid
+    RlsProtoData.RouteLookupRequestKey invalidRouteLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(ImmutableMap.<String, String>of());
+    CachedRouteLookupResponse errorResp = getInSyncContext(invalidRouteLookupRequestKey);
+    assertThat(errorResp.isPending()).isTrue();
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+
+    errorResp = getInSyncContext(invalidRouteLookupRequestKey);
+    assertThat(errorResp.hasError()).isTrue();
+
+    // Channel is still READY because the subchannel for method /service1/create is still READY.
+    // Method /doesn/exists will use fallback child balancer and fail immediately.
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
+    pickResult = pickerCaptor.getValue().pickSubchannel(
+        new PickSubchannelArgsImpl(
+            TestMethodDescriptors.voidMethod().toBuilder()
+                .setFullMethodName("doesn/exists")
+                .build(),
+            headers,
+            CallOptions.DEFAULT,
+            new PickDetailsConsumer() {}));
+    assertThat(pickResult.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(pickResult.getStatus().getDescription()).contains("fallback not available");
+    assertThat(fakeThrottler.getNumThrottled()).isEqualTo(1);
+    assertThat(fakeThrottler.getNumUnthrottled()).isEqualTo(1);
+  }
+
+  @Test
+  public void timeout_not_changing_picked_subchannel() throws Exception {
+    setUpRlsLbClient();
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of(
+            "server", "bigtable.googleapis.com", "service-key", "service1",
+                "method-key", "create"));
+    rlsServerImpl.setLookupTable(
+        ImmutableMap.of(
+            routeLookupRequestKey,
+            RouteLookupResponse.create(
+                ImmutableList.of("primary.cloudbigtable.googleapis.com", "target2", "target3"),
+                "header-rls-data-value")));
+
+    // valid channel
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.hasData()).isFalse();
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+
+    resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.hasData()).isTrue();
+
+    ArgumentCaptor<SubchannelPicker> pickerCaptor = ArgumentCaptor.forClass(SubchannelPicker.class);
+    ArgumentCaptor<ConnectivityState> stateCaptor =
+        ArgumentCaptor.forClass(ConnectivityState.class);
+    verify(helper, times(5)).updateBalancingState(stateCaptor.capture(), pickerCaptor.capture());
+
+    Metadata headers = new Metadata();
+    PickResult pickResult = getPickResultForCreate(pickerCaptor, headers);
+    assertThat(pickResult.getStatus().isOk()).isTrue();
+    assertThat(pickResult.getSubchannel().toString())
+        .isEqualTo("primary.cloudbigtable.googleapis.com");
+
+    fakeClock.forwardTime(5, TimeUnit.MINUTES);
+    PickResult pickResult2 = getPickResultForCreate(pickerCaptor, headers);
+    assertThat(pickResult2.getSubchannel()).isNull();
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+    PickResult pickResult3 = getPickResultForCreate(pickerCaptor, headers);
+    assertThat(pickResult3.getSubchannel()).isNotNull();
+    assertThat(pickResult3.getSubchannel().toString())
+        .isEqualTo(pickResult.getSubchannel().toString());
+  }
+
+  private static PickResult getPickResultForCreate(ArgumentCaptor<SubchannelPicker> pickerCaptor,
+      Metadata headers) {
+    return pickerCaptor.getValue().pickSubchannel(
+        new PickSubchannelArgsImpl(
+            TestMethodDescriptors.voidMethod().toBuilder().setFullMethodName("service1/create")
+                .build(),
+            headers,
+            CallOptions.DEFAULT,
+            new PickDetailsConsumer() {}));
+  }
+
+  @Test
+  public void get_withAdaptiveThrottler() throws Exception {
+    AdaptiveThrottler adaptiveThrottler =
+        new AdaptiveThrottler.Builder()
+            .setHistorySeconds(1)
+            .setRatioForAccepts(1.0f)
+            .setRequestsPadding(1)
+            .setTicker(fakeClock.getTicker())
+            .build();
+
+    this.rlsLbClient =
+        CachingRlsLbClient.newBuilder()
+            .setBackoffProvider(fakeBackoffProvider)
+            .setResolvedAddressesFactory(resolvedAddressFactory)
+            .setEvictionListener(evictionListener)
+            .setHelper(helper)
+            .setLbPolicyConfig(lbPolicyConfiguration)
+            .setThrottler(adaptiveThrottler)
+            .setTicker(fakeClock.getTicker())
+            .build();
+    InOrder inOrder = inOrder(helper);
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of(
+            "server", "bigtable.googleapis.com", "service-key", "service1",
+                "method-key", "create"));
+    rlsServerImpl.setLookupTable(
+        ImmutableMap.of(
+            routeLookupRequestKey,
+            RouteLookupResponse.create(
+                ImmutableList.of("primary.cloudbigtable.googleapis.com"),
+                "header-rls-data-value")));
+
+    // valid channel
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.isPending()).isTrue();
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+
+    resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.hasData()).isTrue();
+
+    ArgumentCaptor<SubchannelPicker> pickerCaptor = ArgumentCaptor.forClass(SubchannelPicker.class);
+    ArgumentCaptor<ConnectivityState> stateCaptor =
+        ArgumentCaptor.forClass(ConnectivityState.class);
+    inOrder.verify(helper, times(3))
+        .updateBalancingState(stateCaptor.capture(), pickerCaptor.capture());
+
+    Metadata headers = new Metadata();
+    PickResult pickResult = getPickResultForCreate(pickerCaptor, headers);
+    assertThat(pickResult.getSubchannel()).isNotNull();
+    assertThat(headers.get(RLS_DATA_KEY)).isEqualTo("header-rls-data-value");
+
+    // move backoff further back to only test error behavior
+    fakeBackoffProvider.nextPolicy = createBackoffPolicy(100, TimeUnit.MILLISECONDS);
+    // try to get invalid
+    RlsProtoData.RouteLookupRequestKey invalidRouteLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(ImmutableMap.<String, String>of());
+    CachedRouteLookupResponse errorResp = getInSyncContext(invalidRouteLookupRequestKey);
+    assertThat(errorResp.isPending()).isTrue();
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+
+    errorResp = getInSyncContext(invalidRouteLookupRequestKey);
+    assertThat(errorResp.hasError()).isTrue();
+
+    // Channel is still READY because the subchannel for method /service1/create is still READY.
+    // Method /doesn/exists will use fallback child balancer and fail immediately.
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
+    PickSubchannelArgsImpl invalidArgs = getInvalidArgs(headers);
+    pickResult = pickerCaptor.getValue().pickSubchannel(invalidArgs);
+    assertThat(pickResult.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(pickResult.getStatus().getDescription()).contains("fallback not available");
+    long time = fakeClock.getTicker().read();
+    assertThat(adaptiveThrottler.requestStat.get(time)).isEqualTo(2L);
+    assertThat(adaptiveThrottler.throttledStat.get(time)).isEqualTo(1L);
+  }
+
+  private PickSubchannelArgsImpl getInvalidArgs(Metadata headers) {
+    PickSubchannelArgsImpl invalidArgs = new PickSubchannelArgsImpl(
+        TestMethodDescriptors.voidMethod().toBuilder()
+            .setFullMethodName("doesn/exists")
+            .build(),
+        headers,
+        CallOptions.DEFAULT,
+        new PickDetailsConsumer() {});
+    return invalidArgs;
+  }
+
+  @Test
+  public void get_childPolicyWrapper_reusedForSameTarget() throws Exception {
+    setUpRlsLbClient();
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of(
+            "server", "bigtable.googleapis.com", "service-key", "foo", "method-key", "bar"));
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey2 =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of(
+            "server", "bigtable.googleapis.com", "service-key", "foo", "method-key", "baz"));
+    rlsServerImpl.setLookupTable(
+        ImmutableMap.of(
+            routeLookupRequestKey,
+            RouteLookupResponse.create(ImmutableList.of("target"), "header"),
+            routeLookupRequestKey2,
+            RouteLookupResponse.create(ImmutableList.of("target"), "header2")));
+
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.isPending()).isTrue();
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+
+    resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.hasData()).isTrue();
+    assertThat(resp.getHeaderData()).isEqualTo("header");
+
+    ChildPolicyWrapper childPolicyWrapper = resp.getChildPolicyWrapper();
+    assertNotNull(childPolicyWrapper);
+    assertThat(childPolicyWrapper.getTarget()).isEqualTo("target");
+    assertThat(childPolicyWrapper.getPicker()).isNotInstanceOf(RlsPicker.class);
+
+    // request2 has same target, it should reuse childPolicyWrapper
+    CachedRouteLookupResponse resp2 = getInSyncContext(routeLookupRequestKey2);
+    assertThat(resp2.isPending()).isTrue();
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+
+    resp2 = getInSyncContext(routeLookupRequestKey2);
+    assertThat(resp2.hasData()).isTrue();
+    assertThat(resp2.getHeaderData()).isEqualTo("header2");
+    assertThat(resp2.getChildPolicyWrapper()).isEqualTo(resp.getChildPolicyWrapper());
+  }
+
+  @Test
+  public void get_childPolicyWrapper_multiTarget() throws Exception {
+    setUpRlsLbClient();
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of(
+            "server", "bigtable.googleapis.com", "service-key", "foo", "method-key", "bar"));
+    rlsServerImpl.setLookupTable(
+        ImmutableMap.of(
+            routeLookupRequestKey,
+            RouteLookupResponse.create(
+                ImmutableList.of("target1", "target2", "target3"),
+                "header")));
+
+    CachedRouteLookupResponse resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.isPending()).isTrue();
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+
+    resp = getInSyncContext(routeLookupRequestKey);
+    assertThat(resp.hasData()).isTrue();
+    List<ChildPolicyWrapper> policyWrappers = new ArrayList<>();
+
+    for (int i = 1; i <= 3; i++) {
+      String target = "target" + i;
+      policyWrappers.add(resp.getChildPolicyWrapper(target));
+    }
+
+    // Set to states: null, READY, null
+    setState(policyWrappers.get(1), ConnectivityState.READY);
+    ChildPolicyWrapper childPolicy = resp.getChildPolicyWrapper();
+    assertSame(policyWrappers.get(0), childPolicy);
+
+    // Set to states: null, CONNECTING, null
+    setState(policyWrappers.get(1), ConnectivityState.CONNECTING);
+    childPolicy = resp.getChildPolicyWrapper();
+    assertSame(policyWrappers.get(0), childPolicy);
+
+    // Set to states: null, CONNECTING, READY
+    setState(policyWrappers.get(2), ConnectivityState.READY);
+    childPolicy = resp.getChildPolicyWrapper();
+    assertSame(policyWrappers.get(0), childPolicy);
+
+    // Set to states: READY, CONNECTING, READY
+    setState(policyWrappers.get(0), ConnectivityState.READY);
+    childPolicy = resp.getChildPolicyWrapper();
+    assertSame(policyWrappers.get(0), childPolicy);
+
+    // Set to states: TRANSIENT_FAILURE, CONNECTING, READY
+    setState(policyWrappers.get(0), ConnectivityState.TRANSIENT_FAILURE);
+    childPolicy = resp.getChildPolicyWrapper();
+    assertSame(policyWrappers.get(1), childPolicy);
+
+    // Set to states: TRANSIENT_FAILURE, TRANSIENT_FAILURE, TRANSIENT_FAILURE
+    setState(policyWrappers.get(1), ConnectivityState.TRANSIENT_FAILURE);
+    setState(policyWrappers.get(2), ConnectivityState.TRANSIENT_FAILURE);
+    childPolicy = resp.getChildPolicyWrapper();
+    assertSame(policyWrappers.get(0), childPolicy);
+
+    // Set to states: TRANSIENT_FAILURE, TRANSIENT_FAILURE, READY
+    setState(policyWrappers.get(2), ConnectivityState.READY);
+    childPolicy = resp.getChildPolicyWrapper();
+    assertSame(policyWrappers.get(2), childPolicy);
+  }
+
+  private void setState(ChildPolicyWrapper policyWrapper, ConnectivityState newState) {
+    policyWrapper.getHelper().updateBalancingState(newState, policyWrapper.getPicker());
+  }
+
+  @Test
+  public void metricGauges() throws ExecutionException, InterruptedException, TimeoutException {
+    setUpRlsLbClient();
+
+    verify(mockMetricRecorder).registerBatchCallback(gaugeBatchCallbackCaptor.capture(),
+        any());
+
+    BatchCallback gaugeBatchCallback = gaugeBatchCallbackCaptor.getValue();
+
+    // Verify the correct cache gauge values when requested at this point.
+    InOrder inOrder = inOrder(mockBatchRecorder);
+    gaugeBatchCallback.accept(mockBatchRecorder);
+    inOrder.verify(mockBatchRecorder).recordLongGauge(
+        argThat(new LongGaugeInstrumentArgumentMatcher("grpc.lb.rls.cache_entries")), eq(0L),
+        any(), any());
+    inOrder.verify(mockBatchRecorder)
+        .recordLongGauge(argThat(new LongGaugeInstrumentArgumentMatcher("grpc.lb.rls.cache_size")),
+            eq(0L), any(), any());
+
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        RlsProtoData.RouteLookupRequestKey.create(
+            ImmutableMap.of("server", "bigtable.googleapis.com", "service-key", "foo", "method-key",
+                "bar"));
+    rlsServerImpl.setLookupTable(ImmutableMap.of(routeLookupRequestKey,
+        RouteLookupResponse.create(ImmutableList.of("target"), "header")));
+
+    // Make a request that will populate the cache with an entry
+    getInSyncContext(routeLookupRequestKey);
+    fakeClock.forwardTime(SERVER_LATENCY_MILLIS, TimeUnit.MILLISECONDS);
+
+    // Gauge values should reflect the new cache entry.
+    gaugeBatchCallback.accept(mockBatchRecorder);
+    inOrder.verify(mockBatchRecorder).recordLongGauge(
+        argThat(new LongGaugeInstrumentArgumentMatcher("grpc.lb.rls.cache_entries")), eq(1L),
+        any(), any());
+    inOrder.verify(mockBatchRecorder)
+        .recordLongGauge(argThat(new LongGaugeInstrumentArgumentMatcher("grpc.lb.rls.cache_size")),
+            eq(260L), any(), any());
+
+    inOrder.verifyNoMoreInteractions();
+
+    // Shutdown
+    rlsLbClient.close();
+    rlsLbClient = null;
+    verify(mockGaugeRegistration).close();
+  }
+
+  private static RouteLookupConfig getRouteLookupConfig() {
+    return RouteLookupConfig.builder()
+        .grpcKeybuilders(ImmutableList.of(
+            GrpcKeyBuilder.create(
+                ImmutableList.of(Name.create("service1", "create")),
+                ImmutableList.of(
+                    NameMatcher.create("user", ImmutableList.of("User", "Parent")),
+                    NameMatcher.create("id", ImmutableList.of("X-Google-Id"))),
+                ExtraKeys.create("server", "service-key", "method-key"),
+                ImmutableMap.<String, String>of())))
+        .lookupService("service1")
+        .lookupServiceTimeoutInNanos(TimeUnit.SECONDS.toNanos(10))
+        .maxAgeInNanos(TimeUnit.SECONDS.toNanos(300))
+        .staleAgeInNanos(TimeUnit.SECONDS.toNanos(240))
+        .cacheSizeBytes(1000)
+        .defaultTarget(DEFAULT_TARGET)
+        .build();
+  }
+
+  private static BackoffPolicy createBackoffPolicy(final long delay, final TimeUnit unit) {
+    checkArgument(delay > 0, "delay should be positive");
+    checkNotNull(unit, "unit");
+    return
+        new BackoffPolicy() {
+          @Override
+          public long nextBackoffNanos() {
+            return TimeUnit.NANOSECONDS.convert(delay, unit);
+          }
+        };
+  }
+
+  private static class LongGaugeInstrumentArgumentMatcher implements
+      ArgumentMatcher<LongGaugeMetricInstrument> {
+
+    private final String instrumentName;
+
+    public LongGaugeInstrumentArgumentMatcher(String instrumentName) {
+      this.instrumentName = instrumentName;
+    }
+
+    @Override
+    public boolean matches(LongGaugeMetricInstrument instrument) {
+      return instrument.getName().equals(instrumentName);
+    }
+  }
+
+  private static final class FakeBackoffProvider implements BackoffPolicy.Provider {
+
+    private BackoffPolicy nextPolicy = createBackoffPolicy(100, TimeUnit.MILLISECONDS);
+
+    @Override
+    public BackoffPolicy get() {
+      return nextPolicy;
+    }
+  }
+
+  /**
+   * A load balancer that immediately goes to READY when using the rls response target and
+   * immediately fails when using the fallback target.
+   */
+  private static final class TestLoadBalancerProvider extends LoadBalancerProvider {
+    final Set<LoadBalancer> loadBalancers = new HashSet<>();
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 0;
+    }
+
+    @Override
+    public String getPolicyName() {
+      return null;
+    }
+
+    @Override
+    public ConfigOrError parseLoadBalancingPolicyConfig(
+        Map<String, ?> rawLoadBalancingPolicyConfig) {
+      return ConfigOrError.fromConfig(rawLoadBalancingPolicyConfig);
+    }
+
+    @Override
+    public LoadBalancer newLoadBalancer(final Helper helper) {
+      LoadBalancer loadBalancer = new LoadBalancer() {
+
+        @Override
+        public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+          Map<?, ?> config = (Map<?, ?>) resolvedAddresses.getLoadBalancingPolicyConfig();
+          if (DEFAULT_TARGET.equals(config.get("target"))) {
+            helper.updateBalancingState(
+                ConnectivityState.TRANSIENT_FAILURE,
+                new SubchannelPicker() {
+                  @Override
+                  public PickResult pickSubchannel(PickSubchannelArgs args) {
+                    return PickResult.withError(
+                            Status.UNAVAILABLE.withDescription("fallback not available"));
+                  }
+                });
+          } else {
+            helper.updateBalancingState(
+                ConnectivityState.READY,
+                new SubchannelPicker() {
+                  @Override
+                  public PickResult pickSubchannel(PickSubchannelArgs args) {
+                    return PickResult.withSubchannel(
+                        mock(Subchannel.class, config.get("target").toString()));
+                  }
+                });
+          }
+
+          return Status.OK;
+        }
+
+        @Override
+        public void handleNameResolutionError(final Status error) {
+          helper.updateBalancingState(
+              ConnectivityState.TRANSIENT_FAILURE,
+              new FixedResultPicker(PickResult.withError(error)));
+        }
+
+        @Override
+        public void shutdown() {
+          loadBalancers.remove(this);
+        }
+      };
+
+      loadBalancers.add(loadBalancer);
+      return loadBalancer;
+    }
+  }
+
+  private static final class StaticFixedDelayRlsServerImpl
+      extends RouteLookupServiceGrpc.RouteLookupServiceImplBase {
+
+    private static final Converter<io.grpc.lookup.v1.RouteLookupRequest, RouteLookupRequest>
+        REQUEST_CONVERTER = new RlsProtoConverters.RouteLookupRequestConverter();
+    private static final Converter<RouteLookupResponse, io.grpc.lookup.v1.RouteLookupResponse>
+        RESPONSE_CONVERTER = new RouteLookupResponseConverter().reverse();
+
+    private final long responseDelayNano;
+    private final ScheduledExecutorService scheduledExecutorService;
+
+    private Map<RlsProtoData.RouteLookupRequestKey, RouteLookupResponse> lookupTable =
+        ImmutableMap.of();
+    io.grpc.lookup.v1.RouteLookupRequest.Reason routeLookupReason;
+
+    public StaticFixedDelayRlsServerImpl(
+        long responseDelayNano, ScheduledExecutorService scheduledExecutorService) {
+      checkArgument(responseDelayNano > 0, "delay must be positive");
+      this.responseDelayNano = responseDelayNano;
+      this.scheduledExecutorService =
+          checkNotNull(scheduledExecutorService, "scheduledExecutorService");
+    }
+
+    private void setLookupTable(Map<RlsProtoData.RouteLookupRequestKey,
+        RouteLookupResponse> lookupTable) {
+      this.lookupTable = checkNotNull(lookupTable, "lookupTable");
+    }
+
+    @Override
+    public void routeLookup(final io.grpc.lookup.v1.RouteLookupRequest request,
+        final StreamObserver<io.grpc.lookup.v1.RouteLookupResponse> responseObserver) {
+      ScheduledFuture<?> unused =
+          scheduledExecutorService.schedule(
+              new Runnable() {
+                @Override
+                public void run() {
+                  routeLookupReason = request.getReason();
+                  RouteLookupResponse response =
+                      lookupTable.get(
+                          RlsProtoData.RouteLookupRequestKey.create(
+                              REQUEST_CONVERTER.convert(request).keyMap()));
+                  if (response == null) {
+                    responseObserver.onError(new RuntimeException("not found"));
+                  } else {
+                    responseObserver.onNext(RESPONSE_CONVERTER.convert(response));
+                    responseObserver.onCompleted();
+                  }
+                }
+              }, responseDelayNano, TimeUnit.NANOSECONDS);
+    }
+  }
+
+  private final class FakeHelper extends Helper {
+
+    Server server;
+    ManagedChannel oobChannel;
+
+    void createServerAndRegister(String target) throws IOException {
+      server = InProcessServerBuilder.forName(target)
+          .addService(rlsServerImpl)
+          .directExecutor()
+          .build()
+          .start();
+      grpcCleanupRule.register(server);
+    }
+
+    @Override
+    public ManagedChannelBuilder<?> createResolvingOobChannelBuilder(
+        String target, ChannelCredentials creds) {
+      try {
+        createServerAndRegister(target);
+      } catch (IOException e) {
+        throw new RuntimeException("cannot create server: " + target, e);
+      }
+      final InProcessChannelBuilder builder =
+          InProcessChannelBuilder.forName(target).directExecutor();
+
+      class CleaningChannelBuilder extends ForwardingChannelBuilder2<CleaningChannelBuilder> {
+
+        @Override
+        protected ManagedChannelBuilder<?> delegate() {
+          return builder;
+        }
+
+        @Override
+        public ManagedChannel build() {
+          oobChannel = super.build();
+          return grpcCleanupRule.register(oobChannel);
+        }
+
+        @Override
+        public CleaningChannelBuilder defaultServiceConfig(Map<String, ?> serviceConfig) {
+          rlsChannelServiceConfig = serviceConfig;
+          delegate().defaultServiceConfig(serviceConfig);
+          return this;
+        }
+
+        @Override
+        public CleaningChannelBuilder overrideAuthority(String authority) {
+          rlsChannelOverriddenAuthority = authority;
+          delegate().overrideAuthority(authority);
+          return this;
+        }
+      }
+
+      return new CleaningChannelBuilder();
+    }
+
+    @Override
+    public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String authority) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void updateBalancingState(
+        @Nonnull ConnectivityState newState, @Nonnull SubchannelPicker newPicker) {
+    }
+
+    @Override
+    public String getAuthority() {
+      return "bigtable.googleapis.com:443";
+    }
+
+    @Override
+    public ChannelCredentials getUnsafeChannelCredentials() {
+      // In test we don't do any authentication.
+      return new ChannelCredentials() {
+        @Override
+        public ChannelCredentials withoutBearerTokens() {
+          return this;
+        }
+      };
+    }
+
+    @Override
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return fakeClock.getScheduledExecutorService();
+    }
+
+    @Override
+    public SynchronizationContext getSynchronizationContext() {
+      return syncContext;
+    }
+
+    @Override
+    public ChannelLogger getChannelLogger() {
+      return mock(ChannelLogger.class);
+    }
+
+    @Override
+    public MetricRecorder getMetricRecorder() {
+      return mockMetricRecorder;
+    }
+
+    @Override
+    public String getChannelTarget() {
+      return "channelTarget";
+    }
+  }
+
+  private static final class FakeThrottler implements Throttler {
+    int numUnthrottled;
+    int numThrottled;
+
+    private boolean nextResult = false;
+
+    @Override
+    public boolean shouldThrottle() {
+      return nextResult;
+    }
+
+    @Override
+    public void registerBackendResponse(boolean throttled) {
+      if (throttled) {
+        numThrottled++;
+      } else {
+        numUnthrottled++;
+      }
+    }
+
+    public int getNumUnthrottled() {
+      return numUnthrottled;
+    }
+
+    public int getNumThrottled() {
+      return numThrottled;
+    }
+
+    public void resetCounts() {
+      numThrottled = 0;
+      numUnthrottled = 0;
+    }
+  }
+}
diff --git a/rls/src/test/java/io/grpc/rls/ChildLbResolvedAddressFactoryTest.java b/rls/src/test/java/io/grpc/rls/ChildLbResolvedAddressFactoryTest.java
new file mode 100644
index 00000000000..c6d296e1ce2
--- /dev/null
+++ b/rls/src/test/java/io/grpc/rls/ChildLbResolvedAddressFactoryTest.java
@@ -0,0 +1,57 @@
+/*
+ * 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.rls;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ChildLbResolvedAddressFactoryTest {
+
+  @Test
+  public void create() {
+    List<EquivalentAddressGroup> addrs = new ArrayList<>();
+    addrs.add(new EquivalentAddressGroup(mock(SocketAddress.class)));
+    Attributes attr = Attributes.newBuilder().build();
+    ChildLbResolvedAddressFactory factory = new ChildLbResolvedAddressFactory(addrs, attr);
+    Object config1 = new Object();
+    
+    ResolvedAddresses resolvedAddress = factory.create(config1);
+    
+    assertThat(resolvedAddress.getAddresses()).isEqualTo(addrs);
+    assertThat(resolvedAddress.getAttributes()).isEqualTo(attr);
+    assertThat(resolvedAddress.getLoadBalancingPolicyConfig()).isEqualTo(config1);
+
+    Object config2 = "different object";
+    
+    resolvedAddress = factory.create(config2);
+
+    assertThat(resolvedAddress.getAddresses()).isEqualTo(addrs);
+    assertThat(resolvedAddress.getAttributes()).isEqualTo(attr);
+    assertThat(resolvedAddress.getLoadBalancingPolicyConfig()).isEqualTo(config2);
+  }
+}
diff --git a/rls/src/test/java/io/grpc/rls/ChildLoadBalancerHelperTest.java b/rls/src/test/java/io/grpc/rls/ChildLoadBalancerHelperTest.java
new file mode 100644
index 00000000000..543540f498e
--- /dev/null
+++ b/rls/src/test/java/io/grpc/rls/ChildLoadBalancerHelperTest.java
@@ -0,0 +1,71 @@
+/*
+ * 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.rls;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.rls.ChildLoadBalancerHelper.ChildLoadBalancerHelperProvider;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.InOrder;
+import org.mockito.Mockito;
+
+@RunWith(JUnit4.class)
+public class ChildLoadBalancerHelperTest {
+
+  private final Helper helper = mock(Helper.class);
+  private final SubchannelStateManager subchannelStateManager = new SubchannelStateManagerImpl();
+  private final SubchannelPicker picker = mock(SubchannelPicker.class);
+  private final ChildLoadBalancerHelperProvider provider =
+      new ChildLoadBalancerHelperProvider(helper, subchannelStateManager, picker);
+
+  @Test
+  public void childLoadBalancerHelper_shouldReportsSubchannelState() {
+    InOrder inOrder = Mockito.inOrder(helper);
+    String target1 = "foo.com";
+    ChildLoadBalancerHelper childLbHelper1 = provider.forTarget(target1);
+    SubchannelPicker picker1 = mock(SubchannelPicker.class);
+    String target2 = "bar.com";
+    ChildLoadBalancerHelper childLbHelper2 = provider.forTarget(target2);
+    SubchannelPicker picker2 = mock(SubchannelPicker.class);
+
+    assertThat(subchannelStateManager.getState(target1)).isNull();
+    assertThat(subchannelStateManager.getState(target2)).isNull();
+
+    childLbHelper1.updateBalancingState(ConnectivityState.TRANSIENT_FAILURE, picker1);
+    inOrder.verify(helper).updateBalancingState(ConnectivityState.TRANSIENT_FAILURE, picker);
+    assertThat(subchannelStateManager.getState(target1))
+        .isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+
+    childLbHelper2.updateBalancingState(ConnectivityState.CONNECTING, picker2);
+    inOrder.verify(helper).updateBalancingState(ConnectivityState.TRANSIENT_FAILURE, picker);
+    assertThat(subchannelStateManager.getState(target2)).isEqualTo(ConnectivityState.CONNECTING);
+
+    childLbHelper1.updateBalancingState(ConnectivityState.READY, picker1);
+    inOrder.verify(helper).updateBalancingState(ConnectivityState.READY, picker);
+    assertThat(subchannelStateManager.getState(target1)).isEqualTo(ConnectivityState.READY);
+
+    childLbHelper1.updateBalancingState(ConnectivityState.SHUTDOWN, picker1);
+    inOrder.verify(helper).updateBalancingState(ConnectivityState.CONNECTING, picker);
+    assertThat(subchannelStateManager.getState(target1)).isNull();
+  }
+}
diff --git a/rls/src/test/java/io/grpc/rls/LbPolicyConfigurationTest.java b/rls/src/test/java/io/grpc/rls/LbPolicyConfigurationTest.java
new file mode 100644
index 00000000000..de41d0488fc
--- /dev/null
+++ b/rls/src/test/java/io/grpc/rls/LbPolicyConfigurationTest.java
@@ -0,0 +1,203 @@
+/*
+ * 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.rls;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.ChannelLogger;
+import io.grpc.ConnectivityState;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.rls.ChildLoadBalancerHelper.ChildLoadBalancerHelperProvider;
+import io.grpc.rls.LbPolicyConfiguration.ChildLoadBalancingPolicy;
+import io.grpc.rls.LbPolicyConfiguration.ChildPolicyWrapper;
+import io.grpc.rls.LbPolicyConfiguration.ChildPolicyWrapper.ChildPolicyReportingHelper;
+import io.grpc.rls.LbPolicyConfiguration.InvalidChildPolicyConfigException;
+import io.grpc.rls.LbPolicyConfiguration.RefCountedChildPolicyWrapperFactory;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentMatchers;
+
+@RunWith(JUnit4.class)
+public class LbPolicyConfigurationTest {
+
+  private final Helper helper = mock(Helper.class);
+  private final LoadBalancerProvider lbProvider = mock(LoadBalancerProvider.class);
+  private final LoadBalancer lb = mock(LoadBalancer.class);
+  private final SubchannelStateManager subchannelStateManager = new SubchannelStateManagerImpl();
+  private final SubchannelPicker picker = mock(SubchannelPicker.class);
+  private final SynchronizationContext syncContext = new SynchronizationContext((t, e) -> {
+    throw new AssertionError(e);
+  });
+  private final ResolvedAddressFactory resolvedAddressFactory =
+      new ResolvedAddressFactory() {
+        @Override
+        public ResolvedAddresses create(Object childLbConfig) {
+          return ResolvedAddresses.newBuilder()
+              .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+              .build();
+        }
+      };
+  private final RefCountedChildPolicyWrapperFactory factory =
+      new RefCountedChildPolicyWrapperFactory(
+          new ChildLoadBalancingPolicy(
+              "targetFieldName",
+              ImmutableMap.<String, Object>of("foo", "bar"),
+              lbProvider),
+          resolvedAddressFactory,
+          new ChildLoadBalancerHelperProvider(helper, subchannelStateManager, picker));
+
+  @Before
+  public void setUp() {
+    doReturn(mock(ChannelLogger.class)).when(helper).getChannelLogger();
+    doReturn(syncContext).when(helper).getSynchronizationContext();
+    doReturn(lb).when(lbProvider).newLoadBalancer(any(Helper.class));
+    doReturn(ConfigOrError.fromConfig(new Object()))
+        .when(lbProvider).parseLoadBalancingPolicyConfig(ArgumentMatchers.<Map<String, ?>>any());
+    doReturn(Status.OK).when(lb).acceptResolvedAddresses(any(ResolvedAddresses.class));
+  }
+
+  @Test
+  public void childPolicyWrapper_refCounted() {
+    String target = "target";
+    ChildPolicyWrapper childPolicy = factory.createOrGet(target);
+    assertThat(factory.childPolicyMap.keySet()).containsExactly(target);
+
+    ChildPolicyWrapper childPolicy2 = factory.createOrGet(target);
+    assertThat(factory.childPolicyMap.keySet()).containsExactly(target);
+    assertThat(childPolicy2).isEqualTo(childPolicy);
+
+    factory.release(childPolicy2);
+    assertThat(factory.childPolicyMap.keySet()).containsExactly(target);
+
+    factory.release(childPolicy);
+    assertThat(factory.childPolicyMap).isEmpty();
+
+    try {
+      factory.release(childPolicy);
+      fail("should not be able to access already released policy");
+    } catch (IllegalStateException e) {
+      assertThat(e).hasMessageThat().contains("already released");
+    }
+  }
+
+  @Test
+  public void childPolicyWrapper_addressesRejected() {
+    when(lb.acceptResolvedAddresses(any(ResolvedAddresses.class))).thenReturn(Status.UNAVAILABLE);
+    factory.createOrGet("target");
+    verify(helper).refreshNameResolution();
+  }
+
+  @Test
+  public void childLoadBalancingPolicy_effectiveChildPolicy() {
+    LoadBalancerProvider mockProvider = mock(LoadBalancerProvider.class);
+    ChildLoadBalancingPolicy childLbPolicy =
+        new ChildLoadBalancingPolicy(
+            "targetFieldName",
+            ImmutableMap.<String, Object>of("foo", "bar"),
+            mockProvider);
+
+    assertThat(childLbPolicy.getEffectiveChildPolicy("target"))
+        .containsExactly("foo", "bar", "targetFieldName", "target");
+    assertThat(childLbPolicy.getEffectiveLbProvider()).isEqualTo(mockProvider);
+  }
+
+  @Test
+  public void childLoadBalancingPolicy_noPolicyProvided() {
+    LoadBalancerProvider mockProvider = mock(LoadBalancerProvider.class);
+    when(mockProvider.getPolicyName()).thenReturn("rls");
+    when(mockProvider.isAvailable()).thenReturn(true);
+
+    LoadBalancerRegistry.getDefaultRegistry().register(mockProvider);
+    try {
+      ChildLoadBalancingPolicy.create(
+          "targetFieldName",
+          ImmutableList.<Map<String, ?>>of(
+              ImmutableMap.<String, Object>of(
+                  "rls", ImmutableMap.of(), "rls2", ImmutableMap.of())));
+      fail("parsing exception expected");
+    } catch (InvalidChildPolicyConfigException e) {
+      assertThat(e).hasMessageThat()
+          .contains("childPolicy should have exactly one loadbalancing policy");
+    } finally {
+      LoadBalancerRegistry.getDefaultRegistry().deregister(mockProvider);
+    }
+  }
+
+  @Test
+  public void childLoadBalancingPolicy_tooManyChildPolicies() {
+    try {
+      ChildLoadBalancingPolicy
+          .create("targetFieldName", ImmutableList.<Map<String, ?>>of());
+      fail("parsing exception expected");
+    } catch (InvalidChildPolicyConfigException e) {
+      assertThat(e).hasMessageThat().contains("no valid childPolicy found");
+    }
+  }
+
+  @Test
+  public void updateBalancingState_triggersListener() {
+    ChildPolicyWrapper childPolicyWrapper = factory.createOrGet("foo.google.com");
+    ChildPolicyReportingHelper childPolicyReportingHelper = childPolicyWrapper.getHelper();
+    SubchannelPicker childPicker = mock(SubchannelPicker.class);
+
+    childPolicyReportingHelper.updateBalancingState(ConnectivityState.READY, childPicker);
+
+    assertThat(childPolicyWrapper.getPicker()).isEqualTo(childPicker);
+    // picker governs childPickers will be reported to parent LB
+    verify(helper).updateBalancingState(ConnectivityState.READY, picker);
+  }
+
+  @Test
+  public void refCountedGetOrCreate_addsChildBeforeConfiguringChild() {
+    AtomicBoolean calledAlready = new AtomicBoolean();
+    when(lb.acceptResolvedAddresses(any(ResolvedAddresses.class))).thenAnswer(i -> {
+      if (!calledAlready.get()) {
+        calledAlready.set(true);
+        // Should end up calling this function again, as this child should already be added to the
+        // list of children. In practice, this can be caused by CDS is_dynamic=true starting a watch
+        // when XdsClient already has the cluster cached (e.g., from another channel).
+        syncContext.execute(() ->
+            factory.acceptResolvedAddressFactory(resolvedAddressFactory));
+      }
+      return Status.OK;
+    });
+    ChildPolicyWrapper unused = factory.createOrGet("foo.google.com");
+    verify(lb, times(2)).acceptResolvedAddresses(any(ResolvedAddresses.class));
+  }
+}
diff --git a/rls/src/test/java/io/grpc/rls/LinkedHashLruCacheTest.java b/rls/src/test/java/io/grpc/rls/LinkedHashLruCacheTest.java
new file mode 100644
index 00000000000..23ffe6ec026
--- /dev/null
+++ b/rls/src/test/java/io/grpc/rls/LinkedHashLruCacheTest.java
@@ -0,0 +1,358 @@
+/*
+ * 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.rls;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.base.Ticker;
+import io.grpc.internal.FakeClock;
+import io.grpc.rls.LruCache.EvictionListener;
+import io.grpc.rls.LruCache.EvictionType;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class LinkedHashLruCacheTest {
+
+  private static final int MAX_SIZE = 5;
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private final FakeClock fakeClock = new FakeClock();
+  private final Ticker ticker = fakeClock.getTicker();
+
+  @Mock
+  private EvictionListener<Integer, Entry> evictionListener;
+  private LinkedHashLruCache<Integer, Entry> cache;
+
+  @Before
+  public void setUp() {
+    this.cache = new LinkedHashLruCache<Integer, Entry>(
+        MAX_SIZE,
+        evictionListener,
+        fakeClock.getTicker()) {
+      @Override
+      protected boolean isExpired(Integer key, Entry value, long nowNanos) {
+        return value.expireTime - nowNanos <= 0;
+      }
+
+      @Override
+      protected int estimateSizeOf(Integer key, Entry value) {
+        return value.size;
+      }
+    };
+  }
+
+  @Test
+  public void eviction_size() {
+    for (int i = 1; i <= MAX_SIZE; i++) {
+      cache.cache(i, new Entry("Entry" + i, Long.MAX_VALUE));
+    }
+    cache.cache(MAX_SIZE + 1, new Entry("should kick the first", Long.MAX_VALUE));
+
+    verify(evictionListener).onEviction(1, new Entry("Entry1", Long.MAX_VALUE), EvictionType.SIZE);
+    assertThat(cache.estimatedSize()).isEqualTo(MAX_SIZE);
+  }
+
+  @Test
+  public void size() {
+    Entry entry1 = new Entry("Entry0", ticker.read() + 10);
+    Entry entry2 = new Entry("Entry1", ticker.read() + 20);
+    cache.cache(0, entry1);
+    cache.cache(1, entry2);
+    assertThat(cache.estimatedSize()).isEqualTo(2);
+
+    assertThat(cache.invalidate(0)).isEqualTo(entry1);
+    assertThat(cache.estimatedSize()).isEqualTo(1);
+
+    assertThat(cache.invalidate(1)).isEqualTo(entry2);
+    assertThat(cache.estimatedSize()).isEqualTo(0);
+  }
+
+  @Test
+  public void eviction_expire() {
+    Entry toBeEvicted = new Entry("Entry0", ticker.read() + 10);
+    Entry survivor = new Entry("Entry1", ticker.read() + 20);
+    cache.cache(0, toBeEvicted);
+    cache.cache(1, survivor);
+
+    fakeClock.forwardTime(10, TimeUnit.NANOSECONDS);
+    cache.cleanupExpiredEntries();
+    verify(evictionListener).onEviction(0, toBeEvicted, EvictionType.EXPIRED);
+
+    fakeClock.forwardTime(10, TimeUnit.NANOSECONDS);
+    cache.cleanupExpiredEntries();
+    verify(evictionListener).onEviction(1, survivor, EvictionType.EXPIRED);
+  }
+
+  @Test
+  public void eviction_explicit() {
+    Entry toBeEvicted = new Entry("Entry0", ticker.read() + 10);
+    Entry survivor = new Entry("Entry1", ticker.read() + 20);
+    cache.cache(0, toBeEvicted);
+    cache.cache(1, survivor);
+
+    assertThat(cache.invalidate(0)).isEqualTo(toBeEvicted);
+
+    verify(evictionListener).onEviction(0, toBeEvicted, EvictionType.EXPLICIT);
+  }
+
+  @Test
+  public void eviction_replaced() {
+    Entry toBeEvicted = new Entry("Entry0", ticker.read() + 10);
+    Entry survivor = new Entry("Entry1", ticker.read() + 20);
+    cache.cache(0, toBeEvicted);
+    cache.cache(0, survivor);
+
+    verify(evictionListener).onEviction(0, toBeEvicted, EvictionType.REPLACED);
+  }
+
+  @Test
+  public void eviction_size_shouldEvictAlreadyExpired() {
+    for (int i = 1; i <= MAX_SIZE; i++) {
+      // last two entries are <= current time (already expired)
+      cache.cache(i, new Entry("Entry" + i, ticker.read() + MAX_SIZE - i - 1));
+    }
+    cache.cache(MAX_SIZE + 1, new Entry("should kick the first", Long.MAX_VALUE));
+
+    // should remove MAX_SIZE-1 instead of MAX_SIZE because MAX_SIZE is accessed later
+    verify(evictionListener)
+        .onEviction(eq(MAX_SIZE - 1), any(Entry.class), eq(EvictionType.EXPIRED));
+    assertThat(cache.estimatedSize()).isEqualTo(MAX_SIZE);
+  }
+
+  @Test
+  public void eviction_cleanupShouldRemoveAlreadyExpired() {
+    for (int i = 1; i <= MAX_SIZE; i++) {
+      // last entry is already expired when added
+      cache.cache(i, new Entry("Entry" + i,
+          ticker.read() + ((MAX_SIZE - i) * TimeUnit.MINUTES.toNanos(1)) + 1));
+    }
+
+    assertThat(cache.estimatedSize()).isEqualTo(MAX_SIZE);
+
+    fakeClock.forwardTime(1, TimeUnit.MINUTES);
+    cache.cleanupExpiredEntries();
+    assertThat(cache.read(MAX_SIZE)).isNull();
+    assertThat(cache.estimatedSize()).isEqualTo(MAX_SIZE - 1);
+    verify(evictionListener).onEviction(eq(MAX_SIZE), any(Entry.class), eq(EvictionType.EXPIRED));
+  }
+
+  @Test
+  public void updateEntrySize() {
+    Entry entry = new Entry("Entry", ticker.read() + 10);
+
+    cache.cache(1, entry);
+
+    assertThat(cache.estimatedSizeBytes()).isEqualTo(1);
+    entry.size = 10;
+    assertThat(cache.estimatedSizeBytes()).isEqualTo(1);
+
+    cache.updateEntrySize(1);
+
+    assertThat(cache.estimatedSizeBytes()).isEqualTo(10);
+
+    cache.updateEntrySize(1);
+
+    assertThat(cache.estimatedSizeBytes()).isEqualTo(10);
+  }
+
+  @Test
+  public void updateEntrySize_multipleEntries() {
+    Entry entry1 = new Entry("Entry", ticker.read() + 10, 2);
+    Entry entry2 = new Entry("Entry2", ticker.read() + 10, 3);
+
+    cache.cache(1, entry1);
+    cache.cache(2, entry2);
+
+    assertThat(cache.estimatedSizeBytes()).isEqualTo(5);
+    entry2.size = 1;
+    assertThat(cache.estimatedSizeBytes()).isEqualTo(5);
+
+    cache.updateEntrySize(2);
+
+    assertThat(cache.estimatedSizeBytes()).isEqualTo(3);
+  }
+
+  @Test
+  public void invalidateAll() {
+    Entry entry1 = new Entry("Entry", ticker.read() + 10);
+    Entry entry2 = new Entry("Entry2", ticker.read() + 10);
+
+    cache.cache(1, entry1);
+    cache.cache(2, entry2);
+
+    assertThat(cache.estimatedSize()).isEqualTo(2);
+
+    cache.invalidateAll();
+
+    assertThat(cache.estimatedSize()).isEqualTo(0);
+  }
+
+  @Test
+  public void resize() {
+    Entry entry1 = new Entry("Entry", ticker.read() + 10);
+    Entry entry2 = new Entry("Entry2", ticker.read() + 10);
+    Entry entry3 = new Entry("Entry3", ticker.read() + 10);
+
+    cache.cache(1, entry1);
+    cache.cache(2, entry2);
+    cache.cache(3, entry3);
+
+    assertThat(cache.estimatedSize()).isEqualTo(3);
+
+    cache.resize(2);
+
+    assertThat(cache.estimatedSize()).isEqualTo(2);
+    // eldest entry should be evicted
+    assertThat(cache.hasCacheEntry(1)).isFalse();
+  }
+
+  private static final class Entry {
+    String value;
+    long expireTime;
+    int size;
+
+    Entry(String value, long expireTime) {
+      this(value, expireTime, 1);
+    }
+
+    Entry(String value, long expireTime, int size) {
+      this.value = value;
+      this.expireTime = expireTime;
+      this.size = size;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      Entry entry = (Entry) o;
+      return expireTime == entry.expireTime && Objects.equals(value, entry.value);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(value, expireTime);
+    }
+  }
+
+  @Test
+  public void testFitToLimitWithReSize() {
+
+    Entry entry1 = new Entry("Entry1", ticker.read() + 10, 4);
+    Entry entry2 = new Entry("Entry2", ticker.read() + 20, 1);
+    Entry entry3 = new Entry("Entry3", ticker.read() + 30, 2);
+
+    cache.cache(1, entry1);
+    cache.cache(2, entry2);
+    cache.cache(3, entry3);
+
+    assertThat(cache.estimatedSize()).isEqualTo(2);
+    assertThat(cache.estimatedSizeBytes()).isEqualTo(3);
+    assertThat(cache.estimatedMaxSizeBytes()).isEqualTo(5);
+
+    cache.resize(2);
+    assertThat(cache.estimatedSize()).isEqualTo(1);
+    assertThat(cache.estimatedSizeBytes()).isEqualTo(2);
+    assertThat(cache.estimatedMaxSizeBytes()).isEqualTo(2);
+
+    assertThat(cache.fitToLimit()).isEqualTo(false);
+  }
+
+  @Test
+  public void testFitToLimit() {
+
+    TestFitToLimitEviction localCache = new TestFitToLimitEviction(
+            MAX_SIZE,
+            evictionListener,
+            fakeClock.getTicker()
+    );
+
+    Entry entry1 = new Entry("Entry1", ticker.read() + 10, 4);
+    Entry entry2 = new Entry("Entry2", ticker.read() + 20, 2);
+    Entry entry3 = new Entry("Entry3", ticker.read() + 30, 1);
+
+    localCache.cache(1, entry1);
+    localCache.cache(2, entry2);
+    localCache.cache(3, entry3);
+
+    assertThat(localCache.estimatedSize()).isEqualTo(3);
+    assertThat(localCache.estimatedSizeBytes()).isEqualTo(7);
+    assertThat(localCache.estimatedMaxSizeBytes()).isEqualTo(5);
+
+    localCache.enableEviction();
+
+    assertThat(localCache.fitToLimit()).isEqualTo(true);
+
+    assertThat(localCache.values().contains(entry1)).isFalse();
+    assertThat(localCache.values().containsAll(Arrays.asList(entry2, entry3))).isTrue();
+
+    assertThat(localCache.estimatedSize()).isEqualTo(2);
+    assertThat(localCache.estimatedSizeBytes()).isEqualTo(3);
+    assertThat(localCache.estimatedMaxSizeBytes()).isEqualTo(5);
+  }
+
+  private static class TestFitToLimitEviction extends LinkedHashLruCache<Integer, Entry> {
+
+    private boolean allowEviction = false;
+
+    TestFitToLimitEviction(
+            long estimatedMaxSizeBytes,
+            @Nullable EvictionListener<Integer, Entry> evictionListener,
+            Ticker ticker) {
+      super(estimatedMaxSizeBytes, evictionListener, ticker);
+    }
+
+    @Override
+    protected boolean isExpired(Integer key, Entry value, long nowNanos) {
+      return value.expireTime - nowNanos <= 0;
+    }
+
+    @Override
+    protected int estimateSizeOf(Integer key, Entry value) {
+      return value.size;
+    }
+
+    @Override
+    protected boolean shouldInvalidateEldestEntry(Integer eldestKey, Entry eldestValue, long now) {
+      return allowEviction && super.shouldInvalidateEldestEntry(eldestKey, eldestValue, now);
+    }
+
+    public void enableEviction() {
+      allowEviction = true;
+    }
+  }
+}
diff --git a/rls/src/test/java/io/grpc/rls/RlsLoadBalancerTest.java b/rls/src/test/java/io/grpc/rls/RlsLoadBalancerTest.java
new file mode 100644
index 00000000000..188c99bcd5a
--- /dev/null
+++ b/rls/src/test/java/io/grpc/rls/RlsLoadBalancerTest.java
@@ -0,0 +1,931 @@
+/*
+ * 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.rls;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Converter;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.ForwardingChannelBuilder2;
+import io.grpc.InternalManagedChannelBuilder;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickDetailsConsumer;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.MetricInstrument;
+import io.grpc.MetricRecorder;
+import io.grpc.MetricRecorder.Registration;
+import io.grpc.MetricSink;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.NoopMetricSink;
+import io.grpc.ServerCall;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.JsonParser;
+import io.grpc.internal.PickSubchannelArgsImpl;
+import io.grpc.internal.testing.StreamRecorder;
+import io.grpc.lookup.v1.RouteLookupServiceGrpc;
+import io.grpc.rls.RlsLoadBalancer.CachingRlsLbClientBuilderProvider;
+import io.grpc.rls.RlsProtoConverters.RouteLookupResponseConverter;
+import io.grpc.rls.RlsProtoData.RouteLookupRequest;
+import io.grpc.rls.RlsProtoData.RouteLookupResponse;
+import io.grpc.stub.ClientCalls;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.TestMethodDescriptors;
+import java.io.IOException;
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.net.SocketAddress;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nonnull;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.AdditionalAnswers;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class RlsLoadBalancerTest {
+
+  @Rule
+  public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  private final RlsLoadBalancerProvider provider = new RlsLoadBalancerProvider();
+  private final FakeClock fakeClock = new FakeClock();
+  private final SynchronizationContext syncContext =
+      new SynchronizationContext(new UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new RuntimeException(e);
+        }
+      });
+  @Mock
+  private MetricRecorder mockMetricRecorder;
+  @Mock
+  private Registration mockGaugeRegistration;
+  private final FakeHelper helperDelegate = new FakeHelper();
+  private final Helper helper =
+      mock(Helper.class, AdditionalAnswers.delegatesTo(helperDelegate));
+  private final FakeRlsServerImpl fakeRlsServerImpl = new FakeRlsServerImpl(
+      fakeClock.getScheduledExecutorService());
+  private final Deque<FakeSubchannel> subchannels = new LinkedList<>();
+  private final FakeThrottler fakeThrottler = new FakeThrottler();
+  private final String channelTarget = "channelTarget";
+  @Captor
+  private ArgumentCaptor<SubchannelPicker> pickerCaptor;
+  private MethodDescriptor<Void, Void> fakeSearchMethod;
+  private MethodDescriptor<Void, Void> fakeRescueMethod;
+  private RlsLoadBalancer rlsLb;
+  private String defaultTarget = "defaultTarget";
+  private PickSubchannelArgs searchSubchannelArgs;
+  private PickSubchannelArgs rescueSubchannelArgs;
+
+  @Before
+  public void setUp() {
+    fakeSearchMethod =
+        MethodDescriptor.<Void, Void>newBuilder()
+            .setFullMethodName("com.google/Search")
+            .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+            .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
+            .setType(MethodType.CLIENT_STREAMING)
+            .build();
+    fakeRescueMethod =
+        MethodDescriptor.<Void, Void>newBuilder()
+            .setFullMethodName("com.google/Rescue")
+            .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+            .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
+            .setType(MethodType.UNARY)
+            .build();
+    fakeRlsServerImpl.setLookupTable(
+        ImmutableMap.of(
+            RouteLookupRequest.create(
+                ImmutableMap.of(
+                "server", "fake-bigtable.googleapis.com",
+                "service-key", "com.google",
+                "method-key", "Search"),
+                RouteLookupRequest.Reason.REASON_MISS),
+            RouteLookupResponse.create(ImmutableList.of("wilderness"), "where are you?"),
+            RouteLookupRequest.create(
+                ImmutableMap.of(
+                "server", "fake-bigtable.googleapis.com",
+                "service-key", "com.google",
+                "method-key", "Rescue"),
+                RouteLookupRequest.Reason.REASON_MISS),
+            RouteLookupResponse.create(ImmutableList.of("civilization"), "you are safe")));
+
+    rlsLb = (RlsLoadBalancer) provider.newLoadBalancer(helper);
+    rlsLb.cachingRlsLbClientBuilderProvider = new CachingRlsLbClientBuilderProvider() {
+      @Override
+      public CachingRlsLbClient.Builder get() {
+        // using fake throttler to allow enablement of throttler
+        return CachingRlsLbClient.newBuilder()
+            .setThrottler(fakeThrottler)
+            .setTicker(fakeClock.getTicker());
+      }
+    };
+
+    searchSubchannelArgs = newPickSubchannelArgs(fakeSearchMethod);
+    rescueSubchannelArgs = newPickSubchannelArgs(fakeRescueMethod);
+
+    when(mockMetricRecorder.registerBatchCallback(any(), any())).thenReturn(mockGaugeRegistration);
+  }
+
+  @After
+  public void tearDown() {
+    rlsLb.shutdown();
+  }
+
+  @Test
+  public void lb_serverStatusCodeConversion() throws Exception {
+    helper.getSynchronizationContext().execute(() -> {
+      try {
+        deliverResolvedAddresses();
+      } catch (Exception e) {
+        throw new RuntimeException(e);
+      }
+    });
+    assertThat(subchannels.poll()).isNotNull(); // default target
+    assertThat(subchannels.poll()).isNull();
+    // Warm-up pick; will be queued
+    InOrder inOrder = inOrder(helper);
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    PickSubchannelArgs fakeSearchMethodArgs = newPickSubchannelArgs(fakeSearchMethod);
+    PickResult res = picker.pickSubchannel(fakeSearchMethodArgs);
+    assertThat(res.getStatus().isOk()).isTrue();
+    assertThat(res.getSubchannel()).isNull();
+    // Cache is warm, but still unconnected
+    picker.pickSubchannel(fakeSearchMethodArgs); // Will create the subchannel
+    FakeSubchannel subchannel = subchannels.peek();
+    assertThat(subchannel).isNotNull();
+
+    // Ensure happy path is unaffected
+    subchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    res = picker.pickSubchannel(fakeSearchMethodArgs);
+    assertThat(res.getStatus().getCode()).isEqualTo(Status.Code.OK);
+    verifyLongCounterAdd("grpc.lb.rls.target_picks", 1, 1, "wilderness", "complete");
+
+    // Check on conversion
+    Throwable cause = new Throwable("cause");
+    Status aborted = Status.ABORTED.withCause(cause).withDescription("base desc");
+    Status serverStatus = CachingRlsLbClient.convertRlsServerStatus(aborted, "conv.test");
+    assertThat(serverStatus.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(serverStatus.getCause()).isEqualTo(cause);
+    assertThat(serverStatus.getDescription()).contains("RLS server returned: ");
+    assertThat(serverStatus.getDescription()).endsWith("ABORTED: base desc");
+    assertThat(serverStatus.getDescription()).contains("RLS server conv.test");
+  }
+
+  @Test
+  public void lb_working_withDefaultTarget_rlsResponding() throws Exception {
+    helper.getSynchronizationContext().execute(() -> {
+      try {
+        deliverResolvedAddresses();
+      } catch (Exception e) {
+        throw new RuntimeException(e);
+      }
+    });
+    InOrder inOrder = inOrder(helper);
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    // Warm-up pick; will be queued
+    PickResult res = picker.pickSubchannel(searchSubchannelArgs);
+    assertThat(res.getStatus().isOk()).isTrue();
+    assertThat(res.getSubchannel()).isNull();
+    // Cache is warm, but still unconnected
+    res = picker.pickSubchannel(searchSubchannelArgs);
+    inOrder.verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
+    inOrder.verify(helper, atLeast(0))
+        .updateBalancingState(eq(ConnectivityState.CONNECTING), any(SubchannelPicker.class));
+    inOrder.verify(helper, atLeast(0)).getSynchronizationContext();
+    inOrder.verify(helper, atLeast(0)).getScheduledExecutorService();
+    inOrder.verify(helper, atLeast(0)).getMetricRecorder();
+    inOrder.verify(helper, atLeast(0)).getChannelTarget();
+    inOrder.verifyNoMoreInteractions();
+
+    assertThat(res.getStatus().isOk()).isTrue();
+    assertThat(subchannels).hasSize(2); // includes fallback sub-channel
+    FakeSubchannel searchSubchannel = subchannels.getLast();
+    assertThat(subchannelIsReady(searchSubchannel)).isFalse();
+
+    searchSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
+    inOrder.verifyNoMoreInteractions();
+    res = picker.pickSubchannel(searchSubchannelArgs);
+    assertThat(subchannelIsReady(res.getSubchannel())).isTrue();
+    assertThat(res.getSubchannel()).isSameInstanceAs(searchSubchannel);
+    verifyLongCounterAdd("grpc.lb.rls.target_picks", 1, 1, "wilderness", "complete");
+
+    // rescue should be pending status although the overall channel state is READY
+    res = picker.pickSubchannel(rescueSubchannelArgs);
+    inOrder.verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
+    // other rls picker itself is ready due to first channel.
+    assertThat(res.getStatus().isOk()).isTrue();
+    assertThat(subchannelIsReady(res.getSubchannel())).isFalse();
+    assertThat(subchannels).hasSize(3); // includes fallback sub-channel
+    FakeSubchannel rescueSubchannel = subchannels.getLast();
+
+    // search subchannel is down, rescue subchannel is connecting
+    searchSubchannel.updateState(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
+
+    rescueSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
+
+    // search again, verify that it doesn't use fallback, since RLS server responded, even though
+    // subchannel is in failure mode
+    res = picker.pickSubchannel(searchSubchannelArgs);
+    assertThat(res.getStatus().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(subchannelIsReady(res.getSubchannel())).isFalse();
+    verifyLongCounterAdd("grpc.lb.rls.target_picks", 1, 1, "wilderness", "fail");
+  }
+
+  @Test
+  public void fallbackWithDelay_succeeds() throws Exception {
+    fakeRlsServerImpl.setResponseDelay(100, TimeUnit.MILLISECONDS);
+    grpcCleanupRule.register(
+        InProcessServerBuilder.forName("fake-bigtable.googleapis.com")
+        .addService(ServerServiceDefinition.builder("com.google")
+          .addMethod(fakeSearchMethod, (call, headers) -> {
+            call.sendHeaders(new Metadata());
+            call.sendMessage(null);
+            call.close(Status.OK, new Metadata());
+            return new ServerCall.Listener<Void>() {};
+          })
+          .build())
+        .addService(fakeRlsServerImpl)
+        .directExecutor()
+        .build()
+        .start());
+    ManagedChannel channel = grpcCleanupRule.register(
+        InProcessChannelBuilder.forName("fake-bigtable.googleapis.com")
+        .defaultServiceConfig(parseJson(getServiceConfigJsonStr()))
+        .directExecutor()
+        .build());
+
+    StreamRecorder<Void> recorder = StreamRecorder.create();
+    StreamObserver<Void> requestObserver = ClientCalls.asyncClientStreamingCall(
+        channel.newCall(fakeSearchMethod, CallOptions.DEFAULT), recorder);
+    requestObserver.onCompleted();
+    fakeClock.forwardTime(100, TimeUnit.MILLISECONDS);
+    assertThat(recorder.awaitCompletion(10, TimeUnit.SECONDS)).isTrue();
+    assertThat(recorder.getError()).isNull();
+  }
+
+  @Test
+  public void metricsWithRealChannel() throws Exception {
+    grpcCleanupRule.register(
+        InProcessServerBuilder.forName("fake-bigtable.googleapis.com")
+        .addService(ServerServiceDefinition.builder("com.google")
+          .addMethod(fakeSearchMethod, (call, headers) -> {
+            call.sendHeaders(new Metadata());
+            call.sendMessage(null);
+            call.close(Status.OK, new Metadata());
+            return new ServerCall.Listener<Void>() {};
+          })
+          .build())
+        .addService(fakeRlsServerImpl)
+        .directExecutor()
+        .build()
+        .start());
+    MetricSink metrics = mock(MetricSink.class, delegatesTo(new NoopMetricSink()));
+    ManagedChannel channel = grpcCleanupRule.register(
+        InternalManagedChannelBuilder.addMetricSink(
+            InProcessChannelBuilder.forName("fake-bigtable.googleapis.com")
+            .defaultServiceConfig(parseJson(getServiceConfigJsonStr()))
+            .directExecutor(),
+        metrics)
+        .build());
+
+    StreamRecorder<Void> recorder = StreamRecorder.create();
+    StreamObserver<Void> requestObserver = ClientCalls.asyncClientStreamingCall(
+        channel.newCall(fakeSearchMethod, CallOptions.DEFAULT), recorder);
+    requestObserver.onCompleted();
+    assertThat(recorder.awaitCompletion(10, TimeUnit.SECONDS)).isTrue();
+    assertThat(recorder.getError()).isNull();
+
+    verify(metrics).addLongCounter(
+        eqMetricInstrumentName("grpc.lb.rls.default_target_picks"),
+        eq(1L),
+        eq(Arrays.asList("directaddress:///fake-bigtable.googleapis.com", "localhost:8972",
+            "defaultTarget", "complete")),
+        eq(Arrays.asList()));
+  }
+
+  @Test
+  public void lb_working_withoutDefaultTarget_noRlsResponse() throws Exception {
+    defaultTarget = "";
+    fakeThrottler.nextResult = true;
+
+    deliverResolvedAddresses();
+    InOrder inOrder = inOrder(helper);
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+
+    // With no RLS response and no fallback, we should see a failure
+    PickResult res = picker.pickSubchannel(searchSubchannelArgs); // create subchannel
+    assertThat(res.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    inOrder.verify(helper).getMetricRecorder();
+    inOrder.verify(helper).getChannelTarget();
+    inOrder.verifyNoMoreInteractions();
+    verifyFailedPicksCounterAdd(1, 1);
+  }
+
+  @Test
+  public void lb_working_withDefaultTarget_noRlsResponse() throws Exception {
+    fakeThrottler.nextResult = true;
+
+    helper.getSynchronizationContext().execute(() -> {
+      try {
+        deliverResolvedAddresses();
+      } catch (Exception e) {
+        throw new RuntimeException(e);
+      }
+    });
+    InOrder inOrder = inOrder(helper);
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+
+    // Search that when the RLS server doesn't respond, that fallback is used
+    PickResult res = picker.pickSubchannel(searchSubchannelArgs); // create subchannel
+    assertThat(res.getStatus().getCode()).isEqualTo(Status.Code.OK);
+    FakeSubchannel fallbackSubchannel =
+        (FakeSubchannel) markReadyAndGetPickResult(inOrder, searchSubchannelArgs).getSubchannel();
+    assertThat(fallbackSubchannel).isNotNull();
+    assertThat(subchannelIsReady(fallbackSubchannel)).isTrue();
+    inOrder.verify(helper).getMetricRecorder();
+    inOrder.verify(helper).getChannelTarget();
+    inOrder.verifyNoMoreInteractions();
+    int times = 1;
+    verifyLongCounterAdd("grpc.lb.rls.default_target_picks", times, 1,
+        "defaultTarget", "complete");
+
+    Subchannel subchannel = picker.pickSubchannel(searchSubchannelArgs).getSubchannel();
+    assertThat(subchannelIsReady(subchannel)).isTrue();
+    assertThat(subchannel).isSameInstanceAs(fallbackSubchannel);
+    verifyLongCounterAdd("grpc.lb.rls.default_target_picks", ++times, 1, "defaultTarget",
+        "complete");
+
+    subchannel = picker.pickSubchannel(searchSubchannelArgs).getSubchannel();
+    assertThat(subchannelIsReady(subchannel)).isTrue();
+    assertThat(subchannel).isSameInstanceAs(fallbackSubchannel);
+    verifyLongCounterAdd("grpc.lb.rls.default_target_picks", ++times, 1, "defaultTarget",
+        "complete");
+
+    // Make sure that when RLS starts communicating that default stops being used
+    fakeThrottler.nextResult = false;
+    fakeClock.forwardTime(2, TimeUnit.SECONDS); // Expires backoff cache entries
+
+    picker.pickSubchannel(searchSubchannelArgs);// Create search subchannel
+    FakeSubchannel searchSubchannel =
+        (FakeSubchannel) markReadyAndGetPickResult(inOrder, searchSubchannelArgs).getSubchannel();
+    assertThat(searchSubchannel).isNotNull();
+    assertThat(searchSubchannel).isNotSameInstanceAs(fallbackSubchannel);
+    verifyLongCounterAdd("grpc.lb.rls.target_picks", 1, 1, "wilderness", "complete");
+
+    // create rescue subchannel
+    picker.pickSubchannel(rescueSubchannelArgs);
+    FakeSubchannel rescueSubchannel =
+        (FakeSubchannel) markReadyAndGetPickResult(inOrder, rescueSubchannelArgs).getSubchannel();
+    assertThat(rescueSubchannel).isNotNull();
+    assertThat(rescueSubchannel).isNotSameInstanceAs(fallbackSubchannel);
+    assertThat(rescueSubchannel).isNotSameInstanceAs(searchSubchannel);
+    verifyLongCounterAdd("grpc.lb.rls.target_picks", 1, 1, "civilization", "complete");
+
+    // all channels are failed
+    rescueSubchannel.updateState(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+    searchSubchannel.updateState(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+    fallbackSubchannel.updateState(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+
+    res = picker.pickSubchannel(
+        searchSubchannelArgs);
+    assertThat(res.getStatus().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(res.getSubchannel()).isNull();
+    verifyLongCounterAdd("grpc.lb.rls.target_picks", 1, 1, "wilderness", "fail");
+  }
+
+  @Test
+  public void lb_working_withoutDefaultTarget() throws Exception {
+    defaultTarget = "";
+    deliverResolvedAddresses();
+    InOrder inOrder = inOrder(helper);
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    // Warm-up pick; will be queued
+    PickResult res = picker.pickSubchannel(searchSubchannelArgs);
+    assertThat(res.getStatus().isOk()).isTrue();
+    assertThat(res.getSubchannel()).isNull();
+    // Cache is warm, but still unconnected
+    res = picker.pickSubchannel(searchSubchannelArgs);
+    inOrder.verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
+    inOrder.verify(helper, atLeast(0))
+        .updateBalancingState(eq(ConnectivityState.CONNECTING), any(SubchannelPicker.class));
+    inOrder.verify(helper, atLeast(0)).getSynchronizationContext();
+    inOrder.verify(helper, atLeast(0)).getScheduledExecutorService();
+    inOrder.verify(helper, atLeast(0)).getMetricRecorder();
+    inOrder.verify(helper, atLeast(0)).getChannelTarget();
+    inOrder.verifyNoMoreInteractions();
+    assertThat(res.getStatus().isOk()).isTrue();
+
+    assertThat(subchannels).hasSize(1);
+    FakeSubchannel searchSubchannel =
+        (FakeSubchannel) markReadyAndGetPickResult(inOrder, searchSubchannelArgs).getSubchannel();
+    inOrder.verify(helper).getMetricRecorder();
+    inOrder.verify(helper).getChannelTarget();
+    inOrder.verifyNoMoreInteractions();
+    assertThat(subchannelIsReady(searchSubchannel)).isTrue();
+    assertThat(subchannels.getLast()).isSameInstanceAs(searchSubchannel);
+
+    // rescue should be pending status although the overall channel state is READY
+    picker = pickerCaptor.getValue();
+    res = picker.pickSubchannel(rescueSubchannelArgs);
+    inOrder.verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
+    // other rls picker itself is ready due to first channel.
+    assertThat(res.getStatus().isOk()).isTrue();
+    assertThat(subchannels).hasSize(2);
+    FakeSubchannel rescueSubchannel = subchannels.getLast();
+    assertThat(subchannelIsReady(rescueSubchannel)).isFalse();
+
+    // search subchannel is down, rescue subchannel is still connecting
+    searchSubchannel.updateState(ConnectivityStateInfo.forTransientFailure(Status.NOT_FOUND));
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
+
+    rescueSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
+
+    // search method will fail because there is no fallback target.
+    picker = pickerCaptor.getValue();
+    res = picker.pickSubchannel(newPickSubchannelArgs(fakeSearchMethod));
+    assertThat(res.getStatus().isOk()).isFalse();
+    assertThat(subchannelIsReady(res.getSubchannel())).isFalse();
+    verifyLongCounterAdd("grpc.lb.rls.target_picks", 1, 1, "wilderness", "complete");
+
+    res = picker.pickSubchannel(newPickSubchannelArgs(fakeRescueMethod));
+    assertThat(subchannelIsReady(res.getSubchannel())).isTrue();
+    assertThat(res.getSubchannel().getAddresses()).isEqualTo(rescueSubchannel.getAddresses());
+    assertThat(res.getSubchannel().getAttributes()).isEqualTo(rescueSubchannel.getAttributes());
+    verifyLongCounterAdd("grpc.lb.rls.target_picks", 1, 1, "civilization", "complete");
+
+    // all channels are failed
+    rescueSubchannel.updateState(ConnectivityStateInfo.forTransientFailure(Status.NOT_FOUND));
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    inOrder.verify(helper, atLeast(0)).refreshNameResolution();
+    inOrder.verifyNoMoreInteractions();
+    verifyLongCounterAdd("grpc.lb.rls.target_picks", 1, 1, "wilderness", "fail");
+  }
+
+  @Test
+  public void lb_nameResolutionFailed() throws Exception {
+    helper.getSynchronizationContext().execute(() -> {
+      try {
+        deliverResolvedAddresses();
+      } catch (Exception e) {
+        throw new RuntimeException(e);
+      }
+    });
+    InOrder inOrder = inOrder(helper);
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    PickResult res = picker.pickSubchannel(newPickSubchannelArgs(fakeSearchMethod));
+    assertThat(res.getStatus().isOk()).isTrue();
+    assertThat(subchannelIsReady(res.getSubchannel())).isFalse();
+
+    inOrder.verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
+    assertThat(subchannels).hasSize(2); // includes fallback sub-channel
+
+    FakeSubchannel searchSubchannel = subchannels.getLast();
+    searchSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    inOrder.verify(helper)
+        .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
+
+    SubchannelPicker picker2 = pickerCaptor.getValue();
+    assertThat(picker2).isEqualTo(picker);
+    res = picker2.pickSubchannel(newPickSubchannelArgs(fakeSearchMethod));
+    // verify success. Subchannel is wrapped, so checking attributes.
+    assertThat(subchannelIsReady(res.getSubchannel())).isTrue();
+    assertThat(res.getSubchannel().getAddresses()).isEqualTo(searchSubchannel.getAddresses());
+    assertThat(res.getSubchannel().getAttributes()).isEqualTo(searchSubchannel.getAttributes());
+    verifyLongCounterAdd("grpc.lb.rls.target_picks", 1, 1, "wilderness", "complete");
+
+    inOrder.verify(helper).getMetricRecorder();
+    inOrder.verify(helper).getChannelTarget();
+    inOrder.verifyNoMoreInteractions();
+
+    rlsLb.handleNameResolutionError(Status.UNAVAILABLE);
+
+    verify(helper)
+        .updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    SubchannelPicker failedPicker = pickerCaptor.getValue();
+    res = failedPicker.pickSubchannel(newPickSubchannelArgs(fakeSearchMethod));
+    assertThat(res.getStatus().isOk()).isFalse();
+    assertThat(subchannelIsReady(res.getSubchannel())).isFalse();
+  }
+
+  private PickResult markReadyAndGetPickResult(InOrder inOrder,
+                                               PickSubchannelArgs pickSubchannelArgs) {
+    subchannels.getLast().updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    inOrder.verify(helper, atLeast(1))
+        .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
+    PickResult pickResult = pickerCaptor.getValue().pickSubchannel(pickSubchannelArgs);
+    inOrder.verify(helper, atLeast(0)).getChannelLogger();
+    return pickResult;
+  }
+
+  private void deliverResolvedAddresses() throws Exception {
+    ConfigOrError parsedConfigOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJson(getLbConfigJsonStr()));
+    assertThat(parsedConfigOrError.getConfig()).isNotNull();
+    rlsLb.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+        .setAddresses(ImmutableList.of(new EquivalentAddressGroup(mock(SocketAddress.class))))
+        .setLoadBalancingPolicyConfig(parsedConfigOrError.getConfig())
+        .build());
+    verify(helper).createResolvingOobChannelBuilder(anyString(), any(ChannelCredentials.class));
+  }
+
+  @SuppressWarnings("unchecked")
+  private Map<String, Object> parseJson(String json) throws IOException {
+    return (Map<String, Object>) JsonParser.parse(json);
+  }
+
+  private String getServiceConfigJsonStr() {
+    return "{"
+        + "  \"loadBalancingConfig\": [{"
+        + "    \"rls_experimental\": " + getLbConfigJsonStr()
+        + "  }]"
+        + "}";
+  }
+
+  private String getLbConfigJsonStr() {
+    return "{"
+        + "  \"routeLookupConfig\": " + getRlsConfigJsonStr() + ", "
+        + "  \"childPolicy\": [{\"pick_first\": {}}],"
+        + "  \"childPolicyConfigTargetFieldName\": \"serviceName\""
+        + "}";
+  }
+
+  private String getRlsConfigJsonStr() {
+    return "{\n"
+        + "  \"grpcKeybuilders\": [\n"
+        + "    {\n"
+        + "      \"names\": [\n"
+        + "        {\n"
+        + "          \"service\": \"com.google\",\n"
+        + "          \"method\": \"*\"\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"headers\": [\n"
+        + "        {\n"
+        + "          \"key\": \"permit\","
+        + "          \"names\": [\"PermitId\"],\n"
+        + "          \"optional\": true\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"extraKeys\": {\n"
+        + "        \"host\": \"server\",\n"
+        + "        \"service\": \"service-key\",\n"
+        + "        \"method\": \"method-key\"\n"
+        + "      }\n"
+        + "    }\n"
+        + "  ],\n"
+        + "  \"lookupService\": \"localhost:8972\",\n"
+        + "  \"lookupServiceTimeout\": \"2s\",\n"
+        + "  \"maxAge\": \"300s\",\n"
+        + "  \"staleAge\": \"240s\",\n"
+        + "  \"validTargets\": [\"localhost:9001\", \"localhost:9002\"],"
+        + "  \"cacheSizeBytes\": \"1000\",\n"
+        + "  \"defaultTarget\": \"" + defaultTarget + "\",\n"
+        + "  \"requestProcessingStrategy\": \"SYNC_LOOKUP_DEFAULT_TARGET_ON_ERROR\"\n"
+        + "}";
+  }
+
+  // Verifies that the MetricRecorder has been called to record a long counter value of 1 for the
+  // given metric name, the given number of times
+  private void verifyLongCounterAdd(String name, int times, long value,
+      String dataPlaneTargetLabel, String pickResult) {
+    // TODO: support the "grpc.target" label once available.
+    verify(mockMetricRecorder, times(times)).addLongCounter(
+        eqMetricInstrumentName(name), eq(value),
+        eq(Lists.newArrayList(channelTarget, "localhost:8972", dataPlaneTargetLabel, pickResult)),
+        eq(Lists.newArrayList()));
+  }
+
+  // This one is for verifying the failed_pick metric specifically.
+  private void verifyFailedPicksCounterAdd(int times, long value) {
+    // TODO: support the "grpc.target" label once available.
+    verify(mockMetricRecorder, times(times)).addLongCounter(
+        eqMetricInstrumentName("grpc.lb.rls.failed_picks"), eq(value),
+        eq(Lists.newArrayList(channelTarget, "localhost:8972")),
+        eq(Lists.newArrayList()));
+  }
+
+  @SuppressWarnings("TypeParameterUnusedInFormals")
+  private <T extends MetricInstrument> T eqMetricInstrumentName(String name) {
+    return argThat(new ArgumentMatcher<T>() {
+      @Override
+      public boolean matches(T instrument) {
+        return instrument.getName().equals(name);
+      }
+    });
+  }
+
+  private PickSubchannelArgs newPickSubchannelArgs(MethodDescriptor<?, ?> method) {
+    return new PickSubchannelArgsImpl(
+        method, new Metadata(), CallOptions.DEFAULT, new PickDetailsConsumer() {});
+  }
+
+  private final class FakeHelper extends Helper {
+
+    @Override
+    public Subchannel createSubchannel(CreateSubchannelArgs args) {
+      FakeSubchannel subchannel = new FakeSubchannel(args.getAddresses(), args.getAttributes());
+      subchannels.add(subchannel);
+      return subchannel;
+    }
+
+    @Override
+    public ManagedChannelBuilder<?> createResolvingOobChannelBuilder(
+        String target, ChannelCredentials creds) {
+      try {
+        grpcCleanupRule.register(
+            InProcessServerBuilder.forName(target)
+                .addService(fakeRlsServerImpl)
+                .directExecutor()
+                .build()
+                .start());
+      } catch (IOException e) {
+        throw new RuntimeException("cannot create server: " + target, e);
+      }
+      final InProcessChannelBuilder builder =
+          InProcessChannelBuilder.forName(target).directExecutor();
+
+      class CleaningChannelBuilder extends ForwardingChannelBuilder2<CleaningChannelBuilder> {
+
+        @Override
+        protected ManagedChannelBuilder<?> delegate() {
+          return builder;
+        }
+
+        @Override
+        public ManagedChannel build() {
+          return grpcCleanupRule.register(super.build());
+        }
+      }
+
+      return new CleaningChannelBuilder();
+    }
+
+    @Override
+    public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String authority) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void updateBalancingState(
+        @Nonnull ConnectivityState newState, @Nonnull SubchannelPicker newPicker) {
+      // no-op
+    }
+
+    @Override
+    public void refreshNameResolution() {
+      // no-op
+    }
+
+    @Override
+    public String getAuthority() {
+      return "fake-bigtable.googleapis.com";
+    }
+
+    @Override
+    public ChannelCredentials getUnsafeChannelCredentials() {
+      // In test we don't do any authentication.
+      return new ChannelCredentials() {
+        @Override
+        public ChannelCredentials withoutBearerTokens() {
+          return this;
+        }
+      };
+    }
+
+
+    @Override
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return fakeClock.getScheduledExecutorService();
+    }
+
+    @Override
+    public SynchronizationContext getSynchronizationContext() {
+      return syncContext;
+    }
+
+    @Override
+    public ChannelLogger getChannelLogger() {
+      return mock(ChannelLogger.class);
+    }
+
+    @Override
+    public MetricRecorder getMetricRecorder() {
+      return mockMetricRecorder;
+    }
+
+    @Override
+    public String getChannelTarget() {
+      return channelTarget;
+    }
+  }
+
+  private static final class FakeRlsServerImpl
+      extends RouteLookupServiceGrpc.RouteLookupServiceImplBase {
+
+    private static final Converter<io.grpc.lookup.v1.RouteLookupRequest, RouteLookupRequest>
+        REQUEST_CONVERTER = new RlsProtoConverters.RouteLookupRequestConverter();
+    private static final Converter<RouteLookupResponse, io.grpc.lookup.v1.RouteLookupResponse>
+        RESPONSE_CONVERTER = new RouteLookupResponseConverter().reverse();
+
+    private final ScheduledExecutorService scheduler;
+    private long delay;
+    private TimeUnit delayUnit;
+
+    public FakeRlsServerImpl(ScheduledExecutorService scheduler) {
+      this.scheduler = scheduler;
+    }
+
+    private Map<RouteLookupRequest, RouteLookupResponse> lookupTable = ImmutableMap.of();
+
+    private void setLookupTable(Map<RouteLookupRequest, RouteLookupResponse> lookupTable) {
+      this.lookupTable = checkNotNull(lookupTable, "lookupTable");
+    }
+
+    void setResponseDelay(long delay, TimeUnit unit) {
+      this.delay = delay;
+      this.delayUnit = unit;
+    }
+
+    @Override
+    @SuppressWarnings("FutureReturnValueIgnored")
+    public void routeLookup(io.grpc.lookup.v1.RouteLookupRequest request,
+        StreamObserver<io.grpc.lookup.v1.RouteLookupResponse> responseObserver) {
+      RouteLookupResponse response =
+          lookupTable.get(REQUEST_CONVERTER.convert(request));
+      Runnable sendResponse = () -> sendResponse(response, responseObserver);
+      if (delay != 0) {
+        scheduler.schedule(sendResponse, delay, delayUnit);
+      } else {
+        sendResponse.run();
+      }
+    }
+
+    private void sendResponse(RouteLookupResponse response,
+        StreamObserver<io.grpc.lookup.v1.RouteLookupResponse> responseObserver) {
+      if (response == null) {
+        responseObserver.onError(new RuntimeException("not found"));
+      } else {
+        responseObserver.onNext(RESPONSE_CONVERTER.convert(response));
+        responseObserver.onCompleted();
+      }
+    }
+  }
+
+  private static final class FakeSubchannel extends Subchannel {
+    private final Attributes attributes;
+    private List<EquivalentAddressGroup> eags;
+    private SubchannelStateListener listener;
+    private volatile boolean isReady;
+
+    public FakeSubchannel(List<EquivalentAddressGroup> eags, Attributes attributes) {
+      this.eags = Collections.unmodifiableList(eags);
+      this.attributes = attributes;
+    }
+
+    @Override
+    public List<EquivalentAddressGroup> getAllAddresses() {
+      return eags;
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return attributes;
+    }
+
+    @Override
+    public void start(SubchannelStateListener listener) {
+      this.listener = checkNotNull(listener, "listener");
+    }
+
+    @Override
+    public void updateAddresses(List<EquivalentAddressGroup> addrs) {
+      this.eags = Collections.unmodifiableList(addrs);
+    }
+
+    @Override
+    public void shutdown() {
+    }
+
+    @Override
+    public void requestConnection() {
+    }
+
+    public void updateState(ConnectivityStateInfo newState) {
+      listener.onSubchannelState(newState);
+      isReady = newState.getState().equals(ConnectivityState.READY);
+    }
+  }
+
+  private static boolean subchannelIsReady(Subchannel subchannel) {
+    return subchannel instanceof FakeSubchannel && ((FakeSubchannel) subchannel).isReady;
+  }
+
+  private static final class FakeThrottler implements Throttler {
+
+    private boolean nextResult = false;
+
+    @Override
+    public boolean shouldThrottle() {
+      return nextResult;
+    }
+
+    @Override
+    public void registerBackendResponse(boolean throttled) {
+      // no-op
+    }
+  }
+
+}
diff --git a/rls/src/test/java/io/grpc/rls/RlsProtoConvertersTest.java b/rls/src/test/java/io/grpc/rls/RlsProtoConvertersTest.java
new file mode 100644
index 00000000000..ad1ce8c363e
--- /dev/null
+++ b/rls/src/test/java/io/grpc/rls/RlsProtoConvertersTest.java
@@ -0,0 +1,656 @@
+/*
+ * 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.rls;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import com.google.common.base.Converter;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.internal.JsonParser;
+import io.grpc.lookup.v1.RouteLookupRequest;
+import io.grpc.lookup.v1.RouteLookupResponse;
+import io.grpc.rls.RlsProtoConverters.RouteLookupConfigConverter;
+import io.grpc.rls.RlsProtoConverters.RouteLookupRequestConverter;
+import io.grpc.rls.RlsProtoConverters.RouteLookupResponseConverter;
+import io.grpc.rls.RlsProtoData.ExtraKeys;
+import io.grpc.rls.RlsProtoData.GrpcKeyBuilder;
+import io.grpc.rls.RlsProtoData.GrpcKeyBuilder.Name;
+import io.grpc.rls.RlsProtoData.NameMatcher;
+import io.grpc.rls.RlsProtoData.RouteLookupConfig;
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class RlsProtoConvertersTest {
+
+  @Test
+  public void convert_toRequestProto() {
+    Converter<RouteLookupRequest, RlsProtoData.RouteLookupRequest> converter =
+        new RouteLookupRequestConverter();
+    RouteLookupRequest proto = RouteLookupRequest.newBuilder()
+        .putKeyMap("key1", "val1")
+        .build();
+
+    RlsProtoData.RouteLookupRequest object = converter.convert(proto);
+
+    assertThat(object.keyMap()).containsExactly("key1", "val1");
+  }
+
+  @Test
+  public void convert_toRequestObject() {
+    Converter<RlsProtoData.RouteLookupRequest, RouteLookupRequest> converter =
+        new RouteLookupRequestConverter().reverse();
+    RlsProtoData.RouteLookupRequest requestObject =
+        RlsProtoData.RouteLookupRequest.create(ImmutableMap.of("key1", "val1"),
+            RlsProtoData.RouteLookupRequest.Reason.REASON_MISS);
+
+    RouteLookupRequest proto = converter.convert(requestObject);
+
+    assertThat(proto.getTargetType()).isEqualTo("grpc");
+    assertThat(proto.getKeyMapMap()).containsExactly("key1", "val1");
+    assertThat(proto.getReason()).isEqualTo(RouteLookupRequest.Reason.REASON_MISS);
+  }
+
+  @Test
+  public void convert_toResponseProto() {
+    Converter<RouteLookupResponse, RlsProtoData.RouteLookupResponse> converter =
+        new RouteLookupResponseConverter();
+    RouteLookupResponse proto = RouteLookupResponse.newBuilder()
+        .addTargets("target")
+        .setHeaderData("some header data")
+        .build();
+
+    RlsProtoData.RouteLookupResponse object = converter.convert(proto);
+
+    assertThat(object.targets()).containsExactly("target");
+    assertThat(object.getHeaderData()).isEqualTo("some header data");
+  }
+
+  @Test
+  public void convert_toResponseObject() {
+    Converter<RlsProtoData.RouteLookupResponse, RouteLookupResponse> converter =
+        new RouteLookupResponseConverter().reverse();
+
+    RlsProtoData.RouteLookupResponse object =
+        RlsProtoData.RouteLookupResponse.create(ImmutableList.of("target"), "some header data");
+
+    RouteLookupResponse proto = converter.convert(object);
+
+    assertThat(proto.getTargetsList()).containsExactly("target");
+    assertThat(proto.getHeaderData()).isEqualTo("some header data");
+  }
+
+  @Test
+  public void convert_jsonRlsConfig() throws IOException {
+    String jsonStr = "{\n"
+        + "  \"grpcKeybuilders\": [\n"
+        + "    {\n"
+        + "      \"names\": [\n"
+        + "        {\n"
+        + "          \"service\": \"service1\",\n"
+        + "          \"method\": \"create\"\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"headers\": [\n"
+        + "        {\n"
+        + "          \"key\": \"user\","
+        + "          \"names\": [\"User\", \"Parent\"],\n"
+        + "          \"optional\": true\n"
+        + "        },\n"
+        + "        {\n"
+        + "          \"key\": \"id\","
+        + "          \"names\": [\"X-Google-Id\"],\n"
+        + "          \"optional\": true\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    },\n"
+        + "    {\n"
+        + "      \"names\": [\n"
+        + "        {\n"
+        + "          \"service\": \"service1\",\n"
+        + "          \"method\": \"*\"\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"headers\": [\n"
+        + "        {\n"
+        + "          \"key\": \"user\","
+        + "          \"names\": [\"User\", \"Parent\"],\n"
+        + "          \"optional\": true\n"
+        + "        },\n"
+        + "        {\n"
+        + "          \"key\": \"password\","
+        + "          \"names\": [\"Password\"],\n"
+        + "          \"optional\": true\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    },\n"
+        + "    {\n"
+        + "      \"names\": [\n"
+        + "        {\n"
+        + "          \"service\": \"service3\",\n"
+        + "          \"method\": \"*\"\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"headers\": ["
+        + "        {\n"
+        + "          \"key\": \"user\","
+        + "          \"names\": [\"User\", \"Parent\"],\n"
+        + "          \"optional\": true\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"extraKeys\": {\n"
+        + "        \"host\": \"host-key\",\n"
+        + "        \"service\": \"service-key\",\n"
+        + "        \"method\": \"method-key\"\n"
+        + "      }, \n"
+        + "      \"constantKeys\": {\n"
+        + "        \"constKey1\": \"value1\"\n"
+        + "      }\n"
+        + "    }\n"
+        + "  ],\n"
+        + "  \"lookupService\": \"service1\",\n"
+        + "  \"lookupServiceTimeout\": \"2s\",\n"
+        + "  \"maxAge\": \"300s\",\n"
+        + "  \"staleAge\": \"240s\",\n"
+        + "  \"validTargets\": [\"a valid target\"],"
+        + "  \"cacheSizeBytes\": \"1000\",\n"
+        + "  \"defaultTarget\": \"us_east_1.cloudbigtable.googleapis.com\"\n"
+        + "}";
+
+    RouteLookupConfig expectedConfig =
+        RouteLookupConfig.builder()
+            .grpcKeybuilders(ImmutableList.of(
+                GrpcKeyBuilder.create(
+                    ImmutableList.of(Name.create("service1", "create")),
+                    ImmutableList.of(
+                        NameMatcher.create("user", ImmutableList.of("User", "Parent")),
+                        NameMatcher.create("id", ImmutableList.of("X-Google-Id"))),
+                    ExtraKeys.DEFAULT,
+                    ImmutableMap.<String, String>of()),
+                GrpcKeyBuilder.create(
+                    ImmutableList.of(Name.create("service1", "*")),
+                    ImmutableList.of(
+                        NameMatcher.create("user", ImmutableList.of("User", "Parent")),
+                        NameMatcher.create("password", ImmutableList.of("Password"))),
+                    ExtraKeys.DEFAULT,
+                    ImmutableMap.<String, String>of()),
+                GrpcKeyBuilder.create(
+                    ImmutableList.of(Name.create("service3", "*")),
+                    ImmutableList.of(
+                        NameMatcher.create("user", ImmutableList.of("User", "Parent"))),
+                    ExtraKeys.create("host-key", "service-key", "method-key"),
+                    ImmutableMap.of("constKey1", "value1"))))
+            .lookupService("service1")
+            .lookupServiceTimeoutInNanos(TimeUnit.SECONDS.toNanos(2))
+            .maxAgeInNanos(TimeUnit.SECONDS.toNanos(300))
+            .staleAgeInNanos(TimeUnit.SECONDS.toNanos(240))
+            .cacheSizeBytes(1000)
+            .defaultTarget("us_east_1.cloudbigtable.googleapis.com")
+            .build();
+
+    RouteLookupConfigConverter converter = new RouteLookupConfigConverter();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> parsedJson = (Map<String, ?>) JsonParser.parse(jsonStr);
+    RouteLookupConfig converted = converter.convert(parsedJson);
+    assertThat(converted).isEqualTo(expectedConfig);
+  }
+
+  @Test
+  public void convert_jsonRlsConfig_emptyKeyBuilders()  throws IOException {
+    String jsonStr = "{\n"
+        + "  \"grpcKeybuilders\": [],\n"
+        + "  \"lookupService\": \"service1\",\n"
+        + "  \"lookupServiceTimeout\": \"2s\",\n"
+        + "  \"maxAge\": \"300s\",\n"
+        + "  \"staleAge\": \"240s\",\n"
+        + "  \"validTargets\": [\"a valid target\"],"
+        + "  \"cacheSizeBytes\": \"1000\",\n"
+        + "  \"defaultTarget\": \"us_east_1.cloudbigtable.googleapis.com\"\n"
+        + "}";
+
+    RouteLookupConfigConverter converter = new RouteLookupConfigConverter();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> parsedJson = (Map<String, ?>) JsonParser.parse(jsonStr);
+    try {
+      converter.convert(parsedJson);
+      fail("Exception expected");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().contains("must have at least one GrpcKeyBuilder");
+    }
+  }
+
+  @Test
+  public void convert_jsonRlsConfig_namesNotUnique() throws IOException {
+    String jsonStr = "{\n"
+        + "  \"grpcKeybuilders\": [\n"
+        + "    {\n"
+        + "      \"names\": [\n"
+        + "        {\n"
+        + "          \"service\": \"service1\",\n"
+        + "          \"method\": \"create\"\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"headers\": [\n"
+        + "        {\n"
+        + "          \"key\": \"user\","
+        + "          \"names\": [\"User\", \"Parent\"],\n"
+        + "          \"optional\": true\n"
+        + "        },\n"
+        + "        {\n"
+        + "          \"key\": \"id\","
+        + "          \"names\": [\"X-Google-Id\"],\n"
+        + "          \"optional\": true\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    },\n"
+        + "    {\n"
+        + "      \"names\": [\n"
+        + "        {\n"
+        + "          \"service\": \"service1\",\n"
+        + "          \"method\": \"create\"\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"headers\": [\n"
+        + "        {\n"
+        + "          \"key\": \"user\","
+        + "          \"names\": [\"User\", \"Parent\"],\n"
+        + "          \"optional\": true\n"
+        + "        },\n"
+        + "        {\n"
+        + "          \"key\": \"password\","
+        + "          \"names\": [\"Password\"],\n"
+        + "          \"optional\": true\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    },\n"
+        + "    {\n"
+        + "      \"names\": [\n"
+        + "        {\n"
+        + "          \"service\": \"service3\",\n"
+        + "          \"method\": \"*\"\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"headers\": ["
+        + "        {\n"
+        + "          \"key\": \"user\","
+        + "          \"names\": [\"User\", \"Parent\"],\n"
+        + "          \"optional\": true\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"extraKeys\": {\n"
+        + "        \"host\": \"host-key\",\n"
+        + "        \"service\": \"service-key\",\n"
+        + "        \"method\": \"method-key\"\n"
+        + "      }, \n"
+        + "      \"constantKeys\": {\n"
+        + "        \"constKey1\": \"value1\"\n"
+        + "      }\n"
+        + "    }\n"
+        + "  ],\n"
+        + "  \"lookupService\": \"service1\",\n"
+        + "  \"lookupServiceTimeout\": \"2s\",\n"
+        + "  \"maxAge\": \"300s\",\n"
+        + "  \"staleAge\": \"240s\",\n"
+        + "  \"validTargets\": [\"a valid target\"],"
+        + "  \"cacheSizeBytes\": \"1000\",\n"
+        + "  \"defaultTarget\": \"us_east_1.cloudbigtable.googleapis.com\"\n"
+        + "}";
+
+    RouteLookupConfigConverter converter = new RouteLookupConfigConverter();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> parsedJson = (Map<String, ?>) JsonParser.parse(jsonStr);
+    try {
+      converter.convert(parsedJson);
+      fail("Exception expected");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat()
+          .contains("duplicate names in grpc_keybuilders: Name{service=service1, method=create}");
+    }
+  }
+
+  @Test
+  public void convert_jsonRlsConfig_defaultValues() throws IOException {
+    String jsonStr = "{\n"
+        + "  \"grpcKeybuilders\": [\n"
+        + "    {\n"
+        + "      \"names\": [\n"
+        + "        {\n"
+        + "          \"service\": \"service1\"\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ],\n"
+        + "  \"lookupService\": \"service1\",\n"
+        + "  \"validTargets\": [\"a valid target\"],"
+        + "  \"defaultTarget\": \"us_east_1.cloudbigtable.googleapis.com\"\n"
+        + "}";
+
+    RouteLookupConfig expectedConfig =
+        RouteLookupConfig.builder()
+            .grpcKeybuilders(ImmutableList.of(
+                GrpcKeyBuilder.create(
+                    ImmutableList.of(Name.create("service1", null)),
+                    ImmutableList.<NameMatcher>of(),
+                    ExtraKeys.DEFAULT,
+                    ImmutableMap.<String, String>of())))
+            .lookupService("service1")
+            .lookupServiceTimeoutInNanos(TimeUnit.SECONDS.toNanos(10))
+            .maxAgeInNanos(TimeUnit.MINUTES.toNanos(5))
+            .staleAgeInNanos(TimeUnit.MINUTES.toNanos(5))
+            .cacheSizeBytes(5 * 1024 * 1024)
+            .defaultTarget("us_east_1.cloudbigtable.googleapis.com")
+            .build();
+
+    RouteLookupConfigConverter converter = new RouteLookupConfigConverter();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> parsedJson = (Map<String, ?>) JsonParser.parse(jsonStr);
+    RouteLookupConfig converted = converter.convert(parsedJson);
+    assertThat(converted).isEqualTo(expectedConfig);
+  }
+
+  @Test
+  public void convert_jsonRlsConfig_staleAgeCappedByMaxAge() throws IOException {
+    String jsonStr = "{\n"
+        + "  \"grpcKeybuilders\": [\n"
+        + "    {\n"
+        + "      \"names\": [\n"
+        + "        {\n"
+        + "          \"service\": \"service1\",\n"
+        + "          \"method\": \"create\"\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"headers\": [\n"
+        + "        {\n"
+        + "          \"key\": \"user\","
+        + "          \"names\": [\"User\", \"Parent\"],\n"
+        + "          \"optional\": true\n"
+        + "        },\n"
+        + "        {\n"
+        + "          \"key\": \"id\","
+        + "          \"names\": [\"X-Google-Id\"],\n"
+        + "          \"optional\": true\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ],\n"
+        + "  \"lookupService\": \"service1\",\n"
+        + "  \"lookupServiceTimeout\": \"2s\",\n"
+        + "  \"maxAge\": \"300s\",\n"
+        + "  \"staleAge\": \"400s\",\n"
+        + "  \"validTargets\": [\"a valid target\"],"
+        + "  \"cacheSizeBytes\": \"1000\",\n"
+        + "  \"defaultTarget\": \"us_east_1.cloudbigtable.googleapis.com\"\n"
+        + "}";
+
+    RouteLookupConfig expectedConfig =
+        RouteLookupConfig.builder()
+            .grpcKeybuilders(ImmutableList.of(
+                GrpcKeyBuilder.create(
+                    ImmutableList.of(Name.create("service1", "create")),
+                    ImmutableList.of(
+                        NameMatcher.create("user", ImmutableList.of("User", "Parent")),
+                        NameMatcher.create("id", ImmutableList.of("X-Google-Id"))),
+                    ExtraKeys.DEFAULT,
+                    ImmutableMap.<String, String>of())))
+            .lookupService("service1")
+            .lookupServiceTimeoutInNanos(TimeUnit.SECONDS.toNanos(2))
+            .maxAgeInNanos(TimeUnit.SECONDS.toNanos(300))
+            .staleAgeInNanos(TimeUnit.SECONDS.toNanos(300))
+            .cacheSizeBytes(1000)
+            .defaultTarget("us_east_1.cloudbigtable.googleapis.com")
+            .build();
+
+    RouteLookupConfigConverter converter = new RouteLookupConfigConverter();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> parsedJson = (Map<String, ?>) JsonParser.parse(jsonStr);
+    RouteLookupConfig converted = converter.convert(parsedJson);
+    assertThat(converted).isEqualTo(expectedConfig);
+  }
+
+  @Test
+  public void convert_jsonRlsConfig_staleAgeGivenWithoutMaxAge() throws IOException {
+    String jsonStr = "{\n"
+        + "  \"grpcKeybuilders\": [\n"
+        + "    {\n"
+        + "      \"names\": [\n"
+        + "        {\n"
+        + "          \"service\": \"service1\",\n"
+        + "          \"method\": \"create\"\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"headers\": [\n"
+        + "        {\n"
+        + "          \"key\": \"user\","
+        + "          \"names\": [\"User\", \"Parent\"],\n"
+        + "          \"optional\": true\n"
+        + "        },\n"
+        + "        {\n"
+        + "          \"key\": \"id\","
+        + "          \"names\": [\"X-Google-Id\"],\n"
+        + "          \"optional\": true\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ],\n"
+        + "  \"lookupService\": \"service1\",\n"
+        + "  \"lookupServiceTimeout\": \"2s\",\n"
+        + "  \"staleAge\": \"240s\",\n"
+        + "  \"validTargets\": [\"a valid target\"],"
+        + "  \"cacheSizeBytes\": \"1000\",\n"
+        + "  \"defaultTarget\": \"us_east_1.cloudbigtable.googleapis.com\"\n"
+        + "}";
+
+    RouteLookupConfigConverter converter = new RouteLookupConfigConverter();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> parsedJson = (Map<String, ?>) JsonParser.parse(jsonStr);
+    try {
+      converter.convert(parsedJson);
+      fail("Exception expected");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().contains("to specify staleAge, must have maxAge");
+    }
+  }
+
+  @Test
+  public void convert_jsonRlsConfig_doNotClampMaxAgeIfStaleAgeIsSet() throws IOException {
+    String jsonStr = "{\n"
+        + "  \"grpcKeybuilders\": [\n"
+        + "    {\n"
+        + "      \"names\": [\n"
+        + "        {\n"
+        + "          \"service\": \"service1\",\n"
+        + "          \"method\": \"create\"\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"headers\": [\n"
+        + "        {\n"
+        + "          \"key\": \"user\","
+        + "          \"names\": [\"User\", \"Parent\"],\n"
+        + "          \"optional\": true\n"
+        + "        },\n"
+        + "        {\n"
+        + "          \"key\": \"id\","
+        + "          \"names\": [\"X-Google-Id\"],\n"
+        + "          \"optional\": true\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ],\n"
+        + "  \"lookupService\": \"service1\",\n"
+        + "  \"lookupServiceTimeout\": \"2s\",\n"
+        + "  \"maxAge\": \"350s\",\n"
+        + "  \"staleAge\": \"310s\",\n"
+        + "  \"validTargets\": [\"a valid target\"],"
+        + "  \"cacheSizeBytes\": \"1000\",\n"
+        + "  \"defaultTarget\": \"us_east_1.cloudbigtable.googleapis.com\"\n"
+        + "}";
+
+    RouteLookupConfig expectedConfig =
+        RouteLookupConfig.builder()
+            .grpcKeybuilders(ImmutableList.of(
+                GrpcKeyBuilder.create(
+                    ImmutableList.of(Name.create("service1", "create")),
+                    ImmutableList.of(
+                        NameMatcher.create("user", ImmutableList.of("User", "Parent")),
+                        NameMatcher.create("id", ImmutableList.of("X-Google-Id"))),
+                    ExtraKeys.DEFAULT,
+                    ImmutableMap.<String, String>of())))
+            .lookupService("service1")
+            .lookupServiceTimeoutInNanos(TimeUnit.SECONDS.toNanos(2))
+            .maxAgeInNanos(TimeUnit.SECONDS.toNanos(350)) // Should not be clamped
+            .staleAgeInNanos(TimeUnit.SECONDS.toNanos(300)) // Should be clamped to max 300s
+            .cacheSizeBytes(1000)
+            .defaultTarget("us_east_1.cloudbigtable.googleapis.com")
+            .build();
+
+    RouteLookupConfigConverter converter = new RouteLookupConfigConverter();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> parsedJson = (Map<String, ?>) JsonParser.parse(jsonStr);
+    RouteLookupConfig converted = converter.convert(parsedJson);
+    assertThat(converted).isEqualTo(expectedConfig);
+  }
+
+  @Test
+  public void convert_jsonRlsConfig_keyBuilderWithoutName() throws IOException {
+    String jsonStr = "{\n"
+        + "  \"grpcKeybuilders\": [\n"
+        + "    {\n"
+        + "      \"headers\": [\n"
+        + "        {\n"
+        + "          \"key\": \"user\","
+        + "          \"names\": [\"User\", \"Parent\"],\n"
+        + "          \"optional\": true\n"
+        + "        },\n"
+        + "        {\n"
+        + "          \"key\": \"id\","
+        + "          \"names\": [\"X-Google-Id\"],\n"
+        + "          \"optional\": true\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ],\n"
+        + "  \"lookupService\": \"service1\",\n"
+        + "  \"lookupServiceTimeout\": \"2s\",\n"
+        + "  \"staleAge\": \"240s\",\n"
+        + "  \"validTargets\": [\"a valid target\"],"
+        + "  \"cacheSizeBytes\": \"1000\",\n"
+        + "  \"defaultTarget\": \"us_east_1.cloudbigtable.googleapis.com\"\n"
+        + "}";
+
+    RouteLookupConfigConverter converter = new RouteLookupConfigConverter();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> parsedJson = (Map<String, ?>) JsonParser.parse(jsonStr);
+    try {
+      converter.convert(parsedJson);
+      fail("Exception expected");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().contains("each keyBuilder must have at least one name");
+    }
+  }
+
+  @Test
+  public void convert_jsonRlsConfig_nameWithoutService() throws IOException {
+    String jsonStr = "{\n"
+        + "  \"grpcKeybuilders\": [\n"
+        + "    {\n"
+        + "      \"names\": [\n"
+        + "        {\n"
+        + "          \"method\": \"create\"\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"headers\": [\n"
+        + "        {\n"
+        + "          \"key\": \"user\","
+        + "          \"names\": [\"User\", \"Parent\"],\n"
+        + "          \"optional\": true\n"
+        + "        },\n"
+        + "        {\n"
+        + "          \"key\": \"id\","
+        + "          \"names\": [\"X-Google-Id\"],\n"
+        + "          \"optional\": true\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ],\n"
+        + "  \"lookupService\": \"service1\",\n"
+        + "  \"lookupServiceTimeout\": \"2s\",\n"
+        + "  \"staleAge\": \"240s\",\n"
+        + "  \"validTargets\": [\"a valid target\"],"
+        + "  \"cacheSizeBytes\": \"1000\",\n"
+        + "  \"defaultTarget\": \"us_east_1.cloudbigtable.googleapis.com\"\n"
+        + "}";
+
+    RouteLookupConfigConverter converter = new RouteLookupConfigConverter();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> parsedJson = (Map<String, ?>) JsonParser.parse(jsonStr);
+    try {
+      converter.convert(parsedJson);
+      fail("Exception expected");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().contains("service must not be empty or null");
+    }
+  }
+
+  @Test
+  public void convert_jsonRlsConfig_keysNotUnique() throws IOException {
+    String jsonStr = "{\n"
+        + "  \"grpcKeybuilders\": [\n"
+        + "    {\n"
+        + "      \"names\": [\n"
+        + "        {\n"
+        + "          \"service\": \"service1\"\n"
+        + "        }\n"
+        + "      ],\n"
+        + "      \"headers\": [\n"
+        + "        {\n"
+        + "          \"key\": \"service\","  // duplicate to extra_keys
+        + "          \"names\": [\"User\", \"Parent\"],\n"
+        + "          \"optional\": true\n"
+        + "        },\n"
+        + "        {\n"
+        + "          \"key\": \"id\","
+        + "          \"names\": [\"X-Google-Id\"],\n"
+        + "          \"optional\": true\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ],\n"
+        + "  \"lookupService\": \"service1\",\n"
+        + "  \"lookupServiceTimeout\": \"2s\",\n"
+        + "  \"staleAge\": \"240s\",\n"
+        + "  \"validTargets\": [\"a valid target\"],"
+        + "  \"cacheSizeBytes\": \"1000\",\n"
+        + "  \"defaultTarget\": \"us_east_1.cloudbigtable.googleapis.com\"\n"
+        + "}";
+
+    RouteLookupConfigConverter converter = new RouteLookupConfigConverter();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> parsedJson = (Map<String, ?>) JsonParser.parse(jsonStr);
+    try {
+      converter.convert(parsedJson);
+      fail("Exception expected");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().contains("keys in KeyBuilder must be unique");
+    }
+  }
+}
diff --git a/rls/src/test/java/io/grpc/rls/RlsRequestFactoryTest.java b/rls/src/test/java/io/grpc/rls/RlsRequestFactoryTest.java
new file mode 100644
index 00000000000..2b900994ed9
--- /dev/null
+++ b/rls/src/test/java/io/grpc/rls/RlsRequestFactoryTest.java
@@ -0,0 +1,151 @@
+/*
+ * 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.rls;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.Metadata;
+import io.grpc.rls.RlsProtoData.ExtraKeys;
+import io.grpc.rls.RlsProtoData.GrpcKeyBuilder;
+import io.grpc.rls.RlsProtoData.GrpcKeyBuilder.Name;
+import io.grpc.rls.RlsProtoData.NameMatcher;
+import io.grpc.rls.RlsProtoData.RouteLookupConfig;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class RlsRequestFactoryTest {
+
+  private static final RouteLookupConfig RLS_CONFIG =
+      RouteLookupConfig.builder()
+          .grpcKeybuilders(ImmutableList.of(
+              GrpcKeyBuilder.create(
+                  ImmutableList.of(Name.create("com.google.service1", "Create")),
+                  ImmutableList.of(
+                      NameMatcher.create("user", ImmutableList.of("User", "Parent")),
+                      NameMatcher.create("id", ImmutableList.of("X-Google-Id"))),
+                  ExtraKeys.create("server-1", null, null),
+                  ImmutableMap.of("const-key-1", "const-value-1")),
+              GrpcKeyBuilder.create(
+                  ImmutableList.of(Name.create("com.google.service1", "*")),
+                  ImmutableList.of(
+                      NameMatcher.create("user", ImmutableList.of("User", "Parent")),
+                      NameMatcher.create("password", ImmutableList.of("Password"))),
+                  ExtraKeys.create(null, "service-2", null),
+                  ImmutableMap.of("const-key-2", "const-value-2")),
+              GrpcKeyBuilder.create(
+                  ImmutableList.of(Name.create("com.google.service2", "*")),
+                  ImmutableList.of(
+                      NameMatcher.create("password", ImmutableList.of("Password"))),
+                  ExtraKeys.create(null, "service-3", "method-3"),
+                  ImmutableMap.<String, String>of()),
+              GrpcKeyBuilder.create(
+                  ImmutableList.of(Name.create("com.google.service3", "*")),
+                  ImmutableList.of(
+                      NameMatcher.create("user", ImmutableList.of("User", "Parent"))),
+                  ExtraKeys.create(null, null, null),
+                  ImmutableMap.of("const-key-4", "const-value-4"))))
+          .lookupService("bigtable-rls.googleapis.com")
+          .lookupServiceTimeoutInNanos(TimeUnit.SECONDS.toNanos(2))
+          .maxAgeInNanos(TimeUnit.SECONDS.toNanos(300))
+          .staleAgeInNanos(TimeUnit.SECONDS.toNanos(240))
+          .cacheSizeBytes(1000)
+          .defaultTarget("us_east_1.cloudbigtable.googleapis.com")
+          .build();
+
+  private final RlsRequestFactory factory = new RlsRequestFactory(
+      RLS_CONFIG, "bigtable.googleapis.com");
+
+  @Test
+  public void create_pathMatches() {
+    Metadata metadata = new Metadata();
+    metadata.put(Metadata.Key.of("User", Metadata.ASCII_STRING_MARSHALLER), "test");
+    metadata.put(Metadata.Key.of("X-Google-Id", Metadata.ASCII_STRING_MARSHALLER), "123");
+    metadata.put(Metadata.Key.of("foo", Metadata.ASCII_STRING_MARSHALLER), "bar");
+
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        factory.create("com.google.service1", "Create", metadata);
+    assertThat(routeLookupRequestKey.keyMap()).containsExactly(
+        "user", "test",
+        "id", "123",
+        "server-1", "bigtable.googleapis.com",
+        "const-key-1", "const-value-1");
+  }
+
+  @Test
+  public void create_pathFallbackMatches() {
+    Metadata metadata = new Metadata();
+    metadata.put(Metadata.Key.of("Parent", Metadata.ASCII_STRING_MARSHALLER), "test");
+    metadata.put(Metadata.Key.of("Password", Metadata.ASCII_STRING_MARSHALLER), "hunter2");
+    metadata.put(Metadata.Key.of("foo", Metadata.ASCII_STRING_MARSHALLER), "bar");
+
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        factory.create("com.google.service1" , "Update", metadata);
+
+    assertThat(routeLookupRequestKey.keyMap()).containsExactly(
+        "user", "test",
+        "password", "hunter2",
+        "service-2", "com.google.service1",
+        "const-key-2", "const-value-2");
+  }
+
+  @Test
+  public void create_pathFallbackMatches_optionalHeaderMissing() {
+    Metadata metadata = new Metadata();
+    metadata.put(Metadata.Key.of("User", Metadata.ASCII_STRING_MARSHALLER), "test");
+    metadata.put(Metadata.Key.of("X-Google-Id", Metadata.ASCII_STRING_MARSHALLER), "123");
+    metadata.put(Metadata.Key.of("foo", Metadata.ASCII_STRING_MARSHALLER), "bar");
+
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        factory.create("com.google.service1", "Update", metadata);
+
+    assertThat(routeLookupRequestKey.keyMap()).containsExactly(
+        "user", "test",
+        "service-2", "com.google.service1",
+        "const-key-2", "const-value-2");
+  }
+
+  @Test
+  public void create_unknownPath() {
+    Metadata metadata = new Metadata();
+    metadata.put(Metadata.Key.of("User", Metadata.ASCII_STRING_MARSHALLER), "test");
+    metadata.put(Metadata.Key.of("X-Google-Id", Metadata.ASCII_STRING_MARSHALLER), "123");
+    metadata.put(Metadata.Key.of("foo", Metadata.ASCII_STRING_MARSHALLER), "bar");
+
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        factory.create("abc.def.service999", "Update", metadata);
+    assertThat(routeLookupRequestKey.keyMap()).isEmpty();
+  }
+
+  @Test
+  public void create_noMethodInRlsConfig() {
+    Metadata metadata = new Metadata();
+    metadata.put(Metadata.Key.of("User", Metadata.ASCII_STRING_MARSHALLER), "test");
+    metadata.put(Metadata.Key.of("X-Google-Id", Metadata.ASCII_STRING_MARSHALLER), "123");
+    metadata.put(Metadata.Key.of("foo", Metadata.ASCII_STRING_MARSHALLER), "bar");
+
+    RlsProtoData.RouteLookupRequestKey routeLookupRequestKey =
+        factory.create("com.google.service3", "Update", metadata);
+
+    assertThat(routeLookupRequestKey.keyMap()).containsExactly(
+        "user", "test", "const-key-4", "const-value-4");
+  }
+}
diff --git a/rls/src/test/java/io/grpc/rls/SubchannelStateManagerImplTest.java b/rls/src/test/java/io/grpc/rls/SubchannelStateManagerImplTest.java
new file mode 100644
index 00000000000..317d49448e5
--- /dev/null
+++ b/rls/src/test/java/io/grpc/rls/SubchannelStateManagerImplTest.java
@@ -0,0 +1,102 @@
+/*
+ * 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.rls;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.ConnectivityState;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class SubchannelStateManagerImplTest {
+
+  private SubchannelStateManager subchannelStateManager = new SubchannelStateManagerImpl();
+
+  @Test
+  public void getState_unknown() {
+    assertThat(subchannelStateManager.getState("unknown")).isNull();
+  }
+
+  @Test
+  public void getState_known() {
+    subchannelStateManager.updateState("known", ConnectivityState.TRANSIENT_FAILURE);
+
+    assertThat(subchannelStateManager.getState("known"))
+        .isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+  }
+
+  @Test
+  public void getState_shutdown_unregistersSubchannel() {
+    subchannelStateManager.updateState("known", ConnectivityState.TRANSIENT_FAILURE);
+
+    assertThat(subchannelStateManager.getState("known"))
+        .isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+
+    subchannelStateManager.updateState("known", ConnectivityState.SHUTDOWN);
+
+    assertThat(subchannelStateManager.getState("known")).isNull();
+  }
+
+  @Test
+  public void getAggregatedStatus_none() {
+    assertThat(subchannelStateManager.getAggregatedState())
+        .isEqualTo(ConnectivityState.IDLE);
+  }
+
+  @Test
+  public void getAggregatedStatus_single() {
+    for (ConnectivityState value : ConnectivityState.values()) {
+      if (value == ConnectivityState.SHUTDOWN) {
+        continue;
+      }
+      SubchannelStateManager stateManager = new SubchannelStateManagerImpl();
+
+      stateManager.updateState("foo", value);
+
+      assertThat(stateManager.getAggregatedState()).isEqualTo(value);
+    }
+  }
+
+  @Test
+  public void getAggregateState_multipleSubchannels() {
+    subchannelStateManager.updateState("channel1", ConnectivityState.TRANSIENT_FAILURE);
+    subchannelStateManager.updateState("channel2", ConnectivityState.READY);
+
+    assertThat(subchannelStateManager.getState("channel1"))
+        .isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+    assertThat(subchannelStateManager.getState("channel2"))
+        .isEqualTo(ConnectivityState.READY);
+
+    assertThat(subchannelStateManager.getAggregatedState())
+        .isEqualTo(ConnectivityState.READY);
+
+    subchannelStateManager.updateState("channel2", ConnectivityState.SHUTDOWN);
+
+    assertThat(subchannelStateManager.getAggregatedState())
+        .isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+
+    subchannelStateManager.updateState("channel1", ConnectivityState.CONNECTING);
+    assertThat(subchannelStateManager.getAggregatedState())
+        .isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+
+    subchannelStateManager.updateState("channel1", ConnectivityState.READY);
+    assertThat(subchannelStateManager.getAggregatedState())
+        .isEqualTo(ConnectivityState.READY);
+  }
+}
diff --git a/run-test-client.sh b/run-test-client.sh
index ddcf236de2d..b904148ae13 100755
--- a/run-test-client.sh
+++ b/run-test-client.sh
@@ -1,9 +1,11 @@
 #!/bin/bash -e
 cd "$(dirname "$0")"
-cat >&2 <<EOF
-Gradle is no longer run automatically. Make sure to run
-'./gradlew installDist -PskipCodegen=true' or
-'./gradlew :grpc-interop-testing:installDist -PskipCodegen=true' after any
-changes. -PskipCodegen=true is optional, but requires less setup.
+BIN="./interop-testing/build/install/grpc-interop-testing/bin/test-client"
+if [[ ! -e "$BIN" ]]; then
+  cat >&2 <<EOF
+Could not find binary. It can be built with:
+./gradlew :grpc-interop-testing:installDist -PskipCodegen=true
 EOF
-exec ./interop-testing/build/install/grpc-interop-testing/bin/test-client "$@"
+  exit 1
+fi
+exec "$BIN" "$@"
diff --git a/run-test-server.sh b/run-test-server.sh
index 487328adb29..a4da7261fcf 100755
--- a/run-test-server.sh
+++ b/run-test-server.sh
@@ -1,9 +1,11 @@
 #!/bin/bash -e
 cd "$(dirname "$0")"
-cat >&2 <<EOF
-Gradle is no longer run automatically. Make sure to run
-'./gradlew installDist -PskipCodegen=true' or
-'./gradlew :grpc-interop-testing:installDist -PskipCodegen=true' after any
-changes. -PskipCodegen=true is optional, but requires less setup.
+BIN="./interop-testing/build/install/grpc-interop-testing/bin/test-server"
+if [[ ! -e "$BIN" ]]; then
+  cat >&2 <<EOF
+Could not find binary. It can be built with:
+./gradlew :grpc-interop-testing:installDist -PskipCodegen=true
 EOF
-exec ./interop-testing/build/install/grpc-interop-testing/bin/test-server "$@"
+  exit 1
+fi
+exec "$BIN" "$@"
diff --git a/s2a/BUILD.bazel b/s2a/BUILD.bazel
new file mode 100644
index 00000000000..34387206ba5
--- /dev/null
+++ b/s2a/BUILD.bazel
@@ -0,0 +1,93 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "s2a_channel_pool",
+    srcs = glob([
+        "src/main/java/io/grpc/s2a/internal/channel/*.java",
+    ]),
+    deps = [
+        "//api",
+        "//core",
+        "//core:internal",
+        "//netty",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+        artifact("org.checkerframework:checker-qual"),
+        artifact("io.netty:netty-common"),
+        artifact("io.netty:netty-transport"),
+    ],
+)
+
+java_library(
+    name = "s2a_identity",
+    srcs = ["src/main/java/io/grpc/s2a/internal/handshaker/S2AIdentity.java"],
+    deps = [
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+        artifact("com.google.s2a.proto.v2:s2a-proto"),
+    ],
+)
+
+java_library(
+    name = "token_manager",
+    srcs = glob([
+        "src/main/java/io/grpc/s2a/internal/handshaker/tokenmanager/*.java",
+    ]),
+    deps = [
+        ":s2a_identity",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
+    ],
+)
+
+java_library(
+    name = "s2a_handshaker",
+    srcs = [
+        "src/main/java/io/grpc/s2a/internal/handshaker/ConnectionClosedException.java",
+        "src/main/java/io/grpc/s2a/internal/handshaker/GetAuthenticationMechanisms.java",
+        "src/main/java/io/grpc/s2a/internal/handshaker/ProtoUtil.java",
+        "src/main/java/io/grpc/s2a/internal/handshaker/S2AConnectionException.java",
+        "src/main/java/io/grpc/s2a/internal/handshaker/S2APrivateKeyMethod.java",
+        "src/main/java/io/grpc/s2a/internal/handshaker/S2AProtocolNegotiatorFactory.java",
+        "src/main/java/io/grpc/s2a/internal/handshaker/S2AStub.java",
+        "src/main/java/io/grpc/s2a/internal/handshaker/S2ATrustManager.java",
+        "src/main/java/io/grpc/s2a/internal/handshaker/SslContextFactory.java",
+    ],
+    deps = [
+        ":s2a_identity",
+        ":token_manager",
+        "//api",
+        "//core:internal",
+        "//netty",
+        "//stub",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+        artifact("com.google.s2a.proto.v2:s2a-proto"),
+        artifact("org.checkerframework:checker-qual"),
+        "@com_google_protobuf//:protobuf_java",
+        artifact("io.netty:netty-common"),
+        artifact("io.netty:netty-handler"),
+        artifact("io.netty:netty-transport"),
+    ],
+)
+
+java_library(
+    name = "s2a",
+    srcs = ["src/main/java/io/grpc/s2a/S2AChannelCredentials.java"],
+    visibility = ["//visibility:public"],
+    deps = [
+        ":s2a_channel_pool",
+        ":s2a_handshaker",
+        ":s2a_identity",
+        "//api",
+        "//core:internal",
+        "//netty",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+        artifact("org.checkerframework:checker-qual"),
+    ],
+)
diff --git a/s2a/build.gradle b/s2a/build.gradle
new file mode 100644
index 00000000000..c46993ec9c8
--- /dev/null
+++ b/s2a/build.gradle
@@ -0,0 +1,120 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "com.google.osdetector"
+    id "com.google.protobuf"
+    id "com.gradleup.shadow"
+    id "ru.vyarus.animalsniffer"
+}
+
+description = "gRPC: S2A"
+
+dependencies {
+    implementation libraries.s2a.proto
+    implementation 'org.checkerframework:checker-qual:3.49.5'
+
+    api project(':grpc-api')
+    implementation project(':grpc-stub'),
+            project(':grpc-protobuf'),
+            project(':grpc-core'),
+            libraries.protobuf.java,
+            libraries.guava.jre // JRE required by protobuf-java-util from grpclb
+    def nettyDependency = implementation project(':grpc-netty')
+
+    shadow configurations.implementation.getDependencies().minus(nettyDependency)
+    shadow project(path: ':grpc-netty-shaded', configuration: 'shadow')
+    
+    testImplementation project(':grpc-benchmarks'),
+            project(':grpc-testing'),
+            project(':grpc-testing-proto'),
+            testFixtures(project(':grpc-core')),
+            libraries.guava
+
+    testImplementation 'com.google.truth:truth:1.4.2'
+    testImplementation 'com.google.truth.extensions:truth-proto-extension:1.4.2' 
+    testImplementation libraries.guava.testlib
+
+    testRuntimeOnly libraries.netty.tcnative,
+            libraries.netty.tcnative.classes
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "linux-x86_64"
+        }
+    }
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "linux-aarch_64"
+        }
+    }
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "osx-x86_64"
+        }
+    }
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "osx-aarch_64"
+        }
+    }
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "windows-x86_64"
+        }
+    }
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+configureProtoCompilation()
+
+tasks.named("javadoc").configure {
+    exclude 'io/grpc/s2a/**'
+}
+
+tasks.named("jar").configure {
+    // Must use a different archiveClassifier to avoid conflicting with shadowJar
+    archiveClassifier = 'original'
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.s2a')
+    }
+}
+
+// We want to use grpc-netty-shaded instead of grpc-netty. But we also want our
+// source to work with Bazel, so we rewrite the code as part of the build.
+tasks.named("shadowJar").configure {
+    archiveClassifier = null
+    dependencies {
+        exclude(dependency {true})
+    }
+    relocate 'io.grpc.netty', 'io.grpc.netty.shaded.io.grpc.netty'
+    relocate 'io.netty', 'io.grpc.netty.shaded.io.netty'
+}
+
+plugins.withId('maven-publish') {
+publishing {
+    publications {
+        maven(MavenPublication) {
+            // We want this to throw an exception if it isn't working
+            def originalJar = artifacts.find { dep -> dep.classifier == 'original'}
+            artifacts.remove(originalJar)
+
+            pom.withXml {
+                def dependenciesNode = new Node(null, 'dependencies')
+                project.configurations.shadow.allDependencies.each { dep ->
+                    def dependencyNode = dependenciesNode.appendNode('dependency')
+                    dependencyNode.appendNode('groupId', dep.group)
+                    dependencyNode.appendNode('artifactId', dep.name)
+                    dependencyNode.appendNode('version', dep.version)
+                    dependencyNode.appendNode('scope', 'compile')
+                }
+                asNode().dependencies[0].replaceNode(dependenciesNode)
+            }
+        }
+    }
+}
+}
diff --git a/s2a/src/main/java/io/grpc/s2a/S2AChannelCredentials.java b/s2a/src/main/java/io/grpc/s2a/S2AChannelCredentials.java
new file mode 100644
index 00000000000..4be32475205
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/S2AChannelCredentials.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2024 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.s2a;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Strings.isNullOrEmpty;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import io.grpc.Channel;
+import io.grpc.ChannelCredentials;
+import io.grpc.ExperimentalApi;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.netty.InternalNettyChannelCredentials;
+import io.grpc.netty.InternalProtocolNegotiator;
+import io.grpc.s2a.internal.channel.S2AHandshakerServiceChannel;
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+import io.grpc.s2a.internal.handshaker.S2AProtocolNegotiatorFactory;
+import io.grpc.s2a.internal.handshaker.S2AStub;
+import javax.annotation.concurrent.NotThreadSafe;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+/**
+ * Configures gRPC to use S2A for transport security when establishing a secure channel. Only for
+ * use on the client side of a gRPC connection.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/11533")
+public final class S2AChannelCredentials {
+  /**
+   * Creates a channel credentials builder for establishing an S2A-secured connection.
+   *
+   * @param s2aAddress the address of the S2A server used to secure the connection.
+   * @param s2aChannelCredentials the credentials to be used when connecting to the S2A.
+   * @return a {@code S2AChannelCredentials.Builder} instance.
+   */
+  public static Builder newBuilder(String s2aAddress, ChannelCredentials s2aChannelCredentials) {
+    checkArgument(!isNullOrEmpty(s2aAddress), "S2A address must not be null or empty.");
+    checkNotNull(s2aChannelCredentials, "S2A channel credentials must not be null");
+    return new Builder(s2aAddress, s2aChannelCredentials);
+  }
+
+  /** Builds an {@code S2AChannelCredentials} instance. */
+  @NotThreadSafe
+  public static final class Builder {
+    private final String s2aAddress;
+    private final ChannelCredentials s2aChannelCredentials;
+    private @Nullable S2AIdentity localIdentity = null;
+    private @Nullable S2AStub stub = null;
+
+    Builder(String s2aAddress, ChannelCredentials s2aChannelCredentials) {
+      this.s2aAddress = s2aAddress;
+      this.s2aChannelCredentials = s2aChannelCredentials;
+    }
+
+    /**
+     * Sets the local identity of the client in the form of a SPIFFE ID. The client may set at most
+     * 1 local identity. If no local identity is specified, then the S2A chooses a default local
+     * identity, if one exists.
+     */
+    @CanIgnoreReturnValue
+    public Builder setLocalSpiffeId(String localSpiffeId) {
+      checkNotNull(localSpiffeId);
+      checkArgument(localIdentity == null, "localIdentity is already set.");
+      localIdentity = S2AIdentity.fromSpiffeId(localSpiffeId);
+      return this;
+    }
+
+    /**
+     * Sets the local identity of the client in the form of a hostname. The client may set at most 1
+     * local identity. If no local identity is specified, then the S2A chooses a default local
+     * identity, if one exists.
+     */
+    @CanIgnoreReturnValue
+    public Builder setLocalHostname(String localHostname) {
+      checkNotNull(localHostname);
+      checkArgument(localIdentity == null, "localIdentity is already set.");
+      localIdentity = S2AIdentity.fromHostname(localHostname);
+      return this;
+    }
+
+    /**
+     * Sets the local identity of the client in the form of a UID. The client may set at most 1
+     * local identity. If no local identity is specified, then the S2A chooses a default local
+     * identity, if one exists.
+     */
+    @CanIgnoreReturnValue
+    public Builder setLocalUid(String localUid) {
+      checkNotNull(localUid);
+      checkArgument(localIdentity == null, "localIdentity is already set.");
+      localIdentity = S2AIdentity.fromUid(localUid);
+      return this;
+    }
+
+    /**
+     * Sets the stub to use to communicate with S2A. This is only used for testing that the
+     * stream to S2A gets closed.
+     */
+    @VisibleForTesting
+    Builder setStub(S2AStub stub) {
+      checkNotNull(stub);
+      this.stub = stub;
+      return this;
+    }
+
+    public ChannelCredentials build() {
+      return InternalNettyChannelCredentials.create(buildProtocolNegotiatorFactory());
+    }
+
+    InternalProtocolNegotiator.ClientFactory buildProtocolNegotiatorFactory() {
+      ObjectPool<Channel> s2aChannelPool =
+          SharedResourcePool.forResource(
+              S2AHandshakerServiceChannel.getChannelResource(s2aAddress, s2aChannelCredentials));
+      checkNotNull(s2aChannelPool, "s2aChannelPool");
+      return S2AProtocolNegotiatorFactory.createClientFactory(localIdentity, s2aChannelPool, stub);
+    }
+  }
+
+  private S2AChannelCredentials() {}
+}
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/channel/S2AHandshakerServiceChannel.java b/s2a/src/main/java/io/grpc/s2a/internal/channel/S2AHandshakerServiceChannel.java
new file mode 100644
index 00000000000..8453268efc0
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/channel/S2AHandshakerServiceChannel.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2024 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.s2a.internal.channel;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import io.grpc.Channel;
+import io.grpc.ChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.internal.SharedResourceHolder.Resource;
+import io.grpc.netty.NettyChannelBuilder;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Provides APIs for managing gRPC channels to an S2A server. Each channel is local and plaintext.
+ * If credentials are provided, they are used to secure the channel.
+ *
+ * <p>This is done as follows: for an S2A server, provides an implementation of gRPC's {@link
+ * SharedResourceHolder.Resource} interface called a {@code Resource<Channel>}. A {@code
+ * Resource<Channel>} is a factory for creating gRPC channels to the S2A server at a given address,
+ * and a channel must be returned to the {@code Resource<Channel>} when it is no longer needed.
+ *
+ * <p>Typical usage pattern is below:
+ *
+ * <pre>{@code
+ * Resource<Channel> resource = S2AHandshakerServiceChannel.getChannelResource("localhost:1234",
+ * creds);
+ * Channel channel = resource.create();
+ * // Send an RPC over the channel to the S2A server running at localhost:1234.
+ * resource.close(channel);
+ * }</pre>
+ */
+@ThreadSafe
+public final class S2AHandshakerServiceChannel {
+
+  /**
+   * Returns a {@link SharedResourceHolder.Resource} instance for managing channels to an S2A server
+   * running at {@code s2aAddress}.
+   *
+   * @param s2aAddress the address of the S2A, typically in the format {@code host:port}.
+   * @param s2aChannelCredentials the credentials to use when establishing a connection to the S2A.
+   * @return a {@link ChannelResource} instance that manages a {@link Channel} to the S2A server
+   *     running at {@code s2aAddress}.
+   */
+  public static Resource<Channel> getChannelResource(
+      String s2aAddress, ChannelCredentials s2aChannelCredentials) {
+    checkNotNull(s2aAddress);
+    return new ChannelResource(s2aAddress, s2aChannelCredentials);
+  }
+
+  /**
+   * Defines how to create and destroy a {@link Channel} instance that uses shared resources. A
+   * channel created by {@code ChannelResource} is a plaintext, local channel to the service running
+   * at {@code targetAddress}.
+   */
+  private static class ChannelResource implements Resource<Channel> {
+    private final String targetAddress;
+    private final ChannelCredentials channelCredentials;
+
+    public ChannelResource(String targetAddress, ChannelCredentials channelCredentials) {
+      this.targetAddress = targetAddress;
+      this.channelCredentials = channelCredentials;
+    }
+
+    /**
+     * Creates a {@code ManagedChannel} instance to the service running at {@code
+     * targetAddress}.
+     */
+    @Override
+    public Channel create() {
+      return NettyChannelBuilder.forTarget(targetAddress, channelCredentials)
+              .directExecutor()
+              .idleTimeout(5, SECONDS)
+              .build();
+    }
+
+    /** Destroys a {@code ManagedChannel} instance. */
+    @Override
+    public void close(Channel instanceChannel) {
+      checkNotNull(instanceChannel);
+      ManagedChannel channel = (ManagedChannel) instanceChannel;
+      channel.shutdownNow();
+    }
+
+    @Override
+    public String toString() {
+      return "grpc-s2a-channel";
+    }
+  }
+
+  private S2AHandshakerServiceChannel() {}
+}
\ No newline at end of file
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/handshaker/ConnectionClosedException.java b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/ConnectionClosedException.java
new file mode 100644
index 00000000000..d6f1aa70f7c
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/ConnectionClosedException.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import java.io.IOException;
+
+/** Indicates that a connection has been closed. */
+@SuppressWarnings("serial") // This class is never serialized.
+final class ConnectionClosedException extends IOException {
+  public ConnectionClosedException(String errorMessage) {
+    super(errorMessage);
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/handshaker/GetAuthenticationMechanisms.java b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/GetAuthenticationMechanisms.java
new file mode 100644
index 00000000000..cf632418e66
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/GetAuthenticationMechanisms.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import com.google.errorprone.annotations.Immutable;
+import com.google.s2a.proto.v2.AuthenticationMechanism;
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+import io.grpc.s2a.internal.handshaker.tokenmanager.AccessTokenManager;
+import java.util.Optional;
+
+/** Retrieves the authentication mechanism for a given local identity. */
+@Immutable
+final class GetAuthenticationMechanisms {
+  static final Optional<AccessTokenManager> TOKEN_MANAGER = AccessTokenManager.create();
+
+  /**
+   * Retrieves the authentication mechanism for a given local identity.
+   *
+   * @param localIdentity the identity for which to fetch a token.
+   * @param tokenManager the token manager to use for fetching tokens.
+   * @return an {@link AuthenticationMechanism} for the given local identity.
+   */
+  static Optional<AuthenticationMechanism> getAuthMechanism(Optional<S2AIdentity> localIdentity,
+      Optional<AccessTokenManager> tokenManager) {
+    if (!tokenManager.isPresent()) {
+      return Optional.empty();
+    }
+    AccessTokenManager manager = tokenManager.get();
+    // If no identity is provided, fetch the default access token and DO NOT attach an identity
+    // to the request.
+    if (!localIdentity.isPresent()) {
+      return Optional.of(
+              AuthenticationMechanism.newBuilder().setToken(manager.getDefaultToken()).build());
+    } else {
+      // Fetch an access token for the provided identity.
+      return Optional.of(
+              AuthenticationMechanism.newBuilder()
+                  .setIdentity(localIdentity.get().getIdentity())
+                  .setToken(manager.getToken(localIdentity.get()))
+                  .build());
+    }
+  }
+
+  private GetAuthenticationMechanisms() {}
+}
\ No newline at end of file
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/handshaker/ProtoUtil.java b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/ProtoUtil.java
new file mode 100644
index 00000000000..0526ec154f9
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/ProtoUtil.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableSet;
+import com.google.s2a.proto.v2.TLSVersion;
+
+/** Converts proto messages to Netty strings. */
+final class ProtoUtil {
+
+  /**
+   * Converts a {@link TLSVersion} object to its {@link String} representation.
+   *
+   * @param tlsVersion the {@link TLSVersion} object to be converted.
+   * @return a {@link String} representation of the TLS version.
+   * @throws IllegalArgumentException if the {@code tlsVersion} is not one of
+   *     the supported TLS versions.
+   */
+  @VisibleForTesting
+  static String convertTlsProtocolVersion(TLSVersion tlsVersion) {
+    switch (tlsVersion) {
+      case TLS_VERSION_1_3:
+        return "TLSv1.3";
+      case TLS_VERSION_1_2:
+        return "TLSv1.2";
+      case TLS_VERSION_1_1:
+        return "TLSv1.1";
+      case TLS_VERSION_1_0:
+        return "TLSv1";
+      default:
+        throw new IllegalArgumentException(
+            String.format("TLS version %d is not supported.", tlsVersion.getNumber()));
+    }
+  }
+
+  /**
+   * Builds a set of strings representing all {@link TLSVersion}s between {@code minTlsVersion} and
+   * {@code maxTlsVersion}.
+   */
+  static ImmutableSet<String> buildTlsProtocolVersionSet(
+      TLSVersion minTlsVersion, TLSVersion maxTlsVersion) {
+    ImmutableSet.Builder<String> tlsVersions = ImmutableSet.<String>builder();
+    for (TLSVersion tlsVersion : TLSVersion.values()) {
+      int versionNumber;
+      try {
+        versionNumber = tlsVersion.getNumber();
+      } catch (IllegalArgumentException e) {
+        continue;
+      }
+      if (versionNumber >= minTlsVersion.getNumber()
+          && versionNumber <= maxTlsVersion.getNumber()) {
+        try {
+          tlsVersions.add(convertTlsProtocolVersion(tlsVersion));
+        } catch (IllegalArgumentException e) {
+          continue;
+        }
+      }
+    }
+    return tlsVersions.build();
+  }
+
+  private ProtoUtil() {}
+}
\ No newline at end of file
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2AConnectionException.java b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2AConnectionException.java
new file mode 100644
index 00000000000..9b6c244751b
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2AConnectionException.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+/** Exception that denotes a runtime error that was encountered when talking to the S2A server. */
+@SuppressWarnings("serial") // This class is never serialized.
+public class S2AConnectionException extends RuntimeException {
+  S2AConnectionException(String message) {
+    super(message);
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2AIdentity.java b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2AIdentity.java
new file mode 100644
index 00000000000..f4d6b88ce45
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2AIdentity.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.errorprone.annotations.ThreadSafe;
+import com.google.s2a.proto.v2.Identity;
+
+/**
+ * Stores an identity in such a way that it can be sent to the S2A handshaker service. The identity
+ * may be formatted as a SPIFFE ID or as a hostname.
+ */
+@ThreadSafe
+public final class S2AIdentity {
+  private final Identity identity;
+
+  /** Returns an {@link S2AIdentity} instance with SPIFFE ID set to {@code spiffeId}. */
+  public static S2AIdentity fromSpiffeId(String spiffeId) {
+    checkNotNull(spiffeId);
+    return new S2AIdentity(Identity.newBuilder().setSpiffeId(spiffeId).build());
+  }
+
+  /** Returns an {@link S2AIdentity} instance with hostname set to {@code hostname}. */
+  public static S2AIdentity fromHostname(String hostname) {
+    checkNotNull(hostname);
+    return new S2AIdentity(Identity.newBuilder().setHostname(hostname).build());
+  }
+
+  /** Returns an {@link S2AIdentity} instance with UID set to {@code uid}. */
+  public static S2AIdentity fromUid(String uid) {
+    checkNotNull(uid);
+    return new S2AIdentity(Identity.newBuilder().setUid(uid).build());
+  }
+
+  /** Returns an {@link S2AIdentity} instance with {@code identity} set. */
+  public static S2AIdentity fromIdentity(Identity identity) {
+    return new S2AIdentity(identity == null ? Identity.getDefaultInstance() : identity);
+  }
+
+  private S2AIdentity(Identity identity) {
+    this.identity = identity;
+  }
+
+  /** Returns the proto {@link Identity} representation of this identity instance. */
+  public Identity getIdentity() {
+    return identity;
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2APrivateKeyMethod.java b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2APrivateKeyMethod.java
new file mode 100644
index 00000000000..1a5c37eb989
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2APrivateKeyMethod.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.ByteString;
+import com.google.s2a.proto.v2.OffloadPrivateKeyOperationReq;
+import com.google.s2a.proto.v2.SessionReq;
+import com.google.s2a.proto.v2.SessionResp;
+import com.google.s2a.proto.v2.SignatureAlgorithm;
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+import io.netty.handler.ssl.OpenSslPrivateKeyMethod;
+import java.io.IOException;
+import java.util.Optional;
+import javax.annotation.concurrent.NotThreadSafe;
+import javax.net.ssl.SSLEngine;
+
+/**
+ * Handles requests on signing bytes with a private key designated by {@code stub}.
+ *
+ * <p>This is done by sending the to-be-signed bytes to an S2A server (designated by {@code stub})
+ * and read the signature from the server.
+ *
+ * <p>OpenSSL libraries must be appropriately initialized before using this class. One possible way
+ * to initialize OpenSSL library is to call {@code
+ * GrpcSslContexts.configure(SslContextBuilder.forClient());}.
+ */
+@NotThreadSafe
+final class S2APrivateKeyMethod implements OpenSslPrivateKeyMethod {
+  private final S2AStub stub;
+  private final Optional<S2AIdentity> localIdentity;
+  private static final ImmutableMap<Integer, SignatureAlgorithm>
+      OPENSSL_TO_S2A_SIGNATURE_ALGORITHM_MAP =
+          ImmutableMap.of(
+              OpenSslPrivateKeyMethod.SSL_SIGN_RSA_PKCS1_SHA256,
+              SignatureAlgorithm.S2A_SSL_SIGN_RSA_PKCS1_SHA256,
+              OpenSslPrivateKeyMethod.SSL_SIGN_RSA_PKCS1_SHA384,
+              SignatureAlgorithm.S2A_SSL_SIGN_RSA_PKCS1_SHA384,
+              OpenSslPrivateKeyMethod.SSL_SIGN_RSA_PKCS1_SHA512,
+              SignatureAlgorithm.S2A_SSL_SIGN_RSA_PKCS1_SHA512,
+              OpenSslPrivateKeyMethod.SSL_SIGN_ECDSA_SECP256R1_SHA256,
+              SignatureAlgorithm.S2A_SSL_SIGN_ECDSA_SECP256R1_SHA256,
+              OpenSslPrivateKeyMethod.SSL_SIGN_ECDSA_SECP384R1_SHA384,
+              SignatureAlgorithm.S2A_SSL_SIGN_ECDSA_SECP384R1_SHA384,
+              OpenSslPrivateKeyMethod.SSL_SIGN_ECDSA_SECP521R1_SHA512,
+              SignatureAlgorithm.S2A_SSL_SIGN_ECDSA_SECP521R1_SHA512,
+              OpenSslPrivateKeyMethod.SSL_SIGN_RSA_PSS_RSAE_SHA256,
+              SignatureAlgorithm.S2A_SSL_SIGN_RSA_PSS_RSAE_SHA256,
+              OpenSslPrivateKeyMethod.SSL_SIGN_RSA_PSS_RSAE_SHA384,
+              SignatureAlgorithm.S2A_SSL_SIGN_RSA_PSS_RSAE_SHA384,
+              OpenSslPrivateKeyMethod.SSL_SIGN_RSA_PSS_RSAE_SHA512,
+              SignatureAlgorithm.S2A_SSL_SIGN_RSA_PSS_RSAE_SHA512);
+
+  public static S2APrivateKeyMethod create(S2AStub stub, Optional<S2AIdentity> localIdentity) {
+    checkNotNull(stub);
+    return new S2APrivateKeyMethod(stub, localIdentity);
+  }
+
+  private S2APrivateKeyMethod(S2AStub stub, Optional<S2AIdentity> localIdentity) {
+    this.stub = stub;
+    this.localIdentity = localIdentity;
+  }
+
+  /**
+   * Converts the signature algorithm to an enum understood by S2A.
+   *
+   * @param signatureAlgorithm the int representation of the signature algorithm define by {@code
+   *     OpenSslPrivateKeyMethod}.
+   * @return the signature algorithm enum defined by S2A proto.
+   * @throws UnsupportedOperationException if the algorithm is not supported by S2A.
+   */
+  @VisibleForTesting
+  static SignatureAlgorithm convertOpenSslSignAlgToS2ASignAlg(int signatureAlgorithm) {
+    SignatureAlgorithm sig = OPENSSL_TO_S2A_SIGNATURE_ALGORITHM_MAP.get(signatureAlgorithm);
+    if (sig == null) {
+      throw new UnsupportedOperationException(
+          String.format("Signature Algorithm %d is not supported.", signatureAlgorithm));
+    }
+    return sig;
+  }
+
+  /**
+   * Signs the input bytes by sending the request to the S2A srever.
+   *
+   * @param engine not used.
+   * @param signatureAlgorithm the {@link OpenSslPrivateKeyMethod}'s signature algorithm
+   *     representation
+   * @param input the bytes to be signed.
+   * @return the signature of the {@code input}.
+   * @throws IOException if the connection to the S2A server is corrupted.
+   * @throws InterruptedException if the connection to the S2A server is interrupted.
+   * @throws S2AConnectionException if the response from the S2A server does not contain valid data.
+   */
+  @Override
+  public byte[] sign(SSLEngine engine, int signatureAlgorithm, byte[] input)
+      throws IOException, InterruptedException {
+    checkArgument(input.length > 0, "No bytes to sign.");
+    SignatureAlgorithm s2aSignatureAlgorithm =
+        convertOpenSslSignAlgToS2ASignAlg(signatureAlgorithm);
+    SessionReq.Builder reqBuilder =
+        SessionReq.newBuilder()
+            .setOffloadPrivateKeyOperationReq(
+                OffloadPrivateKeyOperationReq.newBuilder()
+                    .setOperation(OffloadPrivateKeyOperationReq.PrivateKeyOperation.SIGN)
+                    .setSignatureAlgorithm(s2aSignatureAlgorithm)
+                    .setRawBytes(ByteString.copyFrom(input)));
+    if (localIdentity.isPresent()) {
+      reqBuilder.setLocalIdentity(localIdentity.get().getIdentity());
+    }
+
+    SessionResp resp = stub.send(reqBuilder.build());
+
+    if (resp.hasStatus() && resp.getStatus().getCode() != 0) {
+      throw new S2AConnectionException(
+          String.format(
+              "Error occurred in response from S2A, error code: %d, error message: \"%s\".",
+              resp.getStatus().getCode(), resp.getStatus().getDetails()));
+    }
+    if (!resp.hasOffloadPrivateKeyOperationResp()) {
+      throw new S2AConnectionException("No valid response received from S2A.");
+    }
+    return resp.getOffloadPrivateKeyOperationResp().getOutBytes().toByteArray();
+  }
+
+  @Override
+  public byte[] decrypt(SSLEngine engine, byte[] input) {
+    throw new UnsupportedOperationException("decrypt is not supported.");
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2AProtocolNegotiatorFactory.java b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2AProtocolNegotiatorFactory.java
new file mode 100644
index 00000000000..9dcbdcf0509
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2AProtocolNegotiatorFactory.java
@@ -0,0 +1,282 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Strings.isNullOrEmpty;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.net.HostAndPort;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.errorprone.annotations.ThreadSafe;
+import com.google.s2a.proto.v2.S2AServiceGrpc;
+import io.grpc.Channel;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.netty.GrpcHttp2ConnectionHandler;
+import io.grpc.netty.InternalProtocolNegotiator;
+import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
+import io.grpc.netty.InternalProtocolNegotiators;
+import io.grpc.netty.InternalProtocolNegotiators.ProtocolNegotiationHandler;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerAdapter;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.handler.ssl.SslContext;
+import io.netty.util.AsciiString;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.Executors;
+import javax.annotation.Nullable;
+
+/** Factory for performing negotiation of a secure channel using the S2A. */
+@ThreadSafe
+public final class S2AProtocolNegotiatorFactory {
+  @VisibleForTesting static final int DEFAULT_PORT = 443;
+  private static final AsciiString SCHEME = AsciiString.of("https");
+
+  /**
+   * Creates a {@code S2AProtocolNegotiatorFactory} configured for a client to establish secure
+   * connections using the S2A.
+   *
+   * @param localIdentity the identity of the client; if none is provided, the S2A will use the
+   *     client's default identity.
+   * @param s2aChannelPool a pool of shared channels that can be used to connect to the S2A.
+   * @param stub the stub to use to communicate with S2A. If none is provided the channelPool
+   *     will be used to create the stub. This is exposed for verifying the stream to S2A gets
+   *     closed in tests.
+   * @return a factory for creating a client-side protocol negotiator.
+   */
+  public static InternalProtocolNegotiator.ClientFactory createClientFactory(
+      @Nullable S2AIdentity localIdentity, ObjectPool<Channel> s2aChannelPool,
+      @Nullable S2AStub stub) {
+    checkNotNull(s2aChannelPool, "S2A channel pool should not be null.");
+    return new S2AClientProtocolNegotiatorFactory(localIdentity, s2aChannelPool, stub);
+  }
+
+  static final class S2AClientProtocolNegotiatorFactory
+      implements InternalProtocolNegotiator.ClientFactory {
+    private final @Nullable S2AIdentity localIdentity;
+    private final ObjectPool<Channel> channelPool;
+    private final @Nullable S2AStub stub;
+
+    S2AClientProtocolNegotiatorFactory(
+        @Nullable S2AIdentity localIdentity, ObjectPool<Channel> channelPool,
+        @Nullable S2AStub stub) {
+      this.localIdentity = localIdentity;
+      this.channelPool = channelPool;
+      this.stub = stub;
+    }
+
+    @Override
+    public ProtocolNegotiator newNegotiator() {
+      return S2AProtocolNegotiator.createForClient(channelPool, localIdentity, stub);
+    }
+
+    @Override
+    public int getDefaultPort() {
+      return DEFAULT_PORT;
+    }
+  }
+
+  /** Negotiates the TLS handshake using S2A. */
+  @VisibleForTesting
+  static final class S2AProtocolNegotiator implements ProtocolNegotiator {
+
+    private final ObjectPool<Channel> channelPool;
+    private @Nullable Channel channel = null;
+    private final Optional<S2AIdentity> localIdentity;
+    private final @Nullable S2AStub stub;
+    private final ListeningExecutorService service =
+        MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(1));
+
+    static S2AProtocolNegotiator createForClient(
+        ObjectPool<Channel> channelPool, @Nullable S2AIdentity localIdentity,
+        @Nullable S2AStub stub) {
+      checkNotNull(channelPool, "Channel pool should not be null.");
+      if (localIdentity == null) {
+        return new S2AProtocolNegotiator(channelPool, Optional.empty(), stub);
+      } else {
+        return new S2AProtocolNegotiator(channelPool, Optional.of(localIdentity), stub);
+      }
+    }
+
+    @VisibleForTesting
+    static @Nullable String getHostNameFromAuthority(@Nullable String authority) {
+      if (authority == null) {
+        return null;
+      }
+      return HostAndPort.fromString(authority).getHost();
+    }
+
+    private S2AProtocolNegotiator(ObjectPool<Channel> channelPool,
+        Optional<S2AIdentity> localIdentity, @Nullable S2AStub stub) {
+      this.channelPool = channelPool;
+      this.localIdentity = localIdentity;
+      this.stub = stub;
+      if (this.stub == null) {
+        this.channel = channelPool.getObject();
+      }
+    }
+
+    @Override
+    public AsciiString scheme() {
+      return SCHEME;
+    }
+
+    @Override
+    public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+      checkNotNull(grpcHandler, "grpcHandler should not be null.");
+      String hostname = getHostNameFromAuthority(grpcHandler.getAuthority());
+      checkArgument(!isNullOrEmpty(hostname), "hostname should not be null or empty.");
+      return new S2AProtocolNegotiationHandler(
+          grpcHandler, channel, localIdentity, hostname, service, stub);
+    }
+
+    @Override
+    public void close() {
+      service.shutdown();
+      if (channel != null) {
+        channelPool.returnObject(channel);
+      }
+    }
+  }
+
+  @VisibleForTesting
+  static class BufferReadsHandler extends ChannelInboundHandlerAdapter {
+    private final List<Object> reads = new ArrayList<>();
+    private boolean readComplete;
+
+    public List<Object> getReads() {
+      return reads;
+    }
+
+    @Override
+    public void channelRead(ChannelHandlerContext unused, Object msg) {
+      reads.add(msg);
+    }
+
+    @Override
+    public void channelReadComplete(ChannelHandlerContext unused) {
+      readComplete = true;
+    }
+
+    @Override
+    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
+      for (Object msg : reads) {
+        super.channelRead(ctx, msg);
+      }
+      if (readComplete) {
+        super.channelReadComplete(ctx);
+      }
+    }
+  }
+
+  private static final class S2AProtocolNegotiationHandler extends ProtocolNegotiationHandler {
+    private final @Nullable Channel channel;
+    private final Optional<S2AIdentity> localIdentity;
+    private final String hostname;
+    private final GrpcHttp2ConnectionHandler grpcHandler;
+    private final ListeningExecutorService service;
+    private final @Nullable S2AStub stub;
+
+    private S2AProtocolNegotiationHandler(
+        GrpcHttp2ConnectionHandler grpcHandler,
+        Channel channel,
+        Optional<S2AIdentity> localIdentity,
+        String hostname,
+        ListeningExecutorService service,
+        @Nullable S2AStub stub) {
+      super(
+          // superclass (InternalProtocolNegotiators.ProtocolNegotiationHandler) expects 'next'
+          // handler but we don't have a next handler _yet_. So we "disable" superclass's behavior
+          // here and then manually add 'next' when we call fireProtocolNegotiationEvent()
+          new ChannelHandlerAdapter() {
+            @Override
+            public void handlerAdded(ChannelHandlerContext ctx) {
+              ctx.pipeline().remove(this);
+            }
+          },
+          grpcHandler.getNegotiationLogger());
+      this.grpcHandler = grpcHandler;
+      this.channel = channel;
+      this.localIdentity = localIdentity;
+      this.hostname = hostname;
+      checkNotNull(service, "service should not be null.");
+      this.service = service;
+      this.stub = stub;
+    }
+
+    @Override
+    protected void handlerAdded0(ChannelHandlerContext ctx) {
+      // Buffer all reads until the TLS Handler is added.
+      BufferReadsHandler bufferReads = new BufferReadsHandler();
+      ctx.pipeline().addBefore(ctx.name(), /* name= */ null, bufferReads);
+
+      S2AStub s2aStub;
+      if (this.stub == null) {
+        checkNotNull(channel, "Channel to S2A should not be null");
+        s2aStub = S2AStub.newInstance(S2AServiceGrpc.newStub(channel));
+      } else {
+        s2aStub = this.stub;
+      }
+
+      ListenableFuture<SslContext> sslContextFuture =
+          service.submit(() -> SslContextFactory.createForClient(s2aStub, hostname, localIdentity));
+      Futures.addCallback(
+          sslContextFuture,
+          new FutureCallback<SslContext>() {
+            @Override
+            public void onSuccess(SslContext sslContext) {
+              ChannelHandler handler =
+                  InternalProtocolNegotiators.tls(
+                          sslContext,
+                          SharedResourcePool.forResource(GrpcUtil.SHARED_CHANNEL_EXECUTOR),
+                          com.google.common.base.Optional.of(new Runnable() {
+                            @Override
+                            public void run() {
+                              s2aStub.close();
+                            }
+                          }),
+                          null, null)
+                      .newHandler(grpcHandler);
+
+              // Delegate the rest of the handshake to the TLS handler. and remove the 
+              // bufferReads handler.
+              ctx.pipeline().addAfter(ctx.name(), /* name= */ null, handler);
+              fireProtocolNegotiationEvent(ctx);
+              ctx.pipeline().remove(bufferReads);
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+              ctx.fireExceptionCaught(t);
+            }
+          },
+          service);
+    }
+  }
+
+  private S2AProtocolNegotiatorFactory() {}
+}
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2AStub.java b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2AStub.java
new file mode 100644
index 00000000000..fe2ec388fe4
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2AStub.java
@@ -0,0 +1,231 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Verify.verify;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.s2a.proto.v2.S2AServiceGrpc;
+import com.google.s2a.proto.v2.SessionReq;
+import com.google.s2a.proto.v2.SessionResp;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.util.Optional;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.concurrent.NotThreadSafe;
+
+/** Reads and writes messages to and from the S2A. */
+@NotThreadSafe
+public class S2AStub implements AutoCloseable {
+  private static final Logger logger = Logger.getLogger(S2AStub.class.getName());
+  private static final long HANDSHAKE_RPC_DEADLINE_SECS = 20;
+  private final StreamObserver<SessionResp> reader = new Reader();
+  private final BlockingQueue<Result> responses = new ArrayBlockingQueue<>(10);
+  private S2AServiceGrpc.S2AServiceStub serviceStub;
+  private StreamObserver<SessionReq> writer;
+  private boolean doneReading = false;
+  private boolean doneWriting = false;
+  private boolean isClosed = false;
+
+  @VisibleForTesting
+  public static S2AStub newInstance(S2AServiceGrpc.S2AServiceStub serviceStub) {
+    checkNotNull(serviceStub);
+    return new S2AStub(serviceStub);
+  }
+
+  @VisibleForTesting
+  static S2AStub newInstanceForTesting(StreamObserver<SessionReq> writer) {
+    checkNotNull(writer);
+    return new S2AStub(writer);
+  }
+
+  private S2AStub(S2AServiceGrpc.S2AServiceStub serviceStub) {
+    this.serviceStub = serviceStub;
+  }
+
+  private S2AStub(StreamObserver<SessionReq> writer) {
+    this.writer = writer;
+  }
+
+  @VisibleForTesting
+  StreamObserver<SessionResp> getReader() {
+    return reader;
+  }
+
+  @VisibleForTesting
+  BlockingQueue<Result> getResponses() {
+    return responses;
+  }
+
+  /**
+   * Sends a request and returns the response. Caller must wait until this method executes prior to
+   * calling it again. If this method throws {@code ConnectionClosedException}, then it should not
+   * be called again, and both {@code reader} and {@code writer} are closed.
+   *
+   * @param req the {@code SessionReq} message to be sent to the S2A server.
+   * @return the {@code SessionResp} message received from the S2A server.
+   * @throws ConnectionClosedException if {@code reader} or {@code writer} calls their {@code
+   *     onCompleted} method.
+   * @throws IOException if an unexpected response is received, or if the {@code reader} or {@code
+   *     writer} calls their {@code onError} method.
+   */
+  @SuppressWarnings("CheckReturnValue")
+  public SessionResp send(SessionReq req) throws IOException, InterruptedException {
+    if (doneWriting && doneReading) {
+      logger.log(Level.INFO, "Stream to the S2A is closed.");
+      throw new ConnectionClosedException("Stream to the S2A is closed.");
+    }
+    createWriterIfNull();
+    if (!responses.isEmpty()) {
+      IOException exception = null;
+      try {
+        responses.take().getResultOrThrow();
+      } catch (IOException e) {
+        exception = e;
+      }
+      responses.clear();
+      if (exception != null) {
+        throw new IOException(
+            "Received an unexpected response from a host at the S2A's address. The S2A might be"
+                + " unavailable.", exception);
+      } else {
+        throw new IOException("Received an unexpected response from a host at the S2A's address.");
+      }
+    }
+    try {
+      writer.onNext(req);
+    } catch (RuntimeException e) {
+      writer.onError(e);
+      responses.add(Result.createWithThrowable(e));
+    }
+    try {
+      return responses.take().getResultOrThrow();
+    } catch (ConnectionClosedException e) {
+      // A ConnectionClosedException is thrown by getResultOrThrow when reader calls its
+      // onCompleted method. The close method is called to also close the writer, and then the
+      // ConnectionClosedException is re-thrown in order to indicate to the caller that send
+      // should not be called again.
+      close();
+      throw e;
+    }
+  }
+
+  @Override
+  public void close() {
+    if (doneWriting && doneReading) {
+      return;
+    }
+    verify(!doneWriting);
+    doneReading = true;
+    doneWriting = true;
+    if (writer != null) {
+      writer.onCompleted();
+    }
+    isClosed = true;
+  }
+
+  public boolean isClosed() {
+    return isClosed;
+  }
+
+  /** Create a new writer if the writer is null. */
+  private void createWriterIfNull() {
+    if (writer == null) {
+      writer =
+          serviceStub
+              .withWaitForReady()
+              .withDeadlineAfter(HANDSHAKE_RPC_DEADLINE_SECS, SECONDS)
+              .setUpSession(reader);
+    }
+  }
+
+  private class Reader implements StreamObserver<SessionResp> {
+    /**
+     * Places a {@code SessionResp} message in the {@code responses} queue, or an {@code
+     * IOException} if reading is complete.
+     *
+     * @param resp the {@code SessionResp} message received from the S2A handshaker module.
+     */
+    @Override
+    public void onNext(SessionResp resp) {
+      verify(!doneReading);
+      responses.add(Result.createWithResponse(resp));
+    }
+
+    /**
+     * Places a {@code Throwable} in the {@code responses} queue.
+     *
+     * @param t the {@code Throwable} caught when reading the stream to the S2A handshaker module.
+     */
+    @Override
+    public void onError(Throwable t) {
+      responses.add(Result.createWithThrowable(t));
+    }
+
+    /**
+     * Sets {@code doneReading} to true, and places a {@code ConnectionClosedException} in the
+     * {@code responses} queue.
+     */
+    @Override
+    public void onCompleted() {
+      logger.log(Level.INFO, "Reading from the S2A is complete.");
+      doneReading = true;
+      responses.add(
+          Result.createWithThrowable(
+              new ConnectionClosedException("Reading from the S2A is complete.")));
+    }
+  }
+
+  private static final class Result {
+    private final Optional<SessionResp> response;
+    private final Optional<Throwable> throwable;
+
+    static Result createWithResponse(SessionResp response) {
+      return new Result(Optional.of(response), Optional.empty());
+    }
+
+    static Result createWithThrowable(Throwable throwable) {
+      return new Result(Optional.empty(), Optional.of(throwable));
+    }
+
+    private Result(Optional<SessionResp> response, Optional<Throwable> throwable) {
+      checkArgument(response.isPresent() != throwable.isPresent());
+      this.response = response;
+      this.throwable = throwable;
+    }
+
+    /** Throws {@code throwable} if present, and returns {@code response} otherwise. */
+    SessionResp getResultOrThrow() throws IOException {
+      if (throwable.isPresent()) {
+        if (throwable.get() instanceof ConnectionClosedException) {
+          ConnectionClosedException exception = (ConnectionClosedException) throwable.get();
+          throw exception;
+        } else {
+          throw new IOException(throwable.get());
+        }
+      }
+      verify(response.isPresent());
+      return response.get();
+    }
+  }
+}
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2ATrustManager.java b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2ATrustManager.java
new file mode 100644
index 00000000000..a7ffafd01f2
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/S2ATrustManager.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.ByteString;
+import com.google.s2a.proto.v2.SessionReq;
+import com.google.s2a.proto.v2.SessionResp;
+import com.google.s2a.proto.v2.ValidatePeerCertificateChainReq;
+import com.google.s2a.proto.v2.ValidatePeerCertificateChainReq.VerificationMode;
+import com.google.s2a.proto.v2.ValidatePeerCertificateChainResp;
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+import java.io.IOException;
+import java.security.cert.CertificateEncodingException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.Optional;
+import javax.annotation.concurrent.NotThreadSafe;
+import javax.net.ssl.X509TrustManager;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+/** Offloads verification of the peer certificate chain to S2A. */
+@NotThreadSafe
+final class S2ATrustManager implements X509TrustManager {
+  private final Optional<S2AIdentity> localIdentity;
+  private final S2AStub stub;
+  private final String hostname;
+
+  static S2ATrustManager createForClient(
+      S2AStub stub, String hostname, Optional<S2AIdentity> localIdentity) {
+    checkNotNull(stub);
+    checkNotNull(hostname);
+    return new S2ATrustManager(stub, hostname, localIdentity);
+  }
+
+  private S2ATrustManager(S2AStub stub, String hostname, Optional<S2AIdentity> localIdentity) {
+    this.stub = stub;
+    this.hostname = hostname;
+    this.localIdentity = localIdentity;
+  }
+
+  /**
+   * Validates the given certificate chain provided by the peer.
+   *
+   * @param chain the peer certificate chain
+   * @param authType the authentication type based on the client certificate
+   * @throws IllegalArgumentException if null or zero-length chain is passed in for the chain
+   *     parameter.
+   * @throws CertificateException if the certificate chain is not trusted by this TrustManager.
+   */
+  @Override
+  public void checkClientTrusted(X509Certificate[] chain, String authType)
+      throws CertificateException {
+    checkPeerTrusted(chain, /* isCheckingClientCertificateChain= */ true);
+  }
+
+  /**
+   * Validates the given certificate chain provided by the peer.
+   *
+   * @param chain the peer certificate chain
+   * @param authType the authentication type based on the client certificate
+   * @throws IllegalArgumentException if null or zero-length chain is passed in for the chain
+   *     parameter.
+   * @throws CertificateException if the certificate chain is not trusted by this TrustManager.
+   */
+  @Override
+  public void checkServerTrusted(X509Certificate[] chain, String authType)
+      throws CertificateException {
+    checkPeerTrusted(chain, /* isCheckingClientCertificateChain= */ false);
+  }
+
+  /**
+   * Returns null because the accepted issuers are held in S2A and this class receives decision made
+   * from S2A on the fly about which to use to verify a given chain.
+   *
+   * @return null.
+   */
+  @Override
+  public X509Certificate @Nullable [] getAcceptedIssuers() {
+    return null;
+  }
+
+  private void checkPeerTrusted(X509Certificate[] chain, boolean isCheckingClientCertificateChain)
+      throws CertificateException {
+    checkNotNull(chain);
+    checkArgument(chain.length > 0, "Certificate chain has zero certificates.");
+
+    ValidatePeerCertificateChainReq.Builder validatePeerCertificateChainReq =
+        ValidatePeerCertificateChainReq.newBuilder().setMode(VerificationMode.UNSPECIFIED);
+    if (isCheckingClientCertificateChain) {
+      validatePeerCertificateChainReq.setClientPeer(
+          ValidatePeerCertificateChainReq.ClientPeer.newBuilder()
+              .addAllCertificateChain(certificateChainToDerChain(chain)));
+    } else {
+      validatePeerCertificateChainReq.setServerPeer(
+          ValidatePeerCertificateChainReq.ServerPeer.newBuilder()
+              .addAllCertificateChain(certificateChainToDerChain(chain))
+              .setServerHostname(hostname));
+    }
+
+    SessionReq.Builder reqBuilder =
+        SessionReq.newBuilder().setValidatePeerCertificateChainReq(validatePeerCertificateChainReq);
+    if (localIdentity.isPresent()) {
+      reqBuilder.setLocalIdentity(localIdentity.get().getIdentity());
+    }
+
+    SessionResp resp;
+    try {
+      resp = stub.send(reqBuilder.build());
+    } catch (IOException e) {
+      throw new CertificateException("Failed to send request to S2A.", e);
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      throw new CertificateException("Failed to send request to S2A.", e);
+    }
+    if (resp.hasStatus() && resp.getStatus().getCode() != 0) {
+      throw new CertificateException(
+          String.format(
+              "Error occurred in response from S2A, error code: %d, error message: %s.",
+              resp.getStatus().getCode(), resp.getStatus().getDetails()));
+    }
+
+    if (!resp.hasValidatePeerCertificateChainResp()) {
+      throw new CertificateException("No valid response received from S2A.");
+    }
+
+    ValidatePeerCertificateChainResp validationResult = resp.getValidatePeerCertificateChainResp();
+    if (validationResult.getValidationResult()
+        != ValidatePeerCertificateChainResp.ValidationResult.SUCCESS) {
+      throw new CertificateException(validationResult.getValidationDetails());
+    }
+  }
+
+  private static ImmutableList<ByteString> certificateChainToDerChain(X509Certificate[] chain)
+      throws CertificateEncodingException {
+    ImmutableList.Builder<ByteString> derChain = ImmutableList.<ByteString>builder();
+    for (X509Certificate certificate : chain) {
+      derChain.add(ByteString.copyFrom(certificate.getEncoded()));
+    }
+    return derChain.build();
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/handshaker/SslContextFactory.java b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/SslContextFactory.java
new file mode 100644
index 00000000000..5d4ef9eb667
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/SslContextFactory.java
@@ -0,0 +1,187 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static java.nio.charset.StandardCharsets.UTF_8;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.s2a.proto.v2.AuthenticationMechanism;
+import com.google.s2a.proto.v2.ConnectionSide;
+import com.google.s2a.proto.v2.GetTlsConfigurationReq;
+import com.google.s2a.proto.v2.GetTlsConfigurationResp;
+import com.google.s2a.proto.v2.SessionReq;
+import com.google.s2a.proto.v2.SessionResp;
+import io.grpc.netty.GrpcSslContexts;
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+import io.netty.handler.ssl.OpenSslContextOption;
+import io.netty.handler.ssl.OpenSslSessionContext;
+import io.netty.handler.ssl.OpenSslX509KeyManagerFactory;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslContextBuilder;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.UnrecoverableKeyException;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.util.Optional;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.SSLSessionContext;
+
+/** Creates {@link SslContext} objects with TLS configurations from S2A server. */
+final class SslContextFactory {
+
+  /**
+   * Creates {@link SslContext} objects for client with TLS configurations from S2A server.
+   *
+   * @param stub the {@link S2AStub} to talk to the S2A server.
+   * @param targetName the {@link String} of the server that this client makes connection to.
+   * @param localIdentity the {@link S2AIdentity} that should be used when talking to S2A server.
+   *     Will use default identity if empty.
+   * @return a {@link SslContext} object.
+   * @throws NullPointerException if either {@code stub} or {@code targetName} is null.
+   * @throws IOException if an unexpected response from S2A server is received.
+   * @throws InterruptedException if {@code stub} is closed.
+   */
+  static SslContext createForClient(
+      S2AStub stub, String targetName, Optional<S2AIdentity> localIdentity)
+      throws IOException,
+          InterruptedException,
+          CertificateException,
+          KeyStoreException,
+          NoSuchAlgorithmException,
+          UnrecoverableKeyException,
+          GeneralSecurityException {
+    checkNotNull(stub, "stub should not be null.");
+    checkNotNull(targetName, "targetName should not be null on client side.");
+    GetTlsConfigurationResp.ClientTlsConfiguration clientTlsConfiguration;
+    try {
+      clientTlsConfiguration = getClientTlsConfigurationFromS2A(stub, localIdentity);
+    } catch (IOException | InterruptedException e) {
+      throw new GeneralSecurityException("Failed to get client TLS configuration from S2A.", e);
+    }
+
+    // Use the default value for timeout.
+    // Use the smallest possible value for cache size.
+    // The Provider is by default OPENSSL. No need to manually set it.
+    SslContextBuilder sslContextBuilder =
+        GrpcSslContexts.configure(SslContextBuilder.forClient())
+            .sessionCacheSize(1)
+            .sessionTimeout(0);
+
+    configureSslContextWithClientTlsConfiguration(clientTlsConfiguration, sslContextBuilder);
+    sslContextBuilder.trustManager(
+        S2ATrustManager.createForClient(stub, targetName, localIdentity));
+    sslContextBuilder.option(
+        OpenSslContextOption.PRIVATE_KEY_METHOD, S2APrivateKeyMethod.create(stub, localIdentity));
+
+    SslContext sslContext = sslContextBuilder.build();
+    SSLSessionContext sslSessionContext = sslContext.sessionContext();
+    if (sslSessionContext instanceof OpenSslSessionContext) {
+      OpenSslSessionContext openSslSessionContext = (OpenSslSessionContext) sslSessionContext;
+      openSslSessionContext.setSessionCacheEnabled(false);
+    }
+
+    return sslContext;
+  }
+
+  private static GetTlsConfigurationResp.ClientTlsConfiguration getClientTlsConfigurationFromS2A(
+      S2AStub stub, Optional<S2AIdentity> localIdentity) throws IOException, InterruptedException {
+    checkNotNull(stub, "stub should not be null.");
+    SessionReq.Builder reqBuilder = SessionReq.newBuilder();
+    if (localIdentity.isPresent()) {
+      reqBuilder.setLocalIdentity(localIdentity.get().getIdentity());
+    }
+    Optional<AuthenticationMechanism> authMechanism =
+        GetAuthenticationMechanisms.getAuthMechanism(localIdentity,
+        GetAuthenticationMechanisms.TOKEN_MANAGER);
+    if (authMechanism.isPresent()) {
+      reqBuilder.addAuthenticationMechanisms(authMechanism.get());
+    }
+    SessionResp resp =
+        stub.send(
+            reqBuilder
+                .setGetTlsConfigurationReq(
+                    GetTlsConfigurationReq.newBuilder()
+                        .setConnectionSide(ConnectionSide.CONNECTION_SIDE_CLIENT))
+                .build());
+    if (resp.hasStatus() && resp.getStatus().getCode() != 0) {
+      throw new S2AConnectionException(
+          String.format(
+              "response from S2A server has ean error %d with error message %s.",
+              resp.getStatus().getCode(), resp.getStatus().getDetails()));
+    }
+    if (!resp.getGetTlsConfigurationResp().hasClientTlsConfiguration()) {
+      throw new S2AConnectionException(
+          "Response from S2A server does NOT contain ClientTlsConfiguration.");
+    }
+    return resp.getGetTlsConfigurationResp().getClientTlsConfiguration();
+  }
+
+  private static void configureSslContextWithClientTlsConfiguration(
+      GetTlsConfigurationResp.ClientTlsConfiguration clientTlsConfiguration,
+      SslContextBuilder sslContextBuilder)
+      throws CertificateException,
+          IOException,
+          KeyStoreException,
+          NoSuchAlgorithmException,
+          UnrecoverableKeyException {
+    sslContextBuilder.keyManager(createKeylessManager(clientTlsConfiguration));
+    ImmutableSet<String> tlsVersions;
+    tlsVersions =
+        ProtoUtil.buildTlsProtocolVersionSet(
+            clientTlsConfiguration.getMinTlsVersion(), clientTlsConfiguration.getMaxTlsVersion());
+    if (tlsVersions.isEmpty()) {
+      throw new S2AConnectionException(
+          "Set of TLS versions received from S2A server is empty or not supported.");
+    }
+    sslContextBuilder.protocols(tlsVersions);
+  }
+
+  private static KeyManager createKeylessManager(
+      GetTlsConfigurationResp.ClientTlsConfiguration clientTlsConfiguration)
+      throws CertificateException,
+          IOException,
+          KeyStoreException,
+          NoSuchAlgorithmException,
+          UnrecoverableKeyException {
+    X509Certificate[] certificates =
+        new X509Certificate[clientTlsConfiguration.getCertificateChainCount()];
+    for (int i = 0; i < clientTlsConfiguration.getCertificateChainCount(); ++i) {
+      certificates[i] = convertStringToX509Cert(clientTlsConfiguration.getCertificateChain(i));
+    }
+    KeyManager[] keyManagers =
+        OpenSslX509KeyManagerFactory.newKeyless(certificates).getKeyManagers();
+    if (keyManagers == null || keyManagers.length == 0) {
+      throw new IllegalStateException("No key managers created.");
+    }
+    return keyManagers[0];
+  }
+
+  private static X509Certificate convertStringToX509Cert(String certificate)
+      throws CertificateException {
+    return (X509Certificate)
+        CertificateFactory.getInstance("X509")
+            .generateCertificate(new ByteArrayInputStream(certificate.getBytes(UTF_8)));
+  }
+
+  private SslContextFactory() {}
+}
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/handshaker/tokenmanager/AccessTokenManager.java b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/tokenmanager/AccessTokenManager.java
new file mode 100644
index 00000000000..65fca46bbb2
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/tokenmanager/AccessTokenManager.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker.tokenmanager;
+
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+import java.util.Optional;
+import javax.annotation.concurrent.ThreadSafe;
+
+/** Manages access tokens for authenticating to the S2A. */
+@ThreadSafe
+public final class AccessTokenManager {
+  private final TokenFetcher tokenFetcher;
+
+  /** Creates an {@code AccessTokenManager} based on the environment where the application runs. */
+  public static Optional<AccessTokenManager> create() {
+    Optional<TokenFetcher> tokenFetcher = SingleTokenFetcher.create();
+    return tokenFetcher.isPresent()
+        ? Optional.of(new AccessTokenManager(tokenFetcher.get()))
+        : Optional.empty();
+  }
+
+  private AccessTokenManager(TokenFetcher tokenFetcher) {
+    this.tokenFetcher = tokenFetcher;
+  }
+
+  /** Returns an access token when no identity is specified. */
+  public String getDefaultToken() {
+    return tokenFetcher.getDefaultToken();
+  }
+
+  /** Returns an access token for the given identity. */
+  public String getToken(S2AIdentity identity) {
+    return tokenFetcher.getToken(identity);
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/handshaker/tokenmanager/SingleTokenFetcher.java b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/tokenmanager/SingleTokenFetcher.java
new file mode 100644
index 00000000000..28aa0f87ba1
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/tokenmanager/SingleTokenFetcher.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker.tokenmanager;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+import java.util.Optional;
+
+/** Fetches a single access token via an environment variable. */
+@SuppressWarnings("NonFinalStaticField")
+public final class SingleTokenFetcher implements TokenFetcher {
+  private static final String ENVIRONMENT_VARIABLE = "S2A_ACCESS_TOKEN";
+  private static String accessToken = System.getenv(ENVIRONMENT_VARIABLE);
+
+  private final String token;
+
+  /**
+   * Creates a {@code SingleTokenFetcher} from {@code ENVIRONMENT_VARIABLE}, and returns an empty
+   * {@code Optional} instance if the token could not be fetched.
+   */
+  public static Optional<TokenFetcher> create() {
+    return Optional.ofNullable(accessToken).map(SingleTokenFetcher::new);
+  }
+
+  @VisibleForTesting
+  public static void setAccessToken(String token) {
+    accessToken = token;
+  }
+
+  @VisibleForTesting
+  public static String getAccessToken() {
+    return accessToken;
+  }
+
+  private SingleTokenFetcher(String token) {
+    this.token = token;
+  }
+
+  @Override
+  public String getDefaultToken() {
+    return token;
+  }
+
+  @Override
+  public String getToken(S2AIdentity identity) {
+    return token;
+  }
+}
diff --git a/s2a/src/main/java/io/grpc/s2a/internal/handshaker/tokenmanager/TokenFetcher.java b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/tokenmanager/TokenFetcher.java
new file mode 100644
index 00000000000..6827f095afe
--- /dev/null
+++ b/s2a/src/main/java/io/grpc/s2a/internal/handshaker/tokenmanager/TokenFetcher.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker.tokenmanager;
+
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+
+/** Fetches tokens used to authenticate to S2A. */
+interface TokenFetcher {
+  /** Returns an access token when no identity is specified. */
+  String getDefaultToken();
+
+  /** Returns an access token for the given identity. */  
+  String getToken(S2AIdentity identity);
+}
\ No newline at end of file
diff --git a/s2a/src/test/java/io/grpc/s2a/IntegrationTest.java b/s2a/src/test/java/io/grpc/s2a/IntegrationTest.java
new file mode 100644
index 00000000000..1d3568808c6
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/IntegrationTest.java
@@ -0,0 +1,256 @@
+/*
+ * Copyright 2024 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.s2a;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import com.google.s2a.proto.v2.S2AServiceGrpc;
+import io.grpc.Channel;
+import io.grpc.ChannelCredentials;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCredentials;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.TlsServerCredentials;
+import io.grpc.benchmarks.Utils;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.netty.GrpcSslContexts;
+import io.grpc.netty.NettyServerBuilder;
+import io.grpc.s2a.S2AChannelCredentials;
+import io.grpc.s2a.internal.channel.S2AHandshakerServiceChannel;
+import io.grpc.s2a.internal.handshaker.FakeS2AServer;
+import io.grpc.s2a.internal.handshaker.S2AStub;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import io.netty.handler.ssl.ClientAuth;
+import io.netty.handler.ssl.OpenSslSessionContext;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslContextBuilder;
+import io.netty.handler.ssl.SslProvider;
+import java.io.InputStream;
+import java.util.concurrent.FutureTask;
+import java.util.logging.Logger;
+import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLSessionContext;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class IntegrationTest {
+  private static final Logger logger = Logger.getLogger(FakeS2AServer.class.getName());
+  private String s2aAddress;
+  private Server s2aServer;
+  private String s2aDelayAddress;
+  private Server s2aDelayServer;
+  private String mtlsS2AAddress;
+  private Server mtlsS2AServer;
+  private String serverAddress;
+  private Server server;
+
+  @Before
+  public void setUp() throws Exception {
+    s2aServer = ServerBuilder.forPort(0).addService(new FakeS2AServer()).build().start();
+    int s2aPort = s2aServer.getPort();
+    s2aAddress = "localhost:" + s2aPort;
+    logger.info("S2A service listening on localhost:" + s2aPort);
+    ClassLoader classLoader = IntegrationTest.class.getClassLoader();
+    InputStream s2aCert = classLoader.getResourceAsStream("server_cert.pem");
+    InputStream s2aKey = classLoader.getResourceAsStream("server_key.pem");
+    InputStream rootCert = classLoader.getResourceAsStream("root_cert.pem");
+    ServerCredentials s2aCreds =
+        TlsServerCredentials.newBuilder()
+            .keyManager(s2aCert, s2aKey)
+            .trustManager(rootCert)
+            .clientAuth(TlsServerCredentials.ClientAuth.REQUIRE)
+            .build();
+    mtlsS2AServer = NettyServerBuilder.forPort(0, s2aCreds).addService(new FakeS2AServer()).build();
+    mtlsS2AServer.start();
+    int mtlsS2APort = mtlsS2AServer.getPort();
+    mtlsS2AAddress = "localhost:" + mtlsS2APort;
+    logger.info("mTLS S2A service listening on localhost:" + mtlsS2APort);
+
+    int s2aDelayPort = Utils.pickUnusedPort();
+    s2aDelayAddress = "localhost:" + s2aDelayPort;
+    s2aDelayServer = ServerBuilder.forPort(s2aDelayPort).addService(new FakeS2AServer()).build();
+
+    server =
+        NettyServerBuilder.forPort(0)
+            .addService(new SimpleServiceImpl())
+            .sslContext(buildSslContext())
+            .build()
+            .start();
+    int serverPort = server.getPort();
+    serverAddress = "localhost:" + serverPort;
+    logger.info("Simple Service listening on localhost:" + serverPort);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    server.shutdown();
+    s2aServer.shutdown();
+    s2aDelayServer.shutdown();
+    mtlsS2AServer.shutdown();
+
+    server.awaitTermination(10, SECONDS);
+    s2aServer.awaitTermination(10, SECONDS);
+    s2aDelayServer.awaitTermination(10, SECONDS);
+    mtlsS2AServer.awaitTermination(10, SECONDS);
+  }
+
+  @Test
+  public void clientCommunicateUsingS2ACredentials_succeeds() throws Exception {
+    ChannelCredentials credentials =
+        S2AChannelCredentials.newBuilder(s2aAddress, InsecureChannelCredentials.create())
+            .setLocalSpiffeId("test-spiffe-id").build();
+    ManagedChannel channel = Grpc.newChannelBuilder(serverAddress, credentials).build();
+
+    assertThat(doUnaryRpc(channel)).isTrue();
+  }
+
+  @Test
+  public void clientCommunicateUsingS2ACredentialsNoLocalIdentity_succeeds() throws Exception {
+    ChannelCredentials credentials = S2AChannelCredentials.newBuilder(s2aAddress,
+        InsecureChannelCredentials.create()).build();
+    ManagedChannel channel = Grpc.newChannelBuilder(serverAddress, credentials).build();
+
+    assertThat(doUnaryRpc(channel)).isTrue();
+  }
+
+  @Test
+  public void clientCommunicateUsingS2ACredentialsSucceeds_verifyStreamToS2AClosed()
+      throws Exception {
+    ObjectPool<Channel> s2aChannelPool =
+          SharedResourcePool.forResource(
+              S2AHandshakerServiceChannel.getChannelResource(s2aAddress,
+              InsecureChannelCredentials.create()));
+    Channel ch = s2aChannelPool.getObject();
+    S2AStub stub = S2AStub.newInstance(S2AServiceGrpc.newStub(ch));
+    ChannelCredentials credentials =
+        S2AChannelCredentials.newBuilder(s2aAddress, InsecureChannelCredentials.create())
+            .setLocalSpiffeId("test-spiffe-id").setStub(stub).build();
+    ManagedChannel channel = Grpc.newChannelBuilder(serverAddress, credentials).build();
+
+    s2aChannelPool.returnObject(ch);
+    assertThat(doUnaryRpc(channel)).isTrue();
+    assertThat(stub.isClosed()).isTrue();
+  }
+
+  @Test
+  public void clientCommunicateUsingMtlsToS2ACredentials_succeeds() throws Exception {
+    ClassLoader classLoader = IntegrationTest.class.getClassLoader();
+    InputStream privateKey = classLoader.getResourceAsStream("client_key.pem");
+    InputStream certChain = classLoader.getResourceAsStream("client_cert.pem");
+    InputStream trustBundle = classLoader.getResourceAsStream("root_cert.pem");
+    ChannelCredentials s2aChannelCredentials =
+        TlsChannelCredentials.newBuilder()
+          .keyManager(certChain, privateKey)
+          .trustManager(trustBundle)
+          .build();
+
+    ChannelCredentials credentials =
+        S2AChannelCredentials.newBuilder(mtlsS2AAddress, s2aChannelCredentials)
+          .setLocalSpiffeId("test-spiffe-id")
+          .build();
+    ManagedChannel channel = Grpc.newChannelBuilder(serverAddress, credentials).build();
+
+    assertThat(doUnaryRpc(channel)).isTrue();
+  }
+
+  @Test
+  public void clientCommunicateUsingS2ACredentials_s2AdelayStart_succeeds() throws Exception {
+    ChannelCredentials credentials = S2AChannelCredentials.newBuilder(s2aDelayAddress,
+        InsecureChannelCredentials.create()).build();
+    ManagedChannel channel = Grpc.newChannelBuilder(serverAddress, credentials).build();
+
+    FutureTask<Boolean> rpc = new FutureTask<>(() -> doUnaryRpc(channel));
+    new Thread(rpc).start();
+    Thread.sleep(2000);
+    s2aDelayServer.start();
+    assertThat(rpc.get()).isTrue();
+  }
+
+  public static boolean doUnaryRpc(ManagedChannel channel) throws InterruptedException {
+    try {
+      SimpleServiceGrpc.SimpleServiceBlockingStub stub =
+          SimpleServiceGrpc.newBlockingStub(channel);
+      SimpleResponse resp = stub.unaryRpc(SimpleRequest.newBuilder()
+                                                       .setRequestMessage("S2A team")
+                                                       .build());
+      if (!resp.getResponseMessage().equals("Hello, S2A team!")) {
+        logger.info(
+            "Received unexpected message from the Simple Service: " + resp.getResponseMessage());
+        throw new RuntimeException();
+      } else {
+        System.out.println(
+            "We received this message from the Simple Service: " + resp.getResponseMessage());
+        return true;
+      }
+    } finally {
+      channel.shutdown();
+      channel.awaitTermination(1, SECONDS);
+    }
+  }
+
+  private static SslContext buildSslContext() throws SSLException {
+    ClassLoader classLoader = IntegrationTest.class.getClassLoader();
+    InputStream privateKey = classLoader.getResourceAsStream("leaf_key_ec.pem");
+    InputStream rootCert = classLoader.getResourceAsStream("root_cert_ec.pem");
+    InputStream certChain = classLoader.getResourceAsStream("cert_chain_ec.pem");
+    SslContextBuilder sslServerContextBuilder =
+          SslContextBuilder.forServer(certChain, privateKey);
+    SslContext sslServerContext =
+        GrpcSslContexts.configure(sslServerContextBuilder, SslProvider.OPENSSL)
+            .protocols("TLSv1.3", "TLSv1.2")
+            .trustManager(rootCert)
+            .clientAuth(ClientAuth.REQUIRE)
+            .build();
+
+    // Enable TLS resumption. This requires using the OpenSSL provider, since the JDK provider does
+    // not allow a server to send session tickets.
+    SSLSessionContext sslSessionContext = sslServerContext.sessionContext();
+    if (!(sslSessionContext instanceof OpenSslSessionContext)) {
+      throw new SSLException("sslSessionContext does not use OpenSSL.");
+    }
+    OpenSslSessionContext openSslSessionContext = (OpenSslSessionContext) sslSessionContext;
+    // Calling {@code setTicketKeys} without specifying any keys means that the SSL libraries will
+    // handle the generation of the resumption master secret.
+    openSslSessionContext.setTicketKeys();
+
+    return sslServerContext;
+  }
+
+  public static class SimpleServiceImpl extends SimpleServiceGrpc.SimpleServiceImplBase {
+    @Override
+    public void unaryRpc(SimpleRequest request, StreamObserver<SimpleResponse> observer) {
+      observer.onNext(
+          SimpleResponse.newBuilder()
+                      .setResponseMessage("Hello, " + request.getRequestMessage() + "!")
+                      .build());
+      observer.onCompleted();
+    }
+  }
+}
diff --git a/s2a/src/test/java/io/grpc/s2a/S2AChannelCredentialsTest.java b/s2a/src/test/java/io/grpc/s2a/S2AChannelCredentialsTest.java
new file mode 100644
index 00000000000..3e6eef7f470
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/S2AChannelCredentialsTest.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2024 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.s2a;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.TlsChannelCredentials;
+import java.io.InputStream;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@code S2AChannelCredentials}. */
+@RunWith(JUnit4.class)
+public final class S2AChannelCredentialsTest {
+  @Test
+  public void newBuilder_nullAddress_throwsException() throws Exception {
+    assertThrows(IllegalArgumentException.class, () -> S2AChannelCredentials.newBuilder(null,
+        InsecureChannelCredentials.create()));
+  }
+
+  @Test
+  public void newBuilder_emptyAddress_throwsException() throws Exception {
+    assertThrows(IllegalArgumentException.class, () -> S2AChannelCredentials.newBuilder("",
+        InsecureChannelCredentials.create()));
+  }
+
+  @Test
+  public void newBuilder_nullChannelCreds_throwsException() throws Exception {
+    assertThrows(NullPointerException.class, () -> S2AChannelCredentials
+        .newBuilder("s2a_address", null));
+  }
+
+  @Test
+  public void setLocalSpiffeId_nullArgument_throwsException() throws Exception {
+    assertThrows(
+        NullPointerException.class,
+        () -> S2AChannelCredentials.newBuilder("s2a_address",
+            InsecureChannelCredentials.create()).setLocalSpiffeId(null));
+  }
+
+  @Test
+  public void setLocalHostname_nullArgument_throwsException() throws Exception {
+    assertThrows(
+        NullPointerException.class,
+        () -> S2AChannelCredentials.newBuilder("s2a_address",
+            InsecureChannelCredentials.create()).setLocalHostname(null));
+  }
+
+  @Test
+  public void setLocalUid_nullArgument_throwsException() throws Exception {
+    assertThrows(
+        NullPointerException.class,
+        () -> S2AChannelCredentials.newBuilder("s2a_address",
+            InsecureChannelCredentials.create()).setLocalUid(null));
+  }
+
+  @Test
+  public void build_withLocalSpiffeId_succeeds() throws Exception {
+    assertThat(
+            S2AChannelCredentials.newBuilder("s2a_address", InsecureChannelCredentials.create())
+                .setLocalSpiffeId("spiffe://test")
+                .build())
+        .isNotNull();
+  }
+
+  @Test
+  public void build_withLocalHostname_succeeds() throws Exception {
+    assertThat(
+            S2AChannelCredentials.newBuilder("s2a_address", InsecureChannelCredentials.create())
+                .setLocalHostname("local_hostname")
+                .build())
+        .isNotNull();
+  }
+
+  @Test
+  public void build_withLocalUid_succeeds() throws Exception {
+    assertThat(S2AChannelCredentials.newBuilder("s2a_address",
+        InsecureChannelCredentials.create()).setLocalUid("local_uid").build())
+        .isNotNull();
+  }
+
+  @Test
+  public void build_withNoLocalIdentity_succeeds() throws Exception {
+    assertThat(S2AChannelCredentials.newBuilder("s2a_address",
+        InsecureChannelCredentials.create()).build())
+        .isNotNull();
+  }
+
+  @Test
+  public void build_withUseMtlsToS2ANoLocalIdentity_success() throws Exception {
+    ChannelCredentials s2aChannelCredentials = getTlsChannelCredentials();
+    assertThat(
+            S2AChannelCredentials.newBuilder("s2a_address", s2aChannelCredentials)
+                .build())
+        .isNotNull();
+  }
+
+  @Test
+  public void build_withUseMtlsToS2AWithLocalUid_success() throws Exception {
+    ChannelCredentials s2aChannelCredentials = getTlsChannelCredentials();
+    assertThat(
+            S2AChannelCredentials.newBuilder("s2a_address", s2aChannelCredentials)
+                .setLocalUid("local_uid")
+                .build())
+        .isNotNull();
+  }
+
+  private static ChannelCredentials getTlsChannelCredentials() throws Exception {
+    ClassLoader classLoader = S2AChannelCredentialsTest.class.getClassLoader();
+    InputStream privateKey = classLoader.getResourceAsStream("client_key.pem");
+    InputStream certChain = classLoader.getResourceAsStream("client_cert.pem");
+    InputStream trustBundle = classLoader.getResourceAsStream("root_cert.pem");
+    return TlsChannelCredentials.newBuilder()
+      .keyManager(certChain, privateKey)
+      .trustManager(trustBundle)
+      .build();
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/test/java/io/grpc/s2a/internal/channel/S2AHandshakerServiceChannelTest.java b/s2a/src/test/java/io/grpc/s2a/internal/channel/S2AHandshakerServiceChannelTest.java
new file mode 100644
index 00000000000..9ba3caaf99e
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/internal/channel/S2AHandshakerServiceChannelTest.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright 2024 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.s2a.internal.channel;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import io.grpc.Channel;
+import io.grpc.ChannelCredentials;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCredentials;
+import io.grpc.StatusRuntimeException;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.TlsServerCredentials;
+import io.grpc.internal.SharedResourceHolder.Resource;
+import io.grpc.netty.NettyServerBuilder;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import java.io.InputStream;
+import org.junit.Before;
+import org.junit.ClassRule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link S2AHandshakerServiceChannel}. */
+@RunWith(JUnit4.class)
+public final class S2AHandshakerServiceChannelTest {
+  @ClassRule public static final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+  private Server mtlsServer;
+  private Server plaintextServer;
+
+  @Before
+  public void setUp() throws Exception {
+    mtlsServer = createMtlsServer();
+    plaintextServer = createPlaintextServer();
+    mtlsServer.start();
+    plaintextServer.start();
+  }
+
+  /**
+   * Creates a {@code Resource<Channel>} and verifies that it produces a {@code ChannelResource}
+   * instance by using its {@code toString()} method.
+   */
+  @Test
+  public void getChannelResource_success() {
+    Resource<Channel> resource =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + plaintextServer.getPort(),
+            InsecureChannelCredentials.create());
+    assertThat(resource.toString()).isEqualTo("grpc-s2a-channel");
+  }
+
+  /** Same as getChannelResource_success, but use mTLS. */
+  @Test
+  public void getChannelResource_mtlsSuccess() throws Exception {
+    Resource<Channel> resource =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + mtlsServer.getPort(), getTlsChannelCredentials());
+    assertThat(resource.toString()).isEqualTo("grpc-s2a-channel");
+  }
+
+  /**
+   * Creates two {@code Resoure<Channel>}s for the same target address and verifies that they are
+   * distinct.
+   */
+  @Test
+  public void getChannelResource_twoUnEqualChannels() {
+    Resource<Channel> resource =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + plaintextServer.getPort(),
+            InsecureChannelCredentials.create());
+    Resource<Channel> resourceTwo =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + plaintextServer.getPort(),
+            InsecureChannelCredentials.create());
+    assertThat(resource).isNotEqualTo(resourceTwo);
+  }
+
+  /** Same as getChannelResource_twoUnEqualChannels, but use mTLS. */
+  @Test
+  public void getChannelResource_mtlsTwoUnEqualChannels() throws Exception {
+    Resource<Channel> resource =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + mtlsServer.getPort(), getTlsChannelCredentials());
+    Resource<Channel> resourceTwo =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + mtlsServer.getPort(), getTlsChannelCredentials());
+    assertThat(resource).isNotEqualTo(resourceTwo);
+  }
+
+  /**
+   * Creates two {@code Resoure<Channel>}s for different target addresses and verifies that they are
+   * distinct.
+   */
+  @Test
+  public void getChannelResource_twoDistinctChannels() {
+    Resource<Channel> resource =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + plaintextServer.getPort(),
+            InsecureChannelCredentials.create());
+    Resource<Channel> resourceTwo =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + plaintextServer.getPort() + 1, InsecureChannelCredentials.create());
+    assertThat(resourceTwo).isNotEqualTo(resource);
+  }
+
+  /** Same as getChannelResource_twoDistinctChannels, but use mTLS. */
+  @Test
+  public void getChannelResource_mtlsTwoDistinctChannels() throws Exception {
+    Resource<Channel> resource =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + mtlsServer.getPort(), getTlsChannelCredentials());
+    Resource<Channel> resourceTwo =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + mtlsServer.getPort() + 1, getTlsChannelCredentials());
+    assertThat(resourceTwo).isNotEqualTo(resource);
+  }
+
+  /**
+   * Uses a {@code Resource<Channel>} to create a channel, closes the channel, and verifies that the
+   * channel is closed by attempting to make a simple RPC.
+   */
+  @Test
+  public void close_success() {
+    Resource<Channel> resource =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + plaintextServer.getPort(),
+            InsecureChannelCredentials.create());
+    Channel channel = resource.create();
+    resource.close(channel);
+    StatusRuntimeException expected =
+        assertThrows(
+            StatusRuntimeException.class,
+            () ->
+                SimpleServiceGrpc.newBlockingStub(channel)
+                    .unaryRpc(SimpleRequest.getDefaultInstance()));
+    assertThat(expected).hasMessageThat().isEqualTo("UNAVAILABLE: Channel shutdown invoked");
+  }
+
+  /** Same as close_success, but use mTLS. */
+  @Test
+  public void close_mtlsSuccess() throws Exception {
+    Resource<Channel> resource =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + mtlsServer.getPort(), getTlsChannelCredentials());
+    Channel channel = resource.create();
+    resource.close(channel);
+    StatusRuntimeException expected =
+        assertThrows(
+            StatusRuntimeException.class,
+            () ->
+                SimpleServiceGrpc.newBlockingStub(channel)
+                    .unaryRpc(SimpleRequest.getDefaultInstance()));
+    assertThat(expected).hasMessageThat().isEqualTo("UNAVAILABLE: Channel shutdown invoked");
+  }
+
+  /**
+   * Creates and closes a {@code ManagedChannel}, creates a new channel from the same
+   * resource, and verifies that this second channel is useable.
+   */
+  @Test
+  public void create_succeedsAfterCloseIsCalledOnce() throws Exception {
+    Resource<Channel> resource =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + plaintextServer.getPort(),
+            InsecureChannelCredentials.create());
+    Channel channelOne = resource.create();
+    resource.close(channelOne);
+
+    Channel channelTwo = resource.create();
+    assertThat(channelTwo).isInstanceOf(ManagedChannel.class);
+    assertThat(
+            SimpleServiceGrpc.newBlockingStub(channelTwo)
+                .unaryRpc(SimpleRequest.getDefaultInstance()))
+        .isEqualToDefaultInstance();
+    resource.close(channelTwo);
+  }
+
+  /** Same as create_succeedsAfterCloseIsCalledOnce, but use mTLS. */
+  @Test
+  public void create_mtlsSucceedsAfterCloseIsCalledOnce() throws Exception {
+    Resource<Channel> resource =
+        S2AHandshakerServiceChannel.getChannelResource(
+            "localhost:" + mtlsServer.getPort(), getTlsChannelCredentials());
+    Channel channelOne = resource.create();
+    resource.close(channelOne);
+
+    Channel channelTwo = resource.create();
+    assertThat(channelTwo).isInstanceOf(ManagedChannel.class);
+    assertThat(
+            SimpleServiceGrpc.newBlockingStub(channelTwo)
+                .unaryRpc(SimpleRequest.getDefaultInstance()))
+        .isEqualToDefaultInstance();
+    resource.close(channelTwo);
+  }
+
+  private static Server createMtlsServer() throws Exception {
+    SimpleServiceImpl service = new SimpleServiceImpl();
+    ClassLoader classLoader = S2AHandshakerServiceChannelTest.class.getClassLoader();
+    InputStream serverCert = classLoader.getResourceAsStream("server_cert.pem");
+    InputStream serverKey = classLoader.getResourceAsStream("server_key.pem");
+    InputStream rootCert = classLoader.getResourceAsStream("root_cert.pem");
+    ServerCredentials creds =
+        TlsServerCredentials.newBuilder()
+            .keyManager(serverCert, serverKey)
+            .trustManager(rootCert)
+            .clientAuth(TlsServerCredentials.ClientAuth.REQUIRE)
+            .build();
+    return grpcCleanup.register(
+        NettyServerBuilder.forPort(0, creds).addService(service).build());
+  }
+
+  private static Server createPlaintextServer() {
+    SimpleServiceImpl service = new SimpleServiceImpl();
+    return grpcCleanup.register(
+        ServerBuilder.forPort(0).addService(service).build());
+  }
+
+  private static ChannelCredentials getTlsChannelCredentials() throws Exception {
+    ClassLoader classLoader = S2AHandshakerServiceChannelTest.class.getClassLoader();
+    InputStream clientCert = classLoader.getResourceAsStream("client_cert.pem");
+    InputStream clientKey = classLoader.getResourceAsStream("client_key.pem");
+    InputStream rootCert = classLoader.getResourceAsStream("root_cert.pem");
+    return TlsChannelCredentials.newBuilder()
+            .keyManager(clientCert, clientKey)
+            .trustManager(rootCert)
+            .build();
+  }
+
+  private static class SimpleServiceImpl extends SimpleServiceGrpc.SimpleServiceImplBase {
+    @Override
+    public void unaryRpc(SimpleRequest request, StreamObserver<SimpleResponse> streamObserver) {
+      streamObserver.onNext(SimpleResponse.getDefaultInstance());
+      streamObserver.onCompleted();
+    }
+  }
+}
diff --git a/s2a/src/test/java/io/grpc/s2a/internal/handshaker/FakeS2AServer.java b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/FakeS2AServer.java
new file mode 100644
index 00000000000..322397c93be
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/FakeS2AServer.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import com.google.s2a.proto.v2.S2AServiceGrpc;
+import com.google.s2a.proto.v2.SessionReq;
+import com.google.s2a.proto.v2.SessionResp;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.security.NoSuchAlgorithmException;
+import java.security.spec.InvalidKeySpecException;
+import java.util.logging.Logger;
+
+/** A fake S2Av2 server that should be used for testing only. */
+public final class FakeS2AServer extends S2AServiceGrpc.S2AServiceImplBase {
+  private static final Logger logger = Logger.getLogger(FakeS2AServer.class.getName());
+
+  private final FakeWriter writer;
+
+  public FakeS2AServer() throws InvalidKeySpecException, NoSuchAlgorithmException, IOException {
+    this.writer = new FakeWriter();
+    this.writer.setVerificationResult(FakeWriter.VerificationResult.SUCCESS).initializePrivateKey();
+  }
+
+  @Override
+  public StreamObserver<SessionReq> setUpSession(StreamObserver<SessionResp> responseObserver) {
+    return new StreamObserver<SessionReq>() {
+      @Override
+      public void onNext(SessionReq req) {
+        logger.info("Received a request from client.");
+        try {
+          responseObserver.onNext(writer.handleResponse(req));
+        } catch (IOException e) {
+          responseObserver.onError(e);
+        }
+      }
+
+      @Override
+      public void onError(Throwable t) {
+        responseObserver.onError(t);
+      }
+
+      @Override
+      public void onCompleted() {
+        responseObserver.onCompleted();
+      }
+    };
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/test/java/io/grpc/s2a/internal/handshaker/FakeS2AServerTest.java b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/FakeS2AServerTest.java
new file mode 100644
index 00000000000..c3155b864b3
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/FakeS2AServerTest.java
@@ -0,0 +1,300 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.protobuf.ByteString;
+import com.google.s2a.proto.v2.Ciphersuite;
+import com.google.s2a.proto.v2.ConnectionSide;
+import com.google.s2a.proto.v2.GetTlsConfigurationReq;
+import com.google.s2a.proto.v2.GetTlsConfigurationResp;
+import com.google.s2a.proto.v2.S2AServiceGrpc;
+import com.google.s2a.proto.v2.SessionReq;
+import com.google.s2a.proto.v2.SessionResp;
+import com.google.s2a.proto.v2.TLSVersion;
+import com.google.s2a.proto.v2.ValidatePeerCertificateChainReq;
+import com.google.s2a.proto.v2.ValidatePeerCertificateChainReq.VerificationMode;
+import com.google.s2a.proto.v2.ValidatePeerCertificateChainResp;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Logger;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link FakeS2AServer}. */
+@RunWith(JUnit4.class)
+public final class FakeS2AServerTest {
+  private static final Logger logger = Logger.getLogger(FakeS2AServerTest.class.getName());
+
+  private static final ImmutableList<ByteString> FAKE_CERT_DER_CHAIN =
+      ImmutableList.of(ByteString.copyFrom("fake-der-chain".getBytes(StandardCharsets.US_ASCII)));
+  private String serverAddress;
+  private Server fakeS2AServer;
+
+  @Before
+  public void setUp() throws Exception {
+    fakeS2AServer = ServerBuilder.forPort(0).addService(new FakeS2AServer()).build();
+    fakeS2AServer.start();
+    serverAddress = String.format("localhost:%d", fakeS2AServer.getPort());
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    fakeS2AServer.shutdown();
+    fakeS2AServer.awaitTermination(10, SECONDS);
+  }
+
+  @Test
+  public void callS2AServerOnce_getTlsConfiguration_returnsValidResult()
+      throws InterruptedException,
+          IOException,
+          java.util.concurrent.ExecutionException,
+          TimeoutException {
+    ExecutorService executor = Executors.newSingleThreadExecutor();
+    logger.info("Client connecting to: " + serverAddress);
+    ManagedChannel channel =
+        Grpc.newChannelBuilder(serverAddress, InsecureChannelCredentials.create())
+            .executor(executor)
+            .build();
+    SettableFuture<SessionResp> respFuture = SettableFuture.create();
+    try {
+      S2AServiceGrpc.S2AServiceStub asyncStub = S2AServiceGrpc.newStub(channel);
+      StreamObserver<SessionReq> requestObserver =
+          asyncStub.setUpSession(
+              new StreamObserver<SessionResp>() {
+                SessionResp recvResp;
+                @Override
+                public void onNext(SessionResp resp) {
+                  recvResp = resp;
+                }
+
+                @Override
+                public void onError(Throwable t) {
+                  respFuture.setException(t);
+                }
+
+                @Override
+                public void onCompleted() {
+                  respFuture.set(recvResp);
+                }
+              });
+      try {
+        requestObserver.onNext(
+            SessionReq.newBuilder()
+                .setGetTlsConfigurationReq(
+                    GetTlsConfigurationReq.newBuilder()
+                        .setConnectionSide(ConnectionSide.CONNECTION_SIDE_CLIENT))
+                .build());
+      } catch (RuntimeException e) {
+        // Cancel the RPC.
+        requestObserver.onError(e);
+        throw e;
+      }
+      // Mark the end of requests.
+      requestObserver.onCompleted();
+      // Wait for receiving to happen.
+      respFuture.get(5, SECONDS);
+    } finally {
+      channel.shutdown();
+      channel.awaitTermination(1, SECONDS);
+      executor.shutdown();
+      executor.awaitTermination(1, SECONDS);
+    }
+
+    String leafCertString = "";
+    String cert2String = "";
+    String cert1String = "";
+    ClassLoader classLoader = FakeS2AServerTest.class.getClassLoader();
+    try (
+        InputStream leafCert = classLoader.getResourceAsStream("leaf_cert_ec.pem");
+        InputStream cert2 = classLoader.getResourceAsStream("int_cert2_ec.pem");
+        InputStream cert1 = classLoader.getResourceAsStream("int_cert1_ec.pem");
+    ) {
+      leafCertString = FakeWriter.convertInputStreamToString(leafCert);
+      cert2String = FakeWriter.convertInputStreamToString(cert2);
+      cert1String = FakeWriter.convertInputStreamToString(cert1);
+    }
+
+    SessionResp expected =
+        SessionResp.newBuilder()
+            .setGetTlsConfigurationResp(
+                GetTlsConfigurationResp.newBuilder()
+                    .setClientTlsConfiguration(
+                        GetTlsConfigurationResp.ClientTlsConfiguration.newBuilder()
+                            .addCertificateChain(leafCertString)
+                            .addCertificateChain(cert1String)
+                            .addCertificateChain(cert2String)
+                            .setMinTlsVersion(TLSVersion.TLS_VERSION_1_3)
+                            .setMaxTlsVersion(TLSVersion.TLS_VERSION_1_3)
+                            .addCiphersuites(
+                                Ciphersuite.CIPHERSUITE_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
+                            .addCiphersuites(
+                                Ciphersuite.CIPHERSUITE_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
+                            .addCiphersuites(
+                                Ciphersuite.CIPHERSUITE_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256)))
+            .build();
+    assertThat(respFuture.get()).ignoringRepeatedFieldOrder().isEqualTo(expected);
+  }
+
+  @Test
+  public void callS2AServerOnce_validatePeerCertifiate_returnsValidResult()
+      throws InterruptedException, java.util.concurrent.ExecutionException, TimeoutException {
+    ExecutorService executor = Executors.newSingleThreadExecutor();
+    logger.info("Client connecting to: " + serverAddress);
+    ManagedChannel channel =
+        Grpc.newChannelBuilder(serverAddress, InsecureChannelCredentials.create())
+            .executor(executor)
+            .build();
+    SettableFuture<SessionResp> respFuture = SettableFuture.create();
+    try {
+      S2AServiceGrpc.S2AServiceStub asyncStub = S2AServiceGrpc.newStub(channel);
+      StreamObserver<SessionReq> requestObserver =
+          asyncStub.setUpSession(
+              new StreamObserver<SessionResp>() {
+                private SessionResp recvResp;
+                @Override
+                public void onNext(SessionResp resp) {
+                  recvResp = resp;
+                }
+
+                @Override
+                public void onError(Throwable t) {
+                  respFuture.setException(t);
+                }
+
+                @Override
+                public void onCompleted() {
+                  respFuture.set(recvResp);
+                }
+              });
+      try {
+        requestObserver.onNext(
+            SessionReq.newBuilder()
+                .setValidatePeerCertificateChainReq(
+                    ValidatePeerCertificateChainReq.newBuilder()
+                        .setMode(VerificationMode.UNSPECIFIED)
+                        .setClientPeer(
+                            ValidatePeerCertificateChainReq.ClientPeer.newBuilder()
+                                .addAllCertificateChain(FAKE_CERT_DER_CHAIN)))
+                .build());
+      } catch (RuntimeException e) {
+        // Cancel the RPC.
+        requestObserver.onError(e);
+        throw e;
+      }
+      // Mark the end of requests.
+      requestObserver.onCompleted();
+      // Wait for receiving to happen.
+      respFuture.get(5, SECONDS);
+    } finally {
+      channel.shutdown();
+      channel.awaitTermination(1, SECONDS);
+      executor.shutdown();
+      executor.awaitTermination(1, SECONDS);
+    }
+
+    SessionResp expected =
+        SessionResp.newBuilder()
+            .setValidatePeerCertificateChainResp(
+                ValidatePeerCertificateChainResp.newBuilder()
+                    .setValidationResult(ValidatePeerCertificateChainResp.ValidationResult.SUCCESS))
+            .build();
+    assertThat(respFuture.get()).ignoringRepeatedFieldOrder().isEqualTo(expected);
+  }
+
+  @Test
+  public void callS2AServerRepeatedly_returnsValidResult() throws InterruptedException {
+    final int numberOfRequests = 10;
+    ExecutorService executor = Executors.newSingleThreadExecutor();
+    logger.info("Client connecting to: " + serverAddress);
+    ManagedChannel channel =
+        Grpc.newChannelBuilder(serverAddress, InsecureChannelCredentials.create())
+            .executor(executor)
+            .build();
+
+    try {
+      S2AServiceGrpc.S2AServiceStub asyncStub = S2AServiceGrpc.newStub(channel);
+      CountDownLatch finishLatch = new CountDownLatch(1);
+      StreamObserver<SessionReq> requestObserver =
+          asyncStub.setUpSession(
+              new StreamObserver<SessionResp>() {
+                private int expectedNumberOfReplies = numberOfRequests;
+
+                @Override
+                public void onNext(SessionResp reply) {
+                  System.out.println("Received a message from the S2AService service.");
+                  expectedNumberOfReplies -= 1;
+                }
+
+                @Override
+                public void onError(Throwable t) {
+                  finishLatch.countDown();
+                  if (expectedNumberOfReplies != 0) {
+                    throw new RuntimeException(t);
+                  }
+                }
+                
+                @Override
+                public void onCompleted() {
+                  finishLatch.countDown();
+                  if (expectedNumberOfReplies != 0) {
+                    throw new RuntimeException();
+                  }
+                }
+              });
+      try {
+        for (int i = 0; i < numberOfRequests; i++) {
+          requestObserver.onNext(SessionReq.getDefaultInstance());
+        }
+      } catch (RuntimeException e) {
+        // Cancel the RPC.
+        requestObserver.onError(e);
+        throw e;
+      }
+      // Mark the end of requests.
+      requestObserver.onCompleted();
+      // Wait for receiving to happen.
+      if (!finishLatch.await(10, SECONDS)) {
+        throw new RuntimeException();
+      }
+    } finally {
+      channel.shutdown();
+      channel.awaitTermination(1, SECONDS);
+      executor.shutdown();
+      executor.awaitTermination(1, SECONDS);
+    }
+  }
+
+}
\ No newline at end of file
diff --git a/s2a/src/test/java/io/grpc/s2a/internal/handshaker/FakeWriter.java b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/FakeWriter.java
new file mode 100644
index 00000000000..0b398638f92
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/FakeWriter.java
@@ -0,0 +1,386 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static com.google.s2a.proto.v2.TLSVersion.TLS_VERSION_1_2;
+import static com.google.s2a.proto.v2.TLSVersion.TLS_VERSION_1_3;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.io.CharStreams;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.protobuf.ByteString;
+import com.google.s2a.proto.v2.Ciphersuite;
+import com.google.s2a.proto.v2.ConnectionSide;
+import com.google.s2a.proto.v2.GetTlsConfigurationReq;
+import com.google.s2a.proto.v2.GetTlsConfigurationResp;
+import com.google.s2a.proto.v2.OffloadPrivateKeyOperationReq;
+import com.google.s2a.proto.v2.OffloadPrivateKeyOperationResp;
+import com.google.s2a.proto.v2.SessionReq;
+import com.google.s2a.proto.v2.SessionResp;
+import com.google.s2a.proto.v2.SignatureAlgorithm;
+import com.google.s2a.proto.v2.Status;
+import com.google.s2a.proto.v2.ValidatePeerCertificateChainReq;
+import com.google.s2a.proto.v2.ValidatePeerCertificateChainResp;
+import io.grpc.stub.StreamObserver;
+import io.grpc.util.CertificateUtils;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.StandardCharsets;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.Signature;
+import java.security.spec.InvalidKeySpecException;
+
+/** A fake Writer Class to mock the behavior of S2A server. */
+final class FakeWriter implements StreamObserver<SessionReq> {
+  /** Fake behavior of S2A service. */
+  enum Behavior {
+    OK_STATUS,
+    EMPTY_RESPONSE,
+    ERROR_STATUS,
+    ERROR_RESPONSE,
+    COMPLETE_STATUS,
+    BAD_TLS_VERSION_RESPONSE,
+  }
+
+  enum VerificationResult {
+    UNSPECIFIED,
+    SUCCESS,
+    FAILURE
+  }
+
+  private static final ClassLoader classLoader = FakeWriter.class.getClassLoader();
+  private static final ImmutableMap<SignatureAlgorithm, String>
+      ALGORITHM_TO_SIGNATURE_INSTANCE_IDENTIFIER =
+          ImmutableMap.of(
+              SignatureAlgorithm.S2A_SSL_SIGN_ECDSA_SECP256R1_SHA256,
+              "SHA256withECDSA",
+              SignatureAlgorithm.S2A_SSL_SIGN_ECDSA_SECP384R1_SHA384,
+              "SHA384withECDSA",
+              SignatureAlgorithm.S2A_SSL_SIGN_ECDSA_SECP521R1_SHA512,
+              "SHA512withECDSA");
+
+  private boolean fakeWriterClosed = false;
+  private Behavior behavior = Behavior.OK_STATUS;
+  private StreamObserver<SessionResp> reader;
+  private VerificationResult verificationResult = VerificationResult.UNSPECIFIED;
+  private String failureReason;
+  private PrivateKey privateKey;
+
+  public static String convertInputStreamToString(InputStream is) throws IOException {
+    return CharStreams.toString(new InputStreamReader(is, StandardCharsets.UTF_8));
+  }
+
+  @CanIgnoreReturnValue
+  FakeWriter setReader(StreamObserver<SessionResp> reader) {
+    this.reader = reader;
+    return this;
+  }
+
+  @CanIgnoreReturnValue
+  FakeWriter setBehavior(Behavior behavior) {
+    this.behavior = behavior;
+    return this;
+  }
+
+  @CanIgnoreReturnValue
+  FakeWriter setVerificationResult(VerificationResult verificationResult) {
+    this.verificationResult = verificationResult;
+    return this;
+  }
+
+  @CanIgnoreReturnValue
+  FakeWriter setFailureReason(String failureReason) {
+    this.failureReason = failureReason;
+    return this;
+  }
+
+  @CanIgnoreReturnValue
+  FakeWriter initializePrivateKey() throws InvalidKeySpecException, NoSuchAlgorithmException,
+                    IOException, FileNotFoundException, UnsupportedEncodingException {
+    try (
+        InputStream keyInputStream = classLoader.getResourceAsStream("leaf_key_ec.pem");
+    ) {
+      privateKey = CertificateUtils.getPrivateKey(keyInputStream);
+    }
+    return this;
+  }
+
+  @CanIgnoreReturnValue
+  FakeWriter resetPrivateKey() {
+    privateKey = null;
+    return this;
+  }
+
+  void sendUnexpectedResponse() {
+    reader.onNext(SessionResp.getDefaultInstance());
+  }
+
+  void sendIoError() {
+    reader.onError(new IOException("Intended ERROR from FakeWriter."));
+  }
+
+  void sendGetTlsConfigResp() {
+    String leafCertString = "";
+    String cert2String = "";
+    String cert1String = "";
+    try (
+        InputStream leafCert = classLoader.getResourceAsStream("leaf_cert_ec.pem");
+        InputStream cert2 = classLoader.getResourceAsStream("int_cert2_ec.pem");
+        InputStream cert1 = classLoader.getResourceAsStream("int_cert1_ec.pem");
+    ) {
+      leafCertString = FakeWriter.convertInputStreamToString(leafCert);
+      cert2String = FakeWriter.convertInputStreamToString(cert2);
+      cert1String = FakeWriter.convertInputStreamToString(cert1);
+    } catch (IOException e) {
+      reader.onError(e);
+    }
+    reader.onNext(
+        SessionResp.newBuilder()
+            .setGetTlsConfigurationResp(
+                GetTlsConfigurationResp.newBuilder()
+                    .setClientTlsConfiguration(
+                        GetTlsConfigurationResp.ClientTlsConfiguration.newBuilder()
+                            .addCertificateChain(leafCertString)
+                            .addCertificateChain(cert1String)
+                            .addCertificateChain(cert2String)
+                            .setMinTlsVersion(TLS_VERSION_1_3)
+                            .setMaxTlsVersion(TLS_VERSION_1_3)
+                            .addCiphersuites(
+                                Ciphersuite.CIPHERSUITE_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
+                            .addCiphersuites(
+                                Ciphersuite.CIPHERSUITE_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
+                            .addCiphersuites(
+                                Ciphersuite
+                                .CIPHERSUITE_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256)))
+            .build());
+  }
+
+  boolean isFakeWriterClosed() {
+    return fakeWriterClosed;
+  }
+
+  @Override
+  public void onNext(SessionReq sessionReq) {
+    switch (behavior) {
+      case OK_STATUS:
+        try {
+          reader.onNext(handleResponse(sessionReq));
+        } catch (IOException e) {
+          reader.onError(e);
+        }
+        break;
+      case EMPTY_RESPONSE:
+        reader.onNext(SessionResp.getDefaultInstance());
+        break;
+      case ERROR_STATUS:
+        reader.onNext(
+            SessionResp.newBuilder()
+                .setStatus(
+                    Status.newBuilder()
+                        .setCode(1)
+                        .setDetails("Intended ERROR Status from FakeWriter."))
+                .build());
+        break;
+      case ERROR_RESPONSE:
+        reader.onError(new S2AConnectionException("Intended ERROR from FakeWriter."));
+        break;
+      case COMPLETE_STATUS:
+        reader.onCompleted();
+        break;
+      case BAD_TLS_VERSION_RESPONSE:
+        String leafCertString = "";
+        String cert2String = "";
+        String cert1String = "";
+        try (
+            InputStream leafCert = classLoader.getResourceAsStream("leaf_cert_ec.pem");
+            InputStream cert2 = classLoader.getResourceAsStream("int_cert2_ec.pem");
+            InputStream cert1 = classLoader.getResourceAsStream("int_cert1_ec.pem");
+        ) {
+          leafCertString = FakeWriter.convertInputStreamToString(leafCert);
+          cert2String = FakeWriter.convertInputStreamToString(cert2);
+          cert1String = FakeWriter.convertInputStreamToString(cert1);
+        } catch (IOException e) {
+          reader.onError(e);
+        }
+        reader.onNext(
+            SessionResp.newBuilder()
+                .setGetTlsConfigurationResp(
+                    GetTlsConfigurationResp.newBuilder()
+                        .setClientTlsConfiguration(
+                            GetTlsConfigurationResp.ClientTlsConfiguration.newBuilder()
+                                .addCertificateChain(leafCertString)
+                                .addCertificateChain(cert1String)
+                                .addCertificateChain(cert2String)
+                                .setMinTlsVersion(TLS_VERSION_1_3)
+                                .setMaxTlsVersion(TLS_VERSION_1_2)))
+                .build());
+        break;
+      default:
+        try {
+          reader.onNext(handleResponse(sessionReq));
+        } catch (IOException e) {
+          reader.onError(e);
+        }
+    }
+  }
+
+  SessionResp handleResponse(SessionReq sessionReq) throws IOException {
+    if (sessionReq.hasGetTlsConfigurationReq()) {
+      return handleGetTlsConfigurationReq(sessionReq.getGetTlsConfigurationReq());
+    }
+
+    if (sessionReq.hasValidatePeerCertificateChainReq()) {
+      return handleValidatePeerCertificateChainReq(sessionReq.getValidatePeerCertificateChainReq());
+    }
+
+    if (sessionReq.hasOffloadPrivateKeyOperationReq()) {
+      return handleOffloadPrivateKeyOperationReq(sessionReq.getOffloadPrivateKeyOperationReq());
+    }
+
+    return SessionResp.newBuilder()
+        .setStatus(
+            Status.newBuilder().setCode(255).setDetails("No supported operation designated."))
+        .build();
+  }
+
+  private SessionResp handleGetTlsConfigurationReq(GetTlsConfigurationReq req)
+      throws IOException {
+    if (!req.getConnectionSide().equals(ConnectionSide.CONNECTION_SIDE_CLIENT)) {
+      return SessionResp.newBuilder()
+          .setStatus(
+              Status.newBuilder()
+                  .setCode(255)
+                  .setDetails("No TLS configuration for the server side."))
+          .build();
+    }
+    String leafCertString = "";
+    String cert2String = "";
+    String cert1String = "";
+    try (
+        InputStream leafCert = classLoader.getResourceAsStream("leaf_cert_ec.pem");
+        InputStream cert2 = classLoader.getResourceAsStream("int_cert2_ec.pem");
+        InputStream cert1 = classLoader.getResourceAsStream("int_cert1_ec.pem");
+    ) {
+      leafCertString = FakeWriter.convertInputStreamToString(leafCert);
+      cert2String = FakeWriter.convertInputStreamToString(cert2);
+      cert1String = FakeWriter.convertInputStreamToString(cert1);
+    } catch (IOException e) {
+      reader.onError(e);
+    }
+    return SessionResp.newBuilder()
+        .setGetTlsConfigurationResp(
+            GetTlsConfigurationResp.newBuilder()
+                .setClientTlsConfiguration(
+                    GetTlsConfigurationResp.ClientTlsConfiguration.newBuilder()
+                        .addCertificateChain(leafCertString)
+                        .addCertificateChain(cert1String)
+                        .addCertificateChain(cert2String)
+                        .setMinTlsVersion(TLS_VERSION_1_3)
+                        .setMaxTlsVersion(TLS_VERSION_1_3)
+                        .addCiphersuites(
+                            Ciphersuite.CIPHERSUITE_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
+                        .addCiphersuites(
+                            Ciphersuite.CIPHERSUITE_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
+                        .addCiphersuites(
+                            Ciphersuite.CIPHERSUITE_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256)))
+        .build();
+  }
+
+  private SessionResp handleValidatePeerCertificateChainReq(ValidatePeerCertificateChainReq req) {
+    if (verifyValidatePeerCertificateChainReq(req)
+        && verificationResult == VerificationResult.SUCCESS) {
+      return SessionResp.newBuilder()
+          .setValidatePeerCertificateChainResp(
+              ValidatePeerCertificateChainResp.newBuilder()
+                  .setValidationResult(ValidatePeerCertificateChainResp.ValidationResult.SUCCESS))
+          .build();
+    }
+    return SessionResp.newBuilder()
+        .setValidatePeerCertificateChainResp(
+            ValidatePeerCertificateChainResp.newBuilder()
+                .setValidationResult(
+                    verificationResult == VerificationResult.FAILURE
+                        ? ValidatePeerCertificateChainResp.ValidationResult.FAILURE
+                        : ValidatePeerCertificateChainResp.ValidationResult.UNSPECIFIED)
+                .setValidationDetails(failureReason))
+        .build();
+  }
+
+  private boolean verifyValidatePeerCertificateChainReq(ValidatePeerCertificateChainReq req) {
+    if (req.getMode() != ValidatePeerCertificateChainReq.VerificationMode.UNSPECIFIED) {
+      return false;
+    }
+    if (req.getClientPeer().getCertificateChainCount() > 0) {
+      return true;
+    }
+    if (req.getServerPeer().getCertificateChainCount() > 0
+        && !req.getServerPeer().getServerHostname().isEmpty()) {
+      return true;
+    }
+    return false;
+  }
+
+  private SessionResp handleOffloadPrivateKeyOperationReq(OffloadPrivateKeyOperationReq req) {
+    if (privateKey == null) {
+      return SessionResp.newBuilder()
+          .setStatus(Status.newBuilder().setCode(255).setDetails("No Private Key available."))
+          .build();
+    }
+    String signatureIdentifier =
+        ALGORITHM_TO_SIGNATURE_INSTANCE_IDENTIFIER.get(req.getSignatureAlgorithm());
+    if (signatureIdentifier == null) {
+      return SessionResp.newBuilder()
+          .setStatus(
+              Status.newBuilder()
+                  .setCode(255)
+                  .setDetails("Only ECDSA key algorithms are supported."))
+          .build();
+    }
+
+    byte[] signature;
+    try {
+      Signature sig = Signature.getInstance(signatureIdentifier);
+      sig.initSign(privateKey);
+      sig.update(req.getRawBytes().toByteArray());
+      signature = sig.sign();
+    } catch (Exception e) {
+      return SessionResp.newBuilder()
+          .setStatus(Status.newBuilder().setCode(255).setDetails(e.getMessage()))
+          .build();
+    }
+
+    return SessionResp.newBuilder()
+        .setOffloadPrivateKeyOperationResp(
+            OffloadPrivateKeyOperationResp.newBuilder().setOutBytes(ByteString.copyFrom(signature)))
+        .build();
+  }
+
+  @Override
+  public void onError(Throwable t) {
+    throw new UnsupportedOperationException("onError is not supported by FakeWriter.");
+  }
+
+  @Override
+  public void onCompleted() {
+    fakeWriterClosed = true;
+    reader.onCompleted();
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/test/java/io/grpc/s2a/internal/handshaker/GetAuthenticationMechanismsTest.java b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/GetAuthenticationMechanismsTest.java
new file mode 100644
index 00000000000..c1c629366aa
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/GetAuthenticationMechanismsTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import com.google.common.truth.Expect;
+import com.google.s2a.proto.v2.AuthenticationMechanism;
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+import io.grpc.s2a.internal.handshaker.tokenmanager.AccessTokenManager;
+import io.grpc.s2a.internal.handshaker.tokenmanager.SingleTokenFetcher;
+import java.util.Optional;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+ 
+/** Unit tests for {@link GetAuthenticationMechanisms}. */
+@RunWith(JUnit4.class)
+public final class GetAuthenticationMechanismsTest {
+  @Rule public final Expect expect = Expect.create();
+  private static final String TOKEN = "access_token";
+  private static String originalAccessToken;
+  private Optional<AccessTokenManager> tokenManager;
+
+  @BeforeClass
+  public static void setUpClass() {
+    originalAccessToken = SingleTokenFetcher.getAccessToken();
+    // Set the token that the client will use to authenticate to the S2A.
+    SingleTokenFetcher.setAccessToken(TOKEN);
+  }
+
+  @Before
+  public void setUp() {
+    tokenManager = AccessTokenManager.create();
+  }
+
+  @AfterClass
+  public static void tearDownClass() {
+    SingleTokenFetcher.setAccessToken(originalAccessToken);
+  }
+
+  @Test
+  public void getAuthMechanisms_emptyIdentity_success() {
+    expect
+        .that(GetAuthenticationMechanisms.getAuthMechanism(Optional.empty(), tokenManager))
+        .isEqualTo(
+            Optional.of(AuthenticationMechanism.newBuilder().setToken("access_token").build()));
+  }
+
+  @Test
+  public void getAuthMechanisms_nonEmptyIdentity_success() {
+    S2AIdentity fakeIdentity = S2AIdentity.fromSpiffeId("fake-spiffe-id");
+    expect
+        .that(GetAuthenticationMechanisms.getAuthMechanism(Optional.of(fakeIdentity), tokenManager))
+        .isEqualTo(
+            Optional.of(
+                AuthenticationMechanism.newBuilder()
+                    .setIdentity(fakeIdentity.getIdentity())
+                    .setToken("access_token")
+                    .build()));
+  }
+}
diff --git a/s2a/src/test/java/io/grpc/s2a/internal/handshaker/ProtoUtilTest.java b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/ProtoUtilTest.java
new file mode 100644
index 00000000000..28dbf0e4d88
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/ProtoUtilTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static org.junit.Assert.assertThrows;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.truth.Expect;
+import com.google.s2a.proto.v2.TLSVersion;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ProtoUtil}. */
+@RunWith(JUnit4.class)
+public final class ProtoUtilTest {
+  @Rule public final Expect expect = Expect.create();
+
+  @Test
+  public void convertTlsProtocolVersion_success() {
+    expect
+        .that(ProtoUtil.convertTlsProtocolVersion(TLSVersion.TLS_VERSION_1_3))
+        .isEqualTo("TLSv1.3");
+    expect
+        .that(ProtoUtil.convertTlsProtocolVersion(TLSVersion.TLS_VERSION_1_2))
+        .isEqualTo("TLSv1.2");
+    expect
+        .that(ProtoUtil.convertTlsProtocolVersion(TLSVersion.TLS_VERSION_1_1))
+        .isEqualTo("TLSv1.1");
+    expect.that(ProtoUtil.convertTlsProtocolVersion(TLSVersion.TLS_VERSION_1_0)).isEqualTo("TLSv1");
+  }
+
+  @Test
+  public void convertTlsProtocolVersion_withUnknownTlsVersion_fails() {
+    IllegalArgumentException expected =
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> ProtoUtil.convertTlsProtocolVersion(TLSVersion.TLS_VERSION_UNSPECIFIED));
+    expect.that(expected).hasMessageThat().isEqualTo("TLS version 0 is not supported.");
+  }
+
+  @Test
+  public void buildTlsProtocolVersionSet_success() {
+    expect
+        .that(
+            ProtoUtil.buildTlsProtocolVersionSet(
+                TLSVersion.TLS_VERSION_1_0, TLSVersion.TLS_VERSION_1_3))
+        .isEqualTo(ImmutableSet.of("TLSv1", "TLSv1.1", "TLSv1.2", "TLSv1.3"));
+    expect
+        .that(
+            ProtoUtil.buildTlsProtocolVersionSet(
+                TLSVersion.TLS_VERSION_1_2, TLSVersion.TLS_VERSION_1_2))
+        .isEqualTo(ImmutableSet.of("TLSv1.2"));
+    expect
+        .that(
+            ProtoUtil.buildTlsProtocolVersionSet(
+                TLSVersion.TLS_VERSION_1_3, TLSVersion.TLS_VERSION_1_3))
+        .isEqualTo(ImmutableSet.of("TLSv1.3"));
+    expect
+        .that(
+            ProtoUtil.buildTlsProtocolVersionSet(
+                TLSVersion.TLS_VERSION_1_3, TLSVersion.TLS_VERSION_1_2))
+        .isEmpty();
+  }
+
+  @Test
+  public void buildTlsProtocolVersionSet_failure() {
+    expect
+        .that(
+            ProtoUtil.buildTlsProtocolVersionSet(
+                    TLSVersion.TLS_VERSION_UNSPECIFIED, TLSVersion.TLS_VERSION_1_3))
+        .isEqualTo(ImmutableSet.of("TLSv1", "TLSv1.1", "TLSv1.2", "TLSv1.3"));
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/test/java/io/grpc/s2a/internal/handshaker/S2APrivateKeyMethodTest.java b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/S2APrivateKeyMethodTest.java
new file mode 100644
index 00000000000..8f71496cab8
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/S2APrivateKeyMethodTest.java
@@ -0,0 +1,318 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.truth.Expect;
+import com.google.protobuf.ByteString;
+import com.google.s2a.proto.v2.OffloadPrivateKeyOperationReq;
+import com.google.s2a.proto.v2.OffloadPrivateKeyOperationResp;
+import com.google.s2a.proto.v2.SessionReq;
+import com.google.s2a.proto.v2.SessionResp;
+import com.google.s2a.proto.v2.SignatureAlgorithm;
+import io.grpc.netty.GrpcSslContexts;
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+import io.netty.handler.ssl.OpenSslPrivateKeyMethod;
+import io.netty.handler.ssl.SslContextBuilder;
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.security.PublicKey;
+import java.security.Signature;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.util.Optional;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class S2APrivateKeyMethodTest {
+  @Rule public final Expect expect = Expect.create();
+  private static final byte[] DATA_TO_SIGN = "random bytes for signing.".getBytes(UTF_8);
+
+  private S2AStub stub;
+  private FakeWriter writer;
+  private S2APrivateKeyMethod keyMethod;
+
+  private static PublicKey extractPublicKeyFromPem(String pem) throws Exception {
+    X509Certificate cert =
+        (X509Certificate)
+            CertificateFactory.getInstance("X.509")
+                .generateCertificate(new ByteArrayInputStream(pem.getBytes(UTF_8)));
+    return cert.getPublicKey();
+  }
+
+  private static boolean verifySignature(
+      byte[] dataToSign, byte[] signature, String signatureAlgorithm) throws Exception {
+    Signature sig = Signature.getInstance(signatureAlgorithm);
+    InputStream leafCert =
+        S2APrivateKeyMethodTest.class.getClassLoader().getResourceAsStream("leaf_cert_ec.pem");
+    sig.initVerify(extractPublicKeyFromPem(FakeWriter.convertInputStreamToString(
+        leafCert)));
+    leafCert.close();
+    sig.update(dataToSign);
+    return sig.verify(signature);
+  }
+
+  @Before
+  public void setUp() {
+    // This is line is to ensure that JNI correctly links the necessary objects. Without this, we
+    // get `java.lang.UnsatisfiedLinkError` on
+    // `io.netty.internal.tcnative.NativeStaticallyReferencedJniMethods.sslSignRsaPkcsSha1()`
+    GrpcSslContexts.configure(SslContextBuilder.forClient());
+
+    writer = new FakeWriter();
+    stub = S2AStub.newInstanceForTesting(writer);
+    writer.setReader(stub.getReader());
+    keyMethod = S2APrivateKeyMethod.create(stub, /* localIdentity= */ Optional.empty());
+  }
+
+  @Test
+  public void signatureAlgorithmConversion_success() {
+    expect
+        .that(
+            S2APrivateKeyMethod.convertOpenSslSignAlgToS2ASignAlg(
+                OpenSslPrivateKeyMethod.SSL_SIGN_RSA_PKCS1_SHA256))
+        .isEqualTo(SignatureAlgorithm.S2A_SSL_SIGN_RSA_PKCS1_SHA256);
+    expect
+        .that(
+            S2APrivateKeyMethod.convertOpenSslSignAlgToS2ASignAlg(
+                OpenSslPrivateKeyMethod.SSL_SIGN_RSA_PKCS1_SHA384))
+        .isEqualTo(SignatureAlgorithm.S2A_SSL_SIGN_RSA_PKCS1_SHA384);
+    expect
+        .that(
+            S2APrivateKeyMethod.convertOpenSslSignAlgToS2ASignAlg(
+                OpenSslPrivateKeyMethod.SSL_SIGN_RSA_PKCS1_SHA512))
+        .isEqualTo(SignatureAlgorithm.S2A_SSL_SIGN_RSA_PKCS1_SHA512);
+    expect
+        .that(
+            S2APrivateKeyMethod.convertOpenSslSignAlgToS2ASignAlg(
+                OpenSslPrivateKeyMethod.SSL_SIGN_ECDSA_SECP256R1_SHA256))
+        .isEqualTo(SignatureAlgorithm.S2A_SSL_SIGN_ECDSA_SECP256R1_SHA256);
+    expect
+        .that(
+            S2APrivateKeyMethod.convertOpenSslSignAlgToS2ASignAlg(
+                OpenSslPrivateKeyMethod.SSL_SIGN_ECDSA_SECP384R1_SHA384))
+        .isEqualTo(SignatureAlgorithm.S2A_SSL_SIGN_ECDSA_SECP384R1_SHA384);
+    expect
+        .that(
+            S2APrivateKeyMethod.convertOpenSslSignAlgToS2ASignAlg(
+                OpenSslPrivateKeyMethod.SSL_SIGN_ECDSA_SECP521R1_SHA512))
+        .isEqualTo(SignatureAlgorithm.S2A_SSL_SIGN_ECDSA_SECP521R1_SHA512);
+    expect
+        .that(
+            S2APrivateKeyMethod.convertOpenSslSignAlgToS2ASignAlg(
+                OpenSslPrivateKeyMethod.SSL_SIGN_RSA_PSS_RSAE_SHA256))
+        .isEqualTo(SignatureAlgorithm.S2A_SSL_SIGN_RSA_PSS_RSAE_SHA256);
+    expect
+        .that(
+            S2APrivateKeyMethod.convertOpenSslSignAlgToS2ASignAlg(
+                OpenSslPrivateKeyMethod.SSL_SIGN_RSA_PSS_RSAE_SHA384))
+        .isEqualTo(SignatureAlgorithm.S2A_SSL_SIGN_RSA_PSS_RSAE_SHA384);
+    expect
+        .that(
+            S2APrivateKeyMethod.convertOpenSslSignAlgToS2ASignAlg(
+                OpenSslPrivateKeyMethod.SSL_SIGN_RSA_PSS_RSAE_SHA512))
+        .isEqualTo(SignatureAlgorithm.S2A_SSL_SIGN_RSA_PSS_RSAE_SHA512);
+  }
+
+  @Test
+  public void signatureAlgorithmConversion_unsupportedOperation() {
+    UnsupportedOperationException e =
+        assertThrows(
+            UnsupportedOperationException.class,
+            () -> S2APrivateKeyMethod.convertOpenSslSignAlgToS2ASignAlg(-1));
+
+    assertThat(e).hasMessageThat().contains("Signature Algorithm -1 is not supported.");
+  }
+
+  @Test
+  public void createOnNullStub_returnsNullPointerException() {
+    assertThrows(
+        NullPointerException.class,
+        () -> S2APrivateKeyMethod.create(/* stub= */ null, /* localIdentity= */ Optional.empty()));
+  }
+
+  @Test
+  public void decrypt_unsupportedOperation() {
+    UnsupportedOperationException e =
+        assertThrows(
+            UnsupportedOperationException.class,
+            () -> keyMethod.decrypt(/* engine= */ null, DATA_TO_SIGN));
+
+    assertThat(e).hasMessageThat().contains("decrypt is not supported.");
+  }
+
+  @Test
+  public void fakelocalIdentity_signWithSha256_success() throws Exception {
+    S2AIdentity fakeIdentity = S2AIdentity.fromSpiffeId("fake-spiffe-id");
+    S2AStub mockStub = mock(S2AStub.class);
+    OpenSslPrivateKeyMethod keyMethodWithFakeIdentity =
+        S2APrivateKeyMethod.create(mockStub, Optional.of(fakeIdentity));
+    SessionReq req =
+        SessionReq.newBuilder()
+            .setLocalIdentity(fakeIdentity.getIdentity())
+            .setOffloadPrivateKeyOperationReq(
+                OffloadPrivateKeyOperationReq.newBuilder()
+                    .setOperation(OffloadPrivateKeyOperationReq.PrivateKeyOperation.SIGN)
+                    .setSignatureAlgorithm(SignatureAlgorithm.S2A_SSL_SIGN_ECDSA_SECP256R1_SHA256)
+                    .setRawBytes(ByteString.copyFrom(DATA_TO_SIGN)))
+            .build();
+    byte[] expectedOutbytes = "fake out bytes".getBytes(UTF_8);
+    when(mockStub.send(req))
+        .thenReturn(
+            SessionResp.newBuilder()
+                .setOffloadPrivateKeyOperationResp(
+                    OffloadPrivateKeyOperationResp.newBuilder()
+                        .setOutBytes(ByteString.copyFrom(expectedOutbytes)))
+                .build());
+
+    byte[] signature =
+        keyMethodWithFakeIdentity.sign(
+            /* engine= */ null,
+            OpenSslPrivateKeyMethod.SSL_SIGN_ECDSA_SECP256R1_SHA256,
+            DATA_TO_SIGN);
+    verify(mockStub).send(req);
+    assertThat(signature).isEqualTo(expectedOutbytes);
+  }
+
+  @Test
+  public void signWithSha256_success() throws Exception {
+    writer.initializePrivateKey().setBehavior(FakeWriter.Behavior.OK_STATUS);
+
+    byte[] signature =
+        keyMethod.sign(
+            /* engine= */ null,
+            OpenSslPrivateKeyMethod.SSL_SIGN_ECDSA_SECP256R1_SHA256,
+            DATA_TO_SIGN);
+
+    assertThat(signature).isNotEmpty();
+    assertThat(verifySignature(DATA_TO_SIGN, signature, "SHA256withECDSA")).isTrue();
+  }
+
+  @Test
+  public void signWithSha384_success() throws Exception {
+    writer.initializePrivateKey().setBehavior(FakeWriter.Behavior.OK_STATUS);
+
+    byte[] signature =
+        keyMethod.sign(
+            /* engine= */ null,
+            OpenSslPrivateKeyMethod.SSL_SIGN_ECDSA_SECP384R1_SHA384,
+            DATA_TO_SIGN);
+
+    assertThat(signature).isNotEmpty();
+    assertThat(verifySignature(DATA_TO_SIGN, signature, "SHA384withECDSA")).isTrue();
+  }
+
+  @Test
+  public void signWithSha512_success() throws Exception {
+    writer.initializePrivateKey().setBehavior(FakeWriter.Behavior.OK_STATUS);
+
+    byte[] signature =
+        keyMethod.sign(
+            /* engine= */ null,
+            OpenSslPrivateKeyMethod.SSL_SIGN_ECDSA_SECP521R1_SHA512,
+            DATA_TO_SIGN);
+
+    assertThat(signature).isNotEmpty();
+    assertThat(verifySignature(DATA_TO_SIGN, signature, "SHA512withECDSA")).isTrue();
+  }
+
+  @Test
+  public void sign_noKeyAvailable() throws Exception {
+    writer.resetPrivateKey().setBehavior(FakeWriter.Behavior.OK_STATUS);
+
+    S2AConnectionException e =
+        assertThrows(
+            S2AConnectionException.class,
+            () ->
+                keyMethod.sign(
+                    /* engine= */ null,
+                    OpenSslPrivateKeyMethod.SSL_SIGN_ECDSA_SECP256R1_SHA256,
+                    DATA_TO_SIGN));
+
+    assertThat(e)
+        .hasMessageThat()
+        .contains(
+            "Error occurred in response from S2A, error code: 255, error message: \"No Private Key"
+                + " available.\".");
+  }
+
+  @Test
+  public void sign_algorithmNotSupported() throws Exception {
+    writer.initializePrivateKey().setBehavior(FakeWriter.Behavior.OK_STATUS);
+
+    S2AConnectionException e =
+        assertThrows(
+            S2AConnectionException.class,
+            () ->
+                keyMethod.sign(
+                    /* engine= */ null,
+                    OpenSslPrivateKeyMethod.SSL_SIGN_RSA_PKCS1_SHA256,
+                    DATA_TO_SIGN));
+
+    assertThat(e)
+        .hasMessageThat()
+        .contains(
+            "Error occurred in response from S2A, error code: 255, error message: \"Only ECDSA key"
+                + " algorithms are supported.\".");
+  }
+
+  @Test
+  public void sign_getsErrorResponse() throws Exception {
+    writer.initializePrivateKey().setBehavior(FakeWriter.Behavior.ERROR_STATUS);
+
+    S2AConnectionException e =
+        assertThrows(
+            S2AConnectionException.class,
+            () ->
+                keyMethod.sign(
+                    /* engine= */ null,
+                    OpenSslPrivateKeyMethod.SSL_SIGN_ECDSA_SECP256R1_SHA256,
+                    DATA_TO_SIGN));
+
+    assertThat(e)
+        .hasMessageThat()
+        .contains(
+            "Error occurred in response from S2A, error code: 1, error message: \"Intended ERROR"
+                + " Status from FakeWriter.\".");
+  }
+
+  @Test
+  public void sign_getsEmptyResponse() throws Exception {
+    writer.initializePrivateKey().setBehavior(FakeWriter.Behavior.EMPTY_RESPONSE);
+
+    S2AConnectionException e =
+        assertThrows(
+            S2AConnectionException.class,
+            () ->
+                keyMethod.sign(
+                    /* engine= */ null,
+                    OpenSslPrivateKeyMethod.SSL_SIGN_ECDSA_SECP256R1_SHA256,
+                    DATA_TO_SIGN));
+
+    assertThat(e).hasMessageThat().contains("No valid response received from S2A.");
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/test/java/io/grpc/s2a/internal/handshaker/S2AProtocolNegotiatorFactoryTest.java b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/S2AProtocolNegotiatorFactoryTest.java
new file mode 100644
index 00000000000..7e776f16da2
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/S2AProtocolNegotiatorFactoryTest.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.testing.NullPointerTester;
+import com.google.common.testing.NullPointerTester.Visibility;
+import com.google.s2a.proto.v2.S2AServiceGrpc;
+import com.google.s2a.proto.v2.SessionReq;
+import com.google.s2a.proto.v2.SessionResp;
+import io.grpc.Channel;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.benchmarks.Utils;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.internal.TestUtils.NoopChannelLogger;
+import io.grpc.netty.GrpcHttp2ConnectionHandler;
+import io.grpc.netty.InternalProtocolNegotiator;
+import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
+import io.grpc.s2a.internal.channel.S2AHandshakerServiceChannel;
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+import io.grpc.s2a.internal.handshaker.S2AProtocolNegotiatorFactory.S2AProtocolNegotiator;
+import io.grpc.stub.StreamObserver;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.embedded.EmbeddedChannel;
+import io.netty.handler.codec.http2.Http2ConnectionDecoder;
+import io.netty.handler.codec.http2.Http2ConnectionEncoder;
+import io.netty.handler.codec.http2.Http2Settings;
+import io.netty.util.AsciiString;
+import java.io.IOException;
+import java.util.Optional;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link S2AProtocolNegotiatorFactory}. */
+@RunWith(JUnit4.class)
+public class S2AProtocolNegotiatorFactoryTest {
+  private static final S2AIdentity LOCAL_IDENTITY = S2AIdentity.fromSpiffeId("local identity");
+  private final ChannelHandlerContext mockChannelHandlerContext = mock(ChannelHandlerContext.class);
+  private GrpcHttp2ConnectionHandler fakeConnectionHandler;
+  private String authority;
+  private int port;
+  private Server fakeS2AServer;
+  private ObjectPool<Channel> channelPool;
+
+  @Before
+  public void setUp() throws Exception {
+    port = Utils.pickUnusedPort();
+    fakeS2AServer = ServerBuilder.forPort(port).addService(new S2AServiceImpl()).build();
+    fakeS2AServer.start();
+    channelPool = new FakeChannelPool();
+    authority = "localhost:" + port;
+    fakeConnectionHandler = FakeConnectionHandler.create(authority);
+  }
+
+  @After
+  public void tearDown() {
+    fakeS2AServer.shutdown();
+  }
+
+  @Test
+  public void handlerRemoved_success() throws Exception {
+    S2AProtocolNegotiatorFactory.BufferReadsHandler handler1 =
+        new S2AProtocolNegotiatorFactory.BufferReadsHandler();
+    S2AProtocolNegotiatorFactory.BufferReadsHandler handler2 =
+        new S2AProtocolNegotiatorFactory.BufferReadsHandler();
+    EmbeddedChannel channel = new EmbeddedChannel(handler1, handler2);
+    channel.writeInbound("message1");
+    channel.writeInbound("message2");
+    channel.writeInbound("message3");
+    assertThat(handler1.getReads()).hasSize(3);
+    assertThat(handler2.getReads()).isEmpty();
+    channel.pipeline().remove(handler1);
+    assertThat(handler2.getReads()).hasSize(3);
+  }
+
+  @Test
+  public void createProtocolNegotiatorFactory_nullArgument() throws Exception {
+    NullPointerTester tester = new NullPointerTester().setDefault(Optional.class, Optional.empty());
+
+    tester.testStaticMethods(S2AProtocolNegotiatorFactory.class, Visibility.PUBLIC);
+  }
+
+  @Test
+  public void createProtocolNegotiator_nullArgument() throws Exception {
+    ObjectPool<Channel> pool =
+            SharedResourcePool.forResource(
+                S2AHandshakerServiceChannel.getChannelResource(
+                    "localhost:8080", InsecureChannelCredentials.create()));
+
+    NullPointerTester tester =
+        new NullPointerTester()
+            .setDefault(ObjectPool.class, pool)
+            .setDefault(Optional.class, Optional.empty());
+
+    tester.testStaticMethods(S2AProtocolNegotiator.class, Visibility.PACKAGE);
+  }
+
+  @Test
+  public void createProtocolNegotiatorFactory_getsDefaultPort_succeeds() throws Exception {
+    InternalProtocolNegotiator.ClientFactory clientFactory =
+        S2AProtocolNegotiatorFactory.createClientFactory(LOCAL_IDENTITY, channelPool, null);
+
+    assertThat(clientFactory.getDefaultPort()).isEqualTo(S2AProtocolNegotiatorFactory.DEFAULT_PORT);
+  }
+
+  @Test
+  public void s2aProtocolNegotiator_getHostNameOnNull_returnsNull() throws Exception {
+    assertThat(S2AProtocolNegotiatorFactory.S2AProtocolNegotiator.getHostNameFromAuthority(null))
+        .isNull();
+  }
+
+  @Test
+  public void s2aProtocolNegotiator_getHostNameOnValidAuthority_returnsValidHostname()
+      throws Exception {
+    assertThat(
+            S2AProtocolNegotiatorFactory.S2AProtocolNegotiator.getHostNameFromAuthority(
+                "hostname:80"))
+        .isEqualTo("hostname");
+  }
+
+  @Test
+  public void createProtocolNegotiatorFactory_buildsAnS2AProtocolNegotiatorOnClientSide_succeeds()
+      throws Exception {
+    InternalProtocolNegotiator.ClientFactory clientFactory =
+        S2AProtocolNegotiatorFactory.createClientFactory(LOCAL_IDENTITY, channelPool, null);
+
+    ProtocolNegotiator clientNegotiator = clientFactory.newNegotiator();
+
+    assertThat(clientNegotiator).isInstanceOf(S2AProtocolNegotiator.class);
+    assertThat(clientNegotiator.scheme()).isEqualTo(AsciiString.of("https"));
+  }
+
+  @Test
+  public void closeProtocolNegotiator_verifyProtocolNegotiatorIsClosedOnClientSide()
+      throws Exception {
+    InternalProtocolNegotiator.ClientFactory clientFactory =
+        S2AProtocolNegotiatorFactory.createClientFactory(LOCAL_IDENTITY, channelPool, null);
+    ProtocolNegotiator clientNegotiator = clientFactory.newNegotiator();
+
+    clientNegotiator.close();
+
+    assertThat(((FakeChannelPool) channelPool).isChannelCached()).isFalse();
+  }
+
+  @Test
+  public void createChannelHandler_addHandlerToMockContext() throws Exception {
+    ProtocolNegotiator clientNegotiator =
+        S2AProtocolNegotiatorFactory.S2AProtocolNegotiator.createForClient(
+            channelPool, LOCAL_IDENTITY, null);
+
+    ChannelHandler channelHandler = clientNegotiator.newHandler(fakeConnectionHandler);
+
+    ((ChannelDuplexHandler) channelHandler).userEventTriggered(mockChannelHandlerContext, "event");
+    verify(mockChannelHandlerContext).fireUserEventTriggered("event");
+  }
+
+  /** A {@code GrpcHttp2ConnectionHandler} that does nothing. */
+  private static class FakeConnectionHandler extends GrpcHttp2ConnectionHandler {
+    private static final Http2ConnectionDecoder DECODER = mock(Http2ConnectionDecoder.class);
+    private static final Http2ConnectionEncoder ENCODER = mock(Http2ConnectionEncoder.class);
+    private static final Http2Settings SETTINGS = new Http2Settings();
+    private final String authority;
+
+    static FakeConnectionHandler create(String authority) {
+      return new FakeConnectionHandler(null, DECODER, ENCODER, SETTINGS, authority);
+    }
+
+    private FakeConnectionHandler(
+        ChannelPromise channelUnused,
+        Http2ConnectionDecoder decoder,
+        Http2ConnectionEncoder encoder,
+        Http2Settings initialSettings,
+        String authority) {
+      super(channelUnused, decoder, encoder, initialSettings, new NoopChannelLogger());
+      this.authority = authority;
+    }
+
+    @Override
+    public String getAuthority() {
+      return authority;
+    }
+  }
+
+  /** An S2A server that handles GetTlsConfiguration request. */
+  private static class S2AServiceImpl extends S2AServiceGrpc.S2AServiceImplBase {
+    static final FakeWriter writer = new FakeWriter();
+
+    @Override
+    public StreamObserver<SessionReq> setUpSession(StreamObserver<SessionResp> responseObserver) {
+      return new StreamObserver<SessionReq>() {
+        @Override
+        public void onNext(SessionReq req) {
+          try {
+            responseObserver.onNext(writer.handleResponse(req));
+          } catch (IOException e) {
+            responseObserver.onError(e);
+          }
+        }
+
+        @Override
+        public void onError(Throwable t) {}
+
+        @Override
+        public void onCompleted() {}
+      };
+    }
+  }
+
+  private static class FakeChannelPool implements ObjectPool<Channel> {
+    private final Channel mockChannel = mock(Channel.class);
+    private @Nullable Channel cachedChannel = null;
+
+    @Override
+    public Channel getObject() {
+      if (cachedChannel == null) {
+        cachedChannel = mockChannel;
+      }
+      return cachedChannel;
+    }
+
+    @Override
+    public Channel returnObject(Object object) {
+      assertThat(object).isSameInstanceAs(mockChannel);
+      cachedChannel = null;
+      return null;
+    }
+
+    public boolean isChannelCached() {
+      return (cachedChannel != null);
+    }
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/test/java/io/grpc/s2a/internal/handshaker/S2AStubTest.java b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/S2AStubTest.java
new file mode 100644
index 00000000000..713984c361d
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/S2AStubTest.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import com.google.common.truth.Expect;
+import com.google.s2a.proto.v2.Ciphersuite;
+import com.google.s2a.proto.v2.ConnectionSide;
+import com.google.s2a.proto.v2.GetTlsConfigurationReq;
+import com.google.s2a.proto.v2.GetTlsConfigurationResp;
+import com.google.s2a.proto.v2.S2AServiceGrpc;
+import com.google.s2a.proto.v2.SessionReq;
+import com.google.s2a.proto.v2.SessionResp;
+import com.google.s2a.proto.v2.Status;
+import com.google.s2a.proto.v2.TLSVersion;
+import io.grpc.Channel;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourcePool;
+import io.grpc.s2a.internal.channel.S2AHandshakerServiceChannel;
+import io.grpc.stub.StreamObserver;
+import java.io.IOException;
+import java.io.InputStream;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link S2AStub}. */
+@RunWith(JUnit4.class)
+public class S2AStubTest {
+  @Rule public final Expect expect = Expect.create();
+  private static final String S2A_ADDRESS = "localhost:8080";
+  private S2AStub stub;
+  private FakeWriter writer;
+
+  @Before
+  public void setUp() {
+    writer = new FakeWriter();
+    stub = S2AStub.newInstanceForTesting(writer);
+    writer.setReader(stub.getReader());
+  }
+
+  @Test
+  public void send_receiveOkStatus() throws Exception {
+    ObjectPool<Channel> channelPool =
+        SharedResourcePool.forResource(
+            S2AHandshakerServiceChannel.getChannelResource(
+                S2A_ADDRESS, InsecureChannelCredentials.create()));
+    S2AServiceGrpc.S2AServiceStub serviceStub = S2AServiceGrpc.newStub(channelPool.getObject());
+    S2AStub newStub = S2AStub.newInstance(serviceStub);
+
+    IOException expected =
+        assertThrows(IOException.class, () -> newStub.send(SessionReq.getDefaultInstance()));
+
+    assertThat(expected).hasMessageThat().contains("DEADLINE_EXCEEDED");
+  }
+
+  @Test
+  public void send_clientTlsConfiguration_receiveOkStatus() throws Exception {
+    SessionReq req =
+        SessionReq.newBuilder()
+            .setGetTlsConfigurationReq(
+                GetTlsConfigurationReq.newBuilder()
+                    .setConnectionSide(ConnectionSide.CONNECTION_SIDE_CLIENT))
+            .build();
+
+    SessionResp resp = stub.send(req);
+
+    String leafCertString = "";
+    String cert2String = "";
+    String cert1String = "";
+    ClassLoader classLoader = S2AStubTest.class.getClassLoader();
+    try (
+        InputStream leafCert = classLoader.getResourceAsStream("leaf_cert_ec.pem");
+        InputStream cert2 = classLoader.getResourceAsStream("int_cert2_ec.pem");
+        InputStream cert1 = classLoader.getResourceAsStream("int_cert1_ec.pem");
+    ) {
+      leafCertString = FakeWriter.convertInputStreamToString(leafCert);
+      cert2String = FakeWriter.convertInputStreamToString(cert2);
+      cert1String = FakeWriter.convertInputStreamToString(cert1);
+    }
+
+    SessionResp expected =
+        SessionResp.newBuilder()
+            .setGetTlsConfigurationResp(
+                GetTlsConfigurationResp.newBuilder()
+                    .setClientTlsConfiguration(
+                        GetTlsConfigurationResp.ClientTlsConfiguration.newBuilder()
+                            .addCertificateChain(leafCertString)
+                            .addCertificateChain(cert1String)
+                            .addCertificateChain(cert2String)
+                            .setMinTlsVersion(TLSVersion.TLS_VERSION_1_3)
+                            .setMaxTlsVersion(TLSVersion.TLS_VERSION_1_3)
+                            .addCiphersuites(
+                                Ciphersuite.CIPHERSUITE_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)
+                            .addCiphersuites(
+                                Ciphersuite.CIPHERSUITE_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)
+                            .addCiphersuites(
+                                Ciphersuite.CIPHERSUITE_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256)))
+            .build();
+    assertThat(resp).ignoringRepeatedFieldOrder().isEqualTo(expected);
+  }
+
+  @Test
+  public void send_serverTlsConfiguration_receiveErrorStatus() throws Exception {
+    SessionReq req =
+        SessionReq.newBuilder()
+            .setGetTlsConfigurationReq(
+                GetTlsConfigurationReq.newBuilder()
+                    .setConnectionSide(ConnectionSide.CONNECTION_SIDE_SERVER))
+            .build();
+
+    SessionResp resp = stub.send(req);
+
+    SessionResp expected =
+        SessionResp.newBuilder()
+            .setStatus(
+                Status.newBuilder()
+                    .setCode(255)
+                    .setDetails("No TLS configuration for the server side."))
+            .build();
+    assertThat(resp).isEqualTo(expected);
+  }
+
+  @Test
+  public void send_receiveErrorStatus() throws Exception {
+    writer.setBehavior(FakeWriter.Behavior.ERROR_STATUS);
+
+    SessionResp resp = stub.send(SessionReq.getDefaultInstance());
+
+    SessionResp expected =
+        SessionResp.newBuilder()
+            .setStatus(
+                Status.newBuilder().setCode(1).setDetails("Intended ERROR Status from FakeWriter."))
+            .build();
+    assertThat(resp).isEqualTo(expected);
+  }
+
+  @Test
+  public void send_receiveErrorResponse() throws InterruptedException {
+    writer.setBehavior(FakeWriter.Behavior.ERROR_RESPONSE);
+
+    IOException expected =
+        assertThrows(IOException.class, () -> stub.send(SessionReq.getDefaultInstance()));
+
+    expect.that(expected).hasCauseThat().isInstanceOf(RuntimeException.class);
+    expect.that(expected).hasMessageThat().contains("Intended ERROR from FakeWriter.");
+  }
+
+  @Test
+  public void send_receiveCompleteStatus() throws Exception {
+    writer.setBehavior(FakeWriter.Behavior.COMPLETE_STATUS);
+
+    ConnectionClosedException expected =
+        assertThrows(
+            ConnectionClosedException.class, () -> stub.send(SessionReq.getDefaultInstance()));
+
+    assertThat(expected).hasMessageThat().contains("Reading from the S2A is complete.");
+  }
+
+  @Test
+  public void send_receiveUnexpectedResponse() throws Exception {
+    writer.sendIoError();
+
+    IOException expected =
+        assertThrows(IOException.class, () -> stub.send(SessionReq.getDefaultInstance()));
+
+    assertThat(expected)
+        .hasMessageThat()
+        .contains(
+            "Received an unexpected response from a host at the S2A's address. The S2A might be"
+                + " unavailable.");
+  }
+
+  @Test
+  public void send_receiveManyUnexpectedResponse_expectResponsesEmpty() throws Exception {
+    writer.sendIoError();
+    writer.sendIoError();
+    writer.sendIoError();
+
+    IOException expected =
+        assertThrows(IOException.class, () -> stub.send(SessionReq.getDefaultInstance()));
+
+    assertThat(expected)
+        .hasMessageThat()
+        .contains(
+            "Received an unexpected response from a host at the S2A's address. The S2A might be"
+                + " unavailable.");
+
+    assertThat(stub.getResponses()).isEmpty();
+  }
+
+  @Test
+  public void send_receiveDelayedResponse() throws Exception {
+    writer.sendGetTlsConfigResp();
+    IOException expectedException =
+        assertThrows(IOException.class, () -> stub.send(SessionReq.getDefaultInstance()));
+    assertThat(expectedException)
+        .hasMessageThat()
+        .contains("Received an unexpected response from a host at the S2A's address.");
+
+    assertThat(stub.getResponses()).isEmpty();
+  }
+
+  @Test
+  public void send_afterEarlyClose_receivesClosedException() throws InterruptedException {
+    stub.close();
+    expect.that(writer.isFakeWriterClosed()).isTrue();
+
+    ConnectionClosedException expected =
+        assertThrows(
+            ConnectionClosedException.class, () -> stub.send(SessionReq.getDefaultInstance()));
+
+    assertThat(expected).hasMessageThat().contains("Stream to the S2A is closed.");
+  }
+
+  @Test
+  public void send_failToWrite() throws Exception {
+    FailWriter failWriter = new FailWriter();
+    stub = S2AStub.newInstanceForTesting(failWriter);
+
+    IOException expected =
+        assertThrows(IOException.class, () -> stub.send(SessionReq.getDefaultInstance()));
+
+    expect.that(expected).hasCauseThat().isInstanceOf(S2AConnectionException.class);
+    expect
+        .that(expected)
+        .hasCauseThat()
+        .hasMessageThat()
+        .isEqualTo("Could not send request to S2A.");
+  }
+
+  /** Fails whenever a write is attempted. */
+  private static class FailWriter implements StreamObserver<SessionReq> {
+    @Override
+    public void onNext(SessionReq req) {
+      assertThat(req).isNotNull();
+      throw new S2AConnectionException("Could not send request to S2A.");
+    }
+
+    @Override
+    public void onError(Throwable t) {
+      assertThat(t).isInstanceOf(S2AConnectionException.class);
+    }
+
+    @Override
+    public void onCompleted() {
+      throw new UnsupportedOperationException();
+    }
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/test/java/io/grpc/s2a/internal/handshaker/S2ATrustManagerTest.java b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/S2ATrustManagerTest.java
new file mode 100644
index 00000000000..198001838aa
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/S2ATrustManagerTest.java
@@ -0,0 +1,262 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+import java.io.ByteArrayInputStream;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.util.Base64;
+import java.util.Optional;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class S2ATrustManagerTest {
+  private S2AStub stub;
+  private FakeWriter writer;
+  private static final String FAKE_HOSTNAME = "Fake-Hostname";
+  private static final String CLIENT_CERT_PEM =
+      "MIICKjCCAc+gAwIBAgIUC2GShcVO+5Zkml+7VO3OQ+B2c7EwCgYIKoZIzj0EAwIw"
+          + "HzEdMBsGA1UEAwwUcm9vdGNlcnQuZXhhbXBsZS5jb20wIBcNMjMwMTI2MTk0OTUx"
+          + "WhgPMjA1MDA2MTMxOTQ5NTFaMB8xHTAbBgNVBAMMFGxlYWZjZXJ0LmV4YW1wbGUu"
+          + "Y29tMFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeciYZgFAZjxyzTrklCRIWpad"
+          + "8wkyCZQzJSf0IfNn9NKtfzL2V/blteULO0o9Da8e2Avaj+XCKfFTc7salMo/waOB"
+          + "5jCB4zAOBgNVHQ8BAf8EBAMCB4AwIAYDVR0lAQH/BBYwFAYIKwYBBQUHAwIGCCsG"
+          + "AQUFBwMBMAwGA1UdEwEB/wQCMAAwYQYDVR0RBFowWIYic3BpZmZlOi8vZm9vLnBy"
+          + "b2QuZ29vZ2xlLmNvbS9wMS9wMoIUZm9vLnByb2Quc3BpZmZlLmdvb2eCHG1hY2hp"
+          + "bmUtbmFtZS5wcm9kLmdvb2dsZS5jb20wHQYDVR0OBBYEFETY6Cu/aW924nfvUrOs"
+          + "yXCC1hrpMB8GA1UdIwQYMBaAFJLkXGlTYKISiGd+K/Ijh4IOEpHBMAoGCCqGSM49"
+          + "BAMCA0kAMEYCIQCZDW472c1/4jEOHES/88X7NTqsYnLtIpTjp5PZ62z3sAIhAN1J"
+          + "vxvbxt9ySdFO+cW7oLBEkCwUicBhxJi5VfQeQypT";
+
+  @Before
+  public void setUp() {
+    writer = new FakeWriter();
+    stub = S2AStub.newInstanceForTesting(writer);
+    writer.setReader(stub.getReader());
+  }
+
+  @Test
+  public void createForClient_withNullStub_throwsError() {
+    NullPointerException expected =
+        assertThrows(
+            NullPointerException.class,
+            () ->
+                S2ATrustManager.createForClient(
+                    /* stub= */ null, FAKE_HOSTNAME, /* localIdentity= */ Optional.empty()));
+
+    assertThat(expected).hasMessageThat().isNull();
+  }
+
+  @Test
+  public void createForClient_withNullHostname_throwsError() {
+    NullPointerException expected =
+        assertThrows(
+            NullPointerException.class,
+            () ->
+                S2ATrustManager.createForClient(
+                    stub, /* hostname= */ null, /* localIdentity= */ Optional.empty()));
+
+    assertThat(expected).hasMessageThat().isNull();
+  }
+
+  @Test
+  public void getAcceptedIssuers_returnsExpectedNullResult() {
+    S2ATrustManager trustManager =
+        S2ATrustManager.createForClient(stub, FAKE_HOSTNAME, /* localIdentity= */ Optional.empty());
+
+    assertThat(trustManager.getAcceptedIssuers()).isNull();
+  }
+
+  @Test
+  public void checkClientTrusted_withEmptyCertificateChain_throwsException()
+      throws CertificateException {
+    writer.setVerificationResult(FakeWriter.VerificationResult.SUCCESS);
+    S2ATrustManager trustManager =
+        S2ATrustManager.createForClient(stub, FAKE_HOSTNAME, /* localIdentity= */ Optional.empty());
+
+    IllegalArgumentException expected =
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> trustManager.checkClientTrusted(new X509Certificate[] {}, /* authType= */ ""));
+
+    assertThat(expected).hasMessageThat().contains("Certificate chain has zero certificates.");
+  }
+
+  @Test
+  public void checkServerTrusted_withEmptyCertificateChain_throwsException()
+      throws CertificateException {
+    writer.setVerificationResult(FakeWriter.VerificationResult.SUCCESS);
+    S2ATrustManager trustManager =
+        S2ATrustManager.createForClient(stub, FAKE_HOSTNAME, /* localIdentity= */ Optional.empty());
+
+    IllegalArgumentException expected =
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> trustManager.checkServerTrusted(new X509Certificate[] {}, /* authType= */ ""));
+
+    assertThat(expected).hasMessageThat().contains("Certificate chain has zero certificates.");
+  }
+
+  @Test
+  public void checkClientTrusted_getsSuccessResponse() throws CertificateException {
+    writer.setVerificationResult(FakeWriter.VerificationResult.SUCCESS);
+    S2ATrustManager trustManager =
+        S2ATrustManager.createForClient(stub, FAKE_HOSTNAME, /* localIdentity= */ Optional.empty());
+
+    // Expect no exception.
+    trustManager.checkClientTrusted(getCerts(), /* authType= */ "");
+  }
+
+  @Test
+  public void checkClientTrusted_withLocalIdentity_getsSuccessResponse()
+      throws CertificateException {
+    writer.setVerificationResult(FakeWriter.VerificationResult.SUCCESS);
+    S2ATrustManager trustManager =
+        S2ATrustManager.createForClient(
+            stub, FAKE_HOSTNAME, Optional.of(S2AIdentity.fromSpiffeId("fake-spiffe-id")));
+
+    // Expect no exception.
+    trustManager.checkClientTrusted(getCerts(), /* authType= */ "");
+  }
+
+  @Test
+  public void checkServerTrusted_getsSuccessResponse() throws CertificateException {
+    writer.setVerificationResult(FakeWriter.VerificationResult.SUCCESS);
+    S2ATrustManager trustManager =
+        S2ATrustManager.createForClient(stub, FAKE_HOSTNAME, /* localIdentity= */ Optional.empty());
+
+    // Expect no exception.
+    trustManager.checkServerTrusted(getCerts(), /* authType= */ "");
+  }
+
+  @Test
+  public void checkServerTrusted_withLocalIdentity_getsSuccessResponse()
+      throws CertificateException {
+    writer.setVerificationResult(FakeWriter.VerificationResult.SUCCESS);
+    S2ATrustManager trustManager =
+        S2ATrustManager.createForClient(
+            stub, FAKE_HOSTNAME, Optional.of(S2AIdentity.fromSpiffeId("fake-spiffe-id")));
+
+    // Expect no exception.
+    trustManager.checkServerTrusted(getCerts(), /* authType= */ "");
+  }
+
+  @Test
+  public void checkClientTrusted_getsIntendedFailureResponse() throws CertificateException {
+    writer
+        .setVerificationResult(FakeWriter.VerificationResult.FAILURE)
+        .setFailureReason("Intended failure.");
+    S2ATrustManager trustManager =
+        S2ATrustManager.createForClient(stub, FAKE_HOSTNAME, /* localIdentity= */ Optional.empty());
+
+    CertificateException expected =
+        assertThrows(
+            CertificateException.class,
+            () -> trustManager.checkClientTrusted(getCerts(), /* authType= */ ""));
+
+    assertThat(expected).hasMessageThat().contains("Intended failure.");
+  }
+
+  @Test
+  public void checkClientTrusted_getsIntendedFailureStatusInResponse() throws CertificateException {
+    writer.setBehavior(FakeWriter.Behavior.ERROR_STATUS);
+    S2ATrustManager trustManager =
+        S2ATrustManager.createForClient(stub, FAKE_HOSTNAME, /* localIdentity= */ Optional.empty());
+
+    CertificateException expected =
+        assertThrows(
+            CertificateException.class,
+            () -> trustManager.checkClientTrusted(getCerts(), /* authType= */ ""));
+
+    assertThat(expected).hasMessageThat().contains("Error occurred in response from S2A");
+  }
+
+  @Test
+  public void checkClientTrusted_getsIntendedFailureFromServer() throws CertificateException {
+    writer.setBehavior(FakeWriter.Behavior.ERROR_RESPONSE);
+    S2ATrustManager trustManager =
+        S2ATrustManager.createForClient(stub, FAKE_HOSTNAME, /* localIdentity= */ Optional.empty());
+
+    CertificateException expected =
+        assertThrows(
+            CertificateException.class,
+            () -> trustManager.checkClientTrusted(getCerts(), /* authType= */ ""));
+
+    assertThat(expected).hasMessageThat().isEqualTo("Failed to send request to S2A.");
+  }
+
+  @Test
+  public void checkServerTrusted_getsIntendedFailureResponse() throws CertificateException {
+    writer
+        .setVerificationResult(FakeWriter.VerificationResult.FAILURE)
+        .setFailureReason("Intended failure.");
+    S2ATrustManager trustManager =
+        S2ATrustManager.createForClient(stub, FAKE_HOSTNAME, /* localIdentity= */ Optional.empty());
+
+    CertificateException expected =
+        assertThrows(
+            CertificateException.class,
+            () -> trustManager.checkServerTrusted(getCerts(), /* authType= */ ""));
+
+    assertThat(expected).hasMessageThat().contains("Intended failure.");
+  }
+
+  @Test
+  public void checkServerTrusted_getsIntendedFailureStatusInResponse() throws CertificateException {
+    writer.setBehavior(FakeWriter.Behavior.ERROR_STATUS);
+    S2ATrustManager trustManager =
+        S2ATrustManager.createForClient(stub, FAKE_HOSTNAME, /* localIdentity= */ Optional.empty());
+
+    CertificateException expected =
+        assertThrows(
+            CertificateException.class,
+            () -> trustManager.checkServerTrusted(getCerts(), /* authType= */ ""));
+
+    assertThat(expected).hasMessageThat().contains("Error occurred in response from S2A");
+  }
+
+  @Test
+  public void checkServerTrusted_getsIntendedFailureFromServer() throws CertificateException {
+    writer.setBehavior(FakeWriter.Behavior.ERROR_RESPONSE);
+    S2ATrustManager trustManager =
+        S2ATrustManager.createForClient(stub, FAKE_HOSTNAME, /* localIdentity= */ Optional.empty());
+
+    CertificateException expected =
+        assertThrows(
+            CertificateException.class,
+            () -> trustManager.checkServerTrusted(getCerts(), /* authType= */ ""));
+
+    assertThat(expected).hasMessageThat().isEqualTo("Failed to send request to S2A.");
+  }
+
+  private X509Certificate[] getCerts() throws CertificateException {
+    byte[] decoded = Base64.getDecoder().decode(CLIENT_CERT_PEM);
+    return new X509Certificate[] {
+      (X509Certificate)
+          CertificateFactory.getInstance("X.509")
+              .generateCertificate(new ByteArrayInputStream(decoded))
+    };
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/test/java/io/grpc/s2a/internal/handshaker/SslContextFactoryTest.java b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/SslContextFactoryTest.java
new file mode 100644
index 00000000000..17b834abf2a
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/SslContextFactoryTest.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import com.google.common.truth.Expect;
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+import io.netty.handler.ssl.OpenSslSessionContext;
+import io.netty.handler.ssl.SslContext;
+import java.security.GeneralSecurityException;
+import java.util.Optional;
+import javax.net.ssl.SSLSessionContext;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link SslContextFactory}. */
+@RunWith(JUnit4.class)
+public final class SslContextFactoryTest {
+  @Rule public final Expect expect = Expect.create();
+  private static final String FAKE_TARGET_NAME = "fake_target_name";
+  private S2AStub stub;
+  private FakeWriter writer;
+
+  @Before
+  public void setUp() {
+    writer = new FakeWriter();
+    stub = S2AStub.newInstanceForTesting(writer);
+    writer.setReader(stub.getReader());
+  }
+
+  @Test
+  public void createForClient_returnsValidSslContext() throws Exception {
+    SslContext sslContext =
+        SslContextFactory.createForClient(
+            stub, FAKE_TARGET_NAME, /* localIdentity= */ Optional.empty());
+
+    expect.that(sslContext).isNotNull();
+    expect.that(sslContext.sessionCacheSize()).isEqualTo(1);
+    expect.that(sslContext.sessionTimeout()).isEqualTo(300);
+    expect.that(sslContext.isClient()).isTrue();
+    expect.that(sslContext.applicationProtocolNegotiator().protocols()).containsExactly("h2");
+    SSLSessionContext sslSessionContext = sslContext.sessionContext();
+    if (sslSessionContext instanceof OpenSslSessionContext) {
+      OpenSslSessionContext openSslSessionContext = (OpenSslSessionContext) sslSessionContext;
+      expect.that(openSslSessionContext.isSessionCacheEnabled()).isFalse();
+    }
+  }
+
+  @Test
+  public void createForClient_withLocalIdentity_returnsValidSslContext() throws Exception {
+    SslContext sslContext =
+        SslContextFactory.createForClient(
+            stub, FAKE_TARGET_NAME, Optional.of(S2AIdentity.fromSpiffeId("fake-spiffe-id")));
+
+    expect.that(sslContext).isNotNull();
+    expect.that(sslContext.sessionCacheSize()).isEqualTo(1);
+    expect.that(sslContext.sessionTimeout()).isEqualTo(300);
+    expect.that(sslContext.isClient()).isTrue();
+    expect.that(sslContext.applicationProtocolNegotiator().protocols()).containsExactly("h2");
+    SSLSessionContext sslSessionContext = sslContext.sessionContext();
+    if (sslSessionContext instanceof OpenSslSessionContext) {
+      OpenSslSessionContext openSslSessionContext = (OpenSslSessionContext) sslSessionContext;
+      expect.that(openSslSessionContext.isSessionCacheEnabled()).isFalse();
+    }
+  }
+
+  @Test
+  public void createForClient_returnsEmptyResponse_error() throws Exception {
+    writer.setBehavior(FakeWriter.Behavior.EMPTY_RESPONSE);
+
+    S2AConnectionException expected =
+        assertThrows(
+            S2AConnectionException.class,
+            () ->
+                SslContextFactory.createForClient(
+                    stub, FAKE_TARGET_NAME, /* localIdentity= */ Optional.empty()));
+
+    assertThat(expected)
+        .hasMessageThat()
+        .contains("Response from S2A server does NOT contain ClientTlsConfiguration.");
+  }
+
+  @Test
+  public void createForClient_returnsErrorStatus_error() throws Exception {
+    writer.setBehavior(FakeWriter.Behavior.ERROR_STATUS);
+
+    S2AConnectionException expected =
+        assertThrows(
+            S2AConnectionException.class,
+            () ->
+                SslContextFactory.createForClient(
+                    stub, FAKE_TARGET_NAME, /* localIdentity= */ Optional.empty()));
+
+    assertThat(expected).hasMessageThat().contains("Intended ERROR Status from FakeWriter.");
+  }
+
+  @Test
+  public void createForClient_getsErrorFromServer_throwsError() throws Exception {
+    writer.sendIoError();
+
+    GeneralSecurityException expected =
+        assertThrows(
+            GeneralSecurityException.class,
+            () ->
+                SslContextFactory.createForClient(
+                    stub, FAKE_TARGET_NAME, /* localIdentity= */ Optional.empty()));
+
+    assertThat(expected)
+        .hasMessageThat()
+        .contains("Failed to get client TLS configuration from S2A.");
+  }
+
+  @Test
+  public void createForClient_getsBadTlsVersionsFromServer_throwsError() throws Exception {
+    writer.setBehavior(FakeWriter.Behavior.BAD_TLS_VERSION_RESPONSE);
+
+    S2AConnectionException expected =
+        assertThrows(
+            S2AConnectionException.class,
+            () ->
+                SslContextFactory.createForClient(
+                    stub, FAKE_TARGET_NAME, /* localIdentity= */ Optional.empty()));
+
+    assertThat(expected)
+        .hasMessageThat()
+        .contains("Set of TLS versions received from S2A server is empty or not supported.");
+  }
+
+  @Test
+  public void createForClient_nullStub_throwsError() throws Exception {
+    writer.sendUnexpectedResponse();
+
+    NullPointerException expected =
+        assertThrows(
+            NullPointerException.class,
+            () ->
+                SslContextFactory.createForClient(
+                    /* stub= */ null, FAKE_TARGET_NAME, /* localIdentity= */ Optional.empty()));
+
+    assertThat(expected).hasMessageThat().isEqualTo("stub should not be null.");
+  }
+
+  @Test
+  public void createForClient_nullTargetName_throwsError() throws Exception {
+    writer.sendUnexpectedResponse();
+
+    NullPointerException expected =
+        assertThrows(
+            NullPointerException.class,
+            () ->
+                SslContextFactory.createForClient(
+                    stub, /* targetName= */ null, /* localIdentity= */ Optional.empty()));
+
+    assertThat(expected)
+        .hasMessageThat()
+        .isEqualTo("targetName should not be null on client side.");
+  }
+}
\ No newline at end of file
diff --git a/s2a/src/test/java/io/grpc/s2a/internal/handshaker/tokenmanager/SingleTokenAccessTokenManagerTest.java b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/tokenmanager/SingleTokenAccessTokenManagerTest.java
new file mode 100644
index 00000000000..9fd33fe9070
--- /dev/null
+++ b/s2a/src/test/java/io/grpc/s2a/internal/handshaker/tokenmanager/SingleTokenAccessTokenManagerTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2024 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.s2a.internal.handshaker.tokenmanager;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.s2a.internal.handshaker.S2AIdentity;
+import java.util.Optional;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class SingleTokenAccessTokenManagerTest {
+  private static final S2AIdentity IDENTITY = S2AIdentity.fromSpiffeId("spiffe_id");
+  private static final String TOKEN = "token";
+
+  private String originalAccessToken;
+
+  @Before
+  public void setUp() {
+    originalAccessToken = SingleTokenFetcher.getAccessToken();
+    SingleTokenFetcher.setAccessToken(null);
+  }
+
+  @After
+  public void tearDown() {
+    SingleTokenFetcher.setAccessToken(originalAccessToken);
+  }
+
+  @Test
+  public void getDefaultToken_success() throws Exception {
+    SingleTokenFetcher.setAccessToken(TOKEN);
+    Optional<AccessTokenManager> manager = AccessTokenManager.create();
+    assertThat(manager).isPresent();
+    assertThat(manager.get().getDefaultToken()).isEqualTo(TOKEN);
+  }
+
+  @Test
+  public void getToken_success() throws Exception {
+    SingleTokenFetcher.setAccessToken(TOKEN);
+    Optional<AccessTokenManager> manager = AccessTokenManager.create();
+    assertThat(manager).isPresent();
+    assertThat(manager.get().getToken(IDENTITY)).isEqualTo(TOKEN);
+  }
+
+  @Test
+  public void getToken_noEnvironmentVariable() throws Exception {
+    assertThat(SingleTokenFetcher.create()).isEmpty();
+  }
+
+  @Test
+  public void create_success() throws Exception {
+    SingleTokenFetcher.setAccessToken(TOKEN);
+    Optional<AccessTokenManager> manager = AccessTokenManager.create();
+    assertThat(manager).isPresent();
+    assertThat(manager.get().getToken(IDENTITY)).isEqualTo(TOKEN);
+  }
+
+  @Test
+  public void create_noEnvironmentVariable() throws Exception {
+    assertThat(AccessTokenManager.create()).isEmpty();
+  }
+}
diff --git a/s2a/src/test/resources/README.md b/s2a/src/test/resources/README.md
new file mode 100644
index 00000000000..2250ffb1dec
--- /dev/null
+++ b/s2a/src/test/resources/README.md
@@ -0,0 +1,69 @@
+# Generating certificates and keys for testing mTLS-S2A
+
+Content from: https://github.com/google/s2a-go/blob/main/testdata/README.md
+
+Create root CA
+
+```
+openssl req -x509 -sha256 -days 7305 -newkey rsa:2048 -keyout root_key.pem -out
+root_cert.pem
+```
+
+Generate private keys for server and client
+
+```
+openssl genrsa -out server_key.pem 2048
+openssl genrsa -out client_key.pem 2048
+```
+
+Generate CSRs for server and client (set Common Name to localhost, leave all
+other fields blank)
+
+```
+openssl req -key server_key.pem -new -out server.csr -config config.cnf
+openssl req -key client_key.pem -new -out client.csr -config config.cnf
+```
+
+Sign CSRs for server and client
+
+```
+openssl x509 -req -CA root_cert.pem -CAkey root_key.pem -in server.csr -out server_cert.pem -days 7305 -extfile config.cnf -extensions req_ext
+openssl x509 -req -CA root_cert.pem -CAkey root_key.pem -in client.csr -out client_cert.pem -days 7305
+```
+
+Generate self-signed ECDSA root cert
+
+```
+openssl ecparam -name prime256v1 -genkey -noout -out temp.pem
+openssl pkcs8 -topk8 -in temp.pem -out root_key_ec.pem -nocrypt
+rm temp.pem
+openssl req -x509 -days 7305 -new -key root_key_ec.pem -nodes -out root_cert_ec.pem -config root_ec.cnf -extensions 'v3_req'
+```
+
+Generate a chain of ECDSA certs
+
+```
+openssl ecparam -name prime256v1 -genkey -noout -out temp.pem
+openssl pkcs8 -topk8 -in temp.pem -out int_key2_ec.pem -nocrypt
+rm temp.pem
+openssl req -key int_key2_ec.pem -new -out temp.csr -config int_cert2.cnf
+openssl x509 -req -days 7305 -in temp.csr -CA root_cert_ec.pem -CAkey root_key_ec.pem -CAcreateserial -out int_cert2_ec.pem -extfile int_cert2.cnf -extensions 'v3_req'
+
+
+openssl ecparam -name prime256v1 -genkey -noout -out temp.pem
+openssl pkcs8 -topk8 -in temp.pem -out int_key1_ec.pem -nocrypt
+rm temp.pem
+openssl req -key int_key1_ec.pem -new -out temp.csr -config int_cert1.cnf
+openssl x509 -req -days 7305 -in temp.csr -CA int_cert2_ec.pem -CAkey int_key2_ec.pem -CAcreateserial -out int_cert1_ec.pem -extfile int_cert1.cnf -extensions 'v3_req'
+
+
+openssl ecparam -name prime256v1 -genkey -noout -out temp.pem
+openssl pkcs8 -topk8 -in temp.pem -out leaf_key_ec.pem -nocrypt
+rm temp.pem
+openssl req -key leaf_key_ec.pem -new -out temp.csr -config leaf.cnf
+openssl x509 -req -days 7305 -in temp.csr -CA int_cert1_ec.pem -CAkey int_key1_ec.pem -CAcreateserial -out leaf_cert_ec.pem -extfile leaf.cnf -extensions 'v3_req'
+```
+
+```
+cat leaf_cert_ec.pem int_cert1_ec.pem int_cert2_ec.pem > cert_chain_ec.pem
+```
\ No newline at end of file
diff --git a/s2a/src/test/resources/cert_chain_ec.pem b/s2a/src/test/resources/cert_chain_ec.pem
new file mode 100644
index 00000000000..a249904286c
--- /dev/null
+++ b/s2a/src/test/resources/cert_chain_ec.pem
@@ -0,0 +1,39 @@
+-----BEGIN CERTIFICATE-----
+MIIB6jCCAZCgAwIBAgIUA98F2JkYZAyz9BdIkBK3P8Df7OUwCgYIKoZIzj0EAwIw
+MjEOMAwGA1UECgwFaW50MU8xDzANBgNVBAsMBmludDFPVTEPMA0GA1UEAwwGaW50
+MUNOMB4XDTI0MTAwMTIxNDIwMFoXDTQ0MTAwMTIxNDIwMFowMjEOMAwGA1UECgwF
+bGVhZk8xDzANBgNVBAsMBmxlYWZPVTEPMA0GA1UEAwwGbGVhZkNOMFkwEwYHKoZI
+zj0CAQYIKoZIzj0DAQcDQgAEtpTTzt2VDTP6gO4uUIpg8sB63Ff4T4YPMoIGrrn3
+tU3f9j0Ysa5/xblM0LkwRImcrKKchYDiNm1wHkWo+qDImaOBgzCBgDAOBgNVHQ8B
+Af8EBAMCB4AwIAYDVR0lAQH/BBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMAwGA1Ud
+EwEB/wQCMAAwHQYDVR0OBBYEFGzFBt/E6vDJRcH+Izy4MQ9AHycqMB8GA1UdIwQY
+MBaAFBYs72Jv682/xzG3Tm8hItIFis//MAoGCCqGSM49BAMCA0gAMEUCIHUcqPTB
+mQ4kXE0WoOUC8ZmzvthvfKjCNe0YogcjZgwWAiEAvapmWoQIO4qie25Ae9sYRCPq
+5xAHztAquk5HLfwabow=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIB8TCCAZagAwIBAgIUEXwpznJIlU+ELO7Qgb4UUGpfbj8wCgYIKoZIzj0EAwIw
+MjEOMAwGA1UECgwFaW50Mk8xDzANBgNVBAsMBmludDJPVTEPMA0GA1UEAwwGaW50
+MkNOMB4XDTI0MTAwMTIxNDIwMFoXDTQ0MTAwMTIxNDIwMFowMjEOMAwGA1UECgwF
+aW50MU8xDzANBgNVBAsMBmludDFPVTEPMA0GA1UEAwwGaW50MUNOMFkwEwYHKoZI
+zj0CAQYIKoZIzj0DAQcDQgAEoenicrtL6ezEW2yLSXADscDJQ/fdbr+vJEU/aieV
+wA2EnPbrdpvQZaz+pXtuZzBLZY50XI9y33E+/PvBFtZob6OBiTCBhjAOBgNVHQ8B
+Af8EBAMCAQYwIAYDVR0lAQH/BBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBIGA1Ud
+EwEB/wQIMAYBAf8CAQEwHQYDVR0OBBYEFBYs72Jv682/xzG3Tm8hItIFis//MB8G
+A1UdIwQYMBaAFPhN6eGgVc36Kc50rREZhMdBIkgGMAoGCCqGSM49BAMCA0kAMEYC
+IQDiPcbihg1iDi0m9CUn96IbWOTh1X75RfVJYcR3Q5T78AIhAK/fxZauDeWPzk2r
+2/ohCQOZFHtAi9VRpr/TqNi3SaYt
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIB8DCCAZagAwIBAgIUNOH4wQEoKHvaQ9Xgd36vh5TnhfUwCgYIKoZIzj0EAwIw
+MjEOMAwGA1UECgwFcm9vdE8xDzANBgNVBAsMBnJvb3RPVTEPMA0GA1UEAwwGcm9v
+dENOMB4XDTI0MTAwMTIxNDIwMFoXDTQ0MTAwMTIxNDIwMFowMjEOMAwGA1UECgwF
+aW50Mk8xDzANBgNVBAsMBmludDJPVTEPMA0GA1UEAwwGaW50MkNOMFkwEwYHKoZI
+zj0CAQYIKoZIzj0DAQcDQgAE44B/G4pzAvLpIUaPp8XNRtXuw8jeLgE40NjQMuqq
+3jNs6ID/fv/jiRggLMXL3Tii1CisM4BRjg56/Owky1Fyv6OBiTCBhjAOBgNVHQ8B
+Af8EBAMCAQYwIAYDVR0lAQH/BBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBIGA1Ud
+EwEB/wQIMAYBAf8CAQIwHQYDVR0OBBYEFPhN6eGgVc36Kc50rREZhMdBIkgGMB8G
+A1UdIwQYMBaAFNHNBlllqi9koRtf7EBHjRMwVgWsMAoGCCqGSM49BAMCA0gAMEUC
+IBd4bvqVeYSSUEGF1wB0KlYxn1L0Ub/LjgIUUQFAEwahAiEAgeArX63bnlI7u3dq
+v/FGilvcLP3P3AvRozpHJiIZ860=
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/client_cert.pem b/s2a/src/test/resources/client_cert.pem
new file mode 100644
index 00000000000..837f8bb5019
--- /dev/null
+++ b/s2a/src/test/resources/client_cert.pem
@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDPTCCAiWgAwIBAgIUaarddwSWeE4jDC9kwxEr446ehqUwDQYJKoZIhvcNAQEL
+BQAwWTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDESMBAGA1UEAwwJbG9jYWxob3N0MB4X
+DTI0MTAwMTIxNTk1NFoXDTQ0MTAwMTIxNTk1NFowFDESMBAGA1UEAwwJbG9jYWxo
+b3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxlNsldt7yAU4KRuS
+2D2/FjNIE1US5olBm4HteTr++41WaELZJqNLRPPp052jEQU3aKSYNGZvUUO6buu7
+eFpz2SBNUVMyvmzzocjVAyyf4NQvDazYHWOb+/YCeUppTRWriz4V5sn47qJTQ8cd
+CGrTFeLHxUjx4nh/OiqVXP/KnF3EqPEuqph0ky7+GirnJgPRe+C5ERuGkJye8dmP
+yWGA2lSS6MeDe7JZTAMi08bAn7BuNpeBkOzz1msGGI9PnUanUs7GOPWTDdcQAVY8
+KMvHCuGaNMGpb4rOR2mm8LlbAbpTPz8Pkw4QtMCLkgsrz2CzXpVwnLsU7nDXJAIO
+B155lQIDAQABo0IwQDAdBgNVHQ4EFgQUSZEyIHLzkIw7AwkBaUjYfIrGVR4wHwYD
+VR0jBBgwFoAUcq3dtxAVA410YWyM0B4e+4umbiwwDQYJKoZIhvcNAQELBQADggEB
+AAz0bZ4ayrZLhA45xn0yvdpdqiCtiWikCRtxgE7VXHg/ziZJVMpBpAhbIGO5tIyd
+lttnRXHwz5DUwKiba4/bCEFe229BshQEql5qaqcbGbFfSly11WeqqnwR1N7c8Gpv
+pD9sVrx22seN0rTUk87MY/S7mzCxHqAx35zm/LTW3pWcgCTMKFHy4Gt4mpTnXkNA
+WkhP2OhW5RLiu6Whi0BEdb2TGG1+ctamgijKXb+gJeef5ehlHXG8eU862KF5UlEA
+NeQKBm/PpQxOMe0NdpatjN8QRoczku0Itiodng+OZ1o+2iSNG988uFRb3CUSnjtE
+R/HL6ULAFzo59EpIYxruU/w=
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/client_key.pem b/s2a/src/test/resources/client_key.pem
new file mode 100644
index 00000000000..38b93eb65c4
--- /dev/null
+++ b/s2a/src/test/resources/client_key.pem
@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDGU2yV23vIBTgp
+G5LYPb8WM0gTVRLmiUGbge15Ov77jVZoQtkmo0tE8+nTnaMRBTdopJg0Zm9RQ7pu
+67t4WnPZIE1RUzK+bPOhyNUDLJ/g1C8NrNgdY5v79gJ5SmlNFauLPhXmyfjuolND
+xx0IatMV4sfFSPHieH86KpVc/8qcXcSo8S6qmHSTLv4aKucmA9F74LkRG4aQnJ7x
+2Y/JYYDaVJLox4N7sllMAyLTxsCfsG42l4GQ7PPWawYYj0+dRqdSzsY49ZMN1xAB
+Vjwoy8cK4Zo0walvis5HaabwuVsBulM/Pw+TDhC0wIuSCyvPYLNelXCcuxTucNck
+Ag4HXnmVAgMBAAECggEAKuW9jXaBgiS63o1jyFkmvWcPNntG0M2sfrXuRzQfFgse
+vwOCk8xrSflWQNsOe+58ayp6746ekl3LdBWSIbiy6SqG/sm3pp/LXNmjVYHv/QH4
+QYV643R5t1ihdVnGiBFhXwdpVleme/tpdjYZzgnJKak5W69o/nrgzhSK5ShAy2xM
+j0XXbgdqG+4JxPb5BZmjHHfXAXUfgSORMdfArkbgFBRc9wL/6JVTXjeAMy5WX9qe
+5UQsSOYkwc9P2snifC/jdIhjHQOkkx59O0FgukJEFZPoagVG1duWQbnNDr7QVHCJ
+jV6dg9tIT4SXD3uPSPbgNGlRUseIakCzrhHARJuA2wKBgQD/h8zoh0KaqKyViCYw
+XKOFpm1pAFnp2GiDOblxNubNFAXEWnC+FlkvO/z1s0zVuYELUqfxcYMSXJFEVelK
+rfjZtoC5oxqWGqLo9iCj7pa8t+ipulYcLt2SWc7eZPD4T4lzeEf1Qz77aKcz34sa
+dv9lzQkDvhR/Mv1VeEGFHiq2VwKBgQDGsLcTGH5Yxs//LRSY8TigBkQEDrH5NvXu
+2jtAzZhy1Yhsoa5eiZkhnnzM6+n05ovfZLcy6s7dnwP1Y+C79vs+DKMBsodtDG5z
+YpsB0VrXYa6P6pCqkcz0Bz9xdo5sOhAK3AKnX6jd29XBDdeYsw/lxHLG24wProTD
+cCYFqtaj8wKBgQCaqKT68DL9zK14a8lBaDCIyexaqx3AjXzkP+Hfhi03XrEG4P5v
+7rLYBeTbCUSt7vMN2V9QoTWFvYUm6SCkVJvTmcRblz6WL1T+z0l+LwAJBP7LC77m
+m+77j2PH8yxt/iXhP6G97o+GNxdMLDbTM8bs5KZaH4fkXQY73uc5HMMZTQKBgEZS
+7blYhf+t/ph2wD+RwVUCYrh86wkmJs2veCFro3WhlnO8lhbn5Mc9bTaqmVgQ8ZjT
+8POYoDdYvPHxs+1TcYF4v4kuQziZmc5FLE/sZZauADb38tQsXrpQhmgGakpsEpmF
+XXsYJJDB6lo2KATn+8x7R5SSyHQUdPEnlI2U9ft5AoGBAJw0NJiM1EzRS8xq0DmO
+AvQaPjo01o2hH6wghws8gDQwrj0eHraHgVi7zo0VkaHJbO7ahKPudset3N7owJhA
+CUAPPRtv5wn0amAyNz77f1dz4Gys3AkcchflqhbEaQpzKYx4kX0adclur4WJ/DVm
+P7DI977SHCVB4FVMbXMEkBjN
+-----END PRIVATE KEY-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/config.cnf b/s2a/src/test/resources/config.cnf
new file mode 100644
index 00000000000..5f9a7710e92
--- /dev/null
+++ b/s2a/src/test/resources/config.cnf
@@ -0,0 +1,17 @@
+[req]
+distinguished_name = req_distinguished_name
+req_extensions = req_ext
+
+[req_distinguished_name]
+countryName                     = Country Name (2 letter code)
+stateOrProvinceName             = State or Province Name (full name)
+localityName                    = Locality Name (eg, city)
+organizationalUnitName          = Organizational Unit Name (eg, section)
+commonName                      = Common Name (eg, your name or your server\'s hostname)
+emailAddress                    = Email Address
+
+[req_ext]
+subjectAltName = @alt_names
+
+[alt_names]
+IP.1 = ::1
\ No newline at end of file
diff --git a/s2a/src/test/resources/int_cert1_.cnf b/s2a/src/test/resources/int_cert1_.cnf
new file mode 100644
index 00000000000..ba5a0f66a5e
--- /dev/null
+++ b/s2a/src/test/resources/int_cert1_.cnf
@@ -0,0 +1,14 @@
+[req]
+distinguished_name = req_distinguished_name
+req_extensions = v3_req
+prompt = no
+
+[req_distinguished_name]
+O = int1O
+OU = int1OU
+CN = int1CN
+
+[v3_req]
+keyUsage = critical, keyCertSign, cRLSign
+extendedKeyUsage = critical, clientAuth, serverAuth
+basicConstraints = critical, CA:true, pathlen: 1
\ No newline at end of file
diff --git a/s2a/src/test/resources/int_cert1_ec.pem b/s2a/src/test/resources/int_cert1_ec.pem
new file mode 100644
index 00000000000..de83c2aba79
--- /dev/null
+++ b/s2a/src/test/resources/int_cert1_ec.pem
@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIIB8TCCAZagAwIBAgIUEXwpznJIlU+ELO7Qgb4UUGpfbj8wCgYIKoZIzj0EAwIw
+MjEOMAwGA1UECgwFaW50Mk8xDzANBgNVBAsMBmludDJPVTEPMA0GA1UEAwwGaW50
+MkNOMB4XDTI0MTAwMTIxNDIwMFoXDTQ0MTAwMTIxNDIwMFowMjEOMAwGA1UECgwF
+aW50MU8xDzANBgNVBAsMBmludDFPVTEPMA0GA1UEAwwGaW50MUNOMFkwEwYHKoZI
+zj0CAQYIKoZIzj0DAQcDQgAEoenicrtL6ezEW2yLSXADscDJQ/fdbr+vJEU/aieV
+wA2EnPbrdpvQZaz+pXtuZzBLZY50XI9y33E+/PvBFtZob6OBiTCBhjAOBgNVHQ8B
+Af8EBAMCAQYwIAYDVR0lAQH/BBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBIGA1Ud
+EwEB/wQIMAYBAf8CAQEwHQYDVR0OBBYEFBYs72Jv682/xzG3Tm8hItIFis//MB8G
+A1UdIwQYMBaAFPhN6eGgVc36Kc50rREZhMdBIkgGMAoGCCqGSM49BAMCA0kAMEYC
+IQDiPcbihg1iDi0m9CUn96IbWOTh1X75RfVJYcR3Q5T78AIhAK/fxZauDeWPzk2r
+2/ohCQOZFHtAi9VRpr/TqNi3SaYt
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/int_cert2.cnf b/s2a/src/test/resources/int_cert2.cnf
new file mode 100644
index 00000000000..f48524effb2
--- /dev/null
+++ b/s2a/src/test/resources/int_cert2.cnf
@@ -0,0 +1,14 @@
+[req]
+distinguished_name = req_distinguished_name
+req_extensions = v3_req
+prompt = no
+
+[req_distinguished_name]
+O = int2O
+OU = int2OU
+CN = int2CN
+
+[v3_req]
+keyUsage = critical, keyCertSign, cRLSign
+extendedKeyUsage = critical, clientAuth, serverAuth
+basicConstraints = critical, CA:true, pathlen: 2
\ No newline at end of file
diff --git a/s2a/src/test/resources/int_cert2_ec.pem b/s2a/src/test/resources/int_cert2_ec.pem
new file mode 100644
index 00000000000..4f502fda808
--- /dev/null
+++ b/s2a/src/test/resources/int_cert2_ec.pem
@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIIB8DCCAZagAwIBAgIUNOH4wQEoKHvaQ9Xgd36vh5TnhfUwCgYIKoZIzj0EAwIw
+MjEOMAwGA1UECgwFcm9vdE8xDzANBgNVBAsMBnJvb3RPVTEPMA0GA1UEAwwGcm9v
+dENOMB4XDTI0MTAwMTIxNDIwMFoXDTQ0MTAwMTIxNDIwMFowMjEOMAwGA1UECgwF
+aW50Mk8xDzANBgNVBAsMBmludDJPVTEPMA0GA1UEAwwGaW50MkNOMFkwEwYHKoZI
+zj0CAQYIKoZIzj0DAQcDQgAE44B/G4pzAvLpIUaPp8XNRtXuw8jeLgE40NjQMuqq
+3jNs6ID/fv/jiRggLMXL3Tii1CisM4BRjg56/Owky1Fyv6OBiTCBhjAOBgNVHQ8B
+Af8EBAMCAQYwIAYDVR0lAQH/BBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMBIGA1Ud
+EwEB/wQIMAYBAf8CAQIwHQYDVR0OBBYEFPhN6eGgVc36Kc50rREZhMdBIkgGMB8G
+A1UdIwQYMBaAFNHNBlllqi9koRtf7EBHjRMwVgWsMAoGCCqGSM49BAMCA0gAMEUC
+IBd4bvqVeYSSUEGF1wB0KlYxn1L0Ub/LjgIUUQFAEwahAiEAgeArX63bnlI7u3dq
+v/FGilvcLP3P3AvRozpHJiIZ860=
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/int_key1_ec.pem b/s2a/src/test/resources/int_key1_ec.pem
new file mode 100644
index 00000000000..909c119b60c
--- /dev/null
+++ b/s2a/src/test/resources/int_key1_ec.pem
@@ -0,0 +1,5 @@
+-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgnYGMzs4siZ7Fy3mI
+rmsqBdP6We4Zt+ndtOYEGaZDj06hRANCAASh6eJyu0vp7MRbbItJcAOxwMlD991u
+v68kRT9qJ5XADYSc9ut2m9BlrP6le25nMEtljnRcj3LfcT78+8EW1mhv
+-----END PRIVATE KEY-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/int_key2_ec.pem b/s2a/src/test/resources/int_key2_ec.pem
new file mode 100644
index 00000000000..520300d2560
--- /dev/null
+++ b/s2a/src/test/resources/int_key2_ec.pem
@@ -0,0 +1,5 @@
+-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgzLSoAcENXIiQfBS7
+meBDCohT1rofhWSfD0m55qi8V3WhRANCAATjgH8binMC8ukhRo+nxc1G1e7DyN4u
+ATjQ2NAy6qreM2zogP9+/+OJGCAsxcvdOKLUKKwzgFGODnr87CTLUXK/
+-----END PRIVATE KEY-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/leaf.cnf b/s2a/src/test/resources/leaf.cnf
new file mode 100644
index 00000000000..c21cee5568f
--- /dev/null
+++ b/s2a/src/test/resources/leaf.cnf
@@ -0,0 +1,14 @@
+[req]
+distinguished_name = req_distinguished_name
+req_extensions = v3_req
+prompt = no
+
+[req_distinguished_name]
+O = leafO
+OU = leafOU
+CN = leafCN
+
+[v3_req]
+keyUsage = critical, digitalSignature
+extendedKeyUsage = critical, clientAuth, serverAuth
+basicConstraints = critical, CA:false
\ No newline at end of file
diff --git a/s2a/src/test/resources/leaf_cert_ec.pem b/s2a/src/test/resources/leaf_cert_ec.pem
new file mode 100644
index 00000000000..ca48b821f60
--- /dev/null
+++ b/s2a/src/test/resources/leaf_cert_ec.pem
@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIIB6jCCAZCgAwIBAgIUA98F2JkYZAyz9BdIkBK3P8Df7OUwCgYIKoZIzj0EAwIw
+MjEOMAwGA1UECgwFaW50MU8xDzANBgNVBAsMBmludDFPVTEPMA0GA1UEAwwGaW50
+MUNOMB4XDTI0MTAwMTIxNDIwMFoXDTQ0MTAwMTIxNDIwMFowMjEOMAwGA1UECgwF
+bGVhZk8xDzANBgNVBAsMBmxlYWZPVTEPMA0GA1UEAwwGbGVhZkNOMFkwEwYHKoZI
+zj0CAQYIKoZIzj0DAQcDQgAEtpTTzt2VDTP6gO4uUIpg8sB63Ff4T4YPMoIGrrn3
+tU3f9j0Ysa5/xblM0LkwRImcrKKchYDiNm1wHkWo+qDImaOBgzCBgDAOBgNVHQ8B
+Af8EBAMCB4AwIAYDVR0lAQH/BBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMAwGA1Ud
+EwEB/wQCMAAwHQYDVR0OBBYEFGzFBt/E6vDJRcH+Izy4MQ9AHycqMB8GA1UdIwQY
+MBaAFBYs72Jv682/xzG3Tm8hItIFis//MAoGCCqGSM49BAMCA0gAMEUCIHUcqPTB
+mQ4kXE0WoOUC8ZmzvthvfKjCNe0YogcjZgwWAiEAvapmWoQIO4qie25Ae9sYRCPq
+5xAHztAquk5HLfwabow=
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/leaf_key_ec.pem b/s2a/src/test/resources/leaf_key_ec.pem
new file mode 100644
index 00000000000..b92b90ba1da
--- /dev/null
+++ b/s2a/src/test/resources/leaf_key_ec.pem
@@ -0,0 +1,5 @@
+-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgkvnGZBh3uIYfZiau
+/0qN0YcQXlwwVVUh8EybjvKUlX2hRANCAAS2lNPO3ZUNM/qA7i5QimDywHrcV/hP
+hg8yggauufe1Td/2PRixrn/FuUzQuTBEiZysopyFgOI2bXAeRaj6oMiZ
+-----END PRIVATE KEY-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/root_cert.pem b/s2a/src/test/resources/root_cert.pem
new file mode 100644
index 00000000000..ccd0a46bc23
--- /dev/null
+++ b/s2a/src/test/resources/root_cert.pem
@@ -0,0 +1,22 @@
+-----BEGIN CERTIFICATE-----
+MIIDkzCCAnugAwIBAgIUWemeXZdfqcqkP8/Eyj74oTJtoNQwDQYJKoZIhvcNAQEL
+BQAwWTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDESMBAGA1UEAwwJbG9jYWxob3N0MB4X
+DTI0MTAwMTIxNTkxMVoXDTQ0MTAwMTIxNTkxMVowWTELMAkGA1UEBhMCQVUxEzAR
+BgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5
+IEx0ZDESMBAGA1UEAwwJbG9jYWxob3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
+MIIBCgKCAQEAt3A04hy5lljv86Nu0LLQZ2hA+fcImHjt1p1Mxgcta/5oxfVLcerE
+ZH+DAQLDtWzp9Up/vI57MM419GIL8Iszk7hnZRS/HWJ+2jewZJtz4i/g15dLr6+1
+uabMdPOWos60BwcLMxKEe6lJO1mV4z9d4NH4mAuMIHyM+ty0Klp9MfeDJtYEh0+z
+AxJUHCixDTsnKJro7My7A3ZT7bvaMfXxS7XN6qlRgBfiCmXo/GKTFfmfBW/EZGkG
+XOCxE2D79wYNhC41Q/ix0kwjEeOj2vgGFoiyblSdHdzvRXzsoQTEiZSM8lJDR2IT
+ZbpgbBlknMU6efNWlS8P5damB9ZWXg3x4wIDAQABo1MwUTAdBgNVHQ4EFgQUcq3d
+txAVA410YWyM0B4e+4umbiwwHwYDVR0jBBgwFoAUcq3dtxAVA410YWyM0B4e+4um
+biwwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEApZvaI9y7vjX/
+RRdvwf2Db9KlTE9nuVQ3AsrmG9Ml0p2X6U5aTetxdYBo2PuaaYHheF03JOH8zjpL
+UfFzvbi52DPbfFAaDw/6NIAenXlg492leNvUFNjGGRyJO9R5/aDfv40/fT3Em5G5
+DnR8SeGQ9tI1t6xBBT+d+/MilSiEKVu8IIF/p0SwvEyR4pKo6wFVZR0ZiIj2v/FZ
+P5Qk0Xhb+slpmaR3Wtx/mPl9Wb3kpPD4CAwhWDqFkKJql9/n9FvMjdwlCQKQGB26
+ZDXY3C0UTdktK5biNWRgAUVJEWBX6Q2amrxQHIn2d9RJ8uxCME/KBAntK+VxZE78
+w0JOvQ4Dpw==
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/root_cert_ec.pem b/s2a/src/test/resources/root_cert_ec.pem
new file mode 100644
index 00000000000..3d20dcfe83c
--- /dev/null
+++ b/s2a/src/test/resources/root_cert_ec.pem
@@ -0,0 +1,12 @@
+-----BEGIN CERTIFICATE-----
+MIIBxzCCAW2gAwIBAgIUN+H7Td9dhyvMrrzZhanevAfCN34wCgYIKoZIzj0EAwIw
+MjEOMAwGA1UECgwFcm9vdE8xDzANBgNVBAsMBnJvb3RPVTEPMA0GA1UEAwwGcm9v
+dENOMB4XDTI0MTAwMTIxNDIwMFoXDTQ0MTAwMTIxNDIwMFowMjEOMAwGA1UECgwF
+cm9vdE8xDzANBgNVBAsMBnJvb3RPVTEPMA0GA1UEAwwGcm9vdENOMFkwEwYHKoZI
+zj0CAQYIKoZIzj0DAQcDQgAEGnS2gVv6Bs0GtuUAOebR9E0fqaj3zi9mD97B/dgi
+MLENhtVPJQzeePv6Ccap+73O0BINRNOl8tlHX0YaXDeEHKNhMF8wDgYDVR0PAQH/
+BAQDAgEGMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjAPBgNVHRMBAf8E
+BTADAQH/MB0GA1UdDgQWBBTRzQZZZaovZKEbX+xAR40TMFYFrDAKBggqhkjOPQQD
+AgNIADBFAiEAgnIyLs7FsZNsJjFgYzlaut4h23RxrpUYVCVZt/+x1Q0CIG3U6WGz
+YaEyKoCtBHH9cAy76+pP/NU2f7/QuHU9Vymd
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/root_ec.cnf b/s2a/src/test/resources/root_ec.cnf
new file mode 100644
index 00000000000..d736865c831
--- /dev/null
+++ b/s2a/src/test/resources/root_ec.cnf
@@ -0,0 +1,14 @@
+[req]
+distinguished_name = req_distinguished_name
+req_extensions = v3_req
+prompt = no
+
+[req_distinguished_name]
+O = rootO
+OU = rootOU
+CN = rootCN
+
+[v3_req]
+keyUsage = critical, keyCertSign, cRLSign
+extendedKeyUsage = serverAuth, clientAuth
+basicConstraints = critical, CA:true
\ No newline at end of file
diff --git a/s2a/src/test/resources/root_key.pem b/s2a/src/test/resources/root_key.pem
new file mode 100644
index 00000000000..34d0ffa61eb
--- /dev/null
+++ b/s2a/src/test/resources/root_key.pem
@@ -0,0 +1,30 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIIFJDBWBgkqhkiG9w0BBQ0wSTAxBgkqhkiG9w0BBQwwJAQQJXNe391O3gaNbKLw
+o60XrQICCAAwDAYIKoZIhvcNAgkFADAUBggqhkiG9w0DBwQI4pf69+BBF8IEggTI
+JuQ3p67U9k/NWMuYXaR9a6lv24YZ1qR6ieL5B6keCaCDVoQMb5V22O0vBqCVePgr
+EG0yWIeeAsARMzAxE7Lnil6abSe7tij+LjEI9F7mV/1QSFt03PLVI+e7OcKNI+Nr
+6vISEi8CaddekP8JDRhPMpgdWderZvogo3REpJ8GNIUddQzu1e3ZgDtOPquqcgqb
+MH/HuPE3vjj4/l6ZpX+6DZKIvzjwtBQ4PMzSWLumzmYLItd3kz7UryN+9hKluSZp
+D2KB24aUIQFbDxe2DMTi5c0QIiyzjwkv081ecNJOy2gYX3uiucr8/Ax3o21RNZtI
+oKCmSPVEfYdrkdfkwuSOioVTbWBZBcSZo3L2bmCkSXTuheGurEw/TtQWXBgew0Bn
+UQjEJgZy96PVsQeu3t+NRCacARQi4vfv7PVHlQW8fcfcC6CeNw7VIZ8aS7supqym
+RJxzMY9ZnLwO9cgybXLYgosVZnvI7nOokJPfO1+KqBK01C1Sgc3tg8czKhRuztHu
+qDO0GCZ7l+9/ku/WIy/5NiatNvRo5dMAOGxsSrjI9a7+EmenoIfd8/KREVX19D+R
+gZRALVATHq83rF6BdsyTwya1QUr/J24EIlkOc4HbCBm5WxA2ZjNdDBZ+KhivYaS7
+l1qrbkFOhmBD9kYRbseBrxlzKUWJMGhOpw3xebut3HngLqyezLcjsXQuF3Iau5Hl
+9QFcmSdLj2ZlNlQvmfNJX/r6a/K2LigruXCbvHWMqVsHd7XZdWJ/8wjm2AL97iON
+mYFLP+ScfYom9qrF41jNkUKZiLk/ppvSHyWBAqbze+R9Zfpcf8ArCwuAL/JlEMzv
+YkBv1DWKfzJpZHYX695MxrpS3C8m0IyXNxktBL3KTVvwZaIhSNBlNS3fdb9m8toR
+Tz/LS8jseWpZ5D552/+KAa0Skhav3ZFpxmAS8BEyE/nI9Dwg9niYcZLWORWHAQPp
+jraG0BkE7bn5No/k7E4rjFb+2N+36QxVacJI3neC8bQXVHP0BVUvrabOWFPnGivl
+Ok91Eo8q5PUAsd15ZnKjTHzlD7zv7fF6ncBgj3P4L2Xrs6P34JOZEd4wixEUZYeC
+Xe+SZrFyUr6CcNC45C6R3hDYqmrz0GK1ikkis3XcKT+C5flBYb9NRx8G9wyCuS6H
+oHl0Rfbpc47wQTuajicMVO2El7syMPUAxjo3EfMzvjm7uCXLTHnXRnRt3Y5AkPGa
+0kFE9Vm00PReRfQ7qbSUiOOHYa9NIsw1l2ZI+knP9XbY2HikELOpjgucrMxZF+ms
+zit5YGD3NGZi5xcHZFZTs9L8kaJccXn5DtjA30eEiFzKqMtMKnwlrbSL55I1JXim
+co1RLpRK2KQmtJHo1br3RH6jP7fePYzgDceDds5HKWz22pYFcVtlx4DeYH5vjdEp
+i3yNQZ32jD2HYhgCK325QLP5S2UYmUOPWd4sEiwZMBPpPOlt0TqCdFKYgS2GHlSN
+IYVBYelPUYsz9Kg0TFtLMZLNUmwsXJ+jqnLVtmFyoV6IIvbSCqQ9jxTbZQKxThK8
+A1G+nXBO41ZW8eQZUGx8CzbCj2JvtVThgErSRqAuYbvlUt7EI4Ac8veZC8rJIG0Q
+ADkueb978o4OI6vpOdTYCmdTIoHWlpup
+-----END ENCRYPTED PRIVATE KEY-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/root_key_ec.pem b/s2a/src/test/resources/root_key_ec.pem
new file mode 100644
index 00000000000..5560a66d414
--- /dev/null
+++ b/s2a/src/test/resources/root_key_ec.pem
@@ -0,0 +1,5 @@
+-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgjfTyzPIlKV0zANQP
+2s1C2FhbenE34QEsf83wjpuQrZWhRANCAAQadLaBW/oGzQa25QA55tH0TR+pqPfO
+L2YP3sH92CIwsQ2G1U8lDN54+/oJxqn7vc7QEg1E06Xy2UdfRhpcN4Qc
+-----END PRIVATE KEY-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/server_cert.pem b/s2a/src/test/resources/server_cert.pem
new file mode 100644
index 00000000000..909b83aa903
--- /dev/null
+++ b/s2a/src/test/resources/server_cert.pem
@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDWjCCAkKgAwIBAgIUAeWzyzIEetYf+ZWHj9NzH1JkLYkwDQYJKoZIhvcNAQEL
+BQAwWTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDESMBAGA1UEAwwJbG9jYWxob3N0MB4X
+DTI0MTAwMTIxNTk0NloXDTQ0MTAwMTIxNTk0NlowFDESMBAGA1UEAwwJbG9jYWxo
+b3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA1qnW7Pb06MgRNLzt
+icv/ydl8W/lpPRjrJJb04/TtXbJ1hjnp7i796TfNGrJgHqEZnaR8q83lO0L38B2X
+sJ04b3R+y+6HhH8+MbHejM7ybrTZRNQXip/Kxu4QLHBTQEsplycWLf42/R3cIk/X
+vgxq5NsCsbk4xI4xwlcqC8FM1AHU0VrKxzHWVhZEM+/KovBAr/hRYln9CukeKjOf
+UiVq58uuDAlJRC3yH2Rd/sqCDELvqRv17J6eYx2nJ3mSN5aBa0FwVjg6vr5Obddj
+AWWIkgrlAr+a+OraxOrWElFfChBSvr/qHdJFWHeCdq/SAhow5uRhC69ScJf+7lrX
+hsj1sQIDAQABo18wXTAbBgNVHREEFDAShxAAAAAAAAAAAAAAAAAAAAABMB0GA1Ud
+DgQWBBRdDRg6GuDj8Sujmz4/rqfP0jZHbTAfBgNVHSMEGDAWgBRyrd23EBUDjXRh
+bIzQHh77i6ZuLDANBgkqhkiG9w0BAQsFAAOCAQEAAEUS27+6p88CWYemMOY0iu0e
+mp4YqG0XQSilbSnxrqnJb3N8pR3Yh6JJKnblQ6xdexfzrXlBA/v7nx+f8e9HS2QZ
+KLtEIaEvNKL51JdOS6ebEzLVvhk98r2kpKM3wpT++/18HPlPK5W3rMQNsLOyAdvP
+UX6TakhIfflRjz1DYXQ1ERvJOFw2HEmw6K6r2VwBhZKfwwzxmAHpVwniWXGbgyRF
+79hG6rO1tv1K5LHAPIRs0h2Lh/VPxm2XiaNkdGyarUy5/NM+GoHErgxOBmYltn5Q
+vAlZrgF2/mSXcUb7EHoXvoC9L4M7U/dRQD4Q1fQRJ/KjrhbDAC3gfZ4zorKoaQ==
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/s2a/src/test/resources/server_key.pem b/s2a/src/test/resources/server_key.pem
new file mode 100644
index 00000000000..edc37cb3855
--- /dev/null
+++ b/s2a/src/test/resources/server_key.pem
@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDWqdbs9vToyBE0
+vO2Jy//J2Xxb+Wk9GOsklvTj9O1dsnWGOenuLv3pN80asmAeoRmdpHyrzeU7Qvfw
+HZewnThvdH7L7oeEfz4xsd6MzvJutNlE1BeKn8rG7hAscFNASymXJxYt/jb9Hdwi
+T9e+DGrk2wKxuTjEjjHCVyoLwUzUAdTRWsrHMdZWFkQz78qi8ECv+FFiWf0K6R4q
+M59SJWrny64MCUlELfIfZF3+yoIMQu+pG/Xsnp5jHacneZI3loFrQXBWODq+vk5t
+12MBZYiSCuUCv5r46trE6tYSUV8KEFK+v+od0kVYd4J2r9ICGjDm5GELr1Jwl/7u
+WteGyPWxAgMBAAECggEAFEAgcOlZME6TZPS/ueSfRET6mNieB2/+2sxM3OZhsBmi
+QZ/cBCa1uFcVx8N1Et6iwn7ebfy199G4/xNjmHs0dDs6rPVbHnI8hUag1oq9TxlL
+d9VERUUOxZZ2uyJ7kBCnI0XCL2OQf29eMXRzx093lBBfIDH3e39ojUtYwZQiMcuw
+EPry0k4fVhymhKg9Wnmt5lMg4Mdc1TpPfmNFuTR0PZ1nAaVQglvH66qNKGVoWEhZ
+paNLaKC4H2Jfa1AfAWl6Efy5JDMOfHF0ww0cDUrTzAeQ7jEh0UGyL1lX8W6kKRDa
+0quUqxOJz9aQ8cyd27s2OQMlRtbXi/jhhVp7WLIrWQKBgQD9gKG5CgBO/L8nIj5o
+EhHFhtfjEhdeXTAlenmxoBxUN7Pwkc2OvhNef7+T0+euwl50ieopWLoRxLZ2yY8l
+E2b2+7EM6/8/wgt1bCVh5NCWrE63tLCx+wdht1oqciDXvuv5bJTf73sipgDTYYSV
+gE+DHXq96mxVJXo1TLtQQpXMVQKBgQDYx0AbO0KP2TTNY5ChqVwthaETHjWs6z9p
+U5WRgNYeXbUKg3l7JJk6zq72ZIBeqEr3d9mJqrk6HFKTh4c+LyjKyLjmY5wkmfHh
+s6s1lCEgEoXKT3Fa+DxlsXltyxrJLzuf1h276jeL5bB6BmJNKLODcEoCx/ubrwOj
+prdUSWqf7QKBgQCO/sg7AJE7/QY2pPJe8hJkQbP1unbEG/zUp0mOEKrqNqGhyh0R
+r9ZtL9J5KMc/pRRy2Hjl6c7LxxLF3tyIJXGnUEKG73iEFokwK1jK569hzsB4j8w8
+GUYIsMyDtO0hxeiGQeGYkBX9bXZ5xkBrtH0lkLNz/ZAuV32gIzBmDalCIQKBgDGT
+f+m6Z8KWHilKt+0A2n/eq7O/mO7u7hWcc/xOxqkzLRA2eTXcbN6yHfljiqgbPOnT
+kwCU9r9/crMir59dEasutHqcFT2Zp2PCv0kFk33OPqLCAF6ZntZy/B5L8NhJ4Qzw
+3uP28LUh1nZRt3GF+Wf56jMwoS49nEt0+UBhee0RAoGAS9YsJkbjBg2p3Gxvo5c0
+IjfZdcyS2ndTjXv+hFvkjMw0ULFT3dqpk+0asaCh5nrDUbVQyan+D8LgwSwNZy89
+e99bl//oliv/Om7lVFCKtBOhe+fIWHlrR0e2bemsQi/pgTURjYFuvjhR50dcKx96
+jLHvG4mTfStHaJ1gKGWvgWA=
+-----END PRIVATE KEY-----
\ No newline at end of file
diff --git a/services/BUILD.bazel b/services/BUILD.bazel
new file mode 100644
index 00000000000..ba9d334a5c9
--- /dev/null
+++ b/services/BUILD.bazel
@@ -0,0 +1,199 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+load("//:java_grpc_library.bzl", "java_grpc_library")
+
+package(default_visibility = ["//visibility:public"])
+
+# Mirrors the dependencies included in the artifact on Maven Central for usage
+# with maven_install's override_targets. Should only be used as a dep for
+# pre-compiled binaries on Maven Central.
+java_library(
+    name = "services_maven",
+    exports = [
+        ":admin",
+        ":binarylog",
+        ":channelz",
+        ":health",
+        ":healthlb",
+        ":metrics",
+        ":metrics_internal",
+        ":reflection",
+    ],
+)
+
+java_library(
+    name = "admin",
+    srcs = [
+        "src/main/java/io/grpc/services/AdminInterface.java",
+    ],
+    deps = [
+        ":channelz",
+        "//api",
+        artifact("com.google.code.findbugs:jsr305"),
+    ],
+)
+
+java_library(
+    name = "metrics",
+    srcs = [
+        "src/main/java/io/grpc/services/CallMetricRecorder.java",
+        "src/main/java/io/grpc/services/MetricRecorder.java",
+        "src/main/java/io/grpc/services/MetricRecorderHelper.java",
+        "src/main/java/io/grpc/services/MetricReport.java",
+    ],
+    deps = [
+        "//api",
+        "//context",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+    ],
+)
+
+java_library(
+    name = "metrics_internal",
+    srcs = [
+        "src/main/java/io/grpc/services/InternalCallMetricRecorder.java",
+        "src/main/java/io/grpc/services/InternalMetricRecorder.java",
+    ],
+    visibility = ["//:__subpackages__"],
+    deps = [
+        ":metrics",
+        "//api",
+        "//context",
+    ],
+)
+
+java_library(
+    name = "binarylog",
+    srcs = [
+        "src/main/java/io/grpc/protobuf/services/BinaryLogProvider.java",
+        "src/main/java/io/grpc/protobuf/services/BinaryLogProviderImpl.java",
+        "src/main/java/io/grpc/protobuf/services/BinaryLogSink.java",
+        "src/main/java/io/grpc/protobuf/services/BinaryLogs.java",
+        "src/main/java/io/grpc/protobuf/services/BinlogHelper.java",
+        "src/main/java/io/grpc/protobuf/services/InetAddressUtil.java",
+        "src/main/java/io/grpc/protobuf/services/TempFileSink.java",
+    ],
+    deps = [
+        "//api",
+        "//context",
+        "@com_google_protobuf//:protobuf_java",
+        "@com_google_protobuf//:protobuf_java_util",
+        "@io_grpc_grpc_proto//:binarylog_java_proto",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
+    ],
+)
+
+java_library(
+    name = "channelz",
+    srcs = [
+        "src/main/java/io/grpc/protobuf/services/ChannelzProtoUtil.java",
+        "src/main/java/io/grpc/protobuf/services/ChannelzService.java",
+        "src/main/java/io/grpc/services/ChannelzService.java",
+    ],
+    deps = [
+        ":_channelz_java_grpc",
+        "//api",
+        "//stub",
+        "@com_google_protobuf//:protobuf_java",
+        "@com_google_protobuf//:protobuf_java_util",
+        "@io_grpc_grpc_proto//:channelz_java_proto",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
+    ],
+)
+
+java_library(
+    name = "reflection",
+    srcs = [
+        "src/main/java/io/grpc/protobuf/services/ProtoReflectionService.java",
+        "src/main/java/io/grpc/protobuf/services/ProtoReflectionServiceV1.java",
+    ],
+    deps = [
+        ":_reflection_java_grpc",
+        ":_reflection_v1_java_grpc",
+        "//api",
+        "//protobuf",
+        "//stub",
+        "@com_google_protobuf//:protobuf_java",
+        "@com_google_protobuf//:protobuf_java_util",
+        "@io_grpc_grpc_proto//:reflection_java_proto",
+        "@io_grpc_grpc_proto//:reflection_java_proto_deprecated",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+    ],
+)
+
+java_library(
+    name = "health",
+    srcs = [
+        "src/main/java/io/grpc/protobuf/services/HealthServiceImpl.java",
+        "src/main/java/io/grpc/protobuf/services/HealthStatusManager.java",
+        "src/main/java/io/grpc/services/HealthStatusManager.java",
+    ],
+    deps = [
+        ":_health_java_grpc",
+        "//api",
+        "//context",
+        "//stub",
+        "@io_grpc_grpc_proto//:health_java_proto",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+    ],
+)
+
+java_library(
+    name = "healthlb",
+    srcs = [
+        "src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerFactory.java",
+        "src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerUtil.java",
+        "src/main/java/io/grpc/protobuf/services/internal/HealthCheckingRoundRobinLoadBalancerProvider.java",
+    ],
+    resources = [
+        "src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider",
+    ],
+    deps = [
+        ":_health_java_grpc",
+        "//api",
+        "//core:internal",
+        "//util",
+        "@io_grpc_grpc_proto//:health_java_proto",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
+    ],
+)
+
+# These shouldn't be here, but this is better than having
+# a circular dependency on grpc-proto and grpc-java.
+
+java_grpc_library(
+    name = "_reflection_java_grpc",
+    srcs = ["@io_grpc_grpc_proto//:reflection_proto_deprecated"],
+    visibility = ["//visibility:private"],
+    deps = ["@io_grpc_grpc_proto//:reflection_java_proto_deprecated"],
+)
+
+java_grpc_library(
+    name = "_reflection_v1_java_grpc",
+    srcs = ["@io_grpc_grpc_proto//:reflection_proto"],
+    visibility = ["//visibility:private"],
+    deps = ["@io_grpc_grpc_proto//:reflection_java_proto"],
+)
+
+java_grpc_library(
+    name = "_channelz_java_grpc",
+    srcs = ["@io_grpc_grpc_proto//:channelz_proto"],
+    visibility = ["//visibility:private"],
+    deps = ["@io_grpc_grpc_proto//:channelz_java_proto"],
+)
+
+java_grpc_library(
+    name = "_health_java_grpc",
+    srcs = ["@io_grpc_grpc_proto//:health_proto"],
+    visibility = ["//visibility:private"],
+    deps = ["@io_grpc_grpc_proto//:health_java_proto"],
+)
diff --git a/services/build.gradle b/services/build.gradle
index 8f66741ac81..c30e1ba53bd 100644
--- a/services/build.gradle
+++ b/services/build.gradle
@@ -1,28 +1,67 @@
-// Add dependency on the protobuf plugin
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-    dependencies {
-        classpath libraries.protobuf_plugin
-    }
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "com.google.protobuf"
+    id "ru.vyarus.animalsniffer"
 }
 
 description = "gRPC: Services"
 
+tasks.named("compileJava").configure {
+    // v1alpha of reflection.proto is deprecated at the file level.
+    // Without this workaround, the project can not compile.
+    it.options.compilerArgs += [
+        "-Xlint:-deprecation",
+    ]
+}
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.services')
+    }
+}
+
 dependencies {
-    compile project(':grpc-protobuf'),
-            project(':grpc-stub')
-    testCompile project(':grpc-testing')
-    signature "org.codehaus.mojo.signature:java16:+@signature"
+    api project(':grpc-stub')
+    implementation project(':grpc-core'),
+            project(':grpc-protobuf'),
+            project(':grpc-util'),
+            libraries.guava.jre, // JRE required by protobuf-java-util
+            libraries.protobuf.java.util
+
+    runtimeOnly libraries.errorprone.annotations,
+            libraries.gson  // to fix checkUpperBoundDeps error here
+    testImplementation project(':grpc-testing'),
+            project(':grpc-inprocess'),
+            libraries.netty.transport.epoll, // for DomainSocketAddress
+            testFixtures(project(':grpc-core')),
+            testFixtures(project(':grpc-api'))
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
 configureProtoCompilation()
 
-// Let intellij projects refer to generated code
-idea {
-    module {
-        sourceDirs += file("${projectDir}/src/generated/main/java");
-        sourceDirs += file("${projectDir}/src/generated/main/grpc");
+tasks.named("javadoc").configure {
+    exclude 'io/grpc/services/Internal*.java'
+    exclude 'io/grpc/services/internal/*'
+    exclude 'io/grpc/protobuf/services/BinaryLogProvider.java'
+    exclude 'io/grpc/protobuf/services/internal/*'
+}
+
+tasks.named("jacocoTestReport").configure {
+    classDirectories.from = sourceSets.main.output.collect {
+        fileTree(dir: it,
+        exclude: [
+                '**/io/grpc/binarylog/v1/**',
+                '**/io/grpc/channelz/v1/**',
+                '**/io/grpc/health/v1/**',
+                '**/io/grpc/reflection/v1/**',
+                '**/io/grpc/reflection/v1alpha/**',
+        ])
     }
 }
diff --git a/services/src/generated/main/grpc/io/grpc/channelz/v1/ChannelzGrpc.java b/services/src/generated/main/grpc/io/grpc/channelz/v1/ChannelzGrpc.java
new file mode 100644
index 00000000000..c4ac4076d22
--- /dev/null
+++ b/services/src/generated/main/grpc/io/grpc/channelz/v1/ChannelzGrpc.java
@@ -0,0 +1,953 @@
+package io.grpc.channelz.v1;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * Channelz is a service exposed by gRPC servers that provides detailed debug
+ * information.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class ChannelzGrpc {
+
+  private ChannelzGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.channelz.v1.Channelz";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetTopChannelsRequest,
+      io.grpc.channelz.v1.GetTopChannelsResponse> getGetTopChannelsMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetTopChannels",
+      requestType = io.grpc.channelz.v1.GetTopChannelsRequest.class,
+      responseType = io.grpc.channelz.v1.GetTopChannelsResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetTopChannelsRequest,
+      io.grpc.channelz.v1.GetTopChannelsResponse> getGetTopChannelsMethod() {
+    io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetTopChannelsRequest, io.grpc.channelz.v1.GetTopChannelsResponse> getGetTopChannelsMethod;
+    if ((getGetTopChannelsMethod = ChannelzGrpc.getGetTopChannelsMethod) == null) {
+      synchronized (ChannelzGrpc.class) {
+        if ((getGetTopChannelsMethod = ChannelzGrpc.getGetTopChannelsMethod) == null) {
+          ChannelzGrpc.getGetTopChannelsMethod = getGetTopChannelsMethod =
+              io.grpc.MethodDescriptor.<io.grpc.channelz.v1.GetTopChannelsRequest, io.grpc.channelz.v1.GetTopChannelsResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetTopChannels"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetTopChannelsRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetTopChannelsResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new ChannelzMethodDescriptorSupplier("GetTopChannels"))
+              .build();
+        }
+      }
+    }
+    return getGetTopChannelsMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetServersRequest,
+      io.grpc.channelz.v1.GetServersResponse> getGetServersMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetServers",
+      requestType = io.grpc.channelz.v1.GetServersRequest.class,
+      responseType = io.grpc.channelz.v1.GetServersResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetServersRequest,
+      io.grpc.channelz.v1.GetServersResponse> getGetServersMethod() {
+    io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetServersRequest, io.grpc.channelz.v1.GetServersResponse> getGetServersMethod;
+    if ((getGetServersMethod = ChannelzGrpc.getGetServersMethod) == null) {
+      synchronized (ChannelzGrpc.class) {
+        if ((getGetServersMethod = ChannelzGrpc.getGetServersMethod) == null) {
+          ChannelzGrpc.getGetServersMethod = getGetServersMethod =
+              io.grpc.MethodDescriptor.<io.grpc.channelz.v1.GetServersRequest, io.grpc.channelz.v1.GetServersResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetServers"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetServersRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetServersResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new ChannelzMethodDescriptorSupplier("GetServers"))
+              .build();
+        }
+      }
+    }
+    return getGetServersMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetServerRequest,
+      io.grpc.channelz.v1.GetServerResponse> getGetServerMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetServer",
+      requestType = io.grpc.channelz.v1.GetServerRequest.class,
+      responseType = io.grpc.channelz.v1.GetServerResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetServerRequest,
+      io.grpc.channelz.v1.GetServerResponse> getGetServerMethod() {
+    io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetServerRequest, io.grpc.channelz.v1.GetServerResponse> getGetServerMethod;
+    if ((getGetServerMethod = ChannelzGrpc.getGetServerMethod) == null) {
+      synchronized (ChannelzGrpc.class) {
+        if ((getGetServerMethod = ChannelzGrpc.getGetServerMethod) == null) {
+          ChannelzGrpc.getGetServerMethod = getGetServerMethod =
+              io.grpc.MethodDescriptor.<io.grpc.channelz.v1.GetServerRequest, io.grpc.channelz.v1.GetServerResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetServer"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetServerRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetServerResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new ChannelzMethodDescriptorSupplier("GetServer"))
+              .build();
+        }
+      }
+    }
+    return getGetServerMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetServerSocketsRequest,
+      io.grpc.channelz.v1.GetServerSocketsResponse> getGetServerSocketsMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetServerSockets",
+      requestType = io.grpc.channelz.v1.GetServerSocketsRequest.class,
+      responseType = io.grpc.channelz.v1.GetServerSocketsResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetServerSocketsRequest,
+      io.grpc.channelz.v1.GetServerSocketsResponse> getGetServerSocketsMethod() {
+    io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetServerSocketsRequest, io.grpc.channelz.v1.GetServerSocketsResponse> getGetServerSocketsMethod;
+    if ((getGetServerSocketsMethod = ChannelzGrpc.getGetServerSocketsMethod) == null) {
+      synchronized (ChannelzGrpc.class) {
+        if ((getGetServerSocketsMethod = ChannelzGrpc.getGetServerSocketsMethod) == null) {
+          ChannelzGrpc.getGetServerSocketsMethod = getGetServerSocketsMethod =
+              io.grpc.MethodDescriptor.<io.grpc.channelz.v1.GetServerSocketsRequest, io.grpc.channelz.v1.GetServerSocketsResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetServerSockets"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetServerSocketsRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetServerSocketsResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new ChannelzMethodDescriptorSupplier("GetServerSockets"))
+              .build();
+        }
+      }
+    }
+    return getGetServerSocketsMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetChannelRequest,
+      io.grpc.channelz.v1.GetChannelResponse> getGetChannelMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetChannel",
+      requestType = io.grpc.channelz.v1.GetChannelRequest.class,
+      responseType = io.grpc.channelz.v1.GetChannelResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetChannelRequest,
+      io.grpc.channelz.v1.GetChannelResponse> getGetChannelMethod() {
+    io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetChannelRequest, io.grpc.channelz.v1.GetChannelResponse> getGetChannelMethod;
+    if ((getGetChannelMethod = ChannelzGrpc.getGetChannelMethod) == null) {
+      synchronized (ChannelzGrpc.class) {
+        if ((getGetChannelMethod = ChannelzGrpc.getGetChannelMethod) == null) {
+          ChannelzGrpc.getGetChannelMethod = getGetChannelMethod =
+              io.grpc.MethodDescriptor.<io.grpc.channelz.v1.GetChannelRequest, io.grpc.channelz.v1.GetChannelResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetChannel"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetChannelRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetChannelResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new ChannelzMethodDescriptorSupplier("GetChannel"))
+              .build();
+        }
+      }
+    }
+    return getGetChannelMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetSubchannelRequest,
+      io.grpc.channelz.v1.GetSubchannelResponse> getGetSubchannelMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetSubchannel",
+      requestType = io.grpc.channelz.v1.GetSubchannelRequest.class,
+      responseType = io.grpc.channelz.v1.GetSubchannelResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetSubchannelRequest,
+      io.grpc.channelz.v1.GetSubchannelResponse> getGetSubchannelMethod() {
+    io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetSubchannelRequest, io.grpc.channelz.v1.GetSubchannelResponse> getGetSubchannelMethod;
+    if ((getGetSubchannelMethod = ChannelzGrpc.getGetSubchannelMethod) == null) {
+      synchronized (ChannelzGrpc.class) {
+        if ((getGetSubchannelMethod = ChannelzGrpc.getGetSubchannelMethod) == null) {
+          ChannelzGrpc.getGetSubchannelMethod = getGetSubchannelMethod =
+              io.grpc.MethodDescriptor.<io.grpc.channelz.v1.GetSubchannelRequest, io.grpc.channelz.v1.GetSubchannelResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetSubchannel"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetSubchannelRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetSubchannelResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new ChannelzMethodDescriptorSupplier("GetSubchannel"))
+              .build();
+        }
+      }
+    }
+    return getGetSubchannelMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetSocketRequest,
+      io.grpc.channelz.v1.GetSocketResponse> getGetSocketMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "GetSocket",
+      requestType = io.grpc.channelz.v1.GetSocketRequest.class,
+      responseType = io.grpc.channelz.v1.GetSocketResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetSocketRequest,
+      io.grpc.channelz.v1.GetSocketResponse> getGetSocketMethod() {
+    io.grpc.MethodDescriptor<io.grpc.channelz.v1.GetSocketRequest, io.grpc.channelz.v1.GetSocketResponse> getGetSocketMethod;
+    if ((getGetSocketMethod = ChannelzGrpc.getGetSocketMethod) == null) {
+      synchronized (ChannelzGrpc.class) {
+        if ((getGetSocketMethod = ChannelzGrpc.getGetSocketMethod) == null) {
+          ChannelzGrpc.getGetSocketMethod = getGetSocketMethod =
+              io.grpc.MethodDescriptor.<io.grpc.channelz.v1.GetSocketRequest, io.grpc.channelz.v1.GetSocketResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetSocket"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetSocketRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.channelz.v1.GetSocketResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new ChannelzMethodDescriptorSupplier("GetSocket"))
+              .build();
+        }
+      }
+    }
+    return getGetSocketMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static ChannelzStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ChannelzStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ChannelzStub>() {
+        @java.lang.Override
+        public ChannelzStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ChannelzStub(channel, callOptions);
+        }
+      };
+    return ChannelzStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static ChannelzBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ChannelzBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ChannelzBlockingV2Stub>() {
+        @java.lang.Override
+        public ChannelzBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ChannelzBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return ChannelzBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static ChannelzBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ChannelzBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ChannelzBlockingStub>() {
+        @java.lang.Override
+        public ChannelzBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ChannelzBlockingStub(channel, callOptions);
+        }
+      };
+    return ChannelzBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static ChannelzFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ChannelzFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ChannelzFutureStub>() {
+        @java.lang.Override
+        public ChannelzFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ChannelzFutureStub(channel, callOptions);
+        }
+      };
+    return ChannelzFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * Channelz is a service exposed by gRPC servers that provides detailed debug
+   * information.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Gets all root channels (i.e. channels the application has directly
+     * created). This does not include subchannels nor non-top level channels.
+     * </pre>
+     */
+    default void getTopChannels(io.grpc.channelz.v1.GetTopChannelsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetTopChannelsResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetTopChannelsMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Gets all servers that exist in the process.
+     * </pre>
+     */
+    default void getServers(io.grpc.channelz.v1.GetServersRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetServersResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetServersMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Server, or else a NOT_FOUND code.
+     * </pre>
+     */
+    default void getServer(io.grpc.channelz.v1.GetServerRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetServerResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetServerMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Gets all server sockets that exist in the process.
+     * </pre>
+     */
+    default void getServerSockets(io.grpc.channelz.v1.GetServerSocketsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetServerSocketsResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetServerSocketsMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Channel, or else a NOT_FOUND code.
+     * </pre>
+     */
+    default void getChannel(io.grpc.channelz.v1.GetChannelRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetChannelResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetChannelMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Subchannel, or else a NOT_FOUND code.
+     * </pre>
+     */
+    default void getSubchannel(io.grpc.channelz.v1.GetSubchannelRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetSubchannelResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetSubchannelMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Socket or else a NOT_FOUND code.
+     * </pre>
+     */
+    default void getSocket(io.grpc.channelz.v1.GetSocketRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetSocketResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetSocketMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service Channelz.
+   * <pre>
+   * Channelz is a service exposed by gRPC servers that provides detailed debug
+   * information.
+   * </pre>
+   */
+  public static abstract class ChannelzImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return ChannelzGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service Channelz.
+   * <pre>
+   * Channelz is a service exposed by gRPC servers that provides detailed debug
+   * information.
+   * </pre>
+   */
+  public static final class ChannelzStub
+      extends io.grpc.stub.AbstractAsyncStub<ChannelzStub> {
+    private ChannelzStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ChannelzStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ChannelzStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets all root channels (i.e. channels the application has directly
+     * created). This does not include subchannels nor non-top level channels.
+     * </pre>
+     */
+    public void getTopChannels(io.grpc.channelz.v1.GetTopChannelsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetTopChannelsResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetTopChannelsMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Gets all servers that exist in the process.
+     * </pre>
+     */
+    public void getServers(io.grpc.channelz.v1.GetServersRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetServersResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetServersMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Server, or else a NOT_FOUND code.
+     * </pre>
+     */
+    public void getServer(io.grpc.channelz.v1.GetServerRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetServerResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetServerMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Gets all server sockets that exist in the process.
+     * </pre>
+     */
+    public void getServerSockets(io.grpc.channelz.v1.GetServerSocketsRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetServerSocketsResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetServerSocketsMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Channel, or else a NOT_FOUND code.
+     * </pre>
+     */
+    public void getChannel(io.grpc.channelz.v1.GetChannelRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetChannelResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetChannelMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Subchannel, or else a NOT_FOUND code.
+     * </pre>
+     */
+    public void getSubchannel(io.grpc.channelz.v1.GetSubchannelRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetSubchannelResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetSubchannelMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Socket or else a NOT_FOUND code.
+     * </pre>
+     */
+    public void getSocket(io.grpc.channelz.v1.GetSocketRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetSocketResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getGetSocketMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service Channelz.
+   * <pre>
+   * Channelz is a service exposed by gRPC servers that provides detailed debug
+   * information.
+   * </pre>
+   */
+  public static final class ChannelzBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<ChannelzBlockingV2Stub> {
+    private ChannelzBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ChannelzBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ChannelzBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets all root channels (i.e. channels the application has directly
+     * created). This does not include subchannels nor non-top level channels.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetTopChannelsResponse getTopChannels(io.grpc.channelz.v1.GetTopChannelsRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetTopChannelsMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Gets all servers that exist in the process.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetServersResponse getServers(io.grpc.channelz.v1.GetServersRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetServersMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Server, or else a NOT_FOUND code.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetServerResponse getServer(io.grpc.channelz.v1.GetServerRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetServerMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Gets all server sockets that exist in the process.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetServerSocketsResponse getServerSockets(io.grpc.channelz.v1.GetServerSocketsRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetServerSocketsMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Channel, or else a NOT_FOUND code.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetChannelResponse getChannel(io.grpc.channelz.v1.GetChannelRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetChannelMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Subchannel, or else a NOT_FOUND code.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetSubchannelResponse getSubchannel(io.grpc.channelz.v1.GetSubchannelRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetSubchannelMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Socket or else a NOT_FOUND code.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetSocketResponse getSocket(io.grpc.channelz.v1.GetSocketRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getGetSocketMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service Channelz.
+   * <pre>
+   * Channelz is a service exposed by gRPC servers that provides detailed debug
+   * information.
+   * </pre>
+   */
+  public static final class ChannelzBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<ChannelzBlockingStub> {
+    private ChannelzBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ChannelzBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ChannelzBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets all root channels (i.e. channels the application has directly
+     * created). This does not include subchannels nor non-top level channels.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetTopChannelsResponse getTopChannels(io.grpc.channelz.v1.GetTopChannelsRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetTopChannelsMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Gets all servers that exist in the process.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetServersResponse getServers(io.grpc.channelz.v1.GetServersRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetServersMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Server, or else a NOT_FOUND code.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetServerResponse getServer(io.grpc.channelz.v1.GetServerRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetServerMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Gets all server sockets that exist in the process.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetServerSocketsResponse getServerSockets(io.grpc.channelz.v1.GetServerSocketsRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetServerSocketsMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Channel, or else a NOT_FOUND code.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetChannelResponse getChannel(io.grpc.channelz.v1.GetChannelRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetChannelMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Subchannel, or else a NOT_FOUND code.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetSubchannelResponse getSubchannel(io.grpc.channelz.v1.GetSubchannelRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetSubchannelMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Socket or else a NOT_FOUND code.
+     * </pre>
+     */
+    public io.grpc.channelz.v1.GetSocketResponse getSocket(io.grpc.channelz.v1.GetSocketRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getGetSocketMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service Channelz.
+   * <pre>
+   * Channelz is a service exposed by gRPC servers that provides detailed debug
+   * information.
+   * </pre>
+   */
+  public static final class ChannelzFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ChannelzFutureStub> {
+    private ChannelzFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ChannelzFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ChannelzFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Gets all root channels (i.e. channels the application has directly
+     * created). This does not include subchannels nor non-top level channels.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.channelz.v1.GetTopChannelsResponse> getTopChannels(
+        io.grpc.channelz.v1.GetTopChannelsRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetTopChannelsMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * Gets all servers that exist in the process.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.channelz.v1.GetServersResponse> getServers(
+        io.grpc.channelz.v1.GetServersRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetServersMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Server, or else a NOT_FOUND code.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.channelz.v1.GetServerResponse> getServer(
+        io.grpc.channelz.v1.GetServerRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetServerMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * Gets all server sockets that exist in the process.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.channelz.v1.GetServerSocketsResponse> getServerSockets(
+        io.grpc.channelz.v1.GetServerSocketsRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetServerSocketsMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Channel, or else a NOT_FOUND code.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.channelz.v1.GetChannelResponse> getChannel(
+        io.grpc.channelz.v1.GetChannelRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetChannelMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Subchannel, or else a NOT_FOUND code.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.channelz.v1.GetSubchannelResponse> getSubchannel(
+        io.grpc.channelz.v1.GetSubchannelRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetSubchannelMethod(), getCallOptions()), request);
+    }
+
+    /**
+     * <pre>
+     * Returns a single Socket or else a NOT_FOUND code.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.channelz.v1.GetSocketResponse> getSocket(
+        io.grpc.channelz.v1.GetSocketRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getGetSocketMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_GET_TOP_CHANNELS = 0;
+  private static final int METHODID_GET_SERVERS = 1;
+  private static final int METHODID_GET_SERVER = 2;
+  private static final int METHODID_GET_SERVER_SOCKETS = 3;
+  private static final int METHODID_GET_CHANNEL = 4;
+  private static final int METHODID_GET_SUBCHANNEL = 5;
+  private static final int METHODID_GET_SOCKET = 6;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_GET_TOP_CHANNELS:
+          serviceImpl.getTopChannels((io.grpc.channelz.v1.GetTopChannelsRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetTopChannelsResponse>) responseObserver);
+          break;
+        case METHODID_GET_SERVERS:
+          serviceImpl.getServers((io.grpc.channelz.v1.GetServersRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetServersResponse>) responseObserver);
+          break;
+        case METHODID_GET_SERVER:
+          serviceImpl.getServer((io.grpc.channelz.v1.GetServerRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetServerResponse>) responseObserver);
+          break;
+        case METHODID_GET_SERVER_SOCKETS:
+          serviceImpl.getServerSockets((io.grpc.channelz.v1.GetServerSocketsRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetServerSocketsResponse>) responseObserver);
+          break;
+        case METHODID_GET_CHANNEL:
+          serviceImpl.getChannel((io.grpc.channelz.v1.GetChannelRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetChannelResponse>) responseObserver);
+          break;
+        case METHODID_GET_SUBCHANNEL:
+          serviceImpl.getSubchannel((io.grpc.channelz.v1.GetSubchannelRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetSubchannelResponse>) responseObserver);
+          break;
+        case METHODID_GET_SOCKET:
+          serviceImpl.getSocket((io.grpc.channelz.v1.GetSocketRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.channelz.v1.GetSocketResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getGetTopChannelsMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.channelz.v1.GetTopChannelsRequest,
+              io.grpc.channelz.v1.GetTopChannelsResponse>(
+                service, METHODID_GET_TOP_CHANNELS)))
+        .addMethod(
+          getGetServersMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.channelz.v1.GetServersRequest,
+              io.grpc.channelz.v1.GetServersResponse>(
+                service, METHODID_GET_SERVERS)))
+        .addMethod(
+          getGetServerMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.channelz.v1.GetServerRequest,
+              io.grpc.channelz.v1.GetServerResponse>(
+                service, METHODID_GET_SERVER)))
+        .addMethod(
+          getGetServerSocketsMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.channelz.v1.GetServerSocketsRequest,
+              io.grpc.channelz.v1.GetServerSocketsResponse>(
+                service, METHODID_GET_SERVER_SOCKETS)))
+        .addMethod(
+          getGetChannelMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.channelz.v1.GetChannelRequest,
+              io.grpc.channelz.v1.GetChannelResponse>(
+                service, METHODID_GET_CHANNEL)))
+        .addMethod(
+          getGetSubchannelMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.channelz.v1.GetSubchannelRequest,
+              io.grpc.channelz.v1.GetSubchannelResponse>(
+                service, METHODID_GET_SUBCHANNEL)))
+        .addMethod(
+          getGetSocketMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.channelz.v1.GetSocketRequest,
+              io.grpc.channelz.v1.GetSocketResponse>(
+                service, METHODID_GET_SOCKET)))
+        .build();
+  }
+
+  private static abstract class ChannelzBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    ChannelzBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.channelz.v1.ChannelzProto.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("Channelz");
+    }
+  }
+
+  private static final class ChannelzFileDescriptorSupplier
+      extends ChannelzBaseDescriptorSupplier {
+    ChannelzFileDescriptorSupplier() {}
+  }
+
+  private static final class ChannelzMethodDescriptorSupplier
+      extends ChannelzBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    ChannelzMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (ChannelzGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new ChannelzFileDescriptorSupplier())
+              .addMethod(getGetTopChannelsMethod())
+              .addMethod(getGetServersMethod())
+              .addMethod(getGetServerMethod())
+              .addMethod(getGetServerSocketsMethod())
+              .addMethod(getGetChannelMethod())
+              .addMethod(getGetSubchannelMethod())
+              .addMethod(getGetSocketMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/services/src/generated/main/grpc/io/grpc/health/v1/HealthGrpc.java b/services/src/generated/main/grpc/io/grpc/health/v1/HealthGrpc.java
index 7b9fb89c818..b8e94ef7d20 100644
--- a/services/src/generated/main/grpc/io/grpc/health/v1/HealthGrpc.java
+++ b/services/src/generated/main/grpc/io/grpc/health/v1/HealthGrpc.java
@@ -1,47 +1,106 @@
 package io.grpc.health.v1;
 
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
 import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: health.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class HealthGrpc {
 
   private HealthGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.health.v1.Health";
+  public static final java.lang.String SERVICE_NAME = "grpc.health.v1.Health";
 
   // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.health.v1.HealthCheckRequest,
-      io.grpc.health.v1.HealthCheckResponse> METHOD_CHECK =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.health.v1.Health", "Check"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.health.v1.HealthCheckRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.health.v1.HealthCheckResponse.getDefaultInstance()));
+  private static volatile io.grpc.MethodDescriptor<io.grpc.health.v1.HealthCheckRequest,
+      io.grpc.health.v1.HealthCheckResponse> getCheckMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Check",
+      requestType = io.grpc.health.v1.HealthCheckRequest.class,
+      responseType = io.grpc.health.v1.HealthCheckResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.health.v1.HealthCheckRequest,
+      io.grpc.health.v1.HealthCheckResponse> getCheckMethod() {
+    io.grpc.MethodDescriptor<io.grpc.health.v1.HealthCheckRequest, io.grpc.health.v1.HealthCheckResponse> getCheckMethod;
+    if ((getCheckMethod = HealthGrpc.getCheckMethod) == null) {
+      synchronized (HealthGrpc.class) {
+        if ((getCheckMethod = HealthGrpc.getCheckMethod) == null) {
+          HealthGrpc.getCheckMethod = getCheckMethod =
+              io.grpc.MethodDescriptor.<io.grpc.health.v1.HealthCheckRequest, io.grpc.health.v1.HealthCheckResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Check"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.health.v1.HealthCheckRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.health.v1.HealthCheckResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new HealthMethodDescriptorSupplier("Check"))
+              .build();
+        }
+      }
+    }
+    return getCheckMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.health.v1.HealthCheckRequest,
+      io.grpc.health.v1.HealthCheckResponse> getWatchMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Watch",
+      requestType = io.grpc.health.v1.HealthCheckRequest.class,
+      responseType = io.grpc.health.v1.HealthCheckResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.health.v1.HealthCheckRequest,
+      io.grpc.health.v1.HealthCheckResponse> getWatchMethod() {
+    io.grpc.MethodDescriptor<io.grpc.health.v1.HealthCheckRequest, io.grpc.health.v1.HealthCheckResponse> getWatchMethod;
+    if ((getWatchMethod = HealthGrpc.getWatchMethod) == null) {
+      synchronized (HealthGrpc.class) {
+        if ((getWatchMethod = HealthGrpc.getWatchMethod) == null) {
+          HealthGrpc.getWatchMethod = getWatchMethod =
+              io.grpc.MethodDescriptor.<io.grpc.health.v1.HealthCheckRequest, io.grpc.health.v1.HealthCheckResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Watch"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.health.v1.HealthCheckRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.health.v1.HealthCheckResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new HealthMethodDescriptorSupplier("Watch"))
+              .build();
+        }
+      }
+    }
+    return getWatchMethod;
+  }
 
   /**
    * Creates a new async stub that supports all call types for the service
    */
   public static HealthStub newStub(io.grpc.Channel channel) {
-    return new HealthStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<HealthStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<HealthStub>() {
+        @java.lang.Override
+        public HealthStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new HealthStub(channel, callOptions);
+        }
+      };
+    return HealthStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static HealthBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<HealthBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<HealthBlockingV2Stub>() {
+        @java.lang.Override
+        public HealthBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new HealthBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return HealthBlockingV2Stub.newStub(factory, channel);
   }
 
   /**
@@ -49,132 +108,276 @@ public static HealthStub newStub(io.grpc.Channel channel) {
    */
   public static HealthBlockingStub newBlockingStub(
       io.grpc.Channel channel) {
-    return new HealthBlockingStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<HealthBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<HealthBlockingStub>() {
+        @java.lang.Override
+        public HealthBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new HealthBlockingStub(channel, callOptions);
+        }
+      };
+    return HealthBlockingStub.newStub(factory, channel);
   }
 
   /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
    */
   public static HealthFutureStub newFutureStub(
       io.grpc.Channel channel) {
-    return new HealthFutureStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<HealthFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<HealthFutureStub>() {
+        @java.lang.Override
+        public HealthFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new HealthFutureStub(channel, callOptions);
+        }
+      };
+    return HealthFutureStub.newStub(factory, channel);
   }
 
   /**
    */
-  public static abstract class HealthImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
+     * <pre>
+     * If the requested service is unknown, the call will fail with status
+     * NOT_FOUND.
+     * </pre>
      */
-    public void check(io.grpc.health.v1.HealthCheckRequest request,
+    default void check(io.grpc.health.v1.HealthCheckRequest request,
         io.grpc.stub.StreamObserver<io.grpc.health.v1.HealthCheckResponse> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_CHECK, responseObserver);
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCheckMethod(), responseObserver);
     }
 
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_CHECK,
-            asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.health.v1.HealthCheckRequest,
-                io.grpc.health.v1.HealthCheckResponse>(
-                  this, METHODID_CHECK)))
-          .build();
+    /**
+     * <pre>
+     * Performs a watch for the serving status of the requested service.
+     * The server will immediately send back a message indicating the current
+     * serving status.  It will then subsequently send a new message whenever
+     * the service's serving status changes.
+     * If the requested service is unknown when the call is received, the
+     * server will send a message setting the serving status to
+     * SERVICE_UNKNOWN but will *not* terminate the call.  If at some
+     * future point, the serving status of the service becomes known, the
+     * server will send a new message with the service's serving status.
+     * If the call terminates with status UNIMPLEMENTED, then clients
+     * should assume this method is not supported and should not retry the
+     * call.  If the call terminates with any other status (including OK),
+     * clients should retry the call with appropriate exponential backoff.
+     * </pre>
+     */
+    default void watch(io.grpc.health.v1.HealthCheckRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.health.v1.HealthCheckResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getWatchMethod(), responseObserver);
     }
   }
 
   /**
+   * Base class for the server implementation of the service Health.
    */
-  public static final class HealthStub extends io.grpc.stub.AbstractStub<HealthStub> {
-    private HealthStub(io.grpc.Channel channel) {
-      super(channel);
+  public static abstract class HealthImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return HealthGrpc.bindService(this);
     }
+  }
 
-    private HealthStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service Health.
+   */
+  public static final class HealthStub
+      extends io.grpc.stub.AbstractAsyncStub<HealthStub> {
+    private HealthStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected HealthStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected HealthStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new HealthStub(channel, callOptions);
     }
 
     /**
+     * <pre>
+     * If the requested service is unknown, the call will fail with status
+     * NOT_FOUND.
+     * </pre>
      */
     public void check(io.grpc.health.v1.HealthCheckRequest request,
         io.grpc.stub.StreamObserver<io.grpc.health.v1.HealthCheckResponse> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_CHECK, getCallOptions()), request, responseObserver);
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getCheckMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Performs a watch for the serving status of the requested service.
+     * The server will immediately send back a message indicating the current
+     * serving status.  It will then subsequently send a new message whenever
+     * the service's serving status changes.
+     * If the requested service is unknown when the call is received, the
+     * server will send a message setting the serving status to
+     * SERVICE_UNKNOWN but will *not* terminate the call.  If at some
+     * future point, the serving status of the service becomes known, the
+     * server will send a new message with the service's serving status.
+     * If the call terminates with status UNIMPLEMENTED, then clients
+     * should assume this method is not supported and should not retry the
+     * call.  If the call terminates with any other status (including OK),
+     * clients should retry the call with appropriate exponential backoff.
+     * </pre>
+     */
+    public void watch(io.grpc.health.v1.HealthCheckRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.health.v1.HealthCheckResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getWatchMethod(), getCallOptions()), request, responseObserver);
     }
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service Health.
    */
-  public static final class HealthBlockingStub extends io.grpc.stub.AbstractStub<HealthBlockingStub> {
-    private HealthBlockingStub(io.grpc.Channel channel) {
-      super(channel);
+  public static final class HealthBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<HealthBlockingV2Stub> {
+    private HealthBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected HealthBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new HealthBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * If the requested service is unknown, the call will fail with status
+     * NOT_FOUND.
+     * </pre>
+     */
+    public io.grpc.health.v1.HealthCheckResponse check(io.grpc.health.v1.HealthCheckRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getCheckMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Performs a watch for the serving status of the requested service.
+     * The server will immediately send back a message indicating the current
+     * serving status.  It will then subsequently send a new message whenever
+     * the service's serving status changes.
+     * If the requested service is unknown when the call is received, the
+     * server will send a message setting the serving status to
+     * SERVICE_UNKNOWN but will *not* terminate the call.  If at some
+     * future point, the serving status of the service becomes known, the
+     * server will send a new message with the service's serving status.
+     * If the call terminates with status UNIMPLEMENTED, then clients
+     * should assume this method is not supported and should not retry the
+     * call.  If the call terminates with any other status (including OK),
+     * clients should retry the call with appropriate exponential backoff.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<?, io.grpc.health.v1.HealthCheckResponse>
+        watch(io.grpc.health.v1.HealthCheckRequest request) {
+      return io.grpc.stub.ClientCalls.blockingV2ServerStreamingCall(
+          getChannel(), getWatchMethod(), getCallOptions(), request);
     }
+  }
 
-    private HealthBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service Health.
+   */
+  public static final class HealthBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<HealthBlockingStub> {
+    private HealthBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected HealthBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected HealthBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new HealthBlockingStub(channel, callOptions);
     }
 
     /**
+     * <pre>
+     * If the requested service is unknown, the call will fail with status
+     * NOT_FOUND.
+     * </pre>
      */
     public io.grpc.health.v1.HealthCheckResponse check(io.grpc.health.v1.HealthCheckRequest request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_CHECK, getCallOptions(), request);
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getCheckMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Performs a watch for the serving status of the requested service.
+     * The server will immediately send back a message indicating the current
+     * serving status.  It will then subsequently send a new message whenever
+     * the service's serving status changes.
+     * If the requested service is unknown when the call is received, the
+     * server will send a message setting the serving status to
+     * SERVICE_UNKNOWN but will *not* terminate the call.  If at some
+     * future point, the serving status of the service becomes known, the
+     * server will send a new message with the service's serving status.
+     * If the call terminates with status UNIMPLEMENTED, then clients
+     * should assume this method is not supported and should not retry the
+     * call.  If the call terminates with any other status (including OK),
+     * clients should retry the call with appropriate exponential backoff.
+     * </pre>
+     */
+    public java.util.Iterator<io.grpc.health.v1.HealthCheckResponse> watch(
+        io.grpc.health.v1.HealthCheckRequest request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getWatchMethod(), getCallOptions(), request);
     }
   }
 
   /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service Health.
    */
-  public static final class HealthFutureStub extends io.grpc.stub.AbstractStub<HealthFutureStub> {
-    private HealthFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private HealthFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class HealthFutureStub
+      extends io.grpc.stub.AbstractFutureStub<HealthFutureStub> {
+    private HealthFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected HealthFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected HealthFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new HealthFutureStub(channel, callOptions);
     }
 
     /**
+     * <pre>
+     * If the requested service is unknown, the call will fail with status
+     * NOT_FOUND.
+     * </pre>
      */
     public com.google.common.util.concurrent.ListenableFuture<io.grpc.health.v1.HealthCheckResponse> check(
         io.grpc.health.v1.HealthCheckRequest request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_CHECK, getCallOptions()), request);
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getCheckMethod(), getCallOptions()), request);
     }
   }
 
   private static final int METHODID_CHECK = 0;
+  private static final int METHODID_WATCH = 1;
 
   private static final class MethodHandlers<Req, Resp> implements
       io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final HealthImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(HealthImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -187,6 +390,10 @@ public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserv
           serviceImpl.check((io.grpc.health.v1.HealthCheckRequest) request,
               (io.grpc.stub.StreamObserver<io.grpc.health.v1.HealthCheckResponse>) responseObserver);
           break;
+        case METHODID_WATCH:
+          serviceImpl.watch((io.grpc.health.v1.HealthCheckRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.health.v1.HealthCheckResponse>) responseObserver);
+          break;
         default:
           throw new AssertionError();
       }
@@ -203,11 +410,58 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
-  private static final class HealthDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getCheckMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.health.v1.HealthCheckRequest,
+              io.grpc.health.v1.HealthCheckResponse>(
+                service, METHODID_CHECK)))
+        .addMethod(
+          getWatchMethod(),
+          io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+            new MethodHandlers<
+              io.grpc.health.v1.HealthCheckRequest,
+              io.grpc.health.v1.HealthCheckResponse>(
+                service, METHODID_WATCH)))
+        .build();
+  }
+
+  private static abstract class HealthBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    HealthBaseDescriptorSupplier() {}
+
     @java.lang.Override
     public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
       return io.grpc.health.v1.HealthProto.getDescriptor();
     }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("Health");
+    }
+  }
+
+  private static final class HealthFileDescriptorSupplier
+      extends HealthBaseDescriptorSupplier {
+    HealthFileDescriptorSupplier() {}
+  }
+
+  private static final class HealthMethodDescriptorSupplier
+      extends HealthBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    HealthMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
   }
 
   private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
@@ -219,8 +473,9 @@ public static io.grpc.ServiceDescriptor getServiceDescriptor() {
         result = serviceDescriptor;
         if (result == null) {
           serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new HealthDescriptorSupplier())
-              .addMethod(METHOD_CHECK)
+              .setSchemaDescriptor(new HealthFileDescriptorSupplier())
+              .addMethod(getCheckMethod())
+              .addMethod(getWatchMethod())
               .build();
         }
       }
diff --git a/services/src/generated/main/grpc/io/grpc/reflection/v1/ServerReflectionGrpc.java b/services/src/generated/main/grpc/io/grpc/reflection/v1/ServerReflectionGrpc.java
new file mode 100644
index 00000000000..04f8dea3ace
--- /dev/null
+++ b/services/src/generated/main/grpc/io/grpc/reflection/v1/ServerReflectionGrpc.java
@@ -0,0 +1,327 @@
+package io.grpc.reflection.v1;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class ServerReflectionGrpc {
+
+  private ServerReflectionGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.reflection.v1.ServerReflection";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.reflection.v1.ServerReflectionRequest,
+      io.grpc.reflection.v1.ServerReflectionResponse> getServerReflectionInfoMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "ServerReflectionInfo",
+      requestType = io.grpc.reflection.v1.ServerReflectionRequest.class,
+      responseType = io.grpc.reflection.v1.ServerReflectionResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.reflection.v1.ServerReflectionRequest,
+      io.grpc.reflection.v1.ServerReflectionResponse> getServerReflectionInfoMethod() {
+    io.grpc.MethodDescriptor<io.grpc.reflection.v1.ServerReflectionRequest, io.grpc.reflection.v1.ServerReflectionResponse> getServerReflectionInfoMethod;
+    if ((getServerReflectionInfoMethod = ServerReflectionGrpc.getServerReflectionInfoMethod) == null) {
+      synchronized (ServerReflectionGrpc.class) {
+        if ((getServerReflectionInfoMethod = ServerReflectionGrpc.getServerReflectionInfoMethod) == null) {
+          ServerReflectionGrpc.getServerReflectionInfoMethod = getServerReflectionInfoMethod =
+              io.grpc.MethodDescriptor.<io.grpc.reflection.v1.ServerReflectionRequest, io.grpc.reflection.v1.ServerReflectionResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ServerReflectionInfo"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.reflection.v1.ServerReflectionRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.reflection.v1.ServerReflectionResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new ServerReflectionMethodDescriptorSupplier("ServerReflectionInfo"))
+              .build();
+        }
+      }
+    }
+    return getServerReflectionInfoMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static ServerReflectionStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ServerReflectionStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ServerReflectionStub>() {
+        @java.lang.Override
+        public ServerReflectionStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ServerReflectionStub(channel, callOptions);
+        }
+      };
+    return ServerReflectionStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static ServerReflectionBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ServerReflectionBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ServerReflectionBlockingV2Stub>() {
+        @java.lang.Override
+        public ServerReflectionBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ServerReflectionBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return ServerReflectionBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static ServerReflectionBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ServerReflectionBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ServerReflectionBlockingStub>() {
+        @java.lang.Override
+        public ServerReflectionBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ServerReflectionBlockingStub(channel, callOptions);
+        }
+      };
+    return ServerReflectionBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static ServerReflectionFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ServerReflectionFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ServerReflectionFutureStub>() {
+        @java.lang.Override
+        public ServerReflectionFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ServerReflectionFutureStub(channel, callOptions);
+        }
+      };
+    return ServerReflectionFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * The reflection service is structured as a bidirectional stream, ensuring
+     * all related requests go to a single server.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.reflection.v1.ServerReflectionRequest> serverReflectionInfo(
+        io.grpc.stub.StreamObserver<io.grpc.reflection.v1.ServerReflectionResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getServerReflectionInfoMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service ServerReflection.
+   */
+  public static abstract class ServerReflectionImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return ServerReflectionGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service ServerReflection.
+   */
+  public static final class ServerReflectionStub
+      extends io.grpc.stub.AbstractAsyncStub<ServerReflectionStub> {
+    private ServerReflectionStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ServerReflectionStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ServerReflectionStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * The reflection service is structured as a bidirectional stream, ensuring
+     * all related requests go to a single server.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.reflection.v1.ServerReflectionRequest> serverReflectionInfo(
+        io.grpc.stub.StreamObserver<io.grpc.reflection.v1.ServerReflectionResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getServerReflectionInfoMethod(), getCallOptions()), responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service ServerReflection.
+   */
+  public static final class ServerReflectionBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<ServerReflectionBlockingV2Stub> {
+    private ServerReflectionBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ServerReflectionBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ServerReflectionBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * The reflection service is structured as a bidirectional stream, ensuring
+     * all related requests go to a single server.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.reflection.v1.ServerReflectionRequest, io.grpc.reflection.v1.ServerReflectionResponse>
+        serverReflectionInfo() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getServerReflectionInfoMethod(), getCallOptions());
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service ServerReflection.
+   */
+  public static final class ServerReflectionBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<ServerReflectionBlockingStub> {
+    private ServerReflectionBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ServerReflectionBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ServerReflectionBlockingStub(channel, callOptions);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service ServerReflection.
+   */
+  public static final class ServerReflectionFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ServerReflectionFutureStub> {
+    private ServerReflectionFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ServerReflectionFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ServerReflectionFutureStub(channel, callOptions);
+    }
+  }
+
+  private static final int METHODID_SERVER_REFLECTION_INFO = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_SERVER_REFLECTION_INFO:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.serverReflectionInfo(
+              (io.grpc.stub.StreamObserver<io.grpc.reflection.v1.ServerReflectionResponse>) responseObserver);
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getServerReflectionInfoMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.reflection.v1.ServerReflectionRequest,
+              io.grpc.reflection.v1.ServerReflectionResponse>(
+                service, METHODID_SERVER_REFLECTION_INFO)))
+        .build();
+  }
+
+  private static abstract class ServerReflectionBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    ServerReflectionBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.reflection.v1.ServerReflectionProto.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("ServerReflection");
+    }
+  }
+
+  private static final class ServerReflectionFileDescriptorSupplier
+      extends ServerReflectionBaseDescriptorSupplier {
+    ServerReflectionFileDescriptorSupplier() {}
+  }
+
+  private static final class ServerReflectionMethodDescriptorSupplier
+      extends ServerReflectionBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    ServerReflectionMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (ServerReflectionGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new ServerReflectionFileDescriptorSupplier())
+              .addMethod(getServerReflectionInfoMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/services/src/generated/main/grpc/io/grpc/reflection/v1alpha/ServerReflectionGrpc.java b/services/src/generated/main/grpc/io/grpc/reflection/v1alpha/ServerReflectionGrpc.java
index 0902eab506f..3cbb3a1d1b9 100644
--- a/services/src/generated/main/grpc/io/grpc/reflection/v1alpha/ServerReflectionGrpc.java
+++ b/services/src/generated/main/grpc/io/grpc/reflection/v1alpha/ServerReflectionGrpc.java
@@ -1,47 +1,75 @@
 package io.grpc.reflection.v1alpha;
 
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
 import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: io/grpc/reflection/v1alpha/reflection.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class ServerReflectionGrpc {
 
   private ServerReflectionGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.reflection.v1alpha.ServerReflection";
+  public static final java.lang.String SERVICE_NAME = "grpc.reflection.v1alpha.ServerReflection";
 
   // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.reflection.v1alpha.ServerReflectionRequest,
-      io.grpc.reflection.v1alpha.ServerReflectionResponse> METHOD_SERVER_REFLECTION_INFO =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
-          generateFullMethodName(
-              "grpc.reflection.v1alpha.ServerReflection", "ServerReflectionInfo"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.reflection.v1alpha.ServerReflectionRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.reflection.v1alpha.ServerReflectionResponse.getDefaultInstance()));
+  private static volatile io.grpc.MethodDescriptor<io.grpc.reflection.v1alpha.ServerReflectionRequest,
+      io.grpc.reflection.v1alpha.ServerReflectionResponse> getServerReflectionInfoMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "ServerReflectionInfo",
+      requestType = io.grpc.reflection.v1alpha.ServerReflectionRequest.class,
+      responseType = io.grpc.reflection.v1alpha.ServerReflectionResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.reflection.v1alpha.ServerReflectionRequest,
+      io.grpc.reflection.v1alpha.ServerReflectionResponse> getServerReflectionInfoMethod() {
+    io.grpc.MethodDescriptor<io.grpc.reflection.v1alpha.ServerReflectionRequest, io.grpc.reflection.v1alpha.ServerReflectionResponse> getServerReflectionInfoMethod;
+    if ((getServerReflectionInfoMethod = ServerReflectionGrpc.getServerReflectionInfoMethod) == null) {
+      synchronized (ServerReflectionGrpc.class) {
+        if ((getServerReflectionInfoMethod = ServerReflectionGrpc.getServerReflectionInfoMethod) == null) {
+          ServerReflectionGrpc.getServerReflectionInfoMethod = getServerReflectionInfoMethod =
+              io.grpc.MethodDescriptor.<io.grpc.reflection.v1alpha.ServerReflectionRequest, io.grpc.reflection.v1alpha.ServerReflectionResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ServerReflectionInfo"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.reflection.v1alpha.ServerReflectionRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.reflection.v1alpha.ServerReflectionResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new ServerReflectionMethodDescriptorSupplier("ServerReflectionInfo"))
+              .build();
+        }
+      }
+    }
+    return getServerReflectionInfoMethod;
+  }
 
   /**
    * Creates a new async stub that supports all call types for the service
    */
   public static ServerReflectionStub newStub(io.grpc.Channel channel) {
-    return new ServerReflectionStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<ServerReflectionStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ServerReflectionStub>() {
+        @java.lang.Override
+        public ServerReflectionStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ServerReflectionStub(channel, callOptions);
+        }
+      };
+    return ServerReflectionStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static ServerReflectionBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ServerReflectionBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ServerReflectionBlockingV2Stub>() {
+        @java.lang.Override
+        public ServerReflectionBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ServerReflectionBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return ServerReflectionBlockingV2Stub.newStub(factory, channel);
   }
 
   /**
@@ -49,20 +77,34 @@ public static ServerReflectionStub newStub(io.grpc.Channel channel) {
    */
   public static ServerReflectionBlockingStub newBlockingStub(
       io.grpc.Channel channel) {
-    return new ServerReflectionBlockingStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<ServerReflectionBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ServerReflectionBlockingStub>() {
+        @java.lang.Override
+        public ServerReflectionBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ServerReflectionBlockingStub(channel, callOptions);
+        }
+      };
+    return ServerReflectionBlockingStub.newStub(factory, channel);
   }
 
   /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
    */
   public static ServerReflectionFutureStub newFutureStub(
       io.grpc.Channel channel) {
-    return new ServerReflectionFutureStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<ServerReflectionFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ServerReflectionFutureStub>() {
+        @java.lang.Override
+        public ServerReflectionFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ServerReflectionFutureStub(channel, callOptions);
+        }
+      };
+    return ServerReflectionFutureStub.newStub(factory, channel);
   }
 
   /**
    */
-  public static abstract class ServerReflectionImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
@@ -70,39 +112,36 @@ public static abstract class ServerReflectionImplBase implements io.grpc.Bindabl
      * all related requests go to a single server.
      * </pre>
      */
-    public io.grpc.stub.StreamObserver<io.grpc.reflection.v1alpha.ServerReflectionRequest> serverReflectionInfo(
+    default io.grpc.stub.StreamObserver<io.grpc.reflection.v1alpha.ServerReflectionRequest> serverReflectionInfo(
         io.grpc.stub.StreamObserver<io.grpc.reflection.v1alpha.ServerReflectionResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_SERVER_REFLECTION_INFO, responseObserver);
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getServerReflectionInfoMethod(), responseObserver);
     }
+  }
+
+  /**
+   * Base class for the server implementation of the service ServerReflection.
+   */
+  public static abstract class ServerReflectionImplBase
+      implements io.grpc.BindableService, AsyncService {
 
     @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_SERVER_REFLECTION_INFO,
-            asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.reflection.v1alpha.ServerReflectionRequest,
-                io.grpc.reflection.v1alpha.ServerReflectionResponse>(
-                  this, METHODID_SERVER_REFLECTION_INFO)))
-          .build();
+      return ServerReflectionGrpc.bindService(this);
     }
   }
 
   /**
+   * A stub to allow clients to do asynchronous rpc calls to service ServerReflection.
    */
-  public static final class ServerReflectionStub extends io.grpc.stub.AbstractStub<ServerReflectionStub> {
-    private ServerReflectionStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private ServerReflectionStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class ServerReflectionStub
+      extends io.grpc.stub.AbstractAsyncStub<ServerReflectionStub> {
+    private ServerReflectionStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected ServerReflectionStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected ServerReflectionStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new ServerReflectionStub(channel, callOptions);
     }
 
@@ -114,45 +153,71 @@ protected ServerReflectionStub build(io.grpc.Channel channel,
      */
     public io.grpc.stub.StreamObserver<io.grpc.reflection.v1alpha.ServerReflectionRequest> serverReflectionInfo(
         io.grpc.stub.StreamObserver<io.grpc.reflection.v1alpha.ServerReflectionResponse> responseObserver) {
-      return asyncBidiStreamingCall(
-          getChannel().newCall(METHOD_SERVER_REFLECTION_INFO, getCallOptions()), responseObserver);
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getServerReflectionInfoMethod(), getCallOptions()), responseObserver);
     }
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service ServerReflection.
    */
-  public static final class ServerReflectionBlockingStub extends io.grpc.stub.AbstractStub<ServerReflectionBlockingStub> {
-    private ServerReflectionBlockingStub(io.grpc.Channel channel) {
-      super(channel);
+  public static final class ServerReflectionBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<ServerReflectionBlockingV2Stub> {
+    private ServerReflectionBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
     }
 
-    private ServerReflectionBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    @java.lang.Override
+    protected ServerReflectionBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ServerReflectionBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * The reflection service is structured as a bidirectional stream, ensuring
+     * all related requests go to a single server.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.reflection.v1alpha.ServerReflectionRequest, io.grpc.reflection.v1alpha.ServerReflectionResponse>
+        serverReflectionInfo() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getServerReflectionInfoMethod(), getCallOptions());
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service ServerReflection.
+   */
+  public static final class ServerReflectionBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<ServerReflectionBlockingStub> {
+    private ServerReflectionBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected ServerReflectionBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected ServerReflectionBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new ServerReflectionBlockingStub(channel, callOptions);
     }
   }
 
   /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service ServerReflection.
    */
-  public static final class ServerReflectionFutureStub extends io.grpc.stub.AbstractStub<ServerReflectionFutureStub> {
-    private ServerReflectionFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private ServerReflectionFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class ServerReflectionFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ServerReflectionFutureStub> {
+    private ServerReflectionFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected ServerReflectionFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected ServerReflectionFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new ServerReflectionFutureStub(channel, callOptions);
     }
   }
@@ -164,10 +229,10 @@ private static final class MethodHandlers<Req, Resp> implements
       io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final ServerReflectionImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(ServerReflectionImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -195,11 +260,51 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
-  private static final class ServerReflectionDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getServerReflectionInfoMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.reflection.v1alpha.ServerReflectionRequest,
+              io.grpc.reflection.v1alpha.ServerReflectionResponse>(
+                service, METHODID_SERVER_REFLECTION_INFO)))
+        .build();
+  }
+
+  private static abstract class ServerReflectionBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    ServerReflectionBaseDescriptorSupplier() {}
+
     @java.lang.Override
     public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
       return io.grpc.reflection.v1alpha.ServerReflectionProto.getDescriptor();
     }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("ServerReflection");
+    }
+  }
+
+  private static final class ServerReflectionFileDescriptorSupplier
+      extends ServerReflectionBaseDescriptorSupplier {
+    ServerReflectionFileDescriptorSupplier() {}
+  }
+
+  private static final class ServerReflectionMethodDescriptorSupplier
+      extends ServerReflectionBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    ServerReflectionMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
   }
 
   private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
@@ -211,8 +316,8 @@ public static io.grpc.ServiceDescriptor getServiceDescriptor() {
         result = serviceDescriptor;
         if (result == null) {
           serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new ServerReflectionDescriptorSupplier())
-              .addMethod(METHOD_SERVER_REFLECTION_INFO)
+              .setSchemaDescriptor(new ServerReflectionFileDescriptorSupplier())
+              .addMethod(getServerReflectionInfoMethod())
               .build();
         }
       }
diff --git a/services/src/generated/main/java/io/grpc/health/v1/HealthCheckRequest.java b/services/src/generated/main/java/io/grpc/health/v1/HealthCheckRequest.java
deleted file mode 100644
index 2ba39bf933f..00000000000
--- a/services/src/generated/main/java/io/grpc/health/v1/HealthCheckRequest.java
+++ /dev/null
@@ -1,494 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: health.proto
-
-package io.grpc.health.v1;
-
-/**
- * Protobuf type {@code grpc.health.v1.HealthCheckRequest}
- */
-public  final class HealthCheckRequest extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.health.v1.HealthCheckRequest)
-    HealthCheckRequestOrBuilder {
-  // Use HealthCheckRequest.newBuilder() to construct.
-  private HealthCheckRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private HealthCheckRequest() {
-    service_ = "";
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private HealthCheckRequest(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            java.lang.String s = input.readStringRequireUtf8();
-
-            service_ = s;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.health.v1.HealthProto.internal_static_grpc_health_v1_HealthCheckRequest_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.health.v1.HealthProto.internal_static_grpc_health_v1_HealthCheckRequest_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.health.v1.HealthCheckRequest.class, io.grpc.health.v1.HealthCheckRequest.Builder.class);
-  }
-
-  public static final int SERVICE_FIELD_NUMBER = 1;
-  private volatile java.lang.Object service_;
-  /**
-   * <code>string service = 1;</code>
-   */
-  public java.lang.String getService() {
-    java.lang.Object ref = service_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      service_ = s;
-      return s;
-    }
-  }
-  /**
-   * <code>string service = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getServiceBytes() {
-    java.lang.Object ref = service_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      service_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (!getServiceBytes().isEmpty()) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, service_);
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (!getServiceBytes().isEmpty()) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, service_);
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.health.v1.HealthCheckRequest)) {
-      return super.equals(obj);
-    }
-    io.grpc.health.v1.HealthCheckRequest other = (io.grpc.health.v1.HealthCheckRequest) obj;
-
-    boolean result = true;
-    result = result && getService()
-        .equals(other.getService());
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (37 * hash) + SERVICE_FIELD_NUMBER;
-    hash = (53 * hash) + getService().hashCode();
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.health.v1.HealthCheckRequest parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.health.v1.HealthCheckRequest parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.health.v1.HealthCheckRequest parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.health.v1.HealthCheckRequest parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.health.v1.HealthCheckRequest parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.health.v1.HealthCheckRequest parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.health.v1.HealthCheckRequest parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.health.v1.HealthCheckRequest parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.health.v1.HealthCheckRequest parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.health.v1.HealthCheckRequest parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.health.v1.HealthCheckRequest prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.health.v1.HealthCheckRequest}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.health.v1.HealthCheckRequest)
-      io.grpc.health.v1.HealthCheckRequestOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.health.v1.HealthProto.internal_static_grpc_health_v1_HealthCheckRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.health.v1.HealthProto.internal_static_grpc_health_v1_HealthCheckRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.health.v1.HealthCheckRequest.class, io.grpc.health.v1.HealthCheckRequest.Builder.class);
-    }
-
-    // Construct using io.grpc.health.v1.HealthCheckRequest.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      service_ = "";
-
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.health.v1.HealthProto.internal_static_grpc_health_v1_HealthCheckRequest_descriptor;
-    }
-
-    public io.grpc.health.v1.HealthCheckRequest getDefaultInstanceForType() {
-      return io.grpc.health.v1.HealthCheckRequest.getDefaultInstance();
-    }
-
-    public io.grpc.health.v1.HealthCheckRequest build() {
-      io.grpc.health.v1.HealthCheckRequest result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.health.v1.HealthCheckRequest buildPartial() {
-      io.grpc.health.v1.HealthCheckRequest result = new io.grpc.health.v1.HealthCheckRequest(this);
-      result.service_ = service_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.health.v1.HealthCheckRequest) {
-        return mergeFrom((io.grpc.health.v1.HealthCheckRequest)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.health.v1.HealthCheckRequest other) {
-      if (other == io.grpc.health.v1.HealthCheckRequest.getDefaultInstance()) return this;
-      if (!other.getService().isEmpty()) {
-        service_ = other.service_;
-        onChanged();
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.health.v1.HealthCheckRequest parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.health.v1.HealthCheckRequest) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-
-    private java.lang.Object service_ = "";
-    /**
-     * <code>string service = 1;</code>
-     */
-    public java.lang.String getService() {
-      java.lang.Object ref = service_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        service_ = s;
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <code>string service = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getServiceBytes() {
-      java.lang.Object ref = service_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        service_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <code>string service = 1;</code>
-     */
-    public Builder setService(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  
-      service_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>string service = 1;</code>
-     */
-    public Builder clearService() {
-      
-      service_ = getDefaultInstance().getService();
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>string service = 1;</code>
-     */
-    public Builder setServiceBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      
-      service_ = value;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.health.v1.HealthCheckRequest)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.health.v1.HealthCheckRequest)
-  private static final io.grpc.health.v1.HealthCheckRequest DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.health.v1.HealthCheckRequest();
-  }
-
-  public static io.grpc.health.v1.HealthCheckRequest getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<HealthCheckRequest>
-      PARSER = new com.google.protobuf.AbstractParser<HealthCheckRequest>() {
-    public HealthCheckRequest parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new HealthCheckRequest(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<HealthCheckRequest> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<HealthCheckRequest> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.health.v1.HealthCheckRequest getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/main/java/io/grpc/health/v1/HealthCheckRequestOrBuilder.java b/services/src/generated/main/java/io/grpc/health/v1/HealthCheckRequestOrBuilder.java
deleted file mode 100644
index 91fef898503..00000000000
--- a/services/src/generated/main/java/io/grpc/health/v1/HealthCheckRequestOrBuilder.java
+++ /dev/null
@@ -1,19 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: health.proto
-
-package io.grpc.health.v1;
-
-public interface HealthCheckRequestOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.health.v1.HealthCheckRequest)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <code>string service = 1;</code>
-   */
-  java.lang.String getService();
-  /**
-   * <code>string service = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getServiceBytes();
-}
diff --git a/services/src/generated/main/java/io/grpc/health/v1/HealthCheckResponse.java b/services/src/generated/main/java/io/grpc/health/v1/HealthCheckResponse.java
deleted file mode 100644
index bd0521c0ce3..00000000000
--- a/services/src/generated/main/java/io/grpc/health/v1/HealthCheckResponse.java
+++ /dev/null
@@ -1,557 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: health.proto
-
-package io.grpc.health.v1;
-
-/**
- * Protobuf type {@code grpc.health.v1.HealthCheckResponse}
- */
-public  final class HealthCheckResponse extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.health.v1.HealthCheckResponse)
-    HealthCheckResponseOrBuilder {
-  // Use HealthCheckResponse.newBuilder() to construct.
-  private HealthCheckResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private HealthCheckResponse() {
-    status_ = 0;
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private HealthCheckResponse(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 8: {
-            int rawValue = input.readEnum();
-
-            status_ = rawValue;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.health.v1.HealthProto.internal_static_grpc_health_v1_HealthCheckResponse_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.health.v1.HealthProto.internal_static_grpc_health_v1_HealthCheckResponse_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.health.v1.HealthCheckResponse.class, io.grpc.health.v1.HealthCheckResponse.Builder.class);
-  }
-
-  /**
-   * Protobuf enum {@code grpc.health.v1.HealthCheckResponse.ServingStatus}
-   */
-  public enum ServingStatus
-      implements com.google.protobuf.ProtocolMessageEnum {
-    /**
-     * <code>UNKNOWN = 0;</code>
-     */
-    UNKNOWN(0),
-    /**
-     * <code>SERVING = 1;</code>
-     */
-    SERVING(1),
-    /**
-     * <code>NOT_SERVING = 2;</code>
-     */
-    NOT_SERVING(2),
-    UNRECOGNIZED(-1),
-    ;
-
-    /**
-     * <code>UNKNOWN = 0;</code>
-     */
-    public static final int UNKNOWN_VALUE = 0;
-    /**
-     * <code>SERVING = 1;</code>
-     */
-    public static final int SERVING_VALUE = 1;
-    /**
-     * <code>NOT_SERVING = 2;</code>
-     */
-    public static final int NOT_SERVING_VALUE = 2;
-
-
-    public final int getNumber() {
-      if (this == UNRECOGNIZED) {
-        throw new java.lang.IllegalArgumentException(
-            "Can't get the number of an unknown enum value.");
-      }
-      return value;
-    }
-
-    /**
-     * @deprecated Use {@link #forNumber(int)} instead.
-     */
-    @java.lang.Deprecated
-    public static ServingStatus valueOf(int value) {
-      return forNumber(value);
-    }
-
-    public static ServingStatus forNumber(int value) {
-      switch (value) {
-        case 0: return UNKNOWN;
-        case 1: return SERVING;
-        case 2: return NOT_SERVING;
-        default: return null;
-      }
-    }
-
-    public static com.google.protobuf.Internal.EnumLiteMap<ServingStatus>
-        internalGetValueMap() {
-      return internalValueMap;
-    }
-    private static final com.google.protobuf.Internal.EnumLiteMap<
-        ServingStatus> internalValueMap =
-          new com.google.protobuf.Internal.EnumLiteMap<ServingStatus>() {
-            public ServingStatus findValueByNumber(int number) {
-              return ServingStatus.forNumber(number);
-            }
-          };
-
-    public final com.google.protobuf.Descriptors.EnumValueDescriptor
-        getValueDescriptor() {
-      return getDescriptor().getValues().get(ordinal());
-    }
-    public final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptorForType() {
-      return getDescriptor();
-    }
-    public static final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptor() {
-      return io.grpc.health.v1.HealthCheckResponse.getDescriptor().getEnumTypes().get(0);
-    }
-
-    private static final ServingStatus[] VALUES = values();
-
-    public static ServingStatus valueOf(
-        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
-      if (desc.getType() != getDescriptor()) {
-        throw new java.lang.IllegalArgumentException(
-          "EnumValueDescriptor is not for this type.");
-      }
-      if (desc.getIndex() == -1) {
-        return UNRECOGNIZED;
-      }
-      return VALUES[desc.getIndex()];
-    }
-
-    private final int value;
-
-    private ServingStatus(int value) {
-      this.value = value;
-    }
-
-    // @@protoc_insertion_point(enum_scope:grpc.health.v1.HealthCheckResponse.ServingStatus)
-  }
-
-  public static final int STATUS_FIELD_NUMBER = 1;
-  private int status_;
-  /**
-   * <code>.grpc.health.v1.HealthCheckResponse.ServingStatus status = 1;</code>
-   */
-  public int getStatusValue() {
-    return status_;
-  }
-  /**
-   * <code>.grpc.health.v1.HealthCheckResponse.ServingStatus status = 1;</code>
-   */
-  public io.grpc.health.v1.HealthCheckResponse.ServingStatus getStatus() {
-    io.grpc.health.v1.HealthCheckResponse.ServingStatus result = io.grpc.health.v1.HealthCheckResponse.ServingStatus.valueOf(status_);
-    return result == null ? io.grpc.health.v1.HealthCheckResponse.ServingStatus.UNRECOGNIZED : result;
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (status_ != io.grpc.health.v1.HealthCheckResponse.ServingStatus.UNKNOWN.getNumber()) {
-      output.writeEnum(1, status_);
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (status_ != io.grpc.health.v1.HealthCheckResponse.ServingStatus.UNKNOWN.getNumber()) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeEnumSize(1, status_);
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.health.v1.HealthCheckResponse)) {
-      return super.equals(obj);
-    }
-    io.grpc.health.v1.HealthCheckResponse other = (io.grpc.health.v1.HealthCheckResponse) obj;
-
-    boolean result = true;
-    result = result && status_ == other.status_;
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (37 * hash) + STATUS_FIELD_NUMBER;
-    hash = (53 * hash) + status_;
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.health.v1.HealthCheckResponse parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.health.v1.HealthCheckResponse parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.health.v1.HealthCheckResponse parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.health.v1.HealthCheckResponse parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.health.v1.HealthCheckResponse parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.health.v1.HealthCheckResponse parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.health.v1.HealthCheckResponse parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.health.v1.HealthCheckResponse parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.health.v1.HealthCheckResponse parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.health.v1.HealthCheckResponse parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.health.v1.HealthCheckResponse prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.health.v1.HealthCheckResponse}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.health.v1.HealthCheckResponse)
-      io.grpc.health.v1.HealthCheckResponseOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.health.v1.HealthProto.internal_static_grpc_health_v1_HealthCheckResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.health.v1.HealthProto.internal_static_grpc_health_v1_HealthCheckResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.health.v1.HealthCheckResponse.class, io.grpc.health.v1.HealthCheckResponse.Builder.class);
-    }
-
-    // Construct using io.grpc.health.v1.HealthCheckResponse.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      status_ = 0;
-
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.health.v1.HealthProto.internal_static_grpc_health_v1_HealthCheckResponse_descriptor;
-    }
-
-    public io.grpc.health.v1.HealthCheckResponse getDefaultInstanceForType() {
-      return io.grpc.health.v1.HealthCheckResponse.getDefaultInstance();
-    }
-
-    public io.grpc.health.v1.HealthCheckResponse build() {
-      io.grpc.health.v1.HealthCheckResponse result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.health.v1.HealthCheckResponse buildPartial() {
-      io.grpc.health.v1.HealthCheckResponse result = new io.grpc.health.v1.HealthCheckResponse(this);
-      result.status_ = status_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.health.v1.HealthCheckResponse) {
-        return mergeFrom((io.grpc.health.v1.HealthCheckResponse)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.health.v1.HealthCheckResponse other) {
-      if (other == io.grpc.health.v1.HealthCheckResponse.getDefaultInstance()) return this;
-      if (other.status_ != 0) {
-        setStatusValue(other.getStatusValue());
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.health.v1.HealthCheckResponse parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.health.v1.HealthCheckResponse) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-
-    private int status_ = 0;
-    /**
-     * <code>.grpc.health.v1.HealthCheckResponse.ServingStatus status = 1;</code>
-     */
-    public int getStatusValue() {
-      return status_;
-    }
-    /**
-     * <code>.grpc.health.v1.HealthCheckResponse.ServingStatus status = 1;</code>
-     */
-    public Builder setStatusValue(int value) {
-      status_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>.grpc.health.v1.HealthCheckResponse.ServingStatus status = 1;</code>
-     */
-    public io.grpc.health.v1.HealthCheckResponse.ServingStatus getStatus() {
-      io.grpc.health.v1.HealthCheckResponse.ServingStatus result = io.grpc.health.v1.HealthCheckResponse.ServingStatus.valueOf(status_);
-      return result == null ? io.grpc.health.v1.HealthCheckResponse.ServingStatus.UNRECOGNIZED : result;
-    }
-    /**
-     * <code>.grpc.health.v1.HealthCheckResponse.ServingStatus status = 1;</code>
-     */
-    public Builder setStatus(io.grpc.health.v1.HealthCheckResponse.ServingStatus value) {
-      if (value == null) {
-        throw new NullPointerException();
-      }
-      
-      status_ = value.getNumber();
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>.grpc.health.v1.HealthCheckResponse.ServingStatus status = 1;</code>
-     */
-    public Builder clearStatus() {
-      
-      status_ = 0;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.health.v1.HealthCheckResponse)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.health.v1.HealthCheckResponse)
-  private static final io.grpc.health.v1.HealthCheckResponse DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.health.v1.HealthCheckResponse();
-  }
-
-  public static io.grpc.health.v1.HealthCheckResponse getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<HealthCheckResponse>
-      PARSER = new com.google.protobuf.AbstractParser<HealthCheckResponse>() {
-    public HealthCheckResponse parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new HealthCheckResponse(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<HealthCheckResponse> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<HealthCheckResponse> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.health.v1.HealthCheckResponse getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/main/java/io/grpc/health/v1/HealthCheckResponseOrBuilder.java b/services/src/generated/main/java/io/grpc/health/v1/HealthCheckResponseOrBuilder.java
deleted file mode 100644
index a748b06842d..00000000000
--- a/services/src/generated/main/java/io/grpc/health/v1/HealthCheckResponseOrBuilder.java
+++ /dev/null
@@ -1,18 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: health.proto
-
-package io.grpc.health.v1;
-
-public interface HealthCheckResponseOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.health.v1.HealthCheckResponse)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <code>.grpc.health.v1.HealthCheckResponse.ServingStatus status = 1;</code>
-   */
-  int getStatusValue();
-  /**
-   * <code>.grpc.health.v1.HealthCheckResponse.ServingStatus status = 1;</code>
-   */
-  io.grpc.health.v1.HealthCheckResponse.ServingStatus getStatus();
-}
diff --git a/services/src/generated/main/java/io/grpc/health/v1/HealthProto.java b/services/src/generated/main/java/io/grpc/health/v1/HealthProto.java
deleted file mode 100644
index 09ce4d0c6c6..00000000000
--- a/services/src/generated/main/java/io/grpc/health/v1/HealthProto.java
+++ /dev/null
@@ -1,74 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: health.proto
-
-package io.grpc.health.v1;
-
-public final class HealthProto {
-  private HealthProto() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_health_v1_HealthCheckRequest_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_health_v1_HealthCheckRequest_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_health_v1_HealthCheckResponse_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_health_v1_HealthCheckResponse_fieldAccessorTable;
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n\014health.proto\022\016grpc.health.v1\"%\n\022Health" +
-      "CheckRequest\022\017\n\007service\030\001 \001(\t\"\224\001\n\023Health" +
-      "CheckResponse\022A\n\006status\030\001 \001(\01621.grpc.hea" +
-      "lth.v1.HealthCheckResponse.ServingStatus" +
-      "\":\n\rServingStatus\022\013\n\007UNKNOWN\020\000\022\013\n\007SERVIN" +
-      "G\020\001\022\017\n\013NOT_SERVING\020\0022Z\n\006Health\022P\n\005Check\022" +
-      "\".grpc.health.v1.HealthCheckRequest\032#.gr" +
-      "pc.health.v1.HealthCheckResponseB3\n\021io.g" +
-      "rpc.health.v1B\013HealthProtoP\001\252\002\016Grpc.Heal" +
-      "th.V1b\006proto3"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-        }, assigner);
-    internal_static_grpc_health_v1_HealthCheckRequest_descriptor =
-      getDescriptor().getMessageTypes().get(0);
-    internal_static_grpc_health_v1_HealthCheckRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_health_v1_HealthCheckRequest_descriptor,
-        new java.lang.String[] { "Service", });
-    internal_static_grpc_health_v1_HealthCheckResponse_descriptor =
-      getDescriptor().getMessageTypes().get(1);
-    internal_static_grpc_health_v1_HealthCheckResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_health_v1_HealthCheckResponse_descriptor,
-        new java.lang.String[] { "Status", });
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ErrorResponse.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ErrorResponse.java
deleted file mode 100644
index 467492dc575..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ErrorResponse.java
+++ /dev/null
@@ -1,576 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-/**
- * <pre>
- * The error code and error message sent by the server when an error occurs.
- * </pre>
- *
- * Protobuf type {@code grpc.reflection.v1alpha.ErrorResponse}
- */
-public  final class ErrorResponse extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.v1alpha.ErrorResponse)
-    ErrorResponseOrBuilder {
-  // Use ErrorResponse.newBuilder() to construct.
-  private ErrorResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private ErrorResponse() {
-    errorCode_ = 0;
-    errorMessage_ = "";
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private ErrorResponse(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 8: {
-
-            errorCode_ = input.readInt32();
-            break;
-          }
-          case 18: {
-            java.lang.String s = input.readStringRequireUtf8();
-
-            errorMessage_ = s;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ErrorResponse_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ErrorResponse_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.v1alpha.ErrorResponse.class, io.grpc.reflection.v1alpha.ErrorResponse.Builder.class);
-  }
-
-  public static final int ERROR_CODE_FIELD_NUMBER = 1;
-  private int errorCode_;
-  /**
-   * <pre>
-   * This field uses the error codes defined in grpc::StatusCode.
-   * </pre>
-   *
-   * <code>int32 error_code = 1;</code>
-   */
-  public int getErrorCode() {
-    return errorCode_;
-  }
-
-  public static final int ERROR_MESSAGE_FIELD_NUMBER = 2;
-  private volatile java.lang.Object errorMessage_;
-  /**
-   * <code>string error_message = 2;</code>
-   */
-  public java.lang.String getErrorMessage() {
-    java.lang.Object ref = errorMessage_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      errorMessage_ = s;
-      return s;
-    }
-  }
-  /**
-   * <code>string error_message = 2;</code>
-   */
-  public com.google.protobuf.ByteString
-      getErrorMessageBytes() {
-    java.lang.Object ref = errorMessage_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      errorMessage_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (errorCode_ != 0) {
-      output.writeInt32(1, errorCode_);
-    }
-    if (!getErrorMessageBytes().isEmpty()) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 2, errorMessage_);
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (errorCode_ != 0) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeInt32Size(1, errorCode_);
-    }
-    if (!getErrorMessageBytes().isEmpty()) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, errorMessage_);
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.v1alpha.ErrorResponse)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.v1alpha.ErrorResponse other = (io.grpc.reflection.v1alpha.ErrorResponse) obj;
-
-    boolean result = true;
-    result = result && (getErrorCode()
-        == other.getErrorCode());
-    result = result && getErrorMessage()
-        .equals(other.getErrorMessage());
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (37 * hash) + ERROR_CODE_FIELD_NUMBER;
-    hash = (53 * hash) + getErrorCode();
-    hash = (37 * hash) + ERROR_MESSAGE_FIELD_NUMBER;
-    hash = (53 * hash) + getErrorMessage().hashCode();
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.v1alpha.ErrorResponse parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ErrorResponse parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ErrorResponse parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ErrorResponse parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ErrorResponse parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ErrorResponse parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ErrorResponse parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ErrorResponse parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ErrorResponse parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ErrorResponse parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.v1alpha.ErrorResponse prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * <pre>
-   * The error code and error message sent by the server when an error occurs.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.reflection.v1alpha.ErrorResponse}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.v1alpha.ErrorResponse)
-      io.grpc.reflection.v1alpha.ErrorResponseOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ErrorResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ErrorResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.v1alpha.ErrorResponse.class, io.grpc.reflection.v1alpha.ErrorResponse.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.v1alpha.ErrorResponse.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      errorCode_ = 0;
-
-      errorMessage_ = "";
-
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ErrorResponse_descriptor;
-    }
-
-    public io.grpc.reflection.v1alpha.ErrorResponse getDefaultInstanceForType() {
-      return io.grpc.reflection.v1alpha.ErrorResponse.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.v1alpha.ErrorResponse build() {
-      io.grpc.reflection.v1alpha.ErrorResponse result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.v1alpha.ErrorResponse buildPartial() {
-      io.grpc.reflection.v1alpha.ErrorResponse result = new io.grpc.reflection.v1alpha.ErrorResponse(this);
-      result.errorCode_ = errorCode_;
-      result.errorMessage_ = errorMessage_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.v1alpha.ErrorResponse) {
-        return mergeFrom((io.grpc.reflection.v1alpha.ErrorResponse)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.v1alpha.ErrorResponse other) {
-      if (other == io.grpc.reflection.v1alpha.ErrorResponse.getDefaultInstance()) return this;
-      if (other.getErrorCode() != 0) {
-        setErrorCode(other.getErrorCode());
-      }
-      if (!other.getErrorMessage().isEmpty()) {
-        errorMessage_ = other.errorMessage_;
-        onChanged();
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.v1alpha.ErrorResponse parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.v1alpha.ErrorResponse) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-
-    private int errorCode_ ;
-    /**
-     * <pre>
-     * This field uses the error codes defined in grpc::StatusCode.
-     * </pre>
-     *
-     * <code>int32 error_code = 1;</code>
-     */
-    public int getErrorCode() {
-      return errorCode_;
-    }
-    /**
-     * <pre>
-     * This field uses the error codes defined in grpc::StatusCode.
-     * </pre>
-     *
-     * <code>int32 error_code = 1;</code>
-     */
-    public Builder setErrorCode(int value) {
-      
-      errorCode_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * This field uses the error codes defined in grpc::StatusCode.
-     * </pre>
-     *
-     * <code>int32 error_code = 1;</code>
-     */
-    public Builder clearErrorCode() {
-      
-      errorCode_ = 0;
-      onChanged();
-      return this;
-    }
-
-    private java.lang.Object errorMessage_ = "";
-    /**
-     * <code>string error_message = 2;</code>
-     */
-    public java.lang.String getErrorMessage() {
-      java.lang.Object ref = errorMessage_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        errorMessage_ = s;
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <code>string error_message = 2;</code>
-     */
-    public com.google.protobuf.ByteString
-        getErrorMessageBytes() {
-      java.lang.Object ref = errorMessage_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        errorMessage_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <code>string error_message = 2;</code>
-     */
-    public Builder setErrorMessage(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  
-      errorMessage_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>string error_message = 2;</code>
-     */
-    public Builder clearErrorMessage() {
-      
-      errorMessage_ = getDefaultInstance().getErrorMessage();
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>string error_message = 2;</code>
-     */
-    public Builder setErrorMessageBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      
-      errorMessage_ = value;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.v1alpha.ErrorResponse)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.v1alpha.ErrorResponse)
-  private static final io.grpc.reflection.v1alpha.ErrorResponse DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.v1alpha.ErrorResponse();
-  }
-
-  public static io.grpc.reflection.v1alpha.ErrorResponse getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<ErrorResponse>
-      PARSER = new com.google.protobuf.AbstractParser<ErrorResponse>() {
-    public ErrorResponse parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new ErrorResponse(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<ErrorResponse> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<ErrorResponse> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.v1alpha.ErrorResponse getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ErrorResponseOrBuilder.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ErrorResponseOrBuilder.java
deleted file mode 100644
index f5316865158..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ErrorResponseOrBuilder.java
+++ /dev/null
@@ -1,28 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-public interface ErrorResponseOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.v1alpha.ErrorResponse)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <pre>
-   * This field uses the error codes defined in grpc::StatusCode.
-   * </pre>
-   *
-   * <code>int32 error_code = 1;</code>
-   */
-  int getErrorCode();
-
-  /**
-   * <code>string error_message = 2;</code>
-   */
-  java.lang.String getErrorMessage();
-  /**
-   * <code>string error_message = 2;</code>
-   */
-  com.google.protobuf.ByteString
-      getErrorMessageBytes();
-}
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ExtensionNumberResponse.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ExtensionNumberResponse.java
deleted file mode 100644
index 4e60914ead7..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ExtensionNumberResponse.java
+++ /dev/null
@@ -1,703 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-/**
- * <pre>
- * A list of extension numbers sent by the server answering
- * all_extension_numbers_of_type request.
- * </pre>
- *
- * Protobuf type {@code grpc.reflection.v1alpha.ExtensionNumberResponse}
- */
-public  final class ExtensionNumberResponse extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.v1alpha.ExtensionNumberResponse)
-    ExtensionNumberResponseOrBuilder {
-  // Use ExtensionNumberResponse.newBuilder() to construct.
-  private ExtensionNumberResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private ExtensionNumberResponse() {
-    baseTypeName_ = "";
-    extensionNumber_ = java.util.Collections.emptyList();
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private ExtensionNumberResponse(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            java.lang.String s = input.readStringRequireUtf8();
-
-            baseTypeName_ = s;
-            break;
-          }
-          case 16: {
-            if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
-              extensionNumber_ = new java.util.ArrayList<java.lang.Integer>();
-              mutable_bitField0_ |= 0x00000002;
-            }
-            extensionNumber_.add(input.readInt32());
-            break;
-          }
-          case 18: {
-            int length = input.readRawVarint32();
-            int limit = input.pushLimit(length);
-            if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) {
-              extensionNumber_ = new java.util.ArrayList<java.lang.Integer>();
-              mutable_bitField0_ |= 0x00000002;
-            }
-            while (input.getBytesUntilLimit() > 0) {
-              extensionNumber_.add(input.readInt32());
-            }
-            input.popLimit(limit);
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
-        extensionNumber_ = java.util.Collections.unmodifiableList(extensionNumber_);
-      }
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ExtensionNumberResponse_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ExtensionNumberResponse_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.v1alpha.ExtensionNumberResponse.class, io.grpc.reflection.v1alpha.ExtensionNumberResponse.Builder.class);
-  }
-
-  private int bitField0_;
-  public static final int BASE_TYPE_NAME_FIELD_NUMBER = 1;
-  private volatile java.lang.Object baseTypeName_;
-  /**
-   * <pre>
-   * Full name of the base type, including the package name. The format
-   * is &lt;package&gt;.&lt;type&gt;
-   * </pre>
-   *
-   * <code>string base_type_name = 1;</code>
-   */
-  public java.lang.String getBaseTypeName() {
-    java.lang.Object ref = baseTypeName_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      baseTypeName_ = s;
-      return s;
-    }
-  }
-  /**
-   * <pre>
-   * Full name of the base type, including the package name. The format
-   * is &lt;package&gt;.&lt;type&gt;
-   * </pre>
-   *
-   * <code>string base_type_name = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getBaseTypeNameBytes() {
-    java.lang.Object ref = baseTypeName_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      baseTypeName_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  public static final int EXTENSION_NUMBER_FIELD_NUMBER = 2;
-  private java.util.List<java.lang.Integer> extensionNumber_;
-  /**
-   * <code>repeated int32 extension_number = 2;</code>
-   */
-  public java.util.List<java.lang.Integer>
-      getExtensionNumberList() {
-    return extensionNumber_;
-  }
-  /**
-   * <code>repeated int32 extension_number = 2;</code>
-   */
-  public int getExtensionNumberCount() {
-    return extensionNumber_.size();
-  }
-  /**
-   * <code>repeated int32 extension_number = 2;</code>
-   */
-  public int getExtensionNumber(int index) {
-    return extensionNumber_.get(index);
-  }
-  private int extensionNumberMemoizedSerializedSize = -1;
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    getSerializedSize();
-    if (!getBaseTypeNameBytes().isEmpty()) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, baseTypeName_);
-    }
-    if (getExtensionNumberList().size() > 0) {
-      output.writeUInt32NoTag(18);
-      output.writeUInt32NoTag(extensionNumberMemoizedSerializedSize);
-    }
-    for (int i = 0; i < extensionNumber_.size(); i++) {
-      output.writeInt32NoTag(extensionNumber_.get(i));
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (!getBaseTypeNameBytes().isEmpty()) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, baseTypeName_);
-    }
-    {
-      int dataSize = 0;
-      for (int i = 0; i < extensionNumber_.size(); i++) {
-        dataSize += com.google.protobuf.CodedOutputStream
-          .computeInt32SizeNoTag(extensionNumber_.get(i));
-      }
-      size += dataSize;
-      if (!getExtensionNumberList().isEmpty()) {
-        size += 1;
-        size += com.google.protobuf.CodedOutputStream
-            .computeInt32SizeNoTag(dataSize);
-      }
-      extensionNumberMemoizedSerializedSize = dataSize;
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.v1alpha.ExtensionNumberResponse)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.v1alpha.ExtensionNumberResponse other = (io.grpc.reflection.v1alpha.ExtensionNumberResponse) obj;
-
-    boolean result = true;
-    result = result && getBaseTypeName()
-        .equals(other.getBaseTypeName());
-    result = result && getExtensionNumberList()
-        .equals(other.getExtensionNumberList());
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (37 * hash) + BASE_TYPE_NAME_FIELD_NUMBER;
-    hash = (53 * hash) + getBaseTypeName().hashCode();
-    if (getExtensionNumberCount() > 0) {
-      hash = (37 * hash) + EXTENSION_NUMBER_FIELD_NUMBER;
-      hash = (53 * hash) + getExtensionNumberList().hashCode();
-    }
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.v1alpha.ExtensionNumberResponse parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionNumberResponse parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionNumberResponse parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionNumberResponse parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionNumberResponse parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionNumberResponse parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionNumberResponse parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionNumberResponse parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionNumberResponse parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionNumberResponse parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.v1alpha.ExtensionNumberResponse prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * <pre>
-   * A list of extension numbers sent by the server answering
-   * all_extension_numbers_of_type request.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.reflection.v1alpha.ExtensionNumberResponse}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.v1alpha.ExtensionNumberResponse)
-      io.grpc.reflection.v1alpha.ExtensionNumberResponseOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ExtensionNumberResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ExtensionNumberResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.v1alpha.ExtensionNumberResponse.class, io.grpc.reflection.v1alpha.ExtensionNumberResponse.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.v1alpha.ExtensionNumberResponse.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      baseTypeName_ = "";
-
-      extensionNumber_ = java.util.Collections.emptyList();
-      bitField0_ = (bitField0_ & ~0x00000002);
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ExtensionNumberResponse_descriptor;
-    }
-
-    public io.grpc.reflection.v1alpha.ExtensionNumberResponse getDefaultInstanceForType() {
-      return io.grpc.reflection.v1alpha.ExtensionNumberResponse.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.v1alpha.ExtensionNumberResponse build() {
-      io.grpc.reflection.v1alpha.ExtensionNumberResponse result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.v1alpha.ExtensionNumberResponse buildPartial() {
-      io.grpc.reflection.v1alpha.ExtensionNumberResponse result = new io.grpc.reflection.v1alpha.ExtensionNumberResponse(this);
-      int from_bitField0_ = bitField0_;
-      int to_bitField0_ = 0;
-      result.baseTypeName_ = baseTypeName_;
-      if (((bitField0_ & 0x00000002) == 0x00000002)) {
-        extensionNumber_ = java.util.Collections.unmodifiableList(extensionNumber_);
-        bitField0_ = (bitField0_ & ~0x00000002);
-      }
-      result.extensionNumber_ = extensionNumber_;
-      result.bitField0_ = to_bitField0_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.v1alpha.ExtensionNumberResponse) {
-        return mergeFrom((io.grpc.reflection.v1alpha.ExtensionNumberResponse)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.v1alpha.ExtensionNumberResponse other) {
-      if (other == io.grpc.reflection.v1alpha.ExtensionNumberResponse.getDefaultInstance()) return this;
-      if (!other.getBaseTypeName().isEmpty()) {
-        baseTypeName_ = other.baseTypeName_;
-        onChanged();
-      }
-      if (!other.extensionNumber_.isEmpty()) {
-        if (extensionNumber_.isEmpty()) {
-          extensionNumber_ = other.extensionNumber_;
-          bitField0_ = (bitField0_ & ~0x00000002);
-        } else {
-          ensureExtensionNumberIsMutable();
-          extensionNumber_.addAll(other.extensionNumber_);
-        }
-        onChanged();
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.v1alpha.ExtensionNumberResponse parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.v1alpha.ExtensionNumberResponse) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int bitField0_;
-
-    private java.lang.Object baseTypeName_ = "";
-    /**
-     * <pre>
-     * Full name of the base type, including the package name. The format
-     * is &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string base_type_name = 1;</code>
-     */
-    public java.lang.String getBaseTypeName() {
-      java.lang.Object ref = baseTypeName_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        baseTypeName_ = s;
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Full name of the base type, including the package name. The format
-     * is &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string base_type_name = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getBaseTypeNameBytes() {
-      java.lang.Object ref = baseTypeName_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        baseTypeName_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Full name of the base type, including the package name. The format
-     * is &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string base_type_name = 1;</code>
-     */
-    public Builder setBaseTypeName(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  
-      baseTypeName_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Full name of the base type, including the package name. The format
-     * is &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string base_type_name = 1;</code>
-     */
-    public Builder clearBaseTypeName() {
-      
-      baseTypeName_ = getDefaultInstance().getBaseTypeName();
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Full name of the base type, including the package name. The format
-     * is &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string base_type_name = 1;</code>
-     */
-    public Builder setBaseTypeNameBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      
-      baseTypeName_ = value;
-      onChanged();
-      return this;
-    }
-
-    private java.util.List<java.lang.Integer> extensionNumber_ = java.util.Collections.emptyList();
-    private void ensureExtensionNumberIsMutable() {
-      if (!((bitField0_ & 0x00000002) == 0x00000002)) {
-        extensionNumber_ = new java.util.ArrayList<java.lang.Integer>(extensionNumber_);
-        bitField0_ |= 0x00000002;
-       }
-    }
-    /**
-     * <code>repeated int32 extension_number = 2;</code>
-     */
-    public java.util.List<java.lang.Integer>
-        getExtensionNumberList() {
-      return java.util.Collections.unmodifiableList(extensionNumber_);
-    }
-    /**
-     * <code>repeated int32 extension_number = 2;</code>
-     */
-    public int getExtensionNumberCount() {
-      return extensionNumber_.size();
-    }
-    /**
-     * <code>repeated int32 extension_number = 2;</code>
-     */
-    public int getExtensionNumber(int index) {
-      return extensionNumber_.get(index);
-    }
-    /**
-     * <code>repeated int32 extension_number = 2;</code>
-     */
-    public Builder setExtensionNumber(
-        int index, int value) {
-      ensureExtensionNumberIsMutable();
-      extensionNumber_.set(index, value);
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>repeated int32 extension_number = 2;</code>
-     */
-    public Builder addExtensionNumber(int value) {
-      ensureExtensionNumberIsMutable();
-      extensionNumber_.add(value);
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>repeated int32 extension_number = 2;</code>
-     */
-    public Builder addAllExtensionNumber(
-        java.lang.Iterable<? extends java.lang.Integer> values) {
-      ensureExtensionNumberIsMutable();
-      com.google.protobuf.AbstractMessageLite.Builder.addAll(
-          values, extensionNumber_);
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>repeated int32 extension_number = 2;</code>
-     */
-    public Builder clearExtensionNumber() {
-      extensionNumber_ = java.util.Collections.emptyList();
-      bitField0_ = (bitField0_ & ~0x00000002);
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.v1alpha.ExtensionNumberResponse)
-  private static final io.grpc.reflection.v1alpha.ExtensionNumberResponse DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.v1alpha.ExtensionNumberResponse();
-  }
-
-  public static io.grpc.reflection.v1alpha.ExtensionNumberResponse getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<ExtensionNumberResponse>
-      PARSER = new com.google.protobuf.AbstractParser<ExtensionNumberResponse>() {
-    public ExtensionNumberResponse parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new ExtensionNumberResponse(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<ExtensionNumberResponse> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<ExtensionNumberResponse> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.v1alpha.ExtensionNumberResponse getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ExtensionNumberResponseOrBuilder.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ExtensionNumberResponseOrBuilder.java
deleted file mode 100644
index a9795793a3f..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ExtensionNumberResponseOrBuilder.java
+++ /dev/null
@@ -1,42 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-public interface ExtensionNumberResponseOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.v1alpha.ExtensionNumberResponse)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <pre>
-   * Full name of the base type, including the package name. The format
-   * is &lt;package&gt;.&lt;type&gt;
-   * </pre>
-   *
-   * <code>string base_type_name = 1;</code>
-   */
-  java.lang.String getBaseTypeName();
-  /**
-   * <pre>
-   * Full name of the base type, including the package name. The format
-   * is &lt;package&gt;.&lt;type&gt;
-   * </pre>
-   *
-   * <code>string base_type_name = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getBaseTypeNameBytes();
-
-  /**
-   * <code>repeated int32 extension_number = 2;</code>
-   */
-  java.util.List<java.lang.Integer> getExtensionNumberList();
-  /**
-   * <code>repeated int32 extension_number = 2;</code>
-   */
-  int getExtensionNumberCount();
-  /**
-   * <code>repeated int32 extension_number = 2;</code>
-   */
-  int getExtensionNumber(int index);
-}
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ExtensionRequest.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ExtensionRequest.java
deleted file mode 100644
index b299e995297..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ExtensionRequest.java
+++ /dev/null
@@ -1,590 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-/**
- * <pre>
- * The type name and extension number sent by the client when requesting
- * file_containing_extension.
- * </pre>
- *
- * Protobuf type {@code grpc.reflection.v1alpha.ExtensionRequest}
- */
-public  final class ExtensionRequest extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.v1alpha.ExtensionRequest)
-    ExtensionRequestOrBuilder {
-  // Use ExtensionRequest.newBuilder() to construct.
-  private ExtensionRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private ExtensionRequest() {
-    containingType_ = "";
-    extensionNumber_ = 0;
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private ExtensionRequest(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            java.lang.String s = input.readStringRequireUtf8();
-
-            containingType_ = s;
-            break;
-          }
-          case 16: {
-
-            extensionNumber_ = input.readInt32();
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ExtensionRequest_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ExtensionRequest_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.v1alpha.ExtensionRequest.class, io.grpc.reflection.v1alpha.ExtensionRequest.Builder.class);
-  }
-
-  public static final int CONTAINING_TYPE_FIELD_NUMBER = 1;
-  private volatile java.lang.Object containingType_;
-  /**
-   * <pre>
-   * Fully-qualified type name. The format should be &lt;package&gt;.&lt;type&gt;
-   * </pre>
-   *
-   * <code>string containing_type = 1;</code>
-   */
-  public java.lang.String getContainingType() {
-    java.lang.Object ref = containingType_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      containingType_ = s;
-      return s;
-    }
-  }
-  /**
-   * <pre>
-   * Fully-qualified type name. The format should be &lt;package&gt;.&lt;type&gt;
-   * </pre>
-   *
-   * <code>string containing_type = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getContainingTypeBytes() {
-    java.lang.Object ref = containingType_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      containingType_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  public static final int EXTENSION_NUMBER_FIELD_NUMBER = 2;
-  private int extensionNumber_;
-  /**
-   * <code>int32 extension_number = 2;</code>
-   */
-  public int getExtensionNumber() {
-    return extensionNumber_;
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (!getContainingTypeBytes().isEmpty()) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, containingType_);
-    }
-    if (extensionNumber_ != 0) {
-      output.writeInt32(2, extensionNumber_);
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (!getContainingTypeBytes().isEmpty()) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, containingType_);
-    }
-    if (extensionNumber_ != 0) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeInt32Size(2, extensionNumber_);
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.v1alpha.ExtensionRequest)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.v1alpha.ExtensionRequest other = (io.grpc.reflection.v1alpha.ExtensionRequest) obj;
-
-    boolean result = true;
-    result = result && getContainingType()
-        .equals(other.getContainingType());
-    result = result && (getExtensionNumber()
-        == other.getExtensionNumber());
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (37 * hash) + CONTAINING_TYPE_FIELD_NUMBER;
-    hash = (53 * hash) + getContainingType().hashCode();
-    hash = (37 * hash) + EXTENSION_NUMBER_FIELD_NUMBER;
-    hash = (53 * hash) + getExtensionNumber();
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.v1alpha.ExtensionRequest parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionRequest parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionRequest parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionRequest parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionRequest parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionRequest parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionRequest parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionRequest parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionRequest parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ExtensionRequest parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.v1alpha.ExtensionRequest prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * <pre>
-   * The type name and extension number sent by the client when requesting
-   * file_containing_extension.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.reflection.v1alpha.ExtensionRequest}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.v1alpha.ExtensionRequest)
-      io.grpc.reflection.v1alpha.ExtensionRequestOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ExtensionRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ExtensionRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.v1alpha.ExtensionRequest.class, io.grpc.reflection.v1alpha.ExtensionRequest.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.v1alpha.ExtensionRequest.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      containingType_ = "";
-
-      extensionNumber_ = 0;
-
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ExtensionRequest_descriptor;
-    }
-
-    public io.grpc.reflection.v1alpha.ExtensionRequest getDefaultInstanceForType() {
-      return io.grpc.reflection.v1alpha.ExtensionRequest.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.v1alpha.ExtensionRequest build() {
-      io.grpc.reflection.v1alpha.ExtensionRequest result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.v1alpha.ExtensionRequest buildPartial() {
-      io.grpc.reflection.v1alpha.ExtensionRequest result = new io.grpc.reflection.v1alpha.ExtensionRequest(this);
-      result.containingType_ = containingType_;
-      result.extensionNumber_ = extensionNumber_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.v1alpha.ExtensionRequest) {
-        return mergeFrom((io.grpc.reflection.v1alpha.ExtensionRequest)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.v1alpha.ExtensionRequest other) {
-      if (other == io.grpc.reflection.v1alpha.ExtensionRequest.getDefaultInstance()) return this;
-      if (!other.getContainingType().isEmpty()) {
-        containingType_ = other.containingType_;
-        onChanged();
-      }
-      if (other.getExtensionNumber() != 0) {
-        setExtensionNumber(other.getExtensionNumber());
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.v1alpha.ExtensionRequest parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.v1alpha.ExtensionRequest) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-
-    private java.lang.Object containingType_ = "";
-    /**
-     * <pre>
-     * Fully-qualified type name. The format should be &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string containing_type = 1;</code>
-     */
-    public java.lang.String getContainingType() {
-      java.lang.Object ref = containingType_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        containingType_ = s;
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Fully-qualified type name. The format should be &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string containing_type = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getContainingTypeBytes() {
-      java.lang.Object ref = containingType_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        containingType_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Fully-qualified type name. The format should be &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string containing_type = 1;</code>
-     */
-    public Builder setContainingType(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  
-      containingType_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Fully-qualified type name. The format should be &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string containing_type = 1;</code>
-     */
-    public Builder clearContainingType() {
-      
-      containingType_ = getDefaultInstance().getContainingType();
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Fully-qualified type name. The format should be &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string containing_type = 1;</code>
-     */
-    public Builder setContainingTypeBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      
-      containingType_ = value;
-      onChanged();
-      return this;
-    }
-
-    private int extensionNumber_ ;
-    /**
-     * <code>int32 extension_number = 2;</code>
-     */
-    public int getExtensionNumber() {
-      return extensionNumber_;
-    }
-    /**
-     * <code>int32 extension_number = 2;</code>
-     */
-    public Builder setExtensionNumber(int value) {
-      
-      extensionNumber_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>int32 extension_number = 2;</code>
-     */
-    public Builder clearExtensionNumber() {
-      
-      extensionNumber_ = 0;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.v1alpha.ExtensionRequest)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.v1alpha.ExtensionRequest)
-  private static final io.grpc.reflection.v1alpha.ExtensionRequest DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.v1alpha.ExtensionRequest();
-  }
-
-  public static io.grpc.reflection.v1alpha.ExtensionRequest getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<ExtensionRequest>
-      PARSER = new com.google.protobuf.AbstractParser<ExtensionRequest>() {
-    public ExtensionRequest parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new ExtensionRequest(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<ExtensionRequest> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<ExtensionRequest> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.v1alpha.ExtensionRequest getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ExtensionRequestOrBuilder.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ExtensionRequestOrBuilder.java
deleted file mode 100644
index d49e3d9cac2..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ExtensionRequestOrBuilder.java
+++ /dev/null
@@ -1,32 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-public interface ExtensionRequestOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.v1alpha.ExtensionRequest)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <pre>
-   * Fully-qualified type name. The format should be &lt;package&gt;.&lt;type&gt;
-   * </pre>
-   *
-   * <code>string containing_type = 1;</code>
-   */
-  java.lang.String getContainingType();
-  /**
-   * <pre>
-   * Fully-qualified type name. The format should be &lt;package&gt;.&lt;type&gt;
-   * </pre>
-   *
-   * <code>string containing_type = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getContainingTypeBytes();
-
-  /**
-   * <code>int32 extension_number = 2;</code>
-   */
-  int getExtensionNumber();
-}
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/FileDescriptorResponse.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/FileDescriptorResponse.java
deleted file mode 100644
index 876a9ba8c84..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/FileDescriptorResponse.java
+++ /dev/null
@@ -1,582 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-/**
- * <pre>
- * Serialized FileDescriptorProto messages sent by the server answering
- * a file_by_filename, file_containing_symbol, or file_containing_extension
- * request.
- * </pre>
- *
- * Protobuf type {@code grpc.reflection.v1alpha.FileDescriptorResponse}
- */
-public  final class FileDescriptorResponse extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.v1alpha.FileDescriptorResponse)
-    FileDescriptorResponseOrBuilder {
-  // Use FileDescriptorResponse.newBuilder() to construct.
-  private FileDescriptorResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private FileDescriptorResponse() {
-    fileDescriptorProto_ = java.util.Collections.emptyList();
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private FileDescriptorResponse(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
-              fileDescriptorProto_ = new java.util.ArrayList<com.google.protobuf.ByteString>();
-              mutable_bitField0_ |= 0x00000001;
-            }
-            fileDescriptorProto_.add(input.readBytes());
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
-        fileDescriptorProto_ = java.util.Collections.unmodifiableList(fileDescriptorProto_);
-      }
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_FileDescriptorResponse_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_FileDescriptorResponse_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.v1alpha.FileDescriptorResponse.class, io.grpc.reflection.v1alpha.FileDescriptorResponse.Builder.class);
-  }
-
-  public static final int FILE_DESCRIPTOR_PROTO_FIELD_NUMBER = 1;
-  private java.util.List<com.google.protobuf.ByteString> fileDescriptorProto_;
-  /**
-   * <pre>
-   * Serialized FileDescriptorProto messages. We avoid taking a dependency on
-   * descriptor.proto, which uses proto2 only features, by making them opaque
-   * bytes instead.
-   * </pre>
-   *
-   * <code>repeated bytes file_descriptor_proto = 1;</code>
-   */
-  public java.util.List<com.google.protobuf.ByteString>
-      getFileDescriptorProtoList() {
-    return fileDescriptorProto_;
-  }
-  /**
-   * <pre>
-   * Serialized FileDescriptorProto messages. We avoid taking a dependency on
-   * descriptor.proto, which uses proto2 only features, by making them opaque
-   * bytes instead.
-   * </pre>
-   *
-   * <code>repeated bytes file_descriptor_proto = 1;</code>
-   */
-  public int getFileDescriptorProtoCount() {
-    return fileDescriptorProto_.size();
-  }
-  /**
-   * <pre>
-   * Serialized FileDescriptorProto messages. We avoid taking a dependency on
-   * descriptor.proto, which uses proto2 only features, by making them opaque
-   * bytes instead.
-   * </pre>
-   *
-   * <code>repeated bytes file_descriptor_proto = 1;</code>
-   */
-  public com.google.protobuf.ByteString getFileDescriptorProto(int index) {
-    return fileDescriptorProto_.get(index);
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    for (int i = 0; i < fileDescriptorProto_.size(); i++) {
-      output.writeBytes(1, fileDescriptorProto_.get(i));
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    {
-      int dataSize = 0;
-      for (int i = 0; i < fileDescriptorProto_.size(); i++) {
-        dataSize += com.google.protobuf.CodedOutputStream
-          .computeBytesSizeNoTag(fileDescriptorProto_.get(i));
-      }
-      size += dataSize;
-      size += 1 * getFileDescriptorProtoList().size();
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.v1alpha.FileDescriptorResponse)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.v1alpha.FileDescriptorResponse other = (io.grpc.reflection.v1alpha.FileDescriptorResponse) obj;
-
-    boolean result = true;
-    result = result && getFileDescriptorProtoList()
-        .equals(other.getFileDescriptorProtoList());
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    if (getFileDescriptorProtoCount() > 0) {
-      hash = (37 * hash) + FILE_DESCRIPTOR_PROTO_FIELD_NUMBER;
-      hash = (53 * hash) + getFileDescriptorProtoList().hashCode();
-    }
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.v1alpha.FileDescriptorResponse parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.FileDescriptorResponse parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.FileDescriptorResponse parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.FileDescriptorResponse parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.FileDescriptorResponse parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.FileDescriptorResponse parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.FileDescriptorResponse parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.FileDescriptorResponse parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.FileDescriptorResponse parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.FileDescriptorResponse parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.v1alpha.FileDescriptorResponse prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * <pre>
-   * Serialized FileDescriptorProto messages sent by the server answering
-   * a file_by_filename, file_containing_symbol, or file_containing_extension
-   * request.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.reflection.v1alpha.FileDescriptorResponse}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.v1alpha.FileDescriptorResponse)
-      io.grpc.reflection.v1alpha.FileDescriptorResponseOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_FileDescriptorResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_FileDescriptorResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.v1alpha.FileDescriptorResponse.class, io.grpc.reflection.v1alpha.FileDescriptorResponse.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.v1alpha.FileDescriptorResponse.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      fileDescriptorProto_ = java.util.Collections.emptyList();
-      bitField0_ = (bitField0_ & ~0x00000001);
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_FileDescriptorResponse_descriptor;
-    }
-
-    public io.grpc.reflection.v1alpha.FileDescriptorResponse getDefaultInstanceForType() {
-      return io.grpc.reflection.v1alpha.FileDescriptorResponse.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.v1alpha.FileDescriptorResponse build() {
-      io.grpc.reflection.v1alpha.FileDescriptorResponse result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.v1alpha.FileDescriptorResponse buildPartial() {
-      io.grpc.reflection.v1alpha.FileDescriptorResponse result = new io.grpc.reflection.v1alpha.FileDescriptorResponse(this);
-      int from_bitField0_ = bitField0_;
-      if (((bitField0_ & 0x00000001) == 0x00000001)) {
-        fileDescriptorProto_ = java.util.Collections.unmodifiableList(fileDescriptorProto_);
-        bitField0_ = (bitField0_ & ~0x00000001);
-      }
-      result.fileDescriptorProto_ = fileDescriptorProto_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.v1alpha.FileDescriptorResponse) {
-        return mergeFrom((io.grpc.reflection.v1alpha.FileDescriptorResponse)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.v1alpha.FileDescriptorResponse other) {
-      if (other == io.grpc.reflection.v1alpha.FileDescriptorResponse.getDefaultInstance()) return this;
-      if (!other.fileDescriptorProto_.isEmpty()) {
-        if (fileDescriptorProto_.isEmpty()) {
-          fileDescriptorProto_ = other.fileDescriptorProto_;
-          bitField0_ = (bitField0_ & ~0x00000001);
-        } else {
-          ensureFileDescriptorProtoIsMutable();
-          fileDescriptorProto_.addAll(other.fileDescriptorProto_);
-        }
-        onChanged();
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.v1alpha.FileDescriptorResponse parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.v1alpha.FileDescriptorResponse) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int bitField0_;
-
-    private java.util.List<com.google.protobuf.ByteString> fileDescriptorProto_ = java.util.Collections.emptyList();
-    private void ensureFileDescriptorProtoIsMutable() {
-      if (!((bitField0_ & 0x00000001) == 0x00000001)) {
-        fileDescriptorProto_ = new java.util.ArrayList<com.google.protobuf.ByteString>(fileDescriptorProto_);
-        bitField0_ |= 0x00000001;
-       }
-    }
-    /**
-     * <pre>
-     * Serialized FileDescriptorProto messages. We avoid taking a dependency on
-     * descriptor.proto, which uses proto2 only features, by making them opaque
-     * bytes instead.
-     * </pre>
-     *
-     * <code>repeated bytes file_descriptor_proto = 1;</code>
-     */
-    public java.util.List<com.google.protobuf.ByteString>
-        getFileDescriptorProtoList() {
-      return java.util.Collections.unmodifiableList(fileDescriptorProto_);
-    }
-    /**
-     * <pre>
-     * Serialized FileDescriptorProto messages. We avoid taking a dependency on
-     * descriptor.proto, which uses proto2 only features, by making them opaque
-     * bytes instead.
-     * </pre>
-     *
-     * <code>repeated bytes file_descriptor_proto = 1;</code>
-     */
-    public int getFileDescriptorProtoCount() {
-      return fileDescriptorProto_.size();
-    }
-    /**
-     * <pre>
-     * Serialized FileDescriptorProto messages. We avoid taking a dependency on
-     * descriptor.proto, which uses proto2 only features, by making them opaque
-     * bytes instead.
-     * </pre>
-     *
-     * <code>repeated bytes file_descriptor_proto = 1;</code>
-     */
-    public com.google.protobuf.ByteString getFileDescriptorProto(int index) {
-      return fileDescriptorProto_.get(index);
-    }
-    /**
-     * <pre>
-     * Serialized FileDescriptorProto messages. We avoid taking a dependency on
-     * descriptor.proto, which uses proto2 only features, by making them opaque
-     * bytes instead.
-     * </pre>
-     *
-     * <code>repeated bytes file_descriptor_proto = 1;</code>
-     */
-    public Builder setFileDescriptorProto(
-        int index, com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  ensureFileDescriptorProtoIsMutable();
-      fileDescriptorProto_.set(index, value);
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Serialized FileDescriptorProto messages. We avoid taking a dependency on
-     * descriptor.proto, which uses proto2 only features, by making them opaque
-     * bytes instead.
-     * </pre>
-     *
-     * <code>repeated bytes file_descriptor_proto = 1;</code>
-     */
-    public Builder addFileDescriptorProto(com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  ensureFileDescriptorProtoIsMutable();
-      fileDescriptorProto_.add(value);
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Serialized FileDescriptorProto messages. We avoid taking a dependency on
-     * descriptor.proto, which uses proto2 only features, by making them opaque
-     * bytes instead.
-     * </pre>
-     *
-     * <code>repeated bytes file_descriptor_proto = 1;</code>
-     */
-    public Builder addAllFileDescriptorProto(
-        java.lang.Iterable<? extends com.google.protobuf.ByteString> values) {
-      ensureFileDescriptorProtoIsMutable();
-      com.google.protobuf.AbstractMessageLite.Builder.addAll(
-          values, fileDescriptorProto_);
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Serialized FileDescriptorProto messages. We avoid taking a dependency on
-     * descriptor.proto, which uses proto2 only features, by making them opaque
-     * bytes instead.
-     * </pre>
-     *
-     * <code>repeated bytes file_descriptor_proto = 1;</code>
-     */
-    public Builder clearFileDescriptorProto() {
-      fileDescriptorProto_ = java.util.Collections.emptyList();
-      bitField0_ = (bitField0_ & ~0x00000001);
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.v1alpha.FileDescriptorResponse)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.v1alpha.FileDescriptorResponse)
-  private static final io.grpc.reflection.v1alpha.FileDescriptorResponse DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.v1alpha.FileDescriptorResponse();
-  }
-
-  public static io.grpc.reflection.v1alpha.FileDescriptorResponse getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<FileDescriptorResponse>
-      PARSER = new com.google.protobuf.AbstractParser<FileDescriptorResponse>() {
-    public FileDescriptorResponse parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new FileDescriptorResponse(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<FileDescriptorResponse> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<FileDescriptorResponse> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.v1alpha.FileDescriptorResponse getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/FileDescriptorResponseOrBuilder.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/FileDescriptorResponseOrBuilder.java
deleted file mode 100644
index 82a69d71d13..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/FileDescriptorResponseOrBuilder.java
+++ /dev/null
@@ -1,40 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-public interface FileDescriptorResponseOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.v1alpha.FileDescriptorResponse)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <pre>
-   * Serialized FileDescriptorProto messages. We avoid taking a dependency on
-   * descriptor.proto, which uses proto2 only features, by making them opaque
-   * bytes instead.
-   * </pre>
-   *
-   * <code>repeated bytes file_descriptor_proto = 1;</code>
-   */
-  java.util.List<com.google.protobuf.ByteString> getFileDescriptorProtoList();
-  /**
-   * <pre>
-   * Serialized FileDescriptorProto messages. We avoid taking a dependency on
-   * descriptor.proto, which uses proto2 only features, by making them opaque
-   * bytes instead.
-   * </pre>
-   *
-   * <code>repeated bytes file_descriptor_proto = 1;</code>
-   */
-  int getFileDescriptorProtoCount();
-  /**
-   * <pre>
-   * Serialized FileDescriptorProto messages. We avoid taking a dependency on
-   * descriptor.proto, which uses proto2 only features, by making them opaque
-   * bytes instead.
-   * </pre>
-   *
-   * <code>repeated bytes file_descriptor_proto = 1;</code>
-   */
-  com.google.protobuf.ByteString getFileDescriptorProto(int index);
-}
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ListServiceResponse.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ListServiceResponse.java
deleted file mode 100644
index 62b5c3eeff6..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ListServiceResponse.java
+++ /dev/null
@@ -1,835 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-/**
- * <pre>
- * A list of ServiceResponse sent by the server answering list_services request.
- * </pre>
- *
- * Protobuf type {@code grpc.reflection.v1alpha.ListServiceResponse}
- */
-public  final class ListServiceResponse extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.v1alpha.ListServiceResponse)
-    ListServiceResponseOrBuilder {
-  // Use ListServiceResponse.newBuilder() to construct.
-  private ListServiceResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private ListServiceResponse() {
-    service_ = java.util.Collections.emptyList();
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private ListServiceResponse(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
-              service_ = new java.util.ArrayList<io.grpc.reflection.v1alpha.ServiceResponse>();
-              mutable_bitField0_ |= 0x00000001;
-            }
-            service_.add(
-                input.readMessage(io.grpc.reflection.v1alpha.ServiceResponse.parser(), extensionRegistry));
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
-        service_ = java.util.Collections.unmodifiableList(service_);
-      }
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ListServiceResponse_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ListServiceResponse_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.v1alpha.ListServiceResponse.class, io.grpc.reflection.v1alpha.ListServiceResponse.Builder.class);
-  }
-
-  public static final int SERVICE_FIELD_NUMBER = 1;
-  private java.util.List<io.grpc.reflection.v1alpha.ServiceResponse> service_;
-  /**
-   * <pre>
-   * The information of each service may be expanded in the future, so we use
-   * ServiceResponse message to encapsulate it.
-   * </pre>
-   *
-   * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-   */
-  public java.util.List<io.grpc.reflection.v1alpha.ServiceResponse> getServiceList() {
-    return service_;
-  }
-  /**
-   * <pre>
-   * The information of each service may be expanded in the future, so we use
-   * ServiceResponse message to encapsulate it.
-   * </pre>
-   *
-   * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-   */
-  public java.util.List<? extends io.grpc.reflection.v1alpha.ServiceResponseOrBuilder> 
-      getServiceOrBuilderList() {
-    return service_;
-  }
-  /**
-   * <pre>
-   * The information of each service may be expanded in the future, so we use
-   * ServiceResponse message to encapsulate it.
-   * </pre>
-   *
-   * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-   */
-  public int getServiceCount() {
-    return service_.size();
-  }
-  /**
-   * <pre>
-   * The information of each service may be expanded in the future, so we use
-   * ServiceResponse message to encapsulate it.
-   * </pre>
-   *
-   * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-   */
-  public io.grpc.reflection.v1alpha.ServiceResponse getService(int index) {
-    return service_.get(index);
-  }
-  /**
-   * <pre>
-   * The information of each service may be expanded in the future, so we use
-   * ServiceResponse message to encapsulate it.
-   * </pre>
-   *
-   * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-   */
-  public io.grpc.reflection.v1alpha.ServiceResponseOrBuilder getServiceOrBuilder(
-      int index) {
-    return service_.get(index);
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    for (int i = 0; i < service_.size(); i++) {
-      output.writeMessage(1, service_.get(i));
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    for (int i = 0; i < service_.size(); i++) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(1, service_.get(i));
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.v1alpha.ListServiceResponse)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.v1alpha.ListServiceResponse other = (io.grpc.reflection.v1alpha.ListServiceResponse) obj;
-
-    boolean result = true;
-    result = result && getServiceList()
-        .equals(other.getServiceList());
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    if (getServiceCount() > 0) {
-      hash = (37 * hash) + SERVICE_FIELD_NUMBER;
-      hash = (53 * hash) + getServiceList().hashCode();
-    }
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.v1alpha.ListServiceResponse parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ListServiceResponse parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ListServiceResponse parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ListServiceResponse parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ListServiceResponse parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ListServiceResponse parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ListServiceResponse parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ListServiceResponse parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ListServiceResponse parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ListServiceResponse parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.v1alpha.ListServiceResponse prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * <pre>
-   * A list of ServiceResponse sent by the server answering list_services request.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.reflection.v1alpha.ListServiceResponse}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.v1alpha.ListServiceResponse)
-      io.grpc.reflection.v1alpha.ListServiceResponseOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ListServiceResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ListServiceResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.v1alpha.ListServiceResponse.class, io.grpc.reflection.v1alpha.ListServiceResponse.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.v1alpha.ListServiceResponse.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-        getServiceFieldBuilder();
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      if (serviceBuilder_ == null) {
-        service_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000001);
-      } else {
-        serviceBuilder_.clear();
-      }
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ListServiceResponse_descriptor;
-    }
-
-    public io.grpc.reflection.v1alpha.ListServiceResponse getDefaultInstanceForType() {
-      return io.grpc.reflection.v1alpha.ListServiceResponse.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.v1alpha.ListServiceResponse build() {
-      io.grpc.reflection.v1alpha.ListServiceResponse result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.v1alpha.ListServiceResponse buildPartial() {
-      io.grpc.reflection.v1alpha.ListServiceResponse result = new io.grpc.reflection.v1alpha.ListServiceResponse(this);
-      int from_bitField0_ = bitField0_;
-      if (serviceBuilder_ == null) {
-        if (((bitField0_ & 0x00000001) == 0x00000001)) {
-          service_ = java.util.Collections.unmodifiableList(service_);
-          bitField0_ = (bitField0_ & ~0x00000001);
-        }
-        result.service_ = service_;
-      } else {
-        result.service_ = serviceBuilder_.build();
-      }
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.v1alpha.ListServiceResponse) {
-        return mergeFrom((io.grpc.reflection.v1alpha.ListServiceResponse)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.v1alpha.ListServiceResponse other) {
-      if (other == io.grpc.reflection.v1alpha.ListServiceResponse.getDefaultInstance()) return this;
-      if (serviceBuilder_ == null) {
-        if (!other.service_.isEmpty()) {
-          if (service_.isEmpty()) {
-            service_ = other.service_;
-            bitField0_ = (bitField0_ & ~0x00000001);
-          } else {
-            ensureServiceIsMutable();
-            service_.addAll(other.service_);
-          }
-          onChanged();
-        }
-      } else {
-        if (!other.service_.isEmpty()) {
-          if (serviceBuilder_.isEmpty()) {
-            serviceBuilder_.dispose();
-            serviceBuilder_ = null;
-            service_ = other.service_;
-            bitField0_ = (bitField0_ & ~0x00000001);
-            serviceBuilder_ = 
-              com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
-                 getServiceFieldBuilder() : null;
-          } else {
-            serviceBuilder_.addAllMessages(other.service_);
-          }
-        }
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.v1alpha.ListServiceResponse parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.v1alpha.ListServiceResponse) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int bitField0_;
-
-    private java.util.List<io.grpc.reflection.v1alpha.ServiceResponse> service_ =
-      java.util.Collections.emptyList();
-    private void ensureServiceIsMutable() {
-      if (!((bitField0_ & 0x00000001) == 0x00000001)) {
-        service_ = new java.util.ArrayList<io.grpc.reflection.v1alpha.ServiceResponse>(service_);
-        bitField0_ |= 0x00000001;
-       }
-    }
-
-    private com.google.protobuf.RepeatedFieldBuilderV3<
-        io.grpc.reflection.v1alpha.ServiceResponse, io.grpc.reflection.v1alpha.ServiceResponse.Builder, io.grpc.reflection.v1alpha.ServiceResponseOrBuilder> serviceBuilder_;
-
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public java.util.List<io.grpc.reflection.v1alpha.ServiceResponse> getServiceList() {
-      if (serviceBuilder_ == null) {
-        return java.util.Collections.unmodifiableList(service_);
-      } else {
-        return serviceBuilder_.getMessageList();
-      }
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public int getServiceCount() {
-      if (serviceBuilder_ == null) {
-        return service_.size();
-      } else {
-        return serviceBuilder_.getCount();
-      }
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public io.grpc.reflection.v1alpha.ServiceResponse getService(int index) {
-      if (serviceBuilder_ == null) {
-        return service_.get(index);
-      } else {
-        return serviceBuilder_.getMessage(index);
-      }
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public Builder setService(
-        int index, io.grpc.reflection.v1alpha.ServiceResponse value) {
-      if (serviceBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        ensureServiceIsMutable();
-        service_.set(index, value);
-        onChanged();
-      } else {
-        serviceBuilder_.setMessage(index, value);
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public Builder setService(
-        int index, io.grpc.reflection.v1alpha.ServiceResponse.Builder builderForValue) {
-      if (serviceBuilder_ == null) {
-        ensureServiceIsMutable();
-        service_.set(index, builderForValue.build());
-        onChanged();
-      } else {
-        serviceBuilder_.setMessage(index, builderForValue.build());
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public Builder addService(io.grpc.reflection.v1alpha.ServiceResponse value) {
-      if (serviceBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        ensureServiceIsMutable();
-        service_.add(value);
-        onChanged();
-      } else {
-        serviceBuilder_.addMessage(value);
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public Builder addService(
-        int index, io.grpc.reflection.v1alpha.ServiceResponse value) {
-      if (serviceBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        ensureServiceIsMutable();
-        service_.add(index, value);
-        onChanged();
-      } else {
-        serviceBuilder_.addMessage(index, value);
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public Builder addService(
-        io.grpc.reflection.v1alpha.ServiceResponse.Builder builderForValue) {
-      if (serviceBuilder_ == null) {
-        ensureServiceIsMutable();
-        service_.add(builderForValue.build());
-        onChanged();
-      } else {
-        serviceBuilder_.addMessage(builderForValue.build());
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public Builder addService(
-        int index, io.grpc.reflection.v1alpha.ServiceResponse.Builder builderForValue) {
-      if (serviceBuilder_ == null) {
-        ensureServiceIsMutable();
-        service_.add(index, builderForValue.build());
-        onChanged();
-      } else {
-        serviceBuilder_.addMessage(index, builderForValue.build());
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public Builder addAllService(
-        java.lang.Iterable<? extends io.grpc.reflection.v1alpha.ServiceResponse> values) {
-      if (serviceBuilder_ == null) {
-        ensureServiceIsMutable();
-        com.google.protobuf.AbstractMessageLite.Builder.addAll(
-            values, service_);
-        onChanged();
-      } else {
-        serviceBuilder_.addAllMessages(values);
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public Builder clearService() {
-      if (serviceBuilder_ == null) {
-        service_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000001);
-        onChanged();
-      } else {
-        serviceBuilder_.clear();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public Builder removeService(int index) {
-      if (serviceBuilder_ == null) {
-        ensureServiceIsMutable();
-        service_.remove(index);
-        onChanged();
-      } else {
-        serviceBuilder_.remove(index);
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public io.grpc.reflection.v1alpha.ServiceResponse.Builder getServiceBuilder(
-        int index) {
-      return getServiceFieldBuilder().getBuilder(index);
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public io.grpc.reflection.v1alpha.ServiceResponseOrBuilder getServiceOrBuilder(
-        int index) {
-      if (serviceBuilder_ == null) {
-        return service_.get(index);  } else {
-        return serviceBuilder_.getMessageOrBuilder(index);
-      }
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public java.util.List<? extends io.grpc.reflection.v1alpha.ServiceResponseOrBuilder> 
-         getServiceOrBuilderList() {
-      if (serviceBuilder_ != null) {
-        return serviceBuilder_.getMessageOrBuilderList();
-      } else {
-        return java.util.Collections.unmodifiableList(service_);
-      }
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public io.grpc.reflection.v1alpha.ServiceResponse.Builder addServiceBuilder() {
-      return getServiceFieldBuilder().addBuilder(
-          io.grpc.reflection.v1alpha.ServiceResponse.getDefaultInstance());
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public io.grpc.reflection.v1alpha.ServiceResponse.Builder addServiceBuilder(
-        int index) {
-      return getServiceFieldBuilder().addBuilder(
-          index, io.grpc.reflection.v1alpha.ServiceResponse.getDefaultInstance());
-    }
-    /**
-     * <pre>
-     * The information of each service may be expanded in the future, so we use
-     * ServiceResponse message to encapsulate it.
-     * </pre>
-     *
-     * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-     */
-    public java.util.List<io.grpc.reflection.v1alpha.ServiceResponse.Builder> 
-         getServiceBuilderList() {
-      return getServiceFieldBuilder().getBuilderList();
-    }
-    private com.google.protobuf.RepeatedFieldBuilderV3<
-        io.grpc.reflection.v1alpha.ServiceResponse, io.grpc.reflection.v1alpha.ServiceResponse.Builder, io.grpc.reflection.v1alpha.ServiceResponseOrBuilder> 
-        getServiceFieldBuilder() {
-      if (serviceBuilder_ == null) {
-        serviceBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-            io.grpc.reflection.v1alpha.ServiceResponse, io.grpc.reflection.v1alpha.ServiceResponse.Builder, io.grpc.reflection.v1alpha.ServiceResponseOrBuilder>(
-                service_,
-                ((bitField0_ & 0x00000001) == 0x00000001),
-                getParentForChildren(),
-                isClean());
-        service_ = null;
-      }
-      return serviceBuilder_;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.v1alpha.ListServiceResponse)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.v1alpha.ListServiceResponse)
-  private static final io.grpc.reflection.v1alpha.ListServiceResponse DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.v1alpha.ListServiceResponse();
-  }
-
-  public static io.grpc.reflection.v1alpha.ListServiceResponse getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<ListServiceResponse>
-      PARSER = new com.google.protobuf.AbstractParser<ListServiceResponse>() {
-    public ListServiceResponse parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new ListServiceResponse(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<ListServiceResponse> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<ListServiceResponse> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.v1alpha.ListServiceResponse getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ListServiceResponseOrBuilder.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ListServiceResponseOrBuilder.java
deleted file mode 100644
index 734ec961ce7..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ListServiceResponseOrBuilder.java
+++ /dev/null
@@ -1,58 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-public interface ListServiceResponseOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.v1alpha.ListServiceResponse)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <pre>
-   * The information of each service may be expanded in the future, so we use
-   * ServiceResponse message to encapsulate it.
-   * </pre>
-   *
-   * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-   */
-  java.util.List<io.grpc.reflection.v1alpha.ServiceResponse> 
-      getServiceList();
-  /**
-   * <pre>
-   * The information of each service may be expanded in the future, so we use
-   * ServiceResponse message to encapsulate it.
-   * </pre>
-   *
-   * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-   */
-  io.grpc.reflection.v1alpha.ServiceResponse getService(int index);
-  /**
-   * <pre>
-   * The information of each service may be expanded in the future, so we use
-   * ServiceResponse message to encapsulate it.
-   * </pre>
-   *
-   * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-   */
-  int getServiceCount();
-  /**
-   * <pre>
-   * The information of each service may be expanded in the future, so we use
-   * ServiceResponse message to encapsulate it.
-   * </pre>
-   *
-   * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-   */
-  java.util.List<? extends io.grpc.reflection.v1alpha.ServiceResponseOrBuilder> 
-      getServiceOrBuilderList();
-  /**
-   * <pre>
-   * The information of each service may be expanded in the future, so we use
-   * ServiceResponse message to encapsulate it.
-   * </pre>
-   *
-   * <code>repeated .grpc.reflection.v1alpha.ServiceResponse service = 1;</code>
-   */
-  io.grpc.reflection.v1alpha.ServiceResponseOrBuilder getServiceOrBuilder(
-      int index);
-}
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionProto.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionProto.java
deleted file mode 100644
index e79cdb2ec9b..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionProto.java
+++ /dev/null
@@ -1,165 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-public final class ServerReflectionProto {
-  private ServerReflectionProto() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_v1alpha_ServerReflectionRequest_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_v1alpha_ServerReflectionRequest_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_v1alpha_ExtensionRequest_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_v1alpha_ExtensionRequest_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_v1alpha_ServerReflectionResponse_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_v1alpha_ServerReflectionResponse_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_v1alpha_FileDescriptorResponse_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_v1alpha_FileDescriptorResponse_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_v1alpha_ExtensionNumberResponse_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_v1alpha_ExtensionNumberResponse_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_v1alpha_ListServiceResponse_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_v1alpha_ListServiceResponse_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_v1alpha_ServiceResponse_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_v1alpha_ServiceResponse_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_v1alpha_ErrorResponse_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_v1alpha_ErrorResponse_fieldAccessorTable;
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n+io/grpc/reflection/v1alpha/reflection." +
-      "proto\022\027grpc.reflection.v1alpha\"\212\002\n\027Serve" +
-      "rReflectionRequest\022\014\n\004host\030\001 \001(\t\022\032\n\020file" +
-      "_by_filename\030\003 \001(\tH\000\022 \n\026file_containing_" +
-      "symbol\030\004 \001(\tH\000\022N\n\031file_containing_extens" +
-      "ion\030\005 \001(\0132).grpc.reflection.v1alpha.Exte" +
-      "nsionRequestH\000\022\'\n\035all_extension_numbers_" +
-      "of_type\030\006 \001(\tH\000\022\027\n\rlist_services\030\007 \001(\tH\000" +
-      "B\021\n\017message_request\"E\n\020ExtensionRequest\022" +
-      "\027\n\017containing_type\030\001 \001(\t\022\030\n\020extension_nu",
-      "mber\030\002 \001(\005\"\321\003\n\030ServerReflectionResponse\022" +
-      "\022\n\nvalid_host\030\001 \001(\t\022J\n\020original_request\030" +
-      "\002 \001(\01320.grpc.reflection.v1alpha.ServerRe" +
-      "flectionRequest\022S\n\030file_descriptor_respo" +
-      "nse\030\004 \001(\0132/.grpc.reflection.v1alpha.File" +
-      "DescriptorResponseH\000\022Z\n\036all_extension_nu" +
-      "mbers_response\030\005 \001(\01320.grpc.reflection.v" +
-      "1alpha.ExtensionNumberResponseH\000\022N\n\026list" +
-      "_services_response\030\006 \001(\0132,.grpc.reflecti" +
-      "on.v1alpha.ListServiceResponseH\000\022@\n\016erro",
-      "r_response\030\007 \001(\0132&.grpc.reflection.v1alp" +
-      "ha.ErrorResponseH\000B\022\n\020message_response\"7" +
-      "\n\026FileDescriptorResponse\022\035\n\025file_descrip" +
-      "tor_proto\030\001 \003(\014\"K\n\027ExtensionNumberRespon" +
-      "se\022\026\n\016base_type_name\030\001 \001(\t\022\030\n\020extension_" +
-      "number\030\002 \003(\005\"P\n\023ListServiceResponse\0229\n\007s" +
-      "ervice\030\001 \003(\0132(.grpc.reflection.v1alpha.S" +
-      "erviceResponse\"\037\n\017ServiceResponse\022\014\n\004nam" +
-      "e\030\001 \001(\t\":\n\rErrorResponse\022\022\n\nerror_code\030\001" +
-      " \001(\005\022\025\n\rerror_message\030\002 \001(\t2\223\001\n\020ServerRe",
-      "flection\022\177\n\024ServerReflectionInfo\0220.grpc." +
-      "reflection.v1alpha.ServerReflectionReque" +
-      "st\0321.grpc.reflection.v1alpha.ServerRefle" +
-      "ctionResponse(\0010\001B5\n\032io.grpc.reflection." +
-      "v1alphaB\025ServerReflectionProtoP\001b\006proto3"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-        }, assigner);
-    internal_static_grpc_reflection_v1alpha_ServerReflectionRequest_descriptor =
-      getDescriptor().getMessageTypes().get(0);
-    internal_static_grpc_reflection_v1alpha_ServerReflectionRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_v1alpha_ServerReflectionRequest_descriptor,
-        new java.lang.String[] { "Host", "FileByFilename", "FileContainingSymbol", "FileContainingExtension", "AllExtensionNumbersOfType", "ListServices", "MessageRequest", });
-    internal_static_grpc_reflection_v1alpha_ExtensionRequest_descriptor =
-      getDescriptor().getMessageTypes().get(1);
-    internal_static_grpc_reflection_v1alpha_ExtensionRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_v1alpha_ExtensionRequest_descriptor,
-        new java.lang.String[] { "ContainingType", "ExtensionNumber", });
-    internal_static_grpc_reflection_v1alpha_ServerReflectionResponse_descriptor =
-      getDescriptor().getMessageTypes().get(2);
-    internal_static_grpc_reflection_v1alpha_ServerReflectionResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_v1alpha_ServerReflectionResponse_descriptor,
-        new java.lang.String[] { "ValidHost", "OriginalRequest", "FileDescriptorResponse", "AllExtensionNumbersResponse", "ListServicesResponse", "ErrorResponse", "MessageResponse", });
-    internal_static_grpc_reflection_v1alpha_FileDescriptorResponse_descriptor =
-      getDescriptor().getMessageTypes().get(3);
-    internal_static_grpc_reflection_v1alpha_FileDescriptorResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_v1alpha_FileDescriptorResponse_descriptor,
-        new java.lang.String[] { "FileDescriptorProto", });
-    internal_static_grpc_reflection_v1alpha_ExtensionNumberResponse_descriptor =
-      getDescriptor().getMessageTypes().get(4);
-    internal_static_grpc_reflection_v1alpha_ExtensionNumberResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_v1alpha_ExtensionNumberResponse_descriptor,
-        new java.lang.String[] { "BaseTypeName", "ExtensionNumber", });
-    internal_static_grpc_reflection_v1alpha_ListServiceResponse_descriptor =
-      getDescriptor().getMessageTypes().get(5);
-    internal_static_grpc_reflection_v1alpha_ListServiceResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_v1alpha_ListServiceResponse_descriptor,
-        new java.lang.String[] { "Service", });
-    internal_static_grpc_reflection_v1alpha_ServiceResponse_descriptor =
-      getDescriptor().getMessageTypes().get(6);
-    internal_static_grpc_reflection_v1alpha_ServiceResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_v1alpha_ServiceResponse_descriptor,
-        new java.lang.String[] { "Name", });
-    internal_static_grpc_reflection_v1alpha_ErrorResponse_descriptor =
-      getDescriptor().getMessageTypes().get(7);
-    internal_static_grpc_reflection_v1alpha_ErrorResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_v1alpha_ErrorResponse_descriptor,
-        new java.lang.String[] { "ErrorCode", "ErrorMessage", });
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionRequest.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionRequest.java
deleted file mode 100644
index 445a0cc3c98..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionRequest.java
+++ /dev/null
@@ -1,1610 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-/**
- * <pre>
- * The message sent by the client when calling ServerReflectionInfo method.
- * </pre>
- *
- * Protobuf type {@code grpc.reflection.v1alpha.ServerReflectionRequest}
- */
-public  final class ServerReflectionRequest extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.v1alpha.ServerReflectionRequest)
-    ServerReflectionRequestOrBuilder {
-  // Use ServerReflectionRequest.newBuilder() to construct.
-  private ServerReflectionRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private ServerReflectionRequest() {
-    host_ = "";
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private ServerReflectionRequest(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            java.lang.String s = input.readStringRequireUtf8();
-
-            host_ = s;
-            break;
-          }
-          case 26: {
-            java.lang.String s = input.readStringRequireUtf8();
-            messageRequestCase_ = 3;
-            messageRequest_ = s;
-            break;
-          }
-          case 34: {
-            java.lang.String s = input.readStringRequireUtf8();
-            messageRequestCase_ = 4;
-            messageRequest_ = s;
-            break;
-          }
-          case 42: {
-            io.grpc.reflection.v1alpha.ExtensionRequest.Builder subBuilder = null;
-            if (messageRequestCase_ == 5) {
-              subBuilder = ((io.grpc.reflection.v1alpha.ExtensionRequest) messageRequest_).toBuilder();
-            }
-            messageRequest_ =
-                input.readMessage(io.grpc.reflection.v1alpha.ExtensionRequest.parser(), extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom((io.grpc.reflection.v1alpha.ExtensionRequest) messageRequest_);
-              messageRequest_ = subBuilder.buildPartial();
-            }
-            messageRequestCase_ = 5;
-            break;
-          }
-          case 50: {
-            java.lang.String s = input.readStringRequireUtf8();
-            messageRequestCase_ = 6;
-            messageRequest_ = s;
-            break;
-          }
-          case 58: {
-            java.lang.String s = input.readStringRequireUtf8();
-            messageRequestCase_ = 7;
-            messageRequest_ = s;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServerReflectionRequest_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServerReflectionRequest_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.v1alpha.ServerReflectionRequest.class, io.grpc.reflection.v1alpha.ServerReflectionRequest.Builder.class);
-  }
-
-  private int messageRequestCase_ = 0;
-  private java.lang.Object messageRequest_;
-  public enum MessageRequestCase
-      implements com.google.protobuf.Internal.EnumLite {
-    FILE_BY_FILENAME(3),
-    FILE_CONTAINING_SYMBOL(4),
-    FILE_CONTAINING_EXTENSION(5),
-    ALL_EXTENSION_NUMBERS_OF_TYPE(6),
-    LIST_SERVICES(7),
-    MESSAGEREQUEST_NOT_SET(0);
-    private final int value;
-    private MessageRequestCase(int value) {
-      this.value = value;
-    }
-    /**
-     * @deprecated Use {@link #forNumber(int)} instead.
-     */
-    @java.lang.Deprecated
-    public static MessageRequestCase valueOf(int value) {
-      return forNumber(value);
-    }
-
-    public static MessageRequestCase forNumber(int value) {
-      switch (value) {
-        case 3: return FILE_BY_FILENAME;
-        case 4: return FILE_CONTAINING_SYMBOL;
-        case 5: return FILE_CONTAINING_EXTENSION;
-        case 6: return ALL_EXTENSION_NUMBERS_OF_TYPE;
-        case 7: return LIST_SERVICES;
-        case 0: return MESSAGEREQUEST_NOT_SET;
-        default: return null;
-      }
-    }
-    public int getNumber() {
-      return this.value;
-    }
-  };
-
-  public MessageRequestCase
-  getMessageRequestCase() {
-    return MessageRequestCase.forNumber(
-        messageRequestCase_);
-  }
-
-  public static final int HOST_FIELD_NUMBER = 1;
-  private volatile java.lang.Object host_;
-  /**
-   * <code>string host = 1;</code>
-   */
-  public java.lang.String getHost() {
-    java.lang.Object ref = host_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      host_ = s;
-      return s;
-    }
-  }
-  /**
-   * <code>string host = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getHostBytes() {
-    java.lang.Object ref = host_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      host_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  public static final int FILE_BY_FILENAME_FIELD_NUMBER = 3;
-  /**
-   * <pre>
-   * Find a proto file by the file name.
-   * </pre>
-   *
-   * <code>string file_by_filename = 3;</code>
-   */
-  public java.lang.String getFileByFilename() {
-    java.lang.Object ref = "";
-    if (messageRequestCase_ == 3) {
-      ref = messageRequest_;
-    }
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      if (messageRequestCase_ == 3) {
-        messageRequest_ = s;
-      }
-      return s;
-    }
-  }
-  /**
-   * <pre>
-   * Find a proto file by the file name.
-   * </pre>
-   *
-   * <code>string file_by_filename = 3;</code>
-   */
-  public com.google.protobuf.ByteString
-      getFileByFilenameBytes() {
-    java.lang.Object ref = "";
-    if (messageRequestCase_ == 3) {
-      ref = messageRequest_;
-    }
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      if (messageRequestCase_ == 3) {
-        messageRequest_ = b;
-      }
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  public static final int FILE_CONTAINING_SYMBOL_FIELD_NUMBER = 4;
-  /**
-   * <pre>
-   * Find the proto file that declares the given fully-qualified symbol name.
-   * This field should be a fully-qualified symbol name
-   * (e.g. &lt;package&gt;.&lt;service&gt;[.&lt;method&gt;] or &lt;package&gt;.&lt;type&gt;).
-   * </pre>
-   *
-   * <code>string file_containing_symbol = 4;</code>
-   */
-  public java.lang.String getFileContainingSymbol() {
-    java.lang.Object ref = "";
-    if (messageRequestCase_ == 4) {
-      ref = messageRequest_;
-    }
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      if (messageRequestCase_ == 4) {
-        messageRequest_ = s;
-      }
-      return s;
-    }
-  }
-  /**
-   * <pre>
-   * Find the proto file that declares the given fully-qualified symbol name.
-   * This field should be a fully-qualified symbol name
-   * (e.g. &lt;package&gt;.&lt;service&gt;[.&lt;method&gt;] or &lt;package&gt;.&lt;type&gt;).
-   * </pre>
-   *
-   * <code>string file_containing_symbol = 4;</code>
-   */
-  public com.google.protobuf.ByteString
-      getFileContainingSymbolBytes() {
-    java.lang.Object ref = "";
-    if (messageRequestCase_ == 4) {
-      ref = messageRequest_;
-    }
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      if (messageRequestCase_ == 4) {
-        messageRequest_ = b;
-      }
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  public static final int FILE_CONTAINING_EXTENSION_FIELD_NUMBER = 5;
-  /**
-   * <pre>
-   * Find the proto file which defines an extension extending the given
-   * message type with the given field number.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;</code>
-   */
-  public io.grpc.reflection.v1alpha.ExtensionRequest getFileContainingExtension() {
-    if (messageRequestCase_ == 5) {
-       return (io.grpc.reflection.v1alpha.ExtensionRequest) messageRequest_;
-    }
-    return io.grpc.reflection.v1alpha.ExtensionRequest.getDefaultInstance();
-  }
-  /**
-   * <pre>
-   * Find the proto file which defines an extension extending the given
-   * message type with the given field number.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;</code>
-   */
-  public io.grpc.reflection.v1alpha.ExtensionRequestOrBuilder getFileContainingExtensionOrBuilder() {
-    if (messageRequestCase_ == 5) {
-       return (io.grpc.reflection.v1alpha.ExtensionRequest) messageRequest_;
-    }
-    return io.grpc.reflection.v1alpha.ExtensionRequest.getDefaultInstance();
-  }
-
-  public static final int ALL_EXTENSION_NUMBERS_OF_TYPE_FIELD_NUMBER = 6;
-  /**
-   * <pre>
-   * Finds the tag numbers used by all known extensions of extendee_type, and
-   * appends them to ExtensionNumberResponse in an undefined order.
-   * Its corresponding method is best-effort: it's not guaranteed that the
-   * reflection service will implement this method, and it's not guaranteed
-   * that this method will provide all extensions. Returns
-   * StatusCode::UNIMPLEMENTED if it's not implemented.
-   * This field should be a fully-qualified type name. The format is
-   * &lt;package&gt;.&lt;type&gt;
-   * </pre>
-   *
-   * <code>string all_extension_numbers_of_type = 6;</code>
-   */
-  public java.lang.String getAllExtensionNumbersOfType() {
-    java.lang.Object ref = "";
-    if (messageRequestCase_ == 6) {
-      ref = messageRequest_;
-    }
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      if (messageRequestCase_ == 6) {
-        messageRequest_ = s;
-      }
-      return s;
-    }
-  }
-  /**
-   * <pre>
-   * Finds the tag numbers used by all known extensions of extendee_type, and
-   * appends them to ExtensionNumberResponse in an undefined order.
-   * Its corresponding method is best-effort: it's not guaranteed that the
-   * reflection service will implement this method, and it's not guaranteed
-   * that this method will provide all extensions. Returns
-   * StatusCode::UNIMPLEMENTED if it's not implemented.
-   * This field should be a fully-qualified type name. The format is
-   * &lt;package&gt;.&lt;type&gt;
-   * </pre>
-   *
-   * <code>string all_extension_numbers_of_type = 6;</code>
-   */
-  public com.google.protobuf.ByteString
-      getAllExtensionNumbersOfTypeBytes() {
-    java.lang.Object ref = "";
-    if (messageRequestCase_ == 6) {
-      ref = messageRequest_;
-    }
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      if (messageRequestCase_ == 6) {
-        messageRequest_ = b;
-      }
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  public static final int LIST_SERVICES_FIELD_NUMBER = 7;
-  /**
-   * <pre>
-   * List the full names of registered services. The content will not be
-   * checked.
-   * </pre>
-   *
-   * <code>string list_services = 7;</code>
-   */
-  public java.lang.String getListServices() {
-    java.lang.Object ref = "";
-    if (messageRequestCase_ == 7) {
-      ref = messageRequest_;
-    }
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      if (messageRequestCase_ == 7) {
-        messageRequest_ = s;
-      }
-      return s;
-    }
-  }
-  /**
-   * <pre>
-   * List the full names of registered services. The content will not be
-   * checked.
-   * </pre>
-   *
-   * <code>string list_services = 7;</code>
-   */
-  public com.google.protobuf.ByteString
-      getListServicesBytes() {
-    java.lang.Object ref = "";
-    if (messageRequestCase_ == 7) {
-      ref = messageRequest_;
-    }
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      if (messageRequestCase_ == 7) {
-        messageRequest_ = b;
-      }
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (!getHostBytes().isEmpty()) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, host_);
-    }
-    if (messageRequestCase_ == 3) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 3, messageRequest_);
-    }
-    if (messageRequestCase_ == 4) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 4, messageRequest_);
-    }
-    if (messageRequestCase_ == 5) {
-      output.writeMessage(5, (io.grpc.reflection.v1alpha.ExtensionRequest) messageRequest_);
-    }
-    if (messageRequestCase_ == 6) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 6, messageRequest_);
-    }
-    if (messageRequestCase_ == 7) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 7, messageRequest_);
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (!getHostBytes().isEmpty()) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, host_);
-    }
-    if (messageRequestCase_ == 3) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, messageRequest_);
-    }
-    if (messageRequestCase_ == 4) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, messageRequest_);
-    }
-    if (messageRequestCase_ == 5) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(5, (io.grpc.reflection.v1alpha.ExtensionRequest) messageRequest_);
-    }
-    if (messageRequestCase_ == 6) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(6, messageRequest_);
-    }
-    if (messageRequestCase_ == 7) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(7, messageRequest_);
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.v1alpha.ServerReflectionRequest)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.v1alpha.ServerReflectionRequest other = (io.grpc.reflection.v1alpha.ServerReflectionRequest) obj;
-
-    boolean result = true;
-    result = result && getHost()
-        .equals(other.getHost());
-    result = result && getMessageRequestCase().equals(
-        other.getMessageRequestCase());
-    if (!result) return false;
-    switch (messageRequestCase_) {
-      case 3:
-        result = result && getFileByFilename()
-            .equals(other.getFileByFilename());
-        break;
-      case 4:
-        result = result && getFileContainingSymbol()
-            .equals(other.getFileContainingSymbol());
-        break;
-      case 5:
-        result = result && getFileContainingExtension()
-            .equals(other.getFileContainingExtension());
-        break;
-      case 6:
-        result = result && getAllExtensionNumbersOfType()
-            .equals(other.getAllExtensionNumbersOfType());
-        break;
-      case 7:
-        result = result && getListServices()
-            .equals(other.getListServices());
-        break;
-      case 0:
-      default:
-    }
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (37 * hash) + HOST_FIELD_NUMBER;
-    hash = (53 * hash) + getHost().hashCode();
-    switch (messageRequestCase_) {
-      case 3:
-        hash = (37 * hash) + FILE_BY_FILENAME_FIELD_NUMBER;
-        hash = (53 * hash) + getFileByFilename().hashCode();
-        break;
-      case 4:
-        hash = (37 * hash) + FILE_CONTAINING_SYMBOL_FIELD_NUMBER;
-        hash = (53 * hash) + getFileContainingSymbol().hashCode();
-        break;
-      case 5:
-        hash = (37 * hash) + FILE_CONTAINING_EXTENSION_FIELD_NUMBER;
-        hash = (53 * hash) + getFileContainingExtension().hashCode();
-        break;
-      case 6:
-        hash = (37 * hash) + ALL_EXTENSION_NUMBERS_OF_TYPE_FIELD_NUMBER;
-        hash = (53 * hash) + getAllExtensionNumbersOfType().hashCode();
-        break;
-      case 7:
-        hash = (37 * hash) + LIST_SERVICES_FIELD_NUMBER;
-        hash = (53 * hash) + getListServices().hashCode();
-        break;
-      case 0:
-      default:
-    }
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.v1alpha.ServerReflectionRequest parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionRequest parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionRequest parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionRequest parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionRequest parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionRequest parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionRequest parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionRequest parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionRequest parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionRequest parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.v1alpha.ServerReflectionRequest prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * <pre>
-   * The message sent by the client when calling ServerReflectionInfo method.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.reflection.v1alpha.ServerReflectionRequest}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.v1alpha.ServerReflectionRequest)
-      io.grpc.reflection.v1alpha.ServerReflectionRequestOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServerReflectionRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServerReflectionRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.v1alpha.ServerReflectionRequest.class, io.grpc.reflection.v1alpha.ServerReflectionRequest.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.v1alpha.ServerReflectionRequest.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      host_ = "";
-
-      messageRequestCase_ = 0;
-      messageRequest_ = null;
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServerReflectionRequest_descriptor;
-    }
-
-    public io.grpc.reflection.v1alpha.ServerReflectionRequest getDefaultInstanceForType() {
-      return io.grpc.reflection.v1alpha.ServerReflectionRequest.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.v1alpha.ServerReflectionRequest build() {
-      io.grpc.reflection.v1alpha.ServerReflectionRequest result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.v1alpha.ServerReflectionRequest buildPartial() {
-      io.grpc.reflection.v1alpha.ServerReflectionRequest result = new io.grpc.reflection.v1alpha.ServerReflectionRequest(this);
-      result.host_ = host_;
-      if (messageRequestCase_ == 3) {
-        result.messageRequest_ = messageRequest_;
-      }
-      if (messageRequestCase_ == 4) {
-        result.messageRequest_ = messageRequest_;
-      }
-      if (messageRequestCase_ == 5) {
-        if (fileContainingExtensionBuilder_ == null) {
-          result.messageRequest_ = messageRequest_;
-        } else {
-          result.messageRequest_ = fileContainingExtensionBuilder_.build();
-        }
-      }
-      if (messageRequestCase_ == 6) {
-        result.messageRequest_ = messageRequest_;
-      }
-      if (messageRequestCase_ == 7) {
-        result.messageRequest_ = messageRequest_;
-      }
-      result.messageRequestCase_ = messageRequestCase_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.v1alpha.ServerReflectionRequest) {
-        return mergeFrom((io.grpc.reflection.v1alpha.ServerReflectionRequest)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.v1alpha.ServerReflectionRequest other) {
-      if (other == io.grpc.reflection.v1alpha.ServerReflectionRequest.getDefaultInstance()) return this;
-      if (!other.getHost().isEmpty()) {
-        host_ = other.host_;
-        onChanged();
-      }
-      switch (other.getMessageRequestCase()) {
-        case FILE_BY_FILENAME: {
-          messageRequestCase_ = 3;
-          messageRequest_ = other.messageRequest_;
-          onChanged();
-          break;
-        }
-        case FILE_CONTAINING_SYMBOL: {
-          messageRequestCase_ = 4;
-          messageRequest_ = other.messageRequest_;
-          onChanged();
-          break;
-        }
-        case FILE_CONTAINING_EXTENSION: {
-          mergeFileContainingExtension(other.getFileContainingExtension());
-          break;
-        }
-        case ALL_EXTENSION_NUMBERS_OF_TYPE: {
-          messageRequestCase_ = 6;
-          messageRequest_ = other.messageRequest_;
-          onChanged();
-          break;
-        }
-        case LIST_SERVICES: {
-          messageRequestCase_ = 7;
-          messageRequest_ = other.messageRequest_;
-          onChanged();
-          break;
-        }
-        case MESSAGEREQUEST_NOT_SET: {
-          break;
-        }
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.v1alpha.ServerReflectionRequest parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.v1alpha.ServerReflectionRequest) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int messageRequestCase_ = 0;
-    private java.lang.Object messageRequest_;
-    public MessageRequestCase
-        getMessageRequestCase() {
-      return MessageRequestCase.forNumber(
-          messageRequestCase_);
-    }
-
-    public Builder clearMessageRequest() {
-      messageRequestCase_ = 0;
-      messageRequest_ = null;
-      onChanged();
-      return this;
-    }
-
-
-    private java.lang.Object host_ = "";
-    /**
-     * <code>string host = 1;</code>
-     */
-    public java.lang.String getHost() {
-      java.lang.Object ref = host_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        host_ = s;
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <code>string host = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getHostBytes() {
-      java.lang.Object ref = host_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        host_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <code>string host = 1;</code>
-     */
-    public Builder setHost(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  
-      host_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>string host = 1;</code>
-     */
-    public Builder clearHost() {
-      
-      host_ = getDefaultInstance().getHost();
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>string host = 1;</code>
-     */
-    public Builder setHostBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      
-      host_ = value;
-      onChanged();
-      return this;
-    }
-
-    /**
-     * <pre>
-     * Find a proto file by the file name.
-     * </pre>
-     *
-     * <code>string file_by_filename = 3;</code>
-     */
-    public java.lang.String getFileByFilename() {
-      java.lang.Object ref = "";
-      if (messageRequestCase_ == 3) {
-        ref = messageRequest_;
-      }
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        if (messageRequestCase_ == 3) {
-          messageRequest_ = s;
-        }
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Find a proto file by the file name.
-     * </pre>
-     *
-     * <code>string file_by_filename = 3;</code>
-     */
-    public com.google.protobuf.ByteString
-        getFileByFilenameBytes() {
-      java.lang.Object ref = "";
-      if (messageRequestCase_ == 3) {
-        ref = messageRequest_;
-      }
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        if (messageRequestCase_ == 3) {
-          messageRequest_ = b;
-        }
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Find a proto file by the file name.
-     * </pre>
-     *
-     * <code>string file_by_filename = 3;</code>
-     */
-    public Builder setFileByFilename(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  messageRequestCase_ = 3;
-      messageRequest_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Find a proto file by the file name.
-     * </pre>
-     *
-     * <code>string file_by_filename = 3;</code>
-     */
-    public Builder clearFileByFilename() {
-      if (messageRequestCase_ == 3) {
-        messageRequestCase_ = 0;
-        messageRequest_ = null;
-        onChanged();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Find a proto file by the file name.
-     * </pre>
-     *
-     * <code>string file_by_filename = 3;</code>
-     */
-    public Builder setFileByFilenameBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      messageRequestCase_ = 3;
-      messageRequest_ = value;
-      onChanged();
-      return this;
-    }
-
-    /**
-     * <pre>
-     * Find the proto file that declares the given fully-qualified symbol name.
-     * This field should be a fully-qualified symbol name
-     * (e.g. &lt;package&gt;.&lt;service&gt;[.&lt;method&gt;] or &lt;package&gt;.&lt;type&gt;).
-     * </pre>
-     *
-     * <code>string file_containing_symbol = 4;</code>
-     */
-    public java.lang.String getFileContainingSymbol() {
-      java.lang.Object ref = "";
-      if (messageRequestCase_ == 4) {
-        ref = messageRequest_;
-      }
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        if (messageRequestCase_ == 4) {
-          messageRequest_ = s;
-        }
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Find the proto file that declares the given fully-qualified symbol name.
-     * This field should be a fully-qualified symbol name
-     * (e.g. &lt;package&gt;.&lt;service&gt;[.&lt;method&gt;] or &lt;package&gt;.&lt;type&gt;).
-     * </pre>
-     *
-     * <code>string file_containing_symbol = 4;</code>
-     */
-    public com.google.protobuf.ByteString
-        getFileContainingSymbolBytes() {
-      java.lang.Object ref = "";
-      if (messageRequestCase_ == 4) {
-        ref = messageRequest_;
-      }
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        if (messageRequestCase_ == 4) {
-          messageRequest_ = b;
-        }
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Find the proto file that declares the given fully-qualified symbol name.
-     * This field should be a fully-qualified symbol name
-     * (e.g. &lt;package&gt;.&lt;service&gt;[.&lt;method&gt;] or &lt;package&gt;.&lt;type&gt;).
-     * </pre>
-     *
-     * <code>string file_containing_symbol = 4;</code>
-     */
-    public Builder setFileContainingSymbol(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  messageRequestCase_ = 4;
-      messageRequest_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Find the proto file that declares the given fully-qualified symbol name.
-     * This field should be a fully-qualified symbol name
-     * (e.g. &lt;package&gt;.&lt;service&gt;[.&lt;method&gt;] or &lt;package&gt;.&lt;type&gt;).
-     * </pre>
-     *
-     * <code>string file_containing_symbol = 4;</code>
-     */
-    public Builder clearFileContainingSymbol() {
-      if (messageRequestCase_ == 4) {
-        messageRequestCase_ = 0;
-        messageRequest_ = null;
-        onChanged();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Find the proto file that declares the given fully-qualified symbol name.
-     * This field should be a fully-qualified symbol name
-     * (e.g. &lt;package&gt;.&lt;service&gt;[.&lt;method&gt;] or &lt;package&gt;.&lt;type&gt;).
-     * </pre>
-     *
-     * <code>string file_containing_symbol = 4;</code>
-     */
-    public Builder setFileContainingSymbolBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      messageRequestCase_ = 4;
-      messageRequest_ = value;
-      onChanged();
-      return this;
-    }
-
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.reflection.v1alpha.ExtensionRequest, io.grpc.reflection.v1alpha.ExtensionRequest.Builder, io.grpc.reflection.v1alpha.ExtensionRequestOrBuilder> fileContainingExtensionBuilder_;
-    /**
-     * <pre>
-     * Find the proto file which defines an extension extending the given
-     * message type with the given field number.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;</code>
-     */
-    public io.grpc.reflection.v1alpha.ExtensionRequest getFileContainingExtension() {
-      if (fileContainingExtensionBuilder_ == null) {
-        if (messageRequestCase_ == 5) {
-          return (io.grpc.reflection.v1alpha.ExtensionRequest) messageRequest_;
-        }
-        return io.grpc.reflection.v1alpha.ExtensionRequest.getDefaultInstance();
-      } else {
-        if (messageRequestCase_ == 5) {
-          return fileContainingExtensionBuilder_.getMessage();
-        }
-        return io.grpc.reflection.v1alpha.ExtensionRequest.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * Find the proto file which defines an extension extending the given
-     * message type with the given field number.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;</code>
-     */
-    public Builder setFileContainingExtension(io.grpc.reflection.v1alpha.ExtensionRequest value) {
-      if (fileContainingExtensionBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        messageRequest_ = value;
-        onChanged();
-      } else {
-        fileContainingExtensionBuilder_.setMessage(value);
-      }
-      messageRequestCase_ = 5;
-      return this;
-    }
-    /**
-     * <pre>
-     * Find the proto file which defines an extension extending the given
-     * message type with the given field number.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;</code>
-     */
-    public Builder setFileContainingExtension(
-        io.grpc.reflection.v1alpha.ExtensionRequest.Builder builderForValue) {
-      if (fileContainingExtensionBuilder_ == null) {
-        messageRequest_ = builderForValue.build();
-        onChanged();
-      } else {
-        fileContainingExtensionBuilder_.setMessage(builderForValue.build());
-      }
-      messageRequestCase_ = 5;
-      return this;
-    }
-    /**
-     * <pre>
-     * Find the proto file which defines an extension extending the given
-     * message type with the given field number.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;</code>
-     */
-    public Builder mergeFileContainingExtension(io.grpc.reflection.v1alpha.ExtensionRequest value) {
-      if (fileContainingExtensionBuilder_ == null) {
-        if (messageRequestCase_ == 5 &&
-            messageRequest_ != io.grpc.reflection.v1alpha.ExtensionRequest.getDefaultInstance()) {
-          messageRequest_ = io.grpc.reflection.v1alpha.ExtensionRequest.newBuilder((io.grpc.reflection.v1alpha.ExtensionRequest) messageRequest_)
-              .mergeFrom(value).buildPartial();
-        } else {
-          messageRequest_ = value;
-        }
-        onChanged();
-      } else {
-        if (messageRequestCase_ == 5) {
-          fileContainingExtensionBuilder_.mergeFrom(value);
-        }
-        fileContainingExtensionBuilder_.setMessage(value);
-      }
-      messageRequestCase_ = 5;
-      return this;
-    }
-    /**
-     * <pre>
-     * Find the proto file which defines an extension extending the given
-     * message type with the given field number.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;</code>
-     */
-    public Builder clearFileContainingExtension() {
-      if (fileContainingExtensionBuilder_ == null) {
-        if (messageRequestCase_ == 5) {
-          messageRequestCase_ = 0;
-          messageRequest_ = null;
-          onChanged();
-        }
-      } else {
-        if (messageRequestCase_ == 5) {
-          messageRequestCase_ = 0;
-          messageRequest_ = null;
-        }
-        fileContainingExtensionBuilder_.clear();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Find the proto file which defines an extension extending the given
-     * message type with the given field number.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;</code>
-     */
-    public io.grpc.reflection.v1alpha.ExtensionRequest.Builder getFileContainingExtensionBuilder() {
-      return getFileContainingExtensionFieldBuilder().getBuilder();
-    }
-    /**
-     * <pre>
-     * Find the proto file which defines an extension extending the given
-     * message type with the given field number.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;</code>
-     */
-    public io.grpc.reflection.v1alpha.ExtensionRequestOrBuilder getFileContainingExtensionOrBuilder() {
-      if ((messageRequestCase_ == 5) && (fileContainingExtensionBuilder_ != null)) {
-        return fileContainingExtensionBuilder_.getMessageOrBuilder();
-      } else {
-        if (messageRequestCase_ == 5) {
-          return (io.grpc.reflection.v1alpha.ExtensionRequest) messageRequest_;
-        }
-        return io.grpc.reflection.v1alpha.ExtensionRequest.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * Find the proto file which defines an extension extending the given
-     * message type with the given field number.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;</code>
-     */
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.reflection.v1alpha.ExtensionRequest, io.grpc.reflection.v1alpha.ExtensionRequest.Builder, io.grpc.reflection.v1alpha.ExtensionRequestOrBuilder> 
-        getFileContainingExtensionFieldBuilder() {
-      if (fileContainingExtensionBuilder_ == null) {
-        if (!(messageRequestCase_ == 5)) {
-          messageRequest_ = io.grpc.reflection.v1alpha.ExtensionRequest.getDefaultInstance();
-        }
-        fileContainingExtensionBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-            io.grpc.reflection.v1alpha.ExtensionRequest, io.grpc.reflection.v1alpha.ExtensionRequest.Builder, io.grpc.reflection.v1alpha.ExtensionRequestOrBuilder>(
-                (io.grpc.reflection.v1alpha.ExtensionRequest) messageRequest_,
-                getParentForChildren(),
-                isClean());
-        messageRequest_ = null;
-      }
-      messageRequestCase_ = 5;
-      onChanged();;
-      return fileContainingExtensionBuilder_;
-    }
-
-    /**
-     * <pre>
-     * Finds the tag numbers used by all known extensions of extendee_type, and
-     * appends them to ExtensionNumberResponse in an undefined order.
-     * Its corresponding method is best-effort: it's not guaranteed that the
-     * reflection service will implement this method, and it's not guaranteed
-     * that this method will provide all extensions. Returns
-     * StatusCode::UNIMPLEMENTED if it's not implemented.
-     * This field should be a fully-qualified type name. The format is
-     * &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string all_extension_numbers_of_type = 6;</code>
-     */
-    public java.lang.String getAllExtensionNumbersOfType() {
-      java.lang.Object ref = "";
-      if (messageRequestCase_ == 6) {
-        ref = messageRequest_;
-      }
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        if (messageRequestCase_ == 6) {
-          messageRequest_ = s;
-        }
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Finds the tag numbers used by all known extensions of extendee_type, and
-     * appends them to ExtensionNumberResponse in an undefined order.
-     * Its corresponding method is best-effort: it's not guaranteed that the
-     * reflection service will implement this method, and it's not guaranteed
-     * that this method will provide all extensions. Returns
-     * StatusCode::UNIMPLEMENTED if it's not implemented.
-     * This field should be a fully-qualified type name. The format is
-     * &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string all_extension_numbers_of_type = 6;</code>
-     */
-    public com.google.protobuf.ByteString
-        getAllExtensionNumbersOfTypeBytes() {
-      java.lang.Object ref = "";
-      if (messageRequestCase_ == 6) {
-        ref = messageRequest_;
-      }
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        if (messageRequestCase_ == 6) {
-          messageRequest_ = b;
-        }
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Finds the tag numbers used by all known extensions of extendee_type, and
-     * appends them to ExtensionNumberResponse in an undefined order.
-     * Its corresponding method is best-effort: it's not guaranteed that the
-     * reflection service will implement this method, and it's not guaranteed
-     * that this method will provide all extensions. Returns
-     * StatusCode::UNIMPLEMENTED if it's not implemented.
-     * This field should be a fully-qualified type name. The format is
-     * &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string all_extension_numbers_of_type = 6;</code>
-     */
-    public Builder setAllExtensionNumbersOfType(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  messageRequestCase_ = 6;
-      messageRequest_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Finds the tag numbers used by all known extensions of extendee_type, and
-     * appends them to ExtensionNumberResponse in an undefined order.
-     * Its corresponding method is best-effort: it's not guaranteed that the
-     * reflection service will implement this method, and it's not guaranteed
-     * that this method will provide all extensions. Returns
-     * StatusCode::UNIMPLEMENTED if it's not implemented.
-     * This field should be a fully-qualified type name. The format is
-     * &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string all_extension_numbers_of_type = 6;</code>
-     */
-    public Builder clearAllExtensionNumbersOfType() {
-      if (messageRequestCase_ == 6) {
-        messageRequestCase_ = 0;
-        messageRequest_ = null;
-        onChanged();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * Finds the tag numbers used by all known extensions of extendee_type, and
-     * appends them to ExtensionNumberResponse in an undefined order.
-     * Its corresponding method is best-effort: it's not guaranteed that the
-     * reflection service will implement this method, and it's not guaranteed
-     * that this method will provide all extensions. Returns
-     * StatusCode::UNIMPLEMENTED if it's not implemented.
-     * This field should be a fully-qualified type name. The format is
-     * &lt;package&gt;.&lt;type&gt;
-     * </pre>
-     *
-     * <code>string all_extension_numbers_of_type = 6;</code>
-     */
-    public Builder setAllExtensionNumbersOfTypeBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      messageRequestCase_ = 6;
-      messageRequest_ = value;
-      onChanged();
-      return this;
-    }
-
-    /**
-     * <pre>
-     * List the full names of registered services. The content will not be
-     * checked.
-     * </pre>
-     *
-     * <code>string list_services = 7;</code>
-     */
-    public java.lang.String getListServices() {
-      java.lang.Object ref = "";
-      if (messageRequestCase_ == 7) {
-        ref = messageRequest_;
-      }
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        if (messageRequestCase_ == 7) {
-          messageRequest_ = s;
-        }
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <pre>
-     * List the full names of registered services. The content will not be
-     * checked.
-     * </pre>
-     *
-     * <code>string list_services = 7;</code>
-     */
-    public com.google.protobuf.ByteString
-        getListServicesBytes() {
-      java.lang.Object ref = "";
-      if (messageRequestCase_ == 7) {
-        ref = messageRequest_;
-      }
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        if (messageRequestCase_ == 7) {
-          messageRequest_ = b;
-        }
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <pre>
-     * List the full names of registered services. The content will not be
-     * checked.
-     * </pre>
-     *
-     * <code>string list_services = 7;</code>
-     */
-    public Builder setListServices(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  messageRequestCase_ = 7;
-      messageRequest_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * List the full names of registered services. The content will not be
-     * checked.
-     * </pre>
-     *
-     * <code>string list_services = 7;</code>
-     */
-    public Builder clearListServices() {
-      if (messageRequestCase_ == 7) {
-        messageRequestCase_ = 0;
-        messageRequest_ = null;
-        onChanged();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * List the full names of registered services. The content will not be
-     * checked.
-     * </pre>
-     *
-     * <code>string list_services = 7;</code>
-     */
-    public Builder setListServicesBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      messageRequestCase_ = 7;
-      messageRequest_ = value;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.v1alpha.ServerReflectionRequest)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.v1alpha.ServerReflectionRequest)
-  private static final io.grpc.reflection.v1alpha.ServerReflectionRequest DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.v1alpha.ServerReflectionRequest();
-  }
-
-  public static io.grpc.reflection.v1alpha.ServerReflectionRequest getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<ServerReflectionRequest>
-      PARSER = new com.google.protobuf.AbstractParser<ServerReflectionRequest>() {
-    public ServerReflectionRequest parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new ServerReflectionRequest(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<ServerReflectionRequest> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<ServerReflectionRequest> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.v1alpha.ServerReflectionRequest getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionRequestOrBuilder.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionRequestOrBuilder.java
deleted file mode 100644
index 9aa5514049e..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionRequestOrBuilder.java
+++ /dev/null
@@ -1,132 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-public interface ServerReflectionRequestOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.v1alpha.ServerReflectionRequest)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <code>string host = 1;</code>
-   */
-  java.lang.String getHost();
-  /**
-   * <code>string host = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getHostBytes();
-
-  /**
-   * <pre>
-   * Find a proto file by the file name.
-   * </pre>
-   *
-   * <code>string file_by_filename = 3;</code>
-   */
-  java.lang.String getFileByFilename();
-  /**
-   * <pre>
-   * Find a proto file by the file name.
-   * </pre>
-   *
-   * <code>string file_by_filename = 3;</code>
-   */
-  com.google.protobuf.ByteString
-      getFileByFilenameBytes();
-
-  /**
-   * <pre>
-   * Find the proto file that declares the given fully-qualified symbol name.
-   * This field should be a fully-qualified symbol name
-   * (e.g. &lt;package&gt;.&lt;service&gt;[.&lt;method&gt;] or &lt;package&gt;.&lt;type&gt;).
-   * </pre>
-   *
-   * <code>string file_containing_symbol = 4;</code>
-   */
-  java.lang.String getFileContainingSymbol();
-  /**
-   * <pre>
-   * Find the proto file that declares the given fully-qualified symbol name.
-   * This field should be a fully-qualified symbol name
-   * (e.g. &lt;package&gt;.&lt;service&gt;[.&lt;method&gt;] or &lt;package&gt;.&lt;type&gt;).
-   * </pre>
-   *
-   * <code>string file_containing_symbol = 4;</code>
-   */
-  com.google.protobuf.ByteString
-      getFileContainingSymbolBytes();
-
-  /**
-   * <pre>
-   * Find the proto file which defines an extension extending the given
-   * message type with the given field number.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;</code>
-   */
-  io.grpc.reflection.v1alpha.ExtensionRequest getFileContainingExtension();
-  /**
-   * <pre>
-   * Find the proto file which defines an extension extending the given
-   * message type with the given field number.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ExtensionRequest file_containing_extension = 5;</code>
-   */
-  io.grpc.reflection.v1alpha.ExtensionRequestOrBuilder getFileContainingExtensionOrBuilder();
-
-  /**
-   * <pre>
-   * Finds the tag numbers used by all known extensions of extendee_type, and
-   * appends them to ExtensionNumberResponse in an undefined order.
-   * Its corresponding method is best-effort: it's not guaranteed that the
-   * reflection service will implement this method, and it's not guaranteed
-   * that this method will provide all extensions. Returns
-   * StatusCode::UNIMPLEMENTED if it's not implemented.
-   * This field should be a fully-qualified type name. The format is
-   * &lt;package&gt;.&lt;type&gt;
-   * </pre>
-   *
-   * <code>string all_extension_numbers_of_type = 6;</code>
-   */
-  java.lang.String getAllExtensionNumbersOfType();
-  /**
-   * <pre>
-   * Finds the tag numbers used by all known extensions of extendee_type, and
-   * appends them to ExtensionNumberResponse in an undefined order.
-   * Its corresponding method is best-effort: it's not guaranteed that the
-   * reflection service will implement this method, and it's not guaranteed
-   * that this method will provide all extensions. Returns
-   * StatusCode::UNIMPLEMENTED if it's not implemented.
-   * This field should be a fully-qualified type name. The format is
-   * &lt;package&gt;.&lt;type&gt;
-   * </pre>
-   *
-   * <code>string all_extension_numbers_of_type = 6;</code>
-   */
-  com.google.protobuf.ByteString
-      getAllExtensionNumbersOfTypeBytes();
-
-  /**
-   * <pre>
-   * List the full names of registered services. The content will not be
-   * checked.
-   * </pre>
-   *
-   * <code>string list_services = 7;</code>
-   */
-  java.lang.String getListServices();
-  /**
-   * <pre>
-   * List the full names of registered services. The content will not be
-   * checked.
-   * </pre>
-   *
-   * <code>string list_services = 7;</code>
-   */
-  com.google.protobuf.ByteString
-      getListServicesBytes();
-
-  public io.grpc.reflection.v1alpha.ServerReflectionRequest.MessageRequestCase getMessageRequestCase();
-}
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionResponse.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionResponse.java
deleted file mode 100644
index ea494fecc64..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionResponse.java
+++ /dev/null
@@ -1,1729 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-/**
- * <pre>
- * The message sent by the server to answer ServerReflectionInfo method.
- * </pre>
- *
- * Protobuf type {@code grpc.reflection.v1alpha.ServerReflectionResponse}
- */
-public  final class ServerReflectionResponse extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.v1alpha.ServerReflectionResponse)
-    ServerReflectionResponseOrBuilder {
-  // Use ServerReflectionResponse.newBuilder() to construct.
-  private ServerReflectionResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private ServerReflectionResponse() {
-    validHost_ = "";
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private ServerReflectionResponse(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            java.lang.String s = input.readStringRequireUtf8();
-
-            validHost_ = s;
-            break;
-          }
-          case 18: {
-            io.grpc.reflection.v1alpha.ServerReflectionRequest.Builder subBuilder = null;
-            if (originalRequest_ != null) {
-              subBuilder = originalRequest_.toBuilder();
-            }
-            originalRequest_ = input.readMessage(io.grpc.reflection.v1alpha.ServerReflectionRequest.parser(), extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom(originalRequest_);
-              originalRequest_ = subBuilder.buildPartial();
-            }
-
-            break;
-          }
-          case 34: {
-            io.grpc.reflection.v1alpha.FileDescriptorResponse.Builder subBuilder = null;
-            if (messageResponseCase_ == 4) {
-              subBuilder = ((io.grpc.reflection.v1alpha.FileDescriptorResponse) messageResponse_).toBuilder();
-            }
-            messageResponse_ =
-                input.readMessage(io.grpc.reflection.v1alpha.FileDescriptorResponse.parser(), extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom((io.grpc.reflection.v1alpha.FileDescriptorResponse) messageResponse_);
-              messageResponse_ = subBuilder.buildPartial();
-            }
-            messageResponseCase_ = 4;
-            break;
-          }
-          case 42: {
-            io.grpc.reflection.v1alpha.ExtensionNumberResponse.Builder subBuilder = null;
-            if (messageResponseCase_ == 5) {
-              subBuilder = ((io.grpc.reflection.v1alpha.ExtensionNumberResponse) messageResponse_).toBuilder();
-            }
-            messageResponse_ =
-                input.readMessage(io.grpc.reflection.v1alpha.ExtensionNumberResponse.parser(), extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom((io.grpc.reflection.v1alpha.ExtensionNumberResponse) messageResponse_);
-              messageResponse_ = subBuilder.buildPartial();
-            }
-            messageResponseCase_ = 5;
-            break;
-          }
-          case 50: {
-            io.grpc.reflection.v1alpha.ListServiceResponse.Builder subBuilder = null;
-            if (messageResponseCase_ == 6) {
-              subBuilder = ((io.grpc.reflection.v1alpha.ListServiceResponse) messageResponse_).toBuilder();
-            }
-            messageResponse_ =
-                input.readMessage(io.grpc.reflection.v1alpha.ListServiceResponse.parser(), extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom((io.grpc.reflection.v1alpha.ListServiceResponse) messageResponse_);
-              messageResponse_ = subBuilder.buildPartial();
-            }
-            messageResponseCase_ = 6;
-            break;
-          }
-          case 58: {
-            io.grpc.reflection.v1alpha.ErrorResponse.Builder subBuilder = null;
-            if (messageResponseCase_ == 7) {
-              subBuilder = ((io.grpc.reflection.v1alpha.ErrorResponse) messageResponse_).toBuilder();
-            }
-            messageResponse_ =
-                input.readMessage(io.grpc.reflection.v1alpha.ErrorResponse.parser(), extensionRegistry);
-            if (subBuilder != null) {
-              subBuilder.mergeFrom((io.grpc.reflection.v1alpha.ErrorResponse) messageResponse_);
-              messageResponse_ = subBuilder.buildPartial();
-            }
-            messageResponseCase_ = 7;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServerReflectionResponse_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServerReflectionResponse_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.v1alpha.ServerReflectionResponse.class, io.grpc.reflection.v1alpha.ServerReflectionResponse.Builder.class);
-  }
-
-  private int messageResponseCase_ = 0;
-  private java.lang.Object messageResponse_;
-  public enum MessageResponseCase
-      implements com.google.protobuf.Internal.EnumLite {
-    FILE_DESCRIPTOR_RESPONSE(4),
-    ALL_EXTENSION_NUMBERS_RESPONSE(5),
-    LIST_SERVICES_RESPONSE(6),
-    ERROR_RESPONSE(7),
-    MESSAGERESPONSE_NOT_SET(0);
-    private final int value;
-    private MessageResponseCase(int value) {
-      this.value = value;
-    }
-    /**
-     * @deprecated Use {@link #forNumber(int)} instead.
-     */
-    @java.lang.Deprecated
-    public static MessageResponseCase valueOf(int value) {
-      return forNumber(value);
-    }
-
-    public static MessageResponseCase forNumber(int value) {
-      switch (value) {
-        case 4: return FILE_DESCRIPTOR_RESPONSE;
-        case 5: return ALL_EXTENSION_NUMBERS_RESPONSE;
-        case 6: return LIST_SERVICES_RESPONSE;
-        case 7: return ERROR_RESPONSE;
-        case 0: return MESSAGERESPONSE_NOT_SET;
-        default: return null;
-      }
-    }
-    public int getNumber() {
-      return this.value;
-    }
-  };
-
-  public MessageResponseCase
-  getMessageResponseCase() {
-    return MessageResponseCase.forNumber(
-        messageResponseCase_);
-  }
-
-  public static final int VALID_HOST_FIELD_NUMBER = 1;
-  private volatile java.lang.Object validHost_;
-  /**
-   * <code>string valid_host = 1;</code>
-   */
-  public java.lang.String getValidHost() {
-    java.lang.Object ref = validHost_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      validHost_ = s;
-      return s;
-    }
-  }
-  /**
-   * <code>string valid_host = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getValidHostBytes() {
-    java.lang.Object ref = validHost_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      validHost_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  public static final int ORIGINAL_REQUEST_FIELD_NUMBER = 2;
-  private io.grpc.reflection.v1alpha.ServerReflectionRequest originalRequest_;
-  /**
-   * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-   */
-  public boolean hasOriginalRequest() {
-    return originalRequest_ != null;
-  }
-  /**
-   * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-   */
-  public io.grpc.reflection.v1alpha.ServerReflectionRequest getOriginalRequest() {
-    return originalRequest_ == null ? io.grpc.reflection.v1alpha.ServerReflectionRequest.getDefaultInstance() : originalRequest_;
-  }
-  /**
-   * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-   */
-  public io.grpc.reflection.v1alpha.ServerReflectionRequestOrBuilder getOriginalRequestOrBuilder() {
-    return getOriginalRequest();
-  }
-
-  public static final int FILE_DESCRIPTOR_RESPONSE_FIELD_NUMBER = 4;
-  /**
-   * <pre>
-   * This message is used to answer file_by_filename, file_containing_symbol,
-   * file_containing_extension requests with transitive dependencies. As
-   * the repeated label is not allowed in oneof fields, we use a
-   * FileDescriptorResponse message to encapsulate the repeated fields.
-   * The reflection service is allowed to avoid sending FileDescriptorProtos
-   * that were previously sent in response to earlier requests in the stream.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;</code>
-   */
-  public io.grpc.reflection.v1alpha.FileDescriptorResponse getFileDescriptorResponse() {
-    if (messageResponseCase_ == 4) {
-       return (io.grpc.reflection.v1alpha.FileDescriptorResponse) messageResponse_;
-    }
-    return io.grpc.reflection.v1alpha.FileDescriptorResponse.getDefaultInstance();
-  }
-  /**
-   * <pre>
-   * This message is used to answer file_by_filename, file_containing_symbol,
-   * file_containing_extension requests with transitive dependencies. As
-   * the repeated label is not allowed in oneof fields, we use a
-   * FileDescriptorResponse message to encapsulate the repeated fields.
-   * The reflection service is allowed to avoid sending FileDescriptorProtos
-   * that were previously sent in response to earlier requests in the stream.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;</code>
-   */
-  public io.grpc.reflection.v1alpha.FileDescriptorResponseOrBuilder getFileDescriptorResponseOrBuilder() {
-    if (messageResponseCase_ == 4) {
-       return (io.grpc.reflection.v1alpha.FileDescriptorResponse) messageResponse_;
-    }
-    return io.grpc.reflection.v1alpha.FileDescriptorResponse.getDefaultInstance();
-  }
-
-  public static final int ALL_EXTENSION_NUMBERS_RESPONSE_FIELD_NUMBER = 5;
-  /**
-   * <pre>
-   * This message is used to answer all_extension_numbers_of_type requst.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;</code>
-   */
-  public io.grpc.reflection.v1alpha.ExtensionNumberResponse getAllExtensionNumbersResponse() {
-    if (messageResponseCase_ == 5) {
-       return (io.grpc.reflection.v1alpha.ExtensionNumberResponse) messageResponse_;
-    }
-    return io.grpc.reflection.v1alpha.ExtensionNumberResponse.getDefaultInstance();
-  }
-  /**
-   * <pre>
-   * This message is used to answer all_extension_numbers_of_type requst.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;</code>
-   */
-  public io.grpc.reflection.v1alpha.ExtensionNumberResponseOrBuilder getAllExtensionNumbersResponseOrBuilder() {
-    if (messageResponseCase_ == 5) {
-       return (io.grpc.reflection.v1alpha.ExtensionNumberResponse) messageResponse_;
-    }
-    return io.grpc.reflection.v1alpha.ExtensionNumberResponse.getDefaultInstance();
-  }
-
-  public static final int LIST_SERVICES_RESPONSE_FIELD_NUMBER = 6;
-  /**
-   * <pre>
-   * This message is used to answer list_services request.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;</code>
-   */
-  public io.grpc.reflection.v1alpha.ListServiceResponse getListServicesResponse() {
-    if (messageResponseCase_ == 6) {
-       return (io.grpc.reflection.v1alpha.ListServiceResponse) messageResponse_;
-    }
-    return io.grpc.reflection.v1alpha.ListServiceResponse.getDefaultInstance();
-  }
-  /**
-   * <pre>
-   * This message is used to answer list_services request.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;</code>
-   */
-  public io.grpc.reflection.v1alpha.ListServiceResponseOrBuilder getListServicesResponseOrBuilder() {
-    if (messageResponseCase_ == 6) {
-       return (io.grpc.reflection.v1alpha.ListServiceResponse) messageResponse_;
-    }
-    return io.grpc.reflection.v1alpha.ListServiceResponse.getDefaultInstance();
-  }
-
-  public static final int ERROR_RESPONSE_FIELD_NUMBER = 7;
-  /**
-   * <pre>
-   * This message is used when an error occurs.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ErrorResponse error_response = 7;</code>
-   */
-  public io.grpc.reflection.v1alpha.ErrorResponse getErrorResponse() {
-    if (messageResponseCase_ == 7) {
-       return (io.grpc.reflection.v1alpha.ErrorResponse) messageResponse_;
-    }
-    return io.grpc.reflection.v1alpha.ErrorResponse.getDefaultInstance();
-  }
-  /**
-   * <pre>
-   * This message is used when an error occurs.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ErrorResponse error_response = 7;</code>
-   */
-  public io.grpc.reflection.v1alpha.ErrorResponseOrBuilder getErrorResponseOrBuilder() {
-    if (messageResponseCase_ == 7) {
-       return (io.grpc.reflection.v1alpha.ErrorResponse) messageResponse_;
-    }
-    return io.grpc.reflection.v1alpha.ErrorResponse.getDefaultInstance();
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (!getValidHostBytes().isEmpty()) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, validHost_);
-    }
-    if (originalRequest_ != null) {
-      output.writeMessage(2, getOriginalRequest());
-    }
-    if (messageResponseCase_ == 4) {
-      output.writeMessage(4, (io.grpc.reflection.v1alpha.FileDescriptorResponse) messageResponse_);
-    }
-    if (messageResponseCase_ == 5) {
-      output.writeMessage(5, (io.grpc.reflection.v1alpha.ExtensionNumberResponse) messageResponse_);
-    }
-    if (messageResponseCase_ == 6) {
-      output.writeMessage(6, (io.grpc.reflection.v1alpha.ListServiceResponse) messageResponse_);
-    }
-    if (messageResponseCase_ == 7) {
-      output.writeMessage(7, (io.grpc.reflection.v1alpha.ErrorResponse) messageResponse_);
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (!getValidHostBytes().isEmpty()) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, validHost_);
-    }
-    if (originalRequest_ != null) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(2, getOriginalRequest());
-    }
-    if (messageResponseCase_ == 4) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(4, (io.grpc.reflection.v1alpha.FileDescriptorResponse) messageResponse_);
-    }
-    if (messageResponseCase_ == 5) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(5, (io.grpc.reflection.v1alpha.ExtensionNumberResponse) messageResponse_);
-    }
-    if (messageResponseCase_ == 6) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(6, (io.grpc.reflection.v1alpha.ListServiceResponse) messageResponse_);
-    }
-    if (messageResponseCase_ == 7) {
-      size += com.google.protobuf.CodedOutputStream
-        .computeMessageSize(7, (io.grpc.reflection.v1alpha.ErrorResponse) messageResponse_);
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.v1alpha.ServerReflectionResponse)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.v1alpha.ServerReflectionResponse other = (io.grpc.reflection.v1alpha.ServerReflectionResponse) obj;
-
-    boolean result = true;
-    result = result && getValidHost()
-        .equals(other.getValidHost());
-    result = result && (hasOriginalRequest() == other.hasOriginalRequest());
-    if (hasOriginalRequest()) {
-      result = result && getOriginalRequest()
-          .equals(other.getOriginalRequest());
-    }
-    result = result && getMessageResponseCase().equals(
-        other.getMessageResponseCase());
-    if (!result) return false;
-    switch (messageResponseCase_) {
-      case 4:
-        result = result && getFileDescriptorResponse()
-            .equals(other.getFileDescriptorResponse());
-        break;
-      case 5:
-        result = result && getAllExtensionNumbersResponse()
-            .equals(other.getAllExtensionNumbersResponse());
-        break;
-      case 6:
-        result = result && getListServicesResponse()
-            .equals(other.getListServicesResponse());
-        break;
-      case 7:
-        result = result && getErrorResponse()
-            .equals(other.getErrorResponse());
-        break;
-      case 0:
-      default:
-    }
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (37 * hash) + VALID_HOST_FIELD_NUMBER;
-    hash = (53 * hash) + getValidHost().hashCode();
-    if (hasOriginalRequest()) {
-      hash = (37 * hash) + ORIGINAL_REQUEST_FIELD_NUMBER;
-      hash = (53 * hash) + getOriginalRequest().hashCode();
-    }
-    switch (messageResponseCase_) {
-      case 4:
-        hash = (37 * hash) + FILE_DESCRIPTOR_RESPONSE_FIELD_NUMBER;
-        hash = (53 * hash) + getFileDescriptorResponse().hashCode();
-        break;
-      case 5:
-        hash = (37 * hash) + ALL_EXTENSION_NUMBERS_RESPONSE_FIELD_NUMBER;
-        hash = (53 * hash) + getAllExtensionNumbersResponse().hashCode();
-        break;
-      case 6:
-        hash = (37 * hash) + LIST_SERVICES_RESPONSE_FIELD_NUMBER;
-        hash = (53 * hash) + getListServicesResponse().hashCode();
-        break;
-      case 7:
-        hash = (37 * hash) + ERROR_RESPONSE_FIELD_NUMBER;
-        hash = (53 * hash) + getErrorResponse().hashCode();
-        break;
-      case 0:
-      default:
-    }
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.v1alpha.ServerReflectionResponse parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionResponse parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionResponse parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionResponse parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionResponse parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionResponse parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionResponse parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionResponse parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionResponse parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ServerReflectionResponse parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.v1alpha.ServerReflectionResponse prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * <pre>
-   * The message sent by the server to answer ServerReflectionInfo method.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.reflection.v1alpha.ServerReflectionResponse}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.v1alpha.ServerReflectionResponse)
-      io.grpc.reflection.v1alpha.ServerReflectionResponseOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServerReflectionResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServerReflectionResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.v1alpha.ServerReflectionResponse.class, io.grpc.reflection.v1alpha.ServerReflectionResponse.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.v1alpha.ServerReflectionResponse.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      validHost_ = "";
-
-      if (originalRequestBuilder_ == null) {
-        originalRequest_ = null;
-      } else {
-        originalRequest_ = null;
-        originalRequestBuilder_ = null;
-      }
-      messageResponseCase_ = 0;
-      messageResponse_ = null;
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServerReflectionResponse_descriptor;
-    }
-
-    public io.grpc.reflection.v1alpha.ServerReflectionResponse getDefaultInstanceForType() {
-      return io.grpc.reflection.v1alpha.ServerReflectionResponse.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.v1alpha.ServerReflectionResponse build() {
-      io.grpc.reflection.v1alpha.ServerReflectionResponse result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.v1alpha.ServerReflectionResponse buildPartial() {
-      io.grpc.reflection.v1alpha.ServerReflectionResponse result = new io.grpc.reflection.v1alpha.ServerReflectionResponse(this);
-      result.validHost_ = validHost_;
-      if (originalRequestBuilder_ == null) {
-        result.originalRequest_ = originalRequest_;
-      } else {
-        result.originalRequest_ = originalRequestBuilder_.build();
-      }
-      if (messageResponseCase_ == 4) {
-        if (fileDescriptorResponseBuilder_ == null) {
-          result.messageResponse_ = messageResponse_;
-        } else {
-          result.messageResponse_ = fileDescriptorResponseBuilder_.build();
-        }
-      }
-      if (messageResponseCase_ == 5) {
-        if (allExtensionNumbersResponseBuilder_ == null) {
-          result.messageResponse_ = messageResponse_;
-        } else {
-          result.messageResponse_ = allExtensionNumbersResponseBuilder_.build();
-        }
-      }
-      if (messageResponseCase_ == 6) {
-        if (listServicesResponseBuilder_ == null) {
-          result.messageResponse_ = messageResponse_;
-        } else {
-          result.messageResponse_ = listServicesResponseBuilder_.build();
-        }
-      }
-      if (messageResponseCase_ == 7) {
-        if (errorResponseBuilder_ == null) {
-          result.messageResponse_ = messageResponse_;
-        } else {
-          result.messageResponse_ = errorResponseBuilder_.build();
-        }
-      }
-      result.messageResponseCase_ = messageResponseCase_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.v1alpha.ServerReflectionResponse) {
-        return mergeFrom((io.grpc.reflection.v1alpha.ServerReflectionResponse)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.v1alpha.ServerReflectionResponse other) {
-      if (other == io.grpc.reflection.v1alpha.ServerReflectionResponse.getDefaultInstance()) return this;
-      if (!other.getValidHost().isEmpty()) {
-        validHost_ = other.validHost_;
-        onChanged();
-      }
-      if (other.hasOriginalRequest()) {
-        mergeOriginalRequest(other.getOriginalRequest());
-      }
-      switch (other.getMessageResponseCase()) {
-        case FILE_DESCRIPTOR_RESPONSE: {
-          mergeFileDescriptorResponse(other.getFileDescriptorResponse());
-          break;
-        }
-        case ALL_EXTENSION_NUMBERS_RESPONSE: {
-          mergeAllExtensionNumbersResponse(other.getAllExtensionNumbersResponse());
-          break;
-        }
-        case LIST_SERVICES_RESPONSE: {
-          mergeListServicesResponse(other.getListServicesResponse());
-          break;
-        }
-        case ERROR_RESPONSE: {
-          mergeErrorResponse(other.getErrorResponse());
-          break;
-        }
-        case MESSAGERESPONSE_NOT_SET: {
-          break;
-        }
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.v1alpha.ServerReflectionResponse parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.v1alpha.ServerReflectionResponse) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int messageResponseCase_ = 0;
-    private java.lang.Object messageResponse_;
-    public MessageResponseCase
-        getMessageResponseCase() {
-      return MessageResponseCase.forNumber(
-          messageResponseCase_);
-    }
-
-    public Builder clearMessageResponse() {
-      messageResponseCase_ = 0;
-      messageResponse_ = null;
-      onChanged();
-      return this;
-    }
-
-
-    private java.lang.Object validHost_ = "";
-    /**
-     * <code>string valid_host = 1;</code>
-     */
-    public java.lang.String getValidHost() {
-      java.lang.Object ref = validHost_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        validHost_ = s;
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <code>string valid_host = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getValidHostBytes() {
-      java.lang.Object ref = validHost_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        validHost_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <code>string valid_host = 1;</code>
-     */
-    public Builder setValidHost(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  
-      validHost_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>string valid_host = 1;</code>
-     */
-    public Builder clearValidHost() {
-      
-      validHost_ = getDefaultInstance().getValidHost();
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>string valid_host = 1;</code>
-     */
-    public Builder setValidHostBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      
-      validHost_ = value;
-      onChanged();
-      return this;
-    }
-
-    private io.grpc.reflection.v1alpha.ServerReflectionRequest originalRequest_ = null;
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.reflection.v1alpha.ServerReflectionRequest, io.grpc.reflection.v1alpha.ServerReflectionRequest.Builder, io.grpc.reflection.v1alpha.ServerReflectionRequestOrBuilder> originalRequestBuilder_;
-    /**
-     * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-     */
-    public boolean hasOriginalRequest() {
-      return originalRequestBuilder_ != null || originalRequest_ != null;
-    }
-    /**
-     * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-     */
-    public io.grpc.reflection.v1alpha.ServerReflectionRequest getOriginalRequest() {
-      if (originalRequestBuilder_ == null) {
-        return originalRequest_ == null ? io.grpc.reflection.v1alpha.ServerReflectionRequest.getDefaultInstance() : originalRequest_;
-      } else {
-        return originalRequestBuilder_.getMessage();
-      }
-    }
-    /**
-     * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-     */
-    public Builder setOriginalRequest(io.grpc.reflection.v1alpha.ServerReflectionRequest value) {
-      if (originalRequestBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        originalRequest_ = value;
-        onChanged();
-      } else {
-        originalRequestBuilder_.setMessage(value);
-      }
-
-      return this;
-    }
-    /**
-     * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-     */
-    public Builder setOriginalRequest(
-        io.grpc.reflection.v1alpha.ServerReflectionRequest.Builder builderForValue) {
-      if (originalRequestBuilder_ == null) {
-        originalRequest_ = builderForValue.build();
-        onChanged();
-      } else {
-        originalRequestBuilder_.setMessage(builderForValue.build());
-      }
-
-      return this;
-    }
-    /**
-     * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-     */
-    public Builder mergeOriginalRequest(io.grpc.reflection.v1alpha.ServerReflectionRequest value) {
-      if (originalRequestBuilder_ == null) {
-        if (originalRequest_ != null) {
-          originalRequest_ =
-            io.grpc.reflection.v1alpha.ServerReflectionRequest.newBuilder(originalRequest_).mergeFrom(value).buildPartial();
-        } else {
-          originalRequest_ = value;
-        }
-        onChanged();
-      } else {
-        originalRequestBuilder_.mergeFrom(value);
-      }
-
-      return this;
-    }
-    /**
-     * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-     */
-    public Builder clearOriginalRequest() {
-      if (originalRequestBuilder_ == null) {
-        originalRequest_ = null;
-        onChanged();
-      } else {
-        originalRequest_ = null;
-        originalRequestBuilder_ = null;
-      }
-
-      return this;
-    }
-    /**
-     * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-     */
-    public io.grpc.reflection.v1alpha.ServerReflectionRequest.Builder getOriginalRequestBuilder() {
-      
-      onChanged();
-      return getOriginalRequestFieldBuilder().getBuilder();
-    }
-    /**
-     * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-     */
-    public io.grpc.reflection.v1alpha.ServerReflectionRequestOrBuilder getOriginalRequestOrBuilder() {
-      if (originalRequestBuilder_ != null) {
-        return originalRequestBuilder_.getMessageOrBuilder();
-      } else {
-        return originalRequest_ == null ?
-            io.grpc.reflection.v1alpha.ServerReflectionRequest.getDefaultInstance() : originalRequest_;
-      }
-    }
-    /**
-     * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-     */
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.reflection.v1alpha.ServerReflectionRequest, io.grpc.reflection.v1alpha.ServerReflectionRequest.Builder, io.grpc.reflection.v1alpha.ServerReflectionRequestOrBuilder> 
-        getOriginalRequestFieldBuilder() {
-      if (originalRequestBuilder_ == null) {
-        originalRequestBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-            io.grpc.reflection.v1alpha.ServerReflectionRequest, io.grpc.reflection.v1alpha.ServerReflectionRequest.Builder, io.grpc.reflection.v1alpha.ServerReflectionRequestOrBuilder>(
-                getOriginalRequest(),
-                getParentForChildren(),
-                isClean());
-        originalRequest_ = null;
-      }
-      return originalRequestBuilder_;
-    }
-
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.reflection.v1alpha.FileDescriptorResponse, io.grpc.reflection.v1alpha.FileDescriptorResponse.Builder, io.grpc.reflection.v1alpha.FileDescriptorResponseOrBuilder> fileDescriptorResponseBuilder_;
-    /**
-     * <pre>
-     * This message is used to answer file_by_filename, file_containing_symbol,
-     * file_containing_extension requests with transitive dependencies. As
-     * the repeated label is not allowed in oneof fields, we use a
-     * FileDescriptorResponse message to encapsulate the repeated fields.
-     * The reflection service is allowed to avoid sending FileDescriptorProtos
-     * that were previously sent in response to earlier requests in the stream.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;</code>
-     */
-    public io.grpc.reflection.v1alpha.FileDescriptorResponse getFileDescriptorResponse() {
-      if (fileDescriptorResponseBuilder_ == null) {
-        if (messageResponseCase_ == 4) {
-          return (io.grpc.reflection.v1alpha.FileDescriptorResponse) messageResponse_;
-        }
-        return io.grpc.reflection.v1alpha.FileDescriptorResponse.getDefaultInstance();
-      } else {
-        if (messageResponseCase_ == 4) {
-          return fileDescriptorResponseBuilder_.getMessage();
-        }
-        return io.grpc.reflection.v1alpha.FileDescriptorResponse.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * This message is used to answer file_by_filename, file_containing_symbol,
-     * file_containing_extension requests with transitive dependencies. As
-     * the repeated label is not allowed in oneof fields, we use a
-     * FileDescriptorResponse message to encapsulate the repeated fields.
-     * The reflection service is allowed to avoid sending FileDescriptorProtos
-     * that were previously sent in response to earlier requests in the stream.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;</code>
-     */
-    public Builder setFileDescriptorResponse(io.grpc.reflection.v1alpha.FileDescriptorResponse value) {
-      if (fileDescriptorResponseBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        messageResponse_ = value;
-        onChanged();
-      } else {
-        fileDescriptorResponseBuilder_.setMessage(value);
-      }
-      messageResponseCase_ = 4;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used to answer file_by_filename, file_containing_symbol,
-     * file_containing_extension requests with transitive dependencies. As
-     * the repeated label is not allowed in oneof fields, we use a
-     * FileDescriptorResponse message to encapsulate the repeated fields.
-     * The reflection service is allowed to avoid sending FileDescriptorProtos
-     * that were previously sent in response to earlier requests in the stream.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;</code>
-     */
-    public Builder setFileDescriptorResponse(
-        io.grpc.reflection.v1alpha.FileDescriptorResponse.Builder builderForValue) {
-      if (fileDescriptorResponseBuilder_ == null) {
-        messageResponse_ = builderForValue.build();
-        onChanged();
-      } else {
-        fileDescriptorResponseBuilder_.setMessage(builderForValue.build());
-      }
-      messageResponseCase_ = 4;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used to answer file_by_filename, file_containing_symbol,
-     * file_containing_extension requests with transitive dependencies. As
-     * the repeated label is not allowed in oneof fields, we use a
-     * FileDescriptorResponse message to encapsulate the repeated fields.
-     * The reflection service is allowed to avoid sending FileDescriptorProtos
-     * that were previously sent in response to earlier requests in the stream.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;</code>
-     */
-    public Builder mergeFileDescriptorResponse(io.grpc.reflection.v1alpha.FileDescriptorResponse value) {
-      if (fileDescriptorResponseBuilder_ == null) {
-        if (messageResponseCase_ == 4 &&
-            messageResponse_ != io.grpc.reflection.v1alpha.FileDescriptorResponse.getDefaultInstance()) {
-          messageResponse_ = io.grpc.reflection.v1alpha.FileDescriptorResponse.newBuilder((io.grpc.reflection.v1alpha.FileDescriptorResponse) messageResponse_)
-              .mergeFrom(value).buildPartial();
-        } else {
-          messageResponse_ = value;
-        }
-        onChanged();
-      } else {
-        if (messageResponseCase_ == 4) {
-          fileDescriptorResponseBuilder_.mergeFrom(value);
-        }
-        fileDescriptorResponseBuilder_.setMessage(value);
-      }
-      messageResponseCase_ = 4;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used to answer file_by_filename, file_containing_symbol,
-     * file_containing_extension requests with transitive dependencies. As
-     * the repeated label is not allowed in oneof fields, we use a
-     * FileDescriptorResponse message to encapsulate the repeated fields.
-     * The reflection service is allowed to avoid sending FileDescriptorProtos
-     * that were previously sent in response to earlier requests in the stream.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;</code>
-     */
-    public Builder clearFileDescriptorResponse() {
-      if (fileDescriptorResponseBuilder_ == null) {
-        if (messageResponseCase_ == 4) {
-          messageResponseCase_ = 0;
-          messageResponse_ = null;
-          onChanged();
-        }
-      } else {
-        if (messageResponseCase_ == 4) {
-          messageResponseCase_ = 0;
-          messageResponse_ = null;
-        }
-        fileDescriptorResponseBuilder_.clear();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used to answer file_by_filename, file_containing_symbol,
-     * file_containing_extension requests with transitive dependencies. As
-     * the repeated label is not allowed in oneof fields, we use a
-     * FileDescriptorResponse message to encapsulate the repeated fields.
-     * The reflection service is allowed to avoid sending FileDescriptorProtos
-     * that were previously sent in response to earlier requests in the stream.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;</code>
-     */
-    public io.grpc.reflection.v1alpha.FileDescriptorResponse.Builder getFileDescriptorResponseBuilder() {
-      return getFileDescriptorResponseFieldBuilder().getBuilder();
-    }
-    /**
-     * <pre>
-     * This message is used to answer file_by_filename, file_containing_symbol,
-     * file_containing_extension requests with transitive dependencies. As
-     * the repeated label is not allowed in oneof fields, we use a
-     * FileDescriptorResponse message to encapsulate the repeated fields.
-     * The reflection service is allowed to avoid sending FileDescriptorProtos
-     * that were previously sent in response to earlier requests in the stream.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;</code>
-     */
-    public io.grpc.reflection.v1alpha.FileDescriptorResponseOrBuilder getFileDescriptorResponseOrBuilder() {
-      if ((messageResponseCase_ == 4) && (fileDescriptorResponseBuilder_ != null)) {
-        return fileDescriptorResponseBuilder_.getMessageOrBuilder();
-      } else {
-        if (messageResponseCase_ == 4) {
-          return (io.grpc.reflection.v1alpha.FileDescriptorResponse) messageResponse_;
-        }
-        return io.grpc.reflection.v1alpha.FileDescriptorResponse.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * This message is used to answer file_by_filename, file_containing_symbol,
-     * file_containing_extension requests with transitive dependencies. As
-     * the repeated label is not allowed in oneof fields, we use a
-     * FileDescriptorResponse message to encapsulate the repeated fields.
-     * The reflection service is allowed to avoid sending FileDescriptorProtos
-     * that were previously sent in response to earlier requests in the stream.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;</code>
-     */
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.reflection.v1alpha.FileDescriptorResponse, io.grpc.reflection.v1alpha.FileDescriptorResponse.Builder, io.grpc.reflection.v1alpha.FileDescriptorResponseOrBuilder> 
-        getFileDescriptorResponseFieldBuilder() {
-      if (fileDescriptorResponseBuilder_ == null) {
-        if (!(messageResponseCase_ == 4)) {
-          messageResponse_ = io.grpc.reflection.v1alpha.FileDescriptorResponse.getDefaultInstance();
-        }
-        fileDescriptorResponseBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-            io.grpc.reflection.v1alpha.FileDescriptorResponse, io.grpc.reflection.v1alpha.FileDescriptorResponse.Builder, io.grpc.reflection.v1alpha.FileDescriptorResponseOrBuilder>(
-                (io.grpc.reflection.v1alpha.FileDescriptorResponse) messageResponse_,
-                getParentForChildren(),
-                isClean());
-        messageResponse_ = null;
-      }
-      messageResponseCase_ = 4;
-      onChanged();;
-      return fileDescriptorResponseBuilder_;
-    }
-
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.reflection.v1alpha.ExtensionNumberResponse, io.grpc.reflection.v1alpha.ExtensionNumberResponse.Builder, io.grpc.reflection.v1alpha.ExtensionNumberResponseOrBuilder> allExtensionNumbersResponseBuilder_;
-    /**
-     * <pre>
-     * This message is used to answer all_extension_numbers_of_type requst.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;</code>
-     */
-    public io.grpc.reflection.v1alpha.ExtensionNumberResponse getAllExtensionNumbersResponse() {
-      if (allExtensionNumbersResponseBuilder_ == null) {
-        if (messageResponseCase_ == 5) {
-          return (io.grpc.reflection.v1alpha.ExtensionNumberResponse) messageResponse_;
-        }
-        return io.grpc.reflection.v1alpha.ExtensionNumberResponse.getDefaultInstance();
-      } else {
-        if (messageResponseCase_ == 5) {
-          return allExtensionNumbersResponseBuilder_.getMessage();
-        }
-        return io.grpc.reflection.v1alpha.ExtensionNumberResponse.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * This message is used to answer all_extension_numbers_of_type requst.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;</code>
-     */
-    public Builder setAllExtensionNumbersResponse(io.grpc.reflection.v1alpha.ExtensionNumberResponse value) {
-      if (allExtensionNumbersResponseBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        messageResponse_ = value;
-        onChanged();
-      } else {
-        allExtensionNumbersResponseBuilder_.setMessage(value);
-      }
-      messageResponseCase_ = 5;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used to answer all_extension_numbers_of_type requst.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;</code>
-     */
-    public Builder setAllExtensionNumbersResponse(
-        io.grpc.reflection.v1alpha.ExtensionNumberResponse.Builder builderForValue) {
-      if (allExtensionNumbersResponseBuilder_ == null) {
-        messageResponse_ = builderForValue.build();
-        onChanged();
-      } else {
-        allExtensionNumbersResponseBuilder_.setMessage(builderForValue.build());
-      }
-      messageResponseCase_ = 5;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used to answer all_extension_numbers_of_type requst.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;</code>
-     */
-    public Builder mergeAllExtensionNumbersResponse(io.grpc.reflection.v1alpha.ExtensionNumberResponse value) {
-      if (allExtensionNumbersResponseBuilder_ == null) {
-        if (messageResponseCase_ == 5 &&
-            messageResponse_ != io.grpc.reflection.v1alpha.ExtensionNumberResponse.getDefaultInstance()) {
-          messageResponse_ = io.grpc.reflection.v1alpha.ExtensionNumberResponse.newBuilder((io.grpc.reflection.v1alpha.ExtensionNumberResponse) messageResponse_)
-              .mergeFrom(value).buildPartial();
-        } else {
-          messageResponse_ = value;
-        }
-        onChanged();
-      } else {
-        if (messageResponseCase_ == 5) {
-          allExtensionNumbersResponseBuilder_.mergeFrom(value);
-        }
-        allExtensionNumbersResponseBuilder_.setMessage(value);
-      }
-      messageResponseCase_ = 5;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used to answer all_extension_numbers_of_type requst.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;</code>
-     */
-    public Builder clearAllExtensionNumbersResponse() {
-      if (allExtensionNumbersResponseBuilder_ == null) {
-        if (messageResponseCase_ == 5) {
-          messageResponseCase_ = 0;
-          messageResponse_ = null;
-          onChanged();
-        }
-      } else {
-        if (messageResponseCase_ == 5) {
-          messageResponseCase_ = 0;
-          messageResponse_ = null;
-        }
-        allExtensionNumbersResponseBuilder_.clear();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used to answer all_extension_numbers_of_type requst.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;</code>
-     */
-    public io.grpc.reflection.v1alpha.ExtensionNumberResponse.Builder getAllExtensionNumbersResponseBuilder() {
-      return getAllExtensionNumbersResponseFieldBuilder().getBuilder();
-    }
-    /**
-     * <pre>
-     * This message is used to answer all_extension_numbers_of_type requst.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;</code>
-     */
-    public io.grpc.reflection.v1alpha.ExtensionNumberResponseOrBuilder getAllExtensionNumbersResponseOrBuilder() {
-      if ((messageResponseCase_ == 5) && (allExtensionNumbersResponseBuilder_ != null)) {
-        return allExtensionNumbersResponseBuilder_.getMessageOrBuilder();
-      } else {
-        if (messageResponseCase_ == 5) {
-          return (io.grpc.reflection.v1alpha.ExtensionNumberResponse) messageResponse_;
-        }
-        return io.grpc.reflection.v1alpha.ExtensionNumberResponse.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * This message is used to answer all_extension_numbers_of_type requst.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;</code>
-     */
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.reflection.v1alpha.ExtensionNumberResponse, io.grpc.reflection.v1alpha.ExtensionNumberResponse.Builder, io.grpc.reflection.v1alpha.ExtensionNumberResponseOrBuilder> 
-        getAllExtensionNumbersResponseFieldBuilder() {
-      if (allExtensionNumbersResponseBuilder_ == null) {
-        if (!(messageResponseCase_ == 5)) {
-          messageResponse_ = io.grpc.reflection.v1alpha.ExtensionNumberResponse.getDefaultInstance();
-        }
-        allExtensionNumbersResponseBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-            io.grpc.reflection.v1alpha.ExtensionNumberResponse, io.grpc.reflection.v1alpha.ExtensionNumberResponse.Builder, io.grpc.reflection.v1alpha.ExtensionNumberResponseOrBuilder>(
-                (io.grpc.reflection.v1alpha.ExtensionNumberResponse) messageResponse_,
-                getParentForChildren(),
-                isClean());
-        messageResponse_ = null;
-      }
-      messageResponseCase_ = 5;
-      onChanged();;
-      return allExtensionNumbersResponseBuilder_;
-    }
-
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.reflection.v1alpha.ListServiceResponse, io.grpc.reflection.v1alpha.ListServiceResponse.Builder, io.grpc.reflection.v1alpha.ListServiceResponseOrBuilder> listServicesResponseBuilder_;
-    /**
-     * <pre>
-     * This message is used to answer list_services request.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;</code>
-     */
-    public io.grpc.reflection.v1alpha.ListServiceResponse getListServicesResponse() {
-      if (listServicesResponseBuilder_ == null) {
-        if (messageResponseCase_ == 6) {
-          return (io.grpc.reflection.v1alpha.ListServiceResponse) messageResponse_;
-        }
-        return io.grpc.reflection.v1alpha.ListServiceResponse.getDefaultInstance();
-      } else {
-        if (messageResponseCase_ == 6) {
-          return listServicesResponseBuilder_.getMessage();
-        }
-        return io.grpc.reflection.v1alpha.ListServiceResponse.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * This message is used to answer list_services request.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;</code>
-     */
-    public Builder setListServicesResponse(io.grpc.reflection.v1alpha.ListServiceResponse value) {
-      if (listServicesResponseBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        messageResponse_ = value;
-        onChanged();
-      } else {
-        listServicesResponseBuilder_.setMessage(value);
-      }
-      messageResponseCase_ = 6;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used to answer list_services request.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;</code>
-     */
-    public Builder setListServicesResponse(
-        io.grpc.reflection.v1alpha.ListServiceResponse.Builder builderForValue) {
-      if (listServicesResponseBuilder_ == null) {
-        messageResponse_ = builderForValue.build();
-        onChanged();
-      } else {
-        listServicesResponseBuilder_.setMessage(builderForValue.build());
-      }
-      messageResponseCase_ = 6;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used to answer list_services request.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;</code>
-     */
-    public Builder mergeListServicesResponse(io.grpc.reflection.v1alpha.ListServiceResponse value) {
-      if (listServicesResponseBuilder_ == null) {
-        if (messageResponseCase_ == 6 &&
-            messageResponse_ != io.grpc.reflection.v1alpha.ListServiceResponse.getDefaultInstance()) {
-          messageResponse_ = io.grpc.reflection.v1alpha.ListServiceResponse.newBuilder((io.grpc.reflection.v1alpha.ListServiceResponse) messageResponse_)
-              .mergeFrom(value).buildPartial();
-        } else {
-          messageResponse_ = value;
-        }
-        onChanged();
-      } else {
-        if (messageResponseCase_ == 6) {
-          listServicesResponseBuilder_.mergeFrom(value);
-        }
-        listServicesResponseBuilder_.setMessage(value);
-      }
-      messageResponseCase_ = 6;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used to answer list_services request.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;</code>
-     */
-    public Builder clearListServicesResponse() {
-      if (listServicesResponseBuilder_ == null) {
-        if (messageResponseCase_ == 6) {
-          messageResponseCase_ = 0;
-          messageResponse_ = null;
-          onChanged();
-        }
-      } else {
-        if (messageResponseCase_ == 6) {
-          messageResponseCase_ = 0;
-          messageResponse_ = null;
-        }
-        listServicesResponseBuilder_.clear();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used to answer list_services request.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;</code>
-     */
-    public io.grpc.reflection.v1alpha.ListServiceResponse.Builder getListServicesResponseBuilder() {
-      return getListServicesResponseFieldBuilder().getBuilder();
-    }
-    /**
-     * <pre>
-     * This message is used to answer list_services request.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;</code>
-     */
-    public io.grpc.reflection.v1alpha.ListServiceResponseOrBuilder getListServicesResponseOrBuilder() {
-      if ((messageResponseCase_ == 6) && (listServicesResponseBuilder_ != null)) {
-        return listServicesResponseBuilder_.getMessageOrBuilder();
-      } else {
-        if (messageResponseCase_ == 6) {
-          return (io.grpc.reflection.v1alpha.ListServiceResponse) messageResponse_;
-        }
-        return io.grpc.reflection.v1alpha.ListServiceResponse.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * This message is used to answer list_services request.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;</code>
-     */
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.reflection.v1alpha.ListServiceResponse, io.grpc.reflection.v1alpha.ListServiceResponse.Builder, io.grpc.reflection.v1alpha.ListServiceResponseOrBuilder> 
-        getListServicesResponseFieldBuilder() {
-      if (listServicesResponseBuilder_ == null) {
-        if (!(messageResponseCase_ == 6)) {
-          messageResponse_ = io.grpc.reflection.v1alpha.ListServiceResponse.getDefaultInstance();
-        }
-        listServicesResponseBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-            io.grpc.reflection.v1alpha.ListServiceResponse, io.grpc.reflection.v1alpha.ListServiceResponse.Builder, io.grpc.reflection.v1alpha.ListServiceResponseOrBuilder>(
-                (io.grpc.reflection.v1alpha.ListServiceResponse) messageResponse_,
-                getParentForChildren(),
-                isClean());
-        messageResponse_ = null;
-      }
-      messageResponseCase_ = 6;
-      onChanged();;
-      return listServicesResponseBuilder_;
-    }
-
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.reflection.v1alpha.ErrorResponse, io.grpc.reflection.v1alpha.ErrorResponse.Builder, io.grpc.reflection.v1alpha.ErrorResponseOrBuilder> errorResponseBuilder_;
-    /**
-     * <pre>
-     * This message is used when an error occurs.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ErrorResponse error_response = 7;</code>
-     */
-    public io.grpc.reflection.v1alpha.ErrorResponse getErrorResponse() {
-      if (errorResponseBuilder_ == null) {
-        if (messageResponseCase_ == 7) {
-          return (io.grpc.reflection.v1alpha.ErrorResponse) messageResponse_;
-        }
-        return io.grpc.reflection.v1alpha.ErrorResponse.getDefaultInstance();
-      } else {
-        if (messageResponseCase_ == 7) {
-          return errorResponseBuilder_.getMessage();
-        }
-        return io.grpc.reflection.v1alpha.ErrorResponse.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * This message is used when an error occurs.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ErrorResponse error_response = 7;</code>
-     */
-    public Builder setErrorResponse(io.grpc.reflection.v1alpha.ErrorResponse value) {
-      if (errorResponseBuilder_ == null) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        messageResponse_ = value;
-        onChanged();
-      } else {
-        errorResponseBuilder_.setMessage(value);
-      }
-      messageResponseCase_ = 7;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used when an error occurs.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ErrorResponse error_response = 7;</code>
-     */
-    public Builder setErrorResponse(
-        io.grpc.reflection.v1alpha.ErrorResponse.Builder builderForValue) {
-      if (errorResponseBuilder_ == null) {
-        messageResponse_ = builderForValue.build();
-        onChanged();
-      } else {
-        errorResponseBuilder_.setMessage(builderForValue.build());
-      }
-      messageResponseCase_ = 7;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used when an error occurs.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ErrorResponse error_response = 7;</code>
-     */
-    public Builder mergeErrorResponse(io.grpc.reflection.v1alpha.ErrorResponse value) {
-      if (errorResponseBuilder_ == null) {
-        if (messageResponseCase_ == 7 &&
-            messageResponse_ != io.grpc.reflection.v1alpha.ErrorResponse.getDefaultInstance()) {
-          messageResponse_ = io.grpc.reflection.v1alpha.ErrorResponse.newBuilder((io.grpc.reflection.v1alpha.ErrorResponse) messageResponse_)
-              .mergeFrom(value).buildPartial();
-        } else {
-          messageResponse_ = value;
-        }
-        onChanged();
-      } else {
-        if (messageResponseCase_ == 7) {
-          errorResponseBuilder_.mergeFrom(value);
-        }
-        errorResponseBuilder_.setMessage(value);
-      }
-      messageResponseCase_ = 7;
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used when an error occurs.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ErrorResponse error_response = 7;</code>
-     */
-    public Builder clearErrorResponse() {
-      if (errorResponseBuilder_ == null) {
-        if (messageResponseCase_ == 7) {
-          messageResponseCase_ = 0;
-          messageResponse_ = null;
-          onChanged();
-        }
-      } else {
-        if (messageResponseCase_ == 7) {
-          messageResponseCase_ = 0;
-          messageResponse_ = null;
-        }
-        errorResponseBuilder_.clear();
-      }
-      return this;
-    }
-    /**
-     * <pre>
-     * This message is used when an error occurs.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ErrorResponse error_response = 7;</code>
-     */
-    public io.grpc.reflection.v1alpha.ErrorResponse.Builder getErrorResponseBuilder() {
-      return getErrorResponseFieldBuilder().getBuilder();
-    }
-    /**
-     * <pre>
-     * This message is used when an error occurs.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ErrorResponse error_response = 7;</code>
-     */
-    public io.grpc.reflection.v1alpha.ErrorResponseOrBuilder getErrorResponseOrBuilder() {
-      if ((messageResponseCase_ == 7) && (errorResponseBuilder_ != null)) {
-        return errorResponseBuilder_.getMessageOrBuilder();
-      } else {
-        if (messageResponseCase_ == 7) {
-          return (io.grpc.reflection.v1alpha.ErrorResponse) messageResponse_;
-        }
-        return io.grpc.reflection.v1alpha.ErrorResponse.getDefaultInstance();
-      }
-    }
-    /**
-     * <pre>
-     * This message is used when an error occurs.
-     * </pre>
-     *
-     * <code>.grpc.reflection.v1alpha.ErrorResponse error_response = 7;</code>
-     */
-    private com.google.protobuf.SingleFieldBuilderV3<
-        io.grpc.reflection.v1alpha.ErrorResponse, io.grpc.reflection.v1alpha.ErrorResponse.Builder, io.grpc.reflection.v1alpha.ErrorResponseOrBuilder> 
-        getErrorResponseFieldBuilder() {
-      if (errorResponseBuilder_ == null) {
-        if (!(messageResponseCase_ == 7)) {
-          messageResponse_ = io.grpc.reflection.v1alpha.ErrorResponse.getDefaultInstance();
-        }
-        errorResponseBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-            io.grpc.reflection.v1alpha.ErrorResponse, io.grpc.reflection.v1alpha.ErrorResponse.Builder, io.grpc.reflection.v1alpha.ErrorResponseOrBuilder>(
-                (io.grpc.reflection.v1alpha.ErrorResponse) messageResponse_,
-                getParentForChildren(),
-                isClean());
-        messageResponse_ = null;
-      }
-      messageResponseCase_ = 7;
-      onChanged();;
-      return errorResponseBuilder_;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.v1alpha.ServerReflectionResponse)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.v1alpha.ServerReflectionResponse)
-  private static final io.grpc.reflection.v1alpha.ServerReflectionResponse DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.v1alpha.ServerReflectionResponse();
-  }
-
-  public static io.grpc.reflection.v1alpha.ServerReflectionResponse getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<ServerReflectionResponse>
-      PARSER = new com.google.protobuf.AbstractParser<ServerReflectionResponse>() {
-    public ServerReflectionResponse parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new ServerReflectionResponse(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<ServerReflectionResponse> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<ServerReflectionResponse> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.v1alpha.ServerReflectionResponse getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionResponseOrBuilder.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionResponseOrBuilder.java
deleted file mode 100644
index 6fe2129c3bf..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServerReflectionResponseOrBuilder.java
+++ /dev/null
@@ -1,112 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-public interface ServerReflectionResponseOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.v1alpha.ServerReflectionResponse)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <code>string valid_host = 1;</code>
-   */
-  java.lang.String getValidHost();
-  /**
-   * <code>string valid_host = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getValidHostBytes();
-
-  /**
-   * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-   */
-  boolean hasOriginalRequest();
-  /**
-   * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-   */
-  io.grpc.reflection.v1alpha.ServerReflectionRequest getOriginalRequest();
-  /**
-   * <code>.grpc.reflection.v1alpha.ServerReflectionRequest original_request = 2;</code>
-   */
-  io.grpc.reflection.v1alpha.ServerReflectionRequestOrBuilder getOriginalRequestOrBuilder();
-
-  /**
-   * <pre>
-   * This message is used to answer file_by_filename, file_containing_symbol,
-   * file_containing_extension requests with transitive dependencies. As
-   * the repeated label is not allowed in oneof fields, we use a
-   * FileDescriptorResponse message to encapsulate the repeated fields.
-   * The reflection service is allowed to avoid sending FileDescriptorProtos
-   * that were previously sent in response to earlier requests in the stream.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;</code>
-   */
-  io.grpc.reflection.v1alpha.FileDescriptorResponse getFileDescriptorResponse();
-  /**
-   * <pre>
-   * This message is used to answer file_by_filename, file_containing_symbol,
-   * file_containing_extension requests with transitive dependencies. As
-   * the repeated label is not allowed in oneof fields, we use a
-   * FileDescriptorResponse message to encapsulate the repeated fields.
-   * The reflection service is allowed to avoid sending FileDescriptorProtos
-   * that were previously sent in response to earlier requests in the stream.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.FileDescriptorResponse file_descriptor_response = 4;</code>
-   */
-  io.grpc.reflection.v1alpha.FileDescriptorResponseOrBuilder getFileDescriptorResponseOrBuilder();
-
-  /**
-   * <pre>
-   * This message is used to answer all_extension_numbers_of_type requst.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;</code>
-   */
-  io.grpc.reflection.v1alpha.ExtensionNumberResponse getAllExtensionNumbersResponse();
-  /**
-   * <pre>
-   * This message is used to answer all_extension_numbers_of_type requst.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ExtensionNumberResponse all_extension_numbers_response = 5;</code>
-   */
-  io.grpc.reflection.v1alpha.ExtensionNumberResponseOrBuilder getAllExtensionNumbersResponseOrBuilder();
-
-  /**
-   * <pre>
-   * This message is used to answer list_services request.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;</code>
-   */
-  io.grpc.reflection.v1alpha.ListServiceResponse getListServicesResponse();
-  /**
-   * <pre>
-   * This message is used to answer list_services request.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ListServiceResponse list_services_response = 6;</code>
-   */
-  io.grpc.reflection.v1alpha.ListServiceResponseOrBuilder getListServicesResponseOrBuilder();
-
-  /**
-   * <pre>
-   * This message is used when an error occurs.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ErrorResponse error_response = 7;</code>
-   */
-  io.grpc.reflection.v1alpha.ErrorResponse getErrorResponse();
-  /**
-   * <pre>
-   * This message is used when an error occurs.
-   * </pre>
-   *
-   * <code>.grpc.reflection.v1alpha.ErrorResponse error_response = 7;</code>
-   */
-  io.grpc.reflection.v1alpha.ErrorResponseOrBuilder getErrorResponseOrBuilder();
-
-  public io.grpc.reflection.v1alpha.ServerReflectionResponse.MessageResponseCase getMessageResponseCase();
-}
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServiceResponse.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServiceResponse.java
deleted file mode 100644
index a146c174879..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServiceResponse.java
+++ /dev/null
@@ -1,539 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-/**
- * <pre>
- * The information of a single service used by ListServiceResponse to answer
- * list_services request.
- * </pre>
- *
- * Protobuf type {@code grpc.reflection.v1alpha.ServiceResponse}
- */
-public  final class ServiceResponse extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.v1alpha.ServiceResponse)
-    ServiceResponseOrBuilder {
-  // Use ServiceResponse.newBuilder() to construct.
-  private ServiceResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private ServiceResponse() {
-    name_ = "";
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-  }
-  private ServiceResponse(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!input.skipField(tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            java.lang.String s = input.readStringRequireUtf8();
-
-            name_ = s;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServiceResponse_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServiceResponse_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.v1alpha.ServiceResponse.class, io.grpc.reflection.v1alpha.ServiceResponse.Builder.class);
-  }
-
-  public static final int NAME_FIELD_NUMBER = 1;
-  private volatile java.lang.Object name_;
-  /**
-   * <pre>
-   * Full name of a registered service, including its package name. The format
-   * is &lt;package&gt;.&lt;service&gt;
-   * </pre>
-   *
-   * <code>string name = 1;</code>
-   */
-  public java.lang.String getName() {
-    java.lang.Object ref = name_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      name_ = s;
-      return s;
-    }
-  }
-  /**
-   * <pre>
-   * Full name of a registered service, including its package name. The format
-   * is &lt;package&gt;.&lt;service&gt;
-   * </pre>
-   *
-   * <code>string name = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getNameBytes() {
-    java.lang.Object ref = name_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      name_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (!getNameBytes().isEmpty()) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_);
-    }
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (!getNameBytes().isEmpty()) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_);
-    }
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.v1alpha.ServiceResponse)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.v1alpha.ServiceResponse other = (io.grpc.reflection.v1alpha.ServiceResponse) obj;
-
-    boolean result = true;
-    result = result && getName()
-        .equals(other.getName());
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (37 * hash) + NAME_FIELD_NUMBER;
-    hash = (53 * hash) + getName().hashCode();
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.v1alpha.ServiceResponse parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ServiceResponse parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ServiceResponse parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.v1alpha.ServiceResponse parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ServiceResponse parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ServiceResponse parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ServiceResponse parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ServiceResponse parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.v1alpha.ServiceResponse parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.v1alpha.ServiceResponse parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.v1alpha.ServiceResponse prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * <pre>
-   * The information of a single service used by ListServiceResponse to answer
-   * list_services request.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.reflection.v1alpha.ServiceResponse}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.v1alpha.ServiceResponse)
-      io.grpc.reflection.v1alpha.ServiceResponseOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServiceResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServiceResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.v1alpha.ServiceResponse.class, io.grpc.reflection.v1alpha.ServiceResponse.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.v1alpha.ServiceResponse.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      name_ = "";
-
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.v1alpha.ServerReflectionProto.internal_static_grpc_reflection_v1alpha_ServiceResponse_descriptor;
-    }
-
-    public io.grpc.reflection.v1alpha.ServiceResponse getDefaultInstanceForType() {
-      return io.grpc.reflection.v1alpha.ServiceResponse.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.v1alpha.ServiceResponse build() {
-      io.grpc.reflection.v1alpha.ServiceResponse result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.v1alpha.ServiceResponse buildPartial() {
-      io.grpc.reflection.v1alpha.ServiceResponse result = new io.grpc.reflection.v1alpha.ServiceResponse(this);
-      result.name_ = name_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.v1alpha.ServiceResponse) {
-        return mergeFrom((io.grpc.reflection.v1alpha.ServiceResponse)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.v1alpha.ServiceResponse other) {
-      if (other == io.grpc.reflection.v1alpha.ServiceResponse.getDefaultInstance()) return this;
-      if (!other.getName().isEmpty()) {
-        name_ = other.name_;
-        onChanged();
-      }
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.v1alpha.ServiceResponse parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.v1alpha.ServiceResponse) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-
-    private java.lang.Object name_ = "";
-    /**
-     * <pre>
-     * Full name of a registered service, including its package name. The format
-     * is &lt;package&gt;.&lt;service&gt;
-     * </pre>
-     *
-     * <code>string name = 1;</code>
-     */
-    public java.lang.String getName() {
-      java.lang.Object ref = name_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        name_ = s;
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Full name of a registered service, including its package name. The format
-     * is &lt;package&gt;.&lt;service&gt;
-     * </pre>
-     *
-     * <code>string name = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getNameBytes() {
-      java.lang.Object ref = name_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        name_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <pre>
-     * Full name of a registered service, including its package name. The format
-     * is &lt;package&gt;.&lt;service&gt;
-     * </pre>
-     *
-     * <code>string name = 1;</code>
-     */
-    public Builder setName(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  
-      name_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Full name of a registered service, including its package name. The format
-     * is &lt;package&gt;.&lt;service&gt;
-     * </pre>
-     *
-     * <code>string name = 1;</code>
-     */
-    public Builder clearName() {
-      
-      name_ = getDefaultInstance().getName();
-      onChanged();
-      return this;
-    }
-    /**
-     * <pre>
-     * Full name of a registered service, including its package name. The format
-     * is &lt;package&gt;.&lt;service&gt;
-     * </pre>
-     *
-     * <code>string name = 1;</code>
-     */
-    public Builder setNameBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-      
-      name_ = value;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return this;
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.v1alpha.ServiceResponse)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.v1alpha.ServiceResponse)
-  private static final io.grpc.reflection.v1alpha.ServiceResponse DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.v1alpha.ServiceResponse();
-  }
-
-  public static io.grpc.reflection.v1alpha.ServiceResponse getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  private static final com.google.protobuf.Parser<ServiceResponse>
-      PARSER = new com.google.protobuf.AbstractParser<ServiceResponse>() {
-    public ServiceResponse parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new ServiceResponse(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<ServiceResponse> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<ServiceResponse> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.v1alpha.ServiceResponse getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServiceResponseOrBuilder.java b/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServiceResponseOrBuilder.java
deleted file mode 100644
index ed234c72e5b..00000000000
--- a/services/src/generated/main/java/io/grpc/reflection/v1alpha/ServiceResponseOrBuilder.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/v1alpha/reflection.proto
-
-package io.grpc.reflection.v1alpha;
-
-public interface ServiceResponseOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.v1alpha.ServiceResponse)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <pre>
-   * Full name of a registered service, including its package name. The format
-   * is &lt;package&gt;.&lt;service&gt;
-   * </pre>
-   *
-   * <code>string name = 1;</code>
-   */
-  java.lang.String getName();
-  /**
-   * <pre>
-   * Full name of a registered service, including its package name. The format
-   * is &lt;package&gt;.&lt;service&gt;
-   * </pre>
-   *
-   * <code>string name = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getNameBytes();
-}
diff --git a/services/src/generated/test/grpc/io/grpc/reflection/testing/AnotherDynamicServiceGrpc.java b/services/src/generated/test/grpc/io/grpc/reflection/testing/AnotherDynamicServiceGrpc.java
index 7d5f6ec2a79..978af2d887e 100644
--- a/services/src/generated/test/grpc/io/grpc/reflection/testing/AnotherDynamicServiceGrpc.java
+++ b/services/src/generated/test/grpc/io/grpc/reflection/testing/AnotherDynamicServiceGrpc.java
@@ -1,50 +1,78 @@
 package io.grpc.reflection.testing;
 
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
 import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
 
 /**
  * <pre>
  * AnotherDynamicService
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: io/grpc/reflection/testing/dynamic_reflection_test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class AnotherDynamicServiceGrpc {
 
   private AnotherDynamicServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.reflection.testing.AnotherDynamicService";
+  public static final java.lang.String SERVICE_NAME = "grpc.reflection.testing.AnotherDynamicService";
 
   // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.reflection.testing.DynamicRequest,
-      io.grpc.reflection.testing.DynamicReply> METHOD_METHOD =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.reflection.testing.AnotherDynamicService", "Method"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.reflection.testing.DynamicRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.reflection.testing.DynamicReply.getDefaultInstance()));
+  private static volatile io.grpc.MethodDescriptor<io.grpc.reflection.testing.DynamicRequest,
+      io.grpc.reflection.testing.DynamicReply> getMethodMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Method",
+      requestType = io.grpc.reflection.testing.DynamicRequest.class,
+      responseType = io.grpc.reflection.testing.DynamicReply.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.reflection.testing.DynamicRequest,
+      io.grpc.reflection.testing.DynamicReply> getMethodMethod() {
+    io.grpc.MethodDescriptor<io.grpc.reflection.testing.DynamicRequest, io.grpc.reflection.testing.DynamicReply> getMethodMethod;
+    if ((getMethodMethod = AnotherDynamicServiceGrpc.getMethodMethod) == null) {
+      synchronized (AnotherDynamicServiceGrpc.class) {
+        if ((getMethodMethod = AnotherDynamicServiceGrpc.getMethodMethod) == null) {
+          AnotherDynamicServiceGrpc.getMethodMethod = getMethodMethod =
+              io.grpc.MethodDescriptor.<io.grpc.reflection.testing.DynamicRequest, io.grpc.reflection.testing.DynamicReply>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Method"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.reflection.testing.DynamicRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.reflection.testing.DynamicReply.getDefaultInstance()))
+              .setSchemaDescriptor(new AnotherDynamicServiceMethodDescriptorSupplier("Method"))
+              .build();
+        }
+      }
+    }
+    return getMethodMethod;
+  }
 
   /**
    * Creates a new async stub that supports all call types for the service
    */
   public static AnotherDynamicServiceStub newStub(io.grpc.Channel channel) {
-    return new AnotherDynamicServiceStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<AnotherDynamicServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AnotherDynamicServiceStub>() {
+        @java.lang.Override
+        public AnotherDynamicServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AnotherDynamicServiceStub(channel, callOptions);
+        }
+      };
+    return AnotherDynamicServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static AnotherDynamicServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<AnotherDynamicServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AnotherDynamicServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public AnotherDynamicServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AnotherDynamicServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return AnotherDynamicServiceBlockingV2Stub.newStub(factory, channel);
   }
 
   /**
@@ -52,15 +80,29 @@ public static AnotherDynamicServiceStub newStub(io.grpc.Channel channel) {
    */
   public static AnotherDynamicServiceBlockingStub newBlockingStub(
       io.grpc.Channel channel) {
-    return new AnotherDynamicServiceBlockingStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<AnotherDynamicServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AnotherDynamicServiceBlockingStub>() {
+        @java.lang.Override
+        public AnotherDynamicServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AnotherDynamicServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return AnotherDynamicServiceBlockingStub.newStub(factory, channel);
   }
 
   /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
    */
   public static AnotherDynamicServiceFutureStub newFutureStub(
       io.grpc.Channel channel) {
-    return new AnotherDynamicServiceFutureStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<AnotherDynamicServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AnotherDynamicServiceFutureStub>() {
+        @java.lang.Override
+        public AnotherDynamicServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AnotherDynamicServiceFutureStub(channel, callOptions);
+        }
+      };
+    return AnotherDynamicServiceFutureStub.newStub(factory, channel);
   }
 
   /**
@@ -68,49 +110,49 @@ public static AnotherDynamicServiceFutureStub newFutureStub(
    * AnotherDynamicService
    * </pre>
    */
-  public static abstract class AnotherDynamicServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * A method
      * </pre>
      */
-    public void method(io.grpc.reflection.testing.DynamicRequest request,
+    default void method(io.grpc.reflection.testing.DynamicRequest request,
         io.grpc.stub.StreamObserver<io.grpc.reflection.testing.DynamicReply> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_METHOD, responseObserver);
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getMethodMethod(), responseObserver);
     }
+  }
+
+  /**
+   * Base class for the server implementation of the service AnotherDynamicService.
+   * <pre>
+   * AnotherDynamicService
+   * </pre>
+   */
+  public static abstract class AnotherDynamicServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
 
     @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_METHOD,
-            asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.reflection.testing.DynamicRequest,
-                io.grpc.reflection.testing.DynamicReply>(
-                  this, METHODID_METHOD)))
-          .build();
+      return AnotherDynamicServiceGrpc.bindService(this);
     }
   }
 
   /**
+   * A stub to allow clients to do asynchronous rpc calls to service AnotherDynamicService.
    * <pre>
    * AnotherDynamicService
    * </pre>
    */
-  public static final class AnotherDynamicServiceStub extends io.grpc.stub.AbstractStub<AnotherDynamicServiceStub> {
-    private AnotherDynamicServiceStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private AnotherDynamicServiceStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class AnotherDynamicServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<AnotherDynamicServiceStub> {
+    private AnotherDynamicServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected AnotherDynamicServiceStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected AnotherDynamicServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new AnotherDynamicServiceStub(channel, callOptions);
     }
 
@@ -121,29 +163,57 @@ protected AnotherDynamicServiceStub build(io.grpc.Channel channel,
      */
     public void method(io.grpc.reflection.testing.DynamicRequest request,
         io.grpc.stub.StreamObserver<io.grpc.reflection.testing.DynamicReply> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_METHOD, getCallOptions()), request, responseObserver);
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getMethodMethod(), getCallOptions()), request, responseObserver);
     }
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service AnotherDynamicService.
    * <pre>
    * AnotherDynamicService
    * </pre>
    */
-  public static final class AnotherDynamicServiceBlockingStub extends io.grpc.stub.AbstractStub<AnotherDynamicServiceBlockingStub> {
-    private AnotherDynamicServiceBlockingStub(io.grpc.Channel channel) {
-      super(channel);
+  public static final class AnotherDynamicServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<AnotherDynamicServiceBlockingV2Stub> {
+    private AnotherDynamicServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected AnotherDynamicServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new AnotherDynamicServiceBlockingV2Stub(channel, callOptions);
     }
 
-    private AnotherDynamicServiceBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    /**
+     * <pre>
+     * A method
+     * </pre>
+     */
+    public io.grpc.reflection.testing.DynamicReply method(io.grpc.reflection.testing.DynamicRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getMethodMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service AnotherDynamicService.
+   * <pre>
+   * AnotherDynamicService
+   * </pre>
+   */
+  public static final class AnotherDynamicServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<AnotherDynamicServiceBlockingStub> {
+    private AnotherDynamicServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected AnotherDynamicServiceBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected AnotherDynamicServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new AnotherDynamicServiceBlockingStub(channel, callOptions);
     }
 
@@ -153,29 +223,27 @@ protected AnotherDynamicServiceBlockingStub build(io.grpc.Channel channel,
      * </pre>
      */
     public io.grpc.reflection.testing.DynamicReply method(io.grpc.reflection.testing.DynamicRequest request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_METHOD, getCallOptions(), request);
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getMethodMethod(), getCallOptions(), request);
     }
   }
 
   /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service AnotherDynamicService.
    * <pre>
    * AnotherDynamicService
    * </pre>
    */
-  public static final class AnotherDynamicServiceFutureStub extends io.grpc.stub.AbstractStub<AnotherDynamicServiceFutureStub> {
-    private AnotherDynamicServiceFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private AnotherDynamicServiceFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class AnotherDynamicServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<AnotherDynamicServiceFutureStub> {
+    private AnotherDynamicServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected AnotherDynamicServiceFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected AnotherDynamicServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new AnotherDynamicServiceFutureStub(channel, callOptions);
     }
 
@@ -186,8 +254,8 @@ protected AnotherDynamicServiceFutureStub build(io.grpc.Channel channel,
      */
     public com.google.common.util.concurrent.ListenableFuture<io.grpc.reflection.testing.DynamicReply> method(
         io.grpc.reflection.testing.DynamicRequest request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_METHOD, getCallOptions()), request);
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getMethodMethod(), getCallOptions()), request);
     }
   }
 
@@ -198,10 +266,10 @@ private static final class MethodHandlers<Req, Resp> implements
       io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final AnotherDynamicServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(AnotherDynamicServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -230,11 +298,51 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
-  private static final class AnotherDynamicServiceDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getMethodMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.reflection.testing.DynamicRequest,
+              io.grpc.reflection.testing.DynamicReply>(
+                service, METHODID_METHOD)))
+        .build();
+  }
+
+  private static abstract class AnotherDynamicServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    AnotherDynamicServiceBaseDescriptorSupplier() {}
+
     @java.lang.Override
     public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
       return io.grpc.reflection.testing.DynamicReflectionTestProto.getDescriptor();
     }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("AnotherDynamicService");
+    }
+  }
+
+  private static final class AnotherDynamicServiceFileDescriptorSupplier
+      extends AnotherDynamicServiceBaseDescriptorSupplier {
+    AnotherDynamicServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class AnotherDynamicServiceMethodDescriptorSupplier
+      extends AnotherDynamicServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    AnotherDynamicServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
   }
 
   private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
@@ -246,8 +354,8 @@ public static io.grpc.ServiceDescriptor getServiceDescriptor() {
         result = serviceDescriptor;
         if (result == null) {
           serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new AnotherDynamicServiceDescriptorSupplier())
-              .addMethod(METHOD_METHOD)
+              .setSchemaDescriptor(new AnotherDynamicServiceFileDescriptorSupplier())
+              .addMethod(getMethodMethod())
               .build();
         }
       }
diff --git a/services/src/generated/test/grpc/io/grpc/reflection/testing/AnotherReflectableServiceGrpc.java b/services/src/generated/test/grpc/io/grpc/reflection/testing/AnotherReflectableServiceGrpc.java
new file mode 100644
index 00000000000..e688c3d5cca
--- /dev/null
+++ b/services/src/generated/test/grpc/io/grpc/reflection/testing/AnotherReflectableServiceGrpc.java
@@ -0,0 +1,329 @@
+package io.grpc.reflection.testing;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class AnotherReflectableServiceGrpc {
+
+  private AnotherReflectableServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.reflection.testing.AnotherReflectableService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.reflection.testing.Request,
+      io.grpc.reflection.testing.Reply> getMethodMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Method",
+      requestType = io.grpc.reflection.testing.Request.class,
+      responseType = io.grpc.reflection.testing.Reply.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.reflection.testing.Request,
+      io.grpc.reflection.testing.Reply> getMethodMethod() {
+    io.grpc.MethodDescriptor<io.grpc.reflection.testing.Request, io.grpc.reflection.testing.Reply> getMethodMethod;
+    if ((getMethodMethod = AnotherReflectableServiceGrpc.getMethodMethod) == null) {
+      synchronized (AnotherReflectableServiceGrpc.class) {
+        if ((getMethodMethod = AnotherReflectableServiceGrpc.getMethodMethod) == null) {
+          AnotherReflectableServiceGrpc.getMethodMethod = getMethodMethod =
+              io.grpc.MethodDescriptor.<io.grpc.reflection.testing.Request, io.grpc.reflection.testing.Reply>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Method"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.reflection.testing.Request.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.reflection.testing.Reply.getDefaultInstance()))
+              .setSchemaDescriptor(new AnotherReflectableServiceMethodDescriptorSupplier("Method"))
+              .build();
+        }
+      }
+    }
+    return getMethodMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static AnotherReflectableServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<AnotherReflectableServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AnotherReflectableServiceStub>() {
+        @java.lang.Override
+        public AnotherReflectableServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AnotherReflectableServiceStub(channel, callOptions);
+        }
+      };
+    return AnotherReflectableServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static AnotherReflectableServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<AnotherReflectableServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AnotherReflectableServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public AnotherReflectableServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AnotherReflectableServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return AnotherReflectableServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static AnotherReflectableServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<AnotherReflectableServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AnotherReflectableServiceBlockingStub>() {
+        @java.lang.Override
+        public AnotherReflectableServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AnotherReflectableServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return AnotherReflectableServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static AnotherReflectableServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<AnotherReflectableServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AnotherReflectableServiceFutureStub>() {
+        @java.lang.Override
+        public AnotherReflectableServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AnotherReflectableServiceFutureStub(channel, callOptions);
+        }
+      };
+    return AnotherReflectableServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public interface AsyncService {
+
+    /**
+     */
+    default void method(io.grpc.reflection.testing.Request request,
+        io.grpc.stub.StreamObserver<io.grpc.reflection.testing.Reply> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getMethodMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service AnotherReflectableService.
+   */
+  public static abstract class AnotherReflectableServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return AnotherReflectableServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service AnotherReflectableService.
+   */
+  public static final class AnotherReflectableServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<AnotherReflectableServiceStub> {
+    private AnotherReflectableServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected AnotherReflectableServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new AnotherReflectableServiceStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public void method(io.grpc.reflection.testing.Request request,
+        io.grpc.stub.StreamObserver<io.grpc.reflection.testing.Reply> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getMethodMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service AnotherReflectableService.
+   */
+  public static final class AnotherReflectableServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<AnotherReflectableServiceBlockingV2Stub> {
+    private AnotherReflectableServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected AnotherReflectableServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new AnotherReflectableServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.reflection.testing.Reply method(io.grpc.reflection.testing.Request request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getMethodMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service AnotherReflectableService.
+   */
+  public static final class AnotherReflectableServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<AnotherReflectableServiceBlockingStub> {
+    private AnotherReflectableServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected AnotherReflectableServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new AnotherReflectableServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.reflection.testing.Reply method(io.grpc.reflection.testing.Request request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getMethodMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service AnotherReflectableService.
+   */
+  public static final class AnotherReflectableServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<AnotherReflectableServiceFutureStub> {
+    private AnotherReflectableServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected AnotherReflectableServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new AnotherReflectableServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.reflection.testing.Reply> method(
+        io.grpc.reflection.testing.Request request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getMethodMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_METHOD = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_METHOD:
+          serviceImpl.method((io.grpc.reflection.testing.Request) request,
+              (io.grpc.stub.StreamObserver<io.grpc.reflection.testing.Reply>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getMethodMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.reflection.testing.Request,
+              io.grpc.reflection.testing.Reply>(
+                service, METHODID_METHOD)))
+        .build();
+  }
+
+  private static abstract class AnotherReflectableServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    AnotherReflectableServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.reflection.testing.ReflectionTestProto.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("AnotherReflectableService");
+    }
+  }
+
+  private static final class AnotherReflectableServiceFileDescriptorSupplier
+      extends AnotherReflectableServiceBaseDescriptorSupplier {
+    AnotherReflectableServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class AnotherReflectableServiceMethodDescriptorSupplier
+      extends AnotherReflectableServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    AnotherReflectableServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (AnotherReflectableServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new AnotherReflectableServiceFileDescriptorSupplier())
+              .addMethod(getMethodMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/services/src/generated/test/grpc/io/grpc/reflection/testing/DynamicServiceGrpc.java b/services/src/generated/test/grpc/io/grpc/reflection/testing/DynamicServiceGrpc.java
index 797417cb443..efef61be151 100644
--- a/services/src/generated/test/grpc/io/grpc/reflection/testing/DynamicServiceGrpc.java
+++ b/services/src/generated/test/grpc/io/grpc/reflection/testing/DynamicServiceGrpc.java
@@ -1,50 +1,78 @@
 package io.grpc.reflection.testing;
 
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
 import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
 
 /**
  * <pre>
  * A DynamicService
  * </pre>
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: io/grpc/reflection/testing/dynamic_reflection_test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class DynamicServiceGrpc {
 
   private DynamicServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.reflection.testing.DynamicService";
+  public static final java.lang.String SERVICE_NAME = "grpc.reflection.testing.DynamicService";
 
   // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.reflection.testing.DynamicRequest,
-      io.grpc.reflection.testing.DynamicReply> METHOD_METHOD =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.reflection.testing.DynamicService", "Method"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.reflection.testing.DynamicRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.reflection.testing.DynamicReply.getDefaultInstance()));
+  private static volatile io.grpc.MethodDescriptor<io.grpc.reflection.testing.DynamicRequest,
+      io.grpc.reflection.testing.DynamicReply> getMethodMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Method",
+      requestType = io.grpc.reflection.testing.DynamicRequest.class,
+      responseType = io.grpc.reflection.testing.DynamicReply.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.reflection.testing.DynamicRequest,
+      io.grpc.reflection.testing.DynamicReply> getMethodMethod() {
+    io.grpc.MethodDescriptor<io.grpc.reflection.testing.DynamicRequest, io.grpc.reflection.testing.DynamicReply> getMethodMethod;
+    if ((getMethodMethod = DynamicServiceGrpc.getMethodMethod) == null) {
+      synchronized (DynamicServiceGrpc.class) {
+        if ((getMethodMethod = DynamicServiceGrpc.getMethodMethod) == null) {
+          DynamicServiceGrpc.getMethodMethod = getMethodMethod =
+              io.grpc.MethodDescriptor.<io.grpc.reflection.testing.DynamicRequest, io.grpc.reflection.testing.DynamicReply>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Method"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.reflection.testing.DynamicRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.reflection.testing.DynamicReply.getDefaultInstance()))
+              .setSchemaDescriptor(new DynamicServiceMethodDescriptorSupplier("Method"))
+              .build();
+        }
+      }
+    }
+    return getMethodMethod;
+  }
 
   /**
    * Creates a new async stub that supports all call types for the service
    */
   public static DynamicServiceStub newStub(io.grpc.Channel channel) {
-    return new DynamicServiceStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<DynamicServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<DynamicServiceStub>() {
+        @java.lang.Override
+        public DynamicServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new DynamicServiceStub(channel, callOptions);
+        }
+      };
+    return DynamicServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static DynamicServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<DynamicServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<DynamicServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public DynamicServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new DynamicServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return DynamicServiceBlockingV2Stub.newStub(factory, channel);
   }
 
   /**
@@ -52,15 +80,29 @@ public static DynamicServiceStub newStub(io.grpc.Channel channel) {
    */
   public static DynamicServiceBlockingStub newBlockingStub(
       io.grpc.Channel channel) {
-    return new DynamicServiceBlockingStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<DynamicServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<DynamicServiceBlockingStub>() {
+        @java.lang.Override
+        public DynamicServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new DynamicServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return DynamicServiceBlockingStub.newStub(factory, channel);
   }
 
   /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
    */
   public static DynamicServiceFutureStub newFutureStub(
       io.grpc.Channel channel) {
-    return new DynamicServiceFutureStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<DynamicServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<DynamicServiceFutureStub>() {
+        @java.lang.Override
+        public DynamicServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new DynamicServiceFutureStub(channel, callOptions);
+        }
+      };
+    return DynamicServiceFutureStub.newStub(factory, channel);
   }
 
   /**
@@ -68,49 +110,49 @@ public static DynamicServiceFutureStub newFutureStub(
    * A DynamicService
    * </pre>
    */
-  public static abstract class DynamicServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      * <pre>
      * A method
      * </pre>
      */
-    public void method(io.grpc.reflection.testing.DynamicRequest request,
+    default void method(io.grpc.reflection.testing.DynamicRequest request,
         io.grpc.stub.StreamObserver<io.grpc.reflection.testing.DynamicReply> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_METHOD, responseObserver);
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getMethodMethod(), responseObserver);
     }
+  }
+
+  /**
+   * Base class for the server implementation of the service DynamicService.
+   * <pre>
+   * A DynamicService
+   * </pre>
+   */
+  public static abstract class DynamicServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
 
     @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_METHOD,
-            asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.reflection.testing.DynamicRequest,
-                io.grpc.reflection.testing.DynamicReply>(
-                  this, METHODID_METHOD)))
-          .build();
+      return DynamicServiceGrpc.bindService(this);
     }
   }
 
   /**
+   * A stub to allow clients to do asynchronous rpc calls to service DynamicService.
    * <pre>
    * A DynamicService
    * </pre>
    */
-  public static final class DynamicServiceStub extends io.grpc.stub.AbstractStub<DynamicServiceStub> {
-    private DynamicServiceStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private DynamicServiceStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class DynamicServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<DynamicServiceStub> {
+    private DynamicServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected DynamicServiceStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected DynamicServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new DynamicServiceStub(channel, callOptions);
     }
 
@@ -121,29 +163,57 @@ protected DynamicServiceStub build(io.grpc.Channel channel,
      */
     public void method(io.grpc.reflection.testing.DynamicRequest request,
         io.grpc.stub.StreamObserver<io.grpc.reflection.testing.DynamicReply> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_METHOD, getCallOptions()), request, responseObserver);
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getMethodMethod(), getCallOptions()), request, responseObserver);
     }
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service DynamicService.
    * <pre>
    * A DynamicService
    * </pre>
    */
-  public static final class DynamicServiceBlockingStub extends io.grpc.stub.AbstractStub<DynamicServiceBlockingStub> {
-    private DynamicServiceBlockingStub(io.grpc.Channel channel) {
-      super(channel);
+  public static final class DynamicServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<DynamicServiceBlockingV2Stub> {
+    private DynamicServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected DynamicServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new DynamicServiceBlockingV2Stub(channel, callOptions);
     }
 
-    private DynamicServiceBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    /**
+     * <pre>
+     * A method
+     * </pre>
+     */
+    public io.grpc.reflection.testing.DynamicReply method(io.grpc.reflection.testing.DynamicRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getMethodMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service DynamicService.
+   * <pre>
+   * A DynamicService
+   * </pre>
+   */
+  public static final class DynamicServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<DynamicServiceBlockingStub> {
+    private DynamicServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected DynamicServiceBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected DynamicServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new DynamicServiceBlockingStub(channel, callOptions);
     }
 
@@ -153,29 +223,27 @@ protected DynamicServiceBlockingStub build(io.grpc.Channel channel,
      * </pre>
      */
     public io.grpc.reflection.testing.DynamicReply method(io.grpc.reflection.testing.DynamicRequest request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_METHOD, getCallOptions(), request);
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getMethodMethod(), getCallOptions(), request);
     }
   }
 
   /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service DynamicService.
    * <pre>
    * A DynamicService
    * </pre>
    */
-  public static final class DynamicServiceFutureStub extends io.grpc.stub.AbstractStub<DynamicServiceFutureStub> {
-    private DynamicServiceFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private DynamicServiceFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class DynamicServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<DynamicServiceFutureStub> {
+    private DynamicServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected DynamicServiceFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected DynamicServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new DynamicServiceFutureStub(channel, callOptions);
     }
 
@@ -186,8 +254,8 @@ protected DynamicServiceFutureStub build(io.grpc.Channel channel,
      */
     public com.google.common.util.concurrent.ListenableFuture<io.grpc.reflection.testing.DynamicReply> method(
         io.grpc.reflection.testing.DynamicRequest request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_METHOD, getCallOptions()), request);
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getMethodMethod(), getCallOptions()), request);
     }
   }
 
@@ -198,10 +266,10 @@ private static final class MethodHandlers<Req, Resp> implements
       io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final DynamicServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(DynamicServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -230,11 +298,51 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
-  private static final class DynamicServiceDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getMethodMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.reflection.testing.DynamicRequest,
+              io.grpc.reflection.testing.DynamicReply>(
+                service, METHODID_METHOD)))
+        .build();
+  }
+
+  private static abstract class DynamicServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    DynamicServiceBaseDescriptorSupplier() {}
+
     @java.lang.Override
     public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
       return io.grpc.reflection.testing.DynamicReflectionTestProto.getDescriptor();
     }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("DynamicService");
+    }
+  }
+
+  private static final class DynamicServiceFileDescriptorSupplier
+      extends DynamicServiceBaseDescriptorSupplier {
+    DynamicServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class DynamicServiceMethodDescriptorSupplier
+      extends DynamicServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    DynamicServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
   }
 
   private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
@@ -246,8 +354,8 @@ public static io.grpc.ServiceDescriptor getServiceDescriptor() {
         result = serviceDescriptor;
         if (result == null) {
           serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new DynamicServiceDescriptorSupplier())
-              .addMethod(METHOD_METHOD)
+              .setSchemaDescriptor(new DynamicServiceFileDescriptorSupplier())
+              .addMethod(getMethodMethod())
               .build();
         }
       }
diff --git a/services/src/generated/test/grpc/io/grpc/reflection/testing/ReflectableServiceGrpc.java b/services/src/generated/test/grpc/io/grpc/reflection/testing/ReflectableServiceGrpc.java
index ab063b3f40e..b5d130d6952 100644
--- a/services/src/generated/test/grpc/io/grpc/reflection/testing/ReflectableServiceGrpc.java
+++ b/services/src/generated/test/grpc/io/grpc/reflection/testing/ReflectableServiceGrpc.java
@@ -1,47 +1,75 @@
 package io.grpc.reflection.testing;
 
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
 import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
 
 /**
  */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: io/grpc/reflection/testing/reflection_test.proto")
+@io.grpc.stub.annotations.GrpcGenerated
 public final class ReflectableServiceGrpc {
 
   private ReflectableServiceGrpc() {}
 
-  public static final String SERVICE_NAME = "grpc.reflection.testing.ReflectableService";
+  public static final java.lang.String SERVICE_NAME = "grpc.reflection.testing.ReflectableService";
 
   // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.reflection.testing.Request,
-      io.grpc.reflection.testing.Reply> METHOD_METHOD =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.reflection.testing.ReflectableService", "Method"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.reflection.testing.Request.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.reflection.testing.Reply.getDefaultInstance()));
+  private static volatile io.grpc.MethodDescriptor<io.grpc.reflection.testing.Request,
+      io.grpc.reflection.testing.Reply> getMethodMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Method",
+      requestType = io.grpc.reflection.testing.Request.class,
+      responseType = io.grpc.reflection.testing.Reply.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.reflection.testing.Request,
+      io.grpc.reflection.testing.Reply> getMethodMethod() {
+    io.grpc.MethodDescriptor<io.grpc.reflection.testing.Request, io.grpc.reflection.testing.Reply> getMethodMethod;
+    if ((getMethodMethod = ReflectableServiceGrpc.getMethodMethod) == null) {
+      synchronized (ReflectableServiceGrpc.class) {
+        if ((getMethodMethod = ReflectableServiceGrpc.getMethodMethod) == null) {
+          ReflectableServiceGrpc.getMethodMethod = getMethodMethod =
+              io.grpc.MethodDescriptor.<io.grpc.reflection.testing.Request, io.grpc.reflection.testing.Reply>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Method"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.reflection.testing.Request.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.reflection.testing.Reply.getDefaultInstance()))
+              .setSchemaDescriptor(new ReflectableServiceMethodDescriptorSupplier("Method"))
+              .build();
+        }
+      }
+    }
+    return getMethodMethod;
+  }
 
   /**
    * Creates a new async stub that supports all call types for the service
    */
   public static ReflectableServiceStub newStub(io.grpc.Channel channel) {
-    return new ReflectableServiceStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<ReflectableServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReflectableServiceStub>() {
+        @java.lang.Override
+        public ReflectableServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReflectableServiceStub(channel, callOptions);
+        }
+      };
+    return ReflectableServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static ReflectableServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ReflectableServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReflectableServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public ReflectableServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReflectableServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return ReflectableServiceBlockingV2Stub.newStub(factory, channel);
   }
 
   /**
@@ -49,56 +77,67 @@ public static ReflectableServiceStub newStub(io.grpc.Channel channel) {
    */
   public static ReflectableServiceBlockingStub newBlockingStub(
       io.grpc.Channel channel) {
-    return new ReflectableServiceBlockingStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<ReflectableServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReflectableServiceBlockingStub>() {
+        @java.lang.Override
+        public ReflectableServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReflectableServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return ReflectableServiceBlockingStub.newStub(factory, channel);
   }
 
   /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
    */
   public static ReflectableServiceFutureStub newFutureStub(
       io.grpc.Channel channel) {
-    return new ReflectableServiceFutureStub(channel);
+    io.grpc.stub.AbstractStub.StubFactory<ReflectableServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ReflectableServiceFutureStub>() {
+        @java.lang.Override
+        public ReflectableServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ReflectableServiceFutureStub(channel, callOptions);
+        }
+      };
+    return ReflectableServiceFutureStub.newStub(factory, channel);
   }
 
   /**
    */
-  public static abstract class ReflectableServiceImplBase implements io.grpc.BindableService {
+  public interface AsyncService {
 
     /**
      */
-    public void method(io.grpc.reflection.testing.Request request,
+    default void method(io.grpc.reflection.testing.Request request,
         io.grpc.stub.StreamObserver<io.grpc.reflection.testing.Reply> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_METHOD, responseObserver);
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getMethodMethod(), responseObserver);
     }
+  }
+
+  /**
+   * Base class for the server implementation of the service ReflectableService.
+   */
+  public static abstract class ReflectableServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
 
     @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_METHOD,
-            asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.reflection.testing.Request,
-                io.grpc.reflection.testing.Reply>(
-                  this, METHODID_METHOD)))
-          .build();
+      return ReflectableServiceGrpc.bindService(this);
     }
   }
 
   /**
+   * A stub to allow clients to do asynchronous rpc calls to service ReflectableService.
    */
-  public static final class ReflectableServiceStub extends io.grpc.stub.AbstractStub<ReflectableServiceStub> {
-    private ReflectableServiceStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private ReflectableServiceStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class ReflectableServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<ReflectableServiceStub> {
+    private ReflectableServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected ReflectableServiceStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected ReflectableServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new ReflectableServiceStub(channel, callOptions);
     }
 
@@ -106,52 +145,72 @@ protected ReflectableServiceStub build(io.grpc.Channel channel,
      */
     public void method(io.grpc.reflection.testing.Request request,
         io.grpc.stub.StreamObserver<io.grpc.reflection.testing.Reply> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_METHOD, getCallOptions()), request, responseObserver);
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getMethodMethod(), getCallOptions()), request, responseObserver);
     }
   }
 
   /**
+   * A stub to allow clients to do synchronous rpc calls to service ReflectableService.
    */
-  public static final class ReflectableServiceBlockingStub extends io.grpc.stub.AbstractStub<ReflectableServiceBlockingStub> {
-    private ReflectableServiceBlockingStub(io.grpc.Channel channel) {
-      super(channel);
+  public static final class ReflectableServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<ReflectableServiceBlockingV2Stub> {
+    private ReflectableServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
     }
 
-    private ReflectableServiceBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    @java.lang.Override
+    protected ReflectableServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ReflectableServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.reflection.testing.Reply method(io.grpc.reflection.testing.Request request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getMethodMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service ReflectableService.
+   */
+  public static final class ReflectableServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<ReflectableServiceBlockingStub> {
+    private ReflectableServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected ReflectableServiceBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected ReflectableServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new ReflectableServiceBlockingStub(channel, callOptions);
     }
 
     /**
      */
     public io.grpc.reflection.testing.Reply method(io.grpc.reflection.testing.Request request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_METHOD, getCallOptions(), request);
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getMethodMethod(), getCallOptions(), request);
     }
   }
 
   /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service ReflectableService.
    */
-  public static final class ReflectableServiceFutureStub extends io.grpc.stub.AbstractStub<ReflectableServiceFutureStub> {
-    private ReflectableServiceFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private ReflectableServiceFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+  public static final class ReflectableServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ReflectableServiceFutureStub> {
+    private ReflectableServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       super(channel, callOptions);
     }
 
     @java.lang.Override
-    protected ReflectableServiceFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
+    protected ReflectableServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
       return new ReflectableServiceFutureStub(channel, callOptions);
     }
 
@@ -159,8 +218,8 @@ protected ReflectableServiceFutureStub build(io.grpc.Channel channel,
      */
     public com.google.common.util.concurrent.ListenableFuture<io.grpc.reflection.testing.Reply> method(
         io.grpc.reflection.testing.Request request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_METHOD, getCallOptions()), request);
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getMethodMethod(), getCallOptions()), request);
     }
   }
 
@@ -171,10 +230,10 @@ private static final class MethodHandlers<Req, Resp> implements
       io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
       io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final ReflectableServiceImplBase serviceImpl;
+    private final AsyncService serviceImpl;
     private final int methodId;
 
-    MethodHandlers(ReflectableServiceImplBase serviceImpl, int methodId) {
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
       this.serviceImpl = serviceImpl;
       this.methodId = methodId;
     }
@@ -203,11 +262,51 @@ public io.grpc.stub.StreamObserver<Req> invoke(
     }
   }
 
-  private static final class ReflectableServiceDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getMethodMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.reflection.testing.Request,
+              io.grpc.reflection.testing.Reply>(
+                service, METHODID_METHOD)))
+        .build();
+  }
+
+  private static abstract class ReflectableServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    ReflectableServiceBaseDescriptorSupplier() {}
+
     @java.lang.Override
     public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
       return io.grpc.reflection.testing.ReflectionTestProto.getDescriptor();
     }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("ReflectableService");
+    }
+  }
+
+  private static final class ReflectableServiceFileDescriptorSupplier
+      extends ReflectableServiceBaseDescriptorSupplier {
+    ReflectableServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class ReflectableServiceMethodDescriptorSupplier
+      extends ReflectableServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    ReflectableServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
   }
 
   private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
@@ -219,8 +318,8 @@ public static io.grpc.ServiceDescriptor getServiceDescriptor() {
         result = serviceDescriptor;
         if (result == null) {
           serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new ReflectableServiceDescriptorSupplier())
-              .addMethod(METHOD_METHOD)
+              .setSchemaDescriptor(new ReflectableServiceFileDescriptorSupplier())
+              .addMethod(getMethodMethod())
               .build();
         }
       }
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/DynamicReflectionTestDepthTwoProto.java b/services/src/generated/test/java/io/grpc/reflection/testing/DynamicReflectionTestDepthTwoProto.java
deleted file mode 100644
index f9bc0211236..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/DynamicReflectionTestDepthTwoProto.java
+++ /dev/null
@@ -1,97 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto
-
-package io.grpc.reflection.testing;
-
-public final class DynamicReflectionTestDepthTwoProto {
-  private DynamicReflectionTestDepthTwoProto() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-    registry.add(io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.extension);
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  public static final int EXTENSION_FIELD_NUMBER = 200;
-  /**
-   * <code>extend .grpc.reflection.testing.TypeWithExtensions { ... }</code>
-   */
-  public static final
-    com.google.protobuf.GeneratedMessage.GeneratedExtension<
-      io.grpc.reflection.testing.TypeWithExtensions,
-      java.lang.Integer> extension = com.google.protobuf.GeneratedMessage
-          .newFileScopedGeneratedExtension(
-        java.lang.Integer.class,
-        null);
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_testing_DynamicRequest_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_testing_DynamicRequest_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_testing_DynamicReply_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_testing_DynamicReply_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_testing_TypeWithExtensions_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_testing_TypeWithExtensions_fieldAccessorTable;
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\nBio/grpc/reflection/testing/dynamic_ref" +
-      "lection_test_depth_two.proto\022\027grpc.refle" +
-      "ction.testing\"!\n\016DynamicRequest\022\017\n\007messa" +
-      "ge\030\001 \001(\t\"\037\n\014DynamicReply\022\017\n\007message\030\001 \001(" +
-      "\t\"-\n\022TypeWithExtensions\022\017\n\007message\030\001 \001(\t" +
-      "*\006\010\310\001\020\254\002:?\n\textension\022+.grpc.reflection." +
-      "testing.TypeWithExtensions\030\310\001 \001(\005BB\n\032io." +
-      "grpc.reflection.testingB\"DynamicReflecti" +
-      "onTestDepthTwoProtoP\001"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-        }, assigner);
-    internal_static_grpc_reflection_testing_DynamicRequest_descriptor =
-      getDescriptor().getMessageTypes().get(0);
-    internal_static_grpc_reflection_testing_DynamicRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_testing_DynamicRequest_descriptor,
-        new java.lang.String[] { "Message", });
-    internal_static_grpc_reflection_testing_DynamicReply_descriptor =
-      getDescriptor().getMessageTypes().get(1);
-    internal_static_grpc_reflection_testing_DynamicReply_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_testing_DynamicReply_descriptor,
-        new java.lang.String[] { "Message", });
-    internal_static_grpc_reflection_testing_TypeWithExtensions_descriptor =
-      getDescriptor().getMessageTypes().get(2);
-    internal_static_grpc_reflection_testing_TypeWithExtensions_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_testing_TypeWithExtensions_descriptor,
-        new java.lang.String[] { "Message", });
-    extension.internalInit(descriptor.getExtensions().get(0));
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/DynamicReflectionTestProto.java b/services/src/generated/test/java/io/grpc/reflection/testing/DynamicReflectionTestProto.java
deleted file mode 100644
index 9a9fe211f7d..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/DynamicReflectionTestProto.java
+++ /dev/null
@@ -1,55 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/dynamic_reflection_test.proto
-
-package io.grpc.reflection.testing;
-
-public final class DynamicReflectionTestProto {
-  private DynamicReflectionTestProto() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n8io/grpc/reflection/testing/dynamic_ref" +
-      "lection_test.proto\022\027grpc.reflection.test" +
-      "ing\032Bio/grpc/reflection/testing/dynamic_" +
-      "reflection_test_depth_two.proto2l\n\016Dynam" +
-      "icService\022Z\n\006Method\022\'.grpc.reflection.te" +
-      "sting.DynamicRequest\032%.grpc.reflection.t" +
-      "esting.DynamicReply\"\0002s\n\025AnotherDynamicS" +
-      "ervice\022Z\n\006Method\022\'.grpc.reflection.testi" +
-      "ng.DynamicRequest\032%.grpc.reflection.test" +
-      "ing.DynamicReply\"\000B:\n\032io.grpc.reflection",
-      ".testingB\032DynamicReflectionTestProtoP\001"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-          io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.getDescriptor(),
-        }, assigner);
-    io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.getDescriptor();
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/DynamicReply.java b/services/src/generated/test/java/io/grpc/reflection/testing/DynamicReply.java
deleted file mode 100644
index c1f456c872e..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/DynamicReply.java
+++ /dev/null
@@ -1,531 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto
-
-package io.grpc.reflection.testing;
-
-/**
- * Protobuf type {@code grpc.reflection.testing.DynamicReply}
- */
-public  final class DynamicReply extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.testing.DynamicReply)
-    DynamicReplyOrBuilder {
-  // Use DynamicReply.newBuilder() to construct.
-  private DynamicReply(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private DynamicReply() {
-    message_ = "";
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return this.unknownFields;
-  }
-  private DynamicReply(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    com.google.protobuf.UnknownFieldSet.Builder unknownFields =
-        com.google.protobuf.UnknownFieldSet.newBuilder();
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!parseUnknownField(input, unknownFields,
-                                   extensionRegistry, tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            com.google.protobuf.ByteString bs = input.readBytes();
-            bitField0_ |= 0x00000001;
-            message_ = bs;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      this.unknownFields = unknownFields.build();
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_DynamicReply_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_DynamicReply_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.testing.DynamicReply.class, io.grpc.reflection.testing.DynamicReply.Builder.class);
-  }
-
-  private int bitField0_;
-  public static final int MESSAGE_FIELD_NUMBER = 1;
-  private volatile java.lang.Object message_;
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public boolean hasMessage() {
-    return ((bitField0_ & 0x00000001) == 0x00000001);
-  }
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public java.lang.String getMessage() {
-    java.lang.Object ref = message_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      if (bs.isValidUtf8()) {
-        message_ = s;
-      }
-      return s;
-    }
-  }
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getMessageBytes() {
-    java.lang.Object ref = message_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      message_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, message_);
-    }
-    unknownFields.writeTo(output);
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, message_);
-    }
-    size += unknownFields.getSerializedSize();
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.testing.DynamicReply)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.testing.DynamicReply other = (io.grpc.reflection.testing.DynamicReply) obj;
-
-    boolean result = true;
-    result = result && (hasMessage() == other.hasMessage());
-    if (hasMessage()) {
-      result = result && getMessage()
-          .equals(other.getMessage());
-    }
-    result = result && unknownFields.equals(other.unknownFields);
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    if (hasMessage()) {
-      hash = (37 * hash) + MESSAGE_FIELD_NUMBER;
-      hash = (53 * hash) + getMessage().hashCode();
-    }
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.testing.DynamicReply parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.DynamicReply parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.DynamicReply parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.DynamicReply parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.DynamicReply parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.DynamicReply parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.DynamicReply parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.DynamicReply parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.DynamicReply parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.DynamicReply parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.testing.DynamicReply prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.reflection.testing.DynamicReply}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.testing.DynamicReply)
-      io.grpc.reflection.testing.DynamicReplyOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_DynamicReply_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_DynamicReply_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.testing.DynamicReply.class, io.grpc.reflection.testing.DynamicReply.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.testing.DynamicReply.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      message_ = "";
-      bitField0_ = (bitField0_ & ~0x00000001);
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_DynamicReply_descriptor;
-    }
-
-    public io.grpc.reflection.testing.DynamicReply getDefaultInstanceForType() {
-      return io.grpc.reflection.testing.DynamicReply.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.testing.DynamicReply build() {
-      io.grpc.reflection.testing.DynamicReply result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.testing.DynamicReply buildPartial() {
-      io.grpc.reflection.testing.DynamicReply result = new io.grpc.reflection.testing.DynamicReply(this);
-      int from_bitField0_ = bitField0_;
-      int to_bitField0_ = 0;
-      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
-        to_bitField0_ |= 0x00000001;
-      }
-      result.message_ = message_;
-      result.bitField0_ = to_bitField0_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.testing.DynamicReply) {
-        return mergeFrom((io.grpc.reflection.testing.DynamicReply)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.testing.DynamicReply other) {
-      if (other == io.grpc.reflection.testing.DynamicReply.getDefaultInstance()) return this;
-      if (other.hasMessage()) {
-        bitField0_ |= 0x00000001;
-        message_ = other.message_;
-        onChanged();
-      }
-      this.mergeUnknownFields(other.unknownFields);
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.testing.DynamicReply parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.testing.DynamicReply) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int bitField0_;
-
-    private java.lang.Object message_ = "";
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public boolean hasMessage() {
-      return ((bitField0_ & 0x00000001) == 0x00000001);
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public java.lang.String getMessage() {
-      java.lang.Object ref = message_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        if (bs.isValidUtf8()) {
-          message_ = s;
-        }
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getMessageBytes() {
-      java.lang.Object ref = message_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        message_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder setMessage(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      message_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder clearMessage() {
-      bitField0_ = (bitField0_ & ~0x00000001);
-      message_ = getDefaultInstance().getMessage();
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder setMessageBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      message_ = value;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.setUnknownFields(unknownFields);
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.mergeUnknownFields(unknownFields);
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.testing.DynamicReply)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.testing.DynamicReply)
-  private static final io.grpc.reflection.testing.DynamicReply DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.testing.DynamicReply();
-  }
-
-  public static io.grpc.reflection.testing.DynamicReply getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  @java.lang.Deprecated public static final com.google.protobuf.Parser<DynamicReply>
-      PARSER = new com.google.protobuf.AbstractParser<DynamicReply>() {
-    public DynamicReply parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new DynamicReply(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<DynamicReply> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<DynamicReply> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.testing.DynamicReply getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/DynamicReplyOrBuilder.java b/services/src/generated/test/java/io/grpc/reflection/testing/DynamicReplyOrBuilder.java
deleted file mode 100644
index 2bf559b165c..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/DynamicReplyOrBuilder.java
+++ /dev/null
@@ -1,23 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto
-
-package io.grpc.reflection.testing;
-
-public interface DynamicReplyOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.testing.DynamicReply)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  boolean hasMessage();
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  java.lang.String getMessage();
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getMessageBytes();
-}
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/DynamicRequest.java b/services/src/generated/test/java/io/grpc/reflection/testing/DynamicRequest.java
deleted file mode 100644
index 73b231cc8e6..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/DynamicRequest.java
+++ /dev/null
@@ -1,531 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto
-
-package io.grpc.reflection.testing;
-
-/**
- * Protobuf type {@code grpc.reflection.testing.DynamicRequest}
- */
-public  final class DynamicRequest extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.testing.DynamicRequest)
-    DynamicRequestOrBuilder {
-  // Use DynamicRequest.newBuilder() to construct.
-  private DynamicRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private DynamicRequest() {
-    message_ = "";
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return this.unknownFields;
-  }
-  private DynamicRequest(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    com.google.protobuf.UnknownFieldSet.Builder unknownFields =
-        com.google.protobuf.UnknownFieldSet.newBuilder();
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!parseUnknownField(input, unknownFields,
-                                   extensionRegistry, tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            com.google.protobuf.ByteString bs = input.readBytes();
-            bitField0_ |= 0x00000001;
-            message_ = bs;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      this.unknownFields = unknownFields.build();
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_DynamicRequest_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_DynamicRequest_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.testing.DynamicRequest.class, io.grpc.reflection.testing.DynamicRequest.Builder.class);
-  }
-
-  private int bitField0_;
-  public static final int MESSAGE_FIELD_NUMBER = 1;
-  private volatile java.lang.Object message_;
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public boolean hasMessage() {
-    return ((bitField0_ & 0x00000001) == 0x00000001);
-  }
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public java.lang.String getMessage() {
-    java.lang.Object ref = message_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      if (bs.isValidUtf8()) {
-        message_ = s;
-      }
-      return s;
-    }
-  }
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getMessageBytes() {
-    java.lang.Object ref = message_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      message_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, message_);
-    }
-    unknownFields.writeTo(output);
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, message_);
-    }
-    size += unknownFields.getSerializedSize();
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.testing.DynamicRequest)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.testing.DynamicRequest other = (io.grpc.reflection.testing.DynamicRequest) obj;
-
-    boolean result = true;
-    result = result && (hasMessage() == other.hasMessage());
-    if (hasMessage()) {
-      result = result && getMessage()
-          .equals(other.getMessage());
-    }
-    result = result && unknownFields.equals(other.unknownFields);
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    if (hasMessage()) {
-      hash = (37 * hash) + MESSAGE_FIELD_NUMBER;
-      hash = (53 * hash) + getMessage().hashCode();
-    }
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.testing.DynamicRequest parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.DynamicRequest parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.DynamicRequest parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.DynamicRequest parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.DynamicRequest parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.DynamicRequest parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.DynamicRequest parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.DynamicRequest parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.DynamicRequest parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.DynamicRequest parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.testing.DynamicRequest prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.reflection.testing.DynamicRequest}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.testing.DynamicRequest)
-      io.grpc.reflection.testing.DynamicRequestOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_DynamicRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_DynamicRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.testing.DynamicRequest.class, io.grpc.reflection.testing.DynamicRequest.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.testing.DynamicRequest.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      message_ = "";
-      bitField0_ = (bitField0_ & ~0x00000001);
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_DynamicRequest_descriptor;
-    }
-
-    public io.grpc.reflection.testing.DynamicRequest getDefaultInstanceForType() {
-      return io.grpc.reflection.testing.DynamicRequest.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.testing.DynamicRequest build() {
-      io.grpc.reflection.testing.DynamicRequest result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.testing.DynamicRequest buildPartial() {
-      io.grpc.reflection.testing.DynamicRequest result = new io.grpc.reflection.testing.DynamicRequest(this);
-      int from_bitField0_ = bitField0_;
-      int to_bitField0_ = 0;
-      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
-        to_bitField0_ |= 0x00000001;
-      }
-      result.message_ = message_;
-      result.bitField0_ = to_bitField0_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.testing.DynamicRequest) {
-        return mergeFrom((io.grpc.reflection.testing.DynamicRequest)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.testing.DynamicRequest other) {
-      if (other == io.grpc.reflection.testing.DynamicRequest.getDefaultInstance()) return this;
-      if (other.hasMessage()) {
-        bitField0_ |= 0x00000001;
-        message_ = other.message_;
-        onChanged();
-      }
-      this.mergeUnknownFields(other.unknownFields);
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.testing.DynamicRequest parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.testing.DynamicRequest) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int bitField0_;
-
-    private java.lang.Object message_ = "";
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public boolean hasMessage() {
-      return ((bitField0_ & 0x00000001) == 0x00000001);
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public java.lang.String getMessage() {
-      java.lang.Object ref = message_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        if (bs.isValidUtf8()) {
-          message_ = s;
-        }
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getMessageBytes() {
-      java.lang.Object ref = message_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        message_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder setMessage(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      message_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder clearMessage() {
-      bitField0_ = (bitField0_ & ~0x00000001);
-      message_ = getDefaultInstance().getMessage();
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder setMessageBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      message_ = value;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.setUnknownFields(unknownFields);
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.mergeUnknownFields(unknownFields);
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.testing.DynamicRequest)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.testing.DynamicRequest)
-  private static final io.grpc.reflection.testing.DynamicRequest DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.testing.DynamicRequest();
-  }
-
-  public static io.grpc.reflection.testing.DynamicRequest getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  @java.lang.Deprecated public static final com.google.protobuf.Parser<DynamicRequest>
-      PARSER = new com.google.protobuf.AbstractParser<DynamicRequest>() {
-    public DynamicRequest parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new DynamicRequest(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<DynamicRequest> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<DynamicRequest> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.testing.DynamicRequest getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/DynamicRequestOrBuilder.java b/services/src/generated/test/java/io/grpc/reflection/testing/DynamicRequestOrBuilder.java
deleted file mode 100644
index 8ad284af2b2..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/DynamicRequestOrBuilder.java
+++ /dev/null
@@ -1,23 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto
-
-package io.grpc.reflection.testing;
-
-public interface DynamicRequestOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.testing.DynamicRequest)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  boolean hasMessage();
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  java.lang.String getMessage();
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getMessageBytes();
-}
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/EmptyMessage.java b/services/src/generated/test/java/io/grpc/reflection/testing/EmptyMessage.java
deleted file mode 100644
index 43bfccc478e..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/EmptyMessage.java
+++ /dev/null
@@ -1,374 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test_depth_three.proto
-
-package io.grpc.reflection.testing;
-
-/**
- * Protobuf type {@code grpc.reflection.testing.EmptyMessage}
- */
-public  final class EmptyMessage extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.testing.EmptyMessage)
-    EmptyMessageOrBuilder {
-  // Use EmptyMessage.newBuilder() to construct.
-  private EmptyMessage(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private EmptyMessage() {
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return this.unknownFields;
-  }
-  private EmptyMessage(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    com.google.protobuf.UnknownFieldSet.Builder unknownFields =
-        com.google.protobuf.UnknownFieldSet.newBuilder();
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!parseUnknownField(input, unknownFields,
-                                   extensionRegistry, tag)) {
-              done = true;
-            }
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      this.unknownFields = unknownFields.build();
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_EmptyMessage_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_EmptyMessage_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.testing.EmptyMessage.class, io.grpc.reflection.testing.EmptyMessage.Builder.class);
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    unknownFields.writeTo(output);
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    size += unknownFields.getSerializedSize();
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.testing.EmptyMessage)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.testing.EmptyMessage other = (io.grpc.reflection.testing.EmptyMessage) obj;
-
-    boolean result = true;
-    result = result && unknownFields.equals(other.unknownFields);
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.testing.EmptyMessage parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.EmptyMessage parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.EmptyMessage parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.EmptyMessage parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.EmptyMessage parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.EmptyMessage parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.EmptyMessage parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.EmptyMessage parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.EmptyMessage parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.EmptyMessage parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.testing.EmptyMessage prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.reflection.testing.EmptyMessage}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.testing.EmptyMessage)
-      io.grpc.reflection.testing.EmptyMessageOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_EmptyMessage_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_EmptyMessage_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.testing.EmptyMessage.class, io.grpc.reflection.testing.EmptyMessage.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.testing.EmptyMessage.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_EmptyMessage_descriptor;
-    }
-
-    public io.grpc.reflection.testing.EmptyMessage getDefaultInstanceForType() {
-      return io.grpc.reflection.testing.EmptyMessage.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.testing.EmptyMessage build() {
-      io.grpc.reflection.testing.EmptyMessage result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.testing.EmptyMessage buildPartial() {
-      io.grpc.reflection.testing.EmptyMessage result = new io.grpc.reflection.testing.EmptyMessage(this);
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.testing.EmptyMessage) {
-        return mergeFrom((io.grpc.reflection.testing.EmptyMessage)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.testing.EmptyMessage other) {
-      if (other == io.grpc.reflection.testing.EmptyMessage.getDefaultInstance()) return this;
-      this.mergeUnknownFields(other.unknownFields);
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.testing.EmptyMessage parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.testing.EmptyMessage) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.setUnknownFields(unknownFields);
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.mergeUnknownFields(unknownFields);
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.testing.EmptyMessage)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.testing.EmptyMessage)
-  private static final io.grpc.reflection.testing.EmptyMessage DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.testing.EmptyMessage();
-  }
-
-  public static io.grpc.reflection.testing.EmptyMessage getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  @java.lang.Deprecated public static final com.google.protobuf.Parser<EmptyMessage>
-      PARSER = new com.google.protobuf.AbstractParser<EmptyMessage>() {
-    public EmptyMessage parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new EmptyMessage(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<EmptyMessage> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<EmptyMessage> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.testing.EmptyMessage getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/EmptyMessageOrBuilder.java b/services/src/generated/test/java/io/grpc/reflection/testing/EmptyMessageOrBuilder.java
deleted file mode 100644
index 5f02779213e..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/EmptyMessageOrBuilder.java
+++ /dev/null
@@ -1,9 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test_depth_three.proto
-
-package io.grpc.reflection.testing;
-
-public interface EmptyMessageOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.testing.EmptyMessage)
-    com.google.protobuf.MessageOrBuilder {
-}
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/NestedTypeOuter.java b/services/src/generated/test/java/io/grpc/reflection/testing/NestedTypeOuter.java
deleted file mode 100644
index e4b9b3a660f..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/NestedTypeOuter.java
+++ /dev/null
@@ -1,1213 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test_depth_three.proto
-
-package io.grpc.reflection.testing;
-
-/**
- * Protobuf type {@code grpc.reflection.testing.NestedTypeOuter}
- */
-public  final class NestedTypeOuter extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.testing.NestedTypeOuter)
-    NestedTypeOuterOrBuilder {
-  // Use NestedTypeOuter.newBuilder() to construct.
-  private NestedTypeOuter(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private NestedTypeOuter() {
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return this.unknownFields;
-  }
-  private NestedTypeOuter(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    com.google.protobuf.UnknownFieldSet.Builder unknownFields =
-        com.google.protobuf.UnknownFieldSet.newBuilder();
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!parseUnknownField(input, unknownFields,
-                                   extensionRegistry, tag)) {
-              done = true;
-            }
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      this.unknownFields = unknownFields.build();
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.testing.NestedTypeOuter.class, io.grpc.reflection.testing.NestedTypeOuter.Builder.class);
-  }
-
-  public interface MiddleOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.reflection.testing.NestedTypeOuter.Middle)
-      com.google.protobuf.MessageOrBuilder {
-  }
-  /**
-   * Protobuf type {@code grpc.reflection.testing.NestedTypeOuter.Middle}
-   */
-  public  static final class Middle extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.reflection.testing.NestedTypeOuter.Middle)
-      MiddleOrBuilder {
-    // Use Middle.newBuilder() to construct.
-    private Middle(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private Middle() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return this.unknownFields;
-    }
-    private Middle(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
-          com.google.protobuf.UnknownFieldSet.newBuilder();
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!parseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
-                done = true;
-              }
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        this.unknownFields = unknownFields.build();
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.testing.NestedTypeOuter.Middle.class, io.grpc.reflection.testing.NestedTypeOuter.Middle.Builder.class);
-    }
-
-    public interface InnerOrBuilder extends
-        // @@protoc_insertion_point(interface_extends:grpc.reflection.testing.NestedTypeOuter.Middle.Inner)
-        com.google.protobuf.MessageOrBuilder {
-
-      /**
-       * <code>optional int32 ival = 1;</code>
-       */
-      boolean hasIval();
-      /**
-       * <code>optional int32 ival = 1;</code>
-       */
-      int getIval();
-    }
-    /**
-     * Protobuf type {@code grpc.reflection.testing.NestedTypeOuter.Middle.Inner}
-     */
-    public  static final class Inner extends
-        com.google.protobuf.GeneratedMessageV3 implements
-        // @@protoc_insertion_point(message_implements:grpc.reflection.testing.NestedTypeOuter.Middle.Inner)
-        InnerOrBuilder {
-      // Use Inner.newBuilder() to construct.
-      private Inner(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-        super(builder);
-      }
-      private Inner() {
-        ival_ = 0;
-      }
-
-      @java.lang.Override
-      public final com.google.protobuf.UnknownFieldSet
-      getUnknownFields() {
-        return this.unknownFields;
-      }
-      private Inner(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-        this();
-        int mutable_bitField0_ = 0;
-        com.google.protobuf.UnknownFieldSet.Builder unknownFields =
-            com.google.protobuf.UnknownFieldSet.newBuilder();
-        try {
-          boolean done = false;
-          while (!done) {
-            int tag = input.readTag();
-            switch (tag) {
-              case 0:
-                done = true;
-                break;
-              default: {
-                if (!parseUnknownField(input, unknownFields,
-                                       extensionRegistry, tag)) {
-                  done = true;
-                }
-                break;
-              }
-              case 8: {
-                bitField0_ |= 0x00000001;
-                ival_ = input.readInt32();
-                break;
-              }
-            }
-          }
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          throw e.setUnfinishedMessage(this);
-        } catch (java.io.IOException e) {
-          throw new com.google.protobuf.InvalidProtocolBufferException(
-              e).setUnfinishedMessage(this);
-        } finally {
-          this.unknownFields = unknownFields.build();
-          makeExtensionsImmutable();
-        }
-      }
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_Inner_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_Inner_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner.class, io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner.Builder.class);
-      }
-
-      private int bitField0_;
-      public static final int IVAL_FIELD_NUMBER = 1;
-      private int ival_;
-      /**
-       * <code>optional int32 ival = 1;</code>
-       */
-      public boolean hasIval() {
-        return ((bitField0_ & 0x00000001) == 0x00000001);
-      }
-      /**
-       * <code>optional int32 ival = 1;</code>
-       */
-      public int getIval() {
-        return ival_;
-      }
-
-      private byte memoizedIsInitialized = -1;
-      public final boolean isInitialized() {
-        byte isInitialized = memoizedIsInitialized;
-        if (isInitialized == 1) return true;
-        if (isInitialized == 0) return false;
-
-        memoizedIsInitialized = 1;
-        return true;
-      }
-
-      public void writeTo(com.google.protobuf.CodedOutputStream output)
-                          throws java.io.IOException {
-        if (((bitField0_ & 0x00000001) == 0x00000001)) {
-          output.writeInt32(1, ival_);
-        }
-        unknownFields.writeTo(output);
-      }
-
-      public int getSerializedSize() {
-        int size = memoizedSize;
-        if (size != -1) return size;
-
-        size = 0;
-        if (((bitField0_ & 0x00000001) == 0x00000001)) {
-          size += com.google.protobuf.CodedOutputStream
-            .computeInt32Size(1, ival_);
-        }
-        size += unknownFields.getSerializedSize();
-        memoizedSize = size;
-        return size;
-      }
-
-      private static final long serialVersionUID = 0L;
-      @java.lang.Override
-      public boolean equals(final java.lang.Object obj) {
-        if (obj == this) {
-         return true;
-        }
-        if (!(obj instanceof io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner)) {
-          return super.equals(obj);
-        }
-        io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner other = (io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner) obj;
-
-        boolean result = true;
-        result = result && (hasIval() == other.hasIval());
-        if (hasIval()) {
-          result = result && (getIval()
-              == other.getIval());
-        }
-        result = result && unknownFields.equals(other.unknownFields);
-        return result;
-      }
-
-      @java.lang.Override
-      public int hashCode() {
-        if (memoizedHashCode != 0) {
-          return memoizedHashCode;
-        }
-        int hash = 41;
-        hash = (19 * hash) + getDescriptor().hashCode();
-        if (hasIval()) {
-          hash = (37 * hash) + IVAL_FIELD_NUMBER;
-          hash = (53 * hash) + getIval();
-        }
-        hash = (29 * hash) + unknownFields.hashCode();
-        memoizedHashCode = hash;
-        return hash;
-      }
-
-      public static io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner parseFrom(
-          com.google.protobuf.ByteString data)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-        return PARSER.parseFrom(data);
-      }
-      public static io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner parseFrom(
-          com.google.protobuf.ByteString data,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-        return PARSER.parseFrom(data, extensionRegistry);
-      }
-      public static io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner parseFrom(byte[] data)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-        return PARSER.parseFrom(data);
-      }
-      public static io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner parseFrom(
-          byte[] data,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-        return PARSER.parseFrom(data, extensionRegistry);
-      }
-      public static io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner parseFrom(java.io.InputStream input)
-          throws java.io.IOException {
-        return com.google.protobuf.GeneratedMessageV3
-            .parseWithIOException(PARSER, input);
-      }
-      public static io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner parseFrom(
-          java.io.InputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        return com.google.protobuf.GeneratedMessageV3
-            .parseWithIOException(PARSER, input, extensionRegistry);
-      }
-      public static io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner parseDelimitedFrom(java.io.InputStream input)
-          throws java.io.IOException {
-        return com.google.protobuf.GeneratedMessageV3
-            .parseDelimitedWithIOException(PARSER, input);
-      }
-      public static io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner parseDelimitedFrom(
-          java.io.InputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        return com.google.protobuf.GeneratedMessageV3
-            .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-      }
-      public static io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner parseFrom(
-          com.google.protobuf.CodedInputStream input)
-          throws java.io.IOException {
-        return com.google.protobuf.GeneratedMessageV3
-            .parseWithIOException(PARSER, input);
-      }
-      public static io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner parseFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        return com.google.protobuf.GeneratedMessageV3
-            .parseWithIOException(PARSER, input, extensionRegistry);
-      }
-
-      public Builder newBuilderForType() { return newBuilder(); }
-      public static Builder newBuilder() {
-        return DEFAULT_INSTANCE.toBuilder();
-      }
-      public static Builder newBuilder(io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner prototype) {
-        return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-      }
-      public Builder toBuilder() {
-        return this == DEFAULT_INSTANCE
-            ? new Builder() : new Builder().mergeFrom(this);
-      }
-
-      @java.lang.Override
-      protected Builder newBuilderForType(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        Builder builder = new Builder(parent);
-        return builder;
-      }
-      /**
-       * Protobuf type {@code grpc.reflection.testing.NestedTypeOuter.Middle.Inner}
-       */
-      public static final class Builder extends
-          com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-          // @@protoc_insertion_point(builder_implements:grpc.reflection.testing.NestedTypeOuter.Middle.Inner)
-          io.grpc.reflection.testing.NestedTypeOuter.Middle.InnerOrBuilder {
-        public static final com.google.protobuf.Descriptors.Descriptor
-            getDescriptor() {
-          return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_Inner_descriptor;
-        }
-
-        protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-            internalGetFieldAccessorTable() {
-          return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_Inner_fieldAccessorTable
-              .ensureFieldAccessorsInitialized(
-                  io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner.class, io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner.Builder.class);
-        }
-
-        // Construct using io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner.newBuilder()
-        private Builder() {
-          maybeForceBuilderInitialization();
-        }
-
-        private Builder(
-            com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-          super(parent);
-          maybeForceBuilderInitialization();
-        }
-        private void maybeForceBuilderInitialization() {
-          if (com.google.protobuf.GeneratedMessageV3
-                  .alwaysUseFieldBuilders) {
-          }
-        }
-        public Builder clear() {
-          super.clear();
-          ival_ = 0;
-          bitField0_ = (bitField0_ & ~0x00000001);
-          return this;
-        }
-
-        public com.google.protobuf.Descriptors.Descriptor
-            getDescriptorForType() {
-          return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_Inner_descriptor;
-        }
-
-        public io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner getDefaultInstanceForType() {
-          return io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner.getDefaultInstance();
-        }
-
-        public io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner build() {
-          io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner result = buildPartial();
-          if (!result.isInitialized()) {
-            throw newUninitializedMessageException(result);
-          }
-          return result;
-        }
-
-        public io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner buildPartial() {
-          io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner result = new io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner(this);
-          int from_bitField0_ = bitField0_;
-          int to_bitField0_ = 0;
-          if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
-            to_bitField0_ |= 0x00000001;
-          }
-          result.ival_ = ival_;
-          result.bitField0_ = to_bitField0_;
-          onBuilt();
-          return result;
-        }
-
-        public Builder clone() {
-          return (Builder) super.clone();
-        }
-        public Builder setField(
-            com.google.protobuf.Descriptors.FieldDescriptor field,
-            Object value) {
-          return (Builder) super.setField(field, value);
-        }
-        public Builder clearField(
-            com.google.protobuf.Descriptors.FieldDescriptor field) {
-          return (Builder) super.clearField(field);
-        }
-        public Builder clearOneof(
-            com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-          return (Builder) super.clearOneof(oneof);
-        }
-        public Builder setRepeatedField(
-            com.google.protobuf.Descriptors.FieldDescriptor field,
-            int index, Object value) {
-          return (Builder) super.setRepeatedField(field, index, value);
-        }
-        public Builder addRepeatedField(
-            com.google.protobuf.Descriptors.FieldDescriptor field,
-            Object value) {
-          return (Builder) super.addRepeatedField(field, value);
-        }
-        public Builder mergeFrom(com.google.protobuf.Message other) {
-          if (other instanceof io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner) {
-            return mergeFrom((io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner)other);
-          } else {
-            super.mergeFrom(other);
-            return this;
-          }
-        }
-
-        public Builder mergeFrom(io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner other) {
-          if (other == io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner.getDefaultInstance()) return this;
-          if (other.hasIval()) {
-            setIval(other.getIval());
-          }
-          this.mergeUnknownFields(other.unknownFields);
-          onChanged();
-          return this;
-        }
-
-        public final boolean isInitialized() {
-          return true;
-        }
-
-        public Builder mergeFrom(
-            com.google.protobuf.CodedInputStream input,
-            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-            throws java.io.IOException {
-          io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner parsedMessage = null;
-          try {
-            parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-          } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-            parsedMessage = (io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner) e.getUnfinishedMessage();
-            throw e.unwrapIOException();
-          } finally {
-            if (parsedMessage != null) {
-              mergeFrom(parsedMessage);
-            }
-          }
-          return this;
-        }
-        private int bitField0_;
-
-        private int ival_ ;
-        /**
-         * <code>optional int32 ival = 1;</code>
-         */
-        public boolean hasIval() {
-          return ((bitField0_ & 0x00000001) == 0x00000001);
-        }
-        /**
-         * <code>optional int32 ival = 1;</code>
-         */
-        public int getIval() {
-          return ival_;
-        }
-        /**
-         * <code>optional int32 ival = 1;</code>
-         */
-        public Builder setIval(int value) {
-          bitField0_ |= 0x00000001;
-          ival_ = value;
-          onChanged();
-          return this;
-        }
-        /**
-         * <code>optional int32 ival = 1;</code>
-         */
-        public Builder clearIval() {
-          bitField0_ = (bitField0_ & ~0x00000001);
-          ival_ = 0;
-          onChanged();
-          return this;
-        }
-        public final Builder setUnknownFields(
-            final com.google.protobuf.UnknownFieldSet unknownFields) {
-          return super.setUnknownFields(unknownFields);
-        }
-
-        public final Builder mergeUnknownFields(
-            final com.google.protobuf.UnknownFieldSet unknownFields) {
-          return super.mergeUnknownFields(unknownFields);
-        }
-
-
-        // @@protoc_insertion_point(builder_scope:grpc.reflection.testing.NestedTypeOuter.Middle.Inner)
-      }
-
-      // @@protoc_insertion_point(class_scope:grpc.reflection.testing.NestedTypeOuter.Middle.Inner)
-      private static final io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner DEFAULT_INSTANCE;
-      static {
-        DEFAULT_INSTANCE = new io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner();
-      }
-
-      public static io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner getDefaultInstance() {
-        return DEFAULT_INSTANCE;
-      }
-
-      @java.lang.Deprecated public static final com.google.protobuf.Parser<Inner>
-          PARSER = new com.google.protobuf.AbstractParser<Inner>() {
-        public Inner parsePartialFrom(
-            com.google.protobuf.CodedInputStream input,
-            com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-            throws com.google.protobuf.InvalidProtocolBufferException {
-            return new Inner(input, extensionRegistry);
-        }
-      };
-
-      public static com.google.protobuf.Parser<Inner> parser() {
-        return PARSER;
-      }
-
-      @java.lang.Override
-      public com.google.protobuf.Parser<Inner> getParserForType() {
-        return PARSER;
-      }
-
-      public io.grpc.reflection.testing.NestedTypeOuter.Middle.Inner getDefaultInstanceForType() {
-        return DEFAULT_INSTANCE;
-      }
-
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      unknownFields.writeTo(output);
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      size += unknownFields.getSerializedSize();
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.reflection.testing.NestedTypeOuter.Middle)) {
-        return super.equals(obj);
-      }
-      io.grpc.reflection.testing.NestedTypeOuter.Middle other = (io.grpc.reflection.testing.NestedTypeOuter.Middle) obj;
-
-      boolean result = true;
-      result = result && unknownFields.equals(other.unknownFields);
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.reflection.testing.NestedTypeOuter.Middle parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.reflection.testing.NestedTypeOuter.Middle parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.reflection.testing.NestedTypeOuter.Middle parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.reflection.testing.NestedTypeOuter.Middle parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.reflection.testing.NestedTypeOuter.Middle parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.reflection.testing.NestedTypeOuter.Middle parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.reflection.testing.NestedTypeOuter.Middle parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.reflection.testing.NestedTypeOuter.Middle parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.reflection.testing.NestedTypeOuter.Middle parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.reflection.testing.NestedTypeOuter.Middle parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.reflection.testing.NestedTypeOuter.Middle prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.reflection.testing.NestedTypeOuter.Middle}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.reflection.testing.NestedTypeOuter.Middle)
-        io.grpc.reflection.testing.NestedTypeOuter.MiddleOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.reflection.testing.NestedTypeOuter.Middle.class, io.grpc.reflection.testing.NestedTypeOuter.Middle.Builder.class);
-      }
-
-      // Construct using io.grpc.reflection.testing.NestedTypeOuter.Middle.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_descriptor;
-      }
-
-      public io.grpc.reflection.testing.NestedTypeOuter.Middle getDefaultInstanceForType() {
-        return io.grpc.reflection.testing.NestedTypeOuter.Middle.getDefaultInstance();
-      }
-
-      public io.grpc.reflection.testing.NestedTypeOuter.Middle build() {
-        io.grpc.reflection.testing.NestedTypeOuter.Middle result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.reflection.testing.NestedTypeOuter.Middle buildPartial() {
-        io.grpc.reflection.testing.NestedTypeOuter.Middle result = new io.grpc.reflection.testing.NestedTypeOuter.Middle(this);
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.reflection.testing.NestedTypeOuter.Middle) {
-          return mergeFrom((io.grpc.reflection.testing.NestedTypeOuter.Middle)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.reflection.testing.NestedTypeOuter.Middle other) {
-        if (other == io.grpc.reflection.testing.NestedTypeOuter.Middle.getDefaultInstance()) return this;
-        this.mergeUnknownFields(other.unknownFields);
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.reflection.testing.NestedTypeOuter.Middle parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.reflection.testing.NestedTypeOuter.Middle) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return super.setUnknownFields(unknownFields);
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return super.mergeUnknownFields(unknownFields);
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.reflection.testing.NestedTypeOuter.Middle)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.reflection.testing.NestedTypeOuter.Middle)
-    private static final io.grpc.reflection.testing.NestedTypeOuter.Middle DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.reflection.testing.NestedTypeOuter.Middle();
-    }
-
-    public static io.grpc.reflection.testing.NestedTypeOuter.Middle getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    @java.lang.Deprecated public static final com.google.protobuf.Parser<Middle>
-        PARSER = new com.google.protobuf.AbstractParser<Middle>() {
-      public Middle parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new Middle(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<Middle> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<Middle> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.reflection.testing.NestedTypeOuter.Middle getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    unknownFields.writeTo(output);
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    size += unknownFields.getSerializedSize();
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.testing.NestedTypeOuter)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.testing.NestedTypeOuter other = (io.grpc.reflection.testing.NestedTypeOuter) obj;
-
-    boolean result = true;
-    result = result && unknownFields.equals(other.unknownFields);
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.testing.NestedTypeOuter parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.NestedTypeOuter parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.NestedTypeOuter parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.NestedTypeOuter parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.NestedTypeOuter parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.NestedTypeOuter parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.NestedTypeOuter parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.NestedTypeOuter parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.NestedTypeOuter parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.NestedTypeOuter parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.testing.NestedTypeOuter prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.reflection.testing.NestedTypeOuter}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.testing.NestedTypeOuter)
-      io.grpc.reflection.testing.NestedTypeOuterOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.testing.NestedTypeOuter.class, io.grpc.reflection.testing.NestedTypeOuter.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.testing.NestedTypeOuter.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_NestedTypeOuter_descriptor;
-    }
-
-    public io.grpc.reflection.testing.NestedTypeOuter getDefaultInstanceForType() {
-      return io.grpc.reflection.testing.NestedTypeOuter.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.testing.NestedTypeOuter build() {
-      io.grpc.reflection.testing.NestedTypeOuter result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.testing.NestedTypeOuter buildPartial() {
-      io.grpc.reflection.testing.NestedTypeOuter result = new io.grpc.reflection.testing.NestedTypeOuter(this);
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.testing.NestedTypeOuter) {
-        return mergeFrom((io.grpc.reflection.testing.NestedTypeOuter)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.testing.NestedTypeOuter other) {
-      if (other == io.grpc.reflection.testing.NestedTypeOuter.getDefaultInstance()) return this;
-      this.mergeUnknownFields(other.unknownFields);
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.testing.NestedTypeOuter parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.testing.NestedTypeOuter) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.setUnknownFields(unknownFields);
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.mergeUnknownFields(unknownFields);
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.testing.NestedTypeOuter)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.testing.NestedTypeOuter)
-  private static final io.grpc.reflection.testing.NestedTypeOuter DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.testing.NestedTypeOuter();
-  }
-
-  public static io.grpc.reflection.testing.NestedTypeOuter getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  @java.lang.Deprecated public static final com.google.protobuf.Parser<NestedTypeOuter>
-      PARSER = new com.google.protobuf.AbstractParser<NestedTypeOuter>() {
-    public NestedTypeOuter parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new NestedTypeOuter(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<NestedTypeOuter> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<NestedTypeOuter> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.testing.NestedTypeOuter getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/NestedTypeOuterOrBuilder.java b/services/src/generated/test/java/io/grpc/reflection/testing/NestedTypeOuterOrBuilder.java
deleted file mode 100644
index 96599fa0804..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/NestedTypeOuterOrBuilder.java
+++ /dev/null
@@ -1,9 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test_depth_three.proto
-
-package io.grpc.reflection.testing;
-
-public interface NestedTypeOuterOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.testing.NestedTypeOuter)
-    com.google.protobuf.MessageOrBuilder {
-}
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/ReflectionTestDepthThreeProto.java b/services/src/generated/test/java/io/grpc/reflection/testing/ReflectionTestDepthThreeProto.java
deleted file mode 100644
index e3ea7e4774a..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/ReflectionTestDepthThreeProto.java
+++ /dev/null
@@ -1,104 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test_depth_three.proto
-
-package io.grpc.reflection.testing;
-
-public final class ReflectionTestDepthThreeProto {
-  private ReflectionTestDepthThreeProto() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_testing_EmptyMessage_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_testing_EmptyMessage_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_testing_ThirdLevelType_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_testing_ThirdLevelType_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_testing_NestedTypeOuter_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_testing_NestedTypeOuter_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_Inner_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_Inner_fieldAccessorTable;
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n<io/grpc/reflection/testing/reflection_" +
-      "test_depth_three.proto\022\027grpc.reflection." +
-      "testing\"\016\n\014EmptyMessage\"(\n\016ThirdLevelTyp" +
-      "e\022\017\n\007message\030\001 \001(\t*\005\010d\020\310\001\"2\n\017NestedTypeO" +
-      "uter\032\037\n\006Middle\032\025\n\005Inner\022\014\n\004ival\030\001 \001(\005B=\n" +
-      "\032io.grpc.reflection.testingB\035ReflectionT" +
-      "estDepthThreeProtoP\001"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-        }, assigner);
-    internal_static_grpc_reflection_testing_EmptyMessage_descriptor =
-      getDescriptor().getMessageTypes().get(0);
-    internal_static_grpc_reflection_testing_EmptyMessage_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_testing_EmptyMessage_descriptor,
-        new java.lang.String[] { });
-    internal_static_grpc_reflection_testing_ThirdLevelType_descriptor =
-      getDescriptor().getMessageTypes().get(1);
-    internal_static_grpc_reflection_testing_ThirdLevelType_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_testing_ThirdLevelType_descriptor,
-        new java.lang.String[] { "Message", });
-    internal_static_grpc_reflection_testing_NestedTypeOuter_descriptor =
-      getDescriptor().getMessageTypes().get(2);
-    internal_static_grpc_reflection_testing_NestedTypeOuter_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_testing_NestedTypeOuter_descriptor,
-        new java.lang.String[] { });
-    internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_descriptor =
-      internal_static_grpc_reflection_testing_NestedTypeOuter_descriptor.getNestedTypes().get(0);
-    internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_descriptor,
-        new java.lang.String[] { });
-    internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_Inner_descriptor =
-      internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_descriptor.getNestedTypes().get(0);
-    internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_Inner_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_testing_NestedTypeOuter_Middle_Inner_descriptor,
-        new java.lang.String[] { "Ival", });
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/ReflectionTestDepthTwoAlternateProto.java b/services/src/generated/test/java/io/grpc/reflection/testing/ReflectionTestDepthTwoAlternateProto.java
deleted file mode 100644
index 12ac5a9ba2a..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/ReflectionTestDepthTwoAlternateProto.java
+++ /dev/null
@@ -1,50 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test_depth_two_alternate.proto
-
-package io.grpc.reflection.testing;
-
-public final class ReflectionTestDepthTwoAlternateProto {
-  private ReflectionTestDepthTwoAlternateProto() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\nDio/grpc/reflection/testing/reflection_" +
-      "test_depth_two_alternate.proto\032<io/grpc/" +
-      "reflection/testing/reflection_test_depth" +
-      "_three.protoBD\n\032io.grpc.reflection.testi" +
-      "ngB$ReflectionTestDepthTwoAlternateProto" +
-      "P\001P\000"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-          io.grpc.reflection.testing.ReflectionTestDepthThreeProto.getDescriptor(),
-        }, assigner);
-    io.grpc.reflection.testing.ReflectionTestDepthThreeProto.getDescriptor();
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/ReflectionTestDepthTwoProto.java b/services/src/generated/test/java/io/grpc/reflection/testing/ReflectionTestDepthTwoProto.java
deleted file mode 100644
index 59902aa4908..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/ReflectionTestDepthTwoProto.java
+++ /dev/null
@@ -1,89 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test_depth_two.proto
-
-package io.grpc.reflection.testing;
-
-public final class ReflectionTestDepthTwoProto {
-  private ReflectionTestDepthTwoProto() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-    registry.add(io.grpc.reflection.testing.ReflectionTestDepthTwoProto.nestedExtension);
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  public static final int NESTED_EXTENSION_FIELD_NUMBER = 101;
-  /**
-   * <code>extend .grpc.reflection.testing.ThirdLevelType { ... }</code>
-   */
-  public static final
-    com.google.protobuf.GeneratedMessage.GeneratedExtension<
-      io.grpc.reflection.testing.ThirdLevelType,
-      io.grpc.reflection.testing.EmptyMessage> nestedExtension = com.google.protobuf.GeneratedMessage
-          .newFileScopedGeneratedExtension(
-        io.grpc.reflection.testing.EmptyMessage.class,
-        io.grpc.reflection.testing.EmptyMessage.getDefaultInstance());
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_testing_Request_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_testing_Request_fieldAccessorTable;
-  static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_reflection_testing_Reply_descriptor;
-  static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_reflection_testing_Reply_fieldAccessorTable;
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n:io/grpc/reflection/testing/reflection_" +
-      "test_depth_two.proto\022\027grpc.reflection.te" +
-      "sting\032<io/grpc/reflection/testing/reflec" +
-      "tion_test_depth_three.proto\"\032\n\007Request\022\017" +
-      "\n\007message\030\001 \001(\t\"\030\n\005Reply\022\017\n\007message\030\001 \001(" +
-      "\t:h\n\020nested_extension\022\'.grpc.reflection." +
-      "testing.ThirdLevelType\030e \001(\0132%.grpc.refl" +
-      "ection.testing.EmptyMessageB;\n\032io.grpc.r" +
-      "eflection.testingB\033ReflectionTestDepthTw" +
-      "oProtoP\001P\000"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-          io.grpc.reflection.testing.ReflectionTestDepthThreeProto.getDescriptor(),
-        }, assigner);
-    internal_static_grpc_reflection_testing_Request_descriptor =
-      getDescriptor().getMessageTypes().get(0);
-    internal_static_grpc_reflection_testing_Request_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_testing_Request_descriptor,
-        new java.lang.String[] { "Message", });
-    internal_static_grpc_reflection_testing_Reply_descriptor =
-      getDescriptor().getMessageTypes().get(1);
-    internal_static_grpc_reflection_testing_Reply_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_reflection_testing_Reply_descriptor,
-        new java.lang.String[] { "Message", });
-    nestedExtension.internalInit(descriptor.getExtensions().get(0));
-    io.grpc.reflection.testing.ReflectionTestDepthThreeProto.getDescriptor();
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/ReflectionTestProto.java b/services/src/generated/test/java/io/grpc/reflection/testing/ReflectionTestProto.java
deleted file mode 100644
index 0463ffba0e0..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/ReflectionTestProto.java
+++ /dev/null
@@ -1,70 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test.proto
-
-package io.grpc.reflection.testing;
-
-public final class ReflectionTestProto {
-  private ReflectionTestProto() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-    registry.add(io.grpc.reflection.testing.ReflectionTestProto.bar);
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  public static final int BAR_FIELD_NUMBER = 100;
-  /**
-   * <code>extend .grpc.reflection.testing.ThirdLevelType { ... }</code>
-   */
-  public static final
-    com.google.protobuf.GeneratedMessage.GeneratedExtension<
-      io.grpc.reflection.testing.ThirdLevelType,
-      java.lang.Integer> bar = com.google.protobuf.GeneratedMessage
-          .newFileScopedGeneratedExtension(
-        java.lang.Integer.class,
-        null);
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n0io/grpc/reflection/testing/reflection_" +
-      "test.proto\022\027grpc.reflection.testing\032:io/" +
-      "grpc/reflection/testing/reflection_test_" +
-      "depth_two.proto\032Dio/grpc/reflection/test" +
-      "ing/reflection_test_depth_two_alternate." +
-      "proto2b\n\022ReflectableService\022L\n\006Method\022 ." +
-      "grpc.reflection.testing.Request\032\036.grpc.r" +
-      "eflection.testing.Reply\"\000:4\n\003bar\022\'.grpc." +
-      "reflection.testing.ThirdLevelType\030d \001(\005B" +
-      "3\n\032io.grpc.reflection.testingB\023Reflectio",
-      "nTestProtoP\001"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-          io.grpc.reflection.testing.ReflectionTestDepthTwoProto.getDescriptor(),
-          io.grpc.reflection.testing.ReflectionTestDepthTwoAlternateProto.getDescriptor(),
-        }, assigner);
-    bar.internalInit(descriptor.getExtensions().get(0));
-    io.grpc.reflection.testing.ReflectionTestDepthTwoProto.getDescriptor();
-    io.grpc.reflection.testing.ReflectionTestDepthTwoAlternateProto.getDescriptor();
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/Reply.java b/services/src/generated/test/java/io/grpc/reflection/testing/Reply.java
deleted file mode 100644
index 0e82ebef05a..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/Reply.java
+++ /dev/null
@@ -1,531 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test_depth_two.proto
-
-package io.grpc.reflection.testing;
-
-/**
- * Protobuf type {@code grpc.reflection.testing.Reply}
- */
-public  final class Reply extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.testing.Reply)
-    ReplyOrBuilder {
-  // Use Reply.newBuilder() to construct.
-  private Reply(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private Reply() {
-    message_ = "";
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return this.unknownFields;
-  }
-  private Reply(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    com.google.protobuf.UnknownFieldSet.Builder unknownFields =
-        com.google.protobuf.UnknownFieldSet.newBuilder();
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!parseUnknownField(input, unknownFields,
-                                   extensionRegistry, tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            com.google.protobuf.ByteString bs = input.readBytes();
-            bitField0_ |= 0x00000001;
-            message_ = bs;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      this.unknownFields = unknownFields.build();
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.testing.ReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_Reply_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.testing.ReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_Reply_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.testing.Reply.class, io.grpc.reflection.testing.Reply.Builder.class);
-  }
-
-  private int bitField0_;
-  public static final int MESSAGE_FIELD_NUMBER = 1;
-  private volatile java.lang.Object message_;
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public boolean hasMessage() {
-    return ((bitField0_ & 0x00000001) == 0x00000001);
-  }
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public java.lang.String getMessage() {
-    java.lang.Object ref = message_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      if (bs.isValidUtf8()) {
-        message_ = s;
-      }
-      return s;
-    }
-  }
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getMessageBytes() {
-    java.lang.Object ref = message_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      message_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, message_);
-    }
-    unknownFields.writeTo(output);
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, message_);
-    }
-    size += unknownFields.getSerializedSize();
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.testing.Reply)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.testing.Reply other = (io.grpc.reflection.testing.Reply) obj;
-
-    boolean result = true;
-    result = result && (hasMessage() == other.hasMessage());
-    if (hasMessage()) {
-      result = result && getMessage()
-          .equals(other.getMessage());
-    }
-    result = result && unknownFields.equals(other.unknownFields);
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    if (hasMessage()) {
-      hash = (37 * hash) + MESSAGE_FIELD_NUMBER;
-      hash = (53 * hash) + getMessage().hashCode();
-    }
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.testing.Reply parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.Reply parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.Reply parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.Reply parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.Reply parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.Reply parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.Reply parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.Reply parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.Reply parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.Reply parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.testing.Reply prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.reflection.testing.Reply}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.testing.Reply)
-      io.grpc.reflection.testing.ReplyOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.testing.ReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_Reply_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.testing.ReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_Reply_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.testing.Reply.class, io.grpc.reflection.testing.Reply.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.testing.Reply.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      message_ = "";
-      bitField0_ = (bitField0_ & ~0x00000001);
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.testing.ReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_Reply_descriptor;
-    }
-
-    public io.grpc.reflection.testing.Reply getDefaultInstanceForType() {
-      return io.grpc.reflection.testing.Reply.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.testing.Reply build() {
-      io.grpc.reflection.testing.Reply result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.testing.Reply buildPartial() {
-      io.grpc.reflection.testing.Reply result = new io.grpc.reflection.testing.Reply(this);
-      int from_bitField0_ = bitField0_;
-      int to_bitField0_ = 0;
-      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
-        to_bitField0_ |= 0x00000001;
-      }
-      result.message_ = message_;
-      result.bitField0_ = to_bitField0_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.testing.Reply) {
-        return mergeFrom((io.grpc.reflection.testing.Reply)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.testing.Reply other) {
-      if (other == io.grpc.reflection.testing.Reply.getDefaultInstance()) return this;
-      if (other.hasMessage()) {
-        bitField0_ |= 0x00000001;
-        message_ = other.message_;
-        onChanged();
-      }
-      this.mergeUnknownFields(other.unknownFields);
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.testing.Reply parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.testing.Reply) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int bitField0_;
-
-    private java.lang.Object message_ = "";
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public boolean hasMessage() {
-      return ((bitField0_ & 0x00000001) == 0x00000001);
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public java.lang.String getMessage() {
-      java.lang.Object ref = message_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        if (bs.isValidUtf8()) {
-          message_ = s;
-        }
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getMessageBytes() {
-      java.lang.Object ref = message_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        message_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder setMessage(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      message_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder clearMessage() {
-      bitField0_ = (bitField0_ & ~0x00000001);
-      message_ = getDefaultInstance().getMessage();
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder setMessageBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      message_ = value;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.setUnknownFields(unknownFields);
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.mergeUnknownFields(unknownFields);
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.testing.Reply)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.testing.Reply)
-  private static final io.grpc.reflection.testing.Reply DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.testing.Reply();
-  }
-
-  public static io.grpc.reflection.testing.Reply getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  @java.lang.Deprecated public static final com.google.protobuf.Parser<Reply>
-      PARSER = new com.google.protobuf.AbstractParser<Reply>() {
-    public Reply parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new Reply(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<Reply> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<Reply> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.testing.Reply getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/ReplyOrBuilder.java b/services/src/generated/test/java/io/grpc/reflection/testing/ReplyOrBuilder.java
deleted file mode 100644
index 4f5a6cac129..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/ReplyOrBuilder.java
+++ /dev/null
@@ -1,23 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test_depth_two.proto
-
-package io.grpc.reflection.testing;
-
-public interface ReplyOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.testing.Reply)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  boolean hasMessage();
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  java.lang.String getMessage();
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getMessageBytes();
-}
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/Request.java b/services/src/generated/test/java/io/grpc/reflection/testing/Request.java
deleted file mode 100644
index 63420e94d68..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/Request.java
+++ /dev/null
@@ -1,531 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test_depth_two.proto
-
-package io.grpc.reflection.testing;
-
-/**
- * Protobuf type {@code grpc.reflection.testing.Request}
- */
-public  final class Request extends
-    com.google.protobuf.GeneratedMessageV3 implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.testing.Request)
-    RequestOrBuilder {
-  // Use Request.newBuilder() to construct.
-  private Request(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-    super(builder);
-  }
-  private Request() {
-    message_ = "";
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return this.unknownFields;
-  }
-  private Request(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    com.google.protobuf.UnknownFieldSet.Builder unknownFields =
-        com.google.protobuf.UnknownFieldSet.newBuilder();
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!parseUnknownField(input, unknownFields,
-                                   extensionRegistry, tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            com.google.protobuf.ByteString bs = input.readBytes();
-            bitField0_ |= 0x00000001;
-            message_ = bs;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      this.unknownFields = unknownFields.build();
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.testing.ReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_Request_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.testing.ReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_Request_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.testing.Request.class, io.grpc.reflection.testing.Request.Builder.class);
-  }
-
-  private int bitField0_;
-  public static final int MESSAGE_FIELD_NUMBER = 1;
-  private volatile java.lang.Object message_;
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public boolean hasMessage() {
-    return ((bitField0_ & 0x00000001) == 0x00000001);
-  }
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public java.lang.String getMessage() {
-    java.lang.Object ref = message_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      if (bs.isValidUtf8()) {
-        message_ = s;
-      }
-      return s;
-    }
-  }
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getMessageBytes() {
-    java.lang.Object ref = message_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      message_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, message_);
-    }
-    unknownFields.writeTo(output);
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, message_);
-    }
-    size += unknownFields.getSerializedSize();
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.testing.Request)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.testing.Request other = (io.grpc.reflection.testing.Request) obj;
-
-    boolean result = true;
-    result = result && (hasMessage() == other.hasMessage());
-    if (hasMessage()) {
-      result = result && getMessage()
-          .equals(other.getMessage());
-    }
-    result = result && unknownFields.equals(other.unknownFields);
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    if (hasMessage()) {
-      hash = (37 * hash) + MESSAGE_FIELD_NUMBER;
-      hash = (53 * hash) + getMessage().hashCode();
-    }
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.testing.Request parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.Request parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.Request parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.Request parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.Request parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.Request parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.Request parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.Request parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.Request parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.Request parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.testing.Request prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.reflection.testing.Request}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.testing.Request)
-      io.grpc.reflection.testing.RequestOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.testing.ReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_Request_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.testing.ReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_Request_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.testing.Request.class, io.grpc.reflection.testing.Request.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.testing.Request.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      message_ = "";
-      bitField0_ = (bitField0_ & ~0x00000001);
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.testing.ReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_Request_descriptor;
-    }
-
-    public io.grpc.reflection.testing.Request getDefaultInstanceForType() {
-      return io.grpc.reflection.testing.Request.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.testing.Request build() {
-      io.grpc.reflection.testing.Request result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.testing.Request buildPartial() {
-      io.grpc.reflection.testing.Request result = new io.grpc.reflection.testing.Request(this);
-      int from_bitField0_ = bitField0_;
-      int to_bitField0_ = 0;
-      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
-        to_bitField0_ |= 0x00000001;
-      }
-      result.message_ = message_;
-      result.bitField0_ = to_bitField0_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.testing.Request) {
-        return mergeFrom((io.grpc.reflection.testing.Request)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.testing.Request other) {
-      if (other == io.grpc.reflection.testing.Request.getDefaultInstance()) return this;
-      if (other.hasMessage()) {
-        bitField0_ |= 0x00000001;
-        message_ = other.message_;
-        onChanged();
-      }
-      this.mergeUnknownFields(other.unknownFields);
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.testing.Request parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.testing.Request) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int bitField0_;
-
-    private java.lang.Object message_ = "";
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public boolean hasMessage() {
-      return ((bitField0_ & 0x00000001) == 0x00000001);
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public java.lang.String getMessage() {
-      java.lang.Object ref = message_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        if (bs.isValidUtf8()) {
-          message_ = s;
-        }
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getMessageBytes() {
-      java.lang.Object ref = message_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        message_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder setMessage(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      message_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder clearMessage() {
-      bitField0_ = (bitField0_ & ~0x00000001);
-      message_ = getDefaultInstance().getMessage();
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder setMessageBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      message_ = value;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.setUnknownFields(unknownFields);
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.mergeUnknownFields(unknownFields);
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.testing.Request)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.testing.Request)
-  private static final io.grpc.reflection.testing.Request DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.testing.Request();
-  }
-
-  public static io.grpc.reflection.testing.Request getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  @java.lang.Deprecated public static final com.google.protobuf.Parser<Request>
-      PARSER = new com.google.protobuf.AbstractParser<Request>() {
-    public Request parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new Request(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<Request> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<Request> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.testing.Request getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/RequestOrBuilder.java b/services/src/generated/test/java/io/grpc/reflection/testing/RequestOrBuilder.java
deleted file mode 100644
index 333e28075c3..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/RequestOrBuilder.java
+++ /dev/null
@@ -1,23 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test_depth_two.proto
-
-package io.grpc.reflection.testing;
-
-public interface RequestOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.testing.Request)
-    com.google.protobuf.MessageOrBuilder {
-
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  boolean hasMessage();
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  java.lang.String getMessage();
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getMessageBytes();
-}
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/ThirdLevelType.java b/services/src/generated/test/java/io/grpc/reflection/testing/ThirdLevelType.java
deleted file mode 100644
index 5a490167a09..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/ThirdLevelType.java
+++ /dev/null
@@ -1,572 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test_depth_three.proto
-
-package io.grpc.reflection.testing;
-
-/**
- * Protobuf type {@code grpc.reflection.testing.ThirdLevelType}
- */
-public  final class ThirdLevelType extends
-    com.google.protobuf.GeneratedMessageV3.ExtendableMessage<
-      ThirdLevelType> implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.testing.ThirdLevelType)
-    ThirdLevelTypeOrBuilder {
-  // Use ThirdLevelType.newBuilder() to construct.
-  private ThirdLevelType(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder<io.grpc.reflection.testing.ThirdLevelType, ?> builder) {
-    super(builder);
-  }
-  private ThirdLevelType() {
-    message_ = "";
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return this.unknownFields;
-  }
-  private ThirdLevelType(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    com.google.protobuf.UnknownFieldSet.Builder unknownFields =
-        com.google.protobuf.UnknownFieldSet.newBuilder();
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!parseUnknownField(input, unknownFields,
-                                   extensionRegistry, tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            com.google.protobuf.ByteString bs = input.readBytes();
-            bitField0_ |= 0x00000001;
-            message_ = bs;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      this.unknownFields = unknownFields.build();
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_ThirdLevelType_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_ThirdLevelType_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.testing.ThirdLevelType.class, io.grpc.reflection.testing.ThirdLevelType.Builder.class);
-  }
-
-  private int bitField0_;
-  public static final int MESSAGE_FIELD_NUMBER = 1;
-  private volatile java.lang.Object message_;
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public boolean hasMessage() {
-    return ((bitField0_ & 0x00000001) == 0x00000001);
-  }
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public java.lang.String getMessage() {
-    java.lang.Object ref = message_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      if (bs.isValidUtf8()) {
-        message_ = s;
-      }
-      return s;
-    }
-  }
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getMessageBytes() {
-    java.lang.Object ref = message_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      message_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    if (!extensionsAreInitialized()) {
-      memoizedIsInitialized = 0;
-      return false;
-    }
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    com.google.protobuf.GeneratedMessageV3
-      .ExtendableMessage<io.grpc.reflection.testing.ThirdLevelType>.ExtensionWriter
-        extensionWriter = newExtensionWriter();
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, message_);
-    }
-    extensionWriter.writeUntil(200, output);
-    unknownFields.writeTo(output);
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, message_);
-    }
-    size += extensionsSerializedSize();
-    size += unknownFields.getSerializedSize();
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.testing.ThirdLevelType)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.testing.ThirdLevelType other = (io.grpc.reflection.testing.ThirdLevelType) obj;
-
-    boolean result = true;
-    result = result && (hasMessage() == other.hasMessage());
-    if (hasMessage()) {
-      result = result && getMessage()
-          .equals(other.getMessage());
-    }
-    result = result && unknownFields.equals(other.unknownFields);
-    result = result &&
-        getExtensionFields().equals(other.getExtensionFields());
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    if (hasMessage()) {
-      hash = (37 * hash) + MESSAGE_FIELD_NUMBER;
-      hash = (53 * hash) + getMessage().hashCode();
-    }
-    hash = hashFields(hash, getExtensionFields());
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.testing.ThirdLevelType parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.ThirdLevelType parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.ThirdLevelType parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.ThirdLevelType parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.ThirdLevelType parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.ThirdLevelType parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.ThirdLevelType parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.ThirdLevelType parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.ThirdLevelType parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.ThirdLevelType parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.testing.ThirdLevelType prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.reflection.testing.ThirdLevelType}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.ExtendableBuilder<
-        io.grpc.reflection.testing.ThirdLevelType, Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.testing.ThirdLevelType)
-      io.grpc.reflection.testing.ThirdLevelTypeOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_ThirdLevelType_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_ThirdLevelType_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.testing.ThirdLevelType.class, io.grpc.reflection.testing.ThirdLevelType.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.testing.ThirdLevelType.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      message_ = "";
-      bitField0_ = (bitField0_ & ~0x00000001);
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.testing.ReflectionTestDepthThreeProto.internal_static_grpc_reflection_testing_ThirdLevelType_descriptor;
-    }
-
-    public io.grpc.reflection.testing.ThirdLevelType getDefaultInstanceForType() {
-      return io.grpc.reflection.testing.ThirdLevelType.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.testing.ThirdLevelType build() {
-      io.grpc.reflection.testing.ThirdLevelType result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.testing.ThirdLevelType buildPartial() {
-      io.grpc.reflection.testing.ThirdLevelType result = new io.grpc.reflection.testing.ThirdLevelType(this);
-      int from_bitField0_ = bitField0_;
-      int to_bitField0_ = 0;
-      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
-        to_bitField0_ |= 0x00000001;
-      }
-      result.message_ = message_;
-      result.bitField0_ = to_bitField0_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public <Type> Builder setExtension(
-        com.google.protobuf.GeneratedMessage.GeneratedExtension<
-            io.grpc.reflection.testing.ThirdLevelType, Type> extension,
-        Type value) {
-      return (Builder) super.setExtension(extension, value);
-    }
-    public <Type> Builder setExtension(
-        com.google.protobuf.GeneratedMessage.GeneratedExtension<
-            io.grpc.reflection.testing.ThirdLevelType, java.util.List<Type>> extension,
-        int index, Type value) {
-      return (Builder) super.setExtension(extension, index, value);
-    }
-    public <Type> Builder addExtension(
-        com.google.protobuf.GeneratedMessage.GeneratedExtension<
-            io.grpc.reflection.testing.ThirdLevelType, java.util.List<Type>> extension,
-        Type value) {
-      return (Builder) super.addExtension(extension, value);
-    }
-    public <Type> Builder clearExtension(
-        com.google.protobuf.GeneratedMessage.GeneratedExtension<
-            io.grpc.reflection.testing.ThirdLevelType, ?> extension) {
-      return (Builder) super.clearExtension(extension);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.testing.ThirdLevelType) {
-        return mergeFrom((io.grpc.reflection.testing.ThirdLevelType)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.testing.ThirdLevelType other) {
-      if (other == io.grpc.reflection.testing.ThirdLevelType.getDefaultInstance()) return this;
-      if (other.hasMessage()) {
-        bitField0_ |= 0x00000001;
-        message_ = other.message_;
-        onChanged();
-      }
-      this.mergeExtensionFields(other);
-      this.mergeUnknownFields(other.unknownFields);
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      if (!extensionsAreInitialized()) {
-        return false;
-      }
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.testing.ThirdLevelType parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.testing.ThirdLevelType) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int bitField0_;
-
-    private java.lang.Object message_ = "";
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public boolean hasMessage() {
-      return ((bitField0_ & 0x00000001) == 0x00000001);
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public java.lang.String getMessage() {
-      java.lang.Object ref = message_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        if (bs.isValidUtf8()) {
-          message_ = s;
-        }
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getMessageBytes() {
-      java.lang.Object ref = message_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        message_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder setMessage(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      message_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder clearMessage() {
-      bitField0_ = (bitField0_ & ~0x00000001);
-      message_ = getDefaultInstance().getMessage();
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder setMessageBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      message_ = value;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.setUnknownFields(unknownFields);
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.mergeUnknownFields(unknownFields);
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.testing.ThirdLevelType)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.testing.ThirdLevelType)
-  private static final io.grpc.reflection.testing.ThirdLevelType DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.testing.ThirdLevelType();
-  }
-
-  public static io.grpc.reflection.testing.ThirdLevelType getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  @java.lang.Deprecated public static final com.google.protobuf.Parser<ThirdLevelType>
-      PARSER = new com.google.protobuf.AbstractParser<ThirdLevelType>() {
-    public ThirdLevelType parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new ThirdLevelType(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<ThirdLevelType> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<ThirdLevelType> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.testing.ThirdLevelType getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/ThirdLevelTypeOrBuilder.java b/services/src/generated/test/java/io/grpc/reflection/testing/ThirdLevelTypeOrBuilder.java
deleted file mode 100644
index ca3ff1a36a2..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/ThirdLevelTypeOrBuilder.java
+++ /dev/null
@@ -1,24 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/reflection_test_depth_three.proto
-
-package io.grpc.reflection.testing;
-
-public interface ThirdLevelTypeOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.testing.ThirdLevelType)
-    com.google.protobuf.GeneratedMessageV3.
-        ExtendableMessageOrBuilder<ThirdLevelType> {
-
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  boolean hasMessage();
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  java.lang.String getMessage();
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getMessageBytes();
-}
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/TypeWithExtensions.java b/services/src/generated/test/java/io/grpc/reflection/testing/TypeWithExtensions.java
deleted file mode 100644
index ba98717d616..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/TypeWithExtensions.java
+++ /dev/null
@@ -1,572 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto
-
-package io.grpc.reflection.testing;
-
-/**
- * Protobuf type {@code grpc.reflection.testing.TypeWithExtensions}
- */
-public  final class TypeWithExtensions extends
-    com.google.protobuf.GeneratedMessageV3.ExtendableMessage<
-      TypeWithExtensions> implements
-    // @@protoc_insertion_point(message_implements:grpc.reflection.testing.TypeWithExtensions)
-    TypeWithExtensionsOrBuilder {
-  // Use TypeWithExtensions.newBuilder() to construct.
-  private TypeWithExtensions(com.google.protobuf.GeneratedMessageV3.ExtendableBuilder<io.grpc.reflection.testing.TypeWithExtensions, ?> builder) {
-    super(builder);
-  }
-  private TypeWithExtensions() {
-    message_ = "";
-  }
-
-  @java.lang.Override
-  public final com.google.protobuf.UnknownFieldSet
-  getUnknownFields() {
-    return this.unknownFields;
-  }
-  private TypeWithExtensions(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    this();
-    int mutable_bitField0_ = 0;
-    com.google.protobuf.UnknownFieldSet.Builder unknownFields =
-        com.google.protobuf.UnknownFieldSet.newBuilder();
-    try {
-      boolean done = false;
-      while (!done) {
-        int tag = input.readTag();
-        switch (tag) {
-          case 0:
-            done = true;
-            break;
-          default: {
-            if (!parseUnknownField(input, unknownFields,
-                                   extensionRegistry, tag)) {
-              done = true;
-            }
-            break;
-          }
-          case 10: {
-            com.google.protobuf.ByteString bs = input.readBytes();
-            bitField0_ |= 0x00000001;
-            message_ = bs;
-            break;
-          }
-        }
-      }
-    } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-      throw e.setUnfinishedMessage(this);
-    } catch (java.io.IOException e) {
-      throw new com.google.protobuf.InvalidProtocolBufferException(
-          e).setUnfinishedMessage(this);
-    } finally {
-      this.unknownFields = unknownFields.build();
-      makeExtensionsImmutable();
-    }
-  }
-  public static final com.google.protobuf.Descriptors.Descriptor
-      getDescriptor() {
-    return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_TypeWithExtensions_descriptor;
-  }
-
-  protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internalGetFieldAccessorTable() {
-    return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_TypeWithExtensions_fieldAccessorTable
-        .ensureFieldAccessorsInitialized(
-            io.grpc.reflection.testing.TypeWithExtensions.class, io.grpc.reflection.testing.TypeWithExtensions.Builder.class);
-  }
-
-  private int bitField0_;
-  public static final int MESSAGE_FIELD_NUMBER = 1;
-  private volatile java.lang.Object message_;
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public boolean hasMessage() {
-    return ((bitField0_ & 0x00000001) == 0x00000001);
-  }
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public java.lang.String getMessage() {
-    java.lang.Object ref = message_;
-    if (ref instanceof java.lang.String) {
-      return (java.lang.String) ref;
-    } else {
-      com.google.protobuf.ByteString bs = 
-          (com.google.protobuf.ByteString) ref;
-      java.lang.String s = bs.toStringUtf8();
-      if (bs.isValidUtf8()) {
-        message_ = s;
-      }
-      return s;
-    }
-  }
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  public com.google.protobuf.ByteString
-      getMessageBytes() {
-    java.lang.Object ref = message_;
-    if (ref instanceof java.lang.String) {
-      com.google.protobuf.ByteString b = 
-          com.google.protobuf.ByteString.copyFromUtf8(
-              (java.lang.String) ref);
-      message_ = b;
-      return b;
-    } else {
-      return (com.google.protobuf.ByteString) ref;
-    }
-  }
-
-  private byte memoizedIsInitialized = -1;
-  public final boolean isInitialized() {
-    byte isInitialized = memoizedIsInitialized;
-    if (isInitialized == 1) return true;
-    if (isInitialized == 0) return false;
-
-    if (!extensionsAreInitialized()) {
-      memoizedIsInitialized = 0;
-      return false;
-    }
-    memoizedIsInitialized = 1;
-    return true;
-  }
-
-  public void writeTo(com.google.protobuf.CodedOutputStream output)
-                      throws java.io.IOException {
-    com.google.protobuf.GeneratedMessageV3
-      .ExtendableMessage<io.grpc.reflection.testing.TypeWithExtensions>.ExtensionWriter
-        extensionWriter = newExtensionWriter();
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      com.google.protobuf.GeneratedMessageV3.writeString(output, 1, message_);
-    }
-    extensionWriter.writeUntil(300, output);
-    unknownFields.writeTo(output);
-  }
-
-  public int getSerializedSize() {
-    int size = memoizedSize;
-    if (size != -1) return size;
-
-    size = 0;
-    if (((bitField0_ & 0x00000001) == 0x00000001)) {
-      size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, message_);
-    }
-    size += extensionsSerializedSize();
-    size += unknownFields.getSerializedSize();
-    memoizedSize = size;
-    return size;
-  }
-
-  private static final long serialVersionUID = 0L;
-  @java.lang.Override
-  public boolean equals(final java.lang.Object obj) {
-    if (obj == this) {
-     return true;
-    }
-    if (!(obj instanceof io.grpc.reflection.testing.TypeWithExtensions)) {
-      return super.equals(obj);
-    }
-    io.grpc.reflection.testing.TypeWithExtensions other = (io.grpc.reflection.testing.TypeWithExtensions) obj;
-
-    boolean result = true;
-    result = result && (hasMessage() == other.hasMessage());
-    if (hasMessage()) {
-      result = result && getMessage()
-          .equals(other.getMessage());
-    }
-    result = result && unknownFields.equals(other.unknownFields);
-    result = result &&
-        getExtensionFields().equals(other.getExtensionFields());
-    return result;
-  }
-
-  @java.lang.Override
-  public int hashCode() {
-    if (memoizedHashCode != 0) {
-      return memoizedHashCode;
-    }
-    int hash = 41;
-    hash = (19 * hash) + getDescriptor().hashCode();
-    if (hasMessage()) {
-      hash = (37 * hash) + MESSAGE_FIELD_NUMBER;
-      hash = (53 * hash) + getMessage().hashCode();
-    }
-    hash = hashFields(hash, getExtensionFields());
-    hash = (29 * hash) + unknownFields.hashCode();
-    memoizedHashCode = hash;
-    return hash;
-  }
-
-  public static io.grpc.reflection.testing.TypeWithExtensions parseFrom(
-      com.google.protobuf.ByteString data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.TypeWithExtensions parseFrom(
-      com.google.protobuf.ByteString data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.TypeWithExtensions parseFrom(byte[] data)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data);
-  }
-  public static io.grpc.reflection.testing.TypeWithExtensions parseFrom(
-      byte[] data,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws com.google.protobuf.InvalidProtocolBufferException {
-    return PARSER.parseFrom(data, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.TypeWithExtensions parseFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.TypeWithExtensions parseFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.TypeWithExtensions parseDelimitedFrom(java.io.InputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.TypeWithExtensions parseDelimitedFrom(
-      java.io.InputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-  }
-  public static io.grpc.reflection.testing.TypeWithExtensions parseFrom(
-      com.google.protobuf.CodedInputStream input)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input);
-  }
-  public static io.grpc.reflection.testing.TypeWithExtensions parseFrom(
-      com.google.protobuf.CodedInputStream input,
-      com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-      throws java.io.IOException {
-    return com.google.protobuf.GeneratedMessageV3
-        .parseWithIOException(PARSER, input, extensionRegistry);
-  }
-
-  public Builder newBuilderForType() { return newBuilder(); }
-  public static Builder newBuilder() {
-    return DEFAULT_INSTANCE.toBuilder();
-  }
-  public static Builder newBuilder(io.grpc.reflection.testing.TypeWithExtensions prototype) {
-    return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-  }
-  public Builder toBuilder() {
-    return this == DEFAULT_INSTANCE
-        ? new Builder() : new Builder().mergeFrom(this);
-  }
-
-  @java.lang.Override
-  protected Builder newBuilderForType(
-      com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-    Builder builder = new Builder(parent);
-    return builder;
-  }
-  /**
-   * Protobuf type {@code grpc.reflection.testing.TypeWithExtensions}
-   */
-  public static final class Builder extends
-      com.google.protobuf.GeneratedMessageV3.ExtendableBuilder<
-        io.grpc.reflection.testing.TypeWithExtensions, Builder> implements
-      // @@protoc_insertion_point(builder_implements:grpc.reflection.testing.TypeWithExtensions)
-      io.grpc.reflection.testing.TypeWithExtensionsOrBuilder {
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_TypeWithExtensions_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_TypeWithExtensions_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.reflection.testing.TypeWithExtensions.class, io.grpc.reflection.testing.TypeWithExtensions.Builder.class);
-    }
-
-    // Construct using io.grpc.reflection.testing.TypeWithExtensions.newBuilder()
-    private Builder() {
-      maybeForceBuilderInitialization();
-    }
-
-    private Builder(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      super(parent);
-      maybeForceBuilderInitialization();
-    }
-    private void maybeForceBuilderInitialization() {
-      if (com.google.protobuf.GeneratedMessageV3
-              .alwaysUseFieldBuilders) {
-      }
-    }
-    public Builder clear() {
-      super.clear();
-      message_ = "";
-      bitField0_ = (bitField0_ & ~0x00000001);
-      return this;
-    }
-
-    public com.google.protobuf.Descriptors.Descriptor
-        getDescriptorForType() {
-      return io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto.internal_static_grpc_reflection_testing_TypeWithExtensions_descriptor;
-    }
-
-    public io.grpc.reflection.testing.TypeWithExtensions getDefaultInstanceForType() {
-      return io.grpc.reflection.testing.TypeWithExtensions.getDefaultInstance();
-    }
-
-    public io.grpc.reflection.testing.TypeWithExtensions build() {
-      io.grpc.reflection.testing.TypeWithExtensions result = buildPartial();
-      if (!result.isInitialized()) {
-        throw newUninitializedMessageException(result);
-      }
-      return result;
-    }
-
-    public io.grpc.reflection.testing.TypeWithExtensions buildPartial() {
-      io.grpc.reflection.testing.TypeWithExtensions result = new io.grpc.reflection.testing.TypeWithExtensions(this);
-      int from_bitField0_ = bitField0_;
-      int to_bitField0_ = 0;
-      if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
-        to_bitField0_ |= 0x00000001;
-      }
-      result.message_ = message_;
-      result.bitField0_ = to_bitField0_;
-      onBuilt();
-      return result;
-    }
-
-    public Builder clone() {
-      return (Builder) super.clone();
-    }
-    public Builder setField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.setField(field, value);
-    }
-    public Builder clearField(
-        com.google.protobuf.Descriptors.FieldDescriptor field) {
-      return (Builder) super.clearField(field);
-    }
-    public Builder clearOneof(
-        com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-      return (Builder) super.clearOneof(oneof);
-    }
-    public Builder setRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        int index, Object value) {
-      return (Builder) super.setRepeatedField(field, index, value);
-    }
-    public Builder addRepeatedField(
-        com.google.protobuf.Descriptors.FieldDescriptor field,
-        Object value) {
-      return (Builder) super.addRepeatedField(field, value);
-    }
-    public <Type> Builder setExtension(
-        com.google.protobuf.GeneratedMessage.GeneratedExtension<
-            io.grpc.reflection.testing.TypeWithExtensions, Type> extension,
-        Type value) {
-      return (Builder) super.setExtension(extension, value);
-    }
-    public <Type> Builder setExtension(
-        com.google.protobuf.GeneratedMessage.GeneratedExtension<
-            io.grpc.reflection.testing.TypeWithExtensions, java.util.List<Type>> extension,
-        int index, Type value) {
-      return (Builder) super.setExtension(extension, index, value);
-    }
-    public <Type> Builder addExtension(
-        com.google.protobuf.GeneratedMessage.GeneratedExtension<
-            io.grpc.reflection.testing.TypeWithExtensions, java.util.List<Type>> extension,
-        Type value) {
-      return (Builder) super.addExtension(extension, value);
-    }
-    public <Type> Builder clearExtension(
-        com.google.protobuf.GeneratedMessage.GeneratedExtension<
-            io.grpc.reflection.testing.TypeWithExtensions, ?> extension) {
-      return (Builder) super.clearExtension(extension);
-    }
-    public Builder mergeFrom(com.google.protobuf.Message other) {
-      if (other instanceof io.grpc.reflection.testing.TypeWithExtensions) {
-        return mergeFrom((io.grpc.reflection.testing.TypeWithExtensions)other);
-      } else {
-        super.mergeFrom(other);
-        return this;
-      }
-    }
-
-    public Builder mergeFrom(io.grpc.reflection.testing.TypeWithExtensions other) {
-      if (other == io.grpc.reflection.testing.TypeWithExtensions.getDefaultInstance()) return this;
-      if (other.hasMessage()) {
-        bitField0_ |= 0x00000001;
-        message_ = other.message_;
-        onChanged();
-      }
-      this.mergeExtensionFields(other);
-      this.mergeUnknownFields(other.unknownFields);
-      onChanged();
-      return this;
-    }
-
-    public final boolean isInitialized() {
-      if (!extensionsAreInitialized()) {
-        return false;
-      }
-      return true;
-    }
-
-    public Builder mergeFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      io.grpc.reflection.testing.TypeWithExtensions parsedMessage = null;
-      try {
-        parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        parsedMessage = (io.grpc.reflection.testing.TypeWithExtensions) e.getUnfinishedMessage();
-        throw e.unwrapIOException();
-      } finally {
-        if (parsedMessage != null) {
-          mergeFrom(parsedMessage);
-        }
-      }
-      return this;
-    }
-    private int bitField0_;
-
-    private java.lang.Object message_ = "";
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public boolean hasMessage() {
-      return ((bitField0_ & 0x00000001) == 0x00000001);
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public java.lang.String getMessage() {
-      java.lang.Object ref = message_;
-      if (!(ref instanceof java.lang.String)) {
-        com.google.protobuf.ByteString bs =
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        if (bs.isValidUtf8()) {
-          message_ = s;
-        }
-        return s;
-      } else {
-        return (java.lang.String) ref;
-      }
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getMessageBytes() {
-      java.lang.Object ref = message_;
-      if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        message_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder setMessage(
-        java.lang.String value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      message_ = value;
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder clearMessage() {
-      bitField0_ = (bitField0_ & ~0x00000001);
-      message_ = getDefaultInstance().getMessage();
-      onChanged();
-      return this;
-    }
-    /**
-     * <code>optional string message = 1;</code>
-     */
-    public Builder setMessageBytes(
-        com.google.protobuf.ByteString value) {
-      if (value == null) {
-    throw new NullPointerException();
-  }
-  bitField0_ |= 0x00000001;
-      message_ = value;
-      onChanged();
-      return this;
-    }
-    public final Builder setUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.setUnknownFields(unknownFields);
-    }
-
-    public final Builder mergeUnknownFields(
-        final com.google.protobuf.UnknownFieldSet unknownFields) {
-      return super.mergeUnknownFields(unknownFields);
-    }
-
-
-    // @@protoc_insertion_point(builder_scope:grpc.reflection.testing.TypeWithExtensions)
-  }
-
-  // @@protoc_insertion_point(class_scope:grpc.reflection.testing.TypeWithExtensions)
-  private static final io.grpc.reflection.testing.TypeWithExtensions DEFAULT_INSTANCE;
-  static {
-    DEFAULT_INSTANCE = new io.grpc.reflection.testing.TypeWithExtensions();
-  }
-
-  public static io.grpc.reflection.testing.TypeWithExtensions getDefaultInstance() {
-    return DEFAULT_INSTANCE;
-  }
-
-  @java.lang.Deprecated public static final com.google.protobuf.Parser<TypeWithExtensions>
-      PARSER = new com.google.protobuf.AbstractParser<TypeWithExtensions>() {
-    public TypeWithExtensions parsePartialFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-        return new TypeWithExtensions(input, extensionRegistry);
-    }
-  };
-
-  public static com.google.protobuf.Parser<TypeWithExtensions> parser() {
-    return PARSER;
-  }
-
-  @java.lang.Override
-  public com.google.protobuf.Parser<TypeWithExtensions> getParserForType() {
-    return PARSER;
-  }
-
-  public io.grpc.reflection.testing.TypeWithExtensions getDefaultInstanceForType() {
-    return DEFAULT_INSTANCE;
-  }
-
-}
-
diff --git a/services/src/generated/test/java/io/grpc/reflection/testing/TypeWithExtensionsOrBuilder.java b/services/src/generated/test/java/io/grpc/reflection/testing/TypeWithExtensionsOrBuilder.java
deleted file mode 100644
index b5cebabb286..00000000000
--- a/services/src/generated/test/java/io/grpc/reflection/testing/TypeWithExtensionsOrBuilder.java
+++ /dev/null
@@ -1,24 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto
-
-package io.grpc.reflection.testing;
-
-public interface TypeWithExtensionsOrBuilder extends
-    // @@protoc_insertion_point(interface_extends:grpc.reflection.testing.TypeWithExtensions)
-    com.google.protobuf.GeneratedMessageV3.
-        ExtendableMessageOrBuilder<TypeWithExtensions> {
-
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  boolean hasMessage();
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  java.lang.String getMessage();
-  /**
-   * <code>optional string message = 1;</code>
-   */
-  com.google.protobuf.ByteString
-      getMessageBytes();
-}
diff --git a/services/src/main/java/io/grpc/protobuf/service/ProtoReflectionService.java b/services/src/main/java/io/grpc/protobuf/service/ProtoReflectionService.java
deleted file mode 100644
index 66113228ca8..00000000000
--- a/services/src/main/java/io/grpc/protobuf/service/ProtoReflectionService.java
+++ /dev/null
@@ -1,557 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.protobuf.service;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.base.Preconditions.checkState;
-
-import com.google.protobuf.Descriptors.Descriptor;
-import com.google.protobuf.Descriptors.FieldDescriptor;
-import com.google.protobuf.Descriptors.FileDescriptor;
-import com.google.protobuf.Descriptors.MethodDescriptor;
-import com.google.protobuf.Descriptors.ServiceDescriptor;
-import io.grpc.BindableService;
-import io.grpc.ExperimentalApi;
-import io.grpc.InternalNotifyOnServerBuild;
-import io.grpc.Server;
-import io.grpc.ServerServiceDefinition;
-import io.grpc.Status;
-import io.grpc.protobuf.ProtoFileDescriptorSupplier;
-import io.grpc.reflection.v1alpha.ErrorResponse;
-import io.grpc.reflection.v1alpha.ExtensionNumberResponse;
-import io.grpc.reflection.v1alpha.ExtensionRequest;
-import io.grpc.reflection.v1alpha.FileDescriptorResponse;
-import io.grpc.reflection.v1alpha.ListServiceResponse;
-import io.grpc.reflection.v1alpha.ServerReflectionGrpc;
-import io.grpc.reflection.v1alpha.ServerReflectionRequest;
-import io.grpc.reflection.v1alpha.ServerReflectionResponse;
-import io.grpc.reflection.v1alpha.ServiceResponse;
-import io.grpc.stub.ServerCallStreamObserver;
-import io.grpc.stub.StreamObserver;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Queue;
-import java.util.Set;
-import javax.annotation.Nullable;
-import javax.annotation.concurrent.GuardedBy;
-
-/**
- * Provides a reflection service for Protobuf services (including the reflection service itself).
- *
- * <p>Separately tracks mutable and immutable services. Throws an exception if either group of
- * services contains multiple Protobuf files with declarations of the same service, method, type, or
- * extension.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
-public final class ProtoReflectionService extends ServerReflectionGrpc.ServerReflectionImplBase
-    implements InternalNotifyOnServerBuild {
-
-  private volatile ServerReflectionIndex serverReflectionIndex;
-
-  private ProtoReflectionService() {}
-
-  public static BindableService getInstance() {
-    return new ProtoReflectionService();
-  }
-
-  /**
-   * Receives a reference to the server at build time.
-   */
-  @Override
-  public void notifyOnBuild(Server server) {
-    checkState(serverReflectionIndex == null);
-    serverReflectionIndex = new ServerReflectionIndex(checkNotNull(server, "server"));
-  }
-
-  @Override
-  public StreamObserver<ServerReflectionRequest> serverReflectionInfo(
-      final StreamObserver<ServerReflectionResponse> responseObserver) {
-
-    checkState(serverReflectionIndex != null);
-    serverReflectionIndex.initializeImmutableServicesIndex();
-
-    final ServerCallStreamObserver<ServerReflectionResponse> serverCallStreamObserver =
-        (ServerCallStreamObserver<ServerReflectionResponse>) responseObserver;
-    ProtoReflectionStreamObserver requestObserver =
-        new ProtoReflectionStreamObserver(serverCallStreamObserver);
-    serverCallStreamObserver.setOnReadyHandler(requestObserver);
-    serverCallStreamObserver.disableAutoInboundFlowControl();
-    serverCallStreamObserver.request(1);
-    return requestObserver;
-  }
-
-  private class ProtoReflectionStreamObserver implements Runnable,
-      StreamObserver<ServerReflectionRequest> {
-    private final ServerCallStreamObserver<ServerReflectionResponse> serverCallStreamObserver;
-
-    private boolean closeAfterSend = false;
-    private ServerReflectionRequest request;
-
-    ProtoReflectionStreamObserver(
-        ServerCallStreamObserver<ServerReflectionResponse> serverCallStreamObserver) {
-      this.serverCallStreamObserver = checkNotNull(serverCallStreamObserver, "observer");
-    }
-
-    @Override
-    public void run() {
-      if (request != null) {
-        handleReflectionRequest();
-      }
-    }
-
-    @Override
-    public void onNext(ServerReflectionRequest request) {
-      checkState(this.request == null);
-      this.request = checkNotNull(request);
-      handleReflectionRequest();
-    }
-
-    private void handleReflectionRequest() {
-      if (serverCallStreamObserver.isReady()) {
-        serverReflectionIndex.updateMutableIndexIfNecessary();
-
-        switch (request.getMessageRequestCase()) {
-          case FILE_BY_FILENAME:
-            getFileByName(request);
-            break;
-          case FILE_CONTAINING_SYMBOL:
-            getFileContainingSymbol(request);
-            break;
-          case FILE_CONTAINING_EXTENSION:
-            getFileByExtension(request);
-            break;
-          case ALL_EXTENSION_NUMBERS_OF_TYPE:
-            getAllExtensions(request);
-            break;
-          case LIST_SERVICES:
-            listServices(request);
-            break;
-          default:
-            sendErrorResponse(request, Status.UNIMPLEMENTED, "");
-        }
-        request = null;
-        if (closeAfterSend) {
-          serverCallStreamObserver.onCompleted();
-        } else {
-          serverCallStreamObserver.request(1);
-        }
-      }
-    }
-
-    @Override
-    public void onCompleted() {
-      if (request != null) {
-        closeAfterSend = true;
-      } else {
-        serverCallStreamObserver.onCompleted();
-      }
-    }
-
-    @Override
-    public void onError(Throwable cause) {
-      serverCallStreamObserver.onError(cause);
-    }
-
-    private void getFileByName(ServerReflectionRequest request) {
-      String name = request.getFileByFilename();
-      FileDescriptor fd = serverReflectionIndex.getFileDescriptorByName(name);
-      if (fd != null) {
-        serverCallStreamObserver.onNext(createServerReflectionResponse(request, fd));
-      } else {
-        sendErrorResponse(request, Status.NOT_FOUND, "File not found.");
-      }
-    }
-
-    private void getFileContainingSymbol(ServerReflectionRequest request) {
-      String symbol = request.getFileContainingSymbol();
-      FileDescriptor fd = serverReflectionIndex.getFileDescriptorBySymbol(symbol);
-      if (fd != null) {
-        serverCallStreamObserver.onNext(createServerReflectionResponse(request, fd));
-      } else {
-        sendErrorResponse(request, Status.NOT_FOUND, "Symbol not found.");
-      }
-    }
-
-    private void getFileByExtension(ServerReflectionRequest request) {
-      ExtensionRequest extensionRequest = request.getFileContainingExtension();
-      String type = extensionRequest.getContainingType();
-      int extension = extensionRequest.getExtensionNumber();
-      FileDescriptor fd =
-          serverReflectionIndex.getFileDescriptorByExtensionAndNumber(type, extension);
-      if (fd != null) {
-        serverCallStreamObserver.onNext(createServerReflectionResponse(request, fd));
-      } else {
-        sendErrorResponse(request, Status.NOT_FOUND, "Extension not found.");
-      }
-    }
-
-    private void getAllExtensions(ServerReflectionRequest request) {
-      String type = request.getAllExtensionNumbersOfType();
-      Set<Integer> extensions = serverReflectionIndex.getExtensionNumbersOfType(type);
-      if (extensions != null) {
-        ExtensionNumberResponse.Builder builder =
-            ExtensionNumberResponse.newBuilder()
-                .setBaseTypeName(type)
-                .addAllExtensionNumber(extensions);
-        serverCallStreamObserver.onNext(
-            ServerReflectionResponse.newBuilder()
-                .setValidHost(request.getHost())
-                .setOriginalRequest(request)
-                .setAllExtensionNumbersResponse(builder)
-                .build());
-      } else {
-        sendErrorResponse(request, Status.NOT_FOUND, "Type not found.");
-      }
-    }
-
-    private void listServices(ServerReflectionRequest request) {
-      ListServiceResponse.Builder builder = ListServiceResponse.newBuilder();
-      for (String serviceName : serverReflectionIndex.getServiceNames()) {
-        builder.addService(ServiceResponse.newBuilder().setName(serviceName));
-      }
-      serverCallStreamObserver.onNext(
-          ServerReflectionResponse.newBuilder()
-              .setValidHost(request.getHost())
-              .setOriginalRequest(request)
-              .setListServicesResponse(builder)
-              .build());
-    }
-
-    private void sendErrorResponse(
-        ServerReflectionRequest request, Status status, String message) {
-      ServerReflectionResponse response =
-          ServerReflectionResponse.newBuilder()
-              .setValidHost(request.getHost())
-              .setOriginalRequest(request)
-              .setErrorResponse(
-                  ErrorResponse.newBuilder()
-                      .setErrorCode(status.getCode().value())
-                      .setErrorMessage(message))
-              .build();
-      serverCallStreamObserver.onNext(response);
-    }
-
-    private ServerReflectionResponse createServerReflectionResponse(
-        ServerReflectionRequest request, FileDescriptor fd) {
-      FileDescriptorResponse.Builder fdRBuilder = FileDescriptorResponse.newBuilder();
-
-      Set<String> seenFiles = new HashSet<String>();
-      Queue<FileDescriptor> frontier = new LinkedList<FileDescriptor>();
-      seenFiles.add(fd.getName());
-      frontier.add(fd);
-      while (!frontier.isEmpty()) {
-        FileDescriptor nextFd = frontier.remove();
-        fdRBuilder.addFileDescriptorProto(nextFd.toProto().toByteString());
-        for (FileDescriptor dependencyFd : nextFd.getDependencies()) {
-          if (!seenFiles.contains(dependencyFd.getName())) {
-            seenFiles.add(dependencyFd.getName());
-            frontier.add(dependencyFd);
-          }
-        }
-      }
-      return ServerReflectionResponse.newBuilder()
-          .setValidHost(request.getHost())
-          .setOriginalRequest(request)
-          .setFileDescriptorResponse(fdRBuilder)
-          .build();
-    }
-  }
-
-  /**
-   * Indexes the server's services and allows lookups of file descriptors by filename, symbol, type,
-   * and extension number.
-   *
-   * <p>Internally, this stores separate indices for the immutable and mutable services. When
-   * queried, the immutable service index is checked for a matching value. Only if there is no match
-   * in the immutable service index are the mutable services checked.
-   */
-  private static final class ServerReflectionIndex {
-    private FileDescriptorIndex immutableServicesIndex;
-    private final Object lock = new Object();
-    /**
-     * Tracks mutable services. Accesses must be synchronized.
-     */
-    @GuardedBy("lock") private FileDescriptorIndex mutableServicesIndex
-        = new FileDescriptorIndex(Collections.<ServerServiceDefinition>emptyList());
-
-    private final Server server;
-
-    public ServerReflectionIndex(Server server) {
-      this.server = server;
-    }
-
-    /**
-     * When first called, initializes the immutable services index. Subsequent calls have no effect.
-     *
-     * <p>This must be called by the reflection service before returning a new
-     * {@link ProtoReflectionStreamObserver}.
-     */
-    private synchronized void initializeImmutableServicesIndex() {
-      if (immutableServicesIndex == null) {
-        immutableServicesIndex = new FileDescriptorIndex(server.getImmutableServices());
-      }
-    }
-
-    /**
-     * Checks for updates to the server's mutable services and updates the index if any changes
-     * are detected. A change is any addition or removal in the set of file descriptors attached to
-     * the mutable services or a change in the service names.
-     */
-    private void updateMutableIndexIfNecessary() {
-      Set<FileDescriptor> currentFileDescriptors = new HashSet<FileDescriptor>();
-      Set<String> currentServiceNames = new HashSet<String>();
-      synchronized (lock) {
-        List<ServerServiceDefinition> currentMutableServices = server.getMutableServices();
-        for (ServerServiceDefinition mutableService : currentMutableServices) {
-          io.grpc.ServiceDescriptor serviceDescriptor = mutableService.getServiceDescriptor();
-          if (serviceDescriptor.getSchemaDescriptor() instanceof ProtoFileDescriptorSupplier) {
-            String serviceName = serviceDescriptor.getName();
-            FileDescriptor fileDescriptor =
-                ((ProtoFileDescriptorSupplier) serviceDescriptor.getSchemaDescriptor())
-                    .getFileDescriptor();
-            currentFileDescriptors.add(fileDescriptor);
-            checkState(!currentServiceNames.contains(serviceName),
-                "Service already defined: %s", serviceName);
-            currentServiceNames.add(serviceName);
-          }
-        }
-
-        // Replace the mutable index if the underlying services have changed. Check both the file
-        // descriptors and the service names, because one file descriptor can define multiple
-        // services.
-        if (!mutableServicesIndex.getServiceFileDescriptors().equals(currentFileDescriptors)
-            || !mutableServicesIndex.getServiceNames().equals(currentServiceNames)) {
-          mutableServicesIndex = new FileDescriptorIndex(currentMutableServices);
-        }
-      }
-    }
-
-    private Set<String> getServiceNames() {
-      Set<String> serviceNames = new HashSet<String>(immutableServicesIndex.getServiceNames());
-      synchronized (lock) {
-        serviceNames.addAll(mutableServicesIndex.getServiceNames());
-      }
-      return serviceNames;
-    }
-
-    @Nullable
-    private FileDescriptor getFileDescriptorByName(String name) {
-      FileDescriptor fd = immutableServicesIndex.getFileDescriptorByName(name);
-      if (fd == null) {
-        synchronized (lock) {
-          fd = mutableServicesIndex.getFileDescriptorByName(name);
-        }
-      }
-      return fd;
-    }
-
-    @Nullable
-    private FileDescriptor getFileDescriptorBySymbol(String symbol) {
-      FileDescriptor fd = immutableServicesIndex.getFileDescriptorBySymbol(symbol);
-      if (fd == null) {
-        synchronized (lock) {
-          fd = mutableServicesIndex.getFileDescriptorBySymbol(symbol);
-        }
-      }
-      return fd;
-    }
-
-    @Nullable
-    private FileDescriptor getFileDescriptorByExtensionAndNumber(String type, int extension) {
-      FileDescriptor fd
-          = immutableServicesIndex.getFileDescriptorByExtensionAndNumber(type, extension);
-      if (fd == null) {
-        synchronized (lock) {
-          fd = mutableServicesIndex.getFileDescriptorByExtensionAndNumber(type, extension);
-        }
-      }
-      return fd;
-    }
-
-    @Nullable
-    private Set<Integer> getExtensionNumbersOfType(String type) {
-      Set<Integer> extensionNumbers = immutableServicesIndex.getExtensionNumbersOfType(type);
-      if (extensionNumbers == null) {
-        synchronized (lock) {
-          extensionNumbers = mutableServicesIndex.getExtensionNumbersOfType(type);
-        }
-      }
-      return extensionNumbers;
-    }
-  }
-
-  /**
-   * Provides a set of methods for answering reflection queries for the file descriptors
-   * underlying a set of services. Used by {@link ServerReflectionIndex} to separately index
-   * immutable and mutable services.
-   */
-  private static final class FileDescriptorIndex {
-    private final Set<String> serviceNames = new HashSet<String>();
-    private final Set<FileDescriptor> serviceFileDescriptors = new HashSet<FileDescriptor>();
-    private final Map<String, FileDescriptor> fileDescriptorsByName
-        = new HashMap<String, FileDescriptor>();
-    private final Map<String, FileDescriptor> fileDescriptorsBySymbol
-        = new HashMap<String, FileDescriptor>();
-    private final Map<String, Map<Integer, FileDescriptor>> fileDescriptorsByExtensionAndNumber
-        = new HashMap<String, Map<Integer, FileDescriptor>>();
-
-    FileDescriptorIndex(List<ServerServiceDefinition> services) {
-      Queue<FileDescriptor> fileDescriptorsToProcess = new LinkedList<FileDescriptor>();
-      Set<String> seenFiles = new HashSet<String>();
-      for (ServerServiceDefinition service : services) {
-        io.grpc.ServiceDescriptor serviceDescriptor = service.getServiceDescriptor();
-        if (serviceDescriptor.getSchemaDescriptor() instanceof ProtoFileDescriptorSupplier) {
-          FileDescriptor fileDescriptor =
-              ((ProtoFileDescriptorSupplier) serviceDescriptor.getSchemaDescriptor())
-                  .getFileDescriptor();
-          String serviceName = serviceDescriptor.getName();
-          checkState(!serviceNames.contains(serviceName),
-              "Service already defined: %s", serviceName);
-          serviceFileDescriptors.add(fileDescriptor);
-          serviceNames.add(serviceName);
-          if (!seenFiles.contains(fileDescriptor.getName())) {
-            seenFiles.add(fileDescriptor.getName());
-            fileDescriptorsToProcess.add(fileDescriptor);
-          }
-        }
-      }
-
-      while (!fileDescriptorsToProcess.isEmpty()) {
-        FileDescriptor currentFd = fileDescriptorsToProcess.remove();
-        processFileDescriptor(currentFd);
-        for (FileDescriptor dependencyFd : currentFd.getDependencies()) {
-          if (!seenFiles.contains(dependencyFd.getName())) {
-            seenFiles.add(dependencyFd.getName());
-            fileDescriptorsToProcess.add(dependencyFd);
-          }
-        }
-      }
-    }
-
-    /**
-     * Returns the file descriptors for the indexed services, but not their dependencies. This is
-     * used to check if the server's mutable services have changed.
-     */
-    private Set<FileDescriptor> getServiceFileDescriptors() {
-      return Collections.unmodifiableSet(serviceFileDescriptors);
-    }
-
-    private Set<String> getServiceNames() {
-      return Collections.unmodifiableSet(serviceNames);
-    }
-
-    @Nullable
-    private FileDescriptor getFileDescriptorByName(String name) {
-      return fileDescriptorsByName.get(name);
-    }
-
-    @Nullable
-    private FileDescriptor getFileDescriptorBySymbol(String symbol) {
-      return fileDescriptorsBySymbol.get(symbol);
-    }
-
-    @Nullable
-    private FileDescriptor getFileDescriptorByExtensionAndNumber(String type, int number) {
-      if (fileDescriptorsByExtensionAndNumber.containsKey(type)) {
-        return fileDescriptorsByExtensionAndNumber.get(type).get(number);
-      }
-      return null;
-    }
-
-    @Nullable
-    private Set<Integer> getExtensionNumbersOfType(String type) {
-      if (fileDescriptorsByExtensionAndNumber.containsKey(type)) {
-        return Collections.unmodifiableSet(fileDescriptorsByExtensionAndNumber.get(type).keySet());
-      }
-      return null;
-    }
-
-    private void processFileDescriptor(FileDescriptor fd) {
-      String fdName = fd.getName();
-      checkState(!fileDescriptorsByName.containsKey(fdName),
-          "File name already used: %s", fdName);
-      fileDescriptorsByName.put(fdName, fd);
-      for (ServiceDescriptor service : fd.getServices()) {
-        processService(service, fd);
-      }
-      for (Descriptor type : fd.getMessageTypes()) {
-        processType(type, fd);
-      }
-      for (FieldDescriptor extension : fd.getExtensions()) {
-        processExtension(extension, fd);
-      }
-    }
-
-    private void processService(ServiceDescriptor service, FileDescriptor fd) {
-      String serviceName = service.getFullName();
-      checkState(!fileDescriptorsBySymbol.containsKey(serviceName),
-          "Service already defined: %s", serviceName);
-      fileDescriptorsBySymbol.put(serviceName, fd);
-      for (MethodDescriptor method : service.getMethods()) {
-        String methodName = method.getFullName();
-        checkState(!fileDescriptorsBySymbol.containsKey(methodName),
-            "Method already defined: %s", methodName);
-        fileDescriptorsBySymbol.put(methodName, fd);
-      }
-    }
-
-    private void processType(Descriptor type, FileDescriptor fd) {
-      String typeName = type.getFullName();
-      checkState(!fileDescriptorsBySymbol.containsKey(typeName),
-          "Type already defined: %s", typeName);
-      fileDescriptorsBySymbol.put(typeName, fd);
-      for (FieldDescriptor extension : type.getExtensions()) {
-        processExtension(extension, fd);
-      }
-      for (Descriptor nestedType : type.getNestedTypes()) {
-        processType(nestedType, fd);
-      }
-    }
-
-    private void processExtension(FieldDescriptor extension, FileDescriptor fd) {
-      String extensionName = extension.getContainingType().getFullName();
-      int extensionNumber = extension.getNumber();
-      if (!fileDescriptorsByExtensionAndNumber.containsKey(extensionName)) {
-        fileDescriptorsByExtensionAndNumber.put(
-            extensionName, new HashMap<Integer, FileDescriptor>());
-      }
-      checkState(
-          !fileDescriptorsByExtensionAndNumber.get(extensionName).containsKey(extensionNumber),
-          "Extension name and number already defined: %s, %s", extensionName, extensionNumber);
-      fileDescriptorsByExtensionAndNumber.get(extensionName).put(extensionNumber, fd);
-    }
-  }
-}
diff --git a/services/src/main/java/io/grpc/protobuf/services/BinaryLogProvider.java b/services/src/main/java/io/grpc/protobuf/services/BinaryLogProvider.java
new file mode 100644
index 00000000000..bbbb88ce6e8
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/BinaryLogProvider.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright 2017 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.protobuf.services;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import io.grpc.BinaryLog;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientInterceptors;
+import io.grpc.Internal;
+import io.grpc.InternalClientInterceptors;
+import io.grpc.InternalServerInterceptors;
+import io.grpc.ManagedChannel;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.Marshaller;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerMethodDefinition;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import javax.annotation.Nullable;
+
+// TODO(zpencer): rename class to AbstractBinaryLog
+@Internal
+public abstract class BinaryLogProvider extends BinaryLog {
+  @VisibleForTesting
+  public static final Marshaller<byte[]> BYTEARRAY_MARSHALLER = new ByteArrayMarshaller();
+
+  private final ClientInterceptor binaryLogShim = new BinaryLogShim();
+
+  /**
+   * Wraps a channel to provide binary logging on {@link ClientCall}s as needed.
+   */
+  @Override
+  public final Channel wrapChannel(Channel channel) {
+    return ClientInterceptors.intercept(channel, binaryLogShim);
+  }
+
+  private static MethodDescriptor<byte[], byte[]> toByteBufferMethod(
+      MethodDescriptor<?, ?> method) {
+    return method.toBuilder(BYTEARRAY_MARSHALLER, BYTEARRAY_MARSHALLER).build();
+  }
+
+  /**
+   * Wraps a {@link ServerMethodDefinition} such that it performs binary logging if needed.
+   */
+  @Override
+  public final <ReqT, RespT> ServerMethodDefinition<?, ?> wrapMethodDefinition(
+      ServerMethodDefinition<ReqT, RespT> oMethodDef) {
+    ServerInterceptor binlogInterceptor =
+        getServerInterceptor(oMethodDef.getMethodDescriptor().getFullMethodName());
+    if (binlogInterceptor == null) {
+      return oMethodDef;
+    }
+    MethodDescriptor<byte[], byte[]> binMethod =
+        BinaryLogProvider.toByteBufferMethod(oMethodDef.getMethodDescriptor());
+    ServerMethodDefinition<byte[], byte[]> binDef =
+        InternalServerInterceptors.wrapMethod(oMethodDef, binMethod);
+    ServerCallHandler<byte[], byte[]> binlogHandler =
+        InternalServerInterceptors.interceptCallHandlerCreate(
+            binlogInterceptor, binDef.getServerCallHandler());
+    return ServerMethodDefinition.create(binMethod, binlogHandler);
+  }
+
+  /**
+   * Returns a {@link ServerInterceptor} for binary logging. gRPC is free to cache the interceptor,
+   * so the interceptor must be reusable across calls. At runtime, the request and response
+   * marshallers are always {@code Marshaller<InputStream>}.
+   * Returns {@code null} if this method is not binary logged.
+   */
+  // TODO(zpencer): ensure the interceptor properly handles retries and hedging
+  @Nullable
+  protected abstract ServerInterceptor getServerInterceptor(String fullMethodName);
+
+  /**
+   * Returns a {@link ClientInterceptor} for binary logging. gRPC is free to cache the interceptor,
+   * so the interceptor must be reusable across calls. At runtime, the request and response
+   * marshallers are always {@code Marshaller<InputStream>}.
+   * Returns {@code null} if this method is not binary logged.
+   */
+  // TODO(zpencer): ensure the interceptor properly handles retries and hedging
+  @Nullable
+  protected abstract ClientInterceptor getClientInterceptor(
+      String fullMethodName, CallOptions callOptions);
+
+  @Override
+  public void close() throws IOException {
+    // default impl: noop
+    // TODO(zpencer): make BinaryLogProvider provide a BinaryLog, and this method belongs there
+  }
+
+  // Creating a named class makes debugging easier
+  private static final class ByteArrayMarshaller implements Marshaller<byte[]> {
+    @Override
+    public InputStream stream(byte[] value) {
+      return new ByteArrayInputStream(value);
+    }
+
+    @Override
+    public byte[] parse(InputStream stream) {
+      try {
+        return parseHelper(stream);
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+    }
+
+    private byte[] parseHelper(InputStream stream) throws IOException {
+      try {
+        return IoUtils.toByteArray(stream);
+      } finally {
+        stream.close();
+      }
+    }
+  }
+
+  /**
+   * The pipeline of interceptors is hard coded when the {@link ManagedChannel} is created.
+   * This shim interceptor should always be installed as a placeholder. When a call starts,
+   * this interceptor checks with the {@link BinaryLogProvider} to see if logging should happen
+   * for this particular {@link ClientCall}'s method.
+   */
+  private final class BinaryLogShim implements ClientInterceptor {
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method,
+        CallOptions callOptions,
+        Channel next) {
+      ClientInterceptor binlogInterceptor = getClientInterceptor(
+          method.getFullMethodName(), callOptions);
+      if (binlogInterceptor == null) {
+        return next.newCall(method, callOptions);
+      } else {
+        return InternalClientInterceptors
+            .wrapClientInterceptor(
+                binlogInterceptor,
+                BYTEARRAY_MARSHALLER,
+                BYTEARRAY_MARSHALLER)
+            .interceptCall(method, callOptions, next);
+      }
+    }
+  }
+
+  // Copied from internal
+  private static final class IoUtils {
+    /** maximum buffer to be read is 16 KB. */
+    private static final int MAX_BUFFER_LENGTH = 16384;
+
+    /** Returns the byte array. */
+    public static byte[] toByteArray(InputStream in) throws IOException {
+      ByteArrayOutputStream out = new ByteArrayOutputStream();
+      copy(in, out);
+      return out.toByteArray();
+    }
+
+    /** Copies the data from input stream to output stream. */
+    public static long copy(InputStream from, OutputStream to) throws IOException {
+      // Copied from guava com.google.common.io.ByteStreams because its API is unstable (beta)
+      Preconditions.checkNotNull(from);
+      Preconditions.checkNotNull(to);
+      byte[] buf = new byte[MAX_BUFFER_LENGTH];
+      long total = 0;
+      while (true) {
+        int r = from.read(buf);
+        if (r == -1) {
+          break;
+        }
+        to.write(buf, 0, r);
+        total += r;
+      }
+      return total;
+    }
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/BinaryLogProviderImpl.java b/services/src/main/java/io/grpc/protobuf/services/BinaryLogProviderImpl.java
new file mode 100644
index 00000000000..896d92bcd91
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/BinaryLogProviderImpl.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2018 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.protobuf.services;
+
+import com.google.common.base.Preconditions;
+import io.grpc.CallOptions;
+import io.grpc.ClientInterceptor;
+import io.grpc.ServerInterceptor;
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicLong;
+import javax.annotation.Nullable;
+
+/**
+ * The default implementation of a {@link BinaryLogProvider}.
+ */
+class BinaryLogProviderImpl extends BinaryLogProvider {
+  // avoid using 0 because proto3 long fields default to 0 when unset
+  private static final AtomicLong counter = new AtomicLong(1);
+
+  private final BinlogHelper.Factory factory;
+  private final BinaryLogSink sink;
+
+  public BinaryLogProviderImpl() throws IOException {
+    this(new TempFileSink(), System.getenv("GRPC_BINARY_LOG_CONFIG"));
+  }
+
+  /**
+   * Deprecated and will be removed in a future version of gRPC.
+   */
+  @Deprecated
+  @SuppressWarnings("InlineMeSuggester") // Only called internally; don't care
+  public BinaryLogProviderImpl(BinaryLogSink sink) throws IOException {
+    this(sink, System.getenv("GRPC_BINARY_LOG_CONFIG"));
+  }
+
+  /**
+   * Creates an instance.
+   * @param sink ownership is transferred to this class.
+   * @param configStr config string to parse to determine logged methods and msg size limits.
+   * @throws IOException if initialization failed.
+   */
+  public BinaryLogProviderImpl(BinaryLogSink sink, String configStr) throws IOException {
+    this.sink = Preconditions.checkNotNull(sink);
+    try {
+      factory = new BinlogHelper.FactoryImpl(sink, configStr);
+    } catch (RuntimeException e) {
+      sink.close();
+      // parsing the conf string may throw if it is blank or contains errors
+      throw new IOException(
+          "Can not initialize. The env variable GRPC_BINARY_LOG_CONFIG must be valid.", e);
+    }
+  }
+
+  @Nullable
+  @Override
+  public ServerInterceptor getServerInterceptor(String fullMethodName) {
+    BinlogHelper helperForMethod = factory.getLog(fullMethodName);
+    if (helperForMethod == null) {
+      return null;
+    }
+    return helperForMethod.getServerInterceptor(counter.getAndIncrement());
+  }
+
+  @Nullable
+  @Override
+  public ClientInterceptor getClientInterceptor(
+      String fullMethodName, CallOptions callOptions) {
+    BinlogHelper helperForMethod = factory.getLog(fullMethodName);
+    if (helperForMethod == null) {
+      return null;
+    }
+    return helperForMethod.getClientInterceptor(counter.getAndIncrement());
+  }
+
+  @Override
+  public void close() throws IOException {
+    sink.close();
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/BinaryLogSink.java b/services/src/main/java/io/grpc/protobuf/services/BinaryLogSink.java
new file mode 100644
index 00000000000..44e4e2cc856
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/BinaryLogSink.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2018 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.protobuf.services;
+
+import com.google.protobuf.MessageLite;
+import io.grpc.ExperimentalApi;
+import java.io.Closeable;
+
+/**
+ * A class that accepts binary log messages.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4017")
+public interface BinaryLogSink extends Closeable {
+  /**
+   * Writes the {@code message} to the destination.
+   */
+  void write(MessageLite message);
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/BinaryLogs.java b/services/src/main/java/io/grpc/protobuf/services/BinaryLogs.java
new file mode 100644
index 00000000000..4a7757c8617
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/BinaryLogs.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2018, gRPC Authors All rights reserved.
+ *
+ * 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.protobuf.services;
+
+import io.grpc.BinaryLog;
+import io.grpc.ExperimentalApi;
+import java.io.IOException;
+
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4017")
+public final class BinaryLogs {
+  /**
+   * Creates a binary log that writes to a temp file. <b>Warning:</b> this implementation is
+   * not performance optimized, and RPCs will experience back pressure if disk IO does not keep
+   * up.
+   */
+  public static BinaryLog createBinaryLog() throws IOException {
+    return new BinaryLogProviderImpl();
+  }
+
+  /**
+   * Deprecated and will be removed in a future version of gRPC.
+   */
+  @Deprecated
+  public static BinaryLog createBinaryLog(BinaryLogSink sink) throws IOException {
+    return new BinaryLogProviderImpl(sink);
+  }
+
+  /**
+   * Creates a binary log with a custom {@link BinaryLogSink} for receiving the logged data,
+   * and a config string as defined by
+   * <a href="https://github.com/grpc/proposal/blob/master/A16-binary-logging.md">
+   *   A16-binary-logging</a>.
+   */
+  public static BinaryLog createBinaryLog(BinaryLogSink sink, String configStr) throws IOException {
+    return new BinaryLogProviderImpl(sink, configStr);
+  }
+
+  private BinaryLogs() {}
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/BinlogHelper.java b/services/src/main/java/io/grpc/protobuf/services/BinlogHelper.java
new file mode 100644
index 00000000000..e810c983beb
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/BinlogHelper.java
@@ -0,0 +1,880 @@
+/*
+ * Copyright 2017 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.protobuf.services;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.protobuf.services.BinaryLogProvider.BYTEARRAY_MARSHALLER;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Splitter;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.Duration;
+import com.google.protobuf.util.Durations;
+import com.google.protobuf.util.Timestamps;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.Context;
+import io.grpc.Deadline;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
+import io.grpc.ForwardingServerCall.SimpleForwardingServerCall;
+import io.grpc.ForwardingServerCallListener.SimpleForwardingServerCallListener;
+import io.grpc.Grpc;
+import io.grpc.InternalMetadata;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.Marshaller;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.Status;
+import io.grpc.binarylog.v1.Address;
+import io.grpc.binarylog.v1.GrpcLogEntry;
+import io.grpc.binarylog.v1.GrpcLogEntry.EventType;
+import io.grpc.binarylog.v1.Message;
+import io.grpc.binarylog.v1.MetadataEntry;
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A binary log class that is configured for a specific {@link MethodDescriptor}.
+ */
+@ThreadSafe
+final class BinlogHelper {
+  private static final Logger logger = Logger.getLogger(BinlogHelper.class.getName());
+  // Normally 'grpc-' metadata keys are set from within gRPC, and applications are not allowed
+  // to set them. This key is a special well known key that set from the application layer, but
+  // represents a com.google.rpc.Status and is given special first class treatment.
+  // See StatusProto.java
+  static final Metadata.Key<byte[]> STATUS_DETAILS_KEY =
+      Metadata.Key.of(
+          "grpc-status-details-bin",
+          Metadata.BINARY_BYTE_MARSHALLER);
+
+  @VisibleForTesting
+  final SinkWriter writer;
+
+  @VisibleForTesting
+  BinlogHelper(SinkWriter writer) {
+    this.writer = writer;
+  }
+
+  // TODO(zpencer): move proto related static helpers into this class
+  static final class SinkWriterImpl extends SinkWriter {
+    private final BinaryLogSink sink;
+    private TimeProvider timeProvider;
+    private final int maxHeaderBytes;
+    private final int maxMessageBytes;
+
+    SinkWriterImpl(
+        BinaryLogSink sink,
+        TimeProvider timeProvider,
+        int maxHeaderBytes,
+        int maxMessageBytes) {
+      this.sink = sink;
+      this.timeProvider = timeProvider;
+      this.maxHeaderBytes = maxHeaderBytes;
+      this.maxMessageBytes = maxMessageBytes;
+    }
+
+    GrpcLogEntry.Builder newTimestampedBuilder() {
+      long epochNanos = timeProvider.currentTimeNanos();
+      return GrpcLogEntry.newBuilder().setTimestamp(Timestamps.fromNanos(epochNanos));
+    }
+
+    @Override
+    void logClientHeader(
+        long seq,
+        String methodName,
+        // not all transports have the concept of authority
+        @Nullable String authority,
+        @Nullable Duration timeout,
+        Metadata metadata,
+        GrpcLogEntry.Logger logger,
+        long callId,
+        // null on client side
+        @Nullable SocketAddress peerAddress) {
+      Preconditions.checkArgument(methodName != null, "methodName can not be null");
+      Preconditions.checkArgument(
+          !methodName.startsWith("/"),
+          "in grpc-java method names should not have a leading '/'. However this class will "
+              + "add one to be consistent with language agnostic conventions.");
+      Preconditions.checkArgument(
+          peerAddress == null || logger == GrpcLogEntry.Logger.LOGGER_SERVER,
+          "peerSocket can only be specified for server");
+
+      MaybeTruncated<io.grpc.binarylog.v1.Metadata.Builder> pair
+          = createMetadataProto(metadata, maxHeaderBytes);
+      io.grpc.binarylog.v1.ClientHeader.Builder clientHeaderBuilder
+          = io.grpc.binarylog.v1.ClientHeader.newBuilder()
+          .setMetadata(pair.proto)
+          .setMethodName("/" + methodName);
+      if (timeout != null) {
+        clientHeaderBuilder.setTimeout(timeout);
+      }
+      if (authority != null) {
+        clientHeaderBuilder.setAuthority(authority);
+      }
+
+      GrpcLogEntry.Builder entryBuilder = newTimestampedBuilder()
+          .setSequenceIdWithinCall(seq)
+          .setType(EventType.EVENT_TYPE_CLIENT_HEADER)
+          .setClientHeader(clientHeaderBuilder)
+          .setPayloadTruncated(pair.truncated)
+          .setLogger(logger)
+          .setCallId(callId);
+      if (peerAddress != null) {
+        entryBuilder.setPeer(socketToProto(peerAddress));
+      }
+      sink.write(entryBuilder.build());
+    }
+
+    @Override
+    void logServerHeader(
+        long seq,
+        Metadata metadata,
+        GrpcLogEntry.Logger logger,
+        long callId,
+        // null on server
+        @Nullable SocketAddress peerAddress) {
+      Preconditions.checkArgument(
+          peerAddress == null || logger == GrpcLogEntry.Logger.LOGGER_CLIENT,
+          "peerSocket can only be specified for client");
+      MaybeTruncated<io.grpc.binarylog.v1.Metadata.Builder> pair
+          = createMetadataProto(metadata, maxHeaderBytes);
+
+      GrpcLogEntry.Builder entryBuilder = newTimestampedBuilder()
+          .setSequenceIdWithinCall(seq)
+          .setType(EventType.EVENT_TYPE_SERVER_HEADER)
+          .setServerHeader(
+              io.grpc.binarylog.v1.ServerHeader.newBuilder()
+                  .setMetadata(pair.proto))
+          .setPayloadTruncated(pair.truncated)
+          .setLogger(logger)
+          .setCallId(callId);
+      if (peerAddress != null) {
+        entryBuilder.setPeer(socketToProto(peerAddress));
+      }
+      sink.write(entryBuilder.build());
+    }
+
+    @Override
+    void logTrailer(
+        long seq,
+        Status status,
+        Metadata metadata,
+        GrpcLogEntry.Logger logger,
+        long callId,
+        // null on server, can be non null on client if this is a trailer-only response
+        @Nullable SocketAddress peerAddress) {
+      Preconditions.checkArgument(
+          peerAddress == null || logger == GrpcLogEntry.Logger.LOGGER_CLIENT,
+          "peerSocket can only be specified for client");
+      MaybeTruncated<io.grpc.binarylog.v1.Metadata.Builder> pair
+          = createMetadataProto(metadata, maxHeaderBytes);
+
+      io.grpc.binarylog.v1.Trailer.Builder trailerBuilder
+          = io.grpc.binarylog.v1.Trailer.newBuilder()
+          .setStatusCode(status.getCode().value())
+          .setMetadata(pair.proto);
+      String statusDescription = status.getDescription();
+      if (statusDescription != null) {
+        trailerBuilder.setStatusMessage(statusDescription);
+      }
+      byte[] statusDetailBytes = metadata.get(STATUS_DETAILS_KEY);
+      if (statusDetailBytes != null) {
+        trailerBuilder.setStatusDetails(ByteString.copyFrom(statusDetailBytes));
+      }
+
+      GrpcLogEntry.Builder entryBuilder = newTimestampedBuilder()
+          .setSequenceIdWithinCall(seq)
+          .setType(EventType.EVENT_TYPE_SERVER_TRAILER)
+          .setTrailer(trailerBuilder)
+          .setPayloadTruncated(pair.truncated)
+          .setLogger(logger)
+          .setCallId(callId);
+      if (peerAddress != null) {
+        entryBuilder.setPeer(socketToProto(peerAddress));
+      }
+      sink.write(entryBuilder.build());
+    }
+
+    @Override
+    <T> void logRpcMessage(
+        long seq,
+        EventType eventType,
+        Marshaller<T> marshaller,
+        T message,
+        GrpcLogEntry.Logger logger,
+        long callId) {
+      Preconditions.checkArgument(
+          eventType == EventType.EVENT_TYPE_CLIENT_MESSAGE
+              || eventType == EventType.EVENT_TYPE_SERVER_MESSAGE,
+          "event type must correspond to client message or server message");
+      if (marshaller != BYTEARRAY_MARSHALLER) {
+        throw new IllegalStateException("Expected the BinaryLog's ByteArrayMarshaller");
+      }
+      MaybeTruncated<Message.Builder> pair = createMessageProto((byte[]) message, maxMessageBytes);
+      GrpcLogEntry.Builder entryBuilder = newTimestampedBuilder()
+          .setSequenceIdWithinCall(seq)
+          .setType(eventType)
+          .setMessage(pair.proto)
+          .setPayloadTruncated(pair.truncated)
+          .setLogger(logger)
+          .setCallId(callId);
+      sink.write(entryBuilder.build());
+    }
+
+    @Override
+    void logHalfClose(long seq, GrpcLogEntry.Logger logger, long callId) {
+      sink.write(
+          newTimestampedBuilder()
+              .setSequenceIdWithinCall(seq)
+              .setType(EventType.EVENT_TYPE_CLIENT_HALF_CLOSE)
+              .setLogger(logger)
+              .setCallId(callId)
+              .build());
+    }
+
+    @Override
+    void logCancel(long seq, GrpcLogEntry.Logger logger, long callId) {
+      sink.write(
+          newTimestampedBuilder()
+              .setSequenceIdWithinCall(seq)
+              .setType(EventType.EVENT_TYPE_CANCEL)
+              .setLogger(logger)
+              .setCallId(callId)
+              .build());
+    }
+
+    @Override
+    int getMaxHeaderBytes() {
+      return maxHeaderBytes;
+    }
+
+    @Override
+    int getMaxMessageBytes() {
+      return maxMessageBytes;
+    }
+  }
+
+  abstract static class SinkWriter {
+    /**
+     * Logs the client header. This method logs the appropriate number of bytes
+     * as determined by the binary logging configuration.
+     */
+    abstract void logClientHeader(
+        long seq,
+        String methodName,
+        // not all transports have the concept of authority
+        @Nullable String authority,
+        @Nullable Duration timeout,
+        Metadata metadata,
+        GrpcLogEntry.Logger logger,
+        long callId,
+        // null on client side
+        @Nullable SocketAddress peerAddress);
+
+    /**
+     * Logs the server header. This method logs the appropriate number of bytes
+     * as determined by the binary logging configuration.
+     */
+    abstract void logServerHeader(
+        long seq,
+        Metadata metadata,
+        GrpcLogEntry.Logger logger,
+        long callId,
+        // null on server
+        @Nullable SocketAddress peerAddress);
+
+    /**
+     * Logs the server trailer. This method logs the appropriate number of bytes
+     * as determined by the binary logging configuration.
+     */
+    abstract void logTrailer(
+        long seq,
+        Status status,
+        Metadata metadata,
+        GrpcLogEntry.Logger logger,
+        long callId,
+        // null on server, can be non null on client if this is a trailer-only response
+        @Nullable SocketAddress peerAddress);
+
+    /**
+     * Logs the message message. The number of bytes logged is determined by the binary
+     * logging configuration.
+     */
+    abstract <T> void logRpcMessage(
+        long seq,
+        EventType eventType,
+        Marshaller<T> marshaller,
+        T message,
+        GrpcLogEntry.Logger logger,
+        long callId);
+
+    abstract void logHalfClose(long seq, GrpcLogEntry.Logger logger, long callId);
+
+    /**
+     * Logs the cancellation.
+     */
+    abstract void logCancel(long seq, GrpcLogEntry.Logger logger, long callId);
+
+    /**
+     * Returns the number bytes of the header this writer will log, according to configuration.
+     */
+    abstract int getMaxHeaderBytes();
+
+    /**
+     * Returns the number bytes of the message this writer will log, according to configuration.
+     */
+    abstract int getMaxMessageBytes();
+  }
+
+  static SocketAddress getPeerSocket(Attributes streamAttributes) {
+    return streamAttributes.get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
+  }
+
+  private static Deadline min(@Nullable Deadline deadline0, @Nullable Deadline deadline1) {
+    if (deadline0 == null) {
+      return deadline1;
+    }
+    if (deadline1 == null) {
+      return deadline0;
+    }
+    return deadline0.minimum(deadline1);
+  }
+
+  interface TimeProvider {
+    /** Returns the current nano time. */
+    long currentTimeNanos();
+
+    TimeProvider SYSTEM_TIME_PROVIDER = new TimeProvider() {
+      @Override
+      public long currentTimeNanos() {
+        return TimeUnit.MILLISECONDS.toNanos(System.currentTimeMillis());
+      }
+    };
+  }
+
+
+  public ClientInterceptor getClientInterceptor(final long callId) {
+    return new ClientInterceptor() {
+      boolean trailersOnlyResponse = true;
+      @Override
+      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+          final MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+        final AtomicLong seq = new AtomicLong(1);
+        final String methodName = method.getFullMethodName();
+        final String authority = next.authority();
+        // The timeout should reflect the time remaining when the call is started, so do not
+        // compute remaining time here.
+        final Deadline deadline = min(callOptions.getDeadline(), Context.current().getDeadline());
+
+        return new SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {
+          @Override
+          public void start(final ClientCall.Listener<RespT> responseListener, Metadata headers) {
+            final Duration timeout = deadline == null ? null
+                : Durations.fromNanos(deadline.timeRemaining(TimeUnit.NANOSECONDS));
+            writer.logClientHeader(
+                seq.getAndIncrement(),
+                methodName,
+                authority,
+                timeout,
+                headers,
+                GrpcLogEntry.Logger.LOGGER_CLIENT,
+                callId,
+                /*peerAddress=*/ null);
+            ClientCall.Listener<RespT> wListener =
+                new SimpleForwardingClientCallListener<RespT>(responseListener) {
+                  @Override
+                  public void onMessage(RespT message) {
+                    writer.logRpcMessage(
+                        seq.getAndIncrement(),
+                        EventType.EVENT_TYPE_SERVER_MESSAGE,
+                        method.getResponseMarshaller(),
+                        message,
+                        GrpcLogEntry.Logger.LOGGER_CLIENT,
+                        callId);
+                    super.onMessage(message);
+                  }
+
+                  @Override
+                  public void onHeaders(Metadata headers) {
+                    trailersOnlyResponse = false;
+                    writer.logServerHeader(
+                        seq.getAndIncrement(),
+                        headers,
+                        GrpcLogEntry.Logger.LOGGER_CLIENT,
+                        callId,
+                        getPeerSocket(getAttributes()));
+                    super.onHeaders(headers);
+                  }
+
+                  @Override
+                  public void onClose(Status status, Metadata trailers) {
+                    SocketAddress peer = trailersOnlyResponse
+                        ? getPeerSocket(getAttributes()) : null;
+                    writer.logTrailer(
+                        seq.getAndIncrement(),
+                        status,
+                        trailers,
+                        GrpcLogEntry.Logger.LOGGER_CLIENT,
+                        callId,
+                        peer);
+                    super.onClose(status, trailers);
+                  }
+                };
+            super.start(wListener, headers);
+          }
+
+          @Override
+          public void sendMessage(ReqT message) {
+            writer.logRpcMessage(
+                seq.getAndIncrement(),
+                EventType.EVENT_TYPE_CLIENT_MESSAGE,
+                method.getRequestMarshaller(),
+                message,
+                GrpcLogEntry.Logger.LOGGER_CLIENT,
+                callId);
+            super.sendMessage(message);
+          }
+
+          @Override
+          public void halfClose() {
+            writer.logHalfClose(
+                seq.getAndIncrement(),
+                GrpcLogEntry.Logger.LOGGER_CLIENT,
+                callId);
+            super.halfClose();
+          }
+
+          @Override
+          public void cancel(String message, Throwable cause) {
+            writer.logCancel(
+                seq.getAndIncrement(),
+                GrpcLogEntry.Logger.LOGGER_CLIENT,
+                callId);
+            super.cancel(message, cause);
+          }
+        };
+      }
+    };
+  }
+
+  public ServerInterceptor getServerInterceptor(final long callId) {
+    return new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+          final ServerCall<ReqT, RespT> call,
+          Metadata headers,
+          ServerCallHandler<ReqT, RespT> next) {
+        final AtomicLong seq = new AtomicLong(1);
+        SocketAddress peer = getPeerSocket(call.getAttributes());
+        String methodName = call.getMethodDescriptor().getFullMethodName();
+        String authority = call.getAuthority();
+        Deadline deadline = Context.current().getDeadline();
+        final Duration timeout = deadline == null ? null
+            : Durations.fromNanos(deadline.timeRemaining(TimeUnit.NANOSECONDS));
+
+        writer.logClientHeader(
+            seq.getAndIncrement(),
+            methodName,
+            authority,
+            timeout,
+            headers,
+            GrpcLogEntry.Logger.LOGGER_SERVER,
+            callId,
+            peer);
+        ServerCall<ReqT, RespT> wCall = new SimpleForwardingServerCall<ReqT, RespT>(call) {
+          @Override
+          public void sendMessage(RespT message) {
+            writer.logRpcMessage(
+                seq.getAndIncrement(),
+                EventType.EVENT_TYPE_SERVER_MESSAGE,
+                call.getMethodDescriptor().getResponseMarshaller(),
+                message,
+                GrpcLogEntry.Logger.LOGGER_SERVER,
+                callId);
+            super.sendMessage(message);
+          }
+
+          @Override
+          public void sendHeaders(Metadata headers) {
+            writer.logServerHeader(
+                seq.getAndIncrement(),
+                headers,
+                GrpcLogEntry.Logger.LOGGER_SERVER,
+                callId,
+                /*peerAddress=*/ null);
+            super.sendHeaders(headers);
+          }
+
+          @Override
+          public void close(Status status, Metadata trailers) {
+            writer.logTrailer(
+                seq.getAndIncrement(),
+                status,
+                trailers,
+                GrpcLogEntry.Logger.LOGGER_SERVER,
+                callId,
+                /*peerAddress=*/ null);
+            super.close(status, trailers);
+          }
+        };
+
+        return new SimpleForwardingServerCallListener<ReqT>(next.startCall(wCall, headers)) {
+          @Override
+          public void onMessage(ReqT message) {
+            writer.logRpcMessage(
+                seq.getAndIncrement(),
+                EventType.EVENT_TYPE_CLIENT_MESSAGE,
+                call.getMethodDescriptor().getRequestMarshaller(),
+                message,
+                GrpcLogEntry.Logger.LOGGER_SERVER,
+                callId);
+            super.onMessage(message);
+          }
+
+          @Override
+          public void onHalfClose() {
+            writer.logHalfClose(
+                seq.getAndIncrement(),
+                GrpcLogEntry.Logger.LOGGER_SERVER,
+                callId);
+            super.onHalfClose();
+          }
+
+          @Override
+          public void onCancel() {
+            writer.logCancel(
+                seq.getAndIncrement(),
+                GrpcLogEntry.Logger.LOGGER_SERVER,
+                callId);
+            super.onCancel();
+          }
+        };
+      }
+    };
+  }
+
+  interface Factory {
+    @Nullable
+    BinlogHelper getLog(String fullMethodName);
+  }
+
+  static final class FactoryImpl implements Factory {
+    private final BinlogHelper globalLog;
+    private final Map<String, BinlogHelper> perServiceLogs;
+    private final Map<String, BinlogHelper> perMethodLogs;
+    private final Set<String> blacklistedMethods;
+
+    /**
+     * Accepts a string in the format specified by the binary log spec.
+     */
+    @VisibleForTesting
+    FactoryImpl(BinaryLogSink sink, String configurationString) {
+      checkNotNull(sink, "sink");
+      BinlogHelper globalLog = null;
+      Map<String, BinlogHelper> perServiceLogs = new HashMap<>();
+      Map<String, BinlogHelper> perMethodLogs = new HashMap<>();
+      Set<String> blacklistedMethods = new HashSet<>();
+      if (configurationString != null && configurationString.length() > 0) {
+        for (String configuration : Splitter.on(',').split(configurationString)) {
+          int leftCurly = configuration.indexOf('{');
+          // '*' for global, 'service/*' for service glob, or 'service/method' for fully qualified
+          String methodOrSvc;
+          // An expression originally wrapped in curly braces; like {m:256,h:256}, {m:256}, {h:256}
+          String binlogOptionStr;
+          if (leftCurly == -1) {
+            methodOrSvc = configuration;
+            binlogOptionStr = null;
+          } else {
+            int rightCurly = configuration.indexOf('}', leftCurly);
+            if (rightCurly != configuration.length() - 1) {
+              throw new IllegalArgumentException("Illegal log config pattern: " + configuration);
+            }
+            methodOrSvc = configuration.substring(0, leftCurly);
+            // option without the curly braces
+            binlogOptionStr = configuration.substring(leftCurly + 1, configuration.length() - 1);
+          }
+          if (methodOrSvc.isEmpty()) {
+            throw new IllegalArgumentException("Illegal log config pattern: " + configuration);
+          }
+          if (methodOrSvc.equals("*")) {
+            // parse config for "*"
+            checkState(
+                globalLog == null,
+                "Duplicate entry, this is fatal: " + configuration);
+            globalLog = createBinaryLog(sink, binlogOptionStr);
+            logger.log(Level.INFO, "Global binlog: {0}", binlogOptionStr);
+          } else if (isServiceGlob(methodOrSvc)) {
+            // parse config for a service, e.g. "service/*"
+            String service = MethodDescriptor.extractFullServiceName(methodOrSvc);
+            checkState(
+                !perServiceLogs.containsKey(service),
+                "Duplicate entry, this is fatal: " + configuration);
+            perServiceLogs.put(service, createBinaryLog(sink, binlogOptionStr));
+            logger.log(
+                Level.INFO,
+                "Service binlog: service={0} config={1}",
+                new Object[] {service, binlogOptionStr});
+          } else if (methodOrSvc.startsWith("-")) {
+            // parse config for a method, e.g. "-service/method"
+            String blacklistedMethod = methodOrSvc.substring(1);
+            if (blacklistedMethod.length() == 0) {
+              continue;
+            }
+            checkState(
+                !blacklistedMethods.contains(blacklistedMethod),
+                "Duplicate entry, this is fatal: " + configuration);
+            checkState(
+                !perMethodLogs.containsKey(blacklistedMethod),
+                "Duplicate entry, this is fatal: " + configuration);
+            blacklistedMethods.add(blacklistedMethod);
+          } else {
+            // parse config for a fully qualified method, e.g "serice/method"
+            checkState(
+                !perMethodLogs.containsKey(methodOrSvc),
+                "Duplicate entry, this is fatal: " + configuration);
+            checkState(
+                !blacklistedMethods.contains(methodOrSvc),
+                "Duplicate entry, this method was blacklisted: " + configuration);
+            perMethodLogs.put(methodOrSvc, createBinaryLog(sink, binlogOptionStr));
+            logger.log(
+                Level.INFO,
+                "Method binlog: method={0} config={1}",
+                new Object[] {methodOrSvc, binlogOptionStr});
+          }
+        }
+      }
+      this.globalLog = globalLog;
+      this.perServiceLogs = Collections.unmodifiableMap(perServiceLogs);
+      this.perMethodLogs = Collections.unmodifiableMap(perMethodLogs);
+      this.blacklistedMethods = Collections.unmodifiableSet(blacklistedMethods);
+    }
+
+    /**
+     * Accepts a full method name and returns the log that should be used.
+     */
+    @Override
+    public BinlogHelper getLog(String fullMethodName) {
+      if (blacklistedMethods.contains(fullMethodName)) {
+        return null;
+      }
+      BinlogHelper methodLog = perMethodLogs.get(fullMethodName);
+      if (methodLog != null) {
+        return methodLog;
+      }
+      BinlogHelper serviceLog = perServiceLogs.get(
+          MethodDescriptor.extractFullServiceName(fullMethodName));
+      if (serviceLog != null) {
+        return serviceLog;
+      }
+      return globalLog;
+    }
+
+    /**
+     * Returns a binlog with the correct header and message limits or {@code null} if the input
+     * is malformed. The input should be a string that is in one of these forms:
+     *
+     * <p>{@code {h(:\d+)?}, {m(:\d+)?}, {h(:\d+)?,m(:\d+)?}}
+     *
+     * <p>If the {@code logConfig} is null, the returned binlog will have a limit of
+     * Integer.MAX_VALUE.
+     */
+    @VisibleForTesting
+    @Nullable
+    static BinlogHelper createBinaryLog(BinaryLogSink sink, @Nullable String logConfig) {
+      if (logConfig == null) {
+        return new BinlogHelper(
+            new SinkWriterImpl(
+                sink, TimeProvider.SYSTEM_TIME_PROVIDER, Integer.MAX_VALUE, Integer.MAX_VALUE));
+      }
+      try {
+        final int maxHeaderBytes;
+        final int maxMsgBytes;
+        String[] parts = logConfig.split(";", 2);
+        if (parts.length == 2) {
+          if (!(parts[0].startsWith("h") && parts[1].startsWith("m"))) {
+            throw new IllegalArgumentException("Illegal log config pattern");
+          }
+          maxHeaderBytes = optionalInt(parts[0].substring(1));
+          maxMsgBytes = optionalInt(parts[1].substring(1));
+        } else if (parts[0].startsWith("h")) {
+          maxHeaderBytes = optionalInt(parts[0].substring(1));
+          maxMsgBytes = 0;
+        } else if (parts[0].startsWith("m")) {
+          maxHeaderBytes = 0;
+          maxMsgBytes = optionalInt(parts[0].substring(1));
+        } else {
+          throw new IllegalArgumentException("Illegal log config pattern");
+        }
+        return new BinlogHelper(
+            new SinkWriterImpl(
+                sink, TimeProvider.SYSTEM_TIME_PROVIDER, maxHeaderBytes, maxMsgBytes));
+      } catch (NumberFormatException e) {
+        throw new IllegalArgumentException("Illegal log config pattern");
+      }
+    }
+
+    /** Returns {@code s}, after verifying it contains only digits. */
+    static String checkDigits(String s) {
+      for (int i = 0; i < s.length(); i++) {
+        char c = s.charAt(i);
+        if (c < '0' || '9' < c) {
+          throw new IllegalArgumentException("Illegal log config pattern");
+        }
+      }
+      return s;
+    }
+
+    /** Parses the optional int of the form "" (max int) or ":123" (123). */
+    static int optionalInt(String s) {
+      if (s.isEmpty()) {
+        return Integer.MAX_VALUE;
+      }
+      if (!s.startsWith(":")) {
+        throw new IllegalArgumentException("Illegal log config pattern");
+      }
+      s = checkDigits(s.substring(1));
+      return Integer.parseInt(s);
+    }
+
+    /**
+     * Returns true if the input string is a glob of the form: {@code <package-service>/*}.
+     */
+    static boolean isServiceGlob(String input) {
+      return input.endsWith("/*");
+    }
+  }
+
+  @VisibleForTesting
+  static Address socketToProto(SocketAddress address) {
+    checkNotNull(address, "address");
+
+    Address.Builder builder = Address.newBuilder();
+    if (address instanceof InetSocketAddress) {
+      InetAddress inetAddress = ((InetSocketAddress) address).getAddress();
+      if (inetAddress instanceof Inet4Address) {
+        builder.setType(Address.Type.TYPE_IPV4)
+            .setAddress(InetAddressUtil.toAddrString(inetAddress));
+      } else if (inetAddress instanceof Inet6Address) {
+        builder.setType(Address.Type.TYPE_IPV6)
+            .setAddress(InetAddressUtil.toAddrString(inetAddress));
+      } else {
+        logger.log(Level.SEVERE, "unknown type of InetSocketAddress: {}", address);
+        builder.setAddress(address.toString());
+      }
+      builder.setIpPort(((InetSocketAddress) address).getPort());
+    } else if (address.getClass().getName().equals("io.netty.channel.unix.DomainSocketAddress")) {
+      // To avoid a compile time dependency on grpc-netty, we check against the runtime class name.
+      builder.setType(Address.Type.TYPE_UNIX)
+          .setAddress(address.toString());
+    } else {
+      builder.setType(Address.Type.TYPE_UNKNOWN).setAddress(address.toString());
+    }
+    return builder.build();
+  }
+
+  private static final Set<String> NEVER_INCLUDED_METADATA = new HashSet<>(
+      Collections.singletonList(
+          // grpc-status-details-bin is already logged in a field of the binlog proto
+          STATUS_DETAILS_KEY.name()));
+  private static final Set<String> ALWAYS_INCLUDED_METADATA = new HashSet<>(
+      Collections.singletonList(
+          "grpc-trace-bin"));
+
+  static final class MaybeTruncated<T> {
+    T proto;
+    boolean truncated;
+
+    private MaybeTruncated(T proto, boolean truncated) {
+      this.proto = proto;
+      this.truncated = truncated;
+    }
+  }
+
+  @VisibleForTesting
+  static MaybeTruncated<io.grpc.binarylog.v1.Metadata.Builder> createMetadataProto(
+      Metadata metadata, int maxHeaderBytes) {
+    checkNotNull(metadata, "metadata");
+    checkArgument(maxHeaderBytes >= 0, "maxHeaderBytes must be non negative");
+    io.grpc.binarylog.v1.Metadata.Builder metaBuilder = io.grpc.binarylog.v1.Metadata.newBuilder();
+    // This code is tightly coupled with Metadata's implementation
+    byte[][] serialized = InternalMetadata.serialize(metadata);
+    boolean truncated = false;
+    if (serialized != null) {
+      int curBytes = 0;
+      for (int i = 0; i < serialized.length; i += 2) {
+        String key = new String(serialized[i], StandardCharsets.UTF_8);
+        byte[] value = serialized[i + 1];
+        if (NEVER_INCLUDED_METADATA.contains(key)) {
+          continue;
+        }
+        boolean forceInclude = ALWAYS_INCLUDED_METADATA.contains(key);
+        int bytesAfterAdd = curBytes + key.length() + value.length;
+        if (!forceInclude && bytesAfterAdd > maxHeaderBytes) {
+          truncated = true;
+          continue;
+        }
+        metaBuilder.addEntry(
+            MetadataEntry.newBuilder().setKey(key).setValue(ByteString.copyFrom(value)));
+        if (!forceInclude) {
+          // force included keys do not count towards the size limit
+          curBytes = bytesAfterAdd;
+        }
+      }
+    }
+    return new MaybeTruncated<>(metaBuilder, truncated);
+  }
+
+  @VisibleForTesting
+  static MaybeTruncated<Message.Builder> createMessageProto(
+      byte[] message, int maxMessageBytes) {
+    checkNotNull(message, "message");
+    checkArgument(maxMessageBytes >= 0, "maxMessageBytes must be non negative");
+    Message.Builder msgBuilder = Message
+        .newBuilder()
+        .setLength(message.length);
+    if (maxMessageBytes > 0) {
+      int desiredBytes = Math.min(maxMessageBytes, message.length);
+      msgBuilder.setData(ByteString.copyFrom(message, 0, desiredBytes));
+    }
+    return new MaybeTruncated<>(msgBuilder, maxMessageBytes < message.length);
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/ChannelzProtoUtil.java b/services/src/main/java/io/grpc/protobuf/services/ChannelzProtoUtil.java
new file mode 100644
index 00000000000..74448a8c5bf
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/ChannelzProtoUtil.java
@@ -0,0 +1,505 @@
+/*
+ * Copyright 2018 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.protobuf.services;
+
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.protobuf.Any;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.Int64Value;
+import com.google.protobuf.MessageLite;
+import com.google.protobuf.util.Durations;
+import com.google.protobuf.util.Timestamps;
+import io.grpc.ConnectivityState;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.ChannelStats;
+import io.grpc.InternalChannelz.ChannelTrace.Event;
+import io.grpc.InternalChannelz.RootChannelList;
+import io.grpc.InternalChannelz.ServerList;
+import io.grpc.InternalChannelz.ServerSocketsList;
+import io.grpc.InternalChannelz.ServerStats;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalChannelz.TransportStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.InternalWithLogId;
+import io.grpc.Status;
+import io.grpc.channelz.v1.Address;
+import io.grpc.channelz.v1.Address.OtherAddress;
+import io.grpc.channelz.v1.Address.TcpIpAddress;
+import io.grpc.channelz.v1.Address.UdsAddress;
+import io.grpc.channelz.v1.Channel;
+import io.grpc.channelz.v1.ChannelConnectivityState;
+import io.grpc.channelz.v1.ChannelConnectivityState.State;
+import io.grpc.channelz.v1.ChannelData;
+import io.grpc.channelz.v1.ChannelRef;
+import io.grpc.channelz.v1.ChannelTrace;
+import io.grpc.channelz.v1.ChannelTraceEvent;
+import io.grpc.channelz.v1.ChannelTraceEvent.Severity;
+import io.grpc.channelz.v1.GetServerSocketsResponse;
+import io.grpc.channelz.v1.GetServersResponse;
+import io.grpc.channelz.v1.GetTopChannelsResponse;
+import io.grpc.channelz.v1.Security;
+import io.grpc.channelz.v1.Security.OtherSecurity;
+import io.grpc.channelz.v1.Security.Tls;
+import io.grpc.channelz.v1.Server;
+import io.grpc.channelz.v1.ServerData;
+import io.grpc.channelz.v1.ServerRef;
+import io.grpc.channelz.v1.Socket;
+import io.grpc.channelz.v1.SocketData;
+import io.grpc.channelz.v1.SocketOption;
+import io.grpc.channelz.v1.SocketOptionLinger;
+import io.grpc.channelz.v1.SocketOptionTcpInfo;
+import io.grpc.channelz.v1.SocketOptionTimeout;
+import io.grpc.channelz.v1.SocketRef;
+import io.grpc.channelz.v1.Subchannel;
+import io.grpc.channelz.v1.SubchannelRef;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.security.cert.CertificateEncodingException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A static utility class for turning internal data structures into protos.
+ *
+ * <p>Works with both regular and lite protos.
+ */
+final class ChannelzProtoUtil {
+  private static final Logger logger = Logger.getLogger(ChannelzProtoUtil.class.getName());
+
+  private ChannelzProtoUtil() {
+    // do not instantiate.
+  }
+
+  static ChannelRef toChannelRef(InternalWithLogId obj) {
+    return ChannelRef
+        .newBuilder()
+        .setChannelId(obj.getLogId().getId())
+        .setName(obj.toString())
+        .build();
+  }
+
+  static SubchannelRef toSubchannelRef(InternalWithLogId obj) {
+    return SubchannelRef
+        .newBuilder()
+        .setSubchannelId(obj.getLogId().getId())
+        .setName(obj.toString())
+        .build();
+  }
+
+  static ServerRef toServerRef(InternalWithLogId obj) {
+    return ServerRef
+        .newBuilder()
+        .setServerId(obj.getLogId().getId())
+        .setName(obj.toString())
+        .build();
+  }
+
+  static SocketRef toSocketRef(InternalWithLogId obj) {
+    return SocketRef
+        .newBuilder()
+        .setSocketId(obj.getLogId().getId())
+        .setName(obj.toString())
+        .build();
+  }
+
+  static Server toServer(InternalInstrumented<ServerStats> obj) {
+    ServerStats stats = getFuture(obj.getStats());
+    Server.Builder builder = Server
+        .newBuilder()
+        .setRef(toServerRef(obj))
+        .setData(toServerData(stats));
+    for (InternalInstrumented<SocketStats> listenSocket : stats.listenSockets) {
+      builder.addListenSocket(toSocketRef(listenSocket));
+    }
+    return builder.build();
+  }
+
+  static ServerData toServerData(ServerStats stats) {
+    return ServerData
+        .newBuilder()
+        .setCallsStarted(stats.callsStarted)
+        .setCallsSucceeded(stats.callsSucceeded)
+        .setCallsFailed(stats.callsFailed)
+        .setLastCallStartedTimestamp(Timestamps.fromNanos(stats.lastCallStartedNanos))
+        .build();
+  }
+
+  static Security toSecurity(InternalChannelz.Security security) {
+    Preconditions.checkNotNull(security);
+    Preconditions.checkState(
+        security.tls != null ^ security.other != null,
+        "one of tls or othersecurity must be non null");
+    if (security.tls != null) {
+      Tls.Builder tlsBuilder
+          = Tls.newBuilder().setStandardName(security.tls.cipherSuiteStandardName);
+      try {
+        if (security.tls.localCert != null) {
+          tlsBuilder.setLocalCertificate(ByteString.copyFrom(
+              security.tls.localCert.getEncoded()));
+        }
+        if (security.tls.remoteCert != null) {
+          tlsBuilder.setRemoteCertificate(ByteString.copyFrom(
+              security.tls.remoteCert.getEncoded()));
+        }
+      } catch (CertificateEncodingException e) {
+        logger.log(Level.FINE, "Caught exception", e);
+      }
+      return Security.newBuilder().setTls(tlsBuilder).build();
+    } else {
+      OtherSecurity.Builder builder = OtherSecurity.newBuilder().setName(security.other.name);
+      if (security.other.any != null) {
+        builder.setValue((Any) security.other.any);
+      }
+      return Security.newBuilder().setOther(builder).build();
+    }
+  }
+
+  static Socket toSocket(InternalInstrumented<SocketStats> obj) {
+    SocketStats socketStats = getFuture(obj.getStats());
+    Socket.Builder builder = Socket.newBuilder()
+        .setRef(toSocketRef(obj))
+        .setLocal(toAddress(socketStats.local));
+    if (socketStats.security != null) {
+      builder.setSecurity(toSecurity(socketStats.security));
+    }
+    // listen sockets do not have remote nor data
+    if (socketStats.remote != null) {
+      builder.setRemote(toAddress(socketStats.remote));
+    }
+    builder.setData(extractSocketData(socketStats));
+    return builder.build();
+  }
+
+  static Address toAddress(SocketAddress address) {
+    Preconditions.checkNotNull(address);
+    Address.Builder builder = Address.newBuilder();
+    if (address instanceof InetSocketAddress) {
+      InetSocketAddress inetAddress = (InetSocketAddress) address;
+      builder.setTcpipAddress(
+          TcpIpAddress
+              .newBuilder()
+              .setIpAddress(
+                  ByteString.copyFrom(inetAddress.getAddress().getAddress()))
+              .setPort(inetAddress.getPort())
+              .build());
+    } else if (address.getClass().getName().endsWith("io.netty.channel.unix.DomainSocketAddress")) {
+      builder.setUdsAddress(
+          UdsAddress
+              .newBuilder()
+              .setFilename(address.toString()) // DomainSocketAddress.toString returns filename
+              .build());
+    } else {
+      builder.setOtherAddress(OtherAddress.newBuilder().setName(address.toString()).build());
+    }
+    return builder.build();
+  }
+
+  static SocketData extractSocketData(SocketStats socketStats) {
+    SocketData.Builder builder = SocketData.newBuilder();
+    if (socketStats.data != null) {
+      TransportStats s = socketStats.data;
+      builder
+          .setStreamsStarted(s.streamsStarted)
+          .setStreamsSucceeded(s.streamsSucceeded)
+          .setStreamsFailed(s.streamsFailed)
+          .setMessagesSent(s.messagesSent)
+          .setMessagesReceived(s.messagesReceived)
+          .setKeepAlivesSent(s.keepAlivesSent)
+          .setLastLocalStreamCreatedTimestamp(
+              Timestamps.fromNanos(s.lastLocalStreamCreatedTimeNanos))
+          .setLastRemoteStreamCreatedTimestamp(
+              Timestamps.fromNanos(s.lastRemoteStreamCreatedTimeNanos))
+          .setLastMessageSentTimestamp(
+              Timestamps.fromNanos(s.lastMessageSentTimeNanos))
+          .setLastMessageReceivedTimestamp(
+              Timestamps.fromNanos(s.lastMessageReceivedTimeNanos))
+          .setLocalFlowControlWindow(
+              Int64Value.of(s.localFlowControlWindow))
+          .setRemoteFlowControlWindow(
+              Int64Value.of(s.remoteFlowControlWindow));
+    }
+    builder.addAllOption(toSocketOptionsList(socketStats.socketOptions));
+    return builder.build();
+  }
+
+  public static final String SO_LINGER = "SO_LINGER";
+  public static final String SO_TIMEOUT = "SO_TIMEOUT";
+  public static final String TCP_INFO = "TCP_INFO";
+
+  static SocketOption toSocketOptionLinger(int lingerSeconds) {
+    final SocketOptionLinger lingerOpt;
+    if (lingerSeconds >= 0) {
+      lingerOpt = SocketOptionLinger
+          .newBuilder()
+          .setActive(true)
+          .setDuration(Durations.fromSeconds(lingerSeconds))
+          .build();
+    } else {
+      lingerOpt = SocketOptionLinger.getDefaultInstance();
+    }
+    return SocketOption.newBuilder()
+        .setName(SO_LINGER)
+        .setAdditional(packToAny("SocketOptionLinger", lingerOpt))
+        .build();
+  }
+
+  static SocketOption toSocketOptionTimeout(String name, int timeoutMillis) {
+    Preconditions.checkNotNull(name);
+    return SocketOption.newBuilder()
+        .setName(name)
+        .setAdditional(
+            packToAny(
+                "SocketOptionTimeout",
+                SocketOptionTimeout.newBuilder()
+                    .setDuration(Durations.fromMillis(timeoutMillis))
+                    .build()))
+        .build();
+  }
+
+  static SocketOption toSocketOptionTcpInfo(InternalChannelz.TcpInfo i) {
+    SocketOptionTcpInfo tcpInfo = SocketOptionTcpInfo.newBuilder()
+        .setTcpiState(i.state)
+        .setTcpiCaState(i.caState)
+        .setTcpiRetransmits(i.retransmits)
+        .setTcpiProbes(i.probes)
+        .setTcpiBackoff(i.backoff)
+        .setTcpiOptions(i.options)
+        .setTcpiSndWscale(i.sndWscale)
+        .setTcpiRcvWscale(i.rcvWscale)
+        .setTcpiRto(i.rto)
+        .setTcpiAto(i.ato)
+        .setTcpiSndMss(i.sndMss)
+        .setTcpiRcvMss(i.rcvMss)
+        .setTcpiUnacked(i.unacked)
+        .setTcpiSacked(i.sacked)
+        .setTcpiLost(i.lost)
+        .setTcpiRetrans(i.retrans)
+        .setTcpiFackets(i.fackets)
+        .setTcpiLastDataSent(i.lastDataSent)
+        .setTcpiLastAckSent(i.lastAckSent)
+        .setTcpiLastDataRecv(i.lastDataRecv)
+        .setTcpiLastAckRecv(i.lastAckRecv)
+        .setTcpiPmtu(i.pmtu)
+        .setTcpiRcvSsthresh(i.rcvSsthresh)
+        .setTcpiRtt(i.rtt)
+        .setTcpiRttvar(i.rttvar)
+        .setTcpiSndSsthresh(i.sndSsthresh)
+        .setTcpiSndCwnd(i.sndCwnd)
+        .setTcpiAdvmss(i.advmss)
+        .setTcpiReordering(i.reordering)
+        .build();
+    return SocketOption.newBuilder()
+        .setName(TCP_INFO)
+        .setAdditional(packToAny("SocketOptionTcpInfo", tcpInfo))
+        .build();
+  }
+
+  static SocketOption toSocketOptionAdditional(String name, String value) {
+    Preconditions.checkNotNull(name);
+    Preconditions.checkNotNull(value);
+    return SocketOption.newBuilder().setName(name).setValue(value).build();
+  }
+
+  static List<SocketOption> toSocketOptionsList(InternalChannelz.SocketOptions options) {
+    Preconditions.checkNotNull(options);
+    List<SocketOption> ret = new ArrayList<>();
+    if (options.lingerSeconds != null) {
+      ret.add(toSocketOptionLinger(options.lingerSeconds));
+    }
+    if (options.soTimeoutMillis != null) {
+      ret.add(toSocketOptionTimeout(SO_TIMEOUT, options.soTimeoutMillis));
+    }
+    if (options.tcpInfo != null) {
+      ret.add(toSocketOptionTcpInfo(options.tcpInfo));
+    }
+    for (Map.Entry<String, String> entry : options.others.entrySet()) {
+      ret.add(toSocketOptionAdditional(entry.getKey(), entry.getValue()));
+    }
+    return ret;
+  }
+
+  static Channel toChannel(InternalInstrumented<ChannelStats> channel) {
+    ChannelStats stats = getFuture(channel.getStats());
+    Channel.Builder channelBuilder = Channel
+        .newBuilder()
+        .setRef(toChannelRef(channel))
+        .setData(extractChannelData(stats));
+    for (InternalWithLogId subchannel : stats.subchannels) {
+      channelBuilder.addSubchannelRef(toSubchannelRef(subchannel));
+    }
+
+    return channelBuilder.build();
+  }
+
+  static ChannelData extractChannelData(InternalChannelz.ChannelStats stats) {
+    ChannelData.Builder builder = ChannelData.newBuilder();
+    builder.setTarget(stats.target)
+        .setState(toChannelConnectivityState(stats.state))
+        .setCallsStarted(stats.callsStarted)
+        .setCallsSucceeded(stats.callsSucceeded)
+        .setCallsFailed(stats.callsFailed)
+        .setLastCallStartedTimestamp(Timestamps.fromNanos(stats.lastCallStartedNanos));
+    if (stats.channelTrace != null) {
+      builder.setTrace(toChannelTrace(stats.channelTrace));
+    }
+    return builder.build();
+  }
+
+  static ChannelConnectivityState toChannelConnectivityState(ConnectivityState s) {
+    return ChannelConnectivityState.newBuilder().setState(toState(s)).build();
+  }
+
+  private static ChannelTrace toChannelTrace(InternalChannelz.ChannelTrace channelTrace) {
+    return ChannelTrace.newBuilder()
+        .setNumEventsLogged(channelTrace.numEventsLogged)
+        .setCreationTimestamp(Timestamps.fromNanos(channelTrace.creationTimeNanos))
+        .addAllEvents(toChannelTraceEvents(channelTrace.events))
+        .build();
+  }
+
+  private static List<ChannelTraceEvent> toChannelTraceEvents(List<Event> events) {
+    List<ChannelTraceEvent> channelTraceEvents = new ArrayList<>();
+    for (Event event : events) {
+      ChannelTraceEvent.Builder builder =
+          ChannelTraceEvent.newBuilder()
+              .setDescription(event.description)
+              .setSeverity(toSeverity(event.severity))
+              .setTimestamp(Timestamps.fromNanos(event.timestampNanos));
+      if (event.channelRef != null) {
+        builder.setChannelRef(toChannelRef(event.channelRef));
+      }
+      if (event.subchannelRef != null) {
+        builder.setSubchannelRef(toSubchannelRef(event.subchannelRef));
+      }
+      channelTraceEvents.add(builder.build());
+    }
+    return Collections.unmodifiableList(channelTraceEvents);
+  }
+
+  static Severity toSeverity(Event.Severity severity) {
+    if (severity == null) {
+      return Severity.CT_UNKNOWN;
+    }
+    switch (severity) {
+      case CT_INFO:
+        return Severity.CT_INFO;
+      case CT_ERROR:
+        return Severity.CT_ERROR;
+      case CT_WARNING:
+        return Severity.CT_WARNING;
+      default:
+        return Severity.CT_UNKNOWN;
+    }
+  }
+
+  static State toState(ConnectivityState state) {
+    if (state == null) {
+      return State.UNKNOWN;
+    }
+    switch (state) {
+      case IDLE:
+        return State.IDLE;
+      case READY:
+        return State.READY;
+      case CONNECTING:
+        return State.CONNECTING;
+      case SHUTDOWN:
+        return State.SHUTDOWN;
+      case TRANSIENT_FAILURE:
+        return State.TRANSIENT_FAILURE;
+      default:
+        return State.UNKNOWN;
+    }
+  }
+
+  static Subchannel toSubchannel(InternalInstrumented<ChannelStats> subchannel) {
+    ChannelStats stats = getFuture(subchannel.getStats());
+    Subchannel.Builder subchannelBuilder = Subchannel
+        .newBuilder()
+        .setRef(toSubchannelRef(subchannel))
+        .setData(extractChannelData(stats));
+    Preconditions.checkState(stats.sockets.isEmpty() || stats.subchannels.isEmpty());
+    for (InternalWithLogId childSocket : stats.sockets) {
+      subchannelBuilder.addSocketRef(toSocketRef(childSocket));
+    }
+    for (InternalWithLogId childSubchannel : stats.subchannels) {
+      subchannelBuilder.addSubchannelRef(toSubchannelRef(childSubchannel));
+    }
+    return subchannelBuilder.build();
+  }
+
+  static GetTopChannelsResponse toGetTopChannelResponse(RootChannelList rootChannels) {
+    GetTopChannelsResponse.Builder responseBuilder = GetTopChannelsResponse
+        .newBuilder()
+        .setEnd(rootChannels.end);
+    for (InternalInstrumented<ChannelStats> c : rootChannels.channels) {
+      responseBuilder.addChannel(ChannelzProtoUtil.toChannel(c));
+    }
+    return responseBuilder.build();
+  }
+
+  static GetServersResponse toGetServersResponse(ServerList servers) {
+    GetServersResponse.Builder responseBuilder = GetServersResponse
+        .newBuilder()
+        .setEnd(servers.end);
+    for (InternalInstrumented<ServerStats> s : servers.servers) {
+      responseBuilder.addServer(ChannelzProtoUtil.toServer(s));
+    }
+    return responseBuilder.build();
+  }
+
+  static GetServerSocketsResponse toGetServerSocketsResponse(ServerSocketsList serverSockets) {
+    GetServerSocketsResponse.Builder responseBuilder = GetServerSocketsResponse
+        .newBuilder()
+        .setEnd(serverSockets.end);
+    for (InternalWithLogId s : serverSockets.sockets) {
+      responseBuilder.addSocketRef(ChannelzProtoUtil.toSocketRef(s));
+    }
+    return responseBuilder.build();
+  }
+
+  private static <T> T getFuture(ListenableFuture<T> future) {
+    try {
+      T ret = future.get();
+      if (ret == null) {
+        throw Status.UNIMPLEMENTED
+            .withDescription("The entity's stats can not be retrieved. "
+                + "If this is an InProcessTransport this is expected.")
+            .asRuntimeException();
+      }
+      return ret;
+    } catch (InterruptedException e) {
+      throw Status.INTERNAL.withCause(e).asRuntimeException();
+    } catch (ExecutionException e) {
+      throw Status.INTERNAL.withCause(e).asRuntimeException();
+    }
+  }
+
+  // A version of Any.pack() that works with protolite.
+  private static Any packToAny(String typeName, MessageLite value) {
+    return Any.newBuilder()
+        .setTypeUrl("type.googleapis.com/grpc.channelz.v1." + typeName)
+        .setValue(value.toByteString())
+        .build();
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/ChannelzService.java b/services/src/main/java/io/grpc/protobuf/services/ChannelzService.java
new file mode 100644
index 00000000000..66daf559d32
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/ChannelzService.java
@@ -0,0 +1,234 @@
+/*
+ * Copyright 2018 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.protobuf.services;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.ExperimentalApi;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.ChannelStats;
+import io.grpc.InternalChannelz.ServerList;
+import io.grpc.InternalChannelz.ServerSocketsList;
+import io.grpc.InternalChannelz.ServerStats;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.channelz.v1.ChannelzGrpc;
+import io.grpc.channelz.v1.GetChannelRequest;
+import io.grpc.channelz.v1.GetChannelResponse;
+import io.grpc.channelz.v1.GetServerRequest;
+import io.grpc.channelz.v1.GetServerResponse;
+import io.grpc.channelz.v1.GetServerSocketsRequest;
+import io.grpc.channelz.v1.GetServerSocketsResponse;
+import io.grpc.channelz.v1.GetServersRequest;
+import io.grpc.channelz.v1.GetServersResponse;
+import io.grpc.channelz.v1.GetSocketRequest;
+import io.grpc.channelz.v1.GetSocketResponse;
+import io.grpc.channelz.v1.GetSubchannelRequest;
+import io.grpc.channelz.v1.GetSubchannelResponse;
+import io.grpc.channelz.v1.GetTopChannelsRequest;
+import io.grpc.channelz.v1.GetTopChannelsResponse;
+import io.grpc.stub.StreamObserver;
+
+/**
+ * The channelz service provides stats about a running gRPC process.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4206")
+public final class ChannelzService extends ChannelzGrpc.ChannelzImplBase {
+  private final InternalChannelz channelz;
+  private final int maxPageSize;
+
+  /**
+   * Creates an instance.
+   */
+  public static ChannelzService newInstance(int maxPageSize) {
+    return new ChannelzService(InternalChannelz.instance(), maxPageSize);
+  }
+
+  @VisibleForTesting
+  ChannelzService(InternalChannelz channelz, int maxPageSize) {
+    this.channelz = channelz;
+    this.maxPageSize = maxPageSize;
+  }
+
+  /** Returns top level channel aka {@link io.grpc.ManagedChannel}. */
+  @Override
+  public void getTopChannels(
+      GetTopChannelsRequest request, StreamObserver<GetTopChannelsResponse> responseObserver) {
+    InternalChannelz.RootChannelList rootChannels
+        = channelz.getRootChannels(request.getStartChannelId(), maxPageSize);
+
+    GetTopChannelsResponse resp;
+    try {
+      resp = ChannelzProtoUtil.toGetTopChannelResponse(rootChannels);
+    } catch (StatusRuntimeException e) {
+      responseObserver.onError(e);
+      return;
+    }
+
+    responseObserver.onNext(resp);
+    responseObserver.onCompleted();
+  }
+
+  /** Returns a top level channel aka {@link io.grpc.ManagedChannel}. */
+  @Override
+  public void getChannel(
+      GetChannelRequest request, StreamObserver<GetChannelResponse> responseObserver) {
+    InternalInstrumented<ChannelStats> s = channelz.getRootChannel(request.getChannelId());
+    if (s == null) {
+      responseObserver.onError(
+          Status.NOT_FOUND.withDescription("Can't find channel " + request.getChannelId())
+              .asRuntimeException());
+      return;
+    }
+
+    GetChannelResponse resp;
+    try {
+      resp = GetChannelResponse
+          .newBuilder()
+          .setChannel(ChannelzProtoUtil.toChannel(s))
+          .build();
+    } catch (StatusRuntimeException e) {
+      responseObserver.onError(e);
+      return;
+    }
+
+    responseObserver.onNext(resp);
+    responseObserver.onCompleted();
+  }
+
+  /** Returns servers. */
+  @Override
+  public void getServers(
+      GetServersRequest request, StreamObserver<GetServersResponse> responseObserver) {
+    ServerList servers = channelz.getServers(request.getStartServerId(), maxPageSize);
+
+    GetServersResponse resp;
+    try {
+      resp = ChannelzProtoUtil.toGetServersResponse(servers);
+    } catch (StatusRuntimeException e) {
+      responseObserver.onError(e);
+      return;
+    }
+
+    responseObserver.onNext(resp);
+    responseObserver.onCompleted();
+  }
+
+  /** Returns a server. */
+  @Override
+  public void getServer(
+      GetServerRequest request, StreamObserver<GetServerResponse> responseObserver) {
+    InternalInstrumented<ServerStats> s = channelz.getServer(request.getServerId());
+    if (s == null) {
+      responseObserver.onError(
+          Status.NOT_FOUND.withDescription("Can't find server " + request.getServerId())
+              .asRuntimeException());
+      return;
+    }
+
+    GetServerResponse resp;
+    try {
+      resp = GetServerResponse
+          .newBuilder()
+          .setServer(ChannelzProtoUtil.toServer(s))
+          .build();
+    } catch (StatusRuntimeException e) {
+      responseObserver.onError(e);
+      return;
+    }
+
+    responseObserver.onNext(resp);
+    responseObserver.onCompleted();
+  }
+
+  /** Returns a subchannel. */
+  @Override
+  public void getSubchannel(
+      GetSubchannelRequest request, StreamObserver<GetSubchannelResponse> responseObserver) {
+    InternalInstrumented<ChannelStats> s = channelz.getSubchannel(request.getSubchannelId());
+    if (s == null) {
+      responseObserver.onError(
+          Status.NOT_FOUND.withDescription("Can't find subchannel " + request.getSubchannelId())
+              .asRuntimeException());
+      return;
+    }
+
+    GetSubchannelResponse resp;
+    try {
+      resp = GetSubchannelResponse
+          .newBuilder()
+          .setSubchannel(ChannelzProtoUtil.toSubchannel(s))
+          .build();
+    } catch (StatusRuntimeException e) {
+      responseObserver.onError(e);
+      return;
+    }
+
+    responseObserver.onNext(resp);
+    responseObserver.onCompleted();
+  }
+
+  /** Returns a socket. */
+  @Override
+  public void getSocket(
+      GetSocketRequest request, StreamObserver<GetSocketResponse> responseObserver) {
+    InternalInstrumented<SocketStats> s = channelz.getSocket(request.getSocketId());
+    if (s == null) {
+      responseObserver.onError(
+          Status.NOT_FOUND.withDescription("Can't find socket " + request.getSocketId())
+              .asRuntimeException());
+      return;
+    }
+
+    GetSocketResponse resp;
+    try {
+      resp =
+          GetSocketResponse.newBuilder().setSocket(ChannelzProtoUtil.toSocket(s)).build();
+    } catch (StatusRuntimeException e) {
+      responseObserver.onError(e);
+      return;
+    }
+
+    responseObserver.onNext(resp);
+    responseObserver.onCompleted();
+  }
+
+  @Override
+  public void getServerSockets(
+      GetServerSocketsRequest request, StreamObserver<GetServerSocketsResponse> responseObserver) {
+    ServerSocketsList serverSockets
+        = channelz.getServerSockets(request.getServerId(), request.getStartSocketId(), maxPageSize);
+    if (serverSockets == null) {
+      responseObserver.onError(
+          Status.NOT_FOUND.withDescription("Can't find server " + request.getServerId())
+              .asRuntimeException());
+      return;
+    }
+
+    GetServerSocketsResponse resp;
+    try {
+      resp = ChannelzProtoUtil.toGetServerSocketsResponse(serverSockets);
+    } catch (StatusRuntimeException e) {
+      responseObserver.onError(e);
+      return;
+    }
+
+    responseObserver.onNext(resp);
+    responseObserver.onCompleted();
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerFactory.java b/services/src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerFactory.java
new file mode 100644
index 00000000000..8cf1458f5dc
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerFactory.java
@@ -0,0 +1,487 @@
+/*
+ * Copyright 2018 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.protobuf.services;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.LoadBalancer.HEALTH_CONSUMER_LISTENER_ARG_KEY;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import io.grpc.CallOptions;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.ClientCall;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import io.grpc.health.v1.HealthCheckRequest;
+import io.grpc.health.v1.HealthCheckResponse;
+import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
+import io.grpc.health.v1.HealthGrpc;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.ServiceConfigUtil;
+import io.grpc.util.ForwardingLoadBalancer;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import io.grpc.util.ForwardingSubchannel;
+import io.grpc.util.HealthProducerHelper;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * Wraps a {@link LoadBalancer} and implements the client-side health-checking
+ * (https://github.com/grpc/proposal/blob/master/A17-client-side-health-checking.md).  The
+ * Subchannel received by the states wrapped LoadBalancer will be determined by health-checking.
+ *
+ * <p>Note the original LoadBalancer must call {@code Helper.createSubchannel()} from the
+ * SynchronizationContext, or it will throw.
+ */
+final class HealthCheckingLoadBalancerFactory extends LoadBalancer.Factory {
+  private static final Logger logger =
+      Logger.getLogger(HealthCheckingLoadBalancerFactory.class.getName());
+
+  private final LoadBalancer.Factory delegateFactory;
+  private final BackoffPolicy.Provider backoffPolicyProvider;
+  private final Supplier<Stopwatch> stopwatchSupplier;
+
+  public HealthCheckingLoadBalancerFactory(
+      LoadBalancer.Factory delegateFactory, BackoffPolicy.Provider backoffPolicyProvider,
+      Supplier<Stopwatch> stopwatchSupplier) {
+    this.delegateFactory = checkNotNull(delegateFactory, "delegateFactory");
+    this.backoffPolicyProvider = checkNotNull(backoffPolicyProvider, "backoffPolicyProvider");
+    this.stopwatchSupplier = checkNotNull(stopwatchSupplier, "stopwatchSupplier");
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    HelperImpl wrappedHelper = new HelperImpl(helper);
+    LoadBalancer delegateBalancer = delegateFactory.newLoadBalancer(wrappedHelper);
+    return new HealthCheckingLoadBalancer(wrappedHelper, delegateBalancer);
+  }
+
+  private final class HelperImpl extends ForwardingLoadBalancerHelper {
+    private final Helper delegate;
+    private final SynchronizationContext syncContext;
+
+    @Nullable String healthCheckedService;
+
+    final HashSet<HealthCheckState> hcStates = new HashSet<>();
+
+    HelperImpl(Helper delegate) {
+      this.delegate = new HealthProducerHelper(checkNotNull(delegate, "delegate"));
+      this.syncContext = checkNotNull(delegate.getSynchronizationContext(), "syncContext");
+    }
+
+    @Override
+    protected Helper delegate() {
+      return delegate;
+    }
+
+    @Override
+    public Subchannel createSubchannel(CreateSubchannelArgs args) {
+      // HealthCheckState is not thread-safe, we are requiring the original LoadBalancer calls
+      // createSubchannel() from the SynchronizationContext.
+      syncContext.throwIfNotInThisSynchronizationContext();
+      LoadBalancer.SubchannelStateListener healthConsumerListener =
+          args.getOption(HEALTH_CONSUMER_LISTENER_ARG_KEY);
+      HealthCheckState hcState = new HealthCheckState(
+          this, syncContext, delegate.getScheduledExecutorService(), healthConsumerListener);
+      if (healthConsumerListener != null) {
+        args = args.toBuilder().addOption(HEALTH_CONSUMER_LISTENER_ARG_KEY, hcState).build();
+      }
+      Subchannel delegate = super.createSubchannel(args);
+      hcState.setSubchannel(delegate);
+      hcStates.add(hcState);
+      Subchannel subchannel = new SubchannelImpl(delegate, hcState);
+      if (healthCheckedService != null) {
+        hcState.setServiceName(healthCheckedService);
+      }
+      return subchannel;
+    }
+
+    void setHealthCheckedService(@Nullable String service) {
+      healthCheckedService = service;
+      for (HealthCheckState hcState : hcStates) {
+        hcState.setServiceName(service);
+      }
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+    }
+  }
+
+  @VisibleForTesting
+  static final class SubchannelImpl extends ForwardingSubchannel {
+    final Subchannel delegate;
+    final HealthCheckState hcState;
+
+    SubchannelImpl(Subchannel delegate, HealthCheckState hcState) {
+      this.delegate = checkNotNull(delegate, "delegate");
+      this.hcState = checkNotNull(hcState, "hcState");
+    }
+
+    @Override
+    protected Subchannel delegate() {
+      return delegate;
+    }
+
+    @Override
+    public void start(final SubchannelStateListener listener) {
+      if (hcState.stateListener == null) {
+        hcState.init(listener);
+        delegate().start(hcState);
+      } else {
+        delegate().start(listener);
+      }
+    }
+  }
+
+  private static final class HealthCheckingLoadBalancer extends ForwardingLoadBalancer {
+    final LoadBalancer delegate;
+    final HelperImpl helper;
+
+    HealthCheckingLoadBalancer(HelperImpl helper, LoadBalancer delegate) {
+      this.helper = checkNotNull(helper, "helper");
+      this.delegate = checkNotNull(delegate, "delegate");
+    }
+
+    @Override
+    protected LoadBalancer delegate() {
+      return delegate;
+    }
+
+    @Override
+    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      Map<String, ?> healthCheckingConfig =
+          resolvedAddresses
+              .getAttributes()
+              .get(LoadBalancer.ATTR_HEALTH_CHECKING_CONFIG);
+      String serviceName = ServiceConfigUtil.getHealthCheckedServiceName(healthCheckingConfig);
+      helper.setHealthCheckedService(serviceName);
+      delegate.handleResolvedAddresses(resolvedAddresses);
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      Map<String, ?> healthCheckingConfig =
+          resolvedAddresses
+              .getAttributes()
+              .get(LoadBalancer.ATTR_HEALTH_CHECKING_CONFIG);
+      String serviceName = ServiceConfigUtil.getHealthCheckedServiceName(healthCheckingConfig);
+      helper.setHealthCheckedService(serviceName);
+      return delegate.acceptResolvedAddresses(resolvedAddresses);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+    }
+  }
+
+  
+  // All methods are run from syncContext
+  private final class HealthCheckState implements SubchannelStateListener {
+    private final Runnable retryTask = new Runnable() {
+        @Override
+        public void run() {
+          startRpc();
+        }
+      };
+
+    private final SynchronizationContext syncContext;
+    private final ScheduledExecutorService timerService;
+    private final HelperImpl helperImpl;
+    private Subchannel subchannel;
+    private ChannelLogger subchannelLogger;
+
+    // In dual stack new pick first, this becomes health listener from create subchannel args.
+    private SubchannelStateListener stateListener;
+
+    // Set when RPC started. Cleared when the RPC has closed or abandoned.
+    @Nullable
+    private HcStream activeRpc;
+
+    // The service name that should be used for health checking
+    private String serviceName;
+    private BackoffPolicy backoffPolicy;
+    // The state from the underlying Subchannel
+    private ConnectivityStateInfo rawState = ConnectivityStateInfo.forNonError(IDLE);
+    // The state concluded from health checking
+    private ConnectivityStateInfo concludedState = ConnectivityStateInfo.forNonError(IDLE);
+    // true if a health check stream should be kept.  When true, either there is an active RPC, or a
+    // retry is pending.
+    private boolean running;
+    // true if server returned UNIMPLEMENTED
+    private boolean disabled;
+    private ScheduledHandle retryTimer;
+
+    HealthCheckState(
+        HelperImpl helperImpl, SynchronizationContext syncContext,
+        ScheduledExecutorService timerService,
+        @Nullable SubchannelStateListener healthListener) {
+      this.helperImpl = checkNotNull(helperImpl, "helperImpl");
+      this.syncContext = checkNotNull(syncContext, "syncContext");
+      this.timerService = checkNotNull(timerService, "timerService");
+      this.stateListener = healthListener;
+    }
+
+    void setSubchannel(Subchannel subchannel) {
+      this.subchannel = checkNotNull(subchannel, "subchannel");
+      this.subchannelLogger = checkNotNull(subchannel.getChannelLogger(), "subchannelLogger");
+    }
+
+    // Only called in old pick first. Can be removed after migration.
+    void init(SubchannelStateListener listener) {
+      checkState(this.stateListener == null, "init() already called");
+      this.stateListener = checkNotNull(listener, "listener");
+    }
+
+    void setServiceName(@Nullable String newServiceName) {
+      if (Objects.equal(newServiceName, serviceName)) {
+        return;
+      }
+      serviceName = newServiceName;
+      // If service name has changed while there is active RPC, cancel it so that
+      // a new call will be made with the new name.
+      String cancelMsg =
+          serviceName == null ? "Health check disabled by service config"
+          : "Switching to new service name: " + newServiceName;
+      stopRpc(cancelMsg);
+      adjustHealthCheck();
+    }
+
+    @Override
+    public void onSubchannelState(ConnectivityStateInfo rawState) {
+      if (Objects.equal(this.rawState.getState(), READY)
+          && !Objects.equal(rawState.getState(), READY)) {
+        // A connection was lost.  We will reset disabled flag because health check
+        // may be available on the new connection.
+        disabled = false;
+      }
+      if (Objects.equal(rawState.getState(), SHUTDOWN)) {
+        helperImpl.hcStates.remove(this);
+      }
+      this.rawState = rawState;
+      adjustHealthCheck();
+    }
+
+    private boolean isRetryTimerPending() {
+      return retryTimer != null && retryTimer.isPending();
+    }
+
+    // Start or stop health check according to the current states.
+    private void adjustHealthCheck() {
+      if (!disabled && serviceName != null && Objects.equal(rawState.getState(), READY)) {
+        running = true;
+        if (activeRpc == null && !isRetryTimerPending()) {
+          startRpc();
+        }
+      } else {
+        running = false;
+        // Prerequisites for health checking not met.
+        // Make sure it's stopped.
+        stopRpc("Client stops health check");
+        backoffPolicy = null;
+        gotoState(rawState);
+      }
+    }
+
+    private void startRpc() {
+      checkState(serviceName != null, "serviceName is null");
+      checkState(activeRpc == null, "previous health-checking RPC has not been cleaned up");
+      checkState(subchannel != null, "init() not called");
+      // Optimization suggested by @markroth: if we are already READY and starting the health
+      // checking RPC, either because health check is just enabled or has switched to a new service
+      // name, we don't go to CONNECTING, otherwise there will be artificial delays on RPCs
+      // waiting for the health check to respond.
+      if (!Objects.equal(concludedState.getState(), READY)) {
+        subchannelLogger.log(
+            ChannelLogLevel.INFO, "CONNECTING: Starting health-check for \"{0}\"", serviceName);
+        gotoState(ConnectivityStateInfo.forNonError(CONNECTING));
+      }
+      activeRpc = new HcStream();
+      activeRpc.start();
+    }
+
+    private void stopRpc(String msg) {
+      if (activeRpc != null) {
+        activeRpc.cancel(msg);
+        // Abandon this RPC.  We are not interested in anything from this RPC any more.
+        activeRpc = null;
+      }
+      if (retryTimer != null) {
+        retryTimer.cancel();
+        retryTimer = null;
+      }
+    }
+
+    private void gotoState(ConnectivityStateInfo newState) {
+      checkState(subchannel != null, "init() not called");
+      if (!Objects.equal(concludedState, newState)) {
+        concludedState = newState;
+        stateListener.onSubchannelState(concludedState);
+      }
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("running", running)
+          .add("disabled", disabled)
+          .add("activeRpc", activeRpc)
+          .add("serviceName", serviceName)
+          .add("rawState", rawState)
+          .add("concludedState", concludedState)
+          .toString();
+    }
+
+    private class HcStream extends ClientCall.Listener<HealthCheckResponse> {
+      private final ClientCall<HealthCheckRequest, HealthCheckResponse> call;
+      private final String callServiceName;
+      private final Stopwatch stopwatch;
+      private boolean callHasResponded;
+
+      HcStream() {
+        stopwatch = stopwatchSupplier.get().start();
+        callServiceName = serviceName;
+        call = subchannel.asChannel().newCall(HealthGrpc.getWatchMethod(), CallOptions.DEFAULT);
+      }
+
+      void start() {
+        call.start(this, new Metadata());
+        call.sendMessage(HealthCheckRequest.newBuilder().setService(serviceName).build());
+        call.halfClose();
+        call.request(1);
+      }
+
+      void cancel(String msg) {
+        call.cancel(msg, null);
+      }
+
+      @Override
+      public void onMessage(final HealthCheckResponse response) {
+        syncContext.execute(new Runnable() {
+            @Override
+            public void run() {
+              if (activeRpc == HcStream.this) {
+                handleResponse(response);
+              }
+            }
+          });
+      }
+
+      @Override
+      public void onClose(final Status status, Metadata trailers) {
+        syncContext.execute(new Runnable() {
+            @Override
+            public void run() {
+              if (activeRpc == HcStream.this) {
+                activeRpc = null;
+                handleStreamClosed(status);
+              }
+            }
+          });
+      }
+
+      void handleResponse(HealthCheckResponse response) {
+        callHasResponded = true;
+        backoffPolicy = null;
+        ServingStatus status = response.getStatus();
+        // running == true means the Subchannel's state (rawState) is READY
+        if (Objects.equal(status, ServingStatus.SERVING)) {
+          subchannelLogger.log(ChannelLogLevel.INFO, "READY: health-check responded SERVING");
+          gotoState(ConnectivityStateInfo.forNonError(READY));
+        } else {
+          subchannelLogger.log(
+              ChannelLogLevel.INFO, "TRANSIENT_FAILURE: health-check responded {0}", status);
+          String errorDescription =  "Health-check service responded "
+              + status + " for '" + callServiceName + "'";
+          gotoState(ConnectivityStateInfo.forTransientFailure(
+              Status.UNAVAILABLE.withDescription(errorDescription)));
+        }
+        call.request(1);
+      }
+
+      void handleStreamClosed(Status status) {
+        if (Objects.equal(status.getCode(), Code.UNIMPLEMENTED)) {
+          disabled = true;
+          logger.log(
+              Level.SEVERE, "Health-check with {0} is disabled. Server returned: {1}",
+              new Object[] {subchannel.getAllAddresses(), status});
+          subchannelLogger.log(ChannelLogLevel.ERROR, "Health-check disabled: {0}", status);
+          subchannelLogger.log(ChannelLogLevel.INFO, "{0} (no health-check)", rawState);
+          gotoState(rawState);
+          return;
+        }
+        long delayNanos = 0;
+        subchannelLogger.log(
+            ChannelLogLevel.INFO, "TRANSIENT_FAILURE: health-check stream closed with {0}", status);
+        String errorDescription = "Health-check stream unexpectedly closed with "
+            + status + " for '" + callServiceName + "'";
+        gotoState(ConnectivityStateInfo.forTransientFailure(
+            Status.UNAVAILABLE.withDescription(errorDescription)));
+        // Use backoff only when server has not responded for the previous call
+        if (!callHasResponded) {
+          if (backoffPolicy == null) {
+            backoffPolicy = backoffPolicyProvider.get();
+          }
+          delayNanos = backoffPolicy.nextBackoffNanos() - stopwatch.elapsed(TimeUnit.NANOSECONDS);
+        }
+        if (delayNanos <= 0) {
+          startRpc();
+        } else {
+          checkState(!isRetryTimerPending(), "Retry double scheduled");
+          subchannelLogger.log(
+              ChannelLogLevel.DEBUG, "Will retry health-check after {0} ns", delayNanos);
+          retryTimer = syncContext.schedule(
+              retryTask, delayNanos, TimeUnit.NANOSECONDS, timerService);
+        }
+      }
+
+      @Override
+      public String toString() {
+        return MoreObjects.toStringHelper(this)
+            .add("callStarted", call != null)
+            .add("serviceName", callServiceName)
+            .add("hasResponded", callHasResponded)
+            .toString();
+      }
+    }
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerUtil.java b/services/src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerUtil.java
new file mode 100644
index 00000000000..7988ed8ff9e
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerUtil.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2018 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.protobuf.services;
+
+import io.grpc.ExperimentalApi;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.internal.ExponentialBackoffPolicy;
+import io.grpc.internal.GrpcUtil;
+
+/**
+ * Utility for enabling
+ * <a href="https://github.com/grpc/proposal/blob/master/A17-client-side-health-checking.md">
+ * client-side health checking</a> for {@link LoadBalancer}s.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/5025")
+public final class HealthCheckingLoadBalancerUtil {
+  private HealthCheckingLoadBalancerUtil() {
+  }
+
+  /**
+   * Creates a health-checking-capable LoadBalancer.  This method is used to implement
+   * health-checking-capable {@link io.grpc.LoadBalancer.Factory}s, which will typically written
+   * this way:
+   *
+   * <pre>
+   * public class HealthCheckingFooLbFactory extends LoadBalancer.Factory {
+   *   // This is the original balancer implementation that doesn't have health checking
+   *   private final LoadBalancer.Factory fooLbFactory;
+   *
+   *   ...
+   *
+   *   // Returns the health-checking-capable version of FooLb   
+   *   public LoadBalancer newLoadBalancer(Helper helper) {
+   *     return HealthCheckingLoadBalancerUtil.newHealthCheckingLoadBalancer(fooLbFactory, helper);
+   *   }
+   * }
+   * </pre>
+   *
+   * <p>As a requirement for the original LoadBalancer, it must call
+   * {@code Helper.createSubchannel()} from the {@link Helper#getSynchronizationContext()
+   * Synchronization Context}, or {@code createSubchannel()} will throw.
+   *
+   * @param factory the original factory that implements load-balancing logic without health
+   *        checking
+   * @param helper the helper passed to the resulting health-checking LoadBalancer.
+   */
+  public static LoadBalancer newHealthCheckingLoadBalancer(
+      LoadBalancer.Factory factory, Helper helper) {
+    HealthCheckingLoadBalancerFactory hcFactory =
+        new HealthCheckingLoadBalancerFactory(
+            factory, new ExponentialBackoffPolicy.Provider(),
+            GrpcUtil.STOPWATCH_SUPPLIER);
+    return hcFactory.newLoadBalancer(helper);
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/HealthServiceImpl.java b/services/src/main/java/io/grpc/protobuf/services/HealthServiceImpl.java
new file mode 100644
index 00000000000..5cd294b4fbe
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/HealthServiceImpl.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright 2016 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.protobuf.services;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.Context;
+import io.grpc.Context.CancellationListener;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.health.v1.HealthCheckRequest;
+import io.grpc.health.v1.HealthCheckResponse;
+import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
+import io.grpc.health.v1.HealthGrpc;
+import io.grpc.stub.ServerCallStreamObserver;
+import io.grpc.stub.StreamObserver;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+final class HealthServiceImpl extends HealthGrpc.HealthImplBase {
+
+  private static final Logger logger = Logger.getLogger(HealthServiceImpl.class.getName());
+
+  // Due to the latency of rpc calls, synchronization of the map does not help with consistency.
+  // However, need use ConcurrentHashMap to allow concurrent reading by check().
+  private final Map<String, ServingStatus> statusMap = new ConcurrentHashMap<>();
+
+  private final Object watchLock = new Object();
+
+  // Indicates if future status changes should be ignored.
+  @GuardedBy("watchLock")
+  private boolean terminal;
+
+  // Technically a Multimap<String, StreamObserver<HealthCheckResponse>>.  The Boolean value is not
+  // used.  The StreamObservers need to be kept in a identity-equality set, to make sure
+  // user-defined equals() doesn't confuse our book-keeping of the StreamObservers.  Constructing
+  // such Multimap would require extra lines and the end result is not significantly simpler, thus I
+  // would rather not have the Guava collections dependency.
+  @GuardedBy("watchLock")
+  private final HashMap<String, IdentityHashMap<StreamObserver<HealthCheckResponse>, Boolean>>
+      watchers = new HashMap<>();
+
+  HealthServiceImpl() {
+    // Copy of what Go and C++ do.
+    statusMap.put(HealthStatusManager.SERVICE_NAME_ALL_SERVICES, ServingStatus.SERVING);
+  }
+
+  @Override
+  public void check(HealthCheckRequest request,
+      StreamObserver<HealthCheckResponse> responseObserver) {
+    ServingStatus status = statusMap.get(request.getService());
+    if (status == null) {
+      responseObserver.onError(new StatusException(
+          Status.NOT_FOUND.withDescription("unknown service " + request.getService())));
+    } else {
+      HealthCheckResponse response = HealthCheckResponse.newBuilder().setStatus(status).build();
+      responseObserver.onNext(response);
+      responseObserver.onCompleted();
+    }
+  }
+
+  @Override
+  public void watch(HealthCheckRequest request,
+      final StreamObserver<HealthCheckResponse> responseObserver) {
+    final String service = request.getService();
+    synchronized (watchLock) {
+      if (responseObserver instanceof ServerCallStreamObserver) {
+        ((ServerCallStreamObserver) responseObserver).setOnCancelHandler(() -> {
+          removeWatcher(service, responseObserver);
+        });
+      }
+      ServingStatus status = statusMap.get(service);
+      responseObserver.onNext(getResponseForWatch(status));
+      IdentityHashMap<StreamObserver<HealthCheckResponse>, Boolean> serviceWatchers =
+          watchers.get(service);
+      if (serviceWatchers == null) {
+        serviceWatchers = new IdentityHashMap<>();
+        watchers.put(service, serviceWatchers);
+      }
+      serviceWatchers.put(responseObserver, Boolean.TRUE);
+    }
+    Context.current().addListener(
+        new CancellationListener() {
+          @Override
+          // Called when the client has closed the stream
+          public void cancelled(Context context) {
+            removeWatcher(service, responseObserver);
+          }
+        },
+        MoreExecutors.directExecutor());
+  }
+
+  void removeWatcher(String service, StreamObserver<HealthCheckResponse> responseObserver) {
+    synchronized (watchLock) {
+      IdentityHashMap<StreamObserver<HealthCheckResponse>, Boolean> serviceWatchers =
+              watchers.get(service);
+      if (serviceWatchers != null) {
+        serviceWatchers.remove(responseObserver);
+        if (serviceWatchers.isEmpty()) {
+          watchers.remove(service);
+        }
+      }
+    }
+  }
+
+  void setStatus(String service, ServingStatus status) {
+    synchronized (watchLock) {
+      if (terminal) {
+        logger.log(Level.FINE, "Ignoring status {} for {}", new Object[]{status, service});
+        return;
+      }
+      setStatusInternal(service, status);
+    }
+  }
+
+  @GuardedBy("watchLock")
+  private void setStatusInternal(String service, ServingStatus status) {
+    ServingStatus prevStatus = statusMap.put(service, status);
+    if (prevStatus != status) {
+      notifyWatchers(service, status);
+    }
+  }
+
+  void clearStatus(String service) {
+    synchronized (watchLock) {
+      if (terminal) {
+        logger.log(Level.FINE, "Ignoring status clearing for {}", new Object[]{service});
+        return;
+      }
+      ServingStatus prevStatus = statusMap.remove(service);
+      if (prevStatus != null) {
+        notifyWatchers(service, null);
+      }
+    }
+  }
+
+  void enterTerminalState() {
+    synchronized (watchLock) {
+      if (terminal) {
+        logger.log(Level.WARNING, "Already terminating", new RuntimeException());
+        return;
+      }
+      terminal = true;
+      for (String service : statusMap.keySet()) {
+        setStatusInternal(service, ServingStatus.NOT_SERVING);
+      }
+    }
+  }
+
+  @VisibleForTesting
+  int numWatchersForTest(String service) {
+    synchronized (watchLock) {
+      IdentityHashMap<StreamObserver<HealthCheckResponse>, Boolean> serviceWatchers =
+          watchers.get(service);
+      if (serviceWatchers == null) {
+        return 0;
+      }
+      return serviceWatchers.size();
+    }
+  }
+
+  @GuardedBy("watchLock")
+  private void notifyWatchers(String service, @Nullable ServingStatus status) {
+    HealthCheckResponse response = getResponseForWatch(status);
+    IdentityHashMap<StreamObserver<HealthCheckResponse>, Boolean> serviceWatchers =
+        watchers.get(service);
+    if (serviceWatchers != null) {
+      for (StreamObserver<HealthCheckResponse> responseObserver : serviceWatchers.keySet()) {
+        responseObserver.onNext(response);
+      }
+    }
+  }
+
+  private static HealthCheckResponse getResponseForWatch(@Nullable ServingStatus recordedStatus) {
+    return HealthCheckResponse.newBuilder().setStatus(
+        recordedStatus == null ? ServingStatus.SERVICE_UNKNOWN : recordedStatus).build();
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/HealthStatusManager.java b/services/src/main/java/io/grpc/protobuf/services/HealthStatusManager.java
new file mode 100644
index 00000000000..56cff68f3aa
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/HealthStatusManager.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2016 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.protobuf.services;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.BindableService;
+import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
+
+/**
+ * A {@code HealthStatusManager} object manages a health check service. A health check service is
+ * created in the constructor of {@code HealthStatusManager}, and it can be retrieved by the
+ * {@link #getHealthService()} method.
+ * The health status manager can update the health statuses of the server.
+ *
+ * <p>The default, empty-string, service name, {@link #SERVICE_NAME_ALL_SERVICES}, is initialized to
+ * {@link ServingStatus#SERVING}.
+ */
+@io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/4696")
+public final class HealthStatusManager {
+  /**
+   * The special "service name" that represent all services on a GRPC server.  It is an empty
+   * string.
+   */
+  public static final String SERVICE_NAME_ALL_SERVICES = "";
+
+  private final HealthServiceImpl healthService;
+
+  /**
+   * Creates a new health service instance.
+   */
+  public HealthStatusManager() {
+    healthService = new HealthServiceImpl();
+  }
+
+  /**
+   * Gets the health check service created in the constructor.
+   */
+  public BindableService getHealthService() {
+    return healthService;
+  }
+
+  /**
+   * Updates the status of the server.
+   * @param service the name of some aspect of the server that is associated with a health status.
+   *     This name can have no relation with the gRPC services that the server is running with.
+   *     It can also be an empty String {@code ""} per the gRPC specification.
+   * @param status is one of the values {@link ServingStatus#SERVING},
+   *     {@link ServingStatus#NOT_SERVING} and {@link ServingStatus#UNKNOWN}.
+   */
+  public void setStatus(String service, ServingStatus status) {
+    checkNotNull(status, "status");
+    healthService.setStatus(service, status);
+  }
+
+  /**
+   * Clears the health status record of a service. The health service will respond with NOT_FOUND
+   * error on checking the status of a cleared service.
+   * @param service the name of some aspect of the server that is associated with a health status.
+   *     This name can have no relation with the gRPC services that the server is running with.
+   *     It can also be an empty String {@code ""} per the gRPC specification.
+   */
+  public void clearStatus(String service) {
+    healthService.clearStatus(service);
+  }
+
+  /**
+   * enterTerminalState causes the health status manager to mark all services as not serving, and
+   * prevents future updates to services.  This method is meant to be called prior to server
+   * shutdown as a way to indicate that clients should redirect their traffic elsewhere.
+   */
+  public void enterTerminalState() {
+    healthService.enterTerminalState();
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/InetAddressUtil.java b/services/src/main/java/io/grpc/protobuf/services/InetAddressUtil.java
new file mode 100644
index 00000000000..b8bacbc2bb3
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/InetAddressUtil.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2018 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.protobuf.services;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.primitives.Ints;
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.util.Arrays;
+
+// This is copied from guava 20.0 because it is a @Beta api
+final class InetAddressUtil {
+  private static final int IPV6_PART_COUNT = 8;
+
+  public static String toAddrString(InetAddress ip) {
+    checkNotNull(ip);
+    if (ip instanceof Inet4Address) {
+      // For IPv4, Java's formatting is good enough.
+      return ip.getHostAddress();
+    }
+    checkArgument(ip instanceof Inet6Address);
+    byte[] bytes = ip.getAddress();
+    int[] hextets = new int[IPV6_PART_COUNT];
+    for (int i = 0; i < hextets.length; i++) {
+      hextets[i] = Ints.fromBytes((byte) 0, (byte) 0, bytes[2 * i], bytes[2 * i + 1]);
+    }
+    compressLongestRunOfZeroes(hextets);
+    return hextetsToIPv6String(hextets);
+  }
+
+  private static void compressLongestRunOfZeroes(int[] hextets) {
+    int bestRunStart = -1;
+    int bestRunLength = -1;
+    int runStart = -1;
+    for (int i = 0; i < hextets.length + 1; i++) {
+      if (i < hextets.length && hextets[i] == 0) {
+        if (runStart < 0) {
+          runStart = i;
+        }
+      } else if (runStart >= 0) {
+        int runLength = i - runStart;
+        if (runLength > bestRunLength) {
+          bestRunStart = runStart;
+          bestRunLength = runLength;
+        }
+        runStart = -1;
+      }
+    }
+    if (bestRunLength >= 2) {
+      Arrays.fill(hextets, bestRunStart, bestRunStart + bestRunLength, -1);
+    }
+  }
+
+  private static String hextetsToIPv6String(int[] hextets) {
+    // While scanning the array, handle these state transitions:
+    //   start->num => "num"     start->gap => "::"
+    //   num->num   => ":num"    num->gap   => "::"
+    //   gap->num   => "num"     gap->gap   => ""
+    StringBuilder buf = new StringBuilder(39);
+    boolean lastWasNumber = false;
+    for (int i = 0; i < hextets.length; i++) {
+      boolean thisIsNumber = hextets[i] >= 0;
+      if (thisIsNumber) {
+        if (lastWasNumber) {
+          buf.append(':');
+        }
+        buf.append(Integer.toHexString(hextets[i]));
+      } else {
+        if (i == 0 || lastWasNumber) {
+          buf.append("::");
+        }
+      }
+      lastWasNumber = thisIsNumber;
+    }
+    return buf.toString();
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/ProtoReflectionService.java b/services/src/main/java/io/grpc/protobuf/services/ProtoReflectionService.java
new file mode 100644
index 00000000000..07008b682c3
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/ProtoReflectionService.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2016 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.protobuf.services;
+
+import io.grpc.BindableService;
+import io.grpc.ExperimentalApi;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.ServiceDescriptor;
+import io.grpc.reflection.v1.ServerReflectionGrpc;
+import io.grpc.reflection.v1.ServerReflectionRequest;
+import io.grpc.reflection.v1.ServerReflectionResponse;
+
+/**
+ * Provides a reflection service for Protobuf services (including the reflection service itself).
+ *
+ * <p>Separately tracks mutable and immutable services. Throws an exception if either group of
+ * services contains multiple Protobuf files with declarations of the same service, method, type, or
+ * extension.
+ * Uses the deprecated v1alpha proto. New users should use {@link ProtoReflectionServiceV1} instead.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
+public final class ProtoReflectionService implements BindableService {
+
+  private ProtoReflectionService() {
+  }
+
+  @Deprecated
+  public static BindableService newInstance() {
+    return new ProtoReflectionService();
+  }
+
+  @Override
+  @SuppressWarnings("deprecation")
+  public ServerServiceDefinition bindService() {
+    ServerServiceDefinition serverServiceDefinitionV1 = ProtoReflectionServiceV1.newInstance()
+        .bindService();
+    MethodDescriptor<ServerReflectionRequest, ServerReflectionResponse> methodDescriptorV1 =
+        ServerReflectionGrpc.getServerReflectionInfoMethod();
+    // Retain the v1 proto marshallers but change the method name and schema descriptor to v1alpha.
+    MethodDescriptor<io.grpc.reflection.v1alpha.ServerReflectionRequest,
+        io.grpc.reflection.v1alpha.ServerReflectionResponse> methodDescriptorV1AlphaGenerated =
+        io.grpc.reflection.v1alpha.ServerReflectionGrpc.getServerReflectionInfoMethod();
+    MethodDescriptor<ServerReflectionRequest, ServerReflectionResponse> methodDescriptorV1Alpha =
+        methodDescriptorV1.toBuilder()
+            .setFullMethodName(methodDescriptorV1AlphaGenerated.getFullMethodName())
+            .setSchemaDescriptor(methodDescriptorV1AlphaGenerated.getSchemaDescriptor())
+            .build();
+    // Retain the v1 server call handler but change the service name schema descriptor in the
+    // service descriptor to v1alpha.
+    ServiceDescriptor serviceDescriptorV1AlphaGenerated =
+        io.grpc.reflection.v1alpha.ServerReflectionGrpc.getServiceDescriptor();
+    ServiceDescriptor serviceDescriptorV1Alpha =
+        ServiceDescriptor.newBuilder(serviceDescriptorV1AlphaGenerated.getName())
+            .setSchemaDescriptor(serviceDescriptorV1AlphaGenerated.getSchemaDescriptor())
+            .addMethod(methodDescriptorV1Alpha)
+            .build();
+    return ServerServiceDefinition.builder(serviceDescriptorV1Alpha)
+        .addMethod(methodDescriptorV1Alpha, createServerCallHandler(serverServiceDefinitionV1))
+        .build();
+  }
+
+  @SuppressWarnings("unchecked")
+  private ServerCallHandler<ServerReflectionRequest, ServerReflectionResponse>
+      createServerCallHandler(
+      ServerServiceDefinition serverServiceDefinition) {
+    return (ServerCallHandler<ServerReflectionRequest, ServerReflectionResponse>)
+        serverServiceDefinition.getMethod(
+            ServerReflectionGrpc.getServerReflectionInfoMethod().getFullMethodName())
+        .getServerCallHandler();
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/ProtoReflectionServiceV1.java b/services/src/main/java/io/grpc/protobuf/services/ProtoReflectionServiceV1.java
new file mode 100644
index 00000000000..59e9c33d279
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/ProtoReflectionServiceV1.java
@@ -0,0 +1,539 @@
+/*
+ * Copyright 2016 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.protobuf.services;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import com.google.protobuf.Descriptors.Descriptor;
+import com.google.protobuf.Descriptors.FieldDescriptor;
+import com.google.protobuf.Descriptors.FileDescriptor;
+import com.google.protobuf.Descriptors.MethodDescriptor;
+import com.google.protobuf.Descriptors.ServiceDescriptor;
+import io.grpc.BindableService;
+import io.grpc.ExperimentalApi;
+import io.grpc.InternalServer;
+import io.grpc.Server;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.protobuf.ProtoFileDescriptorSupplier;
+import io.grpc.reflection.v1.ErrorResponse;
+import io.grpc.reflection.v1.ExtensionNumberResponse;
+import io.grpc.reflection.v1.ExtensionRequest;
+import io.grpc.reflection.v1.FileDescriptorResponse;
+import io.grpc.reflection.v1.ListServiceResponse;
+import io.grpc.reflection.v1.ServerReflectionGrpc;
+import io.grpc.reflection.v1.ServerReflectionRequest;
+import io.grpc.reflection.v1.ServerReflectionResponse;
+import io.grpc.reflection.v1.ServiceResponse;
+import io.grpc.stub.ServerCallStreamObserver;
+import io.grpc.stub.StreamObserver;
+import java.util.ArrayDeque;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+import java.util.WeakHashMap;
+import javax.annotation.Nullable;
+
+/**
+ * Provides a reflection service for Protobuf services (including the reflection service itself).
+ *
+ * <p>Separately tracks mutable and immutable services. Throws an exception if either group of
+ * services contains multiple Protobuf files with declarations of the same service, method, type, or
+ * extension.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
+public final class ProtoReflectionServiceV1 extends ServerReflectionGrpc.ServerReflectionImplBase {
+
+  private final Object lock = new Object();
+
+  @GuardedBy("lock")
+  private final Map<Server, ServerReflectionIndex> serverReflectionIndexes = new WeakHashMap<>();
+
+  private ProtoReflectionServiceV1() {}
+
+  /**
+   * Creates a instance of {@link ProtoReflectionServiceV1}.
+   */
+  public static BindableService newInstance() {
+    return new ProtoReflectionServiceV1();
+  }
+
+  /**
+   * Retrieves the index for services of the server that dispatches the current call. Computes
+   * one if not exist. The index is updated if any changes to the server's mutable services are
+   * detected. A change is any addition or removal in the set of file descriptors attached to the
+   * mutable services or a change in the service names.
+   */
+  private ServerReflectionIndex getRefreshedIndex() {
+    synchronized (lock) {
+      Server server = InternalServer.SERVER_CONTEXT_KEY.get();
+      ServerReflectionIndex index = serverReflectionIndexes.get(server);
+      if (index == null) {
+        index =
+            new ServerReflectionIndex(server.getImmutableServices(), server.getMutableServices());
+        serverReflectionIndexes.put(server, index);
+        return index;
+      }
+
+      Set<FileDescriptor> serverFileDescriptors = new HashSet<>();
+      Set<String> serverServiceNames = new HashSet<>();
+      List<ServerServiceDefinition> serverMutableServices = server.getMutableServices();
+      for (ServerServiceDefinition mutableService : serverMutableServices) {
+        io.grpc.ServiceDescriptor serviceDescriptor = mutableService.getServiceDescriptor();
+        if (serviceDescriptor.getSchemaDescriptor() instanceof ProtoFileDescriptorSupplier) {
+          String serviceName = serviceDescriptor.getName();
+          FileDescriptor fileDescriptor =
+              ((ProtoFileDescriptorSupplier) serviceDescriptor.getSchemaDescriptor())
+                  .getFileDescriptor();
+          serverFileDescriptors.add(fileDescriptor);
+          serverServiceNames.add(serviceName);
+        }
+      }
+
+      // Replace the index if the underlying mutable services have changed. Check both the file
+      // descriptors and the service names, because one file descriptor can define multiple
+      // services.
+      FileDescriptorIndex mutableServicesIndex = index.getMutableServicesIndex();
+      if (!mutableServicesIndex.getServiceFileDescriptors().equals(serverFileDescriptors)
+          || !mutableServicesIndex.getServiceNames().equals(serverServiceNames)) {
+        index =
+            new ServerReflectionIndex(server.getImmutableServices(), serverMutableServices);
+        serverReflectionIndexes.put(server, index);
+      }
+
+      return index;
+    }
+  }
+
+  @Override
+  public StreamObserver<ServerReflectionRequest> serverReflectionInfo(
+      final StreamObserver<ServerReflectionResponse> responseObserver) {
+    final ServerCallStreamObserver<ServerReflectionResponse> serverCallStreamObserver =
+        (ServerCallStreamObserver<ServerReflectionResponse>) responseObserver;
+    ProtoReflectionStreamObserver requestObserver =
+        new ProtoReflectionStreamObserver(getRefreshedIndex(), serverCallStreamObserver);
+    serverCallStreamObserver.setOnReadyHandler(requestObserver);
+    serverCallStreamObserver.disableAutoRequest();
+    serverCallStreamObserver.request(1);
+    return requestObserver;
+  }
+
+  private static class ProtoReflectionStreamObserver
+      implements Runnable, StreamObserver<ServerReflectionRequest> {
+    private final ServerReflectionIndex serverReflectionIndex;
+    private final ServerCallStreamObserver<ServerReflectionResponse> serverCallStreamObserver;
+
+    private boolean closeAfterSend = false;
+    private ServerReflectionRequest request;
+
+    ProtoReflectionStreamObserver(
+        ServerReflectionIndex serverReflectionIndex,
+        ServerCallStreamObserver<ServerReflectionResponse> serverCallStreamObserver) {
+      this.serverReflectionIndex = serverReflectionIndex;
+      this.serverCallStreamObserver = checkNotNull(serverCallStreamObserver, "observer");
+    }
+
+    @Override
+    public void run() {
+      if (request != null) {
+        handleReflectionRequest();
+      }
+    }
+
+    @Override
+    public void onNext(ServerReflectionRequest request) {
+      checkState(this.request == null);
+      this.request = checkNotNull(request);
+      handleReflectionRequest();
+    }
+
+    private void handleReflectionRequest() {
+      if (serverCallStreamObserver.isReady()) {
+        switch (request.getMessageRequestCase()) {
+          case FILE_BY_FILENAME:
+            getFileByName(request);
+            break;
+          case FILE_CONTAINING_SYMBOL:
+            getFileContainingSymbol(request);
+            break;
+          case FILE_CONTAINING_EXTENSION:
+            getFileByExtension(request);
+            break;
+          case ALL_EXTENSION_NUMBERS_OF_TYPE:
+            getAllExtensions(request);
+            break;
+          case LIST_SERVICES:
+            listServices(request);
+            break;
+          default:
+            sendErrorResponse(
+                request,
+                Status.Code.UNIMPLEMENTED,
+                "not implemented " + request.getMessageRequestCase());
+        }
+        request = null;
+        if (closeAfterSend) {
+          serverCallStreamObserver.onCompleted();
+        } else {
+          serverCallStreamObserver.request(1);
+        }
+      }
+    }
+
+    @Override
+    public void onCompleted() {
+      if (request != null) {
+        closeAfterSend = true;
+      } else {
+        serverCallStreamObserver.onCompleted();
+      }
+    }
+
+    @Override
+    public void onError(Throwable cause) {
+      serverCallStreamObserver.onError(cause);
+    }
+
+    private void getFileByName(ServerReflectionRequest request) {
+      String name = request.getFileByFilename();
+      FileDescriptor fd = serverReflectionIndex.getFileDescriptorByName(name);
+      if (fd != null) {
+        serverCallStreamObserver.onNext(createServerReflectionResponse(request, fd));
+      } else {
+        sendErrorResponse(request, Status.Code.NOT_FOUND, "File not found.");
+      }
+    }
+
+    private void getFileContainingSymbol(ServerReflectionRequest request) {
+      String symbol = request.getFileContainingSymbol();
+      FileDescriptor fd = serverReflectionIndex.getFileDescriptorBySymbol(symbol);
+      if (fd != null) {
+        serverCallStreamObserver.onNext(createServerReflectionResponse(request, fd));
+      } else {
+        sendErrorResponse(request, Status.Code.NOT_FOUND, "Symbol not found.");
+      }
+    }
+
+    private void getFileByExtension(ServerReflectionRequest request) {
+      ExtensionRequest extensionRequest = request.getFileContainingExtension();
+      String type = extensionRequest.getContainingType();
+      int extension = extensionRequest.getExtensionNumber();
+      FileDescriptor fd =
+          serverReflectionIndex.getFileDescriptorByExtensionAndNumber(type, extension);
+      if (fd != null) {
+        serverCallStreamObserver.onNext(createServerReflectionResponse(request, fd));
+      } else {
+        sendErrorResponse(request, Status.Code.NOT_FOUND, "Extension not found.");
+      }
+    }
+
+    private void getAllExtensions(ServerReflectionRequest request) {
+      String type = request.getAllExtensionNumbersOfType();
+      Set<Integer> extensions = serverReflectionIndex.getExtensionNumbersOfType(type);
+      if (extensions != null) {
+        ExtensionNumberResponse.Builder builder =
+            ExtensionNumberResponse.newBuilder()
+                .setBaseTypeName(type)
+                .addAllExtensionNumber(extensions);
+        serverCallStreamObserver.onNext(
+            ServerReflectionResponse.newBuilder()
+                .setValidHost(request.getHost())
+                .setOriginalRequest(request)
+                .setAllExtensionNumbersResponse(builder)
+                .build());
+      } else {
+        sendErrorResponse(request, Status.Code.NOT_FOUND, "Type not found.");
+      }
+    }
+
+    private void listServices(ServerReflectionRequest request) {
+      ListServiceResponse.Builder builder = ListServiceResponse.newBuilder();
+      for (String serviceName : serverReflectionIndex.getServiceNames()) {
+        builder.addService(ServiceResponse.newBuilder().setName(serviceName));
+      }
+      serverCallStreamObserver.onNext(
+          ServerReflectionResponse.newBuilder()
+              .setValidHost(request.getHost())
+              .setOriginalRequest(request)
+              .setListServicesResponse(builder)
+              .build());
+    }
+
+    private void sendErrorResponse(
+        ServerReflectionRequest request, Status.Code code, String message) {
+      ServerReflectionResponse response =
+          ServerReflectionResponse.newBuilder()
+              .setValidHost(request.getHost())
+              .setOriginalRequest(request)
+              .setErrorResponse(
+                  ErrorResponse.newBuilder()
+                      .setErrorCode(code.value())
+                      .setErrorMessage(message))
+              .build();
+      serverCallStreamObserver.onNext(response);
+    }
+
+    private ServerReflectionResponse createServerReflectionResponse(
+        ServerReflectionRequest request, FileDescriptor fd) {
+      FileDescriptorResponse.Builder fdRBuilder = FileDescriptorResponse.newBuilder();
+
+      Set<String> seenFiles = new HashSet<>();
+      Queue<FileDescriptor> frontier = new ArrayDeque<>();
+      seenFiles.add(fd.getName());
+      frontier.add(fd);
+      while (!frontier.isEmpty()) {
+        FileDescriptor nextFd = frontier.remove();
+        fdRBuilder.addFileDescriptorProto(nextFd.toProto().toByteString());
+        for (FileDescriptor dependencyFd : nextFd.getDependencies()) {
+          if (!seenFiles.contains(dependencyFd.getName())) {
+            seenFiles.add(dependencyFd.getName());
+            frontier.add(dependencyFd);
+          }
+        }
+      }
+      return ServerReflectionResponse.newBuilder()
+          .setValidHost(request.getHost())
+          .setOriginalRequest(request)
+          .setFileDescriptorResponse(fdRBuilder)
+          .build();
+    }
+  }
+
+  /**
+   * Indexes the server's services and allows lookups of file descriptors by filename, symbol, type,
+   * and extension number.
+   *
+   * <p>Internally, this stores separate indices for the immutable and mutable services. When
+   * queried, the immutable service index is checked for a matching value. Only if there is no match
+   * in the immutable service index are the mutable services checked.
+   */
+  private static final class ServerReflectionIndex {
+    private final FileDescriptorIndex immutableServicesIndex;
+    private final FileDescriptorIndex mutableServicesIndex;
+
+    public ServerReflectionIndex(
+        List<ServerServiceDefinition> immutableServices,
+        List<ServerServiceDefinition> mutableServices) {
+      immutableServicesIndex = new FileDescriptorIndex(immutableServices);
+      mutableServicesIndex = new FileDescriptorIndex(mutableServices);
+    }
+
+    private FileDescriptorIndex getMutableServicesIndex() {
+      return mutableServicesIndex;
+    }
+
+    private Set<String> getServiceNames() {
+      Set<String> immutableServiceNames = immutableServicesIndex.getServiceNames();
+      Set<String> mutableServiceNames = mutableServicesIndex.getServiceNames();
+      Set<String> serviceNames =
+          new HashSet<>(immutableServiceNames.size() + mutableServiceNames.size());
+      serviceNames.addAll(immutableServiceNames);
+      serviceNames.addAll(mutableServiceNames);
+      return serviceNames;
+    }
+
+    @Nullable
+    private FileDescriptor getFileDescriptorByName(String name) {
+      FileDescriptor fd = immutableServicesIndex.getFileDescriptorByName(name);
+      if (fd == null) {
+        fd = mutableServicesIndex.getFileDescriptorByName(name);
+      }
+      return fd;
+    }
+
+    @Nullable
+    private FileDescriptor getFileDescriptorBySymbol(String symbol) {
+      FileDescriptor fd = immutableServicesIndex.getFileDescriptorBySymbol(symbol);
+      if (fd == null) {
+        fd = mutableServicesIndex.getFileDescriptorBySymbol(symbol);
+      }
+      return fd;
+    }
+
+    @Nullable
+    private FileDescriptor getFileDescriptorByExtensionAndNumber(String type, int extension) {
+      FileDescriptor fd =
+          immutableServicesIndex.getFileDescriptorByExtensionAndNumber(type, extension);
+      if (fd == null) {
+        fd = mutableServicesIndex.getFileDescriptorByExtensionAndNumber(type, extension);
+      }
+      return fd;
+    }
+
+    @Nullable
+    private Set<Integer> getExtensionNumbersOfType(String type) {
+      Set<Integer> extensionNumbers = immutableServicesIndex.getExtensionNumbersOfType(type);
+      if (extensionNumbers == null) {
+        extensionNumbers = mutableServicesIndex.getExtensionNumbersOfType(type);
+      }
+      return extensionNumbers;
+    }
+  }
+
+  /**
+   * Provides a set of methods for answering reflection queries for the file descriptors underlying
+   * a set of services. Used by {@link ServerReflectionIndex} to separately index immutable and
+   * mutable services.
+   */
+  private static final class FileDescriptorIndex {
+    private final Set<String> serviceNames = new HashSet<>();
+    private final Set<FileDescriptor> serviceFileDescriptors = new HashSet<>();
+    private final Map<String, FileDescriptor> fileDescriptorsByName =
+        new HashMap<>();
+    private final Map<String, FileDescriptor> fileDescriptorsBySymbol =
+        new HashMap<>();
+    private final Map<String, Map<Integer, FileDescriptor>> fileDescriptorsByExtensionAndNumber =
+        new HashMap<>();
+
+    FileDescriptorIndex(List<ServerServiceDefinition> services) {
+      Queue<FileDescriptor> fileDescriptorsToProcess = new ArrayDeque<>();
+      Set<String> seenFiles = new HashSet<>();
+      for (ServerServiceDefinition service : services) {
+        io.grpc.ServiceDescriptor serviceDescriptor = service.getServiceDescriptor();
+        if (serviceDescriptor.getSchemaDescriptor() instanceof ProtoFileDescriptorSupplier) {
+          FileDescriptor fileDescriptor =
+              ((ProtoFileDescriptorSupplier) serviceDescriptor.getSchemaDescriptor())
+                  .getFileDescriptor();
+          String serviceName = serviceDescriptor.getName();
+          checkState(
+              !serviceNames.contains(serviceName), "Service already defined: %s", serviceName);
+          serviceFileDescriptors.add(fileDescriptor);
+          serviceNames.add(serviceName);
+          if (!seenFiles.contains(fileDescriptor.getName())) {
+            seenFiles.add(fileDescriptor.getName());
+            fileDescriptorsToProcess.add(fileDescriptor);
+          }
+        }
+      }
+
+      while (!fileDescriptorsToProcess.isEmpty()) {
+        FileDescriptor currentFd = fileDescriptorsToProcess.remove();
+        processFileDescriptor(currentFd);
+        for (FileDescriptor dependencyFd : currentFd.getDependencies()) {
+          if (!seenFiles.contains(dependencyFd.getName())) {
+            seenFiles.add(dependencyFd.getName());
+            fileDescriptorsToProcess.add(dependencyFd);
+          }
+        }
+      }
+    }
+
+    /**
+     * Returns the file descriptors for the indexed services, but not their dependencies. This is
+     * used to check if the server's mutable services have changed.
+     */
+    private Set<FileDescriptor> getServiceFileDescriptors() {
+      return Collections.unmodifiableSet(serviceFileDescriptors);
+    }
+
+    private Set<String> getServiceNames() {
+      return Collections.unmodifiableSet(serviceNames);
+    }
+
+    @Nullable
+    private FileDescriptor getFileDescriptorByName(String name) {
+      return fileDescriptorsByName.get(name);
+    }
+
+    @Nullable
+    private FileDescriptor getFileDescriptorBySymbol(String symbol) {
+      return fileDescriptorsBySymbol.get(symbol);
+    }
+
+    @Nullable
+    private FileDescriptor getFileDescriptorByExtensionAndNumber(String type, int number) {
+      if (fileDescriptorsByExtensionAndNumber.containsKey(type)) {
+        return fileDescriptorsByExtensionAndNumber.get(type).get(number);
+      }
+      return null;
+    }
+
+    @Nullable
+    private Set<Integer> getExtensionNumbersOfType(String type) {
+      if (fileDescriptorsByExtensionAndNumber.containsKey(type)) {
+        return Collections.unmodifiableSet(fileDescriptorsByExtensionAndNumber.get(type).keySet());
+      }
+      return null;
+    }
+
+    private void processFileDescriptor(FileDescriptor fd) {
+      String fdName = fd.getName();
+      checkState(!fileDescriptorsByName.containsKey(fdName), "File name already used: %s", fdName);
+      fileDescriptorsByName.put(fdName, fd);
+      for (ServiceDescriptor service : fd.getServices()) {
+        processService(service, fd);
+      }
+      for (Descriptor type : fd.getMessageTypes()) {
+        processType(type, fd);
+      }
+      for (FieldDescriptor extension : fd.getExtensions()) {
+        processExtension(extension, fd);
+      }
+    }
+
+    private void processService(ServiceDescriptor service, FileDescriptor fd) {
+      String serviceName = service.getFullName();
+      checkState(
+          !fileDescriptorsBySymbol.containsKey(serviceName),
+          "Service already defined: %s",
+          serviceName);
+      fileDescriptorsBySymbol.put(serviceName, fd);
+      for (MethodDescriptor method : service.getMethods()) {
+        String methodName = method.getFullName();
+        checkState(
+            !fileDescriptorsBySymbol.containsKey(methodName),
+            "Method already defined: %s",
+            methodName);
+        fileDescriptorsBySymbol.put(methodName, fd);
+      }
+    }
+
+    private void processType(Descriptor type, FileDescriptor fd) {
+      String typeName = type.getFullName();
+      checkState(
+          !fileDescriptorsBySymbol.containsKey(typeName), "Type already defined: %s", typeName);
+      fileDescriptorsBySymbol.put(typeName, fd);
+      for (FieldDescriptor extension : type.getExtensions()) {
+        processExtension(extension, fd);
+      }
+      for (Descriptor nestedType : type.getNestedTypes()) {
+        processType(nestedType, fd);
+      }
+    }
+
+    private void processExtension(FieldDescriptor extension, FileDescriptor fd) {
+      String extensionName = extension.getContainingType().getFullName();
+      int extensionNumber = extension.getNumber();
+      if (!fileDescriptorsByExtensionAndNumber.containsKey(extensionName)) {
+        fileDescriptorsByExtensionAndNumber.put(
+            extensionName, new HashMap<Integer, FileDescriptor>());
+      }
+      checkState(
+          !fileDescriptorsByExtensionAndNumber.get(extensionName).containsKey(extensionNumber),
+          "Extension name and number already defined: %s, %s",
+          extensionName,
+          extensionNumber);
+      fileDescriptorsByExtensionAndNumber.get(extensionName).put(extensionNumber, fd);
+    }
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/TempFileSink.java b/services/src/main/java/io/grpc/protobuf/services/TempFileSink.java
new file mode 100644
index 00000000000..0ab91f54329
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/TempFileSink.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2018, gRPC Authors All rights reserved.
+ *
+ * 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.protobuf.services;
+
+import com.google.protobuf.MessageLite;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * The output file goes to the JVM's temp dir with a prefix of BINARY_INFO. The proto messages
+ * are written serially using {@link MessageLite#writeDelimitedTo(OutputStream)}.
+ */
+class TempFileSink implements BinaryLogSink {
+  private static final Logger logger = Logger.getLogger(TempFileSink.class.getName());
+
+  private final String outPath;
+  private final OutputStream out;
+  private boolean closed;
+
+  TempFileSink() throws IOException {
+    File outFile = File.createTempFile("BINARY_INFO.", "");
+    outPath = outFile.getPath();
+    logger.log(Level.INFO, "Writing binary logs to to {0}", outFile.getAbsolutePath());
+    out = new BufferedOutputStream(new FileOutputStream(outFile));
+  }
+
+  String getPath() {
+    return this.outPath;
+  }
+
+  @Override
+  public synchronized void write(MessageLite message) {
+    if (closed) {
+      logger.log(Level.FINEST, "Attempt to write after TempFileSink is closed.");
+      return;
+    }
+    try {
+      message.writeDelimitedTo(out);
+    } catch (IOException e) {
+      logger.log(Level.SEVERE, "Caught exception while writing", e);
+      closeQuietly();
+    }
+  }
+
+  @Override
+  public synchronized void close() throws IOException {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    try {
+      out.flush();
+    } finally {
+      out.close();
+    }
+  }
+
+  private synchronized void closeQuietly() {
+    try {
+      close();
+    } catch (IOException e) {
+      logger.log(Level.SEVERE, "Caught exception while closing", e);
+    }
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/internal/HealthCheckingRoundRobinLoadBalancerProvider.java b/services/src/main/java/io/grpc/protobuf/services/internal/HealthCheckingRoundRobinLoadBalancerProvider.java
new file mode 100644
index 00000000000..68d67dbeb28
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/internal/HealthCheckingRoundRobinLoadBalancerProvider.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2018 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.protobuf.services.internal;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Throwables;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.protobuf.services.HealthCheckingLoadBalancerUtil;
+import java.util.Map;
+
+/**
+ * The health-check-capable provider for the "round_robin" balancing policy.  This overrides
+ * the "round_robin" provided by grpc-core.
+ */
+@Internal
+public final class HealthCheckingRoundRobinLoadBalancerProvider extends LoadBalancerProvider {
+  private final LoadBalancerProvider rrProvider;
+
+  public HealthCheckingRoundRobinLoadBalancerProvider() {
+    rrProvider = newRoundRobinProvider();
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return rrProvider.isAvailable();
+  }
+
+  @Override
+  public int getPriority() {
+    return rrProvider.getPriority() + 1;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return rrProvider.getPolicyName();
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    return HealthCheckingLoadBalancerUtil.newHealthCheckingLoadBalancer(rrProvider, helper);
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(
+      Map<String, ?> rawLoadBalancingPolicyConfig) {
+    return rrProvider.parseLoadBalancingPolicyConfig(rawLoadBalancingPolicyConfig);
+  }
+
+  @VisibleForTesting
+  static LoadBalancerProvider newRoundRobinProvider() {
+    try {
+      Class<? extends LoadBalancerProvider> rrProviderClass =
+          Class.forName("io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider")
+              .asSubclass(LoadBalancerProvider.class);
+      return rrProviderClass.getDeclaredConstructor().newInstance();
+    } catch (Exception e) {
+      Throwables.throwIfUnchecked(e);
+      throw new RuntimeException(e);
+    }
+  }
+}
diff --git a/services/src/main/java/io/grpc/protobuf/services/package-info.java b/services/src/main/java/io/grpc/protobuf/services/package-info.java
new file mode 100644
index 00000000000..6fb88cc4756
--- /dev/null
+++ b/services/src/main/java/io/grpc/protobuf/services/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * 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.
+ */
+
+/**
+ * Service definitions and utilities with protobuf dependency for the pre-defined gRPC services.
+ */
+package io.grpc.protobuf.services;
diff --git a/services/src/main/java/io/grpc/services/AdminInterface.java b/services/src/main/java/io/grpc/services/AdminInterface.java
new file mode 100644
index 00000000000..2288d844fd1
--- /dev/null
+++ b/services/src/main/java/io/grpc/services/AdminInterface.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2021 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.services;
+
+import io.grpc.BindableService;
+import io.grpc.ExperimentalApi;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.protobuf.services.ChannelzService;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Admin Interface provides a class of services for exposing the overall state of gRPC
+ * activity in a given binary. It aims to be a convenient API that provides available admin
+ * services.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7929")
+@ThreadSafe
+public final class AdminInterface {
+  private static final int DEFAULT_CHANNELZ_MAX_PAGE_SIZE = 100;
+  private static final Logger logger = Logger.getLogger(AdminInterface.class.getName());
+
+  // Do not instantiate.
+  private AdminInterface() {}
+
+  /**
+   * Returns a list of gRPC's built-in admin services.
+   *
+   * @return list of standard admin services
+   */
+  public static List<ServerServiceDefinition> getStandardServices() {
+    List<ServerServiceDefinition> services = new ArrayList<>();
+    services.add(ChannelzService.newInstance(DEFAULT_CHANNELZ_MAX_PAGE_SIZE).bindService());
+    BindableService csds = null;
+    try {
+      Class<?> clazz = Class.forName("io.grpc.xds.CsdsService");
+      Method m = clazz.getMethod("newInstance");
+      csds = (BindableService) m.invoke(null);
+    } catch (ClassNotFoundException e) {
+      logger.log(Level.FINE, "Unable to find CSDS service", e);
+    } catch (NoSuchMethodException e) {
+      logger.log(Level.FINE, "Unable to load CSDS service", e);
+    } catch (IllegalAccessException e) {
+      logger.log(Level.FINE, "Unable to load CSDS service", e);
+    } catch (InvocationTargetException e) {
+      logger.log(Level.FINE, "Unable to load CSDS service", e);
+    }
+    if (csds != null) {
+      services.add(csds.bindService());
+    }
+    return Collections.unmodifiableList(services);
+  }
+}
diff --git a/services/src/main/java/io/grpc/services/CallMetricRecorder.java b/services/src/main/java/io/grpc/services/CallMetricRecorder.java
new file mode 100644
index 00000000000..d480f0f4c3b
--- /dev/null
+++ b/services/src/main/java/io/grpc/services/CallMetricRecorder.java
@@ -0,0 +1,287 @@
+/*
+ * Copyright 2019 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.services;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.errorprone.annotations.InlineMe;
+import io.grpc.Context;
+import io.grpc.ExperimentalApi;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Utility to record call metrics for load-balancing. One instance per call.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/6012")
+@ThreadSafe
+public final class CallMetricRecorder {
+  private static final CallMetricRecorder NOOP = new CallMetricRecorder().disable();
+
+  static final Context.Key<CallMetricRecorder> CONTEXT_KEY =
+      Context.key("io.grpc.services.CallMetricRecorder");
+
+  private final AtomicReference<ConcurrentHashMap<String, Double>> utilizationMetrics =
+      new AtomicReference<>();
+  private final AtomicReference<ConcurrentHashMap<String, Double>> requestCostMetrics =
+      new AtomicReference<>();
+  private final AtomicReference<ConcurrentHashMap<String, Double>> namedMetrics =
+      new AtomicReference<>();
+  private double cpuUtilizationMetric = 0;
+  private double applicationUtilizationMetric = 0;
+  private double memoryUtilizationMetric = 0;
+  private double qps = 0;
+  private double eps = 0;
+  private volatile boolean disabled;
+
+  /**
+   * Returns the call metric recorder attached to the current {@link Context}.  If there is none,
+   * returns a no-op recorder.
+   *
+   * <p><strong>IMPORTANT:</strong>It returns the recorder specifically for the current RPC call.
+   * <b>DO NOT</b> save the returned object or share it between different RPC calls.
+   *
+   * <p><strong>IMPORTANT:</strong>It must be called under the {@link Context} under which the RPC
+   * handler was called.  If it is called from a different thread, the Context must be propagated to
+   * the same thread, e.g., with {@link Context#wrap(Runnable)}.
+   *
+   * @since 1.23.0
+   */
+  public static CallMetricRecorder getCurrent() {
+    CallMetricRecorder recorder = CONTEXT_KEY.get();
+    return recorder != null ? recorder : NOOP;
+  }
+
+  /**
+   * Records a call metric measurement for utilization in the range [0, 1]. Values outside the valid
+   * range are ignored. If RPC has already finished, this method is no-op.
+   *
+   * <p>A latter record will overwrite its former name-sakes.
+   *
+   * @return this recorder object
+   * @since 1.23.0
+   */
+  public CallMetricRecorder recordUtilizationMetric(String name, double value) {
+    if (disabled || !MetricRecorderHelper.isUtilizationValid(value)) {
+      return this;
+    }
+    if (utilizationMetrics.get() == null) {
+      // The chance of race of creation of the map should be very small, so it should be fine
+      // to create these maps that might be discarded.
+      utilizationMetrics.compareAndSet(null, new ConcurrentHashMap<String, Double>());
+    }
+    utilizationMetrics.get().put(name, value);
+    return this;
+  }
+
+  /**
+   * Records a call metric measurement for request cost.
+   * If RPC has already finished, this method is no-op.
+   *
+   * <p>A latter record will overwrite its former name-sakes.
+   *
+   * @return this recorder object
+   * @since 1.47.0
+   * @deprecated use {@link #recordRequestCostMetric} instead.
+   *     This method will be removed in the future.
+   */
+  @Deprecated
+  @InlineMe(replacement = "this.recordRequestCostMetric(name, value)")
+  public CallMetricRecorder recordCallMetric(String name, double value) {
+    return recordRequestCostMetric(name, value);
+  }
+
+  /**
+   * Records a call metric measurement for request cost.
+   * If RPC has already finished, this method is no-op.
+   *
+   * <p>A latter record will overwrite its former name-sakes.
+   *
+   * @return this recorder object
+   * @since 1.48.1
+   */
+  public CallMetricRecorder recordRequestCostMetric(String name, double value) {
+    if (disabled) {
+      return this;
+    }
+    if (requestCostMetrics.get() == null) {
+      // The chance of race of creation of the map should be very small, so it should be fine
+      // to create these maps that might be discarded.
+      requestCostMetrics.compareAndSet(null, new ConcurrentHashMap<String, Double>());
+    }
+    requestCostMetrics.get().put(name, value);
+    return this;
+  }
+
+  /**
+   * Records an application-specific opaque custom metric measurement. If RPC has already finished,
+   * this method is no-op.
+   *
+   * <p>A latter record will overwrite its former name-sakes.
+   *
+   * @return this recorder object
+   */
+  public CallMetricRecorder recordNamedMetric(String name, double value) {
+    if (disabled) {
+      return this;
+    }
+    if (namedMetrics.get() == null) {
+      // The chance of race of creation of the map should be very small, so it should be fine
+      // to create these maps that might be discarded.
+      namedMetrics.compareAndSet(null, new ConcurrentHashMap<String, Double>());
+    }
+    namedMetrics.get().put(name, value);
+    return this;
+  }
+
+  /**
+   * Records a call metric measurement for CPU utilization in the range [0, inf). Values outside the
+   * valid range are ignored. If RPC has already finished, this method is no-op.
+   *
+   * <p>A latter record will overwrite its former name-sakes.
+   *
+   * @return this recorder object
+   * @since 1.47.0
+   */
+  public CallMetricRecorder recordCpuUtilizationMetric(double value) {
+    if (disabled || !MetricRecorderHelper.isCpuOrApplicationUtilizationValid(value)) {
+      return this;
+    }
+    cpuUtilizationMetric = value;
+    return this;
+  }
+
+  /**
+   * Records a call metric measurement for application specific utilization in the range [0, inf).
+   * Values outside the valid range are ignored. If RPC has already finished, this method is no-op.
+   *
+   * <p>A latter record will overwrite its former name-sakes.
+   *
+   * @return this recorder object
+   */
+  public CallMetricRecorder recordApplicationUtilizationMetric(double value) {
+    if (disabled || !MetricRecorderHelper.isCpuOrApplicationUtilizationValid(value)) {
+      return this;
+    }
+    applicationUtilizationMetric = value;
+    return this;
+  }
+
+  /**
+   * Records a call metric measurement for memory utilization in the range [0, 1]. Values outside
+   * the valid range are ignored. If RPC has already finished, this method is no-op.
+   *
+   * <p>A latter record will overwrite its former name-sakes.
+   *
+   * @return this recorder object
+   * @since 1.47.0
+   */
+  public CallMetricRecorder recordMemoryUtilizationMetric(double value) {
+    if (disabled || !MetricRecorderHelper.isUtilizationValid(value)) {
+      return this;
+    }
+    memoryUtilizationMetric = value;
+    return this;
+  }
+
+  /**
+   * Records a call metric measurement for queries per second (qps) in the range [0, inf). Values
+   * outside the valid range are ignored. If RPC has already finished, this method is no-op.
+   *
+   * <p>A latter record will overwrite its former name-sakes.
+   *
+   * @return this recorder object
+   * @since 1.54.0
+   */
+  public CallMetricRecorder recordQpsMetric(double value) {
+    if (disabled || !MetricRecorderHelper.isRateValid(value)) {
+      return this;
+    }
+    qps = value;
+    return this;
+  }
+
+  /**
+   * Records a call metric measurement for errors per second (eps) in the range [0, inf). Values
+   * outside the valid range are ignored. If RPC has already finished, this method is no-op.
+   *
+   * <p>A latter record will overwrite its former name-sakes.
+   *
+   * @return this recorder object
+   */
+  public CallMetricRecorder recordEpsMetric(double value) {
+    if (disabled || !MetricRecorderHelper.isRateValid(value)) {
+      return this;
+    }
+    eps = value;
+    return this;
+  }
+
+  /**
+   * Returns all request cost metric values. No more metric values will be recorded after this
+   * method is called. Calling this method multiple times returns the same collection of metric
+   * values.
+   *
+   * @return a map containing all saved metric name-value pairs.
+   */
+  Map<String, Double> finalizeAndDump() {
+    disabled = true;
+    Map<String, Double> savedMetrics = requestCostMetrics.get();
+    if (savedMetrics == null) {
+      return Collections.emptyMap();
+    }
+    return Collections.unmodifiableMap(savedMetrics);
+  }
+
+  /**
+   * Returns all save metric values. No more metric values will be recorded after this method is
+   * called. Calling this method multiple times returns the same collection of metric values.
+   *
+   * @return a per-request ORCA reports containing all saved metrics.
+   */
+  MetricReport finalizeAndDump2() {
+    Map<String, Double> savedRequestCostMetrics = finalizeAndDump();
+    Map<String, Double> savedUtilizationMetrics = utilizationMetrics.get();
+    Map<String, Double> savedNamedMetrics = namedMetrics.get();
+    if (savedUtilizationMetrics == null) {
+      savedUtilizationMetrics = Collections.emptyMap();
+    }
+    if (savedNamedMetrics == null) {
+      savedNamedMetrics = Collections.emptyMap();
+    }
+    return new MetricReport(cpuUtilizationMetric, applicationUtilizationMetric,
+        memoryUtilizationMetric, qps, eps, Collections.unmodifiableMap(savedRequestCostMetrics),
+        Collections.unmodifiableMap(savedUtilizationMetrics),
+        Collections.unmodifiableMap(savedNamedMetrics)
+    );
+  }
+
+  @VisibleForTesting
+  boolean isDisabled() {
+    return disabled;
+  }
+
+  /**
+   * Turn this recorder into a no-op one.
+   */
+  private CallMetricRecorder disable() {
+    disabled = true;
+    return this;
+  }
+}
diff --git a/services/src/main/java/io/grpc/services/ChannelzService.java b/services/src/main/java/io/grpc/services/ChannelzService.java
new file mode 100644
index 00000000000..e8ef2bb8a9a
--- /dev/null
+++ b/services/src/main/java/io/grpc/services/ChannelzService.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2018 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.services;
+
+import io.grpc.ExperimentalApi;
+import io.grpc.channelz.v1.ChannelzGrpc;
+import io.grpc.channelz.v1.GetChannelRequest;
+import io.grpc.channelz.v1.GetChannelResponse;
+import io.grpc.channelz.v1.GetServerRequest;
+import io.grpc.channelz.v1.GetServerResponse;
+import io.grpc.channelz.v1.GetServerSocketsRequest;
+import io.grpc.channelz.v1.GetServerSocketsResponse;
+import io.grpc.channelz.v1.GetServersRequest;
+import io.grpc.channelz.v1.GetServersResponse;
+import io.grpc.channelz.v1.GetSocketRequest;
+import io.grpc.channelz.v1.GetSocketResponse;
+import io.grpc.channelz.v1.GetSubchannelRequest;
+import io.grpc.channelz.v1.GetSubchannelResponse;
+import io.grpc.channelz.v1.GetTopChannelsRequest;
+import io.grpc.channelz.v1.GetTopChannelsResponse;
+import io.grpc.stub.StreamObserver;
+
+/**
+ * The channelz service provides stats about a running gRPC process.
+ *
+ * @deprecated Use {@link io.grpc.protobuf.services.ChannelzService} instead.
+ */
+@Deprecated
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/4206")
+public final class ChannelzService extends ChannelzGrpc.ChannelzImplBase {
+  private final io.grpc.protobuf.services.ChannelzService delegate;
+
+  /**
+   * Creates an instance.
+   */
+  public static ChannelzService newInstance(int maxPageSize) {
+    return new ChannelzService(maxPageSize);
+  }
+
+  private ChannelzService(int maxPageSize) {
+    delegate = io.grpc.protobuf.services.ChannelzService.newInstance(maxPageSize);
+  }
+
+  /** Returns top level channel aka {@link io.grpc.ManagedChannel}. */
+  @Override
+  public void getTopChannels(
+      GetTopChannelsRequest request, StreamObserver<GetTopChannelsResponse> responseObserver) {
+    delegate.getTopChannels(request, responseObserver);
+  }
+
+  /** Returns a top level channel aka {@link io.grpc.ManagedChannel}. */
+  @Override
+  public void getChannel(
+      GetChannelRequest request, StreamObserver<GetChannelResponse> responseObserver) {
+    delegate.getChannel(request, responseObserver);
+  }
+
+  /** Returns servers. */
+  @Override
+  public void getServers(
+      GetServersRequest request, StreamObserver<GetServersResponse> responseObserver) {
+    delegate.getServers(request, responseObserver);
+  }
+
+  /** Returns a server. */
+  @Override
+  public void getServer(
+      GetServerRequest request, StreamObserver<GetServerResponse> responseObserver) {
+    delegate.getServer(request, responseObserver);
+  }
+
+  /** Returns a subchannel. */
+  @Override
+  public void getSubchannel(
+      GetSubchannelRequest request, StreamObserver<GetSubchannelResponse> responseObserver) {
+    delegate.getSubchannel(request, responseObserver);
+  }
+
+  /** Returns a socket. */
+  @Override
+  public void getSocket(
+      GetSocketRequest request, StreamObserver<GetSocketResponse> responseObserver) {
+    delegate.getSocket(request, responseObserver);
+  }
+
+  @Override
+  public void getServerSockets(
+      GetServerSocketsRequest request, StreamObserver<GetServerSocketsResponse> responseObserver) {
+    delegate.getServerSockets(request, responseObserver);
+  }
+}
diff --git a/services/src/main/java/io/grpc/services/HealthServiceImpl.java b/services/src/main/java/io/grpc/services/HealthServiceImpl.java
deleted file mode 100644
index 1229380e759..00000000000
--- a/services/src/main/java/io/grpc/services/HealthServiceImpl.java
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.services;
-
-import io.grpc.Status;
-import io.grpc.StatusException;
-import io.grpc.health.v1.HealthCheckRequest;
-import io.grpc.health.v1.HealthCheckResponse;
-import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
-import io.grpc.health.v1.HealthGrpc;
-import io.grpc.stub.StreamObserver;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import javax.annotation.Nullable;
-
-
-final class HealthServiceImpl extends HealthGrpc.HealthImplBase {
-
-  /* Due to the latency of rpc calls, synchronization of the map does not help with consistency.
-   * However, need use ConcurrentHashMap to prevent the possible race condition of currently putting
-   * two keys with a colliding hashCode into the map. */
-  private final Map<String, ServingStatus> statusMap
-      = new ConcurrentHashMap<String, ServingStatus>();
-
-  @Override
-  public void check(HealthCheckRequest request,
-      StreamObserver<HealthCheckResponse> responseObserver) {
-    ServingStatus status = getStatus(request.getService());
-    if (status == null) {
-      responseObserver.onError(new StatusException(Status.NOT_FOUND));
-    } else {
-      HealthCheckResponse response = HealthCheckResponse.newBuilder().setStatus(status).build();
-      responseObserver.onNext(response);
-      responseObserver.onCompleted();
-    }
-  }
-
-  void setStatus(String service, ServingStatus status) {
-    statusMap.put(service, status);
-  }
-
-  @Nullable
-  ServingStatus getStatus(String service) {
-    return statusMap.get(service);
-  }
-
-  void clearStatus(String service) {
-    statusMap.remove(service);
-  }
-
-  void clearAll() {
-    statusMap.clear();
-  }
-}
diff --git a/services/src/main/java/io/grpc/services/HealthStatusManager.java b/services/src/main/java/io/grpc/services/HealthStatusManager.java
index 937a778f937..7bcaf52da52 100644
--- a/services/src/main/java/io/grpc/services/HealthStatusManager.java
+++ b/services/src/main/java/io/grpc/services/HealthStatusManager.java
@@ -1,64 +1,59 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.services;
 
-import static com.google.common.base.Preconditions.checkNotNull;
-
+import io.grpc.BindableService;
 import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
-import io.grpc.health.v1.HealthGrpc;
 
 /**
  * A {@code HealthStatusManager} object manages a health check service. A health check service is
  * created in the constructor of {@code HealthStatusManager}, and it can be retrieved by the
  * {@link #getHealthService()} method.
  * The health status manager can update the health statuses of the server.
+ *
+ * <p>The default, empty-string, service name, {@link #SERVICE_NAME_ALL_SERVICES}, is initialized to
+ * {@link ServingStatus#SERVING}.
+ *
+ * @deprecated Use {@link io.grpc.protobuf.services.HealthStatusManager} instead.
  */
-@io.grpc.ExperimentalApi
+@Deprecated
+@io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/4696")
 public final class HealthStatusManager {
+  /**
+   * The special "service name" that represent all services on a GRPC server.  It is an empty
+   * string.
+   */
+  public static final String SERVICE_NAME_ALL_SERVICES =
+      io.grpc.protobuf.services.HealthStatusManager.SERVICE_NAME_ALL_SERVICES;
 
-  private final HealthServiceImpl healthService;
+  private io.grpc.protobuf.services.HealthStatusManager delegate;
 
   /**
    * Creates a new health service instance.
    */
   public HealthStatusManager() {
-    healthService = new HealthServiceImpl();
+    delegate = new io.grpc.protobuf.services.HealthStatusManager();
   }
 
   /**
    * Gets the health check service created in the constructor.
    */
-  public HealthGrpc.HealthImplBase getHealthService() {
-    return healthService;
+  public BindableService getHealthService() {
+    return delegate.getHealthService();
   }
 
   /**
@@ -70,8 +65,7 @@ public HealthGrpc.HealthImplBase getHealthService() {
    *     {@link ServingStatus#NOT_SERVING} and {@link ServingStatus#UNKNOWN}.
    */
   public void setStatus(String service, ServingStatus status) {
-    checkNotNull(status, "status");
-    healthService.setStatus(service, status);
+    delegate.setStatus(service, status);
   }
 
   /**
@@ -82,6 +76,15 @@ public void setStatus(String service, ServingStatus status) {
    *     It can also be an empty String {@code ""} per the gRPC specification.
    */
   public void clearStatus(String service) {
-    healthService.clearStatus(service);
+    delegate.clearStatus(service);
+  }
+
+  /**
+   * enterTerminalState causes the health status manager to mark all services as not serving, and
+   * prevents future updates to services.  This method is meant to be called prior to server
+   * shutdown as a way to indicate that clients should redirect their traffic elsewhere.
+   */
+  public void enterTerminalState() {
+    delegate.enterTerminalState();
   }
 }
diff --git a/services/src/main/java/io/grpc/services/InternalCallMetricRecorder.java b/services/src/main/java/io/grpc/services/InternalCallMetricRecorder.java
new file mode 100644
index 00000000000..a7ff1e5c32e
--- /dev/null
+++ b/services/src/main/java/io/grpc/services/InternalCallMetricRecorder.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2019 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.services;
+
+import io.grpc.Context;
+import io.grpc.Internal;
+import java.util.Map;
+
+/**
+ * Internal {@link CallMetricRecorder} accessor.  This is intended for usage internal to the gRPC
+ * team.  If you *really* think you need to use this, contact the gRPC team first.
+ */
+@Internal
+public final class InternalCallMetricRecorder {
+
+  public static final Context.Key<CallMetricRecorder> CONTEXT_KEY = CallMetricRecorder.CONTEXT_KEY;
+
+  // Prevent instantiation.
+  private InternalCallMetricRecorder() {
+  }
+
+  public static CallMetricRecorder newCallMetricRecorder() {
+    return new CallMetricRecorder();
+  }
+
+  public static Map<String, Double> finalizeAndDump(CallMetricRecorder recorder) {
+    return recorder.finalizeAndDump();
+  }
+
+  public static MetricReport finalizeAndDump2(CallMetricRecorder recorder) {
+    return recorder.finalizeAndDump2();
+  }
+
+  public static MetricReport createMetricReport(double cpuUtilization,
+      double applicationUtilization, double memoryUtilization, double qps, double eps,
+      Map<String, Double> requestCostMetrics, Map<String, Double> utilizationMetrics,
+      Map<String, Double> namedMetrics) {
+    return new MetricReport(cpuUtilization, applicationUtilization, memoryUtilization, qps, eps,
+        requestCostMetrics, utilizationMetrics, namedMetrics);
+  }
+}
diff --git a/services/src/main/java/io/grpc/services/InternalMetricRecorder.java b/services/src/main/java/io/grpc/services/InternalMetricRecorder.java
new file mode 100644
index 00000000000..cd36c425ac8
--- /dev/null
+++ b/services/src/main/java/io/grpc/services/InternalMetricRecorder.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2022 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.services;
+
+import io.grpc.Internal;
+
+/**
+ * Internal {@link CallMetricRecorder} accessor.  This is intended for usage internal to the gRPC
+ * team.  If you *really* think you need to use this, contact the gRPC team first.
+ */
+@Internal
+public final class InternalMetricRecorder {
+
+  // Prevent instantiation.
+  private InternalMetricRecorder() {
+  }
+
+  public static MetricReport getMetricReport(MetricRecorder recorder) {
+    return recorder.getMetricReport();
+  }
+}
diff --git a/services/src/main/java/io/grpc/services/MetricRecorder.java b/services/src/main/java/io/grpc/services/MetricRecorder.java
new file mode 100644
index 00000000000..39b0e8df25f
--- /dev/null
+++ b/services/src/main/java/io/grpc/services/MetricRecorder.java
@@ -0,0 +1,160 @@
+/*
+ * Copyright 2022 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.services;
+
+import io.grpc.ExperimentalApi;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Implements the service/APIs for Out-of-Band metrics reporting, only for utilization metrics.
+ * A user should use the public set-APIs to update the server machine's utilization metrics data.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/9006")
+public final class MetricRecorder {
+  private volatile ConcurrentHashMap<String, Double> metricsData = new ConcurrentHashMap<>();
+  private volatile double cpuUtilization;
+  private volatile double applicationUtilization;
+  private volatile double memoryUtilization;
+  private volatile double qps;
+  private volatile double eps;
+
+  public static MetricRecorder newInstance() {
+    return new MetricRecorder();
+  }
+
+  private MetricRecorder() {}
+
+  /**
+   * Update the metrics value in the range [0, 1] corresponding to the specified key. Values outside
+   * the valid range are ignored.
+   */
+  public void putUtilizationMetric(String key, double value) {
+    if (!MetricRecorderHelper.isUtilizationValid(value)) {
+      return;
+    }
+    metricsData.put(key, value);
+  }
+
+  /**
+   * Replace the whole metrics data using the specified map. No range validation.
+   */
+  public void setAllUtilizationMetrics(Map<String, Double> metrics) {
+    metricsData = new ConcurrentHashMap<>(metrics);
+  }
+
+  /**
+   * Remove the metrics data entry corresponding to the specified key.
+   */
+  public void removeUtilizationMetric(String key) {
+    metricsData.remove(key);
+  }
+
+  /**
+   * Update the CPU utilization metrics data in the range [0, inf). Values outside the valid range
+   * are ignored.
+   */
+  public void setCpuUtilizationMetric(double value) {
+    if (!MetricRecorderHelper.isCpuOrApplicationUtilizationValid(value)) {
+      return;
+    }
+    cpuUtilization = value;
+  }
+
+  /**
+   * Clear the CPU utilization metrics data.
+   */
+  public void clearCpuUtilizationMetric() {
+    cpuUtilization = 0;
+  }
+
+  /**
+   * Update the application specific utilization metrics data in the range [0, inf). Values outside
+   * the valid range are ignored.
+   */
+  public void setApplicationUtilizationMetric(double value) {
+    if (!MetricRecorderHelper.isCpuOrApplicationUtilizationValid(value)) {
+      return;
+    }
+    applicationUtilization = value;
+  }
+
+  /**
+   * Clear the application specific utilization metrics data.
+   */
+  public void clearApplicationUtilizationMetric() {
+    applicationUtilization = 0;
+  }
+
+  /**
+   * Update the memory utilization metrics data in the range [0, 1]. Values outside the valid range
+   * are ignored.
+   */
+  public void setMemoryUtilizationMetric(double value) {
+    if (!MetricRecorderHelper.isUtilizationValid(value)) {
+      return;
+    }
+    memoryUtilization = value;
+  }
+
+  /**
+   * Clear the memory utilization metrics data.
+   */
+  public void clearMemoryUtilizationMetric() {
+    memoryUtilization = 0;
+  }
+
+  /**
+   * Update the QPS metrics data in the range [0, inf). Values outside the valid range are ignored.
+   */
+  public void setQpsMetric(double value) {
+    if (!MetricRecorderHelper.isRateValid(value)) {
+      return;
+    }
+    qps = value;
+  }
+
+  /**
+   * Clear the QPS metrics data.
+   */
+  public void clearQpsMetric() {
+    qps = 0;
+  }
+
+  /**
+   * Update the EPS metrics data in the range [0, inf). Values outside the valid range are ignored.
+   */
+  public void setEpsMetric(double value) {
+    if (!MetricRecorderHelper.isRateValid(value)) {
+      return;
+    }
+    this.eps = value;
+  }
+
+  /**
+   * Clear the EPS metrics data.
+   */
+  public void clearEpsMetric() {
+    eps = 0;
+  }
+
+  MetricReport getMetricReport() {
+    return new MetricReport(cpuUtilization, applicationUtilization, memoryUtilization, qps, eps,
+        Collections.emptyMap(), Collections.unmodifiableMap(metricsData), Collections.emptyMap());
+  }
+}
diff --git a/services/src/main/java/io/grpc/services/MetricRecorderHelper.java b/services/src/main/java/io/grpc/services/MetricRecorderHelper.java
new file mode 100644
index 00000000000..6d042fb0f19
--- /dev/null
+++ b/services/src/main/java/io/grpc/services/MetricRecorderHelper.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2023 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.services;
+
+/**
+ * Utility helper class to check whether values for {@link CallMetricRecorder} and
+ * {@link MetricRecorder} are inside the valid range.
+ */
+final class MetricRecorderHelper {
+
+  /**
+   * Return true if the utilization value is in the range [0, 1] and false otherwise.
+   */
+  static boolean isUtilizationValid(double utilization) {
+    return utilization >= 0.0 && utilization <= 1.0;
+  }
+
+  /**
+   * Return true if the cpu utilization or application specific utilization value is in the range
+   * [0, inf) and false otherwise. Occasionally users have over 100% cpu utilization and get a
+   * runaway effect where the backend with highest qps gets more and more qps sent to it. So we
+   * allow cpu utilization > 1.0, similarly for application specific utilization.
+   */
+  static boolean isCpuOrApplicationUtilizationValid(double utilization) {
+    return utilization >= 0.0;
+  }
+
+  /**
+   * Return true if a rate value (such as qps or eps) is in the range [0, inf) and false otherwise.
+   */
+  static boolean isRateValid(double rate) {
+    return rate >= 0.0;
+  }
+
+  // Prevent instantiation.
+  private MetricRecorderHelper() {
+  }
+}
diff --git a/services/src/main/java/io/grpc/services/MetricReport.java b/services/src/main/java/io/grpc/services/MetricReport.java
new file mode 100644
index 00000000000..e559f0f00b5
--- /dev/null
+++ b/services/src/main/java/io/grpc/services/MetricReport.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2022 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.services;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.ExperimentalApi;
+import java.util.Map;
+
+/**
+ * A gRPC object of orca load report. LB policies listening at per-rpc or oob orca load reports
+ * will be notified of the metrics data in this data format.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/9381")
+public final class MetricReport {
+  private double cpuUtilization;
+  private double applicationUtilization;
+  private double memoryUtilization;
+  private double qps;
+  private double eps;
+  private Map<String, Double> requestCostMetrics;
+  private Map<String, Double> utilizationMetrics;
+  private Map<String, Double> namedMetrics;
+
+  MetricReport(double cpuUtilization, double applicationUtilization, double memoryUtilization,
+      double qps, double eps, Map<String, Double> requestCostMetrics,
+      Map<String, Double> utilizationMetrics, Map<String, Double> namedMetrics) {
+    this.cpuUtilization = cpuUtilization;
+    this.applicationUtilization = applicationUtilization;
+    this.memoryUtilization = memoryUtilization;
+    this.qps = qps;
+    this.eps = eps;
+    this.requestCostMetrics = checkNotNull(requestCostMetrics, "requestCostMetrics");
+    this.utilizationMetrics = checkNotNull(utilizationMetrics, "utilizationMetrics");
+    this.namedMetrics = checkNotNull(namedMetrics, "namedMetrics");
+  }
+
+  public double getCpuUtilization() {
+    return cpuUtilization;
+  }
+
+  public double getApplicationUtilization() {
+    return applicationUtilization;
+  }
+
+  public double getMemoryUtilization() {
+    return memoryUtilization;
+  }
+
+  public Map<String, Double> getRequestCostMetrics() {
+    return requestCostMetrics;
+  }
+
+  public Map<String, Double> getUtilizationMetrics() {
+    return utilizationMetrics;
+  }
+
+  public Map<String, Double> getNamedMetrics() {
+    return namedMetrics;
+  }
+
+  public double getQps() {
+    return qps;
+  }
+
+  public double getEps() {
+    return eps;
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("cpuUtilization", cpuUtilization)
+        .add("applicationUtilization", applicationUtilization)
+        .add("memoryUtilization", memoryUtilization)
+        .add("requestCost", requestCostMetrics)
+        .add("utilization", utilizationMetrics)
+        .add("named", namedMetrics)
+        .add("qps", qps)
+        .add("eps", eps)
+        .toString();
+  }
+}
diff --git a/services/src/main/java/io/grpc/services/package-info.java b/services/src/main/java/io/grpc/services/package-info.java
index 195e6aa2df4..7e21ae519bb 100644
--- a/services/src/main/java/io/grpc/services/package-info.java
+++ b/services/src/main/java/io/grpc/services/package-info.java
@@ -1,34 +1,21 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.
  */
 
+// TODO(chengyuanzhang): update description after deleting classes with protobuf dependency that
+//  have already been moved.
 /**
  * Service definitions and utilities for the pre-defined gRPC services.
  */
diff --git a/services/src/main/proto/grpc/binlog/v1/binarylog.proto b/services/src/main/proto/grpc/binlog/v1/binarylog.proto
new file mode 100644
index 00000000000..b18bd88ddc9
--- /dev/null
+++ b/services/src/main/proto/grpc/binlog/v1/binarylog.proto
@@ -0,0 +1,209 @@
+// Copyright 2018 The gRPC Authors
+// All rights reserved.
+//
+// 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.
+
+// The canonical version of this proto can be found at
+// https://github.com/grpc/grpc-proto/blob/master/grpc/binlog/v1/binarylog.proto
+
+syntax = "proto3";
+
+package grpc.binarylog.v1;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+
+option go_package = "google.golang.org/grpc/binarylog/grpc_binarylog_v1";
+option java_multiple_files = true;
+option java_package = "io.grpc.binarylog.v1";
+option java_outer_classname = "BinaryLogProto";
+
+// Log entry we store in binary logs
+message GrpcLogEntry {
+  // Enumerates the type of event
+  // Note the terminology is different from the RPC semantics
+  // definition, but the same meaning is expressed here.
+  enum EventType {
+    EVENT_TYPE_UNKNOWN = 0;
+    // Header sent from client to server
+    EVENT_TYPE_CLIENT_HEADER = 1;
+    // Header sent from server to client
+    EVENT_TYPE_SERVER_HEADER = 2;
+    // Message sent from client to server
+    EVENT_TYPE_CLIENT_MESSAGE = 3;
+    // Message sent from server to client
+    EVENT_TYPE_SERVER_MESSAGE = 4;
+    // A signal that client is done sending
+    EVENT_TYPE_CLIENT_HALF_CLOSE = 5;
+    // Trailer indicates the end of the RPC.
+    // On client side, this event means a trailer was either received
+    // from the network or the gRPC library locally generated a status
+    // to inform the application about a failure.
+    // On server side, this event means the server application requested
+    // to send a trailer. Note: EVENT_TYPE_CANCEL may still arrive after
+    // this due to races on server side.
+    EVENT_TYPE_SERVER_TRAILER = 6;
+    // A signal that the RPC is cancelled. On client side, this
+    // indicates the client application requests a cancellation.
+    // On server side, this indicates that cancellation was detected.
+    // Note: This marks the end of the RPC. Events may arrive after
+    // this due to races. For example, on client side a trailer
+    // may arrive even though the application requested to cancel the RPC.
+    EVENT_TYPE_CANCEL = 7;
+  }
+
+  // Enumerates the entity that generates the log entry
+  enum Logger {
+    LOGGER_UNKNOWN = 0;
+    LOGGER_CLIENT = 1;
+    LOGGER_SERVER = 2;
+  }
+
+  // The timestamp of the binary log message
+  google.protobuf.Timestamp timestamp = 1;
+
+  // Uniquely identifies a call. The value must not be 0 in order to disambiguate
+  // from an unset value.
+  // Each call may have several log entries, they will all have the same call_id.
+  // Nothing is guaranteed about their value other than they are unique across
+  // different RPCs in the same gRPC process.
+  uint64 call_id = 2;
+
+  // The entry sequence id for this call. The first GrpcLogEntry has a
+  // value of 1, to disambiguate from an unset value. The purpose of
+  // this field is to detect missing entries in environments where
+  // durability or ordering is not guaranteed.
+  uint64 sequence_id_within_call = 3;
+
+  EventType type = 4;
+  Logger logger = 5;  // One of the above Logger enum
+
+  // The logger uses one of the following fields to record the payload,
+  // according to the type of the log entry.
+  oneof payload {
+    ClientHeader client_header = 6;
+    ServerHeader server_header = 7;
+    // Used by EVENT_TYPE_CLIENT_MESSAGE, EVENT_TYPE_SERVER_MESSAGE
+    Message message = 8;
+    Trailer trailer = 9;
+  }
+
+  // true if payload does not represent the full message or metadata.
+  bool payload_truncated = 10;
+
+  // Peer address information, will only be recorded on the first
+  // incoming event. On client side, peer is logged on
+  // EVENT_TYPE_SERVER_HEADER normally or EVENT_TYPE_SERVER_TRAILER in
+  // the case of trailers-only. On server side, peer is always
+  // logged on EVENT_TYPE_CLIENT_HEADER.
+  Address peer = 11;
+};
+
+message ClientHeader {
+  // This contains only the metadata from the application.
+  Metadata metadata = 1;
+
+  // The name of the RPC method, which looks something like:
+  // /<service>/<method>
+  // Note the leading "/" character.
+  string method_name = 2;
+
+  // A single process may be used to run multiple virtual
+  // servers with different identities.
+  // The authority is the name of such a server identity.
+  // It is typically a portion of the URI in the form of
+  // <host> or <host>:<port> .
+  string authority = 3;
+
+  // the RPC timeout
+  google.protobuf.Duration timeout = 4;
+}
+
+message ServerHeader {
+  // This contains only the metadata from the application.
+  Metadata metadata = 1;
+}
+
+message Trailer {
+  // This contains only the metadata from the application.
+  Metadata metadata = 1;
+
+  // The gRPC status code.
+  uint32 status_code = 2;
+
+  // An original status message before any transport specific
+  // encoding.
+  string status_message = 3;
+
+  // The value of the 'grpc-status-details-bin' metadata key. If
+  // present, this is always an encoded 'google.rpc.Status' message.
+  bytes status_details = 4;
+}
+
+// Message payload, used by CLIENT_MESSAGE and SERVER_MESSAGE
+message Message {
+  // Length of the message. It may not be the same as the length of the
+  // data field, as the logging payload can be truncated or omitted.
+  uint32 length = 1;
+  // May be truncated or omitted.
+  bytes data = 2;
+}
+
+// A list of metadata pairs, used in the payload of client header,
+// server header, and server trailer.
+// Implementations may omit some entries to honor the header limits
+// of GRPC_BINARY_LOG_CONFIG.
+//
+// Header keys added by gRPC are omitted. To be more specific,
+// implementations will not log the following entries, and this is
+// not to be treated as a truncation:
+// - entries handled by grpc that are not user visible, such as those
+//   that begin with 'grpc-' (with exception of grpc-trace-bin)
+//   or keys like 'lb-token'
+// - transport specific entries, including but not limited to:
+//   ':path', ':authority', 'content-encoding', 'user-agent', 'te', etc
+// - entries added for call credentials
+//
+// Implementations must always log grpc-trace-bin if it is present.
+// Practically speaking it will only be visible on server side because
+// grpc-trace-bin is managed by low level client side mechanisms
+// inaccessible from the application level. On server side, the
+// header is just a normal metadata key.
+// The pair will not count towards the size limit.
+message Metadata {
+  repeated MetadataEntry entry = 1;
+}
+
+// A metadata key value pair
+message MetadataEntry {
+  string key = 1;
+  bytes value = 2;
+}
+
+// Address information
+message Address {
+  enum Type {
+    TYPE_UNKNOWN = 0;
+    // address is in 1.2.3.4 form
+    TYPE_IPV4 = 1;
+    // address is in IPv6 canonical form (RFC5952 section 4)
+    // The scope is NOT included in the address string.
+    TYPE_IPV6 = 2;
+    // address is UDS string
+    TYPE_UNIX = 3;
+  };
+  Type type = 1;
+  string address = 2;
+  // only for TYPE_IPV4 and TYPE_IPV6
+  uint32 ip_port = 3;
+}
diff --git a/services/src/main/proto/grpc/channelz/v1/channelz.proto b/services/src/main/proto/grpc/channelz/v1/channelz.proto
new file mode 100644
index 00000000000..d0781094ea8
--- /dev/null
+++ b/services/src/main/proto/grpc/channelz/v1/channelz.proto
@@ -0,0 +1,564 @@
+// Copyright 2018 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.
+
+// This file defines an interface for exporting monitoring information
+// out of gRPC servers.  See the full design at
+// https://github.com/grpc/proposal/blob/master/A14-channelz.md
+//
+// The canonical version of this proto can be found at
+// https://github.com/grpc/grpc-proto/blob/master/grpc/channelz/v1/channelz.proto
+
+syntax = "proto3";
+
+package grpc.channelz.v1;
+
+import "google/protobuf/any.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/wrappers.proto";
+
+option go_package = "google.golang.org/grpc/channelz/grpc_channelz_v1";
+option java_multiple_files = true;
+option java_package = "io.grpc.channelz.v1";
+option java_outer_classname = "ChannelzProto";
+
+// Channel is a logical grouping of channels, subchannels, and sockets.
+message Channel {
+  // The identifier for this channel. This should be set.
+  ChannelRef ref = 1;
+  // Data specific to this channel.
+  ChannelData data = 2;
+  // At most one of 'channel_ref+subchannel_ref' and 'socket' is set.
+
+  // There are no ordering guarantees on the order of channel refs.
+  // There may not be cycles in the ref graph.
+  // A channel ref may be present in more than one channel or subchannel.
+  repeated ChannelRef channel_ref = 3;
+
+  // At most one of 'channel_ref+subchannel_ref' and 'socket' is set.
+  // There are no ordering guarantees on the order of subchannel refs.
+  // There may not be cycles in the ref graph.
+  // A sub channel ref may be present in more than one channel or subchannel.
+  repeated SubchannelRef subchannel_ref = 4;
+
+  // There are no ordering guarantees on the order of sockets.
+  repeated SocketRef socket_ref = 5;
+}
+
+// Subchannel is a logical grouping of channels, subchannels, and sockets.
+// A subchannel is load balanced over by it's ancestor
+message Subchannel {
+  // The identifier for this channel.
+  SubchannelRef ref = 1;
+  // Data specific to this channel.
+  ChannelData data = 2;
+  // At most one of 'channel_ref+subchannel_ref' and 'socket' is set.
+
+  // There are no ordering guarantees on the order of channel refs.
+  // There may not be cycles in the ref graph.
+  // A channel ref may be present in more than one channel or subchannel.
+  repeated ChannelRef channel_ref = 3;
+
+  // At most one of 'channel_ref+subchannel_ref' and 'socket' is set.
+  // There are no ordering guarantees on the order of subchannel refs.
+  // There may not be cycles in the ref graph.
+  // A sub channel ref may be present in more than one channel or subchannel.
+  repeated SubchannelRef subchannel_ref = 4;
+
+  // There are no ordering guarantees on the order of sockets.
+  repeated SocketRef socket_ref = 5;
+}
+
+// These come from the specified states in this document:
+// https://github.com/grpc/grpc/blob/master/doc/connectivity-semantics-and-api.md
+message ChannelConnectivityState {
+  enum State {
+    UNKNOWN = 0;
+    IDLE = 1;
+    CONNECTING = 2;
+    READY = 3;
+    TRANSIENT_FAILURE = 4;
+    SHUTDOWN = 5;
+  }
+  State state = 1;
+}
+
+// Channel data is data related to a specific Channel or Subchannel.
+message ChannelData {
+  // The connectivity state of the channel or subchannel.  Implementations
+  // should always set this.
+  ChannelConnectivityState state = 1;
+
+  // The target this channel originally tried to connect to.  May be absent
+  string target = 2;
+
+  // A trace of recent events on the channel.  May be absent.
+  ChannelTrace trace = 3;
+
+  // The number of calls started on the channel
+  int64 calls_started = 4;
+  // The number of calls that have completed with an OK status
+  int64 calls_succeeded = 5;
+  // The number of calls that have completed with a non-OK status
+  int64 calls_failed = 6;
+
+  // The last time a call was started on the channel.
+  google.protobuf.Timestamp last_call_started_timestamp = 7;
+}
+
+// A trace event is an interesting thing that happened to a channel or
+// subchannel, such as creation, address resolution, subchannel creation, etc.
+message ChannelTraceEvent {
+  // High level description of the event.
+  string description = 1;
+  // The supported severity levels of trace events.
+  enum Severity {
+    CT_UNKNOWN = 0;
+    CT_INFO = 1;
+    CT_WARNING = 2;
+    CT_ERROR = 3;
+  }
+  // the severity of the trace event
+  Severity severity = 2;
+  // When this event occurred.
+  google.protobuf.Timestamp timestamp = 3;
+  // ref of referenced channel or subchannel.
+  // Optional, only present if this event refers to a child object. For example,
+  // this field would be filled if this trace event was for a subchannel being
+  // created.
+  oneof child_ref {
+    ChannelRef channel_ref = 4;
+    SubchannelRef subchannel_ref = 5;
+  }
+}
+
+// ChannelTrace represents the recent events that have occurred on the channel.
+message ChannelTrace {
+  // Number of events ever logged in this tracing object. This can differ from
+  // events.size() because events can be overwritten or garbage collected by
+  // implementations.
+  int64 num_events_logged = 1;
+  // Time that this channel was created.
+  google.protobuf.Timestamp creation_timestamp = 2;
+  // List of events that have occurred on this channel.
+  repeated ChannelTraceEvent events = 3;
+}
+
+// ChannelRef is a reference to a Channel.
+message ChannelRef {
+  // The globally unique id for this channel.  Must be a positive number.
+  int64 channel_id = 1;
+  // An optional name associated with the channel.
+  string name = 2;
+  // Intentionally don't use field numbers from other refs.
+  reserved 3, 4, 5, 6, 7, 8;
+}
+
+// SubchannelRef is a reference to a Subchannel.
+message SubchannelRef {
+  // The globally unique id for this subchannel.  Must be a positive number.
+  int64 subchannel_id = 7;
+  // An optional name associated with the subchannel.
+  string name = 8;
+  // Intentionally don't use field numbers from other refs.
+  reserved 1, 2, 3, 4, 5, 6;
+}
+
+// SocketRef is a reference to a Socket.
+message SocketRef {
+  // The globally unique id for this socket.  Must be a positive number.
+  int64 socket_id = 3;
+  // An optional name associated with the socket.
+  string name = 4;
+  // Intentionally don't use field numbers from other refs.
+  reserved 1, 2, 5, 6, 7, 8;
+}
+
+// ServerRef is a reference to a Server.
+message ServerRef {
+  // A globally unique identifier for this server.  Must be a positive number.
+  int64 server_id = 5;
+  // An optional name associated with the server.
+  string name = 6;
+  // Intentionally don't use field numbers from other refs.
+  reserved 1, 2, 3, 4, 7, 8;
+}
+
+// Server represents a single server.  There may be multiple servers in a single
+// program.
+message Server {
+  // The identifier for a Server.  This should be set.
+  ServerRef ref = 1;
+  // The associated data of the Server.
+  ServerData data = 2;
+
+  // The sockets that the server is listening on.  There are no ordering
+  // guarantees.  This may be absent.
+  repeated SocketRef listen_socket = 3;
+}
+
+// ServerData is data for a specific Server.
+message ServerData {
+  // A trace of recent events on the server.  May be absent.
+  ChannelTrace trace = 1;
+
+  // The number of incoming calls started on the server
+  int64 calls_started = 2;
+  // The number of incoming calls that have completed with an OK status
+  int64 calls_succeeded = 3;
+  // The number of incoming calls that have a completed with a non-OK status
+  int64 calls_failed = 4;
+
+  // The last time a call was started on the server.
+  google.protobuf.Timestamp last_call_started_timestamp = 5;
+}
+
+// Information about an actual connection.  Pronounced "sock-ay".
+message Socket {
+  // The identifier for the Socket.
+  SocketRef ref = 1;
+
+  // Data specific to this Socket.
+  SocketData data = 2;
+  // The locally bound address.
+  Address local = 3;
+  // The remote bound address.  May be absent.
+  Address remote = 4;
+  // Security details for this socket.  May be absent if not available, or
+  // there is no security on the socket.
+  Security security = 5;
+
+  // Optional, represents the name of the remote endpoint, if different than
+  // the original target name.
+  string remote_name = 6;
+}
+
+// SocketData is data associated for a specific Socket.  The fields present
+// are specific to the implementation, so there may be minor differences in
+// the semantics.  (e.g. flow control windows)
+message SocketData {
+  // The number of streams that have been started.
+  int64 streams_started = 1;
+  // The number of streams that have ended successfully:
+  // On client side, received frame with eos bit set;
+  // On server side, sent frame with eos bit set.
+  int64 streams_succeeded = 2;
+  // The number of streams that have ended unsuccessfully:
+  // On client side, ended without receiving frame with eos bit set;
+  // On server side, ended without sending frame with eos bit set.
+  int64 streams_failed = 3;
+  // The number of grpc messages successfully sent on this socket.
+  int64 messages_sent = 4;
+  // The number of grpc messages received on this socket.
+  int64 messages_received = 5;
+
+  // The number of keep alives sent.  This is typically implemented with HTTP/2
+  // ping messages.
+  int64 keep_alives_sent = 6;
+
+  // The last time a stream was created by this endpoint.  Usually unset for
+  // servers.
+  google.protobuf.Timestamp last_local_stream_created_timestamp = 7;
+  // The last time a stream was created by the remote endpoint.  Usually unset
+  // for clients.
+  google.protobuf.Timestamp last_remote_stream_created_timestamp = 8;
+
+  // The last time a message was sent by this endpoint.
+  google.protobuf.Timestamp last_message_sent_timestamp = 9;
+  // The last time a message was received by this endpoint.
+  google.protobuf.Timestamp last_message_received_timestamp = 10;
+
+  // The amount of window, granted to the local endpoint by the remote endpoint.
+  // This may be slightly out of date due to network latency.  This does NOT
+  // include stream level or TCP level flow control info.
+  google.protobuf.Int64Value local_flow_control_window = 11;
+
+  // The amount of window, granted to the remote endpoint by the local endpoint.
+  // This may be slightly out of date due to network latency.  This does NOT
+  // include stream level or TCP level flow control info.
+  google.protobuf.Int64Value  remote_flow_control_window = 12;
+
+  // Socket options set on this socket.  May be absent if 'summary' is set
+  // on GetSocketRequest.
+  repeated SocketOption option = 13;
+}
+
+// Address represents the address used to create the socket.
+message Address {
+  message TcpIpAddress {
+    // Either the IPv4 or IPv6 address in bytes.  Will be either 4 bytes or 16
+    // bytes in length.
+    bytes ip_address = 1;
+    // 0-64k, or -1 if not appropriate.
+    int32 port = 2;
+  }
+  // A Unix Domain Socket address.
+  message UdsAddress {
+    string filename = 1;
+  }
+  // An address type not included above.
+  message OtherAddress {
+    // The human readable version of the value.  This value should be set.
+    string name = 1;
+    // The actual address message.
+    google.protobuf.Any value = 2;
+  }
+
+  oneof address {
+    TcpIpAddress tcpip_address = 1;
+    UdsAddress uds_address = 2;
+    OtherAddress other_address = 3;
+  }
+}
+
+// Security represents details about how secure the socket is.
+message Security {
+  message Tls {
+    oneof cipher_suite {
+      // The cipher suite name in the RFC 4346 format:
+      // https://tools.ietf.org/html/rfc4346#appendix-C
+      string standard_name = 1;
+      // Some other way to describe the cipher suite if
+      // the RFC 4346 name is not available.
+      string other_name = 2;
+    }
+    // the certificate used by this endpoint.
+    bytes local_certificate = 3;
+    // the certificate used by the remote endpoint.
+    bytes remote_certificate = 4;
+  }
+  message OtherSecurity {
+    // The human readable version of the value.
+    string name = 1;
+    // The actual security details message.
+    google.protobuf.Any value = 2;
+  }
+  oneof model {
+    Tls tls = 1;
+    OtherSecurity other = 2;
+  }
+}
+
+// SocketOption represents socket options for a socket.  Specifically, these
+// are the options returned by getsockopt().
+message SocketOption {
+  // The full name of the socket option.  Typically this will be the upper case
+  // name, such as "SO_REUSEPORT".
+  string name = 1;
+  // The human readable value of this socket option.  At least one of value or
+  // additional will be set.
+  string value = 2;
+  // Additional data associated with the socket option.  At least one of value
+  // or additional will be set.
+  google.protobuf.Any additional = 3;
+}
+
+// For use with SocketOption's additional field.  This is primarily used for
+// SO_RCVTIMEO and SO_SNDTIMEO
+message SocketOptionTimeout {
+  google.protobuf.Duration duration = 1;
+}
+
+// For use with SocketOption's additional field.  This is primarily used for
+// SO_LINGER.
+message SocketOptionLinger {
+  // active maps to `struct linger.l_onoff`
+  bool active = 1;
+  // duration maps to `struct linger.l_linger`
+  google.protobuf.Duration duration = 2;
+}
+
+// For use with SocketOption's additional field.  Tcp info for
+// SOL_TCP and TCP_INFO.
+message SocketOptionTcpInfo {
+  uint32 tcpi_state = 1;
+
+  uint32 tcpi_ca_state = 2;
+  uint32 tcpi_retransmits = 3;
+  uint32 tcpi_probes = 4;
+  uint32 tcpi_backoff = 5;
+  uint32 tcpi_options = 6;
+  uint32 tcpi_snd_wscale = 7;
+  uint32 tcpi_rcv_wscale = 8;
+
+  uint32 tcpi_rto = 9;
+  uint32 tcpi_ato = 10;
+  uint32 tcpi_snd_mss = 11;
+  uint32 tcpi_rcv_mss = 12;
+
+  uint32 tcpi_unacked = 13;
+  uint32 tcpi_sacked = 14;
+  uint32 tcpi_lost = 15;
+  uint32 tcpi_retrans = 16;
+  uint32 tcpi_fackets = 17;
+
+  uint32 tcpi_last_data_sent = 18;
+  uint32 tcpi_last_ack_sent = 19;
+  uint32 tcpi_last_data_recv = 20;
+  uint32 tcpi_last_ack_recv = 21;
+
+  uint32 tcpi_pmtu = 22;
+  uint32 tcpi_rcv_ssthresh = 23;
+  uint32 tcpi_rtt = 24;
+  uint32 tcpi_rttvar = 25;
+  uint32 tcpi_snd_ssthresh = 26;
+  uint32 tcpi_snd_cwnd = 27;
+  uint32 tcpi_advmss = 28;
+  uint32 tcpi_reordering = 29;
+}
+
+// Channelz is a service exposed by gRPC servers that provides detailed debug
+// information.
+service Channelz {
+  // Gets all root channels (i.e. channels the application has directly
+  // created). This does not include subchannels nor non-top level channels.
+  rpc GetTopChannels(GetTopChannelsRequest) returns (GetTopChannelsResponse);
+  // Gets all servers that exist in the process.
+  rpc GetServers(GetServersRequest) returns (GetServersResponse);
+  // Returns a single Server, or else a NOT_FOUND code.
+  rpc GetServer(GetServerRequest) returns (GetServerResponse);
+  // Gets all server sockets that exist in the process.
+  rpc GetServerSockets(GetServerSocketsRequest) returns (GetServerSocketsResponse);
+  // Returns a single Channel, or else a NOT_FOUND code.
+  rpc GetChannel(GetChannelRequest) returns (GetChannelResponse);
+  // Returns a single Subchannel, or else a NOT_FOUND code.
+  rpc GetSubchannel(GetSubchannelRequest) returns (GetSubchannelResponse);
+  // Returns a single Socket or else a NOT_FOUND code.
+  rpc GetSocket(GetSocketRequest) returns (GetSocketResponse);
+}
+
+message GetTopChannelsRequest {
+  // start_channel_id indicates that only channels at or above this id should be
+  // included in the results.
+  // To request the first page, this should be set to 0. To request
+  // subsequent pages, the client generates this value by adding 1 to
+  // the highest seen result ID.
+  int64 start_channel_id = 1;
+
+  // If non-zero, the server will return a page of results containing
+  // at most this many items. If zero, the server will choose a
+  // reasonable page size.  Must never be negative.
+  int64 max_results = 2;
+}
+
+message GetTopChannelsResponse {
+  // list of channels that the connection detail service knows about.  Sorted in
+  // ascending channel_id order.
+  // Must contain at least 1 result, otherwise 'end' must be true.
+  repeated Channel channel = 1;
+  // If set, indicates that the list of channels is the final list.  Requesting
+  // more channels can only return more if they are created after this RPC
+  // completes.
+  bool end = 2;
+}
+
+message GetServersRequest {
+  // start_server_id indicates that only servers at or above this id should be
+  // included in the results.
+  // To request the first page, this must be set to 0. To request
+  // subsequent pages, the client generates this value by adding 1 to
+  // the highest seen result ID.
+  int64 start_server_id = 1;
+
+  // If non-zero, the server will return a page of results containing
+  // at most this many items. If zero, the server will choose a
+  // reasonable page size.  Must never be negative.
+  int64 max_results = 2;
+}
+
+message GetServersResponse {
+  // list of servers that the connection detail service knows about.  Sorted in
+  // ascending server_id order.
+  // Must contain at least 1 result, otherwise 'end' must be true.
+  repeated Server server = 1;
+  // If set, indicates that the list of servers is the final list.  Requesting
+  // more servers will only return more if they are created after this RPC
+  // completes.
+  bool end = 2;
+}
+
+message GetServerRequest {
+  // server_id is the identifier of the specific server to get.
+  int64 server_id = 1;
+}
+
+message GetServerResponse {
+  // The Server that corresponds to the requested server_id.  This field
+  // should be set.
+  Server server = 1;
+}
+
+message GetServerSocketsRequest {
+  int64 server_id = 1;
+  // start_socket_id indicates that only sockets at or above this id should be
+  // included in the results.
+  // To request the first page, this must be set to 0. To request
+  // subsequent pages, the client generates this value by adding 1 to
+  // the highest seen result ID.
+  int64 start_socket_id = 2;
+
+  // If non-zero, the server will return a page of results containing
+  // at most this many items. If zero, the server will choose a
+  // reasonable page size.  Must never be negative.
+  int64 max_results = 3;
+}
+
+message GetServerSocketsResponse {
+  // list of socket refs that the connection detail service knows about.  Sorted in
+  // ascending socket_id order.
+  // Must contain at least 1 result, otherwise 'end' must be true.
+  repeated SocketRef socket_ref = 1;
+  // If set, indicates that the list of sockets is the final list.  Requesting
+  // more sockets will only return more if they are created after this RPC
+  // completes.
+  bool end = 2;
+}
+
+message GetChannelRequest {
+  // channel_id is the identifier of the specific channel to get.
+  int64 channel_id = 1;
+}
+
+message GetChannelResponse {
+  // The Channel that corresponds to the requested channel_id.  This field
+  // should be set.
+  Channel channel = 1;
+}
+
+message GetSubchannelRequest {
+  // subchannel_id is the identifier of the specific subchannel to get.
+  int64 subchannel_id = 1;
+}
+
+message GetSubchannelResponse {
+  // The Subchannel that corresponds to the requested subchannel_id.  This
+  // field should be set.
+  Subchannel subchannel = 1;
+}
+
+message GetSocketRequest {
+  // socket_id is the identifier of the specific socket to get.
+  int64 socket_id = 1;
+
+  // If true, the response will contain only high level information
+  // that is inexpensive to obtain. Fields thay may be omitted are
+  // documented.
+  bool summary = 2;
+}
+
+message GetSocketResponse {
+  // The Socket that corresponds to the requested socket_id.  This field
+  // should be set.
+  Socket socket = 1;
+}
diff --git a/services/src/main/proto/grpc/health/v1/health.proto b/services/src/main/proto/grpc/health/v1/health.proto
new file mode 100644
index 00000000000..38843ff1e73
--- /dev/null
+++ b/services/src/main/proto/grpc/health/v1/health.proto
@@ -0,0 +1,63 @@
+// Copyright 2015 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.
+
+// The canonical version of this proto can be found at
+// https://github.com/grpc/grpc-proto/blob/master/grpc/health/v1/health.proto
+
+syntax = "proto3";
+
+package grpc.health.v1;
+
+option csharp_namespace = "Grpc.Health.V1";
+option go_package = "google.golang.org/grpc/health/grpc_health_v1";
+option java_multiple_files = true;
+option java_outer_classname = "HealthProto";
+option java_package = "io.grpc.health.v1";
+
+message HealthCheckRequest {
+  string service = 1;
+}
+
+message HealthCheckResponse {
+  enum ServingStatus {
+    UNKNOWN = 0;
+    SERVING = 1;
+    NOT_SERVING = 2;
+    SERVICE_UNKNOWN = 3;  // Used only by the Watch method.
+  }
+  ServingStatus status = 1;
+}
+
+service Health {
+  // If the requested service is unknown, the call will fail with status
+  // NOT_FOUND.
+  rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
+
+  // Performs a watch for the serving status of the requested service.
+  // The server will immediately send back a message indicating the current
+  // serving status.  It will then subsequently send a new message whenever
+  // the service's serving status changes.
+  //
+  // If the requested service is unknown when the call is received, the
+  // server will send a message setting the serving status to
+  // SERVICE_UNKNOWN but will *not* terminate the call.  If at some
+  // future point, the serving status of the service becomes known, the
+  // server will send a new message with the service's serving status.
+  //
+  // If the call terminates with status UNIMPLEMENTED, then clients
+  // should assume this method is not supported and should not retry the
+  // call.  If the call terminates with any other status (including OK),
+  // clients should retry the call with appropriate exponential backoff.
+  rpc Watch(HealthCheckRequest) returns (stream HealthCheckResponse);
+}
diff --git a/services/src/main/proto/grpc/reflection/v1/reflection.proto b/services/src/main/proto/grpc/reflection/v1/reflection.proto
new file mode 100644
index 00000000000..1a2ceedc3d2
--- /dev/null
+++ b/services/src/main/proto/grpc/reflection/v1/reflection.proto
@@ -0,0 +1,147 @@
+// Copyright 2016 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.
+
+// Service exported by server reflection.  A more complete description of how
+// server reflection works can be found at
+// https://github.com/grpc/grpc/blob/master/doc/server-reflection.md
+//
+// The canonical version of this proto can be found at
+// https://github.com/grpc/grpc-proto/blob/master/grpc/reflection/v1/reflection.proto
+
+syntax = "proto3";
+
+package grpc.reflection.v1;
+
+option go_package = "google.golang.org/grpc/reflection/grpc_reflection_v1";
+option java_multiple_files = true;
+option java_package = "io.grpc.reflection.v1";
+option java_outer_classname = "ServerReflectionProto";
+
+service ServerReflection {
+  // The reflection service is structured as a bidirectional stream, ensuring
+  // all related requests go to a single server.
+  rpc ServerReflectionInfo(stream ServerReflectionRequest)
+      returns (stream ServerReflectionResponse);
+}
+
+// The message sent by the client when calling ServerReflectionInfo method.
+message ServerReflectionRequest {
+  string host = 1;
+  // To use reflection service, the client should set one of the following
+  // fields in message_request. The server distinguishes requests by their
+  // defined field and then handles them using corresponding methods.
+  oneof message_request {
+    // Find a proto file by the file name.
+    string file_by_filename = 3;
+
+    // Find the proto file that declares the given fully-qualified symbol name.
+    // This field should be a fully-qualified symbol name
+    // (e.g. <package>.<service>[.<method>] or <package>.<type>).
+    string file_containing_symbol = 4;
+
+    // Find the proto file which defines an extension extending the given
+    // message type with the given field number.
+    ExtensionRequest file_containing_extension = 5;
+
+    // Finds the tag numbers used by all known extensions of the given message
+    // type, and appends them to ExtensionNumberResponse in an undefined order.
+    // Its corresponding method is best-effort: it's not guaranteed that the
+    // reflection service will implement this method, and it's not guaranteed
+    // that this method will provide all extensions. Returns
+    // StatusCode::UNIMPLEMENTED if it's not implemented.
+    // This field should be a fully-qualified type name. The format is
+    // <package>.<type>
+    string all_extension_numbers_of_type = 6;
+
+    // List the full names of registered services. The content will not be
+    // checked.
+    string list_services = 7;
+  }
+}
+
+// The type name and extension number sent by the client when requesting
+// file_containing_extension.
+message ExtensionRequest {
+  // Fully-qualified type name. The format should be <package>.<type>
+  string containing_type = 1;
+  int32 extension_number = 2;
+}
+
+// The message sent by the server to answer ServerReflectionInfo method.
+message ServerReflectionResponse {
+  string valid_host = 1;
+  ServerReflectionRequest original_request = 2;
+  // The server sets one of the following fields according to the message_request
+  // in the request.
+  oneof message_response {
+    // This message is used to answer file_by_filename, file_containing_symbol,
+    // file_containing_extension requests with transitive dependencies.
+    // As the repeated label is not allowed in oneof fields, we use a
+    // FileDescriptorResponse message to encapsulate the repeated fields.
+    // The reflection service is allowed to avoid sending FileDescriptorProtos
+    // that were previously sent in response to earlier requests in the stream.
+    FileDescriptorResponse file_descriptor_response = 4;
+
+    // This message is used to answer all_extension_numbers_of_type requests.
+    ExtensionNumberResponse all_extension_numbers_response = 5;
+
+    // This message is used to answer list_services requests.
+    ListServiceResponse list_services_response = 6;
+
+    // This message is used when an error occurs.
+    ErrorResponse error_response = 7;
+  }
+}
+
+// Serialized FileDescriptorProto messages sent by the server answering
+// a file_by_filename, file_containing_symbol, or file_containing_extension
+// request.
+message FileDescriptorResponse {
+  // Serialized FileDescriptorProto messages. We avoid taking a dependency on
+  // descriptor.proto, which uses proto2 only features, by making them opaque
+  // bytes instead.
+  repeated bytes file_descriptor_proto = 1;
+}
+
+// A list of extension numbers sent by the server answering
+// all_extension_numbers_of_type request.
+message ExtensionNumberResponse {
+  // Full name of the base type, including the package name. The format
+  // is <package>.<type>
+  string base_type_name = 1;
+  repeated int32 extension_number = 2;
+}
+
+// A list of ServiceResponse sent by the server answering list_services request.
+message ListServiceResponse {
+  // The information of each service may be expanded in the future, so we use
+  // ServiceResponse message to encapsulate it.
+  repeated ServiceResponse service = 1;
+}
+
+// The information of a single service used by ListServiceResponse to answer
+// list_services request.
+message ServiceResponse {
+  // Full name of a registered service, including its package name. The format
+  // is <package>.<service>
+  string name = 1;
+}
+
+// The error code and error message sent by the server when an error occurs.
+message ErrorResponse {
+  // This field uses the error codes defined in grpc::StatusCode.
+  int32 error_code = 1;
+  string error_message = 2;
+}
+
diff --git a/services/src/main/proto/grpc/reflection/v1alpha/reflection.proto b/services/src/main/proto/grpc/reflection/v1alpha/reflection.proto
new file mode 100644
index 00000000000..a3984b55c2d
--- /dev/null
+++ b/services/src/main/proto/grpc/reflection/v1alpha/reflection.proto
@@ -0,0 +1,144 @@
+// Copyright 2016 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.
+// Service exported by server reflection
+
+
+// Warning: this entire file is deprecated. Use this instead:
+// https://github.com/grpc/grpc-proto/blob/master/grpc/reflection/v1/reflection.proto
+
+syntax = "proto3";
+
+package grpc.reflection.v1alpha;
+
+option deprecated = true;
+option java_multiple_files = true;
+option java_package = "io.grpc.reflection.v1alpha";
+option java_outer_classname = "ServerReflectionProto";
+
+service ServerReflection {
+  // The reflection service is structured as a bidirectional stream, ensuring
+  // all related requests go to a single server.
+  rpc ServerReflectionInfo(stream ServerReflectionRequest)
+      returns (stream ServerReflectionResponse);
+}
+
+// The message sent by the client when calling ServerReflectionInfo method.
+message ServerReflectionRequest {
+  string host = 1;
+  // To use reflection service, the client should set one of the following
+  // fields in message_request. The server distinguishes requests by their
+  // defined field and then handles them using corresponding methods.
+  oneof message_request {
+    // Find a proto file by the file name.
+    string file_by_filename = 3;
+
+    // Find the proto file that declares the given fully-qualified symbol name.
+    // This field should be a fully-qualified symbol name
+    // (e.g. <package>.<service>[.<method>] or <package>.<type>).
+    string file_containing_symbol = 4;
+
+    // Find the proto file which defines an extension extending the given
+    // message type with the given field number.
+    ExtensionRequest file_containing_extension = 5;
+
+    // Finds the tag numbers used by all known extensions of extendee_type, and
+    // appends them to ExtensionNumberResponse in an undefined order.
+    // Its corresponding method is best-effort: it's not guaranteed that the
+    // reflection service will implement this method, and it's not guaranteed
+    // that this method will provide all extensions. Returns
+    // StatusCode::UNIMPLEMENTED if it's not implemented.
+    // This field should be a fully-qualified type name. The format is
+    // <package>.<type>
+    string all_extension_numbers_of_type = 6;
+
+    // List the full names of registered services. The content will not be
+    // checked.
+    string list_services = 7;
+  }
+}
+
+// The type name and extension number sent by the client when requesting
+// file_containing_extension.
+message ExtensionRequest {
+  // Fully-qualified type name. The format should be <package>.<type>
+  string containing_type = 1;
+  int32 extension_number = 2;
+}
+
+// The message sent by the server to answer ServerReflectionInfo method.
+message ServerReflectionResponse {
+  string valid_host = 1;
+  ServerReflectionRequest original_request = 2;
+  // The server set one of the following fields according to the message_request
+  // in the request.
+  oneof message_response {
+    // This message is used to answer file_by_filename, file_containing_symbol,
+    // file_containing_extension requests with transitive dependencies. As
+    // the repeated label is not allowed in oneof fields, we use a
+    // FileDescriptorResponse message to encapsulate the repeated fields.
+    // The reflection service is allowed to avoid sending FileDescriptorProtos
+    // that were previously sent in response to earlier requests in the stream.
+    FileDescriptorResponse file_descriptor_response = 4;
+
+    // This message is used to answer all_extension_numbers_of_type request.
+    ExtensionNumberResponse all_extension_numbers_response = 5;
+
+    // This message is used to answer list_services request.
+    ListServiceResponse list_services_response = 6;
+
+    // This message is used when an error occurs.
+    ErrorResponse error_response = 7;
+  }
+}
+
+// Serialized FileDescriptorProto messages sent by the server answering
+// a file_by_filename, file_containing_symbol, or file_containing_extension
+// request.
+message FileDescriptorResponse {
+  // Serialized FileDescriptorProto messages. We avoid taking a dependency on
+  // descriptor.proto, which uses proto2 only features, by making them opaque
+  // bytes instead.
+  repeated bytes file_descriptor_proto = 1;
+}
+
+// A list of extension numbers sent by the server answering
+// all_extension_numbers_of_type request.
+message ExtensionNumberResponse {
+  // Full name of the base type, including the package name. The format
+  // is <package>.<type>
+  string base_type_name = 1;
+  repeated int32 extension_number = 2;
+}
+
+// A list of ServiceResponse sent by the server answering list_services request.
+message ListServiceResponse {
+  // The information of each service may be expanded in the future, so we use
+  // ServiceResponse message to encapsulate it.
+  repeated ServiceResponse service = 1;
+}
+
+// The information of a single service used by ListServiceResponse to answer
+// list_services request.
+message ServiceResponse {
+  // Full name of a registered service, including its package name. The format
+  // is <package>.<service>
+  string name = 1;
+}
+
+// The error code and error message sent by the server when an error occurs.
+message ErrorResponse {
+  // This field uses the error codes defined in grpc::StatusCode.
+  int32 error_code = 1;
+  string error_message = 2;
+}
diff --git a/services/src/main/proto/health.proto b/services/src/main/proto/health.proto
deleted file mode 100644
index bfe6a094d76..00000000000
--- a/services/src/main/proto/health.proto
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto3";
-
-package grpc.health.v1;
-option csharp_namespace = "Grpc.Health.V1";
-
-option java_multiple_files = true;
-option java_package = "io.grpc.health.v1";
-option java_outer_classname = "HealthProto";
-
-message HealthCheckRequest {
-  string service = 1;
-}
-
-message HealthCheckResponse {
-  enum ServingStatus {
-    UNKNOWN = 0;
-    SERVING = 1;
-    NOT_SERVING = 2;
-  }
-  ServingStatus status = 1;
-}
-
-service Health {
-  rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
-}
diff --git a/services/src/main/proto/io/grpc/reflection/v1alpha/reflection.proto b/services/src/main/proto/io/grpc/reflection/v1alpha/reflection.proto
deleted file mode 100644
index 7f07894b717..00000000000
--- a/services/src/main/proto/io/grpc/reflection/v1alpha/reflection.proto
+++ /dev/null
@@ -1,155 +0,0 @@
-// Copyright 2016, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Service exported by server reflection
-
-syntax = "proto3";
-
-package grpc.reflection.v1alpha;
-
-option java_multiple_files = true;
-option java_package = "io.grpc.reflection.v1alpha";
-option java_outer_classname = "ServerReflectionProto";
-
-service ServerReflection {
-  // The reflection service is structured as a bidirectional stream, ensuring
-  // all related requests go to a single server.
-  rpc ServerReflectionInfo(stream ServerReflectionRequest)
-      returns (stream ServerReflectionResponse);
-}
-
-// The message sent by the client when calling ServerReflectionInfo method.
-message ServerReflectionRequest {
-  string host = 1;
-  // To use reflection service, the client should set one of the following
-  // fields in message_request. The server distinguishes requests by their
-  // defined field and then handles them using corresponding methods.
-  oneof message_request {
-    // Find a proto file by the file name.
-    string file_by_filename = 3;
-
-    // Find the proto file that declares the given fully-qualified symbol name.
-    // This field should be a fully-qualified symbol name
-    // (e.g. <package>.<service>[.<method>] or <package>.<type>).
-    string file_containing_symbol = 4;
-
-    // Find the proto file which defines an extension extending the given
-    // message type with the given field number.
-    ExtensionRequest file_containing_extension = 5;
-
-    // Finds the tag numbers used by all known extensions of extendee_type, and
-    // appends them to ExtensionNumberResponse in an undefined order.
-    // Its corresponding method is best-effort: it's not guaranteed that the
-    // reflection service will implement this method, and it's not guaranteed
-    // that this method will provide all extensions. Returns
-    // StatusCode::UNIMPLEMENTED if it's not implemented.
-    // This field should be a fully-qualified type name. The format is
-    // <package>.<type>
-    string all_extension_numbers_of_type = 6;
-
-    // List the full names of registered services. The content will not be
-    // checked.
-    string list_services = 7;
-  }
-}
-
-// The type name and extension number sent by the client when requesting
-// file_containing_extension.
-message ExtensionRequest {
-  // Fully-qualified type name. The format should be <package>.<type>
-  string containing_type = 1;
-  int32 extension_number = 2;
-}
-
-// The message sent by the server to answer ServerReflectionInfo method.
-message ServerReflectionResponse {
-  string valid_host = 1;
-  ServerReflectionRequest original_request = 2;
-  // The server set one of the following fields accroding to the message_request
-  // in the request.
-  oneof message_response {
-    // This message is used to answer file_by_filename, file_containing_symbol,
-    // file_containing_extension requests with transitive dependencies. As
-    // the repeated label is not allowed in oneof fields, we use a
-    // FileDescriptorResponse message to encapsulate the repeated fields.
-    // The reflection service is allowed to avoid sending FileDescriptorProtos
-    // that were previously sent in response to earlier requests in the stream.
-    FileDescriptorResponse file_descriptor_response = 4;
-
-    // This message is used to answer all_extension_numbers_of_type requst.
-    ExtensionNumberResponse all_extension_numbers_response = 5;
-
-    // This message is used to answer list_services request.
-    ListServiceResponse list_services_response = 6;
-
-    // This message is used when an error occurs.
-    ErrorResponse error_response = 7;
-  }
-}
-
-// Serialized FileDescriptorProto messages sent by the server answering
-// a file_by_filename, file_containing_symbol, or file_containing_extension
-// request.
-message FileDescriptorResponse {
-  // Serialized FileDescriptorProto messages. We avoid taking a dependency on
-  // descriptor.proto, which uses proto2 only features, by making them opaque
-  // bytes instead.
-  repeated bytes file_descriptor_proto = 1;
-}
-
-// A list of extension numbers sent by the server answering
-// all_extension_numbers_of_type request.
-message ExtensionNumberResponse {
-  // Full name of the base type, including the package name. The format
-  // is <package>.<type>
-  string base_type_name = 1;
-  repeated int32 extension_number = 2;
-}
-
-// A list of ServiceResponse sent by the server answering list_services request.
-message ListServiceResponse {
-  // The information of each service may be expanded in the future, so we use
-  // ServiceResponse message to encapsulate it.
-  repeated ServiceResponse service = 1;
-}
-
-// The information of a single service used by ListServiceResponse to answer
-// list_services request.
-message ServiceResponse {
-  // Full name of a registered service, including its package name. The format
-  // is <package>.<service>
-  string name = 1;
-}
-
-// The error code and error message sent by the server when an error occurs.
-message ErrorResponse {
-  // This field uses the error codes defined in grpc::StatusCode.
-  int32 error_code = 1;
-  string error_message = 2;
-}
diff --git a/services/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider b/services/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
new file mode 100644
index 00000000000..d3e5f85ffbb
--- /dev/null
+++ b/services/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
@@ -0,0 +1 @@
+io.grpc.protobuf.services.internal.HealthCheckingRoundRobinLoadBalancerProvider
diff --git a/services/src/test/java/io/grpc/protobuf/service/ProtoReflectionServiceTest.java b/services/src/test/java/io/grpc/protobuf/service/ProtoReflectionServiceTest.java
deleted file mode 100644
index 5c4e8141bd2..00000000000
--- a/services/src/test/java/io/grpc/protobuf/service/ProtoReflectionServiceTest.java
+++ /dev/null
@@ -1,600 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.protobuf.service;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-import com.google.protobuf.ByteString;
-import io.grpc.BindableService;
-import io.grpc.ManagedChannel;
-import io.grpc.Server;
-import io.grpc.ServerServiceDefinition;
-import io.grpc.inprocess.InProcessChannelBuilder;
-import io.grpc.inprocess.InProcessServerBuilder;
-import io.grpc.reflection.testing.AnotherDynamicServiceGrpc;
-import io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto;
-import io.grpc.reflection.testing.DynamicServiceGrpc;
-import io.grpc.reflection.testing.ReflectableServiceGrpc;
-import io.grpc.reflection.testing.ReflectionTestDepthThreeProto;
-import io.grpc.reflection.testing.ReflectionTestDepthTwoAlternateProto;
-import io.grpc.reflection.testing.ReflectionTestDepthTwoProto;
-import io.grpc.reflection.testing.ReflectionTestProto;
-import io.grpc.reflection.v1alpha.ExtensionNumberResponse;
-import io.grpc.reflection.v1alpha.ExtensionRequest;
-import io.grpc.reflection.v1alpha.FileDescriptorResponse;
-import io.grpc.reflection.v1alpha.ServerReflectionGrpc;
-import io.grpc.reflection.v1alpha.ServerReflectionRequest;
-import io.grpc.reflection.v1alpha.ServerReflectionResponse;
-import io.grpc.reflection.v1alpha.ServiceResponse;
-import io.grpc.stub.ClientCallStreamObserver;
-import io.grpc.stub.ClientResponseObserver;
-import io.grpc.stub.StreamObserver;
-import io.grpc.testing.StreamRecorder;
-import io.grpc.util.MutableHandlerRegistry;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/**
- * Tests for {@link ProtoReflectionService}.
- */
-@RunWith(JUnit4.class)
-public class ProtoReflectionServiceTest {
-  private static final String TEST_HOST = "localhost";
-  private MutableHandlerRegistry handlerRegistry = new MutableHandlerRegistry();
-  private BindableService reflectionService;
-  private ServerServiceDefinition dynamicService =
-      (new DynamicServiceGrpc.DynamicServiceImplBase() {}).bindService();
-  private ServerServiceDefinition anotherDynamicService =
-      (new AnotherDynamicServiceGrpc.AnotherDynamicServiceImplBase() {}).bindService();
-  private Server server;
-  private ManagedChannel channel;
-  private ServerReflectionGrpc.ServerReflectionStub stub;
-
-  @Before
-  public void setUp() throws Exception {
-    reflectionService = ProtoReflectionService.getInstance();
-    server = InProcessServerBuilder.forName("proto-reflection-test")
-        .directExecutor()
-        .addService(reflectionService)
-        .addService(new ReflectableServiceGrpc.ReflectableServiceImplBase() {})
-        .fallbackHandlerRegistry(handlerRegistry)
-        .build()
-        .start();
-    channel = InProcessChannelBuilder.forName("proto-reflection-test")
-        .directExecutor()
-        .build();
-    stub = ServerReflectionGrpc.newStub(channel);
-  }
-
-  @After
-  public void tearDown() {
-    if (server != null) {
-      server.shutdownNow();
-    }
-    if (channel != null) {
-      channel.shutdownNow();
-    }
-  }
-
-  @Test
-  public void listServices() throws Exception {
-    Set<ServiceResponse> originalServices = new HashSet<ServiceResponse>(
-        Arrays.asList(
-            ServiceResponse.newBuilder()
-                .setName("grpc.reflection.v1alpha.ServerReflection")
-                .build(),
-            ServiceResponse.newBuilder()
-                .setName("grpc.reflection.testing.ReflectableService")
-                .build())
-    );
-    assertServiceResponseEquals(originalServices);
-
-    handlerRegistry.addService(dynamicService);
-    assertServiceResponseEquals(new HashSet<ServiceResponse>(
-        Arrays.asList(
-            ServiceResponse.newBuilder()
-                .setName("grpc.reflection.v1alpha.ServerReflection")
-                .build(),
-            ServiceResponse.newBuilder()
-                .setName("grpc.reflection.testing.ReflectableService")
-                .build(),
-            ServiceResponse.newBuilder()
-                .setName("grpc.reflection.testing.DynamicService")
-                .build())
-    ));
-
-    handlerRegistry.addService(anotherDynamicService);
-    assertServiceResponseEquals(new HashSet<ServiceResponse>(
-        Arrays.asList(
-            ServiceResponse.newBuilder()
-                .setName("grpc.reflection.v1alpha.ServerReflection")
-                .build(),
-            ServiceResponse.newBuilder()
-                .setName("grpc.reflection.testing.ReflectableService")
-                .build(),
-            ServiceResponse.newBuilder()
-                .setName("grpc.reflection.testing.DynamicService")
-                .build(),
-            ServiceResponse.newBuilder()
-                .setName("grpc.reflection.testing.AnotherDynamicService")
-                .build())
-    ));
-
-    handlerRegistry.removeService(dynamicService);
-    assertServiceResponseEquals(new HashSet<ServiceResponse>(
-        Arrays.asList(
-            ServiceResponse.newBuilder()
-                .setName("grpc.reflection.v1alpha.ServerReflection")
-                .build(),
-            ServiceResponse.newBuilder()
-                .setName("grpc.reflection.testing.ReflectableService")
-                .build(),
-            ServiceResponse.newBuilder()
-                .setName("grpc.reflection.testing.AnotherDynamicService")
-                .build())
-    ));
-
-    handlerRegistry.removeService(anotherDynamicService);
-    assertServiceResponseEquals(originalServices);
-  }
-
-  @Test
-  public void fileByFilename() throws Exception {
-    ServerReflectionRequest request =
-        ServerReflectionRequest.newBuilder()
-            .setHost(TEST_HOST)
-            .setFileByFilename("io/grpc/reflection/testing/reflection_test_depth_three.proto")
-            .build();
-
-    ServerReflectionResponse goldenResponse =
-        ServerReflectionResponse.newBuilder()
-            .setValidHost(TEST_HOST)
-            .setOriginalRequest(request)
-            .setFileDescriptorResponse(
-                FileDescriptorResponse.newBuilder()
-                    .addFileDescriptorProto(
-                        ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString())
-                    .build())
-            .build();
-
-    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
-    StreamObserver<ServerReflectionRequest> requestObserver =
-        stub.serverReflectionInfo(responseObserver);
-    requestObserver.onNext(request);
-    requestObserver.onCompleted();
-
-    assertEquals(goldenResponse, responseObserver.firstValue().get());
-  }
-
-  @Test
-  public void fileByFilenameForMutableServices() throws Exception {
-    ServerReflectionRequest request =
-        ServerReflectionRequest.newBuilder()
-            .setHost(TEST_HOST)
-            .setFileByFilename("io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto")
-            .build();
-    ServerReflectionResponse goldenResponse =
-        ServerReflectionResponse.newBuilder()
-            .setValidHost(TEST_HOST)
-            .setOriginalRequest(request)
-            .setFileDescriptorResponse(
-                FileDescriptorResponse.newBuilder()
-                    .addFileDescriptorProto(
-                        DynamicReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString())
-                    .build())
-            .build();
-
-    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
-    StreamObserver<ServerReflectionRequest> requestObserver =
-        stub.serverReflectionInfo(responseObserver);
-    handlerRegistry.addService(dynamicService);
-    requestObserver.onNext(request);
-    handlerRegistry.removeService(dynamicService);
-    requestObserver.onNext(request);
-    requestObserver.onCompleted();
-
-    assertEquals(goldenResponse, responseObserver.getValues().get(0));
-    assertEquals(ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
-        responseObserver.getValues().get(1).getMessageResponseCase());
-  }
-
-  @Test
-  public void fileContainingSymbol() throws Exception {
-    ServerReflectionRequest request =
-        ServerReflectionRequest.newBuilder()
-            .setHost(TEST_HOST)
-            .setFileContainingSymbol("grpc.reflection.testing.ReflectableService.Method")
-            .build();
-
-    List<ByteString> goldenResponse =
-        Arrays.asList(
-            ReflectionTestProto.getDescriptor().toProto().toByteString(),
-            ReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString(),
-            ReflectionTestDepthTwoAlternateProto.getDescriptor().toProto().toByteString(),
-            ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString()
-        );
-
-    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
-    StreamObserver<ServerReflectionRequest> requestObserver =
-        stub.serverReflectionInfo(responseObserver);
-    requestObserver.onNext(request);
-    requestObserver.onCompleted();
-
-    List<ByteString> response =
-        responseObserver.firstValue().get()
-            .getFileDescriptorResponse().getFileDescriptorProtoList();
-    assertEquals(goldenResponse.size(), response.size());
-    assertEquals(new HashSet<ByteString>(goldenResponse), new HashSet<ByteString>(response));
-  }
-
-  @Test
-  public void fileContainingNestedSymbol() throws Exception {
-    ServerReflectionRequest request =
-        ServerReflectionRequest.newBuilder()
-            .setHost(TEST_HOST)
-            .setFileContainingSymbol("grpc.reflection.testing.NestedTypeOuter.Middle.Inner")
-            .build();
-
-    ServerReflectionResponse goldenResponse =
-        ServerReflectionResponse.newBuilder()
-            .setValidHost(TEST_HOST)
-            .setOriginalRequest(request)
-            .setFileDescriptorResponse(
-                FileDescriptorResponse.newBuilder()
-                    .addFileDescriptorProto(
-                        ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString())
-                    .build())
-            .build();
-
-    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
-    StreamObserver<ServerReflectionRequest> requestObserver =
-        stub.serverReflectionInfo(responseObserver);
-    requestObserver.onNext(request);
-    requestObserver.onCompleted();
-    assertEquals(goldenResponse, responseObserver.firstValue().get());
-  }
-
-  @Test
-  public void fileContainingSymbolForMutableServices() throws Exception {
-    ServerReflectionRequest request =
-        ServerReflectionRequest.newBuilder()
-            .setHost(TEST_HOST)
-            .setFileContainingSymbol("grpc.reflection.testing.DynamicRequest")
-            .build();
-    ServerReflectionResponse goldenResponse =
-        ServerReflectionResponse.newBuilder()
-            .setValidHost(TEST_HOST)
-            .setOriginalRequest(request)
-            .setFileDescriptorResponse(
-                FileDescriptorResponse.newBuilder()
-                    .addFileDescriptorProto(
-                        DynamicReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString())
-                    .build())
-            .build();
-
-    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
-    StreamObserver<ServerReflectionRequest> requestObserver =
-        stub.serverReflectionInfo(responseObserver);
-    handlerRegistry.addService(dynamicService);
-    requestObserver.onNext(request);
-    handlerRegistry.removeService(dynamicService);
-    requestObserver.onNext(request);
-    requestObserver.onCompleted();
-
-    assertEquals(goldenResponse, responseObserver.getValues().get(0));
-    assertEquals(ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
-        responseObserver.getValues().get(1).getMessageResponseCase());
-  }
-
-  @Test
-  public void fileContainingExtension() throws Exception {
-    ServerReflectionRequest request =
-        ServerReflectionRequest.newBuilder()
-            .setHost(TEST_HOST)
-            .setFileContainingExtension(
-                ExtensionRequest.newBuilder()
-                    .setContainingType("grpc.reflection.testing.ThirdLevelType")
-                    .setExtensionNumber(100)
-                    .build())
-            .build();
-
-    List<ByteString> goldenResponse =
-        Arrays.asList(
-            ReflectionTestProto.getDescriptor().toProto().toByteString(),
-            ReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString(),
-            ReflectionTestDepthTwoAlternateProto.getDescriptor().toProto().toByteString(),
-            ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString()
-        );
-
-    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
-    StreamObserver<ServerReflectionRequest> requestObserver =
-        stub.serverReflectionInfo(responseObserver);
-    requestObserver.onNext(request);
-    requestObserver.onCompleted();
-
-    List<ByteString> response =
-        responseObserver.firstValue().get()
-            .getFileDescriptorResponse().getFileDescriptorProtoList();
-    assertEquals(goldenResponse.size(), response.size());
-    assertEquals(new HashSet<ByteString>(goldenResponse), new HashSet<ByteString>(response));
-  }
-
-  @Test
-  public void fileContainingNestedExtension() throws Exception {
-    ServerReflectionRequest request =
-        ServerReflectionRequest.newBuilder()
-            .setHost(TEST_HOST)
-            .setFileContainingExtension(
-                ExtensionRequest.newBuilder()
-                    .setContainingType("grpc.reflection.testing.ThirdLevelType")
-                    .setExtensionNumber(101)
-                    .build())
-            .build();
-
-    ServerReflectionResponse goldenResponse =
-        ServerReflectionResponse.newBuilder()
-            .setValidHost(TEST_HOST)
-            .setOriginalRequest(request)
-            .setFileDescriptorResponse(
-                FileDescriptorResponse.newBuilder()
-                    .addFileDescriptorProto(
-                        ReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString())
-                    .addFileDescriptorProto(
-                        ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString())
-                    .build())
-            .build();
-
-    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
-    StreamObserver<ServerReflectionRequest> requestObserver =
-        stub.serverReflectionInfo(responseObserver);
-    requestObserver.onNext(request);
-    requestObserver.onCompleted();
-    assertEquals(goldenResponse, responseObserver.firstValue().get());
-  }
-
-  @Test
-  public void fileContainingExtensionForMutableServices() throws Exception {
-    ServerReflectionRequest request =
-        ServerReflectionRequest.newBuilder()
-            .setHost(TEST_HOST)
-            .setFileContainingExtension(
-                ExtensionRequest.newBuilder()
-                    .setContainingType("grpc.reflection.testing.TypeWithExtensions")
-                    .setExtensionNumber(200)
-                    .build())
-            .build();
-    ServerReflectionResponse goldenResponse =
-        ServerReflectionResponse.newBuilder()
-            .setValidHost(TEST_HOST)
-            .setOriginalRequest(request)
-            .setFileDescriptorResponse(
-                FileDescriptorResponse.newBuilder()
-                    .addFileDescriptorProto(
-                        DynamicReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString())
-                    .build())
-            .build();
-
-    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
-    StreamObserver<ServerReflectionRequest> requestObserver =
-        stub.serverReflectionInfo(responseObserver);
-    handlerRegistry.addService(dynamicService);
-    requestObserver.onNext(request);
-    handlerRegistry.removeService(dynamicService);
-    requestObserver.onNext(request);
-    requestObserver.onCompleted();
-
-    assertEquals(goldenResponse, responseObserver.getValues().get(0));
-    assertEquals(ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
-        responseObserver.getValues().get(1).getMessageResponseCase());
-  }
-
-  @Test
-  public void allExtensionNumbersOfType() throws Exception {
-    ServerReflectionRequest request =
-        ServerReflectionRequest.newBuilder()
-            .setHost(TEST_HOST)
-            .setAllExtensionNumbersOfType("grpc.reflection.testing.ThirdLevelType")
-            .build();
-
-    Set<Integer> goldenResponse = new HashSet<Integer>(Arrays.asList(100, 101));
-
-    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
-    StreamObserver<ServerReflectionRequest> requestObserver =
-        stub.serverReflectionInfo(responseObserver);
-    requestObserver.onNext(request);
-    requestObserver.onCompleted();
-    Set<Integer> extensionNumberResponseSet =
-        new HashSet<Integer>(
-            responseObserver
-                .firstValue()
-                .get()
-                .getAllExtensionNumbersResponse()
-                .getExtensionNumberList());
-    assertEquals(goldenResponse, extensionNumberResponseSet);
-  }
-
-  @Test
-  public void allExtensionNumbersOfTypeForMutableServices() throws Exception {
-    String type = "grpc.reflection.testing.TypeWithExtensions";
-    ServerReflectionRequest request =
-        ServerReflectionRequest.newBuilder()
-            .setHost(TEST_HOST)
-            .setAllExtensionNumbersOfType(type)
-            .build();
-    ServerReflectionResponse goldenResponse =
-        ServerReflectionResponse.newBuilder()
-            .setValidHost(TEST_HOST)
-            .setOriginalRequest(request)
-            .setAllExtensionNumbersResponse(
-                ExtensionNumberResponse.newBuilder()
-                    .setBaseTypeName(type)
-                    .addExtensionNumber(200)
-                    .build())
-            .build();
-
-    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
-    StreamObserver<ServerReflectionRequest> requestObserver =
-        stub.serverReflectionInfo(responseObserver);
-    handlerRegistry.addService(dynamicService);
-    requestObserver.onNext(request);
-    handlerRegistry.removeService(dynamicService);
-    requestObserver.onNext(request);
-    requestObserver.onCompleted();
-
-    assertEquals(goldenResponse, responseObserver.getValues().get(0));
-    assertEquals(ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
-        responseObserver.getValues().get(1).getMessageResponseCase());
-  }
-
-  @Test
-  public void flowControl() throws Exception {
-    FlowControlClientResponseObserver clientResponseObserver =
-        new FlowControlClientResponseObserver();
-    ClientCallStreamObserver<ServerReflectionRequest> requestObserver =
-        (ClientCallStreamObserver<ServerReflectionRequest>)
-            stub.serverReflectionInfo(clientResponseObserver);
-
-    // ClientCalls.startCall() calls request(1) initially, so we should get an immediate response.
-    requestObserver.onNext(flowControlRequest);
-    assertEquals(1, clientResponseObserver.getResponses().size());
-    assertEquals(flowControlGoldenResponse, clientResponseObserver.getResponses().get(0));
-
-    // Verify we don't receive an additional response until we request it.
-    requestObserver.onNext(flowControlRequest);
-    assertEquals(1, clientResponseObserver.getResponses().size());
-
-    requestObserver.request(1);
-    assertEquals(2, clientResponseObserver.getResponses().size());
-    assertEquals(flowControlGoldenResponse, clientResponseObserver.getResponses().get(1));
-
-    requestObserver.onCompleted();
-    assertTrue(clientResponseObserver.onCompleteCalled());
-  }
-
-  @Test
-  public void flowControlOnCompleteWithPendingRequest() throws Exception {
-    FlowControlClientResponseObserver clientResponseObserver =
-        new FlowControlClientResponseObserver();
-    ClientCallStreamObserver<ServerReflectionRequest> requestObserver =
-        (ClientCallStreamObserver<ServerReflectionRequest>)
-            stub.serverReflectionInfo(clientResponseObserver);
-
-    // ClientCalls.startCall() calls request(1) initially, so make additional request.
-    requestObserver.onNext(flowControlRequest);
-    requestObserver.onNext(flowControlRequest);
-    requestObserver.onCompleted();
-    assertEquals(1, clientResponseObserver.getResponses().size());
-    assertFalse(clientResponseObserver.onCompleteCalled());
-
-    requestObserver.request(1);
-    assertTrue(clientResponseObserver.onCompleteCalled());
-    assertEquals(2, clientResponseObserver.getResponses().size());
-    assertEquals(flowControlGoldenResponse, clientResponseObserver.getResponses().get(1));
-  }
-
-  private final ServerReflectionRequest flowControlRequest =
-      ServerReflectionRequest.newBuilder()
-          .setHost(TEST_HOST)
-          .setFileByFilename("io/grpc/reflection/testing/reflection_test_depth_three.proto")
-          .build();
-  private final ServerReflectionResponse flowControlGoldenResponse =
-      ServerReflectionResponse.newBuilder()
-          .setValidHost(TEST_HOST)
-          .setOriginalRequest(flowControlRequest)
-          .setFileDescriptorResponse(
-              FileDescriptorResponse.newBuilder()
-                  .addFileDescriptorProto(
-                      ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString())
-                  .build())
-          .build();
-
-  private static class FlowControlClientResponseObserver implements
-      ClientResponseObserver<ServerReflectionRequest, ServerReflectionResponse> {
-    private final List<ServerReflectionResponse> responses =
-        new ArrayList<ServerReflectionResponse>();
-    private boolean onCompleteCalled = false;
-
-    @Override
-    public void beforeStart(
-        final ClientCallStreamObserver<ServerReflectionRequest> requestStream) {
-      requestStream.disableAutoInboundFlowControl();
-    }
-
-    @Override
-    public void onNext(ServerReflectionResponse value) {
-      responses.add(value);
-    }
-
-    @Override
-    public void onError(Throwable t) {
-      fail("onError called");
-    }
-
-    @Override
-    public void onCompleted() {
-      onCompleteCalled = true;
-    }
-
-    public List<ServerReflectionResponse> getResponses() {
-      return responses;
-    }
-
-    public boolean onCompleteCalled() {
-      return onCompleteCalled;
-    }
-  }
-
-  private void assertServiceResponseEquals(Set<ServiceResponse> goldenResponse) throws Exception {
-    ServerReflectionRequest request =
-        ServerReflectionRequest.newBuilder().setHost(TEST_HOST).setListServices("services").build();
-    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
-    StreamObserver<ServerReflectionRequest> requestObserver =
-        stub.serverReflectionInfo(responseObserver);
-    requestObserver.onNext(request);
-    requestObserver.onCompleted();
-    List<ServiceResponse> response =
-        responseObserver.firstValue().get().getListServicesResponse().getServiceList();
-    assertEquals(goldenResponse.size(), response.size());
-    assertEquals(goldenResponse, new HashSet<ServiceResponse>(response));
-  }
-}
diff --git a/services/src/test/java/io/grpc/protobuf/services/BinaryLogProviderImplTest.java b/services/src/test/java/io/grpc/protobuf/services/BinaryLogProviderImplTest.java
new file mode 100644
index 00000000000..cab7dcf05e5
--- /dev/null
+++ b/services/src/test/java/io/grpc/protobuf/services/BinaryLogProviderImplTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2018 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.protobuf.services;
+
+import static org.junit.Assert.assertNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.CallOptions;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link BinaryLogProviderImpl}. */
+@RunWith(JUnit4.class)
+public class BinaryLogProviderImplTest {
+  @Test
+  public void configStrNullTest() throws Exception {
+    BinaryLogSink sink = mock(BinaryLogSink.class);
+    BinaryLogProviderImpl binlog = new BinaryLogProviderImpl(sink, /*configStr=*/ null);
+    assertNull(binlog.getServerInterceptor("package.service/method"));
+    assertNull(binlog.getClientInterceptor("package.service/method", CallOptions.DEFAULT));
+  }
+
+  @Test
+  public void configStrEmptyTest() throws Exception {
+    BinaryLogSink sink = mock(BinaryLogSink.class);
+    BinaryLogProviderImpl binlog = new BinaryLogProviderImpl(sink, "");
+    assertNull(binlog.getServerInterceptor("package.service/method"));
+    assertNull(binlog.getClientInterceptor("package.service/method", CallOptions.DEFAULT));
+  }
+
+  @Test
+  public void closeTest() throws Exception {
+    BinaryLogSink sink = mock(BinaryLogSink.class);
+    BinaryLogProviderImpl log = new BinaryLogProviderImpl(sink, "*");
+    verify(sink, never()).close();
+    log.close();
+    verify(sink).close();
+  }
+}
diff --git a/services/src/test/java/io/grpc/protobuf/services/BinaryLogProviderTest.java b/services/src/test/java/io/grpc/protobuf/services/BinaryLogProviderTest.java
new file mode 100644
index 00000000000..67b187e9d7a
--- /dev/null
+++ b/services/src/test/java/io/grpc/protobuf/services/BinaryLogProviderTest.java
@@ -0,0 +1,437 @@
+/*
+ * Copyright 2017 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.protobuf.services;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import com.google.common.io.ByteStreams;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
+import io.grpc.ForwardingServerCall.SimpleForwardingServerCall;
+import io.grpc.ForwardingServerCallListener.SimpleForwardingServerCallListener;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.Marshaller;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.NoopClientCall;
+import io.grpc.NoopServerCall;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerMethodDefinition;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link BinaryLogProvider}. */
+@RunWith(JUnit4.class)
+public class BinaryLogProviderTest {
+  private final InvocationCountMarshaller<String> reqMarshaller =
+      new InvocationCountMarshaller<String>() {
+        @Override
+        Marshaller<String> delegate() {
+          return StringMarshaller.INSTANCE;
+        }
+      };
+  private final InvocationCountMarshaller<Integer> respMarshaller =
+      new InvocationCountMarshaller<Integer>() {
+        @Override
+        Marshaller<Integer> delegate() {
+          return IntegerMarshaller.INSTANCE;
+        }
+      };
+  private final MethodDescriptor<String, Integer> method =
+      MethodDescriptor
+          .newBuilder(reqMarshaller, respMarshaller)
+          .setFullMethodName("myservice/mymethod")
+          .setType(MethodType.UNARY)
+          .setSchemaDescriptor(new Object())
+          .setIdempotent(true)
+          .setSafe(true)
+          .setSampledToLocalTracing(true)
+          .build();
+  private final List<byte[]> binlogReq = new ArrayList<>();
+  private final List<byte[]> binlogResp = new ArrayList<>();
+  private final BinaryLogProvider binlogProvider = new BinaryLogProvider() {
+    @Override
+    public ServerInterceptor getServerInterceptor(String fullMethodName) {
+      return new TestBinaryLogServerInterceptor();
+    }
+
+    @Override
+    public ClientInterceptor getClientInterceptor(
+        String fullMethodName, CallOptions callOptions) {
+      return new TestBinaryLogClientInterceptor();
+    }
+  };
+
+  @Test
+  public void wrapChannel_methodDescriptor() throws Exception {
+    final AtomicReference<MethodDescriptor<?, ?>> methodRef =
+        new AtomicReference<>();
+    Channel channel = new Channel() {
+      @Override
+      public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+          MethodDescriptor<RequestT, ResponseT> method, CallOptions callOptions) {
+        methodRef.set(method);
+        return new NoopClientCall<>();
+      }
+
+      @Override
+      public String authority() {
+        throw new UnsupportedOperationException();
+      }
+    };
+    Channel wChannel = binlogProvider.wrapChannel(channel);
+    ClientCall<String, Integer> unusedClientCall = wChannel.newCall(method, CallOptions.DEFAULT);
+    validateWrappedMethod(methodRef.get());
+  }
+
+  @Test
+  public void wrapChannel_handler() throws Exception {
+    final List<byte[]> serializedReq = new ArrayList<>();
+    final AtomicReference<ClientCall.Listener<?>> listener =
+        new AtomicReference<>();
+    Channel channel = new Channel() {
+      @Override
+      public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+          MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+        return new NoopClientCall<RequestT, ResponseT>() {
+          @Override
+          public void start(ClientCall.Listener<ResponseT> responseListener, Metadata headers) {
+            listener.set(responseListener);
+          }
+
+          @Override
+          public void sendMessage(RequestT message) {
+            serializedReq.add((byte[]) message);
+          }
+        };
+      }
+
+      @Override
+      public String authority() {
+        throw new UnsupportedOperationException();
+      }
+    };
+    Channel wChannel = binlogProvider.wrapChannel(channel);
+    ClientCall<String, Integer> clientCall = wChannel.newCall(method, CallOptions.DEFAULT);
+    final List<Integer> observedResponse = new ArrayList<>();
+    clientCall.start(
+        new NoopClientCall.NoopClientCallListener<Integer>() {
+          @Override
+          public void onMessage(Integer message) {
+            observedResponse.add(message);
+          }
+        },
+        new Metadata());
+
+    String expectedRequest = "hello world";
+    assertThat(binlogReq).isEmpty();
+    assertThat(serializedReq).isEmpty();
+    assertEquals(0, reqMarshaller.streamInvocations);
+    clientCall.sendMessage(expectedRequest);
+    // it is unacceptably expensive for the binlog to double parse every logged message
+    assertEquals(1, reqMarshaller.streamInvocations);
+    assertEquals(0, reqMarshaller.parseInvocations);
+    assertThat(binlogReq).hasSize(1);
+    assertThat(serializedReq).hasSize(1);
+    assertEquals(
+        expectedRequest,
+        StringMarshaller.INSTANCE.parse(new ByteArrayInputStream(binlogReq.get(0))));
+    assertEquals(
+        expectedRequest,
+        StringMarshaller.INSTANCE.parse(new ByteArrayInputStream(serializedReq.get(0))));
+
+    int expectedResponse = 12345;
+    assertThat(binlogResp).isEmpty();
+    assertThat(observedResponse).isEmpty();
+    assertEquals(0, respMarshaller.parseInvocations);
+    onClientMessageHelper(listener.get(), IntegerMarshaller.INSTANCE.stream(expectedResponse));
+    // it is unacceptably expensive for the binlog to double parse every logged message
+    assertEquals(1, respMarshaller.parseInvocations);
+    assertEquals(0, respMarshaller.streamInvocations);
+    assertThat(binlogResp).hasSize(1);
+    assertThat(observedResponse).hasSize(1);
+    assertEquals(
+        expectedResponse,
+        (int) IntegerMarshaller.INSTANCE.parse(new ByteArrayInputStream(binlogResp.get(0))));
+    assertEquals(expectedResponse, (int) observedResponse.get(0));
+  }
+
+  @SuppressWarnings({"rawtypes", "unchecked"})
+  private static void onClientMessageHelper(ClientCall.Listener listener, Object request) {
+    listener.onMessage(request);
+  }
+
+  private void validateWrappedMethod(MethodDescriptor<?, ?> wMethod) {
+    assertSame(BinaryLogProvider.BYTEARRAY_MARSHALLER, wMethod.getRequestMarshaller());
+    assertSame(BinaryLogProvider.BYTEARRAY_MARSHALLER, wMethod.getResponseMarshaller());
+    assertEquals(method.getType(), wMethod.getType());
+    assertEquals(method.getFullMethodName(), wMethod.getFullMethodName());
+    assertEquals(method.getSchemaDescriptor(), wMethod.getSchemaDescriptor());
+    assertEquals(method.isIdempotent(), wMethod.isIdempotent());
+    assertEquals(method.isSafe(), wMethod.isSafe());
+    assertEquals(method.isSampledToLocalTracing(), wMethod.isSampledToLocalTracing());
+  }
+
+  @Test
+  public void wrapMethodDefinition_methodDescriptor() throws Exception {
+    ServerMethodDefinition<String, Integer> methodDef =
+        ServerMethodDefinition.create(
+            method,
+            new ServerCallHandler<String, Integer>() {
+              @Override
+              public ServerCall.Listener<String> startCall(
+                  ServerCall<String, Integer> call, Metadata headers) {
+                throw new UnsupportedOperationException();
+              }
+            });
+    ServerMethodDefinition<?, ?> wMethodDef = binlogProvider.wrapMethodDefinition(methodDef);
+    validateWrappedMethod(wMethodDef.getMethodDescriptor());
+  }
+
+  @Test
+  public void wrapMethodDefinition_handler() throws Exception {
+    // The request as seen by the user supplied server code
+    final List<String> observedRequest = new ArrayList<>();
+    final AtomicReference<ServerCall<String, Integer>> serverCall =
+        new AtomicReference<>();
+    ServerMethodDefinition<String, Integer> methodDef =
+        ServerMethodDefinition.create(
+            method,
+            new ServerCallHandler<String, Integer>() {
+              @Override
+              public ServerCall.Listener<String> startCall(
+                  ServerCall<String, Integer> call, Metadata headers) {
+                serverCall.set(call);
+                return new ServerCall.Listener<String>() {
+                  @Override
+                  public void onMessage(String message) {
+                    observedRequest.add(message);
+                  }
+                };
+              }
+            });
+    ServerMethodDefinition<?, ?> wDef = binlogProvider.wrapMethodDefinition(methodDef);
+    List<Object> serializedResp = new ArrayList<>();
+    ServerCall.Listener<?> wListener = startServerCallHelper(wDef, serializedResp);
+
+    String expectedRequest = "hello world";
+    assertThat(binlogReq).isEmpty();
+    assertThat(observedRequest).isEmpty();
+    assertEquals(0, reqMarshaller.parseInvocations);
+    onServerMessageHelper(wListener, StringMarshaller.INSTANCE.stream(expectedRequest));
+    // it is unacceptably expensive for the binlog to double parse every logged message
+    assertEquals(1, reqMarshaller.parseInvocations);
+    assertEquals(0, reqMarshaller.streamInvocations);
+    assertThat(binlogReq).hasSize(1);
+    assertThat(observedRequest).hasSize(1);
+    assertEquals(
+        expectedRequest,
+        StringMarshaller.INSTANCE.parse(new ByteArrayInputStream(binlogReq.get(0))));
+    assertEquals(expectedRequest, observedRequest.get(0));
+
+    int expectedResponse = 12345;
+    assertThat(binlogResp).isEmpty();
+    assertThat(serializedResp).isEmpty();
+    assertEquals(0, respMarshaller.streamInvocations);
+    serverCall.get().sendMessage(expectedResponse);
+    // it is unacceptably expensive for the binlog to double parse every logged message
+    assertEquals(0, respMarshaller.parseInvocations);
+    assertEquals(1, respMarshaller.streamInvocations);
+    assertThat(binlogResp).hasSize(1);
+    assertThat(serializedResp).hasSize(1);
+    assertEquals(
+        expectedResponse,
+        (int) IntegerMarshaller.INSTANCE.parse(new ByteArrayInputStream(binlogResp.get(0))));
+    assertEquals(expectedResponse,
+        (int) method.parseResponse(new ByteArrayInputStream((byte[]) serializedResp.get(0))));
+  }
+
+  @SuppressWarnings({"rawtypes", "unchecked"})
+  private static void onServerMessageHelper(ServerCall.Listener listener, Object request) {
+    listener.onMessage(request);
+  }
+
+  private static <ReqT, RespT> ServerCall.Listener<ReqT> startServerCallHelper(
+      final ServerMethodDefinition<ReqT, RespT> methodDef,
+      final List<Object> serializedResp) {
+    ServerCall<ReqT, RespT> serverCall = new NoopServerCall<ReqT, RespT>() {
+      @Override
+      public void sendMessage(RespT message) {
+        serializedResp.add(message);
+      }
+
+      @Override
+      public MethodDescriptor<ReqT, RespT> getMethodDescriptor() {
+        return methodDef.getMethodDescriptor();
+      }
+    };
+    return methodDef.getServerCallHandler().startCall(serverCall, new Metadata());
+  }
+
+  private final class TestBinaryLogClientInterceptor implements ClientInterceptor {
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        final MethodDescriptor<ReqT, RespT> method,
+        CallOptions callOptions,
+        Channel next) {
+      assertSame(BinaryLogProvider.BYTEARRAY_MARSHALLER, method.getRequestMarshaller());
+      assertSame(BinaryLogProvider.BYTEARRAY_MARSHALLER, method.getResponseMarshaller());
+      return new SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {
+        @Override
+        public void start(ClientCall.Listener<RespT> responseListener, Metadata headers) {
+          super.start(
+              new SimpleForwardingClientCallListener<RespT>(responseListener) {
+                @Override
+                public void onMessage(RespT message) {
+                  assertTrue(message instanceof InputStream);
+                  try {
+                    byte[] bytes = ByteStreams.toByteArray((InputStream) message);
+                    binlogResp.add(bytes);
+                    ByteArrayInputStream input = new ByteArrayInputStream(bytes);
+                    RespT dup = method.parseResponse(input);
+                    super.onMessage(dup);
+                  } catch (IOException e) {
+                    throw new RuntimeException(e);
+                  }
+                }
+              },
+              headers);
+        }
+
+        @Override
+        public void sendMessage(ReqT message) {
+            byte[] bytes = (byte[]) message;
+            binlogReq.add(bytes);
+            ByteArrayInputStream input = new ByteArrayInputStream(bytes);
+            ReqT dup = method.parseRequest(input);
+            super.sendMessage(dup);
+        }
+      };
+    }
+  }
+
+  private final class TestBinaryLogServerInterceptor implements ServerInterceptor {
+    @Override
+    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+        final ServerCall<ReqT, RespT> call,
+        Metadata headers,
+        ServerCallHandler<ReqT, RespT> next) {
+      assertSame(
+          BinaryLogProvider.BYTEARRAY_MARSHALLER,
+          call.getMethodDescriptor().getRequestMarshaller());
+      assertSame(
+          BinaryLogProvider.BYTEARRAY_MARSHALLER,
+          call.getMethodDescriptor().getResponseMarshaller());
+      ServerCall<ReqT, RespT> wCall = new SimpleForwardingServerCall<ReqT, RespT>(call) {
+        @Override
+        public void sendMessage(RespT message) {
+            byte[] bytes = (byte[]) message;
+            binlogResp.add(bytes);
+            ByteArrayInputStream input = new ByteArrayInputStream(bytes);
+            RespT dup = call.getMethodDescriptor().parseResponse(input);
+            super.sendMessage(dup);
+        }
+      };
+      final ServerCall.Listener<ReqT> oListener = next.startCall(wCall, headers);
+      return new SimpleForwardingServerCallListener<ReqT>(oListener) {
+        @Override
+        public void onMessage(ReqT message) {
+          assertTrue(message instanceof InputStream);
+          try {
+            byte[] bytes = ByteStreams.toByteArray((InputStream) message);
+            binlogReq.add(bytes);
+            ByteArrayInputStream input = new ByteArrayInputStream(bytes);
+            ReqT dup = call.getMethodDescriptor().parseRequest(input);
+            super.onMessage(dup);
+          } catch (IOException e) {
+            throw new RuntimeException(e);
+          }
+        }
+      };
+    }
+  }
+
+  private abstract static class InvocationCountMarshaller<T>
+      implements MethodDescriptor.Marshaller<T> {
+    private int streamInvocations = 0;
+    private int parseInvocations = 0;
+
+    abstract MethodDescriptor.Marshaller<T> delegate();
+
+    @Override
+    public InputStream stream(T value) {
+      streamInvocations++;
+      return delegate().stream(value);
+    }
+
+    @Override
+    public T parse(InputStream stream) {
+      parseInvocations++;
+      return delegate().parse(stream);
+    }
+  }
+
+
+  private static class StringMarshaller implements MethodDescriptor.Marshaller<String> {
+    public static final StringMarshaller INSTANCE = new StringMarshaller();
+
+    @Override
+    public InputStream stream(String value) {
+      return new ByteArrayInputStream(value.getBytes(UTF_8));
+    }
+
+    @Override
+    public String parse(InputStream stream) {
+      try {
+        return new String(ByteStreams.toByteArray(stream), UTF_8);
+      } catch (IOException ex) {
+        throw new RuntimeException(ex);
+      }
+    }
+  }
+
+  private static class IntegerMarshaller implements MethodDescriptor.Marshaller<Integer> {
+    public static final IntegerMarshaller INSTANCE = new IntegerMarshaller();
+
+    @Override
+    public InputStream stream(Integer value) {
+      return StringMarshaller.INSTANCE.stream(value.toString());
+    }
+
+    @Override
+    public Integer parse(InputStream stream) {
+      return Integer.valueOf(StringMarshaller.INSTANCE.parse(stream));
+    }
+  }
+}
diff --git a/services/src/test/java/io/grpc/protobuf/services/BinlogHelperTest.java b/services/src/test/java/io/grpc/protobuf/services/BinlogHelperTest.java
new file mode 100644
index 00000000000..ca42c1691b1
--- /dev/null
+++ b/services/src/test/java/io/grpc/protobuf/services/BinlogHelperTest.java
@@ -0,0 +1,1581 @@
+/*
+ * Copyright 2017 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.protobuf.services;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.protobuf.services.BinaryLogProvider.BYTEARRAY_MARSHALLER;
+import static io.grpc.protobuf.services.BinlogHelper.createMetadataProto;
+import static io.grpc.protobuf.services.BinlogHelper.getPeerSocket;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import com.google.common.collect.Iterables;
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.protobuf.Any;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.Duration;
+import com.google.protobuf.StringValue;
+import com.google.protobuf.Timestamp;
+import com.google.protobuf.util.Durations;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.Context;
+import io.grpc.Deadline;
+import io.grpc.Grpc;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.NoopClientCall;
+import io.grpc.NoopServerCall;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.binarylog.v1.Address;
+import io.grpc.binarylog.v1.ClientHeader;
+import io.grpc.binarylog.v1.GrpcLogEntry;
+import io.grpc.binarylog.v1.GrpcLogEntry.EventType;
+import io.grpc.binarylog.v1.GrpcLogEntry.Logger;
+import io.grpc.binarylog.v1.Message;
+import io.grpc.binarylog.v1.MetadataEntry;
+import io.grpc.binarylog.v1.ServerHeader;
+import io.grpc.binarylog.v1.Trailer;
+import io.grpc.protobuf.StatusProto;
+import io.grpc.protobuf.services.BinlogHelper.FactoryImpl;
+import io.grpc.protobuf.services.BinlogHelper.MaybeTruncated;
+import io.grpc.protobuf.services.BinlogHelper.SinkWriter;
+import io.grpc.protobuf.services.BinlogHelper.SinkWriterImpl;
+import io.grpc.protobuf.services.BinlogHelper.TimeProvider;
+import io.netty.channel.unix.DomainSocketAddress;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.charset.Charset;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.AdditionalMatchers;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+
+/** Tests for {@link BinlogHelper}. */
+@SuppressWarnings("AddressSelection") // It will only be one address
+@RunWith(JUnit4.class)
+public final class BinlogHelperTest {
+  private static final Charset US_ASCII = Charset.forName("US-ASCII");
+  private static final BinlogHelper HEADER_FULL = new Builder().header(Integer.MAX_VALUE).build();
+  private static final BinlogHelper HEADER_256 = new Builder().header(256).build();
+  private static final BinlogHelper MSG_FULL = new Builder().msg(Integer.MAX_VALUE).build();
+  private static final BinlogHelper MSG_256 = new Builder().msg(256).build();
+  private static final BinlogHelper BOTH_256 = new Builder().header(256).msg(256).build();
+  private static final BinlogHelper BOTH_FULL =
+      new Builder().header(Integer.MAX_VALUE).msg(Integer.MAX_VALUE).build();
+
+  private static final String DATA_A = "aaaaaaaaa";
+  private static final String DATA_B = "bbbbbbbbb";
+  private static final String DATA_C = "ccccccccc";
+  private static final Metadata.Key<String> KEY_A =
+      Metadata.Key.of("a", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> KEY_B =
+      Metadata.Key.of("b", Metadata.ASCII_STRING_MARSHALLER);
+  private static final Metadata.Key<String> KEY_C =
+      Metadata.Key.of("c", Metadata.ASCII_STRING_MARSHALLER);
+  private static final MetadataEntry ENTRY_A =
+      MetadataEntry
+            .newBuilder()
+            .setKey(KEY_A.name())
+            .setValue(ByteString.copyFrom(DATA_A.getBytes(US_ASCII)))
+            .build();
+  private static final MetadataEntry ENTRY_B =
+        MetadataEntry
+            .newBuilder()
+            .setKey(KEY_B.name())
+            .setValue(ByteString.copyFrom(DATA_B.getBytes(US_ASCII)))
+            .build();
+  private static final MetadataEntry ENTRY_C =
+        MetadataEntry
+            .newBuilder()
+            .setKey(KEY_C.name())
+            .setValue(ByteString.copyFrom(DATA_C.getBytes(US_ASCII)))
+            .build();
+  private static final long CALL_ID = 0x1112131415161718L;
+  private static final int HEADER_LIMIT = 10;
+  private static final int MESSAGE_LIMIT = Integer.MAX_VALUE;
+
+  private final Metadata nonEmptyMetadata = new Metadata();
+  private final BinaryLogSink sink = mock(BinaryLogSink.class);
+  private final Timestamp timestamp
+      = Timestamp.newBuilder().setSeconds(9876).setNanos(54321).build();
+  private final BinlogHelper.TimeProvider timeProvider = new TimeProvider() {
+    @Override
+    public long currentTimeNanos() {
+      return TimeUnit.SECONDS.toNanos(9876) + 54321;
+    }
+  };
+  private final SinkWriter sinkWriterImpl =
+      new SinkWriterImpl(
+          sink,
+          timeProvider,
+          HEADER_LIMIT,
+          MESSAGE_LIMIT);
+  private final SinkWriter mockSinkWriter = mock(SinkWriter.class);
+  private final byte[] message = new byte[100];
+  private SocketAddress peer;
+
+  @Before
+  public void setUp() throws Exception {
+    nonEmptyMetadata.put(KEY_A, DATA_A);
+    nonEmptyMetadata.put(KEY_B, DATA_B);
+    nonEmptyMetadata.put(KEY_C, DATA_C);
+    peer = new InetSocketAddress(InetAddress.getByName("127.0.0.1"), 1234);
+  }
+
+  @Test
+  public void configBinLog_global() throws Exception {
+    assertSameLimits(BOTH_FULL, makeLog("*", "p.s/m"));
+    assertSameLimits(BOTH_FULL, makeLog("*{h;m}", "p.s/m"));
+    assertSameLimits(HEADER_FULL, makeLog("*{h}", "p.s/m"));
+    assertSameLimits(MSG_FULL, makeLog("*{m}", "p.s/m"));
+    assertSameLimits(HEADER_256, makeLog("*{h:256}", "p.s/m"));
+    assertSameLimits(MSG_256, makeLog("*{m:256}", "p.s/m"));
+    assertSameLimits(BOTH_256, makeLog("*{h:256;m:256}", "p.s/m"));
+    assertSameLimits(
+        new Builder().header(Integer.MAX_VALUE).msg(256).build(),
+        makeLog("*{h;m:256}", "p.s/m"));
+    assertSameLimits(
+        new Builder().header(256).msg(Integer.MAX_VALUE).build(),
+        makeLog("*{h:256;m}", "p.s/m"));
+  }
+
+  @Test
+  public void configBinLog_method() throws Exception {
+    assertSameLimits(BOTH_FULL, makeLog("p.s/m", "p.s/m"));
+    assertSameLimits(BOTH_FULL, makeLog("p.s/m{h;m}", "p.s/m"));
+    assertSameLimits(HEADER_FULL, makeLog("p.s/m{h}", "p.s/m"));
+    assertSameLimits(MSG_FULL, makeLog("p.s/m{m}", "p.s/m"));
+    assertSameLimits(HEADER_256, makeLog("p.s/m{h:256}", "p.s/m"));
+    assertSameLimits(MSG_256, makeLog("p.s/m{m:256}", "p.s/m"));
+    assertSameLimits(BOTH_256, makeLog("p.s/m{h:256;m:256}", "p.s/m"));
+    assertSameLimits(
+        new Builder().header(Integer.MAX_VALUE).msg(256).build(),
+        makeLog("p.s/m{h;m:256}", "p.s/m"));
+    assertSameLimits(
+        new Builder().header(256).msg(Integer.MAX_VALUE).build(),
+        makeLog("p.s/m{h:256;m}", "p.s/m"));
+  }
+
+  @Test
+  public void configBinLog_method_absent() throws Exception {
+    assertNull(makeLog("p.s/m", "p.s/absent"));
+  }
+
+  @Test
+  public void configBinLog_service() throws Exception {
+    assertSameLimits(BOTH_FULL, makeLog("p.s/*", "p.s/m"));
+    assertSameLimits(BOTH_FULL, makeLog("p.s/*{h;m}", "p.s/m"));
+    assertSameLimits(HEADER_FULL, makeLog("p.s/*{h}", "p.s/m"));
+    assertSameLimits(MSG_FULL, makeLog("p.s/*{m}", "p.s/m"));
+    assertSameLimits(HEADER_256, makeLog("p.s/*{h:256}", "p.s/m"));
+    assertSameLimits(MSG_256, makeLog("p.s/*{m:256}", "p.s/m"));
+    assertSameLimits(BOTH_256, makeLog("p.s/*{h:256;m:256}", "p.s/m"));
+    assertSameLimits(
+        new Builder().header(Integer.MAX_VALUE).msg(256).build(),
+        makeLog("p.s/*{h;m:256}", "p.s/m"));
+    assertSameLimits(
+        new Builder().header(256).msg(Integer.MAX_VALUE).build(),
+        makeLog("p.s/*{h:256;m}", "p.s/m"));
+  }
+
+  @Test
+  public void configBinLog_service_absent() throws Exception {
+    assertNull(makeLog("p.s/*", "p.other/m"));
+  }
+
+  @Test
+  public void createLogFromOptionString() throws Exception {
+    assertSameLimits(BOTH_FULL, makeOptions(null));
+    assertSameLimits(HEADER_FULL, makeOptions("h"));
+    assertSameLimits(MSG_FULL, makeOptions("m"));
+    assertSameLimits(HEADER_256, makeOptions("h:256"));
+    assertSameLimits(MSG_256, makeOptions("m:256"));
+    assertSameLimits(BOTH_256, makeOptions("h:256;m:256"));
+    assertSameLimits(
+        new Builder().header(Integer.MAX_VALUE).msg(256).build(),
+        makeOptions("h;m:256"));
+    assertSameLimits(
+        new Builder().header(256).msg(Integer.MAX_VALUE).build(),
+        makeOptions("h:256;m"));
+  }
+
+  private void assertIllegalPatternDetected(String perSvcOrMethodConfig) {
+    try {
+      FactoryImpl.createBinaryLog(sink, perSvcOrMethodConfig);
+      fail();
+    } catch (IllegalArgumentException expected) {
+      assertThat(expected).hasMessageThat().startsWith("Illegal log config pattern");
+    }
+  }
+
+  @Test
+  public void badFactoryConfigStrDetected() throws Exception {
+    try {
+      new FactoryImpl(sink, "obviouslybad{");
+      fail();
+    } catch (IllegalArgumentException expected) {
+      assertThat(expected).hasMessageThat().startsWith("Illegal log config pattern");
+    }
+  }
+
+  @Test
+  public void badFactoryConfigStrDetected_empty() throws Exception {
+    try {
+      new FactoryImpl(sink, "*,");
+      fail();
+    } catch (IllegalArgumentException expected) {
+      assertThat(expected).hasMessageThat().startsWith("Illegal log config pattern");
+    }
+  }
+
+  @Test
+  public void createLogFromOptionString_malformed() throws Exception {
+    assertIllegalPatternDetected("");
+    assertIllegalPatternDetected("bad");
+    assertIllegalPatternDetected("mad");
+    assertIllegalPatternDetected("x;y");
+    assertIllegalPatternDetected("h:abc");
+    assertIllegalPatternDetected("h:1e8");
+    assertIllegalPatternDetected("2");
+    assertIllegalPatternDetected("2;2");
+    // The grammar specifies that if both h and m are present, h comes before m
+    assertIllegalPatternDetected("m:123;h:123");
+    // NumberFormatException
+    assertIllegalPatternDetected("h:99999999999999");
+  }
+
+  @Test
+  public void configBinLog_multiConfig_withGlobal() throws Exception {
+    String configStr =
+        "*{h},"
+        + "package.both256/*{h:256;m:256},"
+        + "package.service1/both128{h:128;m:128},"
+        + "package.service2/method_messageOnly{m}";
+    assertSameLimits(HEADER_FULL, makeLog(configStr, "otherpackage.service/method"));
+
+    assertSameLimits(BOTH_256, makeLog(configStr, "package.both256/method1"));
+    assertSameLimits(BOTH_256, makeLog(configStr, "package.both256/method2"));
+    assertSameLimits(BOTH_256, makeLog(configStr, "package.both256/method3"));
+
+    assertSameLimits(
+        new Builder().header(128).msg(128).build(), makeLog(configStr, "package.service1/both128"));
+    // the global config is in effect
+    assertSameLimits(HEADER_FULL, makeLog(configStr, "package.service1/absent"));
+
+    assertSameLimits(MSG_FULL, makeLog(configStr, "package.service2/method_messageOnly"));
+    // the global config is in effect
+    assertSameLimits(HEADER_FULL, makeLog(configStr, "package.service2/absent"));
+  }
+
+  @Test
+  public void configBinLog_multiConfig_noGlobal() throws Exception {
+    String configStr =
+        "package.both256/*{h:256;m:256},"
+        + "package.service1/both128{h:128;m:128},"
+        + "package.service2/method_messageOnly{m}";
+    assertNull(makeLog(configStr, "otherpackage.service/method"));
+
+    assertSameLimits(BOTH_256, makeLog(configStr, "package.both256/method1"));
+    assertSameLimits(BOTH_256, makeLog(configStr, "package.both256/method2"));
+    assertSameLimits(BOTH_256, makeLog(configStr, "package.both256/method3"));
+
+    assertSameLimits(
+        new Builder().header(128).msg(128).build(), makeLog(configStr, "package.service1/both128"));
+    // no global config in effect
+    assertNull(makeLog(configStr, "package.service1/absent"));
+
+    assertSameLimits(MSG_FULL, makeLog(configStr, "package.service2/method_messageOnly"));
+    // no global config in effect
+    assertNull(makeLog(configStr, "package.service2/absent"));
+  }
+
+  @Test
+  public void configBinLog_blacklist() {
+    assertNull(makeLog("*,-p.s/blacklisted", "p.s/blacklisted"));
+    assertNull(makeLog("-p.s/blacklisted,*", "p.s/blacklisted"));
+    assertNotNull(makeLog("-p.s/method,*", "p.s/allowed"));
+
+    assertNull(makeLog("p.s/*,-p.s/blacklisted", "p.s/blacklisted"));
+    assertNull(makeLog("-p.s/blacklisted,p.s/*", "p.s/blacklisted"));
+    assertNotNull(makeLog("-p.s/blacklisted,p.s/*", "p.s/allowed"));
+  }
+
+  private void assertDuplicatelPatternDetected(String factoryConfigStr) {
+    try {
+      new BinlogHelper.FactoryImpl(sink, factoryConfigStr);
+      fail();
+    } catch (IllegalStateException expected) {
+      assertThat(expected).hasMessageThat().startsWith("Duplicate entry");
+    }
+  }
+
+  @Test
+  public void configBinLog_duplicates_global() throws Exception {
+    assertDuplicatelPatternDetected("*{h},*{h:256}");
+  }
+
+  @Test
+  public void configBinLog_duplicates_service() throws Exception {
+    assertDuplicatelPatternDetected("p.s/*,p.s/*{h}");
+
+  }
+
+  @Test
+  public void configBinLog_duplicates_method() throws Exception {
+    assertDuplicatelPatternDetected("p.s/*,p.s/*{h:1;m:2}");
+    assertDuplicatelPatternDetected("p.s/m,-p.s/m");
+    assertDuplicatelPatternDetected("-p.s/m,p.s/m");
+    assertDuplicatelPatternDetected("-p.s/m,-p.s/m");
+  }
+
+  @Test
+  public void socketToProto_ipv4() throws Exception {
+    InetAddress address = InetAddress.getByName("127.0.0.1");
+    int port = 12345;
+    InetSocketAddress socketAddress = new InetSocketAddress(address, port);
+    assertEquals(
+        Address
+            .newBuilder()
+            .setType(Address.Type.TYPE_IPV4)
+            .setAddress("127.0.0.1")
+            .setIpPort(12345)
+            .build(),
+        BinlogHelper.socketToProto(socketAddress));
+  }
+
+  @Test
+  public void socketToProto_ipv6() throws Exception {
+    // this is a ipv6 link local address
+    InetAddress address = InetAddress.getByName("2001:db8:0:0:0:0:2:1");
+    int port = 12345;
+    InetSocketAddress socketAddress = new InetSocketAddress(address, port);
+    assertEquals(
+        Address
+            .newBuilder()
+            .setType(Address.Type.TYPE_IPV6)
+            .setAddress("2001:db8::2:1") // RFC 5952 section 4: ipv6 canonical form required
+            .setIpPort(12345)
+            .build(),
+        BinlogHelper.socketToProto(socketAddress));
+  }
+
+  @Test
+  public void socketToProto_unix() throws Exception {
+    String path = "/some/path";
+    DomainSocketAddress socketAddress = new DomainSocketAddress(path);
+    assertEquals(
+        Address
+            .newBuilder()
+            .setType(Address.Type.TYPE_UNIX)
+            .setAddress("/some/path")
+            .build(),
+        BinlogHelper.socketToProto(socketAddress)
+    );
+  }
+
+  @Test
+  public void socketToProto_unknown() throws Exception {
+    SocketAddress unknownSocket = new SocketAddress() {
+      @Override
+      public String toString() {
+        return "some-socket-address";
+      }
+    };
+    assertEquals(
+        Address.newBuilder()
+            .setType(Address.Type.TYPE_UNKNOWN)
+            .setAddress("some-socket-address")
+            .build(),
+        BinlogHelper.socketToProto(unknownSocket));
+  }
+
+  @Test
+  public void metadataToProto_empty() throws Exception {
+    assertEquals(
+        GrpcLogEntry.newBuilder()
+            .setType(EventType.EVENT_TYPE_CLIENT_HEADER)
+            .setClientHeader(
+                ClientHeader.newBuilder().setMetadata(
+                    io.grpc.binarylog.v1.Metadata.getDefaultInstance()))
+            .build(),
+        metadataToProtoTestHelper(
+            EventType.EVENT_TYPE_CLIENT_HEADER, new Metadata(), Integer.MAX_VALUE));
+  }
+
+  @Test
+  public void metadataToProto() throws Exception {
+    assertEquals(
+        GrpcLogEntry.newBuilder()
+            .setType(EventType.EVENT_TYPE_CLIENT_HEADER)
+            .setClientHeader(
+                ClientHeader.newBuilder().setMetadata(
+                io.grpc.binarylog.v1.Metadata
+                    .newBuilder()
+                    .addEntry(ENTRY_A)
+                    .addEntry(ENTRY_B)
+                    .addEntry(ENTRY_C)
+                    .build()))
+            .build(),
+        metadataToProtoTestHelper(
+            EventType.EVENT_TYPE_CLIENT_HEADER, nonEmptyMetadata, Integer.MAX_VALUE));
+  }
+
+  @Test
+  public void metadataToProto_setsTruncated() throws Exception {
+    assertTrue(BinlogHelper.createMetadataProto(nonEmptyMetadata, 0).truncated);
+  }
+
+  @Test
+  public void metadataToProto_truncated() throws Exception {
+    // 0 byte limit not enough for any metadata
+    assertEquals(
+        io.grpc.binarylog.v1.Metadata.getDefaultInstance(),
+        BinlogHelper.createMetadataProto(nonEmptyMetadata, 0).proto.build());
+    // not enough bytes for first key value
+    assertEquals(
+        io.grpc.binarylog.v1.Metadata.getDefaultInstance(),
+        BinlogHelper.createMetadataProto(nonEmptyMetadata, 9).proto.build());
+    // enough for first key value
+    assertEquals(
+        io.grpc.binarylog.v1.Metadata
+            .newBuilder()
+            .addEntry(ENTRY_A)
+            .build(),
+        BinlogHelper.createMetadataProto(nonEmptyMetadata, 10).proto.build());
+    // Test edge cases for >= 2 key values
+    assertEquals(
+        io.grpc.binarylog.v1.Metadata
+            .newBuilder()
+            .addEntry(ENTRY_A)
+            .build(),
+        BinlogHelper.createMetadataProto(nonEmptyMetadata, 19).proto.build());
+    assertEquals(
+        io.grpc.binarylog.v1.Metadata
+            .newBuilder()
+            .addEntry(ENTRY_A)
+            .addEntry(ENTRY_B)
+            .build(),
+        BinlogHelper.createMetadataProto(nonEmptyMetadata, 20).proto.build());
+    assertEquals(
+        io.grpc.binarylog.v1.Metadata
+            .newBuilder()
+            .addEntry(ENTRY_A)
+            .addEntry(ENTRY_B)
+            .build(),
+        BinlogHelper.createMetadataProto(nonEmptyMetadata, 29).proto.build());
+
+    // not truncated: enough for all keys
+    assertEquals(
+        io.grpc.binarylog.v1.Metadata
+            .newBuilder()
+            .addEntry(ENTRY_A)
+            .addEntry(ENTRY_B)
+            .addEntry(ENTRY_C)
+            .build(),
+        BinlogHelper.createMetadataProto(nonEmptyMetadata, 30).proto.build());
+  }
+
+  @Test
+  public void messageToProto() throws Exception {
+    byte[] bytes
+        = "this is a long message: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".getBytes(US_ASCII);
+    assertEquals(
+        GrpcLogEntry.newBuilder()
+            .setMessage(
+                Message
+                    .newBuilder()
+                    .setData(ByteString.copyFrom(bytes))
+                    .setLength(bytes.length)
+                    .build())
+            .build(),
+        messageToProtoTestHelper(bytes, Integer.MAX_VALUE));
+  }
+
+  @Test
+  public void messageToProto_truncated() throws Exception {
+    byte[] bytes
+        = "this is a long message: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA".getBytes(US_ASCII);
+    assertEquals(
+        GrpcLogEntry.newBuilder()
+            .setMessage(
+                Message
+                    .newBuilder()
+                    .setLength(bytes.length)
+                    .build())
+            .setPayloadTruncated(true)
+            .build(),
+        messageToProtoTestHelper(bytes, 0));
+
+    int limit = 10;
+    String truncatedMessage = "this is a ";
+    assertEquals(
+        GrpcLogEntry.newBuilder()
+            .setMessage(
+                Message
+                    .newBuilder()
+                    .setData(ByteString.copyFrom(truncatedMessage.getBytes(US_ASCII)))
+                    .setLength(bytes.length)
+                    .build())
+            .setPayloadTruncated(true)
+            .build(),
+        messageToProtoTestHelper(bytes, limit));
+  }
+
+  @Test
+  public void logClientHeader() throws Exception {
+    long seq = 1;
+    String authority = "authority";
+    String methodName = "service/method";
+    Duration timeout = Durations.fromMillis(1234);
+    InetAddress address = InetAddress.getByName("127.0.0.1");
+    int port = 12345;
+    InetSocketAddress peerAddress = new InetSocketAddress(address, port);
+    long callId = 1000;
+
+    GrpcLogEntry.Builder builder =
+        metadataToProtoTestHelper(EventType.EVENT_TYPE_CLIENT_HEADER, nonEmptyMetadata, 10)
+            .toBuilder()
+            .setTimestamp(timestamp)
+            .setSequenceIdWithinCall(seq)
+            .setLogger(Logger.LOGGER_CLIENT)
+            .setCallId(callId);
+    builder.getClientHeaderBuilder()
+        .setMethodName("/" + methodName)
+        .setAuthority(authority)
+        .setTimeout(timeout);
+    GrpcLogEntry base = builder.build();
+    {
+      sinkWriterImpl.logClientHeader(
+          seq,
+          methodName,
+          authority,
+          timeout,
+          nonEmptyMetadata,
+          Logger.LOGGER_CLIENT,
+          callId,
+          /*peerAddress=*/ null);
+      verify(sink).write(base);
+    }
+
+    // logger is server
+    {
+      sinkWriterImpl.logClientHeader(
+          seq,
+          methodName,
+          authority,
+          timeout,
+          nonEmptyMetadata,
+          Logger.LOGGER_SERVER,
+          callId,
+          peerAddress);
+      verify(sink).write(
+          base.toBuilder()
+              .setPeer(BinlogHelper.socketToProto(peerAddress))
+              .setLogger(Logger.LOGGER_SERVER)
+              .build());
+    }
+
+    // authority is null
+    {
+      sinkWriterImpl.logClientHeader(
+          seq,
+          methodName,
+          /*authority=*/ null,
+          timeout,
+          nonEmptyMetadata,
+          Logger.LOGGER_CLIENT,
+          callId,
+          /*peerAddress=*/ null);
+
+      verify(sink).write(
+          base.toBuilder()
+              .setClientHeader(builder.getClientHeader().toBuilder().clearAuthority().build())
+              .build());
+    }
+
+    // timeout is null
+    {
+      sinkWriterImpl.logClientHeader(
+          seq,
+          methodName,
+          authority,
+          /*timeout=*/ null,
+          nonEmptyMetadata,
+          Logger.LOGGER_CLIENT,
+          callId,
+          /*peerAddress=*/ null);
+
+      verify(sink).write(
+          base.toBuilder()
+              .setClientHeader(builder.getClientHeader().toBuilder().clearTimeout().build())
+              .build());
+    }
+
+    // peerAddress is non null (error for client side)
+    try {
+      sinkWriterImpl.logClientHeader(
+          seq,
+          methodName,
+          authority,
+          timeout,
+          nonEmptyMetadata,
+          Logger.LOGGER_CLIENT,
+          callId,
+          peerAddress);
+      fail();
+    } catch (IllegalArgumentException expected) {
+      // noop
+    }
+  }
+
+  @Test
+  public void logServerHeader() throws Exception {
+    long seq = 1;
+    InetAddress address = InetAddress.getByName("127.0.0.1");
+    int port = 12345;
+    InetSocketAddress peerAddress = new InetSocketAddress(address, port);
+    long callId = 1000;
+
+    GrpcLogEntry.Builder builder =
+        metadataToProtoTestHelper(EventType.EVENT_TYPE_SERVER_HEADER, nonEmptyMetadata, 10)
+            .toBuilder()
+            .setTimestamp(timestamp)
+            .setSequenceIdWithinCall(seq)
+            .setLogger(Logger.LOGGER_CLIENT)
+            .setCallId(callId)
+            .setPeer(BinlogHelper.socketToProto(peerAddress));
+
+    {
+      sinkWriterImpl.logServerHeader(
+          seq,
+          nonEmptyMetadata,
+          Logger.LOGGER_CLIENT,
+          callId,
+          peerAddress);
+      verify(sink).write(builder.build());
+    }
+
+    // logger is server
+    // null peerAddress is required for server side
+    {
+      sinkWriterImpl.logServerHeader(
+          seq,
+          nonEmptyMetadata,
+          Logger.LOGGER_SERVER,
+          callId,
+          /*peerAddress=*/ null);
+      verify(sink).write(
+          builder
+              .setLogger(Logger.LOGGER_SERVER)
+              .clearPeer()
+              .build());
+    }
+
+    // logger is server
+    // non null peerAddress is an error
+    try {
+      sinkWriterImpl.logServerHeader(
+          seq,
+          nonEmptyMetadata,
+          Logger.LOGGER_SERVER,
+          callId,
+          peerAddress);
+      fail();
+    } catch (IllegalArgumentException expected) {
+      // noop
+    }
+  }
+
+  @Test
+  public void logTrailer() throws Exception {
+    long seq = 1;
+    InetAddress address = InetAddress.getByName("127.0.0.1");
+    int port = 12345;
+    InetSocketAddress peerAddress = new InetSocketAddress(address, port);
+    long callId = 1000;
+    Status statusDescription = Status.INTERNAL.withDescription("my description");
+
+    GrpcLogEntry.Builder builder =
+        metadataToProtoTestHelper(EventType.EVENT_TYPE_SERVER_TRAILER, nonEmptyMetadata, 10)
+            .toBuilder()
+            .setTimestamp(timestamp)
+            .setSequenceIdWithinCall(seq)
+            .setLogger(Logger.LOGGER_CLIENT)
+            .setCallId(callId)
+            .setPeer(BinlogHelper.socketToProto(peerAddress));
+
+    builder.getTrailerBuilder()
+        .setStatusCode(Status.INTERNAL.getCode().value())
+        .setStatusMessage("my description");
+    GrpcLogEntry base = builder.build();
+
+    {
+      sinkWriterImpl.logTrailer(
+          seq,
+          statusDescription,
+          nonEmptyMetadata,
+          Logger.LOGGER_CLIENT,
+          callId,
+          peerAddress);
+      verify(sink).write(base);
+    }
+
+    // logger is server
+    {
+      sinkWriterImpl.logTrailer(
+          seq,
+          statusDescription,
+          nonEmptyMetadata,
+          Logger.LOGGER_SERVER,
+          callId,
+          /*peerAddress=*/ null);
+      verify(sink).write(
+          base.toBuilder()
+              .clearPeer()
+              .setLogger(Logger.LOGGER_SERVER)
+              .build());
+    }
+
+    // peerAddress is null
+    {
+      sinkWriterImpl.logTrailer(
+          seq,
+          statusDescription,
+          nonEmptyMetadata,
+          Logger.LOGGER_CLIENT,
+          callId,
+          /*peerAddress=*/ null);
+      verify(sink).write(
+          base.toBuilder()
+              .clearPeer()
+              .build());
+    }
+
+    // status code is present but description is null
+    {
+      sinkWriterImpl.logTrailer(
+          seq,
+          statusDescription.getCode().toStatus(), // strip the description
+          nonEmptyMetadata,
+          Logger.LOGGER_CLIENT,
+          callId,
+          peerAddress);
+      verify(sink).write(
+          base.toBuilder()
+              .setTrailer(base.getTrailer().toBuilder().clearStatusMessage())
+              .build());
+    }
+
+    // status proto always logged if present (com.google.rpc.Status),
+    {
+      int zeroHeaderBytes = 0;
+      SinkWriterImpl truncatingWriter = new SinkWriterImpl(
+          sink, timeProvider, zeroHeaderBytes, MESSAGE_LIMIT);
+      com.google.rpc.Status statusProto = com.google.rpc.Status.newBuilder()
+          .addDetails(
+              Any.pack(StringValue.newBuilder().setValue("arbitrarypayload").build()))
+          .setCode(Status.INTERNAL.getCode().value())
+          .setMessage("status detail string")
+          .build();
+      StatusException statusException
+          = StatusProto.toStatusException(statusProto, nonEmptyMetadata);
+      truncatingWriter.logTrailer(
+          seq,
+          statusException.getStatus(),
+          statusException.getTrailers(),
+          Logger.LOGGER_CLIENT,
+          callId,
+          peerAddress);
+      verify(sink).write(
+          base.toBuilder()
+              .setTrailer(
+                  builder.getTrailerBuilder()
+                      .setStatusMessage("status detail string")
+                      .setStatusDetails(ByteString.copyFrom(statusProto.toByteArray()))
+                      .setMetadata(io.grpc.binarylog.v1.Metadata.getDefaultInstance()))
+              .build());
+    }
+  }
+
+  @Test
+  public void alwaysLoggedMetadata_grpcTraceBin() throws Exception {
+    Metadata.Key<byte[]> key
+        = Metadata.Key.of("grpc-trace-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    Metadata metadata = new Metadata();
+    metadata.put(key, new byte[1]);
+    int zeroHeaderBytes = 0;
+    MaybeTruncated<io.grpc.binarylog.v1.Metadata.Builder> pair =
+        createMetadataProto(metadata, zeroHeaderBytes);
+    assertEquals(
+        key.name(),
+        Iterables.getOnlyElement(pair.proto.getEntryBuilderList()).getKey());
+    assertFalse(pair.truncated);
+  }
+
+  @Test
+  public void neverLoggedMetadata_grpcStatusDetilsBin() throws Exception {
+    Metadata.Key<byte[]> key
+        = Metadata.Key.of("grpc-status-details-bin", Metadata.BINARY_BYTE_MARSHALLER);
+    Metadata metadata = new Metadata();
+    metadata.put(key, new byte[1]);
+    int unlimitedHeaderBytes = Integer.MAX_VALUE;
+    MaybeTruncated<io.grpc.binarylog.v1.Metadata.Builder> pair
+        = createMetadataProto(metadata, unlimitedHeaderBytes);
+    assertThat(pair.proto.getEntryBuilderList()).isEmpty();
+    assertFalse(pair.truncated);
+  }
+
+  @Test
+  public void logRpcMessage() throws Exception {
+    long seq = 1;
+    long callId = 1000;
+    GrpcLogEntry base = messageToProtoTestHelper(message, MESSAGE_LIMIT).toBuilder()
+        .setTimestamp(timestamp)
+        .setType(EventType.EVENT_TYPE_CLIENT_MESSAGE)
+        .setLogger(Logger.LOGGER_CLIENT)
+        .setSequenceIdWithinCall(1)
+        .setCallId(callId)
+        .build();
+    {
+      sinkWriterImpl.logRpcMessage(
+          seq,
+          EventType.EVENT_TYPE_CLIENT_MESSAGE,
+          BYTEARRAY_MARSHALLER,
+          message,
+          Logger.LOGGER_CLIENT,
+          callId);
+      verify(sink).write(base);
+    }
+
+    // server message
+    {
+      sinkWriterImpl.logRpcMessage(
+          seq,
+          EventType.EVENT_TYPE_SERVER_MESSAGE,
+          BYTEARRAY_MARSHALLER,
+          message,
+          Logger.LOGGER_CLIENT,
+          callId);
+      verify(sink).write(
+          base.toBuilder()
+              .setType(EventType.EVENT_TYPE_SERVER_MESSAGE)
+              .build());
+    }
+
+    // logger is server
+    {
+      sinkWriterImpl.logRpcMessage(
+          seq,
+          EventType.EVENT_TYPE_CLIENT_MESSAGE,
+          BYTEARRAY_MARSHALLER,
+          message,
+          Logger.LOGGER_SERVER,
+          callId);
+      verify(sink).write(
+          base.toBuilder()
+              .setLogger(Logger.LOGGER_SERVER)
+              .build());
+    }
+  }
+
+  @Test
+  public void getPeerSocketTest() {
+    assertNull(getPeerSocket(Attributes.EMPTY));
+    assertSame(
+        peer,
+        getPeerSocket(Attributes.newBuilder().set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, peer).build()));
+  }
+
+  @Test
+  public void serverDeadlineLogged() {
+    final MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    final ServerCall<byte[], byte[]> noopServerCall = new NoopServerCall<byte[], byte[]>() {
+      @Override
+      public MethodDescriptor<byte[], byte[]> getMethodDescriptor() {
+        return method;
+      }
+    };
+    final ServerCallHandler<byte[], byte[]> noopHandler = new ServerCallHandler<byte[], byte[]>() {
+      @Override
+      public ServerCall.Listener<byte[]> startCall(
+          ServerCall<byte[], byte[]> call,
+          Metadata headers) {
+        return new ServerCall.Listener<byte[]>() {};
+      }
+    };
+
+    // Warm-up JVM
+    new BinlogHelper(mock(SinkWriter.class))
+        .getServerInterceptor(1234)
+        .interceptCall(noopServerCall, new Metadata(), noopHandler);
+
+    // We expect the contents of the "grpc-timeout" header to be installed the context
+    Context.current()
+        .withDeadlineAfter(1, TimeUnit.SECONDS, Executors.newSingleThreadScheduledExecutor())
+        .run(new Runnable() {
+          @Override
+          public void run() {
+            ServerCall.Listener<byte[]> unused =
+                new BinlogHelper(mockSinkWriter)
+                    .getServerInterceptor(CALL_ID)
+                    .interceptCall(noopServerCall, new Metadata(), noopHandler);
+          }
+        });
+    ArgumentCaptor<Duration> timeoutCaptor = ArgumentCaptor.forClass(Duration.class);
+    verify(mockSinkWriter).logClientHeader(
+        /*seq=*/ eq(1L),
+        eq("service/method"),
+        ArgumentMatchers.<String>isNull(),
+        timeoutCaptor.capture(),
+        any(Metadata.class),
+        eq(Logger.LOGGER_SERVER),
+        eq(CALL_ID),
+        ArgumentMatchers.<SocketAddress>isNull());
+    verifyNoMoreInteractions(mockSinkWriter);
+    Duration timeout = timeoutCaptor.getValue();
+    assertThat(Math.abs(TimeUnit.SECONDS.toNanos(1) - Durations.toNanos(timeout)))
+        .isAtMost(TimeUnit.MILLISECONDS.toNanos(250));
+  }
+
+  @Test
+  public void clientDeadlineLogged_deadlineSetViaCallOption() {
+    MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    @SuppressWarnings("unchecked")
+    ClientCall.Listener<byte[]> mockListener = mock(ClientCall.Listener.class);
+
+    ClientCall<byte[], byte[]> call =
+        new BinlogHelper(mockSinkWriter)
+            .getClientInterceptor(CALL_ID)
+            .interceptCall(
+                method,
+                CallOptions.DEFAULT.withDeadlineAfter(2, TimeUnit.SECONDS),
+                new Channel() {
+                  @Override
+                  public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+                      MethodDescriptor<RequestT, ResponseT> methodDescriptor,
+                      CallOptions callOptions) {
+                    return new NoopClientCall<>();
+                  }
+
+                  @Override
+                  public String authority() {
+                    return null;
+                  }
+                });
+    call.start(mockListener, new Metadata());
+    ArgumentCaptor<Duration> callOptTimeoutCaptor = ArgumentCaptor.forClass(Duration.class);
+    verify(mockSinkWriter)
+        .logClientHeader(
+            anyLong(),
+            AdditionalMatchers.or(ArgumentMatchers.<String>isNull(), anyString()),
+            AdditionalMatchers.or(ArgumentMatchers.<String>isNull(), anyString()),
+            callOptTimeoutCaptor.capture(),
+            any(Metadata.class),
+            any(GrpcLogEntry.Logger.class),
+            anyLong(),
+            AdditionalMatchers.or(ArgumentMatchers.<SocketAddress>isNull(),
+                ArgumentMatchers.<SocketAddress>any()));
+    Duration timeout = callOptTimeoutCaptor.getValue();
+    assertThat(Math.abs(TimeUnit.SECONDS.toNanos(2) - Durations.toNanos(timeout)))
+        .isAtMost(TimeUnit.MILLISECONDS.toNanos(750));
+  }
+
+  @Test
+  public void clientDeadlineLogged_deadlineSetViaContext() throws Exception {
+    // important: deadline is read from the ctx where call was created
+    final SettableFuture<ClientCall<byte[], byte[]>> callFuture = SettableFuture.create();
+    Deadline expectedDeadline = Deadline.after(2, TimeUnit.SECONDS);
+    Context.current()
+        .withDeadline(
+            expectedDeadline, Executors.newSingleThreadScheduledExecutor())
+        .run(new Runnable() {
+          @Override
+          public void run() {
+            MethodDescriptor<byte[], byte[]> method =
+                MethodDescriptor.<byte[], byte[]>newBuilder()
+                    .setType(MethodType.UNKNOWN)
+                    .setFullMethodName("service/method")
+                    .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+                    .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+                    .build();
+
+            callFuture.set(new BinlogHelper(mockSinkWriter)
+                .getClientInterceptor(CALL_ID)
+                .interceptCall(
+                    method,
+                    CallOptions.DEFAULT.withDeadlineAfter(10, TimeUnit.SECONDS),
+                    new Channel() {
+                      @Override
+                      public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+                          MethodDescriptor<RequestT, ResponseT> methodDescriptor,
+                          CallOptions callOptions) {
+                        return new NoopClientCall<>();
+                      }
+
+                      @Override
+                      public String authority() {
+                        return null;
+                      }
+                    }));
+          }
+        });
+    @SuppressWarnings("unchecked")
+    ClientCall.Listener<byte[]> mockListener = mock(ClientCall.Listener.class);
+    callFuture.get().start(mockListener, new Metadata());
+    ArgumentCaptor<Duration> callOptTimeoutCaptor = ArgumentCaptor.forClass(Duration.class);
+    verify(mockSinkWriter)
+        .logClientHeader(
+            anyLong(),
+            anyString(),
+            ArgumentMatchers.<String>any(),
+            callOptTimeoutCaptor.capture(),
+            any(Metadata.class),
+            any(GrpcLogEntry.Logger.class),
+            anyLong(),
+            AdditionalMatchers.or(ArgumentMatchers.<SocketAddress>isNull(),
+                ArgumentMatchers.<SocketAddress>any()));
+    long expectedTimeRemaining = expectedDeadline.timeRemaining(TimeUnit.NANOSECONDS);
+    long timeout = Durations.toNanos(callOptTimeoutCaptor.getValue());
+    assertThat(Math.abs(expectedTimeRemaining - timeout))
+        .isAtMost(TimeUnit.MILLISECONDS.toNanos(750));
+  }
+
+  @Test
+  public void clientInterceptor() throws Exception {
+    final AtomicReference<ClientCall.Listener<byte[]>> interceptedListener =
+        new AtomicReference<>();
+    // capture these manually because ClientCall can not be mocked
+    final AtomicReference<Metadata> actualClientInitial = new AtomicReference<>();
+    final AtomicReference<Object> actualRequest = new AtomicReference<>();
+
+    final SettableFuture<Void> halfCloseCalled = SettableFuture.create();
+    final SettableFuture<Void> cancelCalled = SettableFuture.create();
+    Channel channel = new Channel() {
+      @Override
+      public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+          MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+        return new NoopClientCall<RequestT, ResponseT>() {
+          @Override
+          @SuppressWarnings("unchecked")
+          public void start(Listener<ResponseT> responseListener, Metadata headers) {
+            interceptedListener.set((Listener<byte[]>) responseListener);
+            actualClientInitial.set(headers);
+          }
+
+          @Override
+          public void sendMessage(RequestT message) {
+            actualRequest.set(message);
+          }
+
+          @Override
+          public void cancel(String message, Throwable cause) {
+            cancelCalled.set(null);
+          }
+
+          @Override
+          public void halfClose() {
+            halfCloseCalled.set(null);
+          }
+
+          @Override
+          public Attributes getAttributes() {
+            return Attributes.newBuilder().set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, peer).build();
+          }
+        };
+      }
+
+      @Override
+      public String authority() {
+        return "the-authority";
+      }
+    };
+
+    @SuppressWarnings("unchecked")
+    ClientCall.Listener<byte[]> mockListener = mock(ClientCall.Listener.class);
+
+    MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    ClientCall<byte[], byte[]> interceptedCall =
+        new BinlogHelper(mockSinkWriter)
+            .getClientInterceptor(CALL_ID)
+            .interceptCall(
+                method,
+                CallOptions.DEFAULT,
+                channel);
+
+    // send client header
+    {
+      Metadata clientInitial = new Metadata();
+      interceptedCall.start(mockListener, clientInitial);
+      verify(mockSinkWriter).logClientHeader(
+          /*seq=*/ eq(1L),
+          eq("service/method"),
+          eq("the-authority"),
+          ArgumentMatchers.<Duration>isNull(),
+          same(clientInitial),
+          eq(Logger.LOGGER_CLIENT),
+          eq(CALL_ID),
+          ArgumentMatchers.<SocketAddress>isNull());
+      verifyNoMoreInteractions(mockSinkWriter);
+      assertSame(clientInitial, actualClientInitial.get());
+    }
+
+    // receive server header
+    {
+      Metadata serverInitial = new Metadata();
+      interceptedListener.get().onHeaders(serverInitial);
+      verify(mockSinkWriter).logServerHeader(
+          /*seq=*/ eq(2L),
+          same(serverInitial),
+          eq(Logger.LOGGER_CLIENT),
+          eq(CALL_ID),
+          same(peer));
+      verifyNoMoreInteractions(mockSinkWriter);
+      verify(mockListener).onHeaders(same(serverInitial));
+    }
+
+    // send client msg
+    {
+      byte[] request = "this is a request".getBytes(US_ASCII);
+      interceptedCall.sendMessage(request);
+      verify(mockSinkWriter).logRpcMessage(
+          /*seq=*/ eq(3L),
+          eq(EventType.EVENT_TYPE_CLIENT_MESSAGE),
+          same(BYTEARRAY_MARSHALLER),
+          same(request),
+          eq(Logger.LOGGER_CLIENT),
+          eq(CALL_ID));
+      verifyNoMoreInteractions(mockSinkWriter);
+      assertSame(request, actualRequest.get());
+    }
+
+    // client half close
+    {
+      interceptedCall.halfClose();
+      verify(mockSinkWriter).logHalfClose(
+          /*seq=*/ eq(4L),
+          eq(Logger.LOGGER_CLIENT),
+          eq(CALL_ID));
+      halfCloseCalled.get(1, TimeUnit.SECONDS);
+      verifyNoMoreInteractions(mockSinkWriter);
+    }
+
+    // receive server msg
+    {
+      byte[] response = "this is a response".getBytes(US_ASCII);
+      interceptedListener.get().onMessage(response);
+      verify(mockSinkWriter).logRpcMessage(
+          /*seq=*/ eq(5L),
+          eq(EventType.EVENT_TYPE_SERVER_MESSAGE),
+          same(BYTEARRAY_MARSHALLER),
+          same(response),
+          eq(Logger.LOGGER_CLIENT),
+          eq(CALL_ID));
+      verifyNoMoreInteractions(mockSinkWriter);
+      verify(mockListener).onMessage(same(response));
+    }
+
+    // receive trailer
+    {
+      Status status = Status.INTERNAL.withDescription("some description");
+      Metadata trailers = new Metadata();
+
+      interceptedListener.get().onClose(status, trailers);
+      verify(mockSinkWriter).logTrailer(
+          /*seq=*/ eq(6L),
+          same(status),
+          same(trailers),
+          eq(Logger.LOGGER_CLIENT),
+          eq(CALL_ID),
+          ArgumentMatchers.<SocketAddress>isNull());
+      verifyNoMoreInteractions(mockSinkWriter);
+      verify(mockListener).onClose(same(status), same(trailers));
+    }
+
+    // cancel
+    {
+      interceptedCall.cancel(null, null);
+      verify(mockSinkWriter).logCancel(
+          /*seq=*/ eq(7L),
+          eq(Logger.LOGGER_CLIENT),
+          eq(CALL_ID));
+      cancelCalled.get(1, TimeUnit.SECONDS);
+    }
+  }
+
+  @Test
+  public void clientInterceptor_trailersOnlyResponseLogsPeerAddress() throws Exception {
+    final AtomicReference<ClientCall.Listener<byte[]>> interceptedListener =
+        new AtomicReference<>();
+    // capture these manually because ClientCall can not be mocked
+    final AtomicReference<Metadata> actualClientInitial = new AtomicReference<>();
+    final AtomicReference<Object> actualRequest = new AtomicReference<>();
+
+    Channel channel = new Channel() {
+      @Override
+      public <RequestT, ResponseT> ClientCall<RequestT, ResponseT> newCall(
+          MethodDescriptor<RequestT, ResponseT> methodDescriptor, CallOptions callOptions) {
+        return new NoopClientCall<RequestT, ResponseT>() {
+          @Override
+          @SuppressWarnings("unchecked")
+          public void start(Listener<ResponseT> responseListener, Metadata headers) {
+            interceptedListener.set((Listener<byte[]>) responseListener);
+            actualClientInitial.set(headers);
+          }
+
+          @Override
+          public void sendMessage(RequestT message) {
+            actualRequest.set(message);
+          }
+
+          @Override
+          public Attributes getAttributes() {
+            return Attributes.newBuilder().set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, peer).build();
+          }
+        };
+      }
+
+      @Override
+      public String authority() {
+        return "the-authority";
+      }
+    };
+
+    @SuppressWarnings("unchecked")
+    ClientCall.Listener<byte[]> mockListener = mock(ClientCall.Listener.class);
+
+    MethodDescriptor<byte[], byte[]> method =
+        MethodDescriptor.<byte[], byte[]>newBuilder()
+            .setType(MethodType.UNKNOWN)
+            .setFullMethodName("service/method")
+            .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+            .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+            .build();
+    ClientCall<byte[], byte[]> interceptedCall =
+        new BinlogHelper(mockSinkWriter)
+            .getClientInterceptor(CALL_ID)
+            .interceptCall(
+                method,
+                CallOptions.DEFAULT.withDeadlineAfter(1, TimeUnit.SECONDS),
+                channel);
+    Metadata clientInitial = new Metadata();
+    interceptedCall.start(mockListener, clientInitial);
+    verify(mockSinkWriter).logClientHeader(
+        /*seq=*/ eq(1L),
+        anyString(),
+        anyString(),
+        any(Duration.class),
+        any(Metadata.class),
+        eq(Logger.LOGGER_CLIENT),
+        eq(CALL_ID),
+        ArgumentMatchers.<SocketAddress>isNull());
+    verifyNoMoreInteractions(mockSinkWriter);
+
+    // trailer only response
+    {
+      Status status = Status.INTERNAL.withDescription("some description");
+      Metadata trailers = new Metadata();
+
+      interceptedListener.get().onClose(status, trailers);
+      verify(mockSinkWriter).logTrailer(
+          /*seq=*/ eq(2L),
+          same(status),
+          same(trailers),
+          eq(Logger.LOGGER_CLIENT),
+          eq(CALL_ID),
+          same(peer));
+      verifyNoMoreInteractions(mockSinkWriter);
+      verify(mockListener).onClose(same(status), same(trailers));
+    }
+  }
+
+  @Test
+  public void serverInterceptor() throws Exception {
+    final AtomicReference<ServerCall<byte[], byte[]>> interceptedCall =
+        new AtomicReference<>();
+    ServerCall.Listener<byte[]> capturedListener;
+    @SuppressWarnings("unchecked")
+    final ServerCall.Listener<byte[]> mockListener = mock(ServerCall.Listener.class);
+    // capture these manually because ServerCall can not be mocked
+    final AtomicReference<Metadata> actualServerInitial = new AtomicReference<>();
+    final AtomicReference<byte[]> actualResponse = new AtomicReference<>();
+    final AtomicReference<Status> actualStatus = new AtomicReference<>();
+    final AtomicReference<Metadata> actualTrailers = new AtomicReference<>();
+
+    // begin call and receive client header
+    {
+      Metadata clientInitial = new Metadata();
+      final MethodDescriptor<byte[], byte[]> method =
+          MethodDescriptor.<byte[], byte[]>newBuilder()
+              .setType(MethodType.UNKNOWN)
+              .setFullMethodName("service/method")
+              .setRequestMarshaller(BYTEARRAY_MARSHALLER)
+              .setResponseMarshaller(BYTEARRAY_MARSHALLER)
+              .build();
+      capturedListener =
+          new BinlogHelper(mockSinkWriter)
+              .getServerInterceptor(CALL_ID)
+              .interceptCall(
+                  new NoopServerCall<byte[], byte[]>() {
+                    @Override
+                    public void sendHeaders(Metadata headers) {
+                      actualServerInitial.set(headers);
+                    }
+
+                    @Override
+                    public void sendMessage(byte[] message) {
+                      actualResponse.set(message);
+                    }
+
+                    @Override
+                    public void close(Status status, Metadata trailers) {
+                      actualStatus.set(status);
+                      actualTrailers.set(trailers);
+                    }
+
+                    @Override
+                    public MethodDescriptor<byte[], byte[]> getMethodDescriptor() {
+                      return method;
+                    }
+
+                    @Override
+                    public Attributes getAttributes() {
+                      return Attributes
+                          .newBuilder()
+                          .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, peer)
+                          .build();
+                    }
+
+                    @Override
+                    public String getAuthority() {
+                      return "the-authority";
+                    }
+                  },
+                  clientInitial,
+                  new ServerCallHandler<byte[], byte[]>() {
+                    @Override
+                    public ServerCall.Listener<byte[]> startCall(
+                        ServerCall<byte[], byte[]> call,
+                        Metadata headers) {
+                      interceptedCall.set(call);
+                      return mockListener;
+                    }
+                  });
+      verify(mockSinkWriter).logClientHeader(
+          /*seq=*/ eq(1L),
+          eq("service/method"),
+          eq("the-authority"),
+          ArgumentMatchers.<Duration>isNull(),
+          same(clientInitial),
+          eq(Logger.LOGGER_SERVER),
+          eq(CALL_ID),
+          same(peer));
+      verifyNoMoreInteractions(mockSinkWriter);
+    }
+
+    // send server header
+    {
+      Metadata serverInitial = new Metadata();
+      interceptedCall.get().sendHeaders(serverInitial);
+      verify(mockSinkWriter).logServerHeader(
+          /*seq=*/ eq(2L),
+          same(serverInitial),
+          eq(Logger.LOGGER_SERVER),
+          eq(CALL_ID),
+          ArgumentMatchers.<SocketAddress>isNull());
+      verifyNoMoreInteractions(mockSinkWriter);
+      assertSame(serverInitial, actualServerInitial.get());
+    }
+
+    // receive client msg
+    {
+      byte[] request = "this is a request".getBytes(US_ASCII);
+      capturedListener.onMessage(request);
+      verify(mockSinkWriter).logRpcMessage(
+          /*seq=*/ eq(3L),
+          eq(EventType.EVENT_TYPE_CLIENT_MESSAGE),
+          same(BYTEARRAY_MARSHALLER),
+          same(request),
+          eq(Logger.LOGGER_SERVER),
+          eq(CALL_ID));
+      verifyNoMoreInteractions(mockSinkWriter);
+      verify(mockListener).onMessage(same(request));
+    }
+
+    // client half close
+    {
+      capturedListener.onHalfClose();
+      verify(mockSinkWriter).logHalfClose(
+          eq(4L),
+          eq(Logger.LOGGER_SERVER),
+          eq(CALL_ID));
+      verifyNoMoreInteractions(mockSinkWriter);
+      verify(mockListener).onHalfClose();
+    }
+
+    // send server msg
+    {
+      byte[] response = "this is a response".getBytes(US_ASCII);
+      interceptedCall.get().sendMessage(response);
+      verify(mockSinkWriter).logRpcMessage(
+          /*seq=*/ eq(5L),
+          eq(EventType.EVENT_TYPE_SERVER_MESSAGE),
+          same(BYTEARRAY_MARSHALLER),
+          same(response),
+          eq(Logger.LOGGER_SERVER),
+          eq(CALL_ID));
+      verifyNoMoreInteractions(mockSinkWriter);
+      assertSame(response, actualResponse.get());
+    }
+
+    // send trailer
+    {
+      Status status = Status.INTERNAL.withDescription("some description");
+      Metadata trailers = new Metadata();
+      interceptedCall.get().close(status, trailers);
+      verify(mockSinkWriter).logTrailer(
+          /*seq=*/ eq(6L),
+          same(status),
+          same(trailers),
+          eq(Logger.LOGGER_SERVER),
+          eq(CALL_ID),
+          ArgumentMatchers.<SocketAddress>isNull());
+      verifyNoMoreInteractions(mockSinkWriter);
+      assertSame(status, actualStatus.get());
+      assertSame(trailers, actualTrailers.get());
+    }
+
+    // cancel
+    {
+      capturedListener.onCancel();
+      verify(mockSinkWriter).logCancel(
+          /*seq=*/ eq(7L),
+          eq(Logger.LOGGER_SERVER),
+          eq(CALL_ID));
+      verify(mockListener).onCancel();
+    }
+  }
+
+  /** A builder class to make unit test code more readable. */
+  private static final class Builder {
+    int maxHeaderBytes = 0;
+    int maxMessageBytes = 0;
+
+    Builder header(int bytes) {
+      maxHeaderBytes = bytes;
+      return this;
+    }
+
+    Builder msg(int bytes) {
+      maxMessageBytes = bytes;
+      return this;
+    }
+
+    BinlogHelper build() {
+      return new BinlogHelper(
+          new SinkWriterImpl(mock(BinaryLogSink.class), null, maxHeaderBytes, maxMessageBytes));
+    }
+  }
+
+  private static void assertSameLimits(BinlogHelper a, BinlogHelper b) {
+    assertEquals(a.writer.getMaxMessageBytes(), b.writer.getMaxMessageBytes());
+    assertEquals(a.writer.getMaxHeaderBytes(), b.writer.getMaxHeaderBytes());
+  }
+
+  private BinlogHelper makeLog(String factoryConfigStr, String lookup) {
+    return new BinlogHelper.FactoryImpl(sink, factoryConfigStr).getLog(lookup);
+  }
+
+  private BinlogHelper makeOptions(String logConfigStr) {
+    return FactoryImpl.createBinaryLog(sink, logConfigStr);
+  }
+
+  private static GrpcLogEntry metadataToProtoTestHelper(
+      EventType type, Metadata metadata, int maxHeaderBytes) {
+    GrpcLogEntry.Builder builder = GrpcLogEntry.newBuilder();
+    MaybeTruncated<io.grpc.binarylog.v1.Metadata.Builder> pair
+        = BinlogHelper.createMetadataProto(metadata, maxHeaderBytes);
+    switch (type) {
+      case EVENT_TYPE_CLIENT_HEADER:
+        builder.setClientHeader(ClientHeader.newBuilder().setMetadata(pair.proto));
+        break;
+      case EVENT_TYPE_SERVER_HEADER:
+        builder.setServerHeader(ServerHeader.newBuilder().setMetadata(pair.proto));
+        break;
+      case EVENT_TYPE_SERVER_TRAILER:
+        builder.setTrailer(Trailer.newBuilder().setMetadata(pair.proto));
+        break;
+      default:
+        throw new IllegalArgumentException();
+    }
+    builder.setType(type).setPayloadTruncated(pair.truncated);
+    return builder.build();
+  }
+
+  private static GrpcLogEntry messageToProtoTestHelper(
+      byte[] message, int maxMessageBytes) {
+    GrpcLogEntry.Builder builder = GrpcLogEntry.newBuilder();
+    MaybeTruncated<Message.Builder> pair
+        = BinlogHelper.createMessageProto(message, maxMessageBytes);
+    builder.setMessage(pair.proto).setPayloadTruncated(pair.truncated);
+    return builder.build();
+  }
+}
diff --git a/services/src/test/java/io/grpc/protobuf/services/ChannelzProtoUtilTest.java b/services/src/test/java/io/grpc/protobuf/services/ChannelzProtoUtilTest.java
new file mode 100644
index 00000000000..598a8625e58
--- /dev/null
+++ b/services/src/test/java/io/grpc/protobuf/services/ChannelzProtoUtilTest.java
@@ -0,0 +1,977 @@
+/*
+ * Copyright 2018 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.protobuf.services;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.InternalChannelz.id;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Any;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.Int64Value;
+import com.google.protobuf.MessageLite;
+import com.google.protobuf.util.Durations;
+import com.google.protobuf.util.Timestamps;
+import io.grpc.ConnectivityState;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.ChannelStats;
+import io.grpc.InternalChannelz.ChannelTrace.Event;
+import io.grpc.InternalChannelz.ChannelTrace.Event.Severity;
+import io.grpc.InternalChannelz.RootChannelList;
+import io.grpc.InternalChannelz.ServerList;
+import io.grpc.InternalChannelz.ServerSocketsList;
+import io.grpc.InternalChannelz.ServerStats;
+import io.grpc.InternalChannelz.SocketOptions;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.InternalWithLogId;
+import io.grpc.channelz.v1.Address;
+import io.grpc.channelz.v1.Address.OtherAddress;
+import io.grpc.channelz.v1.Address.TcpIpAddress;
+import io.grpc.channelz.v1.Address.UdsAddress;
+import io.grpc.channelz.v1.Channel;
+import io.grpc.channelz.v1.ChannelConnectivityState;
+import io.grpc.channelz.v1.ChannelConnectivityState.State;
+import io.grpc.channelz.v1.ChannelData;
+import io.grpc.channelz.v1.ChannelRef;
+import io.grpc.channelz.v1.ChannelTrace;
+import io.grpc.channelz.v1.ChannelTraceEvent;
+import io.grpc.channelz.v1.GetChannelRequest;
+import io.grpc.channelz.v1.GetServerSocketsResponse;
+import io.grpc.channelz.v1.GetServersResponse;
+import io.grpc.channelz.v1.GetTopChannelsResponse;
+import io.grpc.channelz.v1.Security;
+import io.grpc.channelz.v1.Security.OtherSecurity;
+import io.grpc.channelz.v1.Security.Tls;
+import io.grpc.channelz.v1.Server;
+import io.grpc.channelz.v1.ServerData;
+import io.grpc.channelz.v1.ServerRef;
+import io.grpc.channelz.v1.Socket;
+import io.grpc.channelz.v1.SocketData;
+import io.grpc.channelz.v1.SocketOption;
+import io.grpc.channelz.v1.SocketOptionLinger;
+import io.grpc.channelz.v1.SocketOptionTcpInfo;
+import io.grpc.channelz.v1.SocketOptionTimeout;
+import io.grpc.channelz.v1.SocketRef;
+import io.grpc.channelz.v1.Subchannel;
+import io.grpc.channelz.v1.SubchannelRef;
+import io.grpc.protobuf.services.ChannelzTestHelper.TestChannel;
+import io.grpc.protobuf.services.ChannelzTestHelper.TestListenSocket;
+import io.grpc.protobuf.services.ChannelzTestHelper.TestServer;
+import io.grpc.protobuf.services.ChannelzTestHelper.TestSocket;
+import io.netty.channel.unix.DomainSocketAddress;
+import java.net.Inet4Address;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.security.cert.Certificate;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class ChannelzProtoUtilTest {
+
+  private final TestChannel channel = new TestChannel();
+  private final ChannelRef channelRef = ChannelRef
+      .newBuilder()
+      .setName(channel.toString())
+      .setChannelId(channel.getLogId().getId())
+      .build();
+  private final ChannelData channelData = ChannelData
+      .newBuilder()
+      .setTarget("sometarget")
+      .setState(ChannelConnectivityState.newBuilder().setState(State.READY))
+      .setCallsStarted(1)
+      .setCallsSucceeded(2)
+      .setCallsFailed(3)
+      .setLastCallStartedTimestamp(Timestamps.fromNanos(4))
+      .build();
+  private final Channel channelProto = Channel
+      .newBuilder()
+      .setRef(channelRef)
+      .setData(channelData)
+      .build();
+
+  private final TestChannel subchannel = new TestChannel();
+  private final SubchannelRef subchannelRef = SubchannelRef
+      .newBuilder()
+      .setName(subchannel.toString())
+      .setSubchannelId(subchannel.getLogId().getId())
+      .build();
+  private final ChannelData subchannelData = ChannelData
+      .newBuilder()
+      .setTarget("sometarget")
+      .setState(ChannelConnectivityState.newBuilder().setState(State.READY))
+      .setCallsStarted(1)
+      .setCallsSucceeded(2)
+      .setCallsFailed(3)
+      .setLastCallStartedTimestamp(Timestamps.fromNanos(4))
+      .build();
+  private final Subchannel subchannelProto = Subchannel
+        .newBuilder()
+        .setRef(subchannelRef)
+        .setData(subchannelData)
+        .build();
+
+  private final TestServer server = new TestServer();
+  private final ServerRef serverRef = ServerRef
+      .newBuilder()
+      .setName(server.toString())
+      .setServerId(server.getLogId().getId())
+      .build();
+  private final ServerData serverData = ServerData
+      .newBuilder()
+      .setCallsStarted(1)
+      .setCallsSucceeded(2)
+      .setCallsFailed(3)
+      .setLastCallStartedTimestamp(Timestamps.fromNanos(4))
+      .build();
+  private final Server serverProto = Server
+      .newBuilder()
+      .setRef(serverRef)
+      .setData(serverData)
+      .build();
+
+  private final SocketOption sockOptLingerDisabled =
+      SocketOption.newBuilder()
+          .setName("SO_LINGER")
+          .setAdditional(
+              Any.newBuilder()
+                  .setTypeUrl("type.googleapis.com/grpc.channelz.v1.SocketOptionLinger")
+                  .setValue(SocketOptionLinger.getDefaultInstance().toByteString())
+                  .build())
+          .build();
+
+  private final SocketOption sockOptlinger10s =
+      SocketOption.newBuilder()
+          .setName("SO_LINGER")
+          .setAdditional(
+              Any.newBuilder()
+                  .setTypeUrl("type.googleapis.com/grpc.channelz.v1.SocketOptionLinger")
+                  .setValue(
+                      SocketOptionLinger.newBuilder()
+                          .setActive(true)
+                          .setDuration(Durations.fromSeconds(10))
+                          .build()
+                          .toByteString())
+                  .build())
+          .build();
+
+  private final SocketOption sockOptTimeout200ms =
+      SocketOption.newBuilder()
+          .setName("SO_TIMEOUT")
+          .setAdditional(
+              Any.newBuilder()
+                  .setTypeUrl("type.googleapis.com/grpc.channelz.v1.SocketOptionTimeout")
+                  .setValue(
+                      SocketOptionTimeout.newBuilder()
+                          .setDuration(Durations.fromMillis(200))
+                          .build()
+                          .toByteString())
+                  .build())
+          .build();
+
+  private final SocketOption sockOptAdditional = SocketOption
+      .newBuilder()
+      .setName("SO_MADE_UP_OPTION")
+      .setValue("some-made-up-value")
+      .build();
+
+  private final InternalChannelz.TcpInfo channelzTcpInfo
+      = new InternalChannelz.TcpInfo.Builder()
+      .setState(70)
+      .setCaState(71)
+      .setRetransmits(72)
+      .setProbes(73)
+      .setBackoff(74)
+      .setOptions(75)
+      .setSndWscale(76)
+      .setRcvWscale(77)
+      .setRto(78)
+      .setAto(79)
+      .setSndMss(710)
+      .setRcvMss(711)
+      .setUnacked(712)
+      .setSacked(713)
+      .setLost(714)
+      .setRetrans(715)
+      .setFackets(716)
+      .setLastDataSent(717)
+      .setLastAckSent(718)
+      .setLastDataRecv(719)
+      .setLastAckRecv(720)
+      .setPmtu(721)
+      .setRcvSsthresh(722)
+      .setRtt(723)
+      .setRttvar(724)
+      .setSndSsthresh(725)
+      .setSndCwnd(726)
+      .setAdvmss(727)
+      .setReordering(728)
+      .build();
+
+  private final SocketOption socketOptionTcpInfo =
+      SocketOption.newBuilder()
+          .setName("TCP_INFO")
+          .setAdditional(
+              Any.newBuilder()
+                  .setTypeUrl("type.googleapis.com/grpc.channelz.v1.SocketOptionTcpInfo")
+                  .setValue(
+                      SocketOptionTcpInfo.newBuilder()
+                          .setTcpiState(70)
+                          .setTcpiCaState(71)
+                          .setTcpiRetransmits(72)
+                          .setTcpiProbes(73)
+                          .setTcpiBackoff(74)
+                          .setTcpiOptions(75)
+                          .setTcpiSndWscale(76)
+                          .setTcpiRcvWscale(77)
+                          .setTcpiRto(78)
+                          .setTcpiAto(79)
+                          .setTcpiSndMss(710)
+                          .setTcpiRcvMss(711)
+                          .setTcpiUnacked(712)
+                          .setTcpiSacked(713)
+                          .setTcpiLost(714)
+                          .setTcpiRetrans(715)
+                          .setTcpiFackets(716)
+                          .setTcpiLastDataSent(717)
+                          .setTcpiLastAckSent(718)
+                          .setTcpiLastDataRecv(719)
+                          .setTcpiLastAckRecv(720)
+                          .setTcpiPmtu(721)
+                          .setTcpiRcvSsthresh(722)
+                          .setTcpiRtt(723)
+                          .setTcpiRttvar(724)
+                          .setTcpiSndSsthresh(725)
+                          .setTcpiSndCwnd(726)
+                          .setTcpiAdvmss(727)
+                          .setTcpiReordering(728)
+                          .build()
+                          .toByteString()))
+          .build();
+
+  private final TestListenSocket listenSocket = new TestListenSocket();
+  private final SocketRef listenSocketRef = SocketRef
+      .newBuilder()
+      .setName(listenSocket.toString())
+      .setSocketId(id(listenSocket))
+      .build();
+  private final Address listenAddress = Address
+      .newBuilder()
+      .setTcpipAddress(
+          TcpIpAddress
+              .newBuilder()
+              .setIpAddress(ByteString.copyFrom(
+                  ((InetSocketAddress) listenSocket.listenAddress).getAddress().getAddress()))
+              .setPort(1234))
+      .build();
+
+  private final TestSocket socket = new TestSocket();
+  private final SocketRef socketRef = SocketRef
+      .newBuilder()
+      .setName(socket.toString())
+      .setSocketId(socket.getLogId().getId())
+      .build();
+  private final SocketData socketDataWithDataNoSockOpts = SocketData
+      .newBuilder()
+      .setStreamsStarted(1)
+      .setLastLocalStreamCreatedTimestamp(Timestamps.fromNanos(2))
+      .setLastRemoteStreamCreatedTimestamp(Timestamps.fromNanos(3))
+      .setStreamsSucceeded(4)
+      .setStreamsFailed(5)
+      .setMessagesSent(6)
+      .setMessagesReceived(7)
+      .setKeepAlivesSent(8)
+      .setLastMessageSentTimestamp(Timestamps.fromNanos(9))
+      .setLastMessageReceivedTimestamp(Timestamps.fromNanos(10))
+      .setLocalFlowControlWindow(Int64Value.newBuilder().setValue(11))
+      .setRemoteFlowControlWindow(Int64Value.newBuilder().setValue(12))
+      .build();
+  private final Address localAddress = Address
+      .newBuilder()
+      .setTcpipAddress(
+          TcpIpAddress
+              .newBuilder()
+              .setIpAddress(ByteString.copyFrom(
+                  ((InetSocketAddress) socket.local).getAddress().getAddress()))
+              .setPort(1000))
+      .build();
+  private final Address remoteAddress = Address
+      .newBuilder()
+      .setTcpipAddress(
+          TcpIpAddress
+              .newBuilder()
+              .setIpAddress(ByteString.copyFrom(
+                  ((InetSocketAddress) socket.remote).getAddress().getAddress()))
+              .setPort(1000))
+      .build();
+
+  private final ChannelTrace channelTrace = ChannelTrace
+      .newBuilder()
+      .setNumEventsLogged(1234)
+      .setCreationTimestamp(Timestamps.fromNanos(1000))
+      .build();
+
+  @Test
+  public void toChannelRef() {
+    assertEquals(channelRef, ChannelzProtoUtil.toChannelRef(channel));
+  }
+
+  @Test
+  public void toSubchannelRef() {
+    assertEquals(subchannelRef, ChannelzProtoUtil.toSubchannelRef(subchannel));
+  }
+
+  @Test
+  public void toServerRef() {
+    assertEquals(serverRef, ChannelzProtoUtil.toServerRef(server));
+  }
+
+  @Test
+  public void toSeverity() {
+    for (Severity severity : Severity.values()) {
+      assertEquals(
+          severity.name(),
+          ChannelzProtoUtil.toSeverity(severity).name()); // OK because test isn't proguarded.
+    }
+    assertEquals(ChannelTraceEvent.Severity.CT_UNKNOWN, ChannelzProtoUtil.toSeverity(null));
+  }
+
+  @Test
+  public void toSocketRef() {
+    assertEquals(socketRef, ChannelzProtoUtil.toSocketRef(socket));
+  }
+
+  @Test
+  public void toState() {
+    for (ConnectivityState connectivityState : ConnectivityState.values()) {
+      assertEquals(
+          connectivityState.name(),
+          ChannelzProtoUtil.toState(connectivityState).name()); // OK because test isn't proguarded.
+    }
+    assertEquals(State.UNKNOWN, ChannelzProtoUtil.toState(null));
+  }
+
+  @Test
+  public void toSocket_withDataNoOptions() throws Exception {
+    assertEquals(
+        Socket
+            .newBuilder()
+            .setRef(socketRef)
+            .setLocal(localAddress)
+            .setRemote(remoteAddress)
+            .setData(socketDataWithDataNoSockOpts)
+            .build(),
+        ChannelzProtoUtil.toSocket(socket));
+  }
+
+  @Test
+  public void toSocket_noDataWithOptions() throws Exception {
+    assertEquals(
+        Socket
+            .newBuilder()
+            .setRef(listenSocketRef)
+            .setLocal(listenAddress)
+            .setData(
+                SocketData
+                    .newBuilder()
+                    .addOption(
+                        SocketOption
+                            .newBuilder()
+                            .setName("listen_option")
+                            .setValue("listen_option_value")))
+            .build(),
+        ChannelzProtoUtil.toSocket(listenSocket));
+  }
+
+  @Test
+  public void toSocket_withDataWithOptions() throws Exception {
+    socket.socketOptions
+        = new SocketOptions(null, null, null, ImmutableMap.of("test_name", "test_value"));
+    assertEquals(
+        Socket
+            .newBuilder()
+            .setRef(socketRef)
+            .setLocal(localAddress)
+            .setRemote(remoteAddress)
+            .setData(
+                SocketData
+                    .newBuilder(socketDataWithDataNoSockOpts)
+                    .addOption(
+                        SocketOption.newBuilder()
+                            .setName("test_name").setValue("test_value")))
+            .build(),
+        ChannelzProtoUtil.toSocket(socket));
+  }
+
+  @Test
+  public void extractSocketData() throws Exception {
+    // no options
+    assertEquals(
+        socketDataWithDataNoSockOpts,
+        ChannelzProtoUtil.extractSocketData(socket.getStats().get()));
+
+    // with options
+    socket.socketOptions = toBuilder(socket.socketOptions)
+        .setSocketOptionLingerSeconds(10)
+        .setTcpInfo(channelzTcpInfo)
+        .build();
+    assertEquals(
+        socketDataWithDataNoSockOpts
+            .toBuilder()
+            .addOption(sockOptlinger10s)
+            .addOption(socketOptionTcpInfo)
+            .build(),
+        ChannelzProtoUtil.extractSocketData(socket.getStats().get()));
+  }
+
+  @Test
+  public void toSocketData() throws Exception {
+    assertEquals(
+        socketDataWithDataNoSockOpts
+            .toBuilder()
+            .build(),
+        ChannelzProtoUtil.extractSocketData(socket.getStats().get()));
+  }
+
+  @Test
+  public void socketSecurityTls() throws Exception {
+    Certificate local = mock(Certificate.class);
+    Certificate remote = mock(Certificate.class);
+    when(local.getEncoded()).thenReturn("localcert".getBytes(StandardCharsets.UTF_8));
+    when(remote.getEncoded()).thenReturn("remotecert".getBytes(StandardCharsets.UTF_8));
+
+    socket.security = new InternalChannelz.Security(
+        new InternalChannelz.Tls("TLS_NULL_WITH_NULL_NULL", local, remote));
+    assertEquals(
+        Security.newBuilder().setTls(
+            Tls.newBuilder()
+            .setStandardName("TLS_NULL_WITH_NULL_NULL")
+            .setLocalCertificate(ByteString.copyFrom("localcert", StandardCharsets.UTF_8))
+            .setRemoteCertificate(ByteString.copyFrom("remotecert", StandardCharsets.UTF_8)))
+        .build(),
+        ChannelzProtoUtil.toSocket(socket).getSecurity());
+
+    socket.security = new InternalChannelz.Security(
+        new InternalChannelz.Tls("TLS_NULL_WITH_NULL_NULL", /*localCert=*/ null, remote));
+    assertEquals(
+        Security.newBuilder().setTls(
+            Tls.newBuilder()
+            .setStandardName("TLS_NULL_WITH_NULL_NULL")
+            .setRemoteCertificate(ByteString.copyFrom("remotecert", StandardCharsets.UTF_8)))
+        .build(),
+        ChannelzProtoUtil.toSocket(socket).getSecurity());
+
+    socket.security = new InternalChannelz.Security(
+        new InternalChannelz.Tls("TLS_NULL_WITH_NULL_NULL", local, /*remoteCert=*/ null));
+    assertEquals(
+        Security.newBuilder().setTls(
+            Tls.newBuilder()
+                .setStandardName("TLS_NULL_WITH_NULL_NULL")
+                .setLocalCertificate(ByteString.copyFrom("localcert", StandardCharsets.UTF_8)))
+            .build(),
+            ChannelzProtoUtil.toSocket(socket).getSecurity());
+  }
+
+  @Test
+  public void socketSecurityOther() throws Exception {
+    // what is packed here is not important, just pick some proto message
+    MessageLite contents = GetChannelRequest.newBuilder().setChannelId(1).build();
+    Any packed =
+        Any.newBuilder()
+            .setTypeUrl("type.googleapis.com/grpc.channelz.v1.GetChannelRequest")
+            .setValue(contents.toByteString())
+            .build();
+    socket.security
+        = new InternalChannelz.Security(
+            new InternalChannelz.OtherSecurity("other_security", packed));
+    assertEquals(
+        Security.newBuilder().setOther(
+            OtherSecurity.newBuilder().setName("other_security").setValue(packed))
+        .build(),
+        ChannelzProtoUtil.toSocket(socket).getSecurity());
+  }
+
+  @Test
+  public void toAddress_inet() throws Exception {
+    InetSocketAddress inet4 = new InetSocketAddress(Inet4Address.getByName("10.0.0.1"), 1000);
+    assertEquals(
+        Address.newBuilder().setTcpipAddress(
+            TcpIpAddress
+                .newBuilder()
+                .setIpAddress(ByteString.copyFrom(inet4.getAddress().getAddress()))
+                .setPort(1000))
+            .build(),
+        ChannelzProtoUtil.toAddress(inet4));
+  }
+
+  @Test
+  public void toAddress_uds() throws Exception {
+    String path = "/tmp/foo";
+    DomainSocketAddress uds = new DomainSocketAddress(path);
+    assertEquals(
+        Address.newBuilder().setUdsAddress(
+            UdsAddress
+                .newBuilder()
+                .setFilename(path))
+            .build(),
+        ChannelzProtoUtil.toAddress(uds));
+  }
+
+  @Test
+  public void toAddress_other() throws Exception {
+    final String name = "my name";
+    SocketAddress other = new SocketAddress() {
+      @Override
+      public String toString() {
+        return name;
+      }
+    };
+    assertEquals(
+        Address.newBuilder().setOtherAddress(
+            OtherAddress
+                .newBuilder()
+                .setName(name))
+            .build(),
+        ChannelzProtoUtil.toAddress(other));
+  }
+
+  @Test
+  public void toServer() throws Exception {
+    // no listen sockets
+    assertEquals(serverProto, ChannelzProtoUtil.toServer(server));
+
+    // 1 listen socket
+    server.serverStats = toBuilder(server.serverStats)
+        .addListenSockets(ImmutableList.<InternalInstrumented<SocketStats>>of(listenSocket))
+        .build();
+    assertEquals(
+        serverProto
+            .toBuilder()
+            .addListenSocket(listenSocketRef)
+            .build(),
+        ChannelzProtoUtil.toServer(server));
+
+    // multiple listen sockets
+    TestListenSocket otherListenSocket = new TestListenSocket();
+    SocketRef otherListenSocketRef = ChannelzProtoUtil.toSocketRef(otherListenSocket);
+    server.serverStats = toBuilder(server.serverStats)
+        .addListenSockets(
+            ImmutableList.<InternalInstrumented<SocketStats>>of(otherListenSocket))
+        .build();
+    assertEquals(
+        serverProto
+            .toBuilder()
+            .addListenSocket(listenSocketRef)
+            .addListenSocket(otherListenSocketRef)
+            .build(),
+        ChannelzProtoUtil.toServer(server));
+  }
+
+  @Test
+  public void toServerData() throws Exception {
+    assertEquals(serverData, ChannelzProtoUtil.toServerData(server.serverStats));
+  }
+
+  @Test
+  public void toChannel() throws Exception {
+    assertEquals(channelProto, ChannelzProtoUtil.toChannel(channel));
+
+    channel.stats = toBuilder(channel.stats)
+        .setSubchannels(ImmutableList.<InternalWithLogId>of(subchannel))
+        .build();
+
+    assertEquals(
+        channelProto
+            .toBuilder()
+            .addSubchannelRef(subchannelRef)
+            .build(),
+        ChannelzProtoUtil.toChannel(channel));
+
+    TestChannel otherSubchannel = new TestChannel();
+    channel.stats = toBuilder(channel.stats)
+        .setSubchannels(ImmutableList.<InternalWithLogId>of(subchannel, otherSubchannel))
+        .build();
+    assertEquals(
+        channelProto
+            .toBuilder()
+            .addSubchannelRef(subchannelRef)
+            .addSubchannelRef(ChannelzProtoUtil.toSubchannelRef(otherSubchannel))
+            .build(),
+        ChannelzProtoUtil.toChannel(channel));
+  }
+
+  @Test
+  public void extractChannelData() {
+    assertEquals(channelData, ChannelzProtoUtil.extractChannelData(channel.stats));
+  }
+
+  @Test
+  public void toSubchannel_noChildren() throws Exception {
+    assertEquals(
+        subchannelProto,
+        ChannelzProtoUtil.toSubchannel(subchannel));
+  }
+
+  @Test
+  public void toSubchannel_socketChildren() throws Exception {
+    subchannel.stats = toBuilder(subchannel.stats)
+        .setSockets(ImmutableList.<InternalWithLogId>of(socket))
+        .build();
+
+    assertEquals(
+        subchannelProto.toBuilder()
+            .addSocketRef(socketRef)
+            .build(),
+        ChannelzProtoUtil.toSubchannel(subchannel));
+
+    TestSocket otherSocket = new TestSocket();
+    subchannel.stats = toBuilder(subchannel.stats)
+        .setSockets(ImmutableList.<InternalWithLogId>of(socket, otherSocket))
+        .build();
+    assertEquals(
+        subchannelProto
+            .toBuilder()
+            .addSocketRef(socketRef)
+            .addSocketRef(ChannelzProtoUtil.toSocketRef(otherSocket))
+            .build(),
+        ChannelzProtoUtil.toSubchannel(subchannel));
+  }
+
+  @Test
+  public void toSubchannel_subchannelChildren() throws Exception {
+    TestChannel subchannel1 = new TestChannel();
+    subchannel.stats = toBuilder(subchannel.stats)
+        .setSubchannels(ImmutableList.<InternalWithLogId>of(subchannel1))
+        .build();
+    assertEquals(
+        subchannelProto.toBuilder()
+            .addSubchannelRef(ChannelzProtoUtil.toSubchannelRef(subchannel1))
+            .build(),
+        ChannelzProtoUtil.toSubchannel(subchannel));
+
+    TestChannel subchannel2 = new TestChannel();
+    subchannel.stats = toBuilder(subchannel.stats)
+        .setSubchannels(ImmutableList.<InternalWithLogId>of(subchannel1, subchannel2))
+        .build();
+    assertEquals(
+        subchannelProto
+            .toBuilder()
+            .addSubchannelRef(ChannelzProtoUtil.toSubchannelRef(subchannel1))
+            .addSubchannelRef(ChannelzProtoUtil.toSubchannelRef(subchannel2))
+            .build(),
+        ChannelzProtoUtil.toSubchannel(subchannel));
+  }
+
+  @Test
+  public void toGetTopChannelsResponse() {
+    // empty results
+    assertEquals(
+        GetTopChannelsResponse.newBuilder().setEnd(true).build(),
+        ChannelzProtoUtil.toGetTopChannelResponse(
+            new RootChannelList(
+                Collections.<InternalInstrumented<ChannelStats>>emptyList(), true)));
+
+    // 1 result, paginated
+    assertEquals(
+        GetTopChannelsResponse
+            .newBuilder()
+            .addChannel(channelProto)
+            .build(),
+        ChannelzProtoUtil.toGetTopChannelResponse(
+            new RootChannelList(
+                ImmutableList.<InternalInstrumented<ChannelStats>>of(channel), false)));
+
+    // 1 result, end
+    assertEquals(
+        GetTopChannelsResponse
+            .newBuilder()
+            .addChannel(channelProto)
+            .setEnd(true)
+            .build(),
+        ChannelzProtoUtil.toGetTopChannelResponse(
+            new RootChannelList(
+                ImmutableList.<InternalInstrumented<ChannelStats>>of(channel), true)));
+
+    // 2 results, end
+    TestChannel channel2 = new TestChannel();
+    assertEquals(
+        GetTopChannelsResponse
+            .newBuilder()
+            .addChannel(channelProto)
+            .addChannel(ChannelzProtoUtil.toChannel(channel2))
+            .setEnd(true)
+            .build(),
+        ChannelzProtoUtil.toGetTopChannelResponse(
+            new RootChannelList(
+                ImmutableList.<InternalInstrumented<ChannelStats>>of(channel, channel2), true)));
+  }
+
+  @Test
+  public void toGetServersResponse() {
+    // empty results
+    assertEquals(
+        GetServersResponse.getDefaultInstance(),
+        ChannelzProtoUtil.toGetServersResponse(
+            new ServerList(Collections.<InternalInstrumented<ServerStats>>emptyList(), false)));
+
+    // 1 result, paginated
+    assertEquals(
+        GetServersResponse
+            .newBuilder()
+            .addServer(serverProto)
+            .build(),
+        ChannelzProtoUtil.toGetServersResponse(
+            new ServerList(ImmutableList.<InternalInstrumented<ServerStats>>of(server), false)));
+
+    // 1 result, end
+    assertEquals(
+        GetServersResponse
+            .newBuilder()
+            .addServer(serverProto)
+            .setEnd(true)
+            .build(),
+        ChannelzProtoUtil.toGetServersResponse(
+            new ServerList(ImmutableList.<InternalInstrumented<ServerStats>>of(server), true)));
+
+    TestServer server2 = new TestServer();
+    // 2 results, end
+    assertEquals(
+        GetServersResponse
+            .newBuilder()
+            .addServer(serverProto)
+            .addServer(ChannelzProtoUtil.toServer(server2))
+            .setEnd(true)
+            .build(),
+        ChannelzProtoUtil.toGetServersResponse(
+            new ServerList(
+                ImmutableList.<InternalInstrumented<ServerStats>>of(server, server2), true)));
+  }
+
+  @Test
+  public void toGetServerSocketsResponse() {
+    // empty results
+    assertEquals(
+        GetServerSocketsResponse.getDefaultInstance(),
+        ChannelzProtoUtil.toGetServerSocketsResponse(
+            new ServerSocketsList(Collections.<InternalWithLogId>emptyList(), false)));
+
+    // 1 result, paginated
+    assertEquals(
+        GetServerSocketsResponse
+            .newBuilder()
+            .addSocketRef(socketRef)
+            .build(),
+        ChannelzProtoUtil.toGetServerSocketsResponse(
+            new ServerSocketsList(ImmutableList.<InternalWithLogId>of(socket), false)));
+
+    // 1 result, end
+    assertEquals(
+        GetServerSocketsResponse
+            .newBuilder()
+            .addSocketRef(socketRef)
+            .setEnd(true)
+            .build(),
+        ChannelzProtoUtil.toGetServerSocketsResponse(
+            new ServerSocketsList(ImmutableList.<InternalWithLogId>of(socket), true)));
+
+    TestSocket socket2 = new TestSocket();
+    // 2 results, end
+    assertEquals(
+        GetServerSocketsResponse
+            .newBuilder()
+            .addSocketRef(socketRef)
+            .addSocketRef(ChannelzProtoUtil.toSocketRef(socket2))
+            .setEnd(true)
+            .build(),
+        ChannelzProtoUtil.toGetServerSocketsResponse(
+            new ServerSocketsList(ImmutableList.<InternalWithLogId>of(socket, socket2), true)));
+  }
+
+  @Test
+  public void toSocketOptionLinger() {
+    assertEquals(sockOptLingerDisabled, ChannelzProtoUtil.toSocketOptionLinger(-1));
+    assertEquals(sockOptlinger10s, ChannelzProtoUtil.toSocketOptionLinger(10));
+  }
+
+  @Test
+  public void toSocketOptionTimeout() {
+    assertEquals(
+        sockOptTimeout200ms, ChannelzProtoUtil.toSocketOptionTimeout("SO_TIMEOUT", 200));
+  }
+
+  @Test
+  public void toSocketOptionAdditional() {
+    assertEquals(
+        sockOptAdditional,
+        ChannelzProtoUtil.toSocketOptionAdditional("SO_MADE_UP_OPTION", "some-made-up-value"));
+  }
+
+  @Test
+  public void toSocketOptionTcpInfo() {
+    assertEquals(
+        socketOptionTcpInfo,
+        ChannelzProtoUtil.toSocketOptionTcpInfo(channelzTcpInfo));
+  }
+
+  @Test
+  public void toSocketOptionsList() {
+    assertThat(
+        ChannelzProtoUtil.toSocketOptionsList(
+            new InternalChannelz.SocketOptions.Builder().build()))
+        .isEmpty();
+
+    assertThat(
+        ChannelzProtoUtil.toSocketOptionsList(
+            new InternalChannelz.SocketOptions.Builder().setSocketOptionLingerSeconds(10).build()))
+        .containsExactly(sockOptlinger10s);
+
+    assertThat(
+        ChannelzProtoUtil.toSocketOptionsList(
+            new InternalChannelz.SocketOptions.Builder().setSocketOptionTimeoutMillis(200).build()))
+        .containsExactly(sockOptTimeout200ms);
+
+    assertThat(
+        ChannelzProtoUtil.toSocketOptionsList(
+            new InternalChannelz.SocketOptions
+                .Builder()
+                .addOption("SO_MADE_UP_OPTION", "some-made-up-value")
+                .build()))
+        .containsExactly(sockOptAdditional);
+
+    SocketOption otherOption = SocketOption
+        .newBuilder()
+        .setName("SO_MADE_UP_OPTION2")
+        .setValue("some-made-up-value2")
+        .build();
+    assertThat(
+        ChannelzProtoUtil.toSocketOptionsList(
+            new InternalChannelz.SocketOptions.Builder()
+                .addOption("SO_MADE_UP_OPTION", "some-made-up-value")
+                .addOption("SO_MADE_UP_OPTION2", "some-made-up-value2")
+                .build()))
+        .containsExactly(sockOptAdditional, otherOption);
+  }
+
+  @Test
+  public void channelTrace_withoutEvents() {
+    ChannelStats stats = toBuilder(channel.stats)
+        .setChannelTrace(new InternalChannelz.ChannelTrace.Builder()
+            .setNumEventsLogged(1234)
+            .setCreationTimeNanos(1000)
+            .build())
+        .build();
+
+    ChannelData protoStats = channelData.toBuilder().setTrace(channelTrace).build();
+    assertEquals(ChannelzProtoUtil.extractChannelData(stats), protoStats);
+  }
+
+  @Test
+  public void channelTrace_withEvents() {
+    Event event1 = new Event.Builder()
+        .setDescription("event1")
+        .setSeverity(Severity.CT_ERROR)
+        .setTimestampNanos(12)
+        .setSubchannelRef(subchannel)
+        .build();
+    Event event2 = new Event.Builder()
+        .setDescription("event2")
+        .setTimestampNanos(34)
+        .setSeverity(Severity.CT_INFO)
+        .setChannelRef(channel)
+        .build();
+
+    ChannelStats stats =
+        toBuilder(channel.stats)
+            .setChannelTrace(
+                new InternalChannelz.ChannelTrace.Builder()
+                    .setNumEventsLogged(1234)
+                    .setCreationTimeNanos(1000)
+                    .setEvents(Arrays.asList(event1, event2))
+                    .build())
+            .build();
+
+    ChannelTraceEvent protoEvent1 = ChannelTraceEvent
+        .newBuilder()
+        .setDescription("event1")
+        .setTimestamp(Timestamps.fromNanos(12))
+        .setSeverity(ChannelTraceEvent.Severity.CT_ERROR)
+        .setSubchannelRef(subchannelRef)
+        .build();
+    ChannelTraceEvent protoEvent2 = ChannelTraceEvent
+        .newBuilder()
+        .setDescription("event2")
+        .setTimestamp(Timestamps.fromNanos(34))
+        .setSeverity(ChannelTraceEvent.Severity.CT_INFO)
+        .setChannelRef(channelRef)
+        .build();
+    ChannelData protoStats = channelData
+        .toBuilder()
+        .setTrace(channelTrace
+            .toBuilder()
+            .addAllEvents(Arrays.asList(protoEvent1, protoEvent2))
+            .build())
+        .build();
+    assertEquals(ChannelzProtoUtil.extractChannelData(stats), protoStats);
+  }
+
+  private static ChannelStats.Builder toBuilder(ChannelStats stats) {
+    ChannelStats.Builder builder = new ChannelStats.Builder()
+        .setTarget(stats.target)
+        .setState(stats.state)
+        .setCallsStarted(stats.callsStarted)
+        .setCallsSucceeded(stats.callsSucceeded)
+        .setCallsFailed(stats.callsFailed)
+        .setLastCallStartedNanos(stats.lastCallStartedNanos);
+    if (!stats.subchannels.isEmpty()) {
+      builder.setSubchannels(stats.subchannels);
+    }
+    if (!stats.sockets.isEmpty()) {
+      builder.setSockets(stats.sockets);
+    }
+    return builder;
+  }
+
+
+  private static SocketOptions.Builder toBuilder(SocketOptions options) {
+    SocketOptions.Builder builder = new SocketOptions.Builder()
+        .setSocketOptionTimeoutMillis(options.soTimeoutMillis)
+        .setSocketOptionLingerSeconds(options.lingerSeconds);
+    for (Map.Entry<String, String> entry : options.others.entrySet()) {
+      builder.addOption(entry.getKey(), entry.getValue());
+    }
+    return builder;
+  }
+
+  private static ServerStats.Builder toBuilder(ServerStats stats) {
+    return new ServerStats.Builder()
+        .setCallsStarted(stats.callsStarted)
+        .setCallsSucceeded(stats.callsSucceeded)
+        .setCallsFailed(stats.callsFailed)
+        .setLastCallStartedNanos(stats.lastCallStartedNanos)
+        .addListenSockets(stats.listenSockets);
+  }
+}
diff --git a/services/src/test/java/io/grpc/protobuf/services/ChannelzServiceTest.java b/services/src/test/java/io/grpc/protobuf/services/ChannelzServiceTest.java
new file mode 100644
index 00000000000..bb520a16dec
--- /dev/null
+++ b/services/src/test/java/io/grpc/protobuf/services/ChannelzServiceTest.java
@@ -0,0 +1,275 @@
+/*
+ * Copyright 2018 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.protobuf.services;
+
+import static com.google.common.truth.Truth.assertWithMessage;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.InternalChannelz;
+import io.grpc.Status;
+import io.grpc.channelz.v1.GetChannelRequest;
+import io.grpc.channelz.v1.GetChannelResponse;
+import io.grpc.channelz.v1.GetServerRequest;
+import io.grpc.channelz.v1.GetServerResponse;
+import io.grpc.channelz.v1.GetServersRequest;
+import io.grpc.channelz.v1.GetServersResponse;
+import io.grpc.channelz.v1.GetSocketRequest;
+import io.grpc.channelz.v1.GetSocketResponse;
+import io.grpc.channelz.v1.GetSubchannelRequest;
+import io.grpc.channelz.v1.GetSubchannelResponse;
+import io.grpc.channelz.v1.GetTopChannelsRequest;
+import io.grpc.channelz.v1.GetTopChannelsResponse;
+import io.grpc.protobuf.services.ChannelzTestHelper.TestChannel;
+import io.grpc.protobuf.services.ChannelzTestHelper.TestServer;
+import io.grpc.protobuf.services.ChannelzTestHelper.TestSocket;
+import io.grpc.stub.StreamObserver;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+
+@RunWith(JUnit4.class)
+public class ChannelzServiceTest {
+  // small value to force pagination
+  private static final int MAX_PAGE_SIZE = 1;
+
+  private final InternalChannelz channelz = new InternalChannelz();
+  private ChannelzService service = new ChannelzService(channelz, MAX_PAGE_SIZE);
+
+  @Test
+  public void getTopChannels_empty() {
+    assertEquals(
+        GetTopChannelsResponse.newBuilder().setEnd(true).build(),
+        getTopChannelHelper(0));
+  }
+
+  @Test
+  public void getTopChannels_onePage() throws Exception {
+    TestChannel root = new TestChannel();
+    channelz.addRootChannel(root);
+
+    assertEquals(
+        GetTopChannelsResponse
+            .newBuilder()
+            .addChannel(ChannelzProtoUtil.toChannel(root))
+            .setEnd(true)
+            .build(),
+        getTopChannelHelper(0));
+  }
+
+  @Test
+  public void getChannel() throws ExecutionException, InterruptedException {
+    TestChannel root = new TestChannel();
+    assertChannelNotFound(root.getLogId().getId());
+
+    channelz.addRootChannel(root);
+    assertEquals(
+        GetChannelResponse
+            .newBuilder()
+            .setChannel(ChannelzProtoUtil.toChannel(root))
+            .build(),
+        getChannelHelper(root.getLogId().getId()));
+
+    channelz.removeRootChannel(root);
+    assertChannelNotFound(root.getLogId().getId());
+  }
+
+  @Test
+  public void getSubchannel() throws Exception {
+    TestChannel subchannel = new TestChannel();
+    assertSubchannelNotFound(subchannel.getLogId().getId());
+
+    channelz.addSubchannel(subchannel);
+    assertEquals(
+        GetSubchannelResponse
+            .newBuilder()
+            .setSubchannel(ChannelzProtoUtil.toSubchannel(subchannel))
+            .build(),
+        getSubchannelHelper(subchannel.getLogId().getId()));
+
+    channelz.removeSubchannel(subchannel);
+    assertSubchannelNotFound(subchannel.getLogId().getId());
+  }
+
+  @Test
+  public void getServers_empty() {
+    assertEquals(
+        GetServersResponse.newBuilder().setEnd(true).build(),
+        getServersHelper(0));
+  }
+
+  @Test
+  public void getServers_onePage() throws Exception {
+    TestServer server = new TestServer();
+    channelz.addServer(server);
+
+    assertEquals(
+        GetServersResponse
+            .newBuilder()
+            .addServer(ChannelzProtoUtil.toServer(server))
+            .setEnd(true)
+            .build(),
+        getServersHelper(0));
+  }
+
+  @Test
+  public void getServer() throws ExecutionException, InterruptedException {
+    TestServer server = new TestServer();
+    assertServerNotFound(server.getLogId().getId());
+
+    channelz.addServer(server);
+    assertEquals(
+        GetServerResponse
+            .newBuilder()
+            .setServer(ChannelzProtoUtil.toServer(server))
+            .build(),
+        getServerHelper(server.getLogId().getId()));
+
+    channelz.removeServer(server);
+    assertServerNotFound(server.getLogId().getId());
+  }
+
+
+  @Test
+  public void getSocket() throws Exception {
+    TestSocket socket = new TestSocket();
+    assertSocketNotFound(socket.getLogId().getId());
+
+    channelz.addClientSocket(socket);
+    assertEquals(
+        GetSocketResponse
+            .newBuilder()
+            .setSocket(ChannelzProtoUtil.toSocket(socket))
+            .build(),
+        getSocketHelper(socket.getLogId().getId()));
+
+    channelz.removeClientSocket(socket);
+    assertSocketNotFound(socket.getLogId().getId());
+  }
+
+  private GetTopChannelsResponse getTopChannelHelper(long startId) {
+    @SuppressWarnings("unchecked")
+    StreamObserver<GetTopChannelsResponse> observer = mock(StreamObserver.class);
+    ArgumentCaptor<GetTopChannelsResponse> responseCaptor
+        = ArgumentCaptor.forClass(GetTopChannelsResponse.class);
+    service.getTopChannels(
+        GetTopChannelsRequest.newBuilder().setStartChannelId(startId).build(),
+        observer);
+    verify(observer).onNext(responseCaptor.capture());
+    verify(observer).onCompleted();
+    return responseCaptor.getValue();
+  }
+
+  private GetChannelResponse getChannelHelper(long id) {
+    @SuppressWarnings("unchecked")
+    StreamObserver<GetChannelResponse> observer = mock(StreamObserver.class);
+    ArgumentCaptor<GetChannelResponse> response
+        = ArgumentCaptor.forClass(GetChannelResponse.class);
+    service.getChannel(GetChannelRequest.newBuilder().setChannelId(id).build(), observer);
+    verify(observer).onNext(response.capture());
+    verify(observer).onCompleted();
+    return response.getValue();
+  }
+
+  private void assertChannelNotFound(long id) {
+    @SuppressWarnings("unchecked")
+    StreamObserver<GetChannelResponse> observer = mock(StreamObserver.class);
+    ArgumentCaptor<Exception> exceptionCaptor = ArgumentCaptor.forClass(Exception.class);
+    service.getChannel(GetChannelRequest.newBuilder().setChannelId(id).build(), observer);
+    verify(observer).onError(exceptionCaptor.capture());
+    Status s = Status.fromThrowable(exceptionCaptor.getValue());
+    assertWithMessage(s.toString()).that(s.getCode()).isEqualTo(Status.Code.NOT_FOUND);
+  }
+
+  private GetSubchannelResponse getSubchannelHelper(long id) {
+    @SuppressWarnings("unchecked")
+    StreamObserver<GetSubchannelResponse> observer = mock(StreamObserver.class);
+    ArgumentCaptor<GetSubchannelResponse> response
+        = ArgumentCaptor.forClass(GetSubchannelResponse.class);
+    service.getSubchannel(GetSubchannelRequest.newBuilder().setSubchannelId(id).build(), observer);
+    verify(observer).onNext(response.capture());
+    verify(observer).onCompleted();
+    return response.getValue();
+  }
+
+  private void assertSubchannelNotFound(long id) {
+    @SuppressWarnings("unchecked")
+    StreamObserver<GetSubchannelResponse> observer = mock(StreamObserver.class);
+    ArgumentCaptor<Exception> exceptionCaptor = ArgumentCaptor.forClass(Exception.class);
+    service.getSubchannel(GetSubchannelRequest.newBuilder().setSubchannelId(id).build(), observer);
+    verify(observer).onError(exceptionCaptor.capture());
+    Status s = Status.fromThrowable(exceptionCaptor.getValue());
+    assertWithMessage(s.toString()).that(s.getCode()).isEqualTo(Status.Code.NOT_FOUND);
+  }
+
+  private GetServersResponse getServersHelper(long startId) {
+    @SuppressWarnings("unchecked")
+    StreamObserver<GetServersResponse> observer = mock(StreamObserver.class);
+    ArgumentCaptor<GetServersResponse> responseCaptor
+        = ArgumentCaptor.forClass(GetServersResponse.class);
+    service.getServers(
+        GetServersRequest.newBuilder().setStartServerId(startId).build(),
+        observer);
+    verify(observer).onNext(responseCaptor.capture());
+    verify(observer).onCompleted();
+    return responseCaptor.getValue();
+  }
+
+  private void assertServerNotFound(long id) {
+    @SuppressWarnings("unchecked")
+    StreamObserver<GetServerResponse> observer = mock(StreamObserver.class);
+    ArgumentCaptor<Exception> exceptionCaptor = ArgumentCaptor.forClass(Exception.class);
+    service.getServer(GetServerRequest.newBuilder().setServerId(id).build(), observer);
+    verify(observer).onError(exceptionCaptor.capture());
+    Status s = Status.fromThrowable(exceptionCaptor.getValue());
+    assertWithMessage(s.toString()).that(s.getCode()).isEqualTo(Status.Code.NOT_FOUND);
+  }
+
+  private GetServerResponse getServerHelper(long id) {
+    @SuppressWarnings("unchecked")
+    StreamObserver<GetServerResponse> observer = mock(StreamObserver.class);
+    ArgumentCaptor<GetServerResponse> response = ArgumentCaptor.forClass(GetServerResponse.class);
+    service.getServer(GetServerRequest.newBuilder().setServerId(id).build(), observer);
+    verify(observer).onNext(response.capture());
+    verify(observer).onCompleted();
+    return response.getValue();
+  }
+
+  private void assertSocketNotFound(long id) {
+    @SuppressWarnings("unchecked")
+    StreamObserver<GetSocketResponse> observer = mock(StreamObserver.class);
+    ArgumentCaptor<Exception> exceptionCaptor = ArgumentCaptor.forClass(Exception.class);
+    service.getSocket(GetSocketRequest.newBuilder().setSocketId(id).build(), observer);
+    verify(observer).onError(exceptionCaptor.capture());
+    Status s = Status.fromThrowable(exceptionCaptor.getValue());
+    assertWithMessage(s.toString()).that(s.getCode()).isEqualTo(Status.Code.NOT_FOUND);
+  }
+
+  private GetSocketResponse getSocketHelper(long id) {
+    @SuppressWarnings("unchecked")
+    StreamObserver<GetSocketResponse> observer = mock(StreamObserver.class);
+    ArgumentCaptor<GetSocketResponse> response
+        = ArgumentCaptor.forClass(GetSocketResponse.class);
+    service.getSocket(GetSocketRequest.newBuilder().setSocketId(id).build(), observer);
+    verify(observer).onNext(response.capture());
+    verify(observer).onCompleted();
+    return response.getValue();
+  }
+}
diff --git a/services/src/test/java/io/grpc/protobuf/services/ChannelzTestHelper.java b/services/src/test/java/io/grpc/protobuf/services/ChannelzTestHelper.java
new file mode 100644
index 00000000000..0b93a8d9271
--- /dev/null
+++ b/services/src/test/java/io/grpc/protobuf/services/ChannelzTestHelper.java
@@ -0,0 +1,183 @@
+/*
+ * Copyright 2018 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.protobuf.services;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.ConnectivityState;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalChannelz.ChannelStats;
+import io.grpc.InternalChannelz.Security;
+import io.grpc.InternalChannelz.ServerStats;
+import io.grpc.InternalChannelz.SocketOptions;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalChannelz.TransportStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.InternalLogId;
+import io.grpc.InternalWithLogId;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.Collections;
+
+/**
+ * Test class definitions that will be used in the proto utils test as well as
+ * channelz service test.
+ */
+final class ChannelzTestHelper {
+
+  static final class TestSocket implements InternalInstrumented<SocketStats> {
+    private final InternalLogId id = InternalLogId.allocate("socket", /*details=*/ null);
+    TransportStats transportStats = new TransportStats(
+        /*streamsStarted=*/ 1,
+        /*lastLocalStreamCreatedTimeNanos=*/ 2,
+        /*lastRemoteStreamCreatedTimeNanos=*/ 3,
+        /*streamsSucceeded=*/ 4,
+        /*streamsFailed=*/ 5,
+        /*messagesSent=*/ 6,
+        /*messagesReceived=*/ 7,
+        /*keepAlivesSent=*/ 8,
+        /*lastMessageSentTimeNanos=*/ 9,
+        /*lastMessageReceivedTimeNanos=*/ 10,
+        /*localFlowControlWindow=*/ 11,
+        /*remoteFlowControlWindow=*/ 12);
+    SocketAddress local = new InetSocketAddress("10.0.0.1", 1000);
+    SocketAddress remote = new InetSocketAddress("10.0.0.2", 1000);
+    InternalChannelz.SocketOptions socketOptions
+        = new InternalChannelz.SocketOptions.Builder().build();
+    Security security = null;
+
+    @Override
+    public ListenableFuture<SocketStats> getStats() {
+      SettableFuture<SocketStats> ret = SettableFuture.create();
+      ret.set(
+          new SocketStats(
+              transportStats,
+              local,
+              remote,
+              socketOptions,
+              security));
+      return ret;
+    }
+
+    @Override
+    public InternalLogId getLogId() {
+      return id;
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("logId", getLogId())
+          .toString();
+    }
+  }
+
+  static final class TestListenSocket implements InternalInstrumented<SocketStats> {
+    private final InternalLogId id = InternalLogId.allocate("listensocket", /*details=*/ null);
+    SocketAddress listenAddress = new InetSocketAddress("10.0.0.1", 1234);
+
+    @Override
+    public ListenableFuture<SocketStats> getStats() {
+      SettableFuture<SocketStats> ret = SettableFuture.create();
+      ret.set(
+          new SocketStats(
+              /*data=*/ null,
+              listenAddress,
+              /*remote=*/ null,
+              new SocketOptions.Builder().addOption("listen_option", "listen_option_value").build(),
+              /*security=*/ null));
+      return ret;
+    }
+
+    @Override
+    public InternalLogId getLogId() {
+      return id;
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("logId", getLogId())
+          .toString();
+    }
+  }
+
+  static final class TestServer implements InternalInstrumented<ServerStats> {
+    private final InternalLogId id = InternalLogId.allocate("server", /*details=*/ null);
+    ServerStats serverStats = new ServerStats(
+        /*callsStarted=*/ 1,
+        /*callsSucceeded=*/ 2,
+        /*callsFailed=*/ 3,
+        /*lastCallStartedNanos=*/ 4,
+        Collections.<InternalInstrumented<SocketStats>>emptyList());
+
+    @Override
+    public ListenableFuture<ServerStats> getStats() {
+      SettableFuture<ServerStats> ret = SettableFuture.create();
+      ret.set(serverStats);
+      return ret;
+    }
+
+    @Override
+    public InternalLogId getLogId() {
+      return id;
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("logId", getLogId())
+          .toString();
+    }
+  }
+
+  static final class TestChannel implements InternalInstrumented<ChannelStats> {
+    private final InternalLogId id =
+        InternalLogId.allocate("channel-or-subchannel", /*details=*/ null);
+
+    ChannelStats stats = new ChannelStats.Builder()
+        .setTarget("sometarget")
+        .setState(ConnectivityState.READY)
+        .setCallsStarted(1)
+        .setCallsSucceeded(2)
+        .setCallsFailed(3)
+        .setLastCallStartedNanos(4)
+        .setSubchannels(Collections.<InternalWithLogId>emptyList())
+        .setSockets(Collections.<InternalWithLogId>emptyList())
+        .build();
+
+    @Override
+    public ListenableFuture<ChannelStats> getStats() {
+      SettableFuture<ChannelStats> ret = SettableFuture.create();
+      ret.set(stats);
+      return ret;
+    }
+
+    @Override
+    public InternalLogId getLogId() {
+      return id;
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("logId", getLogId())
+          .toString();
+    }
+  }
+}
diff --git a/services/src/test/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerFactoryTest.java b/services/src/test/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerFactoryTest.java
new file mode 100644
index 00000000000..a49c426f7e1
--- /dev/null
+++ b/services/src/test/java/io/grpc/protobuf/services/HealthCheckingLoadBalancerFactoryTest.java
@@ -0,0 +1,1441 @@
+/*
+ * Copyright 2018 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.protobuf.services;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.Attributes;
+import io.grpc.Channel;
+import io.grpc.ChannelLogger;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.Context;
+import io.grpc.Context.CancellationListener;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.health.v1.HealthCheckRequest;
+import io.grpc.health.v1.HealthCheckResponse;
+import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
+import io.grpc.health.v1.HealthGrpc;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.ServiceConfigUtil;
+import io.grpc.protobuf.services.HealthCheckingLoadBalancerFactory.SubchannelImpl;
+import io.grpc.stub.StreamObserver;
+import java.net.SocketAddress;
+import java.text.MessageFormat;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.hamcrest.MockitoHamcrest;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
+
+/** Tests for {@link HealthCheckingLoadBalancerFactory} with new generic health implementation. */
+@RunWith(Parameterized.class)
+public class HealthCheckingLoadBalancerFactoryTest {
+  @Parameterized.Parameters(name = "{0}")
+  public static Iterable<Object[]> data() {
+    // Before and after dual stack
+    return Arrays.asList(new Object[][] {
+        {true}, {false}
+    });
+  }
+
+  @Parameterized.Parameter
+  public boolean hasHealthConsumer;
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private static final Attributes.Key<String> SUBCHANNEL_ATTR_KEY =
+      Attributes.Key.create("subchannel-attr-for-test");
+
+  // We use in-process channels for Subchannel.asChannel(), so that we make sure we are making RPCs
+  // correctly.  Mocking Channel and ClientCall is a bad idea because it can easily be done wrong.
+  // Each Channel goes to a different server, so that we can verify the health check activity on
+  // each Subchannel.
+  private static final int NUM_SUBCHANNELS = 2;
+  private final EquivalentAddressGroup[] eags = new EquivalentAddressGroup[NUM_SUBCHANNELS];
+  @SuppressWarnings({"rawtypes", "unchecked"})
+  private final List<EquivalentAddressGroup>[] eagLists = new List[NUM_SUBCHANNELS];
+  private final SubchannelStateListener[] mockStateListeners =
+      new SubchannelStateListener[NUM_SUBCHANNELS];
+  private final SubchannelStateListener[] mockHealthListeners =
+      new SubchannelStateListener[NUM_SUBCHANNELS];
+  private List<EquivalentAddressGroup> resolvedAddressList;
+  private final FakeSubchannel[] subchannels = new FakeSubchannel[NUM_SUBCHANNELS];
+  private final ManagedChannel[] channels = new ManagedChannel[NUM_SUBCHANNELS];
+  private final Server[] servers = new Server[NUM_SUBCHANNELS];
+  private final HealthImpl[] healthImpls = new HealthImpl[NUM_SUBCHANNELS];
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final FakeClock clock = new FakeClock();
+  private final Helper origHelper = mock(Helper.class, delegatesTo(new FakeHelper()));
+  // The helper seen by the origLb
+  private Helper wrappedHelper;
+  private final LoadBalancer.Factory origLbFactory =
+      mock(LoadBalancer.Factory.class, delegatesTo(new LoadBalancer.Factory() {
+          @Override
+          public LoadBalancer newLoadBalancer(Helper helper) {
+            checkState(wrappedHelper == null, "LoadBalancer already created");
+            wrappedHelper = helper;
+            return origLb;
+          }
+        }));
+
+  @Mock
+  private LoadBalancer origLb;
+  private LoadBalancer hcLb;
+  @Captor
+  ArgumentCaptor<CreateSubchannelArgs> createArgsCaptor;
+  @Mock
+  private BackoffPolicy.Provider backoffPolicyProvider;
+  @Mock
+  private BackoffPolicy backoffPolicy1;
+  @Mock
+  private BackoffPolicy backoffPolicy2;
+
+  private HealthCheckingLoadBalancerFactory hcLbFactory;
+  private LoadBalancer hcLbEventDelivery;
+
+  @Before
+  @SuppressWarnings("unchecked")
+  public void setup() throws Exception {
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      HealthImpl healthImpl = new HealthImpl();
+      healthImpls[i] = healthImpl;
+      Server server =
+          InProcessServerBuilder.forName("health-check-test-" + i)
+          .addService(healthImpl).directExecutor().build().start();
+      servers[i] = server;
+      ManagedChannel channel =
+          InProcessChannelBuilder.forName("health-check-test-" + i).directExecutor().build();
+      channels[i] = channel;
+
+      EquivalentAddressGroup eag =
+          new EquivalentAddressGroup(new FakeSocketAddress("address-" + i));
+      eags[i] = eag;
+      List<EquivalentAddressGroup> eagList = Arrays.asList(eag);
+      eagLists[i] = eagList;
+      mockStateListeners[i] = mock(SubchannelStateListener.class);
+      mockHealthListeners[i] = mock(SubchannelStateListener.class);
+    }
+    resolvedAddressList = Arrays.asList(eags);
+
+    when(backoffPolicyProvider.get()).thenReturn(backoffPolicy1, backoffPolicy2);
+    when(backoffPolicy1.nextBackoffNanos()).thenReturn(11L, 21L, 31L);
+    when(backoffPolicy2.nextBackoffNanos()).thenReturn(12L, 22L, 32L);
+
+    hcLbFactory = new HealthCheckingLoadBalancerFactory(
+        origLbFactory, backoffPolicyProvider,
+        clock.getStopwatchSupplier());
+    hcLb = hcLbFactory.newLoadBalancer(origHelper);
+    // Make sure all calls into the hcLb is from the syncContext
+    hcLbEventDelivery = new LoadBalancer() {
+        // Per LoadBalancer API, no more callbacks will be called after shutdown() is called.
+        boolean shutdown;
+
+        @Override
+        public Status acceptResolvedAddresses(final ResolvedAddresses resolvedAddresses) {
+          syncContext.execute(new Runnable() {
+              @Override
+              public void run() {
+                if (!shutdown) {
+                  hcLb.acceptResolvedAddresses(resolvedAddresses);
+                }
+              }
+            });
+          return Status.OK;
+        }
+
+        @Override
+        public void handleNameResolutionError(Status error) {
+          throw new AssertionError("Not supposed to be called");
+        }
+
+        @Override
+        public void shutdown() {
+          syncContext.execute(new Runnable() {
+              @Override
+              public void run() {
+                if (!shutdown) {
+                  shutdown = true;
+                  hcLb.shutdown();
+                }
+              }
+            });
+        }
+      };
+    verify(origLbFactory).newLoadBalancer(any(Helper.class));
+  }
+
+  @After
+  public void teardown() throws Exception {
+    // All scheduled tasks have been accounted for
+    assertThat(clock.getPendingTasks()).isEmpty();
+    // Health-check streams are usually not closed in the tests because onSubchannelState() is
+    // faked.  Force closing for clean up.
+    for (Server server : servers) {
+      server.shutdownNow();
+      assertThat(server.awaitTermination(1, TimeUnit.SECONDS)).isTrue();
+    }
+    for (ManagedChannel channel : channels) {
+      channel.shutdownNow();
+      assertThat(channel.awaitTermination(1, TimeUnit.SECONDS)).isTrue();
+    }
+    for (HealthImpl impl : healthImpls) {
+      assertThat(impl.checkCalled).isFalse();
+    }
+  }
+
+  @Test
+  public void typicalWorkflow() {
+    Attributes resolutionAttrs = attrsWithHealthCheckService("FooService");
+    ResolvedAddresses result = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result);
+
+    verify(origLb).acceptResolvedAddresses(result);
+    verify(origHelper, atLeast(0)).getSynchronizationContext();
+    verify(origHelper, atLeast(0)).getScheduledExecutorService();
+    verifyNoMoreInteractions(origHelper);
+    verifyNoMoreInteractions(origLb);
+    Subchannel[] wrappedSubchannels = new Subchannel[NUM_SUBCHANNELS];
+
+    // Simulate that the original LB creates Subchannels
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      // Subchannel attributes set by origLb are correctly plumbed in
+      String subchannelAttrValue = "eag attr " + i;
+      Attributes attrs = Attributes.newBuilder()
+          .set(SUBCHANNEL_ATTR_KEY, subchannelAttrValue).build();
+      wrappedSubchannels[i] = createSubchannel(i, attrs,
+          hasHealthConsumer ? mockHealthListeners[i] : null);
+      assertThat(unwrap(wrappedSubchannels[i])).isSameInstanceAs(subchannels[i]);
+      verify(origHelper, times(i + 1)).createSubchannel(createArgsCaptor.capture());
+      assertThat(createArgsCaptor.getValue().getAddresses()).isEqualTo(eagLists[i]);
+      assertThat(createArgsCaptor.getValue().getAttributes().get(SUBCHANNEL_ATTR_KEY))
+          .isEqualTo(subchannelAttrValue);
+    }
+
+    for (int i = NUM_SUBCHANNELS - 1; i >= 0; i--) {
+      // Not starting health check until underlying Subchannel is READY
+      FakeSubchannel subchannel = subchannels[i];
+      HealthImpl healthImpl = healthImpls[i];
+      SubchannelStateListener mockStateListener = mockStateListeners[i];
+      SubchannelStateListener mockHealthListener = mockHealthListeners[i];
+      InOrder inOrder = inOrder(mockStateListener, mockHealthListener);
+      deliverSubchannelState(i, ConnectivityStateInfo.forNonError(CONNECTING));
+      deliverSubchannelState(i, ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+      deliverSubchannelState(i, ConnectivityStateInfo.forNonError(IDLE));
+
+      inOrder.verify(mockStateListener).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+      if (hasHealthConsumer) {
+        inOrder.verify(mockHealthListener).onSubchannelState(
+            eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+      }
+      inOrder.verify(mockStateListener).onSubchannelState(
+          eq(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE)));
+      if (hasHealthConsumer) {
+        inOrder.verify(mockHealthListener).onSubchannelState(
+            eq(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE)));
+      }
+      inOrder.verify(mockStateListener).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(IDLE)));
+      if (hasHealthConsumer) {
+        inOrder.verify(mockHealthListener).onSubchannelState(
+            eq(ConnectivityStateInfo.forNonError(IDLE)));
+      }
+      verifyNoMoreInteractions(mockStateListener);
+      verifyNoMoreInteractions(mockHealthListener);
+
+      assertThat(subchannel.logs).isEmpty();
+      assertThat(healthImpl.calls).isEmpty();
+      deliverSubchannelState(i, ConnectivityStateInfo.forNonError(READY));
+      if (hasHealthConsumer) {
+        inOrder.verify(mockStateListener).onSubchannelState(
+            eq(ConnectivityStateInfo.forNonError(READY)));
+      }
+      inOrder.verify(hasHealthConsumer ? mockHealthListener : mockStateListener).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+      assertThat(healthImpl.calls).hasSize(1);
+      ServerSideCall serverCall = healthImpl.calls.peek();
+      assertThat(serverCall.request).isEqualTo(makeRequest("FooService"));
+
+      verifyNoMoreInteractions(mockStateListener, mockHealthListener);
+
+      assertThat(subchannel.logs).containsExactly(
+          "INFO: CONNECTING: Starting health-check for \"FooService\"");
+      subchannel.logs.clear();
+
+      // Simulate a series of responses.
+      for (ServingStatus servingStatus :
+               new ServingStatus[] {
+                 ServingStatus.UNKNOWN, ServingStatus.NOT_SERVING, ServingStatus.SERVICE_UNKNOWN,
+                 ServingStatus.SERVING, ServingStatus.NOT_SERVING, ServingStatus.SERVING}) {
+        serverCall.responseObserver.onNext(makeResponse(servingStatus));
+        // SERVING is mapped to READY, while other statuses are mapped to TRANSIENT_FAILURE
+        if (servingStatus == ServingStatus.SERVING) {
+          inOrder.verify(hasHealthConsumer ? mockHealthListener : mockStateListener)
+              .onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+          assertThat(subchannel.logs).containsExactly(
+              "INFO: READY: health-check responded SERVING");
+        } else {
+          inOrder.verify(hasHealthConsumer ? mockHealthListener : mockStateListener)
+              .onSubchannelState(
+              unavailableStateWithMsg(
+                  "Health-check service responded " + servingStatus + " for 'FooService'"));
+          assertThat(subchannel.logs).containsExactly(
+              "INFO: TRANSIENT_FAILURE: health-check responded " + servingStatus);
+        }
+        subchannel.logs.clear();
+        verifyNoMoreInteractions(hasHealthConsumer ? mockHealthListener : mockStateListener);
+      }
+    }
+
+    // origLb shuts down Subchannels
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      FakeSubchannel subchannel = subchannels[i];
+      SubchannelStateListener mockStateListener = mockStateListeners[i];
+
+      ServerSideCall serverCall = healthImpls[i].calls.peek();
+      assertThat(serverCall.cancelled).isFalse();
+      verifyNoMoreInteractions(mockStateListener);
+
+      assertThat(subchannels[i].isShutdown).isFalse();
+      final Subchannel wrappedSubchannel = wrappedSubchannels[i];
+      // Subchannel enters SHUTDOWN state as a response to shutdown(), and that will cancel the
+      // health check RPC
+      syncContext.execute(new Runnable() {
+          @Override
+          public void run() {
+            wrappedSubchannel.shutdown();
+          }
+        });
+      assertThat(subchannels[i].isShutdown).isTrue();
+      assertThat(serverCall.cancelled).isTrue();
+      verify(mockStateListener).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(SHUTDOWN)));
+      assertThat(subchannel.logs).isEmpty();
+    }
+
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      assertThat(healthImpls[i].calls).hasSize(1);
+    }
+
+    verifyNoInteractions(backoffPolicyProvider);
+  }
+
+  @Test
+  public void healthCheckDisabledWhenServiceNotImplemented() {
+    Attributes resolutionAttrs = attrsWithHealthCheckService("BarService");
+    ResolvedAddresses result = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result);
+
+    verify(origLb).acceptResolvedAddresses(result);
+    verifyNoMoreInteractions(origLb);
+
+    // We create 2 Subchannels. One of them connects to a server that doesn't implement health check
+    for (int i = 0; i < 2; i++) {
+      createSubchannel(i, Attributes.EMPTY, hasHealthConsumer ? mockHealthListeners[i] : null);
+    }
+
+    InOrder inOrder = inOrder(mockStateListeners[0], mockStateListeners[1], mockHealthListeners[0],
+        mockHealthListeners[1]);
+
+    for (int i = 0; i < 2; i++) {
+      deliverSubchannelState(i, ConnectivityStateInfo.forNonError(READY));
+      assertThat(healthImpls[i].calls).hasSize(1);
+      if (hasHealthConsumer) {
+        inOrder.verify(mockStateListeners[i]).onSubchannelState(eq(
+            ConnectivityStateInfo.forNonError(READY)));
+      }
+      inOrder.verify(hasHealthConsumer ? mockHealthListeners[i] : mockStateListeners[i])
+          .onSubchannelState(eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+    }
+
+    ServerSideCall serverCall0 = healthImpls[0].calls.poll();
+    ServerSideCall serverCall1 = healthImpls[1].calls.poll();
+
+    subchannels[0].logs.clear();
+    // subchannels[0] gets UNIMPLEMENTED for health checking, which will disable health
+    // checking and it'll use the original state, which is currently READY.
+    // In reality UNIMPLEMENTED is generated by GRPC server library, but the client can't tell
+    // whether it's the server library or the service implementation that returned this status.
+    serverCall0.responseObserver.onError(Status.UNIMPLEMENTED.asException());
+    inOrder.verify(hasHealthConsumer ? mockHealthListeners[0] : mockStateListeners[0])
+        .onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+    assertThat(subchannels[0].logs).containsExactly(
+        "ERROR: Health-check disabled: " + Status.UNIMPLEMENTED,
+        "INFO: READY (no health-check)").inOrder();
+
+    // subchannels[1] has normal health checking
+    serverCall1.responseObserver.onNext(makeResponse(ServingStatus.NOT_SERVING));
+    inOrder.verify(hasHealthConsumer ? mockHealthListeners[1] : mockStateListeners[1])
+        .onSubchannelState(
+        unavailableStateWithMsg("Health-check service responded NOT_SERVING for 'BarService'"));
+
+    // Without health checking, states from underlying Subchannel are delivered directly to the mock
+    // listeners.
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(mockStateListeners[0]).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(IDLE)));
+    if (hasHealthConsumer) {
+      inOrder.verify(mockHealthListeners[0]).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(IDLE)));
+    }
+
+    // Re-connecting on a Subchannel will reset the "disabled" flag.
+    assertThat(healthImpls[0].calls).hasSize(0);
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    if (hasHealthConsumer) {
+      inOrder.verify(mockStateListeners[0]).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(READY)));
+    }
+    assertThat(healthImpls[0].calls).hasSize(1);
+    serverCall0 = healthImpls[0].calls.poll();
+    inOrder.verify(hasHealthConsumer ? mockHealthListeners[0] : mockStateListeners[0])
+        .onSubchannelState(eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+
+    // Health check now works as normal
+    serverCall0.responseObserver.onNext(makeResponse(ServingStatus.SERVICE_UNKNOWN));
+    inOrder.verify(hasHealthConsumer ? mockHealthListeners[0] : mockStateListeners[0])
+        .onSubchannelState(unavailableStateWithMsg(
+            "Health-check service responded SERVICE_UNKNOWN for 'BarService'"));
+
+    verifyNoMoreInteractions(origLb, mockStateListeners[0], mockStateListeners[1],
+        mockHealthListeners[0], mockHealthListeners[1]);
+    verifyNoInteractions(backoffPolicyProvider);
+  }
+
+  @Test
+  public void backoffRetriesWhenServerErroneouslyClosesRpcBeforeAnyResponse() {
+    Attributes resolutionAttrs = attrsWithHealthCheckService("TeeService");
+    ResolvedAddresses result = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result);
+
+    verify(origLb).acceptResolvedAddresses(result);
+    verifyNoMoreInteractions(origLb);
+
+    SubchannelStateListener mockHealthListener = mockHealthListeners[0];
+    FakeSubchannel subchannel = unwrap(createSubchannel(0, Attributes.EMPTY,
+        maybeGetMockListener()));
+    assertThat(subchannel).isSameInstanceAs(subchannels[0]);
+    SubchannelStateListener mockListener = mockStateListeners[0];
+    InOrder inOrder = inOrder(mockListener, mockHealthListener, backoffPolicyProvider,
+        backoffPolicy1, backoffPolicy2);
+
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    if (hasHealthConsumer) {
+      inOrder.verify(mockListener).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(READY)));
+    }
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+    HealthImpl healthImpl = healthImpls[0];
+    assertThat(healthImpl.calls).hasSize(1);
+    assertThat(clock.getPendingTasks()).isEmpty();
+
+    subchannel.logs.clear();
+    // Server closes the health checking RPC without any response
+    healthImpl.calls.poll().responseObserver.onCompleted();
+
+    // which results in TRANSIENT_FAILURE
+    inOrder.verify(getMockListener()).onSubchannelState(
+        unavailableStateWithMsg(
+            "Health-check stream unexpectedly closed with " + Status.OK + " for 'TeeService'"));
+    assertThat(subchannel.logs).containsExactly(
+        "INFO: TRANSIENT_FAILURE: health-check stream closed with " + Status.OK,
+        "DEBUG: Will retry health-check after 11 ns").inOrder();
+
+    // Retry with backoff is scheduled
+    inOrder.verify(backoffPolicyProvider).get();
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+    assertThat(clock.getPendingTasks()).hasSize(1);
+
+    verifyRetryAfterNanos(inOrder, getMockListener(), healthImpl, 11);
+    assertThat(clock.getPendingTasks()).isEmpty();
+
+    subchannel.logs.clear();
+    // Server closes the health checking RPC without any response
+    healthImpl.calls.poll().responseObserver.onError(Status.CANCELLED.asException());
+
+    // which also results in TRANSIENT_FAILURE, with a different description
+    inOrder.verify(getMockListener()).onSubchannelState(
+        unavailableStateWithMsg(
+            "Health-check stream unexpectedly closed with "
+                + Status.CANCELLED + " for 'TeeService'"));
+    assertThat(subchannel.logs).containsExactly(
+        "INFO: TRANSIENT_FAILURE: health-check stream closed with " + Status.CANCELLED,
+        "DEBUG: Will retry health-check after 21 ns").inOrder();
+
+    // Retry with backoff
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+
+    verifyRetryAfterNanos(inOrder, getMockListener(), healthImpl, 21);
+
+    // Server responds this time
+    healthImpl.calls.poll().responseObserver.onNext(makeResponse(ServingStatus.SERVING));
+
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(READY)));
+
+    verifyNoMoreInteractions(origLb, getMockListener(), backoffPolicyProvider, backoffPolicy1);
+  }
+
+  @Test
+  public void serverRespondResetsBackoff() {
+    Attributes resolutionAttrs = attrsWithHealthCheckService("TeeService");
+    ResolvedAddresses result = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result);
+
+    verify(origLb).acceptResolvedAddresses(result);
+    verifyNoMoreInteractions(origLb);
+
+    SubchannelStateListener mockStateListener = mockStateListeners[0];
+    SubchannelStateListener mockHealthListener = mockHealthListeners[0];
+    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY, maybeGetMockListener());
+
+    assertThat(unwrap(subchannel)).isSameInstanceAs(subchannels[0]);
+    InOrder inOrder =
+        inOrder(mockStateListener, mockHealthListener,
+            backoffPolicyProvider, backoffPolicy1, backoffPolicy2);
+
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    if (hasHealthConsumer) {
+      inOrder.verify(mockStateListener).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(READY)));
+    }
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+    HealthImpl healthImpl = healthImpls[0];
+    assertThat(healthImpl.calls).hasSize(1);
+    assertThat(clock.getPendingTasks()).isEmpty();
+
+    // Server closes the health checking RPC without any response
+    healthImpl.calls.poll().responseObserver.onError(Status.CANCELLED.asException());
+
+    // which results in TRANSIENT_FAILURE
+    inOrder.verify(getMockListener()).onSubchannelState(
+        unavailableStateWithMsg(
+            "Health-check stream unexpectedly closed with "
+                + Status.CANCELLED + " for 'TeeService'"));
+
+    // Retry with backoff is scheduled
+    inOrder.verify(backoffPolicyProvider).get();
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+    assertThat(clock.getPendingTasks()).hasSize(1);
+
+    verifyRetryAfterNanos(inOrder, getMockListener(), healthImpl, 11);
+    assertThat(clock.getPendingTasks()).isEmpty();
+
+    // Server responds
+    healthImpl.calls.peek().responseObserver.onNext(makeResponse(ServingStatus.SERVING));
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(READY)));
+
+    verifyNoMoreInteractions(mockStateListener);
+
+    // then closes the stream
+    healthImpl.calls.poll().responseObserver.onError(Status.UNAVAILABLE.asException());
+    inOrder.verify(getMockListener()).onSubchannelState(
+        unavailableStateWithMsg(
+            "Health-check stream unexpectedly closed with "
+                + Status.UNAVAILABLE + " for 'TeeService'"));
+
+    // Because server has responded, the first retry is not subject to backoff.
+    // But the backoff policy has been reset.  A new backoff policy will be used for
+    // the next backed-off retry.
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+    assertThat(healthImpl.calls).hasSize(1);
+    assertThat(clock.getPendingTasks()).isEmpty();
+    inOrder.verifyNoMoreInteractions();
+
+    // then closes the stream for this retry
+    healthImpl.calls.poll().responseObserver.onError(Status.UNAVAILABLE.asException());
+    inOrder.verify(getMockListener()).onSubchannelState(
+        unavailableStateWithMsg(
+            "Health-check stream unexpectedly closed with "
+                + Status.UNAVAILABLE + " for 'TeeService'"));
+
+    // New backoff policy is used
+    inOrder.verify(backoffPolicyProvider).get();
+    // Retry with a new backoff policy
+    inOrder.verify(backoffPolicy2).nextBackoffNanos();
+
+    verifyRetryAfterNanos(inOrder, getMockListener(), healthImpl, 12);
+  }
+
+  private void verifyRetryAfterNanos(
+      InOrder inOrder, SubchannelStateListener listener, HealthImpl impl,
+      long nanos) {
+    assertThat(impl.calls).isEmpty();
+    clock.forwardNanos(nanos - 1);
+    assertThat(impl.calls).isEmpty();
+    inOrder.verifyNoMoreInteractions();
+    verifyNoMoreInteractions(listener);
+    clock.forwardNanos(1);
+    inOrder.verify(listener).onSubchannelState(eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+    assertThat(impl.calls).hasSize(1);
+  }
+
+  @Test
+  public void serviceConfigHasNoHealthCheckingInitiallyButDoesLater() {
+    // No service config, thus no health check.
+    ResolvedAddresses result1 = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(Attributes.EMPTY)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
+
+    verify(origLb).acceptResolvedAddresses(result1);
+    verifyNoMoreInteractions(origLb);
+
+    // First, create Subchannels 0
+    createSubchannel(0, Attributes.EMPTY);
+
+    // No health check activity.  Underlying Subchannel states are directly propagated
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    assertThat(healthImpls[0].calls).isEmpty();
+    verify(mockStateListeners[0]).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+
+    verifyNoMoreInteractions(mockStateListeners[0]);
+
+    // Service config enables health check
+    Attributes resolutionAttrs = attrsWithHealthCheckService("FooService");
+    ResolvedAddresses result2 = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
+    verify(origLb).acceptResolvedAddresses(result2);
+
+    // Health check started on existing Subchannel
+    assertThat(healthImpls[0].calls).hasSize(1);
+
+    // State stays in READY, instead of switching to CONNECTING.
+    verifyNoMoreInteractions(mockStateListeners[0]);
+
+    // Start Subchannel 1, which will have health check
+    createSubchannel(1, Attributes.EMPTY);
+    assertThat(healthImpls[1].calls).isEmpty();
+    deliverSubchannelState(1, ConnectivityStateInfo.forNonError(READY));
+    assertThat(healthImpls[1].calls).hasSize(1);
+  }
+
+  @Test
+  public void serviceConfigDisablesHealthCheckWhenRpcActive() {
+    Attributes resolutionAttrs = attrsWithHealthCheckService("TeeService");
+    ResolvedAddresses result1 = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
+
+    verify(origLb).acceptResolvedAddresses(result1);
+    verifyNoMoreInteractions(origLb);
+
+    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY, maybeGetMockListener());
+    assertThat(unwrap(subchannel)).isSameInstanceAs(subchannels[0]);
+    InOrder inOrder = inOrder(origLb, mockStateListeners[0], mockHealthListeners[0]);
+
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    if (hasHealthConsumer) {
+      inOrder.verify(mockStateListeners[0]).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(READY)));
+    }
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+    inOrder.verifyNoMoreInteractions();
+    HealthImpl healthImpl = healthImpls[0];
+    assertThat(healthImpl.calls).hasSize(1);
+    ServerSideCall serverCall = healthImpl.calls.poll();
+    assertThat(serverCall.cancelled).isFalse();
+
+    // NameResolver gives an update without service config, thus health check will be disabled
+    ResolvedAddresses result2 = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(Attributes.EMPTY)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
+
+    // Health check RPC cancelled.
+    assertThat(serverCall.cancelled).isTrue();
+    // Subchannel uses original state
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(READY)));
+
+    inOrder.verify(origLb).acceptResolvedAddresses(result2);
+
+    verifyNoMoreInteractions(origLb, mockStateListeners[0]);
+    assertThat(healthImpl.calls).isEmpty();
+  }
+
+  @Test
+  public void serviceConfigDisablesHealthCheckWhenRetryPending() {
+    Attributes resolutionAttrs = attrsWithHealthCheckService("TeeService");
+    ResolvedAddresses result = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result);
+
+    verify(origLb).acceptResolvedAddresses(result);
+    verifyNoMoreInteractions(origLb);
+
+    SubchannelStateListener mockHealthListener = mockHealthListeners[0];
+    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY, maybeGetMockListener());
+    assertThat(unwrap(subchannel)).isSameInstanceAs(subchannels[0]);
+    InOrder inOrder = inOrder(origLb, mockStateListeners[0], mockHealthListener);
+
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    if (hasHealthConsumer) {
+      inOrder.verify(mockStateListeners[0]).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(READY)));
+    }
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+    inOrder.verifyNoMoreInteractions();
+    HealthImpl healthImpl = healthImpls[0];
+    assertThat(healthImpl.calls).hasSize(1);
+
+    // Server closes the stream without responding.  Client in retry backoff
+    assertThat(clock.getPendingTasks()).isEmpty();
+    healthImpl.calls.poll().responseObserver.onCompleted();
+    assertThat(clock.getPendingTasks()).hasSize(1);
+    inOrder.verify(getMockListener()).onSubchannelState(
+        unavailableStateWithMsg(
+            "Health-check stream unexpectedly closed with " + Status.OK + " for 'TeeService'"));
+
+    // NameResolver gives an update without service config, thus health check will be disabled
+    ResolvedAddresses result2 = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(Attributes.EMPTY)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
+
+    // Retry timer is cancelled
+    assertThat(clock.getPendingTasks()).isEmpty();
+
+    // No retry was attempted
+    assertThat(healthImpl.calls).isEmpty();
+
+    // Subchannel uses raw state as health state
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(READY)));
+
+    inOrder.verify(origLb).acceptResolvedAddresses(result2);
+
+    verifyNoMoreInteractions(origLb, mockStateListeners[0]);
+  }
+
+  @Test
+  public void serviceConfigDisablesHealthCheckWhenRpcInactive() {
+    Attributes resolutionAttrs = attrsWithHealthCheckService("TeeService");
+    ResolvedAddresses result1 = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
+
+    verify(origLb).acceptResolvedAddresses(result1);
+    verifyNoMoreInteractions(origLb);
+
+    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY, maybeGetMockListener());
+    assertThat(unwrap(subchannel)).isSameInstanceAs(subchannels[0]);
+    InOrder inOrder = inOrder(origLb, mockStateListeners[0], mockHealthListeners[0]);
+
+    // Underlying subchannel is not READY initially
+    ConnectivityStateInfo underlyingErrorState =
+        ConnectivityStateInfo.forTransientFailure(
+            Status.UNAVAILABLE.withDescription("connection refused"));
+    deliverSubchannelState(0, underlyingErrorState);
+    if (hasHealthConsumer) {
+      inOrder.verify(mockStateListeners[0]).onSubchannelState(same(underlyingErrorState));
+    }
+    inOrder.verify(getMockListener()).onSubchannelState(same(underlyingErrorState));
+    inOrder.verifyNoMoreInteractions();
+
+    // NameResolver gives an update without service config, thus health check will be disabled
+    ResolvedAddresses result2 = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(Attributes.EMPTY)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
+
+    inOrder.verify(origLb).acceptResolvedAddresses(result2);
+
+    // Underlying subchannel is now ready
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+
+    // Since health check is disabled, READY state is propagated directly.
+    if (hasHealthConsumer) {
+      inOrder.verify(mockStateListeners[0]).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(READY)));
+    }
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(READY)));
+
+    // and there is no health check activity.
+    assertThat(healthImpls[0].calls).isEmpty();
+
+    verifyNoMoreInteractions(origLb, mockStateListeners[0]);
+  }
+
+  @Test
+  public void serviceConfigChangesServiceNameWhenRpcActive() {
+    Attributes resolutionAttrs = attrsWithHealthCheckService("TeeService");
+    ResolvedAddresses result1 = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
+
+    verify(origLb).acceptResolvedAddresses(result1);
+    verifyNoMoreInteractions(origLb);
+
+    SubchannelStateListener mockHealthListener = mockHealthListeners[0];
+    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY, maybeGetMockListener());
+    SubchannelStateListener mockListener = mockStateListeners[0];
+    assertThat(unwrap(subchannel)).isSameInstanceAs(subchannels[0]);
+    InOrder inOrder = inOrder(origLb, mockListener, mockHealthListener);
+
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    if (hasHealthConsumer) {
+      inOrder.verify(mockListener).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+    }
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+
+    HealthImpl healthImpl = healthImpls[0];
+    assertThat(healthImpl.calls).hasSize(1);
+    ServerSideCall serverCall = healthImpl.calls.poll();
+    assertThat(serverCall.cancelled).isFalse();
+    assertThat(serverCall.request).isEqualTo(makeRequest("TeeService"));
+
+    // Health check responded
+    serverCall.responseObserver.onNext(makeResponse(ServingStatus.SERVING));
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(READY)));
+
+    // Service config returns with the same health check name.
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
+    // It's delivered to origLb, but nothing else happens
+    inOrder.verify(origLb).acceptResolvedAddresses(result1);
+    verifyNoMoreInteractions(origLb, mockListener);
+
+    // Service config returns a different health check name.
+    resolutionAttrs = attrsWithHealthCheckService("FooService");
+    ResolvedAddresses result2 = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
+    inOrder.verify(origLb).acceptResolvedAddresses(result2);
+
+    // Current health check RPC cancelled.
+    assertThat(serverCall.cancelled).isTrue();
+
+    // A second RPC is started immediately
+    assertThat(healthImpl.calls).hasSize(1);
+    serverCall = healthImpl.calls.poll();
+    // with the new service name
+    assertThat(serverCall.request).isEqualTo(makeRequest("FooService"));
+
+    // State stays in READY, instead of switching to CONNECTING.
+    verifyNoMoreInteractions(origLb, mockListener, mockHealthListener);
+  }
+
+  @Test
+  public void serviceConfigChangesServiceNameWhenRetryPending() {
+    Attributes resolutionAttrs = attrsWithHealthCheckService("TeeService");
+    ResolvedAddresses result1 = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
+
+    verify(origLb).acceptResolvedAddresses(result1);
+    verifyNoMoreInteractions(origLb);
+
+    SubchannelStateListener mockHealthListener = mockHealthListeners[0];
+    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY, maybeGetMockListener());
+    SubchannelStateListener mockListener = mockStateListeners[0];
+    assertThat(unwrap(subchannel)).isSameInstanceAs(subchannels[0]);
+    InOrder inOrder = inOrder(origLb, mockListener, mockHealthListener);
+
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    if (hasHealthConsumer) {
+      inOrder.verify(mockListener).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+    }
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+
+    HealthImpl healthImpl = healthImpls[0];
+    assertThat(healthImpl.calls).hasSize(1);
+    ServerSideCall serverCall = healthImpl.calls.poll();
+    assertThat(serverCall.cancelled).isFalse();
+    assertThat(serverCall.request).isEqualTo(makeRequest("TeeService"));
+
+    // Health check stream closed without responding.  Client in retry backoff.
+    assertThat(clock.getPendingTasks()).isEmpty();
+    serverCall.responseObserver.onCompleted();
+    assertThat(clock.getPendingTasks()).hasSize(1);
+    assertThat(healthImpl.calls).isEmpty();
+    inOrder.verify(getMockListener()).onSubchannelState(
+        unavailableStateWithMsg(
+            "Health-check stream unexpectedly closed with " + Status.OK + " for 'TeeService'"));
+
+    // Service config returns with the same health check name.
+
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
+    // It's delivered to origLb, but nothing else happens
+    inOrder.verify(origLb).acceptResolvedAddresses(result1);
+    verifyNoMoreInteractions(origLb, mockListener);
+    assertThat(clock.getPendingTasks()).hasSize(1);
+    assertThat(healthImpl.calls).isEmpty();
+
+    // Service config returns a different health check name.
+    resolutionAttrs = attrsWithHealthCheckService("FooService");
+    ResolvedAddresses result2 = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
+    // Concluded CONNECTING state
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+
+    inOrder.verify(origLb).acceptResolvedAddresses(result2);
+
+    // Current retry timer cancelled
+    assertThat(clock.getPendingTasks()).isEmpty();
+
+    // A second RPC is started immediately
+    assertThat(healthImpl.calls).hasSize(1);
+    serverCall = healthImpl.calls.poll();
+    // with the new service name
+    assertThat(serverCall.request).isEqualTo(makeRequest("FooService"));
+
+    verifyNoMoreInteractions(origLb, mockListener, mockHealthListener);
+  }
+
+  @Test
+  public void serviceConfigChangesServiceNameWhenRpcInactive() {
+    Attributes resolutionAttrs = attrsWithHealthCheckService("TeeService");
+    ResolvedAddresses result1 = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
+
+    verify(origLb).acceptResolvedAddresses(result1);
+    verifyNoMoreInteractions(origLb);
+
+    Subchannel subchannel = createSubchannel(0, Attributes.EMPTY, maybeGetMockListener());
+    SubchannelStateListener mockListener = mockStateListeners[0];
+    assertThat(unwrap(subchannel)).isSameInstanceAs(subchannels[0]);
+    InOrder inOrder = inOrder(origLb, mockListener, mockHealthListeners[0]);
+    HealthImpl healthImpl = healthImpls[0];
+
+    // Underlying subchannel is not READY initially
+    ConnectivityStateInfo underlyingErrorState =
+        ConnectivityStateInfo.forTransientFailure(
+            Status.UNAVAILABLE.withDescription("connection refused"));
+    deliverSubchannelState(0, underlyingErrorState);
+    if (hasHealthConsumer) {
+      inOrder.verify(mockListener).onSubchannelState(same(underlyingErrorState));
+    }
+    inOrder.verify(getMockListener()).onSubchannelState(same(underlyingErrorState));
+    inOrder.verifyNoMoreInteractions();
+
+    // Service config returns with the same health check name.
+    hcLbEventDelivery.acceptResolvedAddresses(result1);
+    // It's delivered to origLb, but nothing else happens
+    inOrder.verify(origLb).acceptResolvedAddresses(result1);
+    assertThat(healthImpl.calls).isEmpty();
+    verifyNoMoreInteractions(origLb);
+
+    // Service config returns a different health check name.
+    resolutionAttrs = attrsWithHealthCheckService("FooService");
+    ResolvedAddresses result2 = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result2);
+
+    inOrder.verify(origLb).acceptResolvedAddresses(result2);
+
+    // Underlying subchannel is now ready
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+
+    // Concluded CONNECTING state
+    if (hasHealthConsumer) {
+      inOrder.verify(mockListener).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(READY)));
+    }
+    inOrder.verify(getMockListener()).onSubchannelState(
+        eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+
+    // Health check RPC is started
+    assertThat(healthImpl.calls).hasSize(1);
+    // with the new service name
+    assertThat(healthImpl.calls.poll().request).isEqualTo(makeRequest("FooService"));
+
+    verifyNoMoreInteractions(origLb, mockListener);
+  }
+
+  @Test
+  public void getHealthCheckedServiceName_nullHealthCheckConfig() {
+    assertThat(ServiceConfigUtil.getHealthCheckedServiceName(null)).isNull();
+  }
+
+  @Test
+  public void getHealthCheckedServiceName_missingServiceName() {
+    HashMap<String, Object> hcConfig = new HashMap<>();
+    assertThat(ServiceConfigUtil.getHealthCheckedServiceName(hcConfig)).isNull();
+  }
+
+  @Test
+  public void getHealthCheckedServiceName_healthCheckConfigHasServiceName() {
+    HashMap<String, Object> hcConfig = new HashMap<>();
+    hcConfig.put("serviceName", "FooService");
+    assertThat(ServiceConfigUtil.getHealthCheckedServiceName(hcConfig))
+        .isEqualTo("FooService");
+  }
+
+  @Test
+  public void balancerShutdown() {
+    Attributes resolutionAttrs = attrsWithHealthCheckService("TeeService");
+    ResolvedAddresses result = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result);
+
+    verify(origLb).acceptResolvedAddresses(result);
+    verifyNoMoreInteractions(origLb);
+    ServerSideCall[] serverCalls = new ServerSideCall[NUM_SUBCHANNELS];
+
+    final Subchannel[] wrappedSubchannels = new Subchannel[NUM_SUBCHANNELS];
+
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      Subchannel subchannel = createSubchannel(i, Attributes.EMPTY,
+          hasHealthConsumer ? mockHealthListeners[i] : null);
+      wrappedSubchannels[i] = subchannel;
+      SubchannelStateListener mockListener = mockStateListeners[i];
+      SubchannelStateListener mockHealthListener = mockHealthListeners[i];
+      assertThat(unwrap(subchannel)).isSameInstanceAs(subchannels[i]);
+
+      // Trigger the health check
+      deliverSubchannelState(i, ConnectivityStateInfo.forNonError(READY));
+
+      HealthImpl healthImpl = healthImpls[i];
+      assertThat(healthImpl.calls).hasSize(1);
+      serverCalls[i] = healthImpl.calls.poll();
+      assertThat(serverCalls[i].cancelled).isFalse();
+
+      if (hasHealthConsumer) {
+        verify(mockListener).onSubchannelState(
+            eq(ConnectivityStateInfo.forNonError(READY)));
+      }
+      verify(hasHealthConsumer ? mockHealthListener : mockListener).onSubchannelState(
+          eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+    }
+
+    doAnswer(new Answer<Void>() {
+        @Override
+        public Void answer(InvocationOnMock invocation) {
+          for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+            wrappedSubchannels[i].shutdown();
+          }
+          return null;
+        }
+      }).when(origLb).shutdown();
+
+    // Shut down the balancer
+    hcLbEventDelivery.shutdown();
+    verify(origLb).shutdown();
+
+    // Health check stream should be cancelled
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      assertThat(serverCalls[i].cancelled).isTrue();
+      verifyNoMoreInteractions(origLb);
+      verify(mockStateListeners[i]).onSubchannelState(ConnectivityStateInfo.forNonError(SHUTDOWN));
+      // No more health check call is made or scheduled
+      assertThat(healthImpls[i].calls).isEmpty();
+    }
+
+    assertThat(clock.getPendingTasks()).isEmpty();
+  }
+
+  @Test
+  public void util_newHealthCheckingLoadBalancer() {
+    LoadBalancer.Factory hcFactory =
+        new LoadBalancer.Factory() {
+          @Override
+          public LoadBalancer newLoadBalancer(Helper helper) {
+            return HealthCheckingLoadBalancerUtil.newHealthCheckingLoadBalancer(
+                origLbFactory, helper);
+          }
+        };
+
+    // hcLb and wrappedHelper are already set in setUp().  For this special test case, we
+    // clear wrappedHelper so that we can create hcLb again with the util.
+    wrappedHelper = null;
+    hcLb = hcFactory.newLoadBalancer(origHelper);
+
+    // Verify that HC works
+    Attributes resolutionAttrs = attrsWithHealthCheckService("BarService");
+    ResolvedAddresses result = ResolvedAddresses.newBuilder()
+        .setAddresses(resolvedAddressList)
+        .setAttributes(resolutionAttrs)
+        .build();
+    hcLbEventDelivery.acceptResolvedAddresses(result);
+    verify(origLb).acceptResolvedAddresses(result);
+    createSubchannel(0, Attributes.EMPTY);
+    assertThat(healthImpls[0].calls).isEmpty();
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    assertThat(healthImpls[0].calls).hasSize(1);
+  }
+
+  private Attributes attrsWithHealthCheckService(@Nullable String serviceName) {
+    HashMap<String, Object> hcConfig = new HashMap<>();
+    hcConfig.put("serviceName", serviceName);
+    return Attributes.newBuilder()
+        .set(LoadBalancer.ATTR_HEALTH_CHECKING_CONFIG, hcConfig)
+        .build();
+  }
+
+  private HealthCheckRequest makeRequest(String service) {
+    return HealthCheckRequest.newBuilder().setService(service).build();
+  }
+
+  private HealthCheckResponse makeResponse(ServingStatus status) {
+    return HealthCheckResponse.newBuilder().setStatus(status).build();
+  }
+
+  private ConnectivityStateInfo unavailableStateWithMsg(final String expectedMsg) {
+    return MockitoHamcrest.argThat(
+        new org.hamcrest.BaseMatcher<ConnectivityStateInfo>() {
+          @Override
+          public boolean matches(Object item) {
+            if (!(item instanceof ConnectivityStateInfo)) {
+              return false;
+            }
+            ConnectivityStateInfo info = (ConnectivityStateInfo) item;
+            if (!info.getState().equals(TRANSIENT_FAILURE)) {
+              return false;
+            }
+            Status error = info.getStatus();
+            if (!error.getCode().equals(Status.Code.UNAVAILABLE)) {
+              return false;
+            }
+            if (!error.getDescription().equals(expectedMsg)) {
+              return false;
+            }
+            return true;
+          }
+
+          @Override
+          public void describeTo(org.hamcrest.Description desc) {
+            desc.appendText("Matches unavailable state with msg='" + expectedMsg + "'");
+          }
+        });
+  }
+
+  private SubchannelStateListener getMockListener() {
+    return hasHealthConsumer ? mockHealthListeners[0] : mockStateListeners[0];
+  }
+
+  private SubchannelStateListener maybeGetMockListener() {
+    return hasHealthConsumer ? mockHealthListeners[0] : null;
+  }
+
+  private static class HealthImpl extends HealthGrpc.HealthImplBase {
+    boolean checkCalled;
+    final Queue<ServerSideCall> calls = new ArrayDeque<>();
+
+    @Override
+    public void check(HealthCheckRequest request,
+        StreamObserver<HealthCheckResponse> responseObserver) {
+      responseObserver.onError(new UnsupportedOperationException("Should never be called"));
+      checkCalled = true;
+    }
+
+    @Override
+    public void watch(HealthCheckRequest request,
+        StreamObserver<HealthCheckResponse> responseObserver) {
+      final ServerSideCall call = new ServerSideCall(request, responseObserver);
+      Context.current().addListener(
+          new CancellationListener() {
+            @Override
+            public void cancelled(Context ctx) {
+              call.cancelled = true;
+            }
+          }, MoreExecutors.directExecutor());
+      calls.add(call);
+    }
+  }
+
+  private static class ServerSideCall {
+    final HealthCheckRequest request;
+    final StreamObserver<HealthCheckResponse> responseObserver;
+    boolean cancelled;
+
+    ServerSideCall(
+        HealthCheckRequest request, StreamObserver<HealthCheckResponse> responseObserver) {
+      this.request = request;
+      this.responseObserver = responseObserver;
+    }
+  }
+
+  private class FakeSubchannel extends Subchannel {
+    final List<EquivalentAddressGroup> eagList;
+    final Attributes attrs;
+    final Channel channel;
+    final ArrayList<String> logs = new ArrayList<>();
+    final int index;
+    SubchannelStateListener listener;
+    boolean isShutdown;
+    private final ChannelLogger logger = new ChannelLogger() {
+        @Override
+        public void log(ChannelLogLevel level, String msg) {
+          logs.add(level + ": " + msg);
+        }
+
+        @Override
+        public void log(ChannelLogLevel level, String template, Object... args) {
+          log(level, MessageFormat.format(template, args));
+        }
+      };
+
+    FakeSubchannel(int index, CreateSubchannelArgs args, Channel channel) {
+      this.index = index;
+      this.eagList = args.getAddresses();
+      this.attrs = args.getAttributes();
+      this.channel = checkNotNull(channel);
+    }
+
+    @Override
+    public Object getInternalSubchannel() {
+      return this;
+    }
+
+    @Override
+    public void start(SubchannelStateListener listener) {
+      checkState(this.listener == null);
+      this.listener = listener;
+    }
+
+    @Override
+    public void shutdown() {
+      isShutdown = true;
+      deliverSubchannelState(index, ConnectivityStateInfo.forNonError(SHUTDOWN));
+    }
+
+    @Override
+    public void requestConnection() {
+      throw new AssertionError("Should not be called");
+    }
+
+    @Override
+    public List<EquivalentAddressGroup> getAllAddresses() {
+      return eagList;
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return attrs;
+    }
+
+    @Override
+    public Channel asChannel() {
+      return channel;
+    }
+
+    @Override
+    public ChannelLogger getChannelLogger() {
+      return logger;
+    }
+  }
+
+  private class FakeHelper extends Helper {
+    @Override
+    public Subchannel createSubchannel(CreateSubchannelArgs args) {
+      int index = -1;
+      for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+        if (eagLists[i].equals(args.getAddresses())) {
+          index = i;
+          break;
+        }
+      }
+      checkState(index >= 0, "addrs " + args.getAddresses() + " not found");
+      FakeSubchannel subchannel = new FakeSubchannel(index, args, channels[index]);
+      checkState(subchannels[index] == null, "subchannels[" + index + "] already created");
+      subchannels[index] = subchannel;
+      return subchannel;
+    }
+
+    @Override
+    public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+      throw new AssertionError("Should not be called");
+    }
+
+    @Override
+    public SynchronizationContext getSynchronizationContext() {
+      return syncContext;
+    }
+
+    @Override
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return clock.getScheduledExecutorService();
+    }
+
+    @Override
+    public String getAuthority() {
+      throw new AssertionError("Should not be called");
+    }
+
+    @Override
+    public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String authority) {
+      throw new AssertionError("Should not be called");
+    }
+  }
+
+  private static class FakeSocketAddress extends SocketAddress {
+    final String name;
+
+    FakeSocketAddress(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
+
+  // In reality wrappedHelper.createSubchannel() is always called from syncContext.
+  // Make sure it's the case in the test too.
+
+  private Subchannel createSubchannel(final int index, final Attributes attrs) {
+    return createSubchannel(index, attrs, null);
+  }
+
+  private Subchannel createSubchannel(final int index, final Attributes attrs,
+      final SubchannelStateListener hcListener) {
+    CreateSubchannelArgs.Builder subchannelArgsBuilder = CreateSubchannelArgs.newBuilder()
+        .setAddresses(eagLists[index])
+        .setAttributes(attrs);
+    if (hcListener != null) {
+      subchannelArgsBuilder.addOption(LoadBalancer.HEALTH_CONSUMER_LISTENER_ARG_KEY, hcListener);
+    }
+    final AtomicReference<Subchannel> returnedSubchannel = new AtomicReference<>();
+    syncContext.execute(new Runnable() {
+        @Override
+        public void run() {
+          Subchannel s = wrappedHelper.createSubchannel(subchannelArgsBuilder.build());
+          s.start(mockStateListeners[index]);
+          returnedSubchannel.set(s);
+        }
+      });
+    return returnedSubchannel.get();
+  }
+
+  private void deliverSubchannelState(final int index, final ConnectivityStateInfo newState) {
+    syncContext.execute(new Runnable() {
+        @Override
+        public void run() {
+          subchannels[index].listener.onSubchannelState(newState);
+        }
+      });
+  }
+
+  private FakeSubchannel unwrap(Subchannel s) {
+    Subchannel s1 = ((SubchannelImpl) s).delegate();
+    return (FakeSubchannel) s1.getInternalSubchannel();
+  }
+}
diff --git a/services/src/test/java/io/grpc/protobuf/services/HealthStatusManagerTest.java b/services/src/test/java/io/grpc/protobuf/services/HealthStatusManagerTest.java
new file mode 100644
index 00000000000..b2652e92771
--- /dev/null
+++ b/services/src/test/java/io/grpc/protobuf/services/HealthStatusManagerTest.java
@@ -0,0 +1,332 @@
+/*
+ * Copyright 2016 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.protobuf.services;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.BindableService;
+import io.grpc.Context;
+import io.grpc.Context.CancellableContext;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.health.v1.HealthCheckRequest;
+import io.grpc.health.v1.HealthCheckResponse;
+import io.grpc.health.v1.HealthCheckResponse.ServingStatus;
+import io.grpc.health.v1.HealthGrpc;
+import io.grpc.stub.ServerCallStreamObserver;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcServerRule;
+import java.util.ArrayDeque;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link HealthStatusManager}. */
+@RunWith(JUnit4.class)
+public class HealthStatusManagerTest {
+  private static final String SERVICE1 = "service1";
+  private static final String SERVICE2 = "service2";
+
+  @Rule public final GrpcServerRule grpcServerRule = new GrpcServerRule().directExecutor();
+
+  private final HealthStatusManager manager = new HealthStatusManager();
+  private final HealthServiceImpl service = (HealthServiceImpl) manager.getHealthService();
+  private HealthGrpc.HealthStub stub;
+  private HealthGrpc.HealthBlockingStub blockingStub;
+
+  @Before
+  public void setup() {
+    grpcServerRule.getServiceRegistry().addService(service);
+    stub = HealthGrpc.newStub(grpcServerRule.getChannel());
+    blockingStub = HealthGrpc.newBlockingStub(grpcServerRule.getChannel());
+  }
+
+  @After
+  public void teardown() {
+    // Health-check streams are usually not closed in the tests.  Force closing for clean up.
+    grpcServerRule.getServer().shutdownNow();
+  }
+
+  @Test
+  public void enterTerminalState_check() throws Exception {
+    manager.setStatus(SERVICE1, ServingStatus.SERVING);
+    RespObserver obs = new RespObserver();
+    service.check(HealthCheckRequest.newBuilder().setService(SERVICE1).build(), obs);
+    assertThat(obs.responses).hasSize(2);
+    HealthCheckResponse resp = (HealthCheckResponse) obs.responses.poll();
+    assertThat(resp.getStatus()).isEqualTo(ServingStatus.SERVING);
+
+    manager.enterTerminalState();
+    obs = new RespObserver();
+    service.check(HealthCheckRequest.newBuilder().setService(SERVICE1).build(), obs);
+    assertThat(obs.responses).hasSize(2);
+    resp = (HealthCheckResponse) obs.responses.poll();
+    assertThat(resp.getStatus()).isEqualTo(ServingStatus.NOT_SERVING);
+
+    manager.setStatus(SERVICE1, ServingStatus.SERVING);
+    obs = new RespObserver();
+    service.check(HealthCheckRequest.newBuilder().setService(SERVICE1).build(), obs);
+    assertThat(obs.responses).hasSize(2);
+    resp = (HealthCheckResponse) obs.responses.poll();
+    assertThat(resp.getStatus()).isEqualTo(ServingStatus.NOT_SERVING);
+  }
+
+  @Test
+  public void enterTerminalState_watch() throws Exception {
+    manager.setStatus(SERVICE1, ServingStatus.SERVING);
+    RespObserver obs = new RespObserver();
+    service.watch(HealthCheckRequest.newBuilder().setService(SERVICE1).build(), obs);
+    assertThat(obs.responses).hasSize(1);
+    HealthCheckResponse resp = (HealthCheckResponse) obs.responses.poll();
+    assertThat(resp.getStatus()).isEqualTo(ServingStatus.SERVING);
+    obs.responses.clear();
+
+    manager.enterTerminalState();
+    assertThat(obs.responses).hasSize(1);
+    resp = (HealthCheckResponse) obs.responses.poll();
+    assertThat(resp.getStatus()).isEqualTo(ServingStatus.NOT_SERVING);
+    obs.responses.clear();
+
+    manager.setStatus(SERVICE1, ServingStatus.SERVING);
+    assertThat(obs.responses).isEmpty();
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void serverCallStreamObserver_watch() throws Exception {
+    manager.setStatus(SERVICE1, ServingStatus.SERVING);
+    ServerCallStreamObserver<HealthCheckResponse> observer = mock(ServerCallStreamObserver.class);
+    service.watch(HealthCheckRequest.newBuilder().setService(SERVICE1).build(), observer);
+
+    verify(observer, times(1))
+            .onNext(eq(HealthCheckResponse.newBuilder().setStatus(ServingStatus.SERVING).build()));
+    verify(observer, times(1)).setOnCancelHandler(any(Runnable.class));
+  }
+
+  @Test
+  public void enterTerminalState_ignoreClear() throws Exception {
+    manager.setStatus(SERVICE1, ServingStatus.SERVING);
+    RespObserver obs = new RespObserver();
+    service.check(HealthCheckRequest.newBuilder().setService(SERVICE1).build(), obs);
+    assertThat(obs.responses).hasSize(2);
+    HealthCheckResponse resp = (HealthCheckResponse) obs.responses.poll();
+    assertThat(resp.getStatus()).isEqualTo(ServingStatus.SERVING);
+
+    manager.enterTerminalState();
+    obs = new RespObserver();
+    service.check(HealthCheckRequest.newBuilder().setService(SERVICE1).build(), obs);
+    assertThat(obs.responses).hasSize(2);
+    resp = (HealthCheckResponse) obs.responses.poll();
+    assertThat(resp.getStatus()).isEqualTo(ServingStatus.NOT_SERVING);
+
+    manager.clearStatus(SERVICE1);
+    obs = new RespObserver();
+    service.check(HealthCheckRequest.newBuilder().setService(SERVICE1).build(), obs);
+    assertThat(obs.responses).hasSize(2);
+    resp = (HealthCheckResponse) obs.responses.poll();
+    assertThat(resp.getStatus()).isEqualTo(ServingStatus.NOT_SERVING);
+  }
+
+  @Test
+  public void defaultIsServing() throws Exception {
+    HealthCheckRequest request =
+        HealthCheckRequest.newBuilder().setService(HealthStatusManager.SERVICE_NAME_ALL_SERVICES)
+            .build();
+
+    HealthCheckResponse response =
+        blockingStub.withDeadlineAfter(5, TimeUnit.SECONDS).check(request);
+
+    assertThat(response).isEqualTo(
+        HealthCheckResponse.newBuilder().setStatus(ServingStatus.SERVING).build());
+  }
+
+  @Test
+  public void getHealthService_getterReturnsTheSameHealthRefAfterUpdate() throws Exception {
+    BindableService health = manager.getHealthService();
+    manager.setStatus(SERVICE1, ServingStatus.UNKNOWN);
+    assertThat(health).isSameInstanceAs(manager.getHealthService());
+  }
+
+  @Test
+  public void checkValidStatus() throws Exception {
+    manager.setStatus(SERVICE1, ServingStatus.NOT_SERVING);
+    manager.setStatus(SERVICE2, ServingStatus.SERVING);
+    HealthCheckRequest request = HealthCheckRequest.newBuilder().setService(SERVICE1).build();
+    HealthCheckResponse response =
+        blockingStub.withDeadlineAfter(5, TimeUnit.SECONDS).check(request);
+    assertThat(response).isEqualTo(
+        HealthCheckResponse.newBuilder().setStatus(ServingStatus.NOT_SERVING).build());
+
+    request = HealthCheckRequest.newBuilder().setService(SERVICE2).build();
+    response = blockingStub.withDeadlineAfter(5, TimeUnit.SECONDS).check(request);
+    assertThat(response).isEqualTo(
+        HealthCheckResponse.newBuilder().setStatus(ServingStatus.SERVING).build());
+    assertThat(service.numWatchersForTest(SERVICE1)).isEqualTo(0);
+    assertThat(service.numWatchersForTest(SERVICE2)).isEqualTo(0);
+  }
+
+  @Test
+  public void checkStatusNotFound() throws Exception {
+    manager.setStatus(SERVICE1, ServingStatus.SERVING);
+    // SERVICE2's status is not set
+    HealthCheckRequest request
+        = HealthCheckRequest.newBuilder().setService(SERVICE2).build();
+    try {
+      blockingStub.withDeadlineAfter(5, TimeUnit.SECONDS).check(request);
+      fail("Should've failed");
+    } catch (StatusRuntimeException e) {
+      assertThat(e.getStatus().getCode()).isEqualTo(Status.Code.NOT_FOUND);
+    }
+    assertThat(service.numWatchersForTest(SERVICE2)).isEqualTo(0);
+  }
+
+  @Test
+  public void notFoundForClearedStatus() throws Exception {
+    manager.setStatus(SERVICE1, ServingStatus.SERVING);
+    manager.clearStatus(SERVICE1);
+    HealthCheckRequest request
+        = HealthCheckRequest.newBuilder().setService(SERVICE1).build();
+    try {
+      blockingStub.withDeadlineAfter(5, TimeUnit.SECONDS).check(request);
+      fail("Should've failed");
+    } catch (StatusRuntimeException e) {
+      assertThat(e.getStatus().getCode()).isEqualTo(Status.Code.NOT_FOUND);
+    }
+  }
+
+  @Test
+  public void watch() throws Exception {
+    manager.setStatus(SERVICE1, ServingStatus.UNKNOWN);
+
+    // Start a watch on SERVICE1
+    assertThat(service.numWatchersForTest(SERVICE1)).isEqualTo(0);
+    RespObserver respObs1 = new RespObserver();
+    stub.watch(HealthCheckRequest.newBuilder().setService(SERVICE1).build(), respObs1);
+    // Will get the current status
+    assertThat(respObs1.responses.poll()).isEqualTo(
+        HealthCheckResponse.newBuilder().setStatus(ServingStatus.UNKNOWN).build());        
+    assertThat(service.numWatchersForTest(SERVICE1)).isEqualTo(1);
+
+    // Status change is notified of to the RPC
+    manager.setStatus(SERVICE1, ServingStatus.SERVING);
+    assertThat(respObs1.responses.poll()).isEqualTo(
+        HealthCheckResponse.newBuilder().setStatus(ServingStatus.SERVING).build());        
+
+    // Start another watch on SERVICE1
+    assertThat(service.numWatchersForTest(SERVICE1)).isEqualTo(1);
+    RespObserver respObs1b = new RespObserver();
+    stub.watch(HealthCheckRequest.newBuilder().setService(SERVICE1).build(), respObs1b);
+    assertThat(service.numWatchersForTest(SERVICE1)).isEqualTo(2);
+    // Will get the current status
+    assertThat(respObs1b.responses.poll()).isEqualTo(
+        HealthCheckResponse.newBuilder().setStatus(ServingStatus.SERVING).build());
+
+    // Start a watch on SERVICE2, which is not known yet
+    assertThat(service.numWatchersForTest(SERVICE2)).isEqualTo(0);
+    RespObserver respObs2 = new RespObserver();
+    stub.watch(HealthCheckRequest.newBuilder().setService(SERVICE2).build(), respObs2);
+    assertThat(service.numWatchersForTest(SERVICE2)).isEqualTo(1);
+    // Current status is SERVICE_UNKNOWN
+    assertThat(respObs2.responses.poll()).isEqualTo(
+        HealthCheckResponse.newBuilder().setStatus(ServingStatus.SERVICE_UNKNOWN).build());
+
+    // Set status for SERVICE2, which will be notified of
+    manager.setStatus(SERVICE2, ServingStatus.NOT_SERVING);
+    assertThat(respObs2.responses.poll()).isEqualTo(
+        HealthCheckResponse.newBuilder().setStatus(ServingStatus.NOT_SERVING).build());
+
+    // Clear the status for SERVICE1, which will be notified of
+    manager.clearStatus(SERVICE1);
+    assertThat(respObs1.responses.poll()).isEqualTo(
+        HealthCheckResponse.newBuilder().setStatus(ServingStatus.SERVICE_UNKNOWN).build());
+    assertThat(respObs1b.responses.poll()).isEqualTo(
+        HealthCheckResponse.newBuilder().setStatus(ServingStatus.SERVICE_UNKNOWN).build());
+
+    // All responses have been accounted for
+    assertThat(respObs1.responses).isEmpty();
+    assertThat(respObs1b.responses).isEmpty();
+    assertThat(respObs2.responses).isEmpty();
+  }
+
+  @Test
+  public void watchRemovedWhenClientCloses() throws Exception {
+    CancellableContext withCancellation = Context.current().withCancellation();
+    Context prevCtx = withCancellation.attach();
+    RespObserver respObs1 = new RespObserver();
+    try {
+      assertThat(service.numWatchersForTest(SERVICE1)).isEqualTo(0);
+      stub.watch(HealthCheckRequest.newBuilder().setService(SERVICE1).build(), respObs1);
+    } finally {
+      withCancellation.detach(prevCtx);
+    }
+    RespObserver respObs1b = new RespObserver();
+    stub.watch(HealthCheckRequest.newBuilder().setService(SERVICE1).build(), respObs1b);
+    RespObserver respObs2 = new RespObserver();
+    stub.watch(HealthCheckRequest.newBuilder().setService(SERVICE2).build(), respObs2);
+
+    assertThat(respObs1.responses.poll()).isEqualTo(
+        HealthCheckResponse.newBuilder().setStatus(ServingStatus.SERVICE_UNKNOWN).build());
+    assertThat(respObs1b.responses.poll()).isEqualTo(
+        HealthCheckResponse.newBuilder().setStatus(ServingStatus.SERVICE_UNKNOWN).build());
+    assertThat(respObs2.responses.poll()).isEqualTo(
+        HealthCheckResponse.newBuilder().setStatus(ServingStatus.SERVICE_UNKNOWN).build());
+    assertThat(service.numWatchersForTest(SERVICE1)).isEqualTo(2);
+    assertThat(service.numWatchersForTest(SERVICE2)).isEqualTo(1);
+    assertThat(respObs1.responses).isEmpty();
+    assertThat(respObs1b.responses).isEmpty();
+    assertThat(respObs2.responses).isEmpty();
+
+    // This will cancel the RPC with respObs1
+    withCancellation.close();
+
+    assertThat(respObs1.responses.poll()).isInstanceOf(Throwable.class);
+    assertThat(service.numWatchersForTest(SERVICE1)).isEqualTo(1);
+    assertThat(service.numWatchersForTest(SERVICE2)).isEqualTo(1);
+    assertThat(respObs1.responses).isEmpty();
+    assertThat(respObs1b.responses).isEmpty();
+    assertThat(respObs2.responses).isEmpty();
+  }
+
+  private static class RespObserver implements StreamObserver<HealthCheckResponse> {
+    final ArrayDeque<Object> responses = new ArrayDeque<>();
+
+    @Override
+    public void onNext(HealthCheckResponse value) {
+      responses.add(value);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+      responses.add(t);
+    }
+
+    @Override
+    public void onCompleted() {
+      responses.add("onCompleted");
+    }
+  }
+}
diff --git a/services/src/test/java/io/grpc/protobuf/services/ProtoReflectionServiceTest.java b/services/src/test/java/io/grpc/protobuf/services/ProtoReflectionServiceTest.java
new file mode 100644
index 00000000000..115dd11b0f1
--- /dev/null
+++ b/services/src/test/java/io/grpc/protobuf/services/ProtoReflectionServiceTest.java
@@ -0,0 +1,670 @@
+/*
+ * Copyright 2016 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.protobuf.services;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.protobuf.ByteString;
+import io.grpc.BindableService;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.testing.StreamRecorder;
+import io.grpc.reflection.testing.AnotherDynamicServiceGrpc;
+import io.grpc.reflection.testing.AnotherReflectableServiceGrpc;
+import io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto;
+import io.grpc.reflection.testing.DynamicServiceGrpc;
+import io.grpc.reflection.testing.ReflectableServiceGrpc;
+import io.grpc.reflection.testing.ReflectionTestDepthThreeProto;
+import io.grpc.reflection.testing.ReflectionTestDepthTwoAlternateProto;
+import io.grpc.reflection.testing.ReflectionTestDepthTwoProto;
+import io.grpc.reflection.testing.ReflectionTestProto;
+import io.grpc.reflection.v1alpha.ExtensionNumberResponse;
+import io.grpc.reflection.v1alpha.ExtensionRequest;
+import io.grpc.reflection.v1alpha.FileDescriptorResponse;
+import io.grpc.reflection.v1alpha.ServerReflectionGrpc;
+import io.grpc.reflection.v1alpha.ServerReflectionRequest;
+import io.grpc.reflection.v1alpha.ServerReflectionResponse;
+import io.grpc.reflection.v1alpha.ServiceResponse;
+import io.grpc.stub.ClientCallStreamObserver;
+import io.grpc.stub.ClientResponseObserver;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.util.MutableHandlerRegistry;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link ProtoReflectionService}. */
+@RunWith(JUnit4.class)
+public class ProtoReflectionServiceTest {
+  @Rule
+  public GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
+
+  private static final String TEST_HOST = "localhost";
+  private MutableHandlerRegistry handlerRegistry = new MutableHandlerRegistry();
+  @SuppressWarnings("deprecation")
+  private BindableService reflectionService = ProtoReflectionService.newInstance();
+  private ServerServiceDefinition dynamicService =
+      new DynamicServiceGrpc.DynamicServiceImplBase() {}.bindService();
+  private ServerServiceDefinition anotherDynamicService =
+      new AnotherDynamicServiceGrpc.AnotherDynamicServiceImplBase() {}.bindService();
+  private ServerReflectionGrpc.ServerReflectionStub stub;
+
+  @Before
+  public void setUp() throws Exception {
+    Server server =
+        InProcessServerBuilder.forName("proto-reflection-test")
+            .directExecutor()
+            .addService(reflectionService)
+            .addService(new ReflectableServiceGrpc.ReflectableServiceImplBase() {})
+            .fallbackHandlerRegistry(handlerRegistry)
+            .build()
+            .start();
+    grpcCleanupRule.register(server);
+    ManagedChannel channel =
+        grpcCleanupRule.register(
+            InProcessChannelBuilder.forName("proto-reflection-test").directExecutor().build());
+    stub = ServerReflectionGrpc.newStub(channel);
+  }
+
+  @Test
+  public void listServices() throws Exception {
+    Set<ServiceResponse> originalServices =
+        new HashSet<>(
+            Arrays.asList(
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.v1alpha.ServerReflection")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.ReflectableService")
+                    .build()));
+    assertServiceResponseEquals(originalServices);
+
+    handlerRegistry.addService(dynamicService);
+    assertServiceResponseEquals(
+        new HashSet<>(
+            Arrays.asList(
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.v1alpha.ServerReflection")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.ReflectableService")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.DynamicService")
+                    .build())));
+
+    handlerRegistry.addService(anotherDynamicService);
+    assertServiceResponseEquals(
+        new HashSet<>(
+            Arrays.asList(
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.v1alpha.ServerReflection")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.ReflectableService")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.DynamicService")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.AnotherDynamicService")
+                    .build())));
+
+    handlerRegistry.removeService(dynamicService);
+    assertServiceResponseEquals(
+        new HashSet<>(
+            Arrays.asList(
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.v1alpha.ServerReflection")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.ReflectableService")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.AnotherDynamicService")
+                    .build())));
+
+    handlerRegistry.removeService(anotherDynamicService);
+    assertServiceResponseEquals(originalServices);
+  }
+
+  @Test
+  public void fileByFilename() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileByFilename("io/grpc/reflection/testing/reflection_test_depth_three.proto")
+            .build();
+
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setFileDescriptorResponse(
+                FileDescriptorResponse.newBuilder()
+                    .addFileDescriptorProto(
+                        ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString())
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+
+    assertEquals(goldenResponse, responseObserver.firstValue().get());
+  }
+
+  @Test
+  public void fileByFilenameConsistentForMutableServices() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileByFilename("io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto")
+            .build();
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setFileDescriptorResponse(
+                FileDescriptorResponse.newBuilder()
+                    .addFileDescriptorProto(
+                        DynamicReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString())
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    handlerRegistry.addService(dynamicService);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver2 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver2 =
+        stub.serverReflectionInfo(responseObserver2);
+    handlerRegistry.removeService(dynamicService);
+    requestObserver2.onNext(request);
+    requestObserver2.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver3 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver3 =
+        stub.serverReflectionInfo(responseObserver3);
+    requestObserver3.onNext(request);
+    requestObserver3.onCompleted();
+
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver.firstValue().get().getMessageResponseCase());
+    assertEquals(goldenResponse, responseObserver2.firstValue().get());
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver3.firstValue().get().getMessageResponseCase());
+  }
+
+  @Test
+  public void fileContainingSymbol() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileContainingSymbol("grpc.reflection.testing.ReflectableService.Method")
+            .build();
+
+    List<ByteString> goldenResponse =
+        Arrays.asList(
+            ReflectionTestProto.getDescriptor().toProto().toByteString(),
+            ReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString(),
+            ReflectionTestDepthTwoAlternateProto.getDescriptor().toProto().toByteString(),
+            ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString());
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+
+    List<ByteString> response =
+        responseObserver
+            .firstValue()
+            .get()
+            .getFileDescriptorResponse()
+            .getFileDescriptorProtoList();
+    assertEquals(goldenResponse.size(), response.size());
+    assertEquals(new HashSet<>(goldenResponse), new HashSet<>(response));
+  }
+
+  @Test
+  public void fileContainingNestedSymbol() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileContainingSymbol("grpc.reflection.testing.NestedTypeOuter.Middle.Inner")
+            .build();
+
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setFileDescriptorResponse(
+                FileDescriptorResponse.newBuilder()
+                    .addFileDescriptorProto(
+                        ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString())
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    assertEquals(goldenResponse, responseObserver.firstValue().get());
+  }
+
+  @Test
+  public void fileContainingSymbolForMutableServices() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileContainingSymbol("grpc.reflection.testing.DynamicRequest")
+            .build();
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setFileDescriptorResponse(
+                FileDescriptorResponse.newBuilder()
+                    .addFileDescriptorProto(
+                        DynamicReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString())
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    handlerRegistry.addService(dynamicService);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver2 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver2 =
+        stub.serverReflectionInfo(responseObserver2);
+    handlerRegistry.removeService(dynamicService);
+    requestObserver2.onNext(request);
+    requestObserver2.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver3 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver3 =
+        stub.serverReflectionInfo(responseObserver3);
+    requestObserver3.onNext(request);
+    requestObserver3.onCompleted();
+
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver.firstValue().get().getMessageResponseCase());
+    assertEquals(goldenResponse, responseObserver2.firstValue().get());
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver3.firstValue().get().getMessageResponseCase());
+  }
+
+  @Test
+  public void fileContainingExtension() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileContainingExtension(
+                ExtensionRequest.newBuilder()
+                    .setContainingType("grpc.reflection.testing.ThirdLevelType")
+                    .setExtensionNumber(100)
+                    .build())
+            .build();
+
+    List<ByteString> goldenResponse =
+        Arrays.asList(
+            ReflectionTestProto.getDescriptor().toProto().toByteString(),
+            ReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString(),
+            ReflectionTestDepthTwoAlternateProto.getDescriptor().toProto().toByteString(),
+            ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString());
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+
+    List<ByteString> response =
+        responseObserver
+            .firstValue()
+            .get()
+            .getFileDescriptorResponse()
+            .getFileDescriptorProtoList();
+    assertEquals(goldenResponse.size(), response.size());
+    assertEquals(new HashSet<>(goldenResponse), new HashSet<>(response));
+  }
+
+  @Test
+  public void fileContainingNestedExtension() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileContainingExtension(
+                ExtensionRequest.newBuilder()
+                    .setContainingType("grpc.reflection.testing.ThirdLevelType")
+                    .setExtensionNumber(101)
+                    .build())
+            .build();
+
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setFileDescriptorResponse(
+                FileDescriptorResponse.newBuilder()
+                    .addFileDescriptorProto(
+                        ReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString())
+                    .addFileDescriptorProto(
+                        ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString())
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    assertEquals(goldenResponse, responseObserver.firstValue().get());
+  }
+
+  @Test
+  public void fileContainingExtensionForMutableServices() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileContainingExtension(
+                ExtensionRequest.newBuilder()
+                    .setContainingType("grpc.reflection.testing.TypeWithExtensions")
+                    .setExtensionNumber(200)
+                    .build())
+            .build();
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setFileDescriptorResponse(
+                FileDescriptorResponse.newBuilder()
+                    .addFileDescriptorProto(
+                        DynamicReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString())
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    handlerRegistry.addService(dynamicService);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver2 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver2 =
+        stub.serverReflectionInfo(responseObserver2);
+    handlerRegistry.removeService(dynamicService);
+    requestObserver2.onNext(request);
+    requestObserver2.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver3 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver3 =
+        stub.serverReflectionInfo(responseObserver3);
+    requestObserver3.onNext(request);
+    requestObserver3.onCompleted();
+
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver.firstValue().get().getMessageResponseCase());
+    assertEquals(goldenResponse, responseObserver2.firstValue().get());
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver3.firstValue().get().getMessageResponseCase());
+  }
+
+  @Test
+  public void allExtensionNumbersOfType() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setAllExtensionNumbersOfType("grpc.reflection.testing.ThirdLevelType")
+            .build();
+
+    Set<Integer> goldenResponse = new HashSet<>(Arrays.asList(100, 101));
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    Set<Integer> extensionNumberResponseSet =
+        new HashSet<>(
+            responseObserver
+                .firstValue()
+                .get()
+                .getAllExtensionNumbersResponse()
+                .getExtensionNumberList());
+    assertEquals(goldenResponse, extensionNumberResponseSet);
+  }
+
+  @Test
+  public void allExtensionNumbersOfTypeForMutableServices() throws Exception {
+    String type = "grpc.reflection.testing.TypeWithExtensions";
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setAllExtensionNumbersOfType(type)
+            .build();
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setAllExtensionNumbersResponse(
+                ExtensionNumberResponse.newBuilder()
+                    .setBaseTypeName(type)
+                    .addExtensionNumber(200)
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    handlerRegistry.addService(dynamicService);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver2 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver2 =
+        stub.serverReflectionInfo(responseObserver2);
+    handlerRegistry.removeService(dynamicService);
+    requestObserver2.onNext(request);
+    requestObserver2.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver3 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver3 =
+        stub.serverReflectionInfo(responseObserver3);
+    requestObserver3.onNext(request);
+    requestObserver3.onCompleted();
+
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver.firstValue().get().getMessageResponseCase());
+    assertEquals(goldenResponse, responseObserver2.firstValue().get());
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver3.firstValue().get().getMessageResponseCase());
+  }
+
+  @Test
+  public void sharedServiceBetweenServers()
+      throws IOException, ExecutionException, InterruptedException {
+    Server anotherServer = InProcessServerBuilder.forName("proto-reflection-test-2")
+        .directExecutor()
+        .addService(reflectionService)
+        .addService(new AnotherReflectableServiceGrpc.AnotherReflectableServiceImplBase() {})
+        .build()
+        .start();
+    grpcCleanupRule.register(anotherServer);
+    ManagedChannel anotherChannel = grpcCleanupRule.register(
+        InProcessChannelBuilder.forName("proto-reflection-test-2").directExecutor().build());
+    ServerReflectionGrpc.ServerReflectionStub stub2 = ServerReflectionGrpc.newStub(anotherChannel);
+
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder().setHost(TEST_HOST).setListServices("services").build();
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub2.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    List<ServiceResponse> response =
+        responseObserver.firstValue().get().getListServicesResponse().getServiceList();
+    assertEquals(new HashSet<>(
+        Arrays.asList(
+            ServiceResponse.newBuilder()
+                .setName("grpc.reflection.v1alpha.ServerReflection")
+                .build(),
+            ServiceResponse.newBuilder()
+                .setName("grpc.reflection.testing.AnotherReflectableService")
+                .build())),
+        new HashSet<>(response));
+  }
+
+  @Test
+  public void flowControl() throws Exception {
+    FlowControlClientResponseObserver clientResponseObserver =
+        new FlowControlClientResponseObserver();
+    ClientCallStreamObserver<ServerReflectionRequest> requestObserver =
+        (ClientCallStreamObserver<ServerReflectionRequest>)
+            stub.serverReflectionInfo(clientResponseObserver);
+
+    // Verify we don't receive a response until we request it.
+    requestObserver.onNext(flowControlRequest);
+    assertEquals(0, clientResponseObserver.getResponses().size());
+
+    requestObserver.request(1);
+    assertEquals(1, clientResponseObserver.getResponses().size());
+    assertEquals(flowControlGoldenResponse, clientResponseObserver.getResponses().get(0));
+
+    // Verify we don't receive an additional response until we request it.
+    requestObserver.onNext(flowControlRequest);
+    assertEquals(1, clientResponseObserver.getResponses().size());
+
+    requestObserver.request(1);
+    assertEquals(2, clientResponseObserver.getResponses().size());
+    assertEquals(flowControlGoldenResponse, clientResponseObserver.getResponses().get(1));
+
+    requestObserver.onCompleted();
+    assertTrue(clientResponseObserver.onCompleteCalled());
+  }
+
+  @Test
+  public void flowControlOnCompleteWithPendingRequest() throws Exception {
+    FlowControlClientResponseObserver clientResponseObserver =
+        new FlowControlClientResponseObserver();
+    ClientCallStreamObserver<ServerReflectionRequest> requestObserver =
+        (ClientCallStreamObserver<ServerReflectionRequest>)
+            stub.serverReflectionInfo(clientResponseObserver);
+
+    requestObserver.onNext(flowControlRequest);
+    requestObserver.onCompleted();
+    assertEquals(0, clientResponseObserver.getResponses().size());
+    assertFalse(clientResponseObserver.onCompleteCalled());
+
+    requestObserver.request(1);
+    assertTrue(clientResponseObserver.onCompleteCalled());
+    assertEquals(1, clientResponseObserver.getResponses().size());
+    assertEquals(flowControlGoldenResponse, clientResponseObserver.getResponses().get(0));
+  }
+
+  private final ServerReflectionRequest flowControlRequest =
+      ServerReflectionRequest.newBuilder()
+          .setHost(TEST_HOST)
+          .setFileByFilename("io/grpc/reflection/testing/reflection_test_depth_three.proto")
+          .build();
+  private final ServerReflectionResponse flowControlGoldenResponse =
+      ServerReflectionResponse.newBuilder()
+          .setValidHost(TEST_HOST)
+          .setOriginalRequest(flowControlRequest)
+          .setFileDescriptorResponse(
+              FileDescriptorResponse.newBuilder()
+                  .addFileDescriptorProto(
+                      ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString())
+                  .build())
+          .build();
+
+  private static class FlowControlClientResponseObserver
+      implements ClientResponseObserver<ServerReflectionRequest, ServerReflectionResponse> {
+    private final List<ServerReflectionResponse> responses =
+        new ArrayList<>();
+    private boolean onCompleteCalled = false;
+
+    @Override
+    public void beforeStart(final ClientCallStreamObserver<ServerReflectionRequest> requestStream) {
+      requestStream.disableAutoRequestWithInitial(0);
+    }
+
+    @Override
+    public void onNext(ServerReflectionResponse value) {
+      responses.add(value);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+      fail("onError called");
+    }
+
+    @Override
+    public void onCompleted() {
+      onCompleteCalled = true;
+    }
+
+    public List<ServerReflectionResponse> getResponses() {
+      return responses;
+    }
+
+    public boolean onCompleteCalled() {
+      return onCompleteCalled;
+    }
+  }
+
+  private void assertServiceResponseEquals(Set<ServiceResponse> goldenResponse) throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder().setHost(TEST_HOST).setListServices("services").build();
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    List<ServiceResponse> response =
+        responseObserver.firstValue().get().getListServicesResponse().getServiceList();
+    assertEquals(goldenResponse.size(), response.size());
+    assertEquals(goldenResponse, new HashSet<>(response));
+  }
+}
diff --git a/services/src/test/java/io/grpc/protobuf/services/ProtoReflectionServiceV1Test.java b/services/src/test/java/io/grpc/protobuf/services/ProtoReflectionServiceV1Test.java
new file mode 100644
index 00000000000..47bd3e792ad
--- /dev/null
+++ b/services/src/test/java/io/grpc/protobuf/services/ProtoReflectionServiceV1Test.java
@@ -0,0 +1,670 @@
+/*
+ * Copyright 2016 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.protobuf.services;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.google.protobuf.ByteString;
+import io.grpc.BindableService;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.testing.StreamRecorder;
+import io.grpc.reflection.testing.AnotherDynamicServiceGrpc;
+import io.grpc.reflection.testing.AnotherReflectableServiceGrpc;
+import io.grpc.reflection.testing.DynamicReflectionTestDepthTwoProto;
+import io.grpc.reflection.testing.DynamicServiceGrpc;
+import io.grpc.reflection.testing.ReflectableServiceGrpc;
+import io.grpc.reflection.testing.ReflectionTestDepthThreeProto;
+import io.grpc.reflection.testing.ReflectionTestDepthTwoAlternateProto;
+import io.grpc.reflection.testing.ReflectionTestDepthTwoProto;
+import io.grpc.reflection.testing.ReflectionTestProto;
+import io.grpc.reflection.v1.ExtensionNumberResponse;
+import io.grpc.reflection.v1.ExtensionRequest;
+import io.grpc.reflection.v1.FileDescriptorResponse;
+import io.grpc.reflection.v1.ServerReflectionGrpc;
+import io.grpc.reflection.v1.ServerReflectionRequest;
+import io.grpc.reflection.v1.ServerReflectionResponse;
+import io.grpc.reflection.v1.ServiceResponse;
+import io.grpc.stub.ClientCallStreamObserver;
+import io.grpc.stub.ClientResponseObserver;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.util.MutableHandlerRegistry;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link ProtoReflectionServiceV1}. */
+@RunWith(JUnit4.class)
+public class ProtoReflectionServiceV1Test {
+  @Rule
+  public GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
+
+  private static final String TEST_HOST = "localhost";
+  private MutableHandlerRegistry handlerRegistry = new MutableHandlerRegistry();
+  private BindableService reflectionService;
+  private ServerServiceDefinition dynamicService =
+      new DynamicServiceGrpc.DynamicServiceImplBase() {}.bindService();
+  private ServerServiceDefinition anotherDynamicService =
+      new AnotherDynamicServiceGrpc.AnotherDynamicServiceImplBase() {}.bindService();
+  private ServerReflectionGrpc.ServerReflectionStub stub;
+
+  @Before
+  public void setUp() throws Exception {
+    reflectionService = ProtoReflectionServiceV1.newInstance();
+    Server server =
+        InProcessServerBuilder.forName("proto-reflection-test")
+            .directExecutor()
+            .addService(reflectionService)
+            .addService(new ReflectableServiceGrpc.ReflectableServiceImplBase() {})
+            .fallbackHandlerRegistry(handlerRegistry)
+            .build()
+            .start();
+    grpcCleanupRule.register(server);
+    ManagedChannel channel =
+        grpcCleanupRule.register(
+            InProcessChannelBuilder.forName("proto-reflection-test").directExecutor().build());
+    stub = ServerReflectionGrpc.newStub(channel);
+  }
+
+  @Test
+  public void listServices() throws Exception {
+    Set<ServiceResponse> originalServices =
+        new HashSet<>(
+            Arrays.asList(
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.v1.ServerReflection")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.ReflectableService")
+                    .build()));
+    assertServiceResponseEquals(originalServices);
+
+    handlerRegistry.addService(dynamicService);
+    assertServiceResponseEquals(
+        new HashSet<>(
+            Arrays.asList(
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.v1.ServerReflection")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.ReflectableService")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.DynamicService")
+                    .build())));
+
+    handlerRegistry.addService(anotherDynamicService);
+    assertServiceResponseEquals(
+        new HashSet<>(
+            Arrays.asList(
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.v1.ServerReflection")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.ReflectableService")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.DynamicService")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.AnotherDynamicService")
+                    .build())));
+
+    handlerRegistry.removeService(dynamicService);
+    assertServiceResponseEquals(
+        new HashSet<>(
+            Arrays.asList(
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.v1.ServerReflection")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.ReflectableService")
+                    .build(),
+                ServiceResponse.newBuilder()
+                    .setName("grpc.reflection.testing.AnotherDynamicService")
+                    .build())));
+
+    handlerRegistry.removeService(anotherDynamicService);
+    assertServiceResponseEquals(originalServices);
+  }
+
+  @Test
+  public void fileByFilename() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileByFilename("io/grpc/reflection/testing/reflection_test_depth_three.proto")
+            .build();
+
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setFileDescriptorResponse(
+                FileDescriptorResponse.newBuilder()
+                    .addFileDescriptorProto(
+                        ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString())
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+
+    assertEquals(goldenResponse, responseObserver.firstValue().get());
+  }
+
+  @Test
+  public void fileByFilenameConsistentForMutableServices() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileByFilename("io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto")
+            .build();
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setFileDescriptorResponse(
+                FileDescriptorResponse.newBuilder()
+                    .addFileDescriptorProto(
+                        DynamicReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString())
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    handlerRegistry.addService(dynamicService);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver2 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver2 =
+        stub.serverReflectionInfo(responseObserver2);
+    handlerRegistry.removeService(dynamicService);
+    requestObserver2.onNext(request);
+    requestObserver2.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver3 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver3 =
+        stub.serverReflectionInfo(responseObserver3);
+    requestObserver3.onNext(request);
+    requestObserver3.onCompleted();
+
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver.firstValue().get().getMessageResponseCase());
+    assertEquals(goldenResponse, responseObserver2.firstValue().get());
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver3.firstValue().get().getMessageResponseCase());
+  }
+
+  @Test
+  public void fileContainingSymbol() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileContainingSymbol("grpc.reflection.testing.ReflectableService.Method")
+            .build();
+
+    List<ByteString> goldenResponse =
+        Arrays.asList(
+            ReflectionTestProto.getDescriptor().toProto().toByteString(),
+            ReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString(),
+            ReflectionTestDepthTwoAlternateProto.getDescriptor().toProto().toByteString(),
+            ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString());
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+
+    List<ByteString> response =
+        responseObserver
+            .firstValue()
+            .get()
+            .getFileDescriptorResponse()
+            .getFileDescriptorProtoList();
+    assertEquals(goldenResponse.size(), response.size());
+    assertEquals(new HashSet<>(goldenResponse), new HashSet<>(response));
+  }
+
+  @Test
+  public void fileContainingNestedSymbol() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileContainingSymbol("grpc.reflection.testing.NestedTypeOuter.Middle.Inner")
+            .build();
+
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setFileDescriptorResponse(
+                FileDescriptorResponse.newBuilder()
+                    .addFileDescriptorProto(
+                        ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString())
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    assertEquals(goldenResponse, responseObserver.firstValue().get());
+  }
+
+  @Test
+  public void fileContainingSymbolForMutableServices() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileContainingSymbol("grpc.reflection.testing.DynamicRequest")
+            .build();
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setFileDescriptorResponse(
+                FileDescriptorResponse.newBuilder()
+                    .addFileDescriptorProto(
+                        DynamicReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString())
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    handlerRegistry.addService(dynamicService);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver2 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver2 =
+        stub.serverReflectionInfo(responseObserver2);
+    handlerRegistry.removeService(dynamicService);
+    requestObserver2.onNext(request);
+    requestObserver2.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver3 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver3 =
+        stub.serverReflectionInfo(responseObserver3);
+    requestObserver3.onNext(request);
+    requestObserver3.onCompleted();
+
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver.firstValue().get().getMessageResponseCase());
+    assertEquals(goldenResponse, responseObserver2.firstValue().get());
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver3.firstValue().get().getMessageResponseCase());
+  }
+
+  @Test
+  public void fileContainingExtension() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileContainingExtension(
+                ExtensionRequest.newBuilder()
+                    .setContainingType("grpc.reflection.testing.ThirdLevelType")
+                    .setExtensionNumber(100)
+                    .build())
+            .build();
+
+    List<ByteString> goldenResponse =
+        Arrays.asList(
+            ReflectionTestProto.getDescriptor().toProto().toByteString(),
+            ReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString(),
+            ReflectionTestDepthTwoAlternateProto.getDescriptor().toProto().toByteString(),
+            ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString());
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+
+    List<ByteString> response =
+        responseObserver
+            .firstValue()
+            .get()
+            .getFileDescriptorResponse()
+            .getFileDescriptorProtoList();
+    assertEquals(goldenResponse.size(), response.size());
+    assertEquals(new HashSet<>(goldenResponse), new HashSet<>(response));
+  }
+
+  @Test
+  public void fileContainingNestedExtension() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileContainingExtension(
+                ExtensionRequest.newBuilder()
+                    .setContainingType("grpc.reflection.testing.ThirdLevelType")
+                    .setExtensionNumber(101)
+                    .build())
+            .build();
+
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setFileDescriptorResponse(
+                FileDescriptorResponse.newBuilder()
+                    .addFileDescriptorProto(
+                        ReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString())
+                    .addFileDescriptorProto(
+                        ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString())
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    assertEquals(goldenResponse, responseObserver.firstValue().get());
+  }
+
+  @Test
+  public void fileContainingExtensionForMutableServices() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setFileContainingExtension(
+                ExtensionRequest.newBuilder()
+                    .setContainingType("grpc.reflection.testing.TypeWithExtensions")
+                    .setExtensionNumber(200)
+                    .build())
+            .build();
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setFileDescriptorResponse(
+                FileDescriptorResponse.newBuilder()
+                    .addFileDescriptorProto(
+                        DynamicReflectionTestDepthTwoProto.getDescriptor().toProto().toByteString())
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    handlerRegistry.addService(dynamicService);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver2 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver2 =
+        stub.serverReflectionInfo(responseObserver2);
+    handlerRegistry.removeService(dynamicService);
+    requestObserver2.onNext(request);
+    requestObserver2.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver3 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver3 =
+        stub.serverReflectionInfo(responseObserver3);
+    requestObserver3.onNext(request);
+    requestObserver3.onCompleted();
+
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver.firstValue().get().getMessageResponseCase());
+    assertEquals(goldenResponse, responseObserver2.firstValue().get());
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver3.firstValue().get().getMessageResponseCase());
+  }
+
+  @Test
+  public void allExtensionNumbersOfType() throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setAllExtensionNumbersOfType("grpc.reflection.testing.ThirdLevelType")
+            .build();
+
+    Set<Integer> goldenResponse = new HashSet<>(Arrays.asList(100, 101));
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    Set<Integer> extensionNumberResponseSet =
+        new HashSet<>(
+            responseObserver
+                .firstValue()
+                .get()
+                .getAllExtensionNumbersResponse()
+                .getExtensionNumberList());
+    assertEquals(goldenResponse, extensionNumberResponseSet);
+  }
+
+  @Test
+  public void allExtensionNumbersOfTypeForMutableServices() throws Exception {
+    String type = "grpc.reflection.testing.TypeWithExtensions";
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder()
+            .setHost(TEST_HOST)
+            .setAllExtensionNumbersOfType(type)
+            .build();
+    ServerReflectionResponse goldenResponse =
+        ServerReflectionResponse.newBuilder()
+            .setValidHost(TEST_HOST)
+            .setOriginalRequest(request)
+            .setAllExtensionNumbersResponse(
+                ExtensionNumberResponse.newBuilder()
+                    .setBaseTypeName(type)
+                    .addExtensionNumber(200)
+                    .build())
+            .build();
+
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    handlerRegistry.addService(dynamicService);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver2 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver2 =
+        stub.serverReflectionInfo(responseObserver2);
+    handlerRegistry.removeService(dynamicService);
+    requestObserver2.onNext(request);
+    requestObserver2.onCompleted();
+    StreamRecorder<ServerReflectionResponse> responseObserver3 = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver3 =
+        stub.serverReflectionInfo(responseObserver3);
+    requestObserver3.onNext(request);
+    requestObserver3.onCompleted();
+
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver.firstValue().get().getMessageResponseCase());
+    assertEquals(goldenResponse, responseObserver2.firstValue().get());
+    assertEquals(
+        ServerReflectionResponse.MessageResponseCase.ERROR_RESPONSE,
+        responseObserver3.firstValue().get().getMessageResponseCase());
+  }
+
+  @Test
+  public void sharedServiceBetweenServers()
+      throws IOException, ExecutionException, InterruptedException {
+    Server anotherServer = InProcessServerBuilder.forName("proto-reflection-test-2")
+        .directExecutor()
+        .addService(reflectionService)
+        .addService(new AnotherReflectableServiceGrpc.AnotherReflectableServiceImplBase() {})
+        .build()
+        .start();
+    grpcCleanupRule.register(anotherServer);
+    ManagedChannel anotherChannel = grpcCleanupRule.register(
+        InProcessChannelBuilder.forName("proto-reflection-test-2").directExecutor().build());
+    ServerReflectionGrpc.ServerReflectionStub stub2 = ServerReflectionGrpc.newStub(anotherChannel);
+
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder().setHost(TEST_HOST).setListServices("services").build();
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub2.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    List<ServiceResponse> response =
+        responseObserver.firstValue().get().getListServicesResponse().getServiceList();
+    assertEquals(new HashSet<>(
+        Arrays.asList(
+            ServiceResponse.newBuilder()
+                .setName("grpc.reflection.v1.ServerReflection")
+                .build(),
+            ServiceResponse.newBuilder()
+                .setName("grpc.reflection.testing.AnotherReflectableService")
+                .build())),
+        new HashSet<>(response));
+  }
+
+  @Test
+  public void flowControl() throws Exception {
+    FlowControlClientResponseObserver clientResponseObserver =
+        new FlowControlClientResponseObserver();
+    ClientCallStreamObserver<ServerReflectionRequest> requestObserver =
+        (ClientCallStreamObserver<ServerReflectionRequest>)
+            stub.serverReflectionInfo(clientResponseObserver);
+
+    // Verify we don't receive a response until we request it.
+    requestObserver.onNext(flowControlRequest);
+    assertEquals(0, clientResponseObserver.getResponses().size());
+
+    requestObserver.request(1);
+    assertEquals(1, clientResponseObserver.getResponses().size());
+    assertEquals(flowControlGoldenResponse, clientResponseObserver.getResponses().get(0));
+
+    // Verify we don't receive an additional response until we request it.
+    requestObserver.onNext(flowControlRequest);
+    assertEquals(1, clientResponseObserver.getResponses().size());
+
+    requestObserver.request(1);
+    assertEquals(2, clientResponseObserver.getResponses().size());
+    assertEquals(flowControlGoldenResponse, clientResponseObserver.getResponses().get(1));
+
+    requestObserver.onCompleted();
+    assertTrue(clientResponseObserver.onCompleteCalled());
+  }
+
+  @Test
+  public void flowControlOnCompleteWithPendingRequest() throws Exception {
+    FlowControlClientResponseObserver clientResponseObserver =
+        new FlowControlClientResponseObserver();
+    ClientCallStreamObserver<ServerReflectionRequest> requestObserver =
+        (ClientCallStreamObserver<ServerReflectionRequest>)
+            stub.serverReflectionInfo(clientResponseObserver);
+
+    requestObserver.onNext(flowControlRequest);
+    requestObserver.onCompleted();
+    assertEquals(0, clientResponseObserver.getResponses().size());
+    assertFalse(clientResponseObserver.onCompleteCalled());
+
+    requestObserver.request(1);
+    assertTrue(clientResponseObserver.onCompleteCalled());
+    assertEquals(1, clientResponseObserver.getResponses().size());
+    assertEquals(flowControlGoldenResponse, clientResponseObserver.getResponses().get(0));
+  }
+
+  private final ServerReflectionRequest flowControlRequest =
+      ServerReflectionRequest.newBuilder()
+          .setHost(TEST_HOST)
+          .setFileByFilename("io/grpc/reflection/testing/reflection_test_depth_three.proto")
+          .build();
+  private final ServerReflectionResponse flowControlGoldenResponse =
+      ServerReflectionResponse.newBuilder()
+          .setValidHost(TEST_HOST)
+          .setOriginalRequest(flowControlRequest)
+          .setFileDescriptorResponse(
+              FileDescriptorResponse.newBuilder()
+                  .addFileDescriptorProto(
+                      ReflectionTestDepthThreeProto.getDescriptor().toProto().toByteString())
+                  .build())
+          .build();
+
+  private static class FlowControlClientResponseObserver
+      implements ClientResponseObserver<ServerReflectionRequest, ServerReflectionResponse> {
+    private final List<ServerReflectionResponse> responses =
+        new ArrayList<>();
+    private boolean onCompleteCalled = false;
+
+    @Override
+    public void beforeStart(final ClientCallStreamObserver<ServerReflectionRequest> requestStream) {
+      requestStream.disableAutoRequestWithInitial(0);
+    }
+
+    @Override
+    public void onNext(ServerReflectionResponse value) {
+      responses.add(value);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+      fail("onError called");
+    }
+
+    @Override
+    public void onCompleted() {
+      onCompleteCalled = true;
+    }
+
+    public List<ServerReflectionResponse> getResponses() {
+      return responses;
+    }
+
+    public boolean onCompleteCalled() {
+      return onCompleteCalled;
+    }
+  }
+
+  private void assertServiceResponseEquals(Set<ServiceResponse> goldenResponse) throws Exception {
+    ServerReflectionRequest request =
+        ServerReflectionRequest.newBuilder().setHost(TEST_HOST).setListServices("services").build();
+    StreamRecorder<ServerReflectionResponse> responseObserver = StreamRecorder.create();
+    StreamObserver<ServerReflectionRequest> requestObserver =
+        stub.serverReflectionInfo(responseObserver);
+    requestObserver.onNext(request);
+    requestObserver.onCompleted();
+    List<ServiceResponse> response =
+        responseObserver.firstValue().get().getListServicesResponse().getServiceList();
+    assertEquals(goldenResponse.size(), response.size());
+    assertEquals(goldenResponse, new HashSet<>(response));
+  }
+}
diff --git a/services/src/test/java/io/grpc/protobuf/services/TempFileSinkTest.java b/services/src/test/java/io/grpc/protobuf/services/TempFileSinkTest.java
new file mode 100644
index 00000000000..e3b662a8588
--- /dev/null
+++ b/services/src/test/java/io/grpc/protobuf/services/TempFileSinkTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2018, gRPC Authors All rights reserved.
+ *
+ * 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.protobuf.services;
+
+import static org.junit.Assert.assertEquals;
+
+import io.grpc.binarylog.v1.GrpcLogEntry;
+import io.grpc.protobuf.services.TempFileSink;
+import java.io.DataInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link TempFileSink}.
+ */
+@RunWith(JUnit4.class)
+public class TempFileSinkTest {
+  @Test
+  public void readMyWrite() throws Exception {
+    TempFileSink sink = new TempFileSink();
+    GrpcLogEntry e1 = GrpcLogEntry.newBuilder()
+        .setCallId(1234)
+        .build();
+    GrpcLogEntry e2 = GrpcLogEntry.newBuilder()
+        .setCallId(5678)
+        .build();
+    sink.write(e1);
+    sink.write(e2);
+    sink.close();
+
+    DataInputStream input = new DataInputStream(new FileInputStream(sink.getPath()));
+    try {
+      GrpcLogEntry read1 = GrpcLogEntry.parseDelimitedFrom(input);
+      GrpcLogEntry read2 = GrpcLogEntry.parseDelimitedFrom(input);
+
+      assertEquals(e1, read1);
+      assertEquals(e2, read2);
+      assertEquals(-1, input.read());
+    } finally {
+      input.close();
+    }
+  }
+
+  @Test
+  public void writeAfterCloseIsSilent() throws IOException {
+    TempFileSink sink = new TempFileSink();
+    sink.close();
+    sink.write(GrpcLogEntry.newBuilder()
+        .setCallId(1234)
+        .build());
+  }
+}
diff --git a/services/src/test/java/io/grpc/protobuf/services/internal/HealthCheckingRoundRobinLoadBalancerProviderTest.java b/services/src/test/java/io/grpc/protobuf/services/internal/HealthCheckingRoundRobinLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..470670f2060
--- /dev/null
+++ b/services/src/test/java/io/grpc/protobuf/services/internal/HealthCheckingRoundRobinLoadBalancerProviderTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2018 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.protobuf.services.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link HealthCheckingRoundRobinLoadBalancerProvider}.
+ */
+@RunWith(JUnit4.class)
+public class HealthCheckingRoundRobinLoadBalancerProviderTest {
+  @Test
+  public void registry() {
+    LoadBalancerProvider hcRoundRobin =
+        LoadBalancerRegistry.getDefaultRegistry().getProvider("round_robin");
+    assertThat(hcRoundRobin).isInstanceOf(
+        HealthCheckingRoundRobinLoadBalancerProvider.class);
+  }
+
+  @Test
+  public void policyName() {
+    LoadBalancerProvider hcRoundRobin = new HealthCheckingRoundRobinLoadBalancerProvider();
+    assertThat(hcRoundRobin.getPolicyName())
+        .isEqualTo(
+            HealthCheckingRoundRobinLoadBalancerProvider.newRoundRobinProvider().getPolicyName());
+  }
+
+  @Test
+  public void priority() {
+    LoadBalancerProvider hcRoundRobin = new HealthCheckingRoundRobinLoadBalancerProvider();
+    assertThat(hcRoundRobin.getPriority())
+        .isEqualTo(
+            HealthCheckingRoundRobinLoadBalancerProvider.newRoundRobinProvider().getPriority() + 1);
+  }
+}
diff --git a/services/src/test/java/io/grpc/services/AdminInterfaceChannelzTest.java b/services/src/test/java/io/grpc/services/AdminInterfaceChannelzTest.java
new file mode 100644
index 00000000000..7d7c68108fb
--- /dev/null
+++ b/services/src/test/java/io/grpc/services/AdminInterfaceChannelzTest.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2021 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.services;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.Iterables;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.channelz.v1.ChannelzGrpc;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class AdminInterfaceChannelzTest {
+
+  @Test
+  public void autoChannelz() {
+    ServerServiceDefinition channelz =
+        Iterables.getOnlyElement(AdminInterface.getStandardServices());
+    assertThat(channelz.getServiceDescriptor().getName()).isEqualTo(ChannelzGrpc.SERVICE_NAME);
+  }
+}
diff --git a/services/src/test/java/io/grpc/services/CallMetricRecorderTest.java b/services/src/test/java/io/grpc/services/CallMetricRecorderTest.java
new file mode 100644
index 00000000000..f60446b1a3a
--- /dev/null
+++ b/services/src/test/java/io/grpc/services/CallMetricRecorderTest.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright 2019 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.services;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.truth.Truth;
+import io.grpc.Context;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link CallMetricRecorder}. */
+@RunWith(JUnit4.class)
+public class CallMetricRecorderTest {
+
+  private final CallMetricRecorder recorder = new CallMetricRecorder();
+
+  @Test
+  public void dumpGivesEmptyResultWhenNoSavedMetricValues() {
+    assertThat(recorder.finalizeAndDump()).isEmpty();
+  }
+
+  @Test
+  public void dumpDumpsAllSavedMetricValues() {
+    recorder.recordUtilizationMetric("util1", 0.154353423);
+    recorder.recordUtilizationMetric("util2", 0.1367);
+    recorder.recordUtilizationMetric("util3", 0.143734);
+    recorder.recordRequestCostMetric("cost1", 37465.12);
+    recorder.recordRequestCostMetric("cost2", 10293.0);
+    recorder.recordRequestCostMetric("cost3", 1.0);
+    recorder.recordNamedMetric("named1", 0.2233);
+    recorder.recordNamedMetric("named2", -1.618);
+    recorder.recordNamedMetric("named3", 3.1415926535);
+    recorder.recordCpuUtilizationMetric(0.1928);
+    recorder.recordApplicationUtilizationMetric(0.9987);
+    recorder.recordMemoryUtilizationMetric(0.474);
+    recorder.recordQpsMetric(2522.54);
+    recorder.recordEpsMetric(1.618);
+
+    MetricReport dump = recorder.finalizeAndDump2();
+    Truth.assertThat(dump.getUtilizationMetrics())
+        .containsExactly("util1", 0.154353423, "util2", 0.1367, "util3", 0.143734);
+    Truth.assertThat(dump.getRequestCostMetrics())
+        .containsExactly("cost1", 37465.12, "cost2", 10293.0, "cost3", 1.0);
+    Truth.assertThat(dump.getNamedMetrics())
+        .containsExactly("named1", 0.2233, "named2", -1.618, "named3", 3.1415926535);
+    Truth.assertThat(dump.getCpuUtilization()).isEqualTo(0.1928);
+    Truth.assertThat(dump.getApplicationUtilization()).isEqualTo(0.9987);
+    Truth.assertThat(dump.getMemoryUtilization()).isEqualTo(0.474);
+    Truth.assertThat(dump.getQps()).isEqualTo(2522.54);
+    Truth.assertThat(dump.getEps()).isEqualTo(1.618);
+    Truth.assertThat(dump.toString()).contains("eps=1.618");
+    Truth.assertThat(dump.toString()).contains("applicationUtilization=0.9987");
+    Truth.assertThat(dump.toString()).contains("named1=0.2233");
+    Truth.assertThat(dump.toString()).contains("named2=-1.618");
+    Truth.assertThat(dump.toString()).contains("named3=3.1415926535");
+  }
+
+  @Test
+  public void noMetricsRecordedAfterSnapshot() {
+    Map<String, Double> initDump = recorder.finalizeAndDump();
+    recorder.recordApplicationUtilizationMetric(0.01);
+    recorder.recordUtilizationMetric("cost", 0.154353423);
+    recorder.recordQpsMetric(3.14159);
+    recorder.recordEpsMetric(1.618);
+    recorder.recordNamedMetric("named1", 2.718);
+    assertThat(recorder.finalizeAndDump()).isEqualTo(initDump);
+  }
+
+  @Test
+  public void noMetricsRecordedIfUtilizationIsGreaterThanUpperBound() {
+    recorder.recordCpuUtilizationMetric(1.001);
+    recorder.recordMemoryUtilizationMetric(1.001);
+    recorder.recordUtilizationMetric("util1", 1.001);
+
+    MetricReport dump = recorder.finalizeAndDump2();
+    Truth.assertThat(dump.getCpuUtilization()).isEqualTo(1.001);
+    Truth.assertThat(dump.getMemoryUtilization()).isEqualTo(0);
+    Truth.assertThat(dump.getQps()).isEqualTo(0);
+    Truth.assertThat(dump.getUtilizationMetrics()).isEmpty();
+    Truth.assertThat(dump.getRequestCostMetrics()).isEmpty();
+  }
+
+  @Test
+  public void noMetricsRecordedIfUtilizationAndQpsAreLessThanLowerBound() {
+    recorder.recordCpuUtilizationMetric(-0.001);
+    recorder.recordApplicationUtilizationMetric(-0.001);
+    recorder.recordMemoryUtilizationMetric(-0.001);
+    recorder.recordQpsMetric(-0.001);
+    recorder.recordEpsMetric(-0.001);
+    recorder.recordUtilizationMetric("util1", -0.001);
+
+    MetricReport dump = recorder.finalizeAndDump2();
+    Truth.assertThat(dump.getCpuUtilization()).isEqualTo(0);
+    Truth.assertThat(dump.getApplicationUtilization()).isEqualTo(0);
+    Truth.assertThat(dump.getMemoryUtilization()).isEqualTo(0);
+    Truth.assertThat(dump.getQps()).isEqualTo(0);
+    Truth.assertThat(dump.getEps()).isEqualTo(0);
+    Truth.assertThat(dump.getUtilizationMetrics()).isEmpty();
+    Truth.assertThat(dump.getRequestCostMetrics()).isEmpty();
+  }
+
+  @Test
+  public void lastValueWinForMetricsWithSameName() {
+    recorder.recordRequestCostMetric("cost1", 3412.5435);
+    recorder.recordRequestCostMetric("cost2", 6441.341);
+    recorder.recordRequestCostMetric("cost1", 6441.341);
+    recorder.recordRequestCostMetric("cost1", 4654.67);
+    recorder.recordRequestCostMetric("cost2", 75.83);
+    recorder.recordApplicationUtilizationMetric(0.92);
+    recorder.recordApplicationUtilizationMetric(1.78);
+    recorder.recordMemoryUtilizationMetric(0.13);
+    recorder.recordMemoryUtilizationMetric(0.31);
+    recorder.recordUtilizationMetric("util1", 0.2837421);
+    recorder.recordMemoryUtilizationMetric(0.93840);
+    recorder.recordUtilizationMetric("util1", 0.843233);
+    recorder.recordNamedMetric("named1", 0.2233);
+    recorder.recordNamedMetric("named2", 2.718);
+    recorder.recordNamedMetric("named1", 3.1415926535);
+    recorder.recordQpsMetric(1928.3);
+    recorder.recordQpsMetric(100.8);
+    recorder.recordEpsMetric(3.14159);
+    recorder.recordEpsMetric(1.618);
+
+    MetricReport dump = recorder.finalizeAndDump2();
+    Truth.assertThat(dump.getRequestCostMetrics())
+        .containsExactly("cost1", 4654.67, "cost2", 75.83);
+    Truth.assertThat(dump.getApplicationUtilization()).isEqualTo(1.78);
+    Truth.assertThat(dump.getMemoryUtilization()).isEqualTo(0.93840);
+    Truth.assertThat(dump.getUtilizationMetrics())
+        .containsExactly("util1", 0.843233);
+    Truth.assertThat(dump.getNamedMetrics())
+        .containsExactly("named1", 3.1415926535, "named2", 2.718);
+    Truth.assertThat(dump.getCpuUtilization()).isEqualTo(0);
+    Truth.assertThat(dump.getQps()).isEqualTo(100.8);
+    Truth.assertThat(dump.getEps()).isEqualTo(1.618);
+  }
+
+  @Test
+  public void getCurrent_sameEnabledInstance() {
+    CallMetricRecorder recorder = new CallMetricRecorder();
+    Context ctx = Context.ROOT.withValue(CallMetricRecorder.CONTEXT_KEY, recorder);
+    Context origCtx = ctx.attach();
+    try {
+      assertThat(CallMetricRecorder.getCurrent()).isSameInstanceAs(recorder);
+      assertThat(recorder.isDisabled()).isFalse();
+    } finally {
+      ctx.detach(origCtx);
+    }
+  }
+
+  @Test
+  public void getCurrent_blankContext() {
+    Context blankCtx = Context.ROOT;
+    Context origCtx = blankCtx.attach();
+    try {
+      assertThat(CallMetricRecorder.getCurrent().isDisabled()).isTrue();
+    } finally {
+      blankCtx.detach(origCtx);
+    }
+  }
+}
diff --git a/services/src/test/java/io/grpc/services/HealthStatusManagerTest.java b/services/src/test/java/io/grpc/services/HealthStatusManagerTest.java
deleted file mode 100644
index dfa5eff41e3..00000000000
--- a/services/src/test/java/io/grpc/services/HealthStatusManagerTest.java
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.services;
-
-import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-import io.grpc.Status;
-import io.grpc.StatusException;
-import io.grpc.health.v1.HealthCheckRequest;
-import io.grpc.health.v1.HealthCheckResponse;
-import io.grpc.health.v1.HealthGrpc;
-import io.grpc.stub.StreamObserver;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InOrder;
-
-/** Unit tests for {@link HealthStatusManager}. */
-@RunWith(JUnit4.class)
-public class HealthStatusManagerTest {
-
-  private final HealthStatusManager manager = new HealthStatusManager();
-  private final HealthGrpc.HealthImplBase health = manager.getHealthService();
-  private final HealthCheckResponse.ServingStatus status
-      = HealthCheckResponse.ServingStatus.UNKNOWN;
-
-  @Test
-  public void getHealthService_getterReturnsTheSameHealthRefAfterUpdate() throws Exception {
-    manager.setStatus("", status);
-    assertEquals(health, manager.getHealthService());
-  }
-
-
-  @Test
-  public void checkValidStatus() throws Exception {
-    //setup
-    manager.setStatus("", status);
-    HealthCheckRequest request = HealthCheckRequest.newBuilder().setService("").build();
-    @SuppressWarnings("unchecked")
-    StreamObserver<HealthCheckResponse> observer = mock(StreamObserver.class);
-
-    //test
-    health.check(request, observer);
-
-    //verify
-    InOrder inOrder = inOrder(observer);
-    inOrder.verify(observer, times(1)).onNext(any(HealthCheckResponse.class));
-    inOrder.verify(observer, times(1)).onCompleted();
-    verify(observer, never()).onError(any(Throwable.class));
-  }
-
-  @Test
-  public void checkStatusNotFound() throws Exception {
-    //setup
-    manager.setStatus("", status);
-    HealthCheckRequest request
-        = HealthCheckRequest.newBuilder().setService("invalid").build();
-    @SuppressWarnings("unchecked")
-    StreamObserver<HealthCheckResponse> observer = mock(StreamObserver.class);
-
-    //test
-    health.check(request, observer);
-
-    //verify
-    ArgumentCaptor<StatusException> exception = ArgumentCaptor.forClass(StatusException.class);
-    verify(observer, times(1)).onError(exception.capture());
-    assertEquals(Status.NOT_FOUND, exception.getValue().getStatus());
-
-    verify(observer, never()).onCompleted();
-  }
-
-  @Test
-  public void notFoundForClearedStatus() throws Exception {
-    //setup
-    manager.setStatus("", status);
-    manager.clearStatus("");
-    HealthCheckRequest request
-        = HealthCheckRequest.newBuilder().setService("").build();
-    @SuppressWarnings("unchecked")
-    StreamObserver<HealthCheckResponse> observer = mock(StreamObserver.class);
-
-    //test
-    health.check(request, observer);
-
-    //verify
-    ArgumentCaptor<StatusException> exception = ArgumentCaptor.forClass(StatusException.class);
-    verify(observer, times(1)).onError(exception.capture());
-    assertEquals(Status.NOT_FOUND, exception.getValue().getStatus());
-
-    verify(observer, never()).onCompleted();
-  }
-}
diff --git a/services/src/test/proto/io/grpc/reflection/testing/dynamic_reflection_test.proto b/services/src/test/proto/io/grpc/reflection/testing/dynamic_reflection_test.proto
index a8b84433d5c..49644041a3f 100644
--- a/services/src/test/proto/io/grpc/reflection/testing/dynamic_reflection_test.proto
+++ b/services/src/test/proto/io/grpc/reflection/testing/dynamic_reflection_test.proto
@@ -1,32 +1,16 @@
-// Copyright 2016, Google Inc.
-// All rights reserved.
+// Copyright 2016 The gRPC Authors
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
+//     http://www.apache.org/licenses/LICENSE-2.0
 //
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
+// 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.
 // Service definition designed to test the ProtoReflectionService when a service
 // is dynamically added and removed.
 
diff --git a/services/src/test/proto/io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto b/services/src/test/proto/io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto
index 2299bca6c00..87d4b26d3c1 100644
--- a/services/src/test/proto/io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto
+++ b/services/src/test/proto/io/grpc/reflection/testing/dynamic_reflection_test_depth_two.proto
@@ -1,32 +1,16 @@
-// Copyright 2016, Google Inc.
-// All rights reserved.
+// Copyright 2016 The gRPC Authors
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
+//     http://www.apache.org/licenses/LICENSE-2.0
 //
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
+// 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.
 syntax = "proto2";
 
 option java_multiple_files = true;
diff --git a/services/src/test/proto/io/grpc/reflection/testing/reflection_test.proto b/services/src/test/proto/io/grpc/reflection/testing/reflection_test.proto
index 7c07e98ce1e..3d0cd020eeb 100644
--- a/services/src/test/proto/io/grpc/reflection/testing/reflection_test.proto
+++ b/services/src/test/proto/io/grpc/reflection/testing/reflection_test.proto
@@ -1,32 +1,16 @@
-// Copyright 2016, Google Inc.
-// All rights reserved.
+// Copyright 2016 The gRPC Authors
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
+//     http://www.apache.org/licenses/LICENSE-2.0
 //
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
+// 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.
 // Service definition designed to test the ProtoReflectionService. It contains
 // nested types, extensions, and multiple levels of imports.
 
@@ -48,3 +32,7 @@ extend ThirdLevelType {
 service ReflectableService {
   rpc Method (Request) returns (Reply) {}
 }
+
+service AnotherReflectableService {
+  rpc Method (Request) returns (Reply) {}
+}
diff --git a/services/src/test/proto/io/grpc/reflection/testing/reflection_test_depth_three.proto b/services/src/test/proto/io/grpc/reflection/testing/reflection_test_depth_three.proto
index ea12a5558b6..c6370a56fd4 100644
--- a/services/src/test/proto/io/grpc/reflection/testing/reflection_test_depth_three.proto
+++ b/services/src/test/proto/io/grpc/reflection/testing/reflection_test_depth_three.proto
@@ -1,32 +1,16 @@
-// Copyright 2016, Google Inc.
-// All rights reserved.
+// Copyright 2016 The gRPC Authors
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
+//     http://www.apache.org/licenses/LICENSE-2.0
 //
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
+// 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.
 // Part of the service definition designed to test the ProtoReflectionService.
 
 syntax = "proto2";
diff --git a/services/src/test/proto/io/grpc/reflection/testing/reflection_test_depth_two.proto b/services/src/test/proto/io/grpc/reflection/testing/reflection_test_depth_two.proto
index 39f3624fdf0..19d6a69380a 100644
--- a/services/src/test/proto/io/grpc/reflection/testing/reflection_test_depth_two.proto
+++ b/services/src/test/proto/io/grpc/reflection/testing/reflection_test_depth_two.proto
@@ -1,32 +1,16 @@
-// Copyright 2016, Google Inc.
-// All rights reserved.
+// Copyright 2016 The gRPC Authors
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
+//     http://www.apache.org/licenses/LICENSE-2.0
 //
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
+// 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.
 // Part of the service definition designed to test the ProtoReflectionService.
 
 syntax = "proto2";
diff --git a/services/src/test/proto/io/grpc/reflection/testing/reflection_test_depth_two_alternate.proto b/services/src/test/proto/io/grpc/reflection/testing/reflection_test_depth_two_alternate.proto
index fa2db62bfc7..c5b0c4163be 100644
--- a/services/src/test/proto/io/grpc/reflection/testing/reflection_test_depth_two_alternate.proto
+++ b/services/src/test/proto/io/grpc/reflection/testing/reflection_test_depth_two_alternate.proto
@@ -1,32 +1,16 @@
-// Copyright 2016, Google Inc.
-// All rights reserved.
+// Copyright 2016 The gRPC Authors
 //
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
+// 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
 //
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
+//     http://www.apache.org/licenses/LICENSE-2.0
 //
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
+// 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.
 // Provides an alternate dependency path to reflection_test_depth_three.proto,
 // to test that the reflection service only returns dependencies once.
 
diff --git a/servlet/build.gradle b/servlet/build.gradle
new file mode 100644
index 00000000000..1367a72ab44
--- /dev/null
+++ b/servlet/build.gradle
@@ -0,0 +1,132 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+}
+
+description = "gRPC: Servlet"
+
+sourceSets {
+    // Testing threading is more of a brute-force test and is very slow. No need to run it as part
+    // of normal suite.
+    threadingTest {}
+    // Create a test sourceset for each classpath - could be simplified if we made new test directories
+    undertowTest {}
+    tomcatTest {}
+
+    // Only compile these tests if java 11+ is being used
+    if (JavaVersion.current().isJava11Compatible()) {
+        jettyTest {}
+    }
+}
+
+configurations {
+    itImplementation.extendsFrom(implementation)
+    undertowTestImplementation.extendsFrom(itImplementation)
+    tomcatTestImplementation.extendsFrom(itImplementation)
+    jettyTestImplementation.extendsFrom(itImplementation)
+}
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.servlet')
+    }
+}
+
+dependencies {
+    api project(':grpc-api')
+    compileOnly libraries.javax.servlet.api
+
+    implementation project(':grpc-core'),
+            libraries.guava
+
+    testImplementation libraries.javax.servlet.api
+
+    threadingTestImplementation project(':grpc-servlet'),
+        libraries.junit,
+        libraries.javax.servlet.api,
+        libraries.lincheck
+
+    itImplementation project(':grpc-servlet'),
+            project(':grpc-netty'),
+            testFixtures(project(':grpc-core')),
+            libraries.junit
+    itImplementation(project(':grpc-interop-testing')) {
+        // Avoid grpc-netty-shaded dependency
+        exclude group: 'io.grpc', module: 'grpc-alts'
+        exclude group: 'io.grpc', module: 'grpc-xds'
+    }
+
+    undertowTestImplementation libraries.undertow.servlet22
+
+    tomcatTestImplementation libraries.tomcat.embed.core9
+
+    jettyTestImplementation libraries.jetty.servlet10,
+            libraries.jetty.http2.server10,
+            libraries.jetty.client,
+            project(':grpc-testing'),
+            libraries.truth,
+            libraries.protobuf.java
+}
+
+tasks.register('threadingTest', Test) {
+    classpath = sourceSets.threadingTest.runtimeClasspath
+    testClassesDirs = sourceSets.threadingTest.output.classesDirs
+    jacoco {
+        enabled = false
+    }
+}
+
+tasks.named("assemble").configure {
+    dependsOn tasks.named('compileThreadingTestJava')
+}
+
+// Set up individual classpaths for each test, to avoid any mismatch,
+// and ensure they are only used when supported by the current jvm
+def undertowTest = tasks.register('undertowTest', Test) {
+    classpath = sourceSets.undertowTest.runtimeClasspath
+    testClassesDirs = sourceSets.undertowTest.output.classesDirs
+}
+def tomcat9Test = tasks.register('tomcat9Test', Test) {
+    classpath = sourceSets.tomcatTest.runtimeClasspath
+    testClassesDirs = sourceSets.tomcatTest.output.classesDirs
+
+    // Provide a temporary directory for tomcat to be deleted after test finishes
+    def tomcatTempDir = "$buildDir/tomcat_catalina_base"
+    systemProperty 'catalina.base', tomcatTempDir
+    doLast {
+        file(tomcatTempDir).deleteDir()
+    }
+
+    // tomcat-embed-core 9 presently performs illegal reflective access on
+    // java.io.ObjectStreamClass$Caches.localDescs and sun.rmi.transport.Target.ccl,
+    // see https://lists.apache.org/thread/s0xr7tk2kfkkxfjps9n7dhh4cypfdhyy
+    if (JavaVersion.current().isJava9Compatible()) {
+        jvmArgs += ['--add-opens=java.base/java.io=ALL-UNNAMED', '--add-opens=java.rmi/sun.rmi.transport=ALL-UNNAMED']
+    }
+}
+
+tasks.named("check").configure {
+    dependsOn undertowTest, tomcat9Test
+}
+
+tasks.named("jacocoTestReport").configure {
+    // Must use executionData(Task...) override. The executionData(Object...) override doesn't find
+    // execution data correctly for tasks.
+    executionData undertowTest.get(), tomcat9Test.get()
+}
+
+// Only run these tests if java 11+ is being used
+if (JavaVersion.current().isJava11Compatible()) {
+    def jettyTest = tasks.register('jettyTest', Test) {
+        classpath = sourceSets.jettyTest.runtimeClasspath
+        testClassesDirs = sourceSets.jettyTest.output.classesDirs
+    }
+    tasks.named("check").configure {
+        dependsOn jettyTest
+    }
+    tasks.named("jacocoTestReport").configure {
+        // Must use executionData(Task...) override. The executionData(Object...) override doesn't
+        // find execution data correctly for tasks.
+        executionData jettyTest.get()
+    }
+}
diff --git a/servlet/jakarta/build.gradle b/servlet/jakarta/build.gradle
new file mode 100644
index 00000000000..bcd904ccaee
--- /dev/null
+++ b/servlet/jakarta/build.gradle
@@ -0,0 +1,153 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+}
+
+description = "gRPC: Jakarta Servlet"
+
+// Set up classpaths and source directories for different servlet tests
+sourceSets {
+
+    // Only run these tests if the required minimum Java version is being used
+    if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17)) {
+        jettyTest {
+            java {
+                include '**/Jetty*.java'
+            }
+        }
+    }
+    if (JavaVersion.current().isJava11Compatible()) {
+        tomcatTest {
+            java {
+                include '**/Tomcat*.java'
+            }
+        }
+        undertowTest {
+            java {
+                include '**/Undertow*.java'
+            }
+        }
+    }
+}
+
+configurations {
+    itImplementation.extendsFrom(implementation)
+    jettyTestImplementation.extendsFrom(itImplementation)
+    tomcatTestImplementation.extendsFrom(itImplementation)
+    undertowTestImplementation.extendsFrom(itImplementation)
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+// Mechanically transform sources from grpc-servlet to use the corrected packages
+def migrate(String name, String inputDir, SourceSet sourceSet) {
+    def outputDir = layout.buildDirectory.dir('generated/sources/jakarta-' + name)
+    sourceSet.java.srcDir tasks.register('migrateSources' + name.capitalize(), Sync) { task ->
+        into(outputDir)
+	// Increment when changing the filter, to inform Gradle it needs to rebuild
+	inputs.property("filter-version", "1")
+        from("$inputDir/io/grpc/servlet") {
+            into('io/grpc/servlet/jakarta')
+            filter { String line ->
+                line.replace('javax.servlet', 'jakarta.servlet')
+                    .replace('io.grpc.servlet', 'io.grpc.servlet.jakarta')
+                    .replace('org.eclipse.jetty.http2.parser', 'org.eclipse.jetty.http2')
+                    .replace('org.eclipse.jetty.servlet', 'org.eclipse.jetty.ee10.servlet')
+            }
+        }
+    }
+}
+
+migrate('main', '../src/main/java', sourceSets.main)
+
+// Only build sourceSets and classpaths for tests if using the required minimum Java version
+if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17)) {
+    migrate('jettyTest', '../src/jettyTest/java', sourceSets.jettyTest)
+}
+if (JavaVersion.current().isJava11Compatible()) {
+    migrate('tomcatTest', '../src/tomcatTest/java', sourceSets.tomcatTest)
+    migrate('undertowTest', '../src/undertowTest/java', sourceSets.undertowTest)
+}
+
+// Disable checkstyle for this project, since it consists only of generated code
+tasks.withType(Checkstyle).configureEach {
+    enabled = false
+}
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.servlet.jakarta')
+    }
+}
+
+dependencies {
+    api project(':grpc-api')
+    compileOnly libraries.jakarta.servlet.api
+
+    implementation project(':grpc-util'),
+            project(':grpc-core'),
+            libraries.guava
+
+    itImplementation project(':grpc-servlet-jakarta'),
+            project(':grpc-netty'),
+            testFixtures(project(':grpc-core')),
+            libraries.junit
+    itImplementation(project(':grpc-interop-testing')) {
+        // Avoid grpc-netty-shaded dependency
+        exclude group: 'io.grpc', module: 'grpc-alts'
+        exclude group: 'io.grpc', module: 'grpc-xds'
+    }
+
+    tomcatTestImplementation libraries.tomcat.embed.core
+
+    jettyTestImplementation libraries.jetty.servlet,
+            libraries.jetty.http2.server
+
+    undertowTestImplementation libraries.undertow.servlet
+}
+
+// Set up individual classpaths for each test, to avoid any mismatch,
+// and ensure they are only used when supported by the current jvm
+if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17)) {
+    def jetty11Test = tasks.register('jetty11Test', Test) {
+        classpath = sourceSets.jettyTest.runtimeClasspath
+        testClassesDirs = sourceSets.jettyTest.output.classesDirs
+    }
+    tasks.named('compileJettyTestJava') { JavaCompile task ->
+        task.options.release.set 9
+    }
+    tasks.named("check").configure {
+        dependsOn jetty11Test
+    }
+}
+if (JavaVersion.current().isJava11Compatible()) {
+    def tomcat10Test = tasks.register('tomcat10Test', Test) {
+        classpath = sourceSets.tomcatTest.runtimeClasspath
+        testClassesDirs = sourceSets.tomcatTest.output.classesDirs
+
+        // Provide a temporary directory for tomcat to be deleted after test finishes
+        def tomcatTempDir = "$buildDir/tomcat_catalina_base"
+        systemProperty 'catalina.base', tomcatTempDir
+        doLast {
+            file(tomcatTempDir).deleteDir()
+        }
+    }
+    tasks.named('compileTomcatTestJava') { JavaCompile task ->
+        task.options.release.set 11
+    }
+
+    def undertowTest = tasks.register('undertowTest', Test) {
+        classpath = sourceSets.undertowTest.runtimeClasspath
+        testClassesDirs = sourceSets.undertowTest.output.classesDirs
+    }
+    tasks.named('compileUndertowTestJava') { JavaCompile task ->
+        task.options.release.set 11
+    }
+
+    tasks.named("check").configure {
+        dependsOn tomcat10Test, undertowTest
+    }
+}
diff --git a/servlet/src/jettyTest/java/io/grpc/servlet/GrpcServletSmokeTest.java b/servlet/src/jettyTest/java/io/grpc/servlet/GrpcServletSmokeTest.java
new file mode 100644
index 00000000000..e1c92e31cc6
--- /dev/null
+++ b/servlet/src/jettyTest/java/io/grpc/servlet/GrpcServletSmokeTest.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2022 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.servlet;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.ByteString;
+import io.grpc.BindableService;
+import io.grpc.Channel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.integration.Messages.Payload;
+import io.grpc.testing.integration.Messages.SimpleRequest;
+import io.grpc.testing.integration.Messages.SimpleResponse;
+import io.grpc.testing.integration.TestServiceGrpc;
+import io.grpc.testing.integration.TestServiceImpl;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import org.eclipse.jetty.client.HttpClient;
+import org.eclipse.jetty.client.api.ContentResponse;
+import org.eclipse.jetty.http2.parser.RateControl;
+import org.eclipse.jetty.http2.server.HTTP2CServerConnectionFactory;
+import org.eclipse.jetty.server.HttpConfiguration;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.ServerConnector;
+import org.eclipse.jetty.servlet.ServletContextHandler;
+import org.eclipse.jetty.servlet.ServletHolder;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Smoke test for {@link GrpcServlet}. */
+@RunWith(JUnit4.class)
+public class GrpcServletSmokeTest {
+  private static final String HOST = "localhost";
+  private static final String MYAPP = "/grpc.testing.TestService";
+
+  @Rule
+  public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+  private final ScheduledExecutorService scheduledExecutorService =
+      Executors.newSingleThreadScheduledExecutor();
+  private int port;
+  private Server server;
+
+  @Before
+  public void startServer() {
+    BindableService service = new TestServiceImpl(scheduledExecutorService);
+    GrpcServlet grpcServlet = new GrpcServlet(ImmutableList.of(service));
+    server = new Server(0);
+    ServerConnector sc = (ServerConnector)server.getConnectors()[0];
+    HTTP2CServerConnectionFactory factory =
+        new HTTP2CServerConnectionFactory(new HttpConfiguration());
+
+    // Explicitly disable safeguards against malicious clients, as some unit tests trigger this
+    factory.setRateControlFactory(new RateControl.Factory() {});
+
+    sc.addConnectionFactory(factory);
+    ServletContextHandler context =
+        new ServletContextHandler(ServletContextHandler.SESSIONS);
+    context.setContextPath(MYAPP);
+    context.addServlet(new ServletHolder(grpcServlet), "/*");
+    server.setHandler(context);
+
+    try {
+      server.start();
+    } catch (Exception e) {
+      throw new AssertionError(e);
+    }
+
+    port = sc.getLocalPort();
+  }
+
+  @After
+  public void tearDown() {
+    scheduledExecutorService.shutdown();
+    try {
+      server.stop();
+    } catch (Exception e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  @Test
+  public void unaryCall() {
+    Channel channel = cleanupRule.register(
+        ManagedChannelBuilder.forAddress(HOST, port).usePlaintext().build());
+    SimpleResponse response = TestServiceGrpc.newBlockingStub(channel).unaryCall(
+        SimpleRequest.newBuilder()
+            .setResponseSize(1234)
+            .setPayload(Payload.newBuilder().setBody(ByteString.copyFromUtf8("hello foo")))
+            .build());
+    assertThat(response.getPayload().getBody().size()).isEqualTo(1234);
+  }
+
+  @Test
+  public void httpGetRequest() throws Exception {
+    HttpClient httpClient = new HttpClient();
+    try {
+      httpClient.start();
+      ContentResponse response =
+          httpClient.GET("http://" + HOST + ":" + port + MYAPP + "/UnaryCall");
+      assertThat(response.getStatus()).isEqualTo(405);
+      assertThat(response.getContentAsString()).contains("GET method not supported");
+    } finally {
+      httpClient.stop();
+    }
+  }
+}
diff --git a/servlet/src/jettyTest/java/io/grpc/servlet/JettyInteropTest.java b/servlet/src/jettyTest/java/io/grpc/servlet/JettyInteropTest.java
new file mode 100644
index 00000000000..9b54eb5a0d7
--- /dev/null
+++ b/servlet/src/jettyTest/java/io/grpc/servlet/JettyInteropTest.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2019 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.servlet;
+
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.ServerBuilder;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.NettyChannelBuilder;
+import io.grpc.testing.integration.AbstractInteropTest;
+import org.eclipse.jetty.http2.parser.RateControl;
+import org.eclipse.jetty.http2.server.HTTP2CServerConnectionFactory;
+import org.eclipse.jetty.server.HttpConfiguration;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.ServerConnector;
+import org.eclipse.jetty.servlet.ServletContextHandler;
+import org.eclipse.jetty.servlet.ServletHolder;
+import org.junit.After;
+
+public class JettyInteropTest extends AbstractInteropTest {
+
+  private static final String HOST = "localhost";
+  private static final String MYAPP = "/grpc.testing.TestService";
+  private int port;
+  private Server server;
+
+  @After
+  @Override
+  public void tearDown() {
+    super.tearDown();
+    try {
+      server.stop();
+    } catch (Exception e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  @Override
+  protected ServerBuilder<?> getServerBuilder() {
+    return new ServletServerBuilder().maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
+  }
+
+  @Override
+  protected void startServer(ServerBuilder<?> builer) {
+    GrpcServlet grpcServlet =
+        new GrpcServlet(((ServletServerBuilder) builer).buildServletAdapter());
+    server = new Server(0);
+    ServerConnector sc = (ServerConnector)server.getConnectors()[0];
+    HTTP2CServerConnectionFactory factory =
+            new HTTP2CServerConnectionFactory(new HttpConfiguration());
+
+    // Explicitly disable safeguards against malicious clients, as some unit tests trigger this
+    factory.setRateControlFactory(new RateControl.Factory() {});
+
+    sc.addConnectionFactory(factory);
+    ServletContextHandler context =
+        new ServletContextHandler(ServletContextHandler.SESSIONS);
+    context.setContextPath(MYAPP);
+    context.addServlet(new ServletHolder(grpcServlet), "/*");
+    server.setHandler(context);
+
+    try {
+      server.start();
+    } catch (Exception e) {
+      throw new AssertionError(e);
+    }
+
+    port = sc.getLocalPort();
+  }
+
+  @Override
+  protected ManagedChannelBuilder<?> createChannelBuilder() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forAddress(HOST, port)
+                                  .usePlaintext()
+                                  .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
+    InternalNettyChannelBuilder.setStatsEnabled(builder, false);
+    builder.intercept(createCensusStatsClientInterceptor());
+    return builder;
+  }
+}
diff --git a/servlet/src/jettyTest/java/io/grpc/servlet/JettyTransportTest.java b/servlet/src/jettyTest/java/io/grpc/servlet/JettyTransportTest.java
new file mode 100644
index 00000000000..58143a8516c
--- /dev/null
+++ b/servlet/src/jettyTest/java/io/grpc/servlet/JettyTransportTest.java
@@ -0,0 +1,274 @@
+/*
+ * Copyright 2021 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.servlet;
+
+import io.grpc.InternalChannelz;
+import io.grpc.InternalInstrumented;
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.AbstractTransportTest;
+import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ManagedClientTransport;
+import io.grpc.internal.ServerListener;
+import io.grpc.internal.ServerTransportListener;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.NegotiationType;
+import io.grpc.netty.NettyChannelBuilder;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import org.eclipse.jetty.http2.parser.RateControl;
+import org.eclipse.jetty.http2.server.HTTP2CServerConnectionFactory;
+import org.eclipse.jetty.server.HttpConfiguration;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.ServerConnector;
+import org.eclipse.jetty.servlet.ServletContextHandler;
+import org.eclipse.jetty.servlet.ServletHolder;
+import org.junit.Ignore;
+import org.junit.Test;
+
+
+public class JettyTransportTest extends AbstractTransportTest {
+  private static final String MYAPP = "/service";
+
+  private final FakeClock fakeClock = new FakeClock();
+  private Server jettyServer;
+  private int port;
+
+
+  @Override
+  protected InternalServer newServer(List<ServerStreamTracer.Factory> streamTracerFactories) {
+    return new InternalServer() {
+      final InternalServer delegate =
+              new ServletServerBuilder().buildTransportServers(streamTracerFactories);
+
+      @Override
+      public void start(ServerListener listener) throws IOException {
+        delegate.start(listener);
+        ScheduledExecutorService scheduler = fakeClock.getScheduledExecutorService();
+        ServerTransportListener serverTransportListener =
+                listener.transportCreated(new ServletServerBuilder.ServerTransportImpl(scheduler));
+        ServletAdapter adapter =
+                new ServletAdapter(serverTransportListener, streamTracerFactories,
+                        ServletAdapter.DEFAULT_METHOD_NAME_RESOLVER,
+                        Integer.MAX_VALUE);
+        GrpcServlet grpcServlet = new GrpcServlet(adapter);
+
+        jettyServer = new Server(0);
+        ServerConnector sc = (ServerConnector) jettyServer.getConnectors()[0];
+        HttpConfiguration httpConfiguration = new HttpConfiguration();
+
+        setDelayDispatchUntilContent(httpConfiguration);
+
+        HTTP2CServerConnectionFactory factory =
+                new HTTP2CServerConnectionFactory(httpConfiguration);
+        factory.setRateControlFactory(new RateControl.Factory() {
+        });
+        sc.addConnectionFactory(factory);
+        ServletContextHandler context =
+                new ServletContextHandler(ServletContextHandler.SESSIONS);
+        context.setContextPath(MYAPP);
+        context.addServlet(new ServletHolder(grpcServlet), "/*");
+        jettyServer.setHandler(context);
+
+        try {
+          jettyServer.start();
+        } catch (Exception e) {
+          throw new AssertionError(e);
+        }
+
+        port = sc.getLocalPort();
+      }
+
+      @Override
+      public void shutdown() {
+        delegate.shutdown();
+      }
+
+      @Override
+      public SocketAddress getListenSocketAddress() {
+        return delegate.getListenSocketAddress();
+      }
+
+      @Override
+      public InternalInstrumented<InternalChannelz.SocketStats> getListenSocketStats() {
+        return delegate.getListenSocketStats();
+      }
+
+      @Override
+      public List<? extends SocketAddress> getListenSocketAddresses() {
+        return delegate.getListenSocketAddresses();
+      }
+
+      @Nullable
+      @Override
+      public List<InternalInstrumented<InternalChannelz.SocketStats>> getListenSocketStatsList() {
+        return delegate.getListenSocketStatsList();
+      }
+    };
+  }
+
+  @Override
+  protected InternalServer newServer(int port,
+                                     List<ServerStreamTracer.Factory> streamTracerFactories) {
+    return newServer(streamTracerFactories);
+  }
+
+  // The future default appears to be false as people are supposed to be migrate to
+  // EagerContentHandler, but the default is still true. Seems they messed up the migration
+  // process here by not flipping the default.
+  @SuppressWarnings("removal")
+  private static void setDelayDispatchUntilContent(HttpConfiguration httpConfiguration) {
+    // Must be set for several tests to pass, so that the request handling can begin before
+    // content arrives.
+    httpConfiguration.setDelayDispatchUntilContent(false);
+  }
+
+  @Override
+  protected ManagedClientTransport newClientTransport(InternalServer server) {
+    NettyChannelBuilder nettyChannelBuilder = NettyChannelBuilder
+            // Although specified here, address is ignored because we never call build.
+            .forAddress("localhost", 0)
+            .flowControlWindow(65 * 1024)
+            .negotiationType(NegotiationType.PLAINTEXT);
+    InternalNettyChannelBuilder
+            .setTransportTracerFactory(nettyChannelBuilder, fakeClockTransportTracer);
+    ClientTransportFactory clientFactory =
+            InternalNettyChannelBuilder.buildTransportFactory(nettyChannelBuilder);
+    return clientFactory.newClientTransport(
+            new InetSocketAddress("localhost", port),
+            new ClientTransportFactory.ClientTransportOptions()
+                    .setAuthority(testAuthority(server))
+                    .setEagAttributes(eagAttrs()),
+            transportLogger());
+  }
+
+  @Override
+  protected String testAuthority(InternalServer server) {
+    return "localhost:" + port;
+  }
+
+  @Override
+  protected void advanceClock(long offset, TimeUnit unit) {
+    fakeClock.forwardTime(offset, unit);
+  }
+
+  @Override
+  protected long fakeCurrentTimeNanos() {
+    return fakeClock.getTicker().read();
+  }
+
+  @Override
+  @Ignore("Skip the test, server lifecycle is managed by the container")
+  @Test
+  public void serverAlreadyListening() {
+  }
+
+  @Override
+  @Ignore("Skip the test, server lifecycle is managed by the container")
+  @Test
+  public void openStreamPreventsTermination() {
+  }
+
+  @Override
+  @Ignore("Skip the test, server lifecycle is managed by the container")
+  @Test
+  public void shutdownNowKillsServerStream() {
+  }
+
+  @Override
+  @Ignore("Skip the test, server lifecycle is managed by the container")
+  @Test
+  public void serverNotListening() {
+  }
+
+  // FIXME
+  @Override
+  @Ignore("Servlet flow control not implemented yet")
+  @Test
+  public void flowControlPushBack() {
+  }
+
+  @Override
+  @Ignore("Servlet flow control not implemented yet")
+  @Test
+  public void flowControlDoesNotDeadlockLargeMessage() {
+  }
+
+  // FIXME
+  @Override
+  @Ignore("Jetty is broken on client RST_STREAM")
+  @Test
+  public void shutdownNowKillsClientStream() {
+  }
+
+  @Override
+  @Ignore("Server side sockets are managed by the servlet container")
+  @Test
+  public void socketStats() {
+  }
+
+  @Override
+  @Ignore("serverTransportListener will not terminate")
+  @Test
+  public void clientStartAndStopOnceConnected() {
+  }
+
+  @Override
+  @Ignore("clientStreamTracer1.getInboundTrailers() is not null; listeners.poll() doesn't apply")
+  @Test
+  public void serverCancel() {
+  }
+
+  @Override
+  @Ignore("This doesn't apply: Ensure that for a closed ServerStream, interactions are noops")
+  @Test
+  public void interactionsAfterServerStreamCloseAreNoops() {
+  }
+
+  @Override
+  @Ignore("listeners.poll() doesn't apply")
+  @Test
+  public void interactionsAfterClientStreamCancelAreNoops() {
+  }
+
+  @Override
+  @Ignore("assertNull(serverStatus.getCause()) isn't true")
+  @Test
+  public void clientCancel() {
+  }
+
+  @Override
+  @Ignore("regression since bumping grpc v1.46 to v1.53")
+  @Test
+  public void messageProducerOnlyProducesRequestedMessages() {}
+
+  @Override
+  @Ignore("https://github.com/jetty/jetty.project/issues/11822")
+  @Test
+  public void clientChecksInboundMetadataSize_header() {}
+
+  @Override
+  @Ignore("https://github.com/jetty/jetty.project/issues/11822")
+  @Test
+  public void clientChecksInboundMetadataSize_trailer() {}
+}
diff --git a/servlet/src/main/java/io/grpc/servlet/AsyncServletOutputStreamWriter.java b/servlet/src/main/java/io/grpc/servlet/AsyncServletOutputStreamWriter.java
new file mode 100644
index 00000000000..3c8d3d07571
--- /dev/null
+++ b/servlet/src/main/java/io/grpc/servlet/AsyncServletOutputStreamWriter.java
@@ -0,0 +1,296 @@
+/*
+ * Copyright 2019 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.servlet;
+
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.servlet.ServletServerStream.toHexString;
+import static java.util.logging.Level.FINE;
+import static java.util.logging.Level.FINEST;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.InternalLogId;
+import io.grpc.servlet.ServletServerStream.ServletTransportState;
+import java.io.IOException;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.LockSupport;
+import java.util.function.BiFunction;
+import java.util.function.BooleanSupplier;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.servlet.AsyncContext;
+import javax.servlet.ServletOutputStream;
+
+/** Handles write actions from the container thread and the application thread. */
+final class AsyncServletOutputStreamWriter {
+
+  /**
+   * Memory boundary for write actions.
+   *
+   * <pre>
+   * WriteState curState = writeState.get();  // mark a boundary
+   * doSomething();  // do something within the boundary
+   * boolean successful = writeState.compareAndSet(curState, newState); // try to mark a boundary
+   * if (successful) {
+   *   // state has not changed since
+   *   return;
+   * } else {
+   *   // state is changed by another thread while doSomething(), need recompute
+   * }
+   * </pre>
+   *
+   * <p>There are two threads, the container thread (calling {@code onWritePossible()}) and the
+   * application thread (calling {@code runOrBuffer()}) that read and update the
+   * writeState. Only onWritePossible() may turn {@code readyAndDrained} from false to true, and
+   * only runOrBuffer() may turn it from true to false.
+   */
+  private final AtomicReference<WriteState> writeState = new AtomicReference<>(WriteState.DEFAULT);
+
+  private final Log log;
+  private final BiFunction<byte[], Integer, ActionItem> writeAction;
+  private final ActionItem flushAction;
+  private final ActionItem completeAction;
+  private final BooleanSupplier isReady;
+
+  /**
+   * New write actions will be buffered into this queue if the servlet output stream is not ready or
+   * the queue is not drained.
+   */
+  // SPSC queue would do
+  private final Queue<ActionItem> writeChain = new ConcurrentLinkedQueue<>();
+  // for a theoretical race condition that onWritePossible() is called immediately after isReady()
+  // returns false and before writeState.compareAndSet()
+  @Nullable
+  private volatile Thread parkingThread;
+
+  AsyncServletOutputStreamWriter(
+      AsyncContext asyncContext,
+      ServletTransportState transportState,
+      InternalLogId logId) throws IOException {
+    Logger logger = Logger.getLogger(AsyncServletOutputStreamWriter.class.getName());
+    this.log = new Log() {
+      @Override
+      public boolean isLoggable(Level level) {
+        return logger.isLoggable(level);
+      }
+
+      @Override
+      public void fine(String str, Object... params) {
+        if (logger.isLoggable(FINE)) {
+          logger.log(FINE, "[" + logId + "]" + str, params);
+        }
+      }
+
+      @Override
+      public void finest(String str, Object... params) {
+        if (logger.isLoggable(FINEST)) {
+          logger.log(FINEST, "[" + logId + "] " + str, params);
+        }
+      }
+    };
+
+    ServletOutputStream outputStream = asyncContext.getResponse().getOutputStream();
+    this.writeAction = (byte[] bytes, Integer numBytes) -> () -> {
+      outputStream.write(bytes, 0, numBytes);
+      transportState.runOnTransportThread(() -> transportState.onSentBytes(numBytes));
+      if (log.isLoggable(Level.FINEST)) {
+        log.finest("outbound data: length={0}, bytes={1}", numBytes, toHexString(bytes, numBytes));
+      }
+    };
+    this.flushAction = () -> {
+      log.finest("flushBuffer");
+      asyncContext.getResponse().flushBuffer();
+    };
+    this.completeAction = () -> {
+      log.fine("call is completing");
+      transportState.runOnTransportThread(
+          () -> {
+            transportState.complete();
+            asyncContext.complete();
+            log.fine("call completed");
+          });
+    };
+    this.isReady = outputStream::isReady;
+  }
+
+  /**
+   * Constructor without java.util.logging and javax.servlet.* dependency, so that Lincheck can run.
+   *
+   * @param writeAction Provides an {@link ActionItem} to write given bytes with specified length.
+   * @param isReady Indicates whether the writer can write bytes at the moment (asynchronously).
+   */
+  @VisibleForTesting
+  AsyncServletOutputStreamWriter(
+      BiFunction<byte[], Integer, ActionItem> writeAction,
+      ActionItem flushAction,
+      ActionItem completeAction,
+      BooleanSupplier isReady,
+      Log log) {
+    this.writeAction = writeAction;
+    this.flushAction = flushAction;
+    this.completeAction = completeAction;
+    this.isReady = isReady;
+    this.log = log;
+  }
+
+  /** Called from application thread. */
+  void writeBytes(byte[] bytes, int numBytes) throws IOException {
+    runOrBuffer(writeAction.apply(bytes, numBytes));
+  }
+
+  /** Called from application thread. */
+  void flush() throws IOException {
+    runOrBuffer(flushAction);
+  }
+
+  /** Called from application thread. */
+  void complete() {
+    try {
+      runOrBuffer(completeAction);
+    } catch (IOException ignore) {
+      // actually completeAction does not throw IOException
+    }
+  }
+
+  /** Called from the container thread {@link javax.servlet.WriteListener#onWritePossible()}. */
+  void onWritePossible() throws IOException {
+    log.finest("onWritePossible: ENTRY. The servlet output stream becomes ready");
+    if (writeState.get().readyAndDrained) {
+      assureReadyAndDrainedTurnsFalse();
+    }
+    while (isReady.getAsBoolean()) {
+      WriteState curState = writeState.get();
+
+      ActionItem actionItem = writeChain.poll();
+      if (actionItem != null) {
+        actionItem.run();
+        continue;
+      }
+
+      if (writeState.compareAndSet(curState, curState.withReadyAndDrained(true))) {
+        // state has not changed since.
+        log.finest(
+            "onWritePossible: EXIT. All data available now is sent out and the servlet output"
+                + " stream is still ready");
+        return;
+      }
+      // else, state changed by another thread (runOrBuffer()), need to drain the writeChain
+      // again
+    }
+    log.finest("onWritePossible: EXIT. The servlet output stream becomes not ready");
+  }
+
+  private void assureReadyAndDrainedTurnsFalse() {
+    // readyAndDrained should have been set to false already.
+    // Just in case due to a race condition readyAndDrained is still true at this moment and is
+    // being set to false by runOrBuffer() concurrently.
+    parkingThread = Thread.currentThread();
+    while (writeState.get().readyAndDrained) {
+      LockSupport.parkNanos(TimeUnit.MINUTES.toNanos(1)); // should return immediately
+    }
+    parkingThread = null;
+  }
+
+  /**
+   * Either execute the write action directly, or buffer the action and let the container thread
+   * drain it.
+   *
+   * <p>Called from application thread.
+   */
+  private void runOrBuffer(ActionItem actionItem) throws IOException {
+    WriteState curState = writeState.get();
+    if (curState.readyAndDrained) { // write to the outputStream directly
+      actionItem.run();
+      if (actionItem == completeAction) {
+        return;
+      }
+      if (!isReady.getAsBoolean()) {
+        boolean successful =
+            writeState.compareAndSet(curState, curState.withReadyAndDrained(false));
+        LockSupport.unpark(parkingThread);
+        checkState(successful, "Bug: curState is unexpectedly changed by another thread");
+        log.finest("the servlet output stream becomes not ready");
+      }
+    } else { // buffer to the writeChain
+      writeChain.offer(actionItem);
+      if (!writeState.compareAndSet(curState, curState.withReadyAndDrained(false))) {
+        checkState(
+            writeState.get().readyAndDrained,
+            "Bug: onWritePossible() should have changed readyAndDrained to true, but not");
+        ActionItem lastItem = writeChain.poll();
+        if (lastItem != null) {
+          checkState(lastItem == actionItem, "Bug: lastItem != actionItem");
+          runOrBuffer(lastItem);
+        }
+      } // state has not changed since
+    }
+  }
+
+  /** Write actions, e.g. writeBytes, flush, complete. */
+  @FunctionalInterface
+  @VisibleForTesting
+  interface ActionItem {
+    void run() throws IOException;
+  }
+
+  @VisibleForTesting // Lincheck test can not run with java.util.logging dependency.
+  interface Log {
+    default boolean isLoggable(Level level) {
+      return false;
+    }
+
+    default void fine(String str, Object...params) {}
+
+    default void finest(String str, Object...params) {}
+  }
+
+  private static final class WriteState {
+
+    static final WriteState DEFAULT = new WriteState(false);
+
+    /**
+     * The servlet output stream is ready and the writeChain is empty.
+     *
+     * <p>readyAndDrained turns from false to true when:
+     * {@code onWritePossible()} exits while currently there is no more data to write, but the last
+     * check of {@link javax.servlet.ServletOutputStream#isReady()} is true.
+     *
+     * <p>readyAndDrained turns from true to false when:
+     * {@code runOrBuffer()} exits while either the action item is written directly to the
+     * servlet output stream and the check of {@link javax.servlet.ServletOutputStream#isReady()}
+     * right after that returns false, or the action item is buffered into the writeChain.
+     */
+    final boolean readyAndDrained;
+
+    WriteState(boolean readyAndDrained) {
+      this.readyAndDrained = readyAndDrained;
+    }
+
+    /**
+     * Only {@code onWritePossible()} can set readyAndDrained to true, and only {@code
+     * runOrBuffer()} can set it to false.
+     */
+    @CheckReturnValue
+    WriteState withReadyAndDrained(boolean readyAndDrained) {
+      return new WriteState(readyAndDrained);
+    }
+  }
+}
diff --git a/servlet/src/main/java/io/grpc/servlet/GrpcServlet.java b/servlet/src/main/java/io/grpc/servlet/GrpcServlet.java
new file mode 100644
index 00000000000..8c1eb858ad1
--- /dev/null
+++ b/servlet/src/main/java/io/grpc/servlet/GrpcServlet.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2018 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.servlet;
+
+import io.grpc.BindableService;
+import io.grpc.ExperimentalApi;
+import java.io.IOException;
+import java.util.List;
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * A simple servlet backed by a gRPC server. Must set {@code asyncSupported} to true. The {@code
+ * /contextRoot/urlPattern} must match the gRPC services' path, which is
+ * "/full-service-name/short-method-name".
+ *
+ * <p>The API is experimental. The authors would like to know more about the real usecases. Users
+ * are welcome to provide feedback by commenting on
+ * <a href=https://github.com/grpc/grpc-java/issues/5066>the tracking issue</a>.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/5066")
+public class GrpcServlet extends HttpServlet {
+  private static final long serialVersionUID = 1L;
+
+  @SuppressWarnings("serial")
+  private final ServletAdapter servletAdapter;
+
+  GrpcServlet(ServletAdapter servletAdapter) {
+    this.servletAdapter = servletAdapter;
+  }
+
+  /**
+   * Instantiate the servlet serving the given list of gRPC services. ServerInterceptors can be
+   * added on each gRPC service by {@link
+   * io.grpc.ServerInterceptors#intercept(BindableService, io.grpc.ServerInterceptor...)}
+   */
+  public GrpcServlet(List<? extends BindableService> bindableServices) {
+    this(loadServices(bindableServices));
+  }
+
+  private static ServletAdapter loadServices(List<? extends BindableService> bindableServices) {
+    ServletServerBuilder serverBuilder = new ServletServerBuilder();
+    bindableServices.forEach(serverBuilder::addService);
+    return serverBuilder.buildServletAdapter();
+  }
+
+  @Override
+  protected final void doGet(HttpServletRequest request, HttpServletResponse response)
+      throws IOException {
+    servletAdapter.doGet(request, response);
+  }
+
+  @Override
+  protected final void doPost(HttpServletRequest request, HttpServletResponse response)
+      throws IOException {
+    servletAdapter.doPost(request, response);
+  }
+
+  @Override
+  public void destroy() {
+    servletAdapter.destroy();
+    super.destroy();
+  }
+}
diff --git a/servlet/src/main/java/io/grpc/servlet/ServletAdapter.java b/servlet/src/main/java/io/grpc/servlet/ServletAdapter.java
new file mode 100644
index 00000000000..668e82425cb
--- /dev/null
+++ b/servlet/src/main/java/io/grpc/servlet/ServletAdapter.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright 2018 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.servlet;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.internal.GrpcUtil.TIMEOUT_KEY;
+import static java.util.logging.Level.FINE;
+import static java.util.logging.Level.FINEST;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.io.BaseEncoding;
+import io.grpc.Attributes;
+import io.grpc.ExperimentalApi;
+import io.grpc.Grpc;
+import io.grpc.InternalLogId;
+import io.grpc.InternalMetadata;
+import io.grpc.Metadata;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.ReadableBuffers;
+import io.grpc.internal.ServerTransportListener;
+import io.grpc.internal.StatsTraceContext;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
+import java.util.logging.Logger;
+import javax.servlet.AsyncContext;
+import javax.servlet.AsyncEvent;
+import javax.servlet.AsyncListener;
+import javax.servlet.ReadListener;
+import javax.servlet.ServletInputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * An adapter that transforms {@link HttpServletRequest} into gRPC request and lets a gRPC server
+ * process it, and transforms the gRPC response into {@link HttpServletResponse}. An adapter can be
+ * instantiated by {@link ServletServerBuilder#buildServletAdapter()}.
+ *
+ * <p>In a servlet, calling {@link #doPost(HttpServletRequest, HttpServletResponse)} inside {@link
+ * javax.servlet.http.HttpServlet#doPost(HttpServletRequest, HttpServletResponse)} makes the servlet
+ * backed by the gRPC server associated with the adapter. The servlet must support Asynchronous
+ * Processing and must be deployed to a container that supports servlet 4.0 and enables HTTP/2.
+ *
+ * <p>The API is experimental. The authors would like to know more about the real usecases. Users
+ * are welcome to provide feedback by commenting on
+ * <a href=https://github.com/grpc/grpc-java/issues/5066>the tracking issue</a>.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/5066")
+public final class ServletAdapter {
+
+  static final Logger logger = Logger.getLogger(ServletAdapter.class.getName());
+  static final Function<HttpServletRequest, String> DEFAULT_METHOD_NAME_RESOLVER =
+          req -> req.getRequestURI().substring(1); // remove the leading "/"
+
+  private final ServerTransportListener transportListener;
+  private final List<? extends ServerStreamTracer.Factory> streamTracerFactories;
+  private final Function<HttpServletRequest, String> methodNameResolver;
+  private final int maxInboundMessageSize;
+  private final Attributes attributes;
+
+  ServletAdapter(
+      ServerTransportListener transportListener,
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories,
+      Function<HttpServletRequest, String> methodNameResolver,
+      int maxInboundMessageSize) {
+    this.transportListener = transportListener;
+    this.streamTracerFactories = streamTracerFactories;
+    this.methodNameResolver = methodNameResolver;
+    this.maxInboundMessageSize = maxInboundMessageSize;
+    attributes = transportListener.transportReady(Attributes.EMPTY);
+  }
+
+  /**
+   * Call this method inside {@link javax.servlet.http.HttpServlet#doGet(HttpServletRequest,
+   * HttpServletResponse)} to serve gRPC GET request.
+   *
+   * <p>This method is currently not implemented.
+   *
+   * <p>Note that in rare case gRPC client sends GET requests.
+   *
+   * <p>Do not modify {@code req} and {@code resp} before or after calling this method. However,
+   * calling {@code resp.setBufferSize()} before invocation is allowed.
+   */
+  public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+    resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "GET method not supported");
+  }
+
+  /**
+   * Call this method inside {@link javax.servlet.http.HttpServlet#doPost(HttpServletRequest,
+   * HttpServletResponse)} to serve gRPC POST request.
+   *
+   * <p>Do not modify {@code req} and {@code resp} before or after calling this method. However,
+   * calling {@code resp.setBufferSize()} before invocation is allowed.
+   */
+  public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
+    checkArgument(req.isAsyncSupported(), "servlet does not support asynchronous operation");
+    checkArgument(ServletAdapter.isGrpc(req), "the request is not a gRPC request");
+
+    InternalLogId logId = InternalLogId.allocate(ServletAdapter.class, null);
+    logger.log(FINE, "[{0}] RPC started", logId);
+
+    AsyncContext asyncCtx = req.startAsync(req, resp);
+
+    String method = methodNameResolver.apply(req);
+    Metadata headers = getHeaders(req);
+
+    if (logger.isLoggable(FINEST)) {
+      logger.log(FINEST, "[{0}] method: {1}", new Object[] {logId, method});
+      logger.log(FINEST, "[{0}] headers: {1}", new Object[] {logId, headers});
+    }
+
+    Long timeoutNanos = headers.get(TIMEOUT_KEY);
+    asyncCtx.setTimeout(timeoutNanos != null
+        ? TimeUnit.NANOSECONDS.toMillis(timeoutNanos) + ASYNC_TIMEOUT_SAFETY_MARGIN
+        : 0);
+    StatsTraceContext statsTraceCtx =
+        StatsTraceContext.newServerContext(streamTracerFactories, method, headers);
+
+    ServletServerStream stream = new ServletServerStream(
+        asyncCtx,
+        statsTraceCtx,
+        maxInboundMessageSize,
+        attributes.toBuilder()
+            .set(
+                Grpc.TRANSPORT_ATTR_REMOTE_ADDR,
+                new InetSocketAddress(req.getRemoteHost(), req.getRemotePort()))
+            .set(
+                Grpc.TRANSPORT_ATTR_LOCAL_ADDR,
+                new InetSocketAddress(req.getLocalAddr(), req.getLocalPort()))
+            .build(),
+        getAuthority(req),
+        logId);
+
+    transportListener.streamCreated(stream, method, headers);
+    stream.transportState().runOnTransportThread(stream.transportState()::onStreamAllocated);
+
+    asyncCtx.getRequest().getInputStream()
+        .setReadListener(new GrpcReadListener(stream, asyncCtx, logId));
+    asyncCtx.addListener(new GrpcAsyncListener(stream, logId));
+  }
+
+  /**
+   * Deadlines are managed via Context, servlet async timeout is not supposed to happen.
+   */
+  @VisibleForTesting
+  static final long ASYNC_TIMEOUT_SAFETY_MARGIN = 5_000;
+
+  // This method must use Enumeration and its members, since that is the only way to read headers
+  // from the servlet api.
+  @SuppressWarnings("JdkObsolete")
+  private static Metadata getHeaders(HttpServletRequest req) {
+    Enumeration<String> headerNames = req.getHeaderNames();
+    checkNotNull(
+        headerNames, "Servlet container does not allow HttpServletRequest.getHeaderNames()");
+    List<byte[]> byteArrays = new ArrayList<>();
+    while (headerNames.hasMoreElements()) {
+      String headerName = headerNames.nextElement();
+      Enumeration<String> values = req.getHeaders(headerName);
+      if (values == null) {
+        continue;
+      }
+      while (values.hasMoreElements()) {
+        String value = values.nextElement();
+        if (headerName.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
+          byteArrays.add(headerName.getBytes(StandardCharsets.US_ASCII));
+          byteArrays.add(BaseEncoding.base64().decode(value));
+        } else {
+          byteArrays.add(headerName.getBytes(StandardCharsets.US_ASCII));
+          byteArrays.add(value.getBytes(StandardCharsets.US_ASCII));
+        }
+      }
+    }
+    return InternalMetadata.newMetadata(byteArrays.toArray(new byte[][]{}));
+  }
+
+  // This method must use HttpRequest#getRequestURL or HttpUtils#getRequestURL, both of which
+  // can only return StringBuffer instances
+  @SuppressWarnings("JdkObsolete")
+  private static String getAuthority(HttpServletRequest req) {
+    try {
+      return new URI(req.getRequestURL().toString()).getAuthority();
+    } catch (URISyntaxException e) {
+      logger.log(FINE, "Error getting authority from the request URL {0}", req.getRequestURL());
+      return req.getServerName() + ":" + req.getServerPort();
+    }
+  }
+
+  /**
+   * Call this method when the adapter is no longer needed. The gRPC server will be terminated.
+   */
+  public void destroy() {
+    transportListener.transportTerminated();
+  }
+
+  private static final class GrpcAsyncListener implements AsyncListener {
+    final InternalLogId logId;
+    final ServletServerStream stream;
+
+    GrpcAsyncListener(ServletServerStream stream, InternalLogId logId) {
+      this.stream = stream;
+      this.logId = logId;
+    }
+
+    @Override
+    public void onComplete(AsyncEvent event) {
+      stream.asyncCompleted = true;
+    }
+
+    @Override
+    public void onTimeout(AsyncEvent event) {
+      if (logger.isLoggable(FINE)) {
+        logger.log(FINE, String.format("[{%s}] Timeout: ", logId), event.getThrowable());
+      }
+      // If the resp is not committed, cancel() to avoid being redirected to an error page.
+      // Else, the container will send RST_STREAM in the end.
+      if (!event.getAsyncContext().getResponse().isCommitted()) {
+        stream.cancel(Status.DEADLINE_EXCEEDED);
+      } else {
+        stream.transportState().runOnTransportThread(
+            () -> stream.transportState().transportReportStatus(Status.DEADLINE_EXCEEDED));
+      }
+    }
+
+    @Override
+    public void onError(AsyncEvent event) {
+      if (logger.isLoggable(FINE)) {
+        logger.log(FINE, String.format("[{%s}] Error: ", logId), event.getThrowable());
+      }
+
+      // If the resp is not committed, cancel() to avoid being redirected to an error page.
+      // Else, the container will send RST_STREAM at the end.
+      if (!event.getAsyncContext().getResponse().isCommitted()) {
+        stream.cancel(Status.fromThrowable(event.getThrowable()));
+      } else {
+        stream.transportState().runOnTransportThread(
+            () -> stream.transportState().transportReportStatus(
+                Status.fromThrowable(event.getThrowable())));
+      }
+    }
+
+    @Override
+    public void onStartAsync(AsyncEvent event) {}
+  }
+
+  private static final class GrpcReadListener implements ReadListener {
+    final ServletServerStream stream;
+    final AsyncContext asyncCtx;
+    final ServletInputStream input;
+    final InternalLogId logId;
+
+    GrpcReadListener(
+        ServletServerStream stream,
+        AsyncContext asyncCtx,
+        InternalLogId logId) throws IOException {
+      this.stream = stream;
+      this.asyncCtx = asyncCtx;
+      input = asyncCtx.getRequest().getInputStream();
+      this.logId = logId;
+    }
+
+    final byte[] buffer = new byte[4 * 1024];
+
+    @Override
+    public void onDataAvailable() throws IOException {
+      logger.log(FINEST, "[{0}] onDataAvailable: ENTRY", logId);
+
+      while (input.isReady()) {
+        int length = input.read(buffer);
+        if (length == -1) {
+          logger.log(FINEST, "[{0}] inbound data: read end of stream", logId);
+          return;
+        } else {
+          if (logger.isLoggable(FINEST)) {
+            logger.log(
+                FINEST,
+                "[{0}] inbound data: length = {1}, bytes = {2}",
+                new Object[] {logId, length, ServletServerStream.toHexString(buffer, length)});
+          }
+
+          byte[] copy = Arrays.copyOf(buffer, length);
+          stream.transportState().runOnTransportThread(
+              () -> stream.transportState().inboundDataReceived(ReadableBuffers.wrap(copy), false));
+        }
+      }
+
+      logger.log(FINEST, "[{0}] onDataAvailable: EXIT", logId);
+    }
+
+    @Override
+    public void onAllDataRead() {
+      logger.log(FINE, "[{0}] onAllDataRead", logId);
+      stream.transportState().runOnTransportThread(() ->
+          stream.transportState().inboundDataReceived(ReadableBuffers.empty(), true));
+    }
+
+    @Override
+    public void onError(Throwable t) {
+      if (logger.isLoggable(FINE)) {
+        logger.log(FINE, String.format("[{%s}] Error: ", logId), t);
+      }
+      // If the resp is not committed, cancel() to avoid being redirected to an error page.
+      // Else, the container will send RST_STREAM at the end.
+      if (!asyncCtx.getResponse().isCommitted()) {
+        stream.cancel(Status.fromThrowable(t));
+      } else {
+        stream.transportState().runOnTransportThread(
+            () -> stream.transportState()
+                .transportReportStatus(Status.fromThrowable(t)));
+      }
+    }
+  }
+
+  /**
+   * Checks whether an incoming {@code HttpServletRequest} may come from a gRPC client.
+   *
+   * @return true if the request comes from a gRPC client
+   */
+  public static boolean isGrpc(HttpServletRequest request) {
+    return request.getContentType() != null
+        && request.getContentType().contains(GrpcUtil.CONTENT_TYPE_GRPC);
+  }
+}
diff --git a/servlet/src/main/java/io/grpc/servlet/ServletServerBuilder.java b/servlet/src/main/java/io/grpc/servlet/ServletServerBuilder.java
new file mode 100644
index 00000000000..aee25de01ad
--- /dev/null
+++ b/servlet/src/main/java/io/grpc/servlet/ServletServerBuilder.java
@@ -0,0 +1,292 @@
+/*
+ * Copyright 2018 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.servlet;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.internal.GrpcUtil.DEFAULT_MAX_MESSAGE_SIZE;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.util.concurrent.ListenableFuture;
+import io.grpc.Attributes;
+import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingServerBuilder;
+import io.grpc.Internal;
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.InternalLogId;
+import io.grpc.Metadata;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ServerImplBuilder;
+import io.grpc.internal.ServerListener;
+import io.grpc.internal.ServerStream;
+import io.grpc.internal.ServerTransport;
+import io.grpc.internal.ServerTransportListener;
+import io.grpc.internal.SharedResourceHolder;
+import java.io.File;
+import java.io.IOException;
+import java.net.SocketAddress;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.function.Function;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.NotThreadSafe;
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * Builder to build a gRPC server that can run as a servlet. This is for advanced custom settings.
+ * Normally, users should consider extending the out-of-box {@link GrpcServlet} directly instead.
+ *
+ * <p>The API is experimental. The authors would like to know more about the real usecases. Users
+ * are welcome to provide feedback by commenting on
+ * <a href=https://github.com/grpc/grpc-java/issues/5066>the tracking issue</a>.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/5066")
+@NotThreadSafe
+public final class ServletServerBuilder extends ForwardingServerBuilder<ServletServerBuilder> {
+  List<? extends ServerStreamTracer.Factory> streamTracerFactories;
+  private Function<HttpServletRequest, String> methodNameResolver =
+      ServletAdapter.DEFAULT_METHOD_NAME_RESOLVER;
+  int maxInboundMessageSize = DEFAULT_MAX_MESSAGE_SIZE;
+
+  private final ServerImplBuilder serverImplBuilder;
+
+  private ScheduledExecutorService scheduler;
+  private boolean internalCaller;
+  private boolean usingCustomScheduler;
+  private InternalServerImpl internalServer;
+
+  public ServletServerBuilder() {
+    serverImplBuilder = new ServerImplBuilder(this::buildTransportServers);
+  }
+
+  /**
+   * Builds a gRPC server that can run as a servlet.
+   *
+   * <p>The returned server will not be started or bound to a port.
+   *
+   * <p>Users should not call this method directly. Instead users should call
+   * {@link #buildServletAdapter()} which internally will call {@code build()} and {@code start()}
+   * appropriately.
+   *
+   * @throws IllegalStateException if this method is called by users directly
+   */
+  @Override
+  public Server build() {
+    checkState(internalCaller, "build() method should not be called directly by an application");
+    return super.build();
+  }
+
+  /**
+   * Creates a {@link ServletAdapter}.
+   */
+  public ServletAdapter buildServletAdapter() {
+    return new ServletAdapter(buildAndStart(), streamTracerFactories, methodNameResolver,
+        maxInboundMessageSize);
+  }
+
+  /**
+   * Creates a {@link GrpcServlet}.
+   */
+  public GrpcServlet buildServlet() {
+    return new GrpcServlet(buildServletAdapter());
+  }
+
+  private ServerTransportListener buildAndStart() {
+    Server server;
+    try {
+      internalCaller = true;
+      server = build().start();
+    } catch (IOException e) {
+      // actually this should never happen
+      throw new RuntimeException(e);
+    } finally {
+      internalCaller = false;
+    }
+
+    if (!usingCustomScheduler) {
+      scheduler = SharedResourceHolder.get(GrpcUtil.TIMER_SERVICE);
+    }
+
+    // Create only one "transport" for all requests because it has no knowledge of which request is
+    // associated with which client socket. This "transport" does not do socket connection, the
+    // container does.
+    ServerTransportImpl serverTransport = new ServerTransportImpl(scheduler);
+    ServerTransportListener delegate =
+        internalServer.serverListener.transportCreated(serverTransport);
+    return new ServerTransportListener() {
+      @Override
+      public void streamCreated(ServerStream stream, String method, Metadata headers) {
+        delegate.streamCreated(stream, method, headers);
+      }
+
+      @Override
+      public Attributes transportReady(Attributes attributes) {
+        return delegate.transportReady(attributes);
+      }
+
+      @Override
+      public void transportTerminated() {
+        server.shutdown();
+        delegate.transportTerminated();
+        if (!usingCustomScheduler) {
+          SharedResourceHolder.release(GrpcUtil.TIMER_SERVICE, scheduler);
+        }
+      }
+    };
+  }
+
+  @VisibleForTesting
+  InternalServer buildTransportServers(
+      List<? extends ServerStreamTracer.Factory> streamTracerFactories) {
+    checkNotNull(streamTracerFactories, "streamTracerFactories");
+    this.streamTracerFactories = streamTracerFactories;
+    internalServer = new InternalServerImpl();
+    return internalServer;
+  }
+
+  @Internal
+  @Override
+  protected ServerBuilder<?> delegate() {
+    return serverImplBuilder;
+  }
+
+  /**
+   * Throws {@code UnsupportedOperationException}. TLS should be configured by the servlet
+   * container.
+   */
+  @Override
+  public ServletServerBuilder useTransportSecurity(File certChain, File privateKey) {
+    throw new UnsupportedOperationException("TLS should be configured by the servlet container");
+  }
+
+  /**
+   * Specifies how to determine gRPC method name from servlet request.
+   *
+   * <p>The default strategy is using {@link HttpServletRequest#getRequestURI()} without the leading
+   * slash.</p>
+   */
+  public ServletServerBuilder methodNameResolver(
+      Function<HttpServletRequest, String> methodResolver) {
+    this.methodNameResolver = checkNotNull(methodResolver);
+    return this;
+  }
+
+  @Override
+  public ServletServerBuilder maxInboundMessageSize(int bytes) {
+    checkArgument(bytes >= 0, "bytes must be >= 0");
+    maxInboundMessageSize = bytes;
+    return this;
+  }
+
+  /**
+   * Provides a custom scheduled executor service to the server builder.
+   *
+   * @return this
+   */
+  public ServletServerBuilder scheduledExecutorService(ScheduledExecutorService scheduler) {
+    this.scheduler = checkNotNull(scheduler, "scheduler");
+    usingCustomScheduler = true;
+    return this;
+  }
+
+  private static final class InternalServerImpl implements InternalServer {
+
+    ServerListener serverListener;
+
+    InternalServerImpl() {}
+
+    @Override
+    public void start(ServerListener listener) {
+      serverListener = listener;
+    }
+
+    @Override
+    public void shutdown() {
+      if (serverListener != null) {
+        serverListener.serverShutdown();
+      }
+    }
+
+    @Override
+    public SocketAddress getListenSocketAddress() {
+      return new SocketAddress() {
+        @Override
+        public String toString() {
+          return "ServletServer";
+        }
+      };
+    }
+
+    @Override
+    public InternalInstrumented<SocketStats> getListenSocketStats() {
+      // sockets are managed by the servlet container, grpc is ignorant of that
+      return null;
+    }
+
+    @Override
+    public List<? extends SocketAddress> getListenSocketAddresses() {
+      return Collections.emptyList();
+    }
+
+    @Nullable
+    @Override
+    public List<InternalInstrumented<SocketStats>> getListenSocketStatsList() {
+      return null;
+    }
+  }
+
+  @VisibleForTesting
+  static final class ServerTransportImpl implements ServerTransport {
+
+    private final InternalLogId logId = InternalLogId.allocate(ServerTransportImpl.class, null);
+    private final ScheduledExecutorService scheduler;
+
+    ServerTransportImpl(ScheduledExecutorService scheduler) {
+      this.scheduler = checkNotNull(scheduler, "scheduler");
+    }
+
+    @Override
+    public void shutdown() {}
+
+    @Override
+    public void shutdownNow(Status reason) {}
+
+    @Override
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return scheduler;
+    }
+
+    @Override
+    public ListenableFuture<SocketStats> getStats() {
+      // does not support instrumentation
+      return null;
+    }
+
+    @Override
+    public InternalLogId getLogId() {
+      return logId;
+    }
+  }
+}
diff --git a/servlet/src/main/java/io/grpc/servlet/ServletServerStream.java b/servlet/src/main/java/io/grpc/servlet/ServletServerStream.java
new file mode 100644
index 00000000000..0182f302698
--- /dev/null
+++ b/servlet/src/main/java/io/grpc/servlet/ServletServerStream.java
@@ -0,0 +1,327 @@
+/*
+ * Copyright 2018 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.servlet;
+
+import static io.grpc.internal.GrpcUtil.CONTENT_TYPE_GRPC;
+import static io.grpc.internal.GrpcUtil.CONTENT_TYPE_KEY;
+import static java.lang.Math.max;
+import static java.lang.Math.min;
+import static java.util.logging.Level.FINE;
+import static java.util.logging.Level.FINEST;
+import static java.util.logging.Level.WARNING;
+
+import com.google.common.io.BaseEncoding;
+import com.google.common.util.concurrent.MoreExecutors;
+import io.grpc.Attributes;
+import io.grpc.InternalLogId;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.internal.AbstractServerStream;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.SerializingExecutor;
+import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.TransportFrameUtil;
+import io.grpc.internal.TransportTracer;
+import io.grpc.internal.WritableBuffer;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BiConsumer;
+import java.util.function.Supplier;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.servlet.AsyncContext;
+import javax.servlet.WriteListener;
+import javax.servlet.http.HttpServletResponse;
+
+final class ServletServerStream extends AbstractServerStream {
+
+  private static final Logger logger = Logger.getLogger(ServletServerStream.class.getName());
+
+  private final ServletTransportState transportState;
+  private final Sink sink = new Sink();
+  private final HttpServletResponse resp;
+  private final Attributes attributes;
+  private final String authority;
+  private final InternalLogId logId;
+  private final AsyncServletOutputStreamWriter writer;
+  /**
+   * If the async servlet operation has been completed.
+   */
+  volatile boolean asyncCompleted = false;
+
+  ServletServerStream(
+      AsyncContext asyncCtx,
+      StatsTraceContext statsTraceCtx,
+      int maxInboundMessageSize,
+      Attributes attributes,
+      String authority,
+      InternalLogId logId) throws IOException {
+    super(ByteArrayWritableBuffer::new, statsTraceCtx);
+    transportState =
+        new ServletTransportState(maxInboundMessageSize, statsTraceCtx, new TransportTracer());
+    this.attributes = attributes;
+    this.authority = authority;
+    this.logId = logId;
+    this.resp = (HttpServletResponse) asyncCtx.getResponse();
+    this.writer = new AsyncServletOutputStreamWriter(
+        asyncCtx, transportState, logId);
+    resp.getOutputStream().setWriteListener(new GrpcWriteListener());
+  }
+
+  @Override
+  protected ServletTransportState transportState() {
+    return transportState;
+  }
+
+  @Override
+  public Attributes getAttributes() {
+    return attributes;
+  }
+
+  @Override
+  public String getAuthority() {
+    return authority;
+  }
+
+  @Override
+  public int streamId() {
+    return -1;
+  }
+
+  @Override
+  protected Sink abstractServerStreamSink() {
+    return sink;
+  }
+
+  private void writeHeadersToServletResponse(Metadata metadata) {
+    // Discard any application supplied duplicates of the reserved headers
+    metadata.discardAll(CONTENT_TYPE_KEY);
+    metadata.discardAll(GrpcUtil.TE_HEADER);
+    metadata.discardAll(GrpcUtil.USER_AGENT_KEY);
+
+    if (logger.isLoggable(FINE)) {
+      logger.log(FINE, "[{0}] writeHeaders {1}", new Object[] {logId, metadata});
+    }
+
+    resp.setStatus(HttpServletResponse.SC_OK);
+    resp.setContentType(CONTENT_TYPE_GRPC);
+
+    serializeHeaders(metadata, resp::addHeader);
+  }
+
+  private static void serializeHeaders(Metadata metadata, BiConsumer<String, String> consumer) {
+    byte[][] serializedHeaders = TransportFrameUtil.toHttp2Headers(metadata);
+    for (int i = 0; i < serializedHeaders.length; i += 2) {
+      consumer.accept(
+          new String(serializedHeaders[i], StandardCharsets.US_ASCII),
+          new String(serializedHeaders[i + 1], StandardCharsets.US_ASCII));
+    }
+  }
+
+  final class ServletTransportState extends TransportState {
+
+    private final SerializingExecutor transportThreadExecutor =
+        new SerializingExecutor(MoreExecutors.directExecutor());
+
+    private ServletTransportState(
+        int maxMessageSize, StatsTraceContext statsTraceCtx, TransportTracer transportTracer) {
+      super(maxMessageSize, statsTraceCtx, transportTracer);
+    }
+
+    @Override
+    public void runOnTransportThread(Runnable r) {
+      transportThreadExecutor.execute(r);
+    }
+
+    @Override
+    public void bytesRead(int numBytes) {
+      // no-op
+      // no flow control yet
+    }
+
+    @Override
+    public void deframeFailed(Throwable cause) {
+      if (logger.isLoggable(WARNING)) {
+        logger.log(WARNING, String.format("[{%s}] Exception processing message", logId), cause);
+      }
+      cancel(Status.fromThrowable(cause));
+    }
+  }
+
+  private static final class ByteArrayWritableBuffer implements WritableBuffer {
+
+    private final int capacity;
+    final byte[] bytes;
+    private int index;
+
+    ByteArrayWritableBuffer(int capacityHint) {
+      this.bytes = new byte[min(1024 * 1024, capacityHint)];
+      this.capacity = bytes.length;
+    }
+
+    @Override
+    public void write(byte[] src, int srcIndex, int length) {
+      System.arraycopy(src, srcIndex, bytes, index, length);
+      index += length;
+    }
+
+    @Override
+    public void write(byte b) {
+      bytes[index++] = b;
+    }
+
+    @Override
+    public int writableBytes() {
+      return capacity - index;
+    }
+
+    @Override
+    public int readableBytes() {
+      return index;
+    }
+
+    @Override
+    public void release() {}
+  }
+
+  private final class GrpcWriteListener implements WriteListener {
+
+    @Override
+    public void onError(Throwable t) {
+      if (logger.isLoggable(FINE)) {
+        logger.log(FINE, String.format("[{%s}] Error: ", logId), t);
+      }
+
+      // If the resp is not committed, cancel() to avoid being redirected to an error page.
+      // Else, the container will send RST_STREAM at the end.
+      if (!resp.isCommitted()) {
+        cancel(Status.fromThrowable(t));
+      } else {
+        transportState.runOnTransportThread(
+            () -> transportState.transportReportStatus(Status.fromThrowable(t)));
+      }
+    }
+
+    @Override
+    public void onWritePossible() throws IOException {
+      writer.onWritePossible();
+    }
+  }
+
+  private final class Sink implements AbstractServerStream.Sink {
+    final TrailerSupplier trailerSupplier = new TrailerSupplier();
+
+    @Override
+    public void writeHeaders(Metadata headers, boolean flush) {
+      writeHeadersToServletResponse(headers);
+      resp.setTrailerFields(trailerSupplier);
+      try {
+        writer.flush();
+      } catch (IOException e) {
+        logger.log(WARNING, String.format("[{%s}] Exception when flushBuffer", logId), e);
+        cancel(Status.fromThrowable(e));
+      }
+    }
+
+    @Override
+    public void writeFrame(@Nullable WritableBuffer frame, boolean flush, int numMessages) {
+      if (frame == null && !flush) {
+        return;
+      }
+
+      if (logger.isLoggable(FINEST)) {
+        logger.log(
+            FINEST,
+            "[{0}] writeFrame: numBytes = {1}, flush = {2}, numMessages = {3}",
+            new Object[]{logId, frame == null ? 0 : frame.readableBytes(), flush, numMessages});
+      }
+
+      try {
+        if (frame != null) {
+          int numBytes = frame.readableBytes();
+          if (numBytes > 0) {
+            onSendingBytes(numBytes);
+          }
+          writer.writeBytes(((ByteArrayWritableBuffer) frame).bytes, frame.readableBytes());
+        }
+
+        if (flush) {
+          writer.flush();
+        }
+      } catch (IOException e) {
+        logger.log(WARNING, String.format("[{%s}] Exception writing message", logId), e);
+        cancel(Status.fromThrowable(e));
+      }
+    }
+
+    @Override
+    public void writeTrailers(Metadata trailers, boolean headersSent, Status status) {
+      if (logger.isLoggable(FINE)) {
+        logger.log(
+            FINE,
+            "[{0}] writeTrailers: {1}, headersSent = {2}, status = {3}",
+            new Object[] {logId, trailers, headersSent, status});
+      }
+      if (!headersSent) {
+        writeHeadersToServletResponse(trailers);
+      } else {
+        serializeHeaders(trailers,
+            (k, v) -> trailerSupplier.get().merge(k, v, (oldV, newV) -> oldV + "," + newV));
+      }
+
+      writer.complete();
+    }
+
+    @Override
+    public void cancel(Status status) {
+      transportState.runOnTransportThread(() -> transportState.transportReportStatus(status));
+      if (asyncCompleted) {
+        logger.fine("ignore cancel as already completed");
+        return;
+      }
+      // There is no way to RST_STREAM with CANCEL code, so write trailers instead
+      close(status, new Metadata());
+      // close() calls writeTrailers(), which calls AsyncContext.complete()
+    }
+  }
+
+  private static final class TrailerSupplier implements Supplier<Map<String, String>> {
+    final Map<String, String> trailers = Collections.synchronizedMap(new HashMap<>());
+
+    TrailerSupplier() {}
+
+    @Override
+    public Map<String, String> get() {
+      return trailers;
+    }
+  }
+
+  static String toHexString(byte[] bytes, int length) {
+    String hex = BaseEncoding.base16().encode(bytes, 0, min(length, 64));
+    if (length > 80) {
+      hex += "...";
+    }
+    if (length > 64) {
+      int offset = max(64, length - 16);
+      hex += BaseEncoding.base16().encode(bytes, offset, length - offset);
+    }
+    return hex;
+  }
+}
diff --git a/servlet/src/main/java/io/grpc/servlet/package-info.java b/servlet/src/main/java/io/grpc/servlet/package-info.java
new file mode 100644
index 00000000000..13d521fdde5
--- /dev/null
+++ b/servlet/src/main/java/io/grpc/servlet/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2018 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.
+ */
+
+/**
+ * API that implements gRPC server as a servlet. The API requires that the application container
+ * supports Servlet 4.0 and enables HTTP/2.
+ *
+ * <p>The API is experimental. The authors would like to know more about the real usecases. Users
+ * are welcome to provide feedback by commenting on
+ * <a href=https://github.com/grpc/grpc-java/issues/5066>the tracking issue</a>.
+ */
+@io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/5066")
+package io.grpc.servlet;
diff --git a/servlet/src/test/java/io/grpc/servlet/ServletServerBuilderTest.java b/servlet/src/test/java/io/grpc/servlet/ServletServerBuilderTest.java
new file mode 100644
index 00000000000..7a8c5b91f25
--- /dev/null
+++ b/servlet/src/test/java/io/grpc/servlet/ServletServerBuilderTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2022 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.servlet;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.verify;
+
+import java.util.Enumeration;
+import java.util.StringTokenizer;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import javax.servlet.AsyncContext;
+import javax.servlet.ServletInputStream;
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Test for {@link ServletServerBuilder}. */
+@RunWith(JUnit4.class)
+public class ServletServerBuilderTest {
+
+  @Test
+  public void scheduledExecutorService() throws Exception {
+    ScheduledExecutorService scheduler = mock(ScheduledExecutorService.class);
+    HttpServletRequest request = mock(HttpServletRequest.class);
+    HttpServletResponse response = mock(HttpServletResponse.class);
+    AsyncContext asyncContext = mock(AsyncContext.class);
+    ServletInputStream inputStream = mock(ServletInputStream.class);
+    ServletOutputStream outputStream = mock(ServletOutputStream.class);
+    ScheduledFuture<?> future = mock(ScheduledFuture.class);
+
+    doReturn(future).when(scheduler).schedule(any(Runnable.class), anyLong(), any(TimeUnit.class));
+    doReturn(true).when(request).isAsyncSupported();
+    doReturn(asyncContext).when(request).startAsync(request, response);
+    doReturn("application/grpc").when(request).getContentType();
+    doReturn("/hello/world").when(request).getRequestURI();
+    @SuppressWarnings({"JdkObsolete", "unchecked"}) // Required by servlet API signatures.
+    // StringTokenizer is actually Enumeration<String>
+    Enumeration<String> headerNames =
+        (Enumeration<String>) ((Enumeration<?>) new StringTokenizer("grpc-timeout"));
+    @SuppressWarnings({"JdkObsolete", "unchecked"})
+    Enumeration<String> headers =
+        (Enumeration<String>) ((Enumeration<?>) new StringTokenizer("1m"));
+    doReturn(headerNames).when(request).getHeaderNames();
+    doReturn(headers).when(request).getHeaders("grpc-timeout");
+    doReturn(new StringBuffer("localhost:8080")).when(request).getRequestURL();
+    doReturn(inputStream).when(request).getInputStream();
+    doReturn("1.1.1.1").when(request).getLocalAddr();
+    doReturn(8080).when(request).getLocalPort();
+    doReturn("remote").when(request).getRemoteHost();
+    doReturn(80).when(request).getRemotePort();
+    doReturn(outputStream).when(response).getOutputStream();
+    doReturn(request).when(asyncContext).getRequest();
+    doReturn(response).when(asyncContext).getResponse();
+
+    ServletServerBuilder serverBuilder =
+        new ServletServerBuilder().scheduledExecutorService(scheduler);
+    ServletAdapter servletAdapter = serverBuilder.buildServletAdapter();
+    servletAdapter.doPost(request, response);
+
+    verify(asyncContext).setTimeout(1 + ServletAdapter.ASYNC_TIMEOUT_SAFETY_MARGIN);
+
+    // The following just verifies that scheduler is populated to the transport.
+    // It doesn't matter what tasks (such as handshake timeout and request deadline) are actually
+    // scheduled.
+    verify(scheduler, timeout(5000).atLeastOnce())
+        .schedule(any(Runnable.class), anyLong(), any(TimeUnit.class));
+  }
+}
diff --git a/servlet/src/threadingTest/java/io/grpc/servlet/AsyncServletOutputStreamWriterConcurrencyTest.java b/servlet/src/threadingTest/java/io/grpc/servlet/AsyncServletOutputStreamWriterConcurrencyTest.java
new file mode 100644
index 00000000000..ebe1df8c3f3
--- /dev/null
+++ b/servlet/src/threadingTest/java/io/grpc/servlet/AsyncServletOutputStreamWriterConcurrencyTest.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2022 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.servlet;
+
+import static org.jetbrains.lincheck.datastructures.ManagedStrategyGuaranteeKt.forClasses;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import io.grpc.servlet.AsyncServletOutputStreamWriter.ActionItem;
+import io.grpc.servlet.AsyncServletOutputStreamWriter.Log;
+import java.io.IOException;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiFunction;
+import org.jetbrains.kotlinx.lincheck.strategy.managed.modelchecking.ModelCheckingCTest;
+import org.jetbrains.lincheck.datastructures.BooleanGen;
+import org.jetbrains.lincheck.datastructures.ModelCheckingOptions;
+import org.jetbrains.lincheck.datastructures.Operation;
+import org.jetbrains.lincheck.datastructures.Param;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Test concurrency correctness of {@link AsyncServletOutputStreamWriter} using model checking with
+ * Lincheck.
+ *
+ * <p>This test should only call AsyncServletOutputStreamWriter's API surface and not rely on any
+ * implementation detail such as whether it's using a lock-free approach or not.
+ *
+ * <p>The test executes two threads concurrently, one for write and flush, and the other for
+ * onWritePossible up to {@link #OPERATIONS_PER_THREAD} operations on each thread. Lincheck will
+ * test all possibly interleaves (on context switch) between the two threads, and then verify the
+ * operations are linearizable in each interleave scenario.
+ */
+@ModelCheckingCTest
+@Param(name = "keepReady", gen = BooleanGen.class)
+@RunWith(JUnit4.class)
+public class AsyncServletOutputStreamWriterConcurrencyTest {
+  private static final int OPERATIONS_PER_THREAD = 6;
+
+  private final AsyncServletOutputStreamWriter writer;
+  private final boolean[] keepReadyArray = new boolean[OPERATIONS_PER_THREAD];
+
+  private volatile boolean isReady;
+  /**
+   * The container initiates the first call shortly after {@code startAsync}.
+   */
+  private final AtomicBoolean initialOnWritePossible = new AtomicBoolean(true);
+  // when isReadyReturnedFalse, writer.onWritePossible() will be called.
+  private volatile boolean isReadyReturnedFalse;
+  private int producerIndex;
+  private int consumerIndex;
+  private int bytesWritten;
+
+  /** Public no-args constructor. */
+  public AsyncServletOutputStreamWriterConcurrencyTest() {
+    BiFunction<byte[], Integer, ActionItem> writeAction =
+        (bytes, numBytes) -> () -> {
+          assertTrue("write should only be called while isReady() is true", isReady);
+          // The byte to be written must equal to consumerIndex, otherwise execution order is wrong
+          assertEquals("write in wrong order", bytes[0], (byte) consumerIndex);
+          bytesWritten++;
+          writeOrFlush();
+        };
+
+    ActionItem flushAction = () -> {
+      assertTrue("flush must only be called while isReady() is true", isReady);
+      writeOrFlush();
+    };
+
+    writer = new AsyncServletOutputStreamWriter(
+        writeAction,
+        flushAction,
+        () -> { },
+        this::isReady,
+        new Log() {});
+  }
+
+  private void writeOrFlush() {
+    boolean keepReady = keepReadyArray[consumerIndex];
+    if (!keepReady) {
+      isReady = false;
+    }
+    consumerIndex++;
+  }
+
+  private boolean isReady() {
+    boolean copyOfIsReady = isReady;
+    if (!copyOfIsReady) {
+      assertFalse("isReady() already returned false, onWritePossible() will be invoked",
+          isReadyReturnedFalse);
+      isReadyReturnedFalse = true;
+    }
+    return copyOfIsReady;
+  }
+
+  /**
+   * Writes a single byte with value equal to {@link #producerIndex}.
+   *
+   * @param keepReady when the byte is written:
+   *                  the ServletOutputStream should remain ready if keepReady == true;
+   *                  the ServletOutputStream should become unready if keepReady == false.
+   */
+  // @com.google.errorprone.annotations.Keep
+  @Operation(nonParallelGroup = "write")
+  public void write(@Param(name = "keepReady") boolean keepReady) throws IOException {
+    keepReadyArray[producerIndex] = keepReady;
+    writer.writeBytes(new byte[]{(byte) producerIndex}, 1);
+    producerIndex++;
+  }
+
+  /**
+   * Flushes the writer.
+   *
+   * @param keepReady when flushing:
+   *                  the ServletOutputStream should remain ready if keepReady == true;
+   *                  the ServletOutputStream should become unready if keepReady == false.
+   */
+  // @com.google.errorprone.annotations.Keep // called by lincheck reflectively
+  @Operation(nonParallelGroup = "write")
+  public void flush(@Param(name = "keepReady") boolean keepReady) throws IOException {
+    keepReadyArray[producerIndex] = keepReady;
+    writer.flush();
+    producerIndex++;
+  }
+
+  /** If the writer is not ready, let it turn ready and call writer.onWritePossible(). */
+  // @com.google.errorprone.annotations.Keep // called by lincheck reflectively
+  @Operation(nonParallelGroup = "update")
+  public void maybeOnWritePossible() throws IOException {
+    if (initialOnWritePossible.compareAndSet(true, false)) {
+      isReady = true;
+      writer.onWritePossible();
+    } else if (isReadyReturnedFalse) {
+      isReadyReturnedFalse = false;
+      isReady = true;
+      writer.onWritePossible();
+    }
+  }
+
+  @Override
+  public final boolean equals(Object o) {
+    return o instanceof AsyncServletOutputStreamWriterConcurrencyTest
+        && bytesWritten == ((AsyncServletOutputStreamWriterConcurrencyTest) o).bytesWritten;
+  }
+
+  @Override
+  public int hashCode() {
+    return bytesWritten;
+  }
+
+  @Test
+  public void linCheck() {
+    ModelCheckingOptions options = new ModelCheckingOptions()
+        .actorsBefore(0)
+        .threads(2)
+        .actorsPerThread(OPERATIONS_PER_THREAD)
+        .actorsAfter(0)
+        .addGuarantee(
+            forClasses(
+                    ConcurrentLinkedQueue.class.getName(),
+                    AtomicReference.class.getName())
+                .allMethods()
+                .treatAsAtomic());
+    options.check(AsyncServletOutputStreamWriterConcurrencyTest.class);
+  }
+}
diff --git a/servlet/src/tomcatTest/java/io/grpc/servlet/TomcatInteropTest.java b/servlet/src/tomcatTest/java/io/grpc/servlet/TomcatInteropTest.java
new file mode 100644
index 00000000000..d072fea93a1
--- /dev/null
+++ b/servlet/src/tomcatTest/java/io/grpc/servlet/TomcatInteropTest.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2018 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.servlet;
+
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.ServerBuilder;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.NettyChannelBuilder;
+import io.grpc.testing.integration.AbstractInteropTest;
+import java.io.File;
+import org.apache.catalina.Context;
+import org.apache.catalina.LifecycleException;
+import org.apache.catalina.startup.Tomcat;
+import org.apache.coyote.http2.Http2Protocol;
+import org.apache.tomcat.util.http.fileupload.FileUtils;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+/**
+ * Interop test for Tomcat server and Netty client.
+ */
+public class TomcatInteropTest extends AbstractInteropTest {
+
+  private static final String HOST = "localhost";
+  private static final String MYAPP = "/grpc.testing.TestService";
+  private int port;
+  private Tomcat server;
+
+  @After
+  @Override
+  public void tearDown() {
+    super.tearDown();
+    try {
+      server.stop();
+    } catch (LifecycleException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  @AfterClass
+  public static void cleanUp() throws Exception {
+    FileUtils.deleteDirectory(new File("tomcat.0"));
+  }
+
+  @Override
+  protected ServerBuilder<?> getServerBuilder() {
+    return new ServletServerBuilder().maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
+  }
+
+  @Override
+  protected void startServer(ServerBuilder<?> builer) {
+    server = new Tomcat();
+    server.setPort(0);
+    Context ctx = server.addContext(MYAPP, new File("build/tmp").getAbsolutePath());
+    Tomcat
+        .addServlet(
+            ctx, "io.grpc.servlet.TomcatInteropTest",
+            new GrpcServlet(((ServletServerBuilder) builer).buildServletAdapter()))
+        .setAsyncSupported(true);
+    ctx.addServletMappingDecoded("/*", "io.grpc.servlet.TomcatInteropTest");
+
+    // Explicitly disable safeguards against malicious clients, as some unit tests trigger these
+    Http2Protocol http2Protocol = new Http2Protocol();
+    http2Protocol.setOverheadCountFactor(0);
+    http2Protocol.setOverheadWindowUpdateThreshold(0);
+    http2Protocol.setOverheadContinuationThreshold(0);
+    http2Protocol.setOverheadDataThreshold(0);
+
+    server.getConnector().addUpgradeProtocol(http2Protocol);
+    try {
+      server.start();
+    } catch (LifecycleException e) {
+      throw new RuntimeException(e);
+    }
+
+    port = server.getConnector().getLocalPort();
+  }
+
+  @Override
+  protected ManagedChannelBuilder<?> createChannelBuilder() {
+    NettyChannelBuilder builder = NettyChannelBuilder.forAddress(HOST, port)
+                                  .usePlaintext()
+                                  .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
+    InternalNettyChannelBuilder.setStatsEnabled(builder, false);
+    builder.intercept(createCensusStatsClientInterceptor());
+    return builder;
+  }
+
+  @Override
+  protected boolean metricsExpected() {
+    return false; // otherwise re-test will not work
+  }
+
+  // FIXME
+  @Override
+  @Ignore("Tomcat is broken on client GOAWAY")
+  @Test
+  public void gracefulShutdown() {}
+
+  @Override
+  @Ignore("Tomcat is not able to send trailer only")
+  @Test
+  public void specialStatusMessage() {}
+
+  @Override
+  @Ignore("Tomcat is not able to send trailer only")
+  @Test
+  public void unimplementedMethod() {}
+
+  @Override
+  @Ignore("Tomcat is not able to send trailer only")
+  @Test
+  public void statusCodeAndMessage() {}
+
+  @Override
+  @Ignore("Tomcat is not able to send trailer only")
+  @Test
+  public void emptyStream() {}
+
+  @Override
+  @Ignore("Tomcat is not able to send trailer only")
+  @Test
+  public void timeoutOnSleepingServer() {}
+}
diff --git a/servlet/src/tomcatTest/java/io/grpc/servlet/TomcatTransportTest.java b/servlet/src/tomcatTest/java/io/grpc/servlet/TomcatTransportTest.java
new file mode 100644
index 00000000000..cd73b096ccb
--- /dev/null
+++ b/servlet/src/tomcatTest/java/io/grpc/servlet/TomcatTransportTest.java
@@ -0,0 +1,283 @@
+/*
+ * Copyright 2018 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.servlet;
+
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.AbstractTransportTest;
+import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ManagedClientTransport;
+import io.grpc.internal.ServerListener;
+import io.grpc.internal.ServerTransportListener;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.NegotiationType;
+import io.grpc.netty.NettyChannelBuilder;
+import io.grpc.servlet.ServletServerBuilder.ServerTransportImpl;
+import java.io.File;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import org.apache.catalina.Context;
+import org.apache.catalina.LifecycleException;
+import org.apache.catalina.startup.Tomcat;
+import org.apache.coyote.http2.Http2Protocol;
+import org.junit.After;
+import org.junit.Ignore;
+import org.junit.Test;
+
+/**
+ * Transport test for Tomcat server and Netty client.
+ */
+public class TomcatTransportTest extends AbstractTransportTest {
+  private static final String MYAPP = "/service";
+
+  private final FakeClock fakeClock = new FakeClock();
+
+  private Tomcat tomcatServer;
+  private int port;
+
+  @After
+  @Override
+  public void tearDown() throws InterruptedException {
+    super.tearDown();
+    try {
+      tomcatServer.stop();
+    } catch (LifecycleException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  @Override
+  protected InternalServer newServer(List<ServerStreamTracer.Factory> streamTracerFactories) {
+    return new InternalServer() {
+      final InternalServer delegate =
+          new ServletServerBuilder().buildTransportServers(streamTracerFactories);
+
+      @Override
+      public void start(ServerListener listener) throws IOException {
+        delegate.start(listener);
+        ScheduledExecutorService scheduler = fakeClock.getScheduledExecutorService();
+        ServerTransportListener serverTransportListener =
+            listener.transportCreated(new ServerTransportImpl(scheduler));
+        ServletAdapter adapter =
+            new ServletAdapter(serverTransportListener, streamTracerFactories,
+                ServletAdapter.DEFAULT_METHOD_NAME_RESOLVER,
+                Integer.MAX_VALUE);
+        GrpcServlet grpcServlet = new GrpcServlet(adapter);
+
+        tomcatServer = new Tomcat();
+        tomcatServer.setPort(0);
+        Context ctx = tomcatServer.addContext(MYAPP, new File("build/tmp").getAbsolutePath());
+        Tomcat.addServlet(ctx, "TomcatTransportTest", grpcServlet)
+            .setAsyncSupported(true);
+        ctx.addServletMappingDecoded("/*", "TomcatTransportTest");
+        tomcatServer.getConnector().addUpgradeProtocol(new Http2Protocol());
+        // Workaround for https://github.com/grpc/grpc-java/issues/12540
+        // Prevent premature OutputBuffer recycling by disabling facade recycling.
+        // This should be revisited once the root cause is fixed.
+        tomcatServer.getConnector().setDiscardFacades(false);
+        try {
+          tomcatServer.start();
+        } catch (LifecycleException e) {
+          throw new RuntimeException(e);
+        }
+
+        port = tomcatServer.getConnector().getLocalPort();
+      }
+
+      @Override
+      public void shutdown() {
+        delegate.shutdown();
+      }
+
+      @Override
+      public SocketAddress getListenSocketAddress() {
+        return delegate.getListenSocketAddress();
+      }
+
+      @Override
+      public InternalInstrumented<SocketStats> getListenSocketStats() {
+        return delegate.getListenSocketStats();
+      }
+
+      @Override
+      public List<? extends SocketAddress> getListenSocketAddresses() {
+        return delegate.getListenSocketAddresses();
+      }
+
+      @Nullable
+      @Override
+      public List<InternalInstrumented<SocketStats>> getListenSocketStatsList() {
+        return delegate.getListenSocketStatsList();
+      }
+    };
+  }
+
+  @Override
+  protected InternalServer newServer(
+      int port, List<ServerStreamTracer.Factory> streamTracerFactories) {
+    return newServer(streamTracerFactories);
+  }
+
+  @Override
+  protected ManagedClientTransport newClientTransport(InternalServer server) {
+    NettyChannelBuilder nettyChannelBuilder = NettyChannelBuilder
+        // Although specified here, address is ignored because we never call build.
+        .forAddress("localhost", 0)
+        .flowControlWindow(65 * 1024)
+        .negotiationType(NegotiationType.PLAINTEXT);
+    InternalNettyChannelBuilder
+        .setTransportTracerFactory(nettyChannelBuilder, fakeClockTransportTracer);
+    ClientTransportFactory clientFactory =
+        InternalNettyChannelBuilder.buildTransportFactory(nettyChannelBuilder);
+    return clientFactory.newClientTransport(
+        new InetSocketAddress("localhost", port),
+        new ClientTransportFactory.ClientTransportOptions()
+            .setAuthority(testAuthority(server))
+            .setEagAttributes(eagAttrs()),
+        transportLogger());
+  }
+
+  @Override
+  protected String testAuthority(InternalServer server) {
+    return "localhost:" + port;
+  }
+
+  @Override
+  protected void advanceClock(long offset, TimeUnit unit) {
+    fakeClock.forwardNanos(unit.toNanos(offset));
+  }
+
+  @Override
+  protected long fakeCurrentTimeNanos() {
+    return fakeClock.getTicker().read();
+  }
+
+  @Override
+  @Ignore("Skip the test, server lifecycle is managed by the container")
+  @Test
+  public void serverAlreadyListening() {}
+
+  @Override
+  @Ignore("Skip the test, server lifecycle is managed by the container")
+  @Test
+  public void openStreamPreventsTermination() {}
+
+  @Override
+  @Ignore("Skip the test, server lifecycle is managed by the container")
+  @Test
+  public void shutdownNowKillsServerStream() {}
+
+  @Override
+  @Ignore("Skip the test, server lifecycle is managed by the container")
+  @Test
+  public void serverNotListening() {}
+
+  // FIXME
+  @Override
+  @Ignore("Tomcat is broken on client GOAWAY")
+  @Test
+  public void newStream_duringShutdown() {}
+
+  // FIXME
+  @Override
+  @Ignore("Tomcat is broken on client GOAWAY")
+  @Test
+  public void ping_duringShutdown() {}
+
+  // FIXME
+  @Override
+  @Ignore("Tomcat is broken on client RST_STREAM")
+  @Test
+  public void frameAfterRstStreamShouldNotBreakClientChannel() {}
+
+  // FIXME
+  @Override
+  @Ignore("Tomcat is broken on client RST_STREAM")
+  @Test
+  public void shutdownNowKillsClientStream() {}
+
+  // FIXME
+  @Override
+  @Ignore("Servlet flow control not implemented yet")
+  @Test
+  public void flowControlPushBack() {}
+
+  // FIXME
+  @Override
+  @Ignore("Servlet flow control not implemented yet")
+  @Test
+  public void flowControlDoesNotDeadlockLargeMessage() {
+  }
+
+  @Override
+  @Ignore("Server side sockets are managed by the servlet container")
+  @Test
+  public void socketStats() {}
+
+  @Override
+  @Ignore("serverTransportListener will not terminate")
+  @Test
+  public void clientStartAndStopOnceConnected() {}
+
+  @Override
+  @Ignore("clientStreamTracer1.getInboundTrailers() is not null; listeners.poll() doesn't apply")
+  @Test
+  public void serverCancel() {}
+
+  @Override
+  @Ignore("This doesn't apply: Ensure that for a closed ServerStream, interactions are noops")
+  @Test
+  public void interactionsAfterServerStreamCloseAreNoops() {}
+
+  @Override
+  @Ignore("listeners.poll() doesn't apply")
+  @Test
+  public void interactionsAfterClientStreamCancelAreNoops() {}
+
+  @Override
+  @Ignore("assertNull(serverStatus.getCause()) isn't true")
+  @Test
+  public void clientCancel() {}
+
+  @Override
+  @Ignore("Tomcat does not support trailers only")
+  @Test
+  public void earlyServerClose_noServerHeaders() {}
+
+  @Override
+  @Ignore("Tomcat does not support trailers only")
+  @Test
+  public void earlyServerClose_serverFailure() {}
+
+  @Override
+  @Ignore("Tomcat does not support trailers only")
+  @Test
+  public void earlyServerClose_serverFailure_withClientCancelOnListenerClosed() {}
+
+  @Override
+  @Ignore("regression since bumping grpc v1.46 to v1.53")
+  @Test
+  public void messageProducerOnlyProducesRequestedMessages() {}
+}
diff --git a/servlet/src/undertowTest/java/io/grpc/servlet/UndertowInteropTest.java b/servlet/src/undertowTest/java/io/grpc/servlet/UndertowInteropTest.java
new file mode 100644
index 00000000000..b8be018664d
--- /dev/null
+++ b/servlet/src/undertowTest/java/io/grpc/servlet/UndertowInteropTest.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2018 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.servlet;
+
+import static io.undertow.servlet.Servlets.defaultContainer;
+import static io.undertow.servlet.Servlets.deployment;
+import static io.undertow.servlet.Servlets.servlet;
+
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.ServerBuilder;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.NettyChannelBuilder;
+import io.grpc.testing.integration.AbstractInteropTest;
+import io.undertow.Handlers;
+import io.undertow.Undertow;
+import io.undertow.UndertowOptions;
+import io.undertow.server.HttpHandler;
+import io.undertow.server.handlers.PathHandler;
+import io.undertow.servlet.api.DeploymentInfo;
+import io.undertow.servlet.api.DeploymentManager;
+import io.undertow.servlet.api.InstanceFactory;
+import io.undertow.servlet.util.ImmediateInstanceHandle;
+import java.net.InetSocketAddress;
+import javax.servlet.Servlet;
+import javax.servlet.ServletException;
+import org.junit.After;
+import org.junit.Ignore;
+import org.junit.Test;
+
+/**
+ * Interop test for Undertow server and Netty client.
+ */
+public class UndertowInteropTest extends AbstractInteropTest {
+  private static final String HOST = "localhost";
+  private static final String MYAPP = "/grpc.testing.TestService";
+  private int port;
+  private Undertow server;
+  private DeploymentManager manager;
+
+  @After
+  @Override
+  public void tearDown() {
+    super.tearDown();
+    if (server != null) {
+      server.stop();
+    }
+    if (manager != null) {
+      try {
+        manager.stop();
+      } catch (ServletException e) {
+        throw new AssertionError("failed to stop container", e);
+      }
+    }
+  }
+
+  @Override
+  protected ServletServerBuilder getServerBuilder() {
+    return new ServletServerBuilder().maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
+  }
+
+  @Override
+  protected void startServer(ServerBuilder<?> builder) {
+    GrpcServlet grpcServlet =
+        new GrpcServlet(((ServletServerBuilder) builder).buildServletAdapter());
+    InstanceFactory<? extends Servlet> instanceFactory =
+        () -> new ImmediateInstanceHandle<>(grpcServlet);
+    DeploymentInfo servletBuilder =
+        deployment()
+            .setClassLoader(UndertowInteropTest.class.getClassLoader())
+            .setContextPath(MYAPP)
+            .setDeploymentName("UndertowInteropTest.war")
+            .addServlets(
+                servlet("InteropTestServlet", GrpcServlet.class, instanceFactory)
+                    .addMapping("/*")
+                    .setAsyncSupported(true));
+
+    manager = defaultContainer().addDeployment(servletBuilder);
+    manager.deploy();
+
+    HttpHandler servletHandler;
+    try {
+      servletHandler = manager.start();
+    } catch (ServletException e) {
+      throw new RuntimeException(e);
+    }
+    PathHandler path = Handlers.path(Handlers.redirect(MYAPP))
+        .addPrefixPath("/", servletHandler); // for unimplementedService test
+    server = Undertow.builder()
+        .setServerOption(UndertowOptions.ENABLE_HTTP2, true)
+        .setServerOption(UndertowOptions.SHUTDOWN_TIMEOUT, 5000 /* 5 sec */)
+        .addHttpListener(0, HOST)
+        .setHandler(path)
+        .build();
+    server.start();
+    port = ((InetSocketAddress) server.getListenerInfo().get(0).getAddress()).getPort();
+  }
+
+  @Override
+  protected ManagedChannelBuilder<?> createChannelBuilder() {
+    NettyChannelBuilder builder = NettyChannelBuilder
+            .forAddress(HOST, port)
+            .usePlaintext()
+            .maxInboundMessageSize(AbstractInteropTest.MAX_MESSAGE_SIZE);
+    InternalNettyChannelBuilder.setStatsEnabled(builder, false);
+    builder.intercept(createCensusStatsClientInterceptor());
+    return builder;
+  }
+
+  // FIXME
+  @Override
+  @Ignore("Undertow is broken on client GOAWAY")
+  @Test
+  public void gracefulShutdown() {}
+}
diff --git a/servlet/src/undertowTest/java/io/grpc/servlet/UndertowTransportTest.java b/servlet/src/undertowTest/java/io/grpc/servlet/UndertowTransportTest.java
new file mode 100644
index 00000000000..ef897c87d70
--- /dev/null
+++ b/servlet/src/undertowTest/java/io/grpc/servlet/UndertowTransportTest.java
@@ -0,0 +1,313 @@
+/*
+ * Copyright 2018 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.servlet;
+
+import static io.undertow.servlet.Servlets.defaultContainer;
+import static io.undertow.servlet.Servlets.deployment;
+import static io.undertow.servlet.Servlets.servlet;
+
+import io.grpc.InternalChannelz.SocketStats;
+import io.grpc.InternalInstrumented;
+import io.grpc.ServerStreamTracer;
+import io.grpc.internal.AbstractTransportTest;
+import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ManagedClientTransport;
+import io.grpc.internal.ServerListener;
+import io.grpc.internal.ServerTransportListener;
+import io.grpc.netty.InternalNettyChannelBuilder;
+import io.grpc.netty.NegotiationType;
+import io.grpc.netty.NettyChannelBuilder;
+import io.grpc.servlet.ServletServerBuilder.ServerTransportImpl;
+import io.undertow.Handlers;
+import io.undertow.Undertow;
+import io.undertow.UndertowOptions;
+import io.undertow.server.HttpHandler;
+import io.undertow.server.handlers.PathHandler;
+import io.undertow.servlet.api.DeploymentInfo;
+import io.undertow.servlet.api.DeploymentManager;
+import io.undertow.servlet.api.InstanceFactory;
+import io.undertow.servlet.util.ImmediateInstanceHandle;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import javax.servlet.Servlet;
+import javax.servlet.ServletException;
+import org.junit.After;
+import org.junit.Ignore;
+import org.junit.Test;
+
+/**
+ * Transport test for Undertow server and Netty client.
+ */
+public class UndertowTransportTest extends AbstractTransportTest {
+
+  private static final String HOST = "localhost";
+  private static final String MYAPP = "/service";
+
+  private final FakeClock fakeClock = new FakeClock();
+
+  private Undertow undertowServer;
+  private DeploymentManager manager;
+  private int port;
+
+  @After
+  @Override
+  public void tearDown() throws InterruptedException {
+    super.tearDown();
+    if (undertowServer != null) {
+      undertowServer.stop();
+    }
+    if (manager != null) {
+      try {
+        manager.stop();
+      } catch (ServletException e) {
+        throw new AssertionError("failed to stop container", e);
+      }
+    }
+  }
+
+  @Override
+  protected InternalServer newServer(List<ServerStreamTracer.Factory>
+                                                               streamTracerFactories) {
+    return new InternalServer() {
+      final InternalServer delegate =
+          new ServletServerBuilder().buildTransportServers(streamTracerFactories);
+
+      @Override
+      public void start(ServerListener listener) throws IOException {
+        delegate.start(listener);
+        ScheduledExecutorService scheduler = fakeClock.getScheduledExecutorService();
+        ServerTransportListener serverTransportListener =
+            listener.transportCreated(new ServerTransportImpl(scheduler));
+        ServletAdapter adapter =
+            new ServletAdapter(serverTransportListener, streamTracerFactories,
+                ServletAdapter.DEFAULT_METHOD_NAME_RESOLVER,
+                Integer.MAX_VALUE);
+        GrpcServlet grpcServlet = new GrpcServlet(adapter);
+        InstanceFactory<? extends Servlet> instanceFactory =
+            () -> new ImmediateInstanceHandle<>(grpcServlet);
+        DeploymentInfo servletBuilder =
+            deployment()
+                .setClassLoader(UndertowInteropTest.class.getClassLoader())
+                .setContextPath(MYAPP)
+                .setDeploymentName("UndertowTransportTest.war")
+                .addServlets(
+                    servlet("TransportTestServlet", GrpcServlet.class, instanceFactory)
+                        .addMapping("/*")
+                        .setAsyncSupported(true));
+
+        manager = defaultContainer().addDeployment(servletBuilder);
+        manager.deploy();
+
+        HttpHandler servletHandler;
+        try {
+          servletHandler = manager.start();
+        } catch (ServletException e) {
+          throw new RuntimeException(e);
+        }
+        PathHandler path =
+            Handlers.path(Handlers.redirect(MYAPP))
+                .addPrefixPath("/", servletHandler); // for unimplementedService test
+        undertowServer =
+            Undertow.builder()
+                .setServerOption(UndertowOptions.ENABLE_HTTP2, true)
+                .setServerOption(UndertowOptions.SHUTDOWN_TIMEOUT, 5000 /* 5 sec */)
+                .addHttpListener(0, HOST)
+                .setHandler(path)
+                .build();
+        undertowServer.start();
+        port = ((InetSocketAddress) undertowServer.getListenerInfo().get(0).getAddress()).getPort();
+      }
+
+      @Override
+      public void shutdown() {
+        delegate.shutdown();
+      }
+
+      @Override
+      public SocketAddress getListenSocketAddress() {
+        return delegate.getListenSocketAddress();
+      }
+
+      @Override
+      public InternalInstrumented<SocketStats> getListenSocketStats() {
+        return delegate.getListenSocketStats();
+      }
+
+      @Override
+      public List<? extends SocketAddress> getListenSocketAddresses() {
+        return delegate.getListenSocketAddresses();
+      }
+
+      @Nullable
+      @Override
+      public List<InternalInstrumented<SocketStats>> getListenSocketStatsList() {
+        return delegate.getListenSocketStatsList();
+      }
+    };
+  }
+
+  @Override
+  protected InternalServer newServer(int port,
+      List<ServerStreamTracer.Factory> streamTracerFactories) {
+    return newServer(streamTracerFactories);
+  }
+
+  @Override
+  protected ManagedClientTransport newClientTransport(InternalServer server) {
+    NettyChannelBuilder nettyChannelBuilder = NettyChannelBuilder
+        // Although specified here, address is ignored because we never call build.
+        .forAddress("localhost", 0)
+        .flowControlWindow(65 * 1024)
+        .negotiationType(NegotiationType.PLAINTEXT);
+    InternalNettyChannelBuilder
+        .setTransportTracerFactory(nettyChannelBuilder, fakeClockTransportTracer);
+    ClientTransportFactory clientFactory =
+        InternalNettyChannelBuilder.buildTransportFactory(nettyChannelBuilder);
+    return clientFactory.newClientTransport(
+        new InetSocketAddress("localhost", port),
+        new ClientTransportFactory.ClientTransportOptions()
+            .setAuthority(testAuthority(server))
+            .setEagAttributes(eagAttrs()),
+        transportLogger());
+  }
+
+  @Override
+  protected String testAuthority(InternalServer server) {
+    return "localhost:" + port;
+  }
+
+  @Override
+  protected void advanceClock(long offset, TimeUnit unit) {
+    fakeClock.forwardNanos(unit.toNanos(offset));
+  }
+
+  @Override
+  protected long fakeCurrentTimeNanos() {
+    return fakeClock.getTicker().read();
+  }
+
+  @Override
+  @Ignore("Skip the test, server lifecycle is managed by the container")
+  @Test
+  public void serverAlreadyListening() {}
+
+  @Override
+  @Ignore("Skip the test, server lifecycle is managed by the container")
+  @Test
+  public void openStreamPreventsTermination() {}
+
+  @Override
+  @Ignore("Skip the test, server lifecycle is managed by the container")
+  @Test
+  public void shutdownNowKillsServerStream() {}
+
+  @Override
+  @Ignore("Skip the test, server lifecycle is managed by the container")
+  @Test
+  public void serverNotListening() {}
+
+  @Override
+  @Ignore("Skip the test, can not set HTTP/2 SETTINGS_MAX_HEADER_LIST_SIZE")
+  @Test
+  public void serverChecksInboundMetadataSize() {}
+
+  // FIXME
+  @Override
+  @Ignore("Undertow is broken on client GOAWAY")
+  @Test
+  public void newStream_duringShutdown() {}
+
+  // FIXME
+  @Override
+  @Ignore("Undertow is broken on client GOAWAY")
+  @Test
+  public void ping_duringShutdown() {}
+
+  // FIXME
+  @Override
+  @Ignore("Undertow is broken on client RST_STREAM")
+  @Test
+  public void frameAfterRstStreamShouldNotBreakClientChannel() {}
+
+  // FIXME
+  @Override
+  @Ignore("Undertow is broken on client RST_STREAM")
+  @Test
+  public void shutdownNowKillsClientStream() {}
+
+  // FIXME: https://github.com/grpc/grpc-java/issues/8925
+  @Override
+  @Ignore("flaky")
+  @Test
+  public void clientCancelFromWithinMessageRead() {}
+
+  // FIXME
+  @Override
+  @Ignore("Servlet flow control not implemented yet")
+  @Test
+  public void flowControlPushBack() {}
+
+  // FIXME
+  @Override
+  @Ignore("Servlet flow control not implemented yet")
+  @Test
+  public void flowControlDoesNotDeadlockLargeMessage() {
+  }
+
+  @Override
+  @Ignore("Server side sockets are managed by the servlet container")
+  @Test
+  public void socketStats() {}
+
+  @Override
+  @Ignore("serverTransportListener will not terminate")
+  @Test
+  public void clientStartAndStopOnceConnected() {}
+
+  @Override
+  @Ignore("clientStreamTracer1.getInboundTrailers() is not null; listeners.poll() doesn't apply")
+  @Test
+  public void serverCancel() {}
+
+  @Override
+  @Ignore("This doesn't apply: Ensure that for a closed ServerStream, interactions are noops")
+  @Test
+  public void interactionsAfterServerStreamCloseAreNoops() {}
+
+  @Override
+  @Ignore("listeners.poll() doesn't apply")
+  @Test
+  public void interactionsAfterClientStreamCancelAreNoops() {}
+
+
+  @Override
+  @Ignore("assertNull(serverStatus.getCause()) isn't true")
+  @Test
+  public void clientCancel() {}
+
+  @Override
+  @Ignore("regression since bumping grpc v1.46 to v1.53")
+  @Test
+  public void messageProducerOnlyProducesRequestedMessages() {}
+}
diff --git a/settings.gradle b/settings.gradle
index ba0e64090db..51c4bdc0d3d 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,43 +1,153 @@
+pluginManagement {
+    // https://issuetracker.google.com/issues/342522142#comment8
+    // use D8/R8 8.0.44 or 8.1.44 with AGP 7.4 if needed.
+    buildscript {
+        repositories {
+            mavenCentral()
+            maven {
+                url = uri("https://storage.googleapis.com/r8-releases/raw")
+            }
+        }
+        dependencies {
+            classpath("com.android.tools:r8:8.1.44")
+        }
+    }
+    plugins {
+        // https://developer.android.com/build/releases/gradle-plugin
+        // 8+ has many changes: https://github.com/grpc/grpc-java/issues/10152
+        id "com.android.application" version "7.4.1"
+        id "com.android.library" version "7.4.1"
+	// https://github.com/kt3k/coveralls-gradle-plugin/tags
+        id "com.github.kt3k.coveralls" version "2.12.2"
+	// https://github.com/GoogleCloudPlatform/appengine-plugins/releases
+        id "com.google.cloud.tools.appengine" version "2.8.6"
+        // https://github.com/GoogleContainerTools/jib/blob/master/jib-gradle-plugin/CHANGELOG.md
+        id "com.google.cloud.tools.jib" version "3.5.1"
+	// https://github.com/google/osdetector-gradle-plugin/tags
+        id "com.google.osdetector" version "1.7.3"
+        // https://github.com/google/protobuf-gradle-plugin/releases
+        id "com.google.protobuf" version "0.9.5"
+        // https://github.com/GradleUp/shadow/releases
+        // 8.3.2+ requires Java 11+
+        // 8.3.1 breaks apache imports for netty/shaded, fixed in 8.3.2
+        id "com.gradleup.shadow" version "8.3.0"
+        // https://github.com/melix/japicmp-gradle-plugin/blob/master/CHANGELOG.txt
+        id "me.champeau.gradle.japicmp" version "0.4.2"
+        // https://github.com/melix/jmh-gradle-plugin/releases
+        id "me.champeau.jmh" version "0.7.3"
+        // https://github.com/tbroyer/gradle-errorprone-plugin/releases
+        id "net.ltgt.errorprone" version "4.3.0"
+        // https://github.com/xvik/gradle-animalsniffer-plugin/releases
+        id "ru.vyarus.animalsniffer" version "2.0.1"
+    }
+    resolutionStrategy {
+        eachPlugin {
+            if (target.id.namespace == "com.android") {
+                useModule("com.android.tools.build:gradle:${target.version}")
+            }
+            if (requested.id.id.startsWith('com.google.cloud.tools.appengine')) {
+                useModule("com.google.cloud.tools:appengine-gradle-plugin:${target.version}")
+            }
+        }
+    }
+    repositories {
+        gradlePluginPortal()
+        google()
+    }
+}
+
 rootProject.name = "grpc"
+include ":grpc-api"
 include ":grpc-core"
 include ":grpc-context"
 include ":grpc-stub"
+include ":grpc-census"
 include ":grpc-auth"
 include ":grpc-okhttp"
 include ":grpc-protobuf"
 include ":grpc-protobuf-lite"
-include ":grpc-protobuf-nano"
 include ":grpc-netty"
+include ":grpc-netty-shaded"
+include ":grpc-googleapis"
 include ":grpc-grpclb"
 include ":grpc-testing"
 include ":grpc-testing-proto"
 include ":grpc-interop-testing"
+include ":grpc-gae-interop-testing-jdk8"
 include ":grpc-all"
+include ":grpc-alts"
 include ":grpc-benchmarks"
 include ":grpc-services"
-include ":grpc-thrift"
+include ":grpc-servlet"
+include ":grpc-servlet-jakarta"
+include ":grpc-s2a"
+include ":grpc-xds"
+include ":grpc-bom"
+include ":grpc-rls"
+include ":grpc-authz"
+include ":grpc-gcp-csm-observability"
+include ":grpc-gcp-observability"
+include ":grpc-gcp-observability:interop"
+include ":grpc-istio-interop-testing"
+include ":grpc-inprocess"
+include ":grpc-util"
+include ":grpc-opentelemetry"
+include ":grpc-context-override-opentelemetry"
 
+project(':grpc-api').projectDir = "$rootDir/api" as File
 project(':grpc-core').projectDir = "$rootDir/core" as File
 project(':grpc-context').projectDir = "$rootDir/context" as File
 project(':grpc-stub').projectDir = "$rootDir/stub" as File
+project(':grpc-census').projectDir = "$rootDir/census" as File
 project(':grpc-auth').projectDir = "$rootDir/auth" as File
 project(':grpc-okhttp').projectDir = "$rootDir/okhttp" as File
 project(':grpc-protobuf').projectDir = "$rootDir/protobuf" as File
 project(':grpc-protobuf-lite').projectDir = "$rootDir/protobuf-lite" as File
-project(':grpc-protobuf-nano').projectDir = "$rootDir/protobuf-nano" as File
 project(':grpc-netty').projectDir = "$rootDir/netty" as File
+project(':grpc-netty-shaded').projectDir = "$rootDir/netty/shaded" as File
+project(':grpc-googleapis').projectDir = "$rootDir/googleapis" as File
 project(':grpc-grpclb').projectDir = "$rootDir/grpclb" as File
 project(':grpc-testing').projectDir = "$rootDir/testing" as File
 project(':grpc-testing-proto').projectDir = "$rootDir/testing-proto" as File
 project(':grpc-interop-testing').projectDir = "$rootDir/interop-testing" as File
+project(':grpc-gae-interop-testing-jdk8').projectDir = "$rootDir/gae-interop-testing/gae-jdk8" as File
 project(':grpc-all').projectDir = "$rootDir/all" as File
+project(':grpc-alts').projectDir = "$rootDir/alts" as File
 project(':grpc-benchmarks').projectDir = "$rootDir/benchmarks" as File
 project(':grpc-services').projectDir = "$rootDir/services" as File
-project(':grpc-thrift').projectDir = "$rootDir/thrift" as File
+project(':grpc-servlet').projectDir = "$rootDir/servlet" as File
+project(':grpc-servlet-jakarta').projectDir = "$rootDir/servlet/jakarta" as File
+project(':grpc-s2a').projectDir = "$rootDir/s2a" as File
+project(':grpc-xds').projectDir = "$rootDir/xds" as File
+project(':grpc-bom').projectDir = "$rootDir/bom" as File
+project(':grpc-rls').projectDir = "$rootDir/rls" as File
+project(':grpc-authz').projectDir = "$rootDir/authz" as File
+project(':grpc-gcp-csm-observability').projectDir = "$rootDir/gcp-csm-observability" as File
+project(':grpc-gcp-observability').projectDir = "$rootDir/gcp-observability" as File
+project(':grpc-gcp-observability:interop').projectDir = "$rootDir/gcp-observability/interop" as File
+project(':grpc-istio-interop-testing').projectDir = "$rootDir/istio-interop-testing" as File
+project(':grpc-inprocess').projectDir = "$rootDir/inprocess" as File
+project(':grpc-util').projectDir = "$rootDir/util" as File
+project(':grpc-opentelemetry').projectDir = "$rootDir/opentelemetry" as File
+project(':grpc-context-override-opentelemetry').projectDir = "$rootDir/contextstorage" as File
 
 if (settings.hasProperty('skipCodegen') && skipCodegen.toBoolean()) {
-  println '*** Skipping the build of codegen and compilation of proto files because skipCodegen=true'
+    println '*** Skipping the build of codegen and compilation of proto files because skipCodegen=true'
+} else {
+    include ":grpc-compiler"
+    project(':grpc-compiler').projectDir = "$rootDir/compiler" as File
+}
+
+if (settings.hasProperty('skipAndroid') && skipAndroid.toBoolean()) {
+    println '  * Skipping the build of Android projects because skipAndroid=true'
 } else {
-  include ":grpc-compiler"
-  project(':grpc-compiler').projectDir = "$rootDir/compiler" as File
+    println '*** Android SDK is required. To avoid building Android projects, set -PskipAndroid=true'
+    include ":grpc-cronet"
+    project(':grpc-cronet').projectDir = "$rootDir/cronet" as File
+    include ":grpc-android"
+    project(':grpc-android').projectDir = "$rootDir/android" as File
+    include ":grpc-android-interop-testing"
+    project(':grpc-android-interop-testing').projectDir = "$rootDir/android-interop-testing" as File
+    include ":grpc-binder"
+    project(':grpc-binder').projectDir = "$rootDir/binder" as File
 }
diff --git a/stub/BUILD.bazel b/stub/BUILD.bazel
new file mode 100644
index 00000000000..f9188c27272
--- /dev/null
+++ b/stub/BUILD.bazel
@@ -0,0 +1,18 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "stub",
+    srcs = glob([
+        "src/main/java/**/*.java",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api",
+        "//context",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+        artifact("org.codehaus.mojo:animal-sniffer-annotations"),
+    ],
+)
diff --git a/stub/build.gradle b/stub/build.gradle
index ae86c39511d..2dabd9e6202 100644
--- a/stub/build.gradle
+++ b/stub/build.gradle
@@ -1,9 +1,40 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "me.champeau.gradle.japicmp"
+    id "ru.vyarus.animalsniffer"
+}
+
 description = "gRPC: Stub"
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.stub')
+    }
+}
+
 dependencies {
-    compile project(':grpc-core')
-    testCompile libraries.truth,
-    project(':grpc-testing')
-    signature "org.codehaus.mojo.signature:java16:+@signature"
+    api project(':grpc-api'),
+        libraries.animalsniffer.annotations,
+        libraries.guava
+    implementation libraries.errorprone.annotations
+    testImplementation libraries.truth,
+            project(':grpc-inprocess'),
+            project(':grpc-testing'),
+            testFixtures(project(':grpc-api'))
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
-javadoc.options.links "https://google.github.io/guava/releases/${guavaVersion}/api/docs/"
+tasks.named("javadoc").configure {
+    exclude 'io/grpc/stub/Internal*'
+}
diff --git a/stub/src/main/java/io/grpc/stub/AbstractAsyncStub.java b/stub/src/main/java/io/grpc/stub/AbstractAsyncStub.java
new file mode 100644
index 00000000000..f369eeaf87f
--- /dev/null
+++ b/stub/src/main/java/io/grpc/stub/AbstractAsyncStub.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2019 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.stub;
+
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.stub.ClientCalls.StubType;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Stub implementations for async stubs.
+ *
+ * <p>DO NOT MOCK: Customizing options doesn't work properly in mocks. Use InProcessChannelBuilder
+ * to create a real channel suitable for testing. It is also possible to mock Channel instead.
+ *
+ * @since 1.26.0
+ */
+@ThreadSafe
+@CheckReturnValue
+public abstract class AbstractAsyncStub<S extends AbstractAsyncStub<S>> extends AbstractStub<S> {
+
+  protected AbstractAsyncStub(Channel channel, CallOptions callOptions) {
+    super(channel, callOptions);
+  }
+
+  /**
+   * Returns a new async stub with the given channel for the provided method configurations.
+   *
+   * @since 1.26.0
+   * @param factory the factory to create an async stub
+   * @param channel the channel that this stub will use to do communications
+   */
+  public static <T extends AbstractStub<T>> T newStub(
+      StubFactory<T> factory, Channel channel) {
+    return newStub(factory, channel, CallOptions.DEFAULT);
+  }
+
+  /**
+   * Returns a new async stub with the given channel for the provided method configurations.
+   *
+   * @since 1.26.0
+   * @param factory the factory to create an async stub
+   * @param channel the channel that this stub will use to do communications
+   * @param callOptions the runtime call options to be applied to every call on this stub
+   */
+  public static <T extends AbstractStub<T>> T newStub(
+      StubFactory<T> factory, Channel channel, CallOptions callOptions) {
+    T stub = factory.newStub(
+        channel, callOptions.withOption(ClientCalls.STUB_TYPE_OPTION, StubType.ASYNC));
+    assert stub instanceof AbstractAsyncStub
+        : String.format("Expected AbstractAsyncStub, but got %s.", stub.getClass());
+    return stub;
+  }
+}
diff --git a/stub/src/main/java/io/grpc/stub/AbstractBlockingStub.java b/stub/src/main/java/io/grpc/stub/AbstractBlockingStub.java
new file mode 100644
index 00000000000..4bdb3c0bb94
--- /dev/null
+++ b/stub/src/main/java/io/grpc/stub/AbstractBlockingStub.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2019 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.stub;
+
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.stub.ClientCalls.StubType;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Stub implementations for blocking stubs.
+ *
+ * <p>DO NOT MOCK: Customizing options doesn't work properly in mocks. Use InProcessChannelBuilder
+ * to create a real channel suitable for testing. It is also possible to mock Channel instead.
+ *
+ * @since 1.26.0
+ */
+@ThreadSafe
+@CheckReturnValue
+public abstract class AbstractBlockingStub<S extends AbstractBlockingStub<S>>
+    extends AbstractStub<S> {
+
+  protected AbstractBlockingStub(Channel channel, CallOptions callOptions) {
+    super(channel, callOptions);
+  }
+
+  /**
+   * Returns a new blocking stub with the given channel for the provided method configurations.
+   *
+   * @since 1.26.0
+   * @param factory the factory to create a blocking stub
+   * @param channel the channel that this stub will use to do communications
+   */
+  public static <T extends AbstractStub<T>> T newStub(
+      StubFactory<T> factory, Channel channel) {
+    return newStub(factory, channel, CallOptions.DEFAULT);
+  }
+
+  /**
+   * Returns a new blocking stub with the given channel for the provided method configurations.
+   *
+   * @since 1.26.0
+   * @param factory the factory to create a blocking stub
+   * @param channel the channel that this stub will use to do communications
+   * @param callOptions the runtime call options to be applied to every call on this stub
+   */
+  public static <T extends AbstractStub<T>> T newStub(
+      StubFactory<T> factory, Channel channel, CallOptions callOptions) {
+    T stub = factory.newStub(
+        channel, callOptions.withOption(ClientCalls.STUB_TYPE_OPTION, StubType.BLOCKING));
+    assert stub instanceof AbstractBlockingStub
+        : String.format("Expected AbstractBlockingStub, but got %s.", stub.getClass());
+    return stub;
+  }
+}
diff --git a/stub/src/main/java/io/grpc/stub/AbstractFutureStub.java b/stub/src/main/java/io/grpc/stub/AbstractFutureStub.java
new file mode 100644
index 00000000000..5e37b1e4915
--- /dev/null
+++ b/stub/src/main/java/io/grpc/stub/AbstractFutureStub.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2019 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.stub;
+
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.stub.ClientCalls.StubType;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Stub implementations for future stubs.
+ *
+ * <p>DO NOT MOCK: Customizing options doesn't work properly in mocks. Use InProcessChannelBuilder
+ * to create a real channel suitable for testing. It is also possible to mock Channel instead.
+ *
+ * @since 1.26.0
+ */
+@ThreadSafe
+@CheckReturnValue
+public abstract class AbstractFutureStub<S extends AbstractFutureStub<S>> extends AbstractStub<S> {
+
+  protected AbstractFutureStub(Channel channel, CallOptions callOptions) {
+    super(channel, callOptions);
+  }
+
+  /**
+   * Returns a new future stub with the given channel for the provided method configurations.
+   *
+   * @since 1.26.0
+   * @param factory the factory to create a future stub
+   * @param channel the channel that this stub will use to do communications
+   */
+  public static <T extends AbstractStub<T>> T newStub(
+      StubFactory<T> factory, Channel channel) {
+    return newStub(factory, channel, CallOptions.DEFAULT);
+  }
+
+  /**
+   * Returns a new future stub with the given channel for the provided method configurations.
+   *
+   * @since 1.26.0
+   * @param factory the factory to create a future stub
+   * @param channel the channel that this stub will use to do communications
+   * @param callOptions the runtime call options to be applied to every call on this stub
+   * @return a future stub
+   */
+  public static <T extends AbstractStub<T>> T newStub(
+      StubFactory<T> factory, Channel channel, CallOptions callOptions) {
+    T stub = factory.newStub(
+        channel, callOptions.withOption(ClientCalls.STUB_TYPE_OPTION, StubType.FUTURE));
+    assert stub instanceof AbstractFutureStub
+        : String.format("Expected AbstractFutureStub, but got %s.", stub.getClass());
+    return stub;
+  }
+}
diff --git a/stub/src/main/java/io/grpc/stub/AbstractStub.java b/stub/src/main/java/io/grpc/stub/AbstractStub.java
index 0c9319fe671..697107760db 100644
--- a/stub/src/main/java/io/grpc/stub/AbstractStub.java
+++ b/stub/src/main/java/io/grpc/stub/AbstractStub.java
@@ -1,38 +1,25 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
 
 import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.InternalTimeUtils.convert;
 
+import com.google.errorprone.annotations.CheckReturnValue;
 import io.grpc.CallCredentials;
 import io.grpc.CallOptions;
 import io.grpc.Channel;
@@ -41,17 +28,29 @@
 import io.grpc.Deadline;
 import io.grpc.ExperimentalApi;
 import io.grpc.ManagedChannelBuilder;
+import java.time.Duration;
+import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
 import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
 
 /**
- * Common base type for stub implementations.
+ * Common base type for stub implementations. Stub configuration is immutable; changing the
+ * configuration returns a new stub with updated configuration. Changing the configuration is cheap
+ * and may be done before every RPC, such as would be common when using {@link #withDeadlineAfter}.
+ *
+ * <p>Configuration is stored in {@link CallOptions} and is passed to the {@link Channel} when
+ * performing an RPC.
  *
- * <p>This is the base class of the stub classes from the generated code. It allows for
- * reconfiguration, e.g., attaching interceptors to the stub.
+ * <p>DO NOT MOCK: Customizing options doesn't work properly in mocks. Use InProcessChannelBuilder
+ * to create a real channel suitable for testing. It is also possible to mock Channel instead.
  *
+ * @since 1.0.0
  * @param <S> the concrete type of this stub.
  */
+@ThreadSafe
+@CheckReturnValue
 public abstract class AbstractStub<S extends AbstractStub<S>> {
   private final Channel channel;
   private final CallOptions callOptions;
@@ -59,6 +58,7 @@ public abstract class AbstractStub<S extends AbstractStub<S>> {
   /**
    * Constructor for use by subclasses, with the default {@code CallOptions}.
    *
+   * @since 1.0.0
    * @param channel the channel that this stub will use to do communications
    */
   protected AbstractStub(Channel channel) {
@@ -66,8 +66,9 @@ protected AbstractStub(Channel channel) {
   }
 
   /**
-   * Constructor for use by subclasses, with the default {@code CallOptions}.
+   * Constructor for use by subclasses.
    *
+   * @since 1.0.0
    * @param channel the channel that this stub will use to do communications
    * @param callOptions the runtime call options to be applied to every call on this stub
    */
@@ -78,6 +79,8 @@ protected AbstractStub(Channel channel, CallOptions callOptions) {
 
   /**
    * The underlying channel of the stub.
+   *
+   * @since 1.0.0
    */
   public final Channel getChannel() {
     return channel;
@@ -85,6 +88,8 @@ public final Channel getChannel() {
 
   /**
    * The {@code CallOptions} of the stub.
+   *
+   * @since 1.0.0
    */
   public final CallOptions getCallOptions() {
     return callOptions;
@@ -93,17 +98,44 @@ public final CallOptions getCallOptions() {
   /**
    * Returns a new stub with the given channel for the provided method configurations.
    *
+   * @since 1.0.0
    * @param channel the channel that this stub will use to do communications
    * @param callOptions the runtime call options to be applied to every call on this stub
    */
   protected abstract S build(Channel channel, CallOptions callOptions);
 
+  /**
+   * Returns a new stub with the given channel for the provided method configurations.
+   *
+   * @since 1.26.0
+   * @param factory the factory to create a stub
+   * @param channel the channel that this stub will use to do communications
+   */
+  public static <T extends AbstractStub<T>> T newStub(
+      StubFactory<T> factory, Channel channel) {
+    return newStub(factory, channel, CallOptions.DEFAULT);
+  }
+
+  /**
+   * Returns a new stub with the given channel for the provided method configurations.
+   *
+   * @since 1.26.0
+   * @param factory the factory to create a stub
+   * @param channel the channel that this stub will use to do communications
+   * @param callOptions the runtime call options to be applied to every call on this stub
+   */
+  public static <T extends AbstractStub<T>> T newStub(
+      StubFactory<T> factory, Channel channel, CallOptions callOptions) {
+    return factory.newStub(channel, callOptions);
+  }
+
   /**
    * Returns a new stub with an absolute deadline.
    *
    * <p>This is mostly used for propagating an existing deadline. {@link #withDeadlineAfter} is the
    * recommended way of setting a new deadline,
    *
+   * @since 1.0.0
    * @param deadline the deadline or {@code null} for unsetting the deadline.
    */
   public final S withDeadline(@Nullable Deadline deadline) {
@@ -113,29 +145,51 @@ public final S withDeadline(@Nullable Deadline deadline) {
   /**
    * Returns a new stub with a deadline that is after the given {@code duration} from now.
    *
+   * @since 1.0.0
    * @see CallOptions#withDeadlineAfter
    */
   public final S withDeadlineAfter(long duration, TimeUnit unit) {
     return build(channel, callOptions.withDeadlineAfter(duration, unit));
   }
 
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11657")
+  @IgnoreJRERequirement
+  public final S withDeadlineAfter(Duration duration) {
+    return withDeadlineAfter(convert(duration), TimeUnit.NANOSECONDS);
+  }
+
+  /**
+   * Returns a new stub with the given executor that is to be used instead of the default one
+   * specified with {@link ManagedChannelBuilder#executor}. Note that setting this option may not
+   * take effect for blocking calls.
+   *
+   * @since 1.8.0
+   */
+  public final S withExecutor(Executor executor) {
+    return build(channel, callOptions.withExecutor(executor));
+  }
+
   /**
    *  Set's the compressor name to use for the call.  It is the responsibility of the application
    *  to make sure the server supports decoding the compressor picked by the client.  To be clear,
-   *  this is the compressor used by the stub to compress messages to the server.  To get
-   *  compressed responses from the server, set the appropriate {@link io.grpc.DecompressorRegistry}
-   *  on the {@link io.grpc.ManagedChannelBuilder}.
+   *  this is the compressor used by the stub to compress messages to the server.
    *
+   * @since 1.0.0
    * @param compressorName the name (e.g. "gzip") of the compressor to use.
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1704")
   public final S withCompression(String compressorName) {
     return build(channel, callOptions.withCompression(compressorName));
   }
 
   /**
    * Returns a new stub that uses the given channel.
+   *
+   * <p>This method is vestigial and is unlikely to be useful.  Instead, users should prefer to
+   * use {@link #withInterceptors}.
+   *
+   * @since 1.0.0
    */
+  @Deprecated // use withInterceptors() instead
   public final S withChannel(Channel newChannel) {
     return build(newChannel, callOptions);
   }
@@ -143,6 +197,8 @@ public final S withChannel(Channel newChannel) {
   /**
    * Sets a custom option to be passed to client interceptors on the channel
    * {@link io.grpc.ClientInterceptor} via the CallOptions parameter.
+   *
+   * @since 1.0.0
    * @param key the option being set
    * @param value the value for the key
    */
@@ -153,6 +209,8 @@ public final <T> S withOption(CallOptions.Key<T> key, T value) {
 
   /**
    * Returns a new stub that has the given interceptors attached to the underlying channel.
+   *
+   * @since 1.0.0
    */
   public final S withInterceptors(ClientInterceptor... interceptors) {
     return build(ClientInterceptors.intercept(channel, interceptors), callOptions);
@@ -160,14 +218,22 @@ public final S withInterceptors(ClientInterceptor... interceptors) {
 
   /**
    * Returns a new stub that uses the given call credentials.
+   *
+   * @since 1.0.0
    */
-  @ExperimentalApi("https//github.com/grpc/grpc-java/issues/1914")
   public final S withCallCredentials(CallCredentials credentials) {
     return build(channel, callOptions.withCallCredentials(credentials));
   }
 
   /**
-   * Returns a new stub that uses the 'wait for ready' call option.
+   * Returns a new stub that uses
+   * <a href="https://github.com/grpc/grpc/blob/master/doc/wait-for-ready.md">'wait for ready'</a>
+   * for the call. Wait-for-ready queues the RPC until a connection is available. This may
+   * dramatically increase the latency of the RPC, but avoids failing "unnecessarily." The default
+   * queues the RPC until an attempt to connect has completed, but fails RPCs without sending them
+   * if unable to connect.
+   *
+   * @since 1.1.0
    */
   public final S withWaitForReady() {
     return build(channel, callOptions.withWaitForReady());
@@ -177,6 +243,8 @@ public final S withWaitForReady() {
    * Returns a new stub that limits the maximum acceptable message size from a remote peer.
    *
    * <p>If unset, the {@link ManagedChannelBuilder#maxInboundMessageSize(int)} limit is used.
+   *
+   * @since 1.1.0
    */
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2563")
   public final S withMaxInboundMessageSize(int maxSize) {
@@ -185,9 +253,30 @@ public final S withMaxInboundMessageSize(int maxSize) {
 
   /**
    * Returns a new stub that limits the maximum acceptable message size to send a remote peer.
+   *
+   * @since 1.1.0
    */
   @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2563")
   public final S withMaxOutboundMessageSize(int maxSize) {
     return build(channel, callOptions.withMaxOutboundMessageSize(maxSize));
   }
+
+  /**
+   * Returns a new stub that limits the maximum number of bytes per stream in the queue.
+   *
+   * @since 1.1.0
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11021")
+  public final S withOnReadyThreshold(int numBytes) {
+    return build(channel, callOptions.withOnReadyThreshold(numBytes));
+  }
+
+  /**
+   * A factory class for stub.
+   *
+   * @since 1.26.0
+   */
+  public interface StubFactory<T extends AbstractStub<T>> {
+    T newStub(Channel channel, CallOptions callOptions);
+  }
 }
diff --git a/stub/src/main/java/io/grpc/stub/BlockingClientCall.java b/stub/src/main/java/io/grpc/stub/BlockingClientCall.java
new file mode 100644
index 00000000000..6a52ce50776
--- /dev/null
+++ b/stub/src/main/java/io/grpc/stub/BlockingClientCall.java
@@ -0,0 +1,352 @@
+/*
+ * Copyright 2023 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.stub;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Predicate;
+import io.grpc.ClientCall;
+import io.grpc.ExperimentalApi;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.stub.ClientCalls.ThreadSafeThreadlessExecutor;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Represents a bidirectional streaming call from a client.  Allows in a blocking manner, sending
+ * over the stream and receiving from the stream.  Also supports terminating the call.
+ * Wraps a ClientCall and converts from async communication to the sync paradigm used by the
+ * various blocking stream methods in {@link ClientCalls} which are used by the generated stubs.
+ *
+ * <p>Supports separate threads for reads and writes, but only 1 of each
+ *
+ * <p>Read methods consist of:
+ * <ul>
+ *   <li>{@link #read()}
+ *   <li>{@link #read(long timeout, TimeUnit unit)}
+ *   <li>{@link #hasNext()}
+ *   <li>{@link #cancel(String, Throwable)}
+ * </ul>
+ *
+ * <p>Write methods consist of:
+ * <ul>
+ *   <li>{@link #write(Object)}
+ *   <li>{@link #write(Object, long timeout, TimeUnit unit)}
+ *   <li>{@link #halfClose()}
+ * </ul>
+ *
+ * @param <ReqT> Type of the Request Message
+ * @param <RespT> Type of the Response Message
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+public final class BlockingClientCall<ReqT, RespT> {
+
+  private static final Logger logger = Logger.getLogger(BlockingClientCall.class.getName());
+
+  private final BlockingQueue<RespT> buffer;
+  private final ClientCall<ReqT, RespT> call;
+
+  private final ThreadSafeThreadlessExecutor executor;
+
+  private boolean writeClosed;
+  private AtomicReference<CloseState> closeState = new AtomicReference<>();
+
+  BlockingClientCall(ClientCall<ReqT, RespT> call, ThreadSafeThreadlessExecutor executor) {
+    this.call = call;
+    this.executor = executor;
+    buffer = new ArrayBlockingQueue<>(1);
+  }
+
+  /**
+   * Wait if necessary for a value to be available from the server. If there is an available value
+   * return it immediately, if the stream is closed return a null. Otherwise, wait for a value to be
+   * available or the stream to be closed
+   *
+   * @return value from server or null if stream has been closed
+   * @throws StatusException If the stream has closed in an error state
+   */
+  public RespT read() throws InterruptedException, StatusException {
+    try {
+      return read(true, 0);
+    } catch (TimeoutException e) {
+      throw new AssertionError("should never happen", e);
+    }
+  }
+
+  /**
+   * Wait with timeout, if necessary, for a value to be available from the server. If there is an
+   * available value, return it immediately.  If the stream is closed return a null. Otherwise, wait
+   * for a value to be available, the stream to be closed or the timeout to expire.
+   *
+   * @param timeout how long to wait before giving up.  Values &lt;= 0 are no wait
+   * @param unit a TimeUnit determining how to interpret the timeout parameter
+   * @return value from server or null (if stream has been closed)
+   * @throws TimeoutException if no read becomes ready before the specified timeout expires
+   * @throws StatusException If the stream has closed in an error state
+   */
+  public RespT read(long timeout, TimeUnit unit) throws InterruptedException, TimeoutException,
+      StatusException {
+    long endNanoTime = System.nanoTime() + unit.toNanos(timeout);
+    return read(false, endNanoTime);
+  }
+
+  private RespT read(boolean waitForever, long endNanoTime)
+      throws InterruptedException, TimeoutException, StatusException {
+    Predicate<BlockingClientCall<ReqT, RespT>> predicate = BlockingClientCall::skipWaitingForRead;
+    executor.waitAndDrainWithTimeout(waitForever, endNanoTime, predicate, this);
+    RespT bufferedValue = buffer.poll();
+
+    if (logger.isLoggable(Level.FINER)) {
+      logger.finer("Client Blocking read had value:  " + bufferedValue);
+    }
+
+    CloseState currentCloseState;
+    if (bufferedValue != null) {
+      call.request(1);
+      return bufferedValue;
+    } else if ((currentCloseState = closeState.get()) == null) {
+      throw new IllegalStateException(
+          "The message disappeared... are you reading from multiple threads?");
+    } else if (!currentCloseState.status.isOk()) {
+      throw currentCloseState.status.asException(currentCloseState.trailers);
+    } else {
+      return null;
+    }
+  }
+
+  boolean skipWaitingForRead() {
+    return closeState.get() != null || !buffer.isEmpty();
+  }
+
+  /**
+   * Wait for a value to be available from the server. If there is an
+   * available value, return true immediately.  If the stream was closed with Status.OK, return
+   * false.  If the stream was closed with an error status, throw a StatusException. Otherwise, wait
+   * for a value to be available or the stream to be closed.
+   *
+   * @return True when there is a value to read.  Return false if stream closed cleanly.
+   * @throws StatusException If the stream was closed in an error state
+   */
+  public boolean hasNext() throws InterruptedException, StatusException {
+    executor.waitAndDrain((x) -> !x.buffer.isEmpty() || x.closeState.get() != null, this);
+
+    CloseState currentCloseState = closeState.get();
+    if (currentCloseState != null && !currentCloseState.status.isOk()) {
+      throw currentCloseState.status.asException(currentCloseState.trailers);
+    }
+
+    return !buffer.isEmpty();
+  }
+
+  /**
+   * Send a value to the stream for sending to server, wait if necessary for the grpc stream to be
+   * ready.
+   *
+   * <p>If write is not legal at the time of call, immediately returns false
+   *
+   * <p><br><b>NOTE: </b>This method will return as soon as it passes the request to the grpc stream
+   * layer. It will not block while the message is being sent on the wire and returning true does
+   * not guarantee that the server gets the message.
+   *
+   * <p><br><b>WARNING: </b>Doing only writes without reads can lead to deadlocks.  This is because
+   * flow control, imposed by networks to protect intermediary routers and endpoints that are
+   * operating under resource constraints, requires reads to be done in order to progress writes.
+   * Furthermore, the server closing the stream will only be identified after
+   * the last sent value is read.
+   *
+   * @param request Message to send to the server
+   * @return true if the request is sent to stream, false if skipped
+   * @throws StatusException If the stream has closed in an error state
+   */
+  public boolean write(ReqT request) throws InterruptedException, StatusException {
+    try {
+      return write(true, request, 0);
+    } catch (TimeoutException e) {
+      throw new RuntimeException(e); // should never happen
+    }
+  }
+
+  /**
+   * Send a value to the stream for sending to server, wait if necessary for the grpc stream to be
+   * ready up to specified timeout.
+   *
+   * <p>If write is not legal at the time of call, immediately returns false
+   *
+   * <p><br><b>NOTE: </b>This method will return as soon as it passes the request to the grpc stream
+   * layer. It will not block while the message is being sent on the wire and returning true does
+   * not guarantee that the server gets the message.
+   *
+   * <p><br><b>WARNING: </b>Doing only writes without reads can lead to deadlocks as a result of
+   * flow control.  Furthermore, the server closing the stream will only be identified after the
+   * last sent value is read.
+   *
+   * @param request Message to send to the server
+   * @param timeout How long to wait before giving up.  Values &lt;= 0 are no wait
+   * @param unit A TimeUnit determining how to interpret the timeout parameter
+   * @return true if the request is sent to stream, false if skipped
+   * @throws TimeoutException if write does not become ready before the specified timeout expires
+   * @throws StatusException If the stream has closed in an error state
+   */
+  public boolean write(ReqT request, long timeout, TimeUnit unit)
+      throws InterruptedException, TimeoutException, StatusException {
+    long endNanoTime = System.nanoTime() + unit.toNanos(timeout);
+    return write(false, request, endNanoTime);
+  }
+
+  private boolean write(boolean waitForever, ReqT request, long endNanoTime)
+      throws InterruptedException, TimeoutException, StatusException {
+
+    if (writeClosed) {
+      throw new IllegalStateException("Writes cannot be done after calling halfClose or cancel");
+    }
+
+    Predicate<BlockingClientCall<ReqT, RespT>> predicate =
+        (x) -> x.call.isReady() || x.closeState.get() != null;
+    executor.waitAndDrainWithTimeout(waitForever, endNanoTime, predicate, this);
+    CloseState savedCloseState = closeState.get();
+    if (savedCloseState == null) {
+      call.sendMessage(request);
+      return true;
+    } else if (savedCloseState.status.isOk()) {
+      return false;
+    } else {
+      throw savedCloseState.status.asException(savedCloseState.trailers);
+    }
+  }
+
+  void sendSingleRequest(ReqT request) {
+    call.sendMessage(request);
+  }
+
+  /**
+   * Cancel stream and stop any further writes.  Note that some reads that are in flight may still
+   * happen after the cancel.
+   *
+   * @param message if not {@code null}, will appear as the description of the CANCELLED status
+   * @param cause if not {@code null}, will appear as the cause of the CANCELLED status
+   */
+  public void cancel(String message, Throwable cause) {
+    writeClosed = true;
+    call.cancel(message, cause);
+  }
+
+  /**
+   * Indicate that no more writes will be done and the stream will be closed from the client side.
+   *
+   * @see ClientCall#halfClose()
+   */
+  public void halfClose() {
+    if (writeClosed) {
+      throw new IllegalStateException(
+          "halfClose cannot be called after already half closed or cancelled");
+    }
+
+    writeClosed = true;
+    call.halfClose();
+  }
+
+  /**
+   * Status that server sent when closing channel from its side.
+   *
+   * @return null if stream not closed by server, otherwise Status sent by server
+   */
+  @VisibleForTesting
+  Status getClosedStatus() {
+    executor.drain();
+    CloseState state = closeState.get();
+    return (state == null) ? null : state.status;
+  }
+
+  /**
+   * Check for whether some action is ready.
+   *
+   * @return True if legal to write and writeOrRead can run without blocking
+   */
+  @VisibleForTesting
+  boolean isEitherReadOrWriteReady() {
+    return (isWriteLegal() && isWriteReady()) || isReadReady();
+  }
+
+  /**
+   * Check whether there are any values waiting to be read.
+   *
+   * @return true if read will not block
+   */
+  @VisibleForTesting
+  boolean isReadReady() {
+    executor.drain();
+
+    return !buffer.isEmpty();
+  }
+
+  /**
+   * Check that write hasn't been marked complete and stream is ready to receive a write (so will
+   * not block).
+   *
+   * @return true if legal to write and write will not block
+   */
+  @VisibleForTesting
+  boolean isWriteReady() {
+    executor.drain();
+
+    return isWriteLegal() && call.isReady();
+  }
+
+  /**
+   * Check whether we'll ever be able to do writes or should terminate.
+   * @return True if writes haven't been closed and the server hasn't closed the stream
+   */
+  private boolean isWriteLegal() {
+    return !writeClosed && closeState.get() == null;
+  }
+
+  ClientCall.Listener<RespT> getListener() {
+    return new QueuingListener();
+  }
+
+  private final class QueuingListener extends ClientCall.Listener<RespT> {
+    @Override
+    public void onMessage(RespT value) {
+      Preconditions.checkState(closeState.get() == null, "ClientCall already closed");
+      buffer.add(value);
+    }
+
+    @Override
+    public void onClose(Status status, Metadata trailers) {
+      CloseState newCloseState = new CloseState(status, trailers);
+      boolean wasSet = closeState.compareAndSet(null, newCloseState);
+      Preconditions.checkState(wasSet, "ClientCall already closed");
+    }
+  }
+
+  private static final class CloseState {
+    final Status status;
+    final Metadata trailers;
+
+    CloseState(Status status, Metadata trailers) {
+      this.status = Preconditions.checkNotNull(status, "status");
+      this.trailers = trailers;
+    }
+  }
+}
diff --git a/stub/src/main/java/io/grpc/stub/CallStreamObserver.java b/stub/src/main/java/io/grpc/stub/CallStreamObserver.java
index 67003181a30..52dd046831d 100644
--- a/stub/src/main/java/io/grpc/stub/CallStreamObserver.java
+++ b/stub/src/main/java/io/grpc/stub/CallStreamObserver.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
@@ -34,28 +19,50 @@
 import io.grpc.ExperimentalApi;
 
 /**
- * A refinement of StreamObserver provided by the GRPC runtime to the application that allows for
- * more complex interactions with call behavior.
+ * A refinement of StreamObserver provided by the GRPC runtime to the application (the client or
+ * the server) that allows for more complex interactions with call behavior.
  *
- * <p>In any call there are logically two {@link StreamObserver} implementations:
+ * <p>In any call there are logically four {@link StreamObserver} implementations:
  * <ul>
- *   <li>'inbound' - which the GRPC runtime calls when it receives messages from the
- *   remote peer. This is implemented by the application.
+ *   <li>'inbound', client-side - which the GRPC runtime calls when it receives messages from
+ *   the server. This is implemented by the client application and passed into a service method
+ *   on a stub object.
+ *   </li>
+ *   <li>'outbound', client-side - which the GRPC runtime provides to the client application and the
+ *   client uses this {@code StreamObserver} to send messages to the server.
+ *   </li>
+ *   <li>'inbound', server-side - which the GRPC runtime calls when it receives messages from
+ *   the client. This is implemented by the server application and returned from service
+ *   implementations of client-side streaming and bidirectional streaming methods.
  *   </li>
- *   <li>'outbound' - which the GRPC runtime provides to the application which it uses to
- *   send messages to the remote peer.
+ *   <li>'outbound', server-side - which the GRPC runtime provides to the server application and
+ *   the server uses this {@code StreamObserver} to send messages (responses) to the client.
  *   </li>
  * </ul>
  *
- * <p>Implementations of this class represent the 'outbound' message stream.
+ * <p>Implementations of this class represent the 'outbound' message streams. The client-side
+ * one is {@link ClientCallStreamObserver} and the service-side one is
+ * {@link ServerCallStreamObserver}.
+ *
+ * <p>Like {@code StreamObserver}, implementations are not required to be thread-safe; if multiple
+ * threads will be writing to an instance concurrently, the application must synchronize its calls.
+ *
+ * <p>DO NOT MOCK: The API is too complex to reliably mock. Use InProcessChannelBuilder to create
+ * "real" RPCs suitable for testing.
  *
+ * @param <V> type of outbound message.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1788")
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/8499")
 public abstract class CallStreamObserver<V> implements StreamObserver<V> {
 
   /**
-   * If {@code true} indicates that a call to {@link #onNext(Object)} will not require the entire
-   * message to be buffered before it is sent to the peer.
+   * If {@code true}, indicates that the observer is capable of sending additional messages
+   * without requiring excessive buffering internally. This value is just a suggestion and the
+   * application is free to ignore it, however doing so may result in excessive buffering within the
+   * observer.
+   *
+   * <p>If {@code false}, the runnable passed to {@link #setOnReadyHandler} will be called after
+   * {@code isReady()} transitions to {@code true}.
    */
   public abstract boolean isReady();
 
@@ -65,8 +72,15 @@ public abstract class CallStreamObserver<V> implements StreamObserver<V> {
    * thread will always be used to execute the {@link Runnable}, it is guaranteed that executions
    * are serialized with calls to the 'inbound' {@link StreamObserver}.
    *
-   * <p>Note that the handler may be called some time after {@link #isReady} has transitioned to
-   * true as other callbacks may still be executing in the 'inbound' observer.
+   * <p>On client-side this method may only be called during {@link
+   * ClientResponseObserver#beforeStart}. On server-side it may only be called during the initial
+   * call to the application, before the service returns its {@code StreamObserver}.
+   *
+   * <p>Because there is a processing delay to deliver this notification, it is possible for
+   * concurrent writes to cause {@code isReady() == false} within this callback. Handle "spurious"
+   * notifications by checking {@code isReady()}'s current value instead of assuming it is now
+   * {@code true}. If {@code isReady() == false} the normal expectations apply, so there would be
+   * <em>another</em> {@code onReadyHandler} callback.
    *
    * @param onReadyHandler to call when peer is ready to receive more messages.
    */
@@ -77,6 +91,10 @@ public abstract class CallStreamObserver<V> implements StreamObserver<V> {
    * to the 'inbound' {@link io.grpc.stub.StreamObserver#onNext(Object)} has completed. If disabled
    * an application must make explicit calls to {@link #request} to receive messages.
    *
+   * <p>On client-side this method may only be called during {@link
+   * ClientResponseObserver#beforeStart}. On server-side it may only be called during the initial
+   * call to the application, before the service returns its {@code StreamObserver}.
+   *
    * <p>Note that for cases where the runtime knows that only one inbound message is allowed
    * calling this method will have no effect and the runtime will always permit one and only
    * one message. This is true for:
@@ -84,18 +102,25 @@ public abstract class CallStreamObserver<V> implements StreamObserver<V> {
    *   <li>{@link io.grpc.MethodDescriptor.MethodType#UNARY} operations on both the
    *   client and server.
    *   </li>
-   *   <li>{@link io.grpc.MethodDescriptor.MethodType#CLIENT_STREAMING} operations on the server.
+   *   <li>{@link io.grpc.MethodDescriptor.MethodType#CLIENT_STREAMING} operations on the client.
    *   </li>
-   *   <li>{@link io.grpc.MethodDescriptor.MethodType#SERVER_STREAMING} operations on the client.
+   *   <li>{@link io.grpc.MethodDescriptor.MethodType#SERVER_STREAMING} operations on the server.
    *   </li>
    * </ul>
    * </p>
+   * 
+   * <p>This API is being replaced, but is not yet deprecated. On server-side it being replaced
+   * with {@link ServerCallStreamObserver#disableAutoRequest}. On client-side {@link
+   * ClientCallStreamObserver#disableAutoRequestWithInitial disableAutoRequestWithInitial(1)}.
    */
   public abstract void disableAutoInboundFlowControl();
 
   /**
    * Requests the peer to produce {@code count} more messages to be delivered to the 'inbound'
    * {@link StreamObserver}.
+   *
+   * <p>This method is safe to call from multiple threads without external synchronization.
+   *
    * @param count more messages
    */
   public abstract void request(int count);
diff --git a/stub/src/main/java/io/grpc/stub/ClientCallStreamObserver.java b/stub/src/main/java/io/grpc/stub/ClientCallStreamObserver.java
index 4dfb41e7b6a..8f420fa77e4 100644
--- a/stub/src/main/java/io/grpc/stub/ClientCallStreamObserver.java
+++ b/stub/src/main/java/io/grpc/stub/ClientCallStreamObserver.java
@@ -1,42 +1,112 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
 
-import io.grpc.ExperimentalApi;
+import javax.annotation.Nullable;
 
 /**
  * A refinement of {@link CallStreamObserver} that allows for lower-level interaction with
- * client calls.
+ * client calls. An instance of this class is obtained via {@link ClientResponseObserver}, or by
+ * manually casting the {@code StreamObserver} returned by a stub.
+ *
+ * <p>Like {@code StreamObserver}, implementations are not required to be thread-safe; if multiple
+ * threads will be writing to an instance concurrently, the application must synchronize its calls.
+ *
+ * <p>DO NOT MOCK: The API is too complex to reliably mock. Use InProcessChannelBuilder to create
+ * "real" RPCs suitable for testing and make a fake for the server-side.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1788")
-public abstract class ClientCallStreamObserver<V> extends CallStreamObserver<V> {
+public abstract class ClientCallStreamObserver<ReqT> extends CallStreamObserver<ReqT> {
+  /**
+   * Prevent any further processing for this {@code ClientCallStreamObserver}. No further messages
+   * will be received. The server is informed of cancellations, but may not stop processing the
+   * call. Cancelling an already
+   * {@code cancel()}ed {@code ClientCallStreamObserver} has no effect.
+   *
+   * <p>No other methods on this class can be called after this method has been called.
+   *
+   * <p>It is recommended that at least one of the arguments to be non-{@code null}, to provide
+   * useful debug information. Both argument being null may log warnings and result in suboptimal
+   * performance. Also note that the provided information will not be sent to the server.
+   *
+   * @param message if not {@code null}, will appear as the description of the CANCELLED status
+   * @param cause if not {@code null}, will appear as the cause of the CANCELLED status
+   */
+  public abstract void cancel(@Nullable String message, @Nullable Throwable cause);
+
+  /**
+   * Swaps to manual flow control where no message will be delivered to {@link
+   * StreamObserver#onNext(Object)} unless it is {@link #request request()}ed. Since {@code
+   * request()} may not be called before the call is started, a number of initial requests may be
+   * specified.
+   *
+   * <p>This method may only be called during {@link ClientResponseObserver#beforeStart
+   * ClientResponseObserver.beforeStart()}.
+   */
+  public void disableAutoRequestWithInitial(int request) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * If {@code true}, indicates that the observer is capable of sending additional messages
+   * without requiring excessive buffering internally. This value is just a suggestion and the
+   * application is free to ignore it, however doing so may result in excessive buffering within the
+   * observer.
+   *
+   * <p>If {@code false}, the runnable passed to {@link #setOnReadyHandler} will be called after
+   * {@code isReady()} transitions to {@code true}.
+   */
+  @Override
+  public abstract boolean isReady();
+
+  /**
+   * Set a {@link Runnable} that will be executed every time the stream {@link #isReady()} state
+   * changes from {@code false} to {@code true}.  While it is not guaranteed that the same
+   * thread will always be used to execute the {@link Runnable}, it is guaranteed that executions
+   * are serialized with calls to the 'inbound' {@link StreamObserver}.
+   *
+   * <p>May only be called during {@link ClientResponseObserver#beforeStart}.
+   *
+   * <p>Because there is a processing delay to deliver this notification, it is possible for
+   * concurrent writes to cause {@code isReady() == false} within this callback. Handle "spurious"
+   * notifications by checking {@code isReady()}'s current value instead of assuming it is now
+   * {@code true}. If {@code isReady() == false} the normal expectations apply, so there would be
+   * <em>another</em> {@code onReadyHandler} callback.
+   *
+   * @param onReadyHandler to call when peer is ready to receive more messages.
+   */
+  @Override
+  public abstract void setOnReadyHandler(Runnable onReadyHandler);
+
+  /**
+   * Requests the peer to produce {@code count} more messages to be delivered to the 'inbound'
+   * {@link StreamObserver}.
+   *
+   * <p>This method is safe to call from multiple threads without external synchronization.
+   *
+   * @param count more messages
+   */
+  @Override
+  public abstract void request(int count);
+
+  /**
+   * Sets message compression for subsequent calls to {@link #onNext}.
+   *
+   * @param enable whether to enable compression.
+   */
+  @Override
+  public abstract void setMessageCompression(boolean enable);
 }
diff --git a/stub/src/main/java/io/grpc/stub/ClientCalls.java b/stub/src/main/java/io/grpc/stub/ClientCalls.java
index 877cc25518f..ff2804a0a1f 100644
--- a/stub/src/main/java/io/grpc/stub/ClientCalls.java
+++ b/stub/src/main/java/io/grpc/stub/ClientCalls.java
@@ -1,44 +1,35 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
 
 import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
 
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
 import com.google.common.base.Preconditions;
+import com.google.common.base.Predicate;
+import com.google.common.base.Strings;
 import com.google.common.util.concurrent.AbstractFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import io.grpc.CallOptions;
 import io.grpc.Channel;
 import io.grpc.ClientCall;
+import io.grpc.ExperimentalApi;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.Status;
@@ -48,12 +39,19 @@
 import java.util.NoSuchElementException;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Future;
-import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.LockSupport;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 /**
@@ -62,99 +60,158 @@
  * that the runtime can vary behavior without requiring regeneration of the stub.
  */
 public final class ClientCalls {
-  private static final Logger log = Logger.getLogger(ClientCalls.class.getName());
+
+  private static final Logger logger = Logger.getLogger(ClientCalls.class.getName());
+
+  @VisibleForTesting
+  static boolean rejectRunnableOnExecutor =
+      !Strings.isNullOrEmpty(System.getenv("GRPC_CLIENT_CALL_REJECT_RUNNABLE"))
+          && Boolean.parseBoolean(System.getenv("GRPC_CLIENT_CALL_REJECT_RUNNABLE"));
 
   // Prevent instantiation
   private ClientCalls() {}
 
   /**
-   * Executes a unary call with a response {@link StreamObserver}.
+   * Executes a unary call with a response {@link StreamObserver}.  The {@code call} should not be
+   * already started.  After calling this method, {@code call} should no longer be used.
+   *
+   * <p>If the provided {@code responseObserver} is an instance of {@link ClientResponseObserver},
+   * {@code beforeStart()} will be called.
    */
   public static <ReqT, RespT> void asyncUnaryCall(
-      ClientCall<ReqT, RespT> call,
-      ReqT param,
-      StreamObserver<RespT> observer) {
-    asyncUnaryRequestCall(call, param, observer, false);
+      ClientCall<ReqT, RespT> call, ReqT req, StreamObserver<RespT> responseObserver) {
+    checkNotNull(responseObserver, "responseObserver");
+    asyncUnaryRequestCall(call, req, responseObserver, false);
   }
 
   /**
-   * Executes a server-streaming call with a response {@link StreamObserver}.
+   * Executes a server-streaming call with a response {@link StreamObserver}.  The {@code call}
+   * should not be already started.  After calling this method, {@code call} should no longer be
+   * used.
+   *
+   * <p>If the provided {@code responseObserver} is an instance of {@link ClientResponseObserver},
+   * {@code beforeStart()} will be called.
    */
   public static <ReqT, RespT> void asyncServerStreamingCall(
-      ClientCall<ReqT, RespT> call,
-      ReqT param,
-      StreamObserver<RespT> responseObserver) {
-    asyncUnaryRequestCall(call, param, responseObserver, true);
+      ClientCall<ReqT, RespT> call, ReqT req, StreamObserver<RespT> responseObserver) {
+    checkNotNull(responseObserver, "responseObserver");
+    asyncUnaryRequestCall(call, req, responseObserver, true);
   }
 
   /**
    * Executes a client-streaming call returning a {@link StreamObserver} for the request messages.
-   * @return request stream observer.
+   * The {@code call} should not be already started.  After calling this method, {@code call}
+   * should no longer be used.
+   *
+   * <p>If the provided {@code responseObserver} is an instance of {@link ClientResponseObserver},
+   * {@code beforeStart()} will be called.
+   *
+   * @return request stream observer. It will extend {@link ClientCallStreamObserver}
    */
   public static <ReqT, RespT> StreamObserver<ReqT> asyncClientStreamingCall(
       ClientCall<ReqT, RespT> call,
       StreamObserver<RespT> responseObserver) {
+    checkNotNull(responseObserver, "responseObserver");
     return asyncStreamingRequestCall(call, responseObserver, false);
   }
 
   /**
-   * Executes a bidi-streaming call.
-   * @return request stream observer.
+   * Executes a bidirectional-streaming call.  The {@code call} should not be already started.
+   * After calling this method, {@code call} should no longer be used.
+   *
+   * <p>If the provided {@code responseObserver} is an instance of {@link ClientResponseObserver},
+   * {@code beforeStart()} will be called.
+   *
+   * @return request stream observer. It will extend {@link ClientCallStreamObserver}
    */
   public static <ReqT, RespT> StreamObserver<ReqT> asyncBidiStreamingCall(
       ClientCall<ReqT, RespT> call, StreamObserver<RespT> responseObserver) {
+    checkNotNull(responseObserver, "responseObserver");
     return asyncStreamingRequestCall(call, responseObserver, true);
   }
 
   /**
-   * Executes a unary call and blocks on the response.
+   * Executes a unary call and blocks on the response.  The {@code call} should not be already
+   * started.  After calling this method, {@code call} should no longer be used.
+   *
    * @return the single response message.
+   * @throws StatusRuntimeException on error
    */
-  public static <ReqT, RespT> RespT blockingUnaryCall(ClientCall<ReqT, RespT> call, ReqT param) {
+  public static <ReqT, RespT> RespT blockingUnaryCall(ClientCall<ReqT, RespT> call, ReqT req) {
     try {
-      return getUnchecked(futureUnaryCall(call, param));
-    } catch (Throwable t) {
-      call.cancel(null, t);
-      throw t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
+      return getUnchecked(futureUnaryCall(call, req));
+    } catch (RuntimeException | Error e) {
+      throw cancelThrow(call, e);
     }
   }
 
   /**
-   * Executes a unary call and blocks on the response.
+   * Executes a unary call and blocks on the response.  The {@code call} should not be already
+   * started.  After calling this method, {@code call} should no longer be used.
    *
    * @return the single response message.
+   * @throws StatusRuntimeException on error
    */
   public static <ReqT, RespT> RespT blockingUnaryCall(
-      Channel channel, MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, ReqT param) {
+      Channel channel, MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, ReqT req) {
     ThreadlessExecutor executor = new ThreadlessExecutor();
-    ClientCall<ReqT, RespT> call = channel.newCall(method, callOptions.withExecutor(executor));
+    boolean interrupt = false;
+    ClientCall<ReqT, RespT> call = channel.newCall(method,
+        callOptions.withOption(ClientCalls.STUB_TYPE_OPTION, StubType.BLOCKING)
+            .withExecutor(executor));
     try {
-      ListenableFuture<RespT> responseFuture = futureUnaryCall(call, param);
+      ListenableFuture<RespT> responseFuture = futureUnaryCall(call, req);
       while (!responseFuture.isDone()) {
         try {
           executor.waitAndDrain();
         } catch (InterruptedException e) {
-          Thread.currentThread().interrupt();
-          throw Status.CANCELLED.withCause(e).asRuntimeException();
+          interrupt = true;
+          call.cancel("Thread interrupted", e);
+          // Now wait for onClose() to be called, so interceptors can clean up
         }
       }
+      executor.shutdown();
       return getUnchecked(responseFuture);
-    } catch (Throwable t) {
-      call.cancel(null, t);
-      throw t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
+    } catch (RuntimeException | Error e) {
+      // Something very bad happened. All bets are off; it may be dangerous to wait for onClose().
+      throw cancelThrow(call, e);
+    } finally {
+      if (interrupt) {
+        Thread.currentThread().interrupt();
+      }
+    }
+  }
+
+  /**
+   * Executes a unary call and blocks on the response,
+   * throws a checked {@link StatusException}.
+   *
+   * @return the single response message.
+   * @throws StatusException on error
+   */
+  public static <ReqT, RespT> RespT blockingV2UnaryCall(
+      Channel channel, MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, ReqT req)
+      throws StatusException {
+    try {
+      return blockingUnaryCall(channel, method, callOptions, req);
+    } catch (StatusRuntimeException e) {
+      throw e.getStatus().asException(e.getTrailers());
     }
   }
 
   /**
    * Executes a server-streaming call returning a blocking {@link Iterator} over the
-   * response stream.
+   * response stream.  The {@code call} should not be already started.  After calling this method,
+   * {@code call} should no longer be used.
+   *
+   * <p>The returned iterator may throw {@link StatusRuntimeException} on error.
+   *
    * @return an iterator over the response stream.
    */
-  // TODO(louiscryan): Not clear if we want to use this idiom for 'simple' stubs.
   public static <ReqT, RespT> Iterator<RespT> blockingServerStreamingCall(
-      ClientCall<ReqT, RespT> call, ReqT param) {
-    BlockingResponseStream<RespT> result = new BlockingResponseStream<RespT>(call);
-    asyncUnaryRequestCall(call, param, result.listener(), true);
+      ClientCall<ReqT, RespT> call, ReqT req) {
+    BlockingResponseStream<RespT> result = new BlockingResponseStream<>(call);
+    asyncUnaryRequestCall(call, req, result.listener());
     return result;
   }
 
@@ -162,33 +219,114 @@ public static <ReqT, RespT> Iterator<RespT> blockingServerStreamingCall(
    * Executes a server-streaming call returning a blocking {@link Iterator} over the
    * response stream.
    *
+   * <p>The returned iterator may throw {@link StatusRuntimeException} on error.
+   *
+   * <p>Warning:  the iterator can result in leaks if not completely consumed.
+   *
    * @return an iterator over the response stream.
    */
-  // TODO(louiscryan): Not clear if we want to use this idiom for 'simple' stubs.
   public static <ReqT, RespT> Iterator<RespT> blockingServerStreamingCall(
-      Channel channel, MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, ReqT param) {
-    ThreadlessExecutor executor = new ThreadlessExecutor();
-    ClientCall<ReqT, RespT> call = channel.newCall(method, callOptions.withExecutor(executor));
-    BlockingResponseStream<RespT> result = new BlockingResponseStream<RespT>(call, executor);
-    asyncUnaryRequestCall(call, param, result.listener(), true);
+      Channel channel, MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, ReqT req) {
+    ClientCall<ReqT, RespT> call = channel.newCall(method,
+        callOptions.withOption(ClientCalls.STUB_TYPE_OPTION, StubType.BLOCKING));
+
+    BlockingResponseStream<RespT> result = new BlockingResponseStream<>(call);
+    asyncUnaryRequestCall(call, req, result.listener());
     return result;
   }
 
   /**
-   * Executes a unary call and returns a {@link ListenableFuture} to the response.
+   * Initiates a client streaming call over the specified channel.  It returns an
+   * object which can be used in a blocking manner to retrieve responses..
+   *
+   * <p>The methods {@link BlockingClientCall#hasNext()} and {@link
+   * BlockingClientCall#cancel(String, Throwable)} can be used for more extensive control.
+   *
+   * @return A {@link BlockingClientCall} that has had the request sent and halfClose called
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+  public static <ReqT, RespT> BlockingClientCall<ReqT, RespT> blockingV2ServerStreamingCall(
+      Channel channel, MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, ReqT req) {
+    BlockingClientCall<ReqT, RespT> call =
+        blockingBidiStreamingCall(channel, method, callOptions);
+
+    call.sendSingleRequest(req);
+    call.halfClose();
+    return call;
+  }
+
+  /**
+   * Initiates a server streaming call and sends the specified request to the server.  It returns an
+   * object which can be used in a blocking manner to retrieve values from the server.  After the
+   * last value has been read, the next read call will return null.
+   *
+   * <p>Call {@link BlockingClientCall#read()} for
+   * retrieving values.  A {@code null} will be returned after the server has closed the stream.
+   *
+   * <p>The methods {@link BlockingClientCall#hasNext()} and {@link
+   * BlockingClientCall#cancel(String, Throwable)} can be used for more extensive control.
+   *
+   * <p><br> Example usage:
+   * <pre> {@code  while ((response = call.read()) != null) { ... } } </pre>
+   * or
+   * <pre> {@code
+   *   while (call.hasNext()) {
+   *     response = call.read();
+   *     ...
+   *   }
+   * } </pre>
+   *
+   * <p>Note that this paradigm is different from the original
+   * {@link #blockingServerStreamingCall(Channel, MethodDescriptor, CallOptions, Object)}
+   * which returns an iterator, which would leave the stream open if not completely consumed.
+   *
+   * @return A {@link BlockingClientCall} which can be used by the client to write and receive
+   *     messages over the grpc channel.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+  public static <ReqT, RespT> BlockingClientCall<ReqT, RespT> blockingClientStreamingCall(
+      Channel channel, MethodDescriptor<ReqT, RespT> method, CallOptions callOptions) {
+    return blockingBidiStreamingCall(channel, method, callOptions);
+  }
+
+  /**
+   * Initiate a bidirectional-streaming {@link ClientCall} and returning a stream object
+   * ({@link BlockingClientCall}) which can be used by the client to send and receive messages over
+   * the grpc channel.
+   *
+   * @return an object representing the call which can be used to read, write and terminate it.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+  public static <ReqT, RespT> BlockingClientCall<ReqT, RespT> blockingBidiStreamingCall(
+      Channel channel, MethodDescriptor<ReqT, RespT> method, CallOptions callOptions) {
+    ThreadSafeThreadlessExecutor executor = new ThreadSafeThreadlessExecutor();
+    ClientCall<ReqT, RespT> call = channel.newCall(method, callOptions.withExecutor(executor));
+
+    BlockingClientCall<ReqT, RespT> blockingClientCall = new BlockingClientCall<>(call, executor);
+
+    // Get the call started
+    call.start(blockingClientCall.getListener(), new Metadata());
+    call.request(1);
+
+    return blockingClientCall;
+  }
+
+  /**
+   * Executes a unary call and returns a {@link ListenableFuture} to the response.  The
+   * {@code call} should not be already started.  After calling this method, {@code call} should no
+   * longer be used.
    *
    * @return a future for the single response message.
    */
   public static <ReqT, RespT> ListenableFuture<RespT> futureUnaryCall(
-      ClientCall<ReqT, RespT> call,
-      ReqT param) {
-    GrpcFuture<RespT> responseFuture = new GrpcFuture<RespT>(call);
-    asyncUnaryRequestCall(call, param, new UnaryStreamToFuture<RespT>(responseFuture), false);
+      ClientCall<ReqT, RespT> call, ReqT req) {
+    GrpcFuture<RespT> responseFuture = new GrpcFuture<>(call);
+    asyncUnaryRequestCall(call, req, new UnaryStreamToFuture<>(responseFuture));
     return responseFuture;
   }
 
   /**
-   * Returns the result of calling {@link Future#get()} interruptably on a task known not to throw a
+   * Returns the result of calling {@link Future#get()} interruptibly on a task known not to throw a
    * checked exception.
    *
    * <p>If interrupted, the interrupt is restored before throwing an exception..
@@ -203,9 +341,12 @@ private static <V> V getUnchecked(Future<V> future) {
       return future.get();
     } catch (InterruptedException e) {
       Thread.currentThread().interrupt();
-      throw Status.CANCELLED.withCause(e).asRuntimeException();
+      throw Status.CANCELLED
+          .withDescription("Thread interrupted")
+          .withCause(e)
+          .asRuntimeException();
     } catch (ExecutionException e) {
-      throw toStatusRuntimeException(e);
+      throw toStatusRuntimeException(e.getCause());
     }
   }
 
@@ -228,63 +369,92 @@ private static StatusRuntimeException toStatusRuntimeException(Throwable t) {
       }
       cause = cause.getCause();
     }
-    return Status.UNKNOWN.withCause(t).asRuntimeException();
+    return Status.UNKNOWN.withDescription("unexpected exception").withCause(t)
+        .asRuntimeException();
+  }
+
+  /**
+   * Cancels a call, and throws the exception.
+   *
+   * @param t must be a RuntimeException or Error
+   */
+  private static RuntimeException cancelThrow(ClientCall<?, ?> call, Throwable t) {
+    try {
+      call.cancel(null, t);
+    } catch (RuntimeException | Error e) {
+      logger.log(Level.SEVERE, "RuntimeException encountered while closing call", e);
+    }
+    if (t instanceof RuntimeException) {
+      throw (RuntimeException) t;
+    } else if (t instanceof Error) {
+      throw (Error) t;
+    }
+    // should be impossible
+    throw new AssertionError(t);
   }
 
   private static <ReqT, RespT> void asyncUnaryRequestCall(
-      ClientCall<ReqT, RespT> call, ReqT param, StreamObserver<RespT> responseObserver,
+      ClientCall<ReqT, RespT> call, ReqT req, StreamObserver<RespT> responseObserver,
       boolean streamingResponse) {
-    asyncUnaryRequestCall(call, param,
-        new StreamObserverToCallListenerAdapter<ReqT, RespT>(call, responseObserver,
-            new CallToStreamObserverAdapter<ReqT>(call),
-            streamingResponse),
-        streamingResponse);
+    asyncUnaryRequestCall(
+        call,
+        req,
+        new StreamObserverToCallListenerAdapter<>(
+            responseObserver,
+            new CallToStreamObserverAdapter<>(call, streamingResponse)));
   }
 
   private static <ReqT, RespT> void asyncUnaryRequestCall(
       ClientCall<ReqT, RespT> call,
-      ReqT param,
-      ClientCall.Listener<RespT> responseListener,
-      boolean streamingResponse) {
-    startCall(call, responseListener, streamingResponse);
+      ReqT req,
+      StartableListener<RespT> responseListener) {
+    startCall(call, responseListener);
     try {
-      call.sendMessage(param);
+      call.sendMessage(req);
       call.halfClose();
-    } catch (Throwable t) {
-      call.cancel(null, t);
-      throw t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
+    } catch (RuntimeException | Error e) {
+      throw cancelThrow(call, e);
     }
   }
 
   private static <ReqT, RespT> StreamObserver<ReqT> asyncStreamingRequestCall(
-      ClientCall<ReqT, RespT> call, StreamObserver<RespT> responseObserver,
+      ClientCall<ReqT, RespT> call,
+      StreamObserver<RespT> responseObserver,
       boolean streamingResponse) {
-    CallToStreamObserverAdapter<ReqT> adapter = new CallToStreamObserverAdapter<ReqT>(call);
-    startCall(call, new StreamObserverToCallListenerAdapter<ReqT, RespT>(
-        call, responseObserver, adapter, streamingResponse), streamingResponse);
+    CallToStreamObserverAdapter<ReqT> adapter = new CallToStreamObserverAdapter<>(
+        call, streamingResponse);
+    startCall(
+        call,
+        new StreamObserverToCallListenerAdapter<>(responseObserver, adapter));
     return adapter;
   }
 
-  private static <ReqT, RespT> void startCall(ClientCall<ReqT, RespT> call,
-      ClientCall.Listener<RespT> responseListener, boolean streamingResponse) {
+  private static <ReqT, RespT> void startCall(
+      ClientCall<ReqT, RespT> call,
+      StartableListener<RespT> responseListener) {
     call.start(responseListener, new Metadata());
-    if (streamingResponse) {
-      call.request(1);
-    } else {
-      // Initially ask for two responses from flow-control so that if a misbehaving server sends
-      // more than one responses, we can catch it and fail it in the listener.
-      call.request(2);
-    }
+    responseListener.onStart();
   }
 
-  private static class CallToStreamObserverAdapter<T> extends ClientCallStreamObserver<T> {
+  private abstract static class StartableListener<T> extends ClientCall.Listener<T> {
+    abstract void onStart();
+  }
+
+  private static final class CallToStreamObserverAdapter<ReqT>
+      extends ClientCallStreamObserver<ReqT> {
     private boolean frozen;
-    private final ClientCall<T, ?> call;
+    private final ClientCall<ReqT, ?> call;
+    private final boolean streamingResponse;
     private Runnable onReadyHandler;
-    private boolean autoFlowControlEnabled = true;
+    private int initialRequest = 1;
+    private boolean autoRequestEnabled = true;
+    private boolean aborted = false;
+    private boolean completed = false;
 
-    public CallToStreamObserverAdapter(ClientCall<T, ?> call) {
+    // Non private to avoid synthetic class
+    CallToStreamObserverAdapter(ClientCall<ReqT, ?> call, boolean streamingResponse) {
       this.call = call;
+      this.streamingResponse = streamingResponse;
     }
 
     private void freeze() {
@@ -292,18 +462,22 @@ private void freeze() {
     }
 
     @Override
-    public void onNext(T value) {
+    public void onNext(ReqT value) {
+      checkState(!aborted, "Stream was terminated by error, no further calls are allowed");
+      checkState(!completed, "Stream is already completed, no further calls are allowed");
       call.sendMessage(value);
     }
 
     @Override
     public void onError(Throwable t) {
       call.cancel("Cancelled by client with StreamObserver.onError()", t);
+      aborted = true;
     }
 
     @Override
     public void onCompleted() {
       call.halfClose();
+      completed = true;
     }
 
     @Override
@@ -314,46 +488,61 @@ public boolean isReady() {
     @Override
     public void setOnReadyHandler(Runnable onReadyHandler) {
       if (frozen) {
-        throw new IllegalStateException("Cannot alter onReadyHandler after call started");
+        throw new IllegalStateException(
+            "Cannot alter onReadyHandler after call started. Use ClientResponseObserver");
       }
       this.onReadyHandler = onReadyHandler;
     }
 
     @Override
     public void disableAutoInboundFlowControl() {
+      disableAutoRequestWithInitial(1);
+    }
+
+    @Override
+    public void disableAutoRequestWithInitial(int request) {
       if (frozen) {
-        throw new IllegalStateException("Cannot disable auto flow control call started");
+        throw new IllegalStateException(
+            "Cannot disable auto flow control after call started. Use ClientResponseObserver");
       }
-      autoFlowControlEnabled = false;
+      Preconditions.checkArgument(request >= 0, "Initial requests must be non-negative");
+      initialRequest = request;
+      autoRequestEnabled = false;
     }
 
     @Override
     public void request(int count) {
-      call.request(count);
+      if (!streamingResponse && count == 1) {
+        // Initially ask for two responses from flow-control so that if a misbehaving server
+        // sends more than one response, we can catch it and fail it in the listener.
+        call.request(2);
+      } else {
+        call.request(count);
+      }
     }
 
     @Override
     public void setMessageCompression(boolean enable) {
       call.setMessageCompression(enable);
     }
+
+    @Override
+    public void cancel(@Nullable String message, @Nullable Throwable cause) {
+      call.cancel(message, cause);
+    }
   }
 
-  private static class StreamObserverToCallListenerAdapter<ReqT, RespT>
-      extends ClientCall.Listener<RespT> {
-    private final ClientCall<ReqT, RespT> call;
+  private static final class StreamObserverToCallListenerAdapter<ReqT, RespT>
+      extends StartableListener<RespT> {
     private final StreamObserver<RespT> observer;
     private final CallToStreamObserverAdapter<ReqT> adapter;
-    private final boolean streamingResponse;
     private boolean firstResponseReceived;
 
+    // Non private to avoid synthetic class
     StreamObserverToCallListenerAdapter(
-        ClientCall<ReqT, RespT> call,
         StreamObserver<RespT> observer,
-        CallToStreamObserverAdapter<ReqT> adapter,
-        boolean streamingResponse) {
-      this.call = call;
+        CallToStreamObserverAdapter<ReqT> adapter) {
       this.observer = observer;
-      this.streamingResponse = streamingResponse;
       this.adapter = adapter;
       if (observer instanceof ClientResponseObserver) {
         @SuppressWarnings("unchecked")
@@ -370,7 +559,7 @@ public void onHeaders(Metadata headers) {
 
     @Override
     public void onMessage(RespT message) {
-      if (firstResponseReceived && !streamingResponse) {
+      if (firstResponseReceived && !adapter.streamingResponse) {
         throw Status.INTERNAL
             .withDescription("More than one responses received for unary or client-streaming call")
             .asRuntimeException();
@@ -378,9 +567,9 @@ public void onMessage(RespT message) {
       firstResponseReceived = true;
       observer.onNext(message);
 
-      if (streamingResponse && adapter.autoFlowControlEnabled) {
+      if (adapter.streamingResponse && adapter.autoRequestEnabled) {
         // Request delivery of the next inbound message.
-        call.request(1);
+        adapter.request(1);
       }
     }
 
@@ -399,16 +588,25 @@ public void onReady() {
         adapter.onReadyHandler.run();
       }
     }
+
+    @Override
+    void onStart() {
+      if (adapter.initialRequest > 0) {
+        adapter.request(adapter.initialRequest);
+      }
+    }
   }
 
   /**
-   * Complete a GrpcFuture using {@link StreamObserver} events.
+   * Completes a {@link GrpcFuture} using {@link StreamObserver} events.
    */
-  private static class UnaryStreamToFuture<RespT> extends ClientCall.Listener<RespT> {
+  private static final class UnaryStreamToFuture<RespT> extends StartableListener<RespT> {
     private final GrpcFuture<RespT> responseFuture;
     private RespT value;
+    private boolean isValueReceived = false;
 
-    public UnaryStreamToFuture(GrpcFuture<RespT> responseFuture) {
+    // Non private to avoid synthetic class
+    UnaryStreamToFuture(GrpcFuture<RespT> responseFuture) {
       this.responseFuture = responseFuture;
     }
 
@@ -418,17 +616,18 @@ public void onHeaders(Metadata headers) {
 
     @Override
     public void onMessage(RespT value) {
-      if (this.value != null) {
+      if (this.isValueReceived) {
         throw Status.INTERNAL.withDescription("More than one value received for unary call")
             .asRuntimeException();
       }
       this.value = value;
+      this.isValueReceived = true;
     }
 
     @Override
     public void onClose(Status status, Metadata trailers) {
       if (status.isOk()) {
-        if (value == null) {
+        if (!isValueReceived) {
           // No value received so mark the future as an error
           responseFuture.setException(
               Status.INTERNAL.withDescription("No value received for unary call")
@@ -439,11 +638,17 @@ public void onClose(Status status, Metadata trailers) {
         responseFuture.setException(status.asRuntimeException(trailers));
       }
     }
+
+    @Override
+    void onStart() {
+      responseFuture.call.request(2);
+    }
   }
 
-  private static class GrpcFuture<RespT> extends AbstractFuture<RespT> {
+  private static final class GrpcFuture<RespT> extends AbstractFuture<RespT> {
     private final ClientCall<?, RespT> call;
 
+    // Non private to avoid synthetic class
     GrpcFuture(ClientCall<?, RespT> call) {
       this.call = call;
     }
@@ -462,63 +667,63 @@ protected boolean set(@Nullable RespT resp) {
     protected boolean setException(Throwable throwable) {
       return super.setException(throwable);
     }
+
+    @SuppressWarnings("MissingOverride") // Add @Override once Java 6 support is dropped
+    protected String pendingToString() {
+      return MoreObjects.toStringHelper(this).add("clientCall", call).toString();
+    }
   }
 
   /**
-   * Convert events on a {@link io.grpc.ClientCall.Listener} into a blocking
-   * {@link Iterator}.
+   * Convert events on a {@link io.grpc.ClientCall.Listener} into a blocking {@link Iterator}.
    *
    * <p>The class is not thread-safe, but it does permit {@link ClientCall.Listener} calls in a
-   * separate thread from {@code Iterator} calls.
+   * separate thread from {@link Iterator} calls.
    */
   // TODO(ejona86): determine how to allow ClientCall.cancel() in case of application error.
-  private static class BlockingResponseStream<T> implements Iterator<T> {
-    // Due to flow control, only needs to hold up to 2 items: 1 for value, 1 for close.
-    private final BlockingQueue<Object> buffer = new ArrayBlockingQueue<Object>(2);
-    private final ClientCall.Listener<T> listener = new QueuingListener();
+  private static final class BlockingResponseStream<T> implements Iterator<T> {
+    // Due to flow control, only needs to hold up to 3 items: 2 for value, 1 for close.
+    // (2 for value, not 1, because of early request() in next())
+    private final BlockingQueue<Object> buffer = new ArrayBlockingQueue<>(3);
+    private final StartableListener<T> listener = new QueuingListener();
     private final ClientCall<?, T> call;
-    /** May be null. */
-    private final ThreadlessExecutor threadless;
     // Only accessed when iterating.
     private Object last;
 
-    private BlockingResponseStream(ClientCall<?, T> call) {
-      this(call, null);
-    }
-
-    private BlockingResponseStream(ClientCall<?, T> call, ThreadlessExecutor threadless) {
+    // Non private to avoid synthetic class
+    BlockingResponseStream(ClientCall<?, T> call) {
       this.call = call;
-      this.threadless = threadless;
     }
 
-    ClientCall.Listener<T> listener() {
+    StartableListener<T> listener() {
       return listener;
     }
 
-    private Object waitForNext() throws InterruptedException {
-      if (threadless == null) {
-        return buffer.take();
-      } else {
-        Object next = buffer.poll();
-        while (next == null) {
-          threadless.waitAndDrain();
-          next = buffer.poll();
+    private Object waitForNext() {
+      boolean interrupt = false;
+      try {
+        while (true) {
+          try {
+            return buffer.take();
+          } catch (InterruptedException ie) {
+            interrupt = true;
+            call.cancel("Thread interrupted", ie);
+            // Now wait for onClose() to be called, to guarantee BlockingQueue doesn't fill
+          }
+        }
+      } finally {
+        if (interrupt) {
+          Thread.currentThread().interrupt();
         }
-        return next;
       }
     }
 
     @Override
     public boolean hasNext() {
-      if (last == null) {
-        try {
-          // Will block here indefinitely waiting for content. RPC timeouts defend against permanent
-          // hangs here as the call will become closed.
-          last = waitForNext();
-        } catch (InterruptedException ie) {
-          Thread.currentThread().interrupt();
-          throw Status.CANCELLED.withCause(ie).asRuntimeException();
-        }
+      while (last == null) {
+        // Will block here indefinitely waiting for content. RPC timeouts defend against permanent
+        // hangs here as the call will become closed.
+        last = waitForNext();
       }
       if (last instanceof StatusRuntimeException) {
         // Rethrow the exception with a new stacktrace.
@@ -530,17 +735,20 @@ public boolean hasNext() {
 
     @Override
     public T next() {
+      // Eagerly call request(1) so it can be processing the next message while we wait for the
+      // current one, which reduces latency for the next message. With MigratingThreadDeframer and
+      // if the data has already been received, every other message can be delivered instantly. This
+      // can be run after hasNext(), but just would be slower.
+      if (!(last instanceof StatusRuntimeException) && last != this) {
+        call.request(1);
+      }
       if (!hasNext()) {
         throw new NoSuchElementException();
       }
-      try {
-        call.request(1);
-        @SuppressWarnings("unchecked")
-        T tmp = (T) last;
-        return tmp;
-      } finally {
-        last = null;
-      }
+      @SuppressWarnings("unchecked")
+      T tmp = (T) last;
+      last = null;
+      return tmp;
     }
 
     @Override
@@ -548,7 +756,10 @@ public void remove() {
       throw new UnsupportedOperationException();
     }
 
-    private class QueuingListener extends ClientCall.Listener<T> {
+    private final class QueuingListener extends StartableListener<T> {
+      // Non private to avoid synthetic class
+      QueuingListener() {}
+
       private boolean done = false;
 
       @Override
@@ -571,30 +782,216 @@ public void onClose(Status status, Metadata trailers) {
         }
         done = true;
       }
+
+      @Override
+      void onStart() {
+        call.request(1);
+      }
     }
   }
 
-  private static class ThreadlessExecutor implements Executor {
-    private final BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();
+  @SuppressWarnings("serial")
+  private static final class ThreadlessExecutor extends ConcurrentLinkedQueue<Runnable>
+      implements Executor {
+    private static final Logger log = Logger.getLogger(ThreadlessExecutor.class.getName());
+
+    private static final Object SHUTDOWN = new Object(); // sentinel
+
+    // Set to the calling thread while it's parked, SHUTDOWN on RPC completion
+    private volatile Object waiter;
+
+    // Non private to avoid synthetic class
+    ThreadlessExecutor() {}
 
     /**
      * Waits until there is a Runnable, then executes it and all queued Runnables after it.
+     * Must only be called by one thread at a time.
      */
     public void waitAndDrain() throws InterruptedException {
-      Runnable runnable = queue.take();
-      while (runnable != null) {
+      throwIfInterrupted();
+      Runnable runnable = poll();
+      if (runnable == null) {
+        waiter = Thread.currentThread();
+        try {
+          while ((runnable = poll()) == null) {
+            LockSupport.park(this);
+            throwIfInterrupted();
+          }
+        } finally {
+          waiter = null;
+        }
+      }
+      do {
+        runQuietly(runnable);
+      } while ((runnable = poll()) != null);
+    }
+
+    private static void throwIfInterrupted() throws InterruptedException {
+      if (Thread.interrupted()) {
+        throw new InterruptedException();
+      }
+    }
+
+    /**
+     * Called after final call to {@link #waitAndDrain()}, from same thread.
+     */
+    public void shutdown() {
+      waiter = SHUTDOWN;
+      Runnable runnable;
+      while ((runnable = poll()) != null) {
+        runQuietly(runnable);
+      }
+    }
+
+    private static void runQuietly(Runnable runnable) {
+      try {
+        runnable.run();
+      } catch (Throwable t) {
+        log.log(Level.WARNING, "Runnable threw exception", t);
+      }
+    }
+
+    @Override
+    public void execute(Runnable runnable) {
+      add(runnable);
+      Object waiter = this.waiter;
+      if (waiter != SHUTDOWN) {
+        LockSupport.unpark((Thread) waiter); // no-op if null
+      } else if (remove(runnable) && rejectRunnableOnExecutor) {
+        throw new RejectedExecutionException();
+      }
+    }
+  }
+
+  @SuppressWarnings("serial")
+  static final class ThreadSafeThreadlessExecutor extends ConcurrentLinkedQueue<Runnable>
+      implements Executor {
+    private static final Logger log =
+        Logger.getLogger(ThreadSafeThreadlessExecutor.class.getName());
+
+    private final Lock waiterLock = new ReentrantLock();
+    private final Condition waiterCondition = waiterLock.newCondition();
+
+    // Non private to avoid synthetic class
+    ThreadSafeThreadlessExecutor() {}
+
+    /**
+     * Waits until there is a Runnable, then executes it and all queued Runnables after it.
+     */
+    public <T> void waitAndDrain(Predicate<T> predicate, T testTarget) throws InterruptedException {
+      try {
+        waitAndDrainWithTimeout(true, 0, predicate, testTarget);
+      } catch (TimeoutException e) {
+        throw new AssertionError(e); // Should never happen
+      }
+    }
+
+    /**
+     * Waits for up to specified nanoseconds until there is a Runnable, then executes it and all
+     * queued Runnables after it.
+     *
+     * <p>his should always be called in a loop that checks whether the reason we are waiting has
+     * been satisfied.</p>T
+     *
+     * @param waitForever ignore the rest of the arguments and wait until there is a task to run
+     * @param end System.nanoTime() to stop waiting if haven't been woken up yet
+     * @param predicate non-null condition to test for skipping wake or waking up threads
+     * @param testTarget object to pass to predicate
+     */
+    public <T> void waitAndDrainWithTimeout(boolean waitForever, long end,
+                                            @Nonnull Predicate<T> predicate, T testTarget)
+        throws InterruptedException, TimeoutException {
+      throwIfInterrupted();
+      Runnable runnable;
+
+      while (!predicate.apply(testTarget)) {
+        waiterLock.lock();
         try {
-          runnable.run();
-        } catch (Throwable t) {
-          log.log(Level.WARNING, "Runnable threw exception", t);
+          while ((runnable = poll()) == null) {
+            if (predicate.apply(testTarget)) {
+              return; // The condition for which we were waiting is now satisfied
+            }
+
+            if (waitForever) {
+              waiterCondition.await();
+            } else {
+              long waitNanos = end - System.nanoTime();
+              if (waitNanos <= 0) {
+                throw new TimeoutException(); // Deadline is expired
+              }
+              waiterCondition.awaitNanos(waitNanos);
+            }
+          }
+        } finally {
+          waiterLock.unlock();
         }
-        runnable = queue.poll();
+
+        do {
+          runQuietly(runnable);
+        } while ((runnable = poll()) != null);
+        // Wake everything up now that we've done something and they can check in their outer loop
+        // if they can continue or need to wait again.
+        signalAll();
+      }
+    }
+
+    /** Executes all queued Runnables and if there were any wakes up any waiting threads. */
+    void drain() {
+      Runnable runnable;
+      boolean didWork = false;
+
+      while ((runnable = poll()) != null) {
+        runQuietly(runnable);
+        didWork = true;
+      }
+
+      if (didWork) {
+        signalAll();
+      }
+    }
+
+    private void signalAll() {
+      waiterLock.lock();
+      try {
+        waiterCondition.signalAll();
+      } finally {
+        waiterLock.unlock();
+      }
+    }
+
+    private static void runQuietly(Runnable runnable) {
+      try {
+        runnable.run();
+      } catch (Throwable t) {
+        log.log(Level.WARNING, "Runnable threw exception", t);
+      }
+    }
+
+    private static void throwIfInterrupted() throws InterruptedException {
+      if (Thread.interrupted()) {
+        throw new InterruptedException();
       }
     }
 
     @Override
     public void execute(Runnable runnable) {
-      queue.add(runnable);
+      waiterLock.lock();
+      try {
+        add(runnable);
+        waiterCondition.signalAll(); // If anything is waiting let it wake up and process this task
+      } finally {
+        waiterLock.unlock();
+      }
     }
   }
+
+  enum StubType {
+    BLOCKING, FUTURE, ASYNC
+  }
+
+  /**
+   * Internal {@link CallOptions.Key} to indicate stub types.
+   */
+  static final CallOptions.Key<StubType> STUB_TYPE_OPTION =
+      CallOptions.Key.create("internal-stub-type");
 }
diff --git a/stub/src/main/java/io/grpc/stub/ClientResponseObserver.java b/stub/src/main/java/io/grpc/stub/ClientResponseObserver.java
index 0238bb2f2f4..b6155f1cbc2 100644
--- a/stub/src/main/java/io/grpc/stub/ClientResponseObserver.java
+++ b/stub/src/main/java/io/grpc/stub/ClientResponseObserver.java
@@ -1,52 +1,34 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
 
-import io.grpc.ExperimentalApi;
-
 /**
  * Specialization of {@link StreamObserver} implemented by clients in order to interact with the
  * advanced features of a call such as flow-control.
  */
-@ExperimentalApi
 public interface ClientResponseObserver<ReqT, RespT> extends StreamObserver<RespT> {
   /**
-   * Called by the runtime priot to the start of a call to provide a reference to the
+   * Called by the runtime prior to the start of a call to provide a reference to the
    * {@link ClientCallStreamObserver} for the outbound stream. This can be used to listen to
    * onReady events, disable auto inbound flow and perform other advanced functions.
    *
    * <p>Only the methods {@link ClientCallStreamObserver#setOnReadyHandler(Runnable)} and
-   * {@link ClientCallStreamObserver#disableAutoInboundFlowControl()} may be called within this
-   * callback
+   * {@link ClientCallStreamObserver#disableAutoRequestWithInitial(int)} may be called within
+   * this callback
    *
    * <pre>
    *   // Copy an iterator to the request stream under flow-control
diff --git a/stub/src/main/java/io/grpc/stub/InternalClientCalls.java b/stub/src/main/java/io/grpc/stub/InternalClientCalls.java
new file mode 100644
index 00000000000..05e08bbe3b6
--- /dev/null
+++ b/stub/src/main/java/io/grpc/stub/InternalClientCalls.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2019 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.stub;
+
+import io.grpc.CallOptions;
+import io.grpc.Internal;
+
+/**
+ * Internal {@link ClientCalls} accessor.  This is intended for usage internal to the gRPC
+ * team.  If you *really* think you need to use this, contact the gRPC team first.
+ */
+@Internal
+public final class InternalClientCalls {
+
+  /** Internal accessor for {@link ClientCalls#STUB_TYPE_OPTION}. */
+  public static CallOptions.Key<ClientCalls.StubType> getStubTypeOption() {
+    return ClientCalls.STUB_TYPE_OPTION;
+  }
+
+  /** Returns {@link StubType} from call options. */
+  public static StubType getStubType(CallOptions callOptions) {
+    return StubType.of(callOptions.getOption(ClientCalls.STUB_TYPE_OPTION));
+  }
+
+  /** Returns {@link CallOptions} with the corresponding {@link ClientCalls.StubType} set. */
+  public static CallOptions setStubType(CallOptions callOptions, StubType stubType) {
+    return callOptions.withOption(ClientCalls.STUB_TYPE_OPTION, stubType.internalType);
+  }
+
+  /** Companion enum for internal enum {@link ClientCalls.StubType}. */
+  public enum StubType {
+    BLOCKING(ClientCalls.StubType.BLOCKING),
+    ASYNC(ClientCalls.StubType.ASYNC),
+    FUTURE(ClientCalls.StubType.FUTURE);
+
+    private final ClientCalls.StubType internalType;
+
+    StubType(ClientCalls.StubType internalType) {
+      this.internalType = internalType;
+    }
+
+    /** Returns companion enum value of passed internal enum equivalent. */
+    public static StubType of(ClientCalls.StubType internal) {
+      for (StubType value : StubType.values()) {
+        if (value.internalType == internal) {
+          return value;
+        }
+      }
+      throw new AssertionError("Unknown StubType: " + internal.name());
+    }
+  }
+}
diff --git a/stub/src/main/java/io/grpc/stub/MetadataUtils.java b/stub/src/main/java/io/grpc/stub/MetadataUtils.java
index 3b7e7d7f214..4208d3ca652 100644
--- a/stub/src/main/java/io/grpc/stub/MetadataUtils.java
+++ b/stub/src/main/java/io/grpc/stub/MetadataUtils.java
@@ -1,36 +1,23 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
 
+import static com.google.common.base.Preconditions.checkNotNull;
+
 import io.grpc.CallOptions;
 import io.grpc.Channel;
 import io.grpc.ClientCall;
@@ -38,8 +25,12 @@
 import io.grpc.ExperimentalApi;
 import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
 import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
+import io.grpc.ForwardingServerCall.SimpleForwardingServerCall;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
 import io.grpc.Status;
 import java.util.concurrent.atomic.AtomicReference;
 
@@ -50,99 +41,170 @@ public final class MetadataUtils {
   // Prevent instantiation
   private MetadataUtils() {}
 
-  /**
-   * Attaches a set of request headers to a stub.
-   *
-   * @param stub to bind the headers to.
-   * @param extraHeaders the headers to be passed by each call on the returned stub.
-   * @return an implementation of the stub with {@code extraHeaders} bound to each call.
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1789")
-  public static <T extends AbstractStub<T>> T attachHeaders(
-      T stub,
-      final Metadata extraHeaders) {
-    return stub.withInterceptors(newAttachHeadersInterceptor(extraHeaders));
-  }
-
   /**
    * Returns a client interceptor that attaches a set of headers to requests.
    *
    * @param extraHeaders the headers to be passed by each call that is processed by the returned
    *                     interceptor
    */
-  public static ClientInterceptor newAttachHeadersInterceptor(final Metadata extraHeaders) {
-    return new ClientInterceptor() {
+  public static ClientInterceptor newAttachHeadersInterceptor(Metadata extraHeaders) {
+    return new HeaderAttachingClientInterceptor(extraHeaders);
+  }
+
+  private static final class HeaderAttachingClientInterceptor implements ClientInterceptor {
+
+    private final Metadata extraHeaders;
+
+    // Non private to avoid synthetic class
+    HeaderAttachingClientInterceptor(Metadata extraHeaders) {
+      this.extraHeaders = checkNotNull(extraHeaders, "extraHeaders");
+    }
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+      return new HeaderAttachingClientCall<>(next.newCall(method, callOptions));
+    }
+
+    private final class HeaderAttachingClientCall<ReqT, RespT>
+        extends SimpleForwardingClientCall<ReqT, RespT> {
+
+      // Non private to avoid synthetic class
+      HeaderAttachingClientCall(ClientCall<ReqT, RespT> call) {
+        super(call);
+      }
+
       @Override
-      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
-          MethodDescriptor<ReqT, RespT> method,
-          CallOptions callOptions,
-          Channel next) {
-        return new SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {
-          @Override
-          public void start(Listener<RespT> responseListener, Metadata headers) {
-            headers.merge(extraHeaders);
-            super.start(responseListener, headers);
-          }
-        };
+      public void start(Listener<RespT> responseListener, Metadata headers) {
+        headers.merge(extraHeaders);
+        super.start(responseListener, headers);
       }
-    };
+    }
   }
 
   /**
-   * Captures the last received metadata for a stub. Useful for testing
+   * Captures the last received metadata on a channel. Useful for testing.
    *
-   * @param stub to capture for
    * @param headersCapture to record the last received headers
    * @param trailersCapture to record the last received trailers
-   * @return an implementation of the stub that allows to access the last received call's
-   *         headers and trailers via {@code headersCapture} and {@code trailersCapture}.
+   * @return an implementation of the channel with captures installed.
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1789")
-  public static <T extends AbstractStub<T>> T captureMetadata(
-      T stub,
-      AtomicReference<Metadata> headersCapture,
-      AtomicReference<Metadata> trailersCapture) {
-    return stub.withInterceptors(
-        newCaptureMetadataInterceptor(headersCapture, trailersCapture));
+  public static ClientInterceptor newCaptureMetadataInterceptor(
+      AtomicReference<Metadata> headersCapture, AtomicReference<Metadata> trailersCapture) {
+    return new MetadataCapturingClientInterceptor(headersCapture, trailersCapture);
+  }
+
+  private static final class MetadataCapturingClientInterceptor implements ClientInterceptor {
+
+    final AtomicReference<Metadata> headersCapture;
+    final AtomicReference<Metadata> trailersCapture;
+
+    // Non private to avoid synthetic class
+    MetadataCapturingClientInterceptor(
+        AtomicReference<Metadata> headersCapture, AtomicReference<Metadata> trailersCapture) {
+      this.headersCapture = checkNotNull(headersCapture, "headersCapture");
+      this.trailersCapture = checkNotNull(trailersCapture, "trailersCapture");
+    }
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+      return new MetadataCapturingClientCall<>(next.newCall(method, callOptions));
+    }
+
+    private final class MetadataCapturingClientCall<ReqT, RespT>
+        extends SimpleForwardingClientCall<ReqT, RespT> {
+
+      // Non private to avoid synthetic class
+      MetadataCapturingClientCall(ClientCall<ReqT, RespT> call) {
+        super(call);
+      }
+
+      @Override
+      public void start(ClientCall.Listener<RespT> responseListener, Metadata headers) {
+        headersCapture.set(null);
+        trailersCapture.set(null);
+        super.start(new MetadataCapturingClientCallListener(responseListener), headers);
+      }
+
+      private final class MetadataCapturingClientCallListener
+          extends SimpleForwardingClientCallListener<RespT> {
+
+        MetadataCapturingClientCallListener(ClientCall.Listener<RespT> responseListener) {
+          super(responseListener);
+        }
+
+        @Override
+        public void onHeaders(Metadata headers) {
+          headersCapture.set(headers);
+          super.onHeaders(headers);
+        }
+
+        @Override
+        public void onClose(Status status, Metadata trailers) {
+          trailersCapture.set(trailers);
+          super.onClose(status, trailers);
+        }
+      }
+    }
   }
 
   /**
-   * Captures the last received metadata on a channel. Useful for testing.
+   * Returns a ServerInterceptor that adds the specified Metadata to every response stream, one way
+   * or another.
    *
-   * @param headersCapture to record the last received headers
-   * @param trailersCapture to record the last received trailers
-   * @return an implementation of the channel with captures installed.
+   * <p>If, absent this interceptor, a stream would have headers, 'extras' will be added to those
+   * headers. Otherwise, 'extras' will be sent as trailers. This pattern is useful when you have
+   * some fixed information, server identity say, that should be included no matter how the call
+   * turns out. The fallback to trailers avoids artificially committing clients to error responses
+   * that could otherwise be retried (see https://grpc.io/docs/guides/retry/ for more).
+   *
+   * <p>For correct operation, be sure to arrange for this interceptor to run *before* any others
+   * that might add headers.
+   *
+   * @param extras the Metadata to be added to each stream. Caller gives up ownership.
    */
-  public static ClientInterceptor newCaptureMetadataInterceptor(
-      final AtomicReference<Metadata> headersCapture,
-      final AtomicReference<Metadata> trailersCapture) {
-    return new ClientInterceptor() {
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11462")
+  public static ServerInterceptor newAttachMetadataServerInterceptor(Metadata extras) {
+    return new MetadataAttachingServerInterceptor(extras);
+  }
+
+  private static final class MetadataAttachingServerInterceptor implements ServerInterceptor {
+
+    private final Metadata extras;
+
+    MetadataAttachingServerInterceptor(Metadata extras) {
+      this.extras = extras;
+    }
+
+    @Override
+    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+        ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+      return next.startCall(new MetadataAttachingServerCall<>(call), headers);
+    }
+
+    final class MetadataAttachingServerCall<ReqT, RespT>
+        extends SimpleForwardingServerCall<ReqT, RespT> {
+      boolean headersSent;
+
+      MetadataAttachingServerCall(ServerCall<ReqT, RespT> delegate) {
+        super(delegate);
+      }
+
+      @Override
+      public void sendHeaders(Metadata headers) {
+        headers.merge(extras);
+        headersSent = true;
+        super.sendHeaders(headers);
+      }
+
       @Override
-      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
-          MethodDescriptor<ReqT, RespT> method,
-          CallOptions callOptions,
-          Channel next) {
-        return new SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {
-          @Override
-          public void start(Listener<RespT> responseListener, Metadata headers) {
-            headersCapture.set(null);
-            trailersCapture.set(null);
-            super.start(new SimpleForwardingClientCallListener<RespT>(responseListener) {
-              @Override
-              public void onHeaders(Metadata headers) {
-                headersCapture.set(headers);
-                super.onHeaders(headers);
-              }
-
-              @Override
-              public void onClose(Status status, Metadata trailers) {
-                trailersCapture.set(trailers);
-                super.onClose(status, trailers);
-              }
-            }, headers);
-          }
-        };
+      public void close(Status status, Metadata trailers) {
+        if (!headersSent) {
+          trailers.merge(extras);
+        }
+        super.close(status, trailers);
       }
-    };
+    }
   }
 }
diff --git a/stub/src/main/java/io/grpc/stub/ServerCallStreamObserver.java b/stub/src/main/java/io/grpc/stub/ServerCallStreamObserver.java
index 3ec594c5b98..6ffea3500cc 100644
--- a/stub/src/main/java/io/grpc/stub/ServerCallStreamObserver.java
+++ b/stub/src/main/java/io/grpc/stub/ServerCallStreamObserver.java
@@ -1,67 +1,191 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
 
+import static com.google.common.base.Preconditions.checkArgument;
+
 import io.grpc.ExperimentalApi;
 
 /**
  * A refinement of {@link CallStreamObserver} to allows for interaction with call
- * cancellation events on the server side.
+ * cancellation events on the server side. An instance of this class is obtained by casting the
+ * {@code StreamObserver} passed as an argument to service implementations.
+ *
+ * <p>Like {@code StreamObserver}, implementations are not required to be thread-safe; if multiple
+ * threads will be writing to an instance concurrently, the application must synchronize its calls.
+ *
+ * <p>DO NOT MOCK: The API is too complex to reliably mock. Use InProcessChannelBuilder to create
+ * "real" RPCs suitable for testing and interact with the server using a normal client stub.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1788")
-public abstract class ServerCallStreamObserver<V> extends CallStreamObserver<V> {
+public abstract class ServerCallStreamObserver<RespT> extends CallStreamObserver<RespT> {
 
   /**
-   * If {@code true} indicates that the call has been cancelled by the remote peer.
+   * Returns {@code true} when the call is cancelled and the server is encouraged to abort
+   * processing to save resources, since the client will not be processing any further methods.
+   * Cancellations can be caused by timeouts, explicit cancellation by client, network errors, and
+   * similar.
+   *
+   * <p>This method may safely be called concurrently from multiple threads.
    */
   public abstract boolean isCancelled();
 
   /**
-   * Set a {@link Runnable} that will be called if the calls  {@link #isCancelled()} state
-   * changes from {@code false} to {@code true}. It is guaranteed that execution of the
-   * {@link Runnable} are serialized with calls to the 'inbound' {@link StreamObserver}.
+   * Sets a {@link Runnable} to be called if the call is cancelled and the server is encouraged to
+   * abort processing to save resources, since the client will not process any further messages.
+   * Cancellations can be caused by timeouts, explicit cancellation by the client, network errors,
+   * etc.
+   *
+   * <p>It is guaranteed that execution of the {@link Runnable} is serialized with calls to the
+   * 'inbound' {@link StreamObserver}. That also means that the callback will be delayed if other
+   * callbacks are running; if one of those other callbacks runs for a significant amount of time
+   * it can poll {@link #isCancelled()}, which is not delayed.
    *
-   * <p>Note that the handler may be called some time after {@link #isCancelled} has transitioned to
-   * {@code true} as other callbacks may still be executing in the 'inbound' observer.
+   * <p>This method may only be called during the initial call to the application, before the
+   * service returns its {@code StreamObserver}.
+   *
+   * <p>Setting the onCancelHandler will suppress the on-cancel exception thrown by
+   * {@link #onNext}. If the caller is already handling cancellation via polling or cannot
+   * substantially benefit from observing cancellation, using a no-op {@code onCancelHandler} is
+   * useful just to suppress the {@code onNext()} exception.
    *
    * @param onCancelHandler to call when client has cancelled the call.
    */
   public abstract void setOnCancelHandler(Runnable onCancelHandler);
 
+
+  /**
+   * A hint to the call that specifies how many bytes must be queued before
+   * {@link #isReady()} will return false. A call may ignore this property if
+   * unsupported. This may only be set during stream initialization before
+   * any messages are set.
+   *
+   * @param numBytes The number of bytes that must be queued. Must be a
+   *                 positive integer.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11021")
+  public void setOnReadyThreshold(int numBytes) {
+    checkArgument(numBytes > 0, "numBytes must be positive: %s", numBytes);
+  }
+
   /**
-   * Sets the compression algorithm to use for the call.  May only be called before sending any
-   * messages.
+   * Sets the compression algorithm to use for the call. May only be called before sending any
+   * messages. Default gRPC servers support the "gzip" compressor.
+   *
+   * <p>It is safe to call this even if the client does not support the compression format chosen.
+   * The implementation will handle negotiation with the client and may fall back to no compression.
    *
    * @param compression the compression algorithm to use.
+   * @throws IllegalArgumentException if the compressor name can not be found.
    */
   public abstract void setCompression(String compression);
+
+  /**
+   * Swaps to manual flow control where no message will be delivered to {@link
+   * StreamObserver#onNext(Object)} unless it is {@link #request request()}ed.
+   *
+   * <p>It may only be called during the initial call to the application, before the service returns
+   * its {@code StreamObserver}.
+   *
+   * <p>Note that for cases where the message is received before the service handler is invoked,
+   * this method will have no effect. This is true for:
+   *
+   * <ul>
+   *   <li>{@link io.grpc.MethodDescriptor.MethodType#UNARY} operations.</li>
+   *   <li>{@link io.grpc.MethodDescriptor.MethodType#SERVER_STREAMING} operations.</li>
+   * </ul>
+   * </p>
+   */
+  public void disableAutoRequest() {
+    throw new UnsupportedOperationException();
+  }
+
+
+  /**
+   * If {@code true}, indicates that the observer is capable of sending additional messages
+   * without requiring excessive buffering internally. This value is just a suggestion and the
+   * application is free to ignore it, however doing so may result in excessive buffering within the
+   * observer.
+   *
+   * <p>If {@code false}, the runnable passed to {@link #setOnReadyHandler} will be called after
+   * {@code isReady()} transitions to {@code true}.
+   */
+  @Override
+  public abstract boolean isReady();
+
+  /**
+   * Set a {@link Runnable} that will be executed every time the stream {@link #isReady()} state
+   * changes from {@code false} to {@code true}.  While it is not guaranteed that the same
+   * thread will always be used to execute the {@link Runnable}, it is guaranteed that executions
+   * are serialized with calls to the 'inbound' {@link StreamObserver}.
+   *
+   * <p>May only be called during the initial call to the application, before the service returns
+   * its {@code StreamObserver}.
+   *
+   * <p>Because there is a processing delay to deliver this notification, it is possible for
+   * concurrent writes to cause {@code isReady() == false} within this callback. Handle "spurious"
+   * notifications by checking {@code isReady()}'s current value instead of assuming it is now
+   * {@code true}. If {@code isReady() == false} the normal expectations apply, so there would be
+   * <em>another</em> {@code onReadyHandler} callback.
+   *
+   * @param onReadyHandler to call when peer is ready to receive more messages.
+   */
+  @Override
+  public abstract void setOnReadyHandler(Runnable onReadyHandler);
+
+  /**
+   * Requests the peer to produce {@code count} more messages to be delivered to the 'inbound'
+   * {@link StreamObserver}.
+   *
+   * <p>This method is safe to call from multiple threads without external synchronization.
+   *
+   * @param count more messages
+   */
+  @Override
+  public abstract void request(int count);
+
+  /**
+   * Sets message compression for subsequent calls to {@link #onNext}.
+   *
+   * @param enable whether to enable compression.
+   */
+  @Override
+  public abstract void setMessageCompression(boolean enable);
+
+  /**
+   * Sets a {@link Runnable} to be executed when the call is closed cleanly from the server's
+   * point of view: either {@link #onCompleted()} or {@link #onError(Throwable)} has been called,
+   * all the messages and trailing metadata have been sent and the stream has been closed. Note
+   * however that the client still may have not received all the messages due to network delay,
+   * client crashes, and cancellation races.
+   *
+   * <p>Exactly one of {@code onCloseHandler} and {@code onCancelHandler} is guaranteed to be called
+   * when the RPC terminates.</p>
+   *
+   * <p>It is guaranteed that execution of {@code onCloseHandler} is serialized with calls to
+   * the 'inbound' {@link StreamObserver}. That also means that the callback will be delayed if
+   * other callbacks are running.</p>
+   *
+   * <p>This method may only be called during the initial call to the application, before the
+   * service returns its {@link StreamObserver request observer}.</p>
+   *
+   * @param onCloseHandler to execute when the call has been closed cleanly.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8467")
+  public void setOnCloseHandler(Runnable onCloseHandler) {
+    throw new UnsupportedOperationException();
+  }
 }
diff --git a/stub/src/main/java/io/grpc/stub/ServerCalls.java b/stub/src/main/java/io/grpc/stub/ServerCalls.java
index da71f272df7..9f0063713cc 100644
--- a/stub/src/main/java/io/grpc/stub/ServerCalls.java
+++ b/stub/src/main/java/io/grpc/stub/ServerCalls.java
@@ -1,38 +1,26 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
 
 import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
 
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
 import io.grpc.ServerCall;
@@ -45,218 +33,313 @@
  */
 public final class ServerCalls {
 
+  @VisibleForTesting
+  static final String TOO_MANY_REQUESTS = "Too many requests";
+  @VisibleForTesting
+  static final String MISSING_REQUEST = "Half-closed without a request";
+
   private ServerCalls() {
   }
 
   /**
-   * Creates a {@code ServerCallHandler} for a unary call method of the service.
+   * Creates a {@link ServerCallHandler} for a unary call method of the service.
    *
    * @param method an adaptor to the actual method on the service implementation.
    */
   public static <ReqT, RespT> ServerCallHandler<ReqT, RespT> asyncUnaryCall(
-      final UnaryMethod<ReqT, RespT> method) {
-    return asyncUnaryRequestCall(method);
+      UnaryMethod<ReqT, RespT> method) {
+    return new UnaryServerCallHandler<>(method, false);
   }
 
   /**
-   * Creates a {@code ServerCallHandler} for a server streaming method of the service.
+   * Creates a {@link ServerCallHandler} for a server streaming method of the service.
    *
    * @param method an adaptor to the actual method on the service implementation.
    */
   public static <ReqT, RespT> ServerCallHandler<ReqT, RespT> asyncServerStreamingCall(
-      final ServerStreamingMethod<ReqT, RespT> method) {
-    return asyncUnaryRequestCall(method);
+      ServerStreamingMethod<ReqT, RespT> method) {
+    return new UnaryServerCallHandler<>(method, true);
   }
 
   /**
-   * Creates a {@code ServerCallHandler} for a client streaming method of the service.
+   * Creates a {@link ServerCallHandler} for a client streaming method of the service.
    *
    * @param method an adaptor to the actual method on the service implementation.
    */
   public static <ReqT, RespT> ServerCallHandler<ReqT, RespT> asyncClientStreamingCall(
-      final ClientStreamingMethod<ReqT, RespT> method) {
-    return asyncStreamingRequestCall(method);
+      ClientStreamingMethod<ReqT, RespT> method) {
+    return new StreamingServerCallHandler<>(method, false);
   }
 
   /**
-   * Creates a {@code ServerCallHandler} for a bidi streaming method of the service.
+   * Creates a {@link ServerCallHandler} for a bidi streaming method of the service.
    *
    * @param method an adaptor to the actual method on the service implementation.
    */
   public static <ReqT, RespT> ServerCallHandler<ReqT, RespT> asyncBidiStreamingCall(
-      final BidiStreamingMethod<ReqT, RespT> method) {
-    return asyncStreamingRequestCall(method);
+      BidiStreamingMethod<ReqT, RespT> method) {
+    return new StreamingServerCallHandler<>(method, true);
   }
 
   /**
    * Adaptor to a unary call method.
    */
-  public static interface UnaryMethod<ReqT, RespT> extends UnaryRequestMethod<ReqT, RespT> {
+  public interface UnaryMethod<ReqT, RespT> extends UnaryRequestMethod<ReqT, RespT> {
+    @Override void invoke(ReqT request, StreamObserver<RespT> responseObserver);
   }
 
   /**
    * Adaptor to a server streaming method.
    */
-  public static interface ServerStreamingMethod<ReqT, RespT>
-      extends UnaryRequestMethod<ReqT, RespT> {
+  public interface ServerStreamingMethod<ReqT, RespT> extends UnaryRequestMethod<ReqT, RespT> {
+    @Override void invoke(ReqT request, StreamObserver<RespT> responseObserver);
   }
 
   /**
    * Adaptor to a client streaming method.
    */
-  public static interface ClientStreamingMethod<ReqT, RespT>
-      extends StreamingRequestMethod<ReqT, RespT> {
+  public interface ClientStreamingMethod<ReqT, RespT> extends StreamingRequestMethod<ReqT, RespT> {
+    @Override StreamObserver<ReqT> invoke(StreamObserver<RespT> responseObserver);
   }
 
   /**
-   * Adaptor to a bi-directional streaming method.
+   * Adaptor to a bidirectional streaming method.
    */
-  public static interface BidiStreamingMethod<ReqT, RespT>
-      extends StreamingRequestMethod<ReqT, RespT> {
+  public interface BidiStreamingMethod<ReqT, RespT> extends StreamingRequestMethod<ReqT, RespT> {
+    @Override StreamObserver<ReqT> invoke(StreamObserver<RespT> responseObserver);
   }
 
-  /**
-   * Creates a {@code ServerCallHandler} for a unary request call method of the service.
-   *
-   * @param method an adaptor to the actual method on the service implementation.
-   */
-  private static <ReqT, RespT> ServerCallHandler<ReqT, RespT> asyncUnaryRequestCall(
-      final UnaryRequestMethod<ReqT, RespT> method) {
-    return new ServerCallHandler<ReqT, RespT>() {
+  private static final class UnaryServerCallHandler<ReqT, RespT>
+      implements ServerCallHandler<ReqT, RespT> {
+
+    private final UnaryRequestMethod<ReqT, RespT> method;
+    private final boolean serverStreaming;
+
+    // Non private to avoid synthetic class
+    UnaryServerCallHandler(UnaryRequestMethod<ReqT, RespT> method, boolean serverStreaming) {
+      this.method = method;
+      this.serverStreaming = serverStreaming;
+    }
+
+    @Override
+    public ServerCall.Listener<ReqT> startCall(ServerCall<ReqT, RespT> call, Metadata headers) {
+      Preconditions.checkArgument(
+          call.getMethodDescriptor().getType().clientSendsOneMessage(),
+          "asyncUnaryRequestCall is only for clientSendsOneMessage methods");
+      ServerCallStreamObserverImpl<ReqT, RespT> responseObserver =
+          new ServerCallStreamObserverImpl<>(call, serverStreaming);
+      // We expect only 1 request, but we ask for 2 requests here so that if a misbehaving client
+      // sends more than 1 requests, ServerCall will catch it. Note that disabling auto
+      // inbound flow control has no effect on unary calls.
+      call.request(2);
+      return new UnaryServerCallListener(responseObserver, call);
+    }
+
+    private final class UnaryServerCallListener extends ServerCall.Listener<ReqT> {
+      private final ServerCall<ReqT, RespT> call;
+      private final ServerCallStreamObserverImpl<ReqT, RespT> responseObserver;
+      private boolean canInvoke = true;
+      private boolean wasReady;
+      private ReqT request;
+
+      // Non private to avoid synthetic class
+      UnaryServerCallListener(
+          ServerCallStreamObserverImpl<ReqT, RespT> responseObserver,
+          ServerCall<ReqT, RespT> call) {
+        this.call = call;
+        this.responseObserver = responseObserver;
+      }
+
       @Override
-      public ServerCall.Listener<ReqT> startCall(
-          final ServerCall<ReqT, RespT> call,
-          Metadata headers) {
-        final ServerCallStreamObserverImpl<ReqT, RespT> responseObserver =
-            new ServerCallStreamObserverImpl<ReqT, RespT>(call);
-        // We expect only 1 request, but we ask for 2 requests here so that if a misbehaving client
-        // sends more than 1 requests, ServerCall will catch it. Note that disabling auto
-        // inbound flow control has no effect on unary calls.
-        call.request(2);
-        return new EmptyServerCallListener<ReqT>() {
-          ReqT request;
-          @Override
-          public void onMessage(ReqT request) {
-            // We delay calling method.invoke() until onHalfClose() to make sure the client
-            // half-closes.
-            this.request = request;
-          }
-
-          @Override
-          public void onHalfClose() {
-            if (request != null) {
-              method.invoke(request, responseObserver);
-              responseObserver.freeze();
-              if (call.isReady()) {
-                // Since we are calling invoke in halfClose we have missed the onReady
-                // event from the transport so recover it here.
-                onReady();
-              }
-            } else {
-              call.close(Status.INTERNAL.withDescription("Half-closed without a request"),
-                  new Metadata());
-            }
-          }
-
-          @Override
-          public void onCancel() {
-            responseObserver.cancelled = true;
-            if (responseObserver.onCancelHandler != null) {
-              responseObserver.onCancelHandler.run();
-            }
-          }
-
-          @Override
-          public void onReady() {
-            if (responseObserver.onReadyHandler != null) {
-              responseObserver.onReadyHandler.run();
-            }
-          }
-        };
+      public void onMessage(ReqT request) {
+        if (this.request != null) {
+          // Safe to close the call, because the application has not yet been invoked
+          call.close(
+              Status.INTERNAL.withDescription(TOO_MANY_REQUESTS),
+              new Metadata());
+          canInvoke = false;
+          return;
+        }
+
+        // We delay calling method.invoke() until onHalfClose() to make sure the client
+        // half-closes.
+        this.request = request;
       }
-    };
-  }
 
-  /**
-   * Creates a {@code ServerCallHandler} for a streaming request call method of the service.
-   *
-   * @param method an adaptor to the actual method on the service implementation.
-   */
-  private static <ReqT, RespT> ServerCallHandler<ReqT, RespT> asyncStreamingRequestCall(
-      final StreamingRequestMethod<ReqT, RespT> method) {
-    return new ServerCallHandler<ReqT, RespT>() {
       @Override
-      public ServerCall.Listener<ReqT> startCall(
-          final ServerCall<ReqT, RespT> call,
-          Metadata headers) {
-        final ServerCallStreamObserverImpl<ReqT, RespT> responseObserver =
-            new ServerCallStreamObserverImpl<ReqT, RespT>(call);
-        final StreamObserver<ReqT> requestObserver = method.invoke(responseObserver);
+      public void onHalfClose() {
+        if (!canInvoke) {
+          return;
+        }
+        if (request == null) {
+          // Safe to close the call, because the application has not yet been invoked
+          call.close(
+              Status.INTERNAL.withDescription(MISSING_REQUEST),
+              new Metadata());
+          return;
+        }
+
+        method.invoke(request, responseObserver);
+        request = null;
         responseObserver.freeze();
-        if (responseObserver.autoFlowControlEnabled) {
+        if (wasReady) {
+          // Since we are calling invoke in halfClose we have missed the onReady
+          // event from the transport so recover it here.
+          onReady();
+        }
+      }
+
+      @Override
+      public void onCancel() {
+        if (responseObserver.onCancelHandler != null) {
+          responseObserver.onCancelHandler.run();
+        } else {
+          // Only trigger exceptions if unable to provide notification via a callback
+          responseObserver.cancelled = true;
+        }
+      }
+
+      @Override
+      public void onReady() {
+        wasReady = true;
+        if (responseObserver.onReadyHandler != null) {
+          responseObserver.onReadyHandler.run();
+        }
+      }
+
+      @Override
+      public void onComplete() {
+        if (responseObserver.onCloseHandler != null) {
+          responseObserver.onCloseHandler.run();
+        }
+      }
+    }
+  }
+
+  private static final class StreamingServerCallHandler<ReqT, RespT>
+      implements ServerCallHandler<ReqT, RespT> {
+
+    private final StreamingRequestMethod<ReqT, RespT> method;
+    private final boolean bidi;
+
+    // Non private to avoid synthetic class
+    StreamingServerCallHandler(StreamingRequestMethod<ReqT, RespT> method, boolean bidi) {
+      this.method = method;
+      this.bidi = bidi;
+    }
+
+    @Override
+    public ServerCall.Listener<ReqT> startCall(ServerCall<ReqT, RespT> call, Metadata headers) {
+      ServerCallStreamObserverImpl<ReqT, RespT> responseObserver =
+          new ServerCallStreamObserverImpl<>(call, bidi);
+      StreamObserver<ReqT> requestObserver = method.invoke(responseObserver);
+      responseObserver.freeze();
+      if (responseObserver.autoRequestEnabled) {
+        call.request(1);
+      }
+      return new StreamingServerCallListener(requestObserver, responseObserver, call);
+    }
+
+    private final class StreamingServerCallListener extends ServerCall.Listener<ReqT> {
+
+      private final StreamObserver<ReqT> requestObserver;
+      private final ServerCallStreamObserverImpl<ReqT, RespT> responseObserver;
+      private final ServerCall<ReqT, RespT> call;
+      private boolean halfClosed = false;
+
+      // Non private to avoid synthetic class
+      StreamingServerCallListener(
+          StreamObserver<ReqT> requestObserver,
+          ServerCallStreamObserverImpl<ReqT, RespT> responseObserver,
+          ServerCall<ReqT, RespT> call) {
+        this.requestObserver = requestObserver;
+        this.responseObserver = responseObserver;
+        this.call = call;
+      }
+
+      @Override
+      public void onMessage(ReqT request) {
+        requestObserver.onNext(request);
+
+        // Request delivery of the next inbound message.
+        if (responseObserver.autoRequestEnabled) {
           call.request(1);
         }
-        return new EmptyServerCallListener<ReqT>() {
-          boolean halfClosed = false;
-
-          @Override
-          public void onMessage(ReqT request) {
-            requestObserver.onNext(request);
-
-            // Request delivery of the next inbound message.
-            if (responseObserver.autoFlowControlEnabled) {
-              call.request(1);
-            }
-          }
-
-          @Override
-          public void onHalfClose() {
-            halfClosed = true;
-            requestObserver.onCompleted();
-          }
-
-          @Override
-          public void onCancel() {
-            responseObserver.cancelled = true;
-            if (responseObserver.onCancelHandler != null) {
-              responseObserver.onCancelHandler.run();
-            }
-            if (!halfClosed) {
-              requestObserver.onError(Status.CANCELLED.asException());
-            }
-          }
-
-          @Override
-          public void onReady() {
-            if (responseObserver.onReadyHandler != null) {
-              responseObserver.onReadyHandler.run();
-            }
-          }
-        };
       }
-    };
+
+      @Override
+      public void onHalfClose() {
+        halfClosed = true;
+        requestObserver.onCompleted();
+      }
+
+      @Override
+      public void onCancel() {
+        if (responseObserver.onCancelHandler != null) {
+          responseObserver.onCancelHandler.run();
+        } else {
+          // Only trigger exceptions if unable to provide notification via a callback. Even though
+          // onError would provide notification to the server, we still throw an error since there
+          // isn't a guaranteed callback available. If the cancellation happened in a different
+          // order the service could be surprised to see the exception.
+          responseObserver.cancelled = true;
+        }
+        if (!halfClosed) {
+          requestObserver.onError(
+              Status.CANCELLED
+                  .withDescription("client cancelled")
+                  .asRuntimeException());
+        }
+      }
+
+      @Override
+      public void onReady() {
+        if (responseObserver.onReadyHandler != null) {
+          responseObserver.onReadyHandler.run();
+        }
+      }
+
+      @Override
+      public void onComplete() {
+        if (responseObserver.onCloseHandler != null) {
+          responseObserver.onCloseHandler.run();
+        }
+      }
+    }
   }
 
-  private static interface UnaryRequestMethod<ReqT, RespT> {
+  private interface UnaryRequestMethod<ReqT, RespT> {
+    /**
+     * The provided {@code responseObserver} will extend {@link ServerCallStreamObserver}.
+     */
     void invoke(ReqT request, StreamObserver<RespT> responseObserver);
   }
 
-  private static interface StreamingRequestMethod<ReqT, RespT> {
+  private interface StreamingRequestMethod<ReqT, RespT> {
+    /**
+     * The provided {@code responseObserver} will extend {@link ServerCallStreamObserver}.
+     */
     StreamObserver<ReqT> invoke(StreamObserver<RespT> responseObserver);
   }
 
   private static final class ServerCallStreamObserverImpl<ReqT, RespT>
       extends ServerCallStreamObserver<RespT> {
     final ServerCall<ReqT, RespT> call;
+    private final boolean serverStreamingOrBidi;
     volatile boolean cancelled;
     private boolean frozen;
-    private boolean autoFlowControlEnabled = true;
+    private boolean autoRequestEnabled = true;
     private boolean sentHeaders;
     private Runnable onReadyHandler;
     private Runnable onCancelHandler;
+    private boolean aborted = false;
+    private boolean completed = false;
+    private Runnable onCloseHandler;
 
-    ServerCallStreamObserverImpl(ServerCall<ReqT, RespT> call) {
+    // Non private to avoid synthetic class
+    ServerCallStreamObserverImpl(ServerCall<ReqT, RespT> call, boolean serverStreamingOrBidi) {
       this.call = call;
+      this.serverStreamingOrBidi = serverStreamingOrBidi;
     }
 
     private void freeze() {
@@ -276,8 +359,20 @@ public void setCompression(String compression) {
     @Override
     public void onNext(RespT response) {
       if (cancelled) {
-        throw Status.CANCELLED.asRuntimeException();
+        if (serverStreamingOrBidi) {
+          throw Status.CANCELLED
+              .withDescription("call already cancelled. "
+                  + "Use ServerCallStreamObserver.setOnCancelHandler() to disable this exception")
+              .asRuntimeException();
+        } else {
+          // We choose not to throw for unary responses. The exception is intended to stop servers
+          // from continuing processing, but for unary responses there is no further processing
+          // so throwing an exception would not provide a benefit and would increase application
+          // complexity.
+        }
       }
+      checkState(!aborted, "Stream was terminated by error, no further calls are allowed");
+      checkState(!completed, "Stream is already completed, no further calls are allowed");
       if (!sentHeaders) {
         call.sendHeaders(new Metadata());
         sentHeaders = true;
@@ -287,22 +382,21 @@ public void onNext(RespT response) {
 
     @Override
     public void onError(Throwable t) {
-      Metadata metadata = Status.trailersFromThrowable(t);
-      if (metadata == null) {
-        metadata = new Metadata();
+      Metadata metadata = new Metadata();
+      Metadata trailers = Status.trailersFromThrowable(t);
+      if (trailers != null) {
+        metadata.merge(trailers);
       }
       call.close(Status.fromThrowable(t), metadata);
+      aborted = true;
     }
 
     @Override
     public void onCompleted() {
-      if (cancelled) {
-        throw Status.CANCELLED.asRuntimeException();
-      } else {
-        call.close(Status.OK, new Metadata());
-      }
+      call.close(Status.OK, new Metadata());
+      completed = true;
     }
-
+    
     @Override
     public boolean isReady() {
       return call.isReady();
@@ -310,9 +404,9 @@ public boolean isReady() {
 
     @Override
     public void setOnReadyHandler(Runnable r) {
-      if (frozen) {
-        throw new IllegalStateException("Cannot alter onReadyHandler after initialization");
-      }
+      checkState(!frozen, "Cannot alter onReadyHandler after initialization. May only be called "
+          + "during the initial call to the application, before the service returns its "
+          + "StreamObserver");
       this.onReadyHandler = r;
     }
 
@@ -323,42 +417,42 @@ public boolean isCancelled() {
 
     @Override
     public void setOnCancelHandler(Runnable onCancelHandler) {
-      if (frozen) {
-        throw new IllegalStateException("Cannot alter onCancelHandler after initialization");
-      }
+      checkState(!frozen, "Cannot alter onCancelHandler after initialization. May only be called "
+          + "during the initial call to the application, before the service returns its "
+          + "StreamObserver");
       this.onCancelHandler = onCancelHandler;
     }
 
     @Override
-    public void disableAutoInboundFlowControl() {
-      if (frozen) {
-        throw new IllegalStateException("Cannot disable auto flow control after initialization");
-      } else {
-        autoFlowControlEnabled = false;
-      }
-    }
-
-    @Override
-    public void request(int count) {
-      call.request(count);
+    public void setOnReadyThreshold(int numBytes) {
+      checkState(!frozen, "Cannot alter setOnReadyThreshold after initialization. May only be "
+          + "called during the initial call to the application, before the service returns its "
+          + "StreamObserver");
+      call.setOnReadyThreshold(numBytes);
     }
-  }
 
-  private static class EmptyServerCallListener<ReqT> extends ServerCall.Listener<ReqT> {
     @Override
-    public void onMessage(ReqT request) {
+    public void disableAutoInboundFlowControl() {
+      disableAutoRequest();
     }
 
     @Override
-    public void onHalfClose() {
+    public void disableAutoRequest() {
+      checkState(!frozen, "Cannot disable auto flow control after initialization");
+      autoRequestEnabled = false;
     }
 
     @Override
-    public void onCancel() {
+    public void request(int count) {
+      call.request(count);
     }
 
     @Override
-    public void onComplete() {
+    public void setOnCloseHandler(Runnable onCloseHandler) {
+      checkState(!frozen, "Cannot alter onCloseHandler after initialization. May only be called "
+          + "during the initial call to the application, before the service returns its "
+          + "StreamObserver");
+      this.onCloseHandler = onCloseHandler;
     }
   }
 
@@ -368,14 +462,14 @@ public void onComplete() {
    * @param methodDescriptor of method for which error will be thrown.
    * @param responseObserver on which error will be set.
    */
-  public static void asyncUnimplementedUnaryCall(MethodDescriptor<?, ?> methodDescriptor,
-      StreamObserver<?> responseObserver) {
+  public static void asyncUnimplementedUnaryCall(
+      MethodDescriptor<?, ?> methodDescriptor, StreamObserver<?> responseObserver) {
     checkNotNull(methodDescriptor, "methodDescriptor");
     checkNotNull(responseObserver, "responseObserver");
     responseObserver.onError(Status.UNIMPLEMENTED
         .withDescription(String.format("Method %s is unimplemented",
             methodDescriptor.getFullMethodName()))
-        .asException());
+        .asRuntimeException());
   }
 
   /**
@@ -384,12 +478,12 @@ public static void asyncUnimplementedUnaryCall(MethodDescriptor<?, ?> methodDesc
    * @param methodDescriptor of method for which error will be thrown.
    * @param responseObserver on which error will be set.
    */
-  public static <T> StreamObserver<T> asyncUnimplementedStreamingCall(
+  public static <ReqT> StreamObserver<ReqT> asyncUnimplementedStreamingCall(
       MethodDescriptor<?, ?> methodDescriptor, StreamObserver<?> responseObserver) {
     // NB: For streaming call we want to do the same as for unary call. Fail-fast by setting error
     // on responseObserver and then return no-op observer.
     asyncUnimplementedUnaryCall(methodDescriptor, responseObserver);
-    return new NoopStreamObserver<T>();
+    return new NoopStreamObserver<>();
   }
 
   /**
diff --git a/stub/src/main/java/io/grpc/stub/StreamObserver.java b/stub/src/main/java/io/grpc/stub/StreamObserver.java
index ac46909b2c0..3a5c756e73e 100644
--- a/stub/src/main/java/io/grpc/stub/StreamObserver.java
+++ b/stub/src/main/java/io/grpc/stub/StreamObserver.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
@@ -40,12 +25,22 @@
  * library to the application. For incoming messages, the application implements the
  * {@code StreamObserver} and passes it to the GRPC library for receiving.
  *
- * <p>Implementations are expected to be
- * <a href="http://www.ibm.com/developerworks/library/j-jtp09263/">thread-compatible</a>.
- * Separate {@code StreamObserver}s do
+ * <p>Implementations are not required to be thread-safe (but should be
+ * <a href="https://web.archive.org/web/20210125044505/https://www.ibm.com/developerworks/java/library/j-jtp09263/index.html">
+ * thread-compatible</a>). Separate {@code StreamObserver}s do
  * not need to be synchronized together; incoming and outgoing directions are independent.
  * Since individual {@code StreamObserver}s are not thread-safe, if multiple threads will be
  * writing to a {@code StreamObserver} concurrently, the application must synchronize calls.
+ *
+ * <p>This API is asynchronous, so methods may return before the operation completes. The API
+ * provides no guarantees for how quickly an operation will complete, so utilizing flow control via
+ * {@link ClientCallStreamObserver} and {@link ServerCallStreamObserver} to avoid excessive
+ * buffering is recommended for streaming RPCs. gRPC's implementation of {@code onError()} on
+ * client-side causes the RPC to be cancelled and discards all messages, so completes quickly.
+ *
+ * <p>gRPC guarantees it does not block on I/O in its implementation, but applications are allowed
+ * to perform blocking operations in their implementations. However, doing so will delay other
+ * callbacks because the methods cannot be called concurrently.
  */
 public interface StreamObserver<V>  {
   /**
diff --git a/stub/src/main/java/io/grpc/stub/StreamObservers.java b/stub/src/main/java/io/grpc/stub/StreamObservers.java
index 20a6d0d19bd..a421d3eca2f 100644
--- a/stub/src/main/java/io/grpc/stub/StreamObservers.java
+++ b/stub/src/main/java/io/grpc/stub/StreamObservers.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
@@ -39,11 +24,24 @@
  * Utility functions for working with {@link StreamObserver} and it's common subclasses like
  * {@link CallStreamObserver}.
  */
-@ExperimentalApi
 public final class StreamObservers {
+  // Prevent instantiation
+  private StreamObservers() { }
+
+  /**
+   * Utility method to call {@link StreamObserver#onNext(Object)} and
+   * {@link StreamObserver#onCompleted()} on the specified responseObserver.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10957")
+  public static <T> void nextAndComplete(StreamObserver<T> responseObserver, T response) {
+    responseObserver.onNext(response);
+    responseObserver.onCompleted();
+  }
+
   /**
    * Copy the values of an {@link Iterator} to the target {@link CallStreamObserver} while properly
-   * accounting for outbound flow-control.
+   * accounting for outbound flow-control.  After calling this method, {@code target} should no
+   * longer be used.
    *
    * <p>For clients this method is safe to call inside {@link ClientResponseObserver#beforeStart},
    * on servers it is safe to call inside the service method implementation.
@@ -51,27 +49,42 @@ public final class StreamObservers {
    *
    * @param source of values expressed as an {@link Iterator}.
    * @param target {@link CallStreamObserver} which accepts values from the source.
+   * @deprecated Of questionable utility and generally not used.
    */
+  @Deprecated
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4694")
   public static <V> void copyWithFlowControl(final Iterator<V> source,
       final CallStreamObserver<V> target) {
     Preconditions.checkNotNull(source, "source");
     Preconditions.checkNotNull(target, "target");
-    target.setOnReadyHandler(new Runnable() {
+
+    final class FlowControllingOnReadyHandler implements Runnable {
+      private boolean completed;
+
       @Override
       public void run() {
+        if (completed) {
+          return;
+        }
+
         while (target.isReady() && source.hasNext()) {
           target.onNext(source.next());
         }
+
         if (!source.hasNext()) {
+          completed = true;
           target.onCompleted();
         }
       }
-    });
+    }
+
+    target.setOnReadyHandler(new FlowControllingOnReadyHandler());
   }
 
   /**
    * Copy the values of an {@link Iterable} to the target {@link CallStreamObserver} while properly
-   * accounting for outbound flow-control.
+   * accounting for outbound flow-control.  After calling this method, {@code target} should no
+   * longer be used.
    *
    * <p>For clients this method is safe to call inside {@link ClientResponseObserver#beforeStart},
    * on servers it is safe to call inside the service method implementation.
@@ -79,7 +92,10 @@ public void run() {
    *
    * @param source of values expressed as an {@link Iterable}.
    * @param target {@link CallStreamObserver} which accepts values from the source.
+   * @deprecated Of questionable utility and generally not used.
    */
+  @Deprecated
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/4694")
   public static <V> void copyWithFlowControl(final Iterable<V> source,
       CallStreamObserver<V> target) {
     Preconditions.checkNotNull(source, "source");
diff --git a/stub/src/main/java/io/grpc/stub/annotations/GrpcGenerated.java b/stub/src/main/java/io/grpc/stub/annotations/GrpcGenerated.java
new file mode 100644
index 00000000000..7cd0a3ae702
--- /dev/null
+++ b/stub/src/main/java/io/grpc/stub/annotations/GrpcGenerated.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2021 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.stub.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotates that the class is gRPC-generated code to assist
+ * <a href="https://docs.oracle.com/javase/6/docs/api/javax/annotation/processing/Processor.html">
+ * Java Annotation Processors.</a>
+ *
+ * <p>This annotation is used by the gRPC stub compiler to annotate outer classes. Users should not
+ * annotate their own classes with this annotation. Not all stubs may have this annotation, so
+ * consumers should not assume that it is present.
+ *
+ * @since 1.40.0
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.TYPE)
+public @interface GrpcGenerated {}
diff --git a/stub/src/main/java/io/grpc/stub/annotations/RpcMethod.java b/stub/src/main/java/io/grpc/stub/annotations/RpcMethod.java
new file mode 100644
index 00000000000..3615eddfa79
--- /dev/null
+++ b/stub/src/main/java/io/grpc/stub/annotations/RpcMethod.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2018 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.stub.annotations;
+
+import io.grpc.MethodDescriptor;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * {@link RpcMethod} contains a limited subset of information about the RPC to assist
+ * <a href="https://docs.oracle.com/javase/6/docs/api/javax/annotation/processing/Processor.html">
+ * Java Annotation Processors</a>.
+ *
+ * <p>
+ *   This annotation is used by the gRPC stub compiler to annotate {@link MethodDescriptor}
+ *   getters.  Users should not annotate their own classes with this annotation.  Not all stubs may
+ *   have this annotation, so consumers should not assume that it is present.
+ * </p>
+ *
+ * @since 1.14.0
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.METHOD)
+public @interface RpcMethod {
+
+  /**
+   * The fully qualified method name.  This should match the name as returned by
+   * {@link MethodDescriptor#generateFullMethodName(String, String)}.
+   */
+  String fullMethodName();
+
+  /**
+   * The request type of the method.  The request type class should be assignable from (i.e.
+   * {@link Class#isAssignableFrom(Class)} the request type {@code ReqT} of the
+   * {@link MethodDescriptor}.  Additionally, if the request {@code MethodDescriptor.Marshaller}
+   * is a {@code MethodDescriptor.ReflectableMarshaller}, the request type should be assignable
+   * from {@code MethodDescriptor.ReflectableMarshaller#getMessageClass()}.
+   */
+  Class<?> requestType();
+
+  /**
+   * The response type of the method.  The response type class should be assignable from (i.e.
+   * {@link Class#isAssignableFrom(Class)} the response type {@code RespT} of the
+   * {@link MethodDescriptor}.  Additionally, if the response {@code MethodDescriptor.Marshaller}
+   * is a {@code MethodDescriptor.ReflectableMarshaller}, the response type should be assignable
+   * from {@code MethodDescriptor.ReflectableMarshaller#getMessageClass()}.
+   */
+  Class<?> responseType();
+
+  /**
+   * The call type of the method.
+   */
+  MethodDescriptor.MethodType methodType();
+}
diff --git a/stub/src/main/java/io/grpc/stub/package-info.java b/stub/src/main/java/io/grpc/stub/package-info.java
new file mode 100644
index 00000000000..fa10854798b
--- /dev/null
+++ b/stub/src/main/java/io/grpc/stub/package-info.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2017 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.
+ */
+
+/**
+ * API for the Stub layer.
+ *
+ * <p>The gRPC Java API is split into two main parts: The stub layer and the call layer. The stub
+ * layer is a wrapper around the call layer.
+ *
+ * <p>In the most common case of gRPC over Protocol Buffers, stub classes are automatically
+ * generated from service definition .proto files by the Protobuf compiler. See <a
+ * href="https://grpc.io/docs/reference/java/generated-code.html">gRPC Java Generated Code Guide</a>
+ * .
+ *
+ * <p>The server side stub classes are abstract classes with RPC methods for the server application
+ * to implement/override. These classes internally use {@link io.grpc.stub.ServerCalls} to interact
+ * with the call layer. The RPC methods consume a {@link io.grpc.stub.StreamObserver} object {@code
+ * responseObserver} as one of its arguments. When users are implementing/override these
+ * methods in the server application, they may call the {@link io.grpc.stub.StreamObserver#onNext
+ * onNext()}, {@link io.grpc.stub.StreamObserver#onError onError()} and {@link
+ * io.grpc.stub.StreamObserver#onCompleted onCompleted()} methods on the {@code responseObserver}
+ * argument to send out a response message, error and completion notification respectively. If the
+ * RPC is client-streaming or bidirectional-streaming, the abstract RPC method should return a
+ * {@code requestObserver} which is also a {@link io.grpc.stub.StreamObserver} object. User should
+ * typically implement the {@link io.grpc.stub.StreamObserver#onNext onNext()}, {@link
+ * io.grpc.stub.StreamObserver#onError onError()} and {@link io.grpc.stub.StreamObserver#onCompleted
+ * onCompleted()} callbacks of {@code requestObserver} to define how the server application would
+ * react when receiving a message, error and completion notification respectively from the client
+ * side.
+ *
+ * <p>The client side stub classes are implementations of {@link io.grpc.stub.AbstractStub} that
+ * provide the RPC methods for the client application to call. The RPC methods in the client stubs
+ * internally use {@link io.grpc.stub.ClientCalls} to interact with the call layer. For asynchronous
+ * stubs, the RPC methods also consume a {@link io.grpc.stub.StreamObserver} object {@code
+ * responseObserver} as one of its arguments, and moreover for client-streaming or
+ * bidirectional-streaming, also return a {@code requestObserver} which is also a {@link
+ * io.grpc.stub.StreamObserver} object. In contrast to the server side, users should implement the
+ * {@link io.grpc.stub.StreamObserver#onNext onNext()}, {@link io.grpc.stub.StreamObserver#onError
+ * onError()} and {@link io.grpc.stub.StreamObserver#onCompleted onCompleted()} callbacks of {@code
+ * responseObserver} to define what the client application would do when receiving a response
+ * message, error and completion notification respectively from the server side, and then pass the
+ * {@code responseObserver} to the RPC method in the client stub. If the RPC method returns a {@code
+ * requestObserver}, users should call the {@link io.grpc.stub.StreamObserver#onNext onNext()},
+ * {@link io.grpc.stub.StreamObserver#onError onError()} and {@link
+ * io.grpc.stub.StreamObserver#onCompleted onCompleted()} methods on the {@code requestObserver} to
+ * send out a request message, error and completion notification respectively.
+ */
+package io.grpc.stub;
diff --git a/stub/src/test/java/io/grpc/stub/AbstractAsyncStubTest.java b/stub/src/test/java/io/grpc/stub/AbstractAsyncStubTest.java
new file mode 100644
index 00000000000..0277b7a66ca
--- /dev/null
+++ b/stub/src/test/java/io/grpc/stub/AbstractAsyncStubTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2019 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.stub;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.stub.AbstractAsyncStubTest.NoopAsyncStub;
+import io.grpc.stub.AbstractBlockingStubTest.NoopBlockingStub;
+import io.grpc.stub.AbstractFutureStubTest.NoopFutureStub;
+import io.grpc.stub.AbstractStub.StubFactory;
+import io.grpc.stub.ClientCalls.StubType;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class AbstractAsyncStubTest extends BaseAbstractStubTest<NoopAsyncStub> {
+
+  @Override
+  NoopAsyncStub create(Channel channel, CallOptions callOptions) {
+    return new NoopAsyncStub(channel, callOptions);
+  }
+
+  @Test
+  public void defaultCallOptions() {
+    NoopAsyncStub stub = NoopAsyncStub.newStub(new StubFactory<NoopAsyncStub>() {
+      @Override
+      public NoopAsyncStub newStub(Channel channel, CallOptions callOptions) {
+        return create(channel, callOptions);
+      }
+    }, channel, CallOptions.DEFAULT);
+
+    assertThat(stub.getCallOptions().getOption(ClientCalls.STUB_TYPE_OPTION))
+        .isEqualTo(StubType.ASYNC);
+  }
+
+  @Test
+  @SuppressWarnings("AssertionFailureIgnored")
+  public void newStub_futureStub_throwsException() {
+    try {
+      NoopFutureStub unused = NoopAsyncStub.newStub(new StubFactory<NoopFutureStub>() {
+        @Override
+        public NoopFutureStub newStub(Channel channel, CallOptions callOptions) {
+          return new NoopFutureStub(channel, callOptions);
+        }
+      }, channel, CallOptions.DEFAULT);
+      fail("should not reach here");
+    } catch (AssertionError e) {
+      assertThat(e).hasMessageThat().startsWith("Expected AbstractAsyncStub");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("AssertionFailureIgnored")
+  public void newStub_blockingStub_throwsException() {
+    try {
+      NoopBlockingStub unused = NoopAsyncStub.newStub(new StubFactory<NoopBlockingStub>() {
+        @Override
+        public NoopBlockingStub newStub(Channel channel, CallOptions callOptions) {
+          return new NoopBlockingStub(channel, callOptions);
+        }
+      }, channel, CallOptions.DEFAULT);
+      fail("should not reach here");
+    } catch (AssertionError e) {
+      assertThat(e).hasMessageThat().startsWith("Expected AbstractAsyncStub");
+    }
+  }
+
+  static class NoopAsyncStub extends AbstractAsyncStub<NoopAsyncStub> {
+
+    NoopAsyncStub(Channel channel, CallOptions options) {
+      super(channel, options);
+    }
+
+    @Override
+    protected NoopAsyncStub build(Channel channel, CallOptions callOptions) {
+      return new NoopAsyncStub(channel, callOptions);
+    }
+  }
+}
diff --git a/stub/src/test/java/io/grpc/stub/AbstractBlockingStubTest.java b/stub/src/test/java/io/grpc/stub/AbstractBlockingStubTest.java
new file mode 100644
index 00000000000..a3477da2bb5
--- /dev/null
+++ b/stub/src/test/java/io/grpc/stub/AbstractBlockingStubTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2019 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.stub;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.stub.AbstractAsyncStubTest.NoopAsyncStub;
+import io.grpc.stub.AbstractBlockingStubTest.NoopBlockingStub;
+import io.grpc.stub.AbstractFutureStubTest.NoopFutureStub;
+import io.grpc.stub.AbstractStub.StubFactory;
+import io.grpc.stub.ClientCalls.StubType;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class AbstractBlockingStubTest extends BaseAbstractStubTest<NoopBlockingStub> {
+
+  @Override
+  NoopBlockingStub create(Channel channel, CallOptions callOptions) {
+    return new NoopBlockingStub(channel, callOptions);
+  }
+
+  @Test
+  public void defaultCallOptions() {
+    NoopBlockingStub stub = NoopBlockingStub.newStub(new StubFactory<NoopBlockingStub>() {
+      @Override
+      public NoopBlockingStub newStub(Channel channel, CallOptions callOptions) {
+        return create(channel, callOptions);
+      }
+    }, channel, CallOptions.DEFAULT);
+
+    assertThat(stub.getCallOptions().getOption(ClientCalls.STUB_TYPE_OPTION))
+        .isEqualTo(StubType.BLOCKING);
+  }
+
+  @Test
+  @SuppressWarnings("AssertionFailureIgnored")
+  public void newStub_asyncStub_throwsException() {
+    try {
+      NoopAsyncStub unused = NoopBlockingStub.newStub(new StubFactory<NoopAsyncStub>() {
+        @Override
+        public NoopAsyncStub newStub(Channel channel, CallOptions callOptions) {
+          return new NoopAsyncStub(channel, callOptions);
+        }
+      }, channel, CallOptions.DEFAULT);
+      fail("should not reach here");
+    } catch (AssertionError e) {
+      assertThat(e).hasMessageThat().startsWith("Expected AbstractBlockingStub");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("AssertionFailureIgnored")
+  public void newStub_futureStub_throwsException() {
+    try {
+      NoopFutureStub unused = NoopBlockingStub.newStub(new StubFactory<NoopFutureStub>() {
+        @Override
+        public NoopFutureStub newStub(Channel channel, CallOptions callOptions) {
+          return new NoopFutureStub(channel, callOptions);
+        }
+      }, channel, CallOptions.DEFAULT);
+      fail("should not reach here");
+    } catch (AssertionError e) {
+      assertThat(e).hasMessageThat().startsWith("Expected AbstractBlockingStub");
+    }
+  }
+
+  static class NoopBlockingStub extends AbstractBlockingStub<NoopBlockingStub> {
+
+    NoopBlockingStub(Channel channel, CallOptions options) {
+      super(channel, options);
+    }
+
+    @Override
+    protected NoopBlockingStub build(Channel channel, CallOptions callOptions) {
+      return new NoopBlockingStub(channel, callOptions);
+    }
+  }
+}
\ No newline at end of file
diff --git a/stub/src/test/java/io/grpc/stub/AbstractFutureStubTest.java b/stub/src/test/java/io/grpc/stub/AbstractFutureStubTest.java
new file mode 100644
index 00000000000..0c0fdaac91f
--- /dev/null
+++ b/stub/src/test/java/io/grpc/stub/AbstractFutureStubTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2019 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.stub;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.stub.AbstractAsyncStubTest.NoopAsyncStub;
+import io.grpc.stub.AbstractBlockingStubTest.NoopBlockingStub;
+import io.grpc.stub.AbstractFutureStubTest.NoopFutureStub;
+import io.grpc.stub.AbstractStub.StubFactory;
+import io.grpc.stub.ClientCalls.StubType;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class AbstractFutureStubTest extends BaseAbstractStubTest<NoopFutureStub> {
+
+  @Override
+  NoopFutureStub create(Channel channel, CallOptions callOptions) {
+    return new NoopFutureStub(channel, callOptions);
+  }
+
+  @Test
+  public void defaultCallOptions() {
+    NoopFutureStub stub = NoopFutureStub.newStub(new StubFactory<NoopFutureStub>() {
+      @Override
+      public NoopFutureStub newStub(Channel channel, CallOptions callOptions) {
+        return create(channel, callOptions);
+      }
+    }, channel, CallOptions.DEFAULT);
+
+    assertThat(stub.getCallOptions().getOption(ClientCalls.STUB_TYPE_OPTION))
+        .isEqualTo(StubType.FUTURE);
+  }
+
+  @Test
+  @SuppressWarnings("AssertionFailureIgnored")
+  public void newStub_asyncStub_throwsException() {
+    try {
+      NoopAsyncStub unused = NoopFutureStub.newStub(new StubFactory<NoopAsyncStub>() {
+        @Override
+        public NoopAsyncStub newStub(Channel channel, CallOptions callOptions) {
+          return new NoopAsyncStub(channel, callOptions);
+        }
+      }, channel, CallOptions.DEFAULT);
+      fail("should not reach here");
+    } catch (AssertionError e) {
+      assertThat(e).hasMessageThat().startsWith("Expected AbstractFutureStub");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("AssertionFailureIgnored")
+  public void newStub_blockingStub_throwsException() {
+    try {
+      NoopBlockingStub unused = NoopFutureStub.newStub(new StubFactory<NoopBlockingStub>() {
+        @Override
+        public NoopBlockingStub newStub(Channel channel, CallOptions callOptions) {
+          return new NoopBlockingStub(channel, callOptions);
+        }
+      }, channel, CallOptions.DEFAULT);
+      fail("should not reach here");
+    } catch (AssertionError e) {
+      assertThat(e).hasMessageThat().startsWith("Expected AbstractFutureStub");
+    }
+  }
+
+  static class NoopFutureStub extends AbstractFutureStub<NoopFutureStub> {
+
+    NoopFutureStub(Channel channel, CallOptions options) {
+      super(channel, options);
+    }
+
+    @Override
+    protected NoopFutureStub build(Channel channel, CallOptions callOptions) {
+      return new NoopFutureStub(channel, callOptions);
+    }
+  }
+}
\ No newline at end of file
diff --git a/stub/src/test/java/io/grpc/stub/AbstractStubTest.java b/stub/src/test/java/io/grpc/stub/AbstractStubTest.java
index 1300629be4d..352a2fb7fe2 100644
--- a/stub/src/test/java/io/grpc/stub/AbstractStubTest.java
+++ b/stub/src/test/java/io/grpc/stub/AbstractStubTest.java
@@ -1,91 +1,76 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2019 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static com.google.common.truth.Truth.assertAbout;
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.testing.DeadlineSubject.deadline;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.MINUTES;
 
 import io.grpc.CallOptions;
 import io.grpc.Channel;
-import org.junit.Before;
+import io.grpc.Deadline;
+import io.grpc.stub.AbstractStub.StubFactory;
+import io.grpc.stub.AbstractStubTest.NoopStub;
+import java.time.Duration;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
 
 @RunWith(JUnit4.class)
-public class AbstractStubTest {
-
-  @Mock
-  Channel channel;
+public class AbstractStubTest extends BaseAbstractStubTest<NoopStub> {
 
-  @Before
-  public void setup() {
-    MockitoAnnotations.initMocks(this);
+  @Override
+  NoopStub create(Channel channel, CallOptions callOptions) {
+    return new NoopStub(channel, callOptions);
   }
 
-  @Test(expected = NullPointerException.class)
-  public void channelMustNotBeNull() {
-    new NoopStub(null);
-  }
-
-  @Test(expected = NullPointerException.class)
-  public void callOptionsMustNotBeNull() {
-    new NoopStub(channel, null);
-  }
+  @Test
+  public void defaultCallOptions() {
+    NoopStub stub = NoopStub.newStub(new StubFactory<NoopStub>() {
+      @Override
+      public NoopStub newStub(Channel channel, CallOptions callOptions) {
+        return create(channel, callOptions);
+      }
+    }, channel, CallOptions.DEFAULT);
 
-  @Test(expected = NullPointerException.class)
-  public void channelMustNotBeNull2() {
-    new NoopStub(null, CallOptions.DEFAULT);
+    assertThat(stub.getCallOptions().getOption(ClientCalls.STUB_TYPE_OPTION))
+        .isNull();
   }
 
-  @Test()
-  public void withWaitForReady() {
-    NoopStub stub = new NoopStub(channel);
-    CallOptions callOptions = stub.getCallOptions();
-    assertFalse(callOptions.isWaitForReady());
+  @Test
+  @IgnoreJRERequirement
+  public void testDuration() {
+    NoopStub stub = NoopStub.newStub(new StubFactory<NoopStub>() {
+      @Override
+      public NoopStub newStub(Channel channel, CallOptions callOptions) {
+        return create(channel, callOptions);
+      }
+    }, channel, CallOptions.DEFAULT);
+    NoopStub stubInstance = stub.withDeadlineAfter(Duration.ofMinutes(1L));
+    Deadline actual = stubInstance.getCallOptions().getDeadline();
+    Deadline expected = Deadline.after(1, MINUTES);
 
-    stub = stub.withWaitForReady();
-    callOptions = stub.getCallOptions();
-    assertTrue(callOptions.isWaitForReady());
+    assertAbout(deadline()).that(actual).isWithin(10, MILLISECONDS).of(expected);
   }
 
   class NoopStub extends AbstractStub<NoopStub> {
-
-    NoopStub(Channel channel) {
-      super(channel);
-    }
-
     NoopStub(Channel channel, CallOptions options) {
       super(channel, options);
     }
@@ -96,3 +81,4 @@ protected NoopStub build(Channel channel, CallOptions callOptions) {
     }
   }
 }
+
diff --git a/stub/src/test/java/io/grpc/stub/BaseAbstractStubTest.java b/stub/src/test/java/io/grpc/stub/BaseAbstractStubTest.java
new file mode 100644
index 00000000000..9f7f10d8298
--- /dev/null
+++ b/stub/src/test/java/io/grpc/stub/BaseAbstractStubTest.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2016 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.stub;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import java.util.concurrent.Executor;
+import javax.annotation.Nullable;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Standard unit tests for AbstractStub and its subclasses. */
+abstract class BaseAbstractStubTest<T extends AbstractStub<T>> {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock
+  Channel channel;
+
+  T create(Channel channel) {
+    return create(channel, CallOptions.DEFAULT);
+  }
+
+  abstract T create(@Nullable Channel channel, @Nullable CallOptions callOptions);
+
+  @Test
+  public void callOptionsMustNotBeNull() {
+    try {
+      create(channel, null);
+      fail("NullPointerException expected");
+    } catch (NullPointerException npe) {
+      // expected
+    }
+  }
+
+  @Test
+  public void channelMustNotBeNull2() {
+    try {
+      create(null, CallOptions.DEFAULT);
+      fail("NullPointerException expected");
+    } catch (NullPointerException npe) {
+      // expected
+    }
+  }
+
+  @Test
+  public void withWaitForReady() {
+    T stub = create(channel);
+    CallOptions callOptions = stub.getCallOptions();
+    assertFalse(callOptions.isWaitForReady());
+
+    stub = stub.withWaitForReady();
+    callOptions = stub.getCallOptions();
+    assertTrue(callOptions.isWaitForReady());
+  }
+
+  @Test
+  public void withExecutor() {
+    T stub = create(channel);
+    CallOptions callOptions = stub.getCallOptions();
+
+    assertNull(callOptions.getExecutor());
+
+    Executor executor = mock(Executor.class);
+    stub = stub.withExecutor(executor);
+    callOptions = stub.getCallOptions();
+
+    assertEquals(callOptions.getExecutor(), executor);
+  }
+
+  @Test
+  public void withOnReadyThreshold() {
+    T stub = create(channel);
+    CallOptions callOptions = stub.getCallOptions();
+    assertNull(callOptions.getOnReadyThreshold());
+
+    int onReadyThreshold = 1024;
+    stub = stub.withOnReadyThreshold(onReadyThreshold);
+    callOptions = stub.getCallOptions();
+    assertThat(callOptions.getOnReadyThreshold()).isEqualTo(onReadyThreshold);
+  }
+}
diff --git a/stub/src/test/java/io/grpc/stub/BlockingClientCallTest.java b/stub/src/test/java/io/grpc/stub/BlockingClientCallTest.java
new file mode 100644
index 00000000000..e3a4f90e2c2
--- /dev/null
+++ b/stub/src/test/java/io/grpc/stub/BlockingClientCallTest.java
@@ -0,0 +1,499 @@
+/*
+ * Copyright 2023 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.stub;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.grpc.CallOptions;
+import io.grpc.ManagedChannel;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.Server;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.ServiceDescriptor;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.StatusException;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.stub.ServerCalls.BidiStreamingMethod;
+import io.grpc.stub.ServerCallsTest.IntegerMarshaller;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Logger;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class BlockingClientCallTest {
+  private static final Logger logger = Logger.getLogger(BlockingClientCallTest.class.getName());
+
+  public static final int DELAY_MILLIS = 2000;
+  public static final long DELAY_NANOS = TimeUnit.MILLISECONDS.toNanos(DELAY_MILLIS);
+  private static final MethodDescriptor<Integer, Integer> BIDI_STREAMING_METHOD =
+      MethodDescriptor.<Integer, Integer>newBuilder()
+          .setType(MethodType.BIDI_STREAMING)
+          .setFullMethodName("some/method")
+          .setRequestMarshaller(new IntegerMarshaller())
+          .setResponseMarshaller(new IntegerMarshaller())
+          .build();
+
+  private Server server;
+
+  private ManagedChannel channel;
+
+  private IntegerTestMethod testMethod;
+  private BlockingClientCall<Integer, Integer> biDiStream;
+
+  @Before
+  public void setUp() throws Exception {
+    testMethod = new IntegerTestMethod();
+
+    ServerServiceDefinition service = ServerServiceDefinition.builder(
+            new ServiceDescriptor("some", BIDI_STREAMING_METHOD))
+        .addMethod(BIDI_STREAMING_METHOD, ServerCalls.asyncBidiStreamingCall(testMethod))
+        .build();
+    long tag = System.nanoTime();
+
+    server = InProcessServerBuilder.forName("go-with-the-flow" + tag).directExecutor()
+        .addService(service).build().start();
+
+    channel = InProcessChannelBuilder.forName("go-with-the-flow" + tag).directExecutor().build();
+  }
+
+  @After
+  public void tearDown() {
+    if (server != null) {
+      server.shutdownNow();
+    }
+    if (channel != null) {
+      channel.shutdownNow();
+    }
+    if (biDiStream != null) {
+      biDiStream.cancel("In teardown", null);
+    }
+  }
+
+  @Test
+  public void sanityTest() throws Exception {
+    Integer req = 2;
+    biDiStream = ClientCalls.blockingBidiStreamingCall(channel,  BIDI_STREAMING_METHOD,
+        CallOptions.DEFAULT);
+
+    //  verify activity ready
+    assertTrue(biDiStream.isEitherReadOrWriteReady());
+    assertTrue(biDiStream.isWriteReady());
+
+    // Have server send a value
+    testMethod.sendValueToClient(10);
+
+    // Do a writeOrRead
+    biDiStream.write(req, 3, TimeUnit.SECONDS);
+    assertEquals(Integer.valueOf(10), biDiStream.read(DELAY_MILLIS, TimeUnit.MILLISECONDS));
+
+    // mark complete
+    biDiStream.halfClose();
+    assertNull(biDiStream.read(2, TimeUnit.SECONDS));
+
+    // verify activity !ready and !writeable
+    assertFalse(biDiStream.isEitherReadOrWriteReady());
+    assertFalse(biDiStream.isWriteReady());
+
+    assertEquals(Code.OK, biDiStream.getClosedStatus().getCode());
+  }
+
+  @Test
+  public void testReadSuccess_withoutBlocking() throws Exception {
+    biDiStream = ClientCalls.blockingBidiStreamingCall(channel,  BIDI_STREAMING_METHOD,
+        CallOptions.DEFAULT);
+
+    // Have server push a value
+    testMethod.sendValueToClient(11);
+
+    long start = System.nanoTime();
+    Integer value = biDiStream.read(100, TimeUnit.SECONDS);
+    assertNotNull(value);
+    long timeTaken = System.nanoTime() - start;
+    assertThat(timeTaken).isLessThan(TimeUnit.MILLISECONDS.toNanos(100));
+  }
+
+  @Test
+  public void testReadSuccess_withBlocking() throws Exception {
+    biDiStream = ClientCalls.blockingBidiStreamingCall(channel,  BIDI_STREAMING_METHOD,
+        CallOptions.DEFAULT);
+
+    try {
+      biDiStream.read(1, TimeUnit.SECONDS);
+      fail("Expected timeout");
+    } catch (TimeoutException t) {
+      // ignore
+    }
+
+    long start = System.nanoTime();
+    delayedAddValue(DELAY_MILLIS, 12);
+    assertNotNull(biDiStream.read(DELAY_MILLIS * 2, TimeUnit.MILLISECONDS));
+    long timeTaken = System.nanoTime() - start;
+    assertThat(timeTaken).isGreaterThan(DELAY_NANOS);
+    assertThat(timeTaken).isLessThan(DELAY_NANOS * 2);
+
+    start = System.nanoTime();
+    Integer[] values = {13, 14, 15, 16};
+    delayedAddValue(DELAY_MILLIS, values);
+    for (Integer value : values) {
+      Integer readValue = biDiStream.read(DELAY_MILLIS * 2, TimeUnit.MILLISECONDS);
+      assertEquals(value, readValue);
+    }
+    timeTaken = System.nanoTime() - start;
+    assertThat(timeTaken).isLessThan(DELAY_NANOS * 2);
+    assertThat(timeTaken).isAtLeast(DELAY_NANOS);
+
+    start = System.nanoTime();
+    delayedVoidMethod(100, testMethod::halfClose);
+    assertNull(biDiStream.read(DELAY_MILLIS * 2, TimeUnit.MILLISECONDS));
+    timeTaken = System.nanoTime() - start;
+    assertThat(timeTaken).isLessThan(DELAY_NANOS);
+  }
+
+  @Test
+  public void testCancel() throws Exception {
+    testMethod.disableAutoRequest();
+    biDiStream = ClientCalls.blockingBidiStreamingCall(channel,  BIDI_STREAMING_METHOD,
+        CallOptions.DEFAULT);
+
+    // read terminated
+    long start = System.currentTimeMillis();
+    delayedCancel(biDiStream, "cancel read");
+    try {
+      assertNull(biDiStream.read(2 * DELAY_MILLIS, TimeUnit.MILLISECONDS));
+      fail("No exception thrown by read after cancel");
+    } catch (StatusException e) {
+      assertEquals(Status.CANCELLED.getCode(), e.getStatus().getCode());
+      assertThat(System.currentTimeMillis() - start).isLessThan(2 * DELAY_MILLIS);
+    }
+
+    // after cancel tests
+    biDiStream = ClientCalls.blockingBidiStreamingCall(channel,  BIDI_STREAMING_METHOD,
+        CallOptions.DEFAULT);
+    biDiStream.cancel("cancel write", new RuntimeException("Test requested close"));
+
+    // Write after cancel should throw an exception
+    try {
+      start = System.currentTimeMillis();
+      biDiStream.write(30);
+      fail("No exception doing write after cancel");
+    } catch (IllegalStateException e) {
+      assertThat(System.currentTimeMillis() - start).isLessThan(200);
+      assertThat(e.getMessage()).contains("cancel");
+    }
+
+    // new read after cancel immediately throws an exception
+    try {
+      start = System.currentTimeMillis();
+      assertNull(biDiStream.read(2, TimeUnit.SECONDS));
+    } catch (StatusException e) {
+      assertEquals(Status.CANCELLED.getCode(), e.getStatus().getCode());
+      assertThat(System.currentTimeMillis() - start).isLessThan(200);
+    }
+
+  }
+
+  @Test
+  public void testIsActivityReady() throws Exception {
+    biDiStream = ClientCalls.blockingBidiStreamingCall(channel,  BIDI_STREAMING_METHOD,
+        CallOptions.DEFAULT);
+
+    // write only ready
+    assertTrue(biDiStream.isEitherReadOrWriteReady());
+    assertTrue(biDiStream.isWriteReady());
+    assertFalse(biDiStream.isReadReady());
+
+    // both ready
+    testMethod.sendValueToClient(40);
+    assertTrue(biDiStream.isEitherReadOrWriteReady());
+    assertTrue(biDiStream.isReadReady());
+    assertTrue(biDiStream.isWriteReady());
+
+    // read only ready
+    biDiStream.halfClose();
+    assertTrue(biDiStream.isEitherReadOrWriteReady());
+    assertTrue(biDiStream.isReadReady());
+    assertFalse(biDiStream.isWriteReady());
+
+    // Neither ready
+    assertNotNull(biDiStream.read(1, TimeUnit.MILLISECONDS));
+    assertFalse(biDiStream.isEitherReadOrWriteReady());
+    assertFalse(biDiStream.isReadReady());
+    assertFalse(biDiStream.isWriteReady());
+  }
+
+  @Test
+  public void testWriteSuccess_withBlocking() throws Exception {
+    testMethod.disableAutoRequest();
+    biDiStream = ClientCalls.blockingBidiStreamingCall(channel,  BIDI_STREAMING_METHOD,
+        CallOptions.DEFAULT);
+
+    assertFalse(biDiStream.isWriteReady());
+    delayedWriteEnable(500);
+    assertTrue(biDiStream.write(40));
+
+    delayedWriteEnable(500);
+    assertTrue(biDiStream.write(41, 0, TimeUnit.NANOSECONDS));
+  }
+
+
+  @Test
+  public void testReadNonblocking_whenWriteBlocked() throws Exception {
+    testMethod.disableAutoRequest();
+    biDiStream = ClientCalls.blockingBidiStreamingCall(channel,  BIDI_STREAMING_METHOD,
+        CallOptions.DEFAULT);
+
+    // One value waiting
+    testMethod.sendValueToClient(50);
+    long start = System.currentTimeMillis();
+    assertEquals(Integer.valueOf(50), biDiStream.read());
+    assertThat(System.currentTimeMillis() - start).isLessThan(DELAY_MILLIS);
+
+    // Two values waiting
+    start = System.currentTimeMillis();
+    testMethod.sendValuesToClient(51, 52);
+    assertEquals(Integer.valueOf(51), biDiStream.read());
+    assertEquals(Integer.valueOf(52), biDiStream.read());
+    assertThat(System.currentTimeMillis() - start).isLessThan(DELAY_MILLIS);
+  }
+
+  @Test
+  public void testReadsAndWritesInterleaved_withBlocking() throws Exception {
+    biDiStream = ClientCalls.blockingBidiStreamingCall(channel,  BIDI_STREAMING_METHOD,
+        CallOptions.DEFAULT);
+
+    Integer[] valuesOut = {1001, 10022, 1003};
+    Integer[] valuesIn = new Integer[valuesOut.length];
+    delayedAddValue(300, valuesOut);
+    int iteration = 0;
+    for (int i = 0; i < valuesOut.length && iteration++ < (20 + valuesOut.length); ) {
+      try {
+        if ((valuesIn[i] = biDiStream.read(50, TimeUnit.MILLISECONDS)) != null) {
+          i++;
+        }
+      } catch (TimeoutException e) {
+        logger.info("Read timed out for " + i);
+      }
+    }
+    assertArrayEquals(valuesOut, valuesIn);
+  }
+
+  @Test
+  public void testReadsAndWritesInterleaved_BlockingWrites() throws Exception {
+    testMethod.disableAutoRequest();
+    biDiStream = ClientCalls.blockingBidiStreamingCall(channel, BIDI_STREAMING_METHOD,
+        CallOptions.DEFAULT);
+
+    testMethod.sendValuesToClient(10, 11, 12);
+    delayedWriteEnable(500);
+    long start = System.currentTimeMillis();
+    boolean done = false;
+    int count = 0;
+    while (!done) {
+      count++;
+      if (!biDiStream.isWriteReady() && biDiStream.isReadReady()) {
+        biDiStream.read(100, TimeUnit.MILLISECONDS);
+      } else {
+        done = biDiStream.write(100, 1, TimeUnit.SECONDS);
+      }
+    }
+    assertEquals(4, count);
+    assertThat(System.currentTimeMillis() - start).isLessThan(700);
+
+    testMethod.sendValuesToClient(20, 21, 22);
+    delayedWriteEnable(100);
+    while (!biDiStream.isWriteReady()) {
+      Thread.sleep(20);
+    }
+
+    assertTrue(biDiStream.write(1000, 2 * DELAY_MILLIS, TimeUnit.MILLISECONDS));
+
+    assertEquals(Integer.valueOf(20), biDiStream.read(200, TimeUnit.MILLISECONDS));
+    assertEquals(Integer.valueOf(21), biDiStream.read(200, TimeUnit.MILLISECONDS));
+    assertEquals(Integer.valueOf(22), biDiStream.read(200, TimeUnit.MILLISECONDS));
+    try {
+      Integer value = biDiStream.read(200, TimeUnit.MILLISECONDS);
+      fail("Unexpected read success instead of timeout.  Value was: " + value);
+    } catch (TimeoutException ignore) {
+      // ignore since expected
+    }
+  }
+
+  @Test
+  public void testWriteAfterCloseThrows() throws Exception {
+    testMethod.disableAutoRequest();
+    biDiStream = ClientCalls.blockingBidiStreamingCall(channel,  BIDI_STREAMING_METHOD,
+        CallOptions.DEFAULT);
+
+    // verify new writes throw an illegalStateException
+    biDiStream.halfClose();
+    try {
+      assertFalse(biDiStream.write(2));
+      fail("write did not throw an exception when called after halfClose");
+    } catch (IllegalStateException e) {
+      assertThat(e.getMessage()).containsMatch("after.*halfClose.*cancel");
+    }
+  }
+
+  @Test
+  public void testClose_withException() throws Exception {
+    biDiStream = ClientCalls.blockingBidiStreamingCall(channel,  BIDI_STREAMING_METHOD,
+        CallOptions.DEFAULT);
+
+    String descr = "too many small numbers";
+    testMethod.sendError(
+        Status.FAILED_PRECONDITION.withDescription(descr).asRuntimeException());
+    Status closedStatus = biDiStream.getClosedStatus();
+    assertEquals(Code.FAILED_PRECONDITION, closedStatus.getCode());
+    assertEquals(descr, closedStatus.getDescription());
+    try {
+      assertFalse(biDiStream.write(1));
+    } catch (StatusException e) {
+      assertThat(e.getMessage()).startsWith("FAILED_PRECONDITION");
+    }
+  }
+
+  private void delayedAddValue(int delayMillis, Integer... values) {
+    new Thread("delayedAddValue " + values.length) {
+      @Override
+      public void run() {
+        try {
+          Thread.sleep(delayMillis);
+          for (Integer cur : values) {
+            testMethod.sendValueToClient(cur);
+          }
+        } catch (InterruptedException e) {
+          throw new RuntimeException(e);
+        }
+      }
+    }.start();
+  }
+
+  public interface Thunk { void apply(); } // supports passing void method w/out args
+
+  private void delayedVoidMethod(int delayMillis, Thunk method) {
+    new Thread("delayedHalfClose") {
+      @Override
+      public void run() {
+        try {
+          Thread.sleep(delayMillis);
+          method.apply();
+        } catch (InterruptedException e) {
+          throw new RuntimeException(e);
+        }
+      }
+    }.start();
+  }
+
+  private void delayedWriteEnable(int delayMillis) {
+    delayedVoidMethod(delayMillis, testMethod::readValueFromClient);
+  }
+
+  private void delayedCancel(BlockingClientCall<Integer, Integer> biDiStream, String message) {
+    new Thread("delayedCancel") {
+      @Override
+      public void run() {
+        try {
+          Thread.sleep(BlockingClientCallTest.DELAY_MILLIS);
+          biDiStream.cancel(message, new RuntimeException("Test requested close"));
+        } catch (InterruptedException e) {
+          throw new RuntimeException(e);
+        }
+      }
+    }.start();
+  }
+
+  private static class IntegerTestMethod implements BidiStreamingMethod<Integer, Integer> {
+    boolean autoRequest = true;
+
+    void disableAutoRequest() {
+      assertNull("Can't disable auto request after invoke has been called", serverCallObserver);
+      autoRequest = false;
+    }
+
+    ServerCallStreamObserver<Integer> serverCallObserver;
+
+    @Override
+    public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
+      serverCallObserver = (ServerCallStreamObserver<Integer>) responseObserver;
+      if (!autoRequest) {
+        serverCallObserver.disableAutoRequest();
+      }
+
+      return new StreamObserver<Integer>() {
+        @Override
+        public void onNext(Integer value) {
+          if (!autoRequest) {
+            serverCallObserver.request(1);
+          }
+
+          // For testing ReqResp actions
+          if (value > 1000) {
+            serverCallObserver.onNext(value);
+          }
+        }
+
+        @Override
+        public void onError(Throwable t) {
+          // no-op
+        }
+
+        @Override
+        public void onCompleted() {
+          serverCallObserver.onCompleted();
+        }
+      };
+    }
+
+    void readValueFromClient() {
+      serverCallObserver.request(1);
+    }
+
+    void sendValueToClient(int value) {
+      serverCallObserver.onNext(value);
+    }
+
+    private void sendValuesToClient(int ...values) {
+      for (int cur : values) {
+        sendValueToClient(cur);
+      }
+    }
+
+    void halfClose() {
+      serverCallObserver.onCompleted();
+    }
+
+    void sendError(Throwable t) {
+      serverCallObserver.onError(t);
+    }
+  }
+
+}
diff --git a/stub/src/test/java/io/grpc/stub/ClientCallsTest.java b/stub/src/test/java/io/grpc/stub/ClientCallsTest.java
index 396c0991510..b711b2a23b5 100644
--- a/stub/src/test/java/io/grpc/stub/ClientCallsTest.java
+++ b/stub/src/test/java/io/grpc/stub/ClientCallsTest.java
@@ -1,50 +1,45 @@
 /*
- * Copyright 2015, Google Inc. All rights reserved.
+ * Copyright 2015 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
 
 import static com.google.common.truth.Truth.assertThat;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.SettableFuture;
 import io.grpc.CallOptions;
+import io.grpc.Channel;
 import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
 import io.grpc.ManagedChannel;
 import io.grpc.Metadata;
 import io.grpc.MethodDescriptor;
+import io.grpc.NoopClientCall;
 import io.grpc.Server;
 import io.grpc.ServerServiceDefinition;
 import io.grpc.ServiceDescriptor;
@@ -52,9 +47,11 @@
 import io.grpc.StatusRuntimeException;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.stub.ClientCalls.StubType;
 import io.grpc.stub.ServerCalls.NoopStreamObserver;
+import io.grpc.stub.ServerCalls.ServerStreamingMethod;
+import io.grpc.stub.ServerCalls.UnaryMethod;
 import io.grpc.stub.ServerCallsTest.IntegerMarshaller;
-import io.grpc.testing.NoopClientCall;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Iterator;
@@ -62,36 +59,56 @@
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
-import org.mockito.MockitoAnnotations;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /**
  * Unit tests for {@link ClientCalls}.
  */
 @RunWith(JUnit4.class)
 public class ClientCallsTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
 
-  private static final MethodDescriptor<Integer, Integer> STREAMING_METHOD =
+  private static final MethodDescriptor<Integer, Integer> UNARY_METHOD =
       MethodDescriptor.<Integer, Integer>newBuilder()
-          .setType(MethodDescriptor.MethodType.BIDI_STREAMING)
+          .setType(MethodDescriptor.MethodType.UNARY)
           .setFullMethodName("some/method")
           .setRequestMarshaller(new IntegerMarshaller())
           .setResponseMarshaller(new IntegerMarshaller())
           .build();
+  private static final MethodDescriptor<Integer, Integer> SERVER_STREAMING_METHOD =
+      UNARY_METHOD.toBuilder().setType(MethodDescriptor.MethodType.SERVER_STREAMING).build();
+  private static final MethodDescriptor<Integer, Integer> BIDI_STREAMING_METHOD =
+      UNARY_METHOD.toBuilder().setType(MethodDescriptor.MethodType.BIDI_STREAMING).build();
 
   private Server server;
   private ManagedChannel channel;
+  @Mock
+  private ManagedChannel mockChannel;
+  @Captor
+  private ArgumentCaptor<MethodDescriptor<?, ?>> methodDescriptorCaptor;
+  @Captor
+  private ArgumentCaptor<CallOptions> callOptionsCaptor;
+  private boolean originalRejectRunnableOnExecutor;
 
   @Before
   public void setUp() {
-    MockitoAnnotations.initMocks(this);
+    originalRejectRunnableOnExecutor = ClientCalls.rejectRunnableOnExecutor;
   }
 
   @After
@@ -102,6 +119,7 @@ public void tearDown() {
     if (channel != null) {
       channel.shutdownNow();
     }
+    ClientCalls.rejectRunnableOnExecutor = originalRejectRunnableOnExecutor;
   }
 
   @Test
@@ -145,12 +163,162 @@ public void start(io.grpc.ClientCall.Listener<String> listener, Metadata headers
     }
   }
 
+  @Test
+  public void blockingUnaryCall2_success() throws Exception {
+    Integer req = 2;
+    final Integer resp = 3;
+
+    class BasicUnaryResponse implements UnaryMethod<Integer, Integer> {
+      Integer request;
+
+      @Override public void invoke(Integer request, StreamObserver<Integer> responseObserver) {
+        this.request = request;
+        responseObserver.onNext(resp);
+        responseObserver.onCompleted();
+      }
+    }
+
+    BasicUnaryResponse service = new BasicUnaryResponse();
+    server = InProcessServerBuilder.forName("simple-reply").directExecutor()
+        .addService(ServerServiceDefinition.builder("some")
+            .addMethod(UNARY_METHOD, ServerCalls.asyncUnaryCall(service))
+            .build())
+        .build().start();
+    channel = InProcessChannelBuilder.forName("simple-reply").directExecutor().build();
+    Integer actualResponse =
+        ClientCalls.blockingUnaryCall(channel, UNARY_METHOD, CallOptions.DEFAULT, req);
+    assertEquals(resp, actualResponse);
+    assertEquals(req, service.request);
+  }
+
+  @Test
+  public void blockingUnaryCall2_interruptedWaitsForOnClose() throws Exception {
+    Integer req = 2;
+
+    class NoopUnaryMethod implements UnaryMethod<Integer, Integer> {
+      ServerCallStreamObserver<Integer> observer;
+
+      @Override public void invoke(Integer request, StreamObserver<Integer> responseObserver) {
+        observer = (ServerCallStreamObserver<Integer>) responseObserver;
+      }
+    }
+
+    NoopUnaryMethod methodImpl = new NoopUnaryMethod();
+    server = InProcessServerBuilder.forName("noop").directExecutor()
+        .addService(ServerServiceDefinition.builder("some")
+            .addMethod(UNARY_METHOD, ServerCalls.asyncUnaryCall(methodImpl))
+            .build())
+        .build().start();
+
+    InterruptInterceptor interceptor = new InterruptInterceptor();
+    channel = InProcessChannelBuilder.forName("noop")
+        .directExecutor()
+        .intercept(interceptor)
+        .build();
+    try {
+      ClientCalls.blockingUnaryCall(channel, UNARY_METHOD, CallOptions.DEFAULT, req);
+      fail();
+    } catch (StatusRuntimeException ex) {
+      assertTrue(Thread.interrupted());
+      assertTrue("interrupted", ex.getCause() instanceof InterruptedException);
+    }
+    assertTrue("onCloseCalled", interceptor.onCloseCalled);
+    assertTrue("context not cancelled", methodImpl.observer.isCancelled());
+  }
+
+  @Test
+  public void blockingUnaryCall2_rejectExecutionOnClose() throws Exception {
+    Integer req = 2;
+
+    class NoopUnaryMethod implements UnaryMethod<Integer, Integer> {
+      ServerCallStreamObserver<Integer> observer;
+
+      @Override public void invoke(Integer request, StreamObserver<Integer> responseObserver) {
+        observer = (ServerCallStreamObserver<Integer>) responseObserver;
+      }
+    }
+
+    NoopUnaryMethod methodImpl = new NoopUnaryMethod();
+    server = InProcessServerBuilder.forName("noop").directExecutor()
+        .addService(ServerServiceDefinition.builder("some")
+            .addMethod(UNARY_METHOD, ServerCalls.asyncUnaryCall(methodImpl))
+            .build())
+        .build().start();
+
+    InterruptInterceptor interceptor = new InterruptInterceptor();
+    channel = InProcessChannelBuilder.forName("noop")
+        .directExecutor()
+        .intercept(interceptor)
+        .build();
+    try {
+      ClientCalls.blockingUnaryCall(channel, UNARY_METHOD, CallOptions.DEFAULT, req);
+      fail();
+    } catch (StatusRuntimeException ex) {
+      assertTrue(Thread.interrupted());
+      assertTrue("interrupted", ex.getCause() instanceof InterruptedException);
+    }
+    assertTrue("onCloseCalled", interceptor.onCloseCalled);
+    assertTrue("context not cancelled", methodImpl.observer.isCancelled());
+    assertNotNull("callOptionsExecutor should not be null", interceptor.savedExecutor);
+    ClientCalls.rejectRunnableOnExecutor = true;
+    try {
+      interceptor.savedExecutor.execute(() -> { });
+      fail();
+    } catch (Exception ex) {
+      assertTrue(ex instanceof RejectedExecutionException);
+    }
+  }
+
+  @Test
+  public void blockingUnaryCall_HasBlockingStubType() {
+    NoopClientCall<Integer, Integer> call = new NoopClientCall<Integer, Integer>() {
+      @Override
+      public void start(io.grpc.ClientCall.Listener<Integer> listener, Metadata headers) {
+        listener.onMessage(1);
+        listener.onClose(Status.OK, new Metadata());
+      }
+    };
+    when(mockChannel.newCall(
+        ArgumentMatchers.<MethodDescriptor<Integer, Integer>>any(), any(CallOptions.class)))
+        .thenReturn(call);
+
+    Integer unused =
+        ClientCalls.blockingUnaryCall(mockChannel, UNARY_METHOD, CallOptions.DEFAULT, 1);
+
+    verify(mockChannel).newCall(methodDescriptorCaptor.capture(), callOptionsCaptor.capture());
+    CallOptions capturedCallOption = callOptionsCaptor.getValue();
+    assertThat(capturedCallOption.getOption(ClientCalls.STUB_TYPE_OPTION))
+        .isEquivalentAccordingToCompareTo(StubType.BLOCKING);
+  }
+
+  @Test
+  public void blockingServerStreamingCall_HasBlockingStubType() {
+    NoopClientCall<Integer, Integer> call = new NoopClientCall<Integer, Integer>() {
+      @Override
+      public void start(io.grpc.ClientCall.Listener<Integer> listener, Metadata headers) {
+        listener.onMessage(1);
+        listener.onClose(Status.OK, new Metadata());
+      }
+    };
+    when(mockChannel.newCall(
+        ArgumentMatchers.<MethodDescriptor<Integer, Integer>>any(), any(CallOptions.class)))
+        .thenReturn(call);
+
+    Iterator<Integer> unused =
+        ClientCalls.blockingServerStreamingCall(mockChannel, UNARY_METHOD, CallOptions.DEFAULT, 1);
+
+    verify(mockChannel).newCall(methodDescriptorCaptor.capture(), callOptionsCaptor.capture());
+    CallOptions capturedCallOption = callOptionsCaptor.getValue();
+    assertThat(capturedCallOption.getOption(ClientCalls.STUB_TYPE_OPTION))
+        .isEquivalentAccordingToCompareTo(StubType.BLOCKING);
+  }
+
   @Test
   public void unaryFutureCallSuccess() throws Exception {
     final AtomicReference<ClientCall.Listener<String>> listener =
-        new AtomicReference<ClientCall.Listener<String>>();
-    final AtomicReference<Integer> message = new AtomicReference<Integer>();
-    final AtomicReference<Boolean> halfClosed = new AtomicReference<Boolean>();
+        new AtomicReference<>();
+    final AtomicReference<Integer> message = new AtomicReference<>();
+    final AtomicReference<Boolean> halfClosed = new AtomicReference<>();
     NoopClientCall<Integer, String> call = new NoopClientCall<Integer, String>() {
       @Override
       public void start(io.grpc.ClientCall.Listener<String> responseListener, Metadata headers) {
@@ -180,7 +348,7 @@ public void halfClose() {
   @Test
   public void unaryFutureCallFailed() throws Exception {
     final AtomicReference<ClientCall.Listener<String>> listener =
-        new AtomicReference<ClientCall.Listener<String>>();
+        new AtomicReference<>();
     NoopClientCall<Integer, String> call = new NoopClientCall<Integer, String>() {
       @Override
       public void start(io.grpc.ClientCall.Listener<String> responseListener, Metadata headers) {
@@ -205,9 +373,9 @@ public void start(io.grpc.ClientCall.Listener<String> responseListener, Metadata
   @Test
   public void unaryFutureCallCancelled() throws Exception {
     final AtomicReference<ClientCall.Listener<String>> listener =
-        new AtomicReference<ClientCall.Listener<String>>();
-    final AtomicReference<String> cancelMessage = new AtomicReference<String>();
-    final AtomicReference<Throwable> cancelCause = new AtomicReference<Throwable>();
+        new AtomicReference<>();
+    final AtomicReference<String> cancelMessage = new AtomicReference<>();
+    final AtomicReference<Throwable> cancelCause = new AtomicReference<>();
     NoopClientCall<Integer, String> call = new NoopClientCall<Integer, String>() {
       @Override
       public void start(io.grpc.ClientCall.Listener<String> responseListener, Metadata headers) {
@@ -231,13 +399,13 @@ public void cancel(String message, Throwable cause) {
       future.get();
       fail("Should fail");
     } catch (CancellationException e) {
-      // Exepcted
+      // Expected
     }
   }
 
   @Test
   public void cannotSetOnReadyAfterCallStarted() throws Exception {
-    NoopClientCall<Integer, String> call = new NoopClientCall<Integer, String>();
+    NoopClientCall<Integer, String> call = new NoopClientCall<>();
     CallStreamObserver<Integer> callStreamObserver =
         (CallStreamObserver<Integer>) ClientCalls.asyncClientStreamingCall(call,
             new NoopStreamObserver<String>());
@@ -258,8 +426,8 @@ public void run() {
   public void disablingInboundAutoFlowControlSuppressesRequestsForMoreMessages()
       throws Exception {
     final AtomicReference<ClientCall.Listener<String>> listener =
-        new AtomicReference<ClientCall.Listener<String>>();
-    final List<Integer> requests = new ArrayList<Integer>();
+        new AtomicReference<>();
+    final List<Integer> requests = new ArrayList<>();
     NoopClientCall<Integer, String> call = new NoopClientCall<Integer, String>() {
       @Override
       public void start(io.grpc.ClientCall.Listener<String> responseListener, Metadata headers) {
@@ -274,7 +442,7 @@ public void request(int numMessages) {
     ClientCalls.asyncBidiStreamingCall(call, new ClientResponseObserver<Integer, String>() {
       @Override
       public void beforeStart(ClientCallStreamObserver<Integer> requestStream) {
-        requestStream.disableAutoInboundFlowControl();
+        requestStream.disableAutoRequestWithInitial(1);
       }
 
       @Override
@@ -296,6 +464,92 @@ public void onCompleted() {
     assertThat(requests).containsExactly(1);
   }
 
+  @Test
+  public void disablingAutoRequestSuppressesRequests()
+      throws Exception {
+    final AtomicReference<ClientCall.Listener<String>> listener =
+        new AtomicReference<>();
+    final List<Integer> requests = new ArrayList<>();
+    NoopClientCall<Integer, String> call = new NoopClientCall<Integer, String>() {
+      @Override
+      public void start(io.grpc.ClientCall.Listener<String> responseListener, Metadata headers) {
+        listener.set(responseListener);
+      }
+
+      @Override
+      public void request(int numMessages) {
+        requests.add(numMessages);
+      }
+    };
+    ClientCalls.asyncBidiStreamingCall(call, new ClientResponseObserver<Integer, String>() {
+      @Override
+      public void beforeStart(ClientCallStreamObserver<Integer> requestStream) {
+        requestStream.disableAutoRequestWithInitial(0);
+      }
+
+      @Override
+      public void onNext(String value) {
+
+      }
+
+      @Override
+      public void onError(Throwable t) {
+
+      }
+
+      @Override
+      public void onCompleted() {
+
+      }
+    });
+    listener.get().onMessage("message");
+    assertThat(requests).isEmpty();
+  }
+
+  @Test
+  public void checkForNullInAsyncUnaryCall()  {
+    NoopClientCall<Integer, String> call = new NoopClientCall<>();
+    try {
+      ClientCalls.asyncUnaryCall(call, Integer.valueOf(1), null);
+      fail("Should have gotten an exception for the null responseObserver");
+    } catch (NullPointerException e) {
+      assertEquals("responseObserver", e.getMessage());
+    }
+  }
+
+  @Test
+  public void checkForNullInBidiCall()  {
+    NoopClientCall<Integer, String> call = new NoopClientCall<>();
+    try {
+      ClientCalls.asyncBidiStreamingCall(call, null);
+      fail("Should have gotten an exception for the null responseObserver");
+    } catch (NullPointerException e) {
+      assertEquals("responseObserver", e.getMessage());
+    }
+  }
+
+  @Test
+  public void checkForNullInClientStreamCall()  {
+    NoopClientCall<Integer, String> call = new NoopClientCall<>();
+    try {
+      ClientCalls.asyncClientStreamingCall(call, null);
+      fail("Should have gotten an exception for the null responseObserver");
+    } catch (NullPointerException e) {
+      assertEquals("responseObserver", e.getMessage());
+    }
+  }
+
+  @Test
+  public void checkForNullInServerStreamCall()  {
+    NoopClientCall<Integer, String> call = new NoopClientCall<>();
+    try {
+      ClientCalls.asyncServerStreamingCall(call, Integer.valueOf(1), null);
+      fail("Should have gotten an exception for the null responseObserver");
+    } catch (NullPointerException e) {
+      assertEquals("responseObserver", e.getMessage());
+    }
+  }
+
   @Test
   public void callStreamObserverPropagatesFlowControlRequestsToCall()
       throws Exception {
@@ -303,7 +557,7 @@ public void callStreamObserverPropagatesFlowControlRequestsToCall()
         new ClientResponseObserver<Integer, String>() {
           @Override
           public void beforeStart(ClientCallStreamObserver<Integer> requestStream) {
-            requestStream.disableAutoInboundFlowControl();
+            requestStream.disableAutoRequestWithInitial(0);
           }
 
           @Override
@@ -319,8 +573,8 @@ public void onCompleted() {
           }
         };
     final AtomicReference<ClientCall.Listener<String>> listener =
-        new AtomicReference<ClientCall.Listener<String>>();
-    final List<Integer> requests = new ArrayList<Integer>();
+        new AtomicReference<>();
+    final List<Integer> requests = new ArrayList<>();
     NoopClientCall<Integer, String> call = new NoopClientCall<Integer, String>() {
       @Override
       public void start(io.grpc.ClientCall.Listener<String> responseListener, Metadata headers) {
@@ -344,29 +598,37 @@ public void request(int numMessages) {
   public void canCaptureInboundFlowControlForServerStreamingObserver()
       throws Exception {
 
-    ClientResponseObserver<Integer, String> responseObserver =
-        new ClientResponseObserver<Integer, String>() {
-          @Override
-          public void beforeStart(ClientCallStreamObserver<Integer> requestStream) {
-            requestStream.disableAutoInboundFlowControl();
-            requestStream.request(5);
-          }
+    class ResponseObserver implements ClientResponseObserver<Integer, String> {
 
-          @Override
-          public void onNext(String value) {
-          }
+      private ClientCallStreamObserver<Integer> requestStream;
 
-          @Override
-          public void onError(Throwable t) {
-          }
+      @Override
+      public void beforeStart(ClientCallStreamObserver<Integer> requestStream) {
+        this.requestStream = requestStream;
+        requestStream.disableAutoRequestWithInitial(0);
+      }
 
-          @Override
-          public void onCompleted() {
-          }
-        };
+      @Override
+      public void onNext(String value) {
+      }
+
+      @Override
+      public void onError(Throwable t) {
+      }
+
+      @Override
+      public void onCompleted() {
+      }
+
+      void request(int numMessages) {
+        requestStream.request(numMessages);
+      }
+    }
+
+    ResponseObserver responseObserver = new ResponseObserver();
     final AtomicReference<ClientCall.Listener<String>> listener =
-            new AtomicReference<ClientCall.Listener<String>>();
-    final List<Integer> requests = new ArrayList<Integer>();
+        new AtomicReference<>();
+    final List<Integer> requests = new ArrayList<>();
     NoopClientCall<Integer, String> call = new NoopClientCall<Integer, String>() {
       @Override
       public void start(io.grpc.ClientCall.Listener<String> responseListener, Metadata headers) {
@@ -379,16 +641,17 @@ public void request(int numMessages) {
       }
     };
     ClientCalls.asyncServerStreamingCall(call, 1, responseObserver);
+    responseObserver.request(5);
     listener.get().onMessage("message");
-    assertThat(requests).containsExactly(5, 1).inOrder();
+    assertThat(requests).containsExactly(5).inOrder();
   }
 
   @Test
   public void inprocessTransportInboundFlowControl() throws Exception {
     final Semaphore semaphore = new Semaphore(0);
     ServerServiceDefinition service = ServerServiceDefinition.builder(
-        new ServiceDescriptor("some", STREAMING_METHOD))
-        .addMethod(STREAMING_METHOD, ServerCalls.asyncBidiStreamingCall(
+        new ServiceDescriptor("some", BIDI_STREAMING_METHOD))
+        .addMethod(BIDI_STREAMING_METHOD, ServerCalls.asyncBidiStreamingCall(
             new ServerCalls.BidiStreamingMethod<Integer, Integer>() {
               int iteration;
 
@@ -419,16 +682,16 @@ public void onCompleted() {
     server = InProcessServerBuilder.forName("go-with-the-flow" + tag).directExecutor()
         .addService(service).build().start();
     channel = InProcessChannelBuilder.forName("go-with-the-flow" + tag).directExecutor().build();
-    final ClientCall<Integer, Integer> clientCall = channel.newCall(STREAMING_METHOD,
+    final ClientCall<Integer, Integer> clientCall = channel.newCall(BIDI_STREAMING_METHOD,
         CallOptions.DEFAULT);
     final CountDownLatch latch = new CountDownLatch(1);
-    final List<Object> receivedMessages = new ArrayList<Object>(6);
+    final List<Object> receivedMessages = new ArrayList<>(6);
 
     ClientResponseObserver<Integer, Integer> responseObserver =
         new ClientResponseObserver<Integer, Integer>() {
           @Override
           public void beforeStart(final ClientCallStreamObserver<Integer> requestStream) {
-            requestStream.disableAutoInboundFlowControl();
+            requestStream.disableAutoRequestWithInitial(0);
           }
 
           @Override
@@ -450,32 +713,33 @@ public void onCompleted() {
 
     CallStreamObserver<Integer> integerStreamObserver = (CallStreamObserver<Integer>)
         ClientCalls.asyncBidiStreamingCall(clientCall, responseObserver);
-    semaphore.acquire();
+    integerStreamObserver.request(1);
+    assertTrue(semaphore.tryAcquire(5, TimeUnit.SECONDS));
     integerStreamObserver.request(2);
-    semaphore.acquire();
+    assertTrue(semaphore.tryAcquire(5, TimeUnit.SECONDS));
     integerStreamObserver.request(3);
     integerStreamObserver.onCompleted();
     assertTrue(latch.await(5, TimeUnit.SECONDS));
     // Verify that number of messages produced in each onReady handler call matches the number
-    // requested by the client. Note that ClientCalls.asyncBidiStreamingCall will request(1)
+    // requested by the client.
     assertEquals(Arrays.asList(0, 1, 1, 2, 2, 2), receivedMessages);
   }
 
   @Test
   public void inprocessTransportOutboundFlowControl() throws Exception {
     final Semaphore semaphore = new Semaphore(0);
-    final List<Object> receivedMessages = new ArrayList<Object>(6);
+    final List<Object> receivedMessages = new ArrayList<>(6);
     final SettableFuture<ServerCallStreamObserver<Integer>> observerFuture
         = SettableFuture.create();
     ServerServiceDefinition service = ServerServiceDefinition.builder(
-        new ServiceDescriptor("some", STREAMING_METHOD))
-        .addMethod(STREAMING_METHOD, ServerCalls.asyncBidiStreamingCall(
+        new ServiceDescriptor("some", BIDI_STREAMING_METHOD))
+        .addMethod(BIDI_STREAMING_METHOD, ServerCalls.asyncBidiStreamingCall(
             new ServerCalls.BidiStreamingMethod<Integer, Integer>() {
               @Override
               public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
                 final ServerCallStreamObserver<Integer> serverCallObserver =
                     (ServerCallStreamObserver<Integer>) responseObserver;
-                serverCallObserver.disableAutoInboundFlowControl();
+                serverCallObserver.disableAutoRequest();
                 observerFuture.set(serverCallObserver);
                 return new StreamObserver<Integer>() {
                   @Override
@@ -500,7 +764,7 @@ public void onCompleted() {
     server = InProcessServerBuilder.forName("go-with-the-flow" + tag).directExecutor()
         .addService(service).build().start();
     channel = InProcessChannelBuilder.forName("go-with-the-flow" + tag).directExecutor().build();
-    final ClientCall<Integer, Integer> clientCall = channel.newCall(STREAMING_METHOD,
+    final ClientCall<Integer, Integer> clientCall = channel.newCall(BIDI_STREAMING_METHOD,
         CallOptions.DEFAULT);
 
     final SettableFuture<Void> future = SettableFuture.create();
@@ -556,7 +820,7 @@ public void onCompleted() {
   @Test
   public void blockingResponseStreamFailed() throws Exception {
     final AtomicReference<ClientCall.Listener<String>> listener =
-        new AtomicReference<ClientCall.Listener<String>>();
+        new AtomicReference<>();
     NoopClientCall<Integer, String> call = new NoopClientCall<Integer, String>() {
       @Override
       public void start(io.grpc.ClientCall.Listener<String> responseListener, Metadata headers) {
@@ -572,11 +836,145 @@ public void start(io.grpc.ClientCall.Listener<String> responseListener, Metadata
     try {
       iter.next();
       fail("Should fail");
-    } catch (Throwable e) {
+    } catch (Exception e) {
       Status status = Status.fromThrowable(e);
       assertEquals(Status.INTERNAL, status);
       Metadata metadata = Status.trailersFromThrowable(e);
       assertSame(trailers, metadata);
     }
   }
+
+  @Test
+  public void blockingServerStreamingCall_interruptedWaitsForOnClose() throws Exception {
+    Integer req = 2;
+
+    class NoopServerStreamingMethod implements ServerStreamingMethod<Integer, Integer> {
+      ServerCallStreamObserver<Integer> observer;
+
+      @Override public void invoke(Integer request, StreamObserver<Integer> responseObserver) {
+        observer = (ServerCallStreamObserver<Integer>) responseObserver;
+      }
+    }
+
+    NoopServerStreamingMethod methodImpl = new NoopServerStreamingMethod();
+    server = InProcessServerBuilder.forName("noop").directExecutor()
+        .addService(ServerServiceDefinition.builder("some")
+            .addMethod(SERVER_STREAMING_METHOD, ServerCalls.asyncServerStreamingCall(methodImpl))
+            .build())
+        .build().start();
+
+    InterruptInterceptor interceptor = new InterruptInterceptor();
+    channel = InProcessChannelBuilder.forName("noop")
+        .directExecutor()
+        .intercept(interceptor)
+        .build();
+    Iterator<Integer> iter = ClientCalls.blockingServerStreamingCall(
+        channel.newCall(SERVER_STREAMING_METHOD, CallOptions.DEFAULT), req);
+    try {
+      iter.next();
+      fail();
+    } catch (StatusRuntimeException ex) {
+      assertTrue(Thread.interrupted());
+      assertTrue("interrupted", ex.getCause() instanceof InterruptedException);
+    }
+    assertTrue("onCloseCalled", interceptor.onCloseCalled);
+    assertTrue("context not cancelled", methodImpl.observer.isCancelled());
+  }
+
+  @Test
+  public void blockingServerStreamingCall2_success() throws Exception {
+    Integer req = 2;
+    final Integer resp1 = 3;
+    final Integer resp2 = 4;
+
+    class BasicServerStreamingResponse implements ServerStreamingMethod<Integer, Integer> {
+      Integer request;
+
+      @Override public void invoke(Integer request, StreamObserver<Integer> responseObserver) {
+        this.request = request;
+        responseObserver.onNext(resp1);
+        responseObserver.onNext(resp2);
+        responseObserver.onCompleted();
+      }
+    }
+
+    BasicServerStreamingResponse service = new BasicServerStreamingResponse();
+    server = InProcessServerBuilder.forName("simple-reply").directExecutor()
+        .addService(ServerServiceDefinition.builder("some")
+            .addMethod(SERVER_STREAMING_METHOD, ServerCalls.asyncServerStreamingCall(service))
+            .build())
+        .build().start();
+    channel = InProcessChannelBuilder.forName("simple-reply").directExecutor().build();
+    Iterator<Integer> iter = ClientCalls.blockingServerStreamingCall(
+            channel, SERVER_STREAMING_METHOD, CallOptions.DEFAULT, req);
+    assertEquals(resp1, iter.next());
+    assertTrue(iter.hasNext());
+    assertEquals(resp2, iter.next());
+    assertFalse(iter.hasNext());
+    assertEquals(req, service.request);
+  }
+
+  @Test
+  public void blockingServerStreamingCall2_interruptedWaitsForOnClose() throws Exception {
+    Integer req = 2;
+
+    class NoopServerStreamingMethod implements ServerStreamingMethod<Integer, Integer> {
+      ServerCallStreamObserver<Integer> observer;
+
+      @Override public void invoke(Integer request, StreamObserver<Integer> responseObserver) {
+        observer = (ServerCallStreamObserver<Integer>) responseObserver;
+      }
+    }
+
+    NoopServerStreamingMethod methodImpl = new NoopServerStreamingMethod();
+    server = InProcessServerBuilder.forName("noop").directExecutor()
+        .addService(ServerServiceDefinition.builder("some")
+            .addMethod(SERVER_STREAMING_METHOD, ServerCalls.asyncServerStreamingCall(methodImpl))
+            .build())
+        .build().start();
+
+    InterruptInterceptor interceptor = new InterruptInterceptor();
+    channel = InProcessChannelBuilder.forName("noop")
+        .directExecutor()
+        .intercept(interceptor)
+        .build();
+    Iterator<Integer> iter = ClientCalls.blockingServerStreamingCall(
+        channel, SERVER_STREAMING_METHOD, CallOptions.DEFAULT, req);
+    try {
+      iter.next();
+      fail();
+    } catch (StatusRuntimeException ex) {
+      assertTrue(Thread.interrupted());
+      assertTrue("interrupted", ex.getCause() instanceof InterruptedException);
+    }
+    assertTrue("onCloseCalled", interceptor.onCloseCalled);
+    assertTrue("context not cancelled", methodImpl.observer.isCancelled());
+  }
+
+  // Used for blocking tests to check interrupt behavior and make sure onClose is still called.
+  class InterruptInterceptor implements ClientInterceptor {
+    boolean onCloseCalled;
+    Executor savedExecutor;
+
+    @Override
+    public <ReqT,RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+      return new SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {
+        @Override public void start(ClientCall.Listener<RespT> listener, Metadata headers) {
+          super.start(new SimpleForwardingClientCallListener<RespT>(listener) {
+            @Override public void onClose(Status status, Metadata trailers) {
+              onCloseCalled = true;
+              savedExecutor = callOptions.getExecutor();
+              super.onClose(status, trailers);
+            }
+          }, headers);
+        }
+
+        @Override public void halfClose() {
+          super.halfClose();
+          Thread.currentThread().interrupt();
+        }
+      };
+    }
+  }
 }
diff --git a/stub/src/test/java/io/grpc/stub/MetadataUtilsTest.java b/stub/src/test/java/io/grpc/stub/MetadataUtilsTest.java
new file mode 100644
index 00000000000..f9890ac0433
--- /dev/null
+++ b/stub/src/test/java/io/grpc/stub/MetadataUtilsTest.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2024 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.stub;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.stub.MetadataUtils.newAttachMetadataServerInterceptor;
+import static io.grpc.stub.MetadataUtils.newCaptureMetadataInterceptor;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.CallOptions;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptors;
+import io.grpc.ServerMethodDefinition;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.StatusRuntimeException;
+import io.grpc.StringMarshaller;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.testing.GrpcCleanupRule;
+import java.io.IOException;
+import java.util.Iterator;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class MetadataUtilsTest {
+
+  @Rule public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+  private static final String SERVER_NAME = "test";
+  private static final Metadata.Key<String> FOO_KEY =
+      Metadata.Key.of("foo-key", Metadata.ASCII_STRING_MARSHALLER);
+
+  private final MethodDescriptor<String, String> echoMethod =
+      MethodDescriptor.newBuilder(StringMarshaller.INSTANCE, StringMarshaller.INSTANCE)
+          .setFullMethodName("test/echo")
+          .setType(MethodDescriptor.MethodType.UNARY)
+          .build();
+
+  private final ServerCallHandler<String, String> echoCallHandler =
+      ServerCalls.asyncUnaryCall(
+          (req, respObserver) -> {
+            respObserver.onNext(req);
+            respObserver.onCompleted();
+          });
+
+  MethodDescriptor<String, String> echoServerStreamingMethod =
+      MethodDescriptor.newBuilder(StringMarshaller.INSTANCE, StringMarshaller.INSTANCE)
+          .setFullMethodName("test/echoStream")
+          .setType(MethodDescriptor.MethodType.SERVER_STREAMING)
+          .build();
+
+  private final AtomicReference<Metadata> trailersCapture = new AtomicReference<>();
+  private final AtomicReference<Metadata> headersCapture = new AtomicReference<>();
+
+  @Test
+  public void shouldAttachHeadersToResponse() throws IOException {
+    Metadata extras = new Metadata();
+    extras.put(FOO_KEY, "foo-value");
+
+    ServerServiceDefinition serviceDef =
+        ServerInterceptors.intercept(
+            ServerServiceDefinition.builder("test").addMethod(echoMethod, echoCallHandler).build(),
+            ImmutableList.of(newAttachMetadataServerInterceptor(extras)));
+
+    grpcCleanup.register(newInProcessServerBuilder().addService(serviceDef).build().start());
+    ManagedChannel channel =
+        grpcCleanup.register(
+            newInProcessChannelBuilder()
+                .intercept(newCaptureMetadataInterceptor(headersCapture, trailersCapture))
+                .build());
+
+    String response =
+        ClientCalls.blockingUnaryCall(channel, echoMethod, CallOptions.DEFAULT, "hello");
+    assertThat(response).isEqualTo("hello");
+    assertThat(trailersCapture.get() == null || !trailersCapture.get().containsKey(FOO_KEY))
+        .isTrue();
+    assertThat(headersCapture.get().get(FOO_KEY)).isEqualTo("foo-value");
+  }
+
+  @Test
+  public void shouldAttachTrailersWhenNoResponse() throws IOException {
+    Metadata extras = new Metadata();
+    extras.put(FOO_KEY, "foo-value");
+
+    ServerServiceDefinition serviceDef =
+        ServerInterceptors.intercept(
+            ServerServiceDefinition.builder("test")
+                .addMethod(
+                    ServerMethodDefinition.create(
+                        echoServerStreamingMethod,
+                        ServerCalls.asyncUnaryCall(
+                            (req, respObserver) -> respObserver.onCompleted())))
+                .build(),
+            ImmutableList.of(newAttachMetadataServerInterceptor(extras)));
+    grpcCleanup.register(newInProcessServerBuilder().addService(serviceDef).build().start());
+
+    ManagedChannel channel =
+        grpcCleanup.register(
+            newInProcessChannelBuilder()
+                .intercept(newCaptureMetadataInterceptor(headersCapture, trailersCapture))
+                .build());
+
+    Iterator<String> response =
+        ClientCalls.blockingServerStreamingCall(
+            channel, echoServerStreamingMethod, CallOptions.DEFAULT, "hello");
+    assertThat(response.hasNext()).isFalse();
+    assertThat(headersCapture.get() == null || !headersCapture.get().containsKey(FOO_KEY)).isTrue();
+    assertThat(trailersCapture.get().get(FOO_KEY)).isEqualTo("foo-value");
+  }
+
+  @Test
+  public void shouldAttachTrailersToErrorResponse() throws IOException {
+    Metadata extras = new Metadata();
+    extras.put(FOO_KEY, "foo-value");
+
+    ServerServiceDefinition serviceDef =
+        ServerInterceptors.intercept(
+            ServerServiceDefinition.builder("test")
+                .addMethod(
+                    echoMethod,
+                    ServerCalls.asyncUnaryCall(
+                        (req, respObserver) ->
+                            respObserver.onError(Status.INVALID_ARGUMENT.asRuntimeException())))
+                .build(),
+            ImmutableList.of(newAttachMetadataServerInterceptor(extras)));
+    grpcCleanup.register(newInProcessServerBuilder().addService(serviceDef).build().start());
+
+    ManagedChannel channel =
+        grpcCleanup.register(
+            newInProcessChannelBuilder()
+                .intercept(newCaptureMetadataInterceptor(headersCapture, trailersCapture))
+                .build());
+    try {
+      ClientCalls.blockingUnaryCall(channel, echoMethod, CallOptions.DEFAULT, "hello");
+      fail();
+    } catch (StatusRuntimeException e) {
+      assertThat(e.getStatus()).isNotNull();
+      assertThat(e.getStatus().getCode()).isEqualTo(Code.INVALID_ARGUMENT);
+    }
+    assertThat(headersCapture.get() == null || !headersCapture.get().containsKey(FOO_KEY)).isTrue();
+    assertThat(trailersCapture.get().get(FOO_KEY)).isEqualTo("foo-value");
+  }
+
+  private static InProcessServerBuilder newInProcessServerBuilder() {
+    return InProcessServerBuilder.forName(SERVER_NAME).directExecutor();
+  }
+
+  private static InProcessChannelBuilder newInProcessChannelBuilder() {
+    return InProcessChannelBuilder.forName(SERVER_NAME).directExecutor();
+  }
+}
diff --git a/stub/src/test/java/io/grpc/stub/ServerCallsTest.java b/stub/src/test/java/io/grpc/stub/ServerCallsTest.java
index 9527240d152..6f458facc5e 100644
--- a/stub/src/test/java/io/grpc/stub/ServerCallsTest.java
+++ b/stub/src/test/java/io/grpc/stub/ServerCallsTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.stub;
@@ -48,6 +33,7 @@
 import io.grpc.ServerServiceDefinition;
 import io.grpc.ServiceDescriptor;
 import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
 import io.grpc.inprocess.InProcessChannelBuilder;
 import io.grpc.inprocess.InProcessServerBuilder;
 import java.io.ByteArrayInputStream;
@@ -77,17 +63,24 @@ public class ServerCallsTest {
   static final MethodDescriptor<Integer, Integer> STREAMING_METHOD =
       MethodDescriptor.<Integer, Integer>newBuilder()
           .setType(MethodDescriptor.MethodType.BIDI_STREAMING)
-          .setFullMethodName("some/method")
+          .setFullMethodName("some/bidi_streaming")
           .setRequestMarshaller(new IntegerMarshaller())
           .setResponseMarshaller(new IntegerMarshaller())
           .build();
 
-  static final MethodDescriptor<Integer, Integer> UNARY_METHOD = STREAMING_METHOD.toBuilder()
-      .setType(MethodDescriptor.MethodType.UNARY)
-      .setFullMethodName("some/unarymethod")
-      .build();
+  static final MethodDescriptor<Integer, Integer> SERVER_STREAMING_METHOD =
+      STREAMING_METHOD.toBuilder()
+          .setType(MethodDescriptor.MethodType.SERVER_STREAMING)
+          .setFullMethodName("some/client_streaming")
+          .build();
+
+  static final MethodDescriptor<Integer, Integer> UNARY_METHOD =
+      STREAMING_METHOD.toBuilder()
+          .setType(MethodDescriptor.MethodType.UNARY)
+          .setFullMethodName("some/unary")
+          .build();
 
-  private final ServerCallRecorder serverCall = new ServerCallRecorder();
+  private final ServerCallRecorder serverCall = new ServerCallRecorder(UNARY_METHOD);
 
   @Test
   public void runtimeStreamObserverIsServerCallStreamObserver() throws Exception {
@@ -95,7 +88,7 @@ public void runtimeStreamObserverIsServerCallStreamObserver() throws Exception {
     final AtomicBoolean onCancelCalled = new AtomicBoolean();
     final AtomicBoolean onReadyCalled = new AtomicBoolean();
     final AtomicReference<ServerCallStreamObserver<Integer>> callObserver =
-        new AtomicReference<ServerCallStreamObserver<Integer>>();
+        new AtomicReference<>();
     ServerCallHandler<Integer, Integer> callHandler =
         ServerCalls.asyncBidiStreamingCall(
             new ServerCalls.BidiStreamingMethod<Integer, Integer>() {
@@ -118,7 +111,7 @@ public void run() {
                   }
                 });
                 invokeCalled.set(true);
-                return new ServerCalls.NoopStreamObserver<Integer>();
+                return new ServerCalls.NoopStreamObserver<>();
               }
             });
     ServerCall.Listener<Integer> callListener =
@@ -142,17 +135,128 @@ public void run() {
     assertThat(serverCall.requestCalls).containsExactly(1, 1).inOrder();
   }
 
+  @Test
+  public void noCancellationExceptionIfOnCancelHandlerSet() throws Exception {
+    final AtomicBoolean onCancelCalled = new AtomicBoolean();
+    final AtomicReference<ServerCallStreamObserver<Integer>> callObserver =
+        new AtomicReference<>();
+    ServerCallHandler<Integer, Integer> callHandler =
+        ServerCalls.asyncBidiStreamingCall(
+            new ServerCalls.BidiStreamingMethod<Integer, Integer>() {
+              @Override
+              public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
+                ServerCallStreamObserver<Integer> serverCallObserver =
+                    (ServerCallStreamObserver<Integer>) responseObserver;
+                callObserver.set(serverCallObserver);
+                serverCallObserver.setOnCancelHandler(new Runnable() {
+                  @Override
+                  public void run() {
+                    onCancelCalled.set(true);
+                  }
+                });
+                return new ServerCalls.NoopStreamObserver<>();
+              }
+            });
+    ServerCall.Listener<Integer> callListener =
+        callHandler.startCall(serverCall, new Metadata());
+    callListener.onReady();
+    callListener.onCancel();
+    assertTrue(onCancelCalled.get());
+    serverCall.isCancelled = true;
+    assertTrue(callObserver.get().isCancelled());
+    callObserver.get().onNext(null);
+    callObserver.get().onCompleted();
+  }
+
+  @Test
+  public void expectCancellationExceptionIfOnCancelHandlerNotSet() throws Exception {
+    final AtomicReference<ServerCallStreamObserver<Integer>> callObserver =
+        new AtomicReference<>();
+    ServerCallHandler<Integer, Integer> callHandler =
+        ServerCalls.asyncBidiStreamingCall(
+            new ServerCalls.BidiStreamingMethod<Integer, Integer>() {
+              @Override
+              public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
+                ServerCallStreamObserver<Integer> serverCallObserver =
+                    (ServerCallStreamObserver<Integer>) responseObserver;
+                callObserver.set(serverCallObserver);
+                return new ServerCalls.NoopStreamObserver<>();
+              }
+            });
+    ServerCall.Listener<Integer> callListener =
+        callHandler.startCall(serverCall, new Metadata());
+    callListener.onReady();
+    callListener.onCancel();
+    serverCall.isCancelled = true;
+    assertTrue(callObserver.get().isCancelled());
+    try {
+      callObserver.get().onNext(null);
+      fail("Expected cancellation exception when onCallHandler not set");
+    } catch (StatusRuntimeException expected) {
+      // Expected
+    }
+    // No exception
+    callObserver.get().onCompleted();
+  }
+
+  @Test
+  public void onCloseHandlerCalledIfSetInStreamingClientCall() throws Exception {
+    final AtomicBoolean onCloseHandlerCalled = new AtomicBoolean();
+    ServerCallHandler<Integer, Integer> callHandler = ServerCalls.asyncBidiStreamingCall(
+        new ServerCalls.BidiStreamingMethod<Integer, Integer>() {
+          @Override
+          public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
+            ServerCallStreamObserver<Integer> serverCallObserver =
+                (ServerCallStreamObserver<Integer>) responseObserver;
+            serverCallObserver.setOnCloseHandler(new Runnable() {
+              @Override
+              public void run() {
+                onCloseHandlerCalled.set(true);
+              }
+            });
+            return new ServerCalls.NoopStreamObserver<>();
+          }
+        });
+    ServerCall.Listener<Integer> callListener = callHandler.startCall(serverCall, new Metadata());
+    callListener.onComplete();
+    assertTrue(onCloseHandlerCalled.get());
+  }
+
+  @Test
+  public void onCloseHandlerCalledIfSetInUnaryClientCall() throws Exception {
+    final AtomicBoolean onCloseHandlerCalled = new AtomicBoolean();
+    ServerCallHandler<Integer, Integer> callHandler = ServerCalls.asyncServerStreamingCall(
+        new ServerCalls.ServerStreamingMethod<Integer, Integer>() {
+          @Override
+          public void invoke(Integer request, StreamObserver<Integer> responseObserver) {
+            ServerCallStreamObserver<Integer> serverCallObserver =
+                (ServerCallStreamObserver<Integer>) responseObserver;
+            serverCallObserver.setOnCloseHandler(new Runnable() {
+              @Override
+              public void run() {
+                onCloseHandlerCalled.set(true);
+              }
+            });
+          }
+        });
+    ServerCall.Listener<Integer> callListener = callHandler.startCall(serverCall, new Metadata());
+    callListener.onMessage(0);
+    callListener.onHalfClose();
+    callListener.onComplete();
+    assertTrue(onCloseHandlerCalled.get());
+  }
+
   @Test
   public void cannotSetOnCancelHandlerAfterServiceInvocation() throws Exception {
     final AtomicReference<ServerCallStreamObserver<Integer>> callObserver =
-        new AtomicReference<ServerCallStreamObserver<Integer>>();
+        new AtomicReference<>();
     ServerCallHandler<Integer, Integer> callHandler =
         ServerCalls.asyncBidiStreamingCall(
             new ServerCalls.BidiStreamingMethod<Integer, Integer>() {
               @Override
               public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
                 callObserver.set((ServerCallStreamObserver<Integer>) responseObserver);
-                return new ServerCalls.NoopStreamObserver<Integer>();
+                return new ServerCalls.NoopStreamObserver<>();
               }
             });
     ServerCall.Listener<Integer> callListener =
@@ -173,14 +277,14 @@ public void run() {
   @Test
   public void cannotSetOnReadyHandlerAfterServiceInvocation() throws Exception {
     final AtomicReference<ServerCallStreamObserver<Integer>> callObserver =
-        new AtomicReference<ServerCallStreamObserver<Integer>>();
+        new AtomicReference<>();
     ServerCallHandler<Integer, Integer> callHandler =
         ServerCalls.asyncBidiStreamingCall(
             new ServerCalls.BidiStreamingMethod<Integer, Integer>() {
               @Override
               public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
                 callObserver.set((ServerCallStreamObserver<Integer>) responseObserver);
-                return new ServerCalls.NoopStreamObserver<Integer>();
+                return new ServerCalls.NoopStreamObserver<>();
               }
             });
     ServerCall.Listener<Integer> callListener =
@@ -199,23 +303,48 @@ public void run() {
   }
 
   @Test
-  public void cannotDisableAutoFlowControlAfterServiceInvocation() throws Exception {
+  public void cannotSetOnCloseHandlerAfterServiceInvocation() throws Exception {
+    final AtomicReference<ServerCallStreamObserver<Integer>> callObserver = new AtomicReference<>();
+    ServerCallHandler<Integer, Integer> callHandler = ServerCalls.asyncBidiStreamingCall(
+        new ServerCalls.BidiStreamingMethod<Integer, Integer>() {
+          @Override
+          public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
+            callObserver.set((ServerCallStreamObserver<Integer>) responseObserver);
+            return new ServerCalls.NoopStreamObserver<>();
+          }
+        });
+    ServerCall.Listener<Integer> callListener = callHandler.startCall(serverCall, new Metadata());
+    callListener.onMessage(1);
+    try {
+      callObserver.get().setOnCloseHandler(new Runnable() {
+        @Override
+        public void run() {
+        }
+      });
+      fail("Cannot set onReady after service invocation");
+    } catch (IllegalStateException expected) {
+      // Expected
+    }
+  }
+
+  @Test
+  public void cannotDisableAutoRequestAfterServiceInvocation() throws Exception {
     final AtomicReference<ServerCallStreamObserver<Integer>> callObserver =
-        new AtomicReference<ServerCallStreamObserver<Integer>>();
+        new AtomicReference<>();
     ServerCallHandler<Integer, Integer> callHandler =
         ServerCalls.asyncBidiStreamingCall(
             new ServerCalls.BidiStreamingMethod<Integer, Integer>() {
               @Override
               public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
                 callObserver.set((ServerCallStreamObserver<Integer>) responseObserver);
-                return new ServerCalls.NoopStreamObserver<Integer>();
+                return new ServerCalls.NoopStreamObserver<>();
               }
             });
     ServerCall.Listener<Integer> callListener =
         callHandler.startCall(serverCall, new Metadata());
     callListener.onMessage(1);
     try {
-      callObserver.get().disableAutoInboundFlowControl();
+      callObserver.get().disableAutoRequest();
       fail("Cannot set onCancel handler after service invocation");
     } catch (IllegalStateException expected) {
       // Expected
@@ -231,8 +360,31 @@ public void disablingInboundAutoFlowControlSuppressesRequestsForMoreMessages() t
               public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
                 ServerCallStreamObserver<Integer> serverCallObserver =
                     (ServerCallStreamObserver<Integer>) responseObserver;
-                serverCallObserver.disableAutoInboundFlowControl();
-                return new ServerCalls.NoopStreamObserver<Integer>();
+                serverCallObserver.disableAutoRequest();
+                return new ServerCalls.NoopStreamObserver<>();
+              }
+            });
+    ServerCall.Listener<Integer> callListener =
+        callHandler.startCall(serverCall, new Metadata());
+    callListener.onReady();
+    // Transport should not call this if nothing has been requested but forcing it here
+    // to verify that message delivery does not trigger a call to request(1).
+    callListener.onMessage(1);
+    // Should never be called
+    assertThat(serverCall.requestCalls).isEmpty();
+  }
+
+  @Test
+  public void disablingInboundAutoRequestSuppressesRequestsForMoreMessages() throws Exception {
+    ServerCallHandler<Integer, Integer> callHandler =
+        ServerCalls.asyncBidiStreamingCall(
+            new ServerCalls.BidiStreamingMethod<Integer, Integer>() {
+              @Override
+              public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver) {
+                ServerCallStreamObserver<Integer> serverCallObserver =
+                    (ServerCallStreamObserver<Integer>) responseObserver;
+                serverCallObserver.disableAutoRequest();
+                return new ServerCalls.NoopStreamObserver<>();
               }
             });
     ServerCall.Listener<Integer> callListener =
@@ -246,7 +398,7 @@ public StreamObserver<Integer> invoke(StreamObserver<Integer> responseObserver)
   }
 
   @Test
-  public void disablingInboundAutoFlowControlForUnaryHasNoEffect() throws Exception {
+  public void disablingInboundAutoRequestForUnaryHasNoEffect() throws Exception {
     ServerCallHandler<Integer, Integer> callHandler =
         ServerCalls.asyncUnaryCall(
             new ServerCalls.UnaryMethod<Integer, Integer>() {
@@ -254,7 +406,7 @@ public void disablingInboundAutoFlowControlForUnaryHasNoEffect() throws Exceptio
               public void invoke(Integer req, StreamObserver<Integer> responseObserver) {
                 ServerCallStreamObserver<Integer> serverCallObserver =
                     (ServerCallStreamObserver<Integer>) responseObserver;
-                serverCallObserver.disableAutoInboundFlowControl();
+                serverCallObserver.disableAutoRequest();
               }
             });
     callHandler.startCall(serverCall, new Metadata());
@@ -299,6 +451,139 @@ public void run() {
     assertEquals(2, onReadyCalled.get());
   }
 
+  @Test
+  public void setOnReadyThreshold() throws Exception {
+    final int testThreshold = Integer.MAX_VALUE;
+    ServerCallHandler<Integer, Integer> callHandler =
+        ServerCalls.asyncServerStreamingCall(
+            new ServerCalls.ServerStreamingMethod<Integer, Integer>() {
+              @Override
+              public void invoke(Integer req, StreamObserver<Integer> responseObserver) {
+                ServerCallStreamObserver<Integer> serverCallObserver =
+                    (ServerCallStreamObserver<Integer>) responseObserver;
+                serverCallObserver.setOnReadyThreshold(req);
+              }
+            });
+    ServerCall.Listener<Integer> callListener =
+        callHandler.startCall(serverCall, new Metadata());
+    serverCall.isReady = true;
+    serverCall.isCancelled = false;
+    callListener.onReady();
+    callListener.onMessage(testThreshold);
+    // half-closing triggers the unary request delivery and onReady
+    callListener.onHalfClose();
+    
+    assertEquals(testThreshold, serverCall.getOnReadyThreshold());
+  }
+
+  @Test
+  public void clientSendsOne_errorMissingRequest_unary() {
+    ServerCallRecorder serverCall = new ServerCallRecorder(UNARY_METHOD);
+    ServerCallHandler<Integer, Integer> callHandler =
+        ServerCalls.asyncUnaryCall(
+            new ServerCalls.UnaryMethod<Integer, Integer>() {
+              @Override
+              public void invoke(Integer req, StreamObserver<Integer> responseObserver) {
+                fail("should not be reached");
+              }
+            });
+    ServerCall.Listener<Integer> listener = callHandler.startCall(serverCall, new Metadata());
+    listener.onHalfClose();
+    assertThat(serverCall.responses).isEmpty();
+    assertEquals(Status.Code.INTERNAL, serverCall.status.getCode());
+    assertEquals(ServerCalls.MISSING_REQUEST, serverCall.status.getDescription());
+  }
+
+  @Test
+  public void clientSendsOne_errorMissingRequest_serverStreaming() {
+    ServerCallRecorder serverCall = new ServerCallRecorder(SERVER_STREAMING_METHOD);
+    ServerCallHandler<Integer, Integer> callHandler =
+        ServerCalls.asyncServerStreamingCall(
+            new ServerCalls.ServerStreamingMethod<Integer, Integer>() {
+              @Override
+              public void invoke(Integer req, StreamObserver<Integer> responseObserver) {
+                fail("should not be reached");
+              }
+            });
+    ServerCall.Listener<Integer> listener = callHandler.startCall(serverCall, new Metadata());
+    listener.onHalfClose();
+    assertThat(serverCall.responses).isEmpty();
+    assertEquals(Status.Code.INTERNAL, serverCall.status.getCode());
+    assertEquals(ServerCalls.MISSING_REQUEST, serverCall.status.getDescription());
+
+  }
+
+  @Test
+  public void clientSendsOne_errorTooManyRequests_unary() {
+    ServerCallRecorder serverCall = new ServerCallRecorder(UNARY_METHOD);
+    ServerCallHandler<Integer, Integer> callHandler =
+        ServerCalls.asyncUnaryCall(
+            new ServerCalls.UnaryMethod<Integer, Integer>() {
+              @Override
+              public void invoke(Integer req, StreamObserver<Integer> responseObserver) {
+                fail("should not be reached");
+              }
+            });
+    ServerCall.Listener<Integer> listener = callHandler.startCall(serverCall, new Metadata());
+    listener.onMessage(1);
+    listener.onMessage(1);
+    assertThat(serverCall.responses).isEmpty();
+    assertEquals(Status.Code.INTERNAL, serverCall.status.getCode());
+    assertEquals(ServerCalls.TOO_MANY_REQUESTS, serverCall.status.getDescription());
+    // ensure onHalfClose does not invoke
+    listener.onHalfClose();
+  }
+
+  @Test
+  public void clientSendsOne_errorTooManyRequests_serverStreaming() {
+    ServerCallRecorder serverCall = new ServerCallRecorder(SERVER_STREAMING_METHOD);
+    ServerCallHandler<Integer, Integer> callHandler =
+        ServerCalls.asyncServerStreamingCall(
+            new ServerCalls.ServerStreamingMethod<Integer, Integer>() {
+              @Override
+              public void invoke(Integer req, StreamObserver<Integer> responseObserver) {
+                fail("should not be reached");
+              }
+            });
+    ServerCall.Listener<Integer> listener = callHandler.startCall(serverCall, new Metadata());
+    listener.onMessage(1);
+    listener.onMessage(1);
+    assertThat(serverCall.responses).isEmpty();
+    assertEquals(Status.Code.INTERNAL, serverCall.status.getCode());
+    assertEquals(ServerCalls.TOO_MANY_REQUESTS, serverCall.status.getDescription());
+    // ensure onHalfClose does not invoke
+    listener.onHalfClose();
+  }
+
+  @Test
+  public void clientSendsOne_serverOnErrorWithTrailers_serverStreaming() {
+    Metadata trailers = new Metadata();
+    Metadata.Key<String> key = Metadata.Key.of("trailers-test-key1",
+            Metadata.ASCII_STRING_MARSHALLER);
+    trailers.put(key, "trailers-test-value1");
+
+    ServerCallRecorder serverCall = new ServerCallRecorder(SERVER_STREAMING_METHOD);
+    ServerCallHandler<Integer, Integer> callHandler = ServerCalls.asyncServerStreamingCall(
+        new ServerCalls.ServerStreamingMethod<Integer, Integer>() {
+          @Override
+          public void invoke(Integer req, StreamObserver<Integer> responseObserver) {
+            responseObserver.onError(
+                    Status.fromCode(Status.Code.INTERNAL)
+                            .asRuntimeException(trailers)
+            );
+          }
+        });
+    ServerCall.Listener<Integer> listener = callHandler.startCall(serverCall, new Metadata());
+    serverCall.isReady = true;
+    serverCall.isCancelled = false;
+    listener.onReady();
+    listener.onMessage(1);
+    listener.onHalfClose();
+    // verify trailers key is set
+    assertTrue(serverCall.trailers.containsKey(key));
+    assertTrue(serverCall.status.equals(Status.INTERNAL));
+  }
+
   @Test
   public void inprocessTransportManualFlow() throws Exception {
     final Semaphore semaphore = new Semaphore(1);
@@ -358,7 +643,7 @@ public void onClose(Status status, Metadata trailers) {
     semaphore.acquire();
     clientCall.request(3);
     clientCall.halfClose();
-    latch.await(5, TimeUnit.SECONDS);
+    assertThat(latch.await(5, TimeUnit.SECONDS)).isTrue();
     // Very that number of messages produced in each onReady handler call matches the number
     // requested by the client.
     assertArrayEquals(new int[]{0, 1, 1, 2, 2, 2}, receivedMessages);
@@ -389,14 +674,18 @@ public Integer parse(InputStream stream) {
   }
 
   private static class ServerCallRecorder extends ServerCall<Integer, Integer> {
-    private List<Integer> requestCalls = new ArrayList<Integer>();
-    private Metadata headers;
-    private Integer message;
-    private Metadata trailers;
+    private final MethodDescriptor<Integer, Integer> methodDescriptor;
+    private final List<Integer> requestCalls = new ArrayList<>();
+    private final List<Integer> responses = new ArrayList<>();
     private Status status;
     private boolean isCancelled;
-    private MethodDescriptor<Integer, Integer> methodDescriptor;
     private boolean isReady;
+    private int onReadyThreshold;
+    private Metadata trailers;
+
+    public ServerCallRecorder(MethodDescriptor<Integer, Integer> methodDescriptor) {
+      this.methodDescriptor = methodDescriptor;
+    }
 
     @Override
     public void request(int numMessages) {
@@ -405,12 +694,11 @@ public void request(int numMessages) {
 
     @Override
     public void sendHeaders(Metadata headers) {
-      this.headers = headers;
     }
 
     @Override
     public void sendMessage(Integer message) {
-      this.message = message;
+      this.responses.add(message);
     }
 
     @Override
@@ -429,9 +717,19 @@ public boolean isReady() {
       return isReady;
     }
 
+    @Override
+    public void setOnReadyThreshold(int numBytes) {
+      super.setOnReadyThreshold(numBytes);
+      onReadyThreshold = numBytes;
+    }
+
     @Override
     public MethodDescriptor<Integer, Integer> getMethodDescriptor() {
       return methodDescriptor;
     }
+
+    public int getOnReadyThreshold() {
+      return onReadyThreshold;
+    }
   }
 }
diff --git a/stub/src/test/java/io/grpc/stub/StreamObserversTest.java b/stub/src/test/java/io/grpc/stub/StreamObserversTest.java
new file mode 100644
index 00000000000..237dd2e1434
--- /dev/null
+++ b/stub/src/test/java/io/grpc/stub/StreamObserversTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2025 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.stub;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.InOrder;
+import org.mockito.Mockito;
+
+@RunWith(JUnit4.class)
+public class StreamObserversTest {
+
+  @Test
+  public void nextAndComplete() {
+    @SuppressWarnings("unchecked")
+    StreamObserver<String> observer = Mockito.mock(StreamObserver.class);
+    InOrder inOrder = Mockito.inOrder(observer);
+    StreamObservers.nextAndComplete(observer, "TEST");
+    inOrder.verify(observer).onNext("TEST");
+    inOrder.verify(observer).onCompleted();
+    inOrder.verifyNoMoreInteractions();
+  }
+}
diff --git a/testing-proto/BUILD.bazel b/testing-proto/BUILD.bazel
new file mode 100644
index 00000000000..aa0fc9ee20b
--- /dev/null
+++ b/testing-proto/BUILD.bazel
@@ -0,0 +1,22 @@
+load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library")
+load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library")
+load("//:java_grpc_library.bzl", "java_grpc_library")
+
+proto_library(
+    name = "simpleservice_proto",
+    srcs = ["src/main/proto/io/grpc/testing/protobuf/simpleservice.proto"],
+    strip_import_prefix = "src/main/proto/",
+)
+
+java_proto_library(
+    name = "simpleservice_java_proto",
+    visibility = ["//xds:__pkg__"],
+    deps = [":simpleservice_proto"],
+)
+
+java_grpc_library(
+    name = "simpleservice_java_grpc",
+    srcs = [":simpleservice_proto"],
+    visibility = ["//xds:__pkg__"],
+    deps = [":simpleservice_java_proto"],
+)
diff --git a/testing-proto/build.gradle b/testing-proto/build.gradle
index f5fc71ececb..ee602bc5135 100644
--- a/testing-proto/build.gradle
+++ b/testing-proto/build.gradle
@@ -1,26 +1,28 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "com.google.protobuf"
+    id "ru.vyarus.animalsniffer"
+}
+
 description = "gRPC: Testing Protos"
 
-// Add dependency on the protobuf plugin
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-    dependencies {
-        classpath libraries.protobuf_plugin
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.testing.protobuf')
     }
 }
 
 dependencies {
-    compile project(':grpc-protobuf'),
+    api project(':grpc-protobuf'),
             project(':grpc-stub')
+    testImplementation libraries.truth
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
 }
 
 configureProtoCompilation()
-
-// Let intellij projects refer to generated code
-idea {
-    module {
-        sourceDirs += file("${projectDir}/src/generated/main/java")
-        sourceDirs += file("${projectDir}/src/generated/main/grpc")
-    }
-}
diff --git a/testing-proto/src/generated/main/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java b/testing-proto/src/generated/main/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java
deleted file mode 100644
index f8bc5c4ce8e..00000000000
--- a/testing-proto/src/generated/main/grpc/io/grpc/testing/integration/MetricsServiceGrpc.java
+++ /dev/null
@@ -1,299 +0,0 @@
-package io.grpc.testing.integration;
-
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
-
-/**
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: io/grpc/testing/integration/metrics.proto")
-public final class MetricsServiceGrpc {
-
-  private MetricsServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "grpc.testing.MetricsService";
-
-  // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.EmptyMessage,
-      io.grpc.testing.integration.Metrics.GaugeResponse> METHOD_GET_ALL_GAUGES =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.MetricsService", "GetAllGauges"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Metrics.EmptyMessage.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Metrics.GaugeRequest,
-      io.grpc.testing.integration.Metrics.GaugeResponse> METHOD_GET_GAUGE =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.testing.MetricsService", "GetGauge"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Metrics.GaugeRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance()));
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static MetricsServiceStub newStub(io.grpc.Channel channel) {
-    return new MetricsServiceStub(channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static MetricsServiceBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    return new MetricsServiceBlockingStub(channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
-   */
-  public static MetricsServiceFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    return new MetricsServiceFutureStub(channel);
-  }
-
-  /**
-   */
-  public static abstract class MetricsServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     * <pre>
-     * Returns the values of all the gauges that are currently being maintained by
-     * the service
-     * </pre>
-     */
-    public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_GET_ALL_GAUGES, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * Returns the value of one gauge
-     * </pre>
-     */
-    public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_GET_GAUGE, responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_GET_ALL_GAUGES,
-            asyncServerStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Metrics.EmptyMessage,
-                io.grpc.testing.integration.Metrics.GaugeResponse>(
-                  this, METHODID_GET_ALL_GAUGES)))
-          .addMethod(
-            METHOD_GET_GAUGE,
-            asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Metrics.GaugeRequest,
-                io.grpc.testing.integration.Metrics.GaugeResponse>(
-                  this, METHODID_GET_GAUGE)))
-          .build();
-    }
-  }
-
-  /**
-   */
-  public static final class MetricsServiceStub extends io.grpc.stub.AbstractStub<MetricsServiceStub> {
-    private MetricsServiceStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private MetricsServiceStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected MetricsServiceStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new MetricsServiceStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * Returns the values of all the gauges that are currently being maintained by
-     * the service
-     * </pre>
-     */
-    public void getAllGauges(io.grpc.testing.integration.Metrics.EmptyMessage request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
-      asyncServerStreamingCall(
-          getChannel().newCall(METHOD_GET_ALL_GAUGES, getCallOptions()), request, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * Returns the value of one gauge
-     * </pre>
-     */
-    public void getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_GET_GAUGE, getCallOptions()), request, responseObserver);
-    }
-  }
-
-  /**
-   */
-  public static final class MetricsServiceBlockingStub extends io.grpc.stub.AbstractStub<MetricsServiceBlockingStub> {
-    private MetricsServiceBlockingStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private MetricsServiceBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected MetricsServiceBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new MetricsServiceBlockingStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * Returns the values of all the gauges that are currently being maintained by
-     * the service
-     * </pre>
-     */
-    public java.util.Iterator<io.grpc.testing.integration.Metrics.GaugeResponse> getAllGauges(
-        io.grpc.testing.integration.Metrics.EmptyMessage request) {
-      return blockingServerStreamingCall(
-          getChannel(), METHOD_GET_ALL_GAUGES, getCallOptions(), request);
-    }
-
-    /**
-     * <pre>
-     * Returns the value of one gauge
-     * </pre>
-     */
-    public io.grpc.testing.integration.Metrics.GaugeResponse getGauge(io.grpc.testing.integration.Metrics.GaugeRequest request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_GET_GAUGE, getCallOptions(), request);
-    }
-  }
-
-  /**
-   */
-  public static final class MetricsServiceFutureStub extends io.grpc.stub.AbstractStub<MetricsServiceFutureStub> {
-    private MetricsServiceFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private MetricsServiceFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected MetricsServiceFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new MetricsServiceFutureStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * Returns the value of one gauge
-     * </pre>
-     */
-    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Metrics.GaugeResponse> getGauge(
-        io.grpc.testing.integration.Metrics.GaugeRequest request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_GET_GAUGE, getCallOptions()), request);
-    }
-  }
-
-  private static final int METHODID_GET_ALL_GAUGES = 0;
-  private static final int METHODID_GET_GAUGE = 1;
-
-  private static final class MethodHandlers<Req, Resp> implements
-      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final MetricsServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(MetricsServiceImplBase serviceImpl, int methodId) {
-      this.serviceImpl = serviceImpl;
-      this.methodId = methodId;
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        case METHODID_GET_ALL_GAUGES:
-          serviceImpl.getAllGauges((io.grpc.testing.integration.Metrics.EmptyMessage) request,
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse>) responseObserver);
-          break;
-        case METHODID_GET_GAUGE:
-          serviceImpl.getGauge((io.grpc.testing.integration.Metrics.GaugeRequest) request,
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Metrics.GaugeResponse>) responseObserver);
-          break;
-        default:
-          throw new AssertionError();
-      }
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public io.grpc.stub.StreamObserver<Req> invoke(
-        io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  private static final class MetricsServiceDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return io.grpc.testing.integration.Metrics.getDescriptor();
-    }
-  }
-
-  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
-
-  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
-    io.grpc.ServiceDescriptor result = serviceDescriptor;
-    if (result == null) {
-      synchronized (MetricsServiceGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new MetricsServiceDescriptorSupplier())
-              .addMethod(METHOD_GET_ALL_GAUGES)
-              .addMethod(METHOD_GET_GAUGE)
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/testing-proto/src/generated/main/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java b/testing-proto/src/generated/main/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java
deleted file mode 100644
index 5610bad7cb5..00000000000
--- a/testing-proto/src/generated/main/grpc/io/grpc/testing/integration/ReconnectServiceGrpc.java
+++ /dev/null
@@ -1,297 +0,0 @@
-package io.grpc.testing.integration;
-
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
-
-/**
- * <pre>
- * A service used to control reconnect server.
- * </pre>
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: io/grpc/testing/integration/test.proto")
-public final class ReconnectServiceGrpc {
-
-  private ReconnectServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "grpc.testing.ReconnectService";
-
-  // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<com.google.protobuf.EmptyProtos.Empty,
-      com.google.protobuf.EmptyProtos.Empty> METHOD_START =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.testing.ReconnectService", "Start"),
-          io.grpc.protobuf.ProtoUtils.marshaller(com.google.protobuf.EmptyProtos.Empty.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(com.google.protobuf.EmptyProtos.Empty.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<com.google.protobuf.EmptyProtos.Empty,
-      io.grpc.testing.integration.Messages.ReconnectInfo> METHOD_STOP =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.testing.ReconnectService", "Stop"),
-          io.grpc.protobuf.ProtoUtils.marshaller(com.google.protobuf.EmptyProtos.Empty.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.ReconnectInfo.getDefaultInstance()));
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static ReconnectServiceStub newStub(io.grpc.Channel channel) {
-    return new ReconnectServiceStub(channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static ReconnectServiceBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    return new ReconnectServiceBlockingStub(channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
-   */
-  public static ReconnectServiceFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    return new ReconnectServiceFutureStub(channel);
-  }
-
-  /**
-   * <pre>
-   * A service used to control reconnect server.
-   * </pre>
-   */
-  public static abstract class ReconnectServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     */
-    public void start(com.google.protobuf.EmptyProtos.Empty request,
-        io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_START, responseObserver);
-    }
-
-    /**
-     */
-    public void stop(com.google.protobuf.EmptyProtos.Empty request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ReconnectInfo> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_STOP, responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_START,
-            asyncUnaryCall(
-              new MethodHandlers<
-                com.google.protobuf.EmptyProtos.Empty,
-                com.google.protobuf.EmptyProtos.Empty>(
-                  this, METHODID_START)))
-          .addMethod(
-            METHOD_STOP,
-            asyncUnaryCall(
-              new MethodHandlers<
-                com.google.protobuf.EmptyProtos.Empty,
-                io.grpc.testing.integration.Messages.ReconnectInfo>(
-                  this, METHODID_STOP)))
-          .build();
-    }
-  }
-
-  /**
-   * <pre>
-   * A service used to control reconnect server.
-   * </pre>
-   */
-  public static final class ReconnectServiceStub extends io.grpc.stub.AbstractStub<ReconnectServiceStub> {
-    private ReconnectServiceStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private ReconnectServiceStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected ReconnectServiceStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new ReconnectServiceStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public void start(com.google.protobuf.EmptyProtos.Empty request,
-        io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_START, getCallOptions()), request, responseObserver);
-    }
-
-    /**
-     */
-    public void stop(com.google.protobuf.EmptyProtos.Empty request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ReconnectInfo> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_STOP, getCallOptions()), request, responseObserver);
-    }
-  }
-
-  /**
-   * <pre>
-   * A service used to control reconnect server.
-   * </pre>
-   */
-  public static final class ReconnectServiceBlockingStub extends io.grpc.stub.AbstractStub<ReconnectServiceBlockingStub> {
-    private ReconnectServiceBlockingStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private ReconnectServiceBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected ReconnectServiceBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new ReconnectServiceBlockingStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public com.google.protobuf.EmptyProtos.Empty start(com.google.protobuf.EmptyProtos.Empty request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_START, getCallOptions(), request);
-    }
-
-    /**
-     */
-    public io.grpc.testing.integration.Messages.ReconnectInfo stop(com.google.protobuf.EmptyProtos.Empty request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_STOP, getCallOptions(), request);
-    }
-  }
-
-  /**
-   * <pre>
-   * A service used to control reconnect server.
-   * </pre>
-   */
-  public static final class ReconnectServiceFutureStub extends io.grpc.stub.AbstractStub<ReconnectServiceFutureStub> {
-    private ReconnectServiceFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private ReconnectServiceFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected ReconnectServiceFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new ReconnectServiceFutureStub(channel, callOptions);
-    }
-
-    /**
-     */
-    public com.google.common.util.concurrent.ListenableFuture<com.google.protobuf.EmptyProtos.Empty> start(
-        com.google.protobuf.EmptyProtos.Empty request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_START, getCallOptions()), request);
-    }
-
-    /**
-     */
-    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.ReconnectInfo> stop(
-        com.google.protobuf.EmptyProtos.Empty request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_STOP, getCallOptions()), request);
-    }
-  }
-
-  private static final int METHODID_START = 0;
-  private static final int METHODID_STOP = 1;
-
-  private static final class MethodHandlers<Req, Resp> implements
-      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final ReconnectServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(ReconnectServiceImplBase serviceImpl, int methodId) {
-      this.serviceImpl = serviceImpl;
-      this.methodId = methodId;
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        case METHODID_START:
-          serviceImpl.start((com.google.protobuf.EmptyProtos.Empty) request,
-              (io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty>) responseObserver);
-          break;
-        case METHODID_STOP:
-          serviceImpl.stop((com.google.protobuf.EmptyProtos.Empty) request,
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.ReconnectInfo>) responseObserver);
-          break;
-        default:
-          throw new AssertionError();
-      }
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public io.grpc.stub.StreamObserver<Req> invoke(
-        io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  private static final class ReconnectServiceDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return io.grpc.testing.integration.Test.getDescriptor();
-    }
-  }
-
-  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
-
-  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
-    io.grpc.ServiceDescriptor result = serviceDescriptor;
-    if (result == null) {
-      synchronized (ReconnectServiceGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new ReconnectServiceDescriptorSupplier())
-              .addMethod(METHOD_START)
-              .addMethod(METHOD_STOP)
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/testing-proto/src/generated/main/grpc/io/grpc/testing/integration/TestServiceGrpc.java b/testing-proto/src/generated/main/grpc/io/grpc/testing/integration/TestServiceGrpc.java
deleted file mode 100644
index a2c80f3d648..00000000000
--- a/testing-proto/src/generated/main/grpc/io/grpc/testing/integration/TestServiceGrpc.java
+++ /dev/null
@@ -1,589 +0,0 @@
-package io.grpc.testing.integration;
-
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
-
-/**
- * <pre>
- * A simple service to test the various types of RPCs and experiment with
- * performance with various types of payload.
- * </pre>
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: io/grpc/testing/integration/test.proto")
-public final class TestServiceGrpc {
-
-  private TestServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "grpc.testing.TestService";
-
-  // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<com.google.protobuf.EmptyProtos.Empty,
-      com.google.protobuf.EmptyProtos.Empty> METHOD_EMPTY_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.testing.TestService", "EmptyCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(com.google.protobuf.EmptyProtos.Empty.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(com.google.protobuf.EmptyProtos.Empty.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.SimpleRequest,
-      io.grpc.testing.integration.Messages.SimpleResponse> METHOD_UNARY_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.testing.TestService", "UnaryCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.SimpleRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.SimpleResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
-      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> METHOD_STREAMING_OUTPUT_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "StreamingOutputCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingInputCallRequest,
-      io.grpc.testing.integration.Messages.StreamingInputCallResponse> METHOD_STREAMING_INPUT_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "StreamingInputCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.StreamingInputCallRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.StreamingInputCallResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
-      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> METHOD_FULL_DUPLEX_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "FullDuplexCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
-      io.grpc.testing.integration.Messages.StreamingOutputCallResponse> METHOD_HALF_DUPLEX_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING,
-          generateFullMethodName(
-              "grpc.testing.TestService", "HalfDuplexCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()));
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<com.google.protobuf.EmptyProtos.Empty,
-      com.google.protobuf.EmptyProtos.Empty> METHOD_UNIMPLEMENTED_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.testing.TestService", "UnimplementedCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(com.google.protobuf.EmptyProtos.Empty.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(com.google.protobuf.EmptyProtos.Empty.getDefaultInstance()));
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static TestServiceStub newStub(io.grpc.Channel channel) {
-    return new TestServiceStub(channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static TestServiceBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    return new TestServiceBlockingStub(channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
-   */
-  public static TestServiceFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    return new TestServiceFutureStub(channel);
-  }
-
-  /**
-   * <pre>
-   * A simple service to test the various types of RPCs and experiment with
-   * performance with various types of payload.
-   * </pre>
-   */
-  public static abstract class TestServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     * <pre>
-     * One empty request followed by one empty response.
-     * </pre>
-     */
-    public void emptyCall(com.google.protobuf.EmptyProtos.Empty request,
-        io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_EMPTY_CALL, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * One request followed by one response.
-     * </pre>
-     */
-    public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_UNARY_CALL, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * One request followed by a sequence of responses (streamed download).
-     * The server returns the payload with client desired type and sizes.
-     * </pre>
-     */
-    public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_STREAMING_OUTPUT_CALL, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * A sequence of requests followed by one response (streamed upload).
-     * The server returns the aggregated size of client payload as the result.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallRequest> streamingInputCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_STREAMING_INPUT_CALL, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * A sequence of requests with each request served by the server immediately.
-     * As one request could lead to multiple responses, this interface
-     * demonstrates the idea of full duplexing.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> fullDuplexCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_FULL_DUPLEX_CALL, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * A sequence of requests followed by a sequence of responses.
-     * The server buffers all the client requests and then serves them in order. A
-     * stream of responses are returned to the client when the server starts with
-     * first request.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> halfDuplexCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
-      return asyncUnimplementedStreamingCall(METHOD_HALF_DUPLEX_CALL, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * The test server will not implement this method. It will be used
-     * to test the behavior when clients call unimplemented methods.
-     * </pre>
-     */
-    public void unimplementedCall(com.google.protobuf.EmptyProtos.Empty request,
-        io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_UNIMPLEMENTED_CALL, responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_EMPTY_CALL,
-            asyncUnaryCall(
-              new MethodHandlers<
-                com.google.protobuf.EmptyProtos.Empty,
-                com.google.protobuf.EmptyProtos.Empty>(
-                  this, METHODID_EMPTY_CALL)))
-          .addMethod(
-            METHOD_UNARY_CALL,
-            asyncUnaryCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Messages.SimpleRequest,
-                io.grpc.testing.integration.Messages.SimpleResponse>(
-                  this, METHODID_UNARY_CALL)))
-          .addMethod(
-            METHOD_STREAMING_OUTPUT_CALL,
-            asyncServerStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
-                io.grpc.testing.integration.Messages.StreamingOutputCallResponse>(
-                  this, METHODID_STREAMING_OUTPUT_CALL)))
-          .addMethod(
-            METHOD_STREAMING_INPUT_CALL,
-            asyncClientStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Messages.StreamingInputCallRequest,
-                io.grpc.testing.integration.Messages.StreamingInputCallResponse>(
-                  this, METHODID_STREAMING_INPUT_CALL)))
-          .addMethod(
-            METHOD_FULL_DUPLEX_CALL,
-            asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
-                io.grpc.testing.integration.Messages.StreamingOutputCallResponse>(
-                  this, METHODID_FULL_DUPLEX_CALL)))
-          .addMethod(
-            METHOD_HALF_DUPLEX_CALL,
-            asyncBidiStreamingCall(
-              new MethodHandlers<
-                io.grpc.testing.integration.Messages.StreamingOutputCallRequest,
-                io.grpc.testing.integration.Messages.StreamingOutputCallResponse>(
-                  this, METHODID_HALF_DUPLEX_CALL)))
-          .addMethod(
-            METHOD_UNIMPLEMENTED_CALL,
-            asyncUnaryCall(
-              new MethodHandlers<
-                com.google.protobuf.EmptyProtos.Empty,
-                com.google.protobuf.EmptyProtos.Empty>(
-                  this, METHODID_UNIMPLEMENTED_CALL)))
-          .build();
-    }
-  }
-
-  /**
-   * <pre>
-   * A simple service to test the various types of RPCs and experiment with
-   * performance with various types of payload.
-   * </pre>
-   */
-  public static final class TestServiceStub extends io.grpc.stub.AbstractStub<TestServiceStub> {
-    private TestServiceStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private TestServiceStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected TestServiceStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new TestServiceStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * One empty request followed by one empty response.
-     * </pre>
-     */
-    public void emptyCall(com.google.protobuf.EmptyProtos.Empty request,
-        io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_EMPTY_CALL, getCallOptions()), request, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * One request followed by one response.
-     * </pre>
-     */
-    public void unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_UNARY_CALL, getCallOptions()), request, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * One request followed by a sequence of responses (streamed download).
-     * The server returns the payload with client desired type and sizes.
-     * </pre>
-     */
-    public void streamingOutputCall(io.grpc.testing.integration.Messages.StreamingOutputCallRequest request,
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
-      asyncServerStreamingCall(
-          getChannel().newCall(METHOD_STREAMING_OUTPUT_CALL, getCallOptions()), request, responseObserver);
-    }
-
-    /**
-     * <pre>
-     * A sequence of requests followed by one response (streamed upload).
-     * The server returns the aggregated size of client payload as the result.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallRequest> streamingInputCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallResponse> responseObserver) {
-      return asyncClientStreamingCall(
-          getChannel().newCall(METHOD_STREAMING_INPUT_CALL, getCallOptions()), responseObserver);
-    }
-
-    /**
-     * <pre>
-     * A sequence of requests with each request served by the server immediately.
-     * As one request could lead to multiple responses, this interface
-     * demonstrates the idea of full duplexing.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> fullDuplexCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
-      return asyncBidiStreamingCall(
-          getChannel().newCall(METHOD_FULL_DUPLEX_CALL, getCallOptions()), responseObserver);
-    }
-
-    /**
-     * <pre>
-     * A sequence of requests followed by a sequence of responses.
-     * The server buffers all the client requests and then serves them in order. A
-     * stream of responses are returned to the client when the server starts with
-     * first request.
-     * </pre>
-     */
-    public io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallRequest> halfDuplexCall(
-        io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> responseObserver) {
-      return asyncBidiStreamingCall(
-          getChannel().newCall(METHOD_HALF_DUPLEX_CALL, getCallOptions()), responseObserver);
-    }
-
-    /**
-     * <pre>
-     * The test server will not implement this method. It will be used
-     * to test the behavior when clients call unimplemented methods.
-     * </pre>
-     */
-    public void unimplementedCall(com.google.protobuf.EmptyProtos.Empty request,
-        io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_UNIMPLEMENTED_CALL, getCallOptions()), request, responseObserver);
-    }
-  }
-
-  /**
-   * <pre>
-   * A simple service to test the various types of RPCs and experiment with
-   * performance with various types of payload.
-   * </pre>
-   */
-  public static final class TestServiceBlockingStub extends io.grpc.stub.AbstractStub<TestServiceBlockingStub> {
-    private TestServiceBlockingStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private TestServiceBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected TestServiceBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new TestServiceBlockingStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * One empty request followed by one empty response.
-     * </pre>
-     */
-    public com.google.protobuf.EmptyProtos.Empty emptyCall(com.google.protobuf.EmptyProtos.Empty request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_EMPTY_CALL, getCallOptions(), request);
-    }
-
-    /**
-     * <pre>
-     * One request followed by one response.
-     * </pre>
-     */
-    public io.grpc.testing.integration.Messages.SimpleResponse unaryCall(io.grpc.testing.integration.Messages.SimpleRequest request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_UNARY_CALL, getCallOptions(), request);
-    }
-
-    /**
-     * <pre>
-     * One request followed by a sequence of responses (streamed download).
-     * The server returns the payload with client desired type and sizes.
-     * </pre>
-     */
-    public java.util.Iterator<io.grpc.testing.integration.Messages.StreamingOutputCallResponse> streamingOutputCall(
-        io.grpc.testing.integration.Messages.StreamingOutputCallRequest request) {
-      return blockingServerStreamingCall(
-          getChannel(), METHOD_STREAMING_OUTPUT_CALL, getCallOptions(), request);
-    }
-
-    /**
-     * <pre>
-     * The test server will not implement this method. It will be used
-     * to test the behavior when clients call unimplemented methods.
-     * </pre>
-     */
-    public com.google.protobuf.EmptyProtos.Empty unimplementedCall(com.google.protobuf.EmptyProtos.Empty request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_UNIMPLEMENTED_CALL, getCallOptions(), request);
-    }
-  }
-
-  /**
-   * <pre>
-   * A simple service to test the various types of RPCs and experiment with
-   * performance with various types of payload.
-   * </pre>
-   */
-  public static final class TestServiceFutureStub extends io.grpc.stub.AbstractStub<TestServiceFutureStub> {
-    private TestServiceFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private TestServiceFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected TestServiceFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new TestServiceFutureStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * One empty request followed by one empty response.
-     * </pre>
-     */
-    public com.google.common.util.concurrent.ListenableFuture<com.google.protobuf.EmptyProtos.Empty> emptyCall(
-        com.google.protobuf.EmptyProtos.Empty request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_EMPTY_CALL, getCallOptions()), request);
-    }
-
-    /**
-     * <pre>
-     * One request followed by one response.
-     * </pre>
-     */
-    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.integration.Messages.SimpleResponse> unaryCall(
-        io.grpc.testing.integration.Messages.SimpleRequest request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_UNARY_CALL, getCallOptions()), request);
-    }
-
-    /**
-     * <pre>
-     * The test server will not implement this method. It will be used
-     * to test the behavior when clients call unimplemented methods.
-     * </pre>
-     */
-    public com.google.common.util.concurrent.ListenableFuture<com.google.protobuf.EmptyProtos.Empty> unimplementedCall(
-        com.google.protobuf.EmptyProtos.Empty request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_UNIMPLEMENTED_CALL, getCallOptions()), request);
-    }
-  }
-
-  private static final int METHODID_EMPTY_CALL = 0;
-  private static final int METHODID_UNARY_CALL = 1;
-  private static final int METHODID_STREAMING_OUTPUT_CALL = 2;
-  private static final int METHODID_UNIMPLEMENTED_CALL = 3;
-  private static final int METHODID_STREAMING_INPUT_CALL = 4;
-  private static final int METHODID_FULL_DUPLEX_CALL = 5;
-  private static final int METHODID_HALF_DUPLEX_CALL = 6;
-
-  private static final class MethodHandlers<Req, Resp> implements
-      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final TestServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(TestServiceImplBase serviceImpl, int methodId) {
-      this.serviceImpl = serviceImpl;
-      this.methodId = methodId;
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        case METHODID_EMPTY_CALL:
-          serviceImpl.emptyCall((com.google.protobuf.EmptyProtos.Empty) request,
-              (io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty>) responseObserver);
-          break;
-        case METHODID_UNARY_CALL:
-          serviceImpl.unaryCall((io.grpc.testing.integration.Messages.SimpleRequest) request,
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.SimpleResponse>) responseObserver);
-          break;
-        case METHODID_STREAMING_OUTPUT_CALL:
-          serviceImpl.streamingOutputCall((io.grpc.testing.integration.Messages.StreamingOutputCallRequest) request,
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse>) responseObserver);
-          break;
-        case METHODID_UNIMPLEMENTED_CALL:
-          serviceImpl.unimplementedCall((com.google.protobuf.EmptyProtos.Empty) request,
-              (io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty>) responseObserver);
-          break;
-        default:
-          throw new AssertionError();
-      }
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public io.grpc.stub.StreamObserver<Req> invoke(
-        io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        case METHODID_STREAMING_INPUT_CALL:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamingInputCall(
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingInputCallResponse>) responseObserver);
-        case METHODID_FULL_DUPLEX_CALL:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.fullDuplexCall(
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse>) responseObserver);
-        case METHODID_HALF_DUPLEX_CALL:
-          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.halfDuplexCall(
-              (io.grpc.stub.StreamObserver<io.grpc.testing.integration.Messages.StreamingOutputCallResponse>) responseObserver);
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  private static final class TestServiceDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return io.grpc.testing.integration.Test.getDescriptor();
-    }
-  }
-
-  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
-
-  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
-    io.grpc.ServiceDescriptor result = serviceDescriptor;
-    if (result == null) {
-      synchronized (TestServiceGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new TestServiceDescriptorSupplier())
-              .addMethod(METHOD_EMPTY_CALL)
-              .addMethod(METHOD_UNARY_CALL)
-              .addMethod(METHOD_STREAMING_OUTPUT_CALL)
-              .addMethod(METHOD_STREAMING_INPUT_CALL)
-              .addMethod(METHOD_FULL_DUPLEX_CALL)
-              .addMethod(METHOD_HALF_DUPLEX_CALL)
-              .addMethod(METHOD_UNIMPLEMENTED_CALL)
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/testing-proto/src/generated/main/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java b/testing-proto/src/generated/main/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java
deleted file mode 100644
index 00b76d4cd69..00000000000
--- a/testing-proto/src/generated/main/grpc/io/grpc/testing/integration/UnimplementedServiceGrpc.java
+++ /dev/null
@@ -1,262 +0,0 @@
-package io.grpc.testing.integration;
-
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
-import static io.grpc.MethodDescriptor.generateFullMethodName;
-import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
-
-/**
- * <pre>
- * A simple service NOT implemented at servers so clients can test for
- * that case.
- * </pre>
- */
-@javax.annotation.Generated(
-    value = "by gRPC proto compiler (version 1.2.0-SNAPSHOT)",
-    comments = "Source: io/grpc/testing/integration/test.proto")
-public final class UnimplementedServiceGrpc {
-
-  private UnimplementedServiceGrpc() {}
-
-  public static final String SERVICE_NAME = "grpc.testing.UnimplementedService";
-
-  // Static method descriptors that strictly reflect the proto.
-  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
-  public static final io.grpc.MethodDescriptor<com.google.protobuf.EmptyProtos.Empty,
-      com.google.protobuf.EmptyProtos.Empty> METHOD_UNIMPLEMENTED_CALL =
-      io.grpc.MethodDescriptor.create(
-          io.grpc.MethodDescriptor.MethodType.UNARY,
-          generateFullMethodName(
-              "grpc.testing.UnimplementedService", "UnimplementedCall"),
-          io.grpc.protobuf.ProtoUtils.marshaller(com.google.protobuf.EmptyProtos.Empty.getDefaultInstance()),
-          io.grpc.protobuf.ProtoUtils.marshaller(com.google.protobuf.EmptyProtos.Empty.getDefaultInstance()));
-
-  /**
-   * Creates a new async stub that supports all call types for the service
-   */
-  public static UnimplementedServiceStub newStub(io.grpc.Channel channel) {
-    return new UnimplementedServiceStub(channel);
-  }
-
-  /**
-   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
-   */
-  public static UnimplementedServiceBlockingStub newBlockingStub(
-      io.grpc.Channel channel) {
-    return new UnimplementedServiceBlockingStub(channel);
-  }
-
-  /**
-   * Creates a new ListenableFuture-style stub that supports unary and streaming output calls on the service
-   */
-  public static UnimplementedServiceFutureStub newFutureStub(
-      io.grpc.Channel channel) {
-    return new UnimplementedServiceFutureStub(channel);
-  }
-
-  /**
-   * <pre>
-   * A simple service NOT implemented at servers so clients can test for
-   * that case.
-   * </pre>
-   */
-  public static abstract class UnimplementedServiceImplBase implements io.grpc.BindableService {
-
-    /**
-     * <pre>
-     * A call that no server should implement
-     * </pre>
-     */
-    public void unimplementedCall(com.google.protobuf.EmptyProtos.Empty request,
-        io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty> responseObserver) {
-      asyncUnimplementedUnaryCall(METHOD_UNIMPLEMENTED_CALL, responseObserver);
-    }
-
-    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
-      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
-          .addMethod(
-            METHOD_UNIMPLEMENTED_CALL,
-            asyncUnaryCall(
-              new MethodHandlers<
-                com.google.protobuf.EmptyProtos.Empty,
-                com.google.protobuf.EmptyProtos.Empty>(
-                  this, METHODID_UNIMPLEMENTED_CALL)))
-          .build();
-    }
-  }
-
-  /**
-   * <pre>
-   * A simple service NOT implemented at servers so clients can test for
-   * that case.
-   * </pre>
-   */
-  public static final class UnimplementedServiceStub extends io.grpc.stub.AbstractStub<UnimplementedServiceStub> {
-    private UnimplementedServiceStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private UnimplementedServiceStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected UnimplementedServiceStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new UnimplementedServiceStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * A call that no server should implement
-     * </pre>
-     */
-    public void unimplementedCall(com.google.protobuf.EmptyProtos.Empty request,
-        io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty> responseObserver) {
-      asyncUnaryCall(
-          getChannel().newCall(METHOD_UNIMPLEMENTED_CALL, getCallOptions()), request, responseObserver);
-    }
-  }
-
-  /**
-   * <pre>
-   * A simple service NOT implemented at servers so clients can test for
-   * that case.
-   * </pre>
-   */
-  public static final class UnimplementedServiceBlockingStub extends io.grpc.stub.AbstractStub<UnimplementedServiceBlockingStub> {
-    private UnimplementedServiceBlockingStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private UnimplementedServiceBlockingStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected UnimplementedServiceBlockingStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new UnimplementedServiceBlockingStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * A call that no server should implement
-     * </pre>
-     */
-    public com.google.protobuf.EmptyProtos.Empty unimplementedCall(com.google.protobuf.EmptyProtos.Empty request) {
-      return blockingUnaryCall(
-          getChannel(), METHOD_UNIMPLEMENTED_CALL, getCallOptions(), request);
-    }
-  }
-
-  /**
-   * <pre>
-   * A simple service NOT implemented at servers so clients can test for
-   * that case.
-   * </pre>
-   */
-  public static final class UnimplementedServiceFutureStub extends io.grpc.stub.AbstractStub<UnimplementedServiceFutureStub> {
-    private UnimplementedServiceFutureStub(io.grpc.Channel channel) {
-      super(channel);
-    }
-
-    private UnimplementedServiceFutureStub(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      super(channel, callOptions);
-    }
-
-    @java.lang.Override
-    protected UnimplementedServiceFutureStub build(io.grpc.Channel channel,
-        io.grpc.CallOptions callOptions) {
-      return new UnimplementedServiceFutureStub(channel, callOptions);
-    }
-
-    /**
-     * <pre>
-     * A call that no server should implement
-     * </pre>
-     */
-    public com.google.common.util.concurrent.ListenableFuture<com.google.protobuf.EmptyProtos.Empty> unimplementedCall(
-        com.google.protobuf.EmptyProtos.Empty request) {
-      return futureUnaryCall(
-          getChannel().newCall(METHOD_UNIMPLEMENTED_CALL, getCallOptions()), request);
-    }
-  }
-
-  private static final int METHODID_UNIMPLEMENTED_CALL = 0;
-
-  private static final class MethodHandlers<Req, Resp> implements
-      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
-      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
-    private final UnimplementedServiceImplBase serviceImpl;
-    private final int methodId;
-
-    MethodHandlers(UnimplementedServiceImplBase serviceImpl, int methodId) {
-      this.serviceImpl = serviceImpl;
-      this.methodId = methodId;
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        case METHODID_UNIMPLEMENTED_CALL:
-          serviceImpl.unimplementedCall((com.google.protobuf.EmptyProtos.Empty) request,
-              (io.grpc.stub.StreamObserver<com.google.protobuf.EmptyProtos.Empty>) responseObserver);
-          break;
-        default:
-          throw new AssertionError();
-      }
-    }
-
-    @java.lang.Override
-    @java.lang.SuppressWarnings("unchecked")
-    public io.grpc.stub.StreamObserver<Req> invoke(
-        io.grpc.stub.StreamObserver<Resp> responseObserver) {
-      switch (methodId) {
-        default:
-          throw new AssertionError();
-      }
-    }
-  }
-
-  private static final class UnimplementedServiceDescriptorSupplier implements io.grpc.protobuf.ProtoFileDescriptorSupplier {
-    @java.lang.Override
-    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
-      return io.grpc.testing.integration.Test.getDescriptor();
-    }
-  }
-
-  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
-
-  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
-    io.grpc.ServiceDescriptor result = serviceDescriptor;
-    if (result == null) {
-      synchronized (UnimplementedServiceGrpc.class) {
-        result = serviceDescriptor;
-        if (result == null) {
-          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
-              .setSchemaDescriptor(new UnimplementedServiceDescriptorSupplier())
-              .addMethod(METHOD_UNIMPLEMENTED_CALL)
-              .build();
-        }
-      }
-    }
-    return result;
-  }
-}
diff --git a/testing-proto/src/generated/main/grpc/io/grpc/testing/protobuf/SimpleServiceGrpc.java b/testing-proto/src/generated/main/grpc/io/grpc/testing/protobuf/SimpleServiceGrpc.java
new file mode 100644
index 00000000000..e242fd0f513
--- /dev/null
+++ b/testing-proto/src/generated/main/grpc/io/grpc/testing/protobuf/SimpleServiceGrpc.java
@@ -0,0 +1,605 @@
+package io.grpc.testing.protobuf;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A simple service for test.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class SimpleServiceGrpc {
+
+  private SimpleServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "grpc.testing.SimpleService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.protobuf.SimpleRequest,
+      io.grpc.testing.protobuf.SimpleResponse> getUnaryRpcMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "UnaryRpc",
+      requestType = io.grpc.testing.protobuf.SimpleRequest.class,
+      responseType = io.grpc.testing.protobuf.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.protobuf.SimpleRequest,
+      io.grpc.testing.protobuf.SimpleResponse> getUnaryRpcMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.protobuf.SimpleRequest, io.grpc.testing.protobuf.SimpleResponse> getUnaryRpcMethod;
+    if ((getUnaryRpcMethod = SimpleServiceGrpc.getUnaryRpcMethod) == null) {
+      synchronized (SimpleServiceGrpc.class) {
+        if ((getUnaryRpcMethod = SimpleServiceGrpc.getUnaryRpcMethod) == null) {
+          SimpleServiceGrpc.getUnaryRpcMethod = getUnaryRpcMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.protobuf.SimpleRequest, io.grpc.testing.protobuf.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UnaryRpc"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.protobuf.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.protobuf.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new SimpleServiceMethodDescriptorSupplier("UnaryRpc"))
+              .build();
+        }
+      }
+    }
+    return getUnaryRpcMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.protobuf.SimpleRequest,
+      io.grpc.testing.protobuf.SimpleResponse> getClientStreamingRpcMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "ClientStreamingRpc",
+      requestType = io.grpc.testing.protobuf.SimpleRequest.class,
+      responseType = io.grpc.testing.protobuf.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.protobuf.SimpleRequest,
+      io.grpc.testing.protobuf.SimpleResponse> getClientStreamingRpcMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.protobuf.SimpleRequest, io.grpc.testing.protobuf.SimpleResponse> getClientStreamingRpcMethod;
+    if ((getClientStreamingRpcMethod = SimpleServiceGrpc.getClientStreamingRpcMethod) == null) {
+      synchronized (SimpleServiceGrpc.class) {
+        if ((getClientStreamingRpcMethod = SimpleServiceGrpc.getClientStreamingRpcMethod) == null) {
+          SimpleServiceGrpc.getClientStreamingRpcMethod = getClientStreamingRpcMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.protobuf.SimpleRequest, io.grpc.testing.protobuf.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ClientStreamingRpc"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.protobuf.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.protobuf.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new SimpleServiceMethodDescriptorSupplier("ClientStreamingRpc"))
+              .build();
+        }
+      }
+    }
+    return getClientStreamingRpcMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.protobuf.SimpleRequest,
+      io.grpc.testing.protobuf.SimpleResponse> getServerStreamingRpcMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "ServerStreamingRpc",
+      requestType = io.grpc.testing.protobuf.SimpleRequest.class,
+      responseType = io.grpc.testing.protobuf.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.protobuf.SimpleRequest,
+      io.grpc.testing.protobuf.SimpleResponse> getServerStreamingRpcMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.protobuf.SimpleRequest, io.grpc.testing.protobuf.SimpleResponse> getServerStreamingRpcMethod;
+    if ((getServerStreamingRpcMethod = SimpleServiceGrpc.getServerStreamingRpcMethod) == null) {
+      synchronized (SimpleServiceGrpc.class) {
+        if ((getServerStreamingRpcMethod = SimpleServiceGrpc.getServerStreamingRpcMethod) == null) {
+          SimpleServiceGrpc.getServerStreamingRpcMethod = getServerStreamingRpcMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.protobuf.SimpleRequest, io.grpc.testing.protobuf.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ServerStreamingRpc"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.protobuf.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.protobuf.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new SimpleServiceMethodDescriptorSupplier("ServerStreamingRpc"))
+              .build();
+        }
+      }
+    }
+    return getServerStreamingRpcMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.grpc.testing.protobuf.SimpleRequest,
+      io.grpc.testing.protobuf.SimpleResponse> getBidiStreamingRpcMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "BidiStreamingRpc",
+      requestType = io.grpc.testing.protobuf.SimpleRequest.class,
+      responseType = io.grpc.testing.protobuf.SimpleResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.grpc.testing.protobuf.SimpleRequest,
+      io.grpc.testing.protobuf.SimpleResponse> getBidiStreamingRpcMethod() {
+    io.grpc.MethodDescriptor<io.grpc.testing.protobuf.SimpleRequest, io.grpc.testing.protobuf.SimpleResponse> getBidiStreamingRpcMethod;
+    if ((getBidiStreamingRpcMethod = SimpleServiceGrpc.getBidiStreamingRpcMethod) == null) {
+      synchronized (SimpleServiceGrpc.class) {
+        if ((getBidiStreamingRpcMethod = SimpleServiceGrpc.getBidiStreamingRpcMethod) == null) {
+          SimpleServiceGrpc.getBidiStreamingRpcMethod = getBidiStreamingRpcMethod =
+              io.grpc.MethodDescriptor.<io.grpc.testing.protobuf.SimpleRequest, io.grpc.testing.protobuf.SimpleResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "BidiStreamingRpc"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.protobuf.SimpleRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.grpc.testing.protobuf.SimpleResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new SimpleServiceMethodDescriptorSupplier("BidiStreamingRpc"))
+              .build();
+        }
+      }
+    }
+    return getBidiStreamingRpcMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static SimpleServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<SimpleServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<SimpleServiceStub>() {
+        @java.lang.Override
+        public SimpleServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new SimpleServiceStub(channel, callOptions);
+        }
+      };
+    return SimpleServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static SimpleServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<SimpleServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<SimpleServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public SimpleServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new SimpleServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return SimpleServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static SimpleServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<SimpleServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<SimpleServiceBlockingStub>() {
+        @java.lang.Override
+        public SimpleServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new SimpleServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return SimpleServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static SimpleServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<SimpleServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<SimpleServiceFutureStub>() {
+        @java.lang.Override
+        public SimpleServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new SimpleServiceFutureStub(channel, callOptions);
+        }
+      };
+    return SimpleServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A simple service for test.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Simple unary RPC.
+     * </pre>
+     */
+    default void unaryRpc(io.grpc.testing.protobuf.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUnaryRpcMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Simple client-to-server streaming RPC.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleRequest> clientStreamingRpc(
+        io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getClientStreamingRpcMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Simple server-to-client streaming RPC.
+     * </pre>
+     */
+    default void serverStreamingRpc(io.grpc.testing.protobuf.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getServerStreamingRpcMethod(), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Simple bidirectional streaming RPC.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleRequest> bidiStreamingRpc(
+        io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getBidiStreamingRpcMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service SimpleService.
+   * <pre>
+   * A simple service for test.
+   * </pre>
+   */
+  public static abstract class SimpleServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return SimpleServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service SimpleService.
+   * <pre>
+   * A simple service for test.
+   * </pre>
+   */
+  public static final class SimpleServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<SimpleServiceStub> {
+    private SimpleServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected SimpleServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new SimpleServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Simple unary RPC.
+     * </pre>
+     */
+    public void unaryRpc(io.grpc.testing.protobuf.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getUnaryRpcMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Simple client-to-server streaming RPC.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleRequest> clientStreamingRpc(
+        io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncClientStreamingCall(
+          getChannel().newCall(getClientStreamingRpcMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Simple server-to-client streaming RPC.
+     * </pre>
+     */
+    public void serverStreamingRpc(io.grpc.testing.protobuf.SimpleRequest request,
+        io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getServerStreamingRpcMethod(), getCallOptions()), request, responseObserver);
+    }
+
+    /**
+     * <pre>
+     * Simple bidirectional streaming RPC.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleRequest> bidiStreamingRpc(
+        io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getBidiStreamingRpcMethod(), getCallOptions()), responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service SimpleService.
+   * <pre>
+   * A simple service for test.
+   * </pre>
+   */
+  public static final class SimpleServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<SimpleServiceBlockingV2Stub> {
+    private SimpleServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected SimpleServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new SimpleServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Simple unary RPC.
+     * </pre>
+     */
+    public io.grpc.testing.protobuf.SimpleResponse unaryRpc(io.grpc.testing.protobuf.SimpleRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getUnaryRpcMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Simple client-to-server streaming RPC.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.protobuf.SimpleRequest, io.grpc.testing.protobuf.SimpleResponse>
+        clientStreamingRpc() {
+      return io.grpc.stub.ClientCalls.blockingClientStreamingCall(
+          getChannel(), getClientStreamingRpcMethod(), getCallOptions());
+    }
+
+    /**
+     * <pre>
+     * Simple server-to-client streaming RPC.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<?, io.grpc.testing.protobuf.SimpleResponse>
+        serverStreamingRpc(io.grpc.testing.protobuf.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingV2ServerStreamingCall(
+          getChannel(), getServerStreamingRpcMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Simple bidirectional streaming RPC.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.grpc.testing.protobuf.SimpleRequest, io.grpc.testing.protobuf.SimpleResponse>
+        bidiStreamingRpc() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getBidiStreamingRpcMethod(), getCallOptions());
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service SimpleService.
+   * <pre>
+   * A simple service for test.
+   * </pre>
+   */
+  public static final class SimpleServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<SimpleServiceBlockingStub> {
+    private SimpleServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected SimpleServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new SimpleServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Simple unary RPC.
+     * </pre>
+     */
+    public io.grpc.testing.protobuf.SimpleResponse unaryRpc(io.grpc.testing.protobuf.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getUnaryRpcMethod(), getCallOptions(), request);
+    }
+
+    /**
+     * <pre>
+     * Simple server-to-client streaming RPC.
+     * </pre>
+     */
+    public java.util.Iterator<io.grpc.testing.protobuf.SimpleResponse> serverStreamingRpc(
+        io.grpc.testing.protobuf.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getServerStreamingRpcMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service SimpleService.
+   * <pre>
+   * A simple service for test.
+   * </pre>
+   */
+  public static final class SimpleServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<SimpleServiceFutureStub> {
+    private SimpleServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected SimpleServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new SimpleServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Simple unary RPC.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.grpc.testing.protobuf.SimpleResponse> unaryRpc(
+        io.grpc.testing.protobuf.SimpleRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getUnaryRpcMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_UNARY_RPC = 0;
+  private static final int METHODID_SERVER_STREAMING_RPC = 1;
+  private static final int METHODID_CLIENT_STREAMING_RPC = 2;
+  private static final int METHODID_BIDI_STREAMING_RPC = 3;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_UNARY_RPC:
+          serviceImpl.unaryRpc((io.grpc.testing.protobuf.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleResponse>) responseObserver);
+          break;
+        case METHODID_SERVER_STREAMING_RPC:
+          serviceImpl.serverStreamingRpc((io.grpc.testing.protobuf.SimpleRequest) request,
+              (io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_CLIENT_STREAMING_RPC:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.clientStreamingRpc(
+              (io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleResponse>) responseObserver);
+        case METHODID_BIDI_STREAMING_RPC:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.bidiStreamingRpc(
+              (io.grpc.stub.StreamObserver<io.grpc.testing.protobuf.SimpleResponse>) responseObserver);
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getUnaryRpcMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.grpc.testing.protobuf.SimpleRequest,
+              io.grpc.testing.protobuf.SimpleResponse>(
+                service, METHODID_UNARY_RPC)))
+        .addMethod(
+          getClientStreamingRpcMethod(),
+          io.grpc.stub.ServerCalls.asyncClientStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.protobuf.SimpleRequest,
+              io.grpc.testing.protobuf.SimpleResponse>(
+                service, METHODID_CLIENT_STREAMING_RPC)))
+        .addMethod(
+          getServerStreamingRpcMethod(),
+          io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.protobuf.SimpleRequest,
+              io.grpc.testing.protobuf.SimpleResponse>(
+                service, METHODID_SERVER_STREAMING_RPC)))
+        .addMethod(
+          getBidiStreamingRpcMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.grpc.testing.protobuf.SimpleRequest,
+              io.grpc.testing.protobuf.SimpleResponse>(
+                service, METHODID_BIDI_STREAMING_RPC)))
+        .build();
+  }
+
+  private static abstract class SimpleServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    SimpleServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.grpc.testing.protobuf.SimpleServiceProto.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("SimpleService");
+    }
+  }
+
+  private static final class SimpleServiceFileDescriptorSupplier
+      extends SimpleServiceBaseDescriptorSupplier {
+    SimpleServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class SimpleServiceMethodDescriptorSupplier
+      extends SimpleServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    SimpleServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (SimpleServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new SimpleServiceFileDescriptorSupplier())
+              .addMethod(getUnaryRpcMethod())
+              .addMethod(getClientStreamingRpcMethod())
+              .addMethod(getServerStreamingRpcMethod())
+              .addMethod(getBidiStreamingRpcMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/testing-proto/src/generated/main/java/com/google/protobuf/EmptyProtos.java b/testing-proto/src/generated/main/java/com/google/protobuf/EmptyProtos.java
deleted file mode 100644
index 7dfb2a2620f..00000000000
--- a/testing-proto/src/generated/main/java/com/google/protobuf/EmptyProtos.java
+++ /dev/null
@@ -1,447 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/testing/integration/empty.proto
-
-package com.google.protobuf;
-
-public final class EmptyProtos {
-  private EmptyProtos() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  public interface EmptyOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.Empty)
-      com.google.protobuf.MessageOrBuilder {
-  }
-  /**
-   * <pre>
-   * An empty message that you can re-use to avoid defining duplicated empty
-   * messages in your project. A typical example is to use it as argument or the
-   * return value of a service API. For instance:
-   *   service Foo {
-   *     rpc Bar (grpc.testing.Empty) returns (grpc.testing.Empty) { };
-   *   };
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.Empty}
-   */
-  public  static final class Empty extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.Empty)
-      EmptyOrBuilder {
-    // Use Empty.newBuilder() to construct.
-    private Empty(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private Empty() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return this.unknownFields;
-    }
-    private Empty(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      com.google.protobuf.UnknownFieldSet.Builder unknownFields =
-          com.google.protobuf.UnknownFieldSet.newBuilder();
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!parseUnknownField(input, unknownFields,
-                                     extensionRegistry, tag)) {
-                done = true;
-              }
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        this.unknownFields = unknownFields.build();
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return com.google.protobuf.EmptyProtos.internal_static_grpc_testing_Empty_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return com.google.protobuf.EmptyProtos.internal_static_grpc_testing_Empty_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              com.google.protobuf.EmptyProtos.Empty.class, com.google.protobuf.EmptyProtos.Empty.Builder.class);
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      unknownFields.writeTo(output);
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      size += unknownFields.getSerializedSize();
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof com.google.protobuf.EmptyProtos.Empty)) {
-        return super.equals(obj);
-      }
-      com.google.protobuf.EmptyProtos.Empty other = (com.google.protobuf.EmptyProtos.Empty) obj;
-
-      boolean result = true;
-      result = result && unknownFields.equals(other.unknownFields);
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static com.google.protobuf.EmptyProtos.Empty parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static com.google.protobuf.EmptyProtos.Empty parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static com.google.protobuf.EmptyProtos.Empty parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static com.google.protobuf.EmptyProtos.Empty parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static com.google.protobuf.EmptyProtos.Empty parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static com.google.protobuf.EmptyProtos.Empty parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static com.google.protobuf.EmptyProtos.Empty parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static com.google.protobuf.EmptyProtos.Empty parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static com.google.protobuf.EmptyProtos.Empty parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static com.google.protobuf.EmptyProtos.Empty parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(com.google.protobuf.EmptyProtos.Empty prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * An empty message that you can re-use to avoid defining duplicated empty
-     * messages in your project. A typical example is to use it as argument or the
-     * return value of a service API. For instance:
-     *   service Foo {
-     *     rpc Bar (grpc.testing.Empty) returns (grpc.testing.Empty) { };
-     *   };
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.Empty}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.Empty)
-        com.google.protobuf.EmptyProtos.EmptyOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return com.google.protobuf.EmptyProtos.internal_static_grpc_testing_Empty_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return com.google.protobuf.EmptyProtos.internal_static_grpc_testing_Empty_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                com.google.protobuf.EmptyProtos.Empty.class, com.google.protobuf.EmptyProtos.Empty.Builder.class);
-      }
-
-      // Construct using com.google.protobuf.EmptyProtos.Empty.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return com.google.protobuf.EmptyProtos.internal_static_grpc_testing_Empty_descriptor;
-      }
-
-      public com.google.protobuf.EmptyProtos.Empty getDefaultInstanceForType() {
-        return com.google.protobuf.EmptyProtos.Empty.getDefaultInstance();
-      }
-
-      public com.google.protobuf.EmptyProtos.Empty build() {
-        com.google.protobuf.EmptyProtos.Empty result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public com.google.protobuf.EmptyProtos.Empty buildPartial() {
-        com.google.protobuf.EmptyProtos.Empty result = new com.google.protobuf.EmptyProtos.Empty(this);
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof com.google.protobuf.EmptyProtos.Empty) {
-          return mergeFrom((com.google.protobuf.EmptyProtos.Empty)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(com.google.protobuf.EmptyProtos.Empty other) {
-        if (other == com.google.protobuf.EmptyProtos.Empty.getDefaultInstance()) return this;
-        this.mergeUnknownFields(other.unknownFields);
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        com.google.protobuf.EmptyProtos.Empty parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (com.google.protobuf.EmptyProtos.Empty) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return super.setUnknownFields(unknownFields);
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return super.mergeUnknownFields(unknownFields);
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.Empty)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.Empty)
-    private static final com.google.protobuf.EmptyProtos.Empty DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new com.google.protobuf.EmptyProtos.Empty();
-    }
-
-    public static com.google.protobuf.EmptyProtos.Empty getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    @java.lang.Deprecated public static final com.google.protobuf.Parser<Empty>
-        PARSER = new com.google.protobuf.AbstractParser<Empty>() {
-      public Empty parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new Empty(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<Empty> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<Empty> getParserForType() {
-      return PARSER;
-    }
-
-    public com.google.protobuf.EmptyProtos.Empty getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_Empty_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_Empty_fieldAccessorTable;
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n\'io/grpc/testing/integration/empty.prot" +
-      "o\022\014grpc.testing\"\007\n\005EmptyB\"\n\023com.google.p" +
-      "rotobufB\013EmptyProtos"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-        }, assigner);
-    internal_static_grpc_testing_Empty_descriptor =
-      getDescriptor().getMessageTypes().get(0);
-    internal_static_grpc_testing_Empty_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_Empty_descriptor,
-        new java.lang.String[] { });
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/testing-proto/src/generated/main/java/io/grpc/testing/integration/Messages.java b/testing-proto/src/generated/main/java/io/grpc/testing/integration/Messages.java
deleted file mode 100644
index 4bb4ae58018..00000000000
--- a/testing-proto/src/generated/main/java/io/grpc/testing/integration/Messages.java
+++ /dev/null
@@ -1,9487 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/testing/integration/messages.proto
-
-package io.grpc.testing.integration;
-
-public final class Messages {
-  private Messages() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  /**
-   * <pre>
-   * The type of payload that should be returned.
-   * </pre>
-   *
-   * Protobuf enum {@code grpc.testing.PayloadType}
-   */
-  public enum PayloadType
-      implements com.google.protobuf.ProtocolMessageEnum {
-    /**
-     * <pre>
-     * Compressable text format.
-     * </pre>
-     *
-     * <code>COMPRESSABLE = 0;</code>
-     */
-    COMPRESSABLE(0),
-    /**
-     * <pre>
-     * Uncompressable binary format.
-     * </pre>
-     *
-     * <code>UNCOMPRESSABLE = 1;</code>
-     */
-    UNCOMPRESSABLE(1),
-    /**
-     * <pre>
-     * Randomly chosen from all other formats defined in this enum.
-     * </pre>
-     *
-     * <code>RANDOM = 2;</code>
-     */
-    RANDOM(2),
-    UNRECOGNIZED(-1),
-    ;
-
-    /**
-     * <pre>
-     * Compressable text format.
-     * </pre>
-     *
-     * <code>COMPRESSABLE = 0;</code>
-     */
-    public static final int COMPRESSABLE_VALUE = 0;
-    /**
-     * <pre>
-     * Uncompressable binary format.
-     * </pre>
-     *
-     * <code>UNCOMPRESSABLE = 1;</code>
-     */
-    public static final int UNCOMPRESSABLE_VALUE = 1;
-    /**
-     * <pre>
-     * Randomly chosen from all other formats defined in this enum.
-     * </pre>
-     *
-     * <code>RANDOM = 2;</code>
-     */
-    public static final int RANDOM_VALUE = 2;
-
-
-    public final int getNumber() {
-      if (this == UNRECOGNIZED) {
-        throw new java.lang.IllegalArgumentException(
-            "Can't get the number of an unknown enum value.");
-      }
-      return value;
-    }
-
-    /**
-     * @deprecated Use {@link #forNumber(int)} instead.
-     */
-    @java.lang.Deprecated
-    public static PayloadType valueOf(int value) {
-      return forNumber(value);
-    }
-
-    public static PayloadType forNumber(int value) {
-      switch (value) {
-        case 0: return COMPRESSABLE;
-        case 1: return UNCOMPRESSABLE;
-        case 2: return RANDOM;
-        default: return null;
-      }
-    }
-
-    public static com.google.protobuf.Internal.EnumLiteMap<PayloadType>
-        internalGetValueMap() {
-      return internalValueMap;
-    }
-    private static final com.google.protobuf.Internal.EnumLiteMap<
-        PayloadType> internalValueMap =
-          new com.google.protobuf.Internal.EnumLiteMap<PayloadType>() {
-            public PayloadType findValueByNumber(int number) {
-              return PayloadType.forNumber(number);
-            }
-          };
-
-    public final com.google.protobuf.Descriptors.EnumValueDescriptor
-        getValueDescriptor() {
-      return getDescriptor().getValues().get(ordinal());
-    }
-    public final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptorForType() {
-      return getDescriptor();
-    }
-    public static final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.getDescriptor().getEnumTypes().get(0);
-    }
-
-    private static final PayloadType[] VALUES = values();
-
-    public static PayloadType valueOf(
-        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
-      if (desc.getType() != getDescriptor()) {
-        throw new java.lang.IllegalArgumentException(
-          "EnumValueDescriptor is not for this type.");
-      }
-      if (desc.getIndex() == -1) {
-        return UNRECOGNIZED;
-      }
-      return VALUES[desc.getIndex()];
-    }
-
-    private final int value;
-
-    private PayloadType(int value) {
-      this.value = value;
-    }
-
-    // @@protoc_insertion_point(enum_scope:grpc.testing.PayloadType)
-  }
-
-  /**
-   * <pre>
-   * Compression algorithms
-   * </pre>
-   *
-   * Protobuf enum {@code grpc.testing.CompressionType}
-   */
-  public enum CompressionType
-      implements com.google.protobuf.ProtocolMessageEnum {
-    /**
-     * <pre>
-     * No compression
-     * </pre>
-     *
-     * <code>NONE = 0;</code>
-     */
-    NONE(0),
-    /**
-     * <code>GZIP = 1;</code>
-     */
-    GZIP(1),
-    /**
-     * <code>DEFLATE = 2;</code>
-     */
-    DEFLATE(2),
-    UNRECOGNIZED(-1),
-    ;
-
-    /**
-     * <pre>
-     * No compression
-     * </pre>
-     *
-     * <code>NONE = 0;</code>
-     */
-    public static final int NONE_VALUE = 0;
-    /**
-     * <code>GZIP = 1;</code>
-     */
-    public static final int GZIP_VALUE = 1;
-    /**
-     * <code>DEFLATE = 2;</code>
-     */
-    public static final int DEFLATE_VALUE = 2;
-
-
-    public final int getNumber() {
-      if (this == UNRECOGNIZED) {
-        throw new java.lang.IllegalArgumentException(
-            "Can't get the number of an unknown enum value.");
-      }
-      return value;
-    }
-
-    /**
-     * @deprecated Use {@link #forNumber(int)} instead.
-     */
-    @java.lang.Deprecated
-    public static CompressionType valueOf(int value) {
-      return forNumber(value);
-    }
-
-    public static CompressionType forNumber(int value) {
-      switch (value) {
-        case 0: return NONE;
-        case 1: return GZIP;
-        case 2: return DEFLATE;
-        default: return null;
-      }
-    }
-
-    public static com.google.protobuf.Internal.EnumLiteMap<CompressionType>
-        internalGetValueMap() {
-      return internalValueMap;
-    }
-    private static final com.google.protobuf.Internal.EnumLiteMap<
-        CompressionType> internalValueMap =
-          new com.google.protobuf.Internal.EnumLiteMap<CompressionType>() {
-            public CompressionType findValueByNumber(int number) {
-              return CompressionType.forNumber(number);
-            }
-          };
-
-    public final com.google.protobuf.Descriptors.EnumValueDescriptor
-        getValueDescriptor() {
-      return getDescriptor().getValues().get(ordinal());
-    }
-    public final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptorForType() {
-      return getDescriptor();
-    }
-    public static final com.google.protobuf.Descriptors.EnumDescriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.getDescriptor().getEnumTypes().get(1);
-    }
-
-    private static final CompressionType[] VALUES = values();
-
-    public static CompressionType valueOf(
-        com.google.protobuf.Descriptors.EnumValueDescriptor desc) {
-      if (desc.getType() != getDescriptor()) {
-        throw new java.lang.IllegalArgumentException(
-          "EnumValueDescriptor is not for this type.");
-      }
-      if (desc.getIndex() == -1) {
-        return UNRECOGNIZED;
-      }
-      return VALUES[desc.getIndex()];
-    }
-
-    private final int value;
-
-    private CompressionType(int value) {
-      this.value = value;
-    }
-
-    // @@protoc_insertion_point(enum_scope:grpc.testing.CompressionType)
-  }
-
-  public interface PayloadOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.Payload)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * The type of data in body.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType type = 1;</code>
-     */
-    int getTypeValue();
-    /**
-     * <pre>
-     * The type of data in body.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType type = 1;</code>
-     */
-    io.grpc.testing.integration.Messages.PayloadType getType();
-
-    /**
-     * <pre>
-     * Primary contents of payload.
-     * </pre>
-     *
-     * <code>bytes body = 2;</code>
-     */
-    com.google.protobuf.ByteString getBody();
-  }
-  /**
-   * <pre>
-   * A block of data, to simply increase gRPC message size.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.Payload}
-   */
-  public  static final class Payload extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.Payload)
-      PayloadOrBuilder {
-    // Use Payload.newBuilder() to construct.
-    private Payload(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private Payload() {
-      type_ = 0;
-      body_ = com.google.protobuf.ByteString.EMPTY;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private Payload(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-              int rawValue = input.readEnum();
-
-              type_ = rawValue;
-              break;
-            }
-            case 18: {
-
-              body_ = input.readBytes();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_Payload_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_Payload_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Messages.Payload.class, io.grpc.testing.integration.Messages.Payload.Builder.class);
-    }
-
-    public static final int TYPE_FIELD_NUMBER = 1;
-    private int type_;
-    /**
-     * <pre>
-     * The type of data in body.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType type = 1;</code>
-     */
-    public int getTypeValue() {
-      return type_;
-    }
-    /**
-     * <pre>
-     * The type of data in body.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType type = 1;</code>
-     */
-    public io.grpc.testing.integration.Messages.PayloadType getType() {
-      io.grpc.testing.integration.Messages.PayloadType result = io.grpc.testing.integration.Messages.PayloadType.valueOf(type_);
-      return result == null ? io.grpc.testing.integration.Messages.PayloadType.UNRECOGNIZED : result;
-    }
-
-    public static final int BODY_FIELD_NUMBER = 2;
-    private com.google.protobuf.ByteString body_;
-    /**
-     * <pre>
-     * Primary contents of payload.
-     * </pre>
-     *
-     * <code>bytes body = 2;</code>
-     */
-    public com.google.protobuf.ByteString getBody() {
-      return body_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (type_ != io.grpc.testing.integration.Messages.PayloadType.COMPRESSABLE.getNumber()) {
-        output.writeEnum(1, type_);
-      }
-      if (!body_.isEmpty()) {
-        output.writeBytes(2, body_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (type_ != io.grpc.testing.integration.Messages.PayloadType.COMPRESSABLE.getNumber()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeEnumSize(1, type_);
-      }
-      if (!body_.isEmpty()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeBytesSize(2, body_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Messages.Payload)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Messages.Payload other = (io.grpc.testing.integration.Messages.Payload) obj;
-
-      boolean result = true;
-      result = result && type_ == other.type_;
-      result = result && getBody()
-          .equals(other.getBody());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + TYPE_FIELD_NUMBER;
-      hash = (53 * hash) + type_;
-      hash = (37 * hash) + BODY_FIELD_NUMBER;
-      hash = (53 * hash) + getBody().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Messages.Payload parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.Payload parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.Payload parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.Payload parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.Payload parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.Payload parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.Payload parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.Payload parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.Payload parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.Payload parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Messages.Payload prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * A block of data, to simply increase gRPC message size.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.Payload}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.Payload)
-        io.grpc.testing.integration.Messages.PayloadOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_Payload_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_Payload_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Messages.Payload.class, io.grpc.testing.integration.Messages.Payload.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Messages.Payload.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        type_ = 0;
-
-        body_ = com.google.protobuf.ByteString.EMPTY;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_Payload_descriptor;
-      }
-
-      public io.grpc.testing.integration.Messages.Payload getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Messages.Payload.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Messages.Payload build() {
-        io.grpc.testing.integration.Messages.Payload result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Messages.Payload buildPartial() {
-        io.grpc.testing.integration.Messages.Payload result = new io.grpc.testing.integration.Messages.Payload(this);
-        result.type_ = type_;
-        result.body_ = body_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Messages.Payload) {
-          return mergeFrom((io.grpc.testing.integration.Messages.Payload)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Messages.Payload other) {
-        if (other == io.grpc.testing.integration.Messages.Payload.getDefaultInstance()) return this;
-        if (other.type_ != 0) {
-          setTypeValue(other.getTypeValue());
-        }
-        if (other.getBody() != com.google.protobuf.ByteString.EMPTY) {
-          setBody(other.getBody());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Messages.Payload parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Messages.Payload) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int type_ = 0;
-      /**
-       * <pre>
-       * The type of data in body.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType type = 1;</code>
-       */
-      public int getTypeValue() {
-        return type_;
-      }
-      /**
-       * <pre>
-       * The type of data in body.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType type = 1;</code>
-       */
-      public Builder setTypeValue(int value) {
-        type_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * The type of data in body.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType type = 1;</code>
-       */
-      public io.grpc.testing.integration.Messages.PayloadType getType() {
-        io.grpc.testing.integration.Messages.PayloadType result = io.grpc.testing.integration.Messages.PayloadType.valueOf(type_);
-        return result == null ? io.grpc.testing.integration.Messages.PayloadType.UNRECOGNIZED : result;
-      }
-      /**
-       * <pre>
-       * The type of data in body.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType type = 1;</code>
-       */
-      public Builder setType(io.grpc.testing.integration.Messages.PayloadType value) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        
-        type_ = value.getNumber();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * The type of data in body.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType type = 1;</code>
-       */
-      public Builder clearType() {
-        
-        type_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private com.google.protobuf.ByteString body_ = com.google.protobuf.ByteString.EMPTY;
-      /**
-       * <pre>
-       * Primary contents of payload.
-       * </pre>
-       *
-       * <code>bytes body = 2;</code>
-       */
-      public com.google.protobuf.ByteString getBody() {
-        return body_;
-      }
-      /**
-       * <pre>
-       * Primary contents of payload.
-       * </pre>
-       *
-       * <code>bytes body = 2;</code>
-       */
-      public Builder setBody(com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  
-        body_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Primary contents of payload.
-       * </pre>
-       *
-       * <code>bytes body = 2;</code>
-       */
-      public Builder clearBody() {
-        
-        body_ = getDefaultInstance().getBody();
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.Payload)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.Payload)
-    private static final io.grpc.testing.integration.Messages.Payload DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Messages.Payload();
-    }
-
-    public static io.grpc.testing.integration.Messages.Payload getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<Payload>
-        PARSER = new com.google.protobuf.AbstractParser<Payload>() {
-      public Payload parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new Payload(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<Payload> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<Payload> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Messages.Payload getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface EchoStatusOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.EchoStatus)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>int32 code = 1;</code>
-     */
-    int getCode();
-
-    /**
-     * <code>string message = 2;</code>
-     */
-    java.lang.String getMessage();
-    /**
-     * <code>string message = 2;</code>
-     */
-    com.google.protobuf.ByteString
-        getMessageBytes();
-  }
-  /**
-   * <pre>
-   * A protobuf representation for grpc status. This is used by test
-   * clients to specify a status that the server should attempt to return.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.EchoStatus}
-   */
-  public  static final class EchoStatus extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.EchoStatus)
-      EchoStatusOrBuilder {
-    // Use EchoStatus.newBuilder() to construct.
-    private EchoStatus(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private EchoStatus() {
-      code_ = 0;
-      message_ = "";
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private EchoStatus(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              code_ = input.readInt32();
-              break;
-            }
-            case 18: {
-              java.lang.String s = input.readStringRequireUtf8();
-
-              message_ = s;
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_EchoStatus_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_EchoStatus_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Messages.EchoStatus.class, io.grpc.testing.integration.Messages.EchoStatus.Builder.class);
-    }
-
-    public static final int CODE_FIELD_NUMBER = 1;
-    private int code_;
-    /**
-     * <code>int32 code = 1;</code>
-     */
-    public int getCode() {
-      return code_;
-    }
-
-    public static final int MESSAGE_FIELD_NUMBER = 2;
-    private volatile java.lang.Object message_;
-    /**
-     * <code>string message = 2;</code>
-     */
-    public java.lang.String getMessage() {
-      java.lang.Object ref = message_;
-      if (ref instanceof java.lang.String) {
-        return (java.lang.String) ref;
-      } else {
-        com.google.protobuf.ByteString bs = 
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        message_ = s;
-        return s;
-      }
-    }
-    /**
-     * <code>string message = 2;</code>
-     */
-    public com.google.protobuf.ByteString
-        getMessageBytes() {
-      java.lang.Object ref = message_;
-      if (ref instanceof java.lang.String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        message_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (code_ != 0) {
-        output.writeInt32(1, code_);
-      }
-      if (!getMessageBytes().isEmpty()) {
-        com.google.protobuf.GeneratedMessageV3.writeString(output, 2, message_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (code_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(1, code_);
-      }
-      if (!getMessageBytes().isEmpty()) {
-        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, message_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Messages.EchoStatus)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Messages.EchoStatus other = (io.grpc.testing.integration.Messages.EchoStatus) obj;
-
-      boolean result = true;
-      result = result && (getCode()
-          == other.getCode());
-      result = result && getMessage()
-          .equals(other.getMessage());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + CODE_FIELD_NUMBER;
-      hash = (53 * hash) + getCode();
-      hash = (37 * hash) + MESSAGE_FIELD_NUMBER;
-      hash = (53 * hash) + getMessage().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Messages.EchoStatus parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.EchoStatus parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.EchoStatus parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.EchoStatus parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.EchoStatus parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.EchoStatus parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.EchoStatus parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.EchoStatus parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.EchoStatus parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.EchoStatus parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Messages.EchoStatus prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * A protobuf representation for grpc status. This is used by test
-     * clients to specify a status that the server should attempt to return.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.EchoStatus}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.EchoStatus)
-        io.grpc.testing.integration.Messages.EchoStatusOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_EchoStatus_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_EchoStatus_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Messages.EchoStatus.class, io.grpc.testing.integration.Messages.EchoStatus.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Messages.EchoStatus.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        code_ = 0;
-
-        message_ = "";
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_EchoStatus_descriptor;
-      }
-
-      public io.grpc.testing.integration.Messages.EchoStatus getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Messages.EchoStatus.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Messages.EchoStatus build() {
-        io.grpc.testing.integration.Messages.EchoStatus result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Messages.EchoStatus buildPartial() {
-        io.grpc.testing.integration.Messages.EchoStatus result = new io.grpc.testing.integration.Messages.EchoStatus(this);
-        result.code_ = code_;
-        result.message_ = message_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Messages.EchoStatus) {
-          return mergeFrom((io.grpc.testing.integration.Messages.EchoStatus)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Messages.EchoStatus other) {
-        if (other == io.grpc.testing.integration.Messages.EchoStatus.getDefaultInstance()) return this;
-        if (other.getCode() != 0) {
-          setCode(other.getCode());
-        }
-        if (!other.getMessage().isEmpty()) {
-          message_ = other.message_;
-          onChanged();
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Messages.EchoStatus parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Messages.EchoStatus) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int code_ ;
-      /**
-       * <code>int32 code = 1;</code>
-       */
-      public int getCode() {
-        return code_;
-      }
-      /**
-       * <code>int32 code = 1;</code>
-       */
-      public Builder setCode(int value) {
-        
-        code_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>int32 code = 1;</code>
-       */
-      public Builder clearCode() {
-        
-        code_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private java.lang.Object message_ = "";
-      /**
-       * <code>string message = 2;</code>
-       */
-      public java.lang.String getMessage() {
-        java.lang.Object ref = message_;
-        if (!(ref instanceof java.lang.String)) {
-          com.google.protobuf.ByteString bs =
-              (com.google.protobuf.ByteString) ref;
-          java.lang.String s = bs.toStringUtf8();
-          message_ = s;
-          return s;
-        } else {
-          return (java.lang.String) ref;
-        }
-      }
-      /**
-       * <code>string message = 2;</code>
-       */
-      public com.google.protobuf.ByteString
-          getMessageBytes() {
-        java.lang.Object ref = message_;
-        if (ref instanceof String) {
-          com.google.protobuf.ByteString b = 
-              com.google.protobuf.ByteString.copyFromUtf8(
-                  (java.lang.String) ref);
-          message_ = b;
-          return b;
-        } else {
-          return (com.google.protobuf.ByteString) ref;
-        }
-      }
-      /**
-       * <code>string message = 2;</code>
-       */
-      public Builder setMessage(
-          java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  
-        message_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>string message = 2;</code>
-       */
-      public Builder clearMessage() {
-        
-        message_ = getDefaultInstance().getMessage();
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>string message = 2;</code>
-       */
-      public Builder setMessageBytes(
-          com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-        
-        message_ = value;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.EchoStatus)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.EchoStatus)
-    private static final io.grpc.testing.integration.Messages.EchoStatus DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Messages.EchoStatus();
-    }
-
-    public static io.grpc.testing.integration.Messages.EchoStatus getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<EchoStatus>
-        PARSER = new com.google.protobuf.AbstractParser<EchoStatus>() {
-      public EchoStatus parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new EchoStatus(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<EchoStatus> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<EchoStatus> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Messages.EchoStatus getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface SimpleRequestOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.SimpleRequest)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, server randomly chooses one from other formats.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    int getResponseTypeValue();
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, server randomly chooses one from other formats.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    io.grpc.testing.integration.Messages.PayloadType getResponseType();
-
-    /**
-     * <pre>
-     * Desired payload size in the response from the server.
-     * If response_type is COMPRESSABLE, this denotes the size before compression.
-     * </pre>
-     *
-     * <code>int32 response_size = 2;</code>
-     */
-    int getResponseSize();
-
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    boolean hasPayload();
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    io.grpc.testing.integration.Messages.Payload getPayload();
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder();
-
-    /**
-     * <pre>
-     * Whether SimpleResponse should include username.
-     * </pre>
-     *
-     * <code>bool fill_username = 4;</code>
-     */
-    boolean getFillUsername();
-
-    /**
-     * <pre>
-     * Whether SimpleResponse should include OAuth scope.
-     * </pre>
-     *
-     * <code>bool fill_oauth_scope = 5;</code>
-     */
-    boolean getFillOauthScope();
-
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    int getResponseCompressionValue();
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    io.grpc.testing.integration.Messages.CompressionType getResponseCompression();
-
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    boolean hasResponseStatus();
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    io.grpc.testing.integration.Messages.EchoStatus getResponseStatus();
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    io.grpc.testing.integration.Messages.EchoStatusOrBuilder getResponseStatusOrBuilder();
-  }
-  /**
-   * <pre>
-   * Unary request.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.SimpleRequest}
-   */
-  public  static final class SimpleRequest extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.SimpleRequest)
-      SimpleRequestOrBuilder {
-    // Use SimpleRequest.newBuilder() to construct.
-    private SimpleRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private SimpleRequest() {
-      responseType_ = 0;
-      responseSize_ = 0;
-      fillUsername_ = false;
-      fillOauthScope_ = false;
-      responseCompression_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private SimpleRequest(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-              int rawValue = input.readEnum();
-
-              responseType_ = rawValue;
-              break;
-            }
-            case 16: {
-
-              responseSize_ = input.readInt32();
-              break;
-            }
-            case 26: {
-              io.grpc.testing.integration.Messages.Payload.Builder subBuilder = null;
-              if (payload_ != null) {
-                subBuilder = payload_.toBuilder();
-              }
-              payload_ = input.readMessage(io.grpc.testing.integration.Messages.Payload.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(payload_);
-                payload_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 32: {
-
-              fillUsername_ = input.readBool();
-              break;
-            }
-            case 40: {
-
-              fillOauthScope_ = input.readBool();
-              break;
-            }
-            case 48: {
-              int rawValue = input.readEnum();
-
-              responseCompression_ = rawValue;
-              break;
-            }
-            case 58: {
-              io.grpc.testing.integration.Messages.EchoStatus.Builder subBuilder = null;
-              if (responseStatus_ != null) {
-                subBuilder = responseStatus_.toBuilder();
-              }
-              responseStatus_ = input.readMessage(io.grpc.testing.integration.Messages.EchoStatus.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(responseStatus_);
-                responseStatus_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Messages.SimpleRequest.class, io.grpc.testing.integration.Messages.SimpleRequest.Builder.class);
-    }
-
-    public static final int RESPONSE_TYPE_FIELD_NUMBER = 1;
-    private int responseType_;
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, server randomly chooses one from other formats.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    public int getResponseTypeValue() {
-      return responseType_;
-    }
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, server randomly chooses one from other formats.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    public io.grpc.testing.integration.Messages.PayloadType getResponseType() {
-      io.grpc.testing.integration.Messages.PayloadType result = io.grpc.testing.integration.Messages.PayloadType.valueOf(responseType_);
-      return result == null ? io.grpc.testing.integration.Messages.PayloadType.UNRECOGNIZED : result;
-    }
-
-    public static final int RESPONSE_SIZE_FIELD_NUMBER = 2;
-    private int responseSize_;
-    /**
-     * <pre>
-     * Desired payload size in the response from the server.
-     * If response_type is COMPRESSABLE, this denotes the size before compression.
-     * </pre>
-     *
-     * <code>int32 response_size = 2;</code>
-     */
-    public int getResponseSize() {
-      return responseSize_;
-    }
-
-    public static final int PAYLOAD_FIELD_NUMBER = 3;
-    private io.grpc.testing.integration.Messages.Payload payload_;
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    public boolean hasPayload() {
-      return payload_ != null;
-    }
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    public io.grpc.testing.integration.Messages.Payload getPayload() {
-      return payload_ == null ? io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-    }
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    public io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-      return getPayload();
-    }
-
-    public static final int FILL_USERNAME_FIELD_NUMBER = 4;
-    private boolean fillUsername_;
-    /**
-     * <pre>
-     * Whether SimpleResponse should include username.
-     * </pre>
-     *
-     * <code>bool fill_username = 4;</code>
-     */
-    public boolean getFillUsername() {
-      return fillUsername_;
-    }
-
-    public static final int FILL_OAUTH_SCOPE_FIELD_NUMBER = 5;
-    private boolean fillOauthScope_;
-    /**
-     * <pre>
-     * Whether SimpleResponse should include OAuth scope.
-     * </pre>
-     *
-     * <code>bool fill_oauth_scope = 5;</code>
-     */
-    public boolean getFillOauthScope() {
-      return fillOauthScope_;
-    }
-
-    public static final int RESPONSE_COMPRESSION_FIELD_NUMBER = 6;
-    private int responseCompression_;
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    public int getResponseCompressionValue() {
-      return responseCompression_;
-    }
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    public io.grpc.testing.integration.Messages.CompressionType getResponseCompression() {
-      io.grpc.testing.integration.Messages.CompressionType result = io.grpc.testing.integration.Messages.CompressionType.valueOf(responseCompression_);
-      return result == null ? io.grpc.testing.integration.Messages.CompressionType.UNRECOGNIZED : result;
-    }
-
-    public static final int RESPONSE_STATUS_FIELD_NUMBER = 7;
-    private io.grpc.testing.integration.Messages.EchoStatus responseStatus_;
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    public boolean hasResponseStatus() {
-      return responseStatus_ != null;
-    }
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    public io.grpc.testing.integration.Messages.EchoStatus getResponseStatus() {
-      return responseStatus_ == null ? io.grpc.testing.integration.Messages.EchoStatus.getDefaultInstance() : responseStatus_;
-    }
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    public io.grpc.testing.integration.Messages.EchoStatusOrBuilder getResponseStatusOrBuilder() {
-      return getResponseStatus();
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (responseType_ != io.grpc.testing.integration.Messages.PayloadType.COMPRESSABLE.getNumber()) {
-        output.writeEnum(1, responseType_);
-      }
-      if (responseSize_ != 0) {
-        output.writeInt32(2, responseSize_);
-      }
-      if (payload_ != null) {
-        output.writeMessage(3, getPayload());
-      }
-      if (fillUsername_ != false) {
-        output.writeBool(4, fillUsername_);
-      }
-      if (fillOauthScope_ != false) {
-        output.writeBool(5, fillOauthScope_);
-      }
-      if (responseCompression_ != io.grpc.testing.integration.Messages.CompressionType.NONE.getNumber()) {
-        output.writeEnum(6, responseCompression_);
-      }
-      if (responseStatus_ != null) {
-        output.writeMessage(7, getResponseStatus());
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (responseType_ != io.grpc.testing.integration.Messages.PayloadType.COMPRESSABLE.getNumber()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeEnumSize(1, responseType_);
-      }
-      if (responseSize_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(2, responseSize_);
-      }
-      if (payload_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(3, getPayload());
-      }
-      if (fillUsername_ != false) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeBoolSize(4, fillUsername_);
-      }
-      if (fillOauthScope_ != false) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeBoolSize(5, fillOauthScope_);
-      }
-      if (responseCompression_ != io.grpc.testing.integration.Messages.CompressionType.NONE.getNumber()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeEnumSize(6, responseCompression_);
-      }
-      if (responseStatus_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(7, getResponseStatus());
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Messages.SimpleRequest)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Messages.SimpleRequest other = (io.grpc.testing.integration.Messages.SimpleRequest) obj;
-
-      boolean result = true;
-      result = result && responseType_ == other.responseType_;
-      result = result && (getResponseSize()
-          == other.getResponseSize());
-      result = result && (hasPayload() == other.hasPayload());
-      if (hasPayload()) {
-        result = result && getPayload()
-            .equals(other.getPayload());
-      }
-      result = result && (getFillUsername()
-          == other.getFillUsername());
-      result = result && (getFillOauthScope()
-          == other.getFillOauthScope());
-      result = result && responseCompression_ == other.responseCompression_;
-      result = result && (hasResponseStatus() == other.hasResponseStatus());
-      if (hasResponseStatus()) {
-        result = result && getResponseStatus()
-            .equals(other.getResponseStatus());
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + RESPONSE_TYPE_FIELD_NUMBER;
-      hash = (53 * hash) + responseType_;
-      hash = (37 * hash) + RESPONSE_SIZE_FIELD_NUMBER;
-      hash = (53 * hash) + getResponseSize();
-      if (hasPayload()) {
-        hash = (37 * hash) + PAYLOAD_FIELD_NUMBER;
-        hash = (53 * hash) + getPayload().hashCode();
-      }
-      hash = (37 * hash) + FILL_USERNAME_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
-          getFillUsername());
-      hash = (37 * hash) + FILL_OAUTH_SCOPE_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
-          getFillOauthScope());
-      hash = (37 * hash) + RESPONSE_COMPRESSION_FIELD_NUMBER;
-      hash = (53 * hash) + responseCompression_;
-      if (hasResponseStatus()) {
-        hash = (37 * hash) + RESPONSE_STATUS_FIELD_NUMBER;
-        hash = (53 * hash) + getResponseStatus().hashCode();
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Messages.SimpleRequest parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleRequest parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleRequest parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleRequest parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleRequest parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleRequest parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleRequest parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleRequest parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleRequest parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleRequest parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Messages.SimpleRequest prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Unary request.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.SimpleRequest}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.SimpleRequest)
-        io.grpc.testing.integration.Messages.SimpleRequestOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleRequest_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleRequest_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Messages.SimpleRequest.class, io.grpc.testing.integration.Messages.SimpleRequest.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Messages.SimpleRequest.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        responseType_ = 0;
-
-        responseSize_ = 0;
-
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-        fillUsername_ = false;
-
-        fillOauthScope_ = false;
-
-        responseCompression_ = 0;
-
-        if (responseStatusBuilder_ == null) {
-          responseStatus_ = null;
-        } else {
-          responseStatus_ = null;
-          responseStatusBuilder_ = null;
-        }
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleRequest_descriptor;
-      }
-
-      public io.grpc.testing.integration.Messages.SimpleRequest getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Messages.SimpleRequest.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Messages.SimpleRequest build() {
-        io.grpc.testing.integration.Messages.SimpleRequest result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Messages.SimpleRequest buildPartial() {
-        io.grpc.testing.integration.Messages.SimpleRequest result = new io.grpc.testing.integration.Messages.SimpleRequest(this);
-        result.responseType_ = responseType_;
-        result.responseSize_ = responseSize_;
-        if (payloadBuilder_ == null) {
-          result.payload_ = payload_;
-        } else {
-          result.payload_ = payloadBuilder_.build();
-        }
-        result.fillUsername_ = fillUsername_;
-        result.fillOauthScope_ = fillOauthScope_;
-        result.responseCompression_ = responseCompression_;
-        if (responseStatusBuilder_ == null) {
-          result.responseStatus_ = responseStatus_;
-        } else {
-          result.responseStatus_ = responseStatusBuilder_.build();
-        }
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Messages.SimpleRequest) {
-          return mergeFrom((io.grpc.testing.integration.Messages.SimpleRequest)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Messages.SimpleRequest other) {
-        if (other == io.grpc.testing.integration.Messages.SimpleRequest.getDefaultInstance()) return this;
-        if (other.responseType_ != 0) {
-          setResponseTypeValue(other.getResponseTypeValue());
-        }
-        if (other.getResponseSize() != 0) {
-          setResponseSize(other.getResponseSize());
-        }
-        if (other.hasPayload()) {
-          mergePayload(other.getPayload());
-        }
-        if (other.getFillUsername() != false) {
-          setFillUsername(other.getFillUsername());
-        }
-        if (other.getFillOauthScope() != false) {
-          setFillOauthScope(other.getFillOauthScope());
-        }
-        if (other.responseCompression_ != 0) {
-          setResponseCompressionValue(other.getResponseCompressionValue());
-        }
-        if (other.hasResponseStatus()) {
-          mergeResponseStatus(other.getResponseStatus());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Messages.SimpleRequest parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Messages.SimpleRequest) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int responseType_ = 0;
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, server randomly chooses one from other formats.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public int getResponseTypeValue() {
-        return responseType_;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, server randomly chooses one from other formats.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public Builder setResponseTypeValue(int value) {
-        responseType_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, server randomly chooses one from other formats.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public io.grpc.testing.integration.Messages.PayloadType getResponseType() {
-        io.grpc.testing.integration.Messages.PayloadType result = io.grpc.testing.integration.Messages.PayloadType.valueOf(responseType_);
-        return result == null ? io.grpc.testing.integration.Messages.PayloadType.UNRECOGNIZED : result;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, server randomly chooses one from other formats.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public Builder setResponseType(io.grpc.testing.integration.Messages.PayloadType value) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        
-        responseType_ = value.getNumber();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, server randomly chooses one from other formats.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public Builder clearResponseType() {
-        
-        responseType_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private int responseSize_ ;
-      /**
-       * <pre>
-       * Desired payload size in the response from the server.
-       * If response_type is COMPRESSABLE, this denotes the size before compression.
-       * </pre>
-       *
-       * <code>int32 response_size = 2;</code>
-       */
-      public int getResponseSize() {
-        return responseSize_;
-      }
-      /**
-       * <pre>
-       * Desired payload size in the response from the server.
-       * If response_type is COMPRESSABLE, this denotes the size before compression.
-       * </pre>
-       *
-       * <code>int32 response_size = 2;</code>
-       */
-      public Builder setResponseSize(int value) {
-        
-        responseSize_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired payload size in the response from the server.
-       * If response_type is COMPRESSABLE, this denotes the size before compression.
-       * </pre>
-       *
-       * <code>int32 response_size = 2;</code>
-       */
-      public Builder clearResponseSize() {
-        
-        responseSize_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private io.grpc.testing.integration.Messages.Payload payload_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder> payloadBuilder_;
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public boolean hasPayload() {
-        return payloadBuilder_ != null || payload_ != null;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public io.grpc.testing.integration.Messages.Payload getPayload() {
-        if (payloadBuilder_ == null) {
-          return payload_ == null ? io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-        } else {
-          return payloadBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder setPayload(io.grpc.testing.integration.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payload_ = value;
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder setPayload(
-          io.grpc.testing.integration.Messages.Payload.Builder builderForValue) {
-        if (payloadBuilder_ == null) {
-          payload_ = builderForValue.build();
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder mergePayload(io.grpc.testing.integration.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (payload_ != null) {
-            payload_ =
-              io.grpc.testing.integration.Messages.Payload.newBuilder(payload_).mergeFrom(value).buildPartial();
-          } else {
-            payload_ = value;
-          }
-          onChanged();
-        } else {
-          payloadBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder clearPayload() {
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-          onChanged();
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public io.grpc.testing.integration.Messages.Payload.Builder getPayloadBuilder() {
-        
-        onChanged();
-        return getPayloadFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-        if (payloadBuilder_ != null) {
-          return payloadBuilder_.getMessageOrBuilder();
-        } else {
-          return payload_ == null ?
-              io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-        }
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder> 
-          getPayloadFieldBuilder() {
-        if (payloadBuilder_ == null) {
-          payloadBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder>(
-                  getPayload(),
-                  getParentForChildren(),
-                  isClean());
-          payload_ = null;
-        }
-        return payloadBuilder_;
-      }
-
-      private boolean fillUsername_ ;
-      /**
-       * <pre>
-       * Whether SimpleResponse should include username.
-       * </pre>
-       *
-       * <code>bool fill_username = 4;</code>
-       */
-      public boolean getFillUsername() {
-        return fillUsername_;
-      }
-      /**
-       * <pre>
-       * Whether SimpleResponse should include username.
-       * </pre>
-       *
-       * <code>bool fill_username = 4;</code>
-       */
-      public Builder setFillUsername(boolean value) {
-        
-        fillUsername_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether SimpleResponse should include username.
-       * </pre>
-       *
-       * <code>bool fill_username = 4;</code>
-       */
-      public Builder clearFillUsername() {
-        
-        fillUsername_ = false;
-        onChanged();
-        return this;
-      }
-
-      private boolean fillOauthScope_ ;
-      /**
-       * <pre>
-       * Whether SimpleResponse should include OAuth scope.
-       * </pre>
-       *
-       * <code>bool fill_oauth_scope = 5;</code>
-       */
-      public boolean getFillOauthScope() {
-        return fillOauthScope_;
-      }
-      /**
-       * <pre>
-       * Whether SimpleResponse should include OAuth scope.
-       * </pre>
-       *
-       * <code>bool fill_oauth_scope = 5;</code>
-       */
-      public Builder setFillOauthScope(boolean value) {
-        
-        fillOauthScope_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether SimpleResponse should include OAuth scope.
-       * </pre>
-       *
-       * <code>bool fill_oauth_scope = 5;</code>
-       */
-      public Builder clearFillOauthScope() {
-        
-        fillOauthScope_ = false;
-        onChanged();
-        return this;
-      }
-
-      private int responseCompression_ = 0;
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public int getResponseCompressionValue() {
-        return responseCompression_;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public Builder setResponseCompressionValue(int value) {
-        responseCompression_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public io.grpc.testing.integration.Messages.CompressionType getResponseCompression() {
-        io.grpc.testing.integration.Messages.CompressionType result = io.grpc.testing.integration.Messages.CompressionType.valueOf(responseCompression_);
-        return result == null ? io.grpc.testing.integration.Messages.CompressionType.UNRECOGNIZED : result;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public Builder setResponseCompression(io.grpc.testing.integration.Messages.CompressionType value) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        
-        responseCompression_ = value.getNumber();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public Builder clearResponseCompression() {
-        
-        responseCompression_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private io.grpc.testing.integration.Messages.EchoStatus responseStatus_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.EchoStatus, io.grpc.testing.integration.Messages.EchoStatus.Builder, io.grpc.testing.integration.Messages.EchoStatusOrBuilder> responseStatusBuilder_;
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public boolean hasResponseStatus() {
-        return responseStatusBuilder_ != null || responseStatus_ != null;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public io.grpc.testing.integration.Messages.EchoStatus getResponseStatus() {
-        if (responseStatusBuilder_ == null) {
-          return responseStatus_ == null ? io.grpc.testing.integration.Messages.EchoStatus.getDefaultInstance() : responseStatus_;
-        } else {
-          return responseStatusBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder setResponseStatus(io.grpc.testing.integration.Messages.EchoStatus value) {
-        if (responseStatusBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          responseStatus_ = value;
-          onChanged();
-        } else {
-          responseStatusBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder setResponseStatus(
-          io.grpc.testing.integration.Messages.EchoStatus.Builder builderForValue) {
-        if (responseStatusBuilder_ == null) {
-          responseStatus_ = builderForValue.build();
-          onChanged();
-        } else {
-          responseStatusBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder mergeResponseStatus(io.grpc.testing.integration.Messages.EchoStatus value) {
-        if (responseStatusBuilder_ == null) {
-          if (responseStatus_ != null) {
-            responseStatus_ =
-              io.grpc.testing.integration.Messages.EchoStatus.newBuilder(responseStatus_).mergeFrom(value).buildPartial();
-          } else {
-            responseStatus_ = value;
-          }
-          onChanged();
-        } else {
-          responseStatusBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder clearResponseStatus() {
-        if (responseStatusBuilder_ == null) {
-          responseStatus_ = null;
-          onChanged();
-        } else {
-          responseStatus_ = null;
-          responseStatusBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public io.grpc.testing.integration.Messages.EchoStatus.Builder getResponseStatusBuilder() {
-        
-        onChanged();
-        return getResponseStatusFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public io.grpc.testing.integration.Messages.EchoStatusOrBuilder getResponseStatusOrBuilder() {
-        if (responseStatusBuilder_ != null) {
-          return responseStatusBuilder_.getMessageOrBuilder();
-        } else {
-          return responseStatus_ == null ?
-              io.grpc.testing.integration.Messages.EchoStatus.getDefaultInstance() : responseStatus_;
-        }
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.EchoStatus, io.grpc.testing.integration.Messages.EchoStatus.Builder, io.grpc.testing.integration.Messages.EchoStatusOrBuilder> 
-          getResponseStatusFieldBuilder() {
-        if (responseStatusBuilder_ == null) {
-          responseStatusBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.testing.integration.Messages.EchoStatus, io.grpc.testing.integration.Messages.EchoStatus.Builder, io.grpc.testing.integration.Messages.EchoStatusOrBuilder>(
-                  getResponseStatus(),
-                  getParentForChildren(),
-                  isClean());
-          responseStatus_ = null;
-        }
-        return responseStatusBuilder_;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.SimpleRequest)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.SimpleRequest)
-    private static final io.grpc.testing.integration.Messages.SimpleRequest DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Messages.SimpleRequest();
-    }
-
-    public static io.grpc.testing.integration.Messages.SimpleRequest getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<SimpleRequest>
-        PARSER = new com.google.protobuf.AbstractParser<SimpleRequest>() {
-      public SimpleRequest parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new SimpleRequest(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<SimpleRequest> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<SimpleRequest> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Messages.SimpleRequest getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface SimpleResponseOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.SimpleResponse)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Payload to increase message size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    boolean hasPayload();
-    /**
-     * <pre>
-     * Payload to increase message size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    io.grpc.testing.integration.Messages.Payload getPayload();
-    /**
-     * <pre>
-     * Payload to increase message size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder();
-
-    /**
-     * <pre>
-     * The user the request came from, for verifying authentication was
-     * successful when the client expected it.
-     * </pre>
-     *
-     * <code>string username = 2;</code>
-     */
-    java.lang.String getUsername();
-    /**
-     * <pre>
-     * The user the request came from, for verifying authentication was
-     * successful when the client expected it.
-     * </pre>
-     *
-     * <code>string username = 2;</code>
-     */
-    com.google.protobuf.ByteString
-        getUsernameBytes();
-
-    /**
-     * <pre>
-     * OAuth scope.
-     * </pre>
-     *
-     * <code>string oauth_scope = 3;</code>
-     */
-    java.lang.String getOauthScope();
-    /**
-     * <pre>
-     * OAuth scope.
-     * </pre>
-     *
-     * <code>string oauth_scope = 3;</code>
-     */
-    com.google.protobuf.ByteString
-        getOauthScopeBytes();
-  }
-  /**
-   * <pre>
-   * Unary response, as configured by the request.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.SimpleResponse}
-   */
-  public  static final class SimpleResponse extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.SimpleResponse)
-      SimpleResponseOrBuilder {
-    // Use SimpleResponse.newBuilder() to construct.
-    private SimpleResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private SimpleResponse() {
-      username_ = "";
-      oauthScope_ = "";
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private SimpleResponse(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              io.grpc.testing.integration.Messages.Payload.Builder subBuilder = null;
-              if (payload_ != null) {
-                subBuilder = payload_.toBuilder();
-              }
-              payload_ = input.readMessage(io.grpc.testing.integration.Messages.Payload.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(payload_);
-                payload_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 18: {
-              java.lang.String s = input.readStringRequireUtf8();
-
-              username_ = s;
-              break;
-            }
-            case 26: {
-              java.lang.String s = input.readStringRequireUtf8();
-
-              oauthScope_ = s;
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Messages.SimpleResponse.class, io.grpc.testing.integration.Messages.SimpleResponse.Builder.class);
-    }
-
-    public static final int PAYLOAD_FIELD_NUMBER = 1;
-    private io.grpc.testing.integration.Messages.Payload payload_;
-    /**
-     * <pre>
-     * Payload to increase message size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public boolean hasPayload() {
-      return payload_ != null;
-    }
-    /**
-     * <pre>
-     * Payload to increase message size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public io.grpc.testing.integration.Messages.Payload getPayload() {
-      return payload_ == null ? io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-    }
-    /**
-     * <pre>
-     * Payload to increase message size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-      return getPayload();
-    }
-
-    public static final int USERNAME_FIELD_NUMBER = 2;
-    private volatile java.lang.Object username_;
-    /**
-     * <pre>
-     * The user the request came from, for verifying authentication was
-     * successful when the client expected it.
-     * </pre>
-     *
-     * <code>string username = 2;</code>
-     */
-    public java.lang.String getUsername() {
-      java.lang.Object ref = username_;
-      if (ref instanceof java.lang.String) {
-        return (java.lang.String) ref;
-      } else {
-        com.google.protobuf.ByteString bs = 
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        username_ = s;
-        return s;
-      }
-    }
-    /**
-     * <pre>
-     * The user the request came from, for verifying authentication was
-     * successful when the client expected it.
-     * </pre>
-     *
-     * <code>string username = 2;</code>
-     */
-    public com.google.protobuf.ByteString
-        getUsernameBytes() {
-      java.lang.Object ref = username_;
-      if (ref instanceof java.lang.String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        username_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-
-    public static final int OAUTH_SCOPE_FIELD_NUMBER = 3;
-    private volatile java.lang.Object oauthScope_;
-    /**
-     * <pre>
-     * OAuth scope.
-     * </pre>
-     *
-     * <code>string oauth_scope = 3;</code>
-     */
-    public java.lang.String getOauthScope() {
-      java.lang.Object ref = oauthScope_;
-      if (ref instanceof java.lang.String) {
-        return (java.lang.String) ref;
-      } else {
-        com.google.protobuf.ByteString bs = 
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        oauthScope_ = s;
-        return s;
-      }
-    }
-    /**
-     * <pre>
-     * OAuth scope.
-     * </pre>
-     *
-     * <code>string oauth_scope = 3;</code>
-     */
-    public com.google.protobuf.ByteString
-        getOauthScopeBytes() {
-      java.lang.Object ref = oauthScope_;
-      if (ref instanceof java.lang.String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        oauthScope_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (payload_ != null) {
-        output.writeMessage(1, getPayload());
-      }
-      if (!getUsernameBytes().isEmpty()) {
-        com.google.protobuf.GeneratedMessageV3.writeString(output, 2, username_);
-      }
-      if (!getOauthScopeBytes().isEmpty()) {
-        com.google.protobuf.GeneratedMessageV3.writeString(output, 3, oauthScope_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (payload_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, getPayload());
-      }
-      if (!getUsernameBytes().isEmpty()) {
-        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, username_);
-      }
-      if (!getOauthScopeBytes().isEmpty()) {
-        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, oauthScope_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Messages.SimpleResponse)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Messages.SimpleResponse other = (io.grpc.testing.integration.Messages.SimpleResponse) obj;
-
-      boolean result = true;
-      result = result && (hasPayload() == other.hasPayload());
-      if (hasPayload()) {
-        result = result && getPayload()
-            .equals(other.getPayload());
-      }
-      result = result && getUsername()
-          .equals(other.getUsername());
-      result = result && getOauthScope()
-          .equals(other.getOauthScope());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      if (hasPayload()) {
-        hash = (37 * hash) + PAYLOAD_FIELD_NUMBER;
-        hash = (53 * hash) + getPayload().hashCode();
-      }
-      hash = (37 * hash) + USERNAME_FIELD_NUMBER;
-      hash = (53 * hash) + getUsername().hashCode();
-      hash = (37 * hash) + OAUTH_SCOPE_FIELD_NUMBER;
-      hash = (53 * hash) + getOauthScope().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Messages.SimpleResponse parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleResponse parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleResponse parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleResponse parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleResponse parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleResponse parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleResponse parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleResponse parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleResponse parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleResponse parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Messages.SimpleResponse prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Unary response, as configured by the request.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.SimpleResponse}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.SimpleResponse)
-        io.grpc.testing.integration.Messages.SimpleResponseOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleResponse_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleResponse_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Messages.SimpleResponse.class, io.grpc.testing.integration.Messages.SimpleResponse.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Messages.SimpleResponse.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-        username_ = "";
-
-        oauthScope_ = "";
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleResponse_descriptor;
-      }
-
-      public io.grpc.testing.integration.Messages.SimpleResponse getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Messages.SimpleResponse.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Messages.SimpleResponse build() {
-        io.grpc.testing.integration.Messages.SimpleResponse result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Messages.SimpleResponse buildPartial() {
-        io.grpc.testing.integration.Messages.SimpleResponse result = new io.grpc.testing.integration.Messages.SimpleResponse(this);
-        if (payloadBuilder_ == null) {
-          result.payload_ = payload_;
-        } else {
-          result.payload_ = payloadBuilder_.build();
-        }
-        result.username_ = username_;
-        result.oauthScope_ = oauthScope_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Messages.SimpleResponse) {
-          return mergeFrom((io.grpc.testing.integration.Messages.SimpleResponse)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Messages.SimpleResponse other) {
-        if (other == io.grpc.testing.integration.Messages.SimpleResponse.getDefaultInstance()) return this;
-        if (other.hasPayload()) {
-          mergePayload(other.getPayload());
-        }
-        if (!other.getUsername().isEmpty()) {
-          username_ = other.username_;
-          onChanged();
-        }
-        if (!other.getOauthScope().isEmpty()) {
-          oauthScope_ = other.oauthScope_;
-          onChanged();
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Messages.SimpleResponse parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Messages.SimpleResponse) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private io.grpc.testing.integration.Messages.Payload payload_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder> payloadBuilder_;
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public boolean hasPayload() {
-        return payloadBuilder_ != null || payload_ != null;
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.testing.integration.Messages.Payload getPayload() {
-        if (payloadBuilder_ == null) {
-          return payload_ == null ? io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-        } else {
-          return payloadBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder setPayload(io.grpc.testing.integration.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payload_ = value;
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder setPayload(
-          io.grpc.testing.integration.Messages.Payload.Builder builderForValue) {
-        if (payloadBuilder_ == null) {
-          payload_ = builderForValue.build();
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder mergePayload(io.grpc.testing.integration.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (payload_ != null) {
-            payload_ =
-              io.grpc.testing.integration.Messages.Payload.newBuilder(payload_).mergeFrom(value).buildPartial();
-          } else {
-            payload_ = value;
-          }
-          onChanged();
-        } else {
-          payloadBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder clearPayload() {
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-          onChanged();
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.testing.integration.Messages.Payload.Builder getPayloadBuilder() {
-        
-        onChanged();
-        return getPayloadFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-        if (payloadBuilder_ != null) {
-          return payloadBuilder_.getMessageOrBuilder();
-        } else {
-          return payload_ == null ?
-              io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-        }
-      }
-      /**
-       * <pre>
-       * Payload to increase message size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder> 
-          getPayloadFieldBuilder() {
-        if (payloadBuilder_ == null) {
-          payloadBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder>(
-                  getPayload(),
-                  getParentForChildren(),
-                  isClean());
-          payload_ = null;
-        }
-        return payloadBuilder_;
-      }
-
-      private java.lang.Object username_ = "";
-      /**
-       * <pre>
-       * The user the request came from, for verifying authentication was
-       * successful when the client expected it.
-       * </pre>
-       *
-       * <code>string username = 2;</code>
-       */
-      public java.lang.String getUsername() {
-        java.lang.Object ref = username_;
-        if (!(ref instanceof java.lang.String)) {
-          com.google.protobuf.ByteString bs =
-              (com.google.protobuf.ByteString) ref;
-          java.lang.String s = bs.toStringUtf8();
-          username_ = s;
-          return s;
-        } else {
-          return (java.lang.String) ref;
-        }
-      }
-      /**
-       * <pre>
-       * The user the request came from, for verifying authentication was
-       * successful when the client expected it.
-       * </pre>
-       *
-       * <code>string username = 2;</code>
-       */
-      public com.google.protobuf.ByteString
-          getUsernameBytes() {
-        java.lang.Object ref = username_;
-        if (ref instanceof String) {
-          com.google.protobuf.ByteString b = 
-              com.google.protobuf.ByteString.copyFromUtf8(
-                  (java.lang.String) ref);
-          username_ = b;
-          return b;
-        } else {
-          return (com.google.protobuf.ByteString) ref;
-        }
-      }
-      /**
-       * <pre>
-       * The user the request came from, for verifying authentication was
-       * successful when the client expected it.
-       * </pre>
-       *
-       * <code>string username = 2;</code>
-       */
-      public Builder setUsername(
-          java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  
-        username_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * The user the request came from, for verifying authentication was
-       * successful when the client expected it.
-       * </pre>
-       *
-       * <code>string username = 2;</code>
-       */
-      public Builder clearUsername() {
-        
-        username_ = getDefaultInstance().getUsername();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * The user the request came from, for verifying authentication was
-       * successful when the client expected it.
-       * </pre>
-       *
-       * <code>string username = 2;</code>
-       */
-      public Builder setUsernameBytes(
-          com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-        
-        username_ = value;
-        onChanged();
-        return this;
-      }
-
-      private java.lang.Object oauthScope_ = "";
-      /**
-       * <pre>
-       * OAuth scope.
-       * </pre>
-       *
-       * <code>string oauth_scope = 3;</code>
-       */
-      public java.lang.String getOauthScope() {
-        java.lang.Object ref = oauthScope_;
-        if (!(ref instanceof java.lang.String)) {
-          com.google.protobuf.ByteString bs =
-              (com.google.protobuf.ByteString) ref;
-          java.lang.String s = bs.toStringUtf8();
-          oauthScope_ = s;
-          return s;
-        } else {
-          return (java.lang.String) ref;
-        }
-      }
-      /**
-       * <pre>
-       * OAuth scope.
-       * </pre>
-       *
-       * <code>string oauth_scope = 3;</code>
-       */
-      public com.google.protobuf.ByteString
-          getOauthScopeBytes() {
-        java.lang.Object ref = oauthScope_;
-        if (ref instanceof String) {
-          com.google.protobuf.ByteString b = 
-              com.google.protobuf.ByteString.copyFromUtf8(
-                  (java.lang.String) ref);
-          oauthScope_ = b;
-          return b;
-        } else {
-          return (com.google.protobuf.ByteString) ref;
-        }
-      }
-      /**
-       * <pre>
-       * OAuth scope.
-       * </pre>
-       *
-       * <code>string oauth_scope = 3;</code>
-       */
-      public Builder setOauthScope(
-          java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  
-        oauthScope_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * OAuth scope.
-       * </pre>
-       *
-       * <code>string oauth_scope = 3;</code>
-       */
-      public Builder clearOauthScope() {
-        
-        oauthScope_ = getDefaultInstance().getOauthScope();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * OAuth scope.
-       * </pre>
-       *
-       * <code>string oauth_scope = 3;</code>
-       */
-      public Builder setOauthScopeBytes(
-          com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-        
-        oauthScope_ = value;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.SimpleResponse)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.SimpleResponse)
-    private static final io.grpc.testing.integration.Messages.SimpleResponse DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Messages.SimpleResponse();
-    }
-
-    public static io.grpc.testing.integration.Messages.SimpleResponse getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<SimpleResponse>
-        PARSER = new com.google.protobuf.AbstractParser<SimpleResponse>() {
-      public SimpleResponse parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new SimpleResponse(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<SimpleResponse> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<SimpleResponse> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Messages.SimpleResponse getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface SimpleContextOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.SimpleContext)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>string value = 1;</code>
-     */
-    java.lang.String getValue();
-    /**
-     * <code>string value = 1;</code>
-     */
-    com.google.protobuf.ByteString
-        getValueBytes();
-  }
-  /**
-   * Protobuf type {@code grpc.testing.SimpleContext}
-   */
-  public  static final class SimpleContext extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.SimpleContext)
-      SimpleContextOrBuilder {
-    // Use SimpleContext.newBuilder() to construct.
-    private SimpleContext(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private SimpleContext() {
-      value_ = "";
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private SimpleContext(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              java.lang.String s = input.readStringRequireUtf8();
-
-              value_ = s;
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleContext_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleContext_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Messages.SimpleContext.class, io.grpc.testing.integration.Messages.SimpleContext.Builder.class);
-    }
-
-    public static final int VALUE_FIELD_NUMBER = 1;
-    private volatile java.lang.Object value_;
-    /**
-     * <code>string value = 1;</code>
-     */
-    public java.lang.String getValue() {
-      java.lang.Object ref = value_;
-      if (ref instanceof java.lang.String) {
-        return (java.lang.String) ref;
-      } else {
-        com.google.protobuf.ByteString bs = 
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        value_ = s;
-        return s;
-      }
-    }
-    /**
-     * <code>string value = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getValueBytes() {
-      java.lang.Object ref = value_;
-      if (ref instanceof java.lang.String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        value_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (!getValueBytes().isEmpty()) {
-        com.google.protobuf.GeneratedMessageV3.writeString(output, 1, value_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (!getValueBytes().isEmpty()) {
-        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, value_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Messages.SimpleContext)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Messages.SimpleContext other = (io.grpc.testing.integration.Messages.SimpleContext) obj;
-
-      boolean result = true;
-      result = result && getValue()
-          .equals(other.getValue());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + VALUE_FIELD_NUMBER;
-      hash = (53 * hash) + getValue().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Messages.SimpleContext parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleContext parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleContext parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleContext parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleContext parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleContext parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleContext parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleContext parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleContext parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.SimpleContext parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Messages.SimpleContext prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.SimpleContext}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.SimpleContext)
-        io.grpc.testing.integration.Messages.SimpleContextOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleContext_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleContext_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Messages.SimpleContext.class, io.grpc.testing.integration.Messages.SimpleContext.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Messages.SimpleContext.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        value_ = "";
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_SimpleContext_descriptor;
-      }
-
-      public io.grpc.testing.integration.Messages.SimpleContext getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Messages.SimpleContext.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Messages.SimpleContext build() {
-        io.grpc.testing.integration.Messages.SimpleContext result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Messages.SimpleContext buildPartial() {
-        io.grpc.testing.integration.Messages.SimpleContext result = new io.grpc.testing.integration.Messages.SimpleContext(this);
-        result.value_ = value_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Messages.SimpleContext) {
-          return mergeFrom((io.grpc.testing.integration.Messages.SimpleContext)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Messages.SimpleContext other) {
-        if (other == io.grpc.testing.integration.Messages.SimpleContext.getDefaultInstance()) return this;
-        if (!other.getValue().isEmpty()) {
-          value_ = other.value_;
-          onChanged();
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Messages.SimpleContext parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Messages.SimpleContext) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private java.lang.Object value_ = "";
-      /**
-       * <code>string value = 1;</code>
-       */
-      public java.lang.String getValue() {
-        java.lang.Object ref = value_;
-        if (!(ref instanceof java.lang.String)) {
-          com.google.protobuf.ByteString bs =
-              (com.google.protobuf.ByteString) ref;
-          java.lang.String s = bs.toStringUtf8();
-          value_ = s;
-          return s;
-        } else {
-          return (java.lang.String) ref;
-        }
-      }
-      /**
-       * <code>string value = 1;</code>
-       */
-      public com.google.protobuf.ByteString
-          getValueBytes() {
-        java.lang.Object ref = value_;
-        if (ref instanceof String) {
-          com.google.protobuf.ByteString b = 
-              com.google.protobuf.ByteString.copyFromUtf8(
-                  (java.lang.String) ref);
-          value_ = b;
-          return b;
-        } else {
-          return (com.google.protobuf.ByteString) ref;
-        }
-      }
-      /**
-       * <code>string value = 1;</code>
-       */
-      public Builder setValue(
-          java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  
-        value_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>string value = 1;</code>
-       */
-      public Builder clearValue() {
-        
-        value_ = getDefaultInstance().getValue();
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>string value = 1;</code>
-       */
-      public Builder setValueBytes(
-          com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-        
-        value_ = value;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.SimpleContext)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.SimpleContext)
-    private static final io.grpc.testing.integration.Messages.SimpleContext DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Messages.SimpleContext();
-    }
-
-    public static io.grpc.testing.integration.Messages.SimpleContext getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<SimpleContext>
-        PARSER = new com.google.protobuf.AbstractParser<SimpleContext>() {
-      public SimpleContext parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new SimpleContext(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<SimpleContext> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<SimpleContext> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Messages.SimpleContext getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface StreamingInputCallRequestOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.StreamingInputCallRequest)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    boolean hasPayload();
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    io.grpc.testing.integration.Messages.Payload getPayload();
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder();
-  }
-  /**
-   * <pre>
-   * Client-streaming request.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.StreamingInputCallRequest}
-   */
-  public  static final class StreamingInputCallRequest extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.StreamingInputCallRequest)
-      StreamingInputCallRequestOrBuilder {
-    // Use StreamingInputCallRequest.newBuilder() to construct.
-    private StreamingInputCallRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private StreamingInputCallRequest() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private StreamingInputCallRequest(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              io.grpc.testing.integration.Messages.Payload.Builder subBuilder = null;
-              if (payload_ != null) {
-                subBuilder = payload_.toBuilder();
-              }
-              payload_ = input.readMessage(io.grpc.testing.integration.Messages.Payload.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(payload_);
-                payload_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingInputCallRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingInputCallRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Messages.StreamingInputCallRequest.class, io.grpc.testing.integration.Messages.StreamingInputCallRequest.Builder.class);
-    }
-
-    public static final int PAYLOAD_FIELD_NUMBER = 1;
-    private io.grpc.testing.integration.Messages.Payload payload_;
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public boolean hasPayload() {
-      return payload_ != null;
-    }
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public io.grpc.testing.integration.Messages.Payload getPayload() {
-      return payload_ == null ? io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-    }
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-      return getPayload();
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (payload_ != null) {
-        output.writeMessage(1, getPayload());
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (payload_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, getPayload());
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Messages.StreamingInputCallRequest)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Messages.StreamingInputCallRequest other = (io.grpc.testing.integration.Messages.StreamingInputCallRequest) obj;
-
-      boolean result = true;
-      result = result && (hasPayload() == other.hasPayload());
-      if (hasPayload()) {
-        result = result && getPayload()
-            .equals(other.getPayload());
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      if (hasPayload()) {
-        hash = (37 * hash) + PAYLOAD_FIELD_NUMBER;
-        hash = (53 * hash) + getPayload().hashCode();
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Messages.StreamingInputCallRequest parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallRequest parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallRequest parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallRequest parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallRequest parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallRequest parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallRequest parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallRequest parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallRequest parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallRequest parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Messages.StreamingInputCallRequest prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Client-streaming request.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.StreamingInputCallRequest}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.StreamingInputCallRequest)
-        io.grpc.testing.integration.Messages.StreamingInputCallRequestOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingInputCallRequest_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingInputCallRequest_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Messages.StreamingInputCallRequest.class, io.grpc.testing.integration.Messages.StreamingInputCallRequest.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Messages.StreamingInputCallRequest.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingInputCallRequest_descriptor;
-      }
-
-      public io.grpc.testing.integration.Messages.StreamingInputCallRequest getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Messages.StreamingInputCallRequest.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Messages.StreamingInputCallRequest build() {
-        io.grpc.testing.integration.Messages.StreamingInputCallRequest result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Messages.StreamingInputCallRequest buildPartial() {
-        io.grpc.testing.integration.Messages.StreamingInputCallRequest result = new io.grpc.testing.integration.Messages.StreamingInputCallRequest(this);
-        if (payloadBuilder_ == null) {
-          result.payload_ = payload_;
-        } else {
-          result.payload_ = payloadBuilder_.build();
-        }
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Messages.StreamingInputCallRequest) {
-          return mergeFrom((io.grpc.testing.integration.Messages.StreamingInputCallRequest)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Messages.StreamingInputCallRequest other) {
-        if (other == io.grpc.testing.integration.Messages.StreamingInputCallRequest.getDefaultInstance()) return this;
-        if (other.hasPayload()) {
-          mergePayload(other.getPayload());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Messages.StreamingInputCallRequest parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Messages.StreamingInputCallRequest) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private io.grpc.testing.integration.Messages.Payload payload_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder> payloadBuilder_;
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public boolean hasPayload() {
-        return payloadBuilder_ != null || payload_ != null;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.testing.integration.Messages.Payload getPayload() {
-        if (payloadBuilder_ == null) {
-          return payload_ == null ? io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-        } else {
-          return payloadBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder setPayload(io.grpc.testing.integration.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payload_ = value;
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder setPayload(
-          io.grpc.testing.integration.Messages.Payload.Builder builderForValue) {
-        if (payloadBuilder_ == null) {
-          payload_ = builderForValue.build();
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder mergePayload(io.grpc.testing.integration.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (payload_ != null) {
-            payload_ =
-              io.grpc.testing.integration.Messages.Payload.newBuilder(payload_).mergeFrom(value).buildPartial();
-          } else {
-            payload_ = value;
-          }
-          onChanged();
-        } else {
-          payloadBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder clearPayload() {
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-          onChanged();
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.testing.integration.Messages.Payload.Builder getPayloadBuilder() {
-        
-        onChanged();
-        return getPayloadFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-        if (payloadBuilder_ != null) {
-          return payloadBuilder_.getMessageOrBuilder();
-        } else {
-          return payload_ == null ?
-              io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-        }
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder> 
-          getPayloadFieldBuilder() {
-        if (payloadBuilder_ == null) {
-          payloadBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder>(
-                  getPayload(),
-                  getParentForChildren(),
-                  isClean());
-          payload_ = null;
-        }
-        return payloadBuilder_;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.StreamingInputCallRequest)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.StreamingInputCallRequest)
-    private static final io.grpc.testing.integration.Messages.StreamingInputCallRequest DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Messages.StreamingInputCallRequest();
-    }
-
-    public static io.grpc.testing.integration.Messages.StreamingInputCallRequest getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<StreamingInputCallRequest>
-        PARSER = new com.google.protobuf.AbstractParser<StreamingInputCallRequest>() {
-      public StreamingInputCallRequest parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new StreamingInputCallRequest(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<StreamingInputCallRequest> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<StreamingInputCallRequest> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Messages.StreamingInputCallRequest getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface StreamingInputCallResponseOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.StreamingInputCallResponse)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Aggregated size of payloads received from the client.
-     * </pre>
-     *
-     * <code>int32 aggregated_payload_size = 1;</code>
-     */
-    int getAggregatedPayloadSize();
-  }
-  /**
-   * <pre>
-   * Client-streaming response.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.StreamingInputCallResponse}
-   */
-  public  static final class StreamingInputCallResponse extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.StreamingInputCallResponse)
-      StreamingInputCallResponseOrBuilder {
-    // Use StreamingInputCallResponse.newBuilder() to construct.
-    private StreamingInputCallResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private StreamingInputCallResponse() {
-      aggregatedPayloadSize_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private StreamingInputCallResponse(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              aggregatedPayloadSize_ = input.readInt32();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingInputCallResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingInputCallResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Messages.StreamingInputCallResponse.class, io.grpc.testing.integration.Messages.StreamingInputCallResponse.Builder.class);
-    }
-
-    public static final int AGGREGATED_PAYLOAD_SIZE_FIELD_NUMBER = 1;
-    private int aggregatedPayloadSize_;
-    /**
-     * <pre>
-     * Aggregated size of payloads received from the client.
-     * </pre>
-     *
-     * <code>int32 aggregated_payload_size = 1;</code>
-     */
-    public int getAggregatedPayloadSize() {
-      return aggregatedPayloadSize_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (aggregatedPayloadSize_ != 0) {
-        output.writeInt32(1, aggregatedPayloadSize_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (aggregatedPayloadSize_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(1, aggregatedPayloadSize_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Messages.StreamingInputCallResponse)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Messages.StreamingInputCallResponse other = (io.grpc.testing.integration.Messages.StreamingInputCallResponse) obj;
-
-      boolean result = true;
-      result = result && (getAggregatedPayloadSize()
-          == other.getAggregatedPayloadSize());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + AGGREGATED_PAYLOAD_SIZE_FIELD_NUMBER;
-      hash = (53 * hash) + getAggregatedPayloadSize();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Messages.StreamingInputCallResponse parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallResponse parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallResponse parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallResponse parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallResponse parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallResponse parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallResponse parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallResponse parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallResponse parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingInputCallResponse parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Messages.StreamingInputCallResponse prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Client-streaming response.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.StreamingInputCallResponse}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.StreamingInputCallResponse)
-        io.grpc.testing.integration.Messages.StreamingInputCallResponseOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingInputCallResponse_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingInputCallResponse_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Messages.StreamingInputCallResponse.class, io.grpc.testing.integration.Messages.StreamingInputCallResponse.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Messages.StreamingInputCallResponse.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        aggregatedPayloadSize_ = 0;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingInputCallResponse_descriptor;
-      }
-
-      public io.grpc.testing.integration.Messages.StreamingInputCallResponse getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Messages.StreamingInputCallResponse.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Messages.StreamingInputCallResponse build() {
-        io.grpc.testing.integration.Messages.StreamingInputCallResponse result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Messages.StreamingInputCallResponse buildPartial() {
-        io.grpc.testing.integration.Messages.StreamingInputCallResponse result = new io.grpc.testing.integration.Messages.StreamingInputCallResponse(this);
-        result.aggregatedPayloadSize_ = aggregatedPayloadSize_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Messages.StreamingInputCallResponse) {
-          return mergeFrom((io.grpc.testing.integration.Messages.StreamingInputCallResponse)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Messages.StreamingInputCallResponse other) {
-        if (other == io.grpc.testing.integration.Messages.StreamingInputCallResponse.getDefaultInstance()) return this;
-        if (other.getAggregatedPayloadSize() != 0) {
-          setAggregatedPayloadSize(other.getAggregatedPayloadSize());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Messages.StreamingInputCallResponse parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Messages.StreamingInputCallResponse) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int aggregatedPayloadSize_ ;
-      /**
-       * <pre>
-       * Aggregated size of payloads received from the client.
-       * </pre>
-       *
-       * <code>int32 aggregated_payload_size = 1;</code>
-       */
-      public int getAggregatedPayloadSize() {
-        return aggregatedPayloadSize_;
-      }
-      /**
-       * <pre>
-       * Aggregated size of payloads received from the client.
-       * </pre>
-       *
-       * <code>int32 aggregated_payload_size = 1;</code>
-       */
-      public Builder setAggregatedPayloadSize(int value) {
-        
-        aggregatedPayloadSize_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Aggregated size of payloads received from the client.
-       * </pre>
-       *
-       * <code>int32 aggregated_payload_size = 1;</code>
-       */
-      public Builder clearAggregatedPayloadSize() {
-        
-        aggregatedPayloadSize_ = 0;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.StreamingInputCallResponse)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.StreamingInputCallResponse)
-    private static final io.grpc.testing.integration.Messages.StreamingInputCallResponse DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Messages.StreamingInputCallResponse();
-    }
-
-    public static io.grpc.testing.integration.Messages.StreamingInputCallResponse getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<StreamingInputCallResponse>
-        PARSER = new com.google.protobuf.AbstractParser<StreamingInputCallResponse>() {
-      public StreamingInputCallResponse parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new StreamingInputCallResponse(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<StreamingInputCallResponse> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<StreamingInputCallResponse> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Messages.StreamingInputCallResponse getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ResponseParametersOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ResponseParameters)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Desired payload sizes in responses from the server.
-     * If response_type is COMPRESSABLE, this denotes the size before compression.
-     * </pre>
-     *
-     * <code>int32 size = 1;</code>
-     */
-    int getSize();
-
-    /**
-     * <pre>
-     * Desired interval between consecutive responses in the response stream in
-     * microseconds.
-     * </pre>
-     *
-     * <code>int32 interval_us = 2;</code>
-     */
-    int getIntervalUs();
-  }
-  /**
-   * <pre>
-   * Configuration for a particular response.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.ResponseParameters}
-   */
-  public  static final class ResponseParameters extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ResponseParameters)
-      ResponseParametersOrBuilder {
-    // Use ResponseParameters.newBuilder() to construct.
-    private ResponseParameters(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ResponseParameters() {
-      size_ = 0;
-      intervalUs_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ResponseParameters(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              size_ = input.readInt32();
-              break;
-            }
-            case 16: {
-
-              intervalUs_ = input.readInt32();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ResponseParameters_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ResponseParameters_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Messages.ResponseParameters.class, io.grpc.testing.integration.Messages.ResponseParameters.Builder.class);
-    }
-
-    public static final int SIZE_FIELD_NUMBER = 1;
-    private int size_;
-    /**
-     * <pre>
-     * Desired payload sizes in responses from the server.
-     * If response_type is COMPRESSABLE, this denotes the size before compression.
-     * </pre>
-     *
-     * <code>int32 size = 1;</code>
-     */
-    public int getSize() {
-      return size_;
-    }
-
-    public static final int INTERVAL_US_FIELD_NUMBER = 2;
-    private int intervalUs_;
-    /**
-     * <pre>
-     * Desired interval between consecutive responses in the response stream in
-     * microseconds.
-     * </pre>
-     *
-     * <code>int32 interval_us = 2;</code>
-     */
-    public int getIntervalUs() {
-      return intervalUs_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (size_ != 0) {
-        output.writeInt32(1, size_);
-      }
-      if (intervalUs_ != 0) {
-        output.writeInt32(2, intervalUs_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (size_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(1, size_);
-      }
-      if (intervalUs_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(2, intervalUs_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Messages.ResponseParameters)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Messages.ResponseParameters other = (io.grpc.testing.integration.Messages.ResponseParameters) obj;
-
-      boolean result = true;
-      result = result && (getSize()
-          == other.getSize());
-      result = result && (getIntervalUs()
-          == other.getIntervalUs());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + SIZE_FIELD_NUMBER;
-      hash = (53 * hash) + getSize();
-      hash = (37 * hash) + INTERVAL_US_FIELD_NUMBER;
-      hash = (53 * hash) + getIntervalUs();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Messages.ResponseParameters parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.ResponseParameters parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.ResponseParameters parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.ResponseParameters parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.ResponseParameters parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.ResponseParameters parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.ResponseParameters parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.ResponseParameters parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.ResponseParameters parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.ResponseParameters parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Messages.ResponseParameters prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Configuration for a particular response.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.ResponseParameters}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ResponseParameters)
-        io.grpc.testing.integration.Messages.ResponseParametersOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ResponseParameters_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ResponseParameters_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Messages.ResponseParameters.class, io.grpc.testing.integration.Messages.ResponseParameters.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Messages.ResponseParameters.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        size_ = 0;
-
-        intervalUs_ = 0;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ResponseParameters_descriptor;
-      }
-
-      public io.grpc.testing.integration.Messages.ResponseParameters getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Messages.ResponseParameters.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Messages.ResponseParameters build() {
-        io.grpc.testing.integration.Messages.ResponseParameters result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Messages.ResponseParameters buildPartial() {
-        io.grpc.testing.integration.Messages.ResponseParameters result = new io.grpc.testing.integration.Messages.ResponseParameters(this);
-        result.size_ = size_;
-        result.intervalUs_ = intervalUs_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Messages.ResponseParameters) {
-          return mergeFrom((io.grpc.testing.integration.Messages.ResponseParameters)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Messages.ResponseParameters other) {
-        if (other == io.grpc.testing.integration.Messages.ResponseParameters.getDefaultInstance()) return this;
-        if (other.getSize() != 0) {
-          setSize(other.getSize());
-        }
-        if (other.getIntervalUs() != 0) {
-          setIntervalUs(other.getIntervalUs());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Messages.ResponseParameters parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Messages.ResponseParameters) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int size_ ;
-      /**
-       * <pre>
-       * Desired payload sizes in responses from the server.
-       * If response_type is COMPRESSABLE, this denotes the size before compression.
-       * </pre>
-       *
-       * <code>int32 size = 1;</code>
-       */
-      public int getSize() {
-        return size_;
-      }
-      /**
-       * <pre>
-       * Desired payload sizes in responses from the server.
-       * If response_type is COMPRESSABLE, this denotes the size before compression.
-       * </pre>
-       *
-       * <code>int32 size = 1;</code>
-       */
-      public Builder setSize(int value) {
-        
-        size_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired payload sizes in responses from the server.
-       * If response_type is COMPRESSABLE, this denotes the size before compression.
-       * </pre>
-       *
-       * <code>int32 size = 1;</code>
-       */
-      public Builder clearSize() {
-        
-        size_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private int intervalUs_ ;
-      /**
-       * <pre>
-       * Desired interval between consecutive responses in the response stream in
-       * microseconds.
-       * </pre>
-       *
-       * <code>int32 interval_us = 2;</code>
-       */
-      public int getIntervalUs() {
-        return intervalUs_;
-      }
-      /**
-       * <pre>
-       * Desired interval between consecutive responses in the response stream in
-       * microseconds.
-       * </pre>
-       *
-       * <code>int32 interval_us = 2;</code>
-       */
-      public Builder setIntervalUs(int value) {
-        
-        intervalUs_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired interval between consecutive responses in the response stream in
-       * microseconds.
-       * </pre>
-       *
-       * <code>int32 interval_us = 2;</code>
-       */
-      public Builder clearIntervalUs() {
-        
-        intervalUs_ = 0;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ResponseParameters)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ResponseParameters)
-    private static final io.grpc.testing.integration.Messages.ResponseParameters DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Messages.ResponseParameters();
-    }
-
-    public static io.grpc.testing.integration.Messages.ResponseParameters getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ResponseParameters>
-        PARSER = new com.google.protobuf.AbstractParser<ResponseParameters>() {
-      public ResponseParameters parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ResponseParameters(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ResponseParameters> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ResponseParameters> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Messages.ResponseParameters getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface StreamingOutputCallRequestOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.StreamingOutputCallRequest)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, the payload from each response in the stream
-     * might be of different types. This is to simulate a mixed type of payload
-     * stream.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    int getResponseTypeValue();
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, the payload from each response in the stream
-     * might be of different types. This is to simulate a mixed type of payload
-     * stream.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    io.grpc.testing.integration.Messages.PayloadType getResponseType();
-
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    java.util.List<io.grpc.testing.integration.Messages.ResponseParameters> 
-        getResponseParametersList();
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    io.grpc.testing.integration.Messages.ResponseParameters getResponseParameters(int index);
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    int getResponseParametersCount();
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    java.util.List<? extends io.grpc.testing.integration.Messages.ResponseParametersOrBuilder> 
-        getResponseParametersOrBuilderList();
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    io.grpc.testing.integration.Messages.ResponseParametersOrBuilder getResponseParametersOrBuilder(
-        int index);
-
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    boolean hasPayload();
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    io.grpc.testing.integration.Messages.Payload getPayload();
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder();
-
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    int getResponseCompressionValue();
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    io.grpc.testing.integration.Messages.CompressionType getResponseCompression();
-
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    boolean hasResponseStatus();
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    io.grpc.testing.integration.Messages.EchoStatus getResponseStatus();
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    io.grpc.testing.integration.Messages.EchoStatusOrBuilder getResponseStatusOrBuilder();
-  }
-  /**
-   * <pre>
-   * Server-streaming request.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.StreamingOutputCallRequest}
-   */
-  public  static final class StreamingOutputCallRequest extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.StreamingOutputCallRequest)
-      StreamingOutputCallRequestOrBuilder {
-    // Use StreamingOutputCallRequest.newBuilder() to construct.
-    private StreamingOutputCallRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private StreamingOutputCallRequest() {
-      responseType_ = 0;
-      responseParameters_ = java.util.Collections.emptyList();
-      responseCompression_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private StreamingOutputCallRequest(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-              int rawValue = input.readEnum();
-
-              responseType_ = rawValue;
-              break;
-            }
-            case 18: {
-              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
-                responseParameters_ = new java.util.ArrayList<io.grpc.testing.integration.Messages.ResponseParameters>();
-                mutable_bitField0_ |= 0x00000002;
-              }
-              responseParameters_.add(
-                  input.readMessage(io.grpc.testing.integration.Messages.ResponseParameters.parser(), extensionRegistry));
-              break;
-            }
-            case 26: {
-              io.grpc.testing.integration.Messages.Payload.Builder subBuilder = null;
-              if (payload_ != null) {
-                subBuilder = payload_.toBuilder();
-              }
-              payload_ = input.readMessage(io.grpc.testing.integration.Messages.Payload.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(payload_);
-                payload_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-            case 48: {
-              int rawValue = input.readEnum();
-
-              responseCompression_ = rawValue;
-              break;
-            }
-            case 58: {
-              io.grpc.testing.integration.Messages.EchoStatus.Builder subBuilder = null;
-              if (responseStatus_ != null) {
-                subBuilder = responseStatus_.toBuilder();
-              }
-              responseStatus_ = input.readMessage(io.grpc.testing.integration.Messages.EchoStatus.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(responseStatus_);
-                responseStatus_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
-          responseParameters_ = java.util.Collections.unmodifiableList(responseParameters_);
-        }
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingOutputCallRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingOutputCallRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class, io.grpc.testing.integration.Messages.StreamingOutputCallRequest.Builder.class);
-    }
-
-    private int bitField0_;
-    public static final int RESPONSE_TYPE_FIELD_NUMBER = 1;
-    private int responseType_;
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, the payload from each response in the stream
-     * might be of different types. This is to simulate a mixed type of payload
-     * stream.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    public int getResponseTypeValue() {
-      return responseType_;
-    }
-    /**
-     * <pre>
-     * Desired payload type in the response from the server.
-     * If response_type is RANDOM, the payload from each response in the stream
-     * might be of different types. This is to simulate a mixed type of payload
-     * stream.
-     * </pre>
-     *
-     * <code>.grpc.testing.PayloadType response_type = 1;</code>
-     */
-    public io.grpc.testing.integration.Messages.PayloadType getResponseType() {
-      io.grpc.testing.integration.Messages.PayloadType result = io.grpc.testing.integration.Messages.PayloadType.valueOf(responseType_);
-      return result == null ? io.grpc.testing.integration.Messages.PayloadType.UNRECOGNIZED : result;
-    }
-
-    public static final int RESPONSE_PARAMETERS_FIELD_NUMBER = 2;
-    private java.util.List<io.grpc.testing.integration.Messages.ResponseParameters> responseParameters_;
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    public java.util.List<io.grpc.testing.integration.Messages.ResponseParameters> getResponseParametersList() {
-      return responseParameters_;
-    }
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    public java.util.List<? extends io.grpc.testing.integration.Messages.ResponseParametersOrBuilder> 
-        getResponseParametersOrBuilderList() {
-      return responseParameters_;
-    }
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    public int getResponseParametersCount() {
-      return responseParameters_.size();
-    }
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    public io.grpc.testing.integration.Messages.ResponseParameters getResponseParameters(int index) {
-      return responseParameters_.get(index);
-    }
-    /**
-     * <pre>
-     * Configuration for each expected response message.
-     * </pre>
-     *
-     * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-     */
-    public io.grpc.testing.integration.Messages.ResponseParametersOrBuilder getResponseParametersOrBuilder(
-        int index) {
-      return responseParameters_.get(index);
-    }
-
-    public static final int PAYLOAD_FIELD_NUMBER = 3;
-    private io.grpc.testing.integration.Messages.Payload payload_;
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    public boolean hasPayload() {
-      return payload_ != null;
-    }
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    public io.grpc.testing.integration.Messages.Payload getPayload() {
-      return payload_ == null ? io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-    }
-    /**
-     * <pre>
-     * Optional input payload sent along with the request.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 3;</code>
-     */
-    public io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-      return getPayload();
-    }
-
-    public static final int RESPONSE_COMPRESSION_FIELD_NUMBER = 6;
-    private int responseCompression_;
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    public int getResponseCompressionValue() {
-      return responseCompression_;
-    }
-    /**
-     * <pre>
-     * Compression algorithm to be used by the server for the response (stream)
-     * </pre>
-     *
-     * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-     */
-    public io.grpc.testing.integration.Messages.CompressionType getResponseCompression() {
-      io.grpc.testing.integration.Messages.CompressionType result = io.grpc.testing.integration.Messages.CompressionType.valueOf(responseCompression_);
-      return result == null ? io.grpc.testing.integration.Messages.CompressionType.UNRECOGNIZED : result;
-    }
-
-    public static final int RESPONSE_STATUS_FIELD_NUMBER = 7;
-    private io.grpc.testing.integration.Messages.EchoStatus responseStatus_;
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    public boolean hasResponseStatus() {
-      return responseStatus_ != null;
-    }
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    public io.grpc.testing.integration.Messages.EchoStatus getResponseStatus() {
-      return responseStatus_ == null ? io.grpc.testing.integration.Messages.EchoStatus.getDefaultInstance() : responseStatus_;
-    }
-    /**
-     * <pre>
-     * Whether server should return a given status
-     * </pre>
-     *
-     * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-     */
-    public io.grpc.testing.integration.Messages.EchoStatusOrBuilder getResponseStatusOrBuilder() {
-      return getResponseStatus();
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (responseType_ != io.grpc.testing.integration.Messages.PayloadType.COMPRESSABLE.getNumber()) {
-        output.writeEnum(1, responseType_);
-      }
-      for (int i = 0; i < responseParameters_.size(); i++) {
-        output.writeMessage(2, responseParameters_.get(i));
-      }
-      if (payload_ != null) {
-        output.writeMessage(3, getPayload());
-      }
-      if (responseCompression_ != io.grpc.testing.integration.Messages.CompressionType.NONE.getNumber()) {
-        output.writeEnum(6, responseCompression_);
-      }
-      if (responseStatus_ != null) {
-        output.writeMessage(7, getResponseStatus());
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (responseType_ != io.grpc.testing.integration.Messages.PayloadType.COMPRESSABLE.getNumber()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeEnumSize(1, responseType_);
-      }
-      for (int i = 0; i < responseParameters_.size(); i++) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(2, responseParameters_.get(i));
-      }
-      if (payload_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(3, getPayload());
-      }
-      if (responseCompression_ != io.grpc.testing.integration.Messages.CompressionType.NONE.getNumber()) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeEnumSize(6, responseCompression_);
-      }
-      if (responseStatus_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(7, getResponseStatus());
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Messages.StreamingOutputCallRequest)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Messages.StreamingOutputCallRequest other = (io.grpc.testing.integration.Messages.StreamingOutputCallRequest) obj;
-
-      boolean result = true;
-      result = result && responseType_ == other.responseType_;
-      result = result && getResponseParametersList()
-          .equals(other.getResponseParametersList());
-      result = result && (hasPayload() == other.hasPayload());
-      if (hasPayload()) {
-        result = result && getPayload()
-            .equals(other.getPayload());
-      }
-      result = result && responseCompression_ == other.responseCompression_;
-      result = result && (hasResponseStatus() == other.hasResponseStatus());
-      if (hasResponseStatus()) {
-        result = result && getResponseStatus()
-            .equals(other.getResponseStatus());
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + RESPONSE_TYPE_FIELD_NUMBER;
-      hash = (53 * hash) + responseType_;
-      if (getResponseParametersCount() > 0) {
-        hash = (37 * hash) + RESPONSE_PARAMETERS_FIELD_NUMBER;
-        hash = (53 * hash) + getResponseParametersList().hashCode();
-      }
-      if (hasPayload()) {
-        hash = (37 * hash) + PAYLOAD_FIELD_NUMBER;
-        hash = (53 * hash) + getPayload().hashCode();
-      }
-      hash = (37 * hash) + RESPONSE_COMPRESSION_FIELD_NUMBER;
-      hash = (53 * hash) + responseCompression_;
-      if (hasResponseStatus()) {
-        hash = (37 * hash) + RESPONSE_STATUS_FIELD_NUMBER;
-        hash = (53 * hash) + getResponseStatus().hashCode();
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallRequest parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallRequest parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallRequest parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallRequest parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallRequest parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallRequest parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallRequest parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallRequest parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallRequest parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallRequest parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Messages.StreamingOutputCallRequest prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Server-streaming request.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.StreamingOutputCallRequest}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.StreamingOutputCallRequest)
-        io.grpc.testing.integration.Messages.StreamingOutputCallRequestOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingOutputCallRequest_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingOutputCallRequest_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Messages.StreamingOutputCallRequest.class, io.grpc.testing.integration.Messages.StreamingOutputCallRequest.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Messages.StreamingOutputCallRequest.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-          getResponseParametersFieldBuilder();
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        responseType_ = 0;
-
-        if (responseParametersBuilder_ == null) {
-          responseParameters_ = java.util.Collections.emptyList();
-          bitField0_ = (bitField0_ & ~0x00000002);
-        } else {
-          responseParametersBuilder_.clear();
-        }
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-        responseCompression_ = 0;
-
-        if (responseStatusBuilder_ == null) {
-          responseStatus_ = null;
-        } else {
-          responseStatus_ = null;
-          responseStatusBuilder_ = null;
-        }
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingOutputCallRequest_descriptor;
-      }
-
-      public io.grpc.testing.integration.Messages.StreamingOutputCallRequest getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Messages.StreamingOutputCallRequest build() {
-        io.grpc.testing.integration.Messages.StreamingOutputCallRequest result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Messages.StreamingOutputCallRequest buildPartial() {
-        io.grpc.testing.integration.Messages.StreamingOutputCallRequest result = new io.grpc.testing.integration.Messages.StreamingOutputCallRequest(this);
-        int from_bitField0_ = bitField0_;
-        int to_bitField0_ = 0;
-        result.responseType_ = responseType_;
-        if (responseParametersBuilder_ == null) {
-          if (((bitField0_ & 0x00000002) == 0x00000002)) {
-            responseParameters_ = java.util.Collections.unmodifiableList(responseParameters_);
-            bitField0_ = (bitField0_ & ~0x00000002);
-          }
-          result.responseParameters_ = responseParameters_;
-        } else {
-          result.responseParameters_ = responseParametersBuilder_.build();
-        }
-        if (payloadBuilder_ == null) {
-          result.payload_ = payload_;
-        } else {
-          result.payload_ = payloadBuilder_.build();
-        }
-        result.responseCompression_ = responseCompression_;
-        if (responseStatusBuilder_ == null) {
-          result.responseStatus_ = responseStatus_;
-        } else {
-          result.responseStatus_ = responseStatusBuilder_.build();
-        }
-        result.bitField0_ = to_bitField0_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Messages.StreamingOutputCallRequest) {
-          return mergeFrom((io.grpc.testing.integration.Messages.StreamingOutputCallRequest)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Messages.StreamingOutputCallRequest other) {
-        if (other == io.grpc.testing.integration.Messages.StreamingOutputCallRequest.getDefaultInstance()) return this;
-        if (other.responseType_ != 0) {
-          setResponseTypeValue(other.getResponseTypeValue());
-        }
-        if (responseParametersBuilder_ == null) {
-          if (!other.responseParameters_.isEmpty()) {
-            if (responseParameters_.isEmpty()) {
-              responseParameters_ = other.responseParameters_;
-              bitField0_ = (bitField0_ & ~0x00000002);
-            } else {
-              ensureResponseParametersIsMutable();
-              responseParameters_.addAll(other.responseParameters_);
-            }
-            onChanged();
-          }
-        } else {
-          if (!other.responseParameters_.isEmpty()) {
-            if (responseParametersBuilder_.isEmpty()) {
-              responseParametersBuilder_.dispose();
-              responseParametersBuilder_ = null;
-              responseParameters_ = other.responseParameters_;
-              bitField0_ = (bitField0_ & ~0x00000002);
-              responseParametersBuilder_ = 
-                com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ?
-                   getResponseParametersFieldBuilder() : null;
-            } else {
-              responseParametersBuilder_.addAllMessages(other.responseParameters_);
-            }
-          }
-        }
-        if (other.hasPayload()) {
-          mergePayload(other.getPayload());
-        }
-        if (other.responseCompression_ != 0) {
-          setResponseCompressionValue(other.getResponseCompressionValue());
-        }
-        if (other.hasResponseStatus()) {
-          mergeResponseStatus(other.getResponseStatus());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Messages.StreamingOutputCallRequest parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Messages.StreamingOutputCallRequest) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      private int bitField0_;
-
-      private int responseType_ = 0;
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, the payload from each response in the stream
-       * might be of different types. This is to simulate a mixed type of payload
-       * stream.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public int getResponseTypeValue() {
-        return responseType_;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, the payload from each response in the stream
-       * might be of different types. This is to simulate a mixed type of payload
-       * stream.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public Builder setResponseTypeValue(int value) {
-        responseType_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, the payload from each response in the stream
-       * might be of different types. This is to simulate a mixed type of payload
-       * stream.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public io.grpc.testing.integration.Messages.PayloadType getResponseType() {
-        io.grpc.testing.integration.Messages.PayloadType result = io.grpc.testing.integration.Messages.PayloadType.valueOf(responseType_);
-        return result == null ? io.grpc.testing.integration.Messages.PayloadType.UNRECOGNIZED : result;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, the payload from each response in the stream
-       * might be of different types. This is to simulate a mixed type of payload
-       * stream.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public Builder setResponseType(io.grpc.testing.integration.Messages.PayloadType value) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        
-        responseType_ = value.getNumber();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Desired payload type in the response from the server.
-       * If response_type is RANDOM, the payload from each response in the stream
-       * might be of different types. This is to simulate a mixed type of payload
-       * stream.
-       * </pre>
-       *
-       * <code>.grpc.testing.PayloadType response_type = 1;</code>
-       */
-      public Builder clearResponseType() {
-        
-        responseType_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private java.util.List<io.grpc.testing.integration.Messages.ResponseParameters> responseParameters_ =
-        java.util.Collections.emptyList();
-      private void ensureResponseParametersIsMutable() {
-        if (!((bitField0_ & 0x00000002) == 0x00000002)) {
-          responseParameters_ = new java.util.ArrayList<io.grpc.testing.integration.Messages.ResponseParameters>(responseParameters_);
-          bitField0_ |= 0x00000002;
-         }
-      }
-
-      private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.grpc.testing.integration.Messages.ResponseParameters, io.grpc.testing.integration.Messages.ResponseParameters.Builder, io.grpc.testing.integration.Messages.ResponseParametersOrBuilder> responseParametersBuilder_;
-
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public java.util.List<io.grpc.testing.integration.Messages.ResponseParameters> getResponseParametersList() {
-        if (responseParametersBuilder_ == null) {
-          return java.util.Collections.unmodifiableList(responseParameters_);
-        } else {
-          return responseParametersBuilder_.getMessageList();
-        }
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public int getResponseParametersCount() {
-        if (responseParametersBuilder_ == null) {
-          return responseParameters_.size();
-        } else {
-          return responseParametersBuilder_.getCount();
-        }
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public io.grpc.testing.integration.Messages.ResponseParameters getResponseParameters(int index) {
-        if (responseParametersBuilder_ == null) {
-          return responseParameters_.get(index);
-        } else {
-          return responseParametersBuilder_.getMessage(index);
-        }
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder setResponseParameters(
-          int index, io.grpc.testing.integration.Messages.ResponseParameters value) {
-        if (responseParametersBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          ensureResponseParametersIsMutable();
-          responseParameters_.set(index, value);
-          onChanged();
-        } else {
-          responseParametersBuilder_.setMessage(index, value);
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder setResponseParameters(
-          int index, io.grpc.testing.integration.Messages.ResponseParameters.Builder builderForValue) {
-        if (responseParametersBuilder_ == null) {
-          ensureResponseParametersIsMutable();
-          responseParameters_.set(index, builderForValue.build());
-          onChanged();
-        } else {
-          responseParametersBuilder_.setMessage(index, builderForValue.build());
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder addResponseParameters(io.grpc.testing.integration.Messages.ResponseParameters value) {
-        if (responseParametersBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          ensureResponseParametersIsMutable();
-          responseParameters_.add(value);
-          onChanged();
-        } else {
-          responseParametersBuilder_.addMessage(value);
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder addResponseParameters(
-          int index, io.grpc.testing.integration.Messages.ResponseParameters value) {
-        if (responseParametersBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          ensureResponseParametersIsMutable();
-          responseParameters_.add(index, value);
-          onChanged();
-        } else {
-          responseParametersBuilder_.addMessage(index, value);
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder addResponseParameters(
-          io.grpc.testing.integration.Messages.ResponseParameters.Builder builderForValue) {
-        if (responseParametersBuilder_ == null) {
-          ensureResponseParametersIsMutable();
-          responseParameters_.add(builderForValue.build());
-          onChanged();
-        } else {
-          responseParametersBuilder_.addMessage(builderForValue.build());
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder addResponseParameters(
-          int index, io.grpc.testing.integration.Messages.ResponseParameters.Builder builderForValue) {
-        if (responseParametersBuilder_ == null) {
-          ensureResponseParametersIsMutable();
-          responseParameters_.add(index, builderForValue.build());
-          onChanged();
-        } else {
-          responseParametersBuilder_.addMessage(index, builderForValue.build());
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder addAllResponseParameters(
-          java.lang.Iterable<? extends io.grpc.testing.integration.Messages.ResponseParameters> values) {
-        if (responseParametersBuilder_ == null) {
-          ensureResponseParametersIsMutable();
-          com.google.protobuf.AbstractMessageLite.Builder.addAll(
-              values, responseParameters_);
-          onChanged();
-        } else {
-          responseParametersBuilder_.addAllMessages(values);
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder clearResponseParameters() {
-        if (responseParametersBuilder_ == null) {
-          responseParameters_ = java.util.Collections.emptyList();
-          bitField0_ = (bitField0_ & ~0x00000002);
-          onChanged();
-        } else {
-          responseParametersBuilder_.clear();
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public Builder removeResponseParameters(int index) {
-        if (responseParametersBuilder_ == null) {
-          ensureResponseParametersIsMutable();
-          responseParameters_.remove(index);
-          onChanged();
-        } else {
-          responseParametersBuilder_.remove(index);
-        }
-        return this;
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public io.grpc.testing.integration.Messages.ResponseParameters.Builder getResponseParametersBuilder(
-          int index) {
-        return getResponseParametersFieldBuilder().getBuilder(index);
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public io.grpc.testing.integration.Messages.ResponseParametersOrBuilder getResponseParametersOrBuilder(
-          int index) {
-        if (responseParametersBuilder_ == null) {
-          return responseParameters_.get(index);  } else {
-          return responseParametersBuilder_.getMessageOrBuilder(index);
-        }
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public java.util.List<? extends io.grpc.testing.integration.Messages.ResponseParametersOrBuilder> 
-           getResponseParametersOrBuilderList() {
-        if (responseParametersBuilder_ != null) {
-          return responseParametersBuilder_.getMessageOrBuilderList();
-        } else {
-          return java.util.Collections.unmodifiableList(responseParameters_);
-        }
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public io.grpc.testing.integration.Messages.ResponseParameters.Builder addResponseParametersBuilder() {
-        return getResponseParametersFieldBuilder().addBuilder(
-            io.grpc.testing.integration.Messages.ResponseParameters.getDefaultInstance());
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public io.grpc.testing.integration.Messages.ResponseParameters.Builder addResponseParametersBuilder(
-          int index) {
-        return getResponseParametersFieldBuilder().addBuilder(
-            index, io.grpc.testing.integration.Messages.ResponseParameters.getDefaultInstance());
-      }
-      /**
-       * <pre>
-       * Configuration for each expected response message.
-       * </pre>
-       *
-       * <code>repeated .grpc.testing.ResponseParameters response_parameters = 2;</code>
-       */
-      public java.util.List<io.grpc.testing.integration.Messages.ResponseParameters.Builder> 
-           getResponseParametersBuilderList() {
-        return getResponseParametersFieldBuilder().getBuilderList();
-      }
-      private com.google.protobuf.RepeatedFieldBuilderV3<
-          io.grpc.testing.integration.Messages.ResponseParameters, io.grpc.testing.integration.Messages.ResponseParameters.Builder, io.grpc.testing.integration.Messages.ResponseParametersOrBuilder> 
-          getResponseParametersFieldBuilder() {
-        if (responseParametersBuilder_ == null) {
-          responseParametersBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3<
-              io.grpc.testing.integration.Messages.ResponseParameters, io.grpc.testing.integration.Messages.ResponseParameters.Builder, io.grpc.testing.integration.Messages.ResponseParametersOrBuilder>(
-                  responseParameters_,
-                  ((bitField0_ & 0x00000002) == 0x00000002),
-                  getParentForChildren(),
-                  isClean());
-          responseParameters_ = null;
-        }
-        return responseParametersBuilder_;
-      }
-
-      private io.grpc.testing.integration.Messages.Payload payload_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder> payloadBuilder_;
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public boolean hasPayload() {
-        return payloadBuilder_ != null || payload_ != null;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public io.grpc.testing.integration.Messages.Payload getPayload() {
-        if (payloadBuilder_ == null) {
-          return payload_ == null ? io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-        } else {
-          return payloadBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder setPayload(io.grpc.testing.integration.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payload_ = value;
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder setPayload(
-          io.grpc.testing.integration.Messages.Payload.Builder builderForValue) {
-        if (payloadBuilder_ == null) {
-          payload_ = builderForValue.build();
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder mergePayload(io.grpc.testing.integration.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (payload_ != null) {
-            payload_ =
-              io.grpc.testing.integration.Messages.Payload.newBuilder(payload_).mergeFrom(value).buildPartial();
-          } else {
-            payload_ = value;
-          }
-          onChanged();
-        } else {
-          payloadBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public Builder clearPayload() {
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-          onChanged();
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public io.grpc.testing.integration.Messages.Payload.Builder getPayloadBuilder() {
-        
-        onChanged();
-        return getPayloadFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      public io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-        if (payloadBuilder_ != null) {
-          return payloadBuilder_.getMessageOrBuilder();
-        } else {
-          return payload_ == null ?
-              io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-        }
-      }
-      /**
-       * <pre>
-       * Optional input payload sent along with the request.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 3;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder> 
-          getPayloadFieldBuilder() {
-        if (payloadBuilder_ == null) {
-          payloadBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder>(
-                  getPayload(),
-                  getParentForChildren(),
-                  isClean());
-          payload_ = null;
-        }
-        return payloadBuilder_;
-      }
-
-      private int responseCompression_ = 0;
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public int getResponseCompressionValue() {
-        return responseCompression_;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public Builder setResponseCompressionValue(int value) {
-        responseCompression_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public io.grpc.testing.integration.Messages.CompressionType getResponseCompression() {
-        io.grpc.testing.integration.Messages.CompressionType result = io.grpc.testing.integration.Messages.CompressionType.valueOf(responseCompression_);
-        return result == null ? io.grpc.testing.integration.Messages.CompressionType.UNRECOGNIZED : result;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public Builder setResponseCompression(io.grpc.testing.integration.Messages.CompressionType value) {
-        if (value == null) {
-          throw new NullPointerException();
-        }
-        
-        responseCompression_ = value.getNumber();
-        onChanged();
-        return this;
-      }
-      /**
-       * <pre>
-       * Compression algorithm to be used by the server for the response (stream)
-       * </pre>
-       *
-       * <code>.grpc.testing.CompressionType response_compression = 6;</code>
-       */
-      public Builder clearResponseCompression() {
-        
-        responseCompression_ = 0;
-        onChanged();
-        return this;
-      }
-
-      private io.grpc.testing.integration.Messages.EchoStatus responseStatus_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.EchoStatus, io.grpc.testing.integration.Messages.EchoStatus.Builder, io.grpc.testing.integration.Messages.EchoStatusOrBuilder> responseStatusBuilder_;
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public boolean hasResponseStatus() {
-        return responseStatusBuilder_ != null || responseStatus_ != null;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public io.grpc.testing.integration.Messages.EchoStatus getResponseStatus() {
-        if (responseStatusBuilder_ == null) {
-          return responseStatus_ == null ? io.grpc.testing.integration.Messages.EchoStatus.getDefaultInstance() : responseStatus_;
-        } else {
-          return responseStatusBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder setResponseStatus(io.grpc.testing.integration.Messages.EchoStatus value) {
-        if (responseStatusBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          responseStatus_ = value;
-          onChanged();
-        } else {
-          responseStatusBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder setResponseStatus(
-          io.grpc.testing.integration.Messages.EchoStatus.Builder builderForValue) {
-        if (responseStatusBuilder_ == null) {
-          responseStatus_ = builderForValue.build();
-          onChanged();
-        } else {
-          responseStatusBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder mergeResponseStatus(io.grpc.testing.integration.Messages.EchoStatus value) {
-        if (responseStatusBuilder_ == null) {
-          if (responseStatus_ != null) {
-            responseStatus_ =
-              io.grpc.testing.integration.Messages.EchoStatus.newBuilder(responseStatus_).mergeFrom(value).buildPartial();
-          } else {
-            responseStatus_ = value;
-          }
-          onChanged();
-        } else {
-          responseStatusBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public Builder clearResponseStatus() {
-        if (responseStatusBuilder_ == null) {
-          responseStatus_ = null;
-          onChanged();
-        } else {
-          responseStatus_ = null;
-          responseStatusBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public io.grpc.testing.integration.Messages.EchoStatus.Builder getResponseStatusBuilder() {
-        
-        onChanged();
-        return getResponseStatusFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      public io.grpc.testing.integration.Messages.EchoStatusOrBuilder getResponseStatusOrBuilder() {
-        if (responseStatusBuilder_ != null) {
-          return responseStatusBuilder_.getMessageOrBuilder();
-        } else {
-          return responseStatus_ == null ?
-              io.grpc.testing.integration.Messages.EchoStatus.getDefaultInstance() : responseStatus_;
-        }
-      }
-      /**
-       * <pre>
-       * Whether server should return a given status
-       * </pre>
-       *
-       * <code>.grpc.testing.EchoStatus response_status = 7;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.EchoStatus, io.grpc.testing.integration.Messages.EchoStatus.Builder, io.grpc.testing.integration.Messages.EchoStatusOrBuilder> 
-          getResponseStatusFieldBuilder() {
-        if (responseStatusBuilder_ == null) {
-          responseStatusBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.testing.integration.Messages.EchoStatus, io.grpc.testing.integration.Messages.EchoStatus.Builder, io.grpc.testing.integration.Messages.EchoStatusOrBuilder>(
-                  getResponseStatus(),
-                  getParentForChildren(),
-                  isClean());
-          responseStatus_ = null;
-        }
-        return responseStatusBuilder_;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.StreamingOutputCallRequest)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.StreamingOutputCallRequest)
-    private static final io.grpc.testing.integration.Messages.StreamingOutputCallRequest DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Messages.StreamingOutputCallRequest();
-    }
-
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallRequest getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<StreamingOutputCallRequest>
-        PARSER = new com.google.protobuf.AbstractParser<StreamingOutputCallRequest>() {
-      public StreamingOutputCallRequest parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new StreamingOutputCallRequest(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<StreamingOutputCallRequest> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<StreamingOutputCallRequest> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Messages.StreamingOutputCallRequest getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface StreamingOutputCallResponseOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.StreamingOutputCallResponse)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <pre>
-     * Payload to increase response size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    boolean hasPayload();
-    /**
-     * <pre>
-     * Payload to increase response size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    io.grpc.testing.integration.Messages.Payload getPayload();
-    /**
-     * <pre>
-     * Payload to increase response size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder();
-  }
-  /**
-   * <pre>
-   * Server-streaming response, as configured by the request and parameters.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.StreamingOutputCallResponse}
-   */
-  public  static final class StreamingOutputCallResponse extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.StreamingOutputCallResponse)
-      StreamingOutputCallResponseOrBuilder {
-    // Use StreamingOutputCallResponse.newBuilder() to construct.
-    private StreamingOutputCallResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private StreamingOutputCallResponse() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private StreamingOutputCallResponse(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              io.grpc.testing.integration.Messages.Payload.Builder subBuilder = null;
-              if (payload_ != null) {
-                subBuilder = payload_.toBuilder();
-              }
-              payload_ = input.readMessage(io.grpc.testing.integration.Messages.Payload.parser(), extensionRegistry);
-              if (subBuilder != null) {
-                subBuilder.mergeFrom(payload_);
-                payload_ = subBuilder.buildPartial();
-              }
-
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingOutputCallResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingOutputCallResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class, io.grpc.testing.integration.Messages.StreamingOutputCallResponse.Builder.class);
-    }
-
-    public static final int PAYLOAD_FIELD_NUMBER = 1;
-    private io.grpc.testing.integration.Messages.Payload payload_;
-    /**
-     * <pre>
-     * Payload to increase response size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public boolean hasPayload() {
-      return payload_ != null;
-    }
-    /**
-     * <pre>
-     * Payload to increase response size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public io.grpc.testing.integration.Messages.Payload getPayload() {
-      return payload_ == null ? io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-    }
-    /**
-     * <pre>
-     * Payload to increase response size.
-     * </pre>
-     *
-     * <code>.grpc.testing.Payload payload = 1;</code>
-     */
-    public io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-      return getPayload();
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (payload_ != null) {
-        output.writeMessage(1, getPayload());
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (payload_ != null) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeMessageSize(1, getPayload());
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Messages.StreamingOutputCallResponse)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Messages.StreamingOutputCallResponse other = (io.grpc.testing.integration.Messages.StreamingOutputCallResponse) obj;
-
-      boolean result = true;
-      result = result && (hasPayload() == other.hasPayload());
-      if (hasPayload()) {
-        result = result && getPayload()
-            .equals(other.getPayload());
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      if (hasPayload()) {
-        hash = (37 * hash) + PAYLOAD_FIELD_NUMBER;
-        hash = (53 * hash) + getPayload().hashCode();
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallResponse parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallResponse parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallResponse parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallResponse parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallResponse parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallResponse parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallResponse parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallResponse parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallResponse parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallResponse parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Messages.StreamingOutputCallResponse prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Server-streaming response, as configured by the request and parameters.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.StreamingOutputCallResponse}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.StreamingOutputCallResponse)
-        io.grpc.testing.integration.Messages.StreamingOutputCallResponseOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingOutputCallResponse_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingOutputCallResponse_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Messages.StreamingOutputCallResponse.class, io.grpc.testing.integration.Messages.StreamingOutputCallResponse.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Messages.StreamingOutputCallResponse.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_StreamingOutputCallResponse_descriptor;
-      }
-
-      public io.grpc.testing.integration.Messages.StreamingOutputCallResponse getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Messages.StreamingOutputCallResponse build() {
-        io.grpc.testing.integration.Messages.StreamingOutputCallResponse result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Messages.StreamingOutputCallResponse buildPartial() {
-        io.grpc.testing.integration.Messages.StreamingOutputCallResponse result = new io.grpc.testing.integration.Messages.StreamingOutputCallResponse(this);
-        if (payloadBuilder_ == null) {
-          result.payload_ = payload_;
-        } else {
-          result.payload_ = payloadBuilder_.build();
-        }
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Messages.StreamingOutputCallResponse) {
-          return mergeFrom((io.grpc.testing.integration.Messages.StreamingOutputCallResponse)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Messages.StreamingOutputCallResponse other) {
-        if (other == io.grpc.testing.integration.Messages.StreamingOutputCallResponse.getDefaultInstance()) return this;
-        if (other.hasPayload()) {
-          mergePayload(other.getPayload());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Messages.StreamingOutputCallResponse parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Messages.StreamingOutputCallResponse) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private io.grpc.testing.integration.Messages.Payload payload_ = null;
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder> payloadBuilder_;
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public boolean hasPayload() {
-        return payloadBuilder_ != null || payload_ != null;
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.testing.integration.Messages.Payload getPayload() {
-        if (payloadBuilder_ == null) {
-          return payload_ == null ? io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-        } else {
-          return payloadBuilder_.getMessage();
-        }
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder setPayload(io.grpc.testing.integration.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (value == null) {
-            throw new NullPointerException();
-          }
-          payload_ = value;
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder setPayload(
-          io.grpc.testing.integration.Messages.Payload.Builder builderForValue) {
-        if (payloadBuilder_ == null) {
-          payload_ = builderForValue.build();
-          onChanged();
-        } else {
-          payloadBuilder_.setMessage(builderForValue.build());
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder mergePayload(io.grpc.testing.integration.Messages.Payload value) {
-        if (payloadBuilder_ == null) {
-          if (payload_ != null) {
-            payload_ =
-              io.grpc.testing.integration.Messages.Payload.newBuilder(payload_).mergeFrom(value).buildPartial();
-          } else {
-            payload_ = value;
-          }
-          onChanged();
-        } else {
-          payloadBuilder_.mergeFrom(value);
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public Builder clearPayload() {
-        if (payloadBuilder_ == null) {
-          payload_ = null;
-          onChanged();
-        } else {
-          payload_ = null;
-          payloadBuilder_ = null;
-        }
-
-        return this;
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.testing.integration.Messages.Payload.Builder getPayloadBuilder() {
-        
-        onChanged();
-        return getPayloadFieldBuilder().getBuilder();
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      public io.grpc.testing.integration.Messages.PayloadOrBuilder getPayloadOrBuilder() {
-        if (payloadBuilder_ != null) {
-          return payloadBuilder_.getMessageOrBuilder();
-        } else {
-          return payload_ == null ?
-              io.grpc.testing.integration.Messages.Payload.getDefaultInstance() : payload_;
-        }
-      }
-      /**
-       * <pre>
-       * Payload to increase response size.
-       * </pre>
-       *
-       * <code>.grpc.testing.Payload payload = 1;</code>
-       */
-      private com.google.protobuf.SingleFieldBuilderV3<
-          io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder> 
-          getPayloadFieldBuilder() {
-        if (payloadBuilder_ == null) {
-          payloadBuilder_ = new com.google.protobuf.SingleFieldBuilderV3<
-              io.grpc.testing.integration.Messages.Payload, io.grpc.testing.integration.Messages.Payload.Builder, io.grpc.testing.integration.Messages.PayloadOrBuilder>(
-                  getPayload(),
-                  getParentForChildren(),
-                  isClean());
-          payload_ = null;
-        }
-        return payloadBuilder_;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.StreamingOutputCallResponse)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.StreamingOutputCallResponse)
-    private static final io.grpc.testing.integration.Messages.StreamingOutputCallResponse DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Messages.StreamingOutputCallResponse();
-    }
-
-    public static io.grpc.testing.integration.Messages.StreamingOutputCallResponse getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<StreamingOutputCallResponse>
-        PARSER = new com.google.protobuf.AbstractParser<StreamingOutputCallResponse>() {
-      public StreamingOutputCallResponse parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new StreamingOutputCallResponse(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<StreamingOutputCallResponse> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<StreamingOutputCallResponse> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Messages.StreamingOutputCallResponse getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ReconnectParamsOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ReconnectParams)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>int32 max_reconnect_backoff_ms = 1;</code>
-     */
-    int getMaxReconnectBackoffMs();
-  }
-  /**
-   * <pre>
-   * For reconnect interop test only.
-   * Client tells server what reconnection parameters it used.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.ReconnectParams}
-   */
-  public  static final class ReconnectParams extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ReconnectParams)
-      ReconnectParamsOrBuilder {
-    // Use ReconnectParams.newBuilder() to construct.
-    private ReconnectParams(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ReconnectParams() {
-      maxReconnectBackoffMs_ = 0;
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ReconnectParams(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              maxReconnectBackoffMs_ = input.readInt32();
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ReconnectParams_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ReconnectParams_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Messages.ReconnectParams.class, io.grpc.testing.integration.Messages.ReconnectParams.Builder.class);
-    }
-
-    public static final int MAX_RECONNECT_BACKOFF_MS_FIELD_NUMBER = 1;
-    private int maxReconnectBackoffMs_;
-    /**
-     * <code>int32 max_reconnect_backoff_ms = 1;</code>
-     */
-    public int getMaxReconnectBackoffMs() {
-      return maxReconnectBackoffMs_;
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (maxReconnectBackoffMs_ != 0) {
-        output.writeInt32(1, maxReconnectBackoffMs_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (maxReconnectBackoffMs_ != 0) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt32Size(1, maxReconnectBackoffMs_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Messages.ReconnectParams)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Messages.ReconnectParams other = (io.grpc.testing.integration.Messages.ReconnectParams) obj;
-
-      boolean result = true;
-      result = result && (getMaxReconnectBackoffMs()
-          == other.getMaxReconnectBackoffMs());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + MAX_RECONNECT_BACKOFF_MS_FIELD_NUMBER;
-      hash = (53 * hash) + getMaxReconnectBackoffMs();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Messages.ReconnectParams parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectParams parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectParams parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectParams parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectParams parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectParams parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectParams parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectParams parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectParams parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectParams parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Messages.ReconnectParams prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * For reconnect interop test only.
-     * Client tells server what reconnection parameters it used.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.ReconnectParams}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ReconnectParams)
-        io.grpc.testing.integration.Messages.ReconnectParamsOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ReconnectParams_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ReconnectParams_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Messages.ReconnectParams.class, io.grpc.testing.integration.Messages.ReconnectParams.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Messages.ReconnectParams.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        maxReconnectBackoffMs_ = 0;
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ReconnectParams_descriptor;
-      }
-
-      public io.grpc.testing.integration.Messages.ReconnectParams getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Messages.ReconnectParams.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Messages.ReconnectParams build() {
-        io.grpc.testing.integration.Messages.ReconnectParams result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Messages.ReconnectParams buildPartial() {
-        io.grpc.testing.integration.Messages.ReconnectParams result = new io.grpc.testing.integration.Messages.ReconnectParams(this);
-        result.maxReconnectBackoffMs_ = maxReconnectBackoffMs_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Messages.ReconnectParams) {
-          return mergeFrom((io.grpc.testing.integration.Messages.ReconnectParams)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Messages.ReconnectParams other) {
-        if (other == io.grpc.testing.integration.Messages.ReconnectParams.getDefaultInstance()) return this;
-        if (other.getMaxReconnectBackoffMs() != 0) {
-          setMaxReconnectBackoffMs(other.getMaxReconnectBackoffMs());
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Messages.ReconnectParams parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Messages.ReconnectParams) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private int maxReconnectBackoffMs_ ;
-      /**
-       * <code>int32 max_reconnect_backoff_ms = 1;</code>
-       */
-      public int getMaxReconnectBackoffMs() {
-        return maxReconnectBackoffMs_;
-      }
-      /**
-       * <code>int32 max_reconnect_backoff_ms = 1;</code>
-       */
-      public Builder setMaxReconnectBackoffMs(int value) {
-        
-        maxReconnectBackoffMs_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>int32 max_reconnect_backoff_ms = 1;</code>
-       */
-      public Builder clearMaxReconnectBackoffMs() {
-        
-        maxReconnectBackoffMs_ = 0;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ReconnectParams)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ReconnectParams)
-    private static final io.grpc.testing.integration.Messages.ReconnectParams DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Messages.ReconnectParams();
-    }
-
-    public static io.grpc.testing.integration.Messages.ReconnectParams getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ReconnectParams>
-        PARSER = new com.google.protobuf.AbstractParser<ReconnectParams>() {
-      public ReconnectParams parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ReconnectParams(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ReconnectParams> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ReconnectParams> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Messages.ReconnectParams getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface ReconnectInfoOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.ReconnectInfo)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>bool passed = 1;</code>
-     */
-    boolean getPassed();
-
-    /**
-     * <code>repeated int32 backoff_ms = 2;</code>
-     */
-    java.util.List<java.lang.Integer> getBackoffMsList();
-    /**
-     * <code>repeated int32 backoff_ms = 2;</code>
-     */
-    int getBackoffMsCount();
-    /**
-     * <code>repeated int32 backoff_ms = 2;</code>
-     */
-    int getBackoffMs(int index);
-  }
-  /**
-   * <pre>
-   * For reconnect interop test only.
-   * Server tells client whether its reconnects are following the spec and the
-   * reconnect backoffs it saw.
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.ReconnectInfo}
-   */
-  public  static final class ReconnectInfo extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.ReconnectInfo)
-      ReconnectInfoOrBuilder {
-    // Use ReconnectInfo.newBuilder() to construct.
-    private ReconnectInfo(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private ReconnectInfo() {
-      passed_ = false;
-      backoffMs_ = java.util.Collections.emptyList();
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private ReconnectInfo(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 8: {
-
-              passed_ = input.readBool();
-              break;
-            }
-            case 16: {
-              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
-                backoffMs_ = new java.util.ArrayList<java.lang.Integer>();
-                mutable_bitField0_ |= 0x00000002;
-              }
-              backoffMs_.add(input.readInt32());
-              break;
-            }
-            case 18: {
-              int length = input.readRawVarint32();
-              int limit = input.pushLimit(length);
-              if (!((mutable_bitField0_ & 0x00000002) == 0x00000002) && input.getBytesUntilLimit() > 0) {
-                backoffMs_ = new java.util.ArrayList<java.lang.Integer>();
-                mutable_bitField0_ |= 0x00000002;
-              }
-              while (input.getBytesUntilLimit() > 0) {
-                backoffMs_.add(input.readInt32());
-              }
-              input.popLimit(limit);
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        if (((mutable_bitField0_ & 0x00000002) == 0x00000002)) {
-          backoffMs_ = java.util.Collections.unmodifiableList(backoffMs_);
-        }
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ReconnectInfo_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ReconnectInfo_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Messages.ReconnectInfo.class, io.grpc.testing.integration.Messages.ReconnectInfo.Builder.class);
-    }
-
-    private int bitField0_;
-    public static final int PASSED_FIELD_NUMBER = 1;
-    private boolean passed_;
-    /**
-     * <code>bool passed = 1;</code>
-     */
-    public boolean getPassed() {
-      return passed_;
-    }
-
-    public static final int BACKOFF_MS_FIELD_NUMBER = 2;
-    private java.util.List<java.lang.Integer> backoffMs_;
-    /**
-     * <code>repeated int32 backoff_ms = 2;</code>
-     */
-    public java.util.List<java.lang.Integer>
-        getBackoffMsList() {
-      return backoffMs_;
-    }
-    /**
-     * <code>repeated int32 backoff_ms = 2;</code>
-     */
-    public int getBackoffMsCount() {
-      return backoffMs_.size();
-    }
-    /**
-     * <code>repeated int32 backoff_ms = 2;</code>
-     */
-    public int getBackoffMs(int index) {
-      return backoffMs_.get(index);
-    }
-    private int backoffMsMemoizedSerializedSize = -1;
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      getSerializedSize();
-      if (passed_ != false) {
-        output.writeBool(1, passed_);
-      }
-      if (getBackoffMsList().size() > 0) {
-        output.writeUInt32NoTag(18);
-        output.writeUInt32NoTag(backoffMsMemoizedSerializedSize);
-      }
-      for (int i = 0; i < backoffMs_.size(); i++) {
-        output.writeInt32NoTag(backoffMs_.get(i));
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (passed_ != false) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeBoolSize(1, passed_);
-      }
-      {
-        int dataSize = 0;
-        for (int i = 0; i < backoffMs_.size(); i++) {
-          dataSize += com.google.protobuf.CodedOutputStream
-            .computeInt32SizeNoTag(backoffMs_.get(i));
-        }
-        size += dataSize;
-        if (!getBackoffMsList().isEmpty()) {
-          size += 1;
-          size += com.google.protobuf.CodedOutputStream
-              .computeInt32SizeNoTag(dataSize);
-        }
-        backoffMsMemoizedSerializedSize = dataSize;
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Messages.ReconnectInfo)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Messages.ReconnectInfo other = (io.grpc.testing.integration.Messages.ReconnectInfo) obj;
-
-      boolean result = true;
-      result = result && (getPassed()
-          == other.getPassed());
-      result = result && getBackoffMsList()
-          .equals(other.getBackoffMsList());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + PASSED_FIELD_NUMBER;
-      hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(
-          getPassed());
-      if (getBackoffMsCount() > 0) {
-        hash = (37 * hash) + BACKOFF_MS_FIELD_NUMBER;
-        hash = (53 * hash) + getBackoffMsList().hashCode();
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Messages.ReconnectInfo parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectInfo parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectInfo parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectInfo parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectInfo parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectInfo parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectInfo parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectInfo parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectInfo parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Messages.ReconnectInfo parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Messages.ReconnectInfo prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * For reconnect interop test only.
-     * Server tells client whether its reconnects are following the spec and the
-     * reconnect backoffs it saw.
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.ReconnectInfo}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.ReconnectInfo)
-        io.grpc.testing.integration.Messages.ReconnectInfoOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ReconnectInfo_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ReconnectInfo_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Messages.ReconnectInfo.class, io.grpc.testing.integration.Messages.ReconnectInfo.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Messages.ReconnectInfo.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        passed_ = false;
-
-        backoffMs_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000002);
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Messages.internal_static_grpc_testing_ReconnectInfo_descriptor;
-      }
-
-      public io.grpc.testing.integration.Messages.ReconnectInfo getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Messages.ReconnectInfo.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Messages.ReconnectInfo build() {
-        io.grpc.testing.integration.Messages.ReconnectInfo result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Messages.ReconnectInfo buildPartial() {
-        io.grpc.testing.integration.Messages.ReconnectInfo result = new io.grpc.testing.integration.Messages.ReconnectInfo(this);
-        int from_bitField0_ = bitField0_;
-        int to_bitField0_ = 0;
-        result.passed_ = passed_;
-        if (((bitField0_ & 0x00000002) == 0x00000002)) {
-          backoffMs_ = java.util.Collections.unmodifiableList(backoffMs_);
-          bitField0_ = (bitField0_ & ~0x00000002);
-        }
-        result.backoffMs_ = backoffMs_;
-        result.bitField0_ = to_bitField0_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Messages.ReconnectInfo) {
-          return mergeFrom((io.grpc.testing.integration.Messages.ReconnectInfo)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Messages.ReconnectInfo other) {
-        if (other == io.grpc.testing.integration.Messages.ReconnectInfo.getDefaultInstance()) return this;
-        if (other.getPassed() != false) {
-          setPassed(other.getPassed());
-        }
-        if (!other.backoffMs_.isEmpty()) {
-          if (backoffMs_.isEmpty()) {
-            backoffMs_ = other.backoffMs_;
-            bitField0_ = (bitField0_ & ~0x00000002);
-          } else {
-            ensureBackoffMsIsMutable();
-            backoffMs_.addAll(other.backoffMs_);
-          }
-          onChanged();
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Messages.ReconnectInfo parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Messages.ReconnectInfo) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      private int bitField0_;
-
-      private boolean passed_ ;
-      /**
-       * <code>bool passed = 1;</code>
-       */
-      public boolean getPassed() {
-        return passed_;
-      }
-      /**
-       * <code>bool passed = 1;</code>
-       */
-      public Builder setPassed(boolean value) {
-        
-        passed_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>bool passed = 1;</code>
-       */
-      public Builder clearPassed() {
-        
-        passed_ = false;
-        onChanged();
-        return this;
-      }
-
-      private java.util.List<java.lang.Integer> backoffMs_ = java.util.Collections.emptyList();
-      private void ensureBackoffMsIsMutable() {
-        if (!((bitField0_ & 0x00000002) == 0x00000002)) {
-          backoffMs_ = new java.util.ArrayList<java.lang.Integer>(backoffMs_);
-          bitField0_ |= 0x00000002;
-         }
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public java.util.List<java.lang.Integer>
-          getBackoffMsList() {
-        return java.util.Collections.unmodifiableList(backoffMs_);
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public int getBackoffMsCount() {
-        return backoffMs_.size();
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public int getBackoffMs(int index) {
-        return backoffMs_.get(index);
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public Builder setBackoffMs(
-          int index, int value) {
-        ensureBackoffMsIsMutable();
-        backoffMs_.set(index, value);
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public Builder addBackoffMs(int value) {
-        ensureBackoffMsIsMutable();
-        backoffMs_.add(value);
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public Builder addAllBackoffMs(
-          java.lang.Iterable<? extends java.lang.Integer> values) {
-        ensureBackoffMsIsMutable();
-        com.google.protobuf.AbstractMessageLite.Builder.addAll(
-            values, backoffMs_);
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>repeated int32 backoff_ms = 2;</code>
-       */
-      public Builder clearBackoffMs() {
-        backoffMs_ = java.util.Collections.emptyList();
-        bitField0_ = (bitField0_ & ~0x00000002);
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.ReconnectInfo)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.ReconnectInfo)
-    private static final io.grpc.testing.integration.Messages.ReconnectInfo DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Messages.ReconnectInfo();
-    }
-
-    public static io.grpc.testing.integration.Messages.ReconnectInfo getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<ReconnectInfo>
-        PARSER = new com.google.protobuf.AbstractParser<ReconnectInfo>() {
-      public ReconnectInfo parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new ReconnectInfo(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<ReconnectInfo> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<ReconnectInfo> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Messages.ReconnectInfo getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_Payload_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_Payload_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_EchoStatus_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_EchoStatus_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_SimpleRequest_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_SimpleRequest_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_SimpleResponse_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_SimpleResponse_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_SimpleContext_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_SimpleContext_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_StreamingInputCallRequest_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_StreamingInputCallRequest_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_StreamingInputCallResponse_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_StreamingInputCallResponse_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ResponseParameters_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ResponseParameters_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_StreamingOutputCallRequest_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_StreamingOutputCallRequest_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_StreamingOutputCallResponse_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_StreamingOutputCallResponse_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ReconnectParams_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ReconnectParams_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_ReconnectInfo_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_ReconnectInfo_fieldAccessorTable;
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n*io/grpc/testing/integration/messages.p" +
-      "roto\022\014grpc.testing\"@\n\007Payload\022\'\n\004type\030\001 " +
-      "\001(\0162\031.grpc.testing.PayloadType\022\014\n\004body\030\002" +
-      " \001(\014\"+\n\nEchoStatus\022\014\n\004code\030\001 \001(\005\022\017\n\007mess" +
-      "age\030\002 \001(\t\"\241\002\n\rSimpleRequest\0220\n\rresponse_" +
-      "type\030\001 \001(\0162\031.grpc.testing.PayloadType\022\025\n" +
-      "\rresponse_size\030\002 \001(\005\022&\n\007payload\030\003 \001(\0132\025." +
-      "grpc.testing.Payload\022\025\n\rfill_username\030\004 " +
-      "\001(\010\022\030\n\020fill_oauth_scope\030\005 \001(\010\022;\n\024respons" +
-      "e_compression\030\006 \001(\0162\035.grpc.testing.Compr",
-      "essionType\0221\n\017response_status\030\007 \001(\0132\030.gr" +
-      "pc.testing.EchoStatus\"_\n\016SimpleResponse\022" +
-      "&\n\007payload\030\001 \001(\0132\025.grpc.testing.Payload\022" +
-      "\020\n\010username\030\002 \001(\t\022\023\n\013oauth_scope\030\003 \001(\t\"\036" +
-      "\n\rSimpleContext\022\r\n\005value\030\001 \001(\t\"C\n\031Stream" +
-      "ingInputCallRequest\022&\n\007payload\030\001 \001(\0132\025.g" +
-      "rpc.testing.Payload\"=\n\032StreamingInputCal" +
-      "lResponse\022\037\n\027aggregated_payload_size\030\001 \001" +
-      "(\005\"7\n\022ResponseParameters\022\014\n\004size\030\001 \001(\005\022\023" +
-      "\n\013interval_us\030\002 \001(\005\"\245\002\n\032StreamingOutputC",
-      "allRequest\0220\n\rresponse_type\030\001 \001(\0162\031.grpc" +
-      ".testing.PayloadType\022=\n\023response_paramet" +
-      "ers\030\002 \003(\0132 .grpc.testing.ResponseParamet" +
-      "ers\022&\n\007payload\030\003 \001(\0132\025.grpc.testing.Payl" +
-      "oad\022;\n\024response_compression\030\006 \001(\0162\035.grpc" +
-      ".testing.CompressionType\0221\n\017response_sta" +
-      "tus\030\007 \001(\0132\030.grpc.testing.EchoStatus\"E\n\033S" +
-      "treamingOutputCallResponse\022&\n\007payload\030\001 " +
-      "\001(\0132\025.grpc.testing.Payload\"3\n\017ReconnectP" +
-      "arams\022 \n\030max_reconnect_backoff_ms\030\001 \001(\005\"",
-      "3\n\rReconnectInfo\022\016\n\006passed\030\001 \001(\010\022\022\n\nback" +
-      "off_ms\030\002 \003(\005*?\n\013PayloadType\022\020\n\014COMPRESSA" +
-      "BLE\020\000\022\022\n\016UNCOMPRESSABLE\020\001\022\n\n\006RANDOM\020\002*2\n" +
-      "\017CompressionType\022\010\n\004NONE\020\000\022\010\n\004GZIP\020\001\022\013\n\007" +
-      "DEFLATE\020\002B\035\n\033io.grpc.testing.integration" +
-      "b\006proto3"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-        }, assigner);
-    internal_static_grpc_testing_Payload_descriptor =
-      getDescriptor().getMessageTypes().get(0);
-    internal_static_grpc_testing_Payload_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_Payload_descriptor,
-        new java.lang.String[] { "Type", "Body", });
-    internal_static_grpc_testing_EchoStatus_descriptor =
-      getDescriptor().getMessageTypes().get(1);
-    internal_static_grpc_testing_EchoStatus_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_EchoStatus_descriptor,
-        new java.lang.String[] { "Code", "Message", });
-    internal_static_grpc_testing_SimpleRequest_descriptor =
-      getDescriptor().getMessageTypes().get(2);
-    internal_static_grpc_testing_SimpleRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_SimpleRequest_descriptor,
-        new java.lang.String[] { "ResponseType", "ResponseSize", "Payload", "FillUsername", "FillOauthScope", "ResponseCompression", "ResponseStatus", });
-    internal_static_grpc_testing_SimpleResponse_descriptor =
-      getDescriptor().getMessageTypes().get(3);
-    internal_static_grpc_testing_SimpleResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_SimpleResponse_descriptor,
-        new java.lang.String[] { "Payload", "Username", "OauthScope", });
-    internal_static_grpc_testing_SimpleContext_descriptor =
-      getDescriptor().getMessageTypes().get(4);
-    internal_static_grpc_testing_SimpleContext_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_SimpleContext_descriptor,
-        new java.lang.String[] { "Value", });
-    internal_static_grpc_testing_StreamingInputCallRequest_descriptor =
-      getDescriptor().getMessageTypes().get(5);
-    internal_static_grpc_testing_StreamingInputCallRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_StreamingInputCallRequest_descriptor,
-        new java.lang.String[] { "Payload", });
-    internal_static_grpc_testing_StreamingInputCallResponse_descriptor =
-      getDescriptor().getMessageTypes().get(6);
-    internal_static_grpc_testing_StreamingInputCallResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_StreamingInputCallResponse_descriptor,
-        new java.lang.String[] { "AggregatedPayloadSize", });
-    internal_static_grpc_testing_ResponseParameters_descriptor =
-      getDescriptor().getMessageTypes().get(7);
-    internal_static_grpc_testing_ResponseParameters_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ResponseParameters_descriptor,
-        new java.lang.String[] { "Size", "IntervalUs", });
-    internal_static_grpc_testing_StreamingOutputCallRequest_descriptor =
-      getDescriptor().getMessageTypes().get(8);
-    internal_static_grpc_testing_StreamingOutputCallRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_StreamingOutputCallRequest_descriptor,
-        new java.lang.String[] { "ResponseType", "ResponseParameters", "Payload", "ResponseCompression", "ResponseStatus", });
-    internal_static_grpc_testing_StreamingOutputCallResponse_descriptor =
-      getDescriptor().getMessageTypes().get(9);
-    internal_static_grpc_testing_StreamingOutputCallResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_StreamingOutputCallResponse_descriptor,
-        new java.lang.String[] { "Payload", });
-    internal_static_grpc_testing_ReconnectParams_descriptor =
-      getDescriptor().getMessageTypes().get(10);
-    internal_static_grpc_testing_ReconnectParams_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ReconnectParams_descriptor,
-        new java.lang.String[] { "MaxReconnectBackoffMs", });
-    internal_static_grpc_testing_ReconnectInfo_descriptor =
-      getDescriptor().getMessageTypes().get(11);
-    internal_static_grpc_testing_ReconnectInfo_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_ReconnectInfo_descriptor,
-        new java.lang.String[] { "Passed", "BackoffMs", });
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/testing-proto/src/generated/main/java/io/grpc/testing/integration/Metrics.java b/testing-proto/src/generated/main/java/io/grpc/testing/integration/Metrics.java
deleted file mode 100644
index 347d36dca9e..00000000000
--- a/testing-proto/src/generated/main/java/io/grpc/testing/integration/Metrics.java
+++ /dev/null
@@ -1,1865 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/testing/integration/metrics.proto
-
-package io.grpc.testing.integration;
-
-public final class Metrics {
-  private Metrics() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-  public interface GaugeResponseOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.GaugeResponse)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>string name = 1;</code>
-     */
-    java.lang.String getName();
-    /**
-     * <code>string name = 1;</code>
-     */
-    com.google.protobuf.ByteString
-        getNameBytes();
-
-    /**
-     * <code>int64 long_value = 2;</code>
-     */
-    long getLongValue();
-
-    /**
-     * <code>double double_value = 3;</code>
-     */
-    double getDoubleValue();
-
-    /**
-     * <code>string string_value = 4;</code>
-     */
-    java.lang.String getStringValue();
-    /**
-     * <code>string string_value = 4;</code>
-     */
-    com.google.protobuf.ByteString
-        getStringValueBytes();
-
-    public io.grpc.testing.integration.Metrics.GaugeResponse.ValueCase getValueCase();
-  }
-  /**
-   * <pre>
-   * Reponse message containing the gauge name and value
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.GaugeResponse}
-   */
-  public  static final class GaugeResponse extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.GaugeResponse)
-      GaugeResponseOrBuilder {
-    // Use GaugeResponse.newBuilder() to construct.
-    private GaugeResponse(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private GaugeResponse() {
-      name_ = "";
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private GaugeResponse(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              java.lang.String s = input.readStringRequireUtf8();
-
-              name_ = s;
-              break;
-            }
-            case 16: {
-              valueCase_ = 2;
-              value_ = input.readInt64();
-              break;
-            }
-            case 25: {
-              valueCase_ = 3;
-              value_ = input.readDouble();
-              break;
-            }
-            case 34: {
-              java.lang.String s = input.readStringRequireUtf8();
-              valueCase_ = 4;
-              value_ = s;
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_GaugeResponse_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_GaugeResponse_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Metrics.GaugeResponse.class, io.grpc.testing.integration.Metrics.GaugeResponse.Builder.class);
-    }
-
-    private int valueCase_ = 0;
-    private java.lang.Object value_;
-    public enum ValueCase
-        implements com.google.protobuf.Internal.EnumLite {
-      LONG_VALUE(2),
-      DOUBLE_VALUE(3),
-      STRING_VALUE(4),
-      VALUE_NOT_SET(0);
-      private final int value;
-      private ValueCase(int value) {
-        this.value = value;
-      }
-      /**
-       * @deprecated Use {@link #forNumber(int)} instead.
-       */
-      @java.lang.Deprecated
-      public static ValueCase valueOf(int value) {
-        return forNumber(value);
-      }
-
-      public static ValueCase forNumber(int value) {
-        switch (value) {
-          case 2: return LONG_VALUE;
-          case 3: return DOUBLE_VALUE;
-          case 4: return STRING_VALUE;
-          case 0: return VALUE_NOT_SET;
-          default: return null;
-        }
-      }
-      public int getNumber() {
-        return this.value;
-      }
-    };
-
-    public ValueCase
-    getValueCase() {
-      return ValueCase.forNumber(
-          valueCase_);
-    }
-
-    public static final int NAME_FIELD_NUMBER = 1;
-    private volatile java.lang.Object name_;
-    /**
-     * <code>string name = 1;</code>
-     */
-    public java.lang.String getName() {
-      java.lang.Object ref = name_;
-      if (ref instanceof java.lang.String) {
-        return (java.lang.String) ref;
-      } else {
-        com.google.protobuf.ByteString bs = 
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        name_ = s;
-        return s;
-      }
-    }
-    /**
-     * <code>string name = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getNameBytes() {
-      java.lang.Object ref = name_;
-      if (ref instanceof java.lang.String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        name_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-
-    public static final int LONG_VALUE_FIELD_NUMBER = 2;
-    /**
-     * <code>int64 long_value = 2;</code>
-     */
-    public long getLongValue() {
-      if (valueCase_ == 2) {
-        return (java.lang.Long) value_;
-      }
-      return 0L;
-    }
-
-    public static final int DOUBLE_VALUE_FIELD_NUMBER = 3;
-    /**
-     * <code>double double_value = 3;</code>
-     */
-    public double getDoubleValue() {
-      if (valueCase_ == 3) {
-        return (java.lang.Double) value_;
-      }
-      return 0D;
-    }
-
-    public static final int STRING_VALUE_FIELD_NUMBER = 4;
-    /**
-     * <code>string string_value = 4;</code>
-     */
-    public java.lang.String getStringValue() {
-      java.lang.Object ref = "";
-      if (valueCase_ == 4) {
-        ref = value_;
-      }
-      if (ref instanceof java.lang.String) {
-        return (java.lang.String) ref;
-      } else {
-        com.google.protobuf.ByteString bs = 
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        if (valueCase_ == 4) {
-          value_ = s;
-        }
-        return s;
-      }
-    }
-    /**
-     * <code>string string_value = 4;</code>
-     */
-    public com.google.protobuf.ByteString
-        getStringValueBytes() {
-      java.lang.Object ref = "";
-      if (valueCase_ == 4) {
-        ref = value_;
-      }
-      if (ref instanceof java.lang.String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        if (valueCase_ == 4) {
-          value_ = b;
-        }
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (!getNameBytes().isEmpty()) {
-        com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_);
-      }
-      if (valueCase_ == 2) {
-        output.writeInt64(
-            2, (long)((java.lang.Long) value_));
-      }
-      if (valueCase_ == 3) {
-        output.writeDouble(
-            3, (double)((java.lang.Double) value_));
-      }
-      if (valueCase_ == 4) {
-        com.google.protobuf.GeneratedMessageV3.writeString(output, 4, value_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (!getNameBytes().isEmpty()) {
-        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_);
-      }
-      if (valueCase_ == 2) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeInt64Size(
-              2, (long)((java.lang.Long) value_));
-      }
-      if (valueCase_ == 3) {
-        size += com.google.protobuf.CodedOutputStream
-          .computeDoubleSize(
-              3, (double)((java.lang.Double) value_));
-      }
-      if (valueCase_ == 4) {
-        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, value_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Metrics.GaugeResponse)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Metrics.GaugeResponse other = (io.grpc.testing.integration.Metrics.GaugeResponse) obj;
-
-      boolean result = true;
-      result = result && getName()
-          .equals(other.getName());
-      result = result && getValueCase().equals(
-          other.getValueCase());
-      if (!result) return false;
-      switch (valueCase_) {
-        case 2:
-          result = result && (getLongValue()
-              == other.getLongValue());
-          break;
-        case 3:
-          result = result && (
-              java.lang.Double.doubleToLongBits(getDoubleValue())
-              == java.lang.Double.doubleToLongBits(
-                  other.getDoubleValue()));
-          break;
-        case 4:
-          result = result && getStringValue()
-              .equals(other.getStringValue());
-          break;
-        case 0:
-        default:
-      }
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + NAME_FIELD_NUMBER;
-      hash = (53 * hash) + getName().hashCode();
-      switch (valueCase_) {
-        case 2:
-          hash = (37 * hash) + LONG_VALUE_FIELD_NUMBER;
-          hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-              getLongValue());
-          break;
-        case 3:
-          hash = (37 * hash) + DOUBLE_VALUE_FIELD_NUMBER;
-          hash = (53 * hash) + com.google.protobuf.Internal.hashLong(
-              java.lang.Double.doubleToLongBits(getDoubleValue()));
-          break;
-        case 4:
-          hash = (37 * hash) + STRING_VALUE_FIELD_NUMBER;
-          hash = (53 * hash) + getStringValue().hashCode();
-          break;
-        case 0:
-        default:
-      }
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Metrics.GaugeResponse parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeResponse parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeResponse parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeResponse parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeResponse parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeResponse parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeResponse parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeResponse parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeResponse parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeResponse parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Metrics.GaugeResponse prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Reponse message containing the gauge name and value
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.GaugeResponse}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.GaugeResponse)
-        io.grpc.testing.integration.Metrics.GaugeResponseOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_GaugeResponse_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_GaugeResponse_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Metrics.GaugeResponse.class, io.grpc.testing.integration.Metrics.GaugeResponse.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Metrics.GaugeResponse.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        name_ = "";
-
-        valueCase_ = 0;
-        value_ = null;
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_GaugeResponse_descriptor;
-      }
-
-      public io.grpc.testing.integration.Metrics.GaugeResponse getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Metrics.GaugeResponse build() {
-        io.grpc.testing.integration.Metrics.GaugeResponse result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Metrics.GaugeResponse buildPartial() {
-        io.grpc.testing.integration.Metrics.GaugeResponse result = new io.grpc.testing.integration.Metrics.GaugeResponse(this);
-        result.name_ = name_;
-        if (valueCase_ == 2) {
-          result.value_ = value_;
-        }
-        if (valueCase_ == 3) {
-          result.value_ = value_;
-        }
-        if (valueCase_ == 4) {
-          result.value_ = value_;
-        }
-        result.valueCase_ = valueCase_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Metrics.GaugeResponse) {
-          return mergeFrom((io.grpc.testing.integration.Metrics.GaugeResponse)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Metrics.GaugeResponse other) {
-        if (other == io.grpc.testing.integration.Metrics.GaugeResponse.getDefaultInstance()) return this;
-        if (!other.getName().isEmpty()) {
-          name_ = other.name_;
-          onChanged();
-        }
-        switch (other.getValueCase()) {
-          case LONG_VALUE: {
-            setLongValue(other.getLongValue());
-            break;
-          }
-          case DOUBLE_VALUE: {
-            setDoubleValue(other.getDoubleValue());
-            break;
-          }
-          case STRING_VALUE: {
-            valueCase_ = 4;
-            value_ = other.value_;
-            onChanged();
-            break;
-          }
-          case VALUE_NOT_SET: {
-            break;
-          }
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Metrics.GaugeResponse parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Metrics.GaugeResponse) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      private int valueCase_ = 0;
-      private java.lang.Object value_;
-      public ValueCase
-          getValueCase() {
-        return ValueCase.forNumber(
-            valueCase_);
-      }
-
-      public Builder clearValue() {
-        valueCase_ = 0;
-        value_ = null;
-        onChanged();
-        return this;
-      }
-
-
-      private java.lang.Object name_ = "";
-      /**
-       * <code>string name = 1;</code>
-       */
-      public java.lang.String getName() {
-        java.lang.Object ref = name_;
-        if (!(ref instanceof java.lang.String)) {
-          com.google.protobuf.ByteString bs =
-              (com.google.protobuf.ByteString) ref;
-          java.lang.String s = bs.toStringUtf8();
-          name_ = s;
-          return s;
-        } else {
-          return (java.lang.String) ref;
-        }
-      }
-      /**
-       * <code>string name = 1;</code>
-       */
-      public com.google.protobuf.ByteString
-          getNameBytes() {
-        java.lang.Object ref = name_;
-        if (ref instanceof String) {
-          com.google.protobuf.ByteString b = 
-              com.google.protobuf.ByteString.copyFromUtf8(
-                  (java.lang.String) ref);
-          name_ = b;
-          return b;
-        } else {
-          return (com.google.protobuf.ByteString) ref;
-        }
-      }
-      /**
-       * <code>string name = 1;</code>
-       */
-      public Builder setName(
-          java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  
-        name_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>string name = 1;</code>
-       */
-      public Builder clearName() {
-        
-        name_ = getDefaultInstance().getName();
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>string name = 1;</code>
-       */
-      public Builder setNameBytes(
-          com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-        
-        name_ = value;
-        onChanged();
-        return this;
-      }
-
-      /**
-       * <code>int64 long_value = 2;</code>
-       */
-      public long getLongValue() {
-        if (valueCase_ == 2) {
-          return (java.lang.Long) value_;
-        }
-        return 0L;
-      }
-      /**
-       * <code>int64 long_value = 2;</code>
-       */
-      public Builder setLongValue(long value) {
-        valueCase_ = 2;
-        value_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>int64 long_value = 2;</code>
-       */
-      public Builder clearLongValue() {
-        if (valueCase_ == 2) {
-          valueCase_ = 0;
-          value_ = null;
-          onChanged();
-        }
-        return this;
-      }
-
-      /**
-       * <code>double double_value = 3;</code>
-       */
-      public double getDoubleValue() {
-        if (valueCase_ == 3) {
-          return (java.lang.Double) value_;
-        }
-        return 0D;
-      }
-      /**
-       * <code>double double_value = 3;</code>
-       */
-      public Builder setDoubleValue(double value) {
-        valueCase_ = 3;
-        value_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>double double_value = 3;</code>
-       */
-      public Builder clearDoubleValue() {
-        if (valueCase_ == 3) {
-          valueCase_ = 0;
-          value_ = null;
-          onChanged();
-        }
-        return this;
-      }
-
-      /**
-       * <code>string string_value = 4;</code>
-       */
-      public java.lang.String getStringValue() {
-        java.lang.Object ref = "";
-        if (valueCase_ == 4) {
-          ref = value_;
-        }
-        if (!(ref instanceof java.lang.String)) {
-          com.google.protobuf.ByteString bs =
-              (com.google.protobuf.ByteString) ref;
-          java.lang.String s = bs.toStringUtf8();
-          if (valueCase_ == 4) {
-            value_ = s;
-          }
-          return s;
-        } else {
-          return (java.lang.String) ref;
-        }
-      }
-      /**
-       * <code>string string_value = 4;</code>
-       */
-      public com.google.protobuf.ByteString
-          getStringValueBytes() {
-        java.lang.Object ref = "";
-        if (valueCase_ == 4) {
-          ref = value_;
-        }
-        if (ref instanceof String) {
-          com.google.protobuf.ByteString b = 
-              com.google.protobuf.ByteString.copyFromUtf8(
-                  (java.lang.String) ref);
-          if (valueCase_ == 4) {
-            value_ = b;
-          }
-          return b;
-        } else {
-          return (com.google.protobuf.ByteString) ref;
-        }
-      }
-      /**
-       * <code>string string_value = 4;</code>
-       */
-      public Builder setStringValue(
-          java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  valueCase_ = 4;
-        value_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>string string_value = 4;</code>
-       */
-      public Builder clearStringValue() {
-        if (valueCase_ == 4) {
-          valueCase_ = 0;
-          value_ = null;
-          onChanged();
-        }
-        return this;
-      }
-      /**
-       * <code>string string_value = 4;</code>
-       */
-      public Builder setStringValueBytes(
-          com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-        valueCase_ = 4;
-        value_ = value;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.GaugeResponse)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.GaugeResponse)
-    private static final io.grpc.testing.integration.Metrics.GaugeResponse DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Metrics.GaugeResponse();
-    }
-
-    public static io.grpc.testing.integration.Metrics.GaugeResponse getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<GaugeResponse>
-        PARSER = new com.google.protobuf.AbstractParser<GaugeResponse>() {
-      public GaugeResponse parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new GaugeResponse(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<GaugeResponse> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<GaugeResponse> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Metrics.GaugeResponse getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface GaugeRequestOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.GaugeRequest)
-      com.google.protobuf.MessageOrBuilder {
-
-    /**
-     * <code>string name = 1;</code>
-     */
-    java.lang.String getName();
-    /**
-     * <code>string name = 1;</code>
-     */
-    com.google.protobuf.ByteString
-        getNameBytes();
-  }
-  /**
-   * <pre>
-   * Request message containing the gauge name
-   * </pre>
-   *
-   * Protobuf type {@code grpc.testing.GaugeRequest}
-   */
-  public  static final class GaugeRequest extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.GaugeRequest)
-      GaugeRequestOrBuilder {
-    // Use GaugeRequest.newBuilder() to construct.
-    private GaugeRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private GaugeRequest() {
-      name_ = "";
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private GaugeRequest(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      int mutable_bitField0_ = 0;
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-            case 10: {
-              java.lang.String s = input.readStringRequireUtf8();
-
-              name_ = s;
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_GaugeRequest_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_GaugeRequest_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Metrics.GaugeRequest.class, io.grpc.testing.integration.Metrics.GaugeRequest.Builder.class);
-    }
-
-    public static final int NAME_FIELD_NUMBER = 1;
-    private volatile java.lang.Object name_;
-    /**
-     * <code>string name = 1;</code>
-     */
-    public java.lang.String getName() {
-      java.lang.Object ref = name_;
-      if (ref instanceof java.lang.String) {
-        return (java.lang.String) ref;
-      } else {
-        com.google.protobuf.ByteString bs = 
-            (com.google.protobuf.ByteString) ref;
-        java.lang.String s = bs.toStringUtf8();
-        name_ = s;
-        return s;
-      }
-    }
-    /**
-     * <code>string name = 1;</code>
-     */
-    public com.google.protobuf.ByteString
-        getNameBytes() {
-      java.lang.Object ref = name_;
-      if (ref instanceof java.lang.String) {
-        com.google.protobuf.ByteString b = 
-            com.google.protobuf.ByteString.copyFromUtf8(
-                (java.lang.String) ref);
-        name_ = b;
-        return b;
-      } else {
-        return (com.google.protobuf.ByteString) ref;
-      }
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-      if (!getNameBytes().isEmpty()) {
-        com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_);
-      }
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      if (!getNameBytes().isEmpty()) {
-        size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_);
-      }
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Metrics.GaugeRequest)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Metrics.GaugeRequest other = (io.grpc.testing.integration.Metrics.GaugeRequest) obj;
-
-      boolean result = true;
-      result = result && getName()
-          .equals(other.getName());
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (37 * hash) + NAME_FIELD_NUMBER;
-      hash = (53 * hash) + getName().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Metrics.GaugeRequest parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeRequest parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeRequest parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeRequest parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeRequest parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeRequest parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeRequest parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeRequest parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeRequest parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Metrics.GaugeRequest parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Metrics.GaugeRequest prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * <pre>
-     * Request message containing the gauge name
-     * </pre>
-     *
-     * Protobuf type {@code grpc.testing.GaugeRequest}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.GaugeRequest)
-        io.grpc.testing.integration.Metrics.GaugeRequestOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_GaugeRequest_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_GaugeRequest_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Metrics.GaugeRequest.class, io.grpc.testing.integration.Metrics.GaugeRequest.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Metrics.GaugeRequest.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        name_ = "";
-
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_GaugeRequest_descriptor;
-      }
-
-      public io.grpc.testing.integration.Metrics.GaugeRequest getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Metrics.GaugeRequest.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Metrics.GaugeRequest build() {
-        io.grpc.testing.integration.Metrics.GaugeRequest result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Metrics.GaugeRequest buildPartial() {
-        io.grpc.testing.integration.Metrics.GaugeRequest result = new io.grpc.testing.integration.Metrics.GaugeRequest(this);
-        result.name_ = name_;
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Metrics.GaugeRequest) {
-          return mergeFrom((io.grpc.testing.integration.Metrics.GaugeRequest)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Metrics.GaugeRequest other) {
-        if (other == io.grpc.testing.integration.Metrics.GaugeRequest.getDefaultInstance()) return this;
-        if (!other.getName().isEmpty()) {
-          name_ = other.name_;
-          onChanged();
-        }
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Metrics.GaugeRequest parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Metrics.GaugeRequest) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-
-      private java.lang.Object name_ = "";
-      /**
-       * <code>string name = 1;</code>
-       */
-      public java.lang.String getName() {
-        java.lang.Object ref = name_;
-        if (!(ref instanceof java.lang.String)) {
-          com.google.protobuf.ByteString bs =
-              (com.google.protobuf.ByteString) ref;
-          java.lang.String s = bs.toStringUtf8();
-          name_ = s;
-          return s;
-        } else {
-          return (java.lang.String) ref;
-        }
-      }
-      /**
-       * <code>string name = 1;</code>
-       */
-      public com.google.protobuf.ByteString
-          getNameBytes() {
-        java.lang.Object ref = name_;
-        if (ref instanceof String) {
-          com.google.protobuf.ByteString b = 
-              com.google.protobuf.ByteString.copyFromUtf8(
-                  (java.lang.String) ref);
-          name_ = b;
-          return b;
-        } else {
-          return (com.google.protobuf.ByteString) ref;
-        }
-      }
-      /**
-       * <code>string name = 1;</code>
-       */
-      public Builder setName(
-          java.lang.String value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  
-        name_ = value;
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>string name = 1;</code>
-       */
-      public Builder clearName() {
-        
-        name_ = getDefaultInstance().getName();
-        onChanged();
-        return this;
-      }
-      /**
-       * <code>string name = 1;</code>
-       */
-      public Builder setNameBytes(
-          com.google.protobuf.ByteString value) {
-        if (value == null) {
-    throw new NullPointerException();
-  }
-  checkByteStringIsUtf8(value);
-        
-        name_ = value;
-        onChanged();
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.GaugeRequest)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.GaugeRequest)
-    private static final io.grpc.testing.integration.Metrics.GaugeRequest DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Metrics.GaugeRequest();
-    }
-
-    public static io.grpc.testing.integration.Metrics.GaugeRequest getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<GaugeRequest>
-        PARSER = new com.google.protobuf.AbstractParser<GaugeRequest>() {
-      public GaugeRequest parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new GaugeRequest(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<GaugeRequest> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<GaugeRequest> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Metrics.GaugeRequest getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  public interface EmptyMessageOrBuilder extends
-      // @@protoc_insertion_point(interface_extends:grpc.testing.EmptyMessage)
-      com.google.protobuf.MessageOrBuilder {
-  }
-  /**
-   * Protobuf type {@code grpc.testing.EmptyMessage}
-   */
-  public  static final class EmptyMessage extends
-      com.google.protobuf.GeneratedMessageV3 implements
-      // @@protoc_insertion_point(message_implements:grpc.testing.EmptyMessage)
-      EmptyMessageOrBuilder {
-    // Use EmptyMessage.newBuilder() to construct.
-    private EmptyMessage(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) {
-      super(builder);
-    }
-    private EmptyMessage() {
-    }
-
-    @java.lang.Override
-    public final com.google.protobuf.UnknownFieldSet
-    getUnknownFields() {
-      return com.google.protobuf.UnknownFieldSet.getDefaultInstance();
-    }
-    private EmptyMessage(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      this();
-      try {
-        boolean done = false;
-        while (!done) {
-          int tag = input.readTag();
-          switch (tag) {
-            case 0:
-              done = true;
-              break;
-            default: {
-              if (!input.skipField(tag)) {
-                done = true;
-              }
-              break;
-            }
-          }
-        }
-      } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-        throw e.setUnfinishedMessage(this);
-      } catch (java.io.IOException e) {
-        throw new com.google.protobuf.InvalidProtocolBufferException(
-            e).setUnfinishedMessage(this);
-      } finally {
-        makeExtensionsImmutable();
-      }
-    }
-    public static final com.google.protobuf.Descriptors.Descriptor
-        getDescriptor() {
-      return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_EmptyMessage_descriptor;
-    }
-
-    protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-        internalGetFieldAccessorTable() {
-      return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_EmptyMessage_fieldAccessorTable
-          .ensureFieldAccessorsInitialized(
-              io.grpc.testing.integration.Metrics.EmptyMessage.class, io.grpc.testing.integration.Metrics.EmptyMessage.Builder.class);
-    }
-
-    private byte memoizedIsInitialized = -1;
-    public final boolean isInitialized() {
-      byte isInitialized = memoizedIsInitialized;
-      if (isInitialized == 1) return true;
-      if (isInitialized == 0) return false;
-
-      memoizedIsInitialized = 1;
-      return true;
-    }
-
-    public void writeTo(com.google.protobuf.CodedOutputStream output)
-                        throws java.io.IOException {
-    }
-
-    public int getSerializedSize() {
-      int size = memoizedSize;
-      if (size != -1) return size;
-
-      size = 0;
-      memoizedSize = size;
-      return size;
-    }
-
-    private static final long serialVersionUID = 0L;
-    @java.lang.Override
-    public boolean equals(final java.lang.Object obj) {
-      if (obj == this) {
-       return true;
-      }
-      if (!(obj instanceof io.grpc.testing.integration.Metrics.EmptyMessage)) {
-        return super.equals(obj);
-      }
-      io.grpc.testing.integration.Metrics.EmptyMessage other = (io.grpc.testing.integration.Metrics.EmptyMessage) obj;
-
-      boolean result = true;
-      return result;
-    }
-
-    @java.lang.Override
-    public int hashCode() {
-      if (memoizedHashCode != 0) {
-        return memoizedHashCode;
-      }
-      int hash = 41;
-      hash = (19 * hash) + getDescriptor().hashCode();
-      hash = (29 * hash) + unknownFields.hashCode();
-      memoizedHashCode = hash;
-      return hash;
-    }
-
-    public static io.grpc.testing.integration.Metrics.EmptyMessage parseFrom(
-        com.google.protobuf.ByteString data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Metrics.EmptyMessage parseFrom(
-        com.google.protobuf.ByteString data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Metrics.EmptyMessage parseFrom(byte[] data)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data);
-    }
-    public static io.grpc.testing.integration.Metrics.EmptyMessage parseFrom(
-        byte[] data,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws com.google.protobuf.InvalidProtocolBufferException {
-      return PARSER.parseFrom(data, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Metrics.EmptyMessage parseFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Metrics.EmptyMessage parseFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Metrics.EmptyMessage parseDelimitedFrom(java.io.InputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Metrics.EmptyMessage parseDelimitedFrom(
-        java.io.InputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseDelimitedWithIOException(PARSER, input, extensionRegistry);
-    }
-    public static io.grpc.testing.integration.Metrics.EmptyMessage parseFrom(
-        com.google.protobuf.CodedInputStream input)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input);
-    }
-    public static io.grpc.testing.integration.Metrics.EmptyMessage parseFrom(
-        com.google.protobuf.CodedInputStream input,
-        com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-        throws java.io.IOException {
-      return com.google.protobuf.GeneratedMessageV3
-          .parseWithIOException(PARSER, input, extensionRegistry);
-    }
-
-    public Builder newBuilderForType() { return newBuilder(); }
-    public static Builder newBuilder() {
-      return DEFAULT_INSTANCE.toBuilder();
-    }
-    public static Builder newBuilder(io.grpc.testing.integration.Metrics.EmptyMessage prototype) {
-      return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype);
-    }
-    public Builder toBuilder() {
-      return this == DEFAULT_INSTANCE
-          ? new Builder() : new Builder().mergeFrom(this);
-    }
-
-    @java.lang.Override
-    protected Builder newBuilderForType(
-        com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-      Builder builder = new Builder(parent);
-      return builder;
-    }
-    /**
-     * Protobuf type {@code grpc.testing.EmptyMessage}
-     */
-    public static final class Builder extends
-        com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements
-        // @@protoc_insertion_point(builder_implements:grpc.testing.EmptyMessage)
-        io.grpc.testing.integration.Metrics.EmptyMessageOrBuilder {
-      public static final com.google.protobuf.Descriptors.Descriptor
-          getDescriptor() {
-        return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_EmptyMessage_descriptor;
-      }
-
-      protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-          internalGetFieldAccessorTable() {
-        return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_EmptyMessage_fieldAccessorTable
-            .ensureFieldAccessorsInitialized(
-                io.grpc.testing.integration.Metrics.EmptyMessage.class, io.grpc.testing.integration.Metrics.EmptyMessage.Builder.class);
-      }
-
-      // Construct using io.grpc.testing.integration.Metrics.EmptyMessage.newBuilder()
-      private Builder() {
-        maybeForceBuilderInitialization();
-      }
-
-      private Builder(
-          com.google.protobuf.GeneratedMessageV3.BuilderParent parent) {
-        super(parent);
-        maybeForceBuilderInitialization();
-      }
-      private void maybeForceBuilderInitialization() {
-        if (com.google.protobuf.GeneratedMessageV3
-                .alwaysUseFieldBuilders) {
-        }
-      }
-      public Builder clear() {
-        super.clear();
-        return this;
-      }
-
-      public com.google.protobuf.Descriptors.Descriptor
-          getDescriptorForType() {
-        return io.grpc.testing.integration.Metrics.internal_static_grpc_testing_EmptyMessage_descriptor;
-      }
-
-      public io.grpc.testing.integration.Metrics.EmptyMessage getDefaultInstanceForType() {
-        return io.grpc.testing.integration.Metrics.EmptyMessage.getDefaultInstance();
-      }
-
-      public io.grpc.testing.integration.Metrics.EmptyMessage build() {
-        io.grpc.testing.integration.Metrics.EmptyMessage result = buildPartial();
-        if (!result.isInitialized()) {
-          throw newUninitializedMessageException(result);
-        }
-        return result;
-      }
-
-      public io.grpc.testing.integration.Metrics.EmptyMessage buildPartial() {
-        io.grpc.testing.integration.Metrics.EmptyMessage result = new io.grpc.testing.integration.Metrics.EmptyMessage(this);
-        onBuilt();
-        return result;
-      }
-
-      public Builder clone() {
-        return (Builder) super.clone();
-      }
-      public Builder setField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.setField(field, value);
-      }
-      public Builder clearField(
-          com.google.protobuf.Descriptors.FieldDescriptor field) {
-        return (Builder) super.clearField(field);
-      }
-      public Builder clearOneof(
-          com.google.protobuf.Descriptors.OneofDescriptor oneof) {
-        return (Builder) super.clearOneof(oneof);
-      }
-      public Builder setRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          int index, Object value) {
-        return (Builder) super.setRepeatedField(field, index, value);
-      }
-      public Builder addRepeatedField(
-          com.google.protobuf.Descriptors.FieldDescriptor field,
-          Object value) {
-        return (Builder) super.addRepeatedField(field, value);
-      }
-      public Builder mergeFrom(com.google.protobuf.Message other) {
-        if (other instanceof io.grpc.testing.integration.Metrics.EmptyMessage) {
-          return mergeFrom((io.grpc.testing.integration.Metrics.EmptyMessage)other);
-        } else {
-          super.mergeFrom(other);
-          return this;
-        }
-      }
-
-      public Builder mergeFrom(io.grpc.testing.integration.Metrics.EmptyMessage other) {
-        if (other == io.grpc.testing.integration.Metrics.EmptyMessage.getDefaultInstance()) return this;
-        onChanged();
-        return this;
-      }
-
-      public final boolean isInitialized() {
-        return true;
-      }
-
-      public Builder mergeFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws java.io.IOException {
-        io.grpc.testing.integration.Metrics.EmptyMessage parsedMessage = null;
-        try {
-          parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
-        } catch (com.google.protobuf.InvalidProtocolBufferException e) {
-          parsedMessage = (io.grpc.testing.integration.Metrics.EmptyMessage) e.getUnfinishedMessage();
-          throw e.unwrapIOException();
-        } finally {
-          if (parsedMessage != null) {
-            mergeFrom(parsedMessage);
-          }
-        }
-        return this;
-      }
-      public final Builder setUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-      public final Builder mergeUnknownFields(
-          final com.google.protobuf.UnknownFieldSet unknownFields) {
-        return this;
-      }
-
-
-      // @@protoc_insertion_point(builder_scope:grpc.testing.EmptyMessage)
-    }
-
-    // @@protoc_insertion_point(class_scope:grpc.testing.EmptyMessage)
-    private static final io.grpc.testing.integration.Metrics.EmptyMessage DEFAULT_INSTANCE;
-    static {
-      DEFAULT_INSTANCE = new io.grpc.testing.integration.Metrics.EmptyMessage();
-    }
-
-    public static io.grpc.testing.integration.Metrics.EmptyMessage getDefaultInstance() {
-      return DEFAULT_INSTANCE;
-    }
-
-    private static final com.google.protobuf.Parser<EmptyMessage>
-        PARSER = new com.google.protobuf.AbstractParser<EmptyMessage>() {
-      public EmptyMessage parsePartialFrom(
-          com.google.protobuf.CodedInputStream input,
-          com.google.protobuf.ExtensionRegistryLite extensionRegistry)
-          throws com.google.protobuf.InvalidProtocolBufferException {
-          return new EmptyMessage(input, extensionRegistry);
-      }
-    };
-
-    public static com.google.protobuf.Parser<EmptyMessage> parser() {
-      return PARSER;
-    }
-
-    @java.lang.Override
-    public com.google.protobuf.Parser<EmptyMessage> getParserForType() {
-      return PARSER;
-    }
-
-    public io.grpc.testing.integration.Metrics.EmptyMessage getDefaultInstanceForType() {
-      return DEFAULT_INSTANCE;
-    }
-
-  }
-
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_GaugeResponse_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_GaugeResponse_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_GaugeRequest_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_GaugeRequest_fieldAccessorTable;
-  private static final com.google.protobuf.Descriptors.Descriptor
-    internal_static_grpc_testing_EmptyMessage_descriptor;
-  private static final 
-    com.google.protobuf.GeneratedMessageV3.FieldAccessorTable
-      internal_static_grpc_testing_EmptyMessage_fieldAccessorTable;
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n)io/grpc/testing/integration/metrics.pr" +
-      "oto\022\014grpc.testing\"l\n\rGaugeResponse\022\014\n\004na" +
-      "me\030\001 \001(\t\022\024\n\nlong_value\030\002 \001(\003H\000\022\026\n\014double" +
-      "_value\030\003 \001(\001H\000\022\026\n\014string_value\030\004 \001(\tH\000B\007" +
-      "\n\005value\"\034\n\014GaugeRequest\022\014\n\004name\030\001 \001(\t\"\016\n" +
-      "\014EmptyMessage2\240\001\n\016MetricsService\022I\n\014GetA" +
-      "llGauges\022\032.grpc.testing.EmptyMessage\032\033.g" +
-      "rpc.testing.GaugeResponse0\001\022C\n\010GetGauge\022" +
-      "\032.grpc.testing.GaugeRequest\032\033.grpc.testi" +
-      "ng.GaugeResponseB\035\n\033io.grpc.testing.inte",
-      "grationb\006proto3"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-        }, assigner);
-    internal_static_grpc_testing_GaugeResponse_descriptor =
-      getDescriptor().getMessageTypes().get(0);
-    internal_static_grpc_testing_GaugeResponse_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_GaugeResponse_descriptor,
-        new java.lang.String[] { "Name", "LongValue", "DoubleValue", "StringValue", "Value", });
-    internal_static_grpc_testing_GaugeRequest_descriptor =
-      getDescriptor().getMessageTypes().get(1);
-    internal_static_grpc_testing_GaugeRequest_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_GaugeRequest_descriptor,
-        new java.lang.String[] { "Name", });
-    internal_static_grpc_testing_EmptyMessage_descriptor =
-      getDescriptor().getMessageTypes().get(2);
-    internal_static_grpc_testing_EmptyMessage_fieldAccessorTable = new
-      com.google.protobuf.GeneratedMessageV3.FieldAccessorTable(
-        internal_static_grpc_testing_EmptyMessage_descriptor,
-        new java.lang.String[] { });
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/testing-proto/src/generated/main/java/io/grpc/testing/integration/Test.java b/testing-proto/src/generated/main/java/io/grpc/testing/integration/Test.java
deleted file mode 100644
index 114d492a8e8..00000000000
--- a/testing-proto/src/generated/main/java/io/grpc/testing/integration/Test.java
+++ /dev/null
@@ -1,72 +0,0 @@
-// Generated by the protocol buffer compiler.  DO NOT EDIT!
-// source: io/grpc/testing/integration/test.proto
-
-package io.grpc.testing.integration;
-
-public final class Test {
-  private Test() {}
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistryLite registry) {
-  }
-
-  public static void registerAllExtensions(
-      com.google.protobuf.ExtensionRegistry registry) {
-    registerAllExtensions(
-        (com.google.protobuf.ExtensionRegistryLite) registry);
-  }
-
-  public static com.google.protobuf.Descriptors.FileDescriptor
-      getDescriptor() {
-    return descriptor;
-  }
-  private static  com.google.protobuf.Descriptors.FileDescriptor
-      descriptor;
-  static {
-    java.lang.String[] descriptorData = {
-      "\n&io/grpc/testing/integration/test.proto" +
-      "\022\014grpc.testing\032\'io/grpc/testing/integrat" +
-      "ion/empty.proto\032*io/grpc/testing/integra" +
-      "tion/messages.proto2\372\004\n\013TestService\0225\n\tE" +
-      "mptyCall\022\023.grpc.testing.Empty\032\023.grpc.tes" +
-      "ting.Empty\022F\n\tUnaryCall\022\033.grpc.testing.S" +
-      "impleRequest\032\034.grpc.testing.SimpleRespon" +
-      "se\022l\n\023StreamingOutputCall\022(.grpc.testing" +
-      ".StreamingOutputCallRequest\032).grpc.testi" +
-      "ng.StreamingOutputCallResponse0\001\022i\n\022Stre",
-      "amingInputCall\022\'.grpc.testing.StreamingI" +
-      "nputCallRequest\032(.grpc.testing.Streaming" +
-      "InputCallResponse(\001\022i\n\016FullDuplexCall\022(." +
-      "grpc.testing.StreamingOutputCallRequest\032" +
-      ").grpc.testing.StreamingOutputCallRespon" +
-      "se(\0010\001\022i\n\016HalfDuplexCall\022(.grpc.testing." +
-      "StreamingOutputCallRequest\032).grpc.testin" +
-      "g.StreamingOutputCallResponse(\0010\001\022=\n\021Uni" +
-      "mplementedCall\022\023.grpc.testing.Empty\032\023.gr" +
-      "pc.testing.Empty2U\n\024UnimplementedService",
-      "\022=\n\021UnimplementedCall\022\023.grpc.testing.Emp" +
-      "ty\032\023.grpc.testing.Empty2\177\n\020ReconnectServ" +
-      "ice\0221\n\005Start\022\023.grpc.testing.Empty\032\023.grpc" +
-      ".testing.Empty\0228\n\004Stop\022\023.grpc.testing.Em" +
-      "pty\032\033.grpc.testing.ReconnectInfoB\035\n\033io.g" +
-      "rpc.testing.integrationb\006proto3"
-    };
-    com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
-        new com.google.protobuf.Descriptors.FileDescriptor.    InternalDescriptorAssigner() {
-          public com.google.protobuf.ExtensionRegistry assignDescriptors(
-              com.google.protobuf.Descriptors.FileDescriptor root) {
-            descriptor = root;
-            return null;
-          }
-        };
-    com.google.protobuf.Descriptors.FileDescriptor
-      .internalBuildGeneratedFileFrom(descriptorData,
-        new com.google.protobuf.Descriptors.FileDescriptor[] {
-          com.google.protobuf.EmptyProtos.getDescriptor(),
-          io.grpc.testing.integration.Messages.getDescriptor(),
-        }, assigner);
-    com.google.protobuf.EmptyProtos.getDescriptor();
-    io.grpc.testing.integration.Messages.getDescriptor();
-  }
-
-  // @@protoc_insertion_point(outer_class_scope)
-}
diff --git a/testing-proto/src/main/proto/io/grpc/testing/integration/empty.proto b/testing-proto/src/main/proto/io/grpc/testing/integration/empty.proto
deleted file mode 100644
index af5591b6654..00000000000
--- a/testing-proto/src/main/proto/io/grpc/testing/integration/empty.proto
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-syntax = "proto2";
-
-package grpc.testing;
-
-option java_package = "com.google.protobuf";
-option java_outer_classname = "EmptyProtos";
-
-// An empty message that you can re-use to avoid defining duplicated empty
-// messages in your project. A typical example is to use it as argument or the
-// return value of a service API. For instance:
-//
-//   service Foo {
-//     rpc Bar (grpc.testing.Empty) returns (grpc.testing.Empty) { };
-//   };
-//
-message Empty {}
diff --git a/testing-proto/src/main/proto/io/grpc/testing/integration/messages.proto b/testing-proto/src/main/proto/io/grpc/testing/integration/messages.proto
deleted file mode 100644
index 5110719e822..00000000000
--- a/testing-proto/src/main/proto/io/grpc/testing/integration/messages.proto
+++ /dev/null
@@ -1,178 +0,0 @@
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Message definitions to be used by integration test service definitions.
-
-syntax = "proto3";
-
-package grpc.testing;
-
-option java_package = "io.grpc.testing.integration";
-
-// The type of payload that should be returned.
-enum PayloadType {
-  // Compressable text format.
-  COMPRESSABLE = 0;
-
-  // Uncompressable binary format.
-  UNCOMPRESSABLE = 1;
-
-  // Randomly chosen from all other formats defined in this enum.
-  RANDOM = 2;
-}
-
-// Compression algorithms
-enum CompressionType {
-  // No compression
-  NONE = 0;
-  GZIP = 1;
-  DEFLATE = 2;
-}
-
-// A block of data, to simply increase gRPC message size.
-message Payload {
-  // The type of data in body.
-  PayloadType type = 1;
-  // Primary contents of payload.
-  bytes body = 2;
-}
-
-// A protobuf representation for grpc status. This is used by test
-// clients to specify a status that the server should attempt to return.
-message EchoStatus {
-  int32 code = 1;
-  string message = 2;
-}
-
-// Unary request.
-message SimpleRequest {
-  // Desired payload type in the response from the server.
-  // If response_type is RANDOM, server randomly chooses one from other formats.
-  PayloadType response_type = 1;
-
-  // Desired payload size in the response from the server.
-  // If response_type is COMPRESSABLE, this denotes the size before compression.
-  int32 response_size = 2;
-
-  // Optional input payload sent along with the request.
-  Payload payload = 3;
-
-  // Whether SimpleResponse should include username.
-  bool fill_username = 4;
-
-  // Whether SimpleResponse should include OAuth scope.
-  bool fill_oauth_scope = 5;
-
-  // Compression algorithm to be used by the server for the response (stream)
-  CompressionType response_compression = 6;
-
-  // Whether server should return a given status
-  EchoStatus response_status = 7;
-}
-
-// Unary response, as configured by the request.
-message SimpleResponse {
-  // Payload to increase message size.
-  Payload payload = 1;
-  // The user the request came from, for verifying authentication was
-  // successful when the client expected it.
-  string username = 2;
-  // OAuth scope.
-  string oauth_scope = 3;
-}
-
-message SimpleContext {
-  string value = 1;
-}
-
-// Client-streaming request.
-message StreamingInputCallRequest {
-  // Optional input payload sent along with the request.
-  Payload payload = 1;
-
-  // Not expecting any payload from the response.
-}
-
-// Client-streaming response.
-message StreamingInputCallResponse {
-  // Aggregated size of payloads received from the client.
-  int32 aggregated_payload_size = 1;
-}
-
-// Configuration for a particular response.
-message ResponseParameters {
-  // Desired payload sizes in responses from the server.
-  // If response_type is COMPRESSABLE, this denotes the size before compression.
-  int32 size = 1;
-
-  // Desired interval between consecutive responses in the response stream in
-  // microseconds.
-  int32 interval_us = 2;
-}
-
-// Server-streaming request.
-message StreamingOutputCallRequest {
-  // Desired payload type in the response from the server.
-  // If response_type is RANDOM, the payload from each response in the stream
-  // might be of different types. This is to simulate a mixed type of payload
-  // stream.
-  PayloadType response_type = 1;
-
-  // Configuration for each expected response message.
-  repeated ResponseParameters response_parameters = 2;
-
-  // Optional input payload sent along with the request.
-  Payload payload = 3;
-
-  // Compression algorithm to be used by the server for the response (stream)
-  CompressionType response_compression = 6;
-
-  // Whether server should return a given status
-  EchoStatus response_status = 7;
-}
-
-// Server-streaming response, as configured by the request and parameters.
-message StreamingOutputCallResponse {
-  // Payload to increase response size.
-  Payload payload = 1;
-}
-
-// For reconnect interop test only.
-// Client tells server what reconnection parameters it used.
-message ReconnectParams {
-  int32 max_reconnect_backoff_ms = 1;
-}
-
-// For reconnect interop test only.
-// Server tells client whether its reconnects are following the spec and the
-// reconnect backoffs it saw.
-message ReconnectInfo {
-  bool passed = 1;
-  repeated int32 backoff_ms = 2;
-}
diff --git a/testing-proto/src/main/proto/io/grpc/testing/integration/metrics.proto b/testing-proto/src/main/proto/io/grpc/testing/integration/metrics.proto
deleted file mode 100644
index 2e08363b1d1..00000000000
--- a/testing-proto/src/main/proto/io/grpc/testing/integration/metrics.proto
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright 2015-2016, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Contains the definitions for a metrics service and the type of metrics
-// exposed by the service.
-//
-// Currently, 'Gauge' (i.e a metric that represents the measured value of
-// something at an instant of time) is the only metric type supported by the
-// service.
-syntax = "proto3";
-
-package grpc.testing;
-
-option java_package = "io.grpc.testing.integration";
-
-// Reponse message containing the gauge name and value
-message GaugeResponse {
-  string name = 1;
-  oneof value {
-    int64 long_value = 2;
-    double double_value = 3;
-    string string_value = 4;
-  }
-}
-
-// Request message containing the gauge name
-message GaugeRequest {
-  string name = 1;
-}
-
-message EmptyMessage {}
-
-service MetricsService {
-  // Returns the values of all the gauges that are currently being maintained by
-  // the service
-  rpc GetAllGauges(EmptyMessage) returns (stream GaugeResponse);
-
-  // Returns the value of one gauge
-  rpc GetGauge(GaugeRequest) returns (GaugeResponse);
-}
diff --git a/testing-proto/src/main/proto/io/grpc/testing/integration/test.proto b/testing-proto/src/main/proto/io/grpc/testing/integration/test.proto
deleted file mode 100644
index e4a41b4c9e9..00000000000
--- a/testing-proto/src/main/proto/io/grpc/testing/integration/test.proto
+++ /dev/null
@@ -1,89 +0,0 @@
-// Copyright 2015, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// An integration test service that covers all the method signature permutations
-// of unary/streaming requests/responses.
-syntax = "proto3";
-
-import "io/grpc/testing/integration/empty.proto";
-import "io/grpc/testing/integration/messages.proto";
-
-package grpc.testing;
-
-option java_package = "io.grpc.testing.integration";
-
-// A simple service to test the various types of RPCs and experiment with
-// performance with various types of payload.
-service TestService {
-  // One empty request followed by one empty response.
-  rpc EmptyCall(grpc.testing.Empty) returns (grpc.testing.Empty);
-
-  // One request followed by one response.
-  rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
-
-  // One request followed by a sequence of responses (streamed download).
-  // The server returns the payload with client desired type and sizes.
-  rpc StreamingOutputCall(StreamingOutputCallRequest)
-      returns (stream StreamingOutputCallResponse);
-
-  // A sequence of requests followed by one response (streamed upload).
-  // The server returns the aggregated size of client payload as the result.
-  rpc StreamingInputCall(stream StreamingInputCallRequest)
-      returns (StreamingInputCallResponse);
-
-  // A sequence of requests with each request served by the server immediately.
-  // As one request could lead to multiple responses, this interface
-  // demonstrates the idea of full duplexing.
-  rpc FullDuplexCall(stream StreamingOutputCallRequest)
-      returns (stream StreamingOutputCallResponse);
-
-  // A sequence of requests followed by a sequence of responses.
-  // The server buffers all the client requests and then serves them in order. A
-  // stream of responses are returned to the client when the server starts with
-  // first request.
-  rpc HalfDuplexCall(stream StreamingOutputCallRequest)
-      returns (stream StreamingOutputCallResponse);
-
-  // The test server will not implement this method. It will be used
-  // to test the behavior when clients call unimplemented methods.
-  rpc UnimplementedCall(grpc.testing.Empty) returns (grpc.testing.Empty);
-}
-
-// A simple service NOT implemented at servers so clients can test for
-// that case.
-service UnimplementedService {
-  // A call that no server should implement
-  rpc UnimplementedCall(grpc.testing.Empty) returns(grpc.testing.Empty);
-}
-
-// A service used to control reconnect server.
-service ReconnectService {
-  rpc Start(grpc.testing.Empty) returns (grpc.testing.Empty);
-  rpc Stop(grpc.testing.Empty) returns (grpc.testing.ReconnectInfo);
-}
diff --git a/testing-proto/src/main/proto/io/grpc/testing/protobuf/simpleservice.proto b/testing-proto/src/main/proto/io/grpc/testing/protobuf/simpleservice.proto
new file mode 100644
index 00000000000..154cc6a3b10
--- /dev/null
+++ b/testing-proto/src/main/proto/io/grpc/testing/protobuf/simpleservice.proto
@@ -0,0 +1,51 @@
+// Copyright 2017 The gRPC Authors
+// All rights reserved.
+//
+// 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.
+// An integration test service that covers all the method signature permutations
+// of unary/streaming requests/responses.
+
+syntax = "proto3";
+
+package grpc.testing;
+
+option java_package = "io.grpc.testing.protobuf";
+option java_outer_classname = "SimpleServiceProto";
+option java_multiple_files = true;
+
+// A simple service for test.
+service SimpleService {
+  // Simple unary RPC.
+  rpc UnaryRpc (SimpleRequest) returns (SimpleResponse) {}
+
+  // Simple client-to-server streaming RPC.
+  rpc ClientStreamingRpc (stream SimpleRequest) returns (SimpleResponse) {}
+
+  // Simple server-to-client streaming RPC.
+  rpc ServerStreamingRpc (SimpleRequest) returns (stream SimpleResponse) {}
+
+  // Simple bidirectional streaming RPC.
+  rpc BidiStreamingRpc (stream SimpleRequest) returns (stream SimpleResponse) {}
+}
+
+// A simple request message type for test.
+message SimpleRequest {
+  // An optional string message for test.
+  string requestMessage = 1;
+}
+
+// A simple response message type for test.
+message SimpleResponse {
+  // An optional string message for test.
+  string responseMessage = 1;
+}
diff --git a/testing-proto/src/test/java/io/grpc/testing/protobuf/SimpleServiceTest.java b/testing-proto/src/test/java/io/grpc/testing/protobuf/SimpleServiceTest.java
new file mode 100644
index 00000000000..fdc658399df
--- /dev/null
+++ b/testing-proto/src/test/java/io/grpc/testing/protobuf/SimpleServiceTest.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright 2017 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.testing.protobuf;
+
+import static io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING;
+import static io.grpc.MethodDescriptor.MethodType.CLIENT_STREAMING;
+import static io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING;
+import static io.grpc.MethodDescriptor.MethodType.UNARY;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import io.grpc.MethodDescriptor;
+import io.grpc.stub.annotations.RpcMethod;
+import java.io.File;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.RoundEnvironment;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.type.MirroredTypeException;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaCompiler.CompilationTask;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.ToolProvider;
+import org.junit.Assume;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Test to verify that the proto file simpleservice.proto generates the expected service. */
+@RunWith(JUnit4.class)
+public class SimpleServiceTest {
+  @Test
+  public void serviceDescriptor() {
+    assertEquals("grpc.testing.SimpleService", SimpleServiceGrpc.getServiceDescriptor().getName());
+  }
+
+  @Test
+  public void serviceMethodDescriotrs() {
+    MethodDescriptor<SimpleRequest, SimpleResponse> genericTypeShouldMatchWhenAssigned;
+
+    genericTypeShouldMatchWhenAssigned = SimpleServiceGrpc.getUnaryRpcMethod();
+    assertEquals(UNARY, genericTypeShouldMatchWhenAssigned.getType());
+
+    genericTypeShouldMatchWhenAssigned = SimpleServiceGrpc.getClientStreamingRpcMethod();
+    assertEquals(CLIENT_STREAMING, genericTypeShouldMatchWhenAssigned.getType());
+
+    genericTypeShouldMatchWhenAssigned = SimpleServiceGrpc.getServerStreamingRpcMethod();
+    assertEquals(SERVER_STREAMING, genericTypeShouldMatchWhenAssigned.getType());
+
+    genericTypeShouldMatchWhenAssigned = SimpleServiceGrpc.getBidiStreamingRpcMethod();
+    assertEquals(BIDI_STREAMING, genericTypeShouldMatchWhenAssigned.getType());
+  }
+
+  @Test
+  public void generatedMethodsAreSampledToLocalTracing() throws Exception {
+    assertTrue(SimpleServiceGrpc.getUnaryRpcMethod().isSampledToLocalTracing());
+  }
+
+  public static class AnnotationProcessor extends AbstractProcessor {
+
+    private boolean processedClass = false;
+
+    @Override
+    public SourceVersion getSupportedSourceVersion() {
+      return SourceVersion.latestSupported();
+    }
+
+    @Override
+    public Set<String> getSupportedAnnotationTypes() {
+      return Collections.singleton(RpcMethod.class.getCanonicalName());
+    }
+
+    private void verifyRpcMethodAnnotation(
+        MethodDescriptor<SimpleRequest, SimpleResponse> descriptor, RpcMethod annotation) {
+      assertEquals(descriptor.getFullMethodName(), annotation.fullMethodName());
+      assertEquals(descriptor.getType(), annotation.methodType());
+
+      // Class objects may not be available at runtime, handle MirroredTypeException if it occurs
+      try {
+        assertEquals(SimpleRequest.class, annotation.requestType());
+      } catch (MirroredTypeException e) {
+        assertEquals(SimpleRequest.class.getCanonicalName(), e.getTypeMirror().toString());
+      }
+
+      try {
+        assertEquals(SimpleResponse.class, annotation.responseType());
+      } catch (MirroredTypeException e) {
+        assertEquals(SimpleResponse.class.getCanonicalName(), e.getTypeMirror().toString());
+      }
+    }
+
+    @Override
+    public synchronized boolean process(
+        Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+      for (Element rootElement : roundEnv.getRootElements()) {
+        if (!rootElement.asType().toString().equals(SimpleServiceGrpc.class.getCanonicalName())) {
+          continue;
+        }
+
+        Map<String, RpcMethod> methodToAnnotation = new HashMap<>();
+        for (Element enclosedElement : rootElement.getEnclosedElements()) {
+          RpcMethod annotation = enclosedElement.getAnnotation(RpcMethod.class);
+          if (annotation != null) {
+            methodToAnnotation.put(enclosedElement.getSimpleName().toString(), annotation);
+          }
+        }
+
+        verifyRpcMethodAnnotation(
+            SimpleServiceGrpc.getUnaryRpcMethod(), methodToAnnotation.get("getUnaryRpcMethod"));
+        verifyRpcMethodAnnotation(
+            SimpleServiceGrpc.getServerStreamingRpcMethod(),
+            methodToAnnotation.get("getServerStreamingRpcMethod"));
+        verifyRpcMethodAnnotation(
+            SimpleServiceGrpc.getClientStreamingRpcMethod(),
+            methodToAnnotation.get("getClientStreamingRpcMethod"));
+        verifyRpcMethodAnnotation(
+            SimpleServiceGrpc.getBidiStreamingRpcMethod(),
+            methodToAnnotation.get("getBidiStreamingRpcMethod"));
+
+        processedClass = true;
+      }
+      return false;
+    }
+  }
+
+  @Test
+  public void testRpcMethodAnnotations() throws Exception {
+    File grpcJavaFile =
+        new File("./src/generated/main/grpc/io/grpc/testing/protobuf/SimpleServiceGrpc.java");
+    Assume.assumeTrue(grpcJavaFile.exists());
+
+    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+    StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
+    AnnotationProcessor processor = new AnnotationProcessor();
+    Iterable<? extends JavaFileObject> obs = fileManager.getJavaFileObjects(grpcJavaFile);
+
+    CompilationTask task =
+        compiler.getTask(
+            null,
+            fileManager,
+            null,
+            Collections.singleton("-proc:only"),
+            Collections.singleton(SimpleServiceGrpc.class.getCanonicalName()),
+            obs);
+    task.setProcessors(Collections.singleton(processor));
+    assertTrue(task.call());
+    assertTrue(processor.processedClass);
+    fileManager.close();
+  }
+}
diff --git a/testing/BUILD.bazel b/testing/BUILD.bazel
new file mode 100644
index 00000000000..d280ab97ee1
--- /dev/null
+++ b/testing/BUILD.bazel
@@ -0,0 +1,25 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "testing",
+    testonly = 1,
+    srcs = glob([
+        "src/main/java/io/grpc/testing/*.java",
+    ]),
+    resources = glob([
+        "src/main/resources/**",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api",
+        "//context",
+        "//inprocess",
+        "//stub",
+        "//util",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
+        artifact("com.google.truth:truth"),
+        artifact("junit:junit"),
+    ],
+)
diff --git a/testing/build.gradle b/testing/build.gradle
index 2ebc78fa264..b92e39279c6 100644
--- a/testing/build.gradle
+++ b/testing/build.gradle
@@ -1,11 +1,48 @@
+plugins {
+    id "java-library"
+    id "maven-publish"
+
+    id "me.champeau.gradle.japicmp"
+    id "ru.vyarus.animalsniffer"
+}
+
 description = "gRPC: Testing"
 
 dependencies {
-    compile project(':grpc-core'),
+    api project(':grpc-util'),
             project(':grpc-stub'),
-            libraries.junit,
-            libraries.mockito,
-            libraries.truth
+            libraries.junit
+    implementation project(':grpc-inprocess')
+    implementation project(':grpc-core')
+    // Only io.grpc.internal.testing.StatsTestUtils depends on opencensus_api, for internal use.
+    compileOnly libraries.opencensus.api,
+            project(":grpc-context") // Override opencensus dependency with our newer version
+    runtimeOnly project(":grpc-api")   // Pull in newer version than census-api
+
+    testImplementation libraries.mockito.core
+
+    testImplementation project(':grpc-testing-proto'),
+            testFixtures(project(':grpc-core'))
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+tasks.named("javadoc").configure { exclude 'io/grpc/internal/**' }
 
-    testCompile project(':grpc-testing-proto')
+tasks.named("jacocoTestReport").configure {
+    classDirectories.from = sourceSets.main.output.collect {
+        fileTree(dir: it,
+        exclude: [
+                '**/io/grpc/internal/testing/**',
+        ])
+    }
 }
diff --git a/testing/src/main/java/io/grpc/internal/TestingAccessor.java b/testing/src/main/java/io/grpc/internal/TestingAccessor.java
deleted file mode 100644
index f1d3238d00d..00000000000
--- a/testing/src/main/java/io/grpc/internal/TestingAccessor.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright 2017, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal;
-
-import com.google.instrumentation.stats.StatsContextFactory;
-
-/**
- * Test helper that allows accessing package-private stuff.
- */
-public final class TestingAccessor {
-  /**
-   * Sets a custom {@link StatsContextFactory} for tests.
-   */
-  public static void setStatsContextFactory(
-      AbstractManagedChannelImplBuilder<?> builder, StatsContextFactory factory) {
-    builder.statsContextFactory(factory);
-  }
-
-  /**
-   * Sets a custom {@link StatsContextFactory} for tests.
-   */
-  public static void setStatsContextFactory(
-      AbstractServerImplBuilder<?> builder, StatsContextFactory factory) {
-    builder.statsContextFactory(factory);
-  }
-
-  private TestingAccessor() {
-  }
-}
diff --git a/testing/src/main/java/io/grpc/internal/testing/AbstractClientTransportFactoryTest.java b/testing/src/main/java/io/grpc/internal/testing/AbstractClientTransportFactoryTest.java
deleted file mode 100644
index 57c0274d928..00000000000
--- a/testing/src/main/java/io/grpc/internal/testing/AbstractClientTransportFactoryTest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal.testing;
-
-import io.grpc.internal.ClientTransportFactory;
-import java.net.InetSocketAddress;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-@RunWith(JUnit4.class)
-public abstract class AbstractClientTransportFactoryTest {
-
-  protected abstract ClientTransportFactory newClientTransportFactory();
-
-  @Test
-  public void multipleCallsToCloseShouldNotThrow() {
-    ClientTransportFactory transportFactory = newClientTransportFactory();
-    transportFactory.close();
-    transportFactory.close();
-    transportFactory.close();
-  }
-
-  @Test(expected = IllegalStateException.class)
-  public void newClientTransportAfterCloseShouldThrow() {
-    ClientTransportFactory transportFactory = newClientTransportFactory();
-    transportFactory.close();
-    transportFactory.newClientTransport(
-        new InetSocketAddress("localhost", 12345), "localhost:" + 12345, "agent");
-  }
-}
diff --git a/testing/src/main/java/io/grpc/internal/testing/AbstractTransportTest.java b/testing/src/main/java/io/grpc/internal/testing/AbstractTransportTest.java
deleted file mode 100644
index fc7a49f0482..00000000000
--- a/testing/src/main/java/io/grpc/internal/testing/AbstractTransportTest.java
+++ /dev/null
@@ -1,1274 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.internal.testing;
-
-import static com.google.common.base.Charsets.UTF_8;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.junit.Assume.assumeTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyBoolean;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Matchers.same;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.timeout;
-import static org.mockito.Mockito.verify;
-
-import com.google.common.collect.Lists;
-import com.google.common.io.ByteStreams;
-import com.google.common.util.concurrent.MoreExecutors;
-import com.google.common.util.concurrent.SettableFuture;
-import io.grpc.Attributes;
-import io.grpc.Grpc;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.Status;
-import io.grpc.internal.ClientStream;
-import io.grpc.internal.ClientStreamListener;
-import io.grpc.internal.ClientTransport;
-import io.grpc.internal.InternalServer;
-import io.grpc.internal.ManagedClientTransport;
-import io.grpc.internal.ServerListener;
-import io.grpc.internal.ServerStream;
-import io.grpc.internal.ServerStreamListener;
-import io.grpc.internal.ServerTransport;
-import io.grpc.internal.ServerTransportListener;
-import io.grpc.internal.StatsTraceContext;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InOrder;
-import org.mockito.Matchers;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-/** Standard unit tests for {@link ClientTransport}s and {@link ServerTransport}s. */
-@RunWith(JUnit4.class)
-public abstract class AbstractTransportTest {
-  private static final int TIMEOUT_MS = 1000;
-
-  private static final Attributes.Key<String> ADDITIONAL_TRANSPORT_ATTR_KEY =
-      Attributes.Key.of("additional-attr");
-
-  /**
-   * Returns a new server that when started will be able to be connected to from the client. Each
-   * returned instance should be new and yet be accessible by new client transports.
-   */
-  protected abstract InternalServer newServer();
-
-  /**
-   * Builds a new server that is listening on the same location as the given server instance does.
-   */
-  protected abstract InternalServer newServer(InternalServer server);
-
-  /**
-   * Returns a new transport that when started will be able to connect to {@code server}.
-   */
-  protected abstract ManagedClientTransport newClientTransport(InternalServer server);
-
-  /**
-   * Returns the authority string used by a client to connect to {@code server}.
-   */
-  protected abstract String testAuthority(InternalServer server);
-
-  /**
-   * When non-null, will be shut down during tearDown(). However, it _must_ have been started with
-   * {@code serverListener}, otherwise tearDown() can't wait for shutdown which can put following
-   * tests in an indeterminate state.
-   */
-  private InternalServer server;
-  private ServerTransport serverTransport;
-  private ManagedClientTransport client;
-  private MethodDescriptor<String, String> methodDescriptor =
-      MethodDescriptor.<String, String>newBuilder()
-          .setType(MethodDescriptor.MethodType.UNKNOWN)
-          .setFullMethodName("service/method")
-          .setRequestMarshaller(StringMarshaller.INSTANCE)
-          .setResponseMarshaller(StringMarshaller.INSTANCE)
-          .build();
-
-  private Metadata.Key<String> asciiKey = Metadata.Key.of(
-      "ascii-key", Metadata.ASCII_STRING_MARSHALLER);
-  private Metadata.Key<String> binaryKey = Metadata.Key.of(
-      "key-bin", StringBinaryMarshaller.INSTANCE);
-
-  private ManagedClientTransport.Listener mockClientTransportListener
-      = mock(ManagedClientTransport.Listener.class);
-  private ClientStreamListener mockClientStreamListener = mock(ClientStreamListener.class);
-  private MockServerListener serverListener = new MockServerListener();
-  private ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
-  private ArgumentCaptor<Throwable> throwableCaptor = ArgumentCaptor.forClass(Throwable.class);
-  private ArgumentCaptor<Metadata> metadataCaptor = ArgumentCaptor.forClass(Metadata.class);
-  private ArgumentCaptor<InputStream> inputStreamCaptor
-      = ArgumentCaptor.forClass(InputStream.class);
-  @Rule
-  public ExpectedException thrown = ExpectedException.none();
-
-  @Before
-  public void setUp() {
-    server = newServer();
-  }
-
-  @After
-  public void tearDown() throws InterruptedException {
-    if (client != null) {
-      client.shutdownNow(Status.UNKNOWN.withDescription("teardown"));
-    }
-    if (serverTransport != null) {
-      serverTransport.shutdownNow(Status.UNKNOWN.withDescription("teardown"));
-    }
-    if (server != null) {
-      server.shutdown();
-      assertTrue(serverListener.waitForShutdown(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    }
-  }
-
-  // TODO(ejona):
-  //   multiple streams on same transport
-  //   multiple client transports to same server
-  //   halfClose to trigger flush (client and server)
-  //   flow control pushes back (client and server)
-  //   flow control provides precisely number of messages requested (client and server)
-  //   onReady called when buffer drained (on server and client)
-  //   test no start reentrancy (esp. during failure) (transport and call)
-  //   multiple requests/responses (verifying contents received)
-  //   server transport shutdown triggers client shutdown (via GOAWAY)
-  //   queued message InputStreams are closed on stream cancel
-  //     (and maybe exceptions handled)
-
-  /**
-   * Test for issue https://github.com/grpc/grpc-java/issues/1682
-   */
-  @Test
-  public void frameAfterRstStreamShouldNotBreakClientChannel() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-
-    // Try to create a sequence of frames so that the client receives a HEADERS or DATA frame
-    // after having sent a RST_STREAM to the server. Previously, this would have broken the
-    // Netty channel.
-
-    ClientStream stream = client.newStream(methodDescriptor, new Metadata());
-    stream.start(mockClientStreamListener);
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    stream.flush();
-    stream.writeMessage(methodDescriptor.streamRequest("foo"));
-    stream.flush();
-    stream.cancel(Status.CANCELLED);
-    stream.flush();
-    serverStreamCreation.stream.writeHeaders(new Metadata());
-    serverStreamCreation.stream.flush();
-    serverStreamCreation.stream.writeMessage(methodDescriptor.streamResponse("bar"));
-    serverStreamCreation.stream.flush();
-
-    verify(mockClientStreamListener, timeout(250))
-        .closed(eq(Status.CANCELLED), any(Metadata.class));
-
-    ClientStreamListener mockClientStreamListener2 = mock(ClientStreamListener.class);
-
-    // Test that the channel is still usable i.e. we can receive headers from the server on a
-    // new stream.
-    stream = client.newStream(methodDescriptor, new Metadata());
-    stream.start(mockClientStreamListener2);
-    serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverStreamCreation.stream.writeHeaders(new Metadata());
-    serverStreamCreation.stream.flush();
-
-    verify(mockClientStreamListener2, timeout(250)).headersRead(any(Metadata.class));
-  }
-
-  @Test
-  public void serverNotListening() throws Exception {
-    // Start server to just acquire a port.
-    server.start(serverListener);
-    client = newClientTransport(server);
-    server.shutdown();
-    assertTrue(serverListener.waitForShutdown(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    server = null;
-
-    InOrder inOrder = inOrder(mockClientTransportListener);
-    runIfNotNull(client.start(mockClientTransportListener));
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
-    inOrder.verify(mockClientTransportListener).transportShutdown(statusCaptor.capture());
-    assertCodeEquals(Status.UNAVAILABLE, statusCaptor.getValue());
-    inOrder.verify(mockClientTransportListener).transportTerminated();
-    verify(mockClientTransportListener, never()).transportReady();
-    verify(mockClientTransportListener, never()).transportInUse(anyBoolean());
-  }
-
-  @Test
-  public void clientStartStop() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    InOrder inOrder = inOrder(mockClientTransportListener);
-    runIfNotNull(client.start(mockClientTransportListener));
-    client.shutdown();
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
-    inOrder.verify(mockClientTransportListener).transportShutdown(statusCaptor.capture());
-    assertCodeEquals(Status.UNAVAILABLE, statusCaptor.getValue());
-    inOrder.verify(mockClientTransportListener).transportTerminated();
-    verify(mockClientTransportListener, never()).transportInUse(anyBoolean());
-  }
-
-  @Test
-  public void clientStartAndStopOnceConnected() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    InOrder inOrder = inOrder(mockClientTransportListener);
-    runIfNotNull(client.start(mockClientTransportListener));
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    client.shutdown();
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
-    inOrder.verify(mockClientTransportListener).transportShutdown(any(Status.class));
-    inOrder.verify(mockClientTransportListener).transportTerminated();
-    assertTrue(serverTransportListener.waitForTermination(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    server.shutdown();
-    assertTrue(serverListener.waitForShutdown(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    server = null;
-    verify(mockClientTransportListener, never()).transportInUse(anyBoolean());
-  }
-
-  @Test
-  public void serverAlreadyListening() throws Exception {
-    client = null;
-    server.start(serverListener);
-    InternalServer server2 = newServer(server);
-    thrown.expect(IOException.class);
-    server2.start(new MockServerListener());
-  }
-
-  @Test
-  public void openStreamPreventsTermination() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata());
-    clientStream.start(mockClientStreamListener);
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    ServerStream serverStream = serverStreamCreation.stream;
-    ServerStreamListener mockServerStreamListener = serverStreamCreation.listener;
-
-    client.shutdown();
-    client = null;
-    server.shutdown();
-    serverTransport.shutdown();
-    serverTransport = null;
-
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class));
-    assertTrue(serverListener.waitForShutdown(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-
-    // A new server should be able to start listening, since the current server has given up
-    // resources. There may be cases this is impossible in the future, but for now it is a useful
-    // property.
-    serverListener = new MockServerListener();
-    server = newServer(server);
-    server.start(serverListener);
-
-    // Try to "flush" out any listener notifications on client and server. This also ensures that
-    // the stream still functions.
-    serverStream.writeHeaders(new Metadata());
-    clientStream.halfClose();
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS)).headersRead(any(Metadata.class));
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).halfClosed();
-
-    verify(mockClientTransportListener, never()).transportTerminated();
-    verify(mockClientTransportListener, never()).transportInUse(false);
-    assertFalse(serverTransportListener.isTerminated());
-
-    clientStream.cancel(Status.CANCELLED);
-
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(false);
-    assertTrue(serverTransportListener.waitForTermination(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-  }
-
-  @Test
-  public void shutdownNowKillsClientStream() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata());
-    clientStream.start(mockClientStreamListener);
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    ServerStreamListener mockServerStreamListener = serverStreamCreation.listener;
-
-    Status status = Status.UNKNOWN.withDescription("test shutdownNow");
-    client.shutdownNow(status);
-    client = null;
-
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class));
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(false);
-    assertTrue(serverTransportListener.waitForTermination(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    assertTrue(serverTransportListener.isTerminated());
-
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS))
-        .closed(same(status), any(Metadata.class));
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).closed(any(Status.class));
-  }
-
-  @Test
-  public void shutdownNowKillsServerStream() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata());
-    clientStream.start(mockClientStreamListener);
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    ServerStreamListener mockServerStreamListener = serverStreamCreation.listener;
-
-    serverTransport.shutdownNow(Status.UNKNOWN.withDescription("test shutdownNow"));
-    serverTransport = null;
-
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class));
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(false);
-    assertTrue(serverTransportListener.waitForTermination(TIMEOUT_MS, TimeUnit.MILLISECONDS));
-    assertTrue(serverTransportListener.isTerminated());
-
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS))
-        .closed(any(Status.class), any(Metadata.class));
-    // Generally will be same status provided to shutdownNow, but InProcessTransport can't
-    // differentiate between client and server shutdownNow. The status is not really used on
-    // server-side, so we don't care much.
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).closed(any(Status.class));
-  }
-
-  @Test
-  public void ping() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    ClientTransport.PingCallback mockPingCallback = mock(ClientTransport.PingCallback.class);
-    try {
-      client.ping(mockPingCallback, MoreExecutors.directExecutor());
-    } catch (UnsupportedOperationException ex) {
-      // Transport doesn't support ping, so this neither passes nor fails.
-      assumeTrue(false);
-    }
-    verify(mockPingCallback, timeout(TIMEOUT_MS)).onSuccess(Matchers.anyInt());
-    verify(mockClientTransportListener, never()).transportInUse(anyBoolean());
-  }
-
-  @Test
-  public void ping_duringShutdown() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    // Stream prevents termination
-    ClientStream stream = client.newStream(methodDescriptor, new Metadata());
-    stream.start(mockClientStreamListener);
-    client.shutdown();
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class));
-    ClientTransport.PingCallback mockPingCallback = mock(ClientTransport.PingCallback.class);
-    try {
-      client.ping(mockPingCallback, MoreExecutors.directExecutor());
-    } catch (UnsupportedOperationException ex) {
-      // Transport doesn't support ping, so this neither passes nor fails.
-      assumeTrue(false);
-    }
-    verify(mockPingCallback, timeout(TIMEOUT_MS)).onSuccess(Matchers.anyInt());
-    stream.cancel(Status.CANCELLED);
-  }
-
-  @Test
-  public void ping_afterTermination() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
-    client.shutdown();
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
-    ClientTransport.PingCallback mockPingCallback = mock(ClientTransport.PingCallback.class);
-    try {
-      client.ping(mockPingCallback, MoreExecutors.directExecutor());
-    } catch (UnsupportedOperationException ex) {
-      // Transport doesn't support ping, so this neither passes nor fails.
-      assumeTrue(false);
-    }
-    verify(mockPingCallback, timeout(TIMEOUT_MS)).onFailure(throwableCaptor.capture());
-    Status status = Status.fromThrowable(throwableCaptor.getValue());
-    assertCodeEquals(Status.UNAVAILABLE, status);
-  }
-
-  @Test
-  public void newStream_duringShutdown() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    // Stream prevents termination
-    ClientStream stream = client.newStream(methodDescriptor, new Metadata());
-    stream.start(mockClientStreamListener);
-    client.shutdown();
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportShutdown(any(Status.class));
-    ClientStream stream2 = client.newStream(methodDescriptor, new Metadata());
-    ClientStreamListener mockClientStreamListener2 = mock(ClientStreamListener.class);
-    stream2.start(mockClientStreamListener2);
-    verify(mockClientStreamListener2, timeout(TIMEOUT_MS))
-        .closed(statusCaptor.capture(), any(Metadata.class));
-    assertCodeEquals(Status.UNAVAILABLE, statusCaptor.getValue());
-
-    // Make sure earlier stream works.
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverStreamCreation.stream.close(Status.OK, new Metadata());
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS))
-        .closed(statusCaptor.capture(), any(Metadata.class));
-    assertCodeEquals(Status.OK, statusCaptor.getValue());
-  }
-
-  @Test
-  public void newStream_afterTermination() throws Exception {
-    // We expect the same general behavior as duringShutdown, but for some transports (e.g., Netty)
-    // dealing with afterTermination is harder than duringShutdown.
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportReady();
-    client.shutdown();
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportTerminated();
-    Thread.sleep(100);
-    ClientStream stream = client.newStream(methodDescriptor, new Metadata());
-    stream.start(mockClientStreamListener);
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS))
-        .closed(statusCaptor.capture(), any(Metadata.class));
-    verify(mockClientTransportListener, never()).transportInUse(anyBoolean());
-    assertCodeEquals(Status.UNAVAILABLE, statusCaptor.getValue());
-  }
-
-  @Test
-  public void transportInUse_normalClose() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    ClientStream stream1 = client.newStream(methodDescriptor, new Metadata());
-    stream1.start(mockClientStreamListener);
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    StreamCreation serverStreamCreation1
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    ClientStream stream2 = client.newStream(methodDescriptor, new Metadata());
-    stream2.start(mockClientStreamListener);
-    StreamCreation serverStreamCreation2
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-
-    stream1.halfClose();
-    serverStreamCreation1.stream.close(Status.OK, new Metadata());
-    stream2.halfClose();
-    verify(mockClientTransportListener, never()).transportInUse(false);
-    serverStreamCreation2.stream.close(Status.OK, new Metadata());
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(false);
-    // Verify that the callback has been called only once for true and false respectively
-    verify(mockClientTransportListener).transportInUse(true);
-    verify(mockClientTransportListener).transportInUse(false);
-  }
-
-  @Test
-  public void transportInUse_clientCancel() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    ClientStream stream1 = client.newStream(methodDescriptor, new Metadata());
-    stream1.start(mockClientStreamListener);
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(true);
-    ClientStream stream2 = client.newStream(methodDescriptor, new Metadata());
-    stream2.start(mockClientStreamListener);
-
-    stream1.cancel(Status.CANCELLED);
-    verify(mockClientTransportListener, never()).transportInUse(false);
-    stream2.cancel(Status.CANCELLED);
-    verify(mockClientTransportListener, timeout(TIMEOUT_MS)).transportInUse(false);
-    // Verify that the callback has been called only once for true and false respectively
-    verify(mockClientTransportListener).transportInUse(true);
-    verify(mockClientTransportListener).transportInUse(false);
-  }
-
-  @Test
-  @SuppressWarnings("deprecation")
-  public void basicStream() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-
-    Metadata clientHeaders = new Metadata();
-    clientHeaders.put(asciiKey, "client");
-    clientHeaders.put(asciiKey, "dupvalue");
-    clientHeaders.put(asciiKey, "dupvalue");
-    clientHeaders.put(binaryKey, "äbinaryclient");
-    Metadata clientHeadersCopy = new Metadata();
-
-    clientHeadersCopy.merge(clientHeaders);
-    ClientStream clientStream = client.newStream(methodDescriptor, clientHeaders);
-    clientStream.start(mockClientStreamListener);
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    assertEquals(methodDescriptor.getFullMethodName(), serverStreamCreation.method);
-    assertEquals(Lists.newArrayList(clientHeadersCopy.getAll(asciiKey)),
-        Lists.newArrayList(serverStreamCreation.headers.getAll(asciiKey)));
-    assertEquals(Lists.newArrayList(clientHeadersCopy.getAll(binaryKey)),
-        Lists.newArrayList(serverStreamCreation.headers.getAll(binaryKey)));
-    ServerStream serverStream = serverStreamCreation.stream;
-    ServerStreamListener mockServerStreamListener = serverStreamCreation.listener;
-
-    assertEquals("additional attribute value",
-        serverStream.getAttributes().get(ADDITIONAL_TRANSPORT_ATTR_KEY));
-    assertNotNull(serverStream.getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR));
-
-    serverStream.request(1);
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS)).onReady();
-    assertTrue(clientStream.isReady());
-    clientStream.writeMessage(methodDescriptor.streamRequest("Hello!"));
-    clientStream.flush();
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).messageRead(inputStreamCaptor.capture());
-    assertEquals("Hello!", methodDescriptor.parseRequest(inputStreamCaptor.getValue()));
-    inputStreamCaptor.getValue().close();
-
-    clientStream.halfClose();
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).halfClosed();
-
-    Metadata serverHeaders = new Metadata();
-    serverHeaders.put(asciiKey, "server");
-    serverHeaders.put(asciiKey, "dupvalue");
-    serverHeaders.put(asciiKey, "dupvalue");
-    serverHeaders.put(binaryKey, "äbinaryserver");
-    Metadata serverHeadersCopy = new Metadata();
-    serverHeadersCopy.merge(serverHeaders);
-    serverStream.writeHeaders(serverHeaders);
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS)).headersRead(metadataCaptor.capture());
-    assertEquals(Lists.newArrayList(serverHeadersCopy.getAll(asciiKey)),
-        Lists.newArrayList(metadataCaptor.getValue().getAll(asciiKey)));
-    assertEquals(Lists.newArrayList(serverHeadersCopy.getAll(binaryKey)),
-        Lists.newArrayList(metadataCaptor.getValue().getAll(binaryKey)));
-
-    clientStream.request(1);
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).onReady();
-    assertTrue(serverStream.isReady());
-    serverStream.writeMessage(methodDescriptor.streamResponse("Hi. Who are you?"));
-    serverStream.flush();
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS)).messageRead(inputStreamCaptor.capture());
-    assertEquals("Hi. Who are you?", methodDescriptor.parseResponse(inputStreamCaptor.getValue()));
-    inputStreamCaptor.getValue().close();
-
-    Status status = Status.OK.withDescription("That was normal");
-    Metadata trailers = new Metadata();
-    trailers.put(asciiKey, "trailers");
-    trailers.put(asciiKey, "dupvalue");
-    trailers.put(asciiKey, "dupvalue");
-    trailers.put(binaryKey, "äbinarytrailers");
-    serverStream.close(status, trailers);
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).closed(statusCaptor.capture());
-    assertCodeEquals(Status.OK, statusCaptor.getValue());
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS))
-        .closed(statusCaptor.capture(), metadataCaptor.capture());
-    assertEquals(status.getCode(), statusCaptor.getValue().getCode());
-    assertEquals(status.getDescription(), statusCaptor.getValue().getDescription());
-    assertEquals(Lists.newArrayList(trailers.getAll(asciiKey)),
-        Lists.newArrayList(metadataCaptor.getValue().getAll(asciiKey)));
-    assertEquals(Lists.newArrayList(trailers.getAll(binaryKey)),
-        Lists.newArrayList(metadataCaptor.getValue().getAll(binaryKey)));
-  }
-
-  @Test
-  @SuppressWarnings("deprecation")
-  public void authorityPropagation() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-            = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-
-    Metadata clientHeaders = new Metadata();
-    ClientStream clientStream = client.newStream(methodDescriptor, clientHeaders);
-    clientStream.start(mockClientStreamListener);
-    StreamCreation serverStreamCreation
-            = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    ServerStream serverStream = serverStreamCreation.stream;
-
-    assertEquals(testAuthority(server), serverStream.getAuthority());
-  }
-
-  @Test
-  public void zeroMessageStream() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata());
-    clientStream.start(mockClientStreamListener);
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    ServerStream serverStream = serverStreamCreation.stream;
-    ServerStreamListener mockServerStreamListener = serverStreamCreation.listener;
-
-    clientStream.halfClose();
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).halfClosed();
-
-    serverStream.writeHeaders(new Metadata());
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS)).headersRead(any(Metadata.class));
-
-    Status status = Status.OK.withDescription("Nice talking to you");
-    serverStream.close(status, new Metadata());
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).closed(statusCaptor.capture());
-    assertCodeEquals(Status.OK, statusCaptor.getValue());
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS))
-        .closed(statusCaptor.capture(), any(Metadata.class));
-    assertEquals(status.getCode(), statusCaptor.getValue().getCode());
-    assertEquals(status.getDescription(), statusCaptor.getValue().getDescription());
-  }
-
-  @Test
-  public void earlyServerClose_withServerHeaders() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata());
-    clientStream.start(mockClientStreamListener);
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    ServerStream serverStream = serverStreamCreation.stream;
-    ServerStreamListener mockServerStreamListener = serverStreamCreation.listener;
-
-    serverStream.writeHeaders(new Metadata());
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS)).headersRead(any(Metadata.class));
-
-    Status status = Status.OK.withDescription("Hello. Goodbye.").withCause(new Exception());
-    serverStream.close(status, new Metadata());
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).closed(statusCaptor.capture());
-    assertCodeEquals(Status.OK, statusCaptor.getValue());
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS))
-        .closed(statusCaptor.capture(), any(Metadata.class));
-    assertEquals(status.getCode(), statusCaptor.getValue().getCode());
-    assertEquals("Hello. Goodbye.", statusCaptor.getValue().getDescription());
-    assertNull(statusCaptor.getValue().getCause());
-  }
-
-  @Test
-  public void earlyServerClose_noServerHeaders() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata());
-    clientStream.start(mockClientStreamListener);
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    ServerStream serverStream = serverStreamCreation.stream;
-    ServerStreamListener mockServerStreamListener = serverStreamCreation.listener;
-
-    Status status = Status.OK.withDescription("Hellogoodbye").withCause(new Exception());
-    Metadata trailers = new Metadata();
-    trailers.put(asciiKey, "trailers");
-    trailers.put(asciiKey, "dupvalue");
-    trailers.put(asciiKey, "dupvalue");
-    trailers.put(binaryKey, "äbinarytrailers");
-    serverStream.close(status, trailers);
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).closed(statusCaptor.capture());
-    assertCodeEquals(Status.OK, statusCaptor.getValue());
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS))
-        .closed(statusCaptor.capture(), metadataCaptor.capture());
-    assertEquals(status.getCode(), statusCaptor.getValue().getCode());
-    assertEquals("Hellogoodbye", statusCaptor.getValue().getDescription());
-    // Cause should not be transmitted to the client.
-    assertNull(statusCaptor.getValue().getCause());
-    assertEquals(Lists.newArrayList(trailers.getAll(asciiKey)),
-        Lists.newArrayList(metadataCaptor.getValue().getAll(asciiKey)));
-    assertEquals(Lists.newArrayList(trailers.getAll(binaryKey)),
-        Lists.newArrayList(metadataCaptor.getValue().getAll(binaryKey)));
-  }
-
-  @Test
-  public void earlyServerClose_serverFailure() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata());
-    clientStream.start(mockClientStreamListener);
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    ServerStream serverStream = serverStreamCreation.stream;
-    ServerStreamListener mockServerStreamListener = serverStreamCreation.listener;
-
-    Status status =
-        Status.INTERNAL.withDescription("I'm not listening").withCause(new Exception());
-    serverStream.close(status, new Metadata());
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).closed(statusCaptor.capture());
-    assertCodeEquals(Status.OK, statusCaptor.getValue());
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS))
-        .closed(statusCaptor.capture(), any(Metadata.class));
-    assertEquals(status.getCode(), statusCaptor.getValue().getCode());
-    assertEquals(status.getDescription(), statusCaptor.getValue().getDescription());
-    assertNull(statusCaptor.getValue().getCause());
-  }
-
-  @Test
-  public void clientCancel() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata());
-    clientStream.start(mockClientStreamListener);
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    ServerStreamListener mockServerStreamListener = serverStreamCreation.listener;
-
-    Status status = Status.CANCELLED.withDescription("Nevermind").withCause(new Exception());
-    clientStream.cancel(status);
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS))
-        .closed(Matchers.same(status), any(Metadata.class));
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).closed(statusCaptor.capture());
-    assertNotEquals(Status.Code.OK, statusCaptor.getValue().getCode());
-    // Cause should not be transmitted between client and server
-    assertNull(statusCaptor.getValue().getCause());
-
-    reset(mockServerStreamListener);
-    reset(mockClientStreamListener);
-    clientStream.cancel(status);
-    verify(mockServerStreamListener, never()).closed(any(Status.class));
-    verify(mockClientStreamListener, never()).closed(any(Status.class), any(Metadata.class));
-  }
-
-  @Test
-  public void clientCancelFromWithinMessageRead() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-
-    final SettableFuture<Boolean> closedCalled = SettableFuture.create();
-    final ClientStream clientStream = client.newStream(methodDescriptor, new Metadata());
-    clientStream.start(new ClientStreamListener() {
-      @Override
-      public void headersRead(Metadata headers) {
-      }
-
-      @Override
-      public void closed(Status status, Metadata trailers) {
-        assertEquals(Status.CANCELLED.getCode(), status.getCode());
-        assertEquals("nevermind", status.getDescription());
-        closedCalled.set(true);
-      }
-
-      @Override
-      public void messageRead(InputStream message) {
-        assertEquals("foo", methodDescriptor.parseResponse(message));
-        clientStream.cancel(Status.CANCELLED.withDescription("nevermind"));
-      }
-
-      @Override
-      public void onReady() {
-      }
-    });
-    clientStream.halfClose();
-    clientStream.request(1);
-
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    assertEquals(methodDescriptor.getFullMethodName(), serverStreamCreation.method);
-    ServerStream serverStream = serverStreamCreation.stream;
-    ServerStreamListener mockServerStreamListener = serverStreamCreation.listener;
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).onReady();
-
-    assertTrue(serverStream.isReady());
-    serverStream.writeHeaders(new Metadata());
-    serverStream.writeMessage(methodDescriptor.streamRequest("foo"));
-    serverStream.flush();
-
-    // Block until closedCalled was set.
-    closedCalled.get(5, TimeUnit.SECONDS);
-
-    serverStream.close(Status.OK, new Metadata());
-  }
-
-  @Test
-  public void serverCancel() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata());
-    clientStream.start(mockClientStreamListener);
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    ServerStream serverStream = serverStreamCreation.stream;
-    ServerStreamListener mockServerStreamListener = serverStreamCreation.listener;
-
-    Status status = Status.DEADLINE_EXCEEDED.withDescription("It was bound to happen")
-        .withCause(new Exception());
-    serverStream.cancel(status);
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).closed(Matchers.same(status));
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS))
-        .closed(statusCaptor.capture(), any(Metadata.class));
-    // Presently we can't sent much back to the client in this case. Verify that is the current
-    // behavior for consistency between transports.
-    assertCodeEquals(Status.CANCELLED, statusCaptor.getValue());
-    // Cause should not be transmitted between server and client
-    assertNull(statusCaptor.getValue().getCause());
-
-    // Second cancellation shouldn't trigger additional callbacks
-    reset(mockServerStreamListener);
-    reset(mockClientStreamListener);
-    serverStream.cancel(status);
-    doPingPong(serverListener);
-    verify(mockServerStreamListener, never()).closed(any(Status.class));
-    verify(mockClientStreamListener, never()).closed(any(Status.class), any(Metadata.class));
-  }
-
-  @Test
-  public void flowControlPushBack() throws Exception {
-    server.start(serverListener);
-    client = newClientTransport(server);
-    runIfNotNull(client.start(mockClientTransportListener));
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    serverTransport = serverTransportListener.transport;
-
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata());
-    clientStream.start(mockClientStreamListener);
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    assertEquals(methodDescriptor.getFullMethodName(), serverStreamCreation.method);
-    ServerStream serverStream = serverStreamCreation.stream;
-    ServerStreamListener mockServerStreamListener = serverStreamCreation.listener;
-    serverStream.writeHeaders(new Metadata());
-
-    Answer<Void> closeStream = new Answer<Void>() {
-      @Override
-      public Void answer(InvocationOnMock invocation) throws Exception {
-        Object[] args = invocation.getArguments();
-        ((InputStream) args[0]).close();
-        return null;
-      }
-    };
-
-    String largeMessage;
-    {
-      int size = 1 * 1024;
-      StringBuffer sb = new StringBuffer(size);
-      for (int i = 0; i < size; i++) {
-        sb.append('a');
-      }
-      largeMessage = sb.toString();
-    }
-
-    doAnswer(closeStream).when(mockServerStreamListener).messageRead(any(InputStream.class));
-    serverStream.request(1);
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS)).onReady();
-    assertTrue(clientStream.isReady());
-    final int maxToSend = 10 * 1024;
-    int clientSent;
-    // Verify that flow control will push back on client.
-    for (clientSent = 0; clientStream.isReady(); clientSent++) {
-      if (clientSent > maxToSend) {
-        // It seems like flow control isn't working. _Surely_ flow control would have pushed-back
-        // already. If this is normal, please configure the transport to buffer less.
-        fail("Too many messages sent before isReady() returned false");
-      }
-      clientStream.writeMessage(methodDescriptor.streamRequest(largeMessage));
-      clientStream.flush();
-    }
-    assertTrue(clientSent > 0);
-    // Make sure there are at least a few messages buffered.
-    for (; clientSent < 5; clientSent++) {
-      clientStream.writeMessage(methodDescriptor.streamResponse(largeMessage));
-      clientStream.flush();
-    }
-    doPingPong(serverListener);
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).messageRead(any(InputStream.class));
-
-    doAnswer(closeStream).when(mockClientStreamListener).messageRead(any(InputStream.class));
-    clientStream.request(1);
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).onReady();
-    assertTrue(serverStream.isReady());
-    int serverSent;
-    // Verify that flow control will push back on server.
-    for (serverSent = 0; serverStream.isReady(); serverSent++) {
-      if (serverSent > maxToSend) {
-        // It seems like flow control isn't working. _Surely_ flow control would have pushed-back
-        // already. If this is normal, please configure the transport to buffer less.
-        fail("Too many messages sent before isReady() returned false");
-      }
-      serverStream.writeMessage(methodDescriptor.streamResponse(largeMessage));
-      serverStream.flush();
-    }
-    assertTrue(serverSent > 0);
-    // Make sure there are at least a few messages buffered.
-    for (; serverSent < 5; serverSent++) {
-      serverStream.writeMessage(methodDescriptor.streamResponse(largeMessage));
-      serverStream.flush();
-    }
-    doPingPong(serverListener);
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS)).messageRead(any(InputStream.class));
-
-    serverStream.request(3);
-    clientStream.request(3);
-    doPingPong(serverListener);
-    // times() is total number throughout the entire test
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS).times(4))
-        .messageRead(any(InputStream.class));
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS).times(4))
-        .messageRead(any(InputStream.class));
-
-    // Request the rest
-    serverStream.request(clientSent);
-    clientStream.request(serverSent);
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS).times(clientSent))
-        .messageRead(any(InputStream.class));
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS).times(serverSent))
-        .messageRead(any(InputStream.class));
-
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS).times(2)).onReady();
-    assertTrue(clientStream.isReady());
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS).times(2)).onReady();
-    assertTrue(serverStream.isReady());
-
-    // Request four more
-    for (int i = 0; i < 5; i++) {
-      clientStream.writeMessage(methodDescriptor.streamRequest(largeMessage));
-      clientStream.flush();
-      serverStream.writeMessage(methodDescriptor.streamResponse(largeMessage));
-      serverStream.flush();
-    }
-    doPingPong(serverListener);
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS).times(clientSent + 4))
-        .messageRead(any(InputStream.class));
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS).times(serverSent + 4))
-        .messageRead(any(InputStream.class));
-
-    // Drain exactly how many messages are left
-    serverStream.request(1);
-    clientStream.request(1);
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS).times(serverSent + 5))
-        .messageRead(any(InputStream.class));
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS).times(clientSent + 5))
-        .messageRead(any(InputStream.class));
-
-    // And now check that the streams can still complete gracefully
-    clientStream.writeMessage(methodDescriptor.streamRequest(largeMessage));
-    clientStream.flush();
-    clientStream.halfClose();
-    doPingPong(serverListener);
-    verify(mockServerStreamListener, never()).halfClosed();
-
-    serverStream.request(1);
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS).times(serverSent + 6))
-        .messageRead(any(InputStream.class));
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).halfClosed();
-
-    serverStream.writeMessage(methodDescriptor.streamResponse(largeMessage));
-    serverStream.flush();
-    Status status = Status.OK.withDescription("... quite a lengthy discussion");
-    serverStream.close(status, new Metadata());
-    doPingPong(serverListener);
-    verify(mockClientStreamListener, never()).closed(any(Status.class), any(Metadata.class));
-
-    clientStream.request(1);
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS).times(clientSent + 6))
-        .messageRead(any(InputStream.class));
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).closed(statusCaptor.capture());
-    assertCodeEquals(Status.OK, statusCaptor.getValue());
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS))
-        .closed(statusCaptor.capture(), any(Metadata.class));
-    assertEquals(status.getCode(), statusCaptor.getValue().getCode());
-    assertEquals(status.getDescription(), statusCaptor.getValue().getDescription());
-  }
-
-  /**
-   * Helper that simply does an RPC. It can be used similar to a sleep for negative testing: to give
-   * time for actions _not_ to happen. Since it is based on doing an actual RPC with actual
-   * callbacks, it generally provides plenty of time for Runnables to execute. But it is also faster
-   * on faster machines and more reliable on slower machines.
-   */
-  private void doPingPong(MockServerListener serverListener) throws InterruptedException {
-    ManagedClientTransport client = newClientTransport(server);
-    runIfNotNull(client.start(mock(ManagedClientTransport.Listener.class)));
-    ClientStream clientStream = client.newStream(methodDescriptor, new Metadata());
-    ClientStreamListener mockClientStreamListener = mock(ClientStreamListener.class);
-    clientStream.start(mockClientStreamListener);
-
-    MockServerTransportListener serverTransportListener
-        = serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    StreamCreation serverStreamCreation
-        = serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
-    ServerStream serverStream = serverStreamCreation.stream;
-    ServerStreamListener mockServerStreamListener = serverStreamCreation.listener;
-
-    serverStream.close(Status.OK, new Metadata());
-    verify(mockClientStreamListener, timeout(TIMEOUT_MS))
-        .closed(any(Status.class), any(Metadata.class));
-    verify(mockServerStreamListener, timeout(TIMEOUT_MS)).closed(any(Status.class));
-    client.shutdown();
-  }
-
-  /**
-   * Only assert that the Status.Code matches, but provide the entire actual result in case the
-   * assertion fails.
-   */
-  private static void assertCodeEquals(String message, Status expected, Status actual) {
-    if (expected == null) {
-      fail("expected should not be null");
-    }
-    if (actual == null || !expected.getCode().equals(actual.getCode())) {
-      assertEquals(message, expected, actual);
-    }
-  }
-
-  private static void assertCodeEquals(Status expected, Status actual) {
-    assertCodeEquals(null, expected, actual);
-  }
-
-  private static boolean waitForFuture(Future<?> future, long timeout, TimeUnit unit)
-      throws InterruptedException {
-    try {
-      future.get(timeout, unit);
-    } catch (ExecutionException ex) {
-      throw new AssertionError(ex);
-    } catch (TimeoutException ex) {
-      return false;
-    }
-    return true;
-  }
-
-  private static void runIfNotNull(Runnable runnable) {
-    if (runnable != null) {
-      runnable.run();
-    }
-  }
-
-  private static class MockServerListener implements ServerListener {
-    public final BlockingQueue<MockServerTransportListener> listeners
-        = new LinkedBlockingQueue<MockServerTransportListener>();
-    private final SettableFuture<?> shutdown = SettableFuture.create();
-
-    @Override
-    public ServerTransportListener transportCreated(ServerTransport transport) {
-      MockServerTransportListener listener = new MockServerTransportListener(transport);
-      listeners.add(listener);
-      return listener;
-    }
-
-    @Override
-    public void serverShutdown() {
-      assertTrue(shutdown.set(null));
-    }
-
-    public boolean waitForShutdown(long timeout, TimeUnit unit) throws InterruptedException {
-      return waitForFuture(shutdown, timeout, unit);
-    }
-
-    public MockServerTransportListener takeListenerOrFail(long timeout, TimeUnit unit)
-        throws InterruptedException {
-      MockServerTransportListener listener = listeners.poll(timeout, unit);
-      if (listener == null) {
-        fail("Timed out waiting for server transport");
-      }
-      return listener;
-    }
-  }
-
-  private static class MockServerTransportListener implements ServerTransportListener {
-    public final ServerTransport transport;
-    public final BlockingQueue<StreamCreation> streams = new LinkedBlockingQueue<StreamCreation>();
-    private final SettableFuture<?> terminated = SettableFuture.create();
-
-    public MockServerTransportListener(ServerTransport transport) {
-      this.transport = transport;
-    }
-
-    @Override
-    public StatsTraceContext methodDetermined(String method, Metadata headers) {
-      return StatsTraceContext.NOOP;
-    }
-
-    @Override
-    public void streamCreated(ServerStream stream, String method, Metadata headers) {
-      ServerStreamListener listener = mock(ServerStreamListener.class);
-      streams.add(new StreamCreation(stream, method, headers, listener));
-      stream.setListener(listener);
-    }
-
-    @Override
-    public Attributes transportReady(Attributes attributes) {
-      return Attributes.newBuilder()
-          .setAll(attributes)
-          .set(ADDITIONAL_TRANSPORT_ATTR_KEY, "additional attribute value")
-          .build();
-    }
-
-    @Override
-    public void transportTerminated() {
-      assertTrue(terminated.set(null));
-    }
-
-    public boolean waitForTermination(long timeout, TimeUnit unit) throws InterruptedException {
-      return waitForFuture(terminated, timeout, unit);
-    }
-
-    public boolean isTerminated() {
-      return terminated.isDone();
-    }
-
-    public StreamCreation takeStreamOrFail(long timeout, TimeUnit unit)
-        throws InterruptedException {
-      StreamCreation stream = streams.poll(timeout, unit);
-      if (stream == null) {
-        fail("Timed out waiting for server stream");
-      }
-      return stream;
-    }
-  }
-
-  private static class StreamCreation {
-    public final ServerStream stream;
-    public final String method;
-    public final Metadata headers;
-    public final ServerStreamListener listener;
-
-    public StreamCreation(ServerStream stream, String method,
-        Metadata headers, ServerStreamListener listener) {
-      this.stream = stream;
-      this.method = method;
-      this.headers = headers;
-      this.listener = listener;
-    }
-  }
-
-  private static class StringMarshaller implements MethodDescriptor.Marshaller<String> {
-    public static final StringMarshaller INSTANCE = new StringMarshaller();
-
-    @Override
-    public InputStream stream(String value) {
-      return new ByteArrayInputStream(value.getBytes(UTF_8));
-    }
-
-    @Override
-    public String parse(InputStream stream) {
-      try {
-        return new String(ByteStreams.toByteArray(stream), UTF_8);
-      } catch (IOException ex) {
-        throw new RuntimeException(ex);
-      }
-    }
-  }
-
-  private static class StringBinaryMarshaller implements Metadata.BinaryMarshaller<String> {
-    public static final StringBinaryMarshaller INSTANCE = new StringBinaryMarshaller();
-
-    @Override
-    public byte[] toBytes(String value) {
-      return value.getBytes(UTF_8);
-    }
-
-    @Override
-    public String parseBytes(byte[] serialized) {
-      return new String(serialized, UTF_8);
-    }
-  }
-}
diff --git a/testing/src/main/java/io/grpc/internal/testing/FakeNameResolverProvider.java b/testing/src/main/java/io/grpc/internal/testing/FakeNameResolverProvider.java
new file mode 100644
index 00000000000..c77f7f8945a
--- /dev/null
+++ b/testing/src/main/java/io/grpc/internal/testing/FakeNameResolverProvider.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2021 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.internal.testing;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.NameResolverProvider;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.Collection;
+import java.util.Collections;
+
+/** A name resolver to always resolve the given URI into the given address. */
+public final class FakeNameResolverProvider extends NameResolverProvider {
+
+  private final URI targetUri;
+  private final SocketAddress address;
+
+  public FakeNameResolverProvider(String targetUri, SocketAddress address) {
+    this.targetUri = URI.create(targetUri);
+    this.address = address;
+  }
+
+  @Override
+  public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+    if (targetUri.equals(this.targetUri)) {
+      return new FakeNameResolver(address);
+    }
+    return null;
+  }
+
+  @Override
+  protected boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  protected int priority() {
+    return 10; // High priority
+  }
+
+  @Override
+  public String getDefaultScheme() {
+    return targetUri.getScheme();
+  }
+
+  @Override
+  public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+    return Collections.singleton(address.getClass());
+  }
+
+  /** A single name resolver. */
+  private static final class FakeNameResolver extends NameResolver {
+    private static final String AUTHORITY = "fake-authority";
+
+    private final SocketAddress address;
+    private volatile boolean shutdown;
+
+    private FakeNameResolver(SocketAddress address) {
+      this.address = address;
+    }
+
+    @Override
+    public void start(Listener2 listener) {
+      if (shutdown) {
+        listener.onError(Status.FAILED_PRECONDITION.withDescription("Resolver is shutdown"));
+      } else {
+        listener.onResult2(
+            ResolutionResult.newBuilder()
+                .setAddressesOrError(
+                    StatusOr.fromValue(ImmutableList.of(new EquivalentAddressGroup(address))))
+                .build());
+      }
+    }
+
+    @Override
+    public String getServiceAuthority() {
+      return AUTHORITY;
+    }
+
+    @Override
+    public void shutdown() {
+      shutdown = true;
+    }
+  }
+}
diff --git a/testing/src/main/java/io/grpc/internal/testing/StatsTestUtils.java b/testing/src/main/java/io/grpc/internal/testing/StatsTestUtils.java
index d99b81fbc99..a15559ed5cb 100644
--- a/testing/src/main/java/io/grpc/internal/testing/StatsTestUtils.java
+++ b/testing/src/main/java/io/grpc/internal/testing/StatsTestUtils.java
@@ -1,51 +1,61 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.internal.testing;
 
-import static com.google.common.base.Charsets.UTF_8;
 import static com.google.common.base.Preconditions.checkNotNull;
+import static java.nio.charset.StandardCharsets.UTF_8;
 
+import com.google.common.base.Function;
 import com.google.common.collect.ImmutableMap;
-import com.google.instrumentation.stats.MeasurementDescriptor;
-import com.google.instrumentation.stats.MeasurementMap;
-import com.google.instrumentation.stats.MeasurementValue;
-import com.google.instrumentation.stats.StatsContext;
-import com.google.instrumentation.stats.StatsContextFactory;
-import com.google.instrumentation.stats.TagKey;
-import com.google.instrumentation.stats.TagValue;
-import io.grpc.internal.IoUtils;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
+import com.google.common.collect.Iterators;
+import com.google.common.collect.Maps;
+import io.grpc.Context;
+import io.opencensus.common.Scope;
+import io.opencensus.stats.Measure;
+import io.opencensus.stats.MeasureMap;
+import io.opencensus.stats.StatsRecorder;
+import io.opencensus.tags.Tag;
+import io.opencensus.tags.TagContext;
+import io.opencensus.tags.TagContextBuilder;
+import io.opencensus.tags.TagKey;
+import io.opencensus.tags.TagMetadata;
+import io.opencensus.tags.TagMetadata.TagTtl;
+import io.opencensus.tags.TagValue;
+import io.opencensus.tags.Tagger;
+import io.opencensus.tags.propagation.TagContextBinarySerializer;
+import io.opencensus.tags.propagation.TagContextDeserializationException;
+import io.opencensus.tags.unsafe.ContextUtils;
+import io.opencensus.trace.Annotation;
+import io.opencensus.trace.AttributeValue;
+import io.opencensus.trace.EndSpanOptions;
+import io.opencensus.trace.Link;
+import io.opencensus.trace.MessageEvent;
+import io.opencensus.trace.Sampler;
+import io.opencensus.trace.Span;
+import io.opencensus.trace.SpanBuilder;
+import io.opencensus.trace.SpanContext;
+import io.opencensus.trace.SpanId;
+import io.opencensus.trace.TraceId;
+import io.opencensus.trace.TraceOptions;
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
@@ -56,10 +66,12 @@ private StatsTestUtils() {
   }
 
   public static class MetricsRecord {
+
     public final ImmutableMap<TagKey, TagValue> tags;
-    public final MeasurementMap metrics;
+    public final ImmutableMap<Measure, Number> metrics;
 
-    private MetricsRecord(ImmutableMap<TagKey, TagValue> tags, MeasurementMap metrics) {
+    private MetricsRecord(
+        ImmutableMap<TagKey, TagValue> tags, ImmutableMap<Measure, Number> metrics) {
       this.tags = tags;
       this.metrics = metrics;
     }
@@ -68,10 +80,16 @@ private MetricsRecord(ImmutableMap<TagKey, TagValue> tags, MeasurementMap metric
      * Returns the value of a metric, or {@code null} if not found.
      */
     @Nullable
-    public Double getMetric(MeasurementDescriptor metricName) {
-      for (MeasurementValue m : metrics) {
-        if (m.getMeasurement().equals(metricName)) {
-          return m.getValue();
+    public Double getMetric(Measure measure) {
+      for (Map.Entry<Measure, Number> m : metrics.entrySet()) {
+        if (m.getKey().equals(measure)) {
+          Number value = m.getValue();
+          if (value instanceof Double) {
+            return (Double) value;
+          } else if (value instanceof Long) {
+            return (double) (Long) value;
+          }
+          throw new AssertionError("Unexpected measure value type: " + value.getClass().getName());
         }
       }
       return null;
@@ -80,51 +98,45 @@ public Double getMetric(MeasurementDescriptor metricName) {
     /**
      * Returns the value of a metric converted to long, or throw if not found.
      */
-    public long getMetricAsLongOrFail(MeasurementDescriptor metricName) {
-      Double doubleValue = getMetric(metricName);
-      checkNotNull(doubleValue, "Metric not found: %s", metricName.toString());
+    public long getMetricAsLongOrFail(Measure measure) {
+      Double doubleValue = getMetric(measure);
+      checkNotNull(doubleValue, "Measure not found: %s", measure.getName());
       long longValue = (long) (Math.abs(doubleValue) + 0.0001);
       if (doubleValue < 0) {
         longValue = -longValue;
       }
       return longValue;
     }
+
+    @Override
+    public String toString() {
+      return "[tags=" + tags + ", metrics=" + metrics + "]";
+    }
   }
 
   /**
-   * This tag will be propagated by {@link FakeStatsContextFactory} on the wire.
+   * This tag will be propagated by {@link FakeTagger} on the wire.
    */
   public static final TagKey EXTRA_TAG = TagKey.create("/rpc/test/extratag");
 
   private static final String EXTRA_TAG_HEADER_VALUE_PREFIX = "extratag:";
-  private static final String NO_EXTRA_TAG_HEADER_VALUE_PREFIX = "noextratag";
 
   /**
-   * A factory that makes fake {@link StatsContext}s and saves the created contexts to be
-   * accessible from {@link #pollContextOrFail}.  The contexts it has created would save metrics
-   * records to be accessible from {@link #pollRecord()} and {@link #pollRecord(long, TimeUnit)},
-   * until {@link #rolloverRecords} is called.
+   * A {@link Tagger} implementation that saves metrics records to be accessible from {@link
+   * #pollRecord()} and {@link #pollRecord(long, TimeUnit)}, until {@link #rolloverRecords} is
+   * called.
    */
-  public static final class FakeStatsContextFactory extends StatsContextFactory {
+  public static final class FakeStatsRecorder extends StatsRecorder {
+
     private BlockingQueue<MetricsRecord> records;
-    public final BlockingQueue<FakeStatsContext> contexts =
-        new LinkedBlockingQueue<FakeStatsContext>();
-    private final FakeStatsContext defaultContext;
 
-    /**
-     * Constructor.
-     */
-    public FakeStatsContextFactory() {
-      rolloverRecords();
-      defaultContext = new FakeStatsContext(ImmutableMap.<TagKey, TagValue>of(), this);
-      // The records on the default context is not visible from pollRecord(), just like it's
-      // not visible from pollContextOrFail() either.
+    public FakeStatsRecorder() {
       rolloverRecords();
     }
 
-    public StatsContext pollContextOrFail() {
-      StatsContext cc = contexts.poll();
-      return checkNotNull(cc);
+    @Override
+    public MeasureMap newMeasureMap() {
+      return new FakeStatsRecord(this);
     }
 
     public MetricsRecord pollRecord() {
@@ -135,37 +147,14 @@ public MetricsRecord pollRecord(long timeout, TimeUnit unit) throws InterruptedE
       return getCurrentRecordSink().poll(timeout, unit);
     }
 
-    @Override
-    public StatsContext deserialize(InputStream buffer) {
-      String serializedString;
-      try {
-        serializedString = new String(IoUtils.toByteArray(buffer), UTF_8);
-      } catch (IOException e) {
-        throw new RuntimeException(e);
-      }
-      if (serializedString.startsWith(EXTRA_TAG_HEADER_VALUE_PREFIX)) {
-        return getDefault().with(EXTRA_TAG,
-            TagValue.create(serializedString.substring(EXTRA_TAG_HEADER_VALUE_PREFIX.length())));
-      } else if (serializedString.startsWith(NO_EXTRA_TAG_HEADER_VALUE_PREFIX)) {
-        return getDefault();
-      } else {
-        return null;
-      }
-    }
-
-    @Override
-    public FakeStatsContext getDefault() {
-      return defaultContext;
-    }
-
     /**
-     * Disconnect this factory with the contexts it has created so far.  The records from those
+     * Disconnect this tagger with the contexts it has created so far.  The records from those
      * contexts will not show up in {@link #pollRecord}.  Useful for isolating the records between
      * test cases.
      */
     // This needs to be synchronized with getCurrentRecordSink() which may run concurrently.
     public synchronized void rolloverRecords() {
-      records = new LinkedBlockingQueue<MetricsRecord>();
+      records = new LinkedBlockingQueue<>();
     }
 
     private synchronized BlockingQueue<MetricsRecord> getCurrentRecordSink() {
@@ -173,83 +162,238 @@ private synchronized BlockingQueue<MetricsRecord> getCurrentRecordSink() {
     }
   }
 
-  public static class FakeStatsContext extends StatsContext {
-    private final ImmutableMap<TagKey, TagValue> tags;
-    private final FakeStatsContextFactory factory;
+  public static final class FakeTagger extends Tagger {
+
+    @Override
+    public FakeTagContext empty() {
+      return FakeTagContext.EMPTY;
+    }
+
+    @Override
+    public TagContext getCurrentTagContext() {
+      return ContextUtils.getValue(Context.current());
+    }
+
+    @Override
+    public TagContextBuilder emptyBuilder() {
+      return new FakeTagContextBuilder(ImmutableMap.<TagKey, TagValue>of());
+    }
+
+    @Override
+    public FakeTagContextBuilder toBuilder(TagContext tags) {
+      return new FakeTagContextBuilder(getTags(tags));
+    }
+
+    @Override
+    public TagContextBuilder currentBuilder() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Scope withTagContext(TagContext tags) {
+      throw new UnsupportedOperationException();
+    }
+  }
+
+  public static final class FakeTagContextBinarySerializer extends TagContextBinarySerializer {
+
+    private final FakeTagger tagger = new FakeTagger();
+
+    @Override
+    public TagContext fromByteArray(byte[] bytes) throws TagContextDeserializationException {
+      String serializedString = new String(bytes, UTF_8);
+      if (serializedString.startsWith(EXTRA_TAG_HEADER_VALUE_PREFIX)) {
+        return tagger.emptyBuilder()
+            .putLocal(EXTRA_TAG,
+                TagValue.create(serializedString.substring(EXTRA_TAG_HEADER_VALUE_PREFIX.length())))
+            .build();
+      } else {
+        throw new TagContextDeserializationException("Malformed value");
+      }
+    }
+
+    @Override
+    public byte[] toByteArray(TagContext tags) {
+      TagValue extraTagValue = getTags(tags).get(EXTRA_TAG);
+      if (extraTagValue == null) {
+        throw new UnsupportedOperationException("TagContext must contain EXTRA_TAG");
+      }
+      return (EXTRA_TAG_HEADER_VALUE_PREFIX + extraTagValue.asString()).getBytes(UTF_8);
+    }
+  }
+
+  public static final class FakeStatsRecord extends MeasureMap {
+
     private final BlockingQueue<MetricsRecord> recordSink;
+    public final Map<Measure, Number> metrics = Maps.newHashMap();
 
-    private FakeStatsContext(ImmutableMap<TagKey, TagValue> tags,
-        FakeStatsContextFactory factory) {
-      this.tags = tags;
-      this.factory = factory;
-      this.recordSink = factory.getCurrentRecordSink();
+    private FakeStatsRecord(FakeStatsRecorder statsRecorder) {
+      this.recordSink = statsRecorder.getCurrentRecordSink();
     }
 
     @Override
-    public Builder builder() {
-      return new FakeStatsContextBuilder(this);
+    public MeasureMap put(Measure.MeasureDouble measure, double value) {
+      metrics.put(measure, value);
+      return this;
     }
 
     @Override
-    public StatsContext record(MeasurementMap metrics) {
-      recordSink.add(new MetricsRecord(tags, metrics));
+    public MeasureMap put(Measure.MeasureLong measure, long value) {
+      metrics.put(measure, value);
       return this;
     }
 
     @Override
-    public void serialize(OutputStream os) {
-      TagValue extraTagValue = tags.get(EXTRA_TAG);
-      try {
-        if (extraTagValue == null) {
-          os.write(NO_EXTRA_TAG_HEADER_VALUE_PREFIX.getBytes(UTF_8));
-        } else {
-          os.write((EXTRA_TAG_HEADER_VALUE_PREFIX + extraTagValue.toString()).getBytes(UTF_8));
-        }
-      } catch (IOException e) {
-        throw new RuntimeException(e);
-      }
+    public void record(TagContext tags) {
+      recordSink.add(new MetricsRecord(getTags(tags), ImmutableMap.copyOf(metrics)));
     }
 
     @Override
-    public String toString() {
-      return "[tags=" + tags + "]";
+    public void record() {
+      throw new UnsupportedOperationException();
+    }
+  }
+
+  public static final class FakeTagContext extends TagContext {
+
+    private static final FakeTagContext EMPTY =
+        new FakeTagContext(ImmutableMap.<TagKey, TagValue>of());
+
+    private static final TagMetadata METADATA_PROPAGATING =
+        TagMetadata.create(TagTtl.UNLIMITED_PROPAGATION);
+
+    private final ImmutableMap<TagKey, TagValue> tags;
+
+    private FakeTagContext(ImmutableMap<TagKey, TagValue> tags) {
+      this.tags = tags;
+    }
+
+    public ImmutableMap<TagKey, TagValue> getTags() {
+      return tags;
     }
 
     @Override
-    public boolean equals(Object other) {
-      if (!(other instanceof FakeStatsContext)) {
-        return false;
-      }
-      FakeStatsContext otherCtx = (FakeStatsContext) other;
-      return tags.equals(otherCtx.tags);
+    public String toString() {
+      return "[tags=" + tags + "]";
     }
 
     @Override
-    public int hashCode() {
-      return tags.hashCode();
+    protected Iterator<Tag> getIterator() {
+      return Iterators.transform(
+          tags.entrySet().iterator(),
+          new Function<Map.Entry<TagKey, TagValue>, Tag>() {
+            @Override
+            public Tag apply(@Nullable Map.Entry<TagKey, TagValue> entry) {
+              return Tag.create(entry.getKey(), entry.getValue(), METADATA_PROPAGATING);
+            }
+          });
     }
   }
 
-  private static class FakeStatsContextBuilder extends StatsContext.Builder {
-    private final ImmutableMap.Builder<TagKey, TagValue> tagsBuilder = ImmutableMap.builder();
-    private final FakeStatsContext base;
+  public static class FakeTagContextBuilder extends TagContextBuilder {
 
-    private FakeStatsContextBuilder(FakeStatsContext base) {
-      this.base = base;
-      tagsBuilder.putAll(base.tags);
+    private final Map<TagKey, TagValue> tagsBuilder = Maps.newHashMap();
+
+    private FakeTagContextBuilder(Map<TagKey, TagValue> tags) {
+      tagsBuilder.putAll(tags);
     }
 
+    @SuppressWarnings("deprecation")
     @Override
-    public StatsContext.Builder set(TagKey key, TagValue value) {
+    public TagContextBuilder put(TagKey key, TagValue value) {
       tagsBuilder.put(key, value);
       return this;
     }
 
     @Override
-    public StatsContext build() {
-      FakeStatsContext context = new FakeStatsContext(tagsBuilder.build(), base.factory);
-      base.factory.contexts.add(context);
+    public TagContextBuilder remove(TagKey key) {
+      tagsBuilder.remove(key);
+      return this;
+    }
+
+    @Override
+    public TagContext build() {
+      FakeTagContext context = new FakeTagContext(ImmutableMap.copyOf(tagsBuilder));
       return context;
     }
+
+    @Override
+    public Scope buildScoped() {
+      throw new UnsupportedOperationException();
+    }
+  }
+
+  // This method handles the default TagContext, which isn't an instance of FakeTagContext.
+  private static ImmutableMap<TagKey, TagValue> getTags(TagContext tags) {
+    return tags instanceof FakeTagContext
+        ? ((FakeTagContext) tags).getTags()
+        : ImmutableMap.<TagKey, TagValue>of();
+  }
+
+  // TODO(bdrutu): Remove this class after OpenCensus releases support for this class.
+  public static class MockableSpan extends Span {
+    /**
+     * Creates a MockableSpan with a random trace ID and span ID.
+     */
+    @SuppressWarnings("deprecation")
+    public static MockableSpan generateRandomSpan(Random random) {
+      return new MockableSpan(
+          SpanContext.create(
+              TraceId.generateRandomId(random),
+              SpanId.generateRandomId(random),
+              TraceOptions.DEFAULT),
+          null);
+    }
+
+    @Override
+    public void putAttributes(Map<String, AttributeValue> attributes) {}
+
+    @Override
+    public void addAnnotation(String description, Map<String, AttributeValue> attributes) {}
+
+    @Override
+    public void addAnnotation(Annotation annotation) {}
+
+    @Override
+    public void addMessageEvent(MessageEvent messageEvent) {}
+
+    @Override
+    public void addLink(Link link) {}
+
+    @Override
+    public void end(EndSpanOptions options) {}
+
+    private MockableSpan(SpanContext context, @Nullable EnumSet<Options> options) {
+      super(context, options);
+    }
+
+    /**
+     * Mockable implementation for the {@link SpanBuilder} class.
+     *
+     * <p>Not {@code final} to allow easy mocking.
+     *
+     */
+    public static class Builder extends SpanBuilder {
+
+      @Override
+      public SpanBuilder setSampler(Sampler sampler) {
+        return this;
+      }
+
+      @Override
+      public SpanBuilder setParentLinks(List<Span> parentLinks) {
+        return this;
+      }
+
+      @Override
+      public SpanBuilder setRecordEvents(boolean recordEvents) {
+        return this;
+      }
+
+      @Override
+      public Span startSpan() {
+        return null;
+      }
+    }
   }
 }
diff --git a/testing/src/main/java/io/grpc/internal/testing/StreamRecorder.java b/testing/src/main/java/io/grpc/internal/testing/StreamRecorder.java
new file mode 100644
index 00000000000..adf092f4fc0
--- /dev/null
+++ b/testing/src/main/java/io/grpc/internal/testing/StreamRecorder.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2014 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.internal.testing;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.stub.StreamObserver;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * Utility implementation of {@link StreamObserver} used in testing. Records all the observed
+ * values produced by the stream as well as any errors.
+ */
+public class StreamRecorder<T> implements StreamObserver<T> {
+
+  /**
+   * Creates a new recorder.
+   */
+  public static <T> StreamRecorder<T> create() {
+    return new StreamRecorder<>();
+  }
+
+  private final CountDownLatch latch;
+  private final List<T> results;
+  private Throwable error;
+  private final SettableFuture<T> firstValue;
+
+  private StreamRecorder() {
+    firstValue = SettableFuture.create();
+    latch = new CountDownLatch(1);
+    results = Collections.synchronizedList(new ArrayList<T>());
+  }
+
+  @Override
+  public void onNext(T value) {
+    if (!firstValue.isDone()) {
+      firstValue.set(value);
+    }
+    results.add(value);
+  }
+
+  @Override
+  public void onError(Throwable t) {
+    if (!firstValue.isDone()) {
+      firstValue.setException(t);
+    }
+    error = t;
+    latch.countDown();
+  }
+
+  @Override
+  public void onCompleted() {
+    if (!firstValue.isDone()) {
+      firstValue.setException(new IllegalStateException("No first value provided"));
+    }
+    latch.countDown();
+  }
+
+  /**
+   * Waits for the stream to terminate.
+   */
+  public void awaitCompletion() throws Exception {
+    latch.await();
+  }
+
+  /**
+   * Waits a fixed timeout for the stream to terminate.
+   */
+  public boolean awaitCompletion(int timeout, TimeUnit unit) throws Exception {
+    return latch.await(timeout, unit);
+  }
+
+  /**
+   * Returns the current set of received values.
+   */
+  public List<T> getValues() {
+    return Collections.unmodifiableList(results);
+  }
+
+  /**
+   * Returns the stream terminating error.
+   */
+  @Nullable public Throwable getError() {
+    return error;
+  }
+
+  /**
+   * Returns a {@link ListenableFuture} for the first value received from the stream. Useful
+   * for testing unary call patterns.
+   */
+  public ListenableFuture<T> firstValue() {
+    return firstValue;
+  }
+}
diff --git a/testing/src/main/java/io/grpc/internal/testing/TestClientStreamTracer.java b/testing/src/main/java/io/grpc/internal/testing/TestClientStreamTracer.java
new file mode 100644
index 00000000000..c4677c496a3
--- /dev/null
+++ b/testing/src/main/java/io/grpc/internal/testing/TestClientStreamTracer.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright 2017 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.internal.testing;
+
+import io.grpc.ClientStreamTracer;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link ClientStreamTracer} suitable for testing.
+ */
+public class TestClientStreamTracer extends ClientStreamTracer implements TestStreamTracer {
+  private final TestBaseStreamTracer delegate = new TestBaseStreamTracer();
+  protected final CountDownLatch outboundHeadersLatch = new CountDownLatch(1);
+  protected final AtomicReference<Throwable> outboundHeadersCalled =
+      new AtomicReference<>();
+  protected final AtomicReference<Throwable> inboundHeadersCalled =
+      new AtomicReference<>();
+  protected final AtomicReference<Metadata> inboundTrailers = new AtomicReference<>();
+
+  @Override
+  public void await() throws InterruptedException {
+    delegate.await();
+  }
+
+  @Override
+  public boolean await(long timeout, TimeUnit timeUnit) throws InterruptedException {
+    return delegate.await(timeout, timeUnit);
+  }
+
+  /**
+   * Returns if {@link ClientStreamTracer#inboundHeaders} has been called.
+   */
+  public boolean getInboundHeaders() {
+    return inboundHeadersCalled.get() != null;
+  }
+
+  /**
+   * Returns the inbound trailers if {@link ClientStreamTracer#inboundTrailers} has been called, or
+   * {@code null}.
+   */
+  @Nullable
+  public Metadata getInboundTrailers() {
+    return inboundTrailers.get();
+  }
+
+  /**
+   * Returns if {@link ClientStreamTracer#outboundHeaders} has been called.
+   */
+  public boolean getOutboundHeaders() {
+    return outboundHeadersCalled.get() != null;
+  }
+
+  /**
+   * Allow tests to await the outbound header event, which depending on the test case may be
+   * necessary (e.g., if we test for a Netty client's outbound headers upon receiving the start of
+   * stream on the server side, the tracer won't know that headers were sent until a channel future
+   * executes).
+   */
+  public boolean awaitOutboundHeaders(int timeout, TimeUnit unit) throws Exception {
+    return outboundHeadersLatch.await(timeout, unit);
+  }
+
+  @Override
+  public Status getStatus() {
+    return delegate.getStatus();
+  }
+
+  @Override
+  public long getInboundWireSize() {
+    return delegate.getInboundWireSize();
+  }
+
+  @Override
+  public long getInboundUncompressedSize() {
+    return delegate.getInboundUncompressedSize();
+  }
+
+  @Override
+  public long getOutboundWireSize() {
+    return delegate.getOutboundWireSize();
+  }
+
+  @Override
+  public long getOutboundUncompressedSize() {
+    return delegate.getOutboundUncompressedSize();
+  }
+
+  @Override
+  public void setFailDuplicateCallbacks(boolean fail) {
+    delegate.setFailDuplicateCallbacks(fail);
+  }
+
+  @Override
+  public String nextOutboundEvent() {
+    return delegate.nextOutboundEvent();
+  }
+
+  @Override
+  public String nextInboundEvent() {
+    return delegate.nextInboundEvent();
+  }
+
+  @Override
+  public void outboundWireSize(long bytes) {
+    delegate.outboundWireSize(bytes);
+  }
+
+  @Override
+  public void inboundWireSize(long bytes) {
+    delegate.inboundWireSize(bytes);
+  }
+
+  @Override
+  public void outboundUncompressedSize(long bytes) {
+    delegate.outboundUncompressedSize(bytes);
+  }
+
+  @Override
+  public void inboundUncompressedSize(long bytes) {
+    delegate.inboundUncompressedSize(bytes);
+  }
+
+  @Override
+  public void streamClosed(Status status) {
+    delegate.streamClosed(status);
+  }
+
+  @Override
+  public void inboundMessage(int seqNo) {
+    delegate.inboundMessage(seqNo);
+  }
+
+  @Override
+  public void outboundMessage(int seqNo) {
+    delegate.outboundMessage(seqNo);
+  }
+
+  @Override
+  public void outboundMessageSent(int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+    delegate.outboundMessageSent(seqNo, optionalWireSize, optionalUncompressedSize);
+  }
+
+  @Override
+  public void inboundMessageRead(int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+    delegate.inboundMessageRead(seqNo, optionalWireSize, optionalUncompressedSize);
+  }
+
+  @Override
+  public void outboundHeaders() {
+    if (!outboundHeadersCalled.compareAndSet(null, new Exception("first stack"))
+        && delegate.failDuplicateCallbacks.get()) {
+      throw new AssertionError(
+          "outboundHeaders called more than once",
+          new Exception("second stack", outboundHeadersCalled.get()));
+    }
+    outboundHeadersLatch.countDown();
+  }
+
+  @Override
+  public void inboundHeaders() {
+    if (!inboundHeadersCalled.compareAndSet(null, new Exception("first stack"))
+        && delegate.failDuplicateCallbacks.get()) {
+      throw new AssertionError(
+          "inboundHeaders called more than once",
+          new Exception("second stack", inboundHeadersCalled.get()));
+    }
+  }
+
+  @Override
+  public void inboundTrailers(Metadata trailers) {
+    if (delegate.getStatus() != null) {
+      throw new AssertionError(
+          "stream has already been closed with " + delegate.getStatus(),
+          delegate.streamClosedStack.get());
+    }
+    if (!inboundTrailers.compareAndSet(null, trailers) && delegate.failDuplicateCallbacks.get()) {
+      throw new AssertionError("inboundTrailers called more than once");
+    }
+  }
+}
diff --git a/testing/src/main/java/io/grpc/internal/testing/TestServerStreamTracer.java b/testing/src/main/java/io/grpc/internal/testing/TestServerStreamTracer.java
new file mode 100644
index 00000000000..dc9e2df23a5
--- /dev/null
+++ b/testing/src/main/java/io/grpc/internal/testing/TestServerStreamTracer.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2017 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.internal.testing;
+
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * A {@link ServerStreamTracer} suitable for testing.
+ */
+public class TestServerStreamTracer extends ServerStreamTracer implements TestStreamTracer {
+  private final TestBaseStreamTracer delegate = new TestBaseStreamTracer();
+  protected final AtomicReference<ServerCallInfo<?, ?>> serverCallInfo =
+      new AtomicReference<>();
+
+  @Override
+  public void await() throws InterruptedException {
+    delegate.await();
+  }
+
+  @Override
+  public boolean await(long timeout, TimeUnit timeUnit) throws InterruptedException {
+    return delegate.await(timeout, timeUnit);
+  }
+
+  /**
+   * Returns the ServerCall passed to {@link ServerStreamTracer#serverCallStarted}.
+   */
+  public ServerCallInfo<?, ?> getServerCallInfo() {
+    return serverCallInfo.get();
+  }
+
+  @Override
+  public Status getStatus() {
+    return delegate.getStatus();
+  }
+
+  @Override
+  public long getInboundWireSize() {
+    return delegate.getInboundWireSize();
+  }
+
+  @Override
+  public long getInboundUncompressedSize() {
+    return delegate.getInboundUncompressedSize();
+  }
+
+  @Override
+  public long getOutboundWireSize() {
+    return delegate.getOutboundWireSize();
+  }
+
+  @Override
+  public long getOutboundUncompressedSize() {
+    return delegate.getOutboundUncompressedSize();
+  }
+
+  @Override
+  public void setFailDuplicateCallbacks(boolean fail) {
+    delegate.setFailDuplicateCallbacks(fail);
+  }
+
+  @Override
+  public String nextOutboundEvent() {
+    return delegate.nextOutboundEvent();
+  }
+
+  @Override
+  public String nextInboundEvent() {
+    return delegate.nextInboundEvent();
+  }
+
+  @Override
+  public void outboundWireSize(long bytes) {
+    delegate.outboundWireSize(bytes);
+  }
+
+  @Override
+  public void inboundWireSize(long bytes) {
+    delegate.inboundWireSize(bytes);
+  }
+
+  @Override
+  public void outboundUncompressedSize(long bytes) {
+    delegate.outboundUncompressedSize(bytes);
+  }
+
+  @Override
+  public void inboundUncompressedSize(long bytes) {
+    delegate.inboundUncompressedSize(bytes);
+  }
+
+  @Override
+  public void streamClosed(Status status) {
+    delegate.streamClosed(status);
+  }
+
+  @Override
+  public void inboundMessage(int seqNo) {
+    delegate.inboundMessage(seqNo);
+  }
+
+  @Override
+  public void outboundMessage(int seqNo) {
+    delegate.outboundMessage(seqNo);
+  }
+
+  @Override
+  public void outboundMessageSent(int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+    delegate.outboundMessageSent(seqNo, optionalWireSize, optionalUncompressedSize);
+  }
+
+  @Override
+  public void inboundMessageRead(int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+    delegate.inboundMessageRead(seqNo, optionalWireSize, optionalUncompressedSize);
+  }
+
+  @Override
+  public void serverCallStarted(ServerCallInfo<?, ?> callInfo) {
+    if (!serverCallInfo.compareAndSet(null, callInfo) && delegate.failDuplicateCallbacks.get()) {
+      throw new AssertionError("serverCallStarted called more than once");
+    }
+  }
+}
diff --git a/testing/src/main/java/io/grpc/internal/testing/TestStreamTracer.java b/testing/src/main/java/io/grpc/internal/testing/TestStreamTracer.java
new file mode 100644
index 00000000000..1d0061f6120
--- /dev/null
+++ b/testing/src/main/java/io/grpc/internal/testing/TestStreamTracer.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2017 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.internal.testing;
+
+import io.grpc.Status;
+import io.grpc.StreamTracer;
+import java.util.Locale;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link StreamTracer} suitable for testing.
+ */
+public interface TestStreamTracer {
+
+  /**
+   * Waits for the stream to be done.
+   */
+  void await() throws InterruptedException;
+
+  /**
+   * Waits for the stream to be done.
+   */
+  boolean await(long timeout, TimeUnit timeUnit) throws InterruptedException;
+
+  /**
+   * Returns the status passed to {@link StreamTracer#streamClosed}.
+   */
+  Status getStatus();
+
+  /**
+   * Returns to sum of all sizes passed to {@link StreamTracer#inboundWireSize}.
+   */
+  long getInboundWireSize();
+
+  /**
+   * Returns to sum of all sizes passed to {@link StreamTracer#inboundUncompressedSize}.
+   */
+  long getInboundUncompressedSize();
+
+  /**
+   * Returns to sum of all sizes passed to {@link StreamTracer#outboundWireSize}.
+   */
+  long getOutboundWireSize();
+
+  /**
+   * Returns to sum of al sizes passed to {@link StreamTracer#outboundUncompressedSize}.
+   */
+  long getOutboundUncompressedSize();
+
+  /**
+   * Sets whether to fail on unexpected duplicate calls to callback methods.
+   */
+  void setFailDuplicateCallbacks(boolean fail);
+
+  /**
+   * Returns the next captured outbound message event.
+   */
+  @Nullable
+  String nextOutboundEvent();
+
+  /**
+   * Returns the next captured outbound message event.
+   */
+  String nextInboundEvent();
+
+  /**
+   * A {@link StreamTracer} suitable for testing.
+   */
+  public static class TestBaseStreamTracer extends StreamTracer implements TestStreamTracer {
+
+    protected final AtomicLong outboundWireSize = new AtomicLong();
+    protected final AtomicLong inboundWireSize = new AtomicLong();
+    protected final AtomicLong outboundUncompressedSize = new AtomicLong();
+    protected final AtomicLong inboundUncompressedSize = new AtomicLong();
+    protected final LinkedBlockingQueue<String> outboundEvents = new LinkedBlockingQueue<>();
+    protected final LinkedBlockingQueue<String> inboundEvents = new LinkedBlockingQueue<>();
+    protected final AtomicReference<Status> streamClosedStatus = new AtomicReference<>();
+    protected final AtomicReference<Throwable> streamClosedStack = new AtomicReference<>();
+    protected final CountDownLatch streamClosed = new CountDownLatch(1);
+    protected final AtomicBoolean failDuplicateCallbacks = new AtomicBoolean(true);
+
+    @Override
+    public void await() throws InterruptedException {
+      streamClosed.await();
+    }
+
+    @Override
+    public boolean await(long timeout, TimeUnit timeUnit) throws InterruptedException {
+      return streamClosed.await(timeout, timeUnit);
+    }
+
+    @Override
+    public Status getStatus() {
+      return streamClosedStatus.get();
+    }
+
+    @Override
+    public long getInboundWireSize() {
+      return inboundWireSize.get();
+    }
+
+    @Override
+    public long getInboundUncompressedSize() {
+      return inboundUncompressedSize.get();
+    }
+
+    @Override
+    public long getOutboundWireSize() {
+      return outboundWireSize.get();
+    }
+
+    @Override
+    public long getOutboundUncompressedSize() {
+      return outboundUncompressedSize.get();
+    }
+
+    @Override
+    public void outboundWireSize(long bytes) {
+      outboundWireSize.addAndGet(bytes);
+    }
+
+    @Override
+    public void inboundWireSize(long bytes) {
+      inboundWireSize.addAndGet(bytes);
+    }
+
+    @Override
+    public void outboundUncompressedSize(long bytes) {
+      outboundUncompressedSize.addAndGet(bytes);
+    }
+
+    @Override
+    public void inboundUncompressedSize(long bytes) {
+      inboundUncompressedSize.addAndGet(bytes);
+    }
+
+    @Override
+    public void streamClosed(Status status) {
+      streamClosedStack.compareAndSet(null, new Throwable("first call"));
+      if (!streamClosedStatus.compareAndSet(null, status)) {
+        if (failDuplicateCallbacks.get()) {
+          throw new AssertionError("streamClosed called more than once", streamClosedStack.get());
+        }
+      } else {
+        streamClosed.countDown();
+      }
+    }
+
+    @Override
+    public void inboundMessage(int seqNo) {
+      inboundEvents.add("inboundMessage(" + seqNo + ")");
+    }
+
+    @Override
+    public void outboundMessage(int seqNo) {
+      outboundEvents.add("outboundMessage(" + seqNo + ")");
+    }
+
+    @Override
+    public void outboundMessageSent(
+        int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+      outboundEvents.add(
+          String.format(
+              Locale.US,
+              "outboundMessageSent(%d, %d, %d)",
+              seqNo, optionalWireSize, optionalUncompressedSize));
+    }
+
+    @Override
+    public void inboundMessageRead(
+        int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+      inboundEvents.add(
+          String.format(
+              Locale.US,
+              "inboundMessageRead(%d, %d, %d)", seqNo, optionalWireSize, optionalUncompressedSize));
+    }
+
+    @Override
+    public void setFailDuplicateCallbacks(boolean fail) {
+      failDuplicateCallbacks.set(fail);
+    }
+
+    @Override
+    public String nextOutboundEvent() {
+      return outboundEvents.poll();
+    }
+
+    @Override
+    public String nextInboundEvent() {
+      return inboundEvents.poll();
+    }
+  }
+}
diff --git a/testing/src/main/java/io/grpc/internal/testing/TestUtils.java b/testing/src/main/java/io/grpc/internal/testing/TestUtils.java
new file mode 100644
index 00000000000..01b0105c45e
--- /dev/null
+++ b/testing/src/main/java/io/grpc/internal/testing/TestUtils.java
@@ -0,0 +1,212 @@
+/*
+ * Copyright 2014 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.internal.testing;
+
+import com.google.common.base.Throwables;
+import io.grpc.internal.ConscryptLoader;
+import io.grpc.testing.TlsTesting;
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.UnknownHostException;
+import java.security.KeyStore;
+import java.security.Provider;
+import java.security.Security;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.List;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManagerFactory;
+import javax.security.auth.x500.X500Principal;
+
+/**
+ * Internal utility functions useful for writing tests.
+ */
+public class TestUtils {
+  public static final String TEST_SERVER_HOST = "foo.test.google.fr";
+
+  /**
+   * Creates a new {@link InetSocketAddress} that overrides the host with {@link #TEST_SERVER_HOST}.
+   */
+  public static InetSocketAddress testServerAddress(String host, int port) {
+    try {
+      InetAddress inetAddress = InetAddress.getByName(host);
+      inetAddress = InetAddress.getByAddress(TEST_SERVER_HOST, inetAddress.getAddress());
+      return new InetSocketAddress(inetAddress, port);
+    } catch (UnknownHostException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * Creates a new {@link InetSocketAddress} on localhost that overrides the host with
+   * {@link #TEST_SERVER_HOST}.
+   */
+  public static InetSocketAddress testServerAddress(InetSocketAddress originalSockAddr) {
+    try {
+      InetAddress inetAddress = InetAddress.getByName("localhost");
+      inetAddress = InetAddress.getByAddress(TEST_SERVER_HOST, inetAddress.getAddress());
+      return new InetSocketAddress(inetAddress, originalSockAddr.getPort());
+    } catch (UnknownHostException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * Creates a new list of {@link InetSocketAddress} on localhost that overrides the host with
+   * {@link #TEST_SERVER_HOST}.
+   */
+  public static List<InetSocketAddress> testServerAddresses(InetSocketAddress... originalSockAddr) {
+    try {
+      InetAddress inetAddress = InetAddress.getByName("localhost");
+      inetAddress = InetAddress.getByAddress(TEST_SERVER_HOST, inetAddress.getAddress());
+      List<InetSocketAddress> addresses = new ArrayList<>();
+      for (InetSocketAddress orig: originalSockAddr) {
+        addresses.add(new InetSocketAddress(inetAddress, orig.getPort()));
+      }
+      return addresses;
+    } catch (UnknownHostException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * Saves a file from the classpath resources in src/main/resources/certs as a file on the
+   * filesystem.
+   *
+   * @param name  name of a file in src/main/resources/certs.
+   */
+  public static File loadCert(String name) throws IOException {
+    InputStream in = new BufferedInputStream(TlsTesting.loadCert(name));
+    File tmpFile = File.createTempFile(name, "");
+    tmpFile.deleteOnExit();
+
+    OutputStream os = new BufferedOutputStream(new FileOutputStream(tmpFile));
+    try {
+      int b;
+      while ((b = in.read()) != -1) {
+        os.write(b);
+      }
+      os.flush();
+    } finally {
+      in.close();
+      os.close();
+    }
+
+    return tmpFile;
+  }
+
+  /**
+   * Loads an X.509 certificate from the classpath resources in src/main/resources/certs.
+   *
+   * @param fileName  name of a file in src/main/resources/certs.
+   */
+  public static X509Certificate loadX509Cert(String fileName)
+      throws CertificateException, IOException {
+    CertificateFactory cf = CertificateFactory.getInstance("X.509");
+
+    InputStream in = TlsTesting.loadCert(fileName);
+    try {
+      return (X509Certificate) cf.generateCertificate(in);
+    } finally {
+      in.close();
+    }
+  }
+
+  private static boolean conscryptInstallAttempted;
+
+  /**
+   * Add Conscrypt to the list of security providers, if it is available. If it appears to be
+   * available but fails to load, this method will throw an exception. Since the list of security
+   * providers is static, this method does nothing if the provider is not available or succeeded
+   * previously.
+   */
+  public static void installConscryptIfAvailable() {
+    if (conscryptInstallAttempted) {
+      return;
+    }
+    // Conscrypt-based I/O (like used in OkHttp) breaks on Windows.
+    // https://github.com/google/conscrypt/issues/444
+    if (System.mapLibraryName("test").endsWith(".dll")) {
+      conscryptInstallAttempted = true;
+      return;
+    }
+    // Concrypt native libraries are not available for ARM architectures.
+    String osArch = System.getProperty("os.arch", "");
+    if (osArch.startsWith("aarch") || osArch.startsWith("arm")) {
+      conscryptInstallAttempted = true;
+      return;
+    }
+    if (!ConscryptLoader.isPresent()) {
+      conscryptInstallAttempted = true;
+      return;
+    }
+    Provider provider;
+    try {
+      provider = ConscryptLoader.newProvider();
+    } catch (Throwable t) {
+      Throwable root = Throwables.getRootCause(t);
+      // Conscrypt uses a newer version of glibc than available on RHEL 6
+      if (root instanceof UnsatisfiedLinkError && root.getMessage() != null
+          && root.getMessage().contains("GLIBC_2.14")) {
+        conscryptInstallAttempted = true;
+        return;
+      }
+      throw new RuntimeException("Could not create Conscrypt provider", t);
+    }
+    Security.addProvider(provider);
+    conscryptInstallAttempted = true;
+  }
+
+  /**
+   * Creates an SSLSocketFactory which contains {@code certChainFile} as its only root certificate.
+   */
+  public static SSLSocketFactory newSslSocketFactoryForCa(Provider provider,
+                                                          File certChainFile) throws Exception {
+    KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
+    ks.load(null, null);
+    CertificateFactory cf = CertificateFactory.getInstance("X.509");
+    BufferedInputStream in = new BufferedInputStream(new FileInputStream(certChainFile));
+    try {
+      X509Certificate cert = (X509Certificate) cf.generateCertificate(in);
+      X500Principal principal = cert.getSubjectX500Principal();
+      ks.setCertificateEntry(principal.getName("RFC2253"), cert);
+    } finally {
+      in.close();
+    }
+
+    // Set up trust manager factory to use our key store.
+    TrustManagerFactory trustManagerFactory =
+        TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+    trustManagerFactory.init(ks);
+    SSLContext context = SSLContext.getInstance("TLS", provider);
+    context.init(null, trustManagerFactory.getTrustManagers(), null);
+    return context.getSocketFactory();
+  }
+
+  private TestUtils() {}
+}
diff --git a/testing/src/main/java/io/grpc/testing/DeadlineSubject.java b/testing/src/main/java/io/grpc/testing/DeadlineSubject.java
deleted file mode 100644
index 61c668f9eab..00000000000
--- a/testing/src/main/java/io/grpc/testing/DeadlineSubject.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.testing;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-import static java.util.concurrent.TimeUnit.NANOSECONDS;
-
-import com.google.common.truth.ComparableSubject;
-import com.google.common.truth.FailureStrategy;
-import com.google.common.truth.SubjectFactory;
-import io.grpc.Deadline;
-import java.math.BigInteger;
-import java.util.concurrent.TimeUnit;
-import javax.annotation.CheckReturnValue;
-import javax.annotation.Nullable;
-
-/**
- * Propositions for {@link Deadline} subjects.
- */
-public final class DeadlineSubject extends ComparableSubject<DeadlineSubject, Deadline> {
-  private static final SubjectFactory<DeadlineSubject, Deadline> deadlineFactory =
-      new DeadlineSubjectFactory();
-
-  public static SubjectFactory<DeadlineSubject, Deadline> deadline() {
-    return deadlineFactory;
-  }
-
-  private DeadlineSubject(FailureStrategy failureStrategy, Deadline subject) {
-    super(failureStrategy, subject);
-  }
-
-  /**
-   * Prepares for a check that the subject is deadline within the given tolerance of an
-   * expected value that will be provided in the next call in the fluent chain.
-   */
-  @CheckReturnValue
-  public TolerantDeadlineComparison isWithin(final long delta, final TimeUnit timeUnit) {
-    return new TolerantDeadlineComparison() {
-      @Override
-      public void of(Deadline expected) {
-        Deadline actual = getSubject();
-        checkNotNull(actual, "actual value cannot be null. expected=%s", expected);
-
-        // This is probably overkill, but easier than thinking about overflow.
-        BigInteger actualTimeRemaining = BigInteger.valueOf(actual.timeRemaining(NANOSECONDS));
-        BigInteger expectedTimeRemaining = BigInteger.valueOf(expected.timeRemaining(NANOSECONDS));
-        BigInteger deltaNanos = BigInteger.valueOf(timeUnit.toNanos(delta));
-        if (actualTimeRemaining.subtract(expectedTimeRemaining).abs().compareTo(deltaNanos) > 0) {
-          failWithRawMessage(
-              "%s and <%s> should have been within <%sns> of each other",
-              getDisplaySubject(),
-              expected,
-              deltaNanos);
-        }
-      }
-    };
-  }
-
-  // TODO(carl-mastrangelo):  Add a isNotWithin method once there is need for one.  Currently there
-  // is no such method since there is no code that uses it, and would lower our coverage numbers.
-
-  /**
-   * A partially specified proposition about an approximate relationship to a {@code deadline}
-   * subject using a tolerance.
-   */
-  public abstract class TolerantDeadlineComparison {
-
-    private TolerantDeadlineComparison() {}
-
-    /**
-     * Fails if the subject was expected to be within the tolerance of the given value but was not
-     * <i>or</i> if it was expected <i>not</i> to be within the tolerance but was. The expectation,
-     * subject, and tolerance are all specified earlier in the fluent call chain.
-     */
-    public abstract void of(Deadline expectedDeadline);
-
-    /**
-     * Do not call this method.
-     *
-     * @throws UnsupportedOperationException always
-     * @deprecated {@link Object#equals(Object)} is not supported on TolerantDeadlineComparison
-     *     If you meant to compare deadlines, use {@link #of(Deadline)} instead.
-     */
-    // Deprecation used to signal visual warning in IDE for the unaware users.
-    // This method is created as a precaution and won't be removed as part of deprecation policy.
-    @Deprecated
-    @Override
-    public boolean equals(@Nullable Object o) {
-      throw new UnsupportedOperationException(
-          "If you meant to compare deadlines, use .of(Deadline) instead.");
-    }
-
-    /**
-     * Do not call this method.
-     *
-     * @throws UnsupportedOperationException always
-     * @deprecated {@link Object#hashCode()} is not supported on TolerantDeadlineComparison
-     */
-    // Deprecation used to signal visual warning in IDE for the unaware users.
-    // This method is created as a precaution and won't be removed as part of deprecation policy.
-    @Deprecated
-    @Override
-    public int hashCode() {
-      throw new UnsupportedOperationException("Subject.hashCode() is not supported.");
-    }
-  }
-
-  private static final class DeadlineSubjectFactory
-      extends SubjectFactory<DeadlineSubject, Deadline>  {
-    @Override
-    public DeadlineSubject getSubject(FailureStrategy fs, Deadline that) {
-      return new DeadlineSubject(fs, that);
-    }
-  }
-}
diff --git a/testing/src/main/java/io/grpc/testing/GrpcCleanupRule.java b/testing/src/main/java/io/grpc/testing/GrpcCleanupRule.java
new file mode 100644
index 00000000000..55188e57149
--- /dev/null
+++ b/testing/src/main/java/io/grpc/testing/GrpcCleanupRule.java
@@ -0,0 +1,280 @@
+/*
+ * Copyright 2018 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.testing;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Ticker;
+import com.google.common.collect.Lists;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nonnull;
+import javax.annotation.concurrent.NotThreadSafe;
+import org.junit.rules.ExternalResource;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+/**
+ * A JUnit {@link ExternalResource} that can register gRPC resources and manages its automatic
+ * release at the end of the test. If any of the resources registered to the rule can not be
+ * successfully released, the test will fail.
+ *
+ * <p>Example usage:
+ * <pre>{@code @Rule public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+ * ...
+ * // The Channel and Server can be created in any order
+ * grpcCleanup.register(
+ *     InProcessServerBuilder.forName("my-test-case")
+ *         .directExecutor()
+ *         .addService(serviceImpl)
+ *         .build()
+ *         .start());
+ * ManagedChannel channel = grpcCleanup.register(
+ *     InProcessChannelBuilder.forName("my-test-case")
+ *         .directExecutor()
+ *         .build());
+ * }</pre>
+ *
+ * <p>To use as a replacement for {@link GrpcServerRule}:
+ * <pre>{@code String serverName = InProcessServerBuilder.generateName();
+ * MutableHandlerRegistry serviceRegistry = new MutableHandlerRegistry();
+ * Server server = grpcCleanup.register(
+ *     InProcessServerBuilder.forName(serverName)
+ *         .fallbackHandlerRegistry(serviceRegistry)
+ *         .build()
+ *         .start());
+ * ManagedChannel channel = grpcCleanup.register(
+ *     InProcessChannelBuilder.forName(serverName).build());
+ * }</pre>
+ *
+ * @since 1.13.0
+ */
+@NotThreadSafe
+public final class GrpcCleanupRule extends ExternalResource {
+
+  private final List<Resource> resources = new ArrayList<>();
+  private long timeoutNanos = TimeUnit.SECONDS.toNanos(10L);
+  private Stopwatch stopwatch = Stopwatch.createUnstarted();
+
+  private boolean abruptShutdown;
+
+  /**
+   * Sets a positive total time limit for the automatic resource cleanup. If any of the resources
+   * registered to the rule fails to be released in time, the test will fail.
+   *
+   * <p>Note that the resource cleanup duration may or may not be counted as part of the JUnit
+   * {@link org.junit.rules.Timeout Timeout} rule's test duration, depending on which rule is
+   * applied first.
+   *
+   * @return this
+   */
+  public GrpcCleanupRule setTimeout(long timeout, TimeUnit timeUnit) {
+    checkArgument(timeout > 0, "timeout should be positive");
+    timeoutNanos = timeUnit.toNanos(timeout);
+    return this;
+  }
+
+  /**
+   * Sets a specified time source for monitoring cleanup timeout.
+   *
+   * @return this
+   */
+  @SuppressWarnings("BetaApi") // Test only.
+  @VisibleForTesting
+  GrpcCleanupRule setTicker(Ticker ticker) {
+    this.stopwatch = Stopwatch.createUnstarted(ticker);
+    return this;
+  }
+
+  /**
+   * Registers the given channel to the rule. Once registered, the channel will be automatically
+   * shutdown at the end of the test.
+   *
+   * <p>This method need be properly synchronized if used in multiple threads. This method must
+   * not be used during the test teardown.
+   *
+   * @return the input channel
+   */
+  public <T extends ManagedChannel> T register(@Nonnull T channel) {
+    checkNotNull(channel, "channel");
+    register(new ManagedChannelResource(channel));
+    return channel;
+  }
+
+  /**
+   * Registers the given server to the rule. Once registered, the server will be automatically
+   * shutdown at the end of the test.
+   *
+   * <p>This method need be properly synchronized if used in multiple threads. This method must
+   * not be used during the test teardown.
+   *
+   * @return the input server
+   */
+  public <T extends Server> T register(@Nonnull T server) {
+    checkNotNull(server, "server");
+    register(new ServerResource(server));
+    return server;
+  }
+
+  @VisibleForTesting
+  void register(Resource resource) {
+    resources.add(resource);
+  }
+
+  // The class extends ExternalResource so it can be used in JUnit 5. But JUnit 5 will only call
+  // before() and after(), thus code cannot assume this method will be called.
+  @Override
+  public Statement apply(final Statement base, Description description) {
+    return super.apply(new Statement() {
+      @Override
+      public void evaluate() throws Throwable {
+        abruptShutdown = false;
+        try {
+          base.evaluate();
+        } catch (Throwable t) {
+          abruptShutdown = true;
+          throw t;
+        }
+      }
+    }, description);
+  }
+
+  /**
+   * Releases all the registered resources.
+   */
+  @Override
+  protected void after() {
+    stopwatch.reset();
+    stopwatch.start();
+
+    InterruptedException interrupted = null;
+    if (!abruptShutdown) {
+      for (Resource resource : Lists.reverse(resources)) {
+        resource.cleanUp();
+      }
+
+      for (int i = resources.size() - 1; i >= 0; i--) {
+        try {
+          boolean released = resources.get(i).awaitReleased(
+              timeoutNanos - stopwatch.elapsed(TimeUnit.NANOSECONDS), TimeUnit.NANOSECONDS);
+          if (released) {
+            resources.remove(i);
+          }
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+          interrupted = e;
+          break;
+        }
+      }
+    }
+
+    if (!resources.isEmpty()) {
+      for (Resource resource : Lists.reverse(resources)) {
+        resource.forceCleanUp();
+      }
+
+      try {
+        if (interrupted != null) {
+          throw new AssertionError(
+              "Thread interrupted before resources gracefully released", interrupted);
+        } else if (!abruptShutdown) {
+          throw new AssertionError(
+            "Resources could not be released in time at the end of test: " + resources);
+        }
+      } finally {
+        resources.clear();
+      }
+    }
+  }
+
+  @VisibleForTesting
+  interface Resource {
+    void cleanUp();
+
+    /**
+     * Error already happened, try the best to clean up. Never throws.
+     */
+    void forceCleanUp();
+
+    /**
+     * Returns true if the resource is released in time.
+     */
+    boolean awaitReleased(long duration, TimeUnit timeUnit) throws InterruptedException;
+  }
+
+  private static final class ManagedChannelResource implements Resource {
+    final ManagedChannel channel;
+
+    ManagedChannelResource(ManagedChannel channel) {
+      this.channel = channel;
+    }
+
+    @Override
+    public void cleanUp() {
+      channel.shutdown();
+    }
+
+    @Override
+    public void forceCleanUp() {
+      channel.shutdownNow();
+    }
+
+    @Override
+    public boolean awaitReleased(long duration, TimeUnit timeUnit) throws InterruptedException {
+      return channel.awaitTermination(duration, timeUnit);
+    }
+
+    @Override
+    public String toString() {
+      return channel.toString();
+    }
+  }
+
+  private static final class ServerResource implements Resource {
+    final Server server;
+
+    ServerResource(Server server) {
+      this.server = server;
+    }
+
+    @Override
+    public void cleanUp() {
+      server.shutdown();
+    }
+
+    @Override
+    public void forceCleanUp() {
+      server.shutdownNow();
+    }
+
+    @Override
+    public boolean awaitReleased(long duration, TimeUnit timeUnit) throws InterruptedException {
+      return server.awaitTermination(duration, timeUnit);
+    }
+
+    @Override
+    public String toString() {
+      return server.toString();
+    }
+  }
+}
diff --git a/testing/src/main/java/io/grpc/testing/GrpcServerRule.java b/testing/src/main/java/io/grpc/testing/GrpcServerRule.java
index 9fcca658dce..641c9927d91 100644
--- a/testing/src/main/java/io/grpc/testing/GrpcServerRule.java
+++ b/testing/src/main/java/io/grpc/testing/GrpcServerRule.java
@@ -1,38 +1,24 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing;
 
+import static com.google.common.base.Preconditions.checkState;
+
 import io.grpc.BindableService;
-import io.grpc.ExperimentalApi;
 import io.grpc.ManagedChannel;
 import io.grpc.Server;
 import io.grpc.ServerServiceDefinition;
@@ -47,14 +33,21 @@
 
 /**
  * {@code GrpcServerRule} is a JUnit {@link TestRule} that starts an in-process gRPC service with
- * a {@link MutableHandlerRegistry} for adding services. It is particularly useful for mocking out
- * external gRPC-based services and asserting that the expected requests were made.
+ * a {@link MutableHandlerRegistry} for adding services. Prefer {@link GrpcCleanupRule} in new code.
+ *
+ * <p>{@code GrpcServerRule} is useful for testing gRPC-based clients and services. However,
+ * because {@code GrpcServerRule} does not support useful features such as transport
+ * types other than in-process, multiple channels per server, custom channel or server builder
+ * options, and configuration inside individual test methods, users would end up to a difficult
+ * situation when later they want to make extensions to their tests that were using {@code
+ * GrpcServerRule}. Little benefit comes from proactively migrating existing code from {@code
+ * GrpcServerRule}, but new code is better served by explicit channel and server creation with
+ * {@code GrpcCleanupRule} managing resource lifetimes.
  *
  * <p>An {@link AbstractStub} can be created against this service by using the
  * {@link ManagedChannel} provided by {@link GrpcServerRule#getChannel()}.
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2488")
-public class GrpcServerRule extends ExternalResource {
+public final class GrpcServerRule extends ExternalResource {
 
   private ManagedChannel channel;
   private Server server;
@@ -64,9 +57,10 @@ public class GrpcServerRule extends ExternalResource {
 
   /**
    * Returns {@code this} configured to use a direct executor for the {@link ManagedChannel} and
-   * {@link Server}.
+   * {@link Server}. This can only be called at the rule instantiation.
    */
   public final GrpcServerRule directExecutor() {
+    checkState(serverName == null, "directExecutor() can only be called at the rule instantiation");
     useDirectExecutor = true;
     return this;
   }
diff --git a/testing/src/main/java/io/grpc/testing/NoopClientCall.java b/testing/src/main/java/io/grpc/testing/NoopClientCall.java
deleted file mode 100644
index ee4c802dfcf..00000000000
--- a/testing/src/main/java/io/grpc/testing/NoopClientCall.java
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.testing;
-
-import io.grpc.ClientCall;
-import io.grpc.ExperimentalApi;
-import io.grpc.Metadata;
-
-/**
- * {@link NoopClientCall} is a class that is designed for use in tests.  It is designed to be used
- * in places where a scriptable call is necessary.  By default, all methods are noops, and designed
- * to be overriden.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2234")
-public class NoopClientCall<ReqT, RespT> extends ClientCall<ReqT, RespT> {
-
-  /**
-   * {@link NoopClientCall.NoopClientCallListener} is a class that is designed for use in tests.
-   * It is designed to be used in places where a scriptable call listener is necessary.  By
-   * default, all methods are noops, and designed to be overriden.
-   */
-  public static class NoopClientCallListener<T> extends ClientCall.Listener<T> {
-  }
-
-  @Override
-  public void start(ClientCall.Listener<RespT> listener, Metadata headers) {}
-
-  @Override
-  public void request(int numMessages) {}
-
-  @Override
-  public void cancel(String message, Throwable cause) {}
-
-  @Override
-  public void halfClose() {}
-
-  @Override
-  public void sendMessage(ReqT message) {}
-}
-
diff --git a/testing/src/main/java/io/grpc/testing/NoopServerCall.java b/testing/src/main/java/io/grpc/testing/NoopServerCall.java
deleted file mode 100644
index 71b2cf165a0..00000000000
--- a/testing/src/main/java/io/grpc/testing/NoopServerCall.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.testing;
-
-import io.grpc.ExperimentalApi;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor;
-import io.grpc.ServerCall;
-import io.grpc.Status;
-
-/**
- * {@link NoopServerCall} is a class that is designed for use in tests.  It is designed to be used
- * in places where a scriptable call is necessary.  By default, all methods are noops, and designed
- * to be overriden.
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2234")
-public class NoopServerCall<ReqT, RespT> extends ServerCall<ReqT, RespT> {
-
-  /**
-   * {@link NoopServerCall.NoopServerCallListener} is a class that is designed for use in tests.
-   * It is designed to be used in places where a scriptable call listener is necessary.  By
-   * default, all methods are noops, and designed to be overriden.
-   */
-  public static class NoopServerCallListener<T> extends ServerCall.Listener<T> {
-  }
-
-  @Override
-  public void request(int numMessages) {}
-
-  @Override
-  public void sendHeaders(Metadata headers) {}
-
-  @Override
-  public void sendMessage(RespT message) {}
-
-  @Override
-  public void close(Status status, Metadata trailers) {}
-
-  @Override
-  public boolean isCancelled() {
-    return false;
-  }
-
-  @Override
-  public MethodDescriptor<ReqT, RespT> getMethodDescriptor() {
-    return null;
-  }
-}
-
diff --git a/testing/src/main/java/io/grpc/testing/StreamRecorder.java b/testing/src/main/java/io/grpc/testing/StreamRecorder.java
index 847f88a7378..a1496a0decd 100644
--- a/testing/src/main/java/io/grpc/testing/StreamRecorder.java
+++ b/testing/src/main/java/io/grpc/testing/StreamRecorder.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing;
@@ -45,7 +30,10 @@
 /**
  * Utility implementation of {@link StreamObserver} used in testing. Records all the observed
  * values produced by the stream as well as any errors.
+ *
+ * @deprecated Not for public use
  */
+@Deprecated
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1791")
 public class StreamRecorder<T> implements StreamObserver<T> {
 
@@ -53,7 +41,7 @@ public class StreamRecorder<T> implements StreamObserver<T> {
    * Creates a new recorder.
    */
   public static <T> StreamRecorder<T> create() {
-    return new StreamRecorder<T>();
+    return new StreamRecorder<>();
   }
 
   private final CountDownLatch latch;
diff --git a/testing/src/main/java/io/grpc/testing/TestMethodDescriptors.java b/testing/src/main/java/io/grpc/testing/TestMethodDescriptors.java
index d4fc66b0a66..5ffc60e369b 100644
--- a/testing/src/main/java/io/grpc/testing/TestMethodDescriptors.java
+++ b/testing/src/main/java/io/grpc/testing/TestMethodDescriptors.java
@@ -1,37 +1,21 @@
 /*
- * Copyright 2017, Google Inc. All rights reserved.
+ * Copyright 2017 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing;
 
-import io.grpc.ExperimentalApi;
 import io.grpc.MethodDescriptor;
 import io.grpc.MethodDescriptor.MethodType;
 import java.io.ByteArrayInputStream;
@@ -43,7 +27,6 @@
  *
  * @since 1.1.0
  */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2600")
 public final class TestMethodDescriptors {
   private TestMethodDescriptors() {}
 
@@ -53,29 +36,12 @@ private TestMethodDescriptors() {}
    *
    * @since 1.1.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2600")
   public static MethodDescriptor<Void, Void> voidMethod() {
-    return TestMethodDescriptors.<Void, Void>noopMethod();
-  }
-
-  /**
-   * Creates a new method descriptor that always creates zero length messages, and always parses to
-   * null objects.
-   *
-   * @since 1.1.0
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2600")
-  public static <ReqT, RespT> MethodDescriptor<ReqT, RespT> noopMethod() {
-    return noopMethod("service_foo", "method_bar");
-  }
-
-  private static <ReqT, RespT> MethodDescriptor<ReqT, RespT> noopMethod(
-      String serviceName, String methodName) {
-    return MethodDescriptor.<ReqT, RespT>newBuilder()
+    return MethodDescriptor.<Void, Void>newBuilder()
         .setType(MethodType.UNARY)
-        .setFullMethodName(MethodDescriptor.generateFullMethodName(serviceName, methodName))
-        .setRequestMarshaller(TestMethodDescriptors.<ReqT>noopMarshaller())
-        .setResponseMarshaller(TestMethodDescriptors.<RespT>noopMarshaller())
+        .setFullMethodName(MethodDescriptor.generateFullMethodName("service_foo", "method_bar"))
+        .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+        .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
         .build();
   }
 
@@ -84,29 +50,18 @@ private static <ReqT, RespT> MethodDescriptor<ReqT, RespT> noopMethod(
    *
    * @since 1.1.0
    */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2600")
   public static MethodDescriptor.Marshaller<Void> voidMarshaller() {
-    return TestMethodDescriptors.<Void>noopMarshaller();
-  }
-
-  /**
-   * Creates a new marshaller that does nothing.
-   *
-   * @since 1.1.0
-   */
-  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2600")
-  public static <T> MethodDescriptor.Marshaller<T> noopMarshaller() {
-    return new NoopMarshaller<T>();
+    return new NoopMarshaller();
   }
 
-  private static final class NoopMarshaller<T> implements MethodDescriptor.Marshaller<T> {
+  private static final class NoopMarshaller implements MethodDescriptor.Marshaller<Void> {
     @Override
-    public InputStream stream(T value) {
+    public InputStream stream(Void value) {
       return new ByteArrayInputStream(new byte[]{});
     }
 
     @Override
-    public T parse(InputStream stream) {
+    public Void parse(InputStream stream) {
       return null;
     }
   }
diff --git a/testing/src/main/java/io/grpc/testing/TestUtils.java b/testing/src/main/java/io/grpc/testing/TestUtils.java
index 08737442f63..f10a6a26640 100644
--- a/testing/src/main/java/io/grpc/testing/TestUtils.java
+++ b/testing/src/main/java/io/grpc/testing/TestUtils.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing;
@@ -37,16 +22,10 @@
 import io.grpc.ServerCallHandler;
 import io.grpc.ServerInterceptor;
 import java.io.BufferedInputStream;
-import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
-import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.OutputStream;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.net.UnknownHostException;
 import java.security.KeyStore;
 import java.security.NoSuchAlgorithmException;
 import java.security.Provider;
@@ -67,8 +46,6 @@
  */
 @ExperimentalApi("https://github.com/grpc/grpc-java/issues/1791")
 public class TestUtils {
-  public static final String TEST_SERVER_HOST = "foo.test.google.fr";
-
   /**
    * Capture the request headers from a client. Useful for testing metadata propagation.
    */
@@ -86,56 +63,14 @@ public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
     };
   }
 
-  /**
-   * Capture the request attributes. Useful for testing ServerCalls.
-   * {@link ServerCall#getAttributes()}
-   */
-  public static ServerInterceptor recordServerCallInterceptor(
-      final AtomicReference<ServerCall<?, ?>> serverCallCapture) {
-    return new ServerInterceptor() {
-      @Override
-      public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
-          ServerCall<ReqT, RespT> call,
-          Metadata requestHeaders,
-          ServerCallHandler<ReqT, RespT> next) {
-        serverCallCapture.set(call);
-        return next.startCall(call, requestHeaders);
-      }
-    };
-  }
-
-  /**
-   * Creates a new {@link InetSocketAddress} that overrides the host with {@link #TEST_SERVER_HOST}.
-   */
-  public static InetSocketAddress testServerAddress(String host, int port) {
-    try {
-      InetAddress inetAddress = InetAddress.getByName(host);
-      inetAddress = InetAddress.getByAddress(TEST_SERVER_HOST, inetAddress.getAddress());
-      return new InetSocketAddress(inetAddress, port);
-    } catch (UnknownHostException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-  /**
-   * Creates a new {@link InetSocketAddress} on localhost that overrides the host with
-   * {@link #TEST_SERVER_HOST}.
-   */
-  public static InetSocketAddress testServerAddress(int port) {
-    try {
-      InetAddress inetAddress = InetAddress.getByName("localhost");
-      inetAddress = InetAddress.getByAddress(TEST_SERVER_HOST, inetAddress.getAddress());
-      return new InetSocketAddress(inetAddress, port);
-    } catch (UnknownHostException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
   /**
    * Returns the ciphers preferred to use during tests. They may be chosen because they are widely
    * available or because they are fast. There is no requirement that they provide confidentiality
    * or integrity.
+   *
+   * @deprecated Not for public use
    */
+  @Deprecated
   public static List<String> preferredTestCiphers() {
     String[] ciphers;
     try {
@@ -143,7 +78,7 @@ public static List<String> preferredTestCiphers() {
     } catch (NoSuchAlgorithmException ex) {
       throw new RuntimeException(ex);
     }
-    List<String> ciphersMinusGcm = new ArrayList<String>();
+    List<String> ciphersMinusGcm = new ArrayList<>();
     for (String cipher : ciphers) {
       // The GCM implementation in Java is _very_ slow (~1 MB/s)
       if (cipher.contains("_GCM_")) {
@@ -154,37 +89,14 @@ public static List<String> preferredTestCiphers() {
     return Collections.unmodifiableList(ciphersMinusGcm);
   }
 
-  /**
-   * Saves a file from the classpath resources in src/main/resources/certs as a file on the
-   * filesystem.
-   *
-   * @param name  name of a file in src/main/resources/certs.
-   */
-  public static File loadCert(String name) throws IOException {
-    InputStream in = new BufferedInputStream(TestUtils.class.getResourceAsStream("/certs/" + name));
-    File tmpFile = File.createTempFile(name, "");
-    tmpFile.deleteOnExit();
-
-    OutputStream os = new BufferedOutputStream(new FileOutputStream(tmpFile));
-    try {
-      int b;
-      while ((b = in.read()) != -1) {
-        os.write(b);
-      }
-      os.flush();
-    } finally {
-      in.close();
-      os.close();
-    }
-
-    return tmpFile;
-  }
-
   /**
    * Loads an X.509 certificate from the classpath resources in src/main/resources/certs.
    *
    * @param fileName  name of a file in src/main/resources/certs.
+   *
+   * @deprecated Not for public use
    */
+  @Deprecated
   public static X509Certificate loadX509Cert(String fileName)
       throws CertificateException, IOException {
     CertificateFactory cf = CertificateFactory.getInstance("X.509");
@@ -199,16 +111,23 @@ public static X509Certificate loadX509Cert(String fileName)
 
   /**
    * Creates an SSLSocketFactory which contains {@code certChainFile} as its only root certificate.
+   *
+   * @deprecated Not for public use
    */
+  @Deprecated
   public static SSLSocketFactory newSslSocketFactoryForCa(Provider provider,
       File certChainFile) throws Exception {
     KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
     ks.load(null, null);
     CertificateFactory cf = CertificateFactory.getInstance("X.509");
-    X509Certificate cert = (X509Certificate) cf.generateCertificate(
-        new BufferedInputStream(new FileInputStream(certChainFile)));
-    X500Principal principal = cert.getSubjectX500Principal();
-    ks.setCertificateEntry(principal.getName("RFC2253"), cert);
+    BufferedInputStream in = new BufferedInputStream(new FileInputStream(certChainFile));
+    try {
+      X509Certificate cert = (X509Certificate) cf.generateCertificate(in);
+      X500Principal principal = cert.getSubjectX500Principal();
+      ks.setCertificateEntry(principal.getName("RFC2253"), cert);
+    } finally {
+      in.close();
+    }
 
     // Set up trust manager factory to use our key store.
     TrustManagerFactory trustManagerFactory =
diff --git a/testing/src/main/java/io/grpc/testing/TlsTesting.java b/testing/src/main/java/io/grpc/testing/TlsTesting.java
new file mode 100644
index 00000000000..3f88fd0402e
--- /dev/null
+++ b/testing/src/main/java/io/grpc/testing/TlsTesting.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2017 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.testing;
+
+import io.grpc.ExperimentalApi;
+import java.io.InputStream;
+
+/** Convenience utilities for using TLS in tests. */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1791")
+public final class TlsTesting {
+  /**
+   * Retrieves the specified test certificate or key resource in src/main/resources/certs/ as an
+   * {@code InputStream}.
+   *
+   * @param name name of a file in src/main/resources/certs/, e.g., {@code "ca.key"}.
+   *
+   * @since 1.8.0
+   */
+  public static InputStream loadCert(String name) {
+    return TestUtils.class.getResourceAsStream("/certs/" + name);
+  }
+
+  private TlsTesting() {}
+}
diff --git a/testing/src/main/java/io/grpc/testing/package-info.java b/testing/src/main/java/io/grpc/testing/package-info.java
new file mode 100644
index 00000000000..7de3e3ba09b
--- /dev/null
+++ b/testing/src/main/java/io/grpc/testing/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 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.
+ */
+
+/**
+ * API that is useful for testing gRPC.
+ */
+package io.grpc.testing;
diff --git a/testing/src/main/resources/certs/README b/testing/src/main/resources/certs/README
index e6d411ad293..13e375784c5 100644
--- a/testing/src/main/resources/certs/README
+++ b/testing/src/main/resources/certs/README
@@ -6,7 +6,7 @@ Bad credentials (badclient.* / badserver.*):
 
 These are self-signed certificates:
 
-$ openssl req -x509 -newkey rsa:1024 -keyout badserver.key -out badserver.pem \
+$ openssl req -x509 -newkey rsa:2048 -keyout badserver.key -out badserver.pem \
   -days 3650 -nodes
 
 When prompted for certificate information, everything is default except the
@@ -19,54 +19,85 @@ Valid test credentials:
 The ca is self-signed:
 ----------------------
 
-$ openssl req -x509 -new -newkey rsa:1024 -nodes -out ca.pem -config ca-openssl.cnf -days 3650 -extensions v3_req
+$ openssl req -x509 -new -newkey rsa:2048 -nodes -keyout ca.key -out ca.pem \
+  -config ca-openssl.cnf -days 3650 -extensions v3_req
 When prompted for certificate information, everything is default.
 
 client is issued by CA:
 -----------------------
 
-$ openssl genrsa -out client.key.rsa 1024
+$ openssl genrsa -out client.key.rsa 2048
 $ openssl pkcs8 -topk8 -in client.key.rsa -out client.key -nocrypt
-$ rm client.key.rsa
 $ openssl req -new -key client.key -out client.csr
 
 When prompted for certificate information, everything is default except the
 common name which is set to testclient.
 
-$ openssl ca -in client.csr -out client.pem -keyfile ca.key -cert ca.pem -verbose -config openssl.cnf -days 3650 -updatedb
-$ openssl x509 -in client.pem -out client.pem -outform PEM
+$ openssl x509 -req -CA ca.pem -CAkey ca.key -CAcreateserial -in client.csr \
+  -out client.pem -days 3650
 
 server0 is issued by CA:
 ------------------------
 
-$ openssl genrsa -out server0.key.rsa 1024
+$ openssl genrsa -out server0.key.rsa 2048
 $ openssl pkcs8 -topk8 -in server0.key.rsa -out server0.key -nocrypt
-$ rm server0.key.rsa
 $ openssl req -new -key server0.key -out server0.csr
 
 When prompted for certificate information, everything is default except the
 common name which is set to *.test.google.com.au.
 
-$ openssl ca -in server0.csr -out server0.pem -keyfile ca.key -cert ca.pem -verbose -config openssl.cnf -days 3650 -updatedb
-$ openssl x509 -in server0.pem -out server0.pem -outform PEM
+$ openssl x509 -req -CA ca.pem -CAkey ca.key -CAcreateserial -in server0.csr \
+  -out server0.pem -days 3650
 
 server1 is issued by CA with a special config for subject alternative names:
 ----------------------------------------------------------------------------
 
-$ openssl genrsa -out server1.key.rsa 1024
+$ openssl genrsa -out server1.key.rsa 2048
 $ openssl pkcs8 -topk8 -in server1.key.rsa -out server1.key -nocrypt
-$ rm server1.key.rsa
 $ openssl req -new -key server1.key -out server1.csr -config server1-openssl.cnf
 
 When prompted for certificate information, everything is default except the
 common name which is set to *.test.google.com.
 
-$ openssl ca -in server1.csr -out server1.pem -keyfile ca.key -cert ca.pem -verbose -config server1-openssl.cnf -days 3650 -extensions v3_req -updatedb
-$ openssl x509 -in server1.pem -out server1.pem -outform PEM
+$ openssl x509 -req -CA ca.pem -CAkey ca.key -CAcreateserial -in server1.csr \
+  -out server1.pem -extensions req_ext -extfile server1-openssl.cnf -days 3650
 
-Gotchas
-=======
+ecdsa.key is used to test keys with algorithm other than RSA:
+----------------------------------------------------------------------------
+$ openssl ecparam -name secp256k1 -genkey -noout -out ecdsa.pem
+$ openssl pkcs8 -topk8 -in ecdsa.pem -out ecdsa.key -nocrypt
 
-You may have to delete and recreate the index.txt file so that it is empty when
-running the `openssl ca` command.
+SPIFFE test credentials:
+=======================
 
+The SPIFFE related extensions are listed in spiffe-openssl.cnf config. Both
+client_spiffe.pem and server1_spiffe.pem are generated in the same way with
+original client.pem and server1.pem but with using that config. Here are the
+exact commands (we pass "-subj" as argument in this case):
+----------------------
+$ openssl req -new -key client.key -out spiffe-cert.csr \
+ -subj /C=US/ST=CA/L=SVL/O=gRPC/CN=testclient/ \
+ -config spiffe-openssl.cnf -reqexts spiffe_client_e2e
+$ openssl x509 -req -CA ca.pem -CAkey ca.key -CAcreateserial \
+ -in spiffe-cert.csr -out client_spiffe.pem -extensions spiffe_client_e2e \
+  -extfile spiffe-openssl.cnf -days 3650 -sha256
+$ openssl req -new -key server1.key -out spiffe-cert.csr \
+ -subj /C=US/ST=CA/L=SVL/O=gRPC/CN=*.test.google.com/ \
+ -config spiffe-openssl.cnf -reqexts spiffe_server_e2e
+$ openssl x509 -req -CA ca.pem -CAkey ca.key -CAcreateserial \
+ -in spiffe-cert.csr -out server1_spiffe.pem -extensions spiffe_server_e2e \
+  -extfile spiffe-openssl.cnf -days 3650 -sha256
+
+Additionally, SPIFFE trust bundle map files spiffebundle.json and \
+spiffebundle1.json are manually created for end to end testing. The \
+spiffebundle.json contains "example.com" trust domain (only this entry is used \
+in e2e tests) matching URI SAN of server1_spiffe.pem, and the CA certificate \
+there is ca.pem. The spiffebundle.json file contains "foo.bar.com" trust \
+domain (only this entry is used in e2e tests) matching URI SAN of \
+client_spiffe.pem, and the CA certificate there is also ca.pem.
+
+Clean up:
+---------
+$ rm *.rsa
+$ rm *.csr
+$ rm ca.srl
diff --git a/testing/src/main/resources/certs/badclient.key b/testing/src/main/resources/certs/badclient.key
index 5832685122a..6cd102b8308 100644
--- a/testing/src/main/resources/certs/badclient.key
+++ b/testing/src/main/resources/certs/badclient.key
@@ -1,16 +1,28 @@
 -----BEGIN PRIVATE KEY-----
-MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBALJfYnFn4nkj52WF
-E5W2qUxCfjsEFyuXYYKS/07UPWsv3gpZhtjXgdeGL+dpwEBC0IRDBfGnkMp6YY5S
-O7rnEz0X3r/fvgYy+dEl2jnaA6zgc7RzMGl9U11d56gP9FiDC2190mvP/hpq2xLZ
-CTbIximpmaoQyxuuH1bbYunesIG/AgMBAAECgYAdqJCEzMIyZE7oaW0tOpcB0BiP
-FYoIvH4BKRH8eHvR476mt+YdDhBP1scGUmYeCT4Ej+RgHv2LPTgVYwT9eciP2+E/
-CBCNRel0Sw9JepwW0r+jWJtDY1pp6YXAgNRGX2UflvUsT+o9lZvagf9moLTMyGvU
-uLFnsyfLim1B4vXvWQJBANouZllXGZoSrZLtR3VgV4tzRQvJxu84kLeIk64Ov47X
-pHVBMTRBfzPEhbBodjr1m5OLaVLqkFcXftzRCrbWoKsCQQDRSoLLXOiLrtJ3DLJC
-rX7Y8wrHZrqk5bMdZLGa/UX8RanhVw3+Xp+urd1711umeNJfzu/MCk4a1KkG/CU0
-rqs9AkA4cSx1DD1JSG+yxMNpsAS1xJomFIrsM9vsPt7FdndDwrF+y+CovhDkGYDk
-RAHh+svGfZg/pQK2JRPimAmHhzqFAkEAu6Ya70s2FUeB3Mu9aJs2CD6hg3dQEVkB
-53DI7TX48d9kGW58VX1xnqS02LyWqAPcW5qm1kLHFLdndaPNmBaj4QJBAJugl367
-9d9t/QLTSuULLaoYv2vJT3s1y9HN89EoaDDEkPVfQu6GVEXgIBtim1sI/VPSzI8H
-aXvaTUwblFWSM70=
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDvdzKDTYvRgjBO
+UOrzDwkAZGwNFHHlMYyMGI5tItj3tCzXkbpM0uz3ZjHVahu+eYc+KvYApM64F2dB
+b16hs713FCk8mihYABjnSndrQsl/U2v8YFT7DipfLReqqaOGu2o9HdvWfiUlaiC/
+UGGfR+YblpK7CG+7/hvTXtUsMw+OppoeH9z87rhOJMxtiC7XwU5rhEmab/1f1XM/
+nLoZrfDAcTbDywoeu826SJ3mifajq7oK3LDdNLjWZwfEsCO1qp2C4gLvBlOOKsWO
+LNby6ByxCOPlCTa0UCaVuoNclYol71jyi17KW+Nk0nNe9yaVcyr6H0z3bImfJhbS
+u4rzI93nAgMBAAECggEBAOIPOJRTpGaH7GpCYUpLK0g/hPFkF5EyEWg/1lSYzRIp
++RsX6zOS+zkiNHEv1jkeKNo7XDiHXM7U6RkQtdkZAQdk9PjM3sEUdm4CEnIjfmzA
+p/R8TD0kxkNLIkhuFH2gd05y3ZHDS/XiFkAE9eOT0FrC7om6ESD7ZfFIWR18pncW
+ZGq7tFAZZRmpkum2D+MJy1gWxIXBxt5madTEpRxQd56toEnfx372F0y4zkcX3pnE
+4H6FaJUBjdvKl2QzF5c0jBqgxMRvWP5YfNu8+dmaQORPkpzSptOPmZM9VKV+tJVS
+1xnOI6DtrnNZRojegR/E6KhNyiPTYy97UgYzdKS+SSECgYEA+wgSIqrfkeqqotJx
+cGxF4x9v/ldKr5hlhJNoKXLkepkcrvhhxfHKgjWz1nZY/+Rpg42GFMvxWRrGTMIJ
+ddiOr24p0HCkusWRMKQL7XxvuHDq0ro8SGqXzqWGuH31R+YNP8dy2pqd3OlwzTgg
+8v0wwzx8AuyP5Ys4M20Ewv7Xuy0CgYEA9DSGMU8jmjxJ/uPDCXWOEAqtE78wTtIw
+uMBv+ge0inc37xf+fN6D/ziTrJvgw/XyT15pmQdOlXx3Sg1h9XBZeIlaeCdFWrFB
+oYrVsiuoXRswfkFwA0yOkCsHyGiI4TE0W1rGbqP158IjwXPczBswWI7i/D6LpINL
+BD7YYpfHmeMCgYB08AiKr7Cf54H/gSqo5TcVGzLvdzhqXgKEZKp0DHpUhfivpTLe
+o8jjKSMSN2U0JvHj/0xDadGO4YMYhJcll3C4VggSejaybpA46WJJCdt9PtSUv36P
+eWAoOkFstfhJuufXGxDstnPtUa1jW881gi5x9D4MmqhZlKXkhtdeApr6LQKBgQDd
+ItsJt9JTjpirGfC5lhwI5sIICa9jEO9RveEoluWkJYUfG6k1xgHdkYwYWCdXDFZa
+DPKuwnEk6MrU4f181joO7sJf35/sGmuGL0SHzQTvGvn0uqkGM8M9RdoMXqzkzzvM
+Jg1ej1bUgXcDbTnaEhzbdLiTFsg5NzMtKwOjdDIpZQKBgEIHeJIqiGjYgf7mUlX2
+vNWgFNlzApkFSCQ8TkzkDOjtCdSHfdRDJ6+q8cS2TSQ7QPoAlI1woS0G48TNbVSo
+wD0jNVRTdpA6R5FPsg09ohB/caSn0zlGVha2GS08ceYrn7nn4PSZ/UIYTm3pjUlV
+H5tvHv0gG2C5vy3tIYQtSQCk
 -----END PRIVATE KEY-----
diff --git a/testing/src/main/resources/certs/badclient.pem b/testing/src/main/resources/certs/badclient.pem
index 1785970221f..345da3932d9 100644
--- a/testing/src/main/resources/certs/badclient.pem
+++ b/testing/src/main/resources/certs/badclient.pem
@@ -1,17 +1,22 @@
 -----BEGIN CERTIFICATE-----
-MIICoDCCAgmgAwIBAgIJANIz2/zoRiapMA0GCSqGSIb3DQEBBQUAMGkxCzAJBgNV
-BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX
-aWRnaXRzIFB0eSBMdGQxIjAgBgNVBAMMGWJhZGNsaWVudC50ZXN0Lmdvb2dsZS5j
-b20wHhcNMTQwNzI4MjAwODI1WhcNMjQwNzI1MjAwODI1WjBpMQswCQYDVQQGEwJB
-VTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0
-cyBQdHkgTHRkMSIwIAYDVQQDDBliYWRjbGllbnQudGVzdC5nb29nbGUuY29tMIGf
-MA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCyX2JxZ+J5I+dlhROVtqlMQn47BBcr
-l2GCkv9O1D1rL94KWYbY14HXhi/nacBAQtCEQwXxp5DKemGOUju65xM9F96/374G
-MvnRJdo52gOs4HO0czBpfVNdXeeoD/RYgwttfdJrz/4aatsS2Qk2yMYpqZmqEMsb
-rh9W22Lp3rCBvwIDAQABo1AwTjAdBgNVHQ4EFgQU523AJMR8Ds9V8fhf7gu1i0MM
-UqAwHwYDVR0jBBgwFoAU523AJMR8Ds9V8fhf7gu1i0MMUqAwDAYDVR0TBAUwAwEB
-/zANBgkqhkiG9w0BAQUFAAOBgQCI/tvSBYH1iyfLaCTBKwpdj36+MkR9EeJJmImx
-X+bjhKWXwsBX4PDMWvdusr++QGUYtyoya+hfYMXRhXua39mD54xgloQNuu9REDwX
-Ffto+aOw3BcYducz6ofxicFK/Y2VeXDurSMpRv5TfGf2Qr6eOOdaRhj6ed7BibHk
-X1VGZA==
+MIIDszCCApugAwIBAgIUONWbkUn1obHCw9L7lMNEE5REvb8wDQYJKoZIhvcNAQEL
+BQAwaTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEiMCAGA1UEAwwZYmFkY2xpZW50LnRl
+c3QuZ29vZ2xlLmNvbTAeFw0yMDAzMTcxNzQzMjNaFw0zMDAzMTUxNzQzMjNaMGkx
+CzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRl
+cm5ldCBXaWRnaXRzIFB0eSBMdGQxIjAgBgNVBAMMGWJhZGNsaWVudC50ZXN0Lmdv
+b2dsZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDvdzKDTYvR
+gjBOUOrzDwkAZGwNFHHlMYyMGI5tItj3tCzXkbpM0uz3ZjHVahu+eYc+KvYApM64
+F2dBb16hs713FCk8mihYABjnSndrQsl/U2v8YFT7DipfLReqqaOGu2o9HdvWfiUl
+aiC/UGGfR+YblpK7CG+7/hvTXtUsMw+OppoeH9z87rhOJMxtiC7XwU5rhEmab/1f
+1XM/nLoZrfDAcTbDywoeu826SJ3mifajq7oK3LDdNLjWZwfEsCO1qp2C4gLvBlOO
+KsWOLNby6ByxCOPlCTa0UCaVuoNclYol71jyi17KW+Nk0nNe9yaVcyr6H0z3bImf
+JhbSu4rzI93nAgMBAAGjUzBRMB0GA1UdDgQWBBTKJskEYd2ndrwihPTg2PzYF/kP
+gzAfBgNVHSMEGDAWgBTKJskEYd2ndrwihPTg2PzYF/kPgzAPBgNVHRMBAf8EBTAD
+AQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBoGwWR0pLM1icX4bIJ6yduFU/A4jSiqET6
+gvJhwgErilqTKfH6Y89rqtzW8k4UurAOCsE4FA6wbkHWwrUMnClY4lkHJh+MuNaJ
+nCGrK8wRKGb/mqW9d5pP72Et1Q6OW6DAKqGfjDWh2MzSPHBxcCLeyigO1wqd4W1T
+nvvql6l4L+B5IT/c+/EHO3PwbI9v6MGTtLjsZgkRKItaPh+YeJdmBYhRD1BvWb6s
+VwEb7aQ1oSF+esUvMmjGVuHXuQvWJahnjYdYT2DikyqR+AwaKzre4GJMHsX3/Cf8
+qdxyI+B1jUwNr7sLA2EYDjnUR0jEHcrOBSpIQyRMGWduj0P16yb9
 -----END CERTIFICATE-----
diff --git a/testing/src/main/resources/certs/badserver.key b/testing/src/main/resources/certs/badserver.key
index abfbde10ff6..1f5a31666cb 100644
--- a/testing/src/main/resources/certs/badserver.key
+++ b/testing/src/main/resources/certs/badserver.key
@@ -1,16 +1,28 @@
 -----BEGIN PRIVATE KEY-----
-MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAKeZ1e1y29cmBKaW
-oIUwJ5neOJUjx+eD/3nRPe+dvLXEd9+db0fG5RYRR0S3mF1Ywuj4PIxlTW2YprUS
-oGSw+tcqWNIzxv94HjwYFkkvER3AblXcDBh0P2zAkzg+nf9AcAsMh0QpDTyrXtMl
-gqryjq1/vkhFofKMMbY+aXJdG6OBAgMBAAECgYAAgaB51S0A22aMMkxN2rVj6530
-JWWHN4jgD1fGj41wZyWNkWYyq1Ep3ed/N6bIMWp1VbqpGe0/9YQba/D8HOTFHGRt
-72YXnP1e/ds8cxU4x4j1vvqSPtXpMmkiXfXijOvCl9mrMH2xjghFAt6/1Nb9xo1m
-VdcOB8OdSuOIw6CI+QJBAN5FZUbS+bRXDWII/FaAih1DBpwCxhYEN+TXPJBxSen6
-kOzGt5g+mB6YqRMZ/qshshwPq7bsgFGfJ2lIdS2t3GsCQQDBCKifV5AAkOdOUrkK
-HvoX3qnVmyIA8CyvWLcIWpfZ76QAYh0q0StedKdOMXaB1jTeSJ2KU1nlss7UD1Yw
-VbrDAkAwjMHpbW3jiVw//Kx5jIwehiRscWKpLnSzBJyTBFvbwsJjJai2lX2OuVO8
-+2GYKb0Iyhd81j3VFkl6grwtpRtPAkB7+n+yt555fpfRKjhGU9b09cHGu7h/OcK5
-bBVCfE0DYHLI/DsXgPiF1g6Onh4rDdUu3xyv9xDKAqnscV099hHZAkEAvcFBfXZs
-tk18N+bUcvXTdZjzZbfLCHlJmwPIspZ8G/6Pn63deg4GVYoCvTwGruah+8y734Ph
-7PskfPgUQlB7Ag==
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDRY2Z886nT6KF4
+tjgJTX0l1M4j8bQp+jKfXz+hwUZbn/PnCXJlu/5denpyu4XrLxr6Ix4Il97SrKfQ
+iGaSZQ8hcq6WQdEDfuo/U7R/dk6lYG7q+yg7+xHm02DzVdPLp09kLhU+fWH3Wek0
+9GCk9iC1/sVTIomBYpar61Ris04iA1QveR+LZKNkQ8rL2i191Djs8cdrn9yhWdfJ
+Ai89lLl6S6d8cXru1LwtEe0ejctnKf6ANqMnmyWTbHV8h0Cc3fbAnx92HsWDMJKe
+8mI0CClauxrlagMHyw10NuFb9/MBEkFPJfxcUyW6F45LmqGHVfcxx6/BU7XRbWx8
+aQM/pt2LAgMBAAECggEBAKWpei3D7op9FDvYF0+s4iXrT0j682r+y8xx5HtK2iql
+y6fwPnUlHqPAwl5B5TtkonhjDmEIH0AZYBBJyrVqhWUWQfEZk4+rexOtWzI5XRHU
+0QzSt0t1Yf15IcyEDDSlY9fD6gTt2HOFzE+cRVZecRTsxBv5SEd4w/KzFqmcaWXY
+Q7mLvCs6eQ55LBQ6EMweZ3XE57qPf71oV8Ckxv/jstLlkE+3JICgEAaiOEzi7oCm
+hYbkoU2VNewx5EA5ka52DQzbVYYYuDbjqtVPXCmlVdejBBmUCAlhdjAIDBYq/RMf
+sVMagAo19Wt5lYuNGD9qzMUmzZPaVmkg4yUmU8EYFVkCgYEA8Tyup/0yx+/tp8KQ
+cLyGc4RDUTfabL8mlvxcbEge9fQ12aHE3cA/hkHCI7AZxwrHYwb1hxzLaOmKYfFC
+oLxfzx81p5BO0lQWcKiFZ6ISiku4TPdmBaauKKxd62kFUPO4Q6Zk1MFHMXrvZUxZ
+BsK058HZ5JALDdQ5wBfJE5P58rcCgYEA3jPDMiXsH1s5gM/bh0s+cC1AFSst6YM3
+rRPmHrqJJhKgU6gSB0d0LCUdj4/NkQT/Bw8DrfxLIqytsfRLKCx85K6lk8GfCk6T
+1OhPKRp8bgg6WDQiJfJMokJN5zrnC02ns1cVdQSPY8bFxB++tv3du6DKLYx0e46D
+Q9ojYqWHh80CgYEA0Shh7nkTrFKUZZ3GClkK4eFNVH/uu9bIKKTJpYCqh2mjvvwJ
+apKjAU7GepbW4sKvuWZxPyJyIpZKSz0ZHa/2CejvZkcycB5EDo2ujPnyxUF9nA3s
+wP2RhuZb0B4QY+3MV6tPRUAG8Bm8ssGNdtUecMqclxVk4Cqfn7N/vZ/RWOUCgYAL
+i2rv1xKOioHRVHtWay1iTKeQsf6frEafQnJpVE294afc0NWm9SpvBLqlc9Y9W6IY
+bspFJt+MfKZFoaip/K28f+pwY9XshiqeHDfIreybFuhZHtRLXmxm3cUIZ4ILj0xQ
+QA0IWGVOzMwHpZKWFViI4BDBDxQaO0xMoS/Hd0w0XQKBgF5uZXXrNLmCeU6oco1R
+gjGJE4gRwaSVcVJbs/VLbBmHT1VhBGsiluBuTpbmzDfyHWHJprnthlSTgqHXSax1
+6GvHZ2NHBqmD2uxEGuwBffzhwWVxHpgSrRgvnnaeIph2Iv92/ATN5LCc5vF+SNGx
+2kKWYTDSRu9q1xHpXcax+nmJ
 -----END PRIVATE KEY-----
diff --git a/testing/src/main/resources/certs/badserver.pem b/testing/src/main/resources/certs/badserver.pem
index 983c979f312..217dd640eba 100644
--- a/testing/src/main/resources/certs/badserver.pem
+++ b/testing/src/main/resources/certs/badserver.pem
@@ -1,17 +1,22 @@
 -----BEGIN CERTIFICATE-----
-MIICoDCCAgmgAwIBAgIJAPdqwqsKNy81MA0GCSqGSIb3DQEBBQUAMGkxCzAJBgNV
-BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX
-aWRnaXRzIFB0eSBMdGQxIjAgBgNVBAMMGWJhZHNlcnZlci50ZXN0Lmdvb2dsZS5j
-b20wHhcNMTQwNzI4MjAwODU0WhcNMjQwNzI1MjAwODU0WjBpMQswCQYDVQQGEwJB
-VTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0
-cyBQdHkgTHRkMSIwIAYDVQQDDBliYWRzZXJ2ZXIudGVzdC5nb29nbGUuY29tMIGf
-MA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCnmdXtctvXJgSmlqCFMCeZ3jiVI8fn
-g/950T3vnby1xHffnW9HxuUWEUdEt5hdWMLo+DyMZU1tmKa1EqBksPrXKljSM8b/
-eB48GBZJLxEdwG5V3AwYdD9swJM4Pp3/QHALDIdEKQ08q17TJYKq8o6tf75IRaHy
-jDG2PmlyXRujgQIDAQABo1AwTjAdBgNVHQ4EFgQU3u/qvHr9knMBeZyAD7mAA/ec
-8cUwHwYDVR0jBBgwFoAU3u/qvHr9knMBeZyAD7mAA/ec8cUwDAYDVR0TBAUwAwEB
-/zANBgkqhkiG9w0BAQUFAAOBgQA/FmR1SGLguxCCfhp4CYCbrAePSyPWDi48gTwj
-vVZf/OMxdVu/H8sBYFf27BjbrEugAw16DElFtgTZ83pLb2BvkUgb6vBUK5sEkgmh
-z88zBsgDp8aCf4STDOLFZMBh/E9ZKkm1zogbEmlTjFp/ceSpa2gNv7OuN4WiorOh
-Wvw40g==
+MIIDszCCApugAwIBAgIULEum14ranwlUZjuZchSWaHtj8Z4wDQYJKoZIhvcNAQEL
+BQAwaTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEiMCAGA1UEAwwZYmFkc2VydmVyLnRl
+c3QuZ29vZ2xlLmNvbTAeFw0yMDAzMTcxNzE5NTRaFw0zMDAzMTUxNzE5NTRaMGkx
+CzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRl
+cm5ldCBXaWRnaXRzIFB0eSBMdGQxIjAgBgNVBAMMGWJhZHNlcnZlci50ZXN0Lmdv
+b2dsZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDRY2Z886nT
+6KF4tjgJTX0l1M4j8bQp+jKfXz+hwUZbn/PnCXJlu/5denpyu4XrLxr6Ix4Il97S
+rKfQiGaSZQ8hcq6WQdEDfuo/U7R/dk6lYG7q+yg7+xHm02DzVdPLp09kLhU+fWH3
+Wek09GCk9iC1/sVTIomBYpar61Ris04iA1QveR+LZKNkQ8rL2i191Djs8cdrn9yh
+WdfJAi89lLl6S6d8cXru1LwtEe0ejctnKf6ANqMnmyWTbHV8h0Cc3fbAnx92HsWD
+MJKe8mI0CClauxrlagMHyw10NuFb9/MBEkFPJfxcUyW6F45LmqGHVfcxx6/BU7XR
+bWx8aQM/pt2LAgMBAAGjUzBRMB0GA1UdDgQWBBTYP9Av5QoPxsDRE33wQedENOke
+wDAfBgNVHSMEGDAWgBTYP9Av5QoPxsDRE33wQedENOkewDAPBgNVHRMBAf8EBTAD
+AQH/MA0GCSqGSIb3DQEBCwUAA4IBAQCXA/Ewb5laDDxJi4YJxnmqQsb4WSsm65Hj
+MX21Ii2vzf4XZ+i8c9xBezCae85Bkhtb/oMC/V15DshjVkkJNmdQfAlYD1NASSrN
+hTaiQ4AfXWjO7H8o2B/rneZtA21NDCwvFxTXeJzAVnBkpIePR//KmuHjtCMjsrtP
+ovckcTRGmhWJJ9sRx4HCsJXygBvnCIIIYC585aU4+nE53UDNT2T+Bd4b1vPmwf9R
+9XgbyN6AhQ+0F11zlnftwsJ23nbnXqX/fpG/YZuhnPwaUILRodc6HZQtf/8xpRcA
+0dKMdnL2YtBjuL5QFJMLT0mdsmnXj3h/oK8894nYBZYSmlb3bzZK
 -----END CERTIFICATE-----
diff --git a/testing/src/main/resources/certs/ca.key b/testing/src/main/resources/certs/ca.key
index 03c4f950e38..03be0bfa6ee 100644
--- a/testing/src/main/resources/certs/ca.key
+++ b/testing/src/main/resources/certs/ca.key
@@ -1,16 +1,28 @@
 -----BEGIN PRIVATE KEY-----
-MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAMBA3wVeTGHZR1Ry
-e/i+J8a2cu5gXwFV6TnObzGM7bLFCO5i9v4mLo4iFzPsHmWDUxKS3Y8iXbu0eYBl
-LoNY0lSvxDx33O+DuwMmVN+DzSD+Eod9zfvwOWHsazYCZT2PhNxnVWIuJXViY4JA
-HUGodjx+QAi6yCAurUZGvYXGgZSBAgMBAAECgYAxRi8i9BlFlufGSBVoGmydbJOm
-bwLKl9dP3o33ODSP9hok5y6A0w5plWk3AJSF1hPLleK9VcSKYGYnt0clmPVHF35g
-bx2rVK8dOT0mn7rz9Zr70jcSz1ETA2QonHZ+Y+niLmcic9At6hRtWiewblUmyFQm
-GwggIzi7LOyEUHrEcQJBAOXxyQvnLvtKzXiqcsW/K6rExqVJVk+KF0fzzVyMzTJx
-HRBxUVgvGdEJT7j+7P2kcTyafve0BBzDSPIaDyiJ+Y0CQQDWCb7jASFSbu5M3Zcd
-Gkr4ZKN1XO3VLQX10b22bQYdF45hrTN2tnzRvVUR4q86VVnXmiGiTqmLkXcA2WWf
-pHfFAkAhv9olUBo6MeF0i3frBEMRfm41hk0PwZHnMqZ6pgPcGnQMnMU2rzsXzkkQ
-OwJnvAIOxhJKovZTjmofdqmw5odlAkBYVUdRWjsNUTjJwj3GRf6gyq/nFMYWz3EB
-RWFdM1ttkDYzu45ctO2IhfHg4sPceDMO1s6AtKQmNI9/azkUjITdAkApNa9yFRzc
-TBaDNPd5KVd58LVIzoPQ6i7uMHteLXJUWqSroji6S3s4gKMFJ/dO+ZXIlgQgfJJJ
-ZDL4cdrdkeoM
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCwYvShd+UXQvOg
+z4GH6pRT3KGrPDbDw45fma7+I0LJQ4GupoeLuYYfHvcYPTV2I3MLO+VxCp00gfo1
+BIvsNOkGNxrrqNhP27ve9l7YwOuvWdVu4u9+73znRx3GJQ4ie/nF/z6xMcbQL5r5
+UC8yGwuJGOyr6VcpEnKTnORtuwRPJuqnGgn4rsKhLLfJz+RAhjdOKnAS3CQo/iHP
+KjoqIZ38M97GJ7icFQic3dtLUFR41nnN5ogLZ6DduR55btypPnlv5h6foLFjRMST
+MEroAq39ZSJqUoyBPTBtPFFk7uRQIfdKrp7/Bd4V0n4e91Us+UCDlOcxo2lF1CKH
+/ydEWmx3AgMBAAECggEAKrDosKQKKKUlvkg6+6CFIf8GiiFax+ru7KiPuCbkpT3X
+h2P67pCKq8Gc4Jr/84YE9DUdBU0iW3ESE/7ztsnflIeF1n/ZSwrN39sVfbTD1n8R
+r3LxsHFac8e8pxaU4zfKbmemztBTZFQBWFJV+fSdyCLmNX2WgPRcEuooR366PkWv
+xZLAxeDGqpnsa62o1GdGmalxx8aljLN/QcbQi73mR9Osim1OtSd1cyDlZ/8x6OoV
+Ae5GDN3Bj0hO9ZKzNWTbQpRw9SHKU6sWXtHlcDx4xi5kN/n9aptn7kixbY9y8uOM
+5zjErVGWvxdP94IvlSkrkenwnIjlHBtdlAjVuCFioQKBgQDoJLyfHNWPBnjPGVnK
+xcbIIwmf4C9UnZBbHRD3YxU/GBpsPgPh9EwhQTAXlGQGHeuslxCIh4cEfbOIrJ9b
+/s3OqeL9CSUaz/N+1av1ZuwOI9CEvNPi51IK+rXNRmVJG8pG6RaKNx57pXaFtmqq
+FUtC7twbPECvjspapn61nZYSiQKBgQDCg1tpGwZJJOCIkhYH4wFc4j4p0LxIcBJ2
+E3L9VnQ+APT/x8uitkZsuRY9tmWcHK8/zWTc1GpFdwGUJ9+Yzvprtej+P/buxM9J
+Y6ZJZdCIHWDuh3eq+sXS4lwr5fi7ir5m97npG1bXPlOoYIJ7p172EyoNmurRIgiP
+LWnzK0jG/wKBgQCRQtOouNFFcyZLaTCPutxdRddy7ESRrRq0eOax9pVH6tw12URy
+snyk3naqepdwYG6li82zsSKig8nA/0uktDeyVwoLjhpiwbc7KZc1sxaI7o4/US1B
+McBb0G/MqH0elz4myxnomP8BHhOhLflmvnZexrqCbFyJvk8PFFn7aUWMCQKBgDvX
+9BCzOszYJqh94X9NrQapqJxu1u6mZFelhjRBHARTgQ0MqC8IS0R58UjNTBeqj5Re
+mdCDHar/gSHW3qkBzPPEhMlsXol5TZjzqp5cT7sA5uicDwowmxpVgCwVVeBFQG0n
+fDAmtCIGz/A2uQ5YIRQuMzr6VZJAGUgLndQtlfd7AoGBAMq1imggFKd1rt49XCnO
+t97lpWOT+TlWYblHr01tOw+esawG5MFucqVI6tGpBSccTRQw6orWf4GK3KmkgQ6J
+UgHKjwYsA0sf4U5vppkdkbAbM/WwUPOTQpGFRERyJqMqFGIc4wMtZOJBxXwf+9iD
+l8tvan8w/6HugqnI7qqkTgLq
 -----END PRIVATE KEY-----
diff --git a/testing/src/main/resources/certs/ca.pem b/testing/src/main/resources/certs/ca.pem
index 6c8511a73c6..49d39cd8ed5 100644
--- a/testing/src/main/resources/certs/ca.pem
+++ b/testing/src/main/resources/certs/ca.pem
@@ -1,15 +1,20 @@
 -----BEGIN CERTIFICATE-----
-MIICSjCCAbOgAwIBAgIJAJHGGR4dGioHMA0GCSqGSIb3DQEBCwUAMFYxCzAJBgNV
-BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX
-aWRnaXRzIFB0eSBMdGQxDzANBgNVBAMTBnRlc3RjYTAeFw0xNDExMTEyMjMxMjla
-Fw0yNDExMDgyMjMxMjlaMFYxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0
-YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxDzANBgNVBAMT
-BnRlc3RjYTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAwEDfBV5MYdlHVHJ7
-+L4nxrZy7mBfAVXpOc5vMYztssUI7mL2/iYujiIXM+weZYNTEpLdjyJdu7R5gGUu
-g1jSVK/EPHfc74O7AyZU34PNIP4Sh33N+/A5YexrNgJlPY+E3GdVYi4ldWJjgkAd
-Qah2PH5ACLrIIC6tRka9hcaBlIECAwEAAaMgMB4wDAYDVR0TBAUwAwEB/zAOBgNV
-HQ8BAf8EBAMCAgQwDQYJKoZIhvcNAQELBQADgYEAHzC7jdYlzAVmddi/gdAeKPau
-sPBG/C2HCWqHzpCUHcKuvMzDVkY/MP2o6JIW2DBbY64bO/FceExhjcykgaYtCH/m
-oIU63+CFOTtR7otyQAWHqXa7q4SbCDlG7DyRFxqG0txPtGvy12lgldA2+RgcigQG
-Dfcog5wrJytaQ6UA0wE=
+MIIDWjCCAkKgAwIBAgIUWrP0VvHcy+LP6UuYNtiL9gBhD5owDQYJKoZIhvcNAQEL
+BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTIw
+MDMxNzE4NTk1MVoXDTMwMDMxNTE4NTk1MVowVjELMAkGA1UEBhMCQVUxEzARBgNV
+BAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0
+ZDEPMA0GA1UEAwwGdGVzdGNhMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEAsGL0oXflF0LzoM+Bh+qUU9yhqzw2w8OOX5mu/iNCyUOBrqaHi7mGHx73GD01
+diNzCzvlcQqdNIH6NQSL7DTpBjca66jYT9u73vZe2MDrr1nVbuLvfu9850cdxiUO
+Inv5xf8+sTHG0C+a+VAvMhsLiRjsq+lXKRJyk5zkbbsETybqpxoJ+K7CoSy3yc/k
+QIY3TipwEtwkKP4hzyo6KiGd/DPexie4nBUInN3bS1BUeNZ5zeaIC2eg3bkeeW7c
+qT55b+Yen6CxY0TEkzBK6AKt/WUialKMgT0wbTxRZO7kUCH3Sq6e/wXeFdJ+HvdV
+LPlAg5TnMaNpRdQih/8nRFpsdwIDAQABoyAwHjAMBgNVHRMEBTADAQH/MA4GA1Ud
+DwEB/wQEAwICBDANBgkqhkiG9w0BAQsFAAOCAQEAkTrKZjBrJXHps/HrjNCFPb5a
+THuGPCSsepe1wkKdSp1h4HGRpLoCgcLysCJ5hZhRpHkRihhef+rFHEe60UePQO3S
+CVTtdJB4CYWpcNyXOdqefrbJW5QNljxgi6Fhvs7JJkBqdXIkWXtFk2eRgOIP2Eo9
+/OHQHlYnwZFrk6sp4wPyR+A95S0toZBcyDVz7u+hOW0pGK3wviOe9lvRgj/H3Pwt
+bewb0l+MhRig0/DVHamyVxrDRbqInU1/GTNCwcZkXKYFWSf92U+kIcTth24Q1gcw
+eZiLl5FfrWokUNytFElXob0V0a5/kbhiLc3yWmvWqHTpqCALbVyF+rKJo2f5Kw==
 -----END CERTIFICATE-----
diff --git a/testing/src/main/resources/certs/client.key b/testing/src/main/resources/certs/client.key
index f48d0735d99..349b40033dd 100644
--- a/testing/src/main/resources/certs/client.key
+++ b/testing/src/main/resources/certs/client.key
@@ -1,16 +1,28 @@
 -----BEGIN PRIVATE KEY-----
-MIICeQIBADANBgkqhkiG9w0BAQEFAASCAmMwggJfAgEAAoGBAOxUR9uhvhbeVUIM
-s5WbH0px0mehl2+6sZpNjzvE2KimZpHzMJHukVH0Ffkvhs0b8+S5Ut9VNUAqd3IM
-JCCAEGtRNoQhM1t9Yr2zAckSvbRacp+FL/Cj9eDmyo00KsVGaeefA4Dh4OW+ZhkT
-NKcldXqkSuj1sEf244JZYuqZp6/tAgMBAAECgYEAi2NSVqpZMafE5YYUTcMGe6QS
-k2jtpsqYgggI2RnLJ/2tNZwYI5pwP8QVSbnMaiF4gokD5hGdrNDfTnb2v+yIwYEH
-0w8+oG7Z81KodsiZSIDJfTGsAZhVNwOz9y0VD8BBZZ1/274Zh52AUKLjZS/ZwIbS
-W2ywya855dPnH/wj+0ECQQD9X8D920kByTNHhBG18biAEZ4pxs9f0OAG8333eVcI
-w2lJDLsYDZrCB2ocgA3lUdozlzPC7YDYw8reg0tkiRY5AkEA7sdNzOeQsQRn7++5
-0bP9DtT/iON1gbfxRzCfCfXdoOtfQWIzTePWtURt9X/5D9NofI0Rg5W2oGy/MLe5
-/sXHVQJBAIup5XrJDkQywNZyAUU2ecn2bCWBFjwtqd+LBmuMciI9fOKsZtEKZrz/
-U0lkeMRoSwvXE8wmGLjjrAbdfohrXFkCQQDZEx/LtIl6JINJQiswVe0tWr6k+ASP
-1WXoTm+HYpoF/XUvv9LccNF1IazFj34hwRQwhx7w/V52Ieb+p0jUMYGxAkEAjDhd
-9pBO1fKXWiXzi9ZKfoyTNcUq3eBSVKwPG2nItg5ycXengjT5sgcWDnciIzW7BIVI
-JiqOszq9GWESErAatg==
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCyqYRp+DXVp72N
+FbQH8hdhTZLycZXOlJhmMsrJmrjn2p7pI/8mTZ/0FC+SGWBGZV+ELiHrmCX5zfaI
+Lr9Iuw7Ghr3Vzoefi8r62rLupVPNi/qdqyjWk2dECHC9Z3+Ag3KzKTyerXWjKcvy
+KVmM0ZxE0RXhDW/RoQbqZsU2GKg1B2rhUU8KN0gVmKn0rJHOxzRVSYeYLYp5Yn7K
+rtPJcKyo9aVuEr7dGANzpyF6lg/nYBWc+9SGwkoLdFvKvABYJMyrbNhHUQfv0fza
+Z0P86dfTENrDxzALrzGnqcx3KTrwJjkZ/aSr1tyD0/tXvukRFiPxWBJhjHQ70GqT
+FQY19RbhAgMBAAECggEAIL8JUhL4awyvpWhQ8xPgTSlWwbEn8BE0TacJnCILuhNM
+BRdf8LlRk/8PKQwVpVF3TFbYSMI+U6b4hMVssfv3HVQc/083dHq+3XOwUCVlUstR
+SAzTE2E5EDMr1stdh0SQhV4Nilfos9s5Uk1Z6IGSztoz1GgOErIc/mGPy/aA/hbr
+fRWHvTp35+MbCJSvZuOeevX2iLs0dNzqdk6DiOWIH/BVGirVPtO6ykrkuTj1FWiN
+hyZ3MBChShlNH2poNX46ntOc7nEus0qteOgxBK8lummFEtlehCA7hd/8xuvYlP0k
+7aN684LCRDajmAGpoZO57NSDYQhAFGZeUZ93SMFucQKBgQDe7GGkzZFEiv91u1q9
+lgMy1h5dZjIZKgQaOarPC6wCQMUdqCf6cSLsAPr4T8EDoWsnY7dSnrTZ6YCIFL1T
+idg8M3BQXipICCJkFORS76pKKZ0wMn3/NgkSepsmNct91WHr6okvx4tOaoRCtdzU
+g7jt4Mr3sfLCiZtqTQyySdMUEwKBgQDNK+ZFKL0XhkWZP+PGKjWG8LWpPiK3d78/
+wYBFXzSTGlkr6FvRmYtZeNwXWRYLB4UxZ9At4hbJVEdi/2dITOz/sehVDyCAjjs3
+gycsc3UJqiZbcw5XKhI5TWBuWxkKENdbMSayogVbp2aSYoRblH764//t0ACmbfTW
+KUQRQPB/uwKBgQC5QjjjfPL8w4cJkGoYpFKELO2PMR7xSrmeEc6hwlFwjeNCgjy3
+JM6g0y++rIj7O2qRkY0IXFxvvF3UuWedxTCu1xC/uYHp2ti506LsScB7YZoAM/YB
+4iYn9Tx6xLoYGP0H0iGwU2SyBlNkHT8oXU+SYP5MWtYkVbeS3/VtNWz1gQKBgQCA
+6Nk4kN0mH7YxEKRzSOfyzeDF4oV7kuB2FYUbkTL+TirC3K58JiYY5Egc31trOKFm
+Jlz1xz0b6DkmKWTiV3r9OPHKJ8P7IeJxAZWmZzCdDuwkv0i+WW+z0zsIe3JjEavN
+3zb6O7R0HtziksWoqMeTqZeO+wa9iw6vVKQw1wWEqwKBgFHfahFs0DZ5cUTpGpBt
+F/AQG7ukgipB6N6AkB9kDbgCs1FLgd199MQrEncug5hfpq8QerbyMatmA+GXoGMb
+7vztKEH85yzp4n02FNL6H7xL4VVILvyZHdolmiORJ4qT2hZnl8pEQ2TYuF4RlHUd
+nSwXX+2o0J/nF85fm4AwWKAc
 -----END PRIVATE KEY-----
diff --git a/testing/src/main/resources/certs/client.pem b/testing/src/main/resources/certs/client.pem
index 913649b97fb..8815875f327 100644
--- a/testing/src/main/resources/certs/client.pem
+++ b/testing/src/main/resources/certs/client.pem
@@ -1,18 +1,20 @@
 -----BEGIN CERTIFICATE-----
-MIIC6TCCAlKgAwIBAgIBCjANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJBVTET
-MBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0cyBQ
-dHkgTHRkMQ8wDQYDVQQDEwZ0ZXN0Y2EwHhcNMTUxMTEwMDEwOTU4WhcNMjUxMTA3
-MDEwOTU4WjBaMQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8G
-A1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMRMwEQYDVQQDDAp0ZXN0Y2xp
-ZW50MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDsVEfbob4W3lVCDLOVmx9K
-cdJnoZdvurGaTY87xNiopmaR8zCR7pFR9BX5L4bNG/PkuVLfVTVAKndyDCQggBBr
-UTaEITNbfWK9swHJEr20WnKfhS/wo/Xg5sqNNCrFRmnnnwOA4eDlvmYZEzSnJXV6
-pEro9bBH9uOCWWLqmaev7QIDAQABo4HCMIG/MAkGA1UdEwQCMAAwCwYDVR0PBAQD
-AgXgMB0GA1UdDgQWBBQAdbW5Vml/CnYwqdP3mOHDARU+8zBwBgNVHSMEaTBnoVqk
-WDBWMQswCQYDVQQGEwJBVTETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMY
-SW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMQ8wDQYDVQQDEwZ0ZXN0Y2GCCQCRxhke
-HRoqBzAJBgNVHREEAjAAMAkGA1UdEgQCMAAwDQYJKoZIhvcNAQELBQADgYEAf4MM
-k+sdzd720DfrQ0PF2gDauR3M9uBubozDuMuF6ufAuQBJSKGQEGibXbUelrwHmnql
-UjTyfolVcxEBVaF4VFHmn7u6vP7S1NexIDdNUHcULqxIb7Tzl8JYq8OOHD2rQy4H
-s8BXaVIzw4YcaCGAMS0iDX052Sy7e2JhP8Noxvo=
+MIIDNzCCAh8CFGyX00RCepOv/qCJ1oVdTtY92U83MA0GCSqGSIb3DQEBCwUAMFYx
+CzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRl
+cm5ldCBXaWRnaXRzIFB0eSBMdGQxDzANBgNVBAMMBnRlc3RjYTAeFw0yMDAzMTgw
+MTA2MTBaFw0zMDAzMTYwMTA2MTBaMFoxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApT
+b21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxEzAR
+BgNVBAMMCnRlc3RjbGllbnQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
+AQCyqYRp+DXVp72NFbQH8hdhTZLycZXOlJhmMsrJmrjn2p7pI/8mTZ/0FC+SGWBG
+ZV+ELiHrmCX5zfaILr9Iuw7Ghr3Vzoefi8r62rLupVPNi/qdqyjWk2dECHC9Z3+A
+g3KzKTyerXWjKcvyKVmM0ZxE0RXhDW/RoQbqZsU2GKg1B2rhUU8KN0gVmKn0rJHO
+xzRVSYeYLYp5Yn7KrtPJcKyo9aVuEr7dGANzpyF6lg/nYBWc+9SGwkoLdFvKvABY
+JMyrbNhHUQfv0fzaZ0P86dfTENrDxzALrzGnqcx3KTrwJjkZ/aSr1tyD0/tXvukR
+FiPxWBJhjHQ70GqTFQY19RbhAgMBAAEwDQYJKoZIhvcNAQELBQADggEBAFXCewK8
+cWT+zWxXyGFnouFSBzTi0BMBJRrhsiNoiQxkqityJHWFExiQZie+7CA+EabXCQUB
++JwMSWM29j3mSw10DTfmC3rhheQqGxy304BZyUpdpvI2dt3p/mcsE7O+p4sQrSep
+gijiDssKAfxTAmUM93N6+Q8yJK5immxlbeYfijoBvmkzyB/B+qNRPsx0n7aFGnfv
+oWfkW296iPhWLiwknpC3xB6oK3vRbK4Zj1OaGb0grK7VN8EyhBix2xVF61i4dzCK
+kMIpl7CUpw1Mb2z8q3F2bHBS7iF7g1Ccn5VGcO+aJ+6PWydaeqJ6VEBF0Nwv9woe
+mL5AluNRLaqjZvE=
 -----END CERTIFICATE-----
diff --git a/testing/src/main/resources/certs/client_spiffe.pem b/testing/src/main/resources/certs/client_spiffe.pem
new file mode 100644
index 00000000000..c70981a4030
--- /dev/null
+++ b/testing/src/main/resources/certs/client_spiffe.pem
@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIEMjCCAxqgAwIBAgIUVXGlXjNENtOZbI12epjgIhMaShUwDQYJKoZIhvcNAQEL
+BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTI0
+MTAyNDE2NDAzN1oXDTM0MTAyMjE2NDAzN1owaDELMAkGA1UEBhMCQVUxEzARBgNV
+BAgMClNvbWUtU3RhdGUxDDAKBgNVBAcMA1NWTDEhMB8GA1UECgwYSW50ZXJuZXQg
+V2lkZ2l0cyBQdHkgTHRkMRMwEQYDVQQDDAp0ZXN0Y2xpZW50MIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsqmEafg11ae9jRW0B/IXYU2S8nGVzpSYZjLK
+yZq459qe6SP/Jk2f9BQvkhlgRmVfhC4h65gl+c32iC6/SLsOxoa91c6Hn4vK+tqy
+7qVTzYv6naso1pNnRAhwvWd/gINysyk8nq11oynL8ilZjNGcRNEV4Q1v0aEG6mbF
+NhioNQdq4VFPCjdIFZip9KyRzsc0VUmHmC2KeWJ+yq7TyXCsqPWlbhK+3RgDc6ch
+epYP52AVnPvUhsJKC3RbyrwAWCTMq2zYR1EH79H82mdD/OnX0xDaw8cwC68xp6nM
+dyk68CY5Gf2kq9bcg9P7V77pERYj8VgSYYx0O9BqkxUGNfUW4QIDAQABo4HlMIHi
+MEQGA1UdEQQ9MDuGOXNwaWZmZTovL2Zvby5iYXIuY29tLzllZWJjY2QyLTEyYmYt
+NDBhNi1iMjYyLTY1ZmUwNDg3ZDQ1MzAdBgNVHQ4EFgQU28U8sUTGNEDyeCrvJDJd
+AALabSMwewYDVR0jBHQwcqFapFgwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNv
+bWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0G
+A1UEAwwGdGVzdGNhghRas/RW8dzL4s/pS5g22Iv2AGEPmjANBgkqhkiG9w0BAQsF
+AAOCAQEAE3LLE8GR283q/aE646SgAfltqpESP38NmYdJMdZgWRxbOqdWabYDfibt
+9r8j+IRvVuuTWuH2eNS5wXJtS1BZ+z24wTLa+a2KjOV12gChP+3N7jhqId4eolSL
+1fjscPY6luZP4Pm3D73lBvIoBvXpDGyrxleiUCEEkKXmTOA8doFvbrcbwm+yUJOP
+VKUKvAzTNztb0BGDzKKU4E2yK5PSyv2n5m2NpzxYYfHoGeVcxvj7nCnSfoX/EWHb
+d8ztJYDg9X0iNcfQXt7PZ+j6VcxfDpGCDxe2rFQoYvlWjhr3xOi/1e5A1zx1Ly07
+m9MB4hntu4e2656ZDWbgOHLpO0q1iQ==
+-----END CERTIFICATE-----
diff --git a/testing/src/main/resources/certs/ecdsa.key b/testing/src/main/resources/certs/ecdsa.key
new file mode 100644
index 00000000000..62b42fd038f
--- /dev/null
+++ b/testing/src/main/resources/certs/ecdsa.key
@@ -0,0 +1,5 @@
+-----BEGIN PRIVATE KEY-----
+MIGEAgEAMBAGByqGSM49AgEGBSuBBAAKBG0wawIBAQQgS0hDYghCuDnBobsToMW6
+vGqwulbAGUX8Oku4ysWMa4qhRANCAAThAMij1tkl4/7RQpZg3w7z1McGSS9q01+4
+3bDcF/Ge2gATx/SNYT5TqaSx7Rka/sJAGaX47ExWLca4gz9KGHih
+-----END PRIVATE KEY-----
diff --git a/testing/src/main/resources/certs/server0.key b/testing/src/main/resources/certs/server0.key
index add153c9aea..261097a87e3 100644
--- a/testing/src/main/resources/certs/server0.key
+++ b/testing/src/main/resources/certs/server0.key
@@ -1,16 +1,28 @@
 -----BEGIN PRIVATE KEY-----
-MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBANOmffupIGC8YDau
-rOF4eKnHwPszgpkkhWzKsVxhNDBxCVYx4TEjG0XWIO0iyRXupZbUC+7N/8HnEVNa
-8F1jYhng14Iiq99cNQbbnuHHhIztmpocrJTxmnhGzoAnRa1Tb+GnAuRoIHRA/V2c
-VUE9tbikQugFx/SPgXAw6tfWB+YvAgMBAAECgYEAoEq9qzUBgoHoVEGiSPiWWe8g
-5p6yUA1qx2QTQyWTAwT4z0DjjfVKmG99bFsl8+hTnJFnoCp/gnjflEOROwkjp5kG
-m0drqOPx1jeipJjpXYTBu49h+WpZ1PF+KhVtxsIm3OOCvh67iWaKyyOVb5Og8aiR
-jl6dn/TdG/dlGD8AfUECQQDuNMle6p0oU8amC6O9wIMBroxx2nFstzE6O35PLEzG
-/tj0kxxn9Jp2TS9mGaLCzSuXmpjlF4+NOWiBPkrLC2TfAkEA43Xg7uEUkaJAz2/W
-m1lIBTLt+4rIQY/2emh33bDcA+rv8rwwrMMIv17/xPx7bs49YqGG5xufD+Rwl6TL
-qFXYsQJAPrOwagax1aKvwJeBw3oAQhoTKAkLIEXcdGqipe6QSzVcIIz0xjxxyEAr
-AOIwoLxnBCISqwMXq2H4K0UdZPMb2wJAdhdYLY1L6YRMk6XjzImg25oidisKZweA
-FvMv8DgHMj2CUAqmVrt3SivfLH1M9C09L3zfFhOAFHcsgX58gav4MQJBANSBnrHj
-tIq4l8z79CPUIuu3QyeEh+XwY8s5qE5CNTck0U59lzp9NvENHbkx3KO896TTerko
-+8bXHMLkJkHPXms=
+MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCei9aKutDNg2mr
+COICW4hT6+LVJfI5J6DZ3yqb6MBzbc//VeUj1OCX/vt5vvPm1Qb5XNk1MOIFPEW6
+t2/0Mhj2VbQfjDe/PhZRhwu4PBtuoJBDeBsKkdnxD0I+4G0XRbeTtUsGMGBgWSAd
+qHMD2HnEhgydRw0krYjZp4a/HMCnZZ1WFamw1PCvQK6AuWSSk4iHGaYklXUaKd3r
+Rlkujr7//ihcvqweJ+OdaTwXD8z4P0YfFe/bkWWpuqIZz1Or/nxiNBtvWKlI8pR2
+K3wkoWsW+6bnFN8u81nstHDardR6zy3B7QXke02q4sddUERcwNFyPqpscetMpnhg
+lhjrmnAXAgMBAAECggEAA6pB5GUbLJUMHUsQRnOtPBto2/qLleynmEHDb2U7BbAV
+LdbjfCeQpZLcZ10VsFFeXudZkhQ2NV7GUeGpseBymUcz6cLJCx+5Tlsr1y90huMp
+UpX1MhJbEmqC4oc3nmEbNEvtlxAJOlD1IBpjxkP71KIwqnYZBK8KSdXIlKRqg7QZ
+VUgjA08TmWlZSxnOt1hpt2ZVjTOn7973YoTb4D7SZydMuVjTkwv9YjPFZOZ/wIP4
+JTZczY/bJjEF7QBYL/wtir/vNJlxxi+FunJdoO3blhf8li5QU0iPd/YsyBFBBWfF
+vD7QslaB7wQ8zyWxWpPLiWeD83XGE+7CY2+8EpG3AQKBgQDMK6N7jDQCq9F7n+5B
+R8YPDMdINpcVsN8bIeEVKSxYE86oADQg/0jPUct+4liUS1dv0DUmUP1U0zbvupX7
+NxE+gI8KFwCyq8nqZ1guW9oO00ZAGo4Rn0TIeoHWVgsE2tDqBFeC2wWYle1AaZLx
+ZtFH6Ya4Q3a4xvjkXXabhbBDlwKBgQDGyzuNCGT1Xa1DXKLzyKspahdm9r7QXifo
+jjZkcmzwItC535MBbQMq5+THD+WUbWrZ/rJ8KaSsoGmnjaWguSG0WLFpH3UiGn1W
+FOSG2UGc0mWyz2p/j97EuhK12fabzn8rkuiohiFXjJDYrAIulcM++0ar3q2LyqXr
+gleBEHLHgQKBgEAt44j9rIe+bO44etOIdUjb0nTvvBR0cd18i910AN169HY5Ainx
+NXj+FELBcejDuiuKvnpZ8RhOALHg7C54w/HqxYv9aRnBCIqni7+e3e/VF/sknc4K
+S7vdTp0KlRIkmpFFZiDbKmopjte1mBxMHrNFRDT99/7jhO98NcFzh9HnAoGAMf62
+sVdlHJg8lO5dRPY4pae6zvhLMNgdLU1mvIhSgWogGD70F6202DuNu8pxsIx8DOsT
+NEq80XVeXPcwqmUk5thPdeKlcLg8wUNr3cYRzEDVtsyXOhGSsuMhBX8VmEWskebW
+gFuLUxtU6kkIG3MqsVI8icjs2HVUmRAktZ7PXwECgYA9V/zZe2DpP36gp63wRk6S
+FI7bDbLPQCKah23mwp3WeP5T+/HmFFRrl0OCaDLwudTolqgPa47CV7JYa9LmJAPj
+QBxcnL4CxjlaaS3V9kxVWOXabMEtwSUurELJwFKTEC/AFN9dR/nv4AzXInZznotG
+7qDX8EhfjbFVJw4riAmlEw==
 -----END PRIVATE KEY-----
diff --git a/testing/src/main/resources/certs/server0.pem b/testing/src/main/resources/certs/server0.pem
index 94589541a00..ab20787fa5b 100644
--- a/testing/src/main/resources/certs/server0.pem
+++ b/testing/src/main/resources/certs/server0.pem
@@ -1,18 +1,20 @@
 -----BEGIN CERTIFICATE-----
-MIIC8zCCAlygAwIBAgIBCzANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJBVTET
-MBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0cyBQ
-dHkgTHRkMQ8wDQYDVQQDEwZ0ZXN0Y2EwHhcNMTUxMTEwMDExNDU1WhcNMjUxMTA3
-MDExNDU1WjBkMQswCQYDVQQGEwJBVTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8G
-A1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMR0wGwYDVQQDDBQqLnRlc3Qu
-Z29vZ2xlLmNvbS5hdTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA06Z9+6kg
-YLxgNq6s4Xh4qcfA+zOCmSSFbMqxXGE0MHEJVjHhMSMbRdYg7SLJFe6lltQL7s3/
-wecRU1rwXWNiGeDXgiKr31w1Btue4ceEjO2amhyslPGaeEbOgCdFrVNv4acC5Ggg
-dED9XZxVQT21uKRC6AXH9I+BcDDq19YH5i8CAwEAAaOBwjCBvzAJBgNVHRMEAjAA
-MAsGA1UdDwQEAwIF4DAdBgNVHQ4EFgQUbyZIbUvqmePzv40xa0mMaDxLToYwcAYD
-VR0jBGkwZ6FapFgwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgTClNvbWUtU3RhdGUx
-ITAfBgNVBAoTGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAxMGdGVz
-dGNhggkAkcYZHh0aKgcwCQYDVR0RBAIwADAJBgNVHRIEAjAAMA0GCSqGSIb3DQEB
-CwUAA4GBAJ21MwMf4WwAjafPKn+8Ng7ordtdp6tlkjt+Xub4l4zMr6FCp6dc/Ceh
-6Hj43zYcKpAe5I6eaVcMc9qcYfUb9i4NVX82dMQpAwpNHgqTzqYt6GYEjF3YhKA7
-uOFdA0OvOFJa14SNdNRk9E1Cd/tElXnLnSE4DOguMNvXz8mRKfnD
+MIIDQTCCAikCFGyX00RCepOv/qCJ1oVdTtY92U84MA0GCSqGSIb3DQEBCwUAMFYx
+CzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRl
+cm5ldCBXaWRnaXRzIFB0eSBMdGQxDzANBgNVBAMMBnRlc3RjYTAeFw0yMDAzMTgw
+MTA3MzhaFw0zMDAzMTYwMTA3MzhaMGQxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApT
+b21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxHTAb
+BgNVBAMMFCoudGVzdC5nb29nbGUuY29tLmF1MIIBIjANBgkqhkiG9w0BAQEFAAOC
+AQ8AMIIBCgKCAQEAnovWirrQzYNpqwjiAluIU+vi1SXyOSeg2d8qm+jAc23P/1Xl
+I9Tgl/77eb7z5tUG+VzZNTDiBTxFurdv9DIY9lW0H4w3vz4WUYcLuDwbbqCQQ3gb
+CpHZ8Q9CPuBtF0W3k7VLBjBgYFkgHahzA9h5xIYMnUcNJK2I2aeGvxzAp2WdVhWp
+sNTwr0CugLlkkpOIhxmmJJV1Gind60ZZLo6+//4oXL6sHifjnWk8Fw/M+D9GHxXv
+25FlqbqiGc9Tq/58YjQbb1ipSPKUdit8JKFrFvum5xTfLvNZ7LRw2q3Ues8twe0F
+5HtNquLHXVBEXMDRcj6qbHHrTKZ4YJYY65pwFwIDAQABMA0GCSqGSIb3DQEBCwUA
+A4IBAQCCGvZpM+t83xWPCsz5FyuCqA6LI+j0NMMmKpe1wJ8JcK2o9Qw4d0wPxWdy
+0O7Ti2YlJS3gups00zsaFhQymIKUBi5Gc+1VC7qHUUrVtkoIRe6QSpcVlxPVczlD
+If1egkjBCUZKVSWqYRKB6AMqjpp7/dF06j6zAaAH54jaLv9VmiBtsFyd017AsC9W
++OG2ke2dNtXySfVX4VusCcji86qb5sr6hNIQWMXk6dZoLDsZvwvVi7KnrqQOza8J
+klcJXV8Hsnq/faHr/ZmsIA65N0+H8KuYfbO+s5nKPG9th6ZZAu4aY2VDei++TH+H
+EAQhivPNUC1DgCmx0P7vKLhgka7S
 -----END CERTIFICATE-----
diff --git a/testing/src/main/resources/certs/server1.key b/testing/src/main/resources/certs/server1.key
index 143a5b87658..086462992cf 100644
--- a/testing/src/main/resources/certs/server1.key
+++ b/testing/src/main/resources/certs/server1.key
@@ -1,16 +1,28 @@
 -----BEGIN PRIVATE KEY-----
-MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAOHDFScoLCVJpYDD
-M4HYtIdV6Ake/sMNaaKdODjDMsux/4tDydlumN+fm+AjPEK5GHhGn1BgzkWF+slf
-3BxhrA/8dNsnunstVA7ZBgA/5qQxMfGAq4wHNVX77fBZOgp9VlSMVfyd9N8YwbBY
-AckOeUQadTi2X1S6OgJXgQ0m3MWhAgMBAAECgYAn7qGnM2vbjJNBm0VZCkOkTIWm
-V10okw7EPJrdL2mkre9NasghNXbE1y5zDshx5Nt3KsazKOxTT8d0Jwh/3KbaN+YY
-tTCbKGW0pXDRBhwUHRcuRzScjli8Rih5UOCiZkhefUTcRb6xIhZJuQy71tjaSy0p
-dHZRmYyBYO2YEQ8xoQJBAPrJPhMBkzmEYFtyIEqAxQ/o/A6E+E4w8i+KM7nQCK7q
-K4JXzyXVAjLfyBZWHGM2uro/fjqPggGD6QH1qXCkI4MCQQDmdKeb2TrKRh5BY1LR
-81aJGKcJ2XbcDu6wMZK4oqWbTX2KiYn9GB0woM6nSr/Y6iy1u145YzYxEV/iMwff
-DJULAkB8B2MnyzOg0pNFJqBJuH29bKCcHa8gHJzqXhNO5lAlEbMK95p/P2Wi+4Hd
-aiEIAF1BF326QJcvYKmwSmrORp85AkAlSNxRJ50OWrfMZnBgzVjDx3xG6KsFQVk2
-ol6VhqL6dFgKUORFUWBvnKSyhjJxurlPEahV6oo6+A+mPhFY8eUvAkAZQyTdupP3
-XEFQKctGz+9+gKkemDp7LBBMEMBXrGTLPhpEfcjv/7KPdnFHYmhYeBTBnuVmTVWe
-F98XJ7tIFfJq
+MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDnE443EknxvxBq
+6+hvn/t09hl8hx366EBYvZmVM/NC+7igXRAjiJiA/mIaCvL3MS0Iz5hBLxSGICU+
+WproA3GCIFITIwcf/ETyWj/5xpgZ4AKrLrjQmmX8mhwUajfF3UvwMJrCOVqPp67t
+PtP+2kBXaqrXdvnvXR41FsIB8V7zIAuIZB6bHQhiGVlc1sgZYsE2EGG9WMmHtS86
+qkAOTjG2XyjmPTGAwhGDpYkYrpzp99IiDh4/Veai81hn0ssQkbry0XRD/Ig3jcHh
+23WiriPNJ0JsbgXUSLKRPZObA9VgOLy2aXoN84IMaeK3yy+cwSYG/99w93fUZJte
+MXwz4oYZAgMBAAECggEBAIVn2Ncai+4xbH0OLWckabwgyJ4IM9rDc0LIU368O1kU
+koais8qP9dujAWgfoh3sGh/YGgKn96VnsZjKHlyMgF+r4TaDJn3k2rlAOWcurGlj
+1qaVlsV4HiEzp7pxiDmHhWvp4672Bb6iBG+bsjCUOEk/n9o9KhZzIBluRhtxCmw5
+nw4Do7z00PTvN81260uPWSc04IrytvZUiAIx/5qxD72bij2xJ8t/I9GI8g4FtoVB
+8pB6S/hJX1PZhh9VlU6Yk+TOfOVnbebG4W5138LkB835eqk3Zz0qsbc2euoi8Hxi
+y1VGwQEmMQ63jXz4c6g+X55ifvUK9Jpn5E8pq+pMd7ECgYEA93lYq+Cr54K4ey5t
+sWMa+ye5RqxjzgXj2Kqr55jb54VWG7wp2iGbg8FMlkQwzTJwebzDyCSatguEZLuB
+gRGroRnsUOy9vBvhKPOch9bfKIl6qOgzMJB267fBVWx5ybnRbWN/I7RvMQf3k+9y
+biCIVnxDLEEYyx7z85/5qxsXg/MCgYEA7wmWKtCTn032Hy9P8OL49T0X6Z8FlkDC
+Rk42ygrc/MUbugq9RGUxcCxoImOG9JXUpEtUe31YDm2j+/nbvrjl6/bP2qWs0V7l
+dTJl6dABP51pCw8+l4cWgBBX08Lkeen812AAFNrjmDCjX6rHjWHLJcpS18fnRRkP
+V1d/AHWX7MMCgYEA6Gsw2guhp0Zf2GCcaNK5DlQab8OL4Hwrpttzo4kuTlwtqNKp
+Q9H4al9qfF4Cr1TFya98+EVYf8yFRM3NLNjZpe3gwYf2EerlJj7VLcahw0KKzoN1
+QBENfwgPLRk5sDkx9VhSmcfl/diLroZdpAwtv3vo4nEoxeuGFbKTGx3Qkf0CgYEA
+xyR+dcb05Ygm3w4klHQTowQ10s1H80iaUcZBgQuR1ghEtDbUPZHsoR5t1xCB02ys
+DgAwLv1bChIvxvH/L6KM8ovZ2LekBX4AviWxoBxJnfz/EVau98B0b1auRN6eSC83
+FRuGldlSOW1z/nSh8ViizSYE5H5HX1qkXEippvFRE88CgYB3Bfu3YQY60ITWIShv
+nNkdcbTT9eoP9suaRJjw92Ln+7ZpALYlQMKUZmJ/5uBmLs4RFwUTQruLOPL4yLTH
+awADWUzs3IRr1fwn9E+zM8JVyKCnUEM3w4N5UZskGO2klashAd30hWO+knRv/y0r
+uGIYs9Ek7YXlXIRVrzMwcsrt1w==
 -----END PRIVATE KEY-----
diff --git a/testing/src/main/resources/certs/server1.pem b/testing/src/main/resources/certs/server1.pem
index f3d43fcc5be..88244f856c6 100644
--- a/testing/src/main/resources/certs/server1.pem
+++ b/testing/src/main/resources/certs/server1.pem
@@ -1,16 +1,22 @@
 -----BEGIN CERTIFICATE-----
-MIICnDCCAgWgAwIBAgIBBzANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJBVTET
-MBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0cyBQ
-dHkgTHRkMQ8wDQYDVQQDEwZ0ZXN0Y2EwHhcNMTUxMTA0MDIyMDI0WhcNMjUxMTAx
-MDIyMDI0WjBlMQswCQYDVQQGEwJVUzERMA8GA1UECBMISWxsaW5vaXMxEDAOBgNV
-BAcTB0NoaWNhZ28xFTATBgNVBAoTDEV4YW1wbGUsIENvLjEaMBgGA1UEAxQRKi50
-ZXN0Lmdvb2dsZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAOHDFSco
-LCVJpYDDM4HYtIdV6Ake/sMNaaKdODjDMsux/4tDydlumN+fm+AjPEK5GHhGn1Bg
-zkWF+slf3BxhrA/8dNsnunstVA7ZBgA/5qQxMfGAq4wHNVX77fBZOgp9VlSMVfyd
-9N8YwbBYAckOeUQadTi2X1S6OgJXgQ0m3MWhAgMBAAGjazBpMAkGA1UdEwQCMAAw
-CwYDVR0PBAQDAgXgME8GA1UdEQRIMEaCECoudGVzdC5nb29nbGUuZnKCGHdhdGVy
-em9vaS50ZXN0Lmdvb2dsZS5iZYISKi50ZXN0LnlvdXR1YmUuY29thwTAqAEDMA0G
-CSqGSIb3DQEBCwUAA4GBAJFXVifQNub1LUP4JlnX5lXNlo8FxZ2a12AFQs+bzoJ6
-hM044EDjqyxUqSbVePK0ni3w1fHQB5rY9yYC5f8G7aqqTY1QOhoUk8ZTSTRpnkTh
-y4jjdvTZeLDVBlueZUTDRmy2feY5aZIU18vFDK08dTG0A87pppuv1LNIR3loveU8
+MIIDtDCCApygAwIBAgIUbJfTREJ6k6/+oInWhV1O1j3ZT0IwDQYJKoZIhvcNAQEL
+BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTIw
+MDMxODAzMTA0MloXDTMwMDMxNjAzMTA0MlowZTELMAkGA1UEBhMCVVMxETAPBgNV
+BAgMCElsbGlub2lzMRAwDgYDVQQHDAdDaGljYWdvMRUwEwYDVQQKDAxFeGFtcGxl
+LCBDby4xGjAYBgNVBAMMESoudGVzdC5nb29nbGUuY29tMIIBIjANBgkqhkiG9w0B
+AQEFAAOCAQ8AMIIBCgKCAQEA5xOONxJJ8b8Qauvob5/7dPYZfIcd+uhAWL2ZlTPz
+Qvu4oF0QI4iYgP5iGgry9zEtCM+YQS8UhiAlPlqa6ANxgiBSEyMHH/xE8lo/+caY
+GeACqy640Jpl/JocFGo3xd1L8DCawjlaj6eu7T7T/tpAV2qq13b5710eNRbCAfFe
+8yALiGQemx0IYhlZXNbIGWLBNhBhvVjJh7UvOqpADk4xtl8o5j0xgMIRg6WJGK6c
+6ffSIg4eP1XmovNYZ9LLEJG68tF0Q/yIN43B4dt1oq4jzSdCbG4F1EiykT2TmwPV
+YDi8tml6DfOCDGnit8svnMEmBv/fcPd31GSbXjF8M+KGGQIDAQABo2swaTAJBgNV
+HRMEAjAAMAsGA1UdDwQEAwIF4DBPBgNVHREESDBGghAqLnRlc3QuZ29vZ2xlLmZy
+ghh3YXRlcnpvb2kudGVzdC5nb29nbGUuYmWCEioudGVzdC55b3V0dWJlLmNvbYcE
+wKgBAzANBgkqhkiG9w0BAQsFAAOCAQEAS8hDQA8PSgipgAml7Q3/djwQ644ghWQv
+C2Kb+r30RCY1EyKNhnQnIIh/OUbBZvh0M0iYsy6xqXgfDhCB93AA6j0i5cS8fkhH
+Jl4RK0tSkGQ3YNY4NzXwQP/vmUgfkw8VBAZ4Y4GKxppdATjffIW+srbAmdDruIRM
+wPeikgOoRrXf0LA1fi4TqxARzeRwenQpayNfGHTvVF9aJkl8HoaMunTAdG5pIVcr
+9GKi/gEMpXUJbbVv3U5frX1Wo4CFo+rZWJ/LyCMeb0jciNLxSdMwj/E/ZuExlyeZ
+gc9ctPjSMvgSyXEKv6Vwobleeg88V2ZgzenziORoWj4KszG/lbQZvg==
 -----END CERTIFICATE-----
diff --git a/testing/src/main/resources/certs/server1_spiffe.pem b/testing/src/main/resources/certs/server1_spiffe.pem
new file mode 100644
index 00000000000..76cb41d6922
--- /dev/null
+++ b/testing/src/main/resources/certs/server1_spiffe.pem
@@ -0,0 +1,26 @@
+-----BEGIN CERTIFICATE-----
+MIIEZDCCA0ygAwIBAgIUVXGlXjNENtOZbI12epjgIhMaShMwDQYJKoZIhvcNAQEL
+BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTI0
+MTAyMTAyMTQxNVoXDTM0MTAxOTAyMTQxNVowZTELMAkGA1UEBhMCVVMxETAPBgNV
+BAgMCElsbGlub2lzMRAwDgYDVQQHDAdDaGljYWdvMRUwEwYDVQQKDAxFeGFtcGxl
+LCBDby4xGjAYBgNVBAMMESoudGVzdC5nb29nbGUuY29tMIIBIjANBgkqhkiG9w0B
+AQEFAAOCAQ8AMIIBCgKCAQEA5xOONxJJ8b8Qauvob5/7dPYZfIcd+uhAWL2ZlTPz
+Qvu4oF0QI4iYgP5iGgry9zEtCM+YQS8UhiAlPlqa6ANxgiBSEyMHH/xE8lo/+caY
+GeACqy640Jpl/JocFGo3xd1L8DCawjlaj6eu7T7T/tpAV2qq13b5710eNRbCAfFe
+8yALiGQemx0IYhlZXNbIGWLBNhBhvVjJh7UvOqpADk4xtl8o5j0xgMIRg6WJGK6c
+6ffSIg4eP1XmovNYZ9LLEJG68tF0Q/yIN43B4dt1oq4jzSdCbG4F1EiykT2TmwPV
+YDi8tml6DfOCDGnit8svnMEmBv/fcPd31GSbXjF8M+KGGQIDAQABo4IBGTCCARUw
+dwYDVR0RBHAwboIQKi50ZXN0Lmdvb2dsZS5mcoIYd2F0ZXJ6b29pLnRlc3QuZ29v
+Z2xlLmJlghIqLnRlc3QueW91dHViZS5jb22HBMCoAQOGJnNwaWZmZTovL2V4YW1w
+bGUuY29tL3dvcmtsb2FkLzllZWJjY2QyMB0GA1UdDgQWBBRvRpAYHQYP6dFPf5V7
+/MyCftnNjTB7BgNVHSMEdDByoVqkWDBWMQswCQYDVQQGEwJBVTETMBEGA1UECAwK
+U29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMQ8w
+DQYDVQQDDAZ0ZXN0Y2GCFFqz9Fbx3Mviz+lLmDbYi/YAYQ+aMA0GCSqGSIb3DQEB
+CwUAA4IBAQBJ1bnbBHa1n15vvhpGIzokuiJ+9q/zim63UuVDnkhrQM2N+RQbStGT
+Tis2tNse1bh460dJFm6ArgHWogzx6fQZzgaDeCOAXvrAe4jM9IHr9K7lkq/33CZS
+BDV+jCmm2sRsqSMkKUcX6JhyqWGFHuTDAKJzsEV2MlcswleKlGHDkeelAaxlLzpz
+RHOSQd0N9xAs18lzx95SQEx90PtrBOmvIDDiI5o5z9Oz12Iy1toiksFl4jmknkDD
+5VF3AyCRgN8NPW0uNC8D2vo4L+tgj9U6NPlmMOrjRsEH257LJ1wopAGr+yezkIId
+QQodGSVm5cOuw/K7Ma4nBDjVJkjcdY3t
+-----END CERTIFICATE-----
diff --git a/testing/src/main/resources/certs/spiffe-openssl.cnf b/testing/src/main/resources/certs/spiffe-openssl.cnf
new file mode 100644
index 00000000000..f03af40a782
--- /dev/null
+++ b/testing/src/main/resources/certs/spiffe-openssl.cnf
@@ -0,0 +1,28 @@
+[spiffe_client]
+subjectAltName = @alt_names
+
+[spiffe_client_multi]
+subjectAltName = @alt_names_multi
+
+[spiffe_server_e2e]
+subjectAltName = @alt_names_server_e2e
+
+[spiffe_client_e2e]
+subjectAltName = @alt_names_client_e2e
+
+[alt_names]
+URI = spiffe://foo.bar.com/client/workload/1
+
+[alt_names_multi]
+URI.1 = spiffe://foo.bar.com/client/workload/1
+URI.2 = spiffe://foo.bar.com/client/workload/2
+
+[alt_names_server_e2e]
+DNS.1 = *.test.google.fr
+DNS.2 = waterzooi.test.google.be
+DNS.3 = *.test.youtube.com
+IP.1 = "192.168.1.3"
+URI = spiffe://example.com/workload/9eebccd2
+
+[alt_names_client_e2e]
+URI = spiffe://foo.bar.com/9eebccd2-12bf-40a6-b262-65fe0487d453
\ No newline at end of file
diff --git a/testing/src/main/resources/certs/spiffe_cert.pem b/testing/src/main/resources/certs/spiffe_cert.pem
new file mode 100644
index 00000000000..bc070042f69
--- /dev/null
+++ b/testing/src/main/resources/certs/spiffe_cert.pem
@@ -0,0 +1,33 @@
+-----BEGIN CERTIFICATE-----
+MIIFsjCCA5qgAwIBAgIURygVMMzdr+Q7rsUaz189JozyHMwwDQYJKoZIhvcNAQEL
+BQAwTjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQwwCgYDVQQHDANTVkwxDTAL
+BgNVBAoMBGdSUEMxFTATBgNVBAMMDHRlc3QtY2xpZW50MTAeFw0yMTEyMjMxODQy
+NTJaFw0zMTEyMjExODQyNTJaME4xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEM
+MAoGA1UEBwwDU1ZMMQ0wCwYDVQQKDARnUlBDMRUwEwYDVQQDDAx0ZXN0LWNsaWVu
+dDEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ4AqpGetyVSqGUuBJ
+LVFla+7bEfca7UYzfVSSZLZ/X+JDmWIVN8UIPuFib5jhMEc3XaUnFXUmM7zEtz/Z
+G5hapwLwOb2C3ZxOP6PQjYCJxbkLie+b43UQrFu1xxd3vMhVJgcj/AIxEpmszuqO
+a6kUrkYifjJADQ+64kZgl66bsTdXMCzpxyFl9xUfff59L8OX+HUfAcoZz3emjg3Z
+JPYURQEmjdZTOau1EjFilwHgd989Jt7NKgx30NXoHmw7nusVBIY94fL2VKN3f1XV
+m0dHu5NI279Q6zr0ZBU7k5T3IeHnzsUesQS4NGlklDWoVTKk73Uv9Pna8yQsSW75
+7PEbHOGp9Knu4bnoGPOlsG81yIPipO6hTgGFK24pF97M9kpGbWqYX4+2vLlrCAfc
+msHqaUPmQlYeRVTT6vw7ctYo2kyUYGtnODXk76LqewRBVvkzx75QUhfjAyb740Yc
+DmIenc56Tq6gebJHjhEmVSehR6xIpXP7SVeurTyhPsEQnpJHtgs4dcwWOZp7BvPN
+zHXmJqfr7vsshie3vS5kQ0u1e1yqAqXgyDjqKXOkx+dpgUTehSJHhPNHvTc5LXRs
+vvXKYz6FrwR/DZ8t7BNEvPeLjFgxpH7QVJFLCvCbXs5K6yYbsnLfxFIBPRnrbJkI
+sK+sQwnRdnsiUdPsTkG5B2lQfQIDAQABo4GHMIGEMB0GA1UdDgQWBBQ2lBp0PiRH
+HvQ5IRURm8aHsj4RETAfBgNVHSMEGDAWgBQ2lBp0PiRHHvQ5IRURm8aHsj4RETAP
+BgNVHRMBAf8EBTADAQH/MDEGA1UdEQQqMCiGJnNwaWZmZTovL2Zvby5iYXIuY29t
+L2NsaWVudC93b3JrbG9hZC8xMA0GCSqGSIb3DQEBCwUAA4ICAQA1mSkgRclAl+E/
+aS9zJ7t8+Y4n3T24nOKKveSIjxXm/zjhWqVsLYBI6kglWtih2+PELvU8JdPqNZK3
+4Kl0Q6FWpVSGDdWN1i6NyORt2ocggL3ke3iXxRk3UpUKJmqwz81VhA2KUHnMlyE0
+IufFfZNwNWWHBv13uJfRbjeQpKPhU+yf4DeXrsWcvrZlGvAET+mcplafUzCp7Iv+
+PcISJtUerbxbVtuHVeZCLlgDXWkLAWJN8rf0dIG4x060LJ+j6j9uRVhb9sZn1HJV
++j4XdIYm1VKilluhOtNwP2d3Ox/JuTBxf7hFHXZPfMagQE5k5PzmxRaCAEMJ1l2D
+vUbZw+shJfSNoWcBo2qadnUaWT3BmmJRBDh7ZReib/RQ1Rd4ygOyzP3E0vkV4/gq
+yjLdApXh5PZP8KLQZ+1JN/sdWt7VfIt9wYOpkIqujdll51ESHzwQeAK9WVCB4UvV
+z6zdhItB9CRbXPreWC+wCB1xDovIzFKOVsLs5+Gqs1m7VinG2LxbDqaKyo/FB0Hx
+x0acBNzezLWoDwXYQrN0T0S4pnqhKD1CYPpdArBkNezUYAjS725FkApuK+mnBX3U
+0msBffEaUEOkcyar1EW2m/33vpetD/k3eQQkmvQf4Hbiu9AF+9cNDm/hMuXEw5EX
+GA91fn0891b5eEW8BJHXX0jri0aN8g==
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/testing/src/main/resources/certs/spiffe_multi_uri_san_cert.pem b/testing/src/main/resources/certs/spiffe_multi_uri_san_cert.pem
new file mode 100644
index 00000000000..eb5c879abf8
--- /dev/null
+++ b/testing/src/main/resources/certs/spiffe_multi_uri_san_cert.pem
@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIELTCCAxWgAwIBAgIUVXGlXjNENtOZbI12epjgIhMaShEwDQYJKoZIhvcNAQEL
+BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTI0
+MDkxNzE2MTk0NFoXDTM0MDkxNTE2MTk0NFowTjELMAkGA1UEBhMCVVMxCzAJBgNV
+BAgMAkNBMQwwCgYDVQQHDANTVkwxDTALBgNVBAoMBGdSUEMxFTATBgNVBAMMDHRl
+c3QtY2xpZW50MTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOcTjjcS
+SfG/EGrr6G+f+3T2GXyHHfroQFi9mZUz80L7uKBdECOImID+YhoK8vcxLQjPmEEv
+FIYgJT5amugDcYIgUhMjBx/8RPJaP/nGmBngAqsuuNCaZfyaHBRqN8XdS/AwmsI5
+Wo+nru0+0/7aQFdqqtd2+e9dHjUWwgHxXvMgC4hkHpsdCGIZWVzWyBliwTYQYb1Y
+yYe1LzqqQA5OMbZfKOY9MYDCEYOliRiunOn30iIOHj9V5qLzWGfSyxCRuvLRdEP8
+iDeNweHbdaKuI80nQmxuBdRIspE9k5sD1WA4vLZpeg3zggxp4rfLL5zBJgb/33D3
+d9Rkm14xfDPihhkCAwEAAaOB+jCB9zBZBgNVHREEUjBQhiZzcGlmZmU6Ly9mb28u
+YmFyLmNvbS9jbGllbnQvd29ya2xvYWQvMYYmc3BpZmZlOi8vZm9vLmJhci5jb20v
+Y2xpZW50L3dvcmtsb2FkLzIwHQYDVR0OBBYEFG9GkBgdBg/p0U9/lXv8zIJ+2c2N
+MHsGA1UdIwR0MHKhWqRYMFYxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0
+YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxDzANBgNVBAMM
+BnRlc3RjYYIUWrP0VvHcy+LP6UuYNtiL9gBhD5owDQYJKoZIhvcNAQELBQADggEB
+AJ4Cbxv+02SpUgkEu4hP/1+8DtSBXUxNxI0VG4e3Ap2+Rhjm3YiFeS/UeaZhNrrw
+UEjkSTPFODyXR7wI7UO9OO1StyD6CMkp3SEvevU5JsZtGL6mTiTLTi3Qkywa91Bt
+GlyZdVMghA1bBJLBMwiD5VT5noqoJBD7hDy6v9yNmt1Sw2iYBJPqI3Gnf5bMjR3s
+UICaxmFyqaMCZsPkfJh0DmZpInGJys3m4QqGz6ZE2DWgcSr1r/ML7/5bSPjjr8j4
+WFFSqFR3dMu8CbGnfZTCTXa4GTX/rARXbAO67Z/oJbJBK7VKayskL+PzKuohb9ox
+jGL772hQMbwtFCOFXu5VP0s=
+-----END CERTIFICATE-----
\ No newline at end of file
diff --git a/testing/src/main/resources/certs/spiffebundle.json b/testing/src/main/resources/certs/spiffebundle.json
new file mode 100644
index 00000000000..5bc8fcfb432
--- /dev/null
+++ b/testing/src/main/resources/certs/spiffebundle.json
@@ -0,0 +1,101 @@
+{
+  "trust_domains": {
+    "example.com": {
+      "spiffe_sequence": 12035488,
+      "keys": [
+        {
+          "kty": "RSA",
+          "use": "x509-svid",
+          "x5c": ["MIIDWjCCAkKgAwIBAgIUWrP0VvHcy+LP6UuYNtiL9gBhD5owDQYJKoZIhvcNAQEL
+          BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+          GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTIw
+          MDMxNzE4NTk1MVoXDTMwMDMxNTE4NTk1MVowVjELMAkGA1UEBhMCQVUxEzARBgNV
+          BAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0
+          ZDEPMA0GA1UEAwwGdGVzdGNhMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+          AQEAsGL0oXflF0LzoM+Bh+qUU9yhqzw2w8OOX5mu/iNCyUOBrqaHi7mGHx73GD01
+          diNzCzvlcQqdNIH6NQSL7DTpBjca66jYT9u73vZe2MDrr1nVbuLvfu9850cdxiUO
+          Inv5xf8+sTHG0C+a+VAvMhsLiRjsq+lXKRJyk5zkbbsETybqpxoJ+K7CoSy3yc/k
+          QIY3TipwEtwkKP4hzyo6KiGd/DPexie4nBUInN3bS1BUeNZ5zeaIC2eg3bkeeW7c
+          qT55b+Yen6CxY0TEkzBK6AKt/WUialKMgT0wbTxRZO7kUCH3Sq6e/wXeFdJ+HvdV
+          LPlAg5TnMaNpRdQih/8nRFpsdwIDAQABoyAwHjAMBgNVHRMEBTADAQH/MA4GA1Ud
+          DwEB/wQEAwICBDANBgkqhkiG9w0BAQsFAAOCAQEAkTrKZjBrJXHps/HrjNCFPb5a
+          THuGPCSsepe1wkKdSp1h4HGRpLoCgcLysCJ5hZhRpHkRihhef+rFHEe60UePQO3S
+          CVTtdJB4CYWpcNyXOdqefrbJW5QNljxgi6Fhvs7JJkBqdXIkWXtFk2eRgOIP2Eo9
+          /OHQHlYnwZFrk6sp4wPyR+A95S0toZBcyDVz7u+hOW0pGK3wviOe9lvRgj/H3Pwt
+          bewb0l+MhRig0/DVHamyVxrDRbqInU1/GTNCwcZkXKYFWSf92U+kIcTth24Q1gcw
+          eZiLl5FfrWokUNytFElXob0V0a5/kbhiLc3yWmvWqHTpqCALbVyF+rKJo2f5Kw=="],
+          "n": "<base64urlUint-encoded value>",
+          "e": "AQAB"
+        }
+      ]
+    },
+    "test.example.com": {
+      "keys": [
+        {
+          "kty": "RSA",
+          "use": "x509-svid",
+          "x5c": ["MIIFsjCCA5qgAwIBAgIURygVMMzdr+Q7rsUaz189JozyHMwwDQYJKoZIhvcNAQEL
+          BQAwTjELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNBMQwwCgYDVQQHDANTVkwxDTAL
+          BgNVBAoMBGdSUEMxFTATBgNVBAMMDHRlc3QtY2xpZW50MTAeFw0yMTEyMjMxODQy
+          NTJaFw0zMTEyMjExODQyNTJaME4xCzAJBgNVBAYTAlVTMQswCQYDVQQIDAJDQTEM
+          MAoGA1UEBwwDU1ZMMQ0wCwYDVQQKDARnUlBDMRUwEwYDVQQDDAx0ZXN0LWNsaWVu
+          dDEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ4AqpGetyVSqGUuBJ
+          LVFla+7bEfca7UYzfVSSZLZ/X+JDmWIVN8UIPuFib5jhMEc3XaUnFXUmM7zEtz/Z
+          G5hapwLwOb2C3ZxOP6PQjYCJxbkLie+b43UQrFu1xxd3vMhVJgcj/AIxEpmszuqO
+          a6kUrkYifjJADQ+64kZgl66bsTdXMCzpxyFl9xUfff59L8OX+HUfAcoZz3emjg3Z
+          JPYURQEmjdZTOau1EjFilwHgd989Jt7NKgx30NXoHmw7nusVBIY94fL2VKN3f1XV
+          m0dHu5NI279Q6zr0ZBU7k5T3IeHnzsUesQS4NGlklDWoVTKk73Uv9Pna8yQsSW75
+          7PEbHOGp9Knu4bnoGPOlsG81yIPipO6hTgGFK24pF97M9kpGbWqYX4+2vLlrCAfc
+          msHqaUPmQlYeRVTT6vw7ctYo2kyUYGtnODXk76LqewRBVvkzx75QUhfjAyb740Yc
+          DmIenc56Tq6gebJHjhEmVSehR6xIpXP7SVeurTyhPsEQnpJHtgs4dcwWOZp7BvPN
+          zHXmJqfr7vsshie3vS5kQ0u1e1yqAqXgyDjqKXOkx+dpgUTehSJHhPNHvTc5LXRs
+          vvXKYz6FrwR/DZ8t7BNEvPeLjFgxpH7QVJFLCvCbXs5K6yYbsnLfxFIBPRnrbJkI
+          sK+sQwnRdnsiUdPsTkG5B2lQfQIDAQABo4GHMIGEMB0GA1UdDgQWBBQ2lBp0PiRH
+          HvQ5IRURm8aHsj4RETAfBgNVHSMEGDAWgBQ2lBp0PiRHHvQ5IRURm8aHsj4RETAP
+          BgNVHRMBAf8EBTADAQH/MDEGA1UdEQQqMCiGJnNwaWZmZTovL2Zvby5iYXIuY29t
+          L2NsaWVudC93b3JrbG9hZC8xMA0GCSqGSIb3DQEBCwUAA4ICAQA1mSkgRclAl+E/
+          aS9zJ7t8+Y4n3T24nOKKveSIjxXm/zjhWqVsLYBI6kglWtih2+PELvU8JdPqNZK3
+          4Kl0Q6FWpVSGDdWN1i6NyORt2ocggL3ke3iXxRk3UpUKJmqwz81VhA2KUHnMlyE0
+          IufFfZNwNWWHBv13uJfRbjeQpKPhU+yf4DeXrsWcvrZlGvAET+mcplafUzCp7Iv+
+          PcISJtUerbxbVtuHVeZCLlgDXWkLAWJN8rf0dIG4x060LJ+j6j9uRVhb9sZn1HJV
+          +j4XdIYm1VKilluhOtNwP2d3Ox/JuTBxf7hFHXZPfMagQE5k5PzmxRaCAEMJ1l2D
+          vUbZw+shJfSNoWcBo2qadnUaWT3BmmJRBDh7ZReib/RQ1Rd4ygOyzP3E0vkV4/gq
+          yjLdApXh5PZP8KLQZ+1JN/sdWt7VfIt9wYOpkIqujdll51ESHzwQeAK9WVCB4UvV
+          z6zdhItB9CRbXPreWC+wCB1xDovIzFKOVsLs5+Gqs1m7VinG2LxbDqaKyo/FB0Hx
+          x0acBNzezLWoDwXYQrN0T0S4pnqhKD1CYPpdArBkNezUYAjS725FkApuK+mnBX3U
+          0msBffEaUEOkcyar1EW2m/33vpetD/k3eQQkmvQf4Hbiu9AF+9cNDm/hMuXEw5EX
+          GA91fn0891b5eEW8BJHXX0jri0aN8g=="],
+          "n": "<base64urlUint-encoded value>",
+          "e": "AQAB"
+        },
+        {
+          "kty": "RSA",
+          "use": "x509-svid",
+          "x5c": ["MIIELTCCAxWgAwIBAgIUVXGlXjNENtOZbI12epjgIhMaShEwDQYJKoZIhvcNAQEL
+          BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+          GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTI0
+          MDkxNzE2MTk0NFoXDTM0MDkxNTE2MTk0NFowTjELMAkGA1UEBhMCVVMxCzAJBgNV
+          BAgMAkNBMQwwCgYDVQQHDANTVkwxDTALBgNVBAoMBGdSUEMxFTATBgNVBAMMDHRl
+          c3QtY2xpZW50MTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOcTjjcS
+          SfG/EGrr6G+f+3T2GXyHHfroQFi9mZUz80L7uKBdECOImID+YhoK8vcxLQjPmEEv
+          FIYgJT5amugDcYIgUhMjBx/8RPJaP/nGmBngAqsuuNCaZfyaHBRqN8XdS/AwmsI5
+          Wo+nru0+0/7aQFdqqtd2+e9dHjUWwgHxXvMgC4hkHpsdCGIZWVzWyBliwTYQYb1Y
+          yYe1LzqqQA5OMbZfKOY9MYDCEYOliRiunOn30iIOHj9V5qLzWGfSyxCRuvLRdEP8
+          iDeNweHbdaKuI80nQmxuBdRIspE9k5sD1WA4vLZpeg3zggxp4rfLL5zBJgb/33D3
+          d9Rkm14xfDPihhkCAwEAAaOB+jCB9zBZBgNVHREEUjBQhiZzcGlmZmU6Ly9mb28u
+          YmFyLmNvbS9jbGllbnQvd29ya2xvYWQvMYYmc3BpZmZlOi8vZm9vLmJhci5jb20v
+          Y2xpZW50L3dvcmtsb2FkLzIwHQYDVR0OBBYEFG9GkBgdBg/p0U9/lXv8zIJ+2c2N
+          MHsGA1UdIwR0MHKhWqRYMFYxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0
+          YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxDzANBgNVBAMM
+          BnRlc3RjYYIUWrP0VvHcy+LP6UuYNtiL9gBhD5owDQYJKoZIhvcNAQELBQADggEB
+          AJ4Cbxv+02SpUgkEu4hP/1+8DtSBXUxNxI0VG4e3Ap2+Rhjm3YiFeS/UeaZhNrrw
+          UEjkSTPFODyXR7wI7UO9OO1StyD6CMkp3SEvevU5JsZtGL6mTiTLTi3Qkywa91Bt
+          GlyZdVMghA1bBJLBMwiD5VT5noqoJBD7hDy6v9yNmt1Sw2iYBJPqI3Gnf5bMjR3s
+          UICaxmFyqaMCZsPkfJh0DmZpInGJys3m4QqGz6ZE2DWgcSr1r/ML7/5bSPjjr8j4
+          WFFSqFR3dMu8CbGnfZTCTXa4GTX/rARXbAO67Z/oJbJBK7VKayskL+PzKuohb9ox
+          jGL772hQMbwtFCOFXu5VP0s="]
+        }
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/testing/src/main/resources/certs/spiffebundle1.json b/testing/src/main/resources/certs/spiffebundle1.json
new file mode 100644
index 00000000000..f79af09a3e7
--- /dev/null
+++ b/testing/src/main/resources/certs/spiffebundle1.json
@@ -0,0 +1,59 @@
+{
+  "trust_domains": {
+    "example.com": {
+      "spiffe_sequence": 12035488,
+      "keys": [
+        {
+          "kty": "RSA",
+          "use": "x509-svid",
+          "x5c": ["MIIDWjCCAkKgAwIBAgIUWrP0VvHcy+LP6UuYNtiL9gBhD5owDQYJKoZIhvcNAQEL
+          BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+          GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTIw
+          MDMxNzE4NTk1MVoXDTMwMDMxNTE4NTk1MVowVjELMAkGA1UEBhMCQVUxEzARBgNV
+          BAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0
+          ZDEPMA0GA1UEAwwGdGVzdGNhMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+          AQEAsGL0oXflF0LzoM+Bh+qUU9yhqzw2w8OOX5mu/iNCyUOBrqaHi7mGHx73GD01
+          diNzCzvlcQqdNIH6NQSL7DTpBjca66jYT9u73vZe2MDrr1nVbuLvfu9850cdxiUO
+          Inv5xf8+sTHG0C+a+VAvMhsLiRjsq+lXKRJyk5zkbbsETybqpxoJ+K7CoSy3yc/k
+          QIY3TipwEtwkKP4hzyo6KiGd/DPexie4nBUInN3bS1BUeNZ5zeaIC2eg3bkeeW7c
+          qT55b+Yen6CxY0TEkzBK6AKt/WUialKMgT0wbTxRZO7kUCH3Sq6e/wXeFdJ+HvdV
+          LPlAg5TnMaNpRdQih/8nRFpsdwIDAQABoyAwHjAMBgNVHRMEBTADAQH/MA4GA1Ud
+          DwEB/wQEAwICBDANBgkqhkiG9w0BAQsFAAOCAQEAkTrKZjBrJXHps/HrjNCFPb5a
+          THuGPCSsepe1wkKdSp1h4HGRpLoCgcLysCJ5hZhRpHkRihhef+rFHEe60UePQO3S
+          CVTtdJB4CYWpcNyXOdqefrbJW5QNljxgi6Fhvs7JJkBqdXIkWXtFk2eRgOIP2Eo9
+          /OHQHlYnwZFrk6sp4wPyR+A95S0toZBcyDVz7u+hOW0pGK3wviOe9lvRgj/H3Pwt
+          bewb0l+MhRig0/DVHamyVxrDRbqInU1/GTNCwcZkXKYFWSf92U+kIcTth24Q1gcw
+          eZiLl5FfrWokUNytFElXob0V0a5/kbhiLc3yWmvWqHTpqCALbVyF+rKJo2f5Kw=="],
+          "n": "<base64urlUint-encoded value>",
+          "e": "AQAB"
+        }
+      ]
+    },
+    "foo.bar.com": {
+      "keys": [
+        {
+          "kty": "RSA",
+          "use": "x509-svid",
+          "x5c": ["MIIDWjCCAkKgAwIBAgIUWrP0VvHcy+LP6UuYNtiL9gBhD5owDQYJKoZIhvcNAQEL
+            BQAwVjELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
+            GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEPMA0GA1UEAwwGdGVzdGNhMB4XDTIw
+            MDMxNzE4NTk1MVoXDTMwMDMxNTE4NTk1MVowVjELMAkGA1UEBhMCQVUxEzARBgNV
+            BAgMClNvbWUtU3RhdGUxITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0
+            ZDEPMA0GA1UEAwwGdGVzdGNhMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+            AQEAsGL0oXflF0LzoM+Bh+qUU9yhqzw2w8OOX5mu/iNCyUOBrqaHi7mGHx73GD01
+            diNzCzvlcQqdNIH6NQSL7DTpBjca66jYT9u73vZe2MDrr1nVbuLvfu9850cdxiUO
+            Inv5xf8+sTHG0C+a+VAvMhsLiRjsq+lXKRJyk5zkbbsETybqpxoJ+K7CoSy3yc/k
+            QIY3TipwEtwkKP4hzyo6KiGd/DPexie4nBUInN3bS1BUeNZ5zeaIC2eg3bkeeW7c
+            qT55b+Yen6CxY0TEkzBK6AKt/WUialKMgT0wbTxRZO7kUCH3Sq6e/wXeFdJ+HvdV
+            LPlAg5TnMaNpRdQih/8nRFpsdwIDAQABoyAwHjAMBgNVHRMEBTADAQH/MA4GA1Ud
+            DwEB/wQEAwICBDANBgkqhkiG9w0BAQsFAAOCAQEAkTrKZjBrJXHps/HrjNCFPb5a
+            THuGPCSsepe1wkKdSp1h4HGRpLoCgcLysCJ5hZhRpHkRihhef+rFHEe60UePQO3S
+            CVTtdJB4CYWpcNyXOdqefrbJW5QNljxgi6Fhvs7JJkBqdXIkWXtFk2eRgOIP2Eo9
+            /OHQHlYnwZFrk6sp4wPyR+A95S0toZBcyDVz7u+hOW0pGK3wviOe9lvRgj/H3Pwt
+            bewb0l+MhRig0/DVHamyVxrDRbqInU1/GTNCwcZkXKYFWSf92U+kIcTth24Q1gcw
+            eZiLl5FfrWokUNytFElXob0V0a5/kbhiLc3yWmvWqHTpqCALbVyF+rKJo2f5Kw=="]
+        }
+      ]
+    }
+  }
+}
\ No newline at end of file
diff --git a/testing/src/test/java/io/grpc/testing/GrpcCleanupRuleTest.java b/testing/src/test/java/io/grpc/testing/GrpcCleanupRuleTest.java
new file mode 100644
index 00000000000..8eb3edd3825
--- /dev/null
+++ b/testing/src/test/java/io/grpc/testing/GrpcCleanupRuleTest.java
@@ -0,0 +1,448 @@
+/*
+ * Copyright 2018 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.testing;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.internal.FakeClock;
+import io.grpc.testing.GrpcCleanupRule.Resource;
+import java.util.concurrent.TimeUnit;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.junit.runners.model.MultipleFailureException;
+import org.junit.runners.model.Statement;
+import org.mockito.InOrder;
+
+/**
+ * Unit tests for {@link GrpcCleanupRule}.
+ */
+@RunWith(JUnit4.class)
+public class GrpcCleanupRuleTest {
+  public static final FakeClock fakeClock = new FakeClock();
+
+  @Test
+  public void registerChannelReturnSameChannel() {
+    ManagedChannel channel = mock(ManagedChannel.class);
+    assertSame(channel, new GrpcCleanupRule().register(channel));
+  }
+
+  @Test
+  public void registerServerReturnSameServer() {
+    Server server = mock(Server.class);
+    assertSame(server, new GrpcCleanupRule().register(server));
+  }
+
+  @Test
+  public void registerNullChannelThrowsNpe() {
+    ManagedChannel channel = null;
+    GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> grpcCleanup.register(channel));
+    assertThat(e).hasMessageThat().isEqualTo("channel");
+  }
+
+  @Test
+  public void registerNullServerThrowsNpe() {
+    Server server = null;
+    GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+    NullPointerException e = assertThrows(NullPointerException.class,
+        () -> grpcCleanup.register(server));
+    assertThat(e).hasMessageThat().isEqualTo("server");
+  }
+
+  @Test
+  public void singleChannelCleanup() throws Throwable {
+    // setup
+    ManagedChannel channel = mock(ManagedChannel.class);
+    Statement statement = mock(Statement.class);
+    InOrder inOrder = inOrder(statement, channel);
+    GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+    // run
+    grpcCleanup.register(channel);
+
+    boolean awaitTerminationFailed = false;
+    try {
+      // will throw because channel.awaitTermination(long, TimeUnit) will return false;
+      grpcCleanup.apply(statement, null /* description*/).evaluate();
+    } catch (AssertionError e) {
+      awaitTerminationFailed = true;
+    }
+
+    // verify
+    assertTrue(awaitTerminationFailed);
+    inOrder.verify(statement).evaluate();
+    inOrder.verify(channel).shutdown();
+    inOrder.verify(channel).awaitTermination(anyLong(), any(TimeUnit.class));
+    inOrder.verify(channel).shutdownNow();
+  }
+
+  @Test
+  public void singleServerCleanup() throws Throwable {
+    // setup
+    Server server = mock(Server.class);
+    Statement statement = mock(Statement.class);
+    InOrder inOrder = inOrder(statement, server);
+    GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+    // run
+    grpcCleanup.register(server);
+
+    boolean awaitTerminationFailed = false;
+    try {
+      // will throw because channel.awaitTermination(long, TimeUnit) will return false;
+      grpcCleanup.apply(statement, null /* description*/).evaluate();
+    } catch (AssertionError e) {
+      awaitTerminationFailed = true;
+    }
+
+    // verify
+    assertTrue(awaitTerminationFailed);
+    inOrder.verify(statement).evaluate();
+    inOrder.verify(server).shutdown();
+    inOrder.verify(server).awaitTermination(anyLong(), any(TimeUnit.class));
+    inOrder.verify(server).shutdownNow();
+  }
+
+  @Test
+  public void multiResource_cleanupGracefully() throws Throwable {
+    // setup
+    Resource resource1 = mock(Resource.class);
+    Resource resource2 = mock(Resource.class);
+    Resource resource3 = mock(Resource.class);
+    doReturn(true).when(resource1).awaitReleased(anyLong(), any(TimeUnit.class));
+    doReturn(true).when(resource2).awaitReleased(anyLong(), any(TimeUnit.class));
+    doReturn(true).when(resource3).awaitReleased(anyLong(), any(TimeUnit.class));
+
+    Statement statement = mock(Statement.class);
+    InOrder inOrder = inOrder(statement, resource1, resource2, resource3);
+    GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+    // run
+    grpcCleanup.register(resource1);
+    grpcCleanup.register(resource2);
+    grpcCleanup.register(resource3);
+    grpcCleanup.apply(statement, null /* description*/).evaluate();
+
+    // Verify.
+    inOrder.verify(statement).evaluate();
+
+    inOrder.verify(resource3).cleanUp();
+    inOrder.verify(resource2).cleanUp();
+    inOrder.verify(resource1).cleanUp();
+
+    inOrder.verify(resource3).awaitReleased(anyLong(), any(TimeUnit.class));
+    inOrder.verify(resource2).awaitReleased(anyLong(), any(TimeUnit.class));
+    inOrder.verify(resource1).awaitReleased(anyLong(), any(TimeUnit.class));
+
+    inOrder.verifyNoMoreInteractions();
+
+    verify(resource1, never()).forceCleanUp();
+    verify(resource2, never()).forceCleanUp();
+    verify(resource3, never()).forceCleanUp();
+  }
+
+  @Test
+  public void baseTestFails() throws Throwable {
+    // setup
+    Resource resource = mock(Resource.class);
+
+    Statement statement = mock(Statement.class);
+    doThrow(new Exception()).when(statement).evaluate();
+
+    GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+    // run
+    grpcCleanup.register(resource);
+
+    boolean baseTestFailed = false;
+    try {
+      grpcCleanup.apply(statement, null /* description*/).evaluate();
+    } catch (Exception e) {
+      baseTestFailed = true;
+    }
+
+    // verify
+    assertTrue(baseTestFailed);
+
+    verify(resource).forceCleanUp();
+    verifyNoMoreInteractions(resource);
+
+    verify(resource, never()).cleanUp();
+    verify(resource, never()).awaitReleased(anyLong(), any(TimeUnit.class));
+  }
+
+  @Test
+  public void multiResource_awaitReleasedFails() throws Throwable {
+    // setup
+    Resource resource1 = mock(Resource.class);
+    Resource resource2 = mock(Resource.class);
+    Resource resource3 = mock(Resource.class);
+    doReturn(true).when(resource1).awaitReleased(anyLong(), any(TimeUnit.class));
+    doReturn(false).when(resource2).awaitReleased(anyLong(), any(TimeUnit.class));
+    doReturn(true).when(resource3).awaitReleased(anyLong(), any(TimeUnit.class));
+
+    Statement statement = mock(Statement.class);
+    InOrder inOrder = inOrder(statement, resource1, resource2, resource3);
+    GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+    // run
+    grpcCleanup.register(resource1);
+    grpcCleanup.register(resource2);
+    grpcCleanup.register(resource3);
+
+    boolean cleanupFailed = false;
+    try {
+      grpcCleanup.apply(statement, null /* description*/).evaluate();
+    } catch (AssertionError e) {
+      cleanupFailed = true;
+    }
+
+    // verify
+    assertTrue(cleanupFailed);
+
+    inOrder.verify(statement).evaluate();
+
+    inOrder.verify(resource3).cleanUp();
+    inOrder.verify(resource2).cleanUp();
+    inOrder.verify(resource1).cleanUp();
+
+    inOrder.verify(resource3).awaitReleased(anyLong(), any(TimeUnit.class));
+    inOrder.verify(resource2).awaitReleased(anyLong(), any(TimeUnit.class));
+    inOrder.verify(resource1).awaitReleased(anyLong(), any(TimeUnit.class));
+    inOrder.verify(resource2).forceCleanUp();
+
+    inOrder.verifyNoMoreInteractions();
+
+    verify(resource3, never()).forceCleanUp();
+    verify(resource1, never()).forceCleanUp();
+  }
+
+  @Test
+  public void multiResource_awaitReleasedInterrupted() throws Throwable {
+    // setup
+    Resource resource1 = mock(Resource.class);
+    Resource resource2 = mock(Resource.class);
+    Resource resource3 = mock(Resource.class);
+    doReturn(true).when(resource1).awaitReleased(anyLong(), any(TimeUnit.class));
+    doThrow(new InterruptedException())
+        .when(resource2).awaitReleased(anyLong(), any(TimeUnit.class));
+    doReturn(true).when(resource3).awaitReleased(anyLong(), any(TimeUnit.class));
+
+    Statement statement = mock(Statement.class);
+    InOrder inOrder = inOrder(statement, resource1, resource2, resource3);
+    GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+    // run
+    grpcCleanup.register(resource1);
+    grpcCleanup.register(resource2);
+    grpcCleanup.register(resource3);
+
+    boolean cleanupFailed = false;
+    try {
+      grpcCleanup.apply(statement, null /* description*/).evaluate();
+    } catch (Throwable e) {
+      cleanupFailed = true;
+    }
+
+    // verify
+    assertTrue(cleanupFailed);
+    assertTrue(Thread.interrupted());
+
+    inOrder.verify(statement).evaluate();
+
+    inOrder.verify(resource3).cleanUp();
+    inOrder.verify(resource2).cleanUp();
+    inOrder.verify(resource1).cleanUp();
+
+    inOrder.verify(resource3).awaitReleased(anyLong(), any(TimeUnit.class));
+    inOrder.verify(resource2).awaitReleased(anyLong(), any(TimeUnit.class));
+    inOrder.verify(resource2).forceCleanUp();
+    inOrder.verify(resource1).forceCleanUp();
+
+    inOrder.verifyNoMoreInteractions();
+
+    verify(resource3, never()).forceCleanUp();
+    verify(resource1, never()).awaitReleased(anyLong(), any(TimeUnit.class));
+  }
+
+  @Test
+  public void multiResource_timeoutCalculation() throws Throwable {
+    // setup
+
+    Resource resource1 = mock(FakeResource.class,
+        delegatesTo(new FakeResource(1 /* cleanupNanos */, 10 /* awaitReleaseNanos */)));
+
+    Resource resource2 = mock(FakeResource.class,
+        delegatesTo(new FakeResource(100 /* cleanupNanos */, 1000 /* awaitReleaseNanos */)));
+
+
+    Statement statement = mock(Statement.class);
+    InOrder inOrder = inOrder(statement, resource1, resource2);
+    GrpcCleanupRule grpcCleanup = new GrpcCleanupRule().setTicker(fakeClock.getTicker());
+
+    // run
+    grpcCleanup.register(resource1);
+    grpcCleanup.register(resource2);
+    grpcCleanup.apply(statement, null /* description*/).evaluate();
+
+    // verify
+    inOrder.verify(statement).evaluate();
+
+    inOrder.verify(resource2).cleanUp();
+    inOrder.verify(resource1).cleanUp();
+
+    inOrder.verify(resource2).awaitReleased(
+        TimeUnit.SECONDS.toNanos(10) - 100 - 1, TimeUnit.NANOSECONDS);
+    inOrder.verify(resource1).awaitReleased(
+        TimeUnit.SECONDS.toNanos(10) - 100 - 1 - 1000, TimeUnit.NANOSECONDS);
+
+    inOrder.verifyNoMoreInteractions();
+
+    verify(resource2, never()).forceCleanUp();
+    verify(resource1, never()).forceCleanUp();
+  }
+
+  @Test
+  public void multiResource_timeoutCalculation_customTimeout() throws Throwable {
+    // setup
+
+    Resource resource1 = mock(FakeResource.class,
+        delegatesTo(new FakeResource(1 /* cleanupNanos */, 10 /* awaitReleaseNanos */)));
+
+    Resource resource2 = mock(FakeResource.class,
+        delegatesTo(new FakeResource(100 /* cleanupNanos */, 1000 /* awaitReleaseNanos */)));
+
+
+    Statement statement = mock(Statement.class);
+    InOrder inOrder = inOrder(statement, resource1, resource2);
+    GrpcCleanupRule grpcCleanup = new GrpcCleanupRule()
+        .setTicker(fakeClock.getTicker()).setTimeout(3000, TimeUnit.NANOSECONDS);
+
+    // run
+    grpcCleanup.register(resource1);
+    grpcCleanup.register(resource2);
+    grpcCleanup.apply(statement, null /* description*/).evaluate();
+
+    // verify
+    inOrder.verify(statement).evaluate();
+
+    inOrder.verify(resource2).cleanUp();
+    inOrder.verify(resource1).cleanUp();
+
+    inOrder.verify(resource2).awaitReleased(3000 - 100 - 1, TimeUnit.NANOSECONDS);
+    inOrder.verify(resource1).awaitReleased(3000 - 100 - 1 - 1000, TimeUnit.NANOSECONDS);
+
+    inOrder.verifyNoMoreInteractions();
+
+    verify(resource2, never()).forceCleanUp();
+    verify(resource1, never()).forceCleanUp();
+  }
+
+  @Test
+  public void baseTestFailsThenCleanupFails() throws Throwable {
+    // setup
+    Exception baseTestFailure = new Exception("base test failure");
+    Exception cleanupFailure = new RuntimeException("force cleanup failed");
+
+    Statement statement = mock(Statement.class);
+    doThrow(baseTestFailure).when(statement).evaluate();
+
+    Resource resource1 = mock(Resource.class);
+    Resource resource2 = mock(Resource.class);
+    Resource resource3 = mock(Resource.class);
+    doThrow(cleanupFailure).when(resource2).forceCleanUp();
+
+    InOrder inOrder = inOrder(statement, resource1, resource2, resource3);
+    GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+
+    // run
+    grpcCleanup.register(resource1);
+    grpcCleanup.register(resource2);
+    grpcCleanup.register(resource3);
+
+    Throwable failure = null;
+    try {
+      grpcCleanup.apply(statement, null /* description*/).evaluate();
+    } catch (Throwable e) {
+      failure = e;
+    }
+
+    // verify
+    if (failure instanceof MultipleFailureException) {
+      // JUnit 4.13+
+      assertThat(((MultipleFailureException) failure).getFailures())
+          .containsExactly(baseTestFailure, cleanupFailure);
+    } else {
+      // JUnit 4.12. Suffers from https://github.com/junit-team/junit4/issues/1334
+      assertThat(failure).isSameInstanceAs(cleanupFailure);
+    }
+
+    inOrder.verify(statement).evaluate();
+    inOrder.verify(resource3).forceCleanUp();
+    inOrder.verify(resource2).forceCleanUp();
+    inOrder.verifyNoMoreInteractions();
+
+    verify(resource1, never()).cleanUp();
+    verify(resource2, never()).cleanUp();
+    verify(resource3, never()).cleanUp();
+    verify(resource1, never()).forceCleanUp();
+  }
+
+  public static class FakeResource implements Resource {
+    private final long cleanupNanos;
+    private final long awaitReleaseNanos;
+
+    private FakeResource(long cleanupNanos, long awaitReleaseNanos) {
+      this.cleanupNanos = cleanupNanos;
+      this.awaitReleaseNanos = awaitReleaseNanos;
+    }
+
+    @Override
+    public void cleanUp() {
+      fakeClock.forwardTime(cleanupNanos, TimeUnit.NANOSECONDS);
+    }
+
+    @Override
+    public void forceCleanUp() {
+    }
+
+    @Override
+    public boolean awaitReleased(long duration, TimeUnit timeUnit) {
+      fakeClock.forwardTime(awaitReleaseNanos, TimeUnit.NANOSECONDS);
+      return true;
+    }
+  }
+}
diff --git a/testing/src/test/java/io/grpc/testing/GrpcServerRuleTest.java b/testing/src/test/java/io/grpc/testing/GrpcServerRuleTest.java
index 61caec79993..10a16871262 100644
--- a/testing/src/test/java/io/grpc/testing/GrpcServerRuleTest.java
+++ b/testing/src/test/java/io/grpc/testing/GrpcServerRuleTest.java
@@ -1,249 +1,209 @@
 /*
- * Copyright 2016, Google Inc. All rights reserved.
+ * Copyright 2016 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.testing;
 
 import static com.google.common.truth.Truth.assertThat;
 
-import com.google.protobuf.ByteString;
-import com.google.protobuf.EmptyProtos;
 import io.grpc.ManagedChannel;
 import io.grpc.Server;
 import io.grpc.stub.StreamObserver;
-import io.grpc.testing.integration.Messages;
-import io.grpc.testing.integration.TestServiceGrpc;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
 import java.util.Collection;
-import java.util.UUID;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import org.junit.Rule;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
 import org.junit.runners.model.Statement;
 
+/** Unit tests for {@link GrpcServerRule}. */
+@RunWith(JUnit4.class)
 public class GrpcServerRuleTest {
 
-  public static class WithoutDirectExecutor {
-
-    @Rule
-    public final GrpcServerRule grpcServerRule = new GrpcServerRule();
+  @Rule public final GrpcServerRule grpcServerRule1 = new GrpcServerRule();
+  @Rule public final GrpcServerRule grpcServerRule2 = new GrpcServerRule().directExecutor();
 
-    @Test
-    public void serverAndChannelAreStarted() {
-      assertThat(grpcServerRule.getServer().isShutdown()).isFalse();
-      assertThat(grpcServerRule.getServer().isTerminated()).isFalse();
+  @Test
+  public void serverAndChannelAreStarted_withoutDirectExecutor() {
+    assertThat(grpcServerRule1.getServer().isShutdown()).isFalse();
+    assertThat(grpcServerRule1.getServer().isTerminated()).isFalse();
 
-      assertThat(grpcServerRule.getChannel().isShutdown()).isFalse();
-      assertThat(grpcServerRule.getChannel().isTerminated()).isFalse();
+    assertThat(grpcServerRule1.getChannel().isShutdown()).isFalse();
+    assertThat(grpcServerRule1.getChannel().isTerminated()).isFalse();
 
-      assertThat(grpcServerRule.getServerName()).isNotNull();
-      assertThat(grpcServerRule.getServiceRegistry()).isNotNull();
-    }
+    assertThat(grpcServerRule1.getServerName()).isNotNull();
+    assertThat(grpcServerRule1.getServiceRegistry()).isNotNull();
+  }
 
-    @Test
-    public void serverAllowsServicesToBeAddedViaServiceRegistry() {
-      TestServiceImpl testService = new TestServiceImpl();
+  @Test
+  public void serverAllowsServicesToBeAddedViaServiceRegistry_withoutDirectExecutor() {
+    TestServiceImpl testService = new TestServiceImpl();
 
-      grpcServerRule.getServiceRegistry().addService(testService);
+    grpcServerRule1.getServiceRegistry().addService(testService);
 
-      TestServiceGrpc.TestServiceBlockingStub stub =
-          TestServiceGrpc.newBlockingStub(grpcServerRule.getChannel());
+    SimpleServiceGrpc.SimpleServiceBlockingStub stub =
+        SimpleServiceGrpc.newBlockingStub(grpcServerRule1.getChannel());
 
-      Messages.SimpleRequest request1 = Messages.SimpleRequest.newBuilder()
-          .setPayload(Messages.Payload.newBuilder()
-                          .setBody(ByteString.copyFromUtf8(UUID.randomUUID().toString())))
-          .build();
+    SimpleRequest request1 = SimpleRequest.getDefaultInstance();
 
-      Messages.SimpleRequest request2 = Messages.SimpleRequest.newBuilder()
-          .setPayload(Messages.Payload.newBuilder()
-                          .setBody(ByteString.copyFromUtf8(UUID.randomUUID().toString())))
-          .build();
+    SimpleRequest request2 = SimpleRequest.newBuilder().build();
 
-      stub.unaryCall(request1);
-      stub.unaryCall(request2);
+    stub.unaryRpc(request1);
+    stub.unaryRpc(request2);
 
-      assertThat(testService.unaryCallRequests)
-          .containsExactly(request1, request2);
-    }
+    assertThat(testService.unaryCallRequests).containsExactly(request1, request2);
+  }
 
-    @Test
-    public void serviceIsNotRunOnSameThreadAsTest() {
-      TestServiceImpl testService = new TestServiceImpl();
+  @Test
+  public void serviceIsNotRunOnSameThreadAsTest_withoutDirectExecutor() {
+    TestServiceImpl testService = new TestServiceImpl();
 
-      grpcServerRule.getServiceRegistry().addService(testService);
+    grpcServerRule1.getServiceRegistry().addService(testService);
 
-      TestServiceGrpc.TestServiceBlockingStub stub =
-          TestServiceGrpc.newBlockingStub(grpcServerRule.getChannel());
+    SimpleServiceGrpc.SimpleServiceBlockingStub stub =
+        SimpleServiceGrpc.newBlockingStub(grpcServerRule1.getChannel());
 
-      // Make a garbage request first due to https://github.com/grpc/grpc-java/issues/2444.
-      stub.emptyCall(EmptyProtos.Empty.newBuilder().build());
-      stub.emptyCall(EmptyProtos.Empty.newBuilder().build());
+    stub.serverStreamingRpc(SimpleRequest.getDefaultInstance());
 
-      assertThat(testService.lastEmptyCallRequestThread).isNotEqualTo(Thread.currentThread());
-    }
+    assertThat(testService.lastServerStreamingRpcThread).isNotEqualTo(Thread.currentThread());
   }
 
-  public static class WithDirectExecutor {
-
-    @Rule
-    public final GrpcServerRule grpcServerRule = new GrpcServerRule().directExecutor();
+  @Test(expected = IllegalStateException.class)
+  public void callDirectExecutorNotAtRuleInstantiation_withoutDirectExecutor() {
+    grpcServerRule1.directExecutor();
+  }
 
-    @Test
-    public void serverAndChannelAreStarted() {
-      assertThat(grpcServerRule.getServer().isShutdown()).isFalse();
-      assertThat(grpcServerRule.getServer().isTerminated()).isFalse();
+  @Test
+  public void serverAndChannelAreStarted_withDirectExecutor() {
+    assertThat(grpcServerRule2.getServer().isShutdown()).isFalse();
+    assertThat(grpcServerRule2.getServer().isTerminated()).isFalse();
 
-      assertThat(grpcServerRule.getChannel().isShutdown()).isFalse();
-      assertThat(grpcServerRule.getChannel().isTerminated()).isFalse();
+    assertThat(grpcServerRule2.getChannel().isShutdown()).isFalse();
+    assertThat(grpcServerRule2.getChannel().isTerminated()).isFalse();
 
-      assertThat(grpcServerRule.getServerName()).isNotNull();
-      assertThat(grpcServerRule.getServiceRegistry()).isNotNull();
-    }
+    assertThat(grpcServerRule2.getServerName()).isNotNull();
+    assertThat(grpcServerRule2.getServiceRegistry()).isNotNull();
+  }
 
-    @Test
-    public void serverAllowsServicesToBeAddedViaServiceRegistry() {
-      TestServiceImpl testService = new TestServiceImpl();
+  @Test
+  public void serverAllowsServicesToBeAddedViaServiceRegistry_withDirectExecutor() {
+    TestServiceImpl testService = new TestServiceImpl();
 
-      grpcServerRule.getServiceRegistry().addService(testService);
+    grpcServerRule2.getServiceRegistry().addService(testService);
 
-      TestServiceGrpc.TestServiceBlockingStub stub =
-          TestServiceGrpc.newBlockingStub(grpcServerRule.getChannel());
+    SimpleServiceGrpc.SimpleServiceBlockingStub stub =
+        SimpleServiceGrpc.newBlockingStub(grpcServerRule2.getChannel());
 
-      Messages.SimpleRequest request1 = Messages.SimpleRequest.newBuilder()
-          .setPayload(Messages.Payload.newBuilder()
-                          .setBody(ByteString.copyFromUtf8(UUID.randomUUID().toString())))
-          .build();
+    SimpleRequest request1 = SimpleRequest.getDefaultInstance();
 
-      Messages.SimpleRequest request2 = Messages.SimpleRequest.newBuilder()
-          .setPayload(Messages.Payload.newBuilder()
-                          .setBody(ByteString.copyFromUtf8(UUID.randomUUID().toString())))
-          .build();
+    SimpleRequest request2 = SimpleRequest.newBuilder().build();
 
-      stub.unaryCall(request1);
-      stub.unaryCall(request2);
+    stub.unaryRpc(request1);
+    stub.unaryRpc(request2);
 
-      assertThat(testService.unaryCallRequests)
-          .containsExactly(request1, request2);
-    }
+    assertThat(testService.unaryCallRequests).containsExactly(request1, request2);
+  }
 
-    @Test
-    public void serviceIsRunOnSameThreadAsTest() {
-      TestServiceImpl testService = new TestServiceImpl();
+  @Test
+  public void serviceIsRunOnSameThreadAsTest_withDirectExecutor() {
+    TestServiceImpl testService = new TestServiceImpl();
 
-      grpcServerRule.getServiceRegistry().addService(testService);
+    grpcServerRule2.getServiceRegistry().addService(testService);
 
-      TestServiceGrpc.TestServiceBlockingStub stub =
-          TestServiceGrpc.newBlockingStub(grpcServerRule.getChannel());
+    SimpleServiceGrpc.SimpleServiceBlockingStub stub =
+        SimpleServiceGrpc.newBlockingStub(grpcServerRule2.getChannel());
 
-      // Make a garbage request first due to https://github.com/grpc/grpc-java/issues/2444.
-      stub.emptyCall(EmptyProtos.Empty.newBuilder().build());
-      stub.emptyCall(EmptyProtos.Empty.newBuilder().build());
+    stub.serverStreamingRpc(SimpleRequest.getDefaultInstance());
 
-      assertThat(testService.lastEmptyCallRequestThread).isEqualTo(Thread.currentThread());
-    }
+    assertThat(testService.lastServerStreamingRpcThread).isEqualTo(Thread.currentThread());
   }
 
-  public static class ResourceCleanup {
-
-    @Test
-    public void serverAndChannelAreShutdownAfterRule() throws Throwable {
-      GrpcServerRule grpcServerRule = new GrpcServerRule();
+  @Test
+  public void serverAndChannelAreShutdownAfterRule() throws Throwable {
+    GrpcServerRule grpcServerRule = new GrpcServerRule();
 
-      // Before the rule has been executed, all of its resources should be null.
-      assertThat(grpcServerRule.getChannel()).isNull();
-      assertThat(grpcServerRule.getServer()).isNull();
-      assertThat(grpcServerRule.getServerName()).isNull();
-      assertThat(grpcServerRule.getServiceRegistry()).isNull();
+    // Before the rule has been executed, all of its resources should be null.
+    assertThat(grpcServerRule.getChannel()).isNull();
+    assertThat(grpcServerRule.getServer()).isNull();
+    assertThat(grpcServerRule.getServerName()).isNull();
+    assertThat(grpcServerRule.getServiceRegistry()).isNull();
 
-      // The TestStatement stores the channel and server instances so that we can inspect them after
-      // the rule cleans up.
-      TestStatement statement = new TestStatement(grpcServerRule);
+    // The TestStatement stores the channel and server instances so that we can inspect them after
+    // the rule cleans up.
+    TestStatement statement = new TestStatement(grpcServerRule);
 
-      grpcServerRule.apply(statement, null).evaluate();
+    grpcServerRule.apply(statement, null).evaluate();
 
-      // Ensure that the stored channel and server instances were shut down.
-      assertThat(statement.channel.isShutdown()).isTrue();
-      assertThat(statement.server.isShutdown()).isTrue();
+    // Ensure that the stored channel and server instances were shut down.
+    assertThat(statement.channel.isShutdown()).isTrue();
+    assertThat(statement.server.isShutdown()).isTrue();
 
-      // All references to the resources that we created should be set to null.
-      assertThat(grpcServerRule.getChannel()).isNull();
-      assertThat(grpcServerRule.getServer()).isNull();
-      assertThat(grpcServerRule.getServerName()).isNull();
-      assertThat(grpcServerRule.getServiceRegistry()).isNull();
-    }
+    // All references to the resources that we created should be set to null.
+    assertThat(grpcServerRule.getChannel()).isNull();
+    assertThat(grpcServerRule.getServer()).isNull();
+    assertThat(grpcServerRule.getServerName()).isNull();
+    assertThat(grpcServerRule.getServiceRegistry()).isNull();
+  }
 
-    private static class TestStatement extends Statement {
+  private static class TestStatement extends Statement {
 
-      private final GrpcServerRule grpcServerRule;
+    private final GrpcServerRule grpcServerRule;
 
-      private ManagedChannel channel;
-      private Server server;
+    private ManagedChannel channel;
+    private Server server;
 
-      private TestStatement(GrpcServerRule grpcServerRule) {
-        this.grpcServerRule = grpcServerRule;
-      }
+    private TestStatement(GrpcServerRule grpcServerRule) {
+      this.grpcServerRule = grpcServerRule;
+    }
 
-      @Override
-      public void evaluate() throws Throwable {
-        channel = grpcServerRule.getChannel();
-        server = grpcServerRule.getServer();
-      }
+    @Override
+    public void evaluate() throws Throwable {
+      channel = grpcServerRule.getChannel();
+      server = grpcServerRule.getServer();
     }
   }
 
-  private static class TestServiceImpl extends TestServiceGrpc.TestServiceImplBase {
+  private static class TestServiceImpl extends SimpleServiceGrpc.SimpleServiceImplBase {
 
-    private final Collection<Messages.SimpleRequest> unaryCallRequests =
-        new ConcurrentLinkedQueue<Messages.SimpleRequest>();
+    private final Collection<SimpleRequest> unaryCallRequests =
+        new ConcurrentLinkedQueue<>();
 
-    private volatile Thread lastEmptyCallRequestThread;
+    private volatile Thread lastServerStreamingRpcThread;
 
     @Override
-    public void emptyCall(
-        EmptyProtos.Empty request,
-        StreamObserver<EmptyProtos.Empty> responseObserver) {
+    public void serverStreamingRpc(
+        SimpleRequest request, StreamObserver<SimpleResponse> responseObserver) {
 
-      lastEmptyCallRequestThread = Thread.currentThread();
+      lastServerStreamingRpcThread = Thread.currentThread();
 
-      responseObserver.onNext(EmptyProtos.Empty.newBuilder().build());
+      responseObserver.onNext(SimpleResponse.getDefaultInstance());
 
       responseObserver.onCompleted();
     }
 
     @Override
-    public void unaryCall(
-        Messages.SimpleRequest request,
-        StreamObserver<Messages.SimpleResponse> responseObserver) {
+    public void unaryRpc(
+        SimpleRequest request, StreamObserver<SimpleResponse> responseObserver) {
 
       unaryCallRequests.add(request);
 
-      responseObserver.onNext(Messages.SimpleResponse.newBuilder().build());
+      responseObserver.onNext(SimpleResponse.getDefaultInstance());
 
       responseObserver.onCompleted();
     }
diff --git a/testing/src/test/java/io/grpc/testing/TlsTestingTest.java b/testing/src/test/java/io/grpc/testing/TlsTestingTest.java
new file mode 100644
index 00000000000..7ffc48fe9df
--- /dev/null
+++ b/testing/src/test/java/io/grpc/testing/TlsTestingTest.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2017 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.testing;
+
+import static org.junit.Assert.assertNotNull;
+
+import java.io.InputStream;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link TlsTesting}. */
+@RunWith(JUnit4.class)
+public class TlsTestingTest {
+  @Test
+  public void loadCert() throws Exception {
+    InputStream is = null;
+    try {
+      is = TlsTesting.loadCert("ca.key");
+      assertNotNull(is);
+    } finally {
+      if (is != null) {
+        is.close();
+      }
+    }
+  }
+}
diff --git a/thrift/build.gradle b/thrift/build.gradle
deleted file mode 100644
index 33e509ea91d..00000000000
--- a/thrift/build.gradle
+++ /dev/null
@@ -1,29 +0,0 @@
-description = 'gRPC: Thrift'
-
-dependencies {
-    compile project(':grpc-core'),
-            'org.apache.thrift:libthrift:0.9.3'
-}
-
-
-String generatedSourcePath = "${projectDir}/src/generated"
-project.sourceSets {
-  main {
-    java {
-      srcDir "${generatedSourcePath}/main/java"
-      srcDir "${generatedSourcePath}/main/grpc"
-    }
-  }
-  test {
-    java {
-      srcDir "${generatedSourcePath}/test/java"
-      srcDir "${generatedSourcePath}/test/grpc"
-    }
-  }
-}
-
-idea {
-    module {
-        sourceDirs += file("${projectDir}/src/generated/test/java");
-    }
-}
\ No newline at end of file
diff --git a/thrift/src/generated/test/java/io/grpc/thrift/Message.java b/thrift/src/generated/test/java/io/grpc/thrift/Message.java
deleted file mode 100644
index 44c7908bd15..00000000000
--- a/thrift/src/generated/test/java/io/grpc/thrift/Message.java
+++ /dev/null
@@ -1,744 +0,0 @@
-/**
- * Autogenerated by Thrift Compiler (1.0.0-dev)
- *
- * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
- *  @generated
- */
-package io.grpc.thrift;
-
-import org.apache.thrift.scheme.IScheme;
-import org.apache.thrift.scheme.SchemeFactory;
-import org.apache.thrift.scheme.StandardScheme;
-
-import org.apache.thrift.scheme.TupleScheme;
-import org.apache.thrift.protocol.TTupleProtocol;
-import org.apache.thrift.protocol.TProtocolException;
-import org.apache.thrift.EncodingUtils;
-import org.apache.thrift.server.AbstractNonblockingServer.*;
-import java.util.List;
-import java.util.ArrayList;
-import java.util.Map;
-import java.util.HashMap;
-import java.util.EnumMap;
-import java.util.Set;
-import java.util.HashSet;
-import java.util.EnumSet;
-import java.util.Collections;
-import java.util.BitSet;
-import java.nio.ByteBuffer;
-import java.util.Arrays;
-import javax.annotation.Generated;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked", "unused"})
-@Generated(value = "Autogenerated by Thrift Compiler (1.0.0-dev)", date = "2016-07-11")
-public class Message implements org.apache.thrift.TBase<Message, Message._Fields>, java.io.Serializable, Cloneable, Comparable<Message> {
-  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("Message");
-
-  private static final org.apache.thrift.protocol.TField I_FIELD_DESC = new org.apache.thrift.protocol.TField("i", org.apache.thrift.protocol.TType.I32, (short)1);
-  private static final org.apache.thrift.protocol.TField B_FIELD_DESC = new org.apache.thrift.protocol.TField("b", org.apache.thrift.protocol.TType.BOOL, (short)2);
-  private static final org.apache.thrift.protocol.TField S_FIELD_DESC = new org.apache.thrift.protocol.TField("s", org.apache.thrift.protocol.TType.STRING, (short)3);
-  private static final org.apache.thrift.protocol.TField L_FIELD_DESC = new org.apache.thrift.protocol.TField("l", org.apache.thrift.protocol.TType.LIST, (short)4);
-
-  private static final SchemeFactory STANDARD_SCHEME_FACTORY = new MessageStandardSchemeFactory();
-  private static final SchemeFactory TUPLE_SCHEME_FACTORY = new MessageTupleSchemeFactory();
-
-  public int i; // required
-  public boolean b; // required
-  public String s; // required
-  public List<Integer> l; // required
-
-  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
-  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
-    I((short)1, "i"),
-    B((short)2, "b"),
-    S((short)3, "s"),
-    L((short)4, "l");
-
-    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
-
-    static {
-      for (_Fields field : EnumSet.allOf(_Fields.class)) {
-        byName.put(field.getFieldName(), field);
-      }
-    }
-
-    /**
-     * Find the _Fields constant that matches fieldId, or null if its not found.
-     */
-    public static _Fields findByThriftId(int fieldId) {
-      switch(fieldId) {
-        case 1: // I
-          return I;
-        case 2: // B
-          return B;
-        case 3: // S
-          return S;
-        case 4: // L
-          return L;
-        default:
-          return null;
-      }
-    }
-
-    /**
-     * Find the _Fields constant that matches fieldId, throwing an exception
-     * if it is not found.
-     */
-    public static _Fields findByThriftIdOrThrow(int fieldId) {
-      _Fields fields = findByThriftId(fieldId);
-      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
-      return fields;
-    }
-
-    /**
-     * Find the _Fields constant that matches name, or null if its not found.
-     */
-    public static _Fields findByName(String name) {
-      return byName.get(name);
-    }
-
-    private final short _thriftId;
-    private final String _fieldName;
-
-    _Fields(short thriftId, String fieldName) {
-      _thriftId = thriftId;
-      _fieldName = fieldName;
-    }
-
-    public short getThriftFieldId() {
-      return _thriftId;
-    }
-
-    public String getFieldName() {
-      return _fieldName;
-    }
-  }
-
-  // isset id assignments
-  private static final int __I_ISSET_ID = 0;
-  private static final int __B_ISSET_ID = 1;
-  private byte __isset_bitfield = 0;
-  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
-  static {
-    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
-    tmpMap.put(_Fields.I, new org.apache.thrift.meta_data.FieldMetaData("i", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
-    tmpMap.put(_Fields.B, new org.apache.thrift.meta_data.FieldMetaData("b", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
-    tmpMap.put(_Fields.S, new org.apache.thrift.meta_data.FieldMetaData("s", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
-    tmpMap.put(_Fields.L, new org.apache.thrift.meta_data.FieldMetaData("l", org.apache.thrift.TFieldRequirementType.DEFAULT, 
-        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
-            new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))));
-    metaDataMap = Collections.unmodifiableMap(tmpMap);
-    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(Message.class, metaDataMap);
-  }
-
-  public Message() {
-  }
-
-  public Message(
-    int i,
-    boolean b,
-    String s,
-    List<Integer> l)
-  {
-    this();
-    this.i = i;
-    setIIsSet(true);
-    this.b = b;
-    setBIsSet(true);
-    this.s = s;
-    this.l = l;
-  }
-
-  /**
-   * Performs a deep copy on <i>other</i>.
-   */
-  public Message(Message other) {
-    __isset_bitfield = other.__isset_bitfield;
-    this.i = other.i;
-    this.b = other.b;
-    if (other.isSetS()) {
-      this.s = other.s;
-    }
-    if (other.isSetL()) {
-      List<Integer> __this__l = new ArrayList<Integer>(other.l);
-      this.l = __this__l;
-    }
-  }
-
-  public Message deepCopy() {
-    return new Message(this);
-  }
-
-  @Override
-  public void clear() {
-    setIIsSet(false);
-    this.i = 0;
-    setBIsSet(false);
-    this.b = false;
-    this.s = null;
-    this.l = null;
-  }
-
-  public int getI() {
-    return this.i;
-  }
-
-  public Message setI(int i) {
-    this.i = i;
-    setIIsSet(true);
-    return this;
-  }
-
-  public void unsetI() {
-    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __I_ISSET_ID);
-  }
-
-  /** Returns true if field i is set (has been assigned a value) and false otherwise */
-  public boolean isSetI() {
-    return EncodingUtils.testBit(__isset_bitfield, __I_ISSET_ID);
-  }
-
-  public void setIIsSet(boolean value) {
-    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __I_ISSET_ID, value);
-  }
-
-  public boolean isB() {
-    return this.b;
-  }
-
-  public Message setB(boolean b) {
-    this.b = b;
-    setBIsSet(true);
-    return this;
-  }
-
-  public void unsetB() {
-    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __B_ISSET_ID);
-  }
-
-  /** Returns true if field b is set (has been assigned a value) and false otherwise */
-  public boolean isSetB() {
-    return EncodingUtils.testBit(__isset_bitfield, __B_ISSET_ID);
-  }
-
-  public void setBIsSet(boolean value) {
-    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __B_ISSET_ID, value);
-  }
-
-  public String getS() {
-    return this.s;
-  }
-
-  public Message setS(String s) {
-    this.s = s;
-    return this;
-  }
-
-  public void unsetS() {
-    this.s = null;
-  }
-
-  /** Returns true if field s is set (has been assigned a value) and false otherwise */
-  public boolean isSetS() {
-    return this.s != null;
-  }
-
-  public void setSIsSet(boolean value) {
-    if (!value) {
-      this.s = null;
-    }
-  }
-
-  public int getLSize() {
-    return (this.l == null) ? 0 : this.l.size();
-  }
-
-  public java.util.Iterator<Integer> getLIterator() {
-    return (this.l == null) ? null : this.l.iterator();
-  }
-
-  public void addToL(int elem) {
-    if (this.l == null) {
-      this.l = new ArrayList<Integer>();
-    }
-    this.l.add(elem);
-  }
-
-  public List<Integer> getL() {
-    return this.l;
-  }
-
-  public Message setL(List<Integer> l) {
-    this.l = l;
-    return this;
-  }
-
-  public void unsetL() {
-    this.l = null;
-  }
-
-  /** Returns true if field l is set (has been assigned a value) and false otherwise */
-  public boolean isSetL() {
-    return this.l != null;
-  }
-
-  public void setLIsSet(boolean value) {
-    if (!value) {
-      this.l = null;
-    }
-  }
-
-  public void setFieldValue(_Fields field, Object value) {
-    switch (field) {
-    case I:
-      if (value == null) {
-        unsetI();
-      } else {
-        setI((Integer)value);
-      }
-      break;
-
-    case B:
-      if (value == null) {
-        unsetB();
-      } else {
-        setB((Boolean)value);
-      }
-      break;
-
-    case S:
-      if (value == null) {
-        unsetS();
-      } else {
-        setS((String)value);
-      }
-      break;
-
-    case L:
-      if (value == null) {
-        unsetL();
-      } else {
-        setL((List<Integer>)value);
-      }
-      break;
-
-    }
-  }
-
-  public Object getFieldValue(_Fields field) {
-    switch (field) {
-    case I:
-      return getI();
-
-    case B:
-      return isB();
-
-    case S:
-      return getS();
-
-    case L:
-      return getL();
-
-    }
-    throw new IllegalStateException();
-  }
-
-  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
-  public boolean isSet(_Fields field) {
-    if (field == null) {
-      throw new IllegalArgumentException();
-    }
-
-    switch (field) {
-    case I:
-      return isSetI();
-    case B:
-      return isSetB();
-    case S:
-      return isSetS();
-    case L:
-      return isSetL();
-    }
-    throw new IllegalStateException();
-  }
-
-  @Override
-  public boolean equals(Object that) {
-    if (that == null)
-      return false;
-    if (that instanceof Message)
-      return this.equals((Message)that);
-    return false;
-  }
-
-  public boolean equals(Message that) {
-    if (that == null)
-      return false;
-
-    boolean this_present_i = true;
-    boolean that_present_i = true;
-    if (this_present_i || that_present_i) {
-      if (!(this_present_i && that_present_i))
-        return false;
-      if (this.i != that.i)
-        return false;
-    }
-
-    boolean this_present_b = true;
-    boolean that_present_b = true;
-    if (this_present_b || that_present_b) {
-      if (!(this_present_b && that_present_b))
-        return false;
-      if (this.b != that.b)
-        return false;
-    }
-
-    boolean this_present_s = true && this.isSetS();
-    boolean that_present_s = true && that.isSetS();
-    if (this_present_s || that_present_s) {
-      if (!(this_present_s && that_present_s))
-        return false;
-      if (!this.s.equals(that.s))
-        return false;
-    }
-
-    boolean this_present_l = true && this.isSetL();
-    boolean that_present_l = true && that.isSetL();
-    if (this_present_l || that_present_l) {
-      if (!(this_present_l && that_present_l))
-        return false;
-      if (!this.l.equals(that.l))
-        return false;
-    }
-
-    return true;
-  }
-
-  @Override
-  public int hashCode() {
-    int hashCode = 1;
-
-    hashCode = hashCode * 8191 + i;
-
-    hashCode = hashCode * 8191 + ((b) ? 131071 : 524287);
-
-    hashCode = hashCode * 8191 + ((isSetS()) ? 131071 : 524287);
-    if (isSetS())
-      hashCode = hashCode * 8191 + s.hashCode();
-
-    hashCode = hashCode * 8191 + ((isSetL()) ? 131071 : 524287);
-    if (isSetL())
-      hashCode = hashCode * 8191 + l.hashCode();
-
-    return hashCode;
-  }
-
-  @Override
-  public int compareTo(Message other) {
-    if (!getClass().equals(other.getClass())) {
-      return getClass().getName().compareTo(other.getClass().getName());
-    }
-
-    int lastComparison = 0;
-
-    lastComparison = Boolean.valueOf(isSetI()).compareTo(other.isSetI());
-    if (lastComparison != 0) {
-      return lastComparison;
-    }
-    if (isSetI()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.i, other.i);
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
-    }
-    lastComparison = Boolean.valueOf(isSetB()).compareTo(other.isSetB());
-    if (lastComparison != 0) {
-      return lastComparison;
-    }
-    if (isSetB()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.b, other.b);
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
-    }
-    lastComparison = Boolean.valueOf(isSetS()).compareTo(other.isSetS());
-    if (lastComparison != 0) {
-      return lastComparison;
-    }
-    if (isSetS()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.s, other.s);
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
-    }
-    lastComparison = Boolean.valueOf(isSetL()).compareTo(other.isSetL());
-    if (lastComparison != 0) {
-      return lastComparison;
-    }
-    if (isSetL()) {
-      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.l, other.l);
-      if (lastComparison != 0) {
-        return lastComparison;
-      }
-    }
-    return 0;
-  }
-
-  public _Fields fieldForId(int fieldId) {
-    return _Fields.findByThriftId(fieldId);
-  }
-
-  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
-    scheme(iprot).read(iprot, this);
-  }
-
-  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
-    scheme(oprot).write(oprot, this);
-  }
-
-  @Override
-  public String toString() {
-    StringBuilder sb = new StringBuilder("Message(");
-    boolean first = true;
-
-    sb.append("i:");
-    sb.append(this.i);
-    first = false;
-    if (!first) sb.append(", ");
-    sb.append("b:");
-    sb.append(this.b);
-    first = false;
-    if (!first) sb.append(", ");
-    sb.append("s:");
-    if (this.s == null) {
-      sb.append("null");
-    } else {
-      sb.append(this.s);
-    }
-    first = false;
-    if (!first) sb.append(", ");
-    sb.append("l:");
-    if (this.l == null) {
-      sb.append("null");
-    } else {
-      sb.append(this.l);
-    }
-    first = false;
-    sb.append(")");
-    return sb.toString();
-  }
-
-  public void validate() throws org.apache.thrift.TException {
-    // check for required fields
-    // check for sub-struct validity
-  }
-
-  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
-    try {
-      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
-    } catch (org.apache.thrift.TException te) {
-      throw new java.io.IOException(te);
-    }
-  }
-
-  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
-    try {
-      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
-      __isset_bitfield = 0;
-      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
-    } catch (org.apache.thrift.TException te) {
-      throw new java.io.IOException(te);
-    }
-  }
-
-  private static class MessageStandardSchemeFactory implements SchemeFactory {
-    public MessageStandardScheme getScheme() {
-      return new MessageStandardScheme();
-    }
-  }
-
-  private static class MessageStandardScheme extends StandardScheme<Message> {
-
-    public void read(org.apache.thrift.protocol.TProtocol iprot, Message struct) throws org.apache.thrift.TException {
-      org.apache.thrift.protocol.TField schemeField;
-      iprot.readStructBegin();
-      while (true)
-      {
-        schemeField = iprot.readFieldBegin();
-        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
-          break;
-        }
-        switch (schemeField.id) {
-          case 1: // I
-            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
-              struct.i = iprot.readI32();
-              struct.setIIsSet(true);
-            } else { 
-              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
-            }
-            break;
-          case 2: // B
-            if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
-              struct.b = iprot.readBool();
-              struct.setBIsSet(true);
-            } else { 
-              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
-            }
-            break;
-          case 3: // S
-            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
-              struct.s = iprot.readString();
-              struct.setSIsSet(true);
-            } else { 
-              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
-            }
-            break;
-          case 4: // L
-            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
-              {
-                org.apache.thrift.protocol.TList _list0 = iprot.readListBegin();
-                struct.l = new ArrayList<Integer>(_list0.size);
-                int _elem1;
-                for (int _i2 = 0; _i2 < _list0.size; ++_i2)
-                {
-                  _elem1 = iprot.readI32();
-                  struct.l.add(_elem1);
-                }
-                iprot.readListEnd();
-              }
-              struct.setLIsSet(true);
-            } else { 
-              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
-            }
-            break;
-          default:
-            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
-        }
-        iprot.readFieldEnd();
-      }
-      iprot.readStructEnd();
-
-      // check for required fields of primitive type, which can't be checked in the validate method
-      struct.validate();
-    }
-
-    public void write(org.apache.thrift.protocol.TProtocol oprot, Message struct) throws org.apache.thrift.TException {
-      struct.validate();
-
-      oprot.writeStructBegin(STRUCT_DESC);
-      oprot.writeFieldBegin(I_FIELD_DESC);
-      oprot.writeI32(struct.i);
-      oprot.writeFieldEnd();
-      oprot.writeFieldBegin(B_FIELD_DESC);
-      oprot.writeBool(struct.b);
-      oprot.writeFieldEnd();
-      if (struct.s != null) {
-        oprot.writeFieldBegin(S_FIELD_DESC);
-        oprot.writeString(struct.s);
-        oprot.writeFieldEnd();
-      }
-      if (struct.l != null) {
-        oprot.writeFieldBegin(L_FIELD_DESC);
-        {
-          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.l.size()));
-          for (int _iter3 : struct.l)
-          {
-            oprot.writeI32(_iter3);
-          }
-          oprot.writeListEnd();
-        }
-        oprot.writeFieldEnd();
-      }
-      oprot.writeFieldStop();
-      oprot.writeStructEnd();
-    }
-
-  }
-
-  private static class MessageTupleSchemeFactory implements SchemeFactory {
-    public MessageTupleScheme getScheme() {
-      return new MessageTupleScheme();
-    }
-  }
-
-  private static class MessageTupleScheme extends TupleScheme<Message> {
-
-    @Override
-    public void write(org.apache.thrift.protocol.TProtocol prot, Message struct) throws org.apache.thrift.TException {
-      TTupleProtocol oprot = (TTupleProtocol) prot;
-      BitSet optionals = new BitSet();
-      if (struct.isSetI()) {
-        optionals.set(0);
-      }
-      if (struct.isSetB()) {
-        optionals.set(1);
-      }
-      if (struct.isSetS()) {
-        optionals.set(2);
-      }
-      if (struct.isSetL()) {
-        optionals.set(3);
-      }
-      oprot.writeBitSet(optionals, 4);
-      if (struct.isSetI()) {
-        oprot.writeI32(struct.i);
-      }
-      if (struct.isSetB()) {
-        oprot.writeBool(struct.b);
-      }
-      if (struct.isSetS()) {
-        oprot.writeString(struct.s);
-      }
-      if (struct.isSetL()) {
-        {
-          oprot.writeI32(struct.l.size());
-          for (int _iter4 : struct.l)
-          {
-            oprot.writeI32(_iter4);
-          }
-        }
-      }
-    }
-
-    @Override
-    public void read(org.apache.thrift.protocol.TProtocol prot, Message struct) throws org.apache.thrift.TException {
-      TTupleProtocol iprot = (TTupleProtocol) prot;
-      BitSet incoming = iprot.readBitSet(4);
-      if (incoming.get(0)) {
-        struct.i = iprot.readI32();
-        struct.setIIsSet(true);
-      }
-      if (incoming.get(1)) {
-        struct.b = iprot.readBool();
-        struct.setBIsSet(true);
-      }
-      if (incoming.get(2)) {
-        struct.s = iprot.readString();
-        struct.setSIsSet(true);
-      }
-      if (incoming.get(3)) {
-        {
-          org.apache.thrift.protocol.TList _list5 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32());
-          struct.l = new ArrayList<Integer>(_list5.size);
-          int _elem6;
-          for (int _i7 = 0; _i7 < _list5.size; ++_i7)
-          {
-            _elem6 = iprot.readI32();
-            struct.l.add(_elem6);
-          }
-        }
-        struct.setLIsSet(true);
-      }
-    }
-  }
-
-  private static <S extends IScheme> S scheme(org.apache.thrift.protocol.TProtocol proto) {
-    return (StandardScheme.class.equals(proto.getScheme()) ? STANDARD_SCHEME_FACTORY : TUPLE_SCHEME_FACTORY).getScheme();
-  }
-}
-
diff --git a/thrift/src/main/java/io/grpc/thrift/MessageFactory.java b/thrift/src/main/java/io/grpc/thrift/MessageFactory.java
deleted file mode 100644
index 658a7e88f53..00000000000
--- a/thrift/src/main/java/io/grpc/thrift/MessageFactory.java
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.thrift;
-
-import io.grpc.ExperimentalApi;
-import org.apache.thrift.TBase;
-
-/** 
- *  Produce new Message Instances. Used by Marshaller to deserialize incoming messages. 
- */
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2170")
-public interface MessageFactory<T extends TBase<T,?>> {
-  T newInstance();
-}
diff --git a/thrift/src/main/java/io/grpc/thrift/ThriftInputStream.java b/thrift/src/main/java/io/grpc/thrift/ThriftInputStream.java
deleted file mode 100644
index bf2bf6708ea..00000000000
--- a/thrift/src/main/java/io/grpc/thrift/ThriftInputStream.java
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.thrift;
-
-import com.google.common.io.ByteStreams;
-import io.grpc.Drainable;
-import io.grpc.KnownLength;
-import io.grpc.Status;
-import java.io.ByteArrayInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import javax.annotation.Nullable;
-import org.apache.thrift.TBase;
-import org.apache.thrift.TException;
-import org.apache.thrift.TSerializer;
-
-/** InputStream for Thrift. */
-final class ThriftInputStream extends InputStream implements Drainable, KnownLength {
-
-  /**
-   * ThriftInput stream is initialized with a *message* , *serializer*
-   * *partial* is initially null.
-   */
-  @Nullable private TBase<?,?> message;
-  @Nullable private ByteArrayInputStream partial;
-  private final TSerializer serializer = new TSerializer();
-
-  /** Initialize message with @param message. */
-  public ThriftInputStream(TBase<?,?> message) {
-    this.message = message;
-  }
-
-  @Override
-  public int drainTo(OutputStream target) throws IOException {
-    int written = 0;
-    if (message != null) {
-      try {
-        byte[] bytes = serializer.serialize(message);
-        written = bytes.length;
-        target.write(bytes);
-        message = null;
-      } catch (TException e) {
-        throw Status.INTERNAL.withDescription("failed to serialize thrift message")
-            .withCause(e).asRuntimeException();
-      }
-    } else if (partial != null) {
-      written = (int) ByteStreams.copy(partial, target);
-      partial = null;
-    } else {
-      written = 0;
-    }
-    return written;
-  }
-
-  @Override
-  public int read() throws IOException {
-    if (message != null) {
-      try {
-        partial = new ByteArrayInputStream(serializer.serialize(message));
-        message = null;
-      } catch (TException e) {
-        throw Status.INTERNAL.withDescription("failed to serialize thrift message")
-            .withCause(e).asRuntimeException();
-      }
-    }
-    if (partial != null) {
-      return partial.read();
-    }
-    return -1;
-  }
-
-  @Override
-  public int available() throws IOException {
-    if (message != null) {
-      try {
-        partial = new ByteArrayInputStream(serializer.serialize(message));
-        message = null;
-        return partial.available();
-      } catch (TException e) {
-        throw Status.INTERNAL.withDescription("failed to serialize thrift message")
-            .withCause(e).asRuntimeException();
-      }
-    } else if (partial != null) {
-      return partial.available();
-    }
-    return 0;
-  }
-
-}
diff --git a/thrift/src/main/java/io/grpc/thrift/ThriftUtils.java b/thrift/src/main/java/io/grpc/thrift/ThriftUtils.java
deleted file mode 100644
index b29729ffd79..00000000000
--- a/thrift/src/main/java/io/grpc/thrift/ThriftUtils.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.thrift;
-
-import io.grpc.ExperimentalApi;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor.Marshaller;
-import io.grpc.Status;
-import io.grpc.internal.IoUtils;
-import java.io.IOException;
-import java.io.InputStream;
-import org.apache.thrift.TBase;
-import org.apache.thrift.TDeserializer;
-import org.apache.thrift.TException;
-import org.apache.thrift.TSerializer;
-
-@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2170")
-public final class ThriftUtils {
-
-  /** Create a {@code Marshaller} for thrift messages. */
-  public static <T extends TBase<T,?>> Marshaller<T> marshaller(final MessageFactory<T> factory) {
-
-    return new Marshaller<T>() {
-
-      @Override
-      public InputStream stream(T value) {
-        return new ThriftInputStream(value);
-      }
-
-      @Override
-      public T parse(InputStream stream) {
-        try {
-          byte[] bytes = IoUtils.toByteArray(stream);
-          TDeserializer deserializer = new TDeserializer();
-          T message = factory.newInstance();
-          deserializer.deserialize(message, bytes);
-          return message;
-        } catch (TException e) {
-          throw Status.INTERNAL.withDescription("Invalid Stream")
-              .withCause(e).asRuntimeException();
-        } catch (IOException e) {
-          throw Status.INTERNAL.withDescription("failed to read stream")
-              .withCause(e).asRuntimeException();
-        }
-      }
-    };
-  }
-
-  /** Produce a metadata marshaller. */
-  public static <T extends TBase<T,?>> Metadata.BinaryMarshaller<T> metadataMarshaller(
-      final MessageFactory<T> factory) {
-    return new Metadata.BinaryMarshaller<T>() {
-
-      @Override
-      public byte[] toBytes(T value) {
-        try {
-          TSerializer serializer = new TSerializer();
-          return serializer.serialize(value);
-        } catch (TException e) {
-          throw Status.INTERNAL.withDescription("Error in serializing Thrift Message")
-              .withCause(e).asRuntimeException();
-        }
-      }
-
-      @Override
-      public T parseBytes(byte[] serialized) {
-        try {
-          TDeserializer deserializer = new TDeserializer();
-          T message = factory.newInstance();
-          deserializer.deserialize(message, serialized);
-          return message;
-        } catch (TException e) {
-          throw Status.INTERNAL.withDescription("Invalid thrift Byte Sequence")
-              .withCause(e).asRuntimeException();
-        }
-      }
-    };
-  }
-
-  private ThriftUtils() {
-  }
-
-}
diff --git a/thrift/src/test/java/io/grpc/thrift/ThriftUtilsTest.java b/thrift/src/test/java/io/grpc/thrift/ThriftUtilsTest.java
deleted file mode 100644
index 187741cfbec..00000000000
--- a/thrift/src/test/java/io/grpc/thrift/ThriftUtilsTest.java
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * Copyright 2016, Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-package io.grpc.thrift;
-
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-import io.grpc.Drainable;
-import io.grpc.Metadata;
-import io.grpc.MethodDescriptor.Marshaller;
-import io.grpc.Status;
-import io.grpc.StatusRuntimeException;
-import io.grpc.internal.IoUtils;
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Collections;
-import org.apache.thrift.TException;
-import org.apache.thrift.TSerializer;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.JUnit4;
-
-/** Unit tests for {@link ThriftUtils}. */
-@RunWith(JUnit4.class)
-public class ThriftUtilsTest {
-  private Marshaller<Message> marshaller = ThriftUtils.marshaller(new MessageFactory<Message>() {
-    @Override
-    public Message newInstance() {
-      return new Message();
-    }
-  });
-
-  private Metadata.BinaryMarshaller<Message> metadataMarshaller = ThriftUtils.metadataMarshaller(
-      new MessageFactory<Message>() {
-        @Override
-        public Message newInstance() {
-          return new Message();
-        }
-      });
-
-  @Test
-  public void testRoundTrip() {
-    Message m = new Message();
-    m.i = 2;
-    m.b = true;
-    m.s = "string";
-    Message m2 = marshaller.parse(marshaller.stream(m));
-    assertNotSame(m, m2);
-    assertTrue(m.equals( m2 ));
-  }
-
-  @Test
-  public void parseInvalid() throws Exception {
-    InputStream is = new ByteArrayInputStream(new byte[] {-127});
-    try {
-      marshaller.parse(is);
-      fail("Expected exception");
-    } catch (StatusRuntimeException ex) {
-      assertEquals(Status.Code.INTERNAL, ex.getStatus().getCode());
-      assertTrue(ex.getCause() instanceof TException);
-    }
-  }
-
-  @Test
-  public void testLarge() throws Exception {
-    Message m = new Message();
-    // list size 80 MB
-    m.l = new ArrayList<Integer>(Collections.nCopies(20 * 1024 * 1024, 1000000007));
-    Message m2 = marshaller.parse(marshaller.stream(m));
-    assertNotSame(m, m2);
-    assertEquals(m.l.size(), m2.l.size());
-  }
-
-  @Test
-  public void metadataMarshaller_roundtrip() {
-    Message m = new Message();
-    m.i = 2;
-    assertEquals(m, metadataMarshaller.parseBytes(metadataMarshaller.toBytes(m)));
-  }
-
-  @Test
-  public void metadataMarshaller_invalid() {
-    try {
-      metadataMarshaller.parseBytes(new byte[] {-127});
-      fail("Expected exception");
-    } catch (Exception ex) {
-      assertTrue(ex.getCause() instanceof TException);
-    }
-  }
-
-  @Test
-  public void testAvailable() throws Exception {
-    Message m = new Message();
-    m.i = 10;
-    InputStream is = marshaller.stream(m);
-    assertEquals(is.available(), new TSerializer().serialize(m).length);
-    is.read();
-    assertEquals(is.available(), new TSerializer().serialize(m).length - 1);
-    while (is.read() != -1) {}
-    assertEquals(-1, is.read());
-    assertEquals(0, is.available());
-  }
-
-  @Test
-  public void testDrainTo_all() throws Exception {
-    Message m = new Message();
-    byte[] bytes = IoUtils.toByteArray(marshaller.stream(m));
-    InputStream is = marshaller.stream(m);
-    Drainable d = (Drainable) is;
-    ByteArrayOutputStream baos = new ByteArrayOutputStream();
-    int drained = d.drainTo(baos);
-    assertEquals(baos.size(), drained);
-    assertArrayEquals(bytes, baos.toByteArray());
-    assertEquals(0, is.available());
-  }
-
-  @Test
-  public void testDrainTo_partial() throws Exception {
-    Message m = new Message();
-    final byte[] bytes;
-    {
-      InputStream is = marshaller.stream(m);
-      is.read();
-      bytes = IoUtils.toByteArray(is);
-    }
-    InputStream is = marshaller.stream(m);
-    is.read();
-    Drainable d = (Drainable) is;
-    ByteArrayOutputStream baos = new ByteArrayOutputStream();
-    int drained = d.drainTo(baos);
-    assertEquals(baos.size(), drained);
-    assertArrayEquals(bytes, baos.toByteArray());
-    assertEquals(0, is.available());
-  }
-
-  @Test
-  public void testDrainTo_none() throws Exception {
-    Message m = new Message();
-    byte[] bytes = IoUtils.toByteArray(marshaller.stream(m));
-    InputStream is = marshaller.stream(m);
-    byte[] unused = IoUtils.toByteArray(is);
-    Drainable d = (Drainable) is;
-    ByteArrayOutputStream baos = new ByteArrayOutputStream();
-    assertEquals(0, d.drainTo(baos));
-    assertArrayEquals(new byte[0], baos.toByteArray());
-    assertEquals(0, is.available());
-  }
-}
\ No newline at end of file
diff --git a/thrift/src/test/thrift/messages.thrift b/thrift/src/test/thrift/messages.thrift
deleted file mode 100644
index 0f2f4323d33..00000000000
--- a/thrift/src/test/thrift/messages.thrift
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2016, Google Inc.
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//     * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-namespace java io.grpc.thrift
-
-struct Message {
-	1:i32 i,
-	2:bool b,
-	3:string s,
-	4:list<i32> l
-}
diff --git a/util/BUILD.bazel b/util/BUILD.bazel
new file mode 100644
index 00000000000..32d5a367b95
--- /dev/null
+++ b/util/BUILD.bazel
@@ -0,0 +1,21 @@
+load("@rules_java//java:defs.bzl", "java_library")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+
+java_library(
+    name = "util",
+    srcs = glob([
+        "src/main/java/io/grpc/util/*.java",
+    ]),
+    resources = glob([
+        "src/main/resources/**",
+    ]),
+    visibility = ["//visibility:public"],
+    deps = [
+        "//api",
+        "//core:internal",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+        artifact("org.codehaus.mojo:animal-sniffer-annotations"),
+    ],
+)
diff --git a/util/build.gradle b/util/build.gradle
new file mode 100644
index 00000000000..846b110b106
--- /dev/null
+++ b/util/build.gradle
@@ -0,0 +1,66 @@
+plugins {
+    id "java-library"
+    id "java-test-fixtures"
+    id "maven-publish"
+
+    id "me.champeau.jmh"
+    id "ru.vyarus.animalsniffer"
+}
+
+description = 'gRPC: Util'
+
+tasks.named("jar").configure {
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.util')
+    }
+}
+
+dependencies {
+    api project(':grpc-api')
+
+    implementation project(':grpc-core'),
+            libraries.animalsniffer.annotations,
+            libraries.guava
+    testImplementation libraries.guava.testlib,
+            testFixtures(project(':grpc-api')),
+            testFixtures(project(':grpc-core')),
+            project(':grpc-testing')
+
+    testFixturesApi project(':grpc-core')
+    testFixturesImplementation libraries.guava,
+            libraries.junit,
+            libraries.mockito.core,
+            testFixtures(project(':grpc-api')),
+            testFixtures(project(':grpc-core')),
+            project(':grpc-testing')
+    jmh project(':grpc-testing')
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    signature (libraries.signature.android) {
+        artifact {
+            extension = "signature"
+        }
+    }
+}
+
+animalsniffer {
+    // Don't check sourceSets.jmh
+    sourceSets = [
+        sourceSets.main,
+        sourceSets.test
+    ]
+}
+
+tasks.named("javadoc").configure {
+    exclude 'io/grpc/util/MultiChildLoadBalancer.java'
+    exclude 'io/grpc/util/OutlierDetectionLoadBalancer*'
+    exclude 'io/grpc/util/RandomSubsettingLoadBalancer*'
+    exclude 'io/grpc/util/RoundRobinLoadBalancer*'
+}
+
+components.java.withVariantsFromConfiguration(configurations.testFixturesApiElements) { skip() }
+components.java.withVariantsFromConfiguration(configurations.testFixturesRuntimeElements) { skip() }
diff --git a/util/src/jmh/java/io/grpc/util/HandlerRegistryBenchmark.java b/util/src/jmh/java/io/grpc/util/HandlerRegistryBenchmark.java
new file mode 100644
index 00000000000..3186e002dc8
--- /dev/null
+++ b/util/src/jmh/java/io/grpc/util/HandlerRegistryBenchmark.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2015 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.util;
+
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCall;
+import io.grpc.ServerCall.Listener;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.testing.TestMethodDescriptors;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Level;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.infra.Blackhole;
+
+/**
+ * Benchmark for {@link MutableHandlerRegistry}.
+ */
+@State(Scope.Benchmark)
+@Fork(1)
+public class HandlerRegistryBenchmark {
+
+  private static final String VALID_CHARACTERS =
+          "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.";
+
+  @Param({"50"})
+  public int nameLength;
+
+  @Param({"100"})
+  public int serviceCount;
+
+  @Param({"100"})
+  public int methodCountPerService;
+
+  private MutableHandlerRegistry registry;
+  private List<String> fullMethodNames;
+
+  /**
+   * Set up the registry.
+   */
+  @Setup(Level.Trial)
+  public void setup() throws Exception {
+    registry = new MutableHandlerRegistry();
+    fullMethodNames = new ArrayList<>(serviceCount * methodCountPerService);
+    for (int serviceIndex = 0; serviceIndex < serviceCount; ++serviceIndex) {
+      String serviceName = randomString();
+      ServerServiceDefinition.Builder serviceBuilder = ServerServiceDefinition.builder(serviceName);
+      for (int methodIndex = 0; methodIndex < methodCountPerService; ++methodIndex) {
+        String methodName = randomString();
+
+        MethodDescriptor<Void, Void> methodDescriptor = MethodDescriptor.<Void, Void>newBuilder()
+            .setType(MethodDescriptor.MethodType.UNKNOWN)
+            .setFullMethodName(MethodDescriptor.generateFullMethodName(serviceName, methodName))
+            .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+            .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
+            .build();
+        serviceBuilder.addMethod(methodDescriptor,
+            new ServerCallHandler<Void, Void>() {
+              @Override
+              public Listener<Void> startCall(ServerCall<Void, Void> call,
+                  Metadata headers) {
+                return null;
+              }
+            });
+        fullMethodNames.add(methodDescriptor.getFullMethodName());
+      }
+      registry.addService(serviceBuilder.build());
+    }
+  }
+
+  /**
+   * Benchmark the {@link MutableHandlerRegistry#lookupMethod(String)} throughput.
+   */
+  @Benchmark
+  public void lookupMethod(Blackhole bh) {
+    for (String fullMethodName : fullMethodNames) {
+      bh.consume(registry.lookupMethod(fullMethodName));
+    }
+  }
+
+  private String randomString() {
+    Random r = new Random();
+    char[] bytes = new char[nameLength];
+    for (int ix = 0; ix < nameLength; ++ix) {
+      int charIx = r.nextInt(VALID_CHARACTERS.length());
+      bytes[ix] = VALID_CHARACTERS.charAt(charIx);
+    }
+    return new String(bytes);
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/AdvancedTlsX509KeyManager.java b/util/src/main/java/io/grpc/util/AdvancedTlsX509KeyManager.java
new file mode 100644
index 00000000000..1f807cd405d
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/AdvancedTlsX509KeyManager.java
@@ -0,0 +1,312 @@
+/*
+ * Copyright 2021 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.util;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.errorprone.annotations.InlineMe;
+import io.grpc.ExperimentalApi;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.net.Socket;
+import java.security.GeneralSecurityException;
+import java.security.Principal;
+import java.security.PrivateKey;
+import java.security.cert.X509Certificate;
+import java.util.Arrays;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.X509ExtendedKeyManager;
+
+/**
+ * AdvancedTlsX509KeyManager is an {@code X509ExtendedKeyManager} that allows users to configure
+ * advanced TLS features, such as private key and certificate chain reloading.
+ */
+public final class AdvancedTlsX509KeyManager extends X509ExtendedKeyManager {
+  private static final Logger log = Logger.getLogger(AdvancedTlsX509KeyManager.class.getName());
+  // Minimum allowed period for refreshing files with credential information.
+  private static final int MINIMUM_REFRESH_PERIOD_IN_MINUTES = 1 ;
+  // The credential information to be sent to peers to prove our identity.
+  private volatile KeyInfo keyInfo;
+
+  @Override
+  public PrivateKey getPrivateKey(String alias) {
+    if (alias.equals("default")) {
+      return this.keyInfo.key;
+    }
+    return null;
+  }
+
+  @Override
+  public X509Certificate[] getCertificateChain(String alias) {
+    if (alias.equals("default")) {
+      return Arrays.copyOf(this.keyInfo.certs, this.keyInfo.certs.length);
+    }
+    return null;
+  }
+
+  @Override
+  public String[] getClientAliases(String keyType, Principal[] issuers) {
+    return new String[] {"default"};
+  }
+
+  @Override
+  public String chooseClientAlias(String[] keyType, Principal[] issuers, Socket socket) {
+    return "default";
+  }
+
+  @Override
+  public String chooseEngineClientAlias(String[] keyType, Principal[] issuers, SSLEngine engine) {
+    return "default";
+  }
+
+  @Override
+  public String[] getServerAliases(String keyType, Principal[] issuers) {
+    return new String[] {"default"};
+  }
+
+  @Override
+  public String chooseServerAlias(String keyType, Principal[] issuers, Socket socket) {
+    return "default";
+  }
+
+  @Override
+  public String chooseEngineServerAlias(String keyType, Principal[] issuers,
+      SSLEngine engine) {
+    return "default";
+  }
+
+  /**
+   * Updates the current cached private key and cert chains.
+   *
+   * @param key  the private key that is going to be used
+   * @param certs  the certificate chain that is going to be used
+   * @deprecated Use {@link #updateIdentityCredentials(X509Certificate[], PrivateKey)}
+   */
+  @Deprecated
+  @InlineMe(replacement = "this.updateIdentityCredentials(certs, key)")
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8024")
+  public void updateIdentityCredentials(PrivateKey key, X509Certificate[] certs) {
+    updateIdentityCredentials(certs, key);
+  }
+
+  /**
+   * Updates the current cached private key and cert chains.
+   *
+   * @param certs  the certificate chain that is going to be used
+   * @param key  the private key that is going to be used
+   */
+  public void updateIdentityCredentials(X509Certificate[] certs, PrivateKey key) {
+    this.keyInfo = new KeyInfo(checkNotNull(certs, "certs"), checkNotNull(key, "key"));
+  }
+
+  /**
+   * Schedules a {@code ScheduledExecutorService} to read certificate chains and private key from
+   * the local file paths periodically, and update the cached identity credentials if they are both
+   * updated. You must close the returned Closeable before calling this method again or other update
+   * methods ({@link AdvancedTlsX509KeyManager#updateIdentityCredentials}, {@link
+   * AdvancedTlsX509KeyManager#updateIdentityCredentials(File, File)}).
+   * Before scheduling the task, the method synchronously executes {@code  readAndUpdate} once. The
+   * minimum refresh period of 1 minute is enforced.
+   *
+   * @param certFile  the file on disk holding the certificate chain
+   * @param keyFile  the file on disk holding the private key
+   * @param period the period between successive read-and-update executions
+   * @param unit the time unit of the initialDelay and period parameters
+   * @param executor the executor service we use to read and update the credentials
+   * @return an object that caller should close when the file refreshes are not needed
+   */
+  public Closeable updateIdentityCredentials(File certFile, File keyFile,
+      long period, TimeUnit unit, ScheduledExecutorService executor) throws IOException,
+      GeneralSecurityException {
+    UpdateResult newResult = readAndUpdate(certFile, keyFile, 0, 0);
+    if (!newResult.success) {
+      throw new GeneralSecurityException(
+          "Files were unmodified before their initial update. Probably a bug.");
+    }
+    if (checkNotNull(unit, "unit").toMinutes(period) < MINIMUM_REFRESH_PERIOD_IN_MINUTES) {
+      log.log(Level.FINE,
+          "Provided refresh period of {0} {1} is too small. Default value of {2} minute(s) "
+          + "will be used.", new Object[] {period, unit.name(), MINIMUM_REFRESH_PERIOD_IN_MINUTES});
+      period = MINIMUM_REFRESH_PERIOD_IN_MINUTES;
+      unit = TimeUnit.MINUTES;
+    }
+    final ScheduledFuture<?> future =
+        checkNotNull(executor, "executor").scheduleWithFixedDelay(
+            new LoadFilePathExecution(certFile, keyFile), period, period, unit);
+    return () -> future.cancel(false);
+  }
+
+  /**
+   * Updates certificate chains and the private key from the local file paths.
+   *
+   * @param certFile  the file on disk holding the certificate chain
+   * @param keyFile  the file on disk holding the private key
+   */
+  public void updateIdentityCredentials(File certFile, File keyFile) throws IOException,
+      GeneralSecurityException {
+    UpdateResult newResult = readAndUpdate(certFile, keyFile, 0, 0);
+    if (!newResult.success) {
+      throw new GeneralSecurityException(
+          "Files were unmodified before their initial update. Probably a bug.");
+    }
+  }
+
+  /**
+   * Updates the private key and certificate chains from the local file paths.
+   *
+   * @param keyFile  the file on disk holding the private key
+   * @param certFile  the file on disk holding the certificate chain
+   * @deprecated Use {@link #updateIdentityCredentials(File, File)} instead.
+   */
+  @Deprecated
+  @InlineMe(replacement = "this.updateIdentityCredentials(certFile, keyFile)")
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8024")
+  public void updateIdentityCredentialsFromFile(File keyFile, File certFile) throws IOException,
+      GeneralSecurityException {
+    updateIdentityCredentials(certFile, keyFile);
+  }
+
+  /**
+   * Schedules a {@code ScheduledExecutorService} to read private key and certificate chains from
+   * the local file paths periodically, and update the cached identity credentials if they are both
+   * updated. You must close the returned Closeable before calling this method again or other update
+   * methods ({@link AdvancedTlsX509KeyManager#updateIdentityCredentials}, {@link
+   * AdvancedTlsX509KeyManager#updateIdentityCredentials(File, File)}).
+   * Before scheduling the task, the method synchronously executes {@code  readAndUpdate} once. The
+   * minimum refresh period of 1 minute is enforced.
+   *
+   * @param keyFile  the file on disk holding the private key
+   * @param certFile  the file on disk holding the certificate chain
+   * @param period the period between successive read-and-update executions
+   * @param unit the time unit of the initialDelay and period parameters
+   * @param executor the executor service we use to read and update the credentials
+   * @return an object that caller should close when the file refreshes are not needed
+   * @deprecated Use {@link
+   * #updateIdentityCredentials(File, File, long, TimeUnit, ScheduledExecutorService)} instead.
+   */
+  @Deprecated
+  @InlineMe(replacement =
+      "this.updateIdentityCredentials(certFile, keyFile, period, unit, executor)")
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8024")
+  public Closeable updateIdentityCredentialsFromFile(File keyFile, File certFile,
+      long period, TimeUnit unit, ScheduledExecutorService executor) throws IOException,
+      GeneralSecurityException {
+    return updateIdentityCredentials(certFile, keyFile, period, unit, executor);
+  }
+
+  private static class KeyInfo {
+    // The private key and the cert chain we will use to send to peers to prove our identity.
+    final X509Certificate[] certs;
+    final PrivateKey key;
+
+    public KeyInfo(X509Certificate[] certs, PrivateKey key) {
+      this.certs = certs;
+      this.key = key;
+    }
+  }
+
+  private class LoadFilePathExecution implements Runnable {
+    File keyFile;
+    File certFile;
+    long currentCertTime;
+    long currentKeyTime;
+
+    public LoadFilePathExecution(File certFile, File keyFile) {
+      this.certFile = certFile;
+      this.keyFile = keyFile;
+      this.currentCertTime = 0;
+      this.currentKeyTime = 0;
+    }
+
+    @Override
+    public void run() {
+      try {
+        UpdateResult newResult = readAndUpdate(this.certFile, this.keyFile, this.currentKeyTime,
+            this.currentCertTime);
+        if (newResult.success) {
+          this.currentCertTime = newResult.certTime;
+          this.currentKeyTime = newResult.keyTime;
+        }
+      } catch (IOException | GeneralSecurityException e) {
+        log.log(Level.SEVERE, String.format("Failed refreshing certificate and private key"
+                + " chain from files. Using previous ones (certFile lastModified = %s, keyFile "
+                + "lastModified = %s)", certFile.lastModified(), keyFile.lastModified()), e);
+      }
+    }
+  }
+
+  private static class UpdateResult {
+    boolean success;
+    long certTime;
+    long keyTime;
+
+    public UpdateResult(boolean success, long certTime, long keyTime) {
+      this.success = success;
+      this.certTime = certTime;
+      this.keyTime = keyTime;
+    }
+  }
+
+  /**
+   * Reads the private key and certificates specified in the path locations. Updates {@code key} and
+   * {@code cert} if both of their modified time changed since last read.
+   *
+   * @param certFile  the file on disk holding the certificate chain
+   * @param keyFile  the file on disk holding the private key
+   * @param oldKeyTime the time when the private key file is modified during last execution
+   * @param oldCertTime the time when the certificate chain file is modified during last execution
+   * @return the result of this update execution
+   */
+  private UpdateResult readAndUpdate(File certFile, File keyFile, long oldKeyTime, long oldCertTime)
+      throws IOException, GeneralSecurityException {
+    long newKeyTime = checkNotNull(keyFile, "keyFile").lastModified();
+    long newCertTime = checkNotNull(certFile, "certFile").lastModified();
+    // We only update when both the key and the certs are updated.
+    if (newKeyTime != oldKeyTime && newCertTime != oldCertTime) {
+      FileInputStream keyInputStream = new FileInputStream(keyFile);
+      try {
+        PrivateKey key = CertificateUtils.getPrivateKey(keyInputStream);
+        FileInputStream certInputStream = new FileInputStream(certFile);
+        try {
+          X509Certificate[] certs = CertificateUtils.getX509Certificates(certInputStream);
+          updateIdentityCredentials(certs, key);
+          return new UpdateResult(true, newKeyTime, newCertTime);
+        } finally {
+          certInputStream.close();
+        }
+      } finally {
+        keyInputStream.close();
+      }
+    }
+    return new UpdateResult(false, oldKeyTime, oldCertTime);
+  }
+
+  /**
+   * Mainly used to avoid throwing IO Exceptions in java.io.Closeable.
+   */
+  public interface Closeable extends java.io.Closeable {
+    @Override
+    void close();
+  }
+}
+
diff --git a/util/src/main/java/io/grpc/util/AdvancedTlsX509TrustManager.java b/util/src/main/java/io/grpc/util/AdvancedTlsX509TrustManager.java
new file mode 100644
index 00000000000..0739fa3d453
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/AdvancedTlsX509TrustManager.java
@@ -0,0 +1,472 @@
+/*
+ * Copyright 2021 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.util;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.errorprone.annotations.InlineMe;
+import io.grpc.ExperimentalApi;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.net.Socket;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509ExtendedTrustManager;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+
+/**
+ * AdvancedTlsX509TrustManager is an {@code X509ExtendedTrustManager} that allows users to configure
+ * advanced TLS features, such as root certificate reloading and peer cert custom verification.
+ * The basic instantiation pattern is
+ * <code>new Builder().build().useSystemDefaultTrustCerts();</code>
+ *
+ * <p>For Android users: this class is only supported in API level 24 and above.
+ */
+@IgnoreJRERequirement
+public final class AdvancedTlsX509TrustManager extends X509ExtendedTrustManager {
+  private static final Logger log = Logger.getLogger(AdvancedTlsX509TrustManager.class.getName());
+
+  // Minimum allowed period for refreshing files with credential information.
+  private static final int MINIMUM_REFRESH_PERIOD_IN_MINUTES = 1;
+  private static final String NOT_ENOUGH_INFO_MESSAGE =
+      "Not enough information to validate peer. SSLEngine or Socket required.";
+  private final Verification verification;
+  private final SslSocketAndEnginePeerVerifier socketAndEnginePeerVerifier;
+
+  // The delegated trust manager used to perform traditional certificate verification.
+  private volatile X509ExtendedTrustManager delegateManager = null;
+
+  private AdvancedTlsX509TrustManager(Verification verification,
+      SslSocketAndEnginePeerVerifier socketAndEnginePeerVerifier) {
+    this.verification = verification;
+    this.socketAndEnginePeerVerifier = socketAndEnginePeerVerifier;
+  }
+
+  @Override
+  public void checkClientTrusted(X509Certificate[] chain, String authType)
+      throws CertificateException {
+    throw new CertificateException(NOT_ENOUGH_INFO_MESSAGE);
+  }
+
+  @Override
+  public void checkClientTrusted(X509Certificate[] chain, String authType, Socket socket)
+      throws CertificateException {
+    checkTrusted(chain, authType, null, socket, false);
+  }
+
+  @Override
+  public void checkClientTrusted(X509Certificate[] chain, String authType, SSLEngine engine)
+      throws CertificateException {
+    checkTrusted(chain, authType, engine, null, false);
+  }
+
+  @Override
+  public void checkServerTrusted(X509Certificate[] chain,  String authType, SSLEngine engine)
+      throws CertificateException {
+    checkTrusted(chain, authType, engine, null, true);
+  }
+
+  @Override
+  public void checkServerTrusted(X509Certificate[] chain, String authType)
+      throws CertificateException {
+    throw new CertificateException(NOT_ENOUGH_INFO_MESSAGE);
+  }
+
+  @Override
+  public void checkServerTrusted(X509Certificate[] chain, String authType, Socket socket)
+      throws CertificateException {
+    checkTrusted(chain, authType, null, socket, true);
+  }
+
+  @Override
+  public X509Certificate[] getAcceptedIssuers() {
+    if (this.delegateManager == null) {
+      return new X509Certificate[0];
+    }
+    return this.delegateManager.getAcceptedIssuers();
+  }
+
+  /**
+   * Uses the default trust certificates stored on user's local system.
+   * After this is used, functions that will provide new credential
+   * data(e.g. updateTrustCredentials) should not be called.
+   */
+  public void useSystemDefaultTrustCerts() throws CertificateException, KeyStoreException,
+      NoSuchAlgorithmException {
+    // Passing a null value of KeyStore would make {@code TrustManagerFactory} attempt to use
+    // system-default trust CA certs.
+    this.delegateManager = createDelegateTrustManager(null);
+  }
+
+  private static X509ExtendedTrustManager createDelegateTrustManager(KeyStore keyStore)
+      throws CertificateException, KeyStoreException, NoSuchAlgorithmException {
+    TrustManagerFactory tmf = TrustManagerFactory.getInstance(
+        TrustManagerFactory.getDefaultAlgorithm());
+    tmf.init(keyStore);
+    X509ExtendedTrustManager delegateManager = null;
+    TrustManager[] tms = tmf.getTrustManagers();
+    // Iterate over the returned trust managers, looking for an instance of X509TrustManager.
+    // If found, use that as the delegate trust manager.
+    for (TrustManager tm : tms) {
+      if (tm instanceof X509ExtendedTrustManager) {
+        delegateManager = (X509ExtendedTrustManager) tm;
+        break;
+      }
+    }
+    if (delegateManager == null) {
+      throw new CertificateException(
+          "Failed to find X509ExtendedTrustManager with default TrustManager algorithm "
+              + TrustManagerFactory.getDefaultAlgorithm());
+    }
+    return delegateManager;
+  }
+
+  private void checkTrusted(X509Certificate[] chain, String authType, SSLEngine sslEngine,
+      Socket socket, boolean checkingServer) throws CertificateException {
+    if (chain == null || chain.length == 0) {
+      throw new IllegalArgumentException(
+          "Want certificate verification but got null or empty certificates");
+    }
+    if (sslEngine == null && socket == null) {
+      throw new CertificateException(NOT_ENOUGH_INFO_MESSAGE);
+    }
+    if (this.verification != Verification.INSECURELY_SKIP_ALL_VERIFICATION) {
+      X509ExtendedTrustManager currentDelegateManager = this.delegateManager;
+      if (currentDelegateManager == null) {
+        throw new CertificateException("No trust roots configured");
+      }
+      if (checkingServer) {
+        String algorithm = this.verification == Verification.CERTIFICATE_AND_HOST_NAME_VERIFICATION
+            ? "HTTPS" : "";
+        if (sslEngine != null) {
+          SSLParameters sslParams = sslEngine.getSSLParameters();
+          sslParams.setEndpointIdentificationAlgorithm(algorithm);
+          sslEngine.setSSLParameters(sslParams);
+          currentDelegateManager.checkServerTrusted(chain, authType, sslEngine);
+        } else {
+          if (!(socket instanceof SSLSocket)) {
+            throw new CertificateException("socket is not a type of SSLSocket");
+          }
+          SSLSocket sslSocket = (SSLSocket)socket;
+          SSLParameters sslParams = sslSocket.getSSLParameters();
+          sslParams.setEndpointIdentificationAlgorithm(algorithm);
+          sslSocket.setSSLParameters(sslParams);
+          currentDelegateManager.checkServerTrusted(chain, authType, sslSocket);
+        }
+      } else {
+        if (sslEngine != null) {
+          currentDelegateManager.checkClientTrusted(chain, authType, sslEngine);
+        } else {
+          currentDelegateManager.checkClientTrusted(chain, authType, socket);
+        }
+      }
+    }
+    // Perform the additional peer cert check.
+    if (socketAndEnginePeerVerifier != null) {
+      if (sslEngine != null) {
+        socketAndEnginePeerVerifier.verifyPeerCertificate(chain, authType, sslEngine);
+      } else {
+        socketAndEnginePeerVerifier.verifyPeerCertificate(chain, authType, socket);
+      }
+    }
+  }
+
+  /**
+   * Updates the current cached trust certificates as well as the key store.
+   *
+   * @param trustCerts the trust certificates that are going to be used
+   */
+  public void updateTrustCredentials(X509Certificate[] trustCerts) throws IOException,
+      GeneralSecurityException {
+    checkNotNull(trustCerts, "trustCerts");
+    KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
+    keyStore.load(null, null);
+    int i = 1;
+    for (X509Certificate cert: trustCerts) {
+      String alias = Integer.toString(i);
+      keyStore.setCertificateEntry(alias, cert);
+      i++;
+    }
+    this.delegateManager = createDelegateTrustManager(keyStore);
+  }
+
+  /**
+   * Updates the trust certificates from a local file path.
+   *
+   * @param trustCertFile  the file on disk holding the trust certificates
+   */
+  public void updateTrustCredentials(File trustCertFile) throws IOException,
+      GeneralSecurityException {
+    long updatedTime = readAndUpdate(trustCertFile, 0);
+    if (updatedTime == 0) {
+      throw new GeneralSecurityException(
+          "Files were unmodified before their initial update. Probably a bug.");
+    }
+  }
+
+  /**
+   * Schedules a {@code ScheduledExecutorService} to read trust certificates from a local file path
+   * periodically, and updates the cached trust certs if there is an update. You must close the
+   * returned Closeable before calling this method again or other update methods
+   * ({@link AdvancedTlsX509TrustManager#useSystemDefaultTrustCerts()},
+   * {@link AdvancedTlsX509TrustManager#updateTrustCredentials(X509Certificate[])},
+   * {@link AdvancedTlsX509TrustManager#updateTrustCredentialsFromFile(File)}).
+   * Before scheduling the task, the method synchronously reads and updates trust certificates once.
+   * If the provided period is less than 1 minute, it is automatically adjusted to 1 minute.
+   *
+   * @param trustCertFile  the file on disk holding the trust certificates
+   * @param period the period between successive read-and-update executions
+   * @param unit the time unit of the initialDelay and period parameters
+   * @param executor the executor service we use to read and update the credentials
+   * @return an object that caller should close when the file refreshes are not needed
+   */
+  public Closeable updateTrustCredentials(File trustCertFile, long period, TimeUnit unit,
+      ScheduledExecutorService executor) throws IOException, GeneralSecurityException {
+    long updatedTime = readAndUpdate(trustCertFile, 0);
+    if (updatedTime == 0) {
+      throw new GeneralSecurityException(
+          "Files were unmodified before their initial update. Probably a bug.");
+    }
+    if (checkNotNull(unit, "unit").toMinutes(period) < MINIMUM_REFRESH_PERIOD_IN_MINUTES) {
+      log.log(Level.FINE,
+          "Provided refresh period of {0} {1} is too small. Default value of {2} minute(s) "
+          + "will be used.", new Object[] {period, unit.name(), MINIMUM_REFRESH_PERIOD_IN_MINUTES});
+      period = MINIMUM_REFRESH_PERIOD_IN_MINUTES;
+      unit = TimeUnit.MINUTES;
+    }
+    final ScheduledFuture<?> future =
+        checkNotNull(executor, "executor").scheduleWithFixedDelay(
+            new LoadFilePathExecution(trustCertFile, updatedTime), period, period, unit);
+    return () -> future.cancel(false);
+  }
+
+  /**
+   * Schedules a {@code ScheduledExecutorService} to read trust certificates from a local file path
+   * periodically, and updates the cached trust certs if there is an update. You must close the
+   * returned Closeable before calling this method again or other update methods
+   * ({@link AdvancedTlsX509TrustManager#useSystemDefaultTrustCerts()},
+   * {@link AdvancedTlsX509TrustManager#updateTrustCredentials(X509Certificate[])},
+   * {@link AdvancedTlsX509TrustManager#updateTrustCredentialsFromFile(File)}).
+   * Before scheduling the task, the method synchronously reads and updates trust certificates once.
+   * If the provided period is less than 1 minute, it is automatically adjusted to 1 minute.
+   *
+   * @param trustCertFile  the file on disk holding the trust certificates
+   * @param period the period between successive read-and-update executions
+   * @param unit the time unit of the initialDelay and period parameters
+   * @param executor the executor service we use to read and update the credentials
+   * @return an object that caller should close when the file refreshes are not needed
+   * @deprecated Use {@link #updateTrustCredentials(File, long ,TimeUnit, ScheduledExecutorService)}
+   */
+  @Deprecated
+  @InlineMe(replacement = "this.updateTrustCredentials(trustCertFile, period, unit, executor)")
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8024")
+  public Closeable updateTrustCredentialsFromFile(File trustCertFile, long period, TimeUnit unit,
+      ScheduledExecutorService executor) throws IOException, GeneralSecurityException {
+    return updateTrustCredentials(trustCertFile, period, unit, executor);
+  }
+
+  /**
+   * Updates the trust certificates from a local file path.
+   *
+   * @param trustCertFile  the file on disk holding the trust certificates
+   * @deprecated Use {@link #updateTrustCredentials(File)}
+   */
+  @Deprecated
+  @InlineMe(replacement = "this.updateTrustCredentials(trustCertFile)")
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/8024")
+  public void updateTrustCredentialsFromFile(File trustCertFile) throws IOException,
+      GeneralSecurityException {
+    updateTrustCredentials(trustCertFile);
+  }
+
+  private class LoadFilePathExecution implements Runnable {
+    File file;
+    long currentTime;
+
+    public LoadFilePathExecution(File file, long currentTime) {
+      this.file = file;
+      this.currentTime = currentTime;
+    }
+
+    @Override
+    public void run() {
+      try {
+        this.currentTime = readAndUpdate(this.file, this.currentTime);
+      } catch (IOException | GeneralSecurityException e) {
+        log.log(Level.SEVERE, String.format("Failed refreshing trust CAs from file. Using "
+            + "previous CAs (file lastModified = %s)", file.lastModified()), e);
+      }
+    }
+  }
+
+  /**
+   * Reads the trust certificates specified in the path location, and updates the key store if the
+   * modified time has changed since last read.
+   *
+   * @param trustCertFile  the file on disk holding the trust certificates
+   * @param oldTime the time when the trust file is modified during last execution
+   * @return oldTime if failed or the modified time is not changed, otherwise the new modified time
+   */
+  private long readAndUpdate(File trustCertFile, long oldTime)
+      throws IOException, GeneralSecurityException {
+    long newTime = checkNotNull(trustCertFile, "trustCertFile").lastModified();
+    if (newTime == 0) {
+      throw new IOException(
+          "Certificate file not found or not readable: " + trustCertFile.getAbsolutePath());
+    }
+    if (newTime == oldTime) {
+      return oldTime;
+    }
+    FileInputStream inputStream = new FileInputStream(trustCertFile);
+    try {
+      X509Certificate[] certificates = CertificateUtils.getX509Certificates(inputStream);
+      updateTrustCredentials(certificates);
+      return newTime;
+    } finally {
+      inputStream.close();
+    }
+  }
+
+  // Mainly used to avoid throwing IO Exceptions in java.io.Closeable.
+  public interface Closeable extends java.io.Closeable {
+    @Override
+    void close();
+  }
+
+  public static Builder newBuilder() {
+    return new Builder();
+  }
+
+  /**
+   * The verification mode when authenticating the peer certificate.
+   */
+  public enum Verification {
+    /**
+     * This is the DEFAULT and RECOMMENDED mode for most applications.
+     * Setting this on the client side performs both certificate and hostname verification, while
+     * setting it on the server side only performs certificate verification.
+     */
+    CERTIFICATE_AND_HOST_NAME_VERIFICATION,
+    /**
+     * DANGEROUS: Use trusted credentials to verify the certificate, but clients will not verify the
+     * certificate is for the expected host. This setting is only appropriate when accompanied by
+     * proper additional peer identity checks set through SslSocketAndEnginePeerVerifier. Failing to
+     * do so will leave your applications vulnerable to MITM attacks.
+     * This setting has the same behavior on server-side as CERTIFICATE_AND_HOST_NAME_VERIFICATION.
+     */
+    CERTIFICATE_ONLY_VERIFICATION,
+    /**
+     * DANGEROUS: This SHOULD be used by advanced user intended to implement the entire verification
+     * logic themselves {@link SslSocketAndEnginePeerVerifier}) themselves. This includes: <br>
+     * 1. Proper verification of the peer certificate chain <br>
+     * 2. Proper checks of the identity of the peer certificate <br>
+     * Failing to do so will leave your application without any TLS-related protection. Keep in mind
+     * that any loaded trust certificates will be ignored when using this mode.
+     */
+    INSECURELY_SKIP_ALL_VERIFICATION,
+  }
+
+  // Additional custom peer verification check.
+  // It will be used when checkClientTrusted/checkServerTrusted is called with the {@code Socket} or
+  // the {@code SSLEngine} parameter.
+  public interface SslSocketAndEnginePeerVerifier {
+    /**
+     * Verifies the peer certificate chain. For more information, please refer to
+     * {@code X509ExtendedTrustManager}.
+     *
+     * @param  peerCertChain  the certificate chain sent from the peer
+     * @param  authType the key exchange algorithm used, e.g. "RSA", "DHE_DSS", etc
+     * @param  socket the socket used for this connection. This parameter can be null, which
+     *         indicates that implementations need not check the ssl parameters
+     */
+    void verifyPeerCertificate(X509Certificate[] peerCertChain,  String authType, Socket socket)
+        throws CertificateException;
+
+    /**
+     * Verifies the peer certificate chain. For more information, please refer to
+     * {@code X509ExtendedTrustManager}.
+     *
+     * @param  peerCertChain  the certificate chain sent from the peer
+     * @param  authType the key exchange algorithm used, e.g. "RSA", "DHE_DSS", etc
+     * @param  engine the engine used for this connection. This parameter can be null, which
+     *         indicates that implementations need not check the ssl parameters
+     */
+    void verifyPeerCertificate(X509Certificate[] peerCertChain, String authType, SSLEngine engine)
+        throws CertificateException;
+  }
+
+  /**
+   * Builds a new {@link AdvancedTlsX509TrustManager}. By default, no trust certificates are loaded
+   * after the build. To load them, use one of the following methods: {@link
+   * AdvancedTlsX509TrustManager#updateTrustCredentials(X509Certificate[])}, {@link
+   * AdvancedTlsX509TrustManager#updateTrustCredentials(File, long, TimeUnit,
+   * ScheduledExecutorService)}, {@link AdvancedTlsX509TrustManager#updateTrustCredentials
+   * (File, long, TimeUnit, ScheduledExecutorService)}.
+   */
+  public static final class Builder {
+
+    private Verification verification = Verification.CERTIFICATE_AND_HOST_NAME_VERIFICATION;
+    private SslSocketAndEnginePeerVerifier socketAndEnginePeerVerifier;
+
+    private Builder() {}
+
+    /**
+     * Sets {@link Verification}, mode when authenticating the peer certificate. By default, {@link
+     * Verification#CERTIFICATE_AND_HOST_NAME_VERIFICATION} value is used.
+     *
+     * @param  verification Verification mode used for the current AdvancedTlsX509TrustManager
+     * @return Builder with set verification
+     */
+    public Builder setVerification(Verification verification) {
+      this.verification = verification;
+      return this;
+    }
+
+    /**
+     * Sets {@link SslSocketAndEnginePeerVerifier}, which methods will be called in addition to
+     * verifying certificates.
+     *
+     * @param  verifier SslSocketAndEnginePeerVerifier used for the current
+     *         AdvancedTlsX509TrustManager
+     * @return Builder with set verifier
+     */
+    public Builder setSslSocketAndEnginePeerVerifier(SslSocketAndEnginePeerVerifier verifier) {
+      this.socketAndEnginePeerVerifier = verifier;
+      return this;
+    }
+
+    public AdvancedTlsX509TrustManager build() throws CertificateException {
+      return new AdvancedTlsX509TrustManager(this.verification, this.socketAndEnginePeerVerifier);
+    }
+  }
+}
+
diff --git a/util/src/main/java/io/grpc/util/CertificateUtils.java b/util/src/main/java/io/grpc/util/CertificateUtils.java
new file mode 100644
index 00000000000..e7082f177ab
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/CertificateUtils.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2021 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.util;
+
+import com.google.common.io.BaseEncoding;
+import io.grpc.ExperimentalApi;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.security.KeyFactory;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.util.Collection;
+
+/**
+ * Contains certificate/key PEM file utility method(s).
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/8024")
+public final class CertificateUtils {
+  /**
+   * Generates X509Certificate array from a PEM file.
+   * The PEM file should contain one or more items in Base64 encoding, each with
+   * plain-text headers and footers
+   * (e.g. -----BEGIN CERTIFICATE----- and -----END CERTIFICATE-----).
+   *
+   * @param inputStream is a {@link InputStream} from the certificate files
+   */
+  public static X509Certificate[] getX509Certificates(InputStream inputStream)
+      throws CertificateException {
+    CertificateFactory factory = CertificateFactory.getInstance("X.509");
+    Collection<? extends Certificate> certs = factory.generateCertificates(inputStream);
+    return certs.toArray(new X509Certificate[0]);
+  }
+
+  /**
+   * Generates a {@link PrivateKey} from a PEM file.
+   * The key should be PKCS #8 formatted. The key algorithm should be "RSA" or "EC".
+   * The PEM file should contain one item in Base64 encoding, with plain-text headers and footers
+   * (e.g. -----BEGIN PRIVATE KEY----- and -----END PRIVATE KEY-----).
+   *
+   * @param inputStream is a {@link InputStream} from the private key file
+   */
+  public static PrivateKey getPrivateKey(InputStream inputStream)
+      throws UnsupportedEncodingException, IOException, NoSuchAlgorithmException,
+      InvalidKeySpecException {
+    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
+    String line;
+    while ((line = reader.readLine()) != null) {
+      if ("-----BEGIN PRIVATE KEY-----".equals(line)) {
+        break;
+      }
+    }
+    StringBuilder keyContent = new StringBuilder();
+    while ((line = reader.readLine()) != null) {
+      if ("-----END PRIVATE KEY-----".equals(line)) {
+        break;
+      }
+      keyContent.append(line);
+    }
+    byte[] decodedKeyBytes = BaseEncoding.base64().decode(keyContent.toString());
+    PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKeyBytes);
+    try {
+      return KeyFactory.getInstance("RSA").generatePrivate(keySpec);
+    } catch (InvalidKeySpecException ignore) {
+      try {
+        return KeyFactory.getInstance("EC").generatePrivate(keySpec);
+      } catch (InvalidKeySpecException e) {
+        throw new InvalidKeySpecException("Neither RSA nor EC worked", e);
+      }
+    }
+  }
+}
+
diff --git a/util/src/main/java/io/grpc/util/ForwardingClientStreamTracer.java b/util/src/main/java/io/grpc/util/ForwardingClientStreamTracer.java
new file mode 100644
index 00000000000..9c9998571e5
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/ForwardingClientStreamTracer.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2019 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.util;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.Attributes;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ExperimentalApi;
+import io.grpc.Metadata;
+import io.grpc.Status;
+
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2861")
+public abstract class ForwardingClientStreamTracer extends ClientStreamTracer {
+  /** Returns the underlying {@code ClientStreamTracer}. */
+  protected abstract ClientStreamTracer delegate();
+
+  @Override
+  public void streamCreated(Attributes transportAttrs, Metadata headers) {
+    delegate().streamCreated(transportAttrs, headers);
+  }
+
+  @Override
+  public void createPendingStream() {
+    delegate().createPendingStream();
+  }
+
+  @Override
+  public void outboundHeaders() {
+    delegate().outboundHeaders();
+  }
+
+  @Override
+  public void inboundHeaders() {
+    delegate().inboundHeaders();
+  }
+
+  @Override
+  public void inboundHeaders(Metadata headers) {
+    delegate().inboundHeaders(headers);
+  }
+
+  @Override
+  public void inboundTrailers(Metadata trailers) {
+    delegate().inboundTrailers(trailers);
+  }
+
+  @Override
+  public void addOptionalLabel(String key, String value) {
+    delegate().addOptionalLabel(key, value);
+  }
+
+  @Override
+  public void streamClosed(Status status) {
+    delegate().streamClosed(status);
+  }
+
+  @Override
+  public void outboundMessage(int seqNo) {
+    delegate().outboundMessage(seqNo);
+  }
+
+  @Override
+  public void inboundMessage(int seqNo) {
+    delegate().inboundMessage(seqNo);
+  }
+
+  @Override
+  public void outboundMessageSent(int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+    delegate().outboundMessageSent(seqNo, optionalWireSize, optionalUncompressedSize);
+  }
+
+  @Override
+  public void inboundMessageRead(int seqNo, long optionalWireSize, long optionalUncompressedSize) {
+    delegate().inboundMessageRead(seqNo, optionalWireSize, optionalUncompressedSize);
+  }
+
+  @Override
+  public void outboundWireSize(long bytes) {
+    delegate().outboundWireSize(bytes);
+  }
+
+  @Override
+  public void outboundUncompressedSize(long bytes) {
+    delegate().outboundUncompressedSize(bytes);
+  }
+
+  @Override
+  public void inboundWireSize(long bytes) {
+    delegate().inboundWireSize(bytes);
+  }
+
+  @Override
+  public void inboundUncompressedSize(long bytes) {
+    delegate().inboundUncompressedSize(bytes);
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/ForwardingLoadBalancer.java b/util/src/main/java/io/grpc/util/ForwardingLoadBalancer.java
new file mode 100644
index 00000000000..cefcbf344ea
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/ForwardingLoadBalancer.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2018 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.util;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.ExperimentalApi;
+import io.grpc.LoadBalancer;
+import io.grpc.Status;
+
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+public abstract class ForwardingLoadBalancer extends LoadBalancer {
+  /**
+   * Returns the underlying balancer.
+   */
+  protected abstract LoadBalancer delegate();
+
+  @Override
+  public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    delegate().handleResolvedAddresses(resolvedAddresses);
+  }
+
+  @Override
+  public void handleNameResolutionError(Status error) {
+    delegate().handleNameResolutionError(error);
+  }
+
+  @Deprecated
+  @Override
+  public void handleSubchannelState(
+      Subchannel subchannel, ConnectivityStateInfo stateInfo) {
+    delegate().handleSubchannelState(subchannel, stateInfo);
+  }
+
+  @Override
+  public void shutdown() {
+    delegate().shutdown();
+  }
+
+  @Override
+  public boolean canHandleEmptyAddressListFromNameResolution() {
+    return delegate().canHandleEmptyAddressListFromNameResolution();
+  }
+
+  @Override
+  public void requestConnection() {
+    delegate().requestConnection();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/ForwardingLoadBalancerHelper.java b/util/src/main/java/io/grpc/util/ForwardingLoadBalancerHelper.java
new file mode 100644
index 00000000000..338903fc5fc
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/ForwardingLoadBalancerHelper.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2018 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.util;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.ChannelCredentials;
+import io.grpc.ChannelLogger;
+import io.grpc.ConnectivityState;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.ExperimentalApi;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.MetricRecorder;
+import io.grpc.NameResolver;
+import io.grpc.NameResolverRegistry;
+import io.grpc.SynchronizationContext;
+import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
+
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+public abstract class ForwardingLoadBalancerHelper extends LoadBalancer.Helper {
+  /**
+   * Returns the underlying helper.
+   */
+  protected abstract LoadBalancer.Helper delegate();
+
+  @Override
+  public Subchannel createSubchannel(CreateSubchannelArgs args) {
+    return delegate().createSubchannel(args);
+  }
+
+  @Override
+  public  ManagedChannel createOobChannel(EquivalentAddressGroup eag, String authority) {
+    return delegate().createOobChannel(eag, authority);
+  }
+
+  @Override
+  public  ManagedChannel createOobChannel(List<EquivalentAddressGroup> eag, String authority) {
+    return delegate().createOobChannel(eag, authority);
+  }
+
+  @Override
+  public void updateOobChannelAddresses(ManagedChannel channel, EquivalentAddressGroup eag) {
+    delegate().updateOobChannelAddresses(channel, eag);
+  }
+
+  @Override
+  public void updateOobChannelAddresses(ManagedChannel channel, List<EquivalentAddressGroup> eag) {
+    delegate().updateOobChannelAddresses(channel, eag);
+  }
+
+  @Deprecated
+  @Override
+  public ManagedChannelBuilder<?> createResolvingOobChannelBuilder(String target) {
+    return delegate().createResolvingOobChannelBuilder(target);
+  }
+
+  @Override
+  public ManagedChannelBuilder<?> createResolvingOobChannelBuilder(
+      String target, ChannelCredentials creds) {
+    return delegate().createResolvingOobChannelBuilder(target, creds);
+  }
+
+  @Override
+  public ManagedChannel createResolvingOobChannel(String target) {
+    return delegate().createResolvingOobChannel(target);
+  }
+
+  @Override
+  public void updateBalancingState(
+      ConnectivityState newState, SubchannelPicker newPicker) {
+    delegate().updateBalancingState(newState, newPicker);
+  }
+
+  @Override
+  public void refreshNameResolution() {
+    delegate().refreshNameResolution();
+  }
+
+  @Override
+  @Deprecated
+  public void ignoreRefreshNameResolutionCheck() {
+    delegate().ignoreRefreshNameResolutionCheck();
+  }
+
+  @Override
+  public String getAuthority() {
+    return delegate().getAuthority();
+  }
+
+  @Override
+  public String getChannelTarget() {
+    return delegate().getChannelTarget();
+  }
+
+  @Override
+  public ChannelCredentials getChannelCredentials() {
+    return delegate().getChannelCredentials();
+  }
+
+  @Override
+  public ChannelCredentials getUnsafeChannelCredentials() {
+    return delegate().getUnsafeChannelCredentials();
+  }
+
+  @Override
+  public SynchronizationContext getSynchronizationContext() {
+    return delegate().getSynchronizationContext();
+  }
+
+  @Override
+  public ScheduledExecutorService getScheduledExecutorService() {
+    return delegate().getScheduledExecutorService();
+  }
+
+  @Override
+  public ChannelLogger getChannelLogger() {
+    return delegate().getChannelLogger();
+  }
+
+  @Override
+  public NameResolver.Args getNameResolverArgs() {
+    return delegate().getNameResolverArgs();
+  }
+
+  @Override
+  public NameResolverRegistry getNameResolverRegistry() {
+    return delegate().getNameResolverRegistry();
+  }
+
+  @Override
+  public MetricRecorder getMetricRecorder() {
+    return delegate().getMetricRecorder();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/ForwardingSubchannel.java b/util/src/main/java/io/grpc/util/ForwardingSubchannel.java
new file mode 100644
index 00000000000..416be378162
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/ForwardingSubchannel.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2019 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.util;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.Attributes;
+import io.grpc.Channel;
+import io.grpc.ChannelLogger;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.ExperimentalApi;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import java.util.List;
+
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/1771")
+public abstract class ForwardingSubchannel extends LoadBalancer.Subchannel {
+  /**
+   * Returns the underlying Subchannel.
+   */
+  protected abstract Subchannel delegate();
+
+  @Override
+  public void start(SubchannelStateListener listener) {
+    delegate().start(listener);
+  }
+
+  @Override
+  public void shutdown() {
+    delegate().shutdown();
+  }
+
+  @Override
+  public void requestConnection() {
+    delegate().requestConnection();
+  }
+
+  @Override
+  public List<EquivalentAddressGroup> getAllAddresses() {
+    return delegate().getAllAddresses();
+  }
+
+  @Override
+  public Attributes getAttributes() {
+    return delegate().getAttributes();
+  }
+
+  @Override
+  public Channel asChannel() {
+    return delegate().asChannel();
+  }
+
+  @Override
+  public ChannelLogger getChannelLogger() {
+    return delegate().getChannelLogger();
+  }
+
+  @Override
+  public Object getInternalSubchannel() {
+    return delegate().getInternalSubchannel();
+  }
+
+
+  @Override
+  public void updateAddresses(List<EquivalentAddressGroup> addrs) {
+    delegate().updateAddresses(addrs);
+  }
+
+  @Override
+  public Attributes getConnectedAddressAttributes() {
+    return delegate().getConnectedAddressAttributes();
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this).add("delegate", delegate()).toString();
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/GracefulSwitchLoadBalancer.java b/util/src/main/java/io/grpc/util/GracefulSwitchLoadBalancer.java
new file mode 100644
index 00000000000..dc296a7293e
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/GracefulSwitchLoadBalancer.java
@@ -0,0 +1,273 @@
+/*
+ * Copyright 2019 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.util;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.ExperimentalApi;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.ServiceConfigUtil;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.NotThreadSafe;
+
+/**
+ * A load balancer that gracefully swaps to a new lb policy. If the channel is currently in a state
+ * other than READY, the new policy will be swapped into place immediately.  Otherwise, the channel
+ * will keep using the old policy until the new policy leaves CONNECTING or the old policy exits
+ * READY.
+ *
+ * <p>The child balancer and configuration is specified using service config. Config objects are
+ * generally created by calling {@link #parseLoadBalancingPolicyConfig(List)} from a
+ * {@link io.grpc.LoadBalancerProvider#parseLoadBalancingPolicyConfig
+ * provider's parseLoadBalancingPolicyConfig()} implementation.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/5999")
+@NotThreadSafe // Must be accessed in SynchronizationContext
+public final class GracefulSwitchLoadBalancer extends ForwardingLoadBalancer {
+  private final LoadBalancer defaultBalancer = new LoadBalancer() {
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      throw new AssertionError("real LB is called instead");
+    }
+
+    @Override
+    public void handleNameResolutionError(final Status error) {
+      helper.updateBalancingState(
+          ConnectivityState.TRANSIENT_FAILURE,
+          new FixedResultPicker(PickResult.withError(error)));
+    }
+
+    @Override
+    public void shutdown() {}
+  };
+
+  private final Helper helper;
+
+  // While the new policy is not fully switched on, the pendingLb is handling new updates from name
+  // resolver, and the currentLb is updating channel state and picker for the given helper.
+  // The current fields are guaranteed to be set after the initial swapTo().
+  // The pending fields are cleared when it becomes current.
+  @Nullable private LoadBalancer.Factory currentBalancerFactory;
+  private LoadBalancer currentLb = defaultBalancer;
+  @Nullable private LoadBalancer.Factory pendingBalancerFactory;
+  private LoadBalancer pendingLb = defaultBalancer;
+  private ConnectivityState pendingState;
+  private SubchannelPicker pendingPicker;
+
+  private boolean currentLbIsReady;
+
+  public GracefulSwitchLoadBalancer(Helper helper) {
+    this.helper = checkNotNull(helper, "helper");
+  }
+
+  @Override
+  public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    Config config = (Config) resolvedAddresses.getLoadBalancingPolicyConfig();
+    switchToInternal(config.childFactory);
+    delegate().handleResolvedAddresses(
+        resolvedAddresses.toBuilder()
+          .setLoadBalancingPolicyConfig(config.childConfig)
+          .build());
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    Config config = (Config) resolvedAddresses.getLoadBalancingPolicyConfig();
+    switchToInternal(config.childFactory);
+    return delegate().acceptResolvedAddresses(
+        resolvedAddresses.toBuilder()
+          .setLoadBalancingPolicyConfig(config.childConfig)
+          .build());
+  }
+
+  private void switchToInternal(LoadBalancer.Factory newBalancerFactory) {
+    checkNotNull(newBalancerFactory, "newBalancerFactory");
+
+    if (newBalancerFactory.equals(pendingBalancerFactory)) {
+      return;
+    }
+    pendingLb.shutdown();
+    pendingLb = defaultBalancer;
+    pendingBalancerFactory = null;
+    pendingState = ConnectivityState.CONNECTING;
+    pendingPicker = new FixedResultPicker(PickResult.withNoResult());
+
+    if (newBalancerFactory.equals(currentBalancerFactory)) {
+      return;
+    }
+
+    class PendingHelper extends ForwardingLoadBalancerHelper {
+      LoadBalancer lb;
+
+      @Override
+      protected Helper delegate() {
+        return helper;
+      }
+
+      @Override
+      public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+        if (lb == pendingLb) {
+          checkState(currentLbIsReady, "there's pending lb while current lb has been out of READY");
+          pendingState = newState;
+          pendingPicker = newPicker;
+          if (newState != ConnectivityState.CONNECTING) {
+            swap();
+          }
+        } else if (lb == currentLb) {
+          currentLbIsReady = newState == ConnectivityState.READY;
+          if (!currentLbIsReady && pendingLb != defaultBalancer) {
+            swap(); // current policy exits READY, so swap
+          } else {
+            helper.updateBalancingState(newState, newPicker);
+          }
+        }
+      }
+    }
+
+    PendingHelper pendingHelper = new PendingHelper();
+    pendingHelper.lb = newBalancerFactory.newLoadBalancer(pendingHelper);
+    pendingLb = pendingHelper.lb;
+    pendingBalancerFactory = newBalancerFactory;
+    if (!currentLbIsReady) {
+      swap(); // the old policy is not READY at the moment, so swap to the new one right now
+    }
+  }
+
+  private void swap() {
+    helper.updateBalancingState(pendingState, pendingPicker);
+    currentLb.shutdown();
+    currentLb = pendingLb;
+    currentBalancerFactory = pendingBalancerFactory;
+    pendingLb = defaultBalancer;
+    pendingBalancerFactory = null;
+  }
+
+  @Override
+  protected LoadBalancer delegate() {
+    return pendingLb == defaultBalancer ? currentLb : pendingLb;
+  }
+
+  @Override
+  @Deprecated
+  public void handleSubchannelState(
+      Subchannel subchannel, ConnectivityStateInfo stateInfo) {
+    throw new UnsupportedOperationException(
+        "handleSubchannelState() is not supported by " + this.getClass().getName());
+  }
+
+  @Override
+  public void shutdown() {
+    pendingLb.shutdown();
+    currentLb.shutdown();
+  }
+
+  public String delegateType() {
+    return delegate().getClass().getSimpleName();
+  }
+
+  /**
+   * Provided a JSON list of LoadBalancingConfigs, parse it into a config to pass to GracefulSwitch.
+   */
+  public static ConfigOrError parseLoadBalancingPolicyConfig(
+      List<Map<String, ?>> loadBalancingConfigs) {
+    return parseLoadBalancingPolicyConfig(
+        loadBalancingConfigs, LoadBalancerRegistry.getDefaultRegistry());
+  }
+
+  /**
+   * Provided a JSON list of LoadBalancingConfigs, parse it into a config to pass to GracefulSwitch.
+   */
+  public static ConfigOrError parseLoadBalancingPolicyConfig(
+      List<Map<String, ?>> loadBalancingConfigs, LoadBalancerRegistry lbRegistry) {
+    List<ServiceConfigUtil.LbConfig> childConfigCandidates =
+        ServiceConfigUtil.unwrapLoadBalancingConfigList(loadBalancingConfigs);
+    if (childConfigCandidates == null || childConfigCandidates.isEmpty()) {
+      return ConfigOrError.fromError(
+          Status.UNAVAILABLE.withDescription("No child LB config specified"));
+    }
+    ConfigOrError selectedConfig =
+        ServiceConfigUtil.selectLbPolicyFromList(childConfigCandidates, lbRegistry);
+    if (selectedConfig.getError() != null) {
+      Status error = selectedConfig.getError();
+      return ConfigOrError.fromError(
+          Status.UNAVAILABLE
+              .withCause(error.getCause())
+              .withDescription(error.getDescription())
+              .augmentDescription("Failed to select child config"));
+    }
+    ServiceConfigUtil.PolicySelection selection =
+        (ServiceConfigUtil.PolicySelection) selectedConfig.getConfig();
+    return ConfigOrError.fromConfig(
+        createLoadBalancingPolicyConfig(selection.getProvider(), selection.getConfig()));
+  }
+
+  /**
+   * Directly create a config to pass to GracefulSwitch. The object returned is the same as would be
+   * found in {@code ConfigOrError.getConfig()}.
+   */
+  public static Object createLoadBalancingPolicyConfig(
+      LoadBalancer.Factory childFactory, @Nullable Object childConfig) {
+    return new Config(childFactory, childConfig);
+  }
+
+  static final class Config {
+    final LoadBalancer.Factory childFactory;
+    @Nullable
+    final Object childConfig;
+
+    public Config(LoadBalancer.Factory childFactory, @Nullable Object childConfig) {
+      this.childFactory = checkNotNull(childFactory, "childFactory");
+      this.childConfig = childConfig;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (!(o instanceof Config)) {
+        return false;
+      }
+      Config that = (Config) o;
+      return Objects.equal(childFactory, that.childFactory)
+          && Objects.equal(childConfig, that.childConfig);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(childFactory, childConfig);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper("GracefulSwitchLoadBalancer.Config")
+          .add("childFactory", childFactory)
+          .add("childConfig", childConfig)
+          .toString();
+    }
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/HealthProducerHelper.java b/util/src/main/java/io/grpc/util/HealthProducerHelper.java
new file mode 100644
index 00000000000..b11864765ea
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/HealthProducerHelper.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright 2023 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.util;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.LoadBalancer.HAS_HEALTH_PRODUCER_LISTENER_KEY;
+import static io.grpc.LoadBalancer.HEALTH_CONSUMER_LISTENER_ARG_KEY;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Attributes;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+
+/**
+ * A new {@link io.grpc.LoadBalancer.Helper} used by health producer systems to build health
+ * notification chain, via {@link io.grpc.LoadBalancer.CreateSubchannelArgs}.
+ * The leaf health consumer is pick first. Each health producer uses this helper.
+ * The health producers should make state listener a pass-through and manipulate the
+ * {@link io.grpc.LoadBalancer.CreateSubchannelArgs} for health notifications.
+ * The helper detects health listener parent. The root health producer in the chain will fan out
+ * the subchannel state change to both state listener and health listener.
+ *
+ * <p>Example usage:
+ * <pre>{@code
+ * class HealthProducerLB {
+ *   private final LoadBalancer.Helper helper;
+ *   public HealthProducer(Helper helper) {
+ *     this.helper = new MyHelper(HealthCheckUtil.HealthCheckHelper(helper));
+ *   }
+ *   class MyHelper implements LoadBalancer.Helper {
+ *     public void createSubchannel(CreateSubchannelArgs args) {
+ *       SubchannelStateListener originalListener =
+ *         args.getAttributes(HEALTH_CHECK_CONSUMER_LISTENER);
+ *       if (hcListener != null) {
+ *         // Implement a health listener that producers health check information.
+ *         SubchannelStateListener myListener = MyHealthListener(originalListener);
+ *         args = args.toBuilder.setOption(HEALTH_CHECK_CONSUMER_LISTENER, myListener);
+ *       }
+ *       return super.createSubchannel(args);
+ *     }
+ *   }
+ *  }
+ * }</pre>
+ */
+@Internal
+public final class HealthProducerHelper extends ForwardingLoadBalancerHelper {
+
+  private final LoadBalancer.Helper delegate;
+
+  public HealthProducerHelper(LoadBalancer.Helper helper) {
+    this.delegate = checkNotNull(helper, "helper");
+  }
+
+  @Override
+  public LoadBalancer.Subchannel createSubchannel(LoadBalancer.CreateSubchannelArgs args) {
+    LoadBalancer.SubchannelStateListener healthConsumerListener =
+        args.getOption(HEALTH_CONSUMER_LISTENER_ARG_KEY);
+    LoadBalancer.Subchannel delegateSubchannel = super.createSubchannel(args);
+    boolean alreadyParent = healthConsumerListener != null
+        && delegateSubchannel.getAttributes().get(HAS_HEALTH_PRODUCER_LISTENER_KEY) == null;
+    if (!alreadyParent) {
+      return delegateSubchannel;
+    }
+    return new HealthProducerSubchannel(delegateSubchannel, healthConsumerListener);
+  }
+
+  @Override
+  protected LoadBalancer.Helper delegate() {
+    return delegate;
+  }
+
+  // The parent subchannel in the health check producer LB chain. It duplicates subchannel state to
+  // both the state listener and health listener.
+  @VisibleForTesting
+  static final class HealthProducerSubchannel extends ForwardingSubchannel {
+    private final LoadBalancer.Subchannel delegate;
+    private final LoadBalancer.SubchannelStateListener healthListener;
+
+    HealthProducerSubchannel(LoadBalancer.Subchannel delegate,
+                             LoadBalancer.SubchannelStateListener healthListener) {
+      this.delegate = checkNotNull(delegate, "delegate");
+      this.healthListener = checkNotNull(healthListener, "healthListener");
+    }
+
+    @Override
+    public LoadBalancer.Subchannel delegate() {
+      return delegate;
+    }
+
+    @Override
+    public void start(LoadBalancer.SubchannelStateListener listener) {
+      delegate.start(new LoadBalancer.SubchannelStateListener() {
+        @Override
+        public void onSubchannelState(ConnectivityStateInfo newState) {
+          listener.onSubchannelState(newState);
+          healthListener.onSubchannelState(newState);
+        }
+      });
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return super.getAttributes().toBuilder().set(HAS_HEALTH_PRODUCER_LISTENER_KEY, Boolean.TRUE)
+            .build();
+    }
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/MultiChildLoadBalancer.java b/util/src/main/java/io/grpc/util/MultiChildLoadBalancer.java
new file mode 100644
index 00000000000..acc186e3be6
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/MultiChildLoadBalancer.java
@@ -0,0 +1,414 @@
+/*
+ * Copyright 2023 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.util;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Maps;
+import com.google.common.primitives.UnsignedInts;
+import io.grpc.Attributes;
+import io.grpc.ConnectivityState;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.Status;
+import io.grpc.internal.PickFirstLoadBalancerProvider;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * A base load balancing policy for those policies which has multiple children such as
+ * ClusterManager or the petiole policies.  For internal use only.
+ */
+@Internal
+public abstract class MultiChildLoadBalancer extends LoadBalancer {
+
+  private static final Logger logger = Logger.getLogger(MultiChildLoadBalancer.class.getName());
+  private static final int OFFSET_SEED = new Random().nextInt();
+  // Modify by replacing the list to release memory when no longer used.
+  private List<ChildLbState> childLbStates = new ArrayList<>(0);
+  private final Helper helper;
+  // Set to true if currently in the process of handling resolved addresses.
+  protected boolean resolvingAddresses;
+
+  protected final LoadBalancerProvider pickFirstLbProvider = new PickFirstLoadBalancerProvider();
+
+  protected ConnectivityState currentConnectivityState;
+
+
+  protected MultiChildLoadBalancer(Helper helper) {
+    this.helper = checkNotNull(helper, "helper");
+    logger.log(Level.FINE, "Created");
+  }
+
+  /**
+   * Using the state of all children will calculate the current connectivity state,
+   * update fields, generate a picker and then call
+   * {@link Helper#updateBalancingState(ConnectivityState, SubchannelPicker)}.
+   */
+  protected abstract void updateOverallBalancingState();
+
+  /**
+   * Override to utilize parsing of the policy configuration or alternative helper/lb generation.
+   * Override this if keys are not Endpoints or if child policies have configuration. Null map
+   * values preserve the child without delivering the child an update.
+   */
+  protected Map<Object, ResolvedAddresses> createChildAddressesMap(
+      ResolvedAddresses resolvedAddresses) {
+    Map<Object, ResolvedAddresses> childAddresses =
+        Maps.newLinkedHashMapWithExpectedSize(resolvedAddresses.getAddresses().size());
+    for (EquivalentAddressGroup eag : resolvedAddresses.getAddresses()) {
+      ResolvedAddresses addresses = resolvedAddresses.toBuilder()
+          .setAddresses(Collections.singletonList(eag))
+          .setAttributes(Attributes.newBuilder().set(IS_PETIOLE_POLICY, true).build())
+          .setLoadBalancingPolicyConfig(null)
+          .build();
+      childAddresses.put(new Endpoint(eag), addresses);
+    }
+    return childAddresses;
+  }
+
+  /**
+   * Override to create an instance of a subclass.
+   */
+  protected ChildLbState createChildLbState(Object key) {
+    return new ChildLbState(key, pickFirstLbProvider);
+  }
+
+  /**
+   *   Override to completely replace the default logic or to do additional activities.
+   */
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    logger.log(Level.FINE, "Received resolution result: {0}", resolvedAddresses);
+    try {
+      resolvingAddresses = true;
+
+      // process resolvedAddresses to update children
+      Map<Object, ResolvedAddresses> newChildAddresses = createChildAddressesMap(resolvedAddresses);
+
+      // Handle error case
+      if (newChildAddresses.isEmpty()) {
+        Status unavailableStatus = Status.UNAVAILABLE.withDescription(
+            "NameResolver returned no usable address. " + resolvedAddresses);
+        handleNameResolutionError(unavailableStatus);
+        return unavailableStatus;
+      }
+
+      return updateChildrenWithResolvedAddresses(newChildAddresses);
+    } finally {
+      resolvingAddresses = false;
+    }
+  }
+
+  /**
+   * Handle the name resolution error.
+   *
+   * <p/>Override if you need special handling.
+   */
+  @Override
+  public void handleNameResolutionError(Status error) {
+    if (currentConnectivityState != READY)  {
+      helper.updateBalancingState(
+          TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
+    }
+  }
+
+  @Override
+  public void shutdown() {
+    logger.log(Level.FINE, "Shutdown");
+    for (ChildLbState state : childLbStates) {
+      state.shutdown();
+    }
+    childLbStates.clear();
+  }
+
+  private Status updateChildrenWithResolvedAddresses(
+      Map<Object, ResolvedAddresses> newChildAddresses) {
+    // Create a map with the old values
+    Map<Object, ChildLbState> oldStatesMap =
+        Maps.newLinkedHashMapWithExpectedSize(childLbStates.size());
+    for (ChildLbState state : childLbStates) {
+      oldStatesMap.put(state.getKey(), state);
+    }
+
+    // Move ChildLbStates from the map to a new list (preserving the new map's order)
+    Status status = Status.OK;
+    List<ChildLbState> newChildLbStates = new ArrayList<>(newChildAddresses.size());
+    for (Map.Entry<Object, ResolvedAddresses> entry : newChildAddresses.entrySet()) {
+      ChildLbState childLbState = oldStatesMap.remove(entry.getKey());
+      if (childLbState == null) {
+        childLbState = createChildLbState(entry.getKey());
+      }
+      newChildLbStates.add(childLbState);
+    }
+    // Use a random start position for child updates to weakly "shuffle" connection creation order.
+    // The network will often add noise to the creation order, but this avoids giving earlier
+    // children a consistent head start.
+    for (ChildLbState childLbState : offsetIterable(newChildLbStates, OFFSET_SEED)) {
+      ResolvedAddresses addresses = newChildAddresses.get(childLbState.getKey());
+      if (addresses != null) {
+        // update child LB
+        Status newStatus = childLbState.lb.acceptResolvedAddresses(addresses);
+        if (!newStatus.isOk()) {
+          status = newStatus;
+        }
+      }
+    }
+
+    childLbStates = newChildLbStates;
+    // Update the picker and our connectivity state
+    updateOverallBalancingState();
+
+    // Remaining entries in map are orphaned
+    for (ChildLbState childLbState : oldStatesMap.values()) {
+      childLbState.shutdown();
+    }
+    return status;
+  }
+
+  @VisibleForTesting
+  static <T> Iterable<T> offsetIterable(Collection<T> c, int seed) {
+    int pos;
+    if (c.isEmpty()) {
+      pos = 0;
+    } else {
+      pos = UnsignedInts.remainder(seed, c.size());
+    }
+    return Iterables.concat(
+        Iterables.skip(c, pos),
+        Iterables.limit(c, pos));
+  }
+
+  @Nullable
+  protected static ConnectivityState aggregateState(
+      @Nullable ConnectivityState overallState, ConnectivityState childState) {
+    if (overallState == null) {
+      return childState;
+    }
+    if (overallState == READY || childState == READY) {
+      return READY;
+    }
+    if (overallState == CONNECTING || childState == CONNECTING) {
+      return CONNECTING;
+    }
+    if (overallState == IDLE || childState == IDLE) {
+      return IDLE;
+    }
+    return overallState;
+  }
+
+  protected final Helper getHelper() {
+    return helper;
+  }
+
+  @VisibleForTesting
+  public final Collection<ChildLbState> getChildLbStates() {
+    return childLbStates;
+  }
+
+  /**
+   * Filters out non-ready child load balancers (subchannels).
+   */
+  protected final List<ChildLbState> getReadyChildren() {
+    List<ChildLbState> activeChildren = new ArrayList<>();
+    for (ChildLbState child : getChildLbStates()) {
+      if (child.getCurrentState() == READY) {
+        activeChildren.add(child);
+      }
+    }
+    return activeChildren;
+  }
+
+  /**
+   * This represents the state of load balancer children.  Each endpoint (represented by an
+   * EquivalentAddressGroup or EDS string) will have a separate ChildLbState which in turn will
+   * have a single child LoadBalancer created from the provided factory.
+   *
+   * <p>A ChildLbStateHelper is the glue between ChildLbState and the helpers associated with the
+   * petiole policy above and the PickFirstLoadBalancer's helper below.
+   *
+   * <p>If you wish to store additional state information related to each subchannel, then extend
+   * this class.
+   */
+  public class ChildLbState {
+    private final Object key;
+    private final LoadBalancer lb;
+    private ConnectivityState currentState;
+    private SubchannelPicker currentPicker = new FixedResultPicker(PickResult.withNoResult());
+
+    @SuppressWarnings("this-escape")
+    // TODO(okshiva): Fix 'this-escape' from the constructor before making the API public.
+    public ChildLbState(Object key, LoadBalancer.Factory policyFactory) {
+      this.key = key;
+      this.lb = policyFactory.newLoadBalancer(createChildHelper());
+      this.currentState = CONNECTING;
+    }
+
+    protected ChildLbStateHelper createChildHelper() {
+      return new ChildLbStateHelper();
+    }
+
+    /**
+     * Override for unique behavior such as delayed shutdowns of subchannels.
+     */
+    protected void shutdown() {
+      lb.shutdown();
+      this.currentState = SHUTDOWN;
+      logger.log(Level.FINE, "Child balancer {0} deleted", key);
+    }
+
+    @Override
+    public String toString() {
+      return "Address = " + key
+          + ", state = " + currentState
+          + ", picker type: " + currentPicker.getClass()
+          + ", lb: " + lb;
+    }
+
+    public final Object getKey() {
+      return key;
+    }
+
+    @VisibleForTesting
+    public final LoadBalancer getLb() {
+      return lb;
+    }
+
+    @VisibleForTesting
+    public final SubchannelPicker getCurrentPicker() {
+      return currentPicker;
+    }
+
+    public final ConnectivityState getCurrentState() {
+      return currentState;
+    }
+
+    protected final void setCurrentState(ConnectivityState newState) {
+      currentState = newState;
+    }
+
+    protected final void setCurrentPicker(SubchannelPicker newPicker) {
+      currentPicker = newPicker;
+    }
+
+    /**
+     * ChildLbStateHelper is the glue between ChildLbState and the helpers associated with the
+     * petiole policy above and the PickFirstLoadBalancer's helper below.
+     *
+     * <p>The ChildLbState updates happen during updateBalancingState.  Otherwise, it is doing
+     * simple forwarding.
+     */
+    protected class ChildLbStateHelper extends ForwardingLoadBalancerHelper {
+
+      /**
+       * Update current state and picker for this child and then use
+       * {@link #updateOverallBalancingState()} for the parent LB.
+       */
+      @Override
+      public void updateBalancingState(final ConnectivityState newState,
+          final SubchannelPicker newPicker) {
+        if (currentState == SHUTDOWN) {
+          return;
+        }
+
+        currentState = newState;
+        currentPicker = newPicker;
+        // If we are already in the process of resolving addresses, the overall balancing state
+        // will be updated at the end of it, and we don't need to trigger that update here.
+        if (!resolvingAddresses) {
+          updateOverallBalancingState();
+        }
+      }
+
+      @Override
+      protected Helper delegate() {
+        return helper;
+      }
+    }
+  }
+
+  /**
+   * Endpoint is an optimization to quickly lookup and compare EquivalentAddressGroup address sets.
+   * It ignores the attributes. Is used as a key for ChildLbState for most load balancers
+   * (ClusterManagerLB uses a String).
+   */
+  protected static class Endpoint {
+    final Collection<SocketAddress> addrs;
+    final int hashCode;
+
+    public Endpoint(EquivalentAddressGroup eag) {
+      checkNotNull(eag, "eag");
+
+      if (eag.getAddresses().size() < 10) {
+        addrs = eag.getAddresses();
+      } else {
+        // This is expected to be very unlikely in practice
+        addrs = new HashSet<>(eag.getAddresses());
+      }
+      int sum = 0;
+      for (SocketAddress address : eag.getAddresses()) {
+        sum += address.hashCode();
+      }
+      hashCode = sum;
+    }
+
+    @Override
+    public int hashCode() {
+      return hashCode;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+      if (this == other) {
+        return true;
+      }
+
+      if (!(other instanceof Endpoint)) {
+        return false;
+      }
+      Endpoint o = (Endpoint) other;
+      if (o.hashCode != hashCode || o.addrs.size() != addrs.size()) {
+        return false;
+      }
+
+      return o.addrs.containsAll(addrs);
+    }
+
+    @Override
+    public String toString() {
+      return addrs.toString();
+    }
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/MutableHandlerRegistry.java b/util/src/main/java/io/grpc/util/MutableHandlerRegistry.java
new file mode 100644
index 00000000000..307142b642c
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/MutableHandlerRegistry.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2014 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.util;
+
+import io.grpc.BindableService;
+import io.grpc.ExperimentalApi;
+import io.grpc.HandlerRegistry;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerMethodDefinition;
+import io.grpc.ServerServiceDefinition;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Default implementation of {@link HandlerRegistry}.
+ *
+ * <p>Uses {@link ConcurrentHashMap} to avoid service registration excessively
+ * blocking method lookup.
+ */
+@ThreadSafe
+public final class MutableHandlerRegistry extends HandlerRegistry {
+  private final ConcurrentMap<String, ServerServiceDefinition> services
+      = new ConcurrentHashMap<>();
+
+  /**
+   * Registers a service.
+   *
+   * @return the previously registered service with the same service descriptor name if exists,
+   *         otherwise {@code null}.
+   */
+  @Nullable
+  public ServerServiceDefinition addService(ServerServiceDefinition service) {
+    return services.put(service.getServiceDescriptor().getName(), service);
+  }
+
+  /**
+   * Registers a service.
+   *
+   * @return the previously registered service with the same service descriptor name if exists,
+   *         otherwise {@code null}.
+   */
+  @Nullable
+  public ServerServiceDefinition addService(BindableService bindableService) {
+    return addService(bindableService.bindService());
+  }
+
+  /**
+   * Removes a registered service.
+   *
+   * @return true if the service was found to be removed.
+   */
+  public boolean removeService(ServerServiceDefinition service) {
+    return services.remove(service.getServiceDescriptor().getName(), service);
+  }
+
+  /**
+   *  Note: This does not necessarily return a consistent view of the map.
+   */
+  @Override
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/2222")
+  public List<ServerServiceDefinition> getServices() {
+    return Collections.unmodifiableList(new ArrayList<>(services.values()));
+  }
+
+  /**
+   * Note: This does not actually honor the authority provided.  It will, eventually in the future.
+   */
+  @Override
+  @Nullable
+  public ServerMethodDefinition<?, ?> lookupMethod(String methodName, @Nullable String authority) {
+    String serviceName = MethodDescriptor.extractFullServiceName(methodName);
+    if (serviceName == null) {
+      return null;
+    }
+    ServerServiceDefinition service = services.get(serviceName);
+    if (service == null) {
+      return null;
+    }
+    return service.getMethod(methodName);
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/OutlierDetectionLoadBalancer.java b/util/src/main/java/io/grpc/util/OutlierDetectionLoadBalancer.java
new file mode 100644
index 00000000000..d72a85012f2
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/OutlierDetectionLoadBalancer.java
@@ -0,0 +1,1160 @@
+/*
+ * Copyright 2022 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.util;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Ticker;
+import com.google.common.collect.ForwardingMap;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import io.grpc.Attributes;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ClientStreamTracer.StreamInfo;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.atomic.AtomicLong;
+import javax.annotation.Nullable;
+
+/**
+ * Wraps a child {@code LoadBalancer} while monitoring for outlier backends and removing them from
+ * the use of the child LB.
+ *
+ * <p>This implements the outlier detection gRFC:
+ * https://github.com/grpc/proposal/blob/master/A50-xds-outlier-detection.md
+ *
+ * <p>The implementation maintains two maps. Each endpoint status is tracked using an
+ * EndpointTracker. E.g. for two endpoints with these address list and their tracker:
+ * Endpoint e1 : [a1, a2] is tracked with EndpointTracker t1
+ * Endpoint e2 : [a3] is tracked with EndpointTracker t2
+ * The two maps are:
+ * First, addressMap maps from socket address -> endpoint tracker : [a1 -> t1, a2 -> t1, a3 -> t2]
+ * EndpointTracker has reference to all the subchannels of the corresponding endpoint.
+ * Second, trackerMap maps from unordered address set -> endpoint tracker.
+ * Updated upon address updates.
+ */
+@Internal
+public final class OutlierDetectionLoadBalancer extends LoadBalancer {
+
+  @VisibleForTesting
+  final EndpointTrackerMap endpointTrackerMap;
+
+  @VisibleForTesting
+  final Map<SocketAddress, EndpointTracker> addressMap = new HashMap<>();
+
+  private final SynchronizationContext syncContext;
+  private final Helper childHelper;
+  private final GracefulSwitchLoadBalancer switchLb;
+  private Ticker ticker;
+  private final ScheduledExecutorService timeService;
+  private ScheduledHandle detectionTimerHandle;
+  private Long detectionTimerStartNanos;
+
+  private final ChannelLogger logger;
+
+  private static final Attributes.Key<EndpointTracker> ENDPOINT_TRACKER_KEY
+      = Attributes.Key.create("endpointTrackerKey");
+
+  /**
+   * Creates a new instance of {@link OutlierDetectionLoadBalancer}.
+   */
+  public OutlierDetectionLoadBalancer(Helper helper, Ticker ticker) {
+    logger = helper.getChannelLogger();
+    childHelper = new ChildHelper(checkNotNull(helper, "helper"));
+    switchLb = new GracefulSwitchLoadBalancer(childHelper);
+    endpointTrackerMap = new EndpointTrackerMap();
+    this.syncContext = checkNotNull(helper.getSynchronizationContext(), "syncContext");
+    this.timeService = checkNotNull(helper.getScheduledExecutorService(), "timeService");
+    this.ticker = ticker;
+    logger.log(ChannelLogLevel.DEBUG, "OutlierDetection lb created.");
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    logger.log(ChannelLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
+    OutlierDetectionLoadBalancerConfig config
+        = (OutlierDetectionLoadBalancerConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+
+    // The map should only retain entries for endpoints in this latest update.
+    Set<Set<SocketAddress>> endpoints = new HashSet<>();
+    Map<SocketAddress, Set<SocketAddress>> addressEndpointMap = new HashMap<>();
+    for (EquivalentAddressGroup addressGroup : resolvedAddresses.getAddresses()) {
+      Set<SocketAddress> endpoint = ImmutableSet.copyOf(addressGroup.getAddresses());
+      endpoints.add(endpoint);
+      for (SocketAddress address : addressGroup.getAddresses()) {
+        if (addressEndpointMap.containsKey(address)) {
+          logger.log(ChannelLogLevel.WARNING,
+              "Unexpected duplicated address {0} belongs to multiple endpoints", address);
+        }
+        addressEndpointMap.put(address, endpoint);
+      }
+    }
+    endpointTrackerMap.keySet().retainAll(endpoints);
+
+    endpointTrackerMap.updateTrackerConfigs(config);
+
+    // Add any new ones.
+    endpointTrackerMap.putNewTrackers(config, endpoints);
+
+    // Update address -> tracker map.
+    addressMap.clear();
+    for (Map.Entry<SocketAddress, Set<SocketAddress>> e : addressEndpointMap.entrySet()) {
+      addressMap.put(e.getKey(), endpointTrackerMap.get(e.getValue()));
+    }
+
+    // If outlier detection is actually configured, start a timer that will periodically try to
+    // detect outliers.
+    if (config.outlierDetectionEnabled()) {
+      long initialDelayNanos;
+
+      if (detectionTimerStartNanos == null) {
+        // On the first go we use the configured interval.
+        initialDelayNanos = config.intervalNanos;
+      } else {
+        // If a timer has started earlier we cancel it and use the difference between the start
+        // time and now as the interval.
+        initialDelayNanos = Math.max(0L,
+            config.intervalNanos - (ticker.read() - detectionTimerStartNanos));
+      }
+
+      // If a timer has been previously created we need to cancel it and reset all the call counters
+      // for a fresh start.
+      if (detectionTimerHandle != null) {
+        detectionTimerHandle.cancel();
+        endpointTrackerMap.resetCallCounters();
+      }
+
+      detectionTimerHandle = syncContext.scheduleWithFixedDelay(new DetectionTimer(config, logger),
+          initialDelayNanos, config.intervalNanos, NANOSECONDS, timeService);
+    } else if (detectionTimerHandle != null) {
+      // Outlier detection is not configured, but we have a lingering timer. Let's cancel it and
+      // uneject any addresses we may have ejected.
+      detectionTimerHandle.cancel();
+      detectionTimerStartNanos = null;
+      endpointTrackerMap.cancelTracking();
+    }
+
+    return switchLb.acceptResolvedAddresses(
+        resolvedAddresses.toBuilder().setLoadBalancingPolicyConfig(config.childConfig).build());
+  }
+
+  @Override
+  public void handleNameResolutionError(Status error) {
+    switchLb.handleNameResolutionError(error);
+  }
+
+  @Override
+  public void shutdown() {
+    switchLb.shutdown();
+  }
+
+  /**
+   * This timer will be invoked periodically, according to configuration, and it will look for any
+   * outlier subchannels.
+   */
+  final class DetectionTimer implements Runnable {
+
+    OutlierDetectionLoadBalancerConfig config;
+    ChannelLogger logger;
+
+    DetectionTimer(OutlierDetectionLoadBalancerConfig config, ChannelLogger logger) {
+      this.config = config;
+      this.logger = logger;
+    }
+
+    @Override
+    public void run() {
+      detectionTimerStartNanos = ticker.read();
+
+      endpointTrackerMap.swapCounters();
+
+      for (OutlierEjectionAlgorithm algo : OutlierEjectionAlgorithm.forConfig(config, logger)) {
+        algo.ejectOutliers(endpointTrackerMap, detectionTimerStartNanos);
+      }
+
+      endpointTrackerMap.maybeUnejectOutliers(detectionTimerStartNanos);
+    }
+  }
+
+  /**
+   * This child helper wraps the provided helper so that it can hand out wrapped {@link
+   * OutlierDetectionSubchannel}s and manage the address info map.
+   */
+  final class ChildHelper extends ForwardingLoadBalancerHelper {
+
+    private Helper delegate;
+
+    ChildHelper(Helper delegate) {
+      this.delegate = new HealthProducerHelper(delegate);
+    }
+
+    @Override
+    protected Helper delegate() {
+      return delegate;
+    }
+
+    @Override
+    public Subchannel createSubchannel(CreateSubchannelArgs args) {
+      // Subchannels are wrapped so that we can monitor call results and to trigger failures when
+      // we decide to eject the subchannel.
+      OutlierDetectionSubchannel subchannel = new OutlierDetectionSubchannel(args, delegate);
+
+      // If the subchannel is associated with a single address that is also already in the map
+      // the subchannel will be added to the map and be included in outlier detection.
+      List<EquivalentAddressGroup> addressGroups = args.getAddresses();
+      if (hasSingleAddress(addressGroups)
+          && addressMap.containsKey(addressGroups.get(0).getAddresses().get(0))) {
+        EndpointTracker tracker = addressMap.get(addressGroups.get(0).getAddresses().get(0));
+        tracker.addSubchannel(subchannel);
+
+        // If this address has already been ejected, we need to immediately eject this Subchannel.
+        if (tracker.ejectionTimeNanos != null) {
+          subchannel.eject();
+        }
+      }
+
+      return subchannel;
+    }
+
+    @Override
+    public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+      delegate.updateBalancingState(newState, new OutlierDetectionPicker(newPicker));
+    }
+  }
+
+  final class OutlierDetectionSubchannel extends ForwardingSubchannel {
+
+    private final Subchannel delegate;
+    private EndpointTracker endpointTracker;
+    private boolean ejected;
+    private ConnectivityStateInfo lastSubchannelState;
+
+    // In the new pick first: created at construction, delegates to health consumer listener;
+    // In th old pick first: created at subchannel.start(), delegates to subchannel state listener.
+    private SubchannelStateListener subchannelStateListener;
+    private final ChannelLogger logger;
+
+    OutlierDetectionSubchannel(CreateSubchannelArgs args, Helper helper) {
+      LoadBalancer.SubchannelStateListener healthConsumerListener =
+          args.getOption(HEALTH_CONSUMER_LISTENER_ARG_KEY);
+      if (healthConsumerListener != null) {
+        this.subchannelStateListener = healthConsumerListener;
+        SubchannelStateListener upstreamListener =
+            new OutlierDetectionSubchannelStateListener(healthConsumerListener);
+        this.delegate = helper.createSubchannel(args.toBuilder()
+             .addOption(HEALTH_CONSUMER_LISTENER_ARG_KEY, upstreamListener).build());
+      } else {
+        this.delegate = helper.createSubchannel(args);
+      }
+      this.logger = delegate.getChannelLogger();
+    }
+
+    @Override
+    public void start(SubchannelStateListener listener) {
+      if (subchannelStateListener != null) {
+        super.start(listener);
+      } else {
+        subchannelStateListener = listener;
+        super.start(new OutlierDetectionSubchannelStateListener(listener));
+      }
+    }
+
+    @Override
+    public void shutdown() {
+      if (endpointTracker != null) {
+        endpointTracker.removeSubchannel(this);
+      }
+      super.shutdown();
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      if (endpointTracker != null) {
+        return delegate.getAttributes().toBuilder().set(ENDPOINT_TRACKER_KEY, endpointTracker)
+            .build();
+      } else {
+        return delegate.getAttributes();
+      }
+    }
+
+    @Override
+    public void updateAddresses(List<EquivalentAddressGroup> addressGroups) {
+      // Outlier detection only supports subchannels with a single address, but the list of
+      // addressGroups associated with a subchannel can change at any time, so we need to react to
+      // changes in the address list plurality.
+
+      // No change in address plurality, we replace the single one with a new one.
+      if (hasSingleAddress(getAllAddresses()) && hasSingleAddress(addressGroups)) {
+        // Remove the current subchannel from the old address it is associated with in the map.
+        if (endpointTrackerMap.containsValue(endpointTracker)) {
+          endpointTracker.removeSubchannel(this);
+        }
+
+        // If the map has an entry for the new address, we associate this subchannel with it.
+        SocketAddress address = addressGroups.get(0).getAddresses().get(0);
+        if (addressMap.containsKey(address)) {
+          addressMap.get(address).addSubchannel(this);
+        }
+      } else if (hasSingleAddress(getAllAddresses()) && !hasSingleAddress(addressGroups)) {
+        // We go from a single address to having multiple, making this subchannel uneligible for
+        // outlier detection. Remove it from all trackers and reset the call counters of all the
+        // associated trackers.
+        // Remove the current subchannel from the old address it is associated with in the map.
+        if (addressMap.containsKey(getAddresses().getAddresses().get(0))) {
+          EndpointTracker tracker = addressMap.get(getAddresses().getAddresses().get(0));
+          tracker.removeSubchannel(this);
+          tracker.resetCallCounters();
+        }
+      } else if (!hasSingleAddress(getAllAddresses()) && hasSingleAddress(addressGroups)) {
+        // We go from, previously uneligble, multiple address mode to a single address. If the map
+        // has an entry for the new address, we associate this subchannel with it.
+        SocketAddress address = addressGroups.get(0).getAddresses().get(0);
+        if (addressMap.containsKey(address)) {
+          EndpointTracker tracker = addressMap.get(address);
+          tracker.addSubchannel(this);
+        }
+      }
+
+      // We could also have multiple addressGroups and get an update for multiple new ones. This is
+      // a no-op as we will just continue to ignore multiple address subchannels.
+
+      delegate.updateAddresses(addressGroups);
+    }
+
+    /**
+     * If the {@link Subchannel} is considered for outlier detection the associated {@link
+     * EndpointTracker} should be set.
+     */
+    void setEndpointTracker(EndpointTracker endpointTracker) {
+      this.endpointTracker = endpointTracker;
+    }
+
+    void clearEndpointTracker() {
+      this.endpointTracker = null;
+    }
+
+    void eject() {
+      ejected = true;
+      subchannelStateListener.onSubchannelState(ConnectivityStateInfo.forTransientFailure(
+          Status.UNAVAILABLE.withDescription(
+              "The subchannel has been ejected by outlier detection")));
+      logger.log(ChannelLogLevel.INFO, "Subchannel ejected: {0}", this);
+    }
+
+    void uneject() {
+      ejected = false;
+      if (lastSubchannelState != null) {
+        subchannelStateListener.onSubchannelState(lastSubchannelState);
+        logger.log(ChannelLogLevel.INFO, "Subchannel unejected: {0}", this);
+      }
+    }
+
+    boolean isEjected() {
+      return ejected;
+    }
+
+    @Override
+    protected Subchannel delegate() {
+      return delegate;
+    }
+
+    /**
+     * Wraps the actual listener so that state changes from the actual one can be intercepted.
+     */
+    final class OutlierDetectionSubchannelStateListener implements SubchannelStateListener {
+
+      private final SubchannelStateListener delegate;
+
+      OutlierDetectionSubchannelStateListener(SubchannelStateListener delegate) {
+        this.delegate = delegate;
+      }
+
+      @Override
+      public void onSubchannelState(ConnectivityStateInfo newState) {
+        lastSubchannelState = newState;
+        if (!ejected) {
+          delegate.onSubchannelState(newState);
+        }
+      }
+    }
+
+    @Override
+    public String toString() {
+      return "OutlierDetectionSubchannel{"
+              + "addresses=" + delegate.getAllAddresses()
+              + '}';
+    }
+  }
+
+
+  /**
+   * This picker delegates the actual picking logic to a wrapped delegate, but associates a {@link
+   * ClientStreamTracer} with each pick to track the results of each subchannel stream.
+   */
+  final class OutlierDetectionPicker extends SubchannelPicker {
+
+    private final SubchannelPicker delegate;
+
+    OutlierDetectionPicker(SubchannelPicker delegate) {
+      this.delegate = delegate;
+    }
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      PickResult pickResult = delegate.pickSubchannel(args);
+
+      Subchannel subchannel = pickResult.getSubchannel();
+      if (subchannel != null) {
+        return PickResult.withSubchannel(subchannel, new ResultCountingClientStreamTracerFactory(
+            subchannel.getAttributes().get(ENDPOINT_TRACKER_KEY),
+            pickResult.getStreamTracerFactory()));
+      }
+
+      return pickResult;
+    }
+
+    /**
+     * Builds instances of a {@link ClientStreamTracer} that increments the call count in the
+     * tracker for each closed stream.
+     */
+    final class ResultCountingClientStreamTracerFactory extends ClientStreamTracer.Factory {
+
+      private final EndpointTracker tracker;
+
+      @Nullable
+      private final ClientStreamTracer.Factory delegateFactory;
+
+      ResultCountingClientStreamTracerFactory(EndpointTracker tracker,
+          @Nullable ClientStreamTracer.Factory delegateFactory) {
+        this.tracker = tracker;
+        this.delegateFactory = delegateFactory;
+      }
+
+      @Override
+      public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+        if (delegateFactory != null) {
+          ClientStreamTracer delegateTracer = delegateFactory.newClientStreamTracer(info, headers);
+          return new ForwardingClientStreamTracer() {
+            @Override
+            protected ClientStreamTracer delegate() {
+              return delegateTracer;
+            }
+
+            @Override
+            public void streamClosed(Status status) {
+              tracker.incrementCallCount(status.isOk());
+              delegate().streamClosed(status);
+            }
+          };
+        } else {
+          return new ClientStreamTracer() {
+            @Override
+            public void streamClosed(Status status) {
+              tracker.incrementCallCount(status.isOk());
+            }
+          };
+        }
+      }
+    }
+  }
+
+  /**
+   * Tracks additional information about the endpoint needed for outlier detection.
+   */
+  static final class EndpointTracker {
+
+    private OutlierDetectionLoadBalancerConfig config;
+    // Marked as volatile to assure that when the inactive counter is swapped in as the new active
+    // one, all threads see the change and don't hold on to a reference to the now inactive counter.
+    private volatile CallCounter activeCallCounter = new CallCounter();
+    private CallCounter inactiveCallCounter = new CallCounter();
+    private Long ejectionTimeNanos;
+    private int ejectionTimeMultiplier;
+    private final Set<OutlierDetectionSubchannel> subchannels = new HashSet<>();
+
+    EndpointTracker(OutlierDetectionLoadBalancerConfig config) {
+      this.config = config;
+    }
+
+    void setConfig(OutlierDetectionLoadBalancerConfig config) {
+      this.config = config;
+    }
+
+    /**
+     * Adds a subchannel to the tracker, while assuring that the subchannel ejection status is
+     * updated to match the tracker's if needed.
+     */
+    boolean addSubchannel(OutlierDetectionSubchannel subchannel) {
+      // Make sure that the subchannel is in the same ejection state as the new tracker it is
+      // associated with.
+      if (subchannelsEjected() && !subchannel.isEjected()) {
+        subchannel.eject();
+      } else if (!subchannelsEjected() && subchannel.isEjected()) {
+        subchannel.uneject();
+      }
+      subchannel.setEndpointTracker(this);
+      return subchannels.add(subchannel);
+    }
+
+    boolean removeSubchannel(OutlierDetectionSubchannel subchannel) {
+      subchannel.clearEndpointTracker();
+      return subchannels.remove(subchannel);
+    }
+
+    boolean containsSubchannel(OutlierDetectionSubchannel subchannel) {
+      return subchannels.contains(subchannel);
+    }
+
+    @VisibleForTesting
+    Set<OutlierDetectionSubchannel> getSubchannels() {
+      return ImmutableSet.copyOf(subchannels);
+    }
+
+    void incrementCallCount(boolean success) {
+      // If neither algorithm is configured, no point in incrementing counters.
+      if (config.successRateEjection == null && config.failurePercentageEjection == null) {
+        return;
+      }
+
+      if (success) {
+        activeCallCounter.successCount.getAndIncrement();
+      } else {
+        activeCallCounter.failureCount.getAndIncrement();
+      }
+    }
+
+    @VisibleForTesting
+    long activeVolume() {
+      return activeCallCounter.successCount.get() + activeCallCounter.failureCount.get();
+    }
+
+    long inactiveVolume() {
+      return inactiveCallCounter.successCount.get() + inactiveCallCounter.failureCount.get();
+    }
+
+    double successRate() {
+      return ((double) inactiveCallCounter.successCount.get()) / inactiveVolume();
+    }
+
+    double failureRate() {
+      return ((double)inactiveCallCounter.failureCount.get()) / inactiveVolume();
+    }
+
+    void resetCallCounters() {
+      activeCallCounter.reset();
+      inactiveCallCounter.reset();
+    }
+
+    void decrementEjectionTimeMultiplier() {
+      // The multiplier should not go negative.
+      ejectionTimeMultiplier = ejectionTimeMultiplier == 0 ? 0 : ejectionTimeMultiplier - 1;
+    }
+
+    void resetEjectionTimeMultiplier() {
+      ejectionTimeMultiplier = 0;
+    }
+
+    /**
+     * Swaps the active and inactive counters.
+     *
+     * <p>Note that this method is not thread safe as the swap is not done atomically. This is
+     * expected to only be called from the timer that is scheduled at a fixed delay, assuring that
+     * only one timer is active at a time.
+     */
+    void swapCounters() {
+      inactiveCallCounter.reset();
+      CallCounter tempCounter = activeCallCounter;
+      activeCallCounter = inactiveCallCounter;
+      inactiveCallCounter = tempCounter;
+    }
+
+    void ejectSubchannels(long ejectionTimeNanos) {
+      this.ejectionTimeNanos = ejectionTimeNanos;
+      ejectionTimeMultiplier++;
+      for (OutlierDetectionSubchannel subchannel : subchannels) {
+        subchannel.eject();
+      }
+    }
+
+    /**
+     * Uneject a currently ejected address.
+     */
+    void unejectSubchannels() {
+      checkState(ejectionTimeNanos != null, "not currently ejected");
+      ejectionTimeNanos = null;
+      for (OutlierDetectionSubchannel subchannel : subchannels) {
+        subchannel.uneject();
+      }
+    }
+
+    boolean subchannelsEjected() {
+      return ejectionTimeNanos != null;
+    }
+
+    public boolean maxEjectionTimeElapsed(long currentTimeNanos) {
+      // The instant in time beyond which the address should no longer be ejected. Also making sure
+      // we honor any maximum ejection time setting.
+      long maxEjectionDurationSecs
+          = Math.max(config.baseEjectionTimeNanos, config.maxEjectionTimeNanos);
+      long maxEjectionTimeNanos =
+          ejectionTimeNanos + Math.min(
+              config.baseEjectionTimeNanos * ejectionTimeMultiplier,
+              maxEjectionDurationSecs);
+
+      return currentTimeNanos - maxEjectionTimeNanos > 0;
+    }
+
+    /** Tracks both successful and failed call counts. */
+    private static final class CallCounter {
+      AtomicLong successCount = new AtomicLong();
+      AtomicLong failureCount = new AtomicLong();
+
+      void reset() {
+        successCount.set(0);
+        failureCount.set(0);
+      }
+    }
+
+    @Override
+    public String toString() {
+      return "EndpointTracker{"
+              + "subchannels=" + subchannels
+              + '}';
+    }
+  }
+
+  /**
+   * Maintains a mapping from endpoint (a set of addresses) to their trackers.
+   */
+  static final class EndpointTrackerMap extends ForwardingMap<Set<SocketAddress>, EndpointTracker> {
+    private final Map<Set<SocketAddress>, EndpointTracker> trackerMap;
+
+    EndpointTrackerMap() {
+      trackerMap = new HashMap<>();
+    }
+
+    @Override
+    protected Map<Set<SocketAddress>, EndpointTracker> delegate() {
+      return trackerMap;
+    }
+
+    void updateTrackerConfigs(OutlierDetectionLoadBalancerConfig config) {
+      for (EndpointTracker tracker: trackerMap.values()) {
+        tracker.setConfig(config);
+      }
+    }
+
+    /** Adds a new tracker for every given address. */
+    void putNewTrackers(OutlierDetectionLoadBalancerConfig config,
+        Set<Set<SocketAddress>> endpoints) {
+      for (Set<SocketAddress> endpoint : endpoints) {
+        if (!trackerMap.containsKey(endpoint)) {
+          trackerMap.put(endpoint, new EndpointTracker(config));
+        }
+      }
+    }
+
+    /** Resets the call counters for all the trackers in the map. */
+    void resetCallCounters() {
+      for (EndpointTracker tracker : trackerMap.values()) {
+        tracker.resetCallCounters();
+      }
+    }
+
+    /**
+     * When OD gets disabled we need to uneject any subchannels that may have been ejected and
+     * to reset the ejection time multiplier.
+     */
+    void cancelTracking() {
+      for (EndpointTracker tracker : trackerMap.values()) {
+        if (tracker.subchannelsEjected()) {
+          tracker.unejectSubchannels();
+        }
+        tracker.resetEjectionTimeMultiplier();
+      }
+    }
+
+    /** Swaps the active and inactive counters for each tracker. */
+    void swapCounters() {
+      for (EndpointTracker tracker : trackerMap.values()) {
+        tracker.swapCounters();
+      }
+    }
+
+    /**
+     * At the end of a timer run we need to decrement the ejection time multiplier for trackers
+     * that don't have ejected subchannels and uneject ones that have spent the maximum ejection
+     * time allowed.
+     */
+    void maybeUnejectOutliers(long detectionTimerStartNanos) {
+      for (EndpointTracker tracker : trackerMap.values()) {
+        if (!tracker.subchannelsEjected()) {
+          tracker.decrementEjectionTimeMultiplier();
+        }
+
+        if (tracker.subchannelsEjected() && tracker.maxEjectionTimeElapsed(
+            detectionTimerStartNanos)) {
+          tracker.unejectSubchannels();
+        }
+      }
+    }
+
+    /**
+     * How many percent of the addresses have been ejected.
+     */
+    double ejectionPercentage() {
+      if (trackerMap.isEmpty()) {
+        return 0;
+      }
+      int totalEndpoints = 0;
+      int ejectedEndpoints = 0;
+      for (EndpointTracker tracker : trackerMap.values()) {
+        totalEndpoints++;
+        if (tracker.subchannelsEjected()) {
+          ejectedEndpoints++;
+        }
+      }
+      return ((double)ejectedEndpoints / totalEndpoints) * 100;
+    }
+  }
+
+
+  /**
+   * Implementations provide different ways of ejecting outlier addresses..
+   */
+  interface OutlierEjectionAlgorithm {
+
+    /** Eject any outlier addresses. */
+    void ejectOutliers(EndpointTrackerMap trackerMap, long ejectionTimeNanos);
+
+    /** Builds a list of algorithms that are enabled in the given config. */
+    @Nullable
+    static List<OutlierEjectionAlgorithm> forConfig(OutlierDetectionLoadBalancerConfig config,
+                                                    ChannelLogger logger) {
+      ImmutableList.Builder<OutlierEjectionAlgorithm> algoListBuilder = ImmutableList.builder();
+      if (config.successRateEjection != null) {
+        algoListBuilder.add(new SuccessRateOutlierEjectionAlgorithm(config, logger));
+      }
+      if (config.failurePercentageEjection != null) {
+        algoListBuilder.add(new FailurePercentageOutlierEjectionAlgorithm(config, logger));
+      }
+      return algoListBuilder.build();
+    }
+  }
+
+  /**
+   * This algorithm ejects addresses that don't maintain a required rate of successful calls. The
+   * required rate is not fixed, but is based on the mean and standard deviation of the success
+   * rates of all of the addresses.
+   */
+  static final class SuccessRateOutlierEjectionAlgorithm implements OutlierEjectionAlgorithm {
+
+    private final OutlierDetectionLoadBalancerConfig config;
+
+    private final ChannelLogger logger;
+
+    SuccessRateOutlierEjectionAlgorithm(OutlierDetectionLoadBalancerConfig config,
+                                        ChannelLogger logger) {
+      checkArgument(config.successRateEjection != null, "success rate ejection config is null");
+      this.config = config;
+      this.logger = logger;
+    }
+
+    @Override
+    public void ejectOutliers(EndpointTrackerMap trackerMap, long ejectionTimeNanos) {
+
+      // Only consider addresses that have the minimum request volume specified in the config.
+      List<EndpointTracker> trackersWithVolume = trackersWithVolume(trackerMap,
+          config.successRateEjection.requestVolume);
+      // If we don't have enough endpoints with significant volume then there's nothing to do.
+      if (trackersWithVolume.size() < config.successRateEjection.minimumHosts
+          || trackersWithVolume.size() == 0) {
+        return;
+      }
+
+      // Calculate mean and standard deviation of the fractions of successful calls.
+      List<Double> successRates = new ArrayList<>();
+      for (EndpointTracker tracker : trackersWithVolume) {
+        successRates.add(tracker.successRate());
+      }
+      double mean = mean(successRates);
+      double stdev = standardDeviation(successRates, mean);
+
+      double requiredSuccessRate =
+          mean - stdev * (config.successRateEjection.stdevFactor / 1000f);
+
+      for (EndpointTracker tracker : trackersWithVolume) {
+        // If we are above or equal to the max ejection percentage, don't eject any more. This will
+        // allow the total ejections to go one above the max, but at the same time it assures at
+        // least one ejection, which the spec calls for. This behavior matches what Envoy proxy
+        // does.
+        if (trackerMap.ejectionPercentage() >= config.maxEjectionPercent) {
+          return;
+        }
+
+        // If success rate is below the threshold, eject the address.
+        if (tracker.successRate() < requiredSuccessRate) {
+          logger.log(ChannelLogLevel.DEBUG,
+                  "SuccessRate algorithm detected outlier: {0}. "
+                          + "Parameters: successRate={1}, mean={2}, stdev={3}, "
+                          + "requiredSuccessRate={4}",
+                  tracker, tracker.successRate(),  mean, stdev, requiredSuccessRate);
+          // Only eject some endpoints based on the enforcement percentage.
+          if (new Random().nextInt(100) < config.successRateEjection.enforcementPercentage) {
+            tracker.ejectSubchannels(ejectionTimeNanos);
+          }
+        }
+      }
+    }
+
+    /** Calculates the mean of the given values. */
+    @VisibleForTesting
+    static double mean(Collection<Double> values) {
+      double totalValue = 0;
+      for (double value : values) {
+        totalValue += value;
+      }
+
+      return totalValue / values.size();
+    }
+
+    /** Calculates the standard deviation for the given values and their mean. */
+    @VisibleForTesting
+    static double standardDeviation(Collection<Double> values, double mean) {
+      double squaredDifferenceSum = 0;
+      for (double value : values) {
+        double difference = value - mean;
+        squaredDifferenceSum += difference * difference;
+      }
+      double variance = squaredDifferenceSum / values.size();
+
+      return Math.sqrt(variance);
+    }
+  }
+
+  static final class FailurePercentageOutlierEjectionAlgorithm implements OutlierEjectionAlgorithm {
+
+    private final OutlierDetectionLoadBalancerConfig config;
+
+    private final ChannelLogger logger;
+
+    FailurePercentageOutlierEjectionAlgorithm(OutlierDetectionLoadBalancerConfig config,
+                                              ChannelLogger logger) {
+      this.config = config;
+      this.logger = logger;
+    }
+
+    @Override
+    public void ejectOutliers(EndpointTrackerMap trackerMap, long ejectionTimeNanos) {
+
+      // Only consider endpoints that have the minimum request volume specified in the config.
+      List<EndpointTracker> trackersWithVolume = trackersWithVolume(trackerMap,
+          config.failurePercentageEjection.requestVolume);
+      // If we don't have enough endpoints with significant volume then there's nothing to do.
+      if (trackersWithVolume.size() < config.failurePercentageEjection.minimumHosts
+          || trackersWithVolume.size() == 0) {
+        return;
+      }
+
+      // If this endpoint does not have enough volume to be considered, skip to the next one.
+      for (EndpointTracker tracker : trackersWithVolume) {
+        // If we are above or equal to the max ejection percentage, don't eject any more. This will
+        // allow the total ejections to go one above the max, but at the same time it assures at
+        // least one ejection, which the spec calls for. This behavior matches what Envoy proxy
+        // does.
+        if (trackerMap.ejectionPercentage() >= config.maxEjectionPercent) {
+          return;
+        }
+
+        if (tracker.inactiveVolume() < config.failurePercentageEjection.requestVolume) {
+          continue;
+        }
+
+        // If the failure rate is above the threshold, we should eject...
+        double maxFailureRate = ((double)config.failurePercentageEjection.threshold) / 100;
+        if (tracker.failureRate() > maxFailureRate) {
+          logger.log(ChannelLogLevel.DEBUG,
+                  "FailurePercentage algorithm detected outlier: {0}, failureRate={1}",
+                  tracker, tracker.failureRate());
+          // ...but only enforce this based on the enforcement percentage.
+          if (new Random().nextInt(100) < config.failurePercentageEjection.enforcementPercentage) {
+            tracker.ejectSubchannels(ejectionTimeNanos);
+          }
+        }
+      }
+    }
+  }
+
+  /** Returns only the trackers that have the minimum configured volume to be considered. */
+  private static List<EndpointTracker> trackersWithVolume(EndpointTrackerMap trackerMap,
+                                                          int volume) {
+    List<EndpointTracker> trackersWithVolume = new ArrayList<>();
+    for (EndpointTracker tracker : trackerMap.values()) {
+      if (tracker.inactiveVolume() >= volume) {
+        trackersWithVolume.add(tracker);
+      }
+    }
+    return trackersWithVolume;
+  }
+
+  /** Counts how many addresses are in a given address group. */
+  private static boolean hasSingleAddress(List<EquivalentAddressGroup> addressGroups) {
+    int addressCount = 0;
+    for (EquivalentAddressGroup addressGroup : addressGroups) {
+      addressCount += addressGroup.getAddresses().size();
+      if (addressCount > 1) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * The configuration for {@link OutlierDetectionLoadBalancer}.
+   */
+  public static final class OutlierDetectionLoadBalancerConfig {
+
+    public final long intervalNanos;
+    public final long baseEjectionTimeNanos;
+    public final long maxEjectionTimeNanos;
+    public final int maxEjectionPercent;
+    public final SuccessRateEjection successRateEjection;
+    public final FailurePercentageEjection failurePercentageEjection;
+    public final Object childConfig;
+
+    private OutlierDetectionLoadBalancerConfig(Builder builder) {
+      this.intervalNanos = builder.intervalNanos;
+      this.baseEjectionTimeNanos = builder.baseEjectionTimeNanos;
+      this.maxEjectionTimeNanos = builder.maxEjectionTimeNanos;
+      this.maxEjectionPercent = builder.maxEjectionPercent;
+      this.successRateEjection = builder.successRateEjection;
+      this.failurePercentageEjection = builder.failurePercentageEjection;
+      this.childConfig = builder.childConfig;
+    }
+
+    /** Builds a new {@link OutlierDetectionLoadBalancerConfig}. */
+    public static final class Builder {
+      long intervalNanos = 10_000_000_000L; // 10s
+      long baseEjectionTimeNanos = 30_000_000_000L; // 30s
+      long maxEjectionTimeNanos = 300_000_000_000L; // 300s
+      int maxEjectionPercent = 10;
+      SuccessRateEjection successRateEjection;
+      FailurePercentageEjection failurePercentageEjection;
+      Object childConfig;
+
+      /** The interval between outlier detection sweeps. */
+      public Builder setIntervalNanos(long intervalNanos) {
+        this.intervalNanos = intervalNanos;
+        return this;
+      }
+
+      /** The base time an address is ejected for. */
+      public Builder setBaseEjectionTimeNanos(long baseEjectionTimeNanos) {
+        this.baseEjectionTimeNanos = baseEjectionTimeNanos;
+        return this;
+      }
+
+      /** The longest time an address can be ejected. */
+      public Builder setMaxEjectionTimeNanos(long maxEjectionTimeNanos) {
+        this.maxEjectionTimeNanos = maxEjectionTimeNanos;
+        return this;
+      }
+
+      /** The algorithm agnostic maximum percentage of addresses that can be ejected. */
+      public Builder setMaxEjectionPercent(int maxEjectionPercent) {
+        this.maxEjectionPercent = maxEjectionPercent;
+        return this;
+      }
+
+      /** Set to enable success rate ejection. */
+      public Builder setSuccessRateEjection(
+          SuccessRateEjection successRateEjection) {
+        this.successRateEjection = successRateEjection;
+        return this;
+      }
+
+      /** Set to enable failure percentage ejection. */
+      public Builder setFailurePercentageEjection(
+          FailurePercentageEjection failurePercentageEjection) {
+        this.failurePercentageEjection = failurePercentageEjection;
+        return this;
+      }
+
+      /**
+       * Sets the graceful child switch config the {@link OutlierDetectionLoadBalancer} delegates
+       * to.
+       */
+      public Builder setChildConfig(Object childConfig) {
+        checkState(childConfig != null);
+        this.childConfig = childConfig;
+        return this;
+      }
+
+      /** Builds a new instance of {@link OutlierDetectionLoadBalancerConfig}. */
+      public OutlierDetectionLoadBalancerConfig build() {
+        checkState(childConfig != null);
+        return new OutlierDetectionLoadBalancerConfig(this);
+      }
+    }
+
+    /** The configuration for success rate ejection. */
+    public static final class SuccessRateEjection {
+
+      public final int stdevFactor;
+      public final int enforcementPercentage;
+      public final int minimumHosts;
+      public final int requestVolume;
+
+      SuccessRateEjection(Builder builder) {
+        this.stdevFactor = builder.stdevFactor;
+        this.enforcementPercentage = builder.enforcementPercentage;
+        this.minimumHosts = builder.minimumHosts;
+        this.requestVolume = builder.requestVolume;
+      }
+
+      /** Builds new instances of {@link SuccessRateEjection}. */
+      public static final class Builder {
+
+        int stdevFactor = 1900;
+        int enforcementPercentage = 100;
+        int minimumHosts = 5;
+        int requestVolume = 100;
+
+        /** The product of this and the standard deviation of success rates determine the ejection
+         * threshold.
+         */
+        public Builder setStdevFactor(int stdevFactor) {
+          this.stdevFactor = stdevFactor;
+          return this;
+        }
+
+        /** Only eject this percentage of outliers. */
+        public Builder setEnforcementPercentage(int enforcementPercentage) {
+          checkArgument(enforcementPercentage >= 0 && enforcementPercentage <= 100);
+          this.enforcementPercentage = enforcementPercentage;
+          return this;
+        }
+
+        /** The minimum amount of hosts needed for success rate ejection. */
+        public Builder setMinimumHosts(int minimumHosts) {
+          checkArgument(minimumHosts >= 0);
+          this.minimumHosts = minimumHosts;
+          return this;
+        }
+
+        /** The minimum address request volume to be considered for success rate ejection. */
+        public Builder setRequestVolume(int requestVolume) {
+          checkArgument(requestVolume >= 0);
+          this.requestVolume = requestVolume;
+          return this;
+        }
+
+        /** Builds a new instance of {@link SuccessRateEjection}. */
+        public SuccessRateEjection build() {
+          return new SuccessRateEjection(this);
+        }
+      }
+    }
+
+    /** The configuration for failure percentage ejection. */
+    public static final class FailurePercentageEjection {
+      public final int threshold;
+      public final int enforcementPercentage;
+      public final int minimumHosts;
+      public final int requestVolume;
+
+      FailurePercentageEjection(Builder builder) {
+        this.threshold = builder.threshold;
+        this.enforcementPercentage = builder.enforcementPercentage;
+        this.minimumHosts = builder.minimumHosts;
+        this.requestVolume = builder.requestVolume;
+      }
+
+      /** For building new {@link FailurePercentageEjection} instances. */
+      public static class Builder {
+        int threshold = 85;
+        int enforcementPercentage = 100;
+        int minimumHosts = 5;
+        int requestVolume = 50;
+
+        /** The failure percentage that will result in an address being considered an outlier. */
+        public Builder setThreshold(int threshold) {
+          checkArgument(threshold >= 0 && threshold <= 100);
+          this.threshold = threshold;
+          return this;
+        }
+
+        /** Only eject this percentage of outliers. */
+        public Builder setEnforcementPercentage(int enforcementPercentage) {
+          checkArgument(enforcementPercentage >= 0 && enforcementPercentage <= 100);
+          this.enforcementPercentage = enforcementPercentage;
+          return this;
+        }
+
+        /** The minimum amount of host for failure percentage ejection to be enabled. */
+        public Builder setMinimumHosts(int minimumHosts) {
+          checkArgument(minimumHosts >= 0);
+          this.minimumHosts = minimumHosts;
+          return this;
+        }
+
+        /**
+         * The request volume required for an address to be considered for failure percentage
+         * ejection.
+         */
+        public Builder setRequestVolume(int requestVolume) {
+          checkArgument(requestVolume >= 0);
+          this.requestVolume = requestVolume;
+          return this;
+        }
+
+        /** Builds a new instance of {@link FailurePercentageEjection}. */
+        public FailurePercentageEjection build() {
+          return new FailurePercentageEjection(this);
+        }
+      }
+    }
+
+    /** Determine if any outlier detection algorithms are enabled in the config. */
+    boolean outlierDetectionEnabled() {
+      return successRateEjection != null || failurePercentageEjection != null;
+    }
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/OutlierDetectionLoadBalancerProvider.java b/util/src/main/java/io/grpc/util/OutlierDetectionLoadBalancerProvider.java
new file mode 100644
index 00000000000..084898bc38f
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/OutlierDetectionLoadBalancerProvider.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright 2022 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.util;
+
+import com.google.common.base.Ticker;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.JsonUtil;
+import io.grpc.util.OutlierDetectionLoadBalancer.OutlierDetectionLoadBalancerConfig;
+import io.grpc.util.OutlierDetectionLoadBalancer.OutlierDetectionLoadBalancerConfig.FailurePercentageEjection;
+import io.grpc.util.OutlierDetectionLoadBalancer.OutlierDetectionLoadBalancerConfig.SuccessRateEjection;
+import java.util.Map;
+
+@Internal
+public final class OutlierDetectionLoadBalancerProvider extends LoadBalancerProvider {
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    return new OutlierDetectionLoadBalancer(helper, Ticker.systemTicker());
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return "outlier_detection_experimental";
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
+    try {
+      return parseLoadBalancingPolicyConfigInternal(rawConfig);
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError(
+          Status.UNAVAILABLE.withCause(e).withDescription(
+              "Failed parsing configuration for " + getPolicyName()));
+    }
+  }
+
+  private ConfigOrError parseLoadBalancingPolicyConfigInternal(Map<String, ?> rawConfig) {
+    // Common configuration.
+    Long intervalNanos = JsonUtil.getStringAsDuration(rawConfig, "interval");
+    Long baseEjectionTimeNanos = JsonUtil.getStringAsDuration(rawConfig, "baseEjectionTime");
+    Long maxEjectionTimeNanos = JsonUtil.getStringAsDuration(rawConfig, "maxEjectionTime");
+    Integer maxEjectionPercentage = JsonUtil.getNumberAsInteger(rawConfig,
+        "maxEjectionPercentage");
+
+    OutlierDetectionLoadBalancerConfig.Builder configBuilder
+        = new OutlierDetectionLoadBalancerConfig.Builder();
+    if (intervalNanos != null) {
+      configBuilder.setIntervalNanos(intervalNanos);
+    }
+    if (baseEjectionTimeNanos != null) {
+      configBuilder.setBaseEjectionTimeNanos(baseEjectionTimeNanos);
+    }
+    if (maxEjectionTimeNanos != null) {
+      configBuilder.setMaxEjectionTimeNanos(maxEjectionTimeNanos);
+    }
+    if (maxEjectionPercentage != null) {
+      configBuilder.setMaxEjectionPercent(maxEjectionPercentage);
+    }
+
+    // Success rate ejection specific configuration.
+    Map<String, ?> rawSuccessRateEjection = JsonUtil.getObject(rawConfig, "successRateEjection");
+    if (rawSuccessRateEjection != null) {
+      SuccessRateEjection.Builder successRateEjectionBuilder = new SuccessRateEjection.Builder();
+
+      Integer stdevFactor = JsonUtil.getNumberAsInteger(rawSuccessRateEjection, "stdevFactor");
+      Integer enforcementPercentage = JsonUtil.getNumberAsInteger(rawSuccessRateEjection,
+          "enforcementPercentage");
+      Integer minimumHosts = JsonUtil.getNumberAsInteger(rawSuccessRateEjection, "minimumHosts");
+      Integer requestVolume = JsonUtil.getNumberAsInteger(rawSuccessRateEjection, "requestVolume");
+
+      if (stdevFactor != null) {
+        successRateEjectionBuilder.setStdevFactor(stdevFactor);
+      }
+      if (enforcementPercentage != null) {
+        successRateEjectionBuilder.setEnforcementPercentage(enforcementPercentage);
+      }
+      if (minimumHosts != null) {
+        successRateEjectionBuilder.setMinimumHosts(minimumHosts);
+      }
+      if (requestVolume != null) {
+        successRateEjectionBuilder.setRequestVolume(requestVolume);
+      }
+
+      configBuilder.setSuccessRateEjection(successRateEjectionBuilder.build());
+    }
+
+    // Failure percentage ejection specific configuration.
+    Map<String, ?> rawFailurePercentageEjection = JsonUtil.getObject(rawConfig,
+        "failurePercentageEjection");
+    if (rawFailurePercentageEjection != null) {
+      FailurePercentageEjection.Builder failurePercentageEjectionBuilder
+          = new FailurePercentageEjection.Builder();
+
+      Integer threshold = JsonUtil.getNumberAsInteger(rawFailurePercentageEjection, "threshold");
+      Integer enforcementPercentage = JsonUtil.getNumberAsInteger(rawFailurePercentageEjection,
+          "enforcementPercentage");
+      Integer minimumHosts = JsonUtil.getNumberAsInteger(rawFailurePercentageEjection,
+          "minimumHosts");
+      Integer requestVolume = JsonUtil.getNumberAsInteger(rawFailurePercentageEjection,
+          "requestVolume");
+
+      if (threshold != null) {
+        failurePercentageEjectionBuilder.setThreshold(threshold);
+      }
+      if (enforcementPercentage != null) {
+        failurePercentageEjectionBuilder.setEnforcementPercentage(enforcementPercentage);
+      }
+      if (minimumHosts != null) {
+        failurePercentageEjectionBuilder.setMinimumHosts(minimumHosts);
+      }
+      if (requestVolume != null) {
+        failurePercentageEjectionBuilder.setRequestVolume(requestVolume);
+      }
+
+      configBuilder.setFailurePercentageEjection(failurePercentageEjectionBuilder.build());
+    }
+
+    // Child load balancer configuration.
+    ConfigOrError childConfig = GracefulSwitchLoadBalancer.parseLoadBalancingPolicyConfig(
+        JsonUtil.getListOfObjects(rawConfig, "childPolicy"));
+    if (childConfig.getError() != null) {
+      return ConfigOrError.fromError(GrpcUtil.statusWithDetails(
+          Status.Code.UNAVAILABLE,
+          "Failed to parse child in outlier_detection_experimental",
+          childConfig.getError()));
+    }
+    configBuilder.setChildConfig(childConfig.getConfig());
+
+    return ConfigOrError.fromConfig(configBuilder.build());
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/RandomSubsettingLoadBalancer.java b/util/src/main/java/io/grpc/util/RandomSubsettingLoadBalancer.java
new file mode 100644
index 00000000000..ad4de9e8921
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/RandomSubsettingLoadBalancer.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright 2025 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.util;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.hash.HashCode;
+import com.google.common.hash.HashFunction;
+import com.google.common.hash.Hashing;
+import com.google.common.primitives.Ints;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.Status;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Random;
+
+
+/**
+ * Wraps a child {@code LoadBalancer}, separating the total set of backends into smaller subsets for
+ * the child balancer to balance across.
+ *
+ * <p>This implements random subsetting gRFC:
+ * https://https://github.com/grpc/proposal/blob/master/A68-random-subsetting.md
+ */
+final class RandomSubsettingLoadBalancer extends LoadBalancer {
+  private final GracefulSwitchLoadBalancer switchLb;
+  private final HashFunction hashFunc;
+
+  public RandomSubsettingLoadBalancer(Helper helper) {
+    this(helper, new Random().nextInt());
+  }
+
+  @VisibleForTesting
+  RandomSubsettingLoadBalancer(Helper helper, int seed) {
+    switchLb = new GracefulSwitchLoadBalancer(checkNotNull(helper, "helper"));
+    hashFunc = Hashing.murmur3_128(seed);
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    RandomSubsettingLoadBalancerConfig config =
+        (RandomSubsettingLoadBalancerConfig)
+            resolvedAddresses.getLoadBalancingPolicyConfig();
+
+    ResolvedAddresses subsetAddresses = filterEndpoints(resolvedAddresses, config.subsetSize);
+
+    return switchLb.acceptResolvedAddresses(
+        subsetAddresses.toBuilder()
+            .setLoadBalancingPolicyConfig(config.childConfig)
+            .build());
+  }
+
+  // implements the subsetting algorithm, as described in A68:
+  // https://github.com/grpc/proposal/pull/423
+  private ResolvedAddresses filterEndpoints(ResolvedAddresses resolvedAddresses, int subsetSize) {
+    if (subsetSize >= resolvedAddresses.getAddresses().size()) {
+      return resolvedAddresses;
+    }
+
+    ArrayList<EndpointWithHash> endpointWithHashList =
+        new ArrayList<>(resolvedAddresses.getAddresses().size());
+
+    for (EquivalentAddressGroup addressGroup : resolvedAddresses.getAddresses()) {
+      HashCode hashCode = hashFunc.hashString(
+          addressGroup.getAddresses().get(0).toString(),
+          StandardCharsets.UTF_8);
+      endpointWithHashList.add(new EndpointWithHash(addressGroup, hashCode.asLong()));
+    }
+
+    Collections.sort(endpointWithHashList, new HashAddressComparator());
+
+    ArrayList<EquivalentAddressGroup> addressGroups = new ArrayList<>(subsetSize);
+
+    for (int idx = 0; idx < subsetSize; ++idx) {
+      addressGroups.add(endpointWithHashList.get(idx).addressGroup);
+    }
+
+    return resolvedAddresses.toBuilder().setAddresses(addressGroups).build();
+  }
+
+  @Override
+  public void handleNameResolutionError(Status error) {
+    switchLb.handleNameResolutionError(error);
+  }
+
+  @Override
+  public void shutdown() {
+    switchLb.shutdown();
+  }
+
+  private static final class EndpointWithHash {
+    public final EquivalentAddressGroup addressGroup;
+    public final long hashCode;
+
+    public EndpointWithHash(EquivalentAddressGroup addressGroup, long hashCode) {
+      this.addressGroup = addressGroup;
+      this.hashCode = hashCode;
+    }
+  }
+
+  private static final class HashAddressComparator implements Comparator<EndpointWithHash> {
+    @Override
+    public int compare(EndpointWithHash lhs, EndpointWithHash rhs) {
+      return Long.compare(lhs.hashCode, rhs.hashCode);
+    }
+  }
+
+  public static final class RandomSubsettingLoadBalancerConfig {
+    public final int subsetSize;
+    public final Object childConfig;
+
+    private RandomSubsettingLoadBalancerConfig(int subsetSize, Object childConfig) {
+      this.subsetSize = subsetSize;
+      this.childConfig = childConfig;
+    }
+
+    public static class Builder {
+      int subsetSize;
+      Object childConfig;
+
+      public Builder setSubsetSize(long subsetSize) {
+        checkArgument(subsetSize > 0L, "Subset size must be greater than 0");
+        // clamping subset size to Integer.MAX_VALUE due to collection indexing limitations in JVM
+        this.subsetSize = Ints.saturatedCast(subsetSize);
+        return this;
+      }
+
+      public Builder setChildConfig(Object childConfig) {
+        this.childConfig = checkNotNull(childConfig, "childConfig");
+        return this;
+      }
+
+      public RandomSubsettingLoadBalancerConfig build() {
+        checkState(subsetSize != 0L, "Subset size must be set before building the config");
+        return new RandomSubsettingLoadBalancerConfig(
+            subsetSize,
+            checkNotNull(childConfig, "childConfig"));
+      }
+    }
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/RandomSubsettingLoadBalancerProvider.java b/util/src/main/java/io/grpc/util/RandomSubsettingLoadBalancerProvider.java
new file mode 100644
index 00000000000..edcbf48a201
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/RandomSubsettingLoadBalancerProvider.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2025 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.util;
+
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.JsonUtil;
+import java.util.Map;
+
+@Internal
+public final class RandomSubsettingLoadBalancerProvider extends LoadBalancerProvider {
+  private static final String POLICY_NAME = "random_subsetting_experimental";
+
+  @Override
+  public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+    return new RandomSubsettingLoadBalancer(helper);
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return POLICY_NAME;
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
+    try {
+      return parseLoadBalancingPolicyConfigInternal(rawConfig);
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError(
+          Status.UNAVAILABLE
+              .withCause(e)
+              .withDescription("Failed parsing configuration for " + getPolicyName()));
+    }
+  }
+
+  private ConfigOrError parseLoadBalancingPolicyConfigInternal(Map<String, ?> rawConfig) {
+    Long subsetSize = JsonUtil.getNumberAsLong(rawConfig, "subsetSize");
+    if (subsetSize == null) {
+      return ConfigOrError.fromError(
+          Status.UNAVAILABLE.withDescription(
+              "Subset size missing in " + getPolicyName() + ", LB policy config=" + rawConfig));
+    }
+
+    ConfigOrError childConfig = GracefulSwitchLoadBalancer.parseLoadBalancingPolicyConfig(
+        JsonUtil.getListOfObjects(rawConfig, "childPolicy"));
+    if (childConfig.getError() != null) {
+      return ConfigOrError.fromError(Status.UNAVAILABLE
+          .withDescription(
+              "Failed to parse child in " + getPolicyName() + ", LB policy config=" + rawConfig)
+          .withCause(childConfig.getError().asRuntimeException()));
+    }
+
+    return ConfigOrError.fromConfig(
+        new RandomSubsettingLoadBalancer.RandomSubsettingLoadBalancerConfig.Builder()
+            .setSubsetSize(subsetSize)
+            .setChildConfig(childConfig.getConfig())
+            .build());
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/RoundRobinLoadBalancer.java b/util/src/main/java/io/grpc/util/RoundRobinLoadBalancer.java
new file mode 100644
index 00000000000..22940e875ac
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/RoundRobinLoadBalancer.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright 2016 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.util;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+import io.grpc.ConnectivityState;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.NameResolver;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * A {@link LoadBalancer} that provides round-robin load-balancing over the {@link
+ * EquivalentAddressGroup}s from the {@link NameResolver}.
+ */
+final class RoundRobinLoadBalancer extends MultiChildLoadBalancer {
+  private final AtomicInteger sequence = new AtomicInteger(new Random().nextInt());
+  private SubchannelPicker currentPicker = new FixedResultPicker(PickResult.withNoResult());
+
+  public RoundRobinLoadBalancer(Helper helper) {
+    super(helper);
+  }
+
+  /**
+   * Updates picker with the list of active subchannels (state == READY).
+   */
+  @Override
+  protected void updateOverallBalancingState() {
+    List<ChildLbState> activeList = getReadyChildren();
+    if (activeList.isEmpty()) {
+      // No READY subchannels
+
+      // RRLB will request connection immediately on subchannel IDLE.
+      boolean isConnecting = false;
+      for (ChildLbState childLbState : getChildLbStates()) {
+        ConnectivityState state = childLbState.getCurrentState();
+        if (state == CONNECTING || state == IDLE) {
+          isConnecting = true;
+          break;
+        }
+      }
+
+      if (isConnecting) {
+        updateBalancingState(CONNECTING, new FixedResultPicker(PickResult.withNoResult()));
+      } else {
+        updateBalancingState(TRANSIENT_FAILURE, createReadyPicker(getChildLbStates()));
+      }
+    } else {
+      updateBalancingState(READY, createReadyPicker(activeList));
+    }
+  }
+
+  private void updateBalancingState(ConnectivityState state, SubchannelPicker picker) {
+    if (state != currentConnectivityState || !picker.equals(currentPicker)) {
+      getHelper().updateBalancingState(state, picker);
+      currentConnectivityState = state;
+      currentPicker = picker;
+    }
+  }
+
+  private SubchannelPicker createReadyPicker(Collection<ChildLbState> children) {
+    List<SubchannelPicker> pickerList = new ArrayList<>();
+    for (ChildLbState child : children) {
+      SubchannelPicker picker = child.getCurrentPicker();
+      pickerList.add(picker);
+    }
+
+    return new ReadyPicker(pickerList, sequence);
+  }
+
+  @Override
+  protected ChildLbState createChildLbState(Object key) {
+    return new ChildLbState(key, pickFirstLbProvider) {
+      @Override
+      protected ChildLbStateHelper createChildHelper() {
+        return new ChildLbStateHelper() {
+          @Override
+          public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+            super.updateBalancingState(newState, newPicker);
+            if (!resolvingAddresses && newState == IDLE) {
+              getLb().requestConnection();
+            }
+          }
+        };
+      }
+    };
+  }
+
+  @VisibleForTesting
+  static class ReadyPicker extends SubchannelPicker {
+    private final List<SubchannelPicker> subchannelPickers; // non-empty
+    private final AtomicInteger index;
+    private final int hashCode;
+
+    public ReadyPicker(List<SubchannelPicker> list, AtomicInteger index) {
+      checkArgument(!list.isEmpty(), "empty list");
+      this.subchannelPickers = list;
+      this.index = Preconditions.checkNotNull(index, "index");
+
+      // Every created picker is checked for equality in updateBalancingState() at least once.
+      // Pre-compute the hash so it can be checked cheaply. Using the hash in equals() makes it very
+      // fast except when the pickers are (very likely) equal.
+      //
+      // For equality we treat children as a set; use hash code as defined by Set
+      int sum = 0;
+      for (SubchannelPicker picker : subchannelPickers) {
+        sum += picker.hashCode();
+      }
+      this.hashCode = sum;
+    }
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      return subchannelPickers.get(nextIndex()).pickSubchannel(args);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(ReadyPicker.class)
+          .add("subchannelPickers", subchannelPickers)
+          .toString();
+    }
+
+    private int nextIndex() {
+      int i = index.getAndIncrement() & Integer.MAX_VALUE;
+      return i % subchannelPickers.size();
+    }
+
+    @VisibleForTesting
+    List<SubchannelPicker> getSubchannelPickers() {
+      return subchannelPickers;
+    }
+
+    @Override
+    public int hashCode() {
+      return hashCode;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (!(o instanceof ReadyPicker)) {
+        return false;
+      }
+      ReadyPicker other = (ReadyPicker) o;
+      if (other == this) {
+        return true;
+      }
+      // the lists cannot contain duplicate subchannels
+      return hashCode == other.hashCode
+          && index == other.index
+          && subchannelPickers.size() == other.subchannelPickers.size()
+          && new HashSet<>(subchannelPickers).containsAll(other.subchannelPickers);
+    }
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/SecretRoundRobinLoadBalancerProvider.java b/util/src/main/java/io/grpc/util/SecretRoundRobinLoadBalancerProvider.java
new file mode 100644
index 00000000000..7843832cd5a
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/SecretRoundRobinLoadBalancerProvider.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2018 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.util;
+
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import java.util.Map;
+
+/**
+ * Provider for the "round_robin" balancing policy.
+ */
+// Make it package-private so that it cannot be directly referenced by users.  Java service loader
+// requires the provider to be public, but we can hide it under a package-private class.
+final class SecretRoundRobinLoadBalancerProvider {
+  private SecretRoundRobinLoadBalancerProvider() {
+  }
+
+  public static final class Provider extends LoadBalancerProvider {
+
+    private static final String NO_CONFIG = "no service config";
+
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 5;
+    }
+
+    @Override
+    public String getPolicyName() {
+      return "round_robin";
+    }
+
+    @Override
+    public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+      return new RoundRobinLoadBalancer(helper);
+    }
+
+    @Override
+    public ConfigOrError parseLoadBalancingPolicyConfig(
+        Map<String, ?> rawLoadBalancingPolicyConfig) {
+      return ConfigOrError.fromConfig(NO_CONFIG);
+    }
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/TransmitStatusRuntimeExceptionInterceptor.java b/util/src/main/java/io/grpc/util/TransmitStatusRuntimeExceptionInterceptor.java
new file mode 100644
index 00000000000..b477ae1fdfb
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/TransmitStatusRuntimeExceptionInterceptor.java
@@ -0,0 +1,280 @@
+/*
+ * Copyright 2017 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.util;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.Attributes;
+import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingServerCall;
+import io.grpc.ForwardingServerCallListener;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.internal.SerializingExecutor;
+import java.util.concurrent.ExecutionException;
+import javax.annotation.Nullable;
+
+/**
+ * A class that intercepts uncaught exceptions of type {@link StatusRuntimeException} and handles
+ * them by closing the {@link ServerCall}, and transmitting the exception's status and metadata
+ * to the client.
+ *
+ * <p>Without this interceptor, gRPC will strip all details and close the {@link ServerCall} with
+ * a generic {@link Status#UNKNOWN} code.
+ *
+ * <p>Security warning: the {@link Status} and {@link Metadata} may contain sensitive server-side
+ * state information, and generally should not be sent to clients. Only install this interceptor
+ * if all clients are trusted.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2189")
+public final class TransmitStatusRuntimeExceptionInterceptor implements ServerInterceptor {
+  private TransmitStatusRuntimeExceptionInterceptor() {
+  }
+
+  public static ServerInterceptor instance() {
+    return new TransmitStatusRuntimeExceptionInterceptor();
+  }
+
+  @Override
+  public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+      ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+    final ServerCall<ReqT, RespT> serverCall = new SerializingServerCall<>(call);
+    ServerCall.Listener<ReqT> listener = next.startCall(serverCall, headers);
+    return new ForwardingServerCallListener.SimpleForwardingServerCallListener<ReqT>(listener) {
+      @Override
+      public void onMessage(ReqT message) {
+        try {
+          super.onMessage(message);
+        } catch (StatusRuntimeException e) {
+          closeWithException(e);
+        }
+      }
+
+      @Override
+      public void onHalfClose() {
+        try {
+          super.onHalfClose();
+        } catch (StatusRuntimeException e) {
+          closeWithException(e);
+        }
+      }
+
+      @Override
+      public void onCancel() {
+        try {
+          super.onCancel();
+        } catch (StatusRuntimeException e) {
+          closeWithException(e);
+        }
+      }
+
+      @Override
+      public void onComplete() {
+        try {
+          super.onComplete();
+        } catch (StatusRuntimeException e) {
+          closeWithException(e);
+        }
+      }
+
+      @Override
+      public void onReady() {
+        try {
+          super.onReady();
+        } catch (StatusRuntimeException e) {
+          closeWithException(e);
+        }
+      }
+
+      private void closeWithException(StatusRuntimeException t) {
+        Metadata metadata = t.getTrailers();
+        if (metadata == null) {
+          metadata = new Metadata();
+        }
+        serverCall.close(t.getStatus(), metadata);
+      }
+    };
+  }
+
+  /**
+   * A {@link ServerCall} that wraps around a non thread safe delegate and provides thread safe
+   * access by serializing everything on an executor.
+   */
+  private static class SerializingServerCall<ReqT, RespT> extends
+      ForwardingServerCall.SimpleForwardingServerCall<ReqT, RespT> {
+    private static final String ERROR_MSG = "Encountered error during serialized access";
+    private final SerializingExecutor serializingExecutor =
+        new SerializingExecutor(MoreExecutors.directExecutor());
+    private boolean closeCalled = false;
+
+    SerializingServerCall(ServerCall<ReqT, RespT> delegate) {
+      super(delegate);
+    }
+
+    @Override
+    public void sendMessage(final RespT message) {
+      serializingExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          SerializingServerCall.super.sendMessage(message);
+        }
+      });
+    }
+
+    @Override
+    public void request(final int numMessages) {
+      serializingExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          SerializingServerCall.super.request(numMessages);
+        }
+      });
+    }
+
+    @Override
+    public void sendHeaders(final Metadata headers) {
+      serializingExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          SerializingServerCall.super.sendHeaders(headers);
+        }
+      });
+    }
+
+    @Override
+    public void close(final Status status, final Metadata trailers) {
+      serializingExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          if (!closeCalled) {
+            closeCalled = true;
+
+            SerializingServerCall.super.close(status, trailers);
+          }
+        }
+      });
+    }
+
+    @Override
+    public boolean isReady() {
+      final SettableFuture<Boolean> retVal = SettableFuture.create();
+      serializingExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          retVal.set(SerializingServerCall.super.isReady());
+        }
+      });
+      try {
+        return retVal.get();
+      } catch (InterruptedException e) {
+        throw new RuntimeException(ERROR_MSG, e);
+      } catch (ExecutionException e) {
+        throw new RuntimeException(ERROR_MSG, e);
+      }
+    }
+
+    @Override
+    public boolean isCancelled() {
+      final SettableFuture<Boolean> retVal = SettableFuture.create();
+      serializingExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          retVal.set(SerializingServerCall.super.isCancelled());
+        }
+      });
+      try {
+        return retVal.get();
+      } catch (InterruptedException e) {
+        throw new RuntimeException(ERROR_MSG, e);
+      } catch (ExecutionException e) {
+        throw new RuntimeException(ERROR_MSG, e);
+      }
+    }
+
+    @Override
+    public void setMessageCompression(final boolean enabled) {
+      serializingExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          SerializingServerCall.super.setMessageCompression(enabled);
+        }
+      });
+    }
+
+    @Override
+    @ExperimentalApi("https://github.com/grpc/grpc-java/issues/11021")
+    public void setOnReadyThreshold(final int numBytes) {
+      serializingExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          SerializingServerCall.super.setOnReadyThreshold(numBytes);
+        }
+      });
+    }
+
+    @Override
+    public void setCompression(final String compressor) {
+      serializingExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          SerializingServerCall.super.setCompression(compressor);
+        }
+      });
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      final SettableFuture<Attributes> retVal = SettableFuture.create();
+      serializingExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          retVal.set(SerializingServerCall.super.getAttributes());
+        }
+      });
+      try {
+        return retVal.get();
+      } catch (InterruptedException e) {
+        throw new RuntimeException(ERROR_MSG, e);
+      } catch (ExecutionException e) {
+        throw new RuntimeException(ERROR_MSG, e);
+      }
+    }
+
+    @Nullable
+    @Override
+    public String getAuthority() {
+      final SettableFuture<String> retVal = SettableFuture.create();
+      serializingExecutor.execute(new Runnable() {
+        @Override
+        public void run() {
+          retVal.set(SerializingServerCall.super.getAuthority());
+        }
+      });
+      try {
+        return retVal.get();
+      } catch (InterruptedException e) {
+        throw new RuntimeException(ERROR_MSG, e);
+      } catch (ExecutionException e) {
+        throw new RuntimeException(ERROR_MSG, e);
+      }
+    }
+  }
+}
diff --git a/util/src/main/java/io/grpc/util/package-info.java b/util/src/main/java/io/grpc/util/package-info.java
new file mode 100644
index 00000000000..b0e877fd4bc
--- /dev/null
+++ b/util/src/main/java/io/grpc/util/package-info.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2017 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.
+ */
+
+/**
+ * Utilities with advanced features in the core layer that user can optionally use.
+ */
+package io.grpc.util;
diff --git a/util/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider b/util/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
new file mode 100644
index 00000000000..d973a6f6728
--- /dev/null
+++ b/util/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
@@ -0,0 +1,3 @@
+io.grpc.util.SecretRoundRobinLoadBalancerProvider$Provider
+io.grpc.util.OutlierDetectionLoadBalancerProvider
+io.grpc.util.RandomSubsettingLoadBalancerProvider
diff --git a/util/src/test/java/io/grpc/util/AdvancedTlsX509KeyManagerTest.java b/util/src/test/java/io/grpc/util/AdvancedTlsX509KeyManagerTest.java
new file mode 100644
index 00000000000..f96c85e4f4f
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/AdvancedTlsX509KeyManagerTest.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2024 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.util;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.testing.TestUtils;
+import io.grpc.testing.TlsTesting;
+import java.io.File;
+import java.security.PrivateKey;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AdvancedTlsX509KeyManager}. */
+@RunWith(JUnit4.class)
+public class AdvancedTlsX509KeyManagerTest {
+  private static final String SERVER_0_KEY_FILE = "server0.key";
+  private static final String SERVER_0_PEM_FILE = "server0.pem";
+  private static final String CLIENT_0_KEY_FILE = "client.key";
+  private static final String CLIENT_0_PEM_FILE = "client.pem";
+  private static final String ALIAS = "default";
+
+  private ScheduledExecutorService executor;
+
+  private File serverKey0File;
+  private File serverCert0File;
+  private File clientKey0File;
+  private File clientCert0File;
+
+  private PrivateKey serverKey0;
+  private X509Certificate[] serverCert0;
+  private PrivateKey clientKey0;
+  private X509Certificate[] clientCert0;
+
+  @Before
+  public void setUp() throws Exception {
+    executor = new FakeClock().getScheduledExecutorService();
+    serverKey0File = TestUtils.loadCert(SERVER_0_KEY_FILE);
+    serverCert0File = TestUtils.loadCert(SERVER_0_PEM_FILE);
+    clientKey0File = TestUtils.loadCert(CLIENT_0_KEY_FILE);
+    clientCert0File = TestUtils.loadCert(CLIENT_0_PEM_FILE);
+    serverKey0 = CertificateUtils.getPrivateKey(TlsTesting.loadCert(SERVER_0_KEY_FILE));
+    serverCert0 = CertificateUtils.getX509Certificates(TlsTesting.loadCert(SERVER_0_PEM_FILE));
+    clientKey0 = CertificateUtils.getPrivateKey(TlsTesting.loadCert(CLIENT_0_KEY_FILE));
+    clientCert0 = CertificateUtils.getX509Certificates(TlsTesting.loadCert(CLIENT_0_PEM_FILE));
+  }
+
+  @Test
+  public void updateTrustCredentials_replacesIssuers() throws Exception {
+    // Overall happy path checking of public API.
+    AdvancedTlsX509KeyManager serverKeyManager = new AdvancedTlsX509KeyManager();
+    serverKeyManager.updateIdentityCredentials(serverCert0, serverKey0);
+    assertEquals(serverKey0, serverKeyManager.getPrivateKey(ALIAS));
+    assertArrayEquals(serverCert0, serverKeyManager.getCertificateChain(ALIAS));
+
+    serverKeyManager.updateIdentityCredentials(clientCert0File, clientKey0File);
+    assertEquals(clientKey0, serverKeyManager.getPrivateKey(ALIAS));
+    assertArrayEquals(clientCert0, serverKeyManager.getCertificateChain(ALIAS));
+
+    serverKeyManager.updateIdentityCredentials(serverCert0File, serverKey0File,1,
+        TimeUnit.MINUTES, executor);
+    assertEquals(serverKey0, serverKeyManager.getPrivateKey(ALIAS));
+    assertArrayEquals(serverCert0, serverKeyManager.getCertificateChain(ALIAS));
+
+    serverKeyManager.updateIdentityCredentials(serverCert0, serverKey0);
+    assertEquals(serverKey0, serverKeyManager.getPrivateKey(ALIAS));
+    assertArrayEquals(serverCert0, serverKeyManager.getCertificateChain(ALIAS));
+  }
+
+  @Test
+  public void credentialSettingParameterValidity() throws Exception {
+    // Checking edge cases of public API parameter setting.
+    AdvancedTlsX509KeyManager serverKeyManager = new AdvancedTlsX509KeyManager();
+    NullPointerException npe = assertThrows(NullPointerException.class, () -> serverKeyManager
+        .updateIdentityCredentials(serverCert0, null));
+    assertEquals("key", npe.getMessage());
+
+    npe = assertThrows(NullPointerException.class, () -> serverKeyManager
+        .updateIdentityCredentials(null, serverKey0));
+    assertEquals("certs", npe.getMessage());
+
+    npe = assertThrows(NullPointerException.class, () -> serverKeyManager
+        .updateIdentityCredentials(null, serverKey0File));
+    assertEquals("certFile", npe.getMessage());
+
+    npe = assertThrows(NullPointerException.class, () -> serverKeyManager
+        .updateIdentityCredentials(serverCert0File, null));
+    assertEquals("keyFile", npe.getMessage());
+
+    npe = assertThrows(NullPointerException.class, () -> serverKeyManager
+        .updateIdentityCredentials(serverCert0File, serverKey0File, 1, null,
+            executor));
+    assertEquals("unit", npe.getMessage());
+
+    npe = assertThrows(NullPointerException.class, () -> serverKeyManager
+        .updateIdentityCredentials(serverCert0File, serverKey0File, 1,
+            TimeUnit.MINUTES, null));
+    assertEquals("executor", npe.getMessage());
+
+    Logger log = Logger.getLogger(AdvancedTlsX509KeyManager.class.getName());
+    TestHandler handler = new TestHandler();
+    log.addHandler(handler);
+    log.setUseParentHandlers(false);
+    log.setLevel(Level.FINE);
+    serverKeyManager.updateIdentityCredentials(serverCert0File, serverKey0File, -1,
+            TimeUnit.SECONDS, executor);
+    log.removeHandler(handler);
+    for (LogRecord record : handler.getRecords()) {
+      if (record.getMessage().contains("Default value of ")) {
+        assertTrue(true);
+        return;
+      }
+    }
+    fail("Log message related to setting default values not found");
+  }
+
+
+  private static class TestHandler extends Handler {
+    private final List<LogRecord> records = new ArrayList<>();
+
+    @Override
+    public void publish(LogRecord record) {
+      records.add(record);
+    }
+
+    @Override
+    public void flush() {
+    }
+
+    @Override
+    public void close() throws SecurityException {
+    }
+
+    public List<LogRecord> getRecords() {
+      return records;
+    }
+  }
+
+}
diff --git a/util/src/test/java/io/grpc/util/AdvancedTlsX509TrustManagerTest.java b/util/src/test/java/io/grpc/util/AdvancedTlsX509TrustManagerTest.java
new file mode 100644
index 00000000000..b9803b03570
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/AdvancedTlsX509TrustManagerTest.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright 2024 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.util;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.Iterables;
+import com.google.common.io.Files;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.testing.TestUtils;
+import io.grpc.testing.TlsTesting;
+import io.grpc.util.AdvancedTlsX509TrustManager.Verification;
+import java.io.File;
+import java.io.IOException;
+import java.net.Socket;
+import java.security.GeneralSecurityException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import javax.net.ssl.SSLSocket;
+import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AdvancedTlsX509TrustManager}. */
+@RunWith(JUnit4.class)
+@IgnoreJRERequirement
+public class AdvancedTlsX509TrustManagerTest {
+
+  private static final String CA_PEM_FILE = "ca.pem";
+  private static final String SERVER_0_PEM_FILE = "server0.pem";
+  private static final String SERVER_1_PEM_FILE = "server1.pem";
+  private File caCertFile;
+  private File serverCert0File;
+  private File serverCert1File;
+
+  private X509Certificate[] caCert;
+  private X509Certificate[] serverCert0;
+  private X509Certificate[] serverCert1;
+
+  private FakeClock fakeClock;
+  private ScheduledExecutorService executor;
+
+  @Before
+  public void setUp() throws IOException, GeneralSecurityException {
+    fakeClock = new FakeClock();
+    executor = fakeClock.getScheduledExecutorService();
+    caCertFile = TestUtils.loadCert(CA_PEM_FILE);
+    caCert = CertificateUtils.getX509Certificates(TlsTesting.loadCert(CA_PEM_FILE));
+    serverCert0File = TestUtils.loadCert(SERVER_0_PEM_FILE);
+    serverCert0 = CertificateUtils.getX509Certificates(TlsTesting.loadCert(SERVER_0_PEM_FILE));
+    serverCert1File = TestUtils.loadCert(SERVER_1_PEM_FILE);
+    serverCert1 = CertificateUtils.getX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+  }
+
+  @Test
+  public void updateTrustCredentials_replacesIssuers() throws Exception {
+    // Overall happy path checking of public API.
+    AdvancedTlsX509TrustManager trustManager = AdvancedTlsX509TrustManager.newBuilder().build();
+    trustManager.updateTrustCredentials(serverCert0File);
+    assertArrayEquals(serverCert0, trustManager.getAcceptedIssuers());
+
+    trustManager.updateTrustCredentials(caCert);
+    assertArrayEquals(caCert, trustManager.getAcceptedIssuers());
+
+    trustManager.updateTrustCredentials(serverCert0File, 1, TimeUnit.MINUTES,
+        executor);
+    assertArrayEquals(serverCert0, trustManager.getAcceptedIssuers());
+
+    trustManager.updateTrustCredentials(serverCert0File);
+    assertArrayEquals(serverCert0, trustManager.getAcceptedIssuers());
+  }
+
+  @Test
+  public void systemDefaultDelegateManagerInstantiation() throws Exception {
+    AdvancedTlsX509TrustManager trustManager = AdvancedTlsX509TrustManager.newBuilder().build();
+    trustManager.useSystemDefaultTrustCerts();
+    CertificateException ce = assertThrows(CertificateException.class, () -> trustManager
+        .checkServerTrusted(serverCert0, "RSA", new Socket()));
+    assertEquals("socket is not a type of SSLSocket", ce.getMessage());
+  }
+
+  @Test
+  public void credentialSettingParameterValidity() throws Exception {
+    // Checking edge cases of public API parameter setting.
+    AdvancedTlsX509TrustManager trustManager = AdvancedTlsX509TrustManager.newBuilder().build();
+
+    NullPointerException npe = assertThrows(NullPointerException.class, () -> trustManager
+        .updateTrustCredentials(null, 1, null, null));
+    assertEquals("trustCertFile", npe.getMessage());
+
+    npe = assertThrows(NullPointerException.class, () -> trustManager
+        .updateTrustCredentials(caCertFile, 1, null, null));
+    assertEquals("unit", npe.getMessage());
+
+    npe = assertThrows(NullPointerException.class, () -> trustManager
+        .updateTrustCredentials(caCertFile, 1, TimeUnit.MINUTES, null));
+    assertEquals("executor", npe.getMessage());
+
+    Logger log = Logger.getLogger(AdvancedTlsX509TrustManager.class.getName());
+    TestHandler handler = new TestHandler();
+    log.addHandler(handler);
+    log.setUseParentHandlers(false);
+    log.setLevel(Level.FINE);
+    trustManager.updateTrustCredentials(serverCert0File, -1, TimeUnit.SECONDS, executor);
+    log.removeHandler(handler);
+    try {
+      LogRecord logRecord = Iterables.find(handler.getRecords(),
+          record -> record.getMessage().contains("Default value of "));
+      assertNotNull(logRecord);
+    } catch (NoSuchElementException e) {
+      throw new AssertionError("Log message related to setting default values not found");
+    }
+  }
+
+  @Test
+  public void missingFile_throwsFileNotFoundException() throws Exception {
+    AdvancedTlsX509TrustManager trustManager = AdvancedTlsX509TrustManager.newBuilder().build();
+    File nonExistentFile = new File("missing_cert.pem");
+    Exception thrown =
+        assertThrows(Exception.class, () -> trustManager.updateTrustCredentials(nonExistentFile));
+    assertNotNull(thrown);
+    assertEquals(thrown.getMessage(),
+        "Certificate file not found or not readable: " + nonExistentFile.getAbsolutePath());
+  }
+
+  @Test
+  public void clientTrustedWithSocketTest() throws Exception {
+    AdvancedTlsX509TrustManager trustManager = AdvancedTlsX509TrustManager.newBuilder()
+        .setVerification(Verification.CERTIFICATE_ONLY_VERIFICATION).build();
+    trustManager.updateTrustCredentials(caCert);
+    SSLSocket sslSocket = mock(SSLSocket.class);
+    when(sslSocket.isConnected()).thenReturn(true);
+    when(sslSocket.getHandshakeSession()).thenReturn(null);
+    CertificateException ce = assertThrows(CertificateException.class, () -> trustManager
+        .checkClientTrusted(serverCert0, "RSA", sslSocket));
+    assertEquals("No handshake session", ce.getMessage());
+  }
+
+  @Test
+  public void updateTrustCredentials_rotate() throws GeneralSecurityException, IOException {
+    AdvancedTlsX509TrustManager trustManager = AdvancedTlsX509TrustManager.newBuilder().build();
+    trustManager.updateTrustCredentials(serverCert0File);
+    assertArrayEquals(serverCert0, trustManager.getAcceptedIssuers());
+
+    trustManager.updateTrustCredentials(serverCert0File, 1, TimeUnit.MINUTES,
+        executor);
+    assertArrayEquals(serverCert0, trustManager.getAcceptedIssuers());
+
+    fakeClock.forwardTime(1, TimeUnit.MINUTES);
+    assertArrayEquals(serverCert0, trustManager.getAcceptedIssuers());
+
+    serverCert0File.setLastModified(serverCert0File.lastModified() - 2000);
+
+    fakeClock.forwardTime(1, TimeUnit.MINUTES);
+    assertArrayEquals(serverCert0, trustManager.getAcceptedIssuers());
+
+    long beforeModify = serverCert0File.lastModified();
+    Files.copy(serverCert1File, serverCert0File);
+    serverCert0File.setLastModified(beforeModify);
+
+    // although file content changed, file modification time is not changed
+    fakeClock.forwardTime(1, TimeUnit.MINUTES);
+    assertArrayEquals(serverCert0, trustManager.getAcceptedIssuers());
+
+    serverCert0File.setLastModified(beforeModify + 2000);
+
+    // file modification time changed
+    fakeClock.forwardTime(1, TimeUnit.MINUTES);
+    assertArrayEquals(serverCert1, trustManager.getAcceptedIssuers());
+  }
+
+  private static class TestHandler extends Handler {
+    private final List<LogRecord> records = new ArrayList<>();
+
+    @Override
+    public void publish(LogRecord record) {
+      records.add(record);
+    }
+
+    @Override
+    public void flush() {
+    }
+
+    @Override
+    public void close() throws SecurityException {
+    }
+
+    public List<LogRecord> getRecords() {
+      return records;
+    }
+  }
+
+}
diff --git a/util/src/test/java/io/grpc/util/CertificateUtilsTest.java b/util/src/test/java/io/grpc/util/CertificateUtilsTest.java
new file mode 100644
index 00000000000..dbddd35bca3
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/CertificateUtilsTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2021 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.internal.testing.TestUtils;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.security.PrivateKey;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.security.spec.InvalidKeySpecException;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link CertificateUtilsTest}. */
+@RunWith(JUnit4.class)
+public class CertificateUtilsTest {
+  public static final String SERVER_0_PEM_FILE = "server0.pem";
+  public static final String SERVER_0_KEY_FILE = "server0.key";
+  public static final String CA_PEM_FILE = "ca.pem";
+  public static final String BAD_PEM_FORMAT = "This is a bad key pem format";
+  public static final String BAD_PEM_CONTENT = "----BEGIN PRIVATE KEY-----\n"
+      + "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDvdzKDTYvRgjBO\n"
+      + "-----END PRIVATE KEY-----";
+  public static final String ECDSA_KEY_FILE = "ecdsa.key";
+
+  @Test
+  public void readPemCertFile() throws CertificateException, IOException {
+    InputStream in = TestUtils.class.getResourceAsStream("/certs/" + SERVER_0_PEM_FILE);
+    X509Certificate[] cert = CertificateUtils.getX509Certificates(in);
+    assertThat(cert.length).isEqualTo(1);
+    // Checks some information on the test certificate.
+    assertThat(cert[0].getSerialNumber()).isEqualTo(new BigInteger(
+        "6c97d344427a93affea089d6855d4ed63dd94f38", 16));
+    assertThat(cert[0].getSubjectX500Principal().toString()).isEqualTo(
+        "CN=*.test.google.com.au, O=Internet Widgits Pty Ltd, ST=Some-State, C=AU");
+  }
+
+  @Test
+  public void readPemKeyFile() throws Exception {
+    InputStream in = TestUtils.class.getResourceAsStream("/certs/" + SERVER_0_KEY_FILE);
+    PrivateKey key = CertificateUtils.getPrivateKey(in);
+    // Checks some information on the test key.
+    assertThat(key.getAlgorithm()).isEqualTo("RSA");
+    assertThat(key.getFormat()).isEqualTo("PKCS#8");
+  }
+
+  @Test
+  public void readCaPemFile() throws CertificateException, IOException {
+    InputStream in = TestUtils.class.getResourceAsStream("/certs/" + CA_PEM_FILE);
+    X509Certificate[] cert = CertificateUtils.getX509Certificates(in);
+    assertThat(cert.length).isEqualTo(1);
+    // Checks some information on the test certificate.
+    assertThat(cert[0].getSerialNumber()).isEqualTo(new BigInteger(
+        "5ab3f456f1dccbe2cfe94b9836d88bf600610f9a", 16));
+    assertThat(cert[0].getSubjectX500Principal().toString()).isEqualTo(
+        "CN=testca, O=Internet Widgits Pty Ltd, ST=Some-State, C=AU");
+  }
+
+  @Test
+  public void readBadFormatKeyFile() throws Exception {
+    InputStream in = new ByteArrayInputStream(BAD_PEM_FORMAT.getBytes(StandardCharsets.UTF_8));
+    try {
+      CertificateUtils.getPrivateKey(in);
+      Assert.fail("no exception thrown");
+    } catch (InvalidKeySpecException expected) {
+      // The error messages for OpenJDK 11 and 8 are different, and for Windows it will generate a
+      // different exception, so we only check if a general exception is thrown.
+    }
+  }
+
+  @Test
+  public void readBadContentKeyFile() {
+    InputStream in = new ByteArrayInputStream(BAD_PEM_CONTENT.getBytes(StandardCharsets.UTF_8));
+    try {
+      CertificateUtils.getPrivateKey(in);
+      Assert.fail("no exception thrown");
+    } catch (Exception expected) {
+      // The error messages for OpenJDK 11 and 8 are different, and for Windows it will generate a
+      // different exception, so we only check if a general exception is thrown.
+    }
+  }
+
+  @Test
+  public void readEcdsaKeyFile() throws Exception {
+    InputStream in = TestUtils.class.getResourceAsStream("/certs/" + ECDSA_KEY_FILE);
+    PrivateKey key = CertificateUtils.getPrivateKey(in);
+    // Checks some information on the test key.
+    assertThat(key.getAlgorithm()).isEqualTo("EC");
+    assertThat(key.getFormat()).isEqualTo("PKCS#8");
+  }
+
+}
diff --git a/util/src/test/java/io/grpc/util/ForwardingClientStreamTracerTest.java b/util/src/test/java/io/grpc/util/ForwardingClientStreamTracerTest.java
new file mode 100644
index 00000000000..dbd7e99b29a
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/ForwardingClientStreamTracerTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2019 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.util;
+
+import static org.mockito.Mockito.mock;
+
+import io.grpc.ClientStreamTracer;
+import io.grpc.ForwardingTestUtil;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ForwardingClientStreamTracer}. */
+@RunWith(JUnit4.class)
+public class ForwardingClientStreamTracerTest {
+  private final ClientStreamTracer mockDelegate = mock(ClientStreamTracer.class);
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        ClientStreamTracer.class,
+        mockDelegate,
+        new ForwardingClientStreamTracerTest.TestClientStreamTracer(),
+        Collections.<Method>emptyList());
+  }
+
+  @SuppressWarnings("deprecation")
+  private final class TestClientStreamTracer extends ForwardingClientStreamTracer {
+    @Override
+    protected ClientStreamTracer delegate() {
+      return mockDelegate;
+    }
+  }
+}
diff --git a/util/src/test/java/io/grpc/util/ForwardingLoadBalancerHelperTest.java b/util/src/test/java/io/grpc/util/ForwardingLoadBalancerHelperTest.java
new file mode 100644
index 00000000000..ba02673c297
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/ForwardingLoadBalancerHelperTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2018 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.util;
+
+import static org.mockito.Mockito.mock;
+
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.ForwardingTestUtil;
+import io.grpc.LoadBalancer;
+import java.lang.reflect.Method;
+import java.net.SocketAddress;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ForwardingLoadBalancerHelper}. */
+@RunWith(JUnit4.class)
+public class ForwardingLoadBalancerHelperTest {
+  private final LoadBalancer.Helper mockDelegate = mock(LoadBalancer.Helper.class);
+
+  private final class TestHelper extends ForwardingLoadBalancerHelper {
+    @Override
+    protected LoadBalancer.Helper delegate() {
+      return mockDelegate;
+    }
+  }
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    final SocketAddress mockAddr = mock(SocketAddress.class);
+    ForwardingTestUtil.testMethodsForwarded(
+        LoadBalancer.Helper.class,
+        mockDelegate,
+        new TestHelper(),
+        Collections.<Method>emptyList(),
+        new ForwardingTestUtil.ArgumentProvider() {
+          @Override
+          public Object get(Method method, int argPos, Class<?> clazz) {
+            if (clazz.equals(EquivalentAddressGroup.class)) {
+              return new EquivalentAddressGroup(Arrays.asList(mockAddr));
+            } else if (clazz.equals(List.class)) {
+              return Collections.emptyList();
+            }
+            return null;
+          }
+        });
+  }
+}
diff --git a/util/src/test/java/io/grpc/util/ForwardingLoadBalancerTest.java b/util/src/test/java/io/grpc/util/ForwardingLoadBalancerTest.java
new file mode 100644
index 00000000000..f9b53400cea
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/ForwardingLoadBalancerTest.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2018 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.util;
+
+import static org.mockito.Mockito.mock;
+
+import io.grpc.ForwardingTestUtil;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import java.util.Arrays;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ForwardingLoadBalancer}. */
+@RunWith(JUnit4.class)
+public class ForwardingLoadBalancerTest {
+  private final LoadBalancer mockDelegate = mock(LoadBalancer.class);
+
+  private final class TestBalancer extends ForwardingLoadBalancer {
+    @Override
+    protected LoadBalancer delegate() {
+      return mockDelegate;
+    }
+  }
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        LoadBalancer.class,
+        mockDelegate,
+        new TestBalancer(),
+        Arrays.asList(
+            LoadBalancer.class.getMethod("acceptResolvedAddresses", ResolvedAddresses.class)));
+  }
+}
diff --git a/util/src/test/java/io/grpc/util/ForwardingSubchannelTest.java b/util/src/test/java/io/grpc/util/ForwardingSubchannelTest.java
new file mode 100644
index 00000000000..2779949ead9
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/ForwardingSubchannelTest.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2018 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.util;
+
+import static org.mockito.Mockito.mock;
+
+import io.grpc.ForwardingTestUtil;
+import io.grpc.LoadBalancer.Subchannel;
+import java.util.Arrays;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ForwardingSubchannel}. */
+@RunWith(JUnit4.class)
+public class ForwardingSubchannelTest {
+  private final Subchannel mockDelegate = mock(Subchannel.class);
+
+  private final class TestSubchannel extends ForwardingSubchannel {
+    @Override
+    protected Subchannel delegate() {
+      return mockDelegate;
+    }
+  }
+
+  @Test
+  public void allMethodsForwarded() throws Exception {
+    ForwardingTestUtil.testMethodsForwarded(
+        Subchannel.class,
+        mockDelegate,
+        new TestSubchannel(),
+        Arrays.asList(Subchannel.class.getMethod("getAddresses")));
+  }
+}
diff --git a/util/src/test/java/io/grpc/util/GracefulSwitchLoadBalancerTest.java b/util/src/test/java/io/grpc/util/GracefulSwitchLoadBalancerTest.java
new file mode 100644
index 00000000000..8f87dab5da6
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/GracefulSwitchLoadBalancerTest.java
@@ -0,0 +1,744 @@
+/*
+ * Copyright 2019 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.testing.EqualsTester;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InOrder;
+
+/**
+ * Tests for {@link GracefulSwitchLoadBalancer}.
+ */
+@RunWith(JUnit4.class)
+public class GracefulSwitchLoadBalancerTest {
+  private static final Object FAKE_CONFIG = new Object();
+
+  private final Map<LoadBalancerProvider, LoadBalancer> balancers = new HashMap<>();
+  private final Map<LoadBalancer, Helper> helpers = new HashMap<>();
+  private final Helper mockHelper = mock(Helper.class);
+  private final GracefulSwitchLoadBalancer gracefulSwitchLb =
+      new GracefulSwitchLoadBalancer(mockHelper);
+  private final LoadBalancerProvider[] lbPolicies = {
+    new FakeLoadBalancerProvider("lb_policy_0"),
+    new FakeLoadBalancerProvider("lb_policy_1"),
+    new FakeLoadBalancerProvider("lb_policy_2"),
+    new FakeLoadBalancerProvider("lb_policy_3"),
+  };
+
+  @Test
+  public void transientFailureOnInitialResolutionError() {
+    gracefulSwitchLb.handleNameResolutionError(Status.DATA_LOSS);
+    ArgumentCaptor<SubchannelPicker> pickerCaptor = ArgumentCaptor.forClass(SubchannelPicker.class);
+    verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertThat(picker.pickSubchannel(mock(PickSubchannelArgs.class)).getStatus().getCode())
+        .isEqualTo(Status.Code.DATA_LOSS);
+  }
+
+  @Deprecated
+  @Test
+  public void handleSubchannelState_shouldThrow() {
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], new Object()))
+        .build()));
+    Subchannel subchannel = mock(Subchannel.class);
+    ConnectivityStateInfo connectivityStateInfo = ConnectivityStateInfo.forNonError(READY);
+    assertThrows(UnsupportedOperationException.class,
+        () -> gracefulSwitchLb.handleSubchannelState(subchannel, connectivityStateInfo));
+  }
+
+  @Test
+  public void canHandleEmptyAddressListFromNameResolutionForwardedToLatestPolicy() {
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], new Object()))
+        .build()));
+    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
+    Helper helper0 = helpers.get(lb0);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(READY, picker);
+
+    assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isFalse();
+    when(lb0.canHandleEmptyAddressListFromNameResolution()).thenReturn(true);
+    assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isTrue();
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[1], new Object()))
+        .build()));
+    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
+
+    assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isFalse();
+
+    when(lb1.canHandleEmptyAddressListFromNameResolution()).thenReturn(true);
+    assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isTrue();
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[2], new Object()))
+        .build()));
+    LoadBalancer lb2 = balancers.get(lbPolicies[2]);
+
+    assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isFalse();
+
+    when(lb2.canHandleEmptyAddressListFromNameResolution()).thenReturn(true);
+    assertThat(gracefulSwitchLb.canHandleEmptyAddressListFromNameResolution()).isTrue();
+  }
+
+  @Test
+  public void handleResolvedAddressesAndNameResolutionErrorForwardedToLatestPolicy() {
+    ResolvedAddresses addresses = newFakeAddresses();
+    Object child0Config = new Object();
+    gracefulSwitchLb.handleResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], child0Config))
+        .build());
+    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
+    verify(lb0).handleResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(child0Config)
+        .build());
+    Helper helper0 = helpers.get(lb0);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(READY, picker);
+    gracefulSwitchLb.handleNameResolutionError(Status.DATA_LOSS);
+    verify(lb0).handleNameResolutionError(Status.DATA_LOSS);
+
+    Object child1Config = new Object();
+    addresses = newFakeAddresses();
+    gracefulSwitchLb.handleResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[1], child1Config))
+        .build());
+    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
+    verify(lb0, never()).handleResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(child1Config)
+        .build());
+    verify(lb1).handleResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(child1Config)
+        .build());
+    gracefulSwitchLb.handleNameResolutionError(Status.ALREADY_EXISTS);
+    verify(lb0, never()).handleNameResolutionError(Status.ALREADY_EXISTS);
+    verify(lb1).handleNameResolutionError(Status.ALREADY_EXISTS);
+
+    Object child2Config = new Object();
+    addresses = newFakeAddresses();
+    gracefulSwitchLb.handleResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[2], child2Config))
+        .build());
+    verify(lb1).shutdown();
+    LoadBalancer lb2 = balancers.get(lbPolicies[2]);
+    verify(lb0, never()).handleResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(child2Config)
+        .build());
+    verify(lb1, never()).handleResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(child2Config)
+        .build());
+    verify(lb2).handleResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(child2Config)
+        .build());
+    gracefulSwitchLb.handleNameResolutionError(Status.CANCELLED);
+    verify(lb0, never()).handleNameResolutionError(Status.CANCELLED);
+    verify(lb1, never()).handleNameResolutionError(Status.CANCELLED);
+    verify(lb2).handleNameResolutionError(Status.CANCELLED);
+
+    verifyNoMoreInteractions(lb0, lb1, lb2);
+  }
+
+  @Test
+  public void acceptResolvedAddressesAndNameResolutionErrorForwardedToLatestPolicy() {
+    ResolvedAddresses addresses = newFakeAddresses();
+    Object child0Config = new Object();
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], child0Config))
+        .build()));
+    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
+    verify(lb0).acceptResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(child0Config)
+        .build());
+    Helper helper0 = helpers.get(lb0);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(READY, picker);
+    gracefulSwitchLb.handleNameResolutionError(Status.DATA_LOSS);
+    verify(lb0).handleNameResolutionError(Status.DATA_LOSS);
+
+    Object child1Config = new Object();
+    addresses = newFakeAddresses();
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[1], child1Config))
+        .build()));
+    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
+    verify(lb0, never()).acceptResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(child1Config)
+        .build());
+    verify(lb1).acceptResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(child1Config)
+        .build());
+    gracefulSwitchLb.handleNameResolutionError(Status.ALREADY_EXISTS);
+    verify(lb0, never()).handleNameResolutionError(Status.ALREADY_EXISTS);
+    verify(lb1).handleNameResolutionError(Status.ALREADY_EXISTS);
+
+    Object child2Config = new Object();
+    addresses = newFakeAddresses();
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[2], child2Config))
+        .build()));
+    verify(lb1).shutdown();
+    LoadBalancer lb2 = balancers.get(lbPolicies[2]);
+    verify(lb0, never()).acceptResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(child2Config)
+        .build());
+    verify(lb1, never()).acceptResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(child2Config)
+        .build());
+    verify(lb2).acceptResolvedAddresses(addresses.toBuilder()
+        .setLoadBalancingPolicyConfig(child2Config)
+        .build());
+    gracefulSwitchLb.handleNameResolutionError(Status.CANCELLED);
+    verify(lb0, never()).handleNameResolutionError(Status.CANCELLED);
+    verify(lb1, never()).handleNameResolutionError(Status.CANCELLED);
+    verify(lb2).handleNameResolutionError(Status.CANCELLED);
+
+    verifyNoMoreInteractions(lb0, lb1, lb2);
+  }
+
+  @Test
+  public void shutdownTriggeredWhenSwitchAndForwardedWhenSwitchLbShutdown() {
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], new Object()))
+        .build()));
+    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
+    Helper helper0 = helpers.get(lb0);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(READY, picker);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[1], new Object()))
+        .build()));
+    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
+    verify(lb1, never()).shutdown();
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[2], new Object()))
+        .build()));
+    verify(lb1).shutdown();
+    LoadBalancer lb2 = balancers.get(lbPolicies[2]);
+    verify(lb0, never()).shutdown();
+    helpers.get(lb2).updateBalancingState(READY, mock(SubchannelPicker.class));
+    verify(lb0).shutdown();
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[3], new Object()))
+        .build()));
+    LoadBalancer lb3 = balancers.get(lbPolicies[3]);
+    verify(lb2, never()).shutdown();
+    verify(lb3, never()).shutdown();
+
+    gracefulSwitchLb.shutdown();
+    verify(lb2).shutdown();
+    verify(lb3).shutdown();
+  }
+
+  @Test
+  public void requestConnectionForwardedToLatestPolicies() {
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], new Object()))
+        .build()));
+    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
+    Helper helper0 = helpers.get(lb0);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(READY, picker);
+
+    gracefulSwitchLb.requestConnection();
+    verify(lb0).requestConnection();
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[1], new Object()))
+        .build()));
+    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
+    gracefulSwitchLb.requestConnection();
+    verify(lb1).requestConnection();
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[2], new Object()))
+        .build()));
+    verify(lb1).shutdown();
+    LoadBalancer lb2 = balancers.get(lbPolicies[2]);
+    gracefulSwitchLb.requestConnection();
+    verify(lb2).requestConnection();
+
+    // lb2 reports READY
+    helpers.get(lb2).updateBalancingState(READY, mock(SubchannelPicker.class));
+    verify(lb0).shutdown();
+
+    gracefulSwitchLb.requestConnection();
+    verify(lb2, times(2)).requestConnection();
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[3], new Object()))
+        .build()));
+    LoadBalancer lb3 = balancers.get(lbPolicies[3]);
+    gracefulSwitchLb.requestConnection();
+    verify(lb3).requestConnection();
+  }
+
+  @Test
+  public void createSubchannelForwarded() {
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], new Object()))
+        .build()));
+    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
+    Helper helper0 = helpers.get(lb0);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(READY, picker);
+
+    CreateSubchannelArgs createSubchannelArgs = newFakeCreateSubchannelArgs();
+    helper0.createSubchannel(createSubchannelArgs);
+    verify(mockHelper).createSubchannel(createSubchannelArgs);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[1], new Object()))
+        .build()));
+    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
+    Helper helper1 = helpers.get(lb1);
+    createSubchannelArgs = newFakeCreateSubchannelArgs();
+    helper1.createSubchannel(createSubchannelArgs);
+    verify(mockHelper).createSubchannel(createSubchannelArgs);
+
+    createSubchannelArgs = newFakeCreateSubchannelArgs();
+    helper0.createSubchannel(createSubchannelArgs);
+    verify(mockHelper).createSubchannel(createSubchannelArgs);
+  }
+
+  @Test
+  public void updateBalancingStateIsGraceful_Ready() {
+    updateBalancingStateIsGraceful(READY);
+  }
+
+  @Test
+  public void updateBalancingStateIsGraceful_TransientFailure() {
+    updateBalancingStateIsGraceful(TRANSIENT_FAILURE);
+  }
+
+  @Test
+  public void updateBalancingStateIsGraceful_Idle() {
+    updateBalancingStateIsGraceful(IDLE);
+  }
+
+  public void updateBalancingStateIsGraceful(ConnectivityState swapsOnState) {
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], new Object()))
+        .build()));
+    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
+    Helper helper0 = helpers.get(lb0);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(READY, picker);
+    verify(mockHelper).updateBalancingState(READY, picker);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[1], new Object()))
+        .build()));
+    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
+    Helper helper1 = helpers.get(lb1);
+    picker = mock(SubchannelPicker.class);
+    helper1.updateBalancingState(CONNECTING, picker);
+    verify(mockHelper, never()).updateBalancingState(CONNECTING, picker);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[2], new Object()))
+        .build()));
+    verify(lb1).shutdown();
+    LoadBalancer lb2 = balancers.get(lbPolicies[2]);
+    Helper helper2 = helpers.get(lb2);
+    picker = mock(SubchannelPicker.class);
+    helper2.updateBalancingState(CONNECTING, picker);
+    verify(mockHelper, never()).updateBalancingState(CONNECTING, picker);
+
+    // lb2 reports swapsOnState
+    SubchannelPicker picker2 = mock(SubchannelPicker.class);
+    helper2.updateBalancingState(swapsOnState, picker2);
+    verify(lb0).shutdown();
+    verify(mockHelper).updateBalancingState(swapsOnState, picker2);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[3], new Object()))
+        .build()));
+    LoadBalancer lb3 = balancers.get(lbPolicies[3]);
+    Helper helper3 = helpers.get(lb3);
+    SubchannelPicker picker3 = mock(SubchannelPicker.class);
+    helper3.updateBalancingState(CONNECTING, picker3);
+    verify(mockHelper, never()).updateBalancingState(CONNECTING, picker3);
+
+    // lb2 out of swapsOnState
+    picker2 = mock(SubchannelPicker.class);
+    helper2.updateBalancingState(CONNECTING, picker2);
+    verify(mockHelper, never()).updateBalancingState(CONNECTING, picker2);
+    verify(mockHelper).updateBalancingState(CONNECTING, picker3);
+    verify(lb2).shutdown();
+
+    picker3 = mock(SubchannelPicker.class);
+    helper3.updateBalancingState(CONNECTING, picker3);
+    verify(mockHelper).updateBalancingState(CONNECTING, picker3);
+  }
+
+  @Test
+  public void switchWhileOldPolicyIsNotReady() {
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], new Object()))
+        .build()));
+    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
+    Helper helper0 = helpers.get(lb0);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(READY, picker);
+    picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(CONNECTING, picker);
+
+    verify(lb0, never()).shutdown();
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[1], new Object()))
+        .build()));
+    verify(lb0).shutdown();
+    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
+
+    Helper helper1 = helpers.get(lb1);
+    picker = mock(SubchannelPicker.class);
+    helper1.updateBalancingState(CONNECTING, picker);
+    verify(mockHelper).updateBalancingState(CONNECTING, picker);
+
+    verify(lb1, never()).shutdown();
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[2], new Object()))
+        .build()));
+    verify(lb1).shutdown();
+  }
+
+  @Test
+  public void switchWhileOldPolicyGoesFromReadyToNotReady() {
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], new Object()))
+        .build()));
+    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
+    Helper helper0 = helpers.get(lb0);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(READY, picker);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[1], new Object()))
+        .build()));
+    verify(lb0, never()).shutdown();
+
+    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
+    Helper helper1 = helpers.get(lb1);
+    SubchannelPicker picker1 = mock(SubchannelPicker.class);
+    helper1.updateBalancingState(CONNECTING, picker1);
+    verify(mockHelper, never()).updateBalancingState(CONNECTING, picker1);
+
+    picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(CONNECTING, picker);
+    verify(lb0).shutdown();
+    verify(mockHelper, never()).updateBalancingState(CONNECTING, picker);
+    verify(mockHelper).updateBalancingState(CONNECTING, picker1);
+
+    picker1 = mock(SubchannelPicker.class);
+    helper1.updateBalancingState(READY, picker1);
+    verify(mockHelper).updateBalancingState(READY, picker1);
+  }
+
+  @Test
+  public void switchWhileOldPolicyGoesFromReadyToNotReadyWhileNewPolicyStillIdle() {
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], new Object()))
+        .build()));
+    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
+    InOrder inOrder = inOrder(lb0, mockHelper);
+    Helper helper0 = helpers.get(lb0);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(READY, picker);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[1], new Object()))
+        .build()));
+    verify(lb0, never()).shutdown();
+
+    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
+    Helper helper1 = helpers.get(lb1);
+
+    picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(CONNECTING, picker);
+
+    verify(mockHelper, never()).updateBalancingState(CONNECTING, picker);
+    ArgumentCaptor<SubchannelPicker> pickerCaptor = ArgumentCaptor.forClass(SubchannelPicker.class);
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    assertThat(pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class)).hasResult())
+        .isFalse();
+
+    inOrder.verify(lb0).shutdown(); // shutdown after update
+
+    picker = mock(SubchannelPicker.class);
+    helper1.updateBalancingState(CONNECTING, picker);
+    inOrder.verify(mockHelper).updateBalancingState(CONNECTING, picker);
+  }
+
+  @Test
+  public void newPolicyNameTheSameAsPendingPolicy_shouldHaveNoEffect() {
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], new Object()))
+        .build()));
+    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
+    Helper helper0 = helpers.get(lb0);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(READY, picker);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[1], new Object()))
+        .build()));
+    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[1], new Object()))
+        .build()));
+    assertThat(balancers.get(lbPolicies[1])).isSameInstanceAs(lb1);
+  }
+
+  @Test
+  public void newPolicyNameTheSameAsCurrentPolicy_shouldShutdownPendingLb() {
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], new Object()))
+        .build()));
+    LoadBalancer lb0 = balancers.get(lbPolicies[0]);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], new Object()))
+        .build()));
+    assertThat(balancers.get(lbPolicies[0])).isSameInstanceAs(lb0);
+
+    Helper helper0 = helpers.get(lb0);
+    SubchannelPicker picker = mock(SubchannelPicker.class);
+    helper0.updateBalancingState(READY, picker);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[1], new Object()))
+        .build()));
+    LoadBalancer lb1 = balancers.get(lbPolicies[1]);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(lbPolicies[0], new Object()))
+        .build()));
+    verify(lb1).shutdown();
+    assertThat(balancers.get(lbPolicies[0])).isSameInstanceAs(lb0);
+  }
+
+
+  @Test
+  public void newLbFactoryEqualToOldOneShouldHaveNoEffect() {
+    final List<LoadBalancer> balancers = new ArrayList<>();
+
+    final class LoadBalancerFactoryWithId extends LoadBalancer.Factory {
+      final int id;
+
+      LoadBalancerFactoryWithId(int id) {
+        this.id = id;
+      }
+
+      @Override
+      public LoadBalancer newLoadBalancer(Helper helper) {
+        LoadBalancer balancer = mock(LoadBalancer.class);
+        when(balancer.acceptResolvedAddresses(any())).thenReturn(Status.OK);
+        balancers.add(balancer);
+        return balancer;
+      }
+
+      @Override
+      public boolean equals(Object o) {
+        if (!(o instanceof LoadBalancerFactoryWithId)) {
+          return false;
+        }
+        LoadBalancerFactoryWithId that = (LoadBalancerFactoryWithId) o;
+        return id == that.id;
+      }
+
+      @Override
+      public int hashCode() {
+        return id;
+      }
+    }
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(new LoadBalancerFactoryWithId(0), new Object()))
+        .build()));
+    assertThat(balancers).hasSize(1);
+    LoadBalancer lb0 = balancers.get(0);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(new LoadBalancerFactoryWithId(0), new Object()))
+        .build()));
+    assertThat(balancers).hasSize(1);
+
+    assertIsOk(gracefulSwitchLb.acceptResolvedAddresses(addressesBuilder()
+        .setLoadBalancingPolicyConfig(createConfig(new LoadBalancerFactoryWithId(1), new Object()))
+        .build()));
+    assertThat(balancers).hasSize(2);
+    verify(lb0).shutdown();
+  }
+
+  @Test
+  public void configEquals() {
+    Object config = new Object();
+    new EqualsTester()
+        .addEqualityGroup(createConfig(lbPolicies[0], config), createConfig(lbPolicies[0], config))
+        .addEqualityGroup(createConfig(lbPolicies[1], config))
+        .addEqualityGroup(createConfig(lbPolicies[0], new Object()))
+        .testEquals();
+  }
+
+  @Test
+  public void parseLoadBalancingPolicyConfig_null_fails() {
+    ConfigOrError result = GracefulSwitchLoadBalancer.parseLoadBalancingPolicyConfig(null);
+    assertThat(result.getError()).isNotNull();
+  }
+
+  @Test
+  public void parseLoadBalancingPolicyConfig_empty_fails() {
+    ConfigOrError result = GracefulSwitchLoadBalancer.parseLoadBalancingPolicyConfig(
+        Arrays.asList());
+    assertThat(result.getError()).isNotNull();
+  }
+
+  @Test
+  public void parseLoadBalancingPolicyConfig_missing_fails() {
+    LoadBalancerRegistry lbRegistry = new LoadBalancerRegistry();
+    ConfigOrError result = GracefulSwitchLoadBalancer.parseLoadBalancingPolicyConfig(
+        Arrays.asList(Collections.singletonMap("lb_policy_0", Collections.emptyMap())), lbRegistry);
+    assertThat(result.getError()).isNotNull();
+  }
+
+  @Test
+  public void parseLoadBalancingPolicyConfig_succeeds() {
+    LoadBalancerRegistry lbRegistry = new LoadBalancerRegistry();
+    lbRegistry.register(lbPolicies[0]);
+    ConfigOrError result = GracefulSwitchLoadBalancer.parseLoadBalancingPolicyConfig(
+        Arrays.asList(Collections.singletonMap("lb_policy_0", Collections.emptyMap())), lbRegistry);
+    assertThat(result.getError()).isNull();
+    assertThat(result.getConfig()).isInstanceOf(GracefulSwitchLoadBalancer.Config.class);
+    GracefulSwitchLoadBalancer.Config config =
+        (GracefulSwitchLoadBalancer.Config) result.getConfig();
+    assertThat(config.childFactory).isEqualTo(lbPolicies[0]);
+    assertThat(config.childConfig).isEqualTo(FAKE_CONFIG);
+  }
+
+  private final class FakeLoadBalancerProvider extends LoadBalancerProvider {
+
+    final String policyName;
+
+    FakeLoadBalancerProvider(String policyName) {
+      this.policyName = policyName;
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 5;
+    }
+
+    @Override
+    public String getPolicyName() {
+      return policyName;
+    }
+
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      LoadBalancer balancer = mock(LoadBalancer.class);
+      when(balancer.acceptResolvedAddresses(any())).thenReturn(Status.OK);
+      balancers.put(this, balancer);
+      helpers.put(balancer, helper);
+      return balancer;
+    }
+
+    @Override
+    public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
+      return ConfigOrError.fromConfig(FAKE_CONFIG);
+    }
+  }
+
+  private static void assertIsOk(Status status) {
+    assertThat(status.isOk()).isTrue();
+  }
+
+  private ResolvedAddresses.Builder addressesBuilder() {
+    return ResolvedAddresses.newBuilder()
+        .setAddresses(
+            Collections.singletonList(new EquivalentAddressGroup(mock(SocketAddress.class))));
+  }
+
+  private static Object createConfig(
+      LoadBalancer.Factory childFactory, Object childConfig) {
+    return GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(childFactory, childConfig);
+  }
+
+  private static ResolvedAddresses newFakeAddresses() {
+    return ResolvedAddresses
+        .newBuilder()
+        .setAddresses(
+            Collections.singletonList(new EquivalentAddressGroup(mock(SocketAddress.class))))
+        .build();
+  }
+
+  private static CreateSubchannelArgs newFakeCreateSubchannelArgs() {
+    return CreateSubchannelArgs
+        .newBuilder()
+        .setAddresses(new EquivalentAddressGroup(mock(SocketAddress.class)))
+        .build();
+  }
+}
diff --git a/util/src/test/java/io/grpc/util/HealthProducerHelperTest.java b/util/src/test/java/io/grpc/util/HealthProducerHelperTest.java
new file mode 100644
index 00000000000..fa2abe8e904
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/HealthProducerHelperTest.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2023 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.LoadBalancer.HAS_HEALTH_PRODUCER_LISTENER_KEY;
+import static io.grpc.LoadBalancer.HEALTH_CONSUMER_LISTENER_ARG_KEY;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+import io.grpc.Attributes;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.Status;
+import java.net.InetSocketAddress;
+import java.util.Collections;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class HealthProducerHelperTest {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock
+  private LoadBalancer.Helper mockHelper;
+
+  @Mock
+  private LoadBalancer.Subchannel mockSubchannel;
+
+  @Mock
+  private LoadBalancer.SubchannelStateListener healthConsumerListener;
+
+  @Captor
+  ArgumentCaptor<LoadBalancer.CreateSubchannelArgs> createSubchannelArgCaptor;
+
+  @Before
+  public void setup() {
+    when(mockHelper.createSubchannel(
+        any(LoadBalancer.CreateSubchannelArgs.class))).thenReturn(mockSubchannel);
+    when(mockSubchannel.getAttributes()).thenReturn(Attributes.EMPTY);
+  }
+
+  @Test
+  public void helper_parentProducer() {
+    LoadBalancer.Helper producerHelper = new HealthProducerHelper(mockHelper);
+    HealthProducerHelper.HealthProducerSubchannel subchannel =
+        (HealthProducerHelper.HealthProducerSubchannel) producerHelper.createSubchannel(
+            LoadBalancer.CreateSubchannelArgs.newBuilder()
+                .addOption(HEALTH_CONSUMER_LISTENER_ARG_KEY, healthConsumerListener)
+                .setAddresses(new EquivalentAddressGroup(
+                    Collections.singletonList(new InetSocketAddress(10))))
+                .build());
+    verify(mockHelper).createSubchannel(createSubchannelArgCaptor.capture());
+    assertThat(mockSubchannel).isSameInstanceAs(subchannel.delegate());
+    assertThat(subchannel.getAttributes().get(HAS_HEALTH_PRODUCER_LISTENER_KEY))
+        .isEqualTo(Boolean.TRUE);
+    assertThat(createSubchannelArgCaptor.getValue().getOption(HEALTH_CONSUMER_LISTENER_ARG_KEY))
+        .isEqualTo(healthConsumerListener);
+
+    LoadBalancer.SubchannelStateListener listener =
+        mock(LoadBalancer.SubchannelStateListener.class);
+    subchannel.start(listener);
+    ArgumentCaptor<LoadBalancer.SubchannelStateListener> listenerCaptor =
+        ArgumentCaptor.forClass(LoadBalancer.SubchannelStateListener.class);
+    verify(mockSubchannel).start(listenerCaptor.capture());
+    listenerCaptor.getValue().onSubchannelState(
+        ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+    verify(healthConsumerListener)
+        .onSubchannelState(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+    verify(listener)
+        .onSubchannelState(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+  }
+
+  @Test
+  public void helper_notParentProducer() {
+    when(mockHelper.createSubchannel(any(LoadBalancer.CreateSubchannelArgs.class))).thenReturn(
+        new HealthProducerHelper.HealthProducerSubchannel(
+            mockSubchannel, mock(LoadBalancer.SubchannelStateListener.class)));
+    LoadBalancer.Helper producerHelper = new HealthProducerHelper(mockHelper);
+    HealthProducerHelper.HealthProducerSubchannel subchannel =
+        (HealthProducerHelper.HealthProducerSubchannel) producerHelper.createSubchannel(
+            LoadBalancer.CreateSubchannelArgs.newBuilder()
+                .addOption(HEALTH_CONSUMER_LISTENER_ARG_KEY, healthConsumerListener)
+                .setAddresses(new EquivalentAddressGroup(
+                    Collections.singletonList(new InetSocketAddress(10))))
+                .build());
+    verify(mockHelper).createSubchannel(createSubchannelArgCaptor.capture());
+    assertThat(mockSubchannel).isSameInstanceAs(subchannel.delegate());
+    assertThat(subchannel.getAttributes().get(HAS_HEALTH_PRODUCER_LISTENER_KEY))
+        .isEqualTo(Boolean.TRUE);
+    LoadBalancer.SubchannelStateListener listener =
+        mock(LoadBalancer.SubchannelStateListener.class);
+    subchannel.start(listener);
+    ArgumentCaptor<LoadBalancer.SubchannelStateListener> listenerCaptor =
+        ArgumentCaptor.forClass(LoadBalancer.SubchannelStateListener.class);
+    verify(mockSubchannel).start(listenerCaptor.capture());
+    LoadBalancer.SubchannelStateListener parentListener = listenerCaptor.getValue();
+    parentListener.onSubchannelState(
+        ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING));
+    verify(listener).onSubchannelState(
+        ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING));
+    parentListener.onSubchannelState(
+        ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    verify(listener).onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    verifyNoInteractions(healthConsumerListener);
+  }
+}
diff --git a/util/src/test/java/io/grpc/util/MultiChildLoadBalancerTest.java b/util/src/test/java/io/grpc/util/MultiChildLoadBalancerTest.java
new file mode 100644
index 00000000000..14dc8518756
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/MultiChildLoadBalancerTest.java
@@ -0,0 +1,428 @@
+/*
+ * Copyright 2023 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.Lists;
+import com.google.common.testing.EqualsTester;
+import io.grpc.Attributes;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.Status;
+import io.grpc.internal.PickFirstLoadBalancerProvider;
+import io.grpc.util.AbstractTestHelper.FakeSocketAddress;
+import io.grpc.util.MultiChildLoadBalancer.ChildLbState;
+import io.grpc.util.MultiChildLoadBalancer.Endpoint;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class MultiChildLoadBalancerTest {
+  private static final Attributes.Key<String> FOO = Attributes.Key.create("foo");
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private final List<EquivalentAddressGroup> servers = Lists.newArrayList();
+  private final Map<List<EquivalentAddressGroup>, LoadBalancer.Subchannel> subchannels =
+      new ConcurrentHashMap<>();
+  private final Attributes affinity = Attributes.newBuilder().set(FOO, "bar").build();
+  @Captor
+  private ArgumentCaptor<LoadBalancer.SubchannelPicker> pickerCaptor;
+  @Captor
+  private ArgumentCaptor<ConnectivityState> stateCaptor;
+  @Captor
+  private ArgumentCaptor<LoadBalancer.CreateSubchannelArgs> createArgsCaptor;
+  private final TestHelper testHelperInst = new TestHelper();
+  private final LoadBalancer.Helper mockHelper =
+      mock(LoadBalancer.Helper.class, delegatesTo(testHelperInst));
+  private TestLb loadBalancer;
+
+
+  @Before
+  public void setUp() {
+    for (int i = 0; i < 3; i++) {
+      SocketAddress addr = new FakeSocketAddress("server" + i);
+      EquivalentAddressGroup eag = new EquivalentAddressGroup(addr);
+      servers.add(eag);
+    }
+
+    loadBalancer = new TestLb(mockHelper);
+  }
+
+  @Test
+  public void pickAfterResolved() {
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        LoadBalancer.ResolvedAddresses.newBuilder().setAddresses(servers).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    final LoadBalancer.Subchannel readySubchannel = subchannels.values().iterator().next();
+    deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
+
+    verify(mockHelper, times(3)).createSubchannel(createArgsCaptor.capture());
+    List<List<EquivalentAddressGroup>> capturedAddrs = new ArrayList<>();
+    for (LoadBalancer.CreateSubchannelArgs arg : createArgsCaptor.getAllValues()) {
+      capturedAddrs.add(arg.getAddresses());
+    }
+
+    assertThat(capturedAddrs).containsAtLeastElementsIn(subchannels.keySet());
+    for (LoadBalancer.Subchannel subchannel : subchannels.values()) {
+      verify(subchannel).requestConnection();
+      verify(subchannel, never()).shutdown();
+    }
+
+    verify(mockHelper, times(2))
+        .updateBalancingState(stateCaptor.capture(), pickerCaptor.capture());
+
+    assertEquals(CONNECTING, stateCaptor.getAllValues().get(0));
+    assertEquals(READY, stateCaptor.getAllValues().get(1));
+    TestLb.TestSubchannelPicker subchannelPicker =
+        (TestLb.TestSubchannelPicker) pickerCaptor.getValue();
+    assertThat(subchannelPicker.getReadySubchannels()).containsExactly(readySubchannel);
+
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(mockHelper);
+  }
+
+  @Test
+  public void pickAfterResolvedUpdatedHosts() {
+    Attributes.Key<String> key = Attributes.Key.create("check-that-it-is-propagated");
+    FakeSocketAddress removedAddr = new FakeSocketAddress("removed");
+    EquivalentAddressGroup removedEag = new EquivalentAddressGroup(removedAddr);
+    FakeSocketAddress oldAddr = new FakeSocketAddress("old");
+    EquivalentAddressGroup oldEag1 = new EquivalentAddressGroup(oldAddr);
+    EquivalentAddressGroup oldEag2 = new EquivalentAddressGroup(
+        oldAddr, Attributes.newBuilder().set(key, "oldattr").build());
+    FakeSocketAddress newAddr = new FakeSocketAddress("new");
+    EquivalentAddressGroup newEag = new EquivalentAddressGroup(
+        newAddr, Attributes.newBuilder().set(key, "newattr").build());
+
+    List<EquivalentAddressGroup> currentServers = Lists.newArrayList(removedEag, oldEag1);
+
+    InOrder inOrder = inOrder(mockHelper);
+
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        LoadBalancer.ResolvedAddresses.newBuilder().setAddresses(currentServers).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    LoadBalancer.Subchannel removedSubchannel = getSubchannel(removedEag);
+    LoadBalancer.Subchannel oldSubchannel = getSubchannel(oldEag1);
+    LoadBalancer.SubchannelStateListener removedListener =
+        testHelperInst.getSubchannelStateListener(removedSubchannel);
+
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+
+    deliverSubchannelState(removedSubchannel, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(oldSubchannel, ConnectivityStateInfo.forNonError(READY));
+
+    inOrder.verify(mockHelper, times(2)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    LoadBalancer.SubchannelPicker picker = pickerCaptor.getValue();
+    assertThat(getList(picker)).containsExactly(removedSubchannel, oldSubchannel);
+
+    verify(removedSubchannel, times(1)).requestConnection();
+    verify(oldSubchannel, times(1)).requestConnection();
+
+    // This time with Attributes
+    List<EquivalentAddressGroup> latestServers = Lists.newArrayList(oldEag2, newEag);
+
+    addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        LoadBalancer.ResolvedAddresses.newBuilder().setAddresses(latestServers).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+
+    LoadBalancer.Subchannel newSubchannel = getSubchannel(newEag);
+
+    verify(newSubchannel, times(1)).requestConnection();
+    verify(oldSubchannel, times(1)).updateAddresses(Arrays.asList(oldEag2));
+    verify(removedSubchannel, times(1)).shutdown();
+
+    removedListener.onSubchannelState(ConnectivityStateInfo.forNonError(SHUTDOWN));
+    deliverSubchannelState(newSubchannel, ConnectivityStateInfo.forNonError(READY));
+
+    verify(mockHelper, times(3)).createSubchannel(any(LoadBalancer.CreateSubchannelArgs.class));
+    inOrder.verify(mockHelper, times(2)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    picker = pickerCaptor.getValue();
+    assertThat(getList(picker)).containsExactly(oldSubchannel, newSubchannel);
+
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(mockHelper);
+  }
+
+  @Test
+  public void pickFromMultiAddressEags() {
+    List<SocketAddress> addressList1 = new ArrayList<>();
+    List<SocketAddress> addressList2 = new ArrayList<>();
+    for (int i = 0; i < 3; i++) {
+      if (i % 2 == 0) {
+        addressList1.add(new FakeSocketAddress("multi_" + i));
+      } else {
+        addressList2.add(new FakeSocketAddress("multi_" + i));
+      }
+    }
+
+    EquivalentAddressGroup eag1 = new EquivalentAddressGroup(addressList1, Attributes.EMPTY);
+    EquivalentAddressGroup eag2 = new EquivalentAddressGroup(addressList2, Attributes.EMPTY);
+
+    List<EquivalentAddressGroup> multiGroups = Arrays.asList(eag1, eag2);
+
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        LoadBalancer.ResolvedAddresses.newBuilder().setAddresses(multiGroups).build());
+
+    assertTrue(addressesAcceptanceStatus.isOk());
+    LoadBalancer.Subchannel evens = getSubchannel(eag1);
+    deliverSubchannelState(evens, ConnectivityStateInfo.forNonError(READY));
+    verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertThat(pickerCaptor.getValue()).isInstanceOf(TestLb.TestSubchannelPicker.class);
+    assertThat(((TestLb.TestSubchannelPicker)pickerCaptor.getValue()).childPickerMap).hasSize(2);
+  }
+
+  @Test
+  public void testEndpoint_toString() {
+    try {
+      new Endpoint(null);
+      fail("No exception thrown for null");
+    } catch (NullPointerException e) {
+      assertThat(e.getMessage()).contains("eag");
+    }
+    
+    // Simple eag
+    EquivalentAddressGroup eagSimple = servers.get(0);
+    Endpoint simple = new Endpoint(eagSimple);
+    assertEquals(addressesOnlyString(eagSimple), simple.toString());
+    
+    // Multiple address eag
+    EquivalentAddressGroup eagMulti = createEag("addr1", "addr2");
+    Endpoint multi = new Endpoint(eagMulti);
+    assertEquals(addressesOnlyString(eagMulti), multi.toString());
+  }
+
+  @Test
+  public void testEndpoint_equals() {
+    new EqualsTester()
+        .addEqualityGroup(
+            createEndpoint(Attributes.EMPTY, "addr1"),
+            createEndpoint(Attributes.EMPTY, "addr1"))
+        .addEqualityGroup(
+            createEndpoint(Attributes.EMPTY, "addr1", "addr2"),
+            createEndpoint(Attributes.EMPTY, "addr2", "addr1"),
+            createEndpoint(affinity, "addr1", "addr2"))
+        .addEqualityGroup(
+            createEndpoint(Attributes.EMPTY, "addr1", "addr3"))
+        .addEqualityGroup(
+            createEndpoint(Attributes.EMPTY, "addr1", "addr2", "addr3", "addr4", "addr5", "addr6",
+              "addr7", "addr8", "addr9", "addr10"),
+            createEndpoint(Attributes.EMPTY, "addr2", "addr1", "addr3", "addr4", "addr5", "addr6",
+              "addr7", "addr8", "addr9", "addr10"))
+        .addEqualityGroup(
+            createEndpoint(Attributes.EMPTY, "addr1", "addr2", "addr3", "addr4", "addr5", "addr6",
+              "addr7", "addr8", "addr9", "addr11"))
+        .addEqualityGroup(
+            createEndpoint(Attributes.EMPTY, "addr1", "addr2", "addr3", "addr4", "addr5", "addr6",
+              "addr7", "addr8", "addr9", "addr10", "addr11"))
+        .testEquals();
+  }
+
+  @Test
+  public void offsetIterable_positive() {
+    assertThat(MultiChildLoadBalancer.offsetIterable(Arrays.asList(1, 2, 3, 4), 9))
+        .containsExactly(2, 3, 4, 1)
+        .inOrder();
+    assertThat(MultiChildLoadBalancer.offsetIterable(Arrays.asList(1, 2, 3, 4, 5), 9))
+        .containsExactly(5, 1, 2, 3, 4)
+        .inOrder();
+    assertThat(MultiChildLoadBalancer.offsetIterable(Arrays.asList(1, 2, 3), 3))
+        .containsExactly(1, 2, 3)
+        .inOrder();
+    assertThat(MultiChildLoadBalancer.offsetIterable(Arrays.asList(1, 2, 3), 0))
+        .containsExactly(1, 2, 3)
+        .inOrder();
+    assertThat(MultiChildLoadBalancer.offsetIterable(Arrays.asList(1), 123))
+        .containsExactly(1)
+        .inOrder();
+  }
+
+  @Test
+  public void offsetIterable_negative() {
+    assertThat(MultiChildLoadBalancer.offsetIterable(Arrays.asList(1, 2, 3, 4), -1))
+        .containsExactly(4, 1, 2, 3)
+        .inOrder();
+  }
+
+  @Test
+  public void offsetIterable_empty() {
+    assertThat(MultiChildLoadBalancer.offsetIterable(Arrays.asList(), 1))
+        .isEmpty();
+    assertThat(MultiChildLoadBalancer.offsetIterable(Arrays.asList(), 0))
+        .isEmpty();
+    assertThat(MultiChildLoadBalancer.offsetIterable(Arrays.asList(), -1))
+        .isEmpty();
+  }
+
+  private String addressesOnlyString(EquivalentAddressGroup eag) {
+    if (eag == null) {
+      return null;
+    }
+
+    String withoutAttrs = eag.toString().replaceAll("\\/\\{\\}","");
+    return "[" + withoutAttrs.replaceAll("[\\[\\]]", "") + "]";
+  }
+
+  @SuppressWarnings("MixedMutabilityReturnType")
+  private List<LoadBalancer.Subchannel> getList(LoadBalancer.SubchannelPicker picker) {
+    if (picker instanceof LoadBalancer.FixedResultPicker) {
+      LoadBalancer.Subchannel subchannel = picker.pickSubchannel(null).getSubchannel();
+      return subchannel != null ? Collections.singletonList(subchannel) : Collections.emptyList();
+    }
+    if (picker instanceof TestLb.TestSubchannelPicker) {
+      List<LoadBalancer.Subchannel> subchannelsInPicker = new ArrayList<>();
+      for (LoadBalancer.SubchannelPicker childPicker :
+          ((TestLb.TestSubchannelPicker)picker).childPickerMap.values()) {
+        subchannelsInPicker.add(childPicker.pickSubchannel(null).getSubchannel());
+      }
+      return subchannelsInPicker;
+    }
+    return Collections.emptyList();
+  }
+
+  private EquivalentAddressGroup createEag(String... names) {
+    List<SocketAddress> addresses = buildAddressList(names);
+    return new EquivalentAddressGroup(addresses, Attributes.EMPTY);
+  }
+
+  private static List<SocketAddress> buildAddressList(String... names) {
+    List<SocketAddress> addresses = new ArrayList<>();
+    for (String name : names) {
+      addresses.add(new FakeSocketAddress(name));
+    }
+    return addresses;
+  }
+
+  private Endpoint createEndpoint(Attributes attr, String... names) {
+    EquivalentAddressGroup eag = new EquivalentAddressGroup(buildAddressList(names), attr);
+    return new Endpoint(eag);
+  }
+  
+  private LoadBalancer.Subchannel getSubchannel(EquivalentAddressGroup eag) {
+    if (PickFirstLoadBalancerProvider.isEnabledNewPickFirst()) {
+      for (SocketAddress addr : eag.getAddresses()) {
+        LoadBalancer.Subchannel subchannel = subchannels.get(
+            Arrays.asList(new EquivalentAddressGroup(addr, eag.getAttributes())));
+        if (subchannel != null) {
+          return subchannel;
+        }
+      }
+    } else {
+      return subchannels.get(Collections.singletonList(eag));
+    }
+
+    return null;
+  }
+
+  private void deliverSubchannelState(LoadBalancer.Subchannel subchannel,
+                                      ConnectivityStateInfo newState) {
+    testHelperInst.deliverSubchannelState(subchannel, newState);
+  }
+
+  private class TestLb extends MultiChildLoadBalancer {
+    protected TestLb(Helper mockHelper) {
+      super(mockHelper);
+    }
+
+    @Override
+    protected void updateOverallBalancingState() {
+      ConnectivityState overallState = null;
+      final Map<Object, SubchannelPicker> childPickers = new HashMap<>();
+      final Map<Object, ConnectivityState> childConnStates = new HashMap<>();
+      for (ChildLbState childLbState : getChildLbStates()) {
+        childPickers.put(childLbState.getKey(), childLbState.getCurrentPicker());
+        childConnStates.put(childLbState.getKey(), childLbState.getCurrentState());
+        overallState = aggregateState(overallState, childLbState.getCurrentState());
+      }
+
+      if (overallState != null) {
+        getHelper().updateBalancingState(
+            overallState, new TestSubchannelPicker(childPickers, childConnStates));
+        currentConnectivityState = overallState;
+      }
+
+    }
+
+    private class TestSubchannelPicker extends SubchannelPicker {
+      Map<Object, SubchannelPicker> childPickerMap;
+      Map<Object, ConnectivityState> childStates = new HashMap<>();
+
+      TestSubchannelPicker(
+          Map<Object, SubchannelPicker> childPickers, Map<Object, ConnectivityState> childStates) {
+        this.childPickerMap = childPickers;
+        this.childStates = childStates;
+      }
+
+      List<Subchannel>  getReadySubchannels() {
+        List<Subchannel> readySubchannels = new ArrayList<>();
+        for ( Map.Entry<Object, ConnectivityState> cur : childStates.entrySet()) {
+          if (cur.getValue() == READY) {
+            Subchannel s = childPickerMap.get(cur.getKey()).pickSubchannel(null).getSubchannel();
+            readySubchannels.add(s);
+          }
+        }
+        return readySubchannels;
+      }
+
+      @Override
+      public PickResult pickSubchannel(PickSubchannelArgs args) {
+        return childPickerMap.values().iterator().next().pickSubchannel(args); // Always use the 1st
+      }
+    }
+  }
+
+  private class TestHelper extends AbstractTestHelper {
+
+    @Override
+    public Map<List<EquivalentAddressGroup>, LoadBalancer.Subchannel> getSubchannelMap() {
+      return subchannels;
+    }
+  }
+
+}
diff --git a/core/src/test/java/io/grpc/util/MutableHandlerRegistryTest.java b/util/src/test/java/io/grpc/util/MutableHandlerRegistryTest.java
similarity index 80%
rename from core/src/test/java/io/grpc/util/MutableHandlerRegistryTest.java
rename to util/src/test/java/io/grpc/util/MutableHandlerRegistryTest.java
index 7235ba0e08f..a9095fcf105 100644
--- a/core/src/test/java/io/grpc/util/MutableHandlerRegistryTest.java
+++ b/util/src/test/java/io/grpc/util/MutableHandlerRegistryTest.java
@@ -1,32 +1,17 @@
 /*
- * Copyright 2014, Google Inc. All rights reserved.
+ * Copyright 2014 The gRPC Authors
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
+ * 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
  *
- *    * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *    * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- *    * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 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.util;
@@ -48,16 +33,20 @@
 import io.grpc.ServiceDescriptor;
 import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
 
 /** Unit tests for {@link MutableHandlerRegistry}. */
 @RunWith(JUnit4.class)
 public class MutableHandlerRegistryTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
   private MutableHandlerRegistry registry = new MutableHandlerRegistry();
 
   @Mock
@@ -75,9 +64,6 @@ public class MutableHandlerRegistryTest {
   @Mock
   private ServerCallHandler<String, Integer> fewHandler;
 
-  @Mock
-  private ServerCallHandler<String, Integer>  otherFlowHandler;
-
   private ServerServiceDefinition basicServiceDefinition;
   private ServerServiceDefinition multiServiceDefinition;
 
@@ -86,7 +72,6 @@ public class MutableHandlerRegistryTest {
 
   @Before
   public void setUp() throws Exception {
-    MockitoAnnotations.initMocks(this);
     MethodDescriptor<String, Integer> flowMethod = MethodDescriptor.<String, Integer>newBuilder()
         .setType(MethodType.UNKNOWN)
         .setFullMethodName("basic/flow")
@@ -114,8 +99,8 @@ public void setUp() throws Exception {
   /** Final checks for all tests. */
   @After
   public void makeSureMocksUnused() {
-    Mockito.verifyZeroInteractions(requestMarshaller);
-    Mockito.verifyZeroInteractions(responseMarshaller);
+    Mockito.verifyNoInteractions(requestMarshaller);
+    Mockito.verifyNoInteractions(responseMarshaller);
     Mockito.verifyNoMoreInteractions(flowHandler);
     Mockito.verifyNoMoreInteractions(coupleHandler);
     Mockito.verifyNoMoreInteractions(fewHandler);
diff --git a/util/src/test/java/io/grpc/util/OutlierDetectionLoadBalancerProviderTest.java b/util/src/test/java/io/grpc/util/OutlierDetectionLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..d87aa85eb4f
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/OutlierDetectionLoadBalancerProviderTest.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright 2022 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import io.grpc.ChannelLogger;
+import io.grpc.InternalServiceProviders;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.JsonParser;
+import io.grpc.util.OutlierDetectionLoadBalancer.OutlierDetectionLoadBalancerConfig;
+import java.io.IOException;
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.util.Map;
+import java.util.concurrent.ScheduledExecutorService;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link OutlierDetectionLoadBalancerProvider}.
+ */
+@RunWith(JUnit4.class)
+public class OutlierDetectionLoadBalancerProviderTest {
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final OutlierDetectionLoadBalancerProvider provider
+      = new OutlierDetectionLoadBalancerProvider();
+
+  @Test
+  public void provided() {
+    for (LoadBalancerProvider current : InternalServiceProviders.getCandidatesViaServiceLoader(
+        LoadBalancerProvider.class, getClass().getClassLoader())) {
+      if (current instanceof OutlierDetectionLoadBalancerProvider) {
+        return;
+      }
+    }
+    fail("OutlierDetectionLoadBalancerProvider not registered");
+  }
+
+  @Test
+  public void providesLoadBalancer() {
+    Helper helper = mock(Helper.class);
+    ChannelLogger channelLogger = mock(ChannelLogger.class);
+
+    when(helper.getChannelLogger()).thenReturn(channelLogger);
+    when(helper.getSynchronizationContext()).thenReturn(syncContext);
+    when(helper.getScheduledExecutorService()).thenReturn(mock(ScheduledExecutorService.class));
+    assertThat(provider.newLoadBalancer(helper))
+        .isInstanceOf(OutlierDetectionLoadBalancer.class);
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_defaults() throws IOException {
+    String lbConfig =
+        "{ \"successRateEjection\" : {}, "
+        + "\"failurePercentageEjection\" : {}, "
+        + "\"childPolicy\" : [{\"round_robin\" : {}}]}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    OutlierDetectionLoadBalancerConfig config
+        = (OutlierDetectionLoadBalancerConfig) configOrError.getConfig();
+    assertThat(config.successRateEjection).isNotNull();
+    assertThat(config.failurePercentageEjection).isNotNull();
+    assertThat(
+        GracefulSwitchLoadBalancerAccessor.getChildProvider(config.childConfig).getPolicyName())
+        .isEqualTo("round_robin");
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_valuesSet() throws IOException {
+    String lbConfig =
+        "{\"interval\" : \"100s\","
+        + " \"baseEjectionTime\" : \"100s\","
+        + " \"maxEjectionTime\" : \"100s\","
+        + " \"maxEjectionPercentage\" : 100,"
+        + " \"successRateEjection\" : {"
+        + "     \"stdevFactor\" : 100,"
+        + "     \"enforcementPercentage\" : 100,"
+        + "     \"minimumHosts\" : 100,"
+        + "     \"requestVolume\" : 100"
+        + "   },"
+        + " \"failurePercentageEjection\" : {"
+        + "     \"threshold\" : 100,"
+        + "     \"enforcementPercentage\" : 100,"
+        + "     \"minimumHosts\" : 100,"
+        + "     \"requestVolume\" : 100"
+        + "   },"
+        + "\"childPolicy\" : [{\"round_robin\" : {}}]}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    OutlierDetectionLoadBalancerConfig config
+        = (OutlierDetectionLoadBalancerConfig) configOrError.getConfig();
+
+    assertThat(config.intervalNanos).isEqualTo(100_000_000_000L);
+    assertThat(config.baseEjectionTimeNanos).isEqualTo(100_000_000_000L);
+    assertThat(config.maxEjectionTimeNanos).isEqualTo(100_000_000_000L);
+    assertThat(config.maxEjectionPercent).isEqualTo(100);
+
+    assertThat(config.successRateEjection).isNotNull();
+    assertThat(config.successRateEjection.stdevFactor).isEqualTo(100);
+    assertThat(config.successRateEjection.enforcementPercentage).isEqualTo(100);
+    assertThat(config.successRateEjection.minimumHosts).isEqualTo(100);
+    assertThat(config.successRateEjection.requestVolume).isEqualTo(100);
+
+    assertThat(config.failurePercentageEjection).isNotNull();
+    assertThat(config.failurePercentageEjection.threshold).isEqualTo(100);
+    assertThat(config.failurePercentageEjection.enforcementPercentage).isEqualTo(100);
+    assertThat(config.failurePercentageEjection.minimumHosts).isEqualTo(100);
+    assertThat(config.failurePercentageEjection.requestVolume).isEqualTo(100);
+
+    assertThat(
+        GracefulSwitchLoadBalancerAccessor.getChildProvider(config.childConfig).getPolicyName())
+        .isEqualTo("round_robin");
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, ?> parseJsonObject(String json) throws IOException {
+    return (Map<String, ?>) JsonParser.parse(json);
+  }
+}
diff --git a/util/src/test/java/io/grpc/util/OutlierDetectionLoadBalancerTest.java b/util/src/test/java/io/grpc/util/OutlierDetectionLoadBalancerTest.java
new file mode 100644
index 00000000000..10436407422
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/OutlierDetectionLoadBalancerTest.java
@@ -0,0 +1,1462 @@
+/*
+ * Copyright 2022 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import io.grpc.ChannelLogger;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.FakeClock.ScheduledTask;
+import io.grpc.internal.TestUtils.StandardLoadBalancerProvider;
+import io.grpc.util.OutlierDetectionLoadBalancer.EndpointTracker;
+import io.grpc.util.OutlierDetectionLoadBalancer.OutlierDetectionLoadBalancerConfig;
+import io.grpc.util.OutlierDetectionLoadBalancer.OutlierDetectionLoadBalancerConfig.FailurePercentageEjection;
+import io.grpc.util.OutlierDetectionLoadBalancer.OutlierDetectionLoadBalancerConfig.SuccessRateEjection;
+import io.grpc.util.OutlierDetectionLoadBalancer.OutlierDetectionSubchannel;
+import io.grpc.util.OutlierDetectionLoadBalancer.SuccessRateOutlierEjectionAlgorithm;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
+
+/**
+ * Unit tests for {@link OutlierDetectionLoadBalancer}.
+ */
+@RunWith(Parameterized.class)
+public class OutlierDetectionLoadBalancerTest {
+  @Parameterized.Parameters(name = "{0}")
+  public static Iterable<Object[]> data() {
+    // Before and after dual stack
+    return Arrays.asList(new Object[][] {
+        {true}, {false}
+    });
+  }
+
+  @Parameterized.Parameter
+  public boolean hasHealthConsumer;
+
+  @Rule
+  public final MockitoRule mockitoRule = MockitoJUnit.rule();
+
+  @Mock
+  private LoadBalancer mockChildLb;
+  @Mock
+  private Helper mockHelper;
+  @Mock
+  private SocketAddress mockSocketAddress;
+  @Mock
+  private ClientStreamTracer.Factory mockStreamTracerFactory;
+  @Mock
+  private ClientStreamTracer mockStreamTracer;
+
+  @Captor
+  private ArgumentCaptor<ConnectivityState> connectivityStateCaptor;
+  @Captor
+  private ArgumentCaptor<SubchannelPicker> errorPickerCaptor;
+  @Captor
+  private ArgumentCaptor<SubchannelPicker> pickerCaptor;
+  @Captor
+  private ArgumentCaptor<ConnectivityState> stateCaptor;
+
+  private FakeLoadBalancer fakeChildLb;
+
+  private final LoadBalancerProvider mockChildLbProvider = new StandardLoadBalancerProvider(
+      "foo_policy") {
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      return mockChildLb;
+    }
+  };
+  private final LoadBalancerProvider fakeLbProvider = new StandardLoadBalancerProvider(
+      "fake_policy") {
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      if (fakeChildLb == null) {
+        fakeChildLb = new FakeLoadBalancer(helper);
+      }
+      return fakeChildLb;
+    }
+  };
+  private final LoadBalancerProvider roundRobinLbProvider = new StandardLoadBalancerProvider(
+      "round_robin") {
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      return new RoundRobinLoadBalancer(helper);
+    }
+  };
+
+  private final FakeClock fakeClock = new FakeClock();
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private OutlierDetectionLoadBalancer loadBalancer;
+
+  private final List<EquivalentAddressGroup> servers = Lists.newArrayList();
+  private final Map<List<EquivalentAddressGroup>, Subchannel> subchannels = Maps.newLinkedHashMap();
+  private final Map<Subchannel, SubchannelStateListener> subchannelStateListeners
+      = Maps.newLinkedHashMap();
+
+  private final Map<EquivalentAddressGroup, SubchannelStateListener> healthListeners =
+      Maps.newLinkedHashMap();
+
+  private Subchannel subchannel1;
+  private Subchannel subchannel2;
+  private Subchannel subchannel3;
+  private Subchannel subchannel4;
+  private Subchannel subchannel5;
+
+  @Before
+  public void setUp() {
+    for (int i = 0; i < 5; i++) {
+      SocketAddress addr = new FakeSocketAddress("server" + i);
+      EquivalentAddressGroup eag = new EquivalentAddressGroup(addr);
+      servers.add(eag);
+      Subchannel sc = mock(Subchannel.class);
+      subchannels.put(Arrays.asList(eag), sc);
+      when(sc.getInternalSubchannel()).thenReturn(sc);
+      if (hasHealthConsumer) {
+        healthListeners.put(eag, mock(SubchannelStateListener.class));
+      }
+    }
+
+    Iterator<Subchannel> subchannelIterator = subchannels.values().iterator();
+    subchannel1 = subchannelIterator.next();
+    subchannel2 = subchannelIterator.next();
+    subchannel3 = subchannelIterator.next();
+    subchannel4 = subchannelIterator.next();
+    subchannel5 = subchannelIterator.next();
+
+    ChannelLogger channelLogger = mock(ChannelLogger.class);
+
+    when(mockHelper.getChannelLogger()).thenReturn(channelLogger);
+    when(mockHelper.getSynchronizationContext()).thenReturn(syncContext);
+    when(mockHelper.getScheduledExecutorService()).thenReturn(
+        fakeClock.getScheduledExecutorService());
+    when(mockHelper.createSubchannel(any(CreateSubchannelArgs.class))).then(
+        new Answer<Subchannel>() {
+          @Override
+          public Subchannel answer(InvocationOnMock invocation) throws Throwable {
+            CreateSubchannelArgs args = (CreateSubchannelArgs) invocation.getArguments()[0];
+            final Subchannel subchannel = subchannels.get(args.getAddresses());
+            when(subchannel.getChannelLogger()).thenReturn(channelLogger);
+            when(subchannel.getAllAddresses()).thenReturn(args.getAddresses());
+            when(subchannel.getAttributes()).thenReturn(args.getAttributes());
+            doAnswer(new Answer<Void>() {
+              @Override
+              public Void answer(InvocationOnMock invocation) throws Throwable {
+                subchannelStateListeners.put(subchannel,
+                    (SubchannelStateListener) invocation.getArguments()[0]);
+                return null;
+              }
+            }).when(subchannel).start(any(SubchannelStateListener.class));
+            return subchannel;
+          }
+        });
+
+    when(mockStreamTracerFactory.newClientStreamTracer(any(),
+        any())).thenReturn(mockStreamTracer);
+
+    loadBalancer = new OutlierDetectionLoadBalancer(mockHelper, fakeClock.getTicker());
+  }
+
+  @Test
+  public void handleNameResolutionError_noChildLb() {
+    loadBalancer.handleNameResolutionError(Status.DEADLINE_EXCEEDED);
+
+    verify(mockHelper).updateBalancingState(connectivityStateCaptor.capture(),
+        errorPickerCaptor.capture());
+    assertThat(connectivityStateCaptor.getValue()).isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+  }
+
+  @Test
+  public void handleNameResolutionError_withChildLb() {
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(
+        new OutlierDetectionLoadBalancerConfig.Builder()
+            .setSuccessRateEjection(new SuccessRateEjection.Builder().build())
+            .setChildConfig(newChildConfig(mockChildLbProvider, null)).build(),
+        new EquivalentAddressGroup(mockSocketAddress)));
+    loadBalancer.handleNameResolutionError(Status.DEADLINE_EXCEEDED);
+
+    verify(mockChildLb).handleNameResolutionError(Status.DEADLINE_EXCEEDED);
+  }
+
+  /**
+   * {@code shutdown()} is simply delegated.
+   */
+  @Test
+  public void shutdown() {
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(
+        new OutlierDetectionLoadBalancerConfig.Builder()
+            .setSuccessRateEjection(new SuccessRateEjection.Builder().build())
+            .setChildConfig(newChildConfig(mockChildLbProvider, null)).build(),
+        new EquivalentAddressGroup(mockSocketAddress)));
+    loadBalancer.shutdown();
+    verify(mockChildLb).shutdown();
+  }
+
+  /**
+   * Base case for accepting new resolved addresses.
+   */
+  @Test
+  public void acceptResolvedAddresses() {
+    Object childConfig = "theConfig";
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setSuccessRateEjection(new SuccessRateEjection.Builder().build())
+        .setChildConfig(newChildConfig(mockChildLbProvider, childConfig)).build();
+    ResolvedAddresses resolvedAddresses = buildResolvedAddress(config,
+        new EquivalentAddressGroup(mockSocketAddress));
+
+    loadBalancer.acceptResolvedAddresses(resolvedAddresses);
+
+    // Handling of resolved addresses is delegated
+    verify(mockChildLb).acceptResolvedAddresses(
+        resolvedAddresses.toBuilder().setLoadBalancingPolicyConfig(childConfig).build());
+
+    // There is a single pending task to run the outlier detection algorithm
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
+
+    // The task is scheduled to run after a delay set in the config.
+    ScheduledTask task = fakeClock.getPendingTasks().iterator().next();
+    assertThat(task.getDelay(TimeUnit.NANOSECONDS)).isEqualTo(config.intervalNanos);
+  }
+
+  /**
+   * The child LB might recreate subchannels leaving the ones we are tracking
+   * orphaned in the address tracker. Make sure subchannels that are shut down get
+   * removed from the tracker.
+   */
+  @Test
+  public void childLbRecreatesSubchannels() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setSuccessRateEjection(new SuccessRateEjection.Builder().build())
+        .setChildConfig(newChildConfig(fakeLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers.get(0)));
+
+    assertThat(loadBalancer.endpointTrackerMap).hasSize(1);
+    EndpointTracker addressTracker =
+        (EndpointTracker) loadBalancer.endpointTrackerMap.values().toArray()[0];
+    assertThat(addressTracker).isNotNull();
+    OutlierDetectionSubchannel trackedSubchannel
+        = (OutlierDetectionSubchannel) addressTracker.getSubchannels().toArray()[0];
+
+    fakeChildLb.recreateSubchannels();
+    assertThat(addressTracker.getSubchannels()).doesNotContain(trackedSubchannel);
+  }
+
+  /**
+   * Outlier detection first enabled, then removed.
+   */
+  @Test
+  public void acceptResolvedAddresses_outlierDetectionDisabled() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setSuccessRateEjection(new SuccessRateEjection.Builder().build())
+        .setChildConfig(newChildConfig(mockChildLbProvider, null)).build();
+    ResolvedAddresses resolvedAddresses = buildResolvedAddress(config,
+        new EquivalentAddressGroup(mockSocketAddress));
+
+    loadBalancer.acceptResolvedAddresses(resolvedAddresses);
+
+    fakeClock.forwardTime(15, TimeUnit.SECONDS);
+
+    // There is a single pending task to run the outlier detection algorithm
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
+
+    config = new OutlierDetectionLoadBalancerConfig.Builder().setChildConfig(
+        newChildConfig(mockChildLbProvider, null)).build();
+    loadBalancer.acceptResolvedAddresses(
+        buildResolvedAddress(config, new EquivalentAddressGroup(mockSocketAddress)));
+
+    // Pending task should be gone since OD is disabled.
+    assertThat(fakeClock.getPendingTasks()).isEmpty();
+
+  }
+
+  /**
+   * Tests different scenarios when the timer interval in the config changes.
+   */
+  @Test
+  public void acceptResolvedAddresses_intervalUpdate() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setSuccessRateEjection(new SuccessRateEjection.Builder().build())
+        .setChildConfig(newChildConfig(mockChildLbProvider, null)).build();
+    ResolvedAddresses resolvedAddresses = buildResolvedAddress(config,
+        new EquivalentAddressGroup(mockSocketAddress));
+
+    loadBalancer.acceptResolvedAddresses(resolvedAddresses);
+
+    // Config update has doubled the interval
+    config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setIntervalNanos(config.intervalNanos * 2)
+        .setSuccessRateEjection(new SuccessRateEjection.Builder().build())
+        .setChildConfig(newChildConfig(mockChildLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(
+        buildResolvedAddress(config, new EquivalentAddressGroup(mockSocketAddress)));
+
+    // If the timer has not run yet the task is just rescheduled to run after the new delay.
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
+    ScheduledTask task = fakeClock.getPendingTasks().iterator().next();
+    assertThat(task.getDelay(TimeUnit.NANOSECONDS)).isEqualTo(config.intervalNanos);
+    assertThat(task.dueTimeNanos).isEqualTo(config.intervalNanos);
+
+    // The new interval time has passed. The next task due time should have been pushed back another
+    // interval.
+    forwardTime(config);
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
+    task = fakeClock.getPendingTasks().iterator().next();
+    assertThat(task.dueTimeNanos).isEqualTo(config.intervalNanos + config.intervalNanos + 1);
+
+    // Some time passes and a second update comes down, but now the timer has had a chance to run,
+    // the new delay to timer start should consider when the timer last ran and if the interval is
+    // not changing in the config, the next task due time should remain unchanged.
+    fakeClock.forwardTime(4, TimeUnit.SECONDS);
+    task = fakeClock.getPendingTasks().iterator().next();
+    loadBalancer.acceptResolvedAddresses(
+        buildResolvedAddress(config, new EquivalentAddressGroup(mockSocketAddress)));
+    assertThat(task.dueTimeNanos).isEqualTo(config.intervalNanos + config.intervalNanos + 1);
+  }
+
+  /**
+   * Confirm basic picking works by delegating to round_robin.
+   */
+  @Test
+  public void delegatePick() throws Exception {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setSuccessRateEjection(new SuccessRateEjection.Builder().build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers.get(0)));
+
+    // Make one of the subchannels READY.
+    final Subchannel readySubchannel = subchannels.values().iterator().next();
+    deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
+
+    verify(mockHelper, times(3)).updateBalancingState(stateCaptor.capture(),
+        pickerCaptor.capture());
+
+    // Make sure that we can pick the single READY subchannel.
+    SubchannelPicker picker = pickerCaptor.getAllValues().get(2);
+    PickResult pickResult = picker.pickSubchannel(mock(PickSubchannelArgs.class));
+    Subchannel s = ((OutlierDetectionSubchannel) pickResult.getSubchannel()).delegate();
+    if (s instanceof HealthProducerHelper.HealthProducerSubchannel) {
+      s = ((HealthProducerHelper.HealthProducerSubchannel) s).delegate();
+    }
+    assertThat(s).isEqualTo(readySubchannel);
+  }
+
+  /**
+   * Any ClientStreamTracer.Factory set by the delegate picker should still get used.
+   */
+  @Test
+  public void delegatePickTracerFactoryPreserved() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setSuccessRateEjection(new SuccessRateEjection.Builder().build())
+        .setChildConfig(newChildConfig(fakeLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers.get(0)));
+
+    // Make one of the subchannels READY.
+    final Subchannel readySubchannel = subchannels.values().iterator().next();
+    deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
+
+    verify(mockHelper, times(2)).updateBalancingState(stateCaptor.capture(),
+        pickerCaptor.capture());
+    if (hasHealthConsumer) {
+      SubchannelStateListener healthListener = healthListeners.get(servers.get(0));
+      verify(healthListener).onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    }
+
+    // Make sure that we can pick the single READY subchannel.
+    SubchannelPicker picker = pickerCaptor.getAllValues().get(1);
+    PickResult pickResult = picker.pickSubchannel(mock(PickSubchannelArgs.class));
+
+    // Calls to a stream tracer created with the factory in the result should make it to a stream
+    // tracer the underlying LB/picker is using.
+    ClientStreamTracer clientStreamTracer = pickResult.getStreamTracerFactory()
+        .newClientStreamTracer(ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());
+    clientStreamTracer.inboundHeaders();
+    // The underlying fake LB provider is configured with a factory that returns a mock stream
+    // tracer.
+    verify(mockStreamTracer).inboundHeaders();
+  }
+
+  /**
+   * Assure the tracer works even when the underlying LB does not have a tracer to delegate to.
+   */
+  @Test
+  public void delegatePickTracerFactoryNotSet() throws Exception {
+    // We set the mock factory to null to indicate that the delegate does not have its own tracer.
+    mockStreamTracerFactory = null;
+
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setSuccessRateEjection(new SuccessRateEjection.Builder().build())
+        .setChildConfig(newChildConfig(fakeLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers.get(0)));
+
+    // Make one of the subchannels READY.
+    final Subchannel readySubchannel = subchannels.values().iterator().next();
+    deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
+
+    verify(mockHelper, times(2)).updateBalancingState(stateCaptor.capture(),
+        pickerCaptor.capture());
+
+    // Make sure that we can pick the single READY subchannel.
+    SubchannelPicker picker = pickerCaptor.getAllValues().get(1);
+    PickResult pickResult = picker.pickSubchannel(mock(PickSubchannelArgs.class));
+
+    // With no delegate tracers factory a call to the OD tracer should still work
+    ClientStreamTracer clientStreamTracer = pickResult.getStreamTracerFactory()
+        .newClientStreamTracer(ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());
+    clientStreamTracer.inboundHeaders();
+
+    // Sanity check to make sure the delegate tracer does not get called.
+    verifyNoInteractions(mockStreamTracer);
+  }
+
+  /**
+   * The success rate algorithm leaves a healthy set of addresses alone.
+   */
+  @Test
+  public void successRateNoOutliers() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder().setMinimumHosts(3).setRequestVolume(10).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // No outliers, no ejections.
+    assertEjectedSubchannels(ImmutableSet.of());
+  }
+
+  /**
+   * The success rate algorithm ejects the outlier.
+   */
+  @Test
+  public void successRateOneOutlier() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // The one subchannel that was returning errors should be ejected.
+    assertEjectedSubchannels(ImmutableSet.of(ImmutableSet.copyOf(servers.get(0).getAddresses())));
+  }
+
+  /**
+   * The success rate algorithm ejects the outlier, but then the config changes so that similar
+   * behavior no longer gets ejected.
+   */
+  @Test
+  public void successRateOneOutlier_configChange() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // The one subchannel that was returning errors should be ejected.
+    assertEjectedSubchannels(ImmutableSet.of(ImmutableSet.copyOf(servers.get(0).getAddresses())));
+
+    // New config sets enforcement percentage to 0.
+    config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10)
+                .setEnforcementPercentage(0).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel2, Status.DEADLINE_EXCEEDED), 8);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // Since we brought enforcement percentage to 0, no additional ejection should have happened.
+    assertEjectedSubchannels(ImmutableSet.of(ImmutableSet.copyOf(servers.get(0).getAddresses())));
+  }
+
+  /**
+   * The success rate algorithm ejects the outlier but after some time it should get unejected
+   * if it stops being an outlier..
+   */
+  @Test
+  public void successRateOneOutlier_unejected() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    fakeClock.forwardTime(config.intervalNanos + 1, TimeUnit.NANOSECONDS);
+
+    // The one subchannel that was returning errors should be ejected.
+    assertEjectedSubchannels(ImmutableSet.of(ImmutableSet.copyOf(servers.get(0).getAddresses())));
+
+    // Now we produce more load, but the subchannel has started working and is no longer an outlier.
+    generateLoad(ImmutableMap.of(), 8);
+
+    // Move forward in time to a point where the detection timer has fired.
+    fakeClock.forwardTime(config.maxEjectionTimeNanos + 1, TimeUnit.NANOSECONDS);
+
+    // No subchannels should remain ejected.
+    assertEjectedSubchannels(ImmutableSet.of());
+  }
+
+  /**
+   * The success rate algorithm ignores addresses without enough volume.
+   */
+  @Test
+  public void successRateOneOutlier_notEnoughVolume() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(20).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    // We produce an outlier, but don't give it enough calls to reach the minimum volume.
+    generateLoad(
+        ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED),
+        ImmutableMap.of(subchannel1, 19), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // The address should not have been ejected.
+    assertEjectedSubchannels(ImmutableSet.of());
+  }
+
+  /**
+   * The success rate algorithm does not apply if we don't have enough addresses that have the
+   * required volume.
+   */
+  @Test
+  public void successRateOneOutlier_notEnoughAddressesWithVolume() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(5)
+                .setRequestVolume(20).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(
+        ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED),
+        // subchannel2 has only 19 calls which results in success rate not triggering.
+        ImmutableMap.of(subchannel2, 19),
+        7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // No subchannels should have been ejected.
+    assertEjectedSubchannels(ImmutableSet.of());
+  }
+
+  /**
+   * The enforcementPercentage configuration should be honored.
+   */
+  @Test
+  public void successRateOneOutlier_enforcementPercentage() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10)
+                .setEnforcementPercentage(0)
+                .build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // There is one outlier, but because enforcementPercentage is 0, nothing should be ejected.
+    assertEjectedSubchannels(ImmutableSet.of());
+  }
+
+  /**
+   * Two outliers get ejected.
+   */
+  @Test
+  public void successRateTwoOutliers() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10)
+                .setStdevFactor(1).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(
+        subchannel1, Status.DEADLINE_EXCEEDED,
+        subchannel2, Status.DEADLINE_EXCEEDED), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // The one subchannel that was returning errors should be ejected.
+    assertEjectedSubchannels(ImmutableSet.of(ImmutableSet.of(servers.get(0).getAddresses().get(0)),
+        ImmutableSet.of(servers.get(1).getAddresses().get(0))));
+  }
+
+  /**
+   * Three outliers, second one ejected even if ejecting it goes above the max ejection percentage,
+   * as this matches Envoy behavior. The third one should not get ejected.
+   */
+  @Test
+  public void successRateThreeOutliers_maxEjectionPercentage() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(30)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10)
+                .setStdevFactor(1).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(
+        subchannel1, Status.DEADLINE_EXCEEDED,
+        subchannel2, Status.DEADLINE_EXCEEDED,
+        subchannel3, Status.DEADLINE_EXCEEDED), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    int totalEjected = 0;
+    for (EquivalentAddressGroup addressGroup: servers) {
+      totalEjected +=
+          loadBalancer.endpointTrackerMap.get(
+              ImmutableSet.of(addressGroup.getAddresses().get(0))).subchannelsEjected() ? 1 : 0;
+    }
+
+    assertThat(totalEjected).isEqualTo(2);
+  }
+
+
+  /**
+   * The success rate algorithm leaves a healthy set of addresses alone.
+   */
+  @Test
+  public void failurePercentageNoOutliers() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    // By default all calls will return OK.
+    generateLoad(ImmutableMap.of(), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // No outliers, no ejections.
+    assertEjectedSubchannels(ImmutableSet.of());
+  }
+
+  /**
+   * The success rate algorithm ejects the outlier.
+   */
+  @Test
+  public void failurePercentageOneOutlier() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // The one subchannel that was returning errors should be ejected.
+    assertEjectedSubchannels(ImmutableSet.of(ImmutableSet.copyOf(servers.get(0).getAddresses())));
+  }
+
+  /**
+   * The failure percentage algorithm ignores addresses without enough volume..
+   */
+  @Test
+  public void failurePercentageOneOutlier_notEnoughVolume() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(100).build()) // We won't produce this much volume...
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // We should see no ejections.
+    assertEjectedSubchannels(ImmutableSet.of());
+  }
+
+  /**
+   * The failure percentage algorithm does not apply if we don't have enough addresses that have the
+   * required volume.
+   */
+  @Test
+  public void failurePercentageOneOutlier_notEnoughAddressesWithVolume() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(5)
+                .setRequestVolume(20).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(
+        ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED),
+        // subchannel2 has only 19 calls which results in failure percentage not triggering.
+        ImmutableMap.of(subchannel2, 19),
+        7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // No subchannels should have been ejected.
+    assertEjectedSubchannels(ImmutableSet.of());
+  }
+
+  /**
+   * The enforcementPercentage configuration should be honored.
+   */
+  @Test
+  public void failurePercentageOneOutlier_enforcementPercentage() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10)
+                .setEnforcementPercentage(0)
+                .build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // There is one outlier, but because enforcementPercentage is 0, nothing should be ejected.
+    assertEjectedSubchannels(ImmutableSet.of());
+  }
+
+  /** Success rate detects two outliers and error percentage three. */
+  @Test
+  public void successRateAndFailurePercentageThreeOutliers() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(100)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10)
+                .setStdevFactor(1).build())
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setThreshold(0)
+                .setMinimumHosts(3)
+                .setRequestVolume(1)
+                .build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    // Three subchannels with problems, but one only has a single call that failed.
+    // This is not enough for success rate to catch, but failure percentage is
+    // configured with a 0 tolerance threshold.
+    generateLoad(
+        ImmutableMap.of(
+            subchannel1, Status.DEADLINE_EXCEEDED,
+            subchannel2, Status.DEADLINE_EXCEEDED,
+            subchannel3, Status.DEADLINE_EXCEEDED),
+        ImmutableMap.of(subchannel3, 1), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // Should see thee ejected, success rate cathes the first two, error percentage the
+    // same two plus the subchannel with the single failure.
+    assertEjectedSubchannels(ImmutableSet.of(
+        ImmutableSet.of(servers.get(0).getAddresses().get(0)),
+        ImmutableSet.of(servers.get(1).getAddresses().get(0)),
+        ImmutableSet.of(servers.get(2).getAddresses().get(0))));
+  }
+
+  /**
+   * When the address a subchannel is associated with changes it should get tracked under the new
+   * address and its ejection state should match what the address has.
+   */
+  @Test
+  public void subchannelUpdateAddress_singleReplaced() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    EquivalentAddressGroup oldAddressGroup = servers.get(0);
+    EndpointTracker oldAddressTracker = loadBalancer.endpointTrackerMap.get(
+        ImmutableSet.of(oldAddressGroup.getAddresses().get(0)));
+    EquivalentAddressGroup newAddressGroup = servers.get(1);
+    EndpointTracker newAddressTracker = loadBalancer.endpointTrackerMap.get(
+        ImmutableSet.of(newAddressGroup.getAddresses().get(0)));
+
+    // The one subchannel that was returning errors should be ejected.
+    assertEjectedSubchannels(ImmutableSet.of(
+        ImmutableSet.of(oldAddressGroup.getAddresses().get(0))));
+
+    // The ejected subchannel gets updated with another address in the map that is not ejected
+    OutlierDetectionSubchannel subchannel = oldAddressTracker.getSubchannels()
+        .iterator().next();
+    subchannel.updateAddresses(ImmutableList.of(newAddressGroup));
+
+    // The replaced address should no longer have the subchannel associated with it.
+    assertThat(oldAddressTracker.getSubchannels()).doesNotContain(subchannel);
+
+    // The new address should instead have the subchannel.
+    assertThat(newAddressTracker.getSubchannels()).contains(subchannel);
+
+    // Since the new address is not ejected, the ejected subchannel moving over to it should also
+    // become unejected.
+    assertThat(subchannel.isEjected()).isFalse();
+  }
+
+  @Test
+  public void multipleAddressesEndpoint() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build())
+        .setChildConfig(newChildConfig(fakeLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+    EquivalentAddressGroup manyAddEndpoint = new EquivalentAddressGroup(Arrays.asList(
+        servers.get(0).getAddresses().get(0), servers.get(1).getAddresses().get(0)));
+    List<EquivalentAddressGroup> manyAddEndpointServer = ImmutableList.of(manyAddEndpoint);
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, manyAddEndpointServer));
+    assertThat(loadBalancer.endpointTrackerMap.size()).isEqualTo(1);
+    assertThat(loadBalancer.addressMap.size()).isEqualTo(2);
+
+    manyAddEndpoint = new EquivalentAddressGroup(Arrays.asList(
+        servers.get(0).getAddresses().get(0), servers.get(1).getAddresses().get(0)));
+    EquivalentAddressGroup manyAddEndpoint2 = new EquivalentAddressGroup(Arrays.asList(
+        servers.get(2).getAddresses().get(0), servers.get(3).getAddresses().get(0)));
+    EquivalentAddressGroup singleAddressEndpoint = new EquivalentAddressGroup(Arrays.asList(
+        servers.get(4).getAddresses().get(0)));
+    manyAddEndpointServer = ImmutableList.of(
+        manyAddEndpoint, manyAddEndpoint2, singleAddressEndpoint);
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, manyAddEndpointServer));
+    assertThat(loadBalancer.endpointTrackerMap.size()).isEqualTo(3);
+    assertThat(loadBalancer.addressMap.size()).isEqualTo(5);
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED,
+        subchannel2, Status.DEADLINE_EXCEEDED), 13);
+    forwardTime(config);
+
+    // eject the first endpoint: (address0, address1)
+    assertEjectedSubchannels(ImmutableSet.of(ImmutableSet.of(
+        servers.get(0).getAddresses().get(0), servers.get(1).getAddresses().get(0))));
+  }
+
+  /**
+   * If a single address gets replaced by multiple, the subchannel becomes uneligible for outlier
+   * detection.
+   */
+  @Test
+  public void subchannelUpdateAddress_singleReplacedWithMultiple() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    EquivalentAddressGroup oldAddressGroup = servers.get(0);
+    EndpointTracker oldAddressTracker = loadBalancer.endpointTrackerMap.get(
+        ImmutableSet.of(oldAddressGroup.getAddresses().get(0)));
+    EquivalentAddressGroup newAddress1 = servers.get(1);
+    EquivalentAddressGroup newAddress2 = servers.get(2);
+
+    OutlierDetectionSubchannel subchannel = oldAddressTracker.getSubchannels()
+        .iterator().next();
+
+    // The subchannel gets updated with two new addresses
+    ImmutableList<EquivalentAddressGroup> addressUpdate
+        = ImmutableList.of(newAddress1, newAddress2);
+    subchannel.updateAddresses(addressUpdate);
+    when(subchannel1.getAllAddresses()).thenReturn(addressUpdate);
+
+    // The replaced address should no longer be tracked.
+    assertThat(oldAddressTracker.getSubchannels()).doesNotContain(subchannel);
+
+    // The old tracker should also have its call counters cleared.
+    assertThat(oldAddressTracker.activeVolume()).isEqualTo(0);
+    assertThat(oldAddressTracker.inactiveVolume()).isEqualTo(0);
+  }
+
+  /**
+   * A subchannel with multiple addresses will again become eligible for outlier detection if it
+   * receives an update with a single address.
+   */
+  @Test
+  public void subchannelUpdateAddress_multipleReplacedWithSingle() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build())
+        .setChildConfig(newChildConfig(fakeLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED), 6);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    EquivalentAddressGroup oldAddressGroup = servers.get(0);
+    EndpointTracker oldAddressTracker = loadBalancer.endpointTrackerMap.get(
+        ImmutableSet.of(oldAddressGroup.getAddresses().get(0)));
+    EquivalentAddressGroup newAddressGroup1 = servers.get(1);
+    EndpointTracker newAddressTracker1 = loadBalancer.endpointTrackerMap.get(
+        ImmutableSet.of(newAddressGroup1.getAddresses().get(0)));
+    EquivalentAddressGroup newAddressGroup2 = servers.get(2);
+
+    // The old subchannel was returning errors and should be ejected.
+    assertEjectedSubchannels(ImmutableSet.of(
+        ImmutableSet.of(oldAddressGroup.getAddresses().get(0))));
+
+    OutlierDetectionSubchannel subchannel = oldAddressTracker.getSubchannels()
+        .iterator().next();
+
+    // The subchannel gets updated with two new addresses
+    ImmutableList<EquivalentAddressGroup> addressUpdate
+        = ImmutableList.of(newAddressGroup1, newAddressGroup2);
+    subchannel.updateAddresses(addressUpdate);
+    when(subchannel1.getAllAddresses()).thenReturn(addressUpdate);
+
+    // The replaced address should no longer be tracked.
+    assertThat(oldAddressTracker.getSubchannels()).doesNotContain(subchannel);
+
+    // The old tracker should also have its call counters cleared.
+    assertThat(oldAddressTracker.activeVolume()).isEqualTo(0);
+    assertThat(oldAddressTracker.inactiveVolume()).isEqualTo(0);
+
+    // Another update takes the subchannel back to a single address.
+    addressUpdate = ImmutableList.of(newAddressGroup1);
+    subchannel.updateAddresses(addressUpdate);
+    when(subchannel1.getAllAddresses()).thenReturn(addressUpdate);
+
+    // The subchannel is now associated with the single new address.
+    assertThat(newAddressTracker1.getSubchannels()).contains(subchannel);
+
+    // The previously ejected subchannel should become unejected as it is now associated with an
+    // unejected address.
+    assertThat(subchannel.isEjected()).isFalse();
+  }
+
+  /** Both algorithms configured, but no outliers. */
+  @Test
+  public void successRateAndFailurePercentage_noOutliers() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build())
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build())
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // No outliers, no ejections.
+    assertEjectedSubchannels(ImmutableSet.of());
+  }
+
+  /** Both algorithms configured, success rate detects an outlier. */
+  @Test
+  public void successRateAndFailurePercentage_successRateOutlier() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build())
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10)
+                .setEnforcementPercentage(0).build()) // Configured, but not enforcing.
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // The one subchannel that was returning errors should be ejected.
+    assertEjectedSubchannels(ImmutableSet.of(ImmutableSet.copyOf(servers.get(0).getAddresses())));
+    for (SubchannelStateListener healthListener : healthListeners.values()) {
+      verifyNoInteractions(healthListener);
+    }
+  }
+
+  @Test
+  public void successRateAndFailurePercentage_successRateOutlier_() { // with health listener
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build())
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10)
+                .setEnforcementPercentage(0).build()) // Configured, but not enforcing.
+        .setChildConfig(newChildConfig(fakeLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED), 6);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // The one subchannel that was returning errors should be ejected.
+    assertEjectedSubchannels(ImmutableSet.of(ImmutableSet.copyOf(servers.get(0).getAddresses())));
+    if (hasHealthConsumer) {
+      ArgumentCaptor<ConnectivityStateInfo> csiCaptor = ArgumentCaptor.forClass(
+          ConnectivityStateInfo.class);
+      verify(healthListeners.get(servers.get(0)), times(2)).onSubchannelState(csiCaptor.capture());
+      List<ConnectivityStateInfo> connectivityStateInfos = csiCaptor.getAllValues();
+
+      // The subchannel went through two state transitions...
+      assertThat(connectivityStateInfos).hasSize(2);
+      // ...it first went to the READY state...
+      assertThat(connectivityStateInfos.get(0).getState()).isEqualTo(READY);
+
+      // ...and then to TRANSIENT_FAILURE as outlier detection ejected it.
+      assertThat(connectivityStateInfos.get(1).getState()).isEqualTo(TRANSIENT_FAILURE);
+      assertThat(connectivityStateInfos.get(1).getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+      assertThat(connectivityStateInfos.get(1).getStatus().getDescription()).isEqualTo(
+          "The subchannel has been ejected by outlier detection");
+    }
+  }
+
+  /** Both algorithms configured, error percentage detects an outlier. */
+  @Test
+  public void successRateAndFailurePercentage_errorPercentageOutlier() {
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10)
+                .setEnforcementPercentage(0).build())
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build()) // Configured, but not enforcing.
+        .setChildConfig(newChildConfig(roundRobinLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED), 7);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // The one subchannel that was returning errors should be ejected.
+    assertEjectedSubchannels(ImmutableSet.of(ImmutableSet.copyOf(servers.get(0).getAddresses())));
+    for (SubchannelStateListener healthListener : healthListeners.values()) {
+      verifyNoInteractions(healthListener);
+    }
+  }
+
+  @Test
+  public void successRateAndFailurePercentage_errorPercentageOutlier_() { // with health listener
+    OutlierDetectionLoadBalancerConfig config = new OutlierDetectionLoadBalancerConfig.Builder()
+        .setMaxEjectionPercent(50)
+        .setSuccessRateEjection(
+            new SuccessRateEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10)
+                .setEnforcementPercentage(0).build())
+        .setFailurePercentageEjection(
+            new FailurePercentageEjection.Builder()
+                .setMinimumHosts(3)
+                .setRequestVolume(10).build()) // Configured, but not enforcing.
+        .setChildConfig(newChildConfig(fakeLbProvider, null)).build();
+
+    loadBalancer.acceptResolvedAddresses(buildResolvedAddress(config, servers));
+
+    generateLoad(ImmutableMap.of(subchannel1, Status.DEADLINE_EXCEEDED), 6);
+
+    // Move forward in time to a point where the detection timer has fired.
+    forwardTime(config);
+
+    // The one subchannel that was returning errors should be ejected.
+    assertEjectedSubchannels(ImmutableSet.of(ImmutableSet.copyOf(servers.get(0).getAddresses())));
+    if (hasHealthConsumer) {
+      ArgumentCaptor<ConnectivityStateInfo> csiCaptor = ArgumentCaptor.forClass(
+          ConnectivityStateInfo.class);
+      verify(healthListeners.get(servers.get(0)), times(2)).onSubchannelState(csiCaptor.capture());
+      List<ConnectivityStateInfo> connectivityStateInfos = csiCaptor.getAllValues();
+
+      // The subchannel went through two state transitions...
+      assertThat(connectivityStateInfos).hasSize(2);
+      // ...it first went to the READY state...
+      assertThat(connectivityStateInfos.get(0).getState()).isEqualTo(READY);
+
+      // ...and then to TRANSIENT_FAILURE as outlier detection ejected it.
+      assertThat(connectivityStateInfos.get(1).getState()).isEqualTo(TRANSIENT_FAILURE);
+      assertThat(connectivityStateInfos.get(1).getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+      assertThat(connectivityStateInfos.get(1).getStatus().getDescription()).isEqualTo(
+          "The subchannel has been ejected by outlier detection");
+    }
+  }
+
+  @Test
+  public void mathChecksOut() {
+    ImmutableList<Double> values = ImmutableList.of(600d, 470d, 170d, 430d, 300d);
+    double mean = SuccessRateOutlierEjectionAlgorithm.mean(values);
+    double stdev = SuccessRateOutlierEjectionAlgorithm.standardDeviation(values, mean);
+
+    assertThat(mean).isEqualTo(394);
+    assertThat(stdev).isEqualTo(147.32277488562318);
+  }
+
+  private static class FakeSocketAddress extends SocketAddress {
+
+    final String name;
+
+    FakeSocketAddress(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public String toString() {
+      return "FakeSocketAddress-" + name;
+    }
+  }
+
+  private ResolvedAddresses buildResolvedAddress(OutlierDetectionLoadBalancerConfig config,
+      EquivalentAddressGroup... servers) {
+    return ResolvedAddresses.newBuilder().setAddresses(ImmutableList.copyOf(servers))
+        .setLoadBalancingPolicyConfig(config).build();
+  }
+
+  private ResolvedAddresses buildResolvedAddress(OutlierDetectionLoadBalancerConfig config,
+      List<EquivalentAddressGroup> servers) {
+    return ResolvedAddresses.newBuilder().setAddresses(ImmutableList.copyOf(servers))
+        .setLoadBalancingPolicyConfig(config).build();
+  }
+
+  private void deliverSubchannelState(Subchannel subchannel, ConnectivityStateInfo newState) {
+    subchannelStateListeners.get(subchannel).onSubchannelState(newState);
+  }
+
+  private void generateLoad(Map<Subchannel, Status> statusMap, int expectedStateChanges) {
+    generateLoad(statusMap, null, expectedStateChanges);
+  }
+
+  // Generates 100 calls, 20 each across the subchannels. Default status is OK.
+  private void generateLoad(Map<Subchannel, Status> statusMap,
+      Map<Subchannel, Integer> maxCallsMap, int expectedStateChanges) {
+    deliverSubchannelState(subchannel1, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(subchannel2, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(subchannel3, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(subchannel4, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(subchannel5, ConnectivityStateInfo.forNonError(READY));
+
+    verify(mockHelper, times(expectedStateChanges)).updateBalancingState(stateCaptor.capture(),
+        pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getAllValues()
+        .get(pickerCaptor.getAllValues().size() - 1);
+
+    HashMap<Subchannel, Integer> callCountMap = new HashMap<>();
+    for (int i = 0; i < 100; i++) {
+      PickResult pickResult = picker
+          .pickSubchannel(mock(PickSubchannelArgs.class));
+      ClientStreamTracer clientStreamTracer = pickResult.getStreamTracerFactory()
+          .newClientStreamTracer(null, null);
+
+      Subchannel subchannel = (Subchannel) pickResult.getSubchannel().getInternalSubchannel();
+
+      int maxCalls =
+          maxCallsMap != null && maxCallsMap.containsKey(subchannel)
+              ? maxCallsMap.get(subchannel) : Integer.MAX_VALUE;
+      int calls = callCountMap.containsKey(subchannel) ? callCountMap.get(subchannel) : 0;
+      if (calls < maxCalls) {
+        callCountMap.put(subchannel, ++calls);
+        clientStreamTracer.streamClosed(
+            statusMap.containsKey(subchannel) ? statusMap.get(subchannel) : Status.OK);
+      }
+    }
+  }
+
+  // Forwards time past the moment when the timer will fire.
+  private void forwardTime(OutlierDetectionLoadBalancerConfig config) {
+    fakeClock.forwardTime(config.intervalNanos + 1, TimeUnit.NANOSECONDS);
+  }
+
+  // Asserts that the given addresses are ejected and the rest are not.
+  void assertEjectedSubchannels(Collection<Set<SocketAddress>> addresses) {
+    for (Entry<Set<SocketAddress>, EndpointTracker> entry :
+        loadBalancer.endpointTrackerMap.entrySet()) {
+      assertWithMessage("not ejected: " + entry.getKey())
+          .that(entry.getValue().subchannelsEjected())
+          .isEqualTo(addresses.contains(entry.getKey()));
+    }
+  }
+
+  private Object newChildConfig(LoadBalancerProvider provider, Object config) {
+    return GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(provider, config);
+  }
+
+  /** Round robin like fake load balancer. */
+  private final class FakeLoadBalancer extends LoadBalancer {
+    private final Helper helper;
+
+    List<Subchannel> subchannelList;
+    int lastPickIndex = -1;
+
+    FakeLoadBalancer(Helper helper) {
+      this.helper = helper;
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      subchannelList = new ArrayList<>();
+      for (EquivalentAddressGroup eag: resolvedAddresses.getAddresses()) {
+        for (SocketAddress address : eag.getAddresses()) {
+          EquivalentAddressGroup constructedEag = new EquivalentAddressGroup(address);
+          CreateSubchannelArgs.Builder args = CreateSubchannelArgs.newBuilder()
+              .setAddresses(constructedEag);
+          if (hasHealthConsumer) {
+            assertThat(healthListeners.get(constructedEag)).isNotNull();
+            args.addOption(HEALTH_CONSUMER_LISTENER_ARG_KEY,
+                healthListeners.get(constructedEag));
+          }
+          Subchannel subchannel = helper.createSubchannel(args.build());
+          subchannelList.add(subchannel);
+          subchannel.start(mock(SubchannelStateListener.class));
+          deliverSubchannelState(READY);
+        }
+      }
+      return Status.OK;
+    }
+
+    @Override
+    public void handleNameResolutionError(Status error) {
+    }
+
+    @Override
+    public void shutdown() {
+    }
+
+    // Simulates a situation where a load balancer might recreate some of the subchannels it is
+    // tracking even if acceptResolvedAddresses() has not been called.
+    void recreateSubchannels() {
+      List<Subchannel> newSubchannelList = new ArrayList<>(subchannelList.size());
+      for (Subchannel subchannel : subchannelList) {
+        Subchannel newSubchannel = helper
+            .createSubchannel(
+                CreateSubchannelArgs.newBuilder().setAddresses(subchannel.getAddresses()).build());
+        newSubchannel.start(mock(SubchannelStateListener.class));
+        subchannel.shutdown();
+        newSubchannelList.add(newSubchannel);
+      }
+      subchannelList = newSubchannelList;
+      deliverSubchannelState(READY);
+    }
+
+    void deliverSubchannelState(ConnectivityState state) {
+      SubchannelPicker picker = new SubchannelPicker() {
+        @Override
+        public PickResult pickSubchannel(PickSubchannelArgs args) {
+          if (lastPickIndex < 0 || lastPickIndex > subchannelList.size() - 1) {
+            lastPickIndex = 0;
+          }
+          return PickResult.withSubchannel(subchannelList.get(lastPickIndex++),
+              mockStreamTracerFactory);
+        }
+      };
+      helper.updateBalancingState(state, picker);
+    }
+  }
+}
diff --git a/util/src/test/java/io/grpc/util/RandomSubsettingLoadBalancerProviderTest.java b/util/src/test/java/io/grpc/util/RandomSubsettingLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..18a0766d4b2
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/RandomSubsettingLoadBalancerProviderTest.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright 2025 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.InternalServiceProviders;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.JsonParser;
+import io.grpc.util.RandomSubsettingLoadBalancer.RandomSubsettingLoadBalancerConfig;
+import java.io.IOException;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class RandomSubsettingLoadBalancerProviderTest {
+  private final RandomSubsettingLoadBalancerProvider provider =
+      new RandomSubsettingLoadBalancerProvider();
+
+  @Test
+  public void registered() {
+    for (LoadBalancerProvider current :
+        InternalServiceProviders.getCandidatesViaServiceLoader(
+            LoadBalancerProvider.class, getClass().getClassLoader())) {
+      if (current instanceof RandomSubsettingLoadBalancerProvider) {
+        return;
+      }
+    }
+    fail("RandomSubsettingLoadBalancerProvider not registered");
+  }
+
+  @Test
+  public void providesLoadBalancer() {
+    Helper helper = mock(Helper.class);
+    assertThat(provider.newLoadBalancer(helper))
+        .isInstanceOf(RandomSubsettingLoadBalancer.class);
+  }
+
+  @Test
+  public void parseConfigRequiresSubsetSize() throws IOException {
+    String emptyConfig = "{}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(emptyConfig));
+    assertThat(configOrError.getError()).isNotNull();
+    assertThat(configOrError.getError().toString())
+        .isEqualTo(
+            Status.UNAVAILABLE
+                .withDescription(
+                    "Subset size missing in random_subsetting_experimental, LB policy config={}")
+                .toString());
+  }
+
+  @Test
+  public void parseConfigReturnsErrorWhenChildPolicyMissing() throws IOException {
+    String missingChildPolicyConfig = "{\"subsetSize\": 3}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(missingChildPolicyConfig));
+    assertThat(configOrError.getError()).isNotNull();
+
+    Status error = configOrError.getError();
+    assertThat(error.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(error.getDescription()).isEqualTo(
+        "Failed to parse child in random_subsetting_experimental"
+        + ", LB policy config={subsetSize=3.0}");
+    assertThat(error.getCause().getMessage()).isEqualTo(
+        "UNAVAILABLE: No child LB config specified");
+  }
+
+  @Test
+  public void parseConfigReturnsErrorWhenChildPolicyInvalid() throws IOException {
+    String invalidChildPolicyConfig =
+        "{"
+            + "\"subsetSize\": 3, "
+            + "\"childPolicy\" : [{\"random_policy\" : {}}]"
+            + "}";
+
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(invalidChildPolicyConfig));
+    assertThat(configOrError.getError()).isNotNull();
+
+    Status error = configOrError.getError();
+    assertThat(error.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(error.getDescription()).isEqualTo(
+        "Failed to parse child in random_subsetting_experimental, LB policy config="
+        + "{subsetSize=3.0, childPolicy=[{random_policy={}}]}");
+    assertThat(error.getCause().getMessage()).contains(
+        "UNAVAILABLE: None of [random_policy] specified by Service Config are available.");
+  }
+
+  @Test
+  public void parseValidConfig() throws IOException {
+    String validConfig =
+        "{"
+            + "\"subsetSize\": 3, "
+            + "\"childPolicy\" : [{\"round_robin\" : {}}]"
+            + "}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(validConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+
+    RandomSubsettingLoadBalancerConfig actualConfig =
+        (RandomSubsettingLoadBalancerConfig) configOrError.getConfig();
+    assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(
+        actualConfig.childConfig).getPolicyName()).isEqualTo("round_robin");
+    assertThat(actualConfig.subsetSize).isEqualTo(3);
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, ?> parseJsonObject(String json) throws IOException {
+    return (Map<String, ?>) JsonParser.parse(json);
+  }
+}
diff --git a/util/src/test/java/io/grpc/util/RandomSubsettingLoadBalancerTest.java b/util/src/test/java/io/grpc/util/RandomSubsettingLoadBalancerTest.java
new file mode 100644
index 00000000000..2c43e8f4c3a
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/RandomSubsettingLoadBalancerTest.java
@@ -0,0 +1,333 @@
+/*
+ * Copyright 2025 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.Status;
+import io.grpc.internal.TestUtils;
+import io.grpc.util.RandomSubsettingLoadBalancer.RandomSubsettingLoadBalancerConfig;
+import java.net.SocketAddress;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
+
+@RunWith(JUnit4.class)
+public class RandomSubsettingLoadBalancerTest {
+  @Rule
+  public final MockitoRule mockitoRule = MockitoJUnit.rule();
+
+  @Mock
+  private LoadBalancer.Helper mockHelper;
+  @Mock
+  private LoadBalancer mockChildLb;
+  @Mock
+  private SocketAddress mockSocketAddress;
+
+  @Captor
+  private ArgumentCaptor<ResolvedAddresses> resolvedAddrCaptor;
+
+  private BackendDetails backendDetails;
+
+  private RandomSubsettingLoadBalancer loadBalancer;
+
+  private final LoadBalancerProvider mockChildLbProvider =
+      new TestUtils.StandardLoadBalancerProvider("foo_policy") {
+        @Override
+        public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+          return mockChildLb;
+        }
+      };
+
+  private final LoadBalancerProvider roundRobinLbProvider =
+      new TestUtils.StandardLoadBalancerProvider("round_robin") {
+        @Override
+        public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+          return new RoundRobinLoadBalancer(helper);
+        }
+      };
+
+  private Object newChildConfig(LoadBalancerProvider provider, Object config) {
+    return GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(provider, config);
+  }
+
+  private RandomSubsettingLoadBalancerConfig createRandomSubsettingLbConfig(
+      int subsetSize, LoadBalancerProvider childLbProvider, Object childConfig) {
+    return new RandomSubsettingLoadBalancer.RandomSubsettingLoadBalancerConfig.Builder()
+            .setSubsetSize(subsetSize)
+            .setChildConfig(newChildConfig(childLbProvider, childConfig))
+            .build();
+  }
+
+  private BackendDetails setupBackends(int backendCount) {
+    List<EquivalentAddressGroup> servers = Lists.newArrayList();
+    Map<List<EquivalentAddressGroup>, Subchannel> subchannels = Maps.newLinkedHashMap();
+
+    for (int i = 0; i < backendCount; i++) {
+      SocketAddress addr = new FakeSocketAddress("server" + i);
+      EquivalentAddressGroup addressGroup = new EquivalentAddressGroup(addr);
+      servers.add(addressGroup);
+      Subchannel subchannel = mock(Subchannel.class);
+      subchannels.put(Arrays.asList(addressGroup), subchannel);
+    }
+
+    return new BackendDetails(servers, subchannels);
+  }
+
+  @Before
+  public void setUp() {
+    int seed = 0;
+    loadBalancer = new RandomSubsettingLoadBalancer(mockHelper, seed);
+
+    int backendSize = 5;
+    backendDetails = setupBackends(backendSize);
+  }
+
+  @Test
+  public void handleNameResolutionError() {
+    int subsetSize = 2;
+    Object childConfig = "someConfig";
+
+    RandomSubsettingLoadBalancerConfig config = createRandomSubsettingLbConfig(
+        subsetSize, mockChildLbProvider, childConfig);
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.of(new EquivalentAddressGroup(mockSocketAddress)))
+            .setLoadBalancingPolicyConfig(config)
+            .build());
+
+    loadBalancer.handleNameResolutionError(Status.DEADLINE_EXCEEDED);
+    verify(mockChildLb).handleNameResolutionError(Status.DEADLINE_EXCEEDED);
+  }
+
+  @Test
+  public void shutdown() {
+    int subsetSize = 2;
+    Object childConfig = "someConfig";
+
+    RandomSubsettingLoadBalancerConfig config = createRandomSubsettingLbConfig(
+        subsetSize, mockChildLbProvider, childConfig);
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.of(new EquivalentAddressGroup(mockSocketAddress)))
+            .setLoadBalancingPolicyConfig(config)
+            .build());
+
+    loadBalancer.shutdown();
+    verify(mockChildLb).shutdown();
+  }
+
+  @Test
+  public void acceptResolvedAddresses_mockedChildLbPolicy() {
+    int subsetSize = 3;
+    Object childConfig = "someConfig";
+
+    RandomSubsettingLoadBalancerConfig config = createRandomSubsettingLbConfig(
+        subsetSize, mockChildLbProvider, childConfig);
+
+    ResolvedAddresses resolvedAddresses =
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.copyOf(backendDetails.servers))
+            .setLoadBalancingPolicyConfig(config)
+            .build();
+
+    loadBalancer.acceptResolvedAddresses(resolvedAddresses);
+
+    verify(mockChildLb).acceptResolvedAddresses(resolvedAddrCaptor.capture());
+    assertThat(resolvedAddrCaptor.getValue().getAddresses().size()).isEqualTo(subsetSize);
+    assertThat(resolvedAddrCaptor.getValue().getLoadBalancingPolicyConfig()).isEqualTo(childConfig);
+  }
+
+  @Test
+  public void acceptResolvedAddresses_roundRobinChildLbPolicy() {
+    int subsetSize = 3;
+    Object childConfig = null;
+
+    RandomSubsettingLoadBalancerConfig config = createRandomSubsettingLbConfig(
+        subsetSize, roundRobinLbProvider, childConfig);
+
+    ResolvedAddresses resolvedAddresses =
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.copyOf(backendDetails.servers))
+            .setLoadBalancingPolicyConfig(config)
+            .build();
+
+    loadBalancer.acceptResolvedAddresses(resolvedAddresses);
+
+    int insubset = 0;
+    for (Subchannel subchannel : backendDetails.subchannels.values()) {
+      LoadBalancer.SubchannelStateListener ssl =
+          backendDetails.subchannelStateListeners.get(subchannel);
+      if (ssl != null) { // it might be null if it's not in the subset.
+        insubset += 1;
+        ssl.onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+      }
+    }
+
+    assertThat(insubset).isEqualTo(subsetSize);
+  }
+
+  // verifies: https://github.com/grpc/proposal/blob/master/A68_graphics/subsetting100-100-5.png
+  @Test
+  public void backendsCanBeDistributedEvenly_subsetting100_100_5() {
+    verifyConnectionsByServer(100, 100, 5, 15);
+  }
+
+  // verifies https://github.com/grpc/proposal/blob/master/A68_graphics/subsetting100-100-25.png
+  @Test
+  public void backendsCanBeDistributedEvenly_subsetting100_100_25() {
+    verifyConnectionsByServer(100, 100, 25, 40);
+  }
+
+  // verifies: https://github.com/grpc/proposal/blob/master/A68_graphics/subsetting100-10-5.png
+  @Test
+  public void backendsCanBeDistributedEvenly_subsetting100_10_5() {
+    verifyConnectionsByServer(100, 10, 5, 65);
+  }
+
+  // verifies: https://github.com/grpc/proposal/blob/master/A68_graphics/subsetting500-10-5.png
+  @Test
+  public void backendsCanBeDistributedEvenly_subsetting500_10_5() {
+    verifyConnectionsByServer(500, 10, 5, 600);
+  }
+
+  // verifies: https://github.com/grpc/proposal/blob/master/A68_graphics/subsetting2000-10-5.png
+  @Test
+  public void backendsCanBeDistributedEvenly_subsetting2000_100_5() {
+    verifyConnectionsByServer(2000, 10, 5, 1200);
+  }
+
+  public void verifyConnectionsByServer(
+      int clientsCount, int serversCount, int subsetSize, int expectedMaxConnections) {
+    backendDetails = setupBackends(serversCount);
+    Object childConfig = "someConfig";
+
+    List<RandomSubsettingLoadBalancerConfig> configs = Lists.newArrayList();
+    for (int i = 0; i < clientsCount; i++) {
+      configs.add(createRandomSubsettingLbConfig(subsetSize, mockChildLbProvider, childConfig));
+    }
+
+    Map<SocketAddress, Integer> connectionsByServer = Maps.newLinkedHashMap();
+
+    for (int i = 0; i < clientsCount; i++) {
+      RandomSubsettingLoadBalancerConfig config = configs.get(i);
+
+      ResolvedAddresses resolvedAddresses =
+          ResolvedAddresses.newBuilder()
+              .setAddresses(ImmutableList.copyOf(backendDetails.servers))
+              .setLoadBalancingPolicyConfig(config)
+              .build();
+
+      loadBalancer = new RandomSubsettingLoadBalancer(mockHelper, i);
+      loadBalancer.acceptResolvedAddresses(resolvedAddresses);
+
+      verify(mockChildLb, atLeastOnce()).acceptResolvedAddresses(resolvedAddrCaptor.capture());
+      // Verify ChildLB is only getting subsetSize ResolvedAddresses each time
+      assertThat(resolvedAddrCaptor.getValue().getAddresses().size()).isEqualTo(config.subsetSize);
+
+      for (EquivalentAddressGroup eag : resolvedAddrCaptor.getValue().getAddresses()) {
+        for (SocketAddress addr : eag.getAddresses()) {
+          Integer prev = connectionsByServer.getOrDefault(addr, 0);
+          connectionsByServer.put(addr, prev + 1);
+        }
+      }
+    }
+
+    int maxConnections = Collections.max(connectionsByServer.values());
+
+    assertThat(maxConnections).isAtMost(expectedMaxConnections);
+  }
+
+  private class BackendDetails {
+    private final List<EquivalentAddressGroup> servers;
+    private final Map<List<EquivalentAddressGroup>, Subchannel> subchannels;
+    private final Map<Subchannel, LoadBalancer.SubchannelStateListener> subchannelStateListeners;
+
+    BackendDetails(List<EquivalentAddressGroup> servers,
+                   Map<List<EquivalentAddressGroup>, Subchannel> subchannels) {
+      this.servers = servers;
+      this.subchannels = subchannels;
+      this.subchannelStateListeners = Maps.newLinkedHashMap();
+
+      when(mockHelper.createSubchannel(any(LoadBalancer.CreateSubchannelArgs.class))).then(
+          new Answer<Subchannel>() {
+            @Override
+            public Subchannel answer(InvocationOnMock invocation) throws Throwable {
+              CreateSubchannelArgs args = (CreateSubchannelArgs) invocation.getArguments()[0];
+              final Subchannel subchannel = backendDetails.subchannels.get(args.getAddresses());
+              when(subchannel.getAllAddresses()).thenReturn(args.getAddresses());
+              when(subchannel.getAttributes()).thenReturn(args.getAttributes());
+              doAnswer(new Answer<Void>() {
+                @Override
+                public Void answer(InvocationOnMock invocation) throws Throwable {
+                  subchannelStateListeners.put(subchannel,
+                        (SubchannelStateListener) invocation.getArguments()[0]);
+                  return null;
+                }
+              }).when(subchannel).start(any(SubchannelStateListener.class));
+              return subchannel;
+            }
+          });
+    }
+  }
+
+  private static class FakeSocketAddress extends SocketAddress {
+    final String name;
+
+    FakeSocketAddress(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public String toString() {
+      return "FakeSocketAddress-" + name;
+    }
+  }
+}
diff --git a/util/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java b/util/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java
new file mode 100644
index 00000000000..18854ca1bb6
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/RoundRobinLoadBalancerTest.java
@@ -0,0 +1,599 @@
+/*
+ * Copyright 2016 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.util;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.fail;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import com.google.common.collect.Lists;
+import io.grpc.Attributes;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.FixedResultPicker;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.Status;
+import io.grpc.internal.PickFirstLoadBalancerProvider;
+import io.grpc.internal.PickFirstLoadBalancerProviderAccessor;
+import io.grpc.internal.TestUtils;
+import io.grpc.util.RoundRobinLoadBalancer.ReadyPicker;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit test for {@link RoundRobinLoadBalancer}. */
+@RunWith(JUnit4.class)
+public class RoundRobinLoadBalancerTest {
+  private static final Attributes.Key<String> MAJOR_KEY = Attributes.Key.create("major-key");
+  private static final SubchannelPicker EMPTY_PICKER =
+      new FixedResultPicker(PickResult.withNoResult());
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private RoundRobinLoadBalancer loadBalancer;
+  private final List<EquivalentAddressGroup> servers = Lists.newArrayList();
+  private final Map<List<EquivalentAddressGroup>, Subchannel> subchannels =
+      new ConcurrentHashMap<>();
+  private final Attributes affinity =
+      Attributes.newBuilder().set(MAJOR_KEY, "I got the keys").build();
+
+  @Captor
+  private ArgumentCaptor<SubchannelPicker> pickerCaptor;
+  @Captor
+  private ArgumentCaptor<ConnectivityState> stateCaptor;
+  @Captor
+  private ArgumentCaptor<CreateSubchannelArgs> createArgsCaptor;
+  private TestHelper testHelperInst = new TestHelper();
+  private Helper mockHelper = mock(Helper.class, delegatesTo(testHelperInst));
+  private boolean defaultNewPickFirst = PickFirstLoadBalancerProvider.isEnabledNewPickFirst();
+
+  @Mock // This LoadBalancer doesn't use any of the arg fields, as verified in tearDown().
+  private PickSubchannelArgs mockArgs;
+
+  @Before
+  public void setUp() {
+    for (int i = 0; i < 3; i++) {
+      SocketAddress addr = new FakeSocketAddress("server" + i);
+      EquivalentAddressGroup eag = new EquivalentAddressGroup(addr);
+      servers.add(eag);
+    }
+
+    loadBalancer = new RoundRobinLoadBalancer(mockHelper);
+  }
+
+  private Status acceptAddresses(List<EquivalentAddressGroup> eagList, Attributes attrs) {
+    return loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(eagList).setAttributes(attrs).build());
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    PickFirstLoadBalancerProviderAccessor.setEnableNewPickFirst(defaultNewPickFirst);
+    verifyNoMoreInteractions(mockArgs);
+  }
+
+  @Test
+  public void pickAfterResolved() throws Exception {
+    Status addressesAcceptanceStatus = acceptAddresses(servers, affinity);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    final Subchannel readySubchannel = subchannels.values().iterator().next();
+    deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
+
+    verify(mockHelper, times(3)).createSubchannel(createArgsCaptor.capture());
+    List<List<EquivalentAddressGroup>> capturedAddrs = new ArrayList<>();
+    for (CreateSubchannelArgs arg : createArgsCaptor.getAllValues()) {
+      capturedAddrs.add(arg.getAddresses());
+    }
+
+    assertThat(capturedAddrs).containsAtLeastElementsIn(subchannels.keySet());
+    for (Subchannel subchannel : subchannels.values()) {
+      verify(subchannel).requestConnection();
+      verify(subchannel, never()).shutdown();
+    }
+
+    verify(mockHelper, times(2))
+        .updateBalancingState(stateCaptor.capture(), pickerCaptor.capture());
+
+    assertEquals(CONNECTING, stateCaptor.getAllValues().get(0));
+    assertEquals(READY, stateCaptor.getAllValues().get(1));
+    assertThat(getList(pickerCaptor.getValue())).containsExactly(readySubchannel);
+
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(mockHelper);
+  }
+
+  @Test
+  public void pickAfterResolvedUpdatedHosts() throws Exception {
+    Attributes.Key<String> key = Attributes.Key.create("check-that-it-is-propagated");
+    FakeSocketAddress removedAddr = new FakeSocketAddress("removed");
+    EquivalentAddressGroup removedEag = new EquivalentAddressGroup(removedAddr);
+    FakeSocketAddress oldAddr = new FakeSocketAddress("old");
+    EquivalentAddressGroup oldEag1 = new EquivalentAddressGroup(oldAddr);
+    EquivalentAddressGroup oldEag2 = new EquivalentAddressGroup(
+        oldAddr, Attributes.newBuilder().set(key, "oldattr").build());
+    FakeSocketAddress newAddr = new FakeSocketAddress("new");
+    EquivalentAddressGroup newEag = new EquivalentAddressGroup(
+        newAddr, Attributes.newBuilder().set(key, "newattr").build());
+
+    Subchannel removedSubchannel = mockHelper.createSubchannel(CreateSubchannelArgs.newBuilder()
+        .setAddresses(removedEag).build());
+    Subchannel oldSubchannel = mockHelper.createSubchannel(CreateSubchannelArgs.newBuilder()
+        .setAddresses(oldEag1).build());
+    Subchannel newSubchannel = mockHelper.createSubchannel(CreateSubchannelArgs.newBuilder()
+        .setAddresses(newEag).build());
+
+    subchannels.put(Collections.singletonList(removedEag), removedSubchannel);
+    subchannels.put(Collections.singletonList(oldEag1), oldSubchannel);
+    subchannels.put(Collections.singletonList(newEag), newSubchannel);
+
+    List<EquivalentAddressGroup> currentServers = Lists.newArrayList(removedEag, oldEag1);
+
+    InOrder inOrder = inOrder(mockHelper);
+
+    Status addressesAcceptanceStatus = acceptAddresses(currentServers, affinity);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+
+    deliverSubchannelState(removedSubchannel, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(oldSubchannel, ConnectivityStateInfo.forNonError(READY));
+
+    inOrder.verify(mockHelper, times(2)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertThat(getList(picker)).containsExactly(removedSubchannel, oldSubchannel);
+
+    verify(removedSubchannel, times(1)).requestConnection();
+    verify(oldSubchannel, times(1)).requestConnection();
+
+    // This time with Attributes
+    List<EquivalentAddressGroup> latestServers = Lists.newArrayList(oldEag2, newEag);
+
+    addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(latestServers).setAttributes(affinity).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+
+    verify(newSubchannel, times(1)).requestConnection();
+    verify(oldSubchannel, times(1)).updateAddresses(Arrays.asList(oldEag2));
+    verify(removedSubchannel, times(1)).shutdown();
+
+    deliverSubchannelState(newSubchannel, ConnectivityStateInfo.forNonError(READY));
+
+    verify(mockHelper, times(6)).createSubchannel(any(CreateSubchannelArgs.class));
+    inOrder.verify(mockHelper, times(2)).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    picker = pickerCaptor.getValue();
+    assertThat(getList(picker)).containsExactly(oldSubchannel, newSubchannel);
+
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(mockHelper);
+  }
+
+  @Test
+  public void pickAfterStateChange() throws Exception {
+    InOrder inOrder = inOrder(mockHelper);
+    Status addressesAcceptanceStatus =
+        acceptAddresses(Arrays.asList(servers.get(0)), Attributes.EMPTY);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    inOrder.verify(mockHelper).createSubchannel(any(CreateSubchannelArgs.class));
+
+    // TODO figure out if this method testing the right things
+
+    assertThat(subchannels).hasSize(1);
+    Subchannel subchannel = subchannels.values().iterator().next();
+
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), eq(EMPTY_PICKER));
+
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertThat(pickerCaptor.getValue()).isInstanceOf(ReadyPicker.class);
+
+    Status error = Status.UNKNOWN.withDescription("¯\\_(ツ)_//¯");
+    deliverSubchannelState(subchannel,
+        ConnectivityStateInfo.forTransientFailure(error));
+    AbstractTestHelper.refreshInvokedAndUpdateBS(
+        inOrder, TRANSIENT_FAILURE, mockHelper, pickerCaptor);
+    assertThat(pickerCaptor.getValue().pickSubchannel(mockArgs).getStatus()).isEqualTo(error);
+
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(mockHelper).refreshNameResolution();
+    inOrder.verify(mockHelper, never())
+        .updateBalancingState(eq(TRANSIENT_FAILURE), any(SubchannelPicker.class));
+
+    verify(subchannel, atLeastOnce()).requestConnection();
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(mockHelper);
+  }
+
+  @Test
+  public void ignoreShutdownSubchannelStateChange() {
+    InOrder inOrder = inOrder(mockHelper);
+    Status addressesAcceptanceStatus = acceptAddresses(servers, Attributes.EMPTY);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), eq(EMPTY_PICKER));
+
+    List<Subchannel> savedSubchannels = new ArrayList<>(subchannels.values());
+    loadBalancer.shutdown();
+    for (Subchannel sc : savedSubchannels) {
+      verify(sc).shutdown();
+      // When the subchannel is being shut down, a SHUTDOWN connectivity state is delivered
+      // back to the subchannel state listener.
+      deliverSubchannelState(sc, ConnectivityStateInfo.forNonError(SHUTDOWN));
+    }
+
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void stayTransientFailureUntilReady() {
+    InOrder inOrder = inOrder(mockHelper);
+    Status addressesAcceptanceStatus = acceptAddresses(servers, Attributes.EMPTY);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+
+    inOrder.verify(mockHelper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), eq(EMPTY_PICKER));
+
+    // Simulate state transitions for each subchannel individually.
+    for (Subchannel sc : subchannels.values()) {
+      Status error = Status.UNKNOWN.withDescription("connection broken");
+      deliverSubchannelState(
+          sc,
+          ConnectivityStateInfo.forTransientFailure(error));
+      deliverSubchannelState(
+          sc,
+          ConnectivityStateInfo.forNonError(CONNECTING));
+    }
+    inOrder.verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), isA(ReadyPicker.class));
+    inOrder.verify(mockHelper, atLeast(0)).refreshNameResolution();
+    inOrder.verifyNoMoreInteractions();
+
+    Subchannel subchannel = subchannels.values().iterator().next();
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper).updateBalancingState(eq(READY), isA(ReadyPicker.class));
+
+    inOrder.verify(mockHelper, atLeast(0)).refreshNameResolution();
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void refreshNameResolutionWhenSubchannelConnectionBroken() {
+    InOrder inOrder = inOrder(mockHelper);
+    Status addressesAcceptanceStatus = acceptAddresses(servers, Attributes.EMPTY);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+
+    verify(mockHelper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), eq(EMPTY_PICKER));
+
+    // Simulate state transitions for each subchannel individually.
+    for (Subchannel sc : subchannels.values()) {
+      verify(sc).requestConnection();
+      deliverSubchannelState(sc, ConnectivityStateInfo.forNonError(CONNECTING));
+      Status error = Status.UNKNOWN.withDescription("connection broken");
+      deliverSubchannelState(sc, ConnectivityStateInfo.forTransientFailure(error));
+      inOrder.verify(mockHelper).refreshNameResolution();
+      deliverSubchannelState(sc, ConnectivityStateInfo.forNonError(READY));
+      inOrder.verify(mockHelper).updateBalancingState(eq(READY), isA(ReadyPicker.class));
+      // Simulate receiving go-away so READY subchannels transit to IDLE.
+      deliverSubchannelState(sc, ConnectivityStateInfo.forNonError(IDLE));
+      inOrder.verify(mockHelper).refreshNameResolution();
+      verify(sc, times(2)).requestConnection();
+      inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), eq(EMPTY_PICKER));
+    }
+
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(mockHelper);
+  }
+
+  @Test
+  public void removingAddressShutsdownSubchannel() {
+    acceptAddresses(servers, affinity);
+    final Subchannel subchannel2 = subchannels.get(Collections.singletonList(servers.get(2)));
+
+    InOrder inOrder = Mockito.inOrder(mockHelper, subchannel2);
+    // send LB only the first 2 addresses
+    List<EquivalentAddressGroup> svs2 = Arrays.asList(servers.get(0), servers.get(1));
+    acceptAddresses(svs2, affinity);
+    inOrder.verify(mockHelper).updateBalancingState(eq(CONNECTING), any());
+    inOrder.verify(subchannel2).shutdown();
+  }
+
+  @Test
+  public void pickerRoundRobin() throws Exception {
+    Subchannel subchannel = mock(Subchannel.class);
+    Subchannel subchannel1 = mock(Subchannel.class);
+    Subchannel subchannel2 = mock(Subchannel.class);
+
+    ArrayList<SubchannelPicker> pickers = Lists.newArrayList(
+        TestUtils.pickerOf(subchannel), TestUtils.pickerOf(subchannel1),
+        TestUtils.pickerOf(subchannel2));
+
+    AtomicInteger seq = new AtomicInteger(0);
+    ReadyPicker picker = new ReadyPicker(Collections.unmodifiableList(pickers), seq);
+
+    assertEquals(subchannel, picker.pickSubchannel(mockArgs).getSubchannel());
+    assertEquals(subchannel1, picker.pickSubchannel(mockArgs).getSubchannel());
+    assertEquals(subchannel2, picker.pickSubchannel(mockArgs).getSubchannel());
+    assertEquals(subchannel, picker.pickSubchannel(mockArgs).getSubchannel());
+
+    seq.set(Integer.MAX_VALUE);
+    assertEquals(subchannel1, picker.pickSubchannel(mockArgs).getSubchannel());
+    assertEquals(subchannel, picker.pickSubchannel(mockArgs).getSubchannel());
+    assertEquals(subchannel1, picker.pickSubchannel(mockArgs).getSubchannel());
+    assertEquals(subchannel2, picker.pickSubchannel(mockArgs).getSubchannel());
+    assertEquals(subchannel, picker.pickSubchannel(mockArgs).getSubchannel());
+  }
+
+  @Test
+  public void nameResolutionErrorWithNoChannels() throws Exception {
+    Status error = Status.NOT_FOUND.withDescription("nameResolutionError");
+    loadBalancer.handleNameResolutionError(error);
+    verify(mockHelper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    LoadBalancer.PickResult pickResult = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertNull(pickResult.getSubchannel());
+    assertEquals(error, pickResult.getStatus());
+    verifyNoMoreInteractions(mockHelper);
+  }
+
+  @Test
+  public void nameResolutionErrorWithActiveChannels() throws Exception {
+    Status addressesAcceptanceStatus = acceptAddresses(servers, affinity);
+    final Subchannel readySubchannel = subchannels.values().iterator().next();
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
+    loadBalancer.resolvingAddresses = true;
+    loadBalancer.handleNameResolutionError(Status.NOT_FOUND.withDescription("nameResolutionError"));
+    loadBalancer.resolvingAddresses = false;
+
+    verify(mockHelper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
+    verify(mockHelper, times(2))
+        .updateBalancingState(stateCaptor.capture(), pickerCaptor.capture());
+
+    Iterator<ConnectivityState> stateIterator = stateCaptor.getAllValues().iterator();
+    assertEquals(CONNECTING, stateIterator.next());
+    assertEquals(READY, stateIterator.next());
+
+    LoadBalancer.PickResult pickResult = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertEquals(readySubchannel, pickResult.getSubchannel());
+    assertEquals(Status.OK.getCode(), pickResult.getStatus().getCode());
+
+    LoadBalancer.PickResult pickResult2 = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertEquals(readySubchannel, pickResult2.getSubchannel());
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(mockHelper);
+  }
+
+  @Test
+  public void subchannelStateIsolation() throws Exception {
+    Status addressesAcceptanceStatus = acceptAddresses(servers, Attributes.EMPTY);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+
+    Iterator<Subchannel> subchannelIterator = subchannels.values().iterator();
+    Subchannel sc1 = subchannelIterator.next();
+    Subchannel sc2 = subchannelIterator.next();
+    Subchannel sc3 = subchannelIterator.next();
+
+    verify(sc1, times(1)).requestConnection();
+    verify(sc2, times(1)).requestConnection();
+    verify(sc3, times(1)).requestConnection();
+
+    deliverSubchannelState(sc1, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(sc2, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(sc3, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(sc2, ConnectivityStateInfo.forNonError(IDLE));
+    deliverSubchannelState(sc3, ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+
+    verify(mockHelper, times(6))
+        .updateBalancingState(stateCaptor.capture(), pickerCaptor.capture());
+    Iterator<ConnectivityState> stateIterator = stateCaptor.getAllValues().iterator();
+    Iterator<SubchannelPicker> pickers = pickerCaptor.getAllValues().iterator();
+    // The picker is incrementally updated as subchannels become READY
+    assertEquals(CONNECTING, stateIterator.next());
+    assertThat(pickers.next()).isEqualTo(EMPTY_PICKER);
+    assertEquals(READY, stateIterator.next());
+    assertThat(getList(pickers.next())).containsExactly(sc1);
+    assertEquals(READY, stateIterator.next());
+    assertThat(getList(pickers.next())).containsExactly(sc1, sc2);
+    assertEquals(READY, stateIterator.next());
+    assertThat(getList(pickers.next())).containsExactly(sc1, sc2, sc3);
+    // The IDLE subchannel is dropped from the picker, but a reconnection is requested
+    assertEquals(READY, stateIterator.next());
+    assertThat(getList(pickers.next())).containsExactly(sc1, sc3);
+    verify(sc2, times(2)).requestConnection();
+    // The failing subchannel is dropped from the picker, with no requested reconnect
+    assertEquals(READY, stateIterator.next());
+    assertThat(getList(pickers.next())).containsExactly(sc1);
+    verify(sc3, times(1)).requestConnection();
+    assertThat(stateIterator.hasNext()).isFalse();
+    assertThat(pickers.hasNext()).isFalse();
+  }
+
+  @Test
+  public void subchannelHealthObserved() throws Exception {
+    // Only the new PF policy observes the new separate listener for health
+    PickFirstLoadBalancerProviderAccessor.setEnableNewPickFirst(true);
+    // PickFirst does most of this work. If the test fails, check IS_PETIOLE_POLICY
+    Map<Subchannel, LoadBalancer.SubchannelStateListener> healthListeners = new HashMap<>();
+    loadBalancer = new RoundRobinLoadBalancer(new ForwardingLoadBalancerHelper() {
+      @Override
+      public Subchannel createSubchannel(CreateSubchannelArgs args) {
+        Subchannel subchannel = super.createSubchannel(args.toBuilder()
+            .setAttributes(args.getAttributes().toBuilder()
+              .set(LoadBalancer.HAS_HEALTH_PRODUCER_LISTENER_KEY, true)
+              .build())
+            .build());
+        healthListeners.put(
+            subchannel, args.getOption(LoadBalancer.HEALTH_CONSUMER_LISTENER_ARG_KEY));
+        return subchannel;
+      }
+
+      @Override
+      protected Helper delegate() {
+        return mockHelper;
+      }
+    });
+
+    InOrder inOrder = inOrder(mockHelper);
+    Status addressesAcceptanceStatus = acceptAddresses(servers, Attributes.EMPTY);
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    Subchannel subchannel0 = subchannels.get(Arrays.asList(servers.get(0)));
+    Subchannel subchannel1 = subchannels.get(Arrays.asList(servers.get(1)));
+    Subchannel subchannel2 = subchannels.get(Arrays.asList(servers.get(2)));
+
+    // Subchannels go READY, but the LB waits for health
+    for (Subchannel subchannel : subchannels.values()) {
+      deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(READY));
+    }
+    inOrder.verify(mockHelper, times(0))
+        .updateBalancingState(eq(READY), any(SubchannelPicker.class));
+
+    // Health results lets subchannels go READY
+    healthListeners.get(subchannel0).onSubchannelState(
+        ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE.withDescription("oh no")));
+    healthListeners.get(subchannel1).onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    healthListeners.get(subchannel2).onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(mockHelper, times(2)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    List<Subchannel> picks = Arrays.asList(
+        picker.pickSubchannel(mockArgs).getSubchannel(),
+        picker.pickSubchannel(mockArgs).getSubchannel(),
+        picker.pickSubchannel(mockArgs).getSubchannel(),
+        picker.pickSubchannel(mockArgs).getSubchannel());
+    assertThat(picks).containsExactly(subchannel1, subchannel2, subchannel1, subchannel2);
+  }
+
+  @Test
+  public void readyPicker_emptyList() {
+    // ready picker list must be non-empty
+    try {
+      new ReadyPicker(Collections.emptyList(), new AtomicInteger(0));
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  @Test
+  public void internalPickerComparisons() {
+    SubchannelPicker empty1 = new FixedResultPicker(PickResult.withNoResult());
+    SubchannelPicker empty2 = new FixedResultPicker(PickResult.withNoResult());
+
+    AtomicInteger seq = new AtomicInteger(0);
+    acceptAddresses(servers, Attributes.EMPTY); // create subchannels
+    Iterator<Subchannel> subchannelIterator = subchannels.values().iterator();
+    SubchannelPicker sc1 = TestUtils.pickerOf(subchannelIterator.next());
+    SubchannelPicker sc2 = TestUtils.pickerOf(subchannelIterator.next());
+    SubchannelPicker ready1 = new ReadyPicker(Arrays.asList(sc1, sc2), seq);
+    SubchannelPicker ready2 = new ReadyPicker(Arrays.asList(sc1), seq);
+    SubchannelPicker ready3 = new ReadyPicker(Arrays.asList(sc2, sc1), seq);
+    SubchannelPicker ready4 = new ReadyPicker(Arrays.asList(sc1, sc2), seq);
+    SubchannelPicker ready5 = new ReadyPicker(Arrays.asList(sc2, sc1), new AtomicInteger(0));
+
+    assertThat(empty1).isEqualTo(empty2);
+    assertThat(ready1).isNotEqualTo(ready2);
+    assertThat(ready1).isEqualTo(ready3);
+    assertThat(ready3).isEqualTo(ready4);
+    assertThat(ready4).isNotEqualTo(ready5);
+    assertThat(empty1).isNotEqualTo(ready1);
+    assertThat(ready1).isNotEqualTo(empty1);
+  }
+
+  @Test
+  public void emptyAddresses() {
+    assertThat(loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(Collections.emptyList())
+            .setAttributes(affinity)
+            .build()).isOk()).isFalse();
+  }
+
+  private List<Subchannel> getList(SubchannelPicker picker) {
+
+    if (picker instanceof ReadyPicker) {
+      List<Subchannel> subchannelList = new ArrayList<>();
+      for (SubchannelPicker childPicker : ((ReadyPicker) picker).getSubchannelPickers()) {
+        subchannelList.add(childPicker.pickSubchannel(mockArgs).getSubchannel());
+      }
+      return subchannelList;
+    } else {
+      return new ArrayList<>();
+    }
+  }
+
+  private void deliverSubchannelState(Subchannel subchannel, ConnectivityStateInfo newState) {
+    testHelperInst.deliverSubchannelState(subchannel, newState);
+  }
+
+  private static class FakeSocketAddress extends SocketAddress {
+    final String name;
+
+    FakeSocketAddress(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public String toString() {
+      return "FakeSocketAddress-" + name;
+    }
+  }
+
+  private class TestHelper extends AbstractTestHelper {
+
+    @Override
+    public Map<List<EquivalentAddressGroup>, Subchannel> getSubchannelMap() {
+      return subchannels;
+    }
+  }
+}
diff --git a/util/src/test/java/io/grpc/util/UtilServerInterceptorsTest.java b/util/src/test/java/io/grpc/util/UtilServerInterceptorsTest.java
new file mode 100644
index 00000000000..a4691d8bdec
--- /dev/null
+++ b/util/src/test/java/io/grpc/util/UtilServerInterceptorsTest.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright 2017 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.util;
+
+import static com.google.common.collect.Iterables.getOnlyElement;
+import static org.junit.Assert.assertEquals;
+
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.NoopServerCall;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptors;
+import io.grpc.ServerMethodDefinition;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.ServiceDescriptor;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.testing.TestMethodDescriptors;
+import java.util.Arrays;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit test for {@link io.grpc.ServerInterceptor} implementations that come with gRPC. Not to be
+ * confused with the unit tests that validate gRPC's usage of interceptors.
+ */
+@RunWith(JUnit4.class)
+public class UtilServerInterceptorsTest {
+  private static class VoidCallListener extends ServerCall.Listener<Void> {
+    public void onCall(ServerCall<Void, Void> unused, Metadata unused2) { }
+  }
+
+  private MethodDescriptor<Void, Void> flowMethod = TestMethodDescriptors.voidMethod();
+  private final Metadata headers = new Metadata();
+  private ServerCallHandler<Void, Void> handler = new ServerCallHandler<Void, Void>() {
+      @Override
+      public ServerCall.Listener<Void> startCall(
+          ServerCall<Void, Void> call, Metadata headers) {
+        listener.onCall(call, headers);
+        return listener;
+      }
+  };
+  private ServerServiceDefinition serviceDefinition =
+      ServerServiceDefinition.builder(new ServiceDescriptor("service_foo", flowMethod))
+          .addMethod(flowMethod, handler)
+          .build();
+  private VoidCallListener listener;
+
+  @SuppressWarnings("unchecked")
+  private static ServerMethodDefinition<Void, Void> getSoleMethod(
+      ServerServiceDefinition serviceDef) {
+    if (serviceDef.getMethods().size() != 1) {
+      throw new AssertionError("Not exactly one method present");
+    }
+    return (ServerMethodDefinition<Void, Void>) getOnlyElement(serviceDef.getMethods());
+  }
+
+  @Test
+  public void statusRuntimeExceptionTransmitter() {
+    final Status expectedStatus = Status.UNAVAILABLE;
+    final Metadata expectedMetadata = new Metadata();
+    FakeServerCall<Void, Void> call =
+        new FakeServerCall<>(expectedStatus, expectedMetadata);
+    final StatusRuntimeException exception =
+        new StatusRuntimeException(expectedStatus, expectedMetadata);
+    listener = new VoidCallListener() {
+      @Override
+      public void onMessage(Void message) {
+        throw exception;
+      }
+
+      @Override
+      public void onHalfClose() {
+        throw exception;
+      }
+
+      @Override
+      public void onCancel() {
+        throw exception;
+      }
+
+      @Override
+      public void onComplete() {
+        throw exception;
+      }
+
+      @Override
+      public void onReady() {
+        throw exception;
+      }
+    };
+
+    ServerServiceDefinition intercepted = ServerInterceptors.intercept(
+        serviceDefinition,
+        Arrays.asList(TransmitStatusRuntimeExceptionInterceptor.instance()));
+    // The interceptor should have handled the error by directly closing the ServerCall
+    // and the exception should not propagate to the method's caller
+    getSoleMethod(intercepted).getServerCallHandler().startCall(call, headers).onMessage(null);
+    getSoleMethod(intercepted).getServerCallHandler().startCall(call, headers).onCancel();
+    getSoleMethod(intercepted).getServerCallHandler().startCall(call, headers).onComplete();
+    getSoleMethod(intercepted).getServerCallHandler().startCall(call, headers).onHalfClose();
+    getSoleMethod(intercepted).getServerCallHandler().startCall(call, headers).onReady();
+    assertEquals(5, call.numCloses);
+  }
+
+  @Test
+  public void statusRuntimeExceptionTransmitterIgnoresClosedCalls() {
+    final Status expectedStatus = Status.UNAVAILABLE;
+    final Status unexpectedStatus = Status.CANCELLED;
+    final Metadata expectedMetadata = new Metadata();
+
+    FakeServerCall<Void, Void> call =
+        new FakeServerCall<>(expectedStatus, expectedMetadata);
+    final StatusRuntimeException exception =
+        new StatusRuntimeException(expectedStatus, expectedMetadata);
+
+    listener = new VoidCallListener() {
+      @Override
+      public void onMessage(Void message) {
+        throw exception;
+      }
+
+      @Override
+      public void onHalfClose() {
+        throw exception;
+      }
+    };
+
+    ServerServiceDefinition intercepted = ServerInterceptors.intercept(
+        serviceDefinition,
+        Arrays.asList(TransmitStatusRuntimeExceptionInterceptor.instance()));
+    ServerCall.Listener<Void> callDoubleSreListener =
+        getSoleMethod(intercepted).getServerCallHandler().startCall(call, headers);
+    callDoubleSreListener.onMessage(null); // the only close with our exception
+    callDoubleSreListener.onHalfClose(); // should not trigger a close
+
+    // this listener closes the call when it is initialized with startCall
+    listener = new VoidCallListener() {
+      @Override
+      public void onCall(ServerCall<Void, Void> call, Metadata headers) {
+        call.close(unexpectedStatus, headers);
+      }
+
+      @Override
+      public void onHalfClose() {
+        throw exception;
+      }
+    };
+
+    ServerCall.Listener<Void> callClosedListener =
+        getSoleMethod(intercepted).getServerCallHandler().startCall(call, headers);
+    // call is already closed, does not match exception
+    callClosedListener.onHalfClose(); // should not trigger a close
+    assertEquals(1, call.numCloses);
+  }
+
+  private static class FakeServerCall<ReqT, RespT> extends NoopServerCall<ReqT, RespT> {
+    final Status expectedStatus;
+    final Metadata expectedMetadata;
+
+    int numCloses;
+
+    FakeServerCall(Status expectedStatus, Metadata expectedMetadata) {
+      this.expectedStatus = expectedStatus;
+      this.expectedMetadata = expectedMetadata;
+    }
+
+    @Override
+    @SuppressWarnings("ReferenceEquality")
+    public void close(Status status, Metadata trailers) {
+      if (status == expectedStatus && trailers == expectedMetadata) {
+        numCloses++;
+      }
+    }
+  }
+}
diff --git a/util/src/testFixtures/java/io/grpc/util/AbstractTestHelper.java b/util/src/testFixtures/java/io/grpc/util/AbstractTestHelper.java
new file mode 100644
index 00000000000..837dc68c057
--- /dev/null
+++ b/util/src/testFixtures/java/io/grpc/util/AbstractTestHelper.java
@@ -0,0 +1,298 @@
+/*
+ * Copyright 2023 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.util;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import io.grpc.Attributes;
+import io.grpc.Channel;
+import io.grpc.ChannelLogger;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.PickFirstLoadBalancerProvider;
+import java.net.SocketAddress;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ScheduledExecutorService;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InOrder;
+
+/**
+ * A real class that can be used as a delegate of a mock Helper to provide more real representation
+ * and track the subchannels as is needed with petiole policies where the subchannels are no
+ * longer direct children of the loadbalancer.
+ * <br>
+ * To use it replace <br>
+ * \@mock Helper mockHelper<br>
+ * with<br>
+ *
+ * <p>Helper mockHelper = mock(Helper.class, delegatesTo(new TestHelper()));</p>
+ * <br>
+ * TestHelper will need to define accessors for the maps that information is store within as
+ * those maps need to be defined in the Test class.
+ */
+public abstract class AbstractTestHelper extends ForwardingLoadBalancerHelper {
+
+  private final Map<Subchannel, TestSubchannel> mockToRealSubChannelMap = new HashMap<>();
+  protected final Map<Subchannel, Subchannel> realToMockSubChannelMap = new HashMap<>();
+  private final FakeClock fakeClock;
+  private final SynchronizationContext syncContext;
+
+  public abstract Map<List<EquivalentAddressGroup>, Subchannel> getSubchannelMap();
+
+  public AbstractTestHelper() {
+    this(new FakeClock(), new SynchronizationContext(new Thread.UncaughtExceptionHandler() {
+      @Override
+      public void uncaughtException(Thread t, Throwable e) {
+        throw new RuntimeException(e);
+      }
+    }));
+  }
+
+  public AbstractTestHelper(FakeClock fakeClock, SynchronizationContext syncContext) {
+    super();
+    this.fakeClock = fakeClock;
+    this.syncContext = syncContext;
+  }
+
+  private TestSubchannel getRealForMockSubChannel(Subchannel mock) {
+    TestSubchannel realSc = mockToRealSubChannelMap.get(mock);
+    if (realSc == null) {
+      realSc = (TestSubchannel) mock;
+    }
+    return realSc;
+  }
+
+  public static final FakeClock.TaskFilter NOT_START_NEXT_CONNECTION =
+      new FakeClock.TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable command) {
+          return !command.toString().contains("StartNextConnection");
+        }
+      };
+
+  public static int getNumFilteredPendingTasks(FakeClock fakeClock) {
+    return fakeClock.getPendingTasks(NOT_START_NEXT_CONNECTION).size();
+  }
+
+  public void deliverSubchannelState(Subchannel subchannel, ConnectivityStateInfo newState) {
+    getSubchannelStateListener(subchannel).onSubchannelState(newState);
+  }
+
+  public SubchannelStateListener getSubchannelStateListener(Subchannel subchannel) {
+    SubchannelStateListener listener = getRealForMockSubChannel(subchannel).listener;
+    if (listener == null) {
+      throw new IllegalArgumentException("subchannel has not been started");
+    }
+    return listener;
+  }
+
+  @Override
+  public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+    // do nothing, should have been done in the wrapper helpers
+  }
+
+  @Override
+  protected Helper delegate() {
+    throw new UnsupportedOperationException("This helper class is only for use in this test");
+  }
+
+  @Override
+  public Subchannel createSubchannel(CreateSubchannelArgs args) {
+    Subchannel subchannel = getSubchannelMap().get(args.getAddresses());
+    if (subchannel == null) {
+      TestSubchannel delegate = createRealSubchannel(args);
+      subchannel = mock(Subchannel.class, delegatesTo(delegate));
+      getSubchannelMap().put(args.getAddresses(), subchannel);
+      mockToRealSubChannelMap.put(subchannel, delegate);
+      realToMockSubChannelMap.put(delegate, subchannel);
+    }
+
+    return subchannel;
+  }
+
+  protected TestSubchannel createRealSubchannel(CreateSubchannelArgs args) {
+    return new TestSubchannel(args);
+  }
+
+  @Override
+  public void refreshNameResolution() {
+    // no-op
+  }
+
+  public void setChannel(Subchannel subchannel, Channel channel) {
+    getRealForMockSubChannel(subchannel).channel = channel;
+  }
+
+  @Override
+  public SynchronizationContext getSynchronizationContext() {
+    return syncContext;
+  }
+
+  @Override
+  public ScheduledExecutorService getScheduledExecutorService() {
+    return fakeClock.getScheduledExecutorService();
+  }
+
+  @Override
+  public String toString() {
+    return "Test Helper";
+  }
+
+  public static void refreshInvokedAndUpdateBS(InOrder inOrder, ConnectivityState state,
+                                                Helper helper,
+                                               ArgumentCaptor<SubchannelPicker> pickerCaptor) {
+    // Old PF and new PF reverse calling order of updateBlaancingState and refreshNameResolution
+    if (PickFirstLoadBalancerProvider.isEnabledNewPickFirst()) {
+      inOrder.verify(helper).updateBalancingState(eq(state), pickerCaptor.capture());
+    }
+
+    inOrder.verify(helper).refreshNameResolution();
+
+    if (!PickFirstLoadBalancerProvider.isEnabledNewPickFirst()) {
+      inOrder.verify(helper).updateBalancingState(eq(state), pickerCaptor.capture());
+    }
+  }
+
+  public static void verifyNoMoreMeaningfulInteractions(Helper helper) {
+    verify(helper, atLeast(0)).getSynchronizationContext();
+    verify(helper, atLeast(0)).getScheduledExecutorService();
+    verifyNoMoreInteractions(helper);
+  }
+
+  public static void verifyNoMoreMeaningfulInteractions(Helper helper, InOrder inOrder) {
+    inOrder.verify(helper, atLeast(0)).getSynchronizationContext();
+    inOrder.verify(helper, atLeast(0)).getScheduledExecutorService();
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  protected class TestSubchannel extends ForwardingSubchannel {
+    CreateSubchannelArgs args;
+    SubchannelStateListener listener;
+    Channel channel;
+
+    public TestSubchannel(CreateSubchannelArgs args) {
+      this.args = args;
+    }
+
+    @Override
+    protected Subchannel delegate() {
+      throw new UnsupportedOperationException("Only to be used in tests");
+    }
+
+    @Override
+    public List<EquivalentAddressGroup> getAllAddresses() {
+      return args.getAddresses();
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return args.getAttributes();
+    }
+
+    @Override
+    public void requestConnection() {
+      // Ignore, we will manually update state
+    }
+
+    @Override
+    public void updateAddresses(List<EquivalentAddressGroup> addrs) {
+      if (args.getAddresses().equals(addrs)) {
+        return; // no changes so it's a no-op
+      }
+
+      List<EquivalentAddressGroup> oldAddrs = args.getAddresses();
+      Subchannel oldTarget = getSubchannelMap().get(oldAddrs);
+
+      this.args = args.toBuilder().setAddresses(addrs).build();
+      getSubchannelMap().put(addrs, oldTarget);
+      getSubchannelMap().remove(oldAddrs);
+    }
+
+    @Override
+    public void start(SubchannelStateListener listener) {
+      this.listener = checkNotNull(listener, "listener");
+    }
+
+    @Override
+    public void shutdown() {
+      for (EquivalentAddressGroup eag : getAllAddresses()) {
+        getSubchannelMap().remove(Collections.singletonList(eag));
+      }
+    }
+
+    @Override
+    public Channel asChannel() {
+      return channel;
+    }
+
+    @Override
+    public ChannelLogger getChannelLogger() {
+      return mock(ChannelLogger.class);
+    }
+
+    @Override
+    public String toString() {
+      return "Mock Subchannel" + args.toString();
+    }
+  }
+
+  public static final class FakeSocketAddress extends SocketAddress {
+    private static final long serialVersionUID = 0L;
+    final String name;
+
+    FakeSocketAddress(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public String toString() {
+      return "FakeSocketAddress-" + name;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (!(o instanceof FakeSocketAddress)) {
+        return false;
+      }
+      FakeSocketAddress that = (FakeSocketAddress) o;
+      return this.name.equals(that.name);
+    }
+
+    @Override
+    public int hashCode() {
+      return name.hashCode();
+    }
+  }
+}
+
diff --git a/util/src/testFixtures/java/io/grpc/util/GracefulSwitchLoadBalancerAccessor.java b/util/src/testFixtures/java/io/grpc/util/GracefulSwitchLoadBalancerAccessor.java
new file mode 100644
index 00000000000..8f62e66be4a
--- /dev/null
+++ b/util/src/testFixtures/java/io/grpc/util/GracefulSwitchLoadBalancerAccessor.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 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.util;
+
+import io.grpc.LoadBalancerProvider;
+
+/**
+ * Accessors for white-box testing involving GracefulSwitchLoadBalancer.
+ */
+public final class GracefulSwitchLoadBalancerAccessor {
+  private GracefulSwitchLoadBalancerAccessor() {
+    // Do not instantiate
+  }
+
+  public static LoadBalancerProvider getChildProvider(Object config) {
+    return (LoadBalancerProvider) ((GracefulSwitchLoadBalancer.Config) config).childFactory;
+  }
+
+  public static Object getChildConfig(Object config) {
+    return ((GracefulSwitchLoadBalancer.Config) config).childConfig;
+  }
+}
diff --git a/xds/BUILD.bazel b/xds/BUILD.bazel
new file mode 100644
index 00000000000..7f2c5f02338
--- /dev/null
+++ b/xds/BUILD.bazel
@@ -0,0 +1,364 @@
+load("@bazel_jar_jar//:jar_jar.bzl", "jar_jar")
+load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library")
+load("@com_google_protobuf//bazel:proto_library.bzl", "proto_library")
+load("@rules_java//java:defs.bzl", "java_binary", "java_library", "java_test")
+load("@rules_jvm_external//:defs.bzl", "artifact")
+load("//:java_grpc_library.bzl", "INTERNAL_java_grpc_library_for_xds", "java_grpc_library", "java_rpc_toolchain")
+
+# Mirrors the dependencies included in the artifact on Maven Central for usage
+# with maven_install's override_targets. Should only be used as a dep for
+# pre-compiled binaries on Maven Central.
+java_library(
+    name = "xds_maven",
+    visibility = ["//visibility:public"],
+    exports = [
+        ":orca",
+        ":xds",
+    ],
+)
+
+# Ordinary deps for :xds
+java_library(
+    name = "xds_deps_depend",
+    exports = [
+        ":orca",
+        "//:auto_value_annotations",
+        "//alts",
+        "//api",
+        "//auth",
+        "//context",
+        "//core:internal",
+        "//netty",
+        "//services:metrics",
+        "//services:metrics_internal",
+        "//stub",
+        "//util",
+        "@com_google_protobuf//:protobuf_java",
+        "@com_google_protobuf//:protobuf_java_util",
+        "@maven//:com_google_auth_google_auth_library_oauth2_http",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.code.gson:gson"),
+        artifact("com.google.errorprone:error_prone_annotations"),
+        artifact("com.google.guava:guava"),
+        artifact("com.google.re2j:re2j"),
+        artifact("io.netty:netty-buffer"),
+        artifact("io.netty:netty-codec"),
+        artifact("io.netty:netty-common"),
+        artifact("io.netty:netty-handler"),
+        artifact("io.netty:netty-transport"),
+    ],
+    runtime_deps = [
+        "//compiler:java_grpc_library_deps__do_not_reference",
+    ],
+)
+
+java_library(
+    name = "xds_deps_depend_neverlink",
+    neverlink = 1,
+    exports = [":xds_deps_depend"],
+)
+
+# Deps to be combined into the :xds jar itself
+java_library(
+    name = "xds_deps_embed",
+    exports = [
+        ":envoy_java_grpc",
+        ":envoy_java_proto",
+        ":googleapis_rpc_java_proto",
+        ":xds_java_proto",
+    ],
+)
+
+java_binary(
+    name = "xds_notjarjar",
+    srcs = glob(
+        [
+            "src/main/java/**/*.java",
+            "third_party/zero-allocation-hashing/main/java/**/*.java",
+        ],
+        exclude = ["src/main/java/io/grpc/xds/orca/**"],
+    ),
+    main_class = "unused",
+    resources = glob([
+        "src/main/resources/**",
+    ]),
+    deps = [
+        # Do not add additional dependencies here; add them to one of these two deps instead
+        ":xds_deps_depend_neverlink",
+        ":xds_deps_embed",
+    ],
+)
+
+JAR_JAR_RULES = [
+    "zap com.google.protobuf.**",  # Drop codegen dep
+    # Keep in sync with build.gradle's shadowJar
+    "rule com.github.udpa.** io.grpc.xds.shaded.com.github.udpa.@1",
+    "rule com.github.xds.** io.grpc.xds.shaded.com.github.xds.@1",
+    "rule com.google.api.expr.** io.grpc.xds.shaded.com.google.api.expr.@1",
+    "rule com.google.security.** io.grpc.xds.shaded.com.google.security.@1",
+    "rule dev.cel.expr.** io.grpc.xds.shaded.dev.cel.expr.@1",
+    "rule envoy.annotations.** io.grpc.xds.shaded.envoy.annotations.@1",
+    "rule io.envoyproxy.** io.grpc.xds.shaded.io.envoyproxy.@1",
+    "rule udpa.annotations.** io.grpc.xds.shaded.udpa.annotations.@1",
+    "rule xds.annotations.** io.grpc.xds.shaded.xds.annotations.@1",
+]
+
+jar_jar(
+    name = "xds_jarjar",
+    inline_rules = JAR_JAR_RULES,
+    input_jar = ":xds_notjarjar_deploy.jar",
+)
+
+java_library(
+    name = "xds",
+    visibility = ["//visibility:public"],
+    exports = [":xds_jarjar"],
+    runtime_deps = [":xds_deps_depend"],
+)
+
+java_proto_library(
+    name = "googleapis_rpc_java_proto",
+    deps = [
+        "@com_google_googleapis//google/rpc:code_proto",
+        "@com_google_googleapis//google/rpc:status_proto",
+    ],
+)
+
+# Ordinary deps for :orca
+java_library(
+    name = "orca_deps_depend",
+    exports = [
+        ":xds_orca_java_grpc",
+        ":xds_orca_java_proto",
+        "//api",
+        "//context",
+        "//core:internal",
+        "//protobuf",
+        "//services:metrics",
+        "//services:metrics_internal",
+        "//stub",
+        "//util",
+        "@com_google_protobuf//:protobuf_java_util",
+        artifact("com.google.code.findbugs:jsr305"),
+        artifact("com.google.guava:guava"),
+    ],
+)
+
+java_library(
+    name = "orca_deps_depend_neverlink",
+    neverlink = 1,
+    exports = [":orca_deps_depend"],
+)
+
+# Deps to be combined into the :orca jar itself
+java_library(
+    name = "orca_deps_embed",
+    exports = [
+        ":xds_orca_java_grpc",
+        ":xds_orca_java_proto",
+    ],
+)
+
+java_binary(
+    name = "orca_notjarjar",
+    srcs = glob([
+        "src/main/java/io/grpc/xds/orca/*.java",
+    ]),
+    main_class = "unused",
+    visibility = ["//visibility:public"],
+    deps = [
+        # Do not add additional dependencies here; add them to one of these two deps instead
+        ":orca_deps_depend_neverlink",
+        ":orca_deps_embed",
+    ],
+)
+
+jar_jar(
+    name = "orca_jarjar",
+    inline_rules = JAR_JAR_RULES,
+    input_jar = ":orca_notjarjar_deploy.jar",
+)
+
+java_library(
+    name = "orca",
+    visibility = ["//visibility:public"],
+    exports = [":orca_jarjar"],
+    runtime_deps = [":orca_deps_depend"],
+)
+
+java_proto_library(
+    name = "orca_java_proto",
+    deps = [":xds_proto"],
+)
+
+java_grpc_library(
+    name = "orca_java_grpc",
+    srcs = [":xds_proto"],
+    deps = [":orca_java_proto"],
+)
+
+proto_library(
+    name = "cel_spec_proto",
+    srcs = glob(["third_party/cel-spec/src/main/proto/**/*.proto"]),
+    strip_import_prefix = "third_party/cel-spec/src/main/proto/",
+    deps = [
+        "@com_google_protobuf//:duration_proto",
+        "@com_google_protobuf//:empty_proto",
+        "@com_google_protobuf//:struct_proto",
+        "@com_google_protobuf//:timestamp_proto",
+    ],
+)
+
+proto_library(
+    name = "envoy_proto",
+    srcs = glob(["third_party/envoy/src/main/proto/**/*.proto"]),
+    strip_import_prefix = "third_party/envoy/src/main/proto/",
+    deps = [
+        ":googleapis_proto",
+        ":protoc_gen_validate_proto",
+        ":xds_proto",
+        "@com_google_googleapis//google/api:annotations_proto",
+        "@com_google_googleapis//google/rpc:status_proto",
+        "@com_google_protobuf//:any_proto",
+        "@com_google_protobuf//:descriptor_proto",
+        "@com_google_protobuf//:duration_proto",
+        "@com_google_protobuf//:empty_proto",
+        "@com_google_protobuf//:struct_proto",
+        "@com_google_protobuf//:timestamp_proto",
+        "@com_google_protobuf//:wrappers_proto",
+    ],
+)
+
+java_proto_library(
+    name = "envoy_java_proto",
+    deps = [":envoy_proto"],
+)
+
+INTERNAL_java_grpc_library_for_xds(
+    name = "envoy_java_grpc",
+    srcs = [":envoy_proto"],
+    deps = [":envoy_java_proto"],
+)
+
+proto_library(
+    name = "googleapis_proto",
+    srcs = glob(["third_party/googleapis/src/main/proto/**/*.proto"]),
+    strip_import_prefix = "third_party/googleapis/src/main/proto/",
+    deps = [
+        "@com_google_protobuf//:duration_proto",
+        "@com_google_protobuf//:empty_proto",
+        "@com_google_protobuf//:struct_proto",
+        "@com_google_protobuf//:timestamp_proto",
+    ],
+)
+
+proto_library(
+    name = "protoc_gen_validate_proto",
+    srcs = glob(["third_party/protoc-gen-validate/src/main/proto/**/*.proto"]),
+    strip_import_prefix = "third_party/protoc-gen-validate/src/main/proto/",
+    deps = [
+        "@com_google_protobuf//:descriptor_proto",
+        "@com_google_protobuf//:duration_proto",
+        "@com_google_protobuf//:timestamp_proto",
+    ],
+)
+
+proto_library(
+    name = "xds_proto",
+    srcs = glob(
+        ["third_party/xds/src/main/proto/**/*.proto"],
+        exclude = [
+            "third_party/xds/src/main/proto/xds/data/orca/v3/*.proto",
+            "third_party/xds/src/main/proto/xds/service/orca/v3/*.proto",
+        ],
+    ),
+    strip_import_prefix = "third_party/xds/src/main/proto/",
+    deps = [
+        ":cel_spec_proto",
+        ":googleapis_proto",
+        ":protoc_gen_validate_proto",
+        "@com_google_protobuf//:any_proto",
+        "@com_google_protobuf//:descriptor_proto",
+        "@com_google_protobuf//:duration_proto",
+        "@com_google_protobuf//:struct_proto",
+        "@com_google_protobuf//:wrappers_proto",
+    ],
+)
+
+java_proto_library(
+    name = "xds_java_proto",
+    deps = [":xds_proto"],
+)
+
+proto_library(
+    name = "xds_orca_proto",
+    srcs = glob([
+        "third_party/xds/src/main/proto/xds/data/orca/v3/*.proto",
+        "third_party/xds/src/main/proto/xds/service/orca/v3/*.proto",
+    ]),
+    strip_import_prefix = "third_party/xds/src/main/proto/",
+    deps = [
+        ":protoc_gen_validate_proto",
+        "@com_google_protobuf//:duration_proto",
+    ],
+)
+
+java_proto_library(
+    name = "xds_orca_java_proto",
+    deps = [":xds_orca_proto"],
+)
+
+java_grpc_library(
+    name = "xds_orca_java_grpc",
+    srcs = [":xds_orca_proto"],
+    deps = [":xds_orca_java_proto"],
+)
+
+java_rpc_toolchain(
+    name = "java_grpc_library_toolchain",
+    plugin = "//compiler:grpc_java_plugin",
+    runtime = [":java_grpc_library_deps"],
+)
+
+java_library(
+    name = "java_grpc_library_deps",
+    neverlink = 1,
+    exports = ["//compiler:java_grpc_library_deps__do_not_reference"],
+)
+
+java_library(
+    name = "testlib",
+    testonly = 1,
+    srcs = [
+        "src/test/java/io/grpc/xds/ControlPlaneRule.java",
+        "src/test/java/io/grpc/xds/DataPlaneRule.java",
+        "src/test/java/io/grpc/xds/FakeControlPlaneXdsIntegrationTest.java",
+        "src/test/java/io/grpc/xds/MetadataLoadBalancerProvider.java",
+        "src/test/java/io/grpc/xds/XdsTestControlPlaneService.java",
+        "src/test/java/io/grpc/xds/XdsTestLoadReportingService.java",
+    ],
+    deps = [
+        ":envoy_java_grpc",
+        ":envoy_java_proto",
+        ":xds",
+        ":xds_java_proto",
+        "//api",
+        "//core:internal",
+        "//stub",
+        "//testing-proto:simpleservice_java_grpc",
+        "//testing-proto:simpleservice_java_proto",
+        "//util",
+        "@com_google_protobuf//java/core",
+        "@maven//:com_google_code_findbugs_jsr305",
+        "@maven//:com_google_guava_guava",
+        "@maven//:com_google_truth_truth",
+        "@maven//:junit_junit",
+    ],
+)
+
+java_test(
+    name = "FakeControlPlaneXdsIntegrationTest",
+    size = "small",
+    test_class = "io.grpc.xds.FakeControlPlaneXdsIntegrationTest",
+    runtime_deps = [":testlib"],
+)
diff --git a/xds/build.gradle b/xds/build.gradle
new file mode 100644
index 00000000000..8394fe12f6b
--- /dev/null
+++ b/xds/build.gradle
@@ -0,0 +1,250 @@
+import io.grpc.gradle.CheckPackageLeakageTask;
+
+plugins {
+    id "java"
+    id "maven-publish"
+
+    id "com.google.protobuf"
+    id "com.gradleup.shadow"
+    id "ru.vyarus.animalsniffer"
+}
+
+description = "gRPC: XDS plugin"
+
+sourceSets {
+    thirdparty {
+        java {
+            srcDir "${projectDir}/third_party/zero-allocation-hashing/main/java"
+        }
+        proto {
+            srcDir 'third_party/cel-spec/src/main/proto'
+            srcDir 'third_party/envoy/src/main/proto'
+            srcDir 'third_party/googleapis/src/main/proto'
+            srcDir 'third_party/protoc-gen-validate/src/main/proto'
+            srcDir 'third_party/xds/src/main/proto'
+        }
+    }
+    main {
+        output.classesDirs.from(sourceSets.thirdparty.output.classesDirs)
+    }
+    test {
+        java {
+            srcDir "${projectDir}/third_party/zero-allocation-hashing/test/java"
+        }
+    }
+}
+
+configurations {
+    pomDeps {
+        extendsFrom configurations.thirdpartyRuntimeClasspath, configurations.shadow
+    }
+}
+
+dependencies {
+    thirdpartyImplementation project(':grpc-protobuf'),
+            project(':grpc-stub')
+    compileOnly sourceSets.thirdparty.output
+    testCompileOnly sourceSets.thirdparty.output
+    implementation project(':grpc-stub'),
+            project(':grpc-core'),
+            project(':grpc-util'),
+            project(':grpc-services'),
+            project(':grpc-auth'),
+            project(path: ':grpc-alts', configuration: 'shadow'),
+            libraries.guava,
+            libraries.gson,
+            libraries.re2j,
+            libraries.auto.value.annotations,
+            libraries.protobuf.java.util
+    def nettyDependency = implementation project(':grpc-netty')
+
+    testImplementation project(':grpc-api')
+    testImplementation project(':grpc-rls')
+    testImplementation project(':grpc-inprocess')
+    testImplementation testFixtures(project(':grpc-core')),
+            testFixtures(project(':grpc-api')),
+            testFixtures(project(':grpc-util'))
+
+    annotationProcessor libraries.auto.value
+    // At runtime use the epoll included in grpc-netty-shaded
+    compileOnly libraries.netty.transport.epoll
+
+    testImplementation project(':grpc-testing'),
+            project(':grpc-testing-proto')
+    testImplementation (libraries.netty.transport.epoll) {
+        artifact {
+            classifier = "linux-x86_64"
+        }
+    }
+    testImplementation libraries.guava.testlib
+
+    shadow configurations.implementation.getDependencies().minus([nettyDependency])
+    shadow project(path: ':grpc-netty-shaded', configuration: 'shadow')
+
+    signature (libraries.signature.java) {
+        artifact {
+            extension = "signature"
+        }
+    }
+    testRuntimeOnly libraries.netty.tcnative,
+            libraries.netty.tcnative.classes
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "linux-x86_64"
+        }
+    }
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "linux-aarch_64"
+        }
+    }
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "osx-x86_64"
+        }
+    }
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "osx-aarch_64"
+        }
+    }
+    testRuntimeOnly (libraries.netty.tcnative) {
+        artifact {
+            classifier = "windows-x86_64"
+        }
+    }
+}
+
+configureProtoCompilation()
+
+tasks.named("compileThirdpartyJava").configure {
+    options.errorprone.enabled = false
+    options.compilerArgs += [
+        // valueOf(int) in RoutingPriority has been deprecated
+        "-Xlint:-deprecation",
+    ]
+}
+
+tasks.named("checkstyleThirdparty").configure {
+    enabled = false
+}
+
+tasks.named("compileJava").configure {
+    it.options.compilerArgs += [
+        // only has AutoValue annotation processor
+        "-Xlint:-processing",
+    ]
+    appendToProperty(
+            it.options.errorprone.excludedPaths,
+            ".*/build/generated/sources/annotationProcessor/java/.*",
+            "|")
+    // remove after upgrade error-prone
+    appendToProperty(
+            it.options.errorprone.excludedPaths,
+            ".*/build/tmp/compileJava/compileTransaction/annotation-output/io/grpc/xds/.*",
+            "|")
+}
+
+tasks.named("jar").configure {
+    archiveClassifier = 'original'
+    manifest {
+        attributes('Automatic-Module-Name': 'io.grpc.xds')
+    }
+}
+
+tasks.named("sourcesJar").configure {
+    from sourceSets.thirdparty.allSource
+}
+
+tasks.named("javadoc").configure {
+    // Exclusions here should generally also be relocated
+    exclude 'com/github/udpa/**'
+    exclude 'com/github/xds/**'
+    exclude 'com/google/security/**'
+    exclude 'io/envoyproxy/**'
+    // Need to clean up the class structure to reduce how much is exposed
+    exclude 'io/grpc/xds/client/**'
+    exclude 'io/grpc/xds/*LoadBalancer*'
+    exclude 'io/grpc/xds/Bootstrapper.java'
+    exclude 'io/grpc/xds/Envoy*'
+    exclude 'io/grpc/xds/FilterChainMatchingProtocolNegotiators.java'
+    exclude 'io/grpc/xds/TlsContextManager.java'
+    exclude 'io/grpc/xds/XdsAttributes.java'
+    exclude 'io/grpc/xds/XdsCredentialsProvider.java'
+    exclude 'io/grpc/xds/XdsInitializationException.java'
+    exclude 'io/grpc/xds/XdsNameResolverProvider.java'
+    exclude 'io/grpc/xds/internal/**'
+    exclude 'io/grpc/xds/Internal*'
+}
+
+def prefixName = 'io.grpc.xds'
+tasks.named("shadowJar").configure {
+    archiveClassifier = null
+    dependencies {
+        include(project(':grpc-xds'))
+    }
+    // Relocated packages commonly need exclusions in jacocoTestReport and javadoc
+    // Keep in sync with BUILD.bazel's JAR_JAR_RULES
+    relocate 'com.github.udpa', "${prefixName}.shaded.com.github.udpa"
+    relocate 'com.github.xds', "${prefixName}.shaded.com.github.xds"
+    relocate 'com.google.api.expr', "${prefixName}.shaded.com.google.api.expr"
+    relocate 'com.google.security', "${prefixName}.shaded.com.google.security"
+    // TODO: missing java_package option in .proto
+    relocate 'dev.cel.expr', "${prefixName}.shaded.dev.cel.expr"
+    relocate 'envoy.annotations', "${prefixName}.shaded.envoy.annotations"
+    relocate 'io.envoyproxy', "${prefixName}.shaded.io.envoyproxy"
+    relocate 'io.grpc.netty', 'io.grpc.netty.shaded.io.grpc.netty'
+    relocate 'io.netty', 'io.grpc.netty.shaded.io.netty'
+    // TODO: missing java_package option in .proto
+    relocate 'udpa.annotations', "${prefixName}.shaded.udpa.annotations"
+    relocate 'xds.annotations', "${prefixName}.shaded.xds.annotations"
+    exclude "**/*.proto"
+}
+
+def checkPackageLeakage = tasks.register("checkPackageLeakage", CheckPackageLeakageTask) {
+    files.from tasks.named('shadowJar')
+    prefix = prefixName
+}
+
+tasks.named("test").configure {
+    dependsOn checkPackageLeakage
+}
+
+tasks.named("jacocoTestReport").configure {
+    classDirectories.from = sourceSets.main.output.collect {
+        fileTree(dir: it,
+        exclude: [ // Exclusions here should generally also be relocated
+                '**/com/github/udpa/**',
+                '**/com/github/xds/**',
+                '**/com/google/api/expr/**',
+                '**/com/google/security/**',
+                '**/cel/expr/**',
+                '**/envoy/annotations/**',
+                '**/io/envoyproxy/**',
+                '**/udpa/annotations/**',
+                '**/xds/annotations/**',
+        ])
+    }
+}
+
+publishing {
+    publications {
+        maven(MavenPublication) {
+            // We want this to throw an exception if it isn't working
+            def originalJar = artifacts.find { dep -> dep.classifier == 'original'}
+            artifacts.remove(originalJar)
+
+            pom.withXml {
+                def dependenciesNode = new Node(null, 'dependencies')
+                project.configurations.pomDeps.allDependencies.each { dep ->
+                    def dependencyNode = dependenciesNode.appendNode('dependency')
+                    dependencyNode.appendNode('groupId', dep.group)
+                    dependencyNode.appendNode('artifactId', dep.name)
+                    dependencyNode.appendNode('version', dep.version)
+                    dependencyNode.appendNode('scope', 'compile')
+                }
+                asNode().dependencies[0].replaceNode(dependenciesNode)
+            }
+        }
+    }
+}
diff --git a/xds/src/generated/thirdparty/grpc/com/github/xds/service/orca/v3/OpenRcaServiceGrpc.java b/xds/src/generated/thirdparty/grpc/com/github/xds/service/orca/v3/OpenRcaServiceGrpc.java
new file mode 100644
index 00000000000..e0e28ad4072
--- /dev/null
+++ b/xds/src/generated/thirdparty/grpc/com/github/xds/service/orca/v3/OpenRcaServiceGrpc.java
@@ -0,0 +1,394 @@
+package com.github.xds.service.orca.v3;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * Out-of-band (OOB) load reporting service for the additional load reporting
+ * agent that does not sit in the request path. Reports are periodically sampled
+ * with sufficient frequency to provide temporal association with requests.
+ * OOB reporting compensates the limitation of in-band reporting in revealing
+ * costs for backends that do not provide a steady stream of telemetry such as
+ * long running stream operations and zero QPS services. This is a server
+ * streaming service, client needs to terminate current RPC and initiate
+ * a new call to change backend reporting frequency.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class OpenRcaServiceGrpc {
+
+  private OpenRcaServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "xds.service.orca.v3.OpenRcaService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<com.github.xds.service.orca.v3.OrcaLoadReportRequest,
+      com.github.xds.data.orca.v3.OrcaLoadReport> getStreamCoreMetricsMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamCoreMetrics",
+      requestType = com.github.xds.service.orca.v3.OrcaLoadReportRequest.class,
+      responseType = com.github.xds.data.orca.v3.OrcaLoadReport.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+  public static io.grpc.MethodDescriptor<com.github.xds.service.orca.v3.OrcaLoadReportRequest,
+      com.github.xds.data.orca.v3.OrcaLoadReport> getStreamCoreMetricsMethod() {
+    io.grpc.MethodDescriptor<com.github.xds.service.orca.v3.OrcaLoadReportRequest, com.github.xds.data.orca.v3.OrcaLoadReport> getStreamCoreMetricsMethod;
+    if ((getStreamCoreMetricsMethod = OpenRcaServiceGrpc.getStreamCoreMetricsMethod) == null) {
+      synchronized (OpenRcaServiceGrpc.class) {
+        if ((getStreamCoreMetricsMethod = OpenRcaServiceGrpc.getStreamCoreMetricsMethod) == null) {
+          OpenRcaServiceGrpc.getStreamCoreMetricsMethod = getStreamCoreMetricsMethod =
+              io.grpc.MethodDescriptor.<com.github.xds.service.orca.v3.OrcaLoadReportRequest, com.github.xds.data.orca.v3.OrcaLoadReport>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamCoreMetrics"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  com.github.xds.service.orca.v3.OrcaLoadReportRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  com.github.xds.data.orca.v3.OrcaLoadReport.getDefaultInstance()))
+              .setSchemaDescriptor(new OpenRcaServiceMethodDescriptorSupplier("StreamCoreMetrics"))
+              .build();
+        }
+      }
+    }
+    return getStreamCoreMetricsMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static OpenRcaServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<OpenRcaServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<OpenRcaServiceStub>() {
+        @java.lang.Override
+        public OpenRcaServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new OpenRcaServiceStub(channel, callOptions);
+        }
+      };
+    return OpenRcaServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static OpenRcaServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<OpenRcaServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<OpenRcaServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public OpenRcaServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new OpenRcaServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return OpenRcaServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static OpenRcaServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<OpenRcaServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<OpenRcaServiceBlockingStub>() {
+        @java.lang.Override
+        public OpenRcaServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new OpenRcaServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return OpenRcaServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static OpenRcaServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<OpenRcaServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<OpenRcaServiceFutureStub>() {
+        @java.lang.Override
+        public OpenRcaServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new OpenRcaServiceFutureStub(channel, callOptions);
+        }
+      };
+    return OpenRcaServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * Out-of-band (OOB) load reporting service for the additional load reporting
+   * agent that does not sit in the request path. Reports are periodically sampled
+   * with sufficient frequency to provide temporal association with requests.
+   * OOB reporting compensates the limitation of in-band reporting in revealing
+   * costs for backends that do not provide a steady stream of telemetry such as
+   * long running stream operations and zero QPS services. This is a server
+   * streaming service, client needs to terminate current RPC and initiate
+   * a new call to change backend reporting frequency.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     */
+    default void streamCoreMetrics(com.github.xds.service.orca.v3.OrcaLoadReportRequest request,
+        io.grpc.stub.StreamObserver<com.github.xds.data.orca.v3.OrcaLoadReport> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getStreamCoreMetricsMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service OpenRcaService.
+   * <pre>
+   * Out-of-band (OOB) load reporting service for the additional load reporting
+   * agent that does not sit in the request path. Reports are periodically sampled
+   * with sufficient frequency to provide temporal association with requests.
+   * OOB reporting compensates the limitation of in-band reporting in revealing
+   * costs for backends that do not provide a steady stream of telemetry such as
+   * long running stream operations and zero QPS services. This is a server
+   * streaming service, client needs to terminate current RPC and initiate
+   * a new call to change backend reporting frequency.
+   * </pre>
+   */
+  public static abstract class OpenRcaServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return OpenRcaServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service OpenRcaService.
+   * <pre>
+   * Out-of-band (OOB) load reporting service for the additional load reporting
+   * agent that does not sit in the request path. Reports are periodically sampled
+   * with sufficient frequency to provide temporal association with requests.
+   * OOB reporting compensates the limitation of in-band reporting in revealing
+   * costs for backends that do not provide a steady stream of telemetry such as
+   * long running stream operations and zero QPS services. This is a server
+   * streaming service, client needs to terminate current RPC and initiate
+   * a new call to change backend reporting frequency.
+   * </pre>
+   */
+  public static final class OpenRcaServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<OpenRcaServiceStub> {
+    private OpenRcaServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected OpenRcaServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new OpenRcaServiceStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public void streamCoreMetrics(com.github.xds.service.orca.v3.OrcaLoadReportRequest request,
+        io.grpc.stub.StreamObserver<com.github.xds.data.orca.v3.OrcaLoadReport> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncServerStreamingCall(
+          getChannel().newCall(getStreamCoreMetricsMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service OpenRcaService.
+   * <pre>
+   * Out-of-band (OOB) load reporting service for the additional load reporting
+   * agent that does not sit in the request path. Reports are periodically sampled
+   * with sufficient frequency to provide temporal association with requests.
+   * OOB reporting compensates the limitation of in-band reporting in revealing
+   * costs for backends that do not provide a steady stream of telemetry such as
+   * long running stream operations and zero QPS services. This is a server
+   * streaming service, client needs to terminate current RPC and initiate
+   * a new call to change backend reporting frequency.
+   * </pre>
+   */
+  public static final class OpenRcaServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<OpenRcaServiceBlockingV2Stub> {
+    private OpenRcaServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected OpenRcaServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new OpenRcaServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<?, com.github.xds.data.orca.v3.OrcaLoadReport>
+        streamCoreMetrics(com.github.xds.service.orca.v3.OrcaLoadReportRequest request) {
+      return io.grpc.stub.ClientCalls.blockingV2ServerStreamingCall(
+          getChannel(), getStreamCoreMetricsMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service OpenRcaService.
+   * <pre>
+   * Out-of-band (OOB) load reporting service for the additional load reporting
+   * agent that does not sit in the request path. Reports are periodically sampled
+   * with sufficient frequency to provide temporal association with requests.
+   * OOB reporting compensates the limitation of in-band reporting in revealing
+   * costs for backends that do not provide a steady stream of telemetry such as
+   * long running stream operations and zero QPS services. This is a server
+   * streaming service, client needs to terminate current RPC and initiate
+   * a new call to change backend reporting frequency.
+   * </pre>
+   */
+  public static final class OpenRcaServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<OpenRcaServiceBlockingStub> {
+    private OpenRcaServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected OpenRcaServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new OpenRcaServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public java.util.Iterator<com.github.xds.data.orca.v3.OrcaLoadReport> streamCoreMetrics(
+        com.github.xds.service.orca.v3.OrcaLoadReportRequest request) {
+      return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
+          getChannel(), getStreamCoreMetricsMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service OpenRcaService.
+   * <pre>
+   * Out-of-band (OOB) load reporting service for the additional load reporting
+   * agent that does not sit in the request path. Reports are periodically sampled
+   * with sufficient frequency to provide temporal association with requests.
+   * OOB reporting compensates the limitation of in-band reporting in revealing
+   * costs for backends that do not provide a steady stream of telemetry such as
+   * long running stream operations and zero QPS services. This is a server
+   * streaming service, client needs to terminate current RPC and initiate
+   * a new call to change backend reporting frequency.
+   * </pre>
+   */
+  public static final class OpenRcaServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<OpenRcaServiceFutureStub> {
+    private OpenRcaServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected OpenRcaServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new OpenRcaServiceFutureStub(channel, callOptions);
+    }
+  }
+
+  private static final int METHODID_STREAM_CORE_METRICS = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_STREAM_CORE_METRICS:
+          serviceImpl.streamCoreMetrics((com.github.xds.service.orca.v3.OrcaLoadReportRequest) request,
+              (io.grpc.stub.StreamObserver<com.github.xds.data.orca.v3.OrcaLoadReport>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getStreamCoreMetricsMethod(),
+          io.grpc.stub.ServerCalls.asyncServerStreamingCall(
+            new MethodHandlers<
+              com.github.xds.service.orca.v3.OrcaLoadReportRequest,
+              com.github.xds.data.orca.v3.OrcaLoadReport>(
+                service, METHODID_STREAM_CORE_METRICS)))
+        .build();
+  }
+
+  private static abstract class OpenRcaServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    OpenRcaServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return com.github.xds.service.orca.v3.OrcaProto.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("OpenRcaService");
+    }
+  }
+
+  private static final class OpenRcaServiceFileDescriptorSupplier
+      extends OpenRcaServiceBaseDescriptorSupplier {
+    OpenRcaServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class OpenRcaServiceMethodDescriptorSupplier
+      extends OpenRcaServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    OpenRcaServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (OpenRcaServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new OpenRcaServiceFileDescriptorSupplier())
+              .addMethod(getStreamCoreMetricsMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/auth/v3/AuthorizationGrpc.java b/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/auth/v3/AuthorizationGrpc.java
new file mode 100644
index 00000000000..df9b7a3514b
--- /dev/null
+++ b/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/auth/v3/AuthorizationGrpc.java
@@ -0,0 +1,377 @@
+package io.envoyproxy.envoy.service.auth.v3;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * A generic interface for performing authorization check on incoming
+ * requests to a networked service.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class AuthorizationGrpc {
+
+  private AuthorizationGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "envoy.service.auth.v3.Authorization";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.auth.v3.CheckRequest,
+      io.envoyproxy.envoy.service.auth.v3.CheckResponse> getCheckMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "Check",
+      requestType = io.envoyproxy.envoy.service.auth.v3.CheckRequest.class,
+      responseType = io.envoyproxy.envoy.service.auth.v3.CheckResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.auth.v3.CheckRequest,
+      io.envoyproxy.envoy.service.auth.v3.CheckResponse> getCheckMethod() {
+    io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.auth.v3.CheckRequest, io.envoyproxy.envoy.service.auth.v3.CheckResponse> getCheckMethod;
+    if ((getCheckMethod = AuthorizationGrpc.getCheckMethod) == null) {
+      synchronized (AuthorizationGrpc.class) {
+        if ((getCheckMethod = AuthorizationGrpc.getCheckMethod) == null) {
+          AuthorizationGrpc.getCheckMethod = getCheckMethod =
+              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.service.auth.v3.CheckRequest, io.envoyproxy.envoy.service.auth.v3.CheckResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Check"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.auth.v3.CheckRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.auth.v3.CheckResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new AuthorizationMethodDescriptorSupplier("Check"))
+              .build();
+        }
+      }
+    }
+    return getCheckMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static AuthorizationStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<AuthorizationStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AuthorizationStub>() {
+        @java.lang.Override
+        public AuthorizationStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AuthorizationStub(channel, callOptions);
+        }
+      };
+    return AuthorizationStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static AuthorizationBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<AuthorizationBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AuthorizationBlockingV2Stub>() {
+        @java.lang.Override
+        public AuthorizationBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AuthorizationBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return AuthorizationBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static AuthorizationBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<AuthorizationBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AuthorizationBlockingStub>() {
+        @java.lang.Override
+        public AuthorizationBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AuthorizationBlockingStub(channel, callOptions);
+        }
+      };
+    return AuthorizationBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static AuthorizationFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<AuthorizationFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AuthorizationFutureStub>() {
+        @java.lang.Override
+        public AuthorizationFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AuthorizationFutureStub(channel, callOptions);
+        }
+      };
+    return AuthorizationFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * A generic interface for performing authorization check on incoming
+   * requests to a networked service.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Performs authorization check based on the attributes associated with the
+     * incoming request, and returns status `OK` or not `OK`.
+     * </pre>
+     */
+    default void check(io.envoyproxy.envoy.service.auth.v3.CheckRequest request,
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.auth.v3.CheckResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCheckMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service Authorization.
+   * <pre>
+   * A generic interface for performing authorization check on incoming
+   * requests to a networked service.
+   * </pre>
+   */
+  public static abstract class AuthorizationImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return AuthorizationGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service Authorization.
+   * <pre>
+   * A generic interface for performing authorization check on incoming
+   * requests to a networked service.
+   * </pre>
+   */
+  public static final class AuthorizationStub
+      extends io.grpc.stub.AbstractAsyncStub<AuthorizationStub> {
+    private AuthorizationStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected AuthorizationStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new AuthorizationStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Performs authorization check based on the attributes associated with the
+     * incoming request, and returns status `OK` or not `OK`.
+     * </pre>
+     */
+    public void check(io.envoyproxy.envoy.service.auth.v3.CheckRequest request,
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.auth.v3.CheckResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getCheckMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service Authorization.
+   * <pre>
+   * A generic interface for performing authorization check on incoming
+   * requests to a networked service.
+   * </pre>
+   */
+  public static final class AuthorizationBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<AuthorizationBlockingV2Stub> {
+    private AuthorizationBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected AuthorizationBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new AuthorizationBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Performs authorization check based on the attributes associated with the
+     * incoming request, and returns status `OK` or not `OK`.
+     * </pre>
+     */
+    public io.envoyproxy.envoy.service.auth.v3.CheckResponse check(io.envoyproxy.envoy.service.auth.v3.CheckRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getCheckMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service Authorization.
+   * <pre>
+   * A generic interface for performing authorization check on incoming
+   * requests to a networked service.
+   * </pre>
+   */
+  public static final class AuthorizationBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<AuthorizationBlockingStub> {
+    private AuthorizationBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected AuthorizationBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new AuthorizationBlockingStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Performs authorization check based on the attributes associated with the
+     * incoming request, and returns status `OK` or not `OK`.
+     * </pre>
+     */
+    public io.envoyproxy.envoy.service.auth.v3.CheckResponse check(io.envoyproxy.envoy.service.auth.v3.CheckRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getCheckMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service Authorization.
+   * <pre>
+   * A generic interface for performing authorization check on incoming
+   * requests to a networked service.
+   * </pre>
+   */
+  public static final class AuthorizationFutureStub
+      extends io.grpc.stub.AbstractFutureStub<AuthorizationFutureStub> {
+    private AuthorizationFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected AuthorizationFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new AuthorizationFutureStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Performs authorization check based on the attributes associated with the
+     * incoming request, and returns status `OK` or not `OK`.
+     * </pre>
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.envoyproxy.envoy.service.auth.v3.CheckResponse> check(
+        io.envoyproxy.envoy.service.auth.v3.CheckRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getCheckMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_CHECK = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_CHECK:
+          serviceImpl.check((io.envoyproxy.envoy.service.auth.v3.CheckRequest) request,
+              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.auth.v3.CheckResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getCheckMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.envoyproxy.envoy.service.auth.v3.CheckRequest,
+              io.envoyproxy.envoy.service.auth.v3.CheckResponse>(
+                service, METHODID_CHECK)))
+        .build();
+  }
+
+  private static abstract class AuthorizationBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    AuthorizationBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.envoyproxy.envoy.service.auth.v3.ExternalAuthProto.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("Authorization");
+    }
+  }
+
+  private static final class AuthorizationFileDescriptorSupplier
+      extends AuthorizationBaseDescriptorSupplier {
+    AuthorizationFileDescriptorSupplier() {}
+  }
+
+  private static final class AuthorizationMethodDescriptorSupplier
+      extends AuthorizationBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    AuthorizationMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (AuthorizationGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new AuthorizationFileDescriptorSupplier())
+              .addMethod(getCheckMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/discovery/v3/AggregatedDiscoveryServiceGrpc.java b/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/discovery/v3/AggregatedDiscoveryServiceGrpc.java
new file mode 100644
index 00000000000..94b2fd86b96
--- /dev/null
+++ b/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/discovery/v3/AggregatedDiscoveryServiceGrpc.java
@@ -0,0 +1,447 @@
+package io.envoyproxy.envoy.service.discovery.v3;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * See https://github.com/envoyproxy/envoy-api#apis for a description of the role of
+ * ADS and how it is intended to be used by a management server. ADS requests
+ * have the same structure as their singleton xDS counterparts, but can
+ * multiplex many resource types on a single stream. The type_url in the
+ * DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+ * the multiplexed singleton APIs at the Envoy instance and management server.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class AggregatedDiscoveryServiceGrpc {
+
+  private AggregatedDiscoveryServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "envoy.service.discovery.v3.AggregatedDiscoveryService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest,
+      io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse> getStreamAggregatedResourcesMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamAggregatedResources",
+      requestType = io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest.class,
+      responseType = io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest,
+      io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse> getStreamAggregatedResourcesMethod() {
+    io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest, io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse> getStreamAggregatedResourcesMethod;
+    if ((getStreamAggregatedResourcesMethod = AggregatedDiscoveryServiceGrpc.getStreamAggregatedResourcesMethod) == null) {
+      synchronized (AggregatedDiscoveryServiceGrpc.class) {
+        if ((getStreamAggregatedResourcesMethod = AggregatedDiscoveryServiceGrpc.getStreamAggregatedResourcesMethod) == null) {
+          AggregatedDiscoveryServiceGrpc.getStreamAggregatedResourcesMethod = getStreamAggregatedResourcesMethod =
+              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest, io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamAggregatedResources"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new AggregatedDiscoveryServiceMethodDescriptorSupplier("StreamAggregatedResources"))
+              .build();
+        }
+      }
+    }
+    return getStreamAggregatedResourcesMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest,
+      io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse> getDeltaAggregatedResourcesMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "DeltaAggregatedResources",
+      requestType = io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest.class,
+      responseType = io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest,
+      io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse> getDeltaAggregatedResourcesMethod() {
+    io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest, io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse> getDeltaAggregatedResourcesMethod;
+    if ((getDeltaAggregatedResourcesMethod = AggregatedDiscoveryServiceGrpc.getDeltaAggregatedResourcesMethod) == null) {
+      synchronized (AggregatedDiscoveryServiceGrpc.class) {
+        if ((getDeltaAggregatedResourcesMethod = AggregatedDiscoveryServiceGrpc.getDeltaAggregatedResourcesMethod) == null) {
+          AggregatedDiscoveryServiceGrpc.getDeltaAggregatedResourcesMethod = getDeltaAggregatedResourcesMethod =
+              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest, io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeltaAggregatedResources"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new AggregatedDiscoveryServiceMethodDescriptorSupplier("DeltaAggregatedResources"))
+              .build();
+        }
+      }
+    }
+    return getDeltaAggregatedResourcesMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static AggregatedDiscoveryServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<AggregatedDiscoveryServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AggregatedDiscoveryServiceStub>() {
+        @java.lang.Override
+        public AggregatedDiscoveryServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AggregatedDiscoveryServiceStub(channel, callOptions);
+        }
+      };
+    return AggregatedDiscoveryServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static AggregatedDiscoveryServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<AggregatedDiscoveryServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AggregatedDiscoveryServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public AggregatedDiscoveryServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AggregatedDiscoveryServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return AggregatedDiscoveryServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static AggregatedDiscoveryServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<AggregatedDiscoveryServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AggregatedDiscoveryServiceBlockingStub>() {
+        @java.lang.Override
+        public AggregatedDiscoveryServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AggregatedDiscoveryServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return AggregatedDiscoveryServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static AggregatedDiscoveryServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<AggregatedDiscoveryServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<AggregatedDiscoveryServiceFutureStub>() {
+        @java.lang.Override
+        public AggregatedDiscoveryServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new AggregatedDiscoveryServiceFutureStub(channel, callOptions);
+        }
+      };
+    return AggregatedDiscoveryServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * See https://github.com/envoyproxy/envoy-api#apis for a description of the role of
+   * ADS and how it is intended to be used by a management server. ADS requests
+   * have the same structure as their singleton xDS counterparts, but can
+   * multiplex many resource types on a single stream. The type_url in the
+   * DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+   * the multiplexed singleton APIs at the Envoy instance and management server.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * This is a gRPC-only API.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest> streamAggregatedResources(
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamAggregatedResourcesMethod(), responseObserver);
+    }
+
+    /**
+     */
+    default io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest> deltaAggregatedResources(
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getDeltaAggregatedResourcesMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service AggregatedDiscoveryService.
+   * <pre>
+   * See https://github.com/envoyproxy/envoy-api#apis for a description of the role of
+   * ADS and how it is intended to be used by a management server. ADS requests
+   * have the same structure as their singleton xDS counterparts, but can
+   * multiplex many resource types on a single stream. The type_url in the
+   * DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+   * the multiplexed singleton APIs at the Envoy instance and management server.
+   * </pre>
+   */
+  public static abstract class AggregatedDiscoveryServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return AggregatedDiscoveryServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service AggregatedDiscoveryService.
+   * <pre>
+   * See https://github.com/envoyproxy/envoy-api#apis for a description of the role of
+   * ADS and how it is intended to be used by a management server. ADS requests
+   * have the same structure as their singleton xDS counterparts, but can
+   * multiplex many resource types on a single stream. The type_url in the
+   * DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+   * the multiplexed singleton APIs at the Envoy instance and management server.
+   * </pre>
+   */
+  public static final class AggregatedDiscoveryServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<AggregatedDiscoveryServiceStub> {
+    private AggregatedDiscoveryServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected AggregatedDiscoveryServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new AggregatedDiscoveryServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * This is a gRPC-only API.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest> streamAggregatedResources(
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getStreamAggregatedResourcesMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     */
+    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest> deltaAggregatedResources(
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getDeltaAggregatedResourcesMethod(), getCallOptions()), responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service AggregatedDiscoveryService.
+   * <pre>
+   * See https://github.com/envoyproxy/envoy-api#apis for a description of the role of
+   * ADS and how it is intended to be used by a management server. ADS requests
+   * have the same structure as their singleton xDS counterparts, but can
+   * multiplex many resource types on a single stream. The type_url in the
+   * DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+   * the multiplexed singleton APIs at the Envoy instance and management server.
+   * </pre>
+   */
+  public static final class AggregatedDiscoveryServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<AggregatedDiscoveryServiceBlockingV2Stub> {
+    private AggregatedDiscoveryServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected AggregatedDiscoveryServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new AggregatedDiscoveryServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * This is a gRPC-only API.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest, io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse>
+        streamAggregatedResources() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getStreamAggregatedResourcesMethod(), getCallOptions());
+    }
+
+    /**
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest, io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse>
+        deltaAggregatedResources() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getDeltaAggregatedResourcesMethod(), getCallOptions());
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service AggregatedDiscoveryService.
+   * <pre>
+   * See https://github.com/envoyproxy/envoy-api#apis for a description of the role of
+   * ADS and how it is intended to be used by a management server. ADS requests
+   * have the same structure as their singleton xDS counterparts, but can
+   * multiplex many resource types on a single stream. The type_url in the
+   * DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+   * the multiplexed singleton APIs at the Envoy instance and management server.
+   * </pre>
+   */
+  public static final class AggregatedDiscoveryServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<AggregatedDiscoveryServiceBlockingStub> {
+    private AggregatedDiscoveryServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected AggregatedDiscoveryServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new AggregatedDiscoveryServiceBlockingStub(channel, callOptions);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service AggregatedDiscoveryService.
+   * <pre>
+   * See https://github.com/envoyproxy/envoy-api#apis for a description of the role of
+   * ADS and how it is intended to be used by a management server. ADS requests
+   * have the same structure as their singleton xDS counterparts, but can
+   * multiplex many resource types on a single stream. The type_url in the
+   * DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+   * the multiplexed singleton APIs at the Envoy instance and management server.
+   * </pre>
+   */
+  public static final class AggregatedDiscoveryServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<AggregatedDiscoveryServiceFutureStub> {
+    private AggregatedDiscoveryServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected AggregatedDiscoveryServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new AggregatedDiscoveryServiceFutureStub(channel, callOptions);
+    }
+  }
+
+  private static final int METHODID_STREAM_AGGREGATED_RESOURCES = 0;
+  private static final int METHODID_DELTA_AGGREGATED_RESOURCES = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_STREAM_AGGREGATED_RESOURCES:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamAggregatedResources(
+              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse>) responseObserver);
+        case METHODID_DELTA_AGGREGATED_RESOURCES:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.deltaAggregatedResources(
+              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse>) responseObserver);
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getStreamAggregatedResourcesMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest,
+              io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse>(
+                service, METHODID_STREAM_AGGREGATED_RESOURCES)))
+        .addMethod(
+          getDeltaAggregatedResourcesMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryRequest,
+              io.envoyproxy.envoy.service.discovery.v3.DeltaDiscoveryResponse>(
+                service, METHODID_DELTA_AGGREGATED_RESOURCES)))
+        .build();
+  }
+
+  private static abstract class AggregatedDiscoveryServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    AggregatedDiscoveryServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.envoyproxy.envoy.service.discovery.v3.AdsProto.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("AggregatedDiscoveryService");
+    }
+  }
+
+  private static final class AggregatedDiscoveryServiceFileDescriptorSupplier
+      extends AggregatedDiscoveryServiceBaseDescriptorSupplier {
+    AggregatedDiscoveryServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class AggregatedDiscoveryServiceMethodDescriptorSupplier
+      extends AggregatedDiscoveryServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    AggregatedDiscoveryServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (AggregatedDiscoveryServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new AggregatedDiscoveryServiceFileDescriptorSupplier())
+              .addMethod(getStreamAggregatedResourcesMethod())
+              .addMethod(getDeltaAggregatedResourcesMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/load_stats/v3/LoadReportingServiceGrpc.java b/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/load_stats/v3/LoadReportingServiceGrpc.java
new file mode 100644
index 00000000000..4f12405be87
--- /dev/null
+++ b/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/load_stats/v3/LoadReportingServiceGrpc.java
@@ -0,0 +1,402 @@
+package io.envoyproxy.envoy.service.load_stats.v3;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class LoadReportingServiceGrpc {
+
+  private LoadReportingServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "envoy.service.load_stats.v3.LoadReportingService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest,
+      io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse> getStreamLoadStatsMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamLoadStats",
+      requestType = io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest.class,
+      responseType = io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest,
+      io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse> getStreamLoadStatsMethod() {
+    io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest, io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse> getStreamLoadStatsMethod;
+    if ((getStreamLoadStatsMethod = LoadReportingServiceGrpc.getStreamLoadStatsMethod) == null) {
+      synchronized (LoadReportingServiceGrpc.class) {
+        if ((getStreamLoadStatsMethod = LoadReportingServiceGrpc.getStreamLoadStatsMethod) == null) {
+          LoadReportingServiceGrpc.getStreamLoadStatsMethod = getStreamLoadStatsMethod =
+              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest, io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamLoadStats"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new LoadReportingServiceMethodDescriptorSupplier("StreamLoadStats"))
+              .build();
+        }
+      }
+    }
+    return getStreamLoadStatsMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static LoadReportingServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadReportingServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadReportingServiceStub>() {
+        @java.lang.Override
+        public LoadReportingServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadReportingServiceStub(channel, callOptions);
+        }
+      };
+    return LoadReportingServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static LoadReportingServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadReportingServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadReportingServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public LoadReportingServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadReportingServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return LoadReportingServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static LoadReportingServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadReportingServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadReportingServiceBlockingStub>() {
+        @java.lang.Override
+        public LoadReportingServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadReportingServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return LoadReportingServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static LoadReportingServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<LoadReportingServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<LoadReportingServiceFutureStub>() {
+        @java.lang.Override
+        public LoadReportingServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new LoadReportingServiceFutureStub(channel, callOptions);
+        }
+      };
+    return LoadReportingServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Advanced API to allow for multi-dimensional load balancing by remote
+     * server. For receiving LB assignments, the steps are:
+     * 1, The management server is configured with per cluster/zone/load metric
+     *    capacity configuration. The capacity configuration definition is
+     *    outside of the scope of this document.
+     * 2. Envoy issues a standard {Stream,Fetch}Endpoints request for the clusters
+     *    to balance.
+     * Independently, Envoy will initiate a StreamLoadStats bidi stream with a
+     * management server:
+     * 1. Once a connection establishes, the management server publishes a
+     *    LoadStatsResponse for all clusters it is interested in learning load
+     *    stats about.
+     * 2. For each cluster, Envoy load balances incoming traffic to upstream hosts
+     *    based on per-zone weights and/or per-instance weights (if specified)
+     *    based on intra-zone LbPolicy. This information comes from the above
+     *    {Stream,Fetch}Endpoints.
+     * 3. When upstream hosts reply, they optionally add header &lt;define header
+     *    name&gt; with ASCII representation of EndpointLoadMetricStats.
+     * 4. Envoy aggregates load reports over the period of time given to it in
+     *    LoadStatsResponse.load_reporting_interval. This includes aggregation
+     *    stats Envoy maintains by itself (total_requests, rpc_errors etc.) as
+     *    well as load metrics from upstream hosts.
+     * 5. When the timer of load_reporting_interval expires, Envoy sends new
+     *    LoadStatsRequest filled with load reports for each cluster.
+     * 6. The management server uses the load reports from all reported Envoys
+     *    from around the world, computes global assignment and prepares traffic
+     *    assignment destined for each zone Envoys are located in. Goto 2.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest> streamLoadStats(
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamLoadStatsMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service LoadReportingService.
+   */
+  public static abstract class LoadReportingServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return LoadReportingServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service LoadReportingService.
+   */
+  public static final class LoadReportingServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<LoadReportingServiceStub> {
+    private LoadReportingServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadReportingServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadReportingServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Advanced API to allow for multi-dimensional load balancing by remote
+     * server. For receiving LB assignments, the steps are:
+     * 1, The management server is configured with per cluster/zone/load metric
+     *    capacity configuration. The capacity configuration definition is
+     *    outside of the scope of this document.
+     * 2. Envoy issues a standard {Stream,Fetch}Endpoints request for the clusters
+     *    to balance.
+     * Independently, Envoy will initiate a StreamLoadStats bidi stream with a
+     * management server:
+     * 1. Once a connection establishes, the management server publishes a
+     *    LoadStatsResponse for all clusters it is interested in learning load
+     *    stats about.
+     * 2. For each cluster, Envoy load balances incoming traffic to upstream hosts
+     *    based on per-zone weights and/or per-instance weights (if specified)
+     *    based on intra-zone LbPolicy. This information comes from the above
+     *    {Stream,Fetch}Endpoints.
+     * 3. When upstream hosts reply, they optionally add header &lt;define header
+     *    name&gt; with ASCII representation of EndpointLoadMetricStats.
+     * 4. Envoy aggregates load reports over the period of time given to it in
+     *    LoadStatsResponse.load_reporting_interval. This includes aggregation
+     *    stats Envoy maintains by itself (total_requests, rpc_errors etc.) as
+     *    well as load metrics from upstream hosts.
+     * 5. When the timer of load_reporting_interval expires, Envoy sends new
+     *    LoadStatsRequest filled with load reports for each cluster.
+     * 6. The management server uses the load reports from all reported Envoys
+     *    from around the world, computes global assignment and prepares traffic
+     *    assignment destined for each zone Envoys are located in. Goto 2.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest> streamLoadStats(
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getStreamLoadStatsMethod(), getCallOptions()), responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service LoadReportingService.
+   */
+  public static final class LoadReportingServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<LoadReportingServiceBlockingV2Stub> {
+    private LoadReportingServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadReportingServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadReportingServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Advanced API to allow for multi-dimensional load balancing by remote
+     * server. For receiving LB assignments, the steps are:
+     * 1, The management server is configured with per cluster/zone/load metric
+     *    capacity configuration. The capacity configuration definition is
+     *    outside of the scope of this document.
+     * 2. Envoy issues a standard {Stream,Fetch}Endpoints request for the clusters
+     *    to balance.
+     * Independently, Envoy will initiate a StreamLoadStats bidi stream with a
+     * management server:
+     * 1. Once a connection establishes, the management server publishes a
+     *    LoadStatsResponse for all clusters it is interested in learning load
+     *    stats about.
+     * 2. For each cluster, Envoy load balances incoming traffic to upstream hosts
+     *    based on per-zone weights and/or per-instance weights (if specified)
+     *    based on intra-zone LbPolicy. This information comes from the above
+     *    {Stream,Fetch}Endpoints.
+     * 3. When upstream hosts reply, they optionally add header &lt;define header
+     *    name&gt; with ASCII representation of EndpointLoadMetricStats.
+     * 4. Envoy aggregates load reports over the period of time given to it in
+     *    LoadStatsResponse.load_reporting_interval. This includes aggregation
+     *    stats Envoy maintains by itself (total_requests, rpc_errors etc.) as
+     *    well as load metrics from upstream hosts.
+     * 5. When the timer of load_reporting_interval expires, Envoy sends new
+     *    LoadStatsRequest filled with load reports for each cluster.
+     * 6. The management server uses the load reports from all reported Envoys
+     *    from around the world, computes global assignment and prepares traffic
+     *    assignment destined for each zone Envoys are located in. Goto 2.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest, io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse>
+        streamLoadStats() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getStreamLoadStatsMethod(), getCallOptions());
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service LoadReportingService.
+   */
+  public static final class LoadReportingServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<LoadReportingServiceBlockingStub> {
+    private LoadReportingServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadReportingServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadReportingServiceBlockingStub(channel, callOptions);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service LoadReportingService.
+   */
+  public static final class LoadReportingServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<LoadReportingServiceFutureStub> {
+    private LoadReportingServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected LoadReportingServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new LoadReportingServiceFutureStub(channel, callOptions);
+    }
+  }
+
+  private static final int METHODID_STREAM_LOAD_STATS = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_STREAM_LOAD_STATS:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamLoadStats(
+              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse>) responseObserver);
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getStreamLoadStatsMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest,
+              io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse>(
+                service, METHODID_STREAM_LOAD_STATS)))
+        .build();
+  }
+
+  private static abstract class LoadReportingServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    LoadReportingServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.envoyproxy.envoy.service.load_stats.v3.LrsProto.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("LoadReportingService");
+    }
+  }
+
+  private static final class LoadReportingServiceFileDescriptorSupplier
+      extends LoadReportingServiceBaseDescriptorSupplier {
+    LoadReportingServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class LoadReportingServiceMethodDescriptorSupplier
+      extends LoadReportingServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    LoadReportingServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (LoadReportingServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new LoadReportingServiceFileDescriptorSupplier())
+              .addMethod(getStreamLoadStatsMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/rate_limit_quota/v3/RateLimitQuotaServiceGrpc.java b/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/rate_limit_quota/v3/RateLimitQuotaServiceGrpc.java
new file mode 100644
index 00000000000..3f17bb54566
--- /dev/null
+++ b/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/rate_limit_quota/v3/RateLimitQuotaServiceGrpc.java
@@ -0,0 +1,348 @@
+package io.envoyproxy.envoy.service.rate_limit_quota.v3;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * Defines the Rate Limit Quota Service (RLQS).
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class RateLimitQuotaServiceGrpc {
+
+  private RateLimitQuotaServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "envoy.service.rate_limit_quota.v3.RateLimitQuotaService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaUsageReports,
+      io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaResponse> getStreamRateLimitQuotasMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamRateLimitQuotas",
+      requestType = io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaUsageReports.class,
+      responseType = io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaUsageReports,
+      io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaResponse> getStreamRateLimitQuotasMethod() {
+    io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaUsageReports, io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaResponse> getStreamRateLimitQuotasMethod;
+    if ((getStreamRateLimitQuotasMethod = RateLimitQuotaServiceGrpc.getStreamRateLimitQuotasMethod) == null) {
+      synchronized (RateLimitQuotaServiceGrpc.class) {
+        if ((getStreamRateLimitQuotasMethod = RateLimitQuotaServiceGrpc.getStreamRateLimitQuotasMethod) == null) {
+          RateLimitQuotaServiceGrpc.getStreamRateLimitQuotasMethod = getStreamRateLimitQuotasMethod =
+              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaUsageReports, io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamRateLimitQuotas"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaUsageReports.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new RateLimitQuotaServiceMethodDescriptorSupplier("StreamRateLimitQuotas"))
+              .build();
+        }
+      }
+    }
+    return getStreamRateLimitQuotasMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static RateLimitQuotaServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<RateLimitQuotaServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<RateLimitQuotaServiceStub>() {
+        @java.lang.Override
+        public RateLimitQuotaServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new RateLimitQuotaServiceStub(channel, callOptions);
+        }
+      };
+    return RateLimitQuotaServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static RateLimitQuotaServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<RateLimitQuotaServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<RateLimitQuotaServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public RateLimitQuotaServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new RateLimitQuotaServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return RateLimitQuotaServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static RateLimitQuotaServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<RateLimitQuotaServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<RateLimitQuotaServiceBlockingStub>() {
+        @java.lang.Override
+        public RateLimitQuotaServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new RateLimitQuotaServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return RateLimitQuotaServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static RateLimitQuotaServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<RateLimitQuotaServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<RateLimitQuotaServiceFutureStub>() {
+        @java.lang.Override
+        public RateLimitQuotaServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new RateLimitQuotaServiceFutureStub(channel, callOptions);
+        }
+      };
+    return RateLimitQuotaServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * Defines the Rate Limit Quota Service (RLQS).
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     * <pre>
+     * Main communication channel: the data plane sends usage reports to the RLQS server,
+     * and the server asynchronously responding with the assignments.
+     * </pre>
+     */
+    default io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaUsageReports> streamRateLimitQuotas(
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamRateLimitQuotasMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service RateLimitQuotaService.
+   * <pre>
+   * Defines the Rate Limit Quota Service (RLQS).
+   * </pre>
+   */
+  public static abstract class RateLimitQuotaServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return RateLimitQuotaServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service RateLimitQuotaService.
+   * <pre>
+   * Defines the Rate Limit Quota Service (RLQS).
+   * </pre>
+   */
+  public static final class RateLimitQuotaServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<RateLimitQuotaServiceStub> {
+    private RateLimitQuotaServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected RateLimitQuotaServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new RateLimitQuotaServiceStub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Main communication channel: the data plane sends usage reports to the RLQS server,
+     * and the server asynchronously responding with the assignments.
+     * </pre>
+     */
+    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaUsageReports> streamRateLimitQuotas(
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getStreamRateLimitQuotasMethod(), getCallOptions()), responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service RateLimitQuotaService.
+   * <pre>
+   * Defines the Rate Limit Quota Service (RLQS).
+   * </pre>
+   */
+  public static final class RateLimitQuotaServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<RateLimitQuotaServiceBlockingV2Stub> {
+    private RateLimitQuotaServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected RateLimitQuotaServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new RateLimitQuotaServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     * <pre>
+     * Main communication channel: the data plane sends usage reports to the RLQS server,
+     * and the server asynchronously responding with the assignments.
+     * </pre>
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaUsageReports, io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaResponse>
+        streamRateLimitQuotas() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getStreamRateLimitQuotasMethod(), getCallOptions());
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service RateLimitQuotaService.
+   * <pre>
+   * Defines the Rate Limit Quota Service (RLQS).
+   * </pre>
+   */
+  public static final class RateLimitQuotaServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<RateLimitQuotaServiceBlockingStub> {
+    private RateLimitQuotaServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected RateLimitQuotaServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new RateLimitQuotaServiceBlockingStub(channel, callOptions);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service RateLimitQuotaService.
+   * <pre>
+   * Defines the Rate Limit Quota Service (RLQS).
+   * </pre>
+   */
+  public static final class RateLimitQuotaServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<RateLimitQuotaServiceFutureStub> {
+    private RateLimitQuotaServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected RateLimitQuotaServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new RateLimitQuotaServiceFutureStub(channel, callOptions);
+    }
+  }
+
+  private static final int METHODID_STREAM_RATE_LIMIT_QUOTAS = 0;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_STREAM_RATE_LIMIT_QUOTAS:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamRateLimitQuotas(
+              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaResponse>) responseObserver);
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getStreamRateLimitQuotasMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaUsageReports,
+              io.envoyproxy.envoy.service.rate_limit_quota.v3.RateLimitQuotaResponse>(
+                service, METHODID_STREAM_RATE_LIMIT_QUOTAS)))
+        .build();
+  }
+
+  private static abstract class RateLimitQuotaServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    RateLimitQuotaServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.envoyproxy.envoy.service.rate_limit_quota.v3.RlqsProto.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("RateLimitQuotaService");
+    }
+  }
+
+  private static final class RateLimitQuotaServiceFileDescriptorSupplier
+      extends RateLimitQuotaServiceBaseDescriptorSupplier {
+    RateLimitQuotaServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class RateLimitQuotaServiceMethodDescriptorSupplier
+      extends RateLimitQuotaServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    RateLimitQuotaServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (RateLimitQuotaServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new RateLimitQuotaServiceFileDescriptorSupplier())
+              .addMethod(getStreamRateLimitQuotasMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/status/v3/ClientStatusDiscoveryServiceGrpc.java b/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/status/v3/ClientStatusDiscoveryServiceGrpc.java
new file mode 100644
index 00000000000..cb166503566
--- /dev/null
+++ b/xds/src/generated/thirdparty/grpc/io/envoyproxy/envoy/service/status/v3/ClientStatusDiscoveryServiceGrpc.java
@@ -0,0 +1,431 @@
+package io.envoyproxy.envoy.service.status.v3;
+
+import static io.grpc.MethodDescriptor.generateFullMethodName;
+
+/**
+ * <pre>
+ * CSDS is Client Status Discovery Service. It can be used to get the status of
+ * an xDS-compliant client from the management server's point of view. It can
+ * also be used to get the current xDS states directly from the client.
+ * </pre>
+ */
+@io.grpc.stub.annotations.GrpcGenerated
+public final class ClientStatusDiscoveryServiceGrpc {
+
+  private ClientStatusDiscoveryServiceGrpc() {}
+
+  public static final java.lang.String SERVICE_NAME = "envoy.service.status.v3.ClientStatusDiscoveryService";
+
+  // Static method descriptors that strictly reflect the proto.
+  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.status.v3.ClientStatusRequest,
+      io.envoyproxy.envoy.service.status.v3.ClientStatusResponse> getStreamClientStatusMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "StreamClientStatus",
+      requestType = io.envoyproxy.envoy.service.status.v3.ClientStatusRequest.class,
+      responseType = io.envoyproxy.envoy.service.status.v3.ClientStatusResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.status.v3.ClientStatusRequest,
+      io.envoyproxy.envoy.service.status.v3.ClientStatusResponse> getStreamClientStatusMethod() {
+    io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.status.v3.ClientStatusRequest, io.envoyproxy.envoy.service.status.v3.ClientStatusResponse> getStreamClientStatusMethod;
+    if ((getStreamClientStatusMethod = ClientStatusDiscoveryServiceGrpc.getStreamClientStatusMethod) == null) {
+      synchronized (ClientStatusDiscoveryServiceGrpc.class) {
+        if ((getStreamClientStatusMethod = ClientStatusDiscoveryServiceGrpc.getStreamClientStatusMethod) == null) {
+          ClientStatusDiscoveryServiceGrpc.getStreamClientStatusMethod = getStreamClientStatusMethod =
+              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.service.status.v3.ClientStatusRequest, io.envoyproxy.envoy.service.status.v3.ClientStatusResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.BIDI_STREAMING)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "StreamClientStatus"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.status.v3.ClientStatusRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.status.v3.ClientStatusResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new ClientStatusDiscoveryServiceMethodDescriptorSupplier("StreamClientStatus"))
+              .build();
+        }
+      }
+    }
+    return getStreamClientStatusMethod;
+  }
+
+  private static volatile io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.status.v3.ClientStatusRequest,
+      io.envoyproxy.envoy.service.status.v3.ClientStatusResponse> getFetchClientStatusMethod;
+
+  @io.grpc.stub.annotations.RpcMethod(
+      fullMethodName = SERVICE_NAME + '/' + "FetchClientStatus",
+      requestType = io.envoyproxy.envoy.service.status.v3.ClientStatusRequest.class,
+      responseType = io.envoyproxy.envoy.service.status.v3.ClientStatusResponse.class,
+      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
+  public static io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.status.v3.ClientStatusRequest,
+      io.envoyproxy.envoy.service.status.v3.ClientStatusResponse> getFetchClientStatusMethod() {
+    io.grpc.MethodDescriptor<io.envoyproxy.envoy.service.status.v3.ClientStatusRequest, io.envoyproxy.envoy.service.status.v3.ClientStatusResponse> getFetchClientStatusMethod;
+    if ((getFetchClientStatusMethod = ClientStatusDiscoveryServiceGrpc.getFetchClientStatusMethod) == null) {
+      synchronized (ClientStatusDiscoveryServiceGrpc.class) {
+        if ((getFetchClientStatusMethod = ClientStatusDiscoveryServiceGrpc.getFetchClientStatusMethod) == null) {
+          ClientStatusDiscoveryServiceGrpc.getFetchClientStatusMethod = getFetchClientStatusMethod =
+              io.grpc.MethodDescriptor.<io.envoyproxy.envoy.service.status.v3.ClientStatusRequest, io.envoyproxy.envoy.service.status.v3.ClientStatusResponse>newBuilder()
+              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
+              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "FetchClientStatus"))
+              .setSampledToLocalTracing(true)
+              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.status.v3.ClientStatusRequest.getDefaultInstance()))
+              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
+                  io.envoyproxy.envoy.service.status.v3.ClientStatusResponse.getDefaultInstance()))
+              .setSchemaDescriptor(new ClientStatusDiscoveryServiceMethodDescriptorSupplier("FetchClientStatus"))
+              .build();
+        }
+      }
+    }
+    return getFetchClientStatusMethod;
+  }
+
+  /**
+   * Creates a new async stub that supports all call types for the service
+   */
+  public static ClientStatusDiscoveryServiceStub newStub(io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ClientStatusDiscoveryServiceStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ClientStatusDiscoveryServiceStub>() {
+        @java.lang.Override
+        public ClientStatusDiscoveryServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ClientStatusDiscoveryServiceStub(channel, callOptions);
+        }
+      };
+    return ClientStatusDiscoveryServiceStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports all types of calls on the service
+   */
+  public static ClientStatusDiscoveryServiceBlockingV2Stub newBlockingV2Stub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ClientStatusDiscoveryServiceBlockingV2Stub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ClientStatusDiscoveryServiceBlockingV2Stub>() {
+        @java.lang.Override
+        public ClientStatusDiscoveryServiceBlockingV2Stub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ClientStatusDiscoveryServiceBlockingV2Stub(channel, callOptions);
+        }
+      };
+    return ClientStatusDiscoveryServiceBlockingV2Stub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
+   */
+  public static ClientStatusDiscoveryServiceBlockingStub newBlockingStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ClientStatusDiscoveryServiceBlockingStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ClientStatusDiscoveryServiceBlockingStub>() {
+        @java.lang.Override
+        public ClientStatusDiscoveryServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ClientStatusDiscoveryServiceBlockingStub(channel, callOptions);
+        }
+      };
+    return ClientStatusDiscoveryServiceBlockingStub.newStub(factory, channel);
+  }
+
+  /**
+   * Creates a new ListenableFuture-style stub that supports unary calls on the service
+   */
+  public static ClientStatusDiscoveryServiceFutureStub newFutureStub(
+      io.grpc.Channel channel) {
+    io.grpc.stub.AbstractStub.StubFactory<ClientStatusDiscoveryServiceFutureStub> factory =
+      new io.grpc.stub.AbstractStub.StubFactory<ClientStatusDiscoveryServiceFutureStub>() {
+        @java.lang.Override
+        public ClientStatusDiscoveryServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+          return new ClientStatusDiscoveryServiceFutureStub(channel, callOptions);
+        }
+      };
+    return ClientStatusDiscoveryServiceFutureStub.newStub(factory, channel);
+  }
+
+  /**
+   * <pre>
+   * CSDS is Client Status Discovery Service. It can be used to get the status of
+   * an xDS-compliant client from the management server's point of view. It can
+   * also be used to get the current xDS states directly from the client.
+   * </pre>
+   */
+  public interface AsyncService {
+
+    /**
+     */
+    default io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.status.v3.ClientStatusRequest> streamClientStatus(
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.status.v3.ClientStatusResponse> responseObserver) {
+      return io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall(getStreamClientStatusMethod(), responseObserver);
+    }
+
+    /**
+     */
+    default void fetchClientStatus(io.envoyproxy.envoy.service.status.v3.ClientStatusRequest request,
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.status.v3.ClientStatusResponse> responseObserver) {
+      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getFetchClientStatusMethod(), responseObserver);
+    }
+  }
+
+  /**
+   * Base class for the server implementation of the service ClientStatusDiscoveryService.
+   * <pre>
+   * CSDS is Client Status Discovery Service. It can be used to get the status of
+   * an xDS-compliant client from the management server's point of view. It can
+   * also be used to get the current xDS states directly from the client.
+   * </pre>
+   */
+  public static abstract class ClientStatusDiscoveryServiceImplBase
+      implements io.grpc.BindableService, AsyncService {
+
+    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
+      return ClientStatusDiscoveryServiceGrpc.bindService(this);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do asynchronous rpc calls to service ClientStatusDiscoveryService.
+   * <pre>
+   * CSDS is Client Status Discovery Service. It can be used to get the status of
+   * an xDS-compliant client from the management server's point of view. It can
+   * also be used to get the current xDS states directly from the client.
+   * </pre>
+   */
+  public static final class ClientStatusDiscoveryServiceStub
+      extends io.grpc.stub.AbstractAsyncStub<ClientStatusDiscoveryServiceStub> {
+    private ClientStatusDiscoveryServiceStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ClientStatusDiscoveryServiceStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ClientStatusDiscoveryServiceStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.status.v3.ClientStatusRequest> streamClientStatus(
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.status.v3.ClientStatusResponse> responseObserver) {
+      return io.grpc.stub.ClientCalls.asyncBidiStreamingCall(
+          getChannel().newCall(getStreamClientStatusMethod(), getCallOptions()), responseObserver);
+    }
+
+    /**
+     */
+    public void fetchClientStatus(io.envoyproxy.envoy.service.status.v3.ClientStatusRequest request,
+        io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.status.v3.ClientStatusResponse> responseObserver) {
+      io.grpc.stub.ClientCalls.asyncUnaryCall(
+          getChannel().newCall(getFetchClientStatusMethod(), getCallOptions()), request, responseObserver);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do synchronous rpc calls to service ClientStatusDiscoveryService.
+   * <pre>
+   * CSDS is Client Status Discovery Service. It can be used to get the status of
+   * an xDS-compliant client from the management server's point of view. It can
+   * also be used to get the current xDS states directly from the client.
+   * </pre>
+   */
+  public static final class ClientStatusDiscoveryServiceBlockingV2Stub
+      extends io.grpc.stub.AbstractBlockingStub<ClientStatusDiscoveryServiceBlockingV2Stub> {
+    private ClientStatusDiscoveryServiceBlockingV2Stub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ClientStatusDiscoveryServiceBlockingV2Stub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ClientStatusDiscoveryServiceBlockingV2Stub(channel, callOptions);
+    }
+
+    /**
+     */
+    @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/10918")
+    public io.grpc.stub.BlockingClientCall<io.envoyproxy.envoy.service.status.v3.ClientStatusRequest, io.envoyproxy.envoy.service.status.v3.ClientStatusResponse>
+        streamClientStatus() {
+      return io.grpc.stub.ClientCalls.blockingBidiStreamingCall(
+          getChannel(), getStreamClientStatusMethod(), getCallOptions());
+    }
+
+    /**
+     */
+    public io.envoyproxy.envoy.service.status.v3.ClientStatusResponse fetchClientStatus(io.envoyproxy.envoy.service.status.v3.ClientStatusRequest request) throws io.grpc.StatusException {
+      return io.grpc.stub.ClientCalls.blockingV2UnaryCall(
+          getChannel(), getFetchClientStatusMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do limited synchronous rpc calls to service ClientStatusDiscoveryService.
+   * <pre>
+   * CSDS is Client Status Discovery Service. It can be used to get the status of
+   * an xDS-compliant client from the management server's point of view. It can
+   * also be used to get the current xDS states directly from the client.
+   * </pre>
+   */
+  public static final class ClientStatusDiscoveryServiceBlockingStub
+      extends io.grpc.stub.AbstractBlockingStub<ClientStatusDiscoveryServiceBlockingStub> {
+    private ClientStatusDiscoveryServiceBlockingStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ClientStatusDiscoveryServiceBlockingStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ClientStatusDiscoveryServiceBlockingStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public io.envoyproxy.envoy.service.status.v3.ClientStatusResponse fetchClientStatus(io.envoyproxy.envoy.service.status.v3.ClientStatusRequest request) {
+      return io.grpc.stub.ClientCalls.blockingUnaryCall(
+          getChannel(), getFetchClientStatusMethod(), getCallOptions(), request);
+    }
+  }
+
+  /**
+   * A stub to allow clients to do ListenableFuture-style rpc calls to service ClientStatusDiscoveryService.
+   * <pre>
+   * CSDS is Client Status Discovery Service. It can be used to get the status of
+   * an xDS-compliant client from the management server's point of view. It can
+   * also be used to get the current xDS states directly from the client.
+   * </pre>
+   */
+  public static final class ClientStatusDiscoveryServiceFutureStub
+      extends io.grpc.stub.AbstractFutureStub<ClientStatusDiscoveryServiceFutureStub> {
+    private ClientStatusDiscoveryServiceFutureStub(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    @java.lang.Override
+    protected ClientStatusDiscoveryServiceFutureStub build(
+        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
+      return new ClientStatusDiscoveryServiceFutureStub(channel, callOptions);
+    }
+
+    /**
+     */
+    public com.google.common.util.concurrent.ListenableFuture<io.envoyproxy.envoy.service.status.v3.ClientStatusResponse> fetchClientStatus(
+        io.envoyproxy.envoy.service.status.v3.ClientStatusRequest request) {
+      return io.grpc.stub.ClientCalls.futureUnaryCall(
+          getChannel().newCall(getFetchClientStatusMethod(), getCallOptions()), request);
+    }
+  }
+
+  private static final int METHODID_FETCH_CLIENT_STATUS = 0;
+  private static final int METHODID_STREAM_CLIENT_STATUS = 1;
+
+  private static final class MethodHandlers<Req, Resp> implements
+      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
+      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
+    private final AsyncService serviceImpl;
+    private final int methodId;
+
+    MethodHandlers(AsyncService serviceImpl, int methodId) {
+      this.serviceImpl = serviceImpl;
+      this.methodId = methodId;
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_FETCH_CLIENT_STATUS:
+          serviceImpl.fetchClientStatus((io.envoyproxy.envoy.service.status.v3.ClientStatusRequest) request,
+              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.status.v3.ClientStatusResponse>) responseObserver);
+          break;
+        default:
+          throw new AssertionError();
+      }
+    }
+
+    @java.lang.Override
+    @java.lang.SuppressWarnings("unchecked")
+    public io.grpc.stub.StreamObserver<Req> invoke(
+        io.grpc.stub.StreamObserver<Resp> responseObserver) {
+      switch (methodId) {
+        case METHODID_STREAM_CLIENT_STATUS:
+          return (io.grpc.stub.StreamObserver<Req>) serviceImpl.streamClientStatus(
+              (io.grpc.stub.StreamObserver<io.envoyproxy.envoy.service.status.v3.ClientStatusResponse>) responseObserver);
+        default:
+          throw new AssertionError();
+      }
+    }
+  }
+
+  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
+    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
+        .addMethod(
+          getStreamClientStatusMethod(),
+          io.grpc.stub.ServerCalls.asyncBidiStreamingCall(
+            new MethodHandlers<
+              io.envoyproxy.envoy.service.status.v3.ClientStatusRequest,
+              io.envoyproxy.envoy.service.status.v3.ClientStatusResponse>(
+                service, METHODID_STREAM_CLIENT_STATUS)))
+        .addMethod(
+          getFetchClientStatusMethod(),
+          io.grpc.stub.ServerCalls.asyncUnaryCall(
+            new MethodHandlers<
+              io.envoyproxy.envoy.service.status.v3.ClientStatusRequest,
+              io.envoyproxy.envoy.service.status.v3.ClientStatusResponse>(
+                service, METHODID_FETCH_CLIENT_STATUS)))
+        .build();
+  }
+
+  private static abstract class ClientStatusDiscoveryServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
+    ClientStatusDiscoveryServiceBaseDescriptorSupplier() {}
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
+      return io.envoyproxy.envoy.service.status.v3.CsdsProto.getDescriptor();
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
+      return getFileDescriptor().findServiceByName("ClientStatusDiscoveryService");
+    }
+  }
+
+  private static final class ClientStatusDiscoveryServiceFileDescriptorSupplier
+      extends ClientStatusDiscoveryServiceBaseDescriptorSupplier {
+    ClientStatusDiscoveryServiceFileDescriptorSupplier() {}
+  }
+
+  private static final class ClientStatusDiscoveryServiceMethodDescriptorSupplier
+      extends ClientStatusDiscoveryServiceBaseDescriptorSupplier
+      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
+    private final java.lang.String methodName;
+
+    ClientStatusDiscoveryServiceMethodDescriptorSupplier(java.lang.String methodName) {
+      this.methodName = methodName;
+    }
+
+    @java.lang.Override
+    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
+      return getServiceDescriptor().findMethodByName(methodName);
+    }
+  }
+
+  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
+
+  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
+    io.grpc.ServiceDescriptor result = serviceDescriptor;
+    if (result == null) {
+      synchronized (ClientStatusDiscoveryServiceGrpc.class) {
+        result = serviceDescriptor;
+        if (result == null) {
+          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
+              .setSchemaDescriptor(new ClientStatusDiscoveryServiceFileDescriptorSupplier())
+              .addMethod(getStreamClientStatusMethod())
+              .addMethod(getFetchClientStatusMethod())
+              .build();
+        }
+      }
+    }
+    return result;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/AddressFilter.java b/xds/src/main/java/io/grpc/xds/AddressFilter.java
new file mode 100644
index 00000000000..841e96d06bb
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/AddressFilter.java
@@ -0,0 +1,91 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver.ResolutionResultAttr;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import javax.annotation.Nullable;
+
+final class AddressFilter {
+  @ResolutionResultAttr
+  private static final Attributes.Key<PathChain> PATH_CHAIN_KEY =
+      Attributes.Key.create("io.grpc.xds.AddressFilter.PATH_CHAIN_KEY");
+
+  // Prevent instantiation.
+  private AddressFilter() {}
+
+  /**
+   * Returns a new EquivalentAddressGroup by setting a path filter to the given
+   * EquivalentAddressGroup. This method does not modify the input address.
+   */
+  static EquivalentAddressGroup setPathFilter(EquivalentAddressGroup address, List<String> names) {
+    checkNotNull(address, "address");
+    checkNotNull(names, "names");
+    Attributes.Builder attrBuilder = address.getAttributes().toBuilder().discard(PATH_CHAIN_KEY);
+    PathChain pathChain = null;
+    for (String name : names) {
+      if (pathChain == null) {
+        pathChain = new PathChain(name);
+        attrBuilder.set(PATH_CHAIN_KEY, pathChain);
+      } else {
+        pathChain.next = new PathChain(name);
+      }
+    }
+    return new EquivalentAddressGroup(address.getAddresses(), attrBuilder.build());
+  }
+
+  /**
+   * Returns the next level hierarchical addresses derived from the given hierarchical addresses
+   * with the given filter name (any non-hierarchical addresses in the input will be ignored).
+   * This method does not modify the input addresses.
+   */
+  static List<EquivalentAddressGroup> filter(List<EquivalentAddressGroup> addresses, String name) {
+    checkNotNull(addresses, "addresses");
+    checkNotNull(name, "name");
+    List<EquivalentAddressGroup> filteredAddresses = new ArrayList<>();
+    for (EquivalentAddressGroup address : addresses) {
+      PathChain pathChain = address.getAttributes().get(PATH_CHAIN_KEY);
+      if (pathChain != null && pathChain.name.equals(name)) {
+        Attributes filteredAddressAttrs =
+            address.getAttributes().toBuilder().set(PATH_CHAIN_KEY, pathChain.next).build();
+        filteredAddresses.add(
+            new EquivalentAddressGroup(address.getAddresses(), filteredAddressAttrs));
+      }
+    }
+    return Collections.unmodifiableList(filteredAddresses);
+  }
+
+  private static final class PathChain {
+    final String name;
+    @Nullable PathChain next;
+
+    PathChain(String name) {
+      this.name = checkNotNull(name, "name");
+    }
+
+    @Override
+    public String toString() {
+      return name + (next == null ? "" : ", " + next);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/CdsLoadBalancer2.java b/xds/src/main/java/io/grpc/xds/CdsLoadBalancer2.java
new file mode 100644
index 00000000000..67c5626aff5
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/CdsLoadBalancer2.java
@@ -0,0 +1,546 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static io.grpc.xds.XdsLbPolicies.CDS_POLICY_NAME;
+import static io.grpc.xds.XdsLbPolicies.PRIORITY_POLICY_NAME;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.errorprone.annotations.CheckReturnValue;
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.HttpConnectProxiedSocketAddress;
+import io.grpc.InternalLogId;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.util.OutlierDetectionLoadBalancer.OutlierDetectionLoadBalancerConfig;
+import io.grpc.xds.CdsLoadBalancerProvider.CdsConfig;
+import io.grpc.xds.ClusterImplLoadBalancerProvider.ClusterImplConfig;
+import io.grpc.xds.Endpoints.DropOverload;
+import io.grpc.xds.Endpoints.LbEndpoint;
+import io.grpc.xds.Endpoints.LocalityLbEndpoints;
+import io.grpc.xds.EnvoyServerProtoData.FailurePercentageEjection;
+import io.grpc.xds.EnvoyServerProtoData.OutlierDetection;
+import io.grpc.xds.EnvoyServerProtoData.SuccessRateEjection;
+import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig;
+import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig.PriorityChildConfig;
+import io.grpc.xds.XdsClusterResource.CdsUpdate;
+import io.grpc.xds.XdsClusterResource.CdsUpdate.ClusterType;
+import io.grpc.xds.XdsConfig.Subscription;
+import io.grpc.xds.XdsConfig.XdsClusterConfig;
+import io.grpc.xds.XdsConfig.XdsClusterConfig.AggregateConfig;
+import io.grpc.xds.XdsConfig.XdsClusterConfig.EndpointConfig;
+import io.grpc.xds.XdsEndpointResource.EdsUpdate;
+import io.grpc.xds.client.Locality;
+import io.grpc.xds.client.XdsLogger;
+import io.grpc.xds.client.XdsLogger.XdsLogLevel;
+import io.grpc.xds.internal.XdsInternalAttributes;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+/**
+ * Load balancer for cds_experimental LB policy. One instance per top-level cluster.
+ * The top-level cluster may be a plain EDS/logical-DNS cluster or an aggregate cluster formed
+ * by a group of sub-clusters in a tree hierarchy.
+ */
+final class CdsLoadBalancer2 extends LoadBalancer {
+  private final XdsLogger logger;
+  private final Helper helper;
+  private final LoadBalancerRegistry lbRegistry;
+  private final ClusterState clusterState = new ClusterState();
+  private GracefulSwitchLoadBalancer delegate;
+  // Following fields are effectively final.
+  private String clusterName;
+  private Subscription clusterSubscription;
+
+  CdsLoadBalancer2(Helper helper, LoadBalancerRegistry lbRegistry) {
+    this.helper = checkNotNull(helper, "helper");
+    this.lbRegistry = checkNotNull(lbRegistry, "lbRegistry");
+    this.delegate = new GracefulSwitchLoadBalancer(helper);
+    logger = XdsLogger.withLogId(InternalLogId.allocate("cds-lb", helper.getAuthority()));
+    logger.log(XdsLogLevel.INFO, "Created");
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
+    if (this.clusterName == null) {
+      CdsConfig config = (CdsConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+      logger.log(XdsLogLevel.INFO, "Config: {0}", config);
+      if (config.isDynamic) {
+        clusterSubscription = resolvedAddresses.getAttributes()
+            .get(XdsAttributes.XDS_CLUSTER_SUBSCRIPT_REGISTRY)
+            .subscribeToCluster(config.name);
+      }
+      this.clusterName = config.name;
+    }
+    XdsConfig xdsConfig = resolvedAddresses.getAttributes().get(XdsAttributes.XDS_CONFIG);
+    StatusOr<XdsClusterConfig> clusterConfigOr = xdsConfig.getClusters().get(clusterName);
+    if (clusterConfigOr == null) {
+      if (clusterSubscription == null) {
+        // Should be impossible, because XdsDependencyManager wouldn't have generated this
+        return fail(Status.INTERNAL.withDescription(
+            errorPrefix() + "Unable to find non-dynamic cluster"));
+      }
+      // The dynamic cluster must not have loaded yet
+      return Status.OK;
+    }
+    if (!clusterConfigOr.hasValue()) {
+      return fail(clusterConfigOr.getStatus());
+    }
+    XdsClusterConfig clusterConfig = clusterConfigOr.getValue();
+
+    NameResolver.ConfigOrError configOrError;
+    if (clusterConfig.getChildren() instanceof EndpointConfig) {
+      // The LB policy config is provided in service_config.proto/JSON format.
+      configOrError =
+              GracefulSwitchLoadBalancer.parseLoadBalancingPolicyConfig(
+                      Arrays.asList(clusterConfig.getClusterResource().lbPolicyConfig()),
+                      lbRegistry);
+      if (configOrError.getError() != null) {
+        // Should be impossible, because XdsClusterResource validated this
+        return fail(Status.INTERNAL.withDescription(
+                errorPrefix() + "Unable to parse the LB config: " + configOrError.getError()));
+      }
+
+      StatusOr<EdsUpdate> edsUpdate = getEdsUpdate(xdsConfig, clusterName);
+      StatusOr<ClusterResolutionResult> statusOrResult = clusterState.edsUpdateToResult(
+          clusterName,
+          clusterConfig.getClusterResource(),
+          configOrError.getConfig(),
+          edsUpdate);
+      if (!statusOrResult.hasValue()) {
+        Status status = Status.UNAVAILABLE
+            .withDescription(statusOrResult.getStatus().getDescription())
+            .withCause(statusOrResult.getStatus().getCause());
+        delegate.handleNameResolutionError(status);
+        return status;
+      }
+      ClusterResolutionResult result = statusOrResult.getValue();
+      List<EquivalentAddressGroup> addresses = result.addresses;
+      if (addresses.isEmpty()) {
+        Status status = Status.UNAVAILABLE
+            .withDescription("No usable endpoint from cluster: " + clusterName);
+        delegate.handleNameResolutionError(status);
+        return status;
+      }
+      Object gracefulConfig = GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+          lbRegistry.getProvider(PRIORITY_POLICY_NAME),
+          new PriorityLbConfig(
+              Collections.unmodifiableMap(result.priorityChildConfigs),
+              Collections.unmodifiableList(result.priorities)));
+      return delegate.acceptResolvedAddresses(
+          resolvedAddresses.toBuilder()
+            .setLoadBalancingPolicyConfig(gracefulConfig)
+            .setAddresses(Collections.unmodifiableList(addresses))
+            .build());
+    } else if (clusterConfig.getChildren() instanceof AggregateConfig) {
+      Map<String, PriorityChildConfig> priorityChildConfigs = new HashMap<>();
+      List<String> leafClusters = ((AggregateConfig) clusterConfig.getChildren()).getLeafNames();
+      for (String childCluster: leafClusters) {
+        priorityChildConfigs.put(childCluster,
+                new PriorityChildConfig(
+                        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+                                lbRegistry.getProvider(CDS_POLICY_NAME),
+                                new CdsConfig(childCluster)),
+                        false));
+      }
+      Object gracefulConfig = GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+          lbRegistry.getProvider(PRIORITY_POLICY_NAME),
+          new PriorityLoadBalancerProvider.PriorityLbConfig(
+              Collections.unmodifiableMap(priorityChildConfigs), leafClusters));
+      return delegate.acceptResolvedAddresses(
+          resolvedAddresses.toBuilder().setLoadBalancingPolicyConfig(gracefulConfig).build());
+    } else {
+      return fail(Status.INTERNAL.withDescription(
+              errorPrefix() + "Unexpected cluster children type: "
+                      + clusterConfig.getChildren().getClass()));
+    }
+  }
+
+  @Override
+  public void handleNameResolutionError(Status error) {
+    logger.log(XdsLogLevel.WARNING, "Received name resolution error: {0}", error);
+    if (delegate != null) {
+      delegate.handleNameResolutionError(error);
+    } else {
+      helper.updateBalancingState(
+          TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
+    }
+  }
+
+  @Override
+  public void shutdown() {
+    logger.log(XdsLogLevel.INFO, "Shutdown");
+    delegate.shutdown();
+    delegate = new GracefulSwitchLoadBalancer(helper);
+    if (clusterSubscription != null) {
+      clusterSubscription.close();
+      clusterSubscription = null;
+    }
+  }
+
+  @CheckReturnValue // don't forget to return up the stack after the fail call
+  private Status fail(Status error) {
+    delegate.shutdown();
+    helper.updateBalancingState(
+        TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
+    return Status.OK; // XdsNameResolver isn't a polling NR, so this value doesn't matter
+  }
+
+  private String errorPrefix() {
+    return "CdsLb for " + clusterName + ": ";
+  }
+
+  private static StatusOr<EdsUpdate> getEdsUpdate(XdsConfig xdsConfig, String cluster) {
+    StatusOr<XdsClusterConfig> clusterConfig = xdsConfig.getClusters().get(cluster);
+    if (clusterConfig == null) {
+      return StatusOr.fromStatus(Status.INTERNAL
+          .withDescription("BUG: cluster resolver could not find cluster in xdsConfig"));
+    }
+    if (!clusterConfig.hasValue()) {
+      return StatusOr.fromStatus(clusterConfig.getStatus());
+    }
+    if (!(clusterConfig.getValue().getChildren() instanceof XdsClusterConfig.EndpointConfig)) {
+      return StatusOr.fromStatus(Status.INTERNAL
+          .withDescription("BUG: cluster resolver cluster with children of unknown type"));
+    }
+    XdsClusterConfig.EndpointConfig endpointConfig =
+        (XdsClusterConfig.EndpointConfig) clusterConfig.getValue().getChildren();
+    return endpointConfig.getEndpoint();
+  }
+
+  /**
+   * Generates a string that represents the priority in the LB policy config. The string is unique
+   * across priorities in all clusters and priorityName(c, p1) < priorityName(c, p2) iff p1 < p2.
+   * The ordering is undefined for priorities in different clusters.
+   */
+  private static String priorityName(String cluster, int priority) {
+    return cluster + "[child" + priority + "]";
+  }
+
+  /**
+   * Generates a string that represents the locality in the LB policy config. The string is unique
+   * across all localities in all clusters.
+   */
+  private static String localityName(Locality locality) {
+    return "{region=\"" + locality.region()
+        + "\", zone=\"" + locality.zone()
+        + "\", sub_zone=\"" + locality.subZone()
+        + "\"}";
+  }
+
+  private final class ClusterState {
+    private Map<Locality, String> localityPriorityNames = Collections.emptyMap();
+    int priorityNameGenId = 1;
+
+    StatusOr<ClusterResolutionResult> edsUpdateToResult(
+        String clusterName,
+        CdsUpdate discovery,
+        Object lbConfig,
+        StatusOr<EdsUpdate> updateOr) {
+      if (!updateOr.hasValue()) {
+        return StatusOr.fromStatus(updateOr.getStatus());
+      }
+      EdsUpdate update = updateOr.getValue();
+      logger.log(XdsLogLevel.DEBUG, "Received endpoint update {0}", update);
+      if (logger.isLoggable(XdsLogLevel.INFO)) {
+        logger.log(XdsLogLevel.INFO, "Cluster {0}: {1} localities, {2} drop categories",
+            clusterName, update.localityLbEndpointsMap.size(),
+            update.dropPolicies.size());
+      }
+      Map<Locality, LocalityLbEndpoints> localityLbEndpoints =
+          update.localityLbEndpointsMap;
+      List<DropOverload> dropOverloads = update.dropPolicies;
+      List<EquivalentAddressGroup> addresses = new ArrayList<>();
+      Map<String, Map<Locality, Integer>> prioritizedLocalityWeights = new HashMap<>();
+      List<String> sortedPriorityNames =
+          generatePriorityNames(clusterName, localityLbEndpoints);
+      for (Locality locality : localityLbEndpoints.keySet()) {
+        LocalityLbEndpoints localityLbInfo = localityLbEndpoints.get(locality);
+        String priorityName = localityPriorityNames.get(locality);
+        boolean discard = true;
+        for (LbEndpoint endpoint : localityLbInfo.endpoints()) {
+          if (endpoint.isHealthy()) {
+            discard = false;
+            long weight = localityLbInfo.localityWeight();
+            if (endpoint.loadBalancingWeight() != 0) {
+              weight *= endpoint.loadBalancingWeight();
+            }
+            String localityName = localityName(locality);
+            Attributes attr =
+                endpoint.eag().getAttributes().toBuilder()
+                    .set(io.grpc.xds.XdsAttributes.ATTR_LOCALITY, locality)
+                    .set(EquivalentAddressGroup.ATTR_LOCALITY_NAME, localityName)
+                    .set(io.grpc.xds.XdsAttributes.ATTR_LOCALITY_WEIGHT,
+                        localityLbInfo.localityWeight())
+                    .set(io.grpc.xds.XdsAttributes.ATTR_SERVER_WEIGHT, weight)
+                    .set(XdsInternalAttributes.ATTR_ADDRESS_NAME, endpoint.hostname())
+                    .build();
+            EquivalentAddressGroup eag;
+            if (discovery.isHttp11ProxyAvailable()) {
+              List<SocketAddress> rewrittenAddresses = new ArrayList<>();
+              for (SocketAddress addr : endpoint.eag().getAddresses()) {
+                rewrittenAddresses.add(rewriteAddress(
+                    addr, endpoint.endpointMetadata(), localityLbInfo.localityMetadata()));
+              }
+              eag = new EquivalentAddressGroup(rewrittenAddresses, attr);
+            } else {
+              eag = new EquivalentAddressGroup(endpoint.eag().getAddresses(), attr);
+            }
+            eag = AddressFilter.setPathFilter(eag, Arrays.asList(priorityName, localityName));
+            addresses.add(eag);
+          }
+        }
+        if (discard) {
+          logger.log(XdsLogLevel.INFO,
+              "Discard locality {0} with 0 healthy endpoints", locality);
+          continue;
+        }
+        if (!prioritizedLocalityWeights.containsKey(priorityName)) {
+          prioritizedLocalityWeights.put(priorityName, new HashMap<Locality, Integer>());
+        }
+        prioritizedLocalityWeights.get(priorityName).put(
+            locality, localityLbInfo.localityWeight());
+      }
+      if (prioritizedLocalityWeights.isEmpty()) {
+        // Will still update the result, as if the cluster resource is revoked.
+        logger.log(XdsLogLevel.INFO,
+            "Cluster {0} has no usable priority/locality/endpoint", clusterName);
+      }
+      sortedPriorityNames.retainAll(prioritizedLocalityWeights.keySet());
+      Map<String, PriorityChildConfig> priorityChildConfigs =
+          generatePriorityChildConfigs(
+              clusterName, discovery, lbConfig, lbRegistry,
+              prioritizedLocalityWeights, dropOverloads);
+      return StatusOr.fromValue(new ClusterResolutionResult(addresses, priorityChildConfigs,
+          sortedPriorityNames));
+    }
+
+    private SocketAddress rewriteAddress(SocketAddress addr,
+        ImmutableMap<String, Object> endpointMetadata,
+        ImmutableMap<String, Object> localityMetadata) {
+      if (!(addr instanceof InetSocketAddress)) {
+        return addr;
+      }
+
+      SocketAddress proxyAddress;
+      try {
+        proxyAddress = (SocketAddress) endpointMetadata.get(
+            "envoy.http11_proxy_transport_socket.proxy_address");
+        if (proxyAddress == null) {
+          proxyAddress = (SocketAddress) localityMetadata.get(
+              "envoy.http11_proxy_transport_socket.proxy_address");
+        }
+      } catch (ClassCastException e) {
+        return addr;
+      }
+
+      if (proxyAddress == null) {
+        return addr;
+      }
+
+      return HttpConnectProxiedSocketAddress.newBuilder()
+          .setTargetAddress((InetSocketAddress) addr)
+          .setProxyAddress(proxyAddress)
+          .build();
+    }
+
+    private List<String> generatePriorityNames(String name,
+        Map<Locality, LocalityLbEndpoints> localityLbEndpoints) {
+      TreeMap<Integer, List<Locality>> todo = new TreeMap<>();
+      for (Locality locality : localityLbEndpoints.keySet()) {
+        int priority = localityLbEndpoints.get(locality).priority();
+        if (!todo.containsKey(priority)) {
+          todo.put(priority, new ArrayList<>());
+        }
+        todo.get(priority).add(locality);
+      }
+      Map<Locality, String> newNames = new HashMap<>();
+      Set<String> usedNames = new HashSet<>();
+      List<String> ret = new ArrayList<>();
+      for (Integer priority: todo.keySet()) {
+        String foundName = "";
+        for (Locality locality : todo.get(priority)) {
+          if (localityPriorityNames.containsKey(locality)
+              && usedNames.add(localityPriorityNames.get(locality))) {
+            foundName = localityPriorityNames.get(locality);
+            break;
+          }
+        }
+        if ("".equals(foundName)) {
+          foundName = priorityName(name, priorityNameGenId++);
+        }
+        for (Locality locality : todo.get(priority)) {
+          newNames.put(locality, foundName);
+        }
+        ret.add(foundName);
+      }
+      localityPriorityNames = newNames;
+      return ret;
+    }
+  }
+
+  private static class ClusterResolutionResult {
+    // Endpoint addresses.
+    private final List<EquivalentAddressGroup> addresses;
+    // Config (include load balancing policy/config) for each priority in the cluster.
+    private final Map<String, PriorityChildConfig> priorityChildConfigs;
+    // List of priority names ordered in descending priorities.
+    private final List<String> priorities;
+
+    ClusterResolutionResult(List<EquivalentAddressGroup> addresses,
+        Map<String, PriorityChildConfig> configs, List<String> priorities) {
+      this.addresses = addresses;
+      this.priorityChildConfigs = configs;
+      this.priorities = priorities;
+    }
+  }
+
+  /**
+   * Generates configs to be used in the priority LB policy for priorities in a cluster.
+   *
+   * <p>priority LB -> cluster_impl LB (one per priority) -> (weighted_target LB
+   * -> round_robin / least_request_experimental (one per locality)) / ring_hash_experimental
+   */
+  private static Map<String, PriorityChildConfig> generatePriorityChildConfigs(
+      String clusterName,
+      CdsUpdate discovery,
+      Object endpointLbConfig,
+      LoadBalancerRegistry lbRegistry,
+      Map<String, Map<Locality, Integer>> prioritizedLocalityWeights,
+      List<DropOverload> dropOverloads) {
+    Map<String, PriorityChildConfig> configs = new HashMap<>();
+    for (String priority : prioritizedLocalityWeights.keySet()) {
+      ClusterImplConfig clusterImplConfig =
+          new ClusterImplConfig(
+              clusterName, discovery.edsServiceName(), discovery.lrsServerInfo(),
+              discovery.maxConcurrentRequests(), dropOverloads, endpointLbConfig,
+              discovery.upstreamTlsContext(), discovery.filterMetadata(),
+              discovery.backendMetricPropagation());
+      LoadBalancerProvider clusterImplLbProvider =
+          lbRegistry.getProvider(XdsLbPolicies.CLUSTER_IMPL_POLICY_NAME);
+      Object priorityChildPolicy = GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+          clusterImplLbProvider, clusterImplConfig);
+
+      // If outlier detection has been configured we wrap the child policy in the outlier detection
+      // load balancer.
+      if (discovery.outlierDetection() != null) {
+        LoadBalancerProvider outlierDetectionProvider = lbRegistry.getProvider(
+            "outlier_detection_experimental");
+        priorityChildPolicy = GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            outlierDetectionProvider,
+            buildOutlierDetectionLbConfig(discovery.outlierDetection(), priorityChildPolicy));
+      }
+
+      boolean isEds = discovery.clusterType() == ClusterType.EDS;
+      PriorityChildConfig priorityChildConfig =
+          new PriorityChildConfig(priorityChildPolicy, isEds /* ignoreReresolution */);
+      configs.put(priority, priorityChildConfig);
+    }
+    return configs;
+  }
+
+  /**
+   * Converts {@link OutlierDetection} that represents the xDS configuration to {@link
+   * OutlierDetectionLoadBalancerConfig} that the {@link io.grpc.util.OutlierDetectionLoadBalancer}
+   * understands.
+   */
+  private static OutlierDetectionLoadBalancerConfig buildOutlierDetectionLbConfig(
+      OutlierDetection outlierDetection, Object childConfig) {
+    OutlierDetectionLoadBalancerConfig.Builder configBuilder
+        = new OutlierDetectionLoadBalancerConfig.Builder();
+
+    configBuilder.setChildConfig(childConfig);
+
+    if (outlierDetection.intervalNanos() != null) {
+      configBuilder.setIntervalNanos(outlierDetection.intervalNanos());
+    }
+    if (outlierDetection.baseEjectionTimeNanos() != null) {
+      configBuilder.setBaseEjectionTimeNanos(outlierDetection.baseEjectionTimeNanos());
+    }
+    if (outlierDetection.maxEjectionTimeNanos() != null) {
+      configBuilder.setMaxEjectionTimeNanos(outlierDetection.maxEjectionTimeNanos());
+    }
+    if (outlierDetection.maxEjectionPercent() != null) {
+      configBuilder.setMaxEjectionPercent(outlierDetection.maxEjectionPercent());
+    }
+
+    SuccessRateEjection successRate = outlierDetection.successRateEjection();
+    if (successRate != null) {
+      OutlierDetectionLoadBalancerConfig.SuccessRateEjection.Builder
+          successRateConfigBuilder = new OutlierDetectionLoadBalancerConfig
+          .SuccessRateEjection.Builder();
+
+      if (successRate.stdevFactor() != null) {
+        successRateConfigBuilder.setStdevFactor(successRate.stdevFactor());
+      }
+      if (successRate.enforcementPercentage() != null) {
+        successRateConfigBuilder.setEnforcementPercentage(successRate.enforcementPercentage());
+      }
+      if (successRate.minimumHosts() != null) {
+        successRateConfigBuilder.setMinimumHosts(successRate.minimumHosts());
+      }
+      if (successRate.requestVolume() != null) {
+        successRateConfigBuilder.setRequestVolume(successRate.requestVolume());
+      }
+
+      configBuilder.setSuccessRateEjection(successRateConfigBuilder.build());
+    }
+
+    FailurePercentageEjection failurePercentage = outlierDetection.failurePercentageEjection();
+    if (failurePercentage != null) {
+      OutlierDetectionLoadBalancerConfig.FailurePercentageEjection.Builder
+          failurePercentageConfigBuilder = new OutlierDetectionLoadBalancerConfig
+          .FailurePercentageEjection.Builder();
+
+      if (failurePercentage.threshold() != null) {
+        failurePercentageConfigBuilder.setThreshold(failurePercentage.threshold());
+      }
+      if (failurePercentage.enforcementPercentage() != null) {
+        failurePercentageConfigBuilder.setEnforcementPercentage(
+            failurePercentage.enforcementPercentage());
+      }
+      if (failurePercentage.minimumHosts() != null) {
+        failurePercentageConfigBuilder.setMinimumHosts(failurePercentage.minimumHosts());
+      }
+      if (failurePercentage.requestVolume() != null) {
+        failurePercentageConfigBuilder.setRequestVolume(failurePercentage.requestVolume());
+      }
+
+      configBuilder.setFailurePercentageEjection(failurePercentageConfigBuilder.build());
+    }
+
+    return configBuilder.build();
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/CdsLoadBalancerProvider.java b/xds/src/main/java/io/grpc/xds/CdsLoadBalancerProvider.java
new file mode 100644
index 00000000000..875af9089ed
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/CdsLoadBalancerProvider.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2019 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.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.JsonUtil;
+import java.util.Map;
+
+/**
+ * The provider for the "cds" balancing policy.  This class should not be directly referenced in
+ * code.  The policy should be accessed through {@link io.grpc.LoadBalancerRegistry#getProvider}
+ * with the name "cds" (currently "cds_experimental").
+ */
+@Internal
+public class CdsLoadBalancerProvider extends LoadBalancerProvider {
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return XdsLbPolicies.CDS_POLICY_NAME;
+  }
+
+  private final LoadBalancerRegistry loadBalancerRegistry;
+
+  public CdsLoadBalancerProvider() {
+    this.loadBalancerRegistry = null;
+  }
+
+  public CdsLoadBalancerProvider(LoadBalancerRegistry loadBalancerRegistry) {
+    this.loadBalancerRegistry = loadBalancerRegistry;
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    LoadBalancerRegistry loadBalancerRegistry = this.loadBalancerRegistry;
+    if (loadBalancerRegistry == null) {
+      loadBalancerRegistry = LoadBalancerRegistry.getDefaultRegistry();
+    }
+
+    return new CdsLoadBalancer2(helper, loadBalancerRegistry);
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(
+      Map<String, ?> rawLoadBalancingPolicyConfig) {
+    return parseLoadBalancingConfigPolicy(rawLoadBalancingPolicyConfig);
+  }
+
+  /**
+   * Parses raw load balancing config and returns a {@link ConfigOrError} that contains a
+   * {@link CdsConfig} if parsing is successful.
+   */
+  static ConfigOrError parseLoadBalancingConfigPolicy(Map<String, ?> rawLoadBalancingPolicyConfig) {
+    try {
+      String cluster = JsonUtil.getString(rawLoadBalancingPolicyConfig, "cluster");
+      Boolean isDynamic = JsonUtil.getBoolean(rawLoadBalancingPolicyConfig, "is_dynamic");
+      if (isDynamic == null) {
+        isDynamic = Boolean.FALSE;
+      }
+      return ConfigOrError.fromConfig(new CdsConfig(cluster, isDynamic));
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError(
+          Status.UNAVAILABLE.withCause(e).withDescription(
+              "Failed to parse CDS LB config: " + rawLoadBalancingPolicyConfig));
+    }
+  }
+
+  /**
+   * Represents a successfully parsed and validated LoadBalancingConfig for CDS.
+   */
+  static final class CdsConfig {
+
+    /**
+     * Name of cluster to query CDS for.
+     */
+    final String name;
+    /**
+     * Whether this cluster was dynamically chosen, so the XdsDependencyManager may be unaware of
+     * it without an explicit cluster subscription.
+     */
+    final boolean isDynamic;
+
+    CdsConfig(String name) {
+      this(name, false);
+    }
+
+    CdsConfig(String name, boolean isDynamic) {
+      checkArgument(name != null && !name.isEmpty(), "name is null or empty");
+      this.name = name;
+      this.isDynamic = isDynamic;
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("name", name)
+          .add("isDynamic", isDynamic)
+          .toString();
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/ClusterImplLoadBalancer.java b/xds/src/main/java/io/grpc/xds/ClusterImplLoadBalancer.java
new file mode 100644
index 00000000000..ec4bec7f25c
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/ClusterImplLoadBalancer.java
@@ -0,0 +1,560 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.xds.client.LoadStatsManager2.isEnabledOrcaLrsPropagation;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Struct;
+import io.grpc.Attributes;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ClientStreamTracer.StreamInfo;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.InternalLogId;
+import io.grpc.LoadBalancer;
+import io.grpc.Metadata;
+import io.grpc.NameResolver;
+import io.grpc.Status;
+import io.grpc.internal.ForwardingClientStreamTracer;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.services.MetricReport;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import io.grpc.util.ForwardingSubchannel;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.xds.ClusterImplLoadBalancerProvider.ClusterImplConfig;
+import io.grpc.xds.Endpoints.DropOverload;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.ThreadSafeRandom.ThreadSafeRandomImpl;
+import io.grpc.xds.XdsNameResolverProvider.CallCounterProvider;
+import io.grpc.xds.client.BackendMetricPropagation;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.LoadStatsManager2.ClusterDropStats;
+import io.grpc.xds.client.LoadStatsManager2.ClusterLocalityStats;
+import io.grpc.xds.client.Locality;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsLogger;
+import io.grpc.xds.client.XdsLogger.XdsLogLevel;
+import io.grpc.xds.internal.XdsInternalAttributes;
+import io.grpc.xds.internal.security.SecurityProtocolNegotiators;
+import io.grpc.xds.internal.security.SslContextProviderSupplier;
+import io.grpc.xds.orca.OrcaPerRequestUtil;
+import io.grpc.xds.orca.OrcaPerRequestUtil.OrcaPerRequestReportListener;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nullable;
+
+/**
+ * Load balancer for cluster_impl_experimental LB policy. This LB policy is the child LB policy of
+ * the priority_experimental LB policy and the parent LB policy of the weighted_target_experimental
+ * LB policy in the xDS load balancing hierarchy. This LB policy applies cluster-level
+ * configurations to requests sent to the corresponding cluster, such as drop policies, circuit
+ * breakers.
+ */
+final class ClusterImplLoadBalancer extends LoadBalancer {
+
+  @VisibleForTesting
+  static final long DEFAULT_PER_CLUSTER_MAX_CONCURRENT_REQUESTS = 1024L;
+  @VisibleForTesting
+  static boolean enableCircuitBreaking =
+      Strings.isNullOrEmpty(System.getenv("GRPC_XDS_EXPERIMENTAL_CIRCUIT_BREAKING"))
+          || Boolean.parseBoolean(System.getenv("GRPC_XDS_EXPERIMENTAL_CIRCUIT_BREAKING"));
+
+  private static final Attributes.Key<AtomicReference<ClusterLocality>> ATTR_CLUSTER_LOCALITY =
+      Attributes.Key.create("io.grpc.xds.ClusterImplLoadBalancer.clusterLocality");
+  @VisibleForTesting
+  static final Attributes.Key<String> ATTR_SUBCHANNEL_ADDRESS_NAME =
+      Attributes.Key.create("io.grpc.xds.ClusterImplLoadBalancer.addressName");
+
+  private final XdsLogger logger;
+  private final Helper helper;
+  private final ThreadSafeRandom random;
+  // The following fields are effectively final.
+  private String cluster;
+  @Nullable
+  private String edsServiceName;
+  private XdsClient xdsClient;
+  private CallCounterProvider callCounterProvider;
+  private ClusterDropStats dropStats;
+  private ClusterImplLbHelper childLbHelper;
+  private GracefulSwitchLoadBalancer childSwitchLb;
+
+  ClusterImplLoadBalancer(Helper helper) {
+    this(helper, ThreadSafeRandomImpl.instance);
+  }
+
+  ClusterImplLoadBalancer(Helper helper, ThreadSafeRandom random) {
+    this.helper = checkNotNull(helper, "helper");
+    this.random = checkNotNull(random, "random");
+    InternalLogId logId = InternalLogId.allocate("cluster-impl-lb", helper.getAuthority());
+    logger = XdsLogger.withLogId(logId);
+    logger.log(XdsLogLevel.INFO, "Created");
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
+    Attributes attributes = resolvedAddresses.getAttributes();
+    if (xdsClient == null) {
+      xdsClient = checkNotNull(attributes.get(io.grpc.xds.XdsAttributes.XDS_CLIENT), "xdsClient");
+    }
+    if (callCounterProvider == null) {
+      callCounterProvider = attributes.get(io.grpc.xds.XdsAttributes.CALL_COUNTER_PROVIDER);
+    }
+
+    ClusterImplConfig config =
+        (ClusterImplConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+    if (config == null) {
+      return Status.INTERNAL.withDescription("No cluster configuration found");
+    }
+
+    if (cluster == null) {
+      cluster = config.cluster;
+      edsServiceName = config.edsServiceName;
+      childLbHelper = new ClusterImplLbHelper(
+          callCounterProvider.getOrCreate(config.cluster, config.edsServiceName),
+          config.lrsServerInfo);
+      childSwitchLb = new GracefulSwitchLoadBalancer(childLbHelper);
+      // Assume load report server does not change throughout cluster lifetime.
+      if (config.lrsServerInfo != null) {
+        dropStats = xdsClient.addClusterDropStats(config.lrsServerInfo, cluster, edsServiceName);
+      }
+    }
+
+    childLbHelper.updateDropPolicies(config.dropCategories);
+    childLbHelper.updateMaxConcurrentRequests(config.maxConcurrentRequests);
+    childLbHelper.updateSslContextProviderSupplier(config.tlsContext);
+    childLbHelper.updateFilterMetadata(config.filterMetadata);
+    childLbHelper.updateBackendMetricPropagation(config.backendMetricPropagation);
+
+    childSwitchLb.handleResolvedAddresses(
+        resolvedAddresses.toBuilder()
+            .setAttributes(attributes.toBuilder()
+              .set(NameResolver.ATTR_BACKEND_SERVICE, cluster)
+              .build())
+            .setLoadBalancingPolicyConfig(config.childConfig)
+            .build());
+    return Status.OK;
+  }
+
+  @Override
+  public void handleNameResolutionError(Status error) {
+    if (childSwitchLb != null) {
+      childSwitchLb.handleNameResolutionError(error);
+    } else {
+      helper.updateBalancingState(
+          ConnectivityState.TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
+    }
+  }
+
+  @Override
+  public void requestConnection() {
+    if (childSwitchLb != null) {
+      childSwitchLb.requestConnection();
+    }
+  }
+
+  @Override
+  public void shutdown() {
+    if (dropStats != null) {
+      dropStats.release();
+    }
+    if (childSwitchLb != null) {
+      childSwitchLb.shutdown();
+      if (childLbHelper != null) {
+        childLbHelper.updateSslContextProviderSupplier(null);
+        childLbHelper = null;
+      }
+    }
+    xdsClient = null;
+  }
+
+  /**
+   * A decorated {@link LoadBalancer.Helper} that applies configurations for connections
+   * or requests to endpoints in the cluster.
+   */
+  private final class ClusterImplLbHelper extends ForwardingLoadBalancerHelper {
+    private final AtomicLong inFlights;
+    private ConnectivityState currentState = ConnectivityState.IDLE;
+    private SubchannelPicker currentPicker = new FixedResultPicker(PickResult.withNoResult());
+    private List<DropOverload> dropPolicies = Collections.emptyList();
+    private long maxConcurrentRequests = DEFAULT_PER_CLUSTER_MAX_CONCURRENT_REQUESTS;
+    @Nullable
+    private SslContextProviderSupplier sslContextProviderSupplier;
+    private Map<String, Struct> filterMetadata = ImmutableMap.of();
+    @Nullable
+    private final ServerInfo lrsServerInfo;
+    @Nullable
+    private BackendMetricPropagation backendMetricPropagation;
+
+    private ClusterImplLbHelper(AtomicLong inFlights, @Nullable ServerInfo lrsServerInfo) {
+      this.inFlights = checkNotNull(inFlights, "inFlights");
+      this.lrsServerInfo = lrsServerInfo;
+    }
+
+    @Override
+    public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+      currentState = newState;
+      currentPicker =  newPicker;
+      SubchannelPicker picker = new RequestLimitingSubchannelPicker(
+          newPicker, dropPolicies, maxConcurrentRequests, filterMetadata);
+      delegate().updateBalancingState(newState, picker);
+    }
+
+    @Override
+    public Subchannel createSubchannel(CreateSubchannelArgs args) {
+      List<EquivalentAddressGroup> addresses = withAdditionalAttributes(args.getAddresses());
+      // This value for  ClusterLocality is not recommended for general use.
+      // Currently, we extract locality data from the first address, even before the subchannel is
+      // READY.
+      // This is mainly to accommodate scenarios where a Load Balancing API (like "pick first")
+      // might return the subchannel before it is READY. Typically, we wouldn't report load for such
+      // selections because the channel will disregard the chosen (not-ready) subchannel.
+      // However, we needed to ensure this case is handled.
+      ClusterLocality clusterLocality = createClusterLocalityFromAttributes(
+          args.getAddresses().get(0).getAttributes());
+      AtomicReference<ClusterLocality> localityAtomicReference = new AtomicReference<>(
+          clusterLocality);
+      Attributes.Builder attrsBuilder = args.getAttributes().toBuilder()
+          .set(ATTR_CLUSTER_LOCALITY, localityAtomicReference);
+      if (GrpcUtil.getFlag("GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE", false)) {
+        String hostname = args.getAddresses().get(0).getAttributes()
+            .get(XdsInternalAttributes.ATTR_ADDRESS_NAME);
+        if (hostname != null) {
+          attrsBuilder.set(ATTR_SUBCHANNEL_ADDRESS_NAME, hostname);
+        }
+      }
+      args = args.toBuilder().setAddresses(addresses).setAttributes(attrsBuilder.build()).build();
+      final Subchannel subchannel = delegate().createSubchannel(args);
+
+      return new ForwardingSubchannel() {
+        @Override
+        public void start(SubchannelStateListener listener) {
+          delegate().start(new SubchannelStateListener() {
+            @Override
+            public void onSubchannelState(ConnectivityStateInfo newState) {
+              // Do nothing if LB has been shutdown
+              if (xdsClient != null && newState.getState().equals(ConnectivityState.READY)) {
+                // Get locality based on the connected address attributes
+                ClusterLocality updatedClusterLocality = createClusterLocalityFromAttributes(
+                    subchannel.getConnectedAddressAttributes());
+                ClusterLocality oldClusterLocality = localityAtomicReference
+                    .getAndSet(updatedClusterLocality);
+                oldClusterLocality.release();
+              }
+              listener.onSubchannelState(newState);
+            }
+          });
+        }
+
+        @Override
+        public void shutdown() {
+          localityAtomicReference.get().release();
+          delegate().shutdown();
+        }
+
+        @Override
+        public void updateAddresses(List<EquivalentAddressGroup> addresses) {
+          delegate().updateAddresses(withAdditionalAttributes(addresses));
+        }
+
+        @Override
+        protected Subchannel delegate() {
+          return subchannel;
+        }
+      };
+    }
+
+    private List<EquivalentAddressGroup> withAdditionalAttributes(
+        List<EquivalentAddressGroup> addresses) {
+      List<EquivalentAddressGroup> newAddresses = new ArrayList<>();
+      for (EquivalentAddressGroup eag : addresses) {
+        Attributes.Builder attrBuilder = eag.getAttributes().toBuilder().set(
+            io.grpc.xds.XdsAttributes.ATTR_CLUSTER_NAME, cluster);
+        if (sslContextProviderSupplier != null) {
+          attrBuilder.set(
+              SecurityProtocolNegotiators.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER,
+              sslContextProviderSupplier);
+        }
+        newAddresses.add(new EquivalentAddressGroup(eag.getAddresses(), attrBuilder.build()));
+      }
+      return newAddresses;
+    }
+
+    private ClusterLocality createClusterLocalityFromAttributes(Attributes addressAttributes) {
+      Locality locality = addressAttributes.get(io.grpc.xds.XdsAttributes.ATTR_LOCALITY);
+      String localityName = addressAttributes.get(EquivalentAddressGroup.ATTR_LOCALITY_NAME);
+
+      // Endpoint addresses resolved by ClusterResolverLoadBalancer should always contain
+      // attributes with its locality, including endpoints in LOGICAL_DNS clusters.
+      // In case of not (which really shouldn't), loads are aggregated under an empty
+      // locality.
+      if (locality == null) {
+        locality = Locality.create("", "", "");
+        localityName = "";
+      }
+
+      final ClusterLocalityStats localityStats =
+          (lrsServerInfo == null)
+              ? null
+              : xdsClient.addClusterLocalityStats(lrsServerInfo, cluster,
+                  edsServiceName, locality, backendMetricPropagation);
+
+      return new ClusterLocality(localityStats, localityName);
+    }
+
+    @Override
+    protected Helper delegate()  {
+      return helper;
+    }
+
+    private void updateDropPolicies(List<DropOverload> dropOverloads) {
+      if (!dropPolicies.equals(dropOverloads)) {
+        dropPolicies = dropOverloads;
+        updateBalancingState(currentState, currentPicker);
+      }
+    }
+
+    private void updateMaxConcurrentRequests(@Nullable Long maxConcurrentRequests) {
+      if (Objects.equals(this.maxConcurrentRequests, maxConcurrentRequests)) {
+        return;
+      }
+      this.maxConcurrentRequests =
+          maxConcurrentRequests != null
+              ? maxConcurrentRequests
+              : DEFAULT_PER_CLUSTER_MAX_CONCURRENT_REQUESTS;
+      updateBalancingState(currentState, currentPicker);
+    }
+
+    private void updateSslContextProviderSupplier(@Nullable UpstreamTlsContext tlsContext) {
+      UpstreamTlsContext currentTlsContext =
+          sslContextProviderSupplier != null
+              ? (UpstreamTlsContext)sslContextProviderSupplier.getTlsContext()
+              : null;
+      if (Objects.equals(currentTlsContext,  tlsContext)) {
+        return;
+      }
+      if (sslContextProviderSupplier != null) {
+        sslContextProviderSupplier.close();
+      }
+      sslContextProviderSupplier =
+          tlsContext != null
+              ? new SslContextProviderSupplier(tlsContext,
+                                               (TlsContextManager) xdsClient.getSecurityConfig())
+              : null;
+    }
+
+    private void updateFilterMetadata(Map<String, Struct> filterMetadata) {
+      this.filterMetadata = ImmutableMap.copyOf(filterMetadata);
+    }
+
+    private void updateBackendMetricPropagation(
+        @Nullable BackendMetricPropagation backendMetricPropagation) {
+      this.backendMetricPropagation = backendMetricPropagation;
+    }
+
+    private class RequestLimitingSubchannelPicker extends SubchannelPicker {
+      private final SubchannelPicker delegate;
+      private final List<DropOverload> dropPolicies;
+      private final long maxConcurrentRequests;
+      private final Map<String, Struct> filterMetadata;
+
+      private RequestLimitingSubchannelPicker(SubchannelPicker delegate,
+          List<DropOverload> dropPolicies, long maxConcurrentRequests,
+          Map<String, Struct> filterMetadata) {
+        this.delegate = delegate;
+        this.dropPolicies = dropPolicies;
+        this.maxConcurrentRequests = maxConcurrentRequests;
+        this.filterMetadata = checkNotNull(filterMetadata, "filterMetadata");
+      }
+
+      @Override
+      public PickResult pickSubchannel(PickSubchannelArgs args) {
+        args.getCallOptions().getOption(ClusterImplLoadBalancerProvider.FILTER_METADATA_CONSUMER)
+            .accept(filterMetadata);
+        args.getPickDetailsConsumer().addOptionalLabel("grpc.lb.backend_service", cluster);
+        for (DropOverload dropOverload : dropPolicies) {
+          int rand = random.nextInt(1_000_000);
+          if (rand < dropOverload.dropsPerMillion()) {
+            logger.log(XdsLogLevel.INFO, "Drop request with category: {0}",
+                dropOverload.category());
+            if (dropStats != null) {
+              dropStats.recordDroppedRequest(dropOverload.category());
+            }
+            return PickResult.withDrop(
+                Status.UNAVAILABLE.withDescription("Dropped: " + dropOverload.category()));
+          }
+        }
+        PickResult result = delegate.pickSubchannel(args);
+        if (result.getStatus().isOk() && result.getSubchannel() != null) {
+          if (enableCircuitBreaking) {
+            if (inFlights.get() >= maxConcurrentRequests) {
+              if (dropStats != null) {
+                dropStats.recordDroppedRequest();
+              }
+              return PickResult.withDrop(Status.UNAVAILABLE.withDescription(
+                  String.format(Locale.US, "Cluster max concurrent requests limit of %d exceeded",
+                      maxConcurrentRequests)));
+            }
+          }
+          final AtomicReference<ClusterLocality> clusterLocality =
+              result.getSubchannel().getAttributes().get(ATTR_CLUSTER_LOCALITY);
+
+          if (clusterLocality != null) {
+            ClusterLocalityStats stats = clusterLocality.get().getClusterLocalityStats();
+            if (stats != null) {
+              String localityName =
+                  result.getSubchannel().getAttributes().get(ATTR_CLUSTER_LOCALITY).get()
+                      .getClusterLocalityName();
+              args.getPickDetailsConsumer().addOptionalLabel("grpc.lb.locality", localityName);
+
+              ClientStreamTracer.Factory tracerFactory = new CountingStreamTracerFactory(
+                  stats, inFlights, result.getStreamTracerFactory());
+              ClientStreamTracer.Factory orcaTracerFactory = OrcaPerRequestUtil.getInstance()
+                  .newOrcaClientStreamTracerFactory(tracerFactory, new OrcaPerRpcListener(stats));
+              result = PickResult.withSubchannel(result.getSubchannel(),
+                  orcaTracerFactory);
+            }
+          }
+          if (args.getCallOptions().getOption(XdsNameResolver.AUTO_HOST_REWRITE_KEY) != null
+              && args.getCallOptions().getOption(XdsNameResolver.AUTO_HOST_REWRITE_KEY)) {
+            result = PickResult.withSubchannel(result.getSubchannel(),
+                result.getStreamTracerFactory(),
+                result.getSubchannel().getAttributes().get(ATTR_SUBCHANNEL_ADDRESS_NAME));
+          }
+        }
+        return result;
+      }
+
+      @Override
+      public String toString() {
+        return MoreObjects.toStringHelper(this).add("delegate", delegate).toString();
+      }
+    }
+  }
+
+  private static final class CountingStreamTracerFactory extends
+      ClientStreamTracer.Factory {
+    private final ClusterLocalityStats stats;
+    private final AtomicLong inFlights;
+    @Nullable
+    private final ClientStreamTracer.Factory delegate;
+
+    private CountingStreamTracerFactory(
+        ClusterLocalityStats stats, AtomicLong inFlights,
+        @Nullable ClientStreamTracer.Factory delegate) {
+      this.stats = checkNotNull(stats, "stats");
+      this.inFlights = checkNotNull(inFlights, "inFlights");
+      this.delegate = delegate;
+    }
+
+    @Override
+    public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+      stats.recordCallStarted();
+      inFlights.incrementAndGet();
+      if (delegate == null) {
+        return new ClientStreamTracer() {
+          @Override
+          public void streamClosed(Status status) {
+            stats.recordCallFinished(status);
+            inFlights.decrementAndGet();
+          }
+        };
+      }
+      final ClientStreamTracer delegatedTracer = delegate.newClientStreamTracer(info, headers);
+      return new ForwardingClientStreamTracer() {
+        @Override
+        protected ClientStreamTracer delegate() {
+          return delegatedTracer;
+        }
+
+        @Override
+        public void streamClosed(Status status) {
+          stats.recordCallFinished(status);
+          inFlights.decrementAndGet();
+          delegate().streamClosed(status);
+        }
+      };
+    }
+  }
+
+  private static final class OrcaPerRpcListener implements OrcaPerRequestReportListener {
+
+    private final ClusterLocalityStats stats;
+
+    private OrcaPerRpcListener(ClusterLocalityStats stats) {
+      this.stats = checkNotNull(stats, "stats");
+    }
+
+    /**
+     * Copies ORCA metrics from {@link MetricReport} to {@link ClusterLocalityStats}
+     * such that they are included in the snapshot for the LRS report sent to the LRS server.
+     * This includes both top-level metrics (CPU, memory, application utilization) and named
+     * metrics, filtered according to the backend metric propagation configuration.
+     */
+    @Override
+    public void onLoadReport(MetricReport report) {
+      if (isEnabledOrcaLrsPropagation) {
+        stats.recordTopLevelMetrics(
+            report.getCpuUtilization(),
+            report.getMemoryUtilization(),
+            report.getApplicationUtilization());
+      }
+      stats.recordBackendLoadMetricStats(report.getNamedMetrics());
+    }
+  }
+
+  /**
+   * Represents the {@link ClusterLocalityStats} and network locality name of a cluster.
+   */
+  static final class ClusterLocality {
+    private final ClusterLocalityStats clusterLocalityStats;
+    private final String clusterLocalityName;
+
+    @VisibleForTesting
+    ClusterLocality(ClusterLocalityStats localityStats, String localityName) {
+      this.clusterLocalityStats = localityStats;
+      this.clusterLocalityName = localityName;
+    }
+
+    ClusterLocalityStats getClusterLocalityStats() {
+      return clusterLocalityStats;
+    }
+
+    String getClusterLocalityName() {
+      return clusterLocalityName;
+    }
+
+    @VisibleForTesting
+    void release() {
+      if (clusterLocalityStats != null) {
+        clusterLocalityStats.release();
+      }
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/ClusterImplLoadBalancerProvider.java b/xds/src/main/java/io/grpc/xds/ClusterImplLoadBalancerProvider.java
new file mode 100644
index 00000000000..f369c3b99b4
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/ClusterImplLoadBalancerProvider.java
@@ -0,0 +1,135 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Struct;
+import io.grpc.CallOptions;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.xds.Endpoints.DropOverload;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.client.BackendMetricPropagation;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import javax.annotation.Nullable;
+
+/**
+ * The provider for the cluster_impl load balancing policy. This class should not be directly
+ * referenced in code.  The policy should be accessed through
+ * {@link LoadBalancerRegistry#getProvider} with the name "cluster_impl_experimental".
+ */
+@Internal
+public final class ClusterImplLoadBalancerProvider extends LoadBalancerProvider {
+  /**
+   * Consumer of filter metadata from the cluster used by the call. Consumer may not modify map.
+   */
+  public static final CallOptions.Key<Consumer<Map<String, Struct>>> FILTER_METADATA_CONSUMER =
+      CallOptions.Key.createWithDefault("io.grpc.xds.internalFilterMetadataConsumer", (m) -> { });
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return XdsLbPolicies.CLUSTER_IMPL_POLICY_NAME;
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawLoadBalancingPolicyConfig) {
+    return ConfigOrError.fromError(
+        Status.INTERNAL.withDescription(getPolicyName() + " cannot be used from service config"));
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    return new ClusterImplLoadBalancer(helper);
+  }
+
+  static final class ClusterImplConfig {
+    // Name of the cluster.
+    final String cluster;
+    // Resource name used in discovering endpoints via EDS. Only valid for EDS clusters.
+    @Nullable
+    final String edsServiceName;
+    // Load report server info. Null if load reporting is disabled.
+    @Nullable
+    final ServerInfo lrsServerInfo;
+    // Cluster-level max concurrent request threshold. Null if not specified.
+    @Nullable
+    final Long maxConcurrentRequests;
+    // TLS context for connections to endpoints.
+    @Nullable
+    final UpstreamTlsContext tlsContext;
+    // Drop configurations.
+    final List<DropOverload> dropCategories;
+    // Provides the direct child policy and its config.
+    final Object childConfig;
+    final Map<String, Struct> filterMetadata;
+    @Nullable
+    final BackendMetricPropagation backendMetricPropagation;
+
+    ClusterImplConfig(String cluster, @Nullable String edsServiceName,
+        @Nullable ServerInfo lrsServerInfo, @Nullable Long maxConcurrentRequests,
+        List<DropOverload> dropCategories, Object childConfig,
+        @Nullable UpstreamTlsContext tlsContext, Map<String, Struct> filterMetadata,
+        @Nullable BackendMetricPropagation backendMetricPropagation) {
+      this.cluster = checkNotNull(cluster, "cluster");
+      this.edsServiceName = edsServiceName;
+      this.lrsServerInfo = lrsServerInfo;
+      this.maxConcurrentRequests = maxConcurrentRequests;
+      this.tlsContext = tlsContext;
+      this.filterMetadata = ImmutableMap.copyOf(filterMetadata);
+      this.dropCategories = Collections.unmodifiableList(
+          new ArrayList<>(checkNotNull(dropCategories, "dropCategories")));
+      this.childConfig = checkNotNull(childConfig, "childConfig");
+      this.backendMetricPropagation = backendMetricPropagation;
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("cluster", cluster)
+          .add("edsServiceName", edsServiceName)
+          .add("lrsServerInfo", lrsServerInfo)
+          .add("maxConcurrentRequests", maxConcurrentRequests)
+          // Exclude tlsContext as its string representation is cumbersome.
+          .add("dropCategories", dropCategories)
+          .add("childConfig", childConfig)
+          .toString();
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/ClusterManagerLoadBalancer.java b/xds/src/main/java/io/grpc/xds/ClusterManagerLoadBalancer.java
new file mode 100644
index 00000000000..22b5aaa7d73
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/ClusterManagerLoadBalancer.java
@@ -0,0 +1,263 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import io.grpc.ConnectivityState;
+import io.grpc.InternalLogId;
+import io.grpc.LoadBalancer;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.util.MultiChildLoadBalancer;
+import io.grpc.xds.ClusterManagerLoadBalancerProvider.ClusterManagerConfig;
+import io.grpc.xds.client.XdsLogger;
+import io.grpc.xds.client.XdsLogger.XdsLogLevel;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * The top-level load balancing policy for use in XDS.
+ * This policy does not immediately delete its children.  Instead, it marks them deactivated
+ * and starts a timer for deletion.  If a subsequent address update restores the child, then it is
+ * simply reactivated instead of built from scratch.  This is necessary because XDS can frequently
+ * remove and then add back a server as machines are rebooted or repurposed for load management.
+ *
+ * <p>Note that this LB does not automatically reconnect children who go into IDLE status
+ */
+class ClusterManagerLoadBalancer extends MultiChildLoadBalancer {
+
+  // 15 minutes is long enough for a reboot and the services to restart while not so long that
+  // many children are waiting for cleanup.
+  @VisibleForTesting
+  public static final int DELAYED_CHILD_DELETION_TIME_MINUTES = 15;
+  protected final SynchronizationContext syncContext;
+  private final ScheduledExecutorService timeService;
+  private final XdsLogger logger;
+  private ResolvedAddresses lastResolvedAddresses;
+
+  ClusterManagerLoadBalancer(Helper helper) {
+    super(helper);
+    this.syncContext = checkNotNull(helper.getSynchronizationContext(), "syncContext");
+    this.timeService = checkNotNull(helper.getScheduledExecutorService(), "timeService");
+    logger = XdsLogger.withLogId(
+        InternalLogId.allocate("cluster_manager-lb", helper.getAuthority()));
+
+    logger.log(XdsLogLevel.INFO, "Created");
+  }
+
+  @Override
+  protected ChildLbState createChildLbState(Object key) {
+    return new ClusterManagerLbState(key, GracefulSwitchLoadBalancerFactory.INSTANCE);
+  }
+
+  @Override
+  protected Map<Object, ResolvedAddresses> createChildAddressesMap(
+      ResolvedAddresses resolvedAddresses) {
+    lastResolvedAddresses = resolvedAddresses;
+
+    ClusterManagerConfig config = (ClusterManagerConfig)
+        resolvedAddresses.getLoadBalancingPolicyConfig();
+    logger.log(
+        XdsLogLevel.INFO,
+        "Received cluster_manager lb config: child names={0}", config.childPolicies.keySet());
+    Map<Object, ResolvedAddresses> childAddresses = new HashMap<>();
+
+    // Reactivate children with config; deactivate children without config
+    for (ChildLbState rawState : getChildLbStates()) {
+      ClusterManagerLbState state = (ClusterManagerLbState) rawState;
+      if (config.childPolicies.containsKey(state.getKey())) {
+        // Active child
+        if (state.deletionTimer != null) {
+          state.reactivateChild();
+        }
+      } else {
+        // Inactive child
+        if (state.deletionTimer == null) {
+          state.deactivateChild();
+        }
+        if (state.deletionTimer.isPending()) {
+          childAddresses.put(state.getKey(), null); // Preserve child, without config update
+        }
+      }
+    }
+
+    for (Map.Entry<String, Object> childPolicy : config.childPolicies.entrySet()) {
+      ResolvedAddresses addresses = resolvedAddresses.toBuilder()
+          .setLoadBalancingPolicyConfig(childPolicy.getValue())
+          .build();
+      childAddresses.put(childPolicy.getKey(), addresses);
+    }
+    return childAddresses;
+  }
+
+  /**
+   * Using the state of all children will calculate the current connectivity state,
+   * update currentConnectivityState, generate a picker and then call
+   * {@link Helper#updateBalancingState(ConnectivityState, SubchannelPicker)}.
+   */
+  @Override
+  protected void updateOverallBalancingState() {
+    ConnectivityState overallState = null;
+    final Map<Object, SubchannelPicker> childPickers = new HashMap<>();
+    for (ChildLbState childLbState : getChildLbStates()) {
+      if (((ClusterManagerLbState) childLbState).deletionTimer != null) {
+        continue;
+      }
+      childPickers.put(childLbState.getKey(), childLbState.getCurrentPicker());
+      overallState = aggregateState(overallState, childLbState.getCurrentState());
+    }
+
+    if (overallState != null) {
+      getHelper().updateBalancingState(overallState, getSubchannelPicker(childPickers));
+      currentConnectivityState = overallState;
+    }
+  }
+
+  protected SubchannelPicker getSubchannelPicker(Map<Object, SubchannelPicker> childPickers) {
+    return new SubchannelPicker() {
+      @Override
+      public PickResult pickSubchannel(PickSubchannelArgs args) {
+        String clusterName =
+            args.getCallOptions().getOption(XdsNameResolver.CLUSTER_SELECTION_KEY);
+        SubchannelPicker childPicker = childPickers.get(clusterName);
+        if (childPicker == null) {
+          return
+              PickResult.withError(
+                  Status.UNAVAILABLE.withDescription("CDS encountered error: unable to find "
+                      + "available subchannel for cluster " + clusterName));
+        }
+        return childPicker.pickSubchannel(args);
+      }
+
+      @Override
+      public String toString() {
+        return MoreObjects.toStringHelper(this).add("pickers", childPickers).toString();
+      }
+    };
+  }
+
+  @Override
+  public void handleNameResolutionError(Status error) {
+    logger.log(XdsLogLevel.WARNING, "Received name resolution error: {0}", error);
+    boolean gotoTransientFailure = true;
+    for (ChildLbState state : getChildLbStates()) {
+      if (((ClusterManagerLbState) state).deletionTimer == null) {
+        gotoTransientFailure = false;
+        state.getLb().handleNameResolutionError(error);
+      }
+    }
+    if (gotoTransientFailure) {
+      getHelper().updateBalancingState(
+          TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
+    }
+  }
+
+  /**
+   * This differs from the base class in the use of the deletion timer.  When it is deactivated,
+   * rather than immediately calling shutdown it starts a timer.  If shutdown or reactivate
+   * are called before the timer fires, the timer is canceled.  Otherwise, time timer calls shutdown
+   * and removes the child from the petiole policy when it is triggered.
+   */
+  private class ClusterManagerLbState extends ChildLbState {
+    @Nullable
+    ScheduledHandle deletionTimer;
+
+    public ClusterManagerLbState(Object key, LoadBalancer.Factory policyFactory) {
+      super(key, policyFactory);
+    }
+
+    @Override
+    protected ChildLbStateHelper createChildHelper() {
+      return new ClusterManagerChildHelper();
+    }
+
+    @Override
+    protected void shutdown() {
+      if (deletionTimer != null) {
+        deletionTimer.cancel();
+        deletionTimer = null;
+      }
+      super.shutdown();
+    }
+
+    void reactivateChild() {
+      assert deletionTimer != null;
+      deletionTimer.cancel();
+      deletionTimer = null;
+      logger.log(XdsLogLevel.DEBUG, "Child balancer {0} reactivated", getKey());
+    }
+
+    void deactivateChild() {
+      assert deletionTimer == null;
+
+      class DeletionTask implements Runnable {
+
+        @Override
+        public void run() {
+          acceptResolvedAddresses(lastResolvedAddresses);
+        }
+      }
+
+      deletionTimer =
+          syncContext.schedule(
+              new DeletionTask(),
+              DELAYED_CHILD_DELETION_TIME_MINUTES,
+              TimeUnit.MINUTES,
+              timeService);
+      logger.log(XdsLogLevel.DEBUG, "Child balancer {0} deactivated", getKey());
+    }
+
+    private class ClusterManagerChildHelper extends ChildLbStateHelper {
+      @Override
+      public void updateBalancingState(final ConnectivityState newState,
+                                       final SubchannelPicker newPicker) {
+        if (getCurrentState() == ConnectivityState.SHUTDOWN) {
+          return;
+        }
+
+        // Subchannel picker and state are saved, but will only be propagated to the channel
+        // when the child instance exits deactivated state.
+        setCurrentState(newState);
+        setCurrentPicker(newPicker);
+        // If we are already in the process of resolving addresses, the overall balancing state
+        // will be updated at the end of it, and we don't need to trigger that update here.
+        if (deletionTimer == null && !resolvingAddresses) {
+          updateOverallBalancingState();
+        }
+      }
+    }
+  }
+
+  static final class GracefulSwitchLoadBalancerFactory extends LoadBalancer.Factory {
+    static final LoadBalancer.Factory INSTANCE = new GracefulSwitchLoadBalancerFactory();
+
+    @Override
+    public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+      return new GracefulSwitchLoadBalancer(helper);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/ClusterManagerLoadBalancerProvider.java b/xds/src/main/java/io/grpc/xds/ClusterManagerLoadBalancerProvider.java
new file mode 100644
index 00000000000..7a7e16286f8
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/ClusterManagerLoadBalancerProvider.java
@@ -0,0 +1,144 @@
+/*
+ * 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.xds;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.JsonUtil;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import javax.annotation.Nullable;
+
+/**
+ * The provider for the cluster_manager load balancing policy. This class should not be directly
+ * referenced in code.  The policy should be accessed through
+ * {@link LoadBalancerRegistry#getProvider} with the name "cluster_manager_experimental".
+ */
+@Internal
+public class ClusterManagerLoadBalancerProvider extends LoadBalancerProvider {
+
+  @Nullable
+  private final LoadBalancerRegistry lbRegistry;
+
+  public ClusterManagerLoadBalancerProvider() {
+    this(null);
+  }
+
+  @VisibleForTesting
+  ClusterManagerLoadBalancerProvider(@Nullable LoadBalancerRegistry lbRegistry) {
+    this.lbRegistry = lbRegistry;
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return XdsLbPolicies.CLUSTER_MANAGER_POLICY_NAME;
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
+    Map<String, Object> parsedChildPolicies = new LinkedHashMap<>();
+    try {
+      Map<String, ?> childPolicies = JsonUtil.getObject(rawConfig, "childPolicy");
+      if (childPolicies == null || childPolicies.isEmpty()) {
+        return ConfigOrError.fromError(Status.INTERNAL.withDescription(
+            "No child policy provided for cluster_manager LB policy: " + rawConfig));
+      }
+      for (String name : childPolicies.keySet()) {
+        Map<String, ?> childPolicy = JsonUtil.getObject(childPolicies, name);
+        if (childPolicy == null) {
+          return ConfigOrError.fromError(Status.INTERNAL.withDescription(
+              "No config for child " + name + " in cluster_manager LB policy: " + rawConfig));
+        }
+        LoadBalancerRegistry registry =
+            lbRegistry != null ? lbRegistry : LoadBalancerRegistry.getDefaultRegistry();
+        ConfigOrError childConfig = GracefulSwitchLoadBalancer.parseLoadBalancingPolicyConfig(
+            JsonUtil.getListOfObjects(childPolicy, "lbPolicy"), registry);
+        if (childConfig.getError() != null) {
+          Status error = childConfig.getError();
+          return ConfigOrError.fromError(
+              Status.INTERNAL
+                  .withCause(error.getCause())
+                  .withDescription(error.getDescription())
+                  .augmentDescription("Failed to parse config for child " + name));
+        }
+        parsedChildPolicies.put(name, childConfig.getConfig());
+      }
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError(
+          Status.INTERNAL.withCause(e).withDescription(
+              "Failed to parse cluster_manager LB config: " + rawConfig));
+    }
+    return ConfigOrError.fromConfig(new ClusterManagerConfig(parsedChildPolicies));
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    return new ClusterManagerLoadBalancer(helper);
+  }
+
+  static class ClusterManagerConfig {
+    final Map<String, Object> childPolicies;
+
+    ClusterManagerConfig(Map<String, Object> childPolicies) {
+      this.childPolicies = Collections.unmodifiableMap(childPolicies);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (!(o instanceof ClusterManagerConfig)) {
+        return false;
+      }
+      ClusterManagerConfig config = (ClusterManagerConfig) o;
+      return Objects.equals(childPolicies, config.childPolicies);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(childPolicies);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("childPolicies", childPolicies)
+          .toString();
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/ClusterSpecifierPlugin.java b/xds/src/main/java/io/grpc/xds/ClusterSpecifierPlugin.java
new file mode 100644
index 00000000000..1a0d4a82c28
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/ClusterSpecifierPlugin.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2021 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.xds;
+
+import com.google.auto.value.AutoValue;
+import com.google.protobuf.Message;
+
+/**
+ * Defines the parsing functionality of a ClusterSpecifierPlugin as defined in the Enovy proto
+ * api/envoy/config/route/v3/route.proto.
+ */
+interface ClusterSpecifierPlugin {
+  /**
+   * The proto message types supported by this plugin. A plugin will be registered by each of its
+   * supported message types.
+   */
+  String[] typeUrls();
+
+  ConfigOrError<? extends PluginConfig> parsePlugin(Message rawProtoMessage);
+
+  /** Represents an opaque data structure holding configuration for a ClusterSpecifierPlugin. */
+  interface PluginConfig {
+    String typeUrl();
+  }
+
+  @AutoValue
+  abstract class NamedPluginConfig {
+    abstract String name();
+
+    abstract PluginConfig config();
+
+    static NamedPluginConfig create(String name, PluginConfig config) {
+      return new AutoValue_ClusterSpecifierPlugin_NamedPluginConfig(name, config);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/ClusterSpecifierPluginRegistry.java b/xds/src/main/java/io/grpc/xds/ClusterSpecifierPluginRegistry.java
new file mode 100644
index 00000000000..b81ee96b319
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/ClusterSpecifierPluginRegistry.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2021 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.xds;
+
+import com.google.common.annotations.VisibleForTesting;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+final class ClusterSpecifierPluginRegistry {
+  private static ClusterSpecifierPluginRegistry instance;
+
+  private final Map<String, ClusterSpecifierPlugin> supportedPlugins = new HashMap<>();
+
+  private ClusterSpecifierPluginRegistry() {}
+
+  static synchronized ClusterSpecifierPluginRegistry getDefaultRegistry() {
+    if (instance == null) {
+      instance = newRegistry().register(RouteLookupServiceClusterSpecifierPlugin.INSTANCE);
+    }
+    return instance;
+  }
+
+  @VisibleForTesting
+  static ClusterSpecifierPluginRegistry newRegistry() {
+    return new ClusterSpecifierPluginRegistry();
+  }
+
+  @VisibleForTesting
+  ClusterSpecifierPluginRegistry register(ClusterSpecifierPlugin... plugins) {
+    for (ClusterSpecifierPlugin plugin : plugins) {
+      for (String typeUrl : plugin.typeUrls()) {
+        supportedPlugins.put(typeUrl, plugin);
+      }
+    }
+    return this;
+  }
+
+  @Nullable
+  ClusterSpecifierPlugin get(String typeUrl) {
+    return supportedPlugins.get(typeUrl);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/ConfigOrError.java b/xds/src/main/java/io/grpc/xds/ConfigOrError.java
new file mode 100644
index 00000000000..e1235b5b544
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/ConfigOrError.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+// TODO(zdapeng): Unify with ClientXdsClient.StructOrError, or just have parseFilterConfig() throw
+//     certain types of Exception.
+final class ConfigOrError<T> {
+
+  /**
+   * Returns a {@link ConfigOrError} for the successfully converted data object.
+   */
+  static <T> ConfigOrError<T> fromConfig(T config) {
+    return new ConfigOrError<>(config);
+  }
+
+  /**
+   * Returns a {@link ConfigOrError} for the failure to convert the data object.
+   */
+  static <T> ConfigOrError<T> fromError(String errorDetail) {
+    return new ConfigOrError<>(errorDetail);
+  }
+
+  final String errorDetail;
+  final T config;
+
+  private ConfigOrError(T config) {
+    this.config = checkNotNull(config, "config");
+    this.errorDetail = null;
+  }
+
+  private ConfigOrError(String errorDetail) {
+    this.config = null;
+    this.errorDetail = checkNotNull(errorDetail, "errorDetail");
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/CsdsService.java b/xds/src/main/java/io/grpc/xds/CsdsService.java
new file mode 100644
index 00000000000..8c2fe333c15
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/CsdsService.java
@@ -0,0 +1,267 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Verify.verifyNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.protobuf.util.Timestamps;
+import io.envoyproxy.envoy.admin.v3.ClientResourceStatus;
+import io.envoyproxy.envoy.service.status.v3.ClientConfig;
+import io.envoyproxy.envoy.service.status.v3.ClientConfig.GenericXdsConfig;
+import io.envoyproxy.envoy.service.status.v3.ClientStatusDiscoveryServiceGrpc;
+import io.envoyproxy.envoy.service.status.v3.ClientStatusRequest;
+import io.envoyproxy.envoy.service.status.v3.ClientStatusResponse;
+import io.grpc.BindableService;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.internal.ObjectPool;
+import io.grpc.stub.StreamObserver;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsClient.ResourceMetadata;
+import io.grpc.xds.client.XdsClient.ResourceMetadata.ResourceMetadataStatus;
+import io.grpc.xds.client.XdsClient.ResourceMetadata.UpdateFailureState;
+import io.grpc.xds.client.XdsResourceType;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * The CSDS service provides information about the status of a running xDS client.
+ *
+ * <p><a href="https://github.com/envoyproxy/envoy/blob/main/api/envoy/service/status/v3/csds.proto">
+ * Client Status Discovery Service</a> is a service that exposes xDS config of a given client. See
+ * the full design at <a href="https://github.com/grpc/proposal/blob/master/A40-csds-support.md">
+ * gRFC A40: xDS Configuration Dump via Client Status Discovery Service in gRPC</a>.
+ *
+ * @since 1.37.0
+ */
+public final class CsdsService implements BindableService {
+  private static final Logger logger = Logger.getLogger(CsdsService.class.getName());
+  private final XdsClientPoolFactory xdsClientPoolFactory;
+  private final CsdsServiceInternal delegate = new CsdsServiceInternal();
+
+  @VisibleForTesting
+  CsdsService(XdsClientPoolFactory xdsClientPoolFactory) {
+    this.xdsClientPoolFactory = checkNotNull(xdsClientPoolFactory, "xdsClientPoolProvider");
+  }
+
+  private CsdsService() {
+    this(SharedXdsClientPoolProvider.getDefaultProvider());
+  }
+
+  /** Creates an instance. */
+  public static CsdsService newInstance() {
+    return new CsdsService();
+  }
+
+  @Override
+  public ServerServiceDefinition bindService() {
+    return delegate.bindService();
+  }
+
+  /** Hide protobuf from being exposed via the API. */
+  private final class CsdsServiceInternal
+      extends ClientStatusDiscoveryServiceGrpc.ClientStatusDiscoveryServiceImplBase {
+    @Override
+    public void fetchClientStatus(
+        ClientStatusRequest request, StreamObserver<ClientStatusResponse> responseObserver) {
+      if (handleRequest(request, responseObserver)) {
+        responseObserver.onCompleted();
+      }
+      // TODO(sergiitk): Add a case covering mutating handleRequest return false to true - to verify
+      //   that responseObserver.onCompleted() isn't erroneously called on error.
+    }
+
+    @Override
+    public StreamObserver<ClientStatusRequest> streamClientStatus(
+        final StreamObserver<ClientStatusResponse> responseObserver) {
+      return new StreamObserver<ClientStatusRequest>() {
+        @Override
+        public void onNext(ClientStatusRequest request) {
+          handleRequest(request, responseObserver);
+        }
+
+        @Override
+        public void onError(Throwable t) {
+          onCompleted();
+        }
+
+        @Override
+        public void onCompleted() {
+          responseObserver.onCompleted();
+        }
+      };
+    }
+  }
+
+  private boolean handleRequest(
+      ClientStatusRequest request, StreamObserver<ClientStatusResponse> responseObserver) {
+    StatusException error = null;
+
+    if (request.getNodeMatchersCount() > 0) {
+      error = new StatusException(
+          Status.INVALID_ARGUMENT.withDescription("node_matchers not supported"));
+    } else {
+      List<String> targets = xdsClientPoolFactory.getTargets();
+      List<ClientConfig> clientConfigs = new ArrayList<>(targets.size());
+
+      for (int i = 0; i < targets.size() && error == null; i++) {
+        try {
+          ClientConfig clientConfig = getConfigForRequest(targets.get(i));
+          if (clientConfig != null) {
+            clientConfigs.add(clientConfig);
+          }
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+          logger.log(Level.FINE, "Server interrupted while building CSDS config dump", e);
+          error = Status.ABORTED.withDescription("Thread interrupted").withCause(e).asException();
+        } catch (RuntimeException e) {
+          logger.log(Level.WARNING, "Unexpected error while building CSDS config dump", e);
+          error = Status.INTERNAL.withDescription("Unexpected internal error").withCause(e)
+              .asException();
+        }
+      }
+
+      try {
+        responseObserver.onNext(getStatusResponse(clientConfigs));
+      } catch (RuntimeException e) {
+        logger.log(Level.WARNING, "Unexpected error while processing CSDS config dump", e);
+        error = Status.INTERNAL.withDescription("Unexpected internal error").withCause(e)
+            .asException();
+      }
+    }
+
+    if (error == null) {
+      return true; // All clients reported without error
+    }
+    responseObserver.onError(error);
+    return false;
+  }
+
+  private ClientConfig getConfigForRequest(String target) throws InterruptedException {
+    ObjectPool<XdsClient> xdsClientPool = xdsClientPoolFactory.get(target);
+    if (xdsClientPool == null) {
+      return null;
+    }
+
+    XdsClient xdsClient = null;
+    try {
+      xdsClient = xdsClientPool.getObject();
+      return getClientConfigForXdsClient(xdsClient, target);
+    } finally {
+      if (xdsClient != null) {
+        xdsClientPool.returnObject(xdsClient);
+      }
+    }
+  }
+
+  private ClientStatusResponse getStatusResponse(List<ClientConfig> clientConfigs) {
+    if (clientConfigs.isEmpty()) {
+      return ClientStatusResponse.getDefaultInstance();
+    }
+    return ClientStatusResponse.newBuilder().addAllConfig(clientConfigs).build();
+  }
+
+  @VisibleForTesting
+  static ClientConfig getClientConfigForXdsClient(XdsClient xdsClient, String target)
+      throws InterruptedException {
+    ClientConfig.Builder builder = ClientConfig.newBuilder()
+        .setClientScope(target)
+        .setNode(xdsClient.getBootstrapInfo().node().toEnvoyProtoNode());
+
+    Map<XdsResourceType<?>, Map<String, ResourceMetadata>> metadataByType =
+        awaitSubscribedResourcesMetadata(xdsClient.getSubscribedResourcesMetadataSnapshot());
+
+    for (Map.Entry<XdsResourceType<?>, Map<String, ResourceMetadata>> metadataByTypeEntry
+        : metadataByType.entrySet()) {
+      XdsResourceType<?> type = metadataByTypeEntry.getKey();
+      Map<String, ResourceMetadata> metadataByResourceName = metadataByTypeEntry.getValue();
+      for (Map.Entry<String, ResourceMetadata> metadataEntry : metadataByResourceName.entrySet()) {
+        String resourceName = metadataEntry.getKey();
+        ResourceMetadata metadata = metadataEntry.getValue();
+        GenericXdsConfig.Builder genericXdsConfigBuilder = GenericXdsConfig.newBuilder()
+            .setTypeUrl(type.typeUrl())
+            .setName(resourceName)
+            .setClientStatus(metadataStatusToClientStatus(metadata.getStatus()));
+        if (metadata.getRawResource() != null) {
+          genericXdsConfigBuilder
+              .setVersionInfo(metadata.getVersion())
+              .setLastUpdated(Timestamps.fromNanos(metadata.getUpdateTimeNanos()))
+              .setXdsConfig(metadata.getRawResource());
+        }
+        if (metadata.getStatus() == ResourceMetadataStatus.NACKED) {
+          verifyNotNull(metadata.getErrorState(), "resource %s getErrorState", resourceName);
+          genericXdsConfigBuilder
+              .setErrorState(metadataUpdateFailureStateToProto(metadata.getErrorState()));
+        }
+        builder.addGenericXdsConfigs(genericXdsConfigBuilder);
+      }
+    }
+    return builder.build();
+  }
+
+  private static Map<XdsResourceType<?>, Map<String, ResourceMetadata>>
+      awaitSubscribedResourcesMetadata(
+      ListenableFuture<Map<XdsResourceType<?>, Map<String, ResourceMetadata>>> future)
+      throws InterruptedException {
+    try {
+      // Normally this shouldn't take long, but add some slack for cases like a cold JVM.
+      return future.get(20, TimeUnit.SECONDS);
+    } catch (ExecutionException | TimeoutException e) {
+      // For CSDS' purposes, the exact reason why metadata not loaded isn't important.
+      throw new RuntimeException(e);
+    }
+  }
+
+  @VisibleForTesting
+  static ClientResourceStatus metadataStatusToClientStatus(ResourceMetadataStatus status) {
+    switch (status) {
+      case UNKNOWN:
+        return ClientResourceStatus.UNKNOWN;
+      case DOES_NOT_EXIST:
+        return ClientResourceStatus.DOES_NOT_EXIST;
+      case REQUESTED:
+        return ClientResourceStatus.REQUESTED;
+      case ACKED:
+        return ClientResourceStatus.ACKED;
+      case NACKED:
+        return ClientResourceStatus.NACKED;
+      case TIMEOUT:
+        return ClientResourceStatus.TIMEOUT;
+      default:
+        throw new AssertionError("Unexpected ResourceMetadataStatus: " + status);
+    }
+  }
+
+  private static io.envoyproxy.envoy.admin.v3.UpdateFailureState metadataUpdateFailureStateToProto(
+      UpdateFailureState errorState) {
+    return io.envoyproxy.envoy.admin.v3.UpdateFailureState.newBuilder()
+        .setLastUpdateAttempt(Timestamps.fromNanos(errorState.getFailedUpdateTimeNanos()))
+        .setDetails(errorState.getFailedDetails())
+        .setVersionInfo(errorState.getFailedVersion())
+        .build();
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/Endpoints.java b/xds/src/main/java/io/grpc/xds/Endpoints.java
new file mode 100644
index 00000000000..dcb72f3e90d
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/Endpoints.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.net.InetAddresses;
+import io.grpc.EquivalentAddressGroup;
+import java.net.InetSocketAddress;
+import java.util.List;
+
+/** Locality and endpoint level load balancing configurations. */
+final class Endpoints {
+  private Endpoints() {}
+
+  /** Represents a group of endpoints belong to a single locality. */
+  @AutoValue
+  abstract static class LocalityLbEndpoints {
+    // Endpoints to be load balanced.
+    abstract ImmutableList<LbEndpoint> endpoints();
+
+    // Locality's weight for inter-locality load balancing. Guaranteed to be greater than 0.
+    abstract int localityWeight();
+
+    // Locality's priority level.
+    abstract int priority();
+
+    abstract ImmutableMap<String, Object> localityMetadata();
+
+    static LocalityLbEndpoints create(List<LbEndpoint> endpoints, int localityWeight,
+        int priority, ImmutableMap<String, Object> localityMetadata) {
+      checkArgument(localityWeight > 0, "localityWeight must be greater than 0");
+      return new AutoValue_Endpoints_LocalityLbEndpoints(
+          ImmutableList.copyOf(endpoints), localityWeight, priority, localityMetadata);
+    }
+  }
+
+  /** Represents a single endpoint to be load balanced. */
+  @AutoValue
+  abstract static class LbEndpoint {
+    // The endpoint address to be connected to.
+    abstract EquivalentAddressGroup eag();
+
+    // Endpoint's weight for load balancing. If unspecified, value of 0 is returned.
+    abstract int loadBalancingWeight();
+
+    // Whether the endpoint is healthy.
+    abstract boolean isHealthy();
+
+    abstract String hostname();
+
+    abstract ImmutableMap<String, Object> endpointMetadata();
+
+    static LbEndpoint create(EquivalentAddressGroup eag, int loadBalancingWeight,
+        boolean isHealthy, String hostname, ImmutableMap<String, Object> endpointMetadata) {
+      return new AutoValue_Endpoints_LbEndpoint(
+          eag, loadBalancingWeight, isHealthy, hostname, endpointMetadata);
+    }
+
+    // Only for testing.
+    @VisibleForTesting
+    static LbEndpoint create(String address, int port, int loadBalancingWeight, boolean isHealthy,
+        String hostname, ImmutableMap<String, Object> endpointMetadata) {
+      return LbEndpoint.create(
+          new EquivalentAddressGroup(new InetSocketAddress(InetAddresses.forString(address), port)),
+          loadBalancingWeight, isHealthy, hostname, endpointMetadata);
+    }
+  }
+
+  /** Represents a drop policy. */
+  @AutoValue
+  abstract static class DropOverload {
+    abstract String category();
+
+    abstract int dropsPerMillion();
+
+    static DropOverload create(String category, int dropsPerMillion) {
+      return new AutoValue_Endpoints_DropOverload(category, dropsPerMillion);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/EnvoyServerProtoData.java b/xds/src/main/java/io/grpc/xds/EnvoyServerProtoData.java
new file mode 100644
index 00000000000..01ef3d97b57
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/EnvoyServerProtoData.java
@@ -0,0 +1,443 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.util.Durations;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress.Protocol;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.grpc.Internal;
+import io.grpc.xds.client.EnvoyProtoData;
+import io.grpc.xds.internal.security.SslContextProviderSupplier;
+import java.net.InetAddress;
+import java.util.Objects;
+import javax.annotation.Nullable;
+
+/**
+ * Defines gRPC data types for Envoy protobuf messages used in xDS protocol on the server side,
+ * similar to how {@link EnvoyProtoData} defines it for the client side.
+ */
+@Internal
+public final class EnvoyServerProtoData {
+
+  // Prevent instantiation.
+  private EnvoyServerProtoData() {
+  }
+
+  public abstract static class BaseTlsContext {
+    protected final CommonTlsContext commonTlsContext;
+
+    protected BaseTlsContext(CommonTlsContext commonTlsContext) {
+      this.commonTlsContext = checkNotNull(commonTlsContext, "commonTlsContext cannot be null.");
+    }
+
+    public CommonTlsContext getCommonTlsContext() {
+      return commonTlsContext;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (!(o instanceof BaseTlsContext)) {
+        return false;
+      }
+      BaseTlsContext that = (BaseTlsContext) o;
+      return Objects.equals(commonTlsContext, that.commonTlsContext);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(commonTlsContext);
+    }
+  }
+
+  public static final class UpstreamTlsContext extends BaseTlsContext {
+
+    private final String sni;
+    private final boolean autoHostSni;
+    private final boolean autoSniSanValidation;
+
+    @VisibleForTesting
+    public UpstreamTlsContext(CommonTlsContext commonTlsContext) {
+      super(commonTlsContext);
+      this.sni = null;
+      this.autoHostSni = false;
+      this.autoSniSanValidation = false;
+    }
+
+    @VisibleForTesting
+    public UpstreamTlsContext(
+        io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext
+            upstreamTlsContext) {
+      super(upstreamTlsContext.getCommonTlsContext());
+      this.sni = upstreamTlsContext.getSni();
+      this.autoHostSni = upstreamTlsContext.getAutoHostSni();
+      this.autoSniSanValidation = upstreamTlsContext.getAutoSniSanValidation();
+    }
+
+    public static UpstreamTlsContext fromEnvoyProtoUpstreamTlsContext(
+        io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext
+            upstreamTlsContext) {
+      return new UpstreamTlsContext(upstreamTlsContext);
+    }
+
+    public String getSni() {
+      return sni;
+    }
+
+    public boolean getAutoHostSni() {
+      return autoHostSni;
+    }
+
+    public boolean getAutoSniSanValidation() {
+      return autoSniSanValidation;
+    }
+
+    @Override
+    public String toString() {
+      return "UpstreamTlsContext{"
+          + "commonTlsContext=" + commonTlsContext
+          + "\nsni=" + sni
+          + "\nauto_host_sni=" + autoHostSni
+          + "\nauto_sni_san_validation=" + autoSniSanValidation
+          + "}";
+    }
+  }
+
+  public static final class DownstreamTlsContext extends BaseTlsContext {
+
+    private final boolean requireClientCertificate;
+
+    @VisibleForTesting
+    public DownstreamTlsContext(
+        CommonTlsContext commonTlsContext, boolean requireClientCertificate) {
+      super(commonTlsContext);
+      this.requireClientCertificate = requireClientCertificate;
+    }
+
+    public static DownstreamTlsContext fromEnvoyProtoDownstreamTlsContext(
+        io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext
+            downstreamTlsContext) {
+      return new DownstreamTlsContext(downstreamTlsContext.getCommonTlsContext(),
+        downstreamTlsContext.hasRequireClientCertificate());
+    }
+
+    public boolean isRequireClientCertificate() {
+      return requireClientCertificate;
+    }
+
+    @Override
+    public String toString() {
+      return "DownstreamTlsContext{"
+          + "commonTlsContext="
+          + commonTlsContext
+          + ", requireClientCertificate="
+          + requireClientCertificate
+          + '}';
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      if (!super.equals(o)) {
+        return false;
+      }
+      DownstreamTlsContext that = (DownstreamTlsContext) o;
+      return requireClientCertificate == that.requireClientCertificate;
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(super.hashCode(), requireClientCertificate);
+    }
+  }
+
+  @AutoValue
+  abstract static class CidrRange {
+
+    abstract InetAddress addressPrefix();
+
+    abstract int prefixLen();
+
+    static CidrRange create(InetAddress addressPrefix, int prefixLen) {
+      return new AutoValue_EnvoyServerProtoData_CidrRange(
+          addressPrefix, prefixLen);
+    }
+  }
+
+  enum ConnectionSourceType {
+    // Any connection source matches.
+    ANY,
+
+    // Match a connection originating from the same host.
+    SAME_IP_OR_LOOPBACK,
+
+    // Match a connection originating from a different host.
+    EXTERNAL
+  }
+
+  /**
+   * Corresponds to Envoy proto message
+   * {@link io.envoyproxy.envoy.config.listener.v3.FilterChainMatch}.
+   */
+  @AutoValue
+  abstract static class FilterChainMatch {
+
+    abstract int destinationPort();
+
+    abstract ImmutableList<CidrRange> prefixRanges();
+
+    abstract ImmutableList<String> applicationProtocols();
+
+    abstract ImmutableList<CidrRange> sourcePrefixRanges();
+
+    abstract ConnectionSourceType connectionSourceType();
+
+    abstract ImmutableList<Integer> sourcePorts();
+
+    abstract ImmutableList<String> serverNames();
+
+    abstract String transportProtocol();
+
+    public static FilterChainMatch create(int destinationPort,
+        ImmutableList<CidrRange> prefixRanges,
+        ImmutableList<String> applicationProtocols, ImmutableList<CidrRange> sourcePrefixRanges,
+        ConnectionSourceType connectionSourceType, ImmutableList<Integer> sourcePorts,
+        ImmutableList<String> serverNames, String transportProtocol) {
+      return new AutoValue_EnvoyServerProtoData_FilterChainMatch(
+          destinationPort, prefixRanges, applicationProtocols, sourcePrefixRanges,
+          connectionSourceType, sourcePorts, serverNames, transportProtocol);
+    }
+  }
+
+  /**
+   * Corresponds to Envoy proto message {@link io.envoyproxy.envoy.config.listener.v3.FilterChain}.
+   */
+  @AutoValue
+  abstract static class FilterChain {
+
+    // Must be unique per server instance (except the default chain).
+    abstract String name();
+
+    // TODO(sanjaypujare): flatten structure by moving FilterChainMatch class members here.
+    abstract FilterChainMatch filterChainMatch();
+
+    abstract HttpConnectionManager httpConnectionManager();
+
+    @Nullable
+    abstract SslContextProviderSupplier sslContextProviderSupplier();
+
+    static FilterChain create(
+        String name,
+        FilterChainMatch filterChainMatch,
+        HttpConnectionManager httpConnectionManager,
+        @Nullable DownstreamTlsContext downstreamTlsContext,
+        TlsContextManager tlsContextManager) {
+      SslContextProviderSupplier sslContextProviderSupplier =
+          downstreamTlsContext == null
+              ? null : new SslContextProviderSupplier(downstreamTlsContext, tlsContextManager);
+      return new AutoValue_EnvoyServerProtoData_FilterChain(
+          name, filterChainMatch, httpConnectionManager, sslContextProviderSupplier);
+    }
+  }
+
+  /**
+   * Corresponds to Envoy proto message {@link io.envoyproxy.envoy.config.listener.v3.Listener} and
+   * related classes.
+   */
+  @AutoValue
+  abstract static class Listener {
+
+    abstract String name();
+
+    @Nullable
+    abstract String address();
+
+    abstract ImmutableList<FilterChain> filterChains();
+
+    @Nullable
+    abstract FilterChain defaultFilterChain();
+
+    @Nullable
+    abstract Protocol protocol();
+
+    static Listener create(
+        String name,
+        @Nullable String address,
+        ImmutableList<FilterChain> filterChains,
+        @Nullable FilterChain defaultFilterChain,
+        @Nullable Protocol protocol) {
+      return new AutoValue_EnvoyServerProtoData_Listener(name, address, filterChains,
+          defaultFilterChain, protocol);
+    }
+  }
+
+  /**
+   * Corresponds to Envoy proto message {@link
+   * io.envoyproxy.envoy.config.cluster.v3.OutlierDetection}. Only the fields supported by gRPC are
+   * included.
+   *
+   * <p>Protobuf Duration fields are represented in their string format (e.g. "10s").
+   */
+  @AutoValue
+  abstract static class OutlierDetection {
+
+    @Nullable
+    abstract Long intervalNanos();
+
+    @Nullable
+    abstract Long baseEjectionTimeNanos();
+
+    @Nullable
+    abstract Long maxEjectionTimeNanos();
+
+    @Nullable
+    abstract Integer maxEjectionPercent();
+
+    @Nullable
+    abstract SuccessRateEjection successRateEjection();
+
+    @Nullable
+    abstract FailurePercentageEjection failurePercentageEjection();
+
+    static OutlierDetection create(
+        @Nullable Long intervalNanos,
+        @Nullable Long baseEjectionTimeNanos,
+        @Nullable Long maxEjectionTimeNanos,
+        @Nullable Integer maxEjectionPercentage,
+        @Nullable SuccessRateEjection successRateEjection,
+        @Nullable FailurePercentageEjection failurePercentageEjection) {
+      return new AutoValue_EnvoyServerProtoData_OutlierDetection(intervalNanos,
+          baseEjectionTimeNanos, maxEjectionTimeNanos, maxEjectionPercentage, successRateEjection,
+          failurePercentageEjection);
+    }
+
+    static OutlierDetection fromEnvoyOutlierDetection(
+        io.envoyproxy.envoy.config.cluster.v3.OutlierDetection envoyOutlierDetection) {
+
+      Long intervalNanos = envoyOutlierDetection.hasInterval()
+          ? Durations.toNanos(envoyOutlierDetection.getInterval()) : null;
+      Long baseEjectionTimeNanos = envoyOutlierDetection.hasBaseEjectionTime()
+          ? Durations.toNanos(envoyOutlierDetection.getBaseEjectionTime()) : null;
+      Long maxEjectionTimeNanos = envoyOutlierDetection.hasMaxEjectionTime()
+          ? Durations.toNanos(envoyOutlierDetection.getMaxEjectionTime()) : null;
+      Integer maxEjectionPercentage = envoyOutlierDetection.hasMaxEjectionPercent()
+          ? envoyOutlierDetection.getMaxEjectionPercent().getValue() : null;
+
+      SuccessRateEjection successRateEjection;
+      // If success rate enforcement has been turned completely off, don't configure this ejection.
+      if (envoyOutlierDetection.hasEnforcingSuccessRate()
+          && envoyOutlierDetection.getEnforcingSuccessRate().getValue() == 0) {
+        successRateEjection = null;
+      } else {
+        Integer stdevFactor = envoyOutlierDetection.hasSuccessRateStdevFactor()
+            ? envoyOutlierDetection.getSuccessRateStdevFactor().getValue() : null;
+        Integer enforcementPercentage = envoyOutlierDetection.hasEnforcingSuccessRate()
+            ? envoyOutlierDetection.getEnforcingSuccessRate().getValue() : null;
+        Integer minimumHosts = envoyOutlierDetection.hasSuccessRateMinimumHosts()
+            ? envoyOutlierDetection.getSuccessRateMinimumHosts().getValue() : null;
+        Integer requestVolume = envoyOutlierDetection.hasSuccessRateRequestVolume()
+            ? envoyOutlierDetection.getSuccessRateRequestVolume().getValue() : null;
+
+        successRateEjection = SuccessRateEjection.create(stdevFactor, enforcementPercentage,
+            minimumHosts, requestVolume);
+      }
+
+      FailurePercentageEjection failurePercentageEjection;
+      if (envoyOutlierDetection.hasEnforcingFailurePercentage()
+          && envoyOutlierDetection.getEnforcingFailurePercentage().getValue() == 0) {
+        failurePercentageEjection = null;
+      } else {
+        Integer threshold = envoyOutlierDetection.hasFailurePercentageThreshold()
+            ? envoyOutlierDetection.getFailurePercentageThreshold().getValue() : null;
+        Integer enforcementPercentage = envoyOutlierDetection.hasEnforcingFailurePercentage()
+            ? envoyOutlierDetection.getEnforcingFailurePercentage().getValue() : null;
+        Integer minimumHosts = envoyOutlierDetection.hasFailurePercentageMinimumHosts()
+            ? envoyOutlierDetection.getFailurePercentageMinimumHosts().getValue() : null;
+        Integer requestVolume = envoyOutlierDetection.hasFailurePercentageRequestVolume()
+            ? envoyOutlierDetection.getFailurePercentageRequestVolume().getValue() : null;
+
+        failurePercentageEjection = FailurePercentageEjection.create(threshold,
+            enforcementPercentage, minimumHosts, requestVolume);
+      }
+
+      return create(intervalNanos, baseEjectionTimeNanos, maxEjectionTimeNanos,
+          maxEjectionPercentage, successRateEjection, failurePercentageEjection);
+    }
+  }
+
+  @AutoValue
+  abstract static class SuccessRateEjection {
+
+    @Nullable
+    abstract Integer stdevFactor();
+
+    @Nullable
+    abstract Integer enforcementPercentage();
+
+    @Nullable
+    abstract Integer minimumHosts();
+
+    @Nullable
+    abstract Integer requestVolume();
+
+    static SuccessRateEjection create(
+        @Nullable Integer stdevFactor,
+        @Nullable Integer enforcementPercentage,
+        @Nullable Integer minimumHosts,
+        @Nullable Integer requestVolume) {
+      return new AutoValue_EnvoyServerProtoData_SuccessRateEjection(stdevFactor,
+          enforcementPercentage, minimumHosts, requestVolume);
+    }
+  }
+
+  @AutoValue
+  abstract static class FailurePercentageEjection {
+
+    @Nullable
+    abstract Integer threshold();
+
+    @Nullable
+    abstract Integer enforcementPercentage();
+
+    @Nullable
+    abstract Integer minimumHosts();
+
+    @Nullable
+    abstract Integer requestVolume();
+
+    static FailurePercentageEjection create(
+        @Nullable Integer threshold,
+        @Nullable Integer enforcementPercentage,
+        @Nullable Integer minimumHosts,
+        @Nullable Integer requestVolume) {
+      return new AutoValue_EnvoyServerProtoData_FailurePercentageEjection(threshold,
+          enforcementPercentage, minimumHosts, requestVolume);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/FaultConfig.java b/xds/src/main/java/io/grpc/xds/FaultConfig.java
new file mode 100644
index 00000000000..95a1cd47044
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/FaultConfig.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.auto.value.AutoValue;
+import io.grpc.Status;
+import io.grpc.xds.Filter.FilterConfig;
+import javax.annotation.Nullable;
+
+/** Fault injection configurations. */
+@AutoValue
+abstract class FaultConfig implements FilterConfig {
+  @Nullable
+  abstract FaultDelay faultDelay();
+
+  @Nullable
+  abstract FaultAbort faultAbort();
+
+  @Nullable
+  abstract Integer maxActiveFaults();
+
+  @Override
+  public final String typeUrl() {
+    return FaultFilter.TYPE_URL;
+  }
+
+  static FaultConfig create(
+      @Nullable FaultDelay faultDelay, @Nullable FaultAbort faultAbort,
+      @Nullable Integer maxActiveFaults) {
+    return new AutoValue_FaultConfig(faultDelay, faultAbort, maxActiveFaults);
+  }
+
+  /** Fault configurations for aborting requests. */
+  @AutoValue
+  abstract static class FaultDelay {
+    @Nullable
+    abstract Long delayNanos();
+
+    abstract boolean headerDelay();
+
+    abstract FractionalPercent percent();
+
+    static FaultDelay forFixedDelay(long delayNanos, FractionalPercent percent) {
+      return FaultDelay.create(delayNanos, false, percent);
+    }
+
+    static FaultDelay forHeader(FractionalPercent percentage) {
+      return FaultDelay.create(null, true, percentage);
+    }
+
+    private static FaultDelay create(
+        @Nullable Long delayNanos, boolean headerDelay, FractionalPercent percent) {
+      return new AutoValue_FaultConfig_FaultDelay(delayNanos, headerDelay, percent);
+    }
+  }
+
+  /** Fault configurations for delaying requests. */
+  @AutoValue
+  abstract static class FaultAbort {
+    @Nullable
+    abstract Status status();
+
+    abstract boolean headerAbort();
+
+    abstract FractionalPercent percent();
+
+    static FaultAbort forStatus(Status status, FractionalPercent percent) {
+      checkNotNull(status, "status");
+      return FaultAbort.create(status, false, percent);
+    }
+
+    static FaultAbort forHeader(FractionalPercent percent) {
+      return FaultAbort.create(null, true, percent);
+    }
+
+    private static FaultAbort create(
+        @Nullable Status status, boolean headerAbort, FractionalPercent percent) {
+      return new AutoValue_FaultConfig_FaultAbort(status, headerAbort, percent);
+    }
+  }
+
+  @AutoValue
+  abstract static class FractionalPercent {
+    enum DenominatorType {
+      HUNDRED, TEN_THOUSAND, MILLION
+    }
+
+    abstract int numerator();
+
+    abstract DenominatorType denominatorType();
+
+    static FractionalPercent perHundred(int numerator) {
+      return FractionalPercent.create(numerator, DenominatorType.HUNDRED);
+    }
+
+    static FractionalPercent perTenThousand(int numerator) {
+      return FractionalPercent.create(numerator, DenominatorType.TEN_THOUSAND);
+    }
+
+    static FractionalPercent perMillion(int numerator) {
+      return FractionalPercent.create(numerator, DenominatorType.MILLION);
+    }
+
+    static FractionalPercent create(
+        int numerator, DenominatorType denominatorType) {
+      return new AutoValue_FaultConfig_FractionalPercent(numerator, denominatorType);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/FaultFilter.java b/xds/src/main/java/io/grpc/xds/FaultFilter.java
new file mode 100644
index 00000000000..0f3bb5b0557
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/FaultFilter.java
@@ -0,0 +1,497 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Supplier;
+import com.google.common.base.Suppliers;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.Any;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Message;
+import com.google.protobuf.util.Durations;
+import io.envoyproxy.envoy.extensions.filters.http.fault.v3.HTTPFault;
+import io.envoyproxy.envoy.type.v3.FractionalPercent;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.Context;
+import io.grpc.Deadline;
+import io.grpc.ForwardingClientCall;
+import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.internal.DelayedClientCall;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.xds.FaultConfig.FaultAbort;
+import io.grpc.xds.FaultConfig.FaultDelay;
+import io.grpc.xds.ThreadSafeRandom.ThreadSafeRandomImpl;
+import java.util.Locale;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import javax.annotation.Nullable;
+
+/** HttpFault filter implementation. */
+final class FaultFilter implements Filter {
+
+  private static final FaultFilter INSTANCE =
+      new FaultFilter(ThreadSafeRandomImpl.instance, new AtomicLong());
+
+  @VisibleForTesting
+  static final Metadata.Key<String> HEADER_DELAY_KEY =
+      Metadata.Key.of("x-envoy-fault-delay-request", Metadata.ASCII_STRING_MARSHALLER);
+  @VisibleForTesting
+  static final Metadata.Key<String> HEADER_DELAY_PERCENTAGE_KEY =
+      Metadata.Key.of("x-envoy-fault-delay-request-percentage", Metadata.ASCII_STRING_MARSHALLER);
+  @VisibleForTesting
+  static final Metadata.Key<String> HEADER_ABORT_HTTP_STATUS_KEY =
+      Metadata.Key.of("x-envoy-fault-abort-request", Metadata.ASCII_STRING_MARSHALLER);
+  @VisibleForTesting
+  static final Metadata.Key<String> HEADER_ABORT_GRPC_STATUS_KEY =
+      Metadata.Key.of("x-envoy-fault-abort-grpc-request", Metadata.ASCII_STRING_MARSHALLER);
+  @VisibleForTesting
+  static final Metadata.Key<String> HEADER_ABORT_PERCENTAGE_KEY =
+      Metadata.Key.of("x-envoy-fault-abort-request-percentage", Metadata.ASCII_STRING_MARSHALLER);
+  static final String TYPE_URL =
+      "type.googleapis.com/envoy.extensions.filters.http.fault.v3.HTTPFault";
+
+  private final ThreadSafeRandom random;
+  private final AtomicLong activeFaultCounter;
+
+  @VisibleForTesting
+  FaultFilter(ThreadSafeRandom random, AtomicLong activeFaultCounter) {
+    this.random = random;
+    this.activeFaultCounter = activeFaultCounter;
+  }
+
+  static final class Provider implements Filter.Provider {
+    @Override
+    public String[] typeUrls() {
+      return new String[]{TYPE_URL};
+    }
+
+    @Override
+    public boolean isClientFilter() {
+      return true;
+    }
+
+    @Override
+    public FaultFilter newInstance(String name) {
+      return INSTANCE;
+    }
+
+    @Override
+    public ConfigOrError<FaultConfig> parseFilterConfig(Message rawProtoMessage) {
+      HTTPFault httpFaultProto;
+      if (!(rawProtoMessage instanceof Any)) {
+        return ConfigOrError.fromError("Invalid config type: " + rawProtoMessage.getClass());
+      }
+      Any anyMessage = (Any) rawProtoMessage;
+      try {
+        httpFaultProto = anyMessage.unpack(HTTPFault.class);
+      } catch (InvalidProtocolBufferException e) {
+        return ConfigOrError.fromError("Invalid proto: " + e);
+      }
+      return parseHttpFault(httpFaultProto);
+    }
+
+    @Override
+    public ConfigOrError<FaultConfig> parseFilterConfigOverride(Message rawProtoMessage) {
+      return parseFilterConfig(rawProtoMessage);
+    }
+
+    private static ConfigOrError<FaultConfig> parseHttpFault(HTTPFault httpFault) {
+      FaultDelay faultDelay = null;
+      FaultAbort faultAbort = null;
+      if (httpFault.hasDelay()) {
+        faultDelay = parseFaultDelay(httpFault.getDelay());
+      }
+      if (httpFault.hasAbort()) {
+        ConfigOrError<FaultAbort> faultAbortOrError = parseFaultAbort(httpFault.getAbort());
+        if (faultAbortOrError.errorDetail != null) {
+          return ConfigOrError.fromError(
+              "HttpFault contains invalid FaultAbort: " + faultAbortOrError.errorDetail);
+        }
+        faultAbort = faultAbortOrError.config;
+      }
+      Integer maxActiveFaults = null;
+      if (httpFault.hasMaxActiveFaults()) {
+        maxActiveFaults = httpFault.getMaxActiveFaults().getValue();
+        if (maxActiveFaults < 0) {
+          maxActiveFaults = Integer.MAX_VALUE;
+        }
+      }
+      return ConfigOrError.fromConfig(FaultConfig.create(faultDelay, faultAbort, maxActiveFaults));
+    }
+
+    private static FaultDelay parseFaultDelay(
+        io.envoyproxy.envoy.extensions.filters.common.fault.v3.FaultDelay faultDelay) {
+      FaultConfig.FractionalPercent percent = parsePercent(faultDelay.getPercentage());
+      if (faultDelay.hasHeaderDelay()) {
+        return FaultDelay.forHeader(percent);
+      }
+      return FaultDelay.forFixedDelay(Durations.toNanos(faultDelay.getFixedDelay()), percent);
+    }
+
+    @VisibleForTesting
+    static ConfigOrError<FaultAbort> parseFaultAbort(
+        io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort faultAbort) {
+      FaultConfig.FractionalPercent percent = parsePercent(faultAbort.getPercentage());
+      switch (faultAbort.getErrorTypeCase()) {
+        case HEADER_ABORT:
+          return ConfigOrError.fromConfig(FaultAbort.forHeader(percent));
+        case HTTP_STATUS:
+          return ConfigOrError.fromConfig(FaultAbort.forStatus(
+              GrpcUtil.httpStatusToGrpcStatus(faultAbort.getHttpStatus()), percent));
+        case GRPC_STATUS:
+          return ConfigOrError.fromConfig(FaultAbort.forStatus(
+              Status.fromCodeValue(faultAbort.getGrpcStatus()), percent));
+        case ERRORTYPE_NOT_SET:
+        default:
+          return ConfigOrError.fromError(
+              "Unknown error type case: " + faultAbort.getErrorTypeCase());
+      }
+    }
+
+    private static FaultConfig.FractionalPercent parsePercent(FractionalPercent proto) {
+      switch (proto.getDenominator()) {
+        case HUNDRED:
+          return FaultConfig.FractionalPercent.perHundred(proto.getNumerator());
+        case TEN_THOUSAND:
+          return FaultConfig.FractionalPercent.perTenThousand(proto.getNumerator());
+        case MILLION:
+          return FaultConfig.FractionalPercent.perMillion(proto.getNumerator());
+        case UNRECOGNIZED:
+        default:
+          throw new IllegalArgumentException("Unknown denominator type: " + proto.getDenominator());
+      }
+    }
+  }
+
+  @Nullable
+  @Override
+  public ClientInterceptor buildClientInterceptor(
+      FilterConfig config, @Nullable FilterConfig overrideConfig,
+      final ScheduledExecutorService scheduler) {
+    checkNotNull(config, "config");
+    if (overrideConfig != null) {
+      config = overrideConfig;
+    }
+    FaultConfig faultConfig = (FaultConfig) config;
+
+    final class FaultInjectionInterceptor implements ClientInterceptor {
+      @Override
+      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+          final MethodDescriptor<ReqT, RespT> method, final CallOptions callOptions,
+          final Channel next) {
+        boolean checkFault = false;
+        if (faultConfig.maxActiveFaults() == null
+            || activeFaultCounter.get() < faultConfig.maxActiveFaults()) {
+          checkFault = faultConfig.faultDelay() != null || faultConfig.faultAbort() != null;
+        }
+        if (!checkFault) {
+          return next.newCall(method, callOptions);
+        }
+        final class DeadlineInsightForwardingCall extends ForwardingClientCall<ReqT, RespT> {
+          private ClientCall<ReqT, RespT> delegate;
+
+          @Override
+          protected ClientCall<ReqT, RespT> delegate() {
+            return delegate;
+          }
+
+          @Override
+          public void start(Listener<RespT> listener, Metadata headers) {
+            Executor callExecutor = callOptions.getExecutor();
+            if (callExecutor == null) { // This should never happen in practice because
+              // ManagedChannelImpl.ConfigSelectingClientCall always provides CallOptions with
+              // a callExecutor.
+              // TODO(https://github.com/grpc/grpc-java/issues/7868)
+              callExecutor = MoreExecutors.directExecutor();
+            }
+
+            Long delayNanos;
+            Status abortStatus = null;
+            if (faultConfig.faultDelay() != null) {
+              delayNanos = determineFaultDelayNanos(faultConfig.faultDelay(), headers);
+            } else {
+              delayNanos = null;
+            }
+            if (faultConfig.faultAbort() != null) {
+              abortStatus = getAbortStatusWithDescription(
+                  determineFaultAbortStatus(faultConfig.faultAbort(), headers));
+            }
+
+            Supplier<? extends ClientCall<ReqT, RespT>> callSupplier;
+            if (abortStatus != null) {
+              callSupplier = Suppliers.ofInstance(
+                  new FailingClientCall<ReqT, RespT>(abortStatus, callExecutor));
+            } else {
+              callSupplier = new Supplier<ClientCall<ReqT, RespT>>() {
+                @Override
+                public ClientCall<ReqT, RespT> get() {
+                  return next.newCall(method, callOptions);
+                }
+              };
+            }
+            if (delayNanos == null) {
+              delegate = callSupplier.get();
+              delegate().start(listener, headers);
+              return;
+            }
+
+            delegate = new DelayInjectedCall<>(
+                delayNanos, callExecutor, scheduler, callOptions.getDeadline(), callSupplier);
+
+            Listener<RespT> finalListener =
+                new SimpleForwardingClientCallListener<RespT>(listener) {
+                  @Override
+                  public void onClose(Status status, Metadata trailers) {
+                    if (status.getCode().equals(Code.DEADLINE_EXCEEDED)) {
+                      // TODO(zdapeng:) check effective deadline locally, and
+                      //   do the following only if the local deadline is exceeded.
+                      //   (If the server sends DEADLINE_EXCEEDED for its own deadline, then the
+                      //   injected delay does not contribute to the error, because the request is
+                      //   only sent out after the delay. There could be a race between local and
+                      //   remote, but it is rather rare.)
+                      String description = String.format(
+                          Locale.US,
+                          "Deadline exceeded after up to %d ns of fault-injected delay",
+                          delayNanos);
+                      if (status.getDescription() != null) {
+                        description = description + ": " + status.getDescription();
+                      }
+                      status = Status.DEADLINE_EXCEEDED
+                          .withDescription(description).withCause(status.getCause());
+                      // Replace trailers to prevent mixing sources of status and trailers.
+                      trailers = new Metadata();
+                    }
+                    delegate().onClose(status, trailers);
+                  }
+                };
+            delegate().start(finalListener, headers);
+          }
+        }
+
+        return new DeadlineInsightForwardingCall();
+      }
+    }
+
+    return new FaultInjectionInterceptor();
+  }
+
+  private static Status getAbortStatusWithDescription(Status abortStatus) {
+    Status finalAbortStatus = null;
+    if (abortStatus != null) {
+      String abortDesc = "RPC terminated due to fault injection";
+      if (abortStatus.getDescription() != null) {
+        abortDesc = abortDesc + ": " + abortStatus.getDescription();
+      }
+      finalAbortStatus = abortStatus.withDescription(abortDesc);
+    }
+    return finalAbortStatus;
+  }
+
+  @Nullable
+  private Long determineFaultDelayNanos(FaultDelay faultDelay, Metadata headers) {
+    Long delayNanos;
+    FaultConfig.FractionalPercent fractionalPercent = faultDelay.percent();
+    if (faultDelay.headerDelay()) {
+      try {
+        int delayMillis = Integer.parseInt(headers.get(HEADER_DELAY_KEY));
+        delayNanos = TimeUnit.MILLISECONDS.toNanos(delayMillis);
+        String delayPercentageStr = headers.get(HEADER_DELAY_PERCENTAGE_KEY);
+        if (delayPercentageStr != null) {
+          int delayPercentage = Integer.parseInt(delayPercentageStr);
+          if (delayPercentage >= 0 && delayPercentage < fractionalPercent.numerator()) {
+            fractionalPercent = FaultConfig.FractionalPercent.create(
+                delayPercentage, fractionalPercent.denominatorType());
+          }
+        }
+      } catch (NumberFormatException e) {
+        return null; // treated as header_delay not applicable
+      }
+    } else {
+      delayNanos = faultDelay.delayNanos();
+    }
+    if (random.nextInt(1_000_000) >= getRatePerMillion(fractionalPercent)) {
+      return null;
+    }
+    return delayNanos;
+  }
+
+  @Nullable
+  private Status determineFaultAbortStatus(FaultAbort faultAbort, Metadata headers) {
+    Status abortStatus = null;
+    FaultConfig.FractionalPercent fractionalPercent = faultAbort.percent();
+    if (faultAbort.headerAbort()) {
+      try {
+        String grpcCodeStr = headers.get(HEADER_ABORT_GRPC_STATUS_KEY);
+        if (grpcCodeStr != null) {
+          int grpcCode = Integer.parseInt(grpcCodeStr);
+          abortStatus = Status.fromCodeValue(grpcCode);
+        }
+        String httpCodeStr = headers.get(HEADER_ABORT_HTTP_STATUS_KEY);
+        if (httpCodeStr != null) {
+          int httpCode = Integer.parseInt(httpCodeStr);
+          abortStatus = GrpcUtil.httpStatusToGrpcStatus(httpCode);
+        }
+        String abortPercentageStr = headers.get(HEADER_ABORT_PERCENTAGE_KEY);
+        if (abortPercentageStr != null) {
+          int abortPercentage =
+              Integer.parseInt(headers.get(HEADER_ABORT_PERCENTAGE_KEY));
+          if (abortPercentage >= 0 && abortPercentage < fractionalPercent.numerator()) {
+            fractionalPercent = FaultConfig.FractionalPercent.create(
+                abortPercentage, fractionalPercent.denominatorType());
+          }
+        }
+      } catch (NumberFormatException e) {
+        return null; // treated as header_abort not applicable
+      }
+    } else {
+      abortStatus = faultAbort.status();
+    }
+    if (random.nextInt(1_000_000) >= getRatePerMillion(fractionalPercent)) {
+      return null;
+    }
+    return abortStatus;
+  }
+
+  private static int getRatePerMillion(FaultConfig.FractionalPercent percent) {
+    int numerator = percent.numerator();
+    FaultConfig.FractionalPercent.DenominatorType type = percent.denominatorType();
+    switch (type) {
+      case TEN_THOUSAND:
+        numerator *= 100;
+        break;
+      case HUNDRED:
+        numerator *= 10_000;
+        break;
+      case MILLION:
+      default:
+        break;
+    }
+    if (numerator > 1_000_000 || numerator < 0) {
+      numerator = 1_000_000;
+    }
+    return numerator;
+  }
+
+  /** A {@link DelayedClientCall} with a fixed delay. */
+  private final class DelayInjectedCall<ReqT, RespT> extends DelayedClientCall<ReqT, RespT> {
+    final Object lock = new Object();
+    ScheduledFuture<?> delayTask;
+    boolean cancelled;
+
+    DelayInjectedCall(
+        long delayNanos, Executor callExecutor, ScheduledExecutorService scheduler,
+        @Nullable Deadline deadline,
+        final Supplier<? extends ClientCall<ReqT, RespT>> callSupplier) {
+      super(callExecutor, scheduler, deadline);
+      activeFaultCounter.incrementAndGet();
+      ScheduledFuture<?> task = scheduler.schedule(
+          new Runnable() {
+            @Override
+            public void run() {
+              synchronized (lock) {
+                if (!cancelled) {
+                  activeFaultCounter.decrementAndGet();
+                }
+              }
+              Runnable toRun = setCall(callSupplier.get());
+              if (toRun != null) {
+                toRun.run();
+              }
+            }
+          },
+          delayNanos,
+          NANOSECONDS);
+      synchronized (lock) {
+        if (!cancelled) {
+          delayTask = task;
+          return;
+        }
+      }
+      task.cancel(false);
+    }
+
+    @Override
+    protected void callCancelled() {
+      ScheduledFuture<?> savedDelayTask;
+      synchronized (lock) {
+        cancelled = true;
+        activeFaultCounter.decrementAndGet();
+        savedDelayTask = delayTask;
+      }
+      if (savedDelayTask != null) {
+        savedDelayTask.cancel(false);
+      }
+    }
+  }
+
+  /** An implementation of {@link ClientCall} that fails when started. */
+  private final class FailingClientCall<ReqT, RespT> extends ClientCall<ReqT, RespT> {
+    final Status error;
+    final Executor callExecutor;
+    final Context context;
+
+    FailingClientCall(Status error, Executor callExecutor) {
+      this.error = error;
+      this.callExecutor = callExecutor;
+      this.context = Context.current();
+    }
+
+    @Override
+    public void start(final ClientCall.Listener<RespT> listener, Metadata headers) {
+      activeFaultCounter.incrementAndGet();
+      callExecutor.execute(
+          new Runnable() {
+            @Override
+            public void run() {
+              Context previous = context.attach();
+              try {
+                listener.onClose(error, new Metadata());
+                activeFaultCounter.decrementAndGet();
+              } finally {
+                context.detach(previous);
+              }
+            }
+          });
+    }
+
+    @Override
+    public void request(int numMessages) {}
+
+    @Override
+    public void cancel(String message, Throwable cause) {}
+
+    @Override
+    public void halfClose() {}
+
+    @Override
+    public void sendMessage(ReqT message) {}
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/Filter.java b/xds/src/main/java/io/grpc/xds/Filter.java
new file mode 100644
index 00000000000..416d929becf
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/Filter.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2021 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.xds;
+
+import com.google.common.base.MoreObjects;
+import com.google.protobuf.Message;
+import io.grpc.ClientInterceptor;
+import io.grpc.ServerInterceptor;
+import java.io.Closeable;
+import java.util.Objects;
+import java.util.concurrent.ScheduledExecutorService;
+import javax.annotation.Nullable;
+
+/**
+ * Defines the parsing functionality of an HTTP filter.
+ *
+ * <p>A Filter may optionally implement either {@link Filter#buildClientInterceptor} or
+ * {@link Filter#buildServerInterceptor} or both, and return true from corresponding
+ * {@link Provider#isClientFilter()}, {@link Provider#isServerFilter()} to indicate that the filter
+ * is capable of working on the client side or server side or both, respectively.
+ */
+interface Filter extends Closeable {
+
+  /** Represents an opaque data structure holding configuration for a filter. */
+  interface FilterConfig {
+    String typeUrl();
+  }
+
+  /**
+   * Common interface for filter providers.
+   */
+  interface Provider {
+    /**
+     * The proto message types supported by this filter. A filter will be registered by each of its
+     * supported message types.
+     */
+    String[] typeUrls();
+
+    /**
+     * Whether the filter can be installed on the client side.
+     *
+     * <p>Returns true if the filter implements {@link Filter#buildClientInterceptor}.
+     */
+    default boolean isClientFilter() {
+      return false;
+    }
+
+    /**
+     * Whether the filter can be installed into xDS-enabled servers.
+     *
+     * <p>Returns true if the filter implements {@link Filter#buildServerInterceptor}.
+     */
+    default boolean isServerFilter() {
+      return false;
+    }
+
+    /**
+     * Creates a new instance of the filter.
+     *
+     * <p>Returns a filter instance registered with the same typeUrls as the provider,
+     * capable of working with the same FilterConfig type returned by provider's parse functions.
+     *
+     * <p>For xDS gRPC clients, new filter instances are created per combination of:
+     * <ol>
+     *   <li><code>XdsNameResolver</code> instance,</li>
+     *   <li>Filter name+typeUrl in HttpConnectionManager (HCM) http_filters.</li>
+     * </ol>
+     *
+     * <p>For xDS-enabled gRPC servers, new filter instances are created per combination of:
+     * <ol>
+     *   <li>Server instance,</li>
+     *   <li>FilterChain name,</li>
+     *   <li>Filter name+typeUrl in FilterChain's HCM.http_filters.</li>
+     * </ol>
+     */
+    Filter newInstance(String name);
+
+    /**
+     * Parses the top-level filter config from raw proto message. The message may be either a {@link
+     * com.google.protobuf.Any} or a {@link com.google.protobuf.Struct}.
+     */
+    ConfigOrError<? extends FilterConfig> parseFilterConfig(Message rawProtoMessage);
+
+    /**
+     * Parses the per-filter override filter config from raw proto message. The message may be
+     * either a {@link com.google.protobuf.Any} or a {@link com.google.protobuf.Struct}.
+     */
+    ConfigOrError<? extends FilterConfig> parseFilterConfigOverride(Message rawProtoMessage);
+  }
+
+  /** Uses the FilterConfigs produced above to produce an HTTP filter interceptor for clients. */
+  @Nullable
+  default ClientInterceptor buildClientInterceptor(
+      FilterConfig config, @Nullable FilterConfig overrideConfig,
+      ScheduledExecutorService scheduler) {
+    return null;
+  }
+
+  /** Uses the FilterConfigs produced above to produce an HTTP filter interceptor for the server. */
+  @Nullable
+  default ServerInterceptor buildServerInterceptor(
+      FilterConfig config, @Nullable FilterConfig overrideConfig) {
+    return null;
+  }
+
+  /**
+   * Releases filter resources like shared resources and remote connections.
+   *
+   * <p>See {@link Provider#newInstance()} for details on filter instance creation.
+   */
+  @Override
+  default void close() {}
+
+  /** Filter config with instance name. */
+  final class NamedFilterConfig {
+    // filter instance name
+    final String name;
+    final FilterConfig filterConfig;
+
+    NamedFilterConfig(String name, FilterConfig filterConfig) {
+      this.name = name;
+      this.filterConfig = filterConfig;
+    }
+
+    String filterStateKey() {
+      return name + "_" + filterConfig.typeUrl();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      NamedFilterConfig that = (NamedFilterConfig) o;
+      return Objects.equals(name, that.name)
+          && Objects.equals(filterConfig, that.filterConfig);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(name, filterConfig);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("name", name)
+          .add("filterConfig", filterConfig)
+          .toString();
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/FilterChainMatchingProtocolNegotiators.java b/xds/src/main/java/io/grpc/xds/FilterChainMatchingProtocolNegotiators.java
new file mode 100644
index 00000000000..77a66495614
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/FilterChainMatchingProtocolNegotiators.java
@@ -0,0 +1,458 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.xds.XdsAttributes.ATTR_DRAIN_GRACE_NANOS;
+import static io.grpc.xds.XdsAttributes.ATTR_FILTER_CHAIN_SELECTOR_MANAGER;
+import static io.grpc.xds.XdsServerWrapper.ATTR_SERVER_ROUTING_CONFIG;
+import static io.grpc.xds.internal.security.SecurityProtocolNegotiators.ATTR_SERVER_SSL_CONTEXT_PROVIDER_SUPPLIER;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Strings;
+import com.google.common.collect.Iterables;
+import com.google.protobuf.UInt32Value;
+import io.grpc.Attributes;
+import io.grpc.internal.ObjectPool;
+import io.grpc.netty.GrpcHttp2ConnectionHandler;
+import io.grpc.netty.InternalGracefulServerCloseCommand;
+import io.grpc.netty.InternalProtocolNegotiationEvent;
+import io.grpc.netty.InternalProtocolNegotiator;
+import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
+import io.grpc.netty.ProtocolNegotiationEvent;
+import io.grpc.xds.EnvoyServerProtoData.CidrRange;
+import io.grpc.xds.EnvoyServerProtoData.ConnectionSourceType;
+import io.grpc.xds.EnvoyServerProtoData.FilterChain;
+import io.grpc.xds.EnvoyServerProtoData.FilterChainMatch;
+import io.grpc.xds.XdsServerWrapper.ServerRoutingConfig;
+import io.grpc.xds.internal.Matchers.CidrMatcher;
+import io.grpc.xds.internal.security.SslContextProviderSupplier;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.util.AsciiString;
+import java.net.Inet6Address;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+
+/**
+ * Handles L4 filter chain match for the connection based on the xds configuration.
+ * */
+@SuppressWarnings("FutureReturnValueIgnored") // Netty doesn't follow this pattern
+final class FilterChainMatchingProtocolNegotiators {
+  private static final Logger log = Logger.getLogger(
+          FilterChainMatchingProtocolNegotiators.class.getName());
+
+  private static final AsciiString SCHEME = AsciiString.of("http");
+
+  private FilterChainMatchingProtocolNegotiators() {
+  }
+
+  @VisibleForTesting
+  static final class FilterChainMatchingHandler extends ChannelInboundHandlerAdapter {
+
+    private final GrpcHttp2ConnectionHandler grpcHandler;
+    private final FilterChainSelectorManager filterChainSelectorManager;
+    private final ProtocolNegotiator delegate;
+
+    FilterChainMatchingHandler(
+            GrpcHttp2ConnectionHandler grpcHandler,
+            FilterChainSelectorManager filterChainSelectorManager,
+            ProtocolNegotiator delegate) {
+      this.grpcHandler = checkNotNull(grpcHandler, "grpcHandler");
+      this.filterChainSelectorManager =
+          checkNotNull(filterChainSelectorManager, "filterChainSelectorManager");
+      this.delegate = checkNotNull(delegate, "delegate");
+    }
+
+    @Override
+    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+      if (!(evt instanceof ProtocolNegotiationEvent)) {
+        super.userEventTriggered(ctx, evt);
+        return;
+      }
+      long drainGraceTime = 0;
+      TimeUnit drainGraceTimeUnit = null;
+      Long drainGraceNanosObj = grpcHandler.getEagAttributes().get(ATTR_DRAIN_GRACE_NANOS);
+      if (drainGraceNanosObj != null) {
+        drainGraceTime = drainGraceNanosObj;
+        drainGraceTimeUnit = TimeUnit.NANOSECONDS;
+      }
+      FilterChainSelectorManager.Closer closer = new FilterChainSelectorManager.Closer(
+          new GracefullyShutdownChannelRunnable(ctx.channel(), drainGraceTime, drainGraceTimeUnit));
+      FilterChainSelector selector = filterChainSelectorManager.register(closer);
+      ctx.channel().closeFuture().addListener(
+          new FilterChainSelectorManagerDeregister(filterChainSelectorManager, closer));
+      checkNotNull(selector, "selector");
+      SelectedConfig config = selector.select(
+          (InetSocketAddress) ctx.channel().localAddress(),
+          (InetSocketAddress) ctx.channel().remoteAddress());
+      if (config == null) {
+        log.log(Level.WARNING, "Connection from {0} to {1} has no matching filter chain. Closing",
+            new Object[] {ctx.channel().remoteAddress(), ctx.channel().localAddress()});
+        ctx.close().addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE);
+        return;
+      }
+      ProtocolNegotiationEvent pne = (ProtocolNegotiationEvent) evt;
+      // TODO(zivy): merge into one key and take care of this outer class visibility.
+      Attributes attr = InternalProtocolNegotiationEvent.getAttributes(pne).toBuilder()
+              .set(ATTR_SERVER_SSL_CONTEXT_PROVIDER_SUPPLIER, config.sslContextProviderSupplier)
+              .set(ATTR_SERVER_ROUTING_CONFIG, config.routingConfig)
+              .build();
+      pne = InternalProtocolNegotiationEvent.withAttributes(pne, attr);
+      ctx.pipeline().replace(this, null, delegate.newHandler(grpcHandler));
+      ctx.fireUserEventTriggered(pne);
+    }
+
+    static final class FilterChainSelector {
+      public static final FilterChainSelector NO_FILTER_CHAIN = new FilterChainSelector(
+              Collections.<FilterChain, AtomicReference<ServerRoutingConfig>>emptyMap(),
+          null, new AtomicReference<ServerRoutingConfig>());
+      private final Map<FilterChain, AtomicReference<ServerRoutingConfig>> routingConfigs;
+      @Nullable
+      private final SslContextProviderSupplier defaultSslContextProviderSupplier;
+      private final AtomicReference<ServerRoutingConfig> defaultRoutingConfig;
+
+      FilterChainSelector(Map<FilterChain, AtomicReference<ServerRoutingConfig>> routingConfigs,
+                          @Nullable SslContextProviderSupplier defaultSslContextProviderSupplier,
+                          AtomicReference<ServerRoutingConfig> defaultRoutingConfig) {
+        this.routingConfigs = checkNotNull(routingConfigs, "routingConfigs");
+        this.defaultSslContextProviderSupplier = defaultSslContextProviderSupplier;
+        this.defaultRoutingConfig = checkNotNull(defaultRoutingConfig, "defaultRoutingConfig");
+      }
+
+      FilterChainSelector(Map<FilterChain, AtomicReference<ServerRoutingConfig>> routingConfigs) {
+        this(routingConfigs, null, new AtomicReference<>());
+      }
+
+      @VisibleForTesting
+      Map<FilterChain, AtomicReference<ServerRoutingConfig>> getRoutingConfigs() {
+        return routingConfigs;
+      }
+
+      @VisibleForTesting
+      AtomicReference<ServerRoutingConfig> getDefaultRoutingConfig() {
+        return defaultRoutingConfig;
+      }
+
+      @VisibleForTesting
+      SslContextProviderSupplier getDefaultSslContextProviderSupplier() {
+        return defaultSslContextProviderSupplier;
+      }
+
+      /**
+       * Throws IllegalStateException when no exact one match, and we should close the connection.
+       */
+      SelectedConfig select(InetSocketAddress localAddr, InetSocketAddress remoteAddr) {
+        Collection<FilterChain> filterChains = routingConfigs.keySet();
+        filterChains = filterOnDestinationPort(filterChains);
+        filterChains = filterOnIpAddress(filterChains, localAddr.getAddress(), true);
+        filterChains = filterOnServerNames(filterChains);
+        filterChains = filterOnTransportProtocol(filterChains);
+        filterChains = filterOnApplicationProtocols(filterChains);
+        filterChains =
+                filterOnSourceType(filterChains, remoteAddr.getAddress(), localAddr.getAddress());
+        filterChains = filterOnIpAddress(filterChains, remoteAddr.getAddress(), false);
+        filterChains = filterOnSourcePort(filterChains, remoteAddr.getPort());
+
+        if (filterChains.size() > 1) {
+          throw new IllegalStateException("Found more than one matching filter chains. This should "
+              + "not be possible as ClientXdsClient validated the chains for uniqueness.");
+        }
+        if (filterChains.size() == 1) {
+          FilterChain selected = Iterables.getOnlyElement(filterChains);
+          return new SelectedConfig(
+                  routingConfigs.get(selected), selected.sslContextProviderSupplier());
+        }
+        if (defaultRoutingConfig.get() != null) {
+          return new SelectedConfig(defaultRoutingConfig, defaultSslContextProviderSupplier);
+        }
+        return null;
+      }
+
+      // reject if filer-chain-match has non-empty application_protocols
+      private static Collection<FilterChain> filterOnApplicationProtocols(
+              Collection<FilterChain> filterChains) {
+        ArrayList<FilterChain> filtered = new ArrayList<>(filterChains.size());
+        for (FilterChain filterChain : filterChains) {
+          FilterChainMatch filterChainMatch = filterChain.filterChainMatch();
+
+          if (filterChainMatch.applicationProtocols().isEmpty()) {
+            filtered.add(filterChain);
+          }
+        }
+        return filtered;
+      }
+
+      // reject if filer-chain-match has non-empty transport protocol other than "raw_buffer"
+      private static Collection<FilterChain> filterOnTransportProtocol(
+              Collection<FilterChain> filterChains) {
+        ArrayList<FilterChain> filtered = new ArrayList<>(filterChains.size());
+        for (FilterChain filterChain : filterChains) {
+          FilterChainMatch filterChainMatch = filterChain.filterChainMatch();
+
+          String transportProtocol = filterChainMatch.transportProtocol();
+          if (Strings.isNullOrEmpty(transportProtocol) || "raw_buffer".equals(transportProtocol)) {
+            filtered.add(filterChain);
+          }
+        }
+        return filtered;
+      }
+
+      // reject if filer-chain-match has server_name(s)
+      private static Collection<FilterChain> filterOnServerNames(
+              Collection<FilterChain> filterChains) {
+        ArrayList<FilterChain> filtered = new ArrayList<>(filterChains.size());
+        for (FilterChain filterChain : filterChains) {
+          FilterChainMatch filterChainMatch = filterChain.filterChainMatch();
+
+          if (filterChainMatch.serverNames().isEmpty()) {
+            filtered.add(filterChain);
+          }
+        }
+        return filtered;
+      }
+
+      // destination_port present => Always fail match
+      private static Collection<FilterChain> filterOnDestinationPort(
+              Collection<FilterChain> filterChains) {
+        ArrayList<FilterChain> filtered = new ArrayList<>(filterChains.size());
+        for (FilterChain filterChain : filterChains) {
+          FilterChainMatch filterChainMatch = filterChain.filterChainMatch();
+
+          if (filterChainMatch.destinationPort()
+                  == UInt32Value.getDefaultInstance().getValue()) {
+            filtered.add(filterChain);
+          }
+        }
+        return filtered;
+      }
+
+      private static Collection<FilterChain> filterOnSourcePort(
+              Collection<FilterChain> filterChains, int sourcePort) {
+        ArrayList<FilterChain> filteredOnMatch = new ArrayList<>(filterChains.size());
+        ArrayList<FilterChain> filteredOnEmpty = new ArrayList<>(filterChains.size());
+        for (FilterChain filterChain : filterChains) {
+          FilterChainMatch filterChainMatch = filterChain.filterChainMatch();
+
+          List<Integer> sourcePortsToMatch = filterChainMatch.sourcePorts();
+          if (sourcePortsToMatch.isEmpty()) {
+            filteredOnEmpty.add(filterChain);
+          } else if (sourcePortsToMatch.contains(sourcePort)) {
+            filteredOnMatch.add(filterChain);
+          }
+        }
+        // match against source port is more specific than match against empty list
+        return filteredOnMatch.isEmpty() ? filteredOnEmpty : filteredOnMatch;
+      }
+
+      private static Collection<FilterChain> filterOnSourceType(
+              Collection<FilterChain> filterChains, InetAddress sourceAddress,
+              InetAddress destAddress) {
+        ArrayList<FilterChain> filtered = new ArrayList<>(filterChains.size());
+        for (FilterChain filterChain : filterChains) {
+          FilterChainMatch filterChainMatch = filterChain.filterChainMatch();
+          ConnectionSourceType sourceType =
+                  filterChainMatch.connectionSourceType();
+
+          boolean matching = false;
+          if (sourceType == ConnectionSourceType.SAME_IP_OR_LOOPBACK) {
+            matching =
+                    sourceAddress.isLoopbackAddress()
+                            || sourceAddress.isAnyLocalAddress()
+                            || sourceAddress.equals(destAddress);
+          } else if (sourceType == ConnectionSourceType.EXTERNAL) {
+            matching = !sourceAddress.isLoopbackAddress() && !sourceAddress.isAnyLocalAddress();
+          } else { // ANY or null
+            matching = true;
+          }
+          if (matching) {
+            filtered.add(filterChain);
+          }
+        }
+        return filtered;
+      }
+
+      private static int getMatchingPrefixLength(
+              FilterChainMatch filterChainMatch, InetAddress address, boolean forDestination) {
+        boolean isIPv6 = address instanceof Inet6Address;
+        List<CidrRange> cidrRanges =
+                forDestination
+                        ? filterChainMatch.prefixRanges()
+                        : filterChainMatch.sourcePrefixRanges();
+        int matchingPrefixLength;
+        if (cidrRanges.isEmpty()) { // if there is no CidrRange assume 0-length match
+          matchingPrefixLength = 0;
+        } else {
+          matchingPrefixLength = -1;
+          for (CidrRange cidrRange : cidrRanges) {
+            InetAddress cidrAddr = cidrRange.addressPrefix();
+            boolean cidrIsIpv6 = cidrAddr instanceof Inet6Address;
+            if (isIPv6 == cidrIsIpv6) {
+              int prefixLen = cidrRange.prefixLen();
+              CidrMatcher matcher = CidrMatcher.create(cidrAddr, prefixLen);
+              if (matcher.matches(address) && prefixLen > matchingPrefixLength) {
+                matchingPrefixLength = prefixLen;
+              }
+            }
+          }
+        }
+        return matchingPrefixLength;
+      }
+
+      // use prefix_ranges (CIDR) and get the most specific matches
+      private static Collection<FilterChain> filterOnIpAddress(
+              Collection<FilterChain> filterChains, InetAddress address, boolean forDestination) {
+        // current list of top ones
+        ArrayList<FilterChain> topOnes = new ArrayList<>(filterChains.size());
+        int topMatchingPrefixLen = -1;
+        for (FilterChain filterChain : filterChains) {
+          int currentMatchingPrefixLen = getMatchingPrefixLength(
+                  filterChain.filterChainMatch(), address, forDestination);
+
+          if (currentMatchingPrefixLen >= 0) {
+            if (currentMatchingPrefixLen < topMatchingPrefixLen) {
+              continue;
+            }
+            if (currentMatchingPrefixLen > topMatchingPrefixLen) {
+              topMatchingPrefixLen = currentMatchingPrefixLen;
+              topOnes.clear();
+            }
+            topOnes.add(filterChain);
+          }
+        }
+        return topOnes;
+      }
+
+      @Override
+      public String toString() {
+        return MoreObjects.toStringHelper(this)
+            .add("routingConfigs", routingConfigs)
+            .add("defaultSslContextProviderSupplier", defaultSslContextProviderSupplier)
+            .add("defaultRoutingConfig", defaultRoutingConfig)
+            .toString();
+      }
+    }
+  }
+
+  static final class FilterChainMatchingNegotiatorServerFactory
+          implements InternalProtocolNegotiator.ServerFactory {
+    private final InternalProtocolNegotiator.ServerFactory delegate;
+
+    public FilterChainMatchingNegotiatorServerFactory(
+            InternalProtocolNegotiator.ServerFactory delegate) {
+      this.delegate = checkNotNull(delegate, "delegate");
+    }
+
+    @Override
+    public ProtocolNegotiator newNegotiator(
+            final ObjectPool<? extends Executor> offloadExecutorPool) {
+
+      class FilterChainMatchingNegotiator implements ProtocolNegotiator {
+
+        @Override
+        public AsciiString scheme() {
+          return SCHEME;
+        }
+
+        @Override
+        public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+          FilterChainSelectorManager filterChainSelectorManager =
+              grpcHandler.getEagAttributes().get(ATTR_FILTER_CHAIN_SELECTOR_MANAGER);
+          checkNotNull(filterChainSelectorManager, "filterChainSelectorManager");
+          return new FilterChainMatchingHandler(grpcHandler, filterChainSelectorManager,
+                  delegate.newNegotiator(offloadExecutorPool));
+        }
+
+        @Override
+        public void close() {
+        }
+      }
+
+      return new FilterChainMatchingNegotiator();
+    }
+  }
+
+  /**
+   * The FilterChain level configuration.
+   */
+  private static final class SelectedConfig {
+    private final AtomicReference<ServerRoutingConfig> routingConfig;
+    @Nullable
+    private final SslContextProviderSupplier sslContextProviderSupplier;
+
+    private SelectedConfig(AtomicReference<ServerRoutingConfig> routingConfig,
+                           @Nullable SslContextProviderSupplier sslContextProviderSupplier) {
+      this.routingConfig = checkNotNull(routingConfig, "routingConfig");
+      this.sslContextProviderSupplier = sslContextProviderSupplier;
+    }
+  }
+
+  private static class FilterChainSelectorManagerDeregister implements ChannelFutureListener {
+    private final FilterChainSelectorManager filterChainSelectorManager;
+    private final FilterChainSelectorManager.Closer closer;
+
+    public FilterChainSelectorManagerDeregister(
+        FilterChainSelectorManager filterChainSelectorManager,
+        FilterChainSelectorManager.Closer closer) {
+      this.filterChainSelectorManager =
+          checkNotNull(filterChainSelectorManager, "filterChainSelectorManager");
+      this.closer = checkNotNull(closer, "closer");
+    }
+
+    @Override public void operationComplete(ChannelFuture future) throws Exception {
+      filterChainSelectorManager.deregister(closer);
+    }
+  }
+
+  private static class GracefullyShutdownChannelRunnable implements Runnable {
+    private final Channel channel;
+    private final long drainGraceTime;
+    @Nullable
+    private final TimeUnit drainGraceTimeUnit;
+
+    public GracefullyShutdownChannelRunnable(
+        Channel channel, long drainGraceTime, @Nullable TimeUnit drainGraceTimeUnit) {
+      this.channel = checkNotNull(channel, "channel");
+      this.drainGraceTime = drainGraceTime;
+      this.drainGraceTimeUnit = drainGraceTimeUnit;
+    }
+
+    @Override public void run() {
+      Object gracefulCloseCommand = InternalGracefulServerCloseCommand.create(
+          "xds_drain", drainGraceTime, drainGraceTimeUnit);
+      channel.writeAndFlush(gracefulCloseCommand)
+          .addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/FilterChainSelectorManager.java b/xds/src/main/java/io/grpc/xds/FilterChainSelectorManager.java
new file mode 100644
index 00000000000..b3cc14c6484
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/FilterChainSelectorManager.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2021 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.xds;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.xds.FilterChainMatchingProtocolNegotiators.FilterChainMatchingHandler.FilterChainSelector;
+import java.util.Comparator;
+import java.util.TreeSet;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Maintains the current xDS selector and any resources using that selector. When the selector
+ * changes, old resources are closed to avoid old config usages.
+ */
+final class FilterChainSelectorManager {
+  private static final AtomicLong closerId = new AtomicLong();
+
+  private final Object lock = new Object();
+  @GuardedBy("lock")
+  private FilterChainSelector selector;
+  // Avoid HashSet since it does not decrease in size, forming a high water mark.
+  @GuardedBy("lock")
+  private TreeSet<Closer> closers = new TreeSet<Closer>(new CloserComparator());
+
+  public FilterChainSelector register(Closer closer) {
+    synchronized (lock) {
+      Preconditions.checkState(closers.add(closer), "closer already registered");
+      return selector;
+    }
+  }
+
+  public void deregister(Closer closer) {
+    synchronized (lock) {
+      closers.remove(closer);
+    }
+  }
+
+  /** Only safe to be called by code that is responsible for updating the selector.  */
+  public FilterChainSelector getSelectorToUpdateSelector() {
+    synchronized (lock) {
+      return selector;
+    }
+  }
+
+  public void updateSelector(FilterChainSelector newSelector) {
+    TreeSet<Closer> oldClosers;
+    synchronized (lock) {
+      oldClosers = closers;
+      closers = new TreeSet<Closer>(closers.comparator());
+      selector = newSelector;
+    }
+    for (Closer closer : oldClosers) {
+      closer.closer.run();
+    }
+  }
+
+  @VisibleForTesting
+  int getRegisterCount() {
+    synchronized (lock) {
+      return closers.size();
+    }
+  }
+
+  public static final class Closer {
+    private final long id = closerId.getAndIncrement();
+    private final Runnable closer;
+
+    /** {@code closer} may be run multiple times. */
+    public Closer(Runnable closer) {
+      this.closer = Preconditions.checkNotNull(closer, "closer");
+    }
+  }
+
+  private static class CloserComparator implements Comparator<Closer> {
+    @Override public int compare(Closer c1, Closer c2) {
+      return Long.compare(c1.id, c2.id);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/FilterRegistry.java b/xds/src/main/java/io/grpc/xds/FilterRegistry.java
new file mode 100644
index 00000000000..da3a59fe8c1
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/FilterRegistry.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2021 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.xds;
+
+import com.google.common.annotations.VisibleForTesting;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/**
+ * A registry for all supported {@link Filter}s. Filters can be queried from the registry
+ * by any of the {@link Filter.Provider#typeUrls() type URLs}.
+ */
+final class FilterRegistry {
+  private static FilterRegistry instance;
+
+  private final Map<String, Filter.Provider> supportedFilters = new HashMap<>();
+
+  private FilterRegistry() {}
+
+  static synchronized FilterRegistry getDefaultRegistry() {
+    if (instance == null) {
+      instance = newRegistry().register(
+              new FaultFilter.Provider(),
+              new RouterFilter.Provider(),
+              new RbacFilter.Provider(),
+              new GcpAuthenticationFilter.Provider());
+    }
+    return instance;
+  }
+
+  @VisibleForTesting
+  static FilterRegistry newRegistry() {
+    return new FilterRegistry();
+  }
+
+  @VisibleForTesting
+  FilterRegistry register(Filter.Provider... filters) {
+    for (Filter.Provider filter : filters) {
+      for (String typeUrl : filter.typeUrls()) {
+        supportedFilters.put(typeUrl, filter);
+      }
+    }
+    return this;
+  }
+
+  @Nullable
+  Filter.Provider get(String typeUrl) {
+    return supportedFilters.get(typeUrl);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/GcpAuthenticationFilter.java b/xds/src/main/java/io/grpc/xds/GcpAuthenticationFilter.java
new file mode 100644
index 00000000000..8ec02f4f809
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/GcpAuthenticationFilter.java
@@ -0,0 +1,327 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.xds.XdsNameResolver.CLUSTER_SELECTION_KEY;
+import static io.grpc.xds.XdsNameResolver.XDS_CONFIG_CALL_OPTION_KEY;
+
+import com.google.auth.oauth2.ComputeEngineCredentials;
+import com.google.auth.oauth2.IdTokenCredentials;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.primitives.UnsignedLongs;
+import com.google.protobuf.Any;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Message;
+import io.envoyproxy.envoy.extensions.filters.http.gcp_authn.v3.Audience;
+import io.envoyproxy.envoy.extensions.filters.http.gcp_authn.v3.GcpAuthnFilterConfig;
+import io.envoyproxy.envoy.extensions.filters.http.gcp_authn.v3.TokenCacheConfig;
+import io.grpc.CallCredentials;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.CompositeCallCredentials;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.auth.MoreCallCredentials;
+import io.grpc.xds.GcpAuthenticationFilter.AudienceMetadataParser.AudienceWrapper;
+import io.grpc.xds.MetadataRegistry.MetadataValueParser;
+import io.grpc.xds.XdsConfig.XdsClusterConfig;
+import io.grpc.xds.client.XdsResourceType.ResourceInvalidException;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.function.Function;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link Filter} that injects a {@link CallCredentials} to handle
+ * authentication for xDS credentials.
+ */
+final class GcpAuthenticationFilter implements Filter {
+
+  static final String TYPE_URL =
+      "type.googleapis.com/envoy.extensions.filters.http.gcp_authn.v3.GcpAuthnFilterConfig";
+  private final LruCache<String, CallCredentials> callCredentialsCache;
+  final String filterInstanceName;
+
+  GcpAuthenticationFilter(String name, int cacheSize) {
+    filterInstanceName = checkNotNull(name, "name");
+    this.callCredentialsCache = new LruCache<>(cacheSize);
+  }
+
+  static final class Provider implements Filter.Provider {
+    private final int cacheSize = 10;
+
+    @Override
+    public String[] typeUrls() {
+      return new String[]{TYPE_URL};
+    }
+
+    @Override
+    public boolean isClientFilter() {
+      return true;
+    }
+
+    @Override
+    public GcpAuthenticationFilter newInstance(String name) {
+      return new GcpAuthenticationFilter(name, cacheSize);
+    }
+
+    @Override
+    public ConfigOrError<GcpAuthenticationConfig> parseFilterConfig(Message rawProtoMessage) {
+      GcpAuthnFilterConfig gcpAuthnProto;
+      if (!(rawProtoMessage instanceof Any)) {
+        return ConfigOrError.fromError("Invalid config type: " + rawProtoMessage.getClass());
+      }
+      Any anyMessage = (Any) rawProtoMessage;
+
+      try {
+        gcpAuthnProto = anyMessage.unpack(GcpAuthnFilterConfig.class);
+      } catch (InvalidProtocolBufferException e) {
+        return ConfigOrError.fromError("Invalid proto: " + e);
+      }
+
+      long cacheSize = 10;
+      // Validate cache_config
+      if (gcpAuthnProto.hasCacheConfig()) {
+        TokenCacheConfig cacheConfig = gcpAuthnProto.getCacheConfig();
+        if (cacheConfig.hasCacheSize()) {
+          cacheSize = cacheConfig.getCacheSize().getValue();
+          if (cacheSize == 0) {
+            return ConfigOrError.fromError(
+                "cache_config.cache_size must be greater than zero");
+          }
+        }
+
+        // LruCache's size is an int and briefly exceeds its maximum size before evicting entries
+        cacheSize = UnsignedLongs.min(cacheSize, Integer.MAX_VALUE - 1);
+      }
+
+      GcpAuthenticationConfig config = new GcpAuthenticationConfig((int) cacheSize);
+      return ConfigOrError.fromConfig(config);
+    }
+
+    @Override
+    public ConfigOrError<GcpAuthenticationConfig> parseFilterConfigOverride(
+        Message rawProtoMessage) {
+      return parseFilterConfig(rawProtoMessage);
+    }
+  }
+
+  @Nullable
+  @Override
+  public ClientInterceptor buildClientInterceptor(FilterConfig config,
+      @Nullable FilterConfig overrideConfig, ScheduledExecutorService scheduler) {
+
+    ComputeEngineCredentials credentials = ComputeEngineCredentials.create();
+    synchronized (callCredentialsCache) {
+      callCredentialsCache.resizeCache(((GcpAuthenticationConfig) config).getCacheSize());
+    }
+    return new ClientInterceptor() {
+      @Override
+      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+          MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+
+        String clusterName = callOptions.getOption(CLUSTER_SELECTION_KEY);
+        if (clusterName == null) {
+          return new FailingClientCall<>(
+              Status.UNAVAILABLE.withDescription(
+                  String.format(
+                      "GCP Authn for %s does not contain cluster resource", filterInstanceName)));
+        }
+
+        if (!clusterName.startsWith("cluster:")) {
+          return next.newCall(method, callOptions);
+        }
+        XdsConfig xdsConfig = callOptions.getOption(XDS_CONFIG_CALL_OPTION_KEY);
+        if (xdsConfig == null) {
+          return new FailingClientCall<>(
+              Status.UNAVAILABLE.withDescription(
+                  String.format(
+                      "GCP Authn for %s with %s does not contain xds configuration",
+                      filterInstanceName, clusterName)));
+        }
+        StatusOr<XdsClusterConfig> xdsCluster =
+            xdsConfig.getClusters().get(clusterName.substring("cluster:".length()));
+        if (xdsCluster == null) {
+          return new FailingClientCall<>(
+              Status.UNAVAILABLE.withDescription(
+                  String.format(
+                      "GCP Authn for %s with %s - xds cluster config does not contain xds cluster",
+                      filterInstanceName, clusterName)));
+        }
+        if (!xdsCluster.hasValue()) {
+          return new FailingClientCall<>(xdsCluster.getStatus());
+        }
+        Object audienceObj =
+            xdsCluster.getValue().getClusterResource().parsedMetadata().get(filterInstanceName);
+        if (audienceObj == null) {
+          return next.newCall(method, callOptions);
+        }
+        if (!(audienceObj instanceof AudienceWrapper)) {
+          return new FailingClientCall<>(
+              Status.UNAVAILABLE.withDescription(
+                  String.format("GCP Authn found wrong type in %s metadata: %s=%s",
+                      clusterName, filterInstanceName, audienceObj.getClass())));
+        }
+        AudienceWrapper audience = (AudienceWrapper) audienceObj;
+        CallCredentials existingCallCredentials = callOptions.getCredentials();
+        CallCredentials newCallCredentials =
+            getCallCredentials(callCredentialsCache, audience.audience, credentials);
+        if (existingCallCredentials != null) {
+          callOptions = callOptions.withCallCredentials(
+              new CompositeCallCredentials(existingCallCredentials, newCallCredentials));
+        } else {
+          callOptions = callOptions.withCallCredentials(newCallCredentials);
+        }
+        return next.newCall(method, callOptions);
+      }
+    };
+  }
+
+  private CallCredentials getCallCredentials(LruCache<String, CallCredentials> cache,
+      String audience, ComputeEngineCredentials credentials) {
+
+    synchronized (cache) {
+      return cache.getOrInsert(audience, key -> {
+        IdTokenCredentials creds = IdTokenCredentials.newBuilder()
+            .setIdTokenProvider(credentials)
+            .setTargetAudience(audience)
+            .build();
+        return MoreCallCredentials.from(creds);
+      });
+    }
+  }
+
+  static final class GcpAuthenticationConfig implements FilterConfig {
+
+    private final int cacheSize;
+
+    public GcpAuthenticationConfig(int cacheSize) {
+      this.cacheSize = cacheSize;
+    }
+
+    public int getCacheSize() {
+      return cacheSize;
+    }
+
+    @Override
+    public String typeUrl() {
+      return GcpAuthenticationFilter.TYPE_URL;
+    }
+  }
+
+  /** An implementation of {@link ClientCall} that fails when started. */
+  @VisibleForTesting
+  static final class FailingClientCall<ReqT, RespT> extends ClientCall<ReqT, RespT> {
+
+    @VisibleForTesting
+    final Status error;
+
+    public FailingClientCall(Status error) {
+      this.error = error;
+    }
+
+    @Override
+    public void start(ClientCall.Listener<RespT> listener, Metadata headers) {
+      listener.onClose(error, new Metadata());
+    }
+
+    @Override
+    public void request(int numMessages) {}
+
+    @Override
+    public void cancel(String message, Throwable cause) {}
+
+    @Override
+    public void halfClose() {}
+
+    @Override
+    public void sendMessage(ReqT message) {}
+  }
+
+  private static final class LruCache<K, V> {
+
+    private Map<K, V> cache;
+    private int maxSize;
+
+    LruCache(int maxSize) {
+      this.maxSize = maxSize;
+      this.cache = createEvictingMap(maxSize);
+    }
+
+    V getOrInsert(K key, Function<K, V> create) {
+      return cache.computeIfAbsent(key, create);
+    }
+
+    private void resizeCache(int newSize) {
+      if (newSize >= maxSize) {
+        maxSize = newSize;
+        return;
+      }
+      Map<K, V> newCache = createEvictingMap(newSize);
+      maxSize = newSize;
+      newCache.putAll(cache);
+      cache = newCache;
+    }
+
+    private Map<K, V> createEvictingMap(int size) {
+      return new LinkedHashMap<K, V>(size, 0.75f, true) {
+        @Override
+        protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
+          return size() > LruCache.this.maxSize;
+        }
+      };
+    }
+  }
+
+  static class AudienceMetadataParser implements MetadataValueParser {
+
+    static final class AudienceWrapper {
+      final String audience;
+
+      AudienceWrapper(String audience) {
+        this.audience = checkNotNull(audience);
+      }
+    }
+
+    @Override
+    public String getTypeUrl() {
+      return "type.googleapis.com/envoy.extensions.filters.http.gcp_authn.v3.Audience";
+    }
+
+    @Override
+    public AudienceWrapper parse(Any any) throws ResourceInvalidException {
+      Audience audience;
+      try {
+        audience = any.unpack(Audience.class);
+      } catch (InvalidProtocolBufferException ex) {
+        throw new ResourceInvalidException("Invalid Resource in address proto", ex);
+      }
+      String url = audience.getUrl();
+      if (url.isEmpty()) {
+        throw new ResourceInvalidException(
+            "Audience URL is empty. Metadata value must contain a valid URL.");
+      }
+      return new AudienceWrapper(url);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/GrpcBootstrapperImpl.java b/xds/src/main/java/io/grpc/xds/GrpcBootstrapperImpl.java
new file mode 100644
index 00000000000..494e95a58f6
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/GrpcBootstrapperImpl.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2024 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.xds;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.ChannelCredentials;
+import io.grpc.internal.JsonUtil;
+import io.grpc.xds.client.BootstrapperImpl;
+import io.grpc.xds.client.XdsInitializationException;
+import io.grpc.xds.client.XdsLogger;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+class GrpcBootstrapperImpl extends BootstrapperImpl {
+  private static final String BOOTSTRAP_PATH_SYS_ENV_VAR = "GRPC_XDS_BOOTSTRAP";
+  private static final String BOOTSTRAP_PATH_SYS_PROPERTY = "io.grpc.xds.bootstrap";
+  private static final String BOOTSTRAP_CONFIG_SYS_ENV_VAR = "GRPC_XDS_BOOTSTRAP_CONFIG";
+  private static final String BOOTSTRAP_CONFIG_SYS_PROPERTY = "io.grpc.xds.bootstrapConfig";
+  @VisibleForTesting
+  String bootstrapPathFromEnvVar = System.getenv(BOOTSTRAP_PATH_SYS_ENV_VAR);
+  @VisibleForTesting
+  String bootstrapPathFromSysProp = System.getProperty(BOOTSTRAP_PATH_SYS_PROPERTY);
+  @VisibleForTesting
+  String bootstrapConfigFromEnvVar = System.getenv(BOOTSTRAP_CONFIG_SYS_ENV_VAR);
+  @VisibleForTesting
+  String bootstrapConfigFromSysProp = System.getProperty(BOOTSTRAP_CONFIG_SYS_PROPERTY);
+
+  GrpcBootstrapperImpl() {
+    super();
+  }
+
+  @Override
+  public BootstrapInfo bootstrap(Map<String, ?> rawData) throws XdsInitializationException {
+    BootstrapInfo info = super.bootstrap(rawData);
+    if (info.servers().isEmpty()) {
+      throw new XdsInitializationException("Invalid bootstrap: 'xds_servers' is empty");
+    }
+    return info;
+  }
+
+  /**
+   * Gets the bootstrap config as JSON. Searches the config (or file of config) with the
+   * following order:
+   *
+   * <ol>
+   *   <li>A filesystem path defined by environment variable "GRPC_XDS_BOOTSTRAP"</li>
+   *   <li>A filesystem path defined by Java System Property "io.grpc.xds.bootstrap"</li>
+   *   <li>Environment variable value of "GRPC_XDS_BOOTSTRAP_CONFIG"</li>
+   *   <li>Java System Property value of "io.grpc.xds.bootstrapConfig"</li>
+   * </ol>
+   */
+  @Override
+  protected String getJsonContent() throws XdsInitializationException, IOException {
+    String jsonContent;
+    String filePath =
+        bootstrapPathFromEnvVar != null ? bootstrapPathFromEnvVar : bootstrapPathFromSysProp;
+    if (filePath != null) {
+      logger.log(XdsLogger.XdsLogLevel.INFO, "Reading bootstrap file from {0}", filePath);
+      jsonContent = reader.readFile(filePath);
+      logger.log(XdsLogger.XdsLogLevel.INFO, "Reading bootstrap from " + filePath);
+    } else {
+      jsonContent = bootstrapConfigFromEnvVar != null
+          ? bootstrapConfigFromEnvVar : bootstrapConfigFromSysProp;
+    }
+    if (jsonContent == null) {
+      throw new XdsInitializationException(
+          "Cannot find bootstrap configuration\n"
+              + "Environment variables searched:\n"
+              + "- " + BOOTSTRAP_PATH_SYS_ENV_VAR + "\n"
+              + "- " + BOOTSTRAP_CONFIG_SYS_ENV_VAR + "\n\n"
+              + "Java System Properties searched:\n"
+              + "- " + BOOTSTRAP_PATH_SYS_PROPERTY + "\n"
+              + "- " + BOOTSTRAP_CONFIG_SYS_PROPERTY + "\n\n");
+    }
+
+    return jsonContent;
+  }
+
+  @Override
+  protected Object getImplSpecificConfig(Map<String, ?> serverConfig, String serverUri)
+      throws XdsInitializationException {
+    return getChannelCredentials(serverConfig, serverUri);
+  }
+
+  @GuardedBy("GrpcBootstrapperImpl.class")
+  private static Map<String, ?> defaultBootstrapOverride;
+  @GuardedBy("GrpcBootstrapperImpl.class")
+  private static BootstrapInfo defaultBootstrap;
+
+  static synchronized void setDefaultBootstrapOverride(Map<String, ?> rawBootstrap) {
+    defaultBootstrapOverride = rawBootstrap;
+  }
+
+  static synchronized BootstrapInfo defaultBootstrap() throws XdsInitializationException {
+    if (defaultBootstrap == null) {
+      if (defaultBootstrapOverride == null) {
+        defaultBootstrap = new GrpcBootstrapperImpl().bootstrap();
+      } else {
+        defaultBootstrap = new GrpcBootstrapperImpl().bootstrap(defaultBootstrapOverride);
+      }
+    }
+    return defaultBootstrap;
+  }
+
+  private static ChannelCredentials getChannelCredentials(Map<String, ?> serverConfig,
+                                                          String serverUri)
+      throws XdsInitializationException {
+    List<?> rawChannelCredsList = JsonUtil.getList(serverConfig, "channel_creds");
+    if (rawChannelCredsList == null || rawChannelCredsList.isEmpty()) {
+      throw new XdsInitializationException(
+          "Invalid bootstrap: server " + serverUri + " 'channel_creds' required");
+    }
+    ChannelCredentials channelCredentials =
+        parseChannelCredentials(JsonUtil.checkObjectList(rawChannelCredsList), serverUri);
+    if (channelCredentials == null) {
+      throw new XdsInitializationException(
+          "Server " + serverUri + ": no supported channel credentials found");
+    }
+    return channelCredentials;
+  }
+
+  @Nullable
+  private static ChannelCredentials parseChannelCredentials(List<Map<String, ?>> jsonList,
+                                                            String serverUri)
+      throws XdsInitializationException {
+    for (Map<String, ?> channelCreds : jsonList) {
+      String type = JsonUtil.getString(channelCreds, "type");
+      if (type == null) {
+        throw new XdsInitializationException(
+            "Invalid bootstrap: server " + serverUri + " with 'channel_creds' type unspecified");
+      }
+      XdsCredentialsProvider provider =  XdsCredentialsRegistry.getDefaultRegistry()
+          .getProvider(type);
+      if (provider != null) {
+        Map<String, ?> config = JsonUtil.getObject(channelCreds, "config");
+        if (config == null) {
+          config = ImmutableMap.of();
+        }
+
+        return provider.newChannelCredentials(config);
+      }
+    }
+    return null;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/GrpcXdsTransportFactory.java b/xds/src/main/java/io/grpc/xds/GrpcXdsTransportFactory.java
new file mode 100644
index 00000000000..0da51bf47f7
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/GrpcXdsTransportFactory.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright 2024 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.CallCredentials;
+import io.grpc.CallOptions;
+import io.grpc.ChannelCredentials;
+import io.grpc.ClientCall;
+import io.grpc.Context;
+import io.grpc.Grpc;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.XdsTransportFactory;
+import java.util.concurrent.TimeUnit;
+
+final class GrpcXdsTransportFactory implements XdsTransportFactory {
+
+  private final CallCredentials callCredentials;
+
+  GrpcXdsTransportFactory(CallCredentials callCredentials) {
+    this.callCredentials = callCredentials;
+  }
+
+  @Override
+  public XdsTransport create(Bootstrapper.ServerInfo serverInfo) {
+    return new GrpcXdsTransport(serverInfo, callCredentials);
+  }
+
+  @VisibleForTesting
+  public XdsTransport createForTest(ManagedChannel channel) {
+    return new GrpcXdsTransport(channel, callCredentials);
+  }
+
+  @VisibleForTesting
+  static class GrpcXdsTransport implements XdsTransport {
+
+    private final ManagedChannel channel;
+    private final CallCredentials callCredentials;
+
+    public GrpcXdsTransport(Bootstrapper.ServerInfo serverInfo) {
+      this(serverInfo, null);
+    }
+
+    @VisibleForTesting
+    public GrpcXdsTransport(ManagedChannel channel) {
+      this(channel, null);
+    }
+
+    public GrpcXdsTransport(Bootstrapper.ServerInfo serverInfo, CallCredentials callCredentials) {
+      String target = serverInfo.target();
+      ChannelCredentials channelCredentials = (ChannelCredentials) serverInfo.implSpecificConfig();
+      this.channel = Grpc.newChannelBuilder(target, channelCredentials)
+          .keepAliveTime(5, TimeUnit.MINUTES)
+          .build();
+      this.callCredentials = callCredentials;
+    }
+
+    @VisibleForTesting
+    public GrpcXdsTransport(ManagedChannel channel, CallCredentials callCredentials) {
+      this.channel = checkNotNull(channel, "channel");
+      this.callCredentials = callCredentials;
+    }
+
+    @Override
+    public <ReqT, RespT> StreamingCall<ReqT, RespT> createStreamingCall(
+        String fullMethodName,
+        MethodDescriptor.Marshaller<ReqT> reqMarshaller,
+        MethodDescriptor.Marshaller<RespT> respMarshaller) {
+      Context prevContext = Context.ROOT.attach();
+      try {
+        return new XdsStreamingCall<>(
+            fullMethodName, reqMarshaller, respMarshaller, callCredentials);
+      } finally {
+        Context.ROOT.detach(prevContext);
+      }
+
+    }
+
+    @Override
+    public void shutdown() {
+      channel.shutdown();
+    }
+
+    private class XdsStreamingCall<ReqT, RespT> implements
+        XdsTransportFactory.StreamingCall<ReqT, RespT> {
+
+      private final ClientCall<ReqT, RespT> call;
+
+      public XdsStreamingCall(
+          String methodName,
+          MethodDescriptor.Marshaller<ReqT> reqMarshaller,
+          MethodDescriptor.Marshaller<RespT> respMarshaller,
+          CallCredentials callCredentials) {
+        this.call =
+            channel.newCall(
+                MethodDescriptor.<ReqT, RespT>newBuilder()
+                    .setFullMethodName(methodName)
+                    .setType(MethodDescriptor.MethodType.BIDI_STREAMING)
+                    .setRequestMarshaller(reqMarshaller)
+                    .setResponseMarshaller(respMarshaller)
+                    .build(),
+                CallOptions.DEFAULT.withCallCredentials(
+                    callCredentials)); // TODO(zivy): support waitForReady
+      }
+
+      @Override
+      public void start(EventHandler<RespT> eventHandler) {
+        call.start(new EventHandlerToCallListenerAdapter<>(eventHandler), new Metadata());
+        call.request(1);
+      }
+
+      @Override
+      public void sendMessage(ReqT message) {
+        call.sendMessage(message);
+      }
+
+      @Override
+      public void startRecvMessage() {
+        call.request(1);
+      }
+
+      @Override
+      public void sendError(Exception e) {
+        call.cancel("Cancelled by XdsClientImpl", e);
+      }
+
+      @Override
+      public boolean isReady() {
+        return call.isReady();
+      }
+    }
+  }
+
+  private static class EventHandlerToCallListenerAdapter<T> extends ClientCall.Listener<T> {
+    private final EventHandler<T> handler;
+
+    EventHandlerToCallListenerAdapter(EventHandler<T> eventHandler) {
+      this.handler = checkNotNull(eventHandler, "eventHandler");
+    }
+
+    @Override
+    public void onHeaders(Metadata headers) {}
+
+    @Override
+    public void onMessage(T message) {
+      handler.onRecvMessage(message);
+    }
+
+    @Override
+    public void onClose(Status status, Metadata trailers) {
+      handler.onStatusReceived(status);
+    }
+
+    @Override
+    public void onReady() {
+      handler.onReady();
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/HttpConnectionManager.java b/xds/src/main/java/io/grpc/xds/HttpConnectionManager.java
new file mode 100644
index 00000000000..8128a42fb06
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/HttpConnectionManager.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableList;
+import io.grpc.xds.Filter.NamedFilterConfig;
+import java.util.List;
+import javax.annotation.Nullable;
+
+/**
+ * HttpConnectionManager is a network filter for proxying HTTP requests.
+ */
+@AutoValue
+abstract class HttpConnectionManager {
+  // Total number of nanoseconds to keep alive an HTTP request/response stream.
+  abstract long httpMaxStreamDurationNano();
+
+  // Name of the route configuration to be used for RDS resource discovery.
+  @Nullable
+  abstract String rdsName();
+
+  // List of virtual hosts that make up the route table.
+  @Nullable
+  abstract ImmutableList<VirtualHost> virtualHosts();
+
+  // List of http filter configs. Null if HttpFilter support is not enabled.
+  @Nullable
+  abstract ImmutableList<NamedFilterConfig> httpFilterConfigs();
+
+  static HttpConnectionManager forRdsName(long httpMaxStreamDurationNano, String rdsName,
+      @Nullable List<NamedFilterConfig> httpFilterConfigs) {
+    checkNotNull(rdsName, "rdsName");
+    return create(httpMaxStreamDurationNano, rdsName, null, httpFilterConfigs);
+  }
+
+  static HttpConnectionManager forVirtualHosts(long httpMaxStreamDurationNano,
+      List<VirtualHost> virtualHosts, @Nullable List<NamedFilterConfig> httpFilterConfigs) {
+    checkNotNull(virtualHosts, "virtualHosts");
+    return create(httpMaxStreamDurationNano, null, virtualHosts,
+        httpFilterConfigs);
+  }
+
+  private static HttpConnectionManager create(long httpMaxStreamDurationNano,
+      @Nullable String rdsName, @Nullable List<VirtualHost> virtualHosts,
+      @Nullable List<NamedFilterConfig> httpFilterConfigs) {
+    return new AutoValue_HttpConnectionManager(
+        httpMaxStreamDurationNano, rdsName,
+        virtualHosts == null ? null : ImmutableList.copyOf(virtualHosts),
+        httpFilterConfigs == null ? null : ImmutableList.copyOf(httpFilterConfigs));
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/InternalGrpcBootstrapperImpl.java b/xds/src/main/java/io/grpc/xds/InternalGrpcBootstrapperImpl.java
new file mode 100644
index 00000000000..7bbc2a6dfca
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/InternalGrpcBootstrapperImpl.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2024 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.xds;
+
+import io.grpc.Internal;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.XdsInitializationException;
+import java.util.Map;
+
+/**
+ * Internal accessors for GrpcBootstrapperImpl.
+ */
+@Internal
+public final class InternalGrpcBootstrapperImpl {
+  private InternalGrpcBootstrapperImpl() {} // prevent instantiation
+
+  public static BootstrapInfo parseBootstrap(Map<String, ?> bootstrap)
+      throws XdsInitializationException {
+    return new GrpcBootstrapperImpl().bootstrap(bootstrap);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/InternalRbacFilter.java b/xds/src/main/java/io/grpc/xds/InternalRbacFilter.java
new file mode 100644
index 00000000000..476adbf9cfd
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/InternalRbacFilter.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2021 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.xds;
+
+import io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBAC;
+import io.grpc.Internal;
+import io.grpc.ServerInterceptor;
+
+/** This class exposes some functionality in RbacFilter to other packages. */
+@Internal
+public final class InternalRbacFilter {
+
+  private InternalRbacFilter() {}
+
+  /** Parses RBAC filter config and creates AuthorizationServerInterceptor. */
+  public static ServerInterceptor createInterceptor(RBAC rbac) {
+    ConfigOrError<RbacConfig> filterConfig = RbacFilter.Provider.parseRbacConfig(rbac);
+    if (filterConfig.errorDetail != null) {
+      throw new IllegalArgumentException(
+        String.format("Failed to parse Rbac policy: %s", filterConfig.errorDetail));
+    }
+    return new RbacFilter.Provider().newInstance("internalRbacFilter")
+        .buildServerInterceptor(filterConfig.config, null);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/InternalSharedXdsClientPoolProvider.java b/xds/src/main/java/io/grpc/xds/InternalSharedXdsClientPoolProvider.java
new file mode 100644
index 00000000000..cc5ff128274
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/InternalSharedXdsClientPoolProvider.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2022 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.xds;
+
+import io.grpc.CallCredentials;
+import io.grpc.Internal;
+import io.grpc.MetricRecorder;
+import io.grpc.internal.ObjectPool;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsInitializationException;
+import java.util.Map;
+
+/**
+ * Accessor for global factory for managing XdsClient instance.
+ */
+@Internal
+public final class InternalSharedXdsClientPoolProvider {
+  // Prevent instantiation
+  private InternalSharedXdsClientPoolProvider() {}
+
+  /**
+   * Override the global bootstrap.
+   *
+   * @deprecated Use InternalGrpcBootstrapperImpl.parseBootstrap() and pass the result to
+   *     getOrCreate().
+   */
+  @Deprecated
+  public static void setDefaultProviderBootstrapOverride(Map<String, ?> bootstrap) {
+    GrpcBootstrapperImpl.setDefaultBootstrapOverride(bootstrap);
+  }
+
+  /**
+   * Get an XdsClient pool.
+   *
+   * @deprecated Use InternalGrpcBootstrapperImpl.parseBootstrap() and pass the result to the other
+   *     getOrCreate().
+   */
+  @Deprecated
+  public static ObjectPool<XdsClient> getOrCreate(String target)
+      throws XdsInitializationException {
+    return getOrCreate(target, new MetricRecorder() {});
+  }
+
+  /**
+   * Get an XdsClient pool.
+   *
+   * @deprecated Use InternalGrpcBootstrapperImpl.parseBootstrap() and pass the result to the other
+   *     getOrCreate().
+   */
+  @Deprecated
+  public static ObjectPool<XdsClient> getOrCreate(String target, MetricRecorder metricRecorder)
+      throws XdsInitializationException {
+    return getOrCreate(target, metricRecorder, null);
+  }
+
+  /**
+   * Get an XdsClient pool.
+   *
+   * @deprecated Use InternalGrpcBootstrapperImpl.parseBootstrap() and pass the result to the other
+   *     getOrCreate().
+   */
+  @Deprecated
+  public static ObjectPool<XdsClient> getOrCreate(
+      String target, MetricRecorder metricRecorder, CallCredentials transportCallCredentials)
+      throws XdsInitializationException {
+    return SharedXdsClientPoolProvider.getDefaultProvider()
+        .getOrCreate(target, metricRecorder, transportCallCredentials);
+  }
+
+  public static XdsClientResult getOrCreate(
+      String target, BootstrapInfo bootstrapInfo, MetricRecorder metricRecorder,
+      CallCredentials transportCallCredentials) {
+    return new XdsClientResult(SharedXdsClientPoolProvider.getDefaultProvider()
+        .getOrCreate(target, bootstrapInfo, metricRecorder, transportCallCredentials));
+  }
+
+  /**
+   * An ObjectPool, except without exposing io.grpc.internal, which must not be used for
+   * cross-package APIs.
+   */
+  public static final class XdsClientResult {
+    private final ObjectPool<XdsClient> xdsClientPool;
+
+    XdsClientResult(ObjectPool<XdsClient> xdsClientPool) {
+      this.xdsClientPool = xdsClientPool;
+    }
+
+    public XdsClient getObject() {
+      return xdsClientPool.getObject();
+    }
+
+    public XdsClient returnObject(XdsClient xdsClient) {
+      return xdsClientPool.returnObject(xdsClient);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/InternalXdsAttributes.java b/xds/src/main/java/io/grpc/xds/InternalXdsAttributes.java
new file mode 100644
index 00000000000..ed70e6f5e78
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/InternalXdsAttributes.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 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.xds;
+
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.Internal;
+
+/**
+ * Internal attributes used for xDS implementation. Do not use.
+ */
+@Internal
+public final class InternalXdsAttributes {
+  /**
+   * Name of the cluster that provides this EquivalentAddressGroup.
+   */
+  @EquivalentAddressGroup.Attr
+  public static final Attributes.Key<String> ATTR_CLUSTER_NAME =
+      XdsAttributes.ATTR_CLUSTER_NAME;
+
+  private InternalXdsAttributes() {}
+}
diff --git a/xds/src/main/java/io/grpc/xds/LazyLoadBalancer.java b/xds/src/main/java/io/grpc/xds/LazyLoadBalancer.java
new file mode 100644
index 00000000000..b5f09c4ea93
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/LazyLoadBalancer.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2024 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.xds;
+
+import com.google.common.base.Preconditions;
+import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer;
+import io.grpc.Status;
+import io.grpc.util.ForwardingLoadBalancer;
+
+/**
+ * A load balancer that starts in IDLE instead of CONNECTING. Once it starts connecting, it
+ * instantiates its delegate.
+ */
+final class LazyLoadBalancer extends ForwardingLoadBalancer {
+  private LoadBalancer delegate;
+
+  public LazyLoadBalancer(Helper helper, LoadBalancer.Factory delegateFactory) {
+    this.delegate = new LazyDelegate(helper, delegateFactory);
+  }
+
+  @Override
+  protected LoadBalancer delegate() {
+    return delegate;
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    return delegate.acceptResolvedAddresses(resolvedAddresses);
+  }
+
+  private final class LazyDelegate extends LoadBalancer {
+    private final Helper helper;
+    private final LoadBalancer.Factory delegateFactory;
+    private ResolvedAddresses addresses;
+    private Status error;
+    private boolean updatedBalancingState;
+
+    public LazyDelegate(Helper helper, LoadBalancer.Factory delegateFactory) {
+      this.helper = Preconditions.checkNotNull(helper, "helper");
+      this.delegateFactory = Preconditions.checkNotNull(delegateFactory, "delegateFactory");
+    }
+
+    private LoadBalancer activate() {
+      if (delegate != this) {
+        return delegate;
+      }
+      delegate = delegateFactory.newLoadBalancer(helper);
+      if (addresses != null) {
+        delegate.acceptResolvedAddresses(addresses);
+      }
+      if (error != null) {
+        delegate.handleNameResolutionError(error);
+      }
+      return delegate;
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      this.addresses = resolvedAddresses;
+      this.error = null;
+      initializeBalancingState();
+      return Status.OK;
+    }
+
+    @Override
+    public void handleNameResolutionError(Status error) {
+      // Preserve addresses, because even old addresses may be used by the real policy
+      this.error = error;
+      initializeBalancingState();
+    }
+
+    private void initializeBalancingState() {
+      if (updatedBalancingState) {
+        return;
+      }
+      helper.updateBalancingState(ConnectivityState.IDLE, new LazyPicker());
+      updatedBalancingState = true;
+    }
+
+    @Override
+    public void requestConnection() {
+      activate().requestConnection();
+    }
+
+    @Override
+    public void shutdown() {
+      delegate = new NoopLoadBalancer();
+    }
+
+    private final class LazyPicker extends SubchannelPicker {
+      @Override
+      public PickResult pickSubchannel(PickSubchannelArgs args) {
+        // activate() is a no-op after shutdown()
+        helper.getSynchronizationContext().execute(LazyDelegate.this::activate);
+        return PickResult.withNoResult();
+      }
+    }
+  }
+
+  public static final class Factory extends LoadBalancer.Factory {
+    private final LoadBalancer.Factory delegate;
+
+    public Factory(LoadBalancer.Factory delegate) {
+      this.delegate = Preconditions.checkNotNull(delegate, "delegate");
+    }
+
+    @Override public LoadBalancer newLoadBalancer(Helper helper) {
+      return new LazyLoadBalancer(helper, delegate);
+    }
+  }
+
+  private static final class NoopLoadBalancer extends LoadBalancer {
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      return Status.OK;
+    }
+
+    @Override
+    public void handleNameResolutionError(Status error) {}
+
+    @Override
+    public void shutdown() {}
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/LeastRequestLoadBalancer.java b/xds/src/main/java/io/grpc/xds/LeastRequestLoadBalancer.java
new file mode 100644
index 00000000000..1f23f2a4af5
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/LeastRequestLoadBalancer.java
@@ -0,0 +1,334 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static io.grpc.xds.LeastRequestLoadBalancerProvider.DEFAULT_CHOICE_COUNT;
+import static io.grpc.xds.LeastRequestLoadBalancerProvider.MAX_CHOICE_COUNT;
+import static io.grpc.xds.LeastRequestLoadBalancerProvider.MIN_CHOICE_COUNT;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import io.grpc.Attributes;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ClientStreamTracer.StreamInfo;
+import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.util.MultiChildLoadBalancer;
+import io.grpc.xds.ThreadSafeRandom.ThreadSafeRandomImpl;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * A {@link LoadBalancer} that provides least request load balancing based on
+ * outstanding request counters.
+ * It works by sampling a number of subchannels and picking the one with the
+ * fewest amount of outstanding requests.
+ * The default sampling amount of two is also known as
+ * the "power of two choices" (P2C).
+ */
+final class LeastRequestLoadBalancer extends MultiChildLoadBalancer {
+  private final ThreadSafeRandom random;
+
+  private SubchannelPicker currentPicker = new FixedResultPicker(PickResult.withNoResult());
+  private int choiceCount = DEFAULT_CHOICE_COUNT;
+
+  LeastRequestLoadBalancer(Helper helper) {
+    this(helper, ThreadSafeRandomImpl.instance);
+  }
+
+  @VisibleForTesting
+  LeastRequestLoadBalancer(Helper helper, ThreadSafeRandom random) {
+    super(helper);
+    this.random = checkNotNull(random, "random");
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    // Need to update choiceCount before calling super so that the updateBalancingState call has the
+    // new value.  However, if the update fails we need to revert it.
+    int oldChoiceCount = choiceCount;
+    LeastRequestConfig config =
+        (LeastRequestConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+    if (config != null) {
+      choiceCount = config.choiceCount;
+    }
+
+    Status addressAcceptanceStatus = super.acceptResolvedAddresses(resolvedAddresses);
+
+    if (!addressAcceptanceStatus.isOk()) {
+      choiceCount = oldChoiceCount;
+    }
+
+    return addressAcceptanceStatus;
+  }
+
+  /**
+   * Updates picker with the list of active subchannels (state == READY).
+   *
+   *  <p>
+   * If no active subchannels exist, but some are in TRANSIENT_FAILURE then returns a picker
+   * with all of the children in TF so that the application code will get an error from a varying
+   * random one when it tries to get a subchannel.
+   * </p>
+   */
+  @SuppressWarnings("ReferenceEquality")
+  @Override
+  protected void updateOverallBalancingState() {
+    List<ChildLbState> activeList = getReadyChildren();
+    if (activeList.isEmpty()) {
+      // No READY subchannels, determine aggregate state and error status
+      boolean isConnecting = false;
+      List<ChildLbState> childrenInTf = new ArrayList<>();
+      for (ChildLbState childLbState : getChildLbStates()) {
+        ConnectivityState state = childLbState.getCurrentState();
+        if (state == CONNECTING || state == IDLE) {
+          isConnecting = true;
+        } else if (state == TRANSIENT_FAILURE) {
+          childrenInTf.add(childLbState);
+        }
+      }
+      if (isConnecting) {
+        updateBalancingState(CONNECTING, new FixedResultPicker(PickResult.withNoResult()));
+      } else {
+        // Give it all the failing children and let it randomly pick among them
+        updateBalancingState(TRANSIENT_FAILURE,
+            new ReadyPicker(childrenInTf, choiceCount, random));
+      }
+    } else {
+      updateBalancingState(READY, new ReadyPicker(activeList, choiceCount, random));
+    }
+  }
+
+  @Override
+  protected ChildLbState createChildLbState(Object key) {
+    return new LeastRequestLbState(key, pickFirstLbProvider);
+  }
+
+  private void updateBalancingState(ConnectivityState state, SubchannelPicker picker) {
+    if (state != currentConnectivityState || !picker.equals(currentPicker)) {
+      getHelper().updateBalancingState(state, picker);
+      currentConnectivityState = state;
+      currentPicker = picker;
+    }
+  }
+
+  /**
+   * This should ONLY be used by tests.
+   */
+  @VisibleForTesting
+  void setResolvingAddresses(boolean newValue) {
+    super.resolvingAddresses = newValue;
+  }
+
+  // Expose for tests in this package.
+  private static AtomicInteger getInFlights(ChildLbState childLbState) {
+    return ((LeastRequestLbState)childLbState).activeRequests;
+  }
+
+  @VisibleForTesting
+  static final class ReadyPicker extends SubchannelPicker {
+    private final List<SubchannelPicker> childPickers; // non-empty
+    private final List<AtomicInteger> childInFlights; // 1:1 with childPickers
+    private final int choiceCount;
+    private final ThreadSafeRandom random;
+    private final int hashCode;
+
+    ReadyPicker(List<ChildLbState> childLbStates, int choiceCount, ThreadSafeRandom random) {
+      checkArgument(!childLbStates.isEmpty(), "empty list");
+      this.childPickers = new ArrayList<>(childLbStates.size());
+      this.childInFlights = new ArrayList<>(childLbStates.size());
+      for (ChildLbState state : childLbStates) {
+        childPickers.add(state.getCurrentPicker());
+        childInFlights.add(getInFlights(state));
+      }
+      this.choiceCount = choiceCount;
+      this.random = checkNotNull(random, "random");
+
+      int sum = 0;
+      for (SubchannelPicker child : childPickers) {
+        sum += child.hashCode();
+      }
+      this.hashCode = sum ^ choiceCount;
+    }
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      int child = nextChildToUse();
+      PickResult childResult = childPickers.get(child).pickSubchannel(args);
+
+      if (!childResult.getStatus().isOk() || childResult.getSubchannel() == null) {
+        return childResult;
+      }
+
+      if (childResult.getStreamTracerFactory() != null) {
+        // Already wrapped, so just use the current picker for selected child
+        return childResult;
+      } else {
+        // Wrap the subchannel
+        OutstandingRequestsTracingFactory factory =
+            new OutstandingRequestsTracingFactory(childInFlights.get(child));
+        return PickResult.withSubchannel(childResult.getSubchannel(), factory);
+      }
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(ReadyPicker.class)
+                        .add("list", childPickers)
+                        .add("choiceCount", choiceCount)
+                        .toString();
+    }
+
+    private int nextChildToUse() {
+      int candidate = random.nextInt(childPickers.size());
+      for (int i = 0; i < choiceCount - 1; ++i) {
+        int sampled = random.nextInt(childPickers.size());
+        if (childInFlights.get(sampled).get() < childInFlights.get(candidate).get()) {
+          candidate = sampled;
+        }
+      }
+      return candidate;
+    }
+
+    @VisibleForTesting
+    List<SubchannelPicker> getChildPickers() {
+      return childPickers;
+    }
+
+    @Override
+    public int hashCode() {
+      return hashCode;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (!(o instanceof ReadyPicker)) {
+        return false;
+      }
+      ReadyPicker other = (ReadyPicker) o;
+      if (other == this) {
+        return true;
+      }
+      // the lists cannot contain duplicate children
+      return hashCode == other.hashCode
+          && choiceCount == other.choiceCount
+          && childPickers.size() == other.childPickers.size()
+          && new HashSet<>(childPickers).containsAll(other.childPickers);
+    }
+  }
+
+  @VisibleForTesting
+  static final class EmptyPicker extends SubchannelPicker {
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      return PickResult.withNoResult();
+    }
+
+    @Override
+    public int hashCode() {
+      return getClass().hashCode();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      return o instanceof EmptyPicker;
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(EmptyPicker.class).toString();
+    }
+  }
+
+  private static final class OutstandingRequestsTracingFactory extends
+      ClientStreamTracer.Factory {
+    private final AtomicInteger inFlights;
+
+    private OutstandingRequestsTracingFactory(AtomicInteger inFlights) {
+      this.inFlights = checkNotNull(inFlights, "inFlights");
+    }
+
+    @Override
+    public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+      return new ClientStreamTracer() {
+        @Override
+        public void streamCreated(Attributes transportAttrs, Metadata headers) {
+          inFlights.incrementAndGet();
+        }
+
+        @Override
+        public void streamClosed(Status status) {
+          inFlights.decrementAndGet();
+        }
+      };
+    }
+  }
+
+  static final class LeastRequestConfig {
+    final int choiceCount;
+
+    LeastRequestConfig(int choiceCount) {
+      checkArgument(choiceCount >= MIN_CHOICE_COUNT, "choiceCount <= 1");
+      // Even though a choiceCount value larger than 2 is currently considered valid in xDS
+      // we restrict it to 10 here as specified in "A48: xDS Least Request LB Policy".
+      this.choiceCount = Math.min(choiceCount, MAX_CHOICE_COUNT);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("choiceCount", choiceCount)
+          .toString();
+    }
+  }
+
+  protected class LeastRequestLbState extends ChildLbState {
+    private final AtomicInteger activeRequests = new AtomicInteger(0);
+
+    public LeastRequestLbState(Object key, LoadBalancerProvider policyProvider) {
+      super(key, policyProvider);
+    }
+
+    int getActiveRequests() {
+      return activeRequests.get();
+    }
+
+    @Override
+    protected ChildLbStateHelper createChildHelper() {
+      return new ChildLbStateHelper() {
+        @Override
+        public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+          super.updateBalancingState(newState, newPicker);
+          if (!resolvingAddresses && newState == IDLE) {
+            getLb().requestConnection();
+          }
+        }
+      };
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/LeastRequestLoadBalancerProvider.java b/xds/src/main/java/io/grpc/xds/LeastRequestLoadBalancerProvider.java
new file mode 100644
index 00000000000..f9281f695ca
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/LeastRequestLoadBalancerProvider.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2021 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.xds;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.JsonUtil;
+import io.grpc.xds.LeastRequestLoadBalancer.LeastRequestConfig;
+import java.util.Map;
+
+/**
+ * Provider for the "least_request_experimental" balancing policy.
+ */
+@Internal
+public final class LeastRequestLoadBalancerProvider extends LoadBalancerProvider {
+  // Minimum number of choices allowed.
+  static final int MIN_CHOICE_COUNT = 2;
+  // Maximum number of choices allowed.
+  static final int MAX_CHOICE_COUNT = 10;
+  // Same as ClientXdsClient.DEFAULT_LEAST_REQUEST_CHOICE_COUNT
+  @VisibleForTesting
+  static final Integer DEFAULT_CHOICE_COUNT = 2;
+
+  @Override
+  public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+    return new LeastRequestLoadBalancer(helper);
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return "least_request_experimental";
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
+    try {
+      Integer choiceCount = JsonUtil.getNumberAsInteger(rawConfig, "choiceCount");
+      if (choiceCount == null) {
+        choiceCount = DEFAULT_CHOICE_COUNT;
+      }
+      if (choiceCount < MIN_CHOICE_COUNT) {
+        return ConfigOrError.fromError(Status.UNAVAILABLE.withDescription(
+            "Invalid 'choiceCount' in least_request_experimental config"));
+      }
+      return ConfigOrError.fromConfig(new LeastRequestConfig(choiceCount));
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError(
+          Status.UNAVAILABLE.withCause(e).withDescription(
+              "Failed to parse least_request_experimental LB config: " + rawConfig));
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/LoadBalancerConfigFactory.java b/xds/src/main/java/io/grpc/xds/LoadBalancerConfigFactory.java
new file mode 100644
index 00000000000..e08ea0fab43
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/LoadBalancerConfigFactory.java
@@ -0,0 +1,452 @@
+/*
+ * Copyright 2022 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.xds;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.protobuf.Any;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Struct;
+import com.google.protobuf.util.Durations;
+import com.google.protobuf.util.JsonFormat;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.LeastRequestLbConfig;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.RingHashLbConfig;
+import io.envoyproxy.envoy.config.cluster.v3.LoadBalancingPolicy;
+import io.envoyproxy.envoy.config.cluster.v3.LoadBalancingPolicy.Policy;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.client_side_weighted_round_robin.v3.ClientSideWeightedRoundRobin;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.least_request.v3.LeastRequest;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.pick_first.v3.PickFirst;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.ring_hash.v3.RingHash;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.round_robin.v3.RoundRobin;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.wrr_locality.v3.WrrLocality;
+import io.grpc.InternalLogId;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.internal.JsonParser;
+import io.grpc.xds.LoadBalancerConfigFactory.LoadBalancingPolicyConverter.MaxRecursionReachedException;
+import io.grpc.xds.client.XdsLogger;
+import io.grpc.xds.client.XdsLogger.XdsLogLevel;
+import io.grpc.xds.client.XdsResourceType.ResourceInvalidException;
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * Creates service config JSON  load balancer config objects for a given xDS Cluster message.
+ * Supports both the "legacy" configuration style and the new, more advanced one that utilizes the
+ * xDS "typed extension" mechanism.
+ *
+ * <p>Legacy configuration is done by setting the lb_policy enum field and any supporting
+ * configuration fields needed by the particular policy.
+ *
+ * <p>The new approach is to set the load_balancing_policy field that contains both the policy
+ * selection as well as any supporting configuration data. Providing a list of acceptable policies
+ * is also supported. Note that if this field is used, it will override any configuration set using
+ * the legacy approach. The new configuration approach is explained in detail in the <a href="
+ * https://github.com/grpc/proposal/blob/master/A52-xds-custom-lb-policies.md">Custom LB Policies
+ * gRFC</a>
+ */
+class LoadBalancerConfigFactory {
+
+  private static final XdsLogger logger = XdsLogger.withLogId(
+      InternalLogId.allocate("xds-client-lbconfig-factory", null));
+
+  static final String ROUND_ROBIN_FIELD_NAME = "round_robin";
+
+  static final String RING_HASH_FIELD_NAME = "ring_hash_experimental";
+  static final String MIN_RING_SIZE_FIELD_NAME = "minRingSize";
+  static final String MAX_RING_SIZE_FIELD_NAME = "maxRingSize";
+
+  static final String LEAST_REQUEST_FIELD_NAME = "least_request_experimental";
+  static final String CHOICE_COUNT_FIELD_NAME = "choiceCount";
+
+  static final String WRR_LOCALITY_FIELD_NAME = "wrr_locality_experimental";
+  static final String CHILD_POLICY_FIELD = "childPolicy";
+
+  static final String BLACK_OUT_PERIOD = "blackoutPeriod";
+
+  static final String WEIGHT_EXPIRATION_PERIOD = "weightExpirationPeriod";
+
+  static final String OOB_REPORTING_PERIOD = "oobReportingPeriod";
+
+  static final String ENABLE_OOB_LOAD_REPORT = "enableOobLoadReport";
+
+  static final String WEIGHT_UPDATE_PERIOD = "weightUpdatePeriod";
+
+  static final String PICK_FIRST_FIELD_NAME = "pick_first";
+  static final String SHUFFLE_ADDRESS_LIST_FIELD_NAME = "shuffleAddressList";
+
+  static final String ERROR_UTILIZATION_PENALTY = "errorUtilizationPenalty";
+
+  /**
+   * Factory method for creating a new {link LoadBalancerConfigConverter} for a given xDS {@link
+   * Cluster}.
+   *
+   * @throws ResourceInvalidException If the {@link Cluster} has an invalid LB configuration.
+   */
+  static ImmutableMap<String, ?> newConfig(Cluster cluster, boolean enableLeastRequest)
+      throws ResourceInvalidException {
+    // The new load_balancing_policy will always be used if it is set, but for backward
+    // compatibility we will fall back to using the old lb_policy field if the new field is not set.
+    if (cluster.hasLoadBalancingPolicy()) {
+      try {
+        return LoadBalancingPolicyConverter.convertToServiceConfig(cluster.getLoadBalancingPolicy(),
+            0);
+      } catch (MaxRecursionReachedException e) {
+        throw new ResourceInvalidException("Maximum LB config recursion depth reached", e);
+      }
+    } else {
+      return LegacyLoadBalancingPolicyConverter.convertToServiceConfig(cluster, enableLeastRequest);
+    }
+  }
+
+  /**
+   * Builds a service config JSON object for the ring_hash load balancer config based on the given
+   * config values.
+   */
+  private static ImmutableMap<String, ?> buildRingHashConfig(Long minRingSize, Long maxRingSize) {
+    ImmutableMap.Builder<String, Object> configBuilder = ImmutableMap.builder();
+    if (minRingSize != null) {
+      configBuilder.put(MIN_RING_SIZE_FIELD_NAME, minRingSize.doubleValue());
+    }
+    if (maxRingSize != null) {
+      configBuilder.put(MAX_RING_SIZE_FIELD_NAME, maxRingSize.doubleValue());
+    }
+    return ImmutableMap.of(RING_HASH_FIELD_NAME, configBuilder.buildOrThrow());
+  }
+
+  /**
+   * Builds a service config JSON object for the weighted_round_robin load balancer config based on
+   * the given config values.
+   */
+  private static ImmutableMap<String, ?> buildWrrConfig(String blackoutPeriod,
+                                                        String weightExpirationPeriod,
+                                                        String oobReportingPeriod,
+                                                        Boolean enableOobLoadReport,
+                                                        String weightUpdatePeriod,
+                                                        Float errorUtilizationPenalty) {
+    ImmutableMap.Builder<String, Object> configBuilder = ImmutableMap.builder();
+    if (blackoutPeriod != null) {
+      configBuilder.put(BLACK_OUT_PERIOD, blackoutPeriod);
+    }
+    if (weightExpirationPeriod != null) {
+      configBuilder.put(WEIGHT_EXPIRATION_PERIOD, weightExpirationPeriod);
+    }
+    if (oobReportingPeriod != null) {
+      configBuilder.put(OOB_REPORTING_PERIOD, oobReportingPeriod);
+    }
+    if (enableOobLoadReport != null) {
+      configBuilder.put(ENABLE_OOB_LOAD_REPORT, enableOobLoadReport);
+    }
+    if (weightUpdatePeriod != null) {
+      configBuilder.put(WEIGHT_UPDATE_PERIOD, weightUpdatePeriod);
+    }
+    if (errorUtilizationPenalty != null) {
+      configBuilder.put(ERROR_UTILIZATION_PENALTY, errorUtilizationPenalty);
+    }
+    return ImmutableMap.of(WeightedRoundRobinLoadBalancerProvider.SCHEME,
+        configBuilder.buildOrThrow());
+  }
+
+  /**
+   * Builds a service config JSON object for the least_request load balancer config based on the
+   * given config values.
+   */
+  private static ImmutableMap<String, ?> buildLeastRequestConfig(Integer choiceCount) {
+    ImmutableMap.Builder<String, Object> configBuilder = ImmutableMap.builder();
+    if (choiceCount != null) {
+      configBuilder.put(CHOICE_COUNT_FIELD_NAME, choiceCount.doubleValue());
+    }
+    return ImmutableMap.of(LEAST_REQUEST_FIELD_NAME, configBuilder.buildOrThrow());
+  }
+
+  /**
+   * Builds a service config JSON wrr_locality by wrapping another policy config.
+   */
+  private static ImmutableMap<String, ?> buildWrrLocalityConfig(
+      ImmutableMap<String, ?> childConfig) {
+    return ImmutableMap.<String, Object>builder().put(WRR_LOCALITY_FIELD_NAME,
+        ImmutableMap.of(CHILD_POLICY_FIELD, ImmutableList.of(childConfig))).buildOrThrow();
+  }
+
+  /**
+   * Builds an empty service config JSON config object for round robin (it is not configurable).
+   */
+  private static ImmutableMap<String, ?> buildRoundRobinConfig() {
+    return ImmutableMap.of(ROUND_ROBIN_FIELD_NAME, ImmutableMap.of());
+  }
+
+  /**
+   * Builds a service config JSON object for the pick_first load balancer config based on the
+   * given config values.
+   */
+  private static ImmutableMap<String, ?> buildPickFirstConfig(boolean shuffleAddressList) {
+    ImmutableMap.Builder<String, Object> configBuilder = ImmutableMap.builder();
+    configBuilder.put(SHUFFLE_ADDRESS_LIST_FIELD_NAME, shuffleAddressList);
+    return ImmutableMap.of(PICK_FIRST_FIELD_NAME, configBuilder.buildOrThrow());
+  }
+
+  /**
+   * Responsible for converting from a {@code envoy.config.cluster.v3.LoadBalancingPolicy} proto
+   * message to a gRPC service config format.
+   */
+  static class LoadBalancingPolicyConverter {
+
+    private static final int MAX_RECURSION = 16;
+
+    /**
+     * Converts a {@link LoadBalancingPolicy} object to a service config JSON object.
+     */
+    private static ImmutableMap<String, ?> convertToServiceConfig(
+        LoadBalancingPolicy loadBalancingPolicy, int recursionDepth)
+        throws ResourceInvalidException, MaxRecursionReachedException {
+      if (recursionDepth > MAX_RECURSION) {
+        throw new MaxRecursionReachedException();
+      }
+      ImmutableMap<String, ?> serviceConfig = null;
+
+      for (Policy policy : loadBalancingPolicy.getPoliciesList()) {
+        Any typedConfig = policy.getTypedExtensionConfig().getTypedConfig();
+        try {
+          if (typedConfig.is(RingHash.class)) {
+            serviceConfig = convertRingHashConfig(typedConfig.unpack(RingHash.class));
+          } else if (typedConfig.is(WrrLocality.class)) {
+            serviceConfig = convertWrrLocalityConfig(typedConfig.unpack(WrrLocality.class),
+                recursionDepth);
+          } else if (typedConfig.is(RoundRobin.class)) {
+            serviceConfig = convertRoundRobinConfig();
+          } else if (typedConfig.is(LeastRequest.class)) {
+            serviceConfig = convertLeastRequestConfig(typedConfig.unpack(LeastRequest.class));
+          } else if (typedConfig.is(ClientSideWeightedRoundRobin.class)) {
+            serviceConfig = convertWeightedRoundRobinConfig(
+                typedConfig.unpack(ClientSideWeightedRoundRobin.class));
+          } else if (typedConfig.is(PickFirst.class)) {
+            serviceConfig = convertPickFirstConfig(typedConfig.unpack(PickFirst.class));
+          } else if (typedConfig.is(com.github.xds.type.v3.TypedStruct.class)) {
+            serviceConfig = convertCustomConfig(
+                typedConfig.unpack(com.github.xds.type.v3.TypedStruct.class));
+          } else if (typedConfig.is(com.github.udpa.udpa.type.v1.TypedStruct.class)) {
+            serviceConfig = convertCustomConfig(
+                typedConfig.unpack(com.github.udpa.udpa.type.v1.TypedStruct.class));
+          }
+
+          // TODO: support least_request once it is added to the envoy protos.
+        } catch (InvalidProtocolBufferException e) {
+          throw new ResourceInvalidException(
+              "Unable to unpack typedConfig for: " + typedConfig.getTypeUrl(), e);
+        }
+        // The service config is expected to have a single root entry, where the name of that entry
+        // is the name of the policy. A Load balancer with this name must exist in the registry.
+        if (serviceConfig == null || LoadBalancerRegistry.getDefaultRegistry()
+            .getProvider(Iterables.getOnlyElement(serviceConfig.keySet())) == null) {
+          logger.log(XdsLogLevel.WARNING, "Policy {0} not found in the LB registry, skipping",
+              typedConfig.getTypeUrl());
+          continue;
+        } else {
+          return serviceConfig;
+        }
+      }
+
+      // If we could not find a Policy that we could both convert as well as find a provider for
+      // then we have an invalid LB policy configuration.
+      throw new ResourceInvalidException("Invalid LoadBalancingPolicy: " + loadBalancingPolicy);
+    }
+
+    /**
+     * Converts a ring_hash {@link Any} configuration to service config format.
+     */
+    private static ImmutableMap<String, ?> convertRingHashConfig(RingHash ringHash)
+        throws ResourceInvalidException {
+      // The hash function needs to be validated here as it is not exposed in the returned
+      // configuration for later validation.
+      if (RingHash.HashFunction.XX_HASH != ringHash.getHashFunction()) {
+        throw new ResourceInvalidException(
+            "Invalid ring hash function: " + ringHash.getHashFunction());
+      }
+
+      return buildRingHashConfig(
+          ringHash.hasMinimumRingSize() ? ringHash.getMinimumRingSize().getValue() : null,
+          ringHash.hasMaximumRingSize() ? ringHash.getMaximumRingSize().getValue() : null);
+    }
+
+    private static ImmutableMap<String, ?> convertWeightedRoundRobinConfig(
+            ClientSideWeightedRoundRobin wrr) throws ResourceInvalidException {
+      try {
+        return buildWrrConfig(
+            wrr.hasBlackoutPeriod() ? Durations.toString(wrr.getBlackoutPeriod()) : null,
+            wrr.hasWeightExpirationPeriod()
+                ? Durations.toString(wrr.getWeightExpirationPeriod()) : null,
+            wrr.hasOobReportingPeriod() ? Durations.toString(wrr.getOobReportingPeriod()) : null,
+            wrr.hasEnableOobLoadReport() ? wrr.getEnableOobLoadReport().getValue() : null,
+            wrr.hasWeightUpdatePeriod() ? Durations.toString(wrr.getWeightUpdatePeriod()) : null,
+            wrr.hasErrorUtilizationPenalty() ? wrr.getErrorUtilizationPenalty().getValue() : null);
+      } catch (IllegalArgumentException ex) {
+        throw new ResourceInvalidException("Invalid duration in weighted round robin config: "
+            + ex.getMessage());
+      }
+    }
+
+    /**
+     * Converts a wrr_locality {@link Any} configuration to service config format.
+     */
+    private static ImmutableMap<String, ?> convertWrrLocalityConfig(WrrLocality wrrLocality,
+        int recursionDepth)
+        throws ResourceInvalidException, MaxRecursionReachedException {
+      return buildWrrLocalityConfig(
+          convertToServiceConfig(wrrLocality.getEndpointPickingPolicy(), recursionDepth + 1));
+    }
+
+    /**
+     * "Converts" a round_robin configuration to service config format.
+     */
+    private static ImmutableMap<String, ?> convertRoundRobinConfig() {
+      return buildRoundRobinConfig();
+    }
+
+    /**
+     * "Converts" a pick_first configuration to service config format.
+     */
+    private static ImmutableMap<String, ?> convertPickFirstConfig(PickFirst pickFirst) {
+      return buildPickFirstConfig(pickFirst.getShuffleAddressList());
+    }
+
+    /**
+     * Converts a least_request {@link Any} configuration to service config format.
+     */
+    private static ImmutableMap<String, ?> convertLeastRequestConfig(LeastRequest leastRequest)
+        throws ResourceInvalidException {
+      return buildLeastRequestConfig(
+          leastRequest.hasChoiceCount() ? leastRequest.getChoiceCount().getValue() : null);
+    }
+
+    /**
+     * Converts a custom TypedStruct LB config to service config format.
+     */
+    @SuppressWarnings("unchecked")
+    private static ImmutableMap<String, ?> convertCustomConfig(
+        com.github.xds.type.v3.TypedStruct configTypedStruct)
+        throws ResourceInvalidException {
+      return ImmutableMap.of(parseCustomConfigTypeName(configTypedStruct.getTypeUrl()),
+          (Map<String, ?>) parseCustomConfigJson(configTypedStruct.getValue()));
+    }
+
+    /**
+     * Converts a custom UDPA (legacy) TypedStruct LB config to service config format.
+     */
+    @SuppressWarnings("unchecked")
+    private static ImmutableMap<String, ?> convertCustomConfig(
+        com.github.udpa.udpa.type.v1.TypedStruct configTypedStruct)
+        throws ResourceInvalidException {
+      return ImmutableMap.of(parseCustomConfigTypeName(configTypedStruct.getTypeUrl()),
+          (Map<String, ?>) parseCustomConfigJson(configTypedStruct.getValue()));
+    }
+
+    /**
+     * Print the config Struct into JSON and then parse that into our internal representation.
+     */
+    private static Object parseCustomConfigJson(Struct configStruct)
+        throws ResourceInvalidException {
+      Object rawJsonConfig = null;
+      try {
+        rawJsonConfig = JsonParser.parse(JsonFormat.printer().print(configStruct));
+      } catch (IOException e) {
+        throw new ResourceInvalidException("Unable to parse custom LB config JSON", e);
+      }
+
+      if (!(rawJsonConfig instanceof Map)) {
+        throw new ResourceInvalidException("Custom LB config does not contain a JSON object");
+      }
+      return rawJsonConfig;
+    }
+
+
+    private static String parseCustomConfigTypeName(String customConfigTypeName) {
+      if (customConfigTypeName.contains("/")) {
+        customConfigTypeName = customConfigTypeName.substring(
+            customConfigTypeName.lastIndexOf("/") + 1);
+      }
+      return customConfigTypeName;
+    }
+
+    // Used to signal that the LB config goes too deep.
+    static class MaxRecursionReachedException extends Exception {
+      static final long serialVersionUID = 1L;
+    }
+  }
+
+  /**
+   * Builds a JSON LB configuration based on the old style of using the xDS Cluster proto message.
+   * The lb_policy field is used to select the policy and configuration is extracted from various
+   * policy specific fields in Cluster.
+   */
+  static class LegacyLoadBalancingPolicyConverter {
+
+    /**
+     * Factory method for creating a new {link LoadBalancerConfigConverter} for a given xDS {@link
+     * Cluster}.
+     *
+     * @throws ResourceInvalidException If the {@link Cluster} has an invalid LB configuration.
+     */
+    static ImmutableMap<String, ?> convertToServiceConfig(Cluster cluster,
+        boolean enableLeastRequest) throws ResourceInvalidException {
+      switch (cluster.getLbPolicy()) {
+        case RING_HASH:
+          return convertRingHashConfig(cluster);
+        case ROUND_ROBIN:
+          return buildWrrLocalityConfig(buildRoundRobinConfig());
+        case LEAST_REQUEST:
+          if (enableLeastRequest) {
+            return buildWrrLocalityConfig(convertLeastRequestConfig(cluster));
+          }
+          break;
+        default:
+      }
+      throw new ResourceInvalidException(
+          "Cluster " + cluster.getName() + ": unsupported lb policy: " + cluster.getLbPolicy());
+    }
+
+    /**
+     * Creates a new ring_hash service config JSON object based on the old {@link RingHashLbConfig}
+     * config message.
+     */
+    private static ImmutableMap<String, ?> convertRingHashConfig(Cluster cluster)
+        throws ResourceInvalidException {
+      RingHashLbConfig lbConfig = cluster.getRingHashLbConfig();
+
+      // The hash function needs to be validated here as it is not exposed in the returned
+      // configuration for later validation.
+      if (lbConfig.getHashFunction() != RingHashLbConfig.HashFunction.XX_HASH) {
+        throw new ResourceInvalidException(
+            "Cluster " + cluster.getName() + ": invalid ring hash function: " + lbConfig);
+      }
+
+      return buildRingHashConfig(
+          lbConfig.hasMinimumRingSize() ? (Long) lbConfig.getMinimumRingSize().getValue() : null,
+          lbConfig.hasMaximumRingSize() ? (Long) lbConfig.getMaximumRingSize().getValue() : null);
+    }
+
+    /**
+     * Creates a new least_request service config JSON object based on the old {@link
+     * LeastRequestLbConfig} config message.
+     */
+    private static ImmutableMap<String, ?> convertLeastRequestConfig(Cluster cluster) {
+      LeastRequestLbConfig lbConfig = cluster.getLeastRequestLbConfig();
+      return buildLeastRequestConfig(
+          lbConfig.hasChoiceCount() ? (Integer) lbConfig.getChoiceCount().getValue() : null);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/MessagePrinter.java b/xds/src/main/java/io/grpc/xds/MessagePrinter.java
new file mode 100644
index 00000000000..d6fdaa81dd7
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/MessagePrinter.java
@@ -0,0 +1,103 @@
+/*
+ * 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.xds;
+
+import com.github.xds.type.v3.TypedStruct;
+import com.google.protobuf.Descriptors.Descriptor;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Message;
+import com.google.protobuf.MessageOrBuilder;
+import com.google.protobuf.TypeRegistry;
+import com.google.protobuf.util.JsonFormat;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;
+import io.envoyproxy.envoy.config.listener.v3.Listener;
+import io.envoyproxy.envoy.config.route.v3.RouteConfiguration;
+import io.envoyproxy.envoy.extensions.clusters.aggregate.v3.ClusterConfig;
+import io.envoyproxy.envoy.extensions.filters.http.fault.v3.HTTPFault;
+import io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBAC;
+import io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBACPerRoute;
+import io.envoyproxy.envoy.extensions.filters.http.router.v3.Router;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.round_robin.v3.RoundRobin;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.wrr_locality.v3.WrrLocality;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext;
+import io.envoyproxy.envoy.service.discovery.v3.Resource;
+import io.grpc.xds.client.MessagePrettyPrinter;
+
+/**
+ * Converts protobuf message to human readable String format. Useful for protobuf messages
+ * containing {@link com.google.protobuf.Any} fields.
+ */
+final class MessagePrinter implements MessagePrettyPrinter {
+  public static final MessagePrinter INSTANCE = new MessagePrinter();
+
+  private MessagePrinter() {}
+
+  // The initialization-on-demand holder idiom.
+  private static class LazyHolder {
+    static final JsonFormat.Printer printer = newPrinter();
+
+    private static JsonFormat.Printer newPrinter() {
+      TypeRegistry.Builder registry =
+          TypeRegistry.newBuilder()
+              .add(Resource.getDescriptor())
+              .add(Listener.getDescriptor())
+              .add(HttpConnectionManager.getDescriptor())
+              .add(HTTPFault.getDescriptor())
+              .add(RBAC.getDescriptor())
+              .add(RBACPerRoute.getDescriptor())
+              .add(Router.getDescriptor())
+              // UpstreamTlsContext and DownstreamTlsContext in v3 are not transitively imported
+              // by top-level resource types.
+              .add(UpstreamTlsContext.getDescriptor())
+              .add(DownstreamTlsContext.getDescriptor())
+              .add(RouteConfiguration.getDescriptor())
+              .add(Cluster.getDescriptor())
+              .add(ClusterConfig.getDescriptor())
+              .add(ClusterLoadAssignment.getDescriptor())
+              .add(WrrLocality.getDescriptor())
+              .add(TypedStruct.getDescriptor())
+              .add(RoundRobin.getDescriptor());
+      try {
+        @SuppressWarnings("unchecked")
+        Class<? extends Message> routeLookupClusterSpecifierClass =
+            (Class<? extends Message>)
+                Class.forName("io.grpc.lookup.v1.RouteLookupClusterSpecifier");
+        Descriptor descriptor =
+            (Descriptor)
+                routeLookupClusterSpecifierClass.getDeclaredMethod("getDescriptor").invoke(null);
+        registry.add(descriptor);
+      } catch (Exception e) {
+        // Ignore. In most cases RouteLookup is not required.
+      }
+      return JsonFormat.printer().usingTypeRegistry(registry.build());
+    }
+  }
+
+  @Override
+  public String print(MessageOrBuilder message) {
+    String res;
+    try {
+      res = LazyHolder.printer.print(message);
+    } catch (InvalidProtocolBufferException e) {
+      res = message + " (failed to pretty-print: " + e + ")";
+    }
+    return res;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/MetadataRegistry.java b/xds/src/main/java/io/grpc/xds/MetadataRegistry.java
new file mode 100644
index 00000000000..b79a61a261a
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/MetadataRegistry.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2024 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.xds;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Any;
+import com.google.protobuf.Struct;
+import io.envoyproxy.envoy.config.core.v3.Metadata;
+import io.grpc.xds.GcpAuthenticationFilter.AudienceMetadataParser;
+import io.grpc.xds.XdsEndpointResource.AddressMetadataParser;
+import io.grpc.xds.client.XdsResourceType.ResourceInvalidException;
+import io.grpc.xds.internal.ProtobufJsonConverter;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Registry for parsing cluster metadata values.
+ *
+ * <p>This class maintains a mapping of type URLs to {@link MetadataValueParser} instances,
+ * allowing for the parsing of different metadata types.
+ */
+final class MetadataRegistry {
+  private static final MetadataRegistry INSTANCE = new MetadataRegistry();
+
+  private final Map<String, MetadataValueParser> supportedParsers = new HashMap<>();
+
+  private MetadataRegistry() {
+    registerParser(new AudienceMetadataParser());
+    registerParser(new AddressMetadataParser());
+  }
+
+  static MetadataRegistry getInstance() {
+    return INSTANCE;
+  }
+
+  MetadataValueParser findParser(String typeUrl) {
+    return supportedParsers.get(typeUrl);
+  }
+
+  @VisibleForTesting
+  void registerParser(MetadataValueParser parser) {
+    supportedParsers.put(parser.getTypeUrl(), parser);
+  }
+
+  void removeParser(MetadataValueParser parser) {
+    supportedParsers.remove(parser.getTypeUrl());
+  }
+
+  /**
+   * Parses cluster metadata into a structured map.
+   *
+   * <p>Values in {@code typed_filter_metadata} take precedence over
+   * {@code filter_metadata} when keys overlap, following Envoy API behavior. See
+   * <a href="https://github.com/envoyproxy/envoy/blob/main/api/envoy/config/core/v3/base.proto#L217-L259">
+   *   Envoy metadata documentation </a> for details.
+   *
+   * @param metadata the {@link Metadata} containing the fields to parse.
+   * @return an immutable map of parsed metadata.
+   * @throws ResourceInvalidException if parsing {@code typed_filter_metadata} fails.
+   */
+  public ImmutableMap<String, Object> parseMetadata(Metadata metadata)
+      throws ResourceInvalidException {
+    ImmutableMap.Builder<String, Object> parsedMetadata = ImmutableMap.builder();
+
+    // Process typed_filter_metadata
+    for (Map.Entry<String, Any> entry : metadata.getTypedFilterMetadataMap().entrySet()) {
+      String key = entry.getKey();
+      Any value = entry.getValue();
+      MetadataValueParser parser = findParser(value.getTypeUrl());
+      if (parser != null) {
+        try {
+          Object parsedValue = parser.parse(value);
+          parsedMetadata.put(key, parsedValue);
+        } catch (ResourceInvalidException e) {
+          throw new ResourceInvalidException(
+              String.format("Failed to parse metadata key: %s, type: %s. Error: %s",
+                  key, value.getTypeUrl(), e.getMessage()), e);
+        }
+      }
+    }
+    // building once to reuse in the next loop
+    ImmutableMap<String, Object> intermediateParsedMetadata = parsedMetadata.build();
+
+    // Process filter_metadata for remaining keys
+    for (Map.Entry<String, Struct> entry : metadata.getFilterMetadataMap().entrySet()) {
+      String key = entry.getKey();
+      if (!intermediateParsedMetadata.containsKey(key)) {
+        Struct structValue = entry.getValue();
+        Object jsonValue = ProtobufJsonConverter.convertToJson(structValue);
+        parsedMetadata.put(key, jsonValue);
+      }
+    }
+
+    return parsedMetadata.build();
+  }
+
+  interface MetadataValueParser {
+
+    String getTypeUrl();
+
+    /**
+     * Parses the given {@link Any} object into a specific metadata value.
+     *
+     * @param any the {@link Any} object to parse.
+     * @return the parsed metadata value.
+     * @throws ResourceInvalidException if the parsing fails.
+     */
+    Object parse(Any any) throws ResourceInvalidException;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/PriorityLoadBalancer.java b/xds/src/main/java/io/grpc/xds/PriorityLoadBalancer.java
new file mode 100644
index 00000000000..6e4566de76d
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/PriorityLoadBalancer.java
@@ -0,0 +1,360 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+
+import io.grpc.ConnectivityState;
+import io.grpc.InternalLogId;
+import io.grpc.LoadBalancer;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig;
+import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig.PriorityChildConfig;
+import io.grpc.xds.client.XdsLogger;
+import io.grpc.xds.client.XdsLogger.XdsLogLevel;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * Load balancer for priority policy. A <em>priority</em> represents a logical entity within a
+ * cluster for load balancing purposes.
+ */
+final class PriorityLoadBalancer extends LoadBalancer {
+  private final Helper helper;
+  private final SynchronizationContext syncContext;
+  private final ScheduledExecutorService executor;
+  private final XdsLogger logger;
+
+  // Includes all active and deactivated children. Mutable. New entries are only added from priority
+  // 0 up to the selected priority. An entry is only deleted 15 minutes after its deactivation.
+  // Note that calling into a child can cause the child to call back into the LB policy and modify
+  // the map.  Therefore copy values before looping over them.
+  private final Map<String, ChildLbState> children = new HashMap<>();
+
+  // Following fields are only null initially.
+  private ResolvedAddresses resolvedAddresses;
+  // List of priority names in order.
+  private List<String> priorityNames;
+  // Config for each priority.
+  private Map<String, PriorityChildConfig> priorityConfigs;
+  @Nullable private String currentPriority;
+  private ConnectivityState currentConnectivityState;
+  private SubchannelPicker currentPicker;
+  // Set to true if currently in the process of handling resolved addresses.
+  private boolean handlingResolvedAddresses;
+
+  PriorityLoadBalancer(Helper helper) {
+    this.helper = checkNotNull(helper, "helper");
+    syncContext = helper.getSynchronizationContext();
+    executor = helper.getScheduledExecutorService();
+    InternalLogId logId = InternalLogId.allocate("priority-lb", helper.getAuthority());
+    logger = XdsLogger.withLogId(logId);
+    logger.log(XdsLogLevel.INFO, "Created");
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
+    this.resolvedAddresses = resolvedAddresses;
+    PriorityLbConfig config = (PriorityLbConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+    checkNotNull(config, "missing priority lb config");
+    priorityNames = config.priorities;
+    priorityConfigs = config.childConfigs;
+    Status status = Status.OK;
+    Set<String> prioritySet = new HashSet<>(config.priorities);
+    ArrayList<String> childKeys = new ArrayList<>(children.keySet());
+    for (String priority : childKeys) {
+      if (!prioritySet.contains(priority)) {
+        ChildLbState childLbState = children.get(priority);
+        if (childLbState != null) {
+          childLbState.deactivate();
+        }
+      }
+    }
+    handlingResolvedAddresses = true;
+    for (String priority : priorityNames) {
+      ChildLbState childLbState = children.get(priority);
+      if (childLbState != null) {
+        Status newStatus = childLbState.updateResolvedAddresses();
+        if (!newStatus.isOk()) {
+          status = newStatus;
+        }
+      }
+    }
+    handlingResolvedAddresses = false;
+    Status newStatus = tryNextPriority();
+    if (!newStatus.isOk()) {
+      status = newStatus;
+    }
+    return status;
+  }
+
+  @Override
+  public void handleNameResolutionError(Status error) {
+    logger.log(XdsLogLevel.WARNING, "Received name resolution error: {0}", error);
+    boolean gotoTransientFailure = true;
+    Collection<ChildLbState> childValues = new ArrayList<>(children.values());
+    for (ChildLbState child : childValues) {
+      if (priorityNames.contains(child.priority)) {
+        child.lb.handleNameResolutionError(error);
+        gotoTransientFailure = false;
+      }
+    }
+    if (gotoTransientFailure) {
+      updateOverallState(
+          null, TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
+    }
+  }
+
+  @Override
+  public void shutdown() {
+    logger.log(XdsLogLevel.INFO, "Shutdown");
+    Collection<ChildLbState> childValues = new ArrayList<>(children.values());
+    for (ChildLbState child : childValues) {
+      child.tearDown();
+    }
+    children.clear();
+  }
+
+  private Status tryNextPriority() {
+    for (int i = 0; i < priorityNames.size(); i++) {
+      String priority = priorityNames.get(i);
+      if (!children.containsKey(priority)) {
+        ChildLbState child =
+            new ChildLbState(priority, priorityConfigs.get(priority).ignoreReresolution);
+        children.put(priority, child);
+        // Child is created in CONNECTING with pending failOverTimer
+        updateOverallState(priority, child.connectivityState, child.picker);
+        // Calling the child's updateResolvedAddresses() can result in tryNextPriority() being
+        // called recursively. We need to be sure to be done with processing here before it is
+        // called.
+        return child.updateResolvedAddresses(); // Give priority i time to connect.
+      }
+      ChildLbState child = children.get(priority);
+      child.reactivate();
+      if (child.connectivityState.equals(READY) || child.connectivityState.equals(IDLE)) {
+        logger.log(XdsLogLevel.DEBUG, "Shifted to priority {0}", priority);
+        updateOverallState(priority, child.connectivityState, child.picker);
+        for (int j = i + 1; j < priorityNames.size(); j++) {
+          String p = priorityNames.get(j);
+          if (children.containsKey(p)) {
+            children.get(p).deactivate();
+          }
+        }
+        return Status.OK;
+      }
+      if (child.failOverTimer.isPending()) {
+        updateOverallState(priority, child.connectivityState, child.picker);
+        return Status.OK; // Give priority i time to connect.
+      }
+    }
+    for (int i = 0; i < priorityNames.size(); i++) {
+      String priority = priorityNames.get(i);
+      ChildLbState child = children.get(priority);
+      if (child.connectivityState.equals(CONNECTING)) {
+        updateOverallState(priority, child.connectivityState, child.picker);
+        return Status.OK;
+      }
+    }
+    logger.log(XdsLogLevel.DEBUG, "All priority failed");
+    String lastPriority = priorityNames.get(priorityNames.size() - 1);
+    ChildLbState child = children.get(lastPriority);
+    updateOverallState(lastPriority, child.connectivityState, child.picker);
+    return Status.OK;
+  }
+
+  private void updateOverallState(
+      @Nullable String priority, ConnectivityState state, SubchannelPicker picker) {
+    if (!Objects.equals(priority, currentPriority) || !state.equals(currentConnectivityState)
+        || !picker.equals(currentPicker)) {
+      currentPriority = priority;
+      currentConnectivityState = state;
+      currentPicker = picker;
+      helper.updateBalancingState(state, picker);
+    }
+  }
+
+  private final class ChildLbState {
+    final String priority;
+    final ChildHelper childHelper;
+    final GracefulSwitchLoadBalancer lb;
+    // Timer to fail over to the next priority if not connected in 10 sec. Scheduled only once at
+    // child initialization.
+    ScheduledHandle failOverTimer;
+    boolean seenReadyOrIdleSinceTransientFailure = false;
+    // Timer to delay shutdown and deletion of the priority. Scheduled whenever the child is
+    // deactivated.
+    @Nullable ScheduledHandle deletionTimer;
+    ConnectivityState connectivityState = CONNECTING;
+    SubchannelPicker picker = new FixedResultPicker(PickResult.withNoResult());
+
+    ChildLbState(final String priority, boolean ignoreReresolution) {
+      this.priority = priority;
+      childHelper = new ChildHelper(ignoreReresolution);
+      lb = new GracefulSwitchLoadBalancer(childHelper);
+      failOverTimer = syncContext.schedule(new FailOverTask(), 10, TimeUnit.SECONDS, executor);
+      logger.log(XdsLogLevel.DEBUG, "Priority created: {0}", priority);
+    }
+
+    final class FailOverTask implements Runnable {
+      @Override
+      public void run() {
+        if (deletionTimer != null && deletionTimer.isPending()) {
+          // The child is deactivated.
+          return;
+        }
+        logger.log(XdsLogLevel.DEBUG, "Priority {0} failed over to next", priority);
+        Status status = tryNextPriority();
+        if (!status.isOk()) {
+          // A child had a problem with the addresses/config. Request it to be refreshed
+          helper.refreshNameResolution();
+        }
+      }
+    }
+
+    /**
+     * Called when the child becomes a priority that is or appears before the first READY one in the
+     * {@code priorities} list, due to either config update or balancing state update.
+     */
+    void reactivate() {
+      if (deletionTimer != null && deletionTimer.isPending()) {
+        deletionTimer.cancel();
+        logger.log(XdsLogLevel.DEBUG, "Priority reactivated: {0}", priority);
+      }
+    }
+
+    /**
+     * Called when either the child is removed by config update, or a higher priority becomes READY.
+     */
+    void deactivate() {
+      if (deletionTimer != null && deletionTimer.isPending()) {
+        return;
+      }
+
+      class DeletionTask implements Runnable {
+        @Override
+        public void run() {
+          tearDown();
+          children.remove(priority);
+        }
+      }
+
+      deletionTimer = syncContext.schedule(new DeletionTask(), 15, TimeUnit.MINUTES, executor);
+      logger.log(XdsLogLevel.DEBUG, "Priority deactivated: {0}", priority);
+    }
+
+    void tearDown() {
+      if (failOverTimer.isPending()) {
+        failOverTimer.cancel();
+      }
+      if (deletionTimer != null && deletionTimer.isPending()) {
+        deletionTimer.cancel();
+      }
+      lb.shutdown();
+      logger.log(XdsLogLevel.DEBUG, "Priority deleted: {0}", priority);
+    }
+
+    /**
+     * Called either when the child is just created and in this case updated with the cached {@code
+     * resolvedAddresses}, or when priority lb receives a new resolved addresses while the child
+     * already exists.
+     */
+    Status updateResolvedAddresses() {
+      PriorityLbConfig config =
+          (PriorityLbConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+      return lb.acceptResolvedAddresses(
+          resolvedAddresses.toBuilder()
+              .setAddresses(AddressFilter.filter(resolvedAddresses.getAddresses(), priority))
+              .setLoadBalancingPolicyConfig(config.childConfigs.get(priority).childConfig)
+              .build());
+    }
+
+    final class ChildHelper extends ForwardingLoadBalancerHelper {
+      private final boolean ignoreReresolution;
+
+      ChildHelper(boolean ignoreReresolution) {
+        this.ignoreReresolution = ignoreReresolution;
+      }
+
+      @Override
+      public void refreshNameResolution() {
+        if (!ignoreReresolution) {
+          delegate().refreshNameResolution();
+        }
+      }
+
+      @Override
+      public void updateBalancingState(final ConnectivityState newState,
+          final SubchannelPicker newPicker) {
+        if (!children.containsKey(priority)) {
+          return;
+        }
+        ConnectivityState oldState = connectivityState;
+        connectivityState = newState;
+        picker = newPicker;
+
+        if (deletionTimer != null && deletionTimer.isPending()) {
+          return;
+        }
+        if (newState.equals(CONNECTING) && !oldState.equals(newState)) {
+          if (!failOverTimer.isPending() && seenReadyOrIdleSinceTransientFailure) {
+            failOverTimer = syncContext.schedule(new FailOverTask(), 10, TimeUnit.SECONDS,
+                executor);
+          }
+        } else if (newState.equals(READY) || newState.equals(IDLE)) {
+          seenReadyOrIdleSinceTransientFailure = true;
+          failOverTimer.cancel();
+        } else if (newState.equals(TRANSIENT_FAILURE)) {
+          seenReadyOrIdleSinceTransientFailure = false;
+          failOverTimer.cancel();
+        }
+
+        // If we are currently handling newly resolved addresses, let's not try to reconfigure as
+        // the address handling process will take care of that to provide an atomic config update.
+        if (!handlingResolvedAddresses) {
+          Status status = tryNextPriority();
+          if (!status.isOk()) {
+            // A child had a problem with the addresses/config. Request it to be refreshed
+            helper.refreshNameResolution();
+          }
+        }
+      }
+
+      @Override
+      protected Helper delegate() {
+        return helper;
+      }
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/PriorityLoadBalancerProvider.java b/xds/src/main/java/io/grpc/xds/PriorityLoadBalancerProvider.java
new file mode 100644
index 00000000000..1aab6c31b08
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/PriorityLoadBalancerProvider.java
@@ -0,0 +1,109 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+
+/** Provider for priority load balancing policy. */
+@Internal
+public final class PriorityLoadBalancerProvider extends LoadBalancerProvider {
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return XdsLbPolicies.PRIORITY_POLICY_NAME;
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    return new PriorityLoadBalancer(helper);
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
+    return ConfigOrError.fromError(
+        Status.INTERNAL.withDescription(getPolicyName() + " cannot be used from service config"));
+  }
+
+  static final class PriorityLbConfig {
+    final Map<String, PriorityChildConfig> childConfigs;
+    final List<String> priorities;
+
+    PriorityLbConfig(Map<String, PriorityChildConfig> childConfigs, List<String> priorities) {
+      this.childConfigs = Collections.unmodifiableMap(checkNotNull(childConfigs, "childConfigs"));
+      this.priorities = Collections.unmodifiableList(checkNotNull(priorities, "priorities"));
+      checkArgument(!priorities.isEmpty(), "priority list is empty");
+      checkArgument(
+          childConfigs.keySet().containsAll(priorities),
+          "missing child config for at lease one of the priorities");
+      checkArgument(
+          priorities.size() == new HashSet<>(priorities).size(),
+          "duplicate names in priorities");
+      checkArgument(
+          priorities.size() == childConfigs.keySet().size(),
+          "some names in childConfigs are not referenced by priorities");
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("childConfigs", childConfigs)
+          .add("priorities", priorities)
+          .toString();
+    }
+
+    static final class PriorityChildConfig {
+      final Object childConfig;
+      final boolean ignoreReresolution;
+
+      PriorityChildConfig(Object childConfig, boolean ignoreReresolution) {
+        this.childConfig = checkNotNull(childConfig, "childConfig");
+        this.ignoreReresolution = ignoreReresolution;
+      }
+
+      @Override
+      public String toString() {
+        return MoreObjects.toStringHelper(this)
+            .add("childConfig", childConfig)
+            .add("ignoreReresolution", ignoreReresolution)
+            .toString();
+      }
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/RbacConfig.java b/xds/src/main/java/io/grpc/xds/RbacConfig.java
new file mode 100644
index 00000000000..14f6ae33e1f
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/RbacConfig.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2021 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.xds;
+
+import com.google.auto.value.AutoValue;
+import io.grpc.xds.Filter.FilterConfig;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AuthConfig;
+import javax.annotation.Nullable;
+
+/** Rbac configuration for Rbac filter. */
+@AutoValue
+abstract class RbacConfig implements FilterConfig {
+  @Override
+  public final String typeUrl() {
+    return RbacFilter.TYPE_URL;
+  }
+
+  @Nullable
+  abstract AuthConfig authConfig();
+
+  static RbacConfig create(@Nullable AuthConfig authConfig) {
+    return new AutoValue_RbacConfig(authConfig);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/RbacFilter.java b/xds/src/main/java/io/grpc/xds/RbacFilter.java
new file mode 100644
index 00000000000..91df1e68802
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/RbacFilter.java
@@ -0,0 +1,363 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.protobuf.Any;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Message;
+import io.envoyproxy.envoy.config.core.v3.CidrRange;
+import io.envoyproxy.envoy.config.rbac.v3.Permission;
+import io.envoyproxy.envoy.config.rbac.v3.Policy;
+import io.envoyproxy.envoy.config.rbac.v3.Principal;
+import io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBAC;
+import io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBACPerRoute;
+import io.envoyproxy.envoy.type.v3.Int32Range;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.Status;
+import io.grpc.xds.internal.MatcherParser;
+import io.grpc.xds.internal.Matchers;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AlwaysTrueMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AndMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AuthConfig;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AuthDecision;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AuthHeaderMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AuthenticatedMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.DestinationIpMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.DestinationPortMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.DestinationPortRangeMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.InvertMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.Matcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.OrMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.PathMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.PolicyMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.RequestedServerNameMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.SourceIpMatcher;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+import javax.annotation.Nullable;
+
+/** RBAC Http filter implementation. */
+final class RbacFilter implements Filter {
+  private static final Logger logger = Logger.getLogger(RbacFilter.class.getName());
+
+  private static final RbacFilter INSTANCE = new RbacFilter();
+
+  static final String TYPE_URL =
+          "type.googleapis.com/envoy.extensions.filters.http.rbac.v3.RBAC";
+
+  private static final String TYPE_URL_OVERRIDE_CONFIG =
+          "type.googleapis.com/envoy.extensions.filters.http.rbac.v3.RBACPerRoute";
+
+  private RbacFilter() {}
+
+  static final class Provider implements Filter.Provider {
+    @Override
+    public String[] typeUrls() {
+      return new String[] {TYPE_URL, TYPE_URL_OVERRIDE_CONFIG};
+    }
+
+    @Override
+    public boolean isServerFilter() {
+      return true;
+    }
+
+    @Override
+    public RbacFilter newInstance(String name) {
+      return INSTANCE;
+    }
+
+    @Override
+    public ConfigOrError<RbacConfig> parseFilterConfig(Message rawProtoMessage) {
+      RBAC rbacProto;
+      if (!(rawProtoMessage instanceof Any)) {
+        return ConfigOrError.fromError("Invalid config type: " + rawProtoMessage.getClass());
+      }
+      Any anyMessage = (Any) rawProtoMessage;
+      try {
+        rbacProto = anyMessage.unpack(RBAC.class);
+      } catch (InvalidProtocolBufferException e) {
+        return ConfigOrError.fromError("Invalid proto: " + e);
+      }
+      return parseRbacConfig(rbacProto);
+    }
+
+    @Override
+    public ConfigOrError<RbacConfig> parseFilterConfigOverride(Message rawProtoMessage) {
+      RBACPerRoute rbacPerRoute;
+      if (!(rawProtoMessage instanceof Any)) {
+        return ConfigOrError.fromError("Invalid config type: " + rawProtoMessage.getClass());
+      }
+      Any anyMessage = (Any) rawProtoMessage;
+      try {
+        rbacPerRoute = anyMessage.unpack(RBACPerRoute.class);
+      } catch (InvalidProtocolBufferException e) {
+        return ConfigOrError.fromError("Invalid proto: " + e);
+      }
+      if (rbacPerRoute.hasRbac()) {
+        return parseRbacConfig(rbacPerRoute.getRbac());
+      } else {
+        return ConfigOrError.fromConfig(RbacConfig.create(null));
+      }
+    }
+
+    static ConfigOrError<RbacConfig> parseRbacConfig(RBAC rbac) {
+      if (!rbac.hasRules()) {
+        return ConfigOrError.fromConfig(RbacConfig.create(null));
+      }
+      io.envoyproxy.envoy.config.rbac.v3.RBAC rbacConfig = rbac.getRules();
+      GrpcAuthorizationEngine.Action authAction;
+      switch (rbacConfig.getAction()) {
+        case ALLOW:
+          authAction = GrpcAuthorizationEngine.Action.ALLOW;
+          break;
+        case DENY:
+          authAction = GrpcAuthorizationEngine.Action.DENY;
+          break;
+        case LOG:
+          return ConfigOrError.fromConfig(RbacConfig.create(null));
+        case UNRECOGNIZED:
+        default:
+          return ConfigOrError.fromError(
+              "Unknown rbacConfig action type: " + rbacConfig.getAction());
+      }
+      List<GrpcAuthorizationEngine.PolicyMatcher> policyMatchers = new ArrayList<>();
+      List<Entry<String, Policy>> sortedPolicyEntries = rbacConfig.getPoliciesMap().entrySet()
+          .stream()
+          .sorted((a,b) -> a.getKey().compareTo(b.getKey()))
+          .collect(Collectors.toList());
+      for (Map.Entry<String, Policy> entry: sortedPolicyEntries) {
+        try {
+          Policy policy = entry.getValue();
+          if (policy.hasCondition() || policy.hasCheckedCondition()) {
+            return ConfigOrError.fromError(
+                "Policy.condition and Policy.checked_condition must not set: " + entry.getKey());
+          }
+          policyMatchers.add(PolicyMatcher.create(entry.getKey(),
+              parsePermissionList(policy.getPermissionsList()),
+              parsePrincipalList(policy.getPrincipalsList())));
+        } catch (Exception e) {
+          return ConfigOrError.fromError("Encountered error parsing policy: " + e);
+        }
+      }
+      return ConfigOrError.fromConfig(RbacConfig.create(
+          AuthConfig.create(policyMatchers, authAction)));
+    }
+  }
+
+  @Nullable
+  @Override
+  public ServerInterceptor buildServerInterceptor(FilterConfig config,
+                                                  @Nullable FilterConfig overrideConfig) {
+    checkNotNull(config, "config");
+    if (overrideConfig != null) {
+      config = overrideConfig;
+    }
+    AuthConfig authConfig = ((RbacConfig) config).authConfig();
+    return authConfig == null ? null : generateAuthorizationInterceptor(authConfig);
+  }
+
+  private ServerInterceptor generateAuthorizationInterceptor(AuthConfig config) {
+    checkNotNull(config, "config");
+    final GrpcAuthorizationEngine authEngine = new GrpcAuthorizationEngine(config);
+    return new ServerInterceptor() {
+        @Override
+        public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+                final ServerCall<ReqT, RespT> call,
+                final Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+          AuthDecision authResult = authEngine.evaluate(headers, call);
+          if (logger.isLoggable(Level.FINE)) {
+            logger.log(Level.FINE,
+                "Authorization result for serverCall {0}: {1}, matching policy: {2}.",
+                new Object[]{call, authResult.decision(), authResult.matchingPolicyName()});
+          }
+          if (GrpcAuthorizationEngine.Action.DENY.equals(authResult.decision())) {
+            Status status = Status.PERMISSION_DENIED.withDescription("Access Denied");
+            call.close(status, new Metadata());
+            return new ServerCall.Listener<ReqT>(){};
+          }
+          return next.startCall(call, headers);
+        }
+    };
+  }
+
+  private static OrMatcher parsePermissionList(List<Permission> permissions) {
+    List<Matcher> anyMatch = new ArrayList<>();
+    for (Permission permission : permissions) {
+      anyMatch.add(parsePermission(permission));
+    }
+    return OrMatcher.create(anyMatch);
+  }
+
+  private static Matcher parsePermission(Permission permission) {
+    switch (permission.getRuleCase()) {
+      case AND_RULES:
+        List<Matcher> andMatch = new ArrayList<>();
+        for (Permission p : permission.getAndRules().getRulesList()) {
+          andMatch.add(parsePermission(p));
+        }
+        return AndMatcher.create(andMatch);
+      case OR_RULES:
+        return parsePermissionList(permission.getOrRules().getRulesList());
+      case ANY:
+        return AlwaysTrueMatcher.INSTANCE;
+      case HEADER:
+        return parseHeaderMatcher(permission.getHeader());
+      case URL_PATH:
+        return parsePathMatcher(permission.getUrlPath());
+      case DESTINATION_IP:
+        return createDestinationIpMatcher(permission.getDestinationIp());
+      case DESTINATION_PORT:
+        return createDestinationPortMatcher(permission.getDestinationPort());
+      case DESTINATION_PORT_RANGE:
+        return parseDestinationPortRangeMatcher(permission.getDestinationPortRange());
+      case NOT_RULE:
+        return InvertMatcher.create(parsePermission(permission.getNotRule()));
+      case METADATA: // hard coded, never match.
+        return InvertMatcher.create(AlwaysTrueMatcher.INSTANCE);
+      case REQUESTED_SERVER_NAME:
+        return parseRequestedServerNameMatcher(permission.getRequestedServerName());
+      case RULE_NOT_SET:
+      default:
+        throw new IllegalArgumentException(
+                "Unknown permission rule case: " + permission.getRuleCase());
+    }
+  }
+
+  private static OrMatcher parsePrincipalList(List<Principal> principals) {
+    List<Matcher> anyMatch = new ArrayList<>();
+    for (Principal principal: principals) {
+      anyMatch.add(parsePrincipal(principal));
+    }
+    return OrMatcher.create(anyMatch);
+  }
+
+  private static Matcher parsePrincipal(Principal principal) {
+    switch (principal.getIdentifierCase()) {
+      case OR_IDS:
+        return parsePrincipalList(principal.getOrIds().getIdsList());
+      case AND_IDS:
+        List<Matcher> nextMatchers = new ArrayList<>();
+        for (Principal next : principal.getAndIds().getIdsList()) {
+          nextMatchers.add(parsePrincipal(next));
+        }
+        return AndMatcher.create(nextMatchers);
+      case ANY:
+        return AlwaysTrueMatcher.INSTANCE;
+      case AUTHENTICATED:
+        return parseAuthenticatedMatcher(principal.getAuthenticated());
+      case DIRECT_REMOTE_IP:
+        return createSourceIpMatcher(principal.getDirectRemoteIp());
+      case REMOTE_IP:
+        return createSourceIpMatcher(principal.getRemoteIp());
+      case SOURCE_IP: {
+        // gRFC A41 has identical handling of source_ip as remote_ip and direct_remote_ip and
+        // pre-dates the deprecation.
+        @SuppressWarnings("deprecation")
+        CidrRange sourceIp = principal.getSourceIp();
+        return createSourceIpMatcher(sourceIp);
+      }
+      case HEADER:
+        return parseHeaderMatcher(principal.getHeader());
+      case NOT_ID:
+        return InvertMatcher.create(parsePrincipal(principal.getNotId()));
+      case URL_PATH:
+        return parsePathMatcher(principal.getUrlPath());
+      case METADATA: // hard coded, never match.
+        return InvertMatcher.create(AlwaysTrueMatcher.INSTANCE);
+      case IDENTIFIER_NOT_SET:
+      default:
+        throw new IllegalArgumentException(
+                "Unknown principal identifier case: " + principal.getIdentifierCase());
+    }
+  }
+
+  private static PathMatcher parsePathMatcher(
+          io.envoyproxy.envoy.type.matcher.v3.PathMatcher proto) {
+    switch (proto.getRuleCase()) {
+      case PATH:
+        return PathMatcher.create(MatcherParser.parseStringMatcher(proto.getPath()));
+      case RULE_NOT_SET:
+      default:
+        throw new IllegalArgumentException(
+                "Unknown path matcher rule type: " + proto.getRuleCase());
+    }
+  }
+
+  private static RequestedServerNameMatcher parseRequestedServerNameMatcher(
+          io.envoyproxy.envoy.type.matcher.v3.StringMatcher proto) {
+    return RequestedServerNameMatcher.create(MatcherParser.parseStringMatcher(proto));
+  }
+
+  private static AuthHeaderMatcher parseHeaderMatcher(
+          io.envoyproxy.envoy.config.route.v3.HeaderMatcher proto) {
+    if (proto.getName().startsWith("grpc-")) {
+      throw new IllegalArgumentException("Invalid header matcher config: [grpc-] prefixed "
+          + "header name is not allowed.");
+    }
+    if (":scheme".equals(proto.getName())) {
+      throw new IllegalArgumentException("Invalid header matcher config: header name [:scheme] "
+          + "is not allowed.");
+    }
+    return AuthHeaderMatcher.create(MatcherParser.parseHeaderMatcher(proto));
+  }
+
+  private static AuthenticatedMatcher parseAuthenticatedMatcher(
+          Principal.Authenticated proto) {
+    Matchers.StringMatcher matcher = MatcherParser.parseStringMatcher(proto.getPrincipalName());
+    return AuthenticatedMatcher.create(matcher);
+  }
+
+  private static DestinationPortMatcher createDestinationPortMatcher(int port) {
+    return DestinationPortMatcher.create(port);
+  }
+
+  private static DestinationPortRangeMatcher parseDestinationPortRangeMatcher(Int32Range range) {
+    return DestinationPortRangeMatcher.create(range.getStart(), range.getEnd());
+  }
+
+  private static DestinationIpMatcher createDestinationIpMatcher(CidrRange cidrRange) {
+    return DestinationIpMatcher.create(Matchers.CidrMatcher.create(
+            resolve(cidrRange), cidrRange.getPrefixLen().getValue()));
+  }
+
+  private static SourceIpMatcher createSourceIpMatcher(CidrRange cidrRange) {
+    return SourceIpMatcher.create(Matchers.CidrMatcher.create(
+            resolve(cidrRange), cidrRange.getPrefixLen().getValue()));
+  }
+
+  private static InetAddress resolve(CidrRange cidrRange) {
+    try {
+      return InetAddress.getByName(cidrRange.getAddressPrefix());
+    } catch (UnknownHostException ex) {
+      throw new IllegalArgumentException("IP address can not be found: " + ex);
+    }
+  }
+}
+
diff --git a/xds/src/main/java/io/grpc/xds/RingHashLoadBalancer.java b/xds/src/main/java/io/grpc/xds/RingHashLoadBalancer.java
new file mode 100644
index 00000000000..513f4d643ea
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/RingHashLoadBalancer.java
@@ -0,0 +1,575 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Joiner;
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.HashMultiset;
+import com.google.common.collect.Multiset;
+import com.google.common.primitives.UnsignedInteger;
+import io.grpc.Attributes;
+import io.grpc.ConnectivityState;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.InternalLogId;
+import io.grpc.LoadBalancer;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.util.MultiChildLoadBalancer;
+import io.grpc.xds.ThreadSafeRandom.ThreadSafeRandomImpl;
+import io.grpc.xds.client.XdsLogger;
+import io.grpc.xds.client.XdsLogger.XdsLogLevel;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link LoadBalancer} that provides consistent hashing based load balancing to upstream hosts.
+ * It implements the "Ketama" hashing that maps hosts onto a circle (the "ring") by hashing its
+ * addresses. Each request is routed to a host by hashing some property of the request and finding
+ * the nearest corresponding host clockwise around the ring. Each host is placed on the ring some
+ * number of times proportional to its weight. With the ring partitioned appropriately, the
+ * addition or removal of one host from a set of N hosts will affect only 1/N requests.
+ */
+final class RingHashLoadBalancer extends MultiChildLoadBalancer {
+  private static final Status RPC_HASH_NOT_FOUND =
+      Status.INTERNAL.withDescription("RPC hash not found. Probably a bug because xds resolver"
+          + " config selector always generates a hash.");
+  private static final XxHash64 hashFunc = XxHash64.INSTANCE;
+
+  private final LoadBalancer.Factory lazyLbFactory =
+      new LazyLoadBalancer.Factory(pickFirstLbProvider);
+  private final XdsLogger logger;
+  private final SynchronizationContext syncContext;
+  private final ThreadSafeRandom random;
+  private List<RingEntry> ring;
+  @Nullable private Metadata.Key<String> requestHashHeaderKey;
+
+  RingHashLoadBalancer(Helper helper) {
+    this(helper, ThreadSafeRandomImpl.instance);
+  }
+
+  @VisibleForTesting
+  RingHashLoadBalancer(Helper helper, ThreadSafeRandom random) {
+    super(helper);
+    syncContext = checkNotNull(helper.getSynchronizationContext(), "syncContext");
+    logger = XdsLogger.withLogId(InternalLogId.allocate("ring_hash_lb", helper.getAuthority()));
+    logger.log(XdsLogLevel.INFO, "Created");
+    this.random = checkNotNull(random, "random");
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
+    List<EquivalentAddressGroup> addrList = resolvedAddresses.getAddresses();
+    Status addressValidityStatus = validateAddrList(addrList);
+    if (!addressValidityStatus.isOk()) {
+      return addressValidityStatus;
+    }
+
+    // Now do the ringhash specific logic with weights and building the ring
+    RingHashConfig config = (RingHashConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+    if (config == null) {
+      throw new IllegalArgumentException("Missing RingHash configuration");
+    }
+    requestHashHeaderKey =
+        config.requestHashHeader.isEmpty()
+            ? null
+            : Metadata.Key.of(config.requestHashHeader, Metadata.ASCII_STRING_MARSHALLER);
+    Map<EquivalentAddressGroup, Long> serverWeights = new HashMap<>();
+    long totalWeight = 0L;
+    for (EquivalentAddressGroup eag : addrList) {
+      Long weight = eag.getAttributes().get(XdsAttributes.ATTR_SERVER_WEIGHT);
+      // Support two ways of server weighing: either multiple instances of the same address
+      // or each address contains a per-address weight attribute. If a weight is not provided,
+      // each occurrence of the address will be counted a weight value of one.
+      if (weight == null) {
+        weight = 1L;
+      }
+      totalWeight += weight;
+      EquivalentAddressGroup addrKey = stripAttrs(eag);
+      if (serverWeights.containsKey(addrKey)) {
+        serverWeights.put(addrKey, serverWeights.get(addrKey) + weight);
+      } else {
+        serverWeights.put(addrKey, weight);
+      }
+    }
+    // Calculate scale
+    long minWeight = Collections.min(serverWeights.values());
+    double normalizedMinWeight = (double) minWeight / totalWeight;
+    // Scale up the number of hashes per host such that the least-weighted host gets a whole
+    // number of hashes on the the ring. Other hosts might not end up with whole numbers, and
+    // that's fine (the ring-building algorithm can handle this). This preserves the original
+    // implementation's behavior: when weights aren't provided, all hosts should get an equal
+    // number of hashes. In the case where this number exceeds the max_ring_size, it's scaled
+    // back down to fit.
+    double scale = Math.min(
+        Math.ceil(normalizedMinWeight * config.minRingSize) / normalizedMinWeight,
+        (double) config.maxRingSize);
+
+    // Build the ring
+    ring = buildRing(serverWeights, totalWeight, scale);
+
+    return super.acceptResolvedAddresses(resolvedAddresses);
+  }
+
+
+  /**
+   * Updates the overall balancing state by aggregating the connectivity states of all subchannels.
+   *
+   * <p>Aggregation rules (in order of dominance):
+   * <ol>
+   *   <li>If there is at least one subchannel in READY state, overall state is READY</li>
+   *   <li>If there are <em>2 or more</em> subchannels in TRANSIENT_FAILURE, overall state is
+   *   TRANSIENT_FAILURE (to allow timely failover to another policy)</li>
+   *   <li>If there is at least one subchannel in CONNECTING state, overall state is
+   *   CONNECTING</li>
+   *   <li> If there is one subchannel in TRANSIENT_FAILURE state and there is
+   *    more than one subchannel, report CONNECTING </li>
+   *   <li>If there is at least one subchannel in IDLE state, overall state is IDLE</li>
+   *   <li>Otherwise, overall state is TRANSIENT_FAILURE</li>
+   * </ol>
+   */
+  @Override
+  protected void updateOverallBalancingState() {
+    checkState(!getChildLbStates().isEmpty(), "no subchannel has been created");
+    if (this.currentConnectivityState == SHUTDOWN) {
+      // Ignore changes that happen after shutdown is called
+      logger.log(XdsLogLevel.DEBUG, "UpdateOverallBalancingState called after shutdown");
+      return;
+    }
+
+    // Calculate the current overall state to report
+    int numIdle = 0;
+    int numReady = 0;
+    int numConnecting = 0;
+    int numTF = 0;
+
+    forloop:
+    for (ChildLbState childLbState : getChildLbStates()) {
+      ConnectivityState state = childLbState.getCurrentState();
+      switch (state) {
+        case READY:
+          numReady++;
+          break forloop;
+        case CONNECTING:
+          numConnecting++;
+          break;
+        case IDLE:
+          numIdle++;
+          break;
+        case TRANSIENT_FAILURE:
+          numTF++;
+          break;
+        default:
+          // ignore it
+      }
+    }
+
+    ConnectivityState overallState;
+    if (numReady > 0) {
+      overallState = READY;
+    } else if (numTF >= 2) {
+      overallState = TRANSIENT_FAILURE;
+    } else if (numConnecting > 0) {
+      overallState = CONNECTING;
+    } else if (numTF == 1 && getChildLbStates().size() > 1) {
+      overallState = CONNECTING;
+    } else if (numIdle > 0) {
+      overallState = IDLE;
+    } else {
+      overallState = TRANSIENT_FAILURE;
+    }
+
+    // gRFC A61: if the aggregated connectivity state is TRANSIENT_FAILURE or CONNECTING and
+    // there are no endpoints in CONNECTING state, the ring_hash policy will choose one of
+    // the endpoints in IDLE state (if any) to trigger a connection attempt on
+    if (numReady == 0 && numTF > 0 && numConnecting == 0 && numIdle > 0) {
+      triggerIdleChildConnection();
+    }
+
+    RingHashPicker picker =
+        new RingHashPicker(syncContext, ring, getChildLbStates(), requestHashHeaderKey, random);
+    getHelper().updateBalancingState(overallState, picker);
+    this.currentConnectivityState = overallState;
+  }
+
+
+  /**
+   * Triggers a connection attempt for the first IDLE child load balancer.
+   */
+  private void triggerIdleChildConnection() {
+    for (ChildLbState child : getChildLbStates()) {
+      if (child.getCurrentState() == ConnectivityState.IDLE) {
+        child.getLb().requestConnection();
+        return;
+      }
+    }
+  }
+
+  @Override
+  protected ChildLbState createChildLbState(Object key) {
+    return new ChildLbState(key, lazyLbFactory);
+  }
+
+  private Status validateAddrList(List<EquivalentAddressGroup> addrList) {
+    if (addrList.isEmpty()) {
+      Status unavailableStatus = Status.UNAVAILABLE.withDescription("Ring hash lb error: EDS "
+              + "resolution was successful, but returned server addresses are empty.");
+      handleNameResolutionError(unavailableStatus);
+      return unavailableStatus;
+    }
+
+    String dupAddrString = validateNoDuplicateAddresses(addrList);
+    if (dupAddrString != null) {
+      Status unavailableStatus = Status.UNAVAILABLE.withDescription("Ring hash lb error: EDS "
+              + "resolution was successful, but there were duplicate addresses: " + dupAddrString);
+      handleNameResolutionError(unavailableStatus);
+      return unavailableStatus;
+    }
+
+    long totalWeight = 0;
+    for (EquivalentAddressGroup eag : addrList) {
+      Long weight = eag.getAttributes().get(XdsAttributes.ATTR_SERVER_WEIGHT);
+
+      if (weight == null) {
+        weight = 1L;
+      }
+
+      if (weight < 0) {
+        Status unavailableStatus = Status.UNAVAILABLE.withDescription(
+            String.format("Ring hash lb error: EDS resolution was successful, but returned a "
+                        + "negative weight for %s.", stripAttrs(eag)));
+        handleNameResolutionError(unavailableStatus);
+        return unavailableStatus;
+      }
+      if (weight > UnsignedInteger.MAX_VALUE.longValue()) {
+        Status unavailableStatus = Status.UNAVAILABLE.withDescription(
+            String.format("Ring hash lb error: EDS resolution was successful, but returned a weight"
+                + " too large to fit in an unsigned int for %s.", stripAttrs(eag)));
+        handleNameResolutionError(unavailableStatus);
+        return unavailableStatus;
+      }
+      totalWeight += weight;
+    }
+
+    if (totalWeight > UnsignedInteger.MAX_VALUE.longValue()) {
+      Status unavailableStatus = Status.UNAVAILABLE.withDescription(
+          String.format(
+              "Ring hash lb error: EDS resolution was successful, but returned a sum of weights too"
+                  + " large to fit in an unsigned int (%d).", totalWeight));
+      handleNameResolutionError(unavailableStatus);
+      return unavailableStatus;
+    }
+
+    return Status.OK;
+  }
+
+  @Nullable
+  private String validateNoDuplicateAddresses(List<EquivalentAddressGroup> addrList) {
+    Set<SocketAddress> addresses = new HashSet<>();
+    Multiset<String> dups = HashMultiset.create();
+    for (EquivalentAddressGroup eag : addrList) {
+      for (SocketAddress address : eag.getAddresses()) {
+        if (!addresses.add(address)) {
+          dups.add(address.toString());
+        }
+      }
+    }
+
+    if (!dups.isEmpty()) {
+      return dups.entrySet().stream()
+          .map((dup) ->
+              String.format("Address: %s, count: %d", dup.getElement(), dup.getCount() + 1))
+          .collect(Collectors.joining("; "));
+    }
+
+    return null;
+  }
+
+  private static List<RingEntry> buildRing(
+      Map<EquivalentAddressGroup, Long> serverWeights, long totalWeight, double scale) {
+    List<RingEntry> ring = new ArrayList<>();
+    double currentHashes = 0.0;
+    double targetHashes = 0.0;
+    for (Map.Entry<EquivalentAddressGroup, Long> entry : serverWeights.entrySet()) {
+      Endpoint endpoint = new Endpoint(entry.getKey());
+      double normalizedWeight = (double) entry.getValue() / totalWeight;
+      // Per GRFC A61 use the first address for the hash
+      StringBuilder sb = new StringBuilder(entry.getKey().getAddresses().get(0).toString());
+      sb.append('_');
+      int lengthWithoutCounter = sb.length();
+      targetHashes += scale * normalizedWeight;
+      long i = 0L;
+      while (currentHashes < targetHashes) {
+        sb.append(i);
+        long hash = hashFunc.hashAsciiString(sb.toString());
+        ring.add(new RingEntry(hash, endpoint));
+        i++;
+        currentHashes++;
+        sb.setLength(lengthWithoutCounter);
+      }
+    }
+    Collections.sort(ring);
+    return Collections.unmodifiableList(ring);
+  }
+
+  @SuppressWarnings("ReferenceEquality")
+  public static EquivalentAddressGroup stripAttrs(EquivalentAddressGroup eag) {
+    if (eag.getAttributes() == Attributes.EMPTY) {
+      return eag;
+    }
+    return new EquivalentAddressGroup(eag.getAddresses());
+  }
+
+  private static final class RingHashPicker extends SubchannelPicker {
+    private final SynchronizationContext syncContext;
+    private final List<RingEntry> ring;
+    // Avoid synchronization between pickSubchannel and subchannel's connectivity state change,
+    // freeze picker's view of subchannel's connectivity state.
+    // TODO(chengyuanzhang): can be more performance-friendly with
+    //  IdentityHashMap<Subchannel, ConnectivityStateInfo> and RingEntry contains Subchannel.
+    private final Map<Endpoint, SubchannelView> pickableSubchannels;  // read-only
+    @Nullable private final Metadata.Key<String> requestHashHeaderKey;
+    private final ThreadSafeRandom random;
+    private final boolean hasEndpointInConnectingState;
+
+    private RingHashPicker(
+        SynchronizationContext syncContext, List<RingEntry> ring,
+        Collection<ChildLbState> children, Metadata.Key<String> requestHashHeaderKey,
+        ThreadSafeRandom random) {
+      this.syncContext = syncContext;
+      this.ring = ring;
+      this.requestHashHeaderKey = requestHashHeaderKey;
+      this.random = random;
+      pickableSubchannels = new HashMap<>(children.size());
+      boolean hasConnectingState = false;
+      for (ChildLbState childLbState : children) {
+        pickableSubchannels.put((Endpoint)childLbState.getKey(),
+            new SubchannelView(childLbState, childLbState.getCurrentState()));
+        if (childLbState.getCurrentState() == CONNECTING) {
+          hasConnectingState = true;
+        }
+      }
+      this.hasEndpointInConnectingState = hasConnectingState;
+    }
+
+    // Find the ring entry with hash next to (clockwise) the RPC's hash (binary search).
+    private int getTargetIndex(long requestHash) {
+      if (ring.size() <= 1) {
+        return 0;
+      }
+
+      int low = 0;
+      int high = ring.size() - 1;
+      int mid = (low + high) / 2;
+      do {
+        long midVal = ring.get(mid).hash;
+        long midValL = mid == 0 ? 0 : ring.get(mid - 1).hash;
+        if (requestHash <= midVal && requestHash > midValL) {
+          break;
+        }
+        if (midVal < requestHash) {
+          low = mid + 1;
+        } else {
+          high =  mid - 1;
+        }
+        mid = (low + high) / 2;
+      } while (mid < ring.size() && low <= high);
+      return mid;
+    }
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      // Determine request hash.
+      boolean usingRandomHash = false;
+      long requestHash;
+      if (requestHashHeaderKey == null) {
+        // Set by the xDS config selector.
+        Long rpcHashFromCallOptions = args.getCallOptions().getOption(XdsNameResolver.RPC_HASH_KEY);
+        if (rpcHashFromCallOptions == null) {
+          return PickResult.withError(RPC_HASH_NOT_FOUND);
+        }
+        requestHash = rpcHashFromCallOptions;
+      } else {
+        Iterable<String> headerValues = args.getHeaders().getAll(requestHashHeaderKey);
+        if (headerValues != null) {
+          requestHash = hashFunc.hashAsciiString(Joiner.on(",").join(headerValues));
+        } else {
+          requestHash = random.nextLong();
+          usingRandomHash = true;
+        }
+      }
+
+      int targetIndex = getTargetIndex(requestHash);
+
+      if (!usingRandomHash) {
+        // Per gRFC A61, because of sticky-TF with PickFirst's auto reconnect on TF, we ignore
+        // all TF subchannels and find the first ring entry in READY, CONNECTING or IDLE.  If
+        // CONNECTING or IDLE we return a pick with no results.  Additionally, if that entry is in
+        // IDLE, we initiate a connection.
+        for (int i = 0; i < ring.size(); i++) {
+          int index = (targetIndex + i) % ring.size();
+          SubchannelView subchannelView = pickableSubchannels.get(ring.get(index).addrKey);
+          ChildLbState childLbState = subchannelView.childLbState;
+
+          if (subchannelView.connectivityState  == READY) {
+            return childLbState.getCurrentPicker().pickSubchannel(args);
+          }
+
+          // RPCs can be buffered if the next subchannel is pending (per A62). Otherwise, RPCs
+          // are failed unless there is a READY connection.
+          if (subchannelView.connectivityState == CONNECTING) {
+            return PickResult.withNoResult();
+          }
+
+          if (subchannelView.connectivityState == IDLE) {
+            syncContext.execute(() -> {
+              if (childLbState.getCurrentState() == IDLE) {
+                childLbState.getLb().requestConnection();
+              }
+            });
+
+            return PickResult.withNoResult(); // Indicates that this should be retried after backoff
+          }
+        }
+      } else {
+        // Using a random hash. Find and use the first READY ring entry, triggering at most one
+        // entry to attempt connection.
+        boolean requestedConnection = hasEndpointInConnectingState;
+        for (int i = 0; i < ring.size(); i++) {
+          int index = (targetIndex + i) % ring.size();
+          SubchannelView subchannelView = pickableSubchannels.get(ring.get(index).addrKey);
+          ChildLbState childLbState = subchannelView.childLbState;
+          if (subchannelView.connectivityState == READY) {
+            return childLbState.getCurrentPicker().pickSubchannel(args);
+          }
+          if (!requestedConnection && subchannelView.connectivityState == IDLE) {
+            syncContext.execute(() -> {
+              if (childLbState.getCurrentState() == IDLE) {
+                childLbState.getLb().requestConnection();
+              }
+            });
+            requestedConnection = true;
+          }
+        }
+        if (requestedConnection) {
+          return PickResult.withNoResult();
+        }
+      }
+
+      // return the pick from the original subchannel hit by hash, which is probably an error
+      ChildLbState originalSubchannel =
+          pickableSubchannels.get(ring.get(targetIndex).addrKey).childLbState;
+      return originalSubchannel.getCurrentPicker().pickSubchannel(args);
+    }
+
+  }
+
+  /**
+   * An unmodifiable view of a subchannel with state not subject to its real connectivity
+   * state changes.
+   */
+  private static final class SubchannelView {
+    private final ChildLbState childLbState;
+    private final ConnectivityState connectivityState;
+
+    private SubchannelView(ChildLbState childLbState, ConnectivityState state) {
+      this.childLbState = childLbState;
+      this.connectivityState = state;
+    }
+  }
+
+  private static final class RingEntry implements Comparable<RingEntry> {
+    private final long hash;
+    private final Endpoint addrKey;
+
+    private RingEntry(long hash, Endpoint addrKey) {
+      this.hash = hash;
+      this.addrKey = addrKey;
+    }
+
+    @Override
+    public int compareTo(RingEntry entry) {
+      return Long.compare(hash, entry.hash);
+    }
+  }
+
+  /**
+   * Configures the ring property. The larger the ring is (that is, the more hashes there are
+   * for each provided host) the better the request distribution will reflect the desired weights.
+   */
+  static final class RingHashConfig {
+    final long minRingSize;
+    final long maxRingSize;
+    final String requestHashHeader;
+
+    RingHashConfig(long minRingSize, long maxRingSize, String requestHashHeader) {
+      checkArgument(minRingSize > 0, "minRingSize <= 0");
+      checkArgument(maxRingSize > 0, "maxRingSize <= 0");
+      checkArgument(minRingSize <= maxRingSize, "minRingSize > maxRingSize");
+      checkNotNull(requestHashHeader);
+      this.minRingSize = minRingSize;
+      this.maxRingSize = maxRingSize;
+      this.requestHashHeader = requestHashHeader;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (!(o instanceof RingHashConfig)) {
+        return false;
+      }
+      RingHashConfig that = (RingHashConfig) o;
+      return this.minRingSize == that.minRingSize
+          && this.maxRingSize == that.maxRingSize
+          && Objects.equals(this.requestHashHeader, that.requestHashHeader);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(minRingSize, maxRingSize, requestHashHeader);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("minRingSize", minRingSize)
+          .add("maxRingSize", maxRingSize)
+          .add("requestHashHeader", requestHashHeader)
+          .toString();
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/RingHashLoadBalancerProvider.java b/xds/src/main/java/io/grpc/xds/RingHashLoadBalancerProvider.java
new file mode 100644
index 00000000000..bb4f8de5a5f
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/RingHashLoadBalancerProvider.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2021 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.xds;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Strings;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.JsonUtil;
+import io.grpc.xds.RingHashLoadBalancer.RingHashConfig;
+import io.grpc.xds.RingHashOptions;
+import java.util.Map;
+
+/**
+ * The provider for the "ring_hash_experimental" balancing policy.
+ */
+@Internal
+public final class RingHashLoadBalancerProvider extends LoadBalancerProvider {
+
+  // Same as ClientXdsClient.DEFAULT_RING_HASH_LB_POLICY_MIN_RING_SIZE
+  @VisibleForTesting
+  static final long DEFAULT_MIN_RING_SIZE = 1024L;
+  // Same as ClientXdsClient.DEFAULT_RING_HASH_LB_POLICY_MAX_RING_SIZE
+  @VisibleForTesting
+  static final long DEFAULT_MAX_RING_SIZE = 4 * 1024L;
+
+  private static final boolean enableRingHash =
+      Strings.isNullOrEmpty(System.getenv("GRPC_XDS_EXPERIMENTAL_ENABLE_RING_HASH"))
+          || Boolean.parseBoolean(System.getenv("GRPC_XDS_EXPERIMENTAL_ENABLE_RING_HASH"));
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    return new RingHashLoadBalancer(helper);
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return enableRingHash;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return "ring_hash_experimental";
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawLoadBalancingPolicyConfig) {
+    try {
+      return parseLoadBalancingPolicyConfigInternal(rawLoadBalancingPolicyConfig);
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError(
+          Status.UNAVAILABLE.withCause(e).withDescription(
+              "Failed parsing configuration for " + getPolicyName()));
+    }
+  }
+
+  private ConfigOrError parseLoadBalancingPolicyConfigInternal(
+      Map<String, ?> rawLoadBalancingPolicyConfig) {
+    Long minRingSize = JsonUtil.getNumberAsLong(rawLoadBalancingPolicyConfig, "minRingSize");
+    Long maxRingSize = JsonUtil.getNumberAsLong(rawLoadBalancingPolicyConfig, "maxRingSize");
+    String requestHashHeader = "";
+    if (GrpcUtil.getFlag("GRPC_EXPERIMENTAL_RING_HASH_SET_REQUEST_HASH_KEY", false)) {
+      requestHashHeader = JsonUtil.getString(rawLoadBalancingPolicyConfig, "requestHashHeader");
+    }
+    long maxRingSizeCap = RingHashOptions.getRingSizeCap();
+    if (minRingSize == null) {
+      minRingSize = DEFAULT_MIN_RING_SIZE;
+    }
+    if (maxRingSize == null) {
+      maxRingSize = DEFAULT_MAX_RING_SIZE;
+    }
+    if (requestHashHeader == null) {
+      requestHashHeader = "";
+    }
+    if (minRingSize > maxRingSizeCap) {
+      minRingSize = maxRingSizeCap;
+    }
+    if (maxRingSize > maxRingSizeCap) {
+      maxRingSize = maxRingSizeCap;
+    }
+    if (minRingSize <= 0 || maxRingSize <= 0 || minRingSize > maxRingSize) {
+      return ConfigOrError.fromError(Status.UNAVAILABLE.withDescription(
+          "Invalid 'minRingSize'/'maxRingSize'"));
+    }
+    return ConfigOrError.fromConfig(
+        new RingHashConfig(minRingSize, maxRingSize, requestHashHeader));
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/RingHashOptions.java b/xds/src/main/java/io/grpc/xds/RingHashOptions.java
new file mode 100644
index 00000000000..6bb3fc7887e
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/RingHashOptions.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2021 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.xds;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.ExperimentalApi;
+
+/**
+ * Utility class that provides a way to configure ring hash size limits. This is applicable
+ * for clients that use the ring hash load balancing policy. Note that size limits involve
+ * a tradeoff between client memory consumption and accuracy of load balancing weight
+ * representations. Also see https://github.com/grpc/proposal/pull/338.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/9718")
+public final class RingHashOptions {
+  // Same as ClientXdsClient.DEFAULT_RING_HASH_LB_POLICY_MAX_RING_SIZE
+  @VisibleForTesting
+  static final long MAX_RING_SIZE_CAP = 8 * 1024 * 1024L;
+  @VisibleForTesting
+  // Same as RingHashLoadBalancerProvider.DEFAULT_MAX_RING_SIZE
+  static final long DEFAULT_RING_SIZE_CAP = 4 * 1024L;
+
+  // Limits ring hash sizes to restrict client memory usage.
+  private static volatile long ringSizeCap = DEFAULT_RING_SIZE_CAP;
+
+  private RingHashOptions() {} // Prevent instantiation
+
+  /**
+   * Set the global limit for the min and max number of ring hash entries per ring.
+   * Note that this limit is clamped between 1 entry and 8,388,608 entries, and new
+   * limits lying outside that range will be silently moved to the nearest number within
+   * that range. Defaults initially to 4096 entries.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/9718")
+  public static void setRingSizeCap(long ringSizeCap) {
+    ringSizeCap = Math.max(1, ringSizeCap);
+    ringSizeCap = Math.min(MAX_RING_SIZE_CAP, ringSizeCap);
+    RingHashOptions.ringSizeCap = ringSizeCap;
+  }
+
+  /**
+   * Get the global limit for min and max ring hash sizes.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/9718")
+  public static long getRingSizeCap() {
+    return RingHashOptions.ringSizeCap;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/RouteLookupServiceClusterSpecifierPlugin.java b/xds/src/main/java/io/grpc/xds/RouteLookupServiceClusterSpecifierPlugin.java
new file mode 100644
index 00000000000..6dd99ae762e
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/RouteLookupServiceClusterSpecifierPlugin.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2021 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.xds;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Any;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Message;
+import io.grpc.internal.JsonParser;
+import io.grpc.internal.JsonUtil;
+import java.io.IOException;
+import java.util.Map;
+
+/** The ClusterSpecifierPlugin for RouteLookup policy. */
+final class RouteLookupServiceClusterSpecifierPlugin implements ClusterSpecifierPlugin {
+
+  static final RouteLookupServiceClusterSpecifierPlugin INSTANCE =
+      new RouteLookupServiceClusterSpecifierPlugin();
+
+  private static final String TYPE_URL =
+      "type.googleapis.com/grpc.lookup.v1.RouteLookupClusterSpecifier";
+
+  private RouteLookupServiceClusterSpecifierPlugin() {}
+
+  @Override
+  public String[] typeUrls() {
+    return new String[] {
+        TYPE_URL,
+    };
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public ConfigOrError<RlsPluginConfig> parsePlugin(Message rawProtoMessage) {
+    if (!(rawProtoMessage instanceof Any)) {
+      return ConfigOrError.fromError("Invalid config type: " + rawProtoMessage.getClass());
+    }
+    try {
+      Any anyMessage = (Any) rawProtoMessage;
+      Class<? extends Message> protoClass;
+      try {
+        protoClass =
+            (Class<? extends Message>)
+                Class.forName("io.grpc.lookup.v1.RouteLookupClusterSpecifier");
+      } catch (ClassNotFoundException e) {
+        return ConfigOrError.fromError("Dependency for 'io.grpc:grpc-rls' is missing: " + e);
+      }
+      Message configProto;
+      try {
+        configProto = anyMessage.unpack(protoClass);
+      } catch (InvalidProtocolBufferException e) {
+        return ConfigOrError.fromError("Invalid proto: " + e);
+      }
+      String jsonString = MessagePrinter.INSTANCE.print(configProto);
+      try {
+        Map<String, ?> jsonMap = (Map<String, ?>) JsonParser.parse(jsonString);
+        Map<String, ?> config = JsonUtil.getObject(jsonMap, "routeLookupConfig");
+        return ConfigOrError.fromConfig(RlsPluginConfig.create(config));
+      } catch (IOException e) {
+        return ConfigOrError.fromError(
+            "Unable to parse RouteLookupClusterSpecifier: " + jsonString);
+      }
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError("Error parsing RouteLookupConfig: " + e);
+    }
+  }
+
+  @AutoValue
+  abstract static class RlsPluginConfig implements PluginConfig {
+
+    abstract ImmutableMap<String, ?> config();
+
+    static RlsPluginConfig create(Map<String, ?> config) {
+      return new AutoValue_RouteLookupServiceClusterSpecifierPlugin_RlsPluginConfig(
+          ImmutableMap.copyOf(config));
+    }
+
+    @Override
+    public String typeUrl() {
+      return TYPE_URL;
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/RouterFilter.java b/xds/src/main/java/io/grpc/xds/RouterFilter.java
new file mode 100644
index 00000000000..504c4213149
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/RouterFilter.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2021 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.xds;
+
+import com.google.protobuf.Message;
+
+/**
+ * Router filter implementation. Currently this filter does not parse any field in the config.
+ */
+final class RouterFilter implements Filter {
+  private static final RouterFilter INSTANCE = new RouterFilter();
+
+  static final String TYPE_URL =
+      "type.googleapis.com/envoy.extensions.filters.http.router.v3.Router";
+
+  static final FilterConfig ROUTER_CONFIG = new FilterConfig() {
+    @Override
+    public String typeUrl() {
+      return TYPE_URL;
+    }
+
+    @Override
+    public String toString() {
+      return "ROUTER_CONFIG";
+    }
+  };
+
+  static final class Provider implements Filter.Provider {
+    @Override
+    public String[] typeUrls() {
+      return new String[]{TYPE_URL};
+    }
+
+    @Override
+    public boolean isClientFilter() {
+      return true;
+    }
+
+    @Override
+    public boolean isServerFilter() {
+      return true;
+    }
+
+    @Override
+    public RouterFilter newInstance(String name) {
+      return INSTANCE;
+    }
+
+    @Override
+    public ConfigOrError<? extends FilterConfig> parseFilterConfig(Message rawProtoMessage) {
+      return ConfigOrError.fromConfig(ROUTER_CONFIG);
+    }
+
+    @Override
+    public ConfigOrError<? extends FilterConfig> parseFilterConfigOverride(
+        Message rawProtoMessage) {
+      return ConfigOrError.fromError("Router Filter should not have override config");
+    }
+  }
+
+  private RouterFilter() {}
+}
diff --git a/xds/src/main/java/io/grpc/xds/RoutingUtils.java b/xds/src/main/java/io/grpc/xds/RoutingUtils.java
new file mode 100644
index 00000000000..2b60e90deda
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/RoutingUtils.java
@@ -0,0 +1,191 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.common.base.Joiner;
+import io.grpc.Metadata;
+import io.grpc.xds.VirtualHost.Route.RouteMatch;
+import io.grpc.xds.VirtualHost.Route.RouteMatch.PathMatcher;
+import io.grpc.xds.internal.Matchers.FractionMatcher;
+import io.grpc.xds.internal.Matchers.HeaderMatcher;
+import java.util.List;
+import java.util.Locale;
+import javax.annotation.Nullable;
+
+/**
+ * Utilities for performing virtual host domain name matching and route matching.
+ */
+// TODO(chengyuanzhang): clean up implementations in XdsNameResolver.
+final class RoutingUtils {
+  // Prevent instantiation.
+  private RoutingUtils() {
+  }
+
+  /**
+   * Returns the {@link VirtualHost} with the best match domain for the given hostname.
+   */
+  @Nullable
+  static VirtualHost findVirtualHostForHostName(List<VirtualHost> virtualHosts, String hostName) {
+    // Domain search order:
+    //  1. Exact domain names: ``www.foo.com``.
+    //  2. Suffix domain wildcards: ``*.foo.com`` or ``*-bar.foo.com``.
+    //  3. Prefix domain wildcards: ``foo.*`` or ``foo-*``.
+    //  4. Special wildcard ``*`` matching any domain.
+    //
+    //  The longest wildcards match first.
+    //  Assuming only a single virtual host in the entire route configuration can match
+    //  on ``*`` and a domain must be unique across all virtual hosts.
+    int matchingLen = -1; // longest length of wildcard pattern that matches host name
+    boolean exactMatchFound = false;  // true if a virtual host with exactly matched domain found
+    VirtualHost targetVirtualHost = null;  // target VirtualHost with longest matched domain
+    for (VirtualHost vHost : virtualHosts) {
+      for (String domain : vHost.domains()) {
+        boolean selected = false;
+        if (matchHostName(hostName, domain)) { // matching
+          if (!domain.contains("*")) { // exact matching
+            exactMatchFound = true;
+            targetVirtualHost = vHost;
+            break;
+          } else if (domain.length() > matchingLen) { // longer matching pattern
+            selected = true;
+          } else if (domain.length() == matchingLen && domain.startsWith("*")) { // suffix matching
+            selected = true;
+          }
+        }
+        if (selected) {
+          matchingLen = domain.length();
+          targetVirtualHost = vHost;
+        }
+      }
+      if (exactMatchFound) {
+        break;
+      }
+    }
+    return targetVirtualHost;
+  }
+
+  /**
+   * Returns {@code true} iff {@code hostName} matches the domain name {@code pattern} with
+   * case-insensitive.
+   *
+   * <p>Wildcard pattern rules:
+   * <ol>
+   * <li>A single asterisk (*) matches any domain.</li>
+   * <li>Asterisk (*) is only permitted in the left-most or the right-most part of the pattern,
+   *     but not both.</li>
+   * </ol>
+   */
+  private static boolean matchHostName(String hostName, String pattern) {
+    checkArgument(hostName.length() != 0 && !hostName.startsWith(".") && !hostName.endsWith("."),
+        "Invalid host name");
+    checkArgument(pattern.length() != 0 && !pattern.startsWith(".") && !pattern.endsWith("."),
+        "Invalid pattern/domain name");
+
+    hostName = hostName.toLowerCase(Locale.US);
+    pattern = pattern.toLowerCase(Locale.US);
+    // hostName and pattern are now in lower case -- domain names are case-insensitive.
+
+    if (!pattern.contains("*")) {
+      // Not a wildcard pattern -- hostName and pattern must match exactly.
+      return hostName.equals(pattern);
+    }
+    // Wildcard pattern
+
+    if (pattern.length() == 1) {
+      return true;
+    }
+
+    int index = pattern.indexOf('*');
+
+    // At most one asterisk (*) is allowed.
+    if (pattern.indexOf('*', index + 1) != -1) {
+      return false;
+    }
+
+    // Asterisk can only match prefix or suffix.
+    if (index != 0 && index != pattern.length() - 1) {
+      return false;
+    }
+
+    // HostName must be at least as long as the pattern because asterisk has to
+    // match one or more characters.
+    if (hostName.length() < pattern.length()) {
+      return false;
+    }
+
+    if (index == 0 && hostName.endsWith(pattern.substring(1))) {
+      // Prefix matching fails.
+      return true;
+    }
+
+    // Pattern matches hostname if suffix matching succeeds.
+    return index == pattern.length() - 1
+        && hostName.startsWith(pattern.substring(0, pattern.length() - 1));
+  }
+
+  /**
+   * Returns {@code true} iff the given {@link RouteMatch} matches the RPC's full method name and
+   * headers.
+   */
+  static boolean matchRoute(RouteMatch routeMatch, String fullMethodName,
+      Metadata headers, ThreadSafeRandom random) {
+    if (!matchPath(routeMatch.pathMatcher(), fullMethodName)) {
+      return false;
+    }
+    for (HeaderMatcher headerMatcher : routeMatch.headerMatchers()) {
+      if (!headerMatcher.matches(getHeaderValue(headers, headerMatcher.name()))) {
+        return false;
+      }
+    }
+    FractionMatcher fraction = routeMatch.fractionMatcher();
+    return fraction == null || random.nextInt(fraction.denominator()) < fraction.numerator();
+  }
+
+  private static boolean matchPath(PathMatcher pathMatcher, String fullMethodName) {
+    if (pathMatcher.path() != null) {
+      return pathMatcher.caseSensitive()
+          ? pathMatcher.path().equals(fullMethodName)
+          : pathMatcher.path().equalsIgnoreCase(fullMethodName);
+    } else if (pathMatcher.prefix() != null) {
+      return pathMatcher.caseSensitive()
+          ? fullMethodName.startsWith(pathMatcher.prefix())
+          : fullMethodName.toLowerCase(Locale.US).startsWith(
+              pathMatcher.prefix().toLowerCase(Locale.US));
+    }
+    return pathMatcher.regEx().matches(fullMethodName);
+  }
+
+  @Nullable
+  private static String getHeaderValue(Metadata headers, String headerName) {
+    if (headerName.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
+      return null;
+    }
+    if (headerName.equals("content-type")) {
+      return "application/grpc";
+    }
+    Metadata.Key<String> key;
+    try {
+      key = Metadata.Key.of(headerName, Metadata.ASCII_STRING_MARSHALLER);
+    } catch (IllegalArgumentException e) {
+      return null;
+    }
+    Iterable<String> values = headers.getAll(key);
+    return values == null ? null : Joiner.on(",").join(values);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/SharedCallCounterMap.java b/xds/src/main/java/io/grpc/xds/SharedCallCounterMap.java
new file mode 100644
index 00000000000..7aa55c27429
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/SharedCallCounterMap.java
@@ -0,0 +1,109 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.xds.XdsNameResolverProvider.CallCounterProvider;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicLong;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * The global map for holding circuit breaker atomic counters.
+ */
+@ThreadSafe
+final class SharedCallCounterMap implements CallCounterProvider {
+
+  private final ReferenceQueue<AtomicLong> refQueue = new ReferenceQueue<>();
+  private final Map<String, Map<String, CounterReference>> counters;
+
+  private SharedCallCounterMap() {
+    this(new HashMap<String, Map<String, CounterReference>>());
+  }
+
+  @VisibleForTesting
+  SharedCallCounterMap(Map<String, Map<String, CounterReference>> counters) {
+    this.counters = checkNotNull(counters, "counters");
+  }
+
+  static SharedCallCounterMap getInstance() {
+    return SharedCallCounterMapHolder.instance;
+  }
+
+  @Override
+  public synchronized AtomicLong getOrCreate(String cluster, @Nullable String edsServiceName) {
+    Map<String, CounterReference> clusterCounters = counters.get(cluster);
+    if (clusterCounters == null) {
+      clusterCounters = new HashMap<>();
+      counters.put(cluster, clusterCounters);
+    }
+    CounterReference ref = clusterCounters.get(edsServiceName);
+    AtomicLong counter = null;
+    if (ref != null) {
+      counter = ref.get();
+      if (counter == null) {
+        ref.enqueue();
+      }
+    }
+    if (counter == null) {
+      counter = new AtomicLong();
+      ref = new CounterReference(counter, refQueue, cluster, edsServiceName);
+      clusterCounters.put(edsServiceName, ref);
+    }
+    cleanQueue();
+    return counter;
+  }
+
+  @VisibleForTesting
+  void cleanQueue() {
+    CounterReference ref;
+    while ((ref = (CounterReference) refQueue.poll()) != null) {
+      Map<String, CounterReference> clusterCounter = counters.get(ref.cluster);
+      if (clusterCounter.get(ref.edsServiceName) != ref) {
+        continue;
+      }
+      clusterCounter.remove(ref.edsServiceName);
+      if (clusterCounter.isEmpty()) {
+        counters.remove(ref.cluster);
+      }
+    }
+  }
+
+  @VisibleForTesting
+  static final class CounterReference extends WeakReference<AtomicLong> {
+    private final String cluster;
+    @Nullable
+    private final String edsServiceName;
+
+    CounterReference(AtomicLong counter, ReferenceQueue<AtomicLong> refQueue, String cluster,
+        @Nullable String edsServiceName) {
+      super(counter, refQueue);
+      this.cluster = cluster;
+      this.edsServiceName = edsServiceName;
+    }
+  }
+
+  private static final class SharedCallCounterMapHolder {
+    private static final SharedCallCounterMap instance = new SharedCallCounterMap();
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/SharedXdsClientPoolProvider.java b/xds/src/main/java/io/grpc/xds/SharedXdsClientPoolProvider.java
new file mode 100644
index 00000000000..45c379244af
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/SharedXdsClientPoolProvider.java
@@ -0,0 +1,227 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.CallCredentials;
+import io.grpc.MetricRecorder;
+import io.grpc.internal.ExponentialBackoffPolicy;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourceHolder;
+import io.grpc.internal.TimeProvider;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsClientImpl;
+import io.grpc.xds.client.XdsInitializationException;
+import io.grpc.xds.internal.security.TlsContextManagerImpl;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * The global factory for creating a singleton {@link XdsClient} instance to be used by all gRPC
+ * clients in the process.
+ */
+@ThreadSafe
+final class SharedXdsClientPoolProvider implements XdsClientPoolFactory {
+  private static final boolean LOG_XDS_NODE_ID = Boolean.parseBoolean(
+      System.getenv("GRPC_LOG_XDS_NODE_ID"));
+  private static final Logger log = Logger.getLogger(XdsClientImpl.class.getName());
+  private static final ExponentialBackoffPolicy.Provider BACKOFF_POLICY_PROVIDER =
+      new ExponentialBackoffPolicy.Provider();
+
+  @Nullable
+  private final Bootstrapper bootstrapper;
+  private final Object lock = new Object();
+  private final Map<String, ObjectPool<XdsClient>> targetToXdsClientMap = new ConcurrentHashMap<>();
+
+  SharedXdsClientPoolProvider() {
+    this(null);
+  }
+
+  @VisibleForTesting
+  SharedXdsClientPoolProvider(@Nullable Bootstrapper bootstrapper) {
+    this.bootstrapper = bootstrapper;
+  }
+
+  static SharedXdsClientPoolProvider getDefaultProvider() {
+    return SharedXdsClientPoolProviderHolder.instance;
+  }
+
+  @Override
+  @Nullable
+  public ObjectPool<XdsClient> get(String target) {
+    return targetToXdsClientMap.get(target);
+  }
+
+  @Deprecated
+  public ObjectPool<XdsClient> getOrCreate(
+      String target, MetricRecorder metricRecorder, CallCredentials transportCallCredentials)
+      throws XdsInitializationException {
+    BootstrapInfo bootstrapInfo;
+    if (bootstrapper != null) {
+      bootstrapInfo = bootstrapper.bootstrap();
+    } else {
+      bootstrapInfo = GrpcBootstrapperImpl.defaultBootstrap();
+    }
+    return getOrCreate(target, bootstrapInfo, metricRecorder, transportCallCredentials);
+  }
+
+  @Override
+  public ObjectPool<XdsClient> getOrCreate(
+      String target, BootstrapInfo bootstrapInfo, MetricRecorder metricRecorder) {
+    return getOrCreate(target, bootstrapInfo, metricRecorder, null);
+  }
+
+  public ObjectPool<XdsClient> getOrCreate(
+      String target,
+      BootstrapInfo bootstrapInfo,
+      MetricRecorder metricRecorder,
+      CallCredentials transportCallCredentials) {
+    ObjectPool<XdsClient> ref = targetToXdsClientMap.get(target);
+    if (ref == null) {
+      synchronized (lock) {
+        ref = targetToXdsClientMap.get(target);
+        if (ref == null) {
+          ref =
+              new RefCountedXdsClientObjectPool(
+                  bootstrapInfo, target, metricRecorder, transportCallCredentials);
+          targetToXdsClientMap.put(target, ref);
+        }
+      }
+    }
+    return ref;
+  }
+
+  @Override
+  public ImmutableList<String> getTargets() {
+    return ImmutableList.copyOf(targetToXdsClientMap.keySet());
+  }
+
+  private static class SharedXdsClientPoolProviderHolder {
+    private static final SharedXdsClientPoolProvider instance = new SharedXdsClientPoolProvider();
+  }
+
+  @ThreadSafe
+  @VisibleForTesting
+  class RefCountedXdsClientObjectPool implements ObjectPool<XdsClient> {
+
+    private final BootstrapInfo bootstrapInfo;
+    private final String target; // The target associated with the xDS client.
+    private final MetricRecorder metricRecorder;
+    private final CallCredentials transportCallCredentials;
+    private final Object lock = new Object();
+    @GuardedBy("lock")
+    private ScheduledExecutorService scheduler;
+    @GuardedBy("lock")
+    private XdsClient xdsClient;
+    @GuardedBy("lock")
+    private int refCount;
+    @GuardedBy("lock")
+    private XdsClientMetricReporterImpl metricReporter;
+
+    @VisibleForTesting
+    RefCountedXdsClientObjectPool(
+        BootstrapInfo bootstrapInfo, String target, MetricRecorder metricRecorder) {
+      this(bootstrapInfo, target, metricRecorder, null);
+    }
+
+    @VisibleForTesting
+    RefCountedXdsClientObjectPool(
+        BootstrapInfo bootstrapInfo,
+        String target,
+        MetricRecorder metricRecorder,
+        CallCredentials transportCallCredentials) {
+      this.bootstrapInfo = checkNotNull(bootstrapInfo, "bootstrapInfo");
+      this.target = target;
+      this.metricRecorder = checkNotNull(metricRecorder, "metricRecorder");
+      this.transportCallCredentials = transportCallCredentials;
+    }
+
+    @Override
+    public XdsClient getObject() {
+      synchronized (lock) {
+        if (refCount == 0) {
+          if (LOG_XDS_NODE_ID) {
+            log.log(Level.INFO, "xDS node ID: {0}", bootstrapInfo.node().getId());
+          }
+          scheduler = SharedResourceHolder.get(GrpcUtil.TIMER_SERVICE);
+          metricReporter = new XdsClientMetricReporterImpl(metricRecorder, target);
+          GrpcXdsTransportFactory xdsTransportFactory =
+              new GrpcXdsTransportFactory(transportCallCredentials);
+          xdsClient =
+              new XdsClientImpl(
+                  xdsTransportFactory,
+                  bootstrapInfo,
+                  scheduler,
+                  BACKOFF_POLICY_PROVIDER,
+                  GrpcUtil.STOPWATCH_SUPPLIER,
+                  TimeProvider.SYSTEM_TIME_PROVIDER,
+                  MessagePrinter.INSTANCE,
+                  new TlsContextManagerImpl(bootstrapInfo),
+                  metricReporter);
+          metricReporter.setXdsClient(xdsClient);
+        }
+        refCount++;
+        return xdsClient;
+      }
+    }
+
+    @Override
+    public XdsClient returnObject(Object object) {
+      synchronized (lock) {
+        refCount--;
+        if (refCount == 0) {
+          xdsClient.shutdown();
+          xdsClient = null;
+          metricReporter.close();
+          metricReporter = null;
+          targetToXdsClientMap.remove(target);
+          scheduler = SharedResourceHolder.release(GrpcUtil.TIMER_SERVICE, scheduler);
+        } else if (refCount < 0) {
+          assert false; // We want our tests to fail
+          log.log(Level.SEVERE, "Negative reference count. File a bug", new Exception());
+          refCount = 0;
+        }
+        return null;
+      }
+    }
+
+    @VisibleForTesting
+    @Nullable
+    XdsClient getXdsClientForTest() {
+      synchronized (lock) {
+        return xdsClient;
+      }
+    }
+
+    public String getTarget() {
+      return target;
+    }
+  }
+
+}
diff --git a/xds/src/main/java/io/grpc/xds/StructOrError.java b/xds/src/main/java/io/grpc/xds/StructOrError.java
new file mode 100644
index 00000000000..14f008d191e
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/StructOrError.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2024 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import javax.annotation.Nullable;
+
+/** An object or a String error. */
+final class StructOrError<T> {
+
+  /**
+  * Returns a {@link StructOrError} for the successfully converted data object.
+  */
+  public static <T> StructOrError<T> fromStruct(T struct) {
+    return new StructOrError<>(struct);
+  }
+
+  /**
+   * Returns a {@link StructOrError} for the failure to convert the data object.
+   */
+  public static <T> StructOrError<T> fromError(String errorDetail) {
+    return new StructOrError<>(errorDetail);
+  }
+
+  private final String errorDetail;
+  private final T struct;
+
+  private StructOrError(T struct) {
+    this.struct = checkNotNull(struct, "struct");
+    this.errorDetail = null;
+  }
+
+  private StructOrError(String errorDetail) {
+    this.struct = null;
+    this.errorDetail = checkNotNull(errorDetail, "errorDetail");
+  }
+
+  /**
+   * Returns struct if exists, otherwise null.
+   */
+  @VisibleForTesting
+  @Nullable
+  public T getStruct() {
+    return struct;
+  }
+
+  /**
+   * Returns error detail if exists, otherwise null.
+   */
+  @VisibleForTesting
+  @Nullable
+  public String getErrorDetail() {
+    return errorDetail;
+  }
+}
+
diff --git a/xds/src/main/java/io/grpc/xds/ThreadSafeRandom.java b/xds/src/main/java/io/grpc/xds/ThreadSafeRandom.java
new file mode 100644
index 00000000000..533ccee2375
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/ThreadSafeRandom.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2019 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.xds;
+
+import java.util.concurrent.ThreadLocalRandom;
+import javax.annotation.concurrent.ThreadSafe;
+
+@ThreadSafe // Except for impls/mocks in tests
+interface ThreadSafeRandom {
+  int nextInt(int bound);
+
+  long nextLong();
+
+  long nextLong(long bound);
+
+  final class ThreadSafeRandomImpl implements ThreadSafeRandom {
+
+    static final ThreadSafeRandom instance = new ThreadSafeRandomImpl();
+
+    private ThreadSafeRandomImpl() {}
+
+    @Override
+    public int nextInt(int bound) {
+      return ThreadLocalRandom.current().nextInt(bound);
+    }
+
+    @Override
+    public long nextLong() {
+      return ThreadLocalRandom.current().nextLong();
+    }
+
+    @Override
+    public long nextLong(long bound) {
+      return ThreadLocalRandom.current().nextLong(bound);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/TlsContextManager.java b/xds/src/main/java/io/grpc/xds/TlsContextManager.java
new file mode 100644
index 00000000000..772a6cff102
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/TlsContextManager.java
@@ -0,0 +1,56 @@
+/*
+ * 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.xds;
+
+import io.grpc.Internal;
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.internal.security.SslContextProvider;
+
+@Internal
+public interface TlsContextManager {
+
+  /** Creates a SslContextProvider. Used for retrieving a server-side SslContext. */
+  SslContextProvider findOrCreateServerSslContextProvider(
+      DownstreamTlsContext downstreamTlsContext);
+
+  /** Creates a SslContextProvider. Used for retrieving a client-side SslContext. */
+  SslContextProvider findOrCreateClientSslContextProvider(
+      UpstreamTlsContext upstreamTlsContext);
+
+  /**
+   * Releases an instance of the given client-side {@link SslContextProvider}.
+   *
+   * <p>The instance must have been obtained from {@link #findOrCreateClientSslContextProvider}.
+   * Otherwise will throw IllegalArgumentException.
+   *
+   * <p>Caller must not release a reference more than once. It's advised that you clear the
+   * reference to the instance with the null returned by this method.
+   */
+  SslContextProvider releaseClientSslContextProvider(SslContextProvider sslContextProvider);
+
+  /**
+   * Releases an instance of the given server-side {@link SslContextProvider}.
+   *
+   * <p>The instance must have been obtained from {@link #findOrCreateServerSslContextProvider}.
+   * Otherwise will throw IllegalArgumentException.
+   *
+   * <p>Caller must not release a reference more than once. It's advised that you clear the
+   * reference to the instance with the null returned by this method.
+   */
+  SslContextProvider releaseServerSslContextProvider(SslContextProvider sslContextProvider);
+}
diff --git a/xds/src/main/java/io/grpc/xds/VirtualHost.java b/xds/src/main/java/io/grpc/xds/VirtualHost.java
new file mode 100644
index 00000000000..5cc979984c6
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/VirtualHost.java
@@ -0,0 +1,305 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Duration;
+import com.google.re2j.Pattern;
+import io.grpc.Status.Code;
+import io.grpc.xds.ClusterSpecifierPlugin.NamedPluginConfig;
+import io.grpc.xds.Filter.FilterConfig;
+import io.grpc.xds.internal.Matchers.FractionMatcher;
+import io.grpc.xds.internal.Matchers.HeaderMatcher;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/** Represents an upstream virtual host. */
+@AutoValue
+abstract class VirtualHost {
+  // The canonical name of this virtual host.
+  abstract String name();
+
+  // The list of domains (host/authority header) that will be matched to this virtual host.
+  abstract ImmutableList<String> domains();
+
+  // The list of routes that will be matched, in order, for incoming requests.
+  abstract ImmutableList<Route> routes();
+
+  abstract ImmutableMap<String, FilterConfig> filterConfigOverrides();
+
+  public static VirtualHost create(
+      String name, List<String> domains, List<Route> routes,
+      Map<String, FilterConfig> filterConfigOverrides) {
+    return new AutoValue_VirtualHost(name, ImmutableList.copyOf(domains),
+        ImmutableList.copyOf(routes), ImmutableMap.copyOf(filterConfigOverrides));
+  }
+
+  @AutoValue
+  abstract static class Route {
+    abstract RouteMatch routeMatch();
+
+    @Nullable
+    abstract RouteAction routeAction();
+
+    abstract ImmutableMap<String, FilterConfig> filterConfigOverrides();
+
+    static Route forAction(RouteMatch routeMatch, RouteAction routeAction,
+        Map<String, FilterConfig> filterConfigOverrides) {
+      return create(routeMatch, routeAction, filterConfigOverrides);
+    }
+
+    static Route forNonForwardingAction(RouteMatch routeMatch,
+        Map<String, FilterConfig> filterConfigOverrides) {
+      return create(routeMatch, null, filterConfigOverrides);
+    }
+
+    private static Route create(
+        RouteMatch routeMatch, @Nullable RouteAction routeAction,
+        Map<String, FilterConfig> filterConfigOverrides) {
+      return new AutoValue_VirtualHost_Route(
+          routeMatch, routeAction, ImmutableMap.copyOf(filterConfigOverrides));
+    }
+
+    @AutoValue
+    abstract static class RouteMatch {
+      abstract PathMatcher pathMatcher();
+
+      abstract ImmutableList<HeaderMatcher> headerMatchers();
+
+      @Nullable
+      abstract FractionMatcher fractionMatcher();
+
+      // TODO(chengyuanzhang): maybe delete me.
+      @VisibleForTesting
+      static RouteMatch withPathExactOnly(String path) {
+        return RouteMatch.create(PathMatcher.fromPath(path, true),
+            Collections.<HeaderMatcher>emptyList(), null);
+      }
+
+      static RouteMatch create(PathMatcher pathMatcher,
+          List<HeaderMatcher> headerMatchers, @Nullable FractionMatcher fractionMatcher) {
+        return new AutoValue_VirtualHost_Route_RouteMatch(pathMatcher,
+            ImmutableList.copyOf(headerMatchers), fractionMatcher);
+      }
+
+      /** Matcher for HTTP request path. */
+      @AutoValue
+      abstract static class PathMatcher {
+        // Exact full path to be matched.
+        @Nullable
+        abstract String path();
+
+        // Path prefix to be matched.
+        @Nullable
+        abstract String prefix();
+
+        // Regular expression pattern of the path to be matched.
+        @Nullable
+        abstract Pattern regEx();
+
+        // Whether case sensitivity is taken into account for matching.
+        // Only valid for full path matching or prefix matching.
+        abstract boolean caseSensitive();
+
+        static PathMatcher fromPath(String path, boolean caseSensitive) {
+          checkNotNull(path, "path");
+          return create(path, null, null, caseSensitive);
+        }
+
+        static PathMatcher fromPrefix(String prefix, boolean caseSensitive) {
+          checkNotNull(prefix, "prefix");
+          return create(null, prefix, null, caseSensitive);
+        }
+
+        static PathMatcher fromRegEx(Pattern regEx) {
+          checkNotNull(regEx, "regEx");
+          return create(null, null, regEx, false /* doesn't matter */);
+        }
+
+        private static PathMatcher create(@Nullable String path, @Nullable String prefix,
+            @Nullable Pattern regEx, boolean caseSensitive) {
+          return new AutoValue_VirtualHost_Route_RouteMatch_PathMatcher(path, prefix, regEx,
+              caseSensitive);
+        }
+      }
+    }
+
+    @AutoValue
+    abstract static class RouteAction {
+      // List of hash policies to use for ring hash load balancing.
+      abstract ImmutableList<HashPolicy> hashPolicies();
+
+      @Nullable
+      abstract Long timeoutNano();
+
+      @Nullable
+      abstract String cluster();
+
+      @Nullable
+      abstract ImmutableList<ClusterWeight> weightedClusters();
+
+      @Nullable
+      abstract NamedPluginConfig namedClusterSpecifierPluginConfig();
+
+      @Nullable
+      abstract RetryPolicy retryPolicy();
+
+      abstract boolean autoHostRewrite();
+
+      static RouteAction forCluster(
+          String cluster, List<HashPolicy> hashPolicies, @Nullable Long timeoutNano,
+          @Nullable RetryPolicy retryPolicy, boolean autoHostRewrite) {
+        checkNotNull(cluster, "cluster");
+        return RouteAction.create(hashPolicies, timeoutNano, cluster, null, null, retryPolicy,
+            autoHostRewrite);
+      }
+
+      static RouteAction forWeightedClusters(
+          List<ClusterWeight> weightedClusters, List<HashPolicy> hashPolicies,
+          @Nullable Long timeoutNano, @Nullable RetryPolicy retryPolicy, boolean autoHostRewrite) {
+        checkNotNull(weightedClusters, "weightedClusters");
+        checkArgument(!weightedClusters.isEmpty(), "empty cluster list");
+        return RouteAction.create(
+            hashPolicies, timeoutNano, null, weightedClusters, null, retryPolicy, autoHostRewrite);
+      }
+
+      static RouteAction forClusterSpecifierPlugin(
+          NamedPluginConfig namedConfig,
+          List<HashPolicy> hashPolicies,
+          @Nullable Long timeoutNano,
+          @Nullable RetryPolicy retryPolicy,
+          boolean autoHostRewrite) {
+        checkNotNull(namedConfig, "namedConfig");
+        return RouteAction.create(hashPolicies, timeoutNano, null, null, namedConfig, retryPolicy,
+            autoHostRewrite);
+      }
+
+      private static RouteAction create(
+          List<HashPolicy> hashPolicies,
+          @Nullable Long timeoutNano,
+          @Nullable String cluster,
+          @Nullable List<ClusterWeight> weightedClusters,
+          @Nullable NamedPluginConfig namedConfig,
+          @Nullable RetryPolicy retryPolicy,
+          boolean autoHostRewrite) {
+        return new AutoValue_VirtualHost_Route_RouteAction(
+            ImmutableList.copyOf(hashPolicies),
+            timeoutNano,
+            cluster,
+            weightedClusters == null ? null : ImmutableList.copyOf(weightedClusters),
+            namedConfig,
+            retryPolicy,
+            autoHostRewrite);
+      }
+
+      @AutoValue
+      abstract static class ClusterWeight {
+        abstract String name();
+
+        abstract long weight();
+
+        abstract ImmutableMap<String, FilterConfig> filterConfigOverrides();
+
+        static ClusterWeight create(
+            String name, long weight, Map<String, FilterConfig> filterConfigOverrides) {
+          checkArgument(weight >= 0, "weight must not be negative");
+          return new AutoValue_VirtualHost_Route_RouteAction_ClusterWeight(
+              name, weight, ImmutableMap.copyOf(filterConfigOverrides));
+        }
+      }
+
+      // Configuration for the route's hashing policy if the upstream cluster uses a hashing load
+      // balancer.
+      @AutoValue
+      abstract static class HashPolicy {
+        // The specifier that indicates the component of the request to be hashed on.
+        abstract Type type();
+
+        // The flag that short-circuits the hash computing.
+        abstract boolean isTerminal();
+
+        // The name of the request header that will be used to obtain the hash key.
+        // Only valid if type is HEADER.
+        @Nullable
+        abstract String headerName();
+
+        // The regular expression used to find portions to be replaced in the header value.
+        // Only valid if type is HEADER.
+        @Nullable
+        abstract Pattern regEx();
+
+        // The string that should be substituted into matching portions of the header value.
+        // Only valid if type is HEADER.
+        @Nullable
+        abstract String regExSubstitution();
+
+        static HashPolicy forHeader(boolean isTerminal, String headerName,
+            @Nullable Pattern regEx, @Nullable String regExSubstitution) {
+          checkNotNull(headerName, "headerName");
+          return HashPolicy.create(Type.HEADER, isTerminal, headerName, regEx, regExSubstitution);
+        }
+
+        static HashPolicy forChannelId(boolean isTerminal) {
+          return HashPolicy.create(Type.CHANNEL_ID, isTerminal, null, null, null);
+        }
+
+        private static HashPolicy create(Type type, boolean isTerminal, @Nullable String headerName,
+            @Nullable Pattern regEx, @Nullable String regExSubstitution) {
+          return new AutoValue_VirtualHost_Route_RouteAction_HashPolicy(type, isTerminal,
+              headerName, regEx, regExSubstitution);
+        }
+
+        enum Type {
+          HEADER, CHANNEL_ID
+        }
+      }
+
+      @AutoValue
+      abstract static class RetryPolicy {
+        abstract int maxAttempts();
+
+        abstract ImmutableList<Code> retryableStatusCodes();
+
+        abstract Duration initialBackoff();
+
+        abstract Duration maxBackoff();
+
+        @Nullable
+        abstract Duration perAttemptRecvTimeout();
+
+        static RetryPolicy create(
+            int maxAttempts, List<Code> retryableStatusCodes, Duration initialBackoff,
+            Duration maxBackoff, @Nullable Duration perAttemptRecvTimeout) {
+          return new AutoValue_VirtualHost_Route_RouteAction_RetryPolicy(
+              maxAttempts,
+              ImmutableList.copyOf(retryableStatusCodes),
+              initialBackoff,
+              maxBackoff,
+              perAttemptRecvTimeout);
+        }
+      }
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/WeightedRandomPicker.java b/xds/src/main/java/io/grpc/xds/WeightedRandomPicker.java
new file mode 100644
index 00000000000..904f3872b6d
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/WeightedRandomPicker.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright 2019 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.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.primitives.UnsignedInteger;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+final class WeightedRandomPicker extends SubchannelPicker {
+
+  @VisibleForTesting
+  final List<WeightedChildPicker> weightedChildPickers;
+
+  private final ThreadSafeRandom random;
+  private final long totalWeight;
+
+  static final class WeightedChildPicker {
+    private final long weight;
+    private final SubchannelPicker childPicker;
+
+    WeightedChildPicker(long weight, SubchannelPicker childPicker) {
+      checkArgument(weight >= 0, "weight is negative");
+      checkArgument(weight <= UnsignedInteger.MAX_VALUE.longValue(), "weight is too large");
+      checkNotNull(childPicker, "childPicker is null");
+
+      this.weight = weight;
+      this.childPicker = childPicker;
+    }
+
+    long getWeight() {
+      return weight;
+    }
+
+    SubchannelPicker getPicker() {
+      return childPicker;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      WeightedChildPicker that = (WeightedChildPicker) o;
+      return weight == that.weight && Objects.equals(childPicker, that.childPicker);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(weight, childPicker);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("weight", weight)
+          .add("childPicker", childPicker)
+          .toString();
+    }
+  }
+
+  WeightedRandomPicker(List<WeightedChildPicker> weightedChildPickers) {
+    this(weightedChildPickers, ThreadSafeRandom.ThreadSafeRandomImpl.instance);
+  }
+
+  @VisibleForTesting
+  WeightedRandomPicker(List<WeightedChildPicker> weightedChildPickers, ThreadSafeRandom random) {
+    checkNotNull(weightedChildPickers, "weightedChildPickers in null");
+    checkArgument(!weightedChildPickers.isEmpty(), "weightedChildPickers is empty");
+
+    this.weightedChildPickers = Collections.unmodifiableList(weightedChildPickers);
+
+    long totalWeight = 0;
+    for (WeightedChildPicker weightedChildPicker : weightedChildPickers) {
+      long weight = weightedChildPicker.getWeight();
+      checkArgument(weight >= 0, "weight is negative");
+      checkNotNull(weightedChildPicker.getPicker(), "childPicker is null");
+      totalWeight += weight;
+    }
+    this.totalWeight = totalWeight;
+    checkArgument(totalWeight <= UnsignedInteger.MAX_VALUE.longValue(),
+        "total weight greater than unsigned int can hold");
+
+    this.random = random;
+  }
+
+  @Override
+  public final PickResult pickSubchannel(PickSubchannelArgs args) {
+    SubchannelPicker childPicker = null;
+
+    if (totalWeight == 0) {
+      childPicker =
+          weightedChildPickers.get(random.nextInt(weightedChildPickers.size())).getPicker();
+    } else {
+      long rand = random.nextLong(totalWeight);
+
+      // Find the first idx such that rand < accumulatedWeights[idx]
+      // Not using Arrays.binarySearch for better readability.
+      long accumulatedWeight = 0;
+      for (WeightedChildPicker weightedChildPicker : weightedChildPickers) {
+        accumulatedWeight += weightedChildPicker.getWeight();
+        if (rand < accumulatedWeight) {
+          childPicker = weightedChildPicker.getPicker();
+          break;
+        }
+      }
+      checkNotNull(childPicker, "childPicker not found");
+    }
+
+    return childPicker.pickSubchannel(args);
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("weightedChildPickers", weightedChildPickers)
+        .add("totalWeight", totalWeight)
+        .toString();
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/WeightedRoundRobinLoadBalancer.java b/xds/src/main/java/io/grpc/xds/WeightedRoundRobinLoadBalancer.java
new file mode 100644
index 00000000000..6cf3189d587
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/WeightedRoundRobinLoadBalancer.java
@@ -0,0 +1,819 @@
+/*
+ * Copyright 2023 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.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.Deadline.Ticker;
+import io.grpc.DoubleHistogramMetricInstrument;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LongCounterMetricInstrument;
+import io.grpc.MetricInstrumentRegistry;
+import io.grpc.NameResolver;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import io.grpc.services.MetricReport;
+import io.grpc.util.ForwardingSubchannel;
+import io.grpc.util.MultiChildLoadBalancer;
+import io.grpc.xds.orca.OrcaOobUtil;
+import io.grpc.xds.orca.OrcaOobUtil.OrcaOobReportListener;
+import io.grpc.xds.orca.OrcaPerRequestUtil;
+import io.grpc.xds.orca.OrcaPerRequestUtil.OrcaPerRequestReportListener;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * A {@link LoadBalancer} that provides weighted-round-robin load-balancing over the
+ * {@link EquivalentAddressGroup}s from the {@link NameResolver}. The subchannel weights are
+ * determined by backend metrics using ORCA.
+ * To use WRR, users may configure through channel serviceConfig. Example config:
+ * <pre> {@code
+ *       String wrrConfig = "{\"loadBalancingConfig\":" +
+ *           "[{\"weighted_round_robin\":{\"enableOobLoadReport\":true, " +
+ *           "\"blackoutPeriod\":\"10s\"," +
+ *           "\"oobReportingPeriod\":\"10s\"," +
+ *           "\"weightExpirationPeriod\":\"180s\"," +
+ *           "\"errorUtilizationPenalty\":\"1.0\"," +
+ *           "\"weightUpdatePeriod\":\"1s\"}}]}";
+ *        serviceConfig = (Map<String, ?>) JsonParser.parse(wrrConfig);
+ *        channel = ManagedChannelBuilder.forTarget("test:///lb.test.grpc.io")
+ *            .defaultServiceConfig(serviceConfig)
+ *            .build();
+ *  }
+ *  </pre>
+ *  Users may also configure through xDS control plane via custom lb policy. But that is much more
+ *  complex to set up. Example config:
+ *  <pre>
+ *  localityLbPolicies:
+ *   - customPolicy:
+ *       name: weighted_round_robin
+ *       data: '{ "enableOobLoadReport": true }'
+ *  </pre>
+ *  See related documentation: https://cloud.google.com/service-mesh/legacy/load-balancing-apis/proxyless-configure-advanced-traffic-management#custom-lb-config
+ */
+final class WeightedRoundRobinLoadBalancer extends MultiChildLoadBalancer {
+
+  private static final LongCounterMetricInstrument RR_FALLBACK_COUNTER;
+  private static final LongCounterMetricInstrument ENDPOINT_WEIGHT_NOT_YET_USEABLE_COUNTER;
+  private static final LongCounterMetricInstrument ENDPOINT_WEIGHT_STALE_COUNTER;
+  private static final DoubleHistogramMetricInstrument ENDPOINT_WEIGHTS_HISTOGRAM;
+  private static final Logger log = Logger.getLogger(
+      WeightedRoundRobinLoadBalancer.class.getName());
+  private WeightedRoundRobinLoadBalancerConfig config;
+  private final SynchronizationContext syncContext;
+  private final ScheduledExecutorService timeService;
+  private ScheduledHandle weightUpdateTimer;
+  private final Runnable updateWeightTask;
+  private final AtomicInteger sequence;
+  private final long infTime;
+  private final Ticker ticker;
+  private String locality = "";
+  private String backendService = "";
+  private SubchannelPicker currentPicker = new FixedResultPicker(PickResult.withNoResult());
+
+  // The metric instruments are only registered once and shared by all instances of this LB.
+  static {
+    MetricInstrumentRegistry metricInstrumentRegistry
+        = MetricInstrumentRegistry.getDefaultRegistry();
+    RR_FALLBACK_COUNTER = metricInstrumentRegistry.registerLongCounter(
+        "grpc.lb.wrr.rr_fallback",
+        "EXPERIMENTAL. Number of scheduler updates in which there were not enough endpoints "
+            + "with valid weight, which caused the WRR policy to fall back to RR behavior",
+        "{update}",
+        Lists.newArrayList("grpc.target"),
+        Lists.newArrayList("grpc.lb.locality", "grpc.lb.backend_service"),
+        false);
+    ENDPOINT_WEIGHT_NOT_YET_USEABLE_COUNTER = metricInstrumentRegistry.registerLongCounter(
+        "grpc.lb.wrr.endpoint_weight_not_yet_usable",
+        "EXPERIMENTAL. Number of endpoints from each scheduler update that don't yet have usable "
+            + "weight information",
+        "{endpoint}",
+        Lists.newArrayList("grpc.target"),
+        Lists.newArrayList("grpc.lb.locality", "grpc.lb.backend_service"),
+        false);
+    ENDPOINT_WEIGHT_STALE_COUNTER = metricInstrumentRegistry.registerLongCounter(
+        "grpc.lb.wrr.endpoint_weight_stale",
+        "EXPERIMENTAL. Number of endpoints from each scheduler update whose latest weight is "
+            + "older than the expiration period",
+        "{endpoint}",
+        Lists.newArrayList("grpc.target"),
+        Lists.newArrayList("grpc.lb.locality", "grpc.lb.backend_service"),
+        false);
+    ENDPOINT_WEIGHTS_HISTOGRAM = metricInstrumentRegistry.registerDoubleHistogram(
+        "grpc.lb.wrr.endpoint_weights",
+        "EXPERIMENTAL. The histogram buckets will be endpoint weight ranges.",
+        "{weight}",
+        Lists.newArrayList(),
+        Lists.newArrayList("grpc.target"),
+        Lists.newArrayList("grpc.lb.locality", "grpc.lb.backend_service"),
+        false);
+  }
+
+  public WeightedRoundRobinLoadBalancer(Helper helper, Ticker ticker) {
+    this(helper, ticker, new Random());
+  }
+
+  @VisibleForTesting
+  WeightedRoundRobinLoadBalancer(Helper helper, Ticker ticker, Random random) {
+    super(OrcaOobUtil.newOrcaReportingHelper(helper));
+    this.ticker = checkNotNull(ticker, "ticker");
+    this.infTime = ticker.nanoTime() + Long.MAX_VALUE;
+    this.syncContext = checkNotNull(helper.getSynchronizationContext(), "syncContext");
+    this.timeService = checkNotNull(helper.getScheduledExecutorService(), "timeService");
+    this.updateWeightTask = new UpdateWeightTask();
+    this.sequence = new AtomicInteger(random.nextInt());
+    log.log(Level.FINE, "weighted_round_robin LB created");
+  }
+
+  @Override
+  protected ChildLbState createChildLbState(Object key) {
+    return new WeightedChildLbState(key, pickFirstLbProvider);
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    if (resolvedAddresses.getLoadBalancingPolicyConfig() == null) {
+      Status unavailableStatus = Status.UNAVAILABLE.withDescription(
+              "NameResolver returned no WeightedRoundRobinLoadBalancerConfig. addrs="
+                      + resolvedAddresses.getAddresses()
+                      + ", attrs=" + resolvedAddresses.getAttributes());
+      handleNameResolutionError(unavailableStatus);
+      return unavailableStatus;
+    }
+    String locality = resolvedAddresses.getAttributes().get(WeightedTargetLoadBalancer.CHILD_NAME);
+    if (locality != null) {
+      this.locality = locality;
+    } else {
+      this.locality = "";
+    }
+    String backendService
+        = resolvedAddresses.getAttributes().get(NameResolver.ATTR_BACKEND_SERVICE);
+    if (backendService != null) {
+      this.backendService = backendService;
+    } else {
+      this.backendService = "";
+    }
+    config =
+            (WeightedRoundRobinLoadBalancerConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+
+    if (weightUpdateTimer != null && weightUpdateTimer.isPending()) {
+      weightUpdateTimer.cancel();
+    }
+    updateWeightTask.run();
+
+    Status status = super.acceptResolvedAddresses(resolvedAddresses);
+
+    createAndApplyOrcaListeners();
+
+    return status;
+  }
+
+  /**
+   * Updates picker with the list of active subchannels (state == READY).
+   */
+  @Override
+  protected void updateOverallBalancingState() {
+    List<ChildLbState> activeList = getReadyChildren();
+    if (activeList.isEmpty()) {
+      // No READY subchannels
+
+      // MultiChildLB will request connection immediately on subchannel IDLE.
+      boolean isConnecting = false;
+      for (ChildLbState childLbState : getChildLbStates()) {
+        ConnectivityState state = childLbState.getCurrentState();
+        if (state == ConnectivityState.CONNECTING || state == ConnectivityState.IDLE) {
+          isConnecting = true;
+          break;
+        }
+      }
+
+      if (isConnecting) {
+        updateBalancingState(
+            ConnectivityState.CONNECTING, new FixedResultPicker(PickResult.withNoResult()));
+      } else {
+        updateBalancingState(
+            ConnectivityState.TRANSIENT_FAILURE, createReadyPicker(getChildLbStates()));
+      }
+    } else {
+      updateBalancingState(ConnectivityState.READY, createReadyPicker(activeList));
+    }
+  }
+
+  private SubchannelPicker createReadyPicker(Collection<ChildLbState> activeList) {
+    WeightedRoundRobinPicker picker = new WeightedRoundRobinPicker(ImmutableList.copyOf(activeList),
+        config.enableOobLoadReport, config.errorUtilizationPenalty, sequence);
+    updateWeight(picker);
+    return picker;
+  }
+
+  private void updateWeight(WeightedRoundRobinPicker picker) {
+    Helper helper = getHelper();
+    float[] newWeights = new float[picker.children.size()];
+    AtomicInteger staleEndpoints = new AtomicInteger();
+    AtomicInteger notYetUsableEndpoints = new AtomicInteger();
+    for (int i = 0; i < picker.children.size(); i++) {
+      double newWeight = ((WeightedChildLbState) picker.children.get(i)).getWeight(staleEndpoints,
+          notYetUsableEndpoints);
+      helper.getMetricRecorder()
+          .recordDoubleHistogram(ENDPOINT_WEIGHTS_HISTOGRAM, newWeight,
+              ImmutableList.of(helper.getChannelTarget()),
+              ImmutableList.of(locality, backendService));
+      newWeights[i] = newWeight > 0 ? (float) newWeight : 0.0f;
+    }
+
+    if (staleEndpoints.get() > 0) {
+      helper.getMetricRecorder()
+          .addLongCounter(ENDPOINT_WEIGHT_STALE_COUNTER, staleEndpoints.get(),
+              ImmutableList.of(helper.getChannelTarget()),
+              ImmutableList.of(locality, backendService));
+    }
+    if (notYetUsableEndpoints.get() > 0) {
+      helper.getMetricRecorder()
+          .addLongCounter(ENDPOINT_WEIGHT_NOT_YET_USEABLE_COUNTER, notYetUsableEndpoints.get(),
+              ImmutableList.of(helper.getChannelTarget()),
+              ImmutableList.of(locality, backendService));
+    }
+    boolean weightsEffective = picker.updateWeight(newWeights);
+    if (!weightsEffective) {
+      helper.getMetricRecorder()
+          .addLongCounter(RR_FALLBACK_COUNTER, 1, ImmutableList.of(helper.getChannelTarget()),
+              ImmutableList.of(locality, backendService));
+    }
+  }
+
+  private void updateBalancingState(ConnectivityState state, SubchannelPicker picker) {
+    if (state != currentConnectivityState || !picker.equals(currentPicker)) {
+      getHelper().updateBalancingState(state, picker);
+      currentConnectivityState = state;
+      currentPicker = picker;
+    }
+  }
+
+  @VisibleForTesting
+  final class WeightedChildLbState extends ChildLbState {
+
+    private final Set<WrrSubchannel> subchannels = new HashSet<>();
+    private volatile long lastUpdated;
+    private volatile long nonEmptySince;
+    private volatile double weight = 0;
+
+    private OrcaReportListener orcaReportListener;
+
+    public WeightedChildLbState(Object key, LoadBalancerProvider policyProvider) {
+      super(key, policyProvider);
+    }
+
+    @Override
+    protected ChildLbStateHelper createChildHelper() {
+      return new WrrChildLbStateHelper();
+    }
+
+    private double getWeight(AtomicInteger staleEndpoints, AtomicInteger notYetUsableEndpoints) {
+      if (config == null) {
+        return 0;
+      }
+      long now = ticker.nanoTime();
+      if (now - lastUpdated >= config.weightExpirationPeriodNanos) {
+        nonEmptySince = infTime;
+        staleEndpoints.incrementAndGet();
+        return 0;
+      } else if (now - nonEmptySince < config.blackoutPeriodNanos
+          && config.blackoutPeriodNanos > 0) {
+        notYetUsableEndpoints.incrementAndGet();
+        return 0;
+      } else {
+        return weight;
+      }
+    }
+
+    public void addSubchannel(WrrSubchannel wrrSubchannel) {
+      subchannels.add(wrrSubchannel);
+    }
+
+    public OrcaReportListener getOrCreateOrcaListener(float errorUtilizationPenalty) {
+      if (orcaReportListener != null
+          && orcaReportListener.errorUtilizationPenalty == errorUtilizationPenalty) {
+        return orcaReportListener;
+      }
+      orcaReportListener = new OrcaReportListener(errorUtilizationPenalty);
+      return orcaReportListener;
+    }
+
+    public void removeSubchannel(WrrSubchannel wrrSubchannel) {
+      subchannels.remove(wrrSubchannel);
+    }
+
+    final class WrrChildLbStateHelper extends ChildLbStateHelper {
+      @Override
+      public Subchannel createSubchannel(CreateSubchannelArgs args) {
+        return new WrrSubchannel(super.createSubchannel(args), WeightedChildLbState.this);
+      }
+
+      @Override
+      public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+        super.updateBalancingState(newState, newPicker);
+        if (!resolvingAddresses && newState == ConnectivityState.IDLE) {
+          getLb().requestConnection();
+        }
+      }
+    }
+
+    final class OrcaReportListener implements OrcaPerRequestReportListener, OrcaOobReportListener {
+      private final float errorUtilizationPenalty;
+
+      OrcaReportListener(float errorUtilizationPenalty) {
+        this.errorUtilizationPenalty = errorUtilizationPenalty;
+      }
+
+      @Override
+      public void onLoadReport(MetricReport report) {
+        double newWeight = 0;
+        // Prefer application utilization and fallback to CPU utilization if unset.
+        double utilization =
+            report.getApplicationUtilization() > 0 ? report.getApplicationUtilization()
+                : report.getCpuUtilization();
+        if (utilization > 0 && report.getQps() > 0) {
+          double penalty = 0;
+          if (report.getEps() > 0 && errorUtilizationPenalty > 0) {
+            penalty = report.getEps() / report.getQps() * errorUtilizationPenalty;
+          }
+          newWeight = report.getQps() / (utilization + penalty);
+        }
+        if (newWeight == 0) {
+          return;
+        }
+        if (nonEmptySince == infTime) {
+          nonEmptySince = ticker.nanoTime();
+        }
+        lastUpdated = ticker.nanoTime();
+        weight = newWeight;
+      }
+    }
+  }
+
+  private final class UpdateWeightTask implements Runnable {
+    @Override
+    public void run() {
+      if (currentPicker != null && currentPicker instanceof WeightedRoundRobinPicker) {
+        updateWeight((WeightedRoundRobinPicker) currentPicker);
+      }
+      weightUpdateTimer = syncContext.schedule(this, config.weightUpdatePeriodNanos,
+          TimeUnit.NANOSECONDS, timeService);
+    }
+  }
+
+  private void createAndApplyOrcaListeners() {
+    for (ChildLbState child : getChildLbStates()) {
+      WeightedChildLbState wChild = (WeightedChildLbState) child;
+      for (WrrSubchannel weightedSubchannel : wChild.subchannels) {
+        if (config.enableOobLoadReport) {
+          OrcaOobUtil.setListener(weightedSubchannel,
+              wChild.getOrCreateOrcaListener(config.errorUtilizationPenalty),
+              OrcaOobUtil.OrcaReportingConfig.newBuilder()
+                  .setReportInterval(config.oobReportingPeriodNanos, TimeUnit.NANOSECONDS)
+                  .build());
+        } else {
+          OrcaOobUtil.setListener(weightedSubchannel, null, null);
+        }
+      }
+    }
+  }
+
+  @Override
+  public void shutdown() {
+    if (weightUpdateTimer != null) {
+      weightUpdateTimer.cancel();
+    }
+    super.shutdown();
+  }
+
+  @VisibleForTesting
+  final class WrrSubchannel extends ForwardingSubchannel {
+    private final Subchannel delegate;
+    private final WeightedChildLbState owner;
+
+    WrrSubchannel(Subchannel delegate, WeightedChildLbState owner) {
+      this.delegate = checkNotNull(delegate, "delegate");
+      this.owner = checkNotNull(owner, "owner");
+    }
+
+    @Override
+    public void start(SubchannelStateListener listener) {
+      owner.addSubchannel(this);
+      delegate().start(new SubchannelStateListener() {
+        @Override
+        public void onSubchannelState(ConnectivityStateInfo newState) {
+          if (newState.getState().equals(ConnectivityState.READY)) {
+            owner.nonEmptySince = infTime;
+          }
+          listener.onSubchannelState(newState);
+        }
+      });
+    }
+
+    @Override
+    protected Subchannel delegate() {
+      return delegate;
+    }
+
+    @Override
+    public void shutdown() {
+      super.shutdown();
+      owner.removeSubchannel(this);
+    }
+  }
+
+  @VisibleForTesting
+  static final class WeightedRoundRobinPicker extends SubchannelPicker {
+    // Parallel lists (column-based storage instead of normal row-based storage of List<Struct>).
+    // The ith element of children corresponds to the ith element of pickers, listeners, and even
+    // updateWeight(float[]).
+    private final List<ChildLbState> children; // May only be accessed from sync context
+    private final List<SubchannelPicker> pickers;
+    private final List<OrcaPerRequestReportListener> reportListeners;
+    private final boolean enableOobLoadReport;
+    private final float errorUtilizationPenalty;
+    private final AtomicInteger sequence;
+    private final int hashCode;
+    private volatile StaticStrideScheduler scheduler;
+
+    WeightedRoundRobinPicker(List<ChildLbState> children, boolean enableOobLoadReport,
+        float errorUtilizationPenalty, AtomicInteger sequence) {
+      checkNotNull(children, "children");
+      Preconditions.checkArgument(!children.isEmpty(), "empty child list");
+      this.children = children;
+      List<SubchannelPicker> pickers = new ArrayList<>(children.size());
+      List<OrcaPerRequestReportListener> reportListeners = new ArrayList<>(children.size());
+      for (ChildLbState child : children) {
+        WeightedChildLbState wChild = (WeightedChildLbState) child;
+        pickers.add(wChild.getCurrentPicker());
+        reportListeners.add(wChild.getOrCreateOrcaListener(errorUtilizationPenalty));
+      }
+      this.pickers = pickers;
+      this.reportListeners = reportListeners;
+      this.enableOobLoadReport = enableOobLoadReport;
+      this.errorUtilizationPenalty = errorUtilizationPenalty;
+      this.sequence = checkNotNull(sequence, "sequence");
+
+      // For equality we treat pickers as a set; use hash code as defined by Set
+      int sum = 0;
+      for (SubchannelPicker picker : pickers) {
+        sum += picker.hashCode();
+      }
+      this.hashCode = sum
+          ^ Boolean.hashCode(enableOobLoadReport)
+          ^ Float.hashCode(errorUtilizationPenalty);
+    }
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      int pick = scheduler.pick();
+      PickResult pickResult = pickers.get(pick).pickSubchannel(args);
+      Subchannel subchannel = pickResult.getSubchannel();
+      if (subchannel == null) {
+        return pickResult;
+      }
+      if (!enableOobLoadReport) {
+        return PickResult.withSubchannel(subchannel,
+            OrcaPerRequestUtil.getInstance().newOrcaClientStreamTracerFactory(
+                reportListeners.get(pick)));
+      } else {
+        return PickResult.withSubchannel(subchannel);
+      }
+    }
+
+    /** Returns {@code true} if weights are different than round_robin. */
+    private boolean updateWeight(float[] newWeights) {
+      this.scheduler = new StaticStrideScheduler(newWeights, sequence);
+      return !this.scheduler.usesRoundRobin();
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(WeightedRoundRobinPicker.class)
+          .add("enableOobLoadReport", enableOobLoadReport)
+          .add("errorUtilizationPenalty", errorUtilizationPenalty)
+          .add("pickers", pickers)
+          .toString();
+    }
+
+    @VisibleForTesting
+    List<ChildLbState> getChildren() {
+      return children;
+    }
+
+    @Override
+    public int hashCode() {
+      return hashCode;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (!(o instanceof WeightedRoundRobinPicker)) {
+        return false;
+      }
+      WeightedRoundRobinPicker other = (WeightedRoundRobinPicker) o;
+      if (other == this) {
+        return true;
+      }
+      // the lists cannot contain duplicate subchannels
+      return hashCode == other.hashCode
+          && sequence == other.sequence
+          && enableOobLoadReport == other.enableOobLoadReport
+          && Float.compare(errorUtilizationPenalty, other.errorUtilizationPenalty) == 0
+          && pickers.size() == other.pickers.size()
+          && new HashSet<>(pickers).containsAll(other.pickers);
+    }
+  }
+
+  /*
+   * The Static Stride Scheduler is an implementation of an earliest deadline first (EDF) scheduler
+   * in which each object's deadline is the multiplicative inverse of the object's weight.
+   * <p>
+   * The way in which this is implemented is through a static stride scheduler. 
+   * The Static Stride Scheduler works by iterating through the list of subchannel weights
+   * and using modular arithmetic to proportionally distribute picks, favoring entries 
+   * with higher weights. It is based on the observation that the intended sequence generated 
+   * from an EDF scheduler is a periodic one that can be achieved through modular arithmetic. 
+   * The Static Stride Scheduler is more performant than other implementations of the EDF
+   * Scheduler, as it removes the need for a priority queue (and thus mutex locks).
+   * <p>
+   * go/static-stride-scheduler
+   * <p>
+   *
+   * <ul>
+   *  <li>nextSequence() - O(1)
+   *  <li>pick() - O(n)
+   */
+  @VisibleForTesting
+  static final class StaticStrideScheduler {
+    private final short[] scaledWeights;
+    private final AtomicInteger sequence;
+    private final boolean usesRoundRobin;
+    private static final int K_MAX_WEIGHT = 0xFFFF;
+
+    // Assuming the mean of all known weights is M, StaticStrideScheduler will clamp
+    // weights bigger than M*kMaxRatio and weights smaller than M*kMinRatio.
+    //
+    // This is done as a performance optimization by limiting the number of rounds for picks
+    // for edge cases where channels have large differences in subchannel weights.
+    // In this case, without these clips, it would potentially require the scheduler to
+    // frequently traverse through the entire subchannel list within the pick method.
+    //
+    // The current values of 10 and 0.1 were chosen without any experimenting. It should
+    // decrease the amount of sequences that the scheduler must traverse through in order
+    // to pick a high weight subchannel in such corner cases.
+    // But, it also makes WeightedRoundRobin to send slightly more requests to
+    // potentially very bad tasks (that would have near-zero weights) than zero.
+    // This is not necessarily a downside, though. Perhaps this is not a problem at
+    // all, and we can increase this value if needed to save CPU cycles.
+    private static final double K_MAX_RATIO = 10;
+    private static final double K_MIN_RATIO = 0.1;
+
+    StaticStrideScheduler(float[] weights, AtomicInteger sequence) {
+      checkArgument(weights.length >= 1, "Couldn't build scheduler: requires at least one weight");
+      int numChannels = weights.length;
+      int numWeightedChannels = 0;
+      double sumWeight = 0;
+      double unscaledMeanWeight;
+      float unscaledMaxWeight = 0;
+      for (float weight : weights) {
+        if (weight > 0) {
+          sumWeight += weight;
+          unscaledMaxWeight = Math.max(weight, unscaledMaxWeight);
+          numWeightedChannels++;
+        }
+      }
+
+      // Adjust max value s.t. ratio does not exceed K_MAX_RATIO. This should
+      // ensure that we on average do at most K_MAX_RATIO rounds for picks.
+      if (numWeightedChannels > 0) {
+        unscaledMeanWeight = sumWeight / numWeightedChannels;
+        unscaledMaxWeight = Math.min(unscaledMaxWeight, (float) (K_MAX_RATIO * unscaledMeanWeight));
+      } else {
+        // Fall back to round robin if all values are non-positives. Note that
+        // numWeightedChannels == 1 also behaves like RR because the weights are all the same, but
+        // the weights aren't 1, so it doesn't go through this path.
+        unscaledMeanWeight = 1;
+        unscaledMaxWeight = 1;
+      }
+      // We need at least two weights for WRR to be distinguishable from round_robin.
+      usesRoundRobin = numWeightedChannels < 2;
+
+      // Scales weights s.t. max(weights) == K_MAX_WEIGHT, meanWeight is scaled accordingly.
+      // Note that, since we cap the weights to stay within K_MAX_RATIO, meanWeight might not
+      // match the actual mean of the values that end up in the scheduler.
+      double scalingFactor = K_MAX_WEIGHT / unscaledMaxWeight;
+      // We compute weightLowerBound and clamp it to 1 from below so that in the
+      // worst case, we represent tiny weights as 1.
+      int weightLowerBound = (int) Math.ceil(scalingFactor * unscaledMeanWeight * K_MIN_RATIO);
+      short[] scaledWeights = new short[numChannels];
+      for (int i = 0; i < numChannels; i++) {
+        if (weights[i] <= 0) {
+          scaledWeights[i] = (short) Math.round(scalingFactor * unscaledMeanWeight);
+        } else {
+          int weight = (int) Math.round(scalingFactor * Math.min(weights[i], unscaledMaxWeight));
+          scaledWeights[i] = (short) Math.max(weight, weightLowerBound);
+        }
+      }
+
+      this.scaledWeights = scaledWeights;
+      this.sequence = sequence;
+    }
+
+    // Without properly weighted channels, we do plain vanilla round_robin.
+    boolean usesRoundRobin() {
+      return usesRoundRobin;
+    }
+
+    /**
+     * Returns the next sequence number and atomically increases sequence with wraparound.
+     */
+    private long nextSequence() {
+      return Integer.toUnsignedLong(sequence.getAndIncrement());
+    }
+
+    /*
+     * Selects index of next backend server.
+     * <p>
+     * A 2D array is compactly represented as a function of W(backend), where the row
+     * represents the generation and the column represents the backend index:
+     * X(backend,generation) | generation ∈ [0,kMaxWeight).
+     * Each element in the conceptual array is a boolean indicating whether the backend at
+     * this index should be picked now. If false, the counter is incremented again,
+     * and the new element is checked. An atomically incremented counter keeps track of our
+     * backend and generation through modular arithmetic within the pick() method.
+     * <p>
+     * Modular arithmetic allows us to evenly distribute picks and skips between
+     * generations based on W(backend).
+     * X(backend,generation) = (W(backend) * generation) % kMaxWeight >= kMaxWeight - W(backend)
+     * If we have the same three backends with weights:
+     * W(backend) = {2,3,6} scaled to max(W(backend)) = 6, then X(backend,generation) is:
+     * <p>
+     * B0    B1    B2
+     * T     T     T
+     * F     F     T
+     * F     T     T
+     * T     F     T
+     * F     T     T
+     * F     F     T
+     * The sequence of picked backend indices is given by
+     * walking across and down: {0,1,2,2,1,2,0,2,1,2,2}.
+     * <p>
+     * To reduce the variance and spread the wasted work among different picks,
+     * an offset that varies per backend index is also included to the calculation.
+     */
+    int pick() {
+      while (true) {
+        long sequence = this.nextSequence();
+        int backendIndex = (int) (sequence % scaledWeights.length);
+        long generation = sequence / scaledWeights.length;
+        int weight = Short.toUnsignedInt(scaledWeights[backendIndex]);
+        long offset = (long) K_MAX_WEIGHT / 2 * backendIndex;
+        if ((weight * generation + offset) % K_MAX_WEIGHT < K_MAX_WEIGHT - weight) {
+          continue;
+        }
+        return backendIndex;
+      }
+    }
+  }
+
+  static final class WeightedRoundRobinLoadBalancerConfig {
+    final long blackoutPeriodNanos;
+    final long weightExpirationPeriodNanos;
+    final boolean enableOobLoadReport;
+    final long oobReportingPeriodNanos;
+    final long weightUpdatePeriodNanos;
+    final float errorUtilizationPenalty;
+
+    public static Builder newBuilder() {
+      return new Builder();
+    }
+
+    private WeightedRoundRobinLoadBalancerConfig(long blackoutPeriodNanos,
+                                                 long weightExpirationPeriodNanos,
+                                                 boolean enableOobLoadReport,
+                                                 long oobReportingPeriodNanos,
+                                                 long weightUpdatePeriodNanos,
+                                                 float errorUtilizationPenalty) {
+      this.blackoutPeriodNanos = blackoutPeriodNanos;
+      this.weightExpirationPeriodNanos = weightExpirationPeriodNanos;
+      this.enableOobLoadReport = enableOobLoadReport;
+      this.oobReportingPeriodNanos = oobReportingPeriodNanos;
+      this.weightUpdatePeriodNanos = weightUpdatePeriodNanos;
+      this.errorUtilizationPenalty = errorUtilizationPenalty;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (!(o instanceof WeightedRoundRobinLoadBalancerConfig)) {
+        return false;
+      }
+      WeightedRoundRobinLoadBalancerConfig that = (WeightedRoundRobinLoadBalancerConfig) o;
+      return this.blackoutPeriodNanos == that.blackoutPeriodNanos
+          && this.weightExpirationPeriodNanos == that.weightExpirationPeriodNanos
+          && this.enableOobLoadReport == that.enableOobLoadReport
+          && this.oobReportingPeriodNanos == that.oobReportingPeriodNanos
+          && this.weightUpdatePeriodNanos == that.weightUpdatePeriodNanos
+          // Float.compare considers NaNs equal
+          && Float.compare(this.errorUtilizationPenalty, that.errorUtilizationPenalty) == 0;
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(
+          blackoutPeriodNanos,
+          weightExpirationPeriodNanos,
+          enableOobLoadReport,
+          oobReportingPeriodNanos,
+          weightUpdatePeriodNanos,
+          errorUtilizationPenalty);
+    }
+
+    static final class Builder {
+      long blackoutPeriodNanos = 10_000_000_000L; // 10s
+      long weightExpirationPeriodNanos = 180_000_000_000L; //3min
+      boolean enableOobLoadReport = false;
+      long oobReportingPeriodNanos = 10_000_000_000L; // 10s
+      long weightUpdatePeriodNanos = 1_000_000_000L; // 1s
+      float errorUtilizationPenalty = 1.0F;
+
+      private Builder() {
+
+      }
+
+      @SuppressWarnings("UnusedReturnValue")
+      Builder setBlackoutPeriodNanos(long blackoutPeriodNanos) {
+        this.blackoutPeriodNanos = blackoutPeriodNanos;
+        return this;
+      }
+
+      @SuppressWarnings("UnusedReturnValue")
+      Builder setWeightExpirationPeriodNanos(long weightExpirationPeriodNanos) {
+        this.weightExpirationPeriodNanos = weightExpirationPeriodNanos;
+        return this;
+      }
+
+      Builder setEnableOobLoadReport(boolean enableOobLoadReport) {
+        this.enableOobLoadReport = enableOobLoadReport;
+        return this;
+      }
+
+      Builder setOobReportingPeriodNanos(long oobReportingPeriodNanos) {
+        this.oobReportingPeriodNanos = oobReportingPeriodNanos;
+        return this;
+      }
+
+      Builder setWeightUpdatePeriodNanos(long weightUpdatePeriodNanos) {
+        this.weightUpdatePeriodNanos = weightUpdatePeriodNanos;
+        return this;
+      }
+
+      Builder setErrorUtilizationPenalty(float errorUtilizationPenalty) {
+        this.errorUtilizationPenalty = errorUtilizationPenalty;
+        return this;
+      }
+
+      WeightedRoundRobinLoadBalancerConfig build() {
+        return new WeightedRoundRobinLoadBalancerConfig(blackoutPeriodNanos,
+                weightExpirationPeriodNanos, enableOobLoadReport, oobReportingPeriodNanos,
+                weightUpdatePeriodNanos, errorUtilizationPenalty);
+      }
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/WeightedRoundRobinLoadBalancerProvider.java b/xds/src/main/java/io/grpc/xds/WeightedRoundRobinLoadBalancerProvider.java
new file mode 100644
index 00000000000..433ea34b857
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/WeightedRoundRobinLoadBalancerProvider.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2023 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.xds;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Deadline;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.JsonUtil;
+import io.grpc.xds.WeightedRoundRobinLoadBalancer.WeightedRoundRobinLoadBalancerConfig;
+import java.util.Map;
+
+/**
+ * Provides a {@link WeightedRoundRobinLoadBalancer}.
+ * */
+@Internal
+public final class WeightedRoundRobinLoadBalancerProvider extends LoadBalancerProvider {
+
+  @VisibleForTesting
+  static final long MIN_WEIGHT_UPDATE_PERIOD_NANOS = 100_000_000L; // 100ms
+
+  static final String SCHEME = "weighted_round_robin";
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    return new WeightedRoundRobinLoadBalancer(helper, Deadline.getSystemTicker());
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return SCHEME;
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
+    try {
+      return parseLoadBalancingPolicyConfigInternal(rawConfig);
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError(
+          Status.UNAVAILABLE.withCause(e).withDescription(
+              "Failed parsing configuration for " + getPolicyName()));
+    }
+  }
+
+  private ConfigOrError parseLoadBalancingPolicyConfigInternal(Map<String, ?> rawConfig) {
+    Long blackoutPeriodNanos = JsonUtil.getStringAsDuration(rawConfig, "blackoutPeriod");
+    Long weightExpirationPeriodNanos =
+            JsonUtil.getStringAsDuration(rawConfig, "weightExpirationPeriod");
+    Long oobReportingPeriodNanos = JsonUtil.getStringAsDuration(rawConfig, "oobReportingPeriod");
+    Boolean enableOobLoadReport = JsonUtil.getBoolean(rawConfig, "enableOobLoadReport");
+    Long weightUpdatePeriodNanos = JsonUtil.getStringAsDuration(rawConfig, "weightUpdatePeriod");
+    Float errorUtilizationPenalty = JsonUtil.getNumberAsFloat(rawConfig, "errorUtilizationPenalty");
+
+    WeightedRoundRobinLoadBalancerConfig.Builder configBuilder =
+            WeightedRoundRobinLoadBalancerConfig.newBuilder();
+    if (blackoutPeriodNanos != null) {
+      configBuilder.setBlackoutPeriodNanos(blackoutPeriodNanos);
+    }
+    if (weightExpirationPeriodNanos != null) {
+      configBuilder.setWeightExpirationPeriodNanos(weightExpirationPeriodNanos);
+    }
+    if (enableOobLoadReport != null) {
+      configBuilder.setEnableOobLoadReport(enableOobLoadReport);
+    }
+    if (oobReportingPeriodNanos != null) {
+      configBuilder.setOobReportingPeriodNanos(oobReportingPeriodNanos);
+    }
+    if (weightUpdatePeriodNanos != null) {
+      configBuilder.setWeightUpdatePeriodNanos(weightUpdatePeriodNanos);
+      if (weightUpdatePeriodNanos < MIN_WEIGHT_UPDATE_PERIOD_NANOS) {
+        configBuilder.setWeightUpdatePeriodNanos(MIN_WEIGHT_UPDATE_PERIOD_NANOS);
+      }
+    }
+    if (errorUtilizationPenalty != null) {
+      configBuilder.setErrorUtilizationPenalty(errorUtilizationPenalty);
+    }
+    return ConfigOrError.fromConfig(configBuilder.build());
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/WeightedTargetLoadBalancer.java b/xds/src/main/java/io/grpc/xds/WeightedTargetLoadBalancer.java
new file mode 100644
index 00000000000..ce7427e5c2c
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/WeightedTargetLoadBalancer.java
@@ -0,0 +1,222 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+
+import com.google.common.collect.ImmutableMap;
+import io.grpc.Attributes;
+import io.grpc.ConnectivityState;
+import io.grpc.InternalLogId;
+import io.grpc.LoadBalancer;
+import io.grpc.Status;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.xds.WeightedRandomPicker.WeightedChildPicker;
+import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedPolicySelection;
+import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedTargetConfig;
+import io.grpc.xds.client.XdsLogger;
+import io.grpc.xds.client.XdsLogger.XdsLogLevel;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/** Load balancer for weighted_target policy. */
+final class WeightedTargetLoadBalancer extends LoadBalancer {
+  public static final Attributes.Key<String> CHILD_NAME =
+      Attributes.Key.create("io.grpc.xds.WeightedTargetLoadBalancer.CHILD_NAME");
+
+  private final XdsLogger logger;
+  private final Map<String, GracefulSwitchLoadBalancer> childBalancers = new HashMap<>();
+  private final Map<String, ChildHelper> childHelpers = new HashMap<>();
+  private final Helper helper;
+
+  private Map<String, WeightedPolicySelection> targets = ImmutableMap.of();
+  // Set to true if currently in the process of handling resolved addresses.
+  private boolean resolvingAddresses;
+
+  WeightedTargetLoadBalancer(Helper helper) {
+    this.helper = checkNotNull(helper, "helper");
+    logger = XdsLogger.withLogId(
+        InternalLogId.allocate("weighted-target-lb", helper.getAuthority()));
+    logger.log(XdsLogLevel.INFO, "Created");
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    try {
+      resolvingAddresses = true;
+      return acceptResolvedAddressesInternal(resolvedAddresses);
+    } finally {
+      resolvingAddresses = false;
+    }
+  }
+
+  public Status acceptResolvedAddressesInternal(ResolvedAddresses resolvedAddresses) {
+    logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
+    Object lbConfig = resolvedAddresses.getLoadBalancingPolicyConfig();
+    checkNotNull(lbConfig, "missing weighted_target lb config");
+    WeightedTargetConfig weightedTargetConfig = (WeightedTargetConfig) lbConfig;
+    Map<String, WeightedPolicySelection> newTargets = weightedTargetConfig.targets;
+    for (String targetName : newTargets.keySet()) {
+      if (!targets.containsKey(targetName)) {
+        ChildHelper childHelper = new ChildHelper(targetName);
+        GracefulSwitchLoadBalancer childBalancer = new GracefulSwitchLoadBalancer(childHelper);
+        childHelpers.put(targetName, childHelper);
+        childBalancers.put(targetName, childBalancer);
+      }
+    }
+    targets = newTargets;
+    Status status = Status.OK;
+    for (String targetName : targets.keySet()) {
+      Status newStatus = childBalancers.get(targetName).acceptResolvedAddresses(
+          resolvedAddresses.toBuilder()
+              .setAddresses(AddressFilter.filter(resolvedAddresses.getAddresses(), targetName))
+              .setLoadBalancingPolicyConfig(targets.get(targetName).childConfig)
+              .setAttributes(resolvedAddresses.getAttributes().toBuilder()
+                .set(CHILD_NAME, targetName)
+                .build())
+              .build());
+      if (!newStatus.isOk()) {
+        status = newStatus;
+      }
+    }
+
+    // Cleanup removed targets.
+    // TODO(zdapeng): cache removed target for 15 minutes.
+    for (String targetName : childBalancers.keySet()) {
+      if (!targets.containsKey(targetName)) {
+        childBalancers.get(targetName).shutdown();
+      }
+    }
+    childBalancers.keySet().retainAll(targets.keySet());
+    childHelpers.keySet().retainAll(targets.keySet());
+    updateOverallBalancingState();
+    return status;
+  }
+
+  @Override
+  public void handleNameResolutionError(Status error) {
+    logger.log(XdsLogLevel.WARNING, "Received name resolution error: {0}", error);
+    if (childBalancers.isEmpty()) {
+      helper.updateBalancingState(
+          TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(error)));
+    }
+    for (LoadBalancer childBalancer : childBalancers.values()) {
+      childBalancer.handleNameResolutionError(error);
+    }
+  }
+
+  @Override
+  public boolean canHandleEmptyAddressListFromNameResolution() {
+    return true;
+  }
+
+  @Override
+  public void shutdown() {
+    logger.log(XdsLogLevel.INFO, "Shutdown");
+    for (LoadBalancer childBalancer : childBalancers.values()) {
+      childBalancer.shutdown();
+    }
+    childBalancers.clear();
+  }
+
+  private void updateOverallBalancingState() {
+    List<WeightedChildPicker> childPickers = new ArrayList<>();
+
+    ConnectivityState overallState = null;
+    List<WeightedChildPicker> errorPickers = new ArrayList<>();
+    for (String name : targets.keySet()) {
+      ChildHelper childHelper = childHelpers.get(name);
+      ConnectivityState childState = childHelper.currentState;
+      overallState = aggregateState(overallState, childState);
+      int weight = targets.get(name).weight;
+      if (READY == childState) {
+        childPickers.add(new WeightedChildPicker(weight, childHelper.currentPicker));
+      } else if (TRANSIENT_FAILURE == childState) {
+        errorPickers.add(new WeightedChildPicker(weight, childHelper.currentPicker));
+      }
+    }
+
+    SubchannelPicker picker;
+    if (childPickers.isEmpty()) {
+      if (overallState == TRANSIENT_FAILURE) {
+        picker = new WeightedRandomPicker(errorPickers);
+      } else {
+        picker = new FixedResultPicker(PickResult.withNoResult());
+      }
+    } else {
+      picker = new WeightedRandomPicker(childPickers);
+    }
+
+    if (overallState != null) {
+      helper.updateBalancingState(overallState, picker);
+    }
+  }
+
+  @Nullable
+  private static ConnectivityState aggregateState(
+      @Nullable ConnectivityState overallState, ConnectivityState childState) {
+    if (overallState == null) {
+      return childState;
+    }
+    if (overallState == READY || childState == READY) {
+      return READY;
+    }
+    if (overallState == CONNECTING || childState == CONNECTING) {
+      return CONNECTING;
+    }
+    if (overallState == IDLE || childState == IDLE) {
+      return IDLE;
+    }
+    return overallState;
+  }
+
+  private final class ChildHelper extends ForwardingLoadBalancerHelper {
+    String name;
+    ConnectivityState currentState = CONNECTING;
+    SubchannelPicker currentPicker = new FixedResultPicker(PickResult.withNoResult());
+
+    private ChildHelper(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public void updateBalancingState(final ConnectivityState newState,
+        final SubchannelPicker newPicker) {
+      currentState = newState;
+      currentPicker = newPicker;
+
+      // If we are already in the process of resolving addresses, the overall balancing state
+      // will be updated at the end of it, and we don't need to trigger that update here.
+      if (!resolvingAddresses && childBalancers.containsKey(name)) {
+        updateOverallBalancingState();
+      }
+    }
+
+    @Override
+    protected Helper delegate() {
+      return helper;
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/WeightedTargetLoadBalancerProvider.java b/xds/src/main/java/io/grpc/xds/WeightedTargetLoadBalancerProvider.java
new file mode 100644
index 00000000000..15318693aca
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/WeightedTargetLoadBalancerProvider.java
@@ -0,0 +1,187 @@
+/*
+ * 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.xds;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.JsonUtil;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import javax.annotation.Nullable;
+
+/**
+ * The provider for the weighted_target balancing policy.  This class should not be
+ * directly referenced in code.  The policy should be accessed through {@link
+ * LoadBalancerRegistry#getProvider} with the name "weighted_target_experimental".
+ */
+@Internal
+public final class WeightedTargetLoadBalancerProvider extends LoadBalancerProvider {
+
+  @Nullable
+  private final LoadBalancerRegistry lbRegistry;
+
+  // We can not call this(LoadBalancerRegistry.getDefaultRegistry()), because it will get stuck
+  // recursively loading LoadBalancerRegistry and WeightedTargetLoadBalancerProvider.
+  public WeightedTargetLoadBalancerProvider() {
+    this(null);
+  }
+
+  @VisibleForTesting
+  WeightedTargetLoadBalancerProvider(@Nullable LoadBalancerRegistry lbRegistry) {
+    this.lbRegistry = lbRegistry;
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return XdsLbPolicies.WEIGHTED_TARGET_POLICY_NAME;
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    return new WeightedTargetLoadBalancer(helper);
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
+    try {
+      Map<String, ?> targets = JsonUtil.getObject(rawConfig, "targets");
+      if (targets == null || targets.isEmpty()) {
+        return ConfigOrError.fromError(Status.INTERNAL.withDescription(
+            "No targets provided for weighted_target LB policy:\n " + rawConfig));
+      }
+      Map<String, WeightedPolicySelection> parsedChildConfigs = new LinkedHashMap<>();
+      for (String name : targets.keySet()) {
+        Map<String, ?> rawWeightedTarget = JsonUtil.getObject(targets, name);
+        if (rawWeightedTarget == null || rawWeightedTarget.isEmpty()) {
+          return ConfigOrError.fromError(Status.INTERNAL.withDescription(
+              "No config for target " + name + " in weighted_target LB policy:\n " + rawConfig));
+        }
+        Integer weight = JsonUtil.getNumberAsInteger(rawWeightedTarget, "weight");
+        if (weight == null || weight < 1) {
+          return ConfigOrError.fromError(Status.INTERNAL.withDescription(
+              "Wrong weight for target " + name + " in weighted_target LB policy:\n " + rawConfig));
+        }
+        LoadBalancerRegistry lbRegistry =
+            this.lbRegistry == null ? LoadBalancerRegistry.getDefaultRegistry() : this.lbRegistry;
+        ConfigOrError childConfig = GracefulSwitchLoadBalancer.parseLoadBalancingPolicyConfig(
+            JsonUtil.getListOfObjects(rawWeightedTarget, "childPolicy"), lbRegistry);
+        if (childConfig.getError() != null) {
+          return ConfigOrError.fromError(GrpcUtil.statusWithDetails(
+              Status.Code.INTERNAL,
+              "Could not parse weighted_target's child policy: " + name,
+              childConfig.getError()));
+        }
+        parsedChildConfigs.put(name, new WeightedPolicySelection(weight, childConfig.getConfig()));
+      }
+      return ConfigOrError.fromConfig(new WeightedTargetConfig(parsedChildConfigs));
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError(
+          Status.INTERNAL.withCause(e).withDescription(
+              "Failed to parse weighted_target LB config: " + rawConfig));
+    }
+  }
+
+  static final class WeightedPolicySelection {
+
+    final int weight;
+    final Object childConfig;
+
+    WeightedPolicySelection(int weight, Object childConfig) {
+      this.weight = weight;
+      this.childConfig = childConfig;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      WeightedPolicySelection that = (WeightedPolicySelection) o;
+      return weight == that.weight && Objects.equals(childConfig, that.childConfig);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(weight, childConfig);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("weight", weight)
+          .add("childConfig", childConfig)
+          .toString();
+    }
+  }
+
+  /** The lb config for WeightedTargetLoadBalancer. */
+  static final class WeightedTargetConfig {
+
+    final Map<String, WeightedPolicySelection> targets;
+
+    WeightedTargetConfig(Map<String, WeightedPolicySelection> targets) {
+      this.targets = targets;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      WeightedTargetConfig that = (WeightedTargetConfig) o;
+      return Objects.equals(targets, that.targets);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(targets);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("targets", targets)
+          .toString();
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/WrrLocalityLoadBalancer.java b/xds/src/main/java/io/grpc/xds/WrrLocalityLoadBalancer.java
new file mode 100644
index 00000000000..1a12412f923
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/WrrLocalityLoadBalancer.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright 2022 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static io.grpc.xds.XdsLbPolicies.WEIGHTED_TARGET_POLICY_NAME;
+
+import com.google.common.base.MoreObjects;
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.InternalLogId;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.Status;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedPolicySelection;
+import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedTargetConfig;
+import io.grpc.xds.client.XdsLogger;
+import io.grpc.xds.client.XdsLogger.XdsLogLevel;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * This load balancer acts as a parent for the {@link WeightedTargetLoadBalancer} and configures
+ * it with a child policy in its configuration and locality weights it gets from an attribute in
+ * {@link io.grpc.LoadBalancer.ResolvedAddresses}.
+ */
+final class WrrLocalityLoadBalancer extends LoadBalancer {
+
+  private final XdsLogger logger;
+  private final Helper helper;
+  private final GracefulSwitchLoadBalancer switchLb;
+  private final LoadBalancerRegistry lbRegistry;
+
+  WrrLocalityLoadBalancer(Helper helper) {
+    this(helper, LoadBalancerRegistry.getDefaultRegistry());
+  }
+
+  WrrLocalityLoadBalancer(Helper helper, LoadBalancerRegistry lbRegistry) {
+    this.helper = checkNotNull(helper, "helper");
+    this.lbRegistry = lbRegistry;
+    switchLb = new GracefulSwitchLoadBalancer(helper);
+    logger = XdsLogger.withLogId(
+        InternalLogId.allocate("xds-wrr-locality-lb", helper.getAuthority()));
+    logger.log(XdsLogLevel.INFO, "Created");
+  }
+
+  @Override
+  public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+    logger.log(XdsLogLevel.DEBUG, "Received resolution result: {0}", resolvedAddresses);
+
+    // The configuration with the child policy is combined with the locality weights
+    // to produce the weighted target LB config.
+    WrrLocalityConfig wrrLocalityConfig
+        = (WrrLocalityConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+
+    // A map of locality weights is built up from the locality weight attributes in each address.
+    Map<String, Integer> localityWeights = new HashMap<>();
+    for (EquivalentAddressGroup eag : resolvedAddresses.getAddresses()) {
+      Attributes eagAttrs = eag.getAttributes();
+      String locality = eagAttrs.get(EquivalentAddressGroup.ATTR_LOCALITY_NAME);
+      Integer localityWeight = eagAttrs.get(XdsAttributes.ATTR_LOCALITY_WEIGHT);
+
+      if (locality == null) {
+        Status unavailableStatus = Status.UNAVAILABLE.withDescription(
+            "wrr_locality error: no locality provided");
+        helper.updateBalancingState(TRANSIENT_FAILURE,
+            new FixedResultPicker(PickResult.withError(unavailableStatus)));
+        return unavailableStatus;
+      }
+      if (localityWeight == null) {
+        Status unavailableStatus = Status.UNAVAILABLE.withDescription(
+                "wrr_locality error: no weight provided for locality " + locality);
+        helper.updateBalancingState(TRANSIENT_FAILURE,
+            new FixedResultPicker(PickResult.withError(unavailableStatus)));
+        return unavailableStatus;
+      }
+
+      if (!localityWeights.containsKey(locality)) {
+        localityWeights.put(locality, localityWeight);
+      } else if (!localityWeights.get(locality).equals(localityWeight)) {
+        logger.log(XdsLogLevel.WARNING,
+            "Locality {0} has both weights {1} and {2}, using weight {1}", locality,
+            localityWeights.get(locality), localityWeight);
+      }
+    }
+
+    // Weighted target LB expects a WeightedPolicySelection for each locality as it will create a
+    // child LB for each.
+    Map<String, WeightedPolicySelection> weightedPolicySelections = new HashMap<>();
+    for (String locality : localityWeights.keySet()) {
+      weightedPolicySelections.put(locality,
+          new WeightedPolicySelection(localityWeights.get(locality),
+              wrrLocalityConfig.childConfig));
+    }
+
+    Object switchConfig = GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+        lbRegistry.getProvider(WEIGHTED_TARGET_POLICY_NAME),
+        new WeightedTargetConfig(weightedPolicySelections));
+    return switchLb.acceptResolvedAddresses(
+        resolvedAddresses.toBuilder()
+            .setLoadBalancingPolicyConfig(switchConfig)
+            .build());
+  }
+
+  @Override
+  public void handleNameResolutionError(Status error) {
+    logger.log(XdsLogLevel.WARNING, "Received name resolution error: {0}", error);
+    switchLb.handleNameResolutionError(error);
+  }
+
+  @Override
+  public void shutdown() {
+    switchLb.shutdown();
+  }
+
+  /**
+   * The LB config for {@link WrrLocalityLoadBalancer}.
+   */
+  static final class WrrLocalityConfig {
+
+    final Object childConfig;
+
+    WrrLocalityConfig(Object childConfig) {
+      this.childConfig = childConfig;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      WrrLocalityConfig that = (WrrLocalityConfig) o;
+      return Objects.equals(childConfig, that.childConfig);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hashCode(childConfig);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this).add("childConfig", childConfig).toString();
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/WrrLocalityLoadBalancerProvider.java b/xds/src/main/java/io/grpc/xds/WrrLocalityLoadBalancerProvider.java
new file mode 100644
index 00000000000..3693df9208a
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/WrrLocalityLoadBalancerProvider.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2022 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.xds;
+
+import io.grpc.Internal;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.JsonUtil;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.xds.WrrLocalityLoadBalancer.WrrLocalityConfig;
+import java.util.Map;
+
+/**
+ * The provider for {@link WrrLocalityLoadBalancer}. An instance of this class should be acquired
+ * through {@link LoadBalancerRegistry#getProvider} by using the name
+ * "xds_wrr_locality_experimental".
+ */
+@Internal
+public final class WrrLocalityLoadBalancerProvider extends LoadBalancerProvider {
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    return new WrrLocalityLoadBalancer(helper);
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return XdsLbPolicies.WRR_LOCALITY_POLICY_NAME;
+  }
+
+  @Override
+  public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
+    try {
+      ConfigOrError childConfig = GracefulSwitchLoadBalancer.parseLoadBalancingPolicyConfig(
+          JsonUtil.getListOfObjects(rawConfig, "childPolicy"));
+      if (childConfig.getError() != null) {
+        return ConfigOrError.fromError(GrpcUtil.statusWithDetails(
+            Status.Code.INTERNAL,
+            "Failed to parse child policy in wrr_locality LB policy",
+            childConfig.getError()));
+      }
+      return ConfigOrError.fromConfig(new WrrLocalityConfig(childConfig.getConfig()));
+    } catch (RuntimeException e) {
+      return ConfigOrError.fromError(Status.INTERNAL.withCause(e)
+          .withDescription("Failed to parse wrr_locality LB config: " + rawConfig));
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsAttributes.java b/xds/src/main/java/io/grpc/xds/XdsAttributes.java
new file mode 100644
index 00000000000..5647b25e418
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsAttributes.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright 2019 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.xds;
+
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.Grpc;
+import io.grpc.NameResolver;
+import io.grpc.xds.XdsNameResolverProvider.CallCounterProvider;
+import io.grpc.xds.client.Locality;
+import io.grpc.xds.client.XdsClient;
+
+/**
+ * Attributes used for xDS implementation.
+ */
+final class XdsAttributes {
+  /**
+   * Attribute key for passing around the XdsClient object pool across NameResolver/LoadBalancers.
+   */
+  @NameResolver.ResolutionResultAttr
+  static final Attributes.Key<XdsClient> XDS_CLIENT =
+      Attributes.Key.create("io.grpc.xds.XdsAttributes.xdsClient");
+
+  /**
+   * Attribute key for passing around the latest XdsConfig across NameResolver/LoadBalancers.
+   */
+  @NameResolver.ResolutionResultAttr
+  static final Attributes.Key<XdsConfig> XDS_CONFIG =
+      Attributes.Key.create("io.grpc.xds.XdsAttributes.xdsConfig");
+
+
+  /**
+   * Attribute key for passing around the XdsDependencyManager across NameResolver/LoadBalancers.
+   */
+  @NameResolver.ResolutionResultAttr
+  static final Attributes.Key<XdsConfig.XdsClusterSubscriptionRegistry>
+      XDS_CLUSTER_SUBSCRIPT_REGISTRY =
+      Attributes.Key.create("io.grpc.xds.XdsAttributes.xdsConfig.XdsClusterSubscriptionRegistry");
+
+  /**
+   * Attribute key for obtaining the global provider that provides atomics for aggregating
+   * outstanding RPCs sent to each cluster.
+   */
+  @NameResolver.ResolutionResultAttr
+  static final Attributes.Key<CallCounterProvider> CALL_COUNTER_PROVIDER =
+      Attributes.Key.create("io.grpc.xds.XdsAttributes.callCounterProvider");
+
+  /**
+   * Map from localities to their weights.
+   */
+  @NameResolver.ResolutionResultAttr
+  static final Attributes.Key<Integer> ATTR_LOCALITY_WEIGHT =
+      Attributes.Key.create("io.grpc.xds.XdsAttributes.localityWeight");
+
+  /**
+   * Name of the cluster that provides this EquivalentAddressGroup.
+   */
+  @EquivalentAddressGroup.Attr
+  public static final Attributes.Key<String> ATTR_CLUSTER_NAME =
+      Attributes.Key.create("io.grpc.xds.XdsAttributes.clusterName");
+
+  /**
+   * The locality that this EquivalentAddressGroup is in.
+   */
+  @EquivalentAddressGroup.Attr
+  static final Attributes.Key<Locality> ATTR_LOCALITY =
+      Attributes.Key.create("io.grpc.xds.XdsAttributes.locality");
+
+  /**
+   * Endpoint weight for load balancing purposes.
+   */
+  @EquivalentAddressGroup.Attr
+  static final Attributes.Key<Long> ATTR_SERVER_WEIGHT =
+      Attributes.Key.create("io.grpc.xds.XdsAttributes.serverWeight");
+
+  /**
+   * Filter chain match for network filters.
+   */
+  @Grpc.TransportAttr
+  static final Attributes.Key<FilterChainSelectorManager>
+          ATTR_FILTER_CHAIN_SELECTOR_MANAGER = Attributes.Key.create(
+          "io.grpc.xds.XdsAttributes.filterChainSelectorManager");
+
+  /** Grace time to use when draining. Null for an infinite grace time. */
+  @Grpc.TransportAttr
+  static final Attributes.Key<Long> ATTR_DRAIN_GRACE_NANOS =
+      Attributes.Key.create("io.grpc.xds.XdsAttributes.drainGraceTime");
+
+  private XdsAttributes() {}
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsChannelCredentials.java b/xds/src/main/java/io/grpc/xds/XdsChannelCredentials.java
new file mode 100644
index 00000000000..189ebc0ca19
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsChannelCredentials.java
@@ -0,0 +1,45 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.ExperimentalApi;
+import io.grpc.netty.InternalNettyChannelCredentials;
+import io.grpc.netty.InternalProtocolNegotiator;
+import io.grpc.xds.internal.security.SecurityProtocolNegotiators;
+
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7514")
+public class XdsChannelCredentials {
+  private XdsChannelCredentials() {} // prevent instantiation
+
+  /**
+   * Creates credentials to be configured by xDS, falling back to other credentials if no
+   * TLS configuration is provided by xDS.
+   *
+   * @param fallback Credentials to fall back to.
+   *
+   * @throws IllegalArgumentException if fallback is unable to be used
+   */
+  public static ChannelCredentials create(ChannelCredentials fallback) {
+    InternalProtocolNegotiator.ClientFactory fallbackNegotiator =
+        InternalNettyChannelCredentials.toNegotiator(checkNotNull(fallback, "fallback"));
+    return InternalNettyChannelCredentials.create(
+        SecurityProtocolNegotiators.clientProtocolNegotiatorFactory(fallbackNegotiator));
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsClientMetricReporterImpl.java b/xds/src/main/java/io/grpc/xds/XdsClientMetricReporterImpl.java
new file mode 100644
index 00000000000..5cfba11c065
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsClientMetricReporterImpl.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright 2024 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.xds;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.util.concurrent.ListenableFuture;
+import io.grpc.LongCounterMetricInstrument;
+import io.grpc.LongGaugeMetricInstrument;
+import io.grpc.MetricInstrumentRegistry;
+import io.grpc.MetricRecorder;
+import io.grpc.MetricRecorder.BatchCallback;
+import io.grpc.MetricRecorder.BatchRecorder;
+import io.grpc.MetricRecorder.Registration;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsClient.ResourceMetadata;
+import io.grpc.xds.client.XdsClient.ResourceMetadata.ResourceMetadataStatus;
+import io.grpc.xds.client.XdsClient.ServerConnectionCallback;
+import io.grpc.xds.client.XdsClientMetricReporter;
+import io.grpc.xds.client.XdsResourceType;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * XdsClientMetricReporter implementation.
+ */
+final class XdsClientMetricReporterImpl implements XdsClientMetricReporter {
+
+  private static final Logger logger = Logger.getLogger(
+      XdsClientMetricReporterImpl.class.getName());
+  private static final LongCounterMetricInstrument SERVER_FAILURE_COUNTER;
+  private static final LongCounterMetricInstrument RESOURCE_UPDATES_VALID_COUNTER;
+  private static final LongCounterMetricInstrument RESOURCE_UPDATES_INVALID_COUNTER;
+  private static final LongGaugeMetricInstrument CONNECTED_GAUGE;
+  private static final LongGaugeMetricInstrument RESOURCES_GAUGE;
+
+  private final MetricRecorder metricRecorder;
+  private final String target;
+  @Nullable
+  private Registration gaugeRegistration = null;
+
+  static {
+    MetricInstrumentRegistry metricInstrumentRegistry
+        = MetricInstrumentRegistry.getDefaultRegistry();
+    SERVER_FAILURE_COUNTER = metricInstrumentRegistry.registerLongCounter(
+       "grpc.xds_client.server_failure",
+        "EXPERIMENTAL. A counter of xDS servers going from healthy to unhealthy. A server goes"
+            + " unhealthy when we have a connectivity failure or when the ADS stream fails without"
+            + " seeing a response message, as per gRFC A57.", "{failure}",
+        Arrays.asList("grpc.target", "grpc.xds.server"), Collections.emptyList(), false);
+    RESOURCE_UPDATES_VALID_COUNTER = metricInstrumentRegistry.registerLongCounter(
+        "grpc.xds_client.resource_updates_valid",
+        "EXPERIMENTAL. A counter of resources received that were considered valid. The counter will"
+            + " be incremented even for resources that have not changed.", "{resource}",
+        Arrays.asList("grpc.target", "grpc.xds.server", "grpc.xds.resource_type"),
+        Collections.emptyList(), false);
+    RESOURCE_UPDATES_INVALID_COUNTER = metricInstrumentRegistry.registerLongCounter(
+        "grpc.xds_client.resource_updates_invalid",
+        "EXPERIMENTAL. A counter of resources received that were considered invalid.", "{resource}",
+        Arrays.asList("grpc.target", "grpc.xds.server", "grpc.xds.resource_type"),
+        Collections.emptyList(), false);
+    CONNECTED_GAUGE = metricInstrumentRegistry.registerLongGauge("grpc.xds_client.connected",
+        "EXPERIMENTAL. Whether or not the xDS client currently has a working ADS stream to the xDS"
+            + " server. For a given server, this will be set to 1 when the stream is initially"
+            + " created. It will be set to 0 when we have a connectivity failure or when the ADS"
+            + " stream fails without seeing a response message, as per gRFC A57. Once set to 0, it"
+            + " will be reset to 1 when we receive the first response on an ADS stream.", "{bool}",
+        Arrays.asList("grpc.target", "grpc.xds.server"), Collections.emptyList(), false);
+    RESOURCES_GAUGE = metricInstrumentRegistry.registerLongGauge("grpc.xds_client.resources",
+        "EXPERIMENTAL.  Number of xDS resources.", "{resource}",
+        Arrays.asList("grpc.target", "grpc.xds.authority", "grpc.xds.cache_state",
+            "grpc.xds.resource_type"), Collections.emptyList(), false);
+  }
+
+  XdsClientMetricReporterImpl(MetricRecorder metricRecorder, String target) {
+    this.metricRecorder = metricRecorder;
+    this.target = target;
+  }
+
+  @Override
+  public void reportResourceUpdates(long validResourceCount, long invalidResourceCount,
+      String xdsServer, String resourceType) {
+    metricRecorder.addLongCounter(RESOURCE_UPDATES_VALID_COUNTER, validResourceCount,
+        Arrays.asList(target, xdsServer, resourceType), Collections.emptyList());
+    metricRecorder.addLongCounter(RESOURCE_UPDATES_INVALID_COUNTER, invalidResourceCount,
+        Arrays.asList(target, xdsServer, resourceType), Collections.emptyList());
+  }
+
+  @Override
+  public void reportServerFailure(long serverFailure, String xdsServer) {
+    metricRecorder.addLongCounter(SERVER_FAILURE_COUNTER, serverFailure,
+        Arrays.asList(target, xdsServer), Collections.emptyList());
+  }
+
+  void setXdsClient(XdsClient xdsClient) {
+    assert gaugeRegistration == null;
+    // register gauge here
+    this.gaugeRegistration = metricRecorder.registerBatchCallback(new BatchCallback() {
+      @Override
+      public void accept(BatchRecorder recorder) {
+        reportCallbackMetrics(recorder, xdsClient);
+      }
+    }, CONNECTED_GAUGE, RESOURCES_GAUGE);
+  }
+
+  void close() {
+    if (gaugeRegistration != null) {
+      gaugeRegistration.close();
+      gaugeRegistration = null;
+    }
+  }
+
+  void reportCallbackMetrics(BatchRecorder recorder, XdsClient xdsClient) {
+    MetricReporterCallback callback = new MetricReporterCallback(recorder, target);
+    try {
+      Future<Void> reportServerConnectionsCompleted = xdsClient.reportServerConnections(callback);
+
+      ListenableFuture<Map<XdsResourceType<?>, Map<String, ResourceMetadata>>>
+          getResourceMetadataCompleted = xdsClient.getSubscribedResourcesMetadataSnapshot();
+
+      Map<XdsResourceType<?>, Map<String, ResourceMetadata>> metadataByType =
+          getResourceMetadataCompleted.get(10, TimeUnit.SECONDS);
+
+      computeAndReportResourceCounts(metadataByType, callback);
+
+      // Normally this shouldn't take long, but adding a timeout to avoid indefinite blocking
+      Void unused = reportServerConnectionsCompleted.get(5, TimeUnit.SECONDS);
+    } catch (ExecutionException | TimeoutException | InterruptedException e) {
+      if (e instanceof InterruptedException) {
+        Thread.currentThread().interrupt(); // re-set the current thread's interruption state
+      }
+      logger.log(Level.WARNING, "Failed to report gauge metrics", e);
+    }
+  }
+
+  private void computeAndReportResourceCounts(
+      Map<XdsResourceType<?>, Map<String, ResourceMetadata>> metadataByType,
+      MetricReporterCallback callback) {
+    for (Map.Entry<XdsResourceType<?>, Map<String, ResourceMetadata>> metadataByTypeEntry :
+        metadataByType.entrySet()) {
+      XdsResourceType<?> type = metadataByTypeEntry.getKey();
+      Map<String, ResourceMetadata> resources = metadataByTypeEntry.getValue();
+
+      Map<String, Map<String, Long>> resourceCountsByAuthorityAndState = new HashMap<>();
+      for (Map.Entry<String, ResourceMetadata> resourceEntry : resources.entrySet()) {
+        String resourceName = resourceEntry.getKey();
+        ResourceMetadata metadata = resourceEntry.getValue();
+        String authority = XdsClient.getAuthorityFromResourceName(resourceName);
+        String cacheState = cacheStateFromResourceStatus(metadata.getStatus(), metadata.isCached());
+        resourceCountsByAuthorityAndState
+            .computeIfAbsent(authority, k -> new HashMap<>())
+            .merge(cacheState, 1L, Long::sum);
+      }
+
+      // Report metrics
+      for (Map.Entry<String, Map<String, Long>> authorityEntry
+            : resourceCountsByAuthorityAndState.entrySet()) {
+        String authority = authorityEntry.getKey();
+        Map<String, Long> stateCounts = authorityEntry.getValue();
+
+        for (Map.Entry<String, Long> stateEntry : stateCounts.entrySet()) {
+          String cacheState = stateEntry.getKey();
+          Long count = stateEntry.getValue();
+
+          callback.reportResourceCountGauge(count, authority, cacheState, type.typeUrl());
+        }
+      }
+    }
+  }
+
+  private static String cacheStateFromResourceStatus(ResourceMetadataStatus metadataStatus,
+      boolean isResourceCached) {
+    switch (metadataStatus) {
+      case REQUESTED:
+        return "requested";
+      case DOES_NOT_EXIST:
+        return "does_not_exist";
+      case ACKED:
+        return "acked";
+      case NACKED:
+        return isResourceCached ? "nacked_but_cached" : "nacked";
+      default:
+        return "unknown";
+    }
+  }
+
+  @VisibleForTesting
+  static final class MetricReporterCallback implements ServerConnectionCallback {
+    private final BatchRecorder recorder;
+    private final String target;
+
+    MetricReporterCallback(BatchRecorder recorder, String target) {
+      this.recorder = recorder;
+      this.target = target;
+    }
+
+    void reportResourceCountGauge(long resourceCount, String authority, String cacheState,
+        String resourceType) {
+      // authority = #old, for non-xdstp resource names
+      recorder.recordLongGauge(RESOURCES_GAUGE, resourceCount,
+          Arrays.asList(target, authority == null ? "#old" : authority, cacheState, resourceType),
+          Collections.emptyList());
+    }
+
+    @Override
+    public void reportServerConnectionGauge(boolean isConnected, String xdsServer) {
+      recorder.recordLongGauge(CONNECTED_GAUGE, isConnected ? 1 : 0,
+          Arrays.asList(target, xdsServer), Collections.emptyList());
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsClientPoolFactory.java b/xds/src/main/java/io/grpc/xds/XdsClientPoolFactory.java
new file mode 100644
index 00000000000..6df8d566a7a
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsClientPoolFactory.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2024 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.xds;
+
+import io.grpc.MetricRecorder;
+import io.grpc.internal.ObjectPool;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.XdsClient;
+import java.util.List;
+import javax.annotation.Nullable;
+
+interface XdsClientPoolFactory {
+  @Nullable
+  ObjectPool<XdsClient> get(String target);
+
+  ObjectPool<XdsClient> getOrCreate(
+      String target, BootstrapInfo bootstrapInfo, MetricRecorder metricRecorder);
+
+  List<String> getTargets();
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsClusterResource.java b/xds/src/main/java/io/grpc/xds/XdsClusterResource.java
new file mode 100644
index 00000000000..d9848d97017
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsClusterResource.java
@@ -0,0 +1,789 @@
+/*
+ * Copyright 2022 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.xds.client.Bootstrapper.ServerInfo;
+import static io.grpc.xds.client.LoadStatsManager2.isEnabledOrcaLrsPropagation;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Duration;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Message;
+import com.google.protobuf.Struct;
+import com.google.protobuf.util.Durations;
+import io.envoyproxy.envoy.config.cluster.v3.CircuitBreakers.Thresholds;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.core.v3.RoutingPriority;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress;
+import io.envoyproxy.envoy.config.core.v3.TransportSocket;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;
+import io.envoyproxy.envoy.extensions.transport_sockets.http_11_proxy.v3.Http11ProxyUpstreamTransport;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.ServiceConfigUtil;
+import io.grpc.internal.ServiceConfigUtil.LbConfig;
+import io.grpc.xds.EnvoyServerProtoData.OutlierDetection;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.XdsClusterResource.CdsUpdate;
+import io.grpc.xds.client.BackendMetricPropagation;
+import io.grpc.xds.client.XdsClient.ResourceUpdate;
+import io.grpc.xds.client.XdsResourceType;
+import io.grpc.xds.internal.security.CommonTlsContextUtil;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import javax.annotation.Nullable;
+
+class XdsClusterResource extends XdsResourceType<CdsUpdate> {
+  @VisibleForTesting
+  static boolean enableLeastRequest =
+      !Strings.isNullOrEmpty(System.getenv("GRPC_EXPERIMENTAL_ENABLE_LEAST_REQUEST"))
+          ? Boolean.parseBoolean(System.getenv("GRPC_EXPERIMENTAL_ENABLE_LEAST_REQUEST"))
+          : Boolean.parseBoolean(
+              System.getProperty("io.grpc.xds.experimentalEnableLeastRequest", "true"));
+  @VisibleForTesting
+  public static boolean enableSystemRootCerts =
+      GrpcUtil.getFlag("GRPC_EXPERIMENTAL_XDS_SYSTEM_ROOT_CERTS", true);
+  static boolean isEnabledXdsHttpConnect =
+      GrpcUtil.getFlag("GRPC_EXPERIMENTAL_XDS_HTTP_CONNECT", false);
+
+  @VisibleForTesting
+  static final String AGGREGATE_CLUSTER_TYPE_NAME = "envoy.clusters.aggregate";
+  static final String ADS_TYPE_URL_CDS =
+      "type.googleapis.com/envoy.config.cluster.v3.Cluster";
+  private static final String TYPE_URL_CLUSTER_CONFIG =
+      "type.googleapis.com/envoy.extensions.clusters.aggregate.v3.ClusterConfig";
+  private static final String TYPE_URL_UPSTREAM_TLS_CONTEXT =
+      "type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext";
+  private static final String TYPE_URL_UPSTREAM_TLS_CONTEXT_V2 =
+      "type.googleapis.com/envoy.api.v2.auth.UpstreamTlsContext";
+  static final String TRANSPORT_SOCKET_NAME_HTTP11_PROXY =
+      "type.googleapis.com/envoy.extensions.transport_sockets.http_11_proxy.v3"
+          + ".Http11ProxyUpstreamTransport";
+  private final LoadBalancerRegistry loadBalancerRegistry
+      = LoadBalancerRegistry.getDefaultRegistry();
+
+  private static final XdsClusterResource instance = new XdsClusterResource();
+
+  public static XdsClusterResource getInstance() {
+    return instance;
+  }
+
+  @Override
+  @Nullable
+  protected String extractResourceName(Message unpackedResource) {
+    if (!(unpackedResource instanceof Cluster)) {
+      return null;
+    }
+    return ((Cluster) unpackedResource).getName();
+  }
+
+  @Override
+  public String typeName() {
+    return "CDS";
+  }
+
+  @Override
+  public String typeUrl() {
+    return ADS_TYPE_URL_CDS;
+  }
+
+  @Override
+  public boolean shouldRetrieveResourceKeysForArgs() {
+    return true;
+  }
+
+  @Override
+  protected boolean isFullStateOfTheWorld() {
+    return true;
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  protected Class<Cluster> unpackedClassName() {
+    return Cluster.class;
+  }
+
+  @Override
+  protected CdsUpdate doParse(Args args, Message unpackedMessage) throws ResourceInvalidException {
+    if (!(unpackedMessage instanceof Cluster)) {
+      throw new ResourceInvalidException("Invalid message type: " + unpackedMessage.getClass());
+    }
+    Set<String> certProviderInstances = null;
+    if (args.getBootstrapInfo() != null && args.getBootstrapInfo().certProviders() != null) {
+      certProviderInstances = args.getBootstrapInfo().certProviders().keySet();
+    }
+    return processCluster((Cluster) unpackedMessage, certProviderInstances,
+        args.getServerInfo(), loadBalancerRegistry);
+  }
+
+  @VisibleForTesting
+  static CdsUpdate processCluster(Cluster cluster,
+                                  Set<String> certProviderInstances,
+                                  ServerInfo serverInfo,
+                                  LoadBalancerRegistry loadBalancerRegistry)
+      throws ResourceInvalidException {
+    StructOrError<CdsUpdate.Builder> structOrError;
+    switch (cluster.getClusterDiscoveryTypeCase()) {
+      case TYPE:
+        structOrError = parseNonAggregateCluster(cluster,
+            certProviderInstances, serverInfo);
+        break;
+      case CLUSTER_TYPE:
+        structOrError = parseAggregateCluster(cluster);
+        break;
+      case CLUSTERDISCOVERYTYPE_NOT_SET:
+      default:
+        throw new ResourceInvalidException(
+            "Cluster " + cluster.getName() + ": unspecified cluster discovery type");
+    }
+    if (structOrError.getErrorDetail() != null) {
+      throw new ResourceInvalidException(structOrError.getErrorDetail());
+    }
+    CdsUpdate.Builder updateBuilder = structOrError.getStruct();
+
+    ImmutableMap<String, ?> lbPolicyConfig = LoadBalancerConfigFactory.newConfig(cluster,
+        enableLeastRequest);
+
+    // Validate the LB config by trying to parse it with the corresponding LB provider.
+    LbConfig lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(lbPolicyConfig);
+    NameResolver.ConfigOrError configOrError = loadBalancerRegistry.getProvider(
+        lbConfig.getPolicyName()).parseLoadBalancingPolicyConfig(
+        lbConfig.getRawConfigValue());
+    if (configOrError.getError() != null) {
+      throw new ResourceInvalidException(
+          "Failed to parse lb config for cluster '" + cluster.getName() + "': "
+          + configOrError.getError());
+    }
+
+    updateBuilder.lbPolicyConfig(lbPolicyConfig);
+    updateBuilder.filterMetadata(
+        ImmutableMap.copyOf(cluster.getMetadata().getFilterMetadataMap()));
+
+    try {
+      MetadataRegistry registry = MetadataRegistry.getInstance();
+      ImmutableMap<String, Object> parsedFilterMetadata =
+          registry.parseMetadata(cluster.getMetadata());
+      updateBuilder.parsedMetadata(parsedFilterMetadata);
+    } catch (ResourceInvalidException e) {
+      throw new ResourceInvalidException(
+          "Failed to parse xDS filter metadata for cluster '" + cluster.getName() + "': "
+              + e.getMessage(), e);
+    }
+
+    return updateBuilder.build();
+  }
+
+  private static StructOrError<CdsUpdate.Builder> parseAggregateCluster(Cluster cluster) {
+    String clusterName = cluster.getName();
+    Cluster.CustomClusterType customType = cluster.getClusterType();
+    String typeName = customType.getName();
+    if (!typeName.equals(AGGREGATE_CLUSTER_TYPE_NAME)) {
+      return StructOrError.fromError(
+          "Cluster " + clusterName + ": unsupported custom cluster type: " + typeName);
+    }
+    io.envoyproxy.envoy.extensions.clusters.aggregate.v3.ClusterConfig clusterConfig;
+    try {
+      clusterConfig = unpackCompatibleType(customType.getTypedConfig(),
+          io.envoyproxy.envoy.extensions.clusters.aggregate.v3.ClusterConfig.class,
+          TYPE_URL_CLUSTER_CONFIG, null);
+    } catch (InvalidProtocolBufferException e) {
+      return StructOrError.fromError("Cluster " + clusterName + ": malformed ClusterConfig: " + e);
+    }
+    if (clusterConfig.getClustersList().isEmpty()) {
+      return StructOrError.fromError("Cluster " + clusterName
+          + ": aggregate ClusterConfig.clusters must not be empty");
+    }
+    return StructOrError.fromStruct(CdsUpdate.forAggregate(
+        clusterName, clusterConfig.getClustersList()));
+  }
+
+  private static StructOrError<CdsUpdate.Builder> parseNonAggregateCluster(
+      Cluster cluster, Set<String> certProviderInstances, ServerInfo serverInfo) {
+    String clusterName = cluster.getName();
+    ServerInfo lrsServerInfo = null;
+    Long maxConcurrentRequests = null;
+    UpstreamTlsContext upstreamTlsContext = null;
+    OutlierDetection outlierDetection = null;
+    boolean isHttp11ProxyAvailable = false;
+    BackendMetricPropagation backendMetricPropagation = null;
+
+    if (isEnabledOrcaLrsPropagation) {
+      backendMetricPropagation = BackendMetricPropagation.fromMetricSpecs(
+          cluster.getLrsReportEndpointMetricsList());
+    }
+    if (cluster.hasLrsServer()) {
+      if (!cluster.getLrsServer().hasSelf()) {
+        return StructOrError.fromError(
+            "Cluster " + clusterName + ": only support LRS for the same management server");
+      }
+      lrsServerInfo = serverInfo;
+    }
+    if (cluster.hasCircuitBreakers()) {
+      List<Thresholds> thresholds = cluster.getCircuitBreakers().getThresholdsList();
+      for (Thresholds threshold : thresholds) {
+        if (threshold.getPriority() != RoutingPriority.DEFAULT) {
+          continue;
+        }
+        if (threshold.hasMaxRequests()) {
+          maxConcurrentRequests = Integer.toUnsignedLong(threshold.getMaxRequests().getValue());
+        }
+      }
+    }
+    if (cluster.getTransportSocketMatchesCount() > 0) {
+      return StructOrError.fromError("Cluster " + clusterName
+          + ": transport-socket-matches not supported.");
+    }
+    boolean hasTransportSocket = cluster.hasTransportSocket();
+    TransportSocket transportSocket = cluster.getTransportSocket();
+
+    if (hasTransportSocket && !TRANSPORT_SOCKET_NAME_TLS.equals(transportSocket.getName())
+        && !(isEnabledXdsHttpConnect
+        && TRANSPORT_SOCKET_NAME_HTTP11_PROXY.equals(transportSocket.getName()))) {
+      return StructOrError.fromError(
+          "transport-socket with name " + transportSocket.getName() + " not supported.");
+    }
+
+    if (hasTransportSocket && isEnabledXdsHttpConnect
+        && TRANSPORT_SOCKET_NAME_HTTP11_PROXY.equals(transportSocket.getName())) {
+      isHttp11ProxyAvailable = true;
+      try {
+        Http11ProxyUpstreamTransport wrappedTransportSocket = transportSocket
+            .getTypedConfig().unpack(io.envoyproxy.envoy.extensions.transport_sockets
+                .http_11_proxy.v3.Http11ProxyUpstreamTransport.class);
+        hasTransportSocket = wrappedTransportSocket.hasTransportSocket();
+        transportSocket = wrappedTransportSocket.getTransportSocket();
+      } catch (InvalidProtocolBufferException e) {
+        return StructOrError.fromError(
+            "Cluster " + clusterName + ": malformed Http11ProxyUpstreamTransport: " + e);
+      } catch (ClassCastException e) {
+        return StructOrError.fromError(
+            "Cluster " + clusterName
+                + ": invalid transport_socket type in Http11ProxyUpstreamTransport");
+      }
+    }
+
+    if (hasTransportSocket && TRANSPORT_SOCKET_NAME_TLS.equals(transportSocket.getName())) {
+      try {
+        upstreamTlsContext = UpstreamTlsContext.fromEnvoyProtoUpstreamTlsContext(
+            validateUpstreamTlsContext(
+                unpackCompatibleType(transportSocket.getTypedConfig(),
+                    io.envoyproxy.envoy.extensions
+                        .transport_sockets.tls.v3.UpstreamTlsContext.class,
+                    TYPE_URL_UPSTREAM_TLS_CONTEXT, TYPE_URL_UPSTREAM_TLS_CONTEXT_V2),
+                certProviderInstances));
+      } catch (InvalidProtocolBufferException | ResourceInvalidException e) {
+        return StructOrError.fromError(
+            "Cluster " + clusterName + ": malformed UpstreamTlsContext: " + e);
+      }
+    }
+
+    if (cluster.hasOutlierDetection()) {
+      try {
+        outlierDetection = OutlierDetection.fromEnvoyOutlierDetection(
+            validateOutlierDetection(cluster.getOutlierDetection()));
+      } catch (ResourceInvalidException e) {
+        return StructOrError.fromError(
+            "Cluster " + clusterName + ": malformed outlier_detection: " + e);
+      }
+    }
+
+    Cluster.DiscoveryType type = cluster.getType();
+    if (type == Cluster.DiscoveryType.EDS) {
+      String edsServiceName = null;
+      io.envoyproxy.envoy.config.cluster.v3.Cluster.EdsClusterConfig edsClusterConfig =
+          cluster.getEdsClusterConfig();
+      if (!edsClusterConfig.getEdsConfig().hasAds()
+          && ! edsClusterConfig.getEdsConfig().hasSelf()) {
+        return StructOrError.fromError(
+            "Cluster " + clusterName + ": field eds_cluster_config must be set to indicate to use"
+                + " EDS over ADS or self ConfigSource");
+      }
+      // If the service_name field is set, that value will be used for the EDS request.
+      if (!edsClusterConfig.getServiceName().isEmpty()) {
+        edsServiceName = edsClusterConfig.getServiceName();
+      }
+      // edsServiceName is required if the CDS resource has an xdstp name.
+      if ((edsServiceName == null) && clusterName.toLowerCase(Locale.ROOT).startsWith("xdstp:")) {
+        return StructOrError.fromError(
+            "EDS service_name must be set when Cluster resource has an xdstp name");
+      }
+
+      return StructOrError.fromStruct(CdsUpdate.forEds(
+          clusterName, edsServiceName, lrsServerInfo, maxConcurrentRequests, upstreamTlsContext,
+          outlierDetection, isHttp11ProxyAvailable, backendMetricPropagation));
+    } else if (type.equals(Cluster.DiscoveryType.LOGICAL_DNS)) {
+      if (!cluster.hasLoadAssignment()) {
+        return StructOrError.fromError(
+            "Cluster " + clusterName + ": LOGICAL_DNS clusters must have a single host");
+      }
+      ClusterLoadAssignment assignment = cluster.getLoadAssignment();
+      if (assignment.getEndpointsCount() != 1
+          || assignment.getEndpoints(0).getLbEndpointsCount() != 1) {
+        return StructOrError.fromError(
+            "Cluster " + clusterName + ": LOGICAL_DNS clusters must have a single "
+                + "locality_lb_endpoint and a single lb_endpoint");
+      }
+      io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint lbEndpoint =
+          assignment.getEndpoints(0).getLbEndpoints(0);
+      if (!lbEndpoint.hasEndpoint() || !lbEndpoint.getEndpoint().hasAddress()
+          || !lbEndpoint.getEndpoint().getAddress().hasSocketAddress()) {
+        return StructOrError.fromError(
+            "Cluster " + clusterName
+                + ": LOGICAL_DNS clusters must have an endpoint with address and socket_address");
+      }
+      SocketAddress socketAddress = lbEndpoint.getEndpoint().getAddress().getSocketAddress();
+      if (!socketAddress.getResolverName().isEmpty()) {
+        return StructOrError.fromError(
+            "Cluster " + clusterName
+                + ": LOGICAL DNS clusters must NOT have a custom resolver name set");
+      }
+      if (socketAddress.getPortSpecifierCase() != SocketAddress.PortSpecifierCase.PORT_VALUE) {
+        return StructOrError.fromError(
+            "Cluster " + clusterName
+                + ": LOGICAL DNS clusters socket_address must have port_value");
+      }
+      String dnsHostName = String.format(
+          Locale.US, "%s:%d", socketAddress.getAddress(), socketAddress.getPortValue());
+      return StructOrError.fromStruct(CdsUpdate.forLogicalDns(
+          clusterName, dnsHostName, lrsServerInfo, maxConcurrentRequests,
+          upstreamTlsContext, isHttp11ProxyAvailable, backendMetricPropagation));
+    }
+    return StructOrError.fromError(
+        "Cluster " + clusterName + ": unsupported built-in discovery type: " + type);
+  }
+
+  static io.envoyproxy.envoy.config.cluster.v3.OutlierDetection validateOutlierDetection(
+      io.envoyproxy.envoy.config.cluster.v3.OutlierDetection outlierDetection)
+      throws ResourceInvalidException {
+    if (outlierDetection.hasInterval()) {
+      if (!Durations.isValid(outlierDetection.getInterval())) {
+        throw new ResourceInvalidException("outlier_detection interval is not a valid Duration");
+      }
+      if (hasNegativeValues(outlierDetection.getInterval())) {
+        throw new ResourceInvalidException("outlier_detection interval has a negative value");
+      }
+    }
+    if (outlierDetection.hasBaseEjectionTime()) {
+      if (!Durations.isValid(outlierDetection.getBaseEjectionTime())) {
+        throw new ResourceInvalidException(
+            "outlier_detection base_ejection_time is not a valid Duration");
+      }
+      if (hasNegativeValues(outlierDetection.getBaseEjectionTime())) {
+        throw new ResourceInvalidException(
+            "outlier_detection base_ejection_time has a negative value");
+      }
+    }
+    if (outlierDetection.hasMaxEjectionTime()) {
+      if (!Durations.isValid(outlierDetection.getMaxEjectionTime())) {
+        throw new ResourceInvalidException(
+            "outlier_detection max_ejection_time is not a valid Duration");
+      }
+      if (hasNegativeValues(outlierDetection.getMaxEjectionTime())) {
+        throw new ResourceInvalidException(
+            "outlier_detection max_ejection_time has a negative value");
+      }
+    }
+    if (outlierDetection.hasMaxEjectionPercent()
+        && outlierDetection.getMaxEjectionPercent().getValue() > 100) {
+      throw new ResourceInvalidException(
+          "outlier_detection max_ejection_percent is > 100");
+    }
+    if (outlierDetection.hasEnforcingSuccessRate()
+        && outlierDetection.getEnforcingSuccessRate().getValue() > 100) {
+      throw new ResourceInvalidException(
+          "outlier_detection enforcing_success_rate is > 100");
+    }
+    if (outlierDetection.hasFailurePercentageThreshold()
+        && outlierDetection.getFailurePercentageThreshold().getValue() > 100) {
+      throw new ResourceInvalidException(
+          "outlier_detection failure_percentage_threshold is > 100");
+    }
+    if (outlierDetection.hasEnforcingFailurePercentage()
+        && outlierDetection.getEnforcingFailurePercentage().getValue() > 100) {
+      throw new ResourceInvalidException(
+          "outlier_detection enforcing_failure_percentage is > 100");
+    }
+
+    return outlierDetection;
+  }
+
+  static boolean hasNegativeValues(Duration duration) {
+    return duration.getSeconds() < 0 || duration.getNanos() < 0;
+  }
+
+  @VisibleForTesting
+  static io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext
+      validateUpstreamTlsContext(
+      io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext upstreamTlsContext,
+      Set<String> certProviderInstances)
+      throws ResourceInvalidException {
+    if (upstreamTlsContext.hasCommonTlsContext()) {
+      validateCommonTlsContext(upstreamTlsContext.getCommonTlsContext(), certProviderInstances,
+          false);
+    } else {
+      throw new ResourceInvalidException("common-tls-context is required in upstream-tls-context");
+    }
+    return upstreamTlsContext;
+  }
+
+  @VisibleForTesting
+  static void validateCommonTlsContext(
+      CommonTlsContext commonTlsContext, Set<String> certProviderInstances, boolean server)
+      throws ResourceInvalidException {
+    if (commonTlsContext.hasCustomHandshaker()) {
+      throw new ResourceInvalidException(
+          "common-tls-context with custom_handshaker is not supported");
+    }
+    if (commonTlsContext.hasTlsParams()) {
+      throw new ResourceInvalidException("common-tls-context with tls_params is not supported");
+    }
+    if (commonTlsContext.hasValidationContextSdsSecretConfig()) {
+      throw new ResourceInvalidException(
+          "common-tls-context with validation_context_sds_secret_config is not supported");
+    }
+    String certInstanceName = getIdentityCertInstanceName(commonTlsContext);
+    if (certInstanceName == null) {
+      if (server) {
+        throw new ResourceInvalidException(
+            "tls_certificate_provider_instance is required in downstream-tls-context");
+      }
+      if (commonTlsContext.getTlsCertificatesCount() > 0) {
+        throw new ResourceInvalidException(
+            "tls_certificate_provider_instance is unset");
+      }
+      if (commonTlsContext.getTlsCertificateSdsSecretConfigsCount() > 0) {
+        throw new ResourceInvalidException(
+            "tls_certificate_provider_instance is unset");
+      }
+    } else if (certProviderInstances == null || !certProviderInstances.contains(certInstanceName)) {
+      throw new ResourceInvalidException(
+          "CertificateProvider instance name '" + certInstanceName
+              + "' not defined in the bootstrap file.");
+    }
+    String rootCaInstanceName = getRootCertInstanceName(commonTlsContext);
+    if (rootCaInstanceName == null) {
+      if (!server && (!enableSystemRootCerts
+          || !CommonTlsContextUtil.isUsingSystemRootCerts(commonTlsContext))) {
+        throw new ResourceInvalidException(
+            "ca_certificate_provider_instance or system_root_certs is required in "
+                + "upstream-tls-context");
+      }
+    } else {
+      if (certProviderInstances == null || !certProviderInstances.contains(rootCaInstanceName)) {
+        throw new ResourceInvalidException(
+            "ca_certificate_provider_instance name '" + rootCaInstanceName
+                + "' not defined in the bootstrap file.");
+      }
+      CertificateValidationContext certificateValidationContext = null;
+      if (commonTlsContext.hasValidationContext()) {
+        certificateValidationContext = commonTlsContext.getValidationContext();
+      } else if (commonTlsContext.hasCombinedValidationContext() && commonTlsContext
+          .getCombinedValidationContext().hasDefaultValidationContext()) {
+        certificateValidationContext = commonTlsContext.getCombinedValidationContext()
+            .getDefaultValidationContext();
+      }
+      if (certificateValidationContext != null) {
+        @SuppressWarnings("deprecation") // gRFC A29 predates match_typed_subject_alt_names
+        int matchSubjectAltNamesCount = certificateValidationContext.getMatchSubjectAltNamesCount();
+        if (matchSubjectAltNamesCount > 0 && server) {
+          throw new ResourceInvalidException(
+              "match_subject_alt_names only allowed in upstream_tls_context");
+        }
+        if (certificateValidationContext.getVerifyCertificateSpkiCount() > 0) {
+          throw new ResourceInvalidException(
+              "verify_certificate_spki in default_validation_context is not supported");
+        }
+        if (certificateValidationContext.getVerifyCertificateHashCount() > 0) {
+          throw new ResourceInvalidException(
+              "verify_certificate_hash in default_validation_context is not supported");
+        }
+        if (certificateValidationContext.hasRequireSignedCertificateTimestamp()) {
+          throw new ResourceInvalidException(
+              "require_signed_certificate_timestamp in default_validation_context is not "
+                  + "supported");
+        }
+        if (certificateValidationContext.hasCrl()) {
+          throw new ResourceInvalidException("crl in default_validation_context is not supported");
+        }
+        if (certificateValidationContext.hasCustomValidatorConfig()) {
+          throw new ResourceInvalidException(
+              "custom_validator_config in default_validation_context is not supported");
+        }
+      }
+    }
+  }
+
+  private static String getIdentityCertInstanceName(CommonTlsContext commonTlsContext) {
+    if (commonTlsContext.hasTlsCertificateProviderInstance()) {
+      return commonTlsContext.getTlsCertificateProviderInstance().getInstanceName();
+    }
+    // Fall back to deprecated field (field 11) for backward compatibility with Istio
+    @SuppressWarnings("deprecation")
+    String instanceName = commonTlsContext.hasTlsCertificateCertificateProviderInstance()
+        ? commonTlsContext.getTlsCertificateCertificateProviderInstance().getInstanceName()
+        : null;
+    return instanceName;
+  }
+
+  private static String getRootCertInstanceName(CommonTlsContext commonTlsContext) {
+    if (commonTlsContext.hasValidationContext()) {
+      if (commonTlsContext.getValidationContext().hasCaCertificateProviderInstance()) {
+        return commonTlsContext.getValidationContext().getCaCertificateProviderInstance()
+            .getInstanceName();
+      }
+    } else if (commonTlsContext.hasCombinedValidationContext()) {
+      CommonTlsContext.CombinedCertificateValidationContext combinedCertificateValidationContext
+          = commonTlsContext.getCombinedValidationContext();
+      if (combinedCertificateValidationContext.hasDefaultValidationContext()
+          && combinedCertificateValidationContext.getDefaultValidationContext()
+          .hasCaCertificateProviderInstance()) {
+        return combinedCertificateValidationContext.getDefaultValidationContext()
+            .getCaCertificateProviderInstance().getInstanceName();
+      }
+      // Fall back to deprecated field (field 4) in CombinedValidationContext
+      @SuppressWarnings("deprecation")
+      String instanceName = combinedCertificateValidationContext
+          .hasValidationContextCertificateProviderInstance()
+          ? combinedCertificateValidationContext.getValidationContextCertificateProviderInstance()
+              .getInstanceName()
+          : null;
+      if (instanceName != null) {
+        return instanceName;
+      }
+    }
+    return null;
+  }
+
+  /** xDS resource update for cluster-level configuration. */
+  @AutoValue
+  abstract static class CdsUpdate implements ResourceUpdate {
+    abstract String clusterName();
+
+    abstract ClusterType clusterType();
+
+    abstract ImmutableMap<String, ?> lbPolicyConfig();
+
+    // Only valid if lbPolicy is "ring_hash_experimental".
+    abstract long minRingSize();
+
+    // Only valid if lbPolicy is "ring_hash_experimental".
+    abstract long maxRingSize();
+
+    // Only valid if lbPolicy is "least_request_experimental".
+    abstract int choiceCount();
+
+    // Alternative resource name to be used in EDS requests.
+    /// Only valid for EDS cluster.
+    @Nullable
+    abstract String edsServiceName();
+
+    // Corresponding DNS name to be used if upstream endpoints of the cluster is resolvable
+    // via DNS.
+    // Only valid for LOGICAL_DNS cluster.
+    @Nullable
+    abstract String dnsHostName();
+
+    // Load report server info for reporting loads via LRS.
+    // Only valid for EDS or LOGICAL_DNS cluster.
+    @Nullable
+    abstract ServerInfo lrsServerInfo();
+
+    // Max number of concurrent requests can be sent to this cluster.
+    // Only valid for EDS or LOGICAL_DNS cluster.
+    @Nullable
+    abstract Long maxConcurrentRequests();
+
+    // TLS context used to connect to connect to this cluster.
+    // Only valid for EDS or LOGICAL_DNS cluster.
+    @Nullable
+    abstract UpstreamTlsContext upstreamTlsContext();
+
+    abstract boolean isHttp11ProxyAvailable();
+
+    // List of underlying clusters making of this aggregate cluster.
+    // Only valid for AGGREGATE cluster.
+    @Nullable
+    abstract ImmutableList<String> prioritizedClusterNames();
+
+    // Outlier detection configuration.
+    @Nullable
+    abstract OutlierDetection outlierDetection();
+
+    abstract ImmutableMap<String, Struct> filterMetadata();
+
+    abstract ImmutableMap<String, Object> parsedMetadata();
+
+    @Nullable
+    abstract BackendMetricPropagation backendMetricPropagation();
+
+    private static Builder newBuilder(String clusterName) {
+      return new AutoValue_XdsClusterResource_CdsUpdate.Builder()
+          .clusterName(clusterName)
+          .minRingSize(0)
+          .maxRingSize(0)
+          .choiceCount(0)
+          .filterMetadata(ImmutableMap.of())
+          .parsedMetadata(ImmutableMap.of())
+          .isHttp11ProxyAvailable(false)
+          .backendMetricPropagation(null);
+    }
+
+    static Builder forAggregate(String clusterName, List<String> prioritizedClusterNames) {
+      checkNotNull(prioritizedClusterNames, "prioritizedClusterNames");
+      return newBuilder(clusterName)
+          .clusterType(ClusterType.AGGREGATE)
+          .prioritizedClusterNames(ImmutableList.copyOf(prioritizedClusterNames));
+    }
+
+    static Builder forEds(String clusterName, @Nullable String edsServiceName,
+                          @Nullable ServerInfo lrsServerInfo, @Nullable Long maxConcurrentRequests,
+                          @Nullable UpstreamTlsContext upstreamTlsContext,
+                          @Nullable OutlierDetection outlierDetection,
+                          boolean isHttp11ProxyAvailable,
+                          BackendMetricPropagation backendMetricPropagation) {
+      return newBuilder(clusterName)
+          .clusterType(ClusterType.EDS)
+          .edsServiceName(edsServiceName)
+          .lrsServerInfo(lrsServerInfo)
+          .maxConcurrentRequests(maxConcurrentRequests)
+          .upstreamTlsContext(upstreamTlsContext)
+          .outlierDetection(outlierDetection)
+          .isHttp11ProxyAvailable(isHttp11ProxyAvailable)
+          .backendMetricPropagation(backendMetricPropagation);
+    }
+
+    static Builder forLogicalDns(String clusterName, String dnsHostName,
+                                 @Nullable ServerInfo lrsServerInfo,
+                                 @Nullable Long maxConcurrentRequests,
+                                 @Nullable UpstreamTlsContext upstreamTlsContext,
+                                 boolean isHttp11ProxyAvailable,
+                                 BackendMetricPropagation backendMetricPropagation) {
+      return newBuilder(clusterName)
+          .clusterType(ClusterType.LOGICAL_DNS)
+          .dnsHostName(dnsHostName)
+          .lrsServerInfo(lrsServerInfo)
+          .maxConcurrentRequests(maxConcurrentRequests)
+          .upstreamTlsContext(upstreamTlsContext)
+          .isHttp11ProxyAvailable(isHttp11ProxyAvailable)
+          .backendMetricPropagation(backendMetricPropagation);
+    }
+
+    enum ClusterType {
+      EDS, LOGICAL_DNS, AGGREGATE
+    }
+
+    enum LbPolicy {
+      ROUND_ROBIN, RING_HASH, LEAST_REQUEST
+    }
+
+    // FIXME(chengyuanzhang): delete this after UpstreamTlsContext's toString() is fixed.
+    @Override
+    public final String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("clusterName", clusterName())
+          .add("clusterType", clusterType())
+          .add("lbPolicyConfig", lbPolicyConfig())
+          .add("minRingSize", minRingSize())
+          .add("maxRingSize", maxRingSize())
+          .add("choiceCount", choiceCount())
+          .add("edsServiceName", edsServiceName())
+          .add("dnsHostName", dnsHostName())
+          .add("lrsServerInfo", lrsServerInfo())
+          .add("maxConcurrentRequests", maxConcurrentRequests())
+          // Exclude upstreamTlsContext and outlierDetection as their string representations are
+          // cumbersome.
+          .add("prioritizedClusterNames", prioritizedClusterNames())
+          .toString();
+    }
+
+    @AutoValue.Builder
+    abstract static class Builder {
+      // Private, use one of the static factory methods instead.
+      protected abstract Builder clusterName(String clusterName);
+
+      // Private, use one of the static factory methods instead.
+      protected abstract Builder clusterType(ClusterType clusterType);
+
+      protected abstract Builder lbPolicyConfig(ImmutableMap<String, ?> lbPolicyConfig);
+
+      Builder roundRobinLbPolicy() {
+        return this.lbPolicyConfig(ImmutableMap.of("round_robin", ImmutableMap.of()));
+      }
+
+      Builder ringHashLbPolicy(Long minRingSize, Long maxRingSize) {
+        return this.lbPolicyConfig(ImmutableMap.of("ring_hash_experimental",
+            ImmutableMap.of("minRingSize", minRingSize.doubleValue(), "maxRingSize",
+                maxRingSize.doubleValue())));
+      }
+
+      Builder leastRequestLbPolicy(Integer choiceCount) {
+        return this.lbPolicyConfig(ImmutableMap.of("least_request_experimental",
+            ImmutableMap.of("choiceCount", choiceCount.doubleValue())));
+      }
+
+      // Private, use leastRequestLbPolicy(int).
+      protected abstract Builder choiceCount(int choiceCount);
+
+      // Private, use ringHashLbPolicy(long, long).
+      protected abstract Builder minRingSize(long minRingSize);
+
+      // Private, use ringHashLbPolicy(long, long).
+      protected abstract Builder maxRingSize(long maxRingSize);
+
+      // Private, use CdsUpdate.forEds() instead.
+      protected abstract Builder edsServiceName(String edsServiceName);
+
+      // Private, use CdsUpdate.forLogicalDns() instead.
+      protected abstract Builder dnsHostName(String dnsHostName);
+
+      // Private, use one of the static factory methods instead.
+      protected abstract Builder lrsServerInfo(ServerInfo lrsServerInfo);
+
+      // Private, use one of the static factory methods instead.
+      protected abstract Builder maxConcurrentRequests(Long maxConcurrentRequests);
+
+      protected abstract Builder isHttp11ProxyAvailable(boolean isHttp11ProxyAvailable);
+
+      // Private, use one of the static factory methods instead.
+      protected abstract Builder upstreamTlsContext(UpstreamTlsContext upstreamTlsContext);
+
+      // Private, use CdsUpdate.forAggregate() instead.
+      protected abstract Builder prioritizedClusterNames(List<String> prioritizedClusterNames);
+
+      protected abstract Builder outlierDetection(OutlierDetection outlierDetection);
+
+      protected abstract Builder filterMetadata(ImmutableMap<String, Struct> filterMetadata);
+
+      protected abstract Builder parsedMetadata(ImmutableMap<String, Object> parsedMetadata);
+
+      protected abstract Builder backendMetricPropagation(
+          BackendMetricPropagation backendMetricPropagation);
+
+      abstract CdsUpdate build();
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsConfig.java b/xds/src/main/java/io/grpc/xds/XdsConfig.java
new file mode 100644
index 00000000000..d184f08de55
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsConfig.java
@@ -0,0 +1,265 @@
+/*
+ * Copyright 2024 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.StatusOr;
+import io.grpc.xds.XdsClusterResource.CdsUpdate;
+import io.grpc.xds.XdsEndpointResource.EdsUpdate;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.XdsRouteConfigureResource.RdsUpdate;
+import java.io.Closeable;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Represents the xDS configuration tree for a specified Listener.
+ */
+final class XdsConfig {
+  private final LdsUpdate listener;
+  private final RdsUpdate route;
+  private final VirtualHost virtualHost;
+  private final ImmutableMap<String, StatusOr<XdsClusterConfig>> clusters;
+  private final int hashCode;
+
+  XdsConfig(LdsUpdate listener, RdsUpdate route, Map<String, StatusOr<XdsClusterConfig>> clusters,
+            VirtualHost virtualHost) {
+    this(listener, route, virtualHost, ImmutableMap.copyOf(clusters));
+  }
+
+  public XdsConfig(LdsUpdate listener, RdsUpdate route, VirtualHost virtualHost,
+                   ImmutableMap<String, StatusOr<XdsClusterConfig>> clusters) {
+    this.listener = listener;
+    this.route = route;
+    this.virtualHost = virtualHost;
+    this.clusters = clusters;
+
+    hashCode = Objects.hash(listener, route, virtualHost, clusters);
+  }
+
+  @Override
+  public boolean equals(Object obj) {
+    if (!(obj instanceof XdsConfig)) {
+      return false;
+    }
+
+    XdsConfig o = (XdsConfig) obj;
+
+    return hashCode() == o.hashCode() && Objects.equals(listener, o.listener)
+        && Objects.equals(route, o.route) && Objects.equals(virtualHost, o.virtualHost)
+        && Objects.equals(clusters, o.clusters);
+  }
+
+  @Override
+  public int hashCode() {
+    return hashCode;
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder builder = new StringBuilder();
+    builder.append("XdsConfig{")
+        .append("\n  listener=").append(listener)
+        .append(",\n  route=").append(route)
+        .append(",\n  virtualHost=").append(virtualHost)
+        .append(",\n  clusters=").append(clusters)
+        .append("\n}");
+    return builder.toString();
+  }
+
+  public LdsUpdate getListener() {
+    return listener;
+  }
+
+  public RdsUpdate getRoute() {
+    return route;
+  }
+
+  public VirtualHost getVirtualHost() {
+    return virtualHost;
+  }
+
+  public ImmutableMap<String, StatusOr<XdsClusterConfig>> getClusters() {
+    return clusters;
+  }
+
+  static final class XdsClusterConfig {
+    private final String clusterName;
+    private final CdsUpdate clusterResource;
+    private final ClusterChild children; // holds details
+
+    XdsClusterConfig(String clusterName, CdsUpdate clusterResource, ClusterChild details) {
+      this.clusterName = checkNotNull(clusterName, "clusterName");
+      this.clusterResource = checkNotNull(clusterResource, "clusterResource");
+      this.children = checkNotNull(details, "details");
+    }
+
+    @Override
+    public int hashCode() {
+      return clusterName.hashCode() + clusterResource.hashCode() + children.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (!(obj instanceof XdsClusterConfig)) {
+        return false;
+      }
+      XdsClusterConfig o = (XdsClusterConfig) obj;
+      return Objects.equals(clusterName, o.clusterName)
+          && Objects.equals(clusterResource, o.clusterResource)
+          && Objects.equals(children, o.children);
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder builder = new StringBuilder();
+      builder.append("XdsClusterConfig{clusterName=").append(clusterName)
+          .append(", clusterResource=").append(clusterResource)
+          .append(", children={").append(children)
+          .append("}");
+      return builder.toString();
+    }
+
+    public String getClusterName() {
+      return clusterName;
+    }
+
+    public CdsUpdate getClusterResource() {
+      return clusterResource;
+    }
+
+    public ClusterChild getChildren() {
+      return children;
+    }
+
+    interface ClusterChild {}
+
+    /** Endpoint info for EDS and LOGICAL_DNS clusters.  If there was an
+     * error, endpoints will be null and resolution_note will be set.
+     */
+    static final class EndpointConfig implements ClusterChild {
+      private final StatusOr<EdsUpdate> endpoint;
+
+      public EndpointConfig(StatusOr<EdsUpdate> endpoint) {
+        this.endpoint = checkNotNull(endpoint, "endpoint");
+      }
+
+      @Override
+      public int hashCode() {
+        return endpoint.hashCode();
+      }
+
+      @Override
+      public boolean equals(Object obj) {
+        if (!(obj instanceof EndpointConfig)) {
+          return false;
+        }
+        return Objects.equals(endpoint, ((EndpointConfig)obj).endpoint);
+      }
+
+      public StatusOr<EdsUpdate> getEndpoint() {
+        return endpoint;
+      }
+
+      @Override
+      public String toString() {
+        if (endpoint.hasValue()) {
+          return "EndpointConfig{endpoint=" + endpoint.getValue() + "}";
+        } else {
+          return "EndpointConfig{error=" + endpoint.getStatus() + "}";
+        }
+      }
+    }
+
+    // The list of leaf clusters for an aggregate cluster.
+    static final class AggregateConfig implements ClusterChild {
+      private final List<String> leafNames;
+
+      public AggregateConfig(List<String> leafNames) {
+        this.leafNames = ImmutableList.copyOf(checkNotNull(leafNames, "leafNames"));
+      }
+
+      public List<String> getLeafNames() {
+        return leafNames;
+      }
+
+      @Override
+      public int hashCode() {
+        return leafNames.hashCode();
+      }
+
+      @Override
+      public boolean equals(Object obj) {
+        if (!(obj instanceof AggregateConfig)) {
+          return false;
+        }
+        return Objects.equals(leafNames, ((AggregateConfig) obj).leafNames);
+      }
+    }
+  }
+
+  static final class XdsConfigBuilder {
+    private LdsUpdate listener;
+    private RdsUpdate route;
+    private Map<String, StatusOr<XdsClusterConfig>> clusters = new HashMap<>();
+    private VirtualHost virtualHost;
+
+    XdsConfigBuilder setListener(LdsUpdate listener) {
+      this.listener = checkNotNull(listener, "listener");
+      return this;
+    }
+
+    XdsConfigBuilder setRoute(RdsUpdate route) {
+      this.route = checkNotNull(route, "route");
+      return this;
+    }
+
+    XdsConfigBuilder addCluster(String name, StatusOr<XdsClusterConfig> clusterConfig) {
+      checkNotNull(name, "name");
+      checkNotNull(clusterConfig, "clusterConfig");
+      clusters.put(name, clusterConfig);
+      return this;
+    }
+
+    XdsConfigBuilder setVirtualHost(VirtualHost virtualHost) {
+      this.virtualHost = checkNotNull(virtualHost, "virtualHost");
+      return this;
+    }
+
+    XdsConfig build() {
+      checkNotNull(listener, "listener");
+      checkNotNull(route, "route");
+      checkNotNull(virtualHost, "virtualHost");
+      return new XdsConfig(listener, route, clusters, virtualHost);
+    }
+  }
+
+  public interface XdsClusterSubscriptionRegistry {
+    Subscription subscribeToCluster(String clusterName);
+  }
+
+  public interface Subscription extends Closeable {
+    /** Release resources without throwing exceptions. */
+    @Override
+    void close();
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsCredentialsProvider.java b/xds/src/main/java/io/grpc/xds/XdsCredentialsProvider.java
new file mode 100644
index 00000000000..e9466f37a0a
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsCredentialsProvider.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2022 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.xds;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.Internal;
+import java.util.Map;
+
+/**
+ * Provider of credentials which can be consumed by clients for xds communications. The actual
+ * credential to be used for a particular xds communication will be chosen based on the bootstrap
+ * configuration.
+ *
+ * <p>Implementations can be automatically discovered by gRPC via Java's SPI mechanism. For
+ * automatic discovery, the implementation must have a zero-argument constructor and include
+ * a resource named {@code META-INF/services/io.grpc.xds.XdsCredentialsProvider} in their JAR. The
+ * file's contents should be the implementation's class name. 
+ * Implementations that need arguments in their constructor can be manually registered by 
+ * {@link XdsCredentialsRegistry#register}.
+ *
+ * <p>Implementations <em>should not</em> throw. If they do, it may interrupt class loading. If
+ * exceptions may reasonably occur for implementation-specific reasons, implementations should
+ * generally handle the exception gracefully and return {@code false} from {@link #isAvailable()}.
+ */
+@Internal
+public abstract class XdsCredentialsProvider {
+  /**
+  * Creates a {@link ChannelCredentials} from the given jsonConfig, or
+  * {@code null} if the given config is invalid. The provider is free to ignore
+  * the config if it's not needed for producing the channel credentials.
+  *
+  * @param jsonConfig json config that can be consumed by the provider to create
+  *                   the channel credentials
+  *
+  */
+  protected abstract ChannelCredentials newChannelCredentials(Map<String, ?> jsonConfig);
+
+  /**
+   * Returns the xDS credential name associated with this provider which makes it selectable
+   * via {@link XdsCredentialsRegistry#getProvider}. This is called only when the class is loaded.
+   * It shouldn't change, and there is no point doing so.
+   */
+  protected abstract String getName();
+
+  /**
+   * Whether this provider is available for use, taking the current environment
+   * into consideration.
+   * If {@code false}, {@link #newChannelCredentials} is not safe to be called.
+   */
+  public abstract boolean isAvailable();
+
+  /**
+   * A priority, from 0 to 10 that this provider should be used, taking the
+   * current environment into consideration. 
+   * 5 should be considered the default, and then tweaked based on
+   * environment detection. A priority of 0 does not imply that the provider
+   * wouldn't work; just that it should be last in line.
+   */
+  public abstract int priority();
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsCredentialsRegistry.java b/xds/src/main/java/io/grpc/xds/XdsCredentialsRegistry.java
new file mode 100644
index 00000000000..9dfefaf1a65
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsCredentialsRegistry.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright 2022 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.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+import io.grpc.InternalServiceProviders;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Registry of {@link XdsCredentialsProvider}s. The {@link #getDefaultRegistry default
+ * instance} loads providers at runtime through the Java service provider mechanism.
+ */
+@ThreadSafe
+final class XdsCredentialsRegistry {
+  private static final Logger logger = Logger.getLogger(XdsCredentialsRegistry.class.getName());
+  private static XdsCredentialsRegistry instance;
+
+  @GuardedBy("this")
+  private final LinkedHashSet<XdsCredentialsProvider> allProviders = new LinkedHashSet<>();
+
+  /**
+   * Generated from {@code allProviders}. Is mapping from scheme key to the
+   * highest priority {@link XdsCredentialsProvider}.
+   * Is replaced instead of mutating.
+   */
+  @GuardedBy("this")
+  private ImmutableMap<String, XdsCredentialsProvider> effectiveProviders = ImmutableMap.of();
+
+  /**
+   * Register a provider.
+   *
+   * <p>If the provider's {@link XdsCredentialsProvider#isAvailable isAvailable()}
+   * returns {@code false}, this method will throw {@link IllegalArgumentException}.
+   *
+   * <p>Providers will be used in priority order. In case of ties, providers are used
+   * in registration order.
+   */
+  public synchronized void register(XdsCredentialsProvider provider) {
+    addProvider(provider);
+    refreshProviders();
+  }
+
+  private synchronized void addProvider(XdsCredentialsProvider provider) {
+    checkArgument(provider.isAvailable(), "isAvailable() returned false");
+    allProviders.add(provider);
+  }
+
+  /**
+   * Deregisters a provider. No-op if the provider is not in the registry.
+   *
+   * @param provider the provider that was added to the register via
+   *                 {@link #register}.
+   */
+  public synchronized void deregister(XdsCredentialsProvider provider) {
+    allProviders.remove(provider);
+    refreshProviders();
+  }
+
+  private synchronized void refreshProviders() {
+    Map<String, XdsCredentialsProvider> refreshedProviders = new HashMap<>();
+    int maxPriority = Integer.MIN_VALUE;
+    // We prefer first-registered providers.
+    for (XdsCredentialsProvider provider : allProviders) {
+      String credsName = provider.getName();
+      XdsCredentialsProvider existing = refreshedProviders.get(credsName);
+      if (existing == null || existing.priority() < provider.priority()) {
+        refreshedProviders.put(credsName, provider);
+      }
+      if (maxPriority < provider.priority()) {
+        maxPriority = provider.priority();
+      }
+    }
+    effectiveProviders = ImmutableMap.copyOf(refreshedProviders);
+  }
+
+  /**
+   * Returns the default registry that loads providers via the Java service loader
+   * mechanism.
+   */
+  public static synchronized XdsCredentialsRegistry getDefaultRegistry() {
+    if (instance == null) {
+      List<XdsCredentialsProvider> providerList = InternalServiceProviders.loadAll(
+              XdsCredentialsProvider.class,
+              getHardCodedClasses(),
+              XdsCredentialsProvider.class.getClassLoader(),
+              new XdsCredentialsProviderPriorityAccessor());
+      if (providerList.isEmpty()) {
+        logger.warning("No XdsCredsRegistry found via ServiceLoader, including for GoogleDefault, "
+            + "TLS and Insecure. This is probably due to a broken build.");
+      }
+      instance = new XdsCredentialsRegistry();
+      for (XdsCredentialsProvider provider : providerList) {
+        logger.fine("Service loader found " + provider);
+        if (provider.isAvailable()) {
+          instance.addProvider(provider);
+        }
+      }
+      instance.refreshProviders();
+    }
+    return instance;
+  }
+
+  /**
+   * Returns effective providers map from scheme to the highest priority
+   * XdsCredsProvider of that scheme. 
+   */
+  @VisibleForTesting
+  synchronized Map<String, XdsCredentialsProvider> providers() {
+    return effectiveProviders;
+  }
+
+  /**
+   * Returns the effective provider for the given xds credential name, or {@code null} if no
+   * suitable provider can be found. 
+   * Each provider declares its name via {@link XdsCredentialsProvider#getName}.
+   */
+  @Nullable
+  public synchronized XdsCredentialsProvider getProvider(String name) {
+    return effectiveProviders.get(checkNotNull(name, "name"));
+  }
+
+  @VisibleForTesting
+  static List<Class<?>> getHardCodedClasses() {
+    // Class.forName(String) is used to remove the need for ProGuard configuration. Note that
+    // ProGuard does not detect usages of Class.forName(String, boolean, ClassLoader):
+    // https://sourceforge.net/p/proguard/bugs/418/
+    ArrayList<Class<?>> list = new ArrayList<>();
+    try {
+      list.add(Class.forName("io.grpc.xds.internal.GoogleDefaultXdsCredentialsProvider")); 
+    } catch (ClassNotFoundException e) {
+      logger.log(Level.WARNING, "Unable to find GoogleDefaultXdsCredentialsProvider", e);
+    }
+
+    try {
+      list.add(Class.forName("io.grpc.xds.internal.InsecureXdsCredentialsProvider"));
+    }  catch (ClassNotFoundException e) {
+      logger.log(Level.WARNING, "Unable to find InsecureXdsCredentialsProvider", e);
+    }
+
+    try {
+      list.add(Class.forName("io.grpc.xds.internal.TlsXdsCredentialsProvider"));
+    } catch (ClassNotFoundException e) {
+      logger.log(Level.WARNING, "Unable to find TlsXdsCredentialsProvider", e);
+    }
+      
+    return Collections.unmodifiableList(list);
+  }
+
+  private static final class XdsCredentialsProviderPriorityAccessor
+          implements InternalServiceProviders.PriorityAccessor<XdsCredentialsProvider> {
+    @Override
+    public boolean isAvailable(XdsCredentialsProvider provider) {
+      return provider.isAvailable();
+    }
+
+    @Override
+    public int getPriority(XdsCredentialsProvider provider) {
+      return provider.priority();
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsDependencyManager.java b/xds/src/main/java/io/grpc/xds/XdsDependencyManager.java
new file mode 100644
index 00000000000..919836ddd9c
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsDependencyManager.java
@@ -0,0 +1,949 @@
+/*
+ * Copyright 2024 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.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.xds.client.XdsClient.ResourceUpdate;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.NameResolverProvider;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.RetryingNameResolver;
+import io.grpc.xds.Endpoints.LocalityLbEndpoints;
+import io.grpc.xds.VirtualHost.Route.RouteAction.ClusterWeight;
+import io.grpc.xds.XdsClusterResource.CdsUpdate.ClusterType;
+import io.grpc.xds.XdsConfig.XdsClusterConfig.AggregateConfig;
+import io.grpc.xds.XdsConfig.XdsClusterConfig.EndpointConfig;
+import io.grpc.xds.XdsRouteConfigureResource.RdsUpdate;
+import io.grpc.xds.client.Locality;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsClient.ResourceWatcher;
+import io.grpc.xds.client.XdsResourceType;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import javax.annotation.Nullable;
+
+/**
+ * This class acts as a layer of indirection between the XdsClient and the NameResolver. It
+ * maintains the watchers for the xds resources and when an update is received, it either requests
+ * referenced resources or updates the XdsConfig and notifies the XdsConfigWatcher.  Each instance
+ * applies to a single data plane authority.
+ */
+final class XdsDependencyManager implements XdsConfig.XdsClusterSubscriptionRegistry {
+  private enum TrackedWatcherTypeEnum {
+    LDS, RDS, CDS, EDS, DNS
+  }
+
+  private static final TrackedWatcherType<XdsListenerResource.LdsUpdate> LDS_TYPE =
+      new TrackedWatcherType<>(TrackedWatcherTypeEnum.LDS);
+  private static final TrackedWatcherType<RdsUpdate> RDS_TYPE =
+      new TrackedWatcherType<>(TrackedWatcherTypeEnum.RDS);
+  private static final TrackedWatcherType<XdsClusterResource.CdsUpdate> CDS_TYPE =
+      new TrackedWatcherType<>(TrackedWatcherTypeEnum.CDS);
+  private static final TrackedWatcherType<XdsEndpointResource.EdsUpdate> EDS_TYPE =
+      new TrackedWatcherType<>(TrackedWatcherTypeEnum.EDS);
+  private static final TrackedWatcherType<List<EquivalentAddressGroup>> DNS_TYPE =
+      new TrackedWatcherType<>(TrackedWatcherTypeEnum.DNS);
+
+  // DNS-resolved endpoints do not have the definition of the locality it belongs to, just hardcode
+  // to an empty locality.
+  private static final Locality LOGICAL_DNS_CLUSTER_LOCALITY = Locality.create("", "", "");
+
+  private static final int MAX_CLUSTER_RECURSION_DEPTH = 16; // Specified by gRFC A37
+
+  static boolean enableLogicalDns = true;
+
+  private final String listenerName;
+  private final XdsClient xdsClient;
+  private final SynchronizationContext syncContext;
+  private final String dataPlaneAuthority;
+  private final NameResolver.Args nameResolverArgs;
+  private XdsConfigWatcher xdsConfigWatcher;
+
+  private StatusOr<XdsConfig> lastUpdate = null;
+  private final Map<TrackedWatcherTypeEnum, TypeWatchers<?>> resourceWatchers =
+      new EnumMap<>(TrackedWatcherTypeEnum.class);
+  private final Set<ClusterSubscription> subscriptions = new HashSet<>();
+
+  XdsDependencyManager(
+      XdsClient xdsClient,
+      SynchronizationContext syncContext,
+      String dataPlaneAuthority,
+      String listenerName,
+      NameResolver.Args nameResolverArgs) {
+    this.listenerName = checkNotNull(listenerName, "listenerName");
+    this.xdsClient = checkNotNull(xdsClient, "xdsClient");
+    this.syncContext = checkNotNull(syncContext, "syncContext");
+    this.dataPlaneAuthority = checkNotNull(dataPlaneAuthority, "dataPlaneAuthority");
+    this.nameResolverArgs = checkNotNull(nameResolverArgs, "nameResolverArgs");
+  }
+
+  public static String toContextStr(String typeName, String resourceName) {
+    return typeName + " resource " + resourceName;
+  }
+
+  public void start(XdsConfigWatcher xdsConfigWatcher) {
+    checkState(this.xdsConfigWatcher == null, "dep manager may not be restarted");
+    this.xdsConfigWatcher = checkNotNull(xdsConfigWatcher, "xdsConfigWatcher");
+    // start the ball rolling
+    syncContext.execute(() -> addWatcher(LDS_TYPE, new LdsWatcher(listenerName)));
+  }
+
+  @Override
+  public XdsConfig.Subscription subscribeToCluster(String clusterName) {
+    checkState(this.xdsConfigWatcher != null, "dep manager must first be started");
+    checkNotNull(clusterName, "clusterName");
+    ClusterSubscription subscription = new ClusterSubscription(clusterName);
+
+    syncContext.execute(() -> {
+      if (getWatchers(LDS_TYPE).isEmpty()) {
+        subscription.closed = true;
+        return; // shutdown() called
+      }
+      subscriptions.add(subscription);
+      addClusterWatcher(clusterName);
+    });
+
+    return subscription;
+  }
+
+  /**
+   * For all logical dns clusters refresh their results.
+   */
+  public void requestReresolution() {
+    syncContext.execute(() -> {
+      for (TrackedWatcher<List<EquivalentAddressGroup>> watcher : getWatchers(DNS_TYPE).values()) {
+        DnsWatcher dnsWatcher = (DnsWatcher) watcher;
+        dnsWatcher.refresh();
+      }
+    });
+  }
+
+  private <T extends ResourceUpdate> void addWatcher(
+      TrackedWatcherType<T> watcherType, XdsWatcherBase<T> watcher) {
+    syncContext.throwIfNotInThisSynchronizationContext();
+    XdsResourceType<T> type = watcher.type;
+    String resourceName = watcher.resourceName;
+
+    getWatchers(watcherType).put(resourceName, watcher);
+    xdsClient.watchXdsResource(type, resourceName, watcher, syncContext);
+  }
+
+  public void shutdown() {
+    syncContext.execute(() -> {
+      for (TypeWatchers<?> watchers : resourceWatchers.values()) {
+        for (TrackedWatcher<?> watcher : watchers.watchers.values()) {
+          watcher.close();
+        }
+      }
+      resourceWatchers.clear();
+      subscriptions.clear();
+    });
+  }
+
+  private void releaseSubscription(ClusterSubscription subscription) {
+    checkNotNull(subscription, "subscription");
+    syncContext.execute(() -> {
+      if (subscription.closed) {
+        return;
+      }
+      subscription.closed = true;
+      if (!subscriptions.remove(subscription)) {
+        return; // shutdown() called
+      }
+      maybePublishConfig();
+    });
+  }
+
+  /**
+   * Check if all resources have results, and if so, generate a new XdsConfig and send it to all
+   * the watchers.
+   */
+  private void maybePublishConfig() {
+    syncContext.throwIfNotInThisSynchronizationContext();
+    if (getWatchers(LDS_TYPE).isEmpty()) {
+      return; // shutdown() called
+    }
+    boolean waitingOnResource = resourceWatchers.values().stream()
+        .flatMap(typeWatchers -> typeWatchers.watchers.values().stream())
+        .anyMatch(TrackedWatcher::missingResult);
+    if (waitingOnResource) {
+      return;
+    }
+
+    StatusOr<XdsConfig> newUpdate = buildUpdate();
+    if (Objects.equals(newUpdate, lastUpdate)) {
+      return;
+    }
+    assert newUpdate.hasValue()
+        || (newUpdate.getStatus().getCode() == Status.Code.UNAVAILABLE
+            || newUpdate.getStatus().getCode() == Status.Code.INTERNAL);
+    lastUpdate = newUpdate;
+    xdsConfigWatcher.onUpdate(lastUpdate);
+  }
+
+  @VisibleForTesting
+  StatusOr<XdsConfig> buildUpdate() {
+    // Create a config and discard any watchers not accessed
+    WatcherTracer tracer = new WatcherTracer(resourceWatchers);
+    StatusOr<XdsConfig> config = buildUpdate(
+        tracer, listenerName, dataPlaneAuthority, subscriptions);
+    tracer.closeUnusedWatchers();
+    return config;
+  }
+
+  private static StatusOr<XdsConfig> buildUpdate(
+      WatcherTracer tracer,
+      String listenerName,
+      String dataPlaneAuthority,
+      Set<ClusterSubscription> subscriptions) {
+    XdsConfig.XdsConfigBuilder builder = new XdsConfig.XdsConfigBuilder();
+
+    // Iterate watchers and build the XdsConfig
+
+    TrackedWatcher<XdsListenerResource.LdsUpdate> ldsWatcher
+        = tracer.getWatcher(LDS_TYPE, listenerName);
+    if (ldsWatcher == null) {
+      return StatusOr.fromStatus(Status.UNAVAILABLE.withDescription(
+          "Bug: No listener watcher found for " + listenerName));
+    }
+    if (!ldsWatcher.getData().hasValue()) {
+      return StatusOr.fromStatus(ldsWatcher.getData().getStatus());
+    }
+    XdsListenerResource.LdsUpdate ldsUpdate = ldsWatcher.getData().getValue();
+    builder.setListener(ldsUpdate);
+
+    RdsUpdateSupplier routeSource = ((LdsWatcher) ldsWatcher).getRouteSource(tracer);
+    if (routeSource == null) {
+      return StatusOr.fromStatus(Status.UNAVAILABLE.withDescription(
+          "Bug: No route source found for listener " + dataPlaneAuthority));
+    }
+    StatusOr<RdsUpdate> statusOrRdsUpdate = routeSource.getRdsUpdate();
+    if (!statusOrRdsUpdate.hasValue()) {
+      return StatusOr.fromStatus(statusOrRdsUpdate.getStatus());
+    }
+    RdsUpdate rdsUpdate = statusOrRdsUpdate.getValue();
+    builder.setRoute(rdsUpdate);
+
+    VirtualHost activeVirtualHost =
+        RoutingUtils.findVirtualHostForHostName(rdsUpdate.virtualHosts, dataPlaneAuthority);
+    if (activeVirtualHost == null) {
+      String error = "Failed to find virtual host matching hostname: " + dataPlaneAuthority;
+      return StatusOr.fromStatus(Status.UNAVAILABLE.withDescription(error));
+    }
+    builder.setVirtualHost(activeVirtualHost);
+
+    Map<String, StatusOr<XdsConfig.XdsClusterConfig>> clusters = new HashMap<>();
+    LinkedHashSet<String> ancestors = new LinkedHashSet<>();
+    for (String cluster : getClusterNamesFromVirtualHost(activeVirtualHost)) {
+      addConfigForCluster(clusters, cluster, ancestors, tracer);
+    }
+    for (ClusterSubscription subscription : subscriptions) {
+      addConfigForCluster(clusters, subscription.getClusterName(), ancestors, tracer);
+    }
+    for (Map.Entry<String, StatusOr<XdsConfig.XdsClusterConfig>> me : clusters.entrySet()) {
+      builder.addCluster(me.getKey(), me.getValue());
+    }
+
+    return StatusOr.fromValue(builder.build());
+  }
+
+  private <T> Map<String, TrackedWatcher<T>> getWatchers(TrackedWatcherType<T> watcherType) {
+    TypeWatchers<?> typeWatchers = resourceWatchers.get(watcherType.typeEnum);
+    if (typeWatchers == null) {
+      typeWatchers = new TypeWatchers<T>(watcherType);
+      resourceWatchers.put(watcherType.typeEnum, typeWatchers);
+    }
+    assert typeWatchers.watcherType == watcherType;
+    @SuppressWarnings("unchecked")
+    TypeWatchers<T> tTypeWatchers = (TypeWatchers<T>) typeWatchers;
+    return tTypeWatchers.watchers;
+  }
+
+  private static void addConfigForCluster(
+      Map<String, StatusOr<XdsConfig.XdsClusterConfig>> clusters,
+      String clusterName,
+      @SuppressWarnings("NonApiType") // Need order-preserving set for errors
+      LinkedHashSet<String> ancestors,
+      WatcherTracer tracer) {
+    if (clusters.containsKey(clusterName)) {
+      return;
+    }
+    if (ancestors.contains(clusterName)) {
+      clusters.put(clusterName, StatusOr.fromStatus(
+          Status.INTERNAL.withDescription(
+              "Aggregate cluster cycle detected: " + ancestors)));
+      return;
+    }
+    if (ancestors.size() > MAX_CLUSTER_RECURSION_DEPTH) {
+      clusters.put(clusterName, StatusOr.fromStatus(
+          Status.INTERNAL.withDescription("Recursion limit reached: " + ancestors)));
+      return;
+    }
+
+    CdsWatcher cdsWatcher = (CdsWatcher) tracer.getWatcher(CDS_TYPE, clusterName);
+    StatusOr<XdsClusterResource.CdsUpdate> cdsWatcherDataOr = cdsWatcher.getData();
+    if (!cdsWatcherDataOr.hasValue()) {
+      clusters.put(clusterName, StatusOr.fromStatus(cdsWatcherDataOr.getStatus()));
+      return;
+    }
+
+    XdsClusterResource.CdsUpdate cdsUpdate = cdsWatcherDataOr.getValue();
+    XdsConfig.XdsClusterConfig.ClusterChild child;
+    switch (cdsUpdate.clusterType()) {
+      case AGGREGATE:
+        // Re-inserting a present element into a LinkedHashSet does not reorder the entries, so it
+        // preserves the priority across all aggregate clusters
+        LinkedHashSet<String> leafNames = new LinkedHashSet<String>();
+        ancestors.add(clusterName);
+        for (String childCluster : cdsUpdate.prioritizedClusterNames()) {
+          addConfigForCluster(clusters, childCluster, ancestors, tracer);
+          StatusOr<XdsConfig.XdsClusterConfig> config = clusters.get(childCluster);
+          if (!config.hasValue()) {
+            // gRFC A37 says: If any of a CDS policy's watchers reports that the resource does not
+            // exist the policy should report that it is in TRANSIENT_FAILURE. If any of the
+            // watchers reports a transient ADS stream error, the policy should report that it is in
+            // TRANSIENT_FAILURE if it has never passed a config to its child.
+            //
+            // But there's currently disagreement about whether that is actually what we want, and
+            // that was not originally implemented in gRPC Java. So we're keeping Java's old
+            // behavior for now and only failing the "leaves" (which is a bit arbitrary for a
+            // cycle).
+            leafNames.add(childCluster);
+            continue;
+          }
+          XdsConfig.XdsClusterConfig.ClusterChild children = config.getValue().getChildren();
+          if (children instanceof AggregateConfig) {
+            leafNames.addAll(((AggregateConfig) children).getLeafNames());
+          } else {
+            leafNames.add(childCluster);
+          }
+        }
+        ancestors.remove(clusterName);
+
+        child = new AggregateConfig(ImmutableList.copyOf(leafNames));
+        break;
+      case EDS:
+        TrackedWatcher<XdsEndpointResource.EdsUpdate> edsWatcher =
+            tracer.getWatcher(EDS_TYPE, cdsWatcher.getEdsServiceName());
+        if (edsWatcher != null) {
+          child = new EndpointConfig(edsWatcher.getData());
+        } else {
+          child = new EndpointConfig(StatusOr.fromStatus(Status.INTERNAL.withDescription(
+              "EDS resource not found for cluster " + clusterName)));
+        }
+        break;
+      case LOGICAL_DNS:
+        if (enableLogicalDns) {
+          TrackedWatcher<List<EquivalentAddressGroup>> dnsWatcher =
+              tracer.getWatcher(DNS_TYPE, cdsUpdate.dnsHostName());
+          child = new EndpointConfig(dnsToEdsUpdate(dnsWatcher.getData(), cdsUpdate.dnsHostName()));
+        } else {
+          child = new EndpointConfig(StatusOr.fromStatus(
+              Status.INTERNAL.withDescription("Logical DNS in dependency manager unsupported")));
+        }
+        break;
+      default:
+        child = new EndpointConfig(StatusOr.fromStatus(Status.UNAVAILABLE.withDescription(
+              "Unknown type in cluster " + clusterName + " " + cdsUpdate.clusterType())));
+    }
+    if (clusters.containsKey(clusterName)) {
+      // If a cycle is detected, we'll have detected it while recursing, so now there will be a key
+      // present. We don't want to overwrite it with a non-error value.
+      return;
+    }
+    clusters.put(clusterName, StatusOr.fromValue(
+        new XdsConfig.XdsClusterConfig(clusterName, cdsUpdate, child)));
+  }
+
+  private static StatusOr<XdsEndpointResource.EdsUpdate> dnsToEdsUpdate(
+      StatusOr<List<EquivalentAddressGroup>> dnsData, String dnsHostName) {
+    if (!dnsData.hasValue()) {
+      return StatusOr.fromStatus(dnsData.getStatus());
+    }
+
+    List<SocketAddress> addresses = new ArrayList<>();
+    for (EquivalentAddressGroup eag : dnsData.getValue()) {
+      addresses.addAll(eag.getAddresses());
+    }
+    EquivalentAddressGroup eag = new EquivalentAddressGroup(addresses);
+    List<Endpoints.LbEndpoint> endpoints = ImmutableList.of(
+        Endpoints.LbEndpoint.create(eag, 1, true, dnsHostName, ImmutableMap.of()));
+    LocalityLbEndpoints lbEndpoints =
+        LocalityLbEndpoints.create(endpoints, 1, 0, ImmutableMap.of());
+    return StatusOr.fromValue(new XdsEndpointResource.EdsUpdate(
+        "fakeEds_logicalDns",
+        Collections.singletonMap(LOGICAL_DNS_CLUSTER_LOCALITY, lbEndpoints),
+        new ArrayList<>()));
+  }
+
+  private void addRdsWatcher(String resourceName) {
+    if (getWatchers(RDS_TYPE).containsKey(resourceName)) {
+      return;
+    }
+
+    addWatcher(RDS_TYPE, new RdsWatcher(resourceName));
+  }
+
+  private void addEdsWatcher(String edsServiceName) {
+    if (getWatchers(EDS_TYPE).containsKey(edsServiceName)) {
+      return;
+    }
+
+    addWatcher(EDS_TYPE, new EdsWatcher(edsServiceName));
+  }
+
+  private void addClusterWatcher(String clusterName) {
+    if (getWatchers(CDS_TYPE).containsKey(clusterName)) {
+      return;
+    }
+
+    addWatcher(CDS_TYPE, new CdsWatcher(clusterName));
+  }
+
+  private void addDnsWatcher(String dnsHostName) {
+    syncContext.throwIfNotInThisSynchronizationContext();
+    if (getWatchers(DNS_TYPE).containsKey(dnsHostName)) {
+      return;
+    }
+
+    DnsWatcher watcher = new DnsWatcher(dnsHostName, nameResolverArgs);
+    getWatchers(DNS_TYPE).put(dnsHostName, watcher);
+    watcher.start();
+  }
+
+  private void updateRoutes(List<VirtualHost> virtualHosts) {
+    VirtualHost virtualHost =
+        RoutingUtils.findVirtualHostForHostName(virtualHosts, dataPlaneAuthority);
+    Set<String> newClusters = getClusterNamesFromVirtualHost(virtualHost);
+    newClusters.forEach((cluster) -> addClusterWatcher(cluster));
+  }
+
+  private String nodeInfo() {
+    return " nodeID: " + xdsClient.getBootstrapInfo().node().getId();
+  }
+
+  private static Set<String> getClusterNamesFromVirtualHost(VirtualHost virtualHost) {
+    if (virtualHost == null) {
+      return Collections.emptySet();
+    }
+
+    // Get all cluster names to which requests can be routed through the virtual host.
+    Set<String> clusters = new HashSet<>();
+    for (VirtualHost.Route route : virtualHost.routes()) {
+      VirtualHost.Route.RouteAction action = route.routeAction();
+      if (action == null) {
+        continue;
+      }
+      if (action.cluster() != null) {
+        clusters.add(action.cluster());
+      } else if (action.weightedClusters() != null) {
+        for (ClusterWeight weighedCluster : action.weightedClusters()) {
+          clusters.add(weighedCluster.name());
+        }
+      }
+    }
+
+    return clusters;
+  }
+
+  private static NameResolver createNameResolver(
+      String dnsHostName,
+      NameResolver.Args nameResolverArgs) {
+    URI uri;
+    try {
+      uri = new URI("dns", "", "/" + dnsHostName, null);
+    } catch (URISyntaxException e) {
+      return new FailingNameResolver(
+          Status.INTERNAL.withDescription("Bug, invalid URI creation: " + dnsHostName)
+            .withCause(e));
+    }
+
+    NameResolverProvider provider =
+        nameResolverArgs.getNameResolverRegistry().getProviderForScheme("dns");
+    if (provider == null) {
+      return new FailingNameResolver(
+          Status.INTERNAL.withDescription("Could not find dns name resolver"));
+    }
+
+    NameResolver bareResolver = provider.newNameResolver(uri, nameResolverArgs);
+    if (bareResolver == null) {
+      return new FailingNameResolver(
+          Status.INTERNAL.withDescription("DNS name resolver provider returned null: " + uri));
+    }
+    return RetryingNameResolver.wrap(bareResolver, nameResolverArgs);
+  }
+
+  private static class TypeWatchers<T> {
+    // Key is resource name
+    final Map<String, TrackedWatcher<T>> watchers = new HashMap<>();
+    final TrackedWatcherType<T> watcherType;
+
+    TypeWatchers(TrackedWatcherType<T> watcherType) {
+      this.watcherType = checkNotNull(watcherType, "watcherType");
+    }
+  }
+
+  public interface XdsConfigWatcher {
+    /**
+     * An updated XdsConfig or RPC-safe Status. The status code will be either UNAVAILABLE or
+     * INTERNAL.
+     */
+    void onUpdate(StatusOr<XdsConfig> config);
+  }
+
+  private final class ClusterSubscription implements XdsConfig.Subscription {
+    private final String clusterName;
+    boolean closed; // Accessed from syncContext
+
+    public ClusterSubscription(String clusterName) {
+      this.clusterName = checkNotNull(clusterName, "clusterName");
+    }
+
+    String getClusterName() {
+      return clusterName;
+    }
+
+    @Override
+    public void close() {
+      releaseSubscription(this);
+    }
+  }
+
+  /** State for tracing garbage collector. */
+  private static final class WatcherTracer {
+    private final Map<TrackedWatcherTypeEnum, TypeWatchers<?>> resourceWatchers;
+    private final Map<TrackedWatcherTypeEnum, TypeWatchers<?>> usedWatchers;
+
+    public WatcherTracer(Map<TrackedWatcherTypeEnum, TypeWatchers<?>> resourceWatchers) {
+      this.resourceWatchers = resourceWatchers;
+
+      this.usedWatchers = new EnumMap<>(TrackedWatcherTypeEnum.class);
+      for (Map.Entry<TrackedWatcherTypeEnum, TypeWatchers<?>> me : resourceWatchers.entrySet()) {
+        usedWatchers.put(me.getKey(), newTypeWatchers(me.getValue().watcherType));
+      }
+    }
+
+    private static <T> TypeWatchers<T> newTypeWatchers(TrackedWatcherType<T> type) {
+      return new TypeWatchers<T>(type);
+    }
+
+    public <T> TrackedWatcher<T> getWatcher(TrackedWatcherType<T> watcherType, String name) {
+      TypeWatchers<?> typeWatchers = resourceWatchers.get(watcherType.typeEnum);
+      if (typeWatchers == null) {
+        return null;
+      }
+      assert typeWatchers.watcherType == watcherType;
+      @SuppressWarnings("unchecked")
+      TypeWatchers<T> tTypeWatchers = (TypeWatchers<T>) typeWatchers;
+      TrackedWatcher<T> watcher = tTypeWatchers.watchers.get(name);
+      if (watcher == null) {
+        return null;
+      }
+      @SuppressWarnings("unchecked")
+      TypeWatchers<T> usedTypeWatchers = (TypeWatchers<T>) usedWatchers.get(watcherType.typeEnum);
+      usedTypeWatchers.watchers.put(name, watcher);
+      return watcher;
+    }
+
+    /** Shut down unused watchers. */
+    public void closeUnusedWatchers() {
+      boolean changed = false; // Help out the GC by preferring old objects
+      for (TrackedWatcherTypeEnum key : resourceWatchers.keySet()) {
+        TypeWatchers<?> orig = resourceWatchers.get(key);
+        TypeWatchers<?> used = usedWatchers.get(key);
+        for (String name : orig.watchers.keySet()) {
+          if (used.watchers.containsKey(name)) {
+            continue;
+          }
+          orig.watchers.get(name).close();
+          changed = true;
+        }
+      }
+      if (changed) {
+        resourceWatchers.putAll(usedWatchers);
+      }
+    }
+  }
+
+  @SuppressWarnings("UnusedTypeParameter")
+  private static final class TrackedWatcherType<T> {
+    public final TrackedWatcherTypeEnum typeEnum;
+
+    public TrackedWatcherType(TrackedWatcherTypeEnum typeEnum) {
+      this.typeEnum = checkNotNull(typeEnum, "typeEnum");
+    }
+  }
+
+  private interface TrackedWatcher<T> {
+    @Nullable
+    StatusOr<T> getData();
+
+    default boolean missingResult() {
+      return getData() == null;
+    }
+
+    default boolean hasDataValue() {
+      StatusOr<T> data = getData();
+      return data != null && data.hasValue();
+    }
+
+    void close();
+  }
+
+  private abstract class XdsWatcherBase<T extends ResourceUpdate>
+      implements ResourceWatcher<T>, TrackedWatcher<T> {
+    private final XdsResourceType<T> type;
+    private final String resourceName;
+    boolean cancelled;
+
+    @Nullable
+    private StatusOr<T> data;
+    @Nullable
+    @SuppressWarnings("unused")
+    private Status ambientError;
+
+
+    private XdsWatcherBase(XdsResourceType<T> type, String resourceName) {
+      this.type = checkNotNull(type, "type");
+      this.resourceName = checkNotNull(resourceName, "resourceName");
+    }
+
+    @Override
+    public void onResourceChanged(StatusOr<T> update) {
+      if (cancelled) {
+        return;
+      }
+      ambientError = null;
+      if (update.hasValue()) {
+        data = update;
+        subscribeToChildren(update.getValue());
+      } else {
+        Status status = update.getStatus();
+        Status translatedStatus = Status.UNAVAILABLE.withDescription(
+            String.format("Error retrieving %s: %s. Details: %s%s",
+                toContextString(),
+                status.getCode(),
+                status.getDescription() != null ? status.getDescription() : "",
+                nodeInfo()));
+
+        data = StatusOr.fromStatus(translatedStatus);
+      }
+      maybePublishConfig();
+    }
+
+    @Override
+    public void onAmbientError(Status error) {
+      if (cancelled) {
+        return;
+      }
+      ambientError = error.withDescription(
+          String.format("Ambient error for %s: %s. Details: %s%s",
+              toContextString(),
+              error.getCode(),
+              error.getDescription() != null ? error.getDescription() : "",
+              nodeInfo()));
+    }
+
+    protected abstract void subscribeToChildren(T update);
+
+    @Override
+    public void close() {
+      cancelled = true;
+      xdsClient.cancelXdsResourceWatch(type, resourceName, this);
+    }
+
+    @Override
+    @Nullable
+    public StatusOr<T> getData() {
+      return data;
+    }
+
+    public String toContextString() {
+      return toContextStr(type.typeName(), resourceName);
+    }
+  }
+
+  private interface RdsUpdateSupplier {
+    StatusOr<RdsUpdate> getRdsUpdate();
+  }
+
+  private class LdsWatcher extends XdsWatcherBase<XdsListenerResource.LdsUpdate>
+      implements RdsUpdateSupplier {
+
+    private LdsWatcher(String resourceName) {
+      super(XdsListenerResource.getInstance(), resourceName);
+    }
+
+    @Override
+    public void subscribeToChildren(XdsListenerResource.LdsUpdate update) {
+      HttpConnectionManager httpConnectionManager = update.httpConnectionManager();
+      List<VirtualHost> virtualHosts;
+      if (httpConnectionManager == null) {
+        // TCP listener. Unsupported config
+        virtualHosts = Collections.emptyList(); // Not null, to not delegate to RDS
+      } else {
+        virtualHosts = httpConnectionManager.virtualHosts();
+      }
+      if (virtualHosts != null) {
+        updateRoutes(virtualHosts);
+      }
+
+      String rdsName = getRdsName(update);
+      if (rdsName != null) {
+        addRdsWatcher(rdsName);
+      }
+    }
+
+    private String getRdsName(XdsListenerResource.LdsUpdate update) {
+      HttpConnectionManager httpConnectionManager = update.httpConnectionManager();
+      if (httpConnectionManager == null) {
+        // TCP listener. Unsupported config
+        return null;
+      }
+      return httpConnectionManager.rdsName();
+    }
+
+    private RdsWatcher getRdsWatcher(XdsListenerResource.LdsUpdate update, WatcherTracer tracer) {
+      String rdsName = getRdsName(update);
+      if (rdsName == null) {
+        return null;
+      }
+      return (RdsWatcher) tracer.getWatcher(RDS_TYPE, rdsName);
+    }
+
+    public RdsUpdateSupplier getRouteSource(WatcherTracer tracer) {
+      if (!hasDataValue()) {
+        return this;
+      }
+      HttpConnectionManager hcm = getData().getValue().httpConnectionManager();
+      if (hcm == null) {
+        return this;
+      }
+      List<VirtualHost> virtualHosts = hcm.virtualHosts();
+      if (virtualHosts != null) {
+        return this;
+      }
+      RdsWatcher rdsWatcher = getRdsWatcher(getData().getValue(), tracer);
+      assert rdsWatcher != null;
+      return rdsWatcher;
+    }
+
+    @Override
+    public StatusOr<RdsUpdate> getRdsUpdate() {
+      if (missingResult()) {
+        return StatusOr.fromStatus(Status.UNAVAILABLE.withDescription("Not yet loaded"));
+      }
+      if (!getData().hasValue()) {
+        return StatusOr.fromStatus(getData().getStatus());
+      }
+      HttpConnectionManager hcm = getData().getValue().httpConnectionManager();
+      if (hcm == null) {
+        return StatusOr.fromStatus(
+            Status.UNAVAILABLE.withDescription("Not an API listener" + nodeInfo()));
+      }
+      List<VirtualHost> virtualHosts = hcm.virtualHosts();
+      if (virtualHosts == null) {
+        // Code shouldn't trigger this case, as it should be calling RdsWatcher instead. This would
+        // be easily implemented with getRdsWatcher().getRdsUpdate(), but getting here is likely a
+        // bug
+        return StatusOr.fromStatus(Status.INTERNAL.withDescription("Routes are in RDS, not LDS"));
+      }
+      return StatusOr.fromValue(new RdsUpdate(virtualHosts));
+    }
+  }
+
+  private class RdsWatcher extends XdsWatcherBase<RdsUpdate> implements RdsUpdateSupplier {
+
+    public RdsWatcher(String resourceName) {
+      super(XdsRouteConfigureResource.getInstance(), checkNotNull(resourceName, "resourceName"));
+    }
+
+    @Override
+    public void subscribeToChildren(RdsUpdate update) {
+      updateRoutes(update.virtualHosts);
+    }
+
+    @Override
+    public StatusOr<RdsUpdate> getRdsUpdate() {
+      if (missingResult()) {
+        return StatusOr.fromStatus(Status.UNAVAILABLE.withDescription("Not yet loaded"));
+      }
+      return getData();
+    }
+  }
+
+  private class CdsWatcher extends XdsWatcherBase<XdsClusterResource.CdsUpdate> {
+    CdsWatcher(String resourceName) {
+      super(XdsClusterResource.getInstance(), checkNotNull(resourceName, "resourceName"));
+    }
+
+    @Override
+    public void subscribeToChildren(XdsClusterResource.CdsUpdate update) {
+      switch (update.clusterType()) {
+        case EDS:
+          addEdsWatcher(getEdsServiceName());
+          break;
+        case LOGICAL_DNS:
+          if (enableLogicalDns) {
+            addDnsWatcher(update.dnsHostName());
+          }
+          break;
+        case AGGREGATE:
+          update.prioritizedClusterNames()
+              .forEach(name -> addClusterWatcher(name));
+          break;
+        default:
+      }
+    }
+
+    public String getEdsServiceName() {
+      XdsClusterResource.CdsUpdate cdsUpdate = getData().getValue();
+      assert cdsUpdate.clusterType() == ClusterType.EDS;
+      String edsServiceName = cdsUpdate.edsServiceName();
+      if (edsServiceName == null) {
+        edsServiceName = cdsUpdate.clusterName();
+      }
+      return edsServiceName;
+    }
+  }
+
+  private class EdsWatcher extends XdsWatcherBase<XdsEndpointResource.EdsUpdate> {
+    private EdsWatcher(String resourceName) {
+      super(XdsEndpointResource.getInstance(), checkNotNull(resourceName, "resourceName"));
+    }
+
+    @Override
+    public void subscribeToChildren(XdsEndpointResource.EdsUpdate update) {}
+  }
+
+  private final class DnsWatcher implements TrackedWatcher<List<EquivalentAddressGroup>> {
+    private final NameResolver resolver;
+    @Nullable
+    private StatusOr<List<EquivalentAddressGroup>> data;
+    private boolean cancelled;
+
+    public DnsWatcher(String dnsHostName, NameResolver.Args nameResolverArgs) {
+      this.resolver = createNameResolver(dnsHostName, nameResolverArgs);
+    }
+
+    public void start() {
+      resolver.start(new NameResolverListener());
+    }
+
+    public void refresh() {
+      if (cancelled) {
+        return;
+      }
+      resolver.refresh();
+    }
+
+    @Override
+    @Nullable
+    public StatusOr<List<EquivalentAddressGroup>> getData() {
+      return data;
+    }
+
+    @Override
+    public void close() {
+      if (cancelled) {
+        return;
+      }
+      cancelled = true;
+      resolver.shutdown();
+    }
+
+    private class NameResolverListener extends NameResolver.Listener2 {
+      @Override
+      public void onResult(final NameResolver.ResolutionResult resolutionResult) {
+        syncContext.execute(() -> onResult2(resolutionResult));
+      }
+
+      @Override
+      public Status onResult2(final NameResolver.ResolutionResult resolutionResult) {
+        if (cancelled) {
+          return Status.OK;
+        }
+        data = resolutionResult.getAddressesOrError();
+        maybePublishConfig();
+        return resolutionResult.getAddressesOrError().getStatus();
+      }
+
+      @Override
+      public void onError(final Status error) {
+        syncContext.execute(new Runnable() {
+          @Override
+          public void run() {
+            if (cancelled) {
+              return;
+            }
+            // DnsNameResolver cannot distinguish between address-not-found and transient errors.
+            // Assume it is a transient error.
+            // TODO: Once the resolution note API is available, don't throw away the error if
+            // hasDataValue(); pass it as the note instead
+            if (!hasDataValue()) {
+              data = StatusOr.fromStatus(error);
+              maybePublishConfig();
+            }
+          }
+        });
+      }
+    }
+  }
+
+  private static final class FailingNameResolver extends NameResolver {
+    private final Status status;
+
+    public FailingNameResolver(Status status) {
+      checkNotNull(status, "status");
+      checkArgument(!status.isOk(), "Status must not be OK");
+      this.status = status;
+    }
+
+    @Override
+    public void start(Listener2 listener) {
+      listener.onError(status);
+    }
+
+    @Override
+    public String getServiceAuthority() {
+      return "bug-if-you-see-this-authority";
+    }
+
+    @Override
+    public void shutdown() {}
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsEndpointResource.java b/xds/src/main/java/io/grpc/xds/XdsEndpointResource.java
new file mode 100644
index 00000000000..9ad75595ea6
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsEndpointResource.java
@@ -0,0 +1,348 @@
+/*
+ * Copyright 2022 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.net.InetAddresses;
+import com.google.protobuf.Any;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Message;
+import io.envoyproxy.envoy.config.core.v3.Address;
+import io.envoyproxy.envoy.config.core.v3.HealthStatus;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;
+import io.envoyproxy.envoy.config.endpoint.v3.Endpoint;
+import io.envoyproxy.envoy.type.v3.FractionalPercent;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.xds.Endpoints.DropOverload;
+import io.grpc.xds.Endpoints.LocalityLbEndpoints;
+import io.grpc.xds.MetadataRegistry.MetadataValueParser;
+import io.grpc.xds.XdsEndpointResource.EdsUpdate;
+import io.grpc.xds.client.Locality;
+import io.grpc.xds.client.XdsClient.ResourceUpdate;
+import io.grpc.xds.client.XdsResourceType;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import javax.annotation.Nullable;
+
+class XdsEndpointResource extends XdsResourceType<EdsUpdate> {
+  static final String ADS_TYPE_URL_EDS =
+      "type.googleapis.com/envoy.config.endpoint.v3.ClusterLoadAssignment";
+
+  public static final String GRPC_EXPERIMENTAL_XDS_DUALSTACK_ENDPOINTS =
+      "GRPC_EXPERIMENTAL_XDS_DUALSTACK_ENDPOINTS";
+
+  private static final XdsEndpointResource instance = new XdsEndpointResource();
+
+  static XdsEndpointResource getInstance() {
+    return instance;
+  }
+
+  @Override
+  @Nullable
+  protected String extractResourceName(Message unpackedResource) {
+    if (!(unpackedResource instanceof ClusterLoadAssignment)) {
+      return null;
+    }
+    return ((ClusterLoadAssignment) unpackedResource).getClusterName();
+  }
+
+  @Override
+  public String typeName() {
+    return "EDS";
+  }
+
+  @Override
+  public String typeUrl() {
+    return ADS_TYPE_URL_EDS;
+  }
+
+  @Override
+  public boolean shouldRetrieveResourceKeysForArgs() {
+    return true;
+  }
+
+  @Override
+  protected boolean isFullStateOfTheWorld() {
+    return false;
+  }
+
+  @Override
+  protected Class<ClusterLoadAssignment> unpackedClassName() {
+    return ClusterLoadAssignment.class;
+  }
+
+  @Override
+  protected EdsUpdate doParse(Args args, Message unpackedMessage) throws ResourceInvalidException {
+    if (!(unpackedMessage instanceof ClusterLoadAssignment)) {
+      throw new ResourceInvalidException("Invalid message type: " + unpackedMessage.getClass());
+    }
+    return processClusterLoadAssignment((ClusterLoadAssignment) unpackedMessage);
+  }
+
+  private static boolean isEnabledXdsDualStack() {
+    return GrpcUtil.getFlag(GRPC_EXPERIMENTAL_XDS_DUALSTACK_ENDPOINTS, false);
+  }
+
+  private static EdsUpdate processClusterLoadAssignment(ClusterLoadAssignment assignment)
+      throws ResourceInvalidException {
+    Map<Integer, Set<Locality>> priorities = new HashMap<>();
+    Map<Locality, LocalityLbEndpoints> localityLbEndpointsMap = new LinkedHashMap<>();
+    List<Endpoints.DropOverload> dropOverloads = new ArrayList<>();
+    int maxPriority = -1;
+    for (io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints localityLbEndpointsProto
+        : assignment.getEndpointsList()) {
+      StructOrError<LocalityLbEndpoints> structOrError =
+          parseLocalityLbEndpoints(localityLbEndpointsProto);
+      if (structOrError == null) {
+        continue;
+      }
+      if (structOrError.getErrorDetail() != null) {
+        throw new ResourceInvalidException(structOrError.getErrorDetail());
+      }
+
+      LocalityLbEndpoints localityLbEndpoints = structOrError.getStruct();
+      int priority = localityLbEndpoints.priority();
+      maxPriority = Math.max(maxPriority, priority);
+      // Note endpoints with health status other than HEALTHY and UNKNOWN are still
+      // handed over to watching parties. It is watching parties' responsibility to
+      // filter out unhealthy endpoints. See EnvoyProtoData.LbEndpoint#isHealthy().
+      Locality locality =  parseLocality(localityLbEndpointsProto.getLocality());
+      localityLbEndpointsMap.put(locality, localityLbEndpoints);
+      if (!priorities.containsKey(priority)) {
+        priorities.put(priority, new HashSet<>());
+      }
+      if (!priorities.get(priority).add(locality)) {
+        throw new ResourceInvalidException("ClusterLoadAssignment has duplicate locality:"
+            + locality + " for priority:" + priority);
+      }
+    }
+    if (priorities.size() != maxPriority + 1) {
+      throw new ResourceInvalidException("ClusterLoadAssignment has sparse priorities");
+    }
+
+    for (ClusterLoadAssignment.Policy.DropOverload dropOverloadProto
+        : assignment.getPolicy().getDropOverloadsList()) {
+      dropOverloads.add(parseDropOverload(dropOverloadProto));
+    }
+    return new EdsUpdate(assignment.getClusterName(), localityLbEndpointsMap, dropOverloads);
+  }
+
+  private static Locality parseLocality(io.envoyproxy.envoy.config.core.v3.Locality proto) {
+    return Locality.create(proto.getRegion(), proto.getZone(), proto.getSubZone());
+  }
+
+  private static DropOverload parseDropOverload(
+      io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment.Policy.DropOverload proto) {
+    return DropOverload.create(proto.getCategory(), getRatePerMillion(proto.getDropPercentage()));
+  }
+
+  private static int getRatePerMillion(FractionalPercent percent) {
+    int numerator = percent.getNumerator();
+    FractionalPercent.DenominatorType type = percent.getDenominator();
+    switch (type) {
+      case TEN_THOUSAND:
+        numerator *= 100;
+        break;
+      case HUNDRED:
+        numerator *= 10_000;
+        break;
+      case MILLION:
+        break;
+      case UNRECOGNIZED:
+      default:
+        throw new IllegalArgumentException("Unknown denominator type of " + percent);
+    }
+
+    if (numerator > 1_000_000 || numerator < 0) {
+      numerator = 1_000_000;
+    }
+    return numerator;
+  }
+
+
+  @VisibleForTesting
+  @Nullable
+  static StructOrError<LocalityLbEndpoints> parseLocalityLbEndpoints(
+      io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints proto)
+      throws ResourceInvalidException {
+    // Filter out localities without or with 0 weight.
+    if (!proto.hasLoadBalancingWeight() || proto.getLoadBalancingWeight().getValue() < 1) {
+      return null;
+    }
+    if (proto.getPriority() < 0) {
+      return StructOrError.fromError("negative priority");
+    }
+
+    ImmutableMap<String, Object> localityMetadata;
+    MetadataRegistry registry = MetadataRegistry.getInstance();
+    try {
+      localityMetadata = registry.parseMetadata(proto.getMetadata());
+    } catch (ResourceInvalidException e) {
+      throw new ResourceInvalidException("Failed to parse Locality Endpoint metadata: "
+          + e.getMessage(), e);
+    }
+    List<Endpoints.LbEndpoint> endpoints = new ArrayList<>(proto.getLbEndpointsCount());
+    for (io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint endpoint : proto.getLbEndpointsList()) {
+      // The endpoint field of each lb_endpoints must be set.
+      // Inside of it: the address field must be set.
+      if (!endpoint.hasEndpoint() || !endpoint.getEndpoint().hasAddress()) {
+        return StructOrError.fromError("LbEndpoint with no endpoint/address");
+      }
+      ImmutableMap<String, Object> endpointMetadata;
+      try {
+        endpointMetadata = registry.parseMetadata(endpoint.getMetadata());
+      } catch (ResourceInvalidException e) {
+        throw new ResourceInvalidException("Failed to parse Endpoint metadata: "
+            + e.getMessage(), e);
+      }
+      List<java.net.SocketAddress> addresses = new ArrayList<>();
+      addresses.add(getInetSocketAddress(endpoint.getEndpoint().getAddress()));
+
+      if (isEnabledXdsDualStack()) {
+        for (Endpoint.AdditionalAddress additionalAddress
+            : endpoint.getEndpoint().getAdditionalAddressesList()) {
+          addresses.add(getInetSocketAddress(additionalAddress.getAddress()));
+        }
+      }
+      boolean isHealthy = (endpoint.getHealthStatus() == HealthStatus.HEALTHY)
+              || (endpoint.getHealthStatus() == HealthStatus.UNKNOWN);
+      endpoints.add(Endpoints.LbEndpoint.create(
+          new EquivalentAddressGroup(addresses),
+          endpoint.getLoadBalancingWeight().getValue(), isHealthy,
+          endpoint.getEndpoint().getHostname(),
+          endpointMetadata));
+    }
+    return StructOrError.fromStruct(Endpoints.LocalityLbEndpoints.create(
+        endpoints, proto.getLoadBalancingWeight().getValue(),
+        proto.getPriority(), localityMetadata));
+  }
+
+  private static InetSocketAddress getInetSocketAddress(Address address)
+      throws ResourceInvalidException {
+    io.envoyproxy.envoy.config.core.v3.SocketAddress socketAddress = address.getSocketAddress();
+    InetAddress parsedAddress;
+    try {
+      parsedAddress = InetAddresses.forString(socketAddress.getAddress());
+    } catch (IllegalArgumentException ex) {
+      throw new ResourceInvalidException("Address is not an IP", ex);
+    }
+    return new InetSocketAddress(parsedAddress, socketAddress.getPortValue());
+  }
+
+  static final class EdsUpdate implements ResourceUpdate {
+    final String clusterName;
+    final Map<Locality, LocalityLbEndpoints> localityLbEndpointsMap;
+    final List<DropOverload> dropPolicies;
+
+    EdsUpdate(String clusterName, Map<Locality, LocalityLbEndpoints> localityLbEndpoints,
+              List<DropOverload> dropPolicies) {
+      this.clusterName = checkNotNull(clusterName, "clusterName");
+      this.localityLbEndpointsMap = Collections.unmodifiableMap(
+          new LinkedHashMap<>(checkNotNull(localityLbEndpoints, "localityLbEndpoints")));
+      this.dropPolicies = Collections.unmodifiableList(
+          new ArrayList<>(checkNotNull(dropPolicies, "dropPolicies")));
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      EdsUpdate that = (EdsUpdate) o;
+      return Objects.equals(clusterName, that.clusterName)
+          && Objects.equals(localityLbEndpointsMap, that.localityLbEndpointsMap)
+          && Objects.equals(dropPolicies, that.dropPolicies);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(clusterName, localityLbEndpointsMap, dropPolicies);
+    }
+
+    @Override
+    public String toString() {
+      return
+          MoreObjects
+              .toStringHelper(this)
+              .add("clusterName", clusterName)
+              .add("localityLbEndpointsMap", localityLbEndpointsMap)
+              .add("dropPolicies", dropPolicies)
+              .toString();
+    }
+  }
+
+  public static class AddressMetadataParser implements MetadataValueParser {
+
+    @Override
+    public String getTypeUrl() {
+      return "type.googleapis.com/envoy.config.core.v3.Address";
+    }
+
+    @Override
+    public java.net.SocketAddress parse(Any any) throws ResourceInvalidException {
+      SocketAddress socketAddress;
+      try {
+        socketAddress = any.unpack(Address.class).getSocketAddress();
+      } catch (InvalidProtocolBufferException ex) {
+        throw new ResourceInvalidException("Invalid Resource in address proto", ex);
+      }
+      validateAddress(socketAddress);
+
+      String ip = socketAddress.getAddress();
+      int port = socketAddress.getPortValue();
+
+      try {
+        return new InetSocketAddress(InetAddresses.forString(ip), port);
+      } catch (IllegalArgumentException e) {
+        throw createException("Invalid IP address or port: " + ip + ":" + port);
+      }
+    }
+
+    private void validateAddress(SocketAddress socketAddress) throws ResourceInvalidException {
+      if (socketAddress.getAddress().isEmpty()) {
+        throw createException("Address field is empty or invalid.");
+      }
+      long port = Integer.toUnsignedLong(socketAddress.getPortValue());
+      if (port > 65535) {
+        throw createException(String.format("Port value %d out of range 1-65535.", port));
+      }
+    }
+
+    private ResourceInvalidException createException(String message) {
+      return new ResourceInvalidException(
+          "Failed to parse envoy.config.core.v3.Address: " + message);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsLbPolicies.java b/xds/src/main/java/io/grpc/xds/XdsLbPolicies.java
new file mode 100644
index 00000000000..ae5ac38b471
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsLbPolicies.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2019 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.xds;
+
+final class XdsLbPolicies {
+  static final String CLUSTER_MANAGER_POLICY_NAME = "cluster_manager_experimental";
+  static final String CDS_POLICY_NAME = "cds_experimental";
+  static final String PRIORITY_POLICY_NAME = "priority_experimental";
+  static final String CLUSTER_IMPL_POLICY_NAME = "cluster_impl_experimental";
+  static final String WEIGHTED_TARGET_POLICY_NAME = "weighted_target_experimental";
+  static final String WRR_LOCALITY_POLICY_NAME = "wrr_locality_experimental";
+
+  private XdsLbPolicies() {}
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsListenerResource.java b/xds/src/main/java/io/grpc/xds/XdsListenerResource.java
new file mode 100644
index 00000000000..041b659b4c3
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsListenerResource.java
@@ -0,0 +1,647 @@
+/*
+ * Copyright 2022 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.xds.XdsClusterResource.validateCommonTlsContext;
+import static io.grpc.xds.XdsRouteConfigureResource.extractVirtualHosts;
+import static io.grpc.xds.client.XdsClient.ResourceUpdate;
+
+import com.github.udpa.udpa.type.v1.TypedStruct;
+import com.google.auto.value.AutoValue;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.common.net.InetAddresses;
+import com.google.protobuf.Any;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Message;
+import com.google.protobuf.util.Durations;
+import io.envoyproxy.envoy.config.core.v3.HttpProtocolOptions;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress;
+import io.envoyproxy.envoy.config.core.v3.TrafficDirection;
+import io.envoyproxy.envoy.config.listener.v3.Listener;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.Rds;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext;
+import io.grpc.xds.EnvoyServerProtoData.CidrRange;
+import io.grpc.xds.EnvoyServerProtoData.ConnectionSourceType;
+import io.grpc.xds.EnvoyServerProtoData.FilterChain;
+import io.grpc.xds.EnvoyServerProtoData.FilterChainMatch;
+import io.grpc.xds.Filter.FilterConfig;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.client.XdsResourceType;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import javax.annotation.Nullable;
+
+class XdsListenerResource extends XdsResourceType<LdsUpdate> {
+  static final String ADS_TYPE_URL_LDS =
+      "type.googleapis.com/envoy.config.listener.v3.Listener";
+  static final String TYPE_URL_HTTP_CONNECTION_MANAGER =
+      "type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3"
+          + ".HttpConnectionManager";
+  private static final String TRANSPORT_SOCKET_NAME_TLS = "envoy.transport_sockets.tls";
+  private static final XdsListenerResource instance = new XdsListenerResource();
+  private static final FilterRegistry filterRegistry = FilterRegistry.getDefaultRegistry();
+
+  static XdsListenerResource getInstance() {
+    return instance;
+  }
+
+  @Override
+  @Nullable
+  protected String extractResourceName(Message unpackedResource) {
+    if (!(unpackedResource instanceof Listener)) {
+      return null;
+    }
+    return ((Listener) unpackedResource).getName();
+  }
+
+  @Override
+  public String typeName() {
+    return "LDS";
+  }
+
+  @Override
+  protected Class<Listener> unpackedClassName() {
+    return Listener.class;
+  }
+
+  @Override
+  public String typeUrl() {
+    return ADS_TYPE_URL_LDS;
+  }
+
+  @Override
+  public boolean shouldRetrieveResourceKeysForArgs() {
+    return false;
+  }
+
+  @Override
+  protected boolean isFullStateOfTheWorld() {
+    return true;
+  }
+
+  @Override
+  protected LdsUpdate doParse(Args args, Message unpackedMessage)
+      throws ResourceInvalidException {
+    if (!(unpackedMessage instanceof Listener)) {
+      throw new ResourceInvalidException("Invalid message type: " + unpackedMessage.getClass());
+    }
+    Listener listener = (Listener) unpackedMessage;
+
+    if (listener.hasApiListener()) {
+      return processClientSideListener(listener, args);
+    } else {
+      return processServerSideListener(listener, args);
+    }
+  }
+
+  private LdsUpdate processClientSideListener(Listener listener, XdsResourceType.Args args)
+      throws ResourceInvalidException {
+    // Unpack HttpConnectionManager from the Listener.
+    HttpConnectionManager hcm;
+    try {
+      hcm = unpackCompatibleType(
+          listener.getApiListener().getApiListener(), HttpConnectionManager.class,
+          TYPE_URL_HTTP_CONNECTION_MANAGER, null);
+    } catch (InvalidProtocolBufferException e) {
+      throw new ResourceInvalidException(
+          "Could not parse HttpConnectionManager config from ApiListener", e);
+    }
+    return LdsUpdate.forApiListener(
+        parseHttpConnectionManager(hcm, filterRegistry, true /* isForClient */, args));
+  }
+
+  private LdsUpdate processServerSideListener(Listener proto, XdsResourceType.Args args)
+      throws ResourceInvalidException {
+    Set<String> certProviderInstances = null;
+    if (args.getBootstrapInfo() != null && args.getBootstrapInfo().certProviders() != null) {
+      certProviderInstances = args.getBootstrapInfo().certProviders().keySet();
+    }
+    return LdsUpdate.forTcpListener(parseServerSideListener(proto,
+        (TlsContextManager) args.getSecurityConfig(),
+        filterRegistry, certProviderInstances, args));
+  }
+
+  @VisibleForTesting
+  static EnvoyServerProtoData.Listener parseServerSideListener(
+      Listener proto, TlsContextManager tlsContextManager,
+      FilterRegistry filterRegistry, Set<String> certProviderInstances, XdsResourceType.Args args)
+      throws ResourceInvalidException {
+    TrafficDirection trafficDirection = proto.getTrafficDirection();
+    if (!trafficDirection.equals(TrafficDirection.INBOUND)
+        && !trafficDirection.equals(TrafficDirection.UNSPECIFIED)) {
+      throw new ResourceInvalidException(
+          "Listener " + proto.getName() + " with invalid traffic direction: " + trafficDirection);
+    }
+    if (!proto.getListenerFiltersList().isEmpty()) {
+      throw new ResourceInvalidException(
+          "Listener " + proto.getName() + " cannot have listener_filters");
+    }
+    if (proto.hasUseOriginalDst()) {
+      throw new ResourceInvalidException(
+          "Listener " + proto.getName() + " cannot have use_original_dst set to true");
+    }
+
+    String address = null;
+    SocketAddress socketAddress = null;
+    if (proto.getAddress().hasSocketAddress()) {
+      socketAddress = proto.getAddress().getSocketAddress();
+      address = socketAddress.getAddress();
+      if (address.isEmpty()) {
+        throw new ResourceInvalidException("Invalid address: Empty address is not allowed.");
+      }
+      switch (socketAddress.getPortSpecifierCase()) {
+        case NAMED_PORT:
+          throw new ResourceInvalidException("NAMED_PORT is not supported in gRPC.");
+        case PORT_VALUE:
+          address = address + ":" + socketAddress.getPortValue();
+          break;
+        default:
+          // noop
+      }
+    }
+
+    ImmutableList.Builder<FilterChain> filterChains = ImmutableList.builder();
+    Set<String> filterChainNames = new HashSet<>();
+    Set<FilterChainMatch> filterChainMatchSet = new HashSet<>();
+    int i = 0;
+    for (io.envoyproxy.envoy.config.listener.v3.FilterChain fc : proto.getFilterChainsList()) {
+      // May be empty. If it's not empty, required to be unique.
+      String filterChainName = fc.getName();
+      if (filterChainName.isEmpty()) {
+        // Generate a name, so we can identify it in the logs.
+        filterChainName = "chain_" + i;
+      }
+      if (!filterChainNames.add(filterChainName)) {
+        throw new ResourceInvalidException("Filter chain names must be unique. "
+            + "Found duplicate: " + filterChainName);
+      }
+      filterChains.add(
+          parseFilterChain(fc, filterChainName, tlsContextManager, filterRegistry,
+              filterChainMatchSet, certProviderInstances, args));
+      i++;
+    }
+
+    FilterChain defaultFilterChain = null;
+    if (proto.hasDefaultFilterChain()) {
+      String defaultFilterChainName = proto.getDefaultFilterChain().getName();
+      if (defaultFilterChainName.isEmpty()) {
+        defaultFilterChainName = "chain_default";
+      }
+      defaultFilterChain = parseFilterChain(
+          proto.getDefaultFilterChain(), defaultFilterChainName, tlsContextManager, filterRegistry,
+          null, certProviderInstances, args);
+    }
+
+    return EnvoyServerProtoData.Listener.create(proto.getName(), address, filterChains.build(),
+        defaultFilterChain, socketAddress == null ? null : socketAddress.getProtocol());
+  }
+
+  @VisibleForTesting
+  static FilterChain parseFilterChain(
+      io.envoyproxy.envoy.config.listener.v3.FilterChain proto,
+      String filterChainName,
+      TlsContextManager tlsContextManager,
+      FilterRegistry filterRegistry,
+      // null disables FilterChainMatch uniqueness check, used for defaultFilterChain
+      @Nullable Set<FilterChainMatch> filterChainMatchSet,
+      Set<String> certProviderInstances,
+      XdsResourceType.Args args)
+      throws ResourceInvalidException {
+    // FilterChain contains L4 filters, so we ensure it contains only HCM.
+    if (proto.getFiltersCount() != 1) {
+      throw new ResourceInvalidException("FilterChain " + filterChainName
+          + " should contain exact one HttpConnectionManager filter");
+    }
+    io.envoyproxy.envoy.config.listener.v3.Filter l4Filter = proto.getFiltersList().get(0);
+    if (!l4Filter.hasTypedConfig()) {
+      throw new ResourceInvalidException(
+          "FilterChain " + filterChainName + " contains filter " + l4Filter.getName()
+              + " without typed_config");
+    }
+    Any any = l4Filter.getTypedConfig();
+    if (!any.getTypeUrl().equals(TYPE_URL_HTTP_CONNECTION_MANAGER)) {
+      throw new ResourceInvalidException(
+          "FilterChain " + filterChainName + " contains filter " + l4Filter.getName()
+              + " with unsupported typed_config type " + any.getTypeUrl());
+    }
+
+    // Parse HCM.
+    HttpConnectionManager hcmProto;
+    try {
+      hcmProto = any.unpack(HttpConnectionManager.class);
+    } catch (InvalidProtocolBufferException e) {
+      throw new ResourceInvalidException("FilterChain " + filterChainName + " with filter "
+          + l4Filter.getName() + " failed to unpack message", e);
+    }
+    io.grpc.xds.HttpConnectionManager httpConnectionManager = parseHttpConnectionManager(
+        hcmProto, filterRegistry, false /* isForClient */, args);
+
+    // Parse Transport Socket.
+    EnvoyServerProtoData.DownstreamTlsContext downstreamTlsContext = null;
+    if (proto.hasTransportSocket()) {
+      if (!TRANSPORT_SOCKET_NAME_TLS.equals(proto.getTransportSocket().getName())) {
+        throw new ResourceInvalidException("transport-socket with name "
+            + proto.getTransportSocket().getName() + " not supported.");
+      }
+      DownstreamTlsContext downstreamTlsContextProto;
+      try {
+        downstreamTlsContextProto =
+            proto.getTransportSocket().getTypedConfig().unpack(DownstreamTlsContext.class);
+      } catch (InvalidProtocolBufferException e) {
+        throw new ResourceInvalidException("FilterChain " + filterChainName
+            + " failed to unpack message", e);
+      }
+      downstreamTlsContext =
+          EnvoyServerProtoData.DownstreamTlsContext.fromEnvoyProtoDownstreamTlsContext(
+              validateDownstreamTlsContext(downstreamTlsContextProto, certProviderInstances));
+    }
+
+    // Parse FilterChainMatch.
+    FilterChainMatch filterChainMatch = parseFilterChainMatch(proto.getFilterChainMatch());
+    // null used to skip this check for defaultFilterChain.
+    if (filterChainMatchSet != null) {
+      validateFilterChainMatchForUniqueness(filterChainMatchSet, filterChainMatch);
+    }
+
+    return FilterChain.create(
+        filterChainName,
+        filterChainMatch,
+        httpConnectionManager,
+        downstreamTlsContext,
+        tlsContextManager
+    );
+  }
+
+  @VisibleForTesting
+  static DownstreamTlsContext validateDownstreamTlsContext(
+      DownstreamTlsContext downstreamTlsContext, Set<String> certProviderInstances)
+      throws ResourceInvalidException {
+    if (downstreamTlsContext.hasCommonTlsContext()) {
+      validateCommonTlsContext(downstreamTlsContext.getCommonTlsContext(), certProviderInstances,
+          true);
+    } else {
+      throw new ResourceInvalidException(
+          "common-tls-context is required in downstream-tls-context");
+    }
+    if (downstreamTlsContext.hasRequireSni()) {
+      throw new ResourceInvalidException(
+          "downstream-tls-context with require-sni is not supported");
+    }
+    DownstreamTlsContext.OcspStaplePolicy ocspStaplePolicy = downstreamTlsContext
+        .getOcspStaplePolicy();
+    if (ocspStaplePolicy != DownstreamTlsContext.OcspStaplePolicy.UNRECOGNIZED
+        && ocspStaplePolicy != DownstreamTlsContext.OcspStaplePolicy.LENIENT_STAPLING) {
+      throw new ResourceInvalidException(
+          "downstream-tls-context with ocsp_staple_policy value " + ocspStaplePolicy.name()
+              + " is not supported");
+    }
+    return downstreamTlsContext;
+  }
+
+  private static void validateFilterChainMatchForUniqueness(
+      Set<FilterChainMatch> filterChainMatchSet,
+      FilterChainMatch filterChainMatch) throws ResourceInvalidException {
+    // Flattens complex FilterChainMatch into a list of simple FilterChainMatch'es.
+    List<FilterChainMatch> crossProduct = getCrossProduct(filterChainMatch);
+    for (FilterChainMatch cur : crossProduct) {
+      if (!filterChainMatchSet.add(cur)) {
+        throw new ResourceInvalidException("FilterChainMatch must be unique. "
+            + "Found duplicate: " + cur);
+      }
+    }
+  }
+
+  private static List<FilterChainMatch> getCrossProduct(FilterChainMatch filterChainMatch) {
+    // repeating fields to process:
+    // prefixRanges, applicationProtocols, sourcePrefixRanges, sourcePorts, serverNames
+    List<FilterChainMatch> expandedList = expandOnPrefixRange(filterChainMatch);
+    expandedList = expandOnApplicationProtocols(expandedList);
+    expandedList = expandOnSourcePrefixRange(expandedList);
+    expandedList = expandOnSourcePorts(expandedList);
+    return expandOnServerNames(expandedList);
+  }
+
+  private static List<FilterChainMatch> expandOnPrefixRange(FilterChainMatch filterChainMatch) {
+    ArrayList<FilterChainMatch> expandedList = new ArrayList<>();
+    if (filterChainMatch.prefixRanges().isEmpty()) {
+      expandedList.add(filterChainMatch);
+    } else {
+      for (CidrRange cidrRange : filterChainMatch.prefixRanges()) {
+        expandedList.add(FilterChainMatch.create(filterChainMatch.destinationPort(),
+            ImmutableList.of(cidrRange),
+            filterChainMatch.applicationProtocols(),
+            filterChainMatch.sourcePrefixRanges(),
+            filterChainMatch.connectionSourceType(),
+            filterChainMatch.sourcePorts(),
+            filterChainMatch.serverNames(),
+            filterChainMatch.transportProtocol()));
+      }
+    }
+    return expandedList;
+  }
+
+  private static List<FilterChainMatch> expandOnApplicationProtocols(
+      Collection<FilterChainMatch> set) {
+    ArrayList<FilterChainMatch> expandedList = new ArrayList<>();
+    for (FilterChainMatch filterChainMatch : set) {
+      if (filterChainMatch.applicationProtocols().isEmpty()) {
+        expandedList.add(filterChainMatch);
+      } else {
+        for (String applicationProtocol : filterChainMatch.applicationProtocols()) {
+          expandedList.add(FilterChainMatch.create(filterChainMatch.destinationPort(),
+              filterChainMatch.prefixRanges(),
+              ImmutableList.of(applicationProtocol),
+              filterChainMatch.sourcePrefixRanges(),
+              filterChainMatch.connectionSourceType(),
+              filterChainMatch.sourcePorts(),
+              filterChainMatch.serverNames(),
+              filterChainMatch.transportProtocol()));
+        }
+      }
+    }
+    return expandedList;
+  }
+
+  private static List<FilterChainMatch> expandOnSourcePrefixRange(
+      Collection<FilterChainMatch> set) {
+    ArrayList<FilterChainMatch> expandedList = new ArrayList<>();
+    for (FilterChainMatch filterChainMatch : set) {
+      if (filterChainMatch.sourcePrefixRanges().isEmpty()) {
+        expandedList.add(filterChainMatch);
+      } else {
+        for (EnvoyServerProtoData.CidrRange cidrRange : filterChainMatch.sourcePrefixRanges()) {
+          expandedList.add(FilterChainMatch.create(filterChainMatch.destinationPort(),
+              filterChainMatch.prefixRanges(),
+              filterChainMatch.applicationProtocols(),
+              ImmutableList.of(cidrRange),
+              filterChainMatch.connectionSourceType(),
+              filterChainMatch.sourcePorts(),
+              filterChainMatch.serverNames(),
+              filterChainMatch.transportProtocol()));
+        }
+      }
+    }
+    return expandedList;
+  }
+
+  private static List<FilterChainMatch> expandOnSourcePorts(Collection<FilterChainMatch> set) {
+    ArrayList<FilterChainMatch> expandedList = new ArrayList<>();
+    for (FilterChainMatch filterChainMatch : set) {
+      if (filterChainMatch.sourcePorts().isEmpty()) {
+        expandedList.add(filterChainMatch);
+      } else {
+        for (Integer sourcePort : filterChainMatch.sourcePorts()) {
+          expandedList.add(FilterChainMatch.create(filterChainMatch.destinationPort(),
+              filterChainMatch.prefixRanges(),
+              filterChainMatch.applicationProtocols(),
+              filterChainMatch.sourcePrefixRanges(),
+              filterChainMatch.connectionSourceType(),
+              ImmutableList.of(sourcePort),
+              filterChainMatch.serverNames(),
+              filterChainMatch.transportProtocol()));
+        }
+      }
+    }
+    return expandedList;
+  }
+
+  private static List<FilterChainMatch> expandOnServerNames(Collection<FilterChainMatch> set) {
+    ArrayList<FilterChainMatch> expandedList = new ArrayList<>();
+    for (FilterChainMatch filterChainMatch : set) {
+      if (filterChainMatch.serverNames().isEmpty()) {
+        expandedList.add(filterChainMatch);
+      } else {
+        for (String serverName : filterChainMatch.serverNames()) {
+          expandedList.add(FilterChainMatch.create(filterChainMatch.destinationPort(),
+              filterChainMatch.prefixRanges(),
+              filterChainMatch.applicationProtocols(),
+              filterChainMatch.sourcePrefixRanges(),
+              filterChainMatch.connectionSourceType(),
+              filterChainMatch.sourcePorts(),
+              ImmutableList.of(serverName),
+              filterChainMatch.transportProtocol()));
+        }
+      }
+    }
+    return expandedList;
+  }
+
+  private static FilterChainMatch parseFilterChainMatch(
+      io.envoyproxy.envoy.config.listener.v3.FilterChainMatch proto)
+      throws ResourceInvalidException {
+    ImmutableList.Builder<CidrRange> prefixRanges = ImmutableList.builder();
+    ImmutableList.Builder<CidrRange> sourcePrefixRanges = ImmutableList.builder();
+    try {
+      for (io.envoyproxy.envoy.config.core.v3.CidrRange range : proto.getPrefixRangesList()) {
+        prefixRanges.add(
+            CidrRange.create(InetAddresses.forString(range.getAddressPrefix()),
+                range.getPrefixLen().getValue()));
+      }
+      for (io.envoyproxy.envoy.config.core.v3.CidrRange range
+          : proto.getSourcePrefixRangesList()) {
+        sourcePrefixRanges.add(CidrRange.create(
+            InetAddresses.forString(range.getAddressPrefix()), range.getPrefixLen().getValue()));
+      }
+    } catch (IllegalArgumentException ex) {
+      throw new ResourceInvalidException("Failed to create CidrRange", ex);
+    }
+
+    ConnectionSourceType sourceType;
+    switch (proto.getSourceType()) {
+      case ANY:
+        sourceType = ConnectionSourceType.ANY;
+        break;
+      case EXTERNAL:
+        sourceType = ConnectionSourceType.EXTERNAL;
+        break;
+      case SAME_IP_OR_LOOPBACK:
+        sourceType = ConnectionSourceType.SAME_IP_OR_LOOPBACK;
+        break;
+      default:
+        throw new ResourceInvalidException("Unknown source-type: " + proto.getSourceType());
+    }
+    return FilterChainMatch.create(
+        proto.getDestinationPort().getValue(),
+        prefixRanges.build(),
+        ImmutableList.copyOf(proto.getApplicationProtocolsList()),
+        sourcePrefixRanges.build(),
+        sourceType,
+        ImmutableList.copyOf(proto.getSourcePortsList()),
+        ImmutableList.copyOf(proto.getServerNamesList()),
+        proto.getTransportProtocol());
+  }
+
+  @VisibleForTesting
+  static io.grpc.xds.HttpConnectionManager parseHttpConnectionManager(
+      HttpConnectionManager proto, FilterRegistry filterRegistry,
+      boolean isForClient, XdsResourceType.Args args) throws ResourceInvalidException {
+    if (proto.getXffNumTrustedHops() != 0) {
+      throw new ResourceInvalidException(
+          "HttpConnectionManager with xff_num_trusted_hops unsupported");
+    }
+    if (!proto.getOriginalIpDetectionExtensionsList().isEmpty()) {
+      throw new ResourceInvalidException("HttpConnectionManager with "
+          + "original_ip_detection_extensions unsupported");
+    }
+    // Obtain max_stream_duration from Http Protocol Options.
+    long maxStreamDuration = 0;
+    if (proto.hasCommonHttpProtocolOptions()) {
+      HttpProtocolOptions options = proto.getCommonHttpProtocolOptions();
+      if (options.hasMaxStreamDuration()) {
+        maxStreamDuration = Durations.toNanos(options.getMaxStreamDuration());
+      }
+    }
+
+    // Parse http filters.
+    if (proto.getHttpFiltersList().isEmpty()) {
+      throw new ResourceInvalidException("Missing HttpFilter in HttpConnectionManager.");
+    }
+    List<Filter.NamedFilterConfig> filterConfigs = new ArrayList<>();
+    Set<String> names = new HashSet<>();
+    for (int i = 0; i < proto.getHttpFiltersCount(); i++) {
+      io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.HttpFilter
+          httpFilter = proto.getHttpFiltersList().get(i);
+      String filterName = httpFilter.getName();
+      if (!names.add(filterName)) {
+        throw new ResourceInvalidException(
+            "HttpConnectionManager contains duplicate HttpFilter: " + filterName);
+      }
+      StructOrError<Filter.FilterConfig> filterConfig =
+          parseHttpFilter(httpFilter, filterRegistry, isForClient);
+      if ((i == proto.getHttpFiltersCount() - 1)
+          && (filterConfig == null || !isTerminalFilter(filterConfig.getStruct()))) {
+        throw new ResourceInvalidException("The last HttpFilter must be a terminal filter: "
+            + filterName);
+      }
+      if (filterConfig == null) {
+        continue;
+      }
+      if (filterConfig.getErrorDetail() != null) {
+        throw new ResourceInvalidException(
+            "HttpConnectionManager contains invalid HttpFilter: "
+                + filterConfig.getErrorDetail());
+      }
+      if ((i < proto.getHttpFiltersCount() - 1) && isTerminalFilter(filterConfig.getStruct())) {
+        throw new ResourceInvalidException("A terminal HttpFilter must be the last filter: "
+            + filterName);
+      }
+      filterConfigs.add(new Filter.NamedFilterConfig(filterName, filterConfig.getStruct()));
+    }
+
+    // Parse inlined RouteConfiguration or RDS.
+    if (proto.hasRouteConfig()) {
+      List<VirtualHost> virtualHosts = extractVirtualHosts(
+          proto.getRouteConfig(), filterRegistry, args);
+      return io.grpc.xds.HttpConnectionManager.forVirtualHosts(
+          maxStreamDuration, virtualHosts, filterConfigs);
+    }
+    if (proto.hasRds()) {
+      Rds rds = proto.getRds();
+      if (!rds.hasConfigSource()) {
+        throw new ResourceInvalidException(
+            "HttpConnectionManager contains invalid RDS: missing config_source");
+      }
+      if (!rds.getConfigSource().hasAds() && !rds.getConfigSource().hasSelf()) {
+        throw new ResourceInvalidException(
+            "HttpConnectionManager contains invalid RDS: must specify ADS or self ConfigSource");
+      }
+      return io.grpc.xds.HttpConnectionManager.forRdsName(
+          maxStreamDuration, rds.getRouteConfigName(), filterConfigs);
+    }
+    throw new ResourceInvalidException(
+        "HttpConnectionManager neither has inlined route_config nor RDS");
+  }
+
+  // hard-coded: currently router config is the only terminal filter.
+  private static boolean isTerminalFilter(Filter.FilterConfig filterConfig) {
+    return RouterFilter.ROUTER_CONFIG.equals(filterConfig);
+  }
+
+  @VisibleForTesting
+  @Nullable // Returns null if the filter is optional but not supported.
+  static StructOrError<Filter.FilterConfig> parseHttpFilter(
+      io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.HttpFilter
+          httpFilter, FilterRegistry filterRegistry, boolean isForClient) {
+    String filterName = httpFilter.getName();
+    boolean isOptional = httpFilter.getIsOptional();
+    if (!httpFilter.hasTypedConfig()) {
+      return isOptional ? null : StructOrError.fromError(
+          "HttpFilter [" + filterName + "] is not optional and has no typed config");
+    }
+    Message rawConfig = httpFilter.getTypedConfig();
+    String typeUrl = httpFilter.getTypedConfig().getTypeUrl();
+
+    try {
+      if (typeUrl.equals(TYPE_URL_TYPED_STRUCT_UDPA)) {
+        TypedStruct typedStruct = httpFilter.getTypedConfig().unpack(TypedStruct.class);
+        typeUrl = typedStruct.getTypeUrl();
+        rawConfig = typedStruct.getValue();
+      } else if (typeUrl.equals(TYPE_URL_TYPED_STRUCT)) {
+        com.github.xds.type.v3.TypedStruct newTypedStruct =
+            httpFilter.getTypedConfig().unpack(com.github.xds.type.v3.TypedStruct.class);
+        typeUrl = newTypedStruct.getTypeUrl();
+        rawConfig = newTypedStruct.getValue();
+      }
+    } catch (InvalidProtocolBufferException e) {
+      return StructOrError.fromError(
+          "HttpFilter [" + filterName + "] contains invalid proto: " + e);
+    }
+
+    Filter.Provider provider = filterRegistry.get(typeUrl);
+    if (provider == null
+        || (isForClient && !provider.isClientFilter())
+        || (!isForClient && !provider.isServerFilter())) {
+      // Filter type not supported.
+      return isOptional ? null : StructOrError.fromError(
+          "HttpFilter [" + filterName + "](" + typeUrl + ") is required but unsupported for " + (
+              isForClient ? "client" : "server"));
+    }
+    ConfigOrError<? extends FilterConfig> filterConfig = provider.parseFilterConfig(rawConfig);
+    if (filterConfig.errorDetail != null) {
+      return StructOrError.fromError(
+          "Invalid filter config for HttpFilter [" + filterName + "]: " + filterConfig.errorDetail);
+    }
+    return StructOrError.fromStruct(filterConfig.config);
+  }
+
+  @AutoValue
+  abstract static class LdsUpdate implements ResourceUpdate {
+    // Http level api listener configuration.
+    @Nullable
+    abstract io.grpc.xds.HttpConnectionManager httpConnectionManager();
+
+    // Tcp level listener configuration.
+    @Nullable
+    abstract EnvoyServerProtoData.Listener listener();
+
+    static LdsUpdate forApiListener(io.grpc.xds.HttpConnectionManager httpConnectionManager) {
+      checkNotNull(httpConnectionManager, "httpConnectionManager");
+      return new io.grpc.xds.AutoValue_XdsListenerResource_LdsUpdate(httpConnectionManager, null);
+    }
+
+    static LdsUpdate forTcpListener(EnvoyServerProtoData.Listener listener) {
+      checkNotNull(listener, "listener");
+      return new io.grpc.xds.AutoValue_XdsListenerResource_LdsUpdate(null, listener);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsNameResolver.java b/xds/src/main/java/io/grpc/xds/XdsNameResolver.java
new file mode 100644
index 00000000000..196d51fb5a6
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsNameResolver.java
@@ -0,0 +1,1111 @@
+/*
+ * Copyright 2019 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.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.xds.client.Bootstrapper.XDSTP_SCHEME;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Joiner;
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Sets;
+import com.google.gson.Gson;
+import com.google.protobuf.util.Durations;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientInterceptors;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
+import io.grpc.InternalConfigSelector;
+import io.grpc.InternalLogId;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MetricRecorder;
+import io.grpc.NameResolver;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.StatusOr;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.ObjectPool;
+import io.grpc.xds.ClusterSpecifierPlugin.PluginConfig;
+import io.grpc.xds.Filter.FilterConfig;
+import io.grpc.xds.Filter.NamedFilterConfig;
+import io.grpc.xds.RouteLookupServiceClusterSpecifierPlugin.RlsPluginConfig;
+import io.grpc.xds.ThreadSafeRandom.ThreadSafeRandomImpl;
+import io.grpc.xds.VirtualHost.Route;
+import io.grpc.xds.VirtualHost.Route.RouteAction;
+import io.grpc.xds.VirtualHost.Route.RouteAction.ClusterWeight;
+import io.grpc.xds.VirtualHost.Route.RouteAction.HashPolicy;
+import io.grpc.xds.VirtualHost.Route.RouteAction.RetryPolicy;
+import io.grpc.xds.VirtualHost.Route.RouteMatch;
+import io.grpc.xds.XdsNameResolverProvider.CallCounterProvider;
+import io.grpc.xds.client.Bootstrapper.AuthorityInfo;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsInitializationException;
+import io.grpc.xds.client.XdsLogger;
+import io.grpc.xds.client.XdsLogger.XdsLogLevel;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Supplier;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link NameResolver} for resolving gRPC target names with "xds:" scheme.
+ *
+ * <p>Resolving a gRPC target involves contacting the control plane management server via xDS
+ * protocol to retrieve service information and produce a service config to the caller.
+ *
+ * @see XdsNameResolverProvider
+ */
+final class XdsNameResolver extends NameResolver {
+  static final CallOptions.Key<String> CLUSTER_SELECTION_KEY =
+      CallOptions.Key.create("io.grpc.xds.CLUSTER_SELECTION_KEY");
+  static final CallOptions.Key<XdsConfig> XDS_CONFIG_CALL_OPTION_KEY =
+      CallOptions.Key.create("io.grpc.xds.XDS_CONFIG_CALL_OPTION_KEY");
+  static final CallOptions.Key<Long> RPC_HASH_KEY =
+      CallOptions.Key.create("io.grpc.xds.RPC_HASH_KEY");
+  static final CallOptions.Key<Boolean> AUTO_HOST_REWRITE_KEY =
+      CallOptions.Key.create("io.grpc.xds.AUTO_HOST_REWRITE_KEY");
+  @VisibleForTesting
+  static boolean enableTimeout =
+      Strings.isNullOrEmpty(System.getenv("GRPC_XDS_EXPERIMENTAL_ENABLE_TIMEOUT"))
+          || Boolean.parseBoolean(System.getenv("GRPC_XDS_EXPERIMENTAL_ENABLE_TIMEOUT"));
+
+  private final InternalLogId logId;
+  private final XdsLogger logger;
+  @Nullable
+  private final String targetAuthority;
+  private final String target;
+  private final String serviceAuthority;
+  // Encoded version of the service authority as per 
+  // https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.
+  private final String encodedServiceAuthority;
+  private final String overrideAuthority;
+  private final ServiceConfigParser serviceConfigParser;
+  private final SynchronizationContext syncContext;
+  private final ScheduledExecutorService scheduler;
+  private final XdsClientPool xdsClientPool;
+  private final ThreadSafeRandom random;
+  private final FilterRegistry filterRegistry;
+  private final XxHash64 hashFunc = XxHash64.INSTANCE;
+  // Clusters (with reference counts) to which new/existing requests can be/are routed.
+  // put()/remove() must be called in SyncContext, and get() can be called in any thread.
+  private final ConcurrentMap<String, ClusterRefState> clusterRefs = new ConcurrentHashMap<>();
+  private final ConfigSelector configSelector = new ConfigSelector();
+  private final long randomChannelId;
+  private final Args nameResolverArgs;
+  // Must be accessed in syncContext.
+  // Filter instances are unique per channel, and per filter (name+typeUrl).
+  // NamedFilterConfig.filterStateKey -> filter_instance.
+  private final HashMap<String, Filter> activeFilters = new HashMap<>();
+
+  private volatile RoutingConfig routingConfig;
+  private Listener2 listener;
+  private XdsClient xdsClient;
+  private CallCounterProvider callCounterProvider;
+  private ResolveState resolveState;
+
+  XdsNameResolver(
+      URI targetUri, String name, @Nullable String overrideAuthority,
+      ServiceConfigParser serviceConfigParser,
+      SynchronizationContext syncContext, ScheduledExecutorService scheduler,
+      @Nullable Map<String, ?> bootstrapOverride,
+      MetricRecorder metricRecorder, Args nameResolverArgs) {
+    this(targetUri, targetUri.getAuthority(), name, overrideAuthority, serviceConfigParser,
+        syncContext, scheduler,
+        bootstrapOverride == null
+          ? SharedXdsClientPoolProvider.getDefaultProvider()
+          : new SharedXdsClientPoolProvider(),
+        ThreadSafeRandomImpl.instance, FilterRegistry.getDefaultRegistry(), bootstrapOverride,
+        metricRecorder, nameResolverArgs);
+  }
+
+  @VisibleForTesting
+  XdsNameResolver(
+      URI targetUri, @Nullable String targetAuthority, String name,
+      @Nullable String overrideAuthority, ServiceConfigParser serviceConfigParser,
+      SynchronizationContext syncContext, ScheduledExecutorService scheduler,
+      XdsClientPoolFactory xdsClientPoolFactory, ThreadSafeRandom random,
+      FilterRegistry filterRegistry, @Nullable Map<String, ?> bootstrapOverride,
+      MetricRecorder metricRecorder, Args nameResolverArgs) {
+    this.targetAuthority = targetAuthority;
+    target = targetUri.toString();
+
+    // The name might have multiple slashes so encode it before verifying.
+    serviceAuthority = checkNotNull(name, "name");
+    this.encodedServiceAuthority = 
+      GrpcUtil.checkAuthority(GrpcUtil.AuthorityEscaper.encodeAuthority(serviceAuthority));
+
+    this.overrideAuthority = overrideAuthority;
+    this.serviceConfigParser = checkNotNull(serviceConfigParser, "serviceConfigParser");
+    this.syncContext = checkNotNull(syncContext, "syncContext");
+    this.scheduler = checkNotNull(scheduler, "scheduler");
+    Supplier<XdsClient> xdsClientSupplierArg =
+        nameResolverArgs.getArg(XdsNameResolverProvider.XDS_CLIENT_SUPPLIER);
+    if (xdsClientSupplierArg != null) {
+      this.xdsClientPool = new SupplierXdsClientPool(xdsClientSupplierArg);
+    } else {
+      checkNotNull(xdsClientPoolFactory, "xdsClientPoolFactory");
+      this.xdsClientPool = new BootstrappingXdsClientPool(
+          xdsClientPoolFactory, target, bootstrapOverride, metricRecorder);
+    }
+    this.random = checkNotNull(random, "random");
+    this.filterRegistry = checkNotNull(filterRegistry, "filterRegistry");
+    this.nameResolverArgs = checkNotNull(nameResolverArgs, "nameResolverArgs");
+
+    randomChannelId = random.nextLong();
+    logId = InternalLogId.allocate("xds-resolver", name);
+    logger = XdsLogger.withLogId(logId);
+    logger.log(XdsLogLevel.INFO, "Created resolver for {0}", name);
+  }
+
+  @Override
+  public String getServiceAuthority() {
+    return encodedServiceAuthority;
+  }
+
+  @Override
+  public void start(Listener2 listener) {
+    this.listener = checkNotNull(listener, "listener");
+    try {
+      xdsClient = xdsClientPool.getObject();
+    } catch (Exception e) {
+      listener.onError(
+          Status.UNAVAILABLE.withDescription("Failed to initialize xDS").withCause(e));
+      return;
+    }
+    BootstrapInfo bootstrapInfo = xdsClient.getBootstrapInfo();
+    String listenerNameTemplate;
+    if (targetAuthority == null) {
+      listenerNameTemplate = bootstrapInfo.clientDefaultListenerResourceNameTemplate();
+    } else {
+      AuthorityInfo authorityInfo = bootstrapInfo.authorities().get(targetAuthority);
+      if (authorityInfo == null) {
+        listener.onError(Status.INVALID_ARGUMENT.withDescription(
+            "invalid target URI: target authority not found in the bootstrap"));
+        return;
+      }
+      listenerNameTemplate = authorityInfo.clientListenerResourceNameTemplate();
+    }
+    String replacement = serviceAuthority;
+    if (listenerNameTemplate.startsWith(XDSTP_SCHEME)) {
+      replacement = XdsClient.percentEncodePath(replacement);
+    }
+    String ldsResourceName = expandPercentS(listenerNameTemplate, replacement);
+    if (!XdsClient.isResourceNameValid(ldsResourceName, XdsListenerResource.getInstance().typeUrl())
+        ) {
+      listener.onError(Status.INVALID_ARGUMENT.withDescription(
+          "invalid listener resource URI for service authority: " + serviceAuthority));
+      return;
+    }
+    ldsResourceName = XdsClient.canonifyResourceName(ldsResourceName);
+    callCounterProvider = SharedCallCounterMap.getInstance();
+
+    resolveState = new ResolveState(ldsResourceName);
+    resolveState.start();
+  }
+
+  @Override
+  public void refresh() {
+    if (resolveState != null) {
+      resolveState.refresh();
+    }
+  }
+
+  private static String expandPercentS(String template, String replacement) {
+    return template.replace("%s", replacement);
+  }
+
+  @Override
+  public void shutdown() {
+    logger.log(XdsLogLevel.INFO, "Shutdown");
+    if (resolveState != null) {
+      resolveState.shutdown();
+    }
+    if (xdsClient != null) {
+      xdsClient = xdsClientPool.returnObject(xdsClient);
+    }
+  }
+
+  @VisibleForTesting
+  static Map<String, ?> generateServiceConfigWithMethodConfig(
+      @Nullable Long timeoutNano, @Nullable RetryPolicy retryPolicy) {
+    if (timeoutNano == null
+        && (retryPolicy == null || retryPolicy.retryableStatusCodes().isEmpty())) {
+      return Collections.emptyMap();
+    }
+    ImmutableMap.Builder<String, Object> methodConfig = ImmutableMap.builder();
+    methodConfig.put(
+        "name", Collections.singletonList(Collections.emptyMap()));
+    if (retryPolicy != null && !retryPolicy.retryableStatusCodes().isEmpty()) {
+      ImmutableMap.Builder<String, Object> rawRetryPolicy = ImmutableMap.builder();
+      rawRetryPolicy.put("maxAttempts", (double) retryPolicy.maxAttempts());
+      rawRetryPolicy.put("initialBackoff", Durations.toString(retryPolicy.initialBackoff()));
+      rawRetryPolicy.put("maxBackoff", Durations.toString(retryPolicy.maxBackoff()));
+      rawRetryPolicy.put("backoffMultiplier", 2D);
+      List<String> codes = new ArrayList<>(retryPolicy.retryableStatusCodes().size());
+      for (Code code : retryPolicy.retryableStatusCodes()) {
+        codes.add(code.name());
+      }
+      rawRetryPolicy.put(
+          "retryableStatusCodes", Collections.unmodifiableList(codes));
+      if (retryPolicy.perAttemptRecvTimeout() != null) {
+        rawRetryPolicy.put(
+            "perAttemptRecvTimeout", Durations.toString(retryPolicy.perAttemptRecvTimeout()));
+      }
+      methodConfig.put("retryPolicy", rawRetryPolicy.buildOrThrow());
+    }
+    if (timeoutNano != null) {
+      String timeout = timeoutNano / 1_000_000_000.0 + "s";
+      methodConfig.put("timeout", timeout);
+    }
+    return Collections.singletonMap(
+        "methodConfig", Collections.singletonList(methodConfig.buildOrThrow()));
+  }
+
+  @VisibleForTesting
+  XdsClient getXdsClient() {
+    return xdsClient;
+  }
+
+  // called in syncContext
+  private void updateResolutionResult(XdsConfig xdsConfig) {
+    syncContext.throwIfNotInThisSynchronizationContext();
+
+    ImmutableMap.Builder<String, Object> childPolicy = new ImmutableMap.Builder<>();
+    for (String name : clusterRefs.keySet()) {
+      Map<String, ?> lbPolicy = clusterRefs.get(name).toLbPolicy();
+      childPolicy.put(name, ImmutableMap.of("lbPolicy", ImmutableList.of(lbPolicy)));
+    }
+    Map<String, ?> rawServiceConfig = ImmutableMap.of(
+        "loadBalancingConfig",
+        ImmutableList.of(ImmutableMap.of(
+            XdsLbPolicies.CLUSTER_MANAGER_POLICY_NAME,
+            ImmutableMap.of("childPolicy", childPolicy.buildOrThrow()))));
+
+    if (logger.isLoggable(XdsLogLevel.INFO)) {
+      logger.log(
+          XdsLogLevel.INFO, "Generated service config: {0}", new Gson().toJson(rawServiceConfig));
+    }
+    ConfigOrError parsedServiceConfig = serviceConfigParser.parseServiceConfig(rawServiceConfig);
+    Attributes attrs =
+        Attributes.newBuilder()
+            .set(XdsAttributes.XDS_CLIENT, xdsClient)
+            .set(XdsAttributes.XDS_CONFIG, xdsConfig)
+            .set(XdsAttributes.XDS_CLUSTER_SUBSCRIPT_REGISTRY, resolveState.xdsDependencyManager)
+            .set(XdsAttributes.CALL_COUNTER_PROVIDER, callCounterProvider)
+            .set(InternalConfigSelector.KEY, configSelector)
+            .build();
+    ResolutionResult result =
+        ResolutionResult.newBuilder()
+            .setAttributes(attrs)
+            .setServiceConfig(parsedServiceConfig)
+            .build();
+    if (!listener.onResult2(result).isOk()) {
+      resolveState.xdsDependencyManager.requestReresolution();
+    }
+  }
+
+  /**
+   * Returns {@code true} iff {@code hostName} matches the domain name {@code pattern} with
+   * case-insensitive.
+   *
+   * <p>Wildcard pattern rules:
+   * <ol>
+   * <li>A single asterisk (*) matches any domain.</li>
+   * <li>Asterisk (*) is only permitted in the left-most or the right-most part of the pattern,
+   *     but not both.</li>
+   * </ol>
+   */
+  @VisibleForTesting
+  static boolean matchHostName(String hostName, String pattern) {
+    checkArgument(hostName.length() != 0 && !hostName.startsWith(".") && !hostName.endsWith("."),
+        "Invalid host name");
+    checkArgument(pattern.length() != 0 && !pattern.startsWith(".") && !pattern.endsWith("."),
+        "Invalid pattern/domain name");
+
+    hostName = hostName.toLowerCase(Locale.US);
+    pattern = pattern.toLowerCase(Locale.US);
+    // hostName and pattern are now in lower case -- domain names are case-insensitive.
+
+    if (!pattern.contains("*")) {
+      // Not a wildcard pattern -- hostName and pattern must match exactly.
+      return hostName.equals(pattern);
+    }
+    // Wildcard pattern
+
+    if (pattern.length() == 1) {
+      return true;
+    }
+
+    int index = pattern.indexOf('*');
+
+    // At most one asterisk (*) is allowed.
+    if (pattern.indexOf('*', index + 1) != -1) {
+      return false;
+    }
+
+    // Asterisk can only match prefix or suffix.
+    if (index != 0 && index != pattern.length() - 1) {
+      return false;
+    }
+
+    // HostName must be at least as long as the pattern because asterisk has to
+    // match one or more characters.
+    if (hostName.length() < pattern.length()) {
+      return false;
+    }
+
+    if (index == 0 && hostName.endsWith(pattern.substring(1))) {
+      // Prefix matching fails.
+      return true;
+    }
+
+    // Pattern matches hostname if suffix matching succeeds.
+    return index == pattern.length() - 1
+        && hostName.startsWith(pattern.substring(0, pattern.length() - 1));
+  }
+
+  private final class ConfigSelector extends InternalConfigSelector {
+    @Override
+    public Result selectConfig(PickSubchannelArgs args) {
+      RoutingConfig routingCfg;
+      RouteData selectedRoute;
+      String cluster;
+      ClientInterceptor filters;
+      Metadata headers = args.getHeaders();
+      String path = "/" + args.getMethodDescriptor().getFullMethodName();
+      do {
+        routingCfg = routingConfig;
+        if (routingCfg.errorStatus != null) {
+          return Result.forError(routingCfg.errorStatus);
+        }
+        selectedRoute = null;
+        for (RouteData route : routingCfg.routes) {
+          if (RoutingUtils.matchRoute(route.routeMatch, path, headers, random)) {
+            selectedRoute = route;
+            break;
+          }
+        }
+        if (selectedRoute == null) {
+          return Result.forError(
+              Status.UNAVAILABLE.withDescription("Could not find xDS route matching RPC"));
+        }
+        if (selectedRoute.routeAction == null) {
+          return Result.forError(Status.UNAVAILABLE.withDescription(
+              "Could not route RPC to Route with non-forwarding action"));
+        }
+        RouteAction action = selectedRoute.routeAction;
+        if (action.cluster() != null) {
+          cluster = prefixedClusterName(action.cluster());
+          filters = selectedRoute.filterChoices.get(0);
+        } else if (action.weightedClusters() != null) {
+          // XdsRouteConfigureResource verifies the total weight will not be 0 or exceed uint32
+          long totalWeight = 0;
+          for (ClusterWeight weightedCluster : action.weightedClusters()) {
+            totalWeight += weightedCluster.weight();
+          }
+          long select = random.nextLong(totalWeight);
+          long accumulator = 0;
+          for (int i = 0; ; i++) {
+            ClusterWeight weightedCluster = action.weightedClusters().get(i);
+            accumulator += weightedCluster.weight();
+            if (select < accumulator) {
+              cluster = prefixedClusterName(weightedCluster.name());
+              filters = selectedRoute.filterChoices.get(i);
+              break;
+            }
+          }
+        } else if (action.namedClusterSpecifierPluginConfig() != null) {
+          cluster =
+              prefixedClusterSpecifierPluginName(action.namedClusterSpecifierPluginConfig().name());
+          filters = selectedRoute.filterChoices.get(0);
+        } else {
+          // updateRoutes() discards routes with unknown actions
+          throw new AssertionError();
+        }
+      } while (!retainCluster(cluster));
+
+      final RouteAction routeAction = selectedRoute.routeAction;
+      Long timeoutNanos = null;
+      if (enableTimeout) {
+        timeoutNanos = routeAction.timeoutNano();
+        if (timeoutNanos == null) {
+          timeoutNanos = routingCfg.fallbackTimeoutNano;
+        }
+        if (timeoutNanos <= 0) {
+          timeoutNanos = null;
+        }
+      }
+      RetryPolicy retryPolicy = routeAction.retryPolicy();
+      // TODO(chengyuanzhang): avoid service config generation and parsing for each call.
+      Map<String, ?> rawServiceConfig =
+          generateServiceConfigWithMethodConfig(timeoutNanos, retryPolicy);
+      ConfigOrError parsedServiceConfig = serviceConfigParser.parseServiceConfig(rawServiceConfig);
+      Object config = parsedServiceConfig.getConfig();
+      if (config == null) {
+        releaseCluster(cluster);
+        return Result.forError(
+            parsedServiceConfig.getError().augmentDescription(
+                "Failed to parse service config (method config)"));
+      }
+      final String finalCluster = cluster;
+      final XdsConfig xdsConfig = routingCfg.xdsConfig;
+      final long hash = generateHash(routeAction.hashPolicies(), headers);
+      class ClusterSelectionInterceptor implements ClientInterceptor {
+        @Override
+        public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+            final MethodDescriptor<ReqT, RespT> method, CallOptions callOptions,
+            final Channel next) {
+          CallOptions callOptionsForCluster =
+              callOptions.withOption(CLUSTER_SELECTION_KEY, finalCluster)
+                  .withOption(XDS_CONFIG_CALL_OPTION_KEY, xdsConfig)
+                  .withOption(RPC_HASH_KEY, hash);
+          if (routeAction.autoHostRewrite()) {
+            callOptionsForCluster = callOptionsForCluster.withOption(AUTO_HOST_REWRITE_KEY, true);
+          }
+          return new SimpleForwardingClientCall<ReqT, RespT>(
+              next.newCall(method, callOptionsForCluster)) {
+            @Override
+            public void start(Listener<RespT> listener, Metadata headers) {
+              listener = new SimpleForwardingClientCallListener<RespT>(listener) {
+                boolean committed;
+
+                @Override
+                public void onHeaders(Metadata headers) {
+                  committed = true;
+                  releaseCluster(finalCluster);
+                  delegate().onHeaders(headers);
+                }
+
+                @Override
+                public void onClose(Status status, Metadata trailers) {
+                  if (!committed) {
+                    releaseCluster(finalCluster);
+                  }
+                  delegate().onClose(status, trailers);
+                }
+              };
+              delegate().start(listener, headers);
+            }
+          };
+        }
+      }
+
+      return
+          Result.newBuilder()
+              .setConfig(config)
+              .setInterceptor(combineInterceptors(
+                  ImmutableList.of(new ClusterSelectionInterceptor(), filters)))
+              .build();
+    }
+
+    private boolean retainCluster(String cluster) {
+      ClusterRefState clusterRefState = clusterRefs.get(cluster);
+      if (clusterRefState == null) {
+        return false;
+      }
+      AtomicInteger refCount = clusterRefState.refCount;
+      int count;
+      do {
+        count = refCount.get();
+        if (count == 0) {
+          return false;
+        }
+      } while (!refCount.compareAndSet(count, count + 1));
+      return true;
+    }
+
+    private void releaseCluster(final String cluster) {
+      int count = clusterRefs.get(cluster).refCount.decrementAndGet();
+      if (count < 0) {
+        throw new AssertionError();
+      }
+      if (count == 0) {
+        syncContext.execute(new Runnable() {
+          @Override
+          public void run() {
+            if (clusterRefs.get(cluster).refCount.get() != 0) {
+              throw new AssertionError();
+            }
+            clusterRefs.remove(cluster).close();
+            if (resolveState.lastConfigOrStatus.hasValue()) {
+              updateResolutionResult(resolveState.lastConfigOrStatus.getValue());
+            } else {
+              resolveState.cleanUpRoutes(resolveState.lastConfigOrStatus.getStatus());
+            }
+          }
+        });
+      }
+    }
+
+    private long generateHash(List<HashPolicy> hashPolicies, Metadata headers) {
+      Long hash = null;
+      for (HashPolicy policy : hashPolicies) {
+        Long newHash = null;
+        if (policy.type() == HashPolicy.Type.HEADER) {
+          String value = getHeaderValue(headers, policy.headerName());
+          if (value != null) {
+            if (policy.regEx() != null && policy.regExSubstitution() != null) {
+              value = policy.regEx().matcher(value).replaceAll(policy.regExSubstitution());
+            }
+            newHash = hashFunc.hashAsciiString(value);
+          }
+        } else if (policy.type() == HashPolicy.Type.CHANNEL_ID) {
+          newHash = hashFunc.hashLong(randomChannelId);
+        }
+        if (newHash != null ) {
+          // Rotating the old value prevents duplicate hash rules from cancelling each other out
+          // and preserves all of the entropy.
+          long oldHash = hash != null ? ((hash << 1L) | (hash >> 63L)) : 0;
+          hash = oldHash ^ newHash;
+        }
+        // If the policy is a terminal policy and a hash has been generated, ignore
+        // the rest of the hash policies.
+        if (policy.isTerminal() && hash != null) {
+          break;
+        }
+      }
+      return hash == null ? random.nextLong() : hash;
+    }
+  }
+
+  static final class PassthroughClientInterceptor implements ClientInterceptor {
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+      return next.newCall(method, callOptions);
+    }
+  }
+
+  private static ClientInterceptor combineInterceptors(final List<ClientInterceptor> interceptors) {
+    if (interceptors.size() == 0) {
+      return new PassthroughClientInterceptor();
+    }
+    if (interceptors.size() == 1) {
+      return interceptors.get(0);
+    }
+    return new ClientInterceptor() {
+      @Override
+      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+          MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+        next = ClientInterceptors.interceptForward(next, interceptors);
+        return next.newCall(method, callOptions);
+      }
+    };
+  }
+
+  @Nullable
+  private static String getHeaderValue(Metadata headers, String headerName) {
+    if (headerName.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
+      return null;
+    }
+    if (headerName.equals("content-type")) {
+      return "application/grpc";
+    }
+    Metadata.Key<String> key;
+    try {
+      key = Metadata.Key.of(headerName, Metadata.ASCII_STRING_MARSHALLER);
+    } catch (IllegalArgumentException e) {
+      return null;
+    }
+    Iterable<String> values = headers.getAll(key);
+    return values == null ? null : Joiner.on(",").join(values);
+  }
+
+  private static String prefixedClusterName(String name) {
+    return "cluster:" + name;
+  }
+
+  private static String prefixedClusterSpecifierPluginName(String pluginName) {
+    return "cluster_specifier_plugin:" + pluginName;
+  }
+
+  class ResolveState implements XdsDependencyManager.XdsConfigWatcher {
+    private final ConfigOrError emptyServiceConfig =
+        serviceConfigParser.parseServiceConfig(Collections.<String, Object>emptyMap());
+    private final String authority;
+    private final XdsDependencyManager xdsDependencyManager;
+    private boolean stopped;
+    @Nullable
+    private Set<String> existingClusters;  // clusters to which new requests can be routed
+    private StatusOr<XdsConfig> lastConfigOrStatus;
+
+    private ResolveState(String ldsResourceName) {
+      authority = overrideAuthority != null ? overrideAuthority : encodedServiceAuthority;
+      xdsDependencyManager =
+          new XdsDependencyManager(xdsClient, syncContext, authority, ldsResourceName,
+              nameResolverArgs);
+    }
+
+    void start() {
+      xdsDependencyManager.start(this);
+    }
+
+    void refresh() {
+      xdsDependencyManager.requestReresolution();
+    }
+
+    private void shutdown() {
+      if (stopped) {
+        return;
+      }
+
+      stopped = true;
+      xdsDependencyManager.shutdown();
+      updateActiveFilters(null);
+    }
+
+    @Override
+    public void onUpdate(StatusOr<XdsConfig> updateOrStatus) {
+      if (stopped) {
+        return;
+      }
+      logger.log(XdsLogLevel.INFO, "Receive XDS resource update: {0}", updateOrStatus);
+
+      lastConfigOrStatus = updateOrStatus;
+      if (!updateOrStatus.hasValue()) {
+        updateActiveFilters(null);
+        cleanUpRoutes(updateOrStatus.getStatus());
+        return;
+      }
+
+      // Process Route
+      XdsConfig update = updateOrStatus.getValue();
+      HttpConnectionManager httpConnectionManager = update.getListener().httpConnectionManager();
+      if (httpConnectionManager == null) {
+        logger.log(XdsLogLevel.INFO, "API Listener: httpConnectionManager does not exist.");
+        updateActiveFilters(null);
+        cleanUpRoutes(updateOrStatus.getStatus());
+        return;
+      }
+
+      VirtualHost virtualHost = update.getVirtualHost();
+      ImmutableList<NamedFilterConfig> filterConfigs = httpConnectionManager.httpFilterConfigs();
+      long streamDurationNano = httpConnectionManager.httpMaxStreamDurationNano();
+
+      updateActiveFilters(filterConfigs);
+      updateRoutes(update, virtualHost, streamDurationNano, filterConfigs);
+    }
+
+    // called in syncContext
+    private void updateActiveFilters(@Nullable List<NamedFilterConfig> filterConfigs) {
+      if (filterConfigs == null) {
+        filterConfigs = ImmutableList.of();
+      }
+      Set<String> filtersToShutdown = new HashSet<>(activeFilters.keySet());
+      for (NamedFilterConfig namedFilter : filterConfigs) {
+        String typeUrl = namedFilter.filterConfig.typeUrl();
+        String filterKey = namedFilter.filterStateKey();
+
+        Filter.Provider provider = filterRegistry.get(typeUrl);
+        checkNotNull(provider, "provider %s", typeUrl);
+        Filter filter = activeFilters.computeIfAbsent(
+            filterKey, k -> provider.newInstance(namedFilter.name));
+        checkNotNull(filter, "filter %s", filterKey);
+        filtersToShutdown.remove(filterKey);
+      }
+
+      // Shutdown filters not present in current HCM.
+      for (String filterKey : filtersToShutdown) {
+        Filter filterToShutdown = activeFilters.remove(filterKey);
+        checkNotNull(filterToShutdown, "filterToShutdown %s", filterKey);
+        filterToShutdown.close();
+      }
+    }
+
+    private void updateRoutes(
+        XdsConfig xdsConfig,
+        @Nullable VirtualHost virtualHost,
+        long httpMaxStreamDurationNano,
+        @Nullable List<NamedFilterConfig> filterConfigs) {
+      List<Route> routes = virtualHost.routes();
+      ImmutableList.Builder<RouteData> routesData = ImmutableList.builder();
+
+      // Populate all clusters to which requests can be routed to through the virtual host.
+      Set<String> clusters = new HashSet<>();
+      // uniqueName -> clusterName
+      Map<String, String> clusterNameMap = new HashMap<>();
+      // uniqueName -> pluginConfig
+      Map<String, RlsPluginConfig> rlsPluginConfigMap = new HashMap<>();
+      for (Route route : routes) {
+        RouteAction action = route.routeAction();
+        String prefixedName;
+        if (action == null) {
+          routesData.add(new RouteData(route.routeMatch(), null, ImmutableList.of()));
+        } else if (action.cluster() != null) {
+          prefixedName = prefixedClusterName(action.cluster());
+          clusters.add(prefixedName);
+          clusterNameMap.put(prefixedName, action.cluster());
+          ClientInterceptor filters = createFilters(filterConfigs, virtualHost, route, null);
+          routesData.add(new RouteData(route.routeMatch(), route.routeAction(), filters));
+        } else if (action.weightedClusters() != null) {
+          ImmutableList.Builder<ClientInterceptor> filterList = ImmutableList.builder();
+          for (ClusterWeight weightedCluster : action.weightedClusters()) {
+            prefixedName = prefixedClusterName(weightedCluster.name());
+            clusters.add(prefixedName);
+            clusterNameMap.put(prefixedName, weightedCluster.name());
+            filterList.add(createFilters(filterConfigs, virtualHost, route, weightedCluster));
+          }
+          routesData.add(
+              new RouteData(route.routeMatch(), route.routeAction(), filterList.build()));
+        } else if (action.namedClusterSpecifierPluginConfig() != null) {
+          PluginConfig pluginConfig = action.namedClusterSpecifierPluginConfig().config();
+          if (pluginConfig instanceof RlsPluginConfig) {
+            prefixedName = prefixedClusterSpecifierPluginName(
+                action.namedClusterSpecifierPluginConfig().name());
+            clusters.add(prefixedName);
+            rlsPluginConfigMap.put(prefixedName, (RlsPluginConfig) pluginConfig);
+          }
+          ClientInterceptor filters = createFilters(filterConfigs, virtualHost, route, null);
+          routesData.add(new RouteData(route.routeMatch(), route.routeAction(), filters));
+        } else {
+          // Discard route
+        }
+      }
+
+      // Updates channel's load balancing config whenever the set of selectable clusters changes.
+      boolean shouldUpdateResult = existingClusters == null;
+      Set<String> addedClusters =
+          existingClusters == null ? clusters : Sets.difference(clusters, existingClusters);
+      Set<String> deletedClusters =
+          existingClusters == null
+              ? Collections.emptySet() : Sets.difference(existingClusters, clusters);
+      existingClusters = clusters;
+      for (String cluster : addedClusters) {
+        if (clusterRefs.containsKey(cluster)) {
+          clusterRefs.get(cluster).refCount.incrementAndGet();
+        } else {
+          if (clusterNameMap.containsKey(cluster)) {
+            assert cluster.startsWith("cluster:");
+            XdsConfig.Subscription subscription =
+                xdsDependencyManager.subscribeToCluster(cluster.substring("cluster:".length()));
+            clusterRefs.put(
+                cluster,
+                ClusterRefState.forCluster(
+                    new AtomicInteger(1), clusterNameMap.get(cluster), subscription));
+          }
+          if (rlsPluginConfigMap.containsKey(cluster)) {
+            clusterRefs.put(
+                cluster,
+                ClusterRefState.forRlsPlugin(
+                    new AtomicInteger(1), rlsPluginConfigMap.get(cluster)));
+          }
+          shouldUpdateResult = true;
+        }
+      }
+      for (String cluster : clusters) {
+        RlsPluginConfig rlsPluginConfig = rlsPluginConfigMap.get(cluster);
+        if (!Objects.equals(rlsPluginConfig, clusterRefs.get(cluster).rlsPluginConfig)) {
+          ClusterRefState newClusterRefState =
+              ClusterRefState.forRlsPlugin(clusterRefs.get(cluster).refCount, rlsPluginConfig);
+          clusterRefs.put(cluster, newClusterRefState);
+          shouldUpdateResult = true;
+        }
+      }
+      // Update service config to include newly added clusters.
+      if (shouldUpdateResult && routingConfig != null) {
+        updateResolutionResult(xdsConfig);
+        shouldUpdateResult = false;
+      } else {
+        // Need to update at least once
+        shouldUpdateResult = true;
+      }
+      // Make newly added clusters selectable by config selector and deleted clusters no longer
+      // selectable.
+      routingConfig = new RoutingConfig(xdsConfig, httpMaxStreamDurationNano, routesData.build());
+      for (String cluster : deletedClusters) {
+        int count = clusterRefs.get(cluster).refCount.decrementAndGet();
+        if (count == 0) {
+          clusterRefs.remove(cluster).close();
+          shouldUpdateResult = true;
+        }
+      }
+      if (shouldUpdateResult) {
+        updateResolutionResult(xdsConfig);
+      }
+    }
+
+    private ClientInterceptor createFilters(
+        @Nullable List<NamedFilterConfig> filterConfigs,
+        VirtualHost virtualHost,
+        Route route,
+        @Nullable ClusterWeight weightedCluster) {
+      if (filterConfigs == null) {
+        return new PassthroughClientInterceptor();
+      }
+
+      Map<String, FilterConfig> selectedOverrideConfigs =
+          new HashMap<>(virtualHost.filterConfigOverrides());
+      selectedOverrideConfigs.putAll(route.filterConfigOverrides());
+      if (weightedCluster != null) {
+        selectedOverrideConfigs.putAll(weightedCluster.filterConfigOverrides());
+      }
+
+      ImmutableList.Builder<ClientInterceptor> filterInterceptors = ImmutableList.builder();
+      for (NamedFilterConfig namedFilter : filterConfigs) {
+        String name = namedFilter.name;
+        FilterConfig config = namedFilter.filterConfig;
+        FilterConfig overrideConfig = selectedOverrideConfigs.get(name);
+        String filterKey = namedFilter.filterStateKey();
+
+        Filter filter = activeFilters.get(filterKey);
+        checkNotNull(filter, "activeFilters.get(%s)", filterKey);
+        ClientInterceptor interceptor =
+            filter.buildClientInterceptor(config, overrideConfig, scheduler);
+
+        if (interceptor != null) {
+          filterInterceptors.add(interceptor);
+        }
+      }
+
+      // Combine interceptors produced by different filters into a single one that executes
+      // them sequentially. The order is preserved.
+      return combineInterceptors(filterInterceptors.build());
+    }
+
+    private void cleanUpRoutes(Status error) {
+      routingConfig = new RoutingConfig(error);
+      if (existingClusters != null) {
+        for (String cluster : existingClusters) {
+          int count = clusterRefs.get(cluster).refCount.decrementAndGet();
+          if (count == 0) {
+            clusterRefs.remove(cluster).close();
+          }
+        }
+        existingClusters = null;
+      }
+
+      // Without addresses the default LB (normally pick_first) should become TRANSIENT_FAILURE, and
+      // the config selector handles the error message itself.
+      listener.onResult2(ResolutionResult.newBuilder()
+          .setAttributes(Attributes.newBuilder()
+            .set(InternalConfigSelector.KEY, configSelector)
+            .build())
+          .setServiceConfig(emptyServiceConfig)
+          .build());
+    }
+  }
+
+  /**
+   * VirtualHost-level configuration for request routing.
+   */
+  private static class RoutingConfig {
+    final XdsConfig xdsConfig;
+    final long fallbackTimeoutNano;
+    final ImmutableList<RouteData> routes;
+    final Status errorStatus;
+
+    private RoutingConfig(
+        XdsConfig xdsConfig, long fallbackTimeoutNano, ImmutableList<RouteData> routes) {
+      this.xdsConfig = checkNotNull(xdsConfig, "xdsConfig");
+      this.fallbackTimeoutNano = fallbackTimeoutNano;
+      this.routes = checkNotNull(routes, "routes");
+      this.errorStatus = null;
+    }
+
+    private RoutingConfig(Status errorStatus) {
+      this.xdsConfig = null;
+      this.fallbackTimeoutNano = 0;
+      this.routes = null;
+      this.errorStatus = checkNotNull(errorStatus, "errorStatus");
+      checkArgument(!errorStatus.isOk(), "errorStatus should not be okay");
+    }
+  }
+
+  static final class RouteData {
+    final RouteMatch routeMatch;
+    /** null implies non-forwarding action. */
+    @Nullable
+    final RouteAction routeAction;
+    /**
+     * Only one of these interceptors should be used per-RPC. There are only multiple values in the
+     * list for weighted clusters, in which case the order of the list mirrors the weighted
+     * clusters.
+     */
+    final ImmutableList<ClientInterceptor> filterChoices;
+
+    RouteData(RouteMatch routeMatch, @Nullable RouteAction routeAction, ClientInterceptor filter) {
+      this(routeMatch, routeAction, ImmutableList.of(filter));
+    }
+
+    RouteData(
+        RouteMatch routeMatch,
+        @Nullable RouteAction routeAction,
+        ImmutableList<ClientInterceptor> filterChoices) {
+      this.routeMatch = checkNotNull(routeMatch, "routeMatch");
+      checkArgument(
+          routeAction == null || !filterChoices.isEmpty(),
+          "filter may be empty only for non-forwarding action");
+      this.routeAction = routeAction;
+      if (routeAction != null && routeAction.weightedClusters() != null) {
+        checkArgument(
+            routeAction.weightedClusters().size() == filterChoices.size(),
+            "filter choices must match size of weighted clusters");
+      }
+      for (ClientInterceptor filter : filterChoices) {
+        checkNotNull(filter, "entry in filterChoices is null");
+      }
+      this.filterChoices = checkNotNull(filterChoices, "filterChoices");
+    }
+  }
+
+  private static class ClusterRefState {
+    final AtomicInteger refCount;
+    @Nullable
+    final String traditionalCluster;
+    @Nullable
+    final RlsPluginConfig rlsPluginConfig;
+    @Nullable
+    final XdsConfig.Subscription subscription;
+
+    private ClusterRefState(
+        AtomicInteger refCount, @Nullable String traditionalCluster,
+        @Nullable RlsPluginConfig rlsPluginConfig, @Nullable XdsConfig.Subscription subscription) {
+      this.refCount = refCount;
+      checkArgument(traditionalCluster == null ^ rlsPluginConfig == null,
+          "There must be exactly one non-null value in traditionalCluster and pluginConfig");
+      this.traditionalCluster = traditionalCluster;
+      this.rlsPluginConfig = rlsPluginConfig;
+      this.subscription = subscription;
+    }
+
+    private Map<String, ?> toLbPolicy() {
+      if (traditionalCluster != null) {
+        return ImmutableMap.of(
+            XdsLbPolicies.CDS_POLICY_NAME,
+            ImmutableMap.of("cluster", traditionalCluster));
+      } else {
+        ImmutableMap<String, ?> rlsConfig = new ImmutableMap.Builder<String, Object>()
+            .put("routeLookupConfig", rlsPluginConfig.config())
+            .put(
+                "childPolicy",
+                ImmutableList.of(ImmutableMap.of(XdsLbPolicies.CDS_POLICY_NAME, ImmutableMap.of(
+                    "is_dynamic", true))))
+            .put("childPolicyConfigTargetFieldName", "cluster")
+            .buildOrThrow();
+        return ImmutableMap.of("rls_experimental", rlsConfig);
+      }
+    }
+
+    private void close() {
+      if (subscription != null) {
+        subscription.close();
+      }
+    }
+
+    static ClusterRefState forCluster(
+        AtomicInteger refCount, String name, XdsConfig.Subscription subscription) {
+      return new ClusterRefState(refCount, name, null, checkNotNull(subscription, "subscription"));
+    }
+
+    static ClusterRefState forRlsPlugin(
+        AtomicInteger refCount,
+        RlsPluginConfig rlsPluginConfig) {
+      return new ClusterRefState(refCount, null, rlsPluginConfig, null);
+    }
+  }
+
+  /** An ObjectPool, except it can throw an exception. */
+  private interface XdsClientPool {
+    XdsClient getObject() throws XdsInitializationException;
+
+    XdsClient returnObject(XdsClient xdsClient);
+  }
+
+  private static final class BootstrappingXdsClientPool implements XdsClientPool {
+    private final XdsClientPoolFactory xdsClientPoolFactory;
+    private final String target;
+    private final @Nullable Map<String, ?> bootstrapOverride;
+    private final @Nullable MetricRecorder metricRecorder;
+    private ObjectPool<XdsClient> xdsClientPool;
+
+    BootstrappingXdsClientPool(
+        XdsClientPoolFactory xdsClientPoolFactory,
+        String target,
+        @Nullable Map<String, ?> bootstrapOverride,
+        @Nullable MetricRecorder metricRecorder) {
+      this.xdsClientPoolFactory = checkNotNull(xdsClientPoolFactory, "xdsClientPoolFactory");
+      this.target = checkNotNull(target, "target");
+      this.bootstrapOverride = bootstrapOverride;
+      this.metricRecorder = metricRecorder;
+    }
+
+    @Override
+    public XdsClient getObject() throws XdsInitializationException {
+      if (xdsClientPool == null) {
+        BootstrapInfo bootstrapInfo;
+        if (bootstrapOverride == null) {
+          bootstrapInfo = GrpcBootstrapperImpl.defaultBootstrap();
+        } else {
+          bootstrapInfo = new GrpcBootstrapperImpl().bootstrap(bootstrapOverride);
+        }
+        this.xdsClientPool =
+            xdsClientPoolFactory.getOrCreate(target, bootstrapInfo, metricRecorder);
+      }
+      return xdsClientPool.getObject();
+    }
+
+    @Override
+    public XdsClient returnObject(XdsClient xdsClient) {
+      return xdsClientPool.returnObject(xdsClient);
+    }
+  }
+
+  private static final class SupplierXdsClientPool implements XdsClientPool {
+    private final Supplier<XdsClient> xdsClientSupplier;
+
+    SupplierXdsClientPool(Supplier<XdsClient> xdsClientSupplier) {
+      this.xdsClientSupplier = checkNotNull(xdsClientSupplier, "xdsClientSupplier");
+    }
+
+    @Override
+    public XdsClient getObject() throws XdsInitializationException {
+      XdsClient xdsClient = xdsClientSupplier.get();
+      if (xdsClient == null) {
+        throw new XdsInitializationException("Caller failed to initialize XDS_CLIENT_SUPPLIER");
+      }
+      return xdsClient;
+    }
+
+    @Override
+    public XdsClient returnObject(XdsClient xdsClient) {
+      return null;
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsNameResolverProvider.java b/xds/src/main/java/io/grpc/xds/XdsNameResolverProvider.java
new file mode 100644
index 00000000000..e3462276b17
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsNameResolverProvider.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2019 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.base.Preconditions;
+import io.grpc.Internal;
+import io.grpc.NameResolver.Args;
+import io.grpc.NameResolverProvider;
+import io.grpc.xds.client.XdsClient;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.net.URI;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Supplier;
+import javax.annotation.Nullable;
+
+/**
+ * A provider for {@link XdsNameResolver}.
+ *
+ * <p>It resolves a target URI whose scheme is {@code "xds"}. The authority of the
+ * target URI is never used for current release. The path of the target URI, excluding the leading
+ * slash {@code '/'}, will indicate the name to use in the VHDS query.
+ *
+ * <p>This class should not be directly referenced in code. The resolver should be accessed
+ * through {@link io.grpc.NameResolverRegistry} with the URI scheme "xds".
+ */
+@Internal
+public final class XdsNameResolverProvider extends NameResolverProvider {
+  /**
+   * If provided, the suppler must return non-null when lb.start() is called (which implies not
+   * throwing), and the XdsClient must remain alive until lb.shutdown() returns. It may only be
+   * called from the synchronization context.
+   */
+  public static final Args.Key<Supplier<XdsClient>> XDS_CLIENT_SUPPLIER =
+      Args.Key.create("io.grpc.xds.XdsNameResolverProvider.XDS_CLIENT_SUPPLIER");
+
+  private static final String SCHEME = "xds";
+  private final String scheme;
+  private final Map<String, ?> bootstrapOverride;
+
+  public XdsNameResolverProvider() {
+    this(SCHEME, null);
+  }
+
+  private XdsNameResolverProvider(String scheme,
+                                 @Nullable Map<String, ?> bootstrapOverride) {
+    this.scheme = checkNotNull(scheme, "scheme");
+    this.bootstrapOverride = bootstrapOverride;
+  }
+
+  /**
+   * A convenient method to allow creating a {@link XdsNameResolverProvider} with custom scheme
+   * and bootstrap.
+   */
+  public static XdsNameResolverProvider createForTest(String scheme,
+                                                      @Nullable Map<String, ?> bootstrapOverride) {
+    return new XdsNameResolverProvider(scheme, bootstrapOverride);
+  }
+
+  @Override
+  public XdsNameResolver newNameResolver(URI targetUri, Args args) {
+    if (scheme.equals(targetUri.getScheme())) {
+      String targetPath = checkNotNull(targetUri.getPath(), "targetPath");
+      Preconditions.checkArgument(
+          targetPath.startsWith("/"),
+          "the path component (%s) of the target (%s) must start with '/'",
+          targetPath,
+          targetUri);
+      String name = targetPath.substring(1);
+      return new XdsNameResolver(
+          targetUri, name, args.getOverrideAuthority(),
+          args.getServiceConfigParser(), args.getSynchronizationContext(),
+          args.getScheduledExecutorService(),
+          bootstrapOverride,
+          args.getMetricRecorder(), args);
+    }
+    return null;
+  }
+
+  @Override
+  public String getDefaultScheme() {
+    return scheme;
+  }
+
+  @Override
+  protected boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  protected int priority() {
+    // Set priority value to be < 5 as we still want DNS resolver to be the primary default
+    // resolver.
+    return 4;
+  }
+
+  @Override
+  public Collection<Class<? extends SocketAddress>> getProducedSocketAddressTypes() {
+    return Collections.singleton(InetSocketAddress.class);
+  }
+
+  /**
+   * Provides the counter for aggregating outstanding requests per cluster:eds_service_name.
+   */
+  interface CallCounterProvider {
+    AtomicLong getOrCreate(String cluster, @Nullable String edsServiceName);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsRouteConfigureResource.java b/xds/src/main/java/io/grpc/xds/XdsRouteConfigureResource.java
new file mode 100644
index 00000000000..24ec0659b42
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsRouteConfigureResource.java
@@ -0,0 +1,691 @@
+/*
+ * Copyright 2022 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.github.udpa.udpa.type.v1.TypedStruct;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.primitives.UnsignedInteger;
+import com.google.protobuf.Any;
+import com.google.protobuf.Duration;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Message;
+import com.google.protobuf.util.Durations;
+import com.google.re2j.Pattern;
+import com.google.re2j.PatternSyntaxException;
+import io.envoyproxy.envoy.config.core.v3.TypedExtensionConfig;
+import io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin;
+import io.envoyproxy.envoy.config.route.v3.RetryPolicy.RetryBackOff;
+import io.envoyproxy.envoy.config.route.v3.RouteConfiguration;
+import io.envoyproxy.envoy.type.v3.FractionalPercent;
+import io.grpc.Status;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.xds.ClusterSpecifierPlugin.NamedPluginConfig;
+import io.grpc.xds.ClusterSpecifierPlugin.PluginConfig;
+import io.grpc.xds.Filter.FilterConfig;
+import io.grpc.xds.VirtualHost.Route;
+import io.grpc.xds.VirtualHost.Route.RouteAction;
+import io.grpc.xds.VirtualHost.Route.RouteAction.ClusterWeight;
+import io.grpc.xds.VirtualHost.Route.RouteAction.HashPolicy;
+import io.grpc.xds.VirtualHost.Route.RouteAction.RetryPolicy;
+import io.grpc.xds.VirtualHost.Route.RouteMatch;
+import io.grpc.xds.VirtualHost.Route.RouteMatch.PathMatcher;
+import io.grpc.xds.XdsRouteConfigureResource.RdsUpdate;
+import io.grpc.xds.client.XdsClient.ResourceUpdate;
+import io.grpc.xds.client.XdsResourceType;
+import io.grpc.xds.internal.MatcherParser;
+import io.grpc.xds.internal.Matchers;
+import io.grpc.xds.internal.Matchers.FractionMatcher;
+import io.grpc.xds.internal.Matchers.HeaderMatcher;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import javax.annotation.Nullable;
+
+class XdsRouteConfigureResource extends XdsResourceType<RdsUpdate> {
+
+  private static final boolean isXdsAuthorityRewriteEnabled = GrpcUtil.getFlag(
+      "GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE", true);
+  @VisibleForTesting
+  static boolean enableRouteLookup = GrpcUtil.getFlag("GRPC_EXPERIMENTAL_XDS_RLS_LB", true);
+
+  static final String ADS_TYPE_URL_RDS =
+      "type.googleapis.com/envoy.config.route.v3.RouteConfiguration";
+  private static final String TYPE_URL_FILTER_CONFIG =
+      "type.googleapis.com/envoy.config.route.v3.FilterConfig";
+  @VisibleForTesting
+  static final String HASH_POLICY_FILTER_STATE_KEY = "io.grpc.channel_id";
+  // TODO(zdapeng): need to discuss how to handle unsupported values.
+  private static final Set<Status.Code> SUPPORTED_RETRYABLE_CODES =
+      Collections.unmodifiableSet(EnumSet.of(
+          Status.Code.CANCELLED, Status.Code.DEADLINE_EXCEEDED, Status.Code.INTERNAL,
+          Status.Code.RESOURCE_EXHAUSTED, Status.Code.UNAVAILABLE));
+
+  private static final XdsRouteConfigureResource instance = new XdsRouteConfigureResource();
+
+  static XdsRouteConfigureResource getInstance() {
+    return instance;
+  }
+
+  @Override
+  @Nullable
+  protected String extractResourceName(Message unpackedResource) {
+    if (!(unpackedResource instanceof RouteConfiguration)) {
+      return null;
+    }
+    return ((RouteConfiguration) unpackedResource).getName();
+  }
+
+  @Override
+  public String typeName() {
+    return "RDS";
+  }
+
+  @Override
+  public String typeUrl() {
+    return ADS_TYPE_URL_RDS;
+  }
+
+  @Override
+  public boolean shouldRetrieveResourceKeysForArgs() {
+    return false;
+  }
+
+  @Override
+  protected boolean isFullStateOfTheWorld() {
+    return false;
+  }
+
+  @Override
+  protected Class<RouteConfiguration> unpackedClassName() {
+    return RouteConfiguration.class;
+  }
+
+  @Override
+  protected RdsUpdate doParse(XdsResourceType.Args args, Message unpackedMessage)
+      throws ResourceInvalidException {
+    if (!(unpackedMessage instanceof RouteConfiguration)) {
+      throw new ResourceInvalidException("Invalid message type: " + unpackedMessage.getClass());
+    }
+    return processRouteConfiguration(
+        (RouteConfiguration) unpackedMessage, FilterRegistry.getDefaultRegistry(), args);
+  }
+
+  private static RdsUpdate processRouteConfiguration(
+      RouteConfiguration routeConfig, FilterRegistry filterRegistry, XdsResourceType.Args args)
+      throws ResourceInvalidException {
+    return new RdsUpdate(extractVirtualHosts(routeConfig, filterRegistry, args));
+  }
+
+  static List<VirtualHost> extractVirtualHosts(
+      RouteConfiguration routeConfig, FilterRegistry filterRegistry, XdsResourceType.Args args)
+      throws ResourceInvalidException {
+    Map<String, PluginConfig> pluginConfigMap = new HashMap<>();
+    ImmutableSet.Builder<String> optionalPlugins = ImmutableSet.builder();
+
+    if (enableRouteLookup) {
+      List<ClusterSpecifierPlugin> plugins = routeConfig.getClusterSpecifierPluginsList();
+      for (ClusterSpecifierPlugin plugin : plugins) {
+        String pluginName = plugin.getExtension().getName();
+        PluginConfig pluginConfig = parseClusterSpecifierPlugin(plugin);
+        if (pluginConfig != null) {
+          if (pluginConfigMap.put(pluginName, pluginConfig) != null) {
+            throw new ResourceInvalidException(
+                "Multiple ClusterSpecifierPlugins with the same name: " + pluginName);
+          }
+        } else {
+          // The plugin parsed successfully, and it's not supported, but it's marked as optional.
+          optionalPlugins.add(pluginName);
+        }
+      }
+    }
+    List<VirtualHost> virtualHosts = new ArrayList<>(routeConfig.getVirtualHostsCount());
+    for (io.envoyproxy.envoy.config.route.v3.VirtualHost virtualHostProto
+        : routeConfig.getVirtualHostsList()) {
+      StructOrError<VirtualHost> virtualHost =
+          parseVirtualHost(virtualHostProto, filterRegistry, pluginConfigMap,
+              optionalPlugins.build(), args);
+      if (virtualHost.getErrorDetail() != null) {
+        throw new ResourceInvalidException(
+            "RouteConfiguration contains invalid virtual host: " + virtualHost.getErrorDetail());
+      }
+      virtualHosts.add(virtualHost.getStruct());
+    }
+    return virtualHosts;
+  }
+
+  private static StructOrError<VirtualHost> parseVirtualHost(
+      io.envoyproxy.envoy.config.route.v3.VirtualHost proto, FilterRegistry filterRegistry,
+       Map<String, PluginConfig> pluginConfigMap,
+      Set<String> optionalPlugins, XdsResourceType.Args args) {
+    String name = proto.getName();
+    List<Route> routes = new ArrayList<>(proto.getRoutesCount());
+    for (io.envoyproxy.envoy.config.route.v3.Route routeProto : proto.getRoutesList()) {
+      StructOrError<Route> route = parseRoute(
+          routeProto, filterRegistry, pluginConfigMap, optionalPlugins, args);
+      if (route == null) {
+        continue;
+      }
+      if (route.getErrorDetail() != null) {
+        return StructOrError.fromError(
+            "Virtual host [" + name + "] contains invalid route : " + route.getErrorDetail());
+      }
+      routes.add(route.getStruct());
+    }
+    StructOrError<Map<String, Filter.FilterConfig>> overrideConfigs =
+        parseOverrideFilterConfigs(proto.getTypedPerFilterConfigMap(), filterRegistry);
+    if (overrideConfigs.getErrorDetail() != null) {
+      return StructOrError.fromError(
+          "VirtualHost [" + proto.getName() + "] contains invalid HttpFilter config: "
+              + overrideConfigs.getErrorDetail());
+    }
+    return StructOrError.fromStruct(VirtualHost.create(
+        name, proto.getDomainsList(), routes, overrideConfigs.getStruct()));
+  }
+
+  @VisibleForTesting
+  static StructOrError<Map<String, FilterConfig>> parseOverrideFilterConfigs(
+      Map<String, Any> rawFilterConfigMap, FilterRegistry filterRegistry) {
+    Map<String, FilterConfig> overrideConfigs = new HashMap<>();
+    for (String name : rawFilterConfigMap.keySet()) {
+      Any anyConfig = rawFilterConfigMap.get(name);
+      String typeUrl = anyConfig.getTypeUrl();
+      boolean isOptional = false;
+      if (typeUrl.equals(TYPE_URL_FILTER_CONFIG)) {
+        io.envoyproxy.envoy.config.route.v3.FilterConfig filterConfig;
+        try {
+          filterConfig =
+              anyConfig.unpack(io.envoyproxy.envoy.config.route.v3.FilterConfig.class);
+        } catch (InvalidProtocolBufferException e) {
+          return StructOrError.fromError(
+              "FilterConfig [" + name + "] contains invalid proto: " + e);
+        }
+        isOptional = filterConfig.getIsOptional();
+        anyConfig = filterConfig.getConfig();
+        typeUrl = anyConfig.getTypeUrl();
+      }
+      Message rawConfig = anyConfig;
+      try {
+        if (typeUrl.equals(TYPE_URL_TYPED_STRUCT_UDPA)) {
+          TypedStruct typedStruct = anyConfig.unpack(TypedStruct.class);
+          typeUrl = typedStruct.getTypeUrl();
+          rawConfig = typedStruct.getValue();
+        } else if (typeUrl.equals(TYPE_URL_TYPED_STRUCT)) {
+          com.github.xds.type.v3.TypedStruct newTypedStruct =
+              anyConfig.unpack(com.github.xds.type.v3.TypedStruct.class);
+          typeUrl = newTypedStruct.getTypeUrl();
+          rawConfig = newTypedStruct.getValue();
+        }
+      } catch (InvalidProtocolBufferException e) {
+        return StructOrError.fromError(
+            "FilterConfig [" + name + "] contains invalid proto: " + e);
+      }
+      Filter.Provider provider = filterRegistry.get(typeUrl);
+      if (provider == null) {
+        if (isOptional) {
+          continue;
+        }
+        return StructOrError.fromError(
+            "HttpFilter [" + name + "](" + typeUrl + ") is required but unsupported");
+      }
+      ConfigOrError<? extends Filter.FilterConfig> filterConfig =
+          provider.parseFilterConfigOverride(rawConfig);
+      if (filterConfig.errorDetail != null) {
+        return StructOrError.fromError(
+            "Invalid filter config for HttpFilter [" + name + "]: " + filterConfig.errorDetail);
+      }
+      overrideConfigs.put(name, filterConfig.config);
+    }
+    return StructOrError.fromStruct(overrideConfigs);
+  }
+
+  @VisibleForTesting
+  @Nullable
+  static StructOrError<Route> parseRoute(
+      io.envoyproxy.envoy.config.route.v3.Route proto, FilterRegistry filterRegistry,
+      Map<String, PluginConfig> pluginConfigMap,
+      Set<String> optionalPlugins, XdsResourceType.Args args) {
+    StructOrError<RouteMatch> routeMatch = parseRouteMatch(proto.getMatch());
+    if (routeMatch == null) {
+      return null;
+    }
+    if (routeMatch.getErrorDetail() != null) {
+      return StructOrError.fromError(
+          "Route [" + proto.getName() + "] contains invalid RouteMatch: "
+              + routeMatch.getErrorDetail());
+    }
+
+    StructOrError<Map<String, FilterConfig>> overrideConfigsOrError =
+        parseOverrideFilterConfigs(proto.getTypedPerFilterConfigMap(), filterRegistry);
+    if (overrideConfigsOrError.getErrorDetail() != null) {
+      return StructOrError.fromError(
+          "Route [" + proto.getName() + "] contains invalid HttpFilter config: "
+              + overrideConfigsOrError.getErrorDetail());
+    }
+    Map<String, FilterConfig> overrideConfigs = overrideConfigsOrError.getStruct();
+
+    switch (proto.getActionCase()) {
+      case ROUTE:
+        StructOrError<RouteAction> routeAction =
+            parseRouteAction(proto.getRoute(), filterRegistry, pluginConfigMap,
+                optionalPlugins, args);
+        if (routeAction == null) {
+          return null;
+        }
+        if (routeAction.getErrorDetail() != null) {
+          return StructOrError.fromError(
+              "Route [" + proto.getName() + "] contains invalid RouteAction: "
+                  + routeAction.getErrorDetail());
+        }
+        return StructOrError.fromStruct(
+            Route.forAction(routeMatch.getStruct(), routeAction.getStruct(), overrideConfigs));
+      case NON_FORWARDING_ACTION:
+        return StructOrError.fromStruct(
+            Route.forNonForwardingAction(routeMatch.getStruct(), overrideConfigs));
+      case REDIRECT:
+      case DIRECT_RESPONSE:
+      case FILTER_ACTION:
+      case ACTION_NOT_SET:
+      default:
+        return StructOrError.fromError(
+            "Route [" + proto.getName() + "] with unknown action type: " + proto.getActionCase());
+    }
+  }
+
+  @VisibleForTesting
+  @Nullable
+  static StructOrError<RouteMatch> parseRouteMatch(
+      io.envoyproxy.envoy.config.route.v3.RouteMatch proto) {
+    if (proto.getQueryParametersCount() != 0) {
+      return null;
+    }
+    StructOrError<PathMatcher> pathMatch = parsePathMatcher(proto);
+    if (pathMatch.getErrorDetail() != null) {
+      return StructOrError.fromError(pathMatch.getErrorDetail());
+    }
+
+    FractionMatcher fractionMatch = null;
+    if (proto.hasRuntimeFraction()) {
+      StructOrError<FractionMatcher> parsedFraction =
+          parseFractionMatcher(proto.getRuntimeFraction().getDefaultValue());
+      if (parsedFraction.getErrorDetail() != null) {
+        return StructOrError.fromError(parsedFraction.getErrorDetail());
+      }
+      fractionMatch = parsedFraction.getStruct();
+    }
+
+    List<HeaderMatcher> headerMatchers = new ArrayList<>();
+    for (io.envoyproxy.envoy.config.route.v3.HeaderMatcher hmProto : proto.getHeadersList()) {
+      StructOrError<HeaderMatcher> headerMatcher = parseHeaderMatcher(hmProto);
+      if (headerMatcher.getErrorDetail() != null) {
+        return StructOrError.fromError(headerMatcher.getErrorDetail());
+      }
+      headerMatchers.add(headerMatcher.getStruct());
+    }
+
+    return StructOrError.fromStruct(RouteMatch.create(
+        pathMatch.getStruct(), headerMatchers, fractionMatch));
+  }
+
+  @VisibleForTesting
+  static StructOrError<PathMatcher> parsePathMatcher(
+      io.envoyproxy.envoy.config.route.v3.RouteMatch proto) {
+    boolean caseSensitive = proto.getCaseSensitive().getValue();
+    switch (proto.getPathSpecifierCase()) {
+      case PREFIX:
+        return StructOrError.fromStruct(
+            PathMatcher.fromPrefix(proto.getPrefix(), caseSensitive));
+      case PATH:
+        return StructOrError.fromStruct(PathMatcher.fromPath(proto.getPath(), caseSensitive));
+      case SAFE_REGEX:
+        String rawPattern = proto.getSafeRegex().getRegex();
+        Pattern safeRegEx;
+        try {
+          safeRegEx = Pattern.compile(rawPattern);
+        } catch (PatternSyntaxException e) {
+          return StructOrError.fromError("Malformed safe regex pattern: " + e.getMessage());
+        }
+        return StructOrError.fromStruct(PathMatcher.fromRegEx(safeRegEx));
+      case PATHSPECIFIER_NOT_SET:
+      default:
+        return StructOrError.fromError("Unknown path match type");
+    }
+  }
+
+  private static StructOrError<FractionMatcher> parseFractionMatcher(FractionalPercent proto) {
+    int numerator = proto.getNumerator();
+    int denominator = 0;
+    switch (proto.getDenominator()) {
+      case HUNDRED:
+        denominator = 100;
+        break;
+      case TEN_THOUSAND:
+        denominator = 10_000;
+        break;
+      case MILLION:
+        denominator = 1_000_000;
+        break;
+      case UNRECOGNIZED:
+      default:
+        return StructOrError.fromError(
+            "Unrecognized fractional percent denominator: " + proto.getDenominator());
+    }
+    return StructOrError.fromStruct(FractionMatcher.create(numerator, denominator));
+  }
+
+  @VisibleForTesting
+  static StructOrError<HeaderMatcher> parseHeaderMatcher(
+      io.envoyproxy.envoy.config.route.v3.HeaderMatcher proto) {
+    try {
+      Matchers.HeaderMatcher headerMatcher = MatcherParser.parseHeaderMatcher(proto);
+      return StructOrError.fromStruct(headerMatcher);
+    } catch (IllegalArgumentException e) {
+      return StructOrError.fromError(e.getMessage());
+    }
+  }
+
+  /**
+   * Parses the RouteAction config. The returned result may contain a (parsed form)
+   * {@link RouteAction} or an error message. Returns {@code null} if the RouteAction
+   * should be ignored.
+   */
+  @VisibleForTesting
+  @Nullable
+  static StructOrError<RouteAction> parseRouteAction(
+      io.envoyproxy.envoy.config.route.v3.RouteAction proto, FilterRegistry filterRegistry,
+      Map<String, PluginConfig> pluginConfigMap,
+      Set<String> optionalPlugins, XdsResourceType.Args args) {
+    Long timeoutNano = null;
+    if (proto.hasMaxStreamDuration()) {
+      io.envoyproxy.envoy.config.route.v3.RouteAction.MaxStreamDuration maxStreamDuration
+          = proto.getMaxStreamDuration();
+      if (maxStreamDuration.hasGrpcTimeoutHeaderMax()) {
+        timeoutNano = Durations.toNanos(maxStreamDuration.getGrpcTimeoutHeaderMax());
+      } else if (maxStreamDuration.hasMaxStreamDuration()) {
+        timeoutNano = Durations.toNanos(maxStreamDuration.getMaxStreamDuration());
+      }
+    }
+    RetryPolicy retryPolicy = null;
+    if (proto.hasRetryPolicy()) {
+      StructOrError<RetryPolicy> retryPolicyOrError = parseRetryPolicy(proto.getRetryPolicy());
+      if (retryPolicyOrError != null) {
+        if (retryPolicyOrError.getErrorDetail() != null) {
+          return StructOrError.fromError(retryPolicyOrError.getErrorDetail());
+        }
+        retryPolicy = retryPolicyOrError.getStruct();
+      }
+    }
+    List<HashPolicy> hashPolicies = new ArrayList<>();
+    for (io.envoyproxy.envoy.config.route.v3.RouteAction.HashPolicy config
+        : proto.getHashPolicyList()) {
+      HashPolicy policy = null;
+      boolean terminal = config.getTerminal();
+      switch (config.getPolicySpecifierCase()) {
+        case HEADER:
+          io.envoyproxy.envoy.config.route.v3.RouteAction.HashPolicy.Header headerCfg =
+              config.getHeader();
+          Pattern regEx = null;
+          String regExSubstitute = null;
+          if (headerCfg.hasRegexRewrite() && headerCfg.getRegexRewrite().hasPattern()) {
+            regEx = Pattern.compile(headerCfg.getRegexRewrite().getPattern().getRegex());
+            regExSubstitute = headerCfg.getRegexRewrite().getSubstitution();
+          }
+          policy = HashPolicy.forHeader(
+              terminal, headerCfg.getHeaderName(), regEx, regExSubstitute);
+          break;
+        case FILTER_STATE:
+          if (config.getFilterState().getKey().equals(HASH_POLICY_FILTER_STATE_KEY)) {
+            policy = HashPolicy.forChannelId(terminal);
+          }
+          break;
+        default:
+          // Ignore
+      }
+      if (policy != null) {
+        hashPolicies.add(policy);
+      }
+    }
+
+    switch (proto.getClusterSpecifierCase()) {
+      case CLUSTER:
+        return StructOrError.fromStruct(RouteAction.forCluster(
+            proto.getCluster(), hashPolicies, timeoutNano, retryPolicy,
+            isXdsAuthorityRewriteEnabled && args.getServerInfo().isTrustedXdsServer()
+                && proto.getAutoHostRewrite().getValue()));
+      case CLUSTER_HEADER:
+        return null;
+      case WEIGHTED_CLUSTERS:
+        List<io.envoyproxy.envoy.config.route.v3.WeightedCluster.ClusterWeight> clusterWeights
+            = proto.getWeightedClusters().getClustersList();
+        if (clusterWeights.isEmpty()) {
+          return StructOrError.fromError("No cluster found in weighted cluster list");
+        }
+        List<ClusterWeight> weightedClusters = new ArrayList<>();
+        long clusterWeightSum = 0;
+        for (io.envoyproxy.envoy.config.route.v3.WeightedCluster.ClusterWeight clusterWeight
+            : clusterWeights) {
+          StructOrError<ClusterWeight> clusterWeightOrError =
+              parseClusterWeight(clusterWeight, filterRegistry);
+          if (clusterWeightOrError.getErrorDetail() != null) {
+            return StructOrError.fromError("RouteAction contains invalid ClusterWeight: "
+                + clusterWeightOrError.getErrorDetail());
+          }
+          ClusterWeight parsedWeight = clusterWeightOrError.getStruct();
+          clusterWeightSum += parsedWeight.weight();
+          weightedClusters.add(parsedWeight);
+        }
+        if (clusterWeightSum <= 0) {
+          return StructOrError.fromError("Sum of cluster weights should be above 0.");
+        }
+        if (clusterWeightSum > UnsignedInteger.MAX_VALUE.longValue()) {
+          return StructOrError.fromError(String.format(
+              "Sum of cluster weights should be less than the maximum unsigned integer (%d), but"
+                  + " was %d. ",
+              UnsignedInteger.MAX_VALUE.longValue(), clusterWeightSum));
+        }
+        return StructOrError.fromStruct(VirtualHost.Route.RouteAction.forWeightedClusters(
+            weightedClusters, hashPolicies, timeoutNano, retryPolicy,
+            isXdsAuthorityRewriteEnabled && args.getServerInfo().isTrustedXdsServer()
+                && proto.getAutoHostRewrite().getValue()));
+      case CLUSTER_SPECIFIER_PLUGIN:
+        if (enableRouteLookup) {
+          String pluginName = proto.getClusterSpecifierPlugin();
+          PluginConfig pluginConfig = pluginConfigMap.get(pluginName);
+          if (pluginConfig == null) {
+            // Skip route if the plugin is not registered, but it is optional.
+            if (optionalPlugins.contains(pluginName)) {
+              return null;
+            }
+            return StructOrError.fromError(
+                "ClusterSpecifierPlugin for [" + pluginName + "] not found");
+          }
+          NamedPluginConfig namedPluginConfig = NamedPluginConfig.create(pluginName, pluginConfig);
+          return StructOrError.fromStruct(VirtualHost.Route.RouteAction.forClusterSpecifierPlugin(
+              namedPluginConfig, hashPolicies, timeoutNano, retryPolicy,
+              isXdsAuthorityRewriteEnabled && args.getServerInfo().isTrustedXdsServer()
+                  && proto.getAutoHostRewrite().getValue()));
+        } else {
+          return null;
+        }
+      case CLUSTERSPECIFIER_NOT_SET:
+      default:
+        return null;
+    }
+  }
+
+  @Nullable // Return null if we ignore the given policy.
+  private static StructOrError<VirtualHost.Route.RouteAction.RetryPolicy> parseRetryPolicy(
+      io.envoyproxy.envoy.config.route.v3.RetryPolicy retryPolicyProto) {
+    int maxAttempts = 2;
+    if (retryPolicyProto.hasNumRetries()) {
+      maxAttempts = retryPolicyProto.getNumRetries().getValue() + 1;
+    }
+    Duration initialBackoff = Durations.fromMillis(25);
+    Duration maxBackoff = Durations.fromMillis(250);
+    if (retryPolicyProto.hasRetryBackOff()) {
+      RetryBackOff retryBackOff = retryPolicyProto.getRetryBackOff();
+      if (!retryBackOff.hasBaseInterval()) {
+        return StructOrError.fromError("No base_interval specified in retry_backoff");
+      }
+      Duration originalInitialBackoff = initialBackoff = retryBackOff.getBaseInterval();
+      if (Durations.compare(initialBackoff, Durations.ZERO) <= 0) {
+        return StructOrError.fromError("base_interval in retry_backoff must be positive");
+      }
+      if (Durations.compare(initialBackoff, Durations.fromMillis(1)) < 0) {
+        initialBackoff = Durations.fromMillis(1);
+      }
+      if (retryBackOff.hasMaxInterval()) {
+        maxBackoff = retryPolicyProto.getRetryBackOff().getMaxInterval();
+        if (Durations.compare(maxBackoff, originalInitialBackoff) < 0) {
+          return StructOrError.fromError(
+              "max_interval in retry_backoff cannot be less than base_interval");
+        }
+        if (Durations.compare(maxBackoff, Durations.fromMillis(1)) < 0) {
+          maxBackoff = Durations.fromMillis(1);
+        }
+      } else {
+        maxBackoff = Durations.fromNanos(Durations.toNanos(initialBackoff) * 10);
+      }
+    }
+    Iterable<String> retryOns =
+        Splitter.on(',').omitEmptyStrings().trimResults().split(retryPolicyProto.getRetryOn());
+    ImmutableList.Builder<Status.Code> retryableStatusCodesBuilder = ImmutableList.builder();
+    for (String retryOn : retryOns) {
+      Status.Code code;
+      try {
+        code = Status.Code.valueOf(retryOn.toUpperCase(Locale.US).replace('-', '_'));
+      } catch (IllegalArgumentException e) {
+        // unsupported value, such as "5xx"
+        continue;
+      }
+      if (!SUPPORTED_RETRYABLE_CODES.contains(code)) {
+        // unsupported value
+        continue;
+      }
+      retryableStatusCodesBuilder.add(code);
+    }
+    List<Status.Code> retryableStatusCodes = retryableStatusCodesBuilder.build();
+    return StructOrError.fromStruct(
+        VirtualHost.Route.RouteAction.RetryPolicy.create(
+            maxAttempts, retryableStatusCodes, initialBackoff, maxBackoff,
+            /* perAttemptRecvTimeout= */ null));
+  }
+
+  @VisibleForTesting
+  static StructOrError<VirtualHost.Route.RouteAction.ClusterWeight> parseClusterWeight(
+      io.envoyproxy.envoy.config.route.v3.WeightedCluster.ClusterWeight proto,
+      FilterRegistry filterRegistry) {
+    StructOrError<Map<String, Filter.FilterConfig>> overrideConfigs =
+        parseOverrideFilterConfigs(proto.getTypedPerFilterConfigMap(), filterRegistry);
+    if (overrideConfigs.getErrorDetail() != null) {
+      return StructOrError.fromError(
+          "ClusterWeight [" + proto.getName() + "] contains invalid HttpFilter config: "
+              + overrideConfigs.getErrorDetail());
+    }
+    return StructOrError.fromStruct(VirtualHost.Route.RouteAction.ClusterWeight.create(
+        proto.getName(),
+        Integer.toUnsignedLong(proto.getWeight().getValue()),
+        overrideConfigs.getStruct()));
+  }
+
+  @Nullable // null if the plugin is not supported, but it's marked as optional.
+  private static PluginConfig parseClusterSpecifierPlugin(ClusterSpecifierPlugin pluginProto)
+      throws ResourceInvalidException {
+    return parseClusterSpecifierPlugin(
+        pluginProto, ClusterSpecifierPluginRegistry.getDefaultRegistry());
+  }
+
+  @Nullable // null if the plugin is not supported, but it's marked as optional.
+  @VisibleForTesting
+  static PluginConfig parseClusterSpecifierPlugin(
+      ClusterSpecifierPlugin pluginProto, ClusterSpecifierPluginRegistry registry)
+      throws ResourceInvalidException {
+    TypedExtensionConfig extension = pluginProto.getExtension();
+    String pluginName = extension.getName();
+    Any anyConfig = extension.getTypedConfig();
+    String typeUrl = anyConfig.getTypeUrl();
+    Message rawConfig = anyConfig;
+    if (typeUrl.equals(TYPE_URL_TYPED_STRUCT_UDPA) || typeUrl.equals(TYPE_URL_TYPED_STRUCT)) {
+      try {
+        TypedStruct typedStruct = unpackCompatibleType(
+            anyConfig, TypedStruct.class, TYPE_URL_TYPED_STRUCT_UDPA, TYPE_URL_TYPED_STRUCT);
+        typeUrl = typedStruct.getTypeUrl();
+        rawConfig = typedStruct.getValue();
+      } catch (InvalidProtocolBufferException e) {
+        throw new ResourceInvalidException(
+            "ClusterSpecifierPlugin [" + pluginName + "] contains invalid proto", e);
+      }
+    }
+    io.grpc.xds.ClusterSpecifierPlugin plugin = registry.get(typeUrl);
+    if (plugin == null) {
+      if (!pluginProto.getIsOptional()) {
+        throw new ResourceInvalidException("Unsupported ClusterSpecifierPlugin type: " + typeUrl);
+      }
+      return null;
+    }
+    ConfigOrError<? extends PluginConfig> pluginConfigOrError = plugin.parsePlugin(rawConfig);
+    if (pluginConfigOrError.errorDetail != null) {
+      throw new ResourceInvalidException(pluginConfigOrError.errorDetail);
+    }
+    return pluginConfigOrError.config;
+  }
+
+  static final class RdsUpdate implements ResourceUpdate {
+    // The list virtual hosts that make up the route table.
+    final List<VirtualHost> virtualHosts;
+
+    RdsUpdate(List<VirtualHost> virtualHosts) {
+      this.virtualHosts = Collections.unmodifiableList(
+          new ArrayList<>(checkNotNull(virtualHosts, "virtualHosts")));
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("virtualHosts", virtualHosts)
+          .toString();
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(virtualHosts);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      RdsUpdate that = (RdsUpdate) o;
+      return Objects.equals(virtualHosts, that.virtualHosts);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsServerBuilder.java b/xds/src/main/java/io/grpc/xds/XdsServerBuilder.java
new file mode 100644
index 00000000000..4a4fb71aa84
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsServerBuilder.java
@@ -0,0 +1,200 @@
+/*
+ * Copyright 2019 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.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.xds.XdsAttributes.ATTR_DRAIN_GRACE_NANOS;
+import static io.grpc.xds.XdsAttributes.ATTR_FILTER_CHAIN_SELECTOR_MANAGER;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.errorprone.annotations.DoNotCall;
+import io.grpc.Attributes;
+import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingServerBuilder;
+import io.grpc.Internal;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCredentials;
+import io.grpc.netty.InternalNettyServerBuilder;
+import io.grpc.netty.InternalNettyServerCredentials;
+import io.grpc.netty.InternalProtocolNegotiator;
+import io.grpc.netty.NettyServerBuilder;
+import io.grpc.xds.FilterChainMatchingProtocolNegotiators.FilterChainMatchingNegotiatorServerFactory;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Logger;
+
+/**
+ * A version of {@link ServerBuilder} to create xDS managed servers.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7514")
+public final class XdsServerBuilder extends ForwardingServerBuilder<XdsServerBuilder> {
+  private static final long AS_LARGE_AS_INFINITE = TimeUnit.DAYS.toNanos(1000);
+
+  private final NettyServerBuilder delegate;
+  private final int port;
+  private XdsServingStatusListener xdsServingStatusListener;
+  private AtomicBoolean isServerBuilt = new AtomicBoolean(false);
+  private final FilterRegistry filterRegistry = FilterRegistry.getDefaultRegistry();
+  private XdsClientPoolFactory xdsClientPoolFactory =
+          SharedXdsClientPoolProvider.getDefaultProvider();
+  private Map<String, ?> bootstrapOverride;
+  private long drainGraceTime = 10;
+  private TimeUnit drainGraceTimeUnit = TimeUnit.MINUTES;
+
+  private XdsServerBuilder(NettyServerBuilder nettyDelegate, int port) {
+    this.delegate = nettyDelegate;
+    this.port = port;
+    xdsServingStatusListener = new DefaultListener("port:" + port);
+  }
+
+  @Override
+  @Internal
+  protected ServerBuilder<?> delegate() {
+    checkState(!isServerBuilt.get(), "Server already built!");
+    return delegate;
+  }
+
+  /** Set the {@link XdsServingStatusListener} to receive "serving" and "not serving" states. */
+  public XdsServerBuilder xdsServingStatusListener(
+      XdsServingStatusListener xdsServingStatusListener) {
+    this.xdsServingStatusListener =
+        checkNotNull(xdsServingStatusListener, "xdsServingStatusListener");
+    return this;
+  }
+
+  /**
+   * Sets the grace time when draining connections with outdated configuration. When an xDS config
+   * update changes connection configuration, pre-existing connections stop accepting new RPCs to be
+   * replaced by new connections. RPCs on those pre-existing connections have the grace time to
+   * complete. RPCs that do not complete in time will be cancelled, allowing the connection to
+   * terminate. {@code Long.MAX_VALUE} nano seconds or an unreasonably large value are considered
+   * infinite. The default is 10 minutes.
+   */
+  public XdsServerBuilder drainGraceTime(long drainGraceTime, TimeUnit drainGraceTimeUnit) {
+    checkArgument(drainGraceTime >= 0, "drain grace time must be non-negative: %s",
+        drainGraceTime);
+    checkNotNull(drainGraceTimeUnit, "drainGraceTimeUnit");
+    if (drainGraceTimeUnit.toNanos(drainGraceTime) >= AS_LARGE_AS_INFINITE) {
+      drainGraceTimeUnit = null;
+    }
+    this.drainGraceTime = drainGraceTime;
+    this.drainGraceTimeUnit = drainGraceTimeUnit;
+    return this;
+  }
+
+  @DoNotCall("Unsupported. Use forPort(int, ServerCredentials) instead")
+  public static ServerBuilder<?> forPort(int port) {
+    throw new UnsupportedOperationException(
+            "Unsupported call - use forPort(int, ServerCredentials)");
+  }
+
+  /** Creates a gRPC server builder for the given port. */
+  public static XdsServerBuilder forPort(int port, ServerCredentials serverCredentials) {
+    checkNotNull(serverCredentials, "serverCredentials");
+    InternalProtocolNegotiator.ServerFactory originalNegotiatorFactory =
+            InternalNettyServerCredentials.toNegotiator(serverCredentials);
+    ServerCredentials wrappedCredentials = InternalNettyServerCredentials.create(
+            new FilterChainMatchingNegotiatorServerFactory(originalNegotiatorFactory));
+    NettyServerBuilder nettyDelegate = NettyServerBuilder.forPort(port, wrappedCredentials);
+    return new XdsServerBuilder(nettyDelegate, port);
+  }
+
+  @Override
+  public Server build() {
+    checkState(isServerBuilt.compareAndSet(false, true), "Server already built!");
+    FilterChainSelectorManager filterChainSelectorManager = new FilterChainSelectorManager();
+    Attributes.Builder builder = Attributes.newBuilder()
+            .set(ATTR_FILTER_CHAIN_SELECTOR_MANAGER, filterChainSelectorManager);
+    if (drainGraceTimeUnit != null) {
+      builder.set(ATTR_DRAIN_GRACE_NANOS, drainGraceTimeUnit.toNanos(drainGraceTime));
+    }
+    InternalNettyServerBuilder.eagAttributes(delegate, builder.build());
+    return new XdsServerWrapper("0.0.0.0:" + port, delegate, xdsServingStatusListener,
+            filterChainSelectorManager, xdsClientPoolFactory, bootstrapOverride, filterRegistry);
+  }
+
+  @VisibleForTesting
+  XdsServerBuilder xdsClientPoolFactory(XdsClientPoolFactory xdsClientPoolFactory) {
+    this.xdsClientPoolFactory = checkNotNull(xdsClientPoolFactory, "xdsClientPoolFactory");
+    return this;
+  }
+
+  /**
+   * Allows providing bootstrap override, useful for testing.
+   */
+  public XdsServerBuilder overrideBootstrapForTest(Map<String, ?> bootstrapOverride) {
+    this.bootstrapOverride = checkNotNull(bootstrapOverride, "bootstrapOverride");
+    if (this.xdsClientPoolFactory == SharedXdsClientPoolProvider.getDefaultProvider()) {
+      this.xdsClientPoolFactory = new SharedXdsClientPoolProvider();
+    }
+    return this;
+  }
+
+  /**
+   * Returns the delegate {@link NettyServerBuilder} to allow experimental level
+   * transport-specific configuration. Note this API will always be experimental.
+   */
+  public ServerBuilder<?> transportBuilder() {
+    return delegate;
+  }
+
+  /**
+   * Applications can register this listener to receive "serving" and "not serving" states of
+   * the server using {@link #xdsServingStatusListener(XdsServingStatusListener)}.
+   */
+  public interface XdsServingStatusListener {
+
+    /** Callback invoked when server begins serving. */
+    void onServing();
+
+    /** Callback invoked when server is forced to be "not serving" due to an error.
+     * @param throwable cause of the error
+     */
+    void onNotServing(Throwable throwable);
+  }
+
+  /** Default implementation of {@link XdsServingStatusListener} that logs at WARNING level. */
+  private static class DefaultListener implements XdsServingStatusListener {
+    private final Logger logger;
+    private final String prefix;
+    boolean notServingDueToError;
+
+    DefaultListener(String prefix) {
+      logger = Logger.getLogger(DefaultListener.class.getName());
+      this.prefix = prefix;
+    }
+
+    /** Log calls to onServing() following a call to onNotServing() at WARNING level. */
+    @Override
+    public void onServing() {
+      if (notServingDueToError) {
+        notServingDueToError = false;
+        logger.warning("[" + prefix + "] Entering serving state.");
+      }
+    }
+
+    @Override
+    public void onNotServing(Throwable throwable) {
+      logger.warning("[" + prefix + "] " + throwable.getMessage());
+      notServingDueToError = true;
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsServerCredentials.java b/xds/src/main/java/io/grpc/xds/XdsServerCredentials.java
new file mode 100644
index 00000000000..2212e7a1855
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsServerCredentials.java
@@ -0,0 +1,45 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.ExperimentalApi;
+import io.grpc.ServerCredentials;
+import io.grpc.netty.InternalNettyServerCredentials;
+import io.grpc.netty.InternalProtocolNegotiator;
+import io.grpc.xds.internal.security.SecurityProtocolNegotiators;
+
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/7514")
+public class XdsServerCredentials {
+  private XdsServerCredentials() {} // prevent instantiation
+
+  /**
+   * Creates credentials to be configured by xDS, falling back to other credentials if no
+   * TLS configuration is provided by xDS.
+   *
+   * @param fallback Credentials to fall back to.
+   *
+   * @throws IllegalArgumentException if fallback is unable to be used
+   */
+  public static ServerCredentials create(ServerCredentials fallback) {
+    InternalProtocolNegotiator.ServerFactory fallbackNegotiator =
+        InternalNettyServerCredentials.toNegotiator(checkNotNull(fallback, "fallback"));
+    return InternalNettyServerCredentials.create(
+        SecurityProtocolNegotiators.serverProtocolNegotiatorFactory(fallbackNegotiator));
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/XdsServerWrapper.java b/xds/src/main/java/io/grpc/xds/XdsServerWrapper.java
new file mode 100644
index 00000000000..5529f96c7a2
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/XdsServerWrapper.java
@@ -0,0 +1,958 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.xds.client.Bootstrapper.XDSTP_SCHEME;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.net.HostAndPort;
+import com.google.common.net.InetAddresses;
+import com.google.common.util.concurrent.SettableFuture;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress.Protocol;
+import io.grpc.Attributes;
+import io.grpc.InternalServerInterceptors;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MetricRecorder;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCall;
+import io.grpc.ServerCall.Listener;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.StatusOr;
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.SharedResourceHolder;
+import io.grpc.xds.EnvoyServerProtoData.FilterChain;
+import io.grpc.xds.Filter.FilterConfig;
+import io.grpc.xds.Filter.NamedFilterConfig;
+import io.grpc.xds.FilterChainMatchingProtocolNegotiators.FilterChainMatchingHandler.FilterChainSelector;
+import io.grpc.xds.ThreadSafeRandom.ThreadSafeRandomImpl;
+import io.grpc.xds.VirtualHost.Route;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.XdsRouteConfigureResource.RdsUpdate;
+import io.grpc.xds.XdsServerBuilder.XdsServingStatusListener;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsClient.ResourceWatcher;
+import io.grpc.xds.internal.security.SslContextProviderSupplier;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+final class XdsServerWrapper extends Server {
+  private static final Logger logger = Logger.getLogger(XdsServerWrapper.class.getName());
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          logger.log(Level.SEVERE, "Exception!" + e);
+          // TODO(chengyuanzhang): implement cleanup.
+        }
+      });
+
+  public static final Attributes.Key<AtomicReference<ServerRoutingConfig>>
+      ATTR_SERVER_ROUTING_CONFIG =
+      Attributes.Key.create("io.grpc.xds.ServerWrapper.serverRoutingConfig");
+
+  @VisibleForTesting
+  static final long RETRY_DELAY_NANOS = TimeUnit.MINUTES.toNanos(1);
+  private final String listenerAddress;
+  private final ServerBuilder<?> delegateBuilder;
+  private boolean sharedTimeService;
+  private final ScheduledExecutorService timeService;
+  private final FilterRegistry filterRegistry;
+  private final ThreadSafeRandom random = ThreadSafeRandomImpl.instance;
+  private final XdsClientPoolFactory xdsClientPoolFactory;
+  private final @Nullable Map<String, ?> bootstrapOverride;
+  private final XdsServingStatusListener listener;
+  private final FilterChainSelectorManager filterChainSelectorManager;
+  private final AtomicBoolean started = new AtomicBoolean(false);
+  private final AtomicBoolean shutdown = new AtomicBoolean(false);
+  private boolean isServing;
+  private final CountDownLatch internalTerminationLatch = new CountDownLatch(1);
+  private final SettableFuture<Exception> initialStartFuture = SettableFuture.create();
+  private boolean initialStarted;
+  private ScheduledHandle restartTimer;
+  private ObjectPool<XdsClient> xdsClientPool;
+  private XdsClient xdsClient;
+  private DiscoveryState discoveryState;
+  private volatile Server delegate;
+
+  // Must be accessed in syncContext.
+  // Filter instances are unique per Server, per FilterChain, and per filter's name+typeUrl.
+  // FilterChain.name -> <NamedFilterConfig.filterStateKey -> filter_instance>.
+  private final HashMap<String, HashMap<String, Filter>> activeFilters = new HashMap<>();
+  // Default filter chain Filter instances are unique per Server, and per filter's name+typeUrl.
+  // NamedFilterConfig.filterStateKey -> filter_instance.
+  private final HashMap<String, Filter> activeFiltersDefaultChain = new HashMap<>();
+
+  XdsServerWrapper(
+      String listenerAddress,
+      ServerBuilder<?> delegateBuilder,
+      XdsServingStatusListener listener,
+      FilterChainSelectorManager filterChainSelectorManager,
+      XdsClientPoolFactory xdsClientPoolFactory,
+      @Nullable Map<String, ?> bootstrapOverride,
+      FilterRegistry filterRegistry) {
+    this(
+        listenerAddress,
+        delegateBuilder,
+        listener,
+        filterChainSelectorManager,
+        xdsClientPoolFactory,
+        bootstrapOverride,
+        filterRegistry,
+        SharedResourceHolder.get(GrpcUtil.TIMER_SERVICE));
+    sharedTimeService = true;
+  }
+
+  @VisibleForTesting
+  XdsServerWrapper(
+          String listenerAddress,
+          ServerBuilder<?> delegateBuilder,
+          XdsServingStatusListener listener,
+          FilterChainSelectorManager filterChainSelectorManager,
+          XdsClientPoolFactory xdsClientPoolFactory,
+          @Nullable Map<String, ?> bootstrapOverride,
+          FilterRegistry filterRegistry,
+          ScheduledExecutorService timeService) {
+    this.listenerAddress = checkNotNull(listenerAddress, "listenerAddress");
+    this.delegateBuilder = checkNotNull(delegateBuilder, "delegateBuilder");
+    this.delegateBuilder.intercept(new ConfigApplyingInterceptor());
+    this.listener = checkNotNull(listener, "listener");
+    this.filterChainSelectorManager
+        = checkNotNull(filterChainSelectorManager, "filterChainSelectorManager");
+    this.xdsClientPoolFactory = checkNotNull(xdsClientPoolFactory, "xdsClientPoolFactory");
+    this.bootstrapOverride = bootstrapOverride;
+    this.timeService = checkNotNull(timeService, "timeService");
+    this.filterRegistry = checkNotNull(filterRegistry,"filterRegistry");
+    this.delegate = delegateBuilder.build();
+  }
+
+  @Override
+  public Server start() throws IOException {
+    checkState(started.compareAndSet(false, true), "Already started");
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        internalStart();
+      }
+    });
+    Exception exception;
+    try {
+      exception = initialStartFuture.get();
+    } catch (InterruptedException | ExecutionException e) {
+      throw new RuntimeException(e);
+    }
+    if (exception != null) {
+      throw (exception instanceof IOException) ? (IOException) exception :
+              new IOException(exception);
+    }
+    return this;
+  }
+
+  private void internalStart() {
+    try {
+      BootstrapInfo bootstrapInfo;
+      if (bootstrapOverride == null) {
+        bootstrapInfo = GrpcBootstrapperImpl.defaultBootstrap();
+      } else {
+        bootstrapInfo = new GrpcBootstrapperImpl().bootstrap(bootstrapOverride);
+      }
+      xdsClientPool = xdsClientPoolFactory.getOrCreate(
+          "#server", bootstrapInfo, new MetricRecorder() {});
+    } catch (Exception e) {
+      StatusException statusException = Status.UNAVAILABLE.withDescription(
+              "Failed to initialize xDS").withCause(e).asException();
+      listener.onNotServing(statusException);
+      initialStartFuture.set(statusException);
+      return;
+    }
+    xdsClient = xdsClientPool.getObject();
+    String listenerTemplate = xdsClient.getBootstrapInfo().serverListenerResourceNameTemplate();
+    if (listenerTemplate == null) {
+      StatusException statusException =
+          Status.UNAVAILABLE.withDescription(
+              "Can only support xDS v3 with listener resource name template").asException();
+      listener.onNotServing(statusException);
+      initialStartFuture.set(statusException);
+      xdsClient = xdsClientPool.returnObject(xdsClient);
+      return;
+    }
+    String replacement = listenerAddress;
+    if (listenerTemplate.startsWith(XDSTP_SCHEME)) {
+      replacement = XdsClient.percentEncodePath(replacement);
+    }
+    discoveryState = new DiscoveryState(listenerTemplate.replaceAll("%s", replacement));
+  }
+
+  @Override
+  public Server shutdown() {
+    if (!shutdown.compareAndSet(false, true)) {
+      return this;
+    }
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        if (!delegate.isShutdown()) {
+          delegate.shutdown();
+        }
+        internalShutdown();
+      }
+    });
+    return this;
+  }
+
+  @Override
+  public Server shutdownNow() {
+    if (!shutdown.compareAndSet(false, true)) {
+      return this;
+    }
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        if (!delegate.isShutdown()) {
+          delegate.shutdownNow();
+        }
+        internalShutdown();
+        initialStartFuture.set(new IOException("server is forcefully shut down"));
+      }
+    });
+    return this;
+  }
+
+  // Must run in SynchronizationContext
+  private void internalShutdown() {
+    logger.log(Level.FINER, "Shutting down XdsServerWrapper");
+    if (discoveryState != null) {
+      discoveryState.shutdown();
+    }
+    if (xdsClient != null) {
+      xdsClient = xdsClientPool.returnObject(xdsClient);
+    }
+    if (restartTimer != null) {
+      restartTimer.cancel();
+    }
+    if (sharedTimeService) {
+      SharedResourceHolder.release(GrpcUtil.TIMER_SERVICE, timeService);
+    }
+    isServing = false;
+    internalTerminationLatch.countDown();
+  }
+
+  @Override
+  public boolean isShutdown() {
+    return shutdown.get();
+  }
+
+  @Override
+  public boolean isTerminated() {
+    return internalTerminationLatch.getCount() == 0 && delegate.isTerminated();
+  }
+
+  @Override
+  public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
+    long startTime = System.nanoTime();
+    if (!internalTerminationLatch.await(timeout, unit)) {
+      return false;
+    }
+    long remainingTime = unit.toNanos(timeout) - (System.nanoTime() - startTime);
+    return delegate.awaitTermination(remainingTime, TimeUnit.NANOSECONDS);
+  }
+
+  @Override
+  public void awaitTermination() throws InterruptedException {
+    internalTerminationLatch.await();
+    delegate.awaitTermination();
+  }
+
+  @Override
+  public int getPort() {
+    return delegate.getPort();
+  }
+
+  @Override
+  public List<? extends SocketAddress> getListenSockets() {
+    return delegate.getListenSockets();
+  }
+
+  @Override
+  public List<ServerServiceDefinition> getServices() {
+    return delegate.getServices();
+  }
+
+  @Override
+  public List<ServerServiceDefinition> getImmutableServices() {
+    return delegate.getImmutableServices();
+  }
+
+  @Override
+  public List<ServerServiceDefinition> getMutableServices() {
+    return delegate.getMutableServices();
+  }
+
+  // Must run in SynchronizationContext
+  private void startDelegateServer() {
+    if (restartTimer != null && restartTimer.isPending()) {
+      return;
+    }
+    if (isServing) {
+      return;
+    }
+    if (delegate.isShutdown()) {
+      delegate = delegateBuilder.build();
+    }
+    try {
+      delegate.start();
+      listener.onServing();
+      isServing = true;
+      if (!initialStarted) {
+        initialStarted = true;
+        initialStartFuture.set(null);
+      }
+      logger.log(Level.FINER, "Delegate server started.");
+    } catch (IOException e) {
+      logger.log(Level.FINE, "Fail to start delegate server: {0}", e);
+      if (!initialStarted) {
+        initialStarted = true;
+        initialStartFuture.set(e);
+      } else {
+        listener.onNotServing(e);
+      }
+      restartTimer = syncContext.schedule(
+        new RestartTask(), RETRY_DELAY_NANOS, TimeUnit.NANOSECONDS, timeService);
+    }
+  }
+
+  private final class RestartTask implements Runnable {
+    @Override
+    public void run() {
+      startDelegateServer();
+    }
+  }
+
+  private final class DiscoveryState implements ResourceWatcher<LdsUpdate> {
+    private final String resourceName;
+    // RDS resource name is the key.
+    private final Map<String, RouteDiscoveryState> routeDiscoveryStates = new HashMap<>();
+    // Track pending RDS resources using rds name.
+    private final Set<String> pendingRds = new HashSet<>();
+    // Most recently discovered filter chains.
+    private List<FilterChain> filterChains = new ArrayList<>();
+    // Most recently discovered default filter chain.
+    @Nullable
+    private FilterChain defaultFilterChain;
+    private boolean stopped;
+    private final Map<FilterChain, AtomicReference<ServerRoutingConfig>> savedRdsRoutingConfigRef 
+        = new HashMap<>();
+    private final ServerInterceptor noopInterceptor = new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+          Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+        return next.startCall(call, headers);
+      }
+    };
+
+    private DiscoveryState(String resourceName) {
+      this.resourceName = checkNotNull(resourceName, "resourceName");
+      xdsClient.watchXdsResource(
+          XdsListenerResource.getInstance(), resourceName, this, syncContext);
+    }
+
+    @Override
+    public void onResourceChanged(final StatusOr<LdsUpdate> update) {
+      if (stopped) {
+        return;
+      }
+
+      if (!update.hasValue()) {
+        Status status = update.getStatus();
+        StatusException statusException = Status.UNAVAILABLE.withDescription(
+                String.format("Listener %s unavailable: %s", resourceName, status.getDescription()))
+            .withCause(status.asException())
+            .asException();
+        handleConfigNotFoundOrMismatch(statusException);
+        return;
+      }
+
+      final LdsUpdate ldsUpdate = update.getValue();
+      logger.log(Level.FINEST, "Received Lds update {0}", ldsUpdate);
+      if (ldsUpdate.listener() == null) {
+        handleConfigNotFoundOrMismatch(
+            Status.NOT_FOUND.withDescription("Listener is null in LdsUpdate").asException());
+        return;
+      }
+      String ldsAddress = ldsUpdate.listener().address();
+      if (ldsAddress == null || ldsUpdate.listener().protocol() != Protocol.TCP
+          || !ipAddressesMatch(ldsAddress)) {
+        handleConfigNotFoundOrMismatch(
+            Status.UNKNOWN.withDescription(
+                String.format(
+                    "Listener address mismatch: expected %s, but got %s.",
+                    listenerAddress, ldsAddress)).asException());
+        return;
+      }
+
+      if (!pendingRds.isEmpty()) {
+        // filter chain state has not yet been applied to filterChainSelectorManager and there
+        releaseSuppliersInFlight();
+        pendingRds.clear();
+      }
+
+      filterChains = ldsUpdate.listener().filterChains();
+      defaultFilterChain = ldsUpdate.listener().defaultFilterChain();
+      updateActiveFilters();
+
+      List<FilterChain> allFilterChains = filterChains;
+      if (defaultFilterChain != null) {
+        allFilterChains = new ArrayList<>(filterChains);
+        allFilterChains.add(defaultFilterChain);
+      }
+
+      Set<String> allRds = new HashSet<>();
+      for (FilterChain filterChain : allFilterChains) {
+        HttpConnectionManager hcm = filterChain.httpConnectionManager();
+        if (hcm.virtualHosts() == null) {
+          RouteDiscoveryState rdsState = routeDiscoveryStates.get(hcm.rdsName());
+          if (rdsState == null) {
+            rdsState = new RouteDiscoveryState(hcm.rdsName());
+            routeDiscoveryStates.put(hcm.rdsName(), rdsState);
+            xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(),
+                hcm.rdsName(), rdsState, syncContext);
+          }
+          if (rdsState.isPending) {
+            pendingRds.add(hcm.rdsName());
+          }
+          allRds.add(hcm.rdsName());
+        }
+      }
+
+      for (Map.Entry<String, RouteDiscoveryState> entry: routeDiscoveryStates.entrySet()) {
+        if (!allRds.contains(entry.getKey())) {
+          xdsClient.cancelXdsResourceWatch(XdsRouteConfigureResource.getInstance(),
+              entry.getKey(), entry.getValue());
+        }
+      }
+      routeDiscoveryStates.keySet().retainAll(allRds);
+      if (pendingRds.isEmpty()) {
+        updateSelector();
+      }
+    }
+
+    @Override
+    public void onAmbientError(final Status error) {
+      if (stopped) {
+        return;
+      }
+      String description = error.getDescription() == null ? "" : error.getDescription() + " ";
+      Status errorWithNodeId = error.withDescription(
+          description + "xDS node ID: " + xdsClient.getBootstrapInfo().node().getId());
+      logger.log(Level.FINE, "Error from XdsClient", errorWithNodeId);
+
+      if (!isServing) {
+        listener.onNotServing(errorWithNodeId.asException());
+      }
+    }
+
+    private boolean ipAddressesMatch(String ldsAddress) {
+      HostAndPort ldsAddressHnP = HostAndPort.fromString(ldsAddress);
+      HostAndPort listenerAddressHnP = HostAndPort.fromString(listenerAddress);
+      if (!ldsAddressHnP.hasPort() || !listenerAddressHnP.hasPort()
+          || ldsAddressHnP.getPort() != listenerAddressHnP.getPort()) {
+        return false;
+      }
+      InetAddress listenerIp = InetAddresses.forString(listenerAddressHnP.getHost());
+      InetAddress ldsIp = InetAddresses.forString(ldsAddressHnP.getHost());
+      return listenerIp.equals(ldsIp);
+    }
+
+    private void shutdown() {
+      stopped = true;
+      cleanUpRouteDiscoveryStates();
+      logger.log(Level.FINE, "Stop watching LDS resource {0}", resourceName);
+      xdsClient.cancelXdsResourceWatch(XdsListenerResource.getInstance(), resourceName, this);
+      shutdownActiveFilters();
+      List<SslContextProviderSupplier> toRelease = getSuppliersInUse();
+      filterChainSelectorManager.updateSelector(FilterChainSelector.NO_FILTER_CHAIN);
+      for (SslContextProviderSupplier s: toRelease) {
+        s.close();
+      }
+      releaseSuppliersInFlight();
+    }
+
+    private void updateSelector() {
+      // This is regenerated in generateRoutingConfig() calls below.
+      savedRdsRoutingConfigRef.clear();
+
+      // Prepare server routing config map.
+      ImmutableMap.Builder<FilterChain, AtomicReference<ServerRoutingConfig>> routingConfigs =
+          ImmutableMap.builder();
+      for (FilterChain filterChain: filterChains) {
+        HashMap<String, Filter> chainFilters = activeFilters.get(filterChain.name());
+        routingConfigs.put(filterChain, generateRoutingConfig(filterChain, chainFilters));
+      }
+
+      // Prepare the new selector.
+      FilterChainSelector selector;
+      if (defaultFilterChain != null) {
+        selector = new FilterChainSelector(
+            routingConfigs.build(),
+            defaultFilterChain.sslContextProviderSupplier(),
+            generateRoutingConfig(defaultFilterChain, activeFiltersDefaultChain));
+      } else {
+        selector = new FilterChainSelector(routingConfigs.build());
+      }
+
+      // Prepare the list of current selector's resources to close later.
+      List<SslContextProviderSupplier> oldSslSuppliers = getSuppliersInUse();
+
+      // Swap the selectors, initiate a graceful shutdown of the old one.
+      logger.log(Level.FINEST, "Updating selector {0}", selector);
+      filterChainSelectorManager.updateSelector(selector);
+
+      // Release old resources.
+      for (SslContextProviderSupplier supplier: oldSslSuppliers) {
+        supplier.close();
+      }
+
+      // Now that we have valid Transport Socket config, we can start/restart listening on a port.
+      startDelegateServer();
+    }
+
+    // called in syncContext
+    private void updateActiveFilters() {
+      Set<String> removedChains = new HashSet<>(activeFilters.keySet());
+      for (FilterChain filterChain: filterChains) {
+        removedChains.remove(filterChain.name());
+        updateActiveFiltersForChain(
+            activeFilters.computeIfAbsent(filterChain.name(), k -> new HashMap<>()),
+            filterChain.httpConnectionManager().httpFilterConfigs());
+      }
+
+      // Shutdown all filters of chains missing from the LDS.
+      for (String chainToShutdown : removedChains) {
+        HashMap<String, Filter> filtersToShutdown = activeFilters.get(chainToShutdown);
+        checkNotNull(filtersToShutdown, "filtersToShutdown of chain %s", chainToShutdown);
+        updateActiveFiltersForChain(filtersToShutdown, null);
+        activeFilters.remove(chainToShutdown);
+      }
+
+      // Default chain.
+      ImmutableList<NamedFilterConfig> defaultChainConfigs = null;
+      if (defaultFilterChain != null) {
+        defaultChainConfigs = defaultFilterChain.httpConnectionManager().httpFilterConfigs();
+      }
+      updateActiveFiltersForChain(activeFiltersDefaultChain, defaultChainConfigs);
+    }
+
+    // called in syncContext
+    private void shutdownActiveFilters() {
+      for (HashMap<String, Filter> chainFilters : activeFilters.values()) {
+        checkNotNull(chainFilters, "chainFilters");
+        updateActiveFiltersForChain(chainFilters, null);
+      }
+      activeFilters.clear();
+      updateActiveFiltersForChain(activeFiltersDefaultChain, null);
+    }
+
+    // called in syncContext
+    private void updateActiveFiltersForChain(
+        Map<String, Filter> chainFilters, @Nullable List<NamedFilterConfig> filterConfigs) {
+      if (filterConfigs == null) {
+        filterConfigs = ImmutableList.of();
+      }
+
+      Set<String> filtersToShutdown = new HashSet<>(chainFilters.keySet());
+      for (NamedFilterConfig namedFilter : filterConfigs) {
+        String typeUrl = namedFilter.filterConfig.typeUrl();
+        String filterKey = namedFilter.filterStateKey();
+
+        Filter.Provider provider = filterRegistry.get(typeUrl);
+        checkNotNull(provider, "provider %s", typeUrl);
+        Filter filter = chainFilters.computeIfAbsent(
+            filterKey, k -> provider.newInstance(namedFilter.name));
+        checkNotNull(filter, "filter %s", filterKey);
+        filtersToShutdown.remove(filterKey);
+      }
+
+      // Shutdown filters not present in current HCM.
+      for (String filterKey : filtersToShutdown) {
+        Filter filterToShutdown = chainFilters.remove(filterKey);
+        checkNotNull(filterToShutdown, "filterToShutdown %s", filterKey);
+        filterToShutdown.close();
+      }
+    }
+
+    private AtomicReference<ServerRoutingConfig> generateRoutingConfig(
+        FilterChain filterChain, Map<String, Filter> chainFilters) {
+      HttpConnectionManager hcm = filterChain.httpConnectionManager();
+      ServerRoutingConfig routingConfig;
+
+      // Inlined routes.
+      ImmutableList<VirtualHost> vhosts = hcm.virtualHosts();
+      if (vhosts != null) {
+        routingConfig = ServerRoutingConfig.create(vhosts,
+            generatePerRouteInterceptors(hcm.httpFilterConfigs(), vhosts, chainFilters));
+        return new AtomicReference<>(routingConfig);
+      }
+
+      // Routes from RDS.
+      RouteDiscoveryState rds = routeDiscoveryStates.get(hcm.rdsName());
+      checkNotNull(rds, "rds");
+
+      ImmutableList<VirtualHost> savedVhosts = rds.savedVirtualHosts;
+      if (savedVhosts != null) {
+        routingConfig = ServerRoutingConfig.create(savedVhosts,
+            generatePerRouteInterceptors(hcm.httpFilterConfigs(), savedVhosts, chainFilters));
+      } else {
+        routingConfig = ServerRoutingConfig.FAILING_ROUTING_CONFIG;
+      }
+      AtomicReference<ServerRoutingConfig> routingConfigRef = new AtomicReference<>(routingConfig);
+      savedRdsRoutingConfigRef.put(filterChain, routingConfigRef);
+      return routingConfigRef;
+    }
+
+    private ImmutableMap<Route, ServerInterceptor> generatePerRouteInterceptors(
+        @Nullable List<NamedFilterConfig> filterConfigs,
+        List<VirtualHost> virtualHosts,
+        Map<String, Filter> chainFilters) {
+      syncContext.throwIfNotInThisSynchronizationContext();
+
+      checkNotNull(chainFilters, "chainFilters");
+      ImmutableMap.Builder<Route, ServerInterceptor> perRouteInterceptors =
+          new ImmutableMap.Builder<>();
+
+      for (VirtualHost virtualHost : virtualHosts) {
+        for (Route route : virtualHost.routes()) {
+          // Short circuit.
+          if (filterConfigs == null) {
+            perRouteInterceptors.put(route, noopInterceptor);
+            continue;
+          }
+
+          // Override vhost filter configs with more specific per-route configs.
+          Map<String, FilterConfig> perRouteOverrides = ImmutableMap.<String, FilterConfig>builder()
+              .putAll(virtualHost.filterConfigOverrides())
+              .putAll(route.filterConfigOverrides())
+              .buildKeepingLast();
+
+          // Interceptors for this vhost/route combo.
+          List<ServerInterceptor> interceptors = new ArrayList<>(filterConfigs.size());
+          for (NamedFilterConfig namedFilter : filterConfigs) {
+            String name = namedFilter.name;
+            FilterConfig config = namedFilter.filterConfig;
+            FilterConfig overrideConfig = perRouteOverrides.get(name);
+            String filterKey = namedFilter.filterStateKey();
+
+            Filter filter = chainFilters.get(filterKey);
+            checkNotNull(filter, "chainFilters.get(%s)", filterKey);
+            ServerInterceptor interceptor = filter.buildServerInterceptor(config, overrideConfig);
+
+            if (interceptor != null) {
+              interceptors.add(interceptor);
+            }
+          }
+
+          // Combine interceptors produced by different filters into a single one that executes
+          // them sequentially. The order is preserved.
+          perRouteInterceptors.put(route, combineInterceptors(interceptors));
+        }
+      }
+
+      return perRouteInterceptors.buildOrThrow();
+    }
+
+    private ServerInterceptor combineInterceptors(final List<ServerInterceptor> interceptors) {
+      if (interceptors.isEmpty()) {
+        return noopInterceptor;
+      }
+      if (interceptors.size() == 1) {
+        return interceptors.get(0);
+      }
+      return new ServerInterceptor() {
+        @Override
+        public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+            Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+          // intercept forward
+          for (int i = interceptors.size() - 1; i >= 0; i--) {
+            next = InternalServerInterceptors.interceptCallHandlerCreate(
+                interceptors.get(i), next);
+          }
+          return next.startCall(call, headers);
+        }
+      };
+    }
+
+    private void handleConfigNotFoundOrMismatch(StatusException exception) {
+      cleanUpRouteDiscoveryStates();
+      shutdownActiveFilters();
+      List<SslContextProviderSupplier> toRelease = getSuppliersInUse();
+      filterChainSelectorManager.updateSelector(FilterChainSelector.NO_FILTER_CHAIN);
+      for (SslContextProviderSupplier s: toRelease) {
+        s.close();
+      }
+      if (restartTimer != null) {
+        restartTimer.cancel();
+      }
+      if (!delegate.isShutdown()) {
+        delegate.shutdown();  // let in-progress calls finish
+      }
+      isServing = false;
+      listener.onNotServing(exception);
+    }
+
+    private void cleanUpRouteDiscoveryStates() {
+      for (RouteDiscoveryState rdsState : routeDiscoveryStates.values()) {
+        String rdsName = rdsState.resourceName;
+        logger.log(Level.FINE, "Stop watching RDS resource {0}", rdsName);
+        xdsClient.cancelXdsResourceWatch(XdsRouteConfigureResource.getInstance(), rdsName,
+            rdsState);
+      }
+      routeDiscoveryStates.clear();
+      savedRdsRoutingConfigRef.clear();
+    }
+
+    private List<SslContextProviderSupplier> getSuppliersInUse() {
+      List<SslContextProviderSupplier> toRelease = new ArrayList<>();
+      FilterChainSelector selector = filterChainSelectorManager.getSelectorToUpdateSelector();
+      if (selector != null) {
+        for (FilterChain f: selector.getRoutingConfigs().keySet()) {
+          if (f.sslContextProviderSupplier() != null) {
+            toRelease.add(f.sslContextProviderSupplier());
+          }
+        }
+        SslContextProviderSupplier defaultSupplier =
+                selector.getDefaultSslContextProviderSupplier();
+        if (defaultSupplier != null) {
+          toRelease.add(defaultSupplier);
+        }
+      }
+      return toRelease;
+    }
+
+    private void releaseSuppliersInFlight() {
+      SslContextProviderSupplier supplier;
+      for (FilterChain filterChain : filterChains) {
+        supplier = filterChain.sslContextProviderSupplier();
+        if (supplier != null) {
+          supplier.close();
+        }
+      }
+      if (defaultFilterChain != null
+              && (supplier = defaultFilterChain.sslContextProviderSupplier()) != null) {
+        supplier.close();
+      }
+    }
+
+    private final class RouteDiscoveryState implements ResourceWatcher<RdsUpdate> {
+      private final String resourceName;
+      private ImmutableList<VirtualHost> savedVirtualHosts;
+      private boolean isPending = true;
+
+      private RouteDiscoveryState(String resourceName) {
+        this.resourceName = checkNotNull(resourceName, "resourceName");
+      }
+
+      @Override
+      public void onResourceChanged(final StatusOr<RdsUpdate> update) {
+        syncContext.execute(() -> {
+          if (!routeDiscoveryStates.containsKey(resourceName)) {
+            return; // Watcher has been cancelled.
+          }
+
+          if (update.hasValue()) {
+            if (savedVirtualHosts == null && !isPending) {
+              logger.log(Level.WARNING, "Received valid Rds {0} configuration.", resourceName);
+            }
+            savedVirtualHosts = ImmutableList.copyOf(update.getValue().virtualHosts);
+          } else {
+            logger.log(Level.WARNING, "Rds {0} unavailable: {1}",
+                new Object[]{resourceName, update.getStatus()});
+            savedVirtualHosts = null;
+          }
+          // In both cases, a change has occurred that requires a config update.
+          updateRdsRoutingConfig();
+          maybeUpdateSelector();
+        });
+      }
+
+      @Override
+      public void onAmbientError(final Status error) {
+        syncContext.execute(() -> {
+          if (!routeDiscoveryStates.containsKey(resourceName)) {
+            return; // Watcher has been cancelled.
+          }
+          String description = error.getDescription() == null ? "" : error.getDescription() + " ";
+          Status errorWithNodeId = error.withDescription(
+              description + "xDS node ID: " + xdsClient.getBootstrapInfo().node().getId());
+          logger.log(Level.WARNING, "Error loading RDS resource {0} from XdsClient: {1}.",
+              new Object[]{resourceName, errorWithNodeId});
+
+          // Per gRFC A88, ambient errors should not trigger a configuration change.
+          // Therefore, we do NOT call maybeUpdateSelector() here.
+        });
+      }
+
+      private void updateRdsRoutingConfig() {
+        for (FilterChain filterChain : savedRdsRoutingConfigRef.keySet()) {
+          HttpConnectionManager hcm = filterChain.httpConnectionManager();
+          if (!resourceName.equals(hcm.rdsName())) {
+            continue;
+          }
+
+          ServerRoutingConfig updatedRoutingConfig;
+          if (savedVirtualHosts == null) {
+            updatedRoutingConfig = ServerRoutingConfig.FAILING_ROUTING_CONFIG;
+          } else {
+            HashMap<String, Filter> chainFilters = activeFilters.get(filterChain.name());
+            ImmutableMap<Route, ServerInterceptor> interceptors = generatePerRouteInterceptors(
+                hcm.httpFilterConfigs(), savedVirtualHosts, chainFilters);
+            updatedRoutingConfig = ServerRoutingConfig.create(savedVirtualHosts, interceptors);
+          }
+
+          logger.log(Level.FINEST, "Updating filter chain {0} rds routing config: {1}",
+              new Object[]{filterChain.name(), updatedRoutingConfig});
+          savedRdsRoutingConfigRef.get(filterChain).set(updatedRoutingConfig);
+        }
+      }
+
+      // Update the selector to use the most recently updated configs only after all rds have been
+      // discovered for the first time. Later changes on rds will be applied through virtual host
+      // list atomic ref.
+      private void maybeUpdateSelector() {
+        isPending = false;
+        boolean isLastPending = pendingRds.remove(resourceName) && pendingRds.isEmpty();
+        if (isLastPending) {
+          updateSelector();
+        }
+      }
+    }
+  }
+
+  @VisibleForTesting
+  final class ConfigApplyingInterceptor implements ServerInterceptor {
+    private final ServerInterceptor noopInterceptor = new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+          Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+        return next.startCall(call, headers);
+      }
+    };
+
+    @Override
+    public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+        Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+      AtomicReference<ServerRoutingConfig> routingConfigRef =
+          call.getAttributes().get(ATTR_SERVER_ROUTING_CONFIG);
+      ServerRoutingConfig routingConfig = routingConfigRef == null ? null :
+          routingConfigRef.get();
+      if (routingConfig == null || routingConfig == ServerRoutingConfig.FAILING_ROUTING_CONFIG) {
+        String errorMsg = "Missing or broken xDS routing config: RDS config unavailable.";
+        call.close(Status.UNAVAILABLE.withDescription(errorMsg), new Metadata());
+        return new Listener<ReqT>() {};
+      }
+      List<VirtualHost> virtualHosts = routingConfig.virtualHosts();
+      VirtualHost virtualHost = RoutingUtils.findVirtualHostForHostName(
+          virtualHosts, call.getAuthority());
+      if (virtualHost == null) {
+        call.close(
+            Status.UNAVAILABLE.withDescription("Could not find xDS virtual host matching RPC"),
+            new Metadata());
+        return new Listener<ReqT>() {};
+      }
+      Route selectedRoute = null;
+      MethodDescriptor<ReqT, RespT> method = call.getMethodDescriptor();
+      for (Route route : virtualHost.routes()) {
+        if (RoutingUtils.matchRoute(
+            route.routeMatch(), "/" + method.getFullMethodName(), headers, random)) {
+          selectedRoute = route;
+          break;
+        }
+      }
+      if (selectedRoute == null) {
+        call.close(Status.UNAVAILABLE.withDescription("Could not find xDS route matching RPC"),
+            new Metadata());
+        return new ServerCall.Listener<ReqT>() {};
+      }
+      if (selectedRoute.routeAction() != null) {
+        call.close(Status.UNAVAILABLE.withDescription("Invalid xDS route action for matching "
+            + "route: only Route.non_forwarding_action should be allowed."), new Metadata());
+        return new ServerCall.Listener<ReqT>() {};
+      }
+      ServerInterceptor routeInterceptor = noopInterceptor;
+      Map<Route, ServerInterceptor> perRouteInterceptors = routingConfig.interceptors();
+      if (perRouteInterceptors != null && perRouteInterceptors.get(selectedRoute) != null) {
+        routeInterceptor = perRouteInterceptors.get(selectedRoute);
+      }
+      return routeInterceptor.interceptCall(call, headers, next);
+    }
+  }
+
+  /**
+   * The HttpConnectionManager level configuration.
+   */
+  @AutoValue
+  abstract static class ServerRoutingConfig {
+    @VisibleForTesting
+    static final ServerRoutingConfig FAILING_ROUTING_CONFIG = ServerRoutingConfig.create(
+        ImmutableList.<VirtualHost>of(), ImmutableMap.<Route, ServerInterceptor>of());
+
+    abstract ImmutableList<VirtualHost> virtualHosts();
+
+    // Prebuilt per route server interceptors from http filter configs.
+    abstract ImmutableMap<Route, ServerInterceptor> interceptors();
+
+    /**
+     * Server routing configuration.
+     * */
+    public static ServerRoutingConfig create(
+        ImmutableList<VirtualHost> virtualHosts,
+        ImmutableMap<Route, ServerInterceptor> interceptors) {
+      checkNotNull(virtualHosts, "virtualHosts");
+      checkNotNull(interceptors, "interceptors");
+      return new AutoValue_XdsServerWrapper_ServerRoutingConfig(virtualHosts, interceptors);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/BackendMetricPropagation.java b/xds/src/main/java/io/grpc/xds/client/BackendMetricPropagation.java
new file mode 100644
index 00000000000..f0e2c9484b4
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/BackendMetricPropagation.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2025 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.xds.client;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.collect.ImmutableSet;
+import io.grpc.Internal;
+import java.util.Objects;
+import javax.annotation.Nullable;
+
+/**
+ * Represents the configuration for which ORCA metrics should be propagated from backend
+ * to LRS load reports, as defined in gRFC A85.
+ */
+@Internal
+public final class BackendMetricPropagation {
+
+  public final boolean propagateCpuUtilization;
+  public final boolean propagateMemUtilization;
+  public final boolean propagateApplicationUtilization;
+
+  private final boolean propagateAllNamedMetrics;
+  private final ImmutableSet<String> namedMetricKeys;
+
+  private BackendMetricPropagation(
+      boolean propagateCpuUtilization,
+      boolean propagateMemUtilization,
+      boolean propagateApplicationUtilization,
+      boolean propagateAllNamedMetrics,
+      ImmutableSet<String> namedMetricKeys) {
+    this.propagateCpuUtilization = propagateCpuUtilization;
+    this.propagateMemUtilization = propagateMemUtilization;
+    this.propagateApplicationUtilization = propagateApplicationUtilization;
+    this.propagateAllNamedMetrics = propagateAllNamedMetrics;
+    this.namedMetricKeys = checkNotNull(namedMetricKeys, "namedMetricKeys");
+  }
+
+  /**
+   * Creates a BackendMetricPropagation from a list of metric specifications.
+   *
+   * @param metricSpecs list of metric specification strings from CDS resource
+   * @return BackendMetricPropagation instance
+   */
+  public static BackendMetricPropagation fromMetricSpecs(
+      @Nullable java.util.List<String> metricSpecs) {
+    if (metricSpecs == null || metricSpecs.isEmpty()) {
+      return new BackendMetricPropagation(false, false, false, false, ImmutableSet.of());
+    }
+
+    boolean propagateCpuUtilization = false;
+    boolean propagateMemUtilization = false;
+    boolean propagateApplicationUtilization = false;
+    boolean propagateAllNamedMetrics = false;
+    ImmutableSet.Builder<String> namedMetricKeysBuilder = ImmutableSet.builder();
+    for (String spec : metricSpecs) {
+      if (spec == null) {
+        continue;
+      }
+      switch (spec) {
+        case "cpu_utilization":
+          propagateCpuUtilization = true;
+          break;
+        case "mem_utilization":
+          propagateMemUtilization = true;
+          break;
+        case "application_utilization":
+          propagateApplicationUtilization = true;
+          break;
+        case "named_metrics.*":
+          propagateAllNamedMetrics = true;
+          break;
+        default:
+          if (spec.startsWith("named_metrics.")) {
+            String metricKey = spec.substring("named_metrics.".length());
+            if (!metricKey.isEmpty()) {
+              namedMetricKeysBuilder.add(metricKey);
+            }
+          }
+      }
+    }
+
+    return new BackendMetricPropagation(
+        propagateCpuUtilization,
+        propagateMemUtilization,
+        propagateApplicationUtilization,
+        propagateAllNamedMetrics,
+        namedMetricKeysBuilder.build());
+  }
+
+  /**
+   * Returns whether the given named metric key should be propagated.
+   */
+  public boolean shouldPropagateNamedMetric(String metricKey) {
+    return propagateAllNamedMetrics || namedMetricKeys.contains(metricKey);
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    BackendMetricPropagation that = (BackendMetricPropagation) o;
+    return propagateCpuUtilization == that.propagateCpuUtilization
+        && propagateMemUtilization == that.propagateMemUtilization
+        && propagateApplicationUtilization == that.propagateApplicationUtilization
+        && propagateAllNamedMetrics == that.propagateAllNamedMetrics
+        && Objects.equals(namedMetricKeys, that.namedMetricKeys);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(propagateCpuUtilization, propagateMemUtilization,
+        propagateApplicationUtilization, propagateAllNamedMetrics, namedMetricKeys);
+  }
+}
\ No newline at end of file
diff --git a/xds/src/main/java/io/grpc/xds/client/Bootstrapper.java b/xds/src/main/java/io/grpc/xds/client/Bootstrapper.java
new file mode 100644
index 00000000000..1d526703299
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/Bootstrapper.java
@@ -0,0 +1,237 @@
+/*
+ * Copyright 2019 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.xds.client;
+
+import static com.google.common.base.Preconditions.checkArgument;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.Internal;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/**
+ * Loads configuration information to bootstrap gRPC's integration of xDS protocol.
+ */
+@Internal
+public abstract class Bootstrapper {
+
+  public static final String XDSTP_SCHEME = "xdstp:";
+
+  /**
+   * Returns system-loaded bootstrap configuration.
+   */
+  public abstract BootstrapInfo bootstrap() throws XdsInitializationException;
+
+  /**
+   * Returns bootstrap configuration given by the raw data in JSON format.
+   */
+  public BootstrapInfo bootstrap(Map<String, ?> rawData) throws XdsInitializationException {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Data class containing xDS server information, such as server URI and channel credentials
+   * to be used for communication.
+   */
+  @AutoValue
+  @Internal
+  public abstract static class ServerInfo {
+    public abstract String target();
+
+    public abstract Object implSpecificConfig();
+
+    public abstract boolean ignoreResourceDeletion();
+
+    public abstract boolean isTrustedXdsServer();
+
+    public abstract boolean resourceTimerIsTransientError();
+
+    public abstract boolean failOnDataErrors();
+
+    @VisibleForTesting
+    public static ServerInfo create(String target, @Nullable Object implSpecificConfig) {
+      return new AutoValue_Bootstrapper_ServerInfo(target, implSpecificConfig,
+          false, false, false, false);
+    }
+
+    @VisibleForTesting
+    public static ServerInfo create(
+        String target, Object implSpecificConfig,
+        boolean ignoreResourceDeletion, boolean isTrustedXdsServer,
+        boolean resourceTimerIsTransientError, boolean failOnDataErrors) {
+      return new AutoValue_Bootstrapper_ServerInfo(target, implSpecificConfig,
+          ignoreResourceDeletion, isTrustedXdsServer,
+          resourceTimerIsTransientError, failOnDataErrors);
+    }
+  }
+
+  /**
+   * Data class containing Certificate provider information: the plugin-name and an opaque
+   * Map that represents the config for that plugin.
+   */
+  @AutoValue
+  @Internal
+  public abstract static class CertificateProviderInfo {
+    public abstract String pluginName();
+
+    public abstract ImmutableMap<String, ?> config();
+
+    @VisibleForTesting
+    public static CertificateProviderInfo create(String pluginName, Map<String, ?> config) {
+      return new AutoValue_Bootstrapper_CertificateProviderInfo(
+          pluginName, ImmutableMap.copyOf(config));
+    }
+  }
+
+  @AutoValue
+  public abstract static class AuthorityInfo {
+
+    /**
+     * A template for the name of the Listener resource to subscribe to for a gRPC client
+     * channel. Used only when the channel is created using an "xds:" URI with this authority
+     * name.
+     *
+     * <p>The token "%s", if present in this string, will be replaced with %-encoded
+     * service authority (i.e., the path part of the target URI used to create the gRPC channel).
+     *
+     * <p>Return value must start with {@code "xdstp://<authority_name>/"}.
+     */
+    public abstract String clientListenerResourceNameTemplate();
+
+    /**
+     * Ordered list of xDS servers to contact for this authority.
+     *
+     * <p>If the same server is listed in multiple authorities, the entries will be de-duped (i.e.,
+     * resources for both authorities will be fetched on the same ADS stream).
+     *
+     * <p>Defaults to the top-level server list {@link BootstrapInfo#servers()}. Must not be empty.
+     */
+    public abstract ImmutableList<ServerInfo> xdsServers();
+
+    public static AuthorityInfo create(
+        String clientListenerResourceNameTemplate, List<ServerInfo> xdsServers) {
+      checkArgument(!xdsServers.isEmpty(), "xdsServers must not be empty");
+      return new AutoValue_Bootstrapper_AuthorityInfo(
+          clientListenerResourceNameTemplate, ImmutableList.copyOf(xdsServers));
+    }
+  }
+
+  /**
+   * Data class containing the results of reading bootstrap.
+   */
+  @AutoValue
+  @Internal
+  public abstract static class BootstrapInfo {
+    /** Returns the list of xDS servers to be connected to. Must not be empty. */
+    public abstract ImmutableList<ServerInfo> servers();
+
+    /** Returns the node identifier to be included in xDS requests. */
+    public abstract Node node();
+
+    /** Returns the cert-providers config map. */
+    @Nullable
+    public abstract ImmutableMap<String, CertificateProviderInfo> certProviders();
+
+    /**
+     * A template for the name of the Listener resource to subscribe to for a gRPC server.
+     *
+     * <p>If starts with "xdstp:", will be interpreted as a new-style name, in which case the
+     * authority of the URI will be used to select the relevant configuration in the
+     * "authorities" map. The token "%s", if present in this string, will be replaced with
+     * the IP and port on which the server is listening. If the template starts with "xdstp:",
+     * the replaced string will be %-encoded.
+     *
+     * <p>There is no default; if unset, xDS-based server creation fails.
+     */
+    @Nullable
+    public abstract String serverListenerResourceNameTemplate();
+
+    /**
+     * A template for the name of the Listener resource to subscribe to for a gRPC client channel.
+     * Used only when the channel is created with an "xds:" URI with no authority.
+     *
+     * <p>If starts with "xdstp:", will be interpreted as a new-style name, in which case the
+     * authority of the URI will be used to select the relevant configuration in the "authorities"
+     * map.
+     *
+     * <p>The token "%s", if present in this string, will be replaced with the service authority
+     * (i.e., the path part of the target URI used to create the gRPC channel). If the template
+     * starts with "xdstp:", the replaced string will be %-encoded.
+     *
+     * <p>Defaults to {@code "%s"}.
+     */
+    public abstract String clientDefaultListenerResourceNameTemplate();
+
+    /**
+     * A map of authority name to corresponding configuration.
+     *
+     * <p>This is used in the following cases:
+     *
+     * <ul>
+     * <li>A gRPC client channel is created using an "xds:" URI that includes  an
+     * authority.</li>
+     *
+     * <li>A gRPC client channel is created using an "xds:" URI with no authority,
+     * but the "client_default_listener_resource_name_template" field above turns it into an
+     * "xdstp:" URI.</li>
+     *
+     * <li>A gRPC server is created and the "server_listener_resource_name_template" field is an
+     * "xdstp:" URI.</li>
+     * </ul>
+     *
+     * <p>In any of those cases, it is an error if the specified authority is not present in this
+     * map.
+     *
+     * <p>Defaults to an empty map.
+     */
+    public abstract ImmutableMap<String, AuthorityInfo> authorities();
+
+    @VisibleForTesting
+    public static Builder builder() {
+      return new AutoValue_Bootstrapper_BootstrapInfo.Builder()
+          .clientDefaultListenerResourceNameTemplate("%s")
+          .authorities(ImmutableMap.<String, AuthorityInfo>of());
+    }
+
+    @AutoValue.Builder
+    @VisibleForTesting
+    public abstract static class Builder {
+
+      public abstract Builder servers(List<ServerInfo> servers);
+
+      public abstract Builder node(Node node);
+
+      public abstract Builder certProviders(@Nullable Map<String,
+          CertificateProviderInfo> certProviders);
+
+      public abstract Builder serverListenerResourceNameTemplate(
+          @Nullable String serverListenerResourceNameTemplate);
+
+      public abstract Builder clientDefaultListenerResourceNameTemplate(
+          String clientDefaultListenerResourceNameTemplate);
+
+      public abstract Builder authorities(Map<String, AuthorityInfo> authorities);
+
+      public abstract BootstrapInfo build();
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/BootstrapperImpl.java b/xds/src/main/java/io/grpc/xds/client/BootstrapperImpl.java
new file mode 100644
index 00000000000..b44e32bb2d9
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/BootstrapperImpl.java
@@ -0,0 +1,313 @@
+/*
+ * Copyright 2021 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.xds.client;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.Internal;
+import io.grpc.InternalLogId;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.GrpcUtil.GrpcBuildVersion;
+import io.grpc.internal.JsonParser;
+import io.grpc.internal.JsonUtil;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+import io.grpc.xds.client.XdsLogger.XdsLogLevel;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A {@link Bootstrapper} implementation that reads xDS configurations from local file system.
+ */
+@Internal
+public abstract class BootstrapperImpl extends Bootstrapper {
+
+  public static final String GRPC_EXPERIMENTAL_XDS_FALLBACK =
+      "GRPC_EXPERIMENTAL_XDS_FALLBACK";
+  public static final String GRPC_EXPERIMENTAL_XDS_DATA_ERROR_HANDLING =
+      "GRPC_EXPERIMENTAL_XDS_DATA_ERROR_HANDLING";
+
+  // Client features.
+  @VisibleForTesting
+  public static final String CLIENT_FEATURE_DISABLE_OVERPROVISIONING =
+      "envoy.lb.does_not_support_overprovisioning";
+  @VisibleForTesting
+  public static final String CLIENT_FEATURE_RESOURCE_IN_SOTW = "xds.config.resource-in-sotw";
+
+  // Server features.
+  private static final String SERVER_FEATURE_IGNORE_RESOURCE_DELETION = "ignore_resource_deletion";
+  private static final String SERVER_FEATURE_TRUSTED_XDS_SERVER = "trusted_xds_server";
+  private static final String
+      SERVER_FEATURE_RESOURCE_TIMER_IS_TRANSIENT_ERROR = "resource_timer_is_transient_error";
+  private static final String SERVER_FEATURE_FAIL_ON_DATA_ERRORS = "fail_on_data_errors";
+
+  @VisibleForTesting
+  static boolean enableXdsFallback = GrpcUtil.getFlag(GRPC_EXPERIMENTAL_XDS_FALLBACK, true);
+
+  @VisibleForTesting
+  public static boolean xdsDataErrorHandlingEnabled
+      = GrpcUtil.getFlag(GRPC_EXPERIMENTAL_XDS_DATA_ERROR_HANDLING, false);
+
+  protected final XdsLogger logger;
+
+  protected FileReader reader = LocalFileReader.INSTANCE;
+
+  protected BootstrapperImpl() {
+    logger = XdsLogger.withLogId(InternalLogId.allocate("bootstrapper", null));
+  }
+
+  protected abstract String getJsonContent() throws IOException, XdsInitializationException;
+
+  protected abstract Object getImplSpecificConfig(Map<String, ?> serverConfig, String serverUri)
+      throws XdsInitializationException;
+
+
+  /**
+   * Reads and parses bootstrap config. The config is expected to be in JSON format.
+   */
+  @SuppressWarnings("unchecked")
+  @Override
+  public BootstrapInfo bootstrap() throws XdsInitializationException {
+    String jsonContent;
+    try {
+      jsonContent = getJsonContent();
+    } catch (IOException e) {
+      throw new XdsInitializationException("Fail to read bootstrap file", e);
+    }
+
+    Map<String, ?> rawBootstrap;
+    try {
+      rawBootstrap = (Map<String, ?>) JsonParser.parse(jsonContent);
+    } catch (IOException e) {
+      throw new XdsInitializationException("Failed to parse JSON", e);
+    }
+
+    logger.log(XdsLogLevel.DEBUG, "Bootstrap configuration:\n{0}", rawBootstrap);
+    return bootstrap(rawBootstrap);
+  }
+
+  @Override
+  public BootstrapInfo bootstrap(Map<String, ?> rawData) throws XdsInitializationException {
+    return bootstrapBuilder(rawData).build();
+  }
+
+  protected BootstrapInfo.Builder bootstrapBuilder(Map<String, ?> rawData)
+      throws XdsInitializationException {
+    BootstrapInfo.Builder builder = BootstrapInfo.builder();
+
+    List<?> rawServerConfigs = JsonUtil.getList(rawData, "xds_servers");
+    if (rawServerConfigs == null) {
+      throw new XdsInitializationException("Invalid bootstrap: 'xds_servers' does not exist.");
+    }
+    List<ServerInfo> servers = parseServerInfos(rawServerConfigs, logger);
+    if (servers.size() > 1 && !enableXdsFallback) {
+      servers = ImmutableList.of(servers.get(0));
+    }
+    builder.servers(servers);
+
+    Node.Builder nodeBuilder = Node.newBuilder();
+    Map<String, ?> rawNode = JsonUtil.getObject(rawData, "node");
+    if (rawNode != null) {
+      String id = JsonUtil.getString(rawNode, "id");
+      if (id != null) {
+        logger.log(XdsLogLevel.INFO, "Node id: {0}", id);
+        nodeBuilder.setId(id);
+      }
+      String cluster = JsonUtil.getString(rawNode, "cluster");
+      if (cluster != null) {
+        logger.log(XdsLogLevel.INFO, "Node cluster: {0}", cluster);
+        nodeBuilder.setCluster(cluster);
+      }
+      Map<String, ?> metadata = JsonUtil.getObject(rawNode, "metadata");
+      if (metadata != null) {
+        nodeBuilder.setMetadata(metadata);
+      }
+      Map<String, ?> rawLocality = JsonUtil.getObject(rawNode, "locality");
+      if (rawLocality != null) {
+        String region = "";
+        String zone = "";
+        String subZone = "";
+        if (rawLocality.containsKey("region")) {
+          region = JsonUtil.getString(rawLocality, "region");
+        }
+        if (rawLocality.containsKey("zone")) {
+          zone = JsonUtil.getString(rawLocality, "zone");
+        }
+        if (rawLocality.containsKey("sub_zone")) {
+          subZone = JsonUtil.getString(rawLocality, "sub_zone");
+        }
+        logger.log(XdsLogLevel.INFO, "Locality region: {0}, zone: {1}, subZone: {2}",
+            region, zone, subZone);
+        Locality locality = Locality.create(region, zone, subZone);
+        nodeBuilder.setLocality(locality);
+      }
+    }
+    GrpcBuildVersion buildVersion = GrpcUtil.getGrpcBuildVersion();
+    logger.log(XdsLogLevel.INFO, "Build version: {0}", buildVersion);
+    nodeBuilder.setBuildVersion(buildVersion.toString());
+    nodeBuilder.setUserAgentName(buildVersion.getUserAgent());
+    nodeBuilder.setUserAgentVersion(buildVersion.getImplementationVersion());
+    nodeBuilder.addClientFeatures(CLIENT_FEATURE_DISABLE_OVERPROVISIONING);
+    nodeBuilder.addClientFeatures(CLIENT_FEATURE_RESOURCE_IN_SOTW);
+    builder.node(nodeBuilder.build());
+
+    Map<String, ?> certProvidersBlob = JsonUtil.getObject(rawData, "certificate_providers");
+    if (certProvidersBlob != null) {
+      logger.log(XdsLogLevel.INFO, "Configured with {0} cert providers", certProvidersBlob.size());
+      Map<String, CertificateProviderInfo> certProviders = new HashMap<>(certProvidersBlob.size());
+      for (String name : certProvidersBlob.keySet()) {
+        Map<String, ?> valueMap = JsonUtil.getObject(certProvidersBlob, name);
+        String pluginName =
+            checkForNull(JsonUtil.getString(valueMap, "plugin_name"), "plugin_name");
+        logger.log(XdsLogLevel.INFO, "cert provider: {0}, plugin name: {1}", name, pluginName);
+        Map<String, ?> config = checkForNull(JsonUtil.getObject(valueMap, "config"), "config");
+        CertificateProviderInfo certificateProviderInfo =
+            CertificateProviderInfo.create(pluginName, config);
+        certProviders.put(name, certificateProviderInfo);
+      }
+      builder.certProviders(certProviders);
+    }
+
+    String serverResourceId =
+        JsonUtil.getString(rawData, "server_listener_resource_name_template");
+    logger.log(
+        XdsLogLevel.INFO, "server_listener_resource_name_template: {0}", serverResourceId);
+    builder.serverListenerResourceNameTemplate(serverResourceId);
+
+    String clientDefaultListener =
+        JsonUtil.getString(rawData, "client_default_listener_resource_name_template");
+    logger.log(
+        XdsLogLevel.INFO, "client_default_listener_resource_name_template: {0}",
+        clientDefaultListener);
+    if (clientDefaultListener != null) {
+      builder.clientDefaultListenerResourceNameTemplate(clientDefaultListener);
+    }
+
+    Map<String, ?> rawAuthoritiesMap =
+        JsonUtil.getObject(rawData, "authorities");
+    ImmutableMap.Builder<String, AuthorityInfo> authorityInfoMapBuilder = ImmutableMap.builder();
+    if (rawAuthoritiesMap != null) {
+      logger.log(
+          XdsLogLevel.INFO, "Configured with {0} xDS server authorities", rawAuthoritiesMap.size());
+      for (String authorityName : rawAuthoritiesMap.keySet()) {
+        logger.log(XdsLogLevel.INFO, "xDS server authority: {0}", authorityName);
+        Map<String, ?> rawAuthority = JsonUtil.getObject(rawAuthoritiesMap, authorityName);
+        String clientListnerTemplate =
+            JsonUtil.getString(rawAuthority, "client_listener_resource_name_template");
+        logger.log(
+            XdsLogLevel.INFO, "client_listener_resource_name_template: {0}", clientListnerTemplate);
+        String prefix = XDSTP_SCHEME + "//" + authorityName + "/";
+        if (clientListnerTemplate == null) {
+          clientListnerTemplate = prefix + "envoy.config.listener.v3.Listener/%s";
+        } else if (!clientListnerTemplate.startsWith(prefix)) {
+          throw new XdsInitializationException(
+              "client_listener_resource_name_template: '" + clientListnerTemplate
+                  + "' does not start with " + prefix);
+        }
+        List<?> rawAuthorityServers = JsonUtil.getList(rawAuthority, "xds_servers");
+        List<ServerInfo> authorityServers;
+        if (rawAuthorityServers == null || rawAuthorityServers.isEmpty()) {
+          authorityServers = servers;
+        } else {
+          if (rawAuthorityServers.size() > 1 && !enableXdsFallback) {
+            rawAuthorityServers = ImmutableList.of(rawAuthorityServers.get(0));
+          }
+          authorityServers = parseServerInfos(rawAuthorityServers, logger);
+        }
+        authorityInfoMapBuilder.put(
+            authorityName, AuthorityInfo.create(clientListnerTemplate, authorityServers));
+      }
+      builder.authorities(authorityInfoMapBuilder.buildOrThrow());
+    }
+
+    return builder;
+  }
+
+  private List<ServerInfo> parseServerInfos(List<?> rawServerConfigs, XdsLogger logger)
+      throws XdsInitializationException {
+    logger.log(XdsLogLevel.INFO, "Configured with {0} xDS servers", rawServerConfigs.size());
+    ImmutableList.Builder<ServerInfo> servers = ImmutableList.builder();
+    List<Map<String, ?>> serverConfigList = JsonUtil.checkObjectList(rawServerConfigs);
+    for (Map<String, ?> serverConfig : serverConfigList) {
+      String serverUri = JsonUtil.getString(serverConfig, "server_uri");
+      if (serverUri == null) {
+        throw new XdsInitializationException("Invalid bootstrap: missing 'server_uri'");
+      }
+      logger.log(XdsLogLevel.INFO, "xDS server URI: {0}", serverUri);
+
+      Object implSpecificConfig = getImplSpecificConfig(serverConfig, serverUri);
+
+      boolean resourceTimerIsTransientError = false;
+      boolean ignoreResourceDeletion = false;
+      boolean failOnDataErrors = false;
+      // "For forward compatibility reasons, the client will ignore any entry in the list that it
+      // does not understand, regardless of type."
+      List<?> serverFeatures = JsonUtil.getList(serverConfig, "server_features");
+      if (serverFeatures != null) {
+        logger.log(XdsLogLevel.INFO, "Server features: {0}", serverFeatures);
+        if (serverFeatures.contains(SERVER_FEATURE_IGNORE_RESOURCE_DELETION)) {
+          ignoreResourceDeletion = true;
+        }
+        resourceTimerIsTransientError = xdsDataErrorHandlingEnabled
+            && serverFeatures.contains(SERVER_FEATURE_RESOURCE_TIMER_IS_TRANSIENT_ERROR);
+        failOnDataErrors = xdsDataErrorHandlingEnabled
+            && serverFeatures.contains(SERVER_FEATURE_FAIL_ON_DATA_ERRORS);
+      }
+      servers.add(
+          ServerInfo.create(serverUri, implSpecificConfig, ignoreResourceDeletion,
+              serverFeatures != null
+                  && serverFeatures.contains(SERVER_FEATURE_TRUSTED_XDS_SERVER),
+              resourceTimerIsTransientError, failOnDataErrors));
+    }
+    return servers.build();
+  }
+
+  @VisibleForTesting
+  public void setFileReader(FileReader reader) {
+    this.reader = reader;
+  }
+
+  /**
+   * Reads the content of the file with the given path in the file system.
+   */
+  public interface FileReader {
+    String readFile(String path) throws IOException;
+  }
+
+  protected enum LocalFileReader implements FileReader {
+    INSTANCE;
+
+    @Override
+    public String readFile(String path) throws IOException {
+      return new String(Files.readAllBytes(Paths.get(path)), StandardCharsets.UTF_8);
+    }
+  }
+
+  private static <T> T checkForNull(T value, String fieldName) throws XdsInitializationException {
+    if (value == null) {
+      throw new XdsInitializationException(
+          "Invalid bootstrap: '" + fieldName + "' does not exist.");
+    }
+    return value;
+  }
+
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/ControlPlaneClient.java b/xds/src/main/java/io/grpc/xds/client/ControlPlaneClient.java
new file mode 100644
index 00000000000..59f439d3687
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/ControlPlaneClient.java
@@ -0,0 +1,562 @@
+/*
+ * 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.xds.client;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.protobuf.Any;
+import com.google.rpc.Code;
+import io.envoyproxy.envoy.service.discovery.v3.AggregatedDiscoveryServiceGrpc;
+import io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest;
+import io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse;
+import io.grpc.InternalLogId;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+import io.grpc.xds.client.XdsClient.ProcessingTracker;
+import io.grpc.xds.client.XdsClient.ResourceStore;
+import io.grpc.xds.client.XdsClient.XdsResponseHandler;
+import io.grpc.xds.client.XdsLogger.XdsLogLevel;
+import io.grpc.xds.client.XdsTransportFactory.StreamingCall;
+import io.grpc.xds.client.XdsTransportFactory.XdsTransport;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * Common base type for XdsClient implementations, which encapsulates the layer abstraction of
+ * the xDS RPC stream.
+ */
+final class ControlPlaneClient {
+
+  private final SynchronizationContext syncContext;
+  private final InternalLogId logId;
+  private final XdsLogger logger;
+  private final ServerInfo serverInfo;
+  private final XdsTransport xdsTransport;
+  private final XdsResponseHandler xdsResponseHandler;
+  private final ResourceStore resourceStore;
+  private final ScheduledExecutorService timeService;
+  private final BackoffPolicy.Provider backoffPolicyProvider;
+  private final Stopwatch stopwatch;
+  private final Node bootstrapNode;
+
+  // Last successfully applied version_info for each resource type. Starts with empty string.
+  // A version_info is used to update management server with client's most recent knowledge of
+  // resources.
+  private final Map<XdsResourceType<?>, String> versions = new HashMap<>();
+
+  private boolean shutdown;
+  private boolean inError;
+
+  @Nullable
+  private AdsStream adsStream;
+  @Nullable
+  private BackoffPolicy retryBackoffPolicy;
+  @Nullable
+  private ScheduledHandle rpcRetryTimer;
+  private final MessagePrettyPrinter messagePrinter;
+
+  /** An entity that manages ADS RPCs over a single channel. */
+  ControlPlaneClient(
+      XdsTransport xdsTransport,
+      ServerInfo serverInfo,
+      Node bootstrapNode,
+      XdsResponseHandler xdsResponseHandler,
+      ResourceStore resourceStore,
+      ScheduledExecutorService
+      timeService,
+      SynchronizationContext syncContext,
+      BackoffPolicy.Provider backoffPolicyProvider,
+      Supplier<Stopwatch> stopwatchSupplier,
+      MessagePrettyPrinter messagePrinter) {
+    this.serverInfo = checkNotNull(serverInfo, "serverInfo");
+    this.xdsTransport = checkNotNull(xdsTransport, "xdsTransport");
+    this.xdsResponseHandler = checkNotNull(xdsResponseHandler, "xdsResponseHandler");
+    this.resourceStore = checkNotNull(resourceStore, "resourcesSubscriber");
+    this.bootstrapNode = checkNotNull(bootstrapNode, "bootstrapNode");
+    this.timeService = checkNotNull(timeService, "timeService");
+    this.syncContext = checkNotNull(syncContext, "syncContext");
+    this.backoffPolicyProvider = checkNotNull(backoffPolicyProvider, "backoffPolicyProvider");
+    this.messagePrinter = checkNotNull(messagePrinter, "messagePrinter");
+    stopwatch = checkNotNull(stopwatchSupplier, "stopwatchSupplier").get();
+    logId = InternalLogId.allocate("xds-cp-client", serverInfo.target());
+    logger = XdsLogger.withLogId(logId);
+    logger.log(XdsLogLevel.INFO, "Created");
+  }
+
+  void shutdown() {
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        shutdown = true;
+        logger.log(XdsLogLevel.INFO, "Shutting down");
+        if (adsStream != null) {
+          adsStream.close(Status.CANCELLED.withDescription("shutdown").asException());
+        }
+        if (rpcRetryTimer != null && rpcRetryTimer.isPending()) {
+          rpcRetryTimer.cancel();
+        }
+        xdsTransport.shutdown();
+      }
+    });
+  }
+
+  @Override
+  public String toString() {
+    return logId.toString();
+  }
+
+  public ServerInfo getServerInfo() {
+    return serverInfo;
+  }
+
+  /**
+   * Updates the resource subscription for the given resource type.
+   */
+  // Must be synchronized.
+  void adjustResourceSubscription(XdsResourceType<?> resourceType) {
+    if (rpcRetryTimer != null && rpcRetryTimer.isPending()) {
+      return;
+    }
+    if (adsStream == null) {
+      startRpcStream();
+      // when the stream becomes ready, it will send the discovery requests
+      return;
+    }
+
+    // We will do the rest of the method as part of the readyHandler when the stream is ready.
+    if (!isConnected()) {
+      return;
+    }
+
+    Collection<String> resources = resourceStore.getSubscribedResources(serverInfo, resourceType);
+    if (resources == null) {
+      resources = Collections.emptyList();
+    }
+    adsStream.sendDiscoveryRequest(resourceType, resources);
+    resourceStore.startMissingResourceTimers(resources, resourceType);
+
+    if (resources.isEmpty()) {
+      // The resource type no longer has subscribing resources; clean up references to it, except
+      // for nonces. If the resource type becomes used again the control plane can ignore requests
+      // for old/missing nonces. Old type's nonces are dropped when the ADS stream is restarted.
+      versions.remove(resourceType);
+    }
+  }
+
+  /**
+   * Accepts the update for the given resource type by updating the latest resource version
+   * and sends an ACK request to the management server.
+   */
+  // Must be synchronized.
+  void ackResponse(XdsResourceType<?> type, String versionInfo, String nonce) {
+    versions.put(type, versionInfo);
+    logger.log(XdsLogLevel.INFO, "Sending ACK for {0} update, nonce: {1}, current version: {2}",
+        type.typeName(), nonce, versionInfo);
+    Collection<String> resources = resourceStore.getSubscribedResources(serverInfo, type);
+    if (resources == null) {
+      resources = Collections.emptyList();
+    }
+    adsStream.sendDiscoveryRequest(type, versionInfo, resources, nonce, null);
+  }
+
+  /**
+   * Rejects the update for the given resource type and sends an NACK request (request with last
+   * accepted version) to the management server.
+   */
+  // Must be synchronized.
+  void nackResponse(XdsResourceType<?> type, String nonce, String errorDetail) {
+    String versionInfo = versions.getOrDefault(type, "");
+    logger.log(XdsLogLevel.INFO, "Sending NACK for {0} update, nonce: {1}, current version: {2}",
+        type.typeName(), nonce, versionInfo);
+    Collection<String> resources = resourceStore.getSubscribedResources(serverInfo, type);
+    if (resources == null) {
+      resources = Collections.emptyList();
+    }
+    adsStream.sendDiscoveryRequest(type, versionInfo, resources, nonce, errorDetail);
+  }
+
+  // Must be synchronized.
+  boolean isReady() {
+    return adsStream != null && adsStream.call != null
+        && adsStream.call.isReady() && !adsStream.closed;
+  }
+
+  boolean isConnected() {
+    return adsStream != null && adsStream.sentInitialRequest;
+  }
+
+  /**
+   * Used for identifying whether or not when getting a control plane for authority that this
+   * control plane should be skipped over if there is a fallback.
+   *
+   * <p>Also used by metric to consider this control plane to not be "active".
+   *
+   * <p>A ControlPlaneClient is considered to be in error during the time from when an
+   * {@link AdsStream} closed without having received a response to the time an AdsStream does
+   * receive a response.
+   */
+  boolean isInError() {
+    return inError;
+  }
+
+
+  /**
+   * Cleans up outstanding rpcRetryTimer if present, since we are communicating.
+   * If we haven't sent the initial discovery request for this RPC stream, we will delegate to
+   * xdsResponseHandler (in practice XdsClientImpl) to do any initialization for a new active
+   * stream such as starting timers.  We then send the initial discovery request.
+   */
+  // Must be synchronized.
+  void readyHandler(boolean shouldSendInitialRequest) {
+    if (shouldSendInitialRequest) {
+      sendDiscoveryRequests();
+    }
+  }
+
+  /**
+   * Establishes the RPC connection by creating a new RPC stream on the given channel for
+   * xDS protocol communication.
+   */
+  // Must be synchronized.
+  private void startRpcStream() {
+    checkState(adsStream == null, "Previous adsStream has not been cleared yet");
+
+    if (rpcRetryTimer != null) {
+      rpcRetryTimer.cancel();
+      rpcRetryTimer = null;
+    }
+
+    adsStream = new AdsStream();
+    adsStream.start();
+    logger.log(XdsLogLevel.INFO, "ADS stream started");
+    stopwatch.reset().start();
+  }
+
+  void sendDiscoveryRequests() {
+    if (rpcRetryTimer != null && rpcRetryTimer.isPending()) {
+      return;
+    }
+
+    if (adsStream == null) {
+      startRpcStream();
+      // when the stream becomes ready, it will send the discovery requests
+      return;
+    }
+
+    if (isConnected()) {
+      Set<XdsResourceType<?>> subscribedResourceTypes =
+          new HashSet<>(resourceStore.getSubscribedResourceTypesWithTypeUrl().values());
+
+      for (XdsResourceType<?> type : subscribedResourceTypes) {
+        adjustResourceSubscription(type);
+      }
+    }
+  }
+
+  @VisibleForTesting
+  public final class RpcRetryTask implements Runnable {
+    @Override
+    public void run() {
+      logger.log(XdsLogLevel.DEBUG, "Retry timeout. Restart ADS stream {0}", logId);
+      if (shutdown) {
+        return;
+      }
+
+      startRpcStream();
+
+      // handling CPC management is triggered in readyHandler
+    }
+  }
+
+  @VisibleForTesting
+  @Nullable
+  XdsResourceType<?> fromTypeUrl(String typeUrl) {
+    return resourceStore.getSubscribedResourceTypesWithTypeUrl().get(typeUrl);
+  }
+
+  private class AdsStream implements XdsTransportFactory.EventHandler<DiscoveryResponse> {
+    private boolean responseReceived;
+    private boolean sentInitialRequest;
+    private boolean closed;
+    // Response nonce for the most recently received discovery responses of each resource type URL.
+    // Client initiated requests start response nonce with empty string.
+    // Nonce in each response is echoed back in the following ACK/NACK request. It is
+    // used for management server to identify which response the client is ACKing/NACking.
+    // To avoid confusion, client-initiated requests will always use the nonce in
+    // most recently received responses of each resource type. Nonces are never deleted from the
+    // map; nonces are only discarded once the stream closes because xds_protocol says "the
+    // management server should not send a DiscoveryResponse for any DiscoveryRequest that has a
+    // stale nonce."
+    private final Map<String, String> respNonces = new HashMap<>();
+    private final StreamingCall<DiscoveryRequest, DiscoveryResponse> call;
+    private final MethodDescriptor<DiscoveryRequest, DiscoveryResponse> methodDescriptor =
+        AggregatedDiscoveryServiceGrpc.getStreamAggregatedResourcesMethod();
+
+    private AdsStream() {
+      this.call = xdsTransport.createStreamingCall(methodDescriptor.getFullMethodName(),
+          methodDescriptor.getRequestMarshaller(), methodDescriptor.getResponseMarshaller());
+    }
+
+    void start() {
+      call.start(this);
+    }
+
+    /**
+     * Sends a discovery request with the given {@code versionInfo}, {@code nonce} and
+     * {@code errorDetail}. Used for reacting to a specific discovery response. For
+     * client-initiated discovery requests, use {@link
+     * #sendDiscoveryRequest(XdsResourceType, Collection)}.
+     */
+    void sendDiscoveryRequest(XdsResourceType<?> type, String versionInfo,
+                              Collection<String> resources, String nonce,
+                              @Nullable String errorDetail) {
+      DiscoveryRequest.Builder builder =
+          DiscoveryRequest.newBuilder()
+              .setVersionInfo(versionInfo)
+              .setNode(bootstrapNode.toEnvoyProtoNode())
+              .addAllResourceNames(resources)
+              .setTypeUrl(type.typeUrl())
+              .setResponseNonce(nonce);
+      if (errorDetail != null) {
+        com.google.rpc.Status error =
+            com.google.rpc.Status.newBuilder()
+                .setCode(Code.INVALID_ARGUMENT_VALUE)  // FIXME(chengyuanzhang): use correct code
+                .setMessage(errorDetail)
+                .build();
+        builder.setErrorDetail(error);
+      }
+      DiscoveryRequest request = builder.build();
+      call.sendMessage(request);
+      if (logger.isLoggable(XdsLogLevel.DEBUG)) {
+        logger.log(XdsLogLevel.DEBUG, "Sent DiscoveryRequest\n{0}", messagePrinter.print(request));
+      }
+    }
+
+    /**
+     * Sends a client-initiated discovery request.
+     */
+    final void sendDiscoveryRequest(XdsResourceType<?> type, Collection<String> resources) {
+      logger.log(XdsLogLevel.INFO, "Sending {0} request for resources: {1}", type, resources);
+      sendDiscoveryRequest(type, versions.getOrDefault(type, ""), resources,
+          respNonces.getOrDefault(type.typeUrl(), ""), null);
+    }
+
+    @Override
+    public void onReady() {
+      syncContext.execute(() -> {
+        if (!isReady()) {
+          logger.log(XdsLogLevel.DEBUG,
+              "ADS stream ready handler called, but not ready {0}", logId);
+          return;
+        }
+
+        logger.log(XdsLogLevel.DEBUG, "ADS stream ready {0}", logId);
+
+        boolean hadSentInitialRequest = sentInitialRequest;
+        sentInitialRequest = true;
+        readyHandler(!hadSentInitialRequest);
+      });
+    }
+
+    @Override
+    public void onRecvMessage(DiscoveryResponse response) {
+      syncContext.execute(new Runnable() {
+        @Override
+        public void run() {
+          if (closed) {
+            return;
+          }
+          boolean isFirstResponse = !responseReceived;
+          responseReceived = true;
+          inError = false;
+          respNonces.put(response.getTypeUrl(), response.getNonce());
+
+          XdsResourceType<?> type = fromTypeUrl(response.getTypeUrl());
+          if (logger.isLoggable(XdsLogLevel.DEBUG)) {
+            logger.log(
+                XdsLogLevel.DEBUG, "Received {0} response:\n{1}", type,
+                messagePrinter.print(response));
+          }
+          if (type == null) {
+            logger.log(
+                XdsLogLevel.WARNING,
+                "Ignore an unknown type of DiscoveryResponse: {0}",
+                response.getTypeUrl());
+
+            call.startRecvMessage();
+            return;
+          }
+          handleRpcResponse(type, response.getVersionInfo(), response.getResourcesList(),
+              response.getNonce(), isFirstResponse);
+        }
+      });
+    }
+
+    @Override
+    public void onStatusReceived(final Status status) {
+      syncContext.execute(() -> {
+        handleRpcStreamClosed(status);
+      });
+    }
+
+    final void handleRpcResponse(XdsResourceType<?> type, String versionInfo, List<Any> resources,
+                                 String nonce, boolean isFirstResponse) {
+      checkNotNull(type, "type");
+
+      ProcessingTracker processingTracker = new ProcessingTracker(
+          () -> call.startRecvMessage(), syncContext);
+      xdsResponseHandler.handleResourceResponse(type, serverInfo, versionInfo, resources, nonce,
+          isFirstResponse, processingTracker);
+      processingTracker.onComplete();
+    }
+
+    private void handleRpcStreamClosed(Status status) {
+      if (closed) {
+        return;
+      }
+
+      if (responseReceived || retryBackoffPolicy == null) {
+        // Reset the backoff sequence if had received a response, or backoff sequence
+        // has never been initialized.
+        retryBackoffPolicy = backoffPolicyProvider.get();
+        stopwatch.reset();
+      }
+
+      Status newStatus = status;
+      if (responseReceived) {
+        // A closed ADS stream after a successful response is not considered an error. Servers may
+        // close streams for various reasons during normal operation, such as load balancing or
+        // underlying connection hitting its max connection age limit (see gRFC A9).
+        if (!status.isOk()) {
+          newStatus = Status.OK;
+          logger.log(XdsLogLevel.DEBUG, "ADS stream closed with error {0}: {1}. However, a "
+              + "response was received, so this will not be treated as an error. Cause: {2}",
+              status.getCode(), status.getDescription(), status.getCause());
+        } else {
+          logger.log(XdsLogLevel.DEBUG,
+              "ADS stream closed by server after a response was received");
+        }
+      } else {
+        // If the ADS stream is closed without ever having received a response from the server, then
+        // the XdsClient should consider that a connectivity error (see gRFC A57).
+        inError = true;
+        if (status.isOk()) {
+          newStatus = Status.UNAVAILABLE.withDescription(
+              "ADS stream closed with OK before receiving a response");
+        }
+        logger.log(
+            XdsLogLevel.ERROR, "ADS stream failed with status {0}: {1}. Cause: {2}",
+            newStatus.getCode(), newStatus.getDescription(), newStatus.getCause());
+      }
+
+      close(newStatus.asException());
+
+      // FakeClock in tests isn't thread-safe. Schedule the retry timer before notifying callbacks
+      // to avoid TSAN races, since tests may wait until callbacks are called but then would run
+      // concurrently with the stopwatch and schedule.
+      long elapsed = stopwatch.elapsed(TimeUnit.NANOSECONDS);
+      long delayNanos = Math.max(0, retryBackoffPolicy.nextBackoffNanos() - elapsed);
+      rpcRetryTimer =
+          syncContext.schedule(new RpcRetryTask(), delayNanos, TimeUnit.NANOSECONDS, timeService);
+
+      xdsResponseHandler.handleStreamClosed(newStatus, !responseReceived);
+    }
+
+    private void close(Exception error) {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      cleanUp();
+      call.sendError(error);
+    }
+
+    private void cleanUp() {
+      if (adsStream == this) {
+        adsStream = null;
+      }
+    }
+  }
+
+  @VisibleForTesting
+  static class FailingXdsTransport implements XdsTransport {
+    Status error;
+
+    public FailingXdsTransport(Status error) {
+      this.error = error;
+    }
+
+    @Override
+    public <ReqT, RespT> StreamingCall<ReqT, RespT>
+        createStreamingCall(String fullMethodName,
+                            MethodDescriptor.Marshaller<ReqT> reqMarshaller,
+                            MethodDescriptor.Marshaller<RespT> respMarshaller) {
+      return new FailingXdsStreamingCall<>();
+    }
+
+    @Override
+    public void shutdown() {
+      // no-op
+    }
+
+    private class FailingXdsStreamingCall<ReqT, RespT> implements StreamingCall<ReqT, RespT> {
+
+      @Override
+      public void start(XdsTransportFactory.EventHandler<RespT> eventHandler) {
+        eventHandler.onStatusReceived(error);
+      }
+
+      @Override
+      public void sendMessage(ReqT message) {
+        // no-op
+      }
+
+      @Override
+      public void startRecvMessage() {
+        // no-op
+      }
+
+      @Override
+      public void sendError(Exception e) {
+        // no-op
+      }
+
+      @Override
+      public boolean isReady() {
+        return false;
+      }
+    }
+  }
+
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/EnvoyProtoData.java b/xds/src/main/java/io/grpc/xds/client/EnvoyProtoData.java
new file mode 100644
index 00000000000..e52fd8741e6
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/EnvoyProtoData.java
@@ -0,0 +1,367 @@
+/*
+ * Copyright 2019 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.xds.client;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
+import com.google.protobuf.ListValue;
+import com.google.protobuf.NullValue;
+import com.google.protobuf.Struct;
+import com.google.protobuf.Value;
+import io.grpc.Internal;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import javax.annotation.Nullable;
+
+/**
+ * Defines gRPC data types for Envoy protobuf messages used in xDS protocol. Each data type has
+ * the same name as Envoy's corresponding protobuf message, but only with fields used by gRPC.
+ *
+ * <p>Each data type should define a {@code fromEnvoyProtoXXX} static method to convert an Envoy
+ * proto message to an instance of that data type.
+ *
+ * <p>For data types that need to be sent as protobuf messages, a {@code toEnvoyProtoXXX} instance
+ * method is defined to convert an instance to Envoy proto message.
+ *
+ * <p>Data conversion should follow the invariant: converted data is guaranteed to be valid for
+ * gRPC. If the protobuf message contains invalid data, the conversion should fail and no object
+ * should be instantiated.
+ */
+@Internal
+public final class EnvoyProtoData {
+
+  // Prevent instantiation.
+  private EnvoyProtoData() {
+  }
+
+  /**
+   * See corresponding Envoy proto message {@link io.envoyproxy.envoy.config.core.v3.Node}.
+   */
+  public static final class Node {
+
+    private final String id;
+    private final String cluster;
+    @Nullable
+    private final Map<String, ?> metadata;
+    @Nullable
+    private final Locality locality;
+    private final List<Address> listeningAddresses;
+    private final String buildVersion;
+    private final String userAgentName;
+    @Nullable
+    private final String userAgentVersion;
+    private final List<String> clientFeatures;
+
+    private Node(
+        String id, String cluster, @Nullable Map<String, ?> metadata, @Nullable Locality locality,
+        List<Address> listeningAddresses, String buildVersion, String userAgentName,
+        @Nullable String userAgentVersion, List<String> clientFeatures) {
+      this.id = checkNotNull(id, "id");
+      this.cluster = checkNotNull(cluster, "cluster");
+      this.metadata = metadata;
+      this.locality = locality;
+      this.listeningAddresses = Collections.unmodifiableList(
+          checkNotNull(listeningAddresses, "listeningAddresses"));
+      this.buildVersion = checkNotNull(buildVersion, "buildVersion");
+      this.userAgentName = checkNotNull(userAgentName, "userAgentName");
+      this.userAgentVersion = userAgentVersion;
+      this.clientFeatures = Collections.unmodifiableList(
+          checkNotNull(clientFeatures, "clientFeatures"));
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("id", id)
+          .add("cluster", cluster)
+          .add("metadata", metadata)
+          .add("locality", locality)
+          .add("listeningAddresses", listeningAddresses)
+          .add("buildVersion", buildVersion)
+          .add("userAgentName", userAgentName)
+          .add("userAgentVersion", userAgentVersion)
+          .add("clientFeatures", clientFeatures)
+          .toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      Node node = (Node) o;
+      return Objects.equals(id, node.id)
+          && Objects.equals(cluster, node.cluster)
+          && Objects.equals(metadata, node.metadata)
+          && Objects.equals(locality, node.locality)
+          && Objects.equals(listeningAddresses, node.listeningAddresses)
+          && Objects.equals(buildVersion, node.buildVersion)
+          && Objects.equals(userAgentName, node.userAgentName)
+          && Objects.equals(userAgentVersion, node.userAgentVersion)
+          && Objects.equals(clientFeatures, node.clientFeatures);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects
+          .hash(id, cluster, metadata, locality, listeningAddresses, buildVersion, userAgentName,
+              userAgentVersion, clientFeatures);
+    }
+
+    public static final class Builder {
+      private String id = "";
+      private String cluster = "";
+      @Nullable
+      private Map<String, ?> metadata;
+      @Nullable
+      private Locality locality;
+      // TODO(sanjaypujare): eliminate usage of listening_addresses field.
+      private final List<Address> listeningAddresses = new ArrayList<>();
+      private String buildVersion = "";
+      private String userAgentName = "";
+      @Nullable
+      private String userAgentVersion;
+      private final List<String> clientFeatures = new ArrayList<>();
+
+      private Builder() {
+      }
+
+      @VisibleForTesting
+      public Builder setId(String id) {
+        this.id = checkNotNull(id, "id");
+        return this;
+      }
+
+      @CanIgnoreReturnValue
+      public Builder setCluster(String cluster) {
+        this.cluster = checkNotNull(cluster, "cluster");
+        return this;
+      }
+
+      @CanIgnoreReturnValue
+      public Builder setMetadata(Map<String, ?> metadata) {
+        this.metadata = checkNotNull(metadata, "metadata");
+        return this;
+      }
+
+      @CanIgnoreReturnValue
+      public Builder setLocality(Locality locality) {
+        this.locality = checkNotNull(locality, "locality");
+        return this;
+      }
+
+      @CanIgnoreReturnValue
+      Builder addListeningAddresses(Address address) {
+        listeningAddresses.add(checkNotNull(address, "address"));
+        return this;
+      }
+
+      @CanIgnoreReturnValue
+      public Builder setBuildVersion(String buildVersion) {
+        this.buildVersion = checkNotNull(buildVersion, "buildVersion");
+        return this;
+      }
+
+      @CanIgnoreReturnValue
+      public Builder setUserAgentName(String userAgentName) {
+        this.userAgentName = checkNotNull(userAgentName, "userAgentName");
+        return this;
+      }
+
+      @CanIgnoreReturnValue
+      public Builder setUserAgentVersion(String userAgentVersion) {
+        this.userAgentVersion = checkNotNull(userAgentVersion, "userAgentVersion");
+        return this;
+      }
+
+      @CanIgnoreReturnValue
+      public Builder addClientFeatures(String clientFeature) {
+        this.clientFeatures.add(checkNotNull(clientFeature, "clientFeature"));
+        return this;
+      }
+
+      public Node build() {
+        return new Node(
+            id, cluster, metadata, locality, listeningAddresses, buildVersion, userAgentName,
+            userAgentVersion, clientFeatures);
+      }
+    }
+
+    public static Builder newBuilder() {
+      return new Builder();
+    }
+
+    public Builder toBuilder() {
+      Builder builder = new Builder();
+      builder.id = id;
+      builder.cluster = cluster;
+      builder.metadata = metadata;
+      builder.locality = locality;
+      builder.buildVersion = buildVersion;
+      builder.listeningAddresses.addAll(listeningAddresses);
+      builder.userAgentName = userAgentName;
+      builder.userAgentVersion = userAgentVersion;
+      builder.clientFeatures.addAll(clientFeatures);
+      return builder;
+    }
+
+    public String getId() {
+      return id;
+    }
+
+    String getCluster() {
+      return cluster;
+    }
+
+    @Nullable
+    Map<String, ?> getMetadata() {
+      return metadata;
+    }
+
+    @Nullable
+    Locality getLocality() {
+      return locality;
+    }
+
+    List<Address> getListeningAddresses() {
+      return listeningAddresses;
+    }
+
+    @SuppressWarnings("deprecation")
+    @VisibleForTesting
+    public io.envoyproxy.envoy.config.core.v3.Node toEnvoyProtoNode() {
+      io.envoyproxy.envoy.config.core.v3.Node.Builder builder =
+          io.envoyproxy.envoy.config.core.v3.Node.newBuilder();
+      builder.setId(id);
+      builder.setCluster(cluster);
+      if (metadata != null) {
+        Struct.Builder structBuilder = Struct.newBuilder();
+        for (Map.Entry<String, ?> entry : metadata.entrySet()) {
+          structBuilder.putFields(entry.getKey(), convertToValue(entry.getValue()));
+        }
+        builder.setMetadata(structBuilder);
+      }
+      if (locality != null) {
+        builder.setLocality(
+            io.envoyproxy.envoy.config.core.v3.Locality.newBuilder()
+                .setRegion(locality.region())
+                .setZone(locality.zone())
+                .setSubZone(locality.subZone()));
+      }
+      for (Address address : listeningAddresses) {
+        builder.addListeningAddresses(address.toEnvoyProtoAddress());
+      }
+      builder.setUserAgentName(userAgentName);
+      if (userAgentVersion != null) {
+        builder.setUserAgentVersion(userAgentVersion);
+      }
+      builder.addAllClientFeatures(clientFeatures);
+      return builder.build();
+    }
+  }
+
+  /**
+   * Converts Java representation of the given JSON value to protobuf's {@link
+   * com.google.protobuf.Value} representation.
+   *
+   * <p>The given {@code rawObject} must be a valid JSON value in Java representation, which is
+   * either a {@code Map<String, ?>}, {@code List<?>}, {@code String}, {@code Double}, {@code
+   * Boolean}, or {@code null}.
+   */
+  private static Value convertToValue(Object rawObject) {
+    Value.Builder valueBuilder = Value.newBuilder();
+    if (rawObject == null) {
+      valueBuilder.setNullValue(NullValue.NULL_VALUE);
+    } else if (rawObject instanceof Double) {
+      valueBuilder.setNumberValue((Double) rawObject);
+    } else if (rawObject instanceof String) {
+      valueBuilder.setStringValue((String) rawObject);
+    } else if (rawObject instanceof Boolean) {
+      valueBuilder.setBoolValue((Boolean) rawObject);
+    } else if (rawObject instanceof Map) {
+      Struct.Builder structBuilder = Struct.newBuilder();
+      @SuppressWarnings("unchecked")
+      Map<String, ?> map = (Map<String, ?>) rawObject;
+      for (Map.Entry<String, ?> entry : map.entrySet()) {
+        structBuilder.putFields(entry.getKey(), convertToValue(entry.getValue()));
+      }
+      valueBuilder.setStructValue(structBuilder);
+    } else if (rawObject instanceof List) {
+      ListValue.Builder listBuilder = ListValue.newBuilder();
+      List<?> list = (List<?>) rawObject;
+      for (Object obj : list) {
+        listBuilder.addValues(convertToValue(obj));
+      }
+      valueBuilder.setListValue(listBuilder);
+    }
+    return valueBuilder.build();
+  }
+
+  /**
+   * See corresponding Envoy proto message {@link io.envoyproxy.envoy.config.core.v3.Address}.
+   */
+  static final class Address {
+    private final String address;
+    private final int port;
+
+    Address(String address, int port) {
+      this.address = checkNotNull(address, "address");
+      this.port = port;
+    }
+
+    io.envoyproxy.envoy.config.core.v3.Address toEnvoyProtoAddress() {
+      return
+          io.envoyproxy.envoy.config.core.v3.Address.newBuilder().setSocketAddress(
+              io.envoyproxy.envoy.config.core.v3.SocketAddress.newBuilder().setAddress(address)
+                  .setPortValue(port)).build();
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("address", address)
+          .add("port", port)
+          .toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (o == null || getClass() != o.getClass()) {
+        return false;
+      }
+      Address address1 = (Address) o;
+      return port == address1.port && Objects.equals(address, address1.address);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(address, port);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/LoadReportClient.java b/xds/src/main/java/io/grpc/xds/client/LoadReportClient.java
new file mode 100644
index 00000000000..959cb364e47
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/LoadReportClient.java
@@ -0,0 +1,371 @@
+/*
+ * Copyright 2019 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.xds.client;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.protobuf.util.Durations;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadReportingServiceGrpc;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse;
+import io.grpc.Internal;
+import io.grpc.InternalLogId;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+import io.grpc.xds.client.Stats.ClusterStats;
+import io.grpc.xds.client.Stats.DroppedRequests;
+import io.grpc.xds.client.Stats.UpstreamLocalityStats;
+import io.grpc.xds.client.XdsLogger.XdsLogLevel;
+import io.grpc.xds.client.XdsTransportFactory.EventHandler;
+import io.grpc.xds.client.XdsTransportFactory.StreamingCall;
+import io.grpc.xds.client.XdsTransportFactory.XdsTransport;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import javax.annotation.Nullable;
+
+/**
+ * Client of xDS load reporting service based on LRS protocol, which reports load stats of
+ * gRPC client's perspective to a management server.
+ */
+@Internal
+public final class LoadReportClient {
+  private final InternalLogId logId;
+  private final XdsLogger logger;
+  private final XdsTransport xdsTransport;
+  private final Node node;
+  private final SynchronizationContext syncContext;
+  private final ScheduledExecutorService timerService;
+  private final Stopwatch retryStopwatch;
+  private final BackoffPolicy.Provider backoffPolicyProvider;
+  @VisibleForTesting
+  public final LoadStatsManager2 loadStatsManager;
+  private boolean started;
+  @Nullable
+  private BackoffPolicy lrsRpcRetryPolicy;
+  @Nullable
+  private ScheduledHandle lrsRpcRetryTimer;
+  @Nullable
+  private LrsStream lrsStream;
+  private static final MethodDescriptor<LoadStatsRequest, LoadStatsResponse> method =
+      LoadReportingServiceGrpc.getStreamLoadStatsMethod();
+
+  @VisibleForTesting
+  public LoadReportClient(
+      LoadStatsManager2 loadStatsManager,
+      XdsTransport xdsTransport,
+      Node node,
+      SynchronizationContext syncContext,
+      ScheduledExecutorService scheduledExecutorService,
+      BackoffPolicy.Provider backoffPolicyProvider,
+      Supplier<Stopwatch> stopwatchSupplier) {
+    this.loadStatsManager = checkNotNull(loadStatsManager, "loadStatsManager");
+    this.xdsTransport = checkNotNull(xdsTransport, "xdsTransport");
+    this.syncContext = checkNotNull(syncContext, "syncContext");
+    this.timerService = checkNotNull(scheduledExecutorService, "timeService");
+    this.backoffPolicyProvider = checkNotNull(backoffPolicyProvider, "backoffPolicyProvider");
+    this.retryStopwatch = checkNotNull(stopwatchSupplier, "stopwatchSupplier").get();
+    this.node = checkNotNull(node, "node").toBuilder()
+        .addClientFeatures("envoy.lrs.supports_send_all_clusters").build();
+    logId = InternalLogId.allocate("lrs-client", null);
+    logger = XdsLogger.withLogId(logId);
+    logger.log(XdsLogLevel.INFO, "Created");
+  }
+
+  @VisibleForTesting
+  public boolean lrsStreamIsNull() {
+    return lrsStream == null;
+  }
+
+  /**
+   * Establishes load reporting communication and negotiates with traffic director to report load
+   * stats periodically. Calling this method on an already started {@link LoadReportClient} is
+   * no-op.
+   */
+  public void startLoadReporting() {
+    syncContext.throwIfNotInThisSynchronizationContext();
+    if (started) {
+      return;
+    }
+    started = true;
+    logger.log(XdsLogLevel.INFO, "Starting load reporting RPC");
+    startLrsRpc();
+  }
+
+  /**
+   * Terminates load reporting. Calling this method on an already stopped
+   * {@link LoadReportClient} is no-op.
+   */
+  public void stopLoadReporting() {
+    syncContext.throwIfNotInThisSynchronizationContext();
+    if (!started) {
+      return;
+    }
+    started = false;
+    logger.log(XdsLogLevel.INFO, "Stopping load reporting RPC");
+    if (lrsRpcRetryTimer != null && lrsRpcRetryTimer.isPending()) {
+      lrsRpcRetryTimer.cancel();
+    }
+    if (lrsStream != null) {
+      lrsStream.close(Status.CANCELLED.withDescription("stop load reporting").asException());
+    }
+    // Do not shut down channel as it is not owned by LrsClient.
+  }
+
+  private static class LoadReportingTask implements Runnable {
+    private final LrsStream stream;
+
+    LoadReportingTask(LrsStream stream) {
+      this.stream = stream;
+    }
+
+    @Override
+    public void run() {
+      stream.sendLoadReport();
+    }
+  }
+
+  private class LrsRpcRetryTask implements Runnable {
+
+    @Override
+    public void run() {
+      startLrsRpc();
+    }
+  }
+
+  private void startLrsRpc() {
+    if (!started) {
+      return;
+    }
+    checkState(lrsStream == null, "previous lbStream has not been cleared yet");
+    retryStopwatch.reset().start();
+    lrsStream = new LrsStream();
+  }
+
+  private final class LrsStream implements EventHandler<LoadStatsResponse> {
+    boolean initialResponseReceived;
+    boolean closed;
+    long intervalNano = -1;
+    boolean reportAllClusters;
+    List<String> clusterNames;  // clusters to report loads for, if not report all.
+    ScheduledHandle loadReportTimer;
+    private final StreamingCall<LoadStatsRequest, LoadStatsResponse> call;
+
+    LrsStream() {
+      this.call = xdsTransport.createStreamingCall(method.getFullMethodName(),
+          method.getRequestMarshaller(), method.getResponseMarshaller());
+      call.start(this);
+      logger.log(XdsLogLevel.DEBUG, "Sending initial LRS request");
+      sendLoadStatsRequest(Collections.<ClusterStats>emptyList());
+    }
+
+    @Override
+    public void onReady() {}
+
+    @Override
+    public void onRecvMessage(LoadStatsResponse response) {
+      syncContext.execute(new Runnable() {
+        @Override
+        public void run() {
+          logger.log(XdsLogLevel.DEBUG, "Received LRS response:\n{0}", response);
+          handleRpcResponse(response.getClustersList(), response.getSendAllClusters(),
+              Durations.toNanos(response.getLoadReportingInterval()));
+          call.startRecvMessage();
+        }
+      });
+    }
+
+    @Override
+    public void onStatusReceived(final Status status) {
+      syncContext.execute(new Runnable() {
+        @Override
+        public void run() {
+          if (status.isOk()) {
+            handleStreamClosed(Status.UNAVAILABLE.withDescription("Closed by server"));
+          } else {
+            handleStreamClosed(status);
+          }
+        }
+      });
+    }
+
+    void sendLoadStatsRequest(List<ClusterStats> clusterStatsList) {
+      LoadStatsRequest.Builder requestBuilder =
+          LoadStatsRequest.newBuilder().setNode(node.toEnvoyProtoNode());
+      for (ClusterStats stats : clusterStatsList) {
+        requestBuilder.addClusterStats(buildClusterStats(stats));
+      }
+      LoadStatsRequest request = requestBuilder.build();
+      call.sendMessage(request);
+      logger.log(XdsLogLevel.DEBUG, "Sent LoadStatsRequest\n{0}", request);
+    }
+
+    void handleRpcResponse(List<String> clusters, boolean sendAllClusters,
+                           long loadReportIntervalNano) {
+      if (closed) {
+        return;
+      }
+      if (!initialResponseReceived) {
+        logger.log(XdsLogLevel.DEBUG, "Initial LRS response received");
+        initialResponseReceived = true;
+      }
+      reportAllClusters = sendAllClusters;
+      if (reportAllClusters) {
+        logger.log(XdsLogLevel.INFO, "Report loads for all clusters");
+      } else {
+        logger.log(XdsLogLevel.INFO, "Report loads for clusters: ", clusters);
+        clusterNames = clusters;
+      }
+      intervalNano = loadReportIntervalNano;
+      logger.log(XdsLogLevel.INFO, "Update load reporting interval to {0} ns", intervalNano);
+      scheduleNextLoadReport();
+    }
+
+    private void sendLoadReport() {
+      if (closed) {
+        return;
+      }
+      List<ClusterStats> clusterStatsList;
+      if (reportAllClusters) {
+        clusterStatsList = loadStatsManager.getAllClusterStatsReports();
+      } else {
+        clusterStatsList = new ArrayList<>();
+        for (String name : clusterNames) {
+          clusterStatsList.addAll(loadStatsManager.getClusterStatsReports(name));
+        }
+      }
+      sendLoadStatsRequest(clusterStatsList);
+      scheduleNextLoadReport();
+    }
+
+    private void scheduleNextLoadReport() {
+      // Cancel pending load report and reschedule with updated load reporting interval.
+      if (loadReportTimer != null && loadReportTimer.isPending()) {
+        loadReportTimer.cancel();
+        loadReportTimer = null;
+      }
+      if (intervalNano > 0) {
+        loadReportTimer = syncContext.schedule(
+            new LoadReportingTask(this), intervalNano, TimeUnit.NANOSECONDS, timerService);
+      }
+    }
+
+    private void handleStreamClosed(Status status) {
+      checkArgument(!status.isOk(), "unexpected OK status");
+      if (closed) {
+        return;
+      }
+      logger.log(
+          XdsLogLevel.ERROR,
+          "LRS stream closed with status {0}: {1}. Cause: {2}",
+          status.getCode(), status.getDescription(), status.getCause());
+      closed = true;
+      cleanUp();
+
+      if (initialResponseReceived || lrsRpcRetryPolicy == null) {
+        // Reset the backoff sequence if balancer has sent the initial response, or backoff sequence
+        // has never been initialized.
+        lrsRpcRetryPolicy = backoffPolicyProvider.get();
+      }
+      // The back-off policy determines the interval between consecutive RPC upstarts, thus the
+      // actual delay may be smaller than the value from the back-off policy, or even negative,
+      // depending on how much time was spent in the previous RPC.
+      long delayNanos =
+          lrsRpcRetryPolicy.nextBackoffNanos() - retryStopwatch.elapsed(TimeUnit.NANOSECONDS);
+      logger.log(XdsLogLevel.INFO, "Retry LRS stream in {0} ns", delayNanos);
+      if (delayNanos <= 0) {
+        startLrsRpc();
+      } else {
+        lrsRpcRetryTimer = syncContext.schedule(
+            new LrsRpcRetryTask(), delayNanos, TimeUnit.NANOSECONDS, timerService);
+      }
+    }
+
+    private void close(Exception error) {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      cleanUp();
+      call.sendError(error);
+    }
+
+    private void cleanUp() {
+      if (loadReportTimer != null && loadReportTimer.isPending()) {
+        loadReportTimer.cancel();
+        loadReportTimer = null;
+      }
+      if (lrsStream == this) {
+        lrsStream = null;
+      }
+    }
+
+    private io.envoyproxy.envoy.config.endpoint.v3.ClusterStats buildClusterStats(
+        ClusterStats stats) {
+      io.envoyproxy.envoy.config.endpoint.v3.ClusterStats.Builder builder =
+          io.envoyproxy.envoy.config.endpoint.v3.ClusterStats.newBuilder()
+              .setClusterName(stats.clusterName());
+      if (stats.clusterServiceName() != null) {
+        builder.setClusterServiceName(stats.clusterServiceName());
+      }
+      for (UpstreamLocalityStats upstreamLocalityStats : stats.upstreamLocalityStatsList()) {
+        builder.addUpstreamLocalityStats(
+            io.envoyproxy.envoy.config.endpoint.v3.UpstreamLocalityStats.newBuilder()
+                .setLocality(
+                    io.envoyproxy.envoy.config.core.v3.Locality.newBuilder()
+                        .setRegion(upstreamLocalityStats.locality().region())
+                        .setZone(upstreamLocalityStats.locality().zone())
+                        .setSubZone(upstreamLocalityStats.locality().subZone()))
+            .setTotalSuccessfulRequests(upstreamLocalityStats.totalSuccessfulRequests())
+            .setTotalErrorRequests(upstreamLocalityStats.totalErrorRequests())
+            .setTotalRequestsInProgress(upstreamLocalityStats.totalRequestsInProgress())
+            .setTotalIssuedRequests(upstreamLocalityStats.totalIssuedRequests())
+            .addAllLoadMetricStats(
+                upstreamLocalityStats.loadMetricStatsMap().entrySet().stream().map(
+                    e -> io.envoyproxy.envoy.config.endpoint.v3.EndpointLoadMetricStats.newBuilder()
+                        .setMetricName(e.getKey())
+                        .setNumRequestsFinishedWithMetric(
+                            e.getValue().numRequestsFinishedWithMetric())
+                        .setTotalMetricValue(e.getValue().totalMetricValue())
+                        .build())
+                .collect(Collectors.toList())));
+      }
+      for (DroppedRequests droppedRequests : stats.droppedRequestsList()) {
+        builder.addDroppedRequests(
+            io.envoyproxy.envoy.config.endpoint.v3.ClusterStats.DroppedRequests.newBuilder()
+                .setCategory(droppedRequests.category())
+                .setDroppedCount(droppedRequests.droppedCount()));
+      }
+      return builder
+          .setTotalDroppedRequests(stats.totalDroppedRequests())
+          .setLoadReportInterval(Durations.fromNanos(stats.loadReportIntervalNano()))
+          .build();
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/LoadStatsManager2.java b/xds/src/main/java/io/grpc/xds/client/LoadStatsManager2.java
new file mode 100644
index 00000000000..cd858dccd99
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/LoadStatsManager2.java
@@ -0,0 +1,472 @@
+/*
+ * Copyright 2021 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.xds.client;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.Sets;
+import io.grpc.Internal;
+import io.grpc.Status;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.xds.client.Stats.BackendLoadMetricStats;
+import io.grpc.xds.client.Stats.ClusterStats;
+import io.grpc.xds.client.Stats.DroppedRequests;
+import io.grpc.xds.client.Stats.UpstreamLocalityStats;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Manages client side traffic stats. Drop stats are maintained in cluster (with edsServiceName)
+ * granularity and load stats (request counts) are maintained in locality granularity.
+ */
+@ThreadSafe
+@Internal
+public final class LoadStatsManager2 {
+  // Recorders for drops of each cluster:edsServiceName.
+  private final Map<String, Map<String, ReferenceCounted<ClusterDropStats>>> allDropStats =
+      new HashMap<>();
+  // Recorders for loads of each cluster:edsServiceName:locality.
+  private final Map<String, Map<String,
+      Map<Locality, ReferenceCounted<ClusterLocalityStats>>>> allLoadStats = new HashMap<>();
+  private final Supplier<Stopwatch> stopwatchSupplier;
+  public static boolean isEnabledOrcaLrsPropagation =
+      GrpcUtil.getFlag("GRPC_EXPERIMENTAL_XDS_ORCA_LRS_PROPAGATION", false);
+
+  @VisibleForTesting
+  public LoadStatsManager2(Supplier<Stopwatch> stopwatchSupplier) {
+    this.stopwatchSupplier = checkNotNull(stopwatchSupplier, "stopwatchSupplier");
+  }
+
+  /**
+   * Gets or creates the stats object for recording drops for the specified cluster with
+   * edsServiceName. The returned object is reference counted and the caller should use {@link
+   * ClusterDropStats#release()} to release its <i>hard</i> reference when it is safe to discard
+   * future stats for the cluster.
+   */
+  @VisibleForTesting
+  public synchronized ClusterDropStats getClusterDropStats(
+      String cluster, @Nullable String edsServiceName) {
+    if (!allDropStats.containsKey(cluster)) {
+      allDropStats.put(cluster, new HashMap<String, ReferenceCounted<ClusterDropStats>>());
+    }
+    Map<String, ReferenceCounted<ClusterDropStats>> perClusterCounters = allDropStats.get(cluster);
+    if (!perClusterCounters.containsKey(edsServiceName)) {
+      perClusterCounters.put(
+          edsServiceName,
+          ReferenceCounted.wrap(new ClusterDropStats(
+              cluster, edsServiceName, stopwatchSupplier.get())));
+    }
+    ReferenceCounted<ClusterDropStats> ref = perClusterCounters.get(edsServiceName);
+    ref.retain();
+    return ref.get();
+  }
+
+  private synchronized void releaseClusterDropCounter(
+      String cluster, @Nullable String edsServiceName) {
+    checkState(allDropStats.containsKey(cluster)
+            && allDropStats.get(cluster).containsKey(edsServiceName),
+        "stats for cluster %s, edsServiceName %s do not exist", cluster, edsServiceName);
+    ReferenceCounted<ClusterDropStats> ref = allDropStats.get(cluster).get(edsServiceName);
+    ref.release();
+  }
+
+  /**
+   * Gets or creates the stats object for recording loads for the specified locality (in the
+   * specified cluster with edsServiceName) with the specified backend metric propagation
+   * configuration. The returned object is reference counted and the caller should
+   * use {@link ClusterLocalityStats#release} to release its <i>hard</i> reference
+   * when it is safe to discard the future stats for the locality.
+   */
+  @VisibleForTesting
+  public synchronized ClusterLocalityStats getClusterLocalityStats(
+      String cluster, @Nullable String edsServiceName, Locality locality) {
+    return getClusterLocalityStats(cluster, edsServiceName, locality, null);
+  }
+
+  public synchronized ClusterLocalityStats getClusterLocalityStats(
+      String cluster, @Nullable String edsServiceName, Locality locality,
+      @Nullable BackendMetricPropagation backendMetricPropagation) {
+    if (!allLoadStats.containsKey(cluster)) {
+      allLoadStats.put(
+          cluster,
+          new HashMap<String, Map<Locality, ReferenceCounted<ClusterLocalityStats>>>());
+    }
+    Map<String, Map<Locality, ReferenceCounted<ClusterLocalityStats>>> perClusterCounters =
+        allLoadStats.get(cluster);
+    if (!perClusterCounters.containsKey(edsServiceName)) {
+      perClusterCounters.put(
+          edsServiceName, new HashMap<Locality, ReferenceCounted<ClusterLocalityStats>>());
+    }
+    Map<Locality, ReferenceCounted<ClusterLocalityStats>> localityStats =
+        perClusterCounters.get(edsServiceName);
+    if (!localityStats.containsKey(locality)) {
+      localityStats.put(
+          locality,
+          ReferenceCounted.wrap(new ClusterLocalityStats(cluster, edsServiceName,
+              locality, stopwatchSupplier.get(), backendMetricPropagation)));
+    }
+    ReferenceCounted<ClusterLocalityStats> ref = localityStats.get(locality);
+    ref.retain();
+    return ref.get();
+  }
+
+  private synchronized void releaseClusterLocalityLoadCounter(
+      String cluster, @Nullable String edsServiceName, Locality locality) {
+    checkState(allLoadStats.containsKey(cluster)
+            && allLoadStats.get(cluster).containsKey(edsServiceName)
+            && allLoadStats.get(cluster).get(edsServiceName).containsKey(locality),
+        "stats for cluster %s, edsServiceName %s, locality %s not exits",
+        cluster, edsServiceName, locality);
+    ReferenceCounted<ClusterLocalityStats> ref =
+        allLoadStats.get(cluster).get(edsServiceName).get(locality);
+    ref.release();
+  }
+
+  /**
+   * Gets the traffic stats (drops and loads) as a list of {@link ClusterStats} recorded for the
+   * specified cluster since the previous call of this method or {@link
+   * #getAllClusterStatsReports}. A {@link ClusterStats} includes stats for a specific cluster with
+   * edsServiceName.
+   */
+  public synchronized List<ClusterStats> getClusterStatsReports(String cluster) {
+    if (!allDropStats.containsKey(cluster) && !allLoadStats.containsKey(cluster)) {
+      return Collections.emptyList();
+    }
+    Map<String, ReferenceCounted<ClusterDropStats>> clusterDropStats = allDropStats.get(cluster);
+    Map<String, Map<Locality, ReferenceCounted<ClusterLocalityStats>>> clusterLoadStats =
+        allLoadStats.get(cluster);
+    Map<String, ClusterStats.Builder> statsReportBuilders = new HashMap<>();
+    // Populate drop stats.
+    if (clusterDropStats != null) {
+      Set<String> toDiscard = new HashSet<>();
+      for (String edsServiceName : clusterDropStats.keySet()) {
+        ClusterStats.Builder builder = ClusterStats.newBuilder().clusterName(cluster);
+        if (edsServiceName != null) {
+          builder.clusterServiceName(edsServiceName);
+        }
+        ReferenceCounted<ClusterDropStats> ref = clusterDropStats.get(edsServiceName);
+        if (ref.getReferenceCount() == 0) {  // stats object no longer needed after snapshot
+          toDiscard.add(edsServiceName);
+        }
+        ClusterDropStatsSnapshot dropStatsSnapshot = ref.get().snapshot();
+        long totalCategorizedDrops = 0L;
+        for (Map.Entry<String, Long> entry : dropStatsSnapshot.categorizedDrops.entrySet()) {
+          builder.addDroppedRequests(DroppedRequests.create(entry.getKey(), entry.getValue()));
+          totalCategorizedDrops += entry.getValue();
+        }
+        builder.totalDroppedRequests(
+            totalCategorizedDrops + dropStatsSnapshot.uncategorizedDrops);
+        builder.loadReportIntervalNano(dropStatsSnapshot.durationNano);
+        statsReportBuilders.put(edsServiceName, builder);
+      }
+      clusterDropStats.keySet().removeAll(toDiscard);
+    }
+    // Populate load stats for all localities in the cluster.
+    if (clusterLoadStats != null) {
+      Set<String> toDiscard = new HashSet<>();
+      for (String edsServiceName : clusterLoadStats.keySet()) {
+        ClusterStats.Builder builder = statsReportBuilders.get(edsServiceName);
+        if (builder == null) {
+          builder = ClusterStats.newBuilder().clusterName(cluster);
+          if (edsServiceName != null) {
+            builder.clusterServiceName(edsServiceName);
+          }
+          statsReportBuilders.put(edsServiceName, builder);
+        }
+        Map<Locality, ReferenceCounted<ClusterLocalityStats>> localityStats =
+            clusterLoadStats.get(edsServiceName);
+        Set<Locality> localitiesToDiscard = new HashSet<>();
+        for (Locality locality : localityStats.keySet()) {
+          ReferenceCounted<ClusterLocalityStats> ref = localityStats.get(locality);
+          ClusterLocalityStatsSnapshot snapshot = ref.get().snapshot();
+          // Only discard stats object after all in-flight calls under recording had finished.
+          if (ref.getReferenceCount() == 0 && snapshot.callsInProgress == 0) {
+            localitiesToDiscard.add(locality);
+          }
+          UpstreamLocalityStats upstreamLocalityStats = UpstreamLocalityStats.create(
+              locality, snapshot.callsIssued, snapshot.callsSucceeded, snapshot.callsFailed,
+              snapshot.callsInProgress, snapshot.loadMetricStatsMap);
+          builder.addUpstreamLocalityStats(upstreamLocalityStats);
+          // Use the max (drops/loads) recording interval as the overall interval for the
+          // cluster's stats. In general, they should be mostly identical.
+          builder.loadReportIntervalNano(
+              Math.max(builder.loadReportIntervalNano(), snapshot.durationNano));
+        }
+        localityStats.keySet().removeAll(localitiesToDiscard);
+        if (localityStats.isEmpty()) {
+          toDiscard.add(edsServiceName);
+        }
+      }
+      clusterLoadStats.keySet().removeAll(toDiscard);
+    }
+    List<ClusterStats> res = new ArrayList<>();
+    for (ClusterStats.Builder builder : statsReportBuilders.values()) {
+      res.add(builder.build());
+    }
+    return Collections.unmodifiableList(res);
+  }
+
+  /**
+   * Gets the traffic stats (drops and loads) as a list of {@link ClusterStats} recorded for all
+   * clusters since the previous call of this method or {@link #getClusterStatsReports} for each
+   * specific cluster. A {@link ClusterStats} includes stats for a specific cluster with
+   * edsServiceName.
+   */
+  synchronized List<ClusterStats> getAllClusterStatsReports() {
+    Set<String> allClusters = Sets.union(allDropStats.keySet(), allLoadStats.keySet());
+    List<ClusterStats> res = new ArrayList<>();
+    for (String cluster : allClusters) {
+      res.addAll(getClusterStatsReports(cluster));
+    }
+    return Collections.unmodifiableList(res);
+  }
+
+  /**
+   * Recorder for dropped requests. One instance per cluster with edsServiceName.
+   */
+  @ThreadSafe
+  public final class ClusterDropStats {
+    private final String clusterName;
+    @Nullable
+    private final String edsServiceName;
+    private final AtomicLong uncategorizedDrops = new AtomicLong();
+    private final ConcurrentMap<String, AtomicLong> categorizedDrops = new ConcurrentHashMap<>();
+    private final Stopwatch stopwatch;
+
+    private ClusterDropStats(
+        String clusterName, @Nullable String edsServiceName, Stopwatch stopwatch) {
+      this.clusterName = checkNotNull(clusterName, "clusterName");
+      this.edsServiceName = edsServiceName;
+      this.stopwatch = checkNotNull(stopwatch, "stopwatch");
+      stopwatch.reset().start();
+    }
+
+    /**
+     * Records a dropped request with the specified category.
+     */
+    public void recordDroppedRequest(String category) {
+      // There is a race between this method and snapshot(), causing one drop recorded but may not
+      // be included in any snapshot. This is acceptable and the race window is extremely small.
+      AtomicLong counter = categorizedDrops.putIfAbsent(category, new AtomicLong(1L));
+      if (counter != null) {
+        counter.getAndIncrement();
+      }
+    }
+
+    /**
+     * Records a dropped request without category.
+     */
+    public void recordDroppedRequest() {
+      uncategorizedDrops.getAndIncrement();
+    }
+
+    /**
+     * Release the <i>hard</i> reference for this stats object (previously obtained via {@link
+     * LoadStatsManager2#getClusterDropStats}). The object may still be recording
+     * drops after this method, but there is no guarantee drops recorded after this point will
+     * be included in load reports.
+     */
+    public void release() {
+      LoadStatsManager2.this.releaseClusterDropCounter(clusterName, edsServiceName);
+    }
+
+    private ClusterDropStatsSnapshot snapshot() {
+      Map<String, Long> drops = new HashMap<>();
+      for (Map.Entry<String, AtomicLong> entry : categorizedDrops.entrySet()) {
+        drops.put(entry.getKey(), entry.getValue().get());
+      }
+      categorizedDrops.clear();
+      long duration = stopwatch.elapsed(TimeUnit.NANOSECONDS);
+      stopwatch.reset().start();
+      return new ClusterDropStatsSnapshot(drops, uncategorizedDrops.getAndSet(0), duration);
+    }
+  }
+
+  private static final class ClusterDropStatsSnapshot {
+    private final Map<String, Long> categorizedDrops;
+    private final long uncategorizedDrops;
+    private final long durationNano;
+
+    private ClusterDropStatsSnapshot(
+        Map<String, Long> categorizedDrops, long uncategorizedDrops, long durationNano) {
+      this.categorizedDrops = Collections.unmodifiableMap(
+          checkNotNull(categorizedDrops, "categorizedDrops"));
+      this.uncategorizedDrops = uncategorizedDrops;
+      this.durationNano = durationNano;
+    }
+  }
+
+  /**
+   * Recorder for client loads. One instance per locality (in cluster with edsService).
+   */
+  @ThreadSafe
+  public final class ClusterLocalityStats {
+    private final String clusterName;
+    @Nullable
+    private final String edsServiceName;
+    private final Locality locality;
+    private final Stopwatch stopwatch;
+    @Nullable
+    private final BackendMetricPropagation backendMetricPropagation;
+    private final AtomicLong callsInProgress = new AtomicLong();
+    private final AtomicLong callsSucceeded = new AtomicLong();
+    private final AtomicLong callsFailed = new AtomicLong();
+    private final AtomicLong callsIssued = new AtomicLong();
+    private Map<String, BackendLoadMetricStats> loadMetricStatsMap = new HashMap<>();
+
+    private ClusterLocalityStats(
+        String clusterName, @Nullable String edsServiceName, Locality locality,
+        Stopwatch stopwatch, BackendMetricPropagation backendMetricPropagation) {
+      this.clusterName = checkNotNull(clusterName, "clusterName");
+      this.edsServiceName = edsServiceName;
+      this.locality = checkNotNull(locality, "locality");
+      this.stopwatch = checkNotNull(stopwatch, "stopwatch");
+      this.backendMetricPropagation = backendMetricPropagation;
+      stopwatch.reset().start();
+    }
+
+    /**
+     * Records a request being issued.
+     */
+    public void recordCallStarted() {
+      callsIssued.getAndIncrement();
+      callsInProgress.getAndIncrement();
+    }
+
+    /**
+     * Records a request finished with the given status.
+     */
+    public void recordCallFinished(Status status) {
+      callsInProgress.getAndDecrement();
+      if (status.isOk()) {
+        callsSucceeded.getAndIncrement();
+      } else {
+        callsFailed.getAndIncrement();
+      }
+    }
+
+    /**
+     * Records all custom named backend load metric stats for per-call load reporting. For each
+     * metric key {@code name}, creates a new {@link BackendLoadMetricStats} with a finished
+     * requests counter of 1 and the {@code value} if the key is not present in the map. Otherwise,
+     * increments the finished requests counter and adds the {@code value} to the existing
+     * {@link BackendLoadMetricStats}.
+     * Metrics are filtered based on the backend metric propagation configuration if configured.
+     */
+    public synchronized void recordBackendLoadMetricStats(Map<String, Double> namedMetrics) {
+      if (!isEnabledOrcaLrsPropagation) {
+        namedMetrics.forEach((name, value) -> updateLoadMetricStats(name, value));
+        return;
+      }
+
+      namedMetrics.forEach((name, value) -> {
+        if (backendMetricPropagation.shouldPropagateNamedMetric(name)) {
+          updateLoadMetricStats("named_metrics." + name, value);
+        }
+      });
+    }
+
+    private void updateLoadMetricStats(String metricName, double value) {
+      if (!loadMetricStatsMap.containsKey(metricName)) {
+        loadMetricStatsMap.put(metricName, new BackendLoadMetricStats(1, value));
+      } else {
+        loadMetricStatsMap.get(metricName).addMetricValueAndIncrementRequestsFinished(value);
+      }
+    }
+
+    /**
+     * Records top-level ORCA metrics (CPU, memory, application utilization) for per-call load
+     * reporting. Metrics are filtered based on the backend metric propagation configuration
+     * if configured.
+     *
+     * @param cpuUtilization CPU utilization metric value
+     * @param memUtilization Memory utilization metric value
+     * @param applicationUtilization Application utilization metric value
+     */
+    public synchronized void recordTopLevelMetrics(double cpuUtilization, double memUtilization,
+        double applicationUtilization) {
+      if (backendMetricPropagation.propagateCpuUtilization && cpuUtilization > 0) {
+        updateLoadMetricStats("cpu_utilization", cpuUtilization);
+      }
+      if (backendMetricPropagation.propagateMemUtilization && memUtilization > 0) {
+        updateLoadMetricStats("mem_utilization", memUtilization);
+      }
+      if (backendMetricPropagation.propagateApplicationUtilization && applicationUtilization > 0) {
+        updateLoadMetricStats("application_utilization", applicationUtilization);
+      }
+    }
+
+    /**
+     * Release the <i>hard</i> reference for this stats object (previously obtained via {@link
+     * LoadStatsManager2#getClusterLocalityStats}). The object may still be
+     * recording loads after this method, but there is no guarantee loads recorded after this
+     * point will be included in load reports.
+     */
+    public void release() {
+      LoadStatsManager2.this.releaseClusterLocalityLoadCounter(
+          clusterName, edsServiceName, locality);
+    }
+
+    private ClusterLocalityStatsSnapshot snapshot() {
+      long duration = stopwatch.elapsed(TimeUnit.NANOSECONDS);
+      stopwatch.reset().start();
+      Map<String, BackendLoadMetricStats> loadMetricStatsMapCopy;
+      synchronized (this) {
+        loadMetricStatsMapCopy = Collections.unmodifiableMap(loadMetricStatsMap);
+        loadMetricStatsMap = new HashMap<>();
+      }
+      return new ClusterLocalityStatsSnapshot(callsSucceeded.getAndSet(0), callsInProgress.get(),
+          callsFailed.getAndSet(0), callsIssued.getAndSet(0), duration, loadMetricStatsMapCopy);
+    }
+  }
+
+  private static final class ClusterLocalityStatsSnapshot {
+    private final long callsSucceeded;
+    private final long callsInProgress;
+    private final long callsFailed;
+    private final long callsIssued;
+    private final long durationNano;
+    private final Map<String, BackendLoadMetricStats> loadMetricStatsMap;
+
+    private ClusterLocalityStatsSnapshot(
+        long callsSucceeded, long callsInProgress, long callsFailed, long callsIssued,
+        long durationNano, Map<String, BackendLoadMetricStats> loadMetricStatsMap) {
+      this.callsSucceeded = callsSucceeded;
+      this.callsInProgress = callsInProgress;
+      this.callsFailed = callsFailed;
+      this.callsIssued = callsIssued;
+      this.durationNano = durationNano;
+      this.loadMetricStatsMap = Collections.unmodifiableMap(
+          checkNotNull(loadMetricStatsMap, "loadMetricStatsMap"));
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/Locality.java b/xds/src/main/java/io/grpc/xds/client/Locality.java
new file mode 100644
index 00000000000..226252e1548
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/Locality.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2021 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.xds.client;
+
+import com.google.auto.value.AutoValue;
+import io.grpc.Internal;
+
+/** Represents a network locality. */
+@AutoValue
+@Internal
+public abstract class Locality {
+  public abstract String region();
+
+  public abstract String zone();
+
+  public abstract String subZone();
+
+  public static Locality create(String region, String zone, String subZone) {
+    return new io.grpc.xds.client.AutoValue_Locality(region, zone, subZone);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/MessagePrettyPrinter.java b/xds/src/main/java/io/grpc/xds/client/MessagePrettyPrinter.java
new file mode 100644
index 00000000000..a2d00ba75ef
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/MessagePrettyPrinter.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2024 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.xds.client;
+
+import com.google.protobuf.MessageOrBuilder;
+import io.grpc.Internal;
+
+@Internal
+public interface MessagePrettyPrinter {
+  String print(MessageOrBuilder message);
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/ReferenceCounted.java b/xds/src/main/java/io/grpc/xds/client/ReferenceCounted.java
new file mode 100644
index 00000000000..893b0358246
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/ReferenceCounted.java
@@ -0,0 +1,61 @@
+/*
+ * 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.xds.client;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+/**
+ * A reference count wrapper for objects. This class does not take the ownership for the object,
+ * but only provides usage counting. The real owner of the wrapped object is responsible for
+ * managing the lifecycle of the object.
+ *
+ * <p>Intended for a container class to keep track of lifecycle for elements it contains. This
+ * wrapper itself should never be returned to the consumers of the elements to avoid reference
+ * counts being leaked.
+ */
+// TODO(chengyuanzhang): move this class into LoadStatsManager2.
+final class ReferenceCounted<T> {
+  private final T instance;
+  private int refs;
+
+  private ReferenceCounted(T instance) {
+    this.instance = instance;
+  }
+
+  static <T> ReferenceCounted<T> wrap(T instance) {
+    checkNotNull(instance, "instance");
+    return new ReferenceCounted<>(instance);
+  }
+
+  void retain() {
+    refs++;
+  }
+
+  void release() {
+    checkState(refs > 0, "reference reached 0");
+    refs--;
+  }
+
+  int getReferenceCount() {
+    return refs;
+  }
+
+  T get() {
+    return instance;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/Stats.java b/xds/src/main/java/io/grpc/xds/client/Stats.java
new file mode 100644
index 00000000000..c3e8a431a69
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/Stats.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright 2021 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.xds.client;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.Internal;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/** Represents client load stats. */
+@Internal
+public final class Stats {
+  private Stats() {}
+
+  /** Cluster-level load stats. */
+  @AutoValue
+  public abstract static class ClusterStats {
+    abstract String clusterName();
+
+    @Nullable
+    public abstract String clusterServiceName();
+
+    public abstract ImmutableList<UpstreamLocalityStats> upstreamLocalityStatsList();
+
+    public abstract ImmutableList<DroppedRequests> droppedRequestsList();
+
+    public abstract long totalDroppedRequests();
+
+    public abstract long loadReportIntervalNano();
+
+    public static Builder newBuilder() {
+      return new AutoValue_Stats_ClusterStats.Builder()
+          .totalDroppedRequests(0L)  // default initialization
+          .loadReportIntervalNano(0L);
+    }
+
+    @SuppressWarnings("UnusedReturnValue")
+    @AutoValue.Builder
+    public abstract static class Builder {
+      abstract Builder clusterName(String clusterName);
+
+      abstract Builder clusterServiceName(String clusterServiceName);
+
+      abstract ImmutableList.Builder<UpstreamLocalityStats> upstreamLocalityStatsListBuilder();
+
+      Builder addUpstreamLocalityStats(UpstreamLocalityStats upstreamLocalityStats) {
+        upstreamLocalityStatsListBuilder().add(upstreamLocalityStats);
+        return this;
+      }
+
+      abstract ImmutableList.Builder<DroppedRequests> droppedRequestsListBuilder();
+
+      Builder addDroppedRequests(DroppedRequests droppedRequests) {
+        droppedRequestsListBuilder().add(droppedRequests);
+        return this;
+      }
+
+      abstract Builder totalDroppedRequests(long totalDroppedRequests);
+
+      abstract Builder loadReportIntervalNano(long loadReportIntervalNano);
+
+      abstract long loadReportIntervalNano();
+
+      abstract ClusterStats build();
+    }
+  }
+
+  /** Stats for dropped requests. */
+  @AutoValue
+  public abstract static class DroppedRequests {
+    public abstract String category();
+
+    public abstract long droppedCount();
+
+    public static DroppedRequests create(String category, long droppedCount) {
+      return new AutoValue_Stats_DroppedRequests(category, droppedCount);
+    }
+  }
+
+  /** Load stats aggregated in locality level. */
+  @AutoValue
+  public abstract static class UpstreamLocalityStats {
+    public abstract Locality locality();
+
+    public abstract long totalIssuedRequests();
+
+    public abstract long totalSuccessfulRequests();
+
+    public abstract long totalErrorRequests();
+
+    public abstract long totalRequestsInProgress();
+
+    public abstract ImmutableMap<String, BackendLoadMetricStats> loadMetricStatsMap();
+
+    public static UpstreamLocalityStats create(Locality locality, long totalIssuedRequests,
+                                        long totalSuccessfulRequests, long totalErrorRequests,
+                                        long totalRequestsInProgress,
+                                        Map<String, BackendLoadMetricStats> loadMetricStatsMap) {
+      return new AutoValue_Stats_UpstreamLocalityStats(locality, totalIssuedRequests,
+          totalSuccessfulRequests, totalErrorRequests, totalRequestsInProgress,
+          ImmutableMap.copyOf(loadMetricStatsMap));
+    }
+  }
+
+  /**
+   * Load metric stats for multi-dimensional load balancing.
+   */
+  public static final class BackendLoadMetricStats {
+
+    private long numRequestsFinishedWithMetric;
+    private double totalMetricValue;
+
+    BackendLoadMetricStats(long numRequestsFinishedWithMetric, double totalMetricValue) {
+      this.numRequestsFinishedWithMetric = numRequestsFinishedWithMetric;
+      this.totalMetricValue = totalMetricValue;
+    }
+
+    public long numRequestsFinishedWithMetric() {
+      return numRequestsFinishedWithMetric;
+    }
+
+    public double totalMetricValue() {
+      return totalMetricValue;
+    }
+
+    /**
+     * Adds the given {@code metricValue} and increments the number of requests finished counter for
+     * the existing {@link BackendLoadMetricStats}.
+     */
+    public void addMetricValueAndIncrementRequestsFinished(double metricValue) {
+      numRequestsFinishedWithMetric += 1;
+      totalMetricValue += metricValue;
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/XdsClient.java b/xds/src/main/java/io/grpc/xds/client/XdsClient.java
new file mode 100644
index 00000000000..982fb6651a9
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/XdsClient.java
@@ -0,0 +1,496 @@
+/*
+ * Copyright 2019 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.xds.client;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.xds.client.Bootstrapper.XDSTP_SCHEME;
+
+import com.google.common.base.Joiner;
+import com.google.common.base.Splitter;
+import com.google.common.net.UrlEscapers;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.Any;
+import io.grpc.ExperimentalApi;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicInteger;
+import javax.annotation.Nullable;
+
+/**
+ * An {@link XdsClient} instance encapsulates all of the logic for communicating with the xDS
+ * server. It may create multiple RPC streams (or a single ADS stream) for a series of xDS
+ * protocols (e.g., LDS, RDS, VHDS, CDS and EDS) over a single channel. Watch-based interfaces
+ * are provided for each set of data needed by gRPC.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/10862")
+public abstract class XdsClient {
+
+  public static boolean isResourceNameValid(String resourceName, String typeUrl) {
+    checkNotNull(resourceName, "resourceName");
+    if (!resourceName.startsWith(XDSTP_SCHEME)) {
+      return true;
+    }
+    URI uri;
+    try {
+      uri = new URI(resourceName);
+    } catch (URISyntaxException e) {
+      return false;
+    }
+    String path = uri.getPath();
+    // path must be in the form of /{resource type}/{id/*}
+    Splitter slashSplitter = Splitter.on('/').omitEmptyStrings();
+    if (path == null) {
+      return false;
+    }
+    List<String> pathSegs = slashSplitter.splitToList(path);
+    if (pathSegs.size() < 2) {
+      return false;
+    }
+    String type = pathSegs.get(0);
+    if (!type.equals(slashSplitter.splitToList(typeUrl).get(1))) {
+      return false;
+    }
+    return true;
+  }
+
+  /*
+   * Convert the XDSTP resource name to its canonical version.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10862")
+  public static String canonifyResourceName(String resourceName) {
+    checkNotNull(resourceName, "resourceName");
+    if (!resourceName.startsWith(XDSTP_SCHEME)) {
+      return resourceName;
+    }
+    URI uri = URI.create(resourceName);
+    String rawQuery = uri.getRawQuery();
+    Splitter ampSplitter = Splitter.on('&').omitEmptyStrings();
+    if (rawQuery == null) {
+      return resourceName;
+    }
+    List<String> queries = ampSplitter.splitToList(rawQuery);
+    if (queries.size() < 2) {
+      return resourceName;
+    }
+    List<String> canonicalContextParams = new ArrayList<>(queries.size());
+    for (String query : queries) {
+      canonicalContextParams.add(query);
+    }
+    Collections.sort(canonicalContextParams);
+    String canonifiedQuery = Joiner.on('&').join(canonicalContextParams);
+    return resourceName.replace(rawQuery, canonifiedQuery);
+  }
+
+  /*
+   * Percent encode the input using the url path segment escaper.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10862")
+  public static String percentEncodePath(String input) {
+    Iterable<String> pathSegs = Splitter.on('/').split(input);
+    List<String> encodedSegs = new ArrayList<>();
+    for (String pathSeg : pathSegs) {
+      encodedSegs.add(UrlEscapers.urlPathSegmentEscaper().escape(pathSeg));
+    }
+    return Joiner.on('/').join(encodedSegs);
+  }
+
+  /**
+   * Returns the authority from the resource name.
+   */
+  public static String getAuthorityFromResourceName(String resourceNames) {
+    String authority;
+    if (resourceNames.startsWith(XDSTP_SCHEME)) {
+      URI uri = URI.create(resourceNames);
+      authority = uri.getAuthority();
+      if (authority == null) {
+        authority = "";
+      }
+    } else {
+      authority = null;
+    }
+    return authority;
+  }
+
+  public interface ResourceUpdate {}
+
+  /**
+   * Watcher interface for a single requested xDS resource.
+   *
+   * <p>Note that we expect that the implementer to:
+   * - Comply with the guarantee to not generate certain statuses by the library:
+   *   https://grpc.github.io/grpc/core/md_doc_statuscodes.html. If the code needs to be
+   *   propagated to the channel, override it with {@link io.grpc.Status.Code#UNAVAILABLE}.
+   * - Keep {@link Status} description in one form or another, as it contains valuable debugging
+   *   information.
+   */
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10862")
+  public interface ResourceWatcher<T extends ResourceUpdate> {
+
+    /**
+     * Called to deliver a resource update or an error. If an error is passed after a valid
+     * resource has been delivered, the watcher should stop using the previously delivered
+     * resource.
+     */
+    void onResourceChanged(StatusOr<T> update);
+
+    /**
+     * Called to deliver a transient error that should not affect the watcher's use of any
+     * previously received resource.
+     *   */
+    void onAmbientError(Status error);
+  }
+
+  /**
+   * The metadata of the xDS resource; used by the xDS config dump.
+   */
+  public static final class ResourceMetadata {
+    private final String version;
+    private final ResourceMetadataStatus status;
+    private final long updateTimeNanos;
+    private final boolean cached;
+    @Nullable private final Any rawResource;
+    @Nullable private final UpdateFailureState errorState;
+
+    private ResourceMetadata(
+        ResourceMetadataStatus status, String version, long updateTimeNanos, boolean cached,
+        @Nullable Any rawResource, @Nullable UpdateFailureState errorState) {
+      this.status = checkNotNull(status, "status");
+      this.version = checkNotNull(version, "version");
+      this.updateTimeNanos = updateTimeNanos;
+      this.cached = cached;
+      this.rawResource = rawResource;
+      this.errorState = errorState;
+    }
+
+    public static ResourceMetadata newResourceMetadataUnknown() {
+      return new ResourceMetadata(ResourceMetadataStatus.UNKNOWN, "", 0, false,null, null);
+    }
+
+    public static ResourceMetadata newResourceMetadataRequested() {
+      return new ResourceMetadata(ResourceMetadataStatus.REQUESTED, "", 0, false, null, null);
+    }
+
+    public static ResourceMetadata newResourceMetadataDoesNotExist() {
+      return new ResourceMetadata(ResourceMetadataStatus.DOES_NOT_EXIST, "", 0, false, null, null);
+    }
+
+    public static ResourceMetadata newResourceMetadataTimeout() {
+      return new ResourceMetadata(ResourceMetadataStatus.TIMEOUT, "", 0, false, null, null);
+    }
+
+    public static ResourceMetadata newResourceMetadataAcked(
+        Any rawResource, String version, long updateTimeNanos) {
+      checkNotNull(rawResource, "rawResource");
+      return new ResourceMetadata(
+          ResourceMetadataStatus.ACKED, version, updateTimeNanos, true, rawResource, null);
+    }
+
+    public static ResourceMetadata newResourceMetadataNacked(
+        ResourceMetadata metadata, String failedVersion, long failedUpdateTime,
+        String failedDetails, boolean cached) {
+      checkNotNull(metadata, "metadata");
+      return new ResourceMetadata(ResourceMetadataStatus.NACKED,
+          metadata.getVersion(), metadata.getUpdateTimeNanos(), cached, metadata.getRawResource(),
+          new UpdateFailureState(failedVersion, failedUpdateTime, failedDetails));
+    }
+
+    /** The last successfully updated version of the resource. */
+    public String getVersion() {
+      return version;
+    }
+
+    /** The client status of this resource. */
+    public ResourceMetadataStatus getStatus() {
+      return status;
+    }
+
+    /** The timestamp when the resource was last successfully updated. */
+    public long getUpdateTimeNanos() {
+      return updateTimeNanos;
+    }
+
+    /** Returns whether the resource was cached. */
+    public boolean isCached() {
+      return cached;
+    }
+
+    /** The last successfully updated xDS resource as it was returned by the server. */
+    @Nullable
+    public Any getRawResource() {
+      return rawResource;
+    }
+
+    /** The metadata capturing the error details of the last rejected update of the resource. */
+    @Nullable
+    public UpdateFailureState getErrorState() {
+      return errorState;
+    }
+
+    /**
+     * Resource status from the view of a xDS client, which tells the synchronization
+     * status between the xDS client and the xDS server.
+     *
+     * <p>This is a native representation of xDS ConfigDump ClientResourceStatus, see
+     * <a href="https://github.com/envoyproxy/envoy/blob/main/api/envoy/admin/v3/config_dump.proto">
+     * config_dump.proto</a>
+     */
+    public enum ResourceMetadataStatus {
+      UNKNOWN, REQUESTED, DOES_NOT_EXIST, ACKED, NACKED, TIMEOUT
+    }
+
+    /**
+     * Captures error metadata of failed resource updates.
+     *
+     * <p>This is a native representation of xDS ConfigDump UpdateFailureState, see
+     * <a href="https://github.com/envoyproxy/envoy/blob/main/api/envoy/admin/v3/config_dump.proto">
+     * config_dump.proto</a>
+     */
+    public static final class UpdateFailureState {
+      private final String failedVersion;
+      private final long failedUpdateTimeNanos;
+      private final String failedDetails;
+
+      private UpdateFailureState(
+          String failedVersion, long failedUpdateTimeNanos, String failedDetails) {
+        this.failedVersion = checkNotNull(failedVersion, "failedVersion");
+        this.failedUpdateTimeNanos = failedUpdateTimeNanos;
+        this.failedDetails = checkNotNull(failedDetails, "failedDetails");
+      }
+
+      /** The rejected version string of the last failed update attempt. */
+      public String getFailedVersion() {
+        return failedVersion;
+      }
+
+      /** Details about the last failed update attempt. */
+      public long getFailedUpdateTimeNanos() {
+        return failedUpdateTimeNanos;
+      }
+
+      /** Timestamp of the last failed update attempt. */
+      public String getFailedDetails() {
+        return failedDetails;
+      }
+    }
+  }
+
+  /**
+   * Shutdown this {@link XdsClient} and release resources.
+   */
+  public void shutdown() {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Returns {@code true} if {@link #shutdown()} has been called.
+   */
+  public boolean isShutDown() {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Returns the config used to bootstrap this XdsClient {@link Bootstrapper.BootstrapInfo}.
+   */
+  public Bootstrapper.BootstrapInfo getBootstrapInfo() {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Returns the implementation specific security configuration used in this XdsClient.
+   */
+  public Object getSecurityConfig() {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Returns a {@link ListenableFuture} to the snapshot of the subscribed resources as
+   * they are at the moment of the call.
+   *
+   * <p>The snapshot is a map from the "resource type" to
+   * a map ("resource name": "resource metadata").
+   */
+  // Must be synchronized.
+  public ListenableFuture<Map<XdsResourceType<?>, Map<String, ResourceMetadata>>>
+      getSubscribedResourcesMetadataSnapshot() {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Registers a data watcher for the given Xds resource.
+   */
+  public <T extends ResourceUpdate> void watchXdsResource(XdsResourceType<T> type,
+      String resourceName,
+      ResourceWatcher<T> watcher,
+      Executor executor) {
+    throw new UnsupportedOperationException();
+  }
+
+  public <T extends ResourceUpdate> void watchXdsResource(XdsResourceType<T> type,
+      String resourceName,
+      ResourceWatcher<T> watcher) {
+    watchXdsResource(type, resourceName, watcher, MoreExecutors.directExecutor());
+  }
+
+  /**
+   * Unregisters the given resource watcher.
+   */
+  public <T extends ResourceUpdate> void cancelXdsResourceWatch(XdsResourceType<T> type,
+      String resourceName,
+      ResourceWatcher<T> watcher) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Adds drop stats for the specified cluster with edsServiceName by using the returned object
+   * to record dropped requests. Drop stats recorded with the returned object will be reported
+   * to the load reporting server. The returned object is reference counted and the caller should
+   * use {@link LoadStatsManager2.ClusterDropStats#release} to release its <i>hard</i> reference
+   * when it is safe to stop reporting dropped RPCs for the specified cluster in the future.
+   */
+  public LoadStatsManager2.ClusterDropStats addClusterDropStats(
+      Bootstrapper.ServerInfo serverInfo, String clusterName, @Nullable String edsServiceName) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Adds load stats for the specified locality (in the specified cluster with edsServiceName) by
+   * using the returned object to record RPCs. Load stats recorded with the returned object will
+   * be reported to the load reporting server. The returned object is reference counted and the
+   * caller should use {@link LoadStatsManager2.ClusterLocalityStats#release} to release its
+   * <i>hard</i> reference when it is safe to stop reporting RPC loads for the specified locality
+   * in the future.
+   */
+  public LoadStatsManager2.ClusterLocalityStats addClusterLocalityStats(
+      Bootstrapper.ServerInfo serverInfo, String clusterName, @Nullable String edsServiceName,
+      Locality locality) {
+    return addClusterLocalityStats(serverInfo, clusterName, edsServiceName, locality, null);
+  }
+
+  /**
+   * Adds load stats for the specified locality (in the specified cluster with edsServiceName) by
+   * using the returned object to record RPCs. Load stats recorded with the returned object will
+   * be reported to the load reporting server. The returned object is reference counted and the
+   * caller should use {@link LoadStatsManager2.ClusterLocalityStats#release} to release its
+   * <i>hard</i> reference when it is safe to stop reporting RPC loads for the specified locality
+   * in the future.
+   *
+   * @param backendMetricPropagation Configuration for which backend metrics should be propagated
+   *     to LRS load reports. If null, all metrics will be propagated (legacy behavior).
+   */
+  public LoadStatsManager2.ClusterLocalityStats addClusterLocalityStats(
+      Bootstrapper.ServerInfo serverInfo, String clusterName, @Nullable String edsServiceName,
+      Locality locality, @Nullable BackendMetricPropagation backendMetricPropagation) {
+    throw new UnsupportedOperationException();
+  }
+
+  /**
+   * Returns a map of control plane server info objects to the LoadReportClients that are
+   * responsible for sending load reports to the control plane servers.
+   */
+  public Map<Bootstrapper.ServerInfo, LoadReportClient> getServerLrsClientMap() {
+    throw new UnsupportedOperationException();
+  }
+
+  /** Callback used to report a gauge metric value for server connections. */
+  public interface ServerConnectionCallback {
+    void reportServerConnectionGauge(boolean isConnected, String xdsServer);
+  }
+
+  /**
+   * Reports whether xDS client has a "working" ADS stream to xDS server. The definition of a
+   * working stream is defined in gRFC A78.
+   *
+   * @see <a
+   *     href="https://github.com/grpc/proposal/blob/master/A78-grpc-metrics-wrr-pf-xds.md#xdsclient">
+   *     A78-grpc-metrics-wrr-pf-xds.md</a>
+   */
+  public Future<Void> reportServerConnections(ServerConnectionCallback callback) {
+    throw new UnsupportedOperationException();
+  }
+
+  static final class ProcessingTracker {
+    private final AtomicInteger pendingTask = new AtomicInteger(1);
+    private final Executor executor;
+    private final Runnable completionListener;
+
+    ProcessingTracker(Runnable completionListener, Executor executor) {
+      this.executor = executor;
+      this.completionListener = completionListener;
+    }
+
+    void startTask() {
+      pendingTask.incrementAndGet();
+    }
+
+    void onComplete() {
+      if (pendingTask.decrementAndGet() == 0) {
+        executor.execute(completionListener);
+      }
+    }
+  }
+
+  interface XdsResponseHandler {
+    /** Called when a xds response is received. */
+    void handleResourceResponse(
+        XdsResourceType<?> resourceType, ServerInfo serverInfo, String versionInfo,
+        List<Any> resources, String nonce, boolean isFirstResponse,
+        ProcessingTracker processingTracker);
+
+    /** Called when the ADS stream is closed passively. */
+    // Must be synchronized.
+    void handleStreamClosed(Status error, boolean shouldTryFallback);
+  }
+
+  interface ResourceStore {
+
+    /**
+     * Returns the collection of resources currently subscribed to which have an authority matching
+     * one of those for which the ControlPlaneClient associated with the specified ServerInfo is
+     * the active one, or {@code null} if no such resources are currently subscribed to.
+     *
+     * <p>Note an empty collection indicates subscribing to resources of the given type with
+     * wildcard mode.
+     *
+     * @param serverInfo the xds server to get the resources from
+     * @param type       the type of the resources that should be retrieved
+     */
+    // Must be synchronized.
+    @Nullable
+    Collection<String> getSubscribedResources(
+        ServerInfo serverInfo, XdsResourceType<? extends ResourceUpdate> type);
+
+    Map<String, XdsResourceType<?>> getSubscribedResourceTypesWithTypeUrl();
+
+    /**
+     * For any of the subscribers to one of the specified resources, if there isn't a result or
+     * an existing timer for the resource, start a timer for the resource.
+     */
+    void startMissingResourceTimers(Collection<String> resourceNames,
+                                    XdsResourceType<?> resourceType);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/XdsClientImpl.java b/xds/src/main/java/io/grpc/xds/client/XdsClientImpl.java
new file mode 100644
index 00000000000..0584a3dbfdd
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/XdsClientImpl.java
@@ -0,0 +1,1102 @@
+/*
+ * 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.xds.client;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.xds.client.XdsResourceType.ParsedResource;
+import static io.grpc.xds.client.XdsResourceType.ValidatedResourceUpdate;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Joiner;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.protobuf.Any;
+import io.grpc.Internal;
+import io.grpc.InternalLogId;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.TimeProvider;
+import io.grpc.xds.client.Bootstrapper.AuthorityInfo;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.XdsClient.ResourceStore;
+import io.grpc.xds.client.XdsLogger.XdsLogLevel;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+import javax.annotation.Nullable;
+
+/**
+ * XdsClient implementation.
+ */
+@Internal
+public final class XdsClientImpl extends XdsClient implements ResourceStore {
+
+  // Longest time to wait, since the subscription to some resource, for concluding its absence.
+  @VisibleForTesting
+  public static final int INITIAL_RESOURCE_FETCH_TIMEOUT_SEC = 15;
+  public static final int EXTENDED_RESOURCE_FETCH_TIMEOUT_SEC = 30;
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          logger.log(
+              XdsLogLevel.ERROR,
+              "Uncaught exception in XdsClient SynchronizationContext. Panic!",
+              e);
+          // TODO: better error handling.
+          throw new AssertionError(e);
+        }
+      });
+
+  private final Map<ServerInfo, LoadStatsManager2> loadStatsManagerMap = new HashMap<>();
+  final Map<ServerInfo, LoadReportClient> serverLrsClientMap = new HashMap<>();
+  /** Map of authority to its activated control plane client (affected by xds fallback).
+   * The last entry in the list for each value is the "active" CPC for the matching key */
+  private final Map<String, List<ControlPlaneClient>> activatedCpClients = new HashMap<>();
+  private final Map<ServerInfo, ControlPlaneClient> serverCpClientMap = new HashMap<>();
+
+  /** Maps resource type to the corresponding map of subscribers (keyed by resource name). */
+  private final Map<XdsResourceType<? extends ResourceUpdate>,
+      Map<String, ResourceSubscriber<? extends ResourceUpdate>>>
+      resourceSubscribers = new HashMap<>();
+  /** Maps typeUrl to the corresponding XdsResourceType. */
+  private final Map<String, XdsResourceType<?>> subscribedResourceTypeUrls = new HashMap<>();
+
+  private final XdsTransportFactory xdsTransportFactory;
+  private final Bootstrapper.BootstrapInfo bootstrapInfo;
+  private final ScheduledExecutorService timeService;
+  private final BackoffPolicy.Provider backoffPolicyProvider;
+  private final Supplier<Stopwatch> stopwatchSupplier;
+  private final TimeProvider timeProvider;
+  private final Object securityConfig;
+  private final InternalLogId logId;
+  private final XdsLogger logger;
+  private volatile boolean isShutdown;
+  private final MessagePrettyPrinter messagePrinter;
+  private final XdsClientMetricReporter metricReporter;
+
+  public XdsClientImpl(
+      XdsTransportFactory xdsTransportFactory,
+      Bootstrapper.BootstrapInfo bootstrapInfo,
+      ScheduledExecutorService timeService,
+      BackoffPolicy.Provider backoffPolicyProvider,
+      Supplier<Stopwatch> stopwatchSupplier,
+      TimeProvider timeProvider,
+      MessagePrettyPrinter messagePrinter,
+      Object securityConfig,
+      XdsClientMetricReporter metricReporter) {
+    this.xdsTransportFactory = xdsTransportFactory;
+    this.bootstrapInfo = bootstrapInfo;
+    this.timeService = timeService;
+    this.backoffPolicyProvider = backoffPolicyProvider;
+    this.stopwatchSupplier = stopwatchSupplier;
+    this.timeProvider = timeProvider;
+    this.messagePrinter = messagePrinter;
+    this.securityConfig = securityConfig;
+    this.metricReporter = metricReporter;
+    logId = InternalLogId.allocate("xds-client", null);
+    logger = XdsLogger.withLogId(logId);
+    logger.log(XdsLogLevel.INFO, "Created");
+  }
+
+  @Override
+  public void shutdown() {
+    syncContext.execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            if (isShutdown) {
+              return;
+            }
+            isShutdown = true;
+            for (ControlPlaneClient xdsChannel : serverCpClientMap.values()) {
+              xdsChannel.shutdown();
+            }
+            for (final LoadReportClient lrsClient : serverLrsClientMap.values()) {
+              lrsClient.stopLoadReporting();
+            }
+            cleanUpResourceTimers(null);
+            activatedCpClients.clear();
+          }
+        });
+  }
+
+  @Override
+  public boolean isShutDown() {
+    return isShutdown;
+  }
+
+  @Override
+  public Map<String, XdsResourceType<?>> getSubscribedResourceTypesWithTypeUrl() {
+    return Collections.unmodifiableMap(subscribedResourceTypeUrls);
+  }
+
+  private ControlPlaneClient getActiveCpc(String authority) {
+    List<ControlPlaneClient> controlPlaneClients = activatedCpClients.get(authority);
+    if (controlPlaneClients == null || controlPlaneClients.isEmpty()) {
+      return null;
+    }
+
+    return controlPlaneClients.get(controlPlaneClients.size() - 1);
+  }
+
+  @Nullable
+  @Override
+  public Collection<String> getSubscribedResources(
+      ServerInfo serverInfo, XdsResourceType<? extends ResourceUpdate> type) {
+    ControlPlaneClient targetCpc = serverCpClientMap.get(serverInfo);
+    if (targetCpc == null) {
+      return null;
+    }
+
+    // This should include all of the authorities that targetCpc or a fallback from it is serving
+    List<String> authorities = activatedCpClients.entrySet().stream()
+        .filter(entry -> entry.getValue().contains(targetCpc))
+        .map(Map.Entry::getKey)
+        .collect(Collectors.toList());
+
+    Map<String, ResourceSubscriber<? extends ResourceUpdate>> resources =
+        resourceSubscribers.getOrDefault(type, Collections.emptyMap());
+
+    Collection<String> retVal = resources.entrySet().stream()
+        .filter(entry -> authorities.contains(entry.getValue().authority))
+        .map(Map.Entry::getKey)
+        .collect(Collectors.toList());
+
+    return retVal.isEmpty() ? null : retVal;
+  }
+
+  @Override
+  public void startMissingResourceTimers(Collection<String> resourceNames,
+                                         XdsResourceType<?> resourceType) {
+    Map<String, ResourceSubscriber<? extends ResourceUpdate>> subscriberMap =
+        resourceSubscribers.get(resourceType);
+
+    for (String resourceName : resourceNames) {
+      ResourceSubscriber<?> subscriber = subscriberMap.get(resourceName);
+      if (subscriber.respTimer == null && !subscriber.hasResult()) {
+        subscriber.restartTimer();
+      }
+    }
+  }
+
+  // As XdsClient APIs becomes resource agnostic, subscribed resource types are dynamic.
+  // ResourceTypes that do not have subscribers does not show up in the snapshot keys.
+  @Override
+  public ListenableFuture<Map<XdsResourceType<?>, Map<String, ResourceMetadata>>>
+      getSubscribedResourcesMetadataSnapshot() {
+    final SettableFuture<Map<XdsResourceType<?>, Map<String, ResourceMetadata>>> future =
+        SettableFuture.create();
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        // A map from a "resource type" to a map ("resource name": "resource metadata")
+        ImmutableMap.Builder<XdsResourceType<?>, Map<String, ResourceMetadata>> metadataSnapshot =
+            ImmutableMap.builder();
+        for (XdsResourceType<?> resourceType : resourceSubscribers.keySet()) {
+          ImmutableMap.Builder<String, ResourceMetadata> metadataMap = ImmutableMap.builder();
+          for (Map.Entry<String, ResourceSubscriber<? extends ResourceUpdate>> resourceEntry
+              : resourceSubscribers.get(resourceType).entrySet()) {
+            metadataMap.put(resourceEntry.getKey(), resourceEntry.getValue().metadata);
+          }
+          metadataSnapshot.put(resourceType, metadataMap.buildOrThrow());
+        }
+        future.set(metadataSnapshot.buildOrThrow());
+      }
+    });
+    return future;
+  }
+
+  @Override
+  public Object getSecurityConfig() {
+    return securityConfig;
+  }
+
+  @Override
+  public <T extends ResourceUpdate> void watchXdsResource(XdsResourceType<T> type,
+                                                          String resourceName,
+                                                          ResourceWatcher<T> watcher,
+                                                          Executor watcherExecutor) {
+    syncContext.execute(new Runnable() {
+      @Override
+      @SuppressWarnings("unchecked")
+      public void run() {
+        if (!resourceSubscribers.containsKey(type)) {
+          resourceSubscribers.put(type, new HashMap<>());
+          subscribedResourceTypeUrls.put(type.typeUrl(), type);
+        }
+        ResourceSubscriber<T> subscriber =
+            (ResourceSubscriber<T>) resourceSubscribers.get(type).get(resourceName);
+
+        if (subscriber == null) {
+          logger.log(XdsLogLevel.INFO, "Subscribe {0} resource {1}", type, resourceName);
+          subscriber = new ResourceSubscriber<>(type, resourceName);
+          resourceSubscribers.get(type).put(resourceName, subscriber);
+
+          if (subscriber.errorDescription == null) {
+            CpcWithFallbackState cpcToUse = manageControlPlaneClient(subscriber);
+            if (cpcToUse.cpc != null) {
+              cpcToUse.cpc.adjustResourceSubscription(type);
+            }
+          }
+        }
+
+        subscriber.addWatcher(watcher, watcherExecutor);
+      }
+    });
+  }
+
+  /**
+   * Gets a ControlPlaneClient for the subscriber's authority, creating one if necessary.
+   * If there already was an active CPC for this authority, and it is different from the one
+   * identified, then do fallback to the identified one (cpcToUse).
+   *
+   * @return identified CPC or {@code null} (if there are no valid ServerInfos associated with the
+   *     subscriber's authority or CPC's for all are in backoff), and whether did a fallback.
+   */
+  @VisibleForTesting
+  private <T extends ResourceUpdate> CpcWithFallbackState manageControlPlaneClient(
+      ResourceSubscriber<T> subscriber) {
+
+    ControlPlaneClient cpcToUse;
+    boolean didFallback = false;
+    try {
+      cpcToUse = getOrCreateControlPlaneClient(subscriber.authority);
+    } catch (IllegalArgumentException e) {
+      if (subscriber.errorDescription == null) {
+        subscriber.errorDescription = "Bad configuration:  " + e.getMessage();
+      }
+
+      subscriber.onError(
+          Status.INVALID_ARGUMENT.withDescription(subscriber.errorDescription), null);
+      return new CpcWithFallbackState(null, false);
+    } catch (IOException e) {
+      logger.log(XdsLogLevel.DEBUG,
+          "Could not create a control plane client for authority {0}: {1}",
+          subscriber.authority, e.getMessage());
+      return new CpcWithFallbackState(null, false);
+    }
+
+    ControlPlaneClient activeCpClient = getActiveCpc(subscriber.authority);
+    if (cpcToUse != activeCpClient) {
+      addCpcToAuthority(subscriber.authority, cpcToUse); // makes it active
+      if (activeCpClient != null) {
+        didFallback = cpcToUse != null && !cpcToUse.isInError();
+        if (didFallback) {
+          logger.log(XdsLogLevel.INFO, "Falling back to XDS server {0}",
+              cpcToUse.getServerInfo().target());
+        } else {
+          logger.log(XdsLogLevel.WARNING, "No working fallback XDS Servers found from {0}",
+              activeCpClient.getServerInfo().target());
+        }
+      }
+    }
+
+    return new CpcWithFallbackState(cpcToUse, didFallback);
+  }
+
+  private void addCpcToAuthority(String authority, ControlPlaneClient cpcToUse) {
+    List<ControlPlaneClient> controlPlaneClients =
+        activatedCpClients.computeIfAbsent(authority, k -> new ArrayList<>());
+
+    if (controlPlaneClients.contains(cpcToUse)) {
+      return;
+    }
+
+    // if there are any missing CPCs between the last one and cpcToUse, add them + add cpcToUse
+    ImmutableList<ServerInfo> serverInfos = getServerInfos(authority);
+    for (int i = controlPlaneClients.size(); i < serverInfos.size(); i++) {
+      ServerInfo serverInfo = serverInfos.get(i);
+      ControlPlaneClient cpc = serverCpClientMap.get(serverInfo);
+      controlPlaneClients.add(cpc);
+      logger.log(XdsLogLevel.DEBUG, "Adding control plane client {0} to authority {1}",
+          cpc, authority);
+      cpcToUse.sendDiscoveryRequests();
+      if (cpc == cpcToUse) {
+        break;
+      }
+    }
+  }
+
+  @Override
+  public <T extends ResourceUpdate> void cancelXdsResourceWatch(XdsResourceType<T> type,
+                                                                String resourceName,
+                                                                ResourceWatcher<T> watcher) {
+    syncContext.execute(new Runnable() {
+      @Override
+      @SuppressWarnings("unchecked")
+      public void run() {
+        ResourceSubscriber<T> subscriber =
+            (ResourceSubscriber<T>) resourceSubscribers.get(type).get(resourceName);
+        if (subscriber == null) {
+          logger.log(XdsLogLevel.WARNING, "double cancel of resource watch for {0}:{1}",
+              type.typeName(), resourceName);
+          return;
+        }
+        subscriber.removeWatcher(watcher);
+        if (!subscriber.isWatched()) {
+          subscriber.cancelResourceWatch();
+          resourceSubscribers.get(type).remove(resourceName);
+
+          List<ControlPlaneClient> controlPlaneClients =
+              activatedCpClients.get(subscriber.authority);
+          if (controlPlaneClients != null) {
+            controlPlaneClients.forEach((cpc) -> {
+              cpc.adjustResourceSubscription(type);
+            });
+          }
+
+          if (resourceSubscribers.get(type).isEmpty()) {
+            resourceSubscribers.remove(type);
+            subscribedResourceTypeUrls.remove(type.typeUrl());
+          }
+        }
+      }
+    });
+  }
+
+  @Override
+  public LoadStatsManager2.ClusterDropStats addClusterDropStats(
+      final ServerInfo serverInfo, String clusterName,
+      @Nullable String edsServiceName) {
+    LoadStatsManager2 loadStatsManager = loadStatsManagerMap.get(serverInfo);
+    LoadStatsManager2.ClusterDropStats dropCounter =
+        loadStatsManager.getClusterDropStats(clusterName, edsServiceName);
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        serverLrsClientMap.get(serverInfo).startLoadReporting();
+      }
+    });
+    return dropCounter;
+  }
+
+  @Override
+  public LoadStatsManager2.ClusterLocalityStats addClusterLocalityStats(
+      final ServerInfo serverInfo, String clusterName, @Nullable String edsServiceName,
+      Locality locality) {
+    return addClusterLocalityStats(serverInfo, clusterName, edsServiceName, locality, null);
+  }
+
+  @Override
+  public LoadStatsManager2.ClusterLocalityStats addClusterLocalityStats(
+      final ServerInfo serverInfo,
+      String clusterName,
+      @Nullable String edsServiceName,
+      Locality locality,
+      @Nullable BackendMetricPropagation backendMetricPropagation) {
+    LoadStatsManager2 loadStatsManager = loadStatsManagerMap.get(serverInfo);
+
+    LoadStatsManager2.ClusterLocalityStats loadCounter =
+        loadStatsManager.getClusterLocalityStats(
+            clusterName, edsServiceName, locality, backendMetricPropagation);
+
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        serverLrsClientMap.get(serverInfo).startLoadReporting();
+      }
+    });
+    return loadCounter;
+  }
+
+
+  @Override
+  public Bootstrapper.BootstrapInfo getBootstrapInfo() {
+    return bootstrapInfo;
+  }
+
+  @Override
+  public String toString() {
+    return logId.toString();
+  }
+
+  private Set<String> getResourceKeys(XdsResourceType<?> xdsResourceType) {
+    if (!resourceSubscribers.containsKey(xdsResourceType)) {
+      return null;
+    }
+
+    return resourceSubscribers.get(xdsResourceType).keySet();
+  }
+
+  // cpcForThisStream is null when doing shutdown
+  private void cleanUpResourceTimers(ControlPlaneClient cpcForThisStream) {
+    Collection<String> authoritiesForCpc = getActiveAuthorities(cpcForThisStream);
+    String target = cpcForThisStream == null ? "null" : cpcForThisStream.getServerInfo().target();
+    logger.log(XdsLogLevel.DEBUG, "Cleaning up resource timers for CPC {0}, authorities {1}",
+        target, authoritiesForCpc);
+
+    for (Map<String, ResourceSubscriber<?>> subscriberMap : resourceSubscribers.values()) {
+      for (ResourceSubscriber<?> subscriber : subscriberMap.values()) {
+        if (cpcForThisStream == null || authoritiesForCpc.contains(subscriber.authority)) {
+          subscriber.stopTimer();
+        }
+      }
+    }
+  }
+
+  private ControlPlaneClient getOrCreateControlPlaneClient(String authority) throws IOException {
+    // Optimize for the common case of a working ads stream already exists for the authority
+    ControlPlaneClient activeCpc = getActiveCpc(authority);
+    if (activeCpc != null && !activeCpc.isInError()) {
+      return activeCpc;
+    }
+
+    ImmutableList<ServerInfo> serverInfos = getServerInfos(authority);
+    if (serverInfos == null) {
+      throw new IllegalArgumentException("No xds servers found for authority " + authority);
+    }
+
+    for (ServerInfo serverInfo : serverInfos) {
+      ControlPlaneClient cpc = getOrCreateControlPlaneClient(serverInfo);
+      if (cpc.isInError()) {
+        continue;
+      }
+      return cpc;
+    }
+
+    // Everything existed and is in backoff so throw
+    throw new IOException("All xds transports for authority " + authority + " are in backoff");
+  }
+
+  private ControlPlaneClient getOrCreateControlPlaneClient(ServerInfo serverInfo) {
+    syncContext.throwIfNotInThisSynchronizationContext();
+    if (serverCpClientMap.containsKey(serverInfo)) {
+      return serverCpClientMap.get(serverInfo);
+    }
+
+    logger.log(XdsLogLevel.DEBUG, "Creating control plane client for {0}", serverInfo.target());
+    XdsTransportFactory.XdsTransport xdsTransport;
+    try {
+      xdsTransport = xdsTransportFactory.create(serverInfo);
+    } catch (Exception e) {
+      String msg = String.format("Failed to create xds transport for %s: %s",
+          serverInfo.target(), e.getMessage());
+      logger.log(XdsLogLevel.WARNING, msg);
+      xdsTransport =
+          new ControlPlaneClient.FailingXdsTransport(Status.UNAVAILABLE.withDescription(msg));
+    }
+
+    ControlPlaneClient controlPlaneClient = new ControlPlaneClient(
+        xdsTransport,
+        serverInfo,
+        bootstrapInfo.node(),
+        new ResponseHandler(serverInfo),
+        this,
+        timeService,
+        syncContext,
+        backoffPolicyProvider,
+        stopwatchSupplier,
+        messagePrinter
+    );
+
+    serverCpClientMap.put(serverInfo, controlPlaneClient);
+
+    LoadStatsManager2 loadStatsManager = new LoadStatsManager2(stopwatchSupplier);
+    loadStatsManagerMap.put(serverInfo, loadStatsManager);
+    LoadReportClient lrsClient = new LoadReportClient(
+        loadStatsManager, xdsTransport, bootstrapInfo.node(),
+        syncContext, timeService, backoffPolicyProvider, stopwatchSupplier);
+    serverLrsClientMap.put(serverInfo, lrsClient);
+
+    return controlPlaneClient;
+  }
+
+  @VisibleForTesting
+  @Override
+  public Map<ServerInfo, LoadReportClient> getServerLrsClientMap() {
+    return ImmutableMap.copyOf(serverLrsClientMap);
+  }
+
+  @Nullable
+  private ImmutableList<ServerInfo> getServerInfos(String authority) {
+    if (authority != null) {
+      AuthorityInfo authorityInfo = bootstrapInfo.authorities().get(authority);
+      if (authorityInfo == null || authorityInfo.xdsServers().isEmpty()) {
+        return null;
+      }
+      return authorityInfo.xdsServers();
+    } else {
+      return bootstrapInfo.servers();
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  private <T extends ResourceUpdate> void handleResourceUpdate(
+      XdsResourceType.Args args, List<Any> resources, XdsResourceType<T> xdsResourceType,
+      boolean isFirstResponse, ProcessingTracker processingTracker) {
+    ControlPlaneClient controlPlaneClient = serverCpClientMap.get(args.serverInfo);
+
+    if (isFirstResponse) {
+      shutdownLowerPriorityCpcs(controlPlaneClient);
+    }
+
+    ValidatedResourceUpdate<T> result = xdsResourceType.parse(args, resources);
+    logger.log(XdsLogger.XdsLogLevel.INFO,
+        "Received {0} Response version {1} nonce {2}. Parsed resources: {3}",
+        xdsResourceType.typeName(), args.versionInfo, args.nonce, result.unpackedResources);
+    Map<String, ParsedResource<T>> parsedResources = result.parsedResources;
+    Set<String> invalidResources = result.invalidResources;
+    metricReporter.reportResourceUpdates(Long.valueOf(parsedResources.size()),
+        Long.valueOf(invalidResources.size()),
+        args.getServerInfo().target(), xdsResourceType.typeUrl());
+
+    List<String> errors = result.errors;
+    String errorDetail = null;
+    if (errors.isEmpty()) {
+      checkArgument(invalidResources.isEmpty(), "found invalid resources but missing errors");
+      controlPlaneClient.ackResponse(xdsResourceType, args.versionInfo, args.nonce);
+    } else {
+      errorDetail = Joiner.on('\n').join(errors);
+      logger.log(XdsLogLevel.WARNING,
+          "Failed processing {0} Response version {1} nonce {2}. Errors:\n{3}",
+          xdsResourceType.typeName(), args.versionInfo, args.nonce, errorDetail);
+      controlPlaneClient.nackResponse(xdsResourceType, args.nonce, errorDetail);
+    }
+
+    long updateTime = timeProvider.currentTimeNanos();
+    Map<String, ResourceSubscriber<? extends ResourceUpdate>> subscribedResources =
+        resourceSubscribers.getOrDefault(xdsResourceType, Collections.emptyMap());
+    for (Map.Entry<String, ResourceSubscriber<?>> entry : subscribedResources.entrySet()) {
+      String resourceName = entry.getKey();
+      ResourceSubscriber<T> subscriber = (ResourceSubscriber<T>) entry.getValue();
+      if (parsedResources.containsKey(resourceName)) {
+        // Happy path: the resource updated successfully. Notify the watchers of the update.
+        subscriber.onData(parsedResources.get(resourceName), args.versionInfo, updateTime,
+            processingTracker);
+        continue;
+      }
+
+      if (invalidResources.contains(resourceName)) {
+        // The resource update is invalid (NACK). Handle as a data error.
+        subscriber.onRejected(args.versionInfo, updateTime, errorDetail);
+        
+        // Handle data errors (NACKs) based on fail_on_data_errors server feature.
+        // When xdsDataErrorHandlingEnabled is true and fail_on_data_errors is present,
+        // delete cached data so onError will call onResourceChanged instead of onAmbientError.
+        // When xdsDataErrorHandlingEnabled is false, use old behavior (always keep cached data).
+        if (BootstrapperImpl.xdsDataErrorHandlingEnabled && subscriber.data != null
+            && args.serverInfo.failOnDataErrors()) {
+          subscriber.data = null;
+        }
+        // Call onError, which will decide whether to call onResourceChanged or onAmbientError
+        // based on whether data exists after the above deletion.
+        subscriber.onError(Status.UNAVAILABLE.withDescription(errorDetail), processingTracker);
+        continue;
+      }
+
+      // Nothing else to do for incremental ADS resources.
+      if (!xdsResourceType.isFullStateOfTheWorld()) {
+        continue;
+      }
+
+      // For State of the World services, notify watchers when their watched resource is missing
+      // from the ADS update. Note that we can only do this if the resource update is coming from
+      // the same xDS server that the ResourceSubscriber is subscribed to.
+      if (getActiveCpc(subscriber.authority) == controlPlaneClient) {
+        subscriber.onAbsent(processingTracker, args.serverInfo);
+      }
+    }
+  }
+
+  @Override
+  public Future<Void> reportServerConnections(ServerConnectionCallback callback) {
+    SettableFuture<Void> future = SettableFuture.create();
+    syncContext.execute(() -> {
+      serverCpClientMap.forEach((serverInfo, controlPlaneClient) ->
+          callback.reportServerConnectionGauge(
+              !controlPlaneClient.isInError(), serverInfo.target()));
+      future.set(null);
+    });
+    return future;
+  }
+
+  private void shutdownLowerPriorityCpcs(ControlPlaneClient activatedCpc) {
+    // For each authority, remove any control plane clients, with lower priority than the activated
+    // one, from activatedCpClients storing them all in cpcsToShutdown.
+    Set<ControlPlaneClient> cpcsToShutdown = new HashSet<>();
+    for ( List<ControlPlaneClient> cpcsForAuth : activatedCpClients.values()) {
+      if (cpcsForAuth == null) {
+        continue;
+      }
+      int index = cpcsForAuth.indexOf(activatedCpc);
+      if (index > -1) {
+        cpcsToShutdown.addAll(cpcsForAuth.subList(index + 1, cpcsForAuth.size()));
+        cpcsForAuth.subList(index + 1, cpcsForAuth.size()).clear(); // remove lower priority cpcs
+      }
+    }
+
+    // Shutdown any lower priority control plane clients identified above that aren't still being
+    // used by another authority.  If they are still being used let the XDS server know that we
+    // no longer are interested in subscriptions for authorities we are no longer responsible for.
+    for (ControlPlaneClient cpc : cpcsToShutdown) {
+      if (activatedCpClients.values().stream().noneMatch(list -> list.contains(cpc))) {
+        cpc.shutdown();
+        serverCpClientMap.remove(cpc.getServerInfo());
+      } else {
+        cpc.sendDiscoveryRequests();
+      }
+    }
+  }
+
+
+  /** Tracks a single subscribed resource. */
+  private final class ResourceSubscriber<T extends ResourceUpdate> {
+    @Nullable
+    private final String authority;
+    private final XdsResourceType<T> type;
+    private final String resource;
+    private final Map<ResourceWatcher<T>, Executor> watchers = new HashMap<>();
+    @Nullable
+    private T data;
+    private boolean absent;
+    // Tracks whether the deletion has been ignored per bootstrap server feature.
+    // See https://github.com/grpc/proposal/blob/master/A53-xds-ignore-resource-deletion.md
+    private boolean resourceDeletionIgnored;
+    @Nullable
+    private ScheduledHandle respTimer;
+    @Nullable
+    private ResourceMetadata metadata;
+    @Nullable
+    private String errorDescription;
+    @Nullable
+    private Status lastError;
+
+    ResourceSubscriber(XdsResourceType<T> type, String resource) {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      this.type = type;
+      this.resource = resource;
+      this.authority = getAuthorityFromResourceName(resource);
+      if (getServerInfos(authority) == null) {
+        this.errorDescription = "Wrong configuration: xds server does not exist for resource "
+            + resource;
+        return;
+      }
+
+      // Initialize metadata in UNKNOWN state to cover the case when resource subscriber,
+      // is created but not yet requested because the client is in backoff.
+      this.metadata = ResourceMetadata.newResourceMetadataUnknown();
+    }
+
+    @Override
+    public String toString() {
+      return "ResourceSubscriber{"
+          + "resource='" + resource + '\''
+          + ", authority='" + authority + '\''
+          + ", type=" + type
+          + ", watchers=" + watchers.size()
+          + ", data=" + data
+          + ", absent=" + absent
+          + ", resourceDeletionIgnored=" + resourceDeletionIgnored
+          + ", errorDescription='" + errorDescription + '\''
+          + '}';
+    }
+
+    void addWatcher(ResourceWatcher<T> watcher, Executor watcherExecutor) {
+      checkArgument(!watchers.containsKey(watcher), "watcher %s already registered", watcher);
+      watchers.put(watcher, watcherExecutor);
+      T savedData = data;
+      boolean savedAbsent = absent;
+      Status savedError = lastError;
+      watcherExecutor.execute(() -> {
+        if (errorDescription != null) {
+          watcher.onResourceChanged(StatusOr.fromStatus(
+              Status.INVALID_ARGUMENT.withDescription(errorDescription)));
+          return;
+        }
+        if (savedData != null) {
+          watcher.onResourceChanged(StatusOr.fromValue(savedData));
+          if (savedError != null) {
+            watcher.onAmbientError(savedError);
+          }
+        } else if (savedError != null) {
+          watcher.onResourceChanged(StatusOr.fromStatus(savedError));
+        } else if (savedAbsent) {
+          watcher.onResourceChanged(StatusOr.fromStatus(
+              Status.NOT_FOUND.withDescription("Resource " + resource + " does not exist")));
+        }
+      });
+    }
+
+    void removeWatcher(ResourceWatcher<T> watcher) {
+      checkArgument(watchers.containsKey(watcher), "watcher %s not registered", watcher);
+      watchers.remove(watcher);
+    }
+
+    void restartTimer() {
+      if (data != null || absent) {  // resource already resolved
+        return;
+      }
+      ControlPlaneClient activeCpc = getActiveCpc(authority);
+      if (activeCpc == null || !activeCpc.isReady()) {
+        // When client becomes ready, it triggers a restartTimer for all relevant subscribers.
+        return;
+      }
+      ServerInfo serverInfo = activeCpc.getServerInfo();
+      int timeoutSec = serverInfo.resourceTimerIsTransientError()
+          ? EXTENDED_RESOURCE_FETCH_TIMEOUT_SEC : INITIAL_RESOURCE_FETCH_TIMEOUT_SEC;
+
+      class ResourceNotFound implements Runnable {
+        @Override
+        public void run() {
+          logger.log(XdsLogLevel.INFO, "{0} resource {1} initial fetch timeout",
+              type, resource);
+          onAbsent(null, activeCpc.getServerInfo());
+          respTimer = null;
+        }
+
+        @Override
+        public String toString() {
+          return type + this.getClass().getSimpleName();
+        }
+      }
+
+      // Initial fetch scheduled or rescheduled, transition metadata state to REQUESTED.
+      metadata = ResourceMetadata.newResourceMetadataRequested();
+
+      if (respTimer != null) {
+        respTimer.cancel();
+      }
+      respTimer = syncContext.schedule(
+          new ResourceNotFound(), timeoutSec, TimeUnit.SECONDS, timeService);
+    }
+
+    void stopTimer() {
+      if (respTimer != null && respTimer.isPending()) {
+        respTimer.cancel();
+        respTimer = null;
+      }
+    }
+
+    void cancelResourceWatch() {
+      if (isWatched()) {
+        throw new IllegalStateException("Can't cancel resource watch with active watchers present");
+      }
+      stopTimer();
+      String message = "Unsubscribing {0} resource {1} from server {2}";
+      XdsLogLevel logLevel = XdsLogLevel.INFO;
+      if (resourceDeletionIgnored) {
+        message += " for which we previously ignored a deletion";
+        logLevel = XdsLogLevel.FORCE_INFO;
+      }
+      logger.log(logLevel, message, type, resource, getTarget());
+    }
+
+    boolean isWatched() {
+      return !watchers.isEmpty();
+    }
+
+    boolean hasResult() {
+      return data != null || absent;
+    }
+
+    void onData(ParsedResource<T> parsedResource, String version, long updateTime,
+                ProcessingTracker processingTracker) {
+      if (respTimer != null && respTimer.isPending()) {
+        respTimer.cancel();
+        respTimer = null;
+      }
+      ResourceUpdate oldData = this.data;
+      this.data = parsedResource.getResourceUpdate();
+      this.metadata = ResourceMetadata.newResourceMetadataAcked(
+          parsedResource.getRawResource(), version, updateTime);
+      absent = false;
+      lastError = null;
+      if (resourceDeletionIgnored) {
+        logger.log(XdsLogLevel.FORCE_INFO, "xds server {0}: server returned new version "
+                + "of resource for which we previously ignored a deletion: type {1} name {2}",
+            getTarget(), type, resource);
+        resourceDeletionIgnored = false;
+      }
+      if (!Objects.equals(oldData, data)) {
+        StatusOr<T> update = StatusOr.fromValue(data);
+        for (ResourceWatcher<T> watcher : watchers.keySet()) {
+          processingTracker.startTask();
+          watchers.get(watcher).execute(() -> {
+            try {
+              watcher.onResourceChanged(update);
+            } finally {
+              processingTracker.onComplete();
+            }
+          });
+        }
+      }
+    }
+
+    private String getTarget() {
+      ControlPlaneClient activeCpc = getActiveCpc(authority);
+      return (activeCpc != null)
+             ? activeCpc.getServerInfo().target()
+             : "unknown";
+    }
+
+    void onAbsent(@Nullable ProcessingTracker processingTracker, ServerInfo serverInfo) {
+      if (respTimer != null && respTimer.isPending()) {  // too early to conclude absence
+        return;
+      }
+
+      // Handle data errors (resource deletions) based on fail_on_data_errors server feature.
+      // When xdsDataErrorHandlingEnabled is true and fail_on_data_errors is not present,
+      // we treat deletions as ambient errors and keep using the cached resource.
+      // When fail_on_data_errors is present, we delete the cached resource and fail.
+      // When xdsDataErrorHandlingEnabled is false, use the old behavior (ignore_resource_deletion).
+      boolean ignoreResourceDeletionEnabled = serverInfo.ignoreResourceDeletion();
+      boolean failOnDataErrors = serverInfo.failOnDataErrors();
+      boolean xdsDataErrorHandlingEnabled = BootstrapperImpl.xdsDataErrorHandlingEnabled;
+
+      if (type.isFullStateOfTheWorld() && data != null) {
+        // New behavior (per gRFC A88): Default is to treat deletions as ambient errors
+        if (xdsDataErrorHandlingEnabled && !failOnDataErrors) {
+          if (!resourceDeletionIgnored) {
+            logger.log(XdsLogLevel.FORCE_WARNING,
+                "xds server {0}: ignoring deletion for resource type {1} name {2}}",
+                serverInfo.target(), type, resource);
+            resourceDeletionIgnored = true;
+          }
+          Status deletionStatus = Status.NOT_FOUND.withDescription(
+              "Resource " + resource + " deleted from server");
+          onAmbientError(deletionStatus, processingTracker);
+          return;
+        }
+        // Old behavior: Use ignore_resource_deletion server feature
+        if (!xdsDataErrorHandlingEnabled && ignoreResourceDeletionEnabled) {
+          if (!resourceDeletionIgnored) {
+            logger.log(XdsLogLevel.FORCE_WARNING,
+                "xds server {0}: ignoring deletion for resource type {1} name {2}}",
+                serverInfo.target(), type, resource);
+            resourceDeletionIgnored = true;
+          }
+          Status deletionStatus = Status.NOT_FOUND.withDescription(
+              "Resource " + resource + " deleted from server");
+          onAmbientError(deletionStatus, processingTracker);
+          return;
+        }
+      }
+
+      logger.log(XdsLogLevel.INFO, "Conclude {0} resource {1} not exist", type, resource);
+      if (!absent) {
+        data = null;
+        absent = true;
+        lastError = null;
+
+        Status status;
+        if (respTimer == null) {
+          status = Status.NOT_FOUND.withDescription("Resource " + resource + " does not exist");
+          metadata = ResourceMetadata.newResourceMetadataDoesNotExist();
+        } else {
+          status = serverInfo.resourceTimerIsTransientError()
+              ? Status.UNAVAILABLE.withDescription(
+                  "Timed out waiting for resource " + resource + " from xDS server")
+              : Status.NOT_FOUND.withDescription(
+                  "Timed out waiting for resource " + resource + " from xDS server");
+          metadata = serverInfo.resourceTimerIsTransientError()
+              ? ResourceMetadata.newResourceMetadataTimeout()
+              : ResourceMetadata.newResourceMetadataDoesNotExist();
+        }
+
+        StatusOr<T> update = StatusOr.fromStatus(status);
+        for (Map.Entry<ResourceWatcher<T>, Executor> entry : watchers.entrySet()) {
+          if (processingTracker != null) {
+            processingTracker.startTask();
+          }
+          entry.getValue().execute(() -> {
+            try {
+              entry.getKey().onResourceChanged(update);
+            } finally {
+              if (processingTracker != null) {
+                processingTracker.onComplete();
+              }
+            }
+          });
+        }
+      }
+    }
+
+    void onError(Status error, @Nullable ProcessingTracker tracker) {
+      if (respTimer != null && respTimer.isPending()) {
+        respTimer.cancel();
+        respTimer = null;
+      }
+
+      // Include node ID in xds failures to allow cross-referencing with control plane logs
+      // when debugging.
+      String description = error.getDescription() == null ? "" : error.getDescription() + " ";
+      Status errorAugmented = Status.fromCode(error.getCode())
+          .withDescription(description + "nodeID: " + bootstrapInfo.node().getId())
+          .withCause(error.getCause());
+      this.lastError = errorAugmented;
+
+      if (data != null) {
+        // We have cached data, so this is an ambient error.
+        onAmbientError(errorAugmented, tracker);
+      } else {
+        // No data, this is a definitive resource error.
+        StatusOr<T> update = StatusOr.fromStatus(errorAugmented);
+        for (Map.Entry<ResourceWatcher<T>, Executor> entry : watchers.entrySet()) {
+          if (tracker != null) {
+            tracker.startTask();
+          }
+          entry.getValue().execute(() -> {
+            try {
+              entry.getKey().onResourceChanged(update);
+            } finally {
+              if (tracker != null) {
+                tracker.onComplete();
+              }
+            }
+          });
+        }
+      }
+    }
+
+    private void onAmbientError(Status error, @Nullable ProcessingTracker tracker) {
+      for (Map.Entry<ResourceWatcher<T>, Executor> entry : watchers.entrySet()) {
+        if (tracker != null) {
+          tracker.startTask();
+        }
+        entry.getValue().execute(() -> {
+          try {
+            entry.getKey().onAmbientError(error);
+          } finally {
+            if (tracker != null) {
+              tracker.onComplete();
+            }
+          }
+        });
+      }
+    }
+
+    void onRejected(String rejectedVersion, long rejectedTime, String rejectedDetails) {
+      metadata = ResourceMetadata
+          .newResourceMetadataNacked(metadata, rejectedVersion, rejectedTime, rejectedDetails,
+              data != null);
+    }
+  }
+
+  private class ResponseHandler implements XdsResponseHandler {
+    final ServerInfo serverInfo;
+
+    ResponseHandler(ServerInfo serverInfo) {
+      this.serverInfo = serverInfo;
+    }
+
+    @Override
+    public void handleResourceResponse(
+        XdsResourceType<?> xdsResourceType, ServerInfo serverInfo, String versionInfo,
+        List<Any> resources, String nonce, boolean isFirstResponse,
+        ProcessingTracker processingTracker) {
+      checkNotNull(xdsResourceType, "xdsResourceType");
+      syncContext.throwIfNotInThisSynchronizationContext();
+      Set<String> toParseResourceNames =
+          xdsResourceType.shouldRetrieveResourceKeysForArgs()
+          ? getResourceKeys(xdsResourceType)
+          : null;
+      XdsResourceType.Args args = new XdsResourceType.Args(serverInfo, versionInfo, nonce,
+          bootstrapInfo, securityConfig, toParseResourceNames);
+      handleResourceUpdate(args, resources, xdsResourceType, isFirstResponse, processingTracker);
+    }
+
+    @Override
+    public void handleStreamClosed(Status status, boolean shouldTryFallback) {
+      syncContext.throwIfNotInThisSynchronizationContext();
+
+      ControlPlaneClient cpcClosed = serverCpClientMap.get(serverInfo);
+      if (cpcClosed == null) {
+        logger.log(XdsLogLevel.DEBUG,
+            "Couldn't find closing CPC for {0}, so skipping cleanup and reporting", serverInfo);
+        return;
+      }
+
+      cleanUpResourceTimers(cpcClosed);
+
+      if (status.isOk()) {
+        return; // Not considered an error
+      }
+
+      metricReporter.reportServerFailure(1L, serverInfo.target());
+
+      Collection<String> authoritiesForClosedCpc = getActiveAuthorities(cpcClosed);
+      for (Map<String, ResourceSubscriber<? extends ResourceUpdate>> subscriberMap :
+          resourceSubscribers.values()) {
+        for (ResourceSubscriber<? extends ResourceUpdate> subscriber : subscriberMap.values()) {
+          if (!authoritiesForClosedCpc.contains(subscriber.authority)) {
+            continue;
+          }
+          // If subscriber already has data, this is an ambient error.
+          if (subscriber.hasResult()) {
+            subscriber.onError(status, null);
+            continue;
+          }
+
+          // try to fallback to lower priority control plane client
+          if (shouldTryFallback && manageControlPlaneClient(subscriber).didFallback) {
+            authoritiesForClosedCpc.remove(subscriber.authority);
+            if (authoritiesForClosedCpc.isEmpty()) {
+              return; // optimization: no need to continue once all authorities have done fallback
+            }
+            continue; // since we did fallback, don't consider it an error
+          }
+
+          subscriber.onError(status, null);
+        }
+      }
+    }
+  }
+
+  private static class CpcWithFallbackState {
+    ControlPlaneClient cpc;
+    boolean didFallback;
+
+    private CpcWithFallbackState(ControlPlaneClient cpc, boolean didFallback) {
+      this.cpc = cpc;
+      this.didFallback = didFallback;
+    }
+  }
+
+  private Collection<String> getActiveAuthorities(ControlPlaneClient cpc) {
+    List<String> asList = activatedCpClients.entrySet().stream()
+        .filter(entry -> !entry.getValue().isEmpty()
+            && cpc == entry.getValue().get(entry.getValue().size() - 1))
+        .map(Map.Entry::getKey)
+        .collect(Collectors.toList());
+
+    // Since this is usually used for contains, use a set when the list is large
+    return (asList.size() < 100) ? asList : new HashSet<>(asList);
+  }
+
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/XdsClientMetricReporter.java b/xds/src/main/java/io/grpc/xds/client/XdsClientMetricReporter.java
new file mode 100644
index 00000000000..a044d501759
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/XdsClientMetricReporter.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2024 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.xds.client;
+
+import io.grpc.Internal;
+
+/**
+ * Interface for reporting metrics from the xDS client.
+ */
+@Internal
+public interface XdsClientMetricReporter {
+
+  /**
+   * Reports number of valid and invalid resources.
+   *
+   * @param validResourceCount Number of resources that were valid.
+   * @param invalidResourceCount Number of resources that were invalid.
+   * @param xdsServer Target URI of the xDS server with which the XdsClient is communicating.
+   * @param resourceType Type of XDS resource (e.g., "envoy.config.listener.v3.Listener").
+   */
+  default void reportResourceUpdates(long validResourceCount, long invalidResourceCount,
+      String xdsServer, String resourceType) {
+  }
+
+  /**
+   * Reports number of xDS servers going from healthy to unhealthy.
+   *
+   * @param serverFailure Number of xDS server failures.
+   * @param xdsServer Target URI of the xDS server with which the XdsClient is communicating.
+   */
+  default void reportServerFailure(long serverFailure, String xdsServer) {
+  }
+
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/XdsInitializationException.java b/xds/src/main/java/io/grpc/xds/client/XdsInitializationException.java
new file mode 100644
index 00000000000..6d0408519ba
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/XdsInitializationException.java
@@ -0,0 +1,35 @@
+/*
+ * 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.xds.client;
+
+import io.grpc.Internal;
+
+/**
+ * Throws when fail to bootstrap or initialize the XdsClient.
+ */
+@Internal
+public final class XdsInitializationException extends Exception {
+  private static final long serialVersionUID = 1L;
+
+  public XdsInitializationException(String message) {
+    super(message);
+  }
+
+  public XdsInitializationException(String message, Throwable cause) {
+    super(message, cause);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/XdsLogger.java b/xds/src/main/java/io/grpc/xds/client/XdsLogger.java
new file mode 100644
index 00000000000..c71eceeffa1
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/XdsLogger.java
@@ -0,0 +1,124 @@
+/*
+ * 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.xds.client;
+
+import com.google.common.base.Preconditions;
+import io.grpc.Internal;
+import io.grpc.InternalLogId;
+import java.text.MessageFormat;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+
+/**
+ * An xDS-specific logger for collecting xDS specific events. Information logged here goes
+ * to the Java logger of this class.
+ */
+@Internal
+public final class XdsLogger {
+  private static final Logger logger = Logger.getLogger("io.grpc.xds.XdsLogger");
+
+  private final String prefix;
+
+  public static XdsLogger withLogId(InternalLogId logId) {
+    Preconditions.checkNotNull(logId, "logId");
+    return new XdsLogger(logId.toString());
+  }
+
+  static XdsLogger withPrefix(String prefix) {
+    return new XdsLogger(prefix);
+  }
+
+  private XdsLogger(String prefix) {
+    this.prefix = Preconditions.checkNotNull(prefix, "prefix");
+  }
+
+  public boolean isLoggable(XdsLogLevel level) {
+    Level javaLevel = toJavaLogLevel(level);
+    return logger.isLoggable(javaLevel);
+  }
+
+  void log(XdsLogLevel level, String msg) {
+    Level javaLevel = toJavaLogLevel(level);
+    logOnly(prefix, javaLevel, msg);
+  }
+
+  public void log(XdsLogLevel level, String messageFormat, Object... args) {
+    Level javaLogLevel = toJavaLogLevel(level);
+    if (logger.isLoggable(javaLogLevel)) {
+      String msg = MessageFormat.format(messageFormat, args);
+      logOnly(prefix, javaLogLevel, msg);
+    }
+  }
+
+  private static void logOnly(String prefix, Level logLevel, String msg) {
+    if (logger.isLoggable(logLevel)) {
+      LogRecord lr = new LogRecord(logLevel, "[" + prefix + "] " + msg);
+      // No resource bundle as gRPC is not localized.
+      lr.setLoggerName(logger.getName());
+      lr.setSourceClassName(logger.getName());
+      lr.setSourceMethodName("log");
+      logger.log(lr);
+    }
+  }
+
+  private static Level toJavaLogLevel(XdsLogLevel level) {
+    switch (level) {
+      case ERROR:
+      case WARNING:
+        return Level.FINE;
+      case INFO:
+        return Level.FINER;
+      case FORCE_INFO:
+        return Level.INFO;
+      case FORCE_WARNING:
+        return Level.WARNING;
+      default:
+        return Level.FINEST;
+    }
+  }
+
+  /**
+   * Log levels. See the table below for the mapping from the XdsLogger levels to
+   * Java logger levels.
+   *
+   * <p><b>NOTE:</b>
+   *   Please use {@code FORCE_} levels with care, only when the message is expected to be
+   *   surfaced to the library user. Normally libraries should minimize the usage
+   *   of highly visible logs.
+   * <pre>
+   * +---------------------+-------------------+
+   * | XdsLogger Level     | Java Logger Level |
+   * +---------------------+-------------------+
+   * | DEBUG               | FINEST            |
+   * | INFO                | FINER             |
+   * | WARNING             | FINE              |
+   * | ERROR               | FINE              |
+   * | FORCE_INFO          | INFO              |
+   * | FORCE_WARNING       | WARNING           |
+   * +---------------------+-------------------+
+   * </pre>
+   */
+  public enum XdsLogLevel {
+    DEBUG,
+    INFO,
+    WARNING,
+    ERROR,
+    FORCE_INFO,
+    FORCE_WARNING,
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/XdsResourceType.java b/xds/src/main/java/io/grpc/xds/client/XdsResourceType.java
new file mode 100644
index 00000000000..4d6e75b1809
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/XdsResourceType.java
@@ -0,0 +1,261 @@
+/*
+ * Copyright 2022 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.xds.client;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.grpc.xds.client.XdsClient.canonifyResourceName;
+import static io.grpc.xds.client.XdsClient.isResourceNameValid;
+
+import com.google.protobuf.Any;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Message;
+import io.envoyproxy.envoy.service.discovery.v3.Resource;
+import io.grpc.ExperimentalApi;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.XdsClient.ResourceUpdate;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/10847")
+public abstract class XdsResourceType<T extends ResourceUpdate> {
+  private static final Logger log = Logger.getLogger(XdsResourceType.class.getName());
+
+  static final String TYPE_URL_RESOURCE =
+      "type.googleapis.com/envoy.service.discovery.v3.Resource";
+  protected static final String TRANSPORT_SOCKET_NAME_TLS = "envoy.transport_sockets.tls";
+
+  protected static final String TYPE_URL_TYPED_STRUCT_UDPA =
+      "type.googleapis.com/udpa.type.v1.TypedStruct";
+  protected static final String TYPE_URL_TYPED_STRUCT =
+      "type.googleapis.com/xds.type.v3.TypedStruct";
+
+  /**
+   * Extract the resource name from an older resource type that included the name within the
+   * resource contents itself. The newer approach has resources wrapped with {@code
+   * envoy.service.discovery.v3.Resource} which then provides the name. This method is only called
+   * for the old approach.
+   *
+   * @return the resource's name, or {@code null} if name is not stored within the resource contents
+   */
+  @Nullable
+  protected String extractResourceName(Message unpackedResource) {
+    return null;
+  }
+
+  protected abstract Class<? extends com.google.protobuf.Message> unpackedClassName();
+
+  public abstract String typeName();
+
+  public abstract String typeUrl();
+
+  public abstract boolean shouldRetrieveResourceKeysForArgs();
+
+  // Do not confuse with the SotW approach: it is the mechanism in which the client must specify all
+  // resource names it is interested in with each request. Different resource types may behave
+  // differently in this approach. For LDS and CDS resources, the server must return all resources
+  // that the client has subscribed to in each request. For RDS and EDS, the server may only return
+  // the resources that need an update.
+  protected abstract boolean isFullStateOfTheWorld();
+
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10847")
+  public static class Args {
+    final ServerInfo serverInfo;
+    final String versionInfo;
+    final String nonce;
+    final Bootstrapper.BootstrapInfo bootstrapInfo;
+    final Object securityConfig;
+    // Management server is required to always send newly requested resources, even if they
+    // may have been sent previously (proactively). Thus, client does not need to cache
+    // unrequested resources.
+    // Only resources in the set needs to be parsed. Null means parse everything.
+    final @Nullable Set<String> subscribedResources;
+
+    public Args(ServerInfo serverInfo, String versionInfo, String nonce,
+                Bootstrapper.BootstrapInfo bootstrapInfo,
+                Object securityConfig,
+                @Nullable Set<String> subscribedResources) {
+      this.serverInfo = serverInfo;
+      this.versionInfo = versionInfo;
+      this.nonce = nonce;
+      this.bootstrapInfo = bootstrapInfo;
+      this.securityConfig = securityConfig;
+      this.subscribedResources = subscribedResources;
+    }
+
+    public ServerInfo getServerInfo() {
+      return serverInfo;
+    }
+
+    public String getNonce() {
+      return nonce;
+    }
+
+    public Bootstrapper.BootstrapInfo getBootstrapInfo() {
+      return bootstrapInfo;
+    }
+
+    public Object getSecurityConfig() {
+      return securityConfig;
+    }
+  }
+
+  @ExperimentalApi("https://github.com/grpc/grpc-java/issues/10847")
+  public static final class ResourceInvalidException extends Exception {
+    private static final long serialVersionUID = 0L;
+
+    public ResourceInvalidException(String message) {
+      super(message, null, false, false);
+    }
+
+    public ResourceInvalidException(String message, Throwable cause) {
+      super(cause != null ? message + ": " + cause.getMessage() : message, cause, false, false);
+    }
+  }
+
+  ValidatedResourceUpdate<T> parse(Args args, List<Any> resources) {
+    Map<String, ParsedResource<T>> parsedResources = new HashMap<>(resources.size());
+    Set<String> unpackedResources = new HashSet<>(resources.size());
+    Set<String> invalidResources = new HashSet<>();
+    List<String> errors = new ArrayList<>();
+
+    for (int i = 0; i < resources.size(); i++) {
+      Any resource = resources.get(i);
+
+      Message unpackedMessage;
+      String name = "";
+      try {
+        if (resource.getTypeUrl().equals(TYPE_URL_RESOURCE)) {
+          Resource wrappedResource = unpackCompatibleType(resource, Resource.class,
+              TYPE_URL_RESOURCE, null);
+          resource = wrappedResource.getResource();
+          name = wrappedResource.getName();
+        } 
+        unpackedMessage = unpackCompatibleType(resource, unpackedClassName(), typeUrl(), null);
+      } catch (InvalidProtocolBufferException e) {
+        errors.add(String.format("%s response Resource index %d - can't decode %s: %s",
+                typeName(), i, unpackedClassName().getSimpleName(), e.getMessage()));
+        continue;
+      }
+      // Fallback to inner resource name if the outer resource didn't have a name.
+      if (name.isEmpty()) {
+        name = extractResourceName(unpackedMessage);
+      }
+      if (name == null || !isResourceNameValid(name, resource.getTypeUrl())) {
+        errors.add(
+            "Unsupported resource name: " + name + " for type: " + typeName());
+        continue;
+      }
+      String cname = canonifyResourceName(name);
+      if (args.subscribedResources != null && !args.subscribedResources.contains(name)) {
+        continue;
+      }
+      unpackedResources.add(cname);
+
+      T resourceUpdate;
+      try {
+        resourceUpdate = doParse(args, unpackedMessage);
+      } catch (ResourceInvalidException e) {
+        errors.add(String.format("%s response %s '%s' validation error: %s",
+                typeName(), unpackedClassName().getSimpleName(), cname, e.getMessage()));
+        invalidResources.add(cname);
+        continue;
+      } catch (Throwable t) {
+        log.log(Level.FINE, "Unexpected error in doParse()", t);
+        String errorMessage = t.getClass().getSimpleName();
+        if (t.getMessage() != null) {
+          errorMessage = errorMessage + ": " + t.getMessage();
+        }
+        errors.add(String.format("%s response '%s' unexpected error: %s",
+                typeName(), cname, errorMessage));
+        invalidResources.add(cname);
+        continue;
+      }
+
+      // Resource parsed successfully.
+      parsedResources.put(cname, new ParsedResource<T>(resourceUpdate, resource));
+    }
+    return new ValidatedResourceUpdate<T>(parsedResources, unpackedResources, invalidResources,
+        errors);
+
+  }
+
+  protected abstract T doParse(Args args, Message unpackedMessage) throws ResourceInvalidException;
+
+  /**
+   * Helper method to unpack serialized {@link com.google.protobuf.Any} message, while replacing
+   * Type URL {@code compatibleTypeUrl} with {@code typeUrl}.
+   *
+   * @param <T> The type of unpacked message
+   * @param any serialized message to unpack
+   * @param clazz the class to unpack the message to
+   * @param typeUrl type URL to replace message Type URL, when it's compatible
+   * @param compatibleTypeUrl compatible Type URL to be replaced with {@code typeUrl}
+   * @return Unpacked message
+   * @throws InvalidProtocolBufferException if the message couldn't be unpacked
+   */
+  protected static <T extends com.google.protobuf.Message> T unpackCompatibleType(
+      Any any, Class<T> clazz, String typeUrl, String compatibleTypeUrl)
+      throws InvalidProtocolBufferException {
+    if (any.getTypeUrl().equals(compatibleTypeUrl)) {
+      any = any.toBuilder().setTypeUrl(typeUrl).build();
+    }
+    return any.unpack(clazz);
+  }
+
+  static final class ParsedResource<T extends ResourceUpdate> {
+    private final T resourceUpdate;
+    private final Any rawResource;
+
+    public ParsedResource(T resourceUpdate, Any rawResource) {
+      this.resourceUpdate = checkNotNull(resourceUpdate, "resourceUpdate");
+      this.rawResource = checkNotNull(rawResource, "rawResource");
+    }
+
+    T getResourceUpdate() {
+      return resourceUpdate;
+    }
+
+    Any getRawResource() {
+      return rawResource;
+    }
+  }
+
+  static final class ValidatedResourceUpdate<T extends ResourceUpdate> {
+    Map<String, ParsedResource<T>> parsedResources;
+    Set<String> unpackedResources;
+    Set<String> invalidResources;
+    List<String> errors;
+
+    // validated resource update
+    public ValidatedResourceUpdate(Map<String, ParsedResource<T>> parsedResources,
+                                   Set<String> unpackedResources,
+                                   Set<String> invalidResources,
+                                   List<String> errors) {
+      this.parsedResources = parsedResources;
+      this.unpackedResources = unpackedResources;
+      this.invalidResources = invalidResources;
+      this.errors = errors;
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/client/XdsTransportFactory.java b/xds/src/main/java/io/grpc/xds/client/XdsTransportFactory.java
new file mode 100644
index 00000000000..ec700bd6dc9
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/client/XdsTransportFactory.java
@@ -0,0 +1,93 @@
+/*
+ * Copyright 2024 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.xds.client;
+
+import io.grpc.ExperimentalApi;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+
+/**
+ * A factory for creating new XdsTransport instances.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/10823")
+public interface XdsTransportFactory {
+  XdsTransport create(Bootstrapper.ServerInfo serverInfo);
+
+  /**
+   * Represents transport for xDS communication (e.g., a gRPC channel).
+   */
+  interface XdsTransport {
+    <ReqT, RespT> StreamingCall<ReqT, RespT> createStreamingCall(
+         String fullMethodName, MethodDescriptor.Marshaller<ReqT> reqMarshaller,
+         MethodDescriptor.Marshaller<RespT> respMarshaller);
+
+    void shutdown();
+  }
+
+  /**
+   * Represents a bidi streaming RPC call.
+   */
+  interface StreamingCall<ReqT, RespT> {
+    void start(EventHandler<RespT> eventHandler);
+
+    /**
+     * Sends a message on the stream.
+     * Only one message will be in flight at a time; subsequent
+     * messages will not be sent until this one is done.
+     */
+    void sendMessage(ReqT message);
+
+    /**
+     * Requests a message to be received.
+     */
+    void startRecvMessage();
+
+    /**
+     * An error is encountered. Sends the error.
+     */
+    void sendError(Exception e);
+
+    /** Indicates whether call is capable of sending additional messages without requiring
+     * excessive buffering internally. Used for resource initial fetch timeout notification. See
+     * also {@link EventHandler#onReady()}. Application is free to ignore it.
+     */
+    boolean isReady();
+  }
+
+  /**
+   * An interface for handling events on a streaming call.
+   **/
+  interface EventHandler<RespT> {
+
+    /**
+     * Called when the stream is ready to send additional messages. If called the library use this
+     * handler to trigger resource arrival timeout, also see {@link StreamingCall#isReady()}.
+     * Application is free to ignore it.
+     */
+    void onReady();
+
+    /**
+     * Called when a message is received on the stream.
+     */
+    void onRecvMessage(RespT message);
+
+    /**
+     * Called when status is received on the stream.
+     */
+    void onStatusReceived(Status status);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/GoogleDefaultXdsCredentialsProvider.java b/xds/src/main/java/io/grpc/xds/internal/GoogleDefaultXdsCredentialsProvider.java
new file mode 100644
index 00000000000..383c19b6665
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/GoogleDefaultXdsCredentialsProvider.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2022 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.xds.internal;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.alts.GoogleDefaultChannelCredentials;
+import io.grpc.xds.XdsCredentialsProvider;
+import java.util.Map;
+
+/**
+ * A wrapper class that supports {@link GoogleDefaultChannelCredentials} for
+ * Xds by implementing {@link XdsCredentialsProvider}.
+ */
+public final class GoogleDefaultXdsCredentialsProvider extends XdsCredentialsProvider {
+  private static final String CREDS_NAME = "google_default";
+
+  @Override
+  protected ChannelCredentials newChannelCredentials(Map<String, ?> jsonConfig) {
+    return GoogleDefaultChannelCredentials.create();
+  }
+
+  @Override
+  protected String getName() {
+    return CREDS_NAME;
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int priority() {
+    return 5;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/InsecureXdsCredentialsProvider.java b/xds/src/main/java/io/grpc/xds/internal/InsecureXdsCredentialsProvider.java
new file mode 100644
index 00000000000..d57cfe2f238
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/InsecureXdsCredentialsProvider.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2022 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.xds.internal;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.xds.XdsCredentialsProvider;
+import java.util.Map;
+
+/**
+ * A wrapper class that supports {@link InsecureChannelCredentials} for Xds
+ * by implementing {@link XdsCredentialsProvider}.
+ */
+public final class InsecureXdsCredentialsProvider extends XdsCredentialsProvider {
+  private static final String CREDS_NAME = "insecure";
+
+  @Override
+  protected ChannelCredentials newChannelCredentials(Map<String, ?> jsonConfig) {
+    return InsecureChannelCredentials.create();
+  }
+
+  @Override
+  protected String getName() {
+    return CREDS_NAME;
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int priority() {
+    return 5;
+  }
+
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/MatcherParser.java b/xds/src/main/java/io/grpc/xds/internal/MatcherParser.java
new file mode 100644
index 00000000000..fb291efc461
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/MatcherParser.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2021 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.xds.internal;
+
+import com.google.re2j.Pattern;
+import com.google.re2j.PatternSyntaxException;
+
+// TODO(zivy@): may reuse common matchers parsers.
+public final class MatcherParser {
+  /** Translates envoy proto HeaderMatcher to internal HeaderMatcher.*/
+  public static Matchers.HeaderMatcher parseHeaderMatcher(
+          io.envoyproxy.envoy.config.route.v3.HeaderMatcher proto) {
+    switch (proto.getHeaderMatchSpecifierCase()) {
+      case EXACT_MATCH:
+        @SuppressWarnings("deprecation") // gRFC A63: support indefinitely
+        String exactMatch = proto.getExactMatch();
+        return Matchers.HeaderMatcher.forExactValue(
+                        proto.getName(), exactMatch, proto.getInvertMatch());
+      case SAFE_REGEX_MATCH:
+        @SuppressWarnings("deprecation") // gRFC A63: support indefinitely
+        String rawPattern = proto.getSafeRegexMatch().getRegex();
+        Pattern safeRegExMatch;
+        try {
+          safeRegExMatch = Pattern.compile(rawPattern);
+        } catch (PatternSyntaxException e) {
+          throw new IllegalArgumentException(
+                "HeaderMatcher [" + proto.getName() + "] contains malformed safe regex pattern: "
+                        + e.getMessage());
+        }
+        return Matchers.HeaderMatcher.forSafeRegEx(
+              proto.getName(), safeRegExMatch, proto.getInvertMatch());
+      case RANGE_MATCH:
+        Matchers.HeaderMatcher.Range rangeMatch = Matchers.HeaderMatcher.Range.create(
+              proto.getRangeMatch().getStart(), proto.getRangeMatch().getEnd());
+        return Matchers.HeaderMatcher.forRange(
+              proto.getName(), rangeMatch, proto.getInvertMatch());
+      case PRESENT_MATCH:
+        return Matchers.HeaderMatcher.forPresent(
+              proto.getName(), proto.getPresentMatch(), proto.getInvertMatch());
+      case PREFIX_MATCH:
+        @SuppressWarnings("deprecation") // gRFC A63: support indefinitely
+        String prefixMatch = proto.getPrefixMatch();
+        return Matchers.HeaderMatcher.forPrefix(
+              proto.getName(), prefixMatch, proto.getInvertMatch());
+      case SUFFIX_MATCH:
+        @SuppressWarnings("deprecation") // gRFC A63: support indefinitely
+        String suffixMatch = proto.getSuffixMatch();
+        return Matchers.HeaderMatcher.forSuffix(
+              proto.getName(), suffixMatch, proto.getInvertMatch());
+      case CONTAINS_MATCH:
+        @SuppressWarnings("deprecation") // gRFC A63: support indefinitely
+        String containsMatch = proto.getContainsMatch();
+        return Matchers.HeaderMatcher.forContains(
+              proto.getName(), containsMatch, proto.getInvertMatch());
+      case STRING_MATCH:
+        return Matchers.HeaderMatcher.forString(
+          proto.getName(), parseStringMatcher(proto.getStringMatch()), proto.getInvertMatch());
+      case HEADERMATCHSPECIFIER_NOT_SET:
+      default:
+        throw new IllegalArgumentException(
+                "Unknown header matcher type: " + proto.getHeaderMatchSpecifierCase());
+    }
+  }
+
+  /** Translate StringMatcher envoy proto to internal StringMatcher. */
+  public static Matchers.StringMatcher parseStringMatcher(
+            io.envoyproxy.envoy.type.matcher.v3.StringMatcher proto) {
+    switch (proto.getMatchPatternCase()) {
+      case EXACT:
+        return Matchers.StringMatcher.forExact(proto.getExact(), proto.getIgnoreCase());
+      case PREFIX:
+        return Matchers.StringMatcher.forPrefix(proto.getPrefix(), proto.getIgnoreCase());
+      case SUFFIX:
+        return Matchers.StringMatcher.forSuffix(proto.getSuffix(), proto.getIgnoreCase());
+      case SAFE_REGEX:
+        return Matchers.StringMatcher.forSafeRegEx(
+                Pattern.compile(proto.getSafeRegex().getRegex()));
+      case CONTAINS:
+        return Matchers.StringMatcher.forContains(proto.getContains());
+      case MATCHPATTERN_NOT_SET:
+      default:
+        throw new IllegalArgumentException(
+                "Unknown StringMatcher match pattern: " + proto.getMatchPatternCase());
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/Matchers.java b/xds/src/main/java/io/grpc/xds/internal/Matchers.java
new file mode 100644
index 00000000000..228b20cfcd7
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/Matchers.java
@@ -0,0 +1,332 @@
+/*
+ * Copyright 2021 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.xds.internal;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.auto.value.AutoValue;
+import com.google.re2j.Pattern;
+import java.math.BigInteger;
+import java.net.InetAddress;
+import java.util.Locale;
+import javax.annotation.Nullable;
+
+/**
+ * Provides a group of request matchers. A matcher evaluates an input and tells whether certain
+ * argument in the input matches a predefined matching pattern.
+ */
+public final class Matchers {
+  // Prevent instantiation.
+  private Matchers() {}
+
+  /** Matcher for HTTP request headers. */
+  @AutoValue
+  public abstract static class HeaderMatcher {
+    // Name of the header to be matched.
+    public abstract String name();
+
+    // Matches exact header value.
+    @Nullable
+    public abstract String exactValue();
+
+    // Matches header value with the regular expression pattern.
+    @Nullable
+    public abstract Pattern safeRegEx();
+
+    // Matches header value an integer value in the range.
+    @Nullable
+    public abstract Range range();
+
+    // Matches header presence.
+    @Nullable
+    public abstract Boolean present();
+
+    // Matches header value with the prefix.
+    @Nullable
+    public abstract String prefix();
+
+    // Matches header value with the suffix.
+    @Nullable
+    public abstract String suffix();
+
+    // Matches header value with the substring.
+    @Nullable
+    public abstract String contains();
+
+    // Matches header value with the string matcher.
+    @Nullable
+    public abstract StringMatcher stringMatcher();
+
+    // Whether the matching semantics is inverted. E.g., present && !inverted -> !present
+    public abstract boolean inverted();
+
+    /** The request header value should exactly match the specified value. */
+    public static HeaderMatcher forExactValue(String name, String exactValue, boolean inverted) {
+      checkNotNull(name, "name");
+      checkNotNull(exactValue, "exactValue");
+      return HeaderMatcher.create(
+        name, exactValue, null, null, null, null, null, null, null, inverted);
+    }
+
+    /** The request header value should match the regular expression pattern. */
+    public static HeaderMatcher forSafeRegEx(String name, Pattern safeRegEx, boolean inverted) {
+      checkNotNull(name, "name");
+      checkNotNull(safeRegEx, "safeRegEx");
+      return HeaderMatcher.create(
+        name, null, safeRegEx, null, null, null, null, null, null, inverted);
+    }
+
+    /** The request header value should be within the range. */
+    public static HeaderMatcher forRange(String name, Range range, boolean inverted) {
+      checkNotNull(name, "name");
+      checkNotNull(range, "range");
+      return HeaderMatcher.create(name, null, null, range, null, null, null, null, null, inverted);
+    }
+
+    /** The request header value should exist. */
+    public static HeaderMatcher forPresent(String name, boolean present, boolean inverted) {
+      checkNotNull(name, "name");
+      return HeaderMatcher.create(
+        name, null, null, null, present, null, null, null, null, inverted);
+    }
+
+    /** The request header value should have this prefix. */
+    public static HeaderMatcher forPrefix(String name, String prefix, boolean inverted) {
+      checkNotNull(name, "name");
+      checkNotNull(prefix, "prefix");
+      return HeaderMatcher.create(name, null, null, null, null, prefix, null, null, null, inverted);
+    }
+
+    /** The request header value should have this suffix. */
+    public static HeaderMatcher forSuffix(String name, String suffix, boolean inverted) {
+      checkNotNull(name, "name");
+      checkNotNull(suffix, "suffix");
+      return HeaderMatcher.create(name, null, null, null, null, null, suffix, null, null, inverted);
+    }
+
+    /** The request header value should have this substring. */
+    public static HeaderMatcher forContains(String name, String contains, boolean inverted) {
+      checkNotNull(name, "name");
+      checkNotNull(contains, "contains");
+      return HeaderMatcher.create(
+        name, null, null, null, null, null, null, contains, null, inverted);
+    }
+
+    /** The request header value should match this stringMatcher. */
+    public static HeaderMatcher forString(
+        String name, StringMatcher stringMatcher, boolean inverted) {
+      checkNotNull(name, "name");
+      checkNotNull(stringMatcher, "stringMatcher");
+      return HeaderMatcher.create(
+        name, null, null, null, null, null, null, null, stringMatcher, inverted);
+    }
+
+    private static HeaderMatcher create(String name, @Nullable String exactValue,
+        @Nullable Pattern safeRegEx, @Nullable Range range,
+        @Nullable Boolean present, @Nullable String prefix,
+        @Nullable String suffix, @Nullable String contains,
+        @Nullable StringMatcher stringMatcher, boolean inverted) {
+      checkNotNull(name, "name");
+      return new AutoValue_Matchers_HeaderMatcher(name, exactValue, safeRegEx, range, present,
+          prefix, suffix, contains, stringMatcher, inverted);
+    }
+
+    /** Returns the matching result. */
+    public boolean matches(@Nullable String value) {
+      if (value == null) {
+        return present() != null && present() == inverted();
+      }
+      boolean baseMatch;
+      if (exactValue() != null) {
+        baseMatch = exactValue().equals(value);
+      } else if (safeRegEx() != null) {
+        baseMatch = safeRegEx().matches(value);
+      } else if (range() != null) {
+        long numValue;
+        try {
+          numValue = Long.parseLong(value);
+          baseMatch = numValue >= range().start()
+              && numValue <= range().end();
+        } catch (NumberFormatException ignored) {
+          baseMatch = false;
+        }
+      } else if (prefix() != null) {
+        baseMatch = value.startsWith(prefix());
+      } else if (present() != null) {
+        baseMatch = present();
+      } else if (suffix() != null) {
+        baseMatch = value.endsWith(suffix());
+      } else if (contains() != null) {
+        baseMatch = value.contains(contains());
+      } else {
+        baseMatch = stringMatcher().matches(value);
+      }
+      return baseMatch != inverted();
+    }
+
+    /** Represents an integer range. */
+    @AutoValue
+    public abstract static class Range {
+      public abstract long start();
+
+      public abstract long end();
+
+      public static Range create(long start, long end) {
+        return new AutoValue_Matchers_HeaderMatcher_Range(start, end);
+      }
+    }
+  }
+
+  /** Represents a fractional value. */
+  @AutoValue
+  public abstract static class FractionMatcher {
+    public abstract int numerator();
+
+    public abstract int denominator();
+
+    public static FractionMatcher create(int numerator, int denominator) {
+      return new AutoValue_Matchers_FractionMatcher(numerator, denominator);
+    }
+  }
+
+  /** Represents various ways to match a string .*/
+  @AutoValue
+  public abstract static class StringMatcher {
+    @Nullable
+    abstract String exact();
+
+    // The input string has this prefix.
+    @Nullable
+    abstract String prefix();
+
+    // The input string has this suffix.
+    @Nullable
+    abstract String suffix();
+
+    // The input string matches the regular expression.
+    @Nullable
+    abstract Pattern regEx();
+
+    // The input string has this substring.
+    @Nullable
+    abstract String contains();
+
+    // If true, exact/prefix/suffix matching should be case insensitive.
+    abstract boolean ignoreCase();
+
+    /** The input string should exactly matches the specified string. */
+    public static StringMatcher forExact(String exact, boolean ignoreCase) {
+      checkNotNull(exact, "exact");
+      return StringMatcher.create(exact, null, null, null, null,
+          ignoreCase);
+    }
+
+    /** The input string should have the prefix. */
+    public static StringMatcher forPrefix(String prefix, boolean ignoreCase) {
+      checkNotNull(prefix, "prefix");
+      return StringMatcher.create(null, prefix, null, null, null,
+          ignoreCase);
+    }
+
+    /** The input string should have the suffix. */
+    public static StringMatcher forSuffix(String suffix, boolean ignoreCase) {
+      checkNotNull(suffix, "suffix");
+      return StringMatcher.create(null, null, suffix, null, null,
+          ignoreCase);
+    }
+
+    /** The input string should match this pattern. */
+    public static StringMatcher forSafeRegEx(Pattern regEx) {
+      checkNotNull(regEx, "regEx");
+      return StringMatcher.create(null, null, null, regEx, null,
+          false/* doesn't matter */);
+    }
+
+    /** The input string should contain this substring. */
+    public static StringMatcher forContains(String contains) {
+      checkNotNull(contains, "contains");
+      return StringMatcher.create(null, null, null, null, contains,
+          false/* doesn't matter */);
+    }
+
+    /** Returns the matching result for this string. */
+    public boolean matches(String args) {
+      if (args == null) {
+        return false;
+      }
+      if (exact() != null) {
+        return ignoreCase()
+            ? exact().equalsIgnoreCase(args)
+            : exact().equals(args);
+      } else if (prefix() != null) {
+        return ignoreCase()
+            ? args.toLowerCase(Locale.ROOT).startsWith(prefix().toLowerCase(Locale.ROOT))
+            : args.startsWith(prefix());
+      } else if (suffix() != null) {
+        return ignoreCase()
+            ? args.toLowerCase(Locale.ROOT).endsWith(suffix().toLowerCase(Locale.ROOT))
+            : args.endsWith(suffix());
+      } else if (contains() != null) {
+        return args.contains(contains());
+      }
+      return regEx().matches(args);
+    }
+
+    private static StringMatcher create(@Nullable String exact, @Nullable String prefix,
+        @Nullable String suffix, @Nullable Pattern regEx, @Nullable String contains,
+        boolean ignoreCase) {
+      return new AutoValue_Matchers_StringMatcher(exact, prefix, suffix, regEx, contains,
+          ignoreCase);
+    }
+  }
+
+  /** Matcher to evaluate whether an IPv4 or IPv6 address is within a CIDR range. */
+  @AutoValue
+  public abstract static class CidrMatcher {
+
+    abstract InetAddress addressPrefix();
+
+    abstract int prefixLen();
+
+    /** Returns matching result for this address. */
+    public boolean matches(InetAddress address) {
+      if (address == null) {
+        return false;
+      }
+      byte[] cidr = addressPrefix().getAddress();
+      byte[] addr = address.getAddress();
+      if (addr.length != cidr.length) {
+        return false;
+      }
+      BigInteger cidrInt = new BigInteger(cidr);
+      BigInteger addrInt = new BigInteger(addr);
+
+      int shiftAmount = 8 * cidr.length - prefixLen();
+
+      cidrInt = cidrInt.shiftRight(shiftAmount);
+      addrInt = addrInt.shiftRight(shiftAmount);
+      return cidrInt.equals(addrInt);
+    }
+
+    /** Constructs a CidrMatcher with this prefix and prefix length.
+     * Do not provide string addressPrefix constructor to avoid IO exception handling.
+     * */
+    public static CidrMatcher create(InetAddress addressPrefix, int prefixLen) {
+      return new AutoValue_Matchers_CidrMatcher(addressPrefix, prefixLen);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/ProtobufJsonConverter.java b/xds/src/main/java/io/grpc/xds/internal/ProtobufJsonConverter.java
new file mode 100644
index 00000000000..964c28c57e0
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/ProtobufJsonConverter.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2024 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.xds.internal;
+
+import com.google.protobuf.Struct;
+import com.google.protobuf.Value;
+import io.grpc.Internal;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * Converter for Protobuf {@link Struct} to JSON-like {@link Map}.
+ */
+@Internal
+public final class ProtobufJsonConverter {
+  private ProtobufJsonConverter() {}
+
+  public static Map<String, Object> convertToJson(Struct struct) {
+    Map<String, Object> result = new HashMap<>();
+    for (Map.Entry<String, Value> entry : struct.getFieldsMap().entrySet()) {
+      result.put(entry.getKey(), convertValue(entry.getValue()));
+    }
+    return result;
+  }
+
+  private static Object convertValue(Value value) {
+    switch (value.getKindCase()) {
+      case STRUCT_VALUE:
+        return convertToJson(value.getStructValue());
+      case LIST_VALUE:
+        return value.getListValue().getValuesList().stream()
+            .map(ProtobufJsonConverter::convertValue)
+            .collect(Collectors.toList());
+      case NUMBER_VALUE:
+        return value.getNumberValue();
+      case STRING_VALUE:
+        return value.getStringValue();
+      case BOOL_VALUE:
+        return value.getBoolValue();
+      case NULL_VALUE:
+        return null;
+      default:
+        throw new IllegalArgumentException("Unknown Value type: " + value.getKindCase());
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/TlsXdsCredentialsProvider.java b/xds/src/main/java/io/grpc/xds/internal/TlsXdsCredentialsProvider.java
new file mode 100644
index 00000000000..f4d26a83795
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/TlsXdsCredentialsProvider.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2022 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.xds.internal;
+
+import io.grpc.ChannelCredentials;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.xds.XdsCredentialsProvider;
+import java.util.Map;
+
+/**
+ * A wrapper class that supports {@link TlsChannelCredentials} for Xds
+ * by implementing {@link XdsCredentialsProvider}.
+ */
+public final class TlsXdsCredentialsProvider extends XdsCredentialsProvider {
+  private static final String CREDS_NAME = "tls";
+
+  @Override
+  protected ChannelCredentials newChannelCredentials(Map<String, ?> jsonConfig) {
+    return TlsChannelCredentials.create();
+  }
+
+  @Override
+  protected String getName() {
+    return CREDS_NAME;
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int priority() {
+    return 5;
+  }
+
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/XdsInternalAttributes.java b/xds/src/main/java/io/grpc/xds/internal/XdsInternalAttributes.java
new file mode 100644
index 00000000000..b05230ea30b
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/XdsInternalAttributes.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2025 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.xds.internal;
+
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+
+public final class XdsInternalAttributes {
+  /** Name associated with individual address, if available (e.g., DNS name). */
+  @EquivalentAddressGroup.Attr
+  public static final Attributes.Key<String> ATTR_ADDRESS_NAME =
+      Attributes.Key.create("io.grpc.xds.XdsAttributes.addressName");
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/package-info.java b/xds/src/main/java/io/grpc/xds/internal/package-info.java
new file mode 100644
index 00000000000..fc220860595
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/package-info.java
@@ -0,0 +1,24 @@
+/*
+ * 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.
+ */
+
+/**
+ * Interfaces and implementations that are internal to gRPC.
+ *
+ * <p>All the content under this package and its subpackages are considered annotated with {@link
+ * io.grpc.Internal}.
+ */
+@io.grpc.Internal
+package io.grpc.xds.internal;
diff --git a/xds/src/main/java/io/grpc/xds/internal/rbac/engine/GrpcAuthorizationEngine.java b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/GrpcAuthorizationEngine.java
new file mode 100644
index 00000000000..3b55b757222
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/rbac/engine/GrpcAuthorizationEngine.java
@@ -0,0 +1,504 @@
+/*
+ * Copyright 2021 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.xds.internal.rbac.engine;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.auto.value.AutoValue;
+import com.google.common.base.Joiner;
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.BaseEncoding;
+import io.grpc.Grpc;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.xds.internal.Matchers;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateParsingException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+
+/**
+ * Implementation of gRPC server access control based on envoy RBAC protocol:
+ * https://www.envoyproxy.io/docs/envoy/latest/api-v3/config/rbac/v3/rbac.proto
+ *
+ * <p>One GrpcAuthorizationEngine is initialized with one action type and a list of policies.
+ * Policies are examined sequentially in order in an any match fashion, and the first matched policy
+ * will be returned. If not matched at all, the opposite action type is returned as a result.
+ */
+public final class GrpcAuthorizationEngine {
+  private static final Logger log = Logger.getLogger(GrpcAuthorizationEngine.class.getName());
+
+  private final AuthConfig authConfig;
+
+  /** Instantiated with envoy policyMatcher configuration. */
+  public GrpcAuthorizationEngine(AuthConfig authConfig) {
+    this.authConfig = authConfig;
+  }
+
+  /** Return the auth decision for the request argument against the policies. */
+  public AuthDecision evaluate(Metadata metadata, ServerCall<?,?> serverCall) {
+    checkNotNull(metadata, "metadata");
+    checkNotNull(serverCall, "serverCall");
+    String firstMatch = null;
+    EvaluateArgs args = new EvaluateArgs(metadata, serverCall);
+    for (PolicyMatcher policyMatcher : authConfig.policies()) {
+      if (policyMatcher.matches(args)) {
+        firstMatch = policyMatcher.name();
+        break;
+      }
+    }
+    Action decisionType = Action.DENY;
+    if (Action.DENY.equals(authConfig.action()) == (firstMatch == null)) {
+      decisionType = Action.ALLOW;
+    }
+    return AuthDecision.create(decisionType, firstMatch);
+  }
+
+  public enum Action {
+    ALLOW,
+    DENY,
+  }
+
+  /**
+   * An authorization decision provides information about the decision type and the policy name
+   * identifier based on the authorization engine evaluation. */
+  @AutoValue
+  public abstract static class AuthDecision {
+    public abstract Action decision();
+
+    @Nullable
+    public abstract String matchingPolicyName();
+
+    static AuthDecision create(Action decisionType, @Nullable String matchingPolicy) {
+      return new AutoValue_GrpcAuthorizationEngine_AuthDecision(decisionType, matchingPolicy);
+    }
+  }
+
+  /** Represents authorization config policy that the engine will evaluate against. */
+  @AutoValue
+  public abstract static class AuthConfig {
+    public abstract ImmutableList<PolicyMatcher> policies();
+
+    public abstract Action action();
+
+    public static AuthConfig create(List<PolicyMatcher> policies, Action action) {
+      return new AutoValue_GrpcAuthorizationEngine_AuthConfig(
+          ImmutableList.copyOf(policies), action);
+    }
+  }
+
+  /**
+   * Implements a top level {@link Matcher} for a single RBAC policy configuration per envoy
+   * protocol:
+   * https://www.envoyproxy.io/docs/envoy/latest/api-v3/config/rbac/v3/rbac.proto#config-rbac-v3-policy.
+   *
+   * <p>Currently we only support matching some of the request fields. Those unsupported fields are
+   * considered not match until we stop ignoring them.
+   */
+  @AutoValue
+  public abstract static class PolicyMatcher implements Matcher {
+    public abstract String name();
+
+    public abstract OrMatcher permissions();
+
+    public abstract OrMatcher principals();
+
+    /** Constructs a matcher for one RBAC policy. */
+    public static PolicyMatcher create(String name, OrMatcher permissions, OrMatcher principals) {
+      return new AutoValue_GrpcAuthorizationEngine_PolicyMatcher(name, permissions, principals);
+    }
+
+    @Override
+    public boolean matches(EvaluateArgs args) {
+      return permissions().matches(args) && principals().matches(args);
+    }
+  }
+
+  @AutoValue
+  public abstract static class AuthenticatedMatcher implements Matcher {
+    @Nullable
+    public abstract Matchers.StringMatcher delegate();
+
+    /**
+     * Passing in null will match all authenticated user, i.e. SSL session is present.
+     * https://github.com/envoyproxy/envoy/blob/3975bf5dadb43421907bbc52df57c0e8539c9a06/api/envoy/config/rbac/v3/rbac.proto#L253
+     * */
+    public static AuthenticatedMatcher create(@Nullable Matchers.StringMatcher delegate) {
+      return new AutoValue_GrpcAuthorizationEngine_AuthenticatedMatcher(delegate);
+    }
+
+    @Override
+    public boolean matches(EvaluateArgs args) {
+      Collection<String> principalNames = args.getPrincipalNames();
+      log.log(Level.FINER, "Matching principal names: {0}", new Object[]{principalNames});
+      // Null means unauthenticated connection.
+      if (principalNames == null) {
+        return false;
+      }
+      // Connection is authenticated, so returns match when delegated string matcher is not present.
+      if (delegate() == null) {
+        return true;
+      }
+      for (String name : principalNames) {
+        if (delegate().matches(name)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+
+  @AutoValue
+  public abstract static class DestinationIpMatcher implements Matcher {
+    public abstract Matchers.CidrMatcher delegate();
+
+    public static DestinationIpMatcher create(Matchers.CidrMatcher delegate) {
+      return new AutoValue_GrpcAuthorizationEngine_DestinationIpMatcher(delegate);
+    }
+
+    @Override
+    public boolean matches(EvaluateArgs args) {
+      return delegate().matches(args.getDestinationIp());
+    }
+  }
+
+  @AutoValue
+  public abstract static class SourceIpMatcher implements Matcher {
+    public abstract Matchers.CidrMatcher delegate();
+
+    public static SourceIpMatcher create(Matchers.CidrMatcher delegate) {
+      return new AutoValue_GrpcAuthorizationEngine_SourceIpMatcher(delegate);
+    }
+
+    @Override
+    public boolean matches(EvaluateArgs args) {
+      return delegate().matches(args.getSourceIp());
+    }
+  }
+
+  @AutoValue
+  public abstract static class PathMatcher implements Matcher {
+    public abstract Matchers.StringMatcher delegate();
+
+    public static PathMatcher create(Matchers.StringMatcher delegate) {
+      return new AutoValue_GrpcAuthorizationEngine_PathMatcher(delegate);
+    }
+
+    @Override
+    public boolean matches(EvaluateArgs args) {
+      return delegate().matches(args.getPath());
+    }
+  }
+
+  @AutoValue
+  public abstract static class AuthHeaderMatcher implements Matcher {
+    public abstract Matchers.HeaderMatcher delegate();
+
+    public static AuthHeaderMatcher create(Matchers.HeaderMatcher delegate) {
+      return new AutoValue_GrpcAuthorizationEngine_AuthHeaderMatcher(delegate);
+    }
+
+    @Override
+    public boolean matches(EvaluateArgs args) {
+      return delegate().matches(args.getHeader(delegate().name()));
+    }
+  }
+
+  @AutoValue
+  public abstract static class DestinationPortMatcher implements Matcher {
+    public abstract int port();
+
+    public static DestinationPortMatcher create(int port) {
+      return new AutoValue_GrpcAuthorizationEngine_DestinationPortMatcher(port);
+    }
+
+    @Override
+    public boolean matches(EvaluateArgs args) {
+      return port() == args.getDestinationPort();
+    }
+  }
+
+  @AutoValue
+  public abstract static class DestinationPortRangeMatcher implements Matcher {
+    public abstract int start();
+
+    public abstract int end();
+
+    /** Start of the range is inclusive. End of the range is exclusive.*/
+    public static DestinationPortRangeMatcher create(int start, int end) {
+      return new AutoValue_GrpcAuthorizationEngine_DestinationPortRangeMatcher(start, end);
+    }
+
+    @Override
+    public boolean matches(EvaluateArgs args) {
+      int port = args.getDestinationPort();
+      return  port >= start() && port < end();
+    }
+  }
+
+  @AutoValue
+  public abstract static class RequestedServerNameMatcher implements Matcher {
+    public abstract Matchers.StringMatcher delegate();
+
+    public static RequestedServerNameMatcher create(Matchers.StringMatcher delegate) {
+      return new AutoValue_GrpcAuthorizationEngine_RequestedServerNameMatcher(delegate);
+    }
+
+    @Override
+    public boolean matches(EvaluateArgs args) {
+      return delegate().matches(args.getRequestedServerName());
+    }
+  }
+
+  private static final class EvaluateArgs {
+    private final Metadata metadata;
+    private final ServerCall<?,?> serverCall;
+    // https://github.com/envoyproxy/envoy/blob/63619d578e1abe0c1725ea28ba02f361466662e1/api/envoy/config/rbac/v3/rbac.proto#L238-L240
+    private static final int URI_SAN = 6;
+    private static final int DNS_SAN = 2;
+
+    private EvaluateArgs(Metadata metadata, ServerCall<?,?> serverCall) {
+      this.metadata = metadata;
+      this.serverCall = serverCall;
+    }
+
+    private String getPath() {
+      return "/" + serverCall.getMethodDescriptor().getFullMethodName();
+    }
+
+    /**
+     * Returns null for unauthenticated connection.
+     * Returns empty string collection if no valid certificate and no
+     * principal names we are interested in.
+     * https://github.com/envoyproxy/envoy/blob/0fae6970ddaf93f024908ba304bbd2b34e997a51/envoy/ssl/connection.h#L70
+     */
+    @Nullable
+    private Collection<String> getPrincipalNames() {
+      SSLSession sslSession = serverCall.getAttributes().get(Grpc.TRANSPORT_ATTR_SSL_SESSION);
+      if (sslSession == null) {
+        return null;
+      }
+      try {
+        Certificate[] certs = sslSession.getPeerCertificates();
+        if (certs == null || certs.length < 1) {
+          return Collections.singleton("");
+        }
+        X509Certificate cert = (X509Certificate)certs[0];
+        if (cert == null) {
+          return Collections.singleton("");
+        }
+        Collection<List<?>> names = cert.getSubjectAlternativeNames();
+        List<String> principalNames = new ArrayList<>();
+        if (names != null) {
+          for (List<?> name : names) {
+            if (URI_SAN == (Integer) name.get(0)) {
+              principalNames.add((String) name.get(1));
+            }
+          }
+          if (!principalNames.isEmpty()) {
+            return Collections.unmodifiableCollection(principalNames);
+          }
+          for (List<?> name : names) {
+            if (DNS_SAN == (Integer) name.get(0)) {
+              principalNames.add((String) name.get(1));
+            }
+          }
+          if (!principalNames.isEmpty()) {
+            return Collections.unmodifiableCollection(principalNames);
+          }
+        }
+        if (cert.getSubjectX500Principal() == null
+            || cert.getSubjectX500Principal().getName() == null) {
+          return Collections.singleton("");
+        }
+        return Collections.singleton(cert.getSubjectX500Principal().getName());
+      } catch (SSLPeerUnverifiedException | CertificateParsingException ex) {
+        log.log(Level.FINE, "Unexpected getPrincipalNames error.", ex);
+        return Collections.singleton("");
+      }
+    }
+
+    @Nullable
+    private String getHeader(String headerName) {
+      headerName = headerName.toLowerCase(Locale.ROOT);
+      if ("te".equals(headerName)) {
+        return null;
+      }
+      if (":authority".equals(headerName)) {
+        headerName = "host";
+      }
+      if ("host".equals(headerName)) {
+        return serverCall.getAuthority();
+      }
+      if (":path".equals(headerName)) {
+        return getPath();
+      }
+      if (":method".equals(headerName)) {
+        return "POST";
+      }
+      return deserializeHeader(headerName);
+    }
+
+    @Nullable
+    private String deserializeHeader(String headerName) {
+      if (headerName.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
+        Metadata.Key<byte[]> key;
+        try {
+          key = Metadata.Key.of(headerName, Metadata.BINARY_BYTE_MARSHALLER);
+        } catch (IllegalArgumentException e) {
+          return null;
+        }
+        Iterable<byte[]> values = metadata.getAll(key);
+        if (values == null) {
+          return null;
+        }
+        List<String> encoded = new ArrayList<>();
+        for (byte[] v : values) {
+          encoded.add(BaseEncoding.base64().omitPadding().encode(v));
+        }
+        return Joiner.on(",").join(encoded);
+      }
+      Metadata.Key<String> key;
+      try {
+        key = Metadata.Key.of(headerName, Metadata.ASCII_STRING_MARSHALLER);
+      } catch (IllegalArgumentException e) {
+        return null;
+      }
+      Iterable<String> values = metadata.getAll(key);
+      return values == null ? null : Joiner.on(",").join(values);
+    }
+
+    private InetAddress getDestinationIp() {
+      SocketAddress addr = serverCall.getAttributes().get(Grpc.TRANSPORT_ATTR_LOCAL_ADDR);
+      return addr == null ? null : ((InetSocketAddress) addr).getAddress();
+    }
+
+    private InetAddress getSourceIp() {
+      SocketAddress addr = serverCall.getAttributes().get(Grpc.TRANSPORT_ATTR_REMOTE_ADDR);
+      return addr == null ? null : ((InetSocketAddress) addr).getAddress();
+    }
+
+    private int getDestinationPort() {
+      SocketAddress addr = serverCall.getAttributes().get(Grpc.TRANSPORT_ATTR_LOCAL_ADDR);
+      return addr == null ? -1 : ((InetSocketAddress) addr).getPort();
+    }
+
+    private String getRequestedServerName() {
+      return "";
+    }
+  }
+
+  public interface Matcher {
+    boolean matches(EvaluateArgs args);
+  }
+
+  @AutoValue
+  public abstract static class OrMatcher implements Matcher {
+    public abstract ImmutableList<? extends Matcher> anyMatch();
+
+    /** Matches when any of the matcher matches. */
+    public static OrMatcher create(List<? extends Matcher> matchers) {
+      checkNotNull(matchers, "matchers");
+      for (Matcher matcher : matchers) {
+        checkNotNull(matcher, "matcher");
+      }
+      return new AutoValue_GrpcAuthorizationEngine_OrMatcher(ImmutableList.copyOf(matchers));
+    }
+
+    public static OrMatcher create(Matcher...matchers) {
+      return OrMatcher.create(Arrays.asList(matchers));
+    }
+
+    @Override
+    public boolean matches(EvaluateArgs args) {
+      for (Matcher m : anyMatch()) {
+        if (m.matches(args)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+
+  @AutoValue
+  public abstract static class AndMatcher implements Matcher {
+    public abstract ImmutableList<? extends Matcher> allMatch();
+
+    /** Matches when all of the matchers match. */
+    public static AndMatcher create(List<? extends Matcher> matchers) {
+      checkNotNull(matchers, "matchers");
+      for (Matcher matcher : matchers) {
+        checkNotNull(matcher, "matcher");
+      }
+      return new AutoValue_GrpcAuthorizationEngine_AndMatcher(ImmutableList.copyOf(matchers));
+    }
+
+    public static AndMatcher create(Matcher...matchers) {
+      return AndMatcher.create(Arrays.asList(matchers));
+    }
+
+    @Override
+    public boolean matches(EvaluateArgs args) {
+      for (Matcher m : allMatch()) {
+        if (!m.matches(args)) {
+          return false;
+        }
+      }
+      return true;
+    }
+  }
+
+  /** Always true matcher.*/
+  @AutoValue
+  public abstract static class AlwaysTrueMatcher implements Matcher {
+    public static AlwaysTrueMatcher INSTANCE =
+        new AutoValue_GrpcAuthorizationEngine_AlwaysTrueMatcher();
+
+    @Override
+    public boolean matches(EvaluateArgs args) {
+      return true;
+    }
+  }
+
+  /** Negate matcher.*/
+  @AutoValue
+  public abstract static class InvertMatcher implements Matcher {
+    public abstract Matcher toInvertMatcher();
+
+    public static InvertMatcher create(Matcher matcher) {
+      return new AutoValue_GrpcAuthorizationEngine_InvertMatcher(matcher);
+    }
+
+    @Override
+    public boolean matches(EvaluateArgs args) {
+      return !toInvertMatcher().matches(args);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/ClientSslContextProviderFactory.java b/xds/src/main/java/io/grpc/xds/internal/security/ClientSslContextProviderFactory.java
new file mode 100644
index 00000000000..37d289c1c47
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/ClientSslContextProviderFactory.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2019 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.xds.internal.security;
+
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.internal.security.ReferenceCountingMap.ValueFactory;
+import io.grpc.xds.internal.security.certprovider.CertProviderClientSslContextProviderFactory;
+
+/** Factory to create client-side SslContextProvider from UpstreamTlsContext. */
+final class ClientSslContextProviderFactory
+    implements ValueFactory<UpstreamTlsContext, SslContextProvider> {
+
+  private BootstrapInfo bootstrapInfo;
+  private final CertProviderClientSslContextProviderFactory
+      certProviderClientSslContextProviderFactory;
+
+  ClientSslContextProviderFactory(BootstrapInfo bootstrapInfo) {
+    this(bootstrapInfo, CertProviderClientSslContextProviderFactory.getInstance());
+  }
+
+  ClientSslContextProviderFactory(
+      BootstrapInfo bootstrapInfo, CertProviderClientSslContextProviderFactory factory) {
+    this.bootstrapInfo = bootstrapInfo;
+    this.certProviderClientSslContextProviderFactory = factory;
+  }
+
+  /** Creates an SslContextProvider from the given UpstreamTlsContext. */
+  @Override
+  public SslContextProvider create(UpstreamTlsContext upstreamTlsContext) {
+    return certProviderClientSslContextProviderFactory.getProvider(
+        upstreamTlsContext,
+        bootstrapInfo.node().toEnvoyProtoNode(),
+        bootstrapInfo.certProviders());
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/Closeable.java b/xds/src/main/java/io/grpc/xds/internal/security/Closeable.java
new file mode 100644
index 00000000000..c78714abfbf
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/Closeable.java
@@ -0,0 +1,23 @@
+/*
+ * 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.xds.internal.security;
+
+public interface Closeable extends java.io.Closeable {
+
+  @Override
+  void close();
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/CommonTlsContextUtil.java b/xds/src/main/java/io/grpc/xds/internal/security/CommonTlsContextUtil.java
new file mode 100644
index 00000000000..bd8a423e683
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/CommonTlsContextUtil.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2019 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.xds.internal.security;
+
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateProviderPluginInstance;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+
+/** Class for utility functions for {@link CommonTlsContext}. */
+public final class CommonTlsContextUtil {
+
+  private CommonTlsContextUtil() {}
+
+  public static boolean hasCertProviderInstance(CommonTlsContext commonTlsContext) {
+    if (commonTlsContext == null) {
+      return false;
+    }
+    @SuppressWarnings("deprecation")
+    boolean hasDeprecatedField = commonTlsContext.hasTlsCertificateCertificateProviderInstance();
+    return commonTlsContext.hasTlsCertificateProviderInstance()
+        || hasDeprecatedField
+        || hasValidationProviderInstance(commonTlsContext);
+  }
+
+  private static boolean hasValidationProviderInstance(CommonTlsContext commonTlsContext) {
+    if (commonTlsContext.hasValidationContext() && commonTlsContext.getValidationContext()
+        .hasCaCertificateProviderInstance()) {
+      return true;
+    }
+    if (commonTlsContext.hasCombinedValidationContext()) {
+      CommonTlsContext.CombinedCertificateValidationContext combined =
+          commonTlsContext.getCombinedValidationContext();
+      if (combined.hasDefaultValidationContext()
+          && combined.getDefaultValidationContext().hasCaCertificateProviderInstance()) {
+        return true;
+      }
+      // Check deprecated field (field 4) in CombinedValidationContext
+      @SuppressWarnings("deprecation")
+      boolean hasDeprecatedField = combined.hasValidationContextCertificateProviderInstance();
+      return hasDeprecatedField;
+    }
+    return false;
+  }
+
+  /**
+   * Converts {@link CertificateProviderPluginInstance} to
+   * {@link CommonTlsContext.CertificateProviderInstance}.
+   */
+  public static CommonTlsContext.CertificateProviderInstance convert(
+      CertificateProviderPluginInstance pluginInstance) {
+    return CommonTlsContext.CertificateProviderInstance.newBuilder()
+        .setInstanceName(pluginInstance.getInstanceName())
+        .setCertificateName(pluginInstance.getCertificateName()).build();
+  }
+
+  public static boolean isUsingSystemRootCerts(CommonTlsContext commonTlsContext) {
+    if (commonTlsContext.hasCombinedValidationContext()) {
+      return commonTlsContext.getCombinedValidationContext().getDefaultValidationContext()
+          .hasSystemRootCerts();
+    }
+    if (commonTlsContext.hasValidationContext()) {
+      return commonTlsContext.getValidationContext().hasSystemRootCerts();
+    }
+    return false;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/DynamicSslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/DynamicSslContextProvider.java
new file mode 100644
index 00000000000..59e114a89ff
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/DynamicSslContextProvider.java
@@ -0,0 +1,161 @@
+/*
+ * 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.xds.internal.security;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.collect.ImmutableList;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.grpc.Internal;
+import io.grpc.Status;
+import io.grpc.xds.EnvoyServerProtoData.BaseTlsContext;
+import io.netty.handler.ssl.ApplicationProtocolConfig;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslContextBuilder;
+import java.io.IOException;
+import java.security.cert.CertStoreException;
+import java.security.cert.CertificateException;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.List;
+import javax.annotation.Nullable;
+import javax.net.ssl.X509TrustManager;
+
+/** Base class for dynamic {@link SslContextProvider}s. */
+@Internal
+public abstract class DynamicSslContextProvider extends SslContextProvider {
+
+  protected final List<Callback> pendingCallbacks = new ArrayList<>();
+  @Nullable protected final CertificateValidationContext staticCertificateValidationContext;
+  @Nullable protected AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager>
+      sslContextAndTrustManager;
+  protected boolean autoSniSanValidationDoesNotApply;
+
+  protected DynamicSslContextProvider(
+      BaseTlsContext tlsContext, CertificateValidationContext staticCertValidationContext) {
+    super(tlsContext);
+    this.staticCertificateValidationContext = staticCertValidationContext;
+  }
+
+  @Nullable
+  public AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager>
+      getSslContextAndTrustManager() {
+    return sslContextAndTrustManager;
+  }
+
+  protected abstract CertificateValidationContext generateCertificateValidationContext();
+
+  public void setAutoSniSanValidationDoesNotApply() {
+    autoSniSanValidationDoesNotApply = true;
+  }
+
+  /** Gets a server or client side SslContextBuilder. */
+  protected abstract AbstractMap.SimpleImmutableEntry<SslContextBuilder, X509TrustManager>
+      getSslContextBuilderAndTrustManager(
+          CertificateValidationContext certificateValidationContext)
+      throws CertificateException, IOException, CertStoreException;
+
+  // this gets called only when requested secrets are ready...
+  protected final void updateSslContext() {
+    try {
+      CertificateValidationContext localCertValidationContext =
+          generateCertificateValidationContext();
+      AbstractMap.SimpleImmutableEntry<SslContextBuilder, X509TrustManager> sslContextBuilderAndTm =
+          getSslContextBuilderAndTrustManager(localCertValidationContext);
+      CommonTlsContext commonTlsContext = getCommonTlsContext();
+      if (commonTlsContext != null && commonTlsContext.getAlpnProtocolsCount() > 0) {
+        List<String> alpnList = commonTlsContext.getAlpnProtocolsList();
+        ApplicationProtocolConfig apn =
+            new ApplicationProtocolConfig(
+                ApplicationProtocolConfig.Protocol.ALPN,
+                ApplicationProtocolConfig.SelectorFailureBehavior.NO_ADVERTISE,
+                ApplicationProtocolConfig.SelectedListenerFailureBehavior.ACCEPT,
+                alpnList);
+        sslContextBuilderAndTm.getKey().applicationProtocolConfig(apn);
+      }
+      List<Callback> pendingCallbacksCopy;
+      AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager>
+          sslContextAndExtendedX09TrustManagerCopy;
+      synchronized (pendingCallbacks) {
+        sslContextAndTrustManager = new AbstractMap.SimpleImmutableEntry<>(
+            sslContextBuilderAndTm.getKey().build(), sslContextBuilderAndTm.getValue());
+        sslContextAndExtendedX09TrustManagerCopy = sslContextAndTrustManager;
+        pendingCallbacksCopy = clonePendingCallbacksAndClear();
+      }
+      makePendingCallbacks(sslContextAndExtendedX09TrustManagerCopy, pendingCallbacksCopy);
+    } catch (Exception e) {
+      onError(Status.fromThrowable(e));
+      throw new RuntimeException(e);
+    }
+  }
+
+  protected final void callPerformCallback(
+          Callback callback,
+          final AbstractMap.SimpleImmutableEntry<SslContext,X509TrustManager> sslContextAndTmCopy) {
+    performCallback(
+        new SslContextGetter() {
+          @Override
+          public AbstractMap.SimpleImmutableEntry<SslContext,X509TrustManager> get() {
+            return sslContextAndTmCopy;
+          }
+        },
+        callback
+    );
+  }
+
+  @Override
+  public final void addCallback(Callback callback) {
+    checkNotNull(callback, "callback");
+    // if there is a computed sslContext just send it
+    AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> sslContextCopy = null;
+    synchronized (pendingCallbacks) {
+      if (sslContextAndTrustManager != null) {
+        sslContextCopy = sslContextAndTrustManager;
+      } else {
+        pendingCallbacks.add(callback);
+      }
+    }
+    if (sslContextCopy != null) {
+      callPerformCallback(callback, sslContextCopy);
+    }
+  }
+
+  private final void makePendingCallbacks(
+      AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager>
+          sslContextAndExtendedX509TrustManagerCopy,
+      List<Callback> pendingCallbacksCopy) {
+    for (Callback callback : pendingCallbacksCopy) {
+      callPerformCallback(callback, sslContextAndExtendedX509TrustManagerCopy);
+    }
+  }
+
+  /** Propagates error to all the callback receivers. */
+  public final void onError(Status error) {
+    for (Callback callback : clonePendingCallbacksAndClear()) {
+      callback.onException(error.asException());
+    }
+  }
+
+  private List<Callback> clonePendingCallbacksAndClear() {
+    synchronized (pendingCallbacks) {
+      List<Callback> copy = ImmutableList.copyOf(pendingCallbacks);
+      pendingCallbacks.clear();
+      return copy;
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/ReferenceCountingMap.java b/xds/src/main/java/io/grpc/xds/internal/security/ReferenceCountingMap.java
new file mode 100644
index 00000000000..08b8f6a325b
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/ReferenceCountingMap.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2019 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.xds.internal.security;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.errorprone.annotations.CheckReturnValue;
+import java.util.HashMap;
+import java.util.Map;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * A map for managing reference-counted shared resources - typically providers.
+ *
+ * <p>A key (of generic type K) identifies a provider (of generic type V). The map also depends on a
+ * factory {@link ValueFactory} to create a new instance of V as needed. Values are ref-counted and
+ * closed by calling {@link Closeable#close()} when ref-count reaches zero.
+ *
+ * @param <K> Key type for the map
+ * @param <V> Value type for the map - it should be a {@link Closeable}
+ */
+@ThreadSafe
+public final class ReferenceCountingMap<K, V extends Closeable> {
+
+  private final Map<K, Instance<V>> instances = new HashMap<>();
+  private final ValueFactory<K, V> valueFactory;
+
+  public ReferenceCountingMap(ValueFactory<K, V> valueFactory) {
+    checkNotNull(valueFactory, "valueFactory");
+    this.valueFactory = valueFactory;
+  }
+
+  /**
+   * Gets an existing instance of a provider. If it doesn't exist, creates a new one
+   * using the provided {@link ValueFactory &lt;K, V&gt;}
+   */
+  @CheckReturnValue
+  public V get(K key) {
+    checkNotNull(key, "key");
+    return getInternal(key);
+  }
+
+  /**
+   * Releases an instance of the given value.
+   *
+   * <p>The instance must have been obtained from {@link #get(Object)}. Otherwise will throw
+   * IllegalArgumentException.
+   *
+   * <p>Caller must not release a reference more than once. It's advised that you clear the
+   * reference to the instance with the null returned by this method.
+   *
+   * @param key for the instance to be released
+   * @param value the instance to be released
+   * @return a null which the caller can use to clear the reference to that instance.
+   */
+  public V release(K key, V value) {
+    checkNotNull(key, "key");
+    checkNotNull(value, "value");
+    return releaseInternal(key, value);
+  }
+
+  private synchronized V getInternal(K key) {
+    Instance<V> instance = instances.get(key);
+    if (instance == null) {
+      instance = new Instance<>(valueFactory.create(key));
+      instances.put(key, instance);
+      return instance.value;
+    } else {
+      return instance.acquire();
+    }
+  }
+
+  private synchronized V releaseInternal(K key, V value) {
+    Instance<V> cached = instances.get(key);
+    checkArgument(cached != null, "No cached instance found for %s", key);
+    checkArgument(value == cached.value, "Releasing the wrong instance");
+    if (cached.release()) {
+      try {
+        cached.value.close();
+      } finally {
+        instances.remove(key);
+      }
+    }
+    // Always return null
+    return null;
+  }
+
+  /** A factory to create a value from the given key. */
+  public interface ValueFactory<K, V extends Closeable> {
+    V create(K key);
+  }
+
+  private static final class Instance<V extends Closeable> {
+    final V value;
+    private int refCount;
+
+    /** Increment refCount and acquire a reference to value. */
+    V acquire() {
+      refCount++;
+      return value;
+    }
+
+    /** Decrement refCount and return true if it has reached 0. */
+    boolean release() {
+      checkState(refCount > 0, "refCount has to be > 0");
+      return --refCount == 0;
+    }
+
+    Instance(V value) {
+      this.value = value;
+      this.refCount = 1;
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/SecurityProtocolNegotiators.java b/xds/src/main/java/io/grpc/xds/internal/security/SecurityProtocolNegotiators.java
new file mode 100644
index 00000000000..37259afa1a9
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/SecurityProtocolNegotiators.java
@@ -0,0 +1,418 @@
+/*
+ * Copyright 2019 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.xds.internal.security;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Strings;
+import io.grpc.Attributes;
+import io.grpc.Grpc;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.ObjectPool;
+import io.grpc.netty.GrpcHttp2ConnectionHandler;
+import io.grpc.netty.InternalProtocolNegotiationEvent;
+import io.grpc.netty.InternalProtocolNegotiator;
+import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
+import io.grpc.netty.InternalProtocolNegotiators;
+import io.grpc.netty.ProtocolNegotiationEvent;
+import io.grpc.xds.EnvoyServerProtoData;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.internal.XdsInternalAttributes;
+import io.grpc.xds.internal.security.trust.CertificateUtils;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerAdapter;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.handler.ssl.SslContext;
+import io.netty.util.AsciiString;
+import java.security.cert.CertStoreException;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+import javax.net.ssl.X509TrustManager;
+
+/**
+ * Provides client and server side gRPC {@link ProtocolNegotiator}s to provide the SSL
+ * context.
+ */
+@VisibleForTesting
+public final class SecurityProtocolNegotiators {
+
+  // Prevent instantiation.
+  private SecurityProtocolNegotiators() {
+  }
+
+  private static final Logger logger
+      = Logger.getLogger(SecurityProtocolNegotiators.class.getName());
+
+  private static final AsciiString SCHEME = AsciiString.of("http");
+
+  public static final Attributes.Key<SslContextProviderSupplier>
+      ATTR_SERVER_SSL_CONTEXT_PROVIDER_SUPPLIER =
+      Attributes.Key.create("io.grpc.xds.internal.security.server.sslContextProviderSupplier");
+
+  /** Attribute key for SslContextProviderSupplier (used from client) for a subchannel. */
+  @Grpc.TransportAttr
+  public static final Attributes.Key<SslContextProviderSupplier>
+      ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER =
+      Attributes.Key.create("io.grpc.xds.internal.security.SslContextProviderSupplier");
+
+  /**
+   * Returns a {@link InternalProtocolNegotiator.ClientFactory}.
+   *
+   * @param fallbackNegotiator protocol negotiator to use as fallback.
+   */
+  public static InternalProtocolNegotiator.ClientFactory clientProtocolNegotiatorFactory(
+      @Nullable InternalProtocolNegotiator.ClientFactory fallbackNegotiator) {
+    return new ClientFactory(fallbackNegotiator);
+  }
+
+  public static InternalProtocolNegotiator.ServerFactory serverProtocolNegotiatorFactory(
+      @Nullable InternalProtocolNegotiator.ServerFactory fallbackNegotiator) {
+    return new ServerFactory(fallbackNegotiator);
+  }
+
+  private static final class ServerFactory implements InternalProtocolNegotiator.ServerFactory {
+
+    private final InternalProtocolNegotiator.ServerFactory fallbackProtocolNegotiator;
+
+    private ServerFactory(InternalProtocolNegotiator.ServerFactory fallbackNegotiator) {
+      this.fallbackProtocolNegotiator = fallbackNegotiator;
+    }
+
+    @Override
+    public ProtocolNegotiator newNegotiator(ObjectPool<? extends Executor> offloadExecutorPool) {
+      return new ServerSecurityProtocolNegotiator(
+          fallbackProtocolNegotiator.newNegotiator(offloadExecutorPool));
+    }
+  }
+
+  private static final class ClientFactory implements InternalProtocolNegotiator.ClientFactory {
+
+    private final InternalProtocolNegotiator.ClientFactory fallbackProtocolNegotiator;
+
+    private ClientFactory(InternalProtocolNegotiator.ClientFactory fallbackNegotiator) {
+      this.fallbackProtocolNegotiator = fallbackNegotiator;
+    }
+
+    @Override
+    public ProtocolNegotiator newNegotiator() {
+      return new ClientSecurityProtocolNegotiator(fallbackProtocolNegotiator.newNegotiator());
+    }
+
+    @Override
+    public int getDefaultPort() {
+      return GrpcUtil.DEFAULT_PORT_SSL;
+    }
+  }
+
+  @VisibleForTesting
+  static final class ClientSecurityProtocolNegotiator implements ProtocolNegotiator {
+
+    @Nullable private final ProtocolNegotiator fallbackProtocolNegotiator;
+
+    ClientSecurityProtocolNegotiator(@Nullable ProtocolNegotiator fallbackProtocolNegotiator) {
+      this.fallbackProtocolNegotiator = fallbackProtocolNegotiator;
+    }
+
+    @Override
+    public AsciiString scheme() {
+      return SCHEME;
+    }
+
+    @Override
+    public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+      // check if SslContextProviderSupplier was passed via attributes
+      SslContextProviderSupplier localSslContextProviderSupplier =
+          grpcHandler.getEagAttributes().get(ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER);
+      if (localSslContextProviderSupplier == null) {
+        checkNotNull(
+            fallbackProtocolNegotiator, "No TLS config and no fallbackProtocolNegotiator!");
+        return fallbackProtocolNegotiator.newHandler(grpcHandler);
+      }
+      return new ClientSecurityHandler(grpcHandler, localSslContextProviderSupplier,
+          grpcHandler.getEagAttributes().get(XdsInternalAttributes.ATTR_ADDRESS_NAME));
+    }
+
+    @Override
+    public void close() {}
+  }
+
+  private static class BufferReadsHandler extends ChannelInboundHandlerAdapter {
+    private final List<Object> reads = new ArrayList<>();
+    private boolean readComplete;
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) {
+      reads.add(msg);
+    }
+
+    @Override
+    public void channelReadComplete(ChannelHandlerContext ctx) {
+      readComplete = true;
+    }
+
+    @Override
+    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
+      for (Object msg : reads) {
+        super.channelRead(ctx, msg);
+      }
+      if (readComplete) {
+        super.channelReadComplete(ctx);
+      }
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+      logger.log(Level.SEVERE, "exceptionCaught", cause);
+      ctx.fireExceptionCaught(cause);
+    }
+  }
+
+  @VisibleForTesting
+  static final class ClientSecurityHandler
+      extends InternalProtocolNegotiators.ProtocolNegotiationHandler {
+    private final GrpcHttp2ConnectionHandler grpcHandler;
+    private final SslContextProviderSupplier sslContextProviderSupplier;
+    private final String sni;
+    private final boolean autoSniSanValidationDoesNotApply;
+
+    ClientSecurityHandler(
+        GrpcHttp2ConnectionHandler grpcHandler,
+        SslContextProviderSupplier sslContextProviderSupplier,
+        String endpointHostname) {
+      super(
+          // superclass (InternalProtocolNegotiators.ProtocolNegotiationHandler) expects 'next'
+          // handler but we don't have a next handler _yet_. So we "disable" superclass's behavior
+          // here and then manually add 'next' when we call fireProtocolNegotiationEvent()
+          new ChannelHandlerAdapter() {
+            @Override
+            public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+              ctx.pipeline().remove(this);
+            }
+          }, grpcHandler.getNegotiationLogger());
+      checkNotNull(grpcHandler, "grpcHandler");
+      this.grpcHandler = grpcHandler;
+      this.sslContextProviderSupplier = sslContextProviderSupplier;
+      EnvoyServerProtoData.BaseTlsContext tlsContext = sslContextProviderSupplier.getTlsContext();
+      UpstreamTlsContext upstreamTlsContext = ((UpstreamTlsContext) tlsContext);
+      if (CertificateUtils.isXdsSniEnabled) {
+        String sniToUse = upstreamTlsContext.getAutoHostSni()
+            && !Strings.isNullOrEmpty(endpointHostname)
+            ? endpointHostname : upstreamTlsContext.getSni();
+        if (sniToUse.isEmpty()) {
+          if (CertificateUtils.useChannelAuthorityIfNoSniApplicable) {
+            sniToUse = grpcHandler.getAuthority();
+          }
+          autoSniSanValidationDoesNotApply = true;
+        } else {
+          autoSniSanValidationDoesNotApply = false;
+        }
+        sni = sniToUse;
+      } else {
+        sni = grpcHandler.getAuthority();
+        autoSniSanValidationDoesNotApply = false;
+      }
+    }
+
+    @VisibleForTesting
+    String getSni() {
+      return sni;
+    }
+
+    @Override
+    protected void handlerAdded0(final ChannelHandlerContext ctx) {
+      final BufferReadsHandler bufferReads = new BufferReadsHandler();
+      ctx.pipeline().addBefore(ctx.name(), null, bufferReads);
+
+      sslContextProviderSupplier.updateSslContext(
+          new SslContextProvider.Callback(ctx.executor()) {
+
+            @Override
+            public void updateSslContextAndExtendedX509TrustManager(
+                AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> sslContextAndTm) {
+              if (ctx.isRemoved()) {
+                return;
+              }
+              logger.log(
+                  Level.FINEST,
+                  "ClientSecurityHandler.updateSslContext authority={0}, ctx.name={1}",
+                  new Object[]{grpcHandler.getAuthority(), ctx.name()});
+              ChannelHandler handler =
+                  InternalProtocolNegotiators.tls(
+                      sslContextAndTm.getKey(), sni, sslContextAndTm.getValue())
+                      .newHandler(grpcHandler);
+
+              // Delegate rest of handshake to TLS handler
+              ctx.pipeline().addAfter(ctx.name(), null, handler);
+              fireProtocolNegotiationEvent(ctx);
+              ctx.pipeline().remove(bufferReads);
+            }
+
+            @Override
+            public void onException(Throwable throwable) {
+              ctx.fireExceptionCaught(throwable);
+            }
+          },
+          autoSniSanValidationDoesNotApply);
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
+        throws Exception {
+      logger.log(Level.SEVERE, "exceptionCaught", cause);
+      ctx.fireExceptionCaught(cause);
+    }
+  }
+
+  private static final class ServerSecurityProtocolNegotiator implements ProtocolNegotiator {
+
+    @Nullable private final ProtocolNegotiator fallbackProtocolNegotiator;
+
+    /** Constructor. */
+    @VisibleForTesting
+    public ServerSecurityProtocolNegotiator(
+        @Nullable ProtocolNegotiator fallbackProtocolNegotiator) {
+      this.fallbackProtocolNegotiator = fallbackProtocolNegotiator;
+    }
+
+    @Override
+    public AsciiString scheme() {
+      return SCHEME;
+    }
+
+    @Override
+    public ChannelHandler newHandler(GrpcHttp2ConnectionHandler grpcHandler) {
+      return new HandlerPickerHandler(grpcHandler, fallbackProtocolNegotiator);
+    }
+
+    @Override
+    public void close() {}
+  }
+
+  @VisibleForTesting
+  static final class HandlerPickerHandler
+      extends ChannelInboundHandlerAdapter {
+    private final GrpcHttp2ConnectionHandler grpcHandler;
+    @Nullable private final ProtocolNegotiator fallbackProtocolNegotiator;
+
+    HandlerPickerHandler(
+        GrpcHttp2ConnectionHandler grpcHandler,
+        @Nullable ProtocolNegotiator fallbackProtocolNegotiator) {
+      this.grpcHandler = checkNotNull(grpcHandler, "grpcHandler");
+      this.fallbackProtocolNegotiator = fallbackProtocolNegotiator;
+    }
+
+    @Override
+    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+      if (evt instanceof ProtocolNegotiationEvent) {
+        ProtocolNegotiationEvent pne = (ProtocolNegotiationEvent)evt;
+        SslContextProviderSupplier sslContextProviderSupplier = InternalProtocolNegotiationEvent
+                .getAttributes(pne).get(ATTR_SERVER_SSL_CONTEXT_PROVIDER_SUPPLIER);
+        if (sslContextProviderSupplier == null) {
+          logger.log(Level.FINE, "No sslContextProviderSupplier found in filterChainMatch "
+              + "for connection from {0} to {1}",
+              new Object[]{ctx.channel().remoteAddress(), ctx.channel().localAddress()});
+          if (fallbackProtocolNegotiator == null) {
+            ctx.fireExceptionCaught(new CertStoreException("No certificate source found!"));
+            return;
+          }
+          logger.log(Level.FINE, "Using fallback credentials for connection from {0} to {1}",
+              new Object[]{ctx.channel().remoteAddress(), ctx.channel().localAddress()});
+          ctx.pipeline()
+              .replace(
+                  this,
+                  null,
+                  fallbackProtocolNegotiator.newHandler(grpcHandler));
+          ctx.fireUserEventTriggered(pne);
+          return;
+        } else {
+          ctx.pipeline()
+              .replace(
+                  this,
+                  null,
+                  new ServerSecurityHandler(
+                      grpcHandler, sslContextProviderSupplier));
+          ctx.fireUserEventTriggered(pne);
+          return;
+        }
+      } else {
+        super.userEventTriggered(ctx, evt);
+      }
+    }
+  }
+
+  @VisibleForTesting
+  static final class ServerSecurityHandler
+          extends InternalProtocolNegotiators.ProtocolNegotiationHandler {
+    private final GrpcHttp2ConnectionHandler grpcHandler;
+    private final SslContextProviderSupplier sslContextProviderSupplier;
+
+    ServerSecurityHandler(
+            GrpcHttp2ConnectionHandler grpcHandler,
+            SslContextProviderSupplier sslContextProviderSupplier) {
+      super(
+          // superclass (InternalProtocolNegotiators.ProtocolNegotiationHandler) expects 'next'
+          // handler but we don't have a next handler _yet_. So we "disable" superclass's behavior
+          // here and then manually add 'next' when we call fireProtocolNegotiationEvent()
+          new ChannelHandlerAdapter() {
+            @Override
+            public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
+              ctx.pipeline().remove(this);
+            }
+          }, grpcHandler.getNegotiationLogger());
+      checkNotNull(grpcHandler, "grpcHandler");
+      this.grpcHandler = grpcHandler;
+      this.sslContextProviderSupplier = sslContextProviderSupplier;
+    }
+
+    @Override
+    protected void handlerAdded0(final ChannelHandlerContext ctx) {
+      final BufferReadsHandler bufferReads = new BufferReadsHandler();
+      ctx.pipeline().addBefore(ctx.name(), null, bufferReads);
+
+      sslContextProviderSupplier.updateSslContext(
+          new SslContextProvider.Callback(ctx.executor()) {
+
+            @Override
+            public void updateSslContextAndExtendedX509TrustManager(
+                AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> sslContextAndTm) {
+              ChannelHandler handler = InternalProtocolNegotiators.serverTls(
+                  sslContextAndTm.getKey()).newHandler(grpcHandler);
+
+              // Delegate rest of handshake to TLS handler
+              if (!ctx.isRemoved()) {
+                ctx.pipeline().addAfter(ctx.name(), null, handler);
+                fireProtocolNegotiationEvent(ctx);
+                ctx.pipeline().remove(bufferReads);
+              }
+            }
+
+            @Override
+            public void onException(Throwable throwable) {
+              ctx.fireExceptionCaught(throwable);
+            }
+          },
+          false);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/ServerSslContextProviderFactory.java b/xds/src/main/java/io/grpc/xds/internal/security/ServerSslContextProviderFactory.java
new file mode 100644
index 00000000000..b57f9b432c1
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/ServerSslContextProviderFactory.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2019 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.xds.internal.security;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.internal.security.ReferenceCountingMap.ValueFactory;
+import io.grpc.xds.internal.security.certprovider.CertProviderServerSslContextProviderFactory;
+
+/** Factory to create server-side SslContextProvider from DownstreamTlsContext. */
+final class ServerSslContextProviderFactory
+    implements ValueFactory<DownstreamTlsContext, SslContextProvider> {
+
+  private BootstrapInfo bootstrapInfo;
+  private final CertProviderServerSslContextProviderFactory
+      certProviderServerSslContextProviderFactory;
+
+  ServerSslContextProviderFactory(BootstrapInfo bootstrapInfo) {
+    this(bootstrapInfo, CertProviderServerSslContextProviderFactory.getInstance());
+  }
+
+  ServerSslContextProviderFactory(
+      BootstrapInfo bootstrapInfo, CertProviderServerSslContextProviderFactory factory) {
+    this.bootstrapInfo = bootstrapInfo;
+    this.certProviderServerSslContextProviderFactory = factory;
+  }
+
+  /** Creates a SslContextProvider from the given DownstreamTlsContext. */
+  @Override
+  public SslContextProvider create(
+      DownstreamTlsContext downstreamTlsContext) {
+    checkNotNull(downstreamTlsContext, "downstreamTlsContext");
+    checkNotNull(
+        downstreamTlsContext.getCommonTlsContext(),
+        "downstreamTlsContext should have CommonTlsContext");
+    if (CommonTlsContextUtil.hasCertProviderInstance(
+        downstreamTlsContext.getCommonTlsContext())) {
+      return certProviderServerSslContextProviderFactory.getProvider(
+          downstreamTlsContext,
+          bootstrapInfo.node().toEnvoyProtoNode(),
+          bootstrapInfo.certProviders());
+    }
+    throw new UnsupportedOperationException("Unsupported configurations in DownstreamTlsContext!");
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/SslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/SslContextProvider.java
new file mode 100644
index 00000000000..a5d14f72dc5
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/SslContextProvider.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2019 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.xds.internal.security;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.grpc.Internal;
+import io.grpc.xds.EnvoyServerProtoData.BaseTlsContext;
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.internal.security.trust.XdsTrustManagerFactory;
+import io.netty.handler.ssl.ClientAuth;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslContextBuilder;
+import java.io.IOException;
+import java.security.cert.CertStoreException;
+import java.security.cert.CertificateException;
+import java.util.AbstractMap;
+import java.util.concurrent.Executor;
+import javax.net.ssl.X509TrustManager;
+
+/**
+ * A SslContextProvider is a "container" or provider of SslContext. This is used by gRPC-xds to
+ * obtain an SslContext, so is not part of the public API of gRPC. This "container" may represent a
+ * stream that is receiving the requested secret(s) or it could represent file-system based
+ * secret(s) that are dynamic.
+ */
+@Internal
+public abstract class SslContextProvider implements Closeable {
+
+  protected final BaseTlsContext tlsContext;
+
+  @VisibleForTesting public abstract static class Callback {
+    private final Executor executor;
+
+    protected Callback(Executor executor) {
+      this.executor = executor;
+    }
+
+    @VisibleForTesting public Executor getExecutor() {
+      return executor;
+    }
+
+    /** Informs callee of new/updated SslContext. */
+    @VisibleForTesting public abstract void updateSslContextAndExtendedX509TrustManager(
+        AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> sslContext);
+
+    /** Informs callee of an exception that was generated. */
+    @VisibleForTesting protected abstract void onException(Throwable throwable);
+  }
+
+  protected SslContextProvider(BaseTlsContext tlsContext) {
+    this.tlsContext = checkNotNull(tlsContext, "tlsContext");
+  }
+
+  protected CommonTlsContext getCommonTlsContext() {
+    return tlsContext.getCommonTlsContext();
+  }
+
+  protected void setClientAuthValues(
+      SslContextBuilder sslContextBuilder, XdsTrustManagerFactory xdsTrustManagerFactory)
+      throws CertificateException, IOException, CertStoreException {
+    DownstreamTlsContext downstreamTlsContext = getDownstreamTlsContext();
+    if (xdsTrustManagerFactory != null) {
+      sslContextBuilder.trustManager(xdsTrustManagerFactory);
+      sslContextBuilder.clientAuth(
+          downstreamTlsContext.isRequireClientCertificate()
+              ? ClientAuth.REQUIRE
+              : ClientAuth.OPTIONAL);
+    } else {
+      sslContextBuilder.clientAuth(ClientAuth.NONE);
+    }
+  }
+
+  /** Returns the DownstreamTlsContext in this SslContextProvider if this is server side. **/
+  public DownstreamTlsContext getDownstreamTlsContext() {
+    checkState(tlsContext instanceof DownstreamTlsContext,
+        "expected DownstreamTlsContext");
+    return ((DownstreamTlsContext)tlsContext);
+  }
+
+  /** Returns the UpstreamTlsContext in this SslContextProvider if this is client side. **/
+  public UpstreamTlsContext getUpstreamTlsContext() {
+    checkState(tlsContext instanceof UpstreamTlsContext,
+        "expected UpstreamTlsContext");
+    return ((UpstreamTlsContext)tlsContext);
+  }
+
+  /** Closes this provider and releases any resources. */
+  @Override
+  public abstract void close();
+
+  /**
+   * Registers a callback on the given executor. The callback will run when SslContext becomes
+   * available or immediately if the result is already available.
+   */
+  public abstract void addCallback(Callback callback);
+
+  protected final void performCallback(
+          final SslContextGetter sslContextGetter, final Callback callback) {
+    checkNotNull(sslContextGetter, "sslContextGetter");
+    checkNotNull(callback, "callback");
+    callback.executor.execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            try {
+              AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> sslContextAndTm =
+                  sslContextGetter.get();
+              callback.updateSslContextAndExtendedX509TrustManager(sslContextAndTm);
+            } catch (Throwable e) {
+              callback.onException(e);
+            }
+          }
+        });
+  }
+
+  /** Allows implementations to compute or get SslContext. */
+  protected interface SslContextGetter {
+    AbstractMap.SimpleImmutableEntry<SslContext,X509TrustManager> get() throws Exception;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/SslContextProviderSupplier.java b/xds/src/main/java/io/grpc/xds/internal/security/SslContextProviderSupplier.java
new file mode 100644
index 00000000000..e5960dd95e8
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/SslContextProviderSupplier.java
@@ -0,0 +1,157 @@
+/*
+ * 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.xds.internal.security;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import io.grpc.xds.EnvoyServerProtoData.BaseTlsContext;
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.TlsContextManager;
+import io.netty.handler.ssl.SslContext;
+import java.util.AbstractMap;
+import java.util.Objects;
+import javax.net.ssl.X509TrustManager;
+
+/**
+ * Enables Client or server side to initialize this object with the received {@link BaseTlsContext}
+ * and communicate it to the consumer i.e. {@link SecurityProtocolNegotiators}
+ * to lazily evaluate the {@link SslContextProvider}. The supplier prevents credentials leakage in
+ * cases where the user is not using xDS credentials but the client/server contains a non-default
+ * {@link BaseTlsContext}.
+ */
+public final class SslContextProviderSupplier implements Closeable {
+
+  private final BaseTlsContext tlsContext;
+  private final TlsContextManager tlsContextManager;
+  private SslContextProvider sslContextProvider;
+  private boolean shutdown;
+
+  public SslContextProviderSupplier(
+      BaseTlsContext tlsContext, TlsContextManager tlsContextManager) {
+    this.tlsContext = checkNotNull(tlsContext, "tlsContext");
+    this.tlsContextManager = checkNotNull(tlsContextManager, "tlsContextManager");
+  }
+
+  public BaseTlsContext getTlsContext() {
+    return tlsContext;
+  }
+
+  /** Updates SslContext via the passed callback. */
+  public synchronized void updateSslContext(
+      final SslContextProvider.Callback callback, boolean autoSniSanValidationDoesNotApply) {
+    checkNotNull(callback, "callback");
+    try {
+      if (!shutdown) {
+        if (sslContextProvider == null) {
+          sslContextProvider = getSslContextProvider();
+          if (tlsContext instanceof UpstreamTlsContext && autoSniSanValidationDoesNotApply) {
+            ((DynamicSslContextProvider) sslContextProvider).setAutoSniSanValidationDoesNotApply();
+          }
+        }
+      }
+      // we want to increment the ref-count so call findOrCreate again...
+      final SslContextProvider toRelease = getSslContextProvider();
+      toRelease.addCallback(
+          new SslContextProvider.Callback(callback.getExecutor()) {
+
+            @Override
+            public void updateSslContextAndExtendedX509TrustManager(
+                AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> sslContextAndTm) {
+              callback.updateSslContextAndExtendedX509TrustManager(sslContextAndTm);
+              releaseSslContextProvider(toRelease);
+            }
+
+            @Override
+            public void onException(Throwable throwable) {
+              callback.onException(throwable);
+              releaseSslContextProvider(toRelease);
+            }
+          });
+    } catch (final Throwable throwable) {
+      callback.getExecutor().execute(new Runnable() {
+        @Override
+        public void run() {
+          callback.onException(throwable);
+        }
+      });
+    }
+  }
+
+  private void releaseSslContextProvider(SslContextProvider toRelease) {
+    if (tlsContext instanceof UpstreamTlsContext) {
+      tlsContextManager.releaseClientSslContextProvider(toRelease);
+    } else {
+      tlsContextManager.releaseServerSslContextProvider(toRelease);
+    }
+  }
+
+  private SslContextProvider getSslContextProvider() {
+    return tlsContext instanceof UpstreamTlsContext
+        ? tlsContextManager.findOrCreateClientSslContextProvider((UpstreamTlsContext) tlsContext)
+        : tlsContextManager.findOrCreateServerSslContextProvider(
+            (DownstreamTlsContext) tlsContext);
+  }
+
+  @VisibleForTesting public boolean isShutdown() {
+    return shutdown;
+  }
+
+  /** Called by consumer when tlsContext changes. */
+  @Override
+  public synchronized void close() {
+    if (sslContextProvider != null) {
+      if (tlsContext instanceof UpstreamTlsContext) {
+        tlsContextManager.releaseClientSslContextProvider(sslContextProvider);
+      } else {
+        tlsContextManager.releaseServerSslContextProvider(sslContextProvider);
+      }
+    }
+    sslContextProvider = null;
+    shutdown = true;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    SslContextProviderSupplier that = (SslContextProviderSupplier) o;
+    return Objects.equals(tlsContext, that.tlsContext)
+        && Objects.equals(tlsContextManager, that.tlsContextManager);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(tlsContext, tlsContextManager);
+  }
+
+  @Override
+  public String toString() {
+    return MoreObjects.toStringHelper(this)
+        .add("tlsContext", tlsContext)
+        .add("tlsContextManager", tlsContextManager)
+        .add("sslContextProvider", sslContextProvider)
+        .add("shutdown", shutdown)
+        .toString();
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/TlsContextManagerImpl.java b/xds/src/main/java/io/grpc/xds/internal/security/TlsContextManagerImpl.java
new file mode 100644
index 00000000000..f56524d50b7
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/TlsContextManagerImpl.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2019 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.xds.internal.security;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.TlsContextManager;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.internal.security.ReferenceCountingMap.ValueFactory;
+
+/**
+ * Class to manage {@link SslContextProvider} objects created from inputs we get from xDS. Used by
+ * gRPC-xds to access the SslContext's and is not public API. This manager manages the life-cycle of
+ * {@link SslContextProvider} objects as shared resources via ref-counting as described in {@link
+ * ReferenceCountingMap}.
+ */
+public final class TlsContextManagerImpl implements TlsContextManager {
+
+  private final ReferenceCountingMap<UpstreamTlsContext, SslContextProvider> mapForClients;
+  private final ReferenceCountingMap<DownstreamTlsContext, SslContextProvider> mapForServers;
+
+  /**
+   * Create a TlsContextManagerImpl instance using the passed in {@link BootstrapInfo}.
+   */
+  @VisibleForTesting public TlsContextManagerImpl(BootstrapInfo bootstrapInfo) {
+    this(
+        new ClientSslContextProviderFactory(bootstrapInfo),
+        new ServerSslContextProviderFactory(bootstrapInfo));
+  }
+
+  @VisibleForTesting
+  TlsContextManagerImpl(
+      ValueFactory<UpstreamTlsContext, SslContextProvider> clientFactory,
+      ValueFactory<DownstreamTlsContext, SslContextProvider> serverFactory) {
+    checkNotNull(clientFactory, "clientFactory");
+    checkNotNull(serverFactory, "serverFactory");
+    mapForClients = new ReferenceCountingMap<>(clientFactory);
+    mapForServers = new ReferenceCountingMap<>(serverFactory);
+  }
+
+  @Override
+  public SslContextProvider findOrCreateServerSslContextProvider(
+      DownstreamTlsContext downstreamTlsContext) {
+    checkNotNull(downstreamTlsContext, "downstreamTlsContext");
+    CommonTlsContext.Builder builder = downstreamTlsContext.getCommonTlsContext().toBuilder();
+    downstreamTlsContext =
+        new DownstreamTlsContext(
+            builder.build(), downstreamTlsContext.isRequireClientCertificate());
+    return mapForServers.get(downstreamTlsContext);
+  }
+
+  @Override
+  public SslContextProvider findOrCreateClientSslContextProvider(
+      UpstreamTlsContext upstreamTlsContext) {
+    checkNotNull(upstreamTlsContext, "upstreamTlsContext");
+    return mapForClients.get(upstreamTlsContext);
+  }
+
+  @Override
+  public SslContextProvider releaseClientSslContextProvider(
+      SslContextProvider clientSslContextProvider) {
+    checkNotNull(clientSslContextProvider, "clientSslContextProvider");
+    return mapForClients.release(clientSslContextProvider.getUpstreamTlsContext(),
+        clientSslContextProvider);
+  }
+
+  @Override
+  public SslContextProvider releaseServerSslContextProvider(
+      SslContextProvider serverSslContextProvider) {
+    checkNotNull(serverSslContextProvider, "serverSslContextProvider");
+    return mapForServers.release(serverSslContextProvider.getDownstreamTlsContext(),
+        serverSslContextProvider);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderClientSslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderClientSslContextProvider.java
new file mode 100644
index 00000000000..b4b72ae11c6
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderClientSslContextProvider.java
@@ -0,0 +1,101 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import io.envoyproxy.envoy.config.core.v3.Node;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.grpc.netty.GrpcSslContexts;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.client.Bootstrapper.CertificateProviderInfo;
+import io.grpc.xds.internal.security.trust.XdsTrustManagerFactory;
+import io.netty.handler.ssl.SslContextBuilder;
+import java.security.cert.CertStoreException;
+import java.security.cert.X509Certificate;
+import java.util.AbstractMap;
+import java.util.Arrays;
+import java.util.Map;
+import javax.annotation.Nullable;
+import javax.net.ssl.X509TrustManager;
+
+/** A client SslContext provider using CertificateProviderInstance to fetch secrets. */
+final class CertProviderClientSslContextProvider extends CertProviderSslContextProvider {
+
+  CertProviderClientSslContextProvider(
+      Node node,
+      @Nullable Map<String, CertificateProviderInfo> certProviders,
+      CommonTlsContext.CertificateProviderInstance certInstance,
+      CommonTlsContext.CertificateProviderInstance rootCertInstance,
+      CertificateValidationContext staticCertValidationContext,
+      UpstreamTlsContext upstreamTlsContext,
+      CertificateProviderStore certificateProviderStore) {
+    super(
+        node,
+        certProviders,
+        certInstance,
+        rootCertInstance,
+        staticCertValidationContext,
+        upstreamTlsContext,
+        certificateProviderStore);
+  }
+
+  @Override
+  protected final AbstractMap.SimpleImmutableEntry<SslContextBuilder, X509TrustManager>
+      getSslContextBuilderAndTrustManager(
+          CertificateValidationContext certificateValidationContext)
+              throws CertStoreException {
+    SslContextBuilder sslContextBuilder = GrpcSslContexts.forClient();
+    if (savedSpiffeTrustMap != null) {
+      sslContextBuilder = sslContextBuilder.trustManager(
+        new XdsTrustManagerFactory(
+            savedSpiffeTrustMap,
+            certificateValidationContext,
+            autoSniSanValidationDoesNotApply
+                ? false : ((UpstreamTlsContext) tlsContext).getAutoSniSanValidation()));
+    } else if (savedTrustedRoots != null) {
+      sslContextBuilder = sslContextBuilder.trustManager(
+          new XdsTrustManagerFactory(
+              savedTrustedRoots.toArray(new X509Certificate[0]),
+              certificateValidationContext,
+              autoSniSanValidationDoesNotApply
+                  ? false : ((UpstreamTlsContext) tlsContext).getAutoSniSanValidation()));
+    } else {
+      // Should be impossible because of the check in CertProviderClientSslContextProviderFactory
+      throw new IllegalStateException("There must be trusted roots or a SPIFFE trust map");
+    }
+    XdsTrustManagerFactory trustManagerFactory;
+    if (savedSpiffeTrustMap != null) {
+      trustManagerFactory = new XdsTrustManagerFactory(
+          savedSpiffeTrustMap,
+          certificateValidationContext,
+          ((UpstreamTlsContext) tlsContext).getAutoSniSanValidation());
+      sslContextBuilder = sslContextBuilder.trustManager(trustManagerFactory);
+    } else {
+      trustManagerFactory = new XdsTrustManagerFactory(
+          savedTrustedRoots.toArray(new X509Certificate[0]),
+          certificateValidationContext,
+          ((UpstreamTlsContext) tlsContext).getAutoSniSanValidation());
+      sslContextBuilder = sslContextBuilder.trustManager(trustManagerFactory);
+    }
+    if (isMtls()) {
+      sslContextBuilder.keyManager(savedKey, savedCertChain);
+    }
+    return new AbstractMap.SimpleImmutableEntry<>(sslContextBuilder,
+        io.grpc.internal.CertificateUtils.getX509ExtendedTrustManager(
+            Arrays.asList(trustManagerFactory.getTrustManagers())));
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderClientSslContextProviderFactory.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderClientSslContextProviderFactory.java
new file mode 100644
index 00000000000..6205c1c3a63
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderClientSslContextProviderFactory.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2022 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.xds.internal.security.certprovider;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.envoyproxy.envoy.config.core.v3.Node;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.grpc.Internal;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.client.Bootstrapper.CertificateProviderInfo;
+import io.grpc.xds.internal.security.CommonTlsContextUtil;
+import io.grpc.xds.internal.security.SslContextProvider;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/**
+ * Creates CertProviderClientSslContextProvider.
+ */
+@Internal
+public final class CertProviderClientSslContextProviderFactory {
+
+  private static final CertProviderClientSslContextProviderFactory DEFAULT_INSTANCE =
+      new CertProviderClientSslContextProviderFactory(CertificateProviderStore.getInstance());
+  private final CertificateProviderStore certificateProviderStore;
+
+  @VisibleForTesting
+  public CertProviderClientSslContextProviderFactory(
+      CertificateProviderStore certificateProviderStore) {
+    this.certificateProviderStore = certificateProviderStore;
+  }
+
+  public static CertProviderClientSslContextProviderFactory getInstance() {
+    return DEFAULT_INSTANCE;
+  }
+
+  /**
+   * Creates a {@link CertProviderClientSslContextProvider}.
+   */
+  public SslContextProvider getProvider(
+      UpstreamTlsContext upstreamTlsContext,
+      Node node,
+      @Nullable Map<String, CertificateProviderInfo> certProviders) {
+    checkNotNull(upstreamTlsContext, "upstreamTlsContext");
+    CommonTlsContext commonTlsContext = upstreamTlsContext.getCommonTlsContext();
+    CertificateValidationContext staticCertValidationContext
+        = CertProviderSslContextProvider.getStaticValidationContext(commonTlsContext);
+    CommonTlsContext.CertificateProviderInstance rootCertInstance
+        = CertProviderSslContextProvider.getRootCertProviderInstance(commonTlsContext);
+    CommonTlsContext.CertificateProviderInstance certInstance
+        = CertProviderSslContextProvider.getCertProviderInstance(commonTlsContext);
+    if (CommonTlsContextUtil.hasCertProviderInstance(upstreamTlsContext.getCommonTlsContext())
+        || CommonTlsContextUtil.isUsingSystemRootCerts(upstreamTlsContext.getCommonTlsContext())) {
+      return new CertProviderClientSslContextProvider(
+          node,
+          certProviders,
+          certInstance,
+          rootCertInstance,
+          staticCertValidationContext,
+          upstreamTlsContext,
+          certificateProviderStore);
+    }
+    throw new UnsupportedOperationException("Unsupported configurations in UpstreamTlsContext!");
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderServerSslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderServerSslContextProvider.java
new file mode 100644
index 00000000000..3712b948142
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderServerSslContextProvider.java
@@ -0,0 +1,81 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import io.envoyproxy.envoy.config.core.v3.Node;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.grpc.netty.GrpcSslContexts;
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.client.Bootstrapper.CertificateProviderInfo;
+import io.grpc.xds.internal.security.trust.XdsTrustManagerFactory;
+import io.netty.handler.ssl.SslContextBuilder;
+import java.io.IOException;
+import java.security.cert.CertStoreException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.AbstractMap;
+import java.util.Map;
+import javax.annotation.Nullable;
+import javax.net.ssl.X509TrustManager;
+
+/** A server SslContext provider using CertificateProviderInstance to fetch secrets. */
+final class CertProviderServerSslContextProvider extends CertProviderSslContextProvider {
+
+  CertProviderServerSslContextProvider(
+      Node node,
+      @Nullable Map<String, CertificateProviderInfo> certProviders,
+      CommonTlsContext.CertificateProviderInstance certInstance,
+      CommonTlsContext.CertificateProviderInstance rootCertInstance,
+      CertificateValidationContext staticCertValidationContext,
+      DownstreamTlsContext downstreamTlsContext,
+      CertificateProviderStore certificateProviderStore) {
+    super(
+        node,
+        certProviders,
+        checkNotNull(certInstance, "Server SSL requires certInstance"),
+        rootCertInstance,
+        staticCertValidationContext,
+        downstreamTlsContext,
+        certificateProviderStore);
+  }
+
+  @Override
+  protected final AbstractMap.SimpleImmutableEntry<SslContextBuilder, X509TrustManager>
+      getSslContextBuilderAndTrustManager(
+          CertificateValidationContext certificateValidationContextdationContext)
+          throws CertStoreException, CertificateException, IOException {
+    SslContextBuilder sslContextBuilder = SslContextBuilder.forServer(savedKey, savedCertChain);
+    XdsTrustManagerFactory trustManagerFactory = null;
+    if (isMtls() && savedSpiffeTrustMap != null) {
+      trustManagerFactory = new XdsTrustManagerFactory(
+          savedSpiffeTrustMap,
+          certificateValidationContextdationContext, false);
+    } else if (isMtls()) {
+      trustManagerFactory = new XdsTrustManagerFactory(
+          savedTrustedRoots.toArray(new X509Certificate[0]),
+          certificateValidationContextdationContext, false);
+    }
+    setClientAuthValues(sslContextBuilder, trustManagerFactory);
+    sslContextBuilder = GrpcSslContexts.configure(sslContextBuilder);
+    // TrustManager in the below return value is not used on the server side, so setting it to null
+    return new AbstractMap.SimpleImmutableEntry<>(sslContextBuilder, null);
+  }
+
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderServerSslContextProviderFactory.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderServerSslContextProviderFactory.java
new file mode 100644
index 00000000000..3e285012347
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderServerSslContextProviderFactory.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2022 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.xds.internal.security.certprovider;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.envoyproxy.envoy.config.core.v3.Node;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.grpc.Internal;
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.client.Bootstrapper.CertificateProviderInfo;
+import io.grpc.xds.internal.security.SslContextProvider;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/**
+ * Creates CertProviderServerSslContextProvider.
+ */
+@Internal
+public final class CertProviderServerSslContextProviderFactory {
+
+  private static final CertProviderServerSslContextProviderFactory DEFAULT_INSTANCE =
+      new CertProviderServerSslContextProviderFactory(CertificateProviderStore.getInstance());
+  private final CertificateProviderStore certificateProviderStore;
+
+  @VisibleForTesting
+  public CertProviderServerSslContextProviderFactory(
+      CertificateProviderStore certificateProviderStore) {
+    this.certificateProviderStore = certificateProviderStore;
+  }
+
+  public static CertProviderServerSslContextProviderFactory getInstance() {
+    return DEFAULT_INSTANCE;
+  }
+
+  /**
+   * Creates a {@link CertProviderServerSslContextProvider}.
+   */
+  public SslContextProvider getProvider(
+      DownstreamTlsContext downstreamTlsContext,
+      Node node,
+      @Nullable Map<String, CertificateProviderInfo> certProviders) {
+    checkNotNull(downstreamTlsContext, "downstreamTlsContext");
+    CommonTlsContext commonTlsContext = downstreamTlsContext.getCommonTlsContext();
+    CertificateValidationContext staticCertValidationContext
+        = CertProviderSslContextProvider.getStaticValidationContext(commonTlsContext);
+    CommonTlsContext.CertificateProviderInstance rootCertInstance
+        = CertProviderSslContextProvider.getRootCertProviderInstance(commonTlsContext);
+    CommonTlsContext.CertificateProviderInstance certInstance
+        = CertProviderSslContextProvider.getCertProviderInstance(commonTlsContext);
+    return new CertProviderServerSslContextProvider(
+        node,
+        certProviders,
+        certInstance,
+        rootCertInstance,
+        staticCertValidationContext,
+        downstreamTlsContext,
+        certificateProviderStore);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderSslContextProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderSslContextProvider.java
new file mode 100644
index 00000000000..cb99ca6ad95
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertProviderSslContextProvider.java
@@ -0,0 +1,229 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import io.envoyproxy.envoy.config.core.v3.Node;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext.CertificateProviderInstance;
+import io.grpc.xds.EnvoyServerProtoData.BaseTlsContext;
+import io.grpc.xds.client.Bootstrapper.CertificateProviderInfo;
+import io.grpc.xds.internal.security.CommonTlsContextUtil;
+import io.grpc.xds.internal.security.DynamicSslContextProvider;
+import java.io.Closeable;
+import java.security.PrivateKey;
+import java.security.cert.X509Certificate;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+/** Base class for {@link CertProviderClientSslContextProvider}. */
+abstract class CertProviderSslContextProvider extends DynamicSslContextProvider implements
+    CertificateProvider.Watcher {
+
+  @Nullable private final NoExceptionCloseable certHandle;
+  @Nullable private final NoExceptionCloseable rootCertHandle;
+  @Nullable private final CertificateProviderInstance certInstance;
+  @Nullable protected final CertificateProviderInstance rootCertInstance;
+  @Nullable protected PrivateKey savedKey;
+  @Nullable protected List<X509Certificate> savedCertChain;
+  @Nullable protected List<X509Certificate> savedTrustedRoots;
+  @Nullable protected Map<String, List<X509Certificate>> savedSpiffeTrustMap;
+  private final boolean isUsingSystemRootCerts;
+
+  protected CertProviderSslContextProvider(
+      Node node,
+      @Nullable Map<String, CertificateProviderInfo> certProviders,
+      CertificateProviderInstance certInstance,
+      CertificateProviderInstance rootCertInstance,
+      CertificateValidationContext staticCertValidationContext,
+      BaseTlsContext tlsContext,
+      CertificateProviderStore certificateProviderStore) {
+    super(tlsContext, staticCertValidationContext);
+    this.certInstance = certInstance;
+    this.rootCertInstance = rootCertInstance;
+    this.isUsingSystemRootCerts = rootCertInstance == null
+        && CommonTlsContextUtil.isUsingSystemRootCerts(tlsContext.getCommonTlsContext());
+    boolean createCertInstance = certInstance != null && certInstance.isInitialized();
+    boolean createRootCertInstance = rootCertInstance != null && rootCertInstance.isInitialized();
+    boolean sharedCertInstance = createCertInstance && createRootCertInstance
+        && rootCertInstance.getInstanceName().equals(certInstance.getInstanceName());
+    if (createCertInstance) {
+      CertificateProviderInfo certProviderInstanceConfig =
+          getCertProviderConfig(certProviders, certInstance.getInstanceName());
+      CertificateProvider.Watcher watcher = this;
+      if (!sharedCertInstance && !isUsingSystemRootCerts) {
+        watcher = new IgnoreUpdatesWatcher(watcher, /* ignoreRootCertUpdates= */ true);
+      }
+      // TODO: Previously we'd hang if certProviderInstanceConfig were null or
+      // certInstance.isInitialized() == false. Now we'll proceed. Those should be errors, or are
+      // they impossible and should be assertions?
+      certHandle = certProviderInstanceConfig == null ? null
+          : certificateProviderStore.createOrGetProvider(
+              certInstance.getCertificateName(),
+              certProviderInstanceConfig.pluginName(),
+              certProviderInstanceConfig.config(),
+              watcher,
+              true)::close;
+    } else {
+      certHandle = null;
+    }
+    if (createRootCertInstance && !sharedCertInstance) {
+      CertificateProviderInfo certProviderInstanceConfig =
+          getCertProviderConfig(certProviders, rootCertInstance.getInstanceName());
+      rootCertHandle = certProviderInstanceConfig == null ? null
+          : certificateProviderStore.createOrGetProvider(
+              rootCertInstance.getCertificateName(),
+              certProviderInstanceConfig.pluginName(),
+              certProviderInstanceConfig.config(),
+              new IgnoreUpdatesWatcher(this, /* ignoreRootCertUpdates= */ false),
+              false)::close;
+    } else if (rootCertInstance == null
+        && CommonTlsContextUtil.isUsingSystemRootCerts(tlsContext.getCommonTlsContext())) {
+      SystemRootCertificateProvider systemRootProvider = new SystemRootCertificateProvider(this);
+      systemRootProvider.start();
+      rootCertHandle = systemRootProvider::close;
+    } else {
+      rootCertHandle = null;
+    }
+  }
+
+  private static CertificateProviderInfo getCertProviderConfig(
+      @Nullable Map<String, CertificateProviderInfo> certProviders, String pluginInstanceName) {
+    return certProviders != null ? certProviders.get(pluginInstanceName) : null;
+  }
+
+  @Nullable
+  protected static CertificateProviderInstance getCertProviderInstance(
+      CommonTlsContext commonTlsContext) {
+    if (commonTlsContext.hasTlsCertificateProviderInstance()) {
+      return CommonTlsContextUtil.convert(commonTlsContext.getTlsCertificateProviderInstance());
+    }
+    // Fall back to deprecated field for backward compatibility with Istio
+    @SuppressWarnings("deprecation")
+    CertificateProviderInstance deprecatedInstance =
+        commonTlsContext.hasTlsCertificateCertificateProviderInstance()
+            ? commonTlsContext.getTlsCertificateCertificateProviderInstance()
+            : null;
+    return deprecatedInstance;
+  }
+
+  @Nullable
+  protected static CertificateValidationContext getStaticValidationContext(
+      CommonTlsContext commonTlsContext) {
+    if (commonTlsContext.hasValidationContext()) {
+      return commonTlsContext.getValidationContext();
+    } else if (commonTlsContext.hasCombinedValidationContext()) {
+      CommonTlsContext.CombinedCertificateValidationContext combinedValidationContext =
+          commonTlsContext.getCombinedValidationContext();
+      if (combinedValidationContext.hasDefaultValidationContext()) {
+        return combinedValidationContext.getDefaultValidationContext();
+      }
+    }
+    return null;
+  }
+
+  @Nullable
+  protected static CommonTlsContext.CertificateProviderInstance getRootCertProviderInstance(
+      CommonTlsContext commonTlsContext) {
+    CertificateValidationContext certValidationContext = getStaticValidationContext(
+        commonTlsContext);
+    if (certValidationContext != null && certValidationContext.hasCaCertificateProviderInstance()) {
+      return CommonTlsContextUtil.convert(certValidationContext.getCaCertificateProviderInstance());
+    }
+    return null;
+  }
+
+  @Override
+  public final void updateCertificate(PrivateKey key, List<X509Certificate> certChain) {
+    savedKey = key;
+    savedCertChain = certChain;
+    updateSslContextWhenReady();
+  }
+
+  @Override
+  public final void updateTrustedRoots(List<X509Certificate> trustedRoots) {
+    savedTrustedRoots = trustedRoots;
+    updateSslContextWhenReady();
+  }
+
+  @Override
+  public final void updateSpiffeTrustMap(Map<String, List<X509Certificate>> spiffeTrustMap) {
+    savedSpiffeTrustMap = spiffeTrustMap;
+    updateSslContextWhenReady();
+  }
+
+  private void updateSslContextWhenReady() {
+    if (isMtls()) {
+      if (savedKey != null && (savedTrustedRoots != null || savedSpiffeTrustMap != null)) {
+        updateSslContext();
+        clearKeysAndCerts();
+      }
+    } else if (isRegularTlsAndClientSide()) {
+      if (savedTrustedRoots != null || savedSpiffeTrustMap != null) {
+        updateSslContext();
+        clearKeysAndCerts();
+      }
+    } else if (isRegularTlsAndServerSide()) {
+      if (savedKey != null) {
+        updateSslContext();
+        clearKeysAndCerts();
+      }
+    }
+  }
+
+  private void clearKeysAndCerts() {
+    savedKey = null;
+    if (!isUsingSystemRootCerts) {
+      savedTrustedRoots = null;
+      savedSpiffeTrustMap = null;
+    }
+    savedCertChain = null;
+  }
+
+  protected final boolean isMtls() {
+    return certInstance != null && (rootCertInstance != null || isUsingSystemRootCerts);
+  }
+
+  protected final boolean isRegularTlsAndClientSide() {
+    return (rootCertInstance != null || isUsingSystemRootCerts) && certInstance == null;
+  }
+
+  protected final boolean isRegularTlsAndServerSide() {
+    return certInstance != null && rootCertInstance == null;
+  }
+
+  @Override
+  protected final CertificateValidationContext generateCertificateValidationContext() {
+    return staticCertificateValidationContext;
+  }
+
+  @Override
+  public final void close() {
+    if (certHandle != null) {
+      certHandle.close();
+    }
+    if (rootCertHandle != null) {
+      rootCertHandle.close();
+    }
+  }
+
+  interface NoExceptionCloseable extends Closeable {
+    @Override
+    void close();
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProvider.java
new file mode 100644
index 00000000000..009bb7bf566
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProvider.java
@@ -0,0 +1,184 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Status;
+import io.grpc.xds.internal.security.Closeable;
+import java.security.PrivateKey;
+import java.security.cert.X509Certificate;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A plug-in that provides certificates required by the xDS security component and created
+ * using the certificate-provider config from the xDS server.
+ *
+ * <p>We may move this out of the internal package and make this an official API in the future.
+ *
+ * <p>The plugin fetches certificates - root and optionally identity cert - required by xDS
+ * security.
+ */
+public abstract class CertificateProvider implements Closeable {
+
+  /** A watcher is registered to receive certificate updates. */
+  public interface Watcher {
+    void updateCertificate(PrivateKey key, List<X509Certificate> certChain);
+
+    void updateTrustedRoots(List<X509Certificate> trustedRoots);
+
+    void updateSpiffeTrustMap(Map<String, List<X509Certificate>> spiffeTrustMap);
+
+    void onError(Status errorStatus);
+  }
+
+  @VisibleForTesting
+  public static final class DistributorWatcher implements Watcher {
+    private PrivateKey privateKey;
+    private List<X509Certificate> certChain;
+    private List<X509Certificate> trustedRoots;
+    private Map<String, List<X509Certificate>> spiffeTrustMap;
+
+    @VisibleForTesting
+    final Set<Watcher> downstreamWatchers = new HashSet<>();
+
+    synchronized void addWatcher(Watcher watcher) {
+      downstreamWatchers.add(watcher);
+      if (privateKey != null && certChain != null) {
+        sendLastCertificateUpdate(watcher);
+      }
+      if (trustedRoots != null) {
+        sendLastTrustedRootsUpdate(watcher);
+      }
+      if (spiffeTrustMap != null) {
+        sendLastSpiffeTrustMapUpdate(watcher);
+      }
+    }
+
+    synchronized void removeWatcher(Watcher watcher) {
+      downstreamWatchers.remove(watcher);
+    }
+
+    @VisibleForTesting public Set<Watcher> getDownstreamWatchers() {
+      return Collections.unmodifiableSet(downstreamWatchers);
+    }
+
+    private void sendLastCertificateUpdate(Watcher watcher) {
+      watcher.updateCertificate(privateKey, certChain);
+    }
+
+    private void sendLastTrustedRootsUpdate(Watcher watcher) {
+      watcher.updateTrustedRoots(trustedRoots);
+    }
+
+    private void sendLastSpiffeTrustMapUpdate(Watcher watcher) {
+      watcher.updateSpiffeTrustMap(spiffeTrustMap);
+    }
+
+    @Override
+    public synchronized void updateCertificate(PrivateKey key, List<X509Certificate> certChain) {
+      checkNotNull(key, "key");
+      checkNotNull(certChain, "certChain");
+      privateKey = key;
+      this.certChain = certChain;
+      for (Watcher watcher : downstreamWatchers) {
+        sendLastCertificateUpdate(watcher);
+      }
+    }
+
+    @Override
+    public synchronized void updateTrustedRoots(List<X509Certificate> trustedRoots) {
+      checkNotNull(trustedRoots, "trustedRoots");
+      this.trustedRoots = trustedRoots;
+      for (Watcher watcher : downstreamWatchers) {
+        sendLastTrustedRootsUpdate(watcher);
+      }
+    }
+
+    @Override
+    public void updateSpiffeTrustMap(Map<String, List<X509Certificate>> spiffeTrustMap) {
+      this.spiffeTrustMap = spiffeTrustMap;
+      for (Watcher watcher : downstreamWatchers) {
+        sendLastSpiffeTrustMapUpdate(watcher);
+      }
+    }
+
+    @Override
+    public synchronized void onError(Status errorStatus) {
+      for (Watcher watcher : downstreamWatchers) {
+        watcher.onError(errorStatus);
+      }
+    }
+
+    X509Certificate getLastIdentityCert() {
+      if (certChain != null && !certChain.isEmpty()) {
+        return certChain.get(0);
+      }
+      return null;
+    }
+
+    void close() {
+      downstreamWatchers.clear();
+      clearValues();
+    }
+
+    void clearValues() {
+      privateKey = null;
+      certChain = null;
+      trustedRoots = null;
+    }
+  }
+
+  /**
+   * Concrete subclasses will call this to register the {@link Watcher}.
+   *
+   * @param watcher to register
+   * @param notifyCertUpdates if true, the provider is required to call the watcher’s
+   *     updateCertificate method. Implies the Provider is capable of minting certificates.
+   *     Used by server-side and mTLS client-side. Note the Provider is always required
+   *     to call updateTrustedRoots to provide trusted-root updates.
+   */
+  protected CertificateProvider(DistributorWatcher watcher, boolean notifyCertUpdates) {
+    this.watcher = watcher;
+    this.notifyCertUpdates = notifyCertUpdates;
+  }
+
+  /** Releases all resources and stop cert refreshes and watcher updates. */
+  @Override
+  public abstract void close();
+
+  /** Starts the async cert refresh and watcher update cycle. */
+  public abstract void start();
+
+  private final DistributorWatcher watcher;
+  private final boolean notifyCertUpdates;
+
+  public DistributorWatcher getWatcher() {
+    return watcher;
+  }
+
+  public boolean isNotifyCertUpdates() {
+    return notifyCertUpdates;
+  }
+
+
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderProvider.java
new file mode 100644
index 00000000000..e2e26ead502
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderProvider.java
@@ -0,0 +1,47 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import io.grpc.Internal;
+import io.grpc.xds.internal.security.certprovider.CertificateProvider.Watcher;
+
+/**
+ * Provider of {@link CertificateProvider}s. Implemented by the implementer of the plugin. We may
+ * move this out of the internal package and make this an official API in the future.
+ */
+@Internal
+public interface CertificateProviderProvider {
+  /** Returns the unique name of the {@link CertificateProvider} plugin. */
+  String getName();
+
+  /**
+   * Creates a {@link CertificateProvider} plugin.
+   *
+   * @param config configuration needed by the Provider to create the CertificateProvider. A form of
+   *     JSON that the Provider understands e.g. a string or a key-value Map.
+   * @param watcher A {@link Watcher} to receive updates from the CertificateProvider
+   * @param notifyCertUpdates if true, the provider is required to call the watcher’s
+   *     updateCertificate method. Implies the Provider is capable of minting certificates. Used
+   *     by server-side and mTLS client-side. Note the Provider is always required  to call
+   *     updateTrustedRoots to provide trusted-root updates.
+   * @throws IllegalArgumentException in case of errors in processing config.
+   * @throws UnsupportedOperationException if the plugin is incapable of sending cert updates when
+   *     notifyCertUpdates is true.
+   */
+  CertificateProvider createCertificateProvider(
+      Object config, CertificateProvider.DistributorWatcher watcher, boolean notifyCertUpdates);
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderRegistry.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderRegistry.java
new file mode 100644
index 00000000000..f8ced7bb2cc
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderRegistry.java
@@ -0,0 +1,79 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import java.util.LinkedHashMap;
+import javax.annotation.Nullable;
+import javax.annotation.concurrent.ThreadSafe;
+
+/** Maintains {@link CertificateProvider}s for all registered plugins. */
+@ThreadSafe
+public final class CertificateProviderRegistry {
+  private static CertificateProviderRegistry instance;
+  private final LinkedHashMap<String, CertificateProviderProvider> providers =
+      new LinkedHashMap<>();
+
+  @VisibleForTesting
+  public CertificateProviderRegistry() {
+  }
+
+  /** Returns the singleton registry. */
+  public static synchronized CertificateProviderRegistry getInstance() {
+    if (instance == null) {
+      instance = new CertificateProviderRegistry();
+      // TODO(sanjaypujare): replace with Java's SPI mechanism and META-INF resource
+      instance.register(new FileWatcherCertificateProviderProvider());
+    }
+    return instance;
+  }
+
+  /**
+   * Register a {@link CertificateProviderProvider}.
+   *
+   * <p>If a provider with the same {@link CertificateProviderProvider#getName name} was already
+   * registered, this method will overwrite that provider.
+   */
+  public synchronized void register(CertificateProviderProvider certificateProviderProvider) {
+    checkNotNull(certificateProviderProvider, "certificateProviderProvider");
+    providers.put(certificateProviderProvider.getName(), certificateProviderProvider);
+  }
+
+  /**
+   * Deregisters a provider.  No-op if the provider is not in the registry.
+   *
+   * @param certificateProviderProvider the provider that was added to the registry via
+   *                                    {@link #register}.
+   */
+  public synchronized void deregister(CertificateProviderProvider certificateProviderProvider) {
+    checkNotNull(certificateProviderProvider, "certificateProviderProvider");
+    providers.remove(certificateProviderProvider.getName());
+  }
+
+  /**
+   * Returns the CertificateProviderProvider for the given name, or {@code null} if no
+   * provider is found.  Each provider declares its name via {@link
+   * CertificateProviderProvider#getName}. This is an internal method of the Registry
+   * *only* used by the framework.
+   */
+  @Nullable
+  synchronized CertificateProviderProvider getProvider(String name) {
+    return providers.get(checkNotNull(name, "name"));
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderStore.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderStore.java
new file mode 100644
index 00000000000..0fe342a36c0
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/CertificateProviderStore.java
@@ -0,0 +1,197 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.xds.internal.security.ReferenceCountingMap;
+import io.grpc.xds.internal.security.certprovider.CertificateProvider.Watcher;
+import java.io.Closeable;
+import java.util.Objects;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.concurrent.ThreadSafe;
+
+/**
+ * Global map of all ref-counted {@link CertificateProvider}s that have been instantiated in
+ * the application. Also  propagates updates received from a {@link CertificateProvider} to all
+ * the {@link Watcher}s registered for that CertificateProvider. The Store is meant to be
+ * used internally by gRPC and *not* a public API.
+ */
+@ThreadSafe
+public final class CertificateProviderStore {
+  private static final Logger logger = Logger.getLogger(CertificateProviderStore.class.getName());
+
+  private static CertificateProviderStore instance;
+  private final CertificateProviderRegistry certificateProviderRegistry;
+  private final ReferenceCountingMap<CertProviderKey, CertificateProvider> certProviderMap;
+
+  /** Opaque Handle returned by {@link #createOrGetProvider}. */
+  @VisibleForTesting
+  final class Handle implements Closeable {
+    private final CertProviderKey key;
+    private final Watcher watcher;
+    @VisibleForTesting
+    final CertificateProvider certProvider;
+
+    private Handle(CertProviderKey key, Watcher watcher, CertificateProvider certProvider) {
+      this.key = key;
+      this.watcher = watcher;
+      this.certProvider = certProvider;
+    }
+
+    /**
+     * Removes the associated {@link Watcher} for the {@link CertificateProvider} and
+     * decrements the ref-count. Releases the {@link CertificateProvider} if the ref-count
+     * has reached 0.
+     */
+    @Override
+    public synchronized void close() {
+      CertificateProvider.DistributorWatcher distWatcher = certProvider.getWatcher();
+      distWatcher.removeWatcher(watcher);
+      certProviderMap.release(key, certProvider);
+    }
+  }
+
+  private static final class CertProviderKey {
+    private final String certName;
+    private final String pluginName;
+    private final boolean notifyCertUpdates;
+    private final Object config;
+
+    private CertProviderKey(
+        String certName, String pluginName, boolean notifyCertUpdates, Object config) {
+      this.certName = certName;
+      this.pluginName = pluginName;
+      this.notifyCertUpdates = notifyCertUpdates;
+      this.config = config;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) {
+        return true;
+      }
+      if (!(o instanceof CertProviderKey)) {
+        return false;
+      }
+      CertProviderKey that = (CertProviderKey) o;
+      return notifyCertUpdates == that.notifyCertUpdates
+          && Objects.equals(certName, that.certName)
+          && Objects.equals(pluginName, that.pluginName)
+          && Objects.equals(config, that.config);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(certName, pluginName, notifyCertUpdates, config);
+    }
+
+    @Override
+    public String toString() {
+      return "CertProviderKey{"
+          + "certName='"
+          + certName
+          + '\''
+          + ", pluginName='"
+          + pluginName
+          + '\''
+          + ", notifyCertUpdates="
+          + notifyCertUpdates
+          + ", config="
+          + config
+          + '}';
+    }
+  }
+
+  private final class CertProviderFactory
+      implements ReferenceCountingMap.ValueFactory<CertProviderKey, CertificateProvider> {
+
+    private CertProviderFactory() {
+    }
+
+    @Override
+    public CertificateProvider create(CertProviderKey key) {
+      CertificateProviderProvider certProviderProvider =
+          certificateProviderRegistry.getProvider(key.pluginName);
+      if (certProviderProvider == null) {
+        throw new IllegalArgumentException("Provider not found for " + key.pluginName);
+      }
+      CertificateProvider certProvider = certProviderProvider.createCertificateProvider(
+              key.config, new CertificateProvider.DistributorWatcher(), key.notifyCertUpdates);
+      certProvider.start();
+      return certProvider;
+    }
+  }
+
+  @VisibleForTesting
+  public CertificateProviderStore(CertificateProviderRegistry certificateProviderRegistry) {
+    this.certificateProviderRegistry = certificateProviderRegistry;
+    certProviderMap = new ReferenceCountingMap<>(new CertProviderFactory());
+  }
+
+  /**
+   * Creates or retrieves a {@link CertificateProvider} instance, increments its ref-count and
+   * registers the watcher passed. Returns a {@link Handle} that can be {@link Handle#close()}d when
+   * the instance is no longer needed by the caller.
+   *
+   * @param notifyCertUpdates when true, the caller is interested in identity cert updates. When
+   *     false, the caller cannot depend on receiving the {@link Watcher#updateCertificate}
+   *     callbacks but may still receive these callbacks which should be ignored.
+   * @throws IllegalArgumentException in case of errors in processing config or the plugin is
+   *     incapable of sending cert updates when notifyCertUpdates is true.
+   * @throws UnsupportedOperationException if the plugin is incapable of sending cert updates when
+   *     notifyCertUpdates is true.
+   */
+  public synchronized Handle createOrGetProvider(
+      String certName,
+      String pluginName,
+      Object config,
+      Watcher watcher,
+      boolean notifyCertUpdates) {
+    if (!notifyCertUpdates) {
+      // we try to get a provider first for notifyCertUpdates==true always
+      try {
+        return createProviderHelper(certName, pluginName, config, watcher, true);
+      } catch (UnsupportedOperationException uoe) {
+        // ignore & log exception and fall thru to create a provider with actual value
+        logger.log(Level.FINE, "Trying to get provider for notifyCertUpdates==true", uoe);
+      }
+    }
+    return createProviderHelper(certName, pluginName, config, watcher, notifyCertUpdates);
+  }
+
+  private synchronized Handle createProviderHelper(
+      String certName,
+      String pluginName,
+      Object config,
+      Watcher watcher,
+      boolean notifyCertUpdates) {
+    CertProviderKey key = new CertProviderKey(certName, pluginName, notifyCertUpdates, config);
+    CertificateProvider provider = certProviderMap.get(key);
+    CertificateProvider.DistributorWatcher distWatcher = provider.getWatcher();
+    distWatcher.addWatcher(watcher);
+    return new Handle(key, watcher, provider);
+  }
+
+  /** Gets the CertificateProviderStore singleton instance. */
+  public static synchronized CertificateProviderStore getInstance() {
+    if (instance == null) {
+      instance = new CertificateProviderStore(CertificateProviderRegistry.getInstance());
+    }
+    return instance;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProvider.java
new file mode 100644
index 00000000000..304124cc7f2
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProvider.java
@@ -0,0 +1,253 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Status;
+import io.grpc.internal.SpiffeUtil;
+import io.grpc.internal.TimeProvider;
+import io.grpc.xds.internal.security.trust.CertificateUtils;
+import java.io.ByteArrayInputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.attribute.FileTime;
+import java.security.PrivateKey;
+import java.security.cert.X509Certificate;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+// TODO(sanjaypujare): abstract out common functionality into an an abstract superclass
+/** Implementation of {@link CertificateProvider} for file watching cert provider. */
+final class FileWatcherCertificateProvider extends CertificateProvider implements Runnable {
+  private static final Logger logger =
+      Logger.getLogger(FileWatcherCertificateProvider.class.getName());
+
+  private final ScheduledExecutorService scheduledExecutorService;
+  private final TimeProvider timeProvider;
+  private final Path certFile;
+  private final Path keyFile;
+  private final Path trustFile;
+  private final Path spiffeTrustMapFile;
+  private final long refreshIntervalInSeconds;
+  @VisibleForTesting ScheduledFuture<?> scheduledFuture;
+  private FileTime lastModifiedTimeCert;
+  private FileTime lastModifiedTimeKey;
+  private FileTime lastModifiedTimeRoot;
+  private FileTime lastModifiedTimespiffeTrustMap;
+  private boolean shutdown;
+
+  FileWatcherCertificateProvider(
+      DistributorWatcher watcher,
+      boolean notifyCertUpdates,
+      String certFile,
+      String keyFile,
+      String trustFile,
+      String spiffeTrustMapFile,
+      long refreshIntervalInSeconds,
+      ScheduledExecutorService scheduledExecutorService,
+      TimeProvider timeProvider) {
+    super(watcher, notifyCertUpdates);
+    this.scheduledExecutorService =
+        checkNotNull(scheduledExecutorService, "scheduledExecutorService");
+    this.timeProvider = checkNotNull(timeProvider, "timeProvider");
+    this.certFile = Paths.get(checkNotNull(certFile, "certFile"));
+    this.keyFile = Paths.get(checkNotNull(keyFile, "keyFile"));
+    checkArgument((trustFile != null || spiffeTrustMapFile != null),
+        "either trustFile or spiffeTrustMapFile must be present");
+    if (spiffeTrustMapFile != null) {
+      this.spiffeTrustMapFile = Paths.get(spiffeTrustMapFile);
+      this.trustFile = null;
+    } else {
+      this.spiffeTrustMapFile = null;
+      this.trustFile = Paths.get(trustFile);
+    }
+    this.refreshIntervalInSeconds = refreshIntervalInSeconds;
+  }
+
+  @Override
+  public void start() {
+    scheduleNextRefreshCertificate(/* delayInSeconds= */0);
+  }
+
+  @Override
+  public synchronized void close() {
+    shutdown = true;
+    scheduledExecutorService.shutdownNow();
+    if (scheduledFuture != null) {
+      scheduledFuture.cancel(true);
+      scheduledFuture = null;
+    }
+    getWatcher().close();
+  }
+
+  private synchronized void scheduleNextRefreshCertificate(long delayInSeconds) {
+    if (!shutdown) {
+      scheduledFuture = scheduledExecutorService.schedule(this, delayInSeconds, TimeUnit.SECONDS);
+    }
+  }
+
+  @VisibleForTesting
+  void checkAndReloadCertificates() {
+    try {
+      try {
+        FileTime currentCertTime = Files.getLastModifiedTime(certFile);
+        FileTime currentKeyTime = Files.getLastModifiedTime(keyFile);
+        if (!currentCertTime.equals(lastModifiedTimeCert)
+            && !currentKeyTime.equals(lastModifiedTimeKey)) {
+          byte[] certFileContents = Files.readAllBytes(certFile);
+          byte[] keyFileContents = Files.readAllBytes(keyFile);
+          FileTime currentCertTime2 = Files.getLastModifiedTime(certFile);
+          FileTime currentKeyTime2 = Files.getLastModifiedTime(keyFile);
+          if (currentCertTime2.equals(currentCertTime) && currentKeyTime2.equals(currentKeyTime)) {
+            try (ByteArrayInputStream certStream = new ByteArrayInputStream(certFileContents);
+                ByteArrayInputStream keyStream = new ByteArrayInputStream(keyFileContents)) {
+              PrivateKey privateKey = CertificateUtils.getPrivateKey(keyStream);
+              X509Certificate[] certs = CertificateUtils.toX509Certificates(certStream);
+              getWatcher().updateCertificate(privateKey, Arrays.asList(certs));
+            }
+            lastModifiedTimeCert = currentCertTime;
+            lastModifiedTimeKey = currentKeyTime;
+          }
+        }
+      } catch (Throwable t) {
+        generateErrorIfCurrentCertExpired(t);
+      }
+      try {
+        if (spiffeTrustMapFile != null) {
+          FileTime currentSpiffeTime = Files.getLastModifiedTime(spiffeTrustMapFile);
+          if (!currentSpiffeTime.equals(lastModifiedTimespiffeTrustMap)) {
+            SpiffeUtil.SpiffeBundle trustBundle = SpiffeUtil
+                .loadTrustBundleFromFile(spiffeTrustMapFile.toString());
+            getWatcher().updateSpiffeTrustMap(new HashMap<>(trustBundle.getBundleMap()));
+            lastModifiedTimespiffeTrustMap = currentSpiffeTime;
+          }
+        }
+      } catch (Throwable t) {
+        getWatcher().onError(Status.fromThrowable(t));
+      }
+      try {
+        if (trustFile != null) {
+          FileTime currentRootTime = Files.getLastModifiedTime(trustFile);
+          if (!currentRootTime.equals(lastModifiedTimeRoot)) {
+            byte[] rootFileContents = Files.readAllBytes(trustFile);
+            FileTime currentRootTime2 = Files.getLastModifiedTime(trustFile);
+            if (currentRootTime2.equals(currentRootTime)) {
+              try (ByteArrayInputStream rootStream = new ByteArrayInputStream(rootFileContents)) {
+                X509Certificate[] caCerts = CertificateUtils.toX509Certificates(rootStream);
+                getWatcher().updateTrustedRoots(Arrays.asList(caCerts));
+              }
+              lastModifiedTimeRoot = currentRootTime;
+            }
+          }
+        }
+      } catch (Throwable t) {
+        getWatcher().onError(Status.fromThrowable(t));
+      }
+    } finally {
+      scheduleNextRefreshCertificate(refreshIntervalInSeconds);
+    }
+  }
+
+  private void generateErrorIfCurrentCertExpired(Throwable t) {
+    X509Certificate currentCert = getWatcher().getLastIdentityCert();
+    if (currentCert != null) {
+      long delaySeconds = computeDelaySecondsToCertExpiry(currentCert);
+      if (delaySeconds > refreshIntervalInSeconds) {
+        logger.log(Level.FINER, "reload certificate error", t);
+        return;
+      }
+      // The current cert is going to expire in less than {@link refreshIntervalInSeconds}
+      // Clear the current cert and notify our watchers thru {@code onError}
+      getWatcher().clearValues();
+    }
+    getWatcher().onError(Status.fromThrowable(t));
+  }
+
+  @SuppressWarnings("JdkObsolete")
+  private long computeDelaySecondsToCertExpiry(X509Certificate lastCert) {
+    checkNotNull(lastCert, "lastCert");
+    return TimeUnit.NANOSECONDS.toSeconds(
+        TimeUnit.MILLISECONDS.toNanos(lastCert.getNotAfter().getTime())
+            - timeProvider.currentTimeNanos());
+  }
+
+  @Override
+  public void run() {
+    if (!shutdown) {
+      try {
+        checkAndReloadCertificates();
+      } catch (Throwable t) {
+        logger.log(Level.SEVERE, "Uncaught exception!", t);
+        if (t instanceof InterruptedException) {
+          Thread.currentThread().interrupt();
+        }
+      }
+    }
+  }
+
+  abstract static class Factory {
+    private static final Factory DEFAULT_INSTANCE =
+        new Factory() {
+          @Override
+          FileWatcherCertificateProvider create(
+              DistributorWatcher watcher,
+              boolean notifyCertUpdates,
+              String certFile,
+              String keyFile,
+              String trustFile,
+              String spiffeTrustMapFile,
+              long refreshIntervalInSeconds,
+              ScheduledExecutorService scheduledExecutorService,
+              TimeProvider timeProvider) {
+            return new FileWatcherCertificateProvider(
+                watcher,
+                notifyCertUpdates,
+                certFile,
+                keyFile,
+                trustFile,
+                spiffeTrustMapFile,
+                refreshIntervalInSeconds,
+                scheduledExecutorService,
+                timeProvider);
+          }
+        };
+
+    static Factory getInstance() {
+      return DEFAULT_INSTANCE;
+    }
+
+    abstract FileWatcherCertificateProvider create(
+        DistributorWatcher watcher,
+        boolean notifyCertUpdates,
+        String certFile,
+        String keyFile,
+        String trustFile,
+        String spiffeTrustMapFile,
+        long refreshIntervalInSeconds,
+        ScheduledExecutorService scheduledExecutorService,
+        TimeProvider timeProvider);
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProviderProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProviderProvider.java
new file mode 100644
index 00000000000..e4871dc4c84
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProviderProvider.java
@@ -0,0 +1,165 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import com.google.protobuf.Duration;
+import com.google.protobuf.util.Durations;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.JsonUtil;
+import io.grpc.internal.TimeProvider;
+import java.text.ParseException;
+import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+/**
+ * Provider of {@link FileWatcherCertificateProvider}s.
+ */
+public final class FileWatcherCertificateProviderProvider implements CertificateProviderProvider {
+
+  // TODO(lwge): Remove the old env var check once it's confirmed to be unused.
+  @VisibleForTesting
+  public static boolean enableSpiffe = GrpcUtil.getFlag("GRPC_EXPERIMENTAL_SPIFFE_TRUST_BUNDLE_MAP",
+      false) || GrpcUtil.getFlag("GRPC_EXPERIMENTAL_XDS_MTLS_SPIFFE", false);
+  private static final String CERT_FILE_KEY = "certificate_file";
+  private static final String KEY_FILE_KEY = "private_key_file";
+  private static final String ROOT_FILE_KEY = "ca_certificate_file";
+  private static final String SPIFFE_TRUST_MAP_FILE_KEY = "spiffe_trust_bundle_map_file";
+  private static final String REFRESH_INTERVAL_KEY = "refresh_interval";
+
+  @VisibleForTesting static final long REFRESH_INTERVAL_DEFAULT = 600L;
+
+
+  static final String FILE_WATCHER_PROVIDER_NAME = "file_watcher";
+
+  final FileWatcherCertificateProvider.Factory fileWatcherCertificateProviderFactory;
+  private final ScheduledExecutorServiceFactory scheduledExecutorServiceFactory;
+  private final TimeProvider timeProvider;
+
+  FileWatcherCertificateProviderProvider() {
+    this(
+        FileWatcherCertificateProvider.Factory.getInstance(),
+        ScheduledExecutorServiceFactory.DEFAULT_INSTANCE,
+        TimeProvider.SYSTEM_TIME_PROVIDER);
+  }
+
+  @VisibleForTesting
+  FileWatcherCertificateProviderProvider(
+      FileWatcherCertificateProvider.Factory fileWatcherCertificateProviderFactory,
+      ScheduledExecutorServiceFactory scheduledExecutorServiceFactory,
+      TimeProvider timeProvider) {
+    this.fileWatcherCertificateProviderFactory = fileWatcherCertificateProviderFactory;
+    this.scheduledExecutorServiceFactory = scheduledExecutorServiceFactory;
+    this.timeProvider = timeProvider;
+  }
+
+  @Override
+  public String getName() {
+    return FILE_WATCHER_PROVIDER_NAME;
+  }
+
+  @Override
+  public CertificateProvider createCertificateProvider(
+      Object config, CertificateProvider.DistributorWatcher watcher, boolean notifyCertUpdates) {
+
+    Config configObj = validateAndTranslateConfig(config);
+    return fileWatcherCertificateProviderFactory.create(
+        watcher,
+        notifyCertUpdates,
+        configObj.certFile,
+        configObj.keyFile,
+        configObj.rootFile,
+        configObj.spiffeTrustMapFile,
+        configObj.refrehInterval,
+        scheduledExecutorServiceFactory.create(),
+        timeProvider);
+  }
+
+  private static String checkForNullAndGet(Map<String, ?> map, String key) {
+    return checkNotNull(JsonUtil.getString(map, key), "'" + key + "' is required in the config");
+  }
+
+  private static Config validateAndTranslateConfig(Object config) {
+    checkArgument(config instanceof Map, "Only Map supported for config");
+    @SuppressWarnings("unchecked") Map<String, ?> map = (Map<String, ?>)config;
+
+    Config configObj = new Config();
+    configObj.certFile = checkForNullAndGet(map, CERT_FILE_KEY);
+    configObj.keyFile = checkForNullAndGet(map, KEY_FILE_KEY);
+    if (enableSpiffe) {
+      if (!map.containsKey(ROOT_FILE_KEY) && !map.containsKey(SPIFFE_TRUST_MAP_FILE_KEY)) {
+        throw new NullPointerException(
+            String.format("either '%s' or '%s' is required in the config",
+                ROOT_FILE_KEY, SPIFFE_TRUST_MAP_FILE_KEY));
+      }
+      if (map.containsKey(SPIFFE_TRUST_MAP_FILE_KEY)) {
+        configObj.spiffeTrustMapFile = JsonUtil.getString(map, SPIFFE_TRUST_MAP_FILE_KEY);
+      } else {
+        configObj.rootFile = JsonUtil.getString(map, ROOT_FILE_KEY);
+      }
+    } else {
+      configObj.rootFile = checkForNullAndGet(map, ROOT_FILE_KEY);
+    }
+    String refreshIntervalString = JsonUtil.getString(map, REFRESH_INTERVAL_KEY);
+    if (refreshIntervalString != null) {
+      try {
+        Duration duration = Durations.parse(refreshIntervalString);
+        configObj.refrehInterval = duration.getSeconds();
+        checkArgument(configObj.refrehInterval > 0L, "refreshInterval needs to be greater than 0");
+      } catch (ParseException e) {
+        throw new IllegalArgumentException(e);
+      }
+    }
+    if (configObj.refrehInterval == null) {
+      configObj.refrehInterval = REFRESH_INTERVAL_DEFAULT;
+    }
+    return configObj;
+  }
+
+  abstract static class ScheduledExecutorServiceFactory {
+
+    private static final ScheduledExecutorServiceFactory DEFAULT_INSTANCE =
+        new ScheduledExecutorServiceFactory() {
+
+          @Override
+          ScheduledExecutorService create() {
+            return Executors.newSingleThreadScheduledExecutor(
+                new ThreadFactoryBuilder()
+                    .setNameFormat("fileWatcher" + "-%d")
+                    .setDaemon(true)
+                    .build());
+          }
+        };
+
+    abstract ScheduledExecutorService create();
+  }
+
+  /** POJO class for storing various config values. */
+  @VisibleForTesting
+  static class Config {
+    String certFile;
+    String keyFile;
+    String rootFile;
+    String spiffeTrustMapFile;
+    Long refrehInterval;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/certprovider/IgnoreUpdatesWatcher.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/IgnoreUpdatesWatcher.java
new file mode 100644
index 00000000000..cd9d88be41b
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/IgnoreUpdatesWatcher.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2025 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.xds.internal.security.certprovider;
+
+import static java.util.Objects.requireNonNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Status;
+import java.security.PrivateKey;
+import java.security.cert.X509Certificate;
+import java.util.List;
+import java.util.Map;
+
+public final class IgnoreUpdatesWatcher implements CertificateProvider.Watcher {
+  private final CertificateProvider.Watcher delegate;
+  private final boolean ignoreRootCertUpdates;
+
+  public IgnoreUpdatesWatcher(
+      CertificateProvider.Watcher delegate, boolean ignoreRootCertUpdates) {
+    this.delegate = requireNonNull(delegate, "delegate");
+    this.ignoreRootCertUpdates = ignoreRootCertUpdates;
+  }
+
+  @Override
+  public void updateCertificate(PrivateKey key, List<X509Certificate> certChain) {
+    if (ignoreRootCertUpdates) {
+      delegate.updateCertificate(key, certChain);
+    }
+  }
+
+  @Override
+  public void updateTrustedRoots(List<X509Certificate> trustedRoots) {
+    if (!ignoreRootCertUpdates) {
+      delegate.updateTrustedRoots(trustedRoots);
+    }
+  }
+
+  @Override
+  public void updateSpiffeTrustMap(Map<String, List<X509Certificate>> spiffeTrustMap) {
+    if (!ignoreRootCertUpdates) {
+      delegate.updateSpiffeTrustMap(spiffeTrustMap);
+    }
+  }
+
+  @Override
+  public void onError(Status errorStatus) {
+    delegate.onError(errorStatus);
+  }
+
+  @VisibleForTesting
+  public CertificateProvider.Watcher getDelegate() {
+    return delegate;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/certprovider/SystemRootCertificateProvider.java b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/SystemRootCertificateProvider.java
new file mode 100644
index 00000000000..7c60f714e71
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/certprovider/SystemRootCertificateProvider.java
@@ -0,0 +1,71 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import io.grpc.Status;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.X509Certificate;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+
+/**
+ * An non-registered provider for CertProviderSslContextProvider to use the same code path for
+ * system root certs as provider-obtained certs.
+ */
+final class SystemRootCertificateProvider extends CertificateProvider {
+  public SystemRootCertificateProvider(CertificateProvider.Watcher watcher) {
+    super(new DistributorWatcher(), false);
+    getWatcher().addWatcher(watcher);
+  }
+
+  @Override
+  public void start() {
+    try {
+      TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(
+          TrustManagerFactory.getDefaultAlgorithm());
+      trustManagerFactory.init((KeyStore) null);
+
+      List<TrustManager> trustManagers = Arrays.asList(trustManagerFactory.getTrustManagers());
+      List<X509Certificate> rootCerts = trustManagers.stream()
+          .filter(X509TrustManager.class::isInstance)
+          .map(X509TrustManager.class::cast)
+          .map(trustManager -> Arrays.asList(trustManager.getAcceptedIssuers()))
+          .flatMap(Collection::stream)
+          .collect(Collectors.toList());
+      getWatcher().updateTrustedRoots(rootCerts);
+    } catch (KeyStoreException | NoSuchAlgorithmException ex) {
+      getWatcher().onError(Status.UNAVAILABLE
+          .withDescription("Could not load system root certs")
+          .withCause(ex));
+    }
+  }
+
+  @Override
+  public void close() {
+    // Unnecessary because there's no more callbacks, but do it for good measure
+    for (Watcher watcher : getWatcher().getDownstreamWatchers()) {
+      getWatcher().removeWatcher(watcher);
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/trust/CertificateUtils.java b/xds/src/main/java/io/grpc/xds/internal/security/trust/CertificateUtils.java
new file mode 100644
index 00000000000..ad030143f62
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/trust/CertificateUtils.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2019 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.xds.internal.security.trust;
+
+import io.grpc.internal.GrpcUtil;
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.PrivateKey;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+
+/**
+ * Contains certificate utility method(s).
+ */
+public final class CertificateUtils {
+  public static boolean isXdsSniEnabled = GrpcUtil.getFlag("GRPC_EXPERIMENTAL_XDS_SNI", true);
+  public static boolean useChannelAuthorityIfNoSniApplicable
+      = GrpcUtil.getFlag("GRPC_USE_CHANNEL_AUTHORITY_IF_NO_SNI_APPLICABLE", false);
+
+  /**
+   * Generates X509Certificate array from a file on disk.
+   *
+   * @param file a {@link File} containing the cert data
+   */
+  static X509Certificate[] toX509Certificates(File file) throws CertificateException, IOException {
+    try (FileInputStream fis = new FileInputStream(file);
+        BufferedInputStream bis = new BufferedInputStream(fis)) {
+      return toX509Certificates(bis);
+    }
+  }
+
+  /** Generates X509Certificate array from the {@link InputStream}. */
+  public static X509Certificate[] toX509Certificates(InputStream inputStream)
+      throws CertificateException, IOException {
+    return io.grpc.util.CertificateUtils.getX509Certificates(inputStream);
+  }
+
+  /** Generates a {@link PrivateKey} from the {@link InputStream}. */
+  public static PrivateKey getPrivateKey(InputStream inputStream)
+          throws Exception {
+    return io.grpc.util.CertificateUtils.getPrivateKey(inputStream);
+  }
+
+  private CertificateUtils() {}
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/trust/XdsTrustManagerFactory.java b/xds/src/main/java/io/grpc/xds/internal/security/trust/XdsTrustManagerFactory.java
new file mode 100644
index 00000000000..664c5dd9362
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/trust/XdsTrustManagerFactory.java
@@ -0,0 +1,201 @@
+/*
+ * Copyright 2019 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.xds.internal.security.trust;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Strings;
+import io.envoyproxy.envoy.config.core.v3.DataSource.SpecifierCase;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.netty.handler.ssl.util.SimpleTrustManagerFactory;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.CertStoreException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.net.ssl.ManagerFactoryParameters;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509ExtendedTrustManager;
+
+/**
+ * Factory class used to provide a {@link XdsX509TrustManager} for trust and SAN checks.
+ */
+public final class XdsTrustManagerFactory extends SimpleTrustManagerFactory {
+
+  private static final Logger logger = Logger.getLogger(XdsTrustManagerFactory.class.getName());
+  private XdsX509TrustManager xdsX509TrustManager;
+
+  /** Constructor constructs from a {@link CertificateValidationContext}. */
+  public XdsTrustManagerFactory(CertificateValidationContext certificateValidationContext)
+      throws CertificateException, IOException, CertStoreException {
+    this(
+        getTrustedCaFromCertContext(certificateValidationContext),
+        certificateValidationContext,
+        false,
+        false);
+  }
+
+  public XdsTrustManagerFactory(
+          X509Certificate[] certs, CertificateValidationContext staticCertificateValidationContext,
+          boolean autoSniSanValidation) throws CertStoreException {
+    this(certs, staticCertificateValidationContext, true, autoSniSanValidation);
+  }
+
+  public XdsTrustManagerFactory(Map<String, List<X509Certificate>> spiffeTrustMap,
+      CertificateValidationContext staticCertificateValidationContext, boolean autoSniSanValidation)
+      throws CertStoreException {
+    this(spiffeTrustMap, staticCertificateValidationContext, true, autoSniSanValidation);
+  }
+
+  private XdsTrustManagerFactory(
+      X509Certificate[] certs,
+      CertificateValidationContext certificateValidationContext,
+      boolean validationContextIsStatic,
+      boolean autoSniSanValidation)
+      throws CertStoreException {
+    if (validationContextIsStatic) {
+      checkArgument(
+          certificateValidationContext == null || !certificateValidationContext.hasTrustedCa()
+          || certificateValidationContext.hasSystemRootCerts(),
+          "only static certificateValidationContext expected");
+    }
+    xdsX509TrustManager = createX509TrustManager(
+        certs, certificateValidationContext, autoSniSanValidation);
+  }
+
+  private XdsTrustManagerFactory(
+      Map<String, List<X509Certificate>> spiffeTrustMap,
+      CertificateValidationContext certificateValidationContext,
+      boolean validationContextIsStatic,
+      boolean autoSniSanValidation)
+      throws CertStoreException {
+    if (validationContextIsStatic) {
+      checkArgument(
+          certificateValidationContext == null || !certificateValidationContext.hasTrustedCa(),
+          "only static certificateValidationContext expected");
+      xdsX509TrustManager = createX509TrustManager(
+          spiffeTrustMap, certificateValidationContext, autoSniSanValidation);
+    }
+  }
+
+  private static X509Certificate[] getTrustedCaFromCertContext(
+      CertificateValidationContext certificateValidationContext)
+      throws CertificateException, IOException {
+    final SpecifierCase specifierCase =
+        certificateValidationContext.getTrustedCa().getSpecifierCase();
+    if (specifierCase == SpecifierCase.FILENAME) {
+      String certsFile = certificateValidationContext.getTrustedCa().getFilename();
+      checkState(
+          !Strings.isNullOrEmpty(certsFile),
+          "trustedCa.file-name in certificateValidationContext cannot be empty");
+      return CertificateUtils.toX509Certificates(new File(certsFile));
+    } else if (specifierCase == SpecifierCase.INLINE_BYTES) {
+      try (InputStream is =
+          certificateValidationContext.getTrustedCa().getInlineBytes().newInput()) {
+        return CertificateUtils.toX509Certificates(is);
+      }
+    } else {
+      throw new IllegalArgumentException("Not supported: " + specifierCase);
+    }
+  }
+
+  @VisibleForTesting
+  static XdsX509TrustManager createX509TrustManager(
+      X509Certificate[] certs, CertificateValidationContext certContext,
+      boolean autoSniSanValidation)
+      throws CertStoreException {
+    return new XdsX509TrustManager(certContext, createTrustManager(certs), autoSniSanValidation);
+  }
+
+  @VisibleForTesting
+  static XdsX509TrustManager createX509TrustManager(
+      Map<String, List<X509Certificate>> spiffeTrustMapFile,
+      CertificateValidationContext certContext, boolean autoSniSanValidation)
+      throws CertStoreException {
+    checkNotNull(spiffeTrustMapFile, "spiffeTrustMapFile");
+    Map<String, X509ExtendedTrustManager> delegates = new HashMap<>();
+    for (Map.Entry<String, List<X509Certificate>> entry:spiffeTrustMapFile.entrySet()) {
+      delegates.put(entry.getKey(), createTrustManager(
+          entry.getValue().toArray(new X509Certificate[0])));
+    }
+    return new XdsX509TrustManager(certContext, delegates, autoSniSanValidation);
+  }
+
+  private static X509ExtendedTrustManager createTrustManager(X509Certificate[] certs)
+      throws CertStoreException {
+    TrustManagerFactory tmf = null;
+    try {
+      tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+      KeyStore ks = KeyStore.getInstance("PKCS12");
+      // perform a load to initialize KeyStore
+      ks.load(/* stream= */ null, /* password= */ null);
+      int i = 1;
+      for (X509Certificate cert : certs) {
+        // note: alias lookup uses toLowerCase(Locale.ENGLISH)
+        // so our alias needs to be all lower-case and unique
+        ks.setCertificateEntry("alias" + i, cert);
+        i++;
+      }
+      tmf.init(ks);
+    } catch (NoSuchAlgorithmException | KeyStoreException | IOException | CertificateException e) {
+      logger.log(Level.SEVERE, "createX509TrustManager", e);
+      throw new CertStoreException(e);
+    }
+    TrustManager[] tms = tmf.getTrustManagers();
+    X509ExtendedTrustManager myDelegate = null;
+    if (tms != null) {
+      for (TrustManager tm : tms) {
+        if (tm instanceof X509ExtendedTrustManager) {
+          myDelegate = (X509ExtendedTrustManager) tm;
+          break;
+        }
+      }
+    }
+    if (myDelegate == null) {
+      throw new CertStoreException("Native X509 TrustManager not found.");
+    }
+    return myDelegate;
+  }
+
+  @Override
+  protected void engineInit(KeyStore keyStore) throws Exception {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  protected void engineInit(ManagerFactoryParameters managerFactoryParameters) throws Exception {
+    throw new UnsupportedOperationException();
+  }
+
+  @Override
+  protected TrustManager[] engineGetTrustManagers() {
+    return new TrustManager[] {xdsX509TrustManager};
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/internal/security/trust/XdsX509TrustManager.java b/xds/src/main/java/io/grpc/xds/internal/security/trust/XdsX509TrustManager.java
new file mode 100644
index 00000000000..e8e7243ce0e
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/internal/security/trust/XdsX509TrustManager.java
@@ -0,0 +1,400 @@
+/*
+ * Copyright 2019 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.xds.internal.security.trust;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableMap;
+import com.google.re2j.Pattern;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.type.matcher.v3.RegexMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import io.grpc.internal.SpiffeUtil;
+import java.net.Socket;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateParsingException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.Nullable;
+import javax.net.ssl.SNIHostName;
+import javax.net.ssl.SNIServerName;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.X509ExtendedTrustManager;
+import javax.net.ssl.X509TrustManager;
+
+/**
+ * Extension of {@link X509ExtendedTrustManager} that implements verification of
+ * SANs (subject-alternate-names) against the list in CertificateValidationContext.
+ */
+final class XdsX509TrustManager extends X509ExtendedTrustManager implements X509TrustManager {
+
+  // ref: io.grpc.okhttp.internal.OkHostnameVerifier and
+  // sun.security.x509.GeneralNameInterface
+  private static final int ALT_DNS_NAME = 2;
+  private static final int ALT_URI_NAME = 6;
+  private static final int ALT_IPA_NAME = 7;
+
+  private final X509ExtendedTrustManager delegate;
+  private final Map<String, X509ExtendedTrustManager> spiffeTrustMapDelegates;
+  private final CertificateValidationContext certContext;
+  private final boolean autoSniSanValidation;
+
+  XdsX509TrustManager(@Nullable CertificateValidationContext certContext,
+                      X509ExtendedTrustManager delegate,
+                      boolean autoSniSanValidation) {
+    checkNotNull(delegate, "delegate");
+    this.certContext = certContext;
+    this.delegate = delegate;
+    this.spiffeTrustMapDelegates = null;
+    this.autoSniSanValidation = autoSniSanValidation;
+  }
+
+  XdsX509TrustManager(@Nullable CertificateValidationContext certContext,
+      Map<String, X509ExtendedTrustManager> spiffeTrustMapDelegates,
+      boolean autoSniSanValidation) {
+    checkNotNull(spiffeTrustMapDelegates, "spiffeTrustMapDelegates");
+    this.spiffeTrustMapDelegates = ImmutableMap.copyOf(spiffeTrustMapDelegates);
+    this.certContext = certContext;
+    this.delegate = null;
+    this.autoSniSanValidation = autoSniSanValidation;
+  }
+
+  private static boolean verifyDnsNameInPattern(
+      String altNameFromCert, StringMatcher sanToVerifyMatcher) {
+    if (Strings.isNullOrEmpty(altNameFromCert)) {
+      return false;
+    }
+    switch (sanToVerifyMatcher.getMatchPatternCase()) {
+      case EXACT:
+        return verifyDnsNameExact(
+            altNameFromCert, sanToVerifyMatcher.getExact(), sanToVerifyMatcher.getIgnoreCase());
+      case PREFIX:
+        return verifyDnsNamePrefix(
+            altNameFromCert, sanToVerifyMatcher.getPrefix(), sanToVerifyMatcher.getIgnoreCase());
+      case SUFFIX:
+        return verifyDnsNameSuffix(
+            altNameFromCert, sanToVerifyMatcher.getSuffix(), sanToVerifyMatcher.getIgnoreCase());
+      case CONTAINS:
+        return verifyDnsNameContains(
+            altNameFromCert, sanToVerifyMatcher.getContains(), sanToVerifyMatcher.getIgnoreCase());
+      case SAFE_REGEX:
+        return verifyDnsNameSafeRegex(altNameFromCert, sanToVerifyMatcher.getSafeRegex());
+      default:
+        throw new IllegalArgumentException(
+            "Unknown match-pattern-case " + sanToVerifyMatcher.getMatchPatternCase());
+    }
+  }
+
+  private static boolean verifyDnsNameSafeRegex(
+          String altNameFromCert, RegexMatcher sanToVerifySafeRegex) {
+    Pattern safeRegExMatch = Pattern.compile(sanToVerifySafeRegex.getRegex());
+    return safeRegExMatch.matches(altNameFromCert);
+  }
+
+  private static boolean verifyDnsNamePrefix(
+      String altNameFromCert, String sanToVerifyPrefix, boolean ignoreCase) {
+    if (Strings.isNullOrEmpty(sanToVerifyPrefix)) {
+      return false;
+    }
+    return ignoreCase
+        ? altNameFromCert.toLowerCase(Locale.ROOT).startsWith(
+            sanToVerifyPrefix.toLowerCase(Locale.ROOT))
+        : altNameFromCert.startsWith(sanToVerifyPrefix);
+  }
+
+  private static boolean verifyDnsNameSuffix(
+          String altNameFromCert, String sanToVerifySuffix, boolean ignoreCase) {
+    if (Strings.isNullOrEmpty(sanToVerifySuffix)) {
+      return false;
+    }
+    return ignoreCase
+            ? altNameFromCert.toLowerCase(Locale.ROOT).endsWith(
+                sanToVerifySuffix.toLowerCase(Locale.ROOT))
+            : altNameFromCert.endsWith(sanToVerifySuffix);
+  }
+
+  private static boolean verifyDnsNameContains(
+          String altNameFromCert, String sanToVerifySubstring, boolean ignoreCase) {
+    if (Strings.isNullOrEmpty(sanToVerifySubstring)) {
+      return false;
+    }
+    return ignoreCase
+            ? altNameFromCert.toLowerCase(Locale.ROOT).contains(
+                sanToVerifySubstring.toLowerCase(Locale.ROOT))
+            : altNameFromCert.contains(sanToVerifySubstring);
+  }
+
+  private static boolean verifyDnsNameExact(
+      String altNameFromCert, String sanToVerifyExact, boolean ignoreCase) {
+    if (Strings.isNullOrEmpty(sanToVerifyExact)) {
+      return false;
+    }
+    if (sanToVerifyExact.contains("*")) {
+      return verifyDnsNameWildcard(altNameFromCert, sanToVerifyExact, ignoreCase);
+    }
+    return ignoreCase
+        ? sanToVerifyExact.equalsIgnoreCase(altNameFromCert)
+        : sanToVerifyExact.equals(altNameFromCert);
+  }
+
+  private static boolean verifyDnsNameInSanList(
+      String altNameFromCert, List<StringMatcher> verifySanList) {
+    for (StringMatcher verifySan : verifySanList) {
+      if (verifyDnsNameInPattern(altNameFromCert, verifySan)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private static boolean verifyOneSanInList(List<?> entry, List<StringMatcher> verifySanList)
+      throws CertificateParsingException {
+    // from OkHostnameVerifier.getSubjectAltNames
+    if (entry == null || entry.size() < 2) {
+      throw new CertificateParsingException("Invalid SAN entry");
+    }
+    Integer altNameType = (Integer) entry.get(0);
+    if (altNameType == null) {
+      throw new CertificateParsingException("Invalid SAN entry: null altNameType");
+    }
+    switch (altNameType) {
+      case ALT_DNS_NAME:
+      case ALT_URI_NAME:
+      case ALT_IPA_NAME:
+        return verifyDnsNameInSanList((String) entry.get(1), verifySanList);
+      default:
+        return false;
+    }
+  }
+
+  // logic from Envoy::Extensions::TransportSockets::Tls::ContextImpl::verifySubjectAltName
+  private static void verifySubjectAltNameInLeaf(
+      X509Certificate cert, List<StringMatcher> verifyList) throws CertificateException {
+    Collection<List<?>> names = cert.getSubjectAlternativeNames();
+    if (names == null || names.isEmpty()) {
+      throw new CertificateException("Peer certificate SAN check failed");
+    }
+    for (List<?> name : names) {
+      if (verifyOneSanInList(name, verifyList)) {
+        return;
+      }
+    }
+    // at this point there's no match
+    throw new CertificateException("Peer certificate SAN check failed");
+  }
+
+  /**
+   * Verifies SANs in the peer cert chain against verify_subject_alt_name in the certContext.
+   * This is called from various check*Trusted methods.
+   */
+  @VisibleForTesting
+  void verifySubjectAltNameInChain(X509Certificate[] peerCertChain,
+      List<StringMatcher> verifyList) throws CertificateException {
+    if (certContext == null) {
+      return;
+    }
+    if (verifyList.isEmpty()) {
+      return;
+    }
+    if (peerCertChain == null || peerCertChain.length < 1) {
+      throw new CertificateException("Peer certificate(s) missing");
+    }
+    // verify SANs only in the top cert (leaf cert)
+    verifySubjectAltNameInLeaf(peerCertChain[0], verifyList);
+  }
+
+  @Override
+  @SuppressWarnings("deprecation") // gRFC A29 predates match_typed_subject_alt_names
+  public void checkClientTrusted(X509Certificate[] chain, String authType, Socket socket)
+      throws CertificateException {
+    chooseDelegate(chain).checkClientTrusted(chain, authType, socket);
+    verifySubjectAltNameInChain(chain, certContext != null
+        ? certContext.getMatchSubjectAltNamesList() : new ArrayList<>());
+  }
+
+  @Override
+  @SuppressWarnings("deprecation") // gRFC A29 predates match_typed_subject_alt_names
+  public void checkClientTrusted(X509Certificate[] chain, String authType, SSLEngine sslEngine)
+      throws CertificateException {
+    chooseDelegate(chain).checkClientTrusted(chain, authType, sslEngine);
+    verifySubjectAltNameInChain(chain, certContext != null
+        ? certContext.getMatchSubjectAltNamesList() : new ArrayList<>());
+  }
+
+  @Override
+  @SuppressWarnings("deprecation") // gRFC A29 predates match_typed_subject_alt_names
+  public void checkClientTrusted(X509Certificate[] chain, String authType)
+      throws CertificateException {
+    chooseDelegate(chain).checkClientTrusted(chain, authType);
+    verifySubjectAltNameInChain(chain, certContext != null
+        ? certContext.getMatchSubjectAltNamesList() : new ArrayList<>());
+  }
+
+  @Override
+  public void checkServerTrusted(X509Certificate[] chain, String authType, Socket socket)
+      throws CertificateException {
+    List<StringMatcher> sniMatchers = null;
+    if (socket instanceof SSLSocket) {
+      SSLSocket sslSocket = (SSLSocket) socket;
+      SSLParameters sslParams = sslSocket.getSSLParameters();
+      if (sslParams != null) {
+        sslParams.setEndpointIdentificationAlgorithm("");
+        sslSocket.setSSLParameters(sslParams);
+      }
+      sniMatchers = getAutoSniSanMatchers(sslParams);
+    }
+    if (sniMatchers.isEmpty() && certContext != null) {
+      @SuppressWarnings("deprecation") // gRFC A29 predates match_typed_subject_alt_names
+      List<StringMatcher> sniMatchersTmp = certContext.getMatchSubjectAltNamesList();
+      sniMatchers = sniMatchersTmp;
+    }
+    chooseDelegate(chain).checkServerTrusted(chain, authType, socket);
+    verifySubjectAltNameInChain(chain, sniMatchers);
+  }
+
+  @Override
+  public void checkServerTrusted(X509Certificate[] chain, String authType, SSLEngine sslEngine)
+      throws CertificateException {
+    List<StringMatcher> sniMatchers = null;
+    SSLParameters sslParams = sslEngine.getSSLParameters();
+    if (sslParams != null) {
+      sslParams.setEndpointIdentificationAlgorithm("");
+      sslEngine.setSSLParameters(sslParams);
+      sniMatchers = getAutoSniSanMatchers(sslParams);
+    }
+    if (sniMatchers.isEmpty() && certContext != null) {
+      @SuppressWarnings("deprecation") // gRFC A29 predates match_typed_subject_alt_names
+      List<StringMatcher> sniMatchersTmp = certContext.getMatchSubjectAltNamesList();
+      sniMatchers = sniMatchersTmp;
+    }
+    chooseDelegate(chain).checkServerTrusted(chain, authType, sslEngine);
+    verifySubjectAltNameInChain(chain, sniMatchers);
+  }
+
+  @Override
+  @SuppressWarnings("deprecation") // gRFC A29 predates match_typed_subject_alt_names
+  public void checkServerTrusted(X509Certificate[] chain, String authType)
+      throws CertificateException {
+    chooseDelegate(chain).checkServerTrusted(chain, authType);
+    verifySubjectAltNameInChain(chain, certContext != null
+        ? certContext.getMatchSubjectAltNamesList() : new ArrayList<>());
+  }
+
+  private List<StringMatcher> getAutoSniSanMatchers(SSLParameters sslParams) {
+    List<StringMatcher> sniNamesToMatch = new ArrayList<>();
+    if (CertificateUtils.isXdsSniEnabled && autoSniSanValidation) {
+      List<SNIServerName> serverNames = sslParams.getServerNames();
+      if (serverNames != null) {
+        for (SNIServerName serverName : serverNames) {
+          if (serverName instanceof SNIHostName) {
+            SNIHostName sniHostName = (SNIHostName) serverName;
+            String hostName = sniHostName.getAsciiName();
+            sniNamesToMatch.add(StringMatcher.newBuilder().setExact(hostName).build());
+          }
+        }
+      }
+    }
+    return sniNamesToMatch;
+  }
+
+  private X509ExtendedTrustManager chooseDelegate(X509Certificate[] chain)
+      throws CertificateException {
+    if (spiffeTrustMapDelegates != null) {
+      Optional<SpiffeUtil.SpiffeId> spiffeId = SpiffeUtil.extractSpiffeId(chain);
+      if (!spiffeId.isPresent()) {
+        throw new CertificateException("Failed to extract SPIFFE ID from peer leaf certificate");
+      }
+      String trustDomain = spiffeId.get().getTrustDomain();
+      if (!spiffeTrustMapDelegates.containsKey(trustDomain)) {
+        throw new CertificateException(String.format("Spiffe Trust Map doesn't contain trust"
+            + " domain '%s' from peer leaf certificate", trustDomain));
+      }
+      return spiffeTrustMapDelegates.get(trustDomain);
+    } else {
+      return delegate;
+    }
+  }
+
+  @Override
+  public X509Certificate[] getAcceptedIssuers() {
+    if (spiffeTrustMapDelegates != null) {
+      Set<X509Certificate> result = new HashSet<>();
+      for (X509ExtendedTrustManager tm: spiffeTrustMapDelegates.values()) {
+        result.addAll(Arrays.asList(tm.getAcceptedIssuers()));
+      }
+      return result.toArray(new X509Certificate[0]);
+    }
+    return delegate.getAcceptedIssuers();
+  }
+
+  private static boolean verifyDnsNameWildcard(
+      String altNameFromCert, String sanToVerify, boolean ignoreCase) {
+    String[] splitPattern = splitAtFirstDelimiter(ignoreCase
+        ? sanToVerify.toLowerCase(Locale.ROOT) : sanToVerify);
+    String[] splitDnsName = splitAtFirstDelimiter(ignoreCase
+        ? altNameFromCert.toLowerCase(Locale.ROOT) : altNameFromCert);
+    if (splitPattern == null || splitDnsName == null) {
+      return false;
+    }
+    if (splitDnsName[0].startsWith("xn--")) {
+      return false;
+    }
+    if (splitPattern[0].contains("*")
+        && !splitPattern[1].contains("*")
+        && !splitPattern[0].startsWith("xn--")) {
+      return splitDnsName[1].equals(splitPattern[1])
+          && labelWildcardMatch(splitDnsName[0], splitPattern[0]);
+    }
+    return false;
+  }
+
+  private static boolean labelWildcardMatch(String dnsLabel, String pattern) {
+    final char glob = '*';
+    // Check the special case of a single * pattern, as it's common.
+    if (pattern.equals("*")) {
+      return !dnsLabel.isEmpty();
+    }
+    int globIndex = pattern.indexOf(glob);
+    if (pattern.indexOf(glob, globIndex + 1) == -1) {
+      return dnsLabel.length() >= pattern.length() - 1
+          && dnsLabel.startsWith(pattern.substring(0, globIndex))
+          && dnsLabel.endsWith(pattern.substring(globIndex + 1));
+    }
+    return false;
+  }
+
+  @Nullable
+  private static String[] splitAtFirstDelimiter(String s) {
+    int index = s.indexOf('.');
+    if (index == -1) {
+      return null;
+    }
+    return new String[]{s.substring(0, index), s.substring(index + 1)};
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/orca/OrcaMetricReportingServerInterceptor.java b/xds/src/main/java/io/grpc/xds/orca/OrcaMetricReportingServerInterceptor.java
new file mode 100644
index 00000000000..1b767e0303c
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/orca/OrcaMetricReportingServerInterceptor.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright 2019 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.xds.orca;
+
+import com.github.xds.data.orca.v3.OrcaLoadReport;
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.Context;
+import io.grpc.Contexts;
+import io.grpc.ExperimentalApi;
+import io.grpc.ForwardingServerCall.SimpleForwardingServerCall;
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCall.Listener;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.Status;
+import io.grpc.protobuf.ProtoUtils;
+import io.grpc.services.CallMetricRecorder;
+import io.grpc.services.InternalCallMetricRecorder;
+import io.grpc.services.InternalMetricRecorder;
+import io.grpc.services.MetricRecorder;
+import io.grpc.services.MetricReport;
+import javax.annotation.Nullable;
+
+/**
+ * A {@link ServerInterceptor} that intercepts a {@link ServerCall} by running server-side RPC
+ * handling under a {@link Context} that records custom per-request metrics provided by server
+ * applications and sends to client side along with the response in the format of Open Request
+ * Cost Aggregation (ORCA).
+ *
+ * @since 1.23.0
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/9127")
+public final class OrcaMetricReportingServerInterceptor implements ServerInterceptor {
+
+  private static final OrcaMetricReportingServerInterceptor INSTANCE =
+      new OrcaMetricReportingServerInterceptor(null);
+
+  @VisibleForTesting
+  static final Metadata.Key<OrcaLoadReport> ORCA_ENDPOINT_LOAD_METRICS_KEY =
+      Metadata.Key.of(
+          "endpoint-load-metrics-bin",
+          ProtoUtils.metadataMarshaller(OrcaLoadReport.getDefaultInstance()));
+
+  @Nullable
+  private final MetricRecorder metricRecorder;
+
+  @VisibleForTesting
+  OrcaMetricReportingServerInterceptor(@Nullable MetricRecorder metricRecorder) {
+    this.metricRecorder = metricRecorder;
+  }
+
+  public static OrcaMetricReportingServerInterceptor getInstance() {
+    return INSTANCE;
+  }
+
+  /**
+   * Creates a new {@link OrcaMetricReportingServerInterceptor} instance with the given
+   * {@link MetricRecorder}. When both {@link CallMetricRecorder} and {@link MetricRecorder} exist,
+   * the metrics are merged such that per-request metrics from {@link CallMetricRecorder} takes a
+   * higher precedence compared to metrics from {@link MetricRecorder}.
+   */
+  public static OrcaMetricReportingServerInterceptor create(
+      @Nullable MetricRecorder metricRecorder) {
+    return new OrcaMetricReportingServerInterceptor(metricRecorder);
+  }
+
+  @Override
+  public <ReqT, RespT> Listener<ReqT> interceptCall(
+      ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+    Context ctx = Context.current();
+    CallMetricRecorder callMetricRecorder = InternalCallMetricRecorder.CONTEXT_KEY.get(ctx);
+    if (callMetricRecorder == null) {
+      callMetricRecorder = InternalCallMetricRecorder.newCallMetricRecorder();
+      ctx = ctx.withValue(InternalCallMetricRecorder.CONTEXT_KEY, callMetricRecorder);
+    }
+    final CallMetricRecorder finalCallMetricRecorder = callMetricRecorder;
+    ServerCall<ReqT, RespT> trailerAttachingCall =
+        new SimpleForwardingServerCall<ReqT, RespT>(call) {
+          @Override
+          public void close(Status status, Metadata trailers) {
+            OrcaLoadReport.Builder reportBuilder = metricRecorder != null ? fromInternalReport(
+                InternalMetricRecorder.getMetricReport(metricRecorder))
+                : OrcaLoadReport.newBuilder();
+            mergeMetrics(reportBuilder,
+                InternalCallMetricRecorder.finalizeAndDump2(finalCallMetricRecorder));
+            OrcaLoadReport report = reportBuilder.build();
+            if (!report.equals(OrcaLoadReport.getDefaultInstance())) {
+              trailers.put(ORCA_ENDPOINT_LOAD_METRICS_KEY, report);
+            }
+            super.close(status, trailers);
+          }
+        };
+    return Contexts.interceptCall(
+        ctx,
+        trailerAttachingCall,
+        headers,
+        next);
+  }
+
+  private static OrcaLoadReport.Builder fromInternalReport(MetricReport internalReport) {
+    return OrcaLoadReport.newBuilder()
+        .setCpuUtilization(internalReport.getCpuUtilization())
+        .setApplicationUtilization(internalReport.getApplicationUtilization())
+        .setMemUtilization(internalReport.getMemoryUtilization())
+        .setRpsFractional(internalReport.getQps())
+        .setEps(internalReport.getEps())
+        .putAllUtilization(internalReport.getUtilizationMetrics())
+        .putAllRequestCost(internalReport.getRequestCostMetrics())
+        .putAllNamedMetrics(internalReport.getNamedMetrics());
+  }
+
+  /**
+   * Modify the given {@link OrcaLoadReport.Builder} containing metrics for {@link MetricRecorder}
+   * such that metrics from the given {@link MetricReport} for {@link CallMetricRecorder} takes a
+   * higher precedence.
+   */
+  private static void mergeMetrics(
+      OrcaLoadReport.Builder metricRecorderReportBuilder,
+      MetricReport callMetricRecorderReport
+  ) {
+    metricRecorderReportBuilder.putAllUtilization(callMetricRecorderReport.getUtilizationMetrics())
+        .putAllRequestCost(callMetricRecorderReport.getRequestCostMetrics())
+        .putAllNamedMetrics(callMetricRecorderReport.getNamedMetrics());
+    // Overwrite only if the values from the given MetricReport for CallMetricRecorder are set
+    double cpu = callMetricRecorderReport.getCpuUtilization();
+    if (isReportValueSet(cpu)) {
+      metricRecorderReportBuilder.setCpuUtilization(cpu);
+    }
+    double applicationUtilization = callMetricRecorderReport.getApplicationUtilization();
+    if (isReportValueSet(applicationUtilization)) {
+      metricRecorderReportBuilder.setApplicationUtilization(applicationUtilization);
+    }
+    double mem = callMetricRecorderReport.getMemoryUtilization();
+    if (isReportValueSet(mem)) {
+      metricRecorderReportBuilder.setMemUtilization(mem);
+    }
+    double rps = callMetricRecorderReport.getQps();
+    if (isReportValueSet(rps)) {
+      metricRecorderReportBuilder.setRpsFractional(rps);
+    }
+    double eps = callMetricRecorderReport.getEps();
+    if (isReportValueSet(eps)) {
+      metricRecorderReportBuilder.setEps(eps);
+    }
+  }
+
+  private static boolean isReportValueSet(double value) {
+    return value != 0;
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/orca/OrcaOobUtil.java b/xds/src/main/java/io/grpc/xds/orca/OrcaOobUtil.java
new file mode 100644
index 00000000000..9ac06d362fc
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/orca/OrcaOobUtil.java
@@ -0,0 +1,604 @@
+/*
+ * Copyright 2019 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.xds.orca;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+
+import com.github.xds.data.orca.v3.OrcaLoadReport;
+import com.github.xds.service.orca.v3.OpenRcaServiceGrpc;
+import com.github.xds.service.orca.v3.OrcaLoadReportRequest;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.MoreObjects;
+import com.google.common.base.Objects;
+import com.google.common.base.Stopwatch;
+import com.google.common.base.Supplier;
+import com.google.protobuf.util.Durations;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.ClientCall;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.ExperimentalApi;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.SynchronizationContext.ScheduledHandle;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.ExponentialBackoffPolicy;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.services.MetricReport;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import io.grpc.util.ForwardingSubchannel;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+
+/**
+ * Utility class that provides method for {@link LoadBalancer} to install listeners to receive
+ * out-of-band backend metrics in the format of Open Request Cost Aggregation (ORCA).
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/9129")
+public final class OrcaOobUtil {
+
+  private OrcaOobUtil() {}
+
+  /**
+   * Creates a new {@link io.grpc.LoadBalancer.Helper} with provided
+   * {@link OrcaOobReportListener} installed
+   * to receive callback when an out-of-band ORCA report is received.
+   *
+   * <p>Example usages:
+   *
+   * <ul>
+   *   <li> Leaf policy (e.g., WRR policy)
+   *     <pre>
+   *       {@code
+   *       class WrrLoadbalancer extends LoadBalancer {
+   *         private final Helper originHelper;  // the original Helper
+   *
+   *         public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+   *           // listener implements the logic for WRR's usage of backend metrics.
+   *           OrcaReportingHelper orcaHelper =
+   *               OrcaOobUtil.newOrcaReportingHelper(originHelper);
+   *           Subchannel subchannel =
+   *               orcaHelper.createSubchannel(CreateSubchannelArgs.newBuilder()...);
+   *           OrcaOobUtil.setListener(
+   *              subchannel,
+   *              listener,
+   *              OrcaRerportingConfig.newBuilder().setReportInterval(30, SECOND).build());
+   *           ...
+   *         }
+   *       }
+   *       }
+   *     </pre>
+   *   </li>
+   *   <li> Delegating policy doing per-child-policy aggregation
+   *     <pre>
+   *       {@code
+   *       class XdsLoadBalancer extends LoadBalancer {
+   *         private final Helper orcaHelper;  // the original Helper
+   *
+   *         public XdsLoadBalancer(LoadBalancer.Helper helper) {
+   *           this.orcaHelper = OrcaUtil.newOrcaReportingHelper(helper);
+   *         }
+   *         private void createChildPolicy(
+   *             Locality locality, LoadBalancerProvider childPolicyProvider) {
+   *           // Each Locality has a child policy, and the parent does per-locality aggregation by
+   *           // summing everything up.
+   *
+   *           // Create an OrcaReportingHelperWrapper for each Locality.
+   *           // listener implements the logic for locality-level backend metric aggregation.
+   *           LoadBalancer childLb = childPolicyProvider.newLoadBalancer(
+   *             new ForwardingLoadBalancerHelper() {
+   *               public Subchannel createSubchannel(CreateSubchannelArgs args) {
+   *                 Subchannel subchannel = super.createSubchannel(args);
+   *                 OrcaOobUtil.setListener(subchannel, listener,
+   *                 OrcaReportingConfig.newBuilder().setReportInterval(30, SECOND).build());
+   *                 return subchannel;
+   *               }
+   *               public LoadBalancer.Helper delegate() {
+   *                 return orcaHelper;
+   *               }
+   *             });
+   *         }
+   *       }
+   *       }
+   *     </pre>
+   *   </li>
+   * </ul>
+   *
+   * @param delegate the delegate helper that provides essentials for establishing subchannels to
+   *     backends.
+   */
+  public static LoadBalancer.Helper newOrcaReportingHelper(LoadBalancer.Helper delegate) {
+    return newOrcaReportingHelper(
+        delegate,
+        new ExponentialBackoffPolicy.Provider(),
+        GrpcUtil.STOPWATCH_SUPPLIER);
+  }
+
+  @VisibleForTesting
+  static LoadBalancer.Helper newOrcaReportingHelper(
+      LoadBalancer.Helper delegate,
+      BackoffPolicy.Provider backoffPolicyProvider,
+      Supplier<Stopwatch> stopwatchSupplier) {
+    return new OrcaReportingHelper(delegate, backoffPolicyProvider, stopwatchSupplier);
+  }
+
+  /**
+   * The listener interface for receiving out-of-band ORCA reports from backends. The class that is
+   * interested in processing backend cost metrics implements this interface, and the object created
+   * with that class is registered with a component, using methods in {@link OrcaPerRequestUtil}.
+   * When an ORCA report is received, that object's {@code onLoadReport} method is invoked.
+   */
+  public interface OrcaOobReportListener {
+
+    /**
+     * Invoked when an out-of-band ORCA report is received.
+     *
+     * <p>Note this callback will be invoked from the {@link SynchronizationContext} of the
+     * delegated helper, implementations should not block.
+     *
+     * @param report load report in the format of grpc {@link MetricReport}.
+     */
+    void onLoadReport(MetricReport report);
+  }
+
+  static final Attributes.Key<SubchannelImpl> ORCA_REPORTING_STATE_KEY =
+      Attributes.Key.create("internal-orca-reporting-state");
+
+  /**
+   *  Update {@link OrcaOobReportListener} to receive Out-of-Band metrics report for the
+   *  particular subchannel connection, and set the configuration of receiving ORCA reports,
+   *  such as the interval of receiving reports. Set listener to null to remove listener, and the
+   *  config will have no effect.
+   *
+   * <p>This method needs to be called from the SynchronizationContext returned by the wrapped
+   * helper's {@link Helper#getSynchronizationContext()}.
+   *
+   * <p>Each load balancing policy must call this method to configure the backend load reporting.
+   * Otherwise, it will not receive ORCA reports.
+   *
+   * <p>If multiple load balancing policies configure reporting with different intervals, reports
+   * come with the minimum of those intervals.
+   *
+   * @param subchannel the server connected by this subchannel to receive the metrics.
+   *
+   * @param listener the callback upon receiving backend metrics from the Out-Of-Band stream.
+   *                 Setting to null to removes the listener from the subchannel.
+   *
+   * @param config the configuration to be set. It has no effect when listener is null.
+   *
+   */
+  public static void setListener(Subchannel subchannel, OrcaOobReportListener listener,
+                                 OrcaReportingConfig config) {
+    Attributes attributes = subchannel.getAttributes();
+    SubchannelImpl orcaSubchannel =
+        (attributes == null) ? null : attributes.get(ORCA_REPORTING_STATE_KEY);
+    if (orcaSubchannel == null) {
+      throw new IllegalArgumentException("Subchannel does not have orca Out-Of-Band stream enabled."
+          + " Try to use a subchannel created by OrcaOobUtil.OrcaHelper.");
+    }
+    orcaSubchannel.orcaState.setListener(orcaSubchannel, listener, config);
+  }
+
+  /**
+   * An {@link OrcaReportingHelper} wraps a delegated {@link LoadBalancer.Helper} with additional
+   * functionality to manage RPCs for out-of-band ORCA reporting for each backend it establishes
+   * connection to. Subchannels created through it will retrieve ORCA load reports if the server
+   * supports it.
+   */
+  static final class OrcaReportingHelper extends ForwardingLoadBalancerHelper {
+    private final LoadBalancer.Helper delegate;
+    private final SynchronizationContext syncContext;
+    private final BackoffPolicy.Provider backoffPolicyProvider;
+    private final Supplier<Stopwatch> stopwatchSupplier;
+
+    OrcaReportingHelper(
+        LoadBalancer.Helper delegate,
+        BackoffPolicy.Provider backoffPolicyProvider,
+        Supplier<Stopwatch> stopwatchSupplier) {
+      this.delegate = checkNotNull(delegate, "delegate");
+      this.backoffPolicyProvider = checkNotNull(backoffPolicyProvider, "backoffPolicyProvider");
+      this.stopwatchSupplier = checkNotNull(stopwatchSupplier, "stopwatchSupplier");
+      syncContext = checkNotNull(delegate.getSynchronizationContext(), "syncContext");
+    }
+
+    @Override
+    protected Helper delegate() {
+      return delegate;
+    }
+
+    @Override
+    public Subchannel createSubchannel(CreateSubchannelArgs args) {
+      syncContext.throwIfNotInThisSynchronizationContext();
+      Subchannel subchannel = super.createSubchannel(args);
+      Attributes attributes = subchannel.getAttributes();
+      SubchannelImpl orcaSubchannel =
+          (attributes == null) ? null : attributes.get(ORCA_REPORTING_STATE_KEY);
+      OrcaReportingState orcaState;
+      if (orcaSubchannel == null) {
+        // Only the first load balancing policy requesting ORCA reports instantiates an
+        // OrcaReportingState.
+        orcaState = new OrcaReportingState(syncContext, delegate().getScheduledExecutorService());
+      } else {
+        orcaState = orcaSubchannel.orcaState;
+      }
+      return new SubchannelImpl(subchannel, orcaState);
+    }
+
+    /**
+     * An {@link OrcaReportingState} is a client of ORCA service running on a single backend.
+     *
+     * <p>All methods are run from {@code syncContext}.
+     */
+    private final class OrcaReportingState implements SubchannelStateListener {
+
+      private final SynchronizationContext syncContext;
+      private final ScheduledExecutorService timeService;
+      private final Map<OrcaOobReportListener, OrcaReportingConfig> configs = new HashMap<>();
+      @Nullable private Subchannel subchannel;
+      @Nullable private ChannelLogger subchannelLogger;
+      @Nullable
+      private SubchannelStateListener stateListener;
+      @Nullable private BackoffPolicy backoffPolicy;
+      @Nullable private OrcaReportingStream orcaRpc;
+      @Nullable private ScheduledHandle retryTimer;
+      @Nullable private OrcaReportingConfig overallConfig;
+      private final Runnable retryTask =
+          new Runnable() {
+            @Override
+            public void run() {
+              startRpc();
+            }
+          };
+      private ConnectivityStateInfo state = ConnectivityStateInfo.forNonError(IDLE);
+      // True if server returned UNIMPLEMENTED.
+      private boolean disabled;
+      private boolean started;
+
+      OrcaReportingState(
+          SynchronizationContext syncContext,
+          ScheduledExecutorService timeService) {
+        this.syncContext = checkNotNull(syncContext, "syncContext");
+        this.timeService = checkNotNull(timeService, "timeService");
+      }
+
+      void init(Subchannel subchannel, SubchannelStateListener stateListener) {
+        checkState(this.subchannel == null, "init() already called");
+        this.subchannel = checkNotNull(subchannel, "subchannel");
+        this.subchannelLogger = checkNotNull(subchannel.getChannelLogger(), "subchannelLogger");
+        this.stateListener = checkNotNull(stateListener, "stateListener");
+        started = true;
+      }
+
+      void setListener(SubchannelImpl orcaSubchannel, OrcaOobReportListener listener,
+                       OrcaReportingConfig config) {
+        syncContext.execute(new Runnable() {
+          @Override
+          public void run() {
+            OrcaOobReportListener oldListener = orcaSubchannel.reportListener;
+            if (oldListener != null) {
+              configs.remove(oldListener);
+            }
+            if (listener != null) {
+              configs.put(listener, config);
+            }
+            orcaSubchannel.reportListener = listener;
+            setReportingConfig(config);
+          }
+        });
+      }
+
+      private void setReportingConfig(OrcaReportingConfig config) {
+        boolean reconfigured = false;
+        // Real reporting interval is the minimum of intervals requested by all participating
+        // helpers.
+        if (configs.isEmpty()) {
+          overallConfig = null;
+          reconfigured = true;
+        } else if (overallConfig == null) {
+          overallConfig = config.toBuilder().build();
+          reconfigured = true;
+        } else {
+          long minInterval = Long.MAX_VALUE;
+          for (OrcaReportingConfig c : configs.values()) {
+            if (c.getReportIntervalNanos() < minInterval) {
+              minInterval = c.getReportIntervalNanos();
+            }
+          }
+          if (overallConfig.getReportIntervalNanos() != minInterval) {
+            overallConfig = overallConfig.toBuilder()
+                .setReportInterval(minInterval, TimeUnit.NANOSECONDS).build();
+            reconfigured = true;
+          }
+        }
+        if (reconfigured) {
+          stopRpc("ORCA reporting reconfigured");
+          adjustOrcaReporting();
+        }
+      }
+
+      @Override
+      public void onSubchannelState(ConnectivityStateInfo newState) {
+        if (Objects.equal(state.getState(), READY) && !Objects.equal(newState.getState(), READY)) {
+          // A connection was lost.  We will reset disabled flag because ORCA service
+          // may be available on the new connection.
+          disabled = false;
+        }
+        state = newState;
+        adjustOrcaReporting();
+        // Propagate subchannel state update to downstream listeners.
+        stateListener.onSubchannelState(newState);
+      }
+
+      void adjustOrcaReporting() {
+        if (!disabled && overallConfig != null && Objects.equal(state.getState(), READY)) {
+          if (orcaRpc == null && !isRetryTimerPending()) {
+            startRpc();
+          }
+        } else {
+          stopRpc("Client stops ORCA reporting");
+          backoffPolicy = null;
+        }
+      }
+
+      void startRpc() {
+        checkState(orcaRpc == null, "previous orca reporting RPC has not been cleaned up");
+        checkState(subchannel != null, "init() not called");
+        subchannelLogger.log(
+            ChannelLogLevel.DEBUG, "Starting ORCA reporting for {0}", subchannel.getAllAddresses());
+        orcaRpc = new OrcaReportingStream(subchannel.asChannel(), stopwatchSupplier.get());
+        orcaRpc.start();
+      }
+
+      void stopRpc(String msg) {
+        if (orcaRpc != null) {
+          orcaRpc.cancel(msg);
+          orcaRpc = null;
+        }
+        if (retryTimer != null) {
+          retryTimer.cancel();
+          retryTimer = null;
+        }
+      }
+
+      boolean isRetryTimerPending() {
+        return retryTimer != null && retryTimer.isPending();
+      }
+
+      @Override
+      public String toString() {
+        return MoreObjects.toStringHelper(this)
+            .add("disabled", disabled)
+            .add("orcaRpc", orcaRpc)
+            .add("reportingConfig", overallConfig)
+            .add("connectivityState", state)
+            .toString();
+      }
+
+      private class OrcaReportingStream extends ClientCall.Listener<OrcaLoadReport> {
+
+        private final ClientCall<OrcaLoadReportRequest, OrcaLoadReport> call;
+        private final Stopwatch stopwatch;
+        private boolean callHasResponded;
+
+        OrcaReportingStream(Channel channel, Stopwatch stopwatch) {
+          call =
+              checkNotNull(channel, "channel")
+                  .newCall(OpenRcaServiceGrpc.getStreamCoreMetricsMethod(), CallOptions.DEFAULT);
+          this.stopwatch = checkNotNull(stopwatch, "stopwatch");
+        }
+
+        void start() {
+          stopwatch.reset().start();
+          call.start(this, new Metadata());
+          call.sendMessage(
+              OrcaLoadReportRequest.newBuilder()
+                  .setReportInterval(Durations.fromNanos(overallConfig.getReportIntervalNanos()))
+                  .build());
+          call.halfClose();
+          call.request(1);
+        }
+
+        @Override
+        public void onMessage(final OrcaLoadReport response) {
+          syncContext.execute(
+              new Runnable() {
+                @Override
+                public void run() {
+                  if (orcaRpc == OrcaReportingStream.this) {
+                    handleResponse(response);
+                  }
+                }
+              });
+        }
+
+        @Override
+        public void onClose(final Status status, Metadata trailers) {
+          syncContext.execute(
+              new Runnable() {
+                @Override
+                public void run() {
+                  if (orcaRpc == OrcaReportingStream.this) {
+                    orcaRpc = null;
+                    handleStreamClosed(status);
+                  }
+                }
+              });
+        }
+
+        void handleResponse(OrcaLoadReport response) {
+          callHasResponded = true;
+          backoffPolicy = null;
+          subchannelLogger.log(ChannelLogLevel.DEBUG, "Received an ORCA report: {0}", response);
+          MetricReport metricReport = OrcaPerRequestUtil.fromOrcaLoadReport(response);
+          for (OrcaOobReportListener listener : configs.keySet()) {
+            listener.onLoadReport(metricReport);
+          }
+          call.request(1);
+        }
+
+        void handleStreamClosed(Status status) {
+          if (Objects.equal(status.getCode(), Code.UNIMPLEMENTED)) {
+            disabled = true;
+            subchannelLogger.log(
+                ChannelLogLevel.ERROR,
+                "Backend {0} OpenRcaService is disabled. Server returned: {1}",
+                new Object[] {subchannel.getAllAddresses(), status});
+            subchannelLogger.log(ChannelLogLevel.ERROR, "OpenRcaService disabled: {0}", status);
+            return;
+          }
+          long delayNanos = 0;
+          // Backoff only when no response has been received.
+          if (!callHasResponded) {
+            if (backoffPolicy == null) {
+              backoffPolicy = backoffPolicyProvider.get();
+            }
+            delayNanos = backoffPolicy.nextBackoffNanos() - stopwatch.elapsed(TimeUnit.NANOSECONDS);
+          }
+          subchannelLogger.log(
+              ChannelLogLevel.DEBUG,
+              "ORCA reporting stream closed with {0}, backoff in {1} ns",
+              status,
+              delayNanos <= 0 ? 0 : delayNanos);
+          if (delayNanos <= 0) {
+            startRpc();
+          } else {
+            checkState(!isRetryTimerPending(), "Retry double scheduled");
+            retryTimer =
+                syncContext.schedule(retryTask, delayNanos, TimeUnit.NANOSECONDS, timeService);
+          }
+        }
+
+        void cancel(String msg) {
+          call.cancel(msg, null);
+        }
+
+        @Override
+        public String toString() {
+          return MoreObjects.toStringHelper(this)
+              .add("callStarted", call != null)
+              .add("callHasResponded", callHasResponded)
+              .toString();
+        }
+      }
+    }
+  }
+
+  @VisibleForTesting
+  static final class SubchannelImpl extends ForwardingSubchannel {
+    private final Subchannel delegate;
+    private final OrcaReportingHelper.OrcaReportingState orcaState;
+    @Nullable private OrcaOobReportListener reportListener;
+
+    SubchannelImpl(Subchannel delegate, OrcaReportingHelper.OrcaReportingState orcaState) {
+      this.delegate = checkNotNull(delegate, "delegate");
+      this.orcaState = checkNotNull(orcaState, "orcaState");
+    }
+
+    @Override
+    protected Subchannel delegate() {
+      return delegate;
+    }
+
+    @Override
+    public void start(SubchannelStateListener listener) {
+      if (!orcaState.started) {
+        orcaState.init(this, listener);
+        super.start(orcaState);
+      } else {
+        super.start(listener);
+      }
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return super.getAttributes().toBuilder().set(ORCA_REPORTING_STATE_KEY, this).build();
+    }
+  }
+
+  /** Configuration for out-of-band ORCA reporting service RPC. */
+  public static final class OrcaReportingConfig {
+
+    private final long reportIntervalNanos;
+
+    private OrcaReportingConfig(long reportIntervalNanos) {
+      this.reportIntervalNanos = reportIntervalNanos;
+    }
+
+    /** Creates a new builder. */
+    public static Builder newBuilder() {
+      return new Builder();
+    }
+
+    /** Returns the configured maximum interval of receiving out-of-band ORCA reports. */
+    public long getReportIntervalNanos() {
+      return reportIntervalNanos;
+    }
+
+    /** Returns a builder with the same initial values as this object. */
+    public Builder toBuilder() {
+      return newBuilder().setReportInterval(reportIntervalNanos, TimeUnit.NANOSECONDS);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("reportIntervalNanos", reportIntervalNanos)
+          .toString();
+    }
+
+    public static final class Builder {
+
+      private long reportIntervalNanos;
+
+      Builder() {}
+
+      /**
+       * Sets the maximum expected interval of receiving out-of-band ORCA report. The actual
+       * reporting interval might be smaller if there are other load balancing policies requesting
+       * for more frequent cost metric report.
+       *
+       * @param reportInterval the maximum expected interval of receiving periodical ORCA reports.
+       * @param unit time unit of {@code reportInterval} value.
+       */
+      public Builder setReportInterval(long reportInterval, TimeUnit unit) {
+        reportIntervalNanos = unit.toNanos(reportInterval);
+        return this;
+      }
+
+      /** Creates a new {@link OrcaReportingConfig} object. */
+      public OrcaReportingConfig build() {
+        return new OrcaReportingConfig(reportIntervalNanos);
+      }
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/orca/OrcaPerRequestUtil.java b/xds/src/main/java/io/grpc/xds/orca/OrcaPerRequestUtil.java
new file mode 100644
index 00000000000..814015ba93e
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/orca/OrcaPerRequestUtil.java
@@ -0,0 +1,281 @@
+/*
+ * Copyright 2019 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.xds.orca;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.github.xds.data.orca.v3.OrcaLoadReport;
+import com.google.common.annotations.VisibleForTesting;
+import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ClientStreamTracer.StreamInfo;
+import io.grpc.ExperimentalApi;
+import io.grpc.LoadBalancer;
+import io.grpc.Metadata;
+import io.grpc.internal.ForwardingClientStreamTracer;
+import io.grpc.protobuf.ProtoUtils;
+import io.grpc.services.InternalCallMetricRecorder;
+import io.grpc.services.MetricReport;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Utility class that provides method for {@link LoadBalancer} to install listeners to receive
+ * per-request backend cost metrics in the format of Open Request Cost Aggregation (ORCA).
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/9128")
+public abstract class OrcaPerRequestUtil {
+  private static final ClientStreamTracer NOOP_CLIENT_STREAM_TRACER = new ClientStreamTracer() {};
+  private static final ClientStreamTracer.Factory NOOP_CLIENT_STREAM_TRACER_FACTORY =
+      new ClientStreamTracer.Factory() {
+        @Override
+        public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+          return NOOP_CLIENT_STREAM_TRACER;
+        }
+      };
+  private static final OrcaPerRequestUtil DEFAULT_INSTANCE =
+      new OrcaPerRequestUtil() {
+        @Override
+        public ClientStreamTracer.Factory newOrcaClientStreamTracerFactory(
+            OrcaPerRequestReportListener listener) {
+          return newOrcaClientStreamTracerFactory(NOOP_CLIENT_STREAM_TRACER_FACTORY, listener);
+        }
+
+        @Override
+        public ClientStreamTracer.Factory newOrcaClientStreamTracerFactory(
+            ClientStreamTracer.Factory delegate, OrcaPerRequestReportListener listener) {
+          return new OrcaReportingTracerFactory(delegate, listener);
+        }
+      };
+
+  /**
+   * Gets an {@code OrcaPerRequestUtil} instance that provides actual implementation of
+   * {@link #newOrcaClientStreamTracerFactory}.
+   */
+  public static OrcaPerRequestUtil getInstance() {
+    return DEFAULT_INSTANCE;
+  }
+
+  /**
+   * Creates a new {@link io.grpc.ClientStreamTracer.Factory} with provided {@link
+   * OrcaPerRequestReportListener} installed to receive callback when a per-request ORCA report is
+   * received.
+   *
+   * <p>Example usages for leaf level policy (e.g., WRR policy)
+   *
+   * <pre>
+   *   {@code
+   *   class WrrPicker extends SubchannelPicker {
+   *
+   *     public PickResult pickSubchannel(PickSubchannelArgs args) {
+   *       Subchannel subchannel = ...  // WRR picking logic
+   *       return PickResult.withSubchannel(
+   *           subchannel,
+   *           OrcaPerRequestReportUtil.getInstance().newOrcaClientStreamTracerFactory(listener));
+   *     }
+   *   }
+   *   }
+   * </pre>
+   *
+   * @param listener contains the callback to be invoked when a per-request ORCA report is received.
+   */
+  public abstract ClientStreamTracer.Factory newOrcaClientStreamTracerFactory(
+      OrcaPerRequestReportListener listener);
+
+  /**
+   * Creates a new {@link io.grpc.ClientStreamTracer.Factory} with provided {@link
+   * OrcaPerRequestReportListener} installed to receive callback when a per-request ORCA report is
+   * received.
+   *
+   * <p>Example usages:
+   *
+   * <ul>
+   *   <li> Delegating policy (e.g., xDS)
+   *     <pre>
+   *       {@code
+   *       class XdsPicker extends SubchannelPicker {
+   *
+   *         public PickResult pickSubchannel(PickSubchannelArgs args) {
+   *           SubchannelPicker perLocalityPicker = ...  // locality picking logic
+   *           Result result = perLocalityPicker.pickSubchannel(args);
+   *           return PickResult.withSubchannel(
+   *               result.getSubchannel(),
+   *               OrcaPerRequestReportUtil.getInstance().newOrcaClientTracerFactory(
+   *                   result.getStreamTracerFactory(), listener));
+   *
+   *         }
+   *       }
+   *       }
+   *     </pre>
+   *   </li>
+   *   <li> Delegating policy with additional tracing logic
+   *     <pre>
+   *       {@code
+   *       class WrappingPicker extends SubchannelPicker {
+   *
+   *         public PickResult pickSubchannel(PickSubchannelArgs args) {
+   *           Result result = delegate.pickSubchannel(args);
+   *           return PickResult.withSubchannel(
+   *               result.getSubchannel(),
+   *               new ClientStreamTracer.Factory() {
+   *                 public ClientStreamTracer newClientStreamTracer(
+   *                     StreamInfo info, Metadata metadata) {
+   *                   ClientStreamTracer.Factory orcaTracerFactory =
+   *                       OrcaPerRequestReportUtil.getInstance().newOrcaClientStreamTracerFactory(
+   *                           result.getStreamTracerFactory(), listener);
+   *
+   *                   // Wrap the tracer from the delegate factory if you need to trace the
+   *                   // stream for your own.
+   *                   final ClientStreamTracer orcaTracer =
+   *                       orcaTracerFactory.newClientStreamTracer(info, metadata);
+   *
+   *                   return ForwardingClientStreamTracer() {
+   *                     protected ClientStreamTracer delegate() {
+   *                       return orcaTracer;
+   *                     }
+   *
+   *                     public void inboundMessage(int seqNo) {
+   *                       // Handle this event.
+   *                       ...
+   *                     }
+   *                   };
+   *                 }
+   *               });
+   *         }
+   *       }
+   *       }
+   *     </pre>
+   *   </li>
+   * </ul>
+   *
+   * @param delegate the delegate factory to produce other client stream tracing.
+   * @param listener contains the callback to be invoked when a per-request ORCA report is received.
+   */
+  public abstract ClientStreamTracer.Factory newOrcaClientStreamTracerFactory(
+      ClientStreamTracer.Factory delegate, OrcaPerRequestReportListener listener);
+
+  /**
+   * The listener interface for receiving per-request ORCA reports from backends. The class that is
+   * interested in processing backend cost metrics implements this interface, and the object created
+   * with that class is registered with a component, using methods in {@link OrcaPerRequestUtil}.
+   * When an ORCA report is received, that object's {@code onLoadReport} method is invoked.
+   */
+  public interface OrcaPerRequestReportListener {
+
+    /**
+     * Invoked when a per-request ORCA report is received.
+     *
+     * <p>Note this callback will be invoked from the network thread as the RPC finishes,
+     * implementations should not block.
+     *
+     * @param report load report in the format of grpc {@link MetricReport}.
+     */
+    void onLoadReport(MetricReport report);
+  }
+
+  /**
+   * An {@link OrcaReportingTracerFactory} wraps a delegated {@link ClientStreamTracer.Factory} with
+   * additional functionality to produce {@link ClientStreamTracer} instances that extract
+   * per-request ORCA reports and push to registered listeners for calls they trace.
+   */
+  @VisibleForTesting
+  static final class OrcaReportingTracerFactory extends
+      ClientStreamTracer.Factory {
+
+    @VisibleForTesting
+    static final Metadata.Key<OrcaLoadReport> ORCA_ENDPOINT_LOAD_METRICS_KEY =
+        Metadata.Key.of(
+            "endpoint-load-metrics-bin",
+            ProtoUtils.metadataMarshaller(OrcaLoadReport.getDefaultInstance()));
+
+    private static final CallOptions.Key<OrcaReportBroker> ORCA_REPORT_BROKER_KEY =
+        CallOptions.Key.create("internal-orca-report-broker");
+    private final ClientStreamTracer.Factory delegate;
+    private final OrcaPerRequestReportListener listener;
+
+    OrcaReportingTracerFactory(
+        ClientStreamTracer.Factory delegate, OrcaPerRequestReportListener listener) {
+      this.delegate = checkNotNull(delegate, "delegate");
+      this.listener = checkNotNull(listener, "listener");
+    }
+
+    @Override
+    public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata headers) {
+      OrcaReportBroker broker = info.getCallOptions().getOption(ORCA_REPORT_BROKER_KEY);
+      boolean augmented = false;
+      if (broker == null) {
+        broker = new OrcaReportBroker();
+        info =
+            info.toBuilder()
+                .setCallOptions(info.getCallOptions().withOption(ORCA_REPORT_BROKER_KEY, broker))
+                .build();
+        augmented = true;
+      }
+      broker.addListener(listener);
+      ClientStreamTracer tracer = delegate.newClientStreamTracer(info, headers);
+      if (augmented) {
+        final ClientStreamTracer currTracer = tracer;
+        final OrcaReportBroker currBroker = broker;
+        // The actual tracer that performs ORCA report deserialization.
+        tracer =
+            new ForwardingClientStreamTracer() {
+              @Override
+              protected ClientStreamTracer delegate() {
+                return currTracer;
+              }
+
+              @Override
+              public void inboundTrailers(Metadata trailers) {
+                OrcaLoadReport report = trailers.get(ORCA_ENDPOINT_LOAD_METRICS_KEY);
+                if (report != null) {
+                  currBroker.onReport(report);
+                }
+                delegate().inboundTrailers(trailers);
+              }
+            };
+      }
+      return tracer;
+    }
+  }
+
+  static MetricReport fromOrcaLoadReport(OrcaLoadReport loadReport) {
+    return InternalCallMetricRecorder.createMetricReport(loadReport.getCpuUtilization(),
+        loadReport.getApplicationUtilization(), loadReport.getMemUtilization(),
+        loadReport.getRpsFractional(), loadReport.getEps(), loadReport.getRequestCostMap(),
+        loadReport.getUtilizationMap(), loadReport.getNamedMetricsMap());
+  }
+
+  /**
+   * A container class to hold registered {@link OrcaPerRequestReportListener}s and invoke all of
+   * them when an {@link OrcaLoadReport} is received.
+   */
+  private static final class OrcaReportBroker {
+
+    private final List<OrcaPerRequestReportListener> listeners = new ArrayList<>();
+
+    void addListener(OrcaPerRequestReportListener listener) {
+      listeners.add(listener);
+    }
+
+    void onReport(OrcaLoadReport report) {
+      MetricReport metricReport = fromOrcaLoadReport(report);
+      for (OrcaPerRequestReportListener listener : listeners) {
+        listener.onLoadReport(metricReport);
+      }
+    }
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/orca/OrcaServiceImpl.java b/xds/src/main/java/io/grpc/xds/orca/OrcaServiceImpl.java
new file mode 100644
index 00000000000..2fe53ab6d1c
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/orca/OrcaServiceImpl.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright 2022 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.xds.orca;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import com.github.xds.data.orca.v3.OrcaLoadReport;
+import com.github.xds.service.orca.v3.OpenRcaServiceGrpc;
+import com.github.xds.service.orca.v3.OrcaLoadReportRequest;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.protobuf.util.Durations;
+import io.grpc.BindableService;
+import io.grpc.ExperimentalApi;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.SynchronizationContext;
+import io.grpc.services.InternalMetricRecorder;
+import io.grpc.services.MetricRecorder;
+import io.grpc.services.MetricReport;
+import io.grpc.stub.ServerCallStreamObserver;
+import io.grpc.stub.StreamObserver;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Implements a {@link BindableService} that generates Out-Of-Band server metrics.
+ * Register the returned service to the server, then a client can request for periodic load reports.
+ */
+@ExperimentalApi("https://github.com/grpc/grpc-java/issues/9006")
+public final class OrcaServiceImpl implements BindableService {
+  private static final Logger logger = Logger.getLogger(OrcaServiceImpl.class.getName());
+
+  /**
+   * Empty or invalid (non-positive) minInterval config in will be treated to this default value.
+   */
+  public static final long DEFAULT_MIN_REPORT_INTERVAL_NANOS = TimeUnit.SECONDS.toNanos(30);
+
+  private final long minReportIntervalNanos;
+  private final ScheduledExecutorService timeService;
+  @VisibleForTesting
+  final AtomicInteger clientCount = new AtomicInteger(0);
+  private MetricRecorder metricRecorder;
+  private final RealOrcaServiceImpl delegate = new RealOrcaServiceImpl();
+
+  /**
+   * Constructs a service to report server metrics. Config the report interval lower bound, the
+   * executor to run the timer, and a {@link MetricRecorder} that contains metrics data.
+   *
+   * @param minInterval configures the minimum metrics reporting interval for the
+   *        service. Bad configuration (non-positive) will be overridden to service default (30s).
+   *        Minimum metrics reporting interval means, if the setting in the client's
+   *        request is invalid (non-positive) or below this value, they will be treated
+   *        as this value.
+   */
+  public static BindableService createService(ScheduledExecutorService timeService,
+                                              MetricRecorder metricsRecorder,
+                                              long minInterval, TimeUnit timeUnit) {
+    return new OrcaServiceImpl(minInterval, timeUnit, timeService,  metricsRecorder);
+  }
+
+  public static BindableService createService(ScheduledExecutorService timeService,
+                                       MetricRecorder metricRecorder) {
+    return new OrcaServiceImpl(DEFAULT_MIN_REPORT_INTERVAL_NANOS, TimeUnit.NANOSECONDS,
+        timeService, metricRecorder);
+  }
+
+  private OrcaServiceImpl(long minInterval, TimeUnit timeUnit, ScheduledExecutorService timeService,
+                         MetricRecorder orcaMetrics) {
+    this.minReportIntervalNanos = minInterval > 0 ? timeUnit.toNanos(minInterval)
+        : DEFAULT_MIN_REPORT_INTERVAL_NANOS;
+    this.timeService = checkNotNull(timeService, "timeService");
+    this.metricRecorder = checkNotNull(orcaMetrics, "orcaMetrics");
+  }
+
+  @Override
+  public ServerServiceDefinition bindService() {
+    return delegate.bindService();
+  }
+
+  private final class RealOrcaServiceImpl extends OpenRcaServiceGrpc.OpenRcaServiceImplBase {
+    @Override
+    public void streamCoreMetrics(
+        OrcaLoadReportRequest request, StreamObserver<OrcaLoadReport> responseObserver) {
+      OrcaClient client = new OrcaClient(request, responseObserver);
+      client.run();
+      clientCount.getAndIncrement();
+    }
+  }
+
+  private final class OrcaClient implements Runnable {
+    final ServerCallStreamObserver<OrcaLoadReport> responseObserver;
+    SynchronizationContext.ScheduledHandle periodicReportTimer;
+    final long reportIntervalNanos;
+    final SynchronizationContext syncContext = new SynchronizationContext(
+        new Thread.UncaughtExceptionHandler() {
+          @Override
+          public void uncaughtException(Thread t, Throwable e) {
+            logger.log(Level.SEVERE, "Exception!" + e);
+          }
+        });
+
+    OrcaClient(OrcaLoadReportRequest request, StreamObserver<OrcaLoadReport> responseObserver) {
+      this.reportIntervalNanos = Math.max(Durations.toNanos(
+          checkNotNull(request).getReportInterval()), minReportIntervalNanos);
+      this.responseObserver = (ServerCallStreamObserver<OrcaLoadReport>) responseObserver;
+      this.responseObserver.setOnCancelHandler(new Runnable() {
+        @Override
+        public void run() {
+          syncContext.execute(new Runnable() {
+            @Override
+            public void run() {
+              if (periodicReportTimer != null) {
+                periodicReportTimer.cancel();
+              }
+              clientCount.getAndDecrement();
+            }
+          });
+        }
+      });
+    }
+
+    @Override
+    public void run() {
+      if (periodicReportTimer != null && periodicReportTimer.isPending()) {
+        return;
+      }
+      OrcaLoadReport report = generateMetricsReport();
+      responseObserver.onNext(report);
+      periodicReportTimer = syncContext.schedule(OrcaClient.this, reportIntervalNanos,
+          TimeUnit.NANOSECONDS, timeService);
+    }
+  }
+
+  private OrcaLoadReport generateMetricsReport() {
+    MetricReport internalReport =
+        InternalMetricRecorder.getMetricReport(metricRecorder);
+    return OrcaLoadReport.newBuilder().setCpuUtilization(internalReport.getCpuUtilization())
+        .setApplicationUtilization(internalReport.getApplicationUtilization())
+        .setMemUtilization(internalReport.getMemoryUtilization())
+        .setRpsFractional(internalReport.getQps())
+        .setEps(internalReport.getEps())
+        .putAllUtilization(internalReport.getUtilizationMetrics())
+        .build();
+  }
+}
diff --git a/xds/src/main/java/io/grpc/xds/package-info.java b/xds/src/main/java/io/grpc/xds/package-info.java
new file mode 100644
index 00000000000..9cc15cd5449
--- /dev/null
+++ b/xds/src/main/java/io/grpc/xds/package-info.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2019 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.
+ */
+
+/**
+ * Library for gRPC proxyless service mesh using Envoy xDS protocol.
+ *
+ * <p>The package currently includes a name resolver plugin and a family of load balancer plugins.
+ * A gRPC channel for a target with {@code "xds:"} scheme will load the plugins and a
+ * bootstrap file, and will communicate with an external control plane management server (e.g.
+ * Traffic Director) that speaks Envoy xDS protocol to retrieve routing, load balancing, load
+ * reporting configurations etc. for the channel. More features will be added.
+ *
+ * <p>The library is currently in an agile development phase, so API and design are subject to
+ * breaking changes.
+ */
+@io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/5288")
+package io.grpc.xds;
diff --git a/xds/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider b/xds/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
new file mode 100644
index 00000000000..04a2d9cf7a8
--- /dev/null
+++ b/xds/src/main/resources/META-INF/services/io.grpc.LoadBalancerProvider
@@ -0,0 +1,9 @@
+io.grpc.xds.CdsLoadBalancerProvider
+io.grpc.xds.PriorityLoadBalancerProvider
+io.grpc.xds.WeightedTargetLoadBalancerProvider
+io.grpc.xds.ClusterManagerLoadBalancerProvider
+io.grpc.xds.ClusterImplLoadBalancerProvider
+io.grpc.xds.LeastRequestLoadBalancerProvider
+io.grpc.xds.RingHashLoadBalancerProvider
+io.grpc.xds.WrrLocalityLoadBalancerProvider
+io.grpc.xds.WeightedRoundRobinLoadBalancerProvider
diff --git a/xds/src/main/resources/META-INF/services/io.grpc.NameResolverProvider b/xds/src/main/resources/META-INF/services/io.grpc.NameResolverProvider
new file mode 100644
index 00000000000..269cdd38801
--- /dev/null
+++ b/xds/src/main/resources/META-INF/services/io.grpc.NameResolverProvider
@@ -0,0 +1 @@
+io.grpc.xds.XdsNameResolverProvider
diff --git a/xds/src/main/resources/META-INF/services/io.grpc.xds.XdsCredentialsProvider b/xds/src/main/resources/META-INF/services/io.grpc.xds.XdsCredentialsProvider
new file mode 100644
index 00000000000..a51cd114737
--- /dev/null
+++ b/xds/src/main/resources/META-INF/services/io.grpc.xds.XdsCredentialsProvider
@@ -0,0 +1,3 @@
+io.grpc.xds.internal.GoogleDefaultXdsCredentialsProvider
+io.grpc.xds.internal.InsecureXdsCredentialsProvider
+io.grpc.xds.internal.TlsXdsCredentialsProvider
\ No newline at end of file
diff --git a/xds/src/test/java/io/grpc/xds/AddressFilterTest.java b/xds/src/test/java/io/grpc/xds/AddressFilterTest.java
new file mode 100644
index 00000000000..7d92e2ba1ce
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/AddressFilterTest.java
@@ -0,0 +1,61 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link AddressFilter}. */
+@RunWith(JUnit4.class)
+public class AddressFilterTest {
+  @Test
+  public void filterAddresses() {
+    Attributes.Key<String> key1 = Attributes.Key.create("key1");
+    Attributes attributes1 = Attributes.newBuilder().set(key1, "value1").build();
+    EquivalentAddressGroup eag0 = new EquivalentAddressGroup(new InetSocketAddress(8000));
+    EquivalentAddressGroup eag1 =
+        new EquivalentAddressGroup(new InetSocketAddress(8001), attributes1);
+    EquivalentAddressGroup eag2 = new EquivalentAddressGroup(new InetSocketAddress(8002));
+    EquivalentAddressGroup eag3 =
+        new EquivalentAddressGroup(
+            Arrays.<SocketAddress>asList(new InetSocketAddress(8003), new InetSocketAddress(8083)));
+    eag0 = AddressFilter.setPathFilter(eag0, Arrays.asList("A", "C"));
+    eag1 = AddressFilter.setPathFilter(eag1, Arrays.asList("A", "B"));
+    eag2 = AddressFilter.setPathFilter(eag2, Arrays.asList("D", "C"));
+    eag3 = AddressFilter.setPathFilter(eag3, Arrays.asList("A", "B"));
+
+    List<EquivalentAddressGroup> addresses =
+        AddressFilter.filter(Arrays.asList(eag0, eag1, eag2, eag3), "A");
+    assertThat(addresses).hasSize(3);
+    addresses = AddressFilter.filter(addresses, "B");
+    assertThat(addresses).hasSize(2);
+    EquivalentAddressGroup filteredAddress0 = addresses.get(0);
+    EquivalentAddressGroup filteredAddress1 = addresses.get(1);
+    assertThat(filteredAddress0.getAddresses()).containsExactlyElementsIn(eag1.getAddresses());
+    assertThat(filteredAddress0.getAttributes().get(key1)).isEqualTo("value1");
+    assertThat(filteredAddress1.getAddresses()).containsExactlyElementsIn(eag3.getAddresses());
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/CdsLoadBalancer2Test.java b/xds/src/test/java/io/grpc/xds/CdsLoadBalancer2Test.java
new file mode 100644
index 00000000000..928520aded7
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/CdsLoadBalancer2Test.java
@@ -0,0 +1,719 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.XdsLbPolicies.CLUSTER_IMPL_POLICY_NAME;
+import static io.grpc.xds.XdsLbPolicies.PRIORITY_POLICY_NAME;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_CDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_EDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_LDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_RDS;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.github.xds.type.v3.TypedStruct;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.protobuf.Any;
+import com.google.protobuf.Struct;
+import com.google.protobuf.UInt32Value;
+import com.google.protobuf.Value;
+import io.envoyproxy.envoy.config.cluster.v3.CircuitBreakers;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.cluster.v3.LoadBalancingPolicy;
+import io.envoyproxy.envoy.config.cluster.v3.LoadBalancingPolicy.Policy;
+import io.envoyproxy.envoy.config.cluster.v3.OutlierDetection;
+import io.envoyproxy.envoy.config.core.v3.Address;
+import io.envoyproxy.envoy.config.core.v3.AggregatedConfigSource;
+import io.envoyproxy.envoy.config.core.v3.ConfigSource;
+import io.envoyproxy.envoy.config.core.v3.RoutingPriority;
+import io.envoyproxy.envoy.config.core.v3.SelfConfigSource;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress;
+import io.envoyproxy.envoy.config.core.v3.TransportSocket;
+import io.envoyproxy.envoy.config.core.v3.TypedExtensionConfig;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;
+import io.envoyproxy.envoy.config.endpoint.v3.Endpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints;
+import io.envoyproxy.envoy.extensions.clusters.aggregate.v3.ClusterConfig;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext;
+import io.grpc.Attributes;
+import io.grpc.ChannelLogger;
+import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver;
+import io.grpc.NameResolverRegistry;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.FakeClock;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.util.GracefulSwitchLoadBalancerAccessor;
+import io.grpc.xds.CdsLoadBalancerProvider.CdsConfig;
+import io.grpc.xds.ClusterImplLoadBalancerProvider.ClusterImplConfig;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Tests for {@link CdsLoadBalancer2}.
+ */
+@RunWith(JUnit4.class)
+public class CdsLoadBalancer2Test {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+  @Rule
+  public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+
+  private static final String SERVER_NAME = "example.com";
+  private static final String CLUSTER = "cluster-foo.googleapis.com";
+  private static final String EDS_SERVICE_NAME = "backend-service-1.googleapis.com";
+  private static final String NODE_ID = "node-id";
+  private final io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext upstreamTlsContext =
+      CommonTlsContextTestsUtil.buildUpstreamTlsContext("cert-instance-name", true);
+  private static final Cluster EDS_CLUSTER = Cluster.newBuilder()
+      .setName(CLUSTER)
+      .setType(Cluster.DiscoveryType.EDS)
+      .setEdsClusterConfig(Cluster.EdsClusterConfig.newBuilder()
+          .setServiceName(EDS_SERVICE_NAME)
+          .setEdsConfig(ConfigSource.newBuilder()
+            .setAds(AggregatedConfigSource.newBuilder())))
+      .build();
+
+  private final FakeClock fakeClock = new FakeClock();
+  private final LoadBalancerRegistry lbRegistry = new LoadBalancerRegistry();
+  private final List<FakeLoadBalancer> childBalancers = new ArrayList<>();
+  private final XdsTestControlPlaneService controlPlaneService = new XdsTestControlPlaneService();
+  private final XdsClient xdsClient = XdsTestUtils.createXdsClient(
+      Arrays.asList("control-plane.example.com"),
+      serverInfo -> new GrpcXdsTransportFactory.GrpcXdsTransport(
+          InProcessChannelBuilder
+            .forName(serverInfo.target())
+            .directExecutor()
+            .build()),
+      fakeClock);
+  private XdsDependencyManager xdsDepManager;
+
+  @Mock
+  private Helper helper;
+  @Captor
+  private ArgumentCaptor<SubchannelPicker> pickerCaptor;
+  private CdsLoadBalancer2 loadBalancer;
+  private XdsConfig lastXdsConfig;
+
+  @Before
+  public void setUp() throws Exception {
+    lbRegistry.register(new FakeLoadBalancerProvider(PRIORITY_POLICY_NAME));
+    lbRegistry.register(new FakeLoadBalancerProvider(CLUSTER_IMPL_POLICY_NAME));
+    lbRegistry.register(new FakeLoadBalancerProvider("round_robin"));
+    lbRegistry.register(new FakeLoadBalancerProvider("outlier_detection_experimental"));
+    lbRegistry.register(
+        new FakeLoadBalancerProvider("ring_hash_experimental", new RingHashLoadBalancerProvider()));
+    lbRegistry.register(new FakeLoadBalancerProvider("least_request_experimental",
+        new LeastRequestLoadBalancerProvider()));
+    lbRegistry.register(new FakeLoadBalancerProvider("wrr_locality_experimental",
+          new WrrLocalityLoadBalancerProvider()));
+    CdsLoadBalancerProvider cdsLoadBalancerProvider = new CdsLoadBalancerProvider(lbRegistry);
+    lbRegistry.register(cdsLoadBalancerProvider);
+    loadBalancer = (CdsLoadBalancer2) cdsLoadBalancerProvider.newLoadBalancer(helper);
+
+    cleanupRule.register(InProcessServerBuilder
+        .forName("control-plane.example.com")
+        .addService(controlPlaneService)
+        .directExecutor()
+        .build()
+        .start());
+
+    SynchronizationContext syncContext = new SynchronizationContext((t, e) -> {
+      throw new AssertionError(e);
+    });
+    when(helper.getSynchronizationContext()).thenReturn(syncContext);
+    when(helper.getScheduledExecutorService()).thenReturn(fakeClock.getScheduledExecutorService());
+
+    NameResolver.Args nameResolverArgs = NameResolver.Args.newBuilder()
+        .setDefaultPort(8080)
+        .setProxyDetector((address) -> null)
+        .setSynchronizationContext(syncContext)
+        .setServiceConfigParser(mock(NameResolver.ServiceConfigParser.class))
+        .setChannelLogger(mock(ChannelLogger.class))
+        .setScheduledExecutorService(fakeClock.getScheduledExecutorService())
+        .setNameResolverRegistry(new NameResolverRegistry())
+        .build();
+
+    xdsDepManager = new XdsDependencyManager(
+        xdsClient,
+        syncContext,
+        SERVER_NAME,
+        SERVER_NAME,
+        nameResolverArgs);
+
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_LDS, ImmutableMap.of(
+        SERVER_NAME, ControlPlaneRule.buildClientListener(SERVER_NAME, "my-route")));
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_RDS, ImmutableMap.of(
+        "my-route", XdsTestUtils.buildRouteConfiguration(SERVER_NAME, "my-route", CLUSTER)));
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, ControlPlaneRule.buildClusterLoadAssignment(
+            "127.0.0.1", "", 1234, EDS_SERVICE_NAME)));
+  }
+
+  @After
+  public void tearDown() {
+    if (loadBalancer != null) {
+      shutdownLoadBalancer();
+    }
+    assertThat(childBalancers).isEmpty();
+
+    if (xdsDepManager != null) {
+      xdsDepManager.shutdown();
+    }
+    xdsClient.shutdown();
+  }
+
+  private void shutdownLoadBalancer() {
+    LoadBalancer lb = this.loadBalancer;
+    this.loadBalancer = null; // Must avoid calling acceptResolvedAddresses after shutdown
+    lb.shutdown();
+  }
+
+  @Test
+  public void discoverTopLevelCluster() {
+    Cluster cluster = Cluster.newBuilder()
+        .setName(CLUSTER)
+        .setType(Cluster.DiscoveryType.EDS)
+        .setEdsClusterConfig(Cluster.EdsClusterConfig.newBuilder()
+          .setServiceName(EDS_SERVICE_NAME)
+          .setEdsConfig(ConfigSource.newBuilder()
+            .setAds(AggregatedConfigSource.newBuilder())))
+        .setLbPolicy(Cluster.LbPolicy.ROUND_ROBIN)
+        .setLrsServer(ConfigSource.newBuilder()
+          .setSelf(SelfConfigSource.getDefaultInstance()))
+        .setCircuitBreakers(CircuitBreakers.newBuilder()
+            .addThresholds(CircuitBreakers.Thresholds.newBuilder()
+              .setPriority(RoutingPriority.DEFAULT)
+              .setMaxRequests(UInt32Value.newBuilder().setValue(100))))
+        .setTransportSocket(TransportSocket.newBuilder()
+            .setName("envoy.transport_sockets.tls")
+            .setTypedConfig(Any.pack(UpstreamTlsContext.newBuilder()
+                .setCommonTlsContext(upstreamTlsContext.getCommonTlsContext())
+                .build())))
+        .setOutlierDetection(OutlierDetection.getDefaultInstance())
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(CLUSTER, cluster));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);
+  }
+
+  @Test
+  public void nonAggregateCluster_resourceNotExist_returnErrorPicker() {
+    startXdsDepManager();
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    String expectedDescription = "Error retrieving CDS resource " + CLUSTER + ": NOT_FOUND. "
+        + "Details: Timed out waiting for resource " + CLUSTER
+        + " from xDS server nodeID: " + NODE_ID;
+    Status unavailable = Status.UNAVAILABLE.withDescription(expectedDescription);
+    assertPickerStatus(pickerCaptor.getValue(), unavailable);
+    assertThat(childBalancers).isEmpty();
+  }
+
+  @Test
+  public void nonAggregateCluster_resourceUpdate() {
+    lbRegistry.register(new PriorityLoadBalancerProvider());
+    Cluster cluster = EDS_CLUSTER.toBuilder()
+        .setCircuitBreakers(CircuitBreakers.newBuilder()
+            .addThresholds(CircuitBreakers.Thresholds.newBuilder()
+              .setPriority(RoutingPriority.DEFAULT)
+              .setMaxRequests(UInt32Value.newBuilder().setValue(100))))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(CLUSTER, cluster));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    ClusterImplConfig childLbConfig = (ClusterImplConfig) childBalancer.config;
+    assertThat(childLbConfig.cluster).isEqualTo(CLUSTER);
+    assertThat(childLbConfig.maxConcurrentRequests).isEqualTo(100L);
+
+    cluster = EDS_CLUSTER.toBuilder()
+        .setCircuitBreakers(CircuitBreakers.newBuilder()
+            .addThresholds(CircuitBreakers.Thresholds.newBuilder()
+              .setPriority(RoutingPriority.DEFAULT)
+              .setMaxRequests(UInt32Value.newBuilder().setValue(200))))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(CLUSTER, cluster));
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    childBalancer = Iterables.getOnlyElement(childBalancers);
+    childLbConfig = (ClusterImplConfig) childBalancer.config;
+    assertThat(childLbConfig.maxConcurrentRequests).isEqualTo(200L);
+  }
+
+  @Test
+  public void nonAggregateCluster_resourceRevoked() {
+    lbRegistry.register(new PriorityLoadBalancerProvider());
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(CLUSTER, EDS_CLUSTER));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    ClusterImplConfig childLbConfig = (ClusterImplConfig) childBalancer.config;
+    assertThat(childLbConfig.cluster).isEqualTo(CLUSTER);
+
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of());
+
+    assertThat(childBalancer.shutdown).isTrue();
+    String expectedDescription = "Error retrieving CDS resource " + CLUSTER + ": NOT_FOUND. "
+        + "Details: Resource " + CLUSTER + " does not exist nodeID: " + NODE_ID;
+    Status unavailable = Status.UNAVAILABLE.withDescription(expectedDescription);
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    assertPickerStatus(pickerCaptor.getValue(), unavailable);
+    assertThat(childBalancer.shutdown).isTrue();
+    assertThat(childBalancers).isEmpty();
+  }
+
+  @Test
+  public void dynamicCluster() {
+    String clusterName = "cluster2";
+    Cluster cluster = EDS_CLUSTER.toBuilder()
+        .setName(clusterName)
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        clusterName, cluster,
+        CLUSTER, Cluster.newBuilder().setName(CLUSTER).build()));
+    startXdsDepManager(new CdsConfig(clusterName, /*dynamic=*/ true));
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);
+
+    assertThat(this.lastXdsConfig.getClusters()).containsKey(clusterName);
+    shutdownLoadBalancer();
+    assertThat(this.lastXdsConfig.getClusters()).doesNotContainKey(clusterName);
+  }
+
+  @Test
+  public void discoverAggregateCluster_createsPriorityLbPolicy() {
+    CdsLoadBalancerProvider cdsLoadBalancerProvider = new CdsLoadBalancerProvider(lbRegistry);
+    lbRegistry.register(cdsLoadBalancerProvider);
+    loadBalancer = (CdsLoadBalancer2) cdsLoadBalancerProvider.newLoadBalancer(helper);
+
+    String cluster1 = "cluster-01.googleapis.com";
+    String cluster2 = "cluster-02.googleapis.com";
+    String cluster3 = "cluster-03.googleapis.com";
+    String cluster4 = "cluster-04.googleapis.com";
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        // CLUSTER (aggr.) -> [cluster1 (aggr.), cluster2 (logical DNS), cluster3 (EDS)]
+        CLUSTER, Cluster.newBuilder()
+          .setName(CLUSTER)
+          .setClusterType(Cluster.CustomClusterType.newBuilder()
+            .setName("envoy.clusters.aggregate")
+            .setTypedConfig(Any.pack(ClusterConfig.newBuilder()
+                .addClusters(cluster1)
+                .addClusters(cluster2)
+                .addClusters(cluster3)
+                .build())))
+          .setLbPolicy(Cluster.LbPolicy.RING_HASH)
+          .build(),
+        // cluster1 (aggr.) -> [cluster3 (EDS), cluster4 (EDS)]
+        cluster1, Cluster.newBuilder()
+          .setName(cluster1)
+          .setClusterType(Cluster.CustomClusterType.newBuilder()
+            .setName("envoy.clusters.aggregate")
+            .setTypedConfig(Any.pack(ClusterConfig.newBuilder()
+                .addClusters(cluster3)
+                .addClusters(cluster4)
+                .build())))
+          .build(),
+        cluster2, Cluster.newBuilder()
+          .setName(cluster2)
+          .setType(Cluster.DiscoveryType.LOGICAL_DNS)
+          .setLoadAssignment(ClusterLoadAssignment.newBuilder()
+            .addEndpoints(LocalityLbEndpoints.newBuilder()
+              .addLbEndpoints(LbEndpoint.newBuilder()
+                .setEndpoint(Endpoint.newBuilder()
+                  .setAddress(Address.newBuilder()
+                    .setSocketAddress(SocketAddress.newBuilder()
+                      .setAddress("dns.example.com")
+                      .setPortValue(1111)))))))
+          .build(),
+        cluster3, EDS_CLUSTER.toBuilder()
+            .setName(cluster3)
+            .setCircuitBreakers(CircuitBreakers.newBuilder()
+                .addThresholds(CircuitBreakers.Thresholds.newBuilder()
+                  .setPriority(RoutingPriority.DEFAULT)
+                  .setMaxRequests(UInt32Value.newBuilder().setValue(100))))
+            .build(),
+        cluster4, EDS_CLUSTER.toBuilder().setName(cluster4).build()));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);
+    PriorityLoadBalancerProvider.PriorityLbConfig childLbConfig =
+            (PriorityLoadBalancerProvider.PriorityLbConfig) childBalancer.config;
+    assertThat(childLbConfig.priorities).hasSize(3);
+    assertThat(childLbConfig.priorities.get(0)).isEqualTo(cluster3);
+    assertThat(childLbConfig.priorities.get(1)).isEqualTo(cluster4);
+    assertThat(childLbConfig.priorities.get(2)).isEqualTo(cluster2);
+    assertThat(childLbConfig.childConfigs).hasSize(3);
+    PriorityLoadBalancerProvider.PriorityLbConfig.PriorityChildConfig childConfig3 =
+            childLbConfig.childConfigs.get(cluster3);
+    assertThat(
+        GracefulSwitchLoadBalancerAccessor.getChildProvider(childConfig3.childConfig)
+            .getPolicyName())
+        .isEqualTo("cds_experimental");
+    PriorityLoadBalancerProvider.PriorityLbConfig.PriorityChildConfig childConfig4 =
+        childLbConfig.childConfigs.get(cluster4);
+    assertThat(
+        GracefulSwitchLoadBalancerAccessor.getChildProvider(childConfig4.childConfig)
+            .getPolicyName())
+        .isEqualTo("cds_experimental");
+    PriorityLoadBalancerProvider.PriorityLbConfig.PriorityChildConfig childConfig2 =
+            childLbConfig.childConfigs.get(cluster2);
+    assertThat(
+        GracefulSwitchLoadBalancerAccessor.getChildProvider(childConfig2.childConfig)
+            .getPolicyName())
+        .isEqualTo("cds_experimental");
+  }
+
+  @Test
+  // Both priorities will get tried using real priority LB policy.
+  public void discoverAggregateCluster_testChildCdsLbPolicyParsing() {
+    lbRegistry.register(new PriorityLoadBalancerProvider());
+    CdsLoadBalancerProvider cdsLoadBalancerProvider = new CdsLoadBalancerProvider(lbRegistry);
+    lbRegistry.register(cdsLoadBalancerProvider);
+    loadBalancer = (CdsLoadBalancer2) cdsLoadBalancerProvider.newLoadBalancer(helper);
+
+    String cluster1 = "cluster-01.googleapis.com";
+    String cluster2 = "cluster-02.googleapis.com";
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        // CLUSTER (aggr.) -> [cluster1 (EDS), cluster2 (EDS)]
+        CLUSTER, Cluster.newBuilder()
+            .setName(CLUSTER)
+            .setClusterType(Cluster.CustomClusterType.newBuilder()
+                .setName("envoy.clusters.aggregate")
+                .setTypedConfig(Any.pack(ClusterConfig.newBuilder()
+                    .addClusters(cluster1)
+                    .addClusters(cluster2)
+                    .build())))
+            .build(),
+        cluster1, EDS_CLUSTER.toBuilder().setName(cluster1).build(),
+        cluster2, EDS_CLUSTER.toBuilder().setName(cluster2).build()));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(2);
+    ClusterImplConfig cluster1ImplConfig =
+        (ClusterImplConfig) childBalancers.get(0).config;
+    assertThat(cluster1ImplConfig.cluster)
+        .isEqualTo("cluster-01.googleapis.com");
+    assertThat(cluster1ImplConfig.edsServiceName)
+        .isEqualTo("backend-service-1.googleapis.com");
+    ClusterImplConfig cluster2ImplConfig =
+        (ClusterImplConfig) childBalancers.get(1).config;
+    assertThat(cluster2ImplConfig.cluster)
+        .isEqualTo("cluster-02.googleapis.com");
+    assertThat(cluster2ImplConfig.edsServiceName)
+        .isEqualTo("backend-service-1.googleapis.com");
+  }
+
+  @Test
+  public void aggregateCluster_noChildren() {
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        // CLUSTER (aggr.) -> []
+        CLUSTER, Cluster.newBuilder()
+          .setName(CLUSTER)
+          .setClusterType(Cluster.CustomClusterType.newBuilder()
+            .setName("envoy.clusters.aggregate")
+            .setTypedConfig(Any.pack(ClusterConfig.newBuilder()
+                .build())))
+          .build()));
+    startXdsDepManager();
+
+    verify(helper)
+        .updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
+    Status actualStatus = result.getStatus();
+    assertThat(actualStatus.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(actualStatus.getDescription())
+        .contains("aggregate ClusterConfig.clusters must not be empty");
+    assertThat(childBalancers).isEmpty();
+  }
+
+  @Test
+  public void aggregateCluster_noNonAggregateClusterExits_returnErrorPicker() {
+    lbRegistry.register(new PriorityLoadBalancerProvider());
+    CdsLoadBalancerProvider cdsLoadBalancerProvider = new CdsLoadBalancerProvider(lbRegistry);
+    lbRegistry.register(cdsLoadBalancerProvider);
+    loadBalancer = (CdsLoadBalancer2) cdsLoadBalancerProvider.newLoadBalancer(helper);
+
+    String cluster1 = "cluster-01.googleapis.com";
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        // CLUSTER (aggr.) -> [cluster1 (missing)]
+        CLUSTER, Cluster.newBuilder()
+          .setName(CLUSTER)
+          .setClusterType(Cluster.CustomClusterType.newBuilder()
+            .setName("envoy.clusters.aggregate")
+            .setTypedConfig(Any.pack(ClusterConfig.newBuilder()
+                .addClusters(cluster1)
+                .build())))
+          .setLbPolicy(Cluster.LbPolicy.RING_HASH)
+          .build()));
+    startXdsDepManager();
+
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    String expectedDescription = "Error retrieving CDS resource " + cluster1 + ": NOT_FOUND. "
+        + "Details: Timed out waiting for resource " + cluster1 + " from xDS server nodeID: "
+        + NODE_ID;
+    Status status = Status.UNAVAILABLE.withDescription(expectedDescription);
+    assertPickerStatus(pickerCaptor.getValue(), status);
+    assertThat(childBalancers).isEmpty();
+  }
+
+  @Test
+  public void handleNameResolutionErrorFromUpstream_beforeChildLbCreated_failingPicker() {
+    Status status = Status.UNAVAILABLE.withDescription("unreachable");
+    loadBalancer.handleNameResolutionError(status);
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    assertPickerStatus(pickerCaptor.getValue(), status);
+  }
+
+  @Test
+  public void handleNameResolutionErrorFromUpstream_afterChildLbCreated_fallThrough() {
+    Cluster cluster = Cluster.newBuilder()
+        .setName(CLUSTER)
+        .setType(Cluster.DiscoveryType.EDS)
+        .setEdsClusterConfig(Cluster.EdsClusterConfig.newBuilder()
+          .setServiceName(EDS_SERVICE_NAME)
+          .setEdsConfig(ConfigSource.newBuilder()
+            .setAds(AggregatedConfigSource.newBuilder())))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(CLUSTER, cluster));
+    startXdsDepManager();
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertThat(childBalancer.shutdown).isFalse();
+
+    loadBalancer.handleNameResolutionError(Status.UNAVAILABLE.withDescription("unreachable"));
+    assertThat(childBalancer.upstreamError.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(childBalancer.upstreamError.getDescription()).isEqualTo("unreachable");
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.CONNECTING), any(SubchannelPicker.class));
+  }
+
+  @Test
+  public void unknownLbProvider() {
+    Cluster cluster = Cluster.newBuilder()
+        .setName(CLUSTER)
+        .setType(Cluster.DiscoveryType.EDS)
+        .setEdsClusterConfig(Cluster.EdsClusterConfig.newBuilder()
+          .setServiceName(EDS_SERVICE_NAME)
+          .setEdsConfig(ConfigSource.newBuilder()
+            .setAds(AggregatedConfigSource.newBuilder())))
+        .setLoadBalancingPolicy(LoadBalancingPolicy.newBuilder()
+            .addPolicies(Policy.newBuilder()
+              .setTypedExtensionConfig(TypedExtensionConfig.newBuilder()
+                .setTypedConfig(Any.pack(TypedStruct.newBuilder()
+                    .setTypeUrl("type.googleapis.com/unknownLb")
+                    .setValue(Struct.getDefaultInstance())
+                    .build())))))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(CLUSTER, cluster));
+    startXdsDepManager();
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
+    Status actualStatus = result.getStatus();
+    assertThat(actualStatus.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(actualStatus.getDescription()).contains("Invalid LoadBalancingPolicy");
+  }
+
+  @Test
+  public void invalidLbConfig() {
+    Cluster cluster = Cluster.newBuilder()
+        .setName(CLUSTER)
+        .setType(Cluster.DiscoveryType.EDS)
+        .setEdsClusterConfig(Cluster.EdsClusterConfig.newBuilder()
+          .setServiceName(EDS_SERVICE_NAME)
+          .setEdsConfig(ConfigSource.newBuilder()
+            .setAds(AggregatedConfigSource.newBuilder())))
+        .setLoadBalancingPolicy(LoadBalancingPolicy.newBuilder()
+            .addPolicies(Policy.newBuilder()
+              .setTypedExtensionConfig(TypedExtensionConfig.newBuilder()
+                .setTypedConfig(Any.pack(TypedStruct.newBuilder()
+                    .setTypeUrl("type.googleapis.com/ring_hash_experimental")
+                    .setValue(Struct.newBuilder()
+                      .putFields("minRingSize", Value.newBuilder().setNumberValue(-1).build()))
+                    .build())))))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(CLUSTER, cluster));
+    startXdsDepManager();
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
+    Status actualStatus = result.getStatus();
+    assertThat(actualStatus.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(actualStatus.getDescription()).contains("Invalid 'minRingSize'");
+  }
+
+  private void startXdsDepManager() {
+    startXdsDepManager(new CdsConfig(CLUSTER));
+  }
+
+  private void startXdsDepManager(final CdsConfig cdsConfig) {
+    xdsDepManager.start(
+        xdsConfig -> {
+          if (!xdsConfig.hasValue()) {
+            throw new AssertionError("" + xdsConfig.getStatus());
+          }
+          this.lastXdsConfig = xdsConfig.getValue();
+          if (loadBalancer == null) {
+            return;
+          }
+          loadBalancer.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+              .setAddresses(Collections.emptyList())
+              .setAttributes(Attributes.newBuilder()
+                .set(XdsAttributes.XDS_CONFIG, xdsConfig.getValue())
+                .set(XdsAttributes.XDS_CLUSTER_SUBSCRIPT_REGISTRY, xdsDepManager)
+                .build())
+              .setLoadBalancingPolicyConfig(cdsConfig)
+              .build());
+        });
+    // trigger does not exist timer, so broken config is more obvious
+    fakeClock.forwardTime(10, TimeUnit.MINUTES);
+  }
+
+  private static void assertPickerStatus(SubchannelPicker picker, Status expectedStatus)  {
+    PickResult result = picker.pickSubchannel(mock(PickSubchannelArgs.class));
+    Status actualStatus = result.getStatus();
+    assertThat(actualStatus.getCode()).isEqualTo(expectedStatus.getCode());
+    assertThat(actualStatus.getDescription()).isEqualTo(expectedStatus.getDescription());
+  }
+
+  private final class FakeLoadBalancerProvider extends LoadBalancerProvider {
+    private final String policyName;
+    private final LoadBalancerProvider configParsingDelegate;
+
+    FakeLoadBalancerProvider(String policyName) {
+      this(policyName, null);
+    }
+
+    FakeLoadBalancerProvider(String policyName, LoadBalancerProvider configParsingDelegate) {
+      this.policyName = policyName;
+      this.configParsingDelegate = configParsingDelegate;
+    }
+
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      FakeLoadBalancer balancer = new FakeLoadBalancer(policyName);
+      childBalancers.add(balancer);
+      return balancer;
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 0;  // doesn't matter
+    }
+
+    @Override
+    public String getPolicyName() {
+      return policyName;
+    }
+
+    @Override
+    public NameResolver.ConfigOrError parseLoadBalancingPolicyConfig(
+        Map<String, ?> rawLoadBalancingPolicyConfig) {
+      if (configParsingDelegate != null) {
+        return configParsingDelegate.parseLoadBalancingPolicyConfig(rawLoadBalancingPolicyConfig);
+      }
+      return super.parseLoadBalancingPolicyConfig(rawLoadBalancingPolicyConfig);
+    }
+  }
+
+  private final class FakeLoadBalancer extends LoadBalancer {
+    private final String name;
+    private Object config;
+    private Status upstreamError;
+    private boolean shutdown;
+
+    FakeLoadBalancer(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      config = resolvedAddresses.getLoadBalancingPolicyConfig();
+      return Status.OK;
+    }
+
+    @Override
+    public void handleNameResolutionError(Status error) {
+      upstreamError = error;
+    }
+
+    @Override
+    public void shutdown() {
+      shutdown = true;
+      childBalancers.remove(this);
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/CdsLoadBalancerProviderTest.java b/xds/src/test/java/io/grpc/xds/CdsLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..0cd3d7306bc
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/CdsLoadBalancerProviderTest.java
@@ -0,0 +1,79 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.JsonParser;
+import io.grpc.xds.CdsLoadBalancerProvider.CdsConfig;
+import java.io.IOException;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link CdsLoadBalancerProvider}. */
+@RunWith(JUnit4.class)
+public class CdsLoadBalancerProviderTest {
+
+  @Test
+  public void parseCdsLoadBalancingPolicyConfig() throws IOException {
+    CdsLoadBalancerProvider provider = new CdsLoadBalancerProvider();
+    String rawCdsLbConfig = "{\n"
+        + "  \"cluster\": \"cluster-foo.googleapis.com\"\n"
+        + "}";
+
+    @SuppressWarnings("unchecked")
+    Map<String, ?> rawLbConfigMap = (Map<String, ?>) JsonParser.parse(rawCdsLbConfig);
+    ConfigOrError result = provider.parseLoadBalancingPolicyConfig(rawLbConfigMap);
+    assertThat(result.getConfig()).isNotNull();
+    CdsConfig config = (CdsConfig) result.getConfig();
+    assertThat(config.name).isEqualTo("cluster-foo.googleapis.com");
+  }
+
+  @Test
+  public void provided() {
+    LoadBalancerProvider provider =
+        LoadBalancerRegistry.getDefaultRegistry().getProvider(XdsLbPolicies.CDS_POLICY_NAME);
+    assertThat(provider).isInstanceOf(CdsLoadBalancerProvider.class);
+  }
+
+  @Test
+  public void providesLoadBalancer()  {
+    Helper helper = mock(Helper.class);
+
+    SynchronizationContext syncContext = new SynchronizationContext(
+        new Thread.UncaughtExceptionHandler() {
+          @Override
+          public void uncaughtException(Thread t, Throwable e) {
+            throw new AssertionError(e);
+          }
+        });
+    when(helper.getSynchronizationContext()).thenReturn(syncContext);
+    LoadBalancerProvider provider = new CdsLoadBalancerProvider();
+    LoadBalancer loadBalancer = provider.newLoadBalancer(helper);
+    assertThat(loadBalancer).isInstanceOf(CdsLoadBalancer2.class);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/ClusterImplLoadBalancerProviderTest.java b/xds/src/test/java/io/grpc/xds/ClusterImplLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..8ecd1d6f9c8
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/ClusterImplLoadBalancerProviderTest.java
@@ -0,0 +1,53 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link ClusterImplLoadBalancerProvider}.
+ */
+@RunWith(JUnit4.class)
+public class ClusterImplLoadBalancerProviderTest {
+
+  @Test
+  public void provided() {
+    LoadBalancerProvider provider =
+        LoadBalancerRegistry.getDefaultRegistry().getProvider(
+            XdsLbPolicies.CLUSTER_IMPL_POLICY_NAME);
+    assertThat(provider).isInstanceOf(ClusterImplLoadBalancerProvider.class);
+  }
+
+  @Test
+  public void providesLoadBalancer()  {
+    Helper helper = mock(Helper.class);
+    when(helper.getAuthority()).thenReturn("api.google.com");
+    LoadBalancerProvider provider = new ClusterImplLoadBalancerProvider();
+    LoadBalancer loadBalancer = provider.newLoadBalancer(helper);
+    assertThat(loadBalancer).isInstanceOf(ClusterImplLoadBalancer.class);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/ClusterImplLoadBalancerTest.java b/xds/src/test/java/io/grpc/xds/ClusterImplLoadBalancerTest.java
new file mode 100644
index 00000000000..9277675385a
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/ClusterImplLoadBalancerTest.java
@@ -0,0 +1,1388 @@
+/*
+ * 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static io.grpc.xds.ClusterImplLoadBalancer.ATTR_SUBCHANNEL_ADDRESS_NAME;
+import static io.grpc.xds.XdsNameResolver.AUTO_HOST_REWRITE_KEY;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.github.xds.data.orca.v3.OrcaLoadReport;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.FixedResultPicker;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickDetailsConsumer;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.NameResolver;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.PickFirstLoadBalancerProvider;
+import io.grpc.internal.PickSubchannelArgsImpl;
+import io.grpc.protobuf.ProtoUtils;
+import io.grpc.testing.TestMethodDescriptors;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.xds.ClusterImplLoadBalancerProvider.ClusterImplConfig;
+import io.grpc.xds.Endpoints.DropOverload;
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedPolicySelection;
+import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedTargetConfig;
+import io.grpc.xds.XdsNameResolverProvider.CallCounterProvider;
+import io.grpc.xds.client.BackendMetricPropagation;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.LoadReportClient;
+import io.grpc.xds.client.LoadStatsManager2;
+import io.grpc.xds.client.LoadStatsManager2.ClusterDropStats;
+import io.grpc.xds.client.LoadStatsManager2.ClusterLocalityStats;
+import io.grpc.xds.client.Locality;
+import io.grpc.xds.client.Stats.ClusterStats;
+import io.grpc.xds.client.Stats.UpstreamLocalityStats;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.internal.XdsInternalAttributes;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil;
+import io.grpc.xds.internal.security.SecurityProtocolNegotiators;
+import io.grpc.xds.internal.security.SslContextProvider;
+import io.grpc.xds.internal.security.SslContextProviderSupplier;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Queue;
+import java.util.concurrent.atomic.AtomicLong;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Tests for {@link ClusterImplLoadBalancer}.
+ */
+@RunWith(JUnit4.class)
+public class ClusterImplLoadBalancerTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private static final double TOLERANCE = 1.0e-10;
+  private static final String AUTHORITY = "api.google.com";
+  private static final String CLUSTER = "cluster-foo.googleapis.com";
+  private static final String EDS_SERVICE_NAME = "service.googleapis.com";
+  private static final ServerInfo LRS_SERVER_INFO =
+      ServerInfo.create("api.google.com", InsecureChannelCredentials.create());
+  private static final Metadata.Key<OrcaLoadReport> ORCA_ENDPOINT_LOAD_METRICS_KEY =
+      Metadata.Key.of(
+          "endpoint-load-metrics-bin",
+          ProtoUtils.metadataMarshaller(OrcaLoadReport.getDefaultInstance()));
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final FakeClock fakeClock = new FakeClock();
+  private final Locality locality =
+      Locality.create("test-region", "test-zone", "test-subzone");
+  private final Object roundRobin = GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+      new FakeLoadBalancerProvider("round_robin"), null);
+  private final List<FakeLoadBalancer> downstreamBalancers = new ArrayList<>();
+  private final FakeTlsContextManager tlsContextManager = new FakeTlsContextManager();
+  private final LoadStatsManager2 loadStatsManager =
+      new LoadStatsManager2(fakeClock.getStopwatchSupplier());
+  private final FakeXdsClient xdsClient = new FakeXdsClient();
+  private final CallCounterProvider callCounterProvider = new CallCounterProvider() {
+    @Override
+    public AtomicLong getOrCreate(String cluster, @Nullable String edsServiceName) {
+      return new AtomicLong();
+    }
+  };
+  private final FakeLbHelper helper = new FakeLbHelper();
+  private PickSubchannelArgs pickSubchannelArgs = new PickSubchannelArgsImpl(
+      TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT,
+      new PickDetailsConsumer() {});
+  @Mock
+  private ThreadSafeRandom mockRandom;
+  private int xdsClientRefs;
+  private ConnectivityState currentState;
+  private SubchannelPicker currentPicker;
+  private ClusterImplLoadBalancer loadBalancer;
+
+  @Before
+  public void setUp() {
+    loadBalancer = new ClusterImplLoadBalancer(helper, mockRandom);
+  }
+
+  @After
+  public void tearDown() {
+    if (loadBalancer != null) {
+      loadBalancer.shutdown();
+    }
+    assertThat(xdsClientRefs).isEqualTo(0);
+    assertThat(downstreamBalancers).isEmpty();
+  }
+
+  @Test
+  public void handleResolvedAddresses_propagateToChildPolicy() {
+    FakeLoadBalancerProvider weightedTargetProvider =
+        new FakeLoadBalancerProvider(XdsLbPolicies.WEIGHTED_TARGET_POLICY_NAME);
+    Object weightedTargetConfig = new Object();
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr", locality);
+    deliverAddressesAndConfig(Collections.singletonList(endpoint), config);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    assertThat(Iterables.getOnlyElement(childBalancer.addresses)).isEqualTo(endpoint);
+    assertThat(childBalancer.config).isSameInstanceAs(weightedTargetConfig);
+    assertThat(childBalancer.attributes.get(io.grpc.xds.XdsAttributes.XDS_CLIENT))
+        .isSameInstanceAs(xdsClient);
+    assertThat(childBalancer.attributes.get(NameResolver.ATTR_BACKEND_SERVICE)).isEqualTo(CLUSTER);
+  }
+
+  /**
+   * If the control plane switches from using the legacy lb_policy field in the xDS Cluster proto
+   * to the newer load_balancing_policy then the child policy can switch from weighted_target to
+   * xds_wrr_locality (this could happen the opposite way as well). This test assures that this
+   * results in the child LB changing if this were to happen. If this is not done correctly the new
+   * configuration would be given to the old LB implementation which would cause a channel panic.
+   */
+  @Test
+  public void handleResolvedAddresses_childPolicyChanges() {
+    FakeLoadBalancerProvider weightedTargetProvider =
+        new FakeLoadBalancerProvider(XdsLbPolicies.WEIGHTED_TARGET_POLICY_NAME);
+    Object weightedTargetConfig = new Object();
+    ClusterImplConfig configWithWeightedTarget = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME,
+        LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr", locality);
+    deliverAddressesAndConfig(Collections.singletonList(endpoint), configWithWeightedTarget);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    assertThat(childBalancer.name).isEqualTo(XdsLbPolicies.WEIGHTED_TARGET_POLICY_NAME);
+    assertThat(childBalancer.config).isSameInstanceAs(weightedTargetConfig);
+
+    FakeLoadBalancerProvider wrrLocalityProvider =
+        new FakeLoadBalancerProvider(XdsLbPolicies.WRR_LOCALITY_POLICY_NAME);
+    Object wrrLocalityConfig = new Object();
+    ClusterImplConfig configWithWrrLocality = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME,
+        LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            wrrLocalityProvider, wrrLocalityConfig),
+        null, Collections.emptyMap(), null);
+    deliverAddressesAndConfig(Collections.singletonList(endpoint), configWithWrrLocality);
+    childBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    assertThat(childBalancer.name).isEqualTo(XdsLbPolicies.WRR_LOCALITY_POLICY_NAME);
+    assertThat(childBalancer.config).isSameInstanceAs(wrrLocalityConfig);
+  }
+
+  @Test
+  public void nameResolutionError_beforeChildPolicyInstantiated_returnErrorPickerToUpstream() {
+    loadBalancer.handleNameResolutionError(Status.UNIMPLEMENTED.withDescription("not found"));
+    assertThat(currentState).isEqualTo(ConnectivityState.TRANSIENT_FAILURE);
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    assertThat(result.getStatus().isOk()).isFalse();
+    assertThat(result.getStatus().getCode()).isEqualTo(Code.UNIMPLEMENTED);
+    assertThat(result.getStatus().getDescription()).isEqualTo("not found");
+  }
+
+  @Test
+  public void nameResolutionError_afterChildPolicyInstantiated_propagateToDownstream() {
+    FakeLoadBalancerProvider weightedTargetProvider =
+        new FakeLoadBalancerProvider(XdsLbPolicies.WEIGHTED_TARGET_POLICY_NAME);
+    Object weightedTargetConfig = new Object();
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr", locality);
+    deliverAddressesAndConfig(Collections.singletonList(endpoint), config);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(downstreamBalancers);
+
+    loadBalancer.handleNameResolutionError(
+        Status.UNAVAILABLE.withDescription("cannot reach server"));
+    assertThat(childBalancer.upstreamError.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(childBalancer.upstreamError.getDescription())
+        .isEqualTo("cannot reach server");
+  }
+
+  @Test
+  public void pick_addsOptionalLabels() {
+    LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
+    WeightedTargetConfig weightedTargetConfig =
+        buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr", locality);
+    deliverAddressesAndConfig(Collections.singletonList(endpoint), config);
+    FakeLoadBalancer leafBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    leafBalancer.createSubChannel();
+    FakeSubchannel fakeSubchannel = helper.subchannels.poll();
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING));
+    fakeSubchannel.setConnectedEagIndex(0);
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    assertThat(currentState).isEqualTo(ConnectivityState.READY);
+
+    PickDetailsConsumer detailsConsumer = mock(PickDetailsConsumer.class);
+    pickSubchannelArgs = new PickSubchannelArgsImpl(
+      TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT, detailsConsumer);
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    assertThat(result.getStatus().isOk()).isTrue();
+    // The value will be determined by the parent policy, so can be different than the value used in
+    // makeAddress() for the test.
+    verify(detailsConsumer).addOptionalLabel("grpc.lb.locality", locality.toString());
+    verify(detailsConsumer).addOptionalLabel("grpc.lb.backend_service", CLUSTER);
+  }
+
+  @Test
+  public void pick_noResult_addsClusterLabel() {
+    LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
+    WeightedTargetConfig weightedTargetConfig =
+        buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr", locality);
+    deliverAddressesAndConfig(Collections.singletonList(endpoint), config);
+    FakeLoadBalancer leafBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    leafBalancer.deliverSubchannelState(PickResult.withNoResult(), ConnectivityState.CONNECTING);
+    assertThat(currentState).isEqualTo(ConnectivityState.CONNECTING);
+
+    PickDetailsConsumer detailsConsumer = mock(PickDetailsConsumer.class);
+    pickSubchannelArgs = new PickSubchannelArgsImpl(
+      TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT, detailsConsumer);
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    assertThat(result.getStatus().isOk()).isTrue();
+    verify(detailsConsumer).addOptionalLabel("grpc.lb.backend_service", CLUSTER);
+  }
+
+  @Test
+  public void recordLoadStats() {
+    LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
+    WeightedTargetConfig weightedTargetConfig =
+        buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr", locality);
+    deliverAddressesAndConfig(Collections.singletonList(endpoint), config);
+    FakeLoadBalancer leafBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    Subchannel subchannel = leafBalancer.createSubChannel();
+    FakeSubchannel fakeSubchannel = helper.subchannels.poll();
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING));
+    fakeSubchannel.setConnectedEagIndex(0);
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    assertThat(currentState).isEqualTo(ConnectivityState.READY);
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    assertThat(result.getStatus().isOk()).isTrue();
+    ClientStreamTracer streamTracer1 = result.getStreamTracerFactory().newClientStreamTracer(
+        ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());  // first RPC call
+    ClientStreamTracer streamTracer2 = result.getStreamTracerFactory().newClientStreamTracer(
+        ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());  // second RPC call
+    ClientStreamTracer streamTracer3 = result.getStreamTracerFactory().newClientStreamTracer(
+        ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());  // third RPC call
+    // When the trailer contains an ORCA report, the listener callback will be invoked.
+    Metadata trailersWithOrcaLoadReport1 = new Metadata();
+    trailersWithOrcaLoadReport1.put(ORCA_ENDPOINT_LOAD_METRICS_KEY,
+        OrcaLoadReport.newBuilder().setApplicationUtilization(1.414).setMemUtilization(0.034)
+            .setRpsFractional(1.414).putNamedMetrics("named1", 3.14159)
+            .putNamedMetrics("named2", -1.618).build());
+    streamTracer1.inboundTrailers(trailersWithOrcaLoadReport1);
+    streamTracer1.streamClosed(Status.OK);
+    Metadata trailersWithOrcaLoadReport2 = new Metadata();
+    trailersWithOrcaLoadReport2.put(ORCA_ENDPOINT_LOAD_METRICS_KEY,
+        OrcaLoadReport.newBuilder().setApplicationUtilization(0.99).setMemUtilization(0.123)
+            .setRpsFractional(0.905).putNamedMetrics("named1", 2.718)
+            .putNamedMetrics("named2", 1.414)
+            .putNamedMetrics("named3", 0.009).build());
+    streamTracer2.inboundTrailers(trailersWithOrcaLoadReport2);
+    streamTracer2.streamClosed(Status.UNAVAILABLE);
+    ClusterStats clusterStats =
+        Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    UpstreamLocalityStats localityStats =
+        Iterables.getOnlyElement(clusterStats.upstreamLocalityStatsList());
+    assertThat(localityStats.locality()).isEqualTo(locality);
+    assertThat(localityStats.totalIssuedRequests()).isEqualTo(3L);
+    assertThat(localityStats.totalSuccessfulRequests()).isEqualTo(1L);
+    assertThat(localityStats.totalErrorRequests()).isEqualTo(1L);
+    assertThat(localityStats.totalRequestsInProgress()).isEqualTo(1L);
+    assertThat(localityStats.loadMetricStatsMap().containsKey("named1")).isTrue();
+    assertThat(
+        localityStats.loadMetricStatsMap().get("named1").numRequestsFinishedWithMetric()).isEqualTo(
+        2L);
+    assertThat(localityStats.loadMetricStatsMap().get("named1").totalMetricValue()).isWithin(
+        TOLERANCE).of(3.14159 + 2.718);
+    assertThat(localityStats.loadMetricStatsMap().containsKey("named2")).isTrue();
+    assertThat(
+        localityStats.loadMetricStatsMap().get("named2").numRequestsFinishedWithMetric()).isEqualTo(
+        2L);
+    assertThat(localityStats.loadMetricStatsMap().get("named2").totalMetricValue()).isWithin(
+        TOLERANCE).of(-1.618 + 1.414);
+    assertThat(localityStats.loadMetricStatsMap().containsKey("named3")).isTrue();
+    assertThat(
+        localityStats.loadMetricStatsMap().get("named3").numRequestsFinishedWithMetric()).isEqualTo(
+        1L);
+    assertThat(localityStats.loadMetricStatsMap().get("named3").totalMetricValue()).isWithin(
+        TOLERANCE).of(0.009);
+
+    streamTracer3.streamClosed(Status.OK);
+    subchannel.shutdown(); // stats recorder released
+    clusterStats = Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    // Locality load is reported for one last time in case of loads occurred since the previous
+    // load report.
+    localityStats = Iterables.getOnlyElement(clusterStats.upstreamLocalityStatsList());
+    assertThat(localityStats.locality()).isEqualTo(locality);
+    assertThat(localityStats.totalIssuedRequests()).isEqualTo(0L);
+    assertThat(localityStats.totalSuccessfulRequests()).isEqualTo(1L);
+    assertThat(localityStats.totalErrorRequests()).isEqualTo(0L);
+    assertThat(localityStats.totalRequestsInProgress()).isEqualTo(0L);
+    assertThat(localityStats.loadMetricStatsMap().isEmpty()).isTrue();
+
+    clusterStats = Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    assertThat(clusterStats.upstreamLocalityStatsList()).isEmpty();  // no longer reported
+  }
+
+  @Test
+  public void recordLoadStats_orcaLrsPropagationEnabled() {
+    boolean originalVal = LoadStatsManager2.isEnabledOrcaLrsPropagation;
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = true;
+    BackendMetricPropagation backendMetricPropagation = BackendMetricPropagation.fromMetricSpecs(
+        Arrays.asList("application_utilization", "cpu_utilization", "named_metrics.named1"));
+    LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
+    WeightedTargetConfig weightedTargetConfig =
+        buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), backendMetricPropagation);
+    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr", locality);
+    deliverAddressesAndConfig(Collections.singletonList(endpoint), config);
+    FakeLoadBalancer leafBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    Subchannel subchannel = leafBalancer.createSubChannel();
+    FakeSubchannel fakeSubchannel = helper.subchannels.poll();
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING));
+    fakeSubchannel.setConnectedEagIndex(0);
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    assertThat(currentState).isEqualTo(ConnectivityState.READY);
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    assertThat(result.getStatus().isOk()).isTrue();
+    ClientStreamTracer streamTracer = result.getStreamTracerFactory().newClientStreamTracer(
+        ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());
+    Metadata trailersWithOrcaLoadReport = new Metadata();
+    trailersWithOrcaLoadReport.put(ORCA_ENDPOINT_LOAD_METRICS_KEY,
+        OrcaLoadReport.newBuilder()
+            .setApplicationUtilization(1.414)
+            .setCpuUtilization(0.5)
+            .setMemUtilization(0.034)
+            .putNamedMetrics("named1", 3.14159)
+            .putNamedMetrics("named2", -1.618).build());
+    streamTracer.inboundTrailers(trailersWithOrcaLoadReport);
+    streamTracer.streamClosed(Status.OK);
+    ClusterStats clusterStats =
+        Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    UpstreamLocalityStats localityStats =
+        Iterables.getOnlyElement(clusterStats.upstreamLocalityStatsList());
+
+    assertThat(localityStats.loadMetricStatsMap()).containsKey("application_utilization");
+    assertThat(localityStats.loadMetricStatsMap().get("application_utilization").totalMetricValue())
+        .isWithin(TOLERANCE).of(1.414);
+    assertThat(localityStats.loadMetricStatsMap()).containsKey("cpu_utilization");
+    assertThat(localityStats.loadMetricStatsMap().get("cpu_utilization").totalMetricValue())
+        .isWithin(TOLERANCE).of(0.5);
+    assertThat(localityStats.loadMetricStatsMap()).doesNotContainKey("mem_utilization");
+    assertThat(localityStats.loadMetricStatsMap()).containsKey("named_metrics.named1");
+    assertThat(localityStats.loadMetricStatsMap().get("named_metrics.named1").totalMetricValue())
+        .isWithin(TOLERANCE).of(3.14159);
+    assertThat(localityStats.loadMetricStatsMap()).doesNotContainKey("named_metrics.named2");
+    subchannel.shutdown();
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = originalVal;
+  }
+
+  @Test
+  public void recordLoadStats_orcaLrsPropagationDisabled() {
+    boolean originalVal = LoadStatsManager2.isEnabledOrcaLrsPropagation;
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = false;
+    BackendMetricPropagation backendMetricPropagation = BackendMetricPropagation.fromMetricSpecs(
+        Arrays.asList("application_utilization", "cpu_utilization", "named_metrics.named1"));
+    LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
+    WeightedTargetConfig weightedTargetConfig =
+        buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), backendMetricPropagation);
+    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr", locality);
+    deliverAddressesAndConfig(Collections.singletonList(endpoint), config);
+    FakeLoadBalancer leafBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    Subchannel subchannel = leafBalancer.createSubChannel();
+    FakeSubchannel fakeSubchannel = helper.subchannels.poll();
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING));
+    fakeSubchannel.setConnectedEagIndex(0);
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    assertThat(currentState).isEqualTo(ConnectivityState.READY);
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    assertThat(result.getStatus().isOk()).isTrue();
+    ClientStreamTracer streamTracer = result.getStreamTracerFactory().newClientStreamTracer(
+        ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());
+    Metadata trailersWithOrcaLoadReport = new Metadata();
+    trailersWithOrcaLoadReport.put(ORCA_ENDPOINT_LOAD_METRICS_KEY,
+        OrcaLoadReport.newBuilder()
+            .setApplicationUtilization(1.414)
+            .setCpuUtilization(0.5)
+            .setMemUtilization(0.034)
+            .putNamedMetrics("named1", 3.14159)
+            .putNamedMetrics("named2", -1.618).build());
+    streamTracer.inboundTrailers(trailersWithOrcaLoadReport);
+    streamTracer.streamClosed(Status.OK);
+    ClusterStats clusterStats =
+        Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    UpstreamLocalityStats localityStats =
+        Iterables.getOnlyElement(clusterStats.upstreamLocalityStatsList());
+
+    assertThat(localityStats.loadMetricStatsMap()).doesNotContainKey("application_utilization");
+    assertThat(localityStats.loadMetricStatsMap()).doesNotContainKey("cpu_utilization");
+    assertThat(localityStats.loadMetricStatsMap()).doesNotContainKey("mem_utilization");
+    assertThat(localityStats.loadMetricStatsMap()).doesNotContainKey("named_metrics.named1");
+    assertThat(localityStats.loadMetricStatsMap()).doesNotContainKey("named_metrics.named2");
+    assertThat(localityStats.loadMetricStatsMap().containsKey("named1")).isTrue();
+    assertThat(localityStats.loadMetricStatsMap().containsKey("named2")).isTrue();
+    subchannel.shutdown();
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = originalVal;
+  }
+
+  // Verifies https://github.com/grpc/grpc-java/issues/11434.
+  @Test
+  public void pickFirstLoadReport_onUpdateAddress() {
+    Locality locality1 =
+        Locality.create("test-region", "test-zone", "test-subzone");
+    Locality locality2 =
+        Locality.create("other-region", "other-zone", "other-subzone");
+
+    LoadBalancerProvider pickFirstProvider = LoadBalancerRegistry
+        .getDefaultRegistry().getProvider("pick_first");
+    Object pickFirstConfig = pickFirstProvider.parseLoadBalancingPolicyConfig(new HashMap<>())
+        .getConfig();
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(pickFirstProvider,
+            pickFirstConfig),
+        null, Collections.emptyMap(), null);
+    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr1", locality1);
+    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr2", locality2);
+    deliverAddressesAndConfig(Arrays.asList(endpoint1, endpoint2), config);
+
+    // Leaf balancer is created by Pick First. Get FakeSubchannel created to update attributes
+    // A real subchannel would get these attributes from the connected address's EAG locality.
+    FakeSubchannel fakeSubchannel = helper.subchannels.poll();
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING));
+    fakeSubchannel.setConnectedEagIndex(0);
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    assertThat(currentState).isEqualTo(ConnectivityState.READY);
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    assertThat(result.getStatus().isOk()).isTrue();
+
+    ClientStreamTracer streamTracer1 = result.getStreamTracerFactory().newClientStreamTracer(
+        ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());  // first RPC call
+    streamTracer1.streamClosed(Status.OK);
+
+    ClusterStats clusterStats = Iterables.getOnlyElement(
+        loadStatsManager.getClusterStatsReports(CLUSTER));
+    UpstreamLocalityStats localityStats = Iterables.getOnlyElement(
+        clusterStats.upstreamLocalityStatsList());
+    assertThat(localityStats.locality()).isEqualTo(locality1);
+    assertThat(localityStats.totalIssuedRequests()).isEqualTo(1L);
+    assertThat(localityStats.totalSuccessfulRequests()).isEqualTo(1L);
+    assertThat(localityStats.totalErrorRequests()).isEqualTo(0L);
+
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.IDLE));
+    loadBalancer.requestConnection();
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING));
+
+    // Faksubchannel mimics update address and returns different locality
+    if (PickFirstLoadBalancerProvider.isEnabledNewPickFirst()) {
+      fakeSubchannel.updateState(ConnectivityStateInfo.forTransientFailure(
+          Status.UNAVAILABLE.withDescription("Try second address instead")));
+      fakeSubchannel = helper.subchannels.poll();
+      fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING));
+      fakeSubchannel.setConnectedEagIndex(0);
+      fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    } else {
+      fakeSubchannel.setConnectedEagIndex(1);
+      fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    }
+    result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    assertThat(result.getStatus().isOk()).isTrue();
+    ClientStreamTracer streamTracer2 = result.getStreamTracerFactory().newClientStreamTracer(
+        ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());  // second RPC call
+    streamTracer2.streamClosed(Status.UNAVAILABLE);
+
+    clusterStats = Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    List<UpstreamLocalityStats> upstreamLocalityStatsList =
+        clusterStats.upstreamLocalityStatsList();
+    UpstreamLocalityStats localityStats1 = Iterables.find(upstreamLocalityStatsList,
+        upstreamLocalityStats -> upstreamLocalityStats.locality().equals(locality1));
+    assertThat(localityStats1.totalIssuedRequests()).isEqualTo(0L);
+    assertThat(localityStats1.totalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(localityStats1.totalErrorRequests()).isEqualTo(0L);
+    UpstreamLocalityStats localityStats2 = Iterables.find(upstreamLocalityStatsList,
+        upstreamLocalityStats -> upstreamLocalityStats.locality().equals(locality2));
+    assertThat(localityStats2.totalIssuedRequests()).isEqualTo(1L);
+    assertThat(localityStats2.totalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(localityStats2.totalErrorRequests()).isEqualTo(1L);
+
+    loadBalancer.shutdown();
+    loadBalancer = null;
+    // No more references are held for localityStats1 hence dropped.
+    // Locality load is reported for one last time in case of loads occurred since the previous
+    // load report.
+    clusterStats = Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    localityStats2 = Iterables.getOnlyElement(clusterStats.upstreamLocalityStatsList());
+
+    assertThat(localityStats2.locality()).isEqualTo(locality2);
+    assertThat(localityStats2.totalIssuedRequests()).isEqualTo(0L);
+    assertThat(localityStats2.totalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(localityStats2.totalErrorRequests()).isEqualTo(0L);
+    assertThat(localityStats2.totalRequestsInProgress()).isEqualTo(0L);
+
+    assertThat(loadStatsManager.getClusterStatsReports(CLUSTER)).isEmpty();
+  }
+
+  @Test
+  public void dropRpcsWithRespectToLbConfigDropCategories() {
+    LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
+    WeightedTargetConfig weightedTargetConfig =
+        buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.singletonList(DropOverload.create("throttle", 500_000)),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr", locality);
+    deliverAddressesAndConfig(Collections.singletonList(endpoint), config);
+    when(mockRandom.nextInt(anyInt())).thenReturn(499_999, 999_999, 1_000_000);
+    assertThat(downstreamBalancers).hasSize(1);  // one leaf balancer
+    FakeLoadBalancer leafBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    assertThat(leafBalancer.name).isEqualTo("round_robin");
+    assertThat(Iterables.getOnlyElement(leafBalancer.addresses).getAddresses())
+        .isEqualTo(endpoint.getAddresses());
+    leafBalancer.createSubChannel();
+    FakeSubchannel fakeSubchannel = helper.subchannels.poll();
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING));
+    fakeSubchannel.setConnectedEagIndex(0);
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+
+    assertThat(currentState).isEqualTo(ConnectivityState.READY);
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    assertThat(result.getStatus().isOk()).isFalse();
+    assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(result.getStatus().getDescription()).isEqualTo("Dropped: throttle");
+    ClusterStats clusterStats =
+        Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    assertThat(clusterStats.clusterServiceName()).isEqualTo(EDS_SERVICE_NAME);
+    assertThat(Iterables.getOnlyElement(clusterStats.droppedRequestsList()).category())
+        .isEqualTo("throttle");
+    assertThat(Iterables.getOnlyElement(clusterStats.droppedRequestsList()).droppedCount())
+        .isEqualTo(1L);
+    assertThat(clusterStats.totalDroppedRequests()).isEqualTo(1L);
+
+    //  Config update updates drop policies.
+    config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO, null,
+        Collections.singletonList(DropOverload.create("lb", 1_000_000)),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(Collections.singletonList(endpoint))
+            .setAttributes(
+                Attributes.newBuilder()
+                    .set(io.grpc.xds.XdsAttributes.XDS_CLIENT, xdsClient)
+                    .build())
+            .setLoadBalancingPolicyConfig(config)
+            .build());
+    result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    assertThat(result.getStatus().isOk()).isFalse();
+    assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(result.getStatus().getDescription()).isEqualTo("Dropped: lb");
+    clusterStats =
+        Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    assertThat(clusterStats.clusterServiceName()).isEqualTo(EDS_SERVICE_NAME);
+    assertThat(Iterables.getOnlyElement(clusterStats.droppedRequestsList()).category())
+        .isEqualTo("lb");
+    assertThat(Iterables.getOnlyElement(clusterStats.droppedRequestsList()).droppedCount())
+        .isEqualTo(1L);
+    assertThat(clusterStats.totalDroppedRequests()).isEqualTo(1L);
+
+    result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    assertThat(result.getStatus().isOk()).isTrue();
+  }
+
+  @Test
+  public void maxConcurrentRequests_appliedByLbConfig_disableCircuitBreaking() {
+    boolean originalEnableCircuitBreaking = ClusterImplLoadBalancer.enableCircuitBreaking;
+    ClusterImplLoadBalancer.enableCircuitBreaking = false;
+    subtest_maxConcurrentRequests_appliedByLbConfig(false);
+    ClusterImplLoadBalancer.enableCircuitBreaking = originalEnableCircuitBreaking;
+  }
+
+  @Test
+  public void maxConcurrentRequests_appliedByLbConfig_circuitBreakingEnabledByDefault() {
+    subtest_maxConcurrentRequests_appliedByLbConfig(true);
+  }
+
+  private void subtest_maxConcurrentRequests_appliedByLbConfig(boolean enableCircuitBreaking) {
+    long maxConcurrentRequests = 100L;
+    LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
+    WeightedTargetConfig weightedTargetConfig =
+        buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        maxConcurrentRequests, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr", locality);
+    deliverAddressesAndConfig(Collections.singletonList(endpoint), config);
+    assertThat(downstreamBalancers).hasSize(1);  // one leaf balancer
+    FakeLoadBalancer leafBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    assertThat(leafBalancer.name).isEqualTo("round_robin");
+    assertThat(Iterables.getOnlyElement(leafBalancer.addresses).getAddresses())
+        .isEqualTo(endpoint.getAddresses());
+    leafBalancer.createSubChannel();
+    FakeSubchannel fakeSubchannel = helper.subchannels.poll();
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING));
+    fakeSubchannel.setConnectedEagIndex(0);
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    assertThat(currentState).isEqualTo(ConnectivityState.READY);
+    assertThat(currentState).isEqualTo(ConnectivityState.READY);
+    for (int i = 0; i < maxConcurrentRequests; i++) {
+      PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+      assertThat(result.getStatus().isOk()).isTrue();
+      ClientStreamTracer.Factory streamTracerFactory = result.getStreamTracerFactory();
+      streamTracerFactory.newClientStreamTracer(
+          ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());
+    }
+    ClusterStats clusterStats =
+        Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    assertThat(clusterStats.clusterServiceName()).isEqualTo(EDS_SERVICE_NAME);
+    assertThat(clusterStats.totalDroppedRequests()).isEqualTo(0L);
+
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    clusterStats = Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    assertThat(clusterStats.clusterServiceName()).isEqualTo(EDS_SERVICE_NAME);
+    if (enableCircuitBreaking) {
+      assertThat(result.getStatus().isOk()).isFalse();
+      assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+      assertThat(result.getStatus().getDescription())
+          .isEqualTo("Cluster max concurrent requests limit of 100 exceeded");
+      assertThat(clusterStats.totalDroppedRequests()).isEqualTo(1L);
+    } else {
+      assertThat(result.getStatus().isOk()).isTrue();
+      assertThat(clusterStats.totalDroppedRequests()).isEqualTo(0L);
+    }
+
+    // Config update increments circuit breakers max_concurrent_requests threshold.
+    maxConcurrentRequests = 101L;
+    config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        maxConcurrentRequests, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    deliverAddressesAndConfig(Collections.singletonList(endpoint), config);
+
+    result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    assertThat(result.getStatus().isOk()).isTrue();
+    result.getStreamTracerFactory().newClientStreamTracer(
+        ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());  // 101th request
+    clusterStats = Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    assertThat(clusterStats.clusterServiceName()).isEqualTo(EDS_SERVICE_NAME);
+    assertThat(clusterStats.totalDroppedRequests()).isEqualTo(0L);
+
+    result = currentPicker.pickSubchannel(pickSubchannelArgs);  // 102th request
+    clusterStats = Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    assertThat(clusterStats.clusterServiceName()).isEqualTo(EDS_SERVICE_NAME);
+    if (enableCircuitBreaking) {
+      assertThat(result.getStatus().isOk()).isFalse();
+      assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+      assertThat(result.getStatus().getDescription())
+          .isEqualTo("Cluster max concurrent requests limit of 101 exceeded");
+      assertThat(clusterStats.totalDroppedRequests()).isEqualTo(1L);
+    } else {
+      assertThat(result.getStatus().isOk()).isTrue();
+      assertThat(clusterStats.totalDroppedRequests()).isEqualTo(0L);
+    }
+  }
+
+  @Test
+  public void maxConcurrentRequests_appliedWithDefaultValue_disableCircuitBreaking() {
+    boolean originalEnableCircuitBreaking = ClusterImplLoadBalancer.enableCircuitBreaking;
+    ClusterImplLoadBalancer.enableCircuitBreaking = false;
+    subtest_maxConcurrentRequests_appliedWithDefaultValue(false);
+    ClusterImplLoadBalancer.enableCircuitBreaking = originalEnableCircuitBreaking;
+  }
+
+  @Test
+  public void maxConcurrentRequests_appliedWithDefaultValue_circuitBreakingEnabledByDefault() {
+    subtest_maxConcurrentRequests_appliedWithDefaultValue(true);
+  }
+
+  private void subtest_maxConcurrentRequests_appliedWithDefaultValue(
+      boolean enableCircuitBreaking) {
+    LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
+    WeightedTargetConfig weightedTargetConfig =
+        buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    EquivalentAddressGroup endpoint = makeAddress("endpoint-addr", locality);
+    deliverAddressesAndConfig(Collections.singletonList(endpoint), config);
+    assertThat(downstreamBalancers).hasSize(1);  // one leaf balancer
+    FakeLoadBalancer leafBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    assertThat(leafBalancer.name).isEqualTo("round_robin");
+    assertThat(Iterables.getOnlyElement(leafBalancer.addresses).getAddresses())
+        .isEqualTo(endpoint.getAddresses());
+    leafBalancer.createSubChannel();
+    FakeSubchannel fakeSubchannel = helper.subchannels.poll();
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.CONNECTING));
+    fakeSubchannel.setConnectedEagIndex(0);
+    fakeSubchannel.updateState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    assertThat(currentState).isEqualTo(ConnectivityState.READY);
+    assertThat(currentState).isEqualTo(ConnectivityState.READY);
+    for (int i = 0; i < ClusterImplLoadBalancer.DEFAULT_PER_CLUSTER_MAX_CONCURRENT_REQUESTS; i++) {
+      PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+      assertThat(result.getStatus().isOk()).isTrue();
+      ClientStreamTracer.Factory streamTracerFactory = result.getStreamTracerFactory();
+      streamTracerFactory.newClientStreamTracer(
+          ClientStreamTracer.StreamInfo.newBuilder().build(), new Metadata());
+    }
+    ClusterStats clusterStats =
+        Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    assertThat(clusterStats.clusterServiceName()).isEqualTo(EDS_SERVICE_NAME);
+    assertThat(clusterStats.totalDroppedRequests()).isEqualTo(0L);
+
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    clusterStats = Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER));
+    assertThat(clusterStats.clusterServiceName()).isEqualTo(EDS_SERVICE_NAME);
+    if (enableCircuitBreaking) {
+      assertThat(result.getStatus().isOk()).isFalse();
+      assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+      assertThat(result.getStatus().getDescription())
+          .isEqualTo("Cluster max concurrent requests limit of 1024 exceeded");
+      assertThat(clusterStats.totalDroppedRequests()).isEqualTo(1L);
+    } else {
+      assertThat(result.getStatus().isOk()).isTrue();
+      assertThat(clusterStats.totalDroppedRequests()).isEqualTo(0L);
+    }
+  }
+
+  @Test
+  public void endpointAddressesAttachedWithClusterName() {
+    LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
+    WeightedTargetConfig weightedTargetConfig =
+        buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    // One locality with two endpoints.
+    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr1", locality);
+    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr2", locality);
+    deliverAddressesAndConfig(Arrays.asList(endpoint1, endpoint2), config);
+    assertThat(downstreamBalancers).hasSize(1);  // one leaf balancer
+    FakeLoadBalancer leafBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    assertThat(leafBalancer.name).isEqualTo("round_robin");
+
+    // Simulates leaf load balancer creating subchannels.
+    CreateSubchannelArgs args =
+        CreateSubchannelArgs.newBuilder()
+            .setAddresses(leafBalancer.addresses)
+            .build();
+    Subchannel subchannel = leafBalancer.helper.createSubchannel(args);
+    for (EquivalentAddressGroup eag : subchannel.getAllAddresses()) {
+      assertThat(eag.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_CLUSTER_NAME))
+          .isEqualTo(CLUSTER);
+    }
+
+    // An address update should also retain the cluster attribute.
+    subchannel.updateAddresses(leafBalancer.addresses);
+    for (EquivalentAddressGroup eag : subchannel.getAllAddresses()) {
+      assertThat(eag.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_CLUSTER_NAME))
+          .isEqualTo(CLUSTER);
+    }
+  }
+
+  @Test
+  public void
+        endpointsWithAuthorityHostname_autoHostRewriteEnabled_pickResultHasAuthorityHostname() {
+    System.setProperty("GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE", "true");
+    try {
+      LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
+      WeightedTargetConfig weightedTargetConfig =
+          buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
+      ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+          null, Collections.<DropOverload>emptyList(),
+          GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+              weightedTargetProvider, weightedTargetConfig),
+          null, Collections.emptyMap(), null);
+      EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr1", locality,
+          "authority-host-name");
+      deliverAddressesAndConfig(Arrays.asList(endpoint1), config);
+      assertThat(downstreamBalancers).hasSize(1);  // one leaf balancer
+      FakeLoadBalancer leafBalancer = Iterables.getOnlyElement(downstreamBalancers);
+      assertThat(leafBalancer.name).isEqualTo("round_robin");
+
+      // Simulates leaf load balancer creating subchannels.
+      CreateSubchannelArgs args =
+          CreateSubchannelArgs.newBuilder()
+              .setAddresses(leafBalancer.addresses)
+              .build();
+      Subchannel subchannel = leafBalancer.helper.createSubchannel(args);
+      subchannel.start(infoObject -> {
+        if (infoObject.getState() == ConnectivityState.READY) {
+          helper.updateBalancingState(
+              ConnectivityState.READY,
+              new FixedResultPicker(PickResult.withSubchannel(subchannel)));
+        }
+      });
+      assertThat(subchannel.getAttributes().get(ATTR_SUBCHANNEL_ADDRESS_NAME)).isEqualTo(
+          "authority-host-name");
+      for (EquivalentAddressGroup eag : subchannel.getAllAddresses()) {
+        assertThat(eag.getAttributes().get(XdsInternalAttributes.ATTR_ADDRESS_NAME))
+            .isEqualTo("authority-host-name");
+      }
+
+      leafBalancer.deliverSubchannelState(subchannel, ConnectivityState.READY);
+      assertThat(currentState).isEqualTo(ConnectivityState.READY);
+      PickDetailsConsumer detailsConsumer = mock(PickDetailsConsumer.class);
+      pickSubchannelArgs = new PickSubchannelArgsImpl(
+          TestMethodDescriptors.voidMethod(), new Metadata(),
+          CallOptions.DEFAULT.withOption(AUTO_HOST_REWRITE_KEY, true), detailsConsumer);
+      PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+      assertThat(result.getAuthorityOverride()).isEqualTo("authority-host-name");
+    } finally {
+      System.clearProperty("GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE");
+    }
+  }
+
+  @Test
+  public void
+        endpointWithAuthorityHostname_autoHostRewriteNotEnabled_pickResultNoAuthorityHostname() {
+    LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
+    WeightedTargetConfig weightedTargetConfig =
+        buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr1", locality,
+        "authority-host-name");
+    deliverAddressesAndConfig(Arrays.asList(endpoint1), config);
+    assertThat(downstreamBalancers).hasSize(1);  // one leaf balancer
+    FakeLoadBalancer leafBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    assertThat(leafBalancer.name).isEqualTo("round_robin");
+
+    // Simulates leaf load balancer creating subchannels.
+    CreateSubchannelArgs args =
+        CreateSubchannelArgs.newBuilder()
+            .setAddresses(leafBalancer.addresses)
+            .build();
+    Subchannel subchannel = leafBalancer.helper.createSubchannel(args);
+    subchannel.start(infoObject -> {
+      if (infoObject.getState() == ConnectivityState.READY) {
+        helper.updateBalancingState(
+            ConnectivityState.READY,
+            new FixedResultPicker(PickResult.withSubchannel(subchannel)));
+      }
+    });
+    // Sub Channel wrapper args won't have the address name although addresses will.
+    assertThat(subchannel.getAttributes().get(ATTR_SUBCHANNEL_ADDRESS_NAME)).isNull();
+    for (EquivalentAddressGroup eag : subchannel.getAllAddresses()) {
+      assertThat(eag.getAttributes().get(XdsInternalAttributes.ATTR_ADDRESS_NAME))
+          .isEqualTo("authority-host-name");
+    }
+
+    leafBalancer.deliverSubchannelState(subchannel, ConnectivityState.READY);
+    assertThat(currentState).isEqualTo(ConnectivityState.READY);
+    PickDetailsConsumer detailsConsumer = mock(PickDetailsConsumer.class);
+    pickSubchannelArgs = new PickSubchannelArgsImpl(
+        TestMethodDescriptors.voidMethod(), new Metadata(), CallOptions.DEFAULT, detailsConsumer);
+    PickResult result = currentPicker.pickSubchannel(pickSubchannelArgs);
+    assertThat(result.getAuthorityOverride()).isNull();
+  }
+
+  @Test
+  public void endpointAddressesAttachedWithTlsConfig_securityEnabledByDefault() {
+    UpstreamTlsContext upstreamTlsContext =
+        CommonTlsContextTestsUtil.buildUpstreamTlsContext(
+            "google_cloud_private_spiffe", true);
+    LoadBalancerProvider weightedTargetProvider = new WeightedTargetLoadBalancerProvider();
+    WeightedTargetConfig weightedTargetConfig =
+        buildWeightedTargetConfig(ImmutableMap.of(locality, 10));
+    ClusterImplConfig config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        upstreamTlsContext, Collections.emptyMap(), null);
+    // One locality with two endpoints.
+    EquivalentAddressGroup endpoint1 = makeAddress("endpoint-addr1", locality);
+    EquivalentAddressGroup endpoint2 = makeAddress("endpoint-addr2", locality);
+    deliverAddressesAndConfig(Arrays.asList(endpoint1, endpoint2), config);
+    assertThat(downstreamBalancers).hasSize(1);  // one leaf balancer
+    FakeLoadBalancer leafBalancer = Iterables.getOnlyElement(downstreamBalancers);
+    assertThat(leafBalancer.name).isEqualTo("round_robin");
+    // Simulates leaf load balancer creating subchannels.
+    CreateSubchannelArgs args =
+        CreateSubchannelArgs.newBuilder()
+            .setAddresses(leafBalancer.addresses)
+            .build();
+    Subchannel subchannel = leafBalancer.helper.createSubchannel(args);
+    for (EquivalentAddressGroup eag : subchannel.getAllAddresses()) {
+      SslContextProviderSupplier supplier =
+          eag.getAttributes().get(SecurityProtocolNegotiators.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER);
+      assertThat(supplier.getTlsContext()).isEqualTo(upstreamTlsContext);
+    }
+
+    // Removes UpstreamTlsContext from the config.
+    config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        null, Collections.emptyMap(), null);
+    deliverAddressesAndConfig(Arrays.asList(endpoint1, endpoint2), config);
+    assertThat(Iterables.getOnlyElement(downstreamBalancers)).isSameInstanceAs(leafBalancer);
+    subchannel = leafBalancer.helper.createSubchannel(args);  // creates new connections
+    for (EquivalentAddressGroup eag : subchannel.getAllAddresses()) {
+      assertThat(
+            eag.getAttributes().get(SecurityProtocolNegotiators.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER))
+          .isNull();
+    }
+
+    // Config with a new UpstreamTlsContext.
+    upstreamTlsContext = CommonTlsContextTestsUtil.buildUpstreamTlsContext(
+        "google_cloud_private_spiffe1", true);
+    config = new ClusterImplConfig(CLUSTER, EDS_SERVICE_NAME, LRS_SERVER_INFO,
+        null, Collections.<DropOverload>emptyList(),
+        GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+            weightedTargetProvider, weightedTargetConfig),
+        upstreamTlsContext, Collections.emptyMap(), null);
+    deliverAddressesAndConfig(Arrays.asList(endpoint1, endpoint2), config);
+    assertThat(Iterables.getOnlyElement(downstreamBalancers)).isSameInstanceAs(leafBalancer);
+    subchannel = leafBalancer.helper.createSubchannel(args);  // creates new connections
+    for (EquivalentAddressGroup eag : subchannel.getAllAddresses()) {
+      SslContextProviderSupplier supplier =
+          eag.getAttributes().get(SecurityProtocolNegotiators.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER);
+      assertThat(supplier.isShutdown()).isFalse();
+      assertThat(supplier.getTlsContext()).isEqualTo(upstreamTlsContext);
+    }
+    loadBalancer.shutdown();
+    for (EquivalentAddressGroup eag : subchannel.getAllAddresses()) {
+      SslContextProviderSupplier supplier =
+          eag.getAttributes().get(SecurityProtocolNegotiators.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER);
+      assertThat(supplier.isShutdown()).isTrue();
+    }
+    loadBalancer = null;
+  }
+
+  private void deliverAddressesAndConfig(List<EquivalentAddressGroup> addresses,
+      ClusterImplConfig config) {
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(addresses)
+            .setAttributes(
+                Attributes.newBuilder()
+                    .set(io.grpc.xds.XdsAttributes.XDS_CLIENT, xdsClient)
+                    .set(io.grpc.xds.XdsAttributes.CALL_COUNTER_PROVIDER, callCounterProvider)
+                    .build())
+            .setLoadBalancingPolicyConfig(config)
+            .build());
+  }
+
+  private WeightedTargetConfig buildWeightedTargetConfig(Map<Locality, Integer> localityWeights) {
+    Map<String, WeightedPolicySelection> targets = new HashMap<>();
+    for (Locality locality : localityWeights.keySet()) {
+      int weight = localityWeights.get(locality);
+      WeightedPolicySelection weightedLocalityLbPolicy =
+          new WeightedPolicySelection(weight, roundRobin);
+      targets.put(locality.toString(), weightedLocalityLbPolicy);
+    }
+    return new WeightedTargetConfig(Collections.unmodifiableMap(targets));
+  }
+
+  /**
+   * Create a locality-labeled address.
+   */
+  private static EquivalentAddressGroup makeAddress(final String name, Locality locality) {
+    return makeAddress(name, locality, null);
+  }
+
+  private static EquivalentAddressGroup makeAddress(final String name, Locality locality,
+      String authorityHostname) {
+    class FakeSocketAddress extends SocketAddress {
+      private final String name;
+
+      private FakeSocketAddress(String name) {
+        this.name = name;
+      }
+
+      @Override
+      public int hashCode() {
+        return Objects.hash(name);
+      }
+
+      @Override
+      public boolean equals(Object o) {
+        if (this == o) {
+          return true;
+        }
+        if (!(o instanceof FakeSocketAddress)) {
+          return false;
+        }
+        FakeSocketAddress that = (FakeSocketAddress) o;
+        return Objects.equals(name, that.name);
+      }
+
+      @Override
+      public String toString() {
+        return name;
+      }
+    }
+
+    Attributes.Builder attributes = Attributes.newBuilder()
+        .set(io.grpc.xds.XdsAttributes.ATTR_LOCALITY, locality)
+        // Unique but arbitrary string
+        .set(EquivalentAddressGroup.ATTR_LOCALITY_NAME, locality.toString());
+    if (authorityHostname != null) {
+      attributes.set(XdsInternalAttributes.ATTR_ADDRESS_NAME, authorityHostname);
+    }
+    EquivalentAddressGroup eag = new EquivalentAddressGroup(new FakeSocketAddress(name),
+        attributes.build());
+    return AddressFilter.setPathFilter(eag, Collections.singletonList(locality.toString()));
+  }
+
+  private final class FakeLoadBalancerProvider extends LoadBalancerProvider {
+    private final String policyName;
+
+    FakeLoadBalancerProvider(String policyName) {
+      this.policyName = policyName;
+    }
+
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      FakeLoadBalancer balancer = new FakeLoadBalancer(policyName, helper);
+      downstreamBalancers.add(balancer);
+      return balancer;
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 0;  // doesn't matter
+    }
+
+    @Override
+    public String getPolicyName() {
+      return policyName;
+    }
+  }
+
+  private final class FakeLoadBalancer extends LoadBalancer {
+    private final String name;
+    private final Helper helper;
+    private List<EquivalentAddressGroup> addresses;
+    private Object config;
+    private Attributes attributes;
+    private Status upstreamError;
+
+    FakeLoadBalancer(String name, Helper helper) {
+      this.name = name;
+      this.helper = helper;
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      addresses = resolvedAddresses.getAddresses();
+      config = resolvedAddresses.getLoadBalancingPolicyConfig();
+      attributes = resolvedAddresses.getAttributes();
+      return Status.OK;
+    }
+
+    @Override
+    public void handleNameResolutionError(Status error) {
+      upstreamError = error;
+    }
+
+    @Override
+    public void shutdown() {
+      downstreamBalancers.remove(this);
+    }
+
+    void deliverSubchannelState(final Subchannel subchannel, ConnectivityState state) {
+      deliverSubchannelState(PickResult.withSubchannel(subchannel), state);
+    }
+
+    void deliverSubchannelState(final PickResult result, ConnectivityState state) {
+      SubchannelPicker picker = new SubchannelPicker() {
+        @Override
+        public PickResult pickSubchannel(PickSubchannelArgs args) {
+          return result;
+        }
+      };
+      helper.updateBalancingState(state, picker);
+    }
+
+    Subchannel createSubChannel() {
+      Subchannel subchannel = helper.createSubchannel(
+          CreateSubchannelArgs.newBuilder().setAddresses(addresses).build());
+      subchannel.start(infoObject -> {
+        if (infoObject.getState() == ConnectivityState.READY) {
+          helper.updateBalancingState(
+              ConnectivityState.READY,
+              new FixedResultPicker(PickResult.withSubchannel(subchannel)));
+        }
+      });
+      subchannel.requestConnection();
+      return subchannel;
+    }
+  }
+
+  private final class FakeLbHelper extends LoadBalancer.Helper {
+
+    private final Queue<FakeSubchannel> subchannels = new LinkedList<>();
+
+    @Override
+    public SynchronizationContext getSynchronizationContext() {
+      return syncContext;
+    }
+
+    @Override
+    public void updateBalancingState(
+        @Nonnull ConnectivityState newState, @Nonnull SubchannelPicker newPicker) {
+      currentState = newState;
+      currentPicker = newPicker;
+    }
+
+    @Override
+    public Subchannel createSubchannel(CreateSubchannelArgs args) {
+      FakeSubchannel subchannel = new FakeSubchannel(args.getAddresses(), args.getAttributes());
+      subchannels.add(subchannel);
+      return subchannel;
+    }
+
+    @Override
+    public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String authority) {
+      throw new UnsupportedOperationException("should not be called");
+    }
+
+    @Override
+    public String getAuthority() {
+      return AUTHORITY;
+    }
+
+    @Override
+    public void refreshNameResolution() {}
+  }
+
+  private static final class FakeSubchannel extends Subchannel {
+    private final List<EquivalentAddressGroup> eags;
+    private final Attributes attrs;
+    private SubchannelStateListener listener;
+    private Attributes connectedAttributes;
+    private ConnectivityStateInfo state = ConnectivityStateInfo.forNonError(ConnectivityState.IDLE);
+    private boolean connectionRequested;
+
+    private FakeSubchannel(List<EquivalentAddressGroup> eags, Attributes attrs) {
+      this.eags = eags;
+      this.attrs = attrs;
+    }
+
+    @Override
+    public void start(SubchannelStateListener listener) {
+      this.listener = checkNotNull(listener, "listener");
+    }
+
+    @Override
+    public void shutdown() {
+    }
+
+    @Override
+    public void requestConnection() {
+      if (state.getState() == ConnectivityState.IDLE) {
+        this.connectionRequested = true;
+      }
+    }
+
+    @Override
+    public List<EquivalentAddressGroup> getAllAddresses() {
+      return eags;
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return attrs;
+    }
+
+    @Override
+    public void updateAddresses(List<EquivalentAddressGroup> addrs) {
+    }
+
+    @Override
+    public Attributes getConnectedAddressAttributes() {
+      return connectedAttributes;
+    }
+
+    public void updateState(ConnectivityStateInfo newState) {
+      switch (newState.getState()) {
+        case IDLE:
+          assertThat(state.getState()).isEqualTo(ConnectivityState.READY);
+          break;
+        case CONNECTING:
+          assertThat(state.getState())
+              .isIn(Arrays.asList(ConnectivityState.IDLE, ConnectivityState.TRANSIENT_FAILURE));
+          if (state.getState() == ConnectivityState.IDLE) {
+            assertWithMessage("Connection requested").that(this.connectionRequested).isTrue();
+            this.connectionRequested = false;
+          }
+          break;
+        case READY:
+        case TRANSIENT_FAILURE:
+          assertThat(state.getState()).isEqualTo(ConnectivityState.CONNECTING);
+          break;
+        default:
+          break;
+      }
+      this.state = newState;
+      listener.onSubchannelState(newState);
+    }
+
+    public void setConnectedEagIndex(int eagIndex) {
+      this.connectedAttributes = eags.get(eagIndex).getAttributes();
+    }
+  }
+
+  private final class FakeXdsClient extends XdsClient {
+
+    @Override
+    public ClusterDropStats addClusterDropStats(
+        ServerInfo lrsServerInfo, String clusterName, @Nullable String edsServiceName) {
+      return loadStatsManager.getClusterDropStats(clusterName, edsServiceName);
+    }
+
+    @Override
+    public ClusterLocalityStats addClusterLocalityStats(
+        ServerInfo lrsServerInfo, String clusterName, @Nullable String edsServiceName,
+        Locality locality, BackendMetricPropagation backendMetricPropagation) {
+      return loadStatsManager.getClusterLocalityStats(
+          clusterName, edsServiceName, locality, backendMetricPropagation);
+    }
+
+    @Override
+    public TlsContextManager getSecurityConfig() {
+      return tlsContextManager;
+    }
+
+    @Override
+    public Map<ServerInfo, LoadReportClient> getServerLrsClientMap() {
+      return null;
+    }
+  }
+
+  private static final class FakeTlsContextManager implements TlsContextManager {
+    @Override
+    public SslContextProvider findOrCreateClientSslContextProvider(
+        UpstreamTlsContext upstreamTlsContext) {
+      SslContextProvider sslContextProvider = mock(SslContextProvider.class);
+      when(sslContextProvider.getUpstreamTlsContext()).thenReturn(upstreamTlsContext);
+      return sslContextProvider;
+    }
+
+    @Override
+    public SslContextProvider releaseClientSslContextProvider(
+        SslContextProvider sslContextProvider) {
+      // no-op
+      return null;
+    }
+
+    @Override
+    public SslContextProvider findOrCreateServerSslContextProvider(
+        DownstreamTlsContext downstreamTlsContext) {
+      throw new UnsupportedOperationException("should not be called");
+    }
+
+    @Override
+    public SslContextProvider releaseServerSslContextProvider(
+        SslContextProvider sslContextProvider) {
+      throw new UnsupportedOperationException("should not be called");
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerProviderTest.java b/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..40943658520
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerProviderTest.java
@@ -0,0 +1,163 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.internal.JsonParser;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.xds.ClusterManagerLoadBalancerProvider.ClusterManagerConfig;
+import java.io.IOException;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link ClusterManagerLoadBalancerProvider}. */
+@RunWith(JUnit4.class)
+public class ClusterManagerLoadBalancerProviderTest {
+
+  private final LoadBalancerRegistry lbRegistry = new LoadBalancerRegistry();
+  private final ClusterManagerLoadBalancerProvider provider =
+      new ClusterManagerLoadBalancerProvider(lbRegistry);
+
+  @Test
+  public void parseLoadBalancingConfig_valid() throws IOException {
+    final Object fooConfig = new Object();
+    LoadBalancerProvider lbProviderFoo = new LoadBalancerProvider() {
+      @Override
+      public boolean isAvailable() {
+        return true;
+      }
+
+      @Override
+      public int getPriority() {
+        return 5;
+      }
+
+      @Override
+      public String getPolicyName() {
+        return "foo_policy";
+      }
+
+      @Override
+      public LoadBalancer newLoadBalancer(Helper helper) {
+        throw new UnsupportedOperationException("Should not be called");
+      }
+
+      @Override
+      public ConfigOrError parseLoadBalancingPolicyConfig(
+          Map<String, ?> rawLoadBalancingPolicyConfig) {
+        return ConfigOrError.fromConfig(fooConfig);
+      }
+    };
+    final Object barConfig = new Object();
+    LoadBalancerProvider lbProviderBar = new LoadBalancerProvider() {
+      @Override
+      public boolean isAvailable() {
+        return true;
+      }
+
+      @Override
+      public int getPriority() {
+        return 5;
+      }
+
+      @Override
+      public String getPolicyName() {
+        return "bar_policy";
+      }
+
+      @Override
+      public LoadBalancer newLoadBalancer(Helper helper) {
+        throw new UnsupportedOperationException("Should not be called");
+      }
+
+      @Override
+      public ConfigOrError parseLoadBalancingPolicyConfig(
+          Map<String, ?> rawLoadBalancingPolicyConfig) {
+        return ConfigOrError.fromConfig(barConfig);
+      }
+    };
+    lbRegistry.register(lbProviderFoo);
+    lbRegistry.register(lbProviderBar);
+
+    String clusterManagerConfigJson = "{\n"
+        + "  \"childPolicy\": {\n"
+        + "    \"child1\": {\n"
+        + "      \"lbPolicy\": [\n"
+        + "        {\n"
+        + "          \"foo_policy\": {"
+        + "            \"config_name\": \"config_value\"\n"
+        + "          }\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    },\n"
+        + "    \"child2\": {\n"
+        + "      \"lbPolicy\": [\n"
+        + "        {\n"
+        + "          \"bar_policy\": {}\n"
+        + "        }, {\n"
+        + "          \"unsupported\": {}\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  }\n"
+        + "}";
+    @SuppressWarnings("unchecked")
+    Map<String, ?> rawLbConfigMap = (Map<String, ?>) JsonParser.parse(clusterManagerConfigJson);
+    ConfigOrError configOrError = provider.parseLoadBalancingPolicyConfig(rawLbConfigMap);
+    assertThat(configOrError.getConfig()).isNotNull();
+    ClusterManagerConfig config = (ClusterManagerConfig) configOrError.getConfig();
+    assertThat(config.childPolicies)
+        .containsExactly(
+            "child1",
+            GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(lbProviderFoo, fooConfig),
+            "child2",
+            GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(lbProviderBar, barConfig));
+  }
+
+  @Test
+  public void parseLoadBalancingPolicyConfig_emptyChildPolicy() throws IOException {
+    String clusterManagerConfigJson = "{\n"
+        + "  \"childPolicy\": {}\n"
+        + "}";
+    @SuppressWarnings("unchecked")
+    Map<String, ?> rawLbConfigMap = (Map<String, ?>) JsonParser.parse(clusterManagerConfigJson);
+    ConfigOrError configOrError = provider.parseLoadBalancingPolicyConfig(rawLbConfigMap);
+    Status error = configOrError.getError();
+    assertThat(error.getCode()).isEqualTo(Code.INTERNAL);
+    assertThat(error.getDescription())
+        .startsWith("No child policy provided for cluster_manager LB policy");
+  }
+
+  @Test
+  public void registered() {
+    LoadBalancerProvider provider =
+        LoadBalancerRegistry
+            .getDefaultRegistry()
+            .getProvider("cluster_manager_experimental");
+    assertThat(provider).isInstanceOf(ClusterManagerLoadBalancerProvider.class);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerTest.java b/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerTest.java
new file mode 100644
index 00000000000..8856efd685f
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/ClusterManagerLoadBalancerTest.java
@@ -0,0 +1,409 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableMap;
+import io.grpc.CallOptions;
+import io.grpc.ConnectivityState;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickDetailsConsumer;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.PickSubchannelArgsImpl;
+import io.grpc.testing.TestMethodDescriptors;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.xds.ClusterManagerLoadBalancerProvider.ClusterManagerConfig;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Tests for {@link ClusterManagerLoadBalancer}. */
+@RunWith(JUnit4.class)
+public class ClusterManagerLoadBalancerTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final FakeClock fakeClock = new FakeClock();
+
+  @Captor
+  ArgumentCaptor<SubchannelPicker> pickerCaptor;
+  @Mock
+  private LoadBalancer.Helper helper;
+
+  private final Map<String, Object> lbConfigInventory = new HashMap<>();
+  private final List<FakeLoadBalancer> childBalancers = new ArrayList<>();
+  private ClusterManagerLoadBalancer clusterManagerLoadBalancer;
+
+  @Before
+  public void setUp() {
+    when(helper.getSynchronizationContext()).thenReturn(syncContext);
+    when(helper.getScheduledExecutorService()).thenReturn(fakeClock.getScheduledExecutorService());
+    lbConfigInventory.put("childA", new Object());
+    lbConfigInventory.put("childB", new Object());
+    lbConfigInventory.put("childC", null);
+    clusterManagerLoadBalancer = new ClusterManagerLoadBalancer(helper);
+    clearInvocations(helper);
+  }
+
+  @After
+  public void tearDown() {
+    clusterManagerLoadBalancer.shutdown();
+    for (FakeLoadBalancer childLb : childBalancers) {
+      assertThat(childLb.shutdown).isTrue();
+    }
+  }
+
+  @Test
+  public void acceptResolvedAddressesUpdatesChannelPicker() {
+    deliverResolvedAddresses(ImmutableMap.of("childA", "policy_a", "childB", "policy_b"));
+
+    verify(helper, atLeastOnce()).updateBalancingState(
+        eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertThat(pickSubchannel(picker, "childA")).isEqualTo(PickResult.withNoResult());
+    assertThat(pickSubchannel(picker, "childB")).isEqualTo(PickResult.withNoResult());
+    assertThat(childBalancers).hasSize(2);
+    assertThat(childBalancers.stream()
+        .filter(b -> b.name.equals("policy_a"))
+        .count()).isEqualTo(1);
+    assertThat(childBalancers.stream()
+        .filter(b -> b.name.equals("policy_b"))
+        .count()).isEqualTo(1);
+    FakeLoadBalancer childBalancer1 = getChildBalancerByName("policy_a");
+    FakeLoadBalancer childBalancer2 = getChildBalancerByName("policy_b");
+    assertThat(childBalancer1.config).isEqualTo(lbConfigInventory.get("childA"));
+    assertThat(childBalancer2.config).isEqualTo(lbConfigInventory.get("childB"));
+
+    // Receive an updated config.
+    deliverResolvedAddresses(ImmutableMap.of("childA", "policy_a", "childC", "policy_c"));
+
+    verify(helper, atLeast(2))
+        .updateBalancingState(eq(ConnectivityState.CONNECTING), pickerCaptor.capture());
+    picker = pickerCaptor.getValue();
+    assertThat(pickSubchannel(picker, "childA")).isEqualTo(PickResult.withNoResult());
+    assertThat(pickSubchannel(picker, "childC")).isEqualTo(PickResult.withNoResult());
+    Status status = pickSubchannel(picker, "childB").getStatus();
+    assertThat(status.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(status.getDescription()).isEqualTo(
+        "CDS encountered error: unable to find available subchannel for cluster childB");
+    assertThat(fakeClock.numPendingTasks())
+        .isEqualTo(1);  // (delayed) shutdown because "childB" is removed
+    assertThat(childBalancer1.shutdown).isFalse();
+    assertThat(childBalancer2.shutdown).isFalse();
+
+    assertThat(childBalancers).hasSize(3);
+    FakeLoadBalancer childBalancer3 = getChildBalancerByName("policy_c");
+    assertThat(childBalancer3.config).isEqualTo(lbConfigInventory.get("childC"));
+
+    // delayed policy_b deletion
+    fakeClock.forwardTime(
+        ClusterManagerLoadBalancer.DELAYED_CHILD_DELETION_TIME_MINUTES, TimeUnit.MINUTES);
+    assertThat(childBalancer2.shutdown).isTrue();
+  }
+
+  @Test
+  public void updateBalancingStateFromChildBalancers() {
+    deliverResolvedAddresses(ImmutableMap.of("childA", "policy_a", "childB", "policy_b"));
+
+    assertThat(childBalancers).hasSize(2);
+    FakeLoadBalancer childBalancer1 = getChildBalancerByName("policy_a");
+    FakeLoadBalancer childBalancer2 = getChildBalancerByName("policy_b");
+    Subchannel subchannel1 = mock(Subchannel.class);
+    Subchannel subchannel2 = mock(Subchannel.class);
+    childBalancer1.deliverSubchannelState(subchannel1, ConnectivityState.READY);
+
+    verify(helper).updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertThat(pickSubchannel(picker, "childA").getSubchannel()).isEqualTo(subchannel1);
+    assertThat(pickSubchannel(picker, "childB")).isEqualTo(PickResult.withNoResult());
+
+    childBalancer2.deliverSubchannelState(subchannel2, ConnectivityState.READY);
+    verify(helper, times(2))
+        .updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
+    assertThat(pickSubchannel(pickerCaptor.getValue(), "childB").getSubchannel())
+        .isEqualTo(subchannel2);
+  }
+
+  private FakeLoadBalancer getChildBalancerByName(String name) {
+    for (FakeLoadBalancer childLb : childBalancers) {
+      if (childLb.name.equals(name)) {
+        return childLb;
+      }
+    }
+    return null;
+  }
+
+  @Test
+  public void ignoreBalancingStateUpdateForDeactivatedChildLbs() {
+    deliverResolvedAddresses(ImmutableMap.of("childA", "policy_a", "childB", "policy_b"));
+    deliverResolvedAddresses(ImmutableMap.of("childB", "policy_b"));
+    FakeLoadBalancer childBalancer1 = getChildBalancerByName("policy_a");  // policy_a (deactivated)
+    Subchannel subchannel = mock(Subchannel.class);
+    childBalancer1.deliverSubchannelState(subchannel, ConnectivityState.READY);
+    verify(helper, never()).updateBalancingState(
+        eq(ConnectivityState.READY), any(SubchannelPicker.class));
+
+    // Reactivate policy_a, balancing state update reflects the latest connectivity state and
+    // picker.
+    deliverResolvedAddresses(ImmutableMap.of("childA", "policy_a", "childB", "policy_b"));
+    verify(helper).updateBalancingState(eq(ConnectivityState.READY), pickerCaptor.capture());
+    assertThat(pickSubchannel(pickerCaptor.getValue(), "childA").getSubchannel())
+        .isEqualTo(subchannel);
+  }
+
+  @Test
+  public void raceBetweenShutdownAndChildLbBalancingStateUpdate() {
+    deliverResolvedAddresses(ImmutableMap.of("childA", "policy_a", "childB", "policy_b"));
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.CONNECTING), any(SubchannelPicker.class));
+    FakeLoadBalancer childBalancer = childBalancers.iterator().next();
+
+    // LB shutdown and subchannel state change can happen simultaneously. If shutdown runs first,
+    // any further balancing state update should be ignored.
+    clusterManagerLoadBalancer.shutdown();
+    childBalancer.deliverSubchannelState(mock(Subchannel.class), ConnectivityState.READY);
+    verifyNoMoreInteractions(helper);
+  }
+
+  @Test
+  public void handleNameResolutionError_beforeChildLbsInstantiated_returnErrorPicker() {
+    clusterManagerLoadBalancer.handleNameResolutionError(
+        Status.UNAVAILABLE.withDescription("resolver error"));
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
+    assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(result.getStatus().getDescription()).isEqualTo("resolver error");
+  }
+
+  @Test
+  public void handleNameResolutionError_afterChildLbsInstantiated_propagateToChildLbs() {
+    deliverResolvedAddresses(ImmutableMap.of("childA", "policy_a", "childB", "policy_b"));
+    assertThat(childBalancers).hasSize(2);
+    FakeLoadBalancer childBalancer1 = getChildBalancerByName("policy_a");
+    FakeLoadBalancer childBalancer2 = getChildBalancerByName("policy_b");
+    clusterManagerLoadBalancer.handleNameResolutionError(
+        Status.UNAVAILABLE.withDescription("resolver error"));
+    assertThat(childBalancer1.upstreamError.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(childBalancer1.upstreamError.getDescription()).isEqualTo("resolver error");
+    assertThat(childBalancer2.upstreamError.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(childBalancer2.upstreamError.getDescription()).isEqualTo("resolver error");
+  }
+
+  @Test
+  public void handleNameResolutionError_notPropagateToDeactivatedChildLbs() {
+    deliverResolvedAddresses(ImmutableMap.of("childA", "policy_a", "childB", "policy_b"));
+    deliverResolvedAddresses(ImmutableMap.of("childB", "policy_b"));
+    FakeLoadBalancer childBalancer1 = getChildBalancerByName("policy_a");  // policy_a (deactivated)
+    FakeLoadBalancer childBalancer2 = getChildBalancerByName("policy_b");  // policy_b
+    clusterManagerLoadBalancer.handleNameResolutionError(
+        Status.UNKNOWN.withDescription("unknown error"));
+    assertThat(childBalancer1.upstreamError).isNull();
+    assertThat(childBalancer2.upstreamError.getCode()).isEqualTo(Code.UNKNOWN);
+    assertThat(childBalancer2.upstreamError.getDescription()).isEqualTo("unknown error");
+  }
+
+  @Test
+  public void noDuplicateOverallBalancingStateUpdate() {
+    deliverResolvedAddresses(ImmutableMap.of("childA", "policy_a", "childB", "policy_b"), true);
+
+    // The test child LBs would have triggered state updates, let's make sure the overall balancing
+    // state was only updated once but that the new state reflects the state the child LB reported.
+    verify(helper, times(1)).updateBalancingState(
+        eq(TRANSIENT_FAILURE), isA(SubchannelPicker.class));
+  }
+
+  private void deliverResolvedAddresses(final Map<String, String> childPolicies) {
+    deliverResolvedAddresses(childPolicies, false);
+  }
+
+  private void deliverResolvedAddresses(final Map<String, String> childPolicies, boolean failing) {
+    clusterManagerLoadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
+            .setLoadBalancingPolicyConfig(buildConfig(childPolicies, failing))
+            .build());
+  }
+
+  // Prevent ClusterManagerLB from detecting different providers even when the configuration is the
+  // same.
+  private Map<List<Object>, FakeLoadBalancerProvider> fakeLoadBalancerProviderCache
+      = new HashMap<>();
+
+  private ClusterManagerConfig buildConfig(Map<String, String> childPolicies, boolean failing) {
+    Map<String, Object> childConfigs = new LinkedHashMap<>();
+    for (String name : childPolicies.keySet()) {
+      String childPolicyName = childPolicies.get(name);
+      Object childConfig = lbConfigInventory.get(name);
+      FakeLoadBalancerProvider lbProvider =
+          fakeLoadBalancerProviderCache.get(Arrays.asList(childPolicyName, failing));
+      if (lbProvider == null) {
+        lbProvider = new FakeLoadBalancerProvider(childPolicyName, failing);
+        fakeLoadBalancerProviderCache.put(Arrays.asList(childPolicyName, failing), lbProvider);
+      }
+      Object policy =
+          GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(lbProvider, childConfig);
+      childConfigs.put(name, policy);
+    }
+    return new ClusterManagerConfig(childConfigs);
+  }
+
+  private static PickResult pickSubchannel(SubchannelPicker picker, String clusterName) {
+    PickSubchannelArgs args =
+        new PickSubchannelArgsImpl(
+            MethodDescriptor.<Void, Void>newBuilder()
+                .setType(MethodType.UNARY)
+                .setFullMethodName("/service/method")
+                .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+                .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
+                .build(),
+            new Metadata(),
+            CallOptions.DEFAULT.withOption(
+                XdsNameResolver.CLUSTER_SELECTION_KEY, clusterName),
+            new PickDetailsConsumer() {});
+    return picker.pickSubchannel(args);
+  }
+
+  private final class FakeLoadBalancerProvider extends LoadBalancerProvider {
+    private final String policyName;
+    private final boolean failing;
+
+    FakeLoadBalancerProvider(String policyName, boolean failing) {
+      this.policyName = policyName;
+      this.failing = failing;
+    }
+
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      FakeLoadBalancer balancer = new FakeLoadBalancer(policyName, helper, failing);
+      childBalancers.add(balancer);
+      return balancer;
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 0;  // doesn't matter
+    }
+
+    @Override
+    public String getPolicyName() {
+      return policyName;
+    }
+  }
+
+  private final class FakeLoadBalancer extends LoadBalancer {
+    private final String name;
+    private final Helper helper;
+    private final boolean failing;
+    private Object config;
+    private Status upstreamError;
+    private boolean shutdown;
+
+    FakeLoadBalancer(String name, Helper helper, boolean failing) {
+      this.name = name;
+      this.helper = helper;
+      this.failing = failing;
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      config = resolvedAddresses.getLoadBalancingPolicyConfig();
+
+      if (failing) {
+        helper.updateBalancingState(
+            TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.INTERNAL)));
+      }
+      return Status.OK;
+    }
+
+    @Override
+    public void handleNameResolutionError(Status error) {
+      upstreamError = error;
+    }
+
+    @Override
+    public void shutdown() {
+      shutdown = true;
+      childBalancers.remove(this);
+    }
+
+    void deliverSubchannelState(final Subchannel subchannel, ConnectivityState state) {
+      SubchannelPicker picker = new SubchannelPicker() {
+        @Override
+        public PickResult pickSubchannel(PickSubchannelArgs args) {
+          return PickResult.withSubchannel(subchannel);
+        }
+      };
+      helper.updateBalancingState(state, picker);
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/ClusterResolverLoadBalancerTest.java b/xds/src/test/java/io/grpc/xds/ClusterResolverLoadBalancerTest.java
new file mode 100644
index 00000000000..5e524f79596
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/ClusterResolverLoadBalancerTest.java
@@ -0,0 +1,1231 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.XdsLbPolicies.CLUSTER_IMPL_POLICY_NAME;
+import static io.grpc.xds.XdsLbPolicies.PRIORITY_POLICY_NAME;
+import static io.grpc.xds.XdsLbPolicies.WEIGHTED_TARGET_POLICY_NAME;
+import static io.grpc.xds.XdsLbPolicies.WRR_LOCALITY_POLICY_NAME;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_CDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_EDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_LDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_RDS;
+import static java.util.stream.Collectors.toList;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.protobuf.Any;
+import com.google.protobuf.Duration;
+import com.google.protobuf.UInt32Value;
+import com.google.protobuf.UInt64Value;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.cluster.v3.OutlierDetection;
+import io.envoyproxy.envoy.config.core.v3.Address;
+import io.envoyproxy.envoy.config.core.v3.AggregatedConfigSource;
+import io.envoyproxy.envoy.config.core.v3.ConfigSource;
+import io.envoyproxy.envoy.config.core.v3.HealthStatus;
+import io.envoyproxy.envoy.config.core.v3.Locality;
+import io.envoyproxy.envoy.config.core.v3.Metadata;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress;
+import io.envoyproxy.envoy.config.core.v3.TransportSocket;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;
+import io.envoyproxy.envoy.config.endpoint.v3.Endpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints;
+import io.envoyproxy.envoy.extensions.transport_sockets.http_11_proxy.v3.Http11ProxyUpstreamTransport;
+import io.grpc.Attributes;
+import io.grpc.ChannelLogger;
+import io.grpc.ConnectivityState;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.HttpConnectProxiedSocketAddress;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.NameResolverProvider;
+import io.grpc.NameResolverRegistry;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.SynchronizationContext;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.util.GracefulSwitchLoadBalancerAccessor;
+import io.grpc.util.OutlierDetectionLoadBalancer.OutlierDetectionLoadBalancerConfig;
+import io.grpc.util.OutlierDetectionLoadBalancerProvider;
+import io.grpc.xds.CdsLoadBalancerProvider.CdsConfig;
+import io.grpc.xds.ClusterImplLoadBalancerProvider.ClusterImplConfig;
+import io.grpc.xds.Endpoints.DropOverload;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig;
+import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig.PriorityChildConfig;
+import io.grpc.xds.RingHashLoadBalancer.RingHashConfig;
+import io.grpc.xds.WrrLocalityLoadBalancer.WrrLocalityConfig;
+import io.grpc.xds.client.BackendMetricPropagation;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.LoadStatsManager2;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.internal.XdsInternalAttributes;
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Tests for {@link ClusterResolverLoadBalancer}. */
+@RunWith(JUnit4.class)
+public class ClusterResolverLoadBalancerTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+  @Rule
+  public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+
+  private static final String SERVER_NAME = "example.com";
+  private static final String CLUSTER = "cluster-foo.googleapis.com";
+  private static final String EDS_SERVICE_NAME = "backend-service-foo.googleapis.com";
+  private static final String DNS_HOST_NAME = "dns-service.googleapis.com";
+  private static final Cluster EDS_CLUSTER = Cluster.newBuilder()
+      .setName(CLUSTER)
+      .setType(Cluster.DiscoveryType.EDS)
+      .setEdsClusterConfig(Cluster.EdsClusterConfig.newBuilder()
+          .setServiceName(EDS_SERVICE_NAME)
+          .setEdsConfig(ConfigSource.newBuilder()
+            .setAds(AggregatedConfigSource.newBuilder())))
+      .build();
+  private static final Cluster LOGICAL_DNS_CLUSTER = Cluster.newBuilder()
+      .setName(CLUSTER)
+      .setType(Cluster.DiscoveryType.LOGICAL_DNS)
+      .setLoadAssignment(ClusterLoadAssignment.newBuilder()
+          .addEndpoints(LocalityLbEndpoints.newBuilder()
+            .addLbEndpoints(newSocketLbEndpoint(DNS_HOST_NAME, 9000))))
+      .build();
+  private static final Locality LOCALITY1 = Locality.newBuilder()
+      .setRegion("test-region-1")
+      .setZone("test-zone-1")
+      .setSubZone("test-subzone-1")
+      .build();
+  private static final Locality LOCALITY2 = Locality.newBuilder()
+      .setRegion("test-region-2")
+      .setZone("test-zone-2")
+      .setSubZone("test-subzone-2")
+      .build();
+  private static final Locality LOCALITY3 = Locality.newBuilder()
+      .setRegion("test-region-3")
+      .setZone("test-zone-3")
+      .setSubZone("test-subzone-3")
+      .build();
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final FakeClock fakeClock = new FakeClock();
+  private final LoadBalancerRegistry lbRegistry = new LoadBalancerRegistry();
+  private final NameResolverRegistry nsRegistry = new NameResolverRegistry();
+  private final List<FakeLoadBalancer> childBalancers = new ArrayList<>();
+  private final List<FakeNameResolver> resolvers = new ArrayList<>();
+  private final XdsTestControlPlaneService controlPlaneService = new XdsTestControlPlaneService();
+  private final XdsClient xdsClient = XdsTestUtils.createXdsClient(
+      Arrays.asList("control-plane.example.com"),
+      serverInfo -> new GrpcXdsTransportFactory.GrpcXdsTransport(
+          InProcessChannelBuilder
+            .forName(serverInfo.target())
+            .directExecutor()
+            .build()),
+      fakeClock);
+
+
+  private XdsDependencyManager xdsDepManager;
+  @Mock
+  private Helper helper;
+  @Captor
+  private ArgumentCaptor<SubchannelPicker> pickerCaptor;
+  private CdsLoadBalancer2 loadBalancer;
+  private boolean originalIsEnabledXdsHttpConnect;
+
+  @Before
+  public void setUp() throws Exception {
+    lbRegistry.register(new RingHashLoadBalancerProvider());
+    lbRegistry.register(new WrrLocalityLoadBalancerProvider());
+    lbRegistry.register(new FakeLoadBalancerProvider(PRIORITY_POLICY_NAME));
+    lbRegistry.register(new FakeLoadBalancerProvider(CLUSTER_IMPL_POLICY_NAME));
+    lbRegistry.register(new FakeLoadBalancerProvider(WEIGHTED_TARGET_POLICY_NAME));
+    lbRegistry.register(
+        new FakeLoadBalancerProvider("pick_first")); // needed by logical_dns
+    lbRegistry.register(new OutlierDetectionLoadBalancerProvider());
+    NameResolver.Args args = NameResolver.Args.newBuilder()
+        .setDefaultPort(8080)
+        .setProxyDetector(GrpcUtil.NOOP_PROXY_DETECTOR)
+        .setSynchronizationContext(syncContext)
+        .setServiceConfigParser(mock(ServiceConfigParser.class))
+        .setChannelLogger(mock(ChannelLogger.class))
+        .setScheduledExecutorService(fakeClock.getScheduledExecutorService())
+        .setNameResolverRegistry(nsRegistry)
+        .build();
+
+    xdsDepManager = new XdsDependencyManager(
+        xdsClient,
+        syncContext,
+        SERVER_NAME,
+        SERVER_NAME,
+        args);
+
+    cleanupRule.register(InProcessServerBuilder
+        .forName("control-plane.example.com")
+        .addService(controlPlaneService)
+        .directExecutor()
+        .build()
+        .start());
+
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_LDS, ImmutableMap.of(
+        SERVER_NAME, ControlPlaneRule.buildClientListener(SERVER_NAME, "my-route")));
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_RDS, ImmutableMap.of(
+        "my-route", XdsTestUtils.buildRouteConfiguration(SERVER_NAME, "my-route", CLUSTER)));
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        CLUSTER, EDS_CLUSTER));
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, ControlPlaneRule.buildClusterLoadAssignment(
+            "127.0.0.1", "", 8080, EDS_SERVICE_NAME)));
+
+    nsRegistry.register(new FakeNameResolverProvider());
+    when(helper.getAuthority()).thenReturn("api.google.com");
+    doAnswer((inv) -> {
+      xdsDepManager.requestReresolution();
+      return null;
+    }).when(helper).refreshNameResolution();
+    loadBalancer = new CdsLoadBalancer2(helper, lbRegistry);
+
+    originalIsEnabledXdsHttpConnect = XdsClusterResource.isEnabledXdsHttpConnect;
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    XdsClusterResource.isEnabledXdsHttpConnect = originalIsEnabledXdsHttpConnect;
+    loadBalancer.shutdown();
+    if (xdsDepManager != null) {
+      xdsDepManager.shutdown();
+    }
+    assertThat(xdsClient.getSubscribedResourcesMetadataSnapshot().get()).isEmpty();
+    xdsClient.shutdown();
+    assertThat(childBalancers).isEmpty();
+    assertThat(resolvers).isEmpty();
+    assertThat(fakeClock.getPendingTasks()).isEmpty();
+  }
+
+  @Test
+  public void edsClustersWithRingHashEndpointLbPolicy() throws Exception {
+    boolean originalVal = LoadStatsManager2.isEnabledOrcaLrsPropagation;
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = true;
+    List<String> metricSpecs = Arrays.asList("cpu_utilization");
+    BackendMetricPropagation backendMetricPropagation =
+        BackendMetricPropagation.fromMetricSpecs(metricSpecs);
+    Cluster cluster = EDS_CLUSTER.toBuilder()
+        .setLbPolicy(Cluster.LbPolicy.RING_HASH)
+        .setRingHashLbConfig(Cluster.RingHashLbConfig.newBuilder()
+            .setMinimumRingSize(UInt64Value.of(10))
+            .setMaximumRingSize(UInt64Value.of(100))
+            .build())
+        .addAllLrsReportEndpointMetrics(metricSpecs)
+        .build();
+    ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()
+        .setClusterName(EDS_SERVICE_NAME)
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(10))
+          .setLocality(LOCALITY1)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.1", 8080))
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.2", 8080)))
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(50))
+          .setLocality(LOCALITY2)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.1.1", 8080)
+            .setLoadBalancingWeight(UInt32Value.of(60))))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        CLUSTER, cluster));
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, clusterLoadAssignment));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertThat(childBalancer.addresses).hasSize(3);
+    EquivalentAddressGroup addr1 = childBalancer.addresses.get(0);
+    EquivalentAddressGroup addr2 = childBalancer.addresses.get(1);
+    EquivalentAddressGroup addr3 = childBalancer.addresses.get(2);
+    // Endpoints in LOCALITY1 have no endpoint-level weight specified, so all endpoints within
+    // LOCALITY1 are equally weighted.
+    assertThat(addr1.getAddresses())
+        .isEqualTo(Arrays.asList(newInetSocketAddress("127.0.0.1", 8080)));
+    assertThat(addr1.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_SERVER_WEIGHT))
+        .isEqualTo(10);
+    assertThat(addr2.getAddresses())
+        .isEqualTo(Arrays.asList(newInetSocketAddress("127.0.0.2", 8080)));
+    assertThat(addr2.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_SERVER_WEIGHT))
+        .isEqualTo(10);
+    assertThat(addr3.getAddresses())
+        .isEqualTo(Arrays.asList(newInetSocketAddress("127.0.1.1", 8080)));
+    assertThat(addr3.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_SERVER_WEIGHT))
+        .isEqualTo(50 * 60);
+    assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);
+    PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;
+    assertThat(priorityLbConfig.priorities).containsExactly(CLUSTER + "[child1]");
+    PriorityChildConfig priorityChildConfig =
+        Iterables.getOnlyElement(priorityLbConfig.childConfigs.values());
+    assertThat(priorityChildConfig.ignoreReresolution).isTrue();
+    assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(priorityChildConfig.childConfig)
+          .getPolicyName())
+        .isEqualTo(CLUSTER_IMPL_POLICY_NAME);
+    ClusterImplConfig clusterImplConfig = (ClusterImplConfig)
+        GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig.childConfig);
+    assertClusterImplConfig(clusterImplConfig, CLUSTER, EDS_SERVICE_NAME, null, null,
+        null, Collections.emptyList(), "ring_hash_experimental");
+    assertThat(clusterImplConfig.backendMetricPropagation).isEqualTo(backendMetricPropagation);
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = originalVal;
+    RingHashConfig ringHashConfig = (RingHashConfig)
+        GracefulSwitchLoadBalancerAccessor.getChildConfig(clusterImplConfig.childConfig);
+    assertThat(ringHashConfig.minRingSize).isEqualTo(10L);
+    assertThat(ringHashConfig.maxRingSize).isEqualTo(100L);
+  }
+
+  @Test
+  public void edsClustersWithLeastRequestEndpointLbPolicy() {
+    Cluster cluster = EDS_CLUSTER.toBuilder()
+        .setLbPolicy(Cluster.LbPolicy.LEAST_REQUEST)
+        .build();
+    // Simple case with one priority and one locality
+    ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()
+        .setClusterName(EDS_SERVICE_NAME)
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(100))
+          .setLocality(LOCALITY1)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.1", 8080)))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        CLUSTER, cluster));
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, clusterLoadAssignment));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertThat(childBalancer.addresses).hasSize(1);
+    EquivalentAddressGroup addr = childBalancer.addresses.get(0);
+    assertThat(addr.getAddresses())
+        .isEqualTo(Arrays.asList(newInetSocketAddress("127.0.0.1", 8080)));
+    assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);
+    PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;
+    assertThat(priorityLbConfig.priorities).containsExactly(CLUSTER + "[child1]");
+    PriorityChildConfig priorityChildConfig =
+        Iterables.getOnlyElement(priorityLbConfig.childConfigs.values());
+    assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(priorityChildConfig.childConfig)
+        .getPolicyName())
+        .isEqualTo(CLUSTER_IMPL_POLICY_NAME);
+    ClusterImplConfig clusterImplConfig = (ClusterImplConfig)
+        GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig.childConfig);
+    assertClusterImplConfig(clusterImplConfig, CLUSTER, EDS_SERVICE_NAME, null, null,
+        null, Collections.emptyList(), WRR_LOCALITY_POLICY_NAME);
+    WrrLocalityConfig wrrLocalityConfig = (WrrLocalityConfig)
+        GracefulSwitchLoadBalancerAccessor.getChildConfig(clusterImplConfig.childConfig);
+    LoadBalancerProvider childProvider =
+        GracefulSwitchLoadBalancerAccessor.getChildProvider(wrrLocalityConfig.childConfig);
+    assertThat(childProvider.getPolicyName()).isEqualTo("least_request_experimental");
+
+    assertThat(
+        childBalancer.addresses.get(0).getAttributes()
+            .get(io.grpc.xds.XdsAttributes.ATTR_LOCALITY_WEIGHT)).isEqualTo(100);
+  }
+
+  @Test
+  public void edsClustersEndpointHostname_addedToAddressAttribute() {
+    // Simple case with one priority and one locality
+    ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()
+        .setClusterName(EDS_SERVICE_NAME)
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(100))
+          .setLocality(LOCALITY1)
+          .addLbEndpoints(LbEndpoint.newBuilder()
+            .setEndpoint(Endpoint.newBuilder()
+              .setHostname("hostname1")
+              .setAddress(newAddress("127.0.0.1", 8000)))))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, clusterLoadAssignment));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+
+    assertThat(
+        childBalancer.addresses.get(0).getAttributes()
+            .get(XdsInternalAttributes.ATTR_ADDRESS_NAME)).isEqualTo("hostname1");
+  }
+
+  @Test
+  public void endpointAddressRewritten_whenProxyMetadataIsInEndpointMetadata() {
+    XdsClusterResource.isEnabledXdsHttpConnect = true;
+    Cluster cluster = EDS_CLUSTER.toBuilder()
+        .setTransportSocket(TransportSocket.newBuilder()
+            .setName(
+                "type.googleapis.com/" + Http11ProxyUpstreamTransport.getDescriptor().getFullName())
+            .setTypedConfig(Any.pack(Http11ProxyUpstreamTransport.getDefaultInstance())))
+        .build();
+    // Proxy address in endpointMetadata, and no proxy in locality metadata
+    ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()
+        .setClusterName(EDS_SERVICE_NAME)
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(100))
+          .setLocality(LOCALITY1)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.1", 8080)
+            .setMetadata(Metadata.newBuilder()
+              .putTypedFilterMetadata(
+                  "envoy.http11_proxy_transport_socket.proxy_address",
+                  Any.pack(newAddress("127.0.0.2", 8081).build()))))
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.3", 8082)))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        CLUSTER, cluster));
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, clusterLoadAssignment));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+
+    // Get the rewritten address
+    java.net.SocketAddress rewrittenAddress =
+        childBalancer.addresses.get(0).getAddresses().get(0);
+    assertThat(rewrittenAddress).isInstanceOf(HttpConnectProxiedSocketAddress.class);
+    HttpConnectProxiedSocketAddress proxiedSocket =
+        (HttpConnectProxiedSocketAddress) rewrittenAddress;
+
+    // Assert that the target address is the original address
+    assertThat(proxiedSocket.getTargetAddress()).isEqualTo(newInetSocketAddress("127.0.0.1", 8080));
+
+    // Assert that the proxy address is correctly set
+    assertThat(proxiedSocket.getProxyAddress()).isEqualTo(newInetSocketAddress("127.0.0.2", 8081));
+
+    // Check the non-rewritten address
+    java.net.SocketAddress normalAddress = childBalancer.addresses.get(1).getAddresses().get(0);
+    assertThat(normalAddress).isEqualTo(newInetSocketAddress("127.0.0.3", 8082));
+  }
+
+  @Test
+  public void endpointAddressRewritten_whenProxyMetadataIsInLocalityMetadata() {
+    XdsClusterResource.isEnabledXdsHttpConnect = true;
+    Cluster cluster = EDS_CLUSTER.toBuilder()
+        .setTransportSocket(TransportSocket.newBuilder()
+            .setName(
+                "type.googleapis.com/" + Http11ProxyUpstreamTransport.getDescriptor().getFullName())
+            .setTypedConfig(Any.pack(Http11ProxyUpstreamTransport.getDefaultInstance())))
+        .build();
+    // No proxy address in endpointMetadata, and proxy in locality metadata
+    ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()
+        .setClusterName(EDS_SERVICE_NAME)
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(100))
+          .setLocality(LOCALITY1)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.1", 8080))
+          .setMetadata(Metadata.newBuilder()
+            .putTypedFilterMetadata(
+                "envoy.http11_proxy_transport_socket.proxy_address",
+                Any.pack(newAddress("127.0.0.2", 8081).build()))))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        CLUSTER, cluster));
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, clusterLoadAssignment));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+
+    // Get the rewritten address
+    java.net.SocketAddress rewrittenAddress = childBalancer.addresses.get(0).getAddresses().get(0);
+
+    // Assert that the address was rewritten
+    assertThat(rewrittenAddress).isInstanceOf(HttpConnectProxiedSocketAddress.class);
+    HttpConnectProxiedSocketAddress proxiedSocket =
+        (HttpConnectProxiedSocketAddress) rewrittenAddress;
+
+    // Assert that the target address is the original address
+    assertThat(proxiedSocket.getTargetAddress()).isEqualTo(newInetSocketAddress("127.0.0.1", 8080));
+
+    // Assert that the proxy address is correctly set from locality metadata
+    assertThat(proxiedSocket.getProxyAddress()).isEqualTo(newInetSocketAddress("127.0.0.2", 8081));
+  }
+
+  @Test
+  public void onlyEdsClusters_receivedEndpoints() {
+    // Has two localities with different priorities
+    ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()
+        .setClusterName(EDS_SERVICE_NAME)
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(70))
+          .setPriority(0)
+          .setLocality(LOCALITY1)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.1", 8080))
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.2", 8080)))
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(30))
+          .setPriority(1)
+          .setLocality(LOCALITY2)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.3", 8080)))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, clusterLoadAssignment));
+    startXdsDepManager();
+
+    String priority1 = CLUSTER + "[child1]";
+    String priority2 = CLUSTER + "[child2]";
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);
+    PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;
+    assertThat(priorityLbConfig.priorities)
+        .containsExactly(priority1, priority2).inOrder();
+
+    PriorityChildConfig priorityChildConfig1 = priorityLbConfig.childConfigs.get(priority1);
+    assertThat(priorityChildConfig1.ignoreReresolution).isTrue();
+    assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(priorityChildConfig1.childConfig)
+        .getPolicyName())
+        .isEqualTo(CLUSTER_IMPL_POLICY_NAME);
+    ClusterImplConfig clusterImplConfig1 = (ClusterImplConfig)
+        GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig1.childConfig);
+    assertClusterImplConfig(clusterImplConfig1, CLUSTER, EDS_SERVICE_NAME, null, null,
+        null, Collections.emptyList(), WRR_LOCALITY_POLICY_NAME);
+    WrrLocalityConfig wrrLocalityConfig1 = (WrrLocalityConfig)
+        GracefulSwitchLoadBalancerAccessor.getChildConfig(clusterImplConfig1.childConfig);
+    LoadBalancerProvider childProvider1 =
+        GracefulSwitchLoadBalancerAccessor.getChildProvider(wrrLocalityConfig1.childConfig);
+    assertThat(childProvider1.getPolicyName()).isEqualTo("round_robin");
+
+    PriorityChildConfig priorityChildConfig2 = priorityLbConfig.childConfigs.get(priority2);
+    assertThat(priorityChildConfig2.ignoreReresolution).isTrue();
+    assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(priorityChildConfig2.childConfig)
+        .getPolicyName())
+        .isEqualTo(CLUSTER_IMPL_POLICY_NAME);
+    ClusterImplConfig clusterImplConfig2 = (ClusterImplConfig)
+        GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig2.childConfig);
+    assertClusterImplConfig(clusterImplConfig2, CLUSTER, EDS_SERVICE_NAME, null, null,
+        null, Collections.emptyList(), WRR_LOCALITY_POLICY_NAME);
+    WrrLocalityConfig wrrLocalityConfig2 = (WrrLocalityConfig)
+        GracefulSwitchLoadBalancerAccessor.getChildConfig(clusterImplConfig1.childConfig);
+    LoadBalancerProvider childProvider2 =
+        GracefulSwitchLoadBalancerAccessor.getChildProvider(wrrLocalityConfig2.childConfig);
+    assertThat(childProvider2.getPolicyName()).isEqualTo("round_robin");
+
+    WrrLocalityConfig wrrLocalityConfig3 = (WrrLocalityConfig)
+        GracefulSwitchLoadBalancerAccessor.getChildConfig(clusterImplConfig1.childConfig);
+    LoadBalancerProvider childProvider3 =
+        GracefulSwitchLoadBalancerAccessor.getChildProvider(wrrLocalityConfig3.childConfig);
+    assertThat(childProvider3.getPolicyName()).isEqualTo("round_robin");
+
+    io.grpc.xds.client.Locality locality1 = io.grpc.xds.client.Locality.create(
+        LOCALITY1.getRegion(), LOCALITY1.getZone(), LOCALITY1.getSubZone());
+    io.grpc.xds.client.Locality locality2 = io.grpc.xds.client.Locality.create(
+        LOCALITY2.getRegion(), LOCALITY2.getZone(), LOCALITY2.getSubZone());
+    for (EquivalentAddressGroup eag : childBalancer.addresses) {
+      io.grpc.xds.client.Locality locality =
+          eag.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_LOCALITY);
+      if (locality.equals(locality1)) {
+        assertThat(eag.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_LOCALITY_WEIGHT))
+            .isEqualTo(70);
+      } else if (locality.equals(locality2)) {
+        assertThat(eag.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_LOCALITY_WEIGHT))
+            .isEqualTo(30);
+      } else {
+        throw new AssertionError("Unexpected locality region: " + locality.region());
+      }
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  private void verifyEdsPriorityNames(List<String> want, List<LocalityLbEndpoints>... updates) {
+    Iterator<ClusterLoadAssignment> edsUpdates = Arrays.asList(updates).stream()
+        .map(update -> ClusterLoadAssignment.newBuilder()
+            .setClusterName(EDS_SERVICE_NAME)
+            .addAllEndpoints(update)
+            .build())
+        .iterator();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, edsUpdates.next()));
+    startXdsDepManager();
+
+    while (edsUpdates.hasNext()) {
+      controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+          EDS_SERVICE_NAME, edsUpdates.next()));
+    }
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);
+    PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;
+    assertThat(priorityLbConfig.priorities).isEqualTo(want);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void edsUpdatePriorityName_twoPriorities() {
+    verifyEdsPriorityNames(Arrays.asList(CLUSTER + "[child1]", CLUSTER + "[child2]"),
+        Arrays.asList(createEndpoints(LOCALITY1, 0), createEndpoints(LOCALITY2, 1)));
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void edsUpdatePriorityName_addOnePriority() {
+    verifyEdsPriorityNames(Arrays.asList(CLUSTER + "[child2]"),
+        Arrays.asList(createEndpoints(LOCALITY1, 0)),
+        Arrays.asList(createEndpoints(LOCALITY2, 0)));
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void edsUpdatePriorityName_swapTwoPriorities() {
+    verifyEdsPriorityNames(Arrays.asList(CLUSTER + "[child2]", CLUSTER + "[child1]",
+            CLUSTER + "[child3]"),
+        Arrays.asList(
+            createEndpoints(LOCALITY1, 0),
+            createEndpoints(LOCALITY2, 1),
+            createEndpoints(LOCALITY3, 2)),
+        Arrays.asList(
+            createEndpoints(LOCALITY1, 1),
+            createEndpoints(LOCALITY2, 0),
+            createEndpoints(LOCALITY3, 2)));
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void edsUpdatePriorityName_mergeTwoPriorities() {
+    verifyEdsPriorityNames(Arrays.asList(CLUSTER + "[child3]", CLUSTER + "[child1]"),
+        Arrays.asList(
+            createEndpoints(LOCALITY1, 0),
+            createEndpoints(LOCALITY3, 2),
+            createEndpoints(LOCALITY2, 1)),
+        Arrays.asList(
+            createEndpoints(LOCALITY1, 1),
+            createEndpoints(LOCALITY3, 0),
+            createEndpoints(LOCALITY2, 0)));
+  }
+
+  private LocalityLbEndpoints createEndpoints(Locality locality, int priority) {
+    return LocalityLbEndpoints.newBuilder()
+        .setLoadBalancingWeight(UInt32Value.of(70))
+        .setLocality(locality)
+        .setPriority(priority)
+        .addLbEndpoints(newSocketLbEndpoint("127.0." + priority + ".1", 8080))
+        .build();
+  }
+
+  @Test
+  public void onlyEdsClusters_resourceNeverExist_returnErrorPicker() {
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of());
+    startXdsDepManager();
+
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    String expectedDescription = "Error retrieving CDS resource " + CLUSTER + ": NOT_FOUND. "
+        + "Details: Timed out waiting for resource " + CLUSTER + " from xDS server nodeID: node-id";
+    Status expectedError = Status.UNAVAILABLE.withDescription(expectedDescription);
+    assertPicker(pickerCaptor.getValue(), expectedError, null);
+  }
+
+  @Test
+  public void cdsMissing_handledDirectly() {
+    ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()
+        .setClusterName(EDS_SERVICE_NAME)
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(100))
+          .setLocality(LOCALITY1)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.1", 8000)))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of());
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, clusterLoadAssignment));
+
+    startXdsDepManager();
+    assertThat(childBalancers).hasSize(0);  // no child LB policy created
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    String expectedDescription = "Error retrieving CDS resource " + CLUSTER + ": NOT_FOUND. "
+        + "Details: Timed out waiting for resource " + CLUSTER + " from xDS server nodeID: node-id";
+    Status expectedError = Status.UNAVAILABLE.withDescription(expectedDescription);
+    assertPicker(pickerCaptor.getValue(), expectedError, null);
+    assertPicker(pickerCaptor.getValue(), expectedError, null);
+  }
+
+  @Test
+  public void cdsRevoked_handledDirectly() {
+    ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()
+        .setClusterName(EDS_SERVICE_NAME)
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(100))
+          .setLocality(LOCALITY1)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.1", 8000)))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, clusterLoadAssignment));
+
+    startXdsDepManager();
+    assertThat(childBalancers).hasSize(1);  // child LB policy created
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertThat(((PriorityLbConfig) childBalancer.config).priorities).hasSize(1);
+    assertThat(childBalancer.addresses).hasSize(1);
+    assertAddressesEqual(
+        Arrays.asList(newInetSocketAddressEag("127.0.0.1", 8000)),
+        childBalancer.addresses);
+
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of());
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    String expectedDescription = "Error retrieving CDS resource " + CLUSTER + ": NOT_FOUND. "
+        + "Details: Resource " + CLUSTER + " does not exist nodeID: node-id";
+    Status expectedError = Status.UNAVAILABLE.withDescription(expectedDescription);
+    assertPicker(pickerCaptor.getValue(), expectedError, null);
+    assertThat(childBalancer.shutdown).isTrue();
+  }
+
+  @Test
+  public void edsMissing_failsRpcs() {
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of());
+
+    startXdsDepManager();
+    assertThat(childBalancers).hasSize(0);  // Graceful switch handles it, so no child policies yet
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    String expectedDescription = "Error retrieving EDS resource " + EDS_SERVICE_NAME
+        + ": NOT_FOUND. Details: Timed out waiting for resource " + EDS_SERVICE_NAME
+        + " from xDS server nodeID: node-id";
+    Status expectedError = Status.UNAVAILABLE.withDescription(expectedDescription);
+    assertPicker(pickerCaptor.getValue(), expectedError, null);
+  }
+
+  @Test
+  public void logicalDnsLookupFailed_failsRpcs() {
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        CLUSTER, LOGICAL_DNS_CLUSTER));
+    startXdsDepManager(new CdsConfig(CLUSTER), /* forwardTime= */ false);
+    FakeNameResolver resolver = assertResolverCreated("/" + DNS_HOST_NAME + ":9000");
+    assertThat(childBalancers).isEmpty();
+    Status status = Status.UNAVAILABLE.withDescription("OH NO! Who would have guessed?");
+    resolver.deliverError(status);
+
+    assertThat(childBalancers).hasSize(0);  // Graceful switch handles it, so no child policies yet
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    assertPicker(pickerCaptor.getValue(), status, null);
+  }
+
+  @Test
+  public void handleEdsResource_ignoreUnhealthyEndpoints() {
+    ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()
+        .setClusterName(EDS_SERVICE_NAME)
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(100))
+          .setLocality(LOCALITY1)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.1", 8000)
+            .setHealthStatus(HealthStatus.UNHEALTHY))
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.2", 8000)))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, clusterLoadAssignment));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertAddressesEqual(
+        Arrays.asList(new EquivalentAddressGroup(newInetSocketAddress("127.0.0.2", 8000))),
+        childBalancer.addresses);
+  }
+
+  @Test
+  public void handleEdsResource_ignoreLocalitiesWithNoHealthyEndpoints() {
+    ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()
+        .setClusterName(EDS_SERVICE_NAME)
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(100))
+          .setLocality(LOCALITY1)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.1", 8000)
+            .setHealthStatus(HealthStatus.UNHEALTHY)))
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(100))
+          .setLocality(LOCALITY2)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.2", 8000)))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, clusterLoadAssignment));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    io.grpc.xds.client.Locality locality2 = io.grpc.xds.client.Locality.create(
+        LOCALITY2.getRegion(), LOCALITY2.getZone(), LOCALITY2.getSubZone());
+    for (EquivalentAddressGroup eag : childBalancer.addresses) {
+      assertThat(eag.getAttributes().get(io.grpc.xds.XdsAttributes.ATTR_LOCALITY))
+          .isEqualTo(locality2);
+    }
+  }
+
+  @Test
+  public void handleEdsResource_ignorePrioritiesWithNoHealthyEndpoints() {
+    ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()
+        .setClusterName(EDS_SERVICE_NAME)
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(100))
+          .setLocality(LOCALITY1)
+          .setPriority(0)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.1", 8000)
+            .setHealthStatus(HealthStatus.UNHEALTHY)))
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(100))
+          .setLocality(LOCALITY2)
+          .setPriority(1)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.2", 8000)))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, clusterLoadAssignment));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    String priority2 = CLUSTER + "[child2]";
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertThat(((PriorityLbConfig) childBalancer.config).priorities).containsExactly(priority2);
+  }
+
+  @Test
+  public void handleEdsResource_noHealthyEndpoint() {
+    ClusterLoadAssignment clusterLoadAssignment = ClusterLoadAssignment.newBuilder()
+        .setClusterName(EDS_SERVICE_NAME)
+        .addEndpoints(LocalityLbEndpoints.newBuilder()
+          .setLoadBalancingWeight(UInt32Value.of(100))
+          .setLocality(LOCALITY1)
+          .addLbEndpoints(newSocketLbEndpoint("127.0.0.1", 8000)
+            .setHealthStatus(HealthStatus.UNHEALTHY)))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, ImmutableMap.of(
+        EDS_SERVICE_NAME, clusterLoadAssignment));
+    startXdsDepManager();
+
+    assertThat(childBalancers).hasSize(0);  // Graceful switch handles it, so no child policies yet
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    Status expectedStatus = Status.UNAVAILABLE
+        .withDescription("No usable endpoint from cluster: " + CLUSTER);
+    assertPicker(pickerCaptor.getValue(), expectedStatus, null);
+  }
+
+  @Test
+  public void onlyLogicalDnsCluster_endpointsResolved() {
+    boolean originalVal = LoadStatsManager2.isEnabledOrcaLrsPropagation;
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = true;
+    List<String> metricSpecs = Arrays.asList("cpu_utilization");
+    BackendMetricPropagation backendMetricPropagation =
+        BackendMetricPropagation.fromMetricSpecs(metricSpecs);
+    Cluster logicalDnsClusterWithMetrics = LOGICAL_DNS_CLUSTER.toBuilder()
+        .addAllLrsReportEndpointMetrics(metricSpecs)
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        CLUSTER, logicalDnsClusterWithMetrics));
+    startXdsDepManager(new CdsConfig(CLUSTER), /* forwardTime= */ false);
+    FakeNameResolver resolver = assertResolverCreated("/" + DNS_HOST_NAME + ":9000");
+    assertThat(childBalancers).isEmpty();
+    resolver.deliverEndpointAddresses(Arrays.asList(
+        newInetSocketAddressEag("127.0.2.1", 9000), newInetSocketAddressEag("127.0.2.2", 9000)));
+    fakeClock.forwardTime(10, TimeUnit.MINUTES);
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);
+    PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;
+    String priority = Iterables.getOnlyElement(priorityLbConfig.priorities);
+    PriorityChildConfig priorityChildConfig = priorityLbConfig.childConfigs.get(priority);
+    assertThat(priorityChildConfig.ignoreReresolution).isFalse();
+    assertThat(GracefulSwitchLoadBalancerAccessor.getChildProvider(priorityChildConfig.childConfig)
+        .getPolicyName())
+        .isEqualTo(CLUSTER_IMPL_POLICY_NAME);
+    ClusterImplConfig clusterImplConfig = (ClusterImplConfig)
+        GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig.childConfig);
+    assertClusterImplConfig(clusterImplConfig, CLUSTER, null, null, null, null,
+        Collections.<DropOverload>emptyList(), "wrr_locality_experimental");
+    assertThat(clusterImplConfig.backendMetricPropagation).isEqualTo(backendMetricPropagation);
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = originalVal;
+    assertAddressesEqual(
+        Arrays.asList(new EquivalentAddressGroup(Arrays.asList(
+            newInetSocketAddress("127.0.2.1", 9000), newInetSocketAddress("127.0.2.2", 9000)))),
+        childBalancer.addresses);
+    assertThat(childBalancer.addresses.get(0).getAttributes()
+        .get(XdsInternalAttributes.ATTR_ADDRESS_NAME)).isEqualTo(DNS_HOST_NAME + ":9000");
+  }
+
+  @Test
+  public void onlyLogicalDnsCluster_handleRefreshNameResolution() {
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        CLUSTER, LOGICAL_DNS_CLUSTER));
+    startXdsDepManager(new CdsConfig(CLUSTER), /* forwardTime= */ false);
+    FakeNameResolver resolver = assertResolverCreated("/" + DNS_HOST_NAME + ":9000");
+    assertThat(childBalancers).isEmpty();
+    resolver.deliverEndpointAddresses(Arrays.asList(newInetSocketAddressEag("127.0.2.1", 9000)));
+    fakeClock.forwardTime(10, TimeUnit.MINUTES);
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(resolver.refreshCount).isEqualTo(0);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    childBalancer.helper.refreshNameResolution();
+    assertThat(resolver.refreshCount).isEqualTo(1);
+  }
+
+  @Test
+  public void outlierDetection_disabledConfig() {
+    Cluster cluster = EDS_CLUSTER.toBuilder()
+        .setOutlierDetection(OutlierDetection.newBuilder()
+            .setEnforcingSuccessRate(UInt32Value.of(0))
+            .setEnforcingFailurePercentage(UInt32Value.of(0)))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        CLUSTER, cluster));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);
+    PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;
+    PriorityChildConfig priorityChildConfig =
+        Iterables.getOnlyElement(priorityLbConfig.childConfigs.values());
+    OutlierDetectionLoadBalancerConfig outlier = (OutlierDetectionLoadBalancerConfig)
+        GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig.childConfig);
+    assertThat(outlier.successRateEjection).isNull();
+    assertThat(outlier.failurePercentageEjection).isNull();
+  }
+
+  @Test
+  public void outlierDetection_fullConfig() {
+    Cluster cluster = EDS_CLUSTER.toBuilder()
+        .setLbPolicy(Cluster.LbPolicy.ROUND_ROBIN)
+        .setOutlierDetection(OutlierDetection.newBuilder()
+            .setInterval(Duration.newBuilder().setNanos(101))
+            .setBaseEjectionTime(Duration.newBuilder().setNanos(102))
+            .setMaxEjectionTime(Duration.newBuilder().setNanos(103))
+            .setMaxEjectionPercent(UInt32Value.of(80))
+            .setSuccessRateStdevFactor(UInt32Value.of(105))
+            .setEnforcingSuccessRate(UInt32Value.of(81))
+            .setSuccessRateMinimumHosts(UInt32Value.of(107))
+            .setSuccessRateRequestVolume(UInt32Value.of(108))
+            .setFailurePercentageThreshold(UInt32Value.of(82))
+            .setEnforcingFailurePercentage(UInt32Value.of(83))
+            .setFailurePercentageMinimumHosts(UInt32Value.of(111))
+            .setFailurePercentageRequestVolume(UInt32Value.of(112)))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of(
+        CLUSTER, cluster));
+    startXdsDepManager();
+
+    verify(helper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(childBalancers).hasSize(1);
+    FakeLoadBalancer childBalancer = Iterables.getOnlyElement(childBalancers);
+    assertThat(childBalancer.name).isEqualTo(PRIORITY_POLICY_NAME);
+    PriorityLbConfig priorityLbConfig = (PriorityLbConfig) childBalancer.config;
+    PriorityChildConfig priorityChildConfig =
+        Iterables.getOnlyElement(priorityLbConfig.childConfigs.values());
+    OutlierDetectionLoadBalancerConfig outlier = (OutlierDetectionLoadBalancerConfig)
+        GracefulSwitchLoadBalancerAccessor.getChildConfig(priorityChildConfig.childConfig);
+    assertThat(outlier.intervalNanos).isEqualTo(101);
+    assertThat(outlier.baseEjectionTimeNanos).isEqualTo(102);
+    assertThat(outlier.maxEjectionTimeNanos).isEqualTo(103);
+    assertThat(outlier.maxEjectionPercent).isEqualTo(80);
+    assertThat(outlier.successRateEjection.stdevFactor).isEqualTo(105);
+    assertThat(outlier.successRateEjection.enforcementPercentage).isEqualTo(81);
+    assertThat(outlier.successRateEjection.minimumHosts).isEqualTo(107);
+    assertThat(outlier.successRateEjection.requestVolume).isEqualTo(108);
+    assertThat(outlier.failurePercentageEjection.threshold).isEqualTo(82);
+    assertThat(outlier.failurePercentageEjection.enforcementPercentage).isEqualTo(83);
+    assertThat(outlier.failurePercentageEjection.minimumHosts).isEqualTo(111);
+    assertThat(outlier.failurePercentageEjection.requestVolume).isEqualTo(112);
+    assertClusterImplConfig(
+        (ClusterImplConfig) GracefulSwitchLoadBalancerAccessor.getChildConfig(outlier.childConfig),
+        CLUSTER, EDS_SERVICE_NAME, null, null, null, Collections.emptyList(),
+        "wrr_locality_experimental");
+  }
+
+  private void startXdsDepManager() {
+    startXdsDepManager(new CdsConfig(CLUSTER));
+  }
+
+  private void startXdsDepManager(final CdsConfig cdsConfig) {
+    startXdsDepManager(cdsConfig, true);
+  }
+
+  private void startXdsDepManager(final CdsConfig cdsConfig, boolean forwardTime) {
+    xdsDepManager.start(
+        xdsConfig -> {
+          if (!xdsConfig.hasValue()) {
+            throw new AssertionError("" + xdsConfig.getStatus());
+          }
+          if (loadBalancer == null) {
+            return;
+          }
+          loadBalancer.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+              .setAddresses(Collections.emptyList())
+              .setAttributes(Attributes.newBuilder()
+                .set(io.grpc.xds.XdsAttributes.XDS_CONFIG, xdsConfig.getValue())
+                .set(io.grpc.xds.XdsAttributes.XDS_CLUSTER_SUBSCRIPT_REGISTRY, xdsDepManager)
+                .build())
+              .setLoadBalancingPolicyConfig(cdsConfig)
+              .build());
+        });
+    if (forwardTime) {
+      // trigger does not exist timer, so broken config is more obvious
+      fakeClock.forwardTime(10, TimeUnit.MINUTES);
+    }
+  }
+
+  private FakeNameResolver assertResolverCreated(String uriPath) {
+    assertThat(resolvers).hasSize(1);
+    FakeNameResolver resolver = Iterables.getOnlyElement(resolvers);
+    assertThat(resolver.targetUri.getPath()).isEqualTo(uriPath);
+    return resolver;
+  }
+
+  private static void assertPicker(SubchannelPicker picker, Status expectedStatus,
+      @Nullable Subchannel expectedSubchannel)  {
+    PickResult result = picker.pickSubchannel(mock(PickSubchannelArgs.class));
+    Status actualStatus = result.getStatus();
+    assertThat(actualStatus.getCode()).isEqualTo(expectedStatus.getCode());
+    assertThat(actualStatus.getDescription()).isEqualTo(expectedStatus.getDescription());
+    if (actualStatus.isOk()) {
+      assertThat(result.getSubchannel()).isSameInstanceAs(expectedSubchannel);
+    }
+  }
+
+  private static void assertClusterImplConfig(ClusterImplConfig config, String cluster,
+      @Nullable String edsServiceName, ServerInfo lrsServerInfo, Long maxConcurrentRequests,
+      @Nullable UpstreamTlsContext tlsContext, List<DropOverload> dropCategories,
+      String childPolicy) {
+    assertThat(config.cluster).isEqualTo(cluster);
+    assertThat(config.edsServiceName).isEqualTo(edsServiceName);
+    assertThat(config.lrsServerInfo).isEqualTo(lrsServerInfo);
+    assertThat(config.maxConcurrentRequests).isEqualTo(maxConcurrentRequests);
+    assertThat(config.tlsContext).isEqualTo(tlsContext);
+    assertThat(config.dropCategories).isEqualTo(dropCategories);
+    assertThat(
+          GracefulSwitchLoadBalancerAccessor.getChildProvider(config.childConfig).getPolicyName())
+        .isEqualTo(childPolicy);
+  }
+
+  /** Asserts two list of EAGs contains same addresses, regardless of attributes. */
+  private static void assertAddressesEqual(
+      List<EquivalentAddressGroup> expected, List<EquivalentAddressGroup> actual) {
+    List<List<java.net.SocketAddress>> expectedAddresses
+        = expected.stream().map(EquivalentAddressGroup::getAddresses).collect(toList());
+    List<List<java.net.SocketAddress>> actualAddresses
+        = actual.stream().map(EquivalentAddressGroup::getAddresses).collect(toList());
+    assertThat(actualAddresses).isEqualTo(expectedAddresses);
+  }
+
+  @SuppressWarnings("AddressSelection")
+  private static InetSocketAddress newInetSocketAddress(String ip, int port) {
+    return new InetSocketAddress(ip, port);
+  }
+
+  private static EquivalentAddressGroup newInetSocketAddressEag(String ip, int port) {
+    return new EquivalentAddressGroup(newInetSocketAddress(ip, port));
+  }
+
+  private static LbEndpoint.Builder newSocketLbEndpoint(String ip, int port) {
+    return LbEndpoint.newBuilder()
+        .setEndpoint(Endpoint.newBuilder()
+          .setAddress(newAddress(ip, port)))
+        .setHealthStatus(HealthStatus.HEALTHY);
+  }
+
+  private static Address.Builder newAddress(String ip, int port) {
+    return Address.newBuilder()
+        .setSocketAddress(SocketAddress.newBuilder()
+            .setAddress(ip)
+            .setPortValue(port));
+  }
+
+  private class FakeNameResolverProvider extends NameResolverProvider {
+    @Override
+    public NameResolver newNameResolver(URI targetUri, NameResolver.Args args) {
+      assertThat(targetUri.getScheme()).isEqualTo("dns");
+      FakeNameResolver resolver = new FakeNameResolver(targetUri);
+      resolvers.add(resolver);
+      return resolver;
+    }
+
+    @Override
+    public String getDefaultScheme() {
+      return "dns";
+    }
+
+    @Override
+    protected boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    protected int priority() {
+      return 0;  // doesn't matter
+    }
+  }
+
+
+  private class FakeNameResolver extends NameResolver {
+    private final URI targetUri;
+    protected Listener2 listener;
+    private int refreshCount;
+
+    private FakeNameResolver(URI targetUri) {
+      this.targetUri = targetUri;
+    }
+
+    @Override
+    public String getServiceAuthority() {
+      throw new UnsupportedOperationException("should not be called");
+    }
+
+    @Override
+    public void start(final Listener2 listener) {
+      this.listener = listener;
+    }
+
+    @Override
+    public void refresh() {
+      refreshCount++;
+    }
+
+    @Override
+    public void shutdown() {
+      resolvers.remove(this);
+    }
+
+    protected void deliverEndpointAddresses(List<EquivalentAddressGroup> addresses) {
+      syncContext.execute(() -> {
+        Status ret = listener.onResult2(ResolutionResult.newBuilder()
+                .setAddressesOrError(StatusOr.fromValue(addresses)).build());
+        assertThat(ret.getCode()).isEqualTo(Status.Code.OK);
+      });
+    }
+
+    protected void deliverError(Status error) {
+      syncContext.execute(() -> listener.onResult2(ResolutionResult.newBuilder()
+                      .setAddressesOrError(StatusOr.fromStatus(error)).build()));
+    }
+  }
+
+  private final class FakeLoadBalancerProvider extends LoadBalancerProvider {
+    private final String policyName;
+
+    FakeLoadBalancerProvider(String policyName) {
+      this.policyName = policyName;
+    }
+
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      FakeLoadBalancer balancer = new FakeLoadBalancer(policyName, helper);
+      childBalancers.add(balancer);
+      return balancer;
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 0;  // doesn't matter
+    }
+
+    @Override
+    public String getPolicyName() {
+      return policyName;
+    }
+  }
+
+  private final class FakeLoadBalancer extends LoadBalancer {
+    private final String name;
+    private final Helper helper;
+    private List<EquivalentAddressGroup> addresses;
+    private Object config;
+    private boolean shutdown;
+
+    FakeLoadBalancer(String name, Helper helper) {
+      this.name = name;
+      this.helper = helper;
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      addresses = resolvedAddresses.getAddresses();
+      config = resolvedAddresses.getLoadBalancingPolicyConfig();
+      return Status.OK;
+    }
+
+    @Override
+    public void handleNameResolutionError(Status error) {
+    }
+
+    @Override
+    public void shutdown() {
+      shutdown = true;
+      childBalancers.remove(this);
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/ClusterSpecifierPluginRegistryTest.java b/xds/src/test/java/io/grpc/xds/ClusterSpecifierPluginRegistryTest.java
new file mode 100644
index 00000000000..27ad72a7683
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/ClusterSpecifierPluginRegistryTest.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link ClusterSpecifierPluginRegistry}. */
+@RunWith(JUnit4.class)
+public class ClusterSpecifierPluginRegistryTest {
+  @Test
+  public void pluginsInGlobaalInstance() {
+    assertThat(ClusterSpecifierPluginRegistry.getDefaultRegistry()
+            .get("type.googleapis.com/grpc.lookup.v1.RouteLookupClusterSpecifier"))
+        .isEqualTo(RouteLookupServiceClusterSpecifierPlugin.INSTANCE);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/ControlPlaneRule.java b/xds/src/test/java/io/grpc/xds/ControlPlaneRule.java
new file mode 100644
index 00000000000..3665e16b6bf
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/ControlPlaneRule.java
@@ -0,0 +1,394 @@
+/*
+ * Copyright 2022 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.xds;
+
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_CDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_EDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_LDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_RDS;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+import com.google.protobuf.Any;
+import com.google.protobuf.BoolValue;
+import com.google.protobuf.Message;
+import com.google.protobuf.UInt32Value;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.core.v3.Address;
+import io.envoyproxy.envoy.config.core.v3.AggregatedConfigSource;
+import io.envoyproxy.envoy.config.core.v3.ConfigSource;
+import io.envoyproxy.envoy.config.core.v3.HealthStatus;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress;
+import io.envoyproxy.envoy.config.core.v3.TrafficDirection;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;
+import io.envoyproxy.envoy.config.endpoint.v3.Endpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints;
+import io.envoyproxy.envoy.config.listener.v3.ApiListener;
+import io.envoyproxy.envoy.config.listener.v3.Filter;
+import io.envoyproxy.envoy.config.listener.v3.FilterChain;
+import io.envoyproxy.envoy.config.listener.v3.FilterChainMatch;
+import io.envoyproxy.envoy.config.listener.v3.Listener;
+import io.envoyproxy.envoy.config.route.v3.NonForwardingAction;
+import io.envoyproxy.envoy.config.route.v3.Route;
+import io.envoyproxy.envoy.config.route.v3.RouteAction;
+import io.envoyproxy.envoy.config.route.v3.RouteConfiguration;
+import io.envoyproxy.envoy.config.route.v3.RouteMatch;
+import io.envoyproxy.envoy.config.route.v3.VirtualHost;
+import io.envoyproxy.envoy.extensions.filters.http.router.v3.Router;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.HttpFilter;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.Rds;
+import io.grpc.Grpc;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.NameResolverRegistry;
+import io.grpc.Server;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.junit.rules.TestWatcher;
+import org.junit.runner.Description;
+
+/**
+ * Starts a control plane server and sets up the test to use it. Initialized with a default
+ * configuration, but also provides methods for updating the configuration.
+ */
+public class ControlPlaneRule extends TestWatcher {
+  private static final Logger logger = Logger.getLogger(ControlPlaneRule.class.getName());
+
+  private static final String SCHEME = "test-xds";
+  private static final String RDS_NAME = "route-config.googleapis.com";
+  private static final String CLUSTER_NAME = "cluster0";
+  private static final String EDS_NAME = "eds-service-0";
+  private static final String SERVER_LISTENER_TEMPLATE_NO_REPLACEMENT =
+      "grpc/server?udpa.resource.listening_address=";
+  private static final String HTTP_CONNECTION_MANAGER_TYPE_URL =
+      "type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3"
+          + ".HttpConnectionManager";
+
+  private String serverHostName;
+  private Server server;
+  private XdsTestControlPlaneService controlPlaneService;
+  private XdsTestLoadReportingService loadReportingService;
+  private XdsNameResolverProvider nameResolverProvider;
+  private int port; // Only change from 0 to actual port used in the server.
+
+  public ControlPlaneRule() {
+    serverHostName = "test-server";
+    this.port = 0;
+  }
+
+  public ControlPlaneRule setServerHostName(String serverHostName) {
+    this.serverHostName = serverHostName;
+    return this;
+  }
+
+  /**
+   * Returns the test control plane service interface.
+   */
+  public XdsTestControlPlaneService getService() {
+    return controlPlaneService;
+  }
+
+  /**
+   * Returns the server instance.
+   */
+  public Server getServer() {
+    return server;
+  }
+
+  @Override protected void starting(Description description) {
+    // Start the control plane server.
+    try {
+      controlPlaneService = new XdsTestControlPlaneService();
+      loadReportingService = new XdsTestLoadReportingService();
+      createAndStartXdsServer();
+    } catch (Exception e) {
+      throw new AssertionError("unable to start the control plane server", e);
+    }
+
+    // Configure and register an xDS name resolver so that gRPC knows how to connect to the server.
+    nameResolverProvider = XdsNameResolverProvider.createForTest(SCHEME,
+        defaultBootstrapOverride());
+    NameResolverRegistry.getDefaultRegistry().register(nameResolverProvider);
+  }
+
+  @Override protected void finished(Description description) {
+    if (server != null) {
+      server.shutdownNow();
+      try {
+        if (!server.awaitTermination(5, TimeUnit.SECONDS)) {
+          logger.log(Level.SEVERE, "Timed out waiting for server shutdown");
+        }
+      } catch (InterruptedException e) {
+        throw new AssertionError("unable to shut down control plane server", e);
+      }
+    }
+    NameResolverRegistry.getDefaultRegistry().deregister(nameResolverProvider);
+  }
+
+  /**
+   * Will shutdown existing server if needed.
+   * Then creates a new server in the same way as {@link #starting(Description)} and starts it.
+   */
+  public void restartXdsServer() {
+
+    if (getServer() != null && !getServer().isTerminated()) {
+      getServer().shutdownNow();
+      try {
+        if (!getServer().awaitTermination(5, TimeUnit.SECONDS)) {
+          logger.log(Level.SEVERE, "Timed out waiting for server shutdown");
+        }
+      } catch (InterruptedException e) {
+        throw new AssertionError("unable to shut down control plane server", e);
+      }
+    }
+
+    try {
+      createAndStartXdsServer();
+    } catch (Exception e) {
+      throw new AssertionError("unable to restart the control plane server", e);
+    }
+  }
+
+  private void createAndStartXdsServer() throws IOException {
+    server = Grpc.newServerBuilderForPort(port, InsecureServerCredentials.create())
+        .addService(controlPlaneService)
+        .addService(loadReportingService)
+        .build()
+        .start();
+
+    if (port == 0) {
+      port = server.getPort();
+    }
+  }
+
+  /**
+   * For test purpose, use boostrapOverride to programmatically provide bootstrap info.
+   */
+  public Map<String, ?> defaultBootstrapOverride() {
+    return ImmutableMap.of(
+        "node", ImmutableMap.of(
+            "id", UUID.randomUUID().toString(),
+            "cluster", "cluster0"),
+        "xds_servers", Collections.singletonList(
+
+            ImmutableMap.of(
+                "server_uri", "localhost:" + server.getPort(),
+                "channel_creds", Collections.singletonList(
+                    ImmutableMap.of("type", "insecure")
+                ),
+                "server_features", Lists.newArrayList("xds_v3", "trusted_xds_server")
+            )
+        ),
+        "server_listener_resource_name_template", SERVER_LISTENER_TEMPLATE_NO_REPLACEMENT
+    );
+  }
+
+  void setLdsConfig(Listener serverListener, Listener clientListener) {
+    getService().setXdsConfig(ADS_TYPE_URL_LDS,
+        ImmutableMap.of(SERVER_LISTENER_TEMPLATE_NO_REPLACEMENT, serverListener,
+                        serverHostName, clientListener));
+  }
+
+  void setRdsConfig(RouteConfiguration routeConfiguration) {
+    setRdsConfig(RDS_NAME, routeConfiguration);
+  }
+
+  public void setRdsConfig(String rdsName, RouteConfiguration routeConfiguration) {
+    getService().setXdsConfig(ADS_TYPE_URL_RDS, ImmutableMap.of(rdsName, routeConfiguration));
+  }
+
+  void setCdsConfig(Cluster cluster) {
+    setCdsConfig(CLUSTER_NAME, cluster);
+  }
+
+  void setCdsConfig(String clusterName, Cluster cluster) {
+    getService().setXdsConfig(ADS_TYPE_URL_CDS,
+        ImmutableMap.<String, Message>of(clusterName, cluster));
+  }
+
+  void setEdsConfig(ClusterLoadAssignment clusterLoadAssignment) {
+    setEdsConfig(EDS_NAME, clusterLoadAssignment);
+  }
+
+  void setEdsConfig(String edsName, ClusterLoadAssignment clusterLoadAssignment) {
+    getService().setXdsConfig(ADS_TYPE_URL_EDS,
+        ImmutableMap.<String, Message>of(edsName, clusterLoadAssignment));
+  }
+
+  /**
+   * Builds a new default RDS configuration.
+   */
+  static RouteConfiguration buildRouteConfiguration(String authority) {
+    return buildRouteConfiguration(authority, RDS_NAME, CLUSTER_NAME);
+  }
+
+  static RouteConfiguration buildRouteConfiguration(String authority, String rdsName,
+                                                    String clusterName) {
+    io.envoyproxy.envoy.config.route.v3.VirtualHost.Builder vhBuilder =
+        io.envoyproxy.envoy.config.route.v3.VirtualHost.newBuilder()
+            .setName(rdsName)
+            .addDomains(authority)
+            .addRoutes(
+                Route.newBuilder()
+                    .setMatch(
+                        RouteMatch.newBuilder().setPrefix("/").build())
+                    .setRoute(
+                        RouteAction.newBuilder().setCluster(clusterName)
+                            .setAutoHostRewrite(BoolValue.newBuilder().setValue(true).build())
+                            .build()));
+    io.envoyproxy.envoy.config.route.v3.VirtualHost virtualHost = vhBuilder.build();
+    return RouteConfiguration.newBuilder().setName(rdsName).addVirtualHosts(virtualHost).build();
+  }
+
+  /**
+   * Builds a new default CDS configuration.
+   */
+  static Cluster buildCluster() {
+    return buildCluster(CLUSTER_NAME, EDS_NAME);
+  }
+
+  static Cluster buildCluster(String clusterName, String edsName) {
+    return Cluster.newBuilder()
+        .setName(clusterName)
+        .setType(Cluster.DiscoveryType.EDS)
+        .setEdsClusterConfig(
+            Cluster.EdsClusterConfig.newBuilder()
+                .setServiceName(edsName)
+                .setEdsConfig(
+                    ConfigSource.newBuilder()
+                        .setAds(AggregatedConfigSource.newBuilder().build())
+                        .build())
+                .build())
+        .setLbPolicy(Cluster.LbPolicy.ROUND_ROBIN)
+        .build();
+  }
+
+  /**
+   * Builds a new default EDS configuration.
+   */
+  static ClusterLoadAssignment buildClusterLoadAssignment(
+          String hostAddress, String endpointHostname, int port) {
+    return buildClusterLoadAssignment(hostAddress, endpointHostname, port, EDS_NAME);
+  }
+
+  static ClusterLoadAssignment buildClusterLoadAssignment(
+          String hostAddress, String endpointHostname, int port, String edsName) {
+
+    Address address = Address.newBuilder()
+        .setSocketAddress(
+            SocketAddress.newBuilder().setAddress(hostAddress).setPortValue(port).build()).build();
+    LocalityLbEndpoints endpoints = LocalityLbEndpoints.newBuilder()
+        .setLoadBalancingWeight(UInt32Value.of(10))
+        .setPriority(0)
+        .addLbEndpoints(
+            LbEndpoint.newBuilder()
+                .setEndpoint(
+                    Endpoint.newBuilder()
+                        .setAddress(address).setHostname(endpointHostname).build())
+                .setHealthStatus(HealthStatus.HEALTHY)
+                .build()).build();
+    return ClusterLoadAssignment.newBuilder()
+        .setClusterName(edsName)
+        .addEndpoints(endpoints)
+        .build();
+  }
+
+  /**
+   * Builds a new client listener.
+   */
+  static Listener buildClientListener(String name) {
+    return buildClientListener(name, RDS_NAME);
+  }
+
+  static Listener buildClientListener(String name, String rdsName) {
+    HttpFilter httpFilter = HttpFilter.newBuilder()
+        .setName("terminal-filter")
+        .setTypedConfig(Any.pack(Router.newBuilder().build()))
+        .setIsOptional(true)
+        .build();
+    ApiListener apiListener = ApiListener.newBuilder().setApiListener(Any.pack(
+        io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3
+            .HttpConnectionManager.newBuilder()
+            .setRds(
+                Rds.newBuilder()
+                    .setRouteConfigName(rdsName)
+                    .setConfigSource(
+                        ConfigSource.newBuilder()
+                            .setAds(AggregatedConfigSource.getDefaultInstance())))
+            .addAllHttpFilters(Collections.singletonList(httpFilter))
+            .build(),
+        HTTP_CONNECTION_MANAGER_TYPE_URL)).build();
+    return Listener.newBuilder()
+        .setName(name)
+        .setApiListener(apiListener).build();
+  }
+
+  /**
+   * Builds a new server listener.
+   */
+  static Listener buildServerListener() {
+    HttpFilter routerFilter = HttpFilter.newBuilder()
+        .setName("terminal-filter")
+        .setTypedConfig(
+            Any.pack(Router.newBuilder().build()))
+        .setIsOptional(true)
+        .build();
+    VirtualHost virtualHost = io.envoyproxy.envoy.config.route.v3.VirtualHost.newBuilder()
+        .setName("virtual-host-0")
+        .addDomains("*")
+        .addRoutes(
+            Route.newBuilder()
+                .setMatch(
+                    RouteMatch.newBuilder().setPrefix("/").build())
+                .setNonForwardingAction(NonForwardingAction.newBuilder().build())
+                .build()).build();
+    RouteConfiguration routeConfig = RouteConfiguration.newBuilder()
+        .addVirtualHosts(virtualHost)
+        .build();
+    io.envoyproxy.envoy.config.listener.v3.Filter filter = Filter.newBuilder()
+        .setName("network-filter-0")
+        .setTypedConfig(
+            Any.pack(
+                HttpConnectionManager.newBuilder()
+                    .setRouteConfig(routeConfig)
+                    .addAllHttpFilters(Collections.singletonList(routerFilter))
+                    .build())).build();
+    FilterChainMatch filterChainMatch = FilterChainMatch.newBuilder()
+        .setSourceType(FilterChainMatch.ConnectionSourceType.ANY)
+        .build();
+    FilterChain filterChain = FilterChain.newBuilder()
+        .setName("filter-chain-0")
+        .setFilterChainMatch(filterChainMatch)
+        .addFilters(filter)
+        .build();
+    Address address = Address.newBuilder()
+        .setSocketAddress(SocketAddress.newBuilder().setAddress("0.0.0.0").setPortValue(0))
+        .build();
+    return Listener.newBuilder()
+        .setName(SERVER_LISTENER_TEMPLATE_NO_REPLACEMENT)
+        .setTrafficDirection(TrafficDirection.INBOUND)
+        .addFilterChains(filterChain)
+        .setAddress(address)
+        .build();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/CsdsServiceTest.java b/xds/src/test/java/io/grpc/xds/CsdsServiceTest.java
new file mode 100644
index 00000000000..e8bd7461736
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/CsdsServiceTest.java
@@ -0,0 +1,521 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.Any;
+import io.envoyproxy.envoy.admin.v3.ClientResourceStatus;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.core.v3.Node;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;
+import io.envoyproxy.envoy.config.listener.v3.Listener;
+import io.envoyproxy.envoy.config.route.v3.RouteConfiguration;
+import io.envoyproxy.envoy.service.status.v3.ClientConfig;
+import io.envoyproxy.envoy.service.status.v3.ClientConfig.GenericXdsConfig;
+import io.envoyproxy.envoy.service.status.v3.ClientStatusDiscoveryServiceGrpc;
+import io.envoyproxy.envoy.service.status.v3.ClientStatusRequest;
+import io.envoyproxy.envoy.service.status.v3.ClientStatusResponse;
+import io.envoyproxy.envoy.type.matcher.v3.NodeMatcher;
+import io.grpc.Deadline;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.MetricRecorder;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.StatusRuntimeException;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.testing.StreamRecorder;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcServerRule;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.EnvoyProtoData;
+import io.grpc.xds.client.EnvoyProtoDataTest;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsClient.ResourceMetadata;
+import io.grpc.xds.client.XdsClient.ResourceMetadata.ResourceMetadataStatus;
+import io.grpc.xds.client.XdsResourceType;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link CsdsService}. */
+@RunWith(Enclosed.class)
+public class CsdsServiceTest {
+  private static final String SERVER_URI = "trafficdirector.googleapis.com";
+  private static final String NODE_ID =
+      "projects/42/networks/default/nodes/5c85b298-6f5b-4722-b74a-f7d1f0ccf5ad";
+  private static final EnvoyProtoData.Node BOOTSTRAP_NODE =
+      EnvoyProtoData.Node.newBuilder().setId(NODE_ID).build();
+  private static final BootstrapInfo BOOTSTRAP_INFO = BootstrapInfo.builder()
+      .servers(ImmutableList.of(
+          ServerInfo.create(SERVER_URI, InsecureChannelCredentials.create())))
+      .node(BOOTSTRAP_NODE)
+      .build();
+  private static final FakeXdsClient XDS_CLIENT_NO_RESOURCES = new FakeXdsClient();
+  private static final XdsResourceType<?> LDS = XdsListenerResource.getInstance();
+  private static final XdsResourceType<?> CDS = XdsClusterResource.getInstance();
+  private static final XdsResourceType<?> RDS = XdsRouteConfigureResource.getInstance();
+  private static final XdsResourceType<?> EDS = XdsEndpointResource.getInstance();
+  public static final String FAKE_CLIENT_SCOPE = "fake";
+
+  @RunWith(JUnit4.class)
+  public static class ServiceTests {
+    private static final CsdsService CSDS_SERVICE_MINIMAL =
+        new CsdsService(new FakeXdsClientPoolFactory(XDS_CLIENT_NO_RESOURCES));
+    private static final ClientStatusRequest REQUEST = ClientStatusRequest.getDefaultInstance();
+    private static final ClientStatusRequest REQUEST_INVALID =
+        ClientStatusRequest.newBuilder().addNodeMatchers(NodeMatcher.getDefaultInstance()).build();
+
+    @Rule public final GrpcServerRule grpcServerRule = new GrpcServerRule().directExecutor();
+
+    private ClientStatusDiscoveryServiceGrpc.ClientStatusDiscoveryServiceBlockingStub csdsStub;
+    private ClientStatusDiscoveryServiceGrpc.ClientStatusDiscoveryServiceStub csdsAsyncStub;
+
+    @Before
+    public void setUp() {
+      // The deadline is needed to prevent CsdsService#handleRequest mutation tests from hanging,
+      // because true->false return mutation prevents fetchClientStatus from completing the request.
+      csdsStub = ClientStatusDiscoveryServiceGrpc
+          .newBlockingStub(grpcServerRule.getChannel())
+          .withDeadline(Deadline.after(30, TimeUnit.SECONDS));
+      csdsAsyncStub = ClientStatusDiscoveryServiceGrpc.newStub(grpcServerRule.getChannel());
+    }
+
+    /** Until XdsClient successfully initialized, expect response to be empty. */
+    @Test
+    public void fetchClientConfig_xdsClientPoolNotInitialized() {
+      grpcServerRule.getServiceRegistry().addService(CsdsService.newInstance());
+      ClientStatusResponse response = csdsStub.fetchClientStatus(REQUEST);
+      assertThat(response).isEqualTo(ClientStatusResponse.getDefaultInstance());
+    }
+
+    /** Status.INVALID_ARGUMENT on unexpected request fields. */
+    @Test
+    public void fetchClientConfig_invalidArgument() {
+      grpcServerRule.getServiceRegistry().addService(CSDS_SERVICE_MINIMAL);
+      try {
+        ClientStatusResponse response = csdsStub.fetchClientStatus(REQUEST_INVALID);
+        fail("Should've failed, got response: " + response);
+      } catch (StatusRuntimeException e) {
+        verifyRequestInvalidResponseStatus(e.getStatus());
+      }
+    }
+
+    /** Unexpected exceptions translated to Status.Code.INTERNAL. */
+    @Test
+    public void fetchClientConfig_unexpectedException() {
+      XdsClient throwingXdsClient = new FakeXdsClient() {
+        @Override
+        public ListenableFuture<Map<XdsResourceType<?>, Map<String, ResourceMetadata>>>
+              getSubscribedResourcesMetadataSnapshot() {
+          return Futures.immediateFailedFuture(
+              new IllegalArgumentException("IllegalArgumentException"));
+        }
+      };
+      grpcServerRule.getServiceRegistry()
+          .addService(new CsdsService(new FakeXdsClientPoolFactory(throwingXdsClient)));
+
+      try {
+        ClientStatusResponse response = csdsStub.fetchClientStatus(REQUEST);
+        fail("Should've failed, got response: " + response);
+      } catch (StatusRuntimeException e) {
+        assertThat(e.getStatus().getCode()).isEqualTo(Code.INTERNAL);
+        assertThat(e.getStatus().getDescription()).isEqualTo("Unexpected internal error");
+        // Cause is not propagated.
+      }
+    }
+
+    /** Interrupted exceptions translated to Status.Code.ABORTED. */
+    @Test
+    public void fetchClientConfig_interruptedException() {
+      XdsClient throwingXdsClient = new FakeXdsClient() {
+        @Override
+        public ListenableFuture<Map<XdsResourceType<?>, Map<String, ResourceMetadata>>>
+            getSubscribedResourcesMetadataSnapshot() {
+          return Futures.submit(() -> {
+            Thread.currentThread().interrupt();
+            return null;
+          }, MoreExecutors.directExecutor());
+        }
+      };
+      grpcServerRule.getServiceRegistry()
+          .addService(new CsdsService(new FakeXdsClientPoolFactory(throwingXdsClient)));
+
+      // Hack to prevent the interrupted exception from propagating through to the client stub.
+      grpcServerRule.getChannel().getState(true);
+
+      try {
+        ClientStatusResponse response = csdsStub.fetchClientStatus(REQUEST);
+        fail("Should've failed, got response: " + response);
+      } catch (StatusRuntimeException e) {
+        assertThat(e.getStatus().getCode()).isEqualTo(Code.ABORTED);
+        assertThat(e.getStatus().getDescription()).isEqualTo("Thread interrupted");
+        // Clean the test thread interrupt.
+        assertThat(Thread.interrupted()).isEqualTo(true);
+      }
+    }
+
+    /** ClientStatusResponse contains valid ClientConfig with the correct shape. */
+    @Test
+    public void fetchClientConfig_happyPath() {
+      grpcServerRule.getServiceRegistry().addService(CSDS_SERVICE_MINIMAL);
+      verifyResponse(csdsStub.fetchClientStatus(REQUEST));
+    }
+
+    @Test
+    public void streamClientStatus_happyPath() {
+      CsdsService csdsService =
+          new CsdsService(new FakeXdsClientPoolFactory(XDS_CLIENT_NO_RESOURCES) {
+            boolean calledOnce;
+
+            @Override
+            @Nullable
+            public ObjectPool<XdsClient> get(String target) {
+              // xDS client not ready on the first call, then becomes ready.
+              if (!calledOnce) {
+                calledOnce = true;
+                return null;
+              } else {
+                return super.get(target);
+              }
+            }
+          });
+
+      grpcServerRule.getServiceRegistry().addService(csdsService);
+
+      StreamRecorder<ClientStatusResponse> responseObserver = StreamRecorder.create();
+      StreamObserver<ClientStatusRequest> requestObserver =
+          csdsAsyncStub.streamClientStatus(responseObserver);
+
+      requestObserver.onNext(REQUEST);
+      requestObserver.onNext(REQUEST);
+      requestObserver.onNext(REQUEST);
+      requestObserver.onCompleted();
+
+      List<ClientStatusResponse> responses = responseObserver.getValues();
+      assertThat(responses).hasSize(3);
+      // Empty response on XdsClient not ready.
+      assertThat(responses.get(0)).isEqualTo(ClientStatusResponse.getDefaultInstance());
+      // The following calls return ClientConfig's successfully.
+      verifyResponse(responses.get(1));
+      verifyResponse(responses.get(2));
+    }
+
+    @Test
+    public void streamClientStatus_requestInvalid() {
+      grpcServerRule.getServiceRegistry().addService(CSDS_SERVICE_MINIMAL);
+
+      StreamRecorder<ClientStatusResponse> responseObserver = StreamRecorder.create();
+      StreamObserver<ClientStatusRequest> requestObserver =
+          csdsAsyncStub.streamClientStatus(responseObserver);
+
+      requestObserver.onNext(REQUEST);
+      requestObserver.onNext(REQUEST_INVALID);
+      requestObserver.onNext(REQUEST);
+      requestObserver.onCompleted();
+
+      List<ClientStatusResponse> responses = responseObserver.getValues();
+      assertThat(responses).hasSize(1);
+      verifyResponse(responses.get(0));
+      assertThat(responseObserver.getError()).isNotNull();
+      verifyRequestInvalidResponseStatus(Status.fromThrowable(responseObserver.getError()));
+    }
+
+    @Test
+    public void streamClientStatus_onClientError() {
+      grpcServerRule.getServiceRegistry().addService(CSDS_SERVICE_MINIMAL);
+
+      StreamRecorder<ClientStatusResponse> responseObserver = StreamRecorder.create();
+      StreamObserver<ClientStatusRequest> requestObserver =
+          csdsAsyncStub.streamClientStatus(responseObserver);
+
+      requestObserver.onNext(REQUEST);
+      requestObserver.onError(new StatusRuntimeException(Status.DATA_LOSS));
+
+      List<ClientStatusResponse> responses = responseObserver.getValues();
+      assertThat(responses).hasSize(1);
+      verifyResponse(responses.get(0));
+      // Server quietly closes its side.
+      assertThat(responseObserver.getError()).isNull();
+    }
+
+    @Test
+    public void multipleXdsClients() {
+      FakeXdsClient xdsClient1 = new FakeXdsClient();
+      FakeXdsClient xdsClient2 = new FakeXdsClient();
+      Map<String, XdsClient> clientMap = new HashMap<>();
+      clientMap.put("target1", xdsClient1);
+      clientMap.put("target2", xdsClient2);
+      FakeXdsClientPoolFactory factory = new FakeXdsClientPoolFactory(clientMap);
+      CsdsService csdsService = new CsdsService(factory);
+      grpcServerRule.getServiceRegistry().addService(csdsService);
+
+      StreamRecorder<ClientStatusResponse> responseObserver = StreamRecorder.create();
+      StreamObserver<ClientStatusRequest> requestObserver =
+          csdsAsyncStub.streamClientStatus(responseObserver);
+
+      requestObserver.onNext(REQUEST);
+      requestObserver.onCompleted();
+
+      List<ClientStatusResponse> responses = responseObserver.getValues();
+      assertThat(responses).hasSize(1);
+      Collection<String> targets = verifyMultiResponse(responses.get(0), 2);
+      assertThat(targets).containsExactly("target1", "target2");
+      responseObserver.onCompleted();
+    }
+
+    private void verifyResponse(ClientStatusResponse response) {
+      assertThat(response.getConfigCount()).isEqualTo(1);
+      ClientConfig clientConfig = response.getConfig(0);
+      verifyClientConfigNode(clientConfig);
+      assertThat(clientConfig.getGenericXdsConfigsList()).isEmpty();
+      assertThat(clientConfig.getClientScope()).isEmpty();
+    }
+
+    private Collection<String> verifyMultiResponse(ClientStatusResponse response, int numExpected) {
+      assertThat(response.getConfigCount()).isEqualTo(numExpected);
+
+      List<String> clientScopes = new ArrayList<>();
+      for (int i = 0; i < numExpected; i++) {
+        ClientConfig clientConfig = response.getConfig(i);
+        verifyClientConfigNode(clientConfig);
+        assertThat(clientConfig.getGenericXdsConfigsList()).isEmpty();
+        clientScopes.add(clientConfig.getClientScope());
+      }
+
+      return clientScopes;
+    }
+
+    private void verifyRequestInvalidResponseStatus(Status status) {
+      assertThat(status.getCode()).isEqualTo(Code.INVALID_ARGUMENT);
+      assertThat(status.getDescription()).isEqualTo("node_matchers not supported");
+    }
+  }
+
+  @RunWith(JUnit4.class)
+  public static class MetadataToProtoTests {
+    private static final String LDS_RESOURCE = "listener.googleapis.com";
+    private static final String RDS_RESOURCE = "route-configuration.googleapis.com";
+    private static final String CDS_RESOURCE = "cluster.googleapis.com";
+    private static final String EDS_RESOURCE = "cluster-load-assignment.googleapis.com";
+    private static final String VERSION_ACK_LDS = "42";
+    private static final String VERSION_ACK_RDS = "38";
+    private static final String VERSION_ACK_CDS = "51";
+    private static final String VERSION_ACK_EDS = "29";
+    private static final long NANOS_LAST_UPDATE = 1577923199_606042047L;
+    // Raw resources.
+    private static final Any RAW_LISTENER =
+        Any.pack(Listener.newBuilder().setName(LDS_RESOURCE).build());
+    private static final Any RAW_ROUTE_CONFIGURATION =
+        Any.pack(RouteConfiguration.newBuilder().setName(RDS_RESOURCE).build());
+    private static final Any RAW_CLUSTER =
+        Any.pack(Cluster.newBuilder().setName(CDS_RESOURCE).build());
+    private static final Any RAW_CLUSTER_LOAD_ASSIGNMENT =
+        Any.pack(ClusterLoadAssignment.newBuilder().setClusterName(EDS_RESOURCE).build());
+
+    // Test metadata: resource acknowledged state, per resource type.
+    private static final ResourceMetadata METADATA_ACKED_LDS = ResourceMetadata
+        .newResourceMetadataAcked(RAW_LISTENER, VERSION_ACK_LDS, NANOS_LAST_UPDATE);
+    private static final ResourceMetadata METADATA_ACKED_RDS = ResourceMetadata
+        .newResourceMetadataAcked(RAW_ROUTE_CONFIGURATION, VERSION_ACK_RDS, NANOS_LAST_UPDATE);
+    private static final ResourceMetadata METADATA_ACKED_CDS = ResourceMetadata
+        .newResourceMetadataAcked(RAW_CLUSTER, VERSION_ACK_CDS, NANOS_LAST_UPDATE);
+    private static final ResourceMetadata METADATA_ACKED_EDS = ResourceMetadata
+        .newResourceMetadataAcked(RAW_CLUSTER_LOAD_ASSIGNMENT, VERSION_ACK_EDS, NANOS_LAST_UPDATE);
+
+    @Test
+    public void metadataStatusToClientStatus() {
+      assertThat(CsdsService.metadataStatusToClientStatus(ResourceMetadataStatus.UNKNOWN))
+          .isEqualTo(ClientResourceStatus.UNKNOWN);
+      assertThat(CsdsService.metadataStatusToClientStatus(ResourceMetadataStatus.DOES_NOT_EXIST))
+          .isEqualTo(ClientResourceStatus.DOES_NOT_EXIST);
+      assertThat(CsdsService.metadataStatusToClientStatus(ResourceMetadataStatus.REQUESTED))
+          .isEqualTo(ClientResourceStatus.REQUESTED);
+      assertThat(CsdsService.metadataStatusToClientStatus(ResourceMetadataStatus.ACKED))
+          .isEqualTo(ClientResourceStatus.ACKED);
+      assertThat(CsdsService.metadataStatusToClientStatus(ResourceMetadataStatus.NACKED))
+          .isEqualTo(ClientResourceStatus.NACKED);
+      assertThat(CsdsService.metadataStatusToClientStatus(ResourceMetadataStatus.TIMEOUT))
+          .isEqualTo(ClientResourceStatus.TIMEOUT);
+    }
+
+    @Test
+    public void getClientConfigForXdsClient_subscribedResourcesToGenericXdsConfig()
+        throws InterruptedException {
+      FakeXdsClient fakeXdsClient = new FakeXdsClient() {
+        @Override
+        protected Map<XdsResourceType<?>, Map<String, ResourceMetadata>>
+            getSubscribedResourcesMetadata() {
+          return new ImmutableMap.Builder<XdsResourceType<?>, Map<String, ResourceMetadata>>()
+              .put(LDS, ImmutableMap.of("subscribedResourceName.LDS", METADATA_ACKED_LDS))
+              .put(RDS, ImmutableMap.of("subscribedResourceName.RDS", METADATA_ACKED_RDS))
+              .put(CDS, ImmutableMap.of("subscribedResourceName.CDS", METADATA_ACKED_CDS))
+              .put(EDS, ImmutableMap.of("subscribedResourceName.EDS", METADATA_ACKED_EDS))
+              .buildOrThrow();
+        }
+      };
+      ClientConfig clientConfig = CsdsService.getClientConfigForXdsClient(fakeXdsClient,
+          FAKE_CLIENT_SCOPE);
+
+      verifyClientConfigNode(clientConfig);
+      assertThat(clientConfig.getClientScope()).isEqualTo(FAKE_CLIENT_SCOPE);
+
+      // Minimal verification to confirm that the data/metadata XdsClient provides,
+      // is propagated to the correct resource types.
+      int xdsConfigCount = clientConfig.getGenericXdsConfigsCount();
+      assertThat(xdsConfigCount).isEqualTo(4);
+      Map<String, GenericXdsConfig> configDumps = mapConfigDumps(clientConfig);
+      assertThat(configDumps.keySet())
+          .containsExactly(LDS.typeUrl(), RDS.typeUrl(), CDS.typeUrl(), EDS.typeUrl());
+
+      // LDS.
+      GenericXdsConfig genericXdsConfigLds = configDumps.get(LDS.typeUrl());
+      assertThat(genericXdsConfigLds.getName()).isEqualTo("subscribedResourceName.LDS");
+      assertThat(genericXdsConfigLds.getClientStatus()).isEqualTo(ClientResourceStatus.ACKED);
+      assertThat(genericXdsConfigLds.getVersionInfo()).isEqualTo(VERSION_ACK_LDS);
+      assertThat(genericXdsConfigLds.getXdsConfig()).isEqualTo(RAW_LISTENER);
+
+      // RDS.
+      GenericXdsConfig genericXdsConfigRds = configDumps.get(RDS.typeUrl());
+      assertThat(genericXdsConfigRds.getClientStatus()).isEqualTo(ClientResourceStatus.ACKED);
+      assertThat(genericXdsConfigRds.getVersionInfo()).isEqualTo(VERSION_ACK_RDS);
+      assertThat(genericXdsConfigRds.getXdsConfig()).isEqualTo(RAW_ROUTE_CONFIGURATION);
+
+      // CDS.
+      GenericXdsConfig genericXdsConfigCds = configDumps.get(CDS.typeUrl());
+      assertThat(genericXdsConfigCds.getClientStatus()).isEqualTo(ClientResourceStatus.ACKED);
+      assertThat(genericXdsConfigCds.getVersionInfo()).isEqualTo(VERSION_ACK_CDS);
+      assertThat(genericXdsConfigCds.getXdsConfig()).isEqualTo(RAW_CLUSTER);
+
+      // RDS.
+      GenericXdsConfig genericXdsConfigEds = configDumps.get(EDS.typeUrl());
+      assertThat(genericXdsConfigEds.getClientStatus()).isEqualTo(ClientResourceStatus.ACKED);
+      assertThat(genericXdsConfigEds.getVersionInfo()).isEqualTo(VERSION_ACK_EDS);
+      assertThat(genericXdsConfigEds.getXdsConfig()).isEqualTo(RAW_CLUSTER_LOAD_ASSIGNMENT);
+    }
+
+    @Test
+    public void getClientConfigForXdsClient_noSubscribedResources() throws InterruptedException {
+      ClientConfig clientConfig =
+          CsdsService.getClientConfigForXdsClient(XDS_CLIENT_NO_RESOURCES, FAKE_CLIENT_SCOPE);
+      verifyClientConfigNode(clientConfig);
+      assertThat(clientConfig.getGenericXdsConfigsList()).isEmpty();
+      assertThat(clientConfig.getClientScope()).isEqualTo(FAKE_CLIENT_SCOPE);
+    }
+  }
+
+  /**
+   * Assuming {@link EnvoyProtoDataTest#convertNode} passes, perform a minimal check,
+   * just verify the node itself is the one we expect.
+   */
+  private static void verifyClientConfigNode(ClientConfig clientConfig) {
+    Node node = clientConfig.getNode();
+    assertThat(node.getId()).isEqualTo(NODE_ID);
+    assertThat(node).isEqualTo(BOOTSTRAP_NODE.toEnvoyProtoNode());
+  }
+
+  private static Map<String, GenericXdsConfig> mapConfigDumps(ClientConfig config) {
+    Map<String, GenericXdsConfig> xdsConfigMap = new HashMap<>();
+    List<GenericXdsConfig> xdsConfigList = config.getGenericXdsConfigsList();
+    for (GenericXdsConfig genericXdsConfig : xdsConfigList) {
+      assertThat(xdsConfigMap).doesNotContainKey(genericXdsConfig.getTypeUrl());
+      xdsConfigMap.put(genericXdsConfig.getTypeUrl(), genericXdsConfig);
+    }
+    return xdsConfigMap;
+  }
+
+  private static class FakeXdsClient extends XdsClient {
+    protected Map<XdsResourceType<?>, Map<String, ResourceMetadata>>
+        getSubscribedResourcesMetadata() {
+      return ImmutableMap.of();
+    }
+
+    @Override
+    public ListenableFuture<Map<XdsResourceType<?>, Map<String, ResourceMetadata>>>
+        getSubscribedResourcesMetadataSnapshot() {
+      return Futures.immediateFuture(getSubscribedResourcesMetadata());
+    }
+
+    @Override
+    public BootstrapInfo getBootstrapInfo() {
+      return BOOTSTRAP_INFO;
+    }
+  }
+
+  private static class FakeXdsClientPoolFactory implements XdsClientPoolFactory {
+    private final Map<String, XdsClient> xdsClientMap = new HashMap<>();
+    private boolean isOldStyle;
+
+    private FakeXdsClientPoolFactory(@Nullable XdsClient xdsClient) {
+      if (xdsClient != null) {
+        xdsClientMap.put("", xdsClient);
+      }
+      isOldStyle = true;
+    }
+
+    private FakeXdsClientPoolFactory(Map<String,XdsClient> xdsClientMap) {
+      this.xdsClientMap.putAll(xdsClientMap);
+      isOldStyle = false;
+    }
+
+    @Override
+    @Nullable
+    public ObjectPool<XdsClient> get(String target) {
+      String targetToUse = isOldStyle ? "" : target;
+
+      return new ObjectPool<XdsClient>() {
+        @Override
+        public XdsClient getObject() {
+          return xdsClientMap.get(targetToUse);
+        }
+
+        @Override
+        public XdsClient returnObject(Object object) {
+          return null;
+        }
+      };
+    }
+
+    @Override
+    public List<String> getTargets() {
+      return new ArrayList<>(xdsClientMap.keySet());
+    }
+
+    @Override
+    public ObjectPool<XdsClient> getOrCreate(
+        String target, BootstrapInfo bootstrapInfo, MetricRecorder metricRecorder) {
+      throw new UnsupportedOperationException("Should not be called");
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/DataPlaneRule.java b/xds/src/test/java/io/grpc/xds/DataPlaneRule.java
new file mode 100644
index 00000000000..b308419d142
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/DataPlaneRule.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2022 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.xds;
+
+import io.grpc.ForwardingServerCall.SimpleForwardingServerCall;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.Server;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.Status;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import java.net.InetSocketAddress;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.junit.rules.TestWatcher;
+import org.junit.runner.Description;
+
+/**
+ * This rule creates a new server instance in the "data plane" that is configured by a "control
+ * plane" xDS server.
+ */
+public class DataPlaneRule extends TestWatcher {
+  private static final Logger logger = Logger.getLogger(DataPlaneRule.class.getName());
+
+  private static final String SERVER_HOST_NAME = "test-server";
+  static final String ENDPOINT_HOST_NAME = "endpoint-host-name";
+  private static final String SCHEME = "test-xds";
+
+  private final ControlPlaneRule controlPlane;
+  private Server server;
+  private HashSet<ManagedChannel> channels = new HashSet<>();
+
+  /**
+   * Creates a new {@link DataPlaneRule} that is connected to the given {@link ControlPlaneRule}.
+   */
+  public DataPlaneRule(ControlPlaneRule controlPlane) {
+    this.controlPlane = controlPlane;
+  }
+
+  /**
+   * Returns the server instance.
+   */
+  public Server getServer() {
+    return server;
+  }
+
+  /**
+   * Returns a newly created {@link ManagedChannel} to the server.
+   */
+  public ManagedChannel getManagedChannel() {
+    ManagedChannel channel = Grpc.newChannelBuilder(SCHEME + ":///" + SERVER_HOST_NAME,
+        InsecureChannelCredentials.create())
+        .build();
+    channels.add(channel);
+    return channel;
+  }
+
+  @Override
+  protected void starting(Description description) {
+    // Let the control plane know about our new server.
+    controlPlane.setLdsConfig(ControlPlaneRule.buildServerListener(),
+        ControlPlaneRule.buildClientListener(SERVER_HOST_NAME)
+    );
+
+    // Start up the server.
+    try {
+      startServer(controlPlane.defaultBootstrapOverride());
+    } catch (Exception e) {
+      throw new AssertionError("unable to start the data plane server", e);
+    }
+
+    // Provide the rest of the configuration to the control plane.
+    controlPlane.setRdsConfig(ControlPlaneRule.buildRouteConfiguration(SERVER_HOST_NAME));
+    controlPlane.setCdsConfig(ControlPlaneRule.buildCluster());
+    InetSocketAddress edsInetSocketAddress = (InetSocketAddress) server.getListenSockets().get(0);
+    controlPlane.setEdsConfig(
+        ControlPlaneRule.buildClusterLoadAssignment(edsInetSocketAddress.getHostName(),
+            ENDPOINT_HOST_NAME, edsInetSocketAddress.getPort()));
+  }
+
+  @Override
+  protected void finished(Description description) {
+    if (server != null) {
+      // Shut down any lingering open channels to the server.
+      for (ManagedChannel channel : channels) {
+        if (!channel.isShutdown()) {
+          channel.shutdownNow();
+        }
+      }
+
+      // Shut down the server itself.
+      server.shutdownNow();
+      try {
+        if (!server.awaitTermination(5, TimeUnit.SECONDS)) {
+          logger.log(Level.SEVERE, "Timed out waiting for server shutdown");
+        }
+      } catch (InterruptedException e) {
+        throw new AssertionError("unable to shut down data plane server", e);
+      }
+    }
+  }
+
+  private void startServer(Map<String, ?> bootstrapOverride) throws Exception {
+    final String[] authority = new String[1];
+    ServerInterceptor metadataInterceptor = new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+          Metadata requestHeaders, ServerCallHandler<ReqT, RespT> next) {
+        authority[0] = call.getAuthority();
+        logger.fine("Received following metadata: " + requestHeaders);
+
+        // Make a copy of the headers so that it can be read in a thread-safe manner when copying
+        // it to the response headers.
+        Metadata headersToReturn = new Metadata();
+        headersToReturn.merge(requestHeaders);
+
+        return next.startCall(new SimpleForwardingServerCall<ReqT, RespT>(call) {
+          @Override
+          public void sendHeaders(Metadata responseHeaders) {
+            responseHeaders.merge(headersToReturn);
+            super.sendHeaders(responseHeaders);
+          }
+
+          @Override
+          public void close(Status status, Metadata trailers) {
+            super.close(status, trailers);
+          }
+        }, requestHeaders);
+      }
+    };
+
+    SimpleServiceGrpc.SimpleServiceImplBase simpleServiceImpl =
+        new SimpleServiceGrpc.SimpleServiceImplBase() {
+          @Override
+          public void unaryRpc(
+              SimpleRequest request, StreamObserver<SimpleResponse> responseObserver) {
+            String responseMsg = "Hi, xDS!";
+            if (authority[0] != null) {
+              responseMsg += " Authority= " + authority[0];
+            }
+            SimpleResponse response =
+                SimpleResponse.newBuilder().setResponseMessage(responseMsg).build();
+            responseObserver.onNext(response);
+            responseObserver.onCompleted();
+          }
+        };
+
+    XdsServerBuilder serverBuilder = XdsServerBuilder.forPort(
+            0, InsecureServerCredentials.create())
+        .addService(simpleServiceImpl)
+        .intercept(metadataInterceptor)
+        .overrideBootstrapForTest(bootstrapOverride);
+    server = serverBuilder.build().start();
+    logger.log(Level.FINE, "data plane server started");
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/FakeControlPlaneXdsIntegrationTest.java b/xds/src/test/java/io/grpc/xds/FakeControlPlaneXdsIntegrationTest.java
new file mode 100644
index 00000000000..c8f2b8932ef
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/FakeControlPlaneXdsIntegrationTest.java
@@ -0,0 +1,342 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.DataPlaneRule.ENDPOINT_HOST_NAME;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_CDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_EDS;
+import static org.junit.Assert.assertEquals;
+
+import com.github.xds.type.v3.TypedStruct;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Any;
+import com.google.protobuf.Struct;
+import com.google.protobuf.Value;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.LbPolicy;
+import io.envoyproxy.envoy.config.cluster.v3.LoadBalancingPolicy;
+import io.envoyproxy.envoy.config.cluster.v3.LoadBalancingPolicy.Policy;
+import io.envoyproxy.envoy.config.core.v3.Address;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress;
+import io.envoyproxy.envoy.config.core.v3.TypedExtensionConfig;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;
+import io.envoyproxy.envoy.config.endpoint.v3.Endpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints;
+import io.envoyproxy.envoy.config.route.v3.Route;
+import io.envoyproxy.envoy.config.route.v3.RouteAction;
+import io.envoyproxy.envoy.config.route.v3.RouteConfiguration;
+import io.envoyproxy.envoy.config.route.v3.RouteMatch;
+import io.envoyproxy.envoy.config.route.v3.VirtualHost;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.wrr_locality.v3.WrrLocality;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingClientCallListener;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import java.net.InetSocketAddress;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Xds integration tests using a local control plane, implemented in {@link
+ * XdsTestControlPlaneService}. Test cases can inject xds configs to the control plane for testing.
+ *
+ * <p>Test components:
+ * 1) A Control Plane {@link XdsTestControlPlaneService} accepts xds requests from multiple clients
+ * from the Data Plane, see {@link ControlPlaneRule}.
+ * 2) A test xDS server {@link XdsServerWrapper}, see {@link DataPlaneRule}.
+ * 3) A test xDS client that uses a testing scheme {@link XdsNameResolverProvider#createForTest},
+ * see {@link DataPlaneRule}.
+ *
+ * <p>The configuration dependency and ephemeral port allocation requires the components to
+ * be initialized in a certain order:
+ * 1) Start the Control Plane server {@link XdsTestControlPlaneService}. After start the bootstrap
+ * information (w/ Control Plane's address) can be constructed for the Data Plane to initialize.
+ * 2) Set LDS and RDS config at the Control Plane. Get the bootstrap file from the Control
+ * Plane from 1). And then start the test xDS server (requires LDS/RDS and bootstrap file to start).
+ * 3) Construct EDS config w/ test server address from 2). Set CDS and EDS Config at the Control
+ * Plane. Then start the test xDS client (requires EDS to do xDS name resolution).
+ */
+@RunWith(JUnit4.class)
+public class FakeControlPlaneXdsIntegrationTest {
+
+  @Rule(order = 0)
+  public ControlPlaneRule controlPlane = new ControlPlaneRule();
+  @Rule(order = 1)
+  public DataPlaneRule dataPlane = new DataPlaneRule(controlPlane);
+
+  @Test
+  public void pingPong() throws Exception {
+    ManagedChannel channel = dataPlane.getManagedChannel();
+    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub = SimpleServiceGrpc.newBlockingStub(
+        channel);
+    SimpleRequest request = SimpleRequest.getDefaultInstance();
+    SimpleResponse goldenResponse = SimpleResponse.newBuilder()
+        .setResponseMessage("Hi, xDS! Authority= test-server")
+        .build();
+    assertEquals(goldenResponse, blockingStub.unaryRpc(request));
+  }
+
+  @Test
+  public void pingPong_edsEndpoint_authorityOverride() throws Exception {
+    System.setProperty("GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE", "true");
+    try {
+      ManagedChannel channel = dataPlane.getManagedChannel();
+      SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub = SimpleServiceGrpc.newBlockingStub(
+          channel);
+      SimpleRequest request = SimpleRequest.getDefaultInstance();
+      SimpleResponse goldenResponse = SimpleResponse.newBuilder()
+          .setResponseMessage("Hi, xDS! Authority= " + ENDPOINT_HOST_NAME)
+          .build();
+      assertEquals(goldenResponse, blockingStub.unaryRpc(request));
+    } finally {
+      System.clearProperty("GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE");
+    }
+  }
+
+  @Test
+  public void pingPong_metadataLoadBalancer() throws Exception {
+    MetadataLoadBalancerProvider metadataLbProvider = new MetadataLoadBalancerProvider();
+    try {
+      LoadBalancerRegistry.getDefaultRegistry().register(metadataLbProvider);
+
+      // Use the LoadBalancingPolicy to configure a custom LB that adds a header to server calls.
+      Policy metadataLbPolicy = Policy.newBuilder().setTypedExtensionConfig(
+          TypedExtensionConfig.newBuilder().setTypedConfig(Any.pack(
+              TypedStruct.newBuilder().setTypeUrl("type.googleapis.com/test.MetadataLoadBalancer")
+                  .setValue(Struct.newBuilder()
+                      .putFields("metadataKey", Value.newBuilder().setStringValue("foo").build())
+                      .putFields("metadataValue", Value.newBuilder().setStringValue("bar").build()))
+                  .build()))).build();
+      Policy wrrLocalityPolicy = Policy.newBuilder()
+          .setTypedExtensionConfig(TypedExtensionConfig.newBuilder().setTypedConfig(
+              Any.pack(WrrLocality.newBuilder().setEndpointPickingPolicy(
+                  LoadBalancingPolicy.newBuilder().addPolicies(metadataLbPolicy)).build())))
+          .build();
+      controlPlane.setCdsConfig(
+          ControlPlaneRule.buildCluster().toBuilder().setLoadBalancingPolicy(
+              LoadBalancingPolicy.newBuilder()
+                  .addPolicies(wrrLocalityPolicy)).build());
+
+      ResponseHeaderClientInterceptor responseHeaderInterceptor
+          = new ResponseHeaderClientInterceptor();
+
+      // We add an interceptor to catch the response headers from the server.
+      SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub = SimpleServiceGrpc.newBlockingStub(
+          dataPlane.getManagedChannel()).withInterceptors(responseHeaderInterceptor);
+      SimpleRequest request = SimpleRequest.getDefaultInstance();
+      SimpleResponse goldenResponse = SimpleResponse.newBuilder()
+          .setResponseMessage("Hi, xDS! Authority= test-server")
+          .build();
+      assertEquals(goldenResponse, blockingStub.unaryRpc(request));
+
+      // Make sure we got back the header we configured the LB with.
+      assertThat(responseHeaderInterceptor.reponseHeaders.get(
+          Metadata.Key.of("foo", Metadata.ASCII_STRING_MARSHALLER))).isEqualTo("bar");
+    } finally {
+      LoadBalancerRegistry.getDefaultRegistry().deregister(metadataLbProvider);
+    }
+  }
+
+  // Try to trigger "UNAVAILABLE: CDS encountered error: unable to find available subchannel for
+  // cluster cluster:cluster1" race, if XdsNameResolver updates its ConfigSelector before
+  // cluster_manager config.
+  @Test
+  public void changeClusterForRoute() throws Exception {
+    // Start with route to cluster0
+    InetSocketAddress edsInetSocketAddress
+        = (InetSocketAddress) dataPlane.getServer().getListenSockets().get(0);
+    controlPlane.getService().setXdsConfig(
+        ADS_TYPE_URL_EDS,
+        ImmutableMap.of(
+          "eds-service-0",
+          ControlPlaneRule.buildClusterLoadAssignment(
+              edsInetSocketAddress.getHostName(), "", edsInetSocketAddress.getPort(),
+              "eds-service-0"),
+          "eds-service-1",
+          ControlPlaneRule.buildClusterLoadAssignment(
+              edsInetSocketAddress.getHostName(), "", edsInetSocketAddress.getPort(),
+              "eds-service-1")));
+    controlPlane.getService().setXdsConfig(
+        ADS_TYPE_URL_CDS,
+        ImmutableMap.of(
+            "cluster0",
+            ControlPlaneRule.buildCluster("cluster0", "eds-service-0"),
+            "cluster1",
+            ControlPlaneRule.buildCluster("cluster1", "eds-service-1")));
+    controlPlane.setRdsConfig(RouteConfiguration.newBuilder()
+        .setName("route-config.googleapis.com")
+        .addVirtualHosts(VirtualHost.newBuilder()
+          .addDomains("test-server")
+          .addRoutes(Route.newBuilder()
+            .setMatch(RouteMatch.newBuilder().setPrefix("/").build())
+            .setRoute(RouteAction.newBuilder().setCluster("cluster0").build())
+            .build())
+          .build())
+        .build());
+
+    class ClusterClientStreamTracer extends ClientStreamTracer {
+      boolean usedCluster1;
+
+      @Override
+      public void addOptionalLabel(String key, String value) {
+        if ("grpc.lb.backend_service".equals(key)) {
+          usedCluster1 = "cluster1".equals(value);
+        }
+      }
+    }
+
+    ClusterClientStreamTracer tracer = new ClusterClientStreamTracer();
+    ClientStreamTracer.Factory tracerFactory = new ClientStreamTracer.Factory() {
+      @Override
+      public ClientStreamTracer newClientStreamTracer(
+          ClientStreamTracer.StreamInfo info, Metadata headers) {
+        return tracer;
+      }
+    };
+    ClientInterceptor tracerInterceptor = new ClientInterceptor() {
+      @Override
+      public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+          MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+        return next.newCall(method, callOptions.withStreamTracerFactory(tracerFactory));
+      }
+    };
+    SimpleServiceGrpc.SimpleServiceBlockingStub stub = SimpleServiceGrpc
+        .newBlockingStub(dataPlane.getManagedChannel())
+        .withInterceptors(tracerInterceptor);
+    SimpleRequest request = SimpleRequest.getDefaultInstance();
+    SimpleResponse goldenResponse = SimpleResponse.newBuilder()
+        .setResponseMessage("Hi, xDS! Authority= test-server")
+        .build();
+    assertThat(stub.unaryRpc(request)).isEqualTo(goldenResponse);
+    assertThat(tracer.usedCluster1).isFalse();
+
+    // Check for errors when swapping route to cluster1
+    controlPlane.setRdsConfig(RouteConfiguration.newBuilder()
+        .setName("route-config.googleapis.com")
+        .addVirtualHosts(VirtualHost.newBuilder()
+          .addDomains("test-server")
+          .addRoutes(Route.newBuilder()
+            .setMatch(RouteMatch.newBuilder().setPrefix("/").build())
+            .setRoute(RouteAction.newBuilder().setCluster("cluster1").build())
+            .build())
+          .build())
+        .build());
+
+    for (int j = 0; j < 10; j++) {
+      stub.unaryRpc(request);
+      if (tracer.usedCluster1) {
+        break;
+      }
+    }
+    assertThat(tracer.usedCluster1).isTrue();
+  }
+
+  // Captures response headers from the server.
+  private static class ResponseHeaderClientInterceptor implements ClientInterceptor {
+    Metadata reponseHeaders;
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method,
+        CallOptions callOptions, Channel next) {
+
+      return new SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {
+        @Override
+        public void start(ClientCall.Listener<RespT> responseListener, Metadata headers) {
+          super.start(new ForwardingClientCallListener<RespT>() {
+            @Override
+            protected ClientCall.Listener<RespT> delegate() {
+              return responseListener;
+            }
+
+            @Override
+            public void onHeaders(Metadata headers) {
+              reponseHeaders = headers;
+            }
+          }, headers);
+        }
+      };
+    }
+  }
+
+  /**
+   * Basic test to make sure RING_HASH configuration works.
+   */
+  @Test
+  public void pingPong_ringHash() {
+    controlPlane.setCdsConfig(
+        ControlPlaneRule.buildCluster().toBuilder()
+            .setLbPolicy(LbPolicy.RING_HASH).build());
+
+    ManagedChannel channel = dataPlane.getManagedChannel();
+    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub = SimpleServiceGrpc.newBlockingStub(
+        channel);
+    SimpleRequest request = SimpleRequest.getDefaultInstance();
+    SimpleResponse goldenResponse = SimpleResponse.newBuilder()
+        .setResponseMessage("Hi, xDS! Authority= test-server")
+        .build();
+    assertEquals(goldenResponse, blockingStub.unaryRpc(request));
+  }
+
+  @Test
+  public void pingPong_logicalDns_authorityOverride() {
+    System.setProperty("GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE", "true");
+    try {
+      InetSocketAddress serverAddress =
+          (InetSocketAddress) dataPlane.getServer().getListenSockets().get(0);
+      controlPlane.setCdsConfig(
+          ControlPlaneRule.buildCluster().toBuilder()
+              .setType(Cluster.DiscoveryType.LOGICAL_DNS)
+              .setLoadAssignment(
+                  ClusterLoadAssignment.newBuilder().addEndpoints(
+                          LocalityLbEndpoints.newBuilder().addLbEndpoints(
+                              LbEndpoint.newBuilder().setEndpoint(
+                                  Endpoint.newBuilder().setAddress(
+                                      Address.newBuilder().setSocketAddress(
+                                          SocketAddress.newBuilder()
+                                              .setAddress("localhost")
+                                              .setPortValue(serverAddress.getPort()))))))
+                      .build())
+              .build());
+
+      ManagedChannel channel = dataPlane.getManagedChannel();
+      SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub = SimpleServiceGrpc.newBlockingStub(
+          channel);
+      SimpleRequest request = SimpleRequest.getDefaultInstance();
+      SimpleResponse goldenResponse = SimpleResponse.newBuilder()
+          .setResponseMessage("Hi, xDS! Authority= localhost:" + serverAddress.getPort())
+          .build();
+      assertEquals(goldenResponse, blockingStub.unaryRpc(request));
+    } finally {
+      System.clearProperty("GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE");
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/FaultFilterTest.java b/xds/src/test/java/io/grpc/xds/FaultFilterTest.java
new file mode 100644
index 00000000000..8f0a33951b0
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/FaultFilterTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.protobuf.Any;
+import io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort;
+import io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort.HeaderAbort;
+import io.envoyproxy.envoy.extensions.filters.http.fault.v3.HTTPFault;
+import io.envoyproxy.envoy.type.v3.FractionalPercent;
+import io.envoyproxy.envoy.type.v3.FractionalPercent.DenominatorType;
+import io.grpc.Status.Code;
+import io.grpc.internal.GrpcUtil;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link FaultFilter}. */
+@RunWith(JUnit4.class)
+public class FaultFilterTest {
+  private static final FaultFilter.Provider FILTER_PROVIDER = new FaultFilter.Provider();
+
+  @Test
+  public void filterType_clientOnly() {
+    assertThat(FILTER_PROVIDER.isClientFilter()).isTrue();
+    assertThat(FILTER_PROVIDER.isServerFilter()).isFalse();
+  }
+
+  @Test
+  public void parseFaultAbort_convertHttpStatus() {
+    Any rawConfig = Any.pack(
+        HTTPFault.newBuilder().setAbort(FaultAbort.newBuilder().setHttpStatus(404)).build());
+    FaultConfig faultConfig = FILTER_PROVIDER.parseFilterConfig(rawConfig).config;
+    assertThat(faultConfig.faultAbort().status().getCode())
+        .isEqualTo(GrpcUtil.httpStatusToGrpcStatus(404).getCode());
+
+    FaultConfig faultConfigOverride = FILTER_PROVIDER.parseFilterConfigOverride(rawConfig).config;
+    assertThat(faultConfigOverride.faultAbort().status().getCode())
+        .isEqualTo(GrpcUtil.httpStatusToGrpcStatus(404).getCode());
+  }
+
+  @Test
+  public void parseFaultAbort_withHeaderAbort() {
+    io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort proto =
+        io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort.newBuilder()
+            .setPercentage(FractionalPercent.newBuilder()
+                .setNumerator(20).setDenominator(DenominatorType.HUNDRED))
+            .setHeaderAbort(HeaderAbort.getDefaultInstance()).build();
+    FaultConfig.FaultAbort faultAbort = FaultFilter.Provider.parseFaultAbort(proto).config;
+    assertThat(faultAbort.headerAbort()).isTrue();
+    assertThat(faultAbort.percent().numerator()).isEqualTo(20);
+    assertThat(faultAbort.percent().denominatorType())
+        .isEqualTo(FaultConfig.FractionalPercent.DenominatorType.HUNDRED);
+  }
+
+  @Test
+  public void parseFaultAbort_withHttpStatus() {
+    io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort proto =
+        io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort.newBuilder()
+            .setPercentage(FractionalPercent.newBuilder()
+                .setNumerator(100).setDenominator(DenominatorType.TEN_THOUSAND))
+            .setHttpStatus(400).build();
+    FaultConfig.FaultAbort res = FaultFilter.Provider.parseFaultAbort(proto).config;
+    assertThat(res.percent().numerator()).isEqualTo(100);
+    assertThat(res.percent().denominatorType())
+        .isEqualTo(FaultConfig.FractionalPercent.DenominatorType.TEN_THOUSAND);
+    assertThat(res.status().getCode()).isEqualTo(Code.INTERNAL);
+  }
+
+  @Test
+  public void parseFaultAbort_withGrpcStatus() {
+    io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort proto =
+        io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort.newBuilder()
+            .setPercentage(FractionalPercent.newBuilder()
+                .setNumerator(600).setDenominator(DenominatorType.MILLION))
+            .setGrpcStatus(Code.DEADLINE_EXCEEDED.value()).build();
+    FaultConfig.FaultAbort faultAbort = FaultFilter.Provider.parseFaultAbort(proto).config;
+    assertThat(faultAbort.percent().numerator()).isEqualTo(600);
+    assertThat(faultAbort.percent().denominatorType())
+        .isEqualTo(FaultConfig.FractionalPercent.DenominatorType.MILLION);
+    assertThat(faultAbort.status().getCode()).isEqualTo(Code.DEADLINE_EXCEEDED);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/FilterChainMatchingProtocolNegotiatorsTest.java b/xds/src/test/java/io/grpc/xds/FilterChainMatchingProtocolNegotiatorsTest.java
new file mode 100644
index 00000000000..722f915dbea
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/FilterChainMatchingProtocolNegotiatorsTest.java
@@ -0,0 +1,1282 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.XdsServerWrapper.ATTR_SERVER_ROUTING_CONFIG;
+import static io.grpc.xds.internal.security.SecurityProtocolNegotiators.ATTR_SERVER_SSL_CONTEXT_PROVIDER_SUPPLIER;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.net.InetAddresses;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.ServerInterceptor;
+import io.grpc.internal.TestUtils.NoopChannelLogger;
+import io.grpc.netty.GrpcHttp2ConnectionHandler;
+import io.grpc.netty.InternalProtocolNegotiationEvent;
+import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
+import io.grpc.netty.ProtocolNegotiationEvent;
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.EnvoyServerProtoData.FilterChain;
+import io.grpc.xds.Filter.FilterConfig;
+import io.grpc.xds.Filter.NamedFilterConfig;
+import io.grpc.xds.FilterChainMatchingProtocolNegotiators.FilterChainMatchingHandler;
+import io.grpc.xds.FilterChainMatchingProtocolNegotiators.FilterChainMatchingHandler.FilterChainSelector;
+import io.grpc.xds.VirtualHost.Route;
+import io.grpc.xds.XdsServerWrapper.ServerRoutingConfig;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil;
+import io.grpc.xds.internal.security.SslContextProviderSupplier;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.embedded.EmbeddedChannel;
+import io.netty.handler.codec.http2.DefaultHttp2Connection;
+import io.netty.handler.codec.http2.DefaultHttp2ConnectionDecoder;
+import io.netty.handler.codec.http2.DefaultHttp2ConnectionEncoder;
+import io.netty.handler.codec.http2.DefaultHttp2FrameReader;
+import io.netty.handler.codec.http2.DefaultHttp2FrameWriter;
+import io.netty.handler.codec.http2.Http2ConnectionDecoder;
+import io.netty.handler.codec.http2.Http2ConnectionEncoder;
+import io.netty.handler.codec.http2.Http2Settings;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.After;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class FilterChainMatchingProtocolNegotiatorsTest {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private final GrpcHttp2ConnectionHandler grpcHandler =
+          FakeGrpcHttp2ConnectionHandler.newHandler();
+  @Mock private TlsContextManager tlsContextManager;
+  private ProtocolNegotiationEvent event = InternalProtocolNegotiationEvent.getDefault();
+  private ChannelPipeline pipeline;
+  private EmbeddedChannel channel;
+  private ChannelHandlerContext channelHandlerCtx;
+  @Mock
+  private ProtocolNegotiator mockDelegate;
+  private FilterChainSelectorManager selectorManager = new FilterChainSelectorManager();
+  private static final EnvoyServerProtoData.FilterChainMatch DEFAULT_FILTER_CHAIN_MATCH =
+      EnvoyServerProtoData.FilterChainMatch.create(
+          0,
+          ImmutableList.of(),
+          ImmutableList.of(),
+          ImmutableList.of(),
+          EnvoyServerProtoData.ConnectionSourceType.ANY,
+          ImmutableList.of(),
+          ImmutableList.of(),
+          "");
+  private static final HttpConnectionManager HTTP_CONNECTION_MANAGER = createRds("routing-config");
+  private static final String LOCAL_IP = "10.1.2.3";  // dest
+  private static final String REMOTE_IP = "10.4.2.3"; // source
+  private static final int PORT = 7000;
+  private final AtomicReference<ServerRoutingConfig> noopConfig = new AtomicReference<>(
+      ServerRoutingConfig.create(ImmutableList.<VirtualHost>of(),
+          ImmutableMap.<Route, ServerInterceptor>of()));
+  final SettableFuture<SslContextProviderSupplier> sslSet = SettableFuture.create();
+  final SettableFuture<AtomicReference<ServerRoutingConfig>> routingSettable =
+      SettableFuture.create();
+
+  @After
+  @SuppressWarnings("FutureReturnValueIgnored")
+  public void tearDown() {
+    if (channel.isActive()) {
+      channel.close();
+      channel.runPendingTasks();
+    }
+    assertThat(selectorManager.getRegisterCount()).isEqualTo(0);
+  }
+
+  @Test
+  public void nofilterChainMatch_defaultSslContext() throws Exception {
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+
+    SslContextProviderSupplier defaultSsl = new SslContextProviderSupplier(createTls(),
+            tlsContextManager);
+    selectorManager.updateSelector(new FilterChainSelector(
+            new HashMap<FilterChain, AtomicReference<ServerRoutingConfig>>(),
+        defaultSsl, noopConfig));
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+    setupChannel("172.168.1.1", "172.168.1.2", 80, filterChainMatchingHandler);
+    ChannelHandlerContext channelHandlerCtx = pipeline.context(filterChainMatchingHandler);
+    assertThat(channelHandlerCtx).isNotNull();
+
+    pipeline.fireUserEventTriggered(event);
+    channelHandlerCtx = pipeline.context(filterChainMatchingHandler);
+    assertThat(channelHandlerCtx).isNull();
+
+    channel.runPendingTasks();
+    assertThat(sslSet.isDone()).isTrue();
+    assertThat(sslSet.get()).isEqualTo(defaultSsl);
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    channelHandlerCtx = pipeline.context(next);
+    assertThat(channelHandlerCtx).isNotNull();
+  }
+
+  @Test
+  public void noFilterChainMatch_noDefaultSslContext() {
+    selectorManager.updateSelector(new FilterChainSelector(
+            new HashMap<FilterChain, AtomicReference<ServerRoutingConfig>>(),
+        null, new AtomicReference<ServerRoutingConfig>()));
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+    setupChannel("172.168.1.1", "172.168.2.2", 90, filterChainMatchingHandler);
+    channelHandlerCtx = pipeline.context(filterChainMatchingHandler);
+    assertThat(channelHandlerCtx).isNotNull();
+
+    assertThat(channel.closeFuture().isDone()).isFalse();
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(channel.closeFuture().isDone()).isTrue();
+  }
+
+  @Test
+  public void filterSelectorChange_drainsConnection() {
+    ChannelHandler next = new ChannelInboundHandlerAdapter();
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    selectorManager.updateSelector(new FilterChainSelector(
+            new HashMap<FilterChain, AtomicReference<ServerRoutingConfig>>(), null, noopConfig));
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+    setupChannel("172.168.1.1", "172.168.2.2", 90, filterChainMatchingHandler);
+    channelHandlerCtx = pipeline.context(filterChainMatchingHandler);
+    assertThat(channelHandlerCtx).isNotNull();
+
+    pipeline.fireUserEventTriggered(event);
+    channelHandlerCtx = pipeline.context(filterChainMatchingHandler);
+    assertThat(channelHandlerCtx).isNull();
+
+    channel.runPendingTasks();
+    channelHandlerCtx = pipeline.context(next);
+    assertThat(channelHandlerCtx).isNotNull();
+    // Force return value to Object, to avoid confusing javac of the type passed to assertThat()
+    Object msg = channel.readOutbound();
+    assertThat(msg).isNull();
+
+    selectorManager.updateSelector(new FilterChainSelector(
+            new HashMap<FilterChain, AtomicReference<ServerRoutingConfig>>(), null, noopConfig));
+    assertThat(channel.readOutbound().getClass().getName())
+        .isEqualTo("io.grpc.netty.GracefulServerCloseCommand");
+  }
+
+  @Test
+  public void singleFilterChainWithoutAlpn() throws Exception {
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.FilterChain filterChain = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-foo", filterChainMatch, HTTP_CONNECTION_MANAGER, tlsContext,
+            tlsContextManager);
+
+    selectorManager.updateSelector(new FilterChainSelector(ImmutableMap.of(filterChain, noopConfig),
+            null, new AtomicReference<ServerRoutingConfig>()));
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.isDone()).isTrue();
+    assertThat(sslSet.get()).isEqualTo(filterChain.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(tlsContext);
+  }
+
+  @Test
+  public void singleFilterChainWithAlpn() throws Exception {
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of("managed-mtls"),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.FilterChain filterChain = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-foo", filterChainMatch, HTTP_CONNECTION_MANAGER, tlsContext,
+            tlsContextManager);
+    EnvoyServerProtoData.DownstreamTlsContext defaultTlsContext =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-bar", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER, defaultTlsContext,
+        tlsContextManager);
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChain, randomConfig("no-match")),
+            defaultFilterChain.sslContextProviderSupplier(), noopConfig));
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(defaultFilterChain.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(defaultTlsContext);
+  }
+
+  @Test
+  public void destPortFails_returnDefaultFilterChain() throws Exception {
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextWithDestPort =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchWithDestPort =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            PORT,
+            ImmutableList.of(),
+            ImmutableList.of("managed-mtls"),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainWithDestPort =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-foo", filterChainMatchWithDestPort, HTTP_CONNECTION_MANAGER,
+                    tlsContextWithDestPort, tlsContextManager);
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextForDefaultFilterChain =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChain defaultFilterChain =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-bar", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER,
+                    tlsContextForDefaultFilterChain, tlsContextManager);
+
+    ServerRoutingConfig routingConfig = ServerRoutingConfig.create(
+                ImmutableList.of(createVirtualHost("virtual")),
+        ImmutableMap.<Route, ServerInterceptor>of());
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChainWithDestPort,
+                new AtomicReference<ServerRoutingConfig>(routingConfig)),
+            defaultFilterChain.sslContextProviderSupplier(), noopConfig));
+
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(defaultFilterChain.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext())
+            .isSameInstanceAs(tlsContextForDefaultFilterChain);
+  }
+
+  @Test
+  public void destPrefixRangeMatch() throws Exception {
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextMatch =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchWithMatch =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.1.2.0"), 24)),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainWithMatch = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-foo", filterChainMatchWithMatch, HTTP_CONNECTION_MANAGER,
+            tlsContextMatch, tlsContextManager);
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextForDefaultFilterChain =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-bar", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER,
+            tlsContextForDefaultFilterChain, tlsContextManager);
+
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChainWithMatch, noopConfig),
+            defaultFilterChain.sslContextProviderSupplier(), randomConfig("no-match")));
+
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(filterChainWithMatch.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(tlsContextMatch);
+  }
+
+  @Test
+  public void destPrefixRangeMismatch_returnDefaultFilterChain()
+          throws Exception {
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextMismatch =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    // 10.2.2.0/24 doesn't match LOCAL_IP
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchWithMismatch =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.2.2.0"), 24)),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainWithMismatch =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-foo", filterChainMatchWithMismatch, HTTP_CONNECTION_MANAGER,
+                    tlsContextMismatch, tlsContextManager);
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextForDefaultFilterChain =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-bar", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER,
+            tlsContextForDefaultFilterChain, tlsContextManager);
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChainWithMismatch, randomConfig("no-match")),
+            defaultFilterChain.sslContextProviderSupplier(), noopConfig));
+
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.isDone()).isTrue();
+    assertThat(sslSet.get()).isEqualTo(defaultFilterChain.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(tlsContextForDefaultFilterChain);
+  }
+
+  @Test
+  public void dest0LengthPrefixRange()
+          throws Exception {
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext0Length =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    // 10.2.2.0/24 doesn't match LOCAL_IP
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch0Length =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.2.2.0"), 0)),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChain0Length = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-foo", filterChainMatch0Length, HTTP_CONNECTION_MANAGER,
+            tlsContext0Length, tlsContextManager);
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextForDefaultFilterChain =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-bar", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER,
+            tlsContextForDefaultFilterChain, tlsContextManager);
+
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChain0Length, noopConfig),
+            defaultFilterChain.sslContextProviderSupplier(),
+        new AtomicReference<ServerRoutingConfig>()));
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(filterChain0Length.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(tlsContext0Length);
+  }
+
+  @Test
+  public void destPrefixRange_moreSpecificWins()
+          throws Exception {
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextLessSpecific =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchLessSpecific =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.1.2.0"), 24)),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainLessSpecific =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-foo", filterChainMatchLessSpecific, HTTP_CONNECTION_MANAGER,
+                    tlsContextLessSpecific, tlsContextManager);
+
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextMoreSpecific =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchMoreSpecific =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.1.2.2"), 31)),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainMoreSpecific =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-bar", filterChainMatchMoreSpecific, HTTP_CONNECTION_MANAGER,
+                    tlsContextMoreSpecific,
+                    tlsContextManager);
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-baz", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER, null,
+        tlsContextManager);
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChainLessSpecific, randomConfig("no-match"),
+                    filterChainMoreSpecific, noopConfig),
+            defaultFilterChain.sslContextProviderSupplier(), randomConfig("default")));
+
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(filterChainMoreSpecific.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(tlsContextMoreSpecific);
+  }
+
+  @Test
+  public void destPrefixRange_emptyListLessSpecific()
+          throws Exception {
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextLessSpecific =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchLessSpecific =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainLessSpecific =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-foo", filterChainMatchLessSpecific, HTTP_CONNECTION_MANAGER,
+                    tlsContextLessSpecific, tlsContextManager);
+
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextMoreSpecific =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchMoreSpecific =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("8.0.0.0"), 5)),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainMoreSpecific =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-bar", filterChainMatchMoreSpecific, HTTP_CONNECTION_MANAGER,
+                    tlsContextMoreSpecific,
+                    tlsContextManager);
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-baz", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER, null,
+        tlsContextManager);
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChainLessSpecific, randomConfig("no-match"),
+                    filterChainMoreSpecific, noopConfig),
+            defaultFilterChain.sslContextProviderSupplier(), randomConfig("default")));
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(filterChainMoreSpecific.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(tlsContextMoreSpecific);
+  }
+
+  @Test
+  public void destPrefixRangeIpv6_moreSpecificWins()
+          throws Exception {
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextLessSpecific =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchLessSpecific =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("FE80:0:0:0:0:0:0:0"), 60)),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainLessSpecific =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-foo", filterChainMatchLessSpecific, HTTP_CONNECTION_MANAGER,
+                    tlsContextLessSpecific, tlsContextManager);
+
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextMoreSpecific =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchMoreSpecific =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("FE80:0000:0000:0000:0202:0:0:0"), 80)),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainMoreSpecific =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-bar", filterChainMatchMoreSpecific, HTTP_CONNECTION_MANAGER,
+                    tlsContextMoreSpecific, tlsContextManager);
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-baz", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER, null,
+        tlsContextManager);
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChainLessSpecific, randomConfig("no-match"),
+                    filterChainMoreSpecific, noopConfig),
+            defaultFilterChain.sslContextProviderSupplier(), randomConfig("default")));
+
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+
+    setupChannel("FE80:0000:0000:0000:0202:B3FF:FE1E:8329", "2001:DB8::8:800:200C:417A",
+            15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(filterChainMoreSpecific.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(tlsContextMoreSpecific);
+  }
+
+  @Test
+  public void destPrefixRange_moreSpecificWith2Wins()
+          throws Exception {
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextMoreSpecificWith2 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchMoreSpecificWith2 =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("10.1.2.0"), 24),
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString(LOCAL_IP), 32)),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainMoreSpecificWith2 =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-foo", filterChainMatchMoreSpecificWith2, HTTP_CONNECTION_MANAGER,
+                    tlsContextMoreSpecificWith2, tlsContextManager);
+
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextLessSpecific =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchLessSpecific =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.1.2.2"), 31)),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainLessSpecific =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-bar", filterChainMatchLessSpecific, HTTP_CONNECTION_MANAGER,
+                    tlsContextLessSpecific, tlsContextManager);
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-baz", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER, null,
+        tlsContextManager);
+
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChainMoreSpecificWith2, noopConfig,
+                    filterChainLessSpecific, randomConfig("no-match")),
+            defaultFilterChain.sslContextProviderSupplier(), randomConfig("default")));
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(
+            filterChainMoreSpecificWith2.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(tlsContextMoreSpecificWith2);
+  }
+
+  @Test
+  public void sourceTypeMismatch_returnDefaultFilterChain() throws Exception {
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextMismatch =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchWithMismatch =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.SAME_IP_OR_LOOPBACK,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainWithMismatch =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-foo", filterChainMatchWithMismatch, HTTP_CONNECTION_MANAGER,
+                    tlsContextMismatch, tlsContextManager);
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextForDefaultFilterChain =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-bar", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER,
+        tlsContextForDefaultFilterChain, tlsContextManager);
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChainWithMismatch, randomConfig("no-match")),
+            defaultFilterChain.sslContextProviderSupplier(), noopConfig));
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+
+
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(defaultFilterChain.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(tlsContextForDefaultFilterChain);
+  }
+
+  @Test
+  public void sourceTypeLocal() throws Exception {
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextMatch =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchWithMatch =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.SAME_IP_OR_LOOPBACK,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainWithMatch = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-foo", filterChainMatchWithMatch, HTTP_CONNECTION_MANAGER, tlsContextMatch,
+            tlsContextManager);
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextForDefaultFilterChain =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-bar", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER,
+        tlsContextForDefaultFilterChain, tlsContextManager);
+
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChainWithMatch, noopConfig),
+            defaultFilterChain.sslContextProviderSupplier(), randomConfig("default")));
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+    setupChannel(LOCAL_IP, LOCAL_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(filterChainWithMatch.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(tlsContextMatch);
+  }
+
+  @Test
+  public void sourcePrefixRange_moreSpecificWith2Wins()
+          throws Exception {
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextMoreSpecificWith2 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchMoreSpecificWith2 =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("10.4.2.0"), 24),
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString(REMOTE_IP), 32)),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainMoreSpecificWith2 =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-foo", filterChainMatchMoreSpecificWith2, HTTP_CONNECTION_MANAGER,
+                    tlsContextMoreSpecificWith2, tlsContextManager);
+
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextLessSpecific =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchLessSpecific =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.4.2.2"), 31)),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainLessSpecific =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-bar", filterChainMatchLessSpecific, HTTP_CONNECTION_MANAGER,
+                    tlsContextLessSpecific, tlsContextManager);
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-baz", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER, null,
+        tlsContextManager);
+
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChainMoreSpecificWith2, noopConfig,
+                    filterChainLessSpecific, randomConfig("no-match")),
+            defaultFilterChain.sslContextProviderSupplier(), randomConfig("default")));
+
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(
+            filterChainMoreSpecificWith2.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(tlsContextMoreSpecificWith2);
+  }
+
+  @Test
+  public void sourcePrefixRange_2Matchers_expectException() {
+    ChannelHandler next = new ChannelInboundHandlerAdapter() {
+      @Override
+      public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
+        ProtocolNegotiationEvent e = (ProtocolNegotiationEvent)evt;
+        sslSet.set(InternalProtocolNegotiationEvent.getAttributes(e)
+                .get(ATTR_SERVER_SSL_CONTEXT_PROVIDER_SUPPLIER));
+      }
+    };
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext1 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch1 =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("10.4.2.0"), 24),
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("192.168.10.2"), 32)),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChain1 = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-foo", filterChainMatch1, HTTP_CONNECTION_MANAGER, tlsContext1,
+            tlsContextManager);
+
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext2 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch2 =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.4.2.0"), 24)),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChain2 = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-bar", filterChainMatch2, HTTP_CONNECTION_MANAGER, tlsContext2,
+            tlsContextManager);
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-baz", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER, null, null);
+
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChain1, noopConfig, filterChain2, noopConfig),
+            defaultFilterChain.sslContextProviderSupplier(), noopConfig));
+
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    try {
+      channel.checkException();
+      fail("expect exception!");
+    } catch (IllegalStateException ise) {
+      assertThat(ise).hasMessageThat().isEqualTo("Found more than one matching filter chains. This "
+          + "should not be possible as ClientXdsClient validated the chains for uniqueness.");
+      assertThat(sslSet.isDone()).isFalse();
+      channelHandlerCtx = pipeline.context(filterChainMatchingHandler);
+      assertThat(channelHandlerCtx).isNotNull();
+    }
+  }
+
+  @Test
+  public void sourcePortMatch_exactMatchWinsOverEmptyList() throws Exception {
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextEmptySourcePorts =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchEmptySourcePorts =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("10.4.2.0"), 24),
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("10.4.2.2"), 31)),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainEmptySourcePorts =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-foo", filterChainMatchEmptySourcePorts, HTTP_CONNECTION_MANAGER,
+                    tlsContextEmptySourcePorts, tlsContextManager);
+
+    EnvoyServerProtoData.DownstreamTlsContext tlsContextSourcePortMatch =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.FilterChainMatch filterChainMatchSourcePortMatch =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.4.2.2"), 31)),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(7000, 15000),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChainSourcePortMatch =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-bar", filterChainMatchSourcePortMatch, HTTP_CONNECTION_MANAGER,
+                    tlsContextSourcePortMatch, tlsContextManager);
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-baz", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER, null,
+        tlsContextManager);
+
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChainEmptySourcePorts, randomConfig("no-match"),
+                    filterChainSourcePortMatch, noopConfig),
+            defaultFilterChain.sslContextProviderSupplier(), randomConfig("default")));
+
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(filterChainSourcePortMatch.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(tlsContextSourcePortMatch);
+  }
+
+  /**
+   * Create 6 filterChains: - 1st filter chain has dest port & specific prefix range but is
+   * eliminated due to dest port - 5 advance to next step: 1 is eliminated due to being less
+   * specific than the remaining 4. - 4 advance to 3rd step: source type external eliminates one
+   * with local source_type. - 3 advance to 4th step: more specific 2 get picked based on
+   * source-prefix range. - 5th step: out of 2 one with matching source port gets picked
+   */
+  @Test
+  public void filterChain_5stepMatch() throws Exception {
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext1 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext2 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext3 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT3", "VA3");
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext4 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT4", "VA4");
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext5 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT5", "VA5");
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext6 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT6", "VA6");
+
+    // has dest port and specific prefix ranges: gets eliminated in step 1
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch1 =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            PORT,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString(REMOTE_IP), 32)),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChain1 = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-1", filterChainMatch1, HTTP_CONNECTION_MANAGER, tlsContext1,
+            tlsContextManager);
+
+    // next 5 use prefix range: 4 with prefixLen of 30 and last one with 29
+
+    // has single prefix range: and less specific source prefix range: gets eliminated in step 4
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch2 =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.1.2.0"), 30)),
+            ImmutableList.of(),
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.4.0.0"), 16)),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChain2 = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-2", filterChainMatch2, HTTP_CONNECTION_MANAGER, tlsContext2,
+            tlsContextManager);
+
+    // has prefix ranges with one not matching and source type local: gets eliminated in step 3
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch3 =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("192.168.2.0"), 24),
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("10.1.2.0"), 30)),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.SAME_IP_OR_LOOPBACK,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChain3 = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-3", filterChainMatch3, HTTP_CONNECTION_MANAGER, tlsContext3,
+            tlsContextManager);
+
+    // has prefix ranges with both matching and source type external but non matching source port:
+    // gets eliminated in step 5
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch4 =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("10.1.0.0"), 16),
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("10.1.2.0"), 30)),
+            ImmutableList.of(),
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.4.2.0"), 24)),
+            EnvoyServerProtoData.ConnectionSourceType.EXTERNAL,
+            ImmutableList.of(16000, 9000),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChain4 =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-4", filterChainMatch4, HTTP_CONNECTION_MANAGER, tlsContext4,
+                    tlsContextManager);
+
+    // has prefix ranges with both matching and source type external and matching source port: this
+    // gets selected
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch5 =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("10.1.0.0"), 16),
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("10.1.2.0"), 30)),
+            ImmutableList.of(),
+            ImmutableList.of(
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("10.4.2.0"), 24),
+                EnvoyServerProtoData.CidrRange.create(
+                    InetAddresses.forString("192.168.2.0"), 24)),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(15000, 8000),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChain5 =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-5", filterChainMatch5, HTTP_CONNECTION_MANAGER, tlsContext5,
+                    tlsContextManager);
+
+    // has prefix range with prefixLen of 29: gets eliminated in step 2
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch6 =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.1.2.0"), 29)),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            EnvoyServerProtoData.ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChain filterChain6 =
+            EnvoyServerProtoData.FilterChain.create(
+                    "filter-chain-6", filterChainMatch6, HTTP_CONNECTION_MANAGER, tlsContext6,
+                    tlsContextManager);
+
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-7", DEFAULT_FILTER_CHAIN_MATCH, HTTP_CONNECTION_MANAGER, null,
+        tlsContextManager);
+
+    Map<FilterChain, AtomicReference<ServerRoutingConfig>> map = new HashMap<>();
+    map.put(filterChain1, randomConfig("1"));
+    map.put(filterChain2, randomConfig("2"));
+    map.put(filterChain3, randomConfig("3"));
+    map.put(filterChain4, randomConfig("4"));
+    map.put(filterChain5, noopConfig);
+    map.put(filterChain6, randomConfig("6"));
+    selectorManager.updateSelector(new FilterChainSelector(
+            map, defaultFilterChain.sslContextProviderSupplier(), randomConfig("default")));
+
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(filterChain5.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext()).isSameInstanceAs(tlsContext5);
+  }
+
+  @Test
+  public void filterChainMatch_unsupportedMatchers() throws Exception {
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext1 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "ROOTCA");
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext2 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "ROOTCA");
+    EnvoyServerProtoData.DownstreamTlsContext tlsContext3 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT3", "ROOTCA");
+
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch1 =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0 /* destinationPort */,
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.1.0.0"), 16)) /* prefixRange */,
+            ImmutableList.of("managed-mtls", "h2") /* applicationProtocol */,
+            ImmutableList.of() /* sourcePrefixRanges */,
+            EnvoyServerProtoData.ConnectionSourceType.ANY /* sourceType */,
+            ImmutableList.of() /* sourcePorts */,
+            ImmutableList.of("server1", "server2") /* serverNames */,
+            "tls" /* transportProtocol */);
+
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch2 =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0 /* destinationPort */,
+            ImmutableList.of(EnvoyServerProtoData.CidrRange.create(
+                InetAddresses.forString("10.0.0.0"), 8)) /* prefixRange */,
+            ImmutableList.of() /* applicationProtocol */,
+            ImmutableList.of() /* sourcePrefixRanges */,
+            EnvoyServerProtoData.ConnectionSourceType.ANY /* sourceType */,
+            ImmutableList.of() /* sourcePorts */,
+            ImmutableList.of() /* serverNames */,
+            "" /* transportProtocol */);
+
+    EnvoyServerProtoData.FilterChainMatch defaultFilterChainMatch =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0 /* destinationPort */,
+            ImmutableList.of() /* prefixRange */,
+            ImmutableList.of() /* applicationProtocol */,
+            ImmutableList.of() /* sourcePrefixRanges */,
+            EnvoyServerProtoData.ConnectionSourceType.ANY /* sourceType */,
+            ImmutableList.of() /* sourcePorts */,
+            ImmutableList.of() /* serverNames */,
+            "" /* transportProtocol */);
+
+    EnvoyServerProtoData.FilterChain filterChain1 = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-foo", filterChainMatch1, HTTP_CONNECTION_MANAGER, tlsContext1,
+            mock(TlsContextManager.class));
+    EnvoyServerProtoData.FilterChain filterChain2 = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-bar", filterChainMatch2, HTTP_CONNECTION_MANAGER, tlsContext2,
+            mock(TlsContextManager.class));
+
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-baz", defaultFilterChainMatch, HTTP_CONNECTION_MANAGER, tlsContext3,
+            mock(TlsContextManager.class));
+
+    selectorManager.updateSelector(new FilterChainSelector(
+            ImmutableMap.of(filterChain1, randomConfig("1"), filterChain2, randomConfig("2")),
+            defaultFilterChain.sslContextProviderSupplier(), noopConfig));
+
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, selectorManager, mockDelegate);
+    ChannelHandler next = captureAttrHandler(sslSet, routingSettable);
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    setupChannel(LOCAL_IP, REMOTE_IP, 15000, filterChainMatchingHandler);
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    assertThat(sslSet.get()).isEqualTo(defaultFilterChain.sslContextProviderSupplier());
+    assertThat(routingSettable.get()).isEqualTo(noopConfig);
+    assertThat(sslSet.get().getTlsContext().getCommonTlsContext()
+            .getTlsCertificateProviderInstance()
+            .getCertificateName()).isEqualTo("CERT3");
+  }
+
+  private static HttpConnectionManager createRds(String name) {
+    return HttpConnectionManager.forRdsName(0L, name,
+            new ArrayList<NamedFilterConfig>());
+  }
+
+  private static VirtualHost createVirtualHost(String name) {
+    return VirtualHost.create(
+            name, Collections.singletonList("auth"), new ArrayList<Route>(),
+            ImmutableMap.<String, FilterConfig>of());
+  }
+
+  private static AtomicReference<ServerRoutingConfig> randomConfig(String domain) {
+    return new AtomicReference<>(
+        ServerRoutingConfig.create(ImmutableList.of(createVirtualHost(domain)),
+        ImmutableMap.<Route, ServerInterceptor>of())
+    );
+  }
+
+  private EnvoyServerProtoData.DownstreamTlsContext createTls() {
+    return DownstreamTlsContext.fromEnvoyProtoDownstreamTlsContext(
+            io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext
+                    .getDefaultInstance());
+  }
+
+  private void setupChannel(final String localIp, final String remoteIp, final int remotePort,
+                            FilterChainMatchingHandler matchingHandler) {
+    channel =
+        new EmbeddedChannel() {
+          @Override
+          public SocketAddress localAddress() {
+            return new InetSocketAddress(localIp, 80);
+          }
+
+          @Override
+          public SocketAddress remoteAddress() {
+            return new InetSocketAddress(remoteIp, remotePort);
+          }
+        };
+    pipeline = channel.pipeline();
+    pipeline.addLast(matchingHandler);
+  }
+
+  private static ChannelHandler captureAttrHandler(
+          final SettableFuture<SslContextProviderSupplier> sslSet,
+          final SettableFuture<AtomicReference<ServerRoutingConfig>> routingSettable) {
+    return new ChannelInboundHandlerAdapter() {
+      @Override
+      public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
+        ProtocolNegotiationEvent e = (ProtocolNegotiationEvent)evt;
+        sslSet.set(InternalProtocolNegotiationEvent.getAttributes(e)
+                .get(ATTR_SERVER_SSL_CONTEXT_PROVIDER_SUPPLIER));
+        routingSettable.set(InternalProtocolNegotiationEvent.getAttributes(e)
+                .get(ATTR_SERVER_ROUTING_CONFIG));
+      }
+    };
+  }
+
+  private static final class FakeGrpcHttp2ConnectionHandler extends GrpcHttp2ConnectionHandler {
+    FakeGrpcHttp2ConnectionHandler(
+            ChannelPromise channelUnused,
+            Http2ConnectionDecoder decoder,
+            Http2ConnectionEncoder encoder,
+            Http2Settings initialSettings) {
+      super(channelUnused, decoder, encoder, initialSettings, new NoopChannelLogger());
+    }
+
+    static FakeGrpcHttp2ConnectionHandler newHandler() {
+      DefaultHttp2Connection conn = new DefaultHttp2Connection(/*server=*/ false);
+      DefaultHttp2ConnectionEncoder encoder =
+              new DefaultHttp2ConnectionEncoder(conn, new DefaultHttp2FrameWriter());
+      DefaultHttp2ConnectionDecoder decoder =
+              new DefaultHttp2ConnectionDecoder(conn, encoder, new DefaultHttp2FrameReader());
+      Http2Settings settings = new Http2Settings();
+      return new FakeGrpcHttp2ConnectionHandler(
+              /*channelUnused=*/ null, decoder, encoder, settings);
+    }
+
+    @Override
+    public String getAuthority() {
+      return "authority";
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/FilterChainSelectorManagerTest.java b/xds/src/test/java/io/grpc/xds/FilterChainSelectorManagerTest.java
new file mode 100644
index 00000000000..a3a2218d4c3
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/FilterChainSelectorManagerTest.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.ServerInterceptor;
+import io.grpc.xds.EnvoyServerProtoData.FilterChain;
+import io.grpc.xds.FilterChainMatchingProtocolNegotiators.FilterChainMatchingHandler.FilterChainSelector;
+import io.grpc.xds.FilterChainSelectorManager.Closer;
+import io.grpc.xds.XdsServerWrapper.ServerRoutingConfig;
+import java.util.Collections;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public final class FilterChainSelectorManagerTest {
+  private FilterChainSelectorManager manager = new FilterChainSelectorManager();
+  private AtomicReference<ServerRoutingConfig> noopConfig = new AtomicReference<>(
+      ServerRoutingConfig.create(ImmutableList.<VirtualHost>of(),
+      ImmutableMap.<VirtualHost.Route, ServerInterceptor>of()));
+  private FilterChainSelector selector1 = new FilterChainSelector(
+            Collections.<FilterChain,AtomicReference<ServerRoutingConfig>>emptyMap(),
+      null, new AtomicReference<ServerRoutingConfig>());
+  private FilterChainSelector selector2 = new FilterChainSelector(
+            Collections.<FilterChain,AtomicReference<ServerRoutingConfig>>emptyMap(),
+      null, noopConfig);
+  private CounterRunnable runnable1 = new CounterRunnable();
+  private CounterRunnable runnable2 = new CounterRunnable();
+
+  @Test
+  public void updateSelector_changesSelector() {
+    assertThat(manager.getSelectorToUpdateSelector()).isNull();
+    assertThat(manager.register(new Closer(runnable1))).isNull();
+
+    manager.updateSelector(selector1);
+
+    assertThat(runnable1.counter).isEqualTo(1);
+    assertThat(manager.getSelectorToUpdateSelector()).isSameInstanceAs(selector1);
+    assertThat(manager.register(new Closer(runnable2))).isSameInstanceAs(selector1);
+    assertThat(runnable2.counter).isEqualTo(0);
+  }
+
+  @Test
+  public void updateSelector_callsCloserOnce() {
+    assertThat(manager.register(new Closer(runnable1))).isNull();
+
+    manager.updateSelector(selector1);
+    manager.updateSelector(selector2);
+
+    assertThat(runnable1.counter).isEqualTo(1);
+  }
+
+  @Test
+  public void deregister_removesCloser() {
+    Closer closer1 = new Closer(runnable1);
+    manager.updateSelector(selector1);
+    assertThat(manager.register(closer1)).isSameInstanceAs(selector1);
+    assertThat(manager.getRegisterCount()).isEqualTo(1);
+
+    manager.deregister(closer1);
+
+    assertThat(manager.getRegisterCount()).isEqualTo(0);
+    manager.updateSelector(selector2);
+    assertThat(runnable1.counter).isEqualTo(0);
+  }
+
+  @Test
+  public void deregister_removesCorrectCloser() {
+    Closer closer1 = new Closer(runnable1);
+    Closer closer2 = new Closer(runnable2);
+    manager.updateSelector(selector1);
+    assertThat(manager.register(closer1)).isSameInstanceAs(selector1);
+    assertThat(manager.register(closer2)).isSameInstanceAs(selector1);
+    assertThat(manager.getRegisterCount()).isEqualTo(2);
+
+    manager.deregister(closer1);
+
+    assertThat(manager.getRegisterCount()).isEqualTo(1);
+    manager.updateSelector(selector2);
+    assertThat(runnable1.counter).isEqualTo(0);
+    assertThat(runnable2.counter).isEqualTo(1);
+  }
+
+  private static class CounterRunnable implements Runnable {
+    int counter;
+
+    @Override public void run() {
+      counter++;
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/GcpAuthenticationFilterTest.java b/xds/src/test/java/io/grpc/xds/GcpAuthenticationFilterTest.java
new file mode 100644
index 00000000000..f252c6f4ec1
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/GcpAuthenticationFilterTest.java
@@ -0,0 +1,524 @@
+/*
+ * Copyright 2024 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.XdsNameResolver.CLUSTER_SELECTION_KEY;
+import static io.grpc.xds.XdsNameResolver.XDS_CONFIG_CALL_OPTION_KEY;
+import static io.grpc.xds.XdsTestUtils.CLUSTER_NAME;
+import static io.grpc.xds.XdsTestUtils.EDS_NAME;
+import static io.grpc.xds.XdsTestUtils.ENDPOINT_HOSTNAME;
+import static io.grpc.xds.XdsTestUtils.ENDPOINT_PORT;
+import static io.grpc.xds.XdsTestUtils.RDS_NAME;
+import static io.grpc.xds.XdsTestUtils.buildRouteConfiguration;
+import static io.grpc.xds.XdsTestUtils.getWrrLbConfigAsMap;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Any;
+import com.google.protobuf.Empty;
+import com.google.protobuf.Message;
+import com.google.protobuf.UInt64Value;
+import io.envoyproxy.envoy.config.route.v3.RouteConfiguration;
+import io.envoyproxy.envoy.extensions.filters.http.gcp_authn.v3.GcpAuthnFilterConfig;
+import io.envoyproxy.envoy.extensions.filters.http.gcp_authn.v3.TokenCacheConfig;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.MethodDescriptor;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.testing.TestMethodDescriptors;
+import io.grpc.xds.Endpoints.LbEndpoint;
+import io.grpc.xds.Endpoints.LocalityLbEndpoints;
+import io.grpc.xds.GcpAuthenticationFilter.AudienceMetadataParser.AudienceWrapper;
+import io.grpc.xds.GcpAuthenticationFilter.FailingClientCall;
+import io.grpc.xds.GcpAuthenticationFilter.GcpAuthenticationConfig;
+import io.grpc.xds.XdsClusterResource.CdsUpdate;
+import io.grpc.xds.XdsConfig.XdsClusterConfig;
+import io.grpc.xds.XdsConfig.XdsClusterConfig.EndpointConfig;
+import io.grpc.xds.XdsEndpointResource.EdsUpdate;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.XdsRouteConfigureResource.RdsUpdate;
+import io.grpc.xds.client.Locality;
+import io.grpc.xds.client.XdsResourceType;
+import io.grpc.xds.client.XdsResourceType.ResourceInvalidException;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+@RunWith(JUnit4.class)
+public class GcpAuthenticationFilterTest {
+  private static final GcpAuthenticationFilter.Provider FILTER_PROVIDER =
+      new GcpAuthenticationFilter.Provider();
+  private static final LdsUpdate ldsUpdate = getLdsUpdate();
+  private static final EdsUpdate edsUpdate = getEdsUpdate();
+  private static final RdsUpdate rdsUpdate = getRdsUpdate();
+  private static final CdsUpdate cdsUpdate = getCdsUpdate();
+
+  @Before
+  public void setUp() {
+    System.setProperty("GRPC_EXPERIMENTAL_XDS_GCP_AUTHENTICATION_FILTER", "true");
+  }
+
+  @Test
+  public void testNewFilterInstancesPerFilterName() {
+    assertThat(new GcpAuthenticationFilter("FILTER_INSTANCE_NAME1", 10))
+        .isNotEqualTo(new GcpAuthenticationFilter("FILTER_INSTANCE_NAME1", 10));
+  }
+
+  @Test
+  public void filterType_clientOnly() {
+    assertThat(FILTER_PROVIDER.isClientFilter()).isTrue();
+    assertThat(FILTER_PROVIDER.isServerFilter()).isFalse();
+  }
+
+  @Test
+  public void testParseFilterConfig_withValidConfig() {
+    GcpAuthnFilterConfig config = GcpAuthnFilterConfig.newBuilder()
+        .setCacheConfig(TokenCacheConfig.newBuilder().setCacheSize(UInt64Value.of(20)))
+        .build();
+    Any anyMessage = Any.pack(config);
+
+    ConfigOrError<GcpAuthenticationConfig> result = FILTER_PROVIDER.parseFilterConfig(anyMessage);
+
+    assertNotNull(result.config);
+    assertNull(result.errorDetail);
+    assertEquals(20L, result.config.getCacheSize());
+  }
+
+  @Test
+  public void testParseFilterConfig_withZeroCacheSize() {
+    GcpAuthnFilterConfig config = GcpAuthnFilterConfig.newBuilder()
+        .setCacheConfig(TokenCacheConfig.newBuilder().setCacheSize(UInt64Value.of(0)))
+        .build();
+    Any anyMessage = Any.pack(config);
+
+    ConfigOrError<GcpAuthenticationConfig> result = FILTER_PROVIDER.parseFilterConfig(anyMessage);
+
+    assertNull(result.config);
+    assertNotNull(result.errorDetail);
+    assertTrue(result.errorDetail.contains("cache_config.cache_size must be greater than zero"));
+  }
+
+  @Test
+  public void testParseFilterConfig_withInvalidMessageType() {
+    Message invalidMessage = Empty.getDefaultInstance();
+    ConfigOrError<GcpAuthenticationConfig> result =
+        FILTER_PROVIDER.parseFilterConfig(invalidMessage);
+
+    assertNull(result.config);
+    assertThat(result.errorDetail).contains("Invalid config type");
+  }
+
+  @Test
+  public void testClientInterceptor_success() throws IOException, ResourceInvalidException {
+    XdsConfig.XdsClusterConfig clusterConfig = new XdsConfig.XdsClusterConfig(
+        CLUSTER_NAME,
+        cdsUpdate,
+        new EndpointConfig(StatusOr.fromValue(edsUpdate)));
+    XdsConfig defaultXdsConfig = new XdsConfig.XdsConfigBuilder()
+        .setListener(ldsUpdate)
+        .setRoute(rdsUpdate)
+        .setVirtualHost(rdsUpdate.virtualHosts.get(0))
+        .addCluster(CLUSTER_NAME, StatusOr.fromValue(clusterConfig)).build();
+    CallOptions callOptionsWithXds = CallOptions.DEFAULT
+        .withOption(CLUSTER_SELECTION_KEY, "cluster:cluster0")
+        .withOption(XDS_CONFIG_CALL_OPTION_KEY, defaultXdsConfig);
+    GcpAuthenticationConfig config = new GcpAuthenticationConfig(10);
+    GcpAuthenticationFilter filter = new GcpAuthenticationFilter("FILTER_INSTANCE_NAME", 10);
+    ClientInterceptor interceptor = filter.buildClientInterceptor(config, null, null);
+    MethodDescriptor<Void, Void> methodDescriptor = TestMethodDescriptors.voidMethod();
+    Channel mockChannel = Mockito.mock(Channel.class);
+    ArgumentCaptor<CallOptions> callOptionsCaptor = ArgumentCaptor.forClass(CallOptions.class);
+
+    interceptor.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel);
+
+    verify(mockChannel).newCall(eq(methodDescriptor), callOptionsCaptor.capture());
+    CallOptions capturedOptions = callOptionsCaptor.getAllValues().get(0);
+    assertNotNull(capturedOptions.getCredentials());
+  }
+
+  @Test
+  public void testClientInterceptor_createsAndReusesCachedCredentials()
+      throws IOException, ResourceInvalidException {
+    XdsConfig.XdsClusterConfig clusterConfig = new XdsConfig.XdsClusterConfig(
+        CLUSTER_NAME,
+        cdsUpdate,
+        new EndpointConfig(StatusOr.fromValue(edsUpdate)));
+    XdsConfig defaultXdsConfig = new XdsConfig.XdsConfigBuilder()
+        .setListener(ldsUpdate)
+        .setRoute(rdsUpdate)
+        .setVirtualHost(rdsUpdate.virtualHosts.get(0))
+        .addCluster(CLUSTER_NAME, StatusOr.fromValue(clusterConfig)).build();
+    CallOptions callOptionsWithXds = CallOptions.DEFAULT
+        .withOption(CLUSTER_SELECTION_KEY, "cluster:cluster0")
+        .withOption(XDS_CONFIG_CALL_OPTION_KEY, defaultXdsConfig);
+    GcpAuthenticationConfig config = new GcpAuthenticationConfig(10);
+    GcpAuthenticationFilter filter = new GcpAuthenticationFilter("FILTER_INSTANCE_NAME", 10);
+    ClientInterceptor interceptor = filter.buildClientInterceptor(config, null, null);
+    MethodDescriptor<Void, Void> methodDescriptor = TestMethodDescriptors.voidMethod();
+    Channel mockChannel = Mockito.mock(Channel.class);
+    ArgumentCaptor<CallOptions> callOptionsCaptor = ArgumentCaptor.forClass(CallOptions.class);
+
+    interceptor.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel);
+    interceptor.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel);
+
+    verify(mockChannel, times(2))
+        .newCall(eq(methodDescriptor), callOptionsCaptor.capture());
+    CallOptions firstCapturedOptions = callOptionsCaptor.getAllValues().get(0);
+    CallOptions secondCapturedOptions = callOptionsCaptor.getAllValues().get(1);
+    assertNotNull(firstCapturedOptions.getCredentials());
+    assertNotNull(secondCapturedOptions.getCredentials());
+    assertSame(firstCapturedOptions.getCredentials(), secondCapturedOptions.getCredentials());
+  }
+
+  @Test
+  public void testClientInterceptor_withoutClusterSelectionKey() throws Exception {
+    GcpAuthenticationConfig config = new GcpAuthenticationConfig(10);
+    GcpAuthenticationFilter filter = new GcpAuthenticationFilter("FILTER_INSTANCE_NAME", 10);
+    ClientInterceptor interceptor = filter.buildClientInterceptor(config, null, null);
+    MethodDescriptor<Void, Void> methodDescriptor = TestMethodDescriptors.voidMethod();
+    Channel mockChannel = mock(Channel.class);
+    CallOptions callOptionsWithXds = CallOptions.DEFAULT;
+
+    ClientCall<Void, Void> call = interceptor.interceptCall(
+        methodDescriptor, callOptionsWithXds, mockChannel);
+
+    assertTrue(call instanceof FailingClientCall);
+    FailingClientCall<Void, Void> clientCall = (FailingClientCall<Void, Void>) call;
+    assertThat(clientCall.error.getDescription()).contains("does not contain cluster resource");
+  }
+
+  @Test
+  public void testClientInterceptor_clusterSelectionKeyWithoutPrefix() throws Exception {
+    XdsConfig.XdsClusterConfig clusterConfig = new XdsConfig.XdsClusterConfig(
+        CLUSTER_NAME,
+        cdsUpdate,
+        new EndpointConfig(StatusOr.fromValue(edsUpdate)));
+    XdsConfig defaultXdsConfig = new XdsConfig.XdsConfigBuilder()
+        .setListener(ldsUpdate)
+        .setRoute(rdsUpdate)
+        .setVirtualHost(rdsUpdate.virtualHosts.get(0))
+        .addCluster(CLUSTER_NAME, StatusOr.fromValue(clusterConfig)).build();
+    CallOptions callOptionsWithXds = CallOptions.DEFAULT
+        .withOption(CLUSTER_SELECTION_KEY, "cluster0")
+        .withOption(XDS_CONFIG_CALL_OPTION_KEY, defaultXdsConfig);
+    Channel mockChannel = mock(Channel.class);
+
+    GcpAuthenticationConfig config = new GcpAuthenticationConfig(10);
+    GcpAuthenticationFilter filter = new GcpAuthenticationFilter("FILTER_INSTANCE_NAME", 10);
+    ClientInterceptor interceptor = filter.buildClientInterceptor(config, null, null);
+    MethodDescriptor<Void, Void> methodDescriptor = TestMethodDescriptors.voidMethod();
+    interceptor.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel);
+
+    verify(mockChannel).newCall(methodDescriptor, callOptionsWithXds);
+  }
+
+  @Test
+  public void testClientInterceptor_xdsConfigDoesNotExist() throws Exception {
+    GcpAuthenticationConfig config = new GcpAuthenticationConfig(10);
+    GcpAuthenticationFilter filter = new GcpAuthenticationFilter("FILTER_INSTANCE_NAME", 10);
+    ClientInterceptor interceptor = filter.buildClientInterceptor(config, null, null);
+    MethodDescriptor<Void, Void> methodDescriptor = TestMethodDescriptors.voidMethod();
+    Channel mockChannel = mock(Channel.class);
+    CallOptions callOptionsWithXds = CallOptions.DEFAULT
+        .withOption(CLUSTER_SELECTION_KEY, "cluster:cluster0");
+
+    ClientCall<Void, Void> call =
+        interceptor.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel);
+
+    assertTrue(call instanceof FailingClientCall);
+    FailingClientCall<Void, Void> clientCall = (FailingClientCall<Void, Void>) call;
+    assertThat(clientCall.error.getDescription()).contains("does not contain xds configuration");
+  }
+
+  @Test
+  public void testClientInterceptor_incorrectClusterName() throws Exception {
+    XdsConfig.XdsClusterConfig clusterConfig = new XdsConfig.XdsClusterConfig(
+        CLUSTER_NAME,
+        cdsUpdate,
+        new EndpointConfig(StatusOr.fromValue(edsUpdate)));
+    XdsConfig defaultXdsConfig = new XdsConfig.XdsConfigBuilder()
+        .setListener(ldsUpdate)
+        .setRoute(rdsUpdate)
+        .setVirtualHost(rdsUpdate.virtualHosts.get(0))
+        .addCluster("custer0", StatusOr.fromValue(clusterConfig)).build();
+    CallOptions callOptionsWithXds = CallOptions.DEFAULT
+        .withOption(CLUSTER_SELECTION_KEY, "cluster:cluster")
+        .withOption(XDS_CONFIG_CALL_OPTION_KEY, defaultXdsConfig);
+    GcpAuthenticationConfig config = new GcpAuthenticationConfig(10);
+    GcpAuthenticationFilter filter = new GcpAuthenticationFilter("FILTER_INSTANCE_NAME", 10);
+    ClientInterceptor interceptor = filter.buildClientInterceptor(config, null, null);
+    MethodDescriptor<Void, Void> methodDescriptor = TestMethodDescriptors.voidMethod();
+    Channel mockChannel = mock(Channel.class);
+
+    ClientCall<Void, Void> call =
+        interceptor.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel);
+
+    assertTrue(call instanceof FailingClientCall);
+    FailingClientCall<Void, Void> clientCall = (FailingClientCall<Void, Void>) call;
+    assertThat(clientCall.error.getDescription()).contains("does not contain xds cluster");
+  }
+
+  @Test
+  public void testClientInterceptor_statusOrError() throws Exception {
+    StatusOr<XdsClusterConfig> errorCluster =
+        StatusOr.fromStatus(Status.NOT_FOUND.withDescription("Cluster resource not found"));
+    XdsConfig defaultXdsConfig = new XdsConfig.XdsConfigBuilder()
+        .setListener(ldsUpdate)
+        .setRoute(rdsUpdate)
+        .setVirtualHost(rdsUpdate.virtualHosts.get(0))
+        .addCluster(CLUSTER_NAME, errorCluster).build();
+    CallOptions callOptionsWithXds = CallOptions.DEFAULT
+        .withOption(CLUSTER_SELECTION_KEY, "cluster:cluster0")
+        .withOption(XDS_CONFIG_CALL_OPTION_KEY, defaultXdsConfig);
+    GcpAuthenticationConfig config = new GcpAuthenticationConfig(10);
+    GcpAuthenticationFilter filter = new GcpAuthenticationFilter("FILTER_INSTANCE_NAME", 10);
+    ClientInterceptor interceptor = filter.buildClientInterceptor(config, null, null);
+    MethodDescriptor<Void, Void> methodDescriptor = TestMethodDescriptors.voidMethod();
+    Channel mockChannel = mock(Channel.class);
+
+    ClientCall<Void, Void> call =
+        interceptor.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel);
+
+    assertTrue(call instanceof FailingClientCall);
+    FailingClientCall<Void, Void> clientCall = (FailingClientCall<Void, Void>) call;
+    assertThat(clientCall.error.getDescription()).contains("Cluster resource not found");
+  }
+
+  @Test
+  public void testClientInterceptor_notAudienceWrapper()
+      throws IOException, ResourceInvalidException {
+    XdsConfig.XdsClusterConfig clusterConfig = new XdsConfig.XdsClusterConfig(
+        CLUSTER_NAME,
+        getCdsUpdateWithIncorrectAudienceWrapper(),
+        new EndpointConfig(StatusOr.fromValue(edsUpdate)));
+    XdsConfig defaultXdsConfig = new XdsConfig.XdsConfigBuilder()
+        .setListener(ldsUpdate)
+        .setRoute(rdsUpdate)
+        .setVirtualHost(rdsUpdate.virtualHosts.get(0))
+        .addCluster(CLUSTER_NAME, StatusOr.fromValue(clusterConfig)).build();
+    CallOptions callOptionsWithXds = CallOptions.DEFAULT
+        .withOption(CLUSTER_SELECTION_KEY, "cluster:cluster0")
+        .withOption(XDS_CONFIG_CALL_OPTION_KEY, defaultXdsConfig);
+    GcpAuthenticationConfig config = new GcpAuthenticationConfig(10);
+    GcpAuthenticationFilter filter = new GcpAuthenticationFilter("FILTER_INSTANCE_NAME", 10);
+    ClientInterceptor interceptor = filter.buildClientInterceptor(config, null, null);
+    MethodDescriptor<Void, Void> methodDescriptor = TestMethodDescriptors.voidMethod();
+    Channel mockChannel = Mockito.mock(Channel.class);
+
+    ClientCall<Void, Void> call =
+        interceptor.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel);
+
+    assertTrue(call instanceof FailingClientCall);
+    FailingClientCall<Void, Void> clientCall = (FailingClientCall<Void, Void>) call;
+    assertThat(clientCall.error.getDescription()).contains("GCP Authn found wrong type");
+  }
+
+  @Test
+  public void testLruCacheAcrossInterceptors() throws IOException, ResourceInvalidException {
+    XdsConfig.XdsClusterConfig clusterConfig = new XdsConfig.XdsClusterConfig(
+        CLUSTER_NAME, cdsUpdate, new EndpointConfig(StatusOr.fromValue(edsUpdate)));
+    XdsConfig defaultXdsConfig = new XdsConfig.XdsConfigBuilder()
+        .setListener(ldsUpdate)
+        .setRoute(rdsUpdate)
+        .setVirtualHost(rdsUpdate.virtualHosts.get(0))
+        .addCluster(CLUSTER_NAME, StatusOr.fromValue(clusterConfig)).build();
+    CallOptions callOptionsWithXds = CallOptions.DEFAULT
+        .withOption(CLUSTER_SELECTION_KEY, "cluster:cluster0")
+        .withOption(XDS_CONFIG_CALL_OPTION_KEY, defaultXdsConfig);
+    GcpAuthenticationFilter filter = new GcpAuthenticationFilter("FILTER_INSTANCE_NAME", 2);
+    ClientInterceptor interceptor1
+        = filter.buildClientInterceptor(new GcpAuthenticationConfig(2), null, null);
+    MethodDescriptor<Void, Void> methodDescriptor = TestMethodDescriptors.voidMethod();
+    Channel mockChannel = Mockito.mock(Channel.class);
+    ArgumentCaptor<CallOptions> callOptionsCaptor = ArgumentCaptor.forClass(CallOptions.class);
+
+    interceptor1.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel);
+    verify(mockChannel).newCall(eq(methodDescriptor), callOptionsCaptor.capture());
+    CallOptions capturedOptions1 = callOptionsCaptor.getAllValues().get(0);
+    assertNotNull(capturedOptions1.getCredentials());
+    ClientInterceptor interceptor2
+        = filter.buildClientInterceptor(new GcpAuthenticationConfig(1), null, null);
+    interceptor2.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel);
+    verify(mockChannel, times(2))
+        .newCall(eq(methodDescriptor), callOptionsCaptor.capture());
+    CallOptions capturedOptions2 = callOptionsCaptor.getAllValues().get(1);
+    assertNotNull(capturedOptions2.getCredentials());
+
+    assertSame(capturedOptions1.getCredentials(), capturedOptions2.getCredentials());
+  }
+
+  @Test
+  public void testLruCacheEvictionOnResize() throws IOException, ResourceInvalidException {
+    XdsConfig.XdsClusterConfig clusterConfig = new XdsConfig.XdsClusterConfig(
+        CLUSTER_NAME, cdsUpdate, new EndpointConfig(StatusOr.fromValue(edsUpdate)));
+    XdsConfig defaultXdsConfig = new XdsConfig.XdsConfigBuilder()
+        .setListener(ldsUpdate)
+        .setRoute(rdsUpdate)
+        .setVirtualHost(rdsUpdate.virtualHosts.get(0))
+        .addCluster(CLUSTER_NAME, StatusOr.fromValue(clusterConfig)).build();
+    CallOptions callOptionsWithXds = CallOptions.DEFAULT
+        .withOption(CLUSTER_SELECTION_KEY, "cluster:cluster0")
+        .withOption(XDS_CONFIG_CALL_OPTION_KEY, defaultXdsConfig);
+    GcpAuthenticationFilter filter = new GcpAuthenticationFilter("FILTER_INSTANCE_NAME", 2);
+    MethodDescriptor<Void, Void> methodDescriptor = TestMethodDescriptors.voidMethod();
+
+    ClientInterceptor interceptor1 =
+        filter.buildClientInterceptor(new GcpAuthenticationConfig(2), null, null);
+    Channel mockChannel1 = Mockito.mock(Channel.class);
+    ArgumentCaptor<CallOptions> captor = ArgumentCaptor.forClass(CallOptions.class);
+    interceptor1.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel1);
+    verify(mockChannel1).newCall(eq(methodDescriptor), captor.capture());
+    CallOptions options1 = captor.getValue();
+    // This will recreate the cache with max size of 1 and copy the credential for audience1.
+    ClientInterceptor interceptor2 =
+        filter.buildClientInterceptor(new GcpAuthenticationConfig(1), null, null);
+    Channel mockChannel2 = Mockito.mock(Channel.class);
+    interceptor2.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel2);
+    verify(mockChannel2).newCall(eq(methodDescriptor), captor.capture());
+    CallOptions options2 = captor.getValue();
+
+    assertSame(options1.getCredentials(), options2.getCredentials());
+
+    clusterConfig = new XdsConfig.XdsClusterConfig(
+        CLUSTER_NAME, getCdsUpdate2(), new EndpointConfig(StatusOr.fromValue(edsUpdate)));
+    defaultXdsConfig = new XdsConfig.XdsConfigBuilder()
+        .setListener(ldsUpdate)
+        .setRoute(rdsUpdate)
+        .setVirtualHost(rdsUpdate.virtualHosts.get(0))
+        .addCluster(CLUSTER_NAME, StatusOr.fromValue(clusterConfig)).build();
+    callOptionsWithXds = CallOptions.DEFAULT
+        .withOption(CLUSTER_SELECTION_KEY, "cluster:cluster0")
+        .withOption(XDS_CONFIG_CALL_OPTION_KEY, defaultXdsConfig);
+
+    // This will evict the credential for audience1 and add new credential for audience2
+    ClientInterceptor interceptor3 =
+        filter.buildClientInterceptor(new GcpAuthenticationConfig(1), null, null);
+    Channel mockChannel3 = Mockito.mock(Channel.class);
+    interceptor3.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel3);
+    verify(mockChannel3).newCall(eq(methodDescriptor), captor.capture());
+    CallOptions options3 = captor.getValue();
+
+    assertNotSame(options1.getCredentials(), options3.getCredentials());
+
+    clusterConfig = new XdsConfig.XdsClusterConfig(
+        CLUSTER_NAME, cdsUpdate, new EndpointConfig(StatusOr.fromValue(edsUpdate)));
+    defaultXdsConfig = new XdsConfig.XdsConfigBuilder()
+        .setListener(ldsUpdate)
+        .setRoute(rdsUpdate)
+        .setVirtualHost(rdsUpdate.virtualHosts.get(0))
+        .addCluster(CLUSTER_NAME, StatusOr.fromValue(clusterConfig)).build();
+    callOptionsWithXds = CallOptions.DEFAULT
+        .withOption(CLUSTER_SELECTION_KEY, "cluster:cluster0")
+        .withOption(XDS_CONFIG_CALL_OPTION_KEY, defaultXdsConfig);
+
+    // This will create new credential for audience1 because it has been evicted
+    ClientInterceptor interceptor4 =
+        filter.buildClientInterceptor(new GcpAuthenticationConfig(1), null, null);
+    Channel mockChannel4 = Mockito.mock(Channel.class);
+    interceptor4.interceptCall(methodDescriptor, callOptionsWithXds, mockChannel4);
+    verify(mockChannel4).newCall(eq(methodDescriptor), captor.capture());
+    CallOptions options4 = captor.getValue();
+
+    assertNotSame(options1.getCredentials(), options4.getCredentials());
+  }
+
+  private static LdsUpdate getLdsUpdate() {
+    Filter.NamedFilterConfig routerFilterConfig = new Filter.NamedFilterConfig(
+        "router", RouterFilter.ROUTER_CONFIG);
+    HttpConnectionManager httpConnectionManager = HttpConnectionManager.forRdsName(
+        0L, RDS_NAME, Collections.singletonList(routerFilterConfig));
+    return XdsListenerResource.LdsUpdate.forApiListener(httpConnectionManager);
+  }
+
+  private static RdsUpdate getRdsUpdate() {
+    RouteConfiguration routeConfiguration =
+        buildRouteConfiguration("my-server", RDS_NAME, CLUSTER_NAME);
+    XdsResourceType.Args args = new XdsResourceType.Args(
+        XdsTestUtils.EMPTY_BOOTSTRAPPER_SERVER_INFO, "0", "0", null, null, null);
+    try {
+      return XdsRouteConfigureResource.getInstance().doParse(args, routeConfiguration);
+    } catch (ResourceInvalidException ex) {
+      return null;
+    }
+  }
+
+  private static EdsUpdate getEdsUpdate() {
+    Map<Locality, LocalityLbEndpoints> lbEndpointsMap = new HashMap<>();
+    LbEndpoint lbEndpoint = LbEndpoint.create(
+        "127.0.0.5", ENDPOINT_PORT, 0, true, ENDPOINT_HOSTNAME, ImmutableMap.of());
+    lbEndpointsMap.put(
+        Locality.create("", "", ""),
+        LocalityLbEndpoints.create(ImmutableList.of(lbEndpoint), 10, 0, ImmutableMap.of()));
+    return new XdsEndpointResource.EdsUpdate(EDS_NAME, lbEndpointsMap, Collections.emptyList());
+  }
+
+  private static CdsUpdate getCdsUpdate() {
+    ImmutableMap.Builder<String, Object> parsedMetadata = ImmutableMap.builder();
+    parsedMetadata.put("FILTER_INSTANCE_NAME", new AudienceWrapper("TEST_AUDIENCE"));
+    try {
+      CdsUpdate.Builder cdsUpdate = CdsUpdate.forEds(
+              CLUSTER_NAME, EDS_NAME, null, null, null, null, false, null)
+          .lbPolicyConfig(getWrrLbConfigAsMap());
+      return cdsUpdate.parsedMetadata(parsedMetadata.build()).build();
+    } catch (IOException ex) {
+      return null;
+    }
+  }
+
+  private static CdsUpdate getCdsUpdate2() {
+    ImmutableMap.Builder<String, Object> parsedMetadata = ImmutableMap.builder();
+    parsedMetadata.put("FILTER_INSTANCE_NAME", new AudienceWrapper("NEW_TEST_AUDIENCE"));
+    try {
+      CdsUpdate.Builder cdsUpdate = CdsUpdate.forEds(
+              CLUSTER_NAME, EDS_NAME, null, null, null, null, false, null)
+          .lbPolicyConfig(getWrrLbConfigAsMap());
+      return cdsUpdate.parsedMetadata(parsedMetadata.build()).build();
+    } catch (IOException ex) {
+      return null;
+    }
+  }
+
+  private static CdsUpdate getCdsUpdateWithIncorrectAudienceWrapper() throws IOException {
+    ImmutableMap.Builder<String, Object> parsedMetadata = ImmutableMap.builder();
+    parsedMetadata.put("FILTER_INSTANCE_NAME", "TEST_AUDIENCE");
+    CdsUpdate.Builder cdsUpdate = CdsUpdate.forEds(
+            CLUSTER_NAME, EDS_NAME, null, null, null, null, false, null)
+        .lbPolicyConfig(getWrrLbConfigAsMap());
+    return cdsUpdate.parsedMetadata(parsedMetadata.build()).build();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/GrpcBootstrapperImplTest.java b/xds/src/test/java/io/grpc/xds/GrpcBootstrapperImplTest.java
new file mode 100644
index 00000000000..0a303b7255d
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/GrpcBootstrapperImplTest.java
@@ -0,0 +1,1006 @@
+/*
+ * Copyright 2019 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyNoInteractions;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.GrpcUtil.GrpcBuildVersion;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.Bootstrapper.AuthorityInfo;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.BootstrapperImpl;
+import io.grpc.xds.client.CommonBootstrapperTestUtils;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+import io.grpc.xds.client.Locality;
+import io.grpc.xds.client.XdsInitializationException;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link Bootstrapper}. */
+@RunWith(JUnit4.class)
+public class GrpcBootstrapperImplTest {
+
+  private static final String BOOTSTRAP_FILE_PATH = "/fake/fs/path/bootstrap.json";
+  private static final String SERVER_URI = "trafficdirector.googleapis.com:443";
+
+  private final GrpcBootstrapperImpl bootstrapper = new GrpcBootstrapperImpl();
+  private String originalBootstrapPathFromEnvVar;
+  private String originalBootstrapPathFromSysProp;
+  private String originalBootstrapConfigFromEnvVar;
+  private String originalBootstrapConfigFromSysProp;
+  private boolean originalExperimentalXdsFallbackFlag;
+
+  @Before
+  public void setUp() {
+    saveEnvironment();
+    originalExperimentalXdsFallbackFlag = CommonBootstrapperTestUtils.setEnableXdsFallback(true);
+    bootstrapper.bootstrapPathFromEnvVar = BOOTSTRAP_FILE_PATH;
+  }
+
+  private void saveEnvironment() {
+    originalBootstrapPathFromEnvVar = bootstrapper.bootstrapPathFromEnvVar;
+    originalBootstrapPathFromSysProp = bootstrapper.bootstrapPathFromSysProp;
+    originalBootstrapConfigFromEnvVar = bootstrapper.bootstrapConfigFromEnvVar;
+    originalBootstrapConfigFromSysProp = bootstrapper.bootstrapConfigFromSysProp;
+  }
+
+  @After
+  public void restoreEnvironment() {
+    bootstrapper.bootstrapPathFromEnvVar = originalBootstrapPathFromEnvVar;
+    bootstrapper.bootstrapPathFromSysProp = originalBootstrapPathFromSysProp;
+    bootstrapper.bootstrapConfigFromEnvVar = originalBootstrapConfigFromEnvVar;
+    bootstrapper.bootstrapConfigFromSysProp = originalBootstrapConfigFromSysProp;
+    CommonBootstrapperTestUtils.setEnableXdsFallback(originalExperimentalXdsFallbackFlag);
+  }
+
+  @Test
+  public void parseBootstrap_emptyServers_throws() {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    XdsInitializationException e = Assert.assertThrows(XdsInitializationException.class,
+        bootstrapper::bootstrap);
+    assertThat(e).hasMessageThat().isEqualTo("Invalid bootstrap: 'xds_servers' is empty");
+  }
+
+  @Test
+  public void parseBootstrap_singleXdsServer() throws XdsInitializationException {
+    String rawData = "{\n"
+        + "  \"node\": {\n"
+        + "    \"id\": \"ENVOY_NODE_ID\",\n"
+        + "    \"cluster\": \"ENVOY_CLUSTER\",\n"
+        + "    \"locality\": {\n"
+        + "      \"region\": \"ENVOY_REGION\",\n"
+        + "      \"zone\": \"ENVOY_ZONE\",\n"
+        + "      \"sub_zone\": \"ENVOY_SUBZONE\"\n"
+        + "    },\n"
+        + "    \"metadata\": {\n"
+        + "      \"TRAFFICDIRECTOR_INTERCEPTION_PORT\": \"ENVOY_PORT\",\n"
+        + "      \"TRAFFICDIRECTOR_NETWORK_NAME\": \"VPC_NETWORK_NAME\"\n"
+        + "    }\n"
+        + "  },\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    assertThat(info.servers()).hasSize(1);
+    ServerInfo serverInfo = Iterables.getOnlyElement(info.servers());
+    assertThat(serverInfo.target()).isEqualTo(SERVER_URI);
+    assertThat(serverInfo.implSpecificConfig()).isInstanceOf(InsecureChannelCredentials.class);
+    assertThat(info.node()).isEqualTo(
+        getNodeBuilder()
+            .setId("ENVOY_NODE_ID")
+            .setCluster("ENVOY_CLUSTER")
+            .setLocality(Locality.create("ENVOY_REGION", "ENVOY_ZONE", "ENVOY_SUBZONE"))
+            .setMetadata(
+                ImmutableMap.of(
+                    "TRAFFICDIRECTOR_INTERCEPTION_PORT",
+                    "ENVOY_PORT",
+                    "TRAFFICDIRECTOR_NETWORK_NAME",
+                    "VPC_NETWORK_NAME"))
+            .build());
+  }
+
+  @Test
+  public void parseBootstrap_multipleXdsServers() throws XdsInitializationException {
+    String rawData = "{\n"
+        + "  \"node\": {\n"
+        + "    \"id\": \"ENVOY_NODE_ID\",\n"
+        + "    \"cluster\": \"ENVOY_CLUSTER\",\n"
+        + "    \"locality\": {\n"
+        + "      \"region\": \"ENVOY_REGION\",\n"
+        + "      \"zone\": \"ENVOY_ZONE\",\n"
+        + "      \"sub_zone\": \"ENVOY_SUBZONE\"\n"
+        + "    },\n"
+        + "    \"metadata\": {\n"
+        + "      \"TRAFFICDIRECTOR_INTERCEPTION_PORT\": \"ENVOY_PORT\",\n"
+        + "      \"TRAFFICDIRECTOR_NETWORK_NAME\": \"VPC_NETWORK_NAME\"\n"
+        + "    }\n"
+        + "  },\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"trafficdirector-foo.googleapis.com:443\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"tls\"}\n"
+        + "      ]\n"
+        + "    },\n"
+        + "    {\n"
+        + "      \"server_uri\": \"trafficdirector-bar.googleapis.com:443\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    assertThat(info.servers()).hasSize(2);
+    List<ServerInfo> serverInfoList = info.servers();
+    assertThat(serverInfoList.get(0).target())
+        .isEqualTo("trafficdirector-foo.googleapis.com:443");
+    assertThat(serverInfoList.get(0).implSpecificConfig())
+        .isInstanceOf(TlsChannelCredentials.class);
+    assertThat(serverInfoList.get(1).target())
+        .isEqualTo("trafficdirector-bar.googleapis.com:443");
+    assertThat(serverInfoList.get(1).implSpecificConfig())
+        .isInstanceOf(InsecureChannelCredentials.class);
+    assertThat(info.node()).isEqualTo(
+        getNodeBuilder()
+            .setId("ENVOY_NODE_ID")
+            .setCluster("ENVOY_CLUSTER")
+            .setLocality(Locality.create("ENVOY_REGION", "ENVOY_ZONE", "ENVOY_SUBZONE"))
+            .setMetadata(
+                ImmutableMap.of(
+                    "TRAFFICDIRECTOR_INTERCEPTION_PORT",
+                    "ENVOY_PORT",
+                    "TRAFFICDIRECTOR_NETWORK_NAME",
+                    "VPC_NETWORK_NAME"))
+            .build());
+  }
+
+  @Test
+  public void parseBootstrap_IgnoreIrrelevantFields() throws XdsInitializationException {
+    String rawData = "{\n"
+        + "  \"node\": {\n"
+        + "    \"id\": \"ENVOY_NODE_ID\",\n"
+        + "    \"cluster\": \"ENVOY_CLUSTER\",\n"
+        + "    \"locality\": {},\n"
+        + "    \"metadata\": {\n"
+        + "      \"TRAFFICDIRECTOR_INTERCEPTION_PORT\": \"ENVOY_PORT\",\n"
+        + "      \"TRAFFICDIRECTOR_NETWORK_NAME\": \"VPC_NETWORK_NAME\"\n"
+        + "    }\n"
+        + "  },\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"ignore\": \"something irrelevant\","
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ],\n"
+        + "  \"ignore\": \"something irrelevant\"\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    assertThat(info.servers()).hasSize(1);
+    ServerInfo serverInfo = Iterables.getOnlyElement(info.servers());
+    assertThat(serverInfo.target()).isEqualTo(SERVER_URI);
+    assertThat(serverInfo.implSpecificConfig()).isInstanceOf(InsecureChannelCredentials.class);
+    assertThat(info.node()).isEqualTo(
+        getNodeBuilder()
+            .setId("ENVOY_NODE_ID")
+            .setCluster("ENVOY_CLUSTER")
+            .setLocality(Locality.create("", "", ""))
+            .setMetadata(
+                ImmutableMap.of(
+                    "TRAFFICDIRECTOR_INTERCEPTION_PORT",
+                    "ENVOY_PORT",
+                    "TRAFFICDIRECTOR_NETWORK_NAME",
+                    "VPC_NETWORK_NAME"))
+            .build());
+  }
+
+  @Test
+  public void parseBootstrap_missingServerChannelCreds() {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\"\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    XdsInitializationException e = Assert.assertThrows(XdsInitializationException.class,
+        bootstrapper::bootstrap);
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Invalid bootstrap: server " + SERVER_URI + " 'channel_creds' required");
+  }
+
+  @Test
+  public void parseBootstrap_unsupportedServerChannelCreds() {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"unsupported\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    XdsInitializationException e = assertThrows(XdsInitializationException.class,
+        bootstrapper::bootstrap);
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Server " + SERVER_URI + ": no supported channel credentials found");
+  }
+
+  @Test
+  public void parseBootstrap_useFirstSupportedChannelCredentials()
+      throws XdsInitializationException {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"unsupported\"}, {\"type\": \"insecure\"}, {\"type\": \"tls\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    assertThat(info.servers()).hasSize(1);
+    ServerInfo serverInfo = Iterables.getOnlyElement(info.servers());
+    assertThat(serverInfo.target()).isEqualTo(SERVER_URI);
+    assertThat(serverInfo.implSpecificConfig()).isInstanceOf(InsecureChannelCredentials.class);
+    assertThat(info.node()).isEqualTo(getNodeBuilder().build());
+  }
+
+  @Test
+  public void parseBootstrap_noXdsServers() {
+    String rawData = "{\n"
+        + "  \"node\": {\n"
+        + "    \"id\": \"ENVOY_NODE_ID\",\n"
+        + "    \"cluster\": \"ENVOY_CLUSTER\",\n"
+        + "    \"locality\": {\n"
+        + "      \"region\": \"ENVOY_REGION\",\n"
+        + "      \"zone\": \"ENVOY_ZONE\",\n"
+        + "      \"sub_zone\": \"ENVOY_SUBZONE\"\n"
+        + "    },\n"
+        + "    \"metadata\": {\n"
+        + "      \"TRAFFICDIRECTOR_INTERCEPTION_PORT\": \"ENVOY_PORT\",\n"
+        + "      \"TRAFFICDIRECTOR_NETWORK_NAME\": \"VPC_NETWORK_NAME\"\n"
+        + "    }\n"
+        + "  }\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    XdsInitializationException e = assertThrows(XdsInitializationException.class,
+        bootstrapper::bootstrap);
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Invalid bootstrap: 'xds_servers' does not exist.");
+  }
+
+  @Test
+  public void parseBootstrap_serverWithoutServerUri() throws XdsInitializationException {
+    String rawData = "{"
+        + "  \"node\": {\n"
+        + "    \"id\": \"ENVOY_NODE_ID\",\n"
+        + "    \"cluster\": \"ENVOY_CLUSTER\",\n"
+        + "    \"locality\": {\n"
+        + "      \"region\": \"ENVOY_REGION\",\n"
+        + "      \"zone\": \"ENVOY_ZONE\",\n"
+        + "      \"sub_zone\": \"ENVOY_SUBZONE\"\n"
+        + "    },\n"
+        + "    \"metadata\": {\n"
+        + "      \"TRAFFICDIRECTOR_INTERCEPTION_PORT\": \"ENVOY_PORT\",\n"
+        + "      \"TRAFFICDIRECTOR_NETWORK_NAME\": \"VPC_NETWORK_NAME\"\n"
+        + "    }\n"
+        + "  },\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"tls\"}, {\"type\": \"loas\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n "
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    XdsInitializationException e = assertThrows(XdsInitializationException.class,
+        bootstrapper::bootstrap);
+    assertThat(e).hasMessageThat().isEqualTo("Invalid bootstrap: missing 'server_uri'");
+  }
+
+  @Test
+  public void parseBootstrap_certProviderInstances() throws XdsInitializationException {
+    String rawData =
+        "{\n"
+            + "  \"xds_servers\": [\n"
+            + "    {\n"
+            + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+            + "      \"channel_creds\": [\n"
+            + "        {\"type\": \"insecure\"}\n"
+            + "      ]\n"
+            + "    }\n"
+            + "  ],\n"
+            + "  \"certificate_providers\": {\n"
+            + "    \"gcp_id\": {\n"
+            + "      \"plugin_name\": \"meshca\",\n"
+            + "      \"config\": {\n"
+            + "        \"server\": {\n"
+            + "          \"api_type\": \"GRPC\",\n"
+            + "          \"grpc_services\": [{\n"
+            + "            \"google_grpc\": {\n"
+            + "              \"target_uri\": \"meshca.com\",\n"
+            + "              \"channel_credentials\": {\"google_default\": {}},\n"
+            + "              \"call_credentials\": [{\n"
+            + "                \"sts_service\": {\n"
+            + "                  \"token_exchange_service\": \"securetoken.googleapis.com\",\n"
+            + "                  \"subject_token_path\": \"/etc/secret/sajwt.token\"\n"
+            + "                }\n"
+            + "              }]\n" // end call_credentials
+            + "            },\n" // end google_grpc
+            + "            \"time_out\": {\"seconds\": 10}\n"
+            + "          }]\n" // end grpc_services
+            + "        },\n" // end server
+            + "        \"certificate_lifetime\": {\"seconds\": 86400},\n"
+            + "        \"renewal_grace_period\": {\"seconds\": 3600},\n"
+            + "        \"key_type\": \"RSA\",\n"
+            + "        \"key_size\": 2048,\n"
+            + "        \"location\": \"https://container.googleapis.com/v1/project/test-project1/locations/test-zone2/clusters/test-cluster3\"\n"
+            + "      }\n" // end config
+            + "    },\n" // end gcp_id
+            + "    \"file_provider\": {\n"
+            + "      \"plugin_name\": \"file_watcher\",\n"
+            + "      \"config\": {\"path\": \"/etc/secret/certs\"}\n"
+            + "    }\n"
+            + "  }\n"
+            + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    assertThat(info.node()).isEqualTo(getNodeBuilder().build());
+    Map<String, Bootstrapper.CertificateProviderInfo> certProviders = info.certProviders();
+    assertThat(certProviders).isNotNull();
+    Bootstrapper.CertificateProviderInfo gcpId = certProviders.get("gcp_id");
+    Bootstrapper.CertificateProviderInfo fileProvider = certProviders.get("file_provider");
+    assertThat(gcpId.pluginName()).isEqualTo("meshca");
+    assertThat(gcpId.config()).isInstanceOf(Map.class);
+    assertThat(fileProvider.pluginName()).isEqualTo("file_watcher");
+    assertThat(fileProvider.config()).isInstanceOf(Map.class);
+    Map<String, ?> meshCaConfig = gcpId.config();
+    assertThat(meshCaConfig.get("key_size")).isEqualTo(2048);
+  }
+
+  @Test
+  public void parseBootstrap_badPluginName() throws XdsInitializationException {
+    String rawData =
+        "{\n"
+            + "  \"xds_servers\": [],\n"
+            + "  \"certificate_providers\": {\n"
+            + "    \"gcp_id\": {\n"
+            + "      \"plugin_name\": 234,\n"
+            + "      \"config\": {\n"
+            + "        \"server\": {\n"
+            + "          \"api_type\": \"GRPC\",\n"
+            + "          \"grpc_services\": [{\n"
+            + "            \"google_grpc\": {\n"
+            + "              \"target_uri\": \"meshca.com\",\n"
+            + "              \"channel_credentials\": {\"google_default\": {}},\n"
+            + "              \"call_credentials\": [{\n"
+            + "                \"sts_service\": {\n"
+            + "                  \"token_exchange_service\": \"securetoken.googleapis.com\",\n"
+            + "                  \"subject_token_path\": \"/etc/secret/sajwt.token\"\n"
+            + "                }\n"
+            + "              }]\n" // end call_credentials
+            + "            },\n" // end google_grpc
+            + "            \"time_out\": {\"seconds\": 10}\n"
+            + "          }]\n" // end grpc_services
+            + "        },\n" // end server
+            + "        \"certificate_lifetime\": {\"seconds\": 86400},\n"
+            + "        \"renewal_grace_period\": {\"seconds\": 3600},\n"
+            + "        \"key_type\": \"RSA\",\n"
+            + "        \"key_size\": 2048,\n"
+            + "        \"location\": \"https://container.googleapis.com/v1/project/test-project1/locations/test-zone2/clusters/test-cluster3\"\n"
+            + "      }\n" // end config
+            + "    },\n" // end gcp_id
+            + "    \"file_provider\": {\n"
+            + "      \"plugin_name\": \"file_watcher\",\n"
+            + "      \"config\": {\"path\": \"/etc/secret/certs\"}\n"
+            + "    }\n"
+            + "  }\n"
+            + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    try {
+      bootstrapper.bootstrap();
+      fail("exception expected");
+    } catch (ClassCastException expected) {
+      assertThat(expected).hasMessageThat().contains("value '234.0' for key 'plugin_name' in");
+    }
+  }
+
+  @Test
+  public void parseBootstrap_badConfig() throws XdsInitializationException {
+    String rawData =
+        "{\n"
+            + "  \"xds_servers\": [],\n"
+            + "  \"certificate_providers\": {\n"
+            + "    \"gcp_id\": {\n"
+            + "      \"plugin_name\": \"meshca\",\n"
+            + "      \"config\": \"badValue\"\n"
+            + "    },\n" // end gcp_id
+            + "    \"file_provider\": {\n"
+            + "      \"plugin_name\": \"file_watcher\",\n"
+            + "      \"config\": {\"path\": \"/etc/secret/certs\"}\n"
+            + "    }\n"
+            + "  }\n"
+            + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    try {
+      bootstrapper.bootstrap();
+      fail("exception expected");
+    } catch (ClassCastException expected) {
+      assertThat(expected).hasMessageThat().contains("value 'badValue' for key 'config' in");
+    }
+  }
+
+  @Test
+  public void parseBootstrap_missingConfig() {
+    String rawData =
+        "{\n"
+            + "  \"xds_servers\": [],\n"
+            + "  \"certificate_providers\": {\n"
+            + "    \"gcp_id\": {\n"
+            + "      \"plugin_name\": \"meshca\"\n"
+            + "    },\n" // end gcp_id
+            + "    \"file_provider\": {\n"
+            + "      \"plugin_name\": \"file_watcher\",\n"
+            + "      \"config\": {\"path\": \"/etc/secret/certs\"}\n"
+            + "    }\n"
+            + "  }\n"
+            + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    try {
+      bootstrapper.bootstrap();
+      fail("exception expected");
+    } catch (XdsInitializationException expected) {
+      assertThat(expected)
+          .hasMessageThat()
+          .isEqualTo("Invalid bootstrap: 'config' does not exist.");
+    }
+  }
+
+  @Test
+  public void parseBootstrap_missingPluginName() {
+    String rawData =
+        "{\n"
+            + "  \"xds_servers\": [],\n"
+            + "  \"certificate_providers\": {\n"
+            + "    \"gcp_id\": {\n"
+            + "      \"plugin_name\": \"meshca\",\n"
+            + "      \"config\": {\n"
+            + "        \"server\": {\n"
+            + "          \"api_type\": \"GRPC\",\n"
+            + "          \"grpc_services\": [{\n"
+            + "            \"google_grpc\": {\n"
+            + "              \"target_uri\": \"meshca.com\",\n"
+            + "              \"channel_credentials\": {\"google_default\": {}},\n"
+            + "              \"call_credentials\": [{\n"
+            + "                \"sts_service\": {\n"
+            + "                  \"token_exchange_service\": \"securetoken.googleapis.com\",\n"
+            + "                  \"subject_token_path\": \"/etc/secret/sajwt.token\"\n"
+            + "                }\n"
+            + "              }]\n" // end call_credentials
+            + "            },\n" // end google_grpc
+            + "            \"time_out\": {\"seconds\": 10}\n"
+            + "          }]\n" // end grpc_services
+            + "        },\n" // end server
+            + "        \"certificate_lifetime\": {\"seconds\": 86400},\n"
+            + "        \"renewal_grace_period\": {\"seconds\": 3600},\n"
+            + "        \"key_type\": \"RSA\",\n"
+            + "        \"key_size\": 2048,\n"
+            + "        \"location\": \"https://container.googleapis.com/v1/project/test-project1/locations/test-zone2/clusters/test-cluster3\"\n"
+            + "      }\n" // end config
+            + "    },\n" // end gcp_id
+            + "    \"file_provider\": {\n"
+            + "      \"config\": {\"path\": \"/etc/secret/certs\"}\n"
+            + "    }\n"
+            + "  }\n"
+            + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    try {
+      bootstrapper.bootstrap();
+      fail("exception expected");
+    } catch (XdsInitializationException expected) {
+      assertThat(expected)
+          .hasMessageThat()
+          .isEqualTo("Invalid bootstrap: 'plugin_name' does not exist.");
+    }
+  }
+
+  @Test
+  public void parseBootstrap_grpcServerResourceId() throws XdsInitializationException {
+    String rawData = "{\n"
+            + "  \"xds_servers\": [\n"
+            + "    {\n"
+            + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+            + "      \"channel_creds\": [\n"
+            + "        {\"type\": \"insecure\"}\n"
+            + "      ]\n"
+            + "    }\n"
+            + "  ],\n"
+            + "  \"server_listener_resource_name_template\": \"grpc/serverx=%s\"\n"
+            + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    assertThat(info.serverListenerResourceNameTemplate()).isEqualTo("grpc/serverx=%s");
+  }
+
+  @Test
+  public void useV2ProtocolByDefault() throws XdsInitializationException {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ],\n"
+        + "      \"server_features\": []\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    ServerInfo serverInfo = Iterables.getOnlyElement(info.servers());
+    assertThat(serverInfo.target()).isEqualTo(SERVER_URI);
+    assertThat(serverInfo.implSpecificConfig()).isInstanceOf(InsecureChannelCredentials.class);
+    assertThat(serverInfo.ignoreResourceDeletion()).isFalse();
+  }
+
+  @Test
+  public void useV3ProtocolIfV3FeaturePresent() throws XdsInitializationException {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ],\n"
+        + "      \"server_features\": [\"xds_v3\"]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    ServerInfo serverInfo = Iterables.getOnlyElement(info.servers());
+    assertThat(serverInfo.target()).isEqualTo(SERVER_URI);
+    assertThat(serverInfo.implSpecificConfig()).isInstanceOf(InsecureChannelCredentials.class);
+    assertThat(serverInfo.ignoreResourceDeletion()).isFalse();
+  }
+
+  @Test
+  public void serverFeatureIgnoreResourceDeletion() throws XdsInitializationException {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ],\n"
+        + "      \"server_features\": [\"ignore_resource_deletion\"]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    ServerInfo serverInfo = Iterables.getOnlyElement(info.servers());
+    assertThat(serverInfo.target()).isEqualTo(SERVER_URI);
+    assertThat(serverInfo.implSpecificConfig()).isInstanceOf(InsecureChannelCredentials.class);
+    // Only ignore_resource_deletion feature enabled: confirm it's on, and xds_v3 is off.
+    assertThat(serverInfo.ignoreResourceDeletion()).isTrue();
+  }
+
+  @Test
+  public void serverFeatureTrustedXdsServer() throws XdsInitializationException {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ],\n"
+        + "      \"server_features\": [\"trusted_xds_server\"]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    ServerInfo serverInfo = Iterables.getOnlyElement(info.servers());
+    assertThat(serverInfo.target()).isEqualTo(SERVER_URI);
+    assertThat(serverInfo.implSpecificConfig()).isInstanceOf(InsecureChannelCredentials.class);
+    assertThat(serverInfo.isTrustedXdsServer()).isTrue();
+  }
+
+  @Test
+  public void serverFeatureIgnoreResourceDeletion_xdsV3() throws XdsInitializationException {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ],\n"
+        + "      \"server_features\": [\"xds_v3\", \"ignore_resource_deletion\"]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    ServerInfo serverInfo = Iterables.getOnlyElement(info.servers());
+    assertThat(serverInfo.target()).isEqualTo(SERVER_URI);
+    assertThat(serverInfo.implSpecificConfig()).isInstanceOf(InsecureChannelCredentials.class);
+    // ignore_resource_deletion features enabled: confirm both are on.
+    assertThat(serverInfo.ignoreResourceDeletion()).isTrue();
+  }
+
+  @Test
+  public void serverFeatures_ignoresUnknownValues() throws XdsInitializationException {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ],\n"
+        + "      \"server_features\": [null, {}, 3, true, \"unexpected\", \"trusted_xds_server\"]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    ServerInfo serverInfo = Iterables.getOnlyElement(info.servers());
+    assertThat(serverInfo.isTrustedXdsServer()).isTrue();
+  }
+
+  @Test
+  public void serverFeature_failOnDataErrors() throws XdsInitializationException {
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = true;
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ],\n"
+        + "      \"server_features\": [\"fail_on_data_errors\"]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    ServerInfo serverInfo = Iterables.getOnlyElement(info.servers());
+    assertThat(serverInfo.target()).isEqualTo(SERVER_URI);
+    assertThat(serverInfo.implSpecificConfig()).isInstanceOf(InsecureChannelCredentials.class);
+    assertThat(serverInfo.failOnDataErrors()).isTrue();
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = false;
+  }
+
+  @Test
+  public void serverFeature_failOnDataErrors_requiresEnvVar() throws XdsInitializationException {
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = false;
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ],\n"
+        + "      \"server_features\": [\"fail_on_data_errors\"]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    ServerInfo serverInfo = Iterables.getOnlyElement(info.servers());
+    // Should be false when env var is not enabled
+    assertThat(serverInfo.failOnDataErrors()).isFalse();
+  }
+
+  @Test
+  public void notFound() {
+    bootstrapper.bootstrapPathFromEnvVar = null;
+    bootstrapper.bootstrapPathFromSysProp = null;
+    bootstrapper.bootstrapConfigFromEnvVar = null;
+    bootstrapper.bootstrapConfigFromSysProp = null;
+    BootstrapperImpl.FileReader reader = mock(BootstrapperImpl.FileReader.class);
+    bootstrapper.setFileReader(reader);
+    try {
+      bootstrapper.bootstrap();
+      fail("should fail");
+    } catch (XdsInitializationException expected) {
+      assertThat(expected).hasMessageThat().startsWith("Cannot find bootstrap configuration");
+    }
+    verifyNoInteractions(reader);
+  }
+
+  @Test
+  public void fallbackToFilePathFromSystemProperty() throws XdsInitializationException {
+    final String customPath = "/home/bootstrap.json";
+    bootstrapper.bootstrapPathFromEnvVar = null;
+    bootstrapper.bootstrapPathFromSysProp = customPath;
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.setFileReader(createFileReader(customPath, rawData));
+    bootstrapper.bootstrap();
+  }
+
+  @Test
+  public void fallbackToConfigFromEnvVar() throws XdsInitializationException {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.bootstrapPathFromEnvVar = null;
+    bootstrapper.bootstrapPathFromSysProp = null;
+    bootstrapper.bootstrapConfigFromEnvVar = rawData;
+    bootstrapper.setFileReader(mock(BootstrapperImpl.FileReader.class));
+    bootstrapper.bootstrap();
+  }
+
+  @Test
+  public void fallbackToConfigFromSysProp() throws XdsInitializationException {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+
+    bootstrapper.bootstrapPathFromEnvVar = null;
+    bootstrapper.bootstrapPathFromSysProp = null;
+    bootstrapper.bootstrapConfigFromEnvVar = null;
+    bootstrapper.bootstrapConfigFromSysProp = rawData;
+    bootstrapper.setFileReader(mock(BootstrapperImpl.FileReader.class));
+    bootstrapper.bootstrap();
+  }
+
+  @Test
+  public void parseClientDefaultListenerResourceNameTemplate() throws Exception {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    assertThat(info.clientDefaultListenerResourceNameTemplate()).isEqualTo("%s");
+
+    rawData = "{\n"
+        + "  \"client_default_listener_resource_name_template\": \"xdstp://a.com/faketype/%s\",\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    info = bootstrapper.bootstrap();
+    assertThat(info.clientDefaultListenerResourceNameTemplate())
+        .isEqualTo("xdstp://a.com/faketype/%s");
+  }
+
+  @Test
+  public void parseAuthorities() throws Exception {
+    String rawData = "{\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    BootstrapInfo info = bootstrapper.bootstrap();
+    assertThat(info.authorities()).isEmpty();
+
+    rawData = "{\n"
+        + "  \"authorities\": {\n"
+        + "    \"a.com\": {\n"
+        + "      \"client_listener_resource_name_template\": \"xdstp://a.com/v1.Listener/id-%s\"\n"
+        + "    }\n"
+        + "  },\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    info = bootstrapper.bootstrap();
+    assertThat(info.authorities()).hasSize(1);
+    AuthorityInfo authorityInfo = info.authorities().get("a.com");
+    assertThat(authorityInfo.clientListenerResourceNameTemplate())
+        .isEqualTo("xdstp://a.com/v1.Listener/id-%s");
+    // Defaults to top-level servers.
+    assertThat(authorityInfo.xdsServers()).hasSize(1);
+    assertThat(authorityInfo.xdsServers().get(0).target()).isEqualTo(SERVER_URI);
+
+    rawData = "{\n"
+        + "  \"authorities\": {\n"
+        + "    \"a.com\": {\n"
+        + "      \"xds_servers\": [\n"
+        + "        {\n"
+        + "          \"server_uri\": \"td2.googleapis.com:443\",\n"
+        + "          \"channel_creds\": [\n"
+        + "            {\"type\": \"insecure\"}\n"
+        + "          ]\n"
+        + "        }\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  },\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    info = bootstrapper.bootstrap();
+    assertThat(info.authorities()).hasSize(1);
+    authorityInfo = info.authorities().get("a.com");
+    // Defaults to "xdstp://<authority_name>>/envoy.config.listener.v3.Listener/%s"
+    assertThat(authorityInfo.clientListenerResourceNameTemplate())
+        .isEqualTo("xdstp://a.com/envoy.config.listener.v3.Listener/%s");
+    assertThat(authorityInfo.xdsServers()).hasSize(1);
+    assertThat(authorityInfo.xdsServers().get(0).target()).isEqualTo("td2.googleapis.com:443");
+  }
+
+  @Test
+  public void badFederationConfig() {
+    String rawData = "{\n"
+        + "  \"authorities\": {\n"
+        + "    \"a.com\": {\n"
+        + "      \"client_listener_resource_name_template\": \"xdstp://wrong/\"\n"
+        + "    }\n"
+        + "  },\n"
+        + "  \"xds_servers\": [\n"
+        + "    {\n"
+        + "      \"server_uri\": \"" + SERVER_URI + "\",\n"
+        + "      \"channel_creds\": [\n"
+        + "        {\"type\": \"insecure\"}\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  ]\n"
+        + "}";
+    bootstrapper.setFileReader(createFileReader(BOOTSTRAP_FILE_PATH, rawData));
+    try {
+      bootstrapper.bootstrap();
+      fail("should fail");
+    } catch (XdsInitializationException e) {
+      assertThat(e).hasMessageThat().isEqualTo(
+          "client_listener_resource_name_template: 'xdstp://wrong/' does not start with "
+              + "xdstp://a.com/");
+    }
+  }
+
+  private static BootstrapperImpl.FileReader createFileReader(
+      final String expectedPath, final String rawData) {
+    return new BootstrapperImpl.FileReader() {
+      @Override
+      public String readFile(String path) throws IOException {
+        assertThat(path).isEqualTo(expectedPath);
+        return rawData;
+      }
+    };
+  }
+
+  private static Node.Builder getNodeBuilder() {
+    GrpcBuildVersion buildVersion = GrpcUtil.getGrpcBuildVersion();
+    return
+        Node.newBuilder()
+            .setBuildVersion(buildVersion.toString())
+            .setUserAgentName(buildVersion.getUserAgent())
+            .setUserAgentVersion(buildVersion.getImplementationVersion())
+            .addClientFeatures(GrpcBootstrapperImpl.CLIENT_FEATURE_DISABLE_OVERPROVISIONING)
+            .addClientFeatures(GrpcBootstrapperImpl.CLIENT_FEATURE_RESOURCE_IN_SOTW);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/GrpcXdsClientImplDataTest.java b/xds/src/test/java/io/grpc/xds/GrpcXdsClientImplDataTest.java
new file mode 100644
index 00000000000..be29e5e719f
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/GrpcXdsClientImplDataTest.java
@@ -0,0 +1,3620 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.envoyproxy.envoy.config.route.v3.RouteAction.ClusterSpecifierCase.CLUSTER_SPECIFIER_PLUGIN;
+import static io.grpc.xds.XdsClusterResource.TRANSPORT_SOCKET_NAME_HTTP11_PROXY;
+import static io.grpc.xds.XdsEndpointResource.GRPC_EXPERIMENTAL_XDS_DUALSTACK_ENDPOINTS;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.fail;
+
+import com.github.udpa.udpa.type.v1.TypedStruct;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Iterables;
+import com.google.protobuf.Any;
+import com.google.protobuf.BoolValue;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.Duration;
+import com.google.protobuf.FloatValue;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Message;
+import com.google.protobuf.StringValue;
+import com.google.protobuf.Struct;
+import com.google.protobuf.UInt32Value;
+import com.google.protobuf.Value;
+import com.google.protobuf.util.Durations;
+import com.google.re2j.Pattern;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.DiscoveryType;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.EdsClusterConfig;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.LbPolicy;
+import io.envoyproxy.envoy.config.cluster.v3.LoadBalancingPolicy;
+import io.envoyproxy.envoy.config.core.v3.Address;
+import io.envoyproxy.envoy.config.core.v3.AggregatedConfigSource;
+import io.envoyproxy.envoy.config.core.v3.CidrRange;
+import io.envoyproxy.envoy.config.core.v3.ConfigSource;
+import io.envoyproxy.envoy.config.core.v3.DataSource;
+import io.envoyproxy.envoy.config.core.v3.HttpProtocolOptions;
+import io.envoyproxy.envoy.config.core.v3.Locality;
+import io.envoyproxy.envoy.config.core.v3.Metadata;
+import io.envoyproxy.envoy.config.core.v3.PathConfigSource;
+import io.envoyproxy.envoy.config.core.v3.RuntimeFractionalPercent;
+import io.envoyproxy.envoy.config.core.v3.SelfConfigSource;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress;
+import io.envoyproxy.envoy.config.core.v3.TrafficDirection;
+import io.envoyproxy.envoy.config.core.v3.TransportSocket;
+import io.envoyproxy.envoy.config.core.v3.TypedExtensionConfig;
+import io.envoyproxy.envoy.config.endpoint.v3.Endpoint;
+import io.envoyproxy.envoy.config.listener.v3.Filter;
+import io.envoyproxy.envoy.config.listener.v3.FilterChain;
+import io.envoyproxy.envoy.config.listener.v3.FilterChainMatch;
+import io.envoyproxy.envoy.config.listener.v3.Listener;
+import io.envoyproxy.envoy.config.listener.v3.ListenerFilter;
+import io.envoyproxy.envoy.config.rbac.v3.Permission;
+import io.envoyproxy.envoy.config.rbac.v3.Policy;
+import io.envoyproxy.envoy.config.rbac.v3.Principal;
+import io.envoyproxy.envoy.config.rbac.v3.RBAC;
+import io.envoyproxy.envoy.config.rbac.v3.RBAC.Action;
+import io.envoyproxy.envoy.config.route.v3.DirectResponseAction;
+import io.envoyproxy.envoy.config.route.v3.FilterAction;
+import io.envoyproxy.envoy.config.route.v3.NonForwardingAction;
+import io.envoyproxy.envoy.config.route.v3.RedirectAction;
+import io.envoyproxy.envoy.config.route.v3.RetryPolicy;
+import io.envoyproxy.envoy.config.route.v3.RetryPolicy.RetryBackOff;
+import io.envoyproxy.envoy.config.route.v3.RouteAction.HashPolicy.ConnectionProperties;
+import io.envoyproxy.envoy.config.route.v3.RouteAction.HashPolicy.FilterState;
+import io.envoyproxy.envoy.config.route.v3.RouteAction.HashPolicy.Header;
+import io.envoyproxy.envoy.config.route.v3.RouteAction.HashPolicy.QueryParameter;
+import io.envoyproxy.envoy.config.route.v3.RouteAction.MaxStreamDuration;
+import io.envoyproxy.envoy.config.route.v3.RouteConfiguration;
+import io.envoyproxy.envoy.config.route.v3.WeightedCluster;
+import io.envoyproxy.envoy.extensions.filters.common.fault.v3.FaultDelay;
+import io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort;
+import io.envoyproxy.envoy.extensions.filters.http.fault.v3.HTTPFault;
+import io.envoyproxy.envoy.extensions.filters.http.gcp_authn.v3.Audience;
+import io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBACPerRoute;
+import io.envoyproxy.envoy.extensions.filters.http.router.v3.Router;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.HttpFilter;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.Rds;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.client_side_weighted_round_robin.v3.ClientSideWeightedRoundRobin;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.wrr_locality.v3.WrrLocality;
+import io.envoyproxy.envoy.extensions.transport_sockets.http_11_proxy.v3.Http11ProxyUpstreamTransport;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateProviderPluginInstance;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext.CombinedCertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.SdsSecretConfig;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.TlsCertificate;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.TlsParameters;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext;
+import io.envoyproxy.envoy.type.matcher.v3.RegexMatchAndSubstitute;
+import io.envoyproxy.envoy.type.matcher.v3.RegexMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.RegexMatcher.GoogleRE2;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import io.envoyproxy.envoy.type.v3.FractionalPercent;
+import io.envoyproxy.envoy.type.v3.FractionalPercent.DenominatorType;
+import io.envoyproxy.envoy.type.v3.Int64Range;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.Status.Code;
+import io.grpc.internal.JsonUtil;
+import io.grpc.internal.ServiceConfigUtil;
+import io.grpc.internal.ServiceConfigUtil.LbConfig;
+import io.grpc.lookup.v1.GrpcKeyBuilder;
+import io.grpc.lookup.v1.GrpcKeyBuilder.Name;
+import io.grpc.lookup.v1.NameMatcher;
+import io.grpc.lookup.v1.RouteLookupClusterSpecifier;
+import io.grpc.lookup.v1.RouteLookupConfig;
+import io.grpc.xds.ClusterSpecifierPlugin.NamedPluginConfig;
+import io.grpc.xds.ClusterSpecifierPlugin.PluginConfig;
+import io.grpc.xds.Endpoints.LbEndpoint;
+import io.grpc.xds.Endpoints.LocalityLbEndpoints;
+import io.grpc.xds.Filter.FilterConfig;
+import io.grpc.xds.GcpAuthenticationFilter.AudienceMetadataParser.AudienceWrapper;
+import io.grpc.xds.MetadataRegistry.MetadataValueParser;
+import io.grpc.xds.RouteLookupServiceClusterSpecifierPlugin.RlsPluginConfig;
+import io.grpc.xds.VirtualHost.Route;
+import io.grpc.xds.VirtualHost.Route.RouteAction;
+import io.grpc.xds.VirtualHost.Route.RouteAction.ClusterWeight;
+import io.grpc.xds.VirtualHost.Route.RouteAction.HashPolicy;
+import io.grpc.xds.VirtualHost.Route.RouteMatch;
+import io.grpc.xds.VirtualHost.Route.RouteMatch.PathMatcher;
+import io.grpc.xds.WeightedRoundRobinLoadBalancer.WeightedRoundRobinLoadBalancerConfig;
+import io.grpc.xds.XdsClusterResource.CdsUpdate;
+import io.grpc.xds.client.BackendMetricPropagation;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.LoadStatsManager2;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsResourceType;
+import io.grpc.xds.client.XdsResourceType.ResourceInvalidException;
+import io.grpc.xds.internal.Matchers;
+import io.grpc.xds.internal.Matchers.FractionMatcher;
+import io.grpc.xds.internal.Matchers.HeaderMatcher;
+import java.net.InetSocketAddress;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@SuppressWarnings("DataFlowIssue")
+@RunWith(JUnit4.class)
+public class GrpcXdsClientImplDataTest {
+
+  private static final FaultFilter.Provider FAULT_FILTER_PROVIDER = new FaultFilter.Provider();
+  private static final RbacFilter.Provider RBAC_FILTER_PROVIDER = new RbacFilter.Provider();
+  private static final RouterFilter.Provider ROUTER_FILTER_PROVIDER = new RouterFilter.Provider();
+
+  private static final ServerInfo LRS_SERVER_INFO =
+      ServerInfo.create("lrs.googleapis.com", InsecureChannelCredentials.create());
+  private static final String GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE =
+      "GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE";
+
+  private final FilterRegistry filterRegistry = FilterRegistry.getDefaultRegistry();
+  private boolean originalEnableRouteLookup;
+  private boolean originalEnableLeastRequest;
+  private boolean originalEnableUseSystemRootCerts;
+
+  @Before
+  public void setUp() {
+    originalEnableRouteLookup = XdsRouteConfigureResource.enableRouteLookup;
+    originalEnableLeastRequest = XdsClusterResource.enableLeastRequest;
+    originalEnableUseSystemRootCerts = XdsClusterResource.enableSystemRootCerts;
+  }
+
+  @After
+  public void tearDown() {
+    XdsRouteConfigureResource.enableRouteLookup = originalEnableRouteLookup;
+    XdsClusterResource.enableLeastRequest = originalEnableLeastRequest;
+    XdsClusterResource.enableSystemRootCerts = originalEnableUseSystemRootCerts;
+  }
+
+  @Test
+  public void parseRoute_withRouteAction() {
+    io.envoyproxy.envoy.config.route.v3.Route proto =
+        io.envoyproxy.envoy.config.route.v3.Route.newBuilder()
+            .setName("route-blade")
+            .setMatch(
+                io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder()
+                    .setPath("/service/method"))
+            .setRoute(
+                io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+                    .setCluster("cluster-foo"))
+            .build();
+    StructOrError<Route> struct = XdsRouteConfigureResource.parseRoute(
+        proto, filterRegistry, ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct())
+        .isEqualTo(
+            Route.forAction(
+                RouteMatch.create(PathMatcher.fromPath("/service/method", false),
+                    Collections.<HeaderMatcher>emptyList(), null),
+                RouteAction.forCluster(
+                    "cluster-foo", Collections.<HashPolicy>emptyList(), null, null, false),
+                ImmutableMap.<String, FilterConfig>of()));
+  }
+
+  @Test
+  public void parseRoute_withNonForwardingAction() {
+    io.envoyproxy.envoy.config.route.v3.Route proto =
+        io.envoyproxy.envoy.config.route.v3.Route.newBuilder()
+            .setName("route-blade")
+            .setMatch(
+                io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder()
+                    .setPath("/service/method"))
+            .setNonForwardingAction(NonForwardingAction.getDefaultInstance())
+            .build();
+    StructOrError<Route> struct = XdsRouteConfigureResource.parseRoute(
+        proto, filterRegistry, ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getStruct())
+        .isEqualTo(
+            Route.forNonForwardingAction(
+                RouteMatch.create(PathMatcher.fromPath("/service/method", false),
+                    Collections.<HeaderMatcher>emptyList(), null),
+                ImmutableMap.<String, FilterConfig>of()));
+  }
+
+  @Test
+  public void parseRoute_withUnsupportedActionTypes() {
+    StructOrError<Route> res;
+    io.envoyproxy.envoy.config.route.v3.Route redirectRoute =
+        io.envoyproxy.envoy.config.route.v3.Route.newBuilder()
+            .setName("route-blade")
+            .setMatch(io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder().setPath(""))
+            .setRedirect(RedirectAction.getDefaultInstance())
+            .build();
+    res = XdsRouteConfigureResource.parseRoute(
+        redirectRoute, filterRegistry, ImmutableMap.of(), ImmutableSet.of(),
+        getXdsResourceTypeArgs(true));
+    assertThat(res.getStruct()).isNull();
+    assertThat(res.getErrorDetail())
+        .isEqualTo("Route [route-blade] with unknown action type: REDIRECT");
+
+    io.envoyproxy.envoy.config.route.v3.Route directResponseRoute =
+        io.envoyproxy.envoy.config.route.v3.Route.newBuilder()
+            .setName("route-blade")
+            .setMatch(io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder().setPath(""))
+            .setDirectResponse(DirectResponseAction.getDefaultInstance())
+            .build();
+    res = XdsRouteConfigureResource.parseRoute(
+        directResponseRoute, filterRegistry, ImmutableMap.of(), ImmutableSet.of(),
+        getXdsResourceTypeArgs(true));
+    assertThat(res.getStruct()).isNull();
+    assertThat(res.getErrorDetail())
+        .isEqualTo("Route [route-blade] with unknown action type: DIRECT_RESPONSE");
+
+    io.envoyproxy.envoy.config.route.v3.Route filterRoute =
+        io.envoyproxy.envoy.config.route.v3.Route.newBuilder()
+            .setName("route-blade")
+            .setMatch(io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder().setPath(""))
+            .setFilterAction(FilterAction.getDefaultInstance())
+            .build();
+    res = XdsRouteConfigureResource.parseRoute(
+        filterRoute, filterRegistry, ImmutableMap.of(), ImmutableSet.of(),
+        getXdsResourceTypeArgs(true));
+    assertThat(res.getStruct()).isNull();
+    assertThat(res.getErrorDetail())
+        .isEqualTo("Route [route-blade] with unknown action type: FILTER_ACTION");
+  }
+
+  @Test
+  public void parseRoute_skipRouteWithUnsupportedMatcher() {
+    io.envoyproxy.envoy.config.route.v3.Route proto =
+        io.envoyproxy.envoy.config.route.v3.Route.newBuilder()
+            .setName("ignore me")
+            .setMatch(
+                io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder()
+                    .setPath("/service/method")
+                    .addQueryParameters(
+                        io.envoyproxy.envoy.config.route.v3.QueryParameterMatcher
+                            .getDefaultInstance()))  // query parameter not supported
+            .setRoute(
+                io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+                    .setCluster("cluster-foo"))
+            .build();
+    assertThat(XdsRouteConfigureResource.parseRoute(
+            proto, filterRegistry, ImmutableMap.of(), ImmutableSet.of(),
+            getXdsResourceTypeArgs(true)))
+        .isNull();
+  }
+
+  @Test
+  public void parseRoute_skipRouteWithUnsupportedAction() {
+    io.envoyproxy.envoy.config.route.v3.Route proto =
+        io.envoyproxy.envoy.config.route.v3.Route.newBuilder()
+            .setName("ignore me")
+            .setMatch(
+                io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder()
+                    .setPath("/service/method"))
+            .setRoute(
+                io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+                    .setClusterHeader("cluster header"))  // cluster_header action not supported
+            .build();
+    assertThat(XdsRouteConfigureResource.parseRoute(
+            proto, filterRegistry, ImmutableMap.of(), ImmutableSet.of(),
+            getXdsResourceTypeArgs(true)))
+        .isNull();
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void parseRouteMatch_withHeaderMatcher() {
+    io.envoyproxy.envoy.config.route.v3.RouteMatch proto =
+        io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder()
+            .setPrefix("")
+            .addHeaders(
+                io.envoyproxy.envoy.config.route.v3.HeaderMatcher.newBuilder()
+                    .setName(":scheme")
+                    .setPrefixMatch("http"))
+            .addHeaders(
+                io.envoyproxy.envoy.config.route.v3.HeaderMatcher.newBuilder()
+                    .setName(":method")
+                    .setExactMatch("PUT"))
+            .build();
+    StructOrError<RouteMatch> struct = XdsRouteConfigureResource.parseRouteMatch(proto);
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct())
+        .isEqualTo(
+            RouteMatch.create(
+                PathMatcher.fromPrefix("", false),
+                Arrays.asList(
+                    HeaderMatcher.forPrefix(":scheme", "http", false),
+                    HeaderMatcher.forExactValue(":method", "PUT", false)),
+                null));
+  }
+
+  @Test
+  public void parseRouteMatch_withRuntimeFractionMatcher() {
+    io.envoyproxy.envoy.config.route.v3.RouteMatch proto =
+        io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder()
+            .setPrefix("")
+            .setRuntimeFraction(
+                RuntimeFractionalPercent.newBuilder()
+                    .setDefaultValue(
+                        FractionalPercent.newBuilder()
+                            .setNumerator(30)
+                            .setDenominator(FractionalPercent.DenominatorType.HUNDRED)))
+            .build();
+    StructOrError<RouteMatch> struct = XdsRouteConfigureResource.parseRouteMatch(proto);
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct())
+        .isEqualTo(
+            RouteMatch.create(
+                PathMatcher.fromPrefix( "", false), Collections.<HeaderMatcher>emptyList(),
+                FractionMatcher.create(30, 100)));
+  }
+
+  @Test
+  public void parsePathMatcher_withFullPath() {
+    io.envoyproxy.envoy.config.route.v3.RouteMatch proto =
+        io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder()
+            .setPath("/service/method")
+            .build();
+    StructOrError<PathMatcher> struct = XdsRouteConfigureResource.parsePathMatcher(proto);
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct()).isEqualTo(
+        PathMatcher.fromPath("/service/method", false));
+  }
+
+  @Test
+  public void parsePathMatcher_withPrefix() {
+    io.envoyproxy.envoy.config.route.v3.RouteMatch proto =
+        io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder().setPrefix("/").build();
+    StructOrError<PathMatcher> struct = XdsRouteConfigureResource.parsePathMatcher(proto);
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct()).isEqualTo(
+        PathMatcher.fromPrefix("/", false));
+  }
+
+  @Test
+  public void parsePathMatcher_withSafeRegEx() {
+    io.envoyproxy.envoy.config.route.v3.RouteMatch proto =
+        io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder()
+            .setSafeRegex(RegexMatcher.newBuilder().setRegex("."))
+            .build();
+    StructOrError<PathMatcher> struct = XdsRouteConfigureResource.parsePathMatcher(proto);
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct()).isEqualTo(PathMatcher.fromRegEx(Pattern.compile(".")));
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void parseHeaderMatcher_withExactMatch() {
+    io.envoyproxy.envoy.config.route.v3.HeaderMatcher proto =
+        io.envoyproxy.envoy.config.route.v3.HeaderMatcher.newBuilder()
+            .setName(":method")
+            .setExactMatch("PUT")
+            .build();
+    StructOrError<HeaderMatcher> struct1 = XdsRouteConfigureResource.parseHeaderMatcher(proto);
+    assertThat(struct1.getErrorDetail()).isNull();
+    assertThat(struct1.getStruct()).isEqualTo(
+        HeaderMatcher.forExactValue(":method", "PUT", false));
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void parseHeaderMatcher_withSafeRegExMatch() {
+    io.envoyproxy.envoy.config.route.v3.HeaderMatcher proto =
+        io.envoyproxy.envoy.config.route.v3.HeaderMatcher.newBuilder()
+            .setName(":method")
+            .setSafeRegexMatch(RegexMatcher.newBuilder().setRegex("P*"))
+            .build();
+    StructOrError<HeaderMatcher> struct3 = XdsRouteConfigureResource.parseHeaderMatcher(proto);
+    assertThat(struct3.getErrorDetail()).isNull();
+    assertThat(struct3.getStruct()).isEqualTo(
+        HeaderMatcher.forSafeRegEx(":method", Pattern.compile("P*"), false));
+  }
+
+  @Test
+  public void parseHeaderMatcher_withRangeMatch() {
+    io.envoyproxy.envoy.config.route.v3.HeaderMatcher proto =
+        io.envoyproxy.envoy.config.route.v3.HeaderMatcher.newBuilder()
+            .setName("timeout")
+            .setRangeMatch(Int64Range.newBuilder().setStart(10L).setEnd(20L))
+            .build();
+    StructOrError<HeaderMatcher> struct4 = XdsRouteConfigureResource.parseHeaderMatcher(proto);
+    assertThat(struct4.getErrorDetail()).isNull();
+    assertThat(struct4.getStruct()).isEqualTo(
+        HeaderMatcher.forRange("timeout", HeaderMatcher.Range.create(10L, 20L), false));
+  }
+
+  @Test
+  public void parseHeaderMatcher_withPresentMatch() {
+    io.envoyproxy.envoy.config.route.v3.HeaderMatcher proto =
+        io.envoyproxy.envoy.config.route.v3.HeaderMatcher.newBuilder()
+            .setName("user-agent")
+            .setPresentMatch(true)
+            .build();
+    StructOrError<HeaderMatcher> struct5 = XdsRouteConfigureResource.parseHeaderMatcher(proto);
+    assertThat(struct5.getErrorDetail()).isNull();
+    assertThat(struct5.getStruct()).isEqualTo(
+        HeaderMatcher.forPresent("user-agent", true, false));
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void parseHeaderMatcher_withPrefixMatch() {
+    io.envoyproxy.envoy.config.route.v3.HeaderMatcher proto =
+        io.envoyproxy.envoy.config.route.v3.HeaderMatcher.newBuilder()
+            .setName("authority")
+            .setPrefixMatch("service-foo")
+            .build();
+    StructOrError<HeaderMatcher> struct6 = XdsRouteConfigureResource.parseHeaderMatcher(proto);
+    assertThat(struct6.getErrorDetail()).isNull();
+    assertThat(struct6.getStruct()).isEqualTo(
+        HeaderMatcher.forPrefix("authority", "service-foo", false));
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void parseHeaderMatcher_withSuffixMatch() {
+    io.envoyproxy.envoy.config.route.v3.HeaderMatcher proto =
+        io.envoyproxy.envoy.config.route.v3.HeaderMatcher.newBuilder()
+            .setName("authority")
+            .setSuffixMatch("googleapis.com")
+            .build();
+    StructOrError<HeaderMatcher> struct7 = XdsRouteConfigureResource.parseHeaderMatcher(proto);
+    assertThat(struct7.getErrorDetail()).isNull();
+    assertThat(struct7.getStruct()).isEqualTo(
+        HeaderMatcher.forSuffix("authority", "googleapis.com", false));
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void parseHeaderMatcher_malformedRegExPattern() {
+    io.envoyproxy.envoy.config.route.v3.HeaderMatcher proto =
+        io.envoyproxy.envoy.config.route.v3.HeaderMatcher.newBuilder()
+            .setName(":method")
+            .setSafeRegexMatch(RegexMatcher.newBuilder().setRegex("["))
+            .build();
+    StructOrError<HeaderMatcher> struct = XdsRouteConfigureResource.parseHeaderMatcher(proto);
+    assertThat(struct.getErrorDetail()).isNotNull();
+    assertThat(struct.getStruct()).isNull();
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void parseHeaderMatcher_withStringMatcher() {
+    io.envoyproxy.envoy.type.matcher.v3.StringMatcher stringMatcherProto =
+            io.envoyproxy.envoy.type.matcher.v3.StringMatcher.newBuilder()
+                    .setPrefix("service-foo")
+                    .setIgnoreCase(false)
+                    .build();
+
+    io.envoyproxy.envoy.config.route.v3.HeaderMatcher proto =
+            io.envoyproxy.envoy.config.route.v3.HeaderMatcher.newBuilder()
+                    .setName("authority")
+                    .setStringMatch(stringMatcherProto)
+                    .setInvertMatch(false)
+                    .build();
+    StructOrError<HeaderMatcher> struct = XdsRouteConfigureResource.parseHeaderMatcher(proto);
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct()).isEqualTo(
+            HeaderMatcher.forString("authority", Matchers.StringMatcher
+                    .forPrefix("service-foo", false), false));
+  }
+
+  @Test
+  public void parseRouteAction_withCluster() {
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setCluster("cluster-foo")
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+          ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct().cluster()).isEqualTo("cluster-foo");
+    assertThat(struct.getStruct().weightedClusters()).isNull();
+    assertThat(struct.getStruct().autoHostRewrite()).isFalse();
+  }
+
+  @Test
+  public void parseRouteAction_withCluster_autoHostRewriteEnabled() {
+    System.setProperty(GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE, "true");
+    try {
+      io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+          io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+              .setCluster("cluster-foo")
+              .setAutoHostRewrite(BoolValue.of(true))
+              .build();
+      StructOrError<RouteAction> struct =
+          XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+              ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+      assertThat(struct.getErrorDetail()).isNull();
+      assertThat(struct.getStruct().cluster()).isEqualTo("cluster-foo");
+      assertThat(struct.getStruct().weightedClusters()).isNull();
+      assertThat(struct.getStruct().autoHostRewrite()).isTrue();
+    } finally {
+      System.clearProperty(GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE);
+    }
+  }
+
+  @Test
+  public void parseRouteAction_withCluster_flagDisabled_autoHostRewriteNotEnabled() {
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setCluster("cluster-foo")
+            .setAutoHostRewrite(BoolValue.of(true))
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+            ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct().cluster()).isEqualTo("cluster-foo");
+    assertThat(struct.getStruct().weightedClusters()).isNull();
+    assertThat(struct.getStruct().autoHostRewrite()).isTrue();
+  }
+
+  @Test
+  public void parseRouteAction_withWeightedCluster() {
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setWeightedClusters(
+                WeightedCluster.newBuilder()
+                    .addClusters(
+                        WeightedCluster.ClusterWeight
+                            .newBuilder()
+                            .setName("cluster-foo")
+                            .setWeight(UInt32Value.newBuilder().setValue(30)))
+                    .addClusters(WeightedCluster.ClusterWeight
+                        .newBuilder()
+                        .setName("cluster-bar")
+                        .setWeight(UInt32Value.newBuilder().setValue(70))))
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+          ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct().cluster()).isNull();
+    assertThat(struct.getStruct().weightedClusters()).containsExactly(
+        ClusterWeight.create("cluster-foo", 30, ImmutableMap.<String, FilterConfig>of()),
+        ClusterWeight.create("cluster-bar", 70, ImmutableMap.<String, FilterConfig>of()));
+    assertThat(struct.getStruct().autoHostRewrite()).isFalse();
+  }
+
+  @Test
+  public void parseRouteAction_withWeightedCluster_autoHostRewriteEnabled() {
+    System.setProperty(GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE, "true");
+    try {
+      io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+          io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+              .setWeightedClusters(
+                  WeightedCluster.newBuilder()
+                      .addClusters(
+                          WeightedCluster.ClusterWeight
+                              .newBuilder()
+                              .setName("cluster-foo")
+                              .setWeight(UInt32Value.newBuilder().setValue(30)))
+                      .addClusters(WeightedCluster.ClusterWeight
+                          .newBuilder()
+                          .setName("cluster-bar")
+                          .setWeight(UInt32Value.newBuilder().setValue(70))))
+              .setAutoHostRewrite(BoolValue.of(true))
+              .build();
+      StructOrError<RouteAction> struct =
+          XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+              ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+      assertThat(struct.getErrorDetail()).isNull();
+      assertThat(struct.getStruct().cluster()).isNull();
+      assertThat(struct.getStruct().weightedClusters()).containsExactly(
+          ClusterWeight.create("cluster-foo", 30, ImmutableMap.<String, FilterConfig>of()),
+          ClusterWeight.create("cluster-bar", 70, ImmutableMap.<String, FilterConfig>of()));
+      assertThat(struct.getStruct().autoHostRewrite()).isTrue();
+    } finally {
+      System.clearProperty(GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE);
+    }
+  }
+
+  @Test
+  public void parseRouteAction_withWeightedCluster_flagDisabled_autoHostRewriteDisabled() {
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setWeightedClusters(
+                WeightedCluster.newBuilder()
+                    .addClusters(
+                        WeightedCluster.ClusterWeight
+                            .newBuilder()
+                            .setName("cluster-foo")
+                            .setWeight(UInt32Value.newBuilder().setValue(30)))
+                    .addClusters(WeightedCluster.ClusterWeight
+                        .newBuilder()
+                        .setName("cluster-bar")
+                        .setWeight(UInt32Value.newBuilder().setValue(70))))
+            .setAutoHostRewrite(BoolValue.of(true))
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+            ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct().cluster()).isNull();
+    assertThat(struct.getStruct().weightedClusters()).containsExactly(
+        ClusterWeight.create("cluster-foo", 30, ImmutableMap.<String, FilterConfig>of()),
+        ClusterWeight.create("cluster-bar", 70, ImmutableMap.<String, FilterConfig>of()));
+    assertThat(struct.getStruct().autoHostRewrite()).isTrue();
+  }
+
+  @Test
+  public void parseRouteAction_weightedClusterSum() {
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setWeightedClusters(
+                WeightedCluster.newBuilder()
+                    .addClusters(
+                        WeightedCluster.ClusterWeight
+                            .newBuilder()
+                            .setName("cluster-foo")
+                            .setWeight(UInt32Value.newBuilder().setValue(0)))
+                    .addClusters(WeightedCluster.ClusterWeight
+                        .newBuilder()
+                        .setName("cluster-bar")
+                        .setWeight(UInt32Value.newBuilder().setValue(0))))
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+            ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getErrorDetail()).isEqualTo("Sum of cluster weights should be above 0.");
+  }
+
+  @Test
+  public void parseRouteAction_withTimeoutByGrpcTimeoutHeaderMax() {
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setCluster("cluster-foo")
+            .setMaxStreamDuration(
+                MaxStreamDuration.newBuilder()
+                    .setGrpcTimeoutHeaderMax(Durations.fromSeconds(5L))
+                    .setMaxStreamDuration(Durations.fromMillis(20L)))
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+            ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getStruct().timeoutNano()).isEqualTo(TimeUnit.SECONDS.toNanos(5L));
+  }
+
+  @Test
+  public void parseRouteAction_withTimeoutByMaxStreamDuration() {
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setCluster("cluster-foo")
+            .setMaxStreamDuration(
+                MaxStreamDuration.newBuilder()
+                    .setMaxStreamDuration(Durations.fromSeconds(5L)))
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+           ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getStruct().timeoutNano()).isEqualTo(TimeUnit.SECONDS.toNanos(5L));
+  }
+
+  @Test
+  public void parseRouteAction_withTimeoutUnset() {
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setCluster("cluster-foo")
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+          ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getStruct().timeoutNano()).isNull();
+  }
+
+  @Test
+  public void parseRouteAction_withRetryPolicy() {
+    RetryPolicy.Builder builder = RetryPolicy.newBuilder()
+        .setNumRetries(UInt32Value.of(3))
+        .setRetryBackOff(
+            RetryBackOff.newBuilder()
+                .setBaseInterval(Durations.fromMillis(500))
+                .setMaxInterval(Durations.fromMillis(600)))
+        .setPerTryTimeout(Durations.fromMillis(300))
+        .setRetryOn(
+            "cancelled,deadline-exceeded,internal,resource-exhausted,unavailable");
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setCluster("cluster-foo")
+            .setRetryPolicy(builder.build())
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+          ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    RouteAction.RetryPolicy retryPolicy = struct.getStruct().retryPolicy();
+    assertThat(retryPolicy.maxAttempts()).isEqualTo(4);
+    assertThat(retryPolicy.initialBackoff()).isEqualTo(Durations.fromMillis(500));
+    assertThat(retryPolicy.maxBackoff()).isEqualTo(Durations.fromMillis(600));
+    // Not supporting per_try_timeout yet.
+    assertThat(retryPolicy.perAttemptRecvTimeout()).isEqualTo(null);
+    assertThat(retryPolicy.retryableStatusCodes()).containsExactly(
+        Code.CANCELLED, Code.DEADLINE_EXCEEDED, Code.INTERNAL, Code.RESOURCE_EXHAUSTED,
+        Code.UNAVAILABLE);
+
+    // empty retry_on
+    builder = RetryPolicy.newBuilder()
+        .setNumRetries(UInt32Value.of(3))
+        .setRetryBackOff(
+            RetryBackOff.newBuilder()
+                .setBaseInterval(Durations.fromMillis(500))
+                .setMaxInterval(Durations.fromMillis(600)))
+        .setPerTryTimeout(Durations.fromMillis(300)); // Not supporting per_try_timeout yet.
+    proto = io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+        .setCluster("cluster-foo")
+        .setRetryPolicy(builder.build())
+        .build();
+    struct = XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+        ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getStruct().retryPolicy()).isNotNull();
+    assertThat(struct.getStruct().retryPolicy().retryableStatusCodes()).isEmpty();
+
+    // base_interval unset
+    builder
+        .setRetryOn("cancelled")
+        .setRetryBackOff(RetryBackOff.newBuilder().setMaxInterval(Durations.fromMillis(600)));
+    proto = io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+        .setCluster("cluster-foo")
+        .setRetryPolicy(builder)
+        .build();
+    struct = XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+        ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getErrorDetail()).isEqualTo("No base_interval specified in retry_backoff");
+
+    // max_interval unset
+    builder.setRetryBackOff(RetryBackOff.newBuilder().setBaseInterval(Durations.fromMillis(500)));
+    proto = io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+        .setCluster("cluster-foo")
+        .setRetryPolicy(builder)
+        .build();
+    struct = XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+        ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    retryPolicy = struct.getStruct().retryPolicy();
+    assertThat(retryPolicy.maxBackoff()).isEqualTo(Durations.fromMillis(500 * 10));
+
+    // base_interval < 0
+    builder.setRetryBackOff(RetryBackOff.newBuilder().setBaseInterval(Durations.fromMillis(-1)));
+    proto = io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+        .setCluster("cluster-foo")
+        .setRetryPolicy(builder)
+        .build();
+    struct = XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+        ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getErrorDetail())
+        .isEqualTo("base_interval in retry_backoff must be positive");
+
+    // base_interval > max_interval > 1ms
+    builder.setRetryBackOff(
+        RetryBackOff.newBuilder()
+            .setBaseInterval(Durations.fromMillis(200)).setMaxInterval(Durations.fromMillis(100)));
+    proto = io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+        .setCluster("cluster-foo")
+        .setRetryPolicy(builder)
+        .build();
+    struct = XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+        ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getErrorDetail())
+        .isEqualTo("max_interval in retry_backoff cannot be less than base_interval");
+
+    // 1ms > base_interval > max_interval
+    builder.setRetryBackOff(
+        RetryBackOff.newBuilder()
+            .setBaseInterval(Durations.fromNanos(200)).setMaxInterval(Durations.fromNanos(100)));
+    proto = io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+        .setCluster("cluster-foo")
+        .setRetryPolicy(builder)
+        .build();
+    struct = XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+        ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getErrorDetail())
+        .isEqualTo("max_interval in retry_backoff cannot be less than base_interval");
+
+    // 1ms > max_interval > base_interval
+    builder.setRetryBackOff(
+        RetryBackOff.newBuilder()
+            .setBaseInterval(Durations.fromNanos(100)).setMaxInterval(Durations.fromNanos(200)));
+    proto = io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+        .setCluster("cluster-foo")
+        .setRetryPolicy(builder)
+        .build();
+    struct = XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+        ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getStruct().retryPolicy().initialBackoff())
+        .isEqualTo(Durations.fromMillis(1));
+    assertThat(struct.getStruct().retryPolicy().maxBackoff())
+        .isEqualTo(Durations.fromMillis(1));
+
+    // retry_backoff unset
+    builder = RetryPolicy.newBuilder()
+        .setNumRetries(UInt32Value.of(3))
+        .setPerTryTimeout(Durations.fromMillis(300))
+        .setRetryOn("cancelled");
+    proto = io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+        .setCluster("cluster-foo")
+        .setRetryPolicy(builder)
+        .build();
+    struct = XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+        ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    retryPolicy = struct.getStruct().retryPolicy();
+    assertThat(retryPolicy.initialBackoff()).isEqualTo(Durations.fromMillis(25));
+    assertThat(retryPolicy.maxBackoff()).isEqualTo(Durations.fromMillis(250));
+
+    // unsupported retry_on value
+    builder = RetryPolicy.newBuilder()
+        .setNumRetries(UInt32Value.of(3))
+        .setRetryBackOff(
+            RetryBackOff.newBuilder()
+                .setBaseInterval(Durations.fromMillis(500))
+                .setMaxInterval(Durations.fromMillis(600)))
+        .setPerTryTimeout(Durations.fromMillis(300))
+        .setRetryOn("cancelled,unsupported-foo");
+    proto = io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+        .setCluster("cluster-foo")
+        .setRetryPolicy(builder)
+        .build();
+    struct = XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+        ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getStruct().retryPolicy().retryableStatusCodes())
+        .containsExactly(Code.CANCELLED);
+
+    // unsupported retry_on code
+    builder = RetryPolicy.newBuilder()
+        .setNumRetries(UInt32Value.of(3))
+        .setRetryBackOff(
+            RetryBackOff.newBuilder()
+                .setBaseInterval(Durations.fromMillis(500))
+                .setMaxInterval(Durations.fromMillis(600)))
+        .setPerTryTimeout(Durations.fromMillis(300))
+        .setRetryOn("cancelled,abort");
+    proto = io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+        .setCluster("cluster-foo")
+        .setRetryPolicy(builder)
+        .build();
+    struct = XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+        ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getStruct().retryPolicy().retryableStatusCodes())
+        .containsExactly(Code.CANCELLED);
+
+    // whitespace in retry_on
+    builder = RetryPolicy.newBuilder()
+        .setNumRetries(UInt32Value.of(3))
+        .setRetryBackOff(
+            RetryBackOff.newBuilder()
+                .setBaseInterval(Durations.fromMillis(500))
+                .setMaxInterval(Durations.fromMillis(600)))
+        .setPerTryTimeout(Durations.fromMillis(300))
+        .setRetryOn("abort, , cancelled , ");
+    proto = io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+        .setCluster("cluster-foo")
+        .setRetryPolicy(builder)
+        .build();
+    struct = XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+        ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct.getStruct().retryPolicy().retryableStatusCodes())
+        .containsExactly(Code.CANCELLED);
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void parseRouteAction_withHashPolicies() {
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setCluster("cluster-foo")
+            .addHashPolicy(
+                io.envoyproxy.envoy.config.route.v3.RouteAction.HashPolicy.newBuilder()
+                    .setHeader(
+                        Header.newBuilder()
+                            .setHeaderName("user-agent")
+                            .setRegexRewrite(
+                                RegexMatchAndSubstitute.newBuilder()
+                                    .setPattern(
+                                        RegexMatcher.newBuilder()
+                                            .setGoogleRe2(GoogleRE2.getDefaultInstance())
+                                            .setRegex("grpc.*"))
+                                    .setSubstitution("gRPC"))))
+            .addHashPolicy(
+                io.envoyproxy.envoy.config.route.v3.RouteAction.HashPolicy.newBuilder()
+                    .setConnectionProperties(ConnectionProperties.newBuilder().setSourceIp(true))
+                    .setTerminal(true))  // unsupported
+            .addHashPolicy(
+                io.envoyproxy.envoy.config.route.v3.RouteAction.HashPolicy.newBuilder()
+                    .setFilterState(
+                        FilterState.newBuilder()
+                            .setKey(XdsRouteConfigureResource.HASH_POLICY_FILTER_STATE_KEY)))
+            .addHashPolicy(
+                io.envoyproxy.envoy.config.route.v3.RouteAction.HashPolicy.newBuilder()
+                    .setQueryParameter(
+                        QueryParameter.newBuilder().setName("param"))) // unsupported
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+            ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    List<HashPolicy> policies = struct.getStruct().hashPolicies();
+    assertThat(policies).hasSize(2);
+    assertThat(policies.get(0).type()).isEqualTo(HashPolicy.Type.HEADER);
+    assertThat(policies.get(0).headerName()).isEqualTo("user-agent");
+    assertThat(policies.get(0).isTerminal()).isFalse();
+    assertThat(policies.get(0).regEx().pattern()).isEqualTo("grpc.*");
+    assertThat(policies.get(0).regExSubstitution()).isEqualTo("gRPC");
+
+    assertThat(policies.get(1).type()).isEqualTo(HashPolicy.Type.CHANNEL_ID);
+    assertThat(policies.get(1).isTerminal()).isFalse();
+  }
+
+  @Test
+  public void parseRouteAction_custerSpecifierNotSet() {
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+            ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct).isNull();
+  }
+
+  @Test
+  public void parseRouteAction_clusterSpecifier_routeLookupDisabled() {
+    XdsRouteConfigureResource.enableRouteLookup = false;
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setClusterSpecifierPlugin(CLUSTER_SPECIFIER_PLUGIN.name())
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+            ImmutableMap.of(), ImmutableSet.of(), getXdsResourceTypeArgs(true));
+    assertThat(struct).isNull();
+  }
+
+  @Test
+  public void parseRouteAction_clusterSpecifier() {
+    XdsRouteConfigureResource.enableRouteLookup = true;
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setClusterSpecifierPlugin(CLUSTER_SPECIFIER_PLUGIN.name())
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+            ImmutableMap.of(CLUSTER_SPECIFIER_PLUGIN.name(), RlsPluginConfig.create(
+                ImmutableMap.of("lookupService", "rls-cbt.googleapis.com"))), ImmutableSet.of(),
+                getXdsResourceTypeArgs(true));
+    assertThat(struct.getStruct()).isNotNull();
+    assertThat(struct.getStruct().autoHostRewrite()).isFalse();
+  }
+
+  @Test
+  public void parseRouteAction_clusterSpecifier_autoHostRewriteEnabled() {
+    System.setProperty(GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE, "true");
+    try {
+      XdsRouteConfigureResource.enableRouteLookup = true;
+      io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+          io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+              .setClusterSpecifierPlugin(CLUSTER_SPECIFIER_PLUGIN.name())
+              .setAutoHostRewrite(BoolValue.of(true))
+              .build();
+      StructOrError<RouteAction> struct =
+          XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+              ImmutableMap.of(CLUSTER_SPECIFIER_PLUGIN.name(), RlsPluginConfig.create(
+                  ImmutableMap.of("lookupService", "rls-cbt.googleapis.com"))), ImmutableSet.of(),
+              getXdsResourceTypeArgs(true));
+      assertThat(struct.getStruct()).isNotNull();
+      assertThat(struct.getStruct().autoHostRewrite()).isTrue();
+    } finally {
+      System.clearProperty(GRPC_EXPERIMENTAL_XDS_AUTHORITY_REWRITE);
+    }
+  }
+
+  @Test
+  public void parseRouteAction_clusterSpecifier_flagDisabled_autoHostRewriteDisabled() {
+    XdsRouteConfigureResource.enableRouteLookup = true;
+    io.envoyproxy.envoy.config.route.v3.RouteAction proto =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setClusterSpecifierPlugin(CLUSTER_SPECIFIER_PLUGIN.name())
+            .setAutoHostRewrite(BoolValue.of(true))
+            .build();
+    StructOrError<RouteAction> struct =
+        XdsRouteConfigureResource.parseRouteAction(proto, filterRegistry,
+            ImmutableMap.of(CLUSTER_SPECIFIER_PLUGIN.name(), RlsPluginConfig.create(
+                ImmutableMap.of("lookupService", "rls-cbt.googleapis.com"))), ImmutableSet.of(),
+            getXdsResourceTypeArgs(true));
+    assertThat(struct.getStruct()).isNotNull();
+    assertThat(struct.getStruct().autoHostRewrite()).isTrue();
+  }
+
+  @Test
+  public void parseClusterWeight() {
+    io.envoyproxy.envoy.config.route.v3.WeightedCluster.ClusterWeight proto =
+        io.envoyproxy.envoy.config.route.v3.WeightedCluster.ClusterWeight.newBuilder()
+            .setName("cluster-foo")
+            .setWeight(UInt32Value.newBuilder().setValue(30))
+            .build();
+    ClusterWeight clusterWeight =
+        XdsRouteConfigureResource.parseClusterWeight(proto, filterRegistry).getStruct();
+    assertThat(clusterWeight.name()).isEqualTo("cluster-foo");
+    assertThat(clusterWeight.weight()).isEqualTo(30);
+  }
+
+  @Test
+  public void parseLocalityLbEndpoints_withHealthyEndpoints() throws ResourceInvalidException {
+    io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints proto =
+        io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints.newBuilder()
+            .setLocality(Locality.newBuilder()
+                .setRegion("region-foo").setZone("zone-foo").setSubZone("subZone-foo"))
+            .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(100))  // locality weight
+            .setPriority(1)
+            .addLbEndpoints(io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint.newBuilder()
+                .setEndpoint(Endpoint.newBuilder()
+                    .setAddress(Address.newBuilder()
+                        .setSocketAddress(
+                            SocketAddress.newBuilder()
+                                .setAddress("172.14.14.5").setPortValue(8888))))
+                .setHealthStatus(io.envoyproxy.envoy.config.core.v3.HealthStatus.HEALTHY)
+                .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(20)))  // endpoint weight
+            .build();
+    StructOrError<LocalityLbEndpoints> struct = XdsEndpointResource.parseLocalityLbEndpoints(proto);
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct()).isEqualTo(
+        LocalityLbEndpoints.create(
+            Collections.singletonList(LbEndpoint.create("172.14.14.5", 8888,
+                20, true, "", ImmutableMap.of())),
+            100, 1, ImmutableMap.of()));
+  }
+
+  @Test
+  public void parseLocalityLbEndpoints_onlyPermitIp() {
+    io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints proto =
+        io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints.newBuilder()
+            .setLocality(Locality.newBuilder()
+                .setRegion("region-foo").setZone("zone-foo").setSubZone("subZone-foo"))
+            .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(100))  // locality weight
+            .setPriority(1)
+            .addLbEndpoints(io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint.newBuilder()
+                .setEndpoint(Endpoint.newBuilder()
+                    .setAddress(Address.newBuilder()
+                        .setSocketAddress(
+                            SocketAddress.newBuilder()
+                                .setAddress("example.com").setPortValue(8888))))
+                .setHealthStatus(io.envoyproxy.envoy.config.core.v3.HealthStatus.HEALTHY)
+                .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(20)))  // endpoint weight
+            .build();
+    ResourceInvalidException ex = assertThrows(
+        ResourceInvalidException.class,
+        () -> XdsEndpointResource.parseLocalityLbEndpoints(proto));
+    assertThat(ex.getMessage()).contains("IP");
+    assertThat(ex.getMessage()).contains("example.com");
+  }
+
+  @Test
+  public void parseLocalityLbEndpoints_treatUnknownHealthAsHealthy()
+      throws ResourceInvalidException {
+    io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints proto =
+        io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints.newBuilder()
+            .setLocality(Locality.newBuilder()
+                .setRegion("region-foo").setZone("zone-foo").setSubZone("subZone-foo"))
+            .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(100))  // locality weight
+            .setPriority(1)
+            .addLbEndpoints(io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint.newBuilder()
+                .setEndpoint(Endpoint.newBuilder()
+                    .setAddress(Address.newBuilder()
+                        .setSocketAddress(
+                            SocketAddress.newBuilder()
+                                .setAddress("172.14.14.5").setPortValue(8888))))
+                .setHealthStatus(io.envoyproxy.envoy.config.core.v3.HealthStatus.UNKNOWN)
+                .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(20)))  // endpoint weight
+            .build();
+    StructOrError<LocalityLbEndpoints> struct = XdsEndpointResource.parseLocalityLbEndpoints(proto);
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct()).isEqualTo(
+        LocalityLbEndpoints.create(
+            Collections.singletonList(LbEndpoint.create("172.14.14.5", 8888,
+                20, true, "", ImmutableMap.of())),
+            100, 1, ImmutableMap.of()));
+  }
+
+  @Test
+  public void parseLocalityLbEndpoints_withUnHealthyEndpoints() throws ResourceInvalidException {
+    io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints proto =
+        io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints.newBuilder()
+            .setLocality(Locality.newBuilder()
+                .setRegion("region-foo").setZone("zone-foo").setSubZone("subZone-foo"))
+            .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(100))  // locality weight
+            .setPriority(1)
+            .addLbEndpoints(io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint.newBuilder()
+                .setEndpoint(Endpoint.newBuilder()
+                    .setAddress(Address.newBuilder()
+                        .setSocketAddress(
+                            SocketAddress.newBuilder()
+                                .setAddress("172.14.14.5").setPortValue(8888))))
+                .setHealthStatus(io.envoyproxy.envoy.config.core.v3.HealthStatus.UNHEALTHY)
+                .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(20)))  // endpoint weight
+            .build();
+    StructOrError<LocalityLbEndpoints> struct = XdsEndpointResource.parseLocalityLbEndpoints(proto);
+    assertThat(struct.getErrorDetail()).isNull();
+    assertThat(struct.getStruct()).isEqualTo(
+        LocalityLbEndpoints.create(
+            Collections.singletonList(LbEndpoint.create("172.14.14.5", 8888, 20,
+                false, "", ImmutableMap.of())),
+            100, 1, ImmutableMap.of()));
+  }
+
+  @Test
+  public void parseLocalityLbEndpoints_ignorZeroWeightLocality() throws ResourceInvalidException {
+    io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints proto =
+        io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints.newBuilder()
+            .setLocality(Locality.newBuilder()
+                .setRegion("region-foo").setZone("zone-foo").setSubZone("subZone-foo"))
+            .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(0))  // locality weight
+            .setPriority(1)
+            .addLbEndpoints(io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint.newBuilder()
+                .setEndpoint(Endpoint.newBuilder()
+                    .setAddress(Address.newBuilder()
+                        .setSocketAddress(
+                            SocketAddress.newBuilder()
+                                .setAddress("172.14.14.5").setPortValue(8888))))
+                .setHealthStatus(io.envoyproxy.envoy.config.core.v3.HealthStatus.UNKNOWN)
+                .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(20)))  // endpoint weight
+            .build();
+    assertThat(XdsEndpointResource.parseLocalityLbEndpoints(proto)).isNull();
+  }
+
+  @Test
+  public void parseLocalityLbEndpoints_withDualStackEndpoints() {
+    String originalDualStackProp =
+        System.setProperty(GRPC_EXPERIMENTAL_XDS_DUALSTACK_ENDPOINTS, "true");
+    String v4Address = "172.14.14.5";
+    String v6Address = "2001:db8::1";
+    int port = 8888;
+
+    try {
+      io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints proto =
+          io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints.newBuilder()
+              .setLocality(Locality.newBuilder()
+                  .setRegion("region-foo").setZone("zone-foo").setSubZone("subZone-foo"))
+              .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(100))  // locality weight
+              .setPriority(1)
+              .addLbEndpoints(io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint.newBuilder()
+                  .setEndpoint(Endpoint.newBuilder()
+                      .setAddress(Address.newBuilder()
+                          .setSocketAddress(
+                              SocketAddress.newBuilder()
+                                  .setAddress(v4Address).setPortValue(port)))
+                      .addAdditionalAddresses(Endpoint.AdditionalAddress.newBuilder()
+                          .setAddress(Address.newBuilder()
+                              .setSocketAddress(
+                                  SocketAddress.newBuilder()
+                                      .setAddress(v6Address).setPortValue(port)))))
+                  .setHealthStatus(io.envoyproxy.envoy.config.core.v3.HealthStatus.HEALTHY)
+                  .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(20)))
+              .build();
+
+      StructOrError<LocalityLbEndpoints> struct =
+          XdsEndpointResource.parseLocalityLbEndpoints(proto);
+      assertThat(struct.getErrorDetail()).isNull();
+      List<java.net.SocketAddress> socketAddressList = Arrays.asList(
+          new InetSocketAddress(v4Address, port), new InetSocketAddress(v6Address, port));
+      EquivalentAddressGroup expectedEag = new EquivalentAddressGroup(socketAddressList);
+      assertThat(struct.getStruct()).isEqualTo(
+          LocalityLbEndpoints.create(
+              Collections.singletonList(LbEndpoint.create(
+                  expectedEag, 20, true, "", ImmutableMap.of())), 100, 1, ImmutableMap.of()));
+    } catch (ResourceInvalidException e) {
+      throw new RuntimeException(e);
+    } finally {
+      if (originalDualStackProp != null) {
+        System.setProperty(GRPC_EXPERIMENTAL_XDS_DUALSTACK_ENDPOINTS, originalDualStackProp);
+      } else {
+        System.clearProperty(GRPC_EXPERIMENTAL_XDS_DUALSTACK_ENDPOINTS);
+      }
+    }
+  }
+
+  @Test
+  public void parseLocalityLbEndpoints_invalidPriority() throws ResourceInvalidException {
+    io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints proto =
+        io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints.newBuilder()
+            .setLocality(Locality.newBuilder()
+                .setRegion("region-foo").setZone("zone-foo").setSubZone("subZone-foo"))
+            .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(100))  // locality weight
+            .setPriority(-1)
+            .addLbEndpoints(io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint.newBuilder()
+                .setEndpoint(Endpoint.newBuilder()
+                    .setAddress(Address.newBuilder()
+                        .setSocketAddress(
+                            SocketAddress.newBuilder()
+                                .setAddress("172.14.14.5").setPortValue(8888))))
+                .setHealthStatus(io.envoyproxy.envoy.config.core.v3.HealthStatus.UNKNOWN)
+                .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(20)))  // endpoint weight
+            .build();
+    StructOrError<LocalityLbEndpoints> struct = XdsEndpointResource.parseLocalityLbEndpoints(proto);
+    assertThat(struct.getErrorDetail()).isEqualTo("negative priority");
+  }
+
+  @Test
+  public void parseHttpFilter_unsupportedButOptional() {
+    HttpFilter httpFilter = HttpFilter.newBuilder()
+        .setIsOptional(true)
+        .setTypedConfig(Any.pack(StringValue.of("unsupported")))
+        .build();
+    assertThat(XdsListenerResource.parseHttpFilter(httpFilter, filterRegistry, true)).isNull();
+  }
+
+  private static class SimpleFilterConfig implements FilterConfig {
+    private final Message message;
+
+    public SimpleFilterConfig(Message rawProtoMessage) {
+      message = rawProtoMessage;
+    }
+
+    public Message getConfig() {
+      return message;
+    }
+
+    @Override
+    public String typeUrl() {
+      return null;
+    }
+  }
+
+  private static class TestFilter implements io.grpc.xds.Filter {
+
+    static final class Provider implements io.grpc.xds.Filter.Provider {
+      @Override
+      public String[] typeUrls() {
+        return new String[]{"test-url"};
+      }
+
+      @Override
+      public boolean isClientFilter() {
+        return true;
+      }
+
+      @Override
+      public TestFilter newInstance(String name) {
+        return new TestFilter();
+      }
+
+      @Override
+      public ConfigOrError<SimpleFilterConfig> parseFilterConfig(Message rawProtoMessage) {
+        return ConfigOrError.fromConfig(new SimpleFilterConfig(rawProtoMessage));
+      }
+
+      @Override
+      public ConfigOrError<SimpleFilterConfig> parseFilterConfigOverride(Message rawProtoMessage) {
+        return ConfigOrError.fromConfig(new SimpleFilterConfig(rawProtoMessage));
+      }
+    }
+  }
+
+  @Test
+  public void parseHttpFilter_typedStructMigration() {
+    filterRegistry.register(new TestFilter.Provider());
+    Struct rawStruct = Struct.newBuilder()
+        .putFields("name", Value.newBuilder().setStringValue("default").build())
+        .build();
+    HttpFilter httpFilter = HttpFilter.newBuilder()
+        .setIsOptional(true)
+        .setTypedConfig(Any.pack(
+            com.github.udpa.udpa.type.v1.TypedStruct.newBuilder()
+                .setTypeUrl("test-url")
+                .setValue(rawStruct)
+        .build())).build();
+    FilterConfig config = XdsListenerResource.parseHttpFilter(httpFilter, filterRegistry,
+        true).getStruct();
+    assertThat(((SimpleFilterConfig)config).getConfig()).isEqualTo(rawStruct);
+
+    HttpFilter httpFilterNewTypeStruct = HttpFilter.newBuilder()
+        .setIsOptional(true)
+        .setTypedConfig(Any.pack(
+            TypedStruct.newBuilder()
+                .setTypeUrl("test-url")
+                .setValue(rawStruct)
+                .build())).build();
+    config = XdsListenerResource.parseHttpFilter(httpFilterNewTypeStruct, filterRegistry,
+        true).getStruct();
+    assertThat(((SimpleFilterConfig)config).getConfig()).isEqualTo(rawStruct);
+  }
+
+  @Test
+  public void parseOverrideHttpFilter_typedStructMigration() {
+    filterRegistry.register(new TestFilter.Provider());
+    Struct rawStruct0 = Struct.newBuilder()
+        .putFields("name", Value.newBuilder().setStringValue("default0").build())
+        .build();
+    Struct rawStruct1 = Struct.newBuilder()
+        .putFields("name", Value.newBuilder().setStringValue("default1").build())
+        .build();
+    Map<String, Any> rawFilterMap = ImmutableMap.of(
+        "struct-0", Any.pack(
+            com.github.udpa.udpa.type.v1.TypedStruct.newBuilder()
+                .setTypeUrl("test-url")
+                .setValue(rawStruct0)
+                .build()),
+          "struct-1", Any.pack(
+              TypedStruct.newBuilder()
+                  .setTypeUrl("test-url")
+                  .setValue(rawStruct1)
+                  .build())
+    );
+    Map<String, FilterConfig> map = XdsRouteConfigureResource.parseOverrideFilterConfigs(
+        rawFilterMap, filterRegistry).getStruct();
+    assertThat(((SimpleFilterConfig)map.get("struct-0")).getConfig()).isEqualTo(rawStruct0);
+    assertThat(((SimpleFilterConfig)map.get("struct-1")).getConfig()).isEqualTo(rawStruct1);
+  }
+
+  @Test
+  public void parseHttpFilter_unsupportedAndRequired() {
+    HttpFilter httpFilter = HttpFilter.newBuilder()
+        .setIsOptional(false)
+        .setName("unsupported.filter")
+        .setTypedConfig(Any.pack(StringValue.of("string value")))
+        .build();
+    assertThat(XdsListenerResource.parseHttpFilter(httpFilter, filterRegistry, true)
+        .getErrorDetail()).isEqualTo(
+            "HttpFilter [unsupported.filter]"
+                + "(type.googleapis.com/google.protobuf.StringValue) is required but unsupported "
+                + "for client");
+  }
+
+  @Test
+  public void parseHttpFilter_routerFilterForClient() {
+    filterRegistry.register(ROUTER_FILTER_PROVIDER);
+    HttpFilter httpFilter =
+        HttpFilter.newBuilder()
+            .setIsOptional(false)
+            .setName("envoy.router")
+            .setTypedConfig(Any.pack(Router.getDefaultInstance()))
+            .build();
+    FilterConfig config = XdsListenerResource.parseHttpFilter(
+        httpFilter, filterRegistry, true /* isForClient */).getStruct();
+    assertThat(config.typeUrl()).isEqualTo(RouterFilter.TYPE_URL);
+  }
+
+  @Test
+  public void parseHttpFilter_routerFilterForServer() {
+    filterRegistry.register(ROUTER_FILTER_PROVIDER);
+    HttpFilter httpFilter =
+        HttpFilter.newBuilder()
+            .setIsOptional(false)
+            .setName("envoy.router")
+            .setTypedConfig(Any.pack(Router.getDefaultInstance()))
+            .build();
+    FilterConfig config = XdsListenerResource.parseHttpFilter(
+        httpFilter, filterRegistry, false /* isForClient */).getStruct();
+    assertThat(config.typeUrl()).isEqualTo(RouterFilter.TYPE_URL);
+  }
+
+  @Test
+  public void parseHttpFilter_faultConfigForClient() {
+    filterRegistry.register(FAULT_FILTER_PROVIDER);
+    HttpFilter httpFilter =
+        HttpFilter.newBuilder()
+            .setIsOptional(false)
+            .setName("envoy.fault")
+            .setTypedConfig(
+                Any.pack(
+                    HTTPFault.newBuilder()
+                        .setDelay(
+                            FaultDelay.newBuilder()
+                                .setFixedDelay(Durations.fromNanos(1234L)))
+                        .setAbort(
+                            FaultAbort.newBuilder()
+                                .setHttpStatus(300)
+                                .setPercentage(
+                                    FractionalPercent.newBuilder()
+                                        .setNumerator(10)
+                                        .setDenominator(DenominatorType.HUNDRED)))
+                        .build()))
+            .build();
+    FilterConfig config = XdsListenerResource.parseHttpFilter(
+        httpFilter, filterRegistry, true /* isForClient */).getStruct();
+    assertThat(config).isInstanceOf(FaultConfig.class);
+  }
+
+  @Test
+  public void parseHttpFilter_faultConfigUnsupportedForServer() {
+    filterRegistry.register(FAULT_FILTER_PROVIDER);
+    HttpFilter httpFilter =
+        HttpFilter.newBuilder()
+            .setIsOptional(false)
+            .setName("envoy.fault")
+            .setTypedConfig(
+                Any.pack(
+                    HTTPFault.newBuilder()
+                        .setDelay(
+                            FaultDelay.newBuilder()
+                                .setFixedDelay(Durations.fromNanos(1234L)))
+                        .setAbort(
+                            FaultAbort.newBuilder()
+                                .setHttpStatus(300)
+                                .setPercentage(
+                                    FractionalPercent.newBuilder()
+                                        .setNumerator(10)
+                                        .setDenominator(DenominatorType.HUNDRED)))
+                        .build()))
+            .build();
+    StructOrError<FilterConfig> config =
+        XdsListenerResource.parseHttpFilter(httpFilter, filterRegistry, false /* isForClient */);
+    assertThat(config.getErrorDetail()).isEqualTo(
+        "HttpFilter [envoy.fault](" + FaultFilter.TYPE_URL + ") is required but "
+            + "unsupported for server");
+  }
+
+  @Test
+  public void parseHttpFilter_rbacConfigForServer() {
+    filterRegistry.register(RBAC_FILTER_PROVIDER);
+    HttpFilter httpFilter =
+        HttpFilter.newBuilder()
+            .setIsOptional(false)
+            .setName("envoy.auth")
+            .setTypedConfig(
+                Any.pack(
+                    io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBAC.newBuilder()
+                        .setRules(
+                            RBAC.newBuilder()
+                                .setAction(Action.ALLOW)
+                                .putPolicies(
+                                    "allow-all",
+                                    Policy.newBuilder()
+                                        .addPrincipals(Principal.newBuilder().setAny(true))
+                                        .addPermissions(Permission.newBuilder().setAny(true))
+                                        .build())
+                                .build())
+                        .build()))
+            .build();
+    FilterConfig config = XdsListenerResource.parseHttpFilter(
+        httpFilter, filterRegistry, false /* isForClient */).getStruct();
+    assertThat(config).isInstanceOf(RbacConfig.class);
+  }
+
+  @Test
+  public void parseHttpFilter_rbacConfigUnsupportedForClient() {
+    filterRegistry.register(RBAC_FILTER_PROVIDER);
+    HttpFilter httpFilter =
+        HttpFilter.newBuilder()
+            .setIsOptional(false)
+            .setName("envoy.auth")
+            .setTypedConfig(
+                Any.pack(
+                    io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBAC.newBuilder()
+                        .setRules(
+                            RBAC.newBuilder()
+                                .setAction(Action.ALLOW)
+                                .putPolicies(
+                                    "allow-all",
+                                    Policy.newBuilder()
+                                        .addPrincipals(Principal.newBuilder().setAny(true))
+                                        .addPermissions(Permission.newBuilder().setAny(true))
+                                        .build())
+                                .build())
+                        .build()))
+            .build();
+    StructOrError<FilterConfig> config =
+        XdsListenerResource.parseHttpFilter(httpFilter, filterRegistry, true /* isForClient */);
+    assertThat(config.getErrorDetail()).isEqualTo(
+        "HttpFilter [envoy.auth](" + RbacFilter.TYPE_URL + ") is required but "
+            + "unsupported for client");
+  }
+
+  @Test
+  public void parseOverrideRbacFilterConfig() {
+    filterRegistry.register(RBAC_FILTER_PROVIDER);
+    RBACPerRoute rbacPerRoute =
+        RBACPerRoute.newBuilder()
+            .setRbac(
+                io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBAC.newBuilder()
+                    .setRules(
+                        RBAC.newBuilder()
+                            .setAction(Action.ALLOW)
+                            .putPolicies(
+                                "allow-all",
+                                Policy.newBuilder()
+                                    .addPrincipals(Principal.newBuilder().setAny(true))
+                                    .addPermissions(Permission.newBuilder().setAny(true))
+                            .build())))
+            .build();
+    Map<String, Any> configOverrides = ImmutableMap.of("envoy.auth", Any.pack(rbacPerRoute));
+    Map<String, FilterConfig> parsedConfigs =
+        XdsRouteConfigureResource.parseOverrideFilterConfigs(configOverrides, filterRegistry)
+            .getStruct();
+    assertThat(parsedConfigs).hasSize(1);
+    assertThat(parsedConfigs).containsKey("envoy.auth");
+    assertThat(parsedConfigs.get("envoy.auth")).isInstanceOf(RbacConfig.class);
+  }
+
+  @Test
+  public void parseOverrideFilterConfigs_unsupportedButOptional() {
+    filterRegistry.register(FAULT_FILTER_PROVIDER);
+    HTTPFault httpFault = HTTPFault.newBuilder()
+        .setDelay(FaultDelay.newBuilder().setFixedDelay(Durations.fromNanos(3000)))
+        .build();
+    Map<String, Any> configOverrides = ImmutableMap.of(
+        "envoy.fault",
+        Any.pack(httpFault),
+        "unsupported.filter",
+        Any.pack(io.envoyproxy.envoy.config.route.v3.FilterConfig.newBuilder()
+            .setIsOptional(true).setConfig(Any.pack(StringValue.of("string value")))
+            .build()));
+    Map<String, FilterConfig> parsedConfigs =
+        XdsRouteConfigureResource.parseOverrideFilterConfigs(configOverrides, filterRegistry)
+            .getStruct();
+    assertThat(parsedConfigs).hasSize(1);
+    assertThat(parsedConfigs).containsKey("envoy.fault");
+  }
+
+  @Test
+  public void parseOverrideFilterConfigs_unsupportedAndRequired() {
+    filterRegistry.register(FAULT_FILTER_PROVIDER);
+    HTTPFault httpFault = HTTPFault.newBuilder()
+        .setDelay(FaultDelay.newBuilder().setFixedDelay(Durations.fromNanos(3000)))
+        .build();
+    Map<String, Any> configOverrides = ImmutableMap.of(
+        "envoy.fault",
+        Any.pack(httpFault),
+        "unsupported.filter",
+        Any.pack(io.envoyproxy.envoy.config.route.v3.FilterConfig.newBuilder()
+            .setIsOptional(false).setConfig(Any.pack(StringValue.of("string value")))
+            .build()));
+    assertThat(XdsRouteConfigureResource.parseOverrideFilterConfigs(configOverrides, filterRegistry)
+        .getErrorDetail()).isEqualTo(
+            "HttpFilter [unsupported.filter]"
+                + "(type.googleapis.com/google.protobuf.StringValue) is required but unsupported");
+
+    configOverrides = ImmutableMap.of(
+        "envoy.fault",
+        Any.pack(httpFault),
+        "unsupported.filter",
+        Any.pack(StringValue.of("string value")));
+    assertThat(XdsRouteConfigureResource.parseOverrideFilterConfigs(configOverrides, filterRegistry)
+        .getErrorDetail()).isEqualTo(
+            "HttpFilter [unsupported.filter]"
+                + "(type.googleapis.com/google.protobuf.StringValue) is required but unsupported");
+  }
+
+  @Test
+  public void parseHttpConnectionManager_xffNumTrustedHopsUnsupported()
+      throws ResourceInvalidException {
+    @SuppressWarnings("deprecation")
+    HttpConnectionManager hcm = HttpConnectionManager.newBuilder().setXffNumTrustedHops(2).build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class,
+        () -> XdsListenerResource.parseHttpConnectionManager(
+            hcm, filterRegistry,
+            true /* does not matter */, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("HttpConnectionManager with xff_num_trusted_hops unsupported");
+  }
+
+  @Test
+  public void parseHttpConnectionManager_OriginalIpDetectionExtensionsMustEmpty()
+      throws ResourceInvalidException {
+    @SuppressWarnings("deprecation")
+    HttpConnectionManager hcm = HttpConnectionManager.newBuilder()
+        .addOriginalIpDetectionExtensions(TypedExtensionConfig.newBuilder().build())
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseHttpConnectionManager(
+            hcm, filterRegistry, false, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("HttpConnectionManager with original_ip_detection_extensions unsupported");
+  }
+
+  @Test
+  public void parseHttpConnectionManager_missingRdsAndInlinedRouteConfiguration()
+      throws ResourceInvalidException {
+    HttpConnectionManager hcm =
+        HttpConnectionManager.newBuilder()
+            .setCommonHttpProtocolOptions(
+                HttpProtocolOptions.newBuilder()
+                    .setMaxStreamDuration(Durations.fromNanos(1000L)))
+            .addHttpFilters(
+                HttpFilter.newBuilder().setName("terminal").setTypedConfig(
+                    Any.pack(Router.newBuilder().build())).setIsOptional(true))
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseHttpConnectionManager(
+            hcm, filterRegistry,
+            true /* does not matter */, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("HttpConnectionManager neither has inlined route_config nor RDS");
+  }
+
+  @Test
+  public void parseHttpConnectionManager_duplicateHttpFilters() throws ResourceInvalidException {
+    HttpConnectionManager hcm =
+        HttpConnectionManager.newBuilder()
+            .addHttpFilters(
+                HttpFilter.newBuilder().setName("envoy.filter.foo").setIsOptional(true))
+            .addHttpFilters(
+                HttpFilter.newBuilder().setName("envoy.filter.foo").setIsOptional(true))
+            .addHttpFilters(
+                HttpFilter.newBuilder().setName("terminal").setTypedConfig(
+                        Any.pack(Router.newBuilder().build())).setIsOptional(true))
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseHttpConnectionManager(
+            hcm, filterRegistry,
+            true /* does not matter */, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("HttpConnectionManager contains duplicate HttpFilter: envoy.filter.foo");
+  }
+
+  @Test
+  public void parseHttpConnectionManager_lastNotTerminal() throws ResourceInvalidException {
+    filterRegistry.register(FAULT_FILTER_PROVIDER);
+    HttpConnectionManager hcm =
+          HttpConnectionManager.newBuilder()
+              .addHttpFilters(
+                HttpFilter.newBuilder().setName("envoy.filter.foo").setIsOptional(true))
+              .addHttpFilters(
+                HttpFilter.newBuilder().setName("envoy.filter.bar").setIsOptional(true)
+                    .setTypedConfig(Any.pack(HTTPFault.newBuilder().build())))
+                    .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseHttpConnectionManager(
+            hcm, filterRegistry,
+            true /* does not matter */, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("The last HttpFilter must be a terminal filter: envoy.filter.bar");
+  }
+
+  @Test
+  public void parseHttpConnectionManager_terminalNotLast() throws ResourceInvalidException {
+    filterRegistry.register(ROUTER_FILTER_PROVIDER);
+    HttpConnectionManager hcm =
+            HttpConnectionManager.newBuilder()
+                    .addHttpFilters(
+                            HttpFilter.newBuilder().setName("terminal").setTypedConfig(
+                                    Any.pack(Router.newBuilder().build())).setIsOptional(true))
+                    .addHttpFilters(
+                            HttpFilter.newBuilder().setName("envoy.filter.foo").setIsOptional(true))
+                    .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseHttpConnectionManager(
+            hcm, filterRegistry,
+            true, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("A terminal HttpFilter must be the last filter: terminal");
+  }
+
+  @Test
+  public void parseHttpConnectionManager_unknownFilters() throws ResourceInvalidException {
+    HttpConnectionManager hcm =
+            HttpConnectionManager.newBuilder()
+                    .addHttpFilters(
+                            HttpFilter.newBuilder().setName("envoy.filter.foo").setIsOptional(true))
+                    .addHttpFilters(
+                            HttpFilter.newBuilder().setName("envoy.filter.bar").setIsOptional(true))
+                    .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseHttpConnectionManager(
+            hcm, filterRegistry,
+            true /* does not matter */, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("The last HttpFilter must be a terminal filter: envoy.filter.bar");
+  }
+
+  @Test
+  public void parseHttpConnectionManager_emptyFilters() throws ResourceInvalidException {
+    HttpConnectionManager hcm =
+            HttpConnectionManager.newBuilder()
+                    .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseHttpConnectionManager(
+            hcm, filterRegistry,
+            true /* does not matter */, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Missing HttpFilter in HttpConnectionManager.");
+  }
+
+  @Test
+  public void parseHttpConnectionManager_clusterSpecifierPlugin() throws Exception {
+    XdsRouteConfigureResource.enableRouteLookup = true;
+    RouteLookupConfig routeLookupConfig = RouteLookupConfig.newBuilder()
+        .addGrpcKeybuilders(
+            GrpcKeyBuilder.newBuilder()
+                .addNames(Name.newBuilder().setService("service1"))
+                .addNames(Name.newBuilder().setService("service2"))
+                .addHeaders(
+                    NameMatcher.newBuilder().setKey("key1").addNames("v1").setRequiredMatch(true)))
+        .setLookupService("rls-cbt.googleapis.com")
+        .setLookupServiceTimeout(Durations.fromMillis(1234))
+        .setCacheSizeBytes(5000)
+        .addValidTargets("valid-target")
+        .build();
+    RouteLookupClusterSpecifier specifier =
+        RouteLookupClusterSpecifier.newBuilder().setRouteLookupConfig(routeLookupConfig).build();
+    TypedExtensionConfig typedExtensionConfig = TypedExtensionConfig.newBuilder()
+        .setName("rls-plugin-1")
+        .setTypedConfig(Any.pack(specifier))
+        .build();
+    io.envoyproxy.envoy.config.route.v3.Route route =
+        io.envoyproxy.envoy.config.route.v3.Route.newBuilder()
+            .setName("route-1")
+            .setMatch(io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder().setPrefix(""))
+            .setRoute(io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+                .setClusterSpecifierPlugin("rls-plugin-1"))
+            .build();
+    HttpConnectionManager hcm =
+        HttpConnectionManager.newBuilder()
+            .setRouteConfig(
+                RouteConfiguration.newBuilder()
+                    .addClusterSpecifierPlugins(
+                        io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin.newBuilder()
+                            .setExtension(typedExtensionConfig)
+                            .build())
+                    .addVirtualHosts(io.envoyproxy.envoy.config.route.v3.VirtualHost.newBuilder()
+                        .setName("virtual-host-1")
+                        .addRoutes(route)))
+            .addHttpFilters(
+                HttpFilter.newBuilder().setName("terminal").setTypedConfig(
+                    Any.pack(Router.newBuilder().build())).setIsOptional(true))
+            .build();
+
+    io.grpc.xds.HttpConnectionManager parsedHcm = XdsListenerResource.parseHttpConnectionManager(
+        hcm, filterRegistry,
+        true /* does not matter */, getXdsResourceTypeArgs(true));
+
+    VirtualHost virtualHost = Iterables.getOnlyElement(parsedHcm.virtualHosts());
+    Route parsedRoute = Iterables.getOnlyElement(virtualHost.routes());
+    NamedPluginConfig namedPluginConfig =
+        parsedRoute.routeAction().namedClusterSpecifierPluginConfig();
+    assertThat(namedPluginConfig.name()).isEqualTo("rls-plugin-1");
+    assertThat(namedPluginConfig.config()).isInstanceOf(RlsPluginConfig.class);
+  }
+
+  @Test
+  public void parseHttpConnectionManager_duplicatePluginName() throws Exception {
+    XdsRouteConfigureResource.enableRouteLookup = true;
+    RouteLookupConfig routeLookupConfig1 = RouteLookupConfig.newBuilder()
+        .addGrpcKeybuilders(
+            GrpcKeyBuilder.newBuilder()
+                .addNames(Name.newBuilder().setService("service1"))
+                .addNames(Name.newBuilder().setService("service2"))
+                .addHeaders(
+                    NameMatcher.newBuilder().setKey("key1").addNames("v1").setRequiredMatch(true)))
+        .setLookupService("rls-cbt.googleapis.com")
+        .setLookupServiceTimeout(Durations.fromMillis(1234))
+        .setCacheSizeBytes(5000)
+        .addValidTargets("valid-target")
+        .build();
+    RouteLookupClusterSpecifier specifier1 =
+        RouteLookupClusterSpecifier.newBuilder().setRouteLookupConfig(routeLookupConfig1).build();
+    RouteLookupConfig routeLookupConfig2 = RouteLookupConfig.newBuilder()
+        .addGrpcKeybuilders(
+            GrpcKeyBuilder.newBuilder()
+                .addNames(Name.newBuilder().setService("service3"))
+                .addHeaders(
+                    NameMatcher.newBuilder().setKey("key1").addNames("v1").setRequiredMatch(true)))
+        .setLookupService("rls-cbt.googleapis.com")
+        .setLookupServiceTimeout(Durations.fromMillis(1234))
+        .setCacheSizeBytes(5000)
+        .addValidTargets("valid-target")
+        .build();
+    RouteLookupClusterSpecifier specifier2 =
+        RouteLookupClusterSpecifier.newBuilder().setRouteLookupConfig(routeLookupConfig2).build();
+    TypedExtensionConfig typedExtensionConfig = TypedExtensionConfig.newBuilder()
+        .setName("rls-plugin-1")
+        .setTypedConfig(Any.pack(specifier1))
+        .build();
+    TypedExtensionConfig typedExtensionConfig2 = TypedExtensionConfig.newBuilder()
+        .setName("rls-plugin-1")
+        .setTypedConfig(Any.pack(specifier2))
+        .build();
+    io.envoyproxy.envoy.config.route.v3.Route route =
+        io.envoyproxy.envoy.config.route.v3.Route.newBuilder()
+            .setName("route-1")
+            .setMatch(io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder().setPrefix(""))
+            .setRoute(io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+                .setClusterSpecifierPlugin("rls-plugin-1"))
+            .build();
+    HttpConnectionManager hcm =
+        HttpConnectionManager.newBuilder()
+            .setRouteConfig(
+                RouteConfiguration.newBuilder()
+                    .addClusterSpecifierPlugins(
+                        io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin.newBuilder()
+                            .setExtension(typedExtensionConfig)
+                            .build())
+                    .addClusterSpecifierPlugins(
+                        io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin.newBuilder()
+                            .setExtension(typedExtensionConfig2)
+                            .build())
+                    .addVirtualHosts(io.envoyproxy.envoy.config.route.v3.VirtualHost.newBuilder()
+                        .setName("virtual-host-1")
+                        .addRoutes(route)))
+            .addHttpFilters(
+                HttpFilter.newBuilder().setName("terminal").setTypedConfig(
+                    Any.pack(Router.newBuilder().build())).setIsOptional(true))
+            .build();
+
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseHttpConnectionManager(
+            hcm, filterRegistry,
+            true /* does not matter */, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Multiple ClusterSpecifierPlugins with the same name: rls-plugin-1");
+  }
+
+  @Test
+  public void parseHttpConnectionManager_pluginNameNotFound() throws Exception {
+    XdsRouteConfigureResource.enableRouteLookup = true;
+    RouteLookupConfig routeLookupConfig = RouteLookupConfig.newBuilder()
+        .addGrpcKeybuilders(
+            GrpcKeyBuilder.newBuilder()
+                .addNames(Name.newBuilder().setService("service1"))
+                .addNames(Name.newBuilder().setService("service2"))
+                .addHeaders(
+                    NameMatcher.newBuilder().setKey("key1").addNames("v1").setRequiredMatch(true)))
+        .setLookupService("rls-cbt.googleapis.com")
+        .setLookupServiceTimeout(Durations.fromMillis(1234))
+        .setCacheSizeBytes(5000)
+        .addValidTargets("valid-target")
+        .build();
+    RouteLookupClusterSpecifier specifier =
+        RouteLookupClusterSpecifier.newBuilder().setRouteLookupConfig(routeLookupConfig).build();
+    TypedExtensionConfig typedExtensionConfig = TypedExtensionConfig.newBuilder()
+        .setName("rls-plugin-1")
+        .setTypedConfig(Any.pack(specifier))
+        .build();
+    io.envoyproxy.envoy.config.route.v3.Route route =
+        io.envoyproxy.envoy.config.route.v3.Route.newBuilder()
+            .setName("route-1")
+            .setMatch(io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder().setPrefix(""))
+            .setRoute(io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+                .setClusterSpecifierPlugin("invalid-plugin-name"))
+            .build();
+    HttpConnectionManager hcm =
+        HttpConnectionManager.newBuilder()
+            .setRouteConfig(
+                RouteConfiguration.newBuilder()
+                    .addClusterSpecifierPlugins(
+                        io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin.newBuilder()
+                            .setExtension(typedExtensionConfig)
+                            .build())
+                    .addVirtualHosts(io.envoyproxy.envoy.config.route.v3.VirtualHost.newBuilder()
+                        .setName("virtual-host-1")
+                        .addRoutes(route)))
+            .addHttpFilters(
+                HttpFilter.newBuilder().setName("terminal").setTypedConfig(
+                    Any.pack(Router.newBuilder().build())).setIsOptional(true))
+            .build();
+
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseHttpConnectionManager(
+            hcm, filterRegistry,
+            true /* does not matter */, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .contains("ClusterSpecifierPlugin for [invalid-plugin-name] not found");
+  }
+
+
+  @Test
+  public void parseHttpConnectionManager_optionalPlugin() throws ResourceInvalidException {
+    XdsRouteConfigureResource.enableRouteLookup = true;
+
+    // RLS Plugin, and a route to it.
+    RouteLookupConfig routeLookupConfig = RouteLookupConfig.newBuilder()
+        .addGrpcKeybuilders(
+            GrpcKeyBuilder.newBuilder()
+                .addNames(Name.newBuilder().setService("service1"))
+                .addNames(Name.newBuilder().setService("service2"))
+                .addHeaders(
+                    NameMatcher.newBuilder().setKey("key1").addNames("v1").setRequiredMatch(true)))
+        .setLookupService("rls-cbt.googleapis.com")
+        .setLookupServiceTimeout(Durations.fromMillis(1234))
+        .setCacheSizeBytes(5000)
+        .addValidTargets("valid-target")
+        .build();
+    io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin rlsPlugin =
+        io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin.newBuilder()
+            .setExtension(
+                TypedExtensionConfig.newBuilder()
+                    .setName("rls-plugin-1")
+                    .setTypedConfig(Any.pack(
+                        RouteLookupClusterSpecifier.newBuilder()
+                            .setRouteLookupConfig(routeLookupConfig)
+                            .build())))
+            .build();
+    io.envoyproxy.envoy.config.route.v3.Route rlsRoute =
+        io.envoyproxy.envoy.config.route.v3.Route.newBuilder()
+            .setName("rls-route-1")
+            .setMatch(io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder().setPrefix(""))
+            .setRoute(io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+                .setClusterSpecifierPlugin("rls-plugin-1"))
+            .build();
+
+    // Unknown optional plugin, and a route to it.
+    io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin optionalPlugin =
+        io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin.newBuilder()
+            .setIsOptional(true)
+            .setExtension(
+                TypedExtensionConfig.newBuilder()
+                    .setName("optional-plugin-1")
+                    .setTypedConfig(Any.pack(StringValue.of("unregistered")))
+                    .build())
+            .build();
+    io.envoyproxy.envoy.config.route.v3.Route optionalRoute =
+        io.envoyproxy.envoy.config.route.v3.Route.newBuilder()
+            .setName("optional-route-1")
+            .setMatch(io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder().setPrefix(""))
+            .setRoute(io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+                .setClusterSpecifierPlugin("optional-plugin-1"))
+            .build();
+
+
+    // Build and parse the route.
+    RouteConfiguration routeConfig = RouteConfiguration.newBuilder()
+        .addClusterSpecifierPlugins(rlsPlugin)
+        .addClusterSpecifierPlugins(optionalPlugin)
+        .addVirtualHosts(
+            io.envoyproxy.envoy.config.route.v3.VirtualHost.newBuilder()
+                .setName("virtual-host-1")
+                .addRoutes(rlsRoute)
+                .addRoutes(optionalRoute))
+        .build();
+    io.grpc.xds.HttpConnectionManager parsedHcm = XdsListenerResource.parseHttpConnectionManager(
+        HttpConnectionManager.newBuilder().setRouteConfig(routeConfig)
+            .addHttpFilters(
+                HttpFilter.newBuilder().setName("terminal").setTypedConfig(
+                    Any.pack(Router.newBuilder().build())).setIsOptional(true))
+            .build(), filterRegistry,
+        true /* does not matter */, getXdsResourceTypeArgs(true));
+
+    // Verify that the only route left is the one with the registered RLS plugin `rls-plugin-1`,
+    // while the route with unregistered optional `optional-plugin-`1 has been skipped.
+    VirtualHost virtualHost = Iterables.getOnlyElement(parsedHcm.virtualHosts());
+    Route parsedRoute = Iterables.getOnlyElement(virtualHost.routes());
+    NamedPluginConfig namedPluginConfig =
+        parsedRoute.routeAction().namedClusterSpecifierPluginConfig();
+    assertThat(namedPluginConfig.name()).isEqualTo("rls-plugin-1");
+    assertThat(namedPluginConfig.config()).isInstanceOf(RlsPluginConfig.class);
+  }
+
+  @Test
+  public void parseHttpConnectionManager_validateRdsConfigSource() throws Exception {
+    XdsRouteConfigureResource.enableRouteLookup = true;
+
+    HttpConnectionManager hcm1 =
+        HttpConnectionManager.newBuilder()
+            .setRds(Rds.newBuilder()
+                .setRouteConfigName("rds-config-foo")
+                .setConfigSource(
+                    ConfigSource.newBuilder().setAds(AggregatedConfigSource.getDefaultInstance())))
+            .addHttpFilters(
+                HttpFilter.newBuilder().setName("terminal").setTypedConfig(
+                    Any.pack(Router.newBuilder().build())).setIsOptional(true))
+            .build();
+    XdsListenerResource.parseHttpConnectionManager(
+        hcm1, filterRegistry,
+        true /* does not matter */, getXdsResourceTypeArgs(true));
+
+    HttpConnectionManager hcm2 =
+        HttpConnectionManager.newBuilder()
+            .setRds(Rds.newBuilder()
+                .setRouteConfigName("rds-config-foo")
+                .setConfigSource(
+                    ConfigSource.newBuilder().setSelf(SelfConfigSource.getDefaultInstance())))
+            .addHttpFilters(
+                HttpFilter.newBuilder().setName("terminal").setTypedConfig(
+                    Any.pack(Router.newBuilder().build())).setIsOptional(true))
+            .build();
+    XdsListenerResource.parseHttpConnectionManager(
+        hcm2, filterRegistry,
+        true /* does not matter */, getXdsResourceTypeArgs(true));
+
+    HttpConnectionManager hcm3 =
+        HttpConnectionManager.newBuilder()
+            .setRds(Rds.newBuilder()
+                .setRouteConfigName("rds-config-foo")
+                .setConfigSource(
+                    ConfigSource.newBuilder()
+                        .setPathConfigSource(PathConfigSource.newBuilder().setPath("foo-path"))))
+            .addHttpFilters(
+                HttpFilter.newBuilder().setName("terminal").setTypedConfig(
+                    Any.pack(Router.newBuilder().build())).setIsOptional(true))
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseHttpConnectionManager(
+            hcm3, filterRegistry,
+            true /* does not matter */, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "HttpConnectionManager contains invalid RDS: must specify ADS or self ConfigSource");
+  }
+
+  @Test
+  public void parseClusterSpecifierPlugin_typedStructInTypedExtension() throws Exception {
+    class TestPluginConfig implements PluginConfig {
+      @Override
+      public String typeUrl() {
+        return "type.googleapis.com/google.protobuf.Empty";
+      }
+    }
+
+    ClusterSpecifierPluginRegistry registry = ClusterSpecifierPluginRegistry.newRegistry();
+    registry.register(new ClusterSpecifierPlugin() {
+      @Override
+      public String[] typeUrls() {
+        return new String[] {
+            "type.googleapis.com/google.protobuf.Empty",
+        };
+      }
+
+      @Override
+      public ConfigOrError<? extends PluginConfig> parsePlugin(Message rawProtoMessage) {
+        return ConfigOrError.fromConfig(new TestPluginConfig());
+      }
+    });
+
+    TypedStruct typedStruct = TypedStruct.newBuilder()
+        .setTypeUrl("type.googleapis.com/google.protobuf.Empty")
+        .setValue(Struct.newBuilder())
+        .build();
+    io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin pluginProto =
+        io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin.newBuilder()
+            .setExtension(TypedExtensionConfig.newBuilder()
+                .setTypedConfig(Any.pack(typedStruct)))
+            .build();
+
+    PluginConfig pluginConfig = XdsRouteConfigureResource
+        .parseClusterSpecifierPlugin(pluginProto, registry);
+    assertThat(pluginConfig).isInstanceOf(TestPluginConfig.class);
+  }
+
+  @Test
+  public void parseClusterSpecifierPlugin_v3TypedStructInTypedExtension() throws Exception {
+    class TestPluginConfig implements PluginConfig {
+      @Override
+      public String typeUrl() {
+        return "type.googleapis.com/google.protobuf.Empty";
+      }
+    }
+
+    ClusterSpecifierPluginRegistry registry = ClusterSpecifierPluginRegistry.newRegistry();
+    registry.register(new ClusterSpecifierPlugin() {
+      @Override
+      public String[] typeUrls() {
+        return new String[] {
+            "type.googleapis.com/google.protobuf.Empty",
+        };
+      }
+
+      @Override
+      public ConfigOrError<? extends PluginConfig> parsePlugin(Message rawProtoMessage) {
+        return ConfigOrError.fromConfig(new TestPluginConfig());
+      }
+    });
+
+    com.github.xds.type.v3.TypedStruct typedStruct = com.github.xds.type.v3.TypedStruct.newBuilder()
+        .setTypeUrl("type.googleapis.com/google.protobuf.Empty")
+        .setValue(Struct.newBuilder())
+        .build();
+    io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin pluginProto =
+        io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin.newBuilder()
+            .setExtension(TypedExtensionConfig.newBuilder()
+                .setTypedConfig(Any.pack(typedStruct)))
+            .build();
+
+    PluginConfig pluginConfig = XdsRouteConfigureResource
+        .parseClusterSpecifierPlugin(pluginProto, registry);
+    assertThat(pluginConfig).isInstanceOf(TestPluginConfig.class);
+  }
+
+  @Test
+  public void parseClusterSpecifierPlugin_unregisteredPlugin() throws Exception {
+    ClusterSpecifierPluginRegistry registry = ClusterSpecifierPluginRegistry.newRegistry();
+    io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin pluginProto =
+        io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin.newBuilder()
+            .setExtension(TypedExtensionConfig.newBuilder()
+                .setTypedConfig(Any.pack(StringValue.of("unregistered"))))
+            .build();
+
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsRouteConfigureResource.parseClusterSpecifierPlugin(pluginProto, registry));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "Unsupported ClusterSpecifierPlugin type: type.googleapis.com/google.protobuf.StringValue");
+  }
+
+  @Test
+  public void parseClusterSpecifierPlugin_unregisteredPlugin_optional()
+      throws ResourceInvalidException {
+    ClusterSpecifierPluginRegistry registry = ClusterSpecifierPluginRegistry.newRegistry();
+    io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin pluginProto =
+        io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin.newBuilder()
+            .setExtension(TypedExtensionConfig.newBuilder()
+                .setTypedConfig(Any.pack(StringValue.of("unregistered"))))
+            .setIsOptional(true)
+            .build();
+
+    PluginConfig pluginConfig = XdsRouteConfigureResource
+        .parseClusterSpecifierPlugin(pluginProto, registry);
+    assertThat(pluginConfig).isNull();
+  }
+
+  @Test
+  public void parseClusterSpecifierPlugin_brokenPlugin() {
+    ClusterSpecifierPluginRegistry registry = ClusterSpecifierPluginRegistry.newRegistry();
+
+    Any failingAny = Any.newBuilder()
+        .setTypeUrl("type.googleapis.com/xds.type.v3.TypedStruct")
+        .setValue(ByteString.copyFromUtf8("fail"))
+        .build();
+
+    TypedExtensionConfig brokenPlugin = TypedExtensionConfig.newBuilder()
+          .setName("bad-plugin-1")
+          .setTypedConfig(failingAny)
+          .build();
+
+    try {
+      XdsRouteConfigureResource.parseClusterSpecifierPlugin(
+          io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin.newBuilder()
+              .setExtension(brokenPlugin)
+              .build(),
+          registry);
+      fail("Expected ResourceInvalidException");
+    } catch (ResourceInvalidException e) {
+      assertThat(e).hasMessageThat()
+          .startsWith("ClusterSpecifierPlugin [bad-plugin-1] contains invalid proto");
+    }
+  }
+
+  @Test
+  public void parseClusterSpecifierPlugin_brokenPlugin_optional() {
+    ClusterSpecifierPluginRegistry registry = ClusterSpecifierPluginRegistry.newRegistry();
+
+    Any failingAny = Any.newBuilder()
+        .setTypeUrl("type.googleapis.com/xds.type.v3.TypedStruct")
+        .setValue(ByteString.copyFromUtf8("fail"))
+        .build();
+
+    TypedExtensionConfig brokenPlugin = TypedExtensionConfig.newBuilder()
+          .setName("bad-plugin-1")
+          .setTypedConfig(failingAny)
+          .build();
+
+    // Despite being optional, still should fail.
+    try {
+      XdsRouteConfigureResource.parseClusterSpecifierPlugin(
+          io.envoyproxy.envoy.config.route.v3.ClusterSpecifierPlugin.newBuilder()
+              .setIsOptional(true)
+              .setExtension(brokenPlugin)
+              .build(),
+          registry);
+      fail("Expected ResourceInvalidException");
+    } catch (ResourceInvalidException e) {
+      assertThat(e).hasMessageThat()
+          .startsWith("ClusterSpecifierPlugin [bad-plugin-1] contains invalid proto");
+    }
+  }
+
+  @Test
+  public void parseCluster_ringHashLbPolicy_defaultLbConfig() throws ResourceInvalidException {
+    Cluster cluster = Cluster.newBuilder()
+        .setName("cluster-foo.googleapis.com")
+        .setType(DiscoveryType.EDS)
+        .setEdsClusterConfig(
+            EdsClusterConfig.newBuilder()
+                .setEdsConfig(
+                    ConfigSource.newBuilder()
+                        .setAds(AggregatedConfigSource.getDefaultInstance()))
+                .setServiceName("service-foo.googleapis.com"))
+        .setLbPolicy(LbPolicy.RING_HASH)
+        .build();
+
+    CdsUpdate update = XdsClusterResource.processCluster(
+        cluster, null, LRS_SERVER_INFO,
+        LoadBalancerRegistry.getDefaultRegistry());
+    LbConfig lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(update.lbPolicyConfig());
+    assertThat(lbConfig.getPolicyName()).isEqualTo("ring_hash_experimental");
+  }
+
+  @Test
+  public void parseCluster_leastRequestLbPolicy_defaultLbConfig() throws ResourceInvalidException {
+    XdsClusterResource.enableLeastRequest = true;
+    Cluster cluster = Cluster.newBuilder()
+        .setName("cluster-foo.googleapis.com")
+        .setType(DiscoveryType.EDS)
+        .setEdsClusterConfig(
+            EdsClusterConfig.newBuilder()
+                .setEdsConfig(
+                    ConfigSource.newBuilder()
+                        .setAds(AggregatedConfigSource.getDefaultInstance()))
+                .setServiceName("service-foo.googleapis.com"))
+        .setLbPolicy(LbPolicy.LEAST_REQUEST)
+        .build();
+
+    CdsUpdate update = XdsClusterResource.processCluster(
+        cluster, null, LRS_SERVER_INFO,
+        LoadBalancerRegistry.getDefaultRegistry());
+    LbConfig lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(update.lbPolicyConfig());
+    assertThat(lbConfig.getPolicyName()).isEqualTo("wrr_locality_experimental");
+    List<LbConfig> childConfigs = ServiceConfigUtil.unwrapLoadBalancingConfigList(
+        JsonUtil.getListOfObjects(lbConfig.getRawConfigValue(), "childPolicy"));
+    assertThat(childConfigs.get(0).getPolicyName()).isEqualTo("least_request_experimental");
+  }
+
+  @Test
+  public void parseCluster_WrrLbPolicy_defaultLbConfig() throws ResourceInvalidException {
+    LoadBalancingPolicy wrrConfig =
+        LoadBalancingPolicy.newBuilder().addPolicies(
+                LoadBalancingPolicy.Policy.newBuilder()
+                    .setTypedExtensionConfig(TypedExtensionConfig.newBuilder()
+                        .setName("backend")
+                        .setTypedConfig(
+                            Any.pack(ClientSideWeightedRoundRobin.newBuilder()
+                                .setBlackoutPeriod(Duration.newBuilder().setSeconds(17).build())
+                                .setEnableOobLoadReport(
+                                    BoolValue.newBuilder().setValue(true).build())
+                                .setErrorUtilizationPenalty(
+                                    FloatValue.newBuilder().setValue(1.75F).build())
+                                .build()))
+                        .build())
+                    .build())
+            .build();
+
+    Cluster cluster = Cluster.newBuilder()
+            .setName("cluster-foo.googleapis.com")
+            .setType(DiscoveryType.EDS)
+            .setEdsClusterConfig(
+                EdsClusterConfig.newBuilder()
+                    .setEdsConfig(
+                        ConfigSource.newBuilder()
+                            .setAds(AggregatedConfigSource.getDefaultInstance()))
+                            .setServiceName("service-foo.googleapis.com"))
+            .setLoadBalancingPolicy(
+                LoadBalancingPolicy.newBuilder().addPolicies(
+                    LoadBalancingPolicy.Policy.newBuilder()
+                        .setTypedExtensionConfig(
+                            TypedExtensionConfig.newBuilder()
+                                .setTypedConfig(
+                                    Any.pack(WrrLocality.newBuilder()
+                                        .setEndpointPickingPolicy(wrrConfig)
+                                        .build()))
+                                .build())
+                        .build())
+                   .build())
+              .build();
+    CdsUpdate update = XdsClusterResource.processCluster(
+            cluster, null, LRS_SERVER_INFO,
+            LoadBalancerRegistry.getDefaultRegistry());
+    LbConfig lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(update.lbPolicyConfig());
+    assertThat(lbConfig.getPolicyName()).isEqualTo("wrr_locality_experimental");
+    List<LbConfig> childConfigs = ServiceConfigUtil.unwrapLoadBalancingConfigList(
+            JsonUtil.getListOfObjects(lbConfig.getRawConfigValue(), "childPolicy"));
+    assertThat(childConfigs.get(0).getPolicyName()).isEqualTo("weighted_round_robin");
+    WeightedRoundRobinLoadBalancerConfig result = (WeightedRoundRobinLoadBalancerConfig)
+        new WeightedRoundRobinLoadBalancerProvider().parseLoadBalancingPolicyConfig(
+        childConfigs.get(0).getRawConfigValue()).getConfig();
+    assertThat(result.blackoutPeriodNanos).isEqualTo(17_000_000_000L);
+    assertThat(result.enableOobLoadReport).isTrue();
+    assertThat(result.oobReportingPeriodNanos).isEqualTo(10_000_000_000L);
+    assertThat(result.weightUpdatePeriodNanos).isEqualTo(1_000_000_000L);
+    assertThat(result.weightExpirationPeriodNanos).isEqualTo(180_000_000_000L);
+    assertThat(result.errorUtilizationPenalty).isEqualTo(1.75F);
+  }
+
+  @Test
+  public void parseCluster_transportSocketMatches_exception() throws ResourceInvalidException {
+    Cluster cluster = Cluster.newBuilder()
+        .setName("cluster-foo.googleapis.com")
+        .setType(DiscoveryType.EDS)
+        .setEdsClusterConfig(
+            EdsClusterConfig.newBuilder()
+                .setEdsConfig(
+                    ConfigSource.newBuilder()
+                        .setAds(AggregatedConfigSource.getDefaultInstance()))
+                .setServiceName("service-foo.googleapis.com"))
+        .setLbPolicy(LbPolicy.ROUND_ROBIN)
+        .addTransportSocketMatches(
+            Cluster.TransportSocketMatch.newBuilder().setName("match1").build())
+        .build();
+
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsClusterResource.processCluster(cluster, null, LRS_SERVER_INFO,
+            LoadBalancerRegistry.getDefaultRegistry()));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "Cluster cluster-foo.googleapis.com: transport-socket-matches not supported.");
+  }
+
+  @Test
+  public void parseCluster_validateEdsSourceConfig() throws ResourceInvalidException {
+    Cluster cluster1 = Cluster.newBuilder()
+        .setName("cluster-foo.googleapis.com")
+        .setType(DiscoveryType.EDS)
+        .setEdsClusterConfig(
+            EdsClusterConfig.newBuilder()
+                .setEdsConfig(
+                    ConfigSource.newBuilder()
+                        .setAds(AggregatedConfigSource.getDefaultInstance()))
+                .setServiceName("service-foo.googleapis.com"))
+        .setLbPolicy(LbPolicy.ROUND_ROBIN)
+        .build();
+    XdsClusterResource.processCluster(cluster1, null, LRS_SERVER_INFO,
+        LoadBalancerRegistry.getDefaultRegistry());
+
+    Cluster cluster2 = Cluster.newBuilder()
+        .setName("cluster-foo.googleapis.com")
+        .setType(DiscoveryType.EDS)
+        .setEdsClusterConfig(
+            EdsClusterConfig.newBuilder()
+                .setEdsConfig(
+                    ConfigSource.newBuilder()
+                        .setSelf(SelfConfigSource.getDefaultInstance()))
+                .setServiceName("service-foo.googleapis.com"))
+        .setLbPolicy(LbPolicy.ROUND_ROBIN)
+        .build();
+    XdsClusterResource.processCluster(cluster2, null, LRS_SERVER_INFO,
+        LoadBalancerRegistry.getDefaultRegistry());
+
+    Cluster cluster3 = Cluster.newBuilder()
+        .setName("cluster-foo.googleapis.com")
+        .setType(DiscoveryType.EDS)
+        .setEdsClusterConfig(
+            EdsClusterConfig.newBuilder()
+                .setEdsConfig(
+                    ConfigSource.newBuilder()
+                        .setPathConfigSource(PathConfigSource.newBuilder().setPath("foo-path")))
+                .setServiceName("service-foo.googleapis.com"))
+        .setLbPolicy(LbPolicy.ROUND_ROBIN)
+        .build();
+
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsClusterResource.processCluster(cluster3, null, LRS_SERVER_INFO,
+            LoadBalancerRegistry.getDefaultRegistry()));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "Cluster cluster-foo.googleapis.com: field eds_cluster_config must be set to indicate to"
+            + " use EDS over ADS or self ConfigSource");
+  }
+
+  @Test
+  public void processCluster_parsesMetadata()
+      throws ResourceInvalidException, InvalidProtocolBufferException {
+    MetadataRegistry metadataRegistry = MetadataRegistry.getInstance();
+
+    MetadataValueParser testParser =
+        new MetadataValueParser() {
+          @Override
+          public String getTypeUrl() {
+            return "type.googleapis.com/test.Type";
+          }
+
+          @Override
+          public Object parse(Any value) {
+            assertThat(value.getValue().toStringUtf8()).isEqualTo("test");
+            return value.getValue().toStringUtf8() + "_processed";
+          }
+        };
+    metadataRegistry.registerParser(testParser);
+
+    Any typedFilterMetadata = Any.newBuilder()
+        .setTypeUrl("type.googleapis.com/test.Type")
+        .setValue(ByteString.copyFromUtf8("test"))
+        .build();
+
+    Struct filterMetadata = Struct.newBuilder()
+        .putFields("key1", Value.newBuilder().setStringValue("value1").build())
+        .putFields("key2", Value.newBuilder().setNumberValue(42).build())
+        .build();
+
+    Metadata metadata = Metadata.newBuilder()
+        .putTypedFilterMetadata("TYPED_FILTER_METADATA", typedFilterMetadata)
+        .putFilterMetadata("FILTER_METADATA", filterMetadata)
+        .build();
+
+    Cluster cluster = Cluster.newBuilder()
+        .setName("cluster-foo.googleapis.com")
+        .setType(DiscoveryType.EDS)
+        .setEdsClusterConfig(
+            EdsClusterConfig.newBuilder()
+                .setEdsConfig(
+                    ConfigSource.newBuilder()
+                        .setAds(AggregatedConfigSource.getDefaultInstance()))
+                .setServiceName("service-foo.googleapis.com"))
+        .setLbPolicy(LbPolicy.ROUND_ROBIN)
+        .setMetadata(metadata)
+        .build();
+
+    CdsUpdate update = XdsClusterResource.processCluster(
+        cluster, null, LRS_SERVER_INFO,
+        LoadBalancerRegistry.getDefaultRegistry());
+
+    ImmutableMap<String, Object> expectedParsedMetadata = ImmutableMap.of(
+        "TYPED_FILTER_METADATA", "test_processed",
+        "FILTER_METADATA", ImmutableMap.of(
+            "key1", "value1",
+            "key2", 42.0));
+    assertThat(update.parsedMetadata()).isEqualTo(expectedParsedMetadata);
+    metadataRegistry.removeParser(testParser);
+  }
+
+  @Test
+  public void processCluster_parsesAudienceMetadata() throws Exception {
+    MetadataRegistry.getInstance();
+
+    Audience audience = Audience.newBuilder()
+        .setUrl("https://example.com")
+        .build();
+
+    Any audienceMetadata = Any.newBuilder()
+        .setTypeUrl("type.googleapis.com/envoy.extensions.filters.http.gcp_authn.v3.Audience")
+        .setValue(audience.toByteString())
+        .build();
+
+    Struct filterMetadata = Struct.newBuilder()
+        .putFields("key1", Value.newBuilder().setStringValue("value1").build())
+        .putFields("key2", Value.newBuilder().setNumberValue(42).build())
+        .build();
+
+    Metadata metadata = Metadata.newBuilder()
+        .putTypedFilterMetadata("AUDIENCE_METADATA", audienceMetadata)
+        .putFilterMetadata("FILTER_METADATA", filterMetadata)
+        .build();
+
+    Cluster cluster = Cluster.newBuilder()
+        .setName("cluster-foo.googleapis.com")
+        .setType(DiscoveryType.EDS)
+        .setEdsClusterConfig(
+            EdsClusterConfig.newBuilder()
+                .setEdsConfig(
+                    ConfigSource.newBuilder()
+                        .setAds(AggregatedConfigSource.getDefaultInstance()))
+                .setServiceName("service-foo.googleapis.com"))
+        .setLbPolicy(LbPolicy.ROUND_ROBIN)
+        .setMetadata(metadata)
+        .build();
+
+    CdsUpdate update = XdsClusterResource.processCluster(
+        cluster, null, LRS_SERVER_INFO,
+        LoadBalancerRegistry.getDefaultRegistry());
+
+    ImmutableMap<String, Object> expectedParsedMetadata = ImmutableMap.of(
+        "AUDIENCE_METADATA", "https://example.com",
+        "FILTER_METADATA", ImmutableMap.of(
+            "key1", "value1",
+            "key2", 42.0));
+
+    assertThat(update.parsedMetadata().get("FILTER_METADATA"))
+        .isEqualTo(expectedParsedMetadata.get("FILTER_METADATA"));
+    assertThat(update.parsedMetadata().get("AUDIENCE_METADATA"))
+        .isInstanceOf(AudienceWrapper.class);
+  }
+
+  @Test
+  public void processCluster_parsesAddressMetadata() throws Exception {
+
+    // Create an Address message
+    Address address = Address.newBuilder()
+        .setSocketAddress(SocketAddress.newBuilder()
+            .setAddress("192.168.1.1")
+            .setPortValue(8080)
+            .build())
+        .build();
+
+    // Wrap the Address in Any
+    Any addressMetadata = Any.newBuilder()
+        .setTypeUrl("type.googleapis.com/envoy.config.core.v3.Address")
+        .setValue(address.toByteString())
+        .build();
+
+    Struct filterMetadata = Struct.newBuilder()
+        .putFields("key1", Value.newBuilder().setStringValue("value1").build())
+        .putFields("key2", Value.newBuilder().setNumberValue(42).build())
+        .build();
+
+    Metadata metadata = Metadata.newBuilder()
+        .putTypedFilterMetadata("ADDRESS_METADATA", addressMetadata)
+        .putFilterMetadata("FILTER_METADATA", filterMetadata)
+        .build();
+
+    Cluster cluster = Cluster.newBuilder()
+        .setName("cluster-foo.googleapis.com")
+        .setType(DiscoveryType.EDS)
+        .setEdsClusterConfig(
+            EdsClusterConfig.newBuilder()
+                .setEdsConfig(
+                    ConfigSource.newBuilder()
+                        .setAds(AggregatedConfigSource.getDefaultInstance()))
+                .setServiceName("service-foo.googleapis.com"))
+        .setLbPolicy(LbPolicy.ROUND_ROBIN)
+        .setMetadata(metadata)
+        .build();
+
+    CdsUpdate update = XdsClusterResource.processCluster(
+        cluster, null, LRS_SERVER_INFO,
+        LoadBalancerRegistry.getDefaultRegistry());
+
+    ImmutableMap<String, Object> expectedParsedMetadata = ImmutableMap.of(
+        "ADDRESS_METADATA", new InetSocketAddress("192.168.1.1", 8080),
+        "FILTER_METADATA", ImmutableMap.of(
+            "key1", "value1",
+            "key2", 42.0));
+
+    assertThat(update.parsedMetadata()).isEqualTo(expectedParsedMetadata);
+  }
+
+  @Test
+  public void processCluster_metadataKeyCollision_resolvesToTypedMetadata() throws Exception {
+    MetadataRegistry metadataRegistry = MetadataRegistry.getInstance();
+
+    MetadataValueParser testParser =
+        new MetadataValueParser() {
+          @Override
+          public String getTypeUrl() {
+            return "type.googleapis.com/test.Type";
+          }
+
+          @Override
+          public Object parse(Any value) {
+            return "typedMetadataValue";
+          }
+        };
+    metadataRegistry.registerParser(testParser);
+
+    Any typedFilterMetadata = Any.newBuilder()
+        .setTypeUrl("type.googleapis.com/test.Type")
+        .setValue(ByteString.copyFromUtf8("test"))
+        .build();
+
+    Struct filterMetadata = Struct.newBuilder()
+        .putFields("key1", Value.newBuilder().setStringValue("filterMetadataValue").build())
+        .build();
+
+    Metadata metadata = Metadata.newBuilder()
+        .putTypedFilterMetadata("key1", typedFilterMetadata)
+        .putFilterMetadata("key1", filterMetadata)
+        .build();
+
+    Cluster cluster = Cluster.newBuilder()
+        .setName("cluster-foo.googleapis.com")
+        .setType(DiscoveryType.EDS)
+        .setEdsClusterConfig(
+            EdsClusterConfig.newBuilder()
+                .setEdsConfig(
+                    ConfigSource.newBuilder()
+                        .setAds(AggregatedConfigSource.getDefaultInstance()))
+                .setServiceName("service-foo.googleapis.com"))
+        .setLbPolicy(LbPolicy.ROUND_ROBIN)
+        .setMetadata(metadata)
+        .build();
+
+    CdsUpdate update = XdsClusterResource.processCluster(
+        cluster, null, LRS_SERVER_INFO,
+        LoadBalancerRegistry.getDefaultRegistry());
+
+    ImmutableMap<String, Object> expectedParsedMetadata = ImmutableMap.of(
+        "key1", "typedMetadataValue");
+    assertThat(update.parsedMetadata()).isEqualTo(expectedParsedMetadata);
+    metadataRegistry.removeParser(testParser);
+  }
+
+  @Test
+  public void parseNonAggregateCluster_withHttp11ProxyTransportSocket() throws Exception {
+    XdsClusterResource.isEnabledXdsHttpConnect = true;
+
+    Http11ProxyUpstreamTransport http11ProxyUpstreamTransport =
+        Http11ProxyUpstreamTransport.newBuilder()
+            .setTransportSocket(TransportSocket.getDefaultInstance())
+            .build();
+
+    TransportSocket transportSocket = TransportSocket.newBuilder()
+        .setName(TRANSPORT_SOCKET_NAME_HTTP11_PROXY)
+        .setTypedConfig(Any.pack(http11ProxyUpstreamTransport))
+        .build();
+
+    Cluster cluster = Cluster.newBuilder()
+        .setName("cluster-http11-proxy.googleapis.com")
+        .setType(DiscoveryType.EDS)
+        .setEdsClusterConfig(
+            EdsClusterConfig.newBuilder()
+                .setEdsConfig(
+                    ConfigSource.newBuilder().setAds(AggregatedConfigSource.getDefaultInstance()))
+                .setServiceName("service-http11-proxy.googleapis.com"))
+        .setLbPolicy(LbPolicy.ROUND_ROBIN)
+        .setTransportSocket(transportSocket)
+        .build();
+
+    CdsUpdate result =
+        XdsClusterResource.processCluster(cluster, null, LRS_SERVER_INFO,
+            LoadBalancerRegistry.getDefaultRegistry());
+
+    assertThat(result).isNotNull();
+    assertThat(result.isHttp11ProxyAvailable()).isTrue();
+  }
+
+  @Test
+  public void processCluster_parsesOrcaLrsPropagationMetrics() throws ResourceInvalidException {
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = true;
+
+    ImmutableList<String> metricSpecs = ImmutableList.of(
+        "cpu_utilization",
+        "named_metrics.foo",
+        "unknown_metric_spec"
+    );
+    Cluster cluster = Cluster.newBuilder()
+        .setName("cluster-orca.googleapis.com")
+        .setType(DiscoveryType.EDS)
+        .setEdsClusterConfig(
+            EdsClusterConfig.newBuilder()
+                .setEdsConfig(
+                    ConfigSource.newBuilder().setAds(AggregatedConfigSource.getDefaultInstance()))
+                .setServiceName("service-orca.googleapis.com"))
+        .setLbPolicy(LbPolicy.ROUND_ROBIN)
+        .addAllLrsReportEndpointMetrics(metricSpecs)
+        .build();
+
+    CdsUpdate update = XdsClusterResource.processCluster(
+        cluster, null, LRS_SERVER_INFO, LoadBalancerRegistry.getDefaultRegistry());
+
+    BackendMetricPropagation propagationConfig = update.backendMetricPropagation();
+    assertThat(propagationConfig).isNotNull();
+    assertThat(propagationConfig.propagateCpuUtilization).isTrue();
+    assertThat(propagationConfig.propagateMemUtilization).isFalse();
+    assertThat(propagationConfig.shouldPropagateNamedMetric("foo")).isTrue();
+    assertThat(propagationConfig.shouldPropagateNamedMetric("bar")).isFalse();
+    assertThat(propagationConfig.shouldPropagateNamedMetric("unknown_metric_spec"))
+        .isFalse();
+
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = false;
+  }
+
+  @Test
+  public void parseServerSideListener_invalidTrafficDirection() throws ResourceInvalidException {
+    Listener listener =
+        Listener.newBuilder()
+            .setName("listener1")
+            .setTrafficDirection(TrafficDirection.OUTBOUND)
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseServerSideListener(
+            listener, null, filterRegistry, null, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Listener listener1 with invalid traffic direction: OUTBOUND");
+  }
+
+  @Test
+  public void parseServerSideListener_noTrafficDirection() throws ResourceInvalidException {
+    Listener listener =
+        Listener.newBuilder()
+            .setName("listener1")
+            .build();
+    XdsListenerResource.parseServerSideListener(
+        listener, null, filterRegistry, null, getXdsResourceTypeArgs(true));
+  }
+
+  @Test
+  public void parseServerSideListener_listenerFiltersPresent() throws ResourceInvalidException {
+    Listener listener =
+        Listener.newBuilder()
+            .setName("listener1")
+            .setTrafficDirection(TrafficDirection.INBOUND)
+            .addListenerFilters(ListenerFilter.newBuilder().build())
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseServerSideListener(listener, null, filterRegistry, null,
+            getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Listener listener1 cannot have listener_filters");
+  }
+
+  @Test
+  public void parseServerSideListener_useOriginalDst() throws ResourceInvalidException {
+    Listener listener =
+        Listener.newBuilder()
+            .setName("listener1")
+            .setTrafficDirection(TrafficDirection.INBOUND)
+            .setUseOriginalDst(BoolValue.of(true))
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseServerSideListener(listener, null, filterRegistry, null,
+            getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Listener listener1 cannot have use_original_dst set to true");
+  }
+
+  @Test
+  public void parseServerSideListener_emptyAddress() throws ResourceInvalidException {
+    Listener listener =
+        Listener.newBuilder()
+            .setName("listener1")
+            .setTrafficDirection(TrafficDirection.INBOUND)
+            .setAddress(Address.newBuilder()
+                .setSocketAddress(
+                    SocketAddress.newBuilder()))
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseServerSideListener(
+            listener, null, filterRegistry, null, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat().isEqualTo("Invalid address: Empty address is not allowed.");
+  }
+
+  @Test
+  public void parseServerSideListener_namedPort() throws ResourceInvalidException {
+    Listener listener =
+        Listener.newBuilder()
+            .setName("listener1")
+            .setTrafficDirection(TrafficDirection.INBOUND)
+            .setAddress(Address.newBuilder()
+                .setSocketAddress(
+                    SocketAddress.newBuilder()
+                        .setAddress("172.14.14.5").setNamedPort("")))
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseServerSideListener(
+            listener, null, filterRegistry, null, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat().isEqualTo("NAMED_PORT is not supported in gRPC.");
+  }
+
+  @Test
+  public void parseServerSideListener_nonUniqueFilterChainMatch() throws ResourceInvalidException {
+    Filter filter1 = buildHttpConnectionManagerFilter(
+        HttpFilter.newBuilder().setName("http-filter-1").setTypedConfig(
+            Any.pack(Router.newBuilder().build())).setIsOptional(true).build());
+    FilterChainMatch filterChainMatch1 =
+        FilterChainMatch.newBuilder()
+            .addAllSourcePorts(Arrays.asList(80, 8080))
+            .addAllPrefixRanges(Arrays.asList(CidrRange.newBuilder().setAddressPrefix("192.168.0.0")
+                    .setPrefixLen(UInt32Value.of(16)).build(),
+                CidrRange.newBuilder().setAddressPrefix("10.0.0.0").setPrefixLen(UInt32Value.of(8))
+                    .build()))
+            .build();
+    FilterChain filterChain1 =
+        FilterChain.newBuilder()
+            .setName("filter-chain-1")
+            .setFilterChainMatch(filterChainMatch1)
+            .addFilters(filter1)
+            .build();
+    Filter filter2 = buildHttpConnectionManagerFilter(
+        HttpFilter.newBuilder().setName("http-filter-2").setTypedConfig(
+            Any.pack(Router.newBuilder().build())).setIsOptional(true).build());
+    FilterChainMatch filterChainMatch2 =
+        FilterChainMatch.newBuilder()
+            .addAllSourcePorts(Arrays.asList(443, 8080))
+            .addAllPrefixRanges(Arrays.asList(
+                CidrRange.newBuilder().setAddressPrefix("2001:DB8::8:800:200C:417A")
+                    .setPrefixLen(UInt32Value.of(60)).build(),
+                CidrRange.newBuilder().setAddressPrefix("192.168.0.0")
+                    .setPrefixLen(UInt32Value.of(16)).build()))
+            .build();
+    FilterChain filterChain2 =
+        FilterChain.newBuilder()
+            .setName("filter-chain-2")
+            .setFilterChainMatch(filterChainMatch2)
+            .addFilters(filter2)
+            .build();
+    Listener listener =
+        Listener.newBuilder()
+            .setName("listener1")
+            .setTrafficDirection(TrafficDirection.INBOUND)
+            .addAllFilterChains(Arrays.asList(filterChain1, filterChain2))
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseServerSideListener(
+            listener, null, filterRegistry, null, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .startsWith("FilterChainMatch must be unique. Found duplicate:");
+  }
+
+  @Test
+  public void parseServerSideListener_nonUniqueFilterChainMatch_sameFilter()
+      throws ResourceInvalidException {
+    Filter filter1 = buildHttpConnectionManagerFilter(
+        HttpFilter.newBuilder().setName("http-filter-1").setTypedConfig(
+            Any.pack(Router.newBuilder().build())).setIsOptional(true).build());
+    FilterChainMatch filterChainMatch1 =
+        FilterChainMatch.newBuilder()
+            .addAllSourcePorts(Arrays.asList(80, 8080))
+            .addAllPrefixRanges(Arrays.asList(
+                CidrRange.newBuilder().setAddressPrefix("10.0.0.0").setPrefixLen(UInt32Value.of(8))
+                    .build()))
+            .build();
+    FilterChain filterChain1 =
+        FilterChain.newBuilder()
+            .setName("filter-chain-1")
+            .setFilterChainMatch(filterChainMatch1)
+            .addFilters(filter1)
+            .build();
+    Filter filter2 = buildHttpConnectionManagerFilter(
+        HttpFilter.newBuilder().setName("http-filter-2").setTypedConfig(
+            Any.pack(Router.newBuilder().build())).setIsOptional(true).build());
+    FilterChainMatch filterChainMatch2 =
+        FilterChainMatch.newBuilder()
+            .addAllSourcePorts(Arrays.asList(443, 8080))
+            .addAllPrefixRanges(Arrays.asList(
+                CidrRange.newBuilder().setAddressPrefix("192.168.0.0")
+                    .setPrefixLen(UInt32Value.of(16)).build(),
+                CidrRange.newBuilder().setAddressPrefix("192.168.0.0")
+                    .setPrefixLen(UInt32Value.of(16)).build()))
+            .build();
+    FilterChain filterChain2 =
+        FilterChain.newBuilder()
+            .setName("filter-chain-2")
+            .setFilterChainMatch(filterChainMatch2)
+            .addFilters(filter2)
+            .build();
+    Listener listener =
+        Listener.newBuilder()
+            .setName("listener1")
+            .setTrafficDirection(TrafficDirection.INBOUND)
+            .addAllFilterChains(Arrays.asList(filterChain1, filterChain2))
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseServerSideListener(
+            listener, null, filterRegistry, null, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .startsWith("FilterChainMatch must be unique. Found duplicate:");
+  }
+
+  @Test
+  public void parseServerSideListener_uniqueFilterChainMatch() throws ResourceInvalidException {
+    Filter filter1 = buildHttpConnectionManagerFilter(
+        HttpFilter.newBuilder().setName("http-filter-1").setTypedConfig(
+            Any.pack(Router.newBuilder().build())).setIsOptional(true).build());
+    FilterChainMatch filterChainMatch1 =
+        FilterChainMatch.newBuilder()
+            .addAllSourcePorts(Arrays.asList(80, 8080))
+            .addAllPrefixRanges(Arrays.asList(CidrRange.newBuilder().setAddressPrefix("192.168.0.0")
+                    .setPrefixLen(UInt32Value.of(16)).build(),
+                CidrRange.newBuilder().setAddressPrefix("10.0.0.0").setPrefixLen(UInt32Value.of(8))
+                    .build()))
+            .setSourceType(FilterChainMatch.ConnectionSourceType.EXTERNAL)
+            .build();
+    FilterChain filterChain1 =
+        FilterChain.newBuilder()
+            .setName("filter-chain-1")
+            .setFilterChainMatch(filterChainMatch1)
+            .addFilters(filter1)
+            .build();
+    Filter filter2 = buildHttpConnectionManagerFilter(
+        HttpFilter.newBuilder().setName("http-filter-2").setTypedConfig(
+            Any.pack(Router.newBuilder().build())).setIsOptional(true).build());
+    FilterChainMatch filterChainMatch2 =
+        FilterChainMatch.newBuilder()
+            .addAllSourcePorts(Arrays.asList(443, 8080))
+            .addAllPrefixRanges(Arrays.asList(
+                CidrRange.newBuilder().setAddressPrefix("2001:DB8::8:800:200C:417A")
+                    .setPrefixLen(UInt32Value.of(60)).build(),
+                CidrRange.newBuilder().setAddressPrefix("192.168.0.0")
+                    .setPrefixLen(UInt32Value.of(16)).build()))
+            .setSourceType(FilterChainMatch.ConnectionSourceType.ANY)
+            .build();
+    FilterChain filterChain2 =
+        FilterChain.newBuilder()
+            .setName("filter-chain-2")
+            .setFilterChainMatch(filterChainMatch2)
+            .addFilters(filter2)
+            .build();
+    Listener listener =
+        Listener.newBuilder()
+            .setName("listener1")
+            .setTrafficDirection(TrafficDirection.INBOUND)
+            .addAllFilterChains(Arrays.asList(filterChain1, filterChain2))
+            .build();
+    XdsListenerResource.parseServerSideListener(
+        listener, null, filterRegistry, null, getXdsResourceTypeArgs(true));
+  }
+
+  @Test
+  public void parseFilterChain_noHcm() throws ResourceInvalidException {
+    FilterChain filterChain =
+        FilterChain.newBuilder()
+            .setName("filter-chain-foo")
+            .setFilterChainMatch(FilterChainMatch.getDefaultInstance())
+            .setTransportSocket(TransportSocket.getDefaultInstance())
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseFilterChain(
+            filterChain, "filter-chain-foo", null, filterRegistry, null, null,
+            getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "FilterChain filter-chain-foo should contain exact one HttpConnectionManager filter");
+  }
+
+  @Test
+  public void parseFilterChain_duplicateFilter() throws ResourceInvalidException {
+    Filter filter = buildHttpConnectionManagerFilter(
+        HttpFilter.newBuilder().setName("http-filter-foo").setIsOptional(true).build());
+    FilterChain filterChain =
+        FilterChain.newBuilder()
+            .setName("filter-chain-foo")
+            .setFilterChainMatch(FilterChainMatch.getDefaultInstance())
+            .setTransportSocket(TransportSocket.getDefaultInstance())
+            .addAllFilters(Arrays.asList(filter, filter))
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseFilterChain(
+            filterChain, "filter-chain-foo", null, filterRegistry, null, null,
+            getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "FilterChain filter-chain-foo should contain exact one HttpConnectionManager filter");
+  }
+
+  @Test
+  public void parseFilterChain_filterMissingTypedConfig() throws ResourceInvalidException {
+    Filter filter = Filter.newBuilder().setName("envoy.http_connection_manager").build();
+    FilterChain filterChain =
+        FilterChain.newBuilder()
+            .setName("filter-chain-foo")
+            .setFilterChainMatch(FilterChainMatch.getDefaultInstance())
+            .setTransportSocket(TransportSocket.getDefaultInstance())
+            .addFilters(filter)
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseFilterChain(
+            filterChain, "filter-chain-foo", null, filterRegistry, null, null,
+            getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "FilterChain filter-chain-foo contains filter envoy.http_connection_manager "
+            + "without typed_config");
+  }
+
+  @Test
+  public void parseFilterChain_unsupportedFilter() throws ResourceInvalidException {
+    Filter filter =
+        Filter.newBuilder()
+            .setName("unsupported")
+            .setTypedConfig(Any.newBuilder().setTypeUrl("unsupported-type-url"))
+            .build();
+    FilterChain filterChain =
+        FilterChain.newBuilder()
+            .setName("filter-chain-foo")
+            .setFilterChainMatch(FilterChainMatch.getDefaultInstance())
+            .setTransportSocket(TransportSocket.getDefaultInstance())
+            .addFilters(filter)
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseFilterChain(
+            filterChain, "filter-chain-foo", null, filterRegistry, null, null,
+            getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "FilterChain filter-chain-foo contains filter unsupported with unsupported "
+            + "typed_config type unsupported-type-url");
+  }
+
+  @Test
+  public void parseFilterChain_noName() throws ResourceInvalidException {
+    FilterChain filterChain0 =
+        FilterChain.newBuilder()
+            .setFilterChainMatch(FilterChainMatch.getDefaultInstance())
+            .addFilters(buildHttpConnectionManagerFilter(
+                HttpFilter.newBuilder()
+                    .setName("http-filter-foo")
+                    .setIsOptional(true)
+                    .setTypedConfig(Any.pack(Router.newBuilder().build()))
+                    .build()))
+            .build();
+
+    FilterChain filterChain1 =
+        FilterChain.newBuilder()
+            .setFilterChainMatch(
+                FilterChainMatch.newBuilder().addAllSourcePorts(Arrays.asList(443, 8080)))
+            .addFilters(buildHttpConnectionManagerFilter(
+                HttpFilter.newBuilder()
+                    .setName("http-filter-bar")
+                    .setTypedConfig(Any.pack(Router.newBuilder().build()))
+                    .setIsOptional(true)
+                    .build()))
+            .build();
+
+    Listener listenerProto =
+        Listener.newBuilder()
+            .setName("listener1")
+            .setTrafficDirection(TrafficDirection.INBOUND)
+            .addAllFilterChains(Arrays.asList(filterChain0, filterChain1))
+            .setDefaultFilterChain(filterChain0)
+            .build();
+    EnvoyServerProtoData.Listener listener = XdsListenerResource.parseServerSideListener(
+        listenerProto, null, filterRegistry, null, getXdsResourceTypeArgs(true));
+
+    assertThat(listener.filterChains().get(0).name()).isEqualTo("chain_0");
+    assertThat(listener.filterChains().get(1).name()).isEqualTo("chain_1");
+    assertThat(listener.defaultFilterChain().name()).isEqualTo("chain_default");
+  }
+
+  @Test
+  public void parseFilterChain_duplicateName() throws ResourceInvalidException {
+    FilterChain filterChain0 =
+        FilterChain.newBuilder()
+            .setName("filter_chain")
+            .setFilterChainMatch(FilterChainMatch.getDefaultInstance())
+            .addFilters(buildHttpConnectionManagerFilter(
+                HttpFilter.newBuilder()
+                    .setName("http-filter-foo")
+                    .setIsOptional(true)
+                    .setTypedConfig(Any.pack(Router.newBuilder().build()))
+                    .build()))
+            .build();
+
+    FilterChain filterChain1 =
+        FilterChain.newBuilder()
+            .setName("filter_chain")
+            .setFilterChainMatch(
+                FilterChainMatch.newBuilder().addAllSourcePorts(Arrays.asList(443, 8080)))
+            .addFilters(buildHttpConnectionManagerFilter(
+                HttpFilter.newBuilder()
+                    .setName("http-filter-bar")
+                    .setTypedConfig(Any.pack(Router.newBuilder().build()))
+                    .setIsOptional(true)
+                    .build()))
+            .build();
+
+    Listener listenerProto =
+        Listener.newBuilder()
+            .setName("listener1")
+            .setTrafficDirection(TrafficDirection.INBOUND)
+            .addAllFilterChains(Arrays.asList(filterChain0, filterChain1))
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsListenerResource.parseServerSideListener(
+            listenerProto, null, filterRegistry, null, getXdsResourceTypeArgs(true)));
+    assertThat(e).hasMessageThat()
+        .isEqualTo("Filter chain names must be unique. Found duplicate: filter_chain");
+  }
+
+  @Test
+  public void validateCommonTlsContext_tlsParams() {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+            .setTlsParams(TlsParameters.getDefaultInstance())
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsClusterResource.validateCommonTlsContext(commonTlsContext, null, false));
+    assertThat(e).hasMessageThat().isEqualTo("common-tls-context with tls_params is not supported");
+  }
+
+  @Test
+  public void validateCommonTlsContext_customHandshaker() {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+            .setCustomHandshaker(TypedExtensionConfig.getDefaultInstance())
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsClusterResource.validateCommonTlsContext(commonTlsContext, null, false));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "common-tls-context with custom_handshaker is not supported");
+  }
+
+  @Test
+  public void validateCommonTlsContext_validationContext() {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+            .setValidationContext(CertificateValidationContext.getDefaultInstance())
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsClusterResource.validateCommonTlsContext(commonTlsContext, null, false));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "ca_certificate_provider_instance or system_root_certs is required "
+            + "in upstream-tls-context");
+  }
+
+  @Test
+  public void validateCommonTlsContext_validationContextSdsSecretConfig() {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setValidationContextSdsSecretConfig(SdsSecretConfig.getDefaultInstance())
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsClusterResource.validateCommonTlsContext(commonTlsContext, null, false));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "common-tls-context with validation_context_sds_secret_config is not supported");
+  }
+
+  @Test
+  public void validateCommonTlsContext_tlsCertificateProviderInstance_isRequiredForServer()
+      throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsClusterResource.validateCommonTlsContext(commonTlsContext, null, true));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "tls_certificate_provider_instance is required in downstream-tls-context");
+  }
+
+  @Test
+  public void validateCommonTlsContext_tlsNewCertificateProviderInstance()
+      throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setTlsCertificateProviderInstance(
+            CertificateProviderPluginInstance.newBuilder().setInstanceName("name1"))
+        .build();
+    XdsClusterResource
+        .validateCommonTlsContext(commonTlsContext, ImmutableSet.of("name1", "name2"), true);
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void validateCommonTlsContext_tlsDeprecatedCertificateProviderInstance()
+      throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setTlsCertificateCertificateProviderInstance(
+            CommonTlsContext.CertificateProviderInstance.newBuilder().setInstanceName("name1"))
+        .build();
+    XdsClusterResource
+        .validateCommonTlsContext(commonTlsContext, ImmutableSet.of("name1", "name2"), true);
+  }
+
+  @Test
+  public void validateCommonTlsContext_tlsCertificateProviderInstance()
+      throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setTlsCertificateProviderInstance(
+            CertificateProviderPluginInstance.newBuilder().setInstanceName("name1"))
+        .build();
+    XdsClusterResource
+        .validateCommonTlsContext(commonTlsContext, ImmutableSet.of("name1", "name2"), true);
+  }
+
+  @Test
+  public void validateCommonTlsContext_tlsCertificateProviderInstance_absentInBootstrapFile()
+          throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setTlsCertificateProviderInstance(
+            CertificateProviderPluginInstance.newBuilder().setInstanceName("bad-name"))
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsClusterResource.validateCommonTlsContext(commonTlsContext,
+            ImmutableSet.of("name1", "name2"), true));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "CertificateProvider instance name 'bad-name' not defined in the bootstrap file.");
+  }
+
+  @Test
+  public void validateCommonTlsContext_validationContextProviderInstance()
+          throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setCombinedValidationContext(
+            CommonTlsContext.CombinedCertificateValidationContext.newBuilder()
+              .setDefaultValidationContext(CertificateValidationContext.newBuilder()
+                .setCaCertificateProviderInstance(CertificateProviderPluginInstance.newBuilder()
+                  .setInstanceName("name1"))))
+        .build();
+    XdsClusterResource
+        .validateCommonTlsContext(commonTlsContext, ImmutableSet.of("name1", "name2"), false);
+  }
+
+  @Test
+  public void
+      validateCommonTlsContext_combinedValidationContextSystemRootCerts_envVarNotSet_throws() {
+    XdsClusterResource.enableSystemRootCerts = false;
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setCombinedValidationContext(
+            CommonTlsContext.CombinedCertificateValidationContext.newBuilder()
+                .setDefaultValidationContext(
+                    CertificateValidationContext.newBuilder()
+                        .setSystemRootCerts(
+                            CertificateValidationContext.SystemRootCerts.newBuilder().build())
+                        .build()
+                )
+                .build())
+        .build();
+    try {
+      XdsClusterResource
+          .validateCommonTlsContext(commonTlsContext, ImmutableSet.of(), false);
+      fail("Expected exception");
+    } catch (ResourceInvalidException ex) {
+      assertThat(ex.getMessage()).isEqualTo(
+          "ca_certificate_provider_instance or system_root_certs is required in"
+              + " upstream-tls-context");
+    }
+  }
+
+  @Test
+  public void validateCommonTlsContext_combinedValidationContextSystemRootCerts()
+      throws ResourceInvalidException {
+    XdsClusterResource.enableSystemRootCerts = true;
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setCombinedValidationContext(
+            CommonTlsContext.CombinedCertificateValidationContext.newBuilder()
+                .setDefaultValidationContext(
+                    CertificateValidationContext.newBuilder()
+                        .setSystemRootCerts(
+                            CertificateValidationContext.SystemRootCerts.newBuilder().build())
+                        .build()
+                )
+                .build())
+        .build();
+    XdsClusterResource
+        .validateCommonTlsContext(commonTlsContext, ImmutableSet.of(), false);
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void validateCommonTlsContext_combinedValidationContextDeprecatedCertProvider()
+      throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setTlsCertificateProviderInstance(
+            CertificateProviderPluginInstance.newBuilder().setInstanceName("cert1"))
+        .setCombinedValidationContext(
+            CommonTlsContext.CombinedCertificateValidationContext.newBuilder()
+                .setValidationContextCertificateProviderInstance(
+                    CommonTlsContext.CertificateProviderInstance.newBuilder()
+                        .setInstanceName("root1"))
+                .build())
+        .build();
+    XdsClusterResource
+        .validateCommonTlsContext(commonTlsContext, ImmutableSet.of("cert1", "root1"), true);
+  }
+
+  @Test
+  public void validateCommonTlsContext_validationContextSystemRootCerts_envVarNotSet_throws() {
+    XdsClusterResource.enableSystemRootCerts = false;
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setValidationContext(
+            CertificateValidationContext.newBuilder()
+                .setSystemRootCerts(
+                    CertificateValidationContext.SystemRootCerts.newBuilder().build())
+                .build())
+        .build();
+    try {
+      XdsClusterResource
+          .validateCommonTlsContext(commonTlsContext, ImmutableSet.of(), false);
+      fail("Expected exception");
+    } catch (ResourceInvalidException ex) {
+      assertThat(ex.getMessage()).isEqualTo(
+          "ca_certificate_provider_instance or system_root_certs is required in "
+              + "upstream-tls-context");
+    }
+  }
+
+  @Test
+  public void validateCommonTlsContext_validationContextSystemRootCerts()
+      throws ResourceInvalidException {
+    XdsClusterResource.enableSystemRootCerts = true;
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setValidationContext(
+            CertificateValidationContext.newBuilder()
+                .setSystemRootCerts(
+                    CertificateValidationContext.SystemRootCerts.newBuilder().build())
+                .build())
+        .build();
+    XdsClusterResource
+        .validateCommonTlsContext(commonTlsContext, ImmutableSet.of(), false);
+  }
+
+  @Test
+  public void validateCommonTlsContext_validationContextProviderInstance_absentInBootstrapFile()
+          throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setCombinedValidationContext(
+            CommonTlsContext.CombinedCertificateValidationContext.newBuilder()
+              .setDefaultValidationContext(CertificateValidationContext.newBuilder()
+                .setCaCertificateProviderInstance(CertificateProviderPluginInstance.newBuilder()
+                  .setInstanceName("bad-name"))))
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsClusterResource.validateCommonTlsContext(commonTlsContext,
+            ImmutableSet.of("name1", "name2"), false));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "ca_certificate_provider_instance name 'bad-name' not defined in the bootstrap file.");
+  }
+
+
+  @Test
+  public void validateCommonTlsContext_tlsCertificatesCount() throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+            .addTlsCertificates(TlsCertificate.getDefaultInstance())
+            .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsClusterResource.validateCommonTlsContext(commonTlsContext, null, false));
+    assertThat(e).hasMessageThat().isEqualTo("tls_certificate_provider_instance is unset");
+  }
+
+  @Test
+  public void validateCommonTlsContext_tlsCertificateSdsSecretConfigsCount()
+      throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .addTlsCertificateSdsSecretConfigs(SdsSecretConfig.getDefaultInstance())
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsClusterResource.validateCommonTlsContext(commonTlsContext, null, false));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "tls_certificate_provider_instance is unset");
+  }
+
+  @Test
+  public void validateCommonTlsContext_combinedValidationContext_isRequiredForClient()
+      throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+        XdsClusterResource.validateCommonTlsContext(commonTlsContext, null, false));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "ca_certificate_provider_instance or system_root_certs is required "
+            + "in upstream-tls-context");
+  }
+
+  @Test
+  public void validateCommonTlsContext_combinedValidationContextWithoutCertProviderInstance()
+      throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setCombinedValidationContext(
+            CommonTlsContext.CombinedCertificateValidationContext.getDefaultInstance())
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+        XdsClusterResource.validateCommonTlsContext(commonTlsContext, null, false));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "ca_certificate_provider_instance or system_root_certs is required in "
+            + "upstream-tls-context");
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void validateCommonTlsContext_combinedValContextWithDefaultValContextForServer()
+      throws ResourceInvalidException, InvalidProtocolBufferException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setCombinedValidationContext(
+            CombinedCertificateValidationContext.newBuilder()
+                .setDefaultValidationContext(CertificateValidationContext.newBuilder()
+                    .setCaCertificateProviderInstance(
+                        CertificateProviderPluginInstance.getDefaultInstance())
+                    .addMatchSubjectAltNames(StringMatcher.newBuilder().setExact("foo.com").build())
+                    .build()))
+        .setTlsCertificateProviderInstance(
+            CertificateProviderPluginInstance.getDefaultInstance())
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+        XdsClusterResource.validateCommonTlsContext(commonTlsContext, ImmutableSet.of(""), true));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "match_subject_alt_names only allowed in upstream_tls_context");
+  }
+
+  @Test
+  public void validateCommonTlsContext_combinedValContextWithDefaultValContextVerifyCertSpki()
+      throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setCombinedValidationContext(
+            CommonTlsContext.CombinedCertificateValidationContext.newBuilder()
+                .setDefaultValidationContext(CertificateValidationContext.newBuilder()
+                    .setCaCertificateProviderInstance(
+                        CertificateProviderPluginInstance.getDefaultInstance())
+                    .addVerifyCertificateSpki("foo")))
+        .setTlsCertificateProviderInstance(CertificateProviderPluginInstance.getDefaultInstance())
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+        XdsClusterResource.validateCommonTlsContext(commonTlsContext, ImmutableSet.of(""), false));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "verify_certificate_spki in default_validation_context is not supported");
+  }
+
+  @Test
+  public void validateCommonTlsContext_combinedValContextWithDefaultValContextVerifyCertHash()
+      throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setCombinedValidationContext(
+            CommonTlsContext.CombinedCertificateValidationContext.newBuilder()
+                .setDefaultValidationContext(CertificateValidationContext.newBuilder()
+                    .setCaCertificateProviderInstance(
+                        CertificateProviderPluginInstance.getDefaultInstance())
+                    .addVerifyCertificateHash("foo")))
+        .setTlsCertificateProviderInstance(CertificateProviderPluginInstance.getDefaultInstance())
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+        XdsClusterResource.validateCommonTlsContext(commonTlsContext, ImmutableSet.of(""), false));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "verify_certificate_hash in default_validation_context is not supported");
+  }
+
+  @Test
+  public void validateCommonTlsContext_combinedValContextDfltValContextRequireSignedCertTimestamp()
+      throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setCombinedValidationContext(
+            CommonTlsContext.CombinedCertificateValidationContext.newBuilder()
+                .setDefaultValidationContext(CertificateValidationContext.newBuilder()
+                    .setCaCertificateProviderInstance(
+                        CertificateProviderPluginInstance.getDefaultInstance())
+                    .setRequireSignedCertificateTimestamp(BoolValue.of(true))))
+        .setTlsCertificateProviderInstance(
+            CertificateProviderPluginInstance.getDefaultInstance())
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+        XdsClusterResource.validateCommonTlsContext(commonTlsContext, ImmutableSet.of(""), false));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "require_signed_certificate_timestamp in default_validation_context is not "
+            + "supported");
+  }
+
+  @Test
+  public void validateCommonTlsContext_combinedValidationContextWithDefaultValidationContextCrl()
+      throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setCombinedValidationContext(
+            CommonTlsContext.CombinedCertificateValidationContext.newBuilder()
+                .setDefaultValidationContext(CertificateValidationContext.newBuilder()
+                    .setCaCertificateProviderInstance(
+                        CertificateProviderPluginInstance.getDefaultInstance())
+                    .setCrl(DataSource.getDefaultInstance())))
+        .setTlsCertificateProviderInstance(CertificateProviderPluginInstance.getDefaultInstance())
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+        XdsClusterResource.validateCommonTlsContext(commonTlsContext, ImmutableSet.of(""), false));
+    assertThat(e).hasMessageThat().isEqualTo("crl in default_validation_context is not supported");
+  }
+
+  @Test
+  public void validateCommonTlsContext_combinedValContextWithDfltValContextCustomValidatorConfig()
+      throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setCombinedValidationContext(
+            CommonTlsContext.CombinedCertificateValidationContext.newBuilder()
+                .setDefaultValidationContext(CertificateValidationContext.newBuilder()
+                    .setCaCertificateProviderInstance(
+                        CertificateProviderPluginInstance.getDefaultInstance())
+                    .setCustomValidatorConfig(TypedExtensionConfig.getDefaultInstance())))
+        .setTlsCertificateProviderInstance(CertificateProviderPluginInstance.getDefaultInstance())
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+        XdsClusterResource.validateCommonTlsContext(commonTlsContext, ImmutableSet.of(""), false));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "custom_validator_config in default_validation_context is not supported");
+  }
+
+  @Test
+  public void validateDownstreamTlsContext_noCommonTlsContext() throws ResourceInvalidException {
+    DownstreamTlsContext downstreamTlsContext = DownstreamTlsContext.getDefaultInstance();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+        XdsListenerResource.validateDownstreamTlsContext(downstreamTlsContext, null));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "common-tls-context is required in downstream-tls-context");
+  }
+
+  @Test
+  public void validateDownstreamTlsContext_hasRequireSni() throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setCombinedValidationContext(
+            CommonTlsContext.CombinedCertificateValidationContext.newBuilder()
+                .setDefaultValidationContext(CertificateValidationContext.newBuilder()
+                    .setCaCertificateProviderInstance(
+                        CertificateProviderPluginInstance.getDefaultInstance())))
+        .setTlsCertificateProviderInstance(CertificateProviderPluginInstance.getDefaultInstance())
+        .build();
+    DownstreamTlsContext downstreamTlsContext = DownstreamTlsContext.newBuilder()
+        .setCommonTlsContext(commonTlsContext)
+        .setRequireSni(BoolValue.of(true))
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+        XdsListenerResource.validateDownstreamTlsContext(downstreamTlsContext,
+            ImmutableSet.of("")));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "downstream-tls-context with require-sni is not supported");
+  }
+
+  @Test
+  public void validateDownstreamTlsContext_hasOcspStaplePolicy() throws ResourceInvalidException {
+    CommonTlsContext commonTlsContext = CommonTlsContext.newBuilder()
+        .setCombinedValidationContext(
+            CommonTlsContext.CombinedCertificateValidationContext.newBuilder()
+                .setDefaultValidationContext(CertificateValidationContext.newBuilder()
+                    .setCaCertificateProviderInstance(
+                        CertificateProviderPluginInstance.getDefaultInstance())))
+        .setTlsCertificateProviderInstance(CertificateProviderPluginInstance.getDefaultInstance())
+        .build();
+    DownstreamTlsContext downstreamTlsContext = DownstreamTlsContext.newBuilder()
+        .setCommonTlsContext(commonTlsContext)
+        .setOcspStaplePolicy(DownstreamTlsContext.OcspStaplePolicy.STRICT_STAPLING)
+        .build();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+        XdsListenerResource.validateDownstreamTlsContext(downstreamTlsContext,
+            ImmutableSet.of("")));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "downstream-tls-context with ocsp_staple_policy value STRICT_STAPLING is not supported");
+  }
+
+  @Test
+  public void validateUpstreamTlsContext_noCommonTlsContext() throws ResourceInvalidException {
+    UpstreamTlsContext upstreamTlsContext = UpstreamTlsContext.getDefaultInstance();
+    ResourceInvalidException e = assertThrows(ResourceInvalidException.class, () ->
+            XdsClusterResource.validateUpstreamTlsContext(upstreamTlsContext, null));
+    assertThat(e).hasMessageThat().isEqualTo(
+        "common-tls-context is required in upstream-tls-context");
+  }
+
+  @Test
+  public void validateResourceName() {
+    String traditionalResource = "cluster1.google.com";
+    assertThat(XdsClient.isResourceNameValid(traditionalResource,
+        XdsClusterResource.getInstance().typeUrl()))
+        .isTrue();
+
+    String invalidPath = "xdstp:/abc/efg";
+    assertThat(XdsClient.isResourceNameValid(invalidPath,
+        XdsClusterResource.getInstance().typeUrl())).isFalse();
+
+    String invalidPath2 = "xdstp:///envoy.config.route.v3.RouteConfiguration";
+    assertThat(XdsClient.isResourceNameValid(invalidPath2,
+        XdsRouteConfigureResource.getInstance().typeUrl())).isFalse();
+
+    String typeMatch = "xdstp:///envoy.config.route.v3.RouteConfiguration/foo/route1";
+    assertThat(XdsClient.isResourceNameValid(typeMatch,
+        XdsListenerResource.getInstance().typeUrl())).isFalse();
+    assertThat(XdsClient.isResourceNameValid(typeMatch,
+        XdsRouteConfigureResource.getInstance().typeUrl())).isTrue();
+  }
+
+  @Test
+  public void canonifyResourceName() {
+    String traditionalResource = "cluster1.google.com";
+    assertThat(XdsClient.canonifyResourceName(traditionalResource))
+        .isEqualTo(traditionalResource);
+    assertThat(XdsClient.canonifyResourceName(traditionalResource))
+        .isEqualTo(traditionalResource);
+    assertThat(XdsClient.canonifyResourceName(traditionalResource))
+        .isEqualTo(traditionalResource);
+    assertThat(XdsClient.canonifyResourceName(traditionalResource))
+        .isEqualTo(traditionalResource);
+
+    String withNoQueries = "xdstp:///envoy.config.route.v3.RouteConfiguration/foo/route1";
+    assertThat(XdsClient.canonifyResourceName(withNoQueries)).isEqualTo(withNoQueries);
+
+    String withOneQueries = "xdstp:///envoy.config.route.v3.RouteConfiguration/foo/route1?name=foo";
+    assertThat(XdsClient.canonifyResourceName(withOneQueries)).isEqualTo(withOneQueries);
+
+    String withTwoQueries = "xdstp:///envoy.config.route.v3.RouteConfiguration/id/route1?b=1&a=1";
+    String expectedCanonifiedName =
+        "xdstp:///envoy.config.route.v3.RouteConfiguration/id/route1?a=1&b=1";
+    assertThat(XdsClient.canonifyResourceName(withTwoQueries))
+        .isEqualTo(expectedCanonifiedName);
+  }
+
+  /**
+   *  Tests compliance with RFC 3986 section 3.3
+   *  https://datatracker.ietf.org/doc/html/rfc3986#section-3.3 .
+   */
+  @Test
+  public void percentEncodePath()  {
+    String unreserved = "aAzZ09-._~";
+    assertThat(XdsClient.percentEncodePath(unreserved)).isEqualTo(unreserved);
+
+    String subDelims = "!$&'(*+,;/=";
+    assertThat(XdsClient.percentEncodePath(subDelims)).isEqualTo(subDelims);
+
+    String colonAndAt = ":@";
+    assertThat(XdsClient.percentEncodePath(colonAndAt)).isEqualTo(colonAndAt);
+
+    String needBeEncoded = "?#[]";
+    assertThat(XdsClient.percentEncodePath(needBeEncoded)).isEqualTo("%3F%23%5B%5D");
+
+    String ipv4 = "0.0.0.0:8080";
+    assertThat(XdsClient.percentEncodePath(ipv4)).isEqualTo(ipv4);
+
+    String ipv6 = "[::1]:8080";
+    assertThat(XdsClient.percentEncodePath(ipv6)).isEqualTo("%5B::1%5D:8080");
+  }
+
+  private static Filter buildHttpConnectionManagerFilter(HttpFilter... httpFilters) {
+    return Filter.newBuilder()
+        .setName("envoy.http_connection_manager")
+        .setTypedConfig(
+            Any.pack(
+                HttpConnectionManager.newBuilder()
+                    .setRds(
+                        Rds.newBuilder()
+                            .setRouteConfigName("route-config.googleapis.com")
+                            .setConfigSource(
+                                ConfigSource.newBuilder()
+                                    .setAds(AggregatedConfigSource.getDefaultInstance())))
+                    .addAllHttpFilters(Arrays.asList(httpFilters))
+                    .build(),
+                "type.googleapis.com"))
+        .build();
+  }
+
+  private XdsResourceType.Args getXdsResourceTypeArgs(boolean isTrustedServer) {
+    return new XdsResourceType.Args(
+        ServerInfo.create("http://td", "", false, isTrustedServer, false, false), "1.0", null, null, null, null
+    );
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/GrpcXdsClientImplTestBase.java b/xds/src/test/java/io/grpc/xds/GrpcXdsClientImplTestBase.java
new file mode 100644
index 00000000000..af55e572811
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/GrpcXdsClientImplTestBase.java
@@ -0,0 +1,5445 @@
+/*
+ * Copyright 2019 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static io.grpc.StatusMatcher.statusHasCode;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.Any;
+import com.google.protobuf.Duration;
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.Message;
+import com.google.protobuf.StringValue;
+import com.google.protobuf.UInt32Value;
+import com.google.protobuf.util.Durations;
+import io.envoyproxy.envoy.config.cluster.v3.OutlierDetection;
+import io.envoyproxy.envoy.config.route.v3.FilterConfig;
+import io.envoyproxy.envoy.config.route.v3.WeightedCluster;
+import io.envoyproxy.envoy.extensions.filters.http.router.v3.Router;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateProviderPluginInstance;
+import io.grpc.BindableService;
+import io.grpc.ChannelCredentials;
+import io.grpc.Context;
+import io.grpc.Context.CancellableContext;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.ManagedChannel;
+import io.grpc.Server;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.StatusOr;
+import io.grpc.StatusOrMatcher;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.FakeClock.ScheduledTask;
+import io.grpc.internal.FakeClock.TaskFilter;
+import io.grpc.internal.JsonUtil;
+import io.grpc.internal.ServiceConfigUtil;
+import io.grpc.internal.ServiceConfigUtil.LbConfig;
+import io.grpc.internal.TimeProvider;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.xds.Endpoints.DropOverload;
+import io.grpc.xds.Endpoints.LbEndpoint;
+import io.grpc.xds.Endpoints.LocalityLbEndpoints;
+import io.grpc.xds.EnvoyServerProtoData.FailurePercentageEjection;
+import io.grpc.xds.EnvoyServerProtoData.FilterChain;
+import io.grpc.xds.EnvoyServerProtoData.SuccessRateEjection;
+import io.grpc.xds.FaultConfig.FractionalPercent.DenominatorType;
+import io.grpc.xds.GrpcXdsTransportFactory.GrpcXdsTransport;
+import io.grpc.xds.XdsClusterResource.CdsUpdate;
+import io.grpc.xds.XdsClusterResource.CdsUpdate.ClusterType;
+import io.grpc.xds.XdsEndpointResource.EdsUpdate;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.XdsRouteConfigureResource.RdsUpdate;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.Bootstrapper.AuthorityInfo;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.Bootstrapper.CertificateProviderInfo;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.BootstrapperImpl;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+import io.grpc.xds.client.LoadStatsManager2.ClusterDropStats;
+import io.grpc.xds.client.Locality;
+import io.grpc.xds.client.XdsClient.ResourceMetadata;
+import io.grpc.xds.client.XdsClient.ResourceMetadata.ResourceMetadataStatus;
+import io.grpc.xds.client.XdsClient.ResourceMetadata.UpdateFailureState;
+import io.grpc.xds.client.XdsClient.ResourceUpdate;
+import io.grpc.xds.client.XdsClient.ResourceWatcher;
+import io.grpc.xds.client.XdsClient.ServerConnectionCallback;
+import io.grpc.xds.client.XdsClientImpl;
+import io.grpc.xds.client.XdsClientMetricReporter;
+import io.grpc.xds.client.XdsResourceType;
+import io.grpc.xds.client.XdsResourceType.ResourceInvalidException;
+import io.grpc.xds.client.XdsTransportFactory;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil;
+import io.grpc.xds.internal.security.TlsContextManagerImpl;
+import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Queue;
+import java.util.concurrent.BlockingDeque;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingDeque;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import javax.annotation.Nullable;
+import org.junit.After;
+import org.junit.Assume;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
+import org.mockito.verification.VerificationMode;
+
+/**
+ * Tests for {@link XdsClientImpl}.
+ */
+@RunWith(JUnit4.class)
+// The base class was used to test both xds v2 and v3. V2 is dropped now so the base class is not
+// necessary. Still keep it for future version usage. Remove if too much trouble to maintain.
+public abstract class GrpcXdsClientImplTestBase {
+
+  private static final String SERVER_URI = "trafficdirector.googleapis.com";
+  private static final String SERVER_URI_CUSTOM_AUTHORITY = "trafficdirector2.googleapis.com";
+  private static final String SERVER_URI_EMPTY_AUTHORITY = "trafficdirector3.googleapis.com";
+  private static final String LDS_RESOURCE = "listener.googleapis.com";
+  private static final String RDS_RESOURCE = "route-configuration.googleapis.com";
+  private static final String CDS_RESOURCE = "cluster.googleapis.com";
+  private static final String EDS_RESOURCE = "cluster-load-assignment.googleapis.com";
+  private static final String LISTENER_RESOURCE =
+      "grpc/server?xds.resource.listening_address=0.0.0.0:7000";
+  private static final String VERSION_1 = "42";
+  private static final String VERSION_2 = "43";
+  private static final String VERSION_3 = "44";
+  private static final String NODE_ID = "cool-node-id";
+  private static final Node NODE = Node.newBuilder().setId(NODE_ID).build();
+  private static final Any FAILING_ANY = MessageFactory.FAILING_ANY;
+  private static final ChannelCredentials CHANNEL_CREDENTIALS = InsecureChannelCredentials.create();
+  private static final XdsResourceType<?> LDS = XdsListenerResource.getInstance();
+  private static final XdsResourceType<?> CDS = XdsClusterResource.getInstance();
+  private static final XdsResourceType<?> RDS = XdsRouteConfigureResource.getInstance();
+  private static final XdsResourceType<?> EDS = XdsEndpointResource.getInstance();
+
+  // xDS control plane server info.
+  private ServerInfo xdsServerInfo;
+
+  private static final FakeClock.TaskFilter RPC_RETRY_TASK_FILTER =
+      new FakeClock.TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable command) {
+          return command.toString().contains("RpcRetryTask");
+        }
+      };
+
+  private static final FakeClock.TaskFilter LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER =
+      new TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable command) {
+          return command.toString().contains(LDS.toString());
+        }
+      };
+
+  private static final FakeClock.TaskFilter RDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER =
+      new TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable command) {
+          return command.toString().contains(RDS.toString());
+        }
+      };
+
+  private static final FakeClock.TaskFilter CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER =
+      new TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable command) {
+          return command.toString().contains(CDS.toString());
+        }
+      };
+
+  private static final FakeClock.TaskFilter EDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER =
+      new FakeClock.TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable command) {
+          return command.toString().contains(EDS.toString());
+        }
+      };
+
+  @Rule
+  public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private final FakeClock fakeClock = new FakeClock();
+  protected final BlockingDeque<DiscoveryRpcCall> resourceDiscoveryCalls =
+      new LinkedBlockingDeque<>(1);
+  protected final Queue<LrsRpcCall> loadReportCalls = new ArrayDeque<>();
+  protected final AtomicBoolean adsEnded = new AtomicBoolean(true);
+  protected final AtomicBoolean lrsEnded = new AtomicBoolean(true);
+  protected MessageFactory mf;
+
+  private static final long TIME_INCREMENT = TimeUnit.SECONDS.toNanos(1);
+  /** Fake time provider increments time TIME_INCREMENT each call. */
+  private final TimeProvider timeProvider = new TimeProvider() {
+    private long count;
+    @Override
+    public long currentTimeNanos() {
+      return ++count * TIME_INCREMENT;
+    }
+  };
+
+  private static final int VHOST_SIZE = 2;
+  // LDS test resources.
+  private Any testListenerVhosts;
+  private Any testListenerRds;
+
+  // RDS test resources.
+  private Any testRouteConfig;
+
+  // CDS test resources.
+  private Any testClusterRoundRobin;
+
+  // EDS test resources.
+  private Message lbEndpointHealthy;
+  // Locality with 0 endpoints
+  private Message lbEndpointEmpty;
+  // Locality with 0-weight endpoint
+  private Message lbEndpointZeroWeight;
+  private Any testClusterLoadAssignment;
+  @Captor
+  private ArgumentCaptor<StatusOr<LdsUpdate>> ldsUpdateCaptor;
+  @Captor
+  private ArgumentCaptor<StatusOr<RdsUpdate>> rdsUpdateCaptor;
+  @Captor
+  private ArgumentCaptor<StatusOr<CdsUpdate>> cdsUpdateCaptor;
+  @Captor
+  private ArgumentCaptor<StatusOr<EdsUpdate>> edsUpdateCaptor;
+
+  @Mock
+  private BackoffPolicy.Provider backoffPolicyProvider;
+  @Mock
+  private BackoffPolicy backoffPolicy1;
+  @Mock
+  private BackoffPolicy backoffPolicy2;
+  @Mock
+  private ResourceWatcher<LdsUpdate> ldsResourceWatcher;
+  @Mock
+  private ResourceWatcher<LdsUpdate> ldsResourceWatcher2;
+  @Mock
+  private ResourceWatcher<RdsUpdate> rdsResourceWatcher;
+  @Mock
+  private ResourceWatcher<CdsUpdate> cdsResourceWatcher;
+  @Mock
+  private ResourceWatcher<EdsUpdate> edsResourceWatcher;
+  @Mock
+  private ResourceWatcher<StringUpdate> stringResourceWatcher;
+  @Mock
+  private XdsClientMetricReporter xdsClientMetricReporter;
+  @Mock
+  private ServerConnectionCallback serverConnectionCallback;
+
+  private ManagedChannel channel;
+  private ManagedChannel channelForCustomAuthority;
+  private ManagedChannel channelForEmptyAuthority;
+  private XdsClientImpl xdsClient;
+  private boolean originalEnableLeastRequest;
+  private Server xdsServer;
+  private final String serverName = InProcessServerBuilder.generateName();
+  private BindableService adsService;
+  private BindableService lrsService;
+
+  private XdsTransportFactory xdsTransportFactory = new XdsTransportFactory() {
+    @Override
+    public XdsTransport create(ServerInfo serverInfo) {
+      if (serverInfo.target().equals(SERVER_URI)) {
+        return new GrpcXdsTransport(channel);
+      }
+      if (serverInfo.target().equals(SERVER_URI_CUSTOM_AUTHORITY)) {
+        if (channelForCustomAuthority == null) {
+          channelForCustomAuthority = cleanupRule.register(
+              InProcessChannelBuilder.forName(serverName).directExecutor().build());
+        }
+        return new GrpcXdsTransport(channelForCustomAuthority);
+      }
+      if (serverInfo.target().equals(SERVER_URI_EMPTY_AUTHORITY)) {
+        if (channelForEmptyAuthority == null) {
+          channelForEmptyAuthority = cleanupRule.register(
+              InProcessChannelBuilder.forName(serverName).directExecutor().build());
+        }
+        return new GrpcXdsTransport(channelForEmptyAuthority);
+      }
+      throw new IllegalArgumentException("Can not create channel for " + serverInfo);
+    }
+  };
+
+  @Before
+  public void setUp() throws IOException {
+    mf = createMessageFactory();
+    testListenerVhosts = Any.pack(mf.buildListenerWithApiListener(LDS_RESOURCE,
+        mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(VHOST_SIZE))));
+    testListenerRds =
+        Any.pack(mf.buildListenerWithApiListenerForRds(LDS_RESOURCE, RDS_RESOURCE));
+    testRouteConfig =
+        Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE, mf.buildOpaqueVirtualHosts(VHOST_SIZE)));
+    testClusterRoundRobin =
+        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, null, "round_robin", null,
+            null, false, null, "envoy.transport_sockets.tls", null, null
+        ));
+    lbEndpointHealthy =
+        mf.buildLocalityLbEndpoints("region1", "zone1", "subzone1",
+            mf.buildLbEndpoint("192.168.0.1", 8080, "healthy", 2, "endpoint-host-name"), 1, 0);
+    lbEndpointEmpty =
+        mf.buildLocalityLbEndpoints("region3", "zone3", "subzone3",
+            ImmutableList.<Message>of(), 2, 1);
+    lbEndpointZeroWeight =
+        mf.buildLocalityLbEndpoints("region4", "zone4", "subzone4",
+            mf.buildLbEndpoint("192.168.142.5", 80, "unknown", 5, "endpoint-host-name"), 0, 2);
+    testClusterLoadAssignment = Any.pack(mf.buildClusterLoadAssignment(EDS_RESOURCE,
+        ImmutableList.of(lbEndpointHealthy, lbEndpointEmpty, lbEndpointZeroWeight),
+        ImmutableList.of(mf.buildDropOverload("lb", 200), mf.buildDropOverload("throttle", 1000))));
+    adsService = createAdsService();
+    lrsService = createLrsService();
+
+    when(backoffPolicyProvider.get()).thenReturn(backoffPolicy1, backoffPolicy2);
+    when(backoffPolicy1.nextBackoffNanos()).thenReturn(10L, 100L);
+    when(backoffPolicy2.nextBackoffNanos()).thenReturn(20L, 200L);
+
+    // Start the server and the client.
+    originalEnableLeastRequest = XdsClusterResource.enableLeastRequest;
+    XdsClusterResource.enableLeastRequest = true;
+    xdsServer = cleanupRule.register(InProcessServerBuilder
+        .forName(serverName)
+        .addService(adsService)
+        .addService(lrsService)
+        .directExecutor()
+        .build()
+        .start());
+    channel =
+        cleanupRule.register(InProcessChannelBuilder.forName(serverName).directExecutor().build());
+
+    xdsServerInfo = ServerInfo.create(SERVER_URI, CHANNEL_CREDENTIALS, ignoreResourceDeletion(),
+        true, false, false);
+    BootstrapInfo bootstrapInfo =
+        Bootstrapper.BootstrapInfo.builder()
+            .servers(Collections.singletonList(xdsServerInfo))
+            .node(NODE)
+            .authorities(ImmutableMap.of(
+                "authority.xds.com",
+                AuthorityInfo.create(
+                    "xdstp://authority.xds.com/envoy.config.listener.v3.Listener/%s",
+                    ImmutableList.of(Bootstrapper.ServerInfo.create(
+                        SERVER_URI_CUSTOM_AUTHORITY, CHANNEL_CREDENTIALS))),
+                "",
+                AuthorityInfo.create(
+                    "xdstp:///envoy.config.listener.v3.Listener/%s",
+                    ImmutableList.of(Bootstrapper.ServerInfo.create(
+                        SERVER_URI_EMPTY_AUTHORITY, CHANNEL_CREDENTIALS)))))
+            .certProviders(ImmutableMap.of("cert-instance-name",
+                CertificateProviderInfo.create("file-watcher", ImmutableMap.<String, Object>of())))
+            .build();
+    xdsClient =
+        new XdsClientImpl(
+            xdsTransportFactory,
+            bootstrapInfo,
+            fakeClock.getScheduledExecutorService(),
+            backoffPolicyProvider,
+            fakeClock.getStopwatchSupplier(),
+            timeProvider,
+            MessagePrinter.INSTANCE,
+            new TlsContextManagerImpl(bootstrapInfo),
+            xdsClientMetricReporter);
+
+    assertThat(resourceDiscoveryCalls).isEmpty();
+    assertThat(loadReportCalls).isEmpty();
+  }
+
+  @After
+  public void tearDown() {
+    XdsClusterResource.enableLeastRequest = originalEnableLeastRequest;
+    xdsClient.shutdown();
+    channel.shutdown();  // channel not owned by XdsClient
+    assertThat(adsEnded.get()).isTrue();
+    assertThat(lrsEnded.get()).isTrue();
+    assertThat(fakeClock.getPendingTasks()).isEmpty();
+  }
+
+  /** Whether ignore_resource_deletion server feature is enabled for the given test. */
+  protected abstract boolean ignoreResourceDeletion();
+
+  protected abstract BindableService createAdsService();
+
+  protected abstract BindableService createLrsService();
+
+  protected abstract MessageFactory createMessageFactory();
+
+  protected static boolean matchErrorDetail(
+      com.google.rpc.Status errorDetail, int expectedCode, List<String> expectedMessages) {
+    if (expectedCode != errorDetail.getCode()) {
+      return false;
+    }
+    List<String> errors = Splitter.on('\n').splitToList(errorDetail.getMessage());
+    if (errors.size() != expectedMessages.size()) {
+      return false;
+    }
+    for (int i = 0; i < errors.size(); i++) {
+      if (!errors.get(i).startsWith(expectedMessages.get(i))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private void verifySubscribedResourcesMetadataSizes(
+      int ldsSize, int cdsSize, int rdsSize, int edsSize) {
+    Map<XdsResourceType<?>, Map<String, ResourceMetadata>> subscribedResourcesMetadata =
+        awaitSubscribedResourcesMetadata();
+    Map<String, XdsResourceType<?>> subscribedTypeUrls =
+        xdsClient.getSubscribedResourceTypesWithTypeUrl();
+    verifyResourceCount(subscribedTypeUrls, subscribedResourcesMetadata, LDS, ldsSize);
+    verifyResourceCount(subscribedTypeUrls, subscribedResourcesMetadata, CDS, cdsSize);
+    verifyResourceCount(subscribedTypeUrls, subscribedResourcesMetadata, RDS, rdsSize);
+    verifyResourceCount(subscribedTypeUrls, subscribedResourcesMetadata, EDS, edsSize);
+  }
+
+  private void verifyResourceCount(
+      Map<String, XdsResourceType<?>> subscribedTypeUrls,
+      Map<XdsResourceType<?>, Map<String, ResourceMetadata>> subscribedResourcesMetadata,
+      XdsResourceType<?> type,
+      int size) {
+    if (size == 0) {
+      assertThat(subscribedTypeUrls.containsKey(type.typeUrl())).isFalse();
+      assertThat(subscribedResourcesMetadata.containsKey(type)).isFalse();
+    } else {
+      assertThat(subscribedTypeUrls.containsKey(type.typeUrl())).isTrue();
+      assertThat(subscribedResourcesMetadata.get(type)).hasSize(size);
+    }
+  }
+
+  private Map<XdsResourceType<?>, Map<String, ResourceMetadata>>
+      awaitSubscribedResourcesMetadata() {
+    try {
+      return xdsClient.getSubscribedResourcesMetadataSnapshot().get(20, TimeUnit.SECONDS);
+    } catch (Exception e) {
+      if (e instanceof InterruptedException) {
+        Thread.currentThread().interrupt();
+      }
+      throw new AssertionError(e);
+    }
+  }
+
+  /** Verify the resource requested, but not updated. */
+  private void verifyResourceMetadataRequested(XdsResourceType<?> type, String resourceName) {
+    verifyResourceMetadata(
+        type, resourceName, null, ResourceMetadataStatus.REQUESTED, "", 0, false);
+  }
+
+  /** Verify that the requested resource does not exist. */
+  private void verifyResourceMetadataDoesNotExist(XdsResourceType<?> type, String resourceName) {
+    verifyResourceMetadata(
+        type, resourceName, null, ResourceMetadataStatus.DOES_NOT_EXIST, "", 0, false);
+  }
+
+  /** Verify the resource to be acked. */
+  private void verifyResourceMetadataAcked(
+      XdsResourceType<?> type, String resourceName, Any rawResource, String versionInfo,
+      long updateTimeNanos) {
+    verifyResourceMetadata(type, resourceName, rawResource, ResourceMetadataStatus.ACKED,
+        versionInfo, updateTimeNanos, false);
+  }
+
+  /**
+   * Verify the resource to be nacked, and every i-th line of error details to begin with
+   * corresponding i-th element of {@code List<String> failedDetails}.
+   */
+  private void verifyResourceMetadataNacked(
+      XdsResourceType<?> type, String resourceName, Any rawResource, String versionInfo,
+      long updateTime, String failedVersion, long failedUpdateTimeNanos,
+      List<String> failedDetails, boolean cached) {
+    ResourceMetadata resourceMetadata =
+        verifyResourceMetadata(type, resourceName, rawResource, ResourceMetadataStatus.NACKED,
+            versionInfo, updateTime, true);
+    assertThat(resourceMetadata.isCached()).isEqualTo(cached);
+
+    UpdateFailureState errorState = resourceMetadata.getErrorState();
+    assertThat(errorState).isNotNull();
+    String name = type.toString() + " resource '" + resourceName + "' metadata error ";
+    assertWithMessage(name + "failedVersion").that(errorState.getFailedVersion())
+        .isEqualTo(failedVersion);
+    assertWithMessage(name + "failedUpdateTimeNanos").that(errorState.getFailedUpdateTimeNanos())
+        .isEqualTo(failedUpdateTimeNanos);
+    List<String> errors = Splitter.on('\n').splitToList(errorState.getFailedDetails());
+    for (int i = 0; i < errors.size(); i++) {
+      assertWithMessage(name + "failedDetails line " + i).that(errors.get(i))
+          .startsWith(failedDetails.get(i));
+    }
+  }
+
+  private ResourceMetadata verifyResourceMetadata(
+      XdsResourceType<?> type, String resourceName, Any rawResource, ResourceMetadataStatus status,
+      String versionInfo, long updateTimeNanos, boolean hasErrorState) {
+    ResourceMetadata metadata = awaitSubscribedResourcesMetadata().get(type).get(resourceName);
+    assertThat(metadata).isNotNull();
+    String name = type.toString() + " resource '" + resourceName + "' metadata field ";
+    assertWithMessage(name + "status").that(metadata.getStatus()).isEqualTo(status);
+    assertWithMessage(name + "version").that(metadata.getVersion()).isEqualTo(versionInfo);
+    assertWithMessage(name + "rawResource").that(metadata.getRawResource()).isEqualTo(rawResource);
+    assertWithMessage(name + "updateTimeNanos").that(metadata.getUpdateTimeNanos())
+        .isEqualTo(updateTimeNanos);
+    if (hasErrorState) {
+      assertWithMessage(name + "errorState").that(metadata.getErrorState()).isNotNull();
+    } else {
+      assertWithMessage(name + "errorState").that(metadata.getErrorState()).isNull();
+    }
+    return metadata;
+  }
+
+  private void verifyStatusWithNodeId(Status status, Code expectedCode, String expectedMsg) {
+    assertThat(status.getCode()).isEqualTo(expectedCode);
+    assertThat(status.getCause()).isNull();
+    // Watcher.onError propagates status description to the channel, and we want to
+    // augment the description with the node id.
+    String description = (expectedMsg.isEmpty() ? "" : expectedMsg + " ") + "nodeID: " + NODE_ID;
+    assertThat(status.getDescription()).isEqualTo(description);
+  }
+
+  /**
+   * Verifies the LDS update against the golden Listener with vhosts {@link #testListenerVhosts}.
+   */
+  private void verifyGoldenListenerVhosts(LdsUpdate ldsUpdate) {
+    assertThat(ldsUpdate.listener()).isNull();
+    HttpConnectionManager hcm = ldsUpdate.httpConnectionManager();
+    assertThat(hcm.rdsName()).isNull();
+    assertThat(hcm.virtualHosts()).hasSize(VHOST_SIZE);
+    verifyGoldenHcm(hcm);
+  }
+
+  /**
+   * Verifies the LDS update against the golden Listener with RDS name {@link #testListenerRds}.
+   */
+  private void verifyGoldenListenerRds(LdsUpdate ldsUpdate) {
+    assertThat(ldsUpdate.listener()).isNull();
+    HttpConnectionManager hcm = ldsUpdate.httpConnectionManager();
+    assertThat(hcm.rdsName()).isEqualTo(RDS_RESOURCE);
+    assertThat(hcm.virtualHosts()).isNull();
+    verifyGoldenHcm(hcm);
+  }
+
+  private void verifyGoldenHcm(HttpConnectionManager hcm) {
+    // The last configured filter has to be a terminal filter.
+    assertThat(hcm.httpFilterConfigs()).isNotNull();
+    assertThat(hcm.httpFilterConfigs()).hasSize(1);
+    assertThat(hcm.httpFilterConfigs().get(0).name).isEqualTo("terminal");
+    assertThat(hcm.httpFilterConfigs().get(0).filterConfig).isEqualTo(RouterFilter.ROUTER_CONFIG);
+  }
+
+  /**
+   * Verifies the RDS update against the golden route config {@link #testRouteConfig}.
+   */
+  private void verifyGoldenRouteConfig(RdsUpdate rdsUpdate) {
+    assertThat(rdsUpdate.virtualHosts).hasSize(VHOST_SIZE);
+    for (VirtualHost vhost : rdsUpdate.virtualHosts) {
+      assertThat(vhost.name()).contains("do not care");
+      assertThat(vhost.domains()).hasSize(1);
+      assertThat(vhost.routes()).hasSize(1);
+    }
+  }
+
+  /**
+   * Verifies the CDS update against the golden Round Robin Cluster {@link #testClusterRoundRobin}.
+   */
+  private void verifyGoldenClusterRoundRobin(CdsUpdate cdsUpdate) {
+    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
+    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
+    assertThat(cdsUpdate.edsServiceName()).isNull();
+    LbConfig lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(cdsUpdate.lbPolicyConfig());
+    assertThat(lbConfig.getPolicyName()).isEqualTo("wrr_locality_experimental");
+    List<LbConfig> childConfigs = ServiceConfigUtil.unwrapLoadBalancingConfigList(
+        JsonUtil.getListOfObjects(lbConfig.getRawConfigValue(), "childPolicy"));
+    assertThat(childConfigs.get(0).getPolicyName()).isEqualTo("round_robin");
+    assertThat(cdsUpdate.lrsServerInfo()).isNull();
+    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
+    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
+  }
+
+  /**
+   * Verifies the EDS update against the golden Cluster with load assignment
+   * {@link #testClusterLoadAssignment}.
+   */
+  private void validateGoldenClusterLoadAssignment(EdsUpdate edsUpdate) {
+    assertThat(edsUpdate.clusterName).isEqualTo(EDS_RESOURCE);
+    assertThat(edsUpdate.dropPolicies)
+        .containsExactly(
+            DropOverload.create("lb", 200),
+            DropOverload.create("throttle", 1000));
+    assertThat(edsUpdate.localityLbEndpointsMap)
+        .containsExactly(
+            Locality.create("region1", "zone1", "subzone1"),
+            LocalityLbEndpoints.create(
+                ImmutableList.of(LbEndpoint.create("192.168.0.1", 8080, 2, true,
+                    "endpoint-host-name", ImmutableMap.of())), 1, 0, ImmutableMap.of()),
+            Locality.create("region3", "zone3", "subzone3"),
+            LocalityLbEndpoints.create(ImmutableList.<LbEndpoint>of(), 2, 1, ImmutableMap.of()));
+  }
+
+  /**
+   * Verifies that the {@link XdsClientMetricReporter#reportResourceUpdates} method has been called
+   * the expected number of times with the expected values for valid resource count, invalid
+   * resource count, and corresponding metric labels.
+   */
+  private void verifyResourceValidInvalidCount(int times, long validResourceCount,
+      long invalidResourceCount, String xdsServerTargetLabel,
+      String resourceType) {
+    verify(xdsClientMetricReporter, times(times)).reportResourceUpdates(
+        eq(validResourceCount),
+        eq(invalidResourceCount),
+        eq(xdsServerTargetLabel),
+        eq(resourceType));
+  }
+
+  private void verifyServerFailureCount(int times, long serverFailureCount, String xdsServer) {
+    verify(xdsClientMetricReporter, times(times)).reportServerFailure(
+        eq(serverFailureCount),
+        eq(xdsServer));
+  }
+
+  /**
+   * Invokes the callback, which will be called by {@link XdsClientMetricReporter} to record
+   * whether XdsClient has a working ADS stream.
+   */
+  private void callback_ReportServerConnection() {
+    try {
+      Future<Void> unused = xdsClient.reportServerConnections(serverConnectionCallback);
+    } catch (Exception e) {
+      if (e instanceof InterruptedException) {
+        Thread.currentThread().interrupt();
+      }
+      throw new AssertionError(e);
+    }
+  }
+
+  private void verifyServerConnection(int times, boolean isConnected, String xdsServer) {
+    verify(serverConnectionCallback, times(times)).reportServerConnectionGauge(
+        eq(isConnected),
+        eq(xdsServer));
+  }
+
+  @Test
+  public void doParse_returnsSuccessfully() {
+    XdsStringResource resourceType = new XdsStringResource();
+    xdsClient.watchXdsResource(
+        resourceType, "resource1", stringResourceWatcher, MoreExecutors.directExecutor());
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+
+    Any resource = Any.pack(StringValue.newBuilder().setValue("resource1").build());
+    call.sendResponse(resourceType, resource, VERSION_1, "0000");
+    verify(stringResourceWatcher).onResourceChanged(argThat(StatusOrMatcher.hasValue(
+        (StringUpdate arg) -> new StringUpdate("resource1").equals(arg))));
+  }
+
+  @Test
+  public void doParse_throwsResourceInvalidException_resourceInvalid() {
+    XdsStringResource resourceType = new XdsStringResource() {
+      @Override
+      protected StringUpdate doParse(Args args, Message unpackedMessage)
+          throws ResourceInvalidException {
+        throw new ResourceInvalidException("some bad input");
+      }
+    };
+    xdsClient.watchXdsResource(
+        resourceType, "resource1", stringResourceWatcher, MoreExecutors.directExecutor());
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+
+    Any resource = Any.pack(StringValue.newBuilder().setValue("resource1").build());
+    call.sendResponse(resourceType, resource, VERSION_1, "0000");
+    verify(stringResourceWatcher).onResourceChanged(argThat(StatusOrMatcher.hasStatus(
+        statusHasCode(Status.Code.UNAVAILABLE)
+          .andDescriptionContains("validation error: some bad input"))));
+  }
+
+  @Test
+  public void doParse_throwsError_resourceInvalid() throws Exception {
+    XdsStringResource resourceType = new XdsStringResource() {
+      @Override
+      protected StringUpdate doParse(Args args, Message unpackedMessage) {
+        throw new AssertionError("something bad happened");
+      }
+    };
+    xdsClient.watchXdsResource(
+        resourceType, "resource1", stringResourceWatcher, MoreExecutors.directExecutor());
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+
+    Any resource = Any.pack(StringValue.newBuilder().setValue("resource1").build());
+    call.sendResponse(resourceType, resource, VERSION_1, "0000");
+    verify(stringResourceWatcher).onResourceChanged(argThat(StatusOrMatcher.hasStatus(
+        statusHasCode(Status.Code.UNAVAILABLE)
+          .andDescriptionContains("unexpected error: AssertionError: something bad happened"))));
+  }
+
+  @Test
+  public void ldsResourceNotFound() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+
+    Any listener = Any.pack(mf.buildListenerWithApiListener("bar.googleapis.com",
+        mf.buildRouteConfiguration("route-bar.googleapis.com", mf.buildOpaqueVirtualHosts(1))));
+    call.sendResponse(LDS, listener, VERSION_1, "0000");
+
+    // Client sends an ACK LDS request.
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    verifyNoInteractions(ldsResourceWatcher);
+    verifyResourceMetadataRequested(LDS, LDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+    // Server failed to return subscribed resource within expected time window.
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isFalse();
+    assertThat(statusOrUpdate.getStatus().getCode()).isEqualTo(Status.Code.NOT_FOUND);
+    assertThat(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataDoesNotExist(LDS, LDS_RESOURCE);
+    // Check metric data.
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+  }
+
+  @Test
+  public void ldsResourceUpdated_withXdstpResourceName_withUnknownAuthority() {
+    String ldsResourceName =
+        "xdstp://unknown.example.com/envoy.config.listener.v3.Listener/listener1";
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), ldsResourceName,
+        ldsResourceWatcher);
+    verify(ldsResourceWatcher).onResourceChanged(argThat(statusOr ->
+        !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Status.Code.INVALID_ARGUMENT
+            && statusOr.getStatus().getDescription().equals(
+            "Wrong configuration: xds server does not exist for resource " + ldsResourceName)));
+    assertThat(resourceDiscoveryCalls.poll()).isNull();
+    xdsClient.cancelXdsResourceWatch(XdsListenerResource.getInstance(), ldsResourceName,
+        ldsResourceWatcher);
+    assertThat(resourceDiscoveryCalls.poll()).isNull();
+  }
+
+  @Test
+  public void ldsResource_onError_cachedForNewWatcher() {
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    call.sendCompleted();
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<StatusOr<LdsUpdate>> errorCaptor =
+        ArgumentCaptor.forClass(StatusOr.class);
+    verify(ldsResourceWatcher, timeout(1000)).onResourceChanged(errorCaptor.capture());
+    StatusOr<LdsUpdate> initialError = errorCaptor.getValue();
+    assertThat(initialError.hasValue()).isFalse();
+
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher2);
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<StatusOr<LdsUpdate>> secondErrorCaptor =
+        ArgumentCaptor.forClass(StatusOr.class);
+    verify(ldsResourceWatcher2, timeout(1000)).onResourceChanged(secondErrorCaptor.capture());
+    StatusOr<LdsUpdate> cachedError = secondErrorCaptor.getValue();
+
+    assertThat(cachedError).isEqualTo(initialError);
+    assertThat(resourceDiscoveryCalls.poll()).isNull();
+  }
+
+  @Test
+  public void ldsResponseErrorHandling_allResourcesFailedUnpack() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    verifyResourceMetadataRequested(LDS, LDS_RESOURCE);
+    call.sendResponse(LDS, ImmutableList.of(FAILING_ANY, FAILING_ANY), VERSION_1, "0000");
+
+    // Resulting metadata unchanged because the response has no identifiable subscribed resources.
+    verifyResourceMetadataRequested(LDS, LDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+    // The response NACKed with errors indicating indices of the failed resources.
+    call.verifyRequestNack(LDS, LDS_RESOURCE, "", "0000", NODE, ImmutableList.of(
+        "LDS response Resource index 0 - can't decode Listener: ",
+        "LDS response Resource index 1 - can't decode Listener: "));
+    verifyNoInteractions(ldsResourceWatcher);
+  }
+
+  @Test
+  public void ldsResponseErrorHandling_someResourcesFailedUnpack() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    verifyResourceMetadataRequested(LDS, LDS_RESOURCE);
+
+    // Correct resource is in the middle to ensure processing continues on errors.
+    List<Any> resources = ImmutableList.of(FAILING_ANY, testListenerRds, FAILING_ANY);
+    call.sendResponse(LDS, resources, VERSION_1, "0000");
+
+    // All errors recorded in the metadata of successfully unpacked subscribed resources.
+    List<String> errors = ImmutableList.of(
+        "LDS response Resource index 0 - can't decode Listener: ",
+        "LDS response Resource index 2 - can't decode Listener: ");
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerRds, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+    // The response is NACKed with the same error message.
+    call.verifyRequestNack(LDS, LDS_RESOURCE, "", "0000", NODE, errors);
+    verify(ldsResourceWatcher).onResourceChanged(any());
+  }
+
+  /**
+   * Tests a subscribed LDS resource transitioned to and from the invalid state.
+   *
+   * @see <a
+   *     href="https://github.com/grpc/proposal/blob/master/A40-csds-support.md#ads-parsing-logic-update-continue-after-first-error">
+   *     A40-csds-support.md</a>
+   */
+  @Test
+  public void ldsResponseErrorHandling_subscribedResourceInvalid() {
+    List<String> subscribedResourceNames = ImmutableList.of("A", "B", "C");
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), "A", ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), "B", ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), "C", ldsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    assertThat(call).isNotNull();
+    verifyResourceMetadataRequested(LDS, "A");
+    verifyResourceMetadataRequested(LDS, "B");
+    verifyResourceMetadataRequested(LDS, "C");
+    verifySubscribedResourcesMetadataSizes(3, 0, 0, 0);
+
+    // LDS -> {A, B, C}, version 1
+    ImmutableMap<String, Any> resourcesV1 = ImmutableMap.of(
+        "A", Any.pack(mf.buildListenerWithApiListenerForRds("A", "A.1")),
+        "B", Any.pack(mf.buildListenerWithApiListenerForRds("B", "B.1")),
+        "C", Any.pack(mf.buildListenerWithApiListenerForRds("C", "C.1")));
+    call.sendResponse(LDS, resourcesV1.values().asList(), VERSION_1, "0000");
+    // {A, B, C} -> ACK, version 1
+    verifyResourceMetadataAcked(LDS, "A", resourcesV1.get("A"), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(LDS, "B", resourcesV1.get("B"), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(LDS, "C", resourcesV1.get("C"), VERSION_1, TIME_INCREMENT);
+    // Check metric data.
+    verifyResourceValidInvalidCount(1, 3, 0, xdsServerInfo.target(), LDS.typeUrl());
+    call.verifyRequest(LDS, subscribedResourceNames, VERSION_1, "0000", NODE);
+
+    // LDS -> {A, B}, version 2
+    // Failed to parse endpoint B
+    ImmutableMap<String, Any> resourcesV2 = ImmutableMap.of(
+        "A", Any.pack(mf.buildListenerWithApiListenerForRds("A", "A.2")),
+        "B", Any.pack(mf.buildListenerWithApiListenerInvalid("B")));
+    call.sendResponse(LDS, resourcesV2.values().asList(), VERSION_2, "0001");
+    // {A} -> ACK, version 2
+    // {B} -> NACK, version 1, rejected version 2, rejected reason: Failed to parse B
+    // {C} -> does not exist
+    List<String> errorsV2 = ImmutableList.of("LDS response Listener 'B' validation error: ");
+    verifyResourceMetadataAcked(LDS, "A", resourcesV2.get("A"), VERSION_2, TIME_INCREMENT * 2);
+    verifyResourceMetadataNacked(LDS, "B", resourcesV1.get("B"), VERSION_1, TIME_INCREMENT,
+        VERSION_2, TIME_INCREMENT * 2, errorsV2, true);
+    // Check metric data.
+    verifyResourceValidInvalidCount(1, 1, 1, xdsServerInfo.target(), LDS.typeUrl());
+    if (!ignoreResourceDeletion()) {
+      verifyResourceMetadataDoesNotExist(LDS, "C");
+    } else {
+      // When resource deletion is disabled, {C} stays ACKed in the previous version VERSION_1.
+      verifyResourceMetadataAcked(LDS, "C", resourcesV1.get("C"), VERSION_1, TIME_INCREMENT);
+    }
+    call.verifyRequestNack(LDS, subscribedResourceNames, VERSION_1, "0001", NODE, errorsV2);
+
+    // LDS -> {B, C} version 3
+    ImmutableMap<String, Any> resourcesV3 = ImmutableMap.of(
+        "B", Any.pack(mf.buildListenerWithApiListenerForRds("B", "B.3")),
+        "C", Any.pack(mf.buildListenerWithApiListenerForRds("C", "C.3")));
+    call.sendResponse(LDS, resourcesV3.values().asList(), VERSION_3, "0002");
+    // {A} -> does not exist
+    // {B, C} -> ACK, version 3
+    // Check metric data.
+    verifyResourceValidInvalidCount(1, 2, 0, xdsServerInfo.target(), LDS.typeUrl());
+    if (!ignoreResourceDeletion()) {
+      verifyResourceMetadataDoesNotExist(LDS, "A");
+    } else {
+      // When resource deletion is disabled, {A} stays ACKed in the previous version VERSION_2.
+      verifyResourceMetadataAcked(LDS, "A", resourcesV2.get("A"), VERSION_2, TIME_INCREMENT * 2);
+    }
+    verifyResourceMetadataAcked(LDS, "B", resourcesV3.get("B"), VERSION_3, TIME_INCREMENT * 3);
+    verifyResourceMetadataAcked(LDS, "C", resourcesV3.get("C"), VERSION_3, TIME_INCREMENT * 3);
+    call.verifyRequest(LDS, subscribedResourceNames, VERSION_3, "0002", NODE);
+    verifySubscribedResourcesMetadataSizes(3, 0, 0, 0);
+  }
+
+  @Test
+  public void ldsResponseErrorHandling_subscribedResourceInvalid_withDataErrorHandlingEnabled() {
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = true;
+
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), "A", ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), "B", ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), "C", ldsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    assertThat(call).isNotNull();
+    verifyResourceMetadataRequested(LDS, "A");
+    verifyResourceMetadataRequested(LDS, "B");
+    verifyResourceMetadataRequested(LDS, "C");
+    ImmutableMap<String, Any> resourcesV1 = ImmutableMap.of(
+        "A", Any.pack(mf.buildListenerWithApiListenerForRds("A", "A.1")),
+        "B", Any.pack(mf.buildListenerWithApiListenerForRds("B", "B.1")),
+        "C", Any.pack(mf.buildListenerWithApiListenerForRds("C", "C.1")));
+    call.sendResponse(LDS, resourcesV1.values().asList(), VERSION_1, "0000");
+    verify(ldsResourceWatcher, times(3)).onResourceChanged(any());
+    ImmutableMap<String, Any> resourcesV2 = ImmutableMap.of(
+        "A", Any.pack(mf.buildListenerWithApiListenerForRds("A", "A.2")),
+        "B", Any.pack(mf.buildListenerWithApiListenerInvalid("B")));
+    call.sendResponse(LDS, resourcesV2.values().asList(), VERSION_2, "0001");
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(ldsResourceWatcher, times(2)).onAmbientError(statusCaptor.capture());
+    List<Status> receivedStatuses = statusCaptor.getAllValues();
+    assertThat(receivedStatuses).hasSize(2);
+
+    assertThat(
+        receivedStatuses.stream().anyMatch(
+            status -> status.getCode() == Status.Code.UNAVAILABLE
+                && status.getDescription().contains("LDS response Listener 'B' validation error")))
+        .isTrue();
+    assertThat(
+        receivedStatuses.stream().anyMatch(
+            status -> status.getCode() == Status.Code.NOT_FOUND
+                && status.getDescription().contains("Resource C deleted from server")))
+        .isTrue();
+    List<String> errorsV2 = ImmutableList.of("LDS response Listener 'B' validation error: ");
+    verifyResourceMetadataAcked(LDS, "A", resourcesV2.get("A"), VERSION_2, TIME_INCREMENT * 2);
+    verifyResourceMetadataNacked(LDS, "B", resourcesV1.get("B"), VERSION_1, TIME_INCREMENT,
+        VERSION_2, TIME_INCREMENT * 2, errorsV2, true);
+    verifyResourceMetadataAcked(LDS, "C", resourcesV1.get("C"), VERSION_1, TIME_INCREMENT);
+
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = false;
+  }
+
+  @Test
+  public void ldsResponseErrorHandling_subscribedResourceInvalid_withRdsSubscription() {
+    List<String> subscribedResourceNames = ImmutableList.of("A", "B", "C");
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), "A", ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), "A.1", rdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), "B", ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), "B.1", rdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), "C", ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), "C.1", rdsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    assertThat(call).isNotNull();
+    verifyResourceMetadataRequested(LDS, "A");
+    verifyResourceMetadataRequested(LDS, "B");
+    verifyResourceMetadataRequested(LDS, "C");
+    verifyResourceMetadataRequested(RDS, "A.1");
+    verifyResourceMetadataRequested(RDS, "B.1");
+    verifyResourceMetadataRequested(RDS, "C.1");
+    verifySubscribedResourcesMetadataSizes(3, 0, 3, 0);
+
+    // LDS -> {A, B, C}, version 1
+    ImmutableMap<String, Any> resourcesV1 = ImmutableMap.of(
+        "A", Any.pack(mf.buildListenerWithApiListenerForRds("A", "A.1")),
+        "B", Any.pack(mf.buildListenerWithApiListenerForRds("B", "B.1")),
+        "C", Any.pack(mf.buildListenerWithApiListenerForRds("C", "C.1")));
+    call.sendResponse(LDS, resourcesV1.values().asList(), VERSION_1, "0000");
+    // {A, B, C} -> ACK, version 1
+    verifyResourceValidInvalidCount(1, 3, 0, xdsServerInfo.target(), LDS.typeUrl());
+    verifyResourceMetadataAcked(LDS, "A", resourcesV1.get("A"), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(LDS, "B", resourcesV1.get("B"), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(LDS, "C", resourcesV1.get("C"), VERSION_1, TIME_INCREMENT);
+    call.verifyRequest(LDS, subscribedResourceNames, VERSION_1, "0000", NODE);
+
+    // RDS -> {A.1, B.1, C.1}, version 1
+    List<Message> vhostsV1 = mf.buildOpaqueVirtualHosts(1);
+    ImmutableMap<String, Any> resourcesV11 = ImmutableMap.of(
+        "A.1", Any.pack(mf.buildRouteConfiguration("A.1", vhostsV1)),
+        "B.1", Any.pack(mf.buildRouteConfiguration("B.1", vhostsV1)),
+        "C.1", Any.pack(mf.buildRouteConfiguration("C.1", vhostsV1)));
+    call.sendResponse(RDS, resourcesV11.values().asList(), VERSION_1, "0000");
+    // {A.1, B.1, C.1} -> ACK, version 1
+    verifyResourceMetadataAcked(RDS, "A.1", resourcesV11.get("A.1"), VERSION_1, TIME_INCREMENT * 2);
+    verifyResourceMetadataAcked(RDS, "B.1", resourcesV11.get("B.1"), VERSION_1, TIME_INCREMENT * 2);
+    verifyResourceMetadataAcked(RDS, "C.1", resourcesV11.get("C.1"), VERSION_1, TIME_INCREMENT * 2);
+    // Check metric data.
+    verifyResourceValidInvalidCount(1, 3, 0, xdsServerInfo.target(), RDS.typeUrl());
+
+    // LDS -> {A, B}, version 2
+    // Failed to parse endpoint B
+    ImmutableMap<String, Any> resourcesV2 = ImmutableMap.of(
+        "A", Any.pack(mf.buildListenerWithApiListenerForRds("A", "A.2")),
+        "B", Any.pack(mf.buildListenerWithApiListenerInvalid("B")));
+    call.sendResponse(LDS, resourcesV2.values().asList(), VERSION_2, "0001");
+    // {A} -> ACK, version 2
+    // {B} -> NACK, version 1, rejected version 2, rejected reason: Failed to parse B
+    // {C} -> does not exist
+    // Check metric data.
+    verifyResourceValidInvalidCount(1, 1, 1, xdsServerInfo.target(), LDS.typeUrl());
+    List<String> errorsV2 = ImmutableList.of("LDS response Listener 'B' validation error: ");
+    verifyResourceMetadataAcked(LDS, "A", resourcesV2.get("A"), VERSION_2, TIME_INCREMENT * 3);
+    verifyResourceMetadataNacked(
+        LDS, "B", resourcesV1.get("B"), VERSION_1, TIME_INCREMENT, VERSION_2, TIME_INCREMENT * 3,
+        errorsV2, true);
+    if (!ignoreResourceDeletion()) {
+      verifyResourceMetadataDoesNotExist(LDS, "C");
+    } else {
+      // When resource deletion is disabled, {C} stays ACKed in the previous version VERSION_1.
+      verifyResourceMetadataAcked(LDS, "C", resourcesV1.get("C"), VERSION_1, TIME_INCREMENT);
+    }
+    call.verifyRequestNack(LDS, subscribedResourceNames, VERSION_1, "0001", NODE, errorsV2);
+    // {A.1} -> version 1
+    // {B.1} -> version 1
+    // {C.1} -> does not exist because {C} does not exist
+    verifyResourceMetadataAcked(RDS, "A.1", resourcesV11.get("A.1"), VERSION_1, TIME_INCREMENT * 2);
+    verifyResourceMetadataAcked(RDS, "B.1", resourcesV11.get("B.1"), VERSION_1, TIME_INCREMENT * 2);
+    // Verify {C.1} stays in the previous version VERSION_1, no matter {C} is deleted or not.
+    verifyResourceMetadataAcked(RDS, "C.1", resourcesV11.get("C.1"), VERSION_1,
+        TIME_INCREMENT * 2);
+  }
+
+  @Test
+  public void ldsResourceFound_containsVirtualHosts() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+
+    // Client sends an ACK LDS request.
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(statusOrUpdate.getValue());
+    assertThat(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerVhosts, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+  }
+
+  @Test
+  public void wrappedLdsResource() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+
+    // Client sends an ACK LDS request.
+    call.sendResponse(LDS, mf.buildWrappedResource(testListenerVhosts), VERSION_1, "0000");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(statusOrUpdate.getValue());
+    assertThat(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerVhosts, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+  }
+
+  @Test
+  public void wrappedLdsResource_preferWrappedName() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+
+    Any innerResource = Any.pack(mf.buildListenerWithApiListener("random_name" /* name */,
+        mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(VHOST_SIZE))));
+
+    // Client sends an ACK LDS request.
+    call.sendResponse(LDS, mf.buildWrappedResourceWithName(innerResource, LDS_RESOURCE), VERSION_1,
+        "0000");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(statusOrUpdate.getValue());
+    assertThat(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, innerResource, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+  }
+
+  @Test
+  public void ldsResourceFound_containsRdsName() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    call.sendResponse(LDS, testListenerRds, VERSION_1, "0000");
+
+    // Client sends an ACK LDS request.
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerRds(statusOrUpdate.getValue());
+    assertThat(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerRds, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void cachedLdsResource_data() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+
+    // Client sends an ACK LDS request.
+    call.sendResponse(LDS, testListenerRds, VERSION_1, "0000");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+
+    ResourceWatcher<LdsUpdate> watcher = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE, watcher);
+    verify(watcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerRds(statusOrUpdate.getValue());
+    call.verifyNoMoreRequest();
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerRds, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void cachedLdsResource_absent() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isFalse();
+    assertThat(statusOrUpdate.getStatus().getCode()).isEqualTo(Status.Code.NOT_FOUND);
+    // Add another watcher.
+    ResourceWatcher<LdsUpdate> watcher = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE, watcher);
+    verify(watcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate1 = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate1.hasValue()).isFalse();
+    assertThat(statusOrUpdate1.getStatus().getCode()).isEqualTo(Status.Code.NOT_FOUND);
+    call.verifyNoMoreRequest();
+    verifyResourceMetadataDoesNotExist(LDS, LDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+  }
+
+  @Test
+  public void ldsResourceUpdated() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    verifyResourceMetadataRequested(LDS, LDS_RESOURCE);
+
+    // Initial LDS response.
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerVhosts, VERSION_1, TIME_INCREMENT);
+
+    // Updated LDS response.
+    call.sendResponse(LDS, testListenerRds, VERSION_2, "0001");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_2, "0001", NODE);
+    verify(ldsResourceWatcher, times(2)).onResourceChanged(ldsUpdateCaptor.capture());
+    statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerRds(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerRds, VERSION_2, TIME_INCREMENT * 2);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+    assertThat(channelForCustomAuthority).isNull();
+    assertThat(channelForEmptyAuthority).isNull();
+  }
+
+  @Test
+  public void cancelResourceWatcherNotRemoveUrlSubscribers() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    verifyResourceMetadataRequested(LDS, LDS_RESOURCE);
+
+    // Initial LDS response.
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerVhosts, VERSION_1, TIME_INCREMENT);
+
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(),
+        LDS_RESOURCE + "1", ldsResourceWatcher);
+    xdsClient.cancelXdsResourceWatch(XdsListenerResource.getInstance(), LDS_RESOURCE + "1",
+        ldsResourceWatcher);
+
+    // Updated LDS response.
+    Any testListenerVhosts2 = Any.pack(mf.buildListenerWithApiListener(LDS_RESOURCE,
+        mf.buildRouteConfiguration("new", mf.buildOpaqueVirtualHosts(VHOST_SIZE))));
+    call.sendResponse(LDS, testListenerVhosts2, VERSION_2, "0001");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_2, "0001", NODE);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerVhosts2, VERSION_2,
+        TIME_INCREMENT * 2);
+  }
+
+  @Test
+  public void ldsResourceUpdated_withXdstpResourceName() {
+    String ldsResourceName =
+        "xdstp://authority.xds.com/envoy.config.listener.v3.Listener/listener1";
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), ldsResourceName,
+        ldsResourceWatcher);
+    assertThat(channelForCustomAuthority).isNotNull();
+    verifyResourceMetadataRequested(LDS, ldsResourceName);
+
+    Any testListenerVhosts = Any.pack(mf.buildListenerWithApiListener(ldsResourceName,
+        mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(VHOST_SIZE))));
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    call.verifyRequest(LDS, ldsResourceName, VERSION_1, "0000", NODE);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(
+        LDS, ldsResourceName, testListenerVhosts, VERSION_1, TIME_INCREMENT);
+  }
+
+  @Test
+  public void ldsResourceUpdated_withXdstpResourceName_withEmptyAuthority() {
+    String ldsResourceName = "xdstp:///envoy.config.listener.v3.Listener/listener1";
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), ldsResourceName,
+        ldsResourceWatcher);
+    assertThat(channelForEmptyAuthority).isNotNull();
+    verifyResourceMetadataRequested(LDS, ldsResourceName);
+
+    Any testListenerVhosts = Any.pack(mf.buildListenerWithApiListener(ldsResourceName,
+        mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(VHOST_SIZE))));
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    call.verifyRequest(LDS, ldsResourceName, VERSION_1, "0000", NODE);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(
+        LDS, ldsResourceName, testListenerVhosts, VERSION_1, TIME_INCREMENT);
+  }
+
+  @Test
+  public void ldsResourceUpdated_withXdstpResourceName_witUnorderedContextParams() {
+    String ldsResourceName =
+        "xdstp://authority.xds.com/envoy.config.listener.v3.Listener/listener1/a?bar=2&foo=1";
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), ldsResourceName,
+        ldsResourceWatcher);
+    assertThat(channelForCustomAuthority).isNotNull();
+
+    String ldsResourceNameWithUnorderedContextParams =
+        "xdstp://authority.xds.com/envoy.config.listener.v3.Listener/listener1/a?foo=1&bar=2";
+    Any testListenerVhosts = Any.pack(mf.buildListenerWithApiListener(
+        ldsResourceNameWithUnorderedContextParams,
+        mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(VHOST_SIZE))));
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    call.verifyRequest(
+        LDS, ldsResourceName, VERSION_1, "0000", NODE);
+  }
+
+  @Test
+  public void ldsResourceUpdated_withXdstpResourceName_withWrongType() {
+    String ldsResourceName =
+        "xdstp://authority.xds.com/envoy.config.listener.v3.Listener/listener1";
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), ldsResourceName,
+        ldsResourceWatcher);
+    assertThat(channelForCustomAuthority).isNotNull();
+
+    String ldsResourceNameWithWrongType =
+        "xdstp://authority.xds.com/envoy.config.route.v3.RouteConfiguration/listener1";
+    Any testListenerVhosts = Any.pack(mf.buildListenerWithApiListener(
+        ldsResourceNameWithWrongType,
+        mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(VHOST_SIZE))));
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    call.verifyRequestNack(
+        LDS, ldsResourceName, "", "0000", NODE,
+        ImmutableList.of(
+            "Unsupported resource name: " + ldsResourceNameWithWrongType + " for type: LDS"));
+  }
+
+  @Test
+  public void rdsResourceUpdated_withXdstpResourceName_withWrongType() {
+    String rdsResourceName =
+        "xdstp://authority.xds.com/envoy.config.route.v3.RouteConfiguration/route1";
+    DiscoveryRpcCall call = startResourceWatcher(XdsRouteConfigureResource.getInstance(),
+        rdsResourceName, rdsResourceWatcher);
+    assertThat(channelForCustomAuthority).isNotNull();
+
+    String rdsResourceNameWithWrongType =
+        "xdstp://authority.xds.com/envoy.config.listener.v3.Listener/route1";
+    Any testRouteConfig = Any.pack(mf.buildRouteConfiguration(
+        rdsResourceNameWithWrongType, mf.buildOpaqueVirtualHosts(VHOST_SIZE)));
+    call.sendResponse(RDS, testRouteConfig, VERSION_1, "0000");
+    call.verifyRequestNack(
+        RDS, rdsResourceName, "", "0000", NODE,
+        ImmutableList.of(
+            "Unsupported resource name: " + rdsResourceNameWithWrongType + " for type: RDS"));
+  }
+
+  @Test
+  public void rdsResourceUpdated_withXdstpResourceName_unknownAuthority() {
+    String rdsResourceName =
+        "xdstp://unknown.example.com/envoy.config.route.v3.RouteConfiguration/route1";
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), rdsResourceName,
+        rdsResourceWatcher);
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<StatusOr<RdsUpdate>> rdsUpdateCaptor = ArgumentCaptor.forClass(StatusOr.class);
+    verify(rdsResourceWatcher).onResourceChanged(rdsUpdateCaptor.capture());
+    StatusOr<RdsUpdate> capturedUpdate = rdsUpdateCaptor.getValue();
+    assertThat(capturedUpdate.hasValue()).isFalse();
+    Status error = capturedUpdate.getStatus();
+    assertThat(error.getCode()).isEqualTo(Code.INVALID_ARGUMENT);
+    assertThat(error.getDescription()).isEqualTo(
+        "Wrong configuration: xds server does not exist for resource " + rdsResourceName);
+    assertThat(resourceDiscoveryCalls.size()).isEqualTo(0);
+    xdsClient.cancelXdsResourceWatch(
+        XdsRouteConfigureResource.getInstance(), rdsResourceName, rdsResourceWatcher);
+    assertThat(resourceDiscoveryCalls.size()).isEqualTo(0);
+  }
+
+  @Test
+  public void cdsResourceUpdated_withXdstpResourceName_withWrongType() {
+    String cdsResourceName = "xdstp://authority.xds.com/envoy.config.cluster.v3.Cluster/cluster1";
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), cdsResourceName,
+        cdsResourceWatcher);
+    assertThat(channelForCustomAuthority).isNotNull();
+
+    String cdsResourceNameWithWrongType =
+        "xdstp://authority.xds.com/envoy.config.listener.v3.Listener/cluster1";
+    Any testClusterConfig = Any.pack(mf.buildEdsCluster(
+        cdsResourceNameWithWrongType, null, "round_robin", null, null, false, null,
+        "envoy.transport_sockets.tls", null, null));
+    call.sendResponse(CDS, testClusterConfig, VERSION_1, "0000");
+    call.verifyRequestNack(
+        CDS, cdsResourceName, "", "0000", NODE,
+        ImmutableList.of(
+            "Unsupported resource name: " + cdsResourceNameWithWrongType + " for type: CDS"));
+  }
+
+  @Test
+  public void cdsResourceUpdated_withXdstpResourceName_unknownAuthority() {
+    String cdsResourceName = "xdstp://unknown.example.com/envoy.config.cluster.v3.Cluster/cluster1";
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), cdsResourceName,
+        cdsResourceWatcher);
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<StatusOr<CdsUpdate>> cdsUpdateCaptor = ArgumentCaptor.forClass(StatusOr.class);
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> capturedUpdate = cdsUpdateCaptor.getValue();
+    assertThat(capturedUpdate.hasValue()).isFalse();
+    Status error = capturedUpdate.getStatus();
+    assertThat(error.getCode()).isEqualTo(Code.INVALID_ARGUMENT);
+    assertThat(error.getDescription()).isEqualTo(
+        "Wrong configuration: xds server does not exist for resource " + cdsResourceName);
+    assertThat(resourceDiscoveryCalls.poll()).isNull();
+    xdsClient.cancelXdsResourceWatch(XdsClusterResource.getInstance(), cdsResourceName,
+        cdsResourceWatcher);
+    assertThat(resourceDiscoveryCalls.poll()).isNull();
+  }
+
+  @Test
+  public void edsResourceUpdated_withXdstpResourceName_withWrongType() {
+    String edsResourceName =
+        "xdstp://authority.xds.com/envoy.config.endpoint.v3.ClusterLoadAssignment/cluster1";
+    DiscoveryRpcCall call = startResourceWatcher(XdsEndpointResource.getInstance(), edsResourceName,
+        edsResourceWatcher);
+    assertThat(channelForCustomAuthority).isNotNull();
+
+    String edsResourceNameWithWrongType =
+        "xdstp://authority.xds.com/envoy.config.listener.v3.Listener/cluster1";
+    Any testEdsConfig = Any.pack(mf.buildClusterLoadAssignment(
+        edsResourceNameWithWrongType,
+        ImmutableList.of(mf.buildLocalityLbEndpoints(
+            "region2", "zone2", "subzone2",
+            mf.buildLbEndpoint("172.44.2.2", 8000, "unknown", 3, "endpoint-host-name"), 2, 0)),
+        ImmutableList.of()));
+    call.sendResponse(EDS, testEdsConfig, VERSION_1, "0000");
+    call.verifyRequestNack(
+        EDS, edsResourceName, "", "0000", NODE,
+        ImmutableList.of(
+            "Unsupported resource name: " + edsResourceNameWithWrongType + " for type: EDS"));
+  }
+
+  @Test
+  public void edsResourceUpdated_withXdstpResourceName_unknownAuthority() {
+    String edsResourceName =
+        "xdstp://unknown.example.com/envoy.config.endpoint.v3.ClusterLoadAssignment/cluster1";
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(),
+        edsResourceName, edsResourceWatcher);
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<StatusOr<EdsUpdate>> edsUpdateCaptor = ArgumentCaptor.forClass(StatusOr.class);
+    verify(edsResourceWatcher).onResourceChanged(edsUpdateCaptor.capture());
+    StatusOr<EdsUpdate> capturedUpdate = edsUpdateCaptor.getValue();
+    assertThat(capturedUpdate.hasValue()).isFalse();
+    Status error = capturedUpdate.getStatus();
+    assertThat(error.getCode()).isEqualTo(Code.INVALID_ARGUMENT);
+    assertThat(error.getDescription()).isEqualTo(
+        "Wrong configuration: xds server does not exist for resource " + edsResourceName);
+    assertThat(resourceDiscoveryCalls.poll()).isNull();
+    xdsClient.cancelXdsResourceWatch(XdsEndpointResource.getInstance(),
+        edsResourceName, edsResourceWatcher);
+    assertThat(resourceDiscoveryCalls.poll()).isNull();
+  }
+
+  @Test
+  public void ldsResourceUpdate_withFaultInjection() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    Any listener = Any.pack(
+        mf.buildListenerWithApiListener(
+            LDS_RESOURCE,
+            mf.buildRouteConfiguration(
+                "do not care",
+                ImmutableList.of(
+                    mf.buildVirtualHost(
+                        mf.buildOpaqueRoutes(1),
+                        ImmutableMap.of(
+                            "irrelevant",
+                            Any.pack(FilterConfig.newBuilder().setIsOptional(true).build()),
+                            "envoy.fault",
+                            mf.buildHttpFaultTypedConfig(
+                                300L, 1000, "cluster1", ImmutableList.<String>of(), 100, null, null,
+                                null))),
+                    mf.buildVirtualHost(
+                        mf.buildOpaqueRoutes(2),
+                        ImmutableMap.of(
+                            "envoy.fault",
+                            mf.buildHttpFaultTypedConfig(
+                                null, null, "cluster2", ImmutableList.<String>of(), 101, null, 503,
+                                2000))))),
+            ImmutableList.of(
+                mf.buildHttpFilter("irrelevant", null, true),
+                mf.buildHttpFilter(
+                    "envoy.fault",
+                    mf.buildHttpFaultTypedConfig(
+                        1L, 2, "cluster1", ImmutableList.<String>of(), 3, null, null,
+                        null),
+                    false),
+                mf.buildHttpFilter("terminal", Any.pack(Router.newBuilder().build()), true))));
+    call.sendResponse(LDS, listener, VERSION_1, "0000");
+
+    // Client sends an ACK LDS request.
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, listener, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+
+    LdsUpdate ldsUpdate = statusOrUpdate.getValue();
+    assertThat(ldsUpdate.httpConnectionManager().virtualHosts()).hasSize(2);
+    assertThat(ldsUpdate.httpConnectionManager().httpFilterConfigs().get(0).name)
+        .isEqualTo("envoy.fault");
+    FaultConfig faultConfig = (FaultConfig) ldsUpdate.httpConnectionManager().virtualHosts().get(0)
+        .filterConfigOverrides().get("envoy.fault");
+    assertThat(faultConfig.faultDelay().delayNanos()).isEqualTo(300);
+    assertThat(faultConfig.faultDelay().percent().numerator()).isEqualTo(1000);
+    assertThat(faultConfig.faultDelay().percent().denominatorType())
+        .isEqualTo(DenominatorType.MILLION);
+    assertThat(faultConfig.faultAbort()).isNull();
+    assertThat(faultConfig.maxActiveFaults()).isEqualTo(100);
+    faultConfig = (FaultConfig) ldsUpdate.httpConnectionManager().virtualHosts().get(1)
+        .filterConfigOverrides().get("envoy.fault");
+    assertThat(faultConfig.faultDelay()).isNull();
+    assertThat(faultConfig.faultAbort().status().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(faultConfig.faultAbort().percent().numerator()).isEqualTo(2000);
+    assertThat(faultConfig.faultAbort().percent().denominatorType())
+        .isEqualTo(DenominatorType.MILLION);
+    assertThat(faultConfig.maxActiveFaults()).isEqualTo(101);
+  }
+
+  @Test
+  public void ldsResourceDeleted() {
+    Assume.assumeFalse(ignoreResourceDeletion());
+    InOrder inOrder = inOrder(ldsResourceWatcher);
+
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    verifyResourceMetadataRequested(LDS, LDS_RESOURCE);
+
+    // Initial LDS response.
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    inOrder.verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerVhosts, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+
+    // Empty LDS response deletes the listener.
+    call.sendResponse(LDS, Collections.<Any>emptyList(), VERSION_2, "0001");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_2, "0001", NODE);
+    inOrder.verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate1 = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate1.hasValue()).isFalse();
+    assertThat(statusOrUpdate1.getStatus().getCode()).isEqualTo(Status.Code.NOT_FOUND);
+    verifyResourceMetadataDoesNotExist(LDS, LDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+  }
+
+  /**
+   * When ignore_resource_deletion server feature is on, xDS client should keep the deleted listener
+   * on empty response, and resume the normal work when LDS contains the listener again.
+   */
+  @Test
+  public void ldsResourceDeleted_ignoreResourceDeletion() {
+    Assume.assumeTrue(ignoreResourceDeletion());
+
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    verifyResourceMetadataRequested(LDS, LDS_RESOURCE);
+
+    // Initial LDS response.
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    verifyGoldenListenerVhosts(ldsUpdateCaptor.getValue().getValue());
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerVhosts, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+
+    // Empty LDS response does not delete the listener.
+    call.sendResponse(LDS, Collections.emptyList(), VERSION_2, "0001");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_2, "0001", NODE);
+    // The resource is still ACKED at VERSION_1 (no changes).
+    verify(ldsResourceWatcher).onAmbientError(
+        argThat(status -> status.getCode() == Status.Code.NOT_FOUND));
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerVhosts, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+
+    // Next update is correct, and contains the listener again.
+    Any updatedListener = Any.pack(mf.buildListenerWithApiListener(LDS_RESOURCE,
+        mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(VHOST_SIZE + 1))));
+    call.sendResponse(LDS, updatedListener, VERSION_3, "0003");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_3, "0003", NODE);
+    verify(ldsResourceWatcher, times(2)).onResourceChanged(ldsUpdateCaptor.capture());
+    assertThat(ldsUpdateCaptor.getValue().getValue().httpConnectionManager().virtualHosts())
+        .hasSize(VHOST_SIZE + 1);
+    // LDS is now ACKEd at VERSION_3.
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, updatedListener, VERSION_3, TIME_INCREMENT * 3);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+    verifyNoMoreInteractions(ldsResourceWatcher);
+  }
+
+  /**
+   * When fail_on_data_errors server feature is on, xDS client should delete the cached listener
+   * and fail RPCs when LDS resource is deleted.
+   */
+  @Test
+  public void ldsResourceDeleted_failOnDataErrors_true() {
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = true;
+    xdsServerInfo = ServerInfo.create(SERVER_URI, CHANNEL_CREDENTIALS, false,
+        true, false, true);
+    BootstrapInfo bootstrapInfo =
+        Bootstrapper.BootstrapInfo.builder()
+            .servers(Collections.singletonList(xdsServerInfo))
+            .node(NODE)
+            .authorities(ImmutableMap.of(
+                "",
+                AuthorityInfo.create(
+                    "xdstp:///envoy.config.listener.v3.Listener/%s",
+                    ImmutableList.of(Bootstrapper.ServerInfo.create(
+                        SERVER_URI_EMPTY_AUTHORITY, CHANNEL_CREDENTIALS)))))
+            .certProviders(ImmutableMap.of())
+            .build();
+    xdsClient = new XdsClientImpl(
+        xdsTransportFactory,
+        bootstrapInfo,
+        fakeClock.getScheduledExecutorService(),
+        backoffPolicyProvider,
+        fakeClock.getStopwatchSupplier(),
+        timeProvider,
+        MessagePrinter.INSTANCE,
+        new TlsContextManagerImpl(bootstrapInfo),
+        xdsClientMetricReporter);
+
+    InOrder inOrder = inOrder(ldsResourceWatcher);
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    verifyResourceMetadataRequested(LDS, LDS_RESOURCE);
+
+    // Initial LDS response.
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    inOrder.verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerVhosts, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+
+    // Empty LDS response deletes the listener and fails RPCs.
+    call.sendResponse(LDS, Collections.<Any>emptyList(), VERSION_2, "0001");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_2, "0001", NODE);
+    inOrder.verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate1 = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate1.hasValue()).isFalse();
+    assertThat(statusOrUpdate1.getStatus().getCode()).isEqualTo(Status.Code.NOT_FOUND);
+    verifyResourceMetadataDoesNotExist(LDS, LDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = false;
+  }
+
+  /**
+   * When the fail_on_data_errors server feature is not present, the default behavior
+   * is to treat a resource deletion as an ambient error and preserve the cached resource.
+   */
+  @Test
+  public void ldsResourceDeleted_failOnDataErrors_false() {
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = true;
+
+    xdsServerInfo = ServerInfo.create(SERVER_URI, CHANNEL_CREDENTIALS, false,
+        true, false, false);
+    BootstrapInfo bootstrapInfo =
+        Bootstrapper.BootstrapInfo.builder()
+            .servers(Collections.singletonList(xdsServerInfo))
+            .node(NODE)
+            .authorities(ImmutableMap.of(
+                "",
+                AuthorityInfo.create(
+                    "xdstp:///envoy.config.listener.v3.Listener/%s",
+                    ImmutableList.of(Bootstrapper.ServerInfo.create(
+                        SERVER_URI_EMPTY_AUTHORITY, CHANNEL_CREDENTIALS)))))
+            .certProviders(ImmutableMap.of())
+            .build();
+    xdsClient = new XdsClientImpl(
+        xdsTransportFactory,
+        bootstrapInfo,
+        fakeClock.getScheduledExecutorService(),
+        backoffPolicyProvider,
+        fakeClock.getStopwatchSupplier(),
+        timeProvider,
+        MessagePrinter.INSTANCE,
+        new TlsContextManagerImpl(bootstrapInfo),
+        xdsClientMetricReporter);
+
+    InOrder inOrder = inOrder(ldsResourceWatcher);
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    verifyResourceMetadataRequested(LDS, LDS_RESOURCE);
+
+    // Initial LDS response.
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    inOrder.verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerVhosts, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+
+    // Empty LDS response deletes the listener and fails RPCs.
+    call.sendResponse(LDS, Collections.<Any>emptyList(), VERSION_2, "0001");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_2, "0001", NODE);
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    inOrder.verify(ldsResourceWatcher).onAmbientError(statusCaptor.capture());
+    Status receivedStatus = statusCaptor.getValue();
+    assertThat(receivedStatus.getCode()).isEqualTo(Status.Code.NOT_FOUND);
+    assertThat(receivedStatus.getDescription()).contains(
+        "Resource " + LDS_RESOURCE + " deleted from server");
+    inOrder.verify(ldsResourceWatcher, never()).onResourceChanged(any());
+    verifySubscribedResourcesMetadataSizes(1, 0, 0, 0);
+
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = false;
+  }
+
+  /**
+   * Tests that fail_on_data_errors feature is ignored if the env var is not enabled,
+   * and the old behavior (dropping the resource) is used.
+   */
+  @Test
+  public void ldsResourceDeleted_failOnDataErrorsIgnoredWithoutEnvVar() {
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = false;
+
+    xdsServerInfo = ServerInfo.create(SERVER_URI, CHANNEL_CREDENTIALS, false,
+        true, false, true);
+    BootstrapInfo bootstrapInfo =
+        Bootstrapper.BootstrapInfo.builder()
+            .servers(Collections.singletonList(xdsServerInfo))
+            .node(NODE)
+            .authorities(ImmutableMap.of(
+                "",
+                AuthorityInfo.create(
+                    "xdstp:///envoy.config.listener.v3.Listener/%s",
+                    ImmutableList.of(Bootstrapper.ServerInfo.create(
+                        SERVER_URI_EMPTY_AUTHORITY, CHANNEL_CREDENTIALS)))))
+            .certProviders(ImmutableMap.of())
+            .build();
+    xdsClient = new XdsClientImpl(
+        xdsTransportFactory,
+        bootstrapInfo,
+        fakeClock.getScheduledExecutorService(),
+        backoffPolicyProvider,
+        fakeClock.getStopwatchSupplier(),
+        timeProvider,
+        MessagePrinter.INSTANCE,
+        new TlsContextManagerImpl(bootstrapInfo),
+        xdsClientMetricReporter);
+
+    InOrder inOrder = inOrder(ldsResourceWatcher);
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    inOrder.verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    assertThat(ldsUpdateCaptor.getValue().hasValue()).isTrue();
+    call.sendResponse(LDS, Collections.<Any>emptyList(), VERSION_2, "0001");
+
+    inOrder.verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isFalse();
+    assertThat(statusOrUpdate.getStatus().getCode()).isEqualTo(Status.Code.NOT_FOUND);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void multipleLdsWatchers() {
+    String ldsResourceTwo = "bar.googleapis.com";
+    ResourceWatcher<LdsUpdate> watcher1 = mock(ResourceWatcher.class);
+    ResourceWatcher<LdsUpdate> watcher2 = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE, ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), ldsResourceTwo, watcher1);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), ldsResourceTwo, watcher2);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    call.verifyRequest(LDS, ImmutableList.of(LDS_RESOURCE, ldsResourceTwo), "", "", NODE);
+    // Both LDS resources were requested.
+    verifyResourceMetadataRequested(LDS, LDS_RESOURCE);
+    verifyResourceMetadataRequested(LDS, ldsResourceTwo);
+    verifySubscribedResourcesMetadataSizes(2, 0, 0, 0);
+
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    verify(ldsResourceWatcher).onResourceChanged(argThat(statusOr ->
+        !statusOr.hasValue() && statusOr.getStatus().getDescription().contains(LDS_RESOURCE)));
+    verify(watcher1).onResourceChanged(argThat(statusOr ->
+        !statusOr.hasValue() && statusOr.getStatus().getDescription().contains(ldsResourceTwo)));
+    verify(watcher2).onResourceChanged(argThat(statusOr ->
+        !statusOr.hasValue() && statusOr.getStatus().getDescription().contains(ldsResourceTwo)));
+    verifyResourceMetadataDoesNotExist(LDS, LDS_RESOURCE);
+    verifyResourceMetadataDoesNotExist(LDS, ldsResourceTwo);
+    verifySubscribedResourcesMetadataSizes(2, 0, 0, 0);
+
+    Any listenerTwo = Any.pack(mf.buildListenerWithApiListenerForRds(ldsResourceTwo, RDS_RESOURCE));
+    call.sendResponse(LDS, ImmutableList.of(testListenerVhosts, listenerTwo), VERSION_1, "0000");
+    // ResourceWatcher called with listenerVhosts.
+    verify(ldsResourceWatcher, times(2)).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(statusOrUpdate.getValue());
+    // watcher1 called with listenerTwo.
+    verify(watcher1, times(2)).onResourceChanged(ldsUpdateCaptor.capture());
+    statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerRds(statusOrUpdate.getValue());
+    assertThat(statusOrUpdate.getValue().httpConnectionManager().virtualHosts()).isNull();
+    // watcher2 called with listenerTwo.
+    verify(watcher2, times(2)).onResourceChanged(ldsUpdateCaptor.capture());
+    statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerRds(statusOrUpdate.getValue());
+    assertThat(statusOrUpdate.getValue().httpConnectionManager().virtualHosts()).isNull();
+    // Metadata of both listeners is stored.
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerVhosts, VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(LDS, ldsResourceTwo, listenerTwo, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(2, 0, 0, 0);
+  }
+
+  @Test
+  public void rdsResourceNotFound() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsRouteConfigureResource.getInstance(),
+        RDS_RESOURCE, rdsResourceWatcher);
+    Any routeConfig = Any.pack(mf.buildRouteConfiguration("route-bar.googleapis.com",
+        mf.buildOpaqueVirtualHosts(2)));
+    call.sendResponse(RDS, routeConfig, VERSION_1, "0000");
+
+    // Client sends an ACK RDS request.
+    call.verifyRequest(RDS, RDS_RESOURCE, VERSION_1, "0000", NODE);
+    verifyNoInteractions(rdsResourceWatcher);
+    verifyResourceMetadataRequested(RDS, RDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 0, 1, 0);
+    // Server failed to return subscribed resource within expected time window.
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    verify(rdsResourceWatcher).onResourceChanged(argThat(
+        arg -> !arg.hasValue() && arg.getStatus().getDescription().contains(RDS_RESOURCE)));
+    assertThat(fakeClock.getPendingTasks(RDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataDoesNotExist(RDS, RDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 0, 1, 0);
+  }
+
+  @Test
+  public void rdsResponseErrorHandling_allResourcesFailedUnpack() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsRouteConfigureResource.getInstance(),
+        RDS_RESOURCE, rdsResourceWatcher);
+    verifyResourceMetadataRequested(RDS, RDS_RESOURCE);
+    call.sendResponse(RDS, ImmutableList.of(FAILING_ANY, FAILING_ANY), VERSION_1, "0000");
+
+    // Resulting metadata unchanged because the response has no identifiable subscribed resources.
+    verifyResourceMetadataRequested(RDS, RDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 0, 1, 0);
+    // The response NACKed with errors indicating indices of the failed resources.
+    call.verifyRequestNack(RDS, RDS_RESOURCE, "", "0000", NODE, ImmutableList.of(
+        "RDS response Resource index 0 - can't decode RouteConfiguration: ",
+        "RDS response Resource index 1 - can't decode RouteConfiguration: "));
+    verifyNoInteractions(rdsResourceWatcher);
+  }
+
+  @Test
+  public void rdsResponseErrorHandling_someResourcesFailedUnpack() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsRouteConfigureResource.getInstance(),
+        RDS_RESOURCE, rdsResourceWatcher);
+    verifyResourceMetadataRequested(RDS, RDS_RESOURCE);
+
+    // Correct resource is in the middle to ensure processing continues on errors.
+    List<Any> resources = ImmutableList.of(FAILING_ANY, testRouteConfig, FAILING_ANY);
+    call.sendResponse(RDS, resources, VERSION_1, "0000");
+
+    // All errors recorded in the metadata of successfully unpacked subscribed resources.
+    List<String> errors = ImmutableList.of(
+        "RDS response Resource index 0 - can't decode RouteConfiguration: ",
+        "RDS response Resource index 2 - can't decode RouteConfiguration: ");
+    verifyResourceMetadataAcked(RDS, RDS_RESOURCE, testRouteConfig, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 0, 1, 0);
+    // The response is NACKed with the same error message.
+    call.verifyRequestNack(RDS, RDS_RESOURCE, "", "0000", NODE, errors);
+    verify(rdsResourceWatcher).onResourceChanged(any());
+  }
+
+  @Test
+  public void rdsResponseErrorHandling_nackWeightedSumZero() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsRouteConfigureResource.getInstance(),
+        RDS_RESOURCE, rdsResourceWatcher);
+    verifyResourceMetadataRequested(RDS, RDS_RESOURCE);
+    String expectedErrorDetail = "Sum of cluster weights should be above 0";
+
+    io.envoyproxy.envoy.config.route.v3.RouteAction routeAction =
+        io.envoyproxy.envoy.config.route.v3.RouteAction.newBuilder()
+            .setWeightedClusters(
+                WeightedCluster.newBuilder()
+                    .addClusters(
+                        WeightedCluster.ClusterWeight
+                            .newBuilder()
+                            .setName("cluster-foo")
+                            .setWeight(UInt32Value.newBuilder().setValue(0)))
+                    .addClusters(WeightedCluster.ClusterWeight
+                        .newBuilder()
+                        .setName("cluster-bar")
+                        .setWeight(UInt32Value.newBuilder().setValue(0))))
+            .build();
+    io.envoyproxy.envoy.config.route.v3.Route route =
+        io.envoyproxy.envoy.config.route.v3.Route.newBuilder()
+            .setName("route-blade")
+            .setMatch(
+                io.envoyproxy.envoy.config.route.v3.RouteMatch.newBuilder()
+                    .setPath("/service/method"))
+            .setRoute(routeAction)
+            .build();
+
+    Any zeroWeightSum = Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE,
+        Arrays.asList(mf.buildVirtualHost(Arrays.asList(route), ImmutableMap.of()))));
+    List<Any> resources = ImmutableList.of(zeroWeightSum);
+    call.sendResponse(RDS, resources, VERSION_1, "0000");
+
+    List<String> errors = ImmutableList.of(
+        "RDS response RouteConfiguration \'route-configuration.googleapis.com\' validation error: "
+            + "RouteConfiguration contains invalid virtual host: Virtual host [do not care] "
+            + "contains invalid route : Route [route-blade] contains invalid RouteAction: "
+            + expectedErrorDetail);
+    verifySubscribedResourcesMetadataSizes(0, 0, 1, 0);
+    // The response is NACKed with the same error message.
+    call.verifyRequestNack(RDS, RDS_RESOURCE, "", "0000", NODE, errors);
+    verify(rdsResourceWatcher).onResourceChanged(argThat(
+        statusOr -> !statusOr.hasValue() && statusOr.getStatus().getDescription()
+            .contains(expectedErrorDetail)));
+    verify(rdsResourceWatcher, never()).onResourceChanged(argThat(StatusOr::hasValue));
+  }
+
+  /**
+   * Tests a subscribed RDS resource transitioned to and from the invalid state.
+   *
+   * @see <a
+   *     href="https://github.com/grpc/proposal/blob/master/A40-csds-support.md#ads-parsing-logic-update-continue-after-first-error">
+   *     A40-csds-support.md</a>
+   */
+  @Test
+  public void rdsResponseErrorHandling_subscribedResourceInvalid() {
+    List<String> subscribedResourceNames = ImmutableList.of("A", "B", "C");
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), "A", rdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), "B", rdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), "C", rdsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    assertThat(call).isNotNull();
+    verifyResourceMetadataRequested(RDS, "A");
+    verifyResourceMetadataRequested(RDS, "B");
+    verifyResourceMetadataRequested(RDS, "C");
+    verifySubscribedResourcesMetadataSizes(0, 0, 3, 0);
+
+    // RDS -> {A, B, C}, version 1
+    List<Message> vhostsV1 = mf.buildOpaqueVirtualHosts(1);
+    ImmutableMap<String, Any> resourcesV1 = ImmutableMap.of(
+        "A", Any.pack(mf.buildRouteConfiguration("A", vhostsV1)),
+        "B", Any.pack(mf.buildRouteConfiguration("B", vhostsV1)),
+        "C", Any.pack(mf.buildRouteConfiguration("C", vhostsV1)));
+    call.sendResponse(RDS, resourcesV1.values().asList(), VERSION_1, "0000");
+    // {A, B, C} -> ACK, version 1
+    verifyResourceMetadataAcked(RDS, "A", resourcesV1.get("A"), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(RDS, "B", resourcesV1.get("B"), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(RDS, "C", resourcesV1.get("C"), VERSION_1, TIME_INCREMENT);
+    // Check metric data.
+    verifyResourceValidInvalidCount(1, 3, 0, xdsServerInfo.target(), RDS.typeUrl());
+    call.verifyRequest(RDS, subscribedResourceNames, VERSION_1, "0000", NODE);
+
+    // RDS -> {A, B}, version 2
+    // Failed to parse endpoint B
+    ImmutableMap<String, Any> resourcesV2 = ImmutableMap.of(
+        "A", Any.pack(mf.buildRouteConfiguration("A", mf.buildOpaqueVirtualHosts(2))),
+        "B", Any.pack(mf.buildRouteConfigurationInvalid("B")));
+    call.sendResponse(RDS, resourcesV2.values().asList(), VERSION_2, "0001");
+    // {A} -> ACK, version 2
+    // {B} -> NACK, version 1, rejected version 2, rejected reason: Failed to parse B
+    // {C} -> ACK, version 1
+    verifyResourceValidInvalidCount(1, 1, 1, xdsServerInfo.target(),
+        RDS.typeUrl());
+    List<String> errorsV2 =
+        ImmutableList.of("RDS response RouteConfiguration 'B' validation error: ");
+    verifyResourceMetadataAcked(RDS, "A", resourcesV2.get("A"), VERSION_2, TIME_INCREMENT * 2);
+    verifyResourceMetadataNacked(RDS, "B", resourcesV1.get("B"), VERSION_1, TIME_INCREMENT,
+        VERSION_2, TIME_INCREMENT * 2, errorsV2, true);
+    verifyResourceMetadataAcked(RDS, "C", resourcesV1.get("C"), VERSION_1, TIME_INCREMENT);
+    call.verifyRequestNack(RDS, subscribedResourceNames, VERSION_1, "0001", NODE, errorsV2);
+
+    // RDS -> {B, C} version 3
+    List<Message> vhostsV3 = mf.buildOpaqueVirtualHosts(3);
+    ImmutableMap<String, Any> resourcesV3 = ImmutableMap.of(
+        "B", Any.pack(mf.buildRouteConfiguration("B", vhostsV3)),
+        "C", Any.pack(mf.buildRouteConfiguration("C", vhostsV3)));
+    call.sendResponse(RDS, resourcesV3.values().asList(), VERSION_3, "0002");
+    // {A} -> ACK, version 2
+    // {B, C} -> ACK, version 3
+    verifyResourceValidInvalidCount(1, 2, 0, xdsServerInfo.target(),
+        RDS.typeUrl());
+    verifyResourceMetadataAcked(RDS, "A", resourcesV2.get("A"), VERSION_2, TIME_INCREMENT * 2);
+    verifyResourceMetadataAcked(RDS, "B", resourcesV3.get("B"), VERSION_3, TIME_INCREMENT * 3);
+    verifyResourceMetadataAcked(RDS, "C", resourcesV3.get("C"), VERSION_3, TIME_INCREMENT * 3);
+    call.verifyRequest(RDS, subscribedResourceNames, VERSION_3, "0002", NODE);
+    verifySubscribedResourcesMetadataSizes(0, 0, 3, 0);
+  }
+
+  @Test
+  public void rdsResourceFound() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsRouteConfigureResource.getInstance(),
+        RDS_RESOURCE, rdsResourceWatcher);
+    call.sendResponse(RDS, testRouteConfig, VERSION_1, "0000");
+
+    // Client sends an ACK RDS request.
+    call.verifyRequest(RDS, RDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(rdsResourceWatcher).onResourceChanged(rdsUpdateCaptor.capture());
+    StatusOr<RdsUpdate> statusOrUpdate = rdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenRouteConfig(statusOrUpdate.getValue());
+    assertThat(fakeClock.getPendingTasks(RDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataAcked(RDS, RDS_RESOURCE, testRouteConfig, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 0, 1, 0);
+  }
+
+  @Test
+  public void wrappedRdsResource() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsRouteConfigureResource.getInstance(),
+        RDS_RESOURCE, rdsResourceWatcher);
+    call.sendResponse(RDS, mf.buildWrappedResource(testRouteConfig), VERSION_1, "0000");
+
+    // Client sends an ACK RDS request.
+    call.verifyRequest(RDS, RDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(rdsResourceWatcher).onResourceChanged(rdsUpdateCaptor.capture());
+    StatusOr<RdsUpdate> statusOrUpdate = rdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenRouteConfig(statusOrUpdate.getValue());
+    assertThat(fakeClock.getPendingTasks(RDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataAcked(RDS, RDS_RESOURCE, testRouteConfig, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 0, 1, 0);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void cachedRdsResource_data() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsRouteConfigureResource.getInstance(),
+        RDS_RESOURCE, rdsResourceWatcher);
+    call.sendResponse(RDS, testRouteConfig, VERSION_1, "0000");
+
+    // Client sends an ACK RDS request.
+    call.verifyRequest(RDS, RDS_RESOURCE, VERSION_1, "0000", NODE);
+
+    ResourceWatcher<RdsUpdate> watcher = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_RESOURCE, watcher);
+    verify(watcher).onResourceChanged(rdsUpdateCaptor.capture());
+    StatusOr<RdsUpdate> statusOrUpdate = rdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenRouteConfig(statusOrUpdate.getValue());
+    call.verifyNoMoreRequest();
+    verifyResourceMetadataAcked(RDS, RDS_RESOURCE, testRouteConfig, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 0, 1, 0);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void cachedRdsResource_absent() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsRouteConfigureResource.getInstance(),
+        RDS_RESOURCE, rdsResourceWatcher);
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    verify(rdsResourceWatcher).onResourceChanged(argThat(statusOr ->
+        !statusOr.hasValue() && statusOr.getStatus().getDescription().contains(RDS_RESOURCE)
+            && statusOr.getStatus().getDescription().contains(RDS_RESOURCE)));
+    // Add another watcher.
+    ResourceWatcher<RdsUpdate> watcher = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_RESOURCE, watcher);
+    verify(watcher).onResourceChanged(argThat(statusOr ->
+        !statusOr.hasValue() && statusOr.getStatus().getDescription().contains(RDS_RESOURCE)
+            && statusOr.getStatus().getDescription().contains(RDS_RESOURCE)));
+    call.verifyNoMoreRequest();
+    verifyResourceMetadataDoesNotExist(RDS, RDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 0, 1, 0);
+  }
+
+  @Test
+  public void rdsResourceUpdated() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsRouteConfigureResource.getInstance(),
+        RDS_RESOURCE, rdsResourceWatcher);
+    verifyResourceMetadataRequested(RDS, RDS_RESOURCE);
+
+    // Initial RDS response.
+    call.sendResponse(RDS, testRouteConfig, VERSION_1, "0000");
+    call.verifyRequest(RDS, RDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(rdsResourceWatcher).onResourceChanged(rdsUpdateCaptor.capture());
+    StatusOr<RdsUpdate> statusOrUpdate = rdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenRouteConfig(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(RDS, RDS_RESOURCE, testRouteConfig, VERSION_1, TIME_INCREMENT);
+
+    // Updated RDS response.
+    Any routeConfigUpdated =
+        Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE, mf.buildOpaqueVirtualHosts(4)));
+    call.sendResponse(RDS, routeConfigUpdated, VERSION_2, "0001");
+
+    // Client sends an ACK RDS request.
+    call.verifyRequest(RDS, RDS_RESOURCE, VERSION_2, "0001", NODE);
+    verify(rdsResourceWatcher, times(2)).onResourceChanged(rdsUpdateCaptor.capture());
+    statusOrUpdate = rdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    assertThat(statusOrUpdate.getValue().virtualHosts).hasSize(4);
+    verifyResourceMetadataAcked(RDS, RDS_RESOURCE, routeConfigUpdated, VERSION_2,
+        TIME_INCREMENT * 2);
+  }
+
+  @Test
+  public void rdsResourceInvalid() {
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), "A", rdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), "B", rdsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    assertThat(call).isNotNull();
+    verifyResourceMetadataRequested(RDS, "A");
+    verifyResourceMetadataRequested(RDS, "B");
+    verifySubscribedResourcesMetadataSizes(0, 0, 2, 0);
+
+    // RDS -> {A, B}, version 1
+    // Failed to parse endpoint B
+    List<Message> vhostsV1 = mf.buildOpaqueVirtualHosts(1);
+    ImmutableMap<String, Any> resourcesV1 = ImmutableMap.of(
+        "A", Any.pack(mf.buildRouteConfiguration("A", vhostsV1)),
+        "B", Any.pack(mf.buildRouteConfigurationInvalid("B")));
+    call.sendResponse(RDS, resourcesV1.values().asList(), VERSION_1, "0000");
+
+    // {A} -> ACK, version 1
+    // {B} -> NACK, version 1, rejected version 1, rejected reason: Failed to parse B
+    List<String> errorsV1 =
+        ImmutableList.of("RDS response RouteConfiguration 'B' validation error: ");
+    verifyResourceMetadataAcked(RDS, "A", resourcesV1.get("A"), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataNacked(RDS, "B", null, "", 0,
+        VERSION_1, TIME_INCREMENT, errorsV1, false);
+    // Check metric data.
+    verifyResourceValidInvalidCount(1, 1, 1, xdsServerInfo.target(), RDS.typeUrl());
+    verifySubscribedResourcesMetadataSizes(0, 0, 2, 0);
+  }
+
+  @Test
+  public void rdsResourceDeletedByLdsApiListener() {
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_RESOURCE,
+        rdsResourceWatcher);
+    verifyResourceMetadataRequested(LDS, LDS_RESOURCE);
+    verifyResourceMetadataRequested(RDS, RDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(1, 0, 1, 0);
+
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    call.sendResponse(LDS, testListenerRds, VERSION_1, "0000");
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerRds(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerRds, VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataRequested(RDS, RDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(1, 0, 1, 0);
+
+    call.sendResponse(RDS, testRouteConfig, VERSION_1, "0000");
+    verify(rdsResourceWatcher).onResourceChanged(rdsUpdateCaptor.capture());
+    StatusOr<RdsUpdate> statusOrUpdate1 = rdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenRouteConfig(statusOrUpdate1.getValue());
+    verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerRds, VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(RDS, RDS_RESOURCE, testRouteConfig, VERSION_1, TIME_INCREMENT * 2);
+    verifySubscribedResourcesMetadataSizes(1, 0, 1, 0);
+
+    // The Listener is getting replaced configured with an RDS name, to the one configured with
+    // vhosts. Expect the RDS resources to be discarded.
+    // Note that this must work the same despite the ignore_resource_deletion feature is on.
+    // This happens because the Listener is getting replaced, and not deleted.
+    call.sendResponse(LDS, testListenerVhosts, VERSION_2, "0001");
+    verify(ldsResourceWatcher, times(2)).onResourceChanged(ldsUpdateCaptor.capture());
+    statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(statusOrUpdate.getValue());
+    verifyNoMoreInteractions(rdsResourceWatcher);
+    verifyResourceMetadataAcked(RDS, RDS_RESOURCE, testRouteConfig, VERSION_1, TIME_INCREMENT * 2);
+    verifyResourceMetadataAcked(
+        LDS, LDS_RESOURCE, testListenerVhosts, VERSION_2, TIME_INCREMENT * 3);
+    verifySubscribedResourcesMetadataSizes(1, 0, 1, 0);
+  }
+
+  @Test
+  public void rdsResourcesDeletedByLdsTcpListener() {
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LISTENER_RESOURCE,
+        ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_RESOURCE,
+        rdsResourceWatcher);
+    verifyResourceMetadataRequested(LDS, LISTENER_RESOURCE);
+    verifyResourceMetadataRequested(RDS, RDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(1, 0, 1, 0);
+
+    Message hcmFilter = mf.buildHttpConnectionManagerFilter(
+        RDS_RESOURCE, null, Collections.singletonList(mf.buildTerminalFilter()));
+    Message downstreamTlsContext = CommonTlsContextTestsUtil.buildTestDownstreamTlsContext(
+        "google-sds-config-default", "ROOTCA", false);
+    Message filterChain = mf.buildFilterChain(
+        Collections.<String>emptyList(), downstreamTlsContext, "envoy.transport_sockets.tls",
+        hcmFilter);
+    Any packedListener =
+        Any.pack(mf.buildListenerWithFilterChain(LISTENER_RESOURCE, 7000, "0.0.0.0", filterChain));
+
+    // Simulates receiving the requested LDS resource as a TCP listener with a filter chain
+    // referencing RDS_RESOURCE.
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    call.sendResponse(LDS, packedListener, VERSION_1, "0000");
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+
+    assertThat(statusOrUpdate.getValue().listener().filterChains()).hasSize(1);
+    FilterChain parsedFilterChain = Iterables.getOnlyElement(
+        statusOrUpdate.getValue().listener().filterChains());
+    assertThat(parsedFilterChain.httpConnectionManager().rdsName()).isEqualTo(RDS_RESOURCE);
+    verifyResourceMetadataAcked(LDS, LISTENER_RESOURCE, packedListener, VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataRequested(RDS, RDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(1, 0, 1, 0);
+
+    // Simulates receiving the requested RDS resource.
+    call.sendResponse(RDS, testRouteConfig, VERSION_1, "0000");
+    verify(rdsResourceWatcher).onResourceChanged(rdsUpdateCaptor.capture());
+    StatusOr<RdsUpdate> statusOrUpdate1 = rdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenRouteConfig(statusOrUpdate1.getValue());
+    verifyResourceMetadataAcked(RDS, RDS_RESOURCE, testRouteConfig, VERSION_1, TIME_INCREMENT * 2);
+
+    // Simulates receiving an updated version of the requested LDS resource as a TCP listener
+    // with a filter chain containing inlined RouteConfiguration.
+    // Note that this must work the same despite the ignore_resource_deletion feature is on.
+    // This happens because the Listener is getting replaced, and not deleted.
+    hcmFilter = mf.buildHttpConnectionManagerFilter(
+        null,
+        mf.buildRouteConfiguration(
+            "route-bar.googleapis.com", mf.buildOpaqueVirtualHosts(VHOST_SIZE)),
+        Collections.singletonList(mf.buildTerminalFilter()));
+    filterChain = mf.buildFilterChain(
+        Collections.<String>emptyList(), downstreamTlsContext, "envoy.transport_sockets.tls",
+        hcmFilter);
+    packedListener =
+        Any.pack(mf.buildListenerWithFilterChain(LISTENER_RESOURCE, 7000, "0.0.0.0", filterChain));
+    call.sendResponse(LDS, packedListener, VERSION_2, "0001");
+    verify(ldsResourceWatcher, times(2)).onResourceChanged(ldsUpdateCaptor.capture());
+    statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    assertThat(statusOrUpdate.getValue().listener().filterChains()).hasSize(1);
+    parsedFilterChain = Iterables.getOnlyElement(
+        statusOrUpdate.getValue().listener().filterChains());
+    assertThat(parsedFilterChain.httpConnectionManager().virtualHosts()).hasSize(VHOST_SIZE);
+    verify(rdsResourceWatcher, never()).onResourceChanged(argThat(statusOr ->
+        !statusOr.hasValue() && statusOr.getStatus().getDescription().equals(RDS_RESOURCE)));
+    verifyResourceMetadataAcked(RDS, RDS_RESOURCE, testRouteConfig, VERSION_1, TIME_INCREMENT * 2);
+    verifyResourceMetadataAcked(
+        LDS, LISTENER_RESOURCE, packedListener, VERSION_2, TIME_INCREMENT * 3);
+    verifySubscribedResourcesMetadataSizes(1, 0, 1, 0);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void multipleRdsWatchers() {
+    String rdsResourceTwo = "route-bar.googleapis.com";
+    ResourceWatcher<RdsUpdate> watcher1 = mock(ResourceWatcher.class);
+    ResourceWatcher<RdsUpdate> watcher2 = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_RESOURCE,
+        rdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), rdsResourceTwo, watcher1);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), rdsResourceTwo, watcher2);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    call.verifyRequest(RDS, Arrays.asList(RDS_RESOURCE, rdsResourceTwo), "", "", NODE);
+    // Both RDS resources were requested.
+    verifyResourceMetadataRequested(RDS, RDS_RESOURCE);
+    verifyResourceMetadataRequested(RDS, rdsResourceTwo);
+    verifySubscribedResourcesMetadataSizes(0, 0, 2, 0);
+
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    verify(rdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Status.Code.NOT_FOUND));
+    verify(watcher1).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Status.Code.NOT_FOUND));
+    verify(watcher2).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Status.Code.NOT_FOUND));
+    verifyResourceMetadataDoesNotExist(RDS, RDS_RESOURCE);
+    verifyResourceMetadataDoesNotExist(RDS, rdsResourceTwo);
+    verifySubscribedResourcesMetadataSizes(0, 0, 2, 0);
+
+    call.sendResponse(RDS, testRouteConfig, VERSION_1, "0000");
+    ArgumentCaptor<StatusOr<RdsUpdate>> rdsUpdateCaptor = ArgumentCaptor.forClass(StatusOr.class);
+    verify(rdsResourceWatcher, times(2)).onResourceChanged(rdsUpdateCaptor.capture());
+    StatusOr<RdsUpdate> capturedUpdate1 = rdsUpdateCaptor.getAllValues().get(1);
+    assertThat(capturedUpdate1.hasValue()).isTrue();
+    verifyGoldenRouteConfig(capturedUpdate1.getValue());
+    verifyNoMoreInteractions(watcher1, watcher2);
+    verifyResourceMetadataAcked(RDS, RDS_RESOURCE, testRouteConfig, VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataDoesNotExist(RDS, rdsResourceTwo);
+    verifySubscribedResourcesMetadataSizes(0, 0, 2, 0);
+
+    Any routeConfigTwo =
+        Any.pack(mf.buildRouteConfiguration(rdsResourceTwo, mf.buildOpaqueVirtualHosts(4)));
+    call.sendResponse(RDS, routeConfigTwo, VERSION_2, "0002");
+    ArgumentCaptor<StatusOr<RdsUpdate>> watcher1Captor =
+        ArgumentCaptor.forClass(StatusOr.class);
+    verify(watcher1, times(2)).onResourceChanged(watcher1Captor.capture());
+    StatusOr<RdsUpdate> capturedUpdate2 = watcher1Captor.getAllValues().get(1);
+    assertThat(capturedUpdate2.hasValue()).isTrue();
+    assertThat(capturedUpdate2.getValue().virtualHosts).hasSize(4);
+    ArgumentCaptor<StatusOr<RdsUpdate>> watcher2Captor =
+        ArgumentCaptor.forClass(StatusOr.class);
+    verify(watcher2, times(2)).onResourceChanged(watcher2Captor.capture());
+    StatusOr<RdsUpdate> capturedUpdate3 = watcher2Captor.getAllValues().get(1);
+    assertThat(capturedUpdate3.hasValue()).isTrue();
+    assertThat(capturedUpdate3.getValue().virtualHosts).hasSize(4);
+    verifyNoMoreInteractions(rdsResourceWatcher);
+    verifyResourceMetadataAcked(RDS, RDS_RESOURCE, testRouteConfig, VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(RDS, rdsResourceTwo, routeConfigTwo, VERSION_2,
+        TIME_INCREMENT * 2);
+    verifySubscribedResourcesMetadataSizes(0, 0, 2, 0);
+  }
+
+  @Test
+  public void cdsResourceNotFound() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+
+    List<Any> clusters = ImmutableList.of(
+        Any.pack(mf.buildEdsCluster("cluster-bar.googleapis.com", null, "round_robin", null,
+            null, false, null, "envoy.transport_sockets.tls", null, null)),
+        Any.pack(mf.buildEdsCluster("cluster-baz.googleapis.com", null, "round_robin", null,
+            null, false, null, "envoy.transport_sockets.tls", null, null)));
+    call.sendResponse(CDS, clusters, VERSION_1, "0000");
+
+    // Client sent an ACK CDS request.
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verifyNoInteractions(ldsResourceWatcher);
+    verifyResourceMetadataRequested(CDS, CDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+    // Server failed to return subscribed resource within expected time window.
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    verify(cdsResourceWatcher).onResourceChanged(argThat(
+        arg -> !arg.hasValue() && arg.getStatus().getDescription().contains(CDS_RESOURCE)));
+    assertThat(fakeClock.getPendingTasks(CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataDoesNotExist(CDS, CDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+  }
+
+  @Test
+  public void cdsResponseErrorHandling_allResourcesFailedUnpack() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    verifyResourceMetadataRequested(CDS, CDS_RESOURCE);
+    call.sendResponse(CDS, ImmutableList.of(FAILING_ANY, FAILING_ANY), VERSION_1, "0000");
+
+    // Resulting metadata unchanged because the response has no identifiable subscribed resources.
+    verifyResourceMetadataRequested(CDS, CDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+    // The response NACKed with errors indicating indices of the failed resources.
+    call.verifyRequestNack(CDS, CDS_RESOURCE, "", "0000", NODE, ImmutableList.of(
+        "CDS response Resource index 0 - can't decode Cluster: ",
+        "CDS response Resource index 1 - can't decode Cluster: "));
+    verifyNoInteractions(ldsResourceWatcher);
+  }
+
+  @Test
+  public void cdsResponseErrorHandling_someResourcesFailedUnpack() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    verifyResourceMetadataRequested(CDS, CDS_RESOURCE);
+
+    // Correct resource is in the middle to ensure processing continues on errors.
+    List<Any> resources = ImmutableList.of(FAILING_ANY, testClusterRoundRobin, FAILING_ANY);
+    call.sendResponse(CDS, resources, VERSION_1, "0000");
+
+    // All errors recorded in the metadata of successfully unpacked subscribed resources.
+    List<String> errors = ImmutableList.of(
+        "CDS response Resource index 0 - can't decode Cluster: ",
+        "CDS response Resource index 2 - can't decode Cluster: ");
+    verifyResourceMetadataAcked(
+        CDS, CDS_RESOURCE, testClusterRoundRobin, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+    // The response is NACKed with the same error message.
+    call.verifyRequestNack(CDS, CDS_RESOURCE, "", "0000", NODE, errors);
+    verify(cdsResourceWatcher).onResourceChanged(any());
+  }
+
+  /**
+   * Tests a subscribed CDS resource transitioned to and from the invalid state.
+   *
+   * @see <a
+   *     href="https://github.com/grpc/proposal/blob/master/A40-csds-support.md#ads-parsing-logic-update-continue-after-first-error">
+   *     A40-csds-support.md</a>
+   */
+  @Test
+  public void cdsResponseErrorHandling_subscribedResourceInvalid() {
+    List<String> subscribedResourceNames = ImmutableList.of("A", "B", "C");
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), "A", cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), "B", cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), "C", cdsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    assertThat(call).isNotNull();
+    verifyResourceMetadataRequested(CDS, "A");
+    verifyResourceMetadataRequested(CDS, "B");
+    verifyResourceMetadataRequested(CDS, "C");
+    verifySubscribedResourcesMetadataSizes(0, 3, 0, 0);
+
+    // CDS -> {A, B, C}, version 1
+    ImmutableMap<String, Any> resourcesV1 = ImmutableMap.of(
+        "A", Any.pack(mf.buildEdsCluster("A", "A.1", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )),
+        "B", Any.pack(mf.buildEdsCluster("B", "B.1", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )),
+        "C", Any.pack(mf.buildEdsCluster("C", "C.1", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )));
+    call.sendResponse(CDS, resourcesV1.values().asList(), VERSION_1, "0000");
+    // {A, B, C} -> ACK, version 1
+    verifyResourceValidInvalidCount(1, 3, 0, xdsServerInfo.target(),
+        CDS.typeUrl());
+    verifyResourceMetadataAcked(CDS, "A", resourcesV1.get("A"), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(CDS, "B", resourcesV1.get("B"), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(CDS, "C", resourcesV1.get("C"), VERSION_1, TIME_INCREMENT);
+    call.verifyRequest(CDS, subscribedResourceNames, VERSION_1, "0000", NODE);
+
+    // CDS -> {A, B}, version 2
+    // Failed to parse endpoint B
+    ImmutableMap<String, Any> resourcesV2 = ImmutableMap.of(
+        "A", Any.pack(mf.buildEdsCluster("A", "A.2", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )),
+        "B", Any.pack(mf.buildClusterInvalid("B")));
+    call.sendResponse(CDS, resourcesV2.values().asList(), VERSION_2, "0001");
+    // {A} -> ACK, version 2
+    // {B} -> NACK, version 1, rejected version 2, rejected reason: Failed to parse B
+    // {C} -> does not exist
+    verifyResourceValidInvalidCount(1, 1, 1, xdsServerInfo.target(),
+        CDS.typeUrl());
+    List<String> errorsV2 = ImmutableList.of("CDS response Cluster 'B' validation error: ");
+    verifyResourceMetadataAcked(CDS, "A", resourcesV2.get("A"), VERSION_2, TIME_INCREMENT * 2);
+    verifyResourceMetadataNacked(CDS, "B", resourcesV1.get("B"), VERSION_1, TIME_INCREMENT,
+        VERSION_2, TIME_INCREMENT * 2, errorsV2, true);
+    if (!ignoreResourceDeletion()) {
+      verifyResourceMetadataDoesNotExist(CDS, "C");
+    } else {
+      // When resource deletion is disabled, {C} stays ACKed in the previous version VERSION_1.
+      verifyResourceMetadataAcked(CDS, "C", resourcesV1.get("C"), VERSION_1, TIME_INCREMENT);
+    }
+    call.verifyRequestNack(CDS, subscribedResourceNames, VERSION_1, "0001", NODE, errorsV2);
+
+    // CDS -> {B, C} version 3
+    ImmutableMap<String, Any> resourcesV3 = ImmutableMap.of(
+        "B", Any.pack(mf.buildEdsCluster("B", "B.3", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )),
+        "C", Any.pack(mf.buildEdsCluster("C", "C.3", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )));
+    call.sendResponse(CDS, resourcesV3.values().asList(), VERSION_3, "0002");
+    // {A} -> does not exit
+    // {B, C} -> ACK, version 3
+    verifyResourceValidInvalidCount(1, 2, 0, xdsServerInfo.target(),
+        CDS.typeUrl());
+    if (!ignoreResourceDeletion()) {
+      verifyResourceMetadataDoesNotExist(CDS, "A");
+    } else {
+      // When resource deletion is disabled, {A} stays ACKed in the previous version VERSION_2.
+      verifyResourceMetadataAcked(CDS, "A", resourcesV2.get("A"), VERSION_2, TIME_INCREMENT * 2);
+    }
+    verifyResourceMetadataAcked(CDS, "B", resourcesV3.get("B"), VERSION_3, TIME_INCREMENT * 3);
+    verifyResourceMetadataAcked(CDS, "C", resourcesV3.get("C"), VERSION_3, TIME_INCREMENT * 3);
+
+    call.verifyRequest(CDS, subscribedResourceNames, VERSION_3, "0002", NODE);
+  }
+
+  @Test
+  public void cdsResponseErrorHandling_subscribedResourceInvalid_withEdsSubscription() {
+    List<String> subscribedResourceNames = ImmutableList.of("A", "B", "C");
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), "A", cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), "A.1", edsResourceWatcher);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), "B", cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), "B.1", edsResourceWatcher);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), "C", cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), "C.1", edsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    assertThat(call).isNotNull();
+    verifyResourceMetadataRequested(CDS, "A");
+    verifyResourceMetadataRequested(CDS, "B");
+    verifyResourceMetadataRequested(CDS, "C");
+    verifyResourceMetadataRequested(EDS, "A.1");
+    verifyResourceMetadataRequested(EDS, "B.1");
+    verifyResourceMetadataRequested(EDS, "C.1");
+    verifySubscribedResourcesMetadataSizes(0, 3, 0, 3);
+
+    // CDS -> {A, B, C}, version 1
+    ImmutableMap<String, Any> resourcesV1 = ImmutableMap.of(
+        "A", Any.pack(mf.buildEdsCluster("A", "A.1", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )),
+        "B", Any.pack(mf.buildEdsCluster("B", "B.1", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )),
+        "C", Any.pack(mf.buildEdsCluster("C", "C.1", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )));
+    call.sendResponse(CDS, resourcesV1.values().asList(), VERSION_1, "0000");
+    // {A, B, C} -> ACK, version 1
+    verifyResourceValidInvalidCount(1, 3, 0, xdsServerInfo.target(),
+        CDS.typeUrl());
+    verifyResourceMetadataAcked(CDS, "A", resourcesV1.get("A"), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(CDS, "B", resourcesV1.get("B"), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(CDS, "C", resourcesV1.get("C"), VERSION_1, TIME_INCREMENT);
+    call.verifyRequest(CDS, subscribedResourceNames, VERSION_1, "0000", NODE);
+
+    // EDS -> {A.1, B.1, C.1}, version 1
+    List<Message> dropOverloads = ImmutableList.of();
+    List<Message> endpointsV1 = ImmutableList.of(lbEndpointHealthy);
+    ImmutableMap<String, Any> resourcesV11 = ImmutableMap.of(
+        "A.1", Any.pack(mf.buildClusterLoadAssignment("A.1", endpointsV1, dropOverloads)),
+        "B.1", Any.pack(mf.buildClusterLoadAssignment("B.1", endpointsV1, dropOverloads)),
+        "C.1", Any.pack(mf.buildClusterLoadAssignment("C.1", endpointsV1, dropOverloads)));
+    call.sendResponse(EDS, resourcesV11.values().asList(), VERSION_1, "0000");
+    // {A.1, B.1, C.1} -> ACK, version 1
+    verifyResourceValidInvalidCount(1, 3, 0, xdsServerInfo.target(),
+        EDS.typeUrl());
+    verifyResourceMetadataAcked(EDS, "A.1", resourcesV11.get("A.1"), VERSION_1, TIME_INCREMENT * 2);
+    verifyResourceMetadataAcked(EDS, "B.1", resourcesV11.get("B.1"), VERSION_1, TIME_INCREMENT * 2);
+    verifyResourceMetadataAcked(EDS, "C.1", resourcesV11.get("C.1"), VERSION_1, TIME_INCREMENT * 2);
+
+    // CDS -> {A, B}, version 2
+    // Failed to parse endpoint B
+    ImmutableMap<String, Any> resourcesV2 = ImmutableMap.of(
+        "A", Any.pack(mf.buildEdsCluster("A", "A.2", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )),
+        "B", Any.pack(mf.buildClusterInvalid("B")));
+    call.sendResponse(CDS, resourcesV2.values().asList(), VERSION_2, "0001");
+    // {A} -> ACK, version 2
+    // {B} -> NACK, version 1, rejected version 2, rejected reason: Failed to parse B
+    // {C} -> does not exist
+    // Check metric data.
+    verifyResourceValidInvalidCount(1, 1, 1, xdsServerInfo.target(), CDS.typeUrl());
+    List<String> errorsV2 = ImmutableList.of("CDS response Cluster 'B' validation error: ");
+    verifyResourceMetadataAcked(CDS, "A", resourcesV2.get("A"), VERSION_2, TIME_INCREMENT * 3);
+    verifyResourceMetadataNacked(
+        CDS, "B", resourcesV1.get("B"), VERSION_1, TIME_INCREMENT, VERSION_2, TIME_INCREMENT * 3,
+        errorsV2, true);
+    if (!ignoreResourceDeletion()) {
+      verifyResourceMetadataDoesNotExist(CDS, "C");
+    } else {
+      // When resource deletion is disabled, {C} stays ACKed in the previous version VERSION_1.
+      verifyResourceMetadataAcked(CDS, "C", resourcesV1.get("C"), VERSION_1, TIME_INCREMENT);
+    }
+    call.verifyRequestNack(CDS, subscribedResourceNames, VERSION_1, "0001", NODE, errorsV2);
+    // {A.1} -> version 1
+    // {B.1} -> version 1
+    // {C.1} -> does not exist because {C} does not exist
+    verifyResourceMetadataAcked(EDS, "A.1", resourcesV11.get("A.1"), VERSION_1, TIME_INCREMENT * 2);
+    verifyResourceMetadataAcked(EDS, "B.1", resourcesV11.get("B.1"), VERSION_1, TIME_INCREMENT * 2);
+    // Verify {C.1} stays in the previous version VERSION_1. {C1} deleted or not does not matter.
+    verifyResourceMetadataAcked(EDS, "C.1", resourcesV11.get("C.1"), VERSION_1,
+        TIME_INCREMENT * 2);
+  }
+
+  @Test
+  public void cdsResourceFound() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(),
+        CDS_RESOURCE, cdsResourceWatcher);
+    call.sendResponse(CDS, testClusterRoundRobin, VERSION_1, "0000");
+
+    // Client sent an ACK CDS request.
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenClusterRoundRobin(statusOrUpdate.getValue());
+    assertThat(fakeClock.getPendingTasks(CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, testClusterRoundRobin, VERSION_1,
+        TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+  }
+
+  @Test
+  public void wrappedCdsResource() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    call.sendResponse(CDS, mf.buildWrappedResource(testClusterRoundRobin), VERSION_1, "0000");
+
+    // Client sent an ACK CDS request.
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenClusterRoundRobin(statusOrUpdate.getValue());
+    assertThat(fakeClock.getPendingTasks(CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, testClusterRoundRobin, VERSION_1,
+        TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+  }
+
+  @Test
+  public void cdsResourceFound_leastRequestLbPolicy() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    Message leastRequestConfig = mf.buildLeastRequestLbConfig(3);
+    Any clusterRingHash = Any.pack(
+        mf.buildEdsCluster(CDS_RESOURCE, null, "least_request_experimental", null,
+            leastRequestConfig, false, null, "envoy.transport_sockets.tls", null, null
+        ));
+    call.sendResponse(CDS, clusterRingHash, VERSION_1, "0000");
+
+    // Client sent an ACK CDS request.
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    CdsUpdate cdsUpdate = statusOrUpdate.getValue();
+    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
+    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
+    assertThat(cdsUpdate.edsServiceName()).isNull();
+    LbConfig lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(cdsUpdate.lbPolicyConfig());
+    assertThat(lbConfig.getPolicyName()).isEqualTo("wrr_locality_experimental");
+    List<LbConfig> childConfigs = ServiceConfigUtil.unwrapLoadBalancingConfigList(
+        JsonUtil.getListOfObjects(lbConfig.getRawConfigValue(), "childPolicy"));
+    assertThat(childConfigs.get(0).getPolicyName()).isEqualTo("least_request_experimental");
+    assertThat(childConfigs.get(0).getRawConfigValue().get("choiceCount")).isEqualTo(3);
+    assertThat(cdsUpdate.lrsServerInfo()).isNull();
+    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
+    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
+    assertThat(fakeClock.getPendingTasks(CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, clusterRingHash, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+  }
+
+  @Test
+  public void cdsResourceFound_ringHashLbPolicy() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    Message ringHashConfig = mf.buildRingHashLbConfig("xx_hash", 10L, 100L);
+    Any clusterRingHash = Any.pack(
+        mf.buildEdsCluster(CDS_RESOURCE, null, "ring_hash_experimental", ringHashConfig, null,
+            false, null, "envoy.transport_sockets.tls", null, null
+        ));
+    call.sendResponse(CDS, clusterRingHash, VERSION_1, "0000");
+
+    // Client sent an ACK CDS request.
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    CdsUpdate cdsUpdate = statusOrUpdate.getValue();
+    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
+    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
+    assertThat(cdsUpdate.edsServiceName()).isNull();
+    LbConfig lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(cdsUpdate.lbPolicyConfig());
+    assertThat(lbConfig.getPolicyName()).isEqualTo("ring_hash_experimental");
+    assertThat(JsonUtil.getNumberAsLong(lbConfig.getRawConfigValue(), "minRingSize")).isEqualTo(
+        10L);
+    assertThat(JsonUtil.getNumberAsLong(lbConfig.getRawConfigValue(), "maxRingSize")).isEqualTo(
+        100L);
+    assertThat(cdsUpdate.lrsServerInfo()).isNull();
+    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
+    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
+    assertThat(fakeClock.getPendingTasks(CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, clusterRingHash, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+  }
+
+  @Test
+  public void cdsResponseWithAggregateCluster() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    List<String> candidates = Arrays.asList(
+        "cluster1.googleapis.com", "cluster2.googleapis.com", "cluster3.googleapis.com");
+    Any clusterAggregate =
+        Any.pack(mf.buildAggregateCluster(CDS_RESOURCE, "round_robin", null, null, candidates));
+    call.sendResponse(CDS, clusterAggregate, VERSION_1, "0000");
+
+    // Client sent an ACK CDS request.
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    CdsUpdate cdsUpdate = statusOrUpdate.getValue();
+    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
+    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.AGGREGATE);
+    LbConfig lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(cdsUpdate.lbPolicyConfig());
+    assertThat(lbConfig.getPolicyName()).isEqualTo("wrr_locality_experimental");
+    List<LbConfig> childConfigs = ServiceConfigUtil.unwrapLoadBalancingConfigList(
+        JsonUtil.getListOfObjects(lbConfig.getRawConfigValue(), "childPolicy"));
+    assertThat(childConfigs.get(0).getPolicyName()).isEqualTo("round_robin");
+    assertThat(cdsUpdate.prioritizedClusterNames()).containsExactlyElementsIn(candidates).inOrder();
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, clusterAggregate, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+  }
+
+  @Test
+  public void cdsResponseWithEmptyAggregateCluster() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    List<String> candidates = Arrays.asList();
+    Any clusterAggregate =
+        Any.pack(mf.buildAggregateCluster(CDS_RESOURCE, "round_robin", null, null, candidates));
+    call.sendResponse(CDS, clusterAggregate, VERSION_1, "0000");
+
+    // Client sent an ACK CDS request.
+    String errorMsg = "CDS response Cluster 'cluster.googleapis.com' validation error: "
+        + "Cluster cluster.googleapis.com: aggregate ClusterConfig.clusters must not be empty";
+    call.verifyRequestNack(CDS, CDS_RESOURCE, "", "0000", NODE, ImmutableList.of(errorMsg));
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    verifyStatusWithNodeId(cdsUpdateCaptor.getValue().getStatus(), Code.UNAVAILABLE, errorMsg);
+  }
+
+  @Test
+  public void cdsResponseWithCircuitBreakers() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    Any clusterCircuitBreakers = Any.pack(
+        mf.buildEdsCluster(CDS_RESOURCE, null, "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", mf.buildCircuitBreakers(50, 200), null));
+    call.sendResponse(CDS, clusterCircuitBreakers, VERSION_1, "0000");
+
+    // Client sent an ACK CDS request.
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    CdsUpdate cdsUpdate = statusOrUpdate.getValue();
+    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
+    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
+    assertThat(cdsUpdate.edsServiceName()).isNull();
+    LbConfig lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(cdsUpdate.lbPolicyConfig());
+    assertThat(lbConfig.getPolicyName()).isEqualTo("wrr_locality_experimental");
+    List<LbConfig> childConfigs = ServiceConfigUtil.unwrapLoadBalancingConfigList(
+        JsonUtil.getListOfObjects(lbConfig.getRawConfigValue(), "childPolicy"));
+    assertThat(childConfigs.get(0).getPolicyName()).isEqualTo("round_robin");
+    assertThat(cdsUpdate.lrsServerInfo()).isNull();
+    assertThat(cdsUpdate.maxConcurrentRequests()).isEqualTo(200L);
+    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, clusterCircuitBreakers, VERSION_1,
+        TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+  }
+
+  /**
+   * CDS response containing UpstreamTlsContext for a cluster.
+   */
+  @Test
+  public void cdsResponseWithUpstreamTlsContext() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+
+    // Management server sends back CDS response with UpstreamTlsContext.
+    Any clusterEds =
+        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, "eds-cluster-foo.googleapis.com", "round_robin",
+            null, null, true,
+            mf.buildUpstreamTlsContext("cert-instance-name", "cert1"),
+            "envoy.transport_sockets.tls", null, null));
+    List<Any> clusters = ImmutableList.of(
+        Any.pack(mf.buildLogicalDnsCluster("cluster-bar.googleapis.com",
+            "dns-service-bar.googleapis.com", 443, "round_robin", null, null, false, null, null)),
+        clusterEds,
+        Any.pack(mf.buildEdsCluster("cluster-baz.googleapis.com", null, "round_robin", null, null,
+            false, null, "envoy.transport_sockets.tls", null, null)));
+    call.sendResponse(CDS, clusters, VERSION_1, "0000");
+
+    // Client sent an ACK CDS request.
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher, times(1))
+        .onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    CdsUpdate cdsUpdate = statusOrUpdate.getValue();
+    CertificateProviderPluginInstance certificateProviderInstance =
+        cdsUpdate.upstreamTlsContext().getCommonTlsContext().getCombinedValidationContext()
+            .getDefaultValidationContext().getCaCertificateProviderInstance();
+    assertThat(certificateProviderInstance.getInstanceName()).isEqualTo("cert-instance-name");
+    assertThat(certificateProviderInstance.getCertificateName()).isEqualTo("cert1");
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, clusterEds, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+  }
+
+  /**
+   * CDS response containing new UpstreamTlsContext for a cluster.
+   */
+  @Test
+  public void cdsResponseWithNewUpstreamTlsContext() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+
+    // Management server sends back CDS response with UpstreamTlsContext.
+    Any clusterEds =
+        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, "eds-cluster-foo.googleapis.com", "round_robin",
+            null, null, true,
+            mf.buildNewUpstreamTlsContext("cert-instance-name", "cert1"),
+            "envoy.transport_sockets.tls", null, null));
+    List<Any> clusters = ImmutableList.of(
+        Any.pack(mf.buildLogicalDnsCluster("cluster-bar.googleapis.com",
+            "dns-service-bar.googleapis.com", 443, "round_robin", null, null, false, null, null)),
+        clusterEds,
+        Any.pack(mf.buildEdsCluster("cluster-baz.googleapis.com", null, "round_robin", null, null,
+            false, null, "envoy.transport_sockets.tls", null, null)));
+    call.sendResponse(CDS, clusters, VERSION_1, "0000");
+
+    // Client sent an ACK CDS request.
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher, times(1)).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    CdsUpdate cdsUpdate = statusOrUpdate.getValue();
+    CertificateProviderPluginInstance certificateProviderInstance =
+        cdsUpdate.upstreamTlsContext().getCommonTlsContext().getValidationContext()
+            .getCaCertificateProviderInstance();
+    assertThat(certificateProviderInstance.getInstanceName()).isEqualTo("cert-instance-name");
+    assertThat(certificateProviderInstance.getCertificateName()).isEqualTo("cert1");
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, clusterEds, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+  }
+
+  /**
+   * CDS response containing bad UpstreamTlsContext for a cluster.
+   */
+  @Test
+  public void cdsResponseErrorHandling_badUpstreamTlsContext() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+
+    // Management server sends back CDS response with UpstreamTlsContext.
+    List<Any> clusters = ImmutableList.of(Any
+        .pack(mf.buildEdsCluster(CDS_RESOURCE, "eds-cluster-foo.googleapis.com", "round_robin",
+            null, null, true,
+            mf.buildUpstreamTlsContext(null, null), "envoy.transport_sockets.tls", null, null)));
+    call.sendResponse(CDS, clusters, VERSION_1, "0000");
+
+    // The response NACKed with errors indicating indices of the failed resources.
+    String errorMsg =  "CDS response Cluster 'cluster.googleapis.com' validation error: "
+        + "Cluster cluster.googleapis.com: malformed UpstreamTlsContext: "
+        + "io.grpc.xds.client.XdsResourceType$ResourceInvalidException: "
+        + "ca_certificate_provider_instance or system_root_certs is required in "
+        + "upstream-tls-context";
+    call.verifyRequestNack(CDS, CDS_RESOURCE, "", "0000", NODE, ImmutableList.of(errorMsg));
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    verifyStatusWithNodeId(cdsUpdateCaptor.getValue().getStatus(), Code.UNAVAILABLE, errorMsg);
+  }
+
+  /**
+   * CDS response containing OutlierDetection for a cluster.
+   */
+  @Test
+  public void cdsResponseWithOutlierDetection() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+
+    OutlierDetection outlierDetectionXds = OutlierDetection.newBuilder()
+        .setInterval(Durations.fromNanos(100))
+        .setBaseEjectionTime(Durations.fromNanos(100))
+        .setMaxEjectionTime(Durations.fromNanos(100))
+        .setMaxEjectionPercent(UInt32Value.of(100))
+        .setSuccessRateStdevFactor(UInt32Value.of(100))
+        .setEnforcingSuccessRate(UInt32Value.of(100))
+        .setSuccessRateMinimumHosts(UInt32Value.of(100))
+        .setSuccessRateRequestVolume(UInt32Value.of(100))
+        .setFailurePercentageThreshold(UInt32Value.of(100))
+        .setEnforcingFailurePercentage(UInt32Value.of(100))
+        .setFailurePercentageMinimumHosts(UInt32Value.of(100))
+        .setFailurePercentageRequestVolume(UInt32Value.of(100)).build();
+
+    // Management server sends back CDS response with UpstreamTlsContext.
+    Any clusterEds =
+        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, "eds-cluster-foo.googleapis.com", "round_robin",
+            null, null, true,
+            mf.buildUpstreamTlsContext("cert-instance-name", "cert1"),
+            "envoy.transport_sockets.tls", null, outlierDetectionXds));
+    List<Any> clusters = ImmutableList.of(
+        Any.pack(mf.buildLogicalDnsCluster("cluster-bar.googleapis.com",
+            "dns-service-bar.googleapis.com", 443, "round_robin", null, null, false, null, null)),
+        clusterEds,
+        Any.pack(mf.buildEdsCluster("cluster-baz.googleapis.com", null, "round_robin", null, null,
+            false, null, "envoy.transport_sockets.tls", null, outlierDetectionXds)));
+    call.sendResponse(CDS, clusters, VERSION_1, "0000");
+
+    // Client sent an ACK CDS request.
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher, times(1)).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    CdsUpdate cdsUpdate = statusOrUpdate.getValue();
+
+    // The outlier detection config in CdsUpdate should match what we get from xDS.
+    EnvoyServerProtoData.OutlierDetection outlierDetection = cdsUpdate.outlierDetection();
+    assertThat(outlierDetection).isNotNull();
+    assertThat(outlierDetection.intervalNanos()).isEqualTo(100);
+    assertThat(outlierDetection.baseEjectionTimeNanos()).isEqualTo(100);
+    assertThat(outlierDetection.maxEjectionTimeNanos()).isEqualTo(100);
+    assertThat(outlierDetection.maxEjectionPercent()).isEqualTo(100);
+
+    SuccessRateEjection successRateEjection = outlierDetection.successRateEjection();
+    assertThat(successRateEjection).isNotNull();
+    assertThat(successRateEjection.stdevFactor()).isEqualTo(100);
+    assertThat(successRateEjection.enforcementPercentage()).isEqualTo(100);
+    assertThat(successRateEjection.minimumHosts()).isEqualTo(100);
+    assertThat(successRateEjection.requestVolume()).isEqualTo(100);
+
+    FailurePercentageEjection failurePercentageEjection
+        = outlierDetection.failurePercentageEjection();
+    assertThat(failurePercentageEjection).isNotNull();
+    assertThat(failurePercentageEjection.threshold()).isEqualTo(100);
+    assertThat(failurePercentageEjection.enforcementPercentage()).isEqualTo(100);
+    assertThat(failurePercentageEjection.minimumHosts()).isEqualTo(100);
+    assertThat(failurePercentageEjection.requestVolume()).isEqualTo(100);
+
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, clusterEds, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+  }
+
+  /**
+   * CDS response containing OutlierDetection for a cluster.
+   */
+  @Test
+  public void cdsResponseWithInvalidOutlierDetectionNacks() {
+
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+
+    OutlierDetection outlierDetectionXds = OutlierDetection.newBuilder()
+        .setMaxEjectionPercent(UInt32Value.of(101)).build();
+
+    // Management server sends back CDS response with UpstreamTlsContext.
+    Any clusterEds =
+        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, "eds-cluster-foo.googleapis.com", "round_robin",
+            null, null, true,
+            mf.buildUpstreamTlsContext("cert-instance-name", "cert1"),
+            "envoy.transport_sockets.tls", null, outlierDetectionXds));
+    List<Any> clusters = ImmutableList.of(
+        Any.pack(mf.buildLogicalDnsCluster("cluster-bar.googleapis.com",
+            "dns-service-bar.googleapis.com", 443, "round_robin", null, null, false, null, null)),
+        clusterEds,
+        Any.pack(mf.buildEdsCluster("cluster-baz.googleapis.com", null, "round_robin", null, null,
+            false, null, "envoy.transport_sockets.tls", null, outlierDetectionXds)));
+    call.sendResponse(CDS, clusters, VERSION_1, "0000");
+
+    String errorMsg = "CDS response Cluster 'cluster.googleapis.com' validation error: "
+        + "Cluster cluster.googleapis.com: malformed outlier_detection: "
+        + "io.grpc.xds.client.XdsResourceType$ResourceInvalidException: outlier_detection "
+        + "max_ejection_percent is > 100";
+    call.verifyRequestNack(CDS, CDS_RESOURCE, "", "0000", NODE, ImmutableList.of(errorMsg));
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    verifyStatusWithNodeId(cdsUpdateCaptor.getValue().getStatus(), Code.UNAVAILABLE, errorMsg);
+  }
+
+  @Test(expected = ResourceInvalidException.class)
+  public void validateOutlierDetection_invalidInterval() throws ResourceInvalidException {
+    XdsClusterResource.validateOutlierDetection(
+        OutlierDetection.newBuilder().setInterval(Duration.newBuilder().setSeconds(Long.MAX_VALUE))
+            .build());
+  }
+
+  @Test(expected = ResourceInvalidException.class)
+  public void validateOutlierDetection_negativeInterval() throws ResourceInvalidException {
+    XdsClusterResource.validateOutlierDetection(
+        OutlierDetection.newBuilder().setInterval(Duration.newBuilder().setSeconds(-1))
+            .build());
+  }
+
+  @Test(expected = ResourceInvalidException.class)
+  public void validateOutlierDetection_invalidBaseEjectionTime() throws ResourceInvalidException {
+    XdsClusterResource.validateOutlierDetection(
+        OutlierDetection.newBuilder()
+            .setBaseEjectionTime(Duration.newBuilder().setSeconds(Long.MAX_VALUE))
+            .build());
+  }
+
+  @Test(expected = ResourceInvalidException.class)
+  public void validateOutlierDetection_negativeBaseEjectionTime() throws ResourceInvalidException {
+    XdsClusterResource.validateOutlierDetection(
+        OutlierDetection.newBuilder().setBaseEjectionTime(Duration.newBuilder().setSeconds(-1))
+            .build());
+  }
+
+  @Test(expected = ResourceInvalidException.class)
+  public void validateOutlierDetection_invalidMaxEjectionTime() throws ResourceInvalidException {
+    XdsClusterResource.validateOutlierDetection(
+        OutlierDetection.newBuilder()
+            .setMaxEjectionTime(Duration.newBuilder().setSeconds(Long.MAX_VALUE))
+            .build());
+  }
+
+  @Test(expected = ResourceInvalidException.class)
+  public void validateOutlierDetection_negativeMaxEjectionTime() throws ResourceInvalidException {
+    XdsClusterResource.validateOutlierDetection(
+        OutlierDetection.newBuilder().setMaxEjectionTime(Duration.newBuilder().setSeconds(-1))
+            .build());
+  }
+
+  @Test(expected = ResourceInvalidException.class)
+  public void validateOutlierDetection_maxEjectionPercentTooHigh() throws ResourceInvalidException {
+    XdsClusterResource.validateOutlierDetection(
+        OutlierDetection.newBuilder().setMaxEjectionPercent(UInt32Value.of(101)).build());
+  }
+
+  @Test(expected = ResourceInvalidException.class)
+  public void validateOutlierDetection_enforcingSuccessRateTooHigh()
+      throws ResourceInvalidException {
+    XdsClusterResource.validateOutlierDetection(
+        OutlierDetection.newBuilder().setEnforcingSuccessRate(UInt32Value.of(101)).build());
+  }
+
+  @Test(expected = ResourceInvalidException.class)
+  public void validateOutlierDetection_failurePercentageThresholdTooHigh()
+      throws ResourceInvalidException {
+    XdsClusterResource.validateOutlierDetection(
+        OutlierDetection.newBuilder().setFailurePercentageThreshold(UInt32Value.of(101)).build());
+  }
+
+  @Test(expected = ResourceInvalidException.class)
+  public void validateOutlierDetection_enforcingFailurePercentageTooHigh()
+      throws ResourceInvalidException {
+    XdsClusterResource.validateOutlierDetection(
+        OutlierDetection.newBuilder().setEnforcingFailurePercentage(UInt32Value.of(101)).build());
+  }
+
+  /**
+   * CDS response containing UpstreamTlsContext with bad transportSocketName for a cluster.
+   */
+  @Test
+  public void cdsResponseErrorHandling_badTransportSocketName() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+
+    // Management server sends back CDS response with UpstreamTlsContext.
+    List<Any> clusters = ImmutableList.of(Any
+        .pack(mf.buildEdsCluster(CDS_RESOURCE, "eds-cluster-foo.googleapis.com", "round_robin",
+            null, null, true,
+            mf.buildUpstreamTlsContext("secret1", "cert1"), "envoy.transport_sockets.bad", null,
+            null)));
+    call.sendResponse(CDS, clusters, VERSION_1, "0000");
+
+    // The response NACKed with errors indicating indices of the failed resources.
+    String errorMsg = "CDS response Cluster 'cluster.googleapis.com' validation error: "
+        + "transport-socket with name envoy.transport_sockets.bad not supported.";
+    call.verifyRequestNack(CDS, CDS_RESOURCE, "", "0000", NODE, ImmutableList.of(errorMsg));
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    verifyStatusWithNodeId(cdsUpdateCaptor.getValue().getStatus(), Code.UNAVAILABLE, errorMsg);
+  }
+
+  @Test
+  public void cdsResponseErrorHandling_xdstpWithoutEdsConfig() {
+    String cdsResourceName = "xdstp://authority.xds.com/envoy.config.cluster.v3.Cluster/cluster1";
+
+    final Any testClusterRoundRobin =
+        Any.pack(mf.buildEdsCluster(cdsResourceName, null, "round_robin", null,
+            null, false, null, "envoy.transport_sockets.tls", null, null
+        ));
+    final Any okClusterRoundRobin =
+        Any.pack(mf.buildEdsCluster(cdsResourceName, "eds-service-bar.googleapis.com",
+            "round_robin", null, null, false, null, "envoy.transport_sockets.tls", null, null));
+
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(),
+        cdsResourceName, cdsResourceWatcher);
+    call.sendResponse(CDS, testClusterRoundRobin, VERSION_1, "0000");
+
+    List<String> errors = ImmutableList.of("CDS response Cluster "
+        + "\'xdstp://authority.xds.com/envoy.config.cluster.v3.Cluster/cluster1\' "
+        + "validation error: EDS service_name must be set when Cluster resource has an xdstp name");
+    call.verifyRequest(CDS, cdsResourceName, "", "", NODE); // get this out of the way
+    call.verifyRequestNack(CDS, cdsResourceName, "", "0000", NODE, errors);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+
+    call.sendResponse(CDS, okClusterRoundRobin, VERSION_1, "0001");
+    call.verifyRequest(CDS, cdsResourceName, VERSION_1, "0001", NODE);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void cachedCdsResource_data() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    call.sendResponse(CDS, testClusterRoundRobin, VERSION_1, "0000");
+
+    // Client sends an ACK CDS request.
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+
+    ResourceWatcher<CdsUpdate> watcher = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), CDS_RESOURCE, watcher);
+    verify(watcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenClusterRoundRobin(statusOrUpdate.getValue());
+    call.verifyNoMoreRequest();
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, testClusterRoundRobin, VERSION_1,
+        TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void cachedCdsResource_absent() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    verify(cdsResourceWatcher).onResourceChanged(argThat(
+        arg -> !arg.hasValue() && arg.getStatus().getDescription().contains(CDS_RESOURCE)));
+    ResourceWatcher<CdsUpdate> watcher = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), CDS_RESOURCE, watcher);
+    verify(watcher).onResourceChanged(argThat(
+        arg -> !arg.hasValue() && arg.getStatus().getDescription().contains(CDS_RESOURCE)));
+    call.verifyNoMoreRequest();
+    verifyResourceMetadataDoesNotExist(CDS, CDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+  }
+
+  @Test
+  public void cdsResourceUpdated() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    verifyResourceMetadataRequested(CDS, CDS_RESOURCE);
+
+    // Initial CDS response.
+    String dnsHostAddr = "dns-service-bar.googleapis.com";
+    int dnsHostPort = 443;
+    Any clusterDns =
+        Any.pack(mf.buildLogicalDnsCluster(CDS_RESOURCE, dnsHostAddr, dnsHostPort, "round_robin",
+            null, null, false, null, null));
+    call.sendResponse(CDS, clusterDns, VERSION_1, "0000");
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    CdsUpdate cdsUpdate = statusOrUpdate.getValue();
+    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
+    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.LOGICAL_DNS);
+    assertThat(cdsUpdate.dnsHostName()).isEqualTo(dnsHostAddr + ":" + dnsHostPort);
+    LbConfig lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(cdsUpdate.lbPolicyConfig());
+    assertThat(lbConfig.getPolicyName()).isEqualTo("wrr_locality_experimental");
+    List<LbConfig> childConfigs = ServiceConfigUtil.unwrapLoadBalancingConfigList(
+        JsonUtil.getListOfObjects(lbConfig.getRawConfigValue(), "childPolicy"));
+    assertThat(childConfigs.get(0).getPolicyName()).isEqualTo("round_robin");
+    assertThat(cdsUpdate.lrsServerInfo()).isNull();
+    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
+    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, clusterDns, VERSION_1, TIME_INCREMENT);
+
+    // Updated CDS response.
+    String edsService = "eds-service-bar.googleapis.com";
+    Any clusterEds = Any.pack(
+        mf.buildEdsCluster(CDS_RESOURCE, edsService, "round_robin", null, null, true, null,
+            "envoy.transport_sockets.tls", null, null
+        ));
+    call.sendResponse(CDS, clusterEds, VERSION_2, "0001");
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_2, "0001", NODE);
+    verify(cdsResourceWatcher, times(2)).onResourceChanged(cdsUpdateCaptor.capture());
+    statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    cdsUpdate = statusOrUpdate.getValue();
+    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
+    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
+    assertThat(cdsUpdate.edsServiceName()).isEqualTo(edsService);
+    lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(cdsUpdate.lbPolicyConfig());
+    assertThat(lbConfig.getPolicyName()).isEqualTo("wrr_locality_experimental");
+    childConfigs = ServiceConfigUtil.unwrapLoadBalancingConfigList(
+        JsonUtil.getListOfObjects(lbConfig.getRawConfigValue(), "childPolicy"));
+    assertThat(childConfigs.get(0).getPolicyName()).isEqualTo("round_robin");
+    assertThat(cdsUpdate.lrsServerInfo()).isEqualTo(xdsServerInfo);
+    assertThat(cdsUpdate.maxConcurrentRequests()).isNull();
+    assertThat(cdsUpdate.upstreamTlsContext()).isNull();
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, clusterEds, VERSION_2, TIME_INCREMENT * 2);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+  }
+
+  // Assures that CDS updates identical to the current config are ignored.
+  @Test
+  public void cdsResourceUpdatedWithDuplicate() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+
+    String edsService = "eds-service-bar.googleapis.com";
+    String transportSocketName = "envoy.transport_sockets.tls";
+    Any roundRobinConfig = Any.pack(
+        mf.buildEdsCluster(CDS_RESOURCE, edsService, "round_robin", null, null, true, null,
+            transportSocketName, null, null
+        ));
+    Any ringHashConfig = Any.pack(
+        mf.buildEdsCluster(CDS_RESOURCE, edsService, "ring_hash_experimental",
+            mf.buildRingHashLbConfig("xx_hash", 1, 2), null, true, null,
+            transportSocketName, null, null
+        ));
+    Any leastRequestConfig = Any.pack(
+        mf.buildEdsCluster(CDS_RESOURCE, edsService, "least_request_experimental",
+            null, mf.buildLeastRequestLbConfig(2), true, null,
+            transportSocketName, null, null
+        ));
+
+    // Configure with round robin, the update should be sent to the watcher.
+    call.sendResponse(CDS, roundRobinConfig, VERSION_2, "0001");
+    verify(cdsResourceWatcher, times(1)).onResourceChanged(argThat(StatusOr::hasValue));
+
+    // Second update is identical, watcher should not get an additional update.
+    call.sendResponse(CDS, roundRobinConfig, VERSION_2, "0002");
+    verify(cdsResourceWatcher, times(1)).onResourceChanged(any());
+
+    // Now we switch to ring hash so the watcher should be notified.
+    call.sendResponse(CDS, ringHashConfig, VERSION_2, "0003");
+    verify(cdsResourceWatcher, times(2)).onResourceChanged(argThat(StatusOr::hasValue));
+
+    // Second update to ring hash should not result in watcher being notified.
+    call.sendResponse(CDS, ringHashConfig, VERSION_2, "0004");
+    verify(cdsResourceWatcher, times(2)).onResourceChanged(any());
+
+    // Now we switch to least request so the watcher should be notified.
+    call.sendResponse(CDS, leastRequestConfig, VERSION_2, "0005");
+    verify(cdsResourceWatcher, times(3)).onResourceChanged(argThat(StatusOr::hasValue));
+
+    // Second update to least request should not result in watcher being notified.
+    call.sendResponse(CDS, leastRequestConfig, VERSION_2, "0006");
+    verify(cdsResourceWatcher, times(3)).onResourceChanged(any());
+  }
+
+  @Test
+  public void cdsResourceDeleted() {
+    Assume.assumeFalse(ignoreResourceDeletion());
+
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    verifyResourceMetadataRequested(CDS, CDS_RESOURCE);
+
+    // Initial CDS response.
+    call.sendResponse(CDS, testClusterRoundRobin, VERSION_1, "0000");
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenClusterRoundRobin(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, testClusterRoundRobin, VERSION_1,
+        TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+
+    // Empty CDS response deletes the cluster.
+    call.sendResponse(CDS, Collections.<Any>emptyList(), VERSION_2, "0001");
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_2, "0001", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(argThat(
+        arg -> !arg.hasValue() && arg.getStatus().getDescription().contains(CDS_RESOURCE)));
+    verifyResourceMetadataDoesNotExist(CDS, CDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+  }
+
+  /**
+   * When ignore_resource_deletion server feature is on, xDS client should keep the deleted cluster
+   * on empty response, and resume the normal work when CDS contains the cluster again.
+   */
+  @Test
+  public void cdsResourceDeleted_ignoreResourceDeletion() {
+    Assume.assumeTrue(ignoreResourceDeletion());
+
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    verifyResourceMetadataRequested(CDS, CDS_RESOURCE);
+
+    // Initial CDS response.
+    call.sendResponse(CDS, testClusterRoundRobin, VERSION_1, "0000");
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenClusterRoundRobin(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, testClusterRoundRobin, VERSION_1,
+        TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+
+    // Empty LDS response does not delete the cluster.
+    call.sendResponse(CDS, Collections.emptyList(), VERSION_2, "0001");
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_2, "0001", NODE);
+
+    // The resource is still ACKED at VERSION_1 (no changes).
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, testClusterRoundRobin, VERSION_1,
+        TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+    // onResourceDoesNotExist must not be called.
+    verify(ldsResourceWatcher, never()).onResourceChanged(argThat(
+        arg -> !arg.hasValue() && arg.getStatus().getDescription().contains(CDS_RESOURCE)));
+
+    // Next update is correct, and contains the cluster again.
+    call.sendResponse(CDS, testClusterRoundRobin, VERSION_3, "0003");
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_3, "0003", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenClusterRoundRobin(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, testClusterRoundRobin, VERSION_3,
+        TIME_INCREMENT * 3);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+    verifyNoMoreInteractions(ldsResourceWatcher);
+  }
+
+  /**
+   * When fail_on_data_errors server feature is on, xDS client should delete the cached cluster
+   * and fail RPCs when CDS resource is deleted.
+   */
+  @Test
+  public void cdsResourceDeleted_failOnDataErrors_true() {
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = true;
+    xdsServerInfo = ServerInfo.create(SERVER_URI, CHANNEL_CREDENTIALS, false,
+        true, false, true);
+    BootstrapInfo bootstrapInfo =
+        Bootstrapper.BootstrapInfo.builder()
+            .servers(Collections.singletonList(xdsServerInfo))
+            .node(NODE)
+            .authorities(ImmutableMap.of(
+                "",
+                AuthorityInfo.create(
+                    "xdstp:///envoy.config.listener.v3.Listener/%s",
+                    ImmutableList.of(Bootstrapper.ServerInfo.create(
+                        SERVER_URI_EMPTY_AUTHORITY, CHANNEL_CREDENTIALS)))))
+            .certProviders(ImmutableMap.of())
+            .build();
+    xdsClient = new XdsClientImpl(
+        xdsTransportFactory,
+        bootstrapInfo,
+        fakeClock.getScheduledExecutorService(),
+        backoffPolicyProvider,
+        fakeClock.getStopwatchSupplier(),
+        timeProvider,
+        MessagePrinter.INSTANCE,
+        new TlsContextManagerImpl(bootstrapInfo),
+        xdsClientMetricReporter);
+
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    verifyResourceMetadataRequested(CDS, CDS_RESOURCE);
+
+    // Initial CDS response.
+    call.sendResponse(CDS, testClusterRoundRobin, VERSION_1, "0000");
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenClusterRoundRobin(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, testClusterRoundRobin, VERSION_1,
+        TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+
+    // Empty CDS response deletes the cluster and fails RPCs.
+    call.sendResponse(CDS, Collections.<Any>emptyList(), VERSION_2, "0001");
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_2, "0001", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(argThat(
+        arg -> !arg.hasValue() && arg.getStatus().getDescription().contains(CDS_RESOURCE)));
+    verifyResourceMetadataDoesNotExist(CDS, CDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = false;
+  }
+
+  /**
+   * When fail_on_data_errors server feature is on, xDS client should delete the cached cluster
+   * and fail RPCs when CDS resource is deleted.
+   */
+  @Test
+  public void cdsResourceDeleted_failOnDataErrors_false() {
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = true;
+    // Set failOnDataErrors to false for this test case.
+    xdsServerInfo = ServerInfo.create(SERVER_URI, CHANNEL_CREDENTIALS, false,
+        true, false, false);
+    BootstrapInfo bootstrapInfo =
+        Bootstrapper.BootstrapInfo.builder()
+            .servers(Collections.singletonList(xdsServerInfo))
+            .node(NODE)
+            .authorities(ImmutableMap.of(
+                "",
+                AuthorityInfo.create(
+                    "xdstp:///envoy.config.listener.v3.Listener/%s",
+                    ImmutableList.of(Bootstrapper.ServerInfo.create(
+                        SERVER_URI_EMPTY_AUTHORITY, CHANNEL_CREDENTIALS)))))
+            .certProviders(ImmutableMap.of())
+            .build();
+    xdsClient = new XdsClientImpl(
+        xdsTransportFactory,
+        bootstrapInfo,
+        fakeClock.getScheduledExecutorService(),
+        backoffPolicyProvider,
+        fakeClock.getStopwatchSupplier(),
+        timeProvider,
+        MessagePrinter.INSTANCE,
+        new TlsContextManagerImpl(bootstrapInfo),
+        xdsClientMetricReporter);
+
+    InOrder inOrder = inOrder(cdsResourceWatcher);
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    verifyResourceMetadataRequested(CDS, CDS_RESOURCE);
+
+    // Initial CDS response.
+    call.sendResponse(CDS, testClusterRoundRobin, VERSION_1, "0000");
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    inOrder.verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    verifyGoldenClusterRoundRobin(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, testClusterRoundRobin, VERSION_1,
+        TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+
+    // Empty CDS response should trigger an ambient error.
+    call.sendResponse(CDS, Collections.<Any>emptyList(), VERSION_2, "0001");
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_2, "0001", NODE);
+
+    // Verify that onAmbientError() is called.
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    inOrder.verify(cdsResourceWatcher).onAmbientError(statusCaptor.capture());
+    Status receivedStatus = statusCaptor.getValue();
+    assertThat(receivedStatus.getCode()).isEqualTo(Status.Code.NOT_FOUND);
+    assertThat(receivedStatus.getDescription()).contains(
+        "Resource " + CDS_RESOURCE + " deleted from server");
+
+    // Verify that onResourceChanged() is NOT called again.
+    inOrder.verify(cdsResourceWatcher, never()).onResourceChanged(any());
+    verifySubscribedResourcesMetadataSizes(0, 1, 0, 0);
+
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = false;
+  }
+
+  /**
+   * Tests that a NACKed LDS resource update drops the cached resource when fail_on_data_errors
+   * is enabled.
+   */
+  @Test
+  public void ldsResourceNacked_withFailOnDataErrors_dropsResource() {
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = true;
+    xdsServerInfo = ServerInfo.create(SERVER_URI, CHANNEL_CREDENTIALS, false,
+        true, false, true);
+    BootstrapInfo bootstrapInfo =
+        Bootstrapper.BootstrapInfo.builder()
+            .servers(Collections.singletonList(xdsServerInfo))
+            .node(NODE)
+            .build();
+    xdsClient = new XdsClientImpl(
+        xdsTransportFactory,
+        bootstrapInfo,
+        fakeClock.getScheduledExecutorService(),
+        backoffPolicyProvider,
+        fakeClock.getStopwatchSupplier(),
+        timeProvider,
+        MessagePrinter.INSTANCE,
+        new TlsContextManagerImpl(bootstrapInfo),
+        xdsClientMetricReporter);
+
+    InOrder inOrder = inOrder(ldsResourceWatcher);
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    inOrder.verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> initialUpdate = ldsUpdateCaptor.getValue();
+    assertThat(initialUpdate.hasValue()).isTrue();
+    verifyGoldenListenerVhosts(initialUpdate.getValue());
+    Message invalidListener = mf.buildListenerWithApiListenerInvalid(LDS_RESOURCE);
+    call.sendResponse(LDS, Collections.singletonList(Any.pack(invalidListener)), VERSION_2, "0001");
+    String expectedError = "LDS response Listener '" + LDS_RESOURCE + "' validation error";
+    call.verifyRequestNack(LDS, LDS_RESOURCE, VERSION_1, "0001", NODE,
+        Collections.singletonList(expectedError));
+
+    inOrder.verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> finalUpdate = ldsUpdateCaptor.getValue();
+    assertThat(finalUpdate.hasValue()).isFalse();
+    assertThat(finalUpdate.getStatus().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(finalUpdate.getStatus().getDescription()).contains(expectedError);
+
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = false;
+  }
+
+  /**
+   * Tests that a NACKed LDS resource update is treated as an ambient error when
+   * fail_on_data_errors is disabled.
+   */
+  @Test
+  public void ldsResourceNacked_withFailOnDataErrorsDisabled_isAmbientError() {
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = true;
+    xdsServerInfo = ServerInfo.create(SERVER_URI, CHANNEL_CREDENTIALS, false,
+        true, false, false);
+    BootstrapInfo bootstrapInfo =
+        Bootstrapper.BootstrapInfo.builder()
+            .servers(Collections.singletonList(xdsServerInfo))
+            .node(NODE)
+            .build();
+    xdsClient = new XdsClientImpl(
+        xdsTransportFactory,
+        bootstrapInfo,
+        fakeClock.getScheduledExecutorService(),
+        backoffPolicyProvider,
+        fakeClock.getStopwatchSupplier(),
+        timeProvider,
+        MessagePrinter.INSTANCE,
+        new TlsContextManagerImpl(bootstrapInfo),
+        xdsClientMetricReporter);
+    InOrder inOrder = inOrder(ldsResourceWatcher);
+    DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+
+    call.sendResponse(LDS, testListenerVhosts, VERSION_1, "0000");
+    call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0000", NODE);
+    inOrder.verify(ldsResourceWatcher).onResourceChanged(any());
+    Message invalidListener = mf.buildListenerWithApiListenerInvalid(LDS_RESOURCE);
+    call.sendResponse(LDS, Collections.singletonList(Any.pack(invalidListener)), VERSION_2, "0001");
+
+    String expectedError = "LDS response Listener '" + LDS_RESOURCE + "' validation error";
+    call.verifyRequestNack(LDS, LDS_RESOURCE, VERSION_1, "0001", NODE,
+        Collections.singletonList(expectedError));
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    inOrder.verify(ldsResourceWatcher).onAmbientError(statusCaptor.capture());
+    Status receivedStatus = statusCaptor.getValue();
+    assertThat(receivedStatus.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(receivedStatus.getDescription()).contains(expectedError);
+    inOrder.verify(ldsResourceWatcher, never()).onResourceChanged(any());
+
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = false;
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void multipleCdsWatchers() {
+    String cdsResourceTwo = "cluster-bar.googleapis.com";
+    ResourceWatcher<CdsUpdate> watcher1 = mock(ResourceWatcher.class);
+    ResourceWatcher<CdsUpdate> watcher2 = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), CDS_RESOURCE, cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), cdsResourceTwo, watcher1);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), cdsResourceTwo, watcher2);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    call.verifyRequest(CDS, Arrays.asList(CDS_RESOURCE, cdsResourceTwo), "", "", NODE);
+    verifyResourceMetadataRequested(CDS, CDS_RESOURCE);
+    verifyResourceMetadataRequested(CDS, cdsResourceTwo);
+    verifySubscribedResourcesMetadataSizes(0, 2, 0, 0);
+
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    verify(cdsResourceWatcher).onResourceChanged(argThat(statusOr ->
+        statusOr.getStatus().getDescription().contains(CDS_RESOURCE)));
+    verify(watcher1).onResourceChanged(argThat(statusOr ->
+        statusOr.getStatus().getDescription().contains(cdsResourceTwo)));
+    verify(watcher2).onResourceChanged(argThat(statusOr ->
+        statusOr.getStatus().getDescription().contains(cdsResourceTwo)));
+    verifyResourceMetadataDoesNotExist(CDS, CDS_RESOURCE);
+    verifyResourceMetadataDoesNotExist(CDS, cdsResourceTwo);
+    verifySubscribedResourcesMetadataSizes(0, 2, 0, 0);
+
+    String dnsHostAddr = "dns-service-bar.googleapis.com";
+    int dnsHostPort = 443;
+    String edsService = "eds-service-bar.googleapis.com";
+    List<Any> clusters = ImmutableList.of(
+        Any.pack(mf.buildLogicalDnsCluster(CDS_RESOURCE, dnsHostAddr, dnsHostPort, "round_robin",
+            null, null, false, null, null)),
+        Any.pack(mf.buildEdsCluster(cdsResourceTwo, edsService, "round_robin", null, null, true,
+            null, "envoy.transport_sockets.tls", null, null)));
+    call.sendResponse(CDS, clusters, VERSION_1, "0000");
+    ArgumentCaptor<StatusOr<CdsUpdate>> cdsUpdateCaptor = ArgumentCaptor.forClass(StatusOr.class);
+    verify(cdsResourceWatcher, times(2)).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> capturedUpdate1 = cdsUpdateCaptor.getAllValues().get(1);
+    assertThat(capturedUpdate1.hasValue()).isTrue();
+    CdsUpdate cdsUpdate1 = capturedUpdate1.getValue();
+    assertThat(cdsUpdate1.clusterName()).isEqualTo(CDS_RESOURCE);
+    assertThat(cdsUpdate1.clusterType()).isEqualTo(ClusterType.LOGICAL_DNS);
+    assertThat(cdsUpdate1.dnsHostName()).isEqualTo(dnsHostAddr + ":" + dnsHostPort);
+    LbConfig lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(cdsUpdate1.lbPolicyConfig());
+    assertThat(lbConfig.getPolicyName()).isEqualTo("wrr_locality_experimental");
+    List<LbConfig> childConfigs = ServiceConfigUtil.unwrapLoadBalancingConfigList(
+        JsonUtil.getListOfObjects(lbConfig.getRawConfigValue(), "childPolicy"));
+    assertThat(childConfigs.get(0).getPolicyName()).isEqualTo("round_robin");
+    assertThat(cdsUpdate1.lrsServerInfo()).isNull();
+    assertThat(cdsUpdate1.maxConcurrentRequests()).isNull();
+    assertThat(cdsUpdate1.upstreamTlsContext()).isNull();
+    ArgumentCaptor<StatusOr<CdsUpdate>> watcher1Captor = ArgumentCaptor.forClass(StatusOr.class);
+    verify(watcher1, times(2)).onResourceChanged(watcher1Captor.capture());
+    StatusOr<CdsUpdate> capturedUpdate2 = watcher1Captor.getAllValues().get(1);
+    assertThat(capturedUpdate2.hasValue()).isTrue();
+    CdsUpdate cdsUpdate2 = capturedUpdate2.getValue();
+    assertThat(cdsUpdate2.clusterName()).isEqualTo(cdsResourceTwo);
+    assertThat(cdsUpdate2.clusterType()).isEqualTo(ClusterType.EDS);
+    assertThat(cdsUpdate2.edsServiceName()).isEqualTo(edsService);
+    lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(cdsUpdate2.lbPolicyConfig());
+    assertThat(lbConfig.getPolicyName()).isEqualTo("wrr_locality_experimental");
+    childConfigs = ServiceConfigUtil.unwrapLoadBalancingConfigList(
+        JsonUtil.getListOfObjects(lbConfig.getRawConfigValue(), "childPolicy"));
+    assertThat(childConfigs.get(0).getPolicyName()).isEqualTo("round_robin");
+    assertThat(cdsUpdate2.lrsServerInfo()).isEqualTo(xdsServerInfo);
+    assertThat(cdsUpdate2.maxConcurrentRequests()).isNull();
+    assertThat(cdsUpdate2.upstreamTlsContext()).isNull();
+    ArgumentCaptor<StatusOr<CdsUpdate>> watcher2Captor = ArgumentCaptor.forClass(StatusOr.class);
+    verify(watcher2, times(2)).onResourceChanged(watcher2Captor.capture());
+    StatusOr<CdsUpdate> capturedUpdate3 = watcher2Captor.getAllValues().get(1);
+    assertThat(capturedUpdate3.hasValue()).isTrue();
+    CdsUpdate cdsUpdate3 = capturedUpdate3.getValue();
+    assertThat(cdsUpdate3.clusterName()).isEqualTo(cdsResourceTwo);
+    assertThat(cdsUpdate3.clusterType()).isEqualTo(ClusterType.EDS);
+    assertThat(cdsUpdate3.edsServiceName()).isEqualTo(edsService);
+    lbConfig = ServiceConfigUtil.unwrapLoadBalancingConfig(cdsUpdate3.lbPolicyConfig());
+    assertThat(lbConfig.getPolicyName()).isEqualTo("wrr_locality_experimental");
+    childConfigs = ServiceConfigUtil.unwrapLoadBalancingConfigList(
+        JsonUtil.getListOfObjects(lbConfig.getRawConfigValue(), "childPolicy"));
+    assertThat(childConfigs.get(0).getPolicyName()).isEqualTo("round_robin");
+    assertThat(cdsUpdate3.lrsServerInfo()).isEqualTo(xdsServerInfo);
+    assertThat(cdsUpdate3.maxConcurrentRequests()).isNull();
+    assertThat(cdsUpdate3.upstreamTlsContext()).isNull();
+    // Metadata of both clusters is stored.
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, clusters.get(0), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(CDS, cdsResourceTwo, clusters.get(1), VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 2, 0, 0);
+  }
+
+  @Test
+  public void edsResourceNotFound() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsEndpointResource.getInstance(), EDS_RESOURCE,
+        edsResourceWatcher);
+    Any clusterLoadAssignment = Any.pack(mf.buildClusterLoadAssignment(
+        "cluster-bar.googleapis.com",
+        ImmutableList.of(lbEndpointHealthy),
+        ImmutableList.<Message>of()));
+    call.sendResponse(EDS, clusterLoadAssignment, VERSION_1, "0000");
+
+    // Client sent an ACK EDS request.
+    call.verifyRequest(EDS, EDS_RESOURCE, VERSION_1, "0000", NODE);
+    verifyNoInteractions(edsResourceWatcher);
+    verifyResourceMetadataRequested(EDS, EDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 1);
+    // Server failed to return subscribed resource within expected time window.
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    verify(edsResourceWatcher).onResourceChanged(argThat(statusOr ->
+        statusOr.getStatus().getDescription().contains(EDS_RESOURCE)));
+    assertThat(fakeClock.getPendingTasks(EDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+    verifyResourceMetadataDoesNotExist(EDS, EDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 1);
+  }
+
+  @Test
+  public void edsCleanupNonceAfterUnsubscription() {
+    Assume.assumeFalse(ignoreResourceDeletion());
+
+    // Suppose we have an EDS subscription A.1
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), "A.1", edsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    assertThat(call).isNotNull();
+    call.verifyRequest(EDS, "A.1", "", "", NODE);
+
+    // EDS -> {A.1}, version 1
+    List<Message> dropOverloads = ImmutableList.of();
+    List<Message> endpointsV1 = ImmutableList.of(lbEndpointHealthy);
+    ImmutableMap<String, Any> resourcesV1 = ImmutableMap.of(
+        "A.1", Any.pack(mf.buildClusterLoadAssignment("A.1", endpointsV1, dropOverloads)));
+    call.sendResponse(EDS, resourcesV1.values().asList(), VERSION_1, "0000");
+    // {A.1} -> ACK, version 1
+    call.verifyRequest(EDS, "A.1", VERSION_1, "0000", NODE);
+    verify(edsResourceWatcher, times(1)).onResourceChanged(any());
+
+    // trigger an EDS resource unsubscription.
+    xdsClient.cancelXdsResourceWatch(XdsEndpointResource.getInstance(), "A.1", edsResourceWatcher);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 0);
+    call.verifyRequest(EDS, Arrays.asList(), VERSION_1, "0000", NODE);
+    // The control plane can send an updated response for the empty subscription list, with a new
+    // nonce.
+    call.sendResponse(EDS, Arrays.asList(), VERSION_1, "0001");
+
+    // When re-subscribing, the version was forgotten but not the nonce
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), "A.1", edsResourceWatcher);
+    call.verifyRequest(EDS, "A.1", "", "0001", NODE, Mockito.timeout(2000));
+  }
+
+  @Test
+  public void edsResponseErrorHandling_allResourcesFailedUnpack() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsEndpointResource.getInstance(), EDS_RESOURCE,
+        edsResourceWatcher);
+    verifyResourceMetadataRequested(EDS, EDS_RESOURCE);
+    call.sendResponse(EDS, ImmutableList.of(FAILING_ANY, FAILING_ANY), VERSION_1, "0000");
+
+    // Resulting metadata unchanged because the response has no identifiable subscribed resources.
+    verifyResourceMetadataRequested(EDS, EDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 1);
+    // The response NACKed with errors indicating indices of the failed resources.
+    call.verifyRequestNack(EDS, EDS_RESOURCE, "", "0000", NODE, ImmutableList.of(
+        "EDS response Resource index 0 - can't decode ClusterLoadAssignment: ",
+        "EDS response Resource index 1 - can't decode ClusterLoadAssignment: "));
+    verifyNoInteractions(edsResourceWatcher);
+  }
+
+  @Test
+  public void edsResponseErrorHandling_someResourcesFailedUnpack() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsEndpointResource.getInstance(), EDS_RESOURCE,
+        edsResourceWatcher);
+    verifyResourceMetadataRequested(EDS, EDS_RESOURCE);
+
+    // Correct resource is in the middle to ensure processing continues on errors.
+    List<Any> resources = ImmutableList.of(FAILING_ANY, testClusterLoadAssignment, FAILING_ANY);
+    call.sendResponse(EDS, resources, VERSION_1, "0000");
+
+    // All errors recorded in the metadata of successfully unpacked subscribed resources.
+    List<String> errors = ImmutableList.of(
+        "EDS response Resource index 0 - can't decode ClusterLoadAssignment: ",
+        "EDS response Resource index 2 - can't decode ClusterLoadAssignment: ");
+    verifyResourceMetadataAcked(
+        EDS, EDS_RESOURCE, testClusterLoadAssignment, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 1);
+    // The response is NACKed with the same error message.
+    call.verifyRequestNack(EDS, EDS_RESOURCE, "", "0000", NODE, errors);
+    verify(edsResourceWatcher).onResourceChanged(edsUpdateCaptor.capture());
+    StatusOr<EdsUpdate> statusOrUpdate = edsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    EdsUpdate edsUpdate = statusOrUpdate.getValue();
+    assertThat(edsUpdate.clusterName).isEqualTo(EDS_RESOURCE);
+  }
+
+  /**
+   * Tests a subscribed EDS resource transitioned to and from the invalid state.
+   *
+   * @see <a
+   *     href="https://github.com/grpc/proposal/blob/master/A40-csds-support.md#ads-parsing-logic-update-continue-after-first-error">
+   *     A40-csds-support.md</a>
+   */
+  @Test
+  public void edsResponseErrorHandling_subscribedResourceInvalid() {
+    List<String> subscribedResourceNames = ImmutableList.of("A", "B", "C");
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), "A", edsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), "B", edsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), "C", edsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    assertThat(call).isNotNull();
+    verifyResourceMetadataRequested(EDS, "A");
+    verifyResourceMetadataRequested(EDS, "B");
+    verifyResourceMetadataRequested(EDS, "C");
+
+    // EDS -> {A, B, C}, version 1
+    List<Message> dropOverloads = ImmutableList.of(mf.buildDropOverload("lb", 200));
+    List<Message> endpointsV1 = ImmutableList.of(lbEndpointHealthy);
+    ImmutableMap<String, Any> resourcesV1 = ImmutableMap.of(
+        "A", Any.pack(mf.buildClusterLoadAssignment("A", endpointsV1, dropOverloads)),
+        "B", Any.pack(mf.buildClusterLoadAssignment("B", endpointsV1, dropOverloads)),
+        "C", Any.pack(mf.buildClusterLoadAssignment("C", endpointsV1, dropOverloads)));
+    call.sendResponse(EDS, resourcesV1.values().asList(), VERSION_1, "0000");
+    // {A, B, C} -> ACK, version 1
+    verifyResourceValidInvalidCount(1, 3, 0, xdsServerInfo.target(), EDS.typeUrl());
+    verifyResourceMetadataAcked(EDS, "A", resourcesV1.get("A"), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(EDS, "B", resourcesV1.get("B"), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(EDS, "C", resourcesV1.get("C"), VERSION_1, TIME_INCREMENT);
+    call.verifyRequest(EDS, subscribedResourceNames, VERSION_1, "0000", NODE);
+
+    // EDS -> {A, B}, version 2
+    // Failed to parse endpoint B
+    List<Message> endpointsV2 = ImmutableList.of(lbEndpointHealthy, lbEndpointEmpty);
+    ImmutableMap<String, Any> resourcesV2 = ImmutableMap.of(
+        "A", Any.pack(mf.buildClusterLoadAssignment("A", endpointsV2, dropOverloads)),
+        "B", Any.pack(mf.buildClusterLoadAssignmentInvalid("B")));
+    call.sendResponse(EDS, resourcesV2.values().asList(), VERSION_2, "0001");
+    // {A} -> ACK, version 2
+    // {B} -> NACK, version 1, rejected version 2, rejected reason: Failed to parse B
+    // {C} -> ACK, version 1
+    // Check metric data.
+    verifyResourceValidInvalidCount(1, 1, 1, xdsServerInfo.target(), EDS.typeUrl());
+    List<String> errorsV2 =
+        ImmutableList.of("EDS response ClusterLoadAssignment 'B' validation error: ");
+    verifyResourceMetadataAcked(EDS, "A", resourcesV2.get("A"), VERSION_2, TIME_INCREMENT * 2);
+    verifyResourceMetadataNacked(EDS, "B", resourcesV1.get("B"), VERSION_1, TIME_INCREMENT,
+        VERSION_2, TIME_INCREMENT * 2, errorsV2, true);
+    verifyResourceMetadataAcked(EDS, "C", resourcesV1.get("C"), VERSION_1, TIME_INCREMENT);
+    call.verifyRequestNack(EDS, subscribedResourceNames, VERSION_1, "0001", NODE, errorsV2);
+
+    // EDS -> {B, C} version 3
+    List<Message> endpointsV3 =
+        ImmutableList.of(lbEndpointHealthy, lbEndpointEmpty, lbEndpointZeroWeight);
+    ImmutableMap<String, Any> resourcesV3 = ImmutableMap.of(
+        "B", Any.pack(mf.buildClusterLoadAssignment("B", endpointsV3, dropOverloads)),
+        "C", Any.pack(mf.buildClusterLoadAssignment("C", endpointsV3, dropOverloads)));
+    call.sendResponse(EDS, resourcesV3.values().asList(), VERSION_3, "0002");
+    // {A} -> ACK, version 2
+    // {B, C} -> ACK, version 3
+    // Check metric data.
+    verifyResourceValidInvalidCount(1, 2, 0, xdsServerInfo.target(), EDS.typeUrl());
+    verifyResourceMetadataAcked(EDS, "A", resourcesV2.get("A"), VERSION_2, TIME_INCREMENT * 2);
+    verifyResourceMetadataAcked(EDS, "B", resourcesV3.get("B"), VERSION_3, TIME_INCREMENT * 3);
+    verifyResourceMetadataAcked(EDS, "C", resourcesV3.get("C"), VERSION_3, TIME_INCREMENT * 3);
+    call.verifyRequest(EDS, subscribedResourceNames, VERSION_3, "0002", NODE);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 3);
+  }
+
+  @Test
+  public void edsResourceFound() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsEndpointResource.getInstance(), EDS_RESOURCE,
+        edsResourceWatcher);
+    call.sendResponse(EDS, testClusterLoadAssignment, VERSION_1, "0000");
+
+    // Client sent an ACK EDS request.
+    call.verifyRequest(EDS, EDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(edsResourceWatcher).onResourceChanged(edsUpdateCaptor.capture());
+    StatusOr<EdsUpdate> statusOrUpdate = edsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    validateGoldenClusterLoadAssignment(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(EDS, EDS_RESOURCE, testClusterLoadAssignment, VERSION_1,
+        TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 1);
+  }
+
+  @Test
+  public void wrappedEdsResourceFound() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsEndpointResource.getInstance(), EDS_RESOURCE,
+        edsResourceWatcher);
+    call.sendResponse(EDS, mf.buildWrappedResource(testClusterLoadAssignment), VERSION_1, "0000");
+
+    // Client sent an ACK EDS request.
+    call.verifyRequest(EDS, EDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(edsResourceWatcher).onResourceChanged(edsUpdateCaptor.capture());
+    StatusOr<EdsUpdate> statusOrUpdate = edsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    validateGoldenClusterLoadAssignment(statusOrUpdate.getValue());
+    verifyResourceMetadataAcked(EDS, EDS_RESOURCE, testClusterLoadAssignment, VERSION_1,
+        TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 1);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void cachedEdsResource_data() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsEndpointResource.getInstance(), EDS_RESOURCE,
+        edsResourceWatcher);
+    call.sendResponse(EDS, testClusterLoadAssignment, VERSION_1, "0000");
+
+    // Client sent an ACK EDS request.
+    call.verifyRequest(EDS, EDS_RESOURCE, VERSION_1, "0000", NODE);
+    // Add another watcher.
+    ResourceWatcher<EdsUpdate> watcher = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), EDS_RESOURCE, watcher);
+    verify(watcher).onResourceChanged(edsUpdateCaptor.capture());
+    StatusOr<EdsUpdate> statusOrUpdate = edsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    validateGoldenClusterLoadAssignment(statusOrUpdate.getValue());
+    call.verifyNoMoreRequest();
+    verifyResourceMetadataAcked(EDS, EDS_RESOURCE, testClusterLoadAssignment, VERSION_1,
+        TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 1);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void cachedEdsResource_absent() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsEndpointResource.getInstance(), EDS_RESOURCE,
+        edsResourceWatcher);
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    verify(edsResourceWatcher).onResourceChanged(argThat(statusOr ->
+        statusOr.getStatus().getDescription().contains(EDS_RESOURCE)));
+    ResourceWatcher<EdsUpdate> watcher = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), EDS_RESOURCE, watcher);
+    verify(watcher).onResourceChanged(argThat(statusOr ->
+        statusOr.getStatus().getDescription().contains(EDS_RESOURCE)));
+    call.verifyNoMoreRequest();
+    verifyResourceMetadataDoesNotExist(EDS, EDS_RESOURCE);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 1);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void flowControlAbsent() throws Exception {
+    String anotherCdsResource = CDS_RESOURCE + "2";
+    FakeClock fakeWatchClock = new FakeClock();
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher, fakeWatchClock.getScheduledExecutorService());
+    ResourceWatcher<CdsUpdate> anotherWatcher = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), anotherCdsResource,
+        anotherWatcher, fakeWatchClock.getScheduledExecutorService());
+    verifyResourceMetadataRequested(CDS, CDS_RESOURCE);
+    verifyResourceMetadataRequested(CDS, anotherCdsResource);
+
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    call.verifyRequest(CDS, Arrays.asList(CDS_RESOURCE, anotherCdsResource), "", "", NODE);
+    assertThat(fakeWatchClock.runDueTasks()).isEqualTo(2);
+    call.sendResponse(CDS, testClusterRoundRobin, VERSION_1, "0000");
+    verifyResourceMetadataAcked(
+        CDS, CDS_RESOURCE, testClusterRoundRobin, VERSION_1, TIME_INCREMENT);
+    call.verifyRequest(CDS, Arrays.asList(CDS_RESOURCE, anotherCdsResource), VERSION_1,
+        "0000", NODE);
+    verifyNoInteractions(cdsResourceWatcher, anotherWatcher);
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    assertThat(fakeWatchClock.getPendingTasks().size()).isEqualTo(2);
+    CyclicBarrier barrier = new CyclicBarrier(2);
+    doAnswer(blockUpdate(barrier)).when(cdsResourceWatcher).onResourceChanged(any());
+
+    CountDownLatch latch = new CountDownLatch(1);
+    new Thread(() -> {
+      try {
+        fakeWatchClock.runDueTasks();
+        latch.countDown();
+      } catch (Exception ex) {
+        throw new RuntimeException(ex);
+      }
+    }).start();
+    ImmutableMap<String, Any> resourcesV2 = ImmutableMap.of(
+        CDS_RESOURCE, Any.pack(mf.buildEdsCluster(CDS_RESOURCE, "A.2", "round_robin", null,
+            null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )),
+        anotherCdsResource, Any.pack(mf.buildClusterInvalid(anotherCdsResource)));
+    call.sendResponse(CDS, resourcesV2.values().asList(), VERSION_2, "0001");
+    assertThat(call.isReady()).isFalse();
+    verifyResourceMetadataAcked(
+        CDS, CDS_RESOURCE, testClusterRoundRobin, VERSION_1, TIME_INCREMENT);
+    barrier.await();
+    verify(cdsResourceWatcher, atLeastOnce()).onResourceChanged(any());
+    String errorMsg = "CDS response Cluster 'cluster.googleapis.com2' validation error: "
+        + "Cluster cluster.googleapis.com2: unspecified cluster discovery type";
+    call.verifyRequestNack(CDS, Arrays.asList(CDS_RESOURCE, anotherCdsResource), VERSION_1, "0001",
+        NODE, Arrays.asList(errorMsg));
+    barrier.await();
+    latch.await(10, TimeUnit.SECONDS);
+    verify(cdsResourceWatcher, times(2)).onResourceChanged(any());
+    verify(anotherWatcher, times(2)).onResourceChanged(
+        argThat(statusOr -> statusOr.getStatus().getDescription().contains(anotherCdsResource)));
+  }
+
+  @Test
+  public void resourceTimerIsTransientError_schedulesExtendedTimeout() {
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = true;
+    ServerInfo serverInfo = ServerInfo.create(SERVER_URI, CHANNEL_CREDENTIALS,
+        false, true, true, false);
+    BootstrapInfo bootstrapInfo =
+        Bootstrapper.BootstrapInfo.builder()
+            .servers(Collections.singletonList(serverInfo))
+            .node(NODE)
+            .authorities(ImmutableMap.of(
+                "",
+                AuthorityInfo.create(
+                    "xdstp:///envoy.config.listener.v3.Listener/%s",
+                    ImmutableList.of(Bootstrapper.ServerInfo.create(
+                        SERVER_URI_EMPTY_AUTHORITY, CHANNEL_CREDENTIALS)))))
+            .certProviders(ImmutableMap.of())
+            .build();
+    xdsClient = new XdsClientImpl(
+        xdsTransportFactory,
+        bootstrapInfo,
+        fakeClock.getScheduledExecutorService(),
+        backoffPolicyProvider,
+        fakeClock.getStopwatchSupplier(),
+        timeProvider,
+        MessagePrinter.INSTANCE,
+        new TlsContextManagerImpl(bootstrapInfo),
+        xdsClientMetricReporter);
+    @SuppressWarnings("unchecked")
+    ResourceWatcher<CdsUpdate> watcher = mock(ResourceWatcher.class);
+    String resourceName = "cluster.googleapis.com";
+
+    xdsClient.watchXdsResource(
+        XdsClusterResource.getInstance(),
+        resourceName,
+        watcher,
+        fakeClock.getScheduledExecutorService());
+
+    ScheduledTask task = Iterables.getOnlyElement(
+        fakeClock.getPendingTasks(CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER));
+    assertThat(task.getDelay(TimeUnit.SECONDS))
+        .isEqualTo(XdsClientImpl.EXTENDED_RESOURCE_FETCH_TIMEOUT_SEC);
+    fakeClock.runDueTasks();
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = false;
+  }
+
+  @Test
+  public void resourceTimerIsTransientError_callsOnErrorUnavailable() {
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = true;
+    xdsServerInfo = ServerInfo.create(SERVER_URI, CHANNEL_CREDENTIALS, ignoreResourceDeletion(),
+        true, true, false);
+    BootstrapInfo bootstrapInfo =
+        Bootstrapper.BootstrapInfo.builder()
+            .servers(Collections.singletonList(xdsServerInfo))
+            .node(NODE)
+            .authorities(ImmutableMap.of(
+                "authority.xds.com",
+                AuthorityInfo.create(
+                    "xdstp://authority.xds.com/envoy.config.listener.v3.Listener/%s",
+                    ImmutableList.of(Bootstrapper.ServerInfo.create(
+                        SERVER_URI_CUSTOM_AUTHORITY, CHANNEL_CREDENTIALS))),
+                "",
+                AuthorityInfo.create(
+                    "xdstp:///envoy.config.listener.v3.Listener/%s",
+                    ImmutableList.of(Bootstrapper.ServerInfo.create(
+                        SERVER_URI_EMPTY_AUTHORITY, CHANNEL_CREDENTIALS)))))
+            .certProviders(ImmutableMap.of("cert-instance-name",
+                CertificateProviderInfo.create("file-watcher", ImmutableMap.of())))
+            .build();
+    xdsClient = new XdsClientImpl(
+        xdsTransportFactory,
+        bootstrapInfo,
+        fakeClock.getScheduledExecutorService(),
+        backoffPolicyProvider,
+        fakeClock.getStopwatchSupplier(),
+        timeProvider,
+        MessagePrinter.INSTANCE,
+        new TlsContextManagerImpl(bootstrapInfo),
+        xdsClientMetricReporter);
+    String timeoutResource = CDS_RESOURCE + "_timeout";
+    @SuppressWarnings("unchecked")
+    ResourceWatcher<CdsUpdate> timeoutWatcher = mock(ResourceWatcher.class);
+
+    xdsClient.watchXdsResource(
+        XdsClusterResource.getInstance(),
+        timeoutResource,
+        timeoutWatcher,
+        fakeClock.getScheduledExecutorService());
+
+    assertThat(resourceDiscoveryCalls).hasSize(1);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    call.verifyRequest(CDS, ImmutableList.of(timeoutResource), "", "", NODE);
+    fakeClock.forwardTime(XdsClientImpl.EXTENDED_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    fakeClock.runDueTasks();
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<StatusOr<CdsUpdate>> statusOrCaptor = ArgumentCaptor.forClass(StatusOr.class);
+    verify(timeoutWatcher).onResourceChanged(statusOrCaptor.capture());
+    StatusOr<CdsUpdate> statusOr = statusOrCaptor.getValue();
+    Status error = statusOr.getStatus();
+    assertThat(error.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(error.getDescription()).isEqualTo(
+        "Timed out waiting for resource " + timeoutResource + " from xDS server");
+    BootstrapperImpl.xdsDataErrorHandlingEnabled = false;
+  }
+
+  private Answer<Void> blockUpdate(CyclicBarrier barrier) {
+    return new Answer<Void>() {
+      @Override
+      public Void answer(InvocationOnMock invocation) throws Throwable {
+        barrier.await();
+        return null;
+      }
+    };
+  }
+
+  @Test
+  public void simpleFlowControl() throws Exception {
+    FakeClock fakeWatchClock = new FakeClock();
+    DiscoveryRpcCall call = startResourceWatcher(XdsEndpointResource.getInstance(), EDS_RESOURCE,
+        edsResourceWatcher, fakeWatchClock.getScheduledExecutorService());
+    verifyResourceMetadataRequested(EDS, EDS_RESOURCE);
+    assertThat(fakeWatchClock.runDueTasks()).isEqualTo(1);
+
+    call.sendResponse(EDS, testClusterLoadAssignment, VERSION_1, "0000");
+    call.verifyRequest(EDS, EDS_RESOURCE, VERSION_1, "0000", NODE);
+    verifyResourceMetadataAcked(EDS, EDS_RESOURCE, testClusterLoadAssignment, VERSION_1,
+        TIME_INCREMENT);
+    verifyNoInteractions(edsResourceWatcher);
+    assertThat(fakeWatchClock.getPendingTasks().size()).isEqualTo(1);
+
+    // Updated EDS response.
+    Any updatedClusterLoadAssignment = Any.pack(mf.buildClusterLoadAssignment(EDS_RESOURCE,
+        ImmutableList.of(mf.buildLocalityLbEndpoints("region2", "zone2", "subzone2",
+            mf.buildLbEndpoint("172.44.2.2", 8000, "unknown", 3, "endpoint-host-name"), 2, 0)),
+        ImmutableList.<Message>of()));
+    call.sendResponse(EDS, updatedClusterLoadAssignment, VERSION_2, "0001");
+    // message not processed due to flow control
+    call.verifyNoMoreRequest();
+    assertThat(call.isReady()).isFalse();
+
+    CyclicBarrier barrier = new CyclicBarrier(2);
+    doAnswer(blockUpdate(barrier)).when(edsResourceWatcher).onResourceChanged(any());
+
+    CountDownLatch latch = new CountDownLatch(1);
+    new Thread(() -> {
+      try {
+        fakeWatchClock.runDueTasks();
+        latch.countDown();
+      } catch (Exception ex) {
+        throw new RuntimeException(ex);
+      }
+    }).start();
+
+    verifyResourceMetadataAcked(EDS, EDS_RESOURCE, testClusterLoadAssignment, VERSION_1,
+        TIME_INCREMENT);
+    barrier.await();
+    verify(edsResourceWatcher, atLeastOnce()).onResourceChanged(edsUpdateCaptor.capture());
+    StatusOr<EdsUpdate> statusOrUpdate = edsUpdateCaptor.getAllValues().get(0);
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    EdsUpdate edsUpdate = statusOrUpdate.getValue();
+    validateGoldenClusterLoadAssignment(edsUpdate);
+    barrier.await();
+    latch.await(10, TimeUnit.SECONDS);
+    verify(edsResourceWatcher, times(2)).onResourceChanged(any());
+    verifyResourceMetadataAcked(EDS, EDS_RESOURCE, updatedClusterLoadAssignment, VERSION_2,
+        TIME_INCREMENT * 2);
+  }
+
+  @Test
+  public void flowControlUnknownType() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsEndpointResource.getInstance(), EDS_RESOURCE,
+        edsResourceWatcher);
+    call.sendResponse(CDS, testClusterRoundRobin, VERSION_1, "0000");
+    call.sendResponse(EDS, testClusterLoadAssignment, VERSION_1, "0000");
+    call.verifyRequest(EDS, EDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(edsResourceWatcher).onResourceChanged(any());
+  }
+
+  @Test
+  public void edsResourceUpdated() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsEndpointResource.getInstance(), EDS_RESOURCE,
+        edsResourceWatcher);
+    verifyResourceMetadataRequested(EDS, EDS_RESOURCE);
+
+    // Initial EDS response.
+    call.sendResponse(EDS, testClusterLoadAssignment, VERSION_1, "0000");
+    call.verifyRequest(EDS, EDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(edsResourceWatcher).onResourceChanged(edsUpdateCaptor.capture());
+    StatusOr<EdsUpdate> statusOrUpdate = edsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    EdsUpdate edsUpdate = statusOrUpdate.getValue();
+    validateGoldenClusterLoadAssignment(edsUpdate);
+    verifyResourceMetadataAcked(EDS, EDS_RESOURCE, testClusterLoadAssignment, VERSION_1,
+        TIME_INCREMENT);
+
+    // Updated EDS response.
+    Any updatedClusterLoadAssignment = Any.pack(mf.buildClusterLoadAssignment(EDS_RESOURCE,
+        ImmutableList.of(mf.buildLocalityLbEndpoints("region2", "zone2", "subzone2",
+            mf.buildLbEndpoint("172.44.2.2", 8000, "unknown", 3, "endpoint-host-name"), 2, 0)),
+        ImmutableList.<Message>of()));
+    call.sendResponse(EDS, updatedClusterLoadAssignment, VERSION_2, "0001");
+
+    verify(edsResourceWatcher, times(2)).onResourceChanged(edsUpdateCaptor.capture());
+    statusOrUpdate = edsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    edsUpdate = statusOrUpdate.getValue();
+    assertThat(edsUpdate.clusterName).isEqualTo(EDS_RESOURCE);
+    assertThat(edsUpdate.dropPolicies).isEmpty();
+    assertThat(edsUpdate.localityLbEndpointsMap)
+        .containsExactly(
+            Locality.create("region2", "zone2", "subzone2"),
+            LocalityLbEndpoints.create(
+                ImmutableList.of(
+                    LbEndpoint.create("172.44.2.2", 8000, 3,
+                        true, "endpoint-host-name", ImmutableMap.of())),
+                2, 0, ImmutableMap.of()));
+    verifyResourceMetadataAcked(EDS, EDS_RESOURCE, updatedClusterLoadAssignment, VERSION_2,
+        TIME_INCREMENT * 2);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 1);
+  }
+
+  @Test
+  public void edsDuplicateLocalityInTheSamePriority() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsEndpointResource.getInstance(), EDS_RESOURCE,
+        edsResourceWatcher);
+    verifyResourceMetadataRequested(EDS, EDS_RESOURCE);
+
+    // Updated EDS response.
+    Any updatedClusterLoadAssignment = Any.pack(mf.buildClusterLoadAssignment(EDS_RESOURCE,
+        ImmutableList.of(
+            mf.buildLocalityLbEndpoints("region2", "zone2", "subzone2",
+              mf.buildLbEndpoint("172.44.2.2", 8000, "unknown", 3, "endpoint-host-name"), 2, 1),
+            mf.buildLocalityLbEndpoints("region2", "zone2", "subzone2",
+                mf.buildLbEndpoint("172.44.2.3", 8080, "healthy", 10, "endpoint-host-name"), 2, 1)
+            ),
+        ImmutableList.<Message>of()));
+    call.sendResponse(EDS, updatedClusterLoadAssignment, "0", "0001");
+    String errorMsg = "EDS response ClusterLoadAssignment"
+        + " \'cluster-load-assignment.googleapis.com\' "
+        + "validation error: ClusterLoadAssignment has duplicate "
+        + "locality:Locality{region=region2, zone=zone2, subZone=subzone2} for priority:1";
+    call.verifyRequestNack(EDS, EDS_RESOURCE, "", "0001", NODE, ImmutableList.of(
+        errorMsg));
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<StatusOr<EdsUpdate>> captor = ArgumentCaptor.forClass(StatusOr.class);
+    verify(edsResourceWatcher).onResourceChanged(captor.capture());
+    StatusOr<EdsUpdate> statusOrUpdate = captor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isFalse();
+    assertThat(statusOrUpdate.getStatus().getDescription()).contains(errorMsg);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void edsResourceDeletedByCds() {
+    String resource = "backend-service.googleapis.com";
+    ResourceWatcher<CdsUpdate> cdsWatcher = mock(ResourceWatcher.class);
+    ResourceWatcher<EdsUpdate> edsWatcher = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), resource, cdsWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), resource, edsWatcher);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), CDS_RESOURCE, cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), EDS_RESOURCE, edsResourceWatcher);
+    verifyResourceMetadataRequested(CDS, CDS_RESOURCE);
+    verifyResourceMetadataRequested(CDS, resource);
+    verifyResourceMetadataRequested(EDS, EDS_RESOURCE);
+    verifyResourceMetadataRequested(EDS, resource);
+    verifySubscribedResourcesMetadataSizes(0, 2, 0, 2);
+
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    List<Any> clusters = ImmutableList.of(
+        Any.pack(mf.buildEdsCluster(resource, null, "round_robin", null, null, true, null,
+            "envoy.transport_sockets.tls", null, null
+        )),
+        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, EDS_RESOURCE, "round_robin", null, null, false,
+            null, "envoy.transport_sockets.tls", null, null)));
+    call.sendResponse(CDS, clusters, VERSION_1, "0000");
+    ArgumentCaptor<StatusOr<CdsUpdate>> cdsUpdateCaptor = ArgumentCaptor.forClass(StatusOr.class);
+    verify(cdsWatcher, times(1)).onResourceChanged(cdsUpdateCaptor.capture());
+    CdsUpdate cdsUpdate = cdsUpdateCaptor.getValue().getValue();
+    assertThat(cdsUpdate.edsServiceName()).isEqualTo(null);
+    assertThat(cdsUpdate.lrsServerInfo()).isEqualTo(xdsServerInfo);
+    verify(cdsResourceWatcher, times(1)).onResourceChanged(cdsUpdateCaptor.capture());
+    cdsUpdate = cdsUpdateCaptor.getValue().getValue();
+    assertThat(cdsUpdate.edsServiceName()).isEqualTo(EDS_RESOURCE);
+    assertThat(cdsUpdate.lrsServerInfo()).isNull();
+    verifyResourceMetadataAcked(CDS, resource, clusters.get(0), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, clusters.get(1), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataRequested(EDS, EDS_RESOURCE);
+    verifyResourceMetadataRequested(EDS, resource);
+
+    List<Any> clusterLoadAssignments =
+        ImmutableList.of(
+            Any.pack(
+                mf.buildClusterLoadAssignment(EDS_RESOURCE,
+                    ImmutableList.of(lbEndpointHealthy),
+                    ImmutableList.of(
+                        mf.buildDropOverload("lb", 200),
+                        mf.buildDropOverload("throttle", 1000)))),
+            Any.pack(
+                mf.buildClusterLoadAssignment(resource,
+                    ImmutableList.of(
+                        mf.buildLocalityLbEndpoints("region2", "zone2", "subzone2",
+                            mf.buildLbEndpoint("192.168.0.2", 9090, "healthy", 3,
+                                "endpoint-host-name"), 1, 0)),
+                    ImmutableList.of(mf.buildDropOverload("lb", 100)))));
+    call.sendResponse(EDS, clusterLoadAssignments, VERSION_1, "0000");
+    ArgumentCaptor<StatusOr<EdsUpdate>> edsUpdateCaptor = ArgumentCaptor.forClass(StatusOr.class);
+    verify(edsWatcher, times(1)).onResourceChanged(edsUpdateCaptor.capture());
+    assertThat(edsUpdateCaptor.getValue().getValue().clusterName).isEqualTo(resource);
+    verify(edsResourceWatcher, times(1)).onResourceChanged(edsUpdateCaptor.capture());
+    assertThat(edsUpdateCaptor.getValue().getValue().clusterName).isEqualTo(EDS_RESOURCE);
+
+    verifyResourceMetadataAcked(
+        EDS, EDS_RESOURCE, clusterLoadAssignments.get(0), VERSION_1, TIME_INCREMENT * 2);
+    verifyResourceMetadataAcked(
+        EDS, resource, clusterLoadAssignments.get(1), VERSION_1, TIME_INCREMENT * 2);
+    // CDS not changed.
+    verifyResourceMetadataAcked(CDS, resource, clusters.get(0), VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, clusters.get(1), VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 2, 0, 2);
+
+    clusters = ImmutableList.of(
+        Any.pack(mf.buildEdsCluster(resource, null, "round_robin", null, null, true, null,
+            "envoy.transport_sockets.tls", null, null)),  // no change
+        Any.pack(mf.buildEdsCluster(CDS_RESOURCE, null, "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )));
+    call.sendResponse(CDS, clusters, VERSION_2, "0001");
+    verify(cdsResourceWatcher, times(2)).onResourceChanged(cdsUpdateCaptor.capture());
+    assertThat(cdsUpdateCaptor.getValue().getValue().edsServiceName()).isNull();
+    verifyNoMoreInteractions(cdsWatcher, edsWatcher);
+    verifyResourceMetadataAcked(
+        EDS, EDS_RESOURCE, clusterLoadAssignments.get(0), VERSION_1, TIME_INCREMENT * 2);
+    verifyResourceMetadataAcked(
+        EDS, resource, clusterLoadAssignments.get(1), VERSION_1, TIME_INCREMENT * 2);  // no change
+    verifyResourceMetadataAcked(CDS, resource, clusters.get(0), VERSION_2, TIME_INCREMENT * 3);
+    verifyResourceMetadataAcked(CDS, CDS_RESOURCE, clusters.get(1), VERSION_2, TIME_INCREMENT * 3);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void multipleEdsWatchers() {
+    String edsResourceTwo = "cluster-load-assignment-bar.googleapis.com";
+    ResourceWatcher<EdsUpdate> watcher1 = mock(ResourceWatcher.class);
+    ResourceWatcher<EdsUpdate> watcher2 = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), EDS_RESOURCE, edsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), edsResourceTwo, watcher1);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), edsResourceTwo, watcher2);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    call.verifyRequest(EDS, Arrays.asList(EDS_RESOURCE, edsResourceTwo), "", "", NODE);
+    verifyResourceMetadataRequested(EDS, EDS_RESOURCE);
+    verifyResourceMetadataRequested(EDS, edsResourceTwo);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 2);
+
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    verify(edsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getDescription().contains(EDS_RESOURCE)));
+    verify(watcher1).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getDescription().contains(edsResourceTwo)));
+    verify(watcher2).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getDescription().contains(edsResourceTwo)));
+    verifyResourceMetadataDoesNotExist(EDS, EDS_RESOURCE);
+    verifyResourceMetadataDoesNotExist(EDS, edsResourceTwo);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 2);
+
+    call.sendResponse(EDS, testClusterLoadAssignment, VERSION_1, "0000");
+    verify(edsResourceWatcher, times(2)).onResourceChanged(edsUpdateCaptor.capture());
+    StatusOr<EdsUpdate> statusOrUpdate = edsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    EdsUpdate edsUpdate = statusOrUpdate.getValue();
+    validateGoldenClusterLoadAssignment(edsUpdate);
+    verifyNoMoreInteractions(watcher1, watcher2);
+    verifyResourceMetadataAcked(
+        EDS, EDS_RESOURCE, testClusterLoadAssignment, VERSION_1, TIME_INCREMENT);
+    verifyResourceMetadataDoesNotExist(EDS, edsResourceTwo);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 2);
+
+    Any clusterLoadAssignmentTwo = Any.pack(
+        mf.buildClusterLoadAssignment(edsResourceTwo,
+            ImmutableList.of(
+                mf.buildLocalityLbEndpoints("region2", "zone2", "subzone2",
+                    mf.buildLbEndpoint("172.44.2.2", 8000, "healthy", 3, "endpoint-host-name"),
+                    2, 0)),
+            ImmutableList.<Message>of()));
+    call.sendResponse(EDS, clusterLoadAssignmentTwo, VERSION_2, "0001");
+
+    verify(watcher1, times(2)).onResourceChanged(edsUpdateCaptor.capture());
+    statusOrUpdate = edsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    edsUpdate = statusOrUpdate.getValue();
+    assertThat(edsUpdate.clusterName).isEqualTo(edsResourceTwo);
+    assertThat(edsUpdate.dropPolicies).isEmpty();
+    assertThat(edsUpdate.localityLbEndpointsMap)
+        .containsExactly(
+            Locality.create("region2", "zone2", "subzone2"),
+            LocalityLbEndpoints.create(
+                ImmutableList.of(
+                    LbEndpoint.create("172.44.2.2", 8000, 3,
+                        true, "endpoint-host-name", ImmutableMap.of())),
+                2, 0, ImmutableMap.of()));
+    verify(watcher2, times(2)).onResourceChanged(edsUpdateCaptor.capture());
+    statusOrUpdate = edsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    edsUpdate = statusOrUpdate.getValue();
+    assertThat(edsUpdate.clusterName).isEqualTo(edsResourceTwo);
+    assertThat(edsUpdate.dropPolicies).isEmpty();
+    assertThat(edsUpdate.localityLbEndpointsMap)
+        .containsExactly(
+            Locality.create("region2", "zone2", "subzone2"),
+            LocalityLbEndpoints.create(
+                ImmutableList.of(
+                    LbEndpoint.create("172.44.2.2", 8000, 3,
+                        true, "endpoint-host-name", ImmutableMap.of())),
+                2, 0, ImmutableMap.of()));
+    verifyNoMoreInteractions(edsResourceWatcher);
+    verifyResourceMetadataAcked(
+        EDS, edsResourceTwo, clusterLoadAssignmentTwo, VERSION_2, TIME_INCREMENT * 2);
+    verifyResourceMetadataAcked(
+        EDS, EDS_RESOURCE, testClusterLoadAssignment, VERSION_1, TIME_INCREMENT);
+    verifySubscribedResourcesMetadataSizes(0, 0, 0, 2);
+  }
+
+  @Test
+  public void useIndependentRpcContext() {
+    // Simulates making RPCs within the context of an inbound RPC.
+    CancellableContext cancellableContext = Context.current().withCancellation();
+    Context prevContext = cancellableContext.attach();
+    try {
+      DiscoveryRpcCall call = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+          ldsResourceWatcher);
+
+      // The inbound RPC finishes and closes its context. The outbound RPC's control plane RPC
+      // should not be impacted.
+      cancellableContext.close();
+      verify(ldsResourceWatcher, never()).onAmbientError(any(Status.class));
+      verify(ldsResourceWatcher, never()).onResourceChanged(argThat(
+          statusOr -> !statusOr.hasValue()
+      ));
+
+      call.sendResponse(LDS, testListenerRds, VERSION_1, "0000");
+      verify(ldsResourceWatcher).onResourceChanged(any());
+    } finally {
+      cancellableContext.detach(prevContext);
+    }
+  }
+
+  @Test
+  public void streamClosedWithNoResponse() {
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE, ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_RESOURCE,
+        rdsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    // Check metric data.
+    callback_ReportServerConnection();
+    verifyServerConnection(1, true, xdsServerInfo.target());
+    // Management server closes the RPC stream before sending any response.
+    call.sendCompleted();
+    // Check metric data.
+    callback_ReportServerConnection();
+    verifyServerConnection(1, false, xdsServerInfo.target());
+    verify(ldsResourceWatcher, Mockito.timeout(1000)).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> ldsStatusOr = ldsUpdateCaptor.getValue();
+    assertThat(ldsStatusOr.hasValue()).isFalse();
+    verifyStatusWithNodeId(ldsStatusOr.getStatus(), Code.UNAVAILABLE,
+        "ADS stream closed with OK before receiving a response");
+    verify(rdsResourceWatcher, Mockito.timeout(1000)).onResourceChanged(rdsUpdateCaptor.capture());
+    StatusOr<RdsUpdate> rdsStatusOr = rdsUpdateCaptor.getValue();
+    assertThat(rdsStatusOr.hasValue()).isFalse();
+    verifyStatusWithNodeId(rdsStatusOr.getStatus(), Code.UNAVAILABLE,
+        "ADS stream closed with OK before receiving a response");
+  }
+
+  @Test
+  public void streamClosedAfterSendingResponses() {
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE, ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_RESOURCE,
+        rdsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    // Check metric data.
+    callback_ReportServerConnection();
+    verifyServerConnection(1, true, xdsServerInfo.target());
+    ScheduledTask ldsResourceTimeout =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER));
+    ScheduledTask rdsResourceTimeout =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(RDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER));
+    call.sendResponse(LDS, testListenerRds, VERSION_1, "0000");
+    // Check metric data.
+    callback_ReportServerConnection();
+    verifyServerConnection(2, true, xdsServerInfo.target());
+    assertThat(ldsResourceTimeout.isCancelled()).isTrue();
+    call.sendResponse(RDS, testRouteConfig, VERSION_1, "0000");
+    assertThat(rdsResourceTimeout.isCancelled()).isTrue();
+    // Management server closes the RPC stream after sending responses.
+    call.sendCompleted();
+    // Check metric data.
+    callback_ReportServerConnection();
+    verifyServerConnection(3, true, xdsServerInfo.target());
+    verify(ldsResourceWatcher, never()).onAmbientError(any(Status.class));
+    verify(rdsResourceWatcher, never()).onAmbientError(any(Status.class));
+    verify(ldsResourceWatcher, times(1)).onResourceChanged(any());
+    verify(rdsResourceWatcher, times(1)).onResourceChanged(any());
+  }
+
+  @Test
+  public void streamClosedAndRetryWithBackoff() {
+    InOrder inOrder = inOrder(backoffPolicyProvider, backoffPolicy1, backoffPolicy2);
+    InOrder ldsWatcherInOrder = inOrder(ldsResourceWatcher);
+    InOrder rdsWatcherInOrder = inOrder(rdsResourceWatcher);
+    InOrder cdsWatcherInOrder = inOrder(cdsResourceWatcher);
+    InOrder edsWatcherInOrder = inOrder(edsResourceWatcher);
+    when(backoffPolicyProvider.get()).thenReturn(backoffPolicy1, backoffPolicy2, backoffPolicy2);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE, ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_RESOURCE,
+        rdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), CDS_RESOURCE, cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), EDS_RESOURCE, edsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    call.verifyRequest(LDS, LDS_RESOURCE, "", "", NODE);
+    call.verifyRequest(RDS, RDS_RESOURCE, "", "", NODE);
+    call.verifyRequest(CDS, CDS_RESOURCE, "", "", NODE);
+    call.verifyRequest(EDS, EDS_RESOURCE, "", "", NODE);
+
+    // Management server closes the RPC stream with an error. No response received yet.
+    fakeClock.forwardNanos(1000L); // Make sure retry isn't based on stopwatch 0
+    call.sendError(Status.UNKNOWN.asException());
+    ldsWatcherInOrder.verify(ldsResourceWatcher, timeout(1000)).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNKNOWN));
+    rdsWatcherInOrder.verify(rdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNKNOWN));
+    cdsWatcherInOrder.verify(cdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNKNOWN));
+    edsWatcherInOrder.verify(edsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNKNOWN));
+
+    verifyServerFailureCount(1, 1, xdsServerInfo.target());
+
+    // Retry after backoff.
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+    ScheduledTask retryTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER));
+    assertThat(retryTask.getDelay(TimeUnit.NANOSECONDS)).isEqualTo(10L);
+    fakeClock.forwardNanos(10L);
+    call = resourceDiscoveryCalls.poll();
+    call.verifyRequest(LDS, LDS_RESOURCE, "", "", NODE);
+    call.verifyRequest(RDS, RDS_RESOURCE, "", "", NODE);
+    call.verifyRequest(CDS, CDS_RESOURCE, "", "", NODE);
+    call.verifyRequest(EDS, EDS_RESOURCE, "", "", NODE);
+
+    // Management server becomes unreachable. No response received on this stream either.
+    String errorMsg = "my fault";
+    call.sendError(Status.UNAVAILABLE.withDescription(errorMsg).asException());
+    ldsWatcherInOrder.verify(ldsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+    rdsWatcherInOrder.verify(rdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+    cdsWatcherInOrder.verify(cdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+    edsWatcherInOrder.verify(edsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+
+    verifyServerFailureCount(2, 1, xdsServerInfo.target());
+
+    // Retry after backoff.
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+    retryTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER));
+    assertThat(retryTask.getDelay(TimeUnit.NANOSECONDS)).isEqualTo(100L);
+    fakeClock.forwardNanos(100L);
+    call = resourceDiscoveryCalls.poll();
+    call.verifyRequest(LDS, LDS_RESOURCE, "", "", NODE);
+    call.verifyRequest(RDS, RDS_RESOURCE, "", "", NODE);
+    call.verifyRequest(CDS, CDS_RESOURCE, "", "", NODE);
+    call.verifyRequest(EDS, EDS_RESOURCE, "", "", NODE);
+
+    List<Any> listeners = ImmutableList.of(
+        Any.pack(mf.buildListenerWithApiListener(LDS_RESOURCE,
+            mf.buildRouteConfiguration("do not care", mf.buildOpaqueVirtualHosts(2)))));
+    call.sendResponse(LDS, listeners, "63", "3242");
+    call.verifyRequest(LDS, LDS_RESOURCE, "63", "3242", NODE);
+    ldsWatcherInOrder.verify(ldsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> statusOr.hasValue()));
+
+    List<Any> routeConfigs = ImmutableList.of(
+        Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE, mf.buildOpaqueVirtualHosts(2))));
+    call.sendResponse(RDS, routeConfigs, "5", "6764");
+    call.verifyRequest(RDS, RDS_RESOURCE, "5", "6764", NODE);
+    rdsWatcherInOrder.verify(rdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> statusOr.hasValue()));
+
+    // Stream fails AFTER a response. Error is suppressed and no watcher notification occurs.
+    call.sendError(Status.DEADLINE_EXCEEDED.asException());
+
+    // Failure count does NOT increase.
+    verifyServerFailureCount(2, 1, xdsServerInfo.target());
+
+    // Reset backoff sequence and retry after backoff.
+    inOrder.verify(backoffPolicyProvider).get();
+    inOrder.verify(backoffPolicy2).nextBackoffNanos();
+    retryTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER));
+    fakeClock.forwardNanos(retryTask.getDelay(TimeUnit.NANOSECONDS));
+    call = resourceDiscoveryCalls.poll();
+    call.verifyRequest(LDS, LDS_RESOURCE, "63", "", NODE);
+    call.verifyRequest(RDS, RDS_RESOURCE, "5", "", NODE);
+    call.verifyRequest(CDS, CDS_RESOURCE, "", "", NODE);
+    call.verifyRequest(EDS, EDS_RESOURCE, "", "", NODE);
+
+    // Management server becomes unreachable again. This is on a new stream, so error propagates.
+    call.sendError(Status.UNAVAILABLE.asException());
+    ldsWatcherInOrder.verify(ldsResourceWatcher).onAmbientError(
+        argThat(status -> status.getCode() == Code.UNAVAILABLE));
+    rdsWatcherInOrder.verify(rdsResourceWatcher).onAmbientError(
+        argThat(status -> status.getCode() == Code.UNAVAILABLE));
+    cdsWatcherInOrder.verify(cdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+    edsWatcherInOrder.verify(edsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+
+    // Failure count is now 3.
+    verifyServerFailureCount(3, 1, xdsServerInfo.target());
+
+    // Retry after backoff.
+    inOrder.verify(backoffPolicy2).nextBackoffNanos();
+    retryTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER));
+    assertThat(retryTask.getDelay(TimeUnit.NANOSECONDS)).isEqualTo(200L);
+    fakeClock.forwardNanos(200L);
+    call = resourceDiscoveryCalls.poll();
+    call.verifyRequest(LDS, LDS_RESOURCE, "63", "", NODE);
+    call.verifyRequest(RDS, RDS_RESOURCE, "5", "", NODE);
+    call.verifyRequest(CDS, CDS_RESOURCE, "", "", NODE);
+    call.verifyRequest(EDS, EDS_RESOURCE, "", "", NODE);
+
+    // Send a response so CPC is considered working and close gracefully.
+    call.sendResponse(LDS, listeners, "63", "3242");
+    call.sendCompleted();
+
+    // Final failure count is still 3.
+    verifyServerFailureCount(3, 1, xdsServerInfo.target());
+  }
+
+  @Test
+  public void newWatcher_receivesCachedDataAndAmbientError() throws Exception {
+    InOrder inOrder = inOrder(ldsResourceWatcher);
+    DiscoveryRpcCall call1 = startResourceWatcher(XdsListenerResource.getInstance(), LDS_RESOURCE,
+        ldsResourceWatcher);
+    call1.sendResponse(LDS, testListenerRds, VERSION_1, "0000");
+    inOrder.verify(ldsResourceWatcher, timeout(5000))
+        .onResourceChanged(argThat(statusOr -> statusOr.hasValue()));
+
+    call1.sendError(Status.DEADLINE_EXCEEDED.asException());
+    ScheduledTask retryTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER));
+    fakeClock.forwardNanos(retryTask.getDelay(TimeUnit.NANOSECONDS));
+    DiscoveryRpcCall call2 = resourceDiscoveryCalls.poll();
+    Status propagatedError = Status.UNAVAILABLE.withDescription("real failure");
+    call2.sendError(propagatedError.asException());
+    inOrder.verify(ldsResourceWatcher, timeout(5000)).onAmbientError(
+        argThat(status -> status.getCode() == Code.UNAVAILABLE));
+    @SuppressWarnings("unchecked")
+    ResourceWatcher<LdsUpdate> ldsResourceWatcher2 = mock(ResourceWatcher.class);
+    xdsClient.watchXdsResource(
+        XdsListenerResource.getInstance(), LDS_RESOURCE, ldsResourceWatcher2);
+
+    verify(ldsResourceWatcher2, timeout(5000)).onResourceChanged(
+        argThat(statusOr -> statusOr.hasValue()));
+    verify(ldsResourceWatcher2, timeout(5000)).onAmbientError(
+        argThat(status -> status.getCode() == Code.UNAVAILABLE));
+  }
+
+  @Test
+  public void streamClosedAndRetryRaceWithAddRemoveWatchers() {
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(),
+        LDS_RESOURCE, ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(),
+        RDS_RESOURCE, rdsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    // Check metric data.
+    callback_ReportServerConnection();
+    verifyServerConnection(1, true, xdsServerInfo.target());
+    call.sendError(Status.UNAVAILABLE.asException());
+    verify(ldsResourceWatcher, Mockito.timeout(1000).times(1))
+        .onResourceChanged(ldsUpdateCaptor.capture());
+    verifyStatusWithNodeId(ldsUpdateCaptor.getValue().getStatus(), Code.UNAVAILABLE, "");
+    verify(rdsResourceWatcher).onResourceChanged(rdsUpdateCaptor.capture());
+    verifyStatusWithNodeId(rdsUpdateCaptor.getValue().getStatus(), Code.UNAVAILABLE, "");
+    ScheduledTask retryTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER));
+    assertThat(retryTask.getDelay(TimeUnit.NANOSECONDS)).isEqualTo(10L);
+
+    // Check metric data.
+    callback_ReportServerConnection();
+    verifyServerConnection(1, false, xdsServerInfo.target());
+
+    xdsClient.cancelXdsResourceWatch(XdsListenerResource.getInstance(),
+        LDS_RESOURCE, ldsResourceWatcher);
+    xdsClient.cancelXdsResourceWatch(XdsRouteConfigureResource.getInstance(),
+        RDS_RESOURCE, rdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(),
+        CDS_RESOURCE, cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(),
+        EDS_RESOURCE, edsResourceWatcher);
+    fakeClock.forwardNanos(10L);
+    call = resourceDiscoveryCalls.poll();
+    call.verifyRequest(CDS, CDS_RESOURCE, "", "", NODE);
+    call.verifyRequest(EDS, EDS_RESOURCE, "", "", NODE);
+    call.verifyNoMoreRequest();
+
+    // Check metric data.
+    callback_ReportServerConnection();
+    verifyServerConnection(2,false, xdsServerInfo.target());
+
+    call.sendResponse(LDS, testListenerRds, VERSION_1, "0000");
+    List<Any> routeConfigs = ImmutableList.of(
+        Any.pack(mf.buildRouteConfiguration(RDS_RESOURCE, mf.buildOpaqueVirtualHosts(VHOST_SIZE))));
+    call.sendResponse(RDS, routeConfigs, VERSION_1, "0000");
+
+    // Check metric data.
+    callback_ReportServerConnection();
+    verifyServerConnection(2, true, xdsServerInfo.target());
+
+    verifyNoMoreInteractions(ldsResourceWatcher, rdsResourceWatcher);
+  }
+
+  @Test
+  public void streamClosedAndRetryRestartsResourceInitialFetchTimerForUnresolvedResources() {
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE, ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_RESOURCE,
+        rdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), CDS_RESOURCE, cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), EDS_RESOURCE, edsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    // Check metric data.
+    callback_ReportServerConnection();
+    verifyServerConnection(1, true, xdsServerInfo.target());
+    ScheduledTask ldsResourceTimeout =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER));
+    ScheduledTask rdsResourceTimeout =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(RDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER));
+    ScheduledTask cdsResourceTimeout =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER));
+    ScheduledTask edsResourceTimeout =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(EDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER));
+    call.sendResponse(LDS, testListenerRds, VERSION_1, "0000");
+    assertThat(ldsResourceTimeout.isCancelled()).isTrue();
+    // Check metric data.
+    callback_ReportServerConnection();
+    verifyServerConnection(2, true, xdsServerInfo.target());
+
+    call.sendResponse(RDS, testRouteConfig, VERSION_1, "0000");
+    assertThat(rdsResourceTimeout.isCancelled()).isTrue();
+    // Check metric data.
+    callback_ReportServerConnection();
+    verifyServerConnection(3, true, xdsServerInfo.target());
+
+    call.sendError(Status.UNAVAILABLE.asException());
+    assertThat(cdsResourceTimeout.isCancelled()).isTrue();
+    assertThat(edsResourceTimeout.isCancelled()).isTrue();
+
+    // With the reverted logic, the first error is suppressed because a response was received.
+    // We verify that no error callbacks are invoked at this point.
+    verify(ldsResourceWatcher, never()).onAmbientError(any(Status.class));
+    verify(rdsResourceWatcher, never()).onAmbientError(any(Status.class));
+
+    // The metric report for a failed server connection is also suppressed.
+    callback_ReportServerConnection();
+    verifyServerConnection(4, true, xdsServerInfo.target());
+
+    fakeClock.forwardTime(5, TimeUnit.SECONDS);
+    DiscoveryRpcCall call2 = resourceDiscoveryCalls.poll();
+    call2.sendError(Status.UNAVAILABLE.asException());
+
+    // Now, verify the watchers are notified as expected.
+    verify(ldsResourceWatcher).onAmbientError(any(Status.class));
+    verify(rdsResourceWatcher).onAmbientError(any(Status.class));
+    verify(cdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+    verify(edsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+
+    fakeClock.forwardTime(5, TimeUnit.SECONDS);
+    DiscoveryRpcCall call3 = resourceDiscoveryCalls.poll();
+    assertThat(call3).isNotNull();
+
+    fakeClock.forwardNanos(10L);
+    assertThat(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).hasSize(0);
+    assertThat(fakeClock.getPendingTasks(RDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).hasSize(0);
+    assertThat(fakeClock.getPendingTasks(CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).hasSize(1);
+    assertThat(fakeClock.getPendingTasks(EDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).hasSize(1);
+  }
+
+  @Test
+  public void reportLoadStatsToServer() {
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE, ldsResourceWatcher);
+    String clusterName = "cluster-foo.googleapis.com";
+    ClusterDropStats dropStats = xdsClient.addClusterDropStats(xdsServerInfo, clusterName, null);
+    LrsRpcCall lrsCall = loadReportCalls.poll();
+    lrsCall.verifyNextReportClusters(Collections.<String[]>emptyList()); // initial LRS request
+
+    lrsCall.sendResponse(Collections.singletonList(clusterName), 1000L);
+    fakeClock.forwardNanos(1000L);
+    lrsCall.verifyNextReportClusters(Collections.singletonList(new String[]{clusterName, null}));
+
+    dropStats.release();
+    fakeClock.forwardNanos(1000L);
+    // In case of having unreported cluster stats, one last report will be sent after corresponding
+    // stats object released.
+    lrsCall.verifyNextReportClusters(Collections.singletonList(new String[]{clusterName, null}));
+
+    fakeClock.forwardNanos(1000L);
+    // Currently load reporting continues (with empty stats) even if all stats objects have been
+    // released.
+    lrsCall.verifyNextReportClusters(Collections.<String[]>emptyList());  // no more stats reported
+
+    // See more test on LoadReportClientTest.java
+  }
+
+  @Test
+  public void serverSideListenerFound() {
+    GrpcXdsClientImplTestBase.DiscoveryRpcCall call =
+        startResourceWatcher(XdsListenerResource.getInstance(), LISTENER_RESOURCE,
+            ldsResourceWatcher);
+    Message hcmFilter = mf.buildHttpConnectionManagerFilter(
+        "route-foo.googleapis.com", null,
+        Collections.singletonList(mf.buildTerminalFilter()));
+    Message downstreamTlsContext = CommonTlsContextTestsUtil.buildTestDownstreamTlsContext(
+        "google-sds-config-default", "ROOTCA", false);
+    Message filterChain = mf.buildFilterChain(
+        Collections.<String>emptyList(), downstreamTlsContext, "envoy.transport_sockets.tls",
+        hcmFilter);
+    Message listener =
+        mf.buildListenerWithFilterChain(LISTENER_RESOURCE, 7000, "0.0.0.0", filterChain);
+    List<Any> listeners = ImmutableList.of(Any.pack(listener));
+    call.sendResponse(LDS, listeners, "0", "0000");
+    // Client sends an ACK LDS request.
+    call.verifyRequest(LDS, Collections.singletonList(LISTENER_RESOURCE), "0", "0000", NODE);
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    EnvoyServerProtoData.Listener parsedListener = statusOrUpdate.getValue().listener();
+    assertThat(parsedListener.name()).isEqualTo(LISTENER_RESOURCE);
+    assertThat(parsedListener.address()).isEqualTo("0.0.0.0:7000");
+    assertThat(parsedListener.defaultFilterChain()).isNull();
+    assertThat(parsedListener.filterChains()).hasSize(1);
+    FilterChain parsedFilterChain = Iterables.getOnlyElement(parsedListener.filterChains());
+    assertThat(parsedFilterChain.filterChainMatch().applicationProtocols()).isEmpty();
+    assertThat(parsedFilterChain.httpConnectionManager().rdsName())
+        .isEqualTo("route-foo.googleapis.com");
+    assertThat(parsedFilterChain.httpConnectionManager().httpFilterConfigs().get(0).filterConfig)
+        .isEqualTo(RouterFilter.ROUTER_CONFIG);
+
+    assertThat(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+  }
+
+  @Test
+  public void serverSideListenerNotFound() {
+    GrpcXdsClientImplTestBase.DiscoveryRpcCall call =
+        startResourceWatcher(XdsListenerResource.getInstance(), LISTENER_RESOURCE,
+            ldsResourceWatcher);
+    Message hcmFilter = mf.buildHttpConnectionManagerFilter(
+        "route-foo.googleapis.com", null,
+        Collections.singletonList(mf.buildTerminalFilter()));
+    Message downstreamTlsContext = CommonTlsContextTestsUtil.buildTestDownstreamTlsContext(
+        "google-sds-config-default", "ROOTCA", false);
+    Message filterChain = mf.buildFilterChain(
+        Collections.singletonList("managed-mtls"), downstreamTlsContext,
+        "envoy.transport_sockets.tls", hcmFilter);
+    Message listener = mf.buildListenerWithFilterChain(
+        "grpc/server?xds.resource.listening_address=0.0.0.0:8000", 7000, "0.0.0.0", filterChain);
+    List<Any> listeners = ImmutableList.of(Any.pack(listener));
+    call.sendResponse(LDS, listeners, "0", "0000");
+    // Client sends an ACK LDS request.
+    call.verifyRequest(LDS, Collections.singletonList(LISTENER_RESOURCE), "0", "0000", NODE);
+
+    verifyNoInteractions(ldsResourceWatcher);
+    fakeClock.forwardTime(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC, TimeUnit.SECONDS);
+    verify(ldsResourceWatcher).onResourceChanged(argThat(
+        statusOr -> statusOr.getStatus().getDescription().contains(LISTENER_RESOURCE)));
+    assertThat(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+  }
+
+  @Test
+  public void serverSideListenerResponseErrorHandling_badDownstreamTlsContext() {
+    GrpcXdsClientImplTestBase.DiscoveryRpcCall call =
+        startResourceWatcher(XdsListenerResource.getInstance(), LISTENER_RESOURCE,
+            ldsResourceWatcher);
+    Message hcmFilter = mf.buildHttpConnectionManagerFilter(
+        "route-foo.googleapis.com", null,
+        Collections.singletonList(mf.buildTerminalFilter()));
+    Message downstreamTlsContext = CommonTlsContextTestsUtil.buildTestDownstreamTlsContext(
+        null, null, false);
+    Message filterChain = mf.buildFilterChain(
+        Collections.<String>emptyList(), downstreamTlsContext, "envoy.transport_sockets.tls",
+        hcmFilter);
+    Message listener =
+        mf.buildListenerWithFilterChain(LISTENER_RESOURCE, 7000, "0.0.0.0", filterChain);
+    List<Any> listeners = ImmutableList.of(Any.pack(listener));
+    call.sendResponse(LDS, listeners, "0", "0000");
+    // The response NACKed with errors indicating indices of the failed resources.
+    String errorMsg = "LDS response Listener \'grpc/server?xds.resource.listening_address="
+        + "0.0.0.0:7000\' validation error: "
+        + "common-tls-context is required in downstream-tls-context";
+    call.verifyRequestNack(LDS, LISTENER_RESOURCE, "", "0000", NODE, ImmutableList.of(errorMsg));
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isFalse();
+    verifyStatusWithNodeId(statusOrUpdate.getStatus(), Code.UNAVAILABLE, errorMsg);
+  }
+
+  @Test
+  public void serverSideListenerResponseErrorHandling_badTransportSocketName() {
+    GrpcXdsClientImplTestBase.DiscoveryRpcCall call =
+        startResourceWatcher(XdsListenerResource.getInstance(), LISTENER_RESOURCE,
+            ldsResourceWatcher);
+    Message hcmFilter = mf.buildHttpConnectionManagerFilter(
+        "route-foo.googleapis.com", null,
+        Collections.singletonList(mf.buildTerminalFilter()));
+    Message downstreamTlsContext = CommonTlsContextTestsUtil.buildTestDownstreamTlsContext(
+        "cert1", "cert2", false);
+    Message filterChain = mf.buildFilterChain(
+        Collections.<String>emptyList(), downstreamTlsContext, "envoy.transport_sockets.bad1",
+        hcmFilter);
+    Message listener =
+        mf.buildListenerWithFilterChain(LISTENER_RESOURCE, 7000, "0.0.0.0", filterChain);
+    List<Any> listeners = ImmutableList.of(Any.pack(listener));
+    call.sendResponse(LDS, listeners, "0", "0000");
+    // The response NACKed with errors indicating indices of the failed resources.
+    String errorMsg = "LDS response Listener \'grpc/server?xds.resource.listening_address="
+        + "0.0.0.0:7000\' validation error: "
+        + "transport-socket with name envoy.transport_sockets.bad1 not supported.";
+    call.verifyRequestNack(LDS, LISTENER_RESOURCE, "", "0000", NODE, ImmutableList.of(
+        errorMsg));
+    verify(ldsResourceWatcher).onResourceChanged(ldsUpdateCaptor.capture());
+    verifyStatusWithNodeId(ldsUpdateCaptor.getValue().getStatus(), Code.UNAVAILABLE, errorMsg);
+  }
+
+  @Test
+  public void sendingToStoppedServer() throws Exception {
+    try {
+      // Establish the adsStream object
+      xdsClient.watchXdsResource(XdsClusterResource.getInstance(), CDS_RESOURCE,
+          cdsResourceWatcher);
+      DiscoveryRpcCall unused = resourceDiscoveryCalls.take(); // clear this entry
+
+      // Shutdown server and initiate a request
+      xdsServer.shutdownNow();
+      xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE,
+          ldsResourceWatcher);
+      fakeClock.forwardTime(14, TimeUnit.SECONDS);
+      // Check metric data.
+      callback_ReportServerConnection();
+      verifyServerConnection(1, false, xdsServerInfo.target());
+
+      // Restart the server
+      xdsServer = cleanupRule.register(
+          InProcessServerBuilder
+              .forName(serverName)
+              .addService(adsService)
+              .addService(lrsService)
+              .directExecutor()
+              .build()
+              .start());
+      fakeClock.forwardTime(5, TimeUnit.SECONDS);
+      verify(ldsResourceWatcher, never()).onResourceChanged(argThat(
+          statusOr -> statusOr.getStatus().getDescription().contains(LDS_RESOURCE)));
+      fakeClock.forwardTime(20, TimeUnit.SECONDS); // Trigger rpcRetryTimer
+      DiscoveryRpcCall call = resourceDiscoveryCalls.poll(3, TimeUnit.SECONDS);
+      // Check metric data.
+      callback_ReportServerConnection();
+      if (call == null) { // The first rpcRetry may have happened before the channel was ready
+        fakeClock.forwardTime(50, TimeUnit.SECONDS);
+        call = resourceDiscoveryCalls.poll(3, TimeUnit.SECONDS);
+      }
+      verifyServerConnection(2, false, xdsServerInfo.target());
+
+      // Check metric data.
+      callback_ReportServerConnection();
+      verifyServerConnection(3, false, xdsServerInfo.target());
+
+      // NOTE:  There is a ScheduledExecutorService that may get involved due to the reconnect
+      // so you cannot rely on the logic being single threaded.  The timeout() in verifyRequest
+      // is therefore necessary to avoid flakiness.
+      // Send a response and do verifications
+      call.sendResponse(LDS, mf.buildWrappedResource(testListenerVhosts), VERSION_1, "0001");
+      call.verifyRequest(LDS, LDS_RESOURCE, VERSION_1, "0001", NODE);
+      @SuppressWarnings("unchecked")
+      ArgumentCaptor<StatusOr<LdsUpdate>> captor = ArgumentCaptor.forClass(StatusOr.class);
+      verify(ldsResourceWatcher, timeout(1000).atLeast(2)).onResourceChanged(captor.capture());
+      StatusOr<LdsUpdate> lastValue = captor.getAllValues().get(captor.getAllValues().size() - 1);
+      assertThat(lastValue.hasValue()).isTrue();
+      verifyGoldenListenerVhosts(lastValue.getValue());
+      assertThat(fakeClock.getPendingTasks(LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER)).isEmpty();
+      verifyResourceMetadataAcked(LDS, LDS_RESOURCE, testListenerVhosts, VERSION_1, TIME_INCREMENT);
+      verifySubscribedResourcesMetadataSizes(1, 1, 0, 0);
+      // Check metric data.
+      callback_ReportServerConnection();
+      verifyServerConnection(1, true, xdsServerInfo.target());
+    } catch (Throwable t) {
+      throw t; // This allows putting a breakpoint here for debugging
+    }
+  }
+
+  @Test
+  public void sendToBadUrl() throws Exception {
+    // Setup xdsClient to fail on stream creation
+    String garbageUri = "some. garbage";
+    XdsClientImpl client = createXdsClient(garbageUri);
+
+    client.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE, ldsResourceWatcher);
+    fakeClock.forwardTime(20, TimeUnit.SECONDS);
+    verify(ldsResourceWatcher, Mockito.timeout(5000).atLeastOnce())
+        .onResourceChanged(ldsUpdateCaptor.capture());
+    assertThat(ldsUpdateCaptor.getValue().getStatus().getDescription()).contains(garbageUri);
+    client.shutdown();
+  }
+
+  @Test
+  public void circuitBreakingConversionOf32bitIntTo64bitLongForMaxRequestNegativeValue() {
+    DiscoveryRpcCall call = startResourceWatcher(XdsClusterResource.getInstance(), CDS_RESOURCE,
+        cdsResourceWatcher);
+    Any clusterCircuitBreakers = Any.pack(
+        mf.buildEdsCluster(CDS_RESOURCE, null, "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", mf.buildCircuitBreakers(50, -1), null));
+    call.sendResponse(CDS, clusterCircuitBreakers, VERSION_1, "0000");
+
+    // Client sent an ACK CDS request.
+    call.verifyRequest(CDS, CDS_RESOURCE, VERSION_1, "0000", NODE);
+    verify(cdsResourceWatcher).onResourceChanged(cdsUpdateCaptor.capture());
+    StatusOr<CdsUpdate> statusOrUpdate = cdsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isTrue();
+    CdsUpdate cdsUpdate = statusOrUpdate.getValue();
+
+    assertThat(cdsUpdate.clusterName()).isEqualTo(CDS_RESOURCE);
+    assertThat(cdsUpdate.clusterType()).isEqualTo(ClusterType.EDS);
+    assertThat(cdsUpdate.maxConcurrentRequests()).isEqualTo(4294967295L);
+  }
+
+  @Test
+  public void sendToNonexistentServer() throws Exception {
+    // Setup xdsClient to fail on stream creation
+    // The Windows CI takes ~11 seconds to resolve "doesnotexist.invalid.". That seems broken, since
+    // it should take no I/O, but let's limit ourselves to IP literals and hostnames in the hosts
+    // file. Assume localhost doesn't speak HTTP/2 on the finger port
+    XdsClientImpl client = createXdsClient("localhost:79");
+    client.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE, ldsResourceWatcher);
+    verify(ldsResourceWatcher, Mockito.timeout(5000)).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOrUpdate = ldsUpdateCaptor.getValue();
+    assertThat(statusOrUpdate.hasValue()).isFalse();
+    assertThat(statusOrUpdate.getStatus().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(fakeClock.numPendingTasks()).isEqualTo(1); //retry
+    assertThat(fakeClock.getPendingTasks().iterator().next().toString().contains("RpcRetryTask"))
+        .isTrue();
+    client.shutdown();
+  }
+
+  @Test
+  public void validAndInvalidResourceMetricReport() {
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), "A", cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), "A.1", edsResourceWatcher);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), "B", cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), "B.1", edsResourceWatcher);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), "C", cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), "C.1", edsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    assertThat(call).isNotNull();
+
+    // CDS -> {A, B, C}, version 1
+    ImmutableMap<String, Any> resourcesV1 = ImmutableMap.of(
+        "A", Any.pack(mf.buildEdsCluster("A", "A.1", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )),
+        "B", Any.pack(mf.buildEdsCluster("B", "B.1", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )),
+        "C", Any.pack(mf.buildEdsCluster("C", "C.1", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )));
+    call.sendResponse(CDS, resourcesV1.values().asList(), VERSION_1, "0000");
+    // {A, B, C} -> ACK, version 1
+    verifyResourceValidInvalidCount(1, 3, 0, xdsServerInfo.target(), CDS.typeUrl());
+
+    // EDS -> {A.1, B.1, C.1}, version 1
+    List<Message> dropOverloads = ImmutableList.of();
+    List<Message> endpointsV1 = ImmutableList.of(lbEndpointHealthy);
+    ImmutableMap<String, Any> resourcesV11 = ImmutableMap.of(
+        "A.1", Any.pack(mf.buildClusterLoadAssignment("A.1", endpointsV1, dropOverloads)),
+        "B.1", Any.pack(mf.buildClusterLoadAssignment("B.1", endpointsV1, dropOverloads)),
+        "C.1", Any.pack(mf.buildClusterLoadAssignment("C.1", endpointsV1, dropOverloads)));
+    call.sendResponse(EDS, resourcesV11.values().asList(), VERSION_1, "0000");
+    // {A.1, B.1, C.1} -> ACK, version 1
+    verifyResourceValidInvalidCount(1, 3, 0, xdsServerInfo.target(), EDS.typeUrl());
+
+    // CDS -> {A, B}, version 2
+    // Failed to parse endpoint B
+    ImmutableMap<String, Any> resourcesV2 = ImmutableMap.of(
+        "A", Any.pack(mf.buildEdsCluster("A", "A.2", "round_robin", null, null, false, null,
+            "envoy.transport_sockets.tls", null, null
+        )),
+        "B", Any.pack(mf.buildClusterInvalid("B")));
+    call.sendResponse(CDS, resourcesV2.values().asList(), VERSION_2, "0001");
+    // {A} -> ACK, version 2
+    // {B} -> NACK, version 1, rejected version 2, rejected reason: Failed to parse B
+    // {C} -> does not exist
+    verifyResourceValidInvalidCount(1, 1, 1, xdsServerInfo.target(), CDS.typeUrl());
+  }
+
+  @Test
+  public void serverFailureMetricReport() {
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE, ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_RESOURCE,
+        rdsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    // Management server closes the RPC stream before sending any response.
+    call.sendCompleted();
+    verify(ldsResourceWatcher, Mockito.timeout(1000)).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> ldsStatusOr = ldsUpdateCaptor.getValue();
+    assertThat(ldsStatusOr.hasValue()).isFalse();
+    verifyStatusWithNodeId(ldsStatusOr.getStatus(), Code.UNAVAILABLE,
+        "ADS stream closed with OK before receiving a response");
+    verify(rdsResourceWatcher).onResourceChanged(rdsUpdateCaptor.capture());
+    StatusOr<RdsUpdate> rdsStatusOr = rdsUpdateCaptor.getValue();
+    assertThat(rdsStatusOr.hasValue()).isFalse();
+    verifyStatusWithNodeId(rdsStatusOr.getStatus(), Code.UNAVAILABLE,
+        "ADS stream closed with OK before receiving a response");
+    verifyServerFailureCount(1, 1, xdsServerInfo.target());
+  }
+
+  @Test
+  public void serverFailureMetricReport_forRetryAndBackoff() {
+    InOrder inOrder = inOrder(backoffPolicyProvider, backoffPolicy1, backoffPolicy2);
+    InOrder ldsWatcherInOrder = inOrder(ldsResourceWatcher);
+    InOrder rdsWatcherInOrder = inOrder(rdsResourceWatcher);
+    InOrder cdsWatcherInOrder = inOrder(cdsResourceWatcher);
+    InOrder edsWatcherInOrder = inOrder(edsResourceWatcher);
+    when(backoffPolicyProvider.get()).thenReturn(backoffPolicy1, backoffPolicy2, backoffPolicy2);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), LDS_RESOURCE, ldsResourceWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_RESOURCE,
+        rdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), CDS_RESOURCE, cdsResourceWatcher);
+    xdsClient.watchXdsResource(XdsEndpointResource.getInstance(), EDS_RESOURCE, edsResourceWatcher);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+
+    // Management server closes the RPC stream with an error.
+    call.sendError(Status.UNKNOWN.asException());
+    ldsWatcherInOrder.verify(ldsResourceWatcher, timeout(1000)).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNKNOWN));
+    rdsWatcherInOrder.verify(rdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNKNOWN));
+    cdsWatcherInOrder.verify(cdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNKNOWN));
+    edsWatcherInOrder.verify(edsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNKNOWN));
+    verifyServerFailureCount(1, 1, xdsServerInfo.target());
+
+    // Retry after backoff.
+    inOrder.verify(backoffPolicyProvider).get();
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+    ScheduledTask retryTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER));
+    assertThat(retryTask.getDelay(TimeUnit.NANOSECONDS)).isEqualTo(10L);
+    fakeClock.forwardNanos(10L);
+    call = resourceDiscoveryCalls.poll();
+
+    // Management server becomes unreachable.
+    String errorMsg = "my fault";
+    call.sendError(Status.UNAVAILABLE.withDescription(errorMsg).asException());
+    ldsWatcherInOrder.verify(ldsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+    rdsWatcherInOrder.verify(rdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+    cdsWatcherInOrder.verify(cdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+    edsWatcherInOrder.verify(edsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+    verifyServerFailureCount(2, 1, xdsServerInfo.target());
+
+    // Retry after backoff.
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+    retryTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER));
+    assertThat(retryTask.getDelay(TimeUnit.NANOSECONDS)).isEqualTo(100L);
+    fakeClock.forwardNanos(100L);
+    call = resourceDiscoveryCalls.poll();
+
+    List<Any> resources = ImmutableList.of(FAILING_ANY, testListenerRds, FAILING_ANY);
+    call.sendResponse(LDS, resources, "63", "3242");
+    ldsWatcherInOrder.verify(ldsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> statusOr.hasValue()));
+
+    List<Any> routeConfigs = ImmutableList.of(FAILING_ANY, testRouteConfig, FAILING_ANY);
+    call.sendResponse(RDS, routeConfigs, "5", "6764");
+    rdsWatcherInOrder.verify(rdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> statusOr.hasValue()));
+
+    // Stream fails AFTER a response. Error is suppressed and no watcher notification occurs.
+    call.sendError(Status.DEADLINE_EXCEEDED.asException());
+
+    // Failure count does NOT increase because the error was suppressed. It is still 2.
+    verifyServerFailureCount(2, 1, xdsServerInfo.target());
+
+    // Reset backoff sequence and retry after backoff.
+    inOrder.verify(backoffPolicyProvider).get();
+    inOrder.verify(backoffPolicy2).nextBackoffNanos();
+    retryTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER));
+    assertThat(retryTask.getDelay(TimeUnit.NANOSECONDS)).isEqualTo(20L);
+    fakeClock.forwardNanos(20L);
+    call = resourceDiscoveryCalls.poll();
+
+    // Management server becomes unreachable again. This is on a new stream, so error propagates.
+    call.sendError(Status.UNAVAILABLE.asException());
+    ldsWatcherInOrder.verify(ldsResourceWatcher).onAmbientError(
+        argThat(status -> status.getCode() == Code.UNAVAILABLE));
+    rdsWatcherInOrder.verify(rdsResourceWatcher).onAmbientError(
+        argThat(status -> status.getCode() == Code.UNAVAILABLE));
+    cdsWatcherInOrder.verify(cdsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+    edsWatcherInOrder.verify(edsResourceWatcher).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Code.UNAVAILABLE));
+
+    // Server failure count is now 3.
+    verifyServerFailureCount(3, 1, xdsServerInfo.target());
+
+    // Retry after backoff.
+    inOrder.verify(backoffPolicy2).nextBackoffNanos();
+    retryTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(RPC_RETRY_TASK_FILTER));
+    assertThat(retryTask.getDelay(TimeUnit.NANOSECONDS)).isEqualTo(200L);
+    fakeClock.forwardNanos(200L);
+    call = resourceDiscoveryCalls.poll();
+
+    List<Any> clusters = ImmutableList.of(FAILING_ANY, testClusterRoundRobin);
+    call.sendResponse(CDS, clusters, VERSION_1, "0000");
+    call.sendCompleted();
+
+    // Final failure count is still 3 as the stream closed gracefully.
+    verifyServerFailureCount(3, 1, xdsServerInfo.target());
+  }
+
+  private XdsClientImpl createXdsClient(String serverUri) {
+    BootstrapInfo bootstrapInfo = buildBootStrap(serverUri);
+    return new XdsClientImpl(
+        new GrpcXdsTransportFactory(null),
+        bootstrapInfo,
+        fakeClock.getScheduledExecutorService(),
+        backoffPolicyProvider,
+        fakeClock.getStopwatchSupplier(),
+        timeProvider,
+        MessagePrinter.INSTANCE,
+        new TlsContextManagerImpl(bootstrapInfo),
+        xdsClientMetricReporter);
+  }
+
+  private BootstrapInfo buildBootStrap(String serverUri) {
+
+    ServerInfo xdsServerInfo = ServerInfo.create(serverUri, CHANNEL_CREDENTIALS,
+        ignoreResourceDeletion(), true, false, false);
+
+    return Bootstrapper.BootstrapInfo.builder()
+        .servers(Collections.singletonList(xdsServerInfo))
+        .node(NODE)
+        .authorities(ImmutableMap.of(
+            "authority.xds.com",
+            AuthorityInfo.create(
+                "xdstp://authority.xds.com/envoy.config.listener.v3.Listener/%s",
+                ImmutableList.of(Bootstrapper.ServerInfo.create(
+                    SERVER_URI_CUSTOM_AUTHORITY, CHANNEL_CREDENTIALS))),
+            "",
+            AuthorityInfo.create(
+                "xdstp:///envoy.config.listener.v3.Listener/%s",
+                ImmutableList.of(Bootstrapper.ServerInfo.create(
+                    SERVER_URI_EMPTY_AUTHORITY, CHANNEL_CREDENTIALS)))))
+        .certProviders(ImmutableMap.of("cert-instance-name",
+            CertificateProviderInfo.create("file-watcher", ImmutableMap.<String, Object>of())))
+        .build();
+  }
+
+  private <T extends ResourceUpdate> DiscoveryRpcCall startResourceWatcher(
+      XdsResourceType<T> type, String name, ResourceWatcher<T> watcher, Executor executor) {
+    xdsClient.watchXdsResource(type, name, watcher, executor);
+    DiscoveryRpcCall call = resourceDiscoveryCalls.poll();
+    assertThat(call).isNotNull();
+    call.verifyRequest(type, Collections.singletonList(name), "", "", NODE);
+
+    FakeClock.TaskFilter timeoutTaskFilter;
+    switch (type.typeName()) {
+      case "LDS":
+        timeoutTaskFilter = LDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER;
+        break;
+      case "RDS":
+        timeoutTaskFilter = RDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER;
+        break;
+      case "CDS":
+        timeoutTaskFilter = CDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER;
+        break;
+      case "EDS":
+        timeoutTaskFilter = EDS_RESOURCE_FETCH_TIMEOUT_TASK_FILTER;
+        break;
+      default:
+        throw new AssertionError("should never be here");
+    }
+    ScheduledTask timeoutTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(timeoutTaskFilter));
+    assertThat(timeoutTask.getDelay(TimeUnit.SECONDS))
+        .isEqualTo(XdsClientImpl.INITIAL_RESOURCE_FETCH_TIMEOUT_SEC);
+    return call;
+  }
+
+  private <T extends ResourceUpdate> DiscoveryRpcCall startResourceWatcher(
+      XdsResourceType<T> type, String name, ResourceWatcher<T> watcher) {
+    return startResourceWatcher(type, name, watcher, MoreExecutors.directExecutor());
+  }
+
+  protected abstract static class DiscoveryRpcCall {
+
+    protected void verifyRequest(
+        XdsResourceType<?> type, List<String> resources, String versionInfo, String nonce,
+        Node node, VerificationMode verificationMode) {
+      throw new UnsupportedOperationException();
+    }
+
+    protected void verifyRequest(
+        XdsResourceType<?> type, List<String> resources, String versionInfo, String nonce,
+        Node node) {
+      verifyRequest(type, resources, versionInfo, nonce, node, Mockito.timeout(2000));
+    }
+
+    protected void verifyRequest(
+        XdsResourceType<?> type, String resource, String versionInfo, String nonce,
+        Node node, VerificationMode verificationMode) {
+      verifyRequest(type, ImmutableList.of(resource), versionInfo, nonce, node, verificationMode);
+    }
+
+    protected void verifyRequest(
+        XdsResourceType<?> type, String resource, String versionInfo, String nonce, Node node) {
+      verifyRequest(type, ImmutableList.of(resource), versionInfo, nonce, node);
+    }
+
+    protected void verifyRequestNack(
+        XdsResourceType<?> type, List<String> resources, String versionInfo, String nonce,
+        Node node, List<String> errorMessages) {
+      throw new UnsupportedOperationException();
+    }
+
+    protected void verifyRequestNack(
+        XdsResourceType<?> type, String resource, String versionInfo, String nonce, Node node,
+        List<String> errorMessages) {
+      verifyRequestNack(type, ImmutableList.of(resource), versionInfo, nonce, node, errorMessages);
+    }
+
+    protected void verifyNoMoreRequest() {
+      throw new UnsupportedOperationException();
+    }
+
+    protected void sendResponse(
+        XdsResourceType<?> type, List<Any> resources, String versionInfo, String nonce) {
+      throw new UnsupportedOperationException();
+    }
+
+    protected void sendResponse(XdsResourceType<?> type, Any resource, String versionInfo,
+        String nonce) {
+      sendResponse(type, ImmutableList.of(resource), versionInfo, nonce);
+    }
+
+    protected void sendError(Throwable t) {
+      throw new UnsupportedOperationException();
+    }
+
+    protected void sendCompleted() {
+      throw new UnsupportedOperationException();
+    }
+
+    protected boolean isReady() {
+      throw new UnsupportedOperationException();
+    }
+  }
+
+  protected abstract static class LrsRpcCall {
+
+    /**
+     * Verifies a LRS request has been sent with ClusterStats of the given list of clusters.
+     */
+    protected void verifyNextReportClusters(List<String[]> clusters) {
+      throw new UnsupportedOperationException();
+    }
+
+    protected void sendResponse(List<String> clusters, long loadReportIntervalNano) {
+      throw new UnsupportedOperationException();
+    }
+  }
+
+  protected abstract static class MessageFactory {
+
+    /** Throws {@link InvalidProtocolBufferException} on {@link Any#unpack(Class)}. */
+    protected static final Any FAILING_ANY = Any.newBuilder().setTypeUrl("fake").build();
+
+    protected abstract Any buildWrappedResource(Any originalResource);
+
+    protected abstract Any buildWrappedResourceWithName(Any originalResource, String name);
+
+    protected Message buildListenerWithApiListener(String name, Message routeConfiguration) {
+      return buildListenerWithApiListener(
+          name, routeConfiguration, Collections.<Message>emptyList());
+    }
+
+    protected abstract Message buildListenerWithApiListener(
+        String name, Message routeConfiguration, List<? extends Message> httpFilters);
+
+    protected abstract Message buildListenerWithApiListenerForRds(
+        String name, String rdsResourceName);
+
+    protected abstract Message buildListenerWithApiListenerInvalid(String name);
+
+    protected abstract Message buildHttpFilter(
+        String name, @Nullable Any typedConfig, boolean isOptional);
+
+    protected abstract Any buildHttpFaultTypedConfig(
+        @Nullable Long delayNanos, @Nullable Integer delayRate, String upstreamCluster,
+        List<String> downstreamNodes, @Nullable Integer maxActiveFaults, @Nullable Status status,
+        @Nullable Integer httpCode, @Nullable Integer abortRate);
+
+    protected abstract Message buildRouteConfiguration(String name,
+        List<Message> virtualHostList);
+
+    protected abstract Message buildRouteConfigurationInvalid(String name);
+
+    protected abstract List<Message> buildOpaqueVirtualHosts(int num);
+
+    protected abstract Message buildVirtualHost(
+        List<? extends Message> routes, Map<String, Any> typedConfigMap);
+
+    protected abstract List<? extends Message> buildOpaqueRoutes(int num);
+
+    protected abstract Message buildClusterInvalid(String name);
+
+    protected abstract Message buildEdsCluster(String clusterName, @Nullable String edsServiceName,
+        String lbPolicy, @Nullable Message ringHashLbConfig, @Nullable Message leastRequestLbConfig,
+        boolean enableLrs, @Nullable Message upstreamTlsContext, String transportSocketName,
+        @Nullable Message circuitBreakers, @Nullable Message outlierDetection);
+
+    protected abstract Message buildLogicalDnsCluster(String clusterName, String dnsHostAddr,
+        int dnsHostPort, String lbPolicy, @Nullable Message ringHashLbConfig,
+        @Nullable Message leastRequestLbConfig, boolean enableLrs,
+        @Nullable Message upstreamTlsContext, @Nullable Message circuitBreakers);
+
+    protected abstract Message buildAggregateCluster(String clusterName, String lbPolicy,
+        @Nullable Message ringHashLbConfig, @Nullable Message leastRequestLbConfig,
+        List<String> clusters);
+
+    protected abstract Message buildRingHashLbConfig(String hashFunction, long minRingSize,
+        long maxRingSize);
+
+    protected abstract Message buildLeastRequestLbConfig(int choiceCount);
+
+    protected abstract Message buildUpstreamTlsContext(String instanceName, String certName);
+
+    protected abstract Message buildNewUpstreamTlsContext(String instanceName, String certName);
+
+    protected abstract Message buildCircuitBreakers(int highPriorityMaxRequests,
+        int defaultPriorityMaxRequests);
+
+    protected abstract Message buildClusterLoadAssignment(String cluster,
+        List<Message> localityLbEndpoints, List<Message> dropOverloads);
+
+    protected abstract Message buildClusterLoadAssignmentInvalid(String cluster);
+
+    protected abstract Message buildLocalityLbEndpoints(String region, String zone, String subZone,
+        List<Message> lbEndpointList, int loadBalancingWeight, int priority);
+
+    protected Message buildLocalityLbEndpoints(String region, String zone, String subZone,
+        Message lbEndpoint, int loadBalancingWeight, int priority) {
+      return buildLocalityLbEndpoints(region, zone, subZone, ImmutableList.of(lbEndpoint),
+          loadBalancingWeight, priority);
+    }
+
+    protected abstract Message buildLbEndpoint(String address, int port, String healthStatus,
+        int lbWeight, String endpointHostname);
+
+    protected abstract Message buildDropOverload(String category, int dropPerMillion);
+
+    protected abstract Message buildFilterChain(
+        List<String> alpn, Message tlsContext, String transportSocketName,
+        Message... filters);
+
+    protected abstract Message buildListenerWithFilterChain(
+        String name, int portValue, String address, Message... filterChains);
+
+    protected abstract Message buildHttpConnectionManagerFilter(
+        @Nullable String rdsName, @Nullable Message routeConfig, List<Message> httpFilters);
+
+    protected abstract Message buildTerminalFilter();
+  }
+
+  private static class XdsStringResource extends XdsResourceType<StringUpdate> {
+    @Override
+    @SuppressWarnings("unchecked")
+    protected Class<? extends com.google.protobuf.Message> unpackedClassName() {
+      return StringValue.class;
+    }
+
+    @Override
+    public String typeName() {
+      return "EMPTY";
+    }
+
+    @Override
+    public String typeUrl() {
+      return "type.googleapis.com/google.protobuf.StringValue";
+    }
+
+    @Override
+    public boolean shouldRetrieveResourceKeysForArgs() {
+      return false;
+    }
+
+    @Override
+    protected boolean isFullStateOfTheWorld() {
+      return false;
+    }
+
+    @Override
+    @Nullable
+    protected String extractResourceName(Message unpackedResource) {
+      if (!(unpackedResource instanceof StringValue)) {
+        return null;
+      }
+      return ((StringValue) unpackedResource).getValue();
+    }
+
+    @Override
+    protected StringUpdate doParse(Args args, Message unpackedMessage)
+        throws ResourceInvalidException {
+      return new StringUpdate(((StringValue) unpackedMessage).getValue());
+    }
+  }
+
+  private static final class StringUpdate implements ResourceUpdate {
+    @SuppressWarnings("UnusedVariable")
+    public final String value;
+
+    public StringUpdate(String value) {
+      this.value = value;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (!(o instanceof StringUpdate)) {
+        return false;
+      }
+      StringUpdate that = (StringUpdate) o;
+      return Objects.equals(this.value, that.value);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(value);
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/GrpcXdsClientImplV3Test.java b/xds/src/test/java/io/grpc/xds/GrpcXdsClientImplV3Test.java
new file mode 100644
index 00000000000..3966fae7f20
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/GrpcXdsClientImplV3Test.java
@@ -0,0 +1,935 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.Any;
+import com.google.protobuf.Message;
+import com.google.protobuf.UInt32Value;
+import com.google.protobuf.UInt64Value;
+import com.google.protobuf.util.Durations;
+import com.google.rpc.Code;
+import io.envoyproxy.envoy.config.cluster.v3.CircuitBreakers;
+import io.envoyproxy.envoy.config.cluster.v3.CircuitBreakers.Thresholds;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.CustomClusterType;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.DiscoveryType;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.EdsClusterConfig;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.LbPolicy;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.LeastRequestLbConfig;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.RingHashLbConfig;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.RingHashLbConfig.HashFunction;
+import io.envoyproxy.envoy.config.cluster.v3.OutlierDetection;
+import io.envoyproxy.envoy.config.core.v3.Address;
+import io.envoyproxy.envoy.config.core.v3.AggregatedConfigSource;
+import io.envoyproxy.envoy.config.core.v3.ConfigSource;
+import io.envoyproxy.envoy.config.core.v3.HealthStatus;
+import io.envoyproxy.envoy.config.core.v3.Locality;
+import io.envoyproxy.envoy.config.core.v3.Node;
+import io.envoyproxy.envoy.config.core.v3.RoutingPriority;
+import io.envoyproxy.envoy.config.core.v3.SelfConfigSource;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress;
+import io.envoyproxy.envoy.config.core.v3.TrafficDirection;
+import io.envoyproxy.envoy.config.core.v3.TransportSocket;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment.Policy;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment.Policy.DropOverload;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterStats;
+import io.envoyproxy.envoy.config.endpoint.v3.Endpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints;
+import io.envoyproxy.envoy.config.listener.v3.ApiListener;
+import io.envoyproxy.envoy.config.listener.v3.Filter;
+import io.envoyproxy.envoy.config.listener.v3.FilterChain;
+import io.envoyproxy.envoy.config.listener.v3.FilterChainMatch;
+import io.envoyproxy.envoy.config.listener.v3.Listener;
+import io.envoyproxy.envoy.config.route.v3.Route;
+import io.envoyproxy.envoy.config.route.v3.RouteAction;
+import io.envoyproxy.envoy.config.route.v3.RouteConfiguration;
+import io.envoyproxy.envoy.config.route.v3.RouteMatch;
+import io.envoyproxy.envoy.config.route.v3.VirtualHost;
+import io.envoyproxy.envoy.extensions.clusters.aggregate.v3.ClusterConfig;
+import io.envoyproxy.envoy.extensions.filters.common.fault.v3.FaultDelay;
+import io.envoyproxy.envoy.extensions.filters.common.fault.v3.FaultDelay.HeaderDelay;
+import io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort;
+import io.envoyproxy.envoy.extensions.filters.http.fault.v3.FaultAbort.HeaderAbort;
+import io.envoyproxy.envoy.extensions.filters.http.fault.v3.HTTPFault;
+import io.envoyproxy.envoy.extensions.filters.http.router.v3.Router;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.HttpFilter;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.Rds;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateProviderPluginInstance;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext;
+import io.envoyproxy.envoy.service.discovery.v3.AggregatedDiscoveryServiceGrpc.AggregatedDiscoveryServiceImplBase;
+import io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest;
+import io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse;
+import io.envoyproxy.envoy.service.discovery.v3.Resource;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadReportingServiceGrpc.LoadReportingServiceImplBase;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse;
+import io.envoyproxy.envoy.type.matcher.v3.RegexMatcher;
+import io.envoyproxy.envoy.type.v3.FractionalPercent;
+import io.envoyproxy.envoy.type.v3.FractionalPercent.DenominatorType;
+import io.grpc.BindableService;
+import io.grpc.Context;
+import io.grpc.Context.CancellationListener;
+import io.grpc.Status;
+import io.grpc.stub.ServerCallStreamObserver;
+import io.grpc.stub.StreamObserver;
+import io.grpc.xds.client.EnvoyProtoData;
+import io.grpc.xds.client.XdsClientImpl;
+import io.grpc.xds.client.XdsResourceType;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.Nullable;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+import org.mockito.ArgumentMatcher;
+import org.mockito.InOrder;
+import org.mockito.Mockito;
+import org.mockito.verification.VerificationMode;
+
+/**
+ * Tests for {@link XdsClientImpl} with protocol version v3.
+ */
+@RunWith(Parameterized.class)
+public class GrpcXdsClientImplV3Test extends GrpcXdsClientImplTestBase {
+
+  /** Parameterized test cases. */
+  @Parameters(name = "ignoreResourceDeletion={0}")
+  public static Iterable<? extends Boolean> data() {
+    return ImmutableList.of(false, true);
+  }
+
+  @Parameter
+  public boolean ignoreResourceDeletion;
+
+  @Override
+  protected BindableService createAdsService() {
+    return new AggregatedDiscoveryServiceImplBase() {
+      @Override
+      public StreamObserver<DiscoveryRequest> streamAggregatedResources(
+          final StreamObserver<DiscoveryResponse> responseObserver) {
+        assertThat(adsEnded.get()).isTrue();  // ensure previous call was ended
+        adsEnded.set(false);
+        @SuppressWarnings("unchecked")
+        StreamObserver<DiscoveryRequest> requestObserver =
+            mock(StreamObserver.class, delegatesTo(new MockStreamObserver()));
+        DiscoveryRpcCall call = new DiscoveryRpcCallV3(requestObserver, responseObserver);
+        resourceDiscoveryCalls.offer(call);
+        Context.current().addListener(
+            new CancellationListener() {
+              @Override
+              public void cancelled(Context context) {
+                adsEnded.set(true);
+              }
+            }, MoreExecutors.directExecutor());
+        return requestObserver;
+      }
+    };
+  }
+
+  @Override
+  protected BindableService createLrsService() {
+    return new LoadReportingServiceImplBase() {
+      @Override
+      public StreamObserver<LoadStatsRequest> streamLoadStats(
+          StreamObserver<LoadStatsResponse> responseObserver) {
+        assertThat(lrsEnded.get()).isTrue();
+        lrsEnded.set(false);
+        @SuppressWarnings("unchecked")
+        StreamObserver<LoadStatsRequest> requestObserver = mock(StreamObserver.class);
+        LrsRpcCall call = new LrsRpcCallV3(requestObserver, responseObserver);
+        Context.current().addListener(
+            new CancellationListener() {
+              @Override
+              public void cancelled(Context context) {
+                lrsEnded.set(true);
+              }
+            }, MoreExecutors.directExecutor());
+        loadReportCalls.offer(call);
+        return requestObserver;
+      }
+    };
+  }
+
+  @Override
+  protected MessageFactory createMessageFactory() {
+    return new MessageFactoryV3();
+  }
+
+  @Override
+  protected boolean ignoreResourceDeletion() {
+    return ignoreResourceDeletion;
+  }
+
+  private static class DiscoveryRpcCallV3 extends DiscoveryRpcCall {
+    StreamObserver<DiscoveryRequest> requestObserver;
+    StreamObserver<DiscoveryResponse> responseObserver;
+
+    private DiscoveryRpcCallV3(StreamObserver<DiscoveryRequest> requestObserver,
+        StreamObserver<DiscoveryResponse> responseObserver) {
+      this.requestObserver = requestObserver;
+      this.responseObserver = responseObserver;
+    }
+
+    @Override
+    protected void verifyRequest(
+        XdsResourceType<?> type, List<String> resources, String versionInfo, String nonce,
+        EnvoyProtoData.Node node, VerificationMode verificationMode) {
+      verify(requestObserver, verificationMode).onNext(argThat(new DiscoveryRequestMatcher(
+          node.toEnvoyProtoNode(), versionInfo, resources, type.typeUrl(), nonce, null, null)));
+    }
+
+    @Override
+    protected void verifyRequestNack(
+        XdsResourceType<?> type, List<String> resources, String versionInfo, String nonce,
+        EnvoyProtoData.Node node, List<String> errorMessages) {
+      verify(requestObserver, Mockito.timeout(2000)).onNext(argThat(new DiscoveryRequestMatcher(
+          node.toEnvoyProtoNode(), versionInfo, resources, type.typeUrl(), nonce,
+          Code.INVALID_ARGUMENT_VALUE, errorMessages)));
+    }
+
+    @Override
+    protected void verifyNoMoreRequest() {
+      verifyNoMoreInteractions(requestObserver);
+    }
+
+    @Override
+    protected void sendResponse(
+        XdsResourceType<?> type, List<Any> resources, String versionInfo, String nonce) {
+      DiscoveryResponse response =
+          DiscoveryResponse.newBuilder()
+              .setVersionInfo(versionInfo)
+              .addAllResources(resources)
+              .setTypeUrl(type.typeUrl())
+              .setNonce(nonce)
+              .build();
+      responseObserver.onNext(response);
+    }
+
+    @Override
+    protected void sendError(Throwable t) {
+      responseObserver.onError(t);
+    }
+
+    @Override
+    protected void sendCompleted() {
+      responseObserver.onCompleted();
+    }
+
+    @Override
+    protected boolean isReady() {
+      return ((ServerCallStreamObserver)responseObserver).isReady();
+    }
+  }
+
+  private static class LrsRpcCallV3 extends LrsRpcCall {
+    private final StreamObserver<LoadStatsRequest> requestObserver;
+    private final StreamObserver<LoadStatsResponse> responseObserver;
+    private final InOrder inOrder;
+
+    private LrsRpcCallV3(StreamObserver<LoadStatsRequest> requestObserver,
+        StreamObserver<LoadStatsResponse> responseObserver) {
+      this.requestObserver = requestObserver;
+      this.responseObserver = responseObserver;
+      inOrder = inOrder(requestObserver);
+    }
+
+    @Override
+    protected void verifyNextReportClusters(List<String[]> clusters) {
+      inOrder.verify(requestObserver).onNext(argThat(new LrsRequestMatcher(clusters)));
+    }
+
+    @Override
+    protected void sendResponse(List<String> clusters, long loadReportIntervalNano) {
+      LoadStatsResponse response =
+          LoadStatsResponse.newBuilder()
+              .addAllClusters(clusters)
+              .setLoadReportingInterval(Durations.fromNanos(loadReportIntervalNano))
+              .build();
+      responseObserver.onNext(response);
+    }
+  }
+
+  private static class MessageFactoryV3 extends MessageFactory {
+
+    @Override
+    protected Any buildWrappedResource(Any originalResource) {
+      return Any.pack(Resource.newBuilder()
+          .setResource(originalResource)
+          .build());
+    }
+
+    @Override
+    protected  Any buildWrappedResourceWithName(Any originalResource, String name) {
+      return Any.pack(Resource.newBuilder()
+      .setResource(originalResource)
+      .setName(name)
+      .build());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected Message buildListenerWithApiListener(
+        String name, Message routeConfiguration, List<? extends Message> httpFilters) {
+      return Listener.newBuilder()
+          .setName(name)
+          .setAddress(Address.getDefaultInstance())
+          .addFilterChains(FilterChain.getDefaultInstance())
+          .setApiListener(
+              ApiListener.newBuilder().setApiListener(Any.pack(
+                  HttpConnectionManager.newBuilder()
+                      .setRouteConfig((RouteConfiguration) routeConfiguration)
+                      .addAllHttpFilters((List<HttpFilter>) httpFilters)
+                      .build())))
+          .build();
+    }
+
+    @Override
+    protected Message buildListenerWithApiListener(String name, Message routeConfiguration) {
+      return buildListenerWithApiListener(name, routeConfiguration, Arrays.asList(
+              HttpFilter.newBuilder()
+                      .setName("terminal")
+                      .setTypedConfig(Any.pack(Router.newBuilder().build())).build()
+      ));
+    }
+
+    @Override
+    protected Message buildListenerWithApiListenerForRds(String name, String rdsResourceName) {
+      return Listener.newBuilder()
+          .setName(name)
+          .setAddress(Address.getDefaultInstance())
+          .addFilterChains(FilterChain.getDefaultInstance())
+          .setApiListener(
+              ApiListener.newBuilder().setApiListener(Any.pack(
+                  HttpConnectionManager.newBuilder()
+                      .setRds(
+                          Rds.newBuilder()
+                              .setRouteConfigName(rdsResourceName)
+                              .setConfigSource(
+                                  ConfigSource.newBuilder()
+                                      .setAds(AggregatedConfigSource.getDefaultInstance())))
+                      .addHttpFilters(
+                          HttpFilter.newBuilder()
+                               .setName("terminal")
+                               .setTypedConfig(Any.pack(Router.newBuilder().build())))
+                      .build())))
+          .build();
+    }
+
+    @Override
+    protected Message buildListenerWithApiListenerInvalid(String name) {
+      return Listener.newBuilder()
+          .setName(name)
+          .setAddress(Address.getDefaultInstance())
+          .setApiListener(ApiListener.newBuilder().setApiListener(FAILING_ANY))
+          .build();
+    }
+
+    @Override
+    protected Message buildHttpFilter(String name, @Nullable Any typedConfig, boolean isOptional) {
+      HttpFilter.Builder builder = HttpFilter.newBuilder().setName(name).setIsOptional(isOptional);
+      if (typedConfig != null) {
+        builder.setTypedConfig(typedConfig);
+      }
+      return builder.build();
+    }
+
+    @Override
+    protected Any buildHttpFaultTypedConfig(
+        @Nullable Long delayNanos, @Nullable Integer delayRate, String upstreamCluster,
+        List<String> downstreamNodes, @Nullable Integer maxActiveFaults, @Nullable Status status,
+        @Nullable Integer httpCode, @Nullable Integer abortRate) {
+      HTTPFault.Builder builder = HTTPFault.newBuilder();
+      if (delayRate != null) {
+        FaultDelay.Builder delayBuilder = FaultDelay.newBuilder();
+        delayBuilder.setPercentage(
+            FractionalPercent.newBuilder()
+                .setNumerator(delayRate).setDenominator(DenominatorType.MILLION));
+        if (delayNanos != null) {
+          delayBuilder.setFixedDelay(Durations.fromNanos(delayNanos));
+        } else {
+          delayBuilder.setHeaderDelay(HeaderDelay.newBuilder());
+        }
+        builder.setDelay(delayBuilder);
+      }
+      if (abortRate != null) {
+        FaultAbort.Builder abortBuilder = FaultAbort.newBuilder();
+        abortBuilder.setPercentage(
+            FractionalPercent.newBuilder()
+                .setNumerator(abortRate).setDenominator(DenominatorType.MILLION));
+        if (status != null) {
+          abortBuilder.setGrpcStatus(status.getCode().value());
+        } else if (httpCode != null) {
+          abortBuilder.setHttpStatus(httpCode);
+        } else {
+          abortBuilder.setHeaderAbort(HeaderAbort.newBuilder());
+        }
+        builder.setAbort(abortBuilder);
+      }
+      builder.setUpstreamCluster(upstreamCluster);
+      builder.addAllDownstreamNodes(downstreamNodes);
+      if (maxActiveFaults != null) {
+        builder.setMaxActiveFaults(UInt32Value.of(maxActiveFaults));
+      }
+      return Any.pack(builder.build());
+    }
+
+    @Override
+    protected Message buildRouteConfiguration(String name, List<Message> virtualHostList) {
+      RouteConfiguration.Builder builder = RouteConfiguration.newBuilder();
+      builder.setName(name);
+      for (Message virtualHost : virtualHostList) {
+        builder.addVirtualHosts((VirtualHost) virtualHost);
+      }
+      return builder.build();
+    }
+
+    @Override
+    protected Message buildRouteConfigurationInvalid(String name) {
+      // Invalid Path matcher: Pattern.compile() will throw PatternSyntaxException
+      // when attempting to process SAFE_REGEX RouteMatch malformed safe regex pattern.
+      // I wish there was a simpler way.
+      return RouteConfiguration.newBuilder()
+          .setName(name)
+          .addVirtualHosts(
+              VirtualHost.newBuilder()
+                  .setName("do not care")
+                  .addDomains("do not care")
+                  .addRoutes(
+                      Route.newBuilder()
+                          .setRoute(RouteAction.newBuilder().setCluster("do not care"))
+                          .setMatch(RouteMatch.newBuilder()
+                              .setSafeRegex(RegexMatcher.newBuilder().setRegex("[z-a]")))))
+          .build();
+    }
+
+    @Override
+    protected List<Message> buildOpaqueVirtualHosts(int num) {
+      List<Message> virtualHosts = new ArrayList<>(num);
+      for (int i = 0; i < num; i++) {
+        VirtualHost virtualHost =
+            VirtualHost.newBuilder()
+                .setName(num + ": do not care")
+                .addDomains("do not care")
+                .addRoutes(
+                    Route.newBuilder()
+                        .setRoute(RouteAction.newBuilder().setCluster("do not care"))
+                        .setMatch(RouteMatch.newBuilder().setPrefix("do not care")))
+                .build();
+        virtualHosts.add(virtualHost);
+      }
+      return virtualHosts;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    protected Message buildVirtualHost(
+        List<? extends Message> routes, Map<String, Any> typedConfigMap) {
+      return VirtualHost.newBuilder()
+          .setName("do not care")
+          .addDomains("do not care")
+          .addAllRoutes((List<Route>) routes)
+          .putAllTypedPerFilterConfig(typedConfigMap)
+          .build();
+    }
+
+    @Override
+    protected List<? extends Message> buildOpaqueRoutes(int num) {
+      List<Route> routes = new ArrayList<>(num);
+      for (int i = 0; i < num; i++) {
+        Route route =
+            Route.newBuilder()
+                .setRoute(RouteAction.newBuilder().setCluster("do not care"))
+                .setMatch(RouteMatch.newBuilder().setPrefix("do not care"))
+                .build();
+        routes.add(route);
+      }
+      return routes;
+    }
+
+    @Override
+    protected Message buildClusterInvalid(String name) {
+      // Unspecified cluster discovery type
+      return Cluster.newBuilder().setName(name).build();
+    }
+
+    @Override
+    protected Message buildEdsCluster(String clusterName, @Nullable String edsServiceName,
+        String lbPolicy, @Nullable Message ringHashLbConfig,
+        @Nullable Message leastRequestLbConfig, boolean enableLrs,
+        @Nullable Message upstreamTlsContext, String transportSocketName,
+        @Nullable Message circuitBreakers, @Nullable Message outlierDetection) {
+      Cluster.Builder builder = initClusterBuilder(
+          clusterName, lbPolicy, ringHashLbConfig, leastRequestLbConfig,
+          enableLrs, upstreamTlsContext, transportSocketName, circuitBreakers, outlierDetection);
+      builder.setType(DiscoveryType.EDS);
+      EdsClusterConfig.Builder edsClusterConfigBuilder = EdsClusterConfig.newBuilder();
+      edsClusterConfigBuilder.setEdsConfig(
+          ConfigSource.newBuilder().setAds(AggregatedConfigSource.getDefaultInstance()));  // ADS
+      if (edsServiceName != null) {
+        edsClusterConfigBuilder.setServiceName(edsServiceName);
+      }
+      builder.setEdsClusterConfig(edsClusterConfigBuilder);
+      return builder.build();
+    }
+
+    @Override
+    protected Message buildLogicalDnsCluster(String clusterName, String dnsHostAddr,
+        int dnsHostPort, String lbPolicy, @Nullable Message ringHashLbConfig,
+        @Nullable Message leastRequestLbConfig, boolean enableLrs,
+        @Nullable Message upstreamTlsContext, @Nullable Message circuitBreakers) {
+      Cluster.Builder builder = initClusterBuilder(
+          clusterName, lbPolicy, ringHashLbConfig, leastRequestLbConfig,
+          enableLrs, upstreamTlsContext, "envoy.transport_sockets.tls", circuitBreakers, null);
+      builder.setType(DiscoveryType.LOGICAL_DNS);
+      builder.setLoadAssignment(
+          ClusterLoadAssignment.newBuilder().addEndpoints(
+              LocalityLbEndpoints.newBuilder().addLbEndpoints(
+                  LbEndpoint.newBuilder().setEndpoint(
+                      Endpoint.newBuilder().setAddress(
+                          Address.newBuilder().setSocketAddress(
+                              SocketAddress.newBuilder()
+                                  .setAddress(dnsHostAddr).setPortValue(dnsHostPort)))))).build());
+      return builder.build();
+    }
+
+    @Override
+    protected Message buildAggregateCluster(String clusterName, String lbPolicy,
+        @Nullable Message ringHashLbConfig, @Nullable Message leastRequestLbConfig,
+        List<String> clusters) {
+      ClusterConfig clusterConfig = ClusterConfig.newBuilder().addAllClusters(clusters).build();
+      CustomClusterType type =
+          CustomClusterType.newBuilder()
+              .setName(XdsClusterResource.AGGREGATE_CLUSTER_TYPE_NAME)
+              .setTypedConfig(Any.pack(clusterConfig))
+              .build();
+      Cluster.Builder builder = Cluster.newBuilder().setName(clusterName).setClusterType(type);
+      if (lbPolicy.equals("round_robin")) {
+        builder.setLbPolicy(LbPolicy.ROUND_ROBIN);
+      } else if (lbPolicy.equals("ring_hash_experimental")) {
+        builder.setLbPolicy(LbPolicy.RING_HASH);
+        builder.setRingHashLbConfig((RingHashLbConfig) ringHashLbConfig);
+      } else if (lbPolicy.equals("least_request_experimental")) {
+        builder.setLbPolicy(LbPolicy.LEAST_REQUEST);
+        builder.setLeastRequestLbConfig((LeastRequestLbConfig) leastRequestLbConfig);
+      } else {
+        throw new AssertionError("Invalid LB policy");
+      }
+      return builder.build();
+    }
+
+    private Cluster.Builder initClusterBuilder(String clusterName, String lbPolicy,
+        @Nullable Message ringHashLbConfig, @Nullable Message leastRequestLbConfig,
+        boolean enableLrs, @Nullable Message upstreamTlsContext, String transportSocketName,
+        @Nullable Message circuitBreakers, @Nullable Message outlierDetection) {
+      Cluster.Builder builder = Cluster.newBuilder();
+      builder.setName(clusterName);
+      if (lbPolicy.equals("round_robin")) {
+        builder.setLbPolicy(LbPolicy.ROUND_ROBIN);
+      } else if (lbPolicy.equals("ring_hash_experimental")) {
+        builder.setLbPolicy(LbPolicy.RING_HASH);
+        builder.setRingHashLbConfig((RingHashLbConfig) ringHashLbConfig);
+      } else if (lbPolicy.equals("least_request_experimental")) {
+        builder.setLbPolicy(LbPolicy.LEAST_REQUEST);
+        builder.setLeastRequestLbConfig((LeastRequestLbConfig) leastRequestLbConfig);
+      } else {
+        throw new AssertionError("Invalid LB policy");
+      }
+      if (enableLrs) {
+        builder.setLrsServer(
+            ConfigSource.newBuilder()
+                .setSelf(SelfConfigSource.getDefaultInstance()));
+      }
+      if (upstreamTlsContext != null) {
+        builder.setTransportSocket(
+            TransportSocket.newBuilder()
+                .setName(transportSocketName)
+                .setTypedConfig(Any.pack(upstreamTlsContext)));
+      }
+      if (circuitBreakers != null) {
+        builder.setCircuitBreakers((CircuitBreakers) circuitBreakers);
+      }
+      if (outlierDetection != null) {
+        builder.setOutlierDetection((OutlierDetection) outlierDetection);
+      }
+      return builder;
+    }
+
+    @Override
+    protected Message buildRingHashLbConfig(String hashFunction, long minRingSize,
+        long maxRingSize) {
+      RingHashLbConfig.Builder builder = RingHashLbConfig.newBuilder();
+      if (hashFunction.equals("xx_hash")) {
+        builder.setHashFunction(HashFunction.XX_HASH);
+      } else if (hashFunction.equals("murmur_hash_2")) {
+        builder.setHashFunction(HashFunction.MURMUR_HASH_2);
+      } else {
+        throw new AssertionError("Invalid hash function");
+      }
+      builder.setMinimumRingSize(UInt64Value.newBuilder().setValue(minRingSize).build());
+      builder.setMaximumRingSize(UInt64Value.newBuilder().setValue(maxRingSize).build());
+      return builder.build();
+    }
+
+    @Override
+    protected Message buildLeastRequestLbConfig(int choiceCount) {
+      LeastRequestLbConfig.Builder builder = LeastRequestLbConfig.newBuilder();
+      builder.setChoiceCount(UInt32Value.newBuilder().setValue(choiceCount));
+      return builder.build();
+    }
+
+    @Override
+    protected Message buildUpstreamTlsContext(String instanceName, String certName) {
+      CommonTlsContext.Builder commonTlsContextBuilder = CommonTlsContext.newBuilder();
+      if (instanceName != null && certName != null) {
+        CommonTlsContext.CombinedCertificateValidationContext combined =
+            CommonTlsContext.CombinedCertificateValidationContext.newBuilder()
+                .setDefaultValidationContext(CertificateValidationContext.newBuilder()
+                  .setCaCertificateProviderInstance(CertificateProviderPluginInstance.newBuilder()
+                    .setInstanceName(instanceName)
+                    .setCertificateName(certName)))
+                .build();
+        commonTlsContextBuilder.setCombinedValidationContext(combined);
+      }
+      return UpstreamTlsContext.newBuilder()
+          .setCommonTlsContext(commonTlsContextBuilder)
+          .build();
+    }
+
+    @Override
+    protected Message buildNewUpstreamTlsContext(String instanceName, String certName) {
+      CommonTlsContext.Builder commonTlsContextBuilder = CommonTlsContext.newBuilder();
+      if (instanceName != null && certName != null) {
+        commonTlsContextBuilder.setValidationContext(CertificateValidationContext.newBuilder()
+            .setCaCertificateProviderInstance(
+                CertificateProviderPluginInstance.newBuilder().setInstanceName(instanceName)
+                    .setCertificateName(certName).build()));
+      }
+      return UpstreamTlsContext.newBuilder()
+          .setCommonTlsContext(commonTlsContextBuilder)
+          .build();
+    }
+
+    @Override
+    protected Message buildCircuitBreakers(int highPriorityMaxRequests,
+        int defaultPriorityMaxRequests) {
+      return CircuitBreakers.newBuilder()
+          .addThresholds(
+              Thresholds.newBuilder()
+                  .setPriority(RoutingPriority.HIGH)
+                  .setMaxRequests(UInt32Value.newBuilder().setValue(highPriorityMaxRequests)))
+          .addThresholds(
+              Thresholds.newBuilder()
+                  .setPriority(RoutingPriority.DEFAULT)
+                  .setMaxRequests(UInt32Value.newBuilder().setValue(defaultPriorityMaxRequests)))
+          .build();
+    }
+
+    @Override
+    protected Message buildClusterLoadAssignment(String cluster,
+        List<Message> localityLbEndpointsList, List<Message> dropOverloadList) {
+      ClusterLoadAssignment.Builder builder = ClusterLoadAssignment.newBuilder();
+      builder.setClusterName(cluster);
+      for (Message localityLbEndpoints : localityLbEndpointsList) {
+        builder.addEndpoints((LocalityLbEndpoints) localityLbEndpoints);
+      }
+      Policy.Builder policyBuilder = Policy.newBuilder();
+      for (Message dropOverload : dropOverloadList) {
+        policyBuilder.addDropOverloads((DropOverload) dropOverload);
+      }
+      builder.setPolicy(policyBuilder);
+      return builder.build();
+    }
+
+    @Override
+    protected Message buildClusterLoadAssignmentInvalid(String cluster) {
+      // Negative priority LocalityLbEndpoint.
+      return ClusterLoadAssignment.newBuilder()
+          .setClusterName(cluster)
+          .addEndpoints(LocalityLbEndpoints.newBuilder()
+              .setPriority(-1)
+              .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(1)))
+          .build();
+    }
+
+    @Override
+    protected Message buildLocalityLbEndpoints(String region, String zone, String subZone,
+        List<Message> lbEndpointList, int loadBalancingWeight, int priority) {
+      LocalityLbEndpoints.Builder builder = LocalityLbEndpoints.newBuilder();
+      builder.setLocality(
+          Locality.newBuilder().setRegion(region).setZone(zone).setSubZone(subZone));
+      for (Message lbEndpoint : lbEndpointList) {
+        builder.addLbEndpoints((LbEndpoint) lbEndpoint);
+      }
+      builder.setLoadBalancingWeight(UInt32Value.of(loadBalancingWeight));
+      builder.setPriority(priority);
+      return builder.build();
+    }
+
+    @Override
+    protected Message buildLbEndpoint(String address, int port, String healthStatus,
+        int lbWeight, String endpointHostname) {
+      HealthStatus status;
+      switch (healthStatus) {
+        case "unknown":
+          status = HealthStatus.UNKNOWN;
+          break;
+        case "healthy":
+          status = HealthStatus.HEALTHY;
+          break;
+        case "unhealthy":
+          status = HealthStatus.UNHEALTHY;
+          break;
+        case "draining":
+          status = HealthStatus.DRAINING;
+          break;
+        case "timeout":
+          status = HealthStatus.TIMEOUT;
+          break;
+        case "degraded":
+          status = HealthStatus.DEGRADED;
+          break;
+        default:
+          status = HealthStatus.UNRECOGNIZED;
+      }
+      return LbEndpoint.newBuilder()
+          .setEndpoint(
+              Endpoint.newBuilder().setAddress(
+                  Address.newBuilder().setSocketAddress(
+                      SocketAddress.newBuilder().setAddress(address).setPortValue(port)))
+                  .setHostname(endpointHostname))
+          .setHealthStatus(status)
+          .setLoadBalancingWeight(UInt32Value.of(lbWeight))
+          .build();
+    }
+
+    @Override
+    protected Message buildDropOverload(String category, int dropPerMillion) {
+      return DropOverload.newBuilder()
+          .setCategory(category)
+          .setDropPercentage(
+              FractionalPercent.newBuilder()
+                  .setNumerator(dropPerMillion)
+                  .setDenominator(DenominatorType.MILLION))
+          .build();
+    }
+
+    @Override
+    protected FilterChain buildFilterChain(
+        List<String> alpn, Message tlsContext, String transportSocketName,
+        Message... filters) {
+      FilterChainMatch filterChainMatch =
+          FilterChainMatch.newBuilder().addAllApplicationProtocols(alpn).build();
+      Filter[] filterArray = new Filter[filters.length];
+      for (int i = 0; i < filters.length; i++) {
+        filterArray[i] = (Filter) filters[i];
+      }
+      return FilterChain.newBuilder()
+          .setFilterChainMatch(filterChainMatch)
+          .setTransportSocket(
+              tlsContext == null
+                  ? TransportSocket.getDefaultInstance()
+                  : TransportSocket.newBuilder()
+                      .setName(transportSocketName)
+                      .setTypedConfig(Any.pack(tlsContext))
+                      .build())
+          .addAllFilters(Arrays.asList(filterArray))
+          .build();
+    }
+
+    @Override
+    protected Listener buildListenerWithFilterChain(
+        String name, int portValue, String address, Message... filterChains) {
+      io.envoyproxy.envoy.config.core.v3.Address listenerAddress =
+          io.envoyproxy.envoy.config.core.v3.Address.newBuilder()
+              .setSocketAddress(
+                  SocketAddress.newBuilder().setPortValue(portValue).setAddress(address))
+              .build();
+      FilterChain[] filterChainsArray = new FilterChain[filterChains.length];
+      for (int i = 0; i < filterChains.length; i++) {
+        filterChainsArray[i] = (FilterChain) filterChains[i];
+      }
+      return Listener.newBuilder()
+          .setName(name)
+          .setAddress(listenerAddress)
+          .addAllFilterChains(Arrays.asList(filterChainsArray))
+          .setTrafficDirection(TrafficDirection.INBOUND)
+          .build();
+    }
+
+    @Override
+    protected Message buildHttpConnectionManagerFilter(
+        @Nullable String rdsName, @Nullable Message routeConfig, List<Message> httpFilters) {
+      HttpConnectionManager.Builder hcmBuilder = HttpConnectionManager.newBuilder();
+      if (rdsName != null) {
+        hcmBuilder.setRds(
+            Rds.newBuilder()
+                .setRouteConfigName(rdsName)
+                .setConfigSource(
+                    ConfigSource.newBuilder()
+                        .setAds(AggregatedConfigSource.getDefaultInstance())));
+      }
+      if (routeConfig != null) {
+        hcmBuilder.setRouteConfig((RouteConfiguration) routeConfig);
+      }
+      for (Message httpFilter : httpFilters) {
+        hcmBuilder.addHttpFilters((HttpFilter) httpFilter);
+      }
+      return Filter.newBuilder()
+          .setName("envoy.http_connection_manager")
+          .setTypedConfig(
+              Any.pack(hcmBuilder.build(), "type.googleapis.com"))
+          .build();
+    }
+
+    @Override
+    protected Message buildTerminalFilter() {
+      return HttpFilter.newBuilder()
+          .setName("terminal")
+          .setTypedConfig(Any.pack(Router.newBuilder().build())).build();
+    }
+  }
+
+  /**
+   * Matches a {@link DiscoveryRequest} with the same node metadata, versionInfo, typeUrl,
+   * response nonce and collection of resource names regardless of order.
+   */
+  private static class DiscoveryRequestMatcher implements ArgumentMatcher<DiscoveryRequest> {
+    private final Node node;
+    private final String versionInfo;
+    private final String typeUrl;
+    private final Set<String> resources;
+    private final String responseNonce;
+    @Nullable private final Integer errorCode;
+    private final List<String> errorMessages;
+
+    private DiscoveryRequestMatcher(
+        Node node, String versionInfo, List<String> resources,
+        String typeUrl, String responseNonce, @Nullable Integer errorCode,
+        @Nullable List<String> errorMessages) {
+      this.node = node;
+      this.versionInfo = versionInfo;
+      this.resources = new HashSet<>(resources);
+      this.typeUrl = typeUrl;
+      this.responseNonce = responseNonce;
+      this.errorCode = errorCode;
+      this.errorMessages = errorMessages != null ? errorMessages : ImmutableList.<String>of();
+    }
+
+    @Override
+    public boolean matches(DiscoveryRequest argument) {
+      if (!typeUrl.equals(argument.getTypeUrl())) {
+        return false;
+      }
+      if (!versionInfo.equals(argument.getVersionInfo())) {
+        return false;
+      }
+      if (!responseNonce.equals(argument.getResponseNonce())) {
+        return false;
+      }
+      if (!resources.equals(new HashSet<>(argument.getResourceNamesList()))) {
+        return false;
+      }
+      if (errorCode == null && argument.hasErrorDetail()) {
+        return false;
+      }
+      if (errorCode != null
+          && !matchErrorDetail(argument.getErrorDetail(), errorCode, errorMessages)) {
+        return false;
+      }
+      return node.equals(argument.getNode());
+    }
+
+    @Override
+    public String toString() {
+      return "DiscoveryRequestMatcher{"
+          + "node=" + node
+          + ", versionInfo='" + versionInfo + '\''
+          + ", typeUrl='" + typeUrl + '\''
+          + ", resources=" + resources
+          + ", responseNonce='" + responseNonce + '\''
+          + ", errorCode=" + errorCode
+          + ", errorMessages=" + errorMessages
+          + '}';
+    }
+  }
+
+  /**
+   * Matches a {@link LoadStatsRequest} containing a collection of {@link ClusterStats} with
+   * the same list of clusterName:clusterServiceName pair.
+   */
+  private static class LrsRequestMatcher implements ArgumentMatcher<LoadStatsRequest> {
+    private final List<String> expected;
+
+    private LrsRequestMatcher(List<String[]> clusterNames) {
+      expected = new ArrayList<>();
+      for (String[] pair : clusterNames) {
+        expected.add(pair[0] + ":" + (pair[1] == null ? "" : pair[1]));
+      }
+      Collections.sort(expected);
+    }
+
+    @Override
+    public boolean matches(LoadStatsRequest argument) {
+      List<String> actual = new ArrayList<>();
+      for (ClusterStats clusterStats : argument.getClusterStatsList()) {
+        actual.add(clusterStats.getClusterName() + ":" + clusterStats.getClusterServiceName());
+      }
+      Collections.sort(actual);
+      return actual.equals(expected);
+    }
+  }
+
+  private static class MockStreamObserver implements StreamObserver<DiscoveryRequest> {
+    private final List<DiscoveryRequest> requests = new ArrayList<>();
+
+    @Override
+    public void onNext(DiscoveryRequest value) {
+      requests.add(value);
+    }
+
+    @Override
+    public void onError(Throwable t) {
+      // Ignore
+    }
+
+    @Override
+    public void onCompleted() {
+      // Ignore
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/GrpcXdsTransportFactoryTest.java b/xds/src/test/java/io/grpc/xds/GrpcXdsTransportFactoryTest.java
new file mode 100644
index 00000000000..66e0d4b3198
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/GrpcXdsTransportFactoryTest.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2024 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.util.concurrent.SettableFuture;
+import io.envoyproxy.envoy.service.discovery.v3.AggregatedDiscoveryServiceGrpc;
+import io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest;
+import io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse;
+import io.grpc.BindableService;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.MethodDescriptor;
+import io.grpc.Server;
+import io.grpc.Status;
+import io.grpc.stub.StreamObserver;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.XdsTransportFactory;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class GrpcXdsTransportFactoryTest {
+
+  private Server server;
+
+  @Before
+  public void setup() throws Exception {
+    server = Grpc.newServerBuilderForPort(0, InsecureServerCredentials.create())
+        .addService(echoAdsService())
+        .build()
+        .start();
+  }
+
+  @After
+  public void tearDown() {
+    server.shutdown();
+  }
+
+  private BindableService echoAdsService() {
+    return new AggregatedDiscoveryServiceGrpc.AggregatedDiscoveryServiceImplBase() {
+      @Override
+      public StreamObserver<DiscoveryRequest> streamAggregatedResources(
+          final StreamObserver<DiscoveryResponse> responseObserver) {
+        StreamObserver<DiscoveryRequest> requestObserver = new StreamObserver<DiscoveryRequest>() {
+          @Override
+          public void onNext(DiscoveryRequest value) {
+            responseObserver.onNext(DiscoveryResponse.newBuilder()
+                .setVersionInfo(value.getVersionInfo())
+                .setNonce(value.getResponseNonce())
+                .build());
+          }
+
+          @Override
+          public void onError(Throwable t) {
+            responseObserver.onError(t);
+          }
+
+          @Override
+          public void onCompleted() {
+            responseObserver.onCompleted();
+          }
+        };
+
+        return requestObserver;
+      }
+    };
+  }
+
+  @Test
+  public void callApis() throws Exception {
+    XdsTransportFactory.XdsTransport xdsTransport =
+        new GrpcXdsTransportFactory(null)
+            .create(
+                Bootstrapper.ServerInfo.create(
+                    "localhost:" + server.getPort(), InsecureChannelCredentials.create()));
+    MethodDescriptor<DiscoveryRequest, DiscoveryResponse> methodDescriptor =
+        AggregatedDiscoveryServiceGrpc.getStreamAggregatedResourcesMethod();
+    XdsTransportFactory.StreamingCall<DiscoveryRequest, DiscoveryResponse> streamingCall =
+        xdsTransport.createStreamingCall(methodDescriptor.getFullMethodName(),
+        methodDescriptor.getRequestMarshaller(), methodDescriptor.getResponseMarshaller());
+    FakeEventHandler fakeEventHandler = new FakeEventHandler();
+    streamingCall.start(fakeEventHandler);
+    streamingCall.sendMessage(
+        DiscoveryRequest.newBuilder().setVersionInfo("v1").setResponseNonce("2024").build());
+    DiscoveryResponse response = fakeEventHandler.respQ.poll(5000, TimeUnit.MILLISECONDS);
+    assertThat(response.getVersionInfo()).isEqualTo("v1");
+    assertThat(response.getNonce()).isEqualTo("2024");
+    assertThat(fakeEventHandler.ready.get(5000, TimeUnit.MILLISECONDS)).isTrue();
+    Exception expectedException = new IllegalStateException("Test cancel stream.");
+    streamingCall.sendError(expectedException);
+    Status realStatus = fakeEventHandler.endFuture.get(5000, TimeUnit.MILLISECONDS);
+    assertThat(realStatus.getDescription()).isEqualTo("Cancelled by XdsClientImpl");
+    assertThat(realStatus.getCode()).isEqualTo(Status.CANCELLED.getCode());
+    assertThat(realStatus.getCause()).isEqualTo(expectedException);
+    xdsTransport.shutdown();
+  }
+
+  private static class FakeEventHandler implements
+      XdsTransportFactory.EventHandler<DiscoveryResponse> {
+    private final BlockingQueue<DiscoveryResponse> respQ = new LinkedBlockingQueue<>();
+    private SettableFuture<Status> endFuture = SettableFuture.create();
+    private SettableFuture<Boolean> ready = SettableFuture.create();
+
+    @Override
+    public void onReady() {
+      ready.set(true);
+    }
+
+    @Override
+    public void onRecvMessage(DiscoveryResponse message) {
+      respQ.offer(message);
+    }
+
+    @Override
+    public void onStatusReceived(Status status) {
+      endFuture.set(status);
+    }
+  }
+}
+
diff --git a/xds/src/test/java/io/grpc/xds/LazyLoadBalancerTest.java b/xds/src/test/java/io/grpc/xds/LazyLoadBalancerTest.java
new file mode 100644
index 00000000000..c79d048c9d3
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/LazyLoadBalancerTest.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2025 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import io.grpc.CallOptions;
+import io.grpc.ConnectivityState;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.PickSubchannelArgsImpl;
+import io.grpc.testing.TestMethodDescriptors;
+import java.util.Arrays;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit test for {@link io.grpc.xds.LazyLoadBalancer}. */
+@RunWith(JUnit4.class)
+public final class LazyLoadBalancerTest {
+  private SynchronizationContext syncContext =
+      new SynchronizationContext((t, e) -> {
+        throw new AssertionError(e);
+      });
+  private LoadBalancer.PickSubchannelArgs args = new PickSubchannelArgsImpl(
+      TestMethodDescriptors.voidMethod(),
+      new Metadata(),
+      CallOptions.DEFAULT,
+      new LoadBalancer.PickDetailsConsumer() {});
+  private FakeHelper helper = new FakeHelper();
+
+  @Test
+  public void pickerIsNoopAfterEarlyShutdown() {
+    LazyLoadBalancer lb = new LazyLoadBalancer(helper, new LoadBalancer.Factory() {
+      @Override
+      public LoadBalancer newLoadBalancer(LoadBalancer.Helper helper) {
+        throw new AssertionError("unexpected");
+      }
+    });
+    lb.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+        .setAddresses(Arrays.asList())
+        .build());
+    SubchannelPicker picker = helper.picker;
+    assertThat(picker).isNotNull();
+    lb.shutdown();
+
+    picker.pickSubchannel(args);
+  }
+
+  class FakeHelper extends LoadBalancer.Helper {
+    ConnectivityState state;
+    SubchannelPicker picker;
+
+    @Override
+    public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String authority) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+      this.state = newState;
+      this.picker = newPicker;
+    }
+
+    @Override
+    public SynchronizationContext getSynchronizationContext() {
+      return syncContext;
+    }
+
+    @Override
+    public String getAuthority() {
+      return "localhost";
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/LeastRequestLoadBalancerProviderTest.java b/xds/src/test/java/io/grpc/xds/LeastRequestLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..51ec8adcc24
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/LeastRequestLoadBalancerProviderTest.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import io.grpc.InternalServiceProviders;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.JsonParser;
+import io.grpc.xds.LeastRequestLoadBalancer.LeastRequestConfig;
+import java.io.IOException;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link LeastRequestLoadBalancerProvider}. */
+@RunWith(JUnit4.class)
+public class LeastRequestLoadBalancerProviderTest {
+  private static final String AUTHORITY = "foo.googleapis.com";
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final LeastRequestLoadBalancerProvider provider = new LeastRequestLoadBalancerProvider();
+
+  @Test
+  public void provided() {
+    for (LoadBalancerProvider current : InternalServiceProviders.getCandidatesViaServiceLoader(
+        LoadBalancerProvider.class, getClass().getClassLoader())) {
+      if (current instanceof LeastRequestLoadBalancerProvider) {
+        return;
+      }
+    }
+    fail("LeastRequestLoadBalancerProvider not registered");
+  }
+
+  @Test
+  public void providesLoadBalancer() {
+    Helper helper = mock(Helper.class);
+    when(helper.getSynchronizationContext()).thenReturn(syncContext);
+    when(helper.getAuthority()).thenReturn(AUTHORITY);
+    assertThat(provider.newLoadBalancer(helper))
+        .isInstanceOf(LeastRequestLoadBalancer.class);
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_valid() throws IOException {
+    String lbConfig = "{\"choiceCount\" : 3}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    LeastRequestConfig config = (LeastRequestConfig) configOrError.getConfig();
+    assertThat(config.choiceCount).isEqualTo(3);
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_missingChoiceCount_useDefaults() throws IOException {
+    String lbConfig = "{}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    LeastRequestConfig config = (LeastRequestConfig) configOrError.getConfig();
+    assertThat(config.choiceCount)
+        .isEqualTo(LeastRequestLoadBalancerProvider.DEFAULT_CHOICE_COUNT);
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_invalid_negativeSize() throws IOException {
+    String lbConfig = "{\"choiceCount\" : -10}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getError()).isNotNull();
+    assertThat(configOrError.getError().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(configOrError.getError().getDescription())
+        .isEqualTo("Invalid 'choiceCount' in least_request_experimental config");
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_invalid_tooSmallSize() throws IOException {
+    String lbConfig = "{\"choiceCount\" : 1}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getError()).isNotNull();
+    assertThat(configOrError.getError().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(configOrError.getError().getDescription())
+        .isEqualTo("Invalid 'choiceCount' in least_request_experimental config");
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_choiceCountCappedAtMax() throws IOException {
+    String lbConfig = "{\"choiceCount\" : 11}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    LeastRequestConfig config = (LeastRequestConfig) configOrError.getConfig();
+    assertThat(config.choiceCount).isEqualTo(LeastRequestLoadBalancerProvider.MAX_CHOICE_COUNT);
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_invalidInteger() throws IOException {
+    Map<String, ?> lbConfig = parseJsonObject("{\"choiceCount\" : \"NaN\"}");
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(lbConfig);
+    assertThat(configOrError.getError()).isNotNull();
+    assertThat(configOrError.getError().getDescription()).isEqualTo(
+        "Failed to parse least_request_experimental LB config: " + lbConfig);
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, ?> parseJsonObject(String json) throws IOException {
+    return (Map<String, ?>) JsonParser.parse(json);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/LeastRequestLoadBalancerTest.java b/xds/src/test/java/io/grpc/xds/LeastRequestLoadBalancerTest.java
new file mode 100644
index 00000000000..302faed95a4
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/LeastRequestLoadBalancerTest.java
@@ -0,0 +1,672 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static io.grpc.LoadBalancerMatchers.pickerReturns;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import io.grpc.Attributes;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ClientStreamTracer.StreamInfo;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.FixedResultPicker;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.internal.PickFirstLoadBalancerProvider;
+import io.grpc.util.AbstractTestHelper;
+import io.grpc.util.MultiChildLoadBalancer.ChildLbState;
+import io.grpc.xds.LeastRequestLoadBalancer.LeastRequestConfig;
+import io.grpc.xds.LeastRequestLoadBalancer.LeastRequestLbState;
+import io.grpc.xds.LeastRequestLoadBalancer.ReadyPicker;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit test for {@link LeastRequestLoadBalancer}. */
+@RunWith(JUnit4.class)
+public class LeastRequestLoadBalancerTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private static final Attributes.Key<String> MAJOR_KEY = Attributes.Key.create("major-key");
+
+  private LeastRequestLoadBalancer loadBalancer;
+  private final List<EquivalentAddressGroup> servers = Lists.newArrayList();
+  private final Map<List<EquivalentAddressGroup>, Subchannel> subchannels = Maps.newLinkedHashMap();
+  private final Attributes affinity =
+      Attributes.newBuilder().set(MAJOR_KEY, "I got the keys").build();
+
+  @Captor
+  private ArgumentCaptor<SubchannelPicker> pickerCaptor;
+  @Captor
+  private ArgumentCaptor<ConnectivityState> stateCaptor;
+  @Captor
+  private ArgumentCaptor<CreateSubchannelArgs> createArgsCaptor;
+  private final TestHelper testHelperInstance = new TestHelper();
+  private final Helper helper = mock(Helper.class, delegatesTo(testHelperInstance));
+
+  @Mock
+  private ThreadSafeRandom mockRandom;
+
+  @Mock // This LoadBalancer doesn't use any of the arg fields, as verified in tearDown().
+  private PickSubchannelArgs mockArgs;
+
+  @Before
+  public void setUp() {
+    for (int i = 0; i < 3; i++) {
+      SocketAddress addr = new FakeSocketAddress("server" + i);
+      EquivalentAddressGroup eag = new EquivalentAddressGroup(addr);
+      servers.add(eag);
+    }
+
+    loadBalancer = new LeastRequestLoadBalancer(helper, mockRandom);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    verifyNoMoreInteractions(mockRandom);
+    verifyNoMoreInteractions(mockArgs);
+  }
+
+  @Test
+  public void pickAfterResolved() throws Exception {
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    final Subchannel readySubchannel = subchannels.values().iterator().next();
+    deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
+
+    verify(helper, times(3)).createSubchannel(createArgsCaptor.capture());
+    List<List<EquivalentAddressGroup>> capturedAddrs = new ArrayList<>();
+    for (CreateSubchannelArgs arg : createArgsCaptor.getAllValues()) {
+      capturedAddrs.add(arg.getAddresses());
+    }
+
+    assertThat(capturedAddrs).containsAtLeastElementsIn(subchannels.keySet());
+    for (Subchannel subchannel : subchannels.values()) {
+      verify(subchannel).requestConnection();
+      verify(subchannel, never()).shutdown();
+    }
+
+    verify(helper, times(2))
+        .updateBalancingState(stateCaptor.capture(), pickerCaptor.capture());
+
+    assertEquals(CONNECTING, stateCaptor.getAllValues().get(0));
+    assertEquals(READY, stateCaptor.getAllValues().get(1));
+    assertThat(getList(pickerCaptor.getValue())).containsExactly(readySubchannel);
+
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(helper);
+  }
+
+  @Test
+  public void pickAfterResolvedUpdatedHosts() throws Exception {
+    Attributes.Key<String> key = Attributes.Key.create("check-that-it-is-propagated");
+    FakeSocketAddress removedAddr = new FakeSocketAddress("removed");
+    EquivalentAddressGroup removedEag = new EquivalentAddressGroup(removedAddr);
+    FakeSocketAddress oldAddr = new FakeSocketAddress("old");
+    EquivalentAddressGroup oldEag1 = new EquivalentAddressGroup(oldAddr);
+    EquivalentAddressGroup oldEag2 = new EquivalentAddressGroup(
+        oldAddr, Attributes.newBuilder().set(key, "oldattr").build());
+    FakeSocketAddress newAddr = new FakeSocketAddress("new");
+    EquivalentAddressGroup newEag = new EquivalentAddressGroup(
+        newAddr, Attributes.newBuilder().set(key, "newattr").build());
+
+    List<EquivalentAddressGroup> currentServers = Lists.newArrayList(removedEag, oldEag1);
+
+    InOrder inOrder = inOrder(helper);
+
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(currentServers).setAttributes(affinity)
+            .build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    Subchannel removedSubchannel = getSubchannel(removedEag);
+    Subchannel oldSubchannel = getSubchannel(oldEag1);
+    SubchannelStateListener removedListener =
+        testHelperInstance.getSubchannelStateListener(removedSubchannel);
+
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+
+    deliverSubchannelState(removedSubchannel, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(oldSubchannel, ConnectivityStateInfo.forNonError(READY));
+
+    inOrder.verify(helper, times(2)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    assertThat(getList(picker)).containsExactly(removedSubchannel, oldSubchannel);
+
+    verify(removedSubchannel, times(1)).requestConnection();
+    verify(oldSubchannel, times(1)).requestConnection();
+
+    // This time with Attributes
+    List<EquivalentAddressGroup> latestServers = Lists.newArrayList(oldEag2, newEag);
+
+    addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(latestServers).setAttributes(affinity).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+
+    Subchannel newSubchannel = getSubchannel(newEag);
+
+    verify(newSubchannel, times(1)).requestConnection();
+    verify(oldSubchannel, times(1)).updateAddresses(Arrays.asList(oldEag2));
+    verify(removedSubchannel, times(1)).shutdown();
+
+    removedListener.onSubchannelState(ConnectivityStateInfo.forNonError(SHUTDOWN));
+    deliverSubchannelState(newSubchannel, ConnectivityStateInfo.forNonError(READY));
+
+    verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
+    inOrder.verify(helper, times(2)).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    assertThat(getList(pickerCaptor.getValue())).containsExactly(oldSubchannel, newSubchannel);
+
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(helper);
+  }
+
+  private Subchannel getSubchannel(EquivalentAddressGroup removedEag) {
+    return subchannels.get(Collections.singletonList(removedEag));
+  }
+
+  @Test
+  public void pickAfterStateChange() throws Exception {
+    InOrder inOrder = inOrder(helper);
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
+            .build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    ChildLbState childLbState = loadBalancer.getChildLbStates().iterator().next();
+    Subchannel subchannel = getSubchannel(servers.get(0));
+
+    inOrder.verify(helper)
+        .updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+    assertThat(childLbState.getCurrentState()).isEqualTo(CONNECTING);
+
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertThat(pickerCaptor.getValue()).isInstanceOf(ReadyPicker.class);
+    assertThat(childLbState.getCurrentState()).isEqualTo(READY);
+
+    Status error = Status.UNKNOWN.withDescription("¯\\_(ツ)_//¯");
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forTransientFailure(error));
+    assertThat(childLbState.getCurrentState()).isEqualTo(TRANSIENT_FAILURE);
+    assertThat(childLbState.getCurrentPicker().toString()).contains(error.toString());
+    refreshInvokedAndUpdateBS(inOrder, CONNECTING);
+    assertThat(pickerCaptor.getValue().pickSubchannel(mockArgs))
+        .isEqualTo(PickResult.withNoResult());
+
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(helper).refreshNameResolution();
+    assertThat(childLbState.getCurrentState()).isEqualTo(TRANSIENT_FAILURE);
+    assertThat(childLbState.getCurrentPicker().toString()).contains(error.toString());
+
+    int expectedCount = PickFirstLoadBalancerProvider.isEnabledNewPickFirst() ? 1 : 2;
+    verify(subchannel, times(expectedCount)).requestConnection();
+    verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(helper);
+  }
+
+  @Test
+  public void pickAfterConfigChange() {
+    final LeastRequestConfig oldConfig = new LeastRequestConfig(4);
+    final LeastRequestConfig newConfig = new LeastRequestConfig(6);
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity)
+            .setLoadBalancingPolicyConfig(oldConfig).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    final Subchannel readySubchannel = subchannels.values().iterator().next();
+    deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
+    verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
+    verify(helper, times(2))
+        .updateBalancingState(any(ConnectivityState.class), pickerCaptor.capture());
+
+    // At this point it should use a ReadyPicker with oldConfig and 1 ready subchannel
+    pickerCaptor.getValue().pickSubchannel(mockArgs);
+    verify(mockRandom, times(oldConfig.choiceCount)).nextInt(1);
+
+    addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity)
+            .setLoadBalancingPolicyConfig(newConfig).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    verify(helper, times(3))
+        .updateBalancingState(any(ConnectivityState.class), pickerCaptor.capture());
+
+    // At this point it should use a ReadyPicker with newConfig
+    pickerCaptor.getValue().pickSubchannel(mockArgs);
+    verify(mockRandom, times(oldConfig.choiceCount + newConfig.choiceCount)).nextInt(1);
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(helper);
+  }
+
+  @Test
+  public void ignoreShutdownSubchannelStateChange() {
+    InOrder inOrder = inOrder(helper);
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
+            .build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    inOrder.verify(helper)
+        .updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+
+    List<Subchannel> savedSubchannels = new ArrayList<>(subchannels.values());
+    loadBalancer.shutdown();
+    for (Subchannel sc : savedSubchannels) {
+      verify(sc).shutdown();
+      // When the subchannel is being shut down, a SHUTDOWN connectivity state is delivered
+      // back to the subchannel state listener.
+      deliverSubchannelState(sc, ConnectivityStateInfo.forNonError(SHUTDOWN));
+    }
+
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void stayTransientFailureUntilReady() {
+    InOrder inOrder = inOrder(helper);
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
+            .build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+
+    inOrder.verify(helper)
+        .updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+
+    // Simulate state transitions for each subchannel individually.
+    List<ChildLbState> children = new ArrayList<>(loadBalancer.getChildLbStates());
+    for (int i = 0; i < children.size(); i++) {
+      ChildLbState childLbState = children.get(i);
+      Subchannel sc = getSubchannel(servers.get(i));
+      Status error = Status.UNKNOWN.withDescription("connection broken");
+      deliverSubchannelState(sc, ConnectivityStateInfo.forTransientFailure(error));
+      deliverSubchannelState(sc, ConnectivityStateInfo.forNonError(CONNECTING));
+      assertThat(childLbState.getCurrentState()).isEqualTo(TRANSIENT_FAILURE);
+    }
+
+    verify(helper, atLeast(loadBalancer.getChildLbStates().size())).refreshNameResolution();
+    inOrder.verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    assertThat(getStatusString(pickerCaptor.getValue()))
+        .contains("Status{code=UNKNOWN, description=connection broken");
+    inOrder.verify(helper, atLeast(0)).refreshNameResolution();
+    inOrder.verifyNoMoreInteractions();
+
+    ChildLbState childLbState = loadBalancer.getChildLbStates().iterator().next();
+    Subchannel subchannel = getSubchannel(servers.get(0));
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(READY));
+    assertThat(childLbState.getCurrentState()).isEqualTo(READY);
+    inOrder.verify(helper).updateBalancingState(eq(READY), isA(ReadyPicker.class));
+
+    verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(helper);
+  }
+
+  private String getStatusString(SubchannelPicker picker) {
+    if (picker == null) {
+      return "";
+    }
+
+    if (picker instanceof ReadyPicker) {
+      List<SubchannelPicker> childPickers = ((ReadyPicker)picker).getChildPickers();
+      if (childPickers == null || childPickers.isEmpty()) {
+        return "";
+      }
+
+      picker = childPickers.get(0);
+    }
+
+    Status status = picker.pickSubchannel(mockArgs).getStatus();
+    if (status == null) {
+      return "";
+    }
+    return status.toString();
+  }
+
+  @Test
+  public void refreshNameResolutionWhenSubchannelConnectionBroken() {
+    InOrder inOrder = inOrder(helper);
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
+            .build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+
+    verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
+    inOrder.verify(helper)
+        .updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+
+    // Simulate state transitions for each subchannel individually.
+    for (Subchannel sc : subchannels.values()) {
+      verify(sc).requestConnection();
+      deliverSubchannelState(sc, ConnectivityStateInfo.forNonError(CONNECTING));
+      Status error = Status.UNKNOWN.withDescription("connection broken");
+      deliverSubchannelState(sc, ConnectivityStateInfo.forTransientFailure(error));
+      inOrder.verify(helper).refreshNameResolution();
+      deliverSubchannelState(sc, ConnectivityStateInfo.forNonError(READY));
+      inOrder.verify(helper).updateBalancingState(eq(READY), isA(ReadyPicker.class));
+      // Simulate receiving go-away so READY subchannels transit to IDLE.
+      deliverSubchannelState(sc, ConnectivityStateInfo.forNonError(IDLE));
+      inOrder.verify(helper).refreshNameResolution();
+      verify(sc, times(2)).requestConnection();
+      inOrder.verify(helper)
+          .updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+    }
+
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(helper);
+  }
+
+  @Test
+  public void pickerLeastRequest() throws Exception {
+    int choiceCount = 2;
+    // This should add inFlight counters to all subchannels.
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
+            .setLoadBalancingPolicyConfig(new LeastRequestConfig(choiceCount))
+            .build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+
+    assertEquals(3, loadBalancer.getChildLbStates().size());
+
+    List<ChildLbState> childLbStates = Lists.newArrayList(loadBalancer.getChildLbStates());
+
+    // Make sure all inFlight counters have started at 0
+    for (int i = 0; i < 3; i++) {
+      assertEquals("counter for child " + i, 0,
+          ((LeastRequestLbState) childLbStates.get(i)).getActiveRequests());
+    }
+
+    for (Subchannel sc : subchannels.values()) {
+      deliverSubchannelState(sc, ConnectivityStateInfo.forNonError(READY));
+    }
+
+    // Capture the active ReadyPicker once all subchannels are READY
+    verify(helper, times(4))
+        .updateBalancingState(any(ConnectivityState.class), pickerCaptor.capture());
+    assertThat(pickerCaptor.getValue()).isInstanceOf(ReadyPicker.class);
+
+    ReadyPicker picker = (ReadyPicker) pickerCaptor.getValue();
+
+    assertThat(picker.getChildPickers()).containsExactlyElementsIn(
+        childLbStates.stream().map(ChildLbState::getCurrentPicker).toArray());
+
+    // Make random return 0, then 2 for the sample indexes.
+    when(mockRandom.nextInt(childLbStates.size())).thenReturn(0, 2);
+    PickResult pickResult1 = picker.pickSubchannel(mockArgs);
+    verify(mockRandom, times(choiceCount)).nextInt(childLbStates.size());
+    assertThat(pickResult1.getSubchannel()).isEqualTo(getSubchannel(servers.get(0)));
+    // This simulates sending the actual RPC on the picked channel
+    ClientStreamTracer streamTracer1 =
+        pickResult1.getStreamTracerFactory()
+            .newClientStreamTracer(StreamInfo.newBuilder().build(), new Metadata());
+    streamTracer1.streamCreated(Attributes.EMPTY, new Metadata());
+    assertEquals(1, ((LeastRequestLbState) childLbStates.get(0)).getActiveRequests());
+
+    // For the second pick it should pick the one with lower inFlight.
+    when(mockRandom.nextInt(childLbStates.size())).thenReturn(0, 2);
+    PickResult pickResult2 = picker.pickSubchannel(mockArgs);
+    // Since this is the second pick we expect the total random samples to be choiceCount * 2
+    verify(mockRandom, times(choiceCount * 2)).nextInt(childLbStates.size());
+    assertThat(pickResult2.getSubchannel()).isEqualTo(getSubchannel(servers.get(2)));
+
+    // For the third pick we unavoidably pick subchannel with index 1.
+    when(mockRandom.nextInt(childLbStates.size())).thenReturn(1, 1);
+    PickResult pickResult3 = picker.pickSubchannel(mockArgs);
+    verify(mockRandom, times(choiceCount * 3)).nextInt(childLbStates.size());
+    assertThat(pickResult3.getSubchannel()).isEqualTo(getSubchannel(servers.get(1)));
+
+    // Finally ensure a finished RPC decreases inFlight
+    streamTracer1.streamClosed(Status.OK);
+    assertEquals(0, ((LeastRequestLbState) childLbStates.get(0)).getActiveRequests());
+  }
+
+  @Test
+  public void nameResolutionErrorWithNoChannels() throws Exception {
+    Status error = Status.NOT_FOUND.withDescription("nameResolutionError");
+    loadBalancer.setResolvingAddresses(true);
+    loadBalancer.handleNameResolutionError(error);
+    loadBalancer.setResolvingAddresses(false);
+    verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    LoadBalancer.PickResult pickResult = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    assertNull(pickResult.getSubchannel());
+    assertEquals(error, pickResult.getStatus());
+    verifyNoMoreInteractions(helper);
+  }
+
+  @Test
+  public void nameResolutionErrorWithActiveChannels() throws Exception {
+    int choiceCount = 8;
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setLoadBalancingPolicyConfig(new LeastRequestConfig(choiceCount))
+            .setAddresses(servers).setAttributes(affinity).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    final Subchannel readySubchannel = subchannels.values().iterator().next();
+
+    deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
+    // TODO This test assumes that existing subchannels are left unchanged while the logic we have
+    // is to tell all of the children that there was a nameResolutionError.  This seems to me to
+    // make more sense, just ignore a bad update.
+    loadBalancer.setResolvingAddresses(true);
+    loadBalancer.handleNameResolutionError(Status.NOT_FOUND.withDescription("nameResolutionError"));
+    loadBalancer.setResolvingAddresses(false);
+
+    verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
+    verify(helper, times(2))
+        .updateBalancingState(stateCaptor.capture(), pickerCaptor.capture());
+
+    Iterator<ConnectivityState> stateIterator = stateCaptor.getAllValues().iterator();
+    assertEquals(CONNECTING, stateIterator.next());
+    assertEquals(READY, stateIterator.next());
+
+    LoadBalancer.PickResult pickResult = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    verify(mockRandom, times(choiceCount)).nextInt(1);
+    assertEquals(readySubchannel, pickResult.getSubchannel());
+    assertEquals(Status.OK.getCode(), pickResult.getStatus().getCode());
+
+    LoadBalancer.PickResult pickResult2 = pickerCaptor.getValue().pickSubchannel(mockArgs);
+    verify(mockRandom, times(choiceCount * 2)).nextInt(1);
+    assertEquals(readySubchannel, pickResult2.getSubchannel());
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(helper);
+  }
+
+  @Test
+  public void subchannelStateIsolation() throws Exception {
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(Attributes.EMPTY)
+            .build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    Iterator<Subchannel> subchannelIterator = subchannels.values().iterator();
+    Subchannel sc1 = subchannelIterator.next();
+    Subchannel sc2 = subchannelIterator.next();
+    Subchannel sc3 = subchannelIterator.next();
+
+    verify(sc1, times(1)).requestConnection();
+    verify(sc2, times(1)).requestConnection();
+    verify(sc3, times(1)).requestConnection();
+
+    deliverSubchannelState(sc1, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(sc2, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(sc3, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelState(sc2, ConnectivityStateInfo.forNonError(IDLE));
+    deliverSubchannelState(sc3, ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+
+    verify(helper, times(6))
+        .updateBalancingState(stateCaptor.capture(), pickerCaptor.capture());
+    Iterator<ConnectivityState> stateIterator = stateCaptor.getAllValues().iterator();
+    Iterator<SubchannelPicker> pickers = pickerCaptor.getAllValues().iterator();
+    // The picker is incrementally updated as subchannels become READY
+    assertEquals(CONNECTING, stateIterator.next());
+    assertThat(pickers.next().pickSubchannel(mockArgs))
+        .isEqualTo(PickResult.withNoResult());
+    assertEquals(READY, stateIterator.next());
+    assertThat(getList(pickers.next())).containsExactly(sc1);
+    assertEquals(READY, stateIterator.next());
+    assertThat(getList(pickers.next())).containsExactly(sc1, sc2);
+    assertEquals(READY, stateIterator.next());
+    assertThat(getList(pickers.next())).containsExactly(sc1, sc2, sc3);
+    // The IDLE subchannel is dropped from the picker, but a reconnection is requested
+    assertEquals(READY, stateIterator.next());
+    assertThat(getList(pickers.next())).containsExactly(sc1, sc3);
+    verify(sc2, times(2)).requestConnection();
+    // The failing subchannel is dropped from the picker, with no requested reconnect
+    assertEquals(READY, stateIterator.next());
+    assertThat(getList(pickers.next())).containsExactly(sc1);
+    verify(sc3, times(1)).requestConnection();
+    assertThat(stateIterator.hasNext()).isFalse();
+    assertThat(pickers.hasNext()).isFalse();
+  }
+
+  @Test
+  public void readyPicker_emptyList() {
+    try {
+      // ready picker list must be non-empty
+      new ReadyPicker(Collections.emptyList(), 2, mockRandom);
+      fail();
+    } catch (IllegalArgumentException expected) {
+    }
+  }
+
+  @Test
+  public void internalPickerComparisons() {
+    FixedResultPicker empty1 = new FixedResultPicker(PickResult.withNoResult());
+    FixedResultPicker empty2 = new FixedResultPicker(PickResult.withNoResult());
+
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(servers).setAttributes(affinity).build());
+
+
+    Iterator<ChildLbState> iterator = loadBalancer.getChildLbStates().iterator();
+    ChildLbState child1 = iterator.next();
+    ChildLbState child2 = iterator.next();
+    ReadyPicker ready1 = new ReadyPicker(Arrays.asList(child1, child2), 2, mockRandom);
+    ReadyPicker ready2 = new ReadyPicker(Arrays.asList(child1), 2, mockRandom);
+    ReadyPicker ready3 = new ReadyPicker(Arrays.asList(child2, child1), 2, mockRandom);
+    ReadyPicker ready4 = new ReadyPicker(Arrays.asList(child1, child2), 2, mockRandom);
+    ReadyPicker ready5 = new ReadyPicker(Arrays.asList(child2, child1), 2, mockRandom);
+    ReadyPicker ready6 = new ReadyPicker(Arrays.asList(child2, child1), 8, mockRandom);
+
+    assertTrue(empty1.equals(empty2));
+    assertFalse(ready1.equals(ready2));
+    assertTrue(ready1.equals(ready3));
+    assertTrue(ready3.equals(ready4));
+    assertTrue(ready4.equals(ready5));
+    assertFalse(empty1.equals(ready1));
+    assertFalse(ready1.equals(empty1));
+    assertFalse(ready5.equals(ready6));
+  }
+
+  @Test
+  public void emptyAddresses() {
+    assertThat(loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(Collections.<EquivalentAddressGroup>emptyList())
+            .setAttributes(affinity)
+            .build()).isOk())
+        .isFalse();
+  }
+
+  private List<Subchannel> getList(SubchannelPicker picker) {
+    if (picker instanceof ReadyPicker) {
+      return ((ReadyPicker) picker).getChildPickers().stream()
+          .map((p) -> p.pickSubchannel(mockArgs).getSubchannel())
+          .collect(Collectors.toList());
+    } else {
+      return Collections.emptyList();
+    }
+  }
+
+  private void deliverSubchannelState(Subchannel subchannel, ConnectivityStateInfo newState) {
+    testHelperInstance.deliverSubchannelState(subchannel, newState);
+  }
+
+  // Old PF and new PF reverse calling order of updateBlaancingState and refreshNameResolution
+  private void refreshInvokedAndUpdateBS(InOrder inOrder, ConnectivityState state) {
+    if (PickFirstLoadBalancerProvider.isEnabledNewPickFirst()) {
+      inOrder.verify(helper).updateBalancingState(eq(state), pickerCaptor.capture());
+    }
+
+    inOrder.verify(helper).refreshNameResolution();
+
+    if (!PickFirstLoadBalancerProvider.isEnabledNewPickFirst()) {
+      inOrder.verify(helper).updateBalancingState(eq(state), pickerCaptor.capture());
+    }
+  }
+
+  private static class FakeSocketAddress extends SocketAddress {
+    final String name;
+
+    FakeSocketAddress(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public String toString() {
+      return "FakeSocketAddress-" + name;
+    }
+  }
+
+  private class TestHelper extends AbstractTestHelper {
+
+    @Override
+    public Map<List<EquivalentAddressGroup>, Subchannel> getSubchannelMap() {
+      return subchannels;
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/LoadBalancerConfigFactoryTest.java b/xds/src/test/java/io/grpc/xds/LoadBalancerConfigFactoryTest.java
new file mode 100644
index 00000000000..e09066461c4
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/LoadBalancerConfigFactoryTest.java
@@ -0,0 +1,416 @@
+/*
+ * Copyright 2022 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+
+import com.github.xds.type.v3.TypedStruct;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+import com.google.protobuf.Any;
+import com.google.protobuf.BoolValue;
+import com.google.protobuf.Duration;
+import com.google.protobuf.FloatValue;
+import com.google.protobuf.Struct;
+import com.google.protobuf.UInt32Value;
+import com.google.protobuf.UInt64Value;
+import com.google.protobuf.Value;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.LbPolicy;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.LeastRequestLbConfig;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.RingHashLbConfig;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.RingHashLbConfig.HashFunction;
+import io.envoyproxy.envoy.config.cluster.v3.LoadBalancingPolicy;
+import io.envoyproxy.envoy.config.cluster.v3.LoadBalancingPolicy.Policy;
+import io.envoyproxy.envoy.config.core.v3.TypedExtensionConfig;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.client_side_weighted_round_robin.v3.ClientSideWeightedRoundRobin;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.least_request.v3.LeastRequest;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.pick_first.v3.PickFirst;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.ring_hash.v3.RingHash;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.round_robin.v3.RoundRobin;
+import io.envoyproxy.envoy.extensions.load_balancing_policies.wrr_locality.v3.WrrLocality;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.internal.JsonUtil;
+import io.grpc.internal.ServiceConfigUtil;
+import io.grpc.internal.ServiceConfigUtil.LbConfig;
+import io.grpc.xds.client.XdsResourceType.ResourceInvalidException;
+import java.util.List;
+import org.junit.After;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit test for {@link LoadBalancerConfigFactory}.
+ */
+@RunWith(JUnit4.class)
+public class LoadBalancerConfigFactoryTest {
+
+  private static final Policy ROUND_ROBIN_POLICY = Policy.newBuilder().setTypedExtensionConfig(
+      TypedExtensionConfig.newBuilder().setTypedConfig(
+          Any.pack(RoundRobin.getDefaultInstance()))).build();
+
+  private static final long RING_HASH_MIN_RING_SIZE = 1;
+  private static final long RING_HASH_MAX_RING_SIZE = 2;
+  private static final Policy RING_HASH_POLICY = Policy.newBuilder().setTypedExtensionConfig(
+      TypedExtensionConfig.newBuilder().setTypedConfig(Any.pack(
+          RingHash.newBuilder().setMinimumRingSize(UInt64Value.of(RING_HASH_MIN_RING_SIZE))
+              .setMaximumRingSize(UInt64Value.of(RING_HASH_MAX_RING_SIZE))
+              .setHashFunction(RingHash.HashFunction.XX_HASH).build()))).build();
+
+  private static final int LEAST_REQUEST_CHOICE_COUNT = 10;
+  private static final Policy LEAST_REQUEST_POLICY = Policy.newBuilder().setTypedExtensionConfig(
+      TypedExtensionConfig.newBuilder().setTypedConfig(Any.pack(
+          LeastRequest.newBuilder().setChoiceCount(UInt32Value.of(LEAST_REQUEST_CHOICE_COUNT))
+              .build()))).build();
+
+  private static final Policy PICK_FIRST_POLICY = Policy.newBuilder().setTypedExtensionConfig(
+      TypedExtensionConfig.newBuilder().setTypedConfig(Any.pack(
+          PickFirst.newBuilder().setShuffleAddressList(true)
+              .build()))).build();
+
+  private static final Policy WRR_POLICY = Policy.newBuilder()
+              .setTypedExtensionConfig(TypedExtensionConfig.newBuilder()
+                  .setName("backend")
+                  .setTypedConfig(
+                      Any.pack(ClientSideWeightedRoundRobin.newBuilder()
+                          .setBlackoutPeriod(Duration.newBuilder().setSeconds(287).build())
+                          .setEnableOobLoadReport(
+                              BoolValue.newBuilder().setValue(true).build())
+                          .setErrorUtilizationPenalty(
+                              FloatValue.newBuilder().setValue(1.75F).build())
+                          .build()))
+                  .build())
+              .build();
+  private static final String CUSTOM_POLICY_NAME = "myorg.MyCustomLeastRequestPolicy";
+  private static final String CUSTOM_POLICY_FIELD_KEY = "choiceCount";
+  private static final double CUSTOM_POLICY_FIELD_VALUE = 2;
+  private static final Policy CUSTOM_POLICY = Policy.newBuilder().setTypedExtensionConfig(
+          TypedExtensionConfig.newBuilder().setTypedConfig(Any.pack(
+              TypedStruct.newBuilder().setTypeUrl(
+                      "type.googleapis.com/" + CUSTOM_POLICY_NAME).setValue(
+                      Struct.newBuilder().putFields(CUSTOM_POLICY_FIELD_KEY,
+                          Value.newBuilder().setNumberValue(CUSTOM_POLICY_FIELD_VALUE).build()))
+                  .build()))).build();
+  private static final Policy CUSTOM_POLICY_UDPA = Policy.newBuilder().setTypedExtensionConfig(
+      TypedExtensionConfig.newBuilder().setTypedConfig(Any.pack(
+          com.github.udpa.udpa.type.v1.TypedStruct.newBuilder().setTypeUrl(
+                  "type.googleapis.com/" + CUSTOM_POLICY_NAME).setValue(
+                  Struct.newBuilder().putFields(CUSTOM_POLICY_FIELD_KEY,
+                      Value.newBuilder().setNumberValue(CUSTOM_POLICY_FIELD_VALUE).build()))
+              .build()))).build();
+  private static final FakeCustomLoadBalancerProvider CUSTOM_POLICY_PROVIDER
+      = new FakeCustomLoadBalancerProvider();
+
+  private static final LbConfig VALID_ROUND_ROBIN_CONFIG = new LbConfig("wrr_locality_experimental",
+      ImmutableMap.of("childPolicy",
+          ImmutableList.of(ImmutableMap.of("round_robin", ImmutableMap.of()))));
+
+  private static final LbConfig VALID_WRR_CONFIG = new LbConfig("wrr_locality_experimental",
+      ImmutableMap.of("childPolicy", ImmutableList.of(
+      ImmutableMap.of("weighted_round_robin",
+      ImmutableMap.of("blackoutPeriod","287s", "enableOobLoadReport", true,
+          "errorUtilizationPenalty", 1.75F )))));
+  private static final LbConfig VALID_RING_HASH_CONFIG = new LbConfig("ring_hash_experimental",
+      ImmutableMap.of("minRingSize", (double) RING_HASH_MIN_RING_SIZE, "maxRingSize",
+          (double) RING_HASH_MAX_RING_SIZE));
+  private static final LbConfig VALID_CUSTOM_CONFIG = new LbConfig(CUSTOM_POLICY_NAME,
+      ImmutableMap.of(CUSTOM_POLICY_FIELD_KEY, CUSTOM_POLICY_FIELD_VALUE));
+  private static final LbConfig VALID_CUSTOM_CONFIG_IN_WRR = new LbConfig(
+      "wrr_locality_experimental", ImmutableMap.of("childPolicy", ImmutableList.of(
+      ImmutableMap.of(VALID_CUSTOM_CONFIG.getPolicyName(),
+          VALID_CUSTOM_CONFIG.getRawConfigValue()))));
+  private static final LbConfig VALID_LEAST_REQUEST_CONFIG = new LbConfig(
+      "least_request_experimental",
+      ImmutableMap.of("choiceCount", (double) LEAST_REQUEST_CHOICE_COUNT));
+  private static final LbConfig VALID_PICK_FIRST_CONFIG = new LbConfig(
+      "pick_first",
+      ImmutableMap.of("shuffleAddressList", true));
+
+  @After
+  public void deregisterCustomProvider() {
+    LoadBalancerRegistry.getDefaultRegistry().deregister(CUSTOM_POLICY_PROVIDER);
+  }
+
+  @Test
+  public void roundRobin() throws ResourceInvalidException {
+    Cluster cluster = newCluster(buildWrrPolicy(ROUND_ROBIN_POLICY));
+
+    assertThat(newLbConfig(cluster, true)).isEqualTo(VALID_ROUND_ROBIN_CONFIG);
+  }
+
+  @Test
+  public void weightedRoundRobin() throws ResourceInvalidException {
+    Cluster cluster = newCluster(buildWrrPolicy(WRR_POLICY));
+
+    assertThat(newLbConfig(cluster, true)).isEqualTo(VALID_WRR_CONFIG);
+  }
+
+  @Test
+  public void weightedRoundRobin_invalid() throws ResourceInvalidException {
+    Cluster cluster = newCluster(buildWrrPolicy(Policy.newBuilder()
+        .setTypedExtensionConfig(TypedExtensionConfig.newBuilder()
+            .setName("backend")
+            .setTypedConfig(
+                Any.pack(ClientSideWeightedRoundRobin.newBuilder()
+                    .setBlackoutPeriod(Duration.newBuilder().setNanos(1000000000).build())
+                    .setEnableOobLoadReport(
+                        BoolValue.newBuilder().setValue(true).build())
+                    .build()))
+            .build())
+        .build()));
+
+    assertResourceInvalidExceptionThrown(cluster, true,
+        "Invalid duration in weighted round robin config");
+  }
+
+  @Test
+  public void roundRobin_legacy() throws ResourceInvalidException {
+    Cluster cluster = Cluster.newBuilder().setLbPolicy(LbPolicy.ROUND_ROBIN).build();
+
+    assertThat(newLbConfig(cluster, true)).isEqualTo(VALID_ROUND_ROBIN_CONFIG);
+  }
+
+  @Test
+  public void ringHash() throws ResourceInvalidException {
+    Cluster cluster = Cluster.newBuilder()
+        .setLoadBalancingPolicy(LoadBalancingPolicy.newBuilder().addPolicies(RING_HASH_POLICY))
+        .build();
+
+    assertThat(newLbConfig(cluster, true)).isEqualTo(VALID_RING_HASH_CONFIG);
+  }
+
+  @Test
+  public void ringHash_legacy() throws ResourceInvalidException {
+    Cluster cluster = Cluster.newBuilder().setLbPolicy(LbPolicy.RING_HASH).setRingHashLbConfig(
+        RingHashLbConfig.newBuilder().setMinimumRingSize(UInt64Value.of(RING_HASH_MIN_RING_SIZE))
+            .setMaximumRingSize(UInt64Value.of(RING_HASH_MAX_RING_SIZE))
+            .setHashFunction(HashFunction.XX_HASH)).build();
+
+    assertThat(newLbConfig(cluster, true)).isEqualTo(VALID_RING_HASH_CONFIG);
+  }
+
+  @Test
+  public void ringHash_invalidHash() {
+    Cluster cluster = newCluster(
+        Policy.newBuilder().setTypedExtensionConfig(TypedExtensionConfig.newBuilder()
+            .setTypedConfig(Any.pack(
+                RingHash.newBuilder().setMinimumRingSize(UInt64Value.of(RING_HASH_MIN_RING_SIZE))
+                    .setMaximumRingSize(UInt64Value.of(RING_HASH_MAX_RING_SIZE))
+                    .setHashFunction(RingHash.HashFunction.MURMUR_HASH_2).build()))).build());
+
+    assertResourceInvalidExceptionThrown(cluster, true, "Invalid ring hash function");
+  }
+
+  @Test
+  public void ringHash_invalidHash_legacy() {
+    Cluster cluster = Cluster.newBuilder().setLbPolicy(LbPolicy.RING_HASH).setRingHashLbConfig(
+        RingHashLbConfig.newBuilder().setHashFunction(HashFunction.MURMUR_HASH_2)).build();
+
+    assertResourceInvalidExceptionThrown(cluster, true, "invalid ring hash function");
+  }
+
+  @Test
+  public void leastRequest() throws ResourceInvalidException {
+    Cluster cluster = Cluster.newBuilder()
+        .setLoadBalancingPolicy(LoadBalancingPolicy.newBuilder().addPolicies(LEAST_REQUEST_POLICY))
+        .build();
+
+    assertThat(newLbConfig(cluster, true)).isEqualTo(VALID_LEAST_REQUEST_CONFIG);
+  }
+
+  @Test
+  public void leastRequest_legacy() throws ResourceInvalidException {
+    System.setProperty("io.grpc.xds.experimentalEnableLeastRequest", "true");
+
+    Cluster cluster = Cluster.newBuilder().setLbPolicy(LbPolicy.LEAST_REQUEST)
+        .setLeastRequestLbConfig(
+            LeastRequestLbConfig.newBuilder()
+                .setChoiceCount(UInt32Value.of(LEAST_REQUEST_CHOICE_COUNT))).build();
+
+    LbConfig lbConfig = newLbConfig(cluster, true);
+    assertThat(lbConfig.getPolicyName()).isEqualTo("wrr_locality_experimental");
+
+    List<LbConfig> childConfigs = ServiceConfigUtil.unwrapLoadBalancingConfigList(
+        JsonUtil.getListOfObjects(lbConfig.getRawConfigValue(), "childPolicy"));
+    assertThat(childConfigs.get(0).getPolicyName()).isEqualTo("least_request_experimental");
+    assertThat(
+        JsonUtil.getNumberAsLong(childConfigs.get(0).getRawConfigValue(), "choiceCount")).isEqualTo(
+        LEAST_REQUEST_CHOICE_COUNT);
+  }
+
+  @Test
+  public void leastRequest_notEnabled() {
+    Cluster cluster = Cluster.newBuilder().setLbPolicy(LbPolicy.LEAST_REQUEST).build();
+
+    assertResourceInvalidExceptionThrown(cluster, false, "unsupported lb policy");
+  }
+
+  @Test
+  public void pickFirst() throws ResourceInvalidException {
+    Cluster cluster = Cluster.newBuilder()
+        .setLoadBalancingPolicy(LoadBalancingPolicy.newBuilder().addPolicies(PICK_FIRST_POLICY))
+        .build();
+
+    assertThat(newLbConfig(cluster, true)).isEqualTo(VALID_PICK_FIRST_CONFIG);
+  }
+
+  @Test
+  public void customRootLb_providerRegistered() throws ResourceInvalidException {
+    LoadBalancerRegistry.getDefaultRegistry().register(CUSTOM_POLICY_PROVIDER);
+
+    assertThat(newLbConfig(newCluster(CUSTOM_POLICY), false)).isEqualTo(VALID_CUSTOM_CONFIG);
+  }
+
+  @Test
+  public void customRootLb_providerNotRegistered() throws ResourceInvalidException {
+    Cluster cluster = Cluster.newBuilder()
+        .setLoadBalancingPolicy(LoadBalancingPolicy.newBuilder().addPolicies(CUSTOM_POLICY))
+        .build();
+
+    assertResourceInvalidExceptionThrown(cluster, false, "Invalid LoadBalancingPolicy");
+  }
+
+  // When a provider for the endpoint picking custom policy is available, the configuration should
+  // use it.
+  @Test
+  public void customLbInWrr_providerRegistered() throws ResourceInvalidException {
+    LoadBalancerRegistry.getDefaultRegistry().register(CUSTOM_POLICY_PROVIDER);
+
+    Cluster cluster = Cluster.newBuilder().setLoadBalancingPolicy(LoadBalancingPolicy.newBuilder()
+        .addPolicies(buildWrrPolicy(CUSTOM_POLICY, ROUND_ROBIN_POLICY))).build();
+
+    assertThat(newLbConfig(cluster, false)).isEqualTo(VALID_CUSTOM_CONFIG_IN_WRR);
+  }
+
+  // When a provider for the endpoint picking custom policy is available, the configuration should
+  // use it. This one uses the legacy UDPA TypedStruct that is also supported.
+  @Test
+  public void customLbInWrr_providerRegistered_udpa() throws ResourceInvalidException {
+    LoadBalancerRegistry.getDefaultRegistry().register(CUSTOM_POLICY_PROVIDER);
+
+    Cluster cluster = Cluster.newBuilder().setLoadBalancingPolicy(LoadBalancingPolicy.newBuilder()
+        .addPolicies(buildWrrPolicy(CUSTOM_POLICY_UDPA, ROUND_ROBIN_POLICY))).build();
+
+    assertThat(newLbConfig(cluster, false)).isEqualTo(VALID_CUSTOM_CONFIG_IN_WRR);
+  }
+
+  // When a provider for the custom wrr_locality child policy is NOT available, we should fall back
+  // to the round_robin that is also provided.
+  @Test
+  public void customLbInWrr_providerNotRegistered() throws ResourceInvalidException {
+    Cluster cluster = Cluster.newBuilder().setLoadBalancingPolicy(LoadBalancingPolicy.newBuilder()
+        .addPolicies(buildWrrPolicy(CUSTOM_POLICY, ROUND_ROBIN_POLICY))).build();
+
+    assertThat(newLbConfig(cluster, false)).isEqualTo(VALID_ROUND_ROBIN_CONFIG);
+  }
+
+  // When a provider for the custom wrr_locality child policy is NOT available and no alternative
+  // child policy is provided, the configuration is invalid.
+  @Test
+  public void customLbInWrr_providerNotRegistered_noFallback() throws ResourceInvalidException {
+    Cluster cluster = Cluster.newBuilder().setLoadBalancingPolicy(
+        LoadBalancingPolicy.newBuilder().addPolicies(buildWrrPolicy(CUSTOM_POLICY))).build();
+
+    assertResourceInvalidExceptionThrown(cluster, false, "Invalid LoadBalancingPolicy");
+  }
+
+  @Test
+  public void maxRecursion() {
+    Cluster cluster = Cluster.newBuilder()
+        .setLoadBalancingPolicy(
+            LoadBalancingPolicy.newBuilder().addPolicies(
+              buildWrrPolicy( // Wheee...
+                buildWrrPolicy( // ...eee...
+                  buildWrrPolicy( // ...eee!
+                    buildWrrPolicy(
+                      buildWrrPolicy(
+                        buildWrrPolicy(
+                          buildWrrPolicy(
+                            buildWrrPolicy(
+                              buildWrrPolicy(
+                                buildWrrPolicy(
+                                  buildWrrPolicy(
+                                    buildWrrPolicy(
+                                      buildWrrPolicy(
+                                        buildWrrPolicy(
+                                          buildWrrPolicy(
+                                            buildWrrPolicy(
+                                              buildWrrPolicy(
+                                                ROUND_ROBIN_POLICY))))))))))))))))))).build();
+
+    assertResourceInvalidExceptionThrown(cluster, false,
+        "Maximum LB config recursion depth reached");
+  }
+
+  private Cluster newCluster(Policy... policies) {
+    return Cluster.newBuilder().setLoadBalancingPolicy(
+        LoadBalancingPolicy.newBuilder().addAllPolicies(Lists.newArrayList(policies))).build();
+  }
+
+  private static Policy buildWrrPolicy(Policy... childPolicy) {
+    return Policy.newBuilder().setTypedExtensionConfig(TypedExtensionConfig.newBuilder()
+        .setTypedConfig(Any.pack(WrrLocality.newBuilder().setEndpointPickingPolicy(
+                LoadBalancingPolicy.newBuilder().addAllPolicies(Lists.newArrayList(childPolicy)))
+            .build()))).build();
+  }
+
+  private LbConfig newLbConfig(Cluster cluster, boolean enableLeastRequest)
+      throws ResourceInvalidException {
+    return ServiceConfigUtil.unwrapLoadBalancingConfig(
+        LoadBalancerConfigFactory.newConfig(cluster, enableLeastRequest));
+  }
+
+  private void assertResourceInvalidExceptionThrown(Cluster cluster, boolean enableLeastRequest,
+      String expectedMessage) {
+    try {
+      newLbConfig(cluster, enableLeastRequest);
+    } catch (ResourceInvalidException e) {
+      assertThat(e).hasMessageThat().contains(expectedMessage);
+      return;
+    }
+    fail("ResourceInvalidException not thrown");
+  }
+
+  private static class FakeCustomLoadBalancerProvider extends LoadBalancerProvider {
+
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      return null;
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 5;
+    }
+
+    @Override
+    public String getPolicyName() {
+      return CUSTOM_POLICY_NAME;
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/LoadReportClientTest.java b/xds/src/test/java/io/grpc/xds/LoadReportClientTest.java
new file mode 100644
index 00000000000..9bdf86132b6
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/LoadReportClientTest.java
@@ -0,0 +1,659 @@
+/*
+ * Copyright 2019 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.Struct;
+import com.google.protobuf.Value;
+import com.google.protobuf.util.Durations;
+import io.envoyproxy.envoy.config.core.v3.Node;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterStats;
+import io.envoyproxy.envoy.config.endpoint.v3.EndpointLoadMetricStats;
+import io.envoyproxy.envoy.config.endpoint.v3.UpstreamLocalityStats;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadReportingServiceGrpc;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse;
+import io.grpc.Context;
+import io.grpc.Context.CancellationListener;
+import io.grpc.ManagedChannel;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.FakeClock;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.xds.client.EnvoyProtoData;
+import io.grpc.xds.client.LoadReportClient;
+import io.grpc.xds.client.LoadStatsManager2;
+import io.grpc.xds.client.LoadStatsManager2.ClusterDropStats;
+import io.grpc.xds.client.LoadStatsManager2.ClusterLocalityStats;
+import io.grpc.xds.client.Locality;
+import java.util.ArrayDeque;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Unit tests for {@link LoadReportClient}.
+ */
+@RunWith(JUnit4.class)
+public class LoadReportClientTest {
+  // bootstrap node identifier
+  private static final EnvoyProtoData.Node NODE =
+      EnvoyProtoData.Node.newBuilder()
+          .setId("LRS test")
+          .setMetadata(ImmutableMap.of("TRAFFICDIRECTOR_NETWORK_HOSTNAME", "default"))
+          .build();
+  private static final String CLUSTER1 = "cluster-foo.googleapis.com";
+  private static final String CLUSTER2 = "cluster-bar.googleapis.com";
+  private static final String EDS_SERVICE_NAME1 = "backend-service-foo.googleapis.com";
+  private static final String EDS_SERVICE_NAME2 = "backend-service-bar.googleapis.com";
+  private static final Locality LOCALITY1 = Locality.create("region1", "zone1", "subZone1");
+  private static final Locality LOCALITY2 = Locality.create("region2", "zone2", "subZone2");
+  private static final FakeClock.TaskFilter LOAD_REPORTING_TASK_FILTER =
+      new FakeClock.TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable command) {
+          return command.toString()
+              .contains("LoadReportingTask");
+        }
+      };
+  private static final FakeClock.TaskFilter LRS_RPC_RETRY_TASK_FILTER =
+      new FakeClock.TaskFilter() {
+        @Override
+        public boolean shouldAccept(Runnable command) {
+          return command.toString()
+              .contains("LrsRpcRetryTask");
+        }
+      };
+
+  @Rule
+  public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final FakeClock fakeClock = new FakeClock();
+  private final ArrayDeque<StreamObserver<LoadStatsRequest>> lrsRequestObservers =
+      new ArrayDeque<>();
+  private final AtomicBoolean callEnded = new AtomicBoolean(true);
+  private final LoadStatsManager2 loadStatsManager =
+      new LoadStatsManager2(fakeClock.getStopwatchSupplier());
+
+  @Mock
+  private BackoffPolicy.Provider backoffPolicyProvider;
+  @Mock
+  private BackoffPolicy backoffPolicy1;
+  @Mock
+  private BackoffPolicy backoffPolicy2;
+  @Captor
+  private ArgumentCaptor<StreamObserver<LoadStatsResponse>> lrsResponseObserverCaptor;
+  @Captor
+  private ArgumentCaptor<LoadStatsRequest> requestCaptor;
+  @Captor
+  private ArgumentCaptor<Throwable> errorCaptor;
+
+  private LoadReportingServiceGrpc.LoadReportingServiceImplBase mockLoadReportingService;
+  private ManagedChannel channel;
+  private LoadReportClient lrsClient;
+
+  @SuppressWarnings("unchecked")
+  @Before
+  public void setUp() throws Exception {
+    mockLoadReportingService = mock(LoadReportingServiceGrpc.LoadReportingServiceImplBase.class,
+        delegatesTo(
+            new LoadReportingServiceGrpc.LoadReportingServiceImplBase() {
+              @Override
+              public StreamObserver<LoadStatsRequest> streamLoadStats(
+                  final StreamObserver<LoadStatsResponse> responseObserver) {
+                assertThat(callEnded.get()).isTrue();  // ensure previous call was ended
+                callEnded.set(false);
+                Context.current().addListener(
+                    new CancellationListener() {
+                      @Override
+                      public void cancelled(Context context) {
+                        callEnded.set(true);
+                      }
+                    }, MoreExecutors.directExecutor());
+                StreamObserver<LoadStatsRequest> requestObserver =
+                    mock(StreamObserver.class);
+                lrsRequestObservers.add(requestObserver);
+                return requestObserver;
+              }
+            }
+        ));
+    cleanupRule.register(InProcessServerBuilder.forName("fakeLoadReportingServer").directExecutor()
+        .addService(mockLoadReportingService).build().start());
+    channel = cleanupRule.register(
+        InProcessChannelBuilder.forName("fakeLoadReportingServer").directExecutor().build());
+    when(backoffPolicyProvider.get()).thenReturn(backoffPolicy1, backoffPolicy2);
+    when(backoffPolicy1.nextBackoffNanos())
+        .thenReturn(TimeUnit.SECONDS.toNanos(1L), TimeUnit.SECONDS.toNanos(10L));
+    when(backoffPolicy2.nextBackoffNanos())
+        .thenReturn(TimeUnit.SECONDS.toNanos(2L), TimeUnit.SECONDS.toNanos(20L));
+    addFakeStatsData();
+    lrsClient =
+        new LoadReportClient(
+            loadStatsManager,
+            new GrpcXdsTransportFactory(null).createForTest(channel),
+            NODE,
+            syncContext,
+            fakeClock.getScheduledExecutorService(),
+            backoffPolicyProvider,
+            fakeClock.getStopwatchSupplier());
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        lrsClient.startLoadReporting();
+      }
+    });
+  }
+
+  private void addFakeStatsData() {
+    ClusterDropStats dropStats1 = loadStatsManager.getClusterDropStats(CLUSTER1, EDS_SERVICE_NAME1);
+    for (int i = 0; i < 52; i++) {
+      dropStats1.recordDroppedRequest("lb");
+    }
+    ClusterDropStats dropStats2 = loadStatsManager.getClusterDropStats(CLUSTER2, EDS_SERVICE_NAME2);
+    for (int i = 0; i < 23; i++) {
+      dropStats2.recordDroppedRequest("throttle");
+    }
+    ClusterLocalityStats localityStats1 =
+        loadStatsManager.getClusterLocalityStats(CLUSTER1, EDS_SERVICE_NAME1, LOCALITY1);
+    for (int i = 0; i < 31; i++) {
+      localityStats1.recordCallStarted();
+    }
+    localityStats1.recordBackendLoadMetricStats(ImmutableMap.of("named1", 3.14159));
+    localityStats1.recordBackendLoadMetricStats(ImmutableMap.of("named1", 1.618));
+    localityStats1.recordBackendLoadMetricStats(ImmutableMap.of("named1", -2.718));
+    ClusterLocalityStats localityStats2 =
+        loadStatsManager.getClusterLocalityStats(CLUSTER2, EDS_SERVICE_NAME2, LOCALITY2);
+    for (int i = 0; i < 45; i++) {
+      localityStats2.recordCallStarted();
+    }
+    localityStats2.recordBackendLoadMetricStats(ImmutableMap.of("named2", 1.414));
+    localityStats2.recordCallFinished(Status.OK);
+  }
+
+  @After
+  public void tearDown() {
+    stopLoadReportingInSyncContext();
+    assertThat(callEnded.get()).isTrue();
+  }
+
+  @Test
+  public void periodicLoadReporting() {
+    verify(mockLoadReportingService).streamLoadStats(lrsResponseObserverCaptor.capture());
+    StreamObserver<LoadStatsResponse> responseObserver = lrsResponseObserverCaptor.getValue();
+    StreamObserver<LoadStatsRequest> requestObserver =
+        Iterables.getOnlyElement(lrsRequestObservers);
+    verify(requestObserver).onNext(eq(buildInitialRequest()));
+
+    // Management server asks to report loads for cluster1.
+    responseObserver.onNext(LoadStatsResponse.newBuilder().addClusters(CLUSTER1)
+        .setLoadReportingInterval(Durations.fromSeconds(10L)).build());
+
+    fakeClock.forwardTime(10L, TimeUnit.SECONDS);
+    verify(requestObserver, times(2)).onNext(requestCaptor.capture());
+    LoadStatsRequest request = requestCaptor.getValue();
+    ClusterStats clusterStats = Iterables.getOnlyElement(request.getClusterStatsList());
+    assertThat(clusterStats.getClusterName()).isEqualTo(CLUSTER1);
+    assertThat(clusterStats.getClusterServiceName()).isEqualTo(EDS_SERVICE_NAME1);
+    assertThat(Durations.toSeconds(clusterStats.getLoadReportInterval())).isEqualTo(10L);
+    assertThat(Iterables.getOnlyElement(clusterStats.getDroppedRequestsList()).getCategory())
+        .isEqualTo("lb");
+    assertThat(Iterables.getOnlyElement(clusterStats.getDroppedRequestsList()).getDroppedCount())
+        .isEqualTo(52L);
+    assertThat(clusterStats.getTotalDroppedRequests()).isEqualTo(52L);
+    UpstreamLocalityStats localityStats =
+        Iterables.getOnlyElement(clusterStats.getUpstreamLocalityStatsList());
+    assertThat(localityStats.getLocality().getRegion()).isEqualTo("region1");
+    assertThat(localityStats.getLocality().getZone()).isEqualTo("zone1");
+    assertThat(localityStats.getLocality().getSubZone()).isEqualTo("subZone1");
+    assertThat(localityStats.getTotalIssuedRequests()).isEqualTo(31L);
+    assertThat(localityStats.getTotalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalErrorRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalRequestsInProgress()).isEqualTo(31L);
+    assertThat(localityStats.getLoadMetricStatsCount()).isEqualTo(1);
+    EndpointLoadMetricStats loadMetricStats = Iterables.getOnlyElement(
+        localityStats.getLoadMetricStatsList());
+    assertThat(loadMetricStats.getMetricName()).isEqualTo("named1");
+    assertThat(loadMetricStats.getNumRequestsFinishedWithMetric()).isEqualTo(3L);
+    assertThat(loadMetricStats.getTotalMetricValue()).isEqualTo(3.14159 + 1.618 - 2.718);
+
+    fakeClock.forwardTime(10L, TimeUnit.SECONDS);
+    verify(requestObserver, times(3)).onNext(requestCaptor.capture());
+    request = requestCaptor.getValue();
+    clusterStats = Iterables.getOnlyElement(request.getClusterStatsList());
+    assertThat(clusterStats.getClusterName()).isEqualTo(CLUSTER1);
+    assertThat(clusterStats.getClusterServiceName()).isEqualTo(EDS_SERVICE_NAME1);
+    assertThat(Durations.toSeconds(clusterStats.getLoadReportInterval())).isEqualTo(10L);
+    assertThat(clusterStats.getDroppedRequestsCount()).isEqualTo(0L);
+    assertThat(clusterStats.getTotalDroppedRequests()).isEqualTo(0L);
+    localityStats = Iterables.getOnlyElement(clusterStats.getUpstreamLocalityStatsList());
+    assertThat(localityStats.getLocality().getRegion()).isEqualTo("region1");
+    assertThat(localityStats.getLocality().getZone()).isEqualTo("zone1");
+    assertThat(localityStats.getLocality().getSubZone()).isEqualTo("subZone1");
+    assertThat(localityStats.getTotalIssuedRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalErrorRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalRequestsInProgress()).isEqualTo(31L);
+    assertThat(localityStats.getLoadMetricStatsList()).isEmpty();
+
+    // Management server updates the interval of sending load reports, while still asking for
+    // loads to cluster1 only.
+    responseObserver.onNext(LoadStatsResponse.newBuilder().addClusters(CLUSTER1)
+        .setLoadReportingInterval(Durations.fromSeconds(20L)).build());
+
+    fakeClock.forwardTime(10L, TimeUnit.SECONDS);
+    verifyNoMoreInteractions(requestObserver);
+    fakeClock.forwardTime(10L, TimeUnit.SECONDS);
+    verify(requestObserver, times(4)).onNext(requestCaptor.capture());
+    request = requestCaptor.getValue();
+    clusterStats = Iterables.getOnlyElement(request.getClusterStatsList());
+    assertThat(clusterStats.getClusterName()).isEqualTo(CLUSTER1);
+    assertThat(clusterStats.getClusterServiceName()).isEqualTo(EDS_SERVICE_NAME1);
+    assertThat(Durations.toSeconds(clusterStats.getLoadReportInterval())).isEqualTo(20L);
+    assertThat(clusterStats.getDroppedRequestsCount()).isEqualTo(0);
+    localityStats = Iterables.getOnlyElement(clusterStats.getUpstreamLocalityStatsList());
+    assertThat(localityStats.getLocality().getRegion()).isEqualTo("region1");
+    assertThat(localityStats.getLocality().getZone()).isEqualTo("zone1");
+    assertThat(localityStats.getLocality().getSubZone()).isEqualTo("subZone1");
+    assertThat(localityStats.getTotalIssuedRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalErrorRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalRequestsInProgress()).isEqualTo(31L);
+    assertThat(localityStats.getLoadMetricStatsList()).isEmpty();
+
+    // Management server asks to report loads for all clusters.
+    responseObserver.onNext(LoadStatsResponse.newBuilder().setSendAllClusters(true)
+        .setLoadReportingInterval(Durations.fromSeconds(20L)).build());
+
+    fakeClock.forwardTime(20L, TimeUnit.SECONDS);
+    verify(requestObserver, times(5)).onNext(requestCaptor.capture());
+    request = requestCaptor.getValue();
+    assertThat(request.getClusterStatsCount()).isEqualTo(2);
+    ClusterStats clusterStats1 = findClusterStats(request.getClusterStatsList(), CLUSTER1);
+    assertThat(Durations.toSeconds(clusterStats1.getLoadReportInterval())).isEqualTo(20L);
+    assertThat(clusterStats1.getDroppedRequestsCount()).isEqualTo(0L);
+    assertThat(clusterStats1.getTotalDroppedRequests()).isEqualTo(0L);
+    UpstreamLocalityStats localityStats1 =
+        Iterables.getOnlyElement(clusterStats1.getUpstreamLocalityStatsList());
+    assertThat(localityStats1.getLocality().getRegion()).isEqualTo("region1");
+    assertThat(localityStats1.getLocality().getZone()).isEqualTo("zone1");
+    assertThat(localityStats1.getLocality().getSubZone()).isEqualTo("subZone1");
+    assertThat(localityStats1.getTotalIssuedRequests()).isEqualTo(0L);
+    assertThat(localityStats1.getTotalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(localityStats1.getTotalErrorRequests()).isEqualTo(0L);
+    assertThat(localityStats1.getTotalRequestsInProgress()).isEqualTo(31L);
+    assertThat(localityStats1.getLoadMetricStatsList()).isEmpty();
+    ClusterStats clusterStats2 = findClusterStats(request.getClusterStatsList(), CLUSTER2);
+    assertThat(Durations.toSeconds(clusterStats2.getLoadReportInterval()))
+        .isEqualTo(10L + 10L + 20L + 20L);
+    assertThat(Iterables.getOnlyElement(clusterStats2.getDroppedRequestsList()).getCategory())
+        .isEqualTo("throttle");
+    assertThat(Iterables.getOnlyElement(clusterStats2.getDroppedRequestsList()).getDroppedCount())
+        .isEqualTo(23L);
+    assertThat(clusterStats2.getTotalDroppedRequests()).isEqualTo(23L);
+    UpstreamLocalityStats localityStats2 =
+        Iterables.getOnlyElement(clusterStats2.getUpstreamLocalityStatsList());
+    assertThat(localityStats2.getLocality().getRegion()).isEqualTo("region2");
+    assertThat(localityStats2.getLocality().getZone()).isEqualTo("zone2");
+    assertThat(localityStats2.getLocality().getSubZone()).isEqualTo("subZone2");
+    assertThat(localityStats2.getTotalIssuedRequests()).isEqualTo(45L);
+    assertThat(localityStats2.getTotalSuccessfulRequests()).isEqualTo(1L);
+    assertThat(localityStats2.getTotalErrorRequests()).isEqualTo(0L);
+    assertThat(localityStats2.getTotalRequestsInProgress()).isEqualTo(45L - 1L);
+    assertThat(localityStats2.getLoadMetricStatsCount()).isEqualTo(1);
+    EndpointLoadMetricStats loadMetricStats2 = Iterables.getOnlyElement(
+        localityStats2.getLoadMetricStatsList());
+    assertThat(loadMetricStats2.getMetricName()).isEqualTo("named2");
+    assertThat(loadMetricStats2.getNumRequestsFinishedWithMetric()).isEqualTo(1L);
+    assertThat(loadMetricStats2.getTotalMetricValue()).isEqualTo(1.414);
+
+    // Load reports for cluster1 is no longer wanted.
+    responseObserver.onNext(LoadStatsResponse.newBuilder().addClusters(CLUSTER2)
+        .setLoadReportingInterval(Durations.fromSeconds(10L)).build());
+
+    fakeClock.forwardTime(10L, TimeUnit.SECONDS);
+    verify(requestObserver, times(6)).onNext(requestCaptor.capture());
+    request = requestCaptor.getValue();
+    clusterStats = Iterables.getOnlyElement(request.getClusterStatsList());
+    assertThat(clusterStats.getClusterName()).isEqualTo(CLUSTER2);
+    assertThat(clusterStats.getClusterServiceName()).isEqualTo(EDS_SERVICE_NAME2);
+    assertThat(Durations.toSeconds(clusterStats.getLoadReportInterval())).isEqualTo(10L);
+    assertThat(clusterStats.getDroppedRequestsCount()).isEqualTo(0L);
+    assertThat(clusterStats.getTotalDroppedRequests()).isEqualTo(0L);
+    localityStats = Iterables.getOnlyElement(clusterStats.getUpstreamLocalityStatsList());
+    assertThat(localityStats.getLocality().getRegion()).isEqualTo("region2");
+    assertThat(localityStats.getLocality().getZone()).isEqualTo("zone2");
+    assertThat(localityStats.getLocality().getSubZone()).isEqualTo("subZone2");
+    assertThat(localityStats.getTotalIssuedRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalErrorRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalRequestsInProgress()).isEqualTo(44L);
+    assertThat(localityStats.getLoadMetricStatsList()).isEmpty();
+
+    fakeClock.forwardTime(10L, TimeUnit.SECONDS);
+    verify(requestObserver, times(7)).onNext(requestCaptor.capture());
+    request = requestCaptor.getValue();
+    clusterStats = Iterables.getOnlyElement(request.getClusterStatsList());
+    assertThat(clusterStats.getClusterName()).isEqualTo(CLUSTER2);
+    assertThat(clusterStats.getClusterServiceName()).isEqualTo(EDS_SERVICE_NAME2);
+    assertThat(Durations.toSeconds(clusterStats.getLoadReportInterval())).isEqualTo(10L);
+    assertThat(clusterStats.getDroppedRequestsCount()).isEqualTo(0L);
+    assertThat(clusterStats.getTotalDroppedRequests()).isEqualTo(0L);
+    localityStats = Iterables.getOnlyElement(clusterStats.getUpstreamLocalityStatsList());
+    assertThat(localityStats.getLocality().getRegion()).isEqualTo("region2");
+    assertThat(localityStats.getLocality().getZone()).isEqualTo("zone2");
+    assertThat(localityStats.getLocality().getSubZone()).isEqualTo("subZone2");
+    assertThat(localityStats.getTotalIssuedRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalErrorRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalRequestsInProgress()).isEqualTo(44L);
+    assertThat(localityStats.getLoadMetricStatsList()).isEmpty();
+
+    // Management server asks loads for a cluster that client has no load data.
+    responseObserver.onNext(LoadStatsResponse.newBuilder().addClusters("unknown.googleapis.com")
+        .setLoadReportingInterval(Durations.fromSeconds(20L)).build());
+
+    fakeClock.forwardTime(20L, TimeUnit.SECONDS);
+    verify(requestObserver, times(8)).onNext(requestCaptor.capture());
+    assertThat(requestCaptor.getValue().getClusterStatsCount()).isEqualTo(0);
+  }
+
+  @Test
+  public void lrsStreamClosedAndRetried() {
+    InOrder inOrder = inOrder(mockLoadReportingService, backoffPolicyProvider, backoffPolicy1,
+        backoffPolicy2);
+    inOrder.verify(mockLoadReportingService).streamLoadStats(lrsResponseObserverCaptor.capture());
+    StreamObserver<LoadStatsResponse> responseObserver = lrsResponseObserverCaptor.getValue();
+    assertThat(lrsRequestObservers).hasSize(1);
+    StreamObserver<LoadStatsRequest> requestObserver = lrsRequestObservers.poll();
+
+    // First balancer RPC
+    verify(requestObserver).onNext(eq(buildInitialRequest()));
+    assertEquals(0, fakeClock.numPendingTasks(LRS_RPC_RETRY_TASK_FILTER));
+
+    // Balancer closes it immediately (erroneously)
+    responseObserver.onCompleted();
+
+    // Will start backoff sequence 1 (1s)
+    inOrder.verify(backoffPolicyProvider).get();
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+    assertEquals(1, fakeClock.numPendingTasks(LRS_RPC_RETRY_TASK_FILTER));
+
+    // Fast-forward to a moment before the retry
+    fakeClock.forwardNanos(TimeUnit.SECONDS.toNanos(1) - 1);
+    verifyNoMoreInteractions(mockLoadReportingService);
+    // Then time for retry
+    fakeClock.forwardNanos(1);
+    inOrder.verify(mockLoadReportingService).streamLoadStats(lrsResponseObserverCaptor.capture());
+    responseObserver = lrsResponseObserverCaptor.getValue();
+    assertThat(lrsRequestObservers).hasSize(1);
+    requestObserver = lrsRequestObservers.poll();
+    verify(requestObserver).onNext(eq(buildInitialRequest()));
+    assertEquals(0, fakeClock.numPendingTasks(LRS_RPC_RETRY_TASK_FILTER));
+
+    // Balancer closes it with an error.
+    responseObserver.onError(Status.UNAVAILABLE.asException());
+    // Will continue the backoff sequence 1 (10s)
+    verifyNoMoreInteractions(backoffPolicyProvider);
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+    assertEquals(1, fakeClock.numPendingTasks(LRS_RPC_RETRY_TASK_FILTER));
+
+    // Fast-forward to a moment before the retry
+    fakeClock.forwardNanos(TimeUnit.SECONDS.toNanos(10) - 1);
+    verifyNoMoreInteractions(mockLoadReportingService);
+    // Then time for retry
+    fakeClock.forwardNanos(1);
+    inOrder.verify(mockLoadReportingService).streamLoadStats(lrsResponseObserverCaptor.capture());
+    responseObserver = lrsResponseObserverCaptor.getValue();
+    assertThat(lrsRequestObservers).hasSize(1);
+    requestObserver = lrsRequestObservers.poll();
+    verify(requestObserver).onNext(eq(buildInitialRequest()));
+    assertEquals(0, fakeClock.numPendingTasks(LRS_RPC_RETRY_TASK_FILTER));
+
+    // Balancer sends a response asking for loads of the cluster.
+    responseObserver.onNext(LoadStatsResponse.newBuilder().addClusters(CLUSTER1)
+        .setLoadReportingInterval(Durations.fromNanos(5L)).build());
+
+    // Then breaks the RPC
+    responseObserver.onError(Status.UNAVAILABLE.asException());
+
+    // Will reset the retry sequence retry after a delay. We want to always delay, to restrict any
+    // accidental closed loop of retries to 1 QPS.
+    inOrder.verify(backoffPolicyProvider).get();
+    inOrder.verify(backoffPolicy2).nextBackoffNanos();
+    // Fast-forward to a moment before the retry of backoff sequence 2 (2s)
+    fakeClock.forwardNanos(TimeUnit.SECONDS.toNanos(2) - 1);
+    verifyNoMoreInteractions(mockLoadReportingService);
+    // Then time for retry
+    fakeClock.forwardNanos(1);
+    inOrder.verify(mockLoadReportingService).streamLoadStats(lrsResponseObserverCaptor.capture());
+    responseObserver = lrsResponseObserverCaptor.getValue();
+    assertThat(lrsRequestObservers).hasSize(1);
+    requestObserver = lrsRequestObservers.poll();
+    verify(requestObserver).onNext(eq(buildInitialRequest()));
+
+    // Fail the retry after spending 4ns
+    fakeClock.forwardNanos(4);
+    responseObserver.onError(Status.UNAVAILABLE.asException());
+
+    // Will be on the second retry (20s) of backoff sequence 2.
+    inOrder.verify(backoffPolicy2).nextBackoffNanos();
+    assertEquals(1, fakeClock.numPendingTasks(LRS_RPC_RETRY_TASK_FILTER));
+
+    // Fast-forward to a moment before the retry, the time spent in the last try is deducted.
+    fakeClock.forwardNanos(TimeUnit.SECONDS.toNanos(20) - 4 - 1);
+    verifyNoMoreInteractions(mockLoadReportingService);
+    // Then time for retry
+    fakeClock.forwardNanos(1);
+    inOrder.verify(mockLoadReportingService).streamLoadStats(lrsResponseObserverCaptor.capture());
+    assertThat(lrsRequestObservers).hasSize(1);
+    requestObserver = lrsRequestObservers.poll();
+    verify(requestObserver).onNext(eq(buildInitialRequest()));
+    assertEquals(0, fakeClock.numPendingTasks(LRS_RPC_RETRY_TASK_FILTER));
+
+    // Load reporting back to normal.
+    responseObserver = lrsResponseObserverCaptor.getValue();
+    responseObserver.onNext(LoadStatsResponse.newBuilder().addClusters(CLUSTER1)
+        .setLoadReportingInterval(Durations.fromNanos(10L)).build());
+    fakeClock.forwardNanos(10);
+    verify(requestObserver, times(2)).onNext(requestCaptor.capture());
+    LoadStatsRequest request = requestCaptor.getValue();
+    ClusterStats clusterStats = Iterables.getOnlyElement(request.getClusterStatsList());
+    assertThat(clusterStats.getClusterName()).isEqualTo(CLUSTER1);
+    assertThat(clusterStats.getClusterServiceName()).isEqualTo(EDS_SERVICE_NAME1);
+    assertThat(Durations.toSeconds(clusterStats.getLoadReportInterval()))
+        .isEqualTo(1L + 10L + 2L + 20L);
+    assertThat(Iterables.getOnlyElement(clusterStats.getDroppedRequestsList()).getCategory())
+        .isEqualTo("lb");
+    assertThat(Iterables.getOnlyElement(clusterStats.getDroppedRequestsList()).getDroppedCount())
+        .isEqualTo(52L);
+    assertThat(clusterStats.getTotalDroppedRequests()).isEqualTo(52L);
+    UpstreamLocalityStats localityStats =
+        Iterables.getOnlyElement(clusterStats.getUpstreamLocalityStatsList());
+    assertThat(localityStats.getLocality().getRegion()).isEqualTo("region1");
+    assertThat(localityStats.getLocality().getZone()).isEqualTo("zone1");
+    assertThat(localityStats.getLocality().getSubZone()).isEqualTo("subZone1");
+    assertThat(localityStats.getTotalIssuedRequests()).isEqualTo(31L);
+    assertThat(localityStats.getTotalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalErrorRequests()).isEqualTo(0L);
+    assertThat(localityStats.getTotalRequestsInProgress()).isEqualTo(31L);
+    assertThat(localityStats.getLoadMetricStatsCount()).isEqualTo(1);
+    EndpointLoadMetricStats loadMetricStats = Iterables.getOnlyElement(
+        localityStats.getLoadMetricStatsList());
+    assertThat(loadMetricStats.getMetricName()).isEqualTo("named1");
+    assertThat(loadMetricStats.getNumRequestsFinishedWithMetric()).isEqualTo(3L);
+    assertThat(loadMetricStats.getTotalMetricValue()).isEqualTo(3.14159 + 1.618 - 2.718);
+
+    // Wrapping up
+    verify(backoffPolicyProvider, times(2)).get();
+    verify(backoffPolicy1, times(2)).nextBackoffNanos();
+    verify(backoffPolicy2, times(2)).nextBackoffNanos();
+  }
+
+  @Test
+  public void raceBetweenStopAndLoadReporting() {
+    verify(mockLoadReportingService).streamLoadStats(lrsResponseObserverCaptor.capture());
+    StreamObserver<LoadStatsResponse> responseObserver = lrsResponseObserverCaptor.getValue();
+    StreamObserver<LoadStatsRequest> requestObserver =
+        Iterables.getOnlyElement(lrsRequestObservers);
+    verify(requestObserver).onNext(eq(buildInitialRequest()));
+
+    responseObserver.onNext(LoadStatsResponse.newBuilder().addClusters(CLUSTER1)
+        .setLoadReportingInterval(Durations.fromNanos(1234L)).build());
+    assertEquals(1, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    FakeClock.ScheduledTask scheduledTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    assertEquals(1234, scheduledTask.getDelay(TimeUnit.NANOSECONDS));
+
+    fakeClock.forwardNanos(1233);
+    stopLoadReportingInSyncContext();
+    verify(requestObserver).onError(errorCaptor.capture());
+    assertEquals("CANCELLED: client cancelled", errorCaptor.getValue().getMessage());
+    assertThat(scheduledTask.isCancelled()).isTrue();
+    fakeClock.forwardNanos(1);
+    assertEquals(0, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    fakeClock.forwardNanos(1234);
+    verifyNoMoreInteractions(requestObserver);
+  }
+
+  @Test
+  public void raceBetweenStopAndLrsStreamRetry() {
+    verify(mockLoadReportingService).streamLoadStats(lrsResponseObserverCaptor.capture());
+    StreamObserver<LoadStatsResponse> responseObserver = lrsResponseObserverCaptor.getValue();
+    StreamObserver<LoadStatsRequest> requestObserver =
+        Iterables.getOnlyElement(lrsRequestObservers);
+    verify(requestObserver).onNext(eq(buildInitialRequest()));
+
+    responseObserver.onCompleted();
+    assertEquals(1, fakeClock.numPendingTasks(LRS_RPC_RETRY_TASK_FILTER));
+    FakeClock.ScheduledTask scheduledTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(LRS_RPC_RETRY_TASK_FILTER));
+    assertEquals(1, scheduledTask.getDelay(TimeUnit.SECONDS));
+
+    fakeClock.forwardTime(999, TimeUnit.MILLISECONDS);
+    stopLoadReportingInSyncContext();
+    assertThat(scheduledTask.isCancelled()).isTrue();
+    fakeClock.forwardTime(1, TimeUnit.MILLISECONDS);
+    assertEquals(0, fakeClock.numPendingTasks(LRS_RPC_RETRY_TASK_FILTER));
+    fakeClock.forwardTime(10, TimeUnit.SECONDS);
+    verifyNoMoreInteractions(requestObserver);
+  }
+
+  @Test
+  public void raceBetweenLoadReportingAndLrsStreamClosure() {
+    verify(mockLoadReportingService).streamLoadStats(lrsResponseObserverCaptor.capture());
+    StreamObserver<LoadStatsResponse> responseObserver = lrsResponseObserverCaptor.getValue();
+    assertThat(lrsRequestObservers).hasSize(1);
+    StreamObserver<LoadStatsRequest> requestObserver = lrsRequestObservers.poll();
+
+    // First balancer RPC
+    verify(requestObserver).onNext(eq(buildInitialRequest()));
+    assertEquals(0, fakeClock.numPendingTasks(LRS_RPC_RETRY_TASK_FILTER));
+
+    // Simulate receiving a response from traffic director.
+    assertEquals(0, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    responseObserver.onNext(LoadStatsResponse.newBuilder().addClusters(CLUSTER1)
+        .setLoadReportingInterval(Durations.fromNanos(1983L)).build());
+    // Load reporting task is scheduled
+    assertEquals(1, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    FakeClock.ScheduledTask scheduledTask =
+        Iterables.getOnlyElement(fakeClock.getPendingTasks(LOAD_REPORTING_TASK_FILTER));
+    assertEquals(1983, scheduledTask.getDelay(TimeUnit.NANOSECONDS));
+
+    // Close RPC stream.
+    responseObserver.onCompleted();
+
+    // Reporting task cancelled
+    assertEquals(0, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+
+    // Simulate a race condition where the task has just started when its cancelled
+    scheduledTask.command.run();
+
+    // No report sent. No new task scheduled
+    verifyNoMoreInteractions(requestObserver);
+    assertEquals(0, fakeClock.numPendingTasks(LOAD_REPORTING_TASK_FILTER));
+  }
+
+  private void stopLoadReportingInSyncContext() {
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        lrsClient.stopLoadReporting();
+      }
+    });
+  }
+
+  private static LoadStatsRequest buildInitialRequest() {
+    return
+        LoadStatsRequest.newBuilder()
+            .setNode(
+                Node.newBuilder()
+                    .setId("LRS test")
+                    .addClientFeatures("envoy.lrs.supports_send_all_clusters")
+                    .setMetadata(
+                        Struct.newBuilder()
+                            .putFields(
+                                "TRAFFICDIRECTOR_NETWORK_HOSTNAME",
+                                Value.newBuilder().setStringValue("default").build())))
+            .build();
+  }
+
+  private ClusterStats findClusterStats(List<ClusterStats> clusterStatsList, String clusterName) {
+    for (ClusterStats stats : clusterStatsList) {
+      if (stats.getClusterName().equals(clusterName)) {
+        return stats;
+      }
+    }
+    return null;
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/MessagePrinterTest.java b/xds/src/test/java/io/grpc/xds/MessagePrinterTest.java
new file mode 100644
index 00000000000..6d8904b4a4f
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/MessagePrinterTest.java
@@ -0,0 +1,361 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.protobuf.Any;
+import com.google.protobuf.UInt32Value;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.EdsClusterConfig;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster.LbPolicy;
+import io.envoyproxy.envoy.config.core.v3.Address;
+import io.envoyproxy.envoy.config.core.v3.AggregatedConfigSource;
+import io.envoyproxy.envoy.config.core.v3.ConfigSource;
+import io.envoyproxy.envoy.config.core.v3.HealthStatus;
+import io.envoyproxy.envoy.config.core.v3.Locality;
+import io.envoyproxy.envoy.config.core.v3.SelfConfigSource;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress;
+import io.envoyproxy.envoy.config.core.v3.TransportSocket;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment.Policy;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment.Policy.DropOverload;
+import io.envoyproxy.envoy.config.endpoint.v3.Endpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints;
+import io.envoyproxy.envoy.config.listener.v3.ApiListener;
+import io.envoyproxy.envoy.config.listener.v3.Filter;
+import io.envoyproxy.envoy.config.listener.v3.FilterChain;
+import io.envoyproxy.envoy.config.listener.v3.Listener;
+import io.envoyproxy.envoy.config.route.v3.Route;
+import io.envoyproxy.envoy.config.route.v3.RouteAction;
+import io.envoyproxy.envoy.config.route.v3.RouteConfiguration;
+import io.envoyproxy.envoy.config.route.v3.RouteMatch;
+import io.envoyproxy.envoy.config.route.v3.VirtualHost;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.Rds;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.SdsSecretConfig;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext;
+import io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse;
+import io.envoyproxy.envoy.type.v3.FractionalPercent;
+import io.envoyproxy.envoy.type.v3.FractionalPercent.DenominatorType;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link MessagePrinter}.
+ */
+@RunWith(JUnit4.class)
+public class MessagePrinterTest {
+
+  @Test
+  public void printLdsResponse_v3() {
+    Listener listener =
+        Listener.newBuilder().setName("foo.googleapis.com:8080")
+            .setAddress(
+                Address.newBuilder()
+                    .setSocketAddress(
+                        SocketAddress.newBuilder().setAddress("10.0.0.1").setPortValue(8080)))
+            .addFilterChains(
+                FilterChain.newBuilder()
+                    .addFilters(Filter.getDefaultInstance())
+                    .setTransportSocket(
+                        TransportSocket.newBuilder()
+                            .setName("envoy.transport_sockets.tls")
+                            .setTypedConfig(
+                                Any.pack(
+                                    DownstreamTlsContext.newBuilder()
+                                        .setCommonTlsContext(
+                                            CommonTlsContext.newBuilder()
+                                                .addTlsCertificateSdsSecretConfigs(
+                                                    SdsSecretConfig.getDefaultInstance()))
+                                        .build()))))
+            .setApiListener(
+                ApiListener.newBuilder()
+                    .setApiListener(
+                        Any.pack(HttpConnectionManager.newBuilder()
+                            .setRds(
+                                Rds.newBuilder()
+                                    .setRouteConfigName("route-foo.googleapis.com")
+                                    .setConfigSource(
+                                        ConfigSource.newBuilder().setAds(
+                                            AggregatedConfigSource.getDefaultInstance())))
+                            .build())))
+            .build();
+    DiscoveryResponse response =
+        DiscoveryResponse.newBuilder()
+            .setTypeUrl("type.googleapis.com/envoy.config.listener.v3.Listener")
+            .setVersionInfo("0")
+            .addResources(Any.pack(listener))
+            .setNonce("0000")
+            .build();
+
+    String expectedString = "{\n"
+        + "  \"versionInfo\": \"0\",\n"
+        + "  \"resources\": [{\n"
+        + "    \"@type\": \"type.googleapis.com/envoy.config.listener.v3.Listener\",\n"
+        + "    \"name\": \"foo.googleapis.com:8080\",\n"
+        + "    \"address\": {\n"
+        + "      \"socketAddress\": {\n"
+        + "        \"address\": \"10.0.0.1\",\n"
+        + "        \"portValue\": 8080\n"
+        + "      }\n"
+        + "    },\n"
+        + "    \"filterChains\": [{\n"
+        + "      \"filters\": [{\n"
+        + "      }],\n"
+        + "      \"transportSocket\": {\n"
+        + "        \"name\": \"envoy.transport_sockets.tls\",\n"
+        + "        \"typedConfig\": {\n"
+        + "          \"@type\": \"type.googleapis.com/envoy.extensions.transport_sockets"
+        + ".tls.v3.DownstreamTlsContext\",\n"
+        + "          \"commonTlsContext\": {\n"
+        + "            \"tlsCertificateSdsSecretConfigs\": [{\n"
+        + "            }]\n"
+        + "          }\n"
+        + "        }\n"
+        + "      }\n"
+        + "    }],\n"
+        + "    \"apiListener\": {\n"
+        + "      \"apiListener\": {\n"
+        + "        \"@type\": \"type.googleapis.com/envoy.extensions.filters.network"
+        + ".http_connection_manager.v3.HttpConnectionManager\",\n"
+        + "        \"rds\": {\n"
+        + "          \"configSource\": {\n"
+        + "            \"ads\": {\n"
+        + "            }\n"
+        + "          },\n"
+        + "          \"routeConfigName\": \"route-foo.googleapis.com\"\n"
+        + "        }\n"
+        + "      }\n"
+        + "    }\n"
+        + "  }],\n"
+        + "  \"typeUrl\": \"type.googleapis.com/envoy.config.listener.v3.Listener\",\n"
+        + "  \"nonce\": \"0000\"\n"
+        + "}";
+    String res = MessagePrinter.INSTANCE.print(response);
+    assertThat(res).isEqualTo(expectedString);
+  }
+
+  @Test
+  public void printRdsResponse_v3() {
+    RouteConfiguration routeConfiguration =
+        RouteConfiguration.newBuilder()
+            .setName("route-foo.googleapis.com")
+            .addVirtualHosts(
+                VirtualHost.newBuilder()
+                    .setName("virtualhost.googleapis.com")
+                    .addDomains("foo.googleapis.com")
+                    .addDomains("bar.googleapis.com")
+                    .addRoutes(
+                        Route.newBuilder()
+                            .setMatch(
+                                RouteMatch.newBuilder().setPath("foo.googleapis.com"))
+                            .setRoute(
+                                RouteAction.newBuilder()
+                                    .setCluster("cluster.googleapis.com"))))
+            .build();
+    DiscoveryResponse response =
+        DiscoveryResponse.newBuilder()
+            .setTypeUrl("type.googleapis.com/envoy.config.route.v3.RouteConfiguration")
+            .setVersionInfo("0")
+            .addResources(Any.pack(routeConfiguration))
+            .setNonce("0000")
+            .build();
+
+    String expectedString = "{\n"
+        + "  \"versionInfo\": \"0\",\n"
+        + "  \"resources\": [{\n"
+        + "    \"@type\": \"type.googleapis.com/envoy.config.route.v3.RouteConfiguration\",\n"
+        + "    \"name\": \"route-foo.googleapis.com\",\n"
+        + "    \"virtualHosts\": [{\n"
+        + "      \"name\": \"virtualhost.googleapis.com\",\n"
+        + "      \"domains\": [\"foo.googleapis.com\", \"bar.googleapis.com\"],\n"
+        + "      \"routes\": [{\n"
+        + "        \"match\": {\n"
+        + "          \"path\": \"foo.googleapis.com\"\n"
+        + "        },\n"
+        + "        \"route\": {\n"
+        + "          \"cluster\": \"cluster.googleapis.com\"\n"
+        + "        }\n"
+        + "      }]\n"
+        + "    }]\n"
+        + "  }],\n"
+        + "  \"typeUrl\": \"type.googleapis.com/envoy.config.route.v3.RouteConfiguration\",\n"
+        + "  \"nonce\": \"0000\"\n"
+        + "}";
+    String res = MessagePrinter.INSTANCE.print(response);
+    assertThat(res).isEqualTo(expectedString);
+  }
+
+  @Test
+  public void printCdsResponse_v3() {
+    Cluster cluster =
+        Cluster.newBuilder()
+            .setName("cluster-foo.googleapis.com")
+            .setEdsClusterConfig(
+                EdsClusterConfig.newBuilder()
+                    .setServiceName("backend-service-foo.googleapis.com")
+                    .setEdsConfig(
+                        ConfigSource.newBuilder()
+                            .setAds(AggregatedConfigSource.getDefaultInstance())))
+            .setLrsServer(ConfigSource.newBuilder().setSelf(SelfConfigSource.getDefaultInstance()))
+            .setLbPolicy(LbPolicy.ROUND_ROBIN)
+            .setTransportSocket(
+                TransportSocket.newBuilder()
+                    .setTypedConfig(
+                        Any.pack(
+                            UpstreamTlsContext.newBuilder()
+                                .setCommonTlsContext(
+                                    CommonTlsContext.newBuilder()
+                                        .addTlsCertificateSdsSecretConfigs(
+                                            SdsSecretConfig.getDefaultInstance())).build())))
+            .build();
+    DiscoveryResponse response =
+        DiscoveryResponse.newBuilder()
+            .setTypeUrl("type.googleapis.com/envoy.config.cluster.v3.Cluster")
+            .setVersionInfo("0")
+            .addResources(Any.pack(cluster))
+            .setNonce("0000")
+            .build();
+
+    String expectedString = "{\n"
+        + "  \"versionInfo\": \"0\",\n"
+        + "  \"resources\": [{\n"
+        + "    \"@type\": \"type.googleapis.com/envoy.config.cluster.v3.Cluster\",\n"
+        + "    \"name\": \"cluster-foo.googleapis.com\",\n"
+        + "    \"edsClusterConfig\": {\n"
+        + "      \"edsConfig\": {\n"
+        + "        \"ads\": {\n"
+        + "        }\n"
+        + "      },\n"
+        + "      \"serviceName\": \"backend-service-foo.googleapis.com\"\n"
+        + "    },\n"
+        + "    \"transportSocket\": {\n"
+        + "      \"typedConfig\": {\n"
+        + "        \"@type\": \"type.googleapis.com/envoy.extensions.transport_sockets.tls.v3"
+        + ".UpstreamTlsContext\",\n"
+        + "        \"commonTlsContext\": {\n"
+        + "          \"tlsCertificateSdsSecretConfigs\": [{\n"
+        + "          }]\n"
+        + "        }\n"
+        + "      }\n"
+        + "    },\n"
+        + "    \"lrsServer\": {\n"
+        + "      \"self\": {\n"
+        + "      }\n"
+        + "    }\n"
+        + "  }],\n"
+        + "  \"typeUrl\": \"type.googleapis.com/envoy.config.cluster.v3.Cluster\",\n"
+        + "  \"nonce\": \"0000\"\n"
+        + "}";
+    String res = MessagePrinter.INSTANCE.print(response);
+    assertThat(res).isEqualTo(expectedString);
+  }
+
+  @Test
+  public void printEdsResponse_v3() {
+    ClusterLoadAssignment clusterLoadAssignment =
+        ClusterLoadAssignment.newBuilder()
+            .setClusterName("cluster-foo.googleapis.com")
+            .setPolicy(
+                Policy.newBuilder()
+                    .addDropOverloads(
+                        DropOverload.newBuilder()
+                            .setCategory("throttle")
+                            .setDropPercentage(
+                                FractionalPercent.newBuilder()
+                                    .setNumerator(80)
+                                    .setDenominator(DenominatorType.HUNDRED))))
+            .addEndpoints(
+                LocalityLbEndpoints.newBuilder()
+                    .setLocality(
+                        Locality.newBuilder()
+                            .setRegion("region")
+                            .setZone("zone")
+                            .setSubZone("subzone")).setPriority(1)
+                    .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(20))
+                    .addLbEndpoints(
+                        LbEndpoint.newBuilder()
+                            .setLoadBalancingWeight(UInt32Value.newBuilder().setValue(100))
+                            .setHealthStatus(HealthStatus.UNHEALTHY)
+                            .setEndpoint(
+                                Endpoint.newBuilder()
+                                    .setAddress(
+                                        Address.newBuilder()
+                                            .setSocketAddress(
+                                                SocketAddress.newBuilder()
+                                                    .setAddress("10.0.0.1")
+                                                    .setPortValue(8001))))))
+            .build();
+
+
+    DiscoveryResponse response =
+        DiscoveryResponse.newBuilder()
+            .setTypeUrl("type.googleapis.com/envoy.config.endpoint.v3.ClusterLoadAssignment")
+            .setVersionInfo("0")
+            .addResources(Any.pack(clusterLoadAssignment))
+            .setNonce("0000")
+            .build();
+
+    String expectedString = "{\n"
+        + "  \"versionInfo\": \"0\",\n"
+        + "  \"resources\": [{\n"
+        + "    \"@type\": \"type.googleapis.com/envoy.config.endpoint.v3"
+        + ".ClusterLoadAssignment\",\n"
+        + "    \"clusterName\": \"cluster-foo.googleapis.com\",\n"
+        + "    \"endpoints\": [{\n"
+        + "      \"locality\": {\n"
+        + "        \"region\": \"region\",\n"
+        + "        \"zone\": \"zone\",\n"
+        + "        \"subZone\": \"subzone\"\n"
+        + "      },\n"
+        + "      \"lbEndpoints\": [{\n"
+        + "        \"endpoint\": {\n"
+        + "          \"address\": {\n"
+        + "            \"socketAddress\": {\n"
+        + "              \"address\": \"10.0.0.1\",\n"
+        + "              \"portValue\": 8001\n"
+        + "            }\n"
+        + "          }\n"
+        + "        },\n"
+        + "        \"healthStatus\": \"UNHEALTHY\",\n"
+        + "        \"loadBalancingWeight\": 100\n"
+        + "      }],\n"
+        + "      \"loadBalancingWeight\": 20,\n"
+        + "      \"priority\": 1\n"
+        + "    }],\n"
+        + "    \"policy\": {\n"
+        + "      \"dropOverloads\": [{\n"
+        + "        \"category\": \"throttle\",\n"
+        + "        \"dropPercentage\": {\n"
+        + "          \"numerator\": 80\n"
+        + "        }\n"
+        + "      }]\n"
+        + "    }\n"
+        + "  }],\n"
+        + "  \"typeUrl\": \"type.googleapis.com/envoy.config.endpoint.v3"
+        + ".ClusterLoadAssignment\",\n"
+        + "  \"nonce\": \"0000\"\n"
+        + "}";
+    String res = MessagePrinter.INSTANCE.print(response);
+    assertThat(res).isEqualTo(expectedString);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/MetadataLoadBalancerProvider.java b/xds/src/test/java/io/grpc/xds/MetadataLoadBalancerProvider.java
new file mode 100644
index 00000000000..7b56f59451c
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/MetadataLoadBalancerProvider.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2022 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.xds;
+
+import io.grpc.ConnectivityState;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.Metadata;
+import io.grpc.NameResolver;
+import io.grpc.Status;
+import io.grpc.internal.JsonUtil;
+import io.grpc.util.ForwardingLoadBalancer;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import java.util.Map;
+import javax.annotation.Nonnull;
+
+/**
+ * A custom LB for testing purposes that simply delegates to round_robin and adds a metadata entry
+ * to each request.
+ */
+public class MetadataLoadBalancerProvider extends LoadBalancerProvider {
+
+  @Override
+  public NameResolver.ConfigOrError parseLoadBalancingPolicyConfig(
+      Map<String, ?> rawLoadBalancingPolicyConfig) {
+    String metadataKey = JsonUtil.getString(rawLoadBalancingPolicyConfig, "metadataKey");
+    if (metadataKey == null) {
+      return NameResolver.ConfigOrError.fromError(
+          Status.UNAVAILABLE.withDescription("no 'metadataKey' defined"));
+    }
+
+    String metadataValue = JsonUtil.getString(rawLoadBalancingPolicyConfig, "metadataValue");
+    if (metadataValue == null) {
+      return NameResolver.ConfigOrError.fromError(
+          Status.UNAVAILABLE.withDescription("no 'metadataValue' defined"));
+    }
+
+    return NameResolver.ConfigOrError.fromConfig(
+        new MetadataLoadBalancerConfig(metadataKey, metadataValue));
+  }
+
+  @Override
+  public LoadBalancer newLoadBalancer(Helper helper) {
+    MetadataHelper metadataHelper = new MetadataHelper(helper);
+    return new MetadataLoadBalancer(metadataHelper,
+        LoadBalancerRegistry.getDefaultRegistry().getProvider("round_robin")
+            .newLoadBalancer(metadataHelper));
+  }
+
+  @Override
+  public boolean isAvailable() {
+    return true;
+  }
+
+  @Override
+  public int getPriority() {
+    return 5;
+  }
+
+  @Override
+  public String getPolicyName() {
+    return "test.MetadataLoadBalancer";
+  }
+
+  static class MetadataLoadBalancerConfig {
+
+    final String metadataKey;
+    final String metadataValue;
+
+    MetadataLoadBalancerConfig(String metadataKey, String metadataValue) {
+      this.metadataKey = metadataKey;
+      this.metadataValue = metadataValue;
+    }
+  }
+
+  static class MetadataLoadBalancer extends ForwardingLoadBalancer {
+
+    private final MetadataHelper helper;
+    private final LoadBalancer delegateLb;
+
+    MetadataLoadBalancer(MetadataHelper helper, LoadBalancer delegateLb) {
+      this.helper = helper;
+      this.delegateLb = delegateLb;
+    }
+
+    @Override
+    protected LoadBalancer delegate() {
+      return delegateLb;
+    }
+
+    @Override
+    public void handleResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      MetadataLoadBalancerConfig config
+          = (MetadataLoadBalancerConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+      helper.setMetadata(config.metadataKey, config.metadataValue);
+      delegateLb.handleResolvedAddresses(resolvedAddresses);
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      MetadataLoadBalancerConfig config
+          = (MetadataLoadBalancerConfig) resolvedAddresses.getLoadBalancingPolicyConfig();
+      helper.setMetadata(config.metadataKey, config.metadataValue);
+      return delegateLb.acceptResolvedAddresses(resolvedAddresses);
+    }
+  }
+
+  /**
+   * Wraps the picker that is provided when the balancing change updates with the {@link
+   * MetadataPicker} that injects the metadata entry.
+   */
+  static class MetadataHelper extends ForwardingLoadBalancerHelper {
+
+    private final Helper delegateHelper;
+    private String metadataKey;
+    private String metadataValue;
+
+    MetadataHelper(Helper delegateHelper) {
+      this.delegateHelper = delegateHelper;
+    }
+
+    void setMetadata(String metadataKey, String metadataValue) {
+      this.metadataKey = metadataKey;
+      this.metadataValue = metadataValue;
+    }
+
+    @Override
+    protected Helper delegate() {
+      return delegateHelper;
+    }
+
+    @Override
+    public void updateBalancingState(@Nonnull ConnectivityState newState,
+        @Nonnull SubchannelPicker newPicker) {
+      delegateHelper.updateBalancingState(newState,
+          new MetadataPicker(newPicker, metadataKey, metadataValue));
+    }
+  }
+
+  /**
+   * Includes the rpc-behavior metadata entry on each subchannel pick.
+   */
+  static class MetadataPicker extends SubchannelPicker {
+
+    private final SubchannelPicker delegatePicker;
+    private final String metadataKey;
+    private final String metadataValue;
+
+    MetadataPicker(SubchannelPicker delegatePicker, String metadataKey, String metadataValue) {
+      this.delegatePicker = delegatePicker;
+      this.metadataKey = metadataKey;
+      this.metadataValue = metadataValue;
+    }
+
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      args.getHeaders()
+          .put(Metadata.Key.of(metadataKey, Metadata.ASCII_STRING_MARSHALLER), metadataValue);
+      return delegatePicker.pickSubchannel(args);
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/PriorityLoadBalancerProviderTest.java b/xds/src/test/java/io/grpc/xds/PriorityLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..37ea24b2aa9
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/PriorityLoadBalancerProviderTest.java
@@ -0,0 +1,69 @@
+/*
+ * 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.xds;
+
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.mock;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig;
+import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig.PriorityChildConfig;
+import java.util.List;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link PriorityLoadBalancerProvider}. */
+@RunWith(JUnit4.class)
+public class PriorityLoadBalancerProviderTest {
+
+  @SuppressWarnings("ExpectedExceptionChecker")
+  @Test
+  public void priorityLbConfig_emptyPriorities() {
+    Map<String, PriorityChildConfig> childConfigs =
+        ImmutableMap.of(
+            "p0",
+            new PriorityChildConfig(
+                newChildConfig(mock(LoadBalancerProvider.class), null), true));
+    List<String> priorities = ImmutableList.of();
+
+    assertThrows(IllegalArgumentException.class,
+        () -> new PriorityLbConfig(childConfigs, priorities));
+  }
+
+  @SuppressWarnings("ExpectedExceptionChecker")
+  @Test
+  public void priorityLbConfig_missingChildConfig() {
+    Map<String, PriorityChildConfig> childConfigs =
+        ImmutableMap.of(
+            "p1",
+            new PriorityChildConfig(
+                newChildConfig(mock(LoadBalancerProvider.class), null), true));
+    List<String> priorities = ImmutableList.of("p0", "p1");
+
+    assertThrows(IllegalArgumentException.class,
+        () -> new PriorityLbConfig(childConfigs, priorities));
+  }
+
+  private Object newChildConfig(LoadBalancerProvider provider, Object config) {
+    return GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(provider, config);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/PriorityLoadBalancerTest.java b/xds/src/test/java/io/grpc/xds/PriorityLoadBalancerTest.java
new file mode 100644
index 00000000000..beb568be9ce
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/PriorityLoadBalancerTest.java
@@ -0,0 +1,1042 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static io.grpc.LoadBalancerMatchers.pickerReturns;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import io.grpc.Attributes;
+import io.grpc.ConnectivityState;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.FixedResultPicker;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.TestUtils.StandardLoadBalancerProvider;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig;
+import io.grpc.xds.PriorityLoadBalancerProvider.PriorityLbConfig.PriorityChildConfig;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Tests for {@link PriorityLoadBalancer}. */
+@RunWith(JUnit4.class)
+public class PriorityLoadBalancerTest {
+  private static final SubchannelPicker EMPTY_PICKER
+      = new FixedResultPicker(PickResult.withNoResult());
+
+  private final List<LoadBalancer> fooBalancers = new ArrayList<>();
+  private final List<LoadBalancer> barBalancers = new ArrayList<>();
+  private final List<Helper> fooHelpers = new ArrayList<>();
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final FakeClock fakeClock = new FakeClock();
+
+  private final LoadBalancerProvider fooLbProvider =
+      new StandardLoadBalancerProvider("foo_policy") {
+        @Override
+        public LoadBalancer newLoadBalancer(Helper helper) {
+          fooHelpers.add(helper);
+          LoadBalancer childBalancer = mock(LoadBalancer.class);
+          when(childBalancer.acceptResolvedAddresses(any(ResolvedAddresses.class)))
+              .thenReturn(Status.OK);
+          fooBalancers.add(childBalancer);
+          return childBalancer;
+        }
+      };
+
+  private final LoadBalancerProvider barLbProvider =
+      new StandardLoadBalancerProvider("bar_policy") {
+        @Override
+        public LoadBalancer newLoadBalancer(Helper helper) {
+          LoadBalancer childBalancer = mock(LoadBalancer.class);
+          when(childBalancer.acceptResolvedAddresses(any(ResolvedAddresses.class)))
+              .thenReturn(Status.OK);
+          barBalancers.add(childBalancer);
+          return childBalancer;
+        }
+      };
+
+  @Rule public final MockitoRule mockitoRule = MockitoJUnit.rule();
+  @Mock private Helper helper;
+  @Captor ArgumentCaptor<ResolvedAddresses> resolvedAddressesCaptor;
+  @Captor ArgumentCaptor<ConnectivityState> connectivityStateCaptor;
+  @Captor ArgumentCaptor<SubchannelPicker> pickerCaptor;
+
+  private PriorityLoadBalancer priorityLb;
+
+  @Before
+  public void setUp() {
+    doReturn(syncContext).when(helper).getSynchronizationContext();
+    doReturn(fakeClock.getScheduledExecutorService()).when(helper).getScheduledExecutorService();
+    priorityLb = new PriorityLoadBalancer(helper);
+    clearInvocations(helper);
+  }
+
+  @After
+  public void tearDown() {
+    priorityLb.shutdown();
+    for (LoadBalancer lb : fooBalancers) {
+      verify(lb).shutdown();
+    }
+    for (LoadBalancer lb : barBalancers) {
+      verify(lb).shutdown();
+    }
+    assertThat(fakeClock.getPendingTasks()).isEmpty();
+  }
+
+  @Test
+  public void acceptResolvedAddresses() {
+    SocketAddress socketAddress = new InetSocketAddress(8080);
+    EquivalentAddressGroup eag = new EquivalentAddressGroup(socketAddress);
+    eag = AddressFilter.setPathFilter(eag, ImmutableList.of("p1"));
+    List<EquivalentAddressGroup> addresses = ImmutableList.of(eag);
+    Attributes attributes =
+        Attributes.newBuilder().set(Attributes.Key.create("fakeKey"), "fakeValue").build();
+    Object fooConfig0 = new Object();
+    PriorityChildConfig priorityChildConfig0 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, fooConfig0), true);
+    Object barConfig0 = new Object();
+    PriorityChildConfig priorityChildConfig1 =
+        new PriorityChildConfig(newChildConfig(barLbProvider, barConfig0), true);
+    Object fooConfig1 = new Object();
+    PriorityChildConfig priorityChildConfig2 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, fooConfig1), true);
+    PriorityLbConfig priorityLbConfig =
+        new PriorityLbConfig(
+            ImmutableMap.of("p0", priorityChildConfig0, "p1", priorityChildConfig1,
+                "p2", priorityChildConfig2),
+            ImmutableList.of("p0", "p1", "p2"));
+    Status status = priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(addresses)
+            .setAttributes(attributes)
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .build());
+    assertThat(status.getCode()).isEqualTo(Status.Code.OK);
+    assertThat(fooBalancers).hasSize(1);
+    assertThat(barBalancers).isEmpty();
+    LoadBalancer fooBalancer0 = Iterables.getOnlyElement(fooBalancers);
+    verify(fooBalancer0).acceptResolvedAddresses(resolvedAddressesCaptor.capture());
+    ResolvedAddresses addressesReceived = resolvedAddressesCaptor.getValue();
+    assertThat(addressesReceived.getAddresses()).isEmpty();
+    assertThat(addressesReceived.getAttributes()).isEqualTo(attributes);
+    assertThat(addressesReceived.getLoadBalancingPolicyConfig()).isEqualTo(fooConfig0);
+
+    // Fail over to p1.
+    fakeClock.forwardTime(10, TimeUnit.SECONDS);
+    assertThat(fooBalancers).hasSize(1);
+    assertThat(barBalancers).hasSize(1);
+    LoadBalancer barBalancer0 = Iterables.getOnlyElement(barBalancers);
+    verify(barBalancer0).acceptResolvedAddresses(resolvedAddressesCaptor.capture());
+    addressesReceived = resolvedAddressesCaptor.getValue();
+    assertThat(Iterables.getOnlyElement(addressesReceived.getAddresses()).getAddresses())
+        .containsExactly(socketAddress);
+    assertThat(addressesReceived.getAttributes()).isEqualTo(attributes);
+    assertThat(addressesReceived.getLoadBalancingPolicyConfig()).isEqualTo(barConfig0);
+
+    // Fail over to p2.
+    fakeClock.forwardTime(10, TimeUnit.SECONDS);
+    assertThat(fooBalancers).hasSize(2);
+    assertThat(barBalancers).hasSize(1);
+    LoadBalancer fooBalancer1 = Iterables.getLast(fooBalancers);
+    verify(fooBalancer1).acceptResolvedAddresses(resolvedAddressesCaptor.capture());
+    addressesReceived = resolvedAddressesCaptor.getValue();
+    assertThat(addressesReceived.getAddresses()).isEmpty();
+    assertThat(addressesReceived.getAttributes()).isEqualTo(attributes);
+    assertThat(addressesReceived.getLoadBalancingPolicyConfig()).isEqualTo(fooConfig1);
+
+    // New update: p0 and p2 deleted; p1 config changed.
+    SocketAddress newSocketAddress = new InetSocketAddress(8081);
+    EquivalentAddressGroup newEag = new EquivalentAddressGroup(newSocketAddress);
+    newEag = AddressFilter.setPathFilter(newEag, ImmutableList.of("p1"));
+    List<EquivalentAddressGroup> newAddresses = ImmutableList.of(newEag);
+    Object newBarConfig = new Object();
+    PriorityLbConfig newPriorityLbConfig =
+        new PriorityLbConfig(
+            ImmutableMap.of("p1",
+                new PriorityChildConfig(newChildConfig(barLbProvider, newBarConfig), true)),
+            ImmutableList.of("p1"));
+    status = priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(newAddresses)
+            .setLoadBalancingPolicyConfig(newPriorityLbConfig)
+            .build());
+    assertThat(status.getCode()).isEqualTo(Status.Code.OK);
+    assertThat(fooBalancers).hasSize(2);
+    assertThat(barBalancers).hasSize(1);
+    verify(barBalancer0, times(2)).acceptResolvedAddresses(resolvedAddressesCaptor.capture());
+    addressesReceived = resolvedAddressesCaptor.getValue();
+    assertThat(Iterables.getOnlyElement(addressesReceived.getAddresses()).getAddresses())
+        .containsExactly(newSocketAddress);
+    assertThat(addressesReceived.getAttributes()).isEqualTo(Attributes.EMPTY);
+    assertThat(addressesReceived.getLoadBalancingPolicyConfig()).isEqualTo(newBarConfig);
+    verify(fooBalancer0, never()).shutdown();
+    verify(fooBalancer1, never()).shutdown();
+    fakeClock.forwardTime(15, TimeUnit.MINUTES);
+    verify(fooBalancer0).shutdown();
+    verify(fooBalancer1).shutdown();
+    verify(barBalancer0, never()).shutdown();
+  }
+
+  @Test
+  public void acceptResolvedAddresses_propagatesChildFailures() {
+    LoadBalancerProvider lbProvider = new CannedLoadBalancer.Provider();
+    CannedLoadBalancer.Config internalTf = new CannedLoadBalancer.Config(
+        Status.INTERNAL, TRANSIENT_FAILURE);
+    CannedLoadBalancer.Config okTf = new CannedLoadBalancer.Config(Status.OK, TRANSIENT_FAILURE);
+    ResolvedAddresses resolvedAddresses = ResolvedAddresses.newBuilder()
+        .setAddresses(ImmutableList.of())
+        .setAttributes(Attributes.EMPTY)
+        .build();
+
+    // tryNewPriority() propagates status
+    Status status = priorityLb.acceptResolvedAddresses(
+        resolvedAddresses.toBuilder()
+          .setLoadBalancingPolicyConfig(new PriorityLbConfig(
+            ImmutableMap.of(
+                "p0", newPriorityChildConfig(lbProvider, internalTf, true)),
+            ImmutableList.of("p0")))
+          .build());
+    assertThat(status.getCode()).isNotEqualTo(Status.Code.OK);
+
+    // Updating a child propagates status
+    status = priorityLb.acceptResolvedAddresses(
+        resolvedAddresses.toBuilder()
+          .setLoadBalancingPolicyConfig(new PriorityLbConfig(
+            ImmutableMap.of(
+                "p0", newPriorityChildConfig(lbProvider, internalTf, true)),
+            ImmutableList.of("p0")))
+          .build());
+    assertThat(status.getCode()).isNotEqualTo(Status.Code.OK);
+
+    // A single pre-existing child failure propagates
+    status = priorityLb.acceptResolvedAddresses(
+        resolvedAddresses.toBuilder()
+          .setLoadBalancingPolicyConfig(new PriorityLbConfig(
+            ImmutableMap.of(
+                "p0", newPriorityChildConfig(lbProvider, okTf, true),
+                "p1", newPriorityChildConfig(lbProvider, okTf, true),
+                "p2", newPriorityChildConfig(lbProvider, okTf, true)),
+            ImmutableList.of("p0", "p1", "p2")))
+          .build());
+    assertThat(status.getCode()).isEqualTo(Status.Code.OK);
+    status = priorityLb.acceptResolvedAddresses(
+        resolvedAddresses.toBuilder()
+          .setLoadBalancingPolicyConfig(new PriorityLbConfig(
+            ImmutableMap.of(
+                "p0", newPriorityChildConfig(lbProvider, okTf, true),
+                "p1", newPriorityChildConfig(lbProvider, internalTf, true),
+                "p2", newPriorityChildConfig(lbProvider, okTf, true)),
+            ImmutableList.of("p0", "p1", "p2")))
+          .build());
+    assertThat(status.getCode()).isNotEqualTo(Status.Code.OK);
+  }
+
+  @Test
+  public void handleNameResolutionError() {
+    Object fooConfig0 = new Object();
+    PriorityChildConfig priorityChildConfig0 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, fooConfig0), true);
+    Object fooConfig1 = new Object();
+    PriorityChildConfig priorityChildConfig1 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, fooConfig1), true);
+
+    PriorityLbConfig priorityLbConfig =
+        new PriorityLbConfig(ImmutableMap.of("p0", priorityChildConfig0), ImmutableList.of("p0"));
+    priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .build());
+    LoadBalancer fooLb0 = Iterables.getOnlyElement(fooBalancers);
+    Status status = Status.DATA_LOSS.withDescription("fake error");
+    priorityLb.handleNameResolutionError(status);
+    verify(fooLb0).handleNameResolutionError(status);
+
+    priorityLbConfig =
+        new PriorityLbConfig(ImmutableMap.of("p1", priorityChildConfig1), ImmutableList.of("p1"));
+    priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .build());
+    assertThat(fooBalancers).hasSize(2);
+    LoadBalancer fooLb1 = Iterables.getLast(fooBalancers);
+    status = Status.UNAVAILABLE.withDescription("fake error");
+    priorityLb.handleNameResolutionError(status);
+    // fooLb0 is deactivated but not yet deleted. However, because it is delisted by the latest
+    // address update, name resolution error will not be propagated to it.
+    verify(fooLb0, never()).shutdown();
+    verify(fooLb0, never()).handleNameResolutionError(status);
+    verify(fooLb1).handleNameResolutionError(status);
+  }
+
+  @Test
+  public void typicalPriorityFailOverFlow() {
+    PriorityChildConfig priorityChildConfig0 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityChildConfig priorityChildConfig1 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityChildConfig priorityChildConfig2 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityChildConfig priorityChildConfig3 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityLbConfig priorityLbConfig =
+        new PriorityLbConfig(
+            ImmutableMap.of("p0", priorityChildConfig0, "p1", priorityChildConfig1,
+                "p2", priorityChildConfig2, "p3", priorityChildConfig3),
+            ImmutableList.of("p0", "p1", "p2", "p3"));
+    priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .build());
+    assertThat(fooBalancers).hasSize(1);
+    assertThat(fooHelpers).hasSize(1);
+    LoadBalancer balancer0 = Iterables.getLast(fooBalancers);
+    Helper helper0 = Iterables.getOnlyElement(fooHelpers);
+
+    // p0 gets READY.
+    final Subchannel subchannel0 = mock(Subchannel.class);
+    helper0.updateBalancingState(
+        READY,
+        new SubchannelPicker() {
+          @Override
+          public PickResult pickSubchannel(PickSubchannelArgs args) {
+            return PickResult.withSubchannel(subchannel0);
+          }
+        });
+    assertCurrentPickerPicksSubchannel(subchannel0);
+
+    // p0 fails over to p1 immediately.
+    helper0.updateBalancingState(
+        TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.ABORTED)));
+    assertLatestConnectivityState(CONNECTING);
+    assertThat(fooBalancers).hasSize(2);
+    assertThat(fooHelpers).hasSize(2);
+    LoadBalancer balancer1 = Iterables.getLast(fooBalancers);
+    Helper helper1 = Iterables.getLast(fooHelpers);
+
+    // p1 timeout, and fails over to p2
+    fakeClock.forwardTime(10, TimeUnit.SECONDS);
+    assertLatestConnectivityState(CONNECTING);
+    assertThat(fooBalancers).hasSize(3);
+    assertThat(fooHelpers).hasSize(3);
+    LoadBalancer balancer2 = Iterables.getLast(fooBalancers);
+    Helper helper2 = Iterables.getLast(fooHelpers);
+
+    // p2 gets READY
+    final Subchannel subchannel1 = mock(Subchannel.class);
+    helper2.updateBalancingState(
+        READY,
+        new SubchannelPicker() {
+          @Override
+          public PickResult pickSubchannel(PickSubchannelArgs args) {
+            return PickResult.withSubchannel(subchannel1);
+          }
+        });
+    assertCurrentPickerPicksSubchannel(subchannel1);
+
+    // p0 gets back to READY
+    final Subchannel subchannel2 = mock(Subchannel.class);
+    helper0.updateBalancingState(
+        READY,
+        new SubchannelPicker() {
+          @Override
+          public PickResult pickSubchannel(PickSubchannelArgs args) {
+            return PickResult.withSubchannel(subchannel2);
+          }
+        });
+    assertCurrentPickerPicksSubchannel(subchannel2);
+
+    // p2 fails but does not affect overall picker
+    helper2.updateBalancingState(
+        TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.UNAVAILABLE)));
+    assertCurrentPickerPicksSubchannel(subchannel2);
+
+    // p0 fails over to p3 immediately since p1 already timeout and p2 already in TRANSIENT_FAILURE.
+    helper0.updateBalancingState(
+        TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.UNAVAILABLE)));
+    assertLatestConnectivityState(CONNECTING);
+    assertThat(fooBalancers).hasSize(4);
+    assertThat(fooHelpers).hasSize(4);
+    LoadBalancer balancer3 = Iterables.getLast(fooBalancers);
+    Helper helper3 = Iterables.getLast(fooHelpers);
+
+    // p3 timeout then the channel should stay in CONNECTING
+    fakeClock.forwardTime(10, TimeUnit.SECONDS);
+    assertCurrentPicker(CONNECTING, PickResult.withNoResult());
+
+    // p3 fails then the picker should still be waiting on p1
+    helper3.updateBalancingState(
+        TRANSIENT_FAILURE,
+        new FixedResultPicker(PickResult.withError(Status.DATA_LOSS.withDescription("foo"))));
+    assertCurrentPicker(CONNECTING, PickResult.withNoResult());
+
+    // p1 fails then the picker should have error status updated to p3
+    helper1.updateBalancingState(
+        TRANSIENT_FAILURE,
+        new FixedResultPicker(PickResult.withError(Status.DATA_LOSS.withDescription("bar"))));
+    assertCurrentPickerReturnsError(Status.Code.DATA_LOSS, "foo");
+
+    // p2 gets back to READY
+    final Subchannel subchannel3 = mock(Subchannel.class);
+    helper2.updateBalancingState(
+        READY,
+        new SubchannelPicker() {
+          @Override
+          public PickResult pickSubchannel(PickSubchannelArgs args) {
+            return PickResult.withSubchannel(subchannel3);
+          }
+        });
+    assertCurrentPickerPicksSubchannel(subchannel3);
+
+    // p0 gets back to READY
+    final Subchannel subchannel4 = mock(Subchannel.class);
+    helper0.updateBalancingState(
+        READY,
+        new SubchannelPicker() {
+          @Override
+          public PickResult pickSubchannel(PickSubchannelArgs args) {
+            return PickResult.withSubchannel(subchannel4);
+          }
+        });
+    assertCurrentPickerPicksSubchannel(subchannel4);
+
+    // p0 fails over to p2 and picker is updated to p2's existing picker.
+    helper0.updateBalancingState(
+        TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.UNAVAILABLE)));
+    assertCurrentPickerPicksSubchannel(subchannel3);
+
+    // Deactivate child balancer get deleted.
+    fakeClock.forwardTime(15, TimeUnit.MINUTES);
+    verify(balancer0, never()).shutdown();
+    verify(balancer1, never()).shutdown();
+    verify(balancer2, never()).shutdown();
+    verify(balancer3).shutdown();
+  }
+
+  @Test
+  public void idleToConnectingDoesNotTriggerFailOver() {
+    PriorityChildConfig priorityChildConfig0 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityChildConfig priorityChildConfig1 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityLbConfig priorityLbConfig =
+        new PriorityLbConfig(
+            ImmutableMap.of("p0", priorityChildConfig0, "p1", priorityChildConfig1),
+            ImmutableList.of("p0", "p1"));
+    priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .build());
+    assertThat(fooBalancers).hasSize(1);
+    assertThat(fooHelpers).hasSize(1);
+    Helper helper0 = Iterables.getOnlyElement(fooHelpers);
+
+    // p0 gets IDLE.
+    helper0.updateBalancingState(
+        IDLE,
+        EMPTY_PICKER);
+    assertCurrentPickerIsBufferPicker();
+
+    // p0 goes to CONNECTING
+    helper0.updateBalancingState(
+        IDLE,
+        EMPTY_PICKER);
+    assertCurrentPickerIsBufferPicker();
+
+    // no failover happened
+    assertThat(fooBalancers).hasSize(1);
+    assertThat(fooHelpers).hasSize(1);
+  }
+
+  @Test
+  public void connectingResetFailOverIfSeenReadyOrIdleSinceTransientFailure() {
+    PriorityChildConfig priorityChildConfig0 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityChildConfig priorityChildConfig1 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityLbConfig priorityLbConfig =
+        new PriorityLbConfig(
+            ImmutableMap.of("p0", priorityChildConfig0, "p1", priorityChildConfig1),
+            ImmutableList.of("p0", "p1"));
+    priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .build());
+    // Nothing important about this verify, other than to provide a baseline
+    verify(helper).updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+    assertThat(fooBalancers).hasSize(1);
+    assertThat(fooHelpers).hasSize(1);
+    Helper helper0 = Iterables.getOnlyElement(fooHelpers);
+
+    // p0 gets IDLE.
+    helper0.updateBalancingState(
+        IDLE,
+        EMPTY_PICKER);
+    assertCurrentPickerIsBufferPicker();
+
+    // p0 goes to CONNECTING, reset failover timer
+    fakeClock.forwardTime(5, TimeUnit.SECONDS);
+    helper0.updateBalancingState(
+        CONNECTING,
+        EMPTY_PICKER);
+    verify(helper, times(2))
+        .updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+
+    // failover happens
+    fakeClock.forwardTime(10, TimeUnit.SECONDS);
+    assertThat(fooBalancers).hasSize(2);
+    assertThat(fooHelpers).hasSize(2);
+  }
+
+  @Test
+  public void failoverTimerNotRestartedOnDupConnecting() {
+    InOrder inOrder = inOrder(helper);
+    PriorityChildConfig priorityChildConfig0 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityChildConfig priorityChildConfig1 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityLbConfig priorityLbConfig =
+        new PriorityLbConfig(
+            ImmutableMap.of("p0", priorityChildConfig0, "p1", priorityChildConfig1),
+            ImmutableList.of("p0", "p1"));
+    priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .build());
+    // Nothing important about this verify, other than to provide a baseline
+    inOrder.verify(helper)
+        .updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+    assertThat(fooBalancers).hasSize(1);
+    assertThat(fooHelpers).hasSize(1);
+    Helper helper0 = Iterables.getOnlyElement(fooHelpers);
+
+    // Cause seenReadyOrIdleSinceTransientFailure = true
+    helper0.updateBalancingState(IDLE, EMPTY_PICKER);
+    inOrder.verify(helper)
+        .updateBalancingState(eq(IDLE), pickerReturns(PickResult.withNoResult()));
+    helper0.updateBalancingState(CONNECTING, EMPTY_PICKER);
+
+    // p0 keeps repeating CONNECTING, failover happens
+    fakeClock.forwardTime(5, TimeUnit.SECONDS);
+    helper0.updateBalancingState(CONNECTING, EMPTY_PICKER);
+    fakeClock.forwardTime(5, TimeUnit.SECONDS);
+    assertThat(fooBalancers).hasSize(2);
+    assertThat(fooHelpers).hasSize(2);
+    inOrder.verify(helper, times(2))
+        .updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+    Helper helper1 = Iterables.getLast(fooHelpers);
+
+    // p0 keeps repeating CONNECTING, no reset of failover timer
+    helper1.updateBalancingState(IDLE, EMPTY_PICKER); // Stop timer for p1
+    inOrder.verify(helper)
+        .updateBalancingState(eq(IDLE), pickerReturns(PickResult.withNoResult()));
+    helper0.updateBalancingState(CONNECTING, EMPTY_PICKER);
+    fakeClock.forwardTime(10, TimeUnit.SECONDS);
+    inOrder.verify(helper, never())
+        .updateBalancingState(eq(CONNECTING), any());
+  }
+
+  @Test
+  public void readyToConnectDoesNotFailOverButUpdatesPicker() {
+    PriorityChildConfig priorityChildConfig0 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityChildConfig priorityChildConfig1 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityLbConfig priorityLbConfig =
+        new PriorityLbConfig(
+            ImmutableMap.of("p0", priorityChildConfig0, "p1", priorityChildConfig1),
+            ImmutableList.of("p0", "p1"));
+    priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .build());
+    assertThat(fooBalancers).hasSize(1);
+    assertThat(fooHelpers).hasSize(1);
+    Helper helper0 = Iterables.getOnlyElement(fooHelpers);
+
+    // p0 gets READY.
+    final Subchannel subchannel0 = mock(Subchannel.class);
+    helper0.updateBalancingState(
+        READY,
+        new SubchannelPicker() {
+          @Override
+          public PickResult pickSubchannel(PickSubchannelArgs args) {
+            return PickResult.withSubchannel(subchannel0);
+          }
+        });
+    assertCurrentPickerPicksSubchannel(subchannel0);
+
+    // p0 goes to CONNECTING
+    helper0.updateBalancingState(
+        IDLE,
+        EMPTY_PICKER);
+    assertCurrentPickerIsBufferPicker();
+
+    // no failover happened
+    assertThat(fooBalancers).hasSize(1);
+    assertThat(fooHelpers).hasSize(1);
+
+    // resolution update without priority change does not trigger failover
+    Attributes.Key<String> fooKey = Attributes.Key.create("fooKey");
+    priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .setAttributes(Attributes.newBuilder().set(fooKey, "barVal").build())
+            .build());
+
+    assertCurrentPickerIsBufferPicker();
+
+    // no failover happened
+    assertThat(fooBalancers).hasSize(1);
+    assertThat(fooHelpers).hasSize(1);
+  }
+
+  @Test
+  public void typicalPriorityFailOverFlowWithIdleUpdate() {
+    PriorityChildConfig priorityChildConfig0 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityChildConfig priorityChildConfig1 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityChildConfig priorityChildConfig2 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityChildConfig priorityChildConfig3 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityLbConfig priorityLbConfig =
+        new PriorityLbConfig(
+            ImmutableMap.of("p0", priorityChildConfig0, "p1", priorityChildConfig1,
+                "p2", priorityChildConfig2, "p3", priorityChildConfig3),
+            ImmutableList.of("p0", "p1", "p2", "p3"));
+    priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .build());
+    assertThat(fooBalancers).hasSize(1);
+    assertThat(fooHelpers).hasSize(1);
+    LoadBalancer balancer0 = Iterables.getLast(fooBalancers);
+    Helper helper0 = Iterables.getOnlyElement(fooHelpers);
+
+    // p0 gets IDLE.
+    helper0.updateBalancingState(
+        IDLE,
+        EMPTY_PICKER);
+    assertCurrentPickerIsBufferPicker();
+
+    // p0 fails over to p1 immediately.
+    helper0.updateBalancingState(
+        TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.ABORTED)));
+    assertLatestConnectivityState(CONNECTING);
+    assertThat(fooBalancers).hasSize(2);
+    assertThat(fooHelpers).hasSize(2);
+    LoadBalancer balancer1 = Iterables.getLast(fooBalancers);
+    Helper helper1 = Iterables.getLast(fooHelpers);
+
+    // p1 timeout, and fails over to p2
+    fakeClock.forwardTime(10, TimeUnit.SECONDS);
+    assertLatestConnectivityState(CONNECTING);
+    assertThat(fooBalancers).hasSize(3);
+    assertThat(fooHelpers).hasSize(3);
+    LoadBalancer balancer2 = Iterables.getLast(fooBalancers);
+    Helper helper2 = Iterables.getLast(fooHelpers);
+
+    // p2 gets IDLE
+    helper2.updateBalancingState(
+        IDLE,
+        EMPTY_PICKER);
+    assertCurrentPickerIsBufferPicker();
+
+    // p0 gets back to IDLE
+    helper0.updateBalancingState(
+        IDLE,
+        EMPTY_PICKER);
+    assertCurrentPickerIsBufferPicker();
+
+    // p2 fails but does not affect overall picker
+    helper2.updateBalancingState(
+        TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.UNAVAILABLE)));
+    assertCurrentPickerIsBufferPicker();
+
+    // p0 fails over to p3 immediately since p1 already timeout and p2 already in TRANSIENT_FAILURE.
+    helper0.updateBalancingState(
+        TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.UNAVAILABLE)));
+    assertLatestConnectivityState(CONNECTING);
+    assertThat(fooBalancers).hasSize(4);
+    assertThat(fooHelpers).hasSize(4);
+    LoadBalancer balancer3 = Iterables.getLast(fooBalancers);
+    Helper helper3 = Iterables.getLast(fooHelpers);
+
+    // p3 timeout then the channel should stay in CONNECTING
+    fakeClock.forwardTime(10, TimeUnit.SECONDS);
+    assertCurrentPicker(CONNECTING, PickResult.withNoResult());
+
+    // p3 fails then the picker should still be waiting on p1
+    helper3.updateBalancingState(
+        TRANSIENT_FAILURE,
+        new FixedResultPicker(PickResult.withError(Status.DATA_LOSS.withDescription("foo"))));
+    assertCurrentPicker(CONNECTING, PickResult.withNoResult());
+
+    // p1 fails then the picker should have error status updated to p3
+    helper1.updateBalancingState(
+        TRANSIENT_FAILURE,
+        new FixedResultPicker(PickResult.withError(Status.DATA_LOSS.withDescription("bar"))));
+    assertCurrentPickerReturnsError(Status.Code.DATA_LOSS, "foo");
+
+    // p2 gets back to IDLE
+    helper2.updateBalancingState(
+        IDLE,
+        EMPTY_PICKER);
+    assertCurrentPickerIsBufferPicker();
+
+    // p0 gets back to IDLE
+    helper0.updateBalancingState(
+        IDLE,
+        EMPTY_PICKER);
+    assertCurrentPickerIsBufferPicker();
+
+    // p0 fails over to p2 and picker is updated to p2's existing picker.
+    helper0.updateBalancingState(
+        TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.UNAVAILABLE)));
+    assertCurrentPickerIsBufferPicker();
+
+    // Deactivate child balancer get deleted.
+    fakeClock.forwardTime(15, TimeUnit.MINUTES);
+    verify(balancer0, never()).shutdown();
+    verify(balancer1, never()).shutdown();
+    verify(balancer2, never()).shutdown();
+    verify(balancer3).shutdown();
+  }
+
+  @Test
+  public void failover_propagatesChildFailures() {
+    LoadBalancerProvider lbProvider = new CannedLoadBalancer.Provider();
+    ResolvedAddresses resolvedAddresses = ResolvedAddresses.newBuilder()
+        .setAddresses(ImmutableList.of())
+        .setAttributes(Attributes.EMPTY)
+        .build();
+
+    Status status = priorityLb.acceptResolvedAddresses(
+        resolvedAddresses.toBuilder()
+          .setLoadBalancingPolicyConfig(new PriorityLbConfig(
+            ImmutableMap.of(
+                "p0", newPriorityChildConfig(
+                    lbProvider, new CannedLoadBalancer.Config(Status.OK, TRANSIENT_FAILURE), true),
+                "p1", newPriorityChildConfig(
+                    lbProvider, new CannedLoadBalancer.Config(Status.INTERNAL, CONNECTING), true)),
+            ImmutableList.of("p0", "p1")))
+          .build());
+    // Since P1's activation wasn't noticed by the result status, it triggered name resolution
+    assertThat(status.getCode()).isEqualTo(Status.Code.OK);
+    verify(helper).refreshNameResolution();
+  }
+
+  @Test
+  public void failoverTimer_propagatesChildFailures() {
+    LoadBalancerProvider lbProvider = new CannedLoadBalancer.Provider();
+    ResolvedAddresses resolvedAddresses = ResolvedAddresses.newBuilder()
+        .setAddresses(ImmutableList.of())
+        .setAttributes(Attributes.EMPTY)
+        .build();
+
+    Status status = priorityLb.acceptResolvedAddresses(
+        resolvedAddresses.toBuilder()
+          .setLoadBalancingPolicyConfig(new PriorityLbConfig(
+            ImmutableMap.of(
+                "p0", newPriorityChildConfig(
+                    lbProvider, new CannedLoadBalancer.Config(Status.OK, CONNECTING), true),
+                "p1", newPriorityChildConfig(
+                    lbProvider, new CannedLoadBalancer.Config(Status.INTERNAL, CONNECTING), true)),
+            ImmutableList.of("p0", "p1")))
+          .build());
+    assertThat(status.getCode()).isEqualTo(Status.Code.OK);
+
+    // P1's activation will refresh name resolution
+    verify(helper, never()).refreshNameResolution();
+    fakeClock.forwardTime(10, TimeUnit.SECONDS);
+    verify(helper).refreshNameResolution();
+  }
+
+  @Test
+  public void bypassReresolutionRequestsIfConfiged() {
+    PriorityChildConfig priorityChildConfig0 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityChildConfig priorityChildConfig1 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), false);
+    PriorityLbConfig priorityLbConfig =
+        new PriorityLbConfig(
+            ImmutableMap.of("p0", priorityChildConfig0, "p1", priorityChildConfig1),
+            ImmutableList.of("p0", "p1"));
+    priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .build());
+    Helper priorityHelper0 = Iterables.getOnlyElement(fooHelpers);  // priority p0
+    priorityHelper0.refreshNameResolution();
+    verify(helper, never()).refreshNameResolution();
+
+    // Simulate fallback to priority p1.
+    priorityHelper0.updateBalancingState(
+        TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.UNAVAILABLE)));
+    assertThat(fooHelpers).hasSize(2);
+    Helper priorityHelper1 = Iterables.getLast(fooHelpers);
+    priorityHelper1.refreshNameResolution();
+    verify(helper).refreshNameResolution();
+  }
+
+  @Test
+  public void raceBetweenShutdownAndChildLbBalancingStateUpdate() {
+    PriorityChildConfig priorityChildConfig0 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), true);
+    PriorityChildConfig priorityChildConfig1 =
+        new PriorityChildConfig(newChildConfig(fooLbProvider, new Object()), false);
+    PriorityLbConfig priorityLbConfig =
+        new PriorityLbConfig(
+            ImmutableMap.of("p0", priorityChildConfig0, "p1", priorityChildConfig1),
+            ImmutableList.of("p0", "p1"));
+    priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .build());
+    verify(helper).updateBalancingState(eq(CONNECTING), isA(SubchannelPicker.class));
+
+    // LB shutdown and subchannel state change can happen simultaneously. If shutdown runs first,
+    // any further balancing state update should be ignored.
+    priorityLb.shutdown();
+    Helper priorityHelper0 = Iterables.getOnlyElement(fooHelpers);  // priority p0
+    priorityHelper0.updateBalancingState(READY, mock(SubchannelPicker.class));
+    verifyNoMoreInteractions(helper);
+  }
+
+  @Test
+  public void noDuplicateOverallBalancingStateUpdate() {
+    FakeLoadBalancerProvider fakeLbProvider = new FakeLoadBalancerProvider();
+
+    PriorityChildConfig priorityChildConfig0 =
+        new PriorityChildConfig(newChildConfig(fakeLbProvider, new Object()), true);
+    PriorityChildConfig priorityChildConfig1 =
+        new PriorityChildConfig(newChildConfig(fakeLbProvider, new Object()), false);
+    PriorityLbConfig priorityLbConfig =
+        new PriorityLbConfig(
+            ImmutableMap.of("p0", priorityChildConfig0),
+            ImmutableList.of("p0"));
+    priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .build());
+
+    priorityLbConfig =
+        new PriorityLbConfig(
+            ImmutableMap.of("p0", priorityChildConfig0, "p1", priorityChildConfig1),
+            ImmutableList.of("p0", "p1"));
+    priorityLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(priorityLbConfig)
+            .build());
+
+    verify(helper, times(4)).updateBalancingState(any(), any());
+  }
+
+  private void assertLatestConnectivityState(ConnectivityState expectedState) {
+    verify(helper, atLeastOnce())
+        .updateBalancingState(connectivityStateCaptor.capture(), pickerCaptor.capture());
+    assertThat(connectivityStateCaptor.getValue()).isEqualTo(expectedState);
+  }
+
+  private void assertCurrentPickerReturnsError(
+      Status.Code expectedCode, String expectedDescription) {
+    assertLatestConnectivityState(TRANSIENT_FAILURE);
+    Status error =
+        pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class)).getStatus();
+    assertThat(error.getCode()).isEqualTo(expectedCode);
+    if (expectedDescription != null) {
+      assertThat(error.getDescription()).contains(expectedDescription);
+    }
+  }
+
+  private void assertCurrentPickerPicksSubchannel(Subchannel expectedSubchannelToPick) {
+    assertCurrentPicker(READY, PickResult.withSubchannel(expectedSubchannelToPick));
+  }
+
+  private void assertCurrentPickerIsBufferPicker() {
+    assertCurrentPicker(IDLE, PickResult.withNoResult());
+  }
+
+  private void assertCurrentPicker(ConnectivityState state, PickResult result) {
+    assertLatestConnectivityState(state);
+    PickResult pickResult = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
+    assertThat(pickResult).isEqualTo(result);
+  }
+
+  private Object newChildConfig(LoadBalancerProvider provider, Object config) {
+    return GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(provider, config);
+  }
+
+  private PriorityChildConfig newPriorityChildConfig(
+      LoadBalancerProvider provider, Object config, boolean ignoreRefresh) {
+    return new PriorityChildConfig(newChildConfig(provider, config), ignoreRefresh);
+  }
+
+  private static class FakeLoadBalancerProvider extends LoadBalancerProvider {
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 5;
+    }
+
+    @Override
+    public String getPolicyName() {
+      return "foo";
+    }
+
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      return new FakeLoadBalancer(helper);
+    }
+  }
+
+  static class FakeLoadBalancer extends LoadBalancer {
+
+    private Helper helper;
+
+    FakeLoadBalancer(Helper helper) {
+      this.helper = helper;
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      helper.updateBalancingState(
+          TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.INTERNAL)));
+      return Status.OK;
+    }
+
+    @Override
+    public void handleNameResolutionError(Status error) {
+    }
+
+    @Override
+    public void shutdown() {
+    }
+  }
+
+  static final class CannedLoadBalancer extends LoadBalancer {
+    private final Helper helper;
+
+    private CannedLoadBalancer(Helper helper) {
+      this.helper = helper;
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses addresses) {
+      Config config = (Config) addresses.getLoadBalancingPolicyConfig();
+      helper.updateBalancingState(
+          config.state, new FixedResultPicker(PickResult.withError(Status.INTERNAL)));
+      return config.resolvedAddressesResult;
+    }
+
+    @Override
+    public void handleNameResolutionError(Status status) {}
+
+    @Override
+    public void shutdown() {}
+
+    static final class Provider extends StandardLoadBalancerProvider {
+      public Provider() {
+        super("echo");
+      }
+
+      @Override
+      public LoadBalancer newLoadBalancer(Helper helper) {
+        return new CannedLoadBalancer(helper);
+      }
+    }
+
+    static final class Config {
+      final Status resolvedAddressesResult;
+      final ConnectivityState state;
+
+      public Config(Status resolvedAddressesResult, ConnectivityState state) {
+        this.resolvedAddressesResult = resolvedAddressesResult;
+        this.state = state;
+      }
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/RbacFilterTest.java b/xds/src/test/java/io/grpc/xds/RbacFilterTest.java
new file mode 100644
index 00000000000..334e159dd1d
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/RbacFilterTest.java
@@ -0,0 +1,463 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.api.expr.v1alpha1.Expr;
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.Any;
+import com.google.protobuf.Message;
+import com.google.protobuf.UInt32Value;
+import io.envoyproxy.envoy.config.core.v3.CidrRange;
+import io.envoyproxy.envoy.config.rbac.v3.Permission;
+import io.envoyproxy.envoy.config.rbac.v3.Policy;
+import io.envoyproxy.envoy.config.rbac.v3.Principal;
+import io.envoyproxy.envoy.config.rbac.v3.Principal.Authenticated;
+import io.envoyproxy.envoy.config.rbac.v3.RBAC;
+import io.envoyproxy.envoy.config.rbac.v3.RBAC.Action;
+import io.envoyproxy.envoy.config.route.v3.HeaderMatcher;
+import io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBACPerRoute;
+import io.envoyproxy.envoy.type.matcher.v3.MetadataMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.PathMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import io.envoyproxy.envoy.type.v3.Int32Range;
+import io.grpc.Attributes;
+import io.grpc.Grpc;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.Status;
+import io.grpc.testing.TestMethodDescriptors;
+import io.grpc.xds.Filter.FilterConfig;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AlwaysTrueMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AuthConfig;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AuthDecision;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.DestinationPortMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.OrMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.PolicyMatcher;
+import java.net.InetSocketAddress;
+import java.security.cert.X509Certificate;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import javax.net.ssl.SSLSession;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+
+/** Tests for {@link RbacFilter}. */
+@RunWith(JUnit4.class)
+public class RbacFilterTest {
+  private static final String PATH = "auth";
+  private static final StringMatcher STRING_MATCHER =
+          StringMatcher.newBuilder().setExact("/" + PATH).setIgnoreCase(true).build();
+  private static final RbacFilter.Provider FILTER_PROVIDER = new RbacFilter.Provider();
+
+  private final String name = "theFilterName";
+
+  @Test
+  public void filterType_serverOnly() {
+    assertThat(FILTER_PROVIDER.isClientFilter()).isFalse();
+    assertThat(FILTER_PROVIDER.isServerFilter()).isTrue();
+  }
+
+  @Test
+  @SuppressWarnings({"unchecked", "deprecation"})
+  public void ipPortParser() {
+    CidrRange cidrRange = CidrRange.newBuilder().setAddressPrefix("10.10.10.0")
+            .setPrefixLen(UInt32Value.of(24)).build();
+    List<Permission> permissionList = Arrays.asList(
+            Permission.newBuilder().setAndRules(Permission.Set.newBuilder()
+                    .addRules(Permission.newBuilder().setDestinationIp(cidrRange).build())
+                    .addRules(Permission.newBuilder().setDestinationPort(9090).build()).build()
+            ).build());
+    List<Principal> principalList = Arrays.asList(
+            Principal.newBuilder().setAndIds(Principal.Set.newBuilder()
+                    .addIds(Principal.newBuilder().setDirectRemoteIp(cidrRange).build())
+                    .addIds(Principal.newBuilder().setRemoteIp(cidrRange).build())
+                    .addIds(Principal.newBuilder().setSourceIp(cidrRange).build())
+                    .build()).build());
+    ConfigOrError<?> result = parseRaw(permissionList, principalList);
+    assertThat(result.errorDetail).isNull();
+    ServerCall<Void,Void> serverCall = mock(ServerCall.class);
+    Attributes attributes = Attributes.newBuilder()
+            .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, new InetSocketAddress("10.10.10.0", 1))
+            .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, new InetSocketAddress("10.10.10.0",9090))
+            .build();
+    when(serverCall.getAttributes()).thenReturn(attributes);
+    when(serverCall.getMethodDescriptor()).thenReturn(method().build());
+    GrpcAuthorizationEngine engine =
+            new GrpcAuthorizationEngine(((RbacConfig)result.config).authConfig());
+    AuthDecision decision = engine.evaluate(new Metadata(), serverCall);
+    assertThat(decision.decision()).isEqualTo(GrpcAuthorizationEngine.Action.DENY);
+  }
+
+  @Test
+  @SuppressWarnings({"unchecked", "deprecation"})
+  public void portRangeParser() {
+    List<Permission> permissionList = Arrays.asList(
+        Permission.newBuilder().setDestinationPortRange(
+            Int32Range.newBuilder().setStart(1010).setEnd(65535).build()
+        ).build());
+    List<Principal> principalList = Arrays.asList(
+        Principal.newBuilder().setRemoteIp(
+            CidrRange.newBuilder().setAddressPrefix("10.10.10.0")
+                .setPrefixLen(UInt32Value.of(24)).build()
+        ).build());
+    ConfigOrError<?> result = parse(permissionList, principalList);
+    assertThat(result.errorDetail).isNull();
+    ServerCall<Void,Void> serverCall = mock(ServerCall.class);
+    Attributes attributes = Attributes.newBuilder()
+        .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, new InetSocketAddress("10.10.10.0", 1))
+        .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, new InetSocketAddress("10.10.10.0",9090))
+        .build();
+    when(serverCall.getAttributes()).thenReturn(attributes);
+    when(serverCall.getMethodDescriptor()).thenReturn(method().build());
+    GrpcAuthorizationEngine engine =
+        new GrpcAuthorizationEngine(((RbacConfig)result.config).authConfig());
+    AuthDecision decision = engine.evaluate(new Metadata(), serverCall);
+    assertThat(decision.decision()).isEqualTo(GrpcAuthorizationEngine.Action.DENY);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void pathParser() {
+    PathMatcher pathMatcher = PathMatcher.newBuilder().setPath(STRING_MATCHER).build();
+    List<Permission> permissionList = Arrays.asList(
+            Permission.newBuilder().setUrlPath(pathMatcher).build());
+    List<Principal> principalList = Arrays.asList(
+            Principal.newBuilder().setUrlPath(pathMatcher).build());
+    ConfigOrError<RbacConfig> result = parse(permissionList, principalList);
+    assertThat(result.errorDetail).isNull();
+    ServerCall<Void,Void> serverCall = mock(ServerCall.class);
+    when(serverCall.getMethodDescriptor()).thenReturn(method().build());
+    GrpcAuthorizationEngine engine =
+            new GrpcAuthorizationEngine(result.config.authConfig());
+    AuthDecision decision = engine.evaluate(new Metadata(), serverCall);
+    assertThat(decision.decision()).isEqualTo(GrpcAuthorizationEngine.Action.DENY);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void authenticatedParser() throws Exception {
+    List<Permission> permissionList = Arrays.asList(
+            Permission.newBuilder().setNotRule(
+               Permission.newBuilder().setRequestedServerName(STRING_MATCHER).build()).build());
+    List<Principal> principalList = Arrays.asList(
+            Principal.newBuilder().setAuthenticated(Authenticated.newBuilder()
+                    .setPrincipalName(STRING_MATCHER).build()).build());
+    ConfigOrError<?> result = parse(permissionList, principalList);
+    assertThat(result.errorDetail).isNull();
+    SSLSession sslSession = mock(SSLSession.class);
+    X509Certificate mockCert = mock(X509Certificate.class);
+    when(sslSession.getPeerCertificates()).thenReturn(new X509Certificate[]{mockCert});
+    when(mockCert.getSubjectAlternativeNames()).thenReturn(
+            Arrays.<List<?>>asList(Arrays.asList(2, "/" + PATH)));
+    Attributes attributes = Attributes.newBuilder()
+            .set(Grpc.TRANSPORT_ATTR_SSL_SESSION, sslSession)
+            .build();
+    ServerCall<Void,Void> serverCall = mock(ServerCall.class);
+    when(serverCall.getAttributes()).thenReturn(attributes);
+    GrpcAuthorizationEngine engine =
+            new GrpcAuthorizationEngine(((RbacConfig)result.config).authConfig());
+    AuthDecision decision = engine.evaluate(new Metadata(), serverCall);
+    assertThat(decision.decision()).isEqualTo(GrpcAuthorizationEngine.Action.DENY);
+  }
+
+  @Test
+  @SuppressWarnings({"unchecked", "deprecation"})
+  public void headerParser() {
+    HeaderMatcher headerMatcher = HeaderMatcher.newBuilder()
+            .setName("party").setExactMatch("win").build();
+    List<Permission> permissionList = Arrays.asList(
+            Permission.newBuilder().setHeader(headerMatcher).build());
+    List<Principal> principalList = Arrays.asList(
+            Principal.newBuilder().setHeader(headerMatcher).build());
+    ConfigOrError<RbacConfig> result = parseOverride(permissionList, principalList);
+    assertThat(result.errorDetail).isNull();
+    ServerCall<Void,Void> serverCall = mock(ServerCall.class);
+    GrpcAuthorizationEngine engine =
+            new GrpcAuthorizationEngine(result.config.authConfig());
+    AuthDecision decision = engine.evaluate(metadata("party", "win"), serverCall);
+    assertThat(decision.decision()).isEqualTo(GrpcAuthorizationEngine.Action.DENY);
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void headerParser_headerName() {
+    HeaderMatcher headerMatcher = HeaderMatcher.newBuilder()
+        .setName("grpc--feature").setExactMatch("win").build();
+    List<Permission> permissionList = Arrays.asList(
+        Permission.newBuilder().setHeader(headerMatcher).build());
+    HeaderMatcher headerMatcher2 = HeaderMatcher.newBuilder()
+        .setName(":scheme").setExactMatch("win").build();
+    List<Principal> principalList = Arrays.asList(
+        Principal.newBuilder().setHeader(headerMatcher2).build());
+    ConfigOrError<RbacConfig> result = parseOverride(permissionList, principalList);
+    assertThat(result.errorDetail).isNotNull();
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void compositeRules() {
+    MetadataMatcher metadataMatcher = MetadataMatcher.newBuilder().build();
+    @SuppressWarnings("deprecation")
+    Permission permissionMetadata = Permission.newBuilder().setMetadata(metadataMatcher).build();
+    List<Permission> permissionList = Arrays.asList(
+            Permission.newBuilder().setOrRules(Permission.Set.newBuilder().addRules(
+                    permissionMetadata).build()).build());
+    @SuppressWarnings("deprecation")
+    Principal principalMetadata = Principal.newBuilder().setMetadata(metadataMatcher).build();
+    List<Principal> principalList = Arrays.asList(
+            Principal.newBuilder().setNotId(principalMetadata).build());
+    ConfigOrError<? extends FilterConfig> result = parse(permissionList, principalList);
+    assertThat(result.errorDetail).isNull();
+    assertThat(result.config).isInstanceOf(RbacConfig.class);
+    ServerCall<Void,Void> serverCall = mock(ServerCall.class);
+    GrpcAuthorizationEngine engine =
+            new GrpcAuthorizationEngine(((RbacConfig)result.config).authConfig());
+    AuthDecision decision = engine.evaluate(new Metadata(), serverCall);
+    assertThat(decision.decision()).isEqualTo(GrpcAuthorizationEngine.Action.ALLOW);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void testAuthorizationInterceptor() {
+    ServerCallHandler<Void, Void> mockHandler = mock(ServerCallHandler.class);
+    ServerCall<Void, Void> mockServerCall = mock(ServerCall.class);
+    Attributes attr = Attributes.newBuilder()
+            .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, new InetSocketAddress("1::", 20))
+            .build();
+    when(mockServerCall.getAttributes()).thenReturn(attr);
+    PolicyMatcher policyMatcher = PolicyMatcher.create("policy-matcher",
+            OrMatcher.create(DestinationPortMatcher.create(99999)),
+            OrMatcher.create(AlwaysTrueMatcher.INSTANCE));
+    AuthConfig authconfig = AuthConfig.create(Collections.singletonList(policyMatcher),
+            GrpcAuthorizationEngine.Action.ALLOW);
+    FILTER_PROVIDER.newInstance(name).buildServerInterceptor(RbacConfig.create(authconfig), null)
+            .interceptCall(mockServerCall, new Metadata(), mockHandler);
+    verify(mockHandler, never()).startCall(eq(mockServerCall), any(Metadata.class));
+    ArgumentCaptor<Status> captor = ArgumentCaptor.forClass(Status.class);
+    verify(mockServerCall).close(captor.capture(), any(Metadata.class));
+    assertThat(captor.getValue().getCode()).isEqualTo(Status.PERMISSION_DENIED.getCode());
+    assertThat(captor.getValue().getDescription()).isEqualTo("Access Denied");
+    verify(mockServerCall).getAttributes();
+    verifyNoMoreInteractions(mockServerCall);
+
+    authconfig = AuthConfig.create(Collections.singletonList(policyMatcher),
+            GrpcAuthorizationEngine.Action.DENY);
+    FILTER_PROVIDER.newInstance(name).buildServerInterceptor(RbacConfig.create(authconfig), null)
+            .interceptCall(mockServerCall, new Metadata(), mockHandler);
+    verify(mockHandler).startCall(eq(mockServerCall), any(Metadata.class));
+  }
+
+  @Test
+  public void handleException() {
+    PathMatcher pathMatcher = PathMatcher.newBuilder()
+            .setPath(StringMatcher.newBuilder().build()).build();
+    List<Permission> permissionList = Arrays.asList(
+            Permission.newBuilder().setUrlPath(pathMatcher).build());
+    List<Principal> principalList = Arrays.asList(
+            Principal.newBuilder().setUrlPath(pathMatcher).build());
+    ConfigOrError<?> result = parse(permissionList, principalList);
+    assertThat(result.errorDetail).isNotNull();
+
+    permissionList = Arrays.asList(Permission.newBuilder().build());
+    principalList = Arrays.asList(Principal.newBuilder().build());
+    result = parse(permissionList, principalList);
+    assertThat(result.errorDetail).isNotNull();
+
+    Message rawProto = io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBAC.newBuilder()
+            .setRules(RBAC.newBuilder().setAction(Action.DENY)
+                    .putPolicies("policy-name",
+                            Policy.newBuilder().setCondition(Expr.newBuilder().build()).build())
+                    .build()).build();
+    result = FILTER_PROVIDER.parseFilterConfig(Any.pack(rawProto));
+    assertThat(result.errorDetail).isNotNull();
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void overrideConfig() {
+    ServerCallHandler<Void, Void> mockHandler = mock(ServerCallHandler.class);
+    ServerCall<Void, Void> mockServerCall = mock(ServerCall.class);
+    Attributes attr = Attributes.newBuilder()
+            .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, new InetSocketAddress("1::", 20))
+            .build();
+    when(mockServerCall.getAttributes()).thenReturn(attr);
+
+    PolicyMatcher policyMatcher = PolicyMatcher.create("policy-matcher",
+            OrMatcher.create(DestinationPortMatcher.create(99999)),
+            OrMatcher.create(AlwaysTrueMatcher.INSTANCE));
+    AuthConfig authconfig =  AuthConfig.create(Collections.singletonList(policyMatcher),
+            GrpcAuthorizationEngine.Action.ALLOW);
+    RbacConfig original = RbacConfig.create(authconfig);
+
+    RBACPerRoute rbacPerRoute = RBACPerRoute.newBuilder().build();
+    RbacConfig override = FILTER_PROVIDER.parseFilterConfigOverride(Any.pack(rbacPerRoute)).config;
+    assertThat(override).isEqualTo(RbacConfig.create(null));
+    ServerInterceptor interceptor =
+        FILTER_PROVIDER.newInstance(name).buildServerInterceptor(original, override);
+    assertThat(interceptor).isNull();
+
+    policyMatcher = PolicyMatcher.create("policy-matcher-override",
+            OrMatcher.create(DestinationPortMatcher.create(20)),
+            OrMatcher.create(AlwaysTrueMatcher.INSTANCE));
+    authconfig =  AuthConfig.create(Collections.singletonList(policyMatcher),
+            GrpcAuthorizationEngine.Action.ALLOW);
+    override = RbacConfig.create(authconfig);
+
+    FILTER_PROVIDER.newInstance(name).buildServerInterceptor(original, override)
+            .interceptCall(mockServerCall, new Metadata(), mockHandler);
+    verify(mockHandler).startCall(eq(mockServerCall), any(Metadata.class));
+    verify(mockServerCall).getAttributes();
+    verifyNoMoreInteractions(mockServerCall);
+  }
+
+  @Test
+  public void ignoredConfig() {
+    Message rawProto = io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBAC.newBuilder()
+            .setRules(RBAC.newBuilder().setAction(Action.LOG)
+                    .putPolicies("policy-name", Policy.newBuilder().build()).build()).build();
+    ConfigOrError<RbacConfig> result = FILTER_PROVIDER.parseFilterConfig(Any.pack(rawProto));
+    assertThat(result.config).isEqualTo(RbacConfig.create(null));
+  }
+
+  @Test
+  public void testOrderIndependenceOfPolicies() {
+    Message rawProto = buildComplexRbac(ImmutableList.of(1, 2, 3, 4, 5, 6), true);
+    ConfigOrError<RbacConfig> ascFirst = FILTER_PROVIDER.parseFilterConfig(Any.pack(rawProto));
+
+    rawProto = buildComplexRbac(ImmutableList.of(1, 2, 3, 4, 5, 6), false);
+    ConfigOrError<RbacConfig> ascLast = FILTER_PROVIDER.parseFilterConfig(Any.pack(rawProto));
+
+    assertThat(ascFirst.config).isEqualTo(ascLast.config);
+
+    rawProto = buildComplexRbac(ImmutableList.of(6, 5, 4, 3, 2, 1), true);
+    ConfigOrError<RbacConfig> decFirst = FILTER_PROVIDER.parseFilterConfig(Any.pack(rawProto));
+
+    assertThat(ascFirst.config).isEqualTo(decFirst.config);
+  }
+
+  private static Metadata metadata(String key, String value) {
+    Metadata metadata = new Metadata();
+    metadata.put(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER), value);
+    return metadata;
+  }
+
+  private MethodDescriptor.Builder<Void, Void> method() {
+    return MethodDescriptor.<Void,Void>newBuilder()
+            .setType(MethodType.BIDI_STREAMING)
+            .setFullMethodName(PATH)
+            .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+            .setResponseMarshaller(TestMethodDescriptors.voidMarshaller());
+  }
+
+  private ConfigOrError<RbacConfig> parse(List<Permission> permissionList,
+                                                      List<Principal> principalList) {
+
+    return RbacFilter.Provider.parseRbacConfig(buildRbac(permissionList, principalList));
+  }
+
+  private ConfigOrError<RbacConfig> parseRaw(List<Permission> permissionList,
+                                                      List<Principal> principalList) {
+    Message rawProto = buildRbac(permissionList, principalList);
+    Any proto = Any.pack(rawProto);
+    return FILTER_PROVIDER.parseFilterConfig(proto);
+  }
+
+  private io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBAC buildRbac(
+          List<Permission> permissionList, List<Principal> principalList) {
+    return io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBAC.newBuilder()
+            .setRules(buildRbacRule("policy-name", Action.DENY,
+                permissionList, principalList)).build();
+  }
+
+  private static RBAC buildRbacRule(String policyName, Action action,
+      List<Permission> permissionList, List<Principal> principalList) {
+    return RBAC.newBuilder().setAction(action)
+        .putPolicies(policyName, Policy.newBuilder()
+            .addAllPermissions(permissionList)
+            .addAllPrincipals(principalList).build())
+        .build();
+  }
+
+  private io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBAC buildComplexRbac(
+      List<Integer> ids, boolean listsFirst) {
+    Policy policy1 = createSimplePolicyUsingLists(0);
+
+    RBAC.Builder ruleBuilder = RBAC.newBuilder().setAction(Action.DENY);
+
+    if (listsFirst) {
+      ruleBuilder.putPolicies("list-policy", policy1);
+    }
+
+    String base = "filterConfig\\u003dRbacConfig{authConfig\\u003dAuthConfig{policies\\u003d[Poli"
+        + "cyMatcher{name\\u003dpsm-interop-authz-policy-20230514-0917-er2uh_td_rbac_rule_";
+
+    for (Integer id : ids) {
+      ruleBuilder.putPolicies(base + id, createSimplePolicyUsingLists(id));
+    }
+
+    if (!listsFirst) {
+      ruleBuilder.putPolicies("list-policy", policy1);
+    }
+
+    return io.envoyproxy.envoy.extensions.filters.http.rbac.v3.RBAC.newBuilder()
+        .setRules(ruleBuilder.build()).build();
+  }
+
+  private static Policy createSimplePolicyUsingLists(int id) {
+    CidrRange cidrRange = CidrRange.newBuilder().setAddressPrefix("10.10." + id + ".0")
+        .setPrefixLen(UInt32Value.of(24)).build();
+    List<Permission> permissionList = Arrays.asList(
+        Permission.newBuilder().setAndRules(Permission.Set.newBuilder()
+            .addRules(Permission.newBuilder().setDestinationIp(cidrRange).build())
+            .addRules(Permission.newBuilder().setDestinationPort(9090).build()).build()
+        ).build());
+    List<Principal> principalList = Arrays.asList(
+        Principal.newBuilder().setAndIds(Principal.Set.newBuilder()
+            .addIds(Principal.newBuilder().setDirectRemoteIp(cidrRange).build())
+            .addIds(Principal.newBuilder().setRemoteIp(cidrRange).build())
+            .build()).build());
+
+    return Policy.newBuilder()
+        .addAllPermissions(permissionList)
+        .addAllPrincipals(principalList).build();
+  }
+
+  private ConfigOrError<RbacConfig> parseOverride(List<Permission> permissionList,
+                                             List<Principal> principalList) {
+    RBACPerRoute rbacPerRoute = RBACPerRoute.newBuilder().setRbac(
+            buildRbac(permissionList, principalList)).build();
+    Any proto = Any.pack(rbacPerRoute);
+    return FILTER_PROVIDER.parseFilterConfigOverride(proto);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/RingHashLoadBalancerProviderTest.java b/xds/src/test/java/io/grpc/xds/RingHashLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..66c9c5c537e
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/RingHashLoadBalancerProviderTest.java
@@ -0,0 +1,288 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import io.grpc.InternalServiceProviders;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.JsonParser;
+import io.grpc.xds.RingHashLoadBalancer.RingHashConfig;
+import io.grpc.xds.RingHashOptions;
+import java.io.IOException;
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.util.Locale;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link RingHashLoadBalancerProvider}. */
+@RunWith(JUnit4.class)
+public class RingHashLoadBalancerProviderTest {
+  private static final String AUTHORITY = "foo.googleapis.com";
+  private static final String GRPC_EXPERIMENTAL_RING_HASH_SET_REQUEST_HASH_KEY =
+      "GRPC_EXPERIMENTAL_RING_HASH_SET_REQUEST_HASH_KEY";
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final RingHashLoadBalancerProvider provider = new RingHashLoadBalancerProvider();
+
+  @Test
+  public void provided() {
+    for (LoadBalancerProvider current : InternalServiceProviders.getCandidatesViaServiceLoader(
+        LoadBalancerProvider.class, getClass().getClassLoader())) {
+      if (current instanceof RingHashLoadBalancerProvider) {
+        return;
+      }
+    }
+    fail("RingHashLoadBalancerProvider not registered");
+  }
+
+  @Test
+  public void providesLoadBalancer() {
+    Helper helper = mock(Helper.class);
+    when(helper.getSynchronizationContext()).thenReturn(syncContext);
+    when(helper.getAuthority()).thenReturn(AUTHORITY);
+    assertThat(provider.newLoadBalancer(helper))
+        .isInstanceOf(RingHashLoadBalancer.class);
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_valid() throws IOException {
+    String lbConfig = "{\"minRingSize\" : 10, \"maxRingSize\" : 100}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    RingHashConfig config = (RingHashConfig) configOrError.getConfig();
+    assertThat(config.minRingSize).isEqualTo(10L);
+    assertThat(config.maxRingSize).isEqualTo(100L);
+    assertThat(config.requestHashHeader).isEmpty();
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_missingRingSize_useDefaults() throws IOException {
+    String lbConfig = "{}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    RingHashConfig config = (RingHashConfig) configOrError.getConfig();
+    assertThat(config.minRingSize).isEqualTo(RingHashLoadBalancerProvider.DEFAULT_MIN_RING_SIZE);
+    assertThat(config.maxRingSize).isEqualTo(RingHashLoadBalancerProvider.DEFAULT_MAX_RING_SIZE);
+    assertThat(config.requestHashHeader).isEmpty();
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_invalid_negativeSize() throws IOException {
+    String lbConfig = "{\"minRingSize\" : -10}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getError()).isNotNull();
+    assertThat(configOrError.getError().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(configOrError.getError().getDescription())
+        .isEqualTo("Invalid 'minRingSize'/'maxRingSize'");
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_invalid_minGreaterThanMax() throws IOException {
+    String lbConfig = "{\"minRingSize\" : 1000, \"maxRingSize\" : 100}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getError()).isNotNull();
+    assertThat(configOrError.getError().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(configOrError.getError().getDescription())
+        .isEqualTo("Invalid 'minRingSize'/'maxRingSize'");
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_ringTooLargeUsesCap() throws IOException {
+    long ringSize = RingHashOptions.MAX_RING_SIZE_CAP + 1;
+    String lbConfig =
+        String.format(Locale.US, "{\"minRingSize\" : 10, \"maxRingSize\" : %d}", ringSize);
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    RingHashConfig config = (RingHashConfig) configOrError.getConfig();
+    assertThat(config.minRingSize).isEqualTo(10);
+    assertThat(config.maxRingSize).isEqualTo(RingHashOptions.DEFAULT_RING_SIZE_CAP);
+    assertThat(config.requestHashHeader).isEmpty();
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_ringCapCanBeRaised() throws IOException {
+    RingHashOptions.setRingSizeCap(RingHashOptions.MAX_RING_SIZE_CAP);
+    long ringSize = RingHashOptions.MAX_RING_SIZE_CAP;
+    String lbConfig =
+        String.format(
+            Locale.US, "{\"minRingSize\" : %d, \"maxRingSize\" : %d}", ringSize, ringSize);
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    RingHashConfig config = (RingHashConfig) configOrError.getConfig();
+    assertThat(config.minRingSize).isEqualTo(RingHashOptions.MAX_RING_SIZE_CAP);
+    assertThat(config.maxRingSize).isEqualTo(RingHashOptions.MAX_RING_SIZE_CAP);
+    assertThat(config.requestHashHeader).isEmpty();
+    // Reset to avoid affecting subsequent test cases
+    RingHashOptions.setRingSizeCap(RingHashOptions.DEFAULT_RING_SIZE_CAP);
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_ringCapIsClampedTo8M() throws IOException {
+    RingHashOptions.setRingSizeCap(RingHashOptions.MAX_RING_SIZE_CAP + 1);
+    long ringSize = RingHashOptions.MAX_RING_SIZE_CAP + 1;
+    String lbConfig =
+        String.format(
+            Locale.US, "{\"minRingSize\" : %d, \"maxRingSize\" : %d}", ringSize, ringSize);
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    RingHashConfig config = (RingHashConfig) configOrError.getConfig();
+    assertThat(config.minRingSize).isEqualTo(RingHashOptions.MAX_RING_SIZE_CAP);
+    assertThat(config.maxRingSize).isEqualTo(RingHashOptions.MAX_RING_SIZE_CAP);
+    assertThat(config.requestHashHeader).isEmpty();
+    // Reset to avoid affecting subsequent test cases
+    RingHashOptions.setRingSizeCap(RingHashOptions.DEFAULT_RING_SIZE_CAP);
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_ringCapCanBeLowered() throws IOException {
+    RingHashOptions.setRingSizeCap(1);
+    long ringSize = 2;
+    String lbConfig =
+        String.format(
+            Locale.US, "{\"minRingSize\" : %d, \"maxRingSize\" : %d}", ringSize, ringSize);
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    RingHashConfig config = (RingHashConfig) configOrError.getConfig();
+    assertThat(config.minRingSize).isEqualTo(1);
+    assertThat(config.maxRingSize).isEqualTo(1);
+    assertThat(config.requestHashHeader).isEmpty();
+    // Reset to avoid affecting subsequent test cases
+    RingHashOptions.setRingSizeCap(RingHashOptions.DEFAULT_RING_SIZE_CAP);
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_ringCapLowerLimitIs1() throws IOException {
+    RingHashOptions.setRingSizeCap(0);
+    long ringSize = 2;
+    String lbConfig =
+        String.format(
+            Locale.US, "{\"minRingSize\" : %d, \"maxRingSize\" : %d}", ringSize, ringSize);
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    RingHashConfig config = (RingHashConfig) configOrError.getConfig();
+    assertThat(config.minRingSize).isEqualTo(1);
+    assertThat(config.maxRingSize).isEqualTo(1);
+    assertThat(config.requestHashHeader).isEmpty();
+    // Reset to avoid affecting subsequent test cases
+    RingHashOptions.setRingSizeCap(RingHashOptions.DEFAULT_RING_SIZE_CAP);
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_zeroMinRingSize() throws IOException {
+    String lbConfig = "{\"minRingSize\" : 0, \"maxRingSize\" : 100}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getError()).isNotNull();
+    assertThat(configOrError.getError().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(configOrError.getError().getDescription())
+        .isEqualTo("Invalid 'minRingSize'/'maxRingSize'");
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_minRingSizeGreaterThanMaxRingSize() throws IOException {
+    String lbConfig = "{\"minRingSize\" : 100, \"maxRingSize\" : 10}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getError()).isNotNull();
+    assertThat(configOrError.getError().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(configOrError.getError().getDescription())
+        .isEqualTo("Invalid 'minRingSize'/'maxRingSize'");
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_requestHashHeaderIgnoredWhenEnvVarNotSet()
+      throws IOException {
+    String lbConfig =
+        "{\"minRingSize\" : 10, \"maxRingSize\" : 100, \"requestHashHeader\" : \"dummy-hash\"}";
+    ConfigOrError configOrError =
+        provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    RingHashConfig config = (RingHashConfig) configOrError.getConfig();
+    assertThat(config.minRingSize).isEqualTo(10L);
+    assertThat(config.maxRingSize).isEqualTo(100L);
+    assertThat(config.requestHashHeader).isEmpty();
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_requestHashHeaderSetWhenEnvVarSet() throws IOException {
+    System.setProperty(GRPC_EXPERIMENTAL_RING_HASH_SET_REQUEST_HASH_KEY, "true");
+    try {
+      String lbConfig =
+          "{\"minRingSize\" : 10, \"maxRingSize\" : 100, \"requestHashHeader\" : \"dummy-hash\"}";
+      ConfigOrError configOrError =
+          provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+      assertThat(configOrError.getConfig()).isNotNull();
+      RingHashConfig config = (RingHashConfig) configOrError.getConfig();
+      assertThat(config.minRingSize).isEqualTo(10L);
+      assertThat(config.maxRingSize).isEqualTo(100L);
+      assertThat(config.requestHashHeader).isEqualTo("dummy-hash");
+      assertThat(config.toString()).contains("minRingSize=10");
+      assertThat(config.toString()).contains("maxRingSize=100");
+      assertThat(config.toString()).contains("requestHashHeader=dummy-hash");
+    } finally {
+      System.clearProperty(GRPC_EXPERIMENTAL_RING_HASH_SET_REQUEST_HASH_KEY);
+    }
+  }
+
+  @Test
+  public void parseLoadBalancingConfig_requestHashHeaderUnsetWhenEnvVarSet_useDefaults()
+      throws IOException {
+    System.setProperty(GRPC_EXPERIMENTAL_RING_HASH_SET_REQUEST_HASH_KEY, "true");
+    try {
+      String lbConfig = "{\"minRingSize\" : 10, \"maxRingSize\" : 100}";
+      ConfigOrError configOrError =
+          provider.parseLoadBalancingPolicyConfig(parseJsonObject(lbConfig));
+      assertThat(configOrError.getConfig()).isNotNull();
+      RingHashConfig config = (RingHashConfig) configOrError.getConfig();
+      assertThat(config.minRingSize).isEqualTo(10L);
+      assertThat(config.maxRingSize).isEqualTo(100L);
+      assertThat(config.requestHashHeader).isEmpty();
+    } finally {
+      System.clearProperty(GRPC_EXPERIMENTAL_RING_HASH_SET_REQUEST_HASH_KEY);
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, ?> parseJsonObject(String json) throws IOException {
+    return (Map<String, ?>) JsonParser.parse(json);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/RingHashLoadBalancerTest.java b/xds/src/test/java/io/grpc/xds/RingHashLoadBalancerTest.java
new file mode 100644
index 00000000000..b515ed81158
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/RingHashLoadBalancerTest.java
@@ -0,0 +1,1384 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static io.grpc.xds.RingHashLoadBalancerTest.InitializationFlags.DO_NOT_RESET_HELPER;
+import static io.grpc.xds.RingHashLoadBalancerTest.InitializationFlags.DO_NOT_VERIFY;
+import static io.grpc.xds.RingHashLoadBalancerTest.InitializationFlags.RESET_SUBCHANNEL_MOCKS;
+import static io.grpc.xds.RingHashLoadBalancerTest.InitializationFlags.STAY_IN_CONNECTING;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+import com.google.common.collect.Iterables;
+import com.google.common.primitives.UnsignedInteger;
+import com.google.common.testing.EqualsTester;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickDetailsConsumer;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.Metadata;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.PickFirstLoadBalancerProvider;
+import io.grpc.internal.PickFirstLoadBalancerProviderAccessor;
+import io.grpc.internal.PickSubchannelArgsImpl;
+import io.grpc.testing.TestMethodDescriptors;
+import io.grpc.util.AbstractTestHelper;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import io.grpc.util.MultiChildLoadBalancer.ChildLbState;
+import io.grpc.xds.RingHashLoadBalancer.RingHashConfig;
+import java.lang.Thread.UncaughtExceptionHandler;
+import java.net.SocketAddress;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit test for {@link io.grpc.LoadBalancer}. */
+@RunWith(JUnit4.class)
+public class RingHashLoadBalancerTest {
+  private static final String AUTHORITY = "foo.googleapis.com";
+  private static final String CUSTOM_REQUEST_HASH_HEADER = "custom-request-hash-header";
+  private static final Metadata.Key<String> CUSTOM_METADATA_KEY =
+      Metadata.Key.of(CUSTOM_REQUEST_HASH_HEADER, Metadata.ASCII_STRING_MARSHALLER);
+  private static final Attributes.Key<String> CUSTOM_KEY = Attributes.Key.create("custom-key");
+  private static final ConnectivityStateInfo CSI_CONNECTING =
+      ConnectivityStateInfo.forNonError(CONNECTING);
+  public static final ConnectivityStateInfo CSI_READY = ConnectivityStateInfo.forNonError(READY);
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final Map<List<EquivalentAddressGroup>, Subchannel> subchannels = new HashMap<>();
+  private final Deque<Subchannel> connectionRequestedQueue = new ArrayDeque<>();
+  private final XxHash64 hashFunc = XxHash64.INSTANCE;
+  private final TestHelper testHelperInst = new TestHelper();
+  private final Helper helper = mock(Helper.class, delegatesTo(testHelperInst));
+  @Captor
+  private ArgumentCaptor<SubchannelPicker> pickerCaptor;
+  private RingHashLoadBalancer loadBalancer;
+  private boolean defaultNewPickFirst = PickFirstLoadBalancerProvider.isEnabledNewPickFirst();
+
+  @Before
+  public void setUp() {
+    loadBalancer = new RingHashLoadBalancer(helper);
+    // Consume calls not relevant for tests that would otherwise fail verifyNoMoreInteractions
+    verify(helper).getAuthority();
+    verify(helper).getSynchronizationContext();
+  }
+
+  @After
+  public void tearDown() {
+    PickFirstLoadBalancerProviderAccessor.setEnableNewPickFirst(defaultNewPickFirst);
+    loadBalancer.shutdown();
+    for (Subchannel subchannel : subchannels.values()) {
+      verify(subchannel).shutdown();
+    }
+    connectionRequestedQueue.clear();
+  }
+
+  @Test
+  public void subchannelLazyConnectUntilPicked() {
+    RingHashConfig config = new RingHashConfig(10, 100, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1);  // one server
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    assertThat(subchannels.size()).isEqualTo(0);
+
+    // Picking subchannel triggers connection.
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    assertThat(result.getSubchannel()).isNull();
+    Subchannel subchannel = Iterables.getOnlyElement(subchannels.values());
+    int expectedTimes = PickFirstLoadBalancerProvider.isEnabledNewPickFirst()
+                            && !PickFirstLoadBalancerProvider.isEnabledHappyEyeballs() ? 1 : 2;
+    verify(subchannel, times(expectedTimes)).requestConnection();
+    verify(helper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+    verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
+    deliverSubchannelState(subchannel, CSI_CONNECTING);
+    int expectedCount = PickFirstLoadBalancerProvider.isEnabledNewPickFirst() ? 1 : 2;
+    verify(helper, times(expectedCount)).updateBalancingState(eq(CONNECTING), any());
+
+    // Subchannel becomes ready, triggers pick again.
+    deliverSubchannelState(subchannel, CSI_READY);
+    verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getSubchannel()).isSameInstanceAs(subchannel);
+    AbstractTestHelper.verifyNoMoreMeaningfulInteractions(helper);
+  }
+
+  @Test
+  public void subchannelNotAutoReconnectAfterReenteringIdle() {
+    RingHashConfig config = new RingHashConfig(10, 100, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1);  // one server
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+
+    assertThat(subchannels).isEmpty();
+
+    // Picking subchannel triggers connection.
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    pickerCaptor.getValue().pickSubchannel(args);
+    Subchannel subchannel = subchannels.get(Collections.singletonList(servers.get(0)));
+    InOrder inOrder = Mockito.inOrder(helper, subchannel);
+    int expectedTimes = PickFirstLoadBalancerProvider.isEnabledHappyEyeballs()
+                            || !PickFirstLoadBalancerProvider.isEnabledNewPickFirst() ? 2 : 1;
+    inOrder.verify(subchannel, times(expectedTimes)).requestConnection();
+    deliverSubchannelState(subchannel, CSI_READY);
+    inOrder.verify(helper).updateBalancingState(eq(READY), any(SubchannelPicker.class));
+    deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(IDLE));
+    inOrder.verify(helper).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+    inOrder.verify(subchannel, never()).requestConnection();
+
+    // Picking again triggers reconnection.
+    pickerCaptor.getValue().pickSubchannel(args);
+    inOrder.verify(subchannel).requestConnection();
+  }
+
+  @Test
+  public void aggregateSubchannelStates_connectingReadyIdleFailure() {
+    RingHashConfig config = new RingHashConfig(10, 100, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1);
+    InOrder inOrder = Mockito.inOrder(helper);
+
+    initializeLbSubchannels(config, servers);
+
+    // one in CONNECTING, one in IDLE
+    deliverSubchannelState(getSubchannel(servers, 0), CSI_CONNECTING);
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+    verifyConnection(0);
+
+    // two in CONNECTING
+    deliverSubchannelState(getSubchannel(servers, 1), CSI_CONNECTING);
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+    verifyConnection(0);
+
+    // one in CONNECTING, one in READY
+    deliverSubchannelState(getSubchannel(servers, 1), CSI_READY);
+    inOrder.verify(helper).updateBalancingState(eq(READY), any(SubchannelPicker.class));
+    verifyConnection(0);
+
+    // one in TRANSIENT_FAILURE, one in READY
+    deliverSubchannelState(
+        getSubchannel(servers, 0),
+        ConnectivityStateInfo.forTransientFailure(
+            Status.UNKNOWN.withDescription("unknown failure")));
+    if (PickFirstLoadBalancerProvider.isEnabledNewPickFirst()) {
+      inOrder.verify(helper).updateBalancingState(eq(READY), any());
+    } else {
+      inOrder.verify(helper).refreshNameResolution();
+      inOrder.verify(helper).updateBalancingState(eq(READY), any());
+    }
+    verifyConnection(0);
+
+    // one in TRANSIENT_FAILURE, one in IDLE
+    deliverSubchannelState(
+        getSubchannel(servers, 1),
+        ConnectivityStateInfo.forNonError(IDLE));
+    if (PickFirstLoadBalancerProvider.isEnabledNewPickFirst()) {
+      inOrder.verify(helper).updateBalancingState(eq(CONNECTING), any());
+    } else {
+      inOrder.verify(helper).refreshNameResolution();
+      inOrder.verify(helper).updateBalancingState(eq(CONNECTING), any());
+    }
+    verifyConnection(1);
+  }
+
+  private void verifyConnection(int times) {
+    for (int i = 0; i < times; i++) {
+      Subchannel connectOnce = connectionRequestedQueue.poll();
+      assertWithMessage("Expected %s new connections, but found %s", times, i)
+          .that(connectOnce).isNotNull();
+      clearInvocations(connectOnce);
+    }
+    assertThat(connectionRequestedQueue.poll()).isNull();
+  }
+
+  @Test
+  public void aggregateSubchannelStates_allSubchannelsInTransientFailure() {
+    RingHashConfig config = new RingHashConfig(10, 100, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1, 1);
+
+    List<Subchannel> subChannelList = initializeLbSubchannels(config, servers, STAY_IN_CONNECTING);
+
+    // reset inOrder to include all the childLBs now that they have been created
+    clearInvocations(helper);
+    InOrder inOrder = Mockito.inOrder(helper,
+        subChannelList.get(0), subChannelList.get(1), subChannelList.get(2), subChannelList.get(3));
+
+    // one in TRANSIENT_FAILURE, three in CONNECTING
+    deliverNotFound(subChannelList, 0);
+    refreshInvokedButNotUpdateBS(inOrder, TRANSIENT_FAILURE);
+
+    // two in TRANSIENT_FAILURE, two in CONNECTING
+    deliverNotFound(subChannelList, 1);
+    refreshInvokedAndUpdateBS(inOrder, TRANSIENT_FAILURE);
+
+    // All 4 in TF switch to TF
+    deliverNotFound(subChannelList, 2);
+    refreshInvokedAndUpdateBS(inOrder, TRANSIENT_FAILURE);
+    deliverNotFound(subChannelList, 3);
+    refreshInvokedAndUpdateBS(inOrder, TRANSIENT_FAILURE);
+
+    // reset subchannel to CONNECTING - shouldn't change anything since PF hides the state change
+    deliverSubchannelState(subChannelList.get(2), CSI_CONNECTING);
+    inOrder.verify(helper, never())
+        .updateBalancingState(eq(TRANSIENT_FAILURE), any(SubchannelPicker.class));
+    inOrder.verify(subChannelList.get(2), never()).requestConnection();
+
+    // three in TRANSIENT_FAILURE, one in READY
+    deliverSubchannelState(subChannelList.get(2), CSI_READY);
+    inOrder.verify(helper).updateBalancingState(eq(READY), any(SubchannelPicker.class));
+    inOrder.verify(subChannelList.get(2), never()).requestConnection();
+  }
+
+  // Old PF and new PF reverse calling order of updateBlaancingState and refreshNameResolution
+  private void refreshInvokedButNotUpdateBS(InOrder inOrder, ConnectivityState state) {
+    inOrder.verify(helper, never()).updateBalancingState(eq(state), any(SubchannelPicker.class));
+    inOrder.verify(helper).refreshNameResolution();
+    inOrder.verify(helper, never()).updateBalancingState(eq(state), any(SubchannelPicker.class));
+  }
+
+  // Old PF and new PF reverse calling order of updateBlaancingState and refreshNameResolution
+  private void refreshInvokedAndUpdateBS(InOrder inOrder, ConnectivityState state) {
+    if (PickFirstLoadBalancerProvider.isEnabledNewPickFirst()) {
+      inOrder.verify(helper).updateBalancingState(eq(state), any());
+    }
+
+    inOrder.verify(helper).refreshNameResolution();
+
+    if (!PickFirstLoadBalancerProvider.isEnabledNewPickFirst()) {
+      inOrder.verify(helper).updateBalancingState(eq(state), any());
+    }
+  }
+
+  @Test
+  public void ignoreShutdownSubchannelStateChange() {
+    RingHashConfig config = new RingHashConfig(10, 100, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+    initializeLbSubchannels(config, servers);
+
+    loadBalancer.shutdown();
+    for (Subchannel sc : subchannels.values()) {
+      verify(sc).shutdown();
+      // When the subchannel is being shut down, a SHUTDOWN connectivity state is delivered
+      // back to the subchannel state listener.
+      deliverSubchannelState(sc, ConnectivityStateInfo.forNonError(SHUTDOWN));
+    }
+    verifyNoMoreInteractions(helper);
+  }
+
+  @Test
+  public void deterministicPickWithHostsPartiallyRemoved() {
+    RingHashConfig config = new RingHashConfig(10, 100, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1, 1, 1);
+    initializeLbSubchannels(config, servers);
+    InOrder inOrder = Mockito.inOrder(helper);
+
+    // Bring all subchannels to READY so that next pick always succeeds.
+    for (Subchannel subchannel : subchannels.values()) {
+      deliverSubchannelState(subchannel, CSI_READY);
+      inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    }
+
+    // Simulate rpc hash hits one ring entry exactly for server1.
+    long rpcHash = hashFunc.hashAsciiString("FakeSocketAddress-server1_0");
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(rpcHash);
+    pickerCaptor.getValue().pickSubchannel(args);
+    PickResult result = pickerCaptor.getValue().pickSubchannel(args);
+    Subchannel subchannel = result.getSubchannel();
+    assertThat(subchannel.getAddresses()).isEqualTo(servers.get(1));
+
+    List<EquivalentAddressGroup> updatedServers = new ArrayList<>();
+    for (EquivalentAddressGroup addr : servers.subList(0, 2)) {  // only server0 and server1 left
+      Attributes attr = addr.getAttributes().toBuilder().set(CUSTOM_KEY, "custom value").build();
+      updatedServers.add(new EquivalentAddressGroup(addr.getAddresses(), attr));
+    }
+    Subchannel subchannel0_old = getSubchannel(servers, 0);
+    Subchannel subchannel1_old = getSubchannel(servers, 1);
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(updatedServers).setLoadBalancingPolicyConfig(config).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    verify(subchannel0_old).updateAddresses(Collections.singletonList(updatedServers.get(0)));
+    verify(subchannel1_old).updateAddresses(Collections.singletonList(updatedServers.get(1)));
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertThat(pickerCaptor.getValue().pickSubchannel(args).getSubchannel())
+        .isSameInstanceAs(subchannel);
+    verifyNoMoreInteractions(helper);
+  }
+
+  @Test
+  public void deterministicPickWithNewHostsAdded() {
+    RingHashConfig config = new RingHashConfig(10, 100, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1);  // server0 and server1
+    initializeLbSubchannels(config, servers, DO_NOT_VERIFY, DO_NOT_RESET_HELPER);
+
+    InOrder inOrder = Mockito.inOrder(helper);
+
+    // Bring all subchannels to READY so that next pick always succeeds.
+    for (Subchannel subchannel : subchannels.values()) {
+      deliverSubchannelState(subchannel, CSI_READY);
+      inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    }
+
+    // Simulate rpc hash hits one ring entry exactly for server1.
+    long rpcHash = hashFunc.hashAsciiString("FakeSocketAddress-server1_0");
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(rpcHash);
+    pickerCaptor.getValue().pickSubchannel(args);
+    PickResult result = pickerCaptor.getValue().pickSubchannel(args);
+    Subchannel subchannel = result.getSubchannel();
+    assertThat(subchannel.getAddresses()).isEqualTo(servers.get(1));
+
+    servers = createWeightedServerAddrs(1, 1, 1, 1, 1);  // server2, server3, server4 added
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+    assertThat(loadBalancer.getChildLbStates().size()).isEqualTo(5);
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertThat(pickerCaptor.getValue().pickSubchannel(args).getSubchannel())
+        .isSameInstanceAs(subchannel);
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void deterministicPickWithRequestHashHeader_oneHeaderValue() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, CUSTOM_REQUEST_HASH_HEADER);
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+    initializeLbSubchannels(config, servers);
+    InOrder inOrder = Mockito.inOrder(helper);
+
+    // Bring all subchannels to READY.
+    for (Subchannel subchannel : subchannels.values()) {
+      deliverSubchannelState(subchannel, CSI_READY);
+      inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    }
+
+    // Pick subchannel with custom request hash header where the rpc hash hits server1.
+    Metadata headers = new Metadata();
+    headers.put(CUSTOM_METADATA_KEY, "FakeSocketAddress-server1_0");
+    PickSubchannelArgs args =
+        new PickSubchannelArgsImpl(
+            TestMethodDescriptors.voidMethod(),
+            headers,
+            CallOptions.DEFAULT,
+            new PickDetailsConsumer() {});
+    SubchannelPicker picker = pickerCaptor.getValue();
+    PickResult result = picker.pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    assertThat(result.getSubchannel().getAddresses()).isEqualTo(servers.get(1));
+  }
+
+  @Test
+  public void deterministicPickWithRequestHashHeader_multipleHeaderValues() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, CUSTOM_REQUEST_HASH_HEADER);
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+    initializeLbSubchannels(config, servers);
+    InOrder inOrder = Mockito.inOrder(helper);
+
+    // Bring all subchannels to READY.
+    for (Subchannel subchannel : subchannels.values()) {
+      deliverSubchannelState(subchannel, CSI_READY);
+      inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    }
+
+    // Pick subchannel with custom request hash header with multiple values for the same key where
+    // the rpc hash hits server1.
+    Metadata headers = new Metadata();
+    headers.put(CUSTOM_METADATA_KEY, "FakeSocketAddress-server0_0");
+    headers.put(CUSTOM_METADATA_KEY, "FakeSocketAddress-server1_0");
+    PickSubchannelArgs args =
+        new PickSubchannelArgsImpl(
+            TestMethodDescriptors.voidMethod(),
+            headers,
+            CallOptions.DEFAULT,
+            new PickDetailsConsumer() {});
+    SubchannelPicker picker = pickerCaptor.getValue();
+    PickResult result = picker.pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    assertThat(result.getSubchannel().getAddresses()).isEqualTo(servers.get(1));
+  }
+
+  @Test
+  public void pickWithRandomHash_allSubchannelsReady() {
+    loadBalancer = new RingHashLoadBalancer(helper, new FakeRandom());
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(2, 2, "dummy-random-hash");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1);
+    initializeLbSubchannels(config, servers);
+    InOrder inOrder = Mockito.inOrder(helper);
+
+    // Bring all subchannels to READY.
+    Map<EquivalentAddressGroup, Integer> pickCounts = new HashMap<>();
+    for (Subchannel subchannel : subchannels.values()) {
+      deliverSubchannelState(subchannel, CSI_READY);
+      pickCounts.put(subchannel.getAddresses(), 0);
+      inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    }
+
+    // Pick subchannel 100 times with random hash.
+    SubchannelPicker picker = pickerCaptor.getValue();
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    for (int i = 0; i < 100; ++i) {
+      Subchannel pickedSubchannel = picker.pickSubchannel(args).getSubchannel();
+      EquivalentAddressGroup addr = pickedSubchannel.getAddresses();
+      pickCounts.put(addr, pickCounts.get(addr) + 1);
+    }
+
+    // Verify the distribution is uniform where server0 and server1 are exactly picked 50 times.
+    assertThat(pickCounts.get(servers.get(0))).isEqualTo(50);
+    assertThat(pickCounts.get(servers.get(1))).isEqualTo(50);
+  }
+
+  @Test
+  public void pickWithRandomHash_atLeastOneSubchannelConnecting() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, "dummy-random-hash");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+    initializeLbSubchannels(config, servers);
+
+    // Bring one subchannel to CONNECTING.
+    deliverSubchannelState(getSubChannel(servers.get(0)), CSI_CONNECTING);
+    verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+
+    // Pick subchannel with random hash does not trigger connection.
+    SubchannelPicker picker = pickerCaptor.getValue();
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    PickResult result = picker.pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    assertThat(result.getSubchannel()).isNull(); // buffer request
+    verifyConnection(0);
+  }
+
+  @Test
+  public void pickWithRandomHash_firstSubchannelInTransientFailure_remainingSubchannelsIdle() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, "dummy-random-hash");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+    initializeLbSubchannels(config, servers);
+
+    // Bring one subchannel to TRANSIENT_FAILURE.
+    deliverSubchannelUnreachable(getSubChannel(servers.get(0)));
+    verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verifyConnection(1);
+
+    // Pick subchannel with random hash does trigger connection by walking the ring
+    // and choosing the first (at most one) IDLE subchannel along the way.
+    SubchannelPicker picker = pickerCaptor.getValue();
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    PickResult result = picker.pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    assertThat(result.getSubchannel()).isNull(); // buffer request
+    verifyConnection(1);
+  }
+
+  private Subchannel getSubChannel(EquivalentAddressGroup eag) {
+    return subchannels.get(Collections.singletonList(eag));
+  }
+
+  @Test
+  public void skipFailingHosts_pickNextNonFailingHost() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+    Status addressesAcceptanceStatus =
+        loadBalancer.acceptResolvedAddresses(
+            ResolvedAddresses.newBuilder()
+                .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+
+    // Create subchannel for the first address
+    loadBalancer.getChildLbStates().iterator().next().getCurrentPicker()
+        .pickSubchannel(getDefaultPickSubchannelArgs(hashFunc.hashVoid()));
+    verifyConnection(1);
+
+    reset(helper);
+    // ring:
+    //   "FakeSocketAddress-server0_0"
+    //   "FakeSocketAddress-server1_0"
+    //   "FakeSocketAddress-server2_0"
+
+    long rpcHash = hashFunc.hashAsciiString("FakeSocketAddress-server0_0");
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(rpcHash);
+
+    // Bring down server0 to force trying server2.
+    deliverSubchannelState(
+        getSubChannel(servers.get(0)),
+        ConnectivityStateInfo.forTransientFailure(
+            Status.UNAVAILABLE.withDescription("unreachable")));
+    verify(helper, atLeastOnce()).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+
+    PickResult result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    assertThat(result.getSubchannel()).isNull();  // buffer request
+    // verify kicked off connection to server2
+    int expectedTimes = PickFirstLoadBalancerProvider.isEnabledHappyEyeballs()
+                            || !PickFirstLoadBalancerProvider.isEnabledNewPickFirst() ? 2 : 1;
+
+    verify(getSubChannel(servers.get(1)), times(expectedTimes)).requestConnection();
+    assertThat(subchannels.size()).isEqualTo(2);  // no excessive connection
+
+    deliverSubchannelState(getSubChannel(servers.get(1)), CSI_CONNECTING);
+    verify(helper, atLeast(1))
+        .updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+
+    result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    assertThat(result.getSubchannel()).isNull();  // buffer request
+
+    deliverSubchannelState(getSubChannel(servers.get(1)), CSI_READY);
+    verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    assertThat(result.getSubchannel().getAddresses()).isEqualTo(servers.get(1));
+  }
+
+  private PickSubchannelArgs getDefaultPickSubchannelArgs(long rpcHash) {
+    return new PickSubchannelArgsImpl(
+        TestMethodDescriptors.voidMethod(), new Metadata(),
+        CallOptions.DEFAULT.withOption(XdsNameResolver.RPC_HASH_KEY, rpcHash),
+        new PickDetailsConsumer() {});
+  }
+
+  private PickSubchannelArgs getDefaultPickSubchannelArgsForServer(int serverid) {
+    long rpcHash = hashFunc.hashAsciiString("FakeSocketAddress-server" + serverid + "_0");
+    return getDefaultPickSubchannelArgs(rpcHash);
+  }
+
+  @Test
+  public void skipFailingHosts_firstTwoHostsFailed_pickNextFirstReady() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+
+    initializeLbSubchannels(config, servers);
+
+    // ring:
+    //   "FakeSocketAddress-server0_0"
+    //   "FakeSocketAddress-server1_0"
+    //   "FakeSocketAddress-server2_0"
+
+    long rpcHash = hashFunc.hashAsciiString("FakeSocketAddress-server1_0");
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(rpcHash);
+
+    // Bring down server0 and server2 to force trying server1.
+    deliverSubchannelState(
+        getSubchannel(servers, 1),
+        ConnectivityStateInfo.forTransientFailure(
+            Status.UNAVAILABLE.withDescription("unreachable")));
+    deliverSubchannelState(
+        getSubchannel(servers, 2),
+        ConnectivityStateInfo.forTransientFailure(
+            Status.PERMISSION_DENIED.withDescription("permission denied")));
+    verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    verifyConnection(2);
+    PickResult result = pickerCaptor.getValue().pickSubchannel(args); // activate last subchannel
+    assertThat(result.getStatus().isOk()).isTrue();
+    int expectedCount = PickFirstLoadBalancerProvider.isEnabledNewPickFirst() ? 0 : 1;
+    verifyConnection(expectedCount);
+
+    deliverSubchannelState(
+        getSubchannel(servers, 0),
+        ConnectivityStateInfo.forTransientFailure(
+            Status.PERMISSION_DENIED.withDescription("permission denied again")));
+    verify(helper, times(2)).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isFalse();  // fail the RPC
+    assertThat(result.getStatus().getCode())
+        .isEqualTo(Code.UNAVAILABLE);  // with error status for the original server hit by hash
+    assertThat(result.getStatus().getDescription()).isEqualTo("unreachable");
+
+    // Now connecting to server1.
+    deliverSubchannelState(getSubchannel(servers, 1), CSI_CONNECTING);
+
+    reset(helper);
+
+    result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isFalse();  // fail the RPC
+    assertThat(result.getStatus().getCode())
+        .isEqualTo(Code.UNAVAILABLE);  // with error status for the original server hit by hash
+    assertThat(result.getStatus().getDescription()).isEqualTo("unreachable");
+
+    // Simulate server1 becomes READY.
+    deliverSubchannelState(getSubchannel(servers, 1), CSI_READY);
+    verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+
+    SubchannelPicker picker = pickerCaptor.getValue();
+    result = picker.pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();  // succeed
+    assertThat(result.getSubchannel().getAddresses()).isEqualTo(servers.get(1));  // with server1
+    assertThat(picker.pickSubchannel(getDefaultPickSubchannelArgsForServer(0))).isEqualTo(result);
+    assertThat(picker.pickSubchannel(getDefaultPickSubchannelArgsForServer(2))).isEqualTo(result);
+  }
+
+  @Test
+  public void removingAddressShutdownSubchannel() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, "");
+    List<EquivalentAddressGroup> svs1 = createWeightedServerAddrs(1, 1, 1);
+    List<Subchannel> subchannels1 = initializeLbSubchannels(config, svs1, STAY_IN_CONNECTING);
+
+    List<EquivalentAddressGroup> svs2 = createWeightedServerAddrs(1, 1);
+    InOrder inOrder = Mockito.inOrder(helper, subchannels1.get(2));
+    // send LB the missing address
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(svs2).setLoadBalancingPolicyConfig(config).build());
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), any());
+    inOrder.verify(subchannels1.get(2)).shutdown();
+  }
+
+  @Test
+  public void allSubchannelsInTransientFailure() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+    initializeLbSubchannels(config, servers);
+
+    // Bring all subchannels to TRANSIENT_FAILURE.
+    for (Subchannel subchannel : subchannels.values()) {
+      deliverSubchannelState(subchannel, ConnectivityStateInfo.forTransientFailure(
+          Status.UNAVAILABLE.withDescription(
+              subchannel.getAddresses().getAddresses() + " unreachable")));
+    }
+    verify(helper, atLeastOnce())
+        .updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    verifyConnection(2);
+
+    // Picking subchannel triggers connection. RPC hash hits server0.
+    PickSubchannelArgs args = getDefaultPickSubchannelArgsForServer(0);
+    PickResult result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isFalse();
+    assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(result.getStatus().getDescription())
+        .isEqualTo("[FakeSocketAddress-server0] unreachable");
+    verifyConnection(0); // TF has already started taking care of this, pick doesn't need to
+  }
+
+  @Test
+  public void firstSubchannelIdle() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+    initializeLbSubchannels(config, servers);
+
+    // As per gRFC A61, entering TF triggers a proactive connection attempt
+    // on an IDLE subchannel because no other subchannel is currently CONNECTING.
+    deliverSubchannelState(getSubchannel(servers, 1),
+        ConnectivityStateInfo.forTransientFailure(
+        Status.UNAVAILABLE.withDescription("unreachable")));
+    verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verifyConnection(1);
+
+    // Picking subchannel triggers connection. RPC hash hits server0.
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    verifyConnection(1);
+  }
+
+  @Test
+  public void firstSubchannelConnecting() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+    initializeLbSubchannels(config, servers);
+
+    deliverSubchannelState(getSubchannel(servers, 0), CSI_CONNECTING);
+    deliverSubchannelState(getSubchannel(servers, 1), CSI_CONNECTING);
+    verify(helper, times(2)).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+
+    // Picking subchannel triggers connection.
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    verify(getSubchannel(servers, 0), never()).requestConnection();
+    verify(getSubchannel(servers, 1), never()).requestConnection();
+    verify(getSubchannel(servers, 2), never()).requestConnection();
+  }
+
+  private Subchannel getSubchannel(List<EquivalentAddressGroup> servers, int serverIndex) {
+    return subchannels.get(Collections.singletonList(servers.get(serverIndex)));
+  }
+
+  @Test
+  public void firstSubchannelFailure() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+
+    List<Subchannel> subchannelList =
+        initializeLbSubchannels(config, servers, RESET_SUBCHANNEL_MOCKS);
+
+    // ring:
+    //   "FakeSocketAddress-server1_0"
+    //   "FakeSocketAddress-server0_0"
+    //   "FakeSocketAddress-server2_0"
+
+    deliverSubchannelState(subchannelList.get(0),
+        ConnectivityStateInfo.forTransientFailure(
+            Status.UNAVAILABLE.withDescription("unreachable")));
+    verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verifyConnection(1);
+
+    // Per GRFC A61 Picking subchannel should no longer request connections that were failing
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    SubchannelPicker picker1 = pickerCaptor.getValue();
+    PickResult result = picker1.pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    assertThat(result.getSubchannel()).isNull();
+    verify(subchannelList.get(0), never()).requestConnection(); // In TF
+    verify(subchannelList.get(1)).requestConnection();
+    verify(subchannelList.get(2), never()).requestConnection(); // Not one of the first 2
+  }
+
+  @Test
+  public void secondSubchannelConnecting() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+
+    initializeLbSubchannels(config, servers);
+
+    // ring:
+    //   "FakeSocketAddress-server1_0"
+    //   "FakeSocketAddress-server0_0"
+    //   "FakeSocketAddress-server2_0"
+
+    Subchannel firstSubchannel = getSubchannel(servers, 0);
+    deliverSubchannelUnreachable(firstSubchannel);
+    verifyConnection(1);
+
+    deliverSubchannelState(getSubchannel(servers, 2), CSI_CONNECTING);
+    verify(helper, times(2)).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verifyConnection(0);
+
+    // Picking subchannel when idle triggers connection.
+    deliverSubchannelState(getSubchannel(servers, 2),
+        ConnectivityStateInfo.forNonError(IDLE));
+    verifyConnection(1);
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    verifyConnection(1);
+  }
+
+  @Test
+  public void secondSubchannelFailure() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+
+    initializeLbSubchannels(config, servers);
+
+    // ring:
+    //   "FakeSocketAddress-server1_0"
+    //   "FakeSocketAddress-server0_0"
+    //   "FakeSocketAddress-server2_0"
+
+    Subchannel firstSubchannel = getSubchannel(servers, 0);
+    deliverSubchannelUnreachable(firstSubchannel);
+    deliverSubchannelUnreachable(getSubchannel(servers, 2));
+    verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    verifyConnection(2);
+
+    // Picking subchannel triggers connection.
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    verify(getSubchannel(servers, 1)).requestConnection();
+    verifyConnection(1);
+  }
+
+  @Test
+  public void thirdSubchannelConnecting() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+
+    initializeLbSubchannels(config, servers);
+
+    // ring:
+    //   "FakeSocketAddress-server1_0"
+    //   "FakeSocketAddress-server0_0"
+    //   "FakeSocketAddress-server2_0"
+
+    Subchannel firstSubchannel = getSubchannel(servers, 0);
+
+    deliverSubchannelUnreachable(firstSubchannel);
+    deliverSubchannelUnreachable(getSubchannel(servers, 2));
+    deliverSubchannelState(getSubchannel(servers, 1), CSI_CONNECTING);
+    verify(helper, atLeastOnce())
+        .updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    verifyConnection(2);
+
+    // Picking subchannel should not trigger connection per gRFC A61.
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    verifyConnection(0);
+  }
+
+  @Test
+  public void stickyTransientFailure() {
+    // Map each server address to exactly one ring entry.
+    RingHashConfig config = new RingHashConfig(3, 3, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+
+    initializeLbSubchannels(config, servers);
+
+    // Bring one subchannel to TRANSIENT_FAILURE.
+    Subchannel firstSubchannel = getSubchannel(servers, 0);
+    deliverSubchannelUnreachable(firstSubchannel);
+
+    verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    verifyConnection(1);
+
+    reset(helper);
+    deliverSubchannelState(firstSubchannel, ConnectivityStateInfo.forNonError(IDLE));
+    // Should not have called updateBalancingState on the helper again because PickFirst is
+    // shielding the higher level from the state change.
+    verify(helper, never()).updateBalancingState(any(), any());
+    verifyConnection(PickFirstLoadBalancerProvider.isEnabledNewPickFirst() ? 0 : 1);
+
+    // Picking subchannel triggers connection on second address. RPC hash hits server0.
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isTrue();
+    verify(getSubchannel(servers, 1)).requestConnection();
+    verify(getSubchannel(servers, 2), never()).requestConnection();
+  }
+
+  @Test
+  public void largeWeights() {
+    RingHashConfig config = new RingHashConfig(10000, 100000, "");  // large ring
+    List<EquivalentAddressGroup> servers =
+        createWeightedServerAddrs(Integer.MAX_VALUE, 10, 100); // MAX:10:100
+
+    initializeLbSubchannels(config, servers);
+
+    // Try value between max signed and max unsigned int
+    servers = createWeightedServerAddrs(Integer.MAX_VALUE + 100L, 100); // (MAX+100):100
+    Status addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+
+    // Try a negative value
+    servers = createWeightedServerAddrs(10, -20, 100); // 10:-20:100
+    addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isFalse();
+
+    // Try an individual value larger than max unsigned int
+    long maxUnsigned = UnsignedInteger.MAX_VALUE.longValue();
+    servers = createWeightedServerAddrs(maxUnsigned + 10, 10, 100); // uMAX+10:10:100
+    addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isFalse();
+
+    // Try a sum of values larger than max unsigned int
+    servers = createWeightedServerAddrs(Integer.MAX_VALUE, Integer.MAX_VALUE, 100); // MAX:MAX:100
+    addressesAcceptanceStatus = loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
+    assertThat(addressesAcceptanceStatus.isOk()).isFalse();
+  }
+
+  @Test
+  public void hostSelectionProportionalToWeights() {
+    RingHashConfig config = new RingHashConfig(10000, 100000, "");  // large ring
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 10, 100); // 1:10:100
+
+    initializeLbSubchannels(config, servers);
+
+    // Bring all subchannels to READY.
+    Map<EquivalentAddressGroup, Integer> pickCounts = new HashMap<>();
+    for (Subchannel subchannel : subchannels.values()) {
+      deliverSubchannelState(subchannel, CSI_READY);
+      pickCounts.put(subchannel.getAddresses(), 0);
+    }
+    verify(helper, times(3)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+
+    for (int i = 0; i < 10000; i++) {
+      long hash = hashFunc.hashInt(i);
+      PickSubchannelArgs args = getDefaultPickSubchannelArgs(hash);
+      Subchannel pickedSubchannel = picker.pickSubchannel(args).getSubchannel();
+      EquivalentAddressGroup addr = pickedSubchannel.getAddresses();
+      pickCounts.put(addr, pickCounts.get(addr) + 1);
+    }
+
+    // Actual distribution: server0 = 104, server1 = 808, server2 = 9088
+    double ratio01 = (double) pickCounts.get(servers.get(0)) / pickCounts.get(servers.get(1));
+    double ratio12 = (double) pickCounts.get(servers.get(1)) / pickCounts.get(servers.get(2));
+    assertThat(ratio01).isWithin(0.03).of((double) 1 / 10);
+    assertThat(ratio12).isWithin(0.03).of((double) 10 / 100);
+  }
+
+  @Test
+  public void nameResolutionErrorWithNoActiveSubchannels() {
+    Status error = Status.UNAVAILABLE.withDescription("not reachable");
+    loadBalancer.handleNameResolutionError(error);
+    verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
+    assertThat(result.getStatus().getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(result.getStatus().getDescription()).isEqualTo("not reachable");
+    assertThat(result.getSubchannel()).isNull();
+    verifyNoMoreInteractions(helper);
+  }
+
+  @Test
+  public void nameResolutionErrorWithActiveSubchannels() {
+    RingHashConfig config = new RingHashConfig(10, 100, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1);
+
+    initializeLbSubchannels(config, servers, DO_NOT_VERIFY, DO_NOT_RESET_HELPER);
+    verify(helper).createSubchannel(any(CreateSubchannelArgs.class));
+    verify(helper, times(2)).updateBalancingState(eq(IDLE), pickerCaptor.capture());
+
+    // Picking subchannel triggers subchannel creation and connection.
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    pickerCaptor.getValue().pickSubchannel(args);
+    verify(helper, never()).updateBalancingState(eq(READY), any(SubchannelPicker.class));
+    deliverSubchannelState(
+        Iterables.getOnlyElement(subchannels.values()), CSI_READY);
+    verify(helper).updateBalancingState(eq(READY), any(SubchannelPicker.class));
+    reset(helper);
+
+    loadBalancer.handleNameResolutionError(Status.NOT_FOUND.withDescription("target not found"));
+    verifyNoMoreInteractions(helper);
+  }
+
+  @Test
+  public void duplicateAddresses() {
+    RingHashConfig config = new RingHashConfig(10, 100, "");
+    List<EquivalentAddressGroup> servers = createRepeatedServerAddrs(1, 2, 3);
+
+    initializeLbSubchannels(config, servers, DO_NOT_VERIFY);
+
+    verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+
+    PickSubchannelArgs args = getDefaultPickSubchannelArgs(hashFunc.hashVoid());
+    PickResult result = pickerCaptor.getValue().pickSubchannel(args);
+    assertThat(result.getStatus().isOk()).isFalse();  // fail the RPC
+    assertThat(result.getStatus().getCode())
+        .isEqualTo(Code.UNAVAILABLE);  // with error status for the original server hit by hash
+    String description = result.getStatus().getDescription();
+    assertThat(description).startsWith(
+        "Ring hash lb error: EDS resolution was successful, but there were duplicate addresses: ");
+    assertThat(description).contains("Address: FakeSocketAddress-server1, count: 2");
+    assertThat(description).contains("Address: FakeSocketAddress-server2, count: 3");
+  }
+
+  @Test
+  public void subchannelHealthObserved() throws Exception {
+    // Only the new PF policy observes the new separate listener for health
+    PickFirstLoadBalancerProviderAccessor.setEnableNewPickFirst(true);
+    // PickFirst does most of this work. If the test fails, check IS_PETIOLE_POLICY
+    Map<Subchannel, LoadBalancer.SubchannelStateListener> healthListeners = new HashMap<>();
+    loadBalancer = new RingHashLoadBalancer(new ForwardingLoadBalancerHelper() {
+      @Override
+      public Subchannel createSubchannel(CreateSubchannelArgs args) {
+        Subchannel subchannel = super.createSubchannel(args.toBuilder()
+            .setAttributes(args.getAttributes().toBuilder()
+              .set(LoadBalancer.HAS_HEALTH_PRODUCER_LISTENER_KEY, true)
+              .build())
+            .build());
+        healthListeners.put(
+            subchannel, args.getOption(LoadBalancer.HEALTH_CONSUMER_LISTENER_ARG_KEY));
+        return subchannel;
+      }
+
+      @Override
+      protected Helper delegate() {
+        return helper;
+      }
+    });
+
+    InOrder inOrder = Mockito.inOrder(helper);
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1);
+    initializeLbSubchannels(new RingHashConfig(10, 100, ""), servers);
+    Subchannel subchannel0 = subchannels.get(Collections.singletonList(servers.get(0)));
+    Subchannel subchannel1 = subchannels.get(Collections.singletonList(servers.get(1)));
+
+    // Subchannels go READY, but the LB waits for health
+    for (Subchannel subchannel : subchannels.values()) {
+      deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(READY));
+    }
+    inOrder.verify(helper, times(0)).updateBalancingState(eq(READY), any(SubchannelPicker.class));
+
+    // Health results lets subchannels go READY
+    healthListeners.get(subchannel0).onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    healthListeners.get(subchannel1).onSubchannelState(ConnectivityStateInfo.forNonError(READY));
+    inOrder.verify(helper, times(2)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    SubchannelPicker picker = pickerCaptor.getValue();
+    Random random = new Random(1);
+    Set<Subchannel> picks = new HashSet<>();
+    for (int i = 0; i < 10; i++) {
+      picks.add(
+          picker.pickSubchannel(getDefaultPickSubchannelArgs(random.nextLong())).getSubchannel());
+    }
+    assertThat(picks).containsExactly(subchannel0, subchannel1);
+
+    // Unhealthy subchannel skipped
+    healthListeners.get(subchannel0).onSubchannelState(
+        ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE.withDescription("oh no")));
+    inOrder.verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    picker = pickerCaptor.getValue();
+    random.setSeed(1);
+    picks.clear();
+    for (int i = 0; i < 10; i++) {
+      picks.add(
+          picker.pickSubchannel(getDefaultPickSubchannelArgs(random.nextLong())).getSubchannel());
+    }
+    assertThat(picks).containsExactly(subchannel1);
+  }
+
+  @Test
+  public void config_equalsTester() {
+    new EqualsTester()
+        .addEqualityGroup(
+            new RingHashConfig(1, 2, "headerA"),
+            new RingHashConfig(1, 2, "headerA"))
+        .addEqualityGroup(new RingHashConfig(1, 1, "headerA"))
+        .addEqualityGroup(new RingHashConfig(2, 2, "headerA"))
+        .addEqualityGroup(new RingHashConfig(1, 2, "headerB"))
+        .addEqualityGroup(new RingHashConfig(1, 2, ""))
+        .testEquals();
+  }
+
+  @Test
+  public void tfWithoutConnectingChild_triggersIdleChildConnection() {
+    RingHashConfig config = new RingHashConfig(10, 100, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1);
+
+    initializeLbSubchannels(config, servers);
+
+    Subchannel tfSubchannel = getSubchannel(servers, 0);
+    Subchannel idleSubchannel = getSubchannel(servers, 1);
+
+    deliverSubchannelUnreachable(tfSubchannel);
+
+    Subchannel requested = connectionRequestedQueue.poll();
+    assertThat(requested).isSameInstanceAs(idleSubchannel);
+    assertThat(connectionRequestedQueue.poll()).isNull();
+  }
+
+  @Test
+  public void tfWithReadyChild_doesNotTriggerIdleChildConnection() {
+    RingHashConfig config = new RingHashConfig(10, 100, "");
+    List<EquivalentAddressGroup> servers = createWeightedServerAddrs(1, 1, 1);
+
+    initializeLbSubchannels(config, servers);
+
+    Subchannel tfSubchannel = getSubchannel(servers, 0);
+    Subchannel readySubchannel = getSubchannel(servers, 1);
+
+    deliverSubchannelState(readySubchannel, ConnectivityStateInfo.forNonError(READY));
+    deliverSubchannelUnreachable(tfSubchannel);
+
+    assertThat(connectionRequestedQueue.poll()).isNull();
+  }
+
+  private List<Subchannel> initializeLbSubchannels(RingHashConfig config,
+      List<EquivalentAddressGroup> servers, InitializationFlags... initFlags) {
+
+    boolean doVerifies = true;
+    boolean resetSubchannels = false;
+    boolean returnToIdle = true;
+    boolean resetHelper = true;
+    for (InitializationFlags flag : initFlags) {
+      switch (flag) {
+        case DO_NOT_VERIFY:
+          doVerifies = false;
+          break;
+        case RESET_SUBCHANNEL_MOCKS:
+          resetSubchannels = true;
+          break;
+        case STAY_IN_CONNECTING:
+          returnToIdle = false;
+          break;
+        case DO_NOT_RESET_HELPER:
+          resetHelper = false;
+          break;
+        default:
+          throw new IllegalArgumentException("Unrecognized flag: " + flag);
+      }
+    }
+
+    Status addressesAcceptanceStatus =
+        loadBalancer.acceptResolvedAddresses(
+            ResolvedAddresses.newBuilder()
+                .setAddresses(servers).setLoadBalancingPolicyConfig(config).build());
+
+    if (doVerifies) {
+      assertThat(addressesAcceptanceStatus.isOk()).isTrue();
+      verify(helper).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
+    }
+
+    if (!addressesAcceptanceStatus.isOk()) {
+      return new ArrayList<>();
+    }
+
+    // Activate them all to create the child LB and subchannel
+    for (ChildLbState childLbState : loadBalancer.getChildLbStates()) {
+      childLbState.getCurrentPicker()
+          .pickSubchannel(getDefaultPickSubchannelArgs(hashFunc.hashVoid()));
+    }
+
+    if (doVerifies) {
+      verify(helper, times(servers.size())).createSubchannel(any(CreateSubchannelArgs.class));
+      verify(helper, times(servers.size()))
+          .updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+      verifyConnection(servers.size());
+    }
+
+    if (returnToIdle) {
+      for (Subchannel subchannel : subchannels.values()) {
+        deliverSubchannelState(subchannel, ConnectivityStateInfo.forNonError(IDLE));
+      }
+      if (doVerifies) {
+        verify(helper, times(2 * servers.size() - 1))
+            .updateBalancingState(eq(CONNECTING), any(SubchannelPicker.class));
+        verify(helper, times(2)).updateBalancingState(eq(IDLE), any(SubchannelPicker.class));
+      }
+    }
+
+
+    // Get a list of subchannels in the same order as servers
+    List<Subchannel> subchannelList = new ArrayList<>();
+    for (EquivalentAddressGroup server : servers) {
+      List<EquivalentAddressGroup> singletonList = Collections.singletonList(server);
+      Subchannel subchannel = subchannels.get(singletonList);
+      subchannelList.add(subchannel);
+      if (resetSubchannels) {
+        reset(subchannel);
+      }
+    }
+
+    if (resetHelper) {
+      reset(helper);
+    }
+
+    return subchannelList;
+  }
+
+  private void deliverSubchannelState(Subchannel subchannel, ConnectivityStateInfo state) {
+    testHelperInst.deliverSubchannelState(subchannel, state);
+  }
+
+  private void deliverNotFound(List<Subchannel> subChannelList, int index) {
+    deliverSubchannelState(
+        subChannelList.get(index),
+        ConnectivityStateInfo.forTransientFailure(
+            Status.UNAVAILABLE.withDescription("also not found")));
+  }
+
+  protected void deliverSubchannelUnreachable(Subchannel subchannel) {
+    deliverSubchannelState(subchannel,
+        ConnectivityStateInfo.forTransientFailure(
+            Status.UNAVAILABLE.withDescription(
+                subchannel.getAddresses().getAddresses() + "unreachable")));
+
+  }
+
+  private static List<EquivalentAddressGroup> createWeightedServerAddrs(long... weights) {
+    List<EquivalentAddressGroup> addrs = new ArrayList<>();
+    for (int i = 0; i < weights.length; i++) {
+      SocketAddress addr = new FakeSocketAddress("server" + i);
+      Attributes attr = Attributes.newBuilder().set(
+          XdsAttributes.ATTR_SERVER_WEIGHT, weights[i]).build();
+      EquivalentAddressGroup eag = new EquivalentAddressGroup(addr, attr);
+      addrs.add(eag);
+    }
+    return addrs;
+  }
+
+  private static List<EquivalentAddressGroup> createRepeatedServerAddrs(long... weights) {
+    List<EquivalentAddressGroup> addrs = new ArrayList<>();
+    for (int i = 0; i < weights.length; i++) {
+      SocketAddress addr = new FakeSocketAddress("server" + i);
+      for (int j = 0; j < weights[i]; j++) {
+        EquivalentAddressGroup eag = new EquivalentAddressGroup(addr);
+        addrs.add(eag);
+      }
+    }
+    return addrs;
+  }
+
+  private static class FakeSocketAddress extends SocketAddress {
+    private final String name;
+
+    FakeSocketAddress(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public int hashCode() {
+      return name.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+      if (!(other instanceof FakeSocketAddress)) {
+        return false;
+      }
+      return name.equals(((FakeSocketAddress) other).name);
+    }
+
+    @Override
+    public String toString() {
+      return "FakeSocketAddress-" +  name;
+    }
+  }
+
+  private class TestHelper extends AbstractTestHelper {
+    public TestHelper() {
+      super(new FakeClock(), syncContext);
+    }
+
+    @Override
+    public Map<List<EquivalentAddressGroup>, Subchannel> getSubchannelMap() {
+      return subchannels;
+    }
+
+    @Override
+    public String getAuthority() {
+      return AUTHORITY;
+    }
+
+    private Subchannel getMockSubchannel(Subchannel realSubchannel) {
+      return realToMockSubChannelMap.get(realSubchannel);
+    }
+
+    @Override
+    protected AbstractTestHelper.TestSubchannel createRealSubchannel(CreateSubchannelArgs args) {
+      return new RingHashTestSubchannel(args);
+    }
+
+    private class RingHashTestSubchannel extends AbstractTestHelper.TestSubchannel {
+
+      RingHashTestSubchannel(CreateSubchannelArgs args) {
+        super(args);
+      }
+
+      @Override
+      public void requestConnection() {
+        connectionRequestedQueue.offer(getMockSubchannel(this));
+      }
+
+    }
+  }
+
+  private static final class FakeRandom implements ThreadSafeRandom {
+    int counter = 0;
+
+    @Override
+    public int nextInt(int bound) {
+      throw new UnsupportedOperationException("Should not be called");
+    }
+
+    @Override
+    public long nextLong() {
+      ++counter;
+      if (counter % 2 == 0) {
+        return XxHash64.INSTANCE.hashAsciiString("FakeSocketAddress-server0_0");
+      } else {
+        return XxHash64.INSTANCE.hashAsciiString("FakeSocketAddress-server1_0");
+      }
+    }
+
+    @Override
+    public long nextLong(long bound) {
+      throw new UnsupportedOperationException("Should not be called");
+    }
+  }
+
+  enum InitializationFlags {
+    DO_NOT_VERIFY,
+    RESET_SUBCHANNEL_MOCKS,
+    STAY_IN_CONNECTING,
+    DO_NOT_RESET_HELPER
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/RouteLookupServiceClusterSpecifierPluginTest.java b/xds/src/test/java/io/grpc/xds/RouteLookupServiceClusterSpecifierPluginTest.java
new file mode 100644
index 00000000000..25b47232c45
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/RouteLookupServiceClusterSpecifierPluginTest.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Any;
+import com.google.protobuf.util.Durations;
+import io.grpc.lookup.v1.GrpcKeyBuilder;
+import io.grpc.lookup.v1.GrpcKeyBuilder.ExtraKeys;
+import io.grpc.lookup.v1.GrpcKeyBuilder.Name;
+import io.grpc.lookup.v1.NameMatcher;
+import io.grpc.lookup.v1.RouteLookupClusterSpecifier;
+import io.grpc.lookup.v1.RouteLookupConfig;
+import io.grpc.xds.RouteLookupServiceClusterSpecifierPlugin.RlsPluginConfig;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link RouteLookupServiceClusterSpecifierPlugin}. */
+@RunWith(JUnit4.class)
+public class RouteLookupServiceClusterSpecifierPluginTest {
+  @Test
+  public void parseConfigWithAllFieldsGiven() {
+    RouteLookupConfig routeLookupConfig = RouteLookupConfig.newBuilder()
+        .addGrpcKeybuilders(
+            GrpcKeyBuilder.newBuilder()
+                .addNames(Name.newBuilder().setService("service1").setMethod("method1"))
+                .addNames(Name.newBuilder().setService("service2").setMethod("method2"))
+                .addHeaders(
+                    NameMatcher.newBuilder().setKey("key1").addNames("v1").setRequiredMatch(true))
+                .setExtraKeys(
+                    ExtraKeys.newBuilder()
+                        .setHost("host1").setService("service1").setMethod("method1"))
+                .putConstantKeys("key2", "value2"))
+        .setLookupService("rls-cbt.googleapis.com")
+        .setLookupServiceTimeout(Durations.fromMillis(1234))
+        .setMaxAge(Durations.fromMillis(56789))
+        .setStaleAge(Durations.fromMillis(1000))
+        .setCacheSizeBytes(5000)
+        .addValidTargets("valid-target")
+        .setDefaultTarget("default-target")
+        .build();
+    RouteLookupClusterSpecifier specifier =
+        RouteLookupClusterSpecifier.newBuilder().setRouteLookupConfig(routeLookupConfig).build();
+    RlsPluginConfig config =
+        RouteLookupServiceClusterSpecifierPlugin.INSTANCE.parsePlugin(Any.pack(specifier))
+            .config;
+    assertThat(config.typeUrl())
+        .isEqualTo("type.googleapis.com/grpc.lookup.v1.RouteLookupClusterSpecifier");
+    assertThat(config.config()).isEqualTo(
+        ImmutableMap.builder()
+            .put(
+                "grpcKeybuilders",
+                ImmutableList.of(ImmutableMap.of(
+                    "names",
+                    ImmutableList.of(
+                        ImmutableMap.of("service", "service1", "method", "method1"),
+                        ImmutableMap.of("service", "service2", "method", "method2")),
+                    "headers",
+                    ImmutableList.of(
+                        ImmutableMap.of(
+                            "key", "key1", "names", ImmutableList.of("v1"),
+                            "requiredMatch", true)),
+                    "extraKeys",
+                    ImmutableMap.of("host", "host1", "service", "service1", "method", "method1"),
+                    "constantKeys",
+                    ImmutableMap.of("key2", "value2"))))
+            .put("lookupService", "rls-cbt.googleapis.com")
+            .put("lookupServiceTimeout", "1.234s")
+            .put("maxAge", "56.789s")
+            .put("staleAge", "1s")
+            .put("cacheSizeBytes", "5000")
+            .put("validTargets", ImmutableList.of("valid-target"))
+            .put("defaultTarget","default-target")
+            .buildOrThrow());
+  }
+
+  @Test
+  public void parseConfigWithOptionalFieldsUnspecified() {
+    RouteLookupConfig routeLookupConfig = RouteLookupConfig.newBuilder()
+        .addGrpcKeybuilders(
+            GrpcKeyBuilder.newBuilder()
+                .addNames(Name.newBuilder().setService("service1"))
+                .addNames(Name.newBuilder().setService("service2"))
+                .addHeaders(
+                    NameMatcher.newBuilder().setKey("key1").addNames("v1").setRequiredMatch(true)))
+        .setLookupService("rls-cbt.googleapis.com")
+        .setLookupServiceTimeout(Durations.fromMillis(1234))
+        .setCacheSizeBytes(5000)
+        .addValidTargets("valid-target")
+        .build();
+    RouteLookupClusterSpecifier specifier =
+        RouteLookupClusterSpecifier.newBuilder().setRouteLookupConfig(routeLookupConfig).build();
+    RlsPluginConfig config =
+        RouteLookupServiceClusterSpecifierPlugin.INSTANCE.parsePlugin(Any.pack(specifier))
+            .config;
+    assertThat(config.typeUrl())
+        .isEqualTo("type.googleapis.com/grpc.lookup.v1.RouteLookupClusterSpecifier");
+    assertThat(config.config()).isEqualTo(
+        ImmutableMap.builder()
+            .put(
+                "grpcKeybuilders",
+                ImmutableList.of(ImmutableMap.of(
+                    "names",
+                    ImmutableList.of(
+                        ImmutableMap.of("service", "service1"),
+                        ImmutableMap.of("service", "service2")),
+                    "headers",
+                    ImmutableList.of(
+                        ImmutableMap.of(
+                            "key", "key1", "names", ImmutableList.of("v1"),
+                            "requiredMatch", true)))))
+            .put("lookupService", "rls-cbt.googleapis.com")
+            .put("lookupServiceTimeout", "1.234s")
+            .put("cacheSizeBytes", "5000")
+            .put("validTargets", ImmutableList.of("valid-target"))
+            .buildOrThrow());
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/RouterFilterTest.java b/xds/src/test/java/io/grpc/xds/RouterFilterTest.java
new file mode 100644
index 00000000000..30fd8a6dc38
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/RouterFilterTest.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2025 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link RouterFilter}. */
+@RunWith(JUnit4.class)
+public class RouterFilterTest {
+  private static final RouterFilter.Provider FILTER_PROVIDER = new RouterFilter.Provider();
+
+  @Test
+  public void filterType_clientAndServer() {
+    assertThat(FILTER_PROVIDER.isClientFilter()).isTrue();
+    assertThat(FILTER_PROVIDER.isServerFilter()).isTrue();
+  }
+
+}
diff --git a/xds/src/test/java/io/grpc/xds/RoutingUtilsTest.java b/xds/src/test/java/io/grpc/xds/RoutingUtilsTest.java
new file mode 100644
index 00000000000..a460501e85b
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/RoutingUtilsTest.java
@@ -0,0 +1,231 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.re2j.Pattern;
+import io.grpc.Metadata;
+import io.grpc.xds.VirtualHost.Route;
+import io.grpc.xds.VirtualHost.Route.RouteMatch;
+import io.grpc.xds.VirtualHost.Route.RouteMatch.PathMatcher;
+import io.grpc.xds.internal.Matchers.HeaderMatcher;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link RoutingUtils }. */
+@RunWith(JUnit4.class)
+public class RoutingUtilsTest {
+
+  @Test
+  public void findVirtualHostForHostName_exactMatchFirst() {
+    String hostname = "a.googleapis.com";
+    List<Route> routes = Collections.emptyList();
+    VirtualHost vHost1 = VirtualHost.create("virtualhost01.googleapis.com",
+        Arrays.asList("a.googleapis.com", "b.googleapis.com"), routes,
+        ImmutableMap.of());
+    VirtualHost vHost2 = VirtualHost.create("virtualhost02.googleapis.com",
+        Collections.singletonList("*.googleapis.com"), routes,
+        ImmutableMap.of());
+    VirtualHost vHost3 = VirtualHost.create("virtualhost03.googleapis.com",
+        Collections.singletonList("*"), routes,
+        ImmutableMap.of());
+    List<VirtualHost> virtualHosts = Arrays.asList(vHost1, vHost2, vHost3);
+    assertThat(RoutingUtils.findVirtualHostForHostName(virtualHosts, hostname))
+         .isEqualTo(vHost1);
+  }
+
+  @Test
+  public void findVirtualHostForHostName_preferSuffixDomainOverPrefixDomain() {
+    String hostname = "a.googleapis.com";
+    List<Route> routes = Collections.emptyList();
+    VirtualHost vHost1 = VirtualHost.create("virtualhost01.googleapis.com",
+        Arrays.asList("*.googleapis.com", "b.googleapis.com"), routes,
+        ImmutableMap.of());
+    VirtualHost vHost2 = VirtualHost.create("virtualhost02.googleapis.com",
+        Collections.singletonList("a.googleapis.*"), routes,
+        ImmutableMap.of());
+    VirtualHost vHost3 = VirtualHost.create("virtualhost03.googleapis.com",
+        Collections.singletonList("*"), routes,
+        ImmutableMap.of());
+    List<VirtualHost> virtualHosts = Arrays.asList(vHost1, vHost2, vHost3);
+    assertThat(RoutingUtils.findVirtualHostForHostName(virtualHosts, hostname))
+        .isEqualTo(vHost1);
+  }
+
+  @Test
+  public void findVirtualHostForHostName_asteriskMatchAnyDomain() {
+    String hostname = "a.googleapis.com";
+    List<Route> routes = Collections.emptyList();
+    VirtualHost vHost1 = VirtualHost.create("virtualhost01.googleapis.com",
+        Collections.singletonList("*"), routes,
+        ImmutableMap.of());
+    VirtualHost vHost2 = VirtualHost.create("virtualhost02.googleapis.com",
+        Collections.singletonList("b.googleapis.com"), routes,
+        ImmutableMap.of());
+    List<VirtualHost> virtualHosts = Arrays.asList(vHost1, vHost2);
+    assertThat(RoutingUtils.findVirtualHostForHostName(virtualHosts, hostname))
+        .isEqualTo(vHost1);
+  }
+
+  @Test
+  public void routeMatching_pathOnly() {
+    Metadata headers = new Metadata();
+    ThreadSafeRandom random = mock(ThreadSafeRandom.class);
+
+    RouteMatch routeMatch1 =
+        RouteMatch.create(
+            PathMatcher.fromPath("/FooService/barMethod", true),
+            Collections.emptyList(), null);
+    assertThat(RoutingUtils.matchRoute(routeMatch1, "/FooService/barMethod", headers, random))
+        .isTrue();
+    assertThat(RoutingUtils.matchRoute(routeMatch1, "/FooService/bazMethod", headers, random))
+        .isFalse();
+
+    RouteMatch routeMatch2 =
+        RouteMatch.create(
+            PathMatcher.fromPrefix("/FooService/", true),
+            Collections.emptyList(), null);
+    assertThat(RoutingUtils.matchRoute(routeMatch2, "/FooService/barMethod", headers, random))
+        .isTrue();
+    assertThat(RoutingUtils.matchRoute(routeMatch2, "/FooService/bazMethod", headers, random))
+        .isTrue();
+    assertThat(RoutingUtils.matchRoute(routeMatch2, "/BarService/bazMethod", headers, random))
+        .isFalse();
+
+    RouteMatch routeMatch3 =
+        RouteMatch.create(
+            PathMatcher.fromRegEx(Pattern.compile(".*Foo.*")),
+            Collections.emptyList(), null);
+    assertThat(RoutingUtils.matchRoute(routeMatch3, "/FooService/barMethod", headers, random))
+        .isTrue();
+  }
+
+  @Test
+  public void routeMatching_pathOnly_caseInsensitive() {
+    Metadata headers = new Metadata();
+    ThreadSafeRandom random = mock(ThreadSafeRandom.class);
+
+    RouteMatch routeMatch1 =
+        RouteMatch.create(
+            PathMatcher.fromPath("/FooService/barMethod", false),
+            Collections.emptyList(), null);
+    assertThat(RoutingUtils.matchRoute(routeMatch1, "/fooservice/barmethod", headers, random))
+        .isTrue();
+
+    RouteMatch routeMatch2 =
+        RouteMatch.create(
+            PathMatcher.fromPrefix("/FooService", false),
+            Collections.emptyList(), null);
+    assertThat(RoutingUtils.matchRoute(routeMatch2, "/fooservice/barmethod", headers, random))
+        .isTrue();
+  }
+
+  @Test
+  public void routeMatching_withHeaders() {
+    Metadata headers = new Metadata();
+    headers.put(Metadata.Key.of("authority", Metadata.ASCII_STRING_MARSHALLER),
+        "foo.googleapis.com");
+    headers.put(Metadata.Key.of("grpc-encoding", Metadata.ASCII_STRING_MARSHALLER), "gzip");
+    headers.put(Metadata.Key.of("user-agent", Metadata.ASCII_STRING_MARSHALLER), "gRPC-Java");
+    headers.put(Metadata.Key.of("content-length", Metadata.ASCII_STRING_MARSHALLER), "1000");
+    headers.put(Metadata.Key.of("custom-key", Metadata.ASCII_STRING_MARSHALLER), "custom-value1");
+    headers.put(Metadata.Key.of("custom-key", Metadata.ASCII_STRING_MARSHALLER), "custom-value2");
+    ThreadSafeRandom random = mock(ThreadSafeRandom.class);
+
+    PathMatcher pathMatcher = PathMatcher.fromPath("/FooService/barMethod", true);
+    RouteMatch routeMatch1 = RouteMatch.create(
+        pathMatcher,
+        Arrays.asList(
+            HeaderMatcher.forExactValue("grpc-encoding", "gzip", false),
+            HeaderMatcher.forSafeRegEx("authority", Pattern.compile(".*googleapis.*"), false),
+            HeaderMatcher.forRange(
+                "content-length", HeaderMatcher.Range.create(100, 10000), false),
+            HeaderMatcher.forPresent("user-agent", true, false),
+            HeaderMatcher.forPrefix("custom-key", "custom-", false),
+            HeaderMatcher.forSuffix("custom-key", "value2", false)),
+            null);
+    assertThat(RoutingUtils.matchRoute(routeMatch1, "/FooService/barMethod", headers, random))
+        .isTrue();
+
+    RouteMatch routeMatch2 = RouteMatch.create(
+        pathMatcher,
+        Collections.singletonList(
+            HeaderMatcher.forSafeRegEx("authority", Pattern.compile(".*googleapis.*"), true)),
+        null);
+    assertThat(RoutingUtils.matchRoute(routeMatch2, "/FooService/barMethod", headers, random))
+        .isFalse();
+
+    RouteMatch routeMatch3 = RouteMatch.create(
+        pathMatcher,
+        Collections.singletonList(
+            HeaderMatcher.forExactValue("user-agent", "gRPC-Go", false)), null);
+    assertThat(RoutingUtils.matchRoute(routeMatch3, "/FooService/barMethod", headers, random))
+        .isFalse();
+
+    RouteMatch routeMatch4 = RouteMatch.create(
+        pathMatcher,
+        Collections.singletonList(HeaderMatcher.forPresent("user-agent", false, false)),
+        null);
+    assertThat(RoutingUtils.matchRoute(routeMatch4, "/FooService/barMethod", headers, random))
+        .isFalse();
+
+    RouteMatch routeMatch5 = RouteMatch.create(
+        pathMatcher,
+        Collections.singletonList(HeaderMatcher.forPresent("user-agent", false, true)), // inverted
+        null);
+    assertThat(RoutingUtils.matchRoute(routeMatch5, "/FooService/barMethod", headers, random))
+        .isTrue();
+
+    RouteMatch routeMatch6 = RouteMatch.create(
+        pathMatcher,
+        Collections.singletonList(HeaderMatcher.forPresent("user-agent", true, true)),
+        null);
+    assertThat(RoutingUtils.matchRoute(routeMatch6, "/FooService/barMethod", headers, random))
+        .isFalse();
+
+    RouteMatch routeMatch7 = RouteMatch.create(
+        pathMatcher,
+        Collections.singletonList(
+            HeaderMatcher.forExactValue("custom-key", "custom-value1,custom-value2", false)),
+        null);
+    assertThat(RoutingUtils.matchRoute(routeMatch7, "/FooService/barMethod", headers, random))
+        .isTrue();
+
+    RouteMatch routeMatch8 = RouteMatch.create(
+        pathMatcher,
+        Collections.singletonList(
+            HeaderMatcher.forExactValue("content-type", "application/grpc", false)),
+        null);
+    assertThat(RoutingUtils.matchRoute(
+        routeMatch8, "/FooService/barMethod", new Metadata(), random)).isTrue();
+
+    RouteMatch routeMatch9 = RouteMatch.create(
+        pathMatcher,
+        Collections.singletonList(
+            HeaderMatcher.forExactValue("custom-key!", "custom-value1,custom-value2", false)),
+        null);
+    assertThat(RoutingUtils.matchRoute(routeMatch9, "/FooService/barMethod", headers, random))
+        .isFalse();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/SharedCallCounterMapTest.java b/xds/src/test/java/io/grpc/xds/SharedCallCounterMapTest.java
new file mode 100644
index 00000000000..3b10c0c0e31
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/SharedCallCounterMapTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2019 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.testing.GcFinalization;
+import com.google.common.testing.GcFinalization.FinalizationPredicate;
+import io.grpc.xds.SharedCallCounterMap.CounterReference;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicLong;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link SharedCallCounterMap}.
+ */
+@RunWith(JUnit4.class)
+public class SharedCallCounterMapTest {
+
+  private static final String CLUSTER = "cluster-foo.googleapis.com";
+  private static final String EDS_SERVICE_NAME = null;
+
+  private final Map<String, Map<String, CounterReference>> counters = new HashMap<>();
+  private final SharedCallCounterMap map = new SharedCallCounterMap(counters);
+
+  @Test
+  public void sharedCounterInstance() {
+    AtomicLong counter1 = map.getOrCreate(CLUSTER, EDS_SERVICE_NAME);
+    AtomicLong counter2 = map.getOrCreate(CLUSTER, EDS_SERVICE_NAME);
+    assertThat(counter2).isSameInstanceAs(counter1);
+  }
+
+  @Test
+  public void autoCleanUp() {
+    @SuppressWarnings("UnusedVariable")
+    AtomicLong counter = map.getOrCreate(CLUSTER, EDS_SERVICE_NAME);
+    final CounterReference ref = counters.get(CLUSTER).get(EDS_SERVICE_NAME);
+    counter = null;
+    GcFinalization.awaitDone(new FinalizationPredicate() {
+      @SuppressWarnings("deprecation") // Use refersTo(null) once we require Java 17+
+      @Override
+      public boolean isDone() {
+        return ref.isEnqueued();
+      }
+    });
+    map.cleanQueue();
+    assertThat(counters).isEmpty();
+  }
+
+  @Test
+  public void gcAndRecreate() {
+    @SuppressWarnings("UnusedVariable") // assign to null for GC only
+    AtomicLong counter = map.getOrCreate(CLUSTER, EDS_SERVICE_NAME);
+    final CounterReference ref = counters.get(CLUSTER).get(EDS_SERVICE_NAME);
+    assertThat(counter.get()).isEqualTo(0);
+    counter = null;
+    GcFinalization.awaitDone(new FinalizationPredicate() {
+      @SuppressWarnings("deprecation") // Use refersTo(null) once we require Java 17+
+      @Override
+      public boolean isDone() {
+        return ref.isEnqueued();
+      }
+    });
+    map.getOrCreate(CLUSTER, EDS_SERVICE_NAME);
+    assertThat(counters.get(CLUSTER)).isNotNull();
+    assertThat(counters.get(CLUSTER).get(EDS_SERVICE_NAME)).isNotNull();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/SharedXdsClientPoolProviderTest.java b/xds/src/test/java/io/grpc/xds/SharedXdsClientPoolProviderTest.java
new file mode 100644
index 00000000000..29b149f166f
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/SharedXdsClientPoolProviderTest.java
@@ -0,0 +1,223 @@
+/*
+ * 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.xds;
+
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.Metadata.ASCII_STRING_MARSHALLER;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.auth.oauth2.AccessToken;
+import com.google.auth.oauth2.OAuth2Credentials;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.CallCredentials;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.Metadata;
+import io.grpc.MetricRecorder;
+import io.grpc.Server;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.auth.MoreCallCredentials;
+import io.grpc.internal.ObjectPool;
+import io.grpc.xds.SharedXdsClientPoolProvider.RefCountedXdsClientObjectPool;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsClient.ResourceWatcher;
+import io.grpc.xds.client.XdsInitializationException;
+import java.util.Collections;
+import java.util.concurrent.TimeUnit;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Tests for {@link SharedXdsClientPoolProvider}. */
+@RunWith(JUnit4.class)
+public class SharedXdsClientPoolProviderTest {
+
+  private static final String SERVER_URI = "trafficdirector.googleapis.com";
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  private final Node node = Node.newBuilder().setId("SharedXdsClientPoolProviderTest").build();
+  private final MetricRecorder metricRecorder = new MetricRecorder() {};
+  private static final String DUMMY_TARGET = "dummy";
+  static final Metadata.Key<String> AUTHORIZATION_METADATA_KEY =
+      Metadata.Key.of("Authorization", ASCII_STRING_MARSHALLER);
+
+  @Mock
+  private GrpcBootstrapperImpl bootstrapper;
+  @Mock private ResourceWatcher<LdsUpdate> ldsResourceWatcher;
+
+  @Deprecated
+  @Test
+  public void sharedXdsClientObjectPool_deprecated() throws XdsInitializationException {
+    ServerInfo server = ServerInfo.create(SERVER_URI, InsecureChannelCredentials.create());
+    BootstrapInfo bootstrapInfo =
+        BootstrapInfo.builder().servers(Collections.singletonList(server)).node(node).build();
+    when(bootstrapper.bootstrap()).thenReturn(bootstrapInfo);
+
+    SharedXdsClientPoolProvider provider = new SharedXdsClientPoolProvider(bootstrapper);
+    assertThat(provider.get(DUMMY_TARGET)).isNull();
+    ObjectPool<XdsClient> xdsClientPool =
+        provider.getOrCreate(DUMMY_TARGET, metricRecorder, null);
+    verify(bootstrapper).bootstrap();
+    assertThat(provider.getOrCreate(DUMMY_TARGET, bootstrapInfo, metricRecorder))
+        .isSameInstanceAs(xdsClientPool);
+    assertThat(provider.get(DUMMY_TARGET)).isNotNull();
+    assertThat(provider.get(DUMMY_TARGET)).isSameInstanceAs(xdsClientPool);
+    verifyNoMoreInteractions(bootstrapper);
+  }
+
+  @Test
+  public void sharedXdsClientObjectPool() throws XdsInitializationException {
+    ServerInfo server = ServerInfo.create(SERVER_URI, InsecureChannelCredentials.create());
+    BootstrapInfo bootstrapInfo =
+        BootstrapInfo.builder().servers(Collections.singletonList(server)).node(node).build();
+
+    SharedXdsClientPoolProvider provider = new SharedXdsClientPoolProvider(bootstrapper);
+    assertThat(provider.get(DUMMY_TARGET)).isNull();
+    ObjectPool<XdsClient> xdsClientPool =
+        provider.getOrCreate(DUMMY_TARGET, bootstrapInfo, metricRecorder);
+    verify(bootstrapper, never()).bootstrap();
+    assertThat(provider.getOrCreate(DUMMY_TARGET, bootstrapInfo, metricRecorder))
+        .isSameInstanceAs(xdsClientPool);
+    assertThat(provider.get(DUMMY_TARGET)).isNotNull();
+    assertThat(provider.get(DUMMY_TARGET)).isSameInstanceAs(xdsClientPool);
+    verifyNoMoreInteractions(bootstrapper);
+  }
+
+  @Test
+  public void refCountedXdsClientObjectPool_delayedCreation() {
+    ServerInfo server = ServerInfo.create(SERVER_URI, InsecureChannelCredentials.create());
+    BootstrapInfo bootstrapInfo =
+        BootstrapInfo.builder().servers(Collections.singletonList(server)).node(node).build();
+    SharedXdsClientPoolProvider provider = new SharedXdsClientPoolProvider();
+    RefCountedXdsClientObjectPool xdsClientPool =
+        provider.new RefCountedXdsClientObjectPool(bootstrapInfo, DUMMY_TARGET, metricRecorder);
+    assertThat(xdsClientPool.getXdsClientForTest()).isNull();
+    XdsClient xdsClient = xdsClientPool.getObject();
+    assertThat(xdsClientPool.getXdsClientForTest()).isNotNull();
+    xdsClientPool.returnObject(xdsClient);
+  }
+
+  @Test
+  public void refCountedXdsClientObjectPool_refCounted() {
+    ServerInfo server = ServerInfo.create(SERVER_URI, InsecureChannelCredentials.create());
+    BootstrapInfo bootstrapInfo =
+        BootstrapInfo.builder().servers(Collections.singletonList(server)).node(node).build();
+    SharedXdsClientPoolProvider provider = new SharedXdsClientPoolProvider();
+    RefCountedXdsClientObjectPool xdsClientPool =
+        provider.new RefCountedXdsClientObjectPool(bootstrapInfo, DUMMY_TARGET, metricRecorder);
+    // getObject once
+    XdsClient xdsClient = xdsClientPool.getObject();
+    assertThat(xdsClient).isNotNull();
+    // getObject twice
+    assertThat(xdsClientPool.getObject()).isSameInstanceAs(xdsClient);
+    // returnObject once
+    assertThat(xdsClientPool.returnObject(xdsClient)).isNull();
+    assertThat(xdsClient.isShutDown()).isFalse();
+    // returnObject twice
+    assertThat(xdsClientPool.returnObject(xdsClient)).isNull();
+    assertThat(xdsClient.isShutDown()).isTrue();
+  }
+
+  @Test
+  public void refCountedXdsClientObjectPool_getObjectCreatesNewInstanceIfAlreadyShutdown() {
+    ServerInfo server = ServerInfo.create(SERVER_URI, InsecureChannelCredentials.create());
+    BootstrapInfo bootstrapInfo =
+        BootstrapInfo.builder().servers(Collections.singletonList(server)).node(node).build();
+    SharedXdsClientPoolProvider provider = new SharedXdsClientPoolProvider();
+    RefCountedXdsClientObjectPool xdsClientPool =
+        provider.new RefCountedXdsClientObjectPool(bootstrapInfo, DUMMY_TARGET, metricRecorder);
+    XdsClient xdsClient1 = xdsClientPool.getObject();
+    assertThat(xdsClientPool.returnObject(xdsClient1)).isNull();
+    assertThat(xdsClient1.isShutDown()).isTrue();
+
+    XdsClient xdsClient2 = xdsClientPool.getObject();
+    assertThat(xdsClient2).isNotSameInstanceAs(xdsClient1);
+    xdsClientPool.returnObject(xdsClient2);
+  }
+
+  private class CallCredsServerInterceptor implements ServerInterceptor {
+    private SettableFuture<String> tokenFuture = SettableFuture.create();
+
+    @Override
+    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
+        ServerCall<ReqT, RespT> serverCall,
+        Metadata metadata,
+        ServerCallHandler<ReqT, RespT> next) {
+      tokenFuture.set(metadata.get(AUTHORIZATION_METADATA_KEY));
+      return next.startCall(serverCall, metadata);
+    }
+
+    public String getTokenWithTimeout(long timeout, TimeUnit unit) throws Exception {
+      return tokenFuture.get(timeout, unit);
+    }
+  }
+
+  @Test
+  public void xdsClient_usesCallCredentials() throws Exception {
+    // Set up fake xDS server
+    XdsTestControlPlaneService fakeXdsService = new XdsTestControlPlaneService();
+    CallCredsServerInterceptor callCredentialsInterceptor = new CallCredsServerInterceptor();
+    Server xdsServer =
+        Grpc.newServerBuilderForPort(0, InsecureServerCredentials.create())
+            .addService(fakeXdsService)
+            .intercept(callCredentialsInterceptor)
+            .build()
+            .start();
+    String xdsServerUri = "localhost:" + xdsServer.getPort();
+
+    // Set up bootstrap & xDS client pool provider
+    ServerInfo server = ServerInfo.create(xdsServerUri, InsecureChannelCredentials.create());
+    BootstrapInfo bootstrapInfo =
+        BootstrapInfo.builder().servers(Collections.singletonList(server)).node(node).build();
+    SharedXdsClientPoolProvider provider = new SharedXdsClientPoolProvider();
+
+    // Create custom xDS transport CallCredentials
+    CallCredentials sampleCreds =
+        MoreCallCredentials.from(
+            OAuth2Credentials.create(new AccessToken("token", /* expirationTime= */ null)));
+
+    // Create xDS client that uses the CallCredentials on the transport
+    ObjectPool<XdsClient> xdsClientPool =
+        provider.getOrCreate("target", bootstrapInfo, metricRecorder, sampleCreds);
+    XdsClient xdsClient = xdsClientPool.getObject();
+    xdsClient.watchXdsResource(
+        XdsListenerResource.getInstance(), "someLDSresource", ldsResourceWatcher);
+
+    // Wait for xDS server to get the request and verify that it received the CallCredentials
+    assertThat(callCredentialsInterceptor.getTokenWithTimeout(5, TimeUnit.SECONDS))
+        .isEqualTo("Bearer token");
+
+    // Clean up
+    xdsClientPool.returnObject(xdsClient);
+    xdsServer.shutdownNow();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/StatefulFilter.java b/xds/src/test/java/io/grpc/xds/StatefulFilter.java
new file mode 100644
index 00000000000..4ef662c7ccd
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/StatefulFilter.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright 2025 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.xds;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.ImmutableList.toImmutableList;
+
+import com.google.common.collect.ImmutableList;
+import com.google.protobuf.Message;
+import io.grpc.ServerInterceptor;
+import java.util.ConcurrentModificationException;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.IntStream;
+import javax.annotation.Nullable;
+
+/**
+ * Unlike most singleton-based filters, each StatefulFilter object has a distinct identity.
+ */
+class StatefulFilter implements Filter {
+
+  static final String DEFAULT_TYPE_URL = "type.googleapis.com/grpc.test.StatefulFilter";
+  private final AtomicBoolean shutdown = new AtomicBoolean();
+
+  final int idx;
+  @Nullable volatile String lastCfg = null;
+
+  public StatefulFilter(int idx) {
+    this.idx = idx;
+  }
+
+  public boolean isShutdown() {
+    return shutdown.get();
+  }
+
+  @Override
+  public void close() {
+    if (!shutdown.compareAndSet(false, true)) {
+      throw new ConcurrentModificationException(
+          "Unexpected: StatefulFilter#close called multiple times");
+    }
+  }
+
+  @Nullable
+  @Override
+  public ServerInterceptor buildServerInterceptor(
+      FilterConfig config,
+      @Nullable FilterConfig overrideConfig) {
+    Config cfg = (Config) config;
+    // TODO(sergiitk): to be replaced when name argument passed to the constructor.
+    lastCfg = cfg.getConfig();
+    return null;
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder().append("StatefulFilter{")
+        .append("idx=").append(idx);
+    if (lastCfg != null) {
+      sb.append(", name=").append(lastCfg);
+    }
+    return sb.append("}").toString();
+  }
+
+  static final class Provider implements Filter.Provider {
+
+    private final String typeUrl;
+    private final ConcurrentMap<Integer, StatefulFilter> instances = new ConcurrentHashMap<>();
+
+    volatile int counter;
+
+    Provider() {
+      this(DEFAULT_TYPE_URL);
+    }
+
+    Provider(String typeUrl) {
+      this.typeUrl = typeUrl;
+    }
+
+    @Override
+    public String[] typeUrls() {
+      return new String[]{ typeUrl };
+    }
+
+    @Override
+    public boolean isClientFilter() {
+      return true;
+    }
+
+    @Override
+    public boolean isServerFilter() {
+      return true;
+    }
+
+    @Override
+    public synchronized StatefulFilter newInstance(String name) {
+      StatefulFilter filter = new StatefulFilter(counter++);
+      instances.put(filter.idx, filter);
+      return filter;
+    }
+
+    public synchronized StatefulFilter getInstance(int idx) {
+      return instances.get(idx);
+    }
+
+    public synchronized ImmutableList<StatefulFilter> getAllInstances() {
+      return IntStream.range(0, counter).mapToObj(this::getInstance).collect(toImmutableList());
+    }
+
+    @SuppressWarnings("UnusedMethod")
+    public synchronized int getCount() {
+      return counter;
+    }
+
+    @Override
+    public ConfigOrError<Config> parseFilterConfig(Message rawProtoMessage) {
+      return ConfigOrError.fromConfig(Config.fromProto(rawProtoMessage, typeUrl));
+    }
+
+    @Override
+    public ConfigOrError<Config> parseFilterConfigOverride(Message rawProtoMessage) {
+      return ConfigOrError.fromConfig(Config.fromProto(rawProtoMessage, typeUrl));
+    }
+  }
+
+
+  static final class Config implements FilterConfig {
+
+    private final String typeUrl;
+    private final String config;
+
+    public Config(String config, String typeUrl) {
+      this.config = config;
+      this.typeUrl = typeUrl;
+    }
+
+    public Config(String config) {
+      this(config, DEFAULT_TYPE_URL);
+    }
+
+    public Config() {
+      this("<BLANK>", DEFAULT_TYPE_URL);
+    }
+
+    public static Config fromProto(Message rawProtoMessage, String typeUrl) {
+      checkNotNull(rawProtoMessage, "rawProtoMessage");
+      return new Config(rawProtoMessage.toString(), typeUrl);
+    }
+
+    public String getConfig() {
+      return config;
+    }
+
+    @Override
+    public String typeUrl() {
+      return typeUrl;
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/WeightedRandomPickerTest.java b/xds/src/test/java/io/grpc/xds/WeightedRandomPickerTest.java
new file mode 100644
index 00000000000..691615762bf
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/WeightedRandomPickerTest.java
@@ -0,0 +1,251 @@
+/*
+ * Copyright 2019 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.mock;
+
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.Status;
+import io.grpc.xds.WeightedRandomPicker.WeightedChildPicker;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Tests for {@link WeightedRandomPicker}.
+ */
+@RunWith(JUnit4.class)
+public class WeightedRandomPickerTest {
+
+  @Rule
+  public final MockitoRule mockitoRule = MockitoJUnit.rule();
+
+  @Mock
+  private PickSubchannelArgs pickSubchannelArgs;
+
+  private final PickResult pickResult0 = PickResult.withNoResult();
+  private final PickResult pickResult1 = PickResult.withDrop(Status.UNAVAILABLE);
+  private final PickResult pickResult2 = PickResult.withSubchannel(mock(Subchannel.class));
+  private final PickResult pickResult3 = PickResult.withSubchannel(mock(Subchannel.class));
+
+  private final SubchannelPicker childPicker0 = new SubchannelPicker() {
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      return pickResult0;
+    }
+  };
+
+  private final SubchannelPicker childPicker1 = new SubchannelPicker() {
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      return pickResult1;
+    }
+  };
+
+  private final SubchannelPicker childPicker2 = new SubchannelPicker() {
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      return pickResult2;
+    }
+  };
+
+  private final SubchannelPicker childPicker3 = new SubchannelPicker() {
+    @Override
+    public PickResult pickSubchannel(PickSubchannelArgs args) {
+      return pickResult3;
+    }
+  };
+
+  private static final class FakeRandom implements ThreadSafeRandom {
+    int nextInt;
+    long bound;
+    Long nextLong;
+
+    @Override
+    public int nextInt(int bound) {
+      this.bound = bound;
+
+      assertThat(nextInt).isAtLeast(0);
+      assertThat(nextInt).isLessThan(bound);
+      return nextInt;
+    }
+
+    @Override
+    public long nextLong() {
+      throw new UnsupportedOperationException("Should not be called");
+    }
+
+    @Override
+    public long nextLong(long bound) {
+      this.bound = bound;
+
+      if (nextLong == null) {
+        assertThat(nextInt).isAtLeast(0);
+        if (bound <= Integer.MAX_VALUE) {
+          assertThat(nextInt).isLessThan((int)bound);
+        }
+        return nextInt;
+      }
+
+      assertThat(nextLong).isAtLeast(0);
+      assertThat(nextLong).isLessThan(bound);
+      return nextLong;
+    }
+  }
+
+  private final FakeRandom fakeRandom = new FakeRandom();
+
+  @Test
+  public void emptyList() {
+    List<WeightedChildPicker> emptyList = new ArrayList<>();
+
+    assertThrows(IllegalArgumentException.class, () -> new WeightedRandomPicker(emptyList));
+  }
+
+  @Test
+  public void negativeWeight() {
+    assertThrows(IllegalArgumentException.class, () -> new WeightedChildPicker(-1, childPicker0));
+  }
+
+  @Test
+  public void overWeightSingle() {
+    assertThrows(IllegalArgumentException.class,
+        () -> new WeightedChildPicker(Integer.MAX_VALUE * 3L, childPicker0));
+  }
+
+  @Test
+  public void overWeightAggregate() {
+
+    List<WeightedChildPicker> weightedChildPickers = Arrays.asList(
+        new WeightedChildPicker(Integer.MAX_VALUE, childPicker0),
+        new WeightedChildPicker(Integer.MAX_VALUE, childPicker1),
+        new WeightedChildPicker(10, childPicker2));
+
+    assertThrows(IllegalArgumentException.class,
+        () -> new WeightedRandomPicker(weightedChildPickers, fakeRandom));
+  }
+
+  @Test
+  public void pickWithFakeRandom() {
+    WeightedChildPicker weightedChildPicker0 = new WeightedChildPicker(0, childPicker0);
+    WeightedChildPicker weightedChildPicker1 = new WeightedChildPicker(15, childPicker1);
+    WeightedChildPicker weightedChildPicker2 = new WeightedChildPicker(0, childPicker2);
+    WeightedChildPicker weightedChildPicker3 = new WeightedChildPicker(10, childPicker3);
+
+    WeightedRandomPicker xdsPicker = new WeightedRandomPicker(
+        Arrays.asList(
+            weightedChildPicker0,
+            weightedChildPicker1,
+            weightedChildPicker2,
+            weightedChildPicker3),
+        fakeRandom);
+
+    fakeRandom.nextInt = 0;
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult1);
+    assertThat(fakeRandom.bound).isEqualTo(25);
+
+    fakeRandom.nextInt = 1;
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult1);
+    assertThat(fakeRandom.bound).isEqualTo(25);
+
+    fakeRandom.nextInt = 14;
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult1);
+    assertThat(fakeRandom.bound).isEqualTo(25);
+
+    fakeRandom.nextInt = 15;
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult3);
+    assertThat(fakeRandom.bound).isEqualTo(25);
+
+    fakeRandom.nextInt = 24;
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult3);
+    assertThat(fakeRandom.bound).isEqualTo(25);
+  }
+
+  @Test
+  public void pickFromLargeTotal() {
+
+    List<WeightedChildPicker> weightedChildPickers = Arrays.asList(
+        new WeightedChildPicker(10, childPicker0),
+        new WeightedChildPicker(Integer.MAX_VALUE, childPicker1),
+        new WeightedChildPicker(10, childPicker2));
+    WeightedRandomPicker xdsPicker = new WeightedRandomPicker(weightedChildPickers,fakeRandom);
+
+    long totalWeight = weightedChildPickers.stream()
+        .mapToLong(WeightedChildPicker::getWeight)
+        .reduce(0, Long::sum);
+
+    fakeRandom.nextLong = 5L;
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult0);
+    assertThat(fakeRandom.bound).isEqualTo(totalWeight);
+
+    fakeRandom.nextLong = 16L;
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult1);
+    assertThat(fakeRandom.bound).isEqualTo(totalWeight);
+
+    fakeRandom.nextLong = Integer.MAX_VALUE + 10L;
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult2);
+    assertThat(fakeRandom.bound).isEqualTo(totalWeight);
+
+    fakeRandom.nextLong = Integer.MAX_VALUE + 15L;
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult2);
+    assertThat(fakeRandom.bound).isEqualTo(totalWeight);
+  }
+
+  @Test
+  public void allZeroWeights() {
+    WeightedChildPicker weightedChildPicker0 = new WeightedChildPicker(0, childPicker0);
+    WeightedChildPicker weightedChildPicker1 = new WeightedChildPicker(0, childPicker1);
+    WeightedChildPicker weightedChildPicker2 = new WeightedChildPicker(0, childPicker2);
+    WeightedChildPicker weightedChildPicker3 = new WeightedChildPicker(0, childPicker3);
+
+    WeightedRandomPicker xdsPicker = new WeightedRandomPicker(
+        Arrays.asList(
+            weightedChildPicker0,
+            weightedChildPicker1,
+            weightedChildPicker2,
+            weightedChildPicker3),
+        fakeRandom);
+
+    fakeRandom.nextInt = 0;
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult0);
+    assertThat(fakeRandom.bound).isEqualTo(4);
+
+    fakeRandom.nextInt = 1;
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult1);
+    assertThat(fakeRandom.bound).isEqualTo(4);
+
+    fakeRandom.nextInt = 2;
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult2);
+    assertThat(fakeRandom.bound).isEqualTo(4);
+
+    fakeRandom.nextInt = 3;
+    assertThat(xdsPicker.pickSubchannel(pickSubchannelArgs)).isSameInstanceAs(pickResult3);
+    assertThat(fakeRandom.bound).isEqualTo(4);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/WeightedRoundRobinLoadBalancerProviderTest.java b/xds/src/test/java/io/grpc/xds/WeightedRoundRobinLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..ddde84ca842
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/WeightedRoundRobinLoadBalancerProviderTest.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright 2023 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import io.grpc.InternalServiceProviders;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.JsonParser;
+import io.grpc.xds.WeightedRoundRobinLoadBalancer.WeightedRoundRobinLoadBalancerConfig;
+import java.io.IOException;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link WeightedRoundRobinLoadBalancerProvider}. */
+@RunWith(JUnit4.class)
+public class WeightedRoundRobinLoadBalancerProviderTest {
+
+  private final WeightedRoundRobinLoadBalancerProvider provider =
+          new WeightedRoundRobinLoadBalancerProvider();
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+
+  @Test
+  public void provided() {
+    for (LoadBalancerProvider current : InternalServiceProviders.getCandidatesViaServiceLoader(
+            LoadBalancerProvider.class, getClass().getClassLoader())) {
+      if (current instanceof WeightedRoundRobinLoadBalancerProvider) {
+        return;
+      }
+    }
+    fail("WeightedRoundRobinLoadBalancerProvider not registered");
+  }
+
+  @Test
+  public void providesLoadBalancer() {
+    LoadBalancer.Helper helper = mock(LoadBalancer.Helper.class);
+    when(helper.getSynchronizationContext()).thenReturn(syncContext);
+    when(helper.getScheduledExecutorService()).thenReturn(
+            new FakeClock().getScheduledExecutorService());
+    assertThat(provider.newLoadBalancer(helper))
+            .isInstanceOf(WeightedRoundRobinLoadBalancer.class);
+  }
+
+  @Test
+  public void parseLoadBalancingConfig() throws IOException {
+    String lbConfig =
+        "{\"blackoutPeriod\" : \"20s\","
+        + " \"weightExpirationPeriod\" : \"300s\","
+        + " \"oobReportingPeriod\" : \"100s\","
+        + " \"enableOobLoadReport\" : true,"
+        + " \"weightUpdatePeriod\" : \"2s\","
+        + " \"errorUtilizationPenalty\" : \"1.75\""
+        + " }";
+
+    ConfigOrError configOrError = provider.parseLoadBalancingPolicyConfig(
+            parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    WeightedRoundRobinLoadBalancerConfig config =
+            (WeightedRoundRobinLoadBalancerConfig) configOrError.getConfig();
+    assertThat(config.blackoutPeriodNanos).isEqualTo(20_000_000_000L);
+    assertThat(config.weightExpirationPeriodNanos).isEqualTo(300_000_000_000L);
+    assertThat(config.oobReportingPeriodNanos).isEqualTo(100_000_000_000L);
+    assertThat(config.enableOobLoadReport).isEqualTo(true);
+    assertThat(config.weightUpdatePeriodNanos).isEqualTo(2_000_000_000L);
+    assertThat(config.errorUtilizationPenalty).isEqualTo(1.75F);
+  }
+
+  @Test
+  public void parseLoadBalancingConfigDefaultValues() throws IOException {
+    String lbConfig = "{\"weightUpdatePeriod\" : \"0.02s\"}";
+
+    ConfigOrError configOrError = provider.parseLoadBalancingPolicyConfig(
+            parseJsonObject(lbConfig));
+    assertThat(configOrError.getConfig()).isNotNull();
+    WeightedRoundRobinLoadBalancerConfig config =
+            (WeightedRoundRobinLoadBalancerConfig) configOrError.getConfig();
+    assertThat(config.blackoutPeriodNanos).isEqualTo(10_000_000_000L);
+    assertThat(config.weightExpirationPeriodNanos).isEqualTo(180_000_000_000L);
+    assertThat(config.enableOobLoadReport).isEqualTo(false);
+    assertThat(config.weightUpdatePeriodNanos).isEqualTo(100_000_000L);
+    assertThat(config.errorUtilizationPenalty).isEqualTo(1.0F);
+  }
+
+
+  @SuppressWarnings("unchecked")
+  private static Map<String, ?> parseJsonObject(String json) throws IOException {
+    return (Map<String, ?>) JsonParser.parse(json);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/WeightedRoundRobinLoadBalancerTest.java b/xds/src/test/java/io/grpc/xds/WeightedRoundRobinLoadBalancerTest.java
new file mode 100644
index 00000000000..9fac46eaf09
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/WeightedRoundRobinLoadBalancerTest.java
@@ -0,0 +1,1443 @@
+/*
+ * Copyright 2023 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.github.xds.data.orca.v3.OrcaLoadReport;
+import com.github.xds.service.orca.v3.OrcaLoadReportRequest;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.testing.EqualsTester;
+import com.google.protobuf.Duration;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientStreamTracer;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.DoubleHistogramMetricInstrument;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.InternalManagedChannelBuilder;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.LongCounterMetricInstrument;
+import io.grpc.Metadata;
+import io.grpc.MetricRecorder;
+import io.grpc.MetricSink;
+import io.grpc.NameResolver;
+import io.grpc.NoopMetricSink;
+import io.grpc.ServerCall;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.PickFirstLoadBalancerProvider;
+import io.grpc.internal.TestUtils;
+import io.grpc.internal.testing.StreamRecorder;
+import io.grpc.protobuf.ProtoUtils;
+import io.grpc.services.InternalCallMetricRecorder;
+import io.grpc.services.MetricReport;
+import io.grpc.stub.ClientCalls;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.TestMethodDescriptors;
+import io.grpc.util.AbstractTestHelper;
+import io.grpc.util.MultiChildLoadBalancer.ChildLbState;
+import io.grpc.xds.WeightedRoundRobinLoadBalancer.StaticStrideScheduler;
+import io.grpc.xds.WeightedRoundRobinLoadBalancer.WeightedChildLbState;
+import io.grpc.xds.WeightedRoundRobinLoadBalancer.WeightedRoundRobinLoadBalancerConfig;
+import io.grpc.xds.WeightedRoundRobinLoadBalancer.WeightedRoundRobinPicker;
+import java.net.SocketAddress;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Random;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+import org.mockito.stubbing.Answer;
+
+@RunWith(JUnit4.class)
+public class WeightedRoundRobinLoadBalancerTest {
+  @Rule
+  public final MockitoRule mockito = MockitoJUnit.rule();
+  @Rule
+  public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
+
+  private final TestHelper testHelperInstance;
+  private final Helper helper;
+
+  @Mock
+  private LoadBalancer.PickSubchannelArgs mockArgs;
+
+  @Captor
+  private ArgumentCaptor<SubchannelPicker> pickerCaptor;
+  @Captor
+  private ArgumentCaptor<SubchannelPicker> pickerCaptor2;
+
+  private final List<EquivalentAddressGroup> servers = Lists.newArrayList();
+  private final Map<List<EquivalentAddressGroup>, Subchannel> subchannels = Maps.newLinkedHashMap();
+
+  private final Queue<ClientCall<OrcaLoadReportRequest, OrcaLoadReport>> oobCalls =
+          new ConcurrentLinkedQueue<>();
+
+  private WeightedRoundRobinLoadBalancer wrr;
+
+  private final FakeClock fakeClock = new FakeClock();
+
+  @Mock
+  private MetricRecorder mockMetricRecorder;
+
+  private WeightedRoundRobinLoadBalancerConfig weightedConfig =
+          WeightedRoundRobinLoadBalancerConfig.newBuilder().build();
+
+  private static final Attributes.Key<String> MAJOR_KEY = Attributes.Key.create("major-key");
+
+  private final Attributes affinity =
+            Attributes.newBuilder().set(MAJOR_KEY, "I got the keys").build();
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+          @Override
+          public void uncaughtException(Thread t, Throwable e) {
+            throw new AssertionError(e);
+          }
+      });
+
+  private String channelTarget = "channel-target";
+  private String locality = "locality";
+  private String backendService = "the-backend-service";
+
+  public WeightedRoundRobinLoadBalancerTest() {
+    testHelperInstance = new TestHelper();
+    helper = mock(Helper.class, delegatesTo(testHelperInstance));
+  }
+
+  @Before
+  public void setup() {
+    for (int i = 0; i < 3; i++) {
+      SocketAddress addr = new FakeSocketAddress("server" + i);
+      EquivalentAddressGroup eag = new EquivalentAddressGroup(addr);
+      servers.add(eag);
+      Subchannel sc = helper.createSubchannel(CreateSubchannelArgs.newBuilder().setAddresses(eag)
+          .build());
+      Channel channel = mock(Channel.class);
+      when(channel.newCall(any(), any())).then(
+          new Answer<ClientCall<OrcaLoadReportRequest, OrcaLoadReport>>() {
+            @SuppressWarnings("unchecked")
+            @Override
+            public ClientCall<OrcaLoadReportRequest, OrcaLoadReport> answer(
+                    InvocationOnMock invocation) throws Throwable {
+              ClientCall<OrcaLoadReportRequest, OrcaLoadReport> clientCall = mock(ClientCall.class);
+              oobCalls.add(clientCall);
+              return clientCall;
+            }
+          });
+      testHelperInstance.setChannel(sc, channel);
+      subchannels.put(Arrays.asList(eag), sc);
+    }
+    wrr = new WeightedRoundRobinLoadBalancer(helper, fakeClock.getDeadlineTicker(),
+        new FakeRandom(0));
+
+    verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
+    reset(helper);
+  }
+
+  @Test
+  public void pickChildLbTF() throws Exception {
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+        .setAddresses(servers.subList(0, 1)).setLoadBalancingPolicyConfig(weightedConfig)
+        .setAttributes(affinity).build()));
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel1 = it.next();
+    getSubchannelStateListener(readySubchannel1).onSubchannelState(ConnectivityStateInfo
+        .forTransientFailure(Status.UNAVAILABLE));
+    verify(helper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE), pickerCaptor.capture());
+    final WeightedRoundRobinPicker weightedPicker =
+        (WeightedRoundRobinPicker) pickerCaptor.getValue();
+    weightedPicker.pickSubchannel(mockArgs);
+  }
+
+  @Test
+  public void config_equalsTester() {
+    WeightedRoundRobinLoadBalancerConfig defaults =
+        WeightedRoundRobinLoadBalancerConfig.newBuilder().build();
+    new EqualsTester()
+        .addEqualityGroup(
+            WeightedRoundRobinLoadBalancerConfig.newBuilder().build(),
+            WeightedRoundRobinLoadBalancerConfig.newBuilder().build(),
+            WeightedRoundRobinLoadBalancerConfig.newBuilder()
+              .setBlackoutPeriodNanos(defaults.blackoutPeriodNanos).build())
+        .addEqualityGroup(
+            WeightedRoundRobinLoadBalancerConfig.newBuilder()
+              .setBlackoutPeriodNanos(5).build())
+        .addEqualityGroup(
+            WeightedRoundRobinLoadBalancerConfig.newBuilder()
+              .setWeightExpirationPeriodNanos(5).build())
+        .addEqualityGroup(
+            WeightedRoundRobinLoadBalancerConfig.newBuilder()
+              .setEnableOobLoadReport(true).build())
+        .addEqualityGroup(
+            WeightedRoundRobinLoadBalancerConfig.newBuilder()
+              .setOobReportingPeriodNanos(5).build())
+        .addEqualityGroup(
+            WeightedRoundRobinLoadBalancerConfig.newBuilder()
+              .setWeightUpdatePeriodNanos(5).build())
+        .addEqualityGroup(
+            WeightedRoundRobinLoadBalancerConfig.newBuilder()
+              .setErrorUtilizationPenalty(0.5F).build())
+        .addEqualityGroup(
+            WeightedRoundRobinLoadBalancerConfig.newBuilder()
+              .setErrorUtilizationPenalty(Float.NaN).build())
+        .testEquals();
+  }
+
+  @Test
+  public void wrrLifeCycle() {
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+                .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+            .setAttributes(affinity).build()));
+    verify(helper, times(3)).createSubchannel(
+                any(CreateSubchannelArgs.class));
+    assertThat(getNumFilteredPendingTasks()).isEqualTo(1);
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel1 = it.next();
+    getSubchannelStateListener(readySubchannel1).onSubchannelState(ConnectivityStateInfo
+            .forNonError(ConnectivityState.READY));
+    Subchannel readySubchannel2  = it.next();
+    getSubchannelStateListener(readySubchannel2).onSubchannelState(ConnectivityStateInfo
+            .forNonError(ConnectivityState.READY));
+    Subchannel connectingSubchannel = it.next();
+    getSubchannelStateListener(connectingSubchannel).onSubchannelState(ConnectivityStateInfo
+            .forNonError(CONNECTING));
+    verify(helper, times(2)).updateBalancingState(
+            eq(ConnectivityState.READY), pickerCaptor.capture());
+    assertThat(pickerCaptor.getAllValues().size()).isEqualTo(2);
+    WeightedRoundRobinPicker weightedPicker =
+        (WeightedRoundRobinPicker) pickerCaptor.getAllValues().get(0);
+    assertThat(weightedPicker.getChildren().size()).isEqualTo(1);
+    weightedPicker = (WeightedRoundRobinPicker) pickerCaptor.getAllValues().get(1);
+    assertThat(weightedPicker.getChildren().size()).isEqualTo(2);
+    String weightedPickerStr = weightedPicker.toString();
+    assertThat(weightedPickerStr).contains("enableOobLoadReport=false");
+    assertThat(weightedPickerStr).contains("errorUtilizationPenalty=1.0");
+    assertThat(weightedPickerStr).contains("pickers=");
+
+    WeightedChildLbState weightedChild1 = (WeightedChildLbState) getChild(weightedPicker, 0);
+    WeightedChildLbState weightedChild2 = (WeightedChildLbState) getChild(weightedPicker, 1);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.2, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    int expectedTasks = isEnabledHappyEyeballs() ? 2 : 1;
+    assertThat(fakeClock.forwardTime(11, TimeUnit.SECONDS)).isEqualTo(expectedTasks);
+
+    assertThat(getAddressesFromPick(weightedPicker)).isEqualTo(servers.get(0));
+    assertThat(fakeClock.getPendingTasks().size()).isEqualTo(1);
+    weightedConfig = WeightedRoundRobinLoadBalancerConfig.newBuilder()
+        .setWeightUpdatePeriodNanos(500_000_000L) //.5s
+        .build();
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+        .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+        .setAttributes(affinity).build()));
+    assertThat(getNumFilteredPendingTasks()).isEqualTo(1);
+
+    syncContext.execute(() -> wrr.shutdown());
+    for (Subchannel subchannel: subchannels.values()) {
+      verify(subchannel).shutdown();
+    }
+    assertThat(getNumFilteredPendingTasks()).isEqualTo(0);
+    verifyNoMoreInteractions(mockArgs);
+  }
+
+  /**
+   * Picks subchannel using mockArgs, gets its EAG, and then strips the Attrs to make a key.
+   */
+  private EquivalentAddressGroup getAddressesFromPick(WeightedRoundRobinPicker weightedPicker) {
+    return TestUtils.stripAttrs(
+        weightedPicker.pickSubchannel(mockArgs).getSubchannel().getAddresses());
+  }
+
+  @Test
+  public void enableOobLoadReportConfig() {
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+            .setAttributes(affinity).build()));
+    verify(helper, times(3)).createSubchannel(
+            any(CreateSubchannelArgs.class));
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel1 = it.next();
+    getSubchannelStateListener(readySubchannel1).onSubchannelState(ConnectivityStateInfo
+            .forNonError(ConnectivityState.READY));
+    Subchannel readySubchannel2  = it.next();
+    getSubchannelStateListener(readySubchannel2).onSubchannelState(ConnectivityStateInfo
+            .forNonError(ConnectivityState.READY));
+    verify(helper, times(2)).updateBalancingState(
+            eq(ConnectivityState.READY), pickerCaptor.capture());
+    WeightedRoundRobinPicker weightedPicker =
+        (WeightedRoundRobinPicker) pickerCaptor.getAllValues().get(1);
+    WeightedChildLbState weightedChild1 = (WeightedChildLbState) getChild(weightedPicker, 0);
+    WeightedChildLbState weightedChild2 = (WeightedChildLbState) getChild(weightedPicker, 1);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.9, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    int expectedTasks = isEnabledHappyEyeballs() ? 2 : 1;
+    assertThat(fakeClock.forwardTime(11, TimeUnit.SECONDS)).isEqualTo(expectedTasks);
+    PickResult pickResult = weightedPicker.pickSubchannel(mockArgs);
+    assertThat(getAddresses(pickResult)).isEqualTo(servers.get(0));
+    assertThat(pickResult.getStreamTracerFactory()).isNotNull(); // verify per-request listener
+    assertThat(oobCalls.isEmpty()).isTrue();
+
+    weightedConfig = WeightedRoundRobinLoadBalancerConfig.newBuilder().setEnableOobLoadReport(true)
+            .setOobReportingPeriodNanos(20_030_000_000L)
+            .build();
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+            .setAttributes(affinity).build()));
+    verify(helper, times(3)).updateBalancingState(
+            eq(ConnectivityState.READY), pickerCaptor2.capture());
+    weightedPicker = (WeightedRoundRobinPicker) pickerCaptor2.getAllValues().get(2);
+    pickResult = weightedPicker.pickSubchannel(mockArgs);
+    assertThat(getAddresses(pickResult)).isEqualTo(servers.get(0));
+    assertThat(pickResult.getStreamTracerFactory()).isNull();
+    OrcaLoadReportRequest golden = OrcaLoadReportRequest.newBuilder().setReportInterval(
+            Duration.newBuilder().setSeconds(20).setNanos(30000000).build()).build();
+    assertThat(oobCalls.size()).isEqualTo(2);
+    verify(oobCalls.poll()).sendMessage(eq(golden));
+    verify(oobCalls.poll()).sendMessage(eq(golden));
+  }
+
+  private void pickByWeight(MetricReport r1, MetricReport r2, MetricReport r3,
+                            double subchannel1PickRatio, double subchannel2PickRatio,
+                            double subchannel3PickRatio) {
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+            .setAttributes(affinity).build()));
+    verify(helper, times(3)).createSubchannel(
+            any(CreateSubchannelArgs.class));
+    assertThat(getNumFilteredPendingTasks()).isEqualTo(1);
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel1 = it.next();
+    getSubchannelStateListener(readySubchannel1).onSubchannelState(ConnectivityStateInfo
+            .forNonError(ConnectivityState.READY));
+    Subchannel readySubchannel2  = it.next();
+    getSubchannelStateListener(readySubchannel2).onSubchannelState(ConnectivityStateInfo
+            .forNonError(ConnectivityState.READY));
+    Subchannel readySubchannel3 = it.next();
+    getSubchannelStateListener(readySubchannel3).onSubchannelState(ConnectivityStateInfo
+            .forNonError(ConnectivityState.READY));
+    verify(helper, times(3)).updateBalancingState(
+            eq(ConnectivityState.READY), pickerCaptor.capture());
+    WeightedRoundRobinPicker weightedPicker =
+        (WeightedRoundRobinPicker) pickerCaptor.getAllValues().get(2);
+    WeightedChildLbState weightedChild1 = (WeightedChildLbState) getChild(weightedPicker, 0);
+    WeightedChildLbState weightedChild2 = (WeightedChildLbState) getChild(weightedPicker, 1);
+    WeightedChildLbState weightedChild3 = (WeightedChildLbState) getChild(weightedPicker, 2);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(r1);
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(r2);
+    weightedChild3.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(r3);
+
+    assertThat(fakeClock.forwardTime(11, TimeUnit.SECONDS)).isEqualTo(1);
+    Map<EquivalentAddressGroup, Integer> pickCount = new HashMap<>();
+    for (int i = 0; i < 10000; i++) {
+      EquivalentAddressGroup result = getAddressesFromPick(weightedPicker);
+      pickCount.put(result, pickCount.getOrDefault(result, 0) + 1);
+    }
+    assertThat(pickCount.size()).isEqualTo(3);
+    assertThat(Math.abs(pickCount.get(servers.get(0)) / 10000.0 - subchannel1PickRatio))
+        .isAtMost(0.0002);
+    assertThat(Math.abs(pickCount.get(servers.get(1)) / 10000.0 - subchannel2PickRatio ))
+        .isAtMost(0.0002);
+    assertThat(Math.abs(pickCount.get(servers.get(2)) / 10000.0 - subchannel3PickRatio ))
+        .isAtMost(0.0002);
+  }
+
+  private SubchannelStateListener getSubchannelStateListener(Subchannel mockSubChannel) {
+    return testHelperInstance.getSubchannelStateListener(mockSubChannel);
+  }
+
+  private static ChildLbState getChild(WeightedRoundRobinPicker picker, int index) {
+    return picker.getChildren().get(index);
+  }
+
+  @Test
+  public void pickByWeight_largeWeight() {
+    MetricReport report1 = InternalCallMetricRecorder.createMetricReport(
+        0.1, 0, 0.1, 999, 0, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report2 = InternalCallMetricRecorder.createMetricReport(
+        0.9, 0, 0.1, 2, 0, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report3 = InternalCallMetricRecorder.createMetricReport(
+        0.86, 0, 0.1, 100, 0, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    double meanWeight = (999 / 0.1 + 2 / 0.9 + 100 / 0.86) / 3;
+    double cappedMin = meanWeight * 0.1; // min capped at minRatio * meanWeight
+    double totalWeight = 999 / 0.1 + cappedMin + cappedMin;
+    pickByWeight(report1, report2, report3, 999 / 0.1 / totalWeight, cappedMin / totalWeight,
+            cappedMin / totalWeight);
+  }
+
+  @Test
+  public void pickByWeight_largeWeight_useApplicationUtilization() {
+    MetricReport report1 = InternalCallMetricRecorder.createMetricReport(
+        0.44, 0.1, 0.1, 999, 0, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report2 = InternalCallMetricRecorder.createMetricReport(
+        0.12, 0.9, 0.1, 2, 0, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report3 = InternalCallMetricRecorder.createMetricReport(
+        0.33, 0.86, 0.1, 100, 0, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    double meanWeight = (999 / 0.1 + 2 / 0.9 + 100 / 0.86) / 3;
+    double cappedMin = meanWeight * 0.1;
+    double totalWeight = 999 / 0.1 + cappedMin + cappedMin; // min capped at minRatio * meanWeight
+    pickByWeight(report1, report2, report3, 999 / 0.1 / totalWeight, cappedMin / totalWeight,
+        cappedMin / totalWeight);
+  }
+
+  @Test
+  public void pickByWeight_largeWeight_withEps_defaultErrorUtilizationPenalty() {
+    MetricReport report1 = InternalCallMetricRecorder.createMetricReport(
+        0.1, 0, 0.1, 999, 13, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report2 = InternalCallMetricRecorder.createMetricReport(
+        0.9, 0, 0.1, 2, 1.8, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report3 = InternalCallMetricRecorder.createMetricReport(
+        0.86, 0, 0.1, 100, 3, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    double weight1 = 999 / (0.1 + 13 / 999F * weightedConfig.errorUtilizationPenalty); // ~5609.899
+    double weight2 = 2 / (0.9 + 1.8 / 2F * weightedConfig.errorUtilizationPenalty); // ~0.317
+    double weight3 = 100 / (0.86 + 3 / 100F * weightedConfig.errorUtilizationPenalty); // ~96.154
+    double meanWeight = (weight1 + weight2 + weight3) / 3;
+    double cappedMin = meanWeight * 0.1; // min capped at minRatio * meanWeight
+    double totalWeight = weight1 + cappedMin + cappedMin;
+    pickByWeight(report1, report2, report3, weight1 / totalWeight, cappedMin / totalWeight,
+        cappedMin / totalWeight);
+  }
+
+  @Test
+  public void pickByWeight_normalWeight() {
+    MetricReport report1 = InternalCallMetricRecorder.createMetricReport(
+        0.12, 0, 0.1, 22, 0, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report2 = InternalCallMetricRecorder.createMetricReport(
+        0.28, 0, 0.1, 40, 0, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report3 = InternalCallMetricRecorder.createMetricReport(
+        0.86, 0, 0.1, 100, 0, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    double totalWeight = 22 / 0.12 + 40 / 0.28 + 100 / 0.86;
+    pickByWeight(report1, report2, report3, 22 / 0.12 / totalWeight,
+            40 / 0.28 / totalWeight, 100 / 0.86 / totalWeight
+    );
+  }
+
+  @Test
+  public void pickByWeight_normalWeight_useApplicationUtilization() {
+    MetricReport report1 = InternalCallMetricRecorder.createMetricReport(
+        0.72, 0.12, 0.1, 22, 0, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report2 = InternalCallMetricRecorder.createMetricReport(
+        0.98, 0.28, 0.1, 40, 0, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report3 = InternalCallMetricRecorder.createMetricReport(
+        0.99, 0.86, 0.1, 100, 0, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    double totalWeight = 22 / 0.12 + 40 / 0.28 + 100 / 0.86;
+    pickByWeight(report1, report2, report3, 22 / 0.12 / totalWeight,
+        40 / 0.28 / totalWeight, 100 / 0.86 / totalWeight
+    );
+  }
+
+  @Test
+  public void pickByWeight_normalWeight_withEps_defaultErrorUtilizationPenalty() {
+    MetricReport report1 = InternalCallMetricRecorder.createMetricReport(
+        0.12, 0, 0.1, 22, 19.7, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report2 = InternalCallMetricRecorder.createMetricReport(
+        0.28, 0, 0.1, 40, 0.998, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report3 = InternalCallMetricRecorder.createMetricReport(
+        0.86, 0, 0.1, 100, 3.14159, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    double weight1 = 22 / (0.12 + 19.7 / 22F * weightedConfig.errorUtilizationPenalty);
+    double weight2 = 40 / (0.28 + 0.998 / 40F * weightedConfig.errorUtilizationPenalty);
+    double weight3 = 100 / (0.86 + 3.14159 / 100F * weightedConfig.errorUtilizationPenalty);
+    double totalWeight = weight1 + weight2 + weight3;
+
+    pickByWeight(report1, report2, report3, weight1 / totalWeight, weight2 / totalWeight,
+        weight3 / totalWeight);
+  }
+
+  @Test
+  public void pickByWeight_normalWeight_withEps_customErrorUtilizationPenalty() {
+    weightedConfig = WeightedRoundRobinLoadBalancerConfig.newBuilder()
+        .setErrorUtilizationPenalty(1.75F).build();
+
+    MetricReport report1 = InternalCallMetricRecorder.createMetricReport(
+        0.12, 0, 0.1, 22, 19.7, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report2 = InternalCallMetricRecorder.createMetricReport(
+        0.28, 0, 0.1, 40, 0.998, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report3 = InternalCallMetricRecorder.createMetricReport(
+        0.86, 0, 0.1, 100, 3.14159, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    double weight1 = 22 / (0.12 + 19.7 / 22F * weightedConfig.errorUtilizationPenalty);
+    double weight2 = 40 / (0.28 + 0.998 / 40F * weightedConfig.errorUtilizationPenalty);
+    double weight3 = 100 / (0.86 + 3.14159 / 100F * weightedConfig.errorUtilizationPenalty);
+    double totalWeight = weight1 + weight2 + weight3;
+
+    pickByWeight(report1, report2, report3, weight1 / totalWeight, weight2 / totalWeight,
+        weight3 / totalWeight);
+  }
+
+  @Test
+  public void pickByWeight_avgWeight_zeroCpuUtilization_withEps_customErrorUtilizationPenalty() {
+    weightedConfig = WeightedRoundRobinLoadBalancerConfig.newBuilder()
+        .setErrorUtilizationPenalty(1.75F).build();
+
+    MetricReport report1 = InternalCallMetricRecorder.createMetricReport(
+        0, 0, 0.1, 22, 19.7, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report2 = InternalCallMetricRecorder.createMetricReport(
+        0, 0, 0.1, 40, 0.998, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    MetricReport report3 = InternalCallMetricRecorder.createMetricReport(
+        0, 0, 0.1, 100, 3.14159, new HashMap<>(), new HashMap<>(), new HashMap<>());
+    double avgSubchannelPickRatio = 1.0 / 3;
+
+    pickByWeight(report1, report2, report3, avgSubchannelPickRatio, avgSubchannelPickRatio,
+        avgSubchannelPickRatio);
+  }
+
+  @Test
+  public void emptyConfig() {
+    assertThat(wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(null)
+            .setAttributes(affinity).build()).isOk()).isFalse();
+    verify(helper, never()).createSubchannel(any(CreateSubchannelArgs.class));
+    verify(helper).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE), any());
+    assertThat(fakeClock.getPendingTasks()).isEmpty();
+
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+            .setAttributes(affinity).build()));
+    verify(helper, times(3)).createSubchannel(
+            any(CreateSubchannelArgs.class));
+    verify(helper).updateBalancingState(eq(CONNECTING), pickerCaptor.capture());
+    assertThat(pickerCaptor.getValue().pickSubchannel(mockArgs))
+        .isEqualTo(PickResult.withNoResult());
+    int expectedCount = isEnabledHappyEyeballs() ? servers.size() + 1 : 1;
+    assertThat(fakeClock.forwardTime(11, TimeUnit.SECONDS)).isEqualTo( expectedCount);
+  }
+
+  @Test
+  public void blackoutPeriod() {
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+            .setAttributes(affinity).build()));
+    verify(helper, times(3)).createSubchannel(any(CreateSubchannelArgs.class));
+    assertThat(getNumFilteredPendingTasks()).isEqualTo(1);
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel1 = it.next();
+    getSubchannelStateListener(readySubchannel1).onSubchannelState(ConnectivityStateInfo
+            .forNonError(ConnectivityState.READY));
+    Subchannel readySubchannel2  = it.next();
+    getSubchannelStateListener(readySubchannel2).onSubchannelState(ConnectivityStateInfo
+            .forNonError(ConnectivityState.READY));
+    verify(helper, times(2)).updateBalancingState(
+            eq(ConnectivityState.READY), pickerCaptor.capture());
+    WeightedRoundRobinPicker weightedPicker =
+        (WeightedRoundRobinPicker) pickerCaptor.getAllValues().get(1);
+    WeightedChildLbState weightedChild1 = (WeightedChildLbState) getChild(weightedPicker, 0);
+    WeightedChildLbState weightedChild2 = (WeightedChildLbState) getChild(weightedPicker, 1);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.2, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    int expectedCount = isEnabledHappyEyeballs() ? 2 : 1;
+    assertThat(fakeClock.forwardTime(5, TimeUnit.SECONDS)).isEqualTo(expectedCount);
+    Map<EquivalentAddressGroup, Integer> pickCount = new HashMap<>();
+    for (int i = 0; i < 10000; i++) {
+      EquivalentAddressGroup result = getAddressesFromPick(weightedPicker);
+      pickCount.put(result, pickCount.getOrDefault(result, 0) + 1);
+    }
+    assertThat(pickCount.size()).isEqualTo(2);
+    // within blackout period, fallback to simple round robin
+    assertThat(Math.abs(pickCount.get(servers.get(0)) / 10000.0 - 0.5)).isLessThan(0.002);
+    assertThat(Math.abs(pickCount.get(servers.get(1)) / 10000.0 - 0.5)).isLessThan(0.002);
+
+    assertThat(fakeClock.forwardTime(5, TimeUnit.SECONDS)).isEqualTo(1);
+    pickCount = new HashMap<>();
+    for (int i = 0; i < 10000; i++) {
+      EquivalentAddressGroup result = getAddressesFromPick(weightedPicker);
+      pickCount.put(result, pickCount.getOrDefault(result, 0) + 1);
+    }
+    assertThat(pickCount.size()).isEqualTo(2);
+    // after blackout period
+    assertThat(Math.abs(pickCount.get(servers.get(0)) / 10000.0 - 2.0 / 3)).isLessThan(0.002);
+    assertThat(Math.abs(pickCount.get(servers.get(1)) / 10000.0 - 1.0 / 3)).isLessThan(0.002);
+  }
+
+  private boolean isEnabledHappyEyeballs() {
+    return PickFirstLoadBalancerProvider.isEnabledHappyEyeballs();
+  }
+
+  @Test
+  public void updateWeightTimer() {
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+        .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+        .setAttributes(affinity).build()));
+    verify(helper, times(3)).createSubchannel(
+        any(CreateSubchannelArgs.class));
+    assertThat(getNumFilteredPendingTasks()).isEqualTo(1);
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel1 = it.next();
+    getSubchannelStateListener(readySubchannel1).onSubchannelState(ConnectivityStateInfo
+        .forNonError(ConnectivityState.READY));
+    Subchannel readySubchannel2  = it.next();
+    getSubchannelStateListener(readySubchannel2).onSubchannelState(ConnectivityStateInfo
+        .forNonError(ConnectivityState.READY));
+    Subchannel connectingSubchannel = it.next();
+    getSubchannelStateListener(connectingSubchannel).onSubchannelState(ConnectivityStateInfo
+        .forNonError(CONNECTING));
+    verify(helper, times(2)).updateBalancingState(
+        eq(ConnectivityState.READY), pickerCaptor.capture());
+    assertThat(pickerCaptor.getAllValues().size()).isEqualTo(2);
+    WeightedRoundRobinPicker weightedPicker =
+        (WeightedRoundRobinPicker) pickerCaptor.getAllValues().get(0);
+    assertThat(weightedPicker.getChildren().size()).isEqualTo(1);
+    weightedPicker = (WeightedRoundRobinPicker) pickerCaptor.getAllValues().get(1);
+    assertThat(weightedPicker.getChildren().size()).isEqualTo(2);
+    WeightedChildLbState weightedChild1 = (WeightedChildLbState) getChild(weightedPicker, 0);
+    WeightedChildLbState weightedChild2 = (WeightedChildLbState) getChild(weightedPicker, 1);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.2, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    int expectedTasks = isEnabledHappyEyeballs() ? 2 : 1;
+    assertThat(fakeClock.forwardTime(11, TimeUnit.SECONDS)).isEqualTo(expectedTasks);
+    assertThat(getAddressesFromPick(weightedPicker)).isEqualTo(servers.get(0));
+    assertThat(getNumFilteredPendingTasks()).isEqualTo(1);
+    weightedConfig = WeightedRoundRobinLoadBalancerConfig.newBuilder()
+        .setWeightUpdatePeriodNanos(500_000_000L) //.5s
+        .build();
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+        .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+        .setAttributes(affinity).build()));
+    assertThat(getNumFilteredPendingTasks()).isEqualTo(1);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.2, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    //timer fires, new weight updated
+    expectedTasks = isEnabledHappyEyeballs() ? 2 : 1;
+    assertThat(fakeClock.forwardTime(500, TimeUnit.MILLISECONDS)).isEqualTo(expectedTasks);
+    assertThat(getAddressesFromPick(weightedPicker)).isEqualTo(servers.get(1));
+    assertThat(getAddressesFromPick(weightedPicker)).isEqualTo(servers.get(0));
+  }
+
+  @Test
+  public void weightExpired() {
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+            .setAttributes(affinity).build()));
+    verify(helper, times(3)).createSubchannel(
+            any(CreateSubchannelArgs.class));
+    assertThat(getNumFilteredPendingTasks()).isEqualTo(1);
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel1 = it.next();
+    getSubchannelStateListener(readySubchannel1).onSubchannelState(ConnectivityStateInfo
+            .forNonError(ConnectivityState.READY));
+    Subchannel readySubchannel2  = it.next();
+    getSubchannelStateListener(readySubchannel2).onSubchannelState(ConnectivityStateInfo
+            .forNonError(ConnectivityState.READY));
+    verify(helper, times(2)).updateBalancingState(
+            eq(ConnectivityState.READY), pickerCaptor.capture());
+    WeightedRoundRobinPicker weightedPicker =
+        (WeightedRoundRobinPicker) pickerCaptor.getAllValues().get(1);
+    WeightedChildLbState weightedChild1 = (WeightedChildLbState) getChild(weightedPicker, 0);
+    WeightedChildLbState weightedChild2 = (WeightedChildLbState) getChild(weightedPicker, 1);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.2, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    int expectedTasks = isEnabledHappyEyeballs() ? 2 : 1;
+    assertThat(fakeClock.forwardTime(10, TimeUnit.SECONDS)).isEqualTo(expectedTasks);
+    Map<EquivalentAddressGroup, Integer> pickCount = new HashMap<>();
+    for (int i = 0; i < 1000; i++) {
+      EquivalentAddressGroup result = getAddressesFromPick(weightedPicker);
+      pickCount.put(result, pickCount.getOrDefault(result, 0) + 1);
+    }
+    assertThat(pickCount.size()).isEqualTo(2);
+    assertThat(Math.abs(pickCount.get(servers.get(0)) / 1000.0 - 2.0 / 3)).isLessThan(0.002);
+    assertThat(Math.abs(pickCount.get(servers.get(1)) / 1000.0 - 1.0 / 3)).isLessThan(0.002);
+
+    // weight expired, fallback to simple round robin
+    assertThat(fakeClock.forwardTime(300, TimeUnit.SECONDS)).isEqualTo(1);
+    pickCount = new HashMap<>();
+    for (int i = 0; i < 1000; i++) {
+      EquivalentAddressGroup result = getAddressesFromPick(weightedPicker);
+      pickCount.put(result, pickCount.getOrDefault(result, 0) + 1);
+    }
+    assertThat(pickCount.size()).isEqualTo(2);
+    assertThat(Math.abs(pickCount.get(servers.get(0)) / 1000.0 - 0.5)).isLessThan(0.002);
+    assertThat(Math.abs(pickCount.get(servers.get(1)) / 1000.0 - 0.5)).isLessThan(0.002);
+  }
+
+  @Test
+  public void rrFallback() {
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+        .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+        .setAttributes(affinity).build()));
+    verify(helper, times(3)).createSubchannel(
+        any(CreateSubchannelArgs.class));
+    assertThat(getNumFilteredPendingTasks()).isEqualTo(1);
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel1 = it.next();
+    getSubchannelStateListener(readySubchannel1).onSubchannelState(ConnectivityStateInfo
+        .forNonError(ConnectivityState.READY));
+    Subchannel readySubchannel2  = it.next();
+    getSubchannelStateListener(readySubchannel2).onSubchannelState(ConnectivityStateInfo
+        .forNonError(ConnectivityState.READY));
+    verify(helper, times(2)).updateBalancingState(
+        eq(ConnectivityState.READY), pickerCaptor.capture());
+    WeightedRoundRobinPicker weightedPicker =
+        (WeightedRoundRobinPicker) pickerCaptor.getAllValues().get(1);
+    int expectedTasks = isEnabledHappyEyeballs() ? 2 : 1;
+    assertThat(fakeClock.forwardTime(10, TimeUnit.SECONDS)).isEqualTo(expectedTasks);
+    Map<EquivalentAddressGroup, Integer> qpsByChannel = ImmutableMap.of(servers.get(0), 2,
+        servers.get(1), 1);
+    Map<EquivalentAddressGroup, Integer> pickCount = new HashMap<>();
+    for (int i = 0; i < 1000; i++) {
+      PickResult pickResult = weightedPicker.pickSubchannel(mockArgs);
+      EquivalentAddressGroup addresses = getAddresses(pickResult);
+      pickCount.merge(addresses, 1, Integer::sum);
+      reportLoadOnRpc(pickResult, 0.1, 0, 0.1, qpsByChannel.get(addresses), 0);
+    }
+    assertThat(Math.abs(pickCount.get(servers.get(0)) / 1000.0 - 1.0 / 2)).isAtMost(0.1);
+    assertThat(Math.abs(pickCount.get(servers.get(1)) / 1000.0 - 1.0 / 2)).isAtMost(0.1);
+
+    // Identical to above except forwards time after each pick
+    pickCount.clear();
+    for (int i = 0; i < 1000; i++) {
+      PickResult pickResult = weightedPicker.pickSubchannel(mockArgs);
+      EquivalentAddressGroup addresses = getAddresses(pickResult);
+      pickCount.merge(addresses, 1, Integer::sum);
+      reportLoadOnRpc(pickResult, 0.1, 0, 0.1, qpsByChannel.get(addresses), 0);
+      fakeClock.forwardTime(50, TimeUnit.MILLISECONDS);
+    }
+    assertThat(pickCount.size()).isEqualTo(2);
+    assertThat(Math.abs(pickCount.get(servers.get(0)) / 1000.0 - 2.0 / 3)).isAtMost(0.1);
+    assertThat(Math.abs(pickCount.get(servers.get(1)) / 1000.0 - 1.0 / 3)).isAtMost(0.1);
+  }
+
+  private static EquivalentAddressGroup getAddresses(PickResult pickResult) {
+    return TestUtils.stripAttrs(pickResult.getSubchannel().getAddresses());
+  }
+
+  @Test
+  public void unknownWeightIsAvgWeight() {
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+            .setAttributes(affinity).build()));
+    verify(helper, times(3)).createSubchannel(
+            any(CreateSubchannelArgs.class)); // 3 from setup plus 3 from the execute
+    assertThat(getNumFilteredPendingTasks()).isEqualTo(1);
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel1 = it.next();
+    getSubchannelStateListener(readySubchannel1)
+        .onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    Subchannel readySubchannel2  = it.next();
+    getSubchannelStateListener(readySubchannel2)
+        .onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    Subchannel readySubchannel3  = it.next();
+    getSubchannelStateListener(readySubchannel3)
+        .onSubchannelState(ConnectivityStateInfo.forNonError(ConnectivityState.READY));
+    verify(helper, times(3)).updateBalancingState(
+            eq(ConnectivityState.READY), pickerCaptor.capture());
+    WeightedRoundRobinPicker weightedPicker =
+        (WeightedRoundRobinPicker) pickerCaptor.getAllValues().get(2);
+    WeightedChildLbState weightedChild1 = (WeightedChildLbState) getChild(weightedPicker, 0);
+    WeightedChildLbState weightedChild2 = (WeightedChildLbState) getChild(weightedPicker, 1);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.2, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    assertThat(fakeClock.forwardTime(10, TimeUnit.SECONDS)).isEqualTo(1);
+    Map<EquivalentAddressGroup, Integer> pickCount = new HashMap<>();
+    for (int i = 0; i < 1000; i++) {
+      Subchannel result = weightedPicker.pickSubchannel(mockArgs).getSubchannel();
+      pickCount.merge(result.getAddresses(), 1, Integer::sum);
+    }
+    assertThat(pickCount.size()).isEqualTo(3);
+    assertThat(Math.abs(pickCount.get(servers.get(0)) / 1000.0 - 4.0 / 9)).isLessThan(0.002);
+    assertThat(Math.abs(pickCount.get(servers.get(1)) / 1000.0 - 2.0 / 9)).isLessThan(0.002);
+    // subchannel3's weight is average of subchannel1 and subchannel2
+    assertThat(Math.abs(pickCount.get(servers.get(2)) / 1000.0 - 3.0 / 9)).isLessThan(0.002);
+  }
+
+  @Test
+  public void pickFromOtherThread() throws Exception {
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+            .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+            .setAttributes(affinity).build()));
+    verify(helper, times(3)).createSubchannel(
+            any(CreateSubchannelArgs.class));
+    assertThat(getNumFilteredPendingTasks()).isEqualTo(1);
+
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel1 = it.next();
+    getSubchannelStateListener(readySubchannel1).onSubchannelState(ConnectivityStateInfo
+            .forNonError(ConnectivityState.READY));
+    Subchannel readySubchannel2  = it.next();
+    getSubchannelStateListener(readySubchannel2).onSubchannelState(ConnectivityStateInfo
+            .forNonError(ConnectivityState.READY));
+    verify(helper, times(2)).updateBalancingState(
+            eq(ConnectivityState.READY), pickerCaptor.capture());
+    WeightedRoundRobinPicker weightedPicker =
+        (WeightedRoundRobinPicker) pickerCaptor.getAllValues().get(1);
+    WeightedChildLbState weightedChild1 = (WeightedChildLbState) getChild(weightedPicker, 0);
+    WeightedChildLbState weightedChild2 = (WeightedChildLbState) getChild(weightedPicker, 1);
+    weightedChild1.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.1, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    weightedChild2.new OrcaReportListener(weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(
+            0.2, 0, 0.1, 1, 0, new HashMap<>(), new HashMap<>(), new HashMap<>()));
+    CyclicBarrier barrier = new CyclicBarrier(2);
+    Map<EquivalentAddressGroup, AtomicInteger> pickCount = new ConcurrentHashMap<>();
+    pickCount.put(servers.get(0), new AtomicInteger(0));
+    pickCount.put(servers.get(1), new AtomicInteger(0));
+    new Thread(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          weightedPicker.pickSubchannel(mockArgs);
+          barrier.await();
+          for (int i = 0; i < 1000; i++) {
+            Subchannel result = weightedPicker.pickSubchannel(mockArgs).getSubchannel();
+            pickCount.get(result.getAddresses()).addAndGet(1);
+          }
+          barrier.await();
+        } catch (Exception ex) {
+          throw new AssertionError(ex);
+        }
+      }
+    }).start();
+    int expectedTasks = isEnabledHappyEyeballs() ? 2 : 1;
+    assertThat(fakeClock.forwardTime(10, TimeUnit.SECONDS)).isEqualTo(expectedTasks);
+    barrier.await();
+    for (int i = 0; i < 1000; i++) {
+      EquivalentAddressGroup result = getAddresses(weightedPicker.pickSubchannel(mockArgs));
+      pickCount.get(result).addAndGet(1);
+    }
+    barrier.await();
+    assertThat(pickCount.size()).isEqualTo(2);
+    // after blackout period
+    assertThat(Math.abs(pickCount.get(servers.get(0)).get() / 2000.0 - 2.0 / 3)).isLessThan(0.002);
+    assertThat(Math.abs(pickCount.get(servers.get(1)).get() / 2000.0 - 1.0 / 3)).isLessThan(0.002);
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void wrrConfig_TimeValueNonNull() {
+    WeightedRoundRobinLoadBalancerConfig.newBuilder().setBlackoutPeriodNanos((Long) null);
+  }
+
+  @Test(expected = NullPointerException.class)
+  public void wrrConfig_BooleanValueNonNull() {
+    WeightedRoundRobinLoadBalancerConfig.newBuilder().setEnableOobLoadReport((Boolean) null);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void emptyWeights() {
+    float[] weights = {};
+    Random random = new Random(0);
+    VerifyingScheduler sss = new VerifyingScheduler(weights, new AtomicInteger(random.nextInt()));
+    sss.pick();
+  }
+
+  @Test
+  public void testPicksEqualsWeights() {
+    float[] weights = {1.0f, 2.0f, 3.0f};
+    Random random = new Random(0);
+    VerifyingScheduler sss = new VerifyingScheduler(weights, new AtomicInteger(random.nextInt()));
+    int[] expectedPicks = new int[] {1, 2, 3};
+    int[] picks = new int[3];
+    for (int i = 0; i < 6; i++) {
+      picks[sss.pick()] += 1;
+    }
+    assertThat(picks).isEqualTo(expectedPicks);
+  }
+
+  @Test
+  public void testContainsZeroWeightUseMean() {
+    float[] weights = {3.0f, 0.0f, 1.0f};
+    Random random = new Random(0);
+    VerifyingScheduler sss = new VerifyingScheduler(weights, new AtomicInteger(random.nextInt()));
+    int[] expectedPicks = new int[] {3, 2, 1};
+    int[] picks = new int[3];
+    for (int i = 0; i < 6; i++) {
+      picks[sss.pick()] += 1;
+    }
+    assertThat(picks).isEqualTo(expectedPicks);
+  }
+
+  @Test
+  public void testContainsNegativeWeightUseMean() {
+    float[] weights = {3.0f, -1.0f, 1.0f};
+    Random random = new Random(0);
+    VerifyingScheduler sss = new VerifyingScheduler(weights, new AtomicInteger(random.nextInt()));
+    int[] expectedPicks = new int[] {3, 2, 1};
+    int[] picks = new int[3];
+    for (int i = 0; i < 6; i++) {
+      picks[sss.pick()] += 1;
+    }
+    assertThat(picks).isEqualTo(expectedPicks);
+  }
+
+  @Test
+  public void testAllSameWeights() {
+    float[] weights = {1.0f, 1.0f, 1.0f};
+    Random random = new Random(0);
+    VerifyingScheduler sss = new VerifyingScheduler(weights, new AtomicInteger(random.nextInt()));
+    int[] expectedPicks = new int[] {2, 2, 2};
+    int[] picks = new int[3];
+    for (int i = 0; i < 6; i++) {
+      picks[sss.pick()] += 1;
+    }
+    assertThat(picks).isEqualTo(expectedPicks);
+  }
+
+  @Test
+  public void testAllZeroWeightsIsRoundRobin() {
+    float[] weights = {0.0f, 0.0f, 0.0f};
+    Random random = new Random(0);
+    VerifyingScheduler sss = new VerifyingScheduler(weights, new AtomicInteger(random.nextInt()));
+    int[] expectedPicks = new int[] {2, 2, 2};
+    int[] picks = new int[3];
+    for (int i = 0; i < 6; i++) {
+      picks[sss.pick()] += 1;
+    }
+    assertThat(picks).isEqualTo(expectedPicks);
+  }
+
+  @Test
+  public void testAllInvalidWeightsIsRoundRobin() {
+    float[] weights = {-3.1f, -0.0f, 0.0f};
+    Random random = new Random(0);
+    VerifyingScheduler sss = new VerifyingScheduler(weights, new AtomicInteger(random.nextInt()));
+    int[] expectedPicks = new int[] {2, 2, 2};
+    int[] picks = new int[3];
+    for (int i = 0; i < 6; i++) {
+      picks[sss.pick()] += 1;
+    }
+    assertThat(picks).isEqualTo(expectedPicks);
+  }
+
+  @Test
+  public void testTwoWeights() {
+    float[] weights = {1.43f, 2.119f};
+    Random random = new Random(0);
+    VerifyingScheduler sss = new VerifyingScheduler(weights, new AtomicInteger(random.nextInt()));
+    double totalWeight = 1.43 + 2.119;
+    Map<Integer, Integer> pickCount = new HashMap<>();
+    for (int i = 0; i < 1000; i++) {
+      int result = sss.pick();
+      pickCount.put(result, pickCount.getOrDefault(result, 0) + 1);
+    }
+    for (int i = 0; i < 2; i++) {
+      assertThat(Math.abs(pickCount.getOrDefault(i, 0) / 1000.0 - weights[i] / totalWeight))
+          .isLessThan(0.002);
+    }
+  }
+
+  @Test
+  public void testManyWeights() {
+    float[] weights = {1.3f, 2.5f, 3.23f, 4.11f, 7.001f};
+    Random random = new Random(0);
+    VerifyingScheduler sss = new VerifyingScheduler(weights, new AtomicInteger(random.nextInt()));
+    double totalWeight = 1.3 + 2.5 + 3.23 + 4.11 + 7.001;
+    Map<Integer, Integer> pickCount = new HashMap<>();
+    for (int i = 0; i < 1000; i++) {
+      int result = sss.pick();
+      pickCount.put(result, pickCount.getOrDefault(result, 0) + 1);
+    }
+    for (int i = 0; i < 5; i++) {
+      assertThat(Math.abs(pickCount.getOrDefault(i, 0) / 1000.0 - weights[i] / totalWeight))
+          .isLessThan(0.002);
+    }
+  }
+
+  @Test
+  public void testMaxClamped() {
+    float[] weights = {81f, 1f, 1f, 1f, 1f, 1f, 1f, 1f,
+        1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f, 1f};
+    VerifyingScheduler sss = new VerifyingScheduler(weights, new AtomicInteger(0));
+    int[] picks = new int[weights.length];
+
+    // max gets clamped to mean*maxRatio = 50 for this set of weights. So if we
+    // pick 50 + 19 times we should get all possible picks.
+    for (int i = 1; i < 70; i++) {
+      picks[sss.pick()] += 1;
+    }
+    int[] expectedPicks = new int[] {50, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+    assertThat(picks).isEqualTo(expectedPicks);
+  }
+
+  @Test
+  public void testMinClamped() {
+    float[] weights = {100f, 1e-10f};
+    VerifyingScheduler sss = new VerifyingScheduler(weights, new AtomicInteger(0));
+    int[] picks = new int[weights.length];
+
+    // We pick 201 elements and ensure that the second channel (with epsilon
+    // weight) also gets picked. The math is: mean value of elements is ~50, so
+    // the first channel keeps its weight of 100, but the second element's weight
+    // gets capped from below to 50*0.1 = 5.
+    for (int i = 0; i < 105; i++) {
+      picks[sss.pick()] += 1;
+    }
+    int[] expectedPicks = new int[] {100, 5};
+    assertThat(picks).isEqualTo(expectedPicks);
+  }
+
+  @Test
+  public void testDeterministicPicks() {
+    float[] weights = {2.0f, 3.0f, 6.0f};
+    AtomicInteger sequence = new AtomicInteger(0);
+    VerifyingScheduler sss = new VerifyingScheduler(weights, sequence);
+    assertThat(sequence.get()).isEqualTo(0);
+    assertThat(sss.pick()).isEqualTo(1);
+    assertThat(sequence.get()).isEqualTo(2);
+    assertThat(sss.pick()).isEqualTo(2);
+    assertThat(sequence.get()).isEqualTo(3);
+    assertThat(sss.pick()).isEqualTo(2);
+    assertThat(sequence.get()).isEqualTo(6);
+    assertThat(sss.pick()).isEqualTo(0);
+    assertThat(sequence.get()).isEqualTo(7);
+    assertThat(sss.pick()).isEqualTo(1);
+    assertThat(sequence.get()).isEqualTo(8);
+    assertThat(sss.pick()).isEqualTo(2);
+    assertThat(sequence.get()).isEqualTo(9);
+  }
+
+  @Test
+  public void testImmediateWraparound() {
+    float[] weights = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
+    VerifyingScheduler sss = new VerifyingScheduler(weights, new AtomicInteger(-1));
+    double totalWeight = 15;
+    Map<Integer, Integer> pickCount = new HashMap<>();
+    for (int i = 0; i < 1000; i++) {
+      int result = sss.pick();
+      pickCount.put(result, pickCount.getOrDefault(result, 0) + 1);
+    }
+    for (int i = 0; i < 5; i++) {
+      assertThat(Math.abs(pickCount.getOrDefault(i, 0) / 1000.0 - weights[i] / totalWeight))
+          .isLessThan(0.002);
+    }
+  }
+  
+  @Test
+  public void testWraparound() {
+    float[] weights = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f};
+    VerifyingScheduler sss = new VerifyingScheduler(weights, new AtomicInteger(-500));
+    double totalWeight = 15;
+    Map<Integer, Integer> pickCount = new HashMap<>();
+    for (int i = 0; i < 1000; i++) {
+      int result = sss.pick();
+      pickCount.put(result, pickCount.getOrDefault(result, 0) + 1);
+    }
+    for (int i = 0; i < 5; i++) {
+      assertThat(Math.abs(pickCount.getOrDefault(i, 0) / 1000.0 - weights[i] / totalWeight))
+          .isLessThan(0.002);
+    }
+  }
+
+  @Test
+  public void testDeterministicWraparound() {
+    float[] weights = {2.0f, 3.0f, 6.0f};
+    AtomicInteger sequence = new AtomicInteger(-1);
+    VerifyingScheduler sss = new VerifyingScheduler(weights, sequence);
+    assertThat(sequence.get()).isEqualTo(-1);
+    assertThat(sss.pick()).isEqualTo(1);
+    assertThat(sequence.get()).isEqualTo(2);
+    assertThat(sss.pick()).isEqualTo(2);
+    assertThat(sequence.get()).isEqualTo(3);
+    assertThat(sss.pick()).isEqualTo(2);
+    assertThat(sequence.get()).isEqualTo(6);
+    assertThat(sss.pick()).isEqualTo(0);
+    assertThat(sequence.get()).isEqualTo(7);
+    assertThat(sss.pick()).isEqualTo(1);
+    assertThat(sequence.get()).isEqualTo(8);
+    assertThat(sss.pick()).isEqualTo(2);
+    assertThat(sequence.get()).isEqualTo(9);
+  }
+
+  @Test
+  public void removingAddressShutsdownSubchannel() {
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+        .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+        .setAttributes(affinity).build()));
+    final Subchannel subchannel2 = subchannels.get(Collections.singletonList(servers.get(2)));
+
+    InOrder inOrder = Mockito.inOrder(helper, subchannel2);
+    // send LB only the first 2 addresses
+    List<EquivalentAddressGroup> svs2 = Arrays.asList(servers.get(0), servers.get(1));
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+        .setAddresses(svs2).setLoadBalancingPolicyConfig(weightedConfig)
+        .setAttributes(affinity).build()));
+    inOrder.verify(helper).updateBalancingState(eq(CONNECTING), any());
+    inOrder.verify(subchannel2).shutdown();
+  }
+
+
+  @Test
+  public void metrics() {
+    // Give WRR some valid addresses to work with.
+    Attributes attributesWithLocality = Attributes.newBuilder()
+        .set(WeightedTargetLoadBalancer.CHILD_NAME, locality)
+        .set(NameResolver.ATTR_BACKEND_SERVICE, backendService)
+        .build();
+    syncContext.execute(() -> wrr.acceptResolvedAddresses(ResolvedAddresses.newBuilder()
+        .setAddresses(servers).setLoadBalancingPolicyConfig(weightedConfig)
+        .setAttributes(attributesWithLocality).build()));
+
+    // Flip the three subchannels to READY state to initiate the WRR logic
+    Iterator<Subchannel> it = subchannels.values().iterator();
+    Subchannel readySubchannel1 = it.next();
+    getSubchannelStateListener(readySubchannel1).onSubchannelState(ConnectivityStateInfo
+        .forNonError(ConnectivityState.READY));
+    Subchannel readySubchannel2  = it.next();
+    getSubchannelStateListener(readySubchannel2).onSubchannelState(ConnectivityStateInfo
+        .forNonError(ConnectivityState.READY));
+    Subchannel readySubchannel3  = it.next();
+    getSubchannelStateListener(readySubchannel3).onSubchannelState(ConnectivityStateInfo
+        .forNonError(ConnectivityState.READY));
+
+    // WRR creates a picker that updates the weights for each of the child subchannels. This should
+    // give us three "rr_fallback" metric events as we don't yet have any weights to do weighted
+    // round-robin.
+    verifyLongCounterRecord("grpc.lb.wrr.rr_fallback", 3, 1);
+
+    // We should also see six records of endpoint weights. They should all be for 0 as we don't yet
+    // have valid weights.
+    verifyDoubleHistogramRecord("grpc.lb.wrr.endpoint_weights", 6, 0);
+
+    // We should not yet be seeing any "endpoint_weight_stale" events since we don't even have
+    // valid weights yet.
+    verifyLongCounterRecord("grpc.lb.wrr.endpoint_weight_stale", 0, 1);
+
+    // Each time weights are updated, WRR will see if each subchannel weight is useable. As we have
+    // no weights yet, we should see three "endpoint_weight_not_yet_usable" metric events with the
+    // value increasing by one each time as all the endpoints come online.
+    verifyLongCounterRecord("grpc.lb.wrr.endpoint_weight_not_yet_usable", 1, 1);
+    verifyLongCounterRecord("grpc.lb.wrr.endpoint_weight_not_yet_usable", 1, 2);
+    verifyLongCounterRecord("grpc.lb.wrr.endpoint_weight_not_yet_usable", 1, 3);
+
+    // Send one child LB state an ORCA update with some valid utilization/qps data so that weights
+    // can be calculated, but it's still essentially round_robin
+    Iterator<ChildLbState> childLbStates = wrr.getChildLbStates().iterator();
+    ((WeightedChildLbState)childLbStates.next()).new OrcaReportListener(
+        weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(0.1, 0, 0.1, 1, 0, new HashMap<>(),
+            new HashMap<>(), new HashMap<>()));
+
+    fakeClock.forwardTime(1, TimeUnit.SECONDS);
+
+    // Now send a second child LB state an ORCA update, so there's real weights
+    ((WeightedChildLbState)childLbStates.next()).new OrcaReportListener(
+        weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(0.1, 0, 0.1, 1, 0, new HashMap<>(),
+            new HashMap<>(), new HashMap<>()));
+    ((WeightedChildLbState)childLbStates.next()).new OrcaReportListener(
+        weightedConfig.errorUtilizationPenalty).onLoadReport(
+        InternalCallMetricRecorder.createMetricReport(0.1, 0, 0.1, 1, 0, new HashMap<>(),
+            new HashMap<>(), new HashMap<>()));
+
+    // Let's reset the mock MetricsRecorder so that it's easier to verify what happened after the
+    // weights were updated
+    reset(mockMetricRecorder);
+
+    // We go forward in time past the default 10s blackout period for the first child. The weights
+    // would get updated as the default update interval is 1s.
+    fakeClock.forwardTime(9, TimeUnit.SECONDS);
+
+    verifyLongCounterRecord("grpc.lb.wrr.rr_fallback", 1, 1);
+
+    // And after another second the other children have weights
+    reset(mockMetricRecorder);
+    fakeClock.forwardTime(1, TimeUnit.SECONDS);
+
+    // Since we have weights on all the child LB states, the weight update should not result in
+    // further rr_fallback metric entries.
+    verifyLongCounterRecord("grpc.lb.wrr.rr_fallback", 0, 1);
+
+    // We should not see an increase to the earlier count of "endpoint_weight_not_yet_usable".
+    verifyLongCounterRecord("grpc.lb.wrr.endpoint_weight_not_yet_usable", 0, 1);
+
+    // No endpoints should have gotten stale yet either.
+    verifyLongCounterRecord("grpc.lb.wrr.endpoint_weight_stale", 0, 1);
+
+    // Now with valid weights we should have seen the value in the endpoint weights histogram.
+    verifyDoubleHistogramRecord("grpc.lb.wrr.endpoint_weights", 3, 10);
+
+    reset(mockMetricRecorder);
+
+    // Weights become stale in three minutes. Let's move ahead in time by 3 minutes and make sure
+    // we get metrics events for each endpoint.
+    fakeClock.forwardTime(3, TimeUnit.MINUTES);
+
+    verifyLongCounterRecord("grpc.lb.wrr.endpoint_weight_stale", 1, 3);
+
+    // With the weights stale each three endpoints should report 0 weights.
+    verifyDoubleHistogramRecord("grpc.lb.wrr.endpoint_weights", 3, 0);
+
+    // Since the weights are now stale the update should have triggered an additional rr_fallback
+    // event.
+    verifyLongCounterRecord("grpc.lb.wrr.rr_fallback", 1, 1);
+
+    // No further weights-not-useable events should occur, since we have received weights and
+    // are out of the blackout.
+    verifyLongCounterRecord("grpc.lb.wrr.endpoint_weight_not_yet_usable", 0, 1);
+
+    // All metric events should be accounted for.
+    verifyNoMoreInteractions(mockMetricRecorder);
+  }
+
+  @Test
+  public void metricWithRealChannel() throws Exception {
+    String serverName = "wrr-metrics";
+    grpcCleanupRule.register(
+        InProcessServerBuilder.forName(serverName)
+        .addService(ServerServiceDefinition.builder(
+            TestMethodDescriptors.voidMethod().getServiceName())
+          .addMethod(TestMethodDescriptors.voidMethod(), (call, headers) -> {
+            call.sendHeaders(new Metadata());
+            call.sendMessage(null);
+            call.close(Status.OK, new Metadata());
+            return new ServerCall.Listener<Void>() {};
+          })
+          .build())
+        .directExecutor()
+        .build()
+        .start());
+    MetricSink metrics = mock(MetricSink.class, delegatesTo(new NoopMetricSink()));
+    Channel channel = grpcCleanupRule.register(
+        InternalManagedChannelBuilder.addMetricSink(
+            InProcessChannelBuilder.forName(serverName)
+            .defaultServiceConfig(Collections.singletonMap(
+                "loadBalancingConfig", Arrays.asList(Collections.singletonMap(
+                    "weighted_round_robin", Collections.emptyMap()))))
+            .directExecutor(),
+        metrics)
+        .directExecutor()
+        .build());
+
+    // Ping-pong to wait for channel to fully start
+    StreamRecorder<Void> recorder = StreamRecorder.create();
+    StreamObserver<Void> requestObserver = ClientCalls.asyncClientStreamingCall(
+        channel.newCall(TestMethodDescriptors.voidMethod(), CallOptions.DEFAULT), recorder);
+    requestObserver.onCompleted();
+    assertThat(recorder.awaitCompletion(10, TimeUnit.SECONDS)).isTrue();
+    assertThat(recorder.getError()).isNull();
+
+    // Make sure at least one metric works. The other tests will make sure other metrics and the
+    // edge cases are working. Since this is racy, we just care it happened at least once.
+    verify(metrics, atLeast(1)).addLongCounter(
+        argThat((instr) -> instr.getName().equals("grpc.lb.wrr.rr_fallback")),
+        eq(1L),
+        eq(Arrays.asList("directaddress:///wrr-metrics")),
+        eq(Arrays.asList("", "")));
+  }
+
+  // Verifies that the MetricRecorder has been called to record a long counter value of 1 for the
+  // given metric name, the given number of times
+  private void verifyLongCounterRecord(String name, int times, long value) {
+    verify(mockMetricRecorder, times(times)).addLongCounter(
+        argThat(new ArgumentMatcher<LongCounterMetricInstrument>() {
+          @Override
+          public boolean matches(LongCounterMetricInstrument longCounterInstrument) {
+            return longCounterInstrument.getName().equals(name);
+          }
+        }),
+        eq(value),
+        eq(Lists.newArrayList(channelTarget)),
+        eq(Lists.newArrayList(locality, backendService)));
+  }
+
+  // Verifies that the MetricRecorder has been called to record a given double histogram value the
+  // given amount of times.
+  private void verifyDoubleHistogramRecord(String name, int times, double value) {
+    verify(mockMetricRecorder, times(times)).recordDoubleHistogram(
+        argThat(new ArgumentMatcher<DoubleHistogramMetricInstrument>() {
+          @Override
+          public boolean matches(DoubleHistogramMetricInstrument doubleHistogramInstrument) {
+            return doubleHistogramInstrument.getName().equals(name);
+          }
+        }),
+        eq(value),
+        eq(Lists.newArrayList(channelTarget)),
+        eq(Lists.newArrayList(locality, backendService)));
+  }
+
+  private int getNumFilteredPendingTasks() {
+    return AbstractTestHelper.getNumFilteredPendingTasks(fakeClock);
+  }
+
+  private static final Metadata.Key<OrcaLoadReport> ORCA_LOAD_METRICS_KEY =
+        Metadata.Key.of(
+            "endpoint-load-metrics-bin",
+            ProtoUtils.metadataMarshaller(OrcaLoadReport.getDefaultInstance()));
+  private static final ClientStreamTracer.StreamInfo STREAM_INFO =
+      ClientStreamTracer.StreamInfo.newBuilder().build();
+
+  private static void reportLoadOnRpc(
+      PickResult pickResult,
+      double cpuUtilization,
+      double applicationUtilization,
+      double memoryUtilization,
+      double qps,
+      double eps) {
+    ClientStreamTracer childTracer = pickResult.getStreamTracerFactory()
+        .newClientStreamTracer(STREAM_INFO, new Metadata());
+    Metadata trailer = new Metadata();
+    trailer.put(
+        ORCA_LOAD_METRICS_KEY,
+        OrcaLoadReport.newBuilder()
+          .setCpuUtilization(cpuUtilization)
+          .setApplicationUtilization(applicationUtilization)
+          .setMemUtilization(memoryUtilization)
+          .setRpsFractional(qps)
+          .setEps(eps)
+          .build());
+    childTracer.inboundTrailers(trailer);
+  }
+
+  private static final class VerifyingScheduler {
+    private final StaticStrideScheduler delegate;
+    private final int max;
+    private final AtomicInteger sequence;
+
+    public VerifyingScheduler(float[] weights, AtomicInteger sequence) {
+      this.delegate = new StaticStrideScheduler(weights, sequence);
+      this.max = weights.length;
+      this.sequence = sequence;
+    }
+
+    public int pick() {
+      int start = sequence.get();
+      int i = delegate.pick();
+      assertThat(sequence.get() - start).isAtMost(max);
+      return i;
+    }
+  }
+
+  private static class FakeSocketAddress extends SocketAddress {
+    final String name;
+
+    FakeSocketAddress(String name) {
+      this.name = name;
+    }
+
+    @Override public String toString() {
+      return "FakeSocketAddress-" + name;
+    }
+  }
+
+  private static class FakeRandom extends Random {
+    private int nextInt;
+
+    public FakeRandom(int nextInt) {
+      this.nextInt = nextInt;
+    }
+
+    @Override
+    public int nextInt() {
+      // return constant value to disable init deadline randomization in the scheduler
+      return nextInt;
+    }
+  }
+
+  private class TestHelper extends AbstractTestHelper {
+    public TestHelper() {
+      super(fakeClock, syncContext);
+    }
+
+    @Override
+    public Map<List<EquivalentAddressGroup>, Subchannel> getSubchannelMap() {
+      return subchannels;
+    }
+
+    @Override
+    public MetricRecorder getMetricRecorder() {
+      return mockMetricRecorder;
+    }
+
+    @Override
+    public String getChannelTarget() {
+      return channelTarget;
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/WeightedTargetLoadBalancerProviderTest.java b/xds/src/test/java/io/grpc/xds/WeightedTargetLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..c8eab309f38
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/WeightedTargetLoadBalancerProviderTest.java
@@ -0,0 +1,140 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import com.google.common.collect.ImmutableMap;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.internal.JsonParser;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedPolicySelection;
+import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedTargetConfig;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Tests for {@link WeightedTargetLoadBalancerProvider}. */
+@RunWith(JUnit4.class)
+public class WeightedTargetLoadBalancerProviderTest {
+
+  @Test
+  public void parseWeightedTargetConfig() throws Exception {
+    LoadBalancerRegistry lbRegistry = new LoadBalancerRegistry();
+    WeightedTargetLoadBalancerProvider weightedTargetLoadBalancerProvider =
+        new WeightedTargetLoadBalancerProvider(lbRegistry);
+    final Object fooConfig = new Object();
+    LoadBalancerProvider lbProviderFoo = new LoadBalancerProvider() {
+      @Override
+      public boolean isAvailable() {
+        return true;
+      }
+
+      @Override
+      public int getPriority() {
+        return 5;
+      }
+
+      @Override
+      public String getPolicyName() {
+        return "foo_policy";
+      }
+
+      @Override
+      public LoadBalancer newLoadBalancer(Helper helper) {
+        return mock(LoadBalancer.class);
+      }
+
+      @Override
+      public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
+        return ConfigOrError.fromConfig(fooConfig);
+      }
+    };
+    final Object barConfig = new Object();
+    LoadBalancerProvider lbProviderBar = new LoadBalancerProvider() {
+      @Override
+      public boolean isAvailable() {
+        return true;
+      }
+
+      @Override
+      public int getPriority() {
+        return 5;
+      }
+
+      @Override
+      public String getPolicyName() {
+        return "bar_policy";
+      }
+
+      @Override
+      public LoadBalancer newLoadBalancer(Helper helper) {
+        return mock(LoadBalancer.class);
+      }
+
+      @Override
+      public ConfigOrError parseLoadBalancingPolicyConfig(Map<String, ?> rawConfig) {
+        return ConfigOrError.fromConfig(barConfig);
+      }
+    };
+    lbRegistry.register(lbProviderFoo);
+    lbRegistry.register(lbProviderBar);
+
+    String weightedTargetConfigJson = ("{"
+        + "  'targets' : {"
+        + "    'target_1' : {"
+        + "      'weight' : 10,"
+        + "      'childPolicy' : ["
+        + "        {'unsupported_policy' : {}},"
+        + "        {'foo_policy' : {}}"
+        + "      ]"
+        + "    },"
+        + "    'target_2' : {"
+        + "      'weight' : 20,"
+        + "      'childPolicy' : ["
+        + "        {'unsupported_policy' : {}},"
+        + "        {'bar_policy' : {}}"
+        + "      ]"
+        + "    }"
+        + "  }"
+        + "}").replace('\'', '"');
+
+    @SuppressWarnings("unchecked")
+    Map<String, ?> rawLbConfigMap = (Map<String, ?>) JsonParser.parse(weightedTargetConfigJson);
+    ConfigOrError parsedConfig =
+        weightedTargetLoadBalancerProvider.parseLoadBalancingPolicyConfig(rawLbConfigMap);
+    ConfigOrError expectedConfig = ConfigOrError.fromConfig(
+        new WeightedTargetConfig(ImmutableMap.of(
+            "target_1",
+            new WeightedPolicySelection(
+                10,
+                GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+                    lbProviderFoo, fooConfig)),
+            "target_2",
+            new WeightedPolicySelection(
+                20,
+                GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(
+                    lbProviderBar, barConfig)))));
+    assertThat(parsedConfig).isEqualTo(expectedConfig);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/WeightedTargetLoadBalancerTest.java b/xds/src/test/java/io/grpc/xds/WeightedTargetLoadBalancerTest.java
new file mode 100644
index 00000000000..55ff0cd8078
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/WeightedTargetLoadBalancerTest.java
@@ -0,0 +1,496 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.TRANSIENT_FAILURE;
+import static io.grpc.LoadBalancerMatchers.pickerReturns;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.FixedResultPicker;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.xds.WeightedRandomPicker.WeightedChildPicker;
+import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedPolicySelection;
+import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedTargetConfig;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Tests for {@link WeightedTargetLoadBalancer}. */
+@RunWith(JUnit4.class)
+public class WeightedTargetLoadBalancerTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final LoadBalancerRegistry lbRegistry = new LoadBalancerRegistry();
+  private final List<LoadBalancer> childBalancers = new ArrayList<>();
+  private final List<Helper> childHelpers = new ArrayList<>();
+  private final int[] weights = {10, 20, 30, 40};
+  private final Object[] configs = {"config0", "config1", "config3", "config4"};
+  private final SocketAddress[] socketAddresses = {
+    new InetSocketAddress(8080),
+    new InetSocketAddress(8081),
+    new InetSocketAddress(8083),
+    new InetSocketAddress(8084)
+  };
+
+  private final LoadBalancerProvider fooLbProvider = new LoadBalancerProvider() {
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 5;
+    }
+
+    @Override
+    public String getPolicyName() {
+      return "foo_policy";
+    }
+
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      childHelpers.add(helper);
+      LoadBalancer childBalancer = mock(LoadBalancer.class);
+      when(childBalancer.acceptResolvedAddresses(any())).thenReturn(Status.OK);
+      childBalancers.add(childBalancer);
+      fooLbCreated++;
+      return childBalancer;
+    }
+  };
+
+  private final LoadBalancerProvider barLbProvider = new LoadBalancerProvider() {
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 5;
+    }
+
+    @Override
+    public String getPolicyName() {
+      return "bar_policy";
+    }
+
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      childHelpers.add(helper);
+      LoadBalancer childBalancer = mock(LoadBalancer.class);
+      when(childBalancer.acceptResolvedAddresses(any())).thenReturn(Status.OK);
+      childBalancers.add(childBalancer);
+      barLbCreated++;
+      return childBalancer;
+    }
+  };
+
+  private final WeightedPolicySelection weightedLbConfig0 = new WeightedPolicySelection(
+      weights[0], newChildConfig(fooLbProvider, configs[0]));
+  private final WeightedPolicySelection weightedLbConfig1 = new WeightedPolicySelection(
+      weights[1], newChildConfig(barLbProvider, configs[1]));
+  private final WeightedPolicySelection weightedLbConfig2 = new WeightedPolicySelection(
+      weights[2],  newChildConfig(barLbProvider, configs[2]));
+  private final WeightedPolicySelection weightedLbConfig3 = new WeightedPolicySelection(
+      weights[3], newChildConfig(fooLbProvider, configs[3]));
+
+  @Mock
+  private Helper helper;
+
+  private LoadBalancer weightedTargetLb;
+  private int fooLbCreated;
+  private int barLbCreated;
+
+  @Before
+  public void setUp() {
+    when(helper.getSynchronizationContext()).thenReturn(syncContext);
+    lbRegistry.register(fooLbProvider);
+    lbRegistry.register(barLbProvider);
+
+    weightedTargetLb = new WeightedTargetLoadBalancer(helper);
+    clearInvocations(helper);
+  }
+
+  @After
+  public void tearDown() {
+    weightedTargetLb.shutdown();
+    for (LoadBalancer childBalancer : childBalancers) {
+      verify(childBalancer).shutdown();
+    }
+  }
+
+  @Test
+  public void acceptResolvedAddresses() {
+    ArgumentCaptor<ResolvedAddresses> resolvedAddressesCaptor =
+        ArgumentCaptor.forClass(ResolvedAddresses.class);
+    Attributes.Key<Object> fakeKey = Attributes.Key.create("fake_key");
+    Object fakeValue = new Object();
+
+    Map<String, WeightedPolicySelection> targets = ImmutableMap.of(
+        // {foo, 10, config0}
+        "target0", weightedLbConfig0,
+        // {bar, 20, config1}
+        "target1", weightedLbConfig1,
+        // {bar, 30, config2}
+        "target2", weightedLbConfig2,
+        // {foo, 40, config3}
+        "target3", weightedLbConfig3);
+    EquivalentAddressGroup eag0 = new EquivalentAddressGroup(socketAddresses[0]);
+    eag0 = AddressFilter.setPathFilter(eag0, ImmutableList.of("target0"));
+    EquivalentAddressGroup eag1 = new EquivalentAddressGroup(socketAddresses[1]);
+    eag1 = AddressFilter.setPathFilter(eag1, ImmutableList.of("target1"));
+    EquivalentAddressGroup eag2 = new EquivalentAddressGroup(socketAddresses[2]);
+    eag2 = AddressFilter.setPathFilter(eag2, ImmutableList.of("target2"));
+    EquivalentAddressGroup eag3 = new EquivalentAddressGroup(socketAddresses[3]);
+    eag3 = AddressFilter.setPathFilter(eag3, ImmutableList.of("target3"));
+    Status status = weightedTargetLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.of(eag0, eag1, eag2, eag3))
+            .setAttributes(Attributes.newBuilder().set(fakeKey, fakeValue).build())
+            .setLoadBalancingPolicyConfig(new WeightedTargetConfig(targets))
+            .build());
+    assertThat(status.isOk()).isTrue();
+    verify(helper).updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+    assertThat(childBalancers).hasSize(4);
+    assertThat(childHelpers).hasSize(4);
+    assertThat(fooLbCreated).isEqualTo(2);
+    assertThat(barLbCreated).isEqualTo(2);
+
+    for (int i = 0; i < childBalancers.size(); i++) {
+      verify(childBalancers.get(i)).acceptResolvedAddresses(resolvedAddressesCaptor.capture());
+      ResolvedAddresses resolvedAddresses = resolvedAddressesCaptor.getValue();
+      assertThat(resolvedAddresses.getLoadBalancingPolicyConfig()).isEqualTo(configs[i]);
+      assertThat(resolvedAddresses.getAttributes().get(fakeKey)).isEqualTo(fakeValue);
+      assertThat(resolvedAddresses.getAttributes().get(WeightedTargetLoadBalancer.CHILD_NAME))
+          .isEqualTo("target" + i);
+      assertThat(Iterables.getOnlyElement(resolvedAddresses.getAddresses()).getAddresses())
+          .containsExactly(socketAddresses[i]);
+    }
+
+    // Even when a child return an error from the update, the other children should still receive
+    // their updates.
+    Status acceptReturnStatus = Status.UNAVAILABLE.withDescription("Didn't like something");
+    when(childBalancers.get(2).acceptResolvedAddresses(any())).thenReturn(acceptReturnStatus);
+
+    // Update new weighted target config for a typical workflow.
+    // target0 removed. target1, target2, target3 changed weight and config. target4 added.
+    int[] newWeights = new int[]{11, 22, 33, 44};
+    Object[] newConfigs = new Object[]{"newConfig1", "newConfig2", "newConfig3", "newConfig4"};
+    Map<String, WeightedPolicySelection> newTargets = ImmutableMap.of(
+        "target1",
+        new WeightedPolicySelection(
+            newWeights[0], newChildConfig(barLbProvider, newConfigs[0])),
+        "target2",
+        new WeightedPolicySelection(
+            newWeights[1], newChildConfig(barLbProvider, newConfigs[1])),
+        "target3",
+        new WeightedPolicySelection(
+            newWeights[2], newChildConfig(fooLbProvider, newConfigs[2])),
+        "target4",
+        new WeightedPolicySelection(
+            newWeights[3], newChildConfig(fooLbProvider, newConfigs[3])));
+    status = weightedTargetLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(new WeightedTargetConfig(newTargets))
+            .build());
+    assertThat(status.getCode()).isEqualTo(acceptReturnStatus.getCode());
+    verify(helper, atLeast(2))
+        .updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+    assertThat(childBalancers).hasSize(5);
+    assertThat(childHelpers).hasSize(5);
+    assertThat(fooLbCreated).isEqualTo(3); // One more foo LB created for target4
+    assertThat(barLbCreated).isEqualTo(2);
+
+    verify(childBalancers.get(0)).shutdown();
+    for (int i = 1; i < childBalancers.size(); i++) {
+      verify(childBalancers.get(i), atLeastOnce())
+          .acceptResolvedAddresses(resolvedAddressesCaptor.capture());
+      assertThat(resolvedAddressesCaptor.getValue().getLoadBalancingPolicyConfig())
+          .isEqualTo(newConfigs[i - 1]);
+    }
+  }
+
+  @Test
+  public void handleNameResolutionError() {
+    ArgumentCaptor<SubchannelPicker> pickerCaptor = ArgumentCaptor.forClass(SubchannelPicker.class);
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+
+    // Error before any child balancer created.
+    weightedTargetLb.handleNameResolutionError(Status.DATA_LOSS);
+
+    verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    PickResult pickResult = pickerCaptor.getValue().pickSubchannel(mock(PickSubchannelArgs.class));
+    assertThat(pickResult.getStatus().getCode()).isEqualTo(Status.Code.DATA_LOSS);
+
+    // Child configs updated.
+    Map<String, WeightedPolicySelection> targets = ImmutableMap.of(
+        // {foo, 10, config0}
+        "target0", weightedLbConfig0,
+        // {bar, 20, config1}
+        "target1", weightedLbConfig1,
+        // {bar, 30, config2}
+        "target2", weightedLbConfig2,
+        // {foo, 40, config3}
+        "target3", weightedLbConfig3);
+    weightedTargetLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(new WeightedTargetConfig(targets))
+            .build());
+    verify(helper).updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+
+    // Error after child balancers created.
+    weightedTargetLb.handleNameResolutionError(Status.ABORTED);
+
+    for (LoadBalancer childBalancer : childBalancers) {
+      verify(childBalancer).handleNameResolutionError(statusCaptor.capture());
+      assertThat(statusCaptor.getValue().getCode()).isEqualTo(Status.Code.ABORTED);
+    }
+  }
+
+  @Test
+  public void balancingStateUpdatedFromChildBalancers() {
+    Map<String, WeightedPolicySelection> targets = ImmutableMap.of(
+        // {foo, 10, config0}
+        "target0", weightedLbConfig0,
+        // {bar, 20, config1}
+        "target1", weightedLbConfig1,
+        // {bar, 30, config2}
+        "target2", weightedLbConfig2,
+        // {foo, 40, config3}
+        "target3", weightedLbConfig3);
+    weightedTargetLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(new WeightedTargetConfig(targets))
+            .build());
+    verify(helper).updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+
+    // Subchannels to be created for each child balancer.
+    final SubchannelPicker[] subchannelPickers = new SubchannelPicker[]{
+        mock(SubchannelPicker.class),
+        mock(SubchannelPicker.class),
+        mock(SubchannelPicker.class),
+        mock(SubchannelPicker.class)};
+    final SubchannelPicker[] failurePickers = new SubchannelPicker[]{
+        new FixedResultPicker(PickResult.withError(Status.CANCELLED)),
+        new FixedResultPicker(PickResult.withError(Status.ABORTED)),
+        new FixedResultPicker(PickResult.withError(Status.DATA_LOSS)),
+        new FixedResultPicker(PickResult.withError(Status.DATA_LOSS))
+    };
+    ArgumentCaptor<SubchannelPicker> pickerCaptor = ArgumentCaptor.forClass(SubchannelPicker.class);
+
+    // One child balancer goes to TRANSIENT_FAILURE.
+    childHelpers.get(1).updateBalancingState(TRANSIENT_FAILURE, failurePickers[1]);
+    verify(helper, never()).updateBalancingState(
+        eq(TRANSIENT_FAILURE), any(SubchannelPicker.class));
+    verify(helper, times(2))
+        .updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+
+    // Another child balancer goes to READY.
+    childHelpers.get(2).updateBalancingState(READY, subchannelPickers[2]);
+    verify(helper).updateBalancingState(eq(READY), pickerCaptor.capture());
+    assertThat(pickerCaptor.getValue()).isInstanceOf(WeightedRandomPicker.class);
+    WeightedRandomPicker overallPicker = (WeightedRandomPicker) pickerCaptor.getValue();
+    assertThat(overallPicker.weightedChildPickers)
+        .containsExactly(new WeightedChildPicker(weights[2], subchannelPickers[2]));
+
+    // Another child balancer goes to READY.
+    childHelpers.get(3).updateBalancingState(READY, subchannelPickers[3]);
+    verify(helper, times(2)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    overallPicker = (WeightedRandomPicker) pickerCaptor.getValue();
+    assertThat(overallPicker.weightedChildPickers)
+        .containsExactly(
+            new WeightedChildPicker(weights[2], subchannelPickers[2]),
+            new WeightedChildPicker(weights[3], subchannelPickers[3]));
+
+    // Another child balancer goes to READY.
+    childHelpers.get(0).updateBalancingState(READY, subchannelPickers[0]);
+    verify(helper, times(3)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    overallPicker = (WeightedRandomPicker) pickerCaptor.getValue();
+    assertThat(overallPicker.weightedChildPickers)
+        .containsExactly(
+            new WeightedChildPicker(weights[0], subchannelPickers[0]),
+            new WeightedChildPicker(weights[2], subchannelPickers[2]),
+            new WeightedChildPicker(weights[3], subchannelPickers[3]));
+
+    // One of READY child balancers goes to TRANSIENT_FAILURE.
+    childHelpers.get(2).updateBalancingState(TRANSIENT_FAILURE, failurePickers[2]);
+    verify(helper, times(4)).updateBalancingState(eq(READY), pickerCaptor.capture());
+    overallPicker = (WeightedRandomPicker) pickerCaptor.getValue();
+    assertThat(overallPicker.weightedChildPickers)
+        .containsExactly(
+            new WeightedChildPicker(weights[0], subchannelPickers[0]),
+            new WeightedChildPicker(weights[3], subchannelPickers[3]));
+
+    // All child balancers go to TRANSIENT_FAILURE.
+    childHelpers.get(3).updateBalancingState(TRANSIENT_FAILURE, failurePickers[3]);
+    childHelpers.get(0).updateBalancingState(TRANSIENT_FAILURE, failurePickers[0]);
+    verify(helper).updateBalancingState(eq(TRANSIENT_FAILURE), pickerCaptor.capture());
+    overallPicker = (WeightedRandomPicker) pickerCaptor.getValue();
+    assertThat(overallPicker.weightedChildPickers)
+        .containsExactly(
+            new WeightedChildPicker(weights[0], failurePickers[0]),
+            new WeightedChildPicker(weights[1], failurePickers[1]),
+            new WeightedChildPicker(weights[2], failurePickers[2]),
+            new WeightedChildPicker(weights[3], failurePickers[3]));
+  }
+
+  @Test
+  public void raceBetweenShutdownAndChildLbBalancingStateUpdate() {
+    Map<String, WeightedPolicySelection> targets = ImmutableMap.of(
+        "target0", weightedLbConfig0,
+        "target1", weightedLbConfig1);
+    weightedTargetLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(new WeightedTargetConfig(targets))
+            .build());
+    verify(helper).updateBalancingState(eq(CONNECTING), pickerReturns(PickResult.withNoResult()));
+
+    // LB shutdown and subchannel state change can happen simultaneously. If shutdown runs first,
+    // any further balancing state update should be ignored.
+    weightedTargetLb.shutdown();
+    Helper weightedChildHelper0 = childHelpers.iterator().next();
+    weightedChildHelper0.updateBalancingState(READY, mock(SubchannelPicker.class));
+    verifyNoMoreInteractions(helper);
+  }
+
+  // When the ChildHelper is asked to update the overall balancing state, it should not do that if
+  // the update was triggered by the parent LB that will handle triggering the overall state update.
+  @Test
+  public void noDuplicateOverallBalancingStateUpdate() {
+    FakeLoadBalancerProvider fakeLbProvider = new FakeLoadBalancerProvider();
+
+    Map<String, WeightedPolicySelection> targets = ImmutableMap.of(
+        "target0", new WeightedPolicySelection(
+            weights[0], newChildConfig(fakeLbProvider, configs[0])),
+        "target3", new WeightedPolicySelection(
+            weights[3], newChildConfig(fakeLbProvider, configs[3])));
+    weightedTargetLb.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder()
+            .setAddresses(ImmutableList.<EquivalentAddressGroup>of())
+            .setLoadBalancingPolicyConfig(new WeightedTargetConfig(targets))
+            .build());
+
+    // Both of the two child LB policies will call the helper to update the balancing state.
+    // But since those calls happen during the handling of teh resolved addresses of the parent
+    // WeightedTargetLLoadBalancer, the overall balancing state should only be updated once.
+    verify(helper, times(1)).updateBalancingState(any(), any());
+
+  }
+
+  private Object newChildConfig(LoadBalancerProvider provider, Object config) {
+    return GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(provider, config);
+  }
+
+  private static class FakeLoadBalancerProvider extends LoadBalancerProvider {
+
+    @Override
+    public boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    public int getPriority() {
+      return 5;
+    }
+
+    @Override
+    public String getPolicyName() {
+      return "foo";
+    }
+
+    @Override
+    public LoadBalancer newLoadBalancer(Helper helper) {
+      return new FakeLoadBalancer(helper);
+    }
+  }
+
+  static class FakeLoadBalancer extends LoadBalancer {
+
+    private Helper helper;
+
+    FakeLoadBalancer(Helper helper) {
+      this.helper = helper;
+    }
+
+    @Override
+    public Status acceptResolvedAddresses(ResolvedAddresses resolvedAddresses) {
+      helper.updateBalancingState(
+          TRANSIENT_FAILURE, new FixedResultPicker(PickResult.withError(Status.INTERNAL)));
+      return Status.OK;
+    }
+
+    @Override
+    public void handleNameResolutionError(Status error) {
+    }
+
+    @Override
+    public void shutdown() {
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/WrrLocalityLoadBalancerProviderTest.java b/xds/src/test/java/io/grpc/xds/WrrLocalityLoadBalancerProviderTest.java
new file mode 100644
index 00000000000..c9ec2bb6af4
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/WrrLocalityLoadBalancerProviderTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2022 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.NameResolver;
+import io.grpc.util.GracefulSwitchLoadBalancerAccessor;
+import io.grpc.xds.WrrLocalityLoadBalancer.WrrLocalityConfig;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link WrrLocalityLoadBalancerProvider}.
+ */
+@RunWith(JUnit4.class)
+public class WrrLocalityLoadBalancerProviderTest {
+
+  @Test
+  public void provided() {
+    LoadBalancerProvider provider =
+        LoadBalancerRegistry.getDefaultRegistry().getProvider(
+            XdsLbPolicies.WRR_LOCALITY_POLICY_NAME);
+    assertThat(provider).isInstanceOf(WrrLocalityLoadBalancerProvider.class);
+  }
+
+  @Test
+  public void providesLoadBalancer()  {
+    Helper helper = mock(Helper.class);
+    when(helper.getAuthority()).thenReturn("api.google.com");
+    LoadBalancerProvider provider = new WrrLocalityLoadBalancerProvider();
+    LoadBalancer loadBalancer = provider.newLoadBalancer(helper);
+    assertThat(loadBalancer).isInstanceOf(WrrLocalityLoadBalancer.class);
+  }
+
+  @Test
+  public void parseConfig() {
+    Map<String, ?> rawConfig = ImmutableMap.of("childPolicy",
+        ImmutableList.of(ImmutableMap.of("round_robin", ImmutableMap.of())));
+
+    WrrLocalityLoadBalancerProvider provider = new WrrLocalityLoadBalancerProvider();
+    NameResolver.ConfigOrError configOrError = provider.parseLoadBalancingPolicyConfig(rawConfig);
+    WrrLocalityConfig config = (WrrLocalityConfig) configOrError.getConfig();
+    LoadBalancerProvider childProvider =
+        GracefulSwitchLoadBalancerAccessor.getChildProvider(config.childConfig);
+    assertThat(childProvider.getPolicyName()).isEqualTo("round_robin");
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/WrrLocalityLoadBalancerTest.java b/xds/src/test/java/io/grpc/xds/WrrLocalityLoadBalancerTest.java
new file mode 100644
index 00000000000..584c32738c5
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/WrrLocalityLoadBalancerTest.java
@@ -0,0 +1,266 @@
+/*
+ * Copyright 2022 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.LoadBalancerMatchers.pickerReturns;
+import static io.grpc.xds.XdsLbPolicies.WEIGHTED_TARGET_POLICY_NAME;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isA;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.testing.EqualsTester;
+import io.grpc.Attributes;
+import io.grpc.ConnectivityState;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.PickResult;
+import io.grpc.LoadBalancer.ResolvedAddresses;
+import io.grpc.LoadBalancerProvider;
+import io.grpc.LoadBalancerRegistry;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.util.GracefulSwitchLoadBalancer;
+import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedPolicySelection;
+import io.grpc.xds.WeightedTargetLoadBalancerProvider.WeightedTargetConfig;
+import io.grpc.xds.WrrLocalityLoadBalancer.WrrLocalityConfig;
+import java.net.SocketAddress;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Tests for {@link WrrLocalityLoadBalancerProvider}.
+ */
+@RunWith(JUnit4.class)
+public class WrrLocalityLoadBalancerTest {
+  @Rule
+  public final MockitoRule mockito = MockitoJUnit.rule();
+
+  @Mock
+  private LoadBalancerProvider mockWeightedTargetProvider;
+  @Mock
+  private LoadBalancer mockWeightedTargetLb;
+  @Mock
+  private LoadBalancerProvider mockChildProvider;
+  @Mock
+  private LoadBalancer mockChildLb;
+  @Mock
+  private Helper mockHelper;
+
+  @Captor
+  private ArgumentCaptor<ResolvedAddresses> resolvedAddressesCaptor;
+
+  private WrrLocalityLoadBalancer loadBalancer;
+  private LoadBalancerRegistry lbRegistry = new LoadBalancerRegistry();
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+
+  @Before
+  public void setUp() {
+    when(mockHelper.getSynchronizationContext()).thenReturn(syncContext);
+
+    when(mockWeightedTargetProvider.newLoadBalancer(isA(Helper.class))).thenReturn(
+        mockWeightedTargetLb);
+    when(mockWeightedTargetProvider.getPolicyName()).thenReturn(WEIGHTED_TARGET_POLICY_NAME);
+    when(mockWeightedTargetProvider.isAvailable()).thenReturn(true);
+    lbRegistry.register(mockWeightedTargetProvider);
+
+    when(mockChildProvider.newLoadBalancer(isA(Helper.class))).thenReturn(mockChildLb);
+    when(mockChildProvider.getPolicyName()).thenReturn("round_robin");
+    lbRegistry.register(mockWeightedTargetProvider);
+
+    loadBalancer = new WrrLocalityLoadBalancer(mockHelper, lbRegistry);
+  }
+
+  @Test
+  public void acceptResolvedAddresses() {
+    // A two locality cluster with a mock child LB policy.
+    String localityOne = "localityOne";
+    String localityTwo = "localityTwo";
+    Object childPolicy = newChildConfig(mockChildProvider, null);
+
+    // The child config is delivered wrapped in the wrr_locality config and the locality weights
+    // in a ResolvedAddresses attribute.
+    WrrLocalityConfig wlConfig = new WrrLocalityConfig(childPolicy);
+    deliverAddresses(wlConfig,
+        ImmutableList.of(
+            makeAddress("addr1", localityOne, 1),
+            makeAddress("addr2", localityTwo, 2)));
+
+    // Assert that the child policy and the locality weights were correctly mapped to a
+    // WeightedTargetConfig.
+    verify(mockWeightedTargetLb).acceptResolvedAddresses(resolvedAddressesCaptor.capture());
+    Object config = resolvedAddressesCaptor.getValue().getLoadBalancingPolicyConfig();
+    assertThat(config).isInstanceOf(WeightedTargetConfig.class);
+    WeightedTargetConfig wtConfig = (WeightedTargetConfig) config;
+    assertThat(wtConfig.targets).hasSize(2);
+    assertThat(wtConfig.targets).containsEntry(localityOne,
+        new WeightedPolicySelection(1, childPolicy));
+    assertThat(wtConfig.targets).containsEntry(localityTwo,
+        new WeightedPolicySelection(2, childPolicy));
+  }
+
+  @Test
+  public void acceptResolvedAddresses_noLocalityWeights() {
+    // A two locality cluster with a mock child LB policy.
+    Object childPolicy = newChildConfig(mockChildProvider, null);
+
+    // The child config is delivered wrapped in the wrr_locality config and the locality weights
+    // in a ResolvedAddresses attribute.
+    WrrLocalityConfig wlConfig = new WrrLocalityConfig(childPolicy);
+    deliverAddresses(wlConfig, ImmutableList.of(makeAddress("addr", "test-locality", null)));
+
+    // With no locality weights, we should get a TRANSIENT_FAILURE.
+    verify(mockHelper).getAuthority();
+    verify(mockHelper).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE),
+        pickerReturns(Status.Code.UNAVAILABLE));
+  }
+
+  @Test
+  public void handleNameResolutionError_noChildLb() {
+    Status status = Status.DEADLINE_EXCEEDED.withDescription("down low");
+    loadBalancer.handleNameResolutionError(status);
+
+    verify(mockHelper).updateBalancingState(
+        eq(ConnectivityState.TRANSIENT_FAILURE),
+        pickerReturns(PickResult.withError(status)));
+  }
+
+  @Test
+  public void handleNameResolutionError_withChildLb() {
+    deliverAddresses(new WrrLocalityConfig(newChildConfig(mockChildProvider, null)),
+        ImmutableList.of(makeAddress("addr1", "test-locality", 1)));
+    Status status = Status.DEADLINE_EXCEEDED.withDescription("too slow");
+    loadBalancer.handleNameResolutionError(status);
+
+    verify(mockHelper, never()).updateBalancingState(eq(ConnectivityState.TRANSIENT_FAILURE),
+        pickerReturns(PickResult.withError(status)));
+    verify(mockWeightedTargetLb).handleNameResolutionError(status);
+  }
+
+  @Test
+  public void localityWeightAttributeNotPropagated() {
+    Object childPolicy = newChildConfig(mockChildProvider, null);
+
+    WrrLocalityConfig wlConfig = new WrrLocalityConfig(childPolicy);
+    deliverAddresses(wlConfig, ImmutableList.of(makeAddress("addr1", "test-locality", 1)));
+
+    // Assert that the child policy and the locality weights were correctly mapped to a
+    // WeightedTargetConfig.
+    verify(mockWeightedTargetLb).acceptResolvedAddresses(resolvedAddressesCaptor.capture());
+
+    //assertThat(resolvedAddressesCaptor.getValue().getAttributes()
+    //    .get(XdsAttributes.ATTR_LOCALITY_WEIGHTS)).isNull();
+  }
+
+  @Test
+  public void shutdown() {
+    deliverAddresses(new WrrLocalityConfig(newChildConfig(mockChildProvider, null)),
+        ImmutableList.of(makeAddress("addr", "test-locality", 1)));
+    loadBalancer.shutdown();
+
+    verify(mockWeightedTargetLb).shutdown();
+  }
+
+  @Test
+  public void configEquality() {
+    WrrLocalityConfig configOne = new WrrLocalityConfig(newChildConfig(mockChildProvider, null));
+    WrrLocalityConfig configTwo = new WrrLocalityConfig(newChildConfig(mockChildProvider, null));
+    WrrLocalityConfig differentConfig = new WrrLocalityConfig(
+        newChildConfig(mockChildProvider, "config"));
+
+    new EqualsTester().addEqualityGroup(configOne, configTwo).addEqualityGroup(differentConfig)
+        .testEquals();
+  }
+
+  private Object newChildConfig(LoadBalancerProvider provider, Object config) {
+    return GracefulSwitchLoadBalancer.createLoadBalancingPolicyConfig(provider, config);
+  }
+
+  private void deliverAddresses(WrrLocalityConfig config, List<EquivalentAddressGroup> addresses) {
+    loadBalancer.acceptResolvedAddresses(
+        ResolvedAddresses.newBuilder().setAddresses(addresses).setLoadBalancingPolicyConfig(config)
+            .build());
+  }
+
+  /**
+   * Create a locality-labeled address.
+   */
+  private static EquivalentAddressGroup makeAddress(final String name, String locality,
+      Integer localityWeight) {
+    class FakeSocketAddress extends SocketAddress {
+      private final String name;
+
+      private FakeSocketAddress(String name) {
+        this.name = name;
+      }
+
+      @Override
+      public int hashCode() {
+        return Objects.hash(name);
+      }
+
+      @Override
+      public boolean equals(Object o) {
+        if (this == o) {
+          return true;
+        }
+        if (!(o instanceof FakeSocketAddress)) {
+          return false;
+        }
+        FakeSocketAddress that = (FakeSocketAddress) o;
+        return Objects.equals(name, that.name);
+      }
+
+      @Override
+      public String toString() {
+        return name;
+      }
+    }
+
+    Attributes.Builder attrBuilder = Attributes.newBuilder()
+        .set(EquivalentAddressGroup.ATTR_LOCALITY_NAME, locality);
+    if (localityWeight != null) {
+      attrBuilder.set(XdsAttributes.ATTR_LOCALITY_WEIGHT, localityWeight);
+    }
+
+    EquivalentAddressGroup eag = new EquivalentAddressGroup(new FakeSocketAddress(name),
+        attrBuilder.build());
+    return AddressFilter.setPathFilter(eag, Collections.singletonList(locality));
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsClientFallbackTest.java b/xds/src/test/java/io/grpc/xds/XdsClientFallbackTest.java
new file mode 100644
index 00000000000..27ee8d22825
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsClientFallbackTest.java
@@ -0,0 +1,610 @@
+/*
+ * Copyright 2024 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.ChannelCredentials;
+import io.grpc.Grpc;
+import io.grpc.MetricRecorder;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.internal.ExponentialBackoffPolicy;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.ObjectPool;
+import io.grpc.xds.XdsClusterResource.CdsUpdate;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.XdsRouteConfigureResource.RdsUpdate;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.CommonBootstrapperTestUtils;
+import io.grpc.xds.client.LoadReportClient;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsClientImpl;
+import io.grpc.xds.client.XdsClientMetricReporter;
+import io.grpc.xds.client.XdsInitializationException;
+import io.grpc.xds.client.XdsTransportFactory;
+import java.net.InetSocketAddress;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class XdsClientFallbackTest {
+  private static final Logger log = Logger.getLogger(XdsClientFallbackTest.class.getName());
+
+  private static final String MAIN_SERVER = "main-server";
+  private static final String FALLBACK_SERVER = "fallback-server";
+  private static final String DUMMY_TARGET = "TEST_TARGET";
+  private static final String RDS_NAME = "route-config.googleapis.com";
+  private static final String FALLBACK_RDS_NAME = "fallback-" + RDS_NAME;
+  private static final String CLUSTER_NAME = "cluster0";
+  private static final String FALLBACK_CLUSTER_NAME = "fallback-" + CLUSTER_NAME;
+  private static final String EDS_NAME = "eds-service-0";
+  private static final String FALLBACK_EDS_NAME = "fallback-" + EDS_NAME;
+  private static final HttpConnectionManager MAIN_HTTP_CONNECTION_MANAGER =
+      HttpConnectionManager.forRdsName(0, RDS_NAME, ImmutableList.of(
+          new Filter.NamedFilterConfig("terminal-filter", RouterFilter.ROUTER_CONFIG)));
+  private static final HttpConnectionManager FALLBACK_HTTP_CONNECTION_MANAGER =
+      HttpConnectionManager.forRdsName(0, FALLBACK_RDS_NAME, ImmutableList.of(
+          new Filter.NamedFilterConfig("terminal-filter", RouterFilter.ROUTER_CONFIG)));
+  private ObjectPool<XdsClient> xdsClientPool;
+  private XdsClient xdsClient;
+  private boolean originalEnableXdsFallback;
+  private final FakeClock fakeClock = new FakeClock();
+  private final MetricRecorder metricRecorder = new MetricRecorder() {};
+
+  @Mock
+  private XdsClientMetricReporter xdsClientMetricReporter;
+
+  @Captor
+  private ArgumentCaptor<StatusOr<LdsUpdate>> ldsUpdateCaptor;
+  @Captor
+  private ArgumentCaptor<StatusOr<RdsUpdate>> rdsUpdateCaptor;
+
+  private final XdsClient.ResourceWatcher<XdsListenerResource.LdsUpdate> raalLdsWatcher =
+      new XdsClient.ResourceWatcher<LdsUpdate>() {
+
+        @Override
+        public void onResourceChanged(StatusOr<LdsUpdate> update) {
+          if (update.hasValue()) {
+            log.log(Level.FINE, "LDS update: " + update.getValue());
+          } else {
+            log.log(Level.FINE, "LDS resource error: " + update.getStatus().getDescription());
+          }
+        }
+
+        @Override
+        public void onAmbientError(Status error) {
+          log.log(Level.FINE, "LDS ambient error: " + error.getDescription());
+        }
+      };
+
+  @SuppressWarnings("unchecked")
+  private final XdsClient.ResourceWatcher<XdsListenerResource.LdsUpdate> ldsWatcher =
+      mock(XdsClient.ResourceWatcher.class, delegatesTo(raalLdsWatcher));
+  @Mock
+  private XdsClient.ResourceWatcher<XdsListenerResource.LdsUpdate> ldsWatcher2;
+
+  @Mock
+  private XdsClient.ResourceWatcher<XdsRouteConfigureResource.RdsUpdate> rdsWatcher;
+  @Mock
+  private XdsClient.ResourceWatcher<XdsRouteConfigureResource.RdsUpdate> rdsWatcher2;
+  @Mock
+  private XdsClient.ResourceWatcher<XdsRouteConfigureResource.RdsUpdate> rdsWatcher3;
+
+  private final XdsClient.ResourceWatcher<CdsUpdate> raalCdsWatcher =
+      new XdsClient.ResourceWatcher<CdsUpdate>() {
+
+        @Override
+        public void onResourceChanged(StatusOr<CdsUpdate> update) {
+          if (update.hasValue()) {
+            log.log(Level.FINE, "CDS update: " + update.getValue());
+          } else {
+            log.log(Level.FINE, "CDS resource error: " + update.getStatus().getDescription());
+          }
+        }
+
+        @Override
+        public void onAmbientError(Status error) {
+          // Logic from the old onError method for transient errors.
+          log.log(Level.FINE, "CDS ambient error: " + error.getDescription());
+        }
+      };
+
+  @SuppressWarnings("unchecked")
+  private final XdsClient.ResourceWatcher<CdsUpdate> cdsWatcher =
+      mock(XdsClient.ResourceWatcher.class, delegatesTo(raalCdsWatcher));
+  @Mock
+  private XdsClient.ResourceWatcher<CdsUpdate> cdsWatcher2;
+
+  @Rule(order = 0)
+  public ControlPlaneRule mainXdsServer =
+      new ControlPlaneRule().setServerHostName(MAIN_SERVER);
+
+  @Rule(order = 1)
+  public ControlPlaneRule fallbackServer =
+      new ControlPlaneRule().setServerHostName(MAIN_SERVER);
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Before
+  public void setUp() throws XdsInitializationException {
+    originalEnableXdsFallback = CommonBootstrapperTestUtils.setEnableXdsFallback(true);
+    if (mainXdsServer == null) {
+      throw new XdsInitializationException("Failed to create ControlPlaneRule for main TD server");
+    }
+    setAdsConfig(mainXdsServer, MAIN_SERVER);
+    setAdsConfig(fallbackServer, FALLBACK_SERVER);
+
+    SharedXdsClientPoolProvider clientPoolProvider = new SharedXdsClientPoolProvider();
+    xdsClientPool = clientPoolProvider.getOrCreate(
+        DUMMY_TARGET,
+        new GrpcBootstrapperImpl().bootstrap(defaultBootstrapOverride()),
+        metricRecorder);
+  }
+
+  @After
+  public void cleanUp() {
+    if (xdsClient != null) {
+      xdsClient = xdsClientPool.returnObject(xdsClient);
+    }
+    CommonBootstrapperTestUtils.setEnableXdsFallback(originalEnableXdsFallback);
+  }
+
+  private static void setAdsConfig(ControlPlaneRule controlPlane, String serverName) {
+    InetSocketAddress edsInetSocketAddress =
+        (InetSocketAddress) controlPlane.getServer().getListenSockets().get(0);
+    boolean isMainServer = serverName.equals(MAIN_SERVER);
+    String rdsName = isMainServer
+                     ? RDS_NAME
+                     : FALLBACK_RDS_NAME;
+    String clusterName = isMainServer ? CLUSTER_NAME : FALLBACK_CLUSTER_NAME;
+    String edsName = isMainServer ? EDS_NAME : FALLBACK_EDS_NAME;
+
+    controlPlane.setLdsConfig(ControlPlaneRule.buildServerListener(),
+        ControlPlaneRule.buildClientListener(MAIN_SERVER, rdsName));
+
+    controlPlane.setRdsConfig(rdsName,
+        XdsTestUtils.buildRouteConfiguration(MAIN_SERVER, rdsName, clusterName));
+    controlPlane.setCdsConfig(clusterName, ControlPlaneRule.buildCluster(clusterName, edsName));
+
+    controlPlane.setEdsConfig(edsName,
+        ControlPlaneRule.buildClusterLoadAssignment(edsInetSocketAddress.getHostName(),
+            DataPlaneRule.ENDPOINT_HOST_NAME, edsInetSocketAddress.getPort(), edsName));
+    log.log(Level.FINE,
+        String.format("Set ADS config for %s with address %s", serverName, edsInetSocketAddress));
+  }
+
+  // This is basically a control test to make sure everything is set up correctly.
+  @Test
+  public void everything_okay() {
+    mainXdsServer.restartXdsServer();
+    fallbackServer.restartXdsServer();
+    xdsClient = xdsClientPool.getObject();
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), MAIN_SERVER, ldsWatcher);
+    verify(ldsWatcher, timeout(5000)).onResourceChanged(ldsUpdateCaptor.capture());
+    assertThat(ldsUpdateCaptor.getValue().hasValue()).isTrue();
+    assertThat(ldsUpdateCaptor.getValue().getValue()).isEqualTo(
+        LdsUpdate.forApiListener(MAIN_HTTP_CONNECTION_MANAGER));
+
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_NAME, rdsWatcher);
+    verify(rdsWatcher, timeout(5000)).onResourceChanged(rdsUpdateCaptor.capture());
+    assertThat(rdsUpdateCaptor.getValue().hasValue()).isTrue();
+  }
+
+  @Test
+  public void mainServerDown_fallbackServerUp() {
+    mainXdsServer.getServer().shutdownNow();
+    fallbackServer.restartXdsServer();
+    xdsClient = xdsClientPool.getObject();
+    log.log(Level.FINE, "Fallback port = " + fallbackServer.getServer().getPort());
+
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), MAIN_SERVER, ldsWatcher);
+
+    verify(ldsWatcher, timeout(5000)).onResourceChanged(
+        StatusOr.fromValue(XdsListenerResource.LdsUpdate.forApiListener(
+            FALLBACK_HTTP_CONNECTION_MANAGER)));
+  }
+
+  @Test
+  public void useBadAuthority() {
+    xdsClient = xdsClientPool.getObject();
+    InOrder inOrder = inOrder(ldsWatcher, rdsWatcher, rdsWatcher2, rdsWatcher3);
+
+    String badPrefix = "xdstp://authority.xds.bad/envoy.config.listener.v3.Listener/";
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(),
+        badPrefix + "listener.googleapis.com", ldsWatcher);
+    inOrder.verify(ldsWatcher, timeout(5000)).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()));
+
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(),
+        badPrefix + "route-config.googleapis.bad", rdsWatcher);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(),
+        badPrefix + "route-config2.googleapis.bad", rdsWatcher2);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(),
+        badPrefix + "route-config3.googleapis.bad", rdsWatcher3);
+    inOrder.verify(rdsWatcher, timeout(5000)).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()));
+    inOrder.verify(rdsWatcher2, timeout(5000)).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()));
+    inOrder.verify(rdsWatcher3, timeout(5000)).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()));
+    verify(rdsWatcher, never()).onResourceChanged(argThat(StatusOr::hasValue));
+
+    // even after an error, a valid one will still work
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), MAIN_SERVER, ldsWatcher2);
+    verify(ldsWatcher2, timeout(5000)).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOr = ldsUpdateCaptor.getValue();
+    assertThat(statusOr.hasValue()).isTrue();
+    assertThat(statusOr.getValue()).isEqualTo(
+        XdsListenerResource.LdsUpdate.forApiListener(MAIN_HTTP_CONNECTION_MANAGER));
+  }
+
+  @Test
+  public void both_down_restart_main() {
+    mainXdsServer.getServer().shutdownNow();
+    fallbackServer.getServer().shutdownNow();
+    xdsClient = xdsClientPool.getObject();
+
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), MAIN_SERVER, ldsWatcher);
+    verify(ldsWatcher, timeout(5000).atLeastOnce())
+        .onResourceChanged(argThat(statusOr -> !statusOr.hasValue()));
+    verify(ldsWatcher, never()).onResourceChanged(argThat(StatusOr::hasValue));
+    xdsClient.watchXdsResource(
+        XdsRouteConfigureResource.getInstance(), RDS_NAME, rdsWatcher2);
+    verify(rdsWatcher2, timeout(5000).atLeastOnce())
+        .onResourceChanged(argThat(statusOr -> !statusOr.hasValue()));
+
+    mainXdsServer.restartXdsServer();
+
+    xdsClient.watchXdsResource(
+        XdsRouteConfigureResource.getInstance(), RDS_NAME, rdsWatcher);
+
+    verify(ldsWatcher, timeout(16000)).onResourceChanged(
+        argThat(statusOr -> statusOr.hasValue() && statusOr.getValue().equals(
+            XdsListenerResource.LdsUpdate.forApiListener(MAIN_HTTP_CONNECTION_MANAGER))));
+    verify(rdsWatcher, timeout(5000)).onResourceChanged(argThat(StatusOr::hasValue));
+    verify(rdsWatcher2, timeout(5000)).onResourceChanged(argThat(StatusOr::hasValue));
+  }
+
+  @Test
+  public void mainDown_fallbackUp_restart_main() {
+    mainXdsServer.getServer().shutdownNow();
+    fallbackServer.restartXdsServer();
+    xdsClient = xdsClientPool.getObject();
+    InOrder inOrder = inOrder(ldsWatcher, rdsWatcher, cdsWatcher, cdsWatcher2);
+
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), MAIN_SERVER, ldsWatcher);
+    inOrder.verify(ldsWatcher, timeout(5000)).onResourceChanged(
+        StatusOr.fromValue(XdsListenerResource.LdsUpdate.forApiListener(
+            FALLBACK_HTTP_CONNECTION_MANAGER)));
+
+    // Watch another resource, also from the fallback server.
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), FALLBACK_CLUSTER_NAME, cdsWatcher);
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<StatusOr<CdsUpdate>> cdsUpdateCaptor1 = ArgumentCaptor.forClass(StatusOr.class);
+    inOrder.verify(cdsWatcher, timeout(5000)).onResourceChanged(cdsUpdateCaptor1.capture());
+    assertThat(cdsUpdateCaptor1.getValue().getStatus().isOk()).isTrue();
+
+    assertThat(fallbackServer.getService().getSubscriberCounts()
+        .get("type.googleapis.com/envoy.config.listener.v3.Listener")).isEqualTo(1);
+    verifyNoSubscribers(mainXdsServer);
+
+    mainXdsServer.restartXdsServer();
+
+    // The existing ldsWatcher should receive a new update from the main server.
+    // Note: This is not an inOrder verification because the timing of the switchover
+    // can vary. We just need to verify it happens.
+    verify(ldsWatcher, timeout(5000)).onResourceChanged(
+        StatusOr.fromValue(XdsListenerResource.LdsUpdate.forApiListener(
+            MAIN_HTTP_CONNECTION_MANAGER)));
+
+    // Watch a new resource; should now come from the main server.
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_NAME, rdsWatcher);
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<StatusOr<RdsUpdate>> rdsUpdateCaptor = ArgumentCaptor.forClass(StatusOr.class);
+    inOrder.verify(rdsWatcher, timeout(5000)).onResourceChanged(rdsUpdateCaptor.capture());
+    assertThat(rdsUpdateCaptor.getValue().getStatus().isOk()).isTrue();
+    verifyNoSubscribers(fallbackServer);
+
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), CLUSTER_NAME, cdsWatcher2);
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<StatusOr<CdsUpdate>> cdsUpdateCaptor2 = ArgumentCaptor.forClass(StatusOr.class);
+    inOrder.verify(cdsWatcher2, timeout(5000)).onResourceChanged(cdsUpdateCaptor2.capture());
+    assertThat(cdsUpdateCaptor2.getValue().getStatus().isOk()).isTrue();
+
+    verifyNoSubscribers(fallbackServer);
+    assertThat(mainXdsServer.getService().getSubscriberCounts()
+        .get("type.googleapis.com/envoy.config.listener.v3.Listener")).isEqualTo(1);
+  }
+
+  private static void verifyNoSubscribers(ControlPlaneRule rule) {
+    for (Map.Entry<String, Integer> me : rule.getService().getSubscriberCounts().entrySet()) {
+      String type = me.getKey();
+      Integer count = me.getValue();
+      assertWithMessage("Type with non-zero subscribers is: %s", type)
+          .that(count).isEqualTo(0);
+    }
+  }
+
+  // This test takes a long time because of the 16 sec timeout for non-existent resource
+  @Test
+  public void connect_then_mainServerDown_fallbackServerUp() throws Exception {
+    mainXdsServer.restartXdsServer();
+    fallbackServer.restartXdsServer();
+    ExecutorService executor = Executors.newFixedThreadPool(1);
+    XdsTransportFactory xdsTransportFactory = new XdsTransportFactory() {
+      @Override
+      public XdsTransport create(Bootstrapper.ServerInfo serverInfo) {
+        ChannelCredentials channelCredentials =
+            (ChannelCredentials) serverInfo.implSpecificConfig();
+        return new GrpcXdsTransportFactory.GrpcXdsTransport(
+            Grpc.newChannelBuilder(serverInfo.target(), channelCredentials)
+              .executor(executor)
+              .build());
+      }
+    };
+    XdsClientImpl xdsClient = CommonBootstrapperTestUtils.createXdsClient(
+        new GrpcBootstrapperImpl().bootstrap(defaultBootstrapOverride()),
+        xdsTransportFactory, fakeClock, new ExponentialBackoffPolicy.Provider(),
+        MessagePrinter.INSTANCE, xdsClientMetricReporter);
+
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), MAIN_SERVER, ldsWatcher);
+
+    // Initial resource fetch from the main server
+    verify(ldsWatcher, timeout(5000)).onResourceChanged(
+        StatusOr.fromValue(LdsUpdate.forApiListener(MAIN_HTTP_CONNECTION_MANAGER)));
+
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_NAME, rdsWatcher);
+    verify(rdsWatcher, timeout(5000)).onResourceChanged(argThat(StatusOr::hasValue));
+
+    mainXdsServer.getServer().shutdownNow();
+    // Sleep for the ADS stream disconnect to be processed and for the retry to fail. Between those
+    // two sleeps we need the fakeClock to progress by 1 second to restart the ADS stream.
+    for (int i = 0; i < 5; i++) {
+      // FakeClock is not thread-safe, and the retry scheduling is concurrent to this test thread
+      executor.submit(() -> fakeClock.forwardTime(1000, TimeUnit.MILLISECONDS)).get();
+      TimeUnit.SECONDS.sleep(1);
+    }
+
+    // Shouldn't do fallback since all watchers are loaded
+    verify(ldsWatcher, never()).onResourceChanged(StatusOr.fromValue(
+        XdsListenerResource.LdsUpdate.forApiListener(FALLBACK_HTTP_CONNECTION_MANAGER)));
+
+    // Should just get from cache
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), MAIN_SERVER, ldsWatcher2);
+    xdsClient.watchXdsResource(XdsRouteConfigureResource.getInstance(), RDS_NAME, rdsWatcher2);
+    verify(ldsWatcher2, timeout(5000)).onResourceChanged(StatusOr.fromValue(
+        XdsListenerResource.LdsUpdate.forApiListener(MAIN_HTTP_CONNECTION_MANAGER)));
+    verify(ldsWatcher, never()).onResourceChanged(StatusOr.fromValue(
+        XdsListenerResource.LdsUpdate.forApiListener(FALLBACK_HTTP_CONNECTION_MANAGER)));
+    // Make sure that rdsWatcher wasn't called again
+    verify(rdsWatcher, times(1)).onResourceChanged(any());
+    verify(rdsWatcher2, timeout(5000)).onResourceChanged(argThat(StatusOr::hasValue));
+
+    // Asking for something not in cache should force a fallback
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), FALLBACK_CLUSTER_NAME, cdsWatcher);
+    verify(ldsWatcher, timeout(5000)).onResourceChanged(StatusOr.fromValue(
+        XdsListenerResource.LdsUpdate.forApiListener(FALLBACK_HTTP_CONNECTION_MANAGER)));
+    verify(ldsWatcher2, timeout(5000)).onResourceChanged(StatusOr.fromValue(
+        XdsListenerResource.LdsUpdate.forApiListener(FALLBACK_HTTP_CONNECTION_MANAGER)));
+    verify(cdsWatcher, timeout(5000)).onResourceChanged(argThat(StatusOr::hasValue));
+
+    xdsClient.watchXdsResource(
+        XdsRouteConfigureResource.getInstance(), FALLBACK_RDS_NAME, rdsWatcher3);
+    verify(rdsWatcher3, timeout(5000)).onResourceChanged(argThat(StatusOr::hasValue));
+
+    // Test that resource defined in main but not fallback is handled correctly
+    xdsClient.watchXdsResource(
+        XdsClusterResource.getInstance(), CLUSTER_NAME, cdsWatcher2);
+    verify(cdsWatcher2, never()).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Status.Code.NOT_FOUND));
+    fakeClock.forwardTime(15000, TimeUnit.MILLISECONDS); // Does not exist timer
+    verify(cdsWatcher2, timeout(5000)).onResourceChanged(
+        argThat(statusOr -> !statusOr.hasValue()
+            && statusOr.getStatus().getCode() == Status.Code.NOT_FOUND
+            && statusOr.getStatus().getDescription().contains(CLUSTER_NAME)));
+    xdsClient.shutdown();
+    executor.shutdown();
+  }
+
+  @Test
+  public void connect_then_mainServerRestart_fallbackServerdown() {
+    mainXdsServer.restartXdsServer();
+    xdsClient = xdsClientPool.getObject();
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), MAIN_SERVER, ldsWatcher);
+
+    verify(ldsWatcher, timeout(5000)).onResourceChanged(
+        argThat(statusOr -> statusOr.hasValue() && statusOr.getValue().equals(
+            LdsUpdate.forApiListener(MAIN_HTTP_CONNECTION_MANAGER))));
+    mainXdsServer.getServer().shutdownNow();
+    fallbackServer.getServer().shutdownNow();
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), CLUSTER_NAME, cdsWatcher);
+    mainXdsServer.restartXdsServer();
+
+    verify(cdsWatcher, timeout(5000)).onResourceChanged(
+        argThat(statusOr -> statusOr.hasValue()));
+    verify(ldsWatcher, timeout(5000).atLeastOnce()).onResourceChanged(
+        argThat(statusOr -> statusOr.hasValue() && statusOr.getValue().equals(
+            LdsUpdate.forApiListener(MAIN_HTTP_CONNECTION_MANAGER))));
+  }
+
+  @Test
+  public void fallbackFromBadUrlToGoodOne() {
+    // Setup xdsClient to fail on stream creation
+    String garbageUri = "some. garbage";
+
+    String validUri = "localhost:" + mainXdsServer.getServer().getPort();
+    XdsClientImpl client =
+        CommonBootstrapperTestUtils.createXdsClient(
+            Arrays.asList(garbageUri, validUri),
+            new GrpcXdsTransportFactory(null),
+            fakeClock,
+            new ExponentialBackoffPolicy.Provider(),
+            MessagePrinter.INSTANCE,
+            xdsClientMetricReporter);
+
+    client.watchXdsResource(XdsListenerResource.getInstance(), MAIN_SERVER, ldsWatcher);
+    fakeClock.forwardTime(20, TimeUnit.SECONDS);
+    verify(ldsWatcher, timeout(5000)).onResourceChanged(
+        StatusOr.fromValue(XdsListenerResource.LdsUpdate.forApiListener(
+            MAIN_HTTP_CONNECTION_MANAGER)));
+    verify(ldsWatcher, never()).onAmbientError(any(Status.class));
+
+    client.shutdown();
+  }
+
+  @Test
+  public void testGoodUrlFollowedByBadUrl() {
+    // xdsClient should succeed in stream creation as it doesn't need to use the bad url
+    String garbageUri = "some. garbage";
+    String validUri = "localhost:" + mainXdsServer.getServer().getPort();
+
+    XdsClientImpl client =
+        CommonBootstrapperTestUtils.createXdsClient(
+            Arrays.asList(validUri, garbageUri),
+            new GrpcXdsTransportFactory(null),
+            fakeClock,
+            new ExponentialBackoffPolicy.Provider(),
+            MessagePrinter.INSTANCE,
+            xdsClientMetricReporter);
+
+    client.watchXdsResource(XdsListenerResource.getInstance(), MAIN_SERVER, ldsWatcher);
+    verify(ldsWatcher, timeout(5000)).onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOr = ldsUpdateCaptor.getValue();
+    assertThat(statusOr.hasValue()).isTrue();
+    assertThat(statusOr.getValue()).isEqualTo(
+        XdsListenerResource.LdsUpdate.forApiListener(MAIN_HTTP_CONNECTION_MANAGER));
+    verify(ldsWatcher, never()).onAmbientError(any());
+    verify(ldsWatcher, times(1)).onResourceChanged(any());
+
+    client.shutdown();
+  }
+
+  @Test
+  public void testTwoBadUrl()  {
+    // Setup xdsClient to fail on stream creation
+    String garbageUri1 = "some. garbage";
+    String garbageUri2 = "other garbage";
+
+    XdsClientImpl client =
+        CommonBootstrapperTestUtils.createXdsClient(
+            Arrays.asList(garbageUri1, garbageUri2),
+            new GrpcXdsTransportFactory(null),
+            fakeClock,
+            new ExponentialBackoffPolicy.Provider(),
+            MessagePrinter.INSTANCE,
+            xdsClientMetricReporter);
+
+    client.watchXdsResource(XdsListenerResource.getInstance(), MAIN_SERVER, ldsWatcher);
+    fakeClock.forwardTime(20, TimeUnit.SECONDS);
+    verify(ldsWatcher, Mockito.timeout(5000).atLeastOnce())
+        .onResourceChanged(ldsUpdateCaptor.capture());
+    StatusOr<LdsUpdate> statusOr = ldsUpdateCaptor.getValue();
+    assertThat(statusOr.hasValue()).isFalse();
+    assertThat(statusOr.getStatus().getDescription()).contains(garbageUri2);
+    verify(ldsWatcher, never()).onResourceChanged(argThat(StatusOr::hasValue));
+    client.shutdown();
+  }
+
+  private Bootstrapper.ServerInfo getLrsServerInfo(String target) {
+    for (Map.Entry<Bootstrapper.ServerInfo, LoadReportClient> entry
+        : xdsClient.getServerLrsClientMap().entrySet()) {
+      if (entry.getKey().target().equals(target)) {
+        return entry.getKey();
+      }
+    }
+    return null;
+  }
+
+  @Test
+  public void used_then_mainServerRestart_fallbackServerUp() {
+    xdsClient = xdsClientPool.getObject();
+
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), MAIN_SERVER, ldsWatcher);
+
+    verify(ldsWatcher, timeout(5000)).onResourceChanged(
+        StatusOr.fromValue(LdsUpdate.forApiListener(MAIN_HTTP_CONNECTION_MANAGER)));
+
+    mainXdsServer.restartXdsServer();
+
+    assertThat(getLrsServerInfo("localhost:" + fallbackServer.getServer().getPort())).isNull();
+    assertThat(getLrsServerInfo("localhost:" + mainXdsServer.getServer().getPort())).isNotNull();
+
+    xdsClient.watchXdsResource(XdsClusterResource.getInstance(), CLUSTER_NAME, cdsWatcher);
+
+    verify(cdsWatcher, timeout(5000)).onResourceChanged(any());
+    assertThat(getLrsServerInfo("localhost:" + fallbackServer.getServer().getPort())).isNull();
+  }
+
+  private Map<String, ?> defaultBootstrapOverride() {
+    return ImmutableMap.of(
+        "node", ImmutableMap.of(
+            "id", UUID.randomUUID().toString(),
+            "cluster", CLUSTER_NAME),
+         "xds_servers", ImmutableList.of(
+            ImmutableMap.of(
+                "server_uri", "localhost:" + mainXdsServer.getServer().getPort(),
+                "channel_creds", Collections.singletonList(
+                    ImmutableMap.of("type", "insecure")
+                ),
+                "server_features", Collections.singletonList("xds_v3")
+            ),
+            ImmutableMap.of(
+                "server_uri", "localhost:" + fallbackServer.getServer().getPort(),
+                "channel_creds", Collections.singletonList(
+                    ImmutableMap.of("type", "insecure")
+                ),
+                "server_features", Collections.singletonList("xds_v3")
+            )
+        ),
+        "fallback-policy", "fallback"
+      );
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsClientFederationTest.java b/xds/src/test/java/io/grpc/xds/XdsClientFederationTest.java
new file mode 100644
index 00000000000..da310871c25
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsClientFederationTest.java
@@ -0,0 +1,269 @@
+/*
+ * Copyright 2023 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.MetricRecorder;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.internal.ObjectPool;
+import io.grpc.xds.Filter.NamedFilterConfig;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.LoadReportClient;
+import io.grpc.xds.client.LoadStatsManager2;
+import io.grpc.xds.client.Locality;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsClient.ResourceWatcher;
+import io.grpc.xds.client.XdsInitializationException;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.UUID;
+import java.util.concurrent.ExecutionException;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Tests for xDS control plane federation scenarios.
+ */
+@RunWith(JUnit4.class)
+public class XdsClientFederationTest {
+
+  @Mock
+  private ResourceWatcher<LdsUpdate> mockDirectPathWatcher;
+
+  @Mock
+  private ResourceWatcher<LdsUpdate> mockWatcher;
+
+  @Rule
+  public ControlPlaneRule trafficdirector = new ControlPlaneRule().setServerHostName("test-server");
+
+  @Rule
+  public ControlPlaneRule directpathPa = new ControlPlaneRule().setServerHostName(
+      "xdstp://server-one/envoy.config.listener.v3.Listener/test-server");
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private ObjectPool<XdsClient> xdsClientPool;
+  private XdsClient xdsClient;
+  private static final String DUMMY_TARGET = "dummy";
+  private final MetricRecorder metricRecorder = new MetricRecorder() {};
+
+  @Before
+  public void setUp() throws XdsInitializationException {
+    SharedXdsClientPoolProvider clientPoolProvider = new SharedXdsClientPoolProvider();
+    xdsClientPool = clientPoolProvider.getOrCreate(
+        DUMMY_TARGET,
+        new GrpcBootstrapperImpl().bootstrap(defaultBootstrapOverride()),
+        metricRecorder);
+    xdsClient = xdsClientPool.getObject();
+  }
+
+  @After
+  public void cleanUp() {
+    xdsClientPool.returnObject(xdsClient);
+  }
+
+  /**
+   * Assures that resource deletions happening in one control plane do not trigger deletion events
+   * in watchers of resources on other control planes.
+   */
+  @Test
+  public void isolatedResourceDeletions() {
+    trafficdirector.setLdsConfig(ControlPlaneRule.buildServerListener(),
+        ControlPlaneRule.buildClientListener("test-server"));
+    directpathPa.setLdsConfig(ControlPlaneRule.buildServerListener(),
+        ControlPlaneRule.buildClientListener(
+            "xdstp://server-one/envoy.config.listener.v3.Listener/test-server"));
+
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), "test-server", mockWatcher);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(),
+        "xdstp://server-one/envoy.config.listener.v3.Listener/test-server", mockDirectPathWatcher);
+
+    @SuppressWarnings("unchecked")
+    ArgumentCaptor<StatusOr<LdsUpdate>> captor = ArgumentCaptor.forClass(StatusOr.class);
+    LdsUpdate expectedUpdate = LdsUpdate.forApiListener(
+        HttpConnectionManager.forRdsName(0, "route-config.googleapis.com", ImmutableList.of(
+            new NamedFilterConfig("terminal-filter", RouterFilter.ROUTER_CONFIG))));
+
+    verify(mockWatcher, timeout(10000)).onResourceChanged(captor.capture());
+    assertThat(captor.getValue().hasValue()).isTrue();
+    assertThat(captor.getValue().getValue()).isEqualTo(expectedUpdate);
+
+    verify(mockDirectPathWatcher, timeout(10000)).onResourceChanged(captor.capture());
+    assertThat(captor.getValue().hasValue()).isTrue();
+    assertThat(captor.getValue().getValue()).isEqualTo(expectedUpdate);
+
+    // By setting the LDS config with a new server name we effectively make the old server to go
+    // away as it is not in the configuration anymore. This change in one control plane (here the
+    // "normal TrafficDirector" one) should not trigger an onResourceDoesNotExist() call on a
+    // watcher of another control plane (here the DirectPath one).
+    trafficdirector.setLdsConfig(ControlPlaneRule.buildServerListener(),
+        ControlPlaneRule.buildClientListener("new-server"));
+    verify(mockWatcher, timeout(20000)).onResourceChanged(argThat(statusOr -> {
+      return !statusOr.hasValue()
+          && statusOr.getStatus().getCode() == Status.Code.NOT_FOUND
+          && statusOr.getStatus().getDescription().contains("test-server");
+    }));
+    verify(mockDirectPathWatcher, times(1)).onResourceChanged(any());
+    verify(mockDirectPathWatcher, never()).onAmbientError(any());
+  }
+
+  /**
+   * Assures that when an {@link XdsClient} is asked to add cluster locality stats it appropriately
+   * starts {@link LoadReportClient}s to do that.
+   */
+  @Test
+  public void lrsClientsStartedForLocalityStats() throws InterruptedException, ExecutionException {
+    trafficdirector.setLdsConfig(ControlPlaneRule.buildServerListener(),
+        ControlPlaneRule.buildClientListener("test-server"));
+    directpathPa.setLdsConfig(ControlPlaneRule.buildServerListener(),
+        ControlPlaneRule.buildClientListener(
+            "xdstp://server-one/envoy.config.listener.v3.Listener/test-server"));
+
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), "test-server", mockWatcher);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(),
+        "xdstp://server-one/envoy.config.listener.v3.Listener/test-server", mockDirectPathWatcher);
+
+    // With two control planes and a watcher for each, there should be two LRS clients.
+    assertThat(xdsClient.getServerLrsClientMap().size()).isEqualTo(2);
+
+    // When the XdsClient is asked to report locality stats for a control plane server, the
+    // corresponding LRS client should be started
+    for (Entry<ServerInfo, LoadReportClient> entry : xdsClient.getServerLrsClientMap().entrySet()) {
+      xdsClient.addClusterLocalityStats(entry.getKey(), "clusterName", "edsServiceName",
+          Locality.create("", "", ""));
+      waitForSyncContext(xdsClient);
+      assertThat(entry.getValue().lrsStreamIsNull()).isFalse();
+    }
+  }
+
+  /**
+   * Assures that when an {@link XdsClient} is asked to add cluster locality stats it appropriately
+   * starts {@link LoadReportClient}s to do that.
+   */
+  @Test
+  public void lrsClientsStartedForDropStats() throws InterruptedException, ExecutionException {
+    trafficdirector.setLdsConfig(ControlPlaneRule.buildServerListener(),
+        ControlPlaneRule.buildClientListener("test-server"));
+    directpathPa.setLdsConfig(ControlPlaneRule.buildServerListener(),
+        ControlPlaneRule.buildClientListener(
+            "xdstp://server-one/envoy.config.listener.v3.Listener/test-server"));
+
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), "test-server", mockWatcher);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(),
+        "xdstp://server-one/envoy.config.listener.v3.Listener/test-server", mockDirectPathWatcher);
+
+    // With two control planes and a watcher for each, there should be two LRS clients.
+    assertThat(xdsClient.getServerLrsClientMap().size()).isEqualTo(2);
+
+    // When the XdsClient is asked to report drop stats for a control plane server, the
+    // corresponding LRS client should be started
+    for (Entry<ServerInfo, LoadReportClient> entry : xdsClient.getServerLrsClientMap().entrySet()) {
+      xdsClient.addClusterDropStats(entry.getKey(), "clusterName", "edsServiceName");
+      waitForSyncContext(xdsClient);
+      assertThat(entry.getValue().lrsStreamIsNull()).isFalse();
+    }
+  }
+
+  /**
+   * Assures that {@link LoadReportClient}s have distinct {@link LoadStatsManager2}s so that they
+   * only report on the traffic for their own control plane.
+   */
+  @Test
+  public void lrsClientsHaveDistinctLoadStatsManagers() {
+    trafficdirector.setLdsConfig(ControlPlaneRule.buildServerListener(),
+        ControlPlaneRule.buildClientListener("test-server"));
+    directpathPa.setLdsConfig(ControlPlaneRule.buildServerListener(),
+        ControlPlaneRule.buildClientListener(
+            "xdstp://server-one/envoy.config.listener.v3.Listener/test-server"));
+
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(), "test-server", mockWatcher);
+    xdsClient.watchXdsResource(XdsListenerResource.getInstance(),
+        "xdstp://server-one/envoy.config.listener.v3.Listener/test-server", mockDirectPathWatcher);
+
+    // With two control planes and a watcher for each, there should be two LRS clients.
+    assertThat(xdsClient.getServerLrsClientMap().size()).isEqualTo(2);
+
+    // Collect the LoadStatManagers and make sure they are distinct for each control plane.
+    HashSet<LoadStatsManager2> loadStatManagers = new HashSet<>();
+    for (Entry<ServerInfo, LoadReportClient> entry : xdsClient.getServerLrsClientMap().entrySet()) {
+      xdsClient.addClusterDropStats(entry.getKey(), "clusterName", "edsServiceName");
+      loadStatManagers.add(entry.getValue().loadStatsManager);
+    }
+    assertThat(loadStatManagers).containsNoDuplicates();
+  }
+
+  // Waits for all SynchronizationContext tasks to finish, assuming no new ones get added.
+  private static void waitForSyncContext(XdsClient xdsClient)
+      throws InterruptedException, ExecutionException {
+    // We use this method just to have a task added to the sync context queue and wait for it to
+    // finish.
+    xdsClient.getSubscribedResourcesMetadataSnapshot().get();
+  }
+
+  private Map<String, ?> defaultBootstrapOverride() {
+    return ImmutableMap.of(
+        "node", ImmutableMap.of(
+            "id", UUID.randomUUID().toString(),
+            "cluster", "cluster0"),
+        "xds_servers", ImmutableList.of(
+            ImmutableMap.of(
+                "server_uri", "localhost:" + trafficdirector.getServer().getPort(),
+                "channel_creds", Collections.singletonList(
+                    ImmutableMap.of("type", "insecure")
+                ),
+                "server_features", Collections.singletonList("xds_v3")
+            )
+        ),
+        "authorities", ImmutableMap.of(
+            "", ImmutableMap.of(),
+            "server-one", ImmutableMap.of(
+                "xds_servers", ImmutableList.of(
+                    ImmutableMap.of(
+                        "server_uri", "localhost:" + directpathPa.getServer().getPort(),
+                        "channel_creds", Collections.singletonList(
+                            ImmutableMap.of("type", "insecure")
+                        ),
+                        "server_features", Collections.singletonList("xds_v3")
+                    )
+                )
+            ),
+            "server-two", ImmutableMap.of()
+        )
+    );
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsClientMetricReporterImplTest.java b/xds/src/test/java/io/grpc/xds/XdsClientMetricReporterImplTest.java
new file mode 100644
index 00000000000..509a0025b7b
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsClientMetricReporterImplTest.java
@@ -0,0 +1,412 @@
+/*
+ * Copyright 2024 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import com.google.protobuf.Any;
+import io.envoyproxy.envoy.config.listener.v3.Listener;
+import io.grpc.MetricInstrument;
+import io.grpc.MetricRecorder;
+import io.grpc.MetricRecorder.BatchCallback;
+import io.grpc.MetricRecorder.BatchRecorder;
+import io.grpc.MetricSink;
+import io.grpc.xds.XdsClientMetricReporterImpl.MetricReporterCallback;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsClient.ResourceMetadata;
+import io.grpc.xds.client.XdsClient.ServerConnectionCallback;
+import io.grpc.xds.client.XdsResourceType;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Unit tests for {@link XdsClientMetricReporterImpl}.
+ */
+@RunWith(JUnit4.class)
+public class XdsClientMetricReporterImplTest {
+
+  private static final String target = "test-target";
+  private static final String authority = "test-authority";
+  private static final String server = "trafficdirector.googleapis.com";
+  private static final String resourceTypeUrl =
+      "resourceTypeUrl.googleapis.com/envoy.config.cluster.v3.Cluster";
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock
+  private XdsClient mockXdsClient;
+  @Captor
+  private ArgumentCaptor<BatchCallback> gaugeBatchCallbackCaptor;
+  private MetricRecorder mockMetricRecorder = mock(MetricRecorder.class,
+      delegatesTo(new MetricRecorderImpl()));
+  private BatchRecorder mockBatchRecorder = mock(BatchRecorder.class,
+      delegatesTo(new BatchRecorderImpl()));
+
+  private XdsClientMetricReporterImpl reporter;
+
+  @Before
+  public void setUp() {
+    reporter = new XdsClientMetricReporterImpl(mockMetricRecorder, target);
+  }
+
+  @Test
+  public void reportResourceUpdates() {
+    reporter.reportResourceUpdates(10, 5, server, resourceTypeUrl);
+    verify(mockMetricRecorder).addLongCounter(
+        eqMetricInstrumentName("grpc.xds_client.resource_updates_valid"), eq((long) 10),
+        eq(Lists.newArrayList(target, server, resourceTypeUrl)),
+        eq(Lists.newArrayList()));
+    verify(mockMetricRecorder).addLongCounter(
+        eqMetricInstrumentName("grpc.xds_client.resource_updates_invalid"),
+        eq((long) 5),
+        eq(Lists.newArrayList(target, server, resourceTypeUrl)),
+        eq(Lists.newArrayList()));
+  }
+
+  @Test
+  public void reportServerFailure() {
+    reporter.reportServerFailure(1, server);
+    verify(mockMetricRecorder).addLongCounter(
+        eqMetricInstrumentName("grpc.xds_client.server_failure"), eq((long) 1),
+        eq(Lists.newArrayList(target, server)),
+        eq(Lists.newArrayList()));
+  }
+
+  @Test
+  public void setXdsClient_reportMetrics() throws Exception {
+    SettableFuture<Void> future = SettableFuture.create();
+    future.set(null);
+    when(mockXdsClient.getSubscribedResourcesMetadataSnapshot()).thenReturn(Futures.immediateFuture(
+        ImmutableMap.of()));
+    when(mockXdsClient.reportServerConnections(any(ServerConnectionCallback.class)))
+        .thenReturn(future);
+    reporter.setXdsClient(mockXdsClient);
+    verify(mockMetricRecorder).registerBatchCallback(gaugeBatchCallbackCaptor.capture(),
+        eqMetricInstrumentName("grpc.xds_client.connected"),
+        eqMetricInstrumentName("grpc.xds_client.resources"));
+    gaugeBatchCallbackCaptor.getValue().accept(mockBatchRecorder);
+    verify(mockXdsClient).reportServerConnections(any(ServerConnectionCallback.class));
+  }
+
+  @Test
+  public void setXdsClient_reportCallbackMetrics_resourceCountsFails() {
+    TestlogHandler testLogHandler = new TestlogHandler();
+    Logger logger = Logger.getLogger(XdsClientMetricReporterImpl.class.getName());
+    logger.addHandler(testLogHandler);
+
+    // For reporting resource counts connections, return a normally completed future
+    SettableFuture<Void> future = SettableFuture.create();
+    future.set(null);
+    when(mockXdsClient.getSubscribedResourcesMetadataSnapshot()).thenReturn(Futures.immediateFuture(
+        ImmutableMap.of()));
+
+    // Create a future that will throw an exception
+    SettableFuture<Void> serverConnectionsFeature = SettableFuture.create();
+    serverConnectionsFeature.setException(new Exception("test"));
+    when(mockXdsClient.reportServerConnections(any())).thenReturn(serverConnectionsFeature);
+
+    reporter.setXdsClient(mockXdsClient);
+    verify(mockMetricRecorder)
+        .registerBatchCallback(gaugeBatchCallbackCaptor.capture(), any(), any());
+    gaugeBatchCallbackCaptor.getValue().accept(mockBatchRecorder);
+    // Verify that the xdsClient methods were called
+    // verify(mockXdsClient).reportResourceCounts(any());
+    verify(mockXdsClient).reportServerConnections(any());
+
+    assertThat(testLogHandler.getLogs().size()).isEqualTo(1);
+    assertThat(testLogHandler.getLogs().get(0).getLevel()).isEqualTo(Level.WARNING);
+    assertThat(testLogHandler.getLogs().get(0).getMessage()).isEqualTo(
+        "Failed to report gauge metrics");
+    logger.removeHandler(testLogHandler);
+  }
+
+  @Test
+  public void metricGauges() {
+    SettableFuture<Void> future = SettableFuture.create();
+    future.set(null);
+    when(mockXdsClient.getSubscribedResourcesMetadataSnapshot())
+        .thenReturn(Futures.immediateFuture(ImmutableMap.of()));
+    when(mockXdsClient.reportServerConnections(any(ServerConnectionCallback.class)))
+        .thenReturn(future);
+    reporter.setXdsClient(mockXdsClient);
+    verify(mockMetricRecorder).registerBatchCallback(gaugeBatchCallbackCaptor.capture(),
+        eqMetricInstrumentName("grpc.xds_client.connected"),
+        eqMetricInstrumentName("grpc.xds_client.resources"));
+    BatchCallback gaugeBatchCallback = gaugeBatchCallbackCaptor.getValue();
+    InOrder inOrder = inOrder(mockBatchRecorder);
+    // Trigger the internal call to reportCallbackMetrics()
+    gaugeBatchCallback.accept(mockBatchRecorder);
+
+    ArgumentCaptor<ServerConnectionCallback> serverConnectionCallbackCaptor =
+        ArgumentCaptor.forClass(ServerConnectionCallback.class);
+    // verify(mockXdsClient).reportResourceCounts(resourceCallbackCaptor.capture());
+    verify(mockXdsClient).reportServerConnections(serverConnectionCallbackCaptor.capture());
+
+    // Get the captured callback
+    MetricReporterCallback callback = (MetricReporterCallback)
+        serverConnectionCallbackCaptor.getValue();
+
+    // Verify that reportResourceCounts and reportServerConnections were called
+    // with the captured callback
+    callback.reportResourceCountGauge(10, "MrPotatoHead",
+        "acked", resourceTypeUrl);
+    inOrder.verify(mockBatchRecorder)
+        .recordLongGauge(eqMetricInstrumentName("grpc.xds_client.resources"), eq(10L), any(),
+            any());
+    callback.reportServerConnectionGauge(true, "xdsServer");
+    inOrder.verify(mockBatchRecorder)
+        .recordLongGauge(eqMetricInstrumentName("grpc.xds_client.connected"),
+            eq(1L), any(), any());
+
+    inOrder.verifyNoMoreInteractions();
+  }
+
+  @Test
+  public void metricReporterCallback() {
+    MetricReporterCallback callback =
+        new MetricReporterCallback(mockBatchRecorder, target);
+
+    callback.reportServerConnectionGauge(true, server);
+    verify(mockBatchRecorder, times(1)).recordLongGauge(
+        eqMetricInstrumentName("grpc.xds_client.connected"), eq(1L),
+        eq(Lists.newArrayList(target, server)),
+        eq(Lists.newArrayList()));
+
+    String cacheState = "requested";
+    callback.reportResourceCountGauge(10, authority, cacheState, resourceTypeUrl);
+    verify(mockBatchRecorder, times(1)).recordLongGauge(
+        eqMetricInstrumentName("grpc.xds_client.resources"), eq(10L),
+        eq(Arrays.asList(target, authority, cacheState, resourceTypeUrl)),
+        eq(Collections.emptyList()));
+  }
+
+  @Test
+  public void reportCallbackMetrics_computeAndReportResourceCounts() {
+    Map<XdsResourceType<?>, Map<String, ResourceMetadata>> metadataByType = new HashMap<>();
+    XdsResourceType<?> listenerResource = XdsListenerResource.getInstance();
+    XdsResourceType<?> routeConfigResource = XdsRouteConfigureResource.getInstance();
+    XdsResourceType<?> clusterResource = XdsClusterResource.getInstance();
+
+    Any rawListener = Any.pack(Listener.newBuilder().setName("listener.googleapis.com").build());
+    long nanosLastUpdate = 1577923199_606042047L;
+
+    Map<String, ResourceMetadata> ldsResourceMetadataMap = new HashMap<>();
+    ldsResourceMetadataMap.put("xdstp://authority1",
+        ResourceMetadata.newResourceMetadataRequested());
+    ResourceMetadata ackedLdsResource =
+        ResourceMetadata.newResourceMetadataAcked(rawListener, "42", nanosLastUpdate);
+    ldsResourceMetadataMap.put("resource2", ackedLdsResource);
+    ldsResourceMetadataMap.put("resource3",
+        ResourceMetadata.newResourceMetadataAcked(rawListener, "43", nanosLastUpdate));
+    ldsResourceMetadataMap.put("xdstp:/no_authority",
+        ResourceMetadata.newResourceMetadataNacked(ackedLdsResource, "44",
+            nanosLastUpdate, "nacked after previous ack", true));
+
+    Map<String, ResourceMetadata> rdsResourceMetadataMap = new HashMap<>();
+    ResourceMetadata requestedRdsResourceMetadata = ResourceMetadata.newResourceMetadataRequested();
+    rdsResourceMetadataMap.put("xdstp://authority5",
+        ResourceMetadata.newResourceMetadataNacked(requestedRdsResourceMetadata, "24",
+            nanosLastUpdate, "nacked after request", false));
+    rdsResourceMetadataMap.put("xdstp://authority6",
+        ResourceMetadata.newResourceMetadataDoesNotExist());
+
+    Map<String, ResourceMetadata> cdsResourceMetadataMap = new HashMap<>();
+    cdsResourceMetadataMap.put("xdstp://authority7", ResourceMetadata.newResourceMetadataUnknown());
+
+    metadataByType.put(listenerResource, ldsResourceMetadataMap);
+    metadataByType.put(routeConfigResource, rdsResourceMetadataMap);
+    metadataByType.put(clusterResource, cdsResourceMetadataMap);
+
+    SettableFuture<Void> reportServerConnectionsCompleted = SettableFuture.create();
+    reportServerConnectionsCompleted.set(null);
+    when(mockXdsClient.reportServerConnections(any(MetricReporterCallback.class)))
+        .thenReturn(reportServerConnectionsCompleted);
+
+    ListenableFuture<Map<XdsResourceType<?>, Map<String, ResourceMetadata>>>
+        getResourceMetadataCompleted = Futures.immediateFuture(metadataByType);
+    when(mockXdsClient.getSubscribedResourcesMetadataSnapshot())
+        .thenReturn(getResourceMetadataCompleted);
+
+    reporter.reportCallbackMetrics(mockBatchRecorder, mockXdsClient);
+
+    // LDS resource requested
+    verify(mockBatchRecorder).recordLongGauge(eqMetricInstrumentName("grpc.xds_client.resources"),
+        eq(1L),
+        eq(Arrays.asList(target, "authority1", "requested", listenerResource.typeUrl())), any());
+    // LDS resources acked
+    // authority = #old, for non-xdstp resource names
+    verify(mockBatchRecorder).recordLongGauge(eqMetricInstrumentName("grpc.xds_client.resources"),
+        eq(2L),
+        eq(Arrays.asList(target, "#old", "acked", listenerResource.typeUrl())), any());
+    // LDS resource nacked but cached
+    // "" for missing authority in the resource name
+    verify(mockBatchRecorder).recordLongGauge(eqMetricInstrumentName("grpc.xds_client.resources"),
+        eq(1L),
+        eq(Arrays.asList(target, "", "nacked_but_cached", listenerResource.typeUrl())), any());
+
+    // RDS resource nacked
+    verify(mockBatchRecorder).recordLongGauge(eqMetricInstrumentName("grpc.xds_client.resources"),
+        eq(1L),
+        eq(Arrays.asList(target, "authority5", "nacked", routeConfigResource.typeUrl())), any());
+    // RDS resource does not exist
+    verify(mockBatchRecorder).recordLongGauge(eqMetricInstrumentName("grpc.xds_client.resources"),
+        eq(1L),
+        eq(Arrays.asList(target, "authority6", "does_not_exist", routeConfigResource.typeUrl())),
+        any());
+
+    // CDS resource unknown
+    verify(mockBatchRecorder).recordLongGauge(eqMetricInstrumentName("grpc.xds_client.resources"),
+        eq(1L),
+        eq(Arrays.asList(target, "authority7", "unknown", clusterResource.typeUrl())),
+        any());
+    verifyNoMoreInteractions(mockBatchRecorder);
+  }
+
+  @Test
+  public void reportCallbackMetrics_computeAndReportResourceCounts_emptyResources() {
+    Map<XdsResourceType<?>, Map<String, ResourceMetadata>> metadataByType = new HashMap<>();
+    XdsResourceType<?> listenerResource = XdsListenerResource.getInstance();
+    metadataByType.put(listenerResource, Collections.emptyMap());
+
+    SettableFuture<Void> reportServerConnectionsCompleted = SettableFuture.create();
+    reportServerConnectionsCompleted.set(null);
+    when(mockXdsClient.reportServerConnections(any(MetricReporterCallback.class)))
+        .thenReturn(reportServerConnectionsCompleted);
+
+    ListenableFuture<Map<XdsResourceType<?>, Map<String, ResourceMetadata>>>
+        getResourceMetadataCompleted = Futures.immediateFuture(metadataByType);
+    when(mockXdsClient.getSubscribedResourcesMetadataSnapshot())
+        .thenReturn(getResourceMetadataCompleted);
+
+    reporter.reportCallbackMetrics(mockBatchRecorder, mockXdsClient);
+
+    // Verify that reportResourceCountGauge is never called
+    verifyNoInteractions(mockBatchRecorder);
+  }
+
+  @Test
+  public void reportCallbackMetrics_computeAndReportResourceCounts_nullMetadata() {
+    TestlogHandler testLogHandler = new TestlogHandler();
+    Logger logger = Logger.getLogger(XdsClientMetricReporterImpl.class.getName());
+    logger.addHandler(testLogHandler);
+
+    SettableFuture<Void> reportServerConnectionsCompleted = SettableFuture.create();
+    reportServerConnectionsCompleted.set(null);
+    when(mockXdsClient.reportServerConnections(any(MetricReporterCallback.class)))
+        .thenReturn(reportServerConnectionsCompleted);
+
+    ListenableFuture<Map<XdsResourceType<?>, Map<String, ResourceMetadata>>>
+        getResourceMetadataCompleted = Futures.immediateFailedFuture(
+            new Exception("Error generating metadata snapshot"));
+    when(mockXdsClient.getSubscribedResourcesMetadataSnapshot())
+        .thenReturn(getResourceMetadataCompleted);
+
+    reporter.reportCallbackMetrics(mockBatchRecorder, mockXdsClient);
+    assertThat(testLogHandler.getLogs().size()).isEqualTo(1);
+    assertThat(testLogHandler.getLogs().get(0).getLevel()).isEqualTo(Level.WARNING);
+    assertThat(testLogHandler.getLogs().get(0).getMessage()).isEqualTo(
+        "Failed to report gauge metrics");
+    logger.removeHandler(testLogHandler);
+  }
+
+  @Test
+  public void close_closesGaugeRegistration() {
+    MetricSink.Registration mockRegistration = mock(MetricSink.Registration.class);
+    when(mockMetricRecorder.registerBatchCallback(any(MetricRecorder.BatchCallback.class),
+        eqMetricInstrumentName("grpc.xds_client.connected"),
+        eqMetricInstrumentName("grpc.xds_client.resources"))).thenReturn(mockRegistration);
+
+    // Sets XdsClient and register the gauges
+    reporter.setXdsClient(mockXdsClient);
+    // Closes registered gauges
+    reporter.close();
+    verify(mockRegistration, times(1)).close();
+  }
+
+  @SuppressWarnings("TypeParameterUnusedInFormals")
+  private <T extends MetricInstrument> T eqMetricInstrumentName(String name) {
+    return argThat(new ArgumentMatcher<T>() {
+      @Override
+      public boolean matches(T instrument) {
+        return instrument.getName().equals(name);
+      }
+    });
+  }
+
+  static class MetricRecorderImpl implements MetricRecorder {
+  }
+
+  static class BatchRecorderImpl implements BatchRecorder {
+  }
+
+  static class TestlogHandler extends Handler {
+    List<LogRecord> logs = new ArrayList<>();
+
+    @Override
+    public void publish(LogRecord record) {
+      logs.add(record);
+    }
+
+    @Override
+    public void close() {}
+
+    @Override
+    public void flush() {}
+
+    public List<LogRecord> getLogs() {
+      return logs;
+    }
+  }
+
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsClientWrapperForServerSdsTestMisc.java b/xds/src/test/java/io/grpc/xds/XdsClientWrapperForServerSdsTestMisc.java
new file mode 100644
index 00000000000..81186d0639c
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsClientWrapperForServerSdsTestMisc.java
@@ -0,0 +1,401 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.FilterChainMatchingProtocolNegotiators.FilterChainMatchingHandler.FilterChainSelector.NO_FILTER_CHAIN;
+import static io.grpc.xds.internal.security.SecurityProtocolNegotiators.ATTR_SERVER_SSL_CONTEXT_PROVIDER_SUPPLIER;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.SettableFuture;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress.Protocol;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.inprocess.InProcessSocketAddress;
+import io.grpc.internal.TestUtils.NoopChannelLogger;
+import io.grpc.netty.GrpcHttp2ConnectionHandler;
+import io.grpc.netty.InternalProtocolNegotiationEvent;
+import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
+import io.grpc.netty.ProtocolNegotiationEvent;
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.FilterChainMatchingProtocolNegotiators.FilterChainMatchingHandler;
+import io.grpc.xds.FilterChainMatchingProtocolNegotiators.FilterChainMatchingHandler.FilterChainSelector;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.XdsServerBuilder.XdsServingStatusListener;
+import io.grpc.xds.XdsServerTestHelper.FakeXdsClient;
+import io.grpc.xds.XdsServerTestHelper.FakeXdsClientPoolFactory;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil;
+import io.grpc.xds.internal.security.SslContextProvider;
+import io.grpc.xds.internal.security.SslContextProviderSupplier;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.embedded.EmbeddedChannel;
+import io.netty.handler.codec.http2.DefaultHttp2Connection;
+import io.netty.handler.codec.http2.DefaultHttp2ConnectionDecoder;
+import io.netty.handler.codec.http2.DefaultHttp2ConnectionEncoder;
+import io.netty.handler.codec.http2.DefaultHttp2FrameReader;
+import io.netty.handler.codec.http2.DefaultHttp2FrameWriter;
+import io.netty.handler.codec.http2.Http2ConnectionDecoder;
+import io.netty.handler.codec.http2.Http2ConnectionEncoder;
+import io.netty.handler.codec.http2.Http2Settings;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Migration test XdsServerWrapper from previous XdsClientWrapperForServerSds. */
+@RunWith(JUnit4.class)
+public class XdsClientWrapperForServerSdsTestMisc {
+
+  private static final int PORT = 7000;
+  private static final int START_WAIT_AFTER_LISTENER_MILLIS = 100;
+
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private EmbeddedChannel channel;
+  private ChannelPipeline pipeline;
+  @Mock private TlsContextManager tlsContextManager;
+  private InetSocketAddress localAddress;
+  private DownstreamTlsContext tlsContext1;
+  private DownstreamTlsContext tlsContext2;
+  private DownstreamTlsContext tlsContext3;
+
+  @Mock
+  private ServerBuilder<?> mockBuilder;
+  @Mock
+  Server mockServer;
+  @Mock
+  private XdsServingStatusListener listener;
+  private FakeXdsClient xdsClient = new FakeXdsClient();
+  private FilterChainSelectorManager selectorManager = new FilterChainSelectorManager();
+  private XdsServerWrapper xdsServerWrapper;
+
+
+  @Before
+  public void setUp() {
+    tlsContext1 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+    tlsContext2 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT2", "VA2");
+    tlsContext3 =
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT3", "VA3");
+    when(mockBuilder.build()).thenReturn(mockServer);
+    when(mockServer.isShutdown()).thenReturn(false);
+    xdsServerWrapper = new XdsServerWrapper("0.0.0.0:" + PORT, mockBuilder, listener,
+            selectorManager, new FakeXdsClientPoolFactory(xdsClient),
+            XdsServerTestHelper.RAW_BOOTSTRAP, FilterRegistry.newRegistry());
+  }
+
+  @Test
+  public void nonInetSocketAddress_expectNull() throws Exception {
+    sendListenerUpdate(new InProcessSocketAddress("test1"), null, null, tlsContextManager);
+    assertThat(getSslContextProviderSupplier(selectorManager.getSelectorToUpdateSelector()))
+        .isNull();
+  }
+
+  @Test
+  public void emptyFilterChain_expectNull() throws Exception {
+    InetAddress ipLocalAddress = InetAddress.getByName("10.1.2.3");
+    final InetSocketAddress localAddress = new InetSocketAddress(ipLocalAddress, PORT);
+    InetAddress ipRemoteAddress = InetAddress.getByName("10.4.5.6");
+    final InetSocketAddress remoteAddress = new InetSocketAddress(ipRemoteAddress, 1234);
+    channel = new EmbeddedChannel() {
+        @Override
+        public SocketAddress localAddress() {
+          return localAddress;
+        }
+
+        @Override
+        public SocketAddress remoteAddress() {
+          return remoteAddress;
+        }
+    };
+    pipeline = channel.pipeline();
+
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsWatched = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    assertThat(ldsWatched).isEqualTo("grpc/server?udpa.resource.listening_address=0.0.0.0:" + PORT);
+
+    EnvoyServerProtoData.Listener tcpListener =
+        EnvoyServerProtoData.Listener.create(
+            "listener1",
+            "0.0.0.0:7000",
+            ImmutableList.of(),
+            null,
+            Protocol.TCP);
+    LdsUpdate listenerUpdate = LdsUpdate.forTcpListener(tcpListener);
+    xdsClient.ldsWatcher.onResourceChanged(StatusOr.fromValue(listenerUpdate));
+    verify(listener, timeout(5000)).onServing();
+    start.get(START_WAIT_AFTER_LISTENER_MILLIS, TimeUnit.MILLISECONDS);
+    FilterChainSelector selector = selectorManager.getSelectorToUpdateSelector();
+    assertThat(getSslContextProviderSupplier(selector)).isNull();
+  }
+
+  @Test
+  public void registerServerWatcher_notifyNotFound() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsWatched = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    Status status = Status.NOT_FOUND.withDescription("Resource not found: " + ldsWatched);
+    xdsClient.ldsWatcher.onResourceChanged(StatusOr.fromStatus(status));
+    verify(listener, timeout(5000)).onNotServing(any());
+    try {
+      start.get(START_WAIT_AFTER_LISTENER_MILLIS, TimeUnit.MILLISECONDS);
+      fail("Start should throw exception");
+    } catch (TimeoutException ex) {
+      assertThat(start.isDone()).isFalse();
+    }
+    assertThat(selectorManager.getSelectorToUpdateSelector()).isSameInstanceAs(NO_FILTER_CHAIN);
+  }
+
+  @Test
+  public void releaseOldSupplierOnChanged_noCloseDueToLazyLoading() throws Exception {
+    InetAddress ipLocalAddress = InetAddress.getByName("10.1.2.3");
+    localAddress = new InetSocketAddress(ipLocalAddress, PORT);
+    sendListenerUpdate(localAddress, tlsContext2, null,
+            tlsContextManager);
+    verify(tlsContextManager, never())
+        .findOrCreateServerSslContextProvider(any(DownstreamTlsContext.class));
+  }
+
+  @Test
+  public void releaseOldSupplierOnChangedOnShutdown_verifyClose() throws Exception {
+    SslContextProvider sslContextProvider1 = mock(SslContextProvider.class);
+    when(tlsContextManager.findOrCreateServerSslContextProvider(eq(tlsContext1)))
+        .thenReturn(sslContextProvider1);
+    InetAddress ipLocalAddress = InetAddress.getByName("10.1.2.3");
+    localAddress = new InetSocketAddress(ipLocalAddress, PORT);
+    sendListenerUpdate(localAddress, tlsContext1, null,
+            tlsContextManager);
+    SslContextProviderSupplier returnedSupplier =
+        getSslContextProviderSupplier(selectorManager.getSelectorToUpdateSelector());
+    assertThat(returnedSupplier.getTlsContext()).isSameInstanceAs(tlsContext1);
+    callUpdateSslContext(returnedSupplier);
+    XdsServerTestHelper
+        .generateListenerUpdate(xdsClient, ImmutableList.of(1234), tlsContext2,
+            tlsContext3, tlsContextManager);
+    returnedSupplier = getSslContextProviderSupplier(selectorManager.getSelectorToUpdateSelector());
+    assertThat(returnedSupplier.getTlsContext()).isSameInstanceAs(tlsContext2);
+    verify(tlsContextManager, times(1)).releaseServerSslContextProvider(eq(sslContextProvider1));
+    reset(tlsContextManager);
+    SslContextProvider sslContextProvider2 = mock(SslContextProvider.class);
+    when(tlsContextManager.findOrCreateServerSslContextProvider(eq(tlsContext2)))
+            .thenReturn(sslContextProvider2);
+    SslContextProvider sslContextProvider3 = mock(SslContextProvider.class);
+    when(tlsContextManager.findOrCreateServerSslContextProvider(eq(tlsContext3)))
+            .thenReturn(sslContextProvider3);
+    callUpdateSslContext(returnedSupplier);
+    InetAddress ipRemoteAddress = InetAddress.getByName("10.4.5.6");
+    final InetSocketAddress remoteAddress = new InetSocketAddress(ipRemoteAddress, 1111);
+    channel = new EmbeddedChannel() {
+        @Override
+        public SocketAddress localAddress() {
+          return localAddress;
+        }
+
+        @Override
+        public SocketAddress remoteAddress() {
+          return remoteAddress;
+        }
+    };
+    pipeline = channel.pipeline();
+    returnedSupplier = getSslContextProviderSupplier(selectorManager.getSelectorToUpdateSelector());
+    assertThat(returnedSupplier.getTlsContext()).isSameInstanceAs(tlsContext3);
+    callUpdateSslContext(returnedSupplier);
+    xdsServerWrapper.shutdown();
+    assertThat(xdsClient.ldsResource).isNull();
+    verify(tlsContextManager, never()).releaseServerSslContextProvider(eq(sslContextProvider1));
+    verify(tlsContextManager, times(1)).releaseServerSslContextProvider(eq(sslContextProvider2));
+    verify(tlsContextManager, times(1)).releaseServerSslContextProvider(eq(sslContextProvider3));
+  }
+
+  @Test
+  public void releaseOldSupplierOnNotFound_verifyClose() throws Exception {
+    SslContextProvider sslContextProvider1 = mock(SslContextProvider.class);
+    when(tlsContextManager.findOrCreateServerSslContextProvider(eq(tlsContext1)))
+            .thenReturn(sslContextProvider1);
+    InetAddress ipLocalAddress = InetAddress.getByName("10.1.2.3");
+    localAddress = new InetSocketAddress(ipLocalAddress, PORT);
+    sendListenerUpdate(localAddress, tlsContext1, null,
+            tlsContextManager);
+    SslContextProviderSupplier returnedSupplier =
+            getSslContextProviderSupplier(selectorManager.getSelectorToUpdateSelector());
+    assertThat(returnedSupplier.getTlsContext()).isSameInstanceAs(tlsContext1);
+    callUpdateSslContext(returnedSupplier);
+    Status status = Status.NOT_FOUND.withDescription("not-found Error");
+    xdsClient.ldsWatcher.onResourceChanged(StatusOr.fromStatus(status));
+    verify(tlsContextManager, times(1)).releaseServerSslContextProvider(eq(sslContextProvider1));
+  }
+
+  @Test
+  public void releaseOldSupplierOnTemporaryError_noClose() throws Exception {
+    SslContextProvider sslContextProvider1 = mock(SslContextProvider.class);
+    when(tlsContextManager.findOrCreateServerSslContextProvider(eq(tlsContext1)))
+            .thenReturn(sslContextProvider1);
+    InetAddress ipLocalAddress = InetAddress.getByName("10.1.2.3");
+    localAddress = new InetSocketAddress(ipLocalAddress, PORT);
+    sendListenerUpdate(localAddress, tlsContext1, null,
+            tlsContextManager);
+    SslContextProviderSupplier returnedSupplier =
+            getSslContextProviderSupplier(selectorManager.getSelectorToUpdateSelector());
+    assertThat(returnedSupplier.getTlsContext()).isSameInstanceAs(tlsContext1);
+    callUpdateSslContext(returnedSupplier);
+    xdsClient.ldsWatcher.onAmbientError(Status.CANCELLED);
+    verify(tlsContextManager, never()).releaseServerSslContextProvider(eq(sslContextProvider1));
+  }
+
+  private void callUpdateSslContext(SslContextProviderSupplier sslContextProviderSupplier) {
+    assertThat(sslContextProviderSupplier).isNotNull();
+    SslContextProvider.Callback callback = mock(SslContextProvider.Callback.class);
+    sslContextProviderSupplier.updateSslContext(callback, false);
+  }
+
+  private void sendListenerUpdate(
+          final SocketAddress localAddress, DownstreamTlsContext tlsContext,
+          DownstreamTlsContext tlsContextForDefaultFilterChain, TlsContextManager tlsContextManager)
+      throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    XdsServerTestHelper
+            .generateListenerUpdate(xdsClient, ImmutableList.of(), tlsContext,
+                    tlsContextForDefaultFilterChain, tlsContextManager);
+    verify(listener, timeout(5000)).onServing();
+    start.get(START_WAIT_AFTER_LISTENER_MILLIS, TimeUnit.MILLISECONDS);
+    InetAddress ipRemoteAddress = InetAddress.getByName("10.4.5.6");
+    final InetSocketAddress remoteAddress = new InetSocketAddress(ipRemoteAddress, 1234);
+    channel = new EmbeddedChannel() {
+      @Override
+      public SocketAddress localAddress() {
+        return localAddress;
+      }
+
+      @Override
+      public SocketAddress remoteAddress() {
+        return remoteAddress;
+      }
+    };
+    pipeline = channel.pipeline();
+  }
+
+  private SslContextProviderSupplier getSslContextProviderSupplier(
+          FilterChainSelector selector) throws Exception {
+    final SettableFuture<SslContextProviderSupplier> sslSet = SettableFuture.create();
+    ChannelHandler next = new ChannelInboundHandlerAdapter() {
+      @Override
+      public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
+        ProtocolNegotiationEvent e = (ProtocolNegotiationEvent)evt;
+        sslSet.set(InternalProtocolNegotiationEvent.getAttributes(e)
+                .get(ATTR_SERVER_SSL_CONTEXT_PROVIDER_SUPPLIER));
+        ctx.pipeline().remove(this);
+      }
+    };
+    ProtocolNegotiator mockDelegate = mock(ProtocolNegotiator.class);
+    GrpcHttp2ConnectionHandler grpcHandler = FakeGrpcHttp2ConnectionHandler.newHandler();
+    when(mockDelegate.newHandler(grpcHandler)).thenReturn(next);
+    FilterChainSelectorManager manager = new FilterChainSelectorManager();
+    manager.updateSelector(selector);
+    FilterChainMatchingHandler filterChainMatchingHandler =
+            new FilterChainMatchingHandler(grpcHandler, manager, mockDelegate);
+    pipeline.addLast(filterChainMatchingHandler);
+    ProtocolNegotiationEvent event = InternalProtocolNegotiationEvent.getDefault();
+    pipeline.fireUserEventTriggered(event);
+    channel.runPendingTasks();
+    sslSet.set(InternalProtocolNegotiationEvent.getAttributes(event)
+            .get(ATTR_SERVER_SSL_CONTEXT_PROVIDER_SUPPLIER));
+    return sslSet.get();
+  }
+
+  private static final class FakeGrpcHttp2ConnectionHandler extends GrpcHttp2ConnectionHandler {
+    FakeGrpcHttp2ConnectionHandler(
+            ChannelPromise channelUnused,
+            Http2ConnectionDecoder decoder,
+            Http2ConnectionEncoder encoder,
+            Http2Settings initialSettings) {
+      super(channelUnused, decoder, encoder, initialSettings, new NoopChannelLogger());
+    }
+
+    static FakeGrpcHttp2ConnectionHandler newHandler() {
+      DefaultHttp2Connection conn = new DefaultHttp2Connection(/*server=*/ false);
+      DefaultHttp2ConnectionEncoder encoder =
+              new DefaultHttp2ConnectionEncoder(conn, new DefaultHttp2FrameWriter());
+      DefaultHttp2ConnectionDecoder decoder =
+              new DefaultHttp2ConnectionDecoder(conn, encoder, new DefaultHttp2FrameReader());
+      Http2Settings settings = new Http2Settings();
+      return new FakeGrpcHttp2ConnectionHandler(
+              /*channelUnused=*/ null, decoder, encoder, settings);
+    }
+
+    @Override
+    public String getAuthority() {
+      return "authority";
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsCredentialsRegistryTest.java b/xds/src/test/java/io/grpc/xds/XdsCredentialsRegistryTest.java
new file mode 100644
index 00000000000..facaffc67a2
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsCredentialsRegistryTest.java
@@ -0,0 +1,216 @@
+/*
+ * Copyright 2022 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableMap;
+import io.grpc.ChannelCredentials;
+import io.grpc.xds.XdsCredentialsProvider;
+import io.grpc.xds.XdsCredentialsRegistry;
+import io.grpc.xds.internal.GoogleDefaultXdsCredentialsProvider;
+import io.grpc.xds.internal.InsecureXdsCredentialsProvider;
+import io.grpc.xds.internal.TlsXdsCredentialsProvider;
+import java.util.List;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link XdsCredentialsRegistry}. */
+@RunWith(JUnit4.class)
+public class XdsCredentialsRegistryTest {
+
+  @Test
+  public void register_unavailableProviderThrows() {
+    XdsCredentialsRegistry reg = new XdsCredentialsRegistry();
+    try {
+      reg.register(new BaseCredsProvider(false, 5, "creds"));
+      fail("Should throw");
+    } catch (IllegalArgumentException e) {
+      assertThat(e).hasMessageThat().contains("isAvailable() returned false");
+    }
+    assertThat(reg.providers()).isEmpty();
+  }
+
+  @Test
+  public void deregister() {
+    XdsCredentialsRegistry reg = new XdsCredentialsRegistry();
+    String credsName = "sampleCredsName";
+    XdsCredentialsProvider p1 = new BaseCredsProvider(true, 5, credsName);
+    XdsCredentialsProvider p2 = new BaseCredsProvider(true, 5, credsName);
+    XdsCredentialsProvider p3 = new BaseCredsProvider(true, 5, credsName);
+    reg.register(p1);
+    reg.register(p2);
+    reg.register(p3);
+    assertThat(reg.getProvider(credsName)).isSameInstanceAs(p1);
+    reg.deregister(p2);
+    assertThat(reg.getProvider(credsName)).isSameInstanceAs(p1);
+    reg.deregister(p1);
+    assertThat(reg.getProvider(credsName)).isSameInstanceAs(p3);
+
+  }
+
+  @Test
+  public void provider_sorted() {
+    XdsCredentialsRegistry reg = new XdsCredentialsRegistry();
+    String credsName = "sampleCredsName";
+    XdsCredentialsProvider p1 = new BaseCredsProvider(true, 5, credsName);
+    XdsCredentialsProvider p2 = new BaseCredsProvider(true, 3, credsName);
+    XdsCredentialsProvider p3 = new BaseCredsProvider(true, 8, credsName);
+    XdsCredentialsProvider p4 = new BaseCredsProvider(true, 3, credsName);
+    XdsCredentialsProvider p5 = new BaseCredsProvider(true, 8, credsName);
+    reg.register(p1);
+    reg.register(p2);
+    reg.register(p3);
+    reg.register(p4);
+    reg.register(p5);
+    assertThat(reg.getProvider(credsName)).isSameInstanceAs(p3);
+  }
+
+  @Test
+  public void channelCredentials_successful() {
+    XdsCredentialsRegistry registry = new XdsCredentialsRegistry();
+    String credsName = "sampleCredsName";
+
+    registry.register(
+        new BaseCredsProvider(true, 5, credsName) {
+        @Override
+        public ChannelCredentials newChannelCredentials(Map<String, ?> config) {
+          return new SampleChannelCredentials(config);
+        }
+      });
+
+    ImmutableMap<String, String> sampleConfig = ImmutableMap.of("a", "b");
+    ChannelCredentials creds = registry.providers().get(credsName)
+        .newChannelCredentials(sampleConfig);
+    assertSame(SampleChannelCredentials.class, creds.getClass());
+    assertEquals(sampleConfig, ((SampleChannelCredentials)creds).getConfig());
+  }
+
+  @Test
+  public void channelCredentials_multiSuccessful() {
+    XdsCredentialsRegistry registry = new XdsCredentialsRegistry();
+    String credsName1 = "sampleCreds1";
+    String credsName2 = "sampleCreds2";
+    registry.register(
+        new BaseCredsProvider(true, 5, credsName1) {
+        @Override
+        public ChannelCredentials newChannelCredentials(Map<String, ?> config) {
+          return null;
+        }
+      });
+
+    registry.register(
+        new BaseCredsProvider(true, 7, credsName2) {
+        @Override
+        public ChannelCredentials newChannelCredentials(Map<String, ?> config) {
+          return new SampleChannelCredentials(config);
+        }
+      });
+
+    assertThat(registry.getProvider(credsName1).newChannelCredentials(null)).isNull();
+    assertThat(registry.getProvider(credsName1).getName()).isEqualTo(credsName1);
+    assertThat(registry.getProvider(credsName2).newChannelCredentials(null)).isNotNull();
+    assertThat(registry.getProvider(credsName2).getName()).isEqualTo(credsName2);
+  }
+
+  @Test
+  public void defaultRegistry_providers() {
+    Map<String, XdsCredentialsProvider> providers =
+            XdsCredentialsRegistry.getDefaultRegistry().providers();
+    assertThat(providers).hasSize(3);
+    assertThat(providers.get("google_default").getClass())
+        .isEqualTo(GoogleDefaultXdsCredentialsProvider.class);
+    assertThat(providers.get("insecure").getClass())
+        .isEqualTo(InsecureXdsCredentialsProvider.class);
+    assertThat(providers.get("tls").getClass())
+        .isEqualTo(TlsXdsCredentialsProvider.class);
+  }
+
+  @Test
+  public void getClassesViaHardcoded_classesPresent() throws Exception {
+    List<Class<?>> classes = XdsCredentialsRegistry.getHardCodedClasses();
+    assertThat(classes).containsExactly(
+        GoogleDefaultXdsCredentialsProvider.class,
+        InsecureXdsCredentialsProvider.class,
+        TlsXdsCredentialsProvider.class);
+  }
+
+  @Test
+  public void getProvider_null() {
+    try {
+      XdsCredentialsRegistry.getDefaultRegistry().getProvider(null);
+      fail("Should throw");
+    } catch (NullPointerException e) {
+      assertThat(e).hasMessageThat().contains("name");
+    }
+  }
+
+
+  private static class BaseCredsProvider extends XdsCredentialsProvider {
+    private final boolean isAvailable;
+    private final int priority;
+    private final String name;
+
+    public BaseCredsProvider(boolean isAvailable, int priority, String name) {
+      this.isAvailable = isAvailable;
+      this.priority = priority;
+      this.name = name;
+    }
+
+    @Override
+    protected String getName() {
+      return name;
+    }
+
+    @Override
+    public boolean isAvailable() {
+      return isAvailable;
+    }
+
+    @Override
+    public int priority() {
+      return priority;
+    }
+
+    @Override
+    public ChannelCredentials newChannelCredentials(Map<String, ?> config) {
+      throw new UnsupportedOperationException();
+    }
+  }
+
+  private static class SampleChannelCredentials extends ChannelCredentials {
+    private final Map<String, ?> config;
+
+    SampleChannelCredentials(Map<String, ?> config) {
+      this.config = config;
+    }
+
+    public Map<String, ?> getConfig() {
+      return config;
+    }
+
+    @Override
+    public ChannelCredentials withoutBearerTokens() {
+      return this;
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsDependencyManagerTest.java b/xds/src/test/java/io/grpc/xds/XdsDependencyManagerTest.java
new file mode 100644
index 00000000000..7bae7000eaf
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsDependencyManagerTest.java
@@ -0,0 +1,1033 @@
+/*
+ * Copyright 2024 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.StatusMatcher.statusHasCode;
+import static io.grpc.xds.XdsClusterResource.CdsUpdate.ClusterType.EDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_CDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_EDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_LDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_RDS;
+import static io.grpc.xds.XdsTestUtils.CLUSTER_NAME;
+import static io.grpc.xds.XdsTestUtils.ENDPOINT_HOSTNAME;
+import static io.grpc.xds.XdsTestUtils.ENDPOINT_PORT;
+import static io.grpc.xds.XdsTestUtils.RDS_NAME;
+import static io.grpc.xds.XdsTestUtils.getEdsNameForCluster;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.Message;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.core.v3.Address;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;
+import io.envoyproxy.envoy.config.endpoint.v3.Endpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LbEndpoint;
+import io.envoyproxy.envoy.config.endpoint.v3.LocalityLbEndpoints;
+import io.envoyproxy.envoy.config.listener.v3.Listener;
+import io.envoyproxy.envoy.config.route.v3.RouteConfiguration;
+import io.grpc.BindableService;
+import io.grpc.ChannelLogger;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.NameResolver;
+import io.grpc.NameResolverRegistry;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.StatusOrMatcher;
+import io.grpc.SynchronizationContext;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.testing.FakeNameResolverProvider;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.xds.XdsClusterResource.CdsUpdate;
+import io.grpc.xds.XdsConfig.XdsClusterConfig;
+import io.grpc.xds.XdsEndpointResource.EdsUpdate;
+import io.grpc.xds.client.Locality;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsClient.ResourceMetadata;
+import io.grpc.xds.client.XdsResourceType;
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Logger;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatcher;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for {@link XdsDependencyManager}. */
+@RunWith(JUnit4.class)
+public class XdsDependencyManagerTest {
+  private static final Logger log = Logger.getLogger(XdsDependencyManagerTest.class.getName());
+  public static final String CLUSTER_TYPE_NAME = XdsClusterResource.getInstance().typeName();
+  public static final String ENDPOINT_TYPE_NAME = XdsEndpointResource.getInstance().typeName();
+
+  private final SynchronizationContext syncContext =
+      new SynchronizationContext((t, e) -> {
+        throw new AssertionError(e);
+      });
+  private final FakeClock fakeClock = new FakeClock();
+
+  private XdsClient xdsClient = XdsTestUtils.createXdsClient(
+      Collections.singletonList("control-plane"),
+      serverInfo -> new GrpcXdsTransportFactory.GrpcXdsTransport(
+          InProcessChannelBuilder.forName(serverInfo.target()).directExecutor().build()),
+      fakeClock);
+
+  private TestWatcher xdsConfigWatcher;
+
+  private final String serverName = "the-service-name";
+  private final Queue<XdsTestUtils.LrsRpcCall> loadReportCalls = new ArrayDeque<>();
+  private final AtomicBoolean adsEnded = new AtomicBoolean(true);
+  private final AtomicBoolean lrsEnded = new AtomicBoolean(true);
+  private final XdsTestControlPlaneService controlPlaneService = new XdsTestControlPlaneService();
+  private final BindableService lrsService =
+      XdsTestUtils.createLrsService(lrsEnded, loadReportCalls);
+  private final NameResolverRegistry nameResolverRegistry = new NameResolverRegistry();
+
+  @Rule
+  public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  private TestWatcher testWatcher;
+  private XdsConfig defaultXdsConfig; // set in setUp()
+
+  @Captor
+  private ArgumentCaptor<StatusOr<XdsConfig>> xdsUpdateCaptor;
+  private final NameResolver.Args nameResolverArgs = NameResolver.Args.newBuilder()
+      .setDefaultPort(8080)
+      .setProxyDetector(GrpcUtil.DEFAULT_PROXY_DETECTOR)
+      .setSynchronizationContext(syncContext)
+      .setServiceConfigParser(mock(NameResolver.ServiceConfigParser.class))
+      .setChannelLogger(mock(ChannelLogger.class))
+      .setScheduledExecutorService(fakeClock.getScheduledExecutorService())
+      .setNameResolverRegistry(nameResolverRegistry)
+      .build();
+
+  private XdsDependencyManager xdsDependencyManager = new XdsDependencyManager(
+      xdsClient, syncContext, serverName, serverName, nameResolverArgs);
+  private boolean savedEnableLogicalDns;
+
+  @Before
+  public void setUp() throws Exception {
+    cleanupRule.register(InProcessServerBuilder
+        .forName("control-plane")
+        .addService(controlPlaneService)
+        .addService(lrsService)
+        .directExecutor()
+        .build()
+        .start());
+
+    XdsTestUtils.setAdsConfig(controlPlaneService, serverName);
+
+    testWatcher = new TestWatcher();
+    xdsConfigWatcher = mock(TestWatcher.class, delegatesTo(testWatcher));
+    defaultXdsConfig = XdsTestUtils.getDefaultXdsConfig(serverName);
+
+    savedEnableLogicalDns = XdsDependencyManager.enableLogicalDns;
+  }
+
+  @After
+  public void tearDown() throws InterruptedException {
+    if (xdsDependencyManager != null) {
+      xdsDependencyManager.shutdown();
+    }
+    xdsClient.shutdown();
+
+    assertThat(adsEnded.get()).isTrue();
+    assertThat(lrsEnded.get()).isTrue();
+    assertThat(fakeClock.getPendingTasks()).isEmpty();
+
+    XdsDependencyManager.enableLogicalDns = savedEnableLogicalDns;
+  }
+
+  @Test
+  public void verify_basic_config() {
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    verify(xdsConfigWatcher).onUpdate(StatusOr.fromValue(defaultXdsConfig));
+    testWatcher.verifyStats(1, 0);
+  }
+
+  @Test
+  public void verify_config_update() {
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    InOrder inOrder = Mockito.inOrder(xdsConfigWatcher);
+    inOrder.verify(xdsConfigWatcher).onUpdate(StatusOr.fromValue(defaultXdsConfig));
+    testWatcher.verifyStats(1, 0);
+    assertThat(testWatcher.lastConfig).isEqualTo(defaultXdsConfig);
+
+    XdsTestUtils.setAdsConfig(controlPlaneService, serverName, "RDS2", "CDS2", "EDS2",
+        ENDPOINT_HOSTNAME + "2", ENDPOINT_PORT + 2);
+    inOrder.verify(xdsConfigWatcher).onUpdate(ArgumentMatchers.notNull());
+    testWatcher.verifyStats(2, 0);
+    assertThat(testWatcher.lastConfig).isNotEqualTo(defaultXdsConfig);
+  }
+
+  @Test
+  public void verify_simple_aggregate() {
+    InOrder inOrder = Mockito.inOrder(xdsConfigWatcher);
+    xdsDependencyManager.start(xdsConfigWatcher);
+    inOrder.verify(xdsConfigWatcher).onUpdate(StatusOr.fromValue(defaultXdsConfig));
+
+    List<String> childNames = Arrays.asList("clusterC", "clusterB", "clusterA");
+    String rootName = "root_c";
+
+    RouteConfiguration routeConfig =
+        XdsTestUtils.buildRouteConfiguration(serverName, XdsTestUtils.RDS_NAME, rootName);
+    controlPlaneService.setXdsConfig(
+        ADS_TYPE_URL_RDS, ImmutableMap.of(XdsTestUtils.RDS_NAME, routeConfig));
+
+    XdsTestUtils.setAggregateCdsConfig(controlPlaneService, serverName, rootName, childNames);
+    inOrder.verify(xdsConfigWatcher).onUpdate(any());
+
+    Map<String, StatusOr<XdsClusterConfig>> lastConfigClusters =
+        testWatcher.lastConfig.getClusters();
+    assertThat(lastConfigClusters).hasSize(childNames.size() + 1);
+    StatusOr<XdsClusterConfig> rootC = lastConfigClusters.get(rootName);
+    assertThat(rootC.getValue().getChildren()).isInstanceOf(XdsClusterConfig.AggregateConfig.class);
+    XdsClusterConfig.AggregateConfig aggConfig =
+        (XdsClusterConfig.AggregateConfig) rootC.getValue().getChildren();
+    assertThat(aggConfig.getLeafNames()).isEqualTo(childNames);
+
+    for (String childName : childNames) {
+      assertThat(lastConfigClusters).containsKey(childName);
+      StatusOr<XdsClusterConfig> childConfigOr = lastConfigClusters.get(childName);
+      CdsUpdate childResource =
+          childConfigOr.getValue().getClusterResource();
+      assertThat(childResource.clusterType()).isEqualTo(EDS);
+      assertThat(childResource.edsServiceName()).isEqualTo(getEdsNameForCluster(childName));
+
+      StatusOr<EdsUpdate> endpoint = getEndpoint(childConfigOr);
+      assertThat(endpoint.hasValue()).isTrue();
+      assertThat(endpoint.getValue().clusterName).isEqualTo(getEdsNameForCluster(childName));
+    }
+  }
+
+  private static StatusOr<EdsUpdate> getEndpoint(StatusOr<XdsClusterConfig> childConfigOr) {
+    XdsClusterConfig.ClusterChild clusterChild = childConfigOr.getValue()
+        .getChildren();
+    assertThat(clusterChild).isInstanceOf(XdsClusterConfig.EndpointConfig.class);
+    StatusOr<EdsUpdate> endpoint = ((XdsClusterConfig.EndpointConfig) clusterChild).getEndpoint();
+    assertThat(endpoint).isNotNull();
+    return endpoint;
+  }
+
+  @Test
+  public void testComplexRegisteredAggregate() throws IOException {
+    InOrder inOrder = Mockito.inOrder(xdsConfigWatcher);
+
+    // Do initialization
+    String rootName1 = "root_c";
+    List<String> childNames = Arrays.asList("clusterC", "clusterB", "clusterA");
+    XdsTestUtils.addAggregateToExistingConfig(controlPlaneService, rootName1, childNames);
+
+    String rootName2 = "root_2";
+    List<String> childNames2 = Arrays.asList("clusterA", "clusterX");
+    XdsTestUtils.addAggregateToExistingConfig(controlPlaneService, rootName2, childNames2);
+
+    xdsDependencyManager.start(xdsConfigWatcher);
+    inOrder.verify(xdsConfigWatcher).onUpdate(any());
+
+    Closeable subscription1 = xdsDependencyManager.subscribeToCluster(rootName1);
+    inOrder.verify(xdsConfigWatcher).onUpdate(any());
+
+    Closeable subscription2 = xdsDependencyManager.subscribeToCluster(rootName2);
+    inOrder.verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    testWatcher.verifyStats(3, 0);
+    ImmutableSet.Builder<String> builder = ImmutableSet.builder();
+    Set<String> expectedClusters = builder.add(rootName1).add(rootName2).add(CLUSTER_NAME)
+        .addAll(childNames).addAll(childNames2).build();
+    assertThat(xdsUpdateCaptor.getValue().getValue().getClusters().keySet())
+        .isEqualTo(expectedClusters);
+
+    // Close 1 subscription shouldn't affect the other or RDS subscriptions
+    subscription1.close();
+    inOrder.verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    builder = ImmutableSet.builder();
+    Set<String> expectedClusters2 =
+        builder.add(rootName2).add(CLUSTER_NAME).addAll(childNames2).build();
+    assertThat(xdsUpdateCaptor.getValue().getValue().getClusters().keySet())
+        .isEqualTo(expectedClusters2);
+
+    subscription2.close();
+    inOrder.verify(xdsConfigWatcher).onUpdate(StatusOr.fromValue(defaultXdsConfig));
+  }
+
+  @Test
+  public void testDelayedSubscription() {
+    InOrder inOrder = Mockito.inOrder(xdsConfigWatcher);
+    xdsDependencyManager.start(xdsConfigWatcher);
+    inOrder.verify(xdsConfigWatcher).onUpdate(StatusOr.fromValue(defaultXdsConfig));
+
+    String rootName1 = "root_c";
+
+    Closeable subscription1 = xdsDependencyManager.subscribeToCluster(rootName1);
+    assertThat(subscription1).isNotNull();
+    fakeClock.forwardTime(16, TimeUnit.SECONDS);
+    inOrder.verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    Status status = xdsUpdateCaptor.getValue().getValue().getClusters().get(rootName1).getStatus();
+    assertThat(status.getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(status.getDescription()).contains(rootName1);
+
+    List<String> childNames = Arrays.asList("clusterC", "clusterB", "clusterA");
+    XdsTestUtils.addAggregateToExistingConfig(controlPlaneService, rootName1, childNames);
+    inOrder.verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    assertThat(xdsUpdateCaptor.getValue().getValue().getClusters().get(rootName1).hasValue())
+        .isTrue();
+  }
+
+  @Test
+  public void testMissingCdsAndEds() {
+    // update config so that agg cluster references 2 existing & 1 non-existing cluster
+    List<String> childNames = Arrays.asList("clusterC", "clusterB", "clusterA");
+    Cluster cluster = XdsTestUtils.buildAggCluster(CLUSTER_NAME, childNames);
+    Map<String, Message> clusterMap = new HashMap<>();
+    Map<String, Message> edsMap = new HashMap<>();
+
+    clusterMap.put(CLUSTER_NAME, cluster);
+    for (int i = 0; i < childNames.size() - 1; i++) {
+      String edsName = XdsTestUtils.EDS_NAME + i;
+      Cluster child = ControlPlaneRule.buildCluster(childNames.get(i), edsName);
+      clusterMap.put(childNames.get(i), child);
+    }
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, clusterMap);
+
+    // Update config so that one of the 2 "valid" clusters has an EDS resource, the other does not
+    // and there is an EDS that doesn't have matching clusters
+    ClusterLoadAssignment clusterLoadAssignment = ControlPlaneRule.buildClusterLoadAssignment(
+        "127.0.1.1", ENDPOINT_HOSTNAME, ENDPOINT_PORT, XdsTestUtils.EDS_NAME + 0);
+    edsMap.put(XdsTestUtils.EDS_NAME + 0, clusterLoadAssignment);
+    clusterLoadAssignment = ControlPlaneRule.buildClusterLoadAssignment(
+        "127.0.1.2", ENDPOINT_HOSTNAME, ENDPOINT_PORT, "garbageEds");
+    edsMap.put("garbageEds", clusterLoadAssignment);
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, edsMap);
+
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    fakeClock.forwardTime(16, TimeUnit.SECONDS);
+    verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+
+    List<StatusOr<XdsClusterConfig>> returnedClusters = new ArrayList<>();
+    for (String childName : childNames) {
+      returnedClusters.add(xdsUpdateCaptor.getValue().getValue().getClusters().get(childName));
+    }
+
+    // Check that missing cluster reported Status and the other 2 are present
+    StatusOr<XdsClusterConfig> missingCluster = returnedClusters.get(2);
+    assertThat(missingCluster.getStatus().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(missingCluster.getStatus().getDescription()).contains(childNames.get(2));
+    assertThat(returnedClusters.get(0).hasValue()).isTrue();
+    assertThat(returnedClusters.get(1).hasValue()).isTrue();
+
+    // Check that missing EDS reported Status, the other one is present and the garbage EDS is not
+    assertThat(getEndpoint(returnedClusters.get(0)).hasValue()).isTrue();
+    assertThat(getEndpoint(returnedClusters.get(1)).getStatus().getCode())
+        .isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(getEndpoint(returnedClusters.get(1)).getStatus().getDescription())
+        .contains(XdsTestUtils.EDS_NAME + 1);
+
+    verify(xdsConfigWatcher, never()).onUpdate(
+        argThat(StatusOrMatcher.hasStatus(statusHasCode(Status.Code.UNAVAILABLE))));
+    testWatcher.verifyStats(1, 0);
+  }
+
+  @Test
+  public void testMissingLds() {
+    String ldsName = "badLdsName";
+    xdsDependencyManager = new XdsDependencyManager(xdsClient, syncContext,
+        serverName, ldsName, nameResolverArgs);
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    fakeClock.forwardTime(16, TimeUnit.SECONDS);
+    verify(xdsConfigWatcher).onUpdate(
+        argThat(StatusOrMatcher.hasStatus(statusHasCode(Status.Code.UNAVAILABLE)
+            .andDescriptionContains(ldsName))));
+
+    testWatcher.verifyStats(0, 1);
+  }
+
+  @Test
+  public void testTcpListenerErrors() {
+    Listener serverListener =
+        ControlPlaneRule.buildServerListener().toBuilder().setName(serverName).build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_LDS, ImmutableMap.of(serverName, serverListener));
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    fakeClock.forwardTime(16, TimeUnit.SECONDS);
+    verify(xdsConfigWatcher).onUpdate(
+        argThat(StatusOrMatcher.hasStatus(
+            statusHasCode(Status.Code.UNAVAILABLE).andDescriptionContains("Not an API listener"))));
+
+    testWatcher.verifyStats(0, 1);
+  }
+
+  @Test
+  public void testMissingRds() {
+    String rdsName = "badRdsName";
+    Listener clientListener = ControlPlaneRule.buildClientListener(serverName, rdsName);
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_LDS,
+        ImmutableMap.of(serverName, clientListener));
+
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    fakeClock.forwardTime(16, TimeUnit.SECONDS);
+    verify(xdsConfigWatcher).onUpdate(
+        argThat(StatusOrMatcher.hasStatus(statusHasCode(Status.Code.UNAVAILABLE)
+            .andDescriptionContains(rdsName))));
+
+    testWatcher.verifyStats(0, 1);
+  }
+
+  @Test
+  public void testUpdateToMissingVirtualHost() {
+    RouteConfiguration routeConfig = XdsTestUtils.buildRouteConfiguration(
+        "wrong-virtual-host", XdsTestUtils.RDS_NAME, XdsTestUtils.CLUSTER_NAME);
+    controlPlaneService.setXdsConfig(
+        ADS_TYPE_URL_RDS, ImmutableMap.of(XdsTestUtils.RDS_NAME, routeConfig));
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    // Update with a config that has a virtual host that doesn't match the server name
+    verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    assertThat(xdsUpdateCaptor.getValue().getStatus().getDescription())
+        .contains("Failed to find virtual host matching hostname: " + serverName);
+
+    testWatcher.verifyStats(0, 1);
+  }
+
+  @Test
+  public void testCorruptLds() {
+    String ldsResourceName =
+        "xdstp://unknown.example.com/envoy.config.listener.v3.Listener/listener1";
+
+    xdsDependencyManager = new XdsDependencyManager(xdsClient, syncContext,
+        serverName, ldsResourceName, nameResolverArgs);
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    verify(xdsConfigWatcher).onUpdate(
+        argThat(StatusOrMatcher.hasStatus(
+            statusHasCode(Status.Code.UNAVAILABLE).andDescriptionContains(ldsResourceName))));
+
+    fakeClock.forwardTime(16, TimeUnit.SECONDS);
+    testWatcher.verifyStats(0, 1);
+  }
+
+  @Test
+  public void testChangeRdsName_fromLds() {
+    InOrder inOrder = Mockito.inOrder(xdsConfigWatcher);
+    xdsDependencyManager.start(xdsConfigWatcher);
+    inOrder.verify(xdsConfigWatcher).onUpdate(StatusOr.fromValue(defaultXdsConfig));
+
+    String newRdsName = "newRdsName1";
+
+    Listener clientListener = buildInlineClientListener(newRdsName, CLUSTER_NAME);
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_LDS,
+        ImmutableMap.of(serverName, clientListener));
+    inOrder.verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    assertThat(xdsUpdateCaptor.getValue().getValue()).isNotEqualTo(defaultXdsConfig);
+    assertThat(xdsUpdateCaptor.getValue().getValue().getVirtualHost().name()).isEqualTo(newRdsName);
+  }
+
+  @Test
+  public void testMultipleParentsInCdsTree() throws IOException {
+    /*
+     * Configure Xds server with the following cluster tree and point RDS to root:
+      2 aggregates under root A & B
+       B has EDS Cluster B1 && shared agg AB1; A has agg A1 && shared agg AB1
+        A1 has shared EDS Cluster A11 && shared agg AB1
+         AB1 has shared EDS Clusters A11 && AB11
+
+      As an alternate visualization, parents are:
+        A -> root, B -> root, A1 -> A, AB1 -> A|B|A1, B1 -> B, A11 -> A1|AB1, AB11 -> AB1
+     */
+    Cluster rootCluster =
+        XdsTestUtils.buildAggCluster("root", Arrays.asList("clusterA", "clusterB"));
+    Cluster clusterA =
+        XdsTestUtils.buildAggCluster("clusterA", Arrays.asList("clusterA1", "clusterAB1"));
+    Cluster clusterB =
+        XdsTestUtils.buildAggCluster("clusterB", Arrays.asList("clusterB1", "clusterAB1"));
+    Cluster clusterA1 =
+        XdsTestUtils.buildAggCluster("clusterA1", Arrays.asList("clusterA11", "clusterAB1"));
+    Cluster clusterAB1 =
+        XdsTestUtils.buildAggCluster("clusterAB1", Arrays.asList("clusterA11", "clusterAB11"));
+
+    Map<String, Message> clusterMap = new HashMap<>();
+    Map<String, Message> edsMap = new HashMap<>();
+
+    clusterMap.put("root", rootCluster);
+    clusterMap.put("clusterA", clusterA);
+    clusterMap.put("clusterB", clusterB);
+    clusterMap.put("clusterA1", clusterA1);
+    clusterMap.put("clusterAB1", clusterAB1);
+
+    XdsTestUtils.addEdsClusters(clusterMap, edsMap, "clusterA11", "clusterAB11", "clusterB1");
+    RouteConfiguration routeConfig =
+        XdsTestUtils.buildRouteConfiguration(serverName, XdsTestUtils.RDS_NAME, "root");
+    controlPlaneService.setXdsConfig(
+        ADS_TYPE_URL_RDS, ImmutableMap.of(XdsTestUtils.RDS_NAME, routeConfig));
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, clusterMap);
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, edsMap);
+
+    // Start the actual test
+    InOrder inOrder = Mockito.inOrder(xdsConfigWatcher);
+    xdsDependencyManager.start(xdsConfigWatcher);
+    inOrder.verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    XdsConfig initialConfig = xdsUpdateCaptor.getValue().getValue();
+
+    // Make sure that adding subscriptions that rds points at doesn't change the config
+    Closeable rootSub = xdsDependencyManager.subscribeToCluster("root");
+    assertThat(xdsDependencyManager.buildUpdate().getValue()).isEqualTo(initialConfig);
+    Closeable clusterAB11Sub = xdsDependencyManager.subscribeToCluster("clusterAB11");
+    assertThat(xdsDependencyManager.buildUpdate().getValue()).isEqualTo(initialConfig);
+
+    // Make sure that closing subscriptions that rds points at doesn't change the config
+    rootSub.close();
+    assertThat(xdsDependencyManager.buildUpdate().getValue()).isEqualTo(initialConfig);
+    clusterAB11Sub.close();
+    assertThat(xdsDependencyManager.buildUpdate().getValue()).isEqualTo(initialConfig);
+
+    // Make an explicit root subscription and then change RDS to point to A11
+    rootSub = xdsDependencyManager.subscribeToCluster("root");
+    RouteConfiguration newRouteConfig =
+        XdsTestUtils.buildRouteConfiguration(serverName, XdsTestUtils.RDS_NAME, "clusterA11");
+    controlPlaneService.setXdsConfig(
+        ADS_TYPE_URL_RDS, ImmutableMap.of(XdsTestUtils.RDS_NAME, newRouteConfig));
+    inOrder.verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    assertThat(xdsUpdateCaptor.getValue().getValue().getClusters()).hasSize(8);
+
+    // Now that it is released, we should only have A11
+    rootSub.close();
+    inOrder.verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    assertThat(xdsUpdateCaptor.getValue().getValue().getClusters().keySet())
+        .containsExactly("clusterA11");
+  }
+
+  @Test
+  public void testCdsDeleteUnsubscribesChild() throws Exception {
+    RouteConfiguration routeConfig =
+        XdsTestUtils.buildRouteConfiguration(serverName, XdsTestUtils.RDS_NAME, "clusterA");
+    Map<String, Message> clusterMap = new HashMap<>();
+    Map<String, Message> edsMap = new HashMap<>();
+    XdsTestUtils.addEdsClusters(clusterMap, edsMap, "clusterA");
+    controlPlaneService.setXdsConfig(
+        ADS_TYPE_URL_RDS, ImmutableMap.of(XdsTestUtils.RDS_NAME, routeConfig));
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, clusterMap);
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, edsMap);
+
+    InOrder inOrder = Mockito.inOrder(xdsConfigWatcher);
+    xdsDependencyManager.start(xdsConfigWatcher);
+    inOrder.verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    XdsConfig config = xdsUpdateCaptor.getValue().getValue();
+    assertThat(config.getClusters().get("clusterA").hasValue()).isTrue();
+    Map<XdsResourceType<?>, Map<String, ResourceMetadata>> watches =
+        xdsClient.getSubscribedResourcesMetadataSnapshot().get();
+    assertThat(watches.get(XdsEndpointResource.getInstance()).keySet())
+        .containsExactly("eds_clusterA");
+
+    // Delete cluster
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.of());
+    inOrder.verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    config = xdsUpdateCaptor.getValue().getValue();
+    assertThat(config.getClusters().get("clusterA").hasValue()).isFalse();
+    watches = xdsClient.getSubscribedResourcesMetadataSnapshot().get();
+    assertThat(watches).doesNotContainKey(XdsEndpointResource.getInstance());
+  }
+
+  @Test
+  public void testCdsCycleReclaimed() throws Exception {
+    RouteConfiguration routeConfig =
+        XdsTestUtils.buildRouteConfiguration(serverName, XdsTestUtils.RDS_NAME, "clusterA");
+    Map<String, Message> clusterMap = new HashMap<>();
+    Map<String, Message> edsMap = new HashMap<>();
+    clusterMap.put("clusterA", XdsTestUtils.buildAggCluster("clusterA", Arrays.asList("clusterB")));
+    clusterMap.put("clusterB", XdsTestUtils.buildAggCluster("clusterB", Arrays.asList("clusterA")));
+    XdsTestUtils.addEdsClusters(clusterMap, edsMap, "clusterC");
+    controlPlaneService.setXdsConfig(
+        ADS_TYPE_URL_RDS, ImmutableMap.of(XdsTestUtils.RDS_NAME, routeConfig));
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, clusterMap);
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, edsMap);
+
+    // The cycle is loaded and detected
+    InOrder inOrder = Mockito.inOrder(xdsConfigWatcher);
+    xdsDependencyManager.start(xdsConfigWatcher);
+    inOrder.verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    XdsConfig config = xdsUpdateCaptor.getValue().getValue();
+    assertThat(config.getClusters().get("clusterA").hasValue()).isFalse();
+    assertThat(config.getClusters().get("clusterA").getStatus().getDescription()).contains("cycle");
+    assertThat(config.getClusters().get("clusterB").hasValue()).isTrue();
+
+    // Orphan the cycle and it is discarded
+    routeConfig =
+        XdsTestUtils.buildRouteConfiguration(serverName, XdsTestUtils.RDS_NAME, "clusterC");
+    controlPlaneService.setXdsConfig(
+        ADS_TYPE_URL_RDS, ImmutableMap.of(XdsTestUtils.RDS_NAME, routeConfig));
+    inOrder.verify(xdsConfigWatcher).onUpdate(any());
+    Map<XdsResourceType<?>, Map<String, ResourceMetadata>> watches =
+        xdsClient.getSubscribedResourcesMetadataSnapshot().get();
+    assertThat(watches.get(XdsClusterResource.getInstance()).keySet()).containsExactly("clusterC");
+  }
+
+  @Test
+  public void testMultipleCdsReferToSameEds() {
+    // Create the maps and Update the config to have 2 clusters that refer to the same EDS resource
+    String edsName = "sharedEds";
+
+    Cluster rootCluster =
+        XdsTestUtils.buildAggCluster("root", Arrays.asList("clusterA", "clusterB"));
+    Cluster clusterA = ControlPlaneRule.buildCluster("clusterA", edsName);
+    Cluster clusterB = ControlPlaneRule.buildCluster("clusterB", edsName);
+
+    Map<String, Message> clusterMap = new HashMap<>();
+    clusterMap.put("root", rootCluster);
+    clusterMap.put("clusterA", clusterA);
+    clusterMap.put("clusterB", clusterB);
+
+    Map<String, Message> edsMap = new HashMap<>();
+    ClusterLoadAssignment clusterLoadAssignment = ControlPlaneRule.buildClusterLoadAssignment(
+        "127.0.1.4", ENDPOINT_HOSTNAME, ENDPOINT_PORT, edsName);
+    edsMap.put(edsName, clusterLoadAssignment);
+
+    RouteConfiguration routeConfig =
+        XdsTestUtils.buildRouteConfiguration(serverName, XdsTestUtils.RDS_NAME, "root");
+    controlPlaneService.setXdsConfig(
+        ADS_TYPE_URL_RDS, ImmutableMap.of(XdsTestUtils.RDS_NAME, routeConfig));
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, clusterMap);
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, edsMap);
+
+    // Start the actual test
+    xdsDependencyManager.start(xdsConfigWatcher);
+    verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    XdsConfig initialConfig = xdsUpdateCaptor.getValue().getValue();
+    assertThat(initialConfig.getClusters().keySet())
+        .containsExactly("root", "clusterA", "clusterB");
+
+    EdsUpdate edsForA = getEndpoint(initialConfig.getClusters().get("clusterA")).getValue();
+    assertThat(edsForA.clusterName).isEqualTo(edsName);
+    EdsUpdate edsForB = getEndpoint(initialConfig.getClusters().get("clusterB")).getValue();
+    assertThat(edsForB.clusterName).isEqualTo(edsName);
+    assertThat(edsForA).isEqualTo(edsForB);
+    edsForA.localityLbEndpointsMap.values().forEach(
+        localityLbEndpoints -> assertThat(localityLbEndpoints.endpoints()).hasSize(1));
+  }
+
+  @Test
+  public void testChangeRdsName_FromLds_complexTree() {
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    // Create the same tree as in testMultipleParentsInCdsTree
+    Cluster rootCluster =
+        XdsTestUtils.buildAggCluster("root", Arrays.asList("clusterA", "clusterB"));
+    Cluster clusterA =
+        XdsTestUtils.buildAggCluster("clusterA", Arrays.asList("clusterA1", "clusterAB1"));
+    Cluster clusterB =
+        XdsTestUtils.buildAggCluster("clusterB", Arrays.asList("clusterB1", "clusterAB1"));
+    Cluster clusterA1 =
+        XdsTestUtils.buildAggCluster("clusterA1", Arrays.asList("clusterA11", "clusterAB1"));
+    Cluster clusterAB1 =
+        XdsTestUtils.buildAggCluster("clusterAB1", Arrays.asList("clusterA11", "clusterAB11"));
+
+    Map<String, Message> clusterMap = new HashMap<>();
+    Map<String, Message> edsMap = new HashMap<>();
+
+    clusterMap.put("root", rootCluster);
+    clusterMap.put("clusterA", clusterA);
+    clusterMap.put("clusterB", clusterB);
+    clusterMap.put("clusterA1", clusterA1);
+    clusterMap.put("clusterAB1", clusterAB1);
+
+    XdsTestUtils.addEdsClusters(clusterMap, edsMap, "clusterA11", "clusterAB11", "clusterB1");
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, clusterMap);
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, edsMap);
+
+    InOrder inOrder = Mockito.inOrder(xdsConfigWatcher);
+    inOrder.verify(xdsConfigWatcher, atLeastOnce()).onUpdate(any());
+
+    // Do the test
+    String newRdsName = "newRdsName1";
+    Listener clientListener = buildInlineClientListener(newRdsName, "root");
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_LDS,
+        ImmutableMap.of(serverName, clientListener));
+    inOrder.verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    XdsConfig config = xdsUpdateCaptor.getValue().getValue();
+    assertThat(config.getVirtualHost().name()).isEqualTo(newRdsName);
+    assertThat(config.getClusters()).hasSize(8);
+  }
+
+  @Test
+  public void testChangeAggCluster() {
+    InOrder inOrder = Mockito.inOrder(xdsConfigWatcher);
+
+    xdsDependencyManager.start(xdsConfigWatcher);
+    inOrder.verify(xdsConfigWatcher).onUpdate(any());
+
+    // Setup initial config A -> A1 -> (A11, A12)
+    Cluster rootCluster =
+        XdsTestUtils.buildAggCluster("root", Arrays.asList("clusterA"));
+    Cluster clusterA =
+        XdsTestUtils.buildAggCluster("clusterA", Arrays.asList("clusterA1"));
+    Cluster clusterA1 =
+        XdsTestUtils.buildAggCluster("clusterA1", Arrays.asList("clusterA11", "clusterA12"));
+
+    Map<String, Message> clusterMap = new HashMap<>();
+    Map<String, Message> edsMap = new HashMap<>();
+
+    clusterMap.put("root", rootCluster);
+    clusterMap.put("clusterA", clusterA);
+    clusterMap.put("clusterA1", clusterA1);
+
+    XdsTestUtils.addEdsClusters(clusterMap, edsMap, "clusterA11", "clusterA12");
+    Listener clientListener = buildInlineClientListener(RDS_NAME, "root");
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_LDS,
+        ImmutableMap.of(serverName, clientListener));
+
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, clusterMap);
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, edsMap);
+
+    inOrder.verify(xdsConfigWatcher).onUpdate(any());
+
+    // Update the cluster to A -> A2 -> (A21, A22)
+    Cluster clusterA2 =
+        XdsTestUtils.buildAggCluster("clusterA2", Arrays.asList("clusterA21", "clusterA22"));
+    clusterA =
+        XdsTestUtils.buildAggCluster("clusterA", Arrays.asList("clusterA2"));
+    clusterMap.clear();
+    edsMap.clear();
+    clusterMap.put("root", rootCluster);
+    clusterMap.put("clusterA", clusterA);
+    clusterMap.put("clusterA2", clusterA2);
+    XdsTestUtils.addEdsClusters(clusterMap, edsMap, "clusterA21", "clusterA22");
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS, clusterMap);
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_EDS, edsMap);
+
+    // Verify that the config is updated as expected
+    ClusterNameMatcher nameMatcher = new ClusterNameMatcher(Arrays.asList(
+        "root", "clusterA", "clusterA2", "clusterA21", "clusterA22"));
+    inOrder.verify(xdsConfigWatcher).onUpdate(argThat(nameMatcher));
+  }
+
+  @Test
+  public void testLogicalDns_success() {
+    XdsDependencyManager.enableLogicalDns = true;
+    FakeSocketAddress fakeAddress = new FakeSocketAddress();
+    nameResolverRegistry.register(new FakeNameResolverProvider(
+        "dns:///dns.example.com:1111", fakeAddress));
+    Cluster cluster = Cluster.newBuilder()
+        .setName(CLUSTER_NAME)
+        .setType(Cluster.DiscoveryType.LOGICAL_DNS)
+        .setLoadAssignment(ClusterLoadAssignment.newBuilder()
+          .addEndpoints(LocalityLbEndpoints.newBuilder()
+            .addLbEndpoints(LbEndpoint.newBuilder()
+              .setEndpoint(Endpoint.newBuilder()
+                .setAddress(Address.newBuilder()
+                  .setSocketAddress(SocketAddress.newBuilder()
+                    .setAddress("dns.example.com")
+                    .setPortValue(1111)))))))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS,
+        ImmutableMap.of(CLUSTER_NAME, cluster));
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    XdsConfig config = xdsUpdateCaptor.getValue().getValue();
+    XdsClusterConfig.ClusterChild clusterChild =
+        config.getClusters().get(CLUSTER_NAME).getValue().getChildren();
+    assertThat(clusterChild).isInstanceOf(XdsClusterConfig.EndpointConfig.class);
+    StatusOr<EdsUpdate> endpointOr = ((XdsClusterConfig.EndpointConfig) clusterChild).getEndpoint();
+    assertThat(endpointOr.getStatus()).isEqualTo(Status.OK);
+    assertThat(endpointOr.getValue()).isEqualTo(new EdsUpdate(
+        "fakeEds_logicalDns",
+        ImmutableMap.of(
+            Locality.create("", "", ""),
+            Endpoints.LocalityLbEndpoints.create(
+                Arrays.asList(Endpoints.LbEndpoint.create(
+                    new EquivalentAddressGroup(fakeAddress),
+                    1, true, "dns.example.com:1111", ImmutableMap.of())),
+                1, 0, ImmutableMap.of())),
+        Arrays.asList()));
+  }
+
+  @Test
+  public void testLogicalDns_noDnsNr() {
+    XdsDependencyManager.enableLogicalDns = true;
+    Cluster cluster = Cluster.newBuilder()
+        .setName(CLUSTER_NAME)
+        .setType(Cluster.DiscoveryType.LOGICAL_DNS)
+        .setLoadAssignment(ClusterLoadAssignment.newBuilder()
+          .addEndpoints(LocalityLbEndpoints.newBuilder()
+            .addLbEndpoints(LbEndpoint.newBuilder()
+              .setEndpoint(Endpoint.newBuilder()
+                .setAddress(Address.newBuilder()
+                  .setSocketAddress(SocketAddress.newBuilder()
+                    .setAddress("dns.example.com")
+                    .setPortValue(1111)))))))
+        .build();
+    controlPlaneService.setXdsConfig(ADS_TYPE_URL_CDS,
+        ImmutableMap.of(CLUSTER_NAME, cluster));
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    XdsConfig config = xdsUpdateCaptor.getValue().getValue();
+    XdsClusterConfig.ClusterChild clusterChild =
+        config.getClusters().get(CLUSTER_NAME).getValue().getChildren();
+    assertThat(clusterChild).isInstanceOf(XdsClusterConfig.EndpointConfig.class);
+    StatusOr<EdsUpdate> endpointOr = ((XdsClusterConfig.EndpointConfig) clusterChild).getEndpoint();
+    assertThat(endpointOr.getStatus().getCode()).isEqualTo(Status.Code.INTERNAL);
+    assertThat(endpointOr.getStatus().getDescription())
+        .isEqualTo("Could not find dns name resolver");
+  }
+
+  @Test
+  public void testCdsError() throws IOException {
+    controlPlaneService.setXdsConfig(
+        ADS_TYPE_URL_CDS, ImmutableMap.of(XdsTestUtils.CLUSTER_NAME,
+          Cluster.newBuilder().setName(XdsTestUtils.CLUSTER_NAME).build()));
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    verify(xdsConfigWatcher).onUpdate(xdsUpdateCaptor.capture());
+    Status status = xdsUpdateCaptor.getValue().getValue()
+        .getClusters().get(CLUSTER_NAME).getStatus();
+    assertThat(status.getDescription()).contains(XdsTestUtils.CLUSTER_NAME);
+  }
+
+  @Test
+  public void ldsUpdateAfterShutdown() {
+    XdsTestUtils.setAdsConfig(controlPlaneService, serverName, "RDS", "CDS", "EDS",
+        ENDPOINT_HOSTNAME, ENDPOINT_PORT);
+
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    verify(xdsConfigWatcher).onUpdate(any());
+
+    @SuppressWarnings("unchecked")
+    XdsClient.ResourceWatcher<XdsListenerResource.LdsUpdate> resourceWatcher =
+        mock(XdsClient.ResourceWatcher.class);
+    xdsClient.watchXdsResource(
+        XdsListenerResource.getInstance(),
+        serverName,
+        resourceWatcher,
+        MoreExecutors.directExecutor());
+    verify(resourceWatcher).onResourceChanged(argThat(StatusOr::hasValue));
+
+    syncContext.execute(() -> {
+      // Shutdown before any updates. This will unsubscribe from XdsClient, but only after this
+      // Runnable returns
+      xdsDependencyManager.shutdown();
+
+      XdsTestUtils.setAdsConfig(controlPlaneService, serverName, "RDS2", "CDS", "EDS",
+          ENDPOINT_HOSTNAME, ENDPOINT_PORT);
+      verify(resourceWatcher, times(2)).onResourceChanged(argThat(StatusOr::hasValue));
+      xdsClient.cancelXdsResourceWatch(
+          XdsListenerResource.getInstance(), serverName, resourceWatcher);
+    });
+  }
+
+  @Test
+  public void rdsUpdateAfterShutdown() {
+    XdsTestUtils.setAdsConfig(controlPlaneService, serverName, "RDS", "CDS", "EDS",
+        ENDPOINT_HOSTNAME, ENDPOINT_PORT);
+
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    verify(xdsConfigWatcher).onUpdate(any());
+
+    @SuppressWarnings("unchecked")
+    XdsClient.ResourceWatcher<XdsRouteConfigureResource.RdsUpdate> resourceWatcher =
+        mock(XdsClient.ResourceWatcher.class);
+    xdsClient.watchXdsResource(
+        XdsRouteConfigureResource.getInstance(),
+        "RDS",
+        resourceWatcher,
+        MoreExecutors.directExecutor());
+    verify(resourceWatcher).onResourceChanged(argThat(StatusOr::hasValue));
+
+    syncContext.execute(() -> {
+      // Shutdown before any updates. This will unsubscribe from XdsClient, but only after this
+      // Runnable returns
+      xdsDependencyManager.shutdown();
+
+      XdsTestUtils.setAdsConfig(controlPlaneService, serverName, "RDS", "CDS2", "EDS",
+          ENDPOINT_HOSTNAME, ENDPOINT_PORT);
+      verify(resourceWatcher, times(2)).onResourceChanged(argThat(StatusOr::hasValue));
+      xdsClient.cancelXdsResourceWatch(
+          XdsRouteConfigureResource.getInstance(), serverName, resourceWatcher);
+    });
+  }
+
+  @Test
+  public void cdsUpdateAfterShutdown() {
+    XdsTestUtils.setAdsConfig(controlPlaneService, serverName, "RDS", "CDS", "EDS",
+        ENDPOINT_HOSTNAME, ENDPOINT_PORT);
+
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    verify(xdsConfigWatcher).onUpdate(any());
+
+    @SuppressWarnings("unchecked")
+    XdsClient.ResourceWatcher<CdsUpdate> resourceWatcher =
+        mock(XdsClient.ResourceWatcher.class);
+    xdsClient.watchXdsResource(
+        XdsClusterResource.getInstance(),
+        "CDS",
+        resourceWatcher,
+        MoreExecutors.directExecutor());
+    verify(resourceWatcher).onResourceChanged(argThat(StatusOr::hasValue));
+
+    syncContext.execute(() -> {
+      // Shutdown before any updates. This will unsubscribe from XdsClient, but only after this
+      // Runnable returns
+      xdsDependencyManager.shutdown();
+
+      XdsTestUtils.setAdsConfig(controlPlaneService, serverName, "RDS", "CDS", "EDS2",
+          ENDPOINT_HOSTNAME, ENDPOINT_PORT);
+      verify(resourceWatcher, times(2)).onResourceChanged(argThat(StatusOr::hasValue));
+      xdsClient.cancelXdsResourceWatch(
+          XdsClusterResource.getInstance(), serverName, resourceWatcher);
+    });
+  }
+
+  @Test
+  public void edsUpdateAfterShutdown() {
+    XdsTestUtils.setAdsConfig(controlPlaneService, serverName, "RDS", "CDS", "EDS",
+        ENDPOINT_HOSTNAME, ENDPOINT_PORT);
+
+    xdsDependencyManager.start(xdsConfigWatcher);
+
+    verify(xdsConfigWatcher).onUpdate(any());
+
+    @SuppressWarnings("unchecked")
+    XdsClient.ResourceWatcher<XdsEndpointResource.EdsUpdate> resourceWatcher =
+        mock(XdsClient.ResourceWatcher.class);
+    xdsClient.watchXdsResource(
+        XdsEndpointResource.getInstance(),
+        "EDS",
+        resourceWatcher,
+        MoreExecutors.directExecutor());
+    verify(resourceWatcher).onResourceChanged(argThat(StatusOr::hasValue));
+
+    syncContext.execute(() -> {
+      // Shutdown before any updates. This will unsubscribe from XdsClient, but only after this
+      // Runnable returns
+      xdsDependencyManager.shutdown();
+
+      XdsTestUtils.setAdsConfig(controlPlaneService, serverName, "RDS", "CDS", "EDS",
+          ENDPOINT_HOSTNAME + "2", ENDPOINT_PORT);
+      verify(resourceWatcher, times(2)).onResourceChanged(argThat(StatusOr::hasValue));
+      xdsClient.cancelXdsResourceWatch(
+          XdsEndpointResource.getInstance(), serverName, resourceWatcher);
+    });
+  }
+
+  @Test
+  public void subscribeToClusterAfterShutdown() throws Exception {
+    XdsTestUtils.setAdsConfig(controlPlaneService, serverName, "RDS", "CDS", "EDS",
+        ENDPOINT_HOSTNAME, ENDPOINT_PORT);
+
+    InOrder inOrder = Mockito.inOrder(xdsConfigWatcher);
+    xdsDependencyManager.start(xdsConfigWatcher);
+    inOrder.verify(xdsConfigWatcher).onUpdate(any());
+    xdsDependencyManager.shutdown();
+
+    Closeable subscription = xdsDependencyManager.subscribeToCluster("CDS");
+    inOrder.verify(xdsConfigWatcher, never()).onUpdate(any());
+    subscription.close();
+  }
+
+  private Listener buildInlineClientListener(String rdsName, String clusterName) {
+    return XdsTestUtils.buildInlineClientListener(rdsName, clusterName, serverName);
+  }
+
+  private static class TestWatcher implements XdsDependencyManager.XdsConfigWatcher {
+    XdsConfig lastConfig;
+    int numUpdates = 0;
+    int numError = 0;
+
+    @Override
+    public void onUpdate(StatusOr<XdsConfig> update) {
+      log.fine("Config update: " + update);
+      if (update.hasValue()) {
+        lastConfig = update.getValue();
+        numUpdates++;
+      } else {
+        numError++;
+      }
+    }
+
+    private List<Integer> getStats() {
+      return Arrays.asList(numUpdates, numError);
+    }
+
+    private void verifyStats(int updt, int err) {
+      assertThat(getStats()).isEqualTo(Arrays.asList(updt, err));
+    }
+  }
+
+  static class ClusterNameMatcher implements ArgumentMatcher<StatusOr<XdsConfig>> {
+    private final List<String> expectedNames;
+
+    ClusterNameMatcher(List<String> expectedNames) {
+      this.expectedNames = expectedNames;
+    }
+
+    @Override
+    public boolean matches(StatusOr<XdsConfig> update) {
+      if (!update.hasValue()) {
+        return false;
+      }
+      XdsConfig xdsConfig = update.getValue();
+      if (xdsConfig == null || xdsConfig.getClusters() == null) {
+        return false;
+      }
+      return xdsConfig.getClusters().size() == expectedNames.size()
+          && xdsConfig.getClusters().keySet().containsAll(expectedNames);
+    }
+  }
+
+  private static class FakeSocketAddress extends java.net.SocketAddress {}
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsNameResolverProviderTest.java b/xds/src/test/java/io/grpc/xds/XdsNameResolverProviderTest.java
new file mode 100644
index 00000000000..33aae268c60
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsNameResolverProviderTest.java
@@ -0,0 +1,179 @@
+/*
+ * Copyright 2019 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+import com.google.common.collect.ImmutableMap;
+import io.grpc.ChannelLogger;
+import io.grpc.InternalServiceProviders;
+import io.grpc.MetricRecorder;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.NameResolverProvider;
+import io.grpc.NameResolverRegistry;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GrpcUtil;
+import java.net.URI;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link XdsNameResolverProvider}. */
+@RunWith(JUnit4.class)
+public class XdsNameResolverProviderTest {
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+
+  private final FakeClock fakeClock = new FakeClock();
+  private final NameResolver.Args args = NameResolver.Args.newBuilder()
+      .setDefaultPort(8080)
+      .setProxyDetector(GrpcUtil.NOOP_PROXY_DETECTOR)
+      .setSynchronizationContext(syncContext)
+      .setServiceConfigParser(mock(ServiceConfigParser.class))
+      .setScheduledExecutorService(fakeClock.getScheduledExecutorService())
+      .setChannelLogger(mock(ChannelLogger.class))
+      .setMetricRecorder(mock(MetricRecorder.class))
+      .build();
+
+  private XdsNameResolverProvider provider = new XdsNameResolverProvider();
+
+  @Test
+  public void provided() {
+    for (NameResolverProvider current
+        : InternalServiceProviders.getCandidatesViaServiceLoader(
+        NameResolverProvider.class, getClass().getClassLoader())) {
+      if (current instanceof XdsNameResolverProvider) {
+        return;
+      }
+    }
+    fail("XdsNameResolverProvider not registered");
+  }
+
+  @Test
+  public void isAvailable() {
+    assertThat(provider.isAvailable()).isTrue();
+  }
+
+  @Test
+  public void newNameResolver() {
+    assertThat(
+        provider.newNameResolver(URI.create("xds://1.1.1.1/foo.googleapis.com"), args))
+        .isInstanceOf(XdsNameResolver.class);
+    assertThat(
+        provider.newNameResolver(URI.create("xds:///foo.googleapis.com"), args))
+        .isInstanceOf(XdsNameResolver.class);
+    assertThat(
+        provider.newNameResolver(URI.create("notxds://1.1.1.1/foo.googleapis.com"),
+            args))
+        .isNull();
+  }
+
+  @Test
+  public void validName_withAuthority() {
+    XdsNameResolver resolver =
+        provider.newNameResolver(
+            URI.create("xds://trafficdirector.google.com/foo.googleapis.com"), args);
+    assertThat(resolver).isNotNull();
+    assertThat(resolver.getServiceAuthority()).isEqualTo("foo.googleapis.com");
+  }
+
+  @Test
+  public void validName_noAuthority() {
+    XdsNameResolver resolver =
+        provider.newNameResolver(URI.create("xds:///foo.googleapis.com"), args);
+    assertThat(resolver).isNotNull();
+    assertThat(resolver.getServiceAuthority()).isEqualTo("foo.googleapis.com");
+  }
+
+  @Test
+  public void validName_urlExtractedAuthorityInvalidWithoutEncoding() {
+    XdsNameResolver resolver = 
+        provider.newNameResolver(URI.create("xds:///1234/path/foo.googleapis.com:8080"), args);
+    assertThat(resolver).isNotNull();
+    assertThat(resolver.getServiceAuthority()).isEqualTo("1234%2Fpath%2Ffoo.googleapis.com:8080");
+  }
+
+  @Test
+  public void validName_urlwithTargetAuthorityAndExtractedAuthorityInvalidWithoutEncoding() {
+    XdsNameResolver resolver = provider.newNameResolver(URI.create(
+        "xds://trafficdirector.google.com/1234/path/foo.googleapis.com:8080"), args);
+    assertThat(resolver).isNotNull();
+    assertThat(resolver.getServiceAuthority()).isEqualTo("1234%2Fpath%2Ffoo.googleapis.com:8080");
+  }
+
+  @Test
+  public void newProvider_multipleScheme() {
+    NameResolverRegistry registry = NameResolverRegistry.getDefaultRegistry();
+    XdsNameResolverProvider provider0 = XdsNameResolverProvider.createForTest("no-scheme", null);
+    registry.register(provider0);
+    XdsNameResolverProvider provider1 = XdsNameResolverProvider.createForTest("new-xds-scheme",
+            new HashMap<String, String>());
+    registry.register(provider1);
+    assertThat(registry.asFactory()
+            .newNameResolver(URI.create("xds:///localhost"), args)).isNotNull();
+    assertThat(registry.asFactory()
+            .newNameResolver(URI.create("new-xds-scheme:///localhost"), args)).isNotNull();
+    assertThat(registry.asFactory()
+            .newNameResolver(URI.create("no-scheme:///localhost"), args)).isNotNull();
+    registry.deregister(provider1);
+    assertThat(registry.asFactory()
+            .newNameResolver(URI.create("new-xds-scheme:///localhost"), args)).isNull();
+    registry.deregister(provider0);
+    assertThat(registry.asFactory()
+            .newNameResolver(URI.create("xds:///localhost"), args)).isNotNull();
+  }
+
+  @Test
+  public void newProvider_overrideBootstrap() {
+    Map<String, ?> b = ImmutableMap.of(
+            "node", ImmutableMap.of(
+                    "id", "ENVOY_NODE_ID",
+                    "cluster", "ENVOY_CLUSTER"),
+            "xds_servers", Collections.singletonList(
+                    ImmutableMap.of(
+                            "server_uri", "trafficdirector.googleapis.com:443",
+                            "channel_creds", Collections.singletonList(
+                                    ImmutableMap.of("type", "insecure")
+                            )
+                    )
+            )
+    );
+    NameResolverRegistry registry = new NameResolverRegistry();
+    XdsNameResolverProvider provider = XdsNameResolverProvider.createForTest("no-scheme", b);
+    registry.register(provider);
+    NameResolver resolver = registry.asFactory()
+            .newNameResolver(URI.create("no-scheme:///localhost"), args);
+    resolver.start(mock(NameResolver.Listener2.class));
+    assertThat(resolver).isInstanceOf(XdsNameResolver.class);
+    assertThat(((XdsNameResolver)resolver).getXdsClient().getBootstrapInfo().node().getId())
+            .isEqualTo("ENVOY_NODE_ID");
+    resolver.shutdown();
+    registry.deregister(provider);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsNameResolverTest.java b/xds/src/test/java/io/grpc/xds/XdsNameResolverTest.java
new file mode 100644
index 00000000000..45a96ee172f
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsNameResolverTest.java
@@ -0,0 +1,2934 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static io.grpc.xds.FaultFilter.HEADER_ABORT_GRPC_STATUS_KEY;
+import static io.grpc.xds.FaultFilter.HEADER_ABORT_HTTP_STATUS_KEY;
+import static io.grpc.xds.FaultFilter.HEADER_ABORT_PERCENTAGE_KEY;
+import static io.grpc.xds.FaultFilter.HEADER_DELAY_KEY;
+import static io.grpc.xds.FaultFilter.HEADER_DELAY_PERCENTAGE_KEY;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.lenient;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.MoreObjects;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.protobuf.util.Durations;
+import com.google.re2j.Pattern;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ChannelLogger;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientInterceptors;
+import io.grpc.Deadline;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InternalConfigSelector;
+import io.grpc.InternalConfigSelector.Result;
+import io.grpc.LoadBalancer.PickDetailsConsumer;
+import io.grpc.LoadBalancer.PickSubchannelArgs;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.MetricRecorder;
+import io.grpc.NameResolver;
+import io.grpc.NameResolver.ConfigOrError;
+import io.grpc.NameResolver.ResolutionResult;
+import io.grpc.NameResolver.ServiceConfigParser;
+import io.grpc.NoopClientCall;
+import io.grpc.NoopClientCall.NoopClientCallListener;
+import io.grpc.Status;
+import io.grpc.Status.Code;
+import io.grpc.StatusOr;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.AutoConfiguredLoadBalancerFactory;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.GrpcUtil;
+import io.grpc.internal.JsonParser;
+import io.grpc.internal.JsonUtil;
+import io.grpc.internal.ObjectPool;
+import io.grpc.internal.PickSubchannelArgsImpl;
+import io.grpc.internal.ScParser;
+import io.grpc.testing.TestMethodDescriptors;
+import io.grpc.xds.ClusterSpecifierPlugin.NamedPluginConfig;
+import io.grpc.xds.FaultConfig.FaultAbort;
+import io.grpc.xds.FaultConfig.FaultDelay;
+import io.grpc.xds.Filter.FilterConfig;
+import io.grpc.xds.Filter.NamedFilterConfig;
+import io.grpc.xds.RouteLookupServiceClusterSpecifierPlugin.RlsPluginConfig;
+import io.grpc.xds.VirtualHost.Route;
+import io.grpc.xds.VirtualHost.Route.RouteAction;
+import io.grpc.xds.VirtualHost.Route.RouteAction.ClusterWeight;
+import io.grpc.xds.VirtualHost.Route.RouteAction.HashPolicy;
+import io.grpc.xds.VirtualHost.Route.RouteAction.RetryPolicy;
+import io.grpc.xds.VirtualHost.Route.RouteMatch;
+import io.grpc.xds.VirtualHost.Route.RouteMatch.PathMatcher;
+import io.grpc.xds.XdsClusterResource.CdsUpdate;
+import io.grpc.xds.XdsEndpointResource.EdsUpdate;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.XdsRouteConfigureResource.RdsUpdate;
+import io.grpc.xds.client.Bootstrapper.AuthorityInfo;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsResourceType;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.Executor;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import javax.annotation.Nullable;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for {@link XdsNameResolver}. */
+// TODO(chengyuanzhang): should do tests with ManagedChannelImpl.
+@RunWith(JUnit4.class)
+public class XdsNameResolverTest {
+  private static final String AUTHORITY = "foo.googleapis.com:80";
+  private static final String RDS_RESOURCE_NAME = "route-configuration.googleapis.com";
+  private static final String FAULT_FILTER_INSTANCE_NAME = "envoy.fault";
+  private static final String ROUTER_FILTER_INSTANCE_NAME = "envoy.router";
+  private static final FaultFilter.Provider FAULT_FILTER_PROVIDER = new FaultFilter.Provider();
+  private static final RouterFilter.Provider ROUTER_FILTER_PROVIDER = new RouterFilter.Provider();
+
+  // Readability: makes it simpler to distinguish resource parameters.
+  private static final ImmutableMap<String, FilterConfig> NO_FILTER_OVERRIDES = ImmutableMap.of();
+  private static final ImmutableList<HashPolicy> NO_HASH_POLICIES = ImmutableList.of();
+
+  // Stateful instance filter names.
+  private static final String STATEFUL_1 = "test.stateful.filter.1";
+  private static final String STATEFUL_2 = "test.stateful.filter.2";
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+  private final FakeClock fakeClock = new FakeClock();
+  private final ScheduledExecutorService scheduler = fakeClock.getScheduledExecutorService();
+  private final ServiceConfigParser serviceConfigParser = new ServiceConfigParser() {
+    @Override
+    public ConfigOrError parseServiceConfig(Map<String, ?> rawServiceConfig) {
+      return ConfigOrError.fromConfig(rawServiceConfig);
+    }
+  };
+  private final FakeXdsClientPoolFactory xdsClientPoolFactory = new FakeXdsClientPoolFactory();
+  private final String cluster1 = "cluster-foo.googleapis.com";
+  private final String cluster2 = "cluster-bar.googleapis.com";
+  private final CallInfo call1 = new CallInfo("HelloService", "hi");
+  private final CallInfo call2 = new CallInfo("GreetService", "bye");
+  private final TestChannel channel = new TestChannel();
+  private final MetricRecorder metricRecorder = new MetricRecorder() {};
+  private final Map<String, ?> rawBootstrap = ImmutableMap.of(
+      "xds_servers", ImmutableList.of(
+          ImmutableMap.of(
+              "server_uri", "td.googleapis.com",
+              "channel_creds", ImmutableList.of(
+                  ImmutableMap.of(
+                      "type", "insecure")))
+      ));
+
+  private BootstrapInfo bootstrapInfo = BootstrapInfo.builder()
+      .servers(ImmutableList.of(ServerInfo.create(
+          "td.googleapis.com", InsecureChannelCredentials.create())))
+      .node(Node.newBuilder().build())
+      .build();
+  private String expectedLdsResourceName = AUTHORITY;
+
+  @Mock
+  private ThreadSafeRandom mockRandom;
+  @Mock
+  private NameResolver.Listener2 mockListener;
+  @Captor
+  private ArgumentCaptor<ResolutionResult> resolutionResultCaptor;
+  @Captor
+  ArgumentCaptor<Status> errorCaptor;
+  private XdsNameResolver resolver;
+  private TestCall<?, ?> testCall;
+  private boolean originalEnableTimeout;
+  private URI targetUri;
+  private final NameResolver.Args nameResolverArgs = NameResolver.Args.newBuilder()
+      .setDefaultPort(8080)
+      .setProxyDetector(GrpcUtil.DEFAULT_PROXY_DETECTOR)
+      .setSynchronizationContext(syncContext)
+      .setServiceConfigParser(mock(NameResolver.ServiceConfigParser.class))
+      .setChannelLogger(mock(ChannelLogger.class))
+      .setScheduledExecutorService(fakeClock.getScheduledExecutorService())
+      .build();
+
+
+  @Before
+  public void setUp() {
+    lenient().doReturn(Status.OK).when(mockListener).onResult2(any());
+
+    try {
+      targetUri = new URI(AUTHORITY);
+    } catch (URISyntaxException e) {
+      targetUri = null;
+    }
+
+    originalEnableTimeout = XdsNameResolver.enableTimeout;
+    XdsNameResolver.enableTimeout = true;
+
+    // Replace FaultFilter.Provider with the one returning FaultFilter injected with mockRandom.
+    Filter.Provider faultFilterProvider =
+        mock(Filter.Provider.class, delegatesTo(FAULT_FILTER_PROVIDER));
+    // Lenient: suppress [MockitoHint] Unused warning, only used in resolved_fault* tests.
+    lenient()
+        .doReturn(new FaultFilter(mockRandom, new AtomicLong()))
+        .when(faultFilterProvider).newInstance(any(String.class));
+
+    FilterRegistry filterRegistry = FilterRegistry.newRegistry().register(
+        ROUTER_FILTER_PROVIDER,
+        faultFilterProvider);
+
+    resolver = new XdsNameResolver(targetUri, null, AUTHORITY, null,
+        serviceConfigParser, syncContext, scheduler,
+        xdsClientPoolFactory, mockRandom, filterRegistry, rawBootstrap, metricRecorder,
+        nameResolverArgs);
+  }
+
+  @After
+  public void tearDown() {
+    XdsNameResolver.enableTimeout = originalEnableTimeout;
+    if (resolver == null) {
+      // Allow tests to test shutdown.
+      return;
+    }
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    resolver.shutdown();
+    if (xdsClient != null) {
+      assertThat(xdsClient.ldsWatcher).isNull();
+      assertThat(xdsClient.rdsWatchers).isEmpty();
+    }
+  }
+
+  @Test
+  public void resolving_failToCreateXdsClientPool() {
+    resolver = new XdsNameResolver(targetUri, null, AUTHORITY, null,
+        serviceConfigParser, syncContext, scheduler,
+        xdsClientPoolFactory, mockRandom, FilterRegistry.getDefaultRegistry(),
+        Collections.emptyMap(), metricRecorder, nameResolverArgs);
+    resolver.start(mockListener);
+    verify(mockListener).onError(errorCaptor.capture());
+    Status error = errorCaptor.getValue();
+    assertThat(error.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(error.getDescription()).isEqualTo("Failed to initialize xDS");
+    assertThat(error.getCause()).hasMessageThat().contains("Invalid bootstrap");
+  }
+
+  @Test
+  public void resolving_withTargetAuthorityNotFound() {
+    resolver = new XdsNameResolver(targetUri,
+        "notfound.google.com", AUTHORITY, null, serviceConfigParser, syncContext, scheduler,
+        xdsClientPoolFactory, mockRandom, FilterRegistry.getDefaultRegistry(), rawBootstrap,
+        metricRecorder, nameResolverArgs);
+    resolver.start(mockListener);
+    verify(mockListener).onError(errorCaptor.capture());
+    Status error = errorCaptor.getValue();
+    assertThat(error.getCode()).isEqualTo(Code.INVALID_ARGUMENT);
+    assertThat(error.getDescription()).isEqualTo(
+        "invalid target URI: target authority not found in the bootstrap");
+  }
+
+  @Test
+  public void resolving_noTargetAuthority_templateWithoutXdstp() {
+    bootstrapInfo = BootstrapInfo.builder()
+        .servers(ImmutableList.of(ServerInfo.create(
+            "td.googleapis.com", InsecureChannelCredentials.create())))
+        .node(Node.newBuilder().build())
+        .clientDefaultListenerResourceNameTemplate("%s/id=1")
+        .build();
+    String serviceAuthority = "[::FFFF:129.144.52.38]:80";
+    expectedLdsResourceName = "[::FFFF:129.144.52.38]:80/id=1";
+    resolver = new XdsNameResolver(
+        targetUri, null, serviceAuthority, null, serviceConfigParser, syncContext,
+        scheduler, xdsClientPoolFactory,
+        mockRandom, FilterRegistry.getDefaultRegistry(), rawBootstrap, metricRecorder,
+        nameResolverArgs);
+    resolver.start(mockListener);
+    verify(mockListener, never()).onError(any(Status.class));
+  }
+
+  @Test
+  public void resolving_noTargetAuthority_templateWithXdstp() {
+    bootstrapInfo = BootstrapInfo.builder()
+        .servers(ImmutableList.of(ServerInfo.create(
+            "td.googleapis.com", InsecureChannelCredentials.create())))
+        .node(Node.newBuilder().build())
+        .clientDefaultListenerResourceNameTemplate(
+            "xdstp://xds.authority.com/envoy.config.listener.v3.Listener/%s?id=1")
+        .build();
+    String serviceAuthority = "[::FFFF:129.144.52.38]:80";
+    expectedLdsResourceName =
+        "xdstp://xds.authority.com/envoy.config.listener.v3.Listener/"
+            + "%5B::FFFF:129.144.52.38%5D:80?id=1";
+    resolver = new XdsNameResolver(
+        targetUri, null, serviceAuthority, null, serviceConfigParser, syncContext, scheduler,
+        xdsClientPoolFactory, mockRandom, FilterRegistry.getDefaultRegistry(), rawBootstrap,
+        metricRecorder, nameResolverArgs);
+    resolver.start(mockListener);
+    verify(mockListener, never()).onError(any(Status.class));
+  }
+
+  @Test
+  public void resolving_noTargetAuthority_xdstpWithMultipleSlashes() {
+    bootstrapInfo = BootstrapInfo.builder()
+        .servers(ImmutableList.of(ServerInfo.create(
+            "td.googleapis.com", InsecureChannelCredentials.create())))
+        .node(Node.newBuilder().build())
+        .clientDefaultListenerResourceNameTemplate(
+            "xdstp://xds.authority.com/envoy.config.listener.v3.Listener/%s?id=1")
+        .build();
+    String serviceAuthority = "path/to/service";
+    expectedLdsResourceName =
+        "xdstp://xds.authority.com/envoy.config.listener.v3.Listener/"
+            + "path/to/service?id=1";
+    resolver = new XdsNameResolver(
+        targetUri, null, serviceAuthority, null, serviceConfigParser, syncContext, scheduler,
+        xdsClientPoolFactory, mockRandom, FilterRegistry.getDefaultRegistry(), rawBootstrap,
+        metricRecorder, nameResolverArgs);
+
+
+    // The Service Authority must be URL encoded, but unlike the LDS resource name.
+    assertThat(resolver.getServiceAuthority()).isEqualTo("path%2Fto%2Fservice");
+
+    resolver.start(mockListener);
+    verify(mockListener, never()).onError(any(Status.class));
+  }
+
+  @Test
+  public void resolving_targetAuthorityInAuthoritiesMap() {
+    String targetAuthority = "xds.authority.com";
+    String serviceAuthority = "[::FFFF:129.144.52.38]:80";
+    bootstrapInfo = BootstrapInfo.builder()
+        .servers(ImmutableList.of(ServerInfo.create(
+            "td.googleapis.com", InsecureChannelCredentials.create(), true, true, false, false)))
+        .node(Node.newBuilder().build())
+        .authorities(
+            ImmutableMap.of(targetAuthority, AuthorityInfo.create(
+                "xdstp://" + targetAuthority + "/envoy.config.listener.v3.Listener/%s?foo=1&bar=2",
+                ImmutableList.of(ServerInfo.create(
+                    "td.googleapis.com", InsecureChannelCredentials.create(),
+                    true, true, false, false)))))
+        .build();
+    expectedLdsResourceName = "xdstp://xds.authority.com/envoy.config.listener.v3.Listener/"
+        + "%5B::FFFF:129.144.52.38%5D:80?bar=2&foo=1"; // query param canonified
+    resolver = new XdsNameResolver(targetUri,
+        "xds.authority.com", serviceAuthority, null, serviceConfigParser, syncContext, scheduler,
+        xdsClientPoolFactory, mockRandom, FilterRegistry.getDefaultRegistry(), rawBootstrap,
+        metricRecorder, nameResolverArgs);
+    resolver.start(mockListener);
+    verify(mockListener, never()).onError(any(Status.class));
+  }
+
+  @Test
+  public void resolving_ldsResourceNotFound() { // hi
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsResourceNotFound();
+    assertEmptyResolutionResult(expectedLdsResourceName);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void resolving_ldsResourceUpdateRdsName() {
+    Route route1 = Route.forAction(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+        RouteAction.forCluster(
+            cluster1, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L), null, false),
+        ImmutableMap.of());
+    Route route2 = Route.forAction(RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
+        RouteAction.forCluster(
+            cluster2, Collections.emptyList(), TimeUnit.SECONDS.toNanos(20L), null, false),
+        ImmutableMap.of());
+    bootstrapInfo = BootstrapInfo.builder()
+        .servers(ImmutableList.of(ServerInfo.create(
+            "td.googleapis.com", InsecureChannelCredentials.create())))
+        .clientDefaultListenerResourceNameTemplate("test-%s")
+        .node(Node.newBuilder().build())
+        .build();
+    resolver = new XdsNameResolver(targetUri, null, AUTHORITY, null,
+        serviceConfigParser, syncContext, scheduler,
+        xdsClientPoolFactory, mockRandom, FilterRegistry.getDefaultRegistry(), rawBootstrap,
+        metricRecorder, nameResolverArgs);
+    // use different ldsResourceName and service authority. The virtualhost lookup should use
+    // service authority.
+    expectedLdsResourceName = "test-" + expectedLdsResourceName;
+
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdateForRdsName(RDS_RESOURCE_NAME);
+    assertThat(xdsClient.rdsWatchers.keySet()).containsExactly(RDS_RESOURCE_NAME);
+    VirtualHost virtualHost =
+        VirtualHost.create("virtualhost", Collections.singletonList(AUTHORITY),
+            Collections.singletonList(route1),
+            ImmutableMap.of());
+    xdsClient.deliverRdsUpdate(RDS_RESOURCE_NAME, Collections.singletonList(virtualHost));
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    assertServiceConfigForLoadBalancingConfig(
+        Collections.singletonList(cluster1),
+        (Map<String, ?>) resolutionResultCaptor.getValue().getServiceConfig().getConfig());
+
+    reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
+    ArgumentCaptor<ResolutionResult> resultCaptor =
+        ArgumentCaptor.forClass(ResolutionResult.class);
+    String alternativeRdsResource = "route-configuration-alter.googleapis.com";
+    xdsClient.deliverLdsUpdateForRdsName(alternativeRdsResource);
+    assertThat(xdsClient.rdsWatchers.keySet()).contains(alternativeRdsResource);
+    virtualHost =
+        VirtualHost.create("virtualhost-alter", Collections.singletonList(AUTHORITY),
+            Collections.singletonList(route2),
+            ImmutableMap.of());
+    xdsClient.deliverRdsUpdate(alternativeRdsResource, Collections.singletonList(virtualHost));
+    createAndDeliverClusterUpdates(xdsClient, cluster2);
+    assertThat(xdsClient.rdsWatchers.keySet()).containsExactly(alternativeRdsResource);
+    // Two new service config updates triggered:
+    //  - with load balancing config being able to select cluster1 and cluster2
+    //  - with load balancing config being able to select cluster2 only
+    verify(mockListener, times(3)).onResult2(resultCaptor.capture());
+    assertServiceConfigForLoadBalancingConfig(
+        Arrays.asList(cluster1, cluster2),
+        (Map<String, ?>) resultCaptor.getAllValues().get(0).getServiceConfig().getConfig());
+    assertServiceConfigForLoadBalancingConfig(
+        Collections.singletonList(cluster2),
+        (Map<String, ?>) resultCaptor.getValue().getServiceConfig().getConfig());
+  }
+
+  @Test
+  public void resolving_rdsResourceNotFound() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdateForRdsName(RDS_RESOURCE_NAME);
+    xdsClient.deliverRdsResourceNotFound(RDS_RESOURCE_NAME);
+    assertEmptyResolutionResult(RDS_RESOURCE_NAME);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void resolving_ldsResourceRevokedAndAddedBack() {
+    Route route = Route.forAction(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+        RouteAction.forCluster(
+            cluster1, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L), null, false),
+        ImmutableMap.of());
+
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdateForRdsName(RDS_RESOURCE_NAME);
+    assertThat(xdsClient.rdsWatchers.keySet()).containsExactly(RDS_RESOURCE_NAME);
+    VirtualHost virtualHost =
+        VirtualHost.create("virtualhost", Collections.singletonList(AUTHORITY),
+            Collections.singletonList(route),
+            ImmutableMap.of());
+    xdsClient.deliverRdsUpdate(RDS_RESOURCE_NAME, Collections.singletonList(virtualHost));
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    assertServiceConfigForLoadBalancingConfig(
+        Collections.singletonList(cluster1),
+        (Map<String, ?>) resolutionResultCaptor.getValue().getServiceConfig().getConfig());
+
+    reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
+    xdsClient.deliverLdsResourceNotFound();  // revoke LDS resource
+    assertThat(xdsClient.rdsWatchers.keySet()).isEmpty();  // stop subscribing to stale RDS resource
+    assertEmptyResolutionResult(expectedLdsResourceName);
+
+    reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
+    xdsClient.deliverLdsUpdateForRdsName(RDS_RESOURCE_NAME);
+    // No name resolution result until new RDS resource update is received. Do not use stale config
+    verifyNoInteractions(mockListener);
+    assertThat(xdsClient.rdsWatchers.keySet()).containsExactly(RDS_RESOURCE_NAME);
+    xdsClient.deliverRdsUpdate(RDS_RESOURCE_NAME, Collections.singletonList(virtualHost));
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    assertServiceConfigForLoadBalancingConfig(
+        Collections.singletonList(cluster1),
+        (Map<String, ?>) resolutionResultCaptor.getValue().getServiceConfig().getConfig());
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void resolving_rdsResourceRevokedAndAddedBack() {
+    Route route = Route.forAction(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+        RouteAction.forCluster(
+            cluster1, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L), null, false),
+        ImmutableMap.of());
+
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdateForRdsName(RDS_RESOURCE_NAME);
+    assertThat(xdsClient.rdsWatchers.keySet()).containsExactly(RDS_RESOURCE_NAME);
+    VirtualHost virtualHost =
+        VirtualHost.create("virtualhost", Collections.singletonList(AUTHORITY),
+            Collections.singletonList(route),
+            ImmutableMap.of());
+    xdsClient.deliverRdsUpdate(RDS_RESOURCE_NAME, Collections.singletonList(virtualHost));
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    assertServiceConfigForLoadBalancingConfig(
+        Collections.singletonList(cluster1),
+        (Map<String, ?>) resolutionResultCaptor.getValue().getServiceConfig().getConfig());
+
+    reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
+    xdsClient.deliverRdsResourceNotFound(RDS_RESOURCE_NAME);  // revoke RDS resource
+    assertEmptyResolutionResult(RDS_RESOURCE_NAME);
+
+    // Simulate management server adds back the previously used RDS resource.
+    reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
+    xdsClient.deliverRdsUpdate(RDS_RESOURCE_NAME, Collections.singletonList(virtualHost));
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    assertServiceConfigForLoadBalancingConfig(
+        Collections.singletonList(cluster1),
+        (Map<String, ?>) resolutionResultCaptor.getValue().getServiceConfig().getConfig());
+  }
+
+  @Test
+  public void resolving_encounterErrorLdsWatcherOnly() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverError(Status.UNAVAILABLE.withDescription("server unreachable"));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    InternalConfigSelector configSelector = resolutionResultCaptor.getValue()
+        .getAttributes().get(InternalConfigSelector.KEY);
+    Result selectResult = configSelector.selectConfig(
+        newPickSubchannelArgs(call1.methodDescriptor, new Metadata(), CallOptions.DEFAULT));
+    Status error = selectResult.getStatus();
+    assertThat(error.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(error.getDescription()).contains(AUTHORITY);
+    assertThat(error.getDescription()).contains("server unreachable");
+  }
+
+  @Test
+  public void resolving_translateErrorLds() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverError(Status.NOT_FOUND.withDescription("server unreachable"));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    InternalConfigSelector configSelector = resolutionResultCaptor.getValue()
+        .getAttributes().get(InternalConfigSelector.KEY);
+    Result selectResult = configSelector.selectConfig(
+        newPickSubchannelArgs(call1.methodDescriptor, new Metadata(), CallOptions.DEFAULT));
+    Status error = selectResult.getStatus();
+    assertThat(error.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(error.getDescription()).contains(AUTHORITY);
+    assertThat(error.getDescription()).contains("server unreachable");
+    assertThat(error.getCause()).isNull();
+  }
+
+  @Test
+  public void resolving_encounterErrorLdsAndRdsWatchers() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdateForRdsName(RDS_RESOURCE_NAME);
+    xdsClient.deliverError(Status.UNAVAILABLE.withDescription("server unreachable"));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    InternalConfigSelector configSelector = resolutionResultCaptor.getValue()
+        .getAttributes().get(InternalConfigSelector.KEY);
+    Result selectResult = configSelector.selectConfig(
+        newPickSubchannelArgs(call1.methodDescriptor, new Metadata(), CallOptions.DEFAULT));
+    Status error = selectResult.getStatus();
+    assertThat(error.getCode()).isEqualTo(Code.UNAVAILABLE);
+    // XdsDepManager.buildUpdate doesn't allow this
+    // assertThat(error.getDescription()).contains(RDS_RESOURCE_NAME);
+    assertThat(error.getDescription()).contains(expectedLdsResourceName);
+    assertThat(error.getDescription()).contains("server unreachable");
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void resolving_matchingVirtualHostNotFound_matchingOverrideAuthority() {
+    Route route = Route.forAction(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+        RouteAction.forCluster(
+            cluster1, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L), null, false),
+        ImmutableMap.of());
+    VirtualHost virtualHost =
+        VirtualHost.create("virtualhost", Collections.singletonList("random"),
+            Collections.singletonList(route),
+            ImmutableMap.of());
+
+    resolver = new XdsNameResolver(targetUri, null, AUTHORITY, "random",
+        serviceConfigParser, syncContext, scheduler,
+        xdsClientPoolFactory, mockRandom, FilterRegistry.getDefaultRegistry(), rawBootstrap,
+        metricRecorder, nameResolverArgs);
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(0L, Arrays.asList(virtualHost));
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    assertServiceConfigForLoadBalancingConfig(
+        Collections.singletonList(cluster1),
+        (Map<String, ?>) resolutionResultCaptor.getValue().getServiceConfig().getConfig());
+  }
+
+  @Test
+  public void resolving_matchingVirtualHostNotFound_notMatchingOverrideAuthority() {
+    Route route = Route.forAction(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+        RouteAction.forCluster(
+            cluster1, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L), null, false),
+        ImmutableMap.of());
+    VirtualHost virtualHost =
+        VirtualHost.create("virtualhost", Collections.singletonList(AUTHORITY),
+            Collections.singletonList(route),
+            ImmutableMap.of());
+
+    resolver = new XdsNameResolver(targetUri, null, AUTHORITY, "random",
+        serviceConfigParser, syncContext, scheduler,
+        xdsClientPoolFactory, mockRandom, FilterRegistry.getDefaultRegistry(), rawBootstrap,
+        metricRecorder, nameResolverArgs);
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdateOnly(0L, Arrays.asList(virtualHost));
+    fakeClock.forwardTime(15, TimeUnit.SECONDS);
+    assertEmptyResolutionResult("random");
+  }
+
+  @Test
+  public void resolving_matchingVirtualHostNotFoundForOverrideAuthority() {
+    resolver = new XdsNameResolver(targetUri, null, AUTHORITY, AUTHORITY,
+        serviceConfigParser, syncContext, scheduler,
+        xdsClientPoolFactory, mockRandom, FilterRegistry.getDefaultRegistry(), rawBootstrap,
+        metricRecorder, nameResolverArgs);
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(0L, buildUnmatchedVirtualHosts());
+    assertEmptyResolutionResult(expectedLdsResourceName);
+  }
+
+  @Test
+  public void resolving_matchingVirtualHostNotFoundInLdsResource() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(0L, buildUnmatchedVirtualHosts());
+    assertEmptyResolutionResult(expectedLdsResourceName);
+  }
+
+  @Test
+  public void resolving_matchingVirtualHostNotFoundInRdsResource() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdateForRdsName(RDS_RESOURCE_NAME);
+    xdsClient.deliverRdsUpdate(RDS_RESOURCE_NAME, buildUnmatchedVirtualHosts());
+    assertEmptyResolutionResult(expectedLdsResourceName);
+  }
+
+  private List<VirtualHost> buildUnmatchedVirtualHosts() {
+    Route route1 = Route.forAction(RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
+        RouteAction.forCluster(
+            cluster2, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L), null, false),
+        ImmutableMap.of());
+    Route route2 = Route.forAction(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+        RouteAction.forCluster(
+            cluster1, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L), null, false),
+        ImmutableMap.of());
+    return Arrays.asList(
+        VirtualHost.create("virtualhost-foo", Collections.singletonList("hello.googleapis.com"),
+            Collections.singletonList(route1),
+            ImmutableMap.of()),
+        VirtualHost.create("virtualhost-bar", Collections.singletonList("hi.googleapis.com"),
+            Collections.singletonList(route2),
+            ImmutableMap.of()));
+  }
+
+  @Test
+  public void resolved_noTimeout() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    Route route = Route.forAction(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+        RouteAction.forCluster(
+            cluster1, Collections.emptyList(), null, null, false), // per-route timeout unset
+        ImmutableMap.of());
+    VirtualHost virtualHost = VirtualHost.create("does not matter",
+        Collections.singletonList(AUTHORITY), Collections.singletonList(route),
+        ImmutableMap.of());
+    xdsClient.deliverLdsUpdate(0L, Collections.singletonList(virtualHost));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    assertCallSelectClusterResult(call1, configSelector, cluster1, null);
+  }
+
+  @Test
+  public void resolved_fallbackToHttpMaxStreamDurationAsTimeout() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    Route route = Route.forAction(RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+        RouteAction.forCluster(
+            cluster1, Collections.emptyList(), null, null, false), // per-route timeout unset
+        ImmutableMap.of());
+    VirtualHost virtualHost = VirtualHost.create("does not matter",
+        Collections.singletonList(AUTHORITY), Collections.singletonList(route),
+        ImmutableMap.of());
+    xdsClient.deliverLdsUpdate(TimeUnit.SECONDS.toNanos(5L),
+        Collections.singletonList(virtualHost));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    assertCallSelectClusterResult(call1, configSelector, cluster1, 5.0);
+  }
+
+  @Test
+  public void retryPolicyInPerMethodConfigGeneratedByResolverIsValid() {
+    ServiceConfigParser realParser = new ScParser(
+        true, 5, 5, new AutoConfiguredLoadBalancerFactory("pick-first"));
+    resolver = new XdsNameResolver(targetUri, null, AUTHORITY, null, realParser, syncContext,
+        scheduler, xdsClientPoolFactory, mockRandom, FilterRegistry.getDefaultRegistry(),
+        rawBootstrap, metricRecorder, nameResolverArgs);
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    RetryPolicy retryPolicy = RetryPolicy.create(
+        4, ImmutableList.of(Code.UNAVAILABLE), Durations.fromMillis(100),
+        Durations.fromMillis(200), null);
+    xdsClient.deliverLdsUpdate(
+        Collections.singletonList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    cluster1,
+                    Collections.emptyList(),
+                    null,
+                    retryPolicy,
+                    false),
+                ImmutableMap.of())));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    Result selectResult = configSelector.selectConfig(
+        newPickSubchannelArgs(call1.methodDescriptor, new Metadata(), CallOptions.DEFAULT));
+    Object config = selectResult.getConfig();
+
+    // Purely validating the data (io.grpc.internal.RetryPolicy).
+    // However, there's no public accessor methods the data object.
+    assertThat(config.getClass().getName())
+        .isEqualTo("io.grpc.internal.ManagedChannelServiceConfig");
+    assertThat(config.toString()).contains(
+        MoreObjects.toStringHelper("RetryPolicy")
+            .add("maxAttempts", 4)
+            .add("initialBackoffNanos", TimeUnit.MILLISECONDS.toNanos(100))
+            .add("maxBackoffNanos", TimeUnit.MILLISECONDS.toNanos(200))
+            .add("backoffMultiplier", 2D)
+            .add("perAttemptRecvTimeoutNanos", null)
+            .add("retryableStatusCodes", ImmutableList.of(Code.UNAVAILABLE))
+            .toString());
+  }
+
+  @Test
+  public void resolved_simpleCallSucceeds() {
+    InternalConfigSelector configSelector = resolveToClusters();
+    assertCallSelectClusterResult(call1, configSelector, cluster1, 15.0);
+    testCall.deliverResponseHeaders();
+    verifyNoMoreInteractions(mockListener);
+  }
+
+  @Test
+  public void resolved_simpleCallFailedToRoute_noMatchingRoute() {
+    InternalConfigSelector configSelector = resolveToClusters();
+    CallInfo call = new CallInfo("FooService", "barMethod");
+    Result selectResult = configSelector.selectConfig(
+        newPickSubchannelArgs(call.methodDescriptor, new Metadata(), CallOptions.DEFAULT));
+    Status status = selectResult.getStatus();
+    assertThat(status.isOk()).isFalse();
+    assertThat(status.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(status.getDescription()).isEqualTo("Could not find xDS route matching RPC");
+    verifyNoMoreInteractions(mockListener);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void resolved_simpleCallFailedToRoute_routeWithNonForwardingAction() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Arrays.asList(
+            Route.forNonForwardingAction(
+                RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+                ImmutableMap.of()),
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
+                RouteAction.forCluster(cluster2, Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(15L), null, false),
+                ImmutableMap.of())));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    assertThat(result.getAddressesOrError().getValue()).isEmpty();
+    assertServiceConfigForLoadBalancingConfig(
+        Collections.singletonList(cluster2),
+        (Map<String, ?>) result.getServiceConfig().getConfig());
+    assertThat(result.getAttributes().get(XdsAttributes.XDS_CLIENT)).isNotNull();
+    assertThat(result.getAttributes().get(XdsAttributes.CALL_COUNTER_PROVIDER)).isNotNull();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    // Simulates making a call1 RPC.
+    Result selectResult = configSelector.selectConfig(
+        newPickSubchannelArgs(call1.methodDescriptor, new Metadata(), CallOptions.DEFAULT));
+    Status status = selectResult.getStatus();
+    assertThat(status.isOk()).isFalse();
+    assertThat(status.getCode()).isEqualTo(Code.UNAVAILABLE);
+    assertThat(status.getDescription())
+        .isEqualTo("Could not route RPC to Route with non-forwarding action");
+    verifyNoMoreInteractions(mockListener);
+  }
+
+  @Test
+  public void resolved_rpcHashingByHeader_withoutSubstitution() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Collections.singletonList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(
+                    "/" + TestMethodDescriptors.voidMethod().getFullMethodName()),
+                RouteAction.forCluster(
+                    cluster1,
+                    Collections.singletonList(
+                        HashPolicy.forHeader(false, "custom-key", null, null)),
+                    null,
+                    null,
+                    false),
+                ImmutableMap.of())));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    InternalConfigSelector configSelector =
+        resolutionResultCaptor.getValue().getAttributes().get(InternalConfigSelector.KEY);
+
+    // First call, with header "custom-key": "custom-value".
+    startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of("custom-key", "custom-value"), CallOptions.DEFAULT);
+    long hash1 = testCall.callOptions.getOption(XdsNameResolver.RPC_HASH_KEY);
+
+    // Second call, with header "custom-key": "custom-val".
+    startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of("custom-key", "custom-val"),
+        CallOptions.DEFAULT);
+    long hash2 = testCall.callOptions.getOption(XdsNameResolver.RPC_HASH_KEY);
+
+    assertThat(hash2).isNotEqualTo(hash1);
+  }
+
+  @Test
+  public void resolved_rpcHashingByHeader_withSubstitution() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Collections.singletonList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(
+                    "/" + TestMethodDescriptors.voidMethod().getFullMethodName()),
+                RouteAction.forCluster(
+                    cluster1,
+                    Collections.singletonList(
+                        HashPolicy.forHeader(false, "custom-key", Pattern.compile("value"),
+                            "val")),
+                    null,
+                    null,
+                    false),
+                ImmutableMap.of())));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    InternalConfigSelector configSelector =
+        resolutionResultCaptor.getValue().getAttributes().get(InternalConfigSelector.KEY);
+
+    // First call, with header "custom-key": "custom-value".
+    startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of("custom-key", "custom-value"), CallOptions.DEFAULT);
+    long hash1 = testCall.callOptions.getOption(XdsNameResolver.RPC_HASH_KEY);
+
+    // Second call, with header "custom-key": "custom-val", "another-key": "another-value".
+    startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of("custom-key", "custom-val", "another-key", "another-value"),
+        CallOptions.DEFAULT);
+    long hash2 = testCall.callOptions.getOption(XdsNameResolver.RPC_HASH_KEY);
+
+    // Third call, with header "custom-key": "value".
+    startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of("custom-key", "value"), CallOptions.DEFAULT);
+    long hash3 = testCall.callOptions.getOption(XdsNameResolver.RPC_HASH_KEY);
+
+    assertThat(hash2).isEqualTo(hash1);
+    assertThat(hash3).isNotEqualTo(hash1);
+  }
+
+  @Test
+  public void resolved_rpcHashingByChannelId() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Collections.singletonList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(
+                    "/" + TestMethodDescriptors.voidMethod().getFullMethodName()),
+                RouteAction.forCluster(
+                    cluster1,
+                    Collections.singletonList(HashPolicy.forChannelId(false)),
+                    null,
+                    null,
+                    false),
+                ImmutableMap.of())));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    InternalConfigSelector configSelector =
+        resolutionResultCaptor.getValue().getAttributes().get(InternalConfigSelector.KEY);
+
+    // First call, with header "custom-key": "value1".
+    startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of("custom-key", "value1"),
+        CallOptions.DEFAULT);
+    long hash1 = testCall.callOptions.getOption(XdsNameResolver.RPC_HASH_KEY);
+
+    // Second call, with no custom header.
+    startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        Collections.emptyMap(),
+        CallOptions.DEFAULT);
+    long hash2 = testCall.callOptions.getOption(XdsNameResolver.RPC_HASH_KEY);
+
+    // A different resolver/Channel.
+    resolver.shutdown();
+    reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
+    when(mockRandom.nextLong()).thenReturn(123L);
+    resolver = new XdsNameResolver(targetUri, null, AUTHORITY, null, serviceConfigParser,
+        syncContext, scheduler,
+        xdsClientPoolFactory, mockRandom, FilterRegistry.getDefaultRegistry(), rawBootstrap,
+        metricRecorder, nameResolverArgs);
+    resolver.start(mockListener);
+    xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Collections.singletonList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(
+                    "/" + TestMethodDescriptors.voidMethod().getFullMethodName()),
+                RouteAction.forCluster(
+                    cluster1,
+                    Collections.singletonList(HashPolicy.forChannelId(false)),
+                    null,
+                    null,
+                    false),
+                ImmutableMap.of())));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    configSelector = resolutionResultCaptor.getValue().getAttributes().get(
+        InternalConfigSelector.KEY);
+
+    // Third call, with no custom header.
+    startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        Collections.emptyMap(),
+        CallOptions.DEFAULT);
+    long hash3 = testCall.callOptions.getOption(XdsNameResolver.RPC_HASH_KEY);
+
+    assertThat(hash2).isEqualTo(hash1);
+    assertThat(hash3).isNotEqualTo(hash1);
+  }
+
+  @Test
+  public void resolved_routeActionHasAutoHostRewrite_emitsCallOptionForTheSame() {
+    resolver = new XdsNameResolver(targetUri, null, AUTHORITY, null, serviceConfigParser,
+        syncContext, scheduler, xdsClientPoolFactory, mockRandom,
+        FilterRegistry.getDefaultRegistry(), rawBootstrap, metricRecorder, nameResolverArgs);
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Collections.singletonList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(
+                    "/" + TestMethodDescriptors.voidMethod().getFullMethodName()),
+                RouteAction.forCluster(
+                    cluster1,
+                    Collections.singletonList(
+                        HashPolicy.forHeader(false, "custom-key", null, null)),
+                    null,
+                    null,
+                    true),
+                ImmutableMap.of())));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    InternalConfigSelector configSelector =
+        resolutionResultCaptor.getValue().getAttributes().get(InternalConfigSelector.KEY);
+
+    // First call, with header "custom-key": "custom-value".
+    startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of("custom-key", "custom-value"), CallOptions.DEFAULT);
+
+    assertThat(testCall.callOptions.getOption(XdsNameResolver.AUTO_HOST_REWRITE_KEY)).isTrue();
+  }
+
+  @Test
+  public void resolved_routeActionNoAutoHostRewrite_doesntEmitCallOptionForTheSame() {
+    resolver = new XdsNameResolver(targetUri, null, AUTHORITY, null, serviceConfigParser,
+        syncContext, scheduler, xdsClientPoolFactory, mockRandom,
+        FilterRegistry.getDefaultRegistry(), rawBootstrap, metricRecorder, nameResolverArgs);
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Collections.singletonList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(
+                    "/" + TestMethodDescriptors.voidMethod().getFullMethodName()),
+                RouteAction.forCluster(
+                    cluster1,
+                    Collections.singletonList(
+                        HashPolicy.forHeader(false, "custom-key", null, null)),
+                    null,
+                    null,
+                    false),
+                ImmutableMap.of())));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    InternalConfigSelector configSelector =
+        resolutionResultCaptor.getValue().getAttributes().get(InternalConfigSelector.KEY);
+
+    // First call, with header "custom-key": "custom-value".
+    startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of("custom-key", "custom-value"), CallOptions.DEFAULT);
+
+    assertThat(testCall.callOptions.getOption(XdsNameResolver.AUTO_HOST_REWRITE_KEY)).isNull();
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void resolved_resourceUpdateAfterCallStarted() {
+    InternalConfigSelector configSelector = resolveToClusters();
+    assertCallSelectClusterResult(call1, configSelector, cluster1, 15.0);
+    TestCall<?, ?> firstCall = testCall;
+
+    reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Arrays.asList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    "another-cluster", Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(20L), null, false),
+                ImmutableMap.of()),
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    cluster2, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L),
+                    null, false),
+                ImmutableMap.of())));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    // Updated service config still contains cluster1 while it is removed resource. New calls no
+    // longer routed to cluster1.
+    assertServiceConfigForLoadBalancingConfig(
+        Arrays.asList(cluster1, cluster2, "another-cluster"),
+        (Map<String, ?>) result.getServiceConfig().getConfig());
+    assertThat(result.getAttributes().get(InternalConfigSelector.KEY))
+        .isSameInstanceAs(configSelector);
+    assertCallSelectClusterResult(call1, configSelector, "another-cluster", 20.0);
+
+    firstCall.deliverErrorStatus();  // completes previous call
+    // Two updates: one for XdsNameResolver releasing the cluster, and another for
+    // XdsDependencyManager updating the XdsConfig
+    verify(mockListener, times(3)).onResult2(resolutionResultCaptor.capture());
+    result = resolutionResultCaptor.getValue();
+    assertServiceConfigForLoadBalancingConfig(
+        Arrays.asList(cluster2, "another-cluster"),
+        (Map<String, ?>) result.getServiceConfig().getConfig());
+    verifyNoMoreInteractions(mockListener);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void resolved_resourceUpdatedBeforeCallStarted() {
+    InternalConfigSelector configSelector = resolveToClusters();
+    reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Arrays.asList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    "another-cluster", Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(20L), null, false),
+                ImmutableMap.of()),
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    cluster2, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L),
+                    null, false),
+                ImmutableMap.of())));
+    // Two consecutive service config updates: one for removing clcuster1,
+    // one for adding "another=cluster".
+    verify(mockListener, times(3)).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    assertServiceConfigForLoadBalancingConfig(
+        Arrays.asList(cluster2, "another-cluster"),
+        (Map<String, ?>) result.getServiceConfig().getConfig());
+    assertThat(result.getAttributes().get(InternalConfigSelector.KEY))
+        .isSameInstanceAs(configSelector);
+    assertCallSelectClusterResult(call1, configSelector, "another-cluster", 20.0);
+
+    verifyNoMoreInteractions(mockListener);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void resolved_raceBetweenCallAndRepeatedResourceUpdate() {
+    InternalConfigSelector configSelector = resolveToClusters();
+    assertCallSelectClusterResult(call1, configSelector, cluster1, 15.0);
+
+    reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Arrays.asList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    "another-cluster", Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(20L), null, false),
+                ImmutableMap.of()),
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    cluster2, Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(15L), null, false),
+                ImmutableMap.of())));
+
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    assertServiceConfigForLoadBalancingConfig(
+        Arrays.asList(cluster1, cluster2, "another-cluster"),
+        (Map<String, ?>) result.getServiceConfig().getConfig());
+
+    xdsClient.deliverLdsUpdate(
+        Arrays.asList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    "another-cluster", Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(15L), null, false),
+                ImmutableMap.of()),
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    cluster2, Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(15L), null, false),
+                ImmutableMap.of())));
+    verify(mockListener, times(2)).onResult2(resolutionResultCaptor.capture());
+    assertCallSelectClusterResult(call1, configSelector, "another-cluster", 15.0);
+  }
+
+  @Test
+  public void resolved_raceBetweenClusterReleasedAndResourceUpdateAddBackAgain() {
+    InternalConfigSelector configSelector = resolveToClusters();
+    assertCallSelectClusterResult(call1, configSelector, cluster1, 15.0);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Collections.singletonList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    cluster2, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L),
+                    null, false),
+                ImmutableMap.of())));
+    xdsClient.deliverLdsUpdate(
+        Arrays.asList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    cluster1, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L),
+                    null, false),
+                ImmutableMap.of()),
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    cluster2, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L),
+                    null, false),
+                ImmutableMap.of())));
+    testCall.deliverErrorStatus();
+    verify(mockListener, times(3)).onResult2(resolutionResultCaptor.capture());
+    assertServiceConfigForLoadBalancingConfig(
+        Arrays.asList(cluster1, cluster2), resolutionResultCaptor.getAllValues().get(1));
+    assertServiceConfigForLoadBalancingConfig(
+        Arrays.asList(cluster1, cluster2), resolutionResultCaptor.getAllValues().get(2));
+    assertServiceConfigForLoadBalancingConfig(
+        Arrays.asList(cluster1, cluster2), resolutionResultCaptor.getAllValues().get(3));
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void resolved_simpleCallSucceeds_routeToWeightedCluster() {
+    when(mockRandom.nextInt(anyInt())).thenReturn(90, 10);
+    when(mockRandom.nextLong(anyLong())).thenReturn(90L, 10L);
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Collections.singletonList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+                RouteAction.forWeightedClusters(
+                    Arrays.asList(
+                        ClusterWeight.create(cluster1, 20, ImmutableMap.of()),
+                        ClusterWeight.create(
+                            cluster2, 80, ImmutableMap.of())),
+                    Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(20L),
+                    null, false),
+                ImmutableMap.of())));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    assertThat(result.getAddressesOrError().getValue()).isEmpty();
+    assertServiceConfigForLoadBalancingConfig(
+        Arrays.asList(cluster1, cluster2), (Map<String, ?>) result.getServiceConfig().getConfig());
+    assertThat(result.getAttributes().get(XdsAttributes.XDS_CLIENT)).isNotNull();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    assertCallSelectClusterResult(call1, configSelector, cluster2, 20.0);
+    assertCallSelectClusterResult(call1, configSelector, cluster1, 20.0);
+  }
+
+  /** Creates and delivers both CDS and EDS updates for the given clusters. */
+  private static void createAndDeliverClusterUpdates(
+      FakeXdsClient xdsClient, String... clusterNames) {
+    for (String clusterName : clusterNames) {
+      CdsUpdate.Builder forEds = CdsUpdate
+          .forEds(clusterName, clusterName, null, null, null, null, false, null)
+              .roundRobinLbPolicy();
+      xdsClient.deliverCdsUpdate(clusterName, forEds.build());
+      EdsUpdate edsUpdate = new EdsUpdate(clusterName,
+          XdsTestUtils.createMinimalLbEndpointsMap("127.0.0.3"), Collections.emptyList());
+      xdsClient.deliverEdsUpdate(clusterName, edsUpdate);
+    }
+  }
+
+  @Test
+  public void resolved_simpleCallSucceeds_routeToRls() {
+    when(mockRandom.nextInt(anyInt())).thenReturn(90, 10);
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Collections.singletonList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+                RouteAction.forClusterSpecifierPlugin(
+                    NamedPluginConfig.create(
+                        "rls-plugin-foo",
+                        RlsPluginConfig.create(
+                            ImmutableMap.of("lookupService", "rls-cbt.googleapis.com"))),
+                    Collections.emptyList(),
+                    TimeUnit.SECONDS.toNanos(20L),
+                    null, false),
+                ImmutableMap.of())));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    assertThat(result.getAddressesOrError().getValue()).isEmpty();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> resultServiceConfig = (Map<String, ?>) result.getServiceConfig().getConfig();
+    List<Map<String, ?>> rawLbConfigs =
+        JsonUtil.getListOfObjects(resultServiceConfig, "loadBalancingConfig");
+    Map<String, ?> lbConfig = Iterables.getOnlyElement(rawLbConfigs);
+    assertThat(lbConfig.keySet()).containsExactly("cluster_manager_experimental");
+    Map<String, ?> clusterManagerLbConfig =
+        JsonUtil.getObject(lbConfig, "cluster_manager_experimental");
+    Map<String, ?> expectedRlsLbConfig = ImmutableMap.of(
+        "routeLookupConfig",
+        ImmutableMap.of("lookupService", "rls-cbt.googleapis.com"),
+        "childPolicy",
+        ImmutableList.of(ImmutableMap.of("cds_experimental", ImmutableMap.of("is_dynamic", true))),
+        "childPolicyConfigTargetFieldName",
+        "cluster");
+    Map<String, ?> expectedClusterManagerLbConfig = ImmutableMap.of(
+        "childPolicy",
+        ImmutableMap.of(
+            "cluster_specifier_plugin:rls-plugin-foo",
+            ImmutableMap.of(
+                "lbPolicy",
+                ImmutableList.of(ImmutableMap.of("rls_experimental", expectedRlsLbConfig)))));
+    assertThat(clusterManagerLbConfig).isEqualTo(expectedClusterManagerLbConfig);
+
+    assertThat(result.getAttributes().get(XdsAttributes.XDS_CLIENT)).isNotNull();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    assertCallSelectRlsPluginResult(
+        call1, configSelector, "rls-plugin-foo", 20.0);
+
+    // config changed
+    xdsClient.deliverLdsUpdate(
+        Collections.singletonList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+                RouteAction.forClusterSpecifierPlugin(
+                    NamedPluginConfig.create(
+                        "rls-plugin-foo",
+                        RlsPluginConfig.create(
+                            // changed
+                            ImmutableMap.of("lookupService", "rls-cbt-2.googleapis.com"))),
+                    Collections.emptyList(),
+                    // changed
+                    TimeUnit.SECONDS.toNanos(30L),
+                    null, false),
+                ImmutableMap.of())));
+    verify(mockListener, times(2)).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result2 = resolutionResultCaptor.getValue();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> resultServiceConfig2 = (Map<String, ?>) result2.getServiceConfig().getConfig();
+    List<Map<String, ?>> rawLbConfigs2 =
+        JsonUtil.getListOfObjects(resultServiceConfig2, "loadBalancingConfig");
+    Map<String, ?> lbConfig2 = Iterables.getOnlyElement(rawLbConfigs2);
+    assertThat(lbConfig2.keySet()).containsExactly("cluster_manager_experimental");
+    Map<String, ?> clusterManagerLbConfig2 =
+        JsonUtil.getObject(lbConfig2, "cluster_manager_experimental");
+    Map<String, ?> expectedRlsLbConfig2 = ImmutableMap.of(
+        "routeLookupConfig",
+        ImmutableMap.of("lookupService", "rls-cbt-2.googleapis.com"),
+        "childPolicy",
+        ImmutableList.of(ImmutableMap.of("cds_experimental", ImmutableMap.of("is_dynamic", true))),
+        "childPolicyConfigTargetFieldName",
+        "cluster");
+    Map<String, ?> expectedClusterManagerLbConfig2 = ImmutableMap.of(
+        "childPolicy",
+        ImmutableMap.of(
+            "cluster_specifier_plugin:rls-plugin-foo",
+            ImmutableMap.of(
+                "lbPolicy",
+                ImmutableList.of(ImmutableMap.of("rls_experimental", expectedRlsLbConfig2)))));
+    assertThat(clusterManagerLbConfig2).isEqualTo(expectedClusterManagerLbConfig2);
+
+    InternalConfigSelector configSelector2 = result.getAttributes().get(InternalConfigSelector.KEY);
+    assertCallSelectRlsPluginResult(
+        call1, configSelector2, "rls-plugin-foo", 30.0);
+  }
+
+  // Begin filter state tests.
+
+  /**
+   * Verifies the lifecycle of HCM filter instances across LDS updates.
+   *
+   * <p>Filter instances:
+   *   1. Must have one unique instance per HCM filter name.
+   *   2. Must be reused when an LDS update with HCM contains a filter with the same name.
+   *   3. Must be shutdown (closed) when an HCM in a LDS update doesn't a filter with the same name.
+   */
+  @Test
+  public void filterState_survivesLds() {
+    StatefulFilter.Provider statefulFilterProvider = filterStateTestSetupResolver();
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    VirtualHost vhost = filterStateTestVhost();
+
+    // LDS 1.
+    xdsClient.deliverLdsUpdateWithFilters(vhost, filterStateTestConfigs(STATEFUL_1, STATEFUL_2));
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    assertClusterResolutionResult(call1, cluster1);
+    ImmutableList<StatefulFilter> lds1Snapshot = statefulFilterProvider.getAllInstances();
+    // Verify that StatefulFilter with different filter names result in different Filter instances.
+    assertWithMessage("LDS 1: expected to create filter instances").that(lds1Snapshot).hasSize(2);
+    // Naming: lds<LDS#>Filter<name#>
+    StatefulFilter lds1Filter1 = lds1Snapshot.get(0);
+    StatefulFilter lds1Filter2 = lds1Snapshot.get(1);
+    assertThat(lds1Filter1).isNotSameInstanceAs(lds1Filter2);
+    // Redundant check just in case StatefulFilter synchronization is broken.
+    assertThat(lds1Filter1.idx).isEqualTo(0);
+    assertThat(lds1Filter2.idx).isEqualTo(1);
+
+    // LDS 2: filter configs with the same names.
+    xdsClient.deliverLdsUpdateWithFilters(vhost, filterStateTestConfigs(STATEFUL_1, STATEFUL_2));
+    assertClusterResolutionResult(call1, cluster1);
+    ImmutableList<StatefulFilter> lds2Snapshot = statefulFilterProvider.getAllInstances();
+    // Filter names hasn't changed, so expecting no new StatefulFilter instances.
+    assertWithMessage("LDS 2: Expected Filter instances to be reused across LDS updates")
+        .that(lds2Snapshot).isEqualTo(lds1Snapshot);
+
+    // LDS 3: Filter "STATEFUL_2" removed.
+    xdsClient.deliverLdsUpdateWithFilters(vhost, filterStateTestConfigs(STATEFUL_1));
+    assertClusterResolutionResult(call1, cluster1);
+    ImmutableList<StatefulFilter> lds3Snapshot = statefulFilterProvider.getAllInstances();
+    // Again, no new StatefulFilter instances should be created.
+    assertWithMessage("LDS 3: Expected Filter instances to be reused across LDS updates")
+        .that(lds3Snapshot).isEqualTo(lds1Snapshot);
+    // Verify the shutdown state.
+    assertThat(lds1Filter1.isShutdown()).isFalse();
+    assertWithMessage("LDS 3: Expected %s to be shut down", lds1Filter2)
+        .that(lds1Filter2.isShutdown()).isTrue();
+
+    // LDS 4: Filter "STATEFUL_2" added back.
+    xdsClient.deliverLdsUpdateWithFilters(vhost, filterStateTestConfigs(STATEFUL_1, STATEFUL_2));
+    assertClusterResolutionResult(call1, cluster1);
+    ImmutableList<StatefulFilter> lds4Snapshot = statefulFilterProvider.getAllInstances();
+    // Filter "STATEFUL_2" should be treated as any other new filter name in an LDS update:
+    // a new instance should be created.
+    assertWithMessage("LDS 4: Expected a new filter instance for %s", STATEFUL_2)
+        .that(lds4Snapshot).hasSize(3);
+    StatefulFilter lds4Filter2 = lds4Snapshot.get(2);
+    assertThat(lds4Filter2.idx).isEqualTo(2);
+    assertThat(lds4Filter2).isNotSameInstanceAs(lds1Filter2);
+    assertThat(lds4Snapshot).containsAtLeastElementsIn(lds1Snapshot);
+    // Verify the shutdown state.
+    assertThat(lds1Filter1.isShutdown()).isFalse();
+    assertThat(lds1Filter2.isShutdown()).isTrue();
+    assertThat(lds4Filter2.isShutdown()).isFalse();
+  }
+
+  /**
+   * Verifies the lifecycle of HCM filter instances across RDS updates.
+   *
+   * <p>Filter instances:
+   *   1. Must have instantiated by the initial LDS/RDS.
+   *   2. Must be reused by all subsequent RDS updates.
+   *   3. Must be not shutdown (closed) by valid RDS updates.
+   */
+  @Test
+  public void filterState_survivesRds() {
+    StatefulFilter.Provider statefulFilterProvider = filterStateTestSetupResolver();
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+
+    // LDS 1.
+    xdsClient.deliverLdsUpdateForRdsNameWithFilters(RDS_RESOURCE_NAME,
+        filterStateTestConfigs(STATEFUL_1, STATEFUL_2));
+    // RDS 1.
+    VirtualHost vhost1 = filterStateTestVhost();
+    xdsClient.deliverRdsUpdate(RDS_RESOURCE_NAME, vhost1);
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    assertClusterResolutionResult(call1, cluster1);
+    // Initial RDS update should not generate Filter instances.
+    ImmutableList<StatefulFilter> rds1Snapshot = statefulFilterProvider.getAllInstances();
+    // Verify that StatefulFilter with different filter names result in different Filter instances.
+    assertWithMessage("RDS 1: expected to create filter instances").that(rds1Snapshot).hasSize(2);
+    // Naming: lds<LDS#>Filter<name#>
+    StatefulFilter lds1Filter1 = rds1Snapshot.get(0);
+    StatefulFilter lds1Filter2 = rds1Snapshot.get(1);
+    assertThat(lds1Filter1).isNotSameInstanceAs(lds1Filter2);
+
+    // RDS 2: exactly the same as RDS 1.
+    xdsClient.deliverRdsUpdate(RDS_RESOURCE_NAME, vhost1);
+    assertClusterResolutionResult(call1, cluster1);
+    ImmutableList<StatefulFilter> rds2Snapshot = statefulFilterProvider.getAllInstances();
+    // Neither should any subsequent RDS updates.
+    assertWithMessage("RDS 2: Expected Filter instances to be reused across RDS route updates")
+        .that(rds2Snapshot).isEqualTo(rds1Snapshot);
+
+    // RDS 3: Contains a per-route override for STATEFUL_1.
+    VirtualHost vhost3 = filterStateTestVhost(ImmutableMap.of(
+        STATEFUL_1, new StatefulFilter.Config("RDS3")
+    ));
+    xdsClient.deliverRdsUpdate(RDS_RESOURCE_NAME, vhost3);
+    assertClusterResolutionResult(call1, cluster1);
+    ImmutableList<StatefulFilter> rds3Snapshot = statefulFilterProvider.getAllInstances();
+    // As with any other Route update, typed_per_filter_config overrides should not result in
+    // creating new filter instances.
+    assertWithMessage("RDS 3: Expected Filter instances to be reused on per-route filter overrides")
+        .that(rds3Snapshot).isEqualTo(rds1Snapshot);
+  }
+
+  /**
+   * Verifies a special case where an existing filter is has a different typeUrl in a subsequent
+   * LDS update.
+   *
+   * <p>Expectations:
+   *   1. The old filter instance must be shutdown.
+   *   2. A new filter instance must be created for the new filter with different typeUrl.
+   */
+  @Test
+  public void filterState_specialCase_sameNameDifferentTypeUrl() {
+    // Prepare filter registry with StatefulFilter of different typeUrl.
+    StatefulFilter.Provider statefulFilterProvider = new StatefulFilter.Provider();
+    String altTypeUrl = "type.googleapis.com/grpc.test.AltStatefulFilter";
+    StatefulFilter.Provider altStatefulFilterProvider = new StatefulFilter.Provider(altTypeUrl);
+    FilterRegistry filterRegistry = FilterRegistry.newRegistry()
+        .register(statefulFilterProvider, altStatefulFilterProvider, ROUTER_FILTER_PROVIDER);
+    resolver = new XdsNameResolver(targetUri, null, AUTHORITY, null, serviceConfigParser,
+        syncContext, scheduler, xdsClientPoolFactory, mockRandom, filterRegistry, rawBootstrap,
+        metricRecorder, nameResolverArgs);
+    resolver.start(mockListener);
+
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    VirtualHost vhost = filterStateTestVhost();
+
+    // LDS 1.
+    xdsClient.deliverLdsUpdateWithFilters(vhost, filterStateTestConfigs(STATEFUL_1, STATEFUL_2));
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    assertClusterResolutionResult(call1, cluster1);
+    ImmutableList<StatefulFilter> lds1Snapshot = statefulFilterProvider.getAllInstances();
+    ImmutableList<StatefulFilter> lds1SnapshotAlt = altStatefulFilterProvider.getAllInstances();
+    // Verify that StatefulFilter with different filter names result in different Filter instances.
+    assertWithMessage("LDS 1: expected to create filter instances").that(lds1Snapshot).hasSize(2);
+    // Naming: lds<LDS#>Filter<name#>
+    StatefulFilter lds1Filter1 = lds1Snapshot.get(0);
+    StatefulFilter lds1Filter2 = lds1Snapshot.get(1);
+    assertThat(lds1Filter1).isNotSameInstanceAs(lds1Filter2);
+    // Nothing in the alternative provider.
+    assertThat(lds1SnapshotAlt).isEmpty();
+
+    // LDS 2: Filter STATEFUL_2 present, but with a different typeUrl: altTypeUrl.
+    ImmutableList<NamedFilterConfig> filterConfigs = ImmutableList.of(
+        new NamedFilterConfig(STATEFUL_1, new StatefulFilter.Config(STATEFUL_1)),
+        new NamedFilterConfig(STATEFUL_2, new StatefulFilter.Config(STATEFUL_2, altTypeUrl)),
+        new NamedFilterConfig(ROUTER_FILTER_INSTANCE_NAME, RouterFilter.ROUTER_CONFIG)
+    );
+    xdsClient.deliverLdsUpdateWithFilters(vhost, filterConfigs);
+    assertClusterResolutionResult(call1, cluster1);
+    ImmutableList<StatefulFilter> lds2Snapshot = statefulFilterProvider.getAllInstances();
+    ImmutableList<StatefulFilter> lds2SnapshotAlt = altStatefulFilterProvider.getAllInstances();
+    // Filter "STATEFUL_2" has different typeUrl, and should be treated as a new filter.
+    // No changes in the snapshot of normal stateful filters.
+    assertWithMessage("LDS 2: expected a new filter instance of different type")
+        .that(lds2Snapshot).isEqualTo(lds1Snapshot);
+    // A new filter instance is created by altStatefulFilterProvider.
+    assertWithMessage("LDS 2: expected a new filter instance for type %s", altTypeUrl)
+        .that(lds2SnapshotAlt).hasSize(1);
+    StatefulFilter lds2Filter2Alt = lds2SnapshotAlt.get(0);
+    assertThat(lds2Filter2Alt).isNotSameInstanceAs(lds1Filter2);
+    // Verify the shutdown state.
+    assertThat(lds1Filter1.isShutdown()).isFalse();
+    assertThat(lds1Filter2.isShutdown()).isTrue();
+    assertThat(lds2Filter2Alt.isShutdown()).isFalse();
+  }
+
+  /**
+   * Verifies that all filter instances are shutdown (closed) on LDS resource not found.
+   */
+  @Test
+  public void filterState_shutdown_onLdsNotFound() {
+    StatefulFilter.Provider statefulFilterProvider = filterStateTestSetupResolver();
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    VirtualHost vhost = filterStateTestVhost();
+
+    // LDS 1.
+    xdsClient.deliverLdsUpdateWithFilters(vhost, filterStateTestConfigs(STATEFUL_1, STATEFUL_2));
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    assertClusterResolutionResult(call1, cluster1);
+    ImmutableList<StatefulFilter> lds1Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("LDS 1: expected to create filter instances").that(lds1Snapshot).hasSize(2);
+    // Naming: lds<LDS#>Filter<name#>
+    StatefulFilter lds1Filter1 = lds1Snapshot.get(0);
+    StatefulFilter lds1Filter2 = lds1Snapshot.get(1);
+
+    // LDS 2: resource not found.
+    reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
+    xdsClient.deliverLdsResourceNotFound();
+    assertEmptyResolutionResult(expectedLdsResourceName);
+    // Verify shutdown.
+    assertThat(lds1Filter1.isShutdown()).isTrue();
+    assertThat(lds1Filter2.isShutdown()).isTrue();
+  }
+
+  @Test
+  public void filterState_noShutdown_onLdsDeletion() {
+    StatefulFilter.Provider statefulFilterProvider = filterStateTestSetupResolver();
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    VirtualHost vhost = filterStateTestVhost();
+
+    xdsClient.deliverLdsUpdateWithFilters(vhost, filterStateTestConfigs(STATEFUL_1, STATEFUL_2));
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    assertClusterResolutionResult(call1, cluster1);
+    ImmutableList<StatefulFilter> lds1Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("LDS 1: expected to create filter instances").that(lds1Snapshot).hasSize(2);
+    StatefulFilter lds1Filter1 = lds1Snapshot.get(0);
+    StatefulFilter lds1Filter2 = lds1Snapshot.get(1);
+
+    // LDS 2: Deliver a resource deletion, which is now an ambient error.
+    reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
+    xdsClient.deliverLdsResourceDeletion();
+
+    // With an ambient error, no new resolution should happen.
+    verify(mockListener, never()).onResult2(any());
+
+    // Verify that the filters are NOT shut down.
+    assertThat(lds1Filter1.isShutdown()).isFalse();
+    assertThat(lds1Filter2.isShutdown()).isFalse();
+  }
+
+  /**
+   * Verifies that all filter instances are shutdown (closed) on LDS ResourceWatcher shutdown.
+   */
+  @Test
+  public void filterState_shutdown_onResolverShutdown() {
+    StatefulFilter.Provider statefulFilterProvider = filterStateTestSetupResolver();
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    VirtualHost vhost = filterStateTestVhost();
+
+    // LDS 1.
+    xdsClient.deliverLdsUpdateWithFilters(vhost, filterStateTestConfigs(STATEFUL_1, STATEFUL_2));
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    assertClusterResolutionResult(call1, cluster1);
+    ImmutableList<StatefulFilter> lds1Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("LDS 1: expected to create filter instances").that(lds1Snapshot).hasSize(2);
+    // Naming: lds<LDS#>Filter<name#>
+    StatefulFilter lds1Filter1 = lds1Snapshot.get(0);
+    StatefulFilter lds1Filter2 = lds1Snapshot.get(1);
+
+    // Shutdown.
+    resolver.shutdown();
+    resolver = null;  // no need to shutdown again in the teardown.
+    // Verify shutdown.
+    assertThat(lds1Filter1.isShutdown()).isTrue();
+    assertThat(lds1Filter2.isShutdown()).isTrue();
+  }
+
+  /**
+   * Verifies that all filter instances are shutdown (closed) on RDS resource not found.
+   */
+  @Test
+  public void filterState_shutdown_onRdsNotFound() {
+    StatefulFilter.Provider statefulFilterProvider = filterStateTestSetupResolver();
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdateForRdsNameWithFilters(
+        RDS_RESOURCE_NAME,
+        filterStateTestConfigs(STATEFUL_1, STATEFUL_2));
+    xdsClient.deliverRdsUpdate(
+        RDS_RESOURCE_NAME,
+        Collections.singletonList(filterStateTestVhost()));
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    assertClusterResolutionResult(call1, cluster1);
+
+    ImmutableList<StatefulFilter> rds1Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("RDS 1: Expected to create filter instances").that(rds1Snapshot).hasSize(2);
+    StatefulFilter rds1Filter1 = rds1Snapshot.get(0);
+    StatefulFilter rds1Filter2 = rds1Snapshot.get(1);
+    assertThat(rds1Filter1.isShutdown()).isFalse();
+    assertThat(rds1Filter2.isShutdown()).isFalse();
+
+    reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
+    xdsClient.deliverRdsResourceNotFound(RDS_RESOURCE_NAME);
+
+    assertEmptyResolutionResult(RDS_RESOURCE_NAME);
+    assertThat(rds1Filter1.isShutdown()).isTrue();
+    assertThat(rds1Filter2.isShutdown()).isTrue();
+  }
+
+  @Test
+  public void filterState_noShutdown_onRdsAmbientError() {
+    StatefulFilter.Provider statefulFilterProvider = filterStateTestSetupResolver();
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+
+    // LDS 1.
+    xdsClient.deliverLdsUpdateForRdsNameWithFilters(RDS_RESOURCE_NAME,
+        filterStateTestConfigs(STATEFUL_1, STATEFUL_2));
+    // RDS 1: Standard vhost with a route.
+    xdsClient.deliverRdsUpdate(RDS_RESOURCE_NAME, filterStateTestVhost());
+    createAndDeliverClusterUpdates(xdsClient, cluster1);
+    assertClusterResolutionResult(call1, cluster1);
+    ImmutableList<StatefulFilter> rds1Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("RDS 1: expected to create filter instances").that(rds1Snapshot).hasSize(2);
+    // Naming: lds<LDS#>Filter<name#>
+    StatefulFilter lds1Filter1 = rds1Snapshot.get(0);
+    StatefulFilter lds1Filter2 = rds1Snapshot.get(1);
+
+    // RDS 2: RDS_RESOURCE_NAME not found.
+    reset(mockListener);
+    when(mockListener.onResult2(any())).thenReturn(Status.OK);
+    xdsClient.deliverRdsAmbientError(RDS_RESOURCE_NAME, Status.NOT_FOUND);
+    verify(mockListener, never()).onResult2(any());
+    assertThat(lds1Filter1.isShutdown()).isFalse();
+    assertThat(lds1Filter2.isShutdown()).isFalse();
+  }
+
+  private StatefulFilter.Provider filterStateTestSetupResolver() {
+    StatefulFilter.Provider statefulFilterProvider = new StatefulFilter.Provider();
+    FilterRegistry filterRegistry = FilterRegistry.newRegistry()
+        .register(statefulFilterProvider, ROUTER_FILTER_PROVIDER);
+    resolver = new XdsNameResolver(targetUri, null, AUTHORITY, null, serviceConfigParser,
+        syncContext, scheduler, xdsClientPoolFactory, mockRandom, filterRegistry, rawBootstrap,
+        metricRecorder, nameResolverArgs);
+    resolver.start(mockListener);
+    return statefulFilterProvider;
+  }
+
+  private ImmutableList<NamedFilterConfig> filterStateTestConfigs(String... names) {
+    ImmutableList.Builder<NamedFilterConfig> result = ImmutableList.builder();
+    for (String name : names) {
+      result.add(new NamedFilterConfig(name, new StatefulFilter.Config(name)));
+    }
+    result.add(new NamedFilterConfig(ROUTER_FILTER_INSTANCE_NAME, RouterFilter.ROUTER_CONFIG));
+    return result.build();
+  }
+
+  private Route filterStateTestRoute(ImmutableMap<String, FilterConfig> perRouteOverrides) {
+    // Standard basic route for filterState tests.
+    return Route.forAction(
+        RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+        RouteAction.forCluster(cluster1, NO_HASH_POLICIES, null, null, true),
+        perRouteOverrides);
+  }
+
+  private VirtualHost filterStateTestVhost() {
+    return filterStateTestVhost(NO_FILTER_OVERRIDES);
+  }
+
+  private VirtualHost filterStateTestVhost(ImmutableMap<String, FilterConfig> perRouteOverrides) {
+    return VirtualHost.create(
+        "stateful-vhost",
+        ImmutableList.of(expectedLdsResourceName),
+        ImmutableList.of(filterStateTestRoute(perRouteOverrides)),
+        NO_FILTER_OVERRIDES);
+  }
+
+  // End filter state tests.
+
+  @SuppressWarnings("unchecked")
+  private void assertEmptyResolutionResult(String resource) {
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    assertThat(result.getAddressesOrError().getValue()).isEmpty();
+    assertThat((Map<String, ?>) result.getServiceConfig().getConfig()).isEmpty();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    Result configResult = configSelector.selectConfig(
+        newPickSubchannelArgs(call1.methodDescriptor, new Metadata(), CallOptions.DEFAULT));
+    assertThat(configResult.getStatus().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+    assertThat(configResult.getStatus().getDescription()).contains(resource);
+  }
+
+  private void assertClusterResolutionResult(CallInfo call, String expectedCluster) {
+    verify(mockListener, atLeast(1)).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    assertCallSelectClusterResult(call, configSelector, expectedCluster, null);
+  }
+
+  private void assertCallSelectClusterResult(
+      CallInfo call, InternalConfigSelector configSelector, String expectedCluster,
+      @Nullable Double expectedTimeoutSec) {
+    Result result = configSelector.selectConfig(
+        newPickSubchannelArgs(call.methodDescriptor, new Metadata(), CallOptions.DEFAULT));
+    assertThat(result.getStatus().isOk()).isTrue();
+    ClientInterceptor interceptor = result.getInterceptor();
+    ClientCall<Void, Void> clientCall = interceptor.interceptCall(
+        call.methodDescriptor, CallOptions.DEFAULT, channel);
+    clientCall.start(new NoopClientCallListener<>(), new Metadata());
+    assertThat(testCall.callOptions.getOption(XdsNameResolver.CLUSTER_SELECTION_KEY))
+        .isEqualTo("cluster:" + expectedCluster);
+    XdsConfig xdsConfig =
+        testCall.callOptions.getOption(XdsNameResolver.XDS_CONFIG_CALL_OPTION_KEY);
+    assertThat(xdsConfig).isNotNull();
+    assertThat(xdsConfig.getClusters()).containsKey(expectedCluster); // Without "cluster:" prefix
+    @SuppressWarnings("unchecked")
+    Map<String, ?> config = (Map<String, ?>) result.getConfig();
+    if (expectedTimeoutSec != null) {
+      // Verify the raw service config contains a single method config for method with the
+      // specified timeout.
+      List<Map<String, ?>> rawMethodConfigs =
+          JsonUtil.getListOfObjects(config, "methodConfig");
+      Map<String, ?> methodConfig = Iterables.getOnlyElement(rawMethodConfigs);
+      List<Map<String, ?>> methods = JsonUtil.getListOfObjects(methodConfig, "name");
+      assertThat(Iterables.getOnlyElement(methods)).isEmpty();
+      assertThat(JsonUtil.getString(methodConfig, "timeout")).isEqualTo(expectedTimeoutSec + "s");
+    } else {
+      assertThat(config).isEmpty();
+    }
+  }
+
+  private void assertCallSelectRlsPluginResult(
+      CallInfo call, InternalConfigSelector configSelector, String expectedPluginName,
+      Double expectedTimeoutSec) {
+    Result result = configSelector.selectConfig(
+        newPickSubchannelArgs(call.methodDescriptor, new Metadata(), CallOptions.DEFAULT));
+    assertThat(result.getStatus().isOk()).isTrue();
+    ClientInterceptor interceptor = result.getInterceptor();
+    ClientCall<Void, Void> clientCall = interceptor.interceptCall(
+        call.methodDescriptor, CallOptions.DEFAULT, channel);
+    clientCall.start(new NoopClientCallListener<>(), new Metadata());
+    assertThat(testCall.callOptions.getOption(XdsNameResolver.CLUSTER_SELECTION_KEY))
+        .isEqualTo("cluster_specifier_plugin:" + expectedPluginName);
+    @SuppressWarnings("unchecked")
+    Map<String, ?> config = (Map<String, ?>) result.getConfig();
+    List<Map<String, ?>> rawMethodConfigs =
+        JsonUtil.getListOfObjects(config, "methodConfig");
+    Map<String, ?> methodConfig = Iterables.getOnlyElement(rawMethodConfigs);
+    List<Map<String, ?>> methods = JsonUtil.getListOfObjects(methodConfig, "name");
+    assertThat(Iterables.getOnlyElement(methods)).isEmpty();
+    assertThat(JsonUtil.getString(methodConfig, "timeout")).isEqualTo(expectedTimeoutSec + "s");
+  }
+
+  @SuppressWarnings("unchecked")
+  private InternalConfigSelector resolveToClusters() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdate(
+        Arrays.asList(
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call1.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    cluster1, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L),
+                    null, false),
+                ImmutableMap.of()),
+            Route.forAction(
+                RouteMatch.withPathExactOnly(call2.getFullMethodNameForPath()),
+                RouteAction.forCluster(
+                    cluster2, Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L),
+                    null, false),
+                ImmutableMap.of())));
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    assertThat(result.getAddressesOrError().getValue()).isEmpty();
+    assertServiceConfigForLoadBalancingConfig(
+        Arrays.asList(cluster1, cluster2), (Map<String, ?>) result.getServiceConfig().getConfig());
+    assertThat(result.getAttributes().get(XdsAttributes.XDS_CLIENT)).isNotNull();
+    assertThat(result.getAttributes().get(XdsAttributes.CALL_COUNTER_PROVIDER)).isNotNull();
+    return result.getAttributes().get(InternalConfigSelector.KEY);
+  }
+
+  private static void assertServiceConfigForLoadBalancingConfig(
+      List<String> clusters, ResolutionResult result) {
+    @SuppressWarnings("unchecked")
+    Map<String, ?> config = (Map<String, ?>) result.getServiceConfig().getConfig();
+    assertServiceConfigForLoadBalancingConfig(clusters, config);
+  }
+
+  /**
+   * Verifies the raw service config contains an xDS load balancing config for the given clusters.
+   */
+  private static void assertServiceConfigForLoadBalancingConfig(
+      List<String> clusters, Map<String, ?> actualServiceConfig) {
+    List<Map<String, ?>> rawLbConfigs =
+        JsonUtil.getListOfObjects(actualServiceConfig, "loadBalancingConfig");
+    Map<String, ?> lbConfig = Iterables.getOnlyElement(rawLbConfigs);
+    assertThat(lbConfig.keySet()).containsExactly("cluster_manager_experimental");
+    Map<String, ?> clusterManagerLbConfig =
+        JsonUtil.getObject(lbConfig, "cluster_manager_experimental");
+    Map<String, ?> clusterManagerChildLbPolicies =
+        JsonUtil.getObject(clusterManagerLbConfig, "childPolicy");
+    List<String> expectedChildLbClusterNames = new ArrayList<>(clusters.size());
+    for (String cluster : clusters) {
+      expectedChildLbClusterNames.add("cluster:" + cluster);
+    }
+    assertThat(clusterManagerChildLbPolicies.keySet())
+        .containsExactlyElementsIn(expectedChildLbClusterNames);
+    for (int i = 0; i < clusters.size(); i++) {
+      Map<String, ?> childLbConfig =
+          JsonUtil.getObject(clusterManagerChildLbPolicies, expectedChildLbClusterNames.get(i));
+      assertThat(childLbConfig.keySet()).containsExactly("lbPolicy");
+      List<Map<String, ?>> childLbConfigValues =
+          JsonUtil.getListOfObjects(childLbConfig, "lbPolicy");
+      Map<String, ?> cdsLbPolicy = Iterables.getOnlyElement(childLbConfigValues);
+      assertThat(cdsLbPolicy.keySet()).containsExactly("cds_experimental");
+      assertThat(JsonUtil.getObject(cdsLbPolicy, "cds_experimental"))
+          .containsExactly("cluster", clusters.get(i));
+    }
+  }
+
+  @Test
+  public void generateServiceConfig_forClusterManagerLoadBalancingConfig() throws IOException {
+    Route route1 = Route.forAction(
+        RouteMatch.withPathExactOnly("HelloService/hi"),
+        RouteAction.forCluster(
+            "cluster-foo", Collections.emptyList(), TimeUnit.SECONDS.toNanos(15L), null, false),
+        ImmutableMap.of());
+    Route route2 = Route.forAction(
+        RouteMatch.withPathExactOnly("HelloService/hello"),
+        RouteAction.forWeightedClusters(
+            ImmutableList.of(
+                ClusterWeight.create("cluster-bar", 50, ImmutableMap.of()),
+                ClusterWeight.create("cluster-baz", 50, ImmutableMap.of())),
+            ImmutableList.of(),
+            TimeUnit.SECONDS.toNanos(15L),
+            null, false),
+        ImmutableMap.of());
+    Map<String, ?> rlsConfig = ImmutableMap.of("lookupService", "rls.bigtable.google.com");
+    Route route3 = Route.forAction(
+        RouteMatch.withPathExactOnly("HelloService/greetings"),
+        RouteAction.forClusterSpecifierPlugin(
+            NamedPluginConfig.create("plugin-foo", RlsPluginConfig.create(rlsConfig)),
+            Collections.emptyList(),
+            TimeUnit.SECONDS.toNanos(20L),
+            null, false),
+        ImmutableMap.of());
+
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    xdsClient.deliverLdsUpdateForRdsName(RDS_RESOURCE_NAME);
+    VirtualHost virtualHost =
+        VirtualHost.create("virtualhost", Collections.singletonList(AUTHORITY),
+            ImmutableList.of(route1, route2, route3),
+            ImmutableMap.of());
+    xdsClient.deliverRdsUpdate(RDS_RESOURCE_NAME, Collections.singletonList(virtualHost));
+    createAndDeliverClusterUpdates(xdsClient, "cluster-foo", "cluster-bar", "cluster-baz");
+
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    String expectedServiceConfigJson =
+        "{\n"
+            + "  \"loadBalancingConfig\": [{\n"
+            + "    \"cluster_manager_experimental\": {\n"
+            + "      \"childPolicy\": {\n"
+            + "        \"cluster:cluster-foo\": {\n"
+            + "          \"lbPolicy\": [{\n"
+            + "            \"cds_experimental\": {\n"
+            + "              \"cluster\": \"cluster-foo\"\n"
+            + "            }\n"
+            + "          }]\n"
+            + "        },\n"
+            + "        \"cluster:cluster-bar\": {\n"
+            + "          \"lbPolicy\": [{\n"
+            + "            \"cds_experimental\": {\n"
+            + "              \"cluster\": \"cluster-bar\"\n"
+            + "            }\n"
+            + "          }]\n"
+            + "        },\n"
+            + "        \"cluster:cluster-baz\": {\n"
+            + "          \"lbPolicy\": [{\n"
+            + "            \"cds_experimental\": {\n"
+            + "              \"cluster\": \"cluster-baz\"\n"
+            + "            }\n"
+            + "          }]\n"
+            + "        },\n"
+            + "        \"cluster_specifier_plugin:plugin-foo\": {\n"
+            + "          \"lbPolicy\": [{\n"
+            + "            \"rls_experimental\": {\n"
+            + "              \"routeLookupConfig\": {\n"
+            + "                \"lookupService\": \"rls.bigtable.google.com\"\n"
+            + "              },\n"
+            + "              \"childPolicy\": [\n"
+            + "                {\"cds_experimental\": {\n"
+            + "                  \"is_dynamic\": true\n"
+            + "                }}\n"
+            + "              ],\n"
+            + "              \"childPolicyConfigTargetFieldName\": \"cluster\"\n"
+            + "            }\n"
+            + "          }]\n"
+            + "        }\n"
+            + "      }\n"
+            + "    }\n"
+            + "  }]\n"
+            + "}";
+    assertThat(resolutionResultCaptor.getValue().getServiceConfig().getConfig())
+        .isEqualTo(JsonParser.parse(expectedServiceConfigJson));
+  }
+
+  @SuppressWarnings("unchecked")
+  @Test
+  public void generateServiceConfig_forPerMethodConfig() throws IOException {
+    long timeoutNano = TimeUnit.SECONDS.toNanos(1L) + 1L; // 1.0000000001s
+    RetryPolicy retryPolicy = RetryPolicy.create(
+        4, ImmutableList.of(Code.UNAVAILABLE, Code.CANCELLED), Durations.fromMillis(100),
+        Durations.fromMillis(200), null);
+    RetryPolicy retryPolicyWithEmptyStatusCodes = RetryPolicy.create(
+        4, ImmutableList.of(), Durations.fromMillis(100), Durations.fromMillis(200), null);
+
+    // timeout only
+    String expectedServiceConfigJson = "{\n"
+        + "  \"methodConfig\": [{\n"
+        + "    \"name\": [ {} ],\n"
+        + "    \"timeout\": \"1.000000001s\"\n"
+        + "  }]\n"
+        + "}";
+    Map<String, ?> expectedServiceConfig =
+        (Map<String, ?>) JsonParser.parse(expectedServiceConfigJson);
+    assertThat(XdsNameResolver.generateServiceConfigWithMethodConfig(timeoutNano, null))
+        .isEqualTo(expectedServiceConfig);
+
+    // timeout and retry with empty retriable status codes
+    assertThat(XdsNameResolver.generateServiceConfigWithMethodConfig(
+            timeoutNano, retryPolicyWithEmptyStatusCodes))
+        .isEqualTo(expectedServiceConfig);
+
+    // retry only
+    expectedServiceConfigJson = "{\n"
+        + "  \"methodConfig\": [{\n"
+        + "    \"name\": [ {} ],\n"
+        + "    \"retryPolicy\": {\n"
+        + "      \"maxAttempts\" : 4,\n"
+        + "      \"initialBackoff\": \"0.100s\",\n"
+        + "      \"maxBackoff\": \"0.200s\",\n"
+        + "      \"backoffMultiplier\": 2,\n"
+        + "      \"retryableStatusCodes\": [\n"
+        + "        \"UNAVAILABLE\", \"CANCELLED\"\n"
+        + "      ]\n"
+        + "    }\n"
+        + "  }]\n"
+        + "}";
+    expectedServiceConfig =
+        (Map<String, ?>) JsonParser.parse(expectedServiceConfigJson);
+    assertThat(XdsNameResolver.generateServiceConfigWithMethodConfig(null, retryPolicy))
+        .isEqualTo(expectedServiceConfig);
+
+    // timeout and retry
+    expectedServiceConfigJson = "{\n"
+        + "  \"methodConfig\": [{\n"
+        + "    \"name\": [ {} ],\n"
+        + "    \"retryPolicy\": {\n"
+        + "      \"maxAttempts\" : 4,\n"
+        + "      \"initialBackoff\": \"0.100s\",\n"
+        + "      \"maxBackoff\": \"0.200s\",\n"
+        + "      \"backoffMultiplier\": 2,\n"
+        + "      \"retryableStatusCodes\": [\n"
+        + "        \"UNAVAILABLE\", \"CANCELLED\"\n"
+        + "      ]\n"
+        + "    },\n"
+        + "    \"timeout\": \"1.000000001s\"\n"
+        + "  }]\n"
+        + "}";
+    expectedServiceConfig =
+        (Map<String, ?>) JsonParser.parse(expectedServiceConfigJson);
+    assertThat(XdsNameResolver.generateServiceConfigWithMethodConfig(timeoutNano, retryPolicy))
+        .isEqualTo(expectedServiceConfig);
+
+    // no timeout and no retry
+    expectedServiceConfigJson = "{}";
+    expectedServiceConfig =
+        (Map<String, ?>) JsonParser.parse(expectedServiceConfigJson);
+    assertThat(XdsNameResolver.generateServiceConfigWithMethodConfig(null, null))
+        .isEqualTo(expectedServiceConfig);
+
+    // retry with emtry retriable status codes only
+    assertThat(XdsNameResolver.generateServiceConfigWithMethodConfig(
+            null, retryPolicyWithEmptyStatusCodes))
+        .isEqualTo(expectedServiceConfig);
+  }
+
+  @Test
+  public void matchHostName_exactlyMatch() {
+    String pattern = "foo.googleapis.com";
+    assertThat(XdsNameResolver.matchHostName("bar.googleapis.com", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("fo.googleapis.com", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("oo.googleapis.com", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("googleapis.com", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("foo.googleapis", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("foo.googleapis.com", pattern)).isTrue();
+  }
+
+  @Test
+  public void matchHostName_prefixWildcard() {
+    String pattern = "*.foo.googleapis.com";
+    assertThat(XdsNameResolver.matchHostName("foo.googleapis.com", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("bar-baz.foo.googleapis", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("bar.foo.googleapis.com", pattern)).isTrue();
+    pattern = "*-bar.foo.googleapis.com";
+    assertThat(XdsNameResolver.matchHostName("bar.foo.googleapis.com", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("baz-bar.foo.googleapis", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("-bar.foo.googleapis.com", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("baz-bar.foo.googleapis.com", pattern))
+        .isTrue();
+  }
+
+  @Test
+  public void matchHostName_postfixWildCard() {
+    String pattern = "foo.*";
+    assertThat(XdsNameResolver.matchHostName("bar.googleapis.com", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("bar.foo.googleapis.com", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("foo.googleapis.com", pattern)).isTrue();
+    assertThat(XdsNameResolver.matchHostName("foo.com", pattern)).isTrue();
+    pattern = "foo-*";
+    assertThat(XdsNameResolver.matchHostName("bar-.googleapis.com", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("foo.googleapis.com", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("foo.googleapis.com", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("foo-", pattern)).isFalse();
+    assertThat(XdsNameResolver.matchHostName("foo-bar.com", pattern)).isTrue();
+    assertThat(XdsNameResolver.matchHostName("foo-.com", pattern)).isTrue();
+    assertThat(XdsNameResolver.matchHostName("foo-bar", pattern)).isTrue();
+  }
+
+  @Test
+  public void resolved_faultAbortInLdsUpdate() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
+
+    // header abort, header abort rate = 60 %
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
+        null,
+        FaultAbort.forHeader(FaultConfig.FractionalPercent.perHundred(70)),
+        null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    // no header abort key provided in metadata, rpc should succeed
+    ClientCall.Listener<Void> observer = startNewCall(TestMethodDescriptors.voidMethod(),
+        configSelector, Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcSucceeded(observer);
+    // header abort http status key provided, rpc should fail
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of(HEADER_ABORT_HTTP_STATUS_KEY.name(), "404",
+            HEADER_ABORT_PERCENTAGE_KEY.name(), "60"), CallOptions.DEFAULT);
+    verifyRpcFailed(
+        observer,
+        Status.UNIMPLEMENTED.withDescription(
+            "RPC terminated due to fault injection: HTTP status code 404"));
+    // header abort grpc status key provided, rpc should fail
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of(HEADER_ABORT_GRPC_STATUS_KEY.name(),
+            String.valueOf(Status.UNAUTHENTICATED.getCode().value()),
+            HEADER_ABORT_PERCENTAGE_KEY.name(), "60"), CallOptions.DEFAULT);
+    verifyRpcFailed(
+        observer, Status.UNAUTHENTICATED.withDescription("RPC terminated due to fault injection"));
+    // header abort, both http and grpc code keys provided, rpc should fail with http code
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of(HEADER_ABORT_HTTP_STATUS_KEY.name(), "404",
+            HEADER_ABORT_GRPC_STATUS_KEY.name(),
+            String.valueOf(Status.UNAUTHENTICATED.getCode().value()),
+            HEADER_ABORT_PERCENTAGE_KEY.name(), "60"), CallOptions.DEFAULT);
+    verifyRpcFailed(
+        observer,
+        Status.UNIMPLEMENTED.withDescription(
+            "RPC terminated due to fault injection: HTTP status code 404"));
+
+    // header abort, no header rate, fix rate = 60 %
+    httpFilterFaultConfig = FaultConfig.create(
+        null,
+        FaultAbort.forHeader(FaultConfig.FractionalPercent.perMillion(600_000)),
+        null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
+    verify(mockListener, times(2)).onResult2(resolutionResultCaptor.capture());
+    result = resolutionResultCaptor.getValue();
+    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of(HEADER_ABORT_HTTP_STATUS_KEY.name(), "404"), CallOptions.DEFAULT);
+    verifyRpcFailed(
+        observer,
+        Status.UNIMPLEMENTED.withDescription(
+            "RPC terminated due to fault injection: HTTP status code 404"));
+
+    // header abort, no header rate, fix rate = 0
+    httpFilterFaultConfig = FaultConfig.create(
+        null,
+        FaultAbort.forHeader(FaultConfig.FractionalPercent.perMillion(0)),
+        null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
+    verify(mockListener, times(3)).onResult2(resolutionResultCaptor.capture());
+    result = resolutionResultCaptor.getValue();
+    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of(HEADER_ABORT_HTTP_STATUS_KEY.name(), "404"), CallOptions.DEFAULT);
+    verifyRpcSucceeded(observer);
+
+    // fixed abort, fix rate = 60%
+    httpFilterFaultConfig = FaultConfig.create(
+        null,
+        FaultAbort.forStatus(
+            Status.UNAUTHENTICATED.withDescription("unauthenticated"),
+            FaultConfig.FractionalPercent.perMillion(600_000)),
+        null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
+    verify(mockListener, times(4)).onResult2(resolutionResultCaptor.capture());
+    result = resolutionResultCaptor.getValue();
+    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcFailed(
+        observer,
+        Status.UNAUTHENTICATED.withDescription(
+            "RPC terminated due to fault injection: unauthenticated"));
+
+    // fixed abort, fix rate = 40%
+    httpFilterFaultConfig = FaultConfig.create(
+        null,
+        FaultAbort.forStatus(
+            Status.UNAUTHENTICATED.withDescription("unauthenticated"),
+            FaultConfig.FractionalPercent.perMillion(400_000)),
+        null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
+    verify(mockListener, times(5)).onResult2(resolutionResultCaptor.capture());
+    result = resolutionResultCaptor.getValue();
+    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcSucceeded(observer);
+  }
+
+  @Test
+  public void resolved_faultDelayInLdsUpdate() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
+
+    // header delay, header delay rate = 60 %
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forHeader(FaultConfig.FractionalPercent.perHundred(70)), null, null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    // no header delay key provided in metadata, rpc should succeed immediately
+    ClientCall.Listener<Void> observer = startNewCall(TestMethodDescriptors.voidMethod(),
+        configSelector, Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcSucceeded(observer);
+    // header delay key provided, rpc should be delayed
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of(HEADER_DELAY_KEY.name(), "1000", HEADER_DELAY_PERCENTAGE_KEY.name(), "60"),
+        CallOptions.DEFAULT);
+    verifyRpcDelayed(observer, TimeUnit.MILLISECONDS.toNanos(1000));
+
+    // header delay, no header rate, fix rate = 60 %
+    httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forHeader(FaultConfig.FractionalPercent.perMillion(600_000)), null, null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
+    verify(mockListener, times(2)).onResult2(resolutionResultCaptor.capture());
+    result = resolutionResultCaptor.getValue();
+    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of(HEADER_DELAY_KEY.name(), "1000"), CallOptions.DEFAULT);
+    verifyRpcDelayed(observer, TimeUnit.MILLISECONDS.toNanos(1000));
+
+    // header delay, no header rate, fix rate = 0
+    httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forHeader(FaultConfig.FractionalPercent.perMillion(0)), null, null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
+    verify(mockListener, times(3)).onResult2(resolutionResultCaptor.capture());
+    result = resolutionResultCaptor.getValue();
+    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        ImmutableMap.of(HEADER_DELAY_KEY.name(), "1000"), CallOptions.DEFAULT);
+    verifyRpcSucceeded(observer);
+
+    // fixed delay, fix rate = 60%
+    httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forFixedDelay(5000L, FaultConfig.FractionalPercent.perMillion(600_000)),
+        null,
+        null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
+    verify(mockListener, times(4)).onResult2(resolutionResultCaptor.capture());
+    result = resolutionResultCaptor.getValue();
+    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcDelayed(observer, 5000L);
+
+    // fixed delay, fix rate = 40%
+    httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forFixedDelay(5000L, FaultConfig.FractionalPercent.perMillion(400_000)),
+        null,
+        null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
+    verify(mockListener, times(5)).onResult2(resolutionResultCaptor.capture());
+    result = resolutionResultCaptor.getValue();
+    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcSucceeded(observer);
+  }
+
+  @Test
+  public void resolved_faultDelayWithMaxActiveStreamsInLdsUpdate() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
+
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forFixedDelay(5000L, FaultConfig.FractionalPercent.perMillion(1000_000)),
+        null,
+        /* maxActiveFaults= */ 1);
+    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+
+    // Send two calls, then the first call should delayed and the second call should not be delayed
+    // because maxActiveFaults is exceeded.
+    ClientCall.Listener<Void> observer1 = startNewCall(TestMethodDescriptors.voidMethod(),
+        configSelector, Collections.emptyMap(), CallOptions.DEFAULT);
+    assertThat(testCall).isNull();
+    ClientCall.Listener<Void> observer2 = startNewCall(TestMethodDescriptors.voidMethod(),
+        configSelector, Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcSucceeded(observer2);
+    verifyRpcDelayed(observer1, 5000L);
+    // Once all calls are finished, new call should be delayed.
+    ClientCall.Listener<Void> observer3 = startNewCall(TestMethodDescriptors.voidMethod(),
+        configSelector, Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcDelayed(observer3, 5000L);
+  }
+
+  @Test
+  public void resolved_faultDelayInLdsUpdate_callWithEarlyDeadline() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
+
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forFixedDelay(5000L, FaultConfig.FractionalPercent.perMillion(1000_000)),
+        null,
+        null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+
+    Deadline.Ticker fakeTicker = new Deadline.Ticker() {
+      @Override
+      public long nanoTime() {
+        return fakeClock.getTicker().read();
+      }
+    };
+    ClientCall.Listener<Void> observer = startNewCall(TestMethodDescriptors.voidMethod(),
+        configSelector, Collections.emptyMap(), CallOptions.DEFAULT.withDeadline(
+            Deadline.after(4000, TimeUnit.NANOSECONDS, fakeTicker)));
+    assertThat(testCall).isNull();
+    verifyRpcDelayedThenAborted(observer, 4000L, Status.DEADLINE_EXCEEDED.withDescription(
+        "Deadline exceeded after up to 5000 ns of fault-injected delay:"
+            + " Deadline CallOptions was exceeded after 0.000004000s"));
+  }
+
+  @Test
+  public void resolved_faultAbortAndDelayInLdsUpdateInLdsUpdate() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
+
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
+        FaultDelay.forFixedDelay(5000L, FaultConfig.FractionalPercent.perMillion(1000_000)),
+        FaultAbort.forStatus(
+            Status.UNAUTHENTICATED.withDescription("unauthenticated"),
+            FaultConfig.FractionalPercent.perMillion(1000_000)),
+        null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(cluster1, httpFilterFaultConfig, null, null, null);
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    ClientCall.Listener<Void> observer = startNewCall(TestMethodDescriptors.voidMethod(),
+        configSelector, Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcDelayedThenAborted(
+        observer, 5000L,
+        Status.UNAUTHENTICATED.withDescription(
+            "RPC terminated due to fault injection: unauthenticated"));
+  }
+
+  @Test
+  public void resolved_faultConfigOverrideInLdsUpdate() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
+
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
+        null,
+        FaultAbort.forStatus(
+            Status.UNAUTHENTICATED, FaultConfig.FractionalPercent.perMillion(1000_000)),
+        null);
+    // VirtualHost fault config override
+    FaultConfig virtualHostFaultConfig = FaultConfig.create(
+        null,
+        FaultAbort.forStatus(Status.INTERNAL, FaultConfig.FractionalPercent.perMillion(1000_000)),
+        null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(
+        cluster1, httpFilterFaultConfig, virtualHostFaultConfig, null, null);
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    ClientCall.Listener<Void> observer = startNewCall(TestMethodDescriptors.voidMethod(),
+        configSelector, Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcFailed(
+        observer, Status.INTERNAL.withDescription("RPC terminated due to fault injection"));
+
+    // Route fault config override
+    FaultConfig routeFaultConfig = FaultConfig.create(
+        null,
+        FaultAbort.forStatus(Status.UNKNOWN, FaultConfig.FractionalPercent.perMillion(1000_000)),
+        null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(
+        cluster1, httpFilterFaultConfig, virtualHostFaultConfig, routeFaultConfig, null);
+    verify(mockListener, times(2)).onResult2(resolutionResultCaptor.capture());
+    result = resolutionResultCaptor.getValue();
+    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcFailed(
+        observer, Status.UNKNOWN.withDescription("RPC terminated due to fault injection"));
+
+    // WeightedCluster fault config override
+    FaultConfig weightedClusterFaultConfig = FaultConfig.create(
+        null,
+        FaultAbort.forStatus(
+            Status.UNAVAILABLE, FaultConfig.FractionalPercent.perMillion(1000_000)),
+        null);
+    xdsClient.deliverLdsUpdateWithFaultInjection(
+        cluster1, httpFilterFaultConfig, virtualHostFaultConfig, routeFaultConfig,
+        weightedClusterFaultConfig);
+    verify(mockListener, times(3)).onResult2(resolutionResultCaptor.capture());
+    result = resolutionResultCaptor.getValue();
+    configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    observer = startNewCall(TestMethodDescriptors.voidMethod(), configSelector,
+        Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcFailed(
+        observer, Status.UNAVAILABLE.withDescription("RPC terminated due to fault injection"));
+  }
+
+  @Test
+  public void resolved_faultConfigOverrideInLdsAndInRdsUpdate() {
+    resolver.start(mockListener);
+    FakeXdsClient xdsClient = (FakeXdsClient) resolver.getXdsClient();
+    when(mockRandom.nextInt(1000_000)).thenReturn(500_000); // 50%
+
+    FaultConfig httpFilterFaultConfig = FaultConfig.create(
+        null,
+        FaultAbort.forStatus(
+            Status.UNAUTHENTICATED, FaultConfig.FractionalPercent.perMillion(1000_000)),
+        null);
+    xdsClient.deliverLdsUpdateForRdsNameWithFaultInjection(
+        RDS_RESOURCE_NAME, httpFilterFaultConfig);
+
+    // Route fault config override
+    FaultConfig routeFaultConfig = FaultConfig.create(
+        null,
+        FaultAbort.forStatus(Status.UNKNOWN, FaultConfig.FractionalPercent.perMillion(1000_000)),
+        null);
+    xdsClient.deliverRdsUpdateWithFaultInjection(RDS_RESOURCE_NAME, null, routeFaultConfig, null);
+    verify(mockListener).onResult2(resolutionResultCaptor.capture());
+    ResolutionResult result = resolutionResultCaptor.getValue();
+    InternalConfigSelector configSelector = result.getAttributes().get(InternalConfigSelector.KEY);
+    ClientCall.Listener<Void> observer = startNewCall(TestMethodDescriptors.voidMethod(),
+        configSelector, Collections.emptyMap(), CallOptions.DEFAULT);
+    verifyRpcFailed(
+        observer, Status.UNKNOWN.withDescription("RPC terminated due to fault injection"));
+  }
+
+  private <ReqT, RespT> ClientCall.Listener<RespT> startNewCall(
+      MethodDescriptor<ReqT, RespT> method, InternalConfigSelector selector,
+      Map<String, String> headers, CallOptions callOptions) {
+    Metadata metadata = new Metadata();
+    for (String key : headers.keySet()) {
+      metadata.put(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER), headers.get(key));
+    }
+    @SuppressWarnings("unchecked")
+    ClientCall.Listener<RespT> listener = mock(ClientCall.Listener.class);
+    Result result = selector.selectConfig(newPickSubchannelArgs(method, metadata, callOptions));
+    ClientCall<ReqT, RespT> call = ClientInterceptors.intercept(channel,
+        result.getInterceptor()).newCall(method, callOptions);
+    call.start(listener, metadata);
+    return listener;
+  }
+
+  private void verifyRpcSucceeded(ClientCall.Listener<Void> observer) {
+    assertThat(testCall).isNotNull();
+    testCall.deliverResponseHeaders();
+    testCall.deliverCompleted();
+    verify(observer).onClose(eq(Status.OK), any(Metadata.class));
+    testCall = null;
+  }
+
+  private void verifyRpcFailed(
+      ClientCall.Listener<Void> listener, Status expectedStatus) {
+    verify(listener).onClose(errorCaptor.capture(), any(Metadata.class));
+    assertThat(errorCaptor.getValue().getCode()).isEqualTo(expectedStatus.getCode());
+    assertThat(errorCaptor.getValue().getDescription())
+        .isEqualTo(expectedStatus.getDescription());
+    assertThat(testCall).isNull();
+  }
+
+  private void verifyRpcDelayed(ClientCall.Listener<Void> observer, long expectedDelayNanos) {
+    assertThat(testCall).isNull();
+    verifyNoInteractions(observer);
+    fakeClock.forwardNanos(expectedDelayNanos);
+    verifyRpcSucceeded(observer);
+  }
+
+  private void verifyRpcDelayedThenAborted(
+      ClientCall.Listener<Void> listener, long expectedDelayNanos, Status expectedStatus) {
+    verifyNoInteractions(listener);
+    fakeClock.forwardNanos(expectedDelayNanos);
+    verifyRpcFailed(listener, expectedStatus);
+  }
+
+  private PickSubchannelArgs newPickSubchannelArgs(
+      MethodDescriptor<?, ?> method, Metadata headers, CallOptions callOptions) {
+    return new PickSubchannelArgsImpl(method, headers, callOptions, new PickDetailsConsumer() {});
+  }
+
+  private final class FakeXdsClientPoolFactory implements XdsClientPoolFactory {
+    Set<String> targets = new HashSet<>();
+    XdsClient xdsClient = new FakeXdsClient();
+
+    @Override
+    @Nullable
+    public ObjectPool<XdsClient> get(String target) {
+      throw new UnsupportedOperationException("Should not be called");
+    }
+
+    @Override
+    public ObjectPool<XdsClient> getOrCreate(
+        String target, BootstrapInfo bootstrapInfo, MetricRecorder metricRecorder) {
+      targets.add(target);
+      return new ObjectPool<XdsClient>() {
+        @Override
+        public XdsClient getObject() {
+          return xdsClient;
+        }
+
+        @Override
+        public XdsClient returnObject(Object object) {
+          return null;
+        }
+      };
+    }
+
+    @Override
+    public List<String> getTargets() {
+      if (targets.isEmpty()) {
+        List<String> targetList = new ArrayList<>();
+        targetList.add(targetUri.toString());
+        return targetList;
+      }
+      return new ArrayList<>(targets);
+    }
+  }
+
+  private class FakeXdsClient extends XdsClient {
+    // Should never be subscribing to more than one LDS and RDS resource at any point of time.
+    private String ldsResource;  // should always be AUTHORITY
+    private ResourceWatcher<LdsUpdate> ldsWatcher;
+    private final Map<String, List<ResourceWatcher<RdsUpdate>>> rdsWatchers = new HashMap<>();
+    private final Map<String, List<ResourceWatcher<CdsUpdate>>> cdsWatchers = new HashMap<>();
+    private final Map<String, List<ResourceWatcher<EdsUpdate>>> edsWatchers = new HashMap<>();
+
+    @Override
+    public BootstrapInfo getBootstrapInfo() {
+      return bootstrapInfo;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T extends ResourceUpdate> void watchXdsResource(XdsResourceType<T> resourceType,
+            String resourceName,
+            ResourceWatcher<T> watcher,
+            Executor syncContext) {
+
+      switch (resourceType.typeName()) {
+        case "LDS":
+          assertThat(ldsResource).isNull();
+          assertThat(ldsWatcher).isNull();
+          assertThat(resourceName).isEqualTo(expectedLdsResourceName);
+          ldsResource = resourceName;
+          ldsWatcher = (ResourceWatcher<LdsUpdate>) watcher;
+          break;
+        case "RDS":
+          rdsWatchers.computeIfAbsent(resourceName, k -> new ArrayList<>())
+              .add((ResourceWatcher<RdsUpdate>) watcher);
+          break;
+        case "CDS":
+          cdsWatchers.computeIfAbsent(resourceName, k -> new ArrayList<>())
+              .add((ResourceWatcher<CdsUpdate>) watcher);
+          break;
+        case "EDS":
+          edsWatchers.computeIfAbsent(resourceName, k -> new ArrayList<>())
+              .add((ResourceWatcher<EdsUpdate>) watcher);
+          break;
+        default:
+      }
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T extends ResourceUpdate> void cancelXdsResourceWatch(XdsResourceType<T> type,
+                                                                  String resourceName,
+                                                                  ResourceWatcher<T> watcher) {
+      switch (type.typeName()) {
+        case "LDS":
+          assertThat(ldsResource).isNotNull();
+          assertThat(ldsWatcher).isNotNull();
+          assertThat(resourceName).isEqualTo(expectedLdsResourceName);
+          ldsResource = null;
+          ldsWatcher = null;
+          break;
+        case "RDS":
+          assertThat(rdsWatchers).containsKey(resourceName);
+          assertThat(rdsWatchers.get(resourceName)).contains(watcher);
+          rdsWatchers.get(resourceName).remove((ResourceWatcher<RdsUpdate>) watcher);
+          if (rdsWatchers.get(resourceName).isEmpty()) {
+            rdsWatchers.remove(resourceName);
+          }
+          break;
+        case "CDS":
+          assertThat(cdsWatchers).containsKey(resourceName);
+          assertThat(cdsWatchers.get(resourceName)).contains(watcher);
+          cdsWatchers.get(resourceName).remove((ResourceWatcher<CdsUpdate>) watcher);
+          break;
+        case "EDS":
+          assertThat(edsWatchers).containsKey(resourceName);
+          assertThat(edsWatchers.get(resourceName)).contains(watcher);
+          edsWatchers.get(resourceName).remove((ResourceWatcher<EdsUpdate>) watcher);
+          break;
+        default:
+      }
+    }
+
+    void deliverRdsAmbientError(String resourceName, Status status) {
+      if (!rdsWatchers.containsKey(resourceName)) {
+        return;
+      }
+      syncContext.execute(() -> {
+        List<ResourceWatcher<RdsUpdate>> resourceWatchers =
+            ImmutableList.copyOf(rdsWatchers.get(resourceName));
+        resourceWatchers.forEach(w -> w.onAmbientError(status));
+      });
+    }
+
+    void deliverLdsUpdateOnly(long httpMaxStreamDurationNano, List<VirtualHost> virtualHosts) {
+      syncContext.execute(() -> {
+        LdsUpdate ldsUpdate = LdsUpdate.forApiListener(HttpConnectionManager.forVirtualHosts(
+            httpMaxStreamDurationNano, virtualHosts, null));
+        ldsWatcher.onResourceChanged(StatusOr.fromValue(ldsUpdate));
+      });
+    }
+
+    void deliverLdsUpdate(long httpMaxStreamDurationNano, List<VirtualHost> virtualHosts) {
+      List<String> clusterNames = new ArrayList<>();
+      for (VirtualHost vh : virtualHosts) {
+        clusterNames.addAll(getClusterNames(vh.routes()));
+      }
+
+      syncContext.execute(() -> {
+        LdsUpdate ldsUpdate = LdsUpdate.forApiListener(HttpConnectionManager.forVirtualHosts(
+            httpMaxStreamDurationNano, virtualHosts, null));
+        ldsWatcher.onResourceChanged(StatusOr.fromValue(ldsUpdate));
+        createAndDeliverClusterUpdates(this, clusterNames.toArray(new String[0]));
+      });
+    }
+
+    void deliverLdsUpdate(final List<Route> routes) {
+      VirtualHost virtualHost =
+          VirtualHost.create(
+              "virtual-host", Collections.singletonList(expectedLdsResourceName), routes,
+              ImmutableMap.of());
+      List<String> clusterNames = getClusterNames(routes);
+
+      syncContext.execute(() -> {
+        LdsUpdate ldsUpdate = LdsUpdate.forApiListener(HttpConnectionManager.forVirtualHosts(
+            0L, Collections.singletonList(virtualHost), null));
+        ldsWatcher.onResourceChanged(StatusOr.fromValue(ldsUpdate));
+        if (!clusterNames.isEmpty()) {
+          createAndDeliverClusterUpdates(this, clusterNames.toArray(new String[0]));
+        }
+      });
+    }
+
+    void deliverLdsUpdateWithFilters(VirtualHost vhost, List<NamedFilterConfig> filterConfigs) {
+      syncContext.execute(() -> {
+        LdsUpdate ldsUpdate = LdsUpdate.forApiListener(HttpConnectionManager.forVirtualHosts(
+            0L, Collections.singletonList(vhost), filterConfigs));
+        ldsWatcher.onResourceChanged(StatusOr.fromValue(ldsUpdate));
+      });
+    }
+
+    void deliverLdsUpdateWithFaultInjection(
+        final String cluster,
+        FaultConfig httpFilterFaultConfig,
+        final FaultConfig virtualHostFaultConfig,
+        final FaultConfig routeFaultConfig,
+        final FaultConfig weightedClusterFaultConfig) {
+      if (httpFilterFaultConfig == null) {
+        httpFilterFaultConfig = FaultConfig.create(null, null, null);
+      }
+      List<NamedFilterConfig> filterChain = ImmutableList.of(
+          new NamedFilterConfig(FAULT_FILTER_INSTANCE_NAME, httpFilterFaultConfig),
+          new NamedFilterConfig(ROUTER_FILTER_INSTANCE_NAME, RouterFilter.ROUTER_CONFIG));
+      ImmutableMap<String, FilterConfig> overrideConfig = weightedClusterFaultConfig == null
+          ? ImmutableMap.of()
+          : ImmutableMap.of(
+              FAULT_FILTER_INSTANCE_NAME, weightedClusterFaultConfig);
+      ClusterWeight clusterWeight =
+          ClusterWeight.create(
+              cluster, 100,
+              overrideConfig);
+      overrideConfig = routeFaultConfig == null
+          ? ImmutableMap.of()
+          : ImmutableMap.of(FAULT_FILTER_INSTANCE_NAME, routeFaultConfig);
+      Route route = Route.forAction(
+          RouteMatch.create(
+              PathMatcher.fromPrefix("/", false), Collections.emptyList(), null),
+          RouteAction.forWeightedClusters(
+              Collections.singletonList(clusterWeight),
+              Collections.emptyList(),
+              null,
+              null,
+              false),
+          overrideConfig);
+      overrideConfig = virtualHostFaultConfig == null
+          ? ImmutableMap.of()
+          : ImmutableMap.of(
+              FAULT_FILTER_INSTANCE_NAME, virtualHostFaultConfig);
+      VirtualHost virtualHost = VirtualHost.create(
+          "virtual-host",
+          Collections.singletonList(expectedLdsResourceName),
+          Collections.singletonList(route),
+          overrideConfig);
+      syncContext.execute(() -> {
+        LdsUpdate ldsUpdate = LdsUpdate.forApiListener(HttpConnectionManager.forVirtualHosts(
+            0L, Collections.singletonList(virtualHost), filterChain));
+        ldsWatcher.onResourceChanged(StatusOr.fromValue(ldsUpdate));
+        createAndDeliverClusterUpdates(this, cluster);
+      });
+    }
+
+    void deliverLdsUpdateForRdsNameWithFaultInjection(
+        final String rdsName, @Nullable FaultConfig httpFilterFaultConfig) {
+      if (httpFilterFaultConfig == null) {
+        httpFilterFaultConfig = FaultConfig.create(
+            null, null, null);
+      }
+      ImmutableList<NamedFilterConfig> filterChain = ImmutableList.of(
+          new NamedFilterConfig(FAULT_FILTER_INSTANCE_NAME, httpFilterFaultConfig),
+          new NamedFilterConfig(ROUTER_FILTER_INSTANCE_NAME, RouterFilter.ROUTER_CONFIG));
+      syncContext.execute(() -> {
+        LdsUpdate ldsUpdate = LdsUpdate.forApiListener(HttpConnectionManager.forRdsName(
+            0L, rdsName, filterChain));
+        ldsWatcher.onResourceChanged(StatusOr.fromValue(ldsUpdate));
+      });
+    }
+
+    void deliverLdsUpdateForRdsName(String rdsName) {
+      deliverLdsUpdateForRdsNameWithFilters(rdsName, null);
+    }
+
+    void deliverLdsUpdateForRdsNameWithFilters(
+        String rdsName,
+        @Nullable List<NamedFilterConfig> filterConfigs) {
+      syncContext.execute(() -> {
+        LdsUpdate ldsUpdate = LdsUpdate.forApiListener(HttpConnectionManager.forRdsName(
+            0, rdsName, filterConfigs));
+        ldsWatcher.onResourceChanged(StatusOr.fromValue(ldsUpdate));
+      });
+    }
+
+    void deliverLdsResourceDeletion() {
+      Status status = Status.NOT_FOUND.withDescription(
+          "Resource not found: " + expectedLdsResourceName);
+      syncContext.execute(() -> {
+        ldsWatcher.onAmbientError(status);
+      });
+    }
+
+    void deliverLdsResourceNotFound() {
+      Status notFoundStatus = Status.UNAVAILABLE.withDescription(
+          "Resource not found: " + expectedLdsResourceName);
+      syncContext.execute(() -> {
+        if (ldsWatcher != null) {
+          ldsWatcher.onResourceChanged(StatusOr.fromStatus(notFoundStatus));
+        }
+      });
+    }
+
+    private List<String> getClusterNames(List<Route> routes) {
+      List<String> clusterNames = new ArrayList<>();
+      for (Route r : routes) {
+        if (r.routeAction() == null) {
+          continue;
+        }
+        String cluster = r.routeAction().cluster();
+        if (cluster != null) {
+          clusterNames.add(cluster);
+        } else {
+          List<ClusterWeight> weightedClusters = r.routeAction().weightedClusters();
+          if (weightedClusters == null) {
+            continue;
+          }
+          for (ClusterWeight wc : weightedClusters) {
+            clusterNames.add(wc.name());
+          }
+        }
+      }
+
+      return clusterNames;
+    }
+
+    void deliverRdsUpdateWithFaultInjection(
+        String resourceName, @Nullable FaultConfig virtualHostFaultConfig,
+        @Nullable FaultConfig routFaultConfig, @Nullable FaultConfig weightedClusterFaultConfig) {
+      ImmutableMap<String, FilterConfig> overrideConfig = weightedClusterFaultConfig == null
+          ? ImmutableMap.of()
+          : ImmutableMap.of(
+              FAULT_FILTER_INSTANCE_NAME, weightedClusterFaultConfig);
+      ClusterWeight clusterWeight =
+          ClusterWeight.create(cluster1, 100, overrideConfig);
+      overrideConfig = routFaultConfig == null
+          ? ImmutableMap.of()
+          : ImmutableMap.of(FAULT_FILTER_INSTANCE_NAME, routFaultConfig);
+      Route route = Route.forAction(
+          RouteMatch.create(
+              PathMatcher.fromPrefix("/", false), Collections.emptyList(), null),
+          RouteAction.forWeightedClusters(
+              Collections.singletonList(clusterWeight),
+              Collections.emptyList(),
+              null,
+              null,
+              false),
+          overrideConfig);
+      overrideConfig = virtualHostFaultConfig == null
+          ? ImmutableMap.of()
+          : ImmutableMap.of(
+              FAULT_FILTER_INSTANCE_NAME, virtualHostFaultConfig);
+      VirtualHost virtualHost = VirtualHost.create(
+          "virtual-host",
+          Collections.singletonList(expectedLdsResourceName),
+          Collections.singletonList(route),
+          overrideConfig);
+      deliverRdsUpdate(resourceName, virtualHost);
+      createAndDeliverClusterUpdates(this, cluster1);
+    }
+
+    void deliverRdsUpdate(String resourceName, List<VirtualHost> virtualHosts) {
+      if (!rdsWatchers.containsKey(resourceName)) {
+        return;
+      }
+      syncContext.execute(() -> {
+        RdsUpdate update = new RdsUpdate(virtualHosts);
+        List<ResourceWatcher<RdsUpdate>> resourceWatchers =
+            ImmutableList.copyOf(rdsWatchers.get(resourceName));
+        resourceWatchers.forEach(w -> w.onResourceChanged(StatusOr.fromValue(update)));
+      });
+    }
+
+    void deliverRdsUpdate(String resourceName, VirtualHost virtualHost) {
+      deliverRdsUpdate(resourceName, ImmutableList.of(virtualHost));
+    }
+
+    void deliverRdsResourceNotFound(String resourceName) {
+      if (!rdsWatchers.containsKey(resourceName)) {
+        return;
+      }
+      syncContext.execute(() -> {
+        List<ResourceWatcher<RdsUpdate>> resourceWatchers =
+            ImmutableList.copyOf(rdsWatchers.get(resourceName));
+        Status status = Status.UNAVAILABLE.withDescription("Resource not found: " + resourceName);
+        resourceWatchers.forEach(w -> w.onResourceChanged(StatusOr.fromStatus(status)));
+      });
+    }
+
+    private void deliverCdsUpdate(String clusterName, CdsUpdate update) {
+      if (!cdsWatchers.containsKey(clusterName)) {
+        return;
+      }
+      syncContext.execute(() -> {
+        List<ResourceWatcher<CdsUpdate>> resourceWatchers =
+            ImmutableList.copyOf(cdsWatchers.get(clusterName));
+        resourceWatchers.forEach(w -> w.onResourceChanged(StatusOr.fromValue(update)));
+      });
+    }
+
+    private void deliverEdsUpdate(String name, EdsUpdate update) {
+      syncContext.execute(() -> {
+        if (!edsWatchers.containsKey(name)) {
+          return;
+        }
+        List<ResourceWatcher<EdsUpdate>> resourceWatchers =
+            ImmutableList.copyOf(edsWatchers.get(name));
+        resourceWatchers.forEach(w -> w.onResourceChanged(StatusOr.fromValue(update)));
+      });
+    }
+
+
+    void deliverError(final Status error) {
+      if (ldsWatcher != null) {
+        syncContext.execute(() -> {
+          ldsWatcher.onResourceChanged(StatusOr.fromStatus(error));
+        });
+      }
+      syncContext.execute(() -> {
+        List<ResourceWatcher<RdsUpdate>> rdsCopy = rdsWatchers.values().stream()
+            .flatMap(List::stream).collect(java.util.stream.Collectors.toList());
+        List<ResourceWatcher<CdsUpdate>> cdsCopy = cdsWatchers.values().stream()
+            .flatMap(List::stream).collect(java.util.stream.Collectors.toList());
+        List<ResourceWatcher<EdsUpdate>> edsCopy = edsWatchers.values().stream()
+            .flatMap(List::stream).collect(java.util.stream.Collectors.toList());
+        rdsCopy.forEach(w -> w.onResourceChanged(StatusOr.fromStatus(error)));
+        cdsCopy.forEach(w -> w.onResourceChanged(StatusOr.fromStatus(error)));
+        edsCopy.forEach(w -> w.onResourceChanged(StatusOr.fromStatus(error)));
+      });
+    }
+  }
+
+  private static final class CallInfo {
+    private final String service;
+    private final String method;
+    private final MethodDescriptor<Void, Void> methodDescriptor;
+
+    private CallInfo(String service, String method) {
+      this.service = service;
+      this.method = method;
+      methodDescriptor =
+          MethodDescriptor.<Void, Void>newBuilder()
+              .setType(MethodType.UNARY).setFullMethodName(service + "/" + method)
+              .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+              .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
+              .build();
+    }
+
+    private String getFullMethodNameForPath() {
+      return "/" + service + "/" + method;
+    }
+  }
+
+  private final class TestChannel extends Channel {
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(
+        MethodDescriptor<ReqT, RespT> methodDescriptor, CallOptions callOptions) {
+      TestCall<ReqT, RespT> call = new TestCall<>(callOptions);
+      testCall = call;
+      return call;
+    }
+
+    @Override
+    public String authority() {
+      return "foo.authority";
+    }
+  }
+
+  private static final class TestCall<ReqT, RespT> extends NoopClientCall<ReqT, RespT> {
+    // CallOptions actually received from the channel when the call is created.
+    final CallOptions callOptions;
+    ClientCall.Listener<RespT> listener;
+
+    TestCall(CallOptions callOptions) {
+      this.callOptions = callOptions;
+    }
+
+    @Override
+    public void start(ClientCall.Listener<RespT> listener, Metadata headers) {
+      this.listener = listener;
+    }
+
+    void deliverResponseHeaders() {
+      listener.onHeaders(new Metadata());
+    }
+
+    void deliverCompleted() {
+      listener.onClose(Status.OK, new Metadata());
+    }
+
+    void deliverErrorStatus() {
+      listener.onClose(Status.UNAVAILABLE, new Metadata());
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsSecurityClientServerTest.java b/xds/src/test/java/io/grpc/xds/XdsSecurityClientServerTest.java
new file mode 100644
index 00000000000..9141147702f
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsSecurityClientServerTest.java
@@ -0,0 +1,1017 @@
+/*
+ * Copyright 2019 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.BAD_CLIENT_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.BAD_CLIENT_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.BAD_SERVER_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.BAD_SERVER_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CA_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_SPIFFE_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_SPIFFE_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SPIFFE_TRUST_MAP_1_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SPIFFE_TRUST_MAP_FILE;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.SettableFuture;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress.Protocol;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import io.grpc.Attributes;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.Grpc;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.NameResolver;
+import io.grpc.NameResolverProvider;
+import io.grpc.NameResolverRegistry;
+import io.grpc.Server;
+import io.grpc.ServerCredentials;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.StatusRuntimeException;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import io.grpc.xds.EnvoyServerProtoData.ConnectionSourceType;
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.Filter.FilterConfig;
+import io.grpc.xds.Filter.NamedFilterConfig;
+import io.grpc.xds.VirtualHost.Route;
+import io.grpc.xds.VirtualHost.Route.RouteMatch;
+import io.grpc.xds.VirtualHost.Route.RouteMatch.PathMatcher;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.XdsServerTestHelper.FakeXdsClient;
+import io.grpc.xds.XdsServerTestHelper.FakeXdsClientPoolFactory;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.CommonBootstrapperTestUtils;
+import io.grpc.xds.internal.Matchers.HeaderMatcher;
+import io.grpc.xds.internal.XdsInternalAttributes;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil;
+import io.grpc.xds.internal.security.SecurityProtocolNegotiators;
+import io.grpc.xds.internal.security.SslContextProviderSupplier;
+import io.grpc.xds.internal.security.TlsContextManagerImpl;
+import io.grpc.xds.internal.security.certprovider.FileWatcherCertificateProviderProvider;
+import io.grpc.xds.internal.security.trust.CertificateUtils;
+import io.netty.handler.ssl.NotSslRecordException;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.Inet4Address;
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.CertificateException;
+import java.security.cert.CertificateFactory;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import javax.net.ssl.SSLException;
+import javax.net.ssl.SSLHandshakeException;
+import javax.net.ssl.TrustManagerFactory;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
+/**
+ * Unit tests for {@link XdsChannelCredentials} and {@link XdsServerBuilder} for plaintext/TLS/mTLS
+ * modes.
+ */
+@RunWith(Parameterized.class)
+public class XdsSecurityClientServerTest {
+ 
+  private static final String SNI_IN_UTC = "waterzooi.test.google.be";
+
+  @Parameter
+  public Boolean enableSpiffe;
+  private Boolean originalEnableSpiffe;
+
+  @Rule public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+  private int port;
+  private FakeNameResolverFactory fakeNameResolverFactory;
+  private Bootstrapper.BootstrapInfo bootstrapInfoForClient = null;
+  private Bootstrapper.BootstrapInfo bootstrapInfoForServer = null;
+  private TlsContextManagerImpl tlsContextManagerForClient;
+  private TlsContextManagerImpl tlsContextManagerForServer;
+  private FakeXdsClient xdsClient = new FakeXdsClient();
+  private FakeXdsClientPoolFactory fakePoolFactory = new FakeXdsClientPoolFactory(xdsClient);
+  private static final String OVERRIDE_AUTHORITY = "foo.test.google.fr";
+  private Attributes sslContextAttributes;
+
+  @Parameters(name = "enableSpiffe={0}")
+  public static Collection<Boolean> data() {
+    return ImmutableList.of(true, false);
+  }
+
+  @Before
+  public void setUp() throws IOException {
+    saveEnvironment();
+    FileWatcherCertificateProviderProvider.enableSpiffe = enableSpiffe;
+  }
+
+  private void saveEnvironment() {
+    originalEnableSpiffe = FileWatcherCertificateProviderProvider.enableSpiffe;
+  }
+
+  @After
+  public void tearDown() throws IOException {
+    if (fakeNameResolverFactory != null) {
+      NameResolverRegistry.getDefaultRegistry().deregister(fakeNameResolverFactory);
+    }
+    FileWatcherCertificateProviderProvider.enableSpiffe = originalEnableSpiffe;
+    if (sslContextAttributes != null) {
+      SslContextProviderSupplier sslContextProviderSupplier = sslContextAttributes.get(
+              SecurityProtocolNegotiators.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER);
+      if (sslContextProviderSupplier != null) {
+        sslContextProviderSupplier.close();
+      }
+      sslContextAttributes = null;
+    }
+  }
+
+  @Test
+  public void plaintextClientServer() throws Exception {
+    buildServerWithTlsContext(/* downstreamTlsContext= */ null);
+
+    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+        getBlockingStub(/* upstreamTlsContext= */ null,
+                /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+    assertThat(unaryRpc("buddy", blockingStub)).isEqualTo("Hello buddy");
+  }
+
+  @Test
+  public void nullFallbackCredentials_expectException() throws Exception {
+    try {
+      buildServerWithTlsContext(/* downstreamTlsContext= */ null, /* fallbackCredentials= */ null);
+      fail("exception expected");
+    } catch (NullPointerException npe) {
+      assertThat(npe).hasMessageThat().isEqualTo("fallback");
+    }
+  }
+
+  /** TLS channel - no mTLS. */
+  @Test
+  public void tlsClientServer_noClientAuthentication() throws Exception {
+    DownstreamTlsContext downstreamTlsContext =
+        setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, null, null, null, null,
+            null, false, false);
+    buildServerWithTlsContext(downstreamTlsContext);
+
+    // for TLS, client only needs trustCa
+    UpstreamTlsContext upstreamTlsContext = setBootstrapInfoAndBuildUpstreamTlsContext(
+        CLIENT_KEY_FILE, CLIENT_PEM_FILE, null, false);
+
+    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+        getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+    assertThat(unaryRpc(/* requestMessage= */ "buddy", blockingStub)).isEqualTo("Hello buddy");
+  }
+
+  /**
+   * Use system root ca cert for TLS channel - no mTLS.
+   * Uses common_tls_context.combined_validation_context in upstream_tls_context.
+   */
+  @Test
+  public void tlsClientServer_useSystemRootCerts_noMtls_useCombinedValidationContext()
+      throws Exception {
+    Path trustStoreFilePath = getCacertFilePathForTestCa();
+    try {
+      setTrustStoreSystemProperties(trustStoreFilePath.toAbsolutePath().toString());
+      DownstreamTlsContext downstreamTlsContext =
+          setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, null, null, null, null,
+              null, false, false);
+      buildServerWithTlsContext(downstreamTlsContext);
+
+      UpstreamTlsContext upstreamTlsContext =
+          setBootstrapInfoAndBuildUpstreamTlsContextForUsingSystemRootCerts(CLIENT_KEY_FILE,
+              CLIENT_PEM_FILE, true, SNI_IN_UTC, false, "", false, false);
+
+      SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+          getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+      assertThat(unaryRpc(/* requestMessage= */ "buddy", blockingStub)).isEqualTo("Hello buddy");
+    } finally {
+      Files.deleteIfExists(trustStoreFilePath);
+      clearTrustStoreSystemProperties();
+    }
+  }
+
+  /**
+   * Use system root ca cert for TLS channel - no mTLS.
+   * Uses common_tls_context.validation_context in upstream_tls_context.
+   */
+  @Test
+  public void tlsClientServer_useSystemRootCerts_noMtls_validationContext() throws Exception {
+    Path trustStoreFilePath = getCacertFilePathForTestCa().toAbsolutePath();
+    try {
+      setTrustStoreSystemProperties(trustStoreFilePath.toAbsolutePath().toString());
+      DownstreamTlsContext downstreamTlsContext =
+          setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, null, null, null, null,
+              null, false, false);
+      buildServerWithTlsContext(downstreamTlsContext);
+
+      UpstreamTlsContext upstreamTlsContext =
+          setBootstrapInfoAndBuildUpstreamTlsContextForUsingSystemRootCerts(CLIENT_KEY_FILE,
+              CLIENT_PEM_FILE, false, SNI_IN_UTC, false, null, false, false);
+
+      SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+          getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+      assertThat(unaryRpc(/* requestMessage= */ "buddy", blockingStub)).isEqualTo("Hello buddy");
+    } finally {
+      Files.deleteIfExists(trustStoreFilePath.toAbsolutePath());
+      clearTrustStoreSystemProperties();
+    }
+  }
+
+  @Test
+  public void tlsClientServer_useSystemRootCerts_mtls() throws Exception {
+    Path trustStoreFilePath = getCacertFilePathForTestCa();
+    try {
+      setTrustStoreSystemProperties(trustStoreFilePath.toAbsolutePath().toString());
+      DownstreamTlsContext downstreamTlsContext =
+          setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, null, null, null, null,
+              null, false, true);
+      buildServerWithTlsContext(downstreamTlsContext);
+
+      UpstreamTlsContext upstreamTlsContext =
+          setBootstrapInfoAndBuildUpstreamTlsContextForUsingSystemRootCerts(CLIENT_KEY_FILE,
+              CLIENT_PEM_FILE, true, SNI_IN_UTC, true, "", false, false);
+
+      SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+          getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+      assertThat(unaryRpc(/* requestMessage= */ "buddy", blockingStub)).isEqualTo("Hello buddy");
+    } finally {
+      Files.deleteIfExists(trustStoreFilePath);
+      clearTrustStoreSystemProperties();
+    }
+  }
+
+  @Test
+  public void tlsClientServer_noAutoSniValidation_failureToMatchSubjAltNames()
+      throws Exception {
+    Path trustStoreFilePath = getCacertFilePathForTestCa();
+    try {
+      setTrustStoreSystemProperties(trustStoreFilePath.toAbsolutePath().toString());
+      DownstreamTlsContext downstreamTlsContext =
+          setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, null, null, null, null,
+              null, false, false);
+      buildServerWithTlsContext(downstreamTlsContext);
+
+      UpstreamTlsContext upstreamTlsContext =
+          setBootstrapInfoAndBuildUpstreamTlsContextForUsingSystemRootCerts(CLIENT_KEY_FILE,
+              CLIENT_PEM_FILE, true, "server1.test.google.in", false, "", false, false);
+
+      SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+          getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+      unaryRpc(/* requestMessage= */ "buddy", blockingStub);
+      fail("Expected handshake failure exception");
+    } catch (StatusRuntimeException e) {
+      assertThat(e.getCause()).isInstanceOf(SSLHandshakeException.class);
+      assertThat(e.getCause().getCause()).isInstanceOf(CertificateException.class);
+      assertThat(e.getCause().getCause().getMessage()).isEqualTo(
+          "Peer certificate SAN check failed");
+    } finally {
+      Files.deleteIfExists(trustStoreFilePath);
+      clearTrustStoreSystemProperties();
+    }
+  }
+
+
+  @Test
+  public void tlsClientServer_autoSniValidation_sniInUtc()
+      throws Exception {
+    CertificateUtils.isXdsSniEnabled = true;
+    Path trustStoreFilePath = getCacertFilePathForTestCa();
+    try {
+      setTrustStoreSystemProperties(trustStoreFilePath.toAbsolutePath().toString());
+      DownstreamTlsContext downstreamTlsContext =
+          setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, null, null, null, null,
+              null, false, false);
+      buildServerWithTlsContext(downstreamTlsContext);
+
+      UpstreamTlsContext upstreamTlsContext =
+          setBootstrapInfoAndBuildUpstreamTlsContextForUsingSystemRootCerts(CLIENT_KEY_FILE,
+              CLIENT_PEM_FILE, true,
+              // SAN matcher in CommonValidationContext. Will be overridden by autoSniSanValidation
+              "server1.test.google.in",
+              false,
+              SNI_IN_UTC,
+              false, true);
+
+      SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+          getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+      unaryRpc(/* requestMessage= */ "buddy", blockingStub);
+    } finally {
+      Files.deleteIfExists(trustStoreFilePath);
+      clearTrustStoreSystemProperties();
+      CertificateUtils.isXdsSniEnabled = false;
+    }
+  }
+
+  @Test
+  public void tlsClientServer_autoSniValidation_sniFromHostname()
+      throws Exception {
+    CertificateUtils.isXdsSniEnabled = true;
+    Path trustStoreFilePath = getCacertFilePathForTestCa();
+    try {
+      setTrustStoreSystemProperties(trustStoreFilePath.toAbsolutePath().toString());
+      DownstreamTlsContext downstreamTlsContext =
+          setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, null, null, null, null,
+              null, false, false);
+      buildServerWithTlsContext(downstreamTlsContext);
+
+      UpstreamTlsContext upstreamTlsContext =
+          setBootstrapInfoAndBuildUpstreamTlsContextForUsingSystemRootCerts(CLIENT_KEY_FILE,
+              CLIENT_PEM_FILE, true,
+              // SAN matcher in CommonValidationContext. Will be overridden by autoSniSanValidation
+              "server1.test.google.in",
+              false,
+              "",
+              true, true);
+
+      // TODO: Change this to foo.test.gooogle.fr that needs wildcard matching after
+      // https://github.com/grpc/grpc-java/pull/12345 is done
+      SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+          getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY,
+              "waterzooi.test.google.be");
+      unaryRpc(/* requestMessage= */ "buddy", blockingStub);
+    } finally {
+      Files.deleteIfExists(trustStoreFilePath);
+      clearTrustStoreSystemProperties();
+      CertificateUtils.isXdsSniEnabled = false;
+    }
+  }
+
+  @Test
+  public void tlsClientServer_autoSniValidation_noSniApplicable_usesMatcherFromCmnVdnCtx()
+      throws Exception {
+    CertificateUtils.isXdsSniEnabled = true;
+    Path trustStoreFilePath = getCacertFilePathForTestCa();
+    try {
+      setTrustStoreSystemProperties(trustStoreFilePath.toAbsolutePath().toString());
+      DownstreamTlsContext downstreamTlsContext =
+          setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, null, null, null, null,
+              null, false, false);
+      buildServerWithTlsContext(downstreamTlsContext);
+
+      UpstreamTlsContext upstreamTlsContext =
+          setBootstrapInfoAndBuildUpstreamTlsContextForUsingSystemRootCerts(CLIENT_KEY_FILE,
+              CLIENT_PEM_FILE, true,
+              // This is what will get used for the SAN validation since no SNI was used
+              "waterzooi.test.google.be",
+              false,
+              "",
+              false, true);
+
+      SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+          getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+      unaryRpc(/* requestMessage= */ "buddy", blockingStub);
+    } finally {
+      Files.deleteIfExists(trustStoreFilePath);
+      clearTrustStoreSystemProperties();
+      CertificateUtils.isXdsSniEnabled = false;
+    }
+  }
+
+  /**
+   * Use system root ca cert for TLS channel - mTLS.
+   */
+  @Test
+  public void tlsClientServer_useSystemRootCerts_requireClientAuth() throws Exception {
+    Path trustStoreFilePath = getCacertFilePathForTestCa().toAbsolutePath();
+    try {
+      setTrustStoreSystemProperties(trustStoreFilePath.toAbsolutePath().toString());
+      DownstreamTlsContext downstreamTlsContext =
+          setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, null, null, null, null,
+              null, false, true);
+      buildServerWithTlsContext(downstreamTlsContext);
+
+      UpstreamTlsContext upstreamTlsContext =
+          setBootstrapInfoAndBuildUpstreamTlsContextForUsingSystemRootCerts(CLIENT_KEY_FILE,
+              CLIENT_PEM_FILE, true, SNI_IN_UTC, false, "", false, false);
+      SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+          getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+      assertThat(unaryRpc(/* requestMessage= */ "buddy", blockingStub)).isEqualTo("Hello buddy");
+    } finally {
+      Files.deleteIfExists(trustStoreFilePath.toAbsolutePath());
+      clearTrustStoreSystemProperties();
+    }
+  }
+
+  private Path getCacertFilePathForTestCa()
+      throws IOException, KeyStoreException, CertificateException, NoSuchAlgorithmException {
+    KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
+    keystore.load(null, null);
+    InputStream caCertStream = getClass().getResource("/certs/ca.pem").openStream();
+    keystore.setCertificateEntry("testca", CertificateFactory.getInstance("X.509")
+        .generateCertificate(caCertStream));
+    caCertStream.close();
+    File trustStoreFile = File.createTempFile("testca-truststore", "jks");
+    FileOutputStream out = new FileOutputStream(trustStoreFile);
+    keystore.store(out, "changeit".toCharArray());
+    out.close();
+    return trustStoreFile.toPath();
+  }
+
+  @Test
+  public void tlsClientServer_Spiffe_noClientAuthentication() throws Exception {
+    DownstreamTlsContext downstreamTlsContext =
+        setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_SPIFFE_PEM_FILE, null, null, null,
+            null, null, false, false);
+    buildServerWithTlsContext(downstreamTlsContext);
+
+    // for TLS, client only needs trustCa, so BAD certs don't matter
+    UpstreamTlsContext upstreamTlsContext = setBootstrapInfoAndBuildUpstreamTlsContext(
+        BAD_CLIENT_KEY_FILE, BAD_CLIENT_PEM_FILE, SPIFFE_TRUST_MAP_FILE, false);
+
+    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+        getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+    assertThat(unaryRpc(/* requestMessage= */ "buddy", blockingStub)).isEqualTo("Hello buddy");
+  }
+
+  @Test
+  public void tlsClientServer_Spiffe_noClientAuthentication_wrongServerCert() throws Exception {
+    if (!enableSpiffe) {
+      return;
+    }
+    DownstreamTlsContext downstreamTlsContext =
+        setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, null, null, null, null,
+            null, false, false);
+    buildServerWithTlsContext(downstreamTlsContext);
+
+    // for TLS, client only needs trustCa, so BAD certs don't matter
+    UpstreamTlsContext upstreamTlsContext = setBootstrapInfoAndBuildUpstreamTlsContext(
+        BAD_CLIENT_KEY_FILE, BAD_CLIENT_PEM_FILE, SPIFFE_TRUST_MAP_FILE, false);
+
+    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+        getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+    try {
+      unaryRpc("buddy", blockingStub);
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre.getStatus().getCode()).isEqualTo(Status.UNAVAILABLE.getCode());
+      assertThat(sre.getCause().getCause().getMessage())
+          .contains("Failed to extract SPIFFE ID from peer leaf certificate");
+    }
+  }
+
+  @Test
+  public void requireClientAuth_noClientCert_expectException()
+      throws Exception {
+    DownstreamTlsContext downstreamTlsContext =
+        setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, null, null, null, null,
+            null, true, true);
+    buildServerWithTlsContext(downstreamTlsContext);
+
+    // for TLS, client only uses trustCa
+    UpstreamTlsContext upstreamTlsContext = setBootstrapInfoAndBuildUpstreamTlsContext(
+        CLIENT_KEY_FILE, CLIENT_PEM_FILE, null, false);
+
+    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+        getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+    try {
+      unaryRpc(/* requestMessage= */ "buddy", blockingStub);
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      if (sre.getCause() instanceof SSLHandshakeException) {
+        assertThat(sre).hasCauseThat().isInstanceOf(SSLHandshakeException.class);
+        assertThat(sre).hasCauseThat().hasMessageThat().contains("HANDSHAKE_FAILURE");
+      } else {
+        // Client cert verification is after handshake in TLSv1.3
+        assertThat(sre).hasCauseThat().hasCauseThat().isInstanceOf(SSLException.class);
+        assertThat(sre).hasCauseThat().hasMessageThat().contains("CERTIFICATE_REQUIRED");
+      }
+    }
+  }
+
+  @Test
+  public void noClientAuth_sendBadClientCert_passes() throws Exception {
+    DownstreamTlsContext downstreamTlsContext =
+        setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, null, null, null, null,
+            null, false, false);
+    buildServerWithTlsContext(downstreamTlsContext);
+
+    UpstreamTlsContext upstreamTlsContext = setBootstrapInfoAndBuildUpstreamTlsContext(
+        BAD_CLIENT_KEY_FILE, BAD_CLIENT_PEM_FILE, null, true);
+
+    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+        getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+    assertThat(unaryRpc("buddy", blockingStub)).isEqualTo("Hello buddy");
+  }
+
+  @Test
+  public void mtls_badClientCert_expectException() throws Exception {
+    UpstreamTlsContext upstreamTlsContext = setBootstrapInfoAndBuildUpstreamTlsContext(
+        BAD_CLIENT_KEY_FILE, BAD_CLIENT_PEM_FILE, null, true);
+    try {
+      performMtlsTestAndGetListenerWatcher(upstreamTlsContext, null, null, null, null);
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      if (sre.getCause() instanceof SSLHandshakeException) {
+        assertThat(sre).hasCauseThat().isInstanceOf(SSLHandshakeException.class);
+        assertThat(sre).hasCauseThat().hasMessageThat().contains("HANDSHAKE_FAILURE");
+      } else {
+        // Client cert verification is after handshake in TLSv1.3
+        assertThat(sre).hasCauseThat().hasCauseThat().isInstanceOf(SSLException.class);
+        assertThat(sre).hasCauseThat().hasMessageThat().contains("CERTIFICATE_REQUIRED");
+      }
+    }
+  }
+
+  /** mTLS with Spiffe Trust Bundle - client auth enabled - using {@link XdsChannelCredentials}
+   * API. */
+  @Test
+  public void mtlsClientServer_Spiffe_withClientAuthentication_withXdsChannelCreds()
+      throws Exception {
+    DownstreamTlsContext downstreamTlsContext =
+        setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_SPIFFE_PEM_FILE, null, null, null,
+            null, SPIFFE_TRUST_MAP_1_FILE, true, true);
+    buildServerWithTlsContext(downstreamTlsContext);
+
+    UpstreamTlsContext upstreamTlsContext = setBootstrapInfoAndBuildUpstreamTlsContext(
+        CLIENT_KEY_FILE, CLIENT_SPIFFE_PEM_FILE, SPIFFE_TRUST_MAP_1_FILE, true);
+
+    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+        getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+    assertThat(unaryRpc(/* requestMessage= */ "buddy", blockingStub)).isEqualTo("Hello buddy");
+  }
+
+  @Test
+  public void mtlsClientServer_Spiffe_badClientCert_expectException()
+      throws Exception {
+    DownstreamTlsContext downstreamTlsContext =
+        setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_SPIFFE_PEM_FILE, null, null, null,
+            null, SPIFFE_TRUST_MAP_1_FILE, true, true);
+    buildServerWithTlsContext(downstreamTlsContext);
+
+    UpstreamTlsContext upstreamTlsContext = setBootstrapInfoAndBuildUpstreamTlsContext(
+        CLIENT_KEY_FILE, BAD_CLIENT_PEM_FILE, SPIFFE_TRUST_MAP_1_FILE, true);
+    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+        getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+    try {
+      assertThat(unaryRpc(/* requestMessage= */ "buddy", blockingStub)).isEqualTo("Hello buddy");
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre.getStatus().getCode()).isEqualTo(Status.UNAVAILABLE.getCode());
+      assertThat(sre.getMessage()).contains("ssl exception");
+    }
+  }
+
+  @Test
+  public void mtlsClientServer_withClientAuthentication_withXdsChannelCreds()
+      throws Exception {
+    UpstreamTlsContext upstreamTlsContext = setBootstrapInfoAndBuildUpstreamTlsContext(
+        CLIENT_KEY_FILE, CLIENT_PEM_FILE, null, true);
+    performMtlsTestAndGetListenerWatcher(upstreamTlsContext, null, null, null, null);
+  }
+
+  @Test
+  public void tlsServer_plaintextClient_expectException() throws Exception {
+    DownstreamTlsContext downstreamTlsContext =
+        setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, null, null, null, null,
+            null, false, false);
+    buildServerWithTlsContext(downstreamTlsContext);
+
+    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+        getBlockingStub(/* upstreamTlsContext= */ null, /* overrideAuthority= */ null);
+    try {
+      unaryRpc("buddy", blockingStub);
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre.getStatus().getCode()).isEqualTo(Status.UNAVAILABLE.getCode());
+      assertThat(sre.getStatus().getDescription()).contains("Network closed");
+    }
+  }
+
+  @Test
+  public void plaintextServer_tlsClient_expectException() throws Exception {
+    buildServerWithTlsContext(/* downstreamTlsContext= */ null);
+
+    // for TLS, client only needs trustCa
+    UpstreamTlsContext upstreamTlsContext = setBootstrapInfoAndBuildUpstreamTlsContext(
+        CLIENT_KEY_FILE, CLIENT_PEM_FILE, null, false);
+
+    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+        getBlockingStub(upstreamTlsContext, /* overrideAuthority= */ OVERRIDE_AUTHORITY);
+    try {
+      unaryRpc("buddy", blockingStub);
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasCauseThat().isInstanceOf(NotSslRecordException.class);
+      assertThat(sre).hasCauseThat().hasMessageThat().contains("not an SSL/TLS record");
+    }
+  }
+
+  /** mTLS - client auth enabled then update server certs to untrusted. */
+  @Test
+  public void mtlsClientServer_changeServerContext_expectException()
+      throws Exception {
+    UpstreamTlsContext upstreamTlsContext = setBootstrapInfoAndBuildUpstreamTlsContext(
+        CLIENT_KEY_FILE, CLIENT_PEM_FILE, null, true);
+
+    performMtlsTestAndGetListenerWatcher(upstreamTlsContext, "cert-instance-name2",
+            BAD_SERVER_KEY_FILE, BAD_SERVER_PEM_FILE, CA_PEM_FILE);
+    DownstreamTlsContext downstreamTlsContext =
+        CommonTlsContextTestsUtil.buildDownstreamTlsContext(
+            "cert-instance-name2", true, true);
+    EnvoyServerProtoData.Listener listener = buildListener("listener1", "0.0.0.0:0",
+            downstreamTlsContext,
+            tlsContextManagerForServer);
+    xdsClient.deliverLdsUpdate(LdsUpdate.forTcpListener(listener));
+    try {
+      SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+          getBlockingStub(upstreamTlsContext, OVERRIDE_AUTHORITY);
+      assertThat(unaryRpc("buddy", blockingStub)).isEqualTo("Hello buddy");
+      fail("exception expected");
+    } catch (StatusRuntimeException sre) {
+      assertThat(sre).hasCauseThat().isInstanceOf(SSLHandshakeException.class);
+      assertThat(sre).hasCauseThat().hasMessageThat().isEqualTo("General OpenSslEngine problem");
+    }
+  }
+
+  private void performMtlsTestAndGetListenerWatcher(
+      UpstreamTlsContext upstreamTlsContext, String certInstanceName2,
+      String privateKey2, String cert2, String trustCa2)
+      throws Exception {
+    DownstreamTlsContext downstreamTlsContext =
+        setBootstrapInfoAndBuildDownstreamTlsContext(SERVER_1_PEM_FILE, certInstanceName2,
+            privateKey2, cert2, trustCa2, null, true, false);
+
+    buildServerWithFallbackServerCredentials(
+            InsecureServerCredentials.create(), downstreamTlsContext);
+
+    SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub =
+            getBlockingStub(upstreamTlsContext, OVERRIDE_AUTHORITY);
+    assertThat(unaryRpc("buddy", blockingStub)).isEqualTo("Hello buddy");
+  }
+
+  private DownstreamTlsContext setBootstrapInfoAndBuildDownstreamTlsContext(
+      String cert1, String certInstanceName2, String privateKey2,
+      String cert2, String trustCa2, String spiffeFile,
+      boolean hasRootCert, boolean requireClientCertificate) {
+    bootstrapInfoForServer = CommonBootstrapperTestUtils
+        .buildBootstrapInfo("google_cloud_private_spiffe-server", SERVER_1_KEY_FILE,
+            cert1, CA_PEM_FILE, certInstanceName2, privateKey2, cert2, trustCa2, spiffeFile);
+    return CommonTlsContextTestsUtil.buildDownstreamTlsContext(
+        "google_cloud_private_spiffe-server", hasRootCert, requireClientCertificate);
+  }
+
+  private UpstreamTlsContext setBootstrapInfoAndBuildUpstreamTlsContext(String clientKeyFile,
+      String clientPemFile, String spiffeFile, boolean hasIdentityCert) {
+    bootstrapInfoForClient = CommonBootstrapperTestUtils
+        .buildBootstrapInfo("google_cloud_private_spiffe-client", clientKeyFile, clientPemFile,
+            CA_PEM_FILE, null, null, null, null, spiffeFile);
+    return CommonTlsContextTestsUtil
+        .buildUpstreamTlsContext("google_cloud_private_spiffe-client", hasIdentityCert);
+  }
+
+  @SuppressWarnings("deprecation") // gRFC A29 predates match_typed_subject_alt_names
+  private UpstreamTlsContext setBootstrapInfoAndBuildUpstreamTlsContextForUsingSystemRootCerts(
+      String clientKeyFile,
+      String clientPemFile,
+      boolean useCombinedValidationContext,
+      String sanToMatch,
+      boolean isMtls,
+      String sniInUpstreamTlsContext,
+      boolean autoHostSni, boolean autoSniSanValidation) {
+    bootstrapInfoForClient = CommonBootstrapperTestUtils
+        .buildBootstrapInfo("google_cloud_private_spiffe-client", clientKeyFile, clientPemFile,
+            CA_PEM_FILE, null, null, null, null, null);
+    if (useCombinedValidationContext) {
+      return CommonTlsContextTestsUtil.buildUpstreamTlsContextForCertProviderInstance(
+          isMtls ? "google_cloud_private_spiffe-client" : null,
+          isMtls ? "ROOT" : null, null,
+          null, null,
+          CertificateValidationContext.newBuilder()
+              .setSystemRootCerts(
+                  CertificateValidationContext.SystemRootCerts.newBuilder().build())
+              .addMatchSubjectAltNames(
+                  StringMatcher.newBuilder()
+                      .setExact(sanToMatch))
+              .build(), sniInUpstreamTlsContext, autoHostSni, autoSniSanValidation);
+    }
+    return CommonTlsContextTestsUtil.buildNewUpstreamTlsContextForCertProviderInstance(
+        "google_cloud_private_spiffe-client", "ROOT", null,
+        null, null, CertificateValidationContext.newBuilder()
+            .setSystemRootCerts(
+                CertificateValidationContext.SystemRootCerts.newBuilder().build())
+            .build());
+  }
+
+  private void buildServerWithTlsContext(DownstreamTlsContext downstreamTlsContext)
+      throws Exception {
+    buildServerWithTlsContext(downstreamTlsContext, InsecureServerCredentials.create());
+  }
+
+  private void buildServerWithTlsContext(
+      DownstreamTlsContext downstreamTlsContext, ServerCredentials fallbackCredentials)
+      throws Exception {
+    buildServerWithFallbackServerCredentials(fallbackCredentials, downstreamTlsContext);
+  }
+
+  private void buildServerWithFallbackServerCredentials(
+      ServerCredentials fallbackCredentials,
+      DownstreamTlsContext downstreamTlsContext)
+      throws Exception {
+    ServerCredentials xdsCredentials = XdsServerCredentials.create(fallbackCredentials);
+    XdsServerBuilder builder = XdsServerBuilder.forPort(0, xdsCredentials)
+            .xdsClientPoolFactory(fakePoolFactory)
+            .overrideBootstrapForTest(XdsServerTestHelper.RAW_BOOTSTRAP)
+            .addService(new SimpleServiceImpl());
+    buildServer(builder, downstreamTlsContext);
+  }
+
+  private void buildServer(
+      XdsServerBuilder builder,
+      DownstreamTlsContext downstreamTlsContext)
+      throws Exception {
+    tlsContextManagerForServer = new TlsContextManagerImpl(bootstrapInfoForServer);
+    XdsServerWrapper xdsServer = (XdsServerWrapper) builder.build();
+    SettableFuture<Throwable> startFuture = startServerAsync(xdsServer);
+    EnvoyServerProtoData.Listener listener = buildListener("listener1", "0.0.0.0:0",
+            downstreamTlsContext, tlsContextManagerForServer);
+    LdsUpdate listenerUpdate = LdsUpdate.forTcpListener(listener);
+    xdsClient.deliverLdsUpdate(listenerUpdate);
+    startFuture.get(10, TimeUnit.SECONDS);
+    port = xdsServer.getPort();
+    URI expectedUri = new URI("sectest://localhost:" + port);
+    fakeNameResolverFactory = new FakeNameResolverFactory.Builder(expectedUri).build();
+    NameResolverRegistry.getDefaultRegistry().register(fakeNameResolverFactory);
+  }
+
+  static EnvoyServerProtoData.Listener buildListener(
+      String name, String address, DownstreamTlsContext tlsContext,
+      TlsContextManager tlsContextManager) {
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    String fullPath = "/" + SimpleServiceGrpc.SERVICE_NAME + "/" + "UnaryRpc";
+    RouteMatch routeMatch =
+            RouteMatch.create(
+                    PathMatcher.fromPath(fullPath, true),
+                    Collections.<HeaderMatcher>emptyList(), null);
+    VirtualHost virtualHost = VirtualHost.create(
+            "virtual-host", Collections.singletonList(OVERRIDE_AUTHORITY),
+            Arrays.asList(Route.forAction(routeMatch, null,
+                    ImmutableMap.<String, FilterConfig>of())),
+            ImmutableMap.<String, FilterConfig>of());
+    HttpConnectionManager httpConnectionManager = HttpConnectionManager.forVirtualHosts(
+            0L, Collections.singletonList(virtualHost),
+            new ArrayList<NamedFilterConfig>());
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-foo", filterChainMatch, httpConnectionManager, tlsContext,
+        tlsContextManager);
+    EnvoyServerProtoData.Listener listener = EnvoyServerProtoData.Listener.create(
+        name, address, ImmutableList.of(defaultFilterChain), null, Protocol.TCP);
+    return listener;
+  }
+
+  private SimpleServiceGrpc.SimpleServiceBlockingStub getBlockingStub(
+      final UpstreamTlsContext upstreamTlsContext, String overrideAuthority) {
+    return getBlockingStub(upstreamTlsContext, overrideAuthority, overrideAuthority);
+  }
+
+  // Two separate parameters for overrideAuthority and addrAttribute is for the SAN SNI validation
+  // test tlsClientServer_useSystemRootCerts_sni_san_validation_from_hostname that uses hostname
+  // passed for SNI. foo.test.google.fr is used for virtual host matching via authority but it
+  // can't be used for SNI in this testcase because foo.test.google.fr needs wildcard matching to
+  // match against *.test.google.fr in the certificate SNI, which isn't implemented yet
+  // (https://github.com/grpc/grpc-java/pull/12345 implements it)
+  // so use an exact match SAN such as waterzooi.test.google.be for SNI for this testcase.
+  private SimpleServiceGrpc.SimpleServiceBlockingStub getBlockingStub(
+      final UpstreamTlsContext upstreamTlsContext, String overrideAuthority,
+      String addrNameAttribute) {
+    ManagedChannelBuilder<?> channelBuilder =
+        Grpc.newChannelBuilder(
+            "sectest://localhost:" + port,
+            XdsChannelCredentials.create(InsecureChannelCredentials.create()));
+
+    if (overrideAuthority != null) {
+      channelBuilder = channelBuilder.overrideAuthority(overrideAuthority);
+    }
+    InetSocketAddress socketAddress =
+        new InetSocketAddress(Inet4Address.getLoopbackAddress(), port);
+    tlsContextManagerForClient = new TlsContextManagerImpl(bootstrapInfoForClient);
+    Attributes.Builder sslContextAttributesBuilder = (upstreamTlsContext != null)
+        ? Attributes.newBuilder()
+        .set(SecurityProtocolNegotiators.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER,
+            new SslContextProviderSupplier(
+                upstreamTlsContext, tlsContextManagerForClient))
+        : Attributes.newBuilder();
+    if (addrNameAttribute != null) {
+      sslContextAttributesBuilder.set(XdsInternalAttributes.ATTR_ADDRESS_NAME, addrNameAttribute);
+    }
+    sslContextAttributes = sslContextAttributesBuilder.build();
+    fakeNameResolverFactory.setServers(
+        ImmutableList.of(new EquivalentAddressGroup(socketAddress, sslContextAttributes)));
+    return SimpleServiceGrpc.newBlockingStub(cleanupRule.register(channelBuilder.build()));
+  }
+
+  /** Say hello to server. */
+  private static String unaryRpc(
+      String requestMessage, SimpleServiceGrpc.SimpleServiceBlockingStub blockingStub) {
+    SimpleRequest request = SimpleRequest.newBuilder().setRequestMessage(requestMessage).build();
+    SimpleResponse response = blockingStub.unaryRpc(request);
+    return response.getResponseMessage();
+  }
+
+  private SettableFuture<Throwable> startServerAsync(final Server xdsServer) throws Exception {
+    cleanupRule.register(xdsServer);
+    final SettableFuture<Throwable> settableFuture = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          xdsServer.start();
+          settableFuture.set(null);
+        } catch (Throwable e) {
+          settableFuture.set(e);
+        }
+      }
+    });
+    try {
+      xdsClient.ldsResource.get(8000, TimeUnit.MILLISECONDS);
+    } catch (Exception ex) {
+      // start() probably failed, so throw its exception
+      if (settableFuture.isDone()) {
+        Throwable t = settableFuture.get();
+        if (t != null) {
+          throw new Exception(t);
+        }
+      }
+      throw ex;
+    }
+    return settableFuture;
+  }
+
+  private void setTrustStoreSystemProperties(String trustStoreFilePath) throws Exception {
+    System.setProperty("javax.net.ssl.trustStore", trustStoreFilePath);
+    System.setProperty("javax.net.ssl.trustStorePassword", "changeit");
+    System.setProperty("javax.net.ssl.trustStoreType", "JKS");
+    createDefaultTrustManager();
+  }
+
+  private void clearTrustStoreSystemProperties() throws Exception {
+    System.clearProperty("javax.net.ssl.trustStore");
+    System.clearProperty("javax.net.ssl.trustStorePassword");
+    System.clearProperty("javax.net.ssl.trustStoreType");
+    createDefaultTrustManager();
+  }
+
+  /**
+   * Workaround the JDK's TrustManagerStore race. TrustManagerStore has a cache for the default
+   * certs based on the system properties. But updating the cache is not thread-safe and can cause a
+   * half-updated cache to appear fully-updated. When both the client and server initialize their
+   * trust store simultaneously, one can see a half-updated value. Creating the trust manager here
+   * fixes the cache while no other threads are running and thus the client and server threads won't
+   * race to update it. See https://github.com/grpc/grpc-java/issues/11678.
+   */
+  private void createDefaultTrustManager() throws Exception {
+    TrustManagerFactory factory =
+        TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+    factory.init((KeyStore) null);
+  }
+
+  private static class SimpleServiceImpl extends SimpleServiceGrpc.SimpleServiceImplBase {
+
+    @Override
+    public void unaryRpc(SimpleRequest req, StreamObserver<SimpleResponse> responseObserver) {
+      SimpleResponse response =
+          SimpleResponse.newBuilder()
+              .setResponseMessage("Hello " + req.getRequestMessage())
+              .build();
+      responseObserver.onNext(response);
+      responseObserver.onCompleted();
+    }
+  }
+
+  private static final class FakeNameResolverFactory extends NameResolverProvider {
+    final URI expectedUri;
+    List<EquivalentAddressGroup> servers = ImmutableList.of();
+    final ArrayList<FakeNameResolver> resolvers = new ArrayList<>();
+
+    FakeNameResolverFactory(URI expectedUri) {
+      this.expectedUri = expectedUri;
+    }
+
+    void setServers(List<EquivalentAddressGroup> servers) {
+      this.servers = servers;
+    }
+
+    @Override
+    public NameResolver newNameResolver(final URI targetUri, NameResolver.Args args) {
+      if (!expectedUri.equals(targetUri)) {
+        return null;
+      }
+      FakeNameResolver resolver = new FakeNameResolver();
+      resolvers.add(resolver);
+      return resolver;
+    }
+
+    @Override
+    public String getDefaultScheme() {
+      return "sectest";
+    }
+
+    @Override
+    protected boolean isAvailable() {
+      return true;
+    }
+
+    @Override
+    protected int priority() {
+      return 5;
+    }
+
+    final class FakeNameResolver extends NameResolver {
+      Listener2 listener;
+
+      @Override
+      public String getServiceAuthority() {
+        return expectedUri.getAuthority();
+      }
+
+      @Override
+      public void start(Listener2 listener) {
+        this.listener = listener;
+        resolved();
+      }
+
+      @Override
+      public void refresh() {
+        resolved();
+      }
+
+      void resolved() {
+        ResolutionResult.Builder builder = ResolutionResult.newBuilder()
+            .setAddressesOrError(StatusOr.fromValue(servers));
+        listener.onResult(builder.build());
+      }
+
+      @Override
+      public void shutdown() {
+      }
+
+      @Override
+      public String toString() {
+        return "FakeNameResolver";
+      }
+    }
+
+    static final class Builder {
+      final URI expectedUri;
+
+      Builder(URI expectedUri) {
+        this.expectedUri = expectedUri;
+      }
+
+      FakeNameResolverFactory build() {
+        return new FakeNameResolverFactory(expectedUri);
+      }
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsServerBuilderTest.java b/xds/src/test/java/io/grpc/xds/XdsServerBuilderTest.java
new file mode 100644
index 00000000000..ac990226259
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsServerBuilderTest.java
@@ -0,0 +1,328 @@
+/*
+ * Copyright 2019 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.XdsServerTestHelper.buildTestListener;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.SettableFuture;
+import io.grpc.BindableService;
+import io.grpc.InsecureServerCredentials;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.StatusOr;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.XdsServerTestHelper.FakeXdsClient;
+import io.grpc.xds.XdsServerTestHelper.FakeXdsClientPoolFactory;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.ServerSocket;
+import java.net.SocketAddress;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+
+// TODO (zivy@): move certain tests down to XdsServerWrapperTest or to XdsSecurityClientServerTest
+/**
+ * Unit tests for {@link XdsServerBuilder}.
+ */
+@RunWith(JUnit4.class)
+public class XdsServerBuilderTest {
+
+  @Rule public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+  private XdsServerBuilder builder;
+  private XdsServerWrapper xdsServer;
+  private int port;
+  private TlsContextManager tlsContextManager;
+  private FakeXdsClient xdsClient = new FakeXdsClient();
+  private FakeXdsClientPoolFactory xdsClientPoolFactory = new FakeXdsClientPoolFactory(xdsClient);
+
+  private void buildServer(XdsServerBuilder.XdsServingStatusListener xdsServingStatusListener)
+      throws IOException {
+    buildBuilder(xdsServingStatusListener);
+    xdsServer = cleanupRule.register((XdsServerWrapper) builder.build());
+  }
+
+  private void buildBuilder(XdsServerBuilder.XdsServingStatusListener xdsServingStatusListener)
+      throws IOException {
+    builder =
+        XdsServerBuilder.forPort(
+            port, XdsServerCredentials.create(InsecureServerCredentials.create()));
+    builder.xdsClientPoolFactory(xdsClientPoolFactory);
+    builder.overrideBootstrapForTest(XdsServerTestHelper.RAW_BOOTSTRAP);
+    if (xdsServingStatusListener != null) {
+      builder.xdsServingStatusListener(xdsServingStatusListener);
+    }
+    tlsContextManager = mock(TlsContextManager.class);
+  }
+
+  private void verifyServer(
+      Future<Throwable> future,
+      XdsServerBuilder.XdsServingStatusListener mockXdsServingStatusListener,
+      Status notServingStatus)
+      throws InterruptedException, ExecutionException, TimeoutException {
+    if (future != null) {
+      Throwable exception = future.get(5, TimeUnit.SECONDS);
+      assertThat(exception).isNull();
+    }
+    List<? extends SocketAddress> list = xdsServer.getListenSockets();
+    assertThat(list).hasSize(1);
+    InetSocketAddress socketAddress = (InetSocketAddress) list.get(0);
+    assertThat(socketAddress.getAddress().isAnyLocalAddress()).isTrue();
+    assertThat(socketAddress.getPort()).isGreaterThan(-1);
+    if (mockXdsServingStatusListener != null) {
+      if (notServingStatus != null) {
+        ArgumentCaptor<Throwable> argCaptor = ArgumentCaptor.forClass(Throwable.class);
+        verify(mockXdsServingStatusListener, times(1)).onNotServing(argCaptor.capture());
+        Throwable throwable = argCaptor.getValue();
+        assertThat(throwable).isInstanceOf(StatusException.class);
+        assertThat(((StatusException) throwable).getStatus()).isEqualTo(notServingStatus);
+      } else {
+        verify(mockXdsServingStatusListener, never()).onNotServing(any(Throwable.class));
+        verify(mockXdsServingStatusListener, times(1)).onServing();
+      }
+    }
+  }
+
+  private void verifyShutdown() throws InterruptedException {
+    xdsServer.shutdown();
+    xdsServer.awaitTermination(500L, TimeUnit.MILLISECONDS);
+    assertThat(xdsClient.isShutDown()).isTrue();
+  }
+
+  private Future<Throwable> startServerAsync() throws
+          InterruptedException, TimeoutException, ExecutionException {
+    final SettableFuture<Throwable> settableFuture = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          xdsServer.start();
+          settableFuture.set(null);
+        } catch (Throwable e) {
+          settableFuture.set(e);
+        }
+      }
+    });
+    try {
+      xdsClient.ldsResource.get(5000, TimeUnit.MILLISECONDS);
+    } catch (TimeoutException ex) {
+      // start() probably failed, so throw its exception
+      if (settableFuture.isDone()) {
+        Throwable t = settableFuture.get();
+        if (t != null) {
+          throw new ExecutionException(t);
+        }
+      }
+      throw ex;
+    }
+    return settableFuture;
+  }
+
+  @Test
+  public void xdsServerStartAndShutdown()
+      throws IOException, InterruptedException, TimeoutException, ExecutionException {
+    buildServer(null);
+    Future<Throwable> future = startServerAsync();
+    XdsServerTestHelper.generateListenerUpdate(
+        xdsClient,
+        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+        tlsContextManager);
+    verifyServer(future, null, null);
+    verifyShutdown();
+  }
+
+  @Test
+  public void xdsServerRestartAfterListenerUpdate()
+          throws IOException, InterruptedException, TimeoutException, ExecutionException {
+    buildServer(null);
+    Future<Throwable> future = startServerAsync();
+    XdsServerTestHelper.generateListenerUpdate(
+            xdsClient,
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+            tlsContextManager);
+    try {
+      xdsServer.start();
+      fail("expected exception");
+    } catch (IllegalStateException expected) {
+      assertThat(expected).hasMessageThat().contains("Already started");
+    }
+    verifyServer(future,null, null);
+  }
+
+  @Test
+  public void xdsServerStartAndShutdownWithXdsServingStatusListener()
+      throws IOException, InterruptedException, TimeoutException, ExecutionException {
+    XdsServerBuilder.XdsServingStatusListener mockXdsServingStatusListener =
+        mock(XdsServerBuilder.XdsServingStatusListener.class);
+    buildServer(mockXdsServingStatusListener);
+    Future<Throwable> future = startServerAsync();
+    XdsServerTestHelper.generateListenerUpdate(
+        xdsClient,
+        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+            tlsContextManager);
+    verifyServer(future, mockXdsServingStatusListener, null);
+  }
+
+  @Test
+  public void xdsServer_discoverState() throws Exception {
+    XdsServerBuilder.XdsServingStatusListener mockXdsServingStatusListener =
+        mock(XdsServerBuilder.XdsServingStatusListener.class);
+    buildServer(mockXdsServingStatusListener);
+    Future<Throwable> future = startServerAsync();
+    XdsServerTestHelper.generateListenerUpdate(
+            xdsClient,
+            CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+            tlsContextManager);
+    future.get(5000, TimeUnit.MILLISECONDS);
+    xdsClient.ldsWatcher.onAmbientError(Status.ABORTED);
+    verify(mockXdsServingStatusListener, never()).onNotServing(any(StatusException.class));
+    reset(mockXdsServingStatusListener);
+    xdsClient.ldsWatcher.onAmbientError(Status.CANCELLED);
+    verify(mockXdsServingStatusListener, never()).onNotServing(any(StatusException.class));
+    reset(mockXdsServingStatusListener);
+    Status notFoundStatus = Status.NOT_FOUND.withDescription("not found error");
+    xdsClient.ldsWatcher.onResourceChanged(StatusOr.fromStatus(notFoundStatus));
+    verify(mockXdsServingStatusListener).onNotServing(any(StatusException.class));
+    reset(mockXdsServingStatusListener);
+    XdsServerTestHelper.generateListenerUpdate(
+        xdsClient,
+        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+            tlsContextManager);
+    verifyServer(null, mockXdsServingStatusListener, null);
+  }
+
+  @Test
+  public void xdsServer_startError()
+      throws IOException, InterruptedException, TimeoutException, ExecutionException {
+    XdsServerBuilder.XdsServingStatusListener mockXdsServingStatusListener =
+        mock(XdsServerBuilder.XdsServingStatusListener.class);
+    ServerSocket serverSocket = new ServerSocket(0);
+    port = serverSocket.getLocalPort();
+    buildServer(mockXdsServingStatusListener);
+    Future<Throwable> future = startServerAsync();
+    // create port conflict for start to fail
+    EnvoyServerProtoData.Listener listener = buildTestListener(
+        "listener1", "0.0.0.0:" + port, ImmutableList.of(),
+        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+        null, tlsContextManager);
+    LdsUpdate listenerUpdate = LdsUpdate.forTcpListener(listener);
+    xdsClient.deliverLdsUpdate(listenerUpdate);
+
+    Throwable exception = future.get(5, TimeUnit.SECONDS);
+    assertThat(exception).isInstanceOf(IOException.class);
+    assertThat(exception).hasMessageThat().contains("Failed to bind");
+    verify(mockXdsServingStatusListener, never()).onNotServing(any(Throwable.class));
+    serverSocket.close();
+  }
+
+  @Test
+  public void xdsServerStartSecondUpdateAndError()
+      throws IOException, InterruptedException, TimeoutException, ExecutionException {
+    XdsServerBuilder.XdsServingStatusListener mockXdsServingStatusListener =
+        mock(XdsServerBuilder.XdsServingStatusListener.class);
+    buildServer(mockXdsServingStatusListener);
+    Future<Throwable> future = startServerAsync();
+    XdsServerTestHelper.generateListenerUpdate(
+        xdsClient,
+        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+            tlsContextManager);
+    XdsServerTestHelper.generateListenerUpdate(
+        xdsClient,
+        CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1"),
+            tlsContextManager);
+    verify(mockXdsServingStatusListener, never()).onNotServing(any(Throwable.class));
+    verifyServer(future, mockXdsServingStatusListener, null);
+    xdsClient.ldsWatcher.onAmbientError(Status.ABORTED);
+    verifyServer(null, mockXdsServingStatusListener, null);
+  }
+
+  @Test
+  public void xdsServer_2ndBuild_expectException() throws IOException {
+    XdsServerBuilder.XdsServingStatusListener mockXdsServingStatusListener =
+        mock(XdsServerBuilder.XdsServingStatusListener.class);
+    buildServer(mockXdsServingStatusListener);
+    try {
+      builder.build();
+      fail("exception expected");
+    } catch (IllegalStateException expected) {
+      assertThat(expected).hasMessageThat().contains("Server already built!");
+    }
+  }
+
+  @Test
+  public void xdsServer_2ndSetter_expectException() throws IOException {
+    XdsServerBuilder.XdsServingStatusListener mockXdsServingStatusListener =
+        mock(XdsServerBuilder.XdsServingStatusListener.class);
+    buildBuilder(mockXdsServingStatusListener);
+    BindableService mockBindableService = mock(BindableService.class);
+    ServerServiceDefinition serverServiceDefinition = io.grpc.ServerServiceDefinition
+        .builder("mock").build();
+    when(mockBindableService.bindService()).thenReturn(serverServiceDefinition);
+    builder.addService(mockBindableService);
+    xdsServer = cleanupRule.register((XdsServerWrapper) builder.build());
+    try {
+      builder.addService(mock(BindableService.class));
+      fail("exception expected");
+    } catch (IllegalStateException expected) {
+      assertThat(expected).hasMessageThat().contains("Server already built!");
+    }
+  }
+
+  @Test
+  public void drainGraceTime_negativeThrows() throws IOException {
+    buildBuilder(null);
+    try {
+      builder.drainGraceTime(-1, TimeUnit.SECONDS);
+      fail("exception expected");
+    } catch (IllegalArgumentException expected) {
+      assertThat(expected).hasMessageThat().contains("drain grace time");
+    }
+  }
+
+  @Test
+  public void testOverrideBootstrap() throws Exception {
+    Map<String, ?> b = XdsServerTestHelper.RAW_BOOTSTRAP;
+    buildBuilder(null);
+    builder.overrideBootstrapForTest(b);
+    xdsServer = cleanupRule.register((XdsServerWrapper) builder.build());
+    Future<Throwable> unused = startServerAsync();
+    assertThat(xdsClientPoolFactory.savedBootstrapInfo.node().getId())
+        .isEqualTo(XdsServerTestHelper.BOOTSTRAP_INFO.node().getId());
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsServerTestHelper.java b/xds/src/test/java/io/grpc/xds/XdsServerTestHelper.java
new file mode 100644
index 00000000000..386793299d8
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsServerTestHelper.java
@@ -0,0 +1,347 @@
+/*
+ * 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.SettableFuture;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress.Protocol;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.MetricRecorder;
+import io.grpc.Status;
+import io.grpc.StatusOr;
+import io.grpc.internal.ObjectPool;
+import io.grpc.xds.EnvoyServerProtoData.ConnectionSourceType;
+import io.grpc.xds.EnvoyServerProtoData.FilterChain;
+import io.grpc.xds.EnvoyServerProtoData.Listener;
+import io.grpc.xds.Filter.FilterConfig;
+import io.grpc.xds.Filter.NamedFilterConfig;
+import io.grpc.xds.VirtualHost.Route;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.XdsRouteConfigureResource.RdsUpdate;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.Bootstrapper.BootstrapInfo;
+import io.grpc.xds.client.EnvoyProtoData;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsResourceType;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import javax.annotation.Nullable;
+
+/**
+ * Helper methods related to {@link XdsServerBuilder} and related classes.
+ */
+public class XdsServerTestHelper {
+
+  private static final String SERVER_URI = "trafficdirector.googleapis.com";
+  private static final String NODE_ID =
+      "projects/42/networks/default/nodes/5c85b298-6f5b-4722-b74a-f7d1f0ccf5ad";
+  private static final EnvoyProtoData.Node BOOTSTRAP_NODE =
+      EnvoyProtoData.Node.newBuilder().setId(NODE_ID).build();
+  static final Map<String, ?> RAW_BOOTSTRAP = ImmutableMap.of(
+      "node", ImmutableMap.of(
+          "id", NODE_ID),
+      "server_listener_resource_name_template", "grpc/server?udpa.resource.listening_address=%s",
+      "xds_servers", ImmutableList.of(
+          ImmutableMap.of(
+              "server_uri", SERVER_URI,
+              "channel_creds", ImmutableList.of(
+                  ImmutableMap.of(
+                      "type", "insecure")))
+      ));
+  static final Bootstrapper.BootstrapInfo BOOTSTRAP_INFO =
+      Bootstrapper.BootstrapInfo.builder()
+          .servers(Arrays.asList(
+              Bootstrapper.ServerInfo.create(
+                  SERVER_URI, InsecureChannelCredentials.create())))
+          .node(BOOTSTRAP_NODE)
+          .serverListenerResourceNameTemplate("grpc/server?udpa.resource.listening_address=%s")
+          .build();
+
+  static void generateListenerUpdate(FakeXdsClient xdsClient,
+                                     EnvoyServerProtoData.DownstreamTlsContext tlsContext,
+                                     TlsContextManager tlsContextManager) {
+    EnvoyServerProtoData.Listener listener = buildTestListener("listener1", "0.0.0.0:0",
+        ImmutableList.of(), tlsContext, null, tlsContextManager);
+    LdsUpdate listenerUpdate = LdsUpdate.forTcpListener(listener);
+    xdsClient.deliverLdsUpdate(listenerUpdate);
+  }
+
+  static void generateListenerUpdate(
+      FakeXdsClient xdsClient, ImmutableList<Integer> sourcePorts,
+      EnvoyServerProtoData.DownstreamTlsContext tlsContext,
+      EnvoyServerProtoData.DownstreamTlsContext tlsContextForDefaultFilterChain,
+      TlsContextManager tlsContextManager) {
+    EnvoyServerProtoData.Listener listener = buildTestListener(
+        "listener1", "0.0.0.0:7000", sourcePorts,
+        tlsContext, tlsContextForDefaultFilterChain, tlsContextManager);
+    LdsUpdate listenerUpdate = LdsUpdate.forTcpListener(listener);
+    xdsClient.deliverLdsUpdate(listenerUpdate);
+  }
+
+  static EnvoyServerProtoData.Listener buildTestListener(
+      String name, String address, ImmutableList<Integer> sourcePorts,
+      EnvoyServerProtoData.DownstreamTlsContext tlsContext,
+      EnvoyServerProtoData.DownstreamTlsContext tlsContextForDefaultFilterChain,
+      TlsContextManager tlsContextManager) {
+    EnvoyServerProtoData.FilterChainMatch filterChainMatch1 =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ConnectionSourceType.ANY,
+            sourcePorts,
+            ImmutableList.of(),
+            "");
+    EnvoyServerProtoData.FilterChainMatch defaultFilterChainMatch =
+        EnvoyServerProtoData.FilterChainMatch.create(
+            0,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ImmutableList.of(),
+            ConnectionSourceType.ANY,
+            ImmutableList.of(),
+            ImmutableList.of(),
+            "");
+    VirtualHost virtualHost =
+            VirtualHost.create(
+                    "virtual-host", Collections.singletonList("auth"), new ArrayList<Route>(),
+                    ImmutableMap.<String, FilterConfig>of());
+    HttpConnectionManager httpConnectionManager = HttpConnectionManager.forVirtualHosts(
+            0L, Collections.singletonList(virtualHost), new ArrayList<NamedFilterConfig>());
+    EnvoyServerProtoData.FilterChain filterChain1 = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-foo", filterChainMatch1, httpConnectionManager, tlsContext,
+        tlsContextManager);
+    EnvoyServerProtoData.FilterChain defaultFilterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-bar", defaultFilterChainMatch, httpConnectionManager,
+        tlsContextForDefaultFilterChain, tlsContextManager);
+    EnvoyServerProtoData.Listener listener =
+        EnvoyServerProtoData.Listener.create(
+            name, address, ImmutableList.of(filterChain1), defaultFilterChain, Protocol.TCP);
+    return listener;
+  }
+
+  static final class FakeXdsClientPoolFactory
+        implements XdsClientPoolFactory {
+
+    private XdsClient xdsClient;
+    BootstrapInfo savedBootstrapInfo;
+
+    FakeXdsClientPoolFactory(XdsClient xdsClient) {
+      this.xdsClient = xdsClient;
+    }
+
+    @Override
+    @Nullable
+    public ObjectPool<XdsClient> get(String target) {
+      throw new UnsupportedOperationException("Should not be called");
+    }
+
+    @Override
+    public ObjectPool<XdsClient> getOrCreate(
+        String target, BootstrapInfo bootstrapInfo, MetricRecorder metricRecorder) {
+      this.savedBootstrapInfo = bootstrapInfo;
+      return new ObjectPool<XdsClient>() {
+        @Override
+        public XdsClient getObject() {
+          return xdsClient;
+        }
+
+        @Override
+        public XdsClient returnObject(Object object) {
+          xdsClient.shutdown();
+          return null;
+        }
+      };
+    }
+
+    @Override
+    public List<String> getTargets() {
+      return Collections.singletonList("fake-target");
+    }
+  }
+
+  // Implementation details:
+  // 1. Use `synchronized` in methods where XdsClientImpl uses its own `syncContext`.
+  // 2. Use `serverExecutor` via `execute()` in methods where XdsClientImpl uses watcher's executor.
+  static final class FakeXdsClient extends XdsClient {
+    public static final Duration DEFAULT_TIMEOUT = Duration.ofSeconds(5);
+
+    private boolean shutdown;
+    @Nullable SettableFuture<String> ldsResource = SettableFuture.create();
+    @Nullable ResourceWatcher<LdsUpdate> ldsWatcher;
+    private CountDownLatch rdsCount = new CountDownLatch(1);
+    final Map<String, ResourceWatcher<RdsUpdate>> rdsWatchers = new HashMap<>();
+    @Nullable private volatile Executor serverExecutor;
+
+    @Override
+    public TlsContextManager getSecurityConfig() {
+      return null;
+    }
+
+    @Override
+    public BootstrapInfo getBootstrapInfo() {
+      return BOOTSTRAP_INFO;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public synchronized <T extends ResourceUpdate> void watchXdsResource(
+        XdsResourceType<T> resourceType,
+        String resourceName,
+        ResourceWatcher<T> watcher,
+        Executor executor) {
+      if (serverExecutor != null) {
+        assertThat(executor).isEqualTo(serverExecutor);
+      }
+
+      switch (resourceType.typeName()) {
+        case "LDS":
+          assertThat(ldsWatcher).isNull();
+          ldsWatcher = (ResourceWatcher<LdsUpdate>) watcher;
+          serverExecutor = executor;
+          ldsResource.set(resourceName);
+          break;
+        case "RDS":
+          //re-register is not allowed.
+          assertThat(rdsWatchers.put(resourceName, (ResourceWatcher<RdsUpdate>)watcher)).isNull();
+          rdsCount.countDown();
+          break;
+        default:
+      }
+    }
+
+    @Override
+    public synchronized <T extends ResourceUpdate>  void cancelXdsResourceWatch(
+        XdsResourceType<T> type, String resourceName, ResourceWatcher<T> watcher) {
+      switch (type.typeName()) {
+        case "LDS":
+          assertThat(ldsWatcher).isNotNull();
+          ldsResource = null;
+          ldsWatcher = null;
+          serverExecutor = null;
+          break;
+        case "RDS":
+          rdsWatchers.remove(resourceName);
+          break;
+        default:
+      }
+    }
+
+    @Override
+    public synchronized void shutdown() {
+      shutdown = true;
+    }
+
+    @Override
+    public synchronized boolean isShutDown() {
+      return shutdown;
+    }
+
+    public void awaitRds(Duration timeout) throws InterruptedException, TimeoutException {
+      if (!rdsCount.await(timeout.toMillis(), TimeUnit.MILLISECONDS)) {
+        throw new TimeoutException("Timeout " + timeout + " waiting for RDSs");
+      }
+    }
+
+    public void setExpectedRdsCount(int count) {
+      rdsCount = new CountDownLatch(count);
+    }
+
+    private void execute(Runnable action) {
+      // This method ensures that all watcher updates:
+      // - Happen after the server started watching LDS.
+      // - Are executed within the sync context of the server.
+      //
+      // Note that this doesn't guarantee that any of the RDS watchers are created.
+      // Tests should use setExpectedRdsCount(int) and awaitRds() for that.
+      awaitLdsResource(DEFAULT_TIMEOUT);
+      serverExecutor.execute(action);
+    }
+
+    private String awaitLdsResource(Duration timeout) {
+      if (ldsResource == null) {
+        throw new IllegalStateException("xDS resource update after watcher cancel");
+      }
+      try {
+        return ldsResource.get(timeout.toMillis(), TimeUnit.MILLISECONDS);
+      } catch (ExecutionException | TimeoutException e) {
+        throw new RuntimeException("Can't resolve LDS resource name in " + timeout, e);
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+        throw new RuntimeException(e);
+      }
+    }
+
+    void deliverLdsUpdateWithApiListener(long httpMaxStreamDurationNano,
+        List<VirtualHost> virtualHosts) {
+      execute(() -> {
+        LdsUpdate update = LdsUpdate.forApiListener(HttpConnectionManager.forVirtualHosts(
+            httpMaxStreamDurationNano, virtualHosts, null));
+        ldsWatcher.onResourceChanged(StatusOr.fromValue(update));
+      });
+    }
+
+    void deliverLdsUpdate(LdsUpdate ldsUpdate) {
+      execute(() -> ldsWatcher.onResourceChanged(StatusOr.fromValue(ldsUpdate)));
+    }
+
+    void deliverLdsUpdate(
+        List<FilterChain> filterChains,
+        @Nullable FilterChain defaultFilterChain) {
+      deliverLdsUpdate(LdsUpdate.forTcpListener(Listener.create("listener", "0.0.0.0:1",
+          ImmutableList.copyOf(filterChains), defaultFilterChain, Protocol.TCP)));
+    }
+
+    void deliverLdsUpdate(FilterChain filterChain, @Nullable FilterChain defaultFilterChain) {
+      deliverLdsUpdate(ImmutableList.of(filterChain), defaultFilterChain);
+    }
+
+    void deliverLdsResourceNotFound() {
+      String resourceName = awaitLdsResource(DEFAULT_TIMEOUT);
+      Status status = Status.NOT_FOUND.withDescription("Resource not found: " + resourceName);
+      execute(() -> ldsWatcher.onResourceChanged(StatusOr.fromStatus(status)));
+    }
+
+    void deliverRdsUpdate(String resourceName, List<VirtualHost> virtualHosts) {
+      RdsUpdate update = new RdsUpdate(virtualHosts);
+      execute(() -> rdsWatchers.get(resourceName).onResourceChanged(StatusOr.fromValue(update)));
+    }
+
+    void deliverRdsUpdate(String resourceName, VirtualHost virtualHost) {
+      deliverRdsUpdate(resourceName, ImmutableList.of(virtualHost));
+    }
+
+    void deliverRdsResourceNotFound(String resourceName) {
+      Status status = Status.NOT_FOUND.withDescription("Resource not found: " + resourceName);
+      execute(() -> rdsWatchers.get(resourceName).onResourceChanged(StatusOr.fromStatus(status)));
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsServerWrapperTest.java b/xds/src/test/java/io/grpc/xds/XdsServerWrapperTest.java
new file mode 100644
index 00000000000..99e3911307a
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsServerWrapperTest.java
@@ -0,0 +1,2033 @@
+/*
+ * Copyright 2021 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static io.grpc.xds.XdsServerWrapper.ATTR_SERVER_ROUTING_CONFIG;
+import static io.grpc.xds.XdsServerWrapper.RETRY_DELAY_NANOS;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.net.InetAddresses;
+import com.google.common.util.concurrent.SettableFuture;
+import io.envoyproxy.envoy.config.core.v3.SocketAddress.Protocol;
+import io.grpc.Attributes;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.Status;
+import io.grpc.StatusException;
+import io.grpc.StatusOr;
+import io.grpc.SynchronizationContext;
+import io.grpc.internal.FakeClock;
+import io.grpc.testing.TestMethodDescriptors;
+import io.grpc.xds.EnvoyServerProtoData.CidrRange;
+import io.grpc.xds.EnvoyServerProtoData.FilterChain;
+import io.grpc.xds.EnvoyServerProtoData.FilterChainMatch;
+import io.grpc.xds.EnvoyServerProtoData.Listener;
+import io.grpc.xds.Filter.FilterConfig;
+import io.grpc.xds.Filter.NamedFilterConfig;
+import io.grpc.xds.FilterChainMatchingProtocolNegotiators.FilterChainMatchingHandler.FilterChainSelector;
+import io.grpc.xds.StatefulFilter.Config;
+import io.grpc.xds.VirtualHost.Route;
+import io.grpc.xds.VirtualHost.Route.RouteMatch;
+import io.grpc.xds.VirtualHost.Route.RouteMatch.PathMatcher;
+import io.grpc.xds.XdsListenerResource.LdsUpdate;
+import io.grpc.xds.XdsRouteConfigureResource.RdsUpdate;
+import io.grpc.xds.XdsServerBuilder.XdsServingStatusListener;
+import io.grpc.xds.XdsServerTestHelper.FakeXdsClient;
+import io.grpc.xds.XdsServerTestHelper.FakeXdsClientPoolFactory;
+import io.grpc.xds.XdsServerWrapper.ConfigApplyingInterceptor;
+import io.grpc.xds.XdsServerWrapper.ServerRoutingConfig;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.EnvoyProtoData;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsClient.ResourceWatcher;
+import io.grpc.xds.internal.Matchers.HeaderMatcher;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil;
+import io.grpc.xds.internal.security.SslContextProviderSupplier;
+import java.io.IOException;
+import java.net.InetAddress;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class XdsServerWrapperTest {
+  private static final int START_WAIT_AFTER_LISTENER_MILLIS = 100;
+  private static final String ROUTER_FILTER_INSTANCE_NAME = "envoy.router";
+  private static final RouterFilter.Provider ROUTER_FILTER_PROVIDER = new RouterFilter.Provider();
+
+  // Readability: makes it simpler to distinguish resource parameters.
+  private static final ImmutableMap<String, FilterConfig> NO_FILTER_OVERRIDES = ImmutableMap.of();
+
+  private static final String STATEFUL_1 = "stateful_1";
+  private static final String STATEFUL_2 = "stateful_2";
+
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock
+  private ServerBuilder<?> mockBuilder;
+  @Mock
+  private Server mockServer;
+  @Mock
+  private XdsServingStatusListener listener;
+
+  private FilterChainSelectorManager selectorManager = new FilterChainSelectorManager();
+  private FakeClock executor = new FakeClock();
+  private FakeXdsClient xdsClient = new FakeXdsClient();
+  private FilterRegistry filterRegistry = FilterRegistry.getDefaultRegistry();
+  private XdsServerWrapper xdsServerWrapper;
+  private ServerRoutingConfig noopConfig = ServerRoutingConfig.create(
+      ImmutableList.<VirtualHost>of(), ImmutableMap.<Route, ServerInterceptor>of());
+
+  @Before
+  public void setup() {
+    when(mockBuilder.build()).thenReturn(mockServer);
+    xdsServerWrapper = new XdsServerWrapper("0.0.0.0:1", mockBuilder, listener,
+            selectorManager, new FakeXdsClientPoolFactory(xdsClient),
+            XdsServerTestHelper.RAW_BOOTSTRAP,
+            filterRegistry, executor.getScheduledExecutorService());
+  }
+
+  @After
+  public void tearDown() {
+    xdsServerWrapper.shutdownNow();
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void testBootstrap() throws Exception {
+    Bootstrapper.BootstrapInfo b =
+        Bootstrapper.BootstrapInfo.builder()
+            .servers(Arrays.asList(
+                Bootstrapper.ServerInfo.create("uri", InsecureChannelCredentials.create())))
+            .node(EnvoyProtoData.Node.newBuilder().setId("id").build())
+            .serverListenerResourceNameTemplate("grpc/server?udpa.resource.listening_address=%s")
+            .build();
+    XdsClient xdsClient = mock(XdsClient.class);
+    XdsListenerResource listenerResource = XdsListenerResource.getInstance();
+    when(xdsClient.getBootstrapInfo()).thenReturn(b);
+    xdsServerWrapper = new XdsServerWrapper("[::FFFF:129.144.52.38]:80", mockBuilder, listener,
+        selectorManager, new FakeXdsClientPoolFactory(xdsClient),
+        XdsServerTestHelper.RAW_BOOTSTRAP, filterRegistry);
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          xdsServerWrapper.start();
+        } catch (IOException ex) {
+          // ignore
+        }
+      }
+    });
+    verify(xdsClient, timeout(5000)).watchXdsResource(
+        eq(listenerResource),
+        eq("grpc/server?udpa.resource.listening_address=[::FFFF:129.144.52.38]:80"),
+        any(ResourceWatcher.class),
+        any(SynchronizationContext.class));
+  }
+
+  @Test
+  public void testBootstrap_noTemplate() throws Exception {
+    Bootstrapper.BootstrapInfo b =
+        Bootstrapper.BootstrapInfo.builder()
+            .servers(Arrays.asList(
+                Bootstrapper.ServerInfo.create("uri", InsecureChannelCredentials.create())))
+            .node(EnvoyProtoData.Node.newBuilder().setId("id").build())
+            .build();
+    verifyBootstrapFail(b);
+  }
+
+  private void verifyBootstrapFail(Bootstrapper.BootstrapInfo b) throws Exception {
+    XdsClient xdsClient = mock(XdsClient.class);
+    when(xdsClient.getBootstrapInfo()).thenReturn(b);
+    xdsServerWrapper = new XdsServerWrapper("0.0.0.0:1", mockBuilder, listener,
+            selectorManager, new FakeXdsClientPoolFactory(xdsClient),
+            XdsServerTestHelper.RAW_BOOTSTRAP, filterRegistry);
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    try {
+      start.get(5000, TimeUnit.MILLISECONDS);
+      fail("Start should throw exception");
+    } catch (ExecutionException ex) {
+      assertThat(ex.getCause()).isInstanceOf(IOException.class);
+      Throwable cause = ex.getCause().getCause();
+      assertThat(cause).isInstanceOf(StatusException.class);
+      assertThat(((StatusException)cause).getStatus().getCode())
+              .isEqualTo(Status.UNAVAILABLE.getCode());
+    }
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void testBootstrap_templateWithXdstp() throws Exception {
+    Bootstrapper.BootstrapInfo b = Bootstrapper.BootstrapInfo.builder()
+        .servers(Arrays.asList(
+            Bootstrapper.ServerInfo.create(
+                "uri", InsecureChannelCredentials.create())))
+        .node(EnvoyProtoData.Node.newBuilder().setId("id").build())
+        .serverListenerResourceNameTemplate(
+            "xdstp://xds.authority.com/envoy.config.listener.v3.Listener/grpc/server/%s")
+        .build();
+    XdsClient xdsClient = mock(XdsClient.class);
+    XdsListenerResource listenerResource = XdsListenerResource.getInstance();
+    when(xdsClient.getBootstrapInfo()).thenReturn(b);
+    xdsServerWrapper = new XdsServerWrapper("[::FFFF:129.144.52.38]:80", mockBuilder, listener,
+        selectorManager, new FakeXdsClientPoolFactory(xdsClient),
+        XdsServerTestHelper.RAW_BOOTSTRAP, filterRegistry);
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          xdsServerWrapper.start();
+        } catch (IOException ex) {
+          // ignore
+        }
+      }
+    });
+    verify(xdsClient, timeout(5000)).watchXdsResource(
+        eq(listenerResource),
+        eq("xdstp://xds.authority.com/envoy.config.listener.v3.Listener/grpc/server/"
+            + "%5B::FFFF:129.144.52.38%5D:80"),
+        any(ResourceWatcher.class),
+        any(SynchronizationContext.class));
+  }
+
+  @Test
+  public void shutdown() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsWatched = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    assertThat(ldsWatched).isEqualTo("grpc/server?udpa.resource.listening_address=0.0.0.0:1");
+    HttpConnectionManager hcm_virtual = HttpConnectionManager.forVirtualHosts(
+            0L, Collections.singletonList(createVirtualHost("virtual-host-0")),
+            new ArrayList<NamedFilterConfig>());
+    FilterChain f0 = createFilterChain("filter-chain-0", hcm_virtual);
+    FilterChain f1 = createFilterChain("filter-chain-1", createRds("rds"));
+    xdsClient.deliverLdsUpdate(Collections.singletonList(f0), f1);
+    xdsClient.awaitRds(FakeXdsClient.DEFAULT_TIMEOUT);
+    xdsClient.deliverRdsUpdate("rds",
+            Collections.singletonList(createVirtualHost("virtual-host-1")));
+    verify(listener, timeout(5000)).onServing();
+    start.get(START_WAIT_AFTER_LISTENER_MILLIS, TimeUnit.MILLISECONDS);
+    verify(mockServer).start();
+    xdsServerWrapper.shutdown();
+    assertThat(xdsServerWrapper.isShutdown()).isTrue();
+    assertThat(xdsClient.ldsResource).isNull();
+    assertThat(xdsClient.isShutDown()).isTrue();
+    verify(mockServer).shutdown();
+    assertThat(f0.sslContextProviderSupplier().isShutdown()).isTrue();
+    assertThat(f1.sslContextProviderSupplier().isShutdown()).isTrue();
+    when(mockServer.isTerminated()).thenReturn(true);
+    when(mockServer.awaitTermination(anyLong(), any(TimeUnit.class))).thenReturn(true);
+    assertThat(xdsServerWrapper.awaitTermination(5, TimeUnit.SECONDS)).isTrue();
+    xdsServerWrapper.awaitTermination();
+    assertThat(xdsServerWrapper.isTerminated()).isTrue();
+    assertThat(start.get()).isSameInstanceAs(xdsServerWrapper);
+  }
+
+  @Test
+  public void shutdown_inflight() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsWatched = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    assertThat(ldsWatched).isEqualTo("grpc/server?udpa.resource.listening_address=0.0.0.0:1");
+    HttpConnectionManager hcmVirtual = HttpConnectionManager.forVirtualHosts(
+            0L, Collections.singletonList(createVirtualHost("virtual-host-0")),
+            new ArrayList<NamedFilterConfig>());
+    FilterChain f0 = createFilterChain("filter-chain-0", createRds("rds"));
+    FilterChain f1 = createFilterChain("filter-chain-1", hcmVirtual);
+    xdsClient.deliverLdsUpdate(Collections.singletonList(f0), f1);
+    xdsServerWrapper.shutdown();
+    when(mockServer.isTerminated()).thenReturn(true);
+    when(mockServer.awaitTermination(anyLong(), any(TimeUnit.class))).thenReturn(true);
+    assertThat(xdsServerWrapper.awaitTermination(5, TimeUnit.SECONDS)).isTrue();
+    xdsServerWrapper.awaitTermination();
+    assertThat(xdsServerWrapper.isTerminated()).isTrue();
+    verify(mockServer, never()).start();
+    assertThat(xdsServerWrapper.isShutdown()).isTrue();
+    assertThat(xdsClient.ldsResource).isNull();
+    assertThat(xdsClient.isShutDown()).isTrue();
+    verify(mockServer).shutdown();
+    assertThat(f0.sslContextProviderSupplier().isShutdown()).isTrue();
+    assertThat(f1.sslContextProviderSupplier().isShutdown()).isTrue();
+    assertThat(start.isDone()).isFalse(); //shall we set initialStatus when shutdown?
+  }
+
+  @Test
+  public void shutdown_afterResourceNotExist() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsResource = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    Status notFoundStatus = Status.NOT_FOUND.withDescription("Resource not found: " + ldsResource);
+    xdsClient.ldsWatcher.onResourceChanged(StatusOr.fromStatus(notFoundStatus));
+    verify(listener, timeout(5000)).onNotServing(any());
+    try {
+      start.get(START_WAIT_AFTER_LISTENER_MILLIS, TimeUnit.MILLISECONDS);
+      fail("server should not start() successfully.");
+    } catch (TimeoutException ex) {
+      // expect to block here.
+      assertThat(start.isDone()).isFalse();
+    }
+    verify(mockBuilder, times(1)).build();
+    verify(mockServer, never()).start();
+    verify(mockServer).shutdown();
+    when(mockServer.isShutdown()).thenReturn(true);
+    when(mockServer.isTerminated()).thenReturn(true);
+    verify(listener, times(1)).onNotServing(any(Throwable.class));
+    xdsServerWrapper.shutdown();
+    assertThat(xdsServerWrapper.isShutdown()).isTrue();
+    assertThat(xdsClient.ldsResource).isNull();
+    assertThat(xdsClient.isShutDown()).isTrue();
+    verify(mockBuilder, times(1)).build();
+    verify(mockServer, times(1)).shutdown();
+    xdsServerWrapper.awaitTermination(1, TimeUnit.SECONDS);
+    assertThat(xdsServerWrapper.isTerminated()).isTrue();
+  }
+
+  @Test
+  public void shutdown_pendingRetry() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    when(mockServer.start()).thenThrow(new IOException("error!"));
+    FilterChain filterChain = createFilterChain("filter-chain-1", createRds("rds"));
+    SslContextProviderSupplier sslSupplier = filterChain.sslContextProviderSupplier();
+    xdsClient.deliverLdsUpdate(Collections.singletonList(filterChain), null);
+    xdsClient.awaitRds(FakeXdsClient.DEFAULT_TIMEOUT);
+    xdsClient.deliverRdsUpdate("rds",
+            Collections.singletonList(createVirtualHost("virtual-host-1")));
+    try {
+      start.get(5000, TimeUnit.MILLISECONDS);
+      fail("Start should throw exception");
+    } catch (ExecutionException ex) {
+      assertThat(ex.getCause()).isInstanceOf(IOException.class);
+    }
+    assertThat(executor.getPendingTasks().size()).isEqualTo(1);
+    verify(mockServer).start();
+    verify(mockServer, never()).shutdown();
+    xdsServerWrapper.shutdown();
+    verify(mockServer).shutdown();
+    when(mockServer.isTerminated()).thenReturn(true);
+    assertThat(sslSupplier.isShutdown()).isTrue();
+    assertThat(executor.getPendingTasks().size()).isEqualTo(0);
+    verify(listener, never()).onNotServing(any(Throwable.class));
+    verify(listener, never()).onServing();
+    xdsServerWrapper.awaitTermination();
+    assertThat(xdsServerWrapper.isTerminated()).isTrue();
+  }
+
+  @Test
+  public void shutdownNow_startThreadShouldNotLeak() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor()
+        .execute(
+            new Runnable() {
+              @Override
+              public void run() {
+                try {
+                  start.set(xdsServerWrapper.start());
+                } catch (Exception ex) {
+                  start.setException(ex);
+                }
+              }
+            });
+    assertThat(xdsClient.ldsResource.get(5, TimeUnit.SECONDS))
+        .isEqualTo("grpc/server?udpa.resource.listening_address=0.0.0.0:1");
+    xdsServerWrapper.shutdownNow();
+    try {
+      start.get(5, TimeUnit.SECONDS);
+      fail("should have thrown but not");
+    } catch (ExecutionException ex) {
+      assertThat(ex).hasCauseThat().isInstanceOf(IOException.class);
+      assertThat(ex).hasCauseThat().hasMessageThat().isEqualTo("server is forcefully shut down");
+    }
+  }
+
+  @Test
+  public void initialStartIoException() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    when(mockServer.start()).thenThrow(new IOException("error!"));
+    xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    FilterChain filterChain = createFilterChain("filter-chain-1", createRds("rds"));
+    xdsClient.deliverLdsUpdate(Collections.singletonList(filterChain), null);
+    xdsClient.awaitRds(FakeXdsClient.DEFAULT_TIMEOUT);
+    xdsClient.deliverRdsUpdate("rds",
+            Collections.singletonList(createVirtualHost("virtual-host-1")));
+    try {
+      start.get(5000, TimeUnit.MILLISECONDS);
+      fail("Start should throw exception");
+    } catch (ExecutionException ex) {
+      assertThat(ex.getCause()).isInstanceOf(IOException.class);
+      assertThat(ex.getCause().getMessage()).isEqualTo("error!");
+    }
+  }
+
+  @Test
+  public void discoverState_virtualhost() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsWatched = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    assertThat(ldsWatched).isEqualTo("grpc/server?udpa.resource.listening_address=0.0.0.0:1");
+    VirtualHost virtualHost =
+            VirtualHost.create(
+                    "virtual-host", Collections.singletonList("auth"), new ArrayList<Route>(),
+                    ImmutableMap.<String, FilterConfig>of());
+    HttpConnectionManager httpConnectionManager = HttpConnectionManager.forVirtualHosts(
+            0L, Collections.singletonList(virtualHost), new ArrayList<NamedFilterConfig>());
+    EnvoyServerProtoData.FilterChain filterChain = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-foo", createMatch(), httpConnectionManager, createTls(),
+            mock(TlsContextManager.class));
+    xdsClient.deliverLdsUpdate(Collections.singletonList(filterChain), null);
+    start.get(5000, TimeUnit.MILLISECONDS);
+    assertThat(ldsWatched).isEqualTo("grpc/server?udpa.resource.listening_address=0.0.0.0:1");
+    assertThat(selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().size())
+        .isEqualTo(1);
+    ServerRoutingConfig realConfig =
+        selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().get(filterChain).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(httpConnectionManager.virtualHosts());
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+    verify(listener).onServing();
+    verify(mockServer).start();
+  }
+
+  @Test
+  public void discoverState_restart_afterResourceNotExist() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsResource = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    assertThat(ldsResource).isEqualTo("grpc/server?udpa.resource.listening_address=0.0.0.0:1");
+    VirtualHost virtualHost =
+            VirtualHost.create(
+                    "virtual-host", Collections.singletonList("auth"), new ArrayList<Route>(),
+                    ImmutableMap.<String, FilterConfig>of());
+    HttpConnectionManager httpConnectionManager = HttpConnectionManager.forVirtualHosts(
+            0L, Collections.singletonList(virtualHost), new ArrayList<NamedFilterConfig>());
+    EnvoyServerProtoData.FilterChain filterChain = EnvoyServerProtoData.FilterChain.create(
+            "filter-chain-foo", createMatch(), httpConnectionManager, createTls(),
+            mock(TlsContextManager.class));
+    xdsClient.deliverLdsUpdate(Collections.singletonList(filterChain), null);
+    start.get(5000, TimeUnit.MILLISECONDS);
+    verify(listener).onServing();
+    verify(mockServer).start();
+
+    // server shutdown after resourceDoesNotExist
+    Status notFoundStatus = Status.NOT_FOUND.withDescription("Resource not found: " + ldsResource);
+    xdsClient.ldsWatcher.onResourceChanged(StatusOr.fromStatus(notFoundStatus));
+    verify(mockServer).shutdown();
+
+    // re-deliver lds resource
+    reset(mockServer);
+    reset(listener);
+    xdsClient.deliverLdsUpdate(Collections.singletonList(filterChain), null);
+    verify(listener).onServing();
+    verify(mockServer).start();
+  }
+
+  @Test
+  public void onChanged_listenerIsNull()
+      throws ExecutionException, InterruptedException, TimeoutException {
+    xdsServerWrapper = new XdsServerWrapper("10.1.2.3:1", mockBuilder, listener,
+        selectorManager, new FakeXdsClientPoolFactory(xdsClient),
+        XdsServerTestHelper.RAW_BOOTSTRAP,
+        filterRegistry, executor.getScheduledExecutorService());
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsResource = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    assertThat(ldsResource).isEqualTo("grpc/server?udpa.resource.listening_address=10.1.2.3:1");
+    VirtualHost virtualHost =
+        VirtualHost.create(
+            "virtual-host", Collections.singletonList("auth"), new ArrayList<Route>(),
+            ImmutableMap.<String, FilterConfig>of());
+
+    xdsClient.deliverLdsUpdateWithApiListener(0L, Arrays.asList(virtualHost));
+
+    verify(listener, timeout(10000)).onNotServing(any());
+  }
+
+  @Test
+  public void onChanged_listenerAddressMissingPort()
+      throws ExecutionException, InterruptedException, TimeoutException {
+    xdsServerWrapper = new XdsServerWrapper("10.1.2.3:1", mockBuilder, listener,
+        selectorManager, new FakeXdsClientPoolFactory(xdsClient),
+        XdsServerTestHelper.RAW_BOOTSTRAP,
+        filterRegistry, executor.getScheduledExecutorService());
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsResource = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    assertThat(ldsResource).isEqualTo("grpc/server?udpa.resource.listening_address=10.1.2.3:1");
+    VirtualHost virtualHost =
+        VirtualHost.create(
+            "virtual-host", Collections.singletonList("auth"), new ArrayList<Route>(),
+            ImmutableMap.<String, FilterConfig>of());
+    HttpConnectionManager httpConnectionManager = HttpConnectionManager.forVirtualHosts(
+        0L, Collections.singletonList(virtualHost), new ArrayList<NamedFilterConfig>());
+    EnvoyServerProtoData.FilterChain filterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-foo", createMatch(), httpConnectionManager, createTls(),
+        mock(TlsContextManager.class));
+    LdsUpdate listenerUpdate = LdsUpdate.forTcpListener(
+        Listener.create("listener", "20.3.4.5:",
+            ImmutableList.copyOf(Collections.singletonList(filterChain)), null, Protocol.TCP));
+
+    xdsClient.deliverLdsUpdate(listenerUpdate);
+
+    verify(listener, timeout(10000)).onNotServing(any());
+  }
+
+  @Test
+  public void onChanged_listenerAddressMismatch()
+      throws ExecutionException, InterruptedException, TimeoutException {
+    xdsServerWrapper = new XdsServerWrapper("10.1.2.3:1", mockBuilder, listener,
+        selectorManager, new FakeXdsClientPoolFactory(xdsClient),
+        XdsServerTestHelper.RAW_BOOTSTRAP,
+        filterRegistry, executor.getScheduledExecutorService());
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsResource = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    assertThat(ldsResource).isEqualTo("grpc/server?udpa.resource.listening_address=10.1.2.3:1");
+    VirtualHost virtualHost =
+        VirtualHost.create(
+            "virtual-host", Collections.singletonList("auth"), new ArrayList<Route>(),
+            ImmutableMap.<String, FilterConfig>of());
+    HttpConnectionManager httpConnectionManager = HttpConnectionManager.forVirtualHosts(
+        0L, Collections.singletonList(virtualHost), new ArrayList<NamedFilterConfig>());
+    EnvoyServerProtoData.FilterChain filterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-foo", createMatch(), httpConnectionManager, createTls(),
+        mock(TlsContextManager.class));
+    LdsUpdate listenerUpdate = LdsUpdate.forTcpListener(
+        Listener.create("listener", "20.3.4.5:1",
+            ImmutableList.copyOf(Collections.singletonList(filterChain)), null, Protocol.TCP));
+
+    xdsClient.deliverLdsUpdate(listenerUpdate);
+
+    verify(listener, timeout(10000)).onNotServing(any());
+  }
+
+  @Test
+  public void onChanged_listenerAddressPortMismatch()
+      throws ExecutionException, InterruptedException, TimeoutException {
+    xdsServerWrapper = new XdsServerWrapper("10.1.2.3:1", mockBuilder, listener,
+        selectorManager, new FakeXdsClientPoolFactory(xdsClient),
+        XdsServerTestHelper.RAW_BOOTSTRAP,
+        filterRegistry, executor.getScheduledExecutorService());
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsResource = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    assertThat(ldsResource).isEqualTo("grpc/server?udpa.resource.listening_address=10.1.2.3:1");
+    VirtualHost virtualHost =
+        VirtualHost.create(
+            "virtual-host", Collections.singletonList("auth"), new ArrayList<Route>(),
+            ImmutableMap.<String, FilterConfig>of());
+    HttpConnectionManager httpConnectionManager = HttpConnectionManager.forVirtualHosts(
+        0L, Collections.singletonList(virtualHost), new ArrayList<NamedFilterConfig>());
+    EnvoyServerProtoData.FilterChain filterChain = EnvoyServerProtoData.FilterChain.create(
+        "filter-chain-foo", createMatch(), httpConnectionManager, createTls(),
+        mock(TlsContextManager.class));
+    LdsUpdate listenerUpdate = LdsUpdate.forTcpListener(
+        Listener.create("listener", "10.1.2.3:2",
+            ImmutableList.copyOf(Collections.singletonList(filterChain)), null, Protocol.TCP));
+
+    xdsClient.deliverLdsUpdate(listenerUpdate);
+
+    verify(listener, timeout(10000)).onNotServing(any());
+  }
+
+  @Test
+  public void discoverState_rds() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsWatched = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    assertThat(ldsWatched).isEqualTo("grpc/server?udpa.resource.listening_address=0.0.0.0:1");
+    VirtualHost virtualHost = createVirtualHost("virtual-host-0");
+    HttpConnectionManager hcmVirtual = HttpConnectionManager.forVirtualHosts(
+            0L, Collections.singletonList(virtualHost), new ArrayList<NamedFilterConfig>());
+    EnvoyServerProtoData.FilterChain f0 = createFilterChain("filter-chain-0", hcmVirtual);
+    EnvoyServerProtoData.FilterChain f1 = createFilterChain("filter-chain-1", createRds("r0"));
+    xdsClient.setExpectedRdsCount(3);
+    xdsClient.deliverLdsUpdate(Arrays.asList(f0, f1), null);
+    assertThat(start.isDone()).isFalse();
+    assertThat(selectorManager.getSelectorToUpdateSelector()).isNull();
+    verify(mockServer, never()).start();
+    verify(listener, never()).onServing();
+
+    EnvoyServerProtoData.FilterChain f2 = createFilterChain("filter-chain-2", createRds("r1"));
+    EnvoyServerProtoData.FilterChain f3 = createFilterChain("filter-chain-3", createRds("r2"));
+    xdsClient.deliverLdsUpdate(Arrays.asList(f0, f2), f3);
+    verify(mockServer, never()).start();
+    verify(listener, never()).onServing();
+    xdsClient.awaitRds(FakeXdsClient.DEFAULT_TIMEOUT);
+
+    xdsClient.deliverRdsUpdate("r1",
+            Collections.singletonList(createVirtualHost("virtual-host-1")));
+    verify(mockServer, never()).start();
+    xdsClient.deliverRdsUpdate("r2",
+            Collections.singletonList(createVirtualHost("virtual-host-2")));
+    start.get(5000, TimeUnit.MILLISECONDS);
+    verify(mockServer).start();
+    ServerRoutingConfig realConfig =
+        selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().get(f0).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-0")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+    assertThat(selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().size())
+        .isEqualTo(2);
+    realConfig = selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().get(f2).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-1")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+    realConfig = selectorManager.getSelectorToUpdateSelector().getDefaultRoutingConfig().get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-2")));
+    assertThat(selectorManager.getSelectorToUpdateSelector().getDefaultSslContextProviderSupplier())
+        .isEqualTo(f3.sslContextProviderSupplier());
+  }
+
+  @Test
+  public void discoverState_oneRdsToMultipleFilterChain() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsWatched = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    assertThat(ldsWatched).isEqualTo("grpc/server?udpa.resource.listening_address=0.0.0.0:1");
+    EnvoyServerProtoData.FilterChain f0 = createFilterChain("filter-chain-0", createRds("r0"));
+    EnvoyServerProtoData.FilterChain f1 = createFilterChain("filter-chain-1", createRds("r0"));
+    EnvoyServerProtoData.FilterChain f2 = createFilterChain("filter-chain-2", createRds("r0"));
+
+    xdsClient.deliverLdsUpdate(Arrays.asList(f0, f1), f2);
+    assertThat(start.isDone()).isFalse();
+    assertThat(selectorManager.getSelectorToUpdateSelector()).isNull();
+
+    xdsClient.awaitRds(FakeXdsClient.DEFAULT_TIMEOUT);
+    xdsClient.deliverRdsUpdate("r0",
+            Collections.singletonList(createVirtualHost("virtual-host-0")));
+    start.get(5000, TimeUnit.MILLISECONDS);
+    verify(mockServer, times(1)).start();
+    ServerRoutingConfig realConfig =
+        selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().get(f0).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-0")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+
+    realConfig = selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().get(f1).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-0")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+
+    realConfig = selectorManager.getSelectorToUpdateSelector().getDefaultRoutingConfig().get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-0")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+    assertThat(selectorManager.getSelectorToUpdateSelector().getDefaultSslContextProviderSupplier())
+        .isSameInstanceAs(f2.sslContextProviderSupplier());
+
+    EnvoyServerProtoData.FilterChain f3 = createFilterChain("filter-chain-3", createRds("r0"));
+    EnvoyServerProtoData.FilterChain f4 = createFilterChain("filter-chain-4", createRds("r1"));
+    EnvoyServerProtoData.FilterChain f5 = createFilterChain("filter-chain-4", createRds("r1"));
+    xdsClient.setExpectedRdsCount(1);
+    xdsClient.deliverLdsUpdate(Arrays.asList(f5, f3), f4);
+    xdsClient.awaitRds(FakeXdsClient.DEFAULT_TIMEOUT);
+    xdsClient.deliverRdsUpdate("r1",
+            Collections.singletonList(createVirtualHost("virtual-host-1")));
+    xdsClient.deliverRdsUpdate("r0",
+            Collections.singletonList(createVirtualHost("virtual-host-0")));
+
+    assertThat(selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().size())
+        .isEqualTo(2);
+    realConfig = selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().get(f5).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-1")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+    realConfig = selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().get(f3).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-0")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+
+    realConfig = selectorManager.getSelectorToUpdateSelector().getDefaultRoutingConfig().get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-1")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+
+    assertThat(selectorManager.getSelectorToUpdateSelector().getDefaultSslContextProviderSupplier())
+        .isSameInstanceAs(f4.sslContextProviderSupplier());
+    verify(mockServer, times(1)).start();
+    xdsServerWrapper.shutdown();
+    verify(mockServer, times(1)).shutdown();
+    when(mockServer.isTerminated()).thenReturn(true);
+    xdsServerWrapper.awaitTermination();
+    assertThat(xdsServerWrapper.isTerminated()).isTrue();
+  }
+
+  @Test
+  public void discoverState_rds_onError_and_resourceNotExist() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsWatched = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    assertThat(ldsWatched).isEqualTo("grpc/server?udpa.resource.listening_address=0.0.0.0:1");
+    VirtualHost virtualHost = createVirtualHost("virtual-host-0");
+    HttpConnectionManager hcmVirtual = HttpConnectionManager.forVirtualHosts(
+            0L, Collections.singletonList(virtualHost), new ArrayList<NamedFilterConfig>());
+    EnvoyServerProtoData.FilterChain f0 = createFilterChain("filter-chain-0", hcmVirtual);
+    EnvoyServerProtoData.FilterChain f1 = createFilterChain("filter-chain-1", createRds("r0"));
+    xdsClient.deliverLdsUpdate(Arrays.asList(f0, f1), null);
+    xdsClient.awaitRds(FakeXdsClient.DEFAULT_TIMEOUT);
+    xdsClient.rdsWatchers.get("r0").onResourceChanged(StatusOr.fromStatus(Status.CANCELLED));
+    start.get(5000, TimeUnit.MILLISECONDS);
+    assertThat(selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().size())
+        .isEqualTo(2);
+    ServerRoutingConfig realConfig =
+        selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().get(f1).get();
+    assertThat(realConfig.virtualHosts()).isEmpty();
+    assertThat(realConfig.interceptors()).isEmpty();
+
+    realConfig = selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().get(f0).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(hcmVirtual.virtualHosts());
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+
+    xdsClient.deliverRdsUpdate("r0",
+            Collections.singletonList(createVirtualHost("virtual-host-1")));
+    realConfig = selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().get(f1).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-1")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+
+    xdsClient.rdsWatchers.get("r0").onAmbientError(Status.CANCELLED);
+    realConfig = selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().get(f1).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-1")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+
+    Status notFoundStatus = Status.NOT_FOUND.withDescription("Resource r0 does not exist");
+    xdsClient.rdsWatchers.get("r0").onResourceChanged(StatusOr.fromStatus(notFoundStatus));
+    realConfig = selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().get(f1).get();
+    assertThat(realConfig.virtualHosts()).isEmpty();
+    assertThat(realConfig.interceptors()).isEmpty();
+  }
+
+  @Test
+  public void error() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    String ldsResource = xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    Status notFoundStatus = Status.NOT_FOUND.withDescription(
+        "FakeXdsClient: Resource not found: " + ldsResource);
+    xdsClient.ldsWatcher.onResourceChanged(StatusOr.fromStatus(notFoundStatus));
+    verify(listener, timeout(5000)).onNotServing(any());
+    try {
+      start.get(START_WAIT_AFTER_LISTENER_MILLIS, TimeUnit.MILLISECONDS);
+      fail("server should not start()");
+    } catch (TimeoutException ex) {
+      // expect to block here.
+      assertThat(start.isDone()).isFalse();
+    }
+    verify(listener, times(1)).onNotServing(any(StatusException.class));
+    verify(mockBuilder, times(1)).build();
+    FilterChain filterChain0 = createFilterChain("filter-chain-0", createRds("rds"));
+    SslContextProviderSupplier sslSupplier0 = filterChain0.sslContextProviderSupplier();
+    xdsClient.deliverLdsUpdate(Collections.singletonList(filterChain0), null);
+    ResourceWatcher<RdsUpdate> saveRdsWatcher = xdsClient.rdsWatchers.get("rds");
+    xdsClient.ldsWatcher.onResourceChanged(StatusOr.fromStatus(Status.INTERNAL));
+    assertThat(selectorManager.getSelectorToUpdateSelector())
+        .isSameInstanceAs(FilterChainSelector.NO_FILTER_CHAIN);
+    verify(mockBuilder, times(1)).build();
+    verify(listener, times(2)).onNotServing(any(StatusException.class));
+    assertThat(sslSupplier0.isShutdown()).isFalse();
+
+    when(mockServer.start()).thenThrow(new IOException("error!"))
+            .thenReturn(mockServer);
+    FilterChain filterChain1 = createFilterChain("filter-chain-1", createRds("rds"));
+    SslContextProviderSupplier sslSupplier1 = filterChain1.sslContextProviderSupplier();
+    xdsClient.deliverLdsUpdate(Collections.singletonList(filterChain1), null);
+    assertThat(sslSupplier0.isShutdown()).isTrue();
+    xdsClient.deliverRdsUpdate("rds",
+            Collections.singletonList(createVirtualHost("virtual-host-1")));
+    try {
+      start.get(5000, TimeUnit.MILLISECONDS);
+      fail("Start should throw exception");
+    } catch (ExecutionException ex) {
+      assertThat(ex.getCause()).isInstanceOf(IOException.class);
+      assertThat(ex.getCause().getMessage()).isEqualTo("error!");
+    }
+    assertThat(executor.forwardNanos(RETRY_DELAY_NANOS)).isEqualTo(1);
+    verify(mockBuilder, times(1)).build();
+    verify(mockServer, times(2)).start();
+    verify(listener, times(1)).onServing();
+    assertThat(selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().size())
+        .isEqualTo(1);
+    ServerRoutingConfig realConfig =
+        selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().get(filterChain1).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-1")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+
+    // xds update after start
+    xdsClient.deliverRdsUpdate("rds",
+            Collections.singletonList(createVirtualHost("virtual-host-2")));
+    assertThat(sslSupplier1.isShutdown()).isFalse();
+    xdsClient.ldsWatcher.onAmbientError(Status.DEADLINE_EXCEEDED);
+    verify(mockBuilder, times(1)).build();
+    verify(mockServer, times(2)).start();
+    verify(listener, times(2)).onNotServing(any(StatusException.class));
+    assertThat(selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().size())
+        .isEqualTo(1);
+    realConfig = selectorManager.getSelectorToUpdateSelector().getRoutingConfigs()
+        .get(filterChain1).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-2")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+
+    assertThat(sslSupplier1.isShutdown()).isFalse();
+
+    // not serving after serving
+    xdsClient.ldsWatcher.onResourceChanged(StatusOr.fromStatus(notFoundStatus));
+    assertThat(xdsClient.rdsWatchers).isEmpty();
+    verify(mockServer, times(3)).shutdown(); // This is the 3rd shutdown in the test.
+    when(mockServer.isShutdown()).thenReturn(true);
+    assertThat(selectorManager.getSelectorToUpdateSelector())
+        .isSameInstanceAs(FilterChainSelector.NO_FILTER_CHAIN);
+    verify(listener, times(3)).onNotServing(any(StatusException.class));
+    assertThat(sslSupplier1.isShutdown()).isTrue();
+    assertThat(xdsClient.rdsWatchers.get("rds")).isNull();
+    // no op
+    saveRdsWatcher.onResourceChanged(StatusOr.fromValue(
+        new RdsUpdate(Collections.singletonList(createVirtualHost("virtual-host-1")))));
+    verify(mockBuilder, times(1)).build();
+    verify(mockServer, times(2)).start();
+    verify(listener, times(1)).onServing();
+
+    // cancel retry
+    when(mockServer.start()).thenThrow(new IOException("error1!"))
+            .thenThrow(new IOException("error2!"))
+            .thenReturn(mockServer);
+    FilterChain filterChain2 = createFilterChain("filter-chain-2", createRds("rds"));
+    SslContextProviderSupplier sslSupplier2 = filterChain2.sslContextProviderSupplier();
+    xdsClient.deliverLdsUpdate(Collections.singletonList(filterChain2), null);
+    xdsClient.deliverRdsUpdate("rds",
+            Collections.singletonList(createVirtualHost("virtual-host-1")));
+    assertThat(sslSupplier1.isShutdown()).isTrue();
+    verify(mockBuilder, times(2)).build();
+    when(mockServer.isShutdown()).thenReturn(false);
+    verify(mockServer, times(3)).start();
+    verify(listener, times(1)).onServing();
+    verify(listener, times(3)).onNotServing(any(StatusException.class));
+    assertThat(selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().size())
+        .isEqualTo(1);
+    realConfig = selectorManager.getSelectorToUpdateSelector().getRoutingConfigs()
+        .get(filterChain2).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-1")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+
+    assertThat(executor.numPendingTasks()).isEqualTo(1);
+    xdsClient.ldsWatcher.onResourceChanged(StatusOr.fromStatus(notFoundStatus));
+    verify(mockServer, times(4)).shutdown();
+    verify(listener, times(4)).onNotServing(any(StatusException.class));
+    verify(listener, times(1)).onNotServing(any(IOException.class));
+    when(mockServer.isShutdown()).thenReturn(true);
+    assertThat(executor.numPendingTasks()).isEqualTo(0);
+    assertThat(sslSupplier2.isShutdown()).isTrue();
+
+    // serving after not serving
+    FilterChain filterChain3 = createFilterChain("filter-chain-2", createRds("rds"));
+    SslContextProviderSupplier sslSupplier3 = filterChain3.sslContextProviderSupplier();
+    xdsClient.deliverLdsUpdate(Collections.singletonList(filterChain3), null);
+    xdsClient.deliverRdsUpdate("rds",
+            Collections.singletonList(createVirtualHost("virtual-host-1")));
+    verify(mockBuilder, times(3)).build();
+    verify(mockServer, times(4)).start();
+    verify(listener, times(1)).onServing();
+    when(mockServer.isShutdown()).thenReturn(false);
+    verify(listener, times(4)).onNotServing(any(StatusException.class));
+
+    assertThat(selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().size())
+        .isEqualTo(1);
+    realConfig = selectorManager.getSelectorToUpdateSelector().getRoutingConfigs()
+        .get(filterChain3).get();
+    assertThat(realConfig.virtualHosts()).isEqualTo(
+        Collections.singletonList(createVirtualHost("virtual-host-1")));
+    assertThat(realConfig.interceptors()).isEqualTo(ImmutableMap.of());
+
+    xdsServerWrapper.shutdown();
+    verify(mockServer, times(5)).shutdown();
+    assertThat(sslSupplier3.isShutdown()).isTrue();
+    when(mockServer.awaitTermination(anyLong(), any(TimeUnit.class))).thenReturn(true);
+    assertThat(xdsServerWrapper.awaitTermination(5, TimeUnit.SECONDS)).isTrue();
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void interceptor_success() throws Exception {
+    ArgumentCaptor<ConfigApplyingInterceptor> interceptorCaptor =
+        ArgumentCaptor.forClass(ConfigApplyingInterceptor.class);
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    verify(mockBuilder).intercept(interceptorCaptor.capture());
+    ConfigApplyingInterceptor interceptor = interceptorCaptor.getValue();
+    RouteMatch routeMatch =
+        RouteMatch.create(
+            PathMatcher.fromPath("/FooService/barMethod", true),
+            Collections.<HeaderMatcher>emptyList(), null);
+    Route route = Route.forAction(routeMatch, null,
+        ImmutableMap.<String, FilterConfig>of());
+    VirtualHost virtualHost  = VirtualHost.create(
+        "v1", Collections.singletonList("foo.google.com"), Arrays.asList(route),
+        ImmutableMap.<String, FilterConfig>of());
+    final List<Integer> interceptorTrace = new ArrayList<>();
+    ServerInterceptor interceptor0 = new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+          Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+        interceptorTrace.add(0);
+        return next.startCall(call, headers);
+      }
+    };
+    ServerRoutingConfig realConfig = ServerRoutingConfig.create(
+        ImmutableList.of(virtualHost), ImmutableMap.of(route, interceptor0));
+    ServerCall<Void, Void> serverCall = mock(ServerCall.class);
+    when(serverCall.getMethodDescriptor()).thenReturn(createMethod("FooService/barMethod"));
+    when(serverCall.getAttributes()).thenReturn(
+        Attributes.newBuilder().set(ATTR_SERVER_ROUTING_CONFIG,
+            new AtomicReference<>(realConfig)).build());
+    when(serverCall.getAuthority()).thenReturn("foo.google.com");
+    ServerCallHandler<Void, Void> next = mock(ServerCallHandler.class);
+    interceptor.interceptCall(serverCall, new Metadata(), next);
+    verify(next).startCall(eq(serverCall), any(Metadata.class));
+    assertThat(interceptorTrace).isEqualTo(Arrays.asList(0));
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void interceptor_virtualHostNotMatch() throws Exception {
+    ArgumentCaptor<ConfigApplyingInterceptor> interceptorCaptor =
+            ArgumentCaptor.forClass(ConfigApplyingInterceptor.class);
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    verify(mockBuilder).intercept(interceptorCaptor.capture());
+    ConfigApplyingInterceptor interceptor = interceptorCaptor.getValue();
+    ServerRoutingConfig routingConfig =
+        createRoutingConfig("/FooService/barMethod", "foo.google.com");
+    ServerCall<Void, Void> serverCall = mock(ServerCall.class);
+    when(serverCall.getAttributes()).thenReturn(
+        Attributes.newBuilder().set(ATTR_SERVER_ROUTING_CONFIG,
+            new AtomicReference<>(routingConfig)).build());
+    when(serverCall.getAuthority()).thenReturn("not-match.google.com");
+
+    Filter.Provider filterProvider = mock(Filter.Provider.class);
+    when(filterProvider.typeUrls()).thenReturn(new String[]{"filter-type-url"});
+    when(filterProvider.isServerFilter()).thenReturn(true);
+    filterRegistry.register(filterProvider);
+
+    ServerCallHandler<Void, Void> next = mock(ServerCallHandler.class);
+    interceptor.interceptCall(serverCall, new Metadata(), next);
+    verify(next, never()).startCall(any(ServerCall.class), any(Metadata.class));
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(serverCall).close(statusCaptor.capture(), any(Metadata.class));
+    Status status = statusCaptor.getValue();
+    assertThat(status.getCode()).isEqualTo(Status.UNAVAILABLE.getCode());
+    assertThat(status.getDescription()).isEqualTo("Could not find xDS virtual host matching RPC");
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void interceptor_routeNotMatch() throws Exception {
+    ArgumentCaptor<ConfigApplyingInterceptor> interceptorCaptor =
+            ArgumentCaptor.forClass(ConfigApplyingInterceptor.class);
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    verify(mockBuilder).intercept(interceptorCaptor.capture());
+    ConfigApplyingInterceptor interceptor = interceptorCaptor.getValue();
+    ServerRoutingConfig routingConfig =
+        createRoutingConfig("/FooService/barMethod", "foo.google.com");
+    ServerCall<Void, Void> serverCall = mock(ServerCall.class);
+    when(serverCall.getAttributes()).thenReturn(
+            Attributes.newBuilder()
+                .set(ATTR_SERVER_ROUTING_CONFIG, new AtomicReference<>(routingConfig)).build());
+    when(serverCall.getMethodDescriptor()).thenReturn(createMethod("NotMatchMethod"));
+    when(serverCall.getAuthority()).thenReturn("foo.google.com");
+
+    Filter.Provider filterProvider = mock(Filter.Provider.class);
+    when(filterProvider.typeUrls()).thenReturn(new String[]{"filter-type-url"});
+    when(filterProvider.isServerFilter()).thenReturn(true);
+    filterRegistry.register(filterProvider);
+
+    ServerCallHandler<Void, Void> next = mock(ServerCallHandler.class);
+    interceptor.interceptCall(serverCall, new Metadata(), next);
+    verify(next, never()).startCall(any(ServerCall.class), any(Metadata.class));
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(serverCall).close(statusCaptor.capture(), any(Metadata.class));
+    Status status = statusCaptor.getValue();
+    assertThat(status.getCode()).isEqualTo(Status.UNAVAILABLE.getCode());
+    assertThat(status.getDescription()).isEqualTo("Could not find xDS route matching RPC");
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void interceptor_invalidRouteAction() throws Exception {
+    ArgumentCaptor<ConfigApplyingInterceptor> interceptorCaptor =
+        ArgumentCaptor.forClass(ConfigApplyingInterceptor.class);
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    verify(mockBuilder).intercept(interceptorCaptor.capture());
+    ConfigApplyingInterceptor interceptor = interceptorCaptor.getValue();
+    ServerRoutingConfig routingConfig =
+        createRoutingConfig(
+            "/FooService/barMethod",
+            "foo.google.com",
+            Route.RouteAction.forCluster(
+                "cluster", Collections.<Route.RouteAction.HashPolicy>emptyList(), null, null,
+                false));
+    ServerCall<Void, Void> serverCall = mock(ServerCall.class);
+    when(serverCall.getAttributes()).thenReturn(
+        Attributes.newBuilder()
+            .set(ATTR_SERVER_ROUTING_CONFIG, new AtomicReference<>(routingConfig)).build());
+    when(serverCall.getMethodDescriptor()).thenReturn(createMethod("FooService/barMethod"));
+    when(serverCall.getAuthority()).thenReturn("foo.google.com");
+
+    Filter.Provider filterProvider = mock(Filter.Provider.class);
+    when(filterProvider.typeUrls()).thenReturn(new String[]{"filter-type-url"});
+    when(filterProvider.isServerFilter()).thenReturn(true);
+    filterRegistry.register(filterProvider);
+
+    ServerCallHandler<Void, Void> next = mock(ServerCallHandler.class);
+    interceptor.interceptCall(serverCall, new Metadata(), next);
+    verify(next, never()).startCall(any(ServerCall.class), any(Metadata.class));
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(serverCall).close(statusCaptor.capture(), any(Metadata.class));
+    Status status = statusCaptor.getValue();
+    assertThat(status.getCode()).isEqualTo(Status.UNAVAILABLE.getCode());
+    assertThat(status.getDescription()).isEqualTo("Invalid xDS route action for matching "
+        + "route: only Route.non_forwarding_action should be allowed.");
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void interceptor_failingRouterConfig() throws Exception {
+    ArgumentCaptor<ConfigApplyingInterceptor> interceptorCaptor =
+            ArgumentCaptor.forClass(ConfigApplyingInterceptor.class);
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    verify(mockBuilder).intercept(interceptorCaptor.capture());
+    ConfigApplyingInterceptor interceptor = interceptorCaptor.getValue();
+    ServerCall<Void, Void> serverCall = mock(ServerCall.class);
+
+    when(serverCall.getAttributes()).thenReturn(
+        Attributes.newBuilder().set(ATTR_SERVER_ROUTING_CONFIG,
+            new AtomicReference<>(ServerRoutingConfig.FAILING_ROUTING_CONFIG)).build());
+
+    ServerCallHandler<Void, Void> next = mock(ServerCallHandler.class);
+    interceptor.interceptCall(serverCall, new Metadata(), next);
+    verify(next, never()).startCall(any(ServerCall.class), any(Metadata.class));
+    ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(serverCall).close(statusCaptor.capture(), any(Metadata.class));
+    Status status = statusCaptor.getValue();
+    assertThat(status.getCode()).isEqualTo(Status.UNAVAILABLE.getCode());
+    assertThat(status.getDescription()).isEqualTo(
+        "Missing or broken xDS routing config: RDS config unavailable.");
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void buildInterceptor_inline() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+    RouteMatch routeMatch =
+        RouteMatch.create(
+            PathMatcher.fromPath("/FooService/barMethod", true),
+            Collections.<HeaderMatcher>emptyList(), null);
+
+    Filter filter = mock(Filter.class);
+    Filter.Provider filterProvider = mock(Filter.Provider.class);
+    when(filterProvider.typeUrls()).thenReturn(new String[]{"filter-type-url"});
+    when(filterProvider.isServerFilter()).thenReturn(true);
+    when(filterProvider.newInstance(any(String.class))).thenReturn(filter);
+    filterRegistry.register(filterProvider);
+
+    FilterConfig f0 = mock(FilterConfig.class);
+    FilterConfig f0Override = mock(FilterConfig.class);
+    when(f0.typeUrl()).thenReturn("filter-type-url");
+    final List<Integer> interceptorTrace = new ArrayList<>();
+    ServerInterceptor interceptor0 = new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+          Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+        interceptorTrace.add(0);
+        return next.startCall(call, headers);
+      }
+    };
+    ServerInterceptor interceptor1 = new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+          Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+        interceptorTrace.add(1);
+        return next.startCall(call, headers);
+      }
+    };
+    when(filter.buildServerInterceptor(f0, null)).thenReturn(interceptor0);
+    when(filter.buildServerInterceptor(f0, f0Override)).thenReturn(interceptor1);
+    Route route = Route.forAction(routeMatch, null,
+        ImmutableMap.<String, FilterConfig>of());
+    VirtualHost virtualHost  = VirtualHost.create(
+        "v1", Collections.singletonList("foo.google.com"), Arrays.asList(route),
+        ImmutableMap.of("filter-config-name-0", f0Override));
+    HttpConnectionManager hcmVirtual = HttpConnectionManager.forVirtualHosts(
+        0L, Collections.singletonList(virtualHost),
+        Arrays.asList(new NamedFilterConfig("filter-config-name-0", f0),
+            new NamedFilterConfig("filter-config-name-1", f0)));
+    EnvoyServerProtoData.FilterChain filterChain = createFilterChain("filter-chain-0", hcmVirtual);
+    xdsClient.deliverLdsUpdate(Collections.singletonList(filterChain), null);
+    start.get(5000, TimeUnit.MILLISECONDS);
+    verify(mockServer).start();
+    assertThat(selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().size())
+        .isEqualTo(1);
+    ServerInterceptor realInterceptor = selectorManager.getSelectorToUpdateSelector()
+        .getRoutingConfigs().get(filterChain).get().interceptors().get(route);
+    assertThat(realInterceptor).isNotNull();
+
+    ServerCall<Void, Void> serverCall = mock(ServerCall.class);
+    ServerCallHandler<Void, Void> mockNext = mock(ServerCallHandler.class);
+    final ServerCall.Listener<Void> listener = new ServerCall.Listener<Void>() {};
+    when(mockNext.startCall(any(ServerCall.class), any(Metadata.class))).thenReturn(listener);
+    realInterceptor.interceptCall(serverCall, new Metadata(), mockNext);
+    assertThat(interceptorTrace).isEqualTo(Arrays.asList(1, 0));
+    verify(mockNext).startCall(eq(serverCall), any(Metadata.class));
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void buildInterceptor_rds() throws Exception {
+    final SettableFuture<Server> start = SettableFuture.create();
+    Executors.newSingleThreadExecutor().execute(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          start.set(xdsServerWrapper.start());
+        } catch (Exception ex) {
+          start.setException(ex);
+        }
+      }
+    });
+    xdsClient.ldsResource.get(5, TimeUnit.SECONDS);
+
+    Filter filter = mock(Filter.class);
+    Filter.Provider filterProvider = mock(Filter.Provider.class);
+    when(filterProvider.typeUrls()).thenReturn(new String[]{"filter-type-url"});
+    when(filterProvider.isServerFilter()).thenReturn(true);
+    when(filterProvider.newInstance(any(String.class))).thenReturn(filter);
+    filterRegistry.register(filterProvider);
+
+    FilterConfig f0 = mock(FilterConfig.class);
+    FilterConfig f0Override = mock(FilterConfig.class);
+    when(f0.typeUrl()).thenReturn("filter-type-url");
+    final List<Integer> interceptorTrace = new ArrayList<>();
+    ServerInterceptor interceptor0 = new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+          Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+        interceptorTrace.add(0);
+        return next.startCall(call, headers);
+      }
+    };
+    ServerInterceptor interceptor1 = new ServerInterceptor() {
+      @Override
+      public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
+          Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+        interceptorTrace.add(1);
+        return next.startCall(call, headers);
+      }
+    };
+    when(filter.buildServerInterceptor(f0, null)).thenReturn(interceptor0);
+    when(filter.buildServerInterceptor(f0, f0Override)).thenReturn(interceptor1);
+    RouteMatch routeMatch =
+        RouteMatch.create(
+            PathMatcher.fromPath("/FooService/barMethod", true),
+            Collections.<HeaderMatcher>emptyList(), null);
+
+    HttpConnectionManager rdsHcm = HttpConnectionManager.forRdsName(0L, "r0",
+        Arrays.asList(new NamedFilterConfig("filter-config-name-0", f0),
+            new NamedFilterConfig("filter-config-name-1", f0)));
+    EnvoyServerProtoData.FilterChain filterChain = createFilterChain("filter-chain-0", rdsHcm);
+    xdsClient.deliverLdsUpdate(Collections.singletonList(filterChain), null);
+    Route route = Route.forAction(routeMatch, null,
+        ImmutableMap.<String, FilterConfig>of());
+    VirtualHost virtualHost  = VirtualHost.create(
+        "v1", Collections.singletonList("foo.google.com"), Arrays.asList(route),
+        ImmutableMap.of("filter-config-name-0", f0Override));
+    xdsClient.awaitRds(FakeXdsClient.DEFAULT_TIMEOUT);
+    xdsClient.deliverRdsUpdate("r0", Collections.singletonList(virtualHost));
+    start.get(5000, TimeUnit.MILLISECONDS);
+    verify(mockServer).start();
+    assertThat(selectorManager.getSelectorToUpdateSelector().getRoutingConfigs().size())
+        .isEqualTo(1);
+    ServerInterceptor realInterceptor = selectorManager.getSelectorToUpdateSelector()
+        .getRoutingConfigs().get(filterChain).get().interceptors().get(route);
+    assertThat(realInterceptor).isNotNull();
+
+    ServerCall<Void, Void> serverCall = mock(ServerCall.class);
+    ServerCallHandler<Void, Void> mockNext = mock(ServerCallHandler.class);
+    final ServerCall.Listener<Void> listener = new ServerCall.Listener<Void>() {};
+    when(mockNext.startCall(any(ServerCall.class), any(Metadata.class))).thenReturn(listener);
+    realInterceptor.interceptCall(serverCall, new Metadata(), mockNext);
+    assertThat(interceptorTrace).isEqualTo(Arrays.asList(1, 0));
+    verify(mockNext).startCall(eq(serverCall), any(Metadata.class));
+
+    virtualHost  = VirtualHost.create(
+        "v1", Collections.singletonList("foo.google.com"), Arrays.asList(route),
+         ImmutableMap.<String, FilterConfig>of());
+    xdsClient.deliverRdsUpdate("r0", Collections.singletonList(virtualHost));
+    realInterceptor = selectorManager.getSelectorToUpdateSelector().getRoutingConfigs()
+        .get(filterChain).get().interceptors().get(route);
+    assertThat(realInterceptor).isNotNull();
+    interceptorTrace.clear();
+    realInterceptor.interceptCall(serverCall, new Metadata(), mockNext);
+    assertThat(interceptorTrace).isEqualTo(Arrays.asList(0, 0));
+    verify(mockNext, times(2)).startCall(eq(serverCall), any(Metadata.class));
+
+    Status notFoundStatus = Status.NOT_FOUND.withDescription("Resource r0 does not exist");
+    xdsClient.rdsWatchers.get("r0").onResourceChanged(StatusOr.fromStatus(notFoundStatus));
+    assertThat(selectorManager.getSelectorToUpdateSelector().getRoutingConfigs()
+        .get(filterChain).get()).isEqualTo(noopConfig);
+  }
+
+  // Begin filter state tests.
+
+  @Test
+  public void filterState_survivesLds() {
+    StatefulFilter.Provider statefulFilterProvider = new StatefulFilter.Provider();
+    FilterRegistry filterRegistry = filterStateTestFilterRegistry(statefulFilterProvider);
+    SettableFuture<Server> serverStart = filterStateTestStartServer(filterRegistry);
+
+    VirtualHost vhost = filterStateTestVhost();
+
+    // LDS 1.
+    FilterChain lds1FilterChain = createFilterChain("chain_0",
+        createHcm(vhost, filterStateTestConfigs(STATEFUL_1, STATEFUL_2)));
+    xdsClient.deliverLdsUpdate(lds1FilterChain, null);
+    verifyServerStarted(serverStart);
+    ImmutableList<StatefulFilter> lds1Snapshot = statefulFilterProvider.getAllInstances();
+    // Verify that StatefulFilter with different filter names result in different Filter instances.
+    assertWithMessage("LDS 1: expected to create filter instances").that(lds1Snapshot).hasSize(2);
+    // Naming: lds<LDS#>Filter<name#>
+    StatefulFilter lds1Filter1 = lds1Snapshot.get(0);
+    StatefulFilter lds1Filter2 = lds1Snapshot.get(1);
+    assertThat(lds1Filter1).isNotSameInstanceAs(lds1Filter2);
+    // Redundant check just in case StatefulFilter synchronization is broken.
+    assertThat(lds1Filter1.idx).isEqualTo(0);
+    assertThat(lds1Filter2.idx).isEqualTo(1);
+
+    // LDS 2: filter configs with the same names.
+    FilterChain lds2FilterChain = createFilterChain("chain_0",
+        createHcm(vhost, filterStateTestConfigs(STATEFUL_1, STATEFUL_2)));
+    xdsClient.deliverLdsUpdate(lds2FilterChain, null);
+    ImmutableList<StatefulFilter> lds2Snapshot = statefulFilterProvider.getAllInstances();
+    // Filter names hasn't changed, so expecting no new StatefulFilter instances.
+    assertWithMessage("LDS 2: Expected Filter instances to be reused across LDS updates")
+        .that(lds2Snapshot).isEqualTo(lds1Snapshot);
+
+    // LDS 3: Filter "STATEFUL_2" removed.
+    FilterChain lds3FilterChain = createFilterChain("chain_0",
+        createHcm(vhost, filterStateTestConfigs(STATEFUL_1)));
+    xdsClient.deliverLdsUpdate(lds3FilterChain, null);
+    ImmutableList<StatefulFilter> lds3Snapshot = statefulFilterProvider.getAllInstances();
+    // Again, no new StatefulFilter instances should be created.
+    assertWithMessage("LDS 3: Expected Filter instances to be reused across LDS updates")
+        .that(lds3Snapshot).isEqualTo(lds1Snapshot);
+    // Verify the shutdown state.
+    assertThat(lds1Filter1.isShutdown()).isFalse();
+    assertWithMessage("LDS 3: Expected %s to be shut down", lds1Filter2)
+        .that(lds1Filter2.isShutdown()).isTrue();
+
+    // LDS 4: Filter "STATEFUL_2" added back.
+    FilterChain lds4FilterChain = createFilterChain("chain_0",
+        createHcm(vhost, filterStateTestConfigs(STATEFUL_1, STATEFUL_2)));
+    xdsClient.deliverLdsUpdate(lds4FilterChain, null);
+    ImmutableList<StatefulFilter> lds4Snapshot = statefulFilterProvider.getAllInstances();
+    // Filter "STATEFUL_2" should be treated as any other new filter name in an LDS update:
+    // a new instance should be created.
+    assertWithMessage("LDS 4: Expected a new filter instance for %s", STATEFUL_2)
+        .that(lds4Snapshot).hasSize(3);
+    StatefulFilter lds4Filter2 = lds4Snapshot.get(2);
+    assertThat(lds4Filter2.idx).isEqualTo(2);
+    assertThat(lds4Filter2).isNotSameInstanceAs(lds1Filter2);
+    assertThat(lds4Snapshot).containsAtLeastElementsIn(lds1Snapshot);
+    // Verify the shutdown state.
+    assertThat(lds1Filter1.isShutdown()).isFalse();
+    assertThat(lds1Filter2.isShutdown()).isTrue();
+    assertThat(lds4Filter2.isShutdown()).isFalse();
+  }
+
+  @Test
+  public void filterState_survivesRds() throws Exception {
+    StatefulFilter.Provider statefulFilterProvider = new StatefulFilter.Provider();
+    FilterRegistry filterRegistry = filterStateTestFilterRegistry(statefulFilterProvider);
+    SettableFuture<Server> serverStart = filterStateTestStartServer(filterRegistry);
+
+    String rdsName = "rds.example.com";
+
+    // LDS 1.
+    FilterChain fc1 = createFilterChain("fc1",
+        createHcmForRds(rdsName, filterStateTestConfigs(STATEFUL_1, STATEFUL_2)));
+    xdsClient.deliverLdsUpdate(fc1, null);
+    xdsClient.awaitRds(FakeXdsClient.DEFAULT_TIMEOUT);
+    verify(listener, never()).onServing();
+    // Server didn't start, but filter instances should have already been created.
+    ImmutableList<StatefulFilter> lds1Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("LDS 1: expected to create filter instances").that(lds1Snapshot).hasSize(2);
+    // Naming: lds<LDS#>Filter<name#>
+    StatefulFilter lds1Filter1 = lds1Snapshot.get(0);
+    StatefulFilter lds1Filter2 = lds1Snapshot.get(1);
+    assertThat(lds1Filter1).isNotSameInstanceAs(lds1Filter2);
+
+    // RDS 1.
+    VirtualHost vhost1 = filterStateTestVhost();
+    xdsClient.deliverRdsUpdate(rdsName, vhost1);
+    verifyServerStarted(serverStart);
+    assertThat(getSelectorRoutingConfigs()).hasSize(1);
+    assertThat(getSelectorVhosts(fc1)).containsExactly(vhost1);
+    // Initial RDS update should not generate Filter instances.
+    ImmutableList<StatefulFilter> rds1Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("RDS 1: Expected Filter instances to be reused across RDS route updates")
+        .that(rds1Snapshot).isEqualTo(lds1Snapshot);
+
+    // RDS 2: exactly the same as RDS 1.
+    xdsClient.deliverRdsUpdate(rdsName, vhost1);
+    assertThat(getSelectorRoutingConfigs()).hasSize(1);
+    assertThat(getSelectorVhosts(fc1)).containsExactly(vhost1);
+    ImmutableList<StatefulFilter> rds2Snapshot = statefulFilterProvider.getAllInstances();
+    // Neither should any subsequent RDS updates.
+    assertWithMessage("RDS 2: Expected Filter instances to be reused across RDS route updates")
+        .that(rds2Snapshot).isEqualTo(lds1Snapshot);
+
+    // RDS 3: Contains a per-route override for STATEFUL_1.
+    VirtualHost vhost3 = filterStateTestVhost(vhost1.name(), ImmutableMap.of(
+        STATEFUL_1, new Config("RDS3")
+    ));
+    xdsClient.deliverRdsUpdate(rdsName, vhost3);
+    assertThat(getSelectorRoutingConfigs()).hasSize(1);
+    assertThat(getSelectorVhosts(fc1)).containsExactly(vhost3);
+    ImmutableList<StatefulFilter> rds3Snapshot = statefulFilterProvider.getAllInstances();
+    // As with any other Route update, typed_per_filter_config overrides should not result in
+    // creating new filter instances.
+    assertWithMessage("RDS 3: Expected Filter instances to be reused on per-route filter overrides")
+        .that(rds3Snapshot).isEqualTo(lds1Snapshot);
+  }
+
+  @Test
+  public void filterState_uniquePerFilterChain() {
+    StatefulFilter.Provider statefulFilterProvider = new StatefulFilter.Provider();
+    FilterRegistry filterRegistry = filterStateTestFilterRegistry(statefulFilterProvider);
+    SettableFuture<Server> serverStart = filterStateTestStartServer(filterRegistry);
+
+    // Prepare multiple filter chains matchers for testing.
+    FilterChainMatch matcherA = createMatchSrcIp("3fff:a::/32");
+    FilterChainMatch matcherB = createMatchSrcIp("3fff:b::/32");
+
+    // Vhosts won't change too.
+    VirtualHost vhostA = filterStateTestVhost("stateful_vhost_a");
+    VirtualHost vhostB = filterStateTestVhost("stateful_vhost_b");
+
+    // LDS 1.
+    FilterChain lds1ChainA = createFilterChain("chain_a",
+        createHcm(vhostA, filterStateTestConfigs(STATEFUL_1, STATEFUL_2)),
+        matcherA);
+    FilterChain lds1ChainB = createFilterChain("chain_b",
+        createHcm(vhostB, filterStateTestConfigs(STATEFUL_2)),
+        matcherB);
+
+    xdsClient.deliverLdsUpdate(ImmutableList.of(lds1ChainA, lds1ChainB), null);
+    verifyServerStarted(serverStart);
+    ImmutableList<StatefulFilter> lds1Snapshot = statefulFilterProvider.getAllInstances();
+    // Verify that filter with name STATEFUL_2 produced separate instances unique per filter chain.
+    assertWithMessage("LDS 1: expected to create filter instances").that(lds1Snapshot).hasSize(3);
+    // Naming: lds<LDS#>Chain<name>Filter<name#>
+    StatefulFilter lds1ChainAFilter1 = lds1Snapshot.get(0);
+    StatefulFilter lds1ChainAFilter2 = lds1Snapshot.get(1);
+    StatefulFilter lds1ChainBFilter2 = lds1Snapshot.get(2);
+    assertThat(lds1ChainAFilter2).isNotSameInstanceAs(lds1ChainBFilter2);
+
+    // LDS 2: In chain B filter with name STATEFUL_1 is replaced STATEFUL_2.
+    FilterChain lds2ChainA = createFilterChain("chain_a",
+        createHcm(vhostA, filterStateTestConfigs(STATEFUL_1, STATEFUL_2)),
+        matcherA);
+    FilterChain lds2ChainB = createFilterChain("chain_b",
+        createHcm(vhostB, filterStateTestConfigs(STATEFUL_1)),
+        matcherB);
+
+    xdsClient.deliverLdsUpdate(ImmutableList.of(lds2ChainA, lds2ChainB), null);
+    ImmutableList<StatefulFilter> lds2Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("LDS 2: expected a distinct instance of filter %s for Chain B", STATEFUL_1)
+        .that(lds2Snapshot).hasSize(4);
+    StatefulFilter lds2ChainBFilter1 = lds2Snapshot.get(3);
+    assertThat(lds2ChainBFilter1).isNotSameInstanceAs(lds1ChainAFilter1);
+    // Confirm correct STATEFUL_2 has been shut down.
+    assertThat(lds1ChainBFilter2.isShutdown()).isTrue();
+    assertThat(lds1ChainAFilter2.isShutdown()).isFalse();
+
+    // LDS 3: Add default chain
+    // Default filter chain is an exception from the uniqueness rule, and we need to make sure
+    // that this is accounted for when we're tracking active filters per unique FilterChain.
+    FilterChain lds3ChainDefault = createFilterChain("chain_default",
+        createHcm(vhostA, filterStateTestConfigs(STATEFUL_1, STATEFUL_2)),
+        matcherA);
+    xdsClient.deliverLdsUpdate(ImmutableList.of(lds2ChainA, lds2ChainB), lds3ChainDefault);
+    ImmutableList<StatefulFilter> lds3Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("LDS 3: Expected two new distinct filter instances for default chain")
+        .that(lds3Snapshot).hasSize(6);
+    StatefulFilter lds3ChainDefaultFilter1 = lds3Snapshot.get(4);
+    StatefulFilter lds3ChainDefaultFilter2 = lds3Snapshot.get(5);
+    // STATEFUL_1 in default chain not the same STATEFUL_1 in chain A or B
+    assertThat(lds3ChainDefaultFilter1).isNotSameInstanceAs(lds1ChainAFilter1);
+    assertThat(lds3ChainDefaultFilter1).isNotSameInstanceAs(lds2ChainBFilter1);
+    // STATEFUL_2 in default chain not the same STATEFUL_1 in chain A
+    assertThat(lds3ChainDefaultFilter2).isNotSameInstanceAs(lds1ChainAFilter2);
+  }
+
+  /**
+   * Verifies a special case where an existing filter is has a different typeUrl in a subsequent
+   * LDS update.
+   *
+   * <p>Expectations:
+   *   1. The old filter instance must be shutdown.
+   *   2. A new filter instance must be created for the new filter with different typeUrl.
+   */
+  @Test
+  public void filterState_specialCase_sameNameDifferentTypeUrl() {
+    // Setup the server with filter containing StatefulFilter.Provider for two distict type URLs.
+    StatefulFilter.Provider statefulFilterProvider = new StatefulFilter.Provider();
+    String altTypeUrl = "type.googleapis.com/grpc.test.AltStatefulFilter";
+    StatefulFilter.Provider altStatefulFilterProvider = new StatefulFilter.Provider(altTypeUrl);
+    FilterRegistry filterRegistry = FilterRegistry.newRegistry()
+        .register(statefulFilterProvider, altStatefulFilterProvider, ROUTER_FILTER_PROVIDER);
+    SettableFuture<Server> serverStart = filterStateTestStartServer(filterRegistry);
+
+    // Test a normal chain and the default chain, as it's handled separately.
+    VirtualHost vhost = filterStateTestVhost();
+
+    // LDS 1.
+    ImmutableList<NamedFilterConfig> lds1Confgs = filterStateTestConfigs(STATEFUL_1, STATEFUL_2);
+    FilterChain lds1ChainA = createFilterChain("chain_a", createHcm(vhost, lds1Confgs));
+    FilterChain lds1ChainDefault = createFilterChain("chain_default", createHcm(vhost, lds1Confgs));
+    xdsClient.deliverLdsUpdate(lds1ChainA, lds1ChainDefault);
+    verifyServerStarted(serverStart);
+    ImmutableList<StatefulFilter> lds1Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("LDS 1: expected to create filter instances").that(lds1Snapshot).hasSize(4);
+    // Naming: lds<LDS#>Chain<name>Filter<name#>
+    StatefulFilter lds1ChainAFilter1 = lds1Snapshot.get(0);
+    StatefulFilter lds1ChainAFilter2 = lds1Snapshot.get(1);
+    StatefulFilter lds1ChainDefaultFilter1 = lds1Snapshot.get(2);
+    StatefulFilter lds1ChainDefaultFilter2 = lds1Snapshot.get(3);
+
+    // LDS 2: Filter STATEFUL_2 present, but with a different typeUrl: altTypeUrl.
+    ImmutableList<NamedFilterConfig> lds2Confgs = ImmutableList.of(
+        new NamedFilterConfig(STATEFUL_1, new StatefulFilter.Config(STATEFUL_1)),
+        new NamedFilterConfig(STATEFUL_2, new StatefulFilter.Config(STATEFUL_2, altTypeUrl)),
+        new NamedFilterConfig(ROUTER_FILTER_INSTANCE_NAME, RouterFilter.ROUTER_CONFIG)
+    );
+    FilterChain lds2ChainA = createFilterChain("chain_a", createHcm(vhost, lds2Confgs));
+    FilterChain lds2ChainDefault = createFilterChain("chain_default", createHcm(vhost, lds2Confgs));
+    xdsClient.deliverLdsUpdate(lds2ChainA, lds2ChainDefault);
+    ImmutableList<StatefulFilter> lds2Snapshot = statefulFilterProvider.getAllInstances();
+    ImmutableList<StatefulFilter> lds2SnapshotAlt = altStatefulFilterProvider.getAllInstances();
+    // Filter "STATEFUL_2" has different typeUrl, and should be treated as a new filter.
+    // No changes in the snapshot of normal stateful filters.
+    assertThat(lds2Snapshot).isEqualTo(lds1Snapshot);
+    // Two new filter instances is created by altStatefulFilterProvider for chainA and chainDefault.
+    assertWithMessage("LDS 2: expected new filter instances for type %s", altTypeUrl)
+        .that(lds2SnapshotAlt).hasSize(2);
+    StatefulFilter lds2ChainAFilter2Alt = lds2SnapshotAlt.get(0);
+    StatefulFilter lds2ChainADefault2Alt = lds2SnapshotAlt.get(1);
+    // Confirm two new distict instances of STATEFUL_2 were created.
+    assertThat(lds2ChainAFilter2Alt).isNotSameInstanceAs(lds1ChainAFilter2);
+    assertThat(lds2ChainADefault2Alt).isNotSameInstanceAs(lds1ChainDefaultFilter2);
+    assertThat(lds2ChainAFilter2Alt).isNotSameInstanceAs(lds2ChainADefault2Alt);
+    // Verify the instance of STATEFUL_2 of the old type are shutdown.
+    assertThat(lds1ChainAFilter2.isShutdown()).isTrue();
+    assertThat(lds1ChainDefaultFilter2.isShutdown()).isTrue();
+    // Verify the new instances of STATEFUL_2 and the old instances of STATEFUL_1 are running.
+    assertThat(lds2ChainAFilter2Alt.isShutdown()).isFalse();
+    assertThat(lds2ChainADefault2Alt.isShutdown()).isFalse();
+    assertThat(lds1ChainAFilter1.isShutdown()).isFalse();
+    assertThat(lds1ChainDefaultFilter1.isShutdown()).isFalse();
+  }
+
+  /**
+   * Verifies that all filter instances are shutdown (closed) on LDS resource not found.
+   */
+  @Test
+  public void filterState_shutdown_onLdsNotFound() {
+    StatefulFilter.Provider statefulFilterProvider = new StatefulFilter.Provider();
+    FilterRegistry filterRegistry = filterStateTestFilterRegistry(statefulFilterProvider);
+    SettableFuture<Server> serverStart = filterStateTestStartServer(filterRegistry);
+
+    // Test a normal chain and the default chain, as it's handled separately.
+    VirtualHost vhost = filterStateTestVhost();
+    FilterChain chainA = createFilterChain("chain_a",
+        createHcm(vhost, filterStateTestConfigs(STATEFUL_1)));
+    FilterChain chainDefault = createFilterChain("chain_default",
+        createHcm(vhost, filterStateTestConfigs(STATEFUL_2)));
+
+    // LDS 1.
+    xdsClient.deliverLdsUpdate(chainA, chainDefault);
+    verifyServerStarted(serverStart);
+    ImmutableList<StatefulFilter> lds1Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("LDS 1: expected to create filter instances").that(lds1Snapshot).hasSize(2);
+    // Naming: lds<LDS#>Chain<name>Filter<name#>
+    StatefulFilter lds1ChainAFilter1 = lds1Snapshot.get(0);
+    StatefulFilter lds1ChainDefaultFilter2 = lds1Snapshot.get(1);
+
+    // LDS 2: resource not found.
+    xdsClient.deliverLdsResourceNotFound();
+    // Verify shutdown.
+    assertThat(lds1ChainAFilter1.isShutdown()).isTrue();
+    assertThat(lds1ChainDefaultFilter2.isShutdown()).isTrue();
+  }
+
+  /**
+   * Verifies that all filter instances of a filter chain are shutdown when said chain is removed.
+   */
+  @Test
+  public void filterState_shutdown_onChainRemoved() {
+    StatefulFilter.Provider statefulFilterProvider = new StatefulFilter.Provider();
+    FilterRegistry filterRegistry = filterStateTestFilterRegistry(statefulFilterProvider);
+    SettableFuture<Server> serverStart = filterStateTestStartServer(filterRegistry);
+
+    ImmutableList<NamedFilterConfig> configs = filterStateTestConfigs(STATEFUL_1, STATEFUL_2);
+    FilterChain chainA = createFilterChain("chain_a",
+        createHcm(filterStateTestVhost("stateful_vhost_a"), configs),
+        createMatchSrcIp("3fff:a::/32"));
+    FilterChain chainB = createFilterChain("chain_b",
+        createHcm(filterStateTestVhost("stateful_vhost_b"), configs),
+        createMatchSrcIp("3fff:b::/32"));
+    FilterChain chainDefault = createFilterChain("chain_default",
+        createHcm(filterStateTestVhost("stateful_vhost_default"), configs),
+        createMatchSrcIp("3fff:defa::/32"));
+
+    // LDS 1.
+    xdsClient.deliverLdsUpdate(ImmutableList.of(chainA, chainB), chainDefault);
+    verifyServerStarted(serverStart);
+    ImmutableList<StatefulFilter> lds1Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("LDS 1: expected to create filter instances").that(lds1Snapshot).hasSize(6);
+    StatefulFilter chainAFilter1 = lds1Snapshot.get(0);
+    StatefulFilter chainAFilter2 = lds1Snapshot.get(1);
+    StatefulFilter chainBFilter1 = lds1Snapshot.get(2);
+    StatefulFilter chainBFilter2 = lds1Snapshot.get(3);
+    StatefulFilter chainDefaultFilter1 = lds1Snapshot.get(4);
+    StatefulFilter chainDefaultFilter2 = lds1Snapshot.get(5);
+
+    // LDS 2: ChainB and ChainDefault are gone.
+    xdsClient.deliverLdsUpdate(chainA, null);
+    assertThat(statefulFilterProvider.getAllInstances()).isEqualTo(lds1Snapshot);
+    // ChainA filters not shutdown (just in case).
+    assertThat(chainAFilter1.isShutdown()).isFalse();
+    assertThat(chainAFilter2.isShutdown()).isFalse();
+    // ChainB and ChainDefault filters shutdown.
+    assertWithMessage("chainBFilter1").that(chainBFilter1.isShutdown()).isTrue();
+    assertWithMessage("chainBFilter2").that(chainBFilter2.isShutdown()).isTrue();
+    assertWithMessage("chainDefaultFilter1").that(chainDefaultFilter1.isShutdown()).isTrue();
+    assertWithMessage("chainDefaultFilter2").that(chainDefaultFilter2.isShutdown()).isTrue();
+  }
+
+  /**
+   * Verifies that all filter instances are shutdown (closed) on LDS ResourceWatcher shutdown.
+   */
+  @Test
+  public void filterState_shutdown_onServerShutdown() {
+    StatefulFilter.Provider statefulFilterProvider = new StatefulFilter.Provider();
+    FilterRegistry filterRegistry = filterStateTestFilterRegistry(statefulFilterProvider);
+    SettableFuture<Server> serverStart = filterStateTestStartServer(filterRegistry);
+
+    // Test a normal chain and the default chain, as it's handled separately.
+    VirtualHost vhost = filterStateTestVhost();
+    FilterChain chainA = createFilterChain("chain_a",
+        createHcm(vhost, filterStateTestConfigs(STATEFUL_1)));
+    FilterChain chainDefault = createFilterChain("chain_default",
+        createHcm(vhost, filterStateTestConfigs(STATEFUL_2)));
+
+    // LDS 1.
+    xdsClient.deliverLdsUpdate(chainA, chainDefault);
+    verifyServerStarted(serverStart);
+    ImmutableList<StatefulFilter> lds1Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("LDS 1: expected to create filter instances").that(lds1Snapshot).hasSize(2);
+    // Naming: lds<LDS#>Chain<name>Filter<name#>
+    StatefulFilter lds1ChainAFilter1 = lds1Snapshot.get(0);
+    StatefulFilter lds1ChainDefaultFilter2 = lds1Snapshot.get(1);
+
+    // Shutdown.
+    xdsServerWrapper.shutdown();
+    assertThat(xdsServerWrapper.isShutdown()).isTrue();
+    assertThat(xdsClient.isShutDown()).isTrue();
+    // Verify shutdown.
+    assertThat(lds1ChainAFilter1.isShutdown()).isTrue();
+    assertThat(lds1ChainDefaultFilter2.isShutdown()).isTrue();
+  }
+
+  /**
+   * Verifies that filter instances are NOT shutdown on RDS_RESOURCE_NAME not found.
+   */
+  @Test
+  public void filterState_shutdown_noShutdownOnRdsNotFound() throws Exception {
+    StatefulFilter.Provider statefulFilterProvider = new StatefulFilter.Provider();
+    FilterRegistry filterRegistry = filterStateTestFilterRegistry(statefulFilterProvider);
+    SettableFuture<Server> serverStart = filterStateTestStartServer(filterRegistry);
+
+    String rdsName = "rds.example.com";
+    // Test a normal chain and the default chain, as it's handled separately.
+    FilterChain chainA = createFilterChain("chain_a",
+        createHcmForRds(rdsName, filterStateTestConfigs(STATEFUL_1)));
+    FilterChain chainDefault = createFilterChain("chain_default",
+        createHcmForRds(rdsName, filterStateTestConfigs(STATEFUL_2)));
+
+    xdsClient.deliverLdsUpdate(chainA, chainDefault);
+    xdsClient.awaitRds(FakeXdsClient.DEFAULT_TIMEOUT);
+    verify(listener, never()).onServing();
+    // Server didn't start, but filter instances should have already been created.
+    ImmutableList<StatefulFilter> lds1Snapshot = statefulFilterProvider.getAllInstances();
+    assertWithMessage("LDS 1: expected to create filter instances").that(lds1Snapshot).hasSize(2);
+    // Naming: lds<LDS#>Chain<name>Filter<name#>
+    StatefulFilter lds1ChainAFilter1 = lds1Snapshot.get(0);
+    StatefulFilter lds1ChainDefaultFilter2 = lds1Snapshot.get(1);
+
+    // RDS 1: Standard vhost with a route.
+    xdsClient.deliverRdsUpdate(rdsName, filterStateTestVhost());
+    verifyServerStarted(serverStart);
+    assertThat(statefulFilterProvider.getAllInstances()).isEqualTo(lds1Snapshot);
+
+    // RDS 2: RDS_RESOURCE_NAME not found.
+    xdsClient.deliverRdsResourceNotFound(rdsName);
+    assertThat(lds1ChainAFilter1.isShutdown()).isFalse();
+    assertThat(lds1ChainDefaultFilter2.isShutdown()).isFalse();
+  }
+
+  private FilterRegistry filterStateTestFilterRegistry(
+      StatefulFilter.Provider statefulFilterProvider) {
+    return FilterRegistry.newRegistry().register(statefulFilterProvider, ROUTER_FILTER_PROVIDER);
+  }
+
+  private SettableFuture<Server> filterStateTestStartServer(FilterRegistry filterRegistry) {
+    xdsServerWrapper = new XdsServerWrapper("0.0.0.0:1", mockBuilder, listener,
+        selectorManager, new FakeXdsClientPoolFactory(xdsClient),
+        XdsServerTestHelper.RAW_BOOTSTRAP, filterRegistry);
+    SettableFuture<Server> serverStart = SettableFuture.create();
+    scheduleServerStart(xdsServerWrapper, serverStart);
+    return serverStart;
+  }
+
+  private static ImmutableList<NamedFilterConfig> filterStateTestConfigs(String... names) {
+    ImmutableList.Builder<NamedFilterConfig> result = ImmutableList.builder();
+    for (String name : names) {
+      result.add(new NamedFilterConfig(name, new StatefulFilter.Config(name)));
+    }
+    result.add(new NamedFilterConfig(ROUTER_FILTER_INSTANCE_NAME, RouterFilter.ROUTER_CONFIG));
+    return result.build();
+  }
+
+  private static Route filterStateTestRoute(ImmutableMap<String, FilterConfig> perRouteOverrides) {
+    // Standard basic route for filterState tests.
+    return Route.forAction(
+        RouteMatch.withPathExactOnly("/grpc.test.HelloService/SayHello"), null, perRouteOverrides);
+  }
+
+  private static VirtualHost filterStateTestVhost() {
+    return filterStateTestVhost("stateful-vhost", NO_FILTER_OVERRIDES);
+  }
+
+  private static VirtualHost filterStateTestVhost(String name) {
+    return filterStateTestVhost(name, NO_FILTER_OVERRIDES);
+  }
+
+  private static VirtualHost filterStateTestVhost(
+      String name, ImmutableMap<String, FilterConfig> perRouteOverrides) {
+    return VirtualHost.create(
+        name,
+        ImmutableList.of("stateful.test.example.com"),
+        ImmutableList.of(filterStateTestRoute(perRouteOverrides)),
+        NO_FILTER_OVERRIDES);
+  }
+
+  // End filter state tests.
+
+  private void verifyServerStarted(SettableFuture<Server> serverStart) {
+    try {
+      serverStart.get(5, TimeUnit.SECONDS);
+    } catch (InterruptedException | ExecutionException | TimeoutException e) {
+      throw new AssertionError("serverStart future failed to resolve within the timeout", e);
+    }
+    verify(listener).onServing();
+    try {
+      verify(mockServer).start();
+    } catch (IOException e) {
+      throw new AssertionError("mockServer.start() shouldn't throw", e);
+    }
+  }
+
+  private Map<FilterChain, AtomicReference<ServerRoutingConfig>> getSelectorRoutingConfigs() {
+    return selectorManager.getSelectorToUpdateSelector().getRoutingConfigs();
+  }
+
+  private ServerRoutingConfig getSelectorRoutingConfig(FilterChain fc) {
+    return getSelectorRoutingConfigs().get(fc).get();
+  }
+
+  private ImmutableList<VirtualHost> getSelectorVhosts(FilterChain fc) {
+    return getSelectorRoutingConfig(fc).virtualHosts();
+  }
+
+  public static void scheduleServerStart(
+      XdsServerWrapper xdsServerWrapper, SettableFuture<Server> serverStart) {
+    Executors.newSingleThreadExecutor().execute(() -> {
+      try {
+        serverStart.set(xdsServerWrapper.start());
+      } catch (Exception e) {
+        serverStart.setException(e);
+      }
+    });
+  }
+
+  private static FilterChain createFilterChain(String name, HttpConnectionManager hcm) {
+    return createFilterChain(name, hcm, createMatch());
+  }
+
+  private static FilterChain createFilterChain(
+      String name, HttpConnectionManager hcm, FilterChainMatch filterChainMatch) {
+    TlsContextManager tlsContextManager = mock(TlsContextManager.class);
+    return FilterChain.create(name, filterChainMatch, hcm, createTls(), tlsContextManager);
+  }
+
+  private static VirtualHost createVirtualHost(String name) {
+    return VirtualHost.create(
+            name, Collections.singletonList("auth"), new ArrayList<Route>(),
+            ImmutableMap.<String, FilterConfig>of());
+  }
+
+  private static HttpConnectionManager createHcm(
+      VirtualHost vhost, List<NamedFilterConfig> filterConfigs) {
+    return HttpConnectionManager.forVirtualHosts(0L, ImmutableList.of(vhost), filterConfigs);
+  }
+
+  private static HttpConnectionManager createHcmForRds(
+      String name, List<NamedFilterConfig> filterConfigs) {
+    return HttpConnectionManager.forRdsName(0L, name, filterConfigs);
+  }
+
+  private static HttpConnectionManager createRds(String name) {
+    NamedFilterConfig config =
+        new NamedFilterConfig(ROUTER_FILTER_INSTANCE_NAME, RouterFilter.ROUTER_CONFIG);
+    return createHcmForRds(name, ImmutableList.of(config));
+  }
+
+  /**
+   * Returns the least-specific match-all Filter Chain Match.
+   */
+  static FilterChainMatch createMatch() {
+    return FilterChainMatch.create(
+        0,
+        ImmutableList.of(),
+        ImmutableList.of(),
+        ImmutableList.of(),
+        EnvoyServerProtoData.ConnectionSourceType.ANY,
+        ImmutableList.of(),
+        ImmutableList.of(),
+        "");
+  }
+
+  private static FilterChainMatch createMatchSrcIp(String srcCidr) {
+    String[] srcParts = srcCidr.split("/", 2);
+    InetAddress ip = InetAddresses.forString(srcParts[0]);
+    Integer subnetMask = Integer.valueOf(srcParts[1], 10);
+    return FilterChainMatch.create(
+        0,
+        ImmutableList.of(),
+        ImmutableList.of(),
+        ImmutableList.of(CidrRange.create(ip, subnetMask)),
+        EnvoyServerProtoData.ConnectionSourceType.ANY,
+        ImmutableList.of(),
+        ImmutableList.of(),
+        "");
+  }
+
+  private static ServerRoutingConfig createRoutingConfig(String path, String domain) {
+    return createRoutingConfig(path, domain, null);
+  }
+
+  private static ServerRoutingConfig createRoutingConfig(
+      String path, String domain, Route.RouteAction action) {
+    RouteMatch routeMatch =
+        RouteMatch.create(
+            PathMatcher.fromPath(path, true),
+            Collections.<HeaderMatcher>emptyList(), null);
+    VirtualHost virtualHost  = VirtualHost.create(
+        "v1", Collections.singletonList(domain),
+        Arrays.asList(Route.forAction(routeMatch, action,
+            ImmutableMap.<String, FilterConfig>of())),
+        Collections.<String, FilterConfig>emptyMap());
+    return ServerRoutingConfig.create(ImmutableList.<VirtualHost>of(virtualHost),
+        ImmutableMap.<Route, ServerInterceptor>of()
+    );
+  }
+
+  private static MethodDescriptor<Void, Void> createMethod(String path) {
+    return MethodDescriptor.<Void, Void>newBuilder()
+            .setType(MethodDescriptor.MethodType.UNKNOWN)
+            .setFullMethodName(path)
+            .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+            .setResponseMarshaller(TestMethodDescriptors.voidMarshaller())
+            .build();
+  }
+
+  static EnvoyServerProtoData.DownstreamTlsContext createTls() {
+    return CommonTlsContextTestsUtil.buildTestInternalDownstreamTlsContext("CERT1", "VA1");
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsTestControlPlaneService.java b/xds/src/test/java/io/grpc/xds/XdsTestControlPlaneService.java
new file mode 100644
index 00000000000..a54893c9075
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsTestControlPlaneService.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright 2021 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.xds;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Any;
+import com.google.protobuf.Message;
+import io.envoyproxy.envoy.service.discovery.v3.AggregatedDiscoveryServiceGrpc;
+import io.envoyproxy.envoy.service.discovery.v3.DiscoveryRequest;
+import io.envoyproxy.envoy.service.discovery.v3.DiscoveryResponse;
+import io.grpc.SynchronizationContext;
+import io.grpc.stub.StreamObserver;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+* A bidi-stream service that acts as a local xDS Control Plane.
+ * It accepts xDS config injection through a method call {@link #setXdsConfig}. Handling AdsStream
+ * response or updating xds config are run in syncContext.
+ *
+ * <p>The service maintains lookup tables:
+ * Subscriber table: map from each resource type, to a map from each client to subscribed resource
+ * names set.
+ * Resources table: store the resources in raw proto message.
+ *
+ * <p>xDS protocol requires version/nonce to avoid various race conditions. In this impl:
+ * Version stores the latest version number per each resource type. It is simply bumped up on each
+ * xds config set.
+ * Nonce stores the nonce number for each resource type and for each client. Incoming xDS requests
+ * share the same proto message type but may at different resources update phases:
+ * 1) Original: an initial xDS request.
+ * 2) NACK an xDS response.
+ * 3) ACK an xDS response.
+ * The service is capable of distinguish these cases when handling the request.
+ */
+final class XdsTestControlPlaneService extends
+    AggregatedDiscoveryServiceGrpc.AggregatedDiscoveryServiceImplBase {
+  private static final Logger logger = Logger.getLogger(XdsTestControlPlaneService.class.getName());
+
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+
+  static final String ADS_TYPE_URL_LDS =
+      "type.googleapis.com/envoy.config.listener.v3.Listener";
+  static final String ADS_TYPE_URL_RDS =
+      "type.googleapis.com/envoy.config.route.v3.RouteConfiguration";
+  static final String ADS_TYPE_URL_CDS =
+      "type.googleapis.com/envoy.config.cluster.v3.Cluster";
+  static final String ADS_TYPE_URL_EDS =
+      "type.googleapis.com/envoy.config.endpoint.v3.ClusterLoadAssignment";
+
+  private final Map<String, HashMap<String, Message>> xdsResources = new HashMap<>();
+  private ImmutableMap<String, Map<StreamObserver<DiscoveryResponse>, Set<String>>> subscribers
+      = ImmutableMap.of(
+      ADS_TYPE_URL_LDS, new ConcurrentHashMap<StreamObserver<DiscoveryResponse>, Set<String>>(),
+      ADS_TYPE_URL_RDS, new ConcurrentHashMap<StreamObserver<DiscoveryResponse>, Set<String>>(),
+      ADS_TYPE_URL_CDS, new ConcurrentHashMap<StreamObserver<DiscoveryResponse>, Set<String>>(),
+      ADS_TYPE_URL_EDS, new ConcurrentHashMap<StreamObserver<DiscoveryResponse>, Set<String>>());
+  private final ImmutableMap<String, AtomicInteger> xdsVersions = ImmutableMap.of(
+      ADS_TYPE_URL_LDS, new AtomicInteger(1),
+      ADS_TYPE_URL_RDS, new AtomicInteger(1),
+      ADS_TYPE_URL_CDS, new AtomicInteger(1),
+      ADS_TYPE_URL_EDS, new AtomicInteger(1)
+  );
+  private final ImmutableMap<String, Map<StreamObserver<DiscoveryResponse>, AtomicInteger>>
+      xdsNonces = ImmutableMap.of(
+      ADS_TYPE_URL_LDS, new ConcurrentHashMap<StreamObserver<DiscoveryResponse>, AtomicInteger>(),
+      ADS_TYPE_URL_RDS, new ConcurrentHashMap<StreamObserver<DiscoveryResponse>, AtomicInteger>(),
+      ADS_TYPE_URL_CDS, new ConcurrentHashMap<StreamObserver<DiscoveryResponse>, AtomicInteger>(),
+      ADS_TYPE_URL_EDS, new ConcurrentHashMap<StreamObserver<DiscoveryResponse>, AtomicInteger>()
+  );
+
+
+  // treat all the resource types as state-of-the-world, send back all resources of a particular
+  // type when any of them change.
+  public <T extends Message> void setXdsConfig(final String type, final Map<String, T> resources) {
+    logger.log(Level.FINE, "setting config {0} {1}", new Object[]{type, resources});
+    syncContext.execute(new Runnable() {
+      @Override
+      public void run() {
+        HashMap<String, Message> copyResources =  new HashMap<>(resources);
+        xdsResources.put(type, copyResources);
+        String newVersionInfo = String.valueOf(xdsVersions.get(type).getAndIncrement());
+
+        for (Map.Entry<StreamObserver<DiscoveryResponse>, Set<String>> entry :
+            subscribers.get(type).entrySet()) {
+          DiscoveryResponse response = generateResponse(type, newVersionInfo,
+              String.valueOf(xdsNonces.get(type).get(entry.getKey()).incrementAndGet()),
+              entry.getValue());
+          entry.getKey().onNext(response);
+        }
+      }
+    });
+  }
+
+  ImmutableMap<String, Message> getCurrentConfig(String type) {
+    HashMap<String, Message> hashMap = xdsResources.get(type);
+    return (hashMap != null) ? ImmutableMap.copyOf(hashMap) : ImmutableMap.of();
+  }
+
+  @Override
+  public StreamObserver<DiscoveryRequest> streamAggregatedResources(
+      final StreamObserver<DiscoveryResponse> responseObserver) {
+
+    final class AdsStreamObserver implements StreamObserver<DiscoveryRequest> {
+      @Override
+      public void onNext(final DiscoveryRequest value) {
+        syncContext.execute(new Runnable() {
+          @Override
+          public void run() {
+            logger.log(Level.FINEST, "control plane received request {0}", value);
+            if (value.hasErrorDetail()) {
+              logger.log(Level.FINE, "control plane received nack resource {0}, error {1}",
+                  new Object[]{value.getResourceNamesList(), value.getErrorDetail()});
+              return;
+            }
+
+            String resourceType = value.getTypeUrl();
+            if (!value.getResponseNonce().isEmpty() && xdsNonces.containsKey(resourceType)
+                && !String.valueOf(xdsNonces.get(resourceType).get(responseObserver))
+                .equals(value.getResponseNonce())) {
+              logger.log(Level.FINE, "Resource nonce does not match, ignore.");
+              return;
+            }
+
+            Set<String> requestedResourceNames = new HashSet<>(value.getResourceNamesList());
+            if (subscribers.get(resourceType).containsKey(responseObserver)
+                && subscribers.get(resourceType).get(responseObserver)
+                    .equals(requestedResourceNames)) {
+              logger.log(Level.FINEST, "control plane received ack for resource: {0}",
+                  value.getResourceNamesList());
+              return;
+            }
+
+            if (!xdsNonces.get(resourceType).containsKey(responseObserver)) {
+              xdsNonces.get(resourceType).put(responseObserver, new AtomicInteger(0));
+            }
+
+            DiscoveryResponse response = generateResponse(resourceType,
+                String.valueOf(xdsVersions.get(resourceType)),
+                String.valueOf(xdsNonces.get(resourceType).get(responseObserver).addAndGet(1)),
+                requestedResourceNames);
+            responseObserver.onNext(response);
+            subscribers.get(resourceType).put(responseObserver, requestedResourceNames);
+          }
+        });
+      }
+
+      @Override
+      public void onError(Throwable t) {
+        logger.log(Level.FINE, "Control plane error: {0} ", t);
+        onCompleted();
+      }
+
+      @Override
+      public void onCompleted() {
+        responseObserver.onCompleted();
+        for (String type : subscribers.keySet()) {
+          subscribers.get(type).remove(responseObserver);
+          xdsNonces.get(type).remove(responseObserver);
+        }
+      }
+    }
+
+    return new AdsStreamObserver();
+  }
+
+  //must run in syncContext
+  private DiscoveryResponse generateResponse(String resourceType, String version, String nonce,
+                                             Set<String> resourceNames) {
+    DiscoveryResponse.Builder responseBuilder = DiscoveryResponse.newBuilder()
+        .setTypeUrl(resourceType)
+        .setVersionInfo(version)
+        .setNonce(nonce);
+    for (String resourceName: resourceNames) {
+      if (xdsResources.containsKey(resourceType)
+          && xdsResources.get(resourceType).containsKey(resourceName)) {
+        responseBuilder.addResources(Any.pack(xdsResources.get(resourceType).get(resourceName),
+            resourceType));
+      }
+    }
+    return responseBuilder.build();
+  }
+
+  public Map<String, Integer> getSubscriberCounts() {
+    Map<String, Integer> subscriberCounts = new HashMap<>();
+    for (String type : subscribers.keySet()) {
+      subscriberCounts.put(type, subscribers.get(type).size());
+    }
+    return subscriberCounts;
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsTestLoadReportingService.java b/xds/src/test/java/io/grpc/xds/XdsTestLoadReportingService.java
new file mode 100644
index 00000000000..5045855cf9e
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsTestLoadReportingService.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2023 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.xds;
+
+import io.envoyproxy.envoy.service.load_stats.v3.LoadReportingServiceGrpc;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse;
+import io.grpc.stub.StreamObserver;
+
+/**
+ * This dummy implementation is just used to allow tests that utilize load reporting to successfully
+ * connect to a test control plane server. It can be later expanded to e.g. store the requests it
+ * receives for tests to verify.
+ */
+final class XdsTestLoadReportingService extends
+    LoadReportingServiceGrpc.LoadReportingServiceImplBase {
+
+  @Override
+  public StreamObserver<LoadStatsRequest> streamLoadStats(
+      StreamObserver<LoadStatsResponse> responseObserver) {
+    return new StreamObserver<LoadStatsRequest>() {
+      @Override
+      public void onNext(LoadStatsRequest request) {
+        responseObserver.onNext(LoadStatsResponse.newBuilder().build());
+      }
+
+      @Override
+      public void onError(Throwable t) {
+        responseObserver.onError(t);
+      }
+
+      @Override
+      public void onCompleted() {
+        responseObserver.onCompleted();
+      }
+    };
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/XdsTestUtils.java b/xds/src/test/java/io/grpc/xds/XdsTestUtils.java
new file mode 100644
index 00000000000..f81957ee311
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/XdsTestUtils.java
@@ -0,0 +1,437 @@
+/*
+ * Copyright 2024 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.xds;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_CDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_EDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_LDS;
+import static io.grpc.xds.XdsTestControlPlaneService.ADS_TYPE_URL_RDS;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+
+import com.google.common.base.Splitter;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.Any;
+import com.google.protobuf.Message;
+import com.google.protobuf.util.Durations;
+import io.envoyproxy.envoy.config.cluster.v3.Cluster;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterLoadAssignment;
+import io.envoyproxy.envoy.config.endpoint.v3.ClusterStats;
+import io.envoyproxy.envoy.config.listener.v3.ApiListener;
+import io.envoyproxy.envoy.config.listener.v3.Listener;
+import io.envoyproxy.envoy.config.route.v3.RouteConfiguration;
+import io.envoyproxy.envoy.extensions.clusters.aggregate.v3.ClusterConfig;
+import io.envoyproxy.envoy.extensions.filters.http.router.v3.Router;
+import io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3.HttpFilter;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadReportingServiceGrpc;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadStatsRequest;
+import io.envoyproxy.envoy.service.load_stats.v3.LoadStatsResponse;
+import io.grpc.BindableService;
+import io.grpc.Context;
+import io.grpc.Context.CancellationListener;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.StatusOr;
+import io.grpc.internal.ExponentialBackoffPolicy;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.JsonParser;
+import io.grpc.stub.StreamObserver;
+import io.grpc.xds.Endpoints.LbEndpoint;
+import io.grpc.xds.Endpoints.LocalityLbEndpoints;
+import io.grpc.xds.XdsConfig.XdsClusterConfig.EndpointConfig;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.CommonBootstrapperTestUtils;
+import io.grpc.xds.client.Locality;
+import io.grpc.xds.client.XdsClient;
+import io.grpc.xds.client.XdsClientMetricReporter;
+import io.grpc.xds.client.XdsResourceType;
+import io.grpc.xds.client.XdsTransportFactory;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.mockito.ArgumentMatcher;
+import org.mockito.InOrder;
+
+public class XdsTestUtils {
+  private static final Logger log = Logger.getLogger(XdsTestUtils.class.getName());
+  static final String RDS_NAME = "route-config.googleapis.com";
+  static final String CLUSTER_NAME = "cluster0";
+  static final String EDS_NAME = "eds-service-0";
+  static final String SERVER_LISTENER = "grpc/server?udpa.resource.listening_address=";
+  static final String HTTP_CONNECTION_MANAGER_TYPE_URL =
+      "type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3"
+          + ".HttpConnectionManager";
+  static final Bootstrapper.ServerInfo EMPTY_BOOTSTRAPPER_SERVER_INFO =
+      Bootstrapper.ServerInfo.create(
+      "td.googleapis.com", InsecureChannelCredentials.create(), false, true, false, false);
+  public static final String ENDPOINT_HOSTNAME = "data-host";
+  public static final int ENDPOINT_PORT = 1234;
+
+  static BindableService createLrsService(AtomicBoolean lrsEnded,
+                                          Queue<LrsRpcCall> loadReportCalls) {
+    return new LoadReportingServiceGrpc.LoadReportingServiceImplBase() {
+      @Override
+      public StreamObserver<LoadStatsRequest> streamLoadStats(
+          StreamObserver<LoadStatsResponse> responseObserver) {
+        assertThat(lrsEnded.get()).isTrue();
+        lrsEnded.set(false);
+        @SuppressWarnings("unchecked")
+        StreamObserver<LoadStatsRequest> requestObserver = mock(StreamObserver.class);
+        LrsRpcCall call = new LrsRpcCall(requestObserver, responseObserver);
+        Context.current().addListener(
+            new CancellationListener() {
+              @Override
+              public void cancelled(Context context) {
+                lrsEnded.set(true);
+              }
+            }, MoreExecutors.directExecutor());
+        loadReportCalls.offer(call);
+        return requestObserver;
+      }
+    };
+  }
+
+  static boolean matchErrorDetail(
+      com.google.rpc.Status errorDetail, int expectedCode, List<String> expectedMessages) {
+    if (expectedCode != errorDetail.getCode()) {
+      return false;
+    }
+    List<String> errors = Splitter.on('\n').splitToList(errorDetail.getMessage());
+    if (errors.size() != expectedMessages.size()) {
+      return false;
+    }
+    for (int i = 0; i < errors.size(); i++) {
+      if (!errors.get(i).startsWith(expectedMessages.get(i))) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  static void setAdsConfig(XdsTestControlPlaneService service, String serverName) {
+    setAdsConfig(service, serverName, RDS_NAME, CLUSTER_NAME, EDS_NAME, ENDPOINT_HOSTNAME,
+        ENDPOINT_PORT);
+  }
+
+  static void setAdsConfig(XdsTestControlPlaneService service, String serverName, String rdsName,
+                           String clusterName, String edsName, String endpointHostname,
+                           int endpointPort) {
+
+    Listener serverListener = ControlPlaneRule.buildServerListener();
+    Listener clientListener = ControlPlaneRule.buildClientListener(serverName, rdsName);
+    service.setXdsConfig(ADS_TYPE_URL_LDS,
+        ImmutableMap.of(SERVER_LISTENER, serverListener, serverName, clientListener));
+
+    RouteConfiguration routeConfig =
+        buildRouteConfiguration(serverName, rdsName, clusterName);
+    service.setXdsConfig(ADS_TYPE_URL_RDS, ImmutableMap.of(rdsName, routeConfig));;
+
+    Cluster cluster = ControlPlaneRule.buildCluster(clusterName, edsName);
+    service.setXdsConfig(ADS_TYPE_URL_CDS, ImmutableMap.<String, Message>of(clusterName, cluster));
+
+    ClusterLoadAssignment clusterLoadAssignment = ControlPlaneRule.buildClusterLoadAssignment(
+        "127.0.0.11", endpointHostname, endpointPort, edsName);
+    service.setXdsConfig(ADS_TYPE_URL_EDS,
+        ImmutableMap.<String, Message>of(edsName, clusterLoadAssignment));
+
+    log.log(Level.FINE, String.format("Set ADS config for %s with address %s:%d",
+        serverName, endpointHostname, endpointPort));
+
+  }
+
+  static String getEdsNameForCluster(String clusterName) {
+    return "eds_" + clusterName;
+  }
+
+  static void setAggregateCdsConfig(XdsTestControlPlaneService service, String serverName,
+                                    String clusterName, List<String> children) {
+    Map<String, Message> clusterMap = new HashMap<>();
+
+    ClusterConfig rootConfig = ClusterConfig.newBuilder().addAllClusters(children).build();
+    Cluster.CustomClusterType type =
+        Cluster.CustomClusterType.newBuilder()
+            .setName(XdsClusterResource.AGGREGATE_CLUSTER_TYPE_NAME)
+            .setTypedConfig(Any.pack(rootConfig))
+            .build();
+    Cluster.Builder builder = Cluster.newBuilder().setName(clusterName).setClusterType(type);
+    builder.setLbPolicy(Cluster.LbPolicy.ROUND_ROBIN);
+    Cluster cluster = builder.build();
+    clusterMap.put(clusterName, cluster);
+
+    for (String child : children) {
+      Cluster childCluster = ControlPlaneRule.buildCluster(child, getEdsNameForCluster(child));
+      clusterMap.put(child, childCluster);
+    }
+
+    service.setXdsConfig(ADS_TYPE_URL_CDS, clusterMap);
+
+    Map<String, Message> edsMap = new HashMap<>();
+    for (String child : children) {
+      ClusterLoadAssignment clusterLoadAssignment = ControlPlaneRule.buildClusterLoadAssignment(
+          "127.0.0.16", ENDPOINT_HOSTNAME, ENDPOINT_PORT, getEdsNameForCluster(child));
+      edsMap.put(getEdsNameForCluster(child), clusterLoadAssignment);
+    }
+    service.setXdsConfig(ADS_TYPE_URL_EDS, edsMap);
+  }
+
+  static void addAggregateToExistingConfig(XdsTestControlPlaneService service, String rootName,
+                                           List<String> children) {
+    Map<String, Message> clusterMap = new HashMap<>(service.getCurrentConfig(ADS_TYPE_URL_CDS));
+    if (clusterMap.containsKey(rootName)) {
+      throw new IllegalArgumentException("Root cluster " + rootName + " already exists");
+    }
+    ClusterConfig rootConfig = ClusterConfig.newBuilder().addAllClusters(children).build();
+    Cluster.CustomClusterType type =
+        Cluster.CustomClusterType.newBuilder()
+            .setName(XdsClusterResource.AGGREGATE_CLUSTER_TYPE_NAME)
+            .setTypedConfig(Any.pack(rootConfig))
+            .build();
+    Cluster.Builder builder = Cluster.newBuilder().setName(rootName).setClusterType(type);
+    builder.setLbPolicy(Cluster.LbPolicy.ROUND_ROBIN);
+    Cluster cluster = builder.build();
+    clusterMap.put(rootName, cluster);
+
+    for (String child : children) {
+      if (clusterMap.containsKey(child)) {
+        continue;
+      }
+      Cluster childCluster = ControlPlaneRule.buildCluster(child, getEdsNameForCluster(child));
+      clusterMap.put(child, childCluster);
+    }
+
+    service.setXdsConfig(ADS_TYPE_URL_CDS, clusterMap);
+
+    Map<String, Message> edsMap = new HashMap<>(service.getCurrentConfig(ADS_TYPE_URL_EDS));
+    for (String child : children) {
+      if (edsMap.containsKey(getEdsNameForCluster(child))) {
+        continue;
+      }
+      ClusterLoadAssignment clusterLoadAssignment = ControlPlaneRule.buildClusterLoadAssignment(
+          "127.0.0.15", ENDPOINT_HOSTNAME, ENDPOINT_PORT, getEdsNameForCluster(child));
+      edsMap.put(getEdsNameForCluster(child), clusterLoadAssignment);
+    }
+    service.setXdsConfig(ADS_TYPE_URL_EDS, edsMap);
+  }
+
+  static XdsConfig getDefaultXdsConfig(String serverHostName)
+      throws XdsResourceType.ResourceInvalidException, IOException {
+    XdsConfig.XdsConfigBuilder builder = new XdsConfig.XdsConfigBuilder();
+
+    Filter.NamedFilterConfig routerFilterConfig = new Filter.NamedFilterConfig(
+        "terminal-filter", RouterFilter.ROUTER_CONFIG);
+
+    HttpConnectionManager httpConnectionManager = HttpConnectionManager.forRdsName(
+        0L, RDS_NAME, Collections.singletonList(routerFilterConfig));
+    XdsListenerResource.LdsUpdate ldsUpdate =
+        XdsListenerResource.LdsUpdate.forApiListener(httpConnectionManager);
+
+    RouteConfiguration routeConfiguration =
+        buildRouteConfiguration(serverHostName, RDS_NAME, CLUSTER_NAME);
+    XdsResourceType.Args args = new XdsResourceType.Args(
+        EMPTY_BOOTSTRAPPER_SERVER_INFO, "0", "0", null, null, null);
+    XdsRouteConfigureResource.RdsUpdate rdsUpdate =
+        XdsRouteConfigureResource.getInstance().doParse(args, routeConfiguration);
+
+    // Take advantage of knowing that there is only 1 virtual host in the route configuration
+    assertThat(rdsUpdate.virtualHosts).hasSize(1);
+    VirtualHost virtualHost = rdsUpdate.virtualHosts.get(0);
+
+    // Need to create endpoints to create locality endpoints map to create edsUpdate
+    Map<Locality, LocalityLbEndpoints> lbEndpointsMap = new HashMap<>();
+    LbEndpoint lbEndpoint = LbEndpoint.create(
+        "127.0.0.11", ENDPOINT_PORT, 0, true, ENDPOINT_HOSTNAME, ImmutableMap.of());
+    lbEndpointsMap.put(
+        Locality.create("", "", ""),
+        LocalityLbEndpoints.create(ImmutableList.of(lbEndpoint), 10, 0, ImmutableMap.of()));
+
+    // Need to create EdsUpdate to create CdsUpdate to create XdsClusterConfig for builder
+    XdsEndpointResource.EdsUpdate edsUpdate = new XdsEndpointResource.EdsUpdate(
+        EDS_NAME, lbEndpointsMap, Collections.emptyList());
+    XdsClusterResource.CdsUpdate cdsUpdate = XdsClusterResource.CdsUpdate.forEds(
+        CLUSTER_NAME, EDS_NAME, null, null, null, null, false, null)
+        .lbPolicyConfig(getWrrLbConfigAsMap()).build();
+    XdsConfig.XdsClusterConfig clusterConfig = new XdsConfig.XdsClusterConfig(
+        CLUSTER_NAME, cdsUpdate, new EndpointConfig(StatusOr.fromValue(edsUpdate)));
+
+    builder
+        .setListener(ldsUpdate)
+        .setRoute(rdsUpdate)
+        .setVirtualHost(virtualHost)
+        .addCluster(CLUSTER_NAME, StatusOr.fromValue(clusterConfig));
+
+    return builder.build();
+  }
+
+  static Map<Locality, LocalityLbEndpoints> createMinimalLbEndpointsMap(String serverAddress) {
+    Map<Locality, LocalityLbEndpoints> lbEndpointsMap = new HashMap<>();
+    LbEndpoint lbEndpoint = LbEndpoint.create(
+        serverAddress, ENDPOINT_PORT, 0, true, ENDPOINT_HOSTNAME, ImmutableMap.of());
+    lbEndpointsMap.put(
+        Locality.create("", "", ""),
+        LocalityLbEndpoints.create(ImmutableList.of(lbEndpoint), 10, 0, ImmutableMap.of()));
+    return lbEndpointsMap;
+  }
+
+  @SuppressWarnings("unchecked")
+  static ImmutableMap<String, ?> getWrrLbConfigAsMap() throws IOException {
+    String lbConfigStr = "{\"wrr_locality_experimental\" : "
+        + "{ \"childPolicy\" : [{\"round_robin\" : {}}]}}";
+
+    return ImmutableMap.copyOf((Map<String, ?>) JsonParser.parse(lbConfigStr));
+  }
+
+  static RouteConfiguration buildRouteConfiguration(String authority, String rdsName,
+                                                    String clusterName) {
+    return ControlPlaneRule.buildRouteConfiguration(authority, rdsName, clusterName);
+  }
+
+  static Cluster buildAggCluster(String name, List<String> childNames) {
+    ClusterConfig rootConfig = ClusterConfig.newBuilder().addAllClusters(childNames).build();
+    Cluster.CustomClusterType type =
+        Cluster.CustomClusterType.newBuilder()
+            .setName(XdsClusterResource.AGGREGATE_CLUSTER_TYPE_NAME)
+            .setTypedConfig(Any.pack(rootConfig))
+            .build();
+    Cluster.Builder builder =
+        Cluster.newBuilder().setName(name).setClusterType(type);
+    builder.setLbPolicy(Cluster.LbPolicy.ROUND_ROBIN);
+    Cluster cluster = builder.build();
+    return cluster;
+  }
+
+  static void addEdsClusters(Map<String, Message> clusterMap, Map<String, Message> edsMap,
+                             String... clusterNames) {
+    for (String clusterName : clusterNames) {
+      String edsName = getEdsNameForCluster(clusterName);
+      Cluster cluster = ControlPlaneRule.buildCluster(clusterName, edsName);
+      clusterMap.put(clusterName, cluster);
+
+      ClusterLoadAssignment clusterLoadAssignment = ControlPlaneRule.buildClusterLoadAssignment(
+          "127.0.0.13", ENDPOINT_HOSTNAME, ENDPOINT_PORT, edsName);
+      edsMap.put(edsName, clusterLoadAssignment);
+    }
+  }
+
+  static Listener buildInlineClientListener(String rdsName, String clusterName, String serverName) {
+    HttpFilter
+        httpFilter = HttpFilter.newBuilder()
+        .setName("terminal-filter")
+        .setTypedConfig(Any.pack(Router.newBuilder().build()))
+        .setIsOptional(true)
+        .build();
+    ApiListener.Builder clientListenerBuilder =
+        ApiListener.newBuilder().setApiListener(Any.pack(
+            io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3
+                .HttpConnectionManager.newBuilder()
+                .setRouteConfig(
+                    buildRouteConfiguration(serverName, rdsName, clusterName))
+                .addAllHttpFilters(Collections.singletonList(httpFilter))
+                .build(),
+            HTTP_CONNECTION_MANAGER_TYPE_URL));
+    return Listener.newBuilder()
+        .setName(serverName)
+        .setApiListener(clientListenerBuilder.build()).build();
+  }
+
+  public static XdsClient createXdsClient(
+      List<String> serverUris,
+      XdsTransportFactory xdsTransportFactory,
+      FakeClock fakeClock) {
+    return createXdsClient(
+        CommonBootstrapperTestUtils.buildBootStrap(serverUris),
+        xdsTransportFactory,
+        fakeClock,
+        new XdsClientMetricReporter() {});
+  }
+
+  /** Calls {@link CommonBootstrapperTestUtils#createXdsClient} with gRPC-specific values. */
+  public static XdsClient createXdsClient(
+      Bootstrapper.BootstrapInfo bootstrapInfo,
+      XdsTransportFactory xdsTransportFactory,
+      FakeClock fakeClock,
+      XdsClientMetricReporter xdsClientMetricReporter) {
+    return CommonBootstrapperTestUtils.createXdsClient(
+          bootstrapInfo,
+          xdsTransportFactory,
+          fakeClock,
+          new ExponentialBackoffPolicy.Provider(),
+          MessagePrinter.INSTANCE,
+          xdsClientMetricReporter);
+  }
+
+  /**
+   * Matches a {@link LoadStatsRequest} containing a collection of {@link ClusterStats} with
+   * the same list of clusterName:clusterServiceName pair.
+   */
+  static class LrsRequestMatcher implements ArgumentMatcher<LoadStatsRequest> {
+    private final List<String> expected;
+
+    private LrsRequestMatcher(List<String[]> clusterNames) {
+      expected = new ArrayList<>();
+      for (String[] pair : clusterNames) {
+        expected.add(pair[0] + ":" + (pair[1] == null ? "" : pair[1]));
+      }
+      Collections.sort(expected);
+    }
+
+    @Override
+    public boolean matches(LoadStatsRequest argument) {
+      List<String> actual = new ArrayList<>();
+      for (ClusterStats clusterStats : argument.getClusterStatsList()) {
+        actual.add(clusterStats.getClusterName() + ":" + clusterStats.getClusterServiceName());
+      }
+      Collections.sort(actual);
+      return actual.equals(expected);
+    }
+  }
+
+  static class LrsRpcCall  {
+    private final StreamObserver<LoadStatsRequest> requestObserver;
+    private final StreamObserver<LoadStatsResponse> responseObserver;
+    private final InOrder inOrder;
+
+    private LrsRpcCall(StreamObserver<LoadStatsRequest> requestObserver,
+                         StreamObserver<LoadStatsResponse> responseObserver) {
+      this.requestObserver = requestObserver;
+      this.responseObserver = responseObserver;
+      inOrder = inOrder(requestObserver);
+    }
+
+    protected void verifyNextReportClusters(List<String[]> clusters) {
+      inOrder.verify(requestObserver).onNext(argThat(new LrsRequestMatcher(clusters)));
+    }
+
+    protected void sendResponse(List<String> clusters, long loadReportIntervalNano) {
+      LoadStatsResponse response =
+          LoadStatsResponse.newBuilder()
+              .addAllClusters(clusters)
+              .setLoadReportingInterval(Durations.fromNanos(loadReportIntervalNano))
+              .build();
+      responseObserver.onNext(response);
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/client/BackendMetricPropagationTest.java b/xds/src/test/java/io/grpc/xds/client/BackendMetricPropagationTest.java
new file mode 100644
index 00000000000..31ad6f9c47f
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/client/BackendMetricPropagationTest.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright 2025 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.xds.client;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.util.Arrays.asList;
+
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link BackendMetricPropagation}.
+ */
+@RunWith(JUnit4.class)
+public class BackendMetricPropagationTest {
+
+  @Test
+  public void fromMetricSpecs_nullInput() {
+    BackendMetricPropagation config = BackendMetricPropagation.fromMetricSpecs(null);
+
+    assertThat(config.propagateCpuUtilization).isFalse();
+    assertThat(config.propagateMemUtilization).isFalse();
+    assertThat(config.propagateApplicationUtilization).isFalse();
+    assertThat(config.shouldPropagateNamedMetric("any")).isFalse();
+  }
+
+  @Test
+  public void fromMetricSpecs_emptyInput() {
+    BackendMetricPropagation config = BackendMetricPropagation.fromMetricSpecs(ImmutableList.of());
+
+    assertThat(config.propagateCpuUtilization).isFalse();
+    assertThat(config.propagateMemUtilization).isFalse();
+    assertThat(config.propagateApplicationUtilization).isFalse();
+    assertThat(config.shouldPropagateNamedMetric("any")).isFalse();
+  }
+
+  @Test
+  public void fromMetricSpecs_partialStandardMetrics() {
+    BackendMetricPropagation config = BackendMetricPropagation.fromMetricSpecs(
+        ImmutableList.of("cpu_utilization", "mem_utilization"));
+
+    assertThat(config.propagateCpuUtilization).isTrue();
+    assertThat(config.propagateMemUtilization).isTrue();
+    assertThat(config.propagateApplicationUtilization).isFalse();
+    assertThat(config.shouldPropagateNamedMetric("any")).isFalse();
+  }
+
+  @Test
+  public void fromMetricSpecs_allStandardMetrics() {
+    BackendMetricPropagation config = BackendMetricPropagation.fromMetricSpecs(
+        ImmutableList.of("cpu_utilization", "mem_utilization", "application_utilization"));
+
+    assertThat(config.propagateCpuUtilization).isTrue();
+    assertThat(config.propagateMemUtilization).isTrue();
+    assertThat(config.propagateApplicationUtilization).isTrue();
+    assertThat(config.shouldPropagateNamedMetric("any")).isFalse();
+  }
+
+  @Test
+  public void fromMetricSpecs_wildcardNamedMetrics() {
+    BackendMetricPropagation config = BackendMetricPropagation.fromMetricSpecs(
+        ImmutableList.of("named_metrics.*"));
+
+    assertThat(config.propagateCpuUtilization).isFalse();
+    assertThat(config.propagateMemUtilization).isFalse();
+    assertThat(config.propagateApplicationUtilization).isFalse();
+    assertThat(config.shouldPropagateNamedMetric("any_key")).isTrue();
+    assertThat(config.shouldPropagateNamedMetric("another_key")).isTrue();
+  }
+
+  @Test
+  public void fromMetricSpecs_specificNamedMetrics() {
+    BackendMetricPropagation config = BackendMetricPropagation.fromMetricSpecs(
+        ImmutableList.of("named_metrics.foo", "named_metrics.bar"));
+
+    assertThat(config.shouldPropagateNamedMetric("foo")).isTrue();
+    assertThat(config.shouldPropagateNamedMetric("bar")).isTrue();
+    assertThat(config.shouldPropagateNamedMetric("baz")).isFalse();
+    assertThat(config.shouldPropagateNamedMetric("any")).isFalse();
+  }
+
+  @Test
+  public void fromMetricSpecs_mixedStandardAndNamed() {
+    BackendMetricPropagation config = BackendMetricPropagation.fromMetricSpecs(
+        ImmutableList.of("cpu_utilization", "named_metrics.foo", "named_metrics.bar"));
+
+    assertThat(config.propagateCpuUtilization).isTrue();
+    assertThat(config.propagateMemUtilization).isFalse();
+    assertThat(config.shouldPropagateNamedMetric("foo")).isTrue();
+    assertThat(config.shouldPropagateNamedMetric("bar")).isTrue();
+    assertThat(config.shouldPropagateNamedMetric("baz")).isFalse();
+  }
+
+  @Test
+  public void fromMetricSpecs_wildcardAndSpecificNamedMetrics() {
+    BackendMetricPropagation config = BackendMetricPropagation.fromMetricSpecs(
+        ImmutableList.of("named_metrics.foo", "named_metrics.*"));
+
+    assertThat(config.shouldPropagateNamedMetric("foo")).isTrue();
+    assertThat(config.shouldPropagateNamedMetric("bar")).isTrue();
+    assertThat(config.shouldPropagateNamedMetric("any_other_key")).isTrue();
+  }
+
+  @Test
+  public void fromMetricSpecs_malformedAndUnknownSpecs_areIgnored() {
+    BackendMetricPropagation config = BackendMetricPropagation.fromMetricSpecs(
+        asList(
+            "cpu_utilization",
+            null,                   // ignored
+            "disk_utilization",
+            "named_metrics.",       // empty key
+            "named_metrics.valid"
+        ));
+
+    assertThat(config.propagateCpuUtilization).isTrue();
+    assertThat(config.propagateMemUtilization).isFalse();
+    assertThat(config.shouldPropagateNamedMetric("disk_utilization")).isFalse();
+    assertThat(config.shouldPropagateNamedMetric("valid")).isTrue();
+    assertThat(config.shouldPropagateNamedMetric("")).isFalse(); // from the empty key
+  }
+
+  @Test
+  public void fromMetricSpecs_duplicateSpecs_areHandledGracefully() {
+    BackendMetricPropagation config = BackendMetricPropagation.fromMetricSpecs(
+        ImmutableList.of(
+            "cpu_utilization",
+            "named_metrics.foo",
+            "cpu_utilization",
+            "named_metrics.foo"));
+
+    assertThat(config.propagateCpuUtilization).isTrue();
+    assertThat(config.shouldPropagateNamedMetric("foo")).isTrue();
+    assertThat(config.shouldPropagateNamedMetric("bar")).isFalse();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/client/CommonBootstrapperTestUtils.java b/xds/src/test/java/io/grpc/xds/client/CommonBootstrapperTestUtils.java
new file mode 100644
index 00000000000..e3760bd983f
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/client/CommonBootstrapperTestUtils.java
@@ -0,0 +1,229 @@
+/*
+ * 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.xds.client;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.grpc.ChannelCredentials;
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.JsonParser;
+import io.grpc.xds.client.Bootstrapper.ServerInfo;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil;
+import io.grpc.xds.internal.security.TlsContextManagerImpl;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
+
+public class CommonBootstrapperTestUtils {
+  public static final String SERVER_URI = "trafficdirector.googleapis.com";
+  private static final ChannelCredentials CHANNEL_CREDENTIALS = InsecureChannelCredentials.create();
+  private static final String SERVER_URI_CUSTOM_AUTHORITY = "trafficdirector2.googleapis.com";
+  private static final String SERVER_URI_EMPTY_AUTHORITY = "trafficdirector3.googleapis.com";
+  public static final String LDS_RESOURCE = "listener.googleapis.com";
+  public static final String RDS_RESOURCE = "route-configuration.googleapis.com";
+  public static final String CDS_RESOURCE = "cluster.googleapis.com";
+  public static final String EDS_RESOURCE = "cluster-load-assignment.googleapis.com";
+
+  private static final String FILE_WATCHER_CONFIG = "{\"path\": \"/etc/secret/certs\"}";
+  private static final String MESHCA_CONFIG =
+      "{\n"
+          + "        \"server\": {\n"
+          + "          \"api_type\": \"GRPC\",\n"
+          + "          \"grpc_services\": [{\n"
+          + "            \"google_grpc\": {\n"
+          + "              \"target_uri\": \"meshca.com\",\n"
+          + "              \"channel_credentials\": {\"google_default\": {}},\n"
+          + "              \"call_credentials\": [{\n"
+          + "                \"sts_service\": {\n"
+          + "                  \"token_exchange_service\": \"securetoken.googleapis.com\",\n"
+          + "                  \"subject_token_path\": \"/etc/secret/sajwt.token\"\n"
+          + "                }\n"
+          + "              }]\n" // end call_credentials
+          + "            },\n" // end google_grpc
+          + "            \"time_out\": {\"seconds\": 10}\n"
+          + "          }]\n" // end grpc_services
+          + "        },\n" // end server
+          + "        \"certificate_lifetime\": {\"seconds\": 86400},\n"
+          + "        \"renewal_grace_period\": {\"seconds\": 3600},\n"
+          + "        \"key_type\": \"RSA\",\n"
+          + "        \"key_size\": 2048,\n"
+          + "        \"location\": \"https://container.googleapis.com/v1/project/test-project1/locations/test-zone2/clusters/test-cluster3\"\n"
+          + "      }";
+
+  /** Creates a test bootstrap info object. */
+  @SuppressWarnings("unchecked")
+  public static Bootstrapper.BootstrapInfo getTestBootstrapInfo() {
+    try {
+      Bootstrapper.CertificateProviderInfo gcpId =
+          Bootstrapper.CertificateProviderInfo.create(
+              "testca", (Map<String, ?>) JsonParser.parse(MESHCA_CONFIG));
+      Bootstrapper.CertificateProviderInfo fileProvider =
+          Bootstrapper.CertificateProviderInfo.create(
+              "file_watcher", (Map<String, ?>) JsonParser.parse(FILE_WATCHER_CONFIG));
+      Map<String, Bootstrapper.CertificateProviderInfo> certProviders =
+          ImmutableMap.of("gcp_id", gcpId, "file_provider", fileProvider);
+      Bootstrapper.BootstrapInfo bootstrapInfo =
+          Bootstrapper.BootstrapInfo.builder()
+              .servers(ImmutableList.<Bootstrapper.ServerInfo>of())
+              .node(EnvoyProtoData.Node.newBuilder().build())
+              .certProviders(certProviders)
+              .serverListenerResourceNameTemplate("grpc/server")
+              .build();
+      return bootstrapInfo;
+    } catch (IOException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  /**
+   * Build {@link Bootstrapper.BootstrapInfo} for certProviderInstance tests.
+   * Populates with temp file paths.
+   */
+  public static Bootstrapper.BootstrapInfo buildBootstrapInfo(
+      String certInstanceName1, @Nullable String privateKey1,
+      @Nullable String cert1,
+      @Nullable String trustCa1, String certInstanceName2, String privateKey2, String cert2,
+      String trustCa2, @Nullable String spiffeTrustMap) {
+    // get temp file for each file
+    try {
+      if (privateKey1 != null) {
+        privateKey1 = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(privateKey1);
+      }
+      if (cert1 != null) {
+        cert1 = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(cert1);
+      }
+      if (trustCa1 != null) {
+        trustCa1 = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(trustCa1);
+      }
+      if (privateKey2 != null) {
+        privateKey2 = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(privateKey2);
+      }
+      if (cert2 != null) {
+        cert2 = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(cert2);
+      }
+      if (trustCa2 != null) {
+        trustCa2 = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(trustCa2);
+      }
+      if (spiffeTrustMap != null) {
+        spiffeTrustMap = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(spiffeTrustMap);
+      }
+    } catch (IOException ioe) {
+      throw new RuntimeException(ioe);
+    }
+    HashMap<String, String> config = new HashMap<>();
+    config.put("certificate_file", cert1);
+    config.put("private_key_file", privateKey1);
+    config.put("ca_certificate_file", trustCa1);
+    if (spiffeTrustMap != null) {
+      config.put("spiffe_trust_bundle_map_file", spiffeTrustMap);
+    }
+    Bootstrapper.CertificateProviderInfo certificateProviderInfo =
+        Bootstrapper.CertificateProviderInfo.create("file_watcher", config);
+    HashMap<String, Bootstrapper.CertificateProviderInfo> certProviders =
+        new HashMap<>();
+    certProviders.put(certInstanceName1, certificateProviderInfo);
+    if (certInstanceName2 != null) {
+      config = new HashMap<>();
+      config.put("certificate_file", cert2);
+      config.put("private_key_file", privateKey2);
+      config.put("ca_certificate_file", trustCa2);
+      if (spiffeTrustMap != null) {
+        config.put("spiffe_trust_bundle_map_file", spiffeTrustMap);
+      }
+      certificateProviderInfo =
+          Bootstrapper.CertificateProviderInfo.create("file_watcher", config);
+      certProviders.put(certInstanceName2, certificateProviderInfo);
+    }
+    return Bootstrapper.BootstrapInfo.builder()
+        .servers(ImmutableList.<ServerInfo>of())
+        .node(EnvoyProtoData.Node.newBuilder().build())
+        .certProviders(certProviders)
+        .build();
+  }
+
+  public static boolean setEnableXdsFallback(boolean target) {
+    boolean oldValue = BootstrapperImpl.enableXdsFallback;
+    BootstrapperImpl.enableXdsFallback = target;
+    return oldValue;
+  }
+
+  public static XdsClientImpl createXdsClient(List<String> serverUris,
+                                              XdsTransportFactory xdsTransportFactory,
+                                              FakeClock fakeClock,
+                                              BackoffPolicy.Provider backoffPolicyProvider,
+                                              MessagePrettyPrinter messagePrinter,
+                                              XdsClientMetricReporter xdsClientMetricReporter) {
+    return createXdsClient(
+        buildBootStrap(serverUris),
+        xdsTransportFactory,
+        fakeClock,
+        backoffPolicyProvider,
+        messagePrinter,
+        xdsClientMetricReporter);
+  }
+
+  public static XdsClientImpl createXdsClient(Bootstrapper.BootstrapInfo bootstrapInfo,
+                                              XdsTransportFactory xdsTransportFactory,
+                                              FakeClock fakeClock,
+                                              BackoffPolicy.Provider backoffPolicyProvider,
+                                              MessagePrettyPrinter messagePrinter,
+                                              XdsClientMetricReporter xdsClientMetricReporter) {
+    return new XdsClientImpl(
+        xdsTransportFactory,
+        bootstrapInfo,
+        fakeClock.getScheduledExecutorService(),
+        backoffPolicyProvider,
+        fakeClock.getStopwatchSupplier(),
+        fakeClock.getTimeProvider(),
+        messagePrinter,
+        new TlsContextManagerImpl(bootstrapInfo),
+        xdsClientMetricReporter);
+  }
+
+  public static Bootstrapper.BootstrapInfo buildBootStrap(List<String> serverUris) {
+
+    List<ServerInfo> serverInfos = new ArrayList<>();
+    for (String uri : serverUris) {
+      serverInfos.add(ServerInfo.create(uri, CHANNEL_CREDENTIALS, false, true, false, false));
+    }
+    EnvoyProtoData.Node node = EnvoyProtoData.Node.newBuilder().setId("node-id").build();
+
+    return Bootstrapper.BootstrapInfo.builder()
+        .servers(serverInfos)
+        .node(node)
+        .authorities(ImmutableMap.of(
+            "authority.xds.com",
+            Bootstrapper.AuthorityInfo.create(
+                "xdstp://authority.xds.com/envoy.config.listener.v3.Listener/%s",
+                ImmutableList.of(Bootstrapper.ServerInfo.create(
+                    SERVER_URI_CUSTOM_AUTHORITY, CHANNEL_CREDENTIALS))),
+            "",
+            Bootstrapper.AuthorityInfo.create(
+                "xdstp:///envoy.config.listener.v3.Listener/%s",
+                ImmutableList.of(Bootstrapper.ServerInfo.create(
+                    SERVER_URI_EMPTY_AUTHORITY, CHANNEL_CREDENTIALS)))))
+        .certProviders(ImmutableMap.of("cert-instance-name",
+            Bootstrapper.CertificateProviderInfo.create("file-watcher", ImmutableMap.of())))
+        .build();
+  }
+
+}
diff --git a/xds/src/test/java/io/grpc/xds/client/EnvoyProtoDataTest.java b/xds/src/test/java/io/grpc/xds/client/EnvoyProtoDataTest.java
new file mode 100644
index 00000000000..f1bb4c2c816
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/client/EnvoyProtoDataTest.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2019 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.xds.client;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Struct;
+import com.google.protobuf.Value;
+import io.grpc.xds.client.EnvoyProtoData.Address;
+import io.grpc.xds.client.EnvoyProtoData.Node;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link EnvoyProtoData}.
+ */
+@RunWith(JUnit4.class)
+public class EnvoyProtoDataTest {
+
+  @SuppressWarnings("deprecation")
+  @Test
+  public void convertNode() {
+    Node node = Node.newBuilder()
+        .setId("node-id")
+        .setCluster("cluster")
+        .setMetadata(
+            ImmutableMap.of(
+                "TRAFFICDIRECTOR_INTERCEPTION_PORT",
+                "ENVOY_PORT",
+                "TRAFFICDIRECTOR_NETWORK_NAME",
+                "VPC_NETWORK_NAME"))
+        .setLocality(Locality.create("region", "zone", "subzone"))
+        .addListeningAddresses(new Address("www.foo.com", 8080))
+        .addListeningAddresses(new Address("www.bar.com", 8088))
+        .setBuildVersion("v1")
+        .setUserAgentName("agent")
+        .setUserAgentVersion("1.1")
+        .addClientFeatures("feature-1")
+        .addClientFeatures("feature-2")
+        .build();
+    io.envoyproxy.envoy.config.core.v3.Node nodeProto =
+        io.envoyproxy.envoy.config.core.v3.Node.newBuilder()
+            .setId("node-id")
+            .setCluster("cluster")
+            .setMetadata(Struct.newBuilder()
+                .putFields("TRAFFICDIRECTOR_INTERCEPTION_PORT",
+                    Value.newBuilder().setStringValue("ENVOY_PORT").build())
+                .putFields("TRAFFICDIRECTOR_NETWORK_NAME",
+                    Value.newBuilder().setStringValue("VPC_NETWORK_NAME").build()))
+            .setLocality(
+                io.envoyproxy.envoy.config.core.v3.Locality.newBuilder()
+                    .setRegion("region")
+                    .setZone("zone")
+                    .setSubZone("subzone"))
+            .addListeningAddresses(
+                io.envoyproxy.envoy.config.core.v3.Address.newBuilder()
+                    .setSocketAddress(
+                        io.envoyproxy.envoy.config.core.v3.SocketAddress.newBuilder()
+                            .setAddress("www.foo.com")
+                            .setPortValue(8080)))
+            .addListeningAddresses(
+                io.envoyproxy.envoy.config.core.v3.Address.newBuilder()
+                    .setSocketAddress(
+                        io.envoyproxy.envoy.config.core.v3.SocketAddress.newBuilder()
+                            .setAddress("www.bar.com")
+                            .setPortValue(8088)))
+            .setUserAgentName("agent")
+            .setUserAgentVersion("1.1")
+            .addClientFeatures("feature-1")
+            .addClientFeatures("feature-2")
+            .build();
+    assertThat(node.toEnvoyProtoNode()).isEqualTo(nodeProto);
+  }
+
+  @Test
+  public void nodeToBuilderPropagatesAllAttributes() {
+    Node node = Node.newBuilder()
+        .setId("id")
+        .setCluster("cluster")
+        .setMetadata(ImmutableMap.of("key1", "value1", "key2", "value2"))
+        .setLocality(Locality.create("region", "zone", "subzone"))
+        .setBuildVersion("v1")
+        .setUserAgentName("grpc-java")
+        .setUserAgentVersion("v1.0.9")
+        .addListeningAddresses(new Address("localhost", 8080))
+        .addListeningAddresses(new Address("localhost", 8081))
+        .addClientFeatures("feature1")
+        .addClientFeatures("feature2")
+        .build();
+    assertThat(node.toBuilder().build()).isEqualTo(node);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/client/LoadStatsManager2Test.java b/xds/src/test/java/io/grpc/xds/client/LoadStatsManager2Test.java
new file mode 100644
index 00000000000..a0642f7e4bb
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/client/LoadStatsManager2Test.java
@@ -0,0 +1,393 @@
+/*
+ * Copyright 2021 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.xds.client;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import io.grpc.Status;
+import io.grpc.internal.FakeClock;
+import io.grpc.xds.client.LoadStatsManager2.ClusterDropStats;
+import io.grpc.xds.client.LoadStatsManager2.ClusterLocalityStats;
+import io.grpc.xds.client.Stats.ClusterStats;
+import io.grpc.xds.client.Stats.DroppedRequests;
+import io.grpc.xds.client.Stats.UpstreamLocalityStats;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+import javax.annotation.Nullable;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Unit tests for {@link LoadStatsManager2}.
+ */
+@RunWith(JUnit4.class)
+public class LoadStatsManager2Test {
+  private static final double TOLERANCE = 1.0e-10;
+  private static final String CLUSTER_NAME1 = "cluster-foo.googleapis.com";
+  private static final String CLUSTER_NAME2 = "cluster-bar.googleapis.com";
+  private static final String EDS_SERVICE_NAME1 = "backend-service-foo.googleapis.com";
+  private static final String EDS_SERVICE_NAME2 = "backend-service-bar.googleapis.com";
+  private static final Locality LOCALITY1 =
+      Locality.create("test_region1", "test_zone1", "test_subzone1");
+  private static final Locality LOCALITY2 =
+      Locality.create("test_region2", "test_zone2", "test_subzone2");
+  private static final Locality LOCALITY3 =
+      Locality.create("test_region3", "test_zone3", "test_subzone3");
+
+  private final FakeClock fakeClock = new FakeClock();
+  private final LoadStatsManager2 loadStatsManager =
+      new LoadStatsManager2(fakeClock.getStopwatchSupplier());
+
+  @Test
+  public void recordAndGetReport() {
+    ClusterDropStats dropCounter1 = loadStatsManager.getClusterDropStats(
+        CLUSTER_NAME1, EDS_SERVICE_NAME1);
+    ClusterDropStats dropCounter2 = loadStatsManager.getClusterDropStats(
+        CLUSTER_NAME1, EDS_SERVICE_NAME2);
+    ClusterLocalityStats loadCounter1 = loadStatsManager.getClusterLocalityStats(
+        CLUSTER_NAME1, EDS_SERVICE_NAME1, LOCALITY1);
+    ClusterLocalityStats loadCounter2 = loadStatsManager.getClusterLocalityStats(
+        CLUSTER_NAME1, EDS_SERVICE_NAME1, LOCALITY2);
+    ClusterLocalityStats loadCounter3 = loadStatsManager.getClusterLocalityStats(
+        CLUSTER_NAME2, null, LOCALITY3);
+    dropCounter1.recordDroppedRequest("lb");
+    dropCounter1.recordDroppedRequest("throttle");
+    for (int i = 0; i < 19; i++) {
+      loadCounter1.recordCallStarted();
+    }
+    loadCounter1.recordBackendLoadMetricStats(ImmutableMap.of("named1", 3.14159));
+    loadCounter1.recordBackendLoadMetricStats(ImmutableMap.of("named1", 1.618));
+    loadCounter1.recordBackendLoadMetricStats(ImmutableMap.of("named1", 99.0));
+    loadCounter1.recordBackendLoadMetricStats(ImmutableMap.of("named1", -97.23, "named2", -2.718));
+    fakeClock.forwardTime(5L, TimeUnit.SECONDS);
+    dropCounter2.recordDroppedRequest();
+    loadCounter1.recordCallFinished(Status.OK);
+    for (int i = 0; i < 9; i++) {
+      loadCounter2.recordCallStarted();
+    }
+    loadCounter2.recordBackendLoadMetricStats(ImmutableMap.of("named3", 0.0009));
+    loadCounter2.recordCallFinished(Status.UNAVAILABLE);
+    fakeClock.forwardTime(10L, TimeUnit.SECONDS);
+    loadCounter3.recordCallStarted();
+    List<ClusterStats> allStats = loadStatsManager.getAllClusterStatsReports();
+    assertThat(allStats).hasSize(3);  // three cluster:edsServiceName
+
+    ClusterStats stats1 = findClusterStats(allStats, CLUSTER_NAME1, EDS_SERVICE_NAME1);
+    assertThat(stats1).isNotNull();
+    assertThat(stats1.loadReportIntervalNano()).isEqualTo(TimeUnit.SECONDS.toNanos(5L + 10L));
+    assertThat(stats1.droppedRequestsList()).hasSize(2);
+    assertThat(findDroppedRequestCount(stats1.droppedRequestsList(), "lb")).isEqualTo(1L);
+    assertThat(findDroppedRequestCount(stats1.droppedRequestsList(), "throttle")).isEqualTo(1L);
+    assertThat(stats1.totalDroppedRequests()).isEqualTo(1L + 1L);
+    assertThat(stats1.upstreamLocalityStatsList()).hasSize(2);  // two localities
+    UpstreamLocalityStats loadStats1 =
+        findLocalityStats(stats1.upstreamLocalityStatsList(), LOCALITY1);
+    assertThat(loadStats1).isNotNull();
+    assertThat(loadStats1.totalIssuedRequests()).isEqualTo(19L);
+    assertThat(loadStats1.totalSuccessfulRequests()).isEqualTo(1L);
+    assertThat(loadStats1.totalErrorRequests()).isEqualTo(0L);
+    assertThat(loadStats1.totalRequestsInProgress()).isEqualTo(19L - 1L);
+    assertThat(loadStats1.loadMetricStatsMap().containsKey("named1")).isTrue();
+    assertThat(loadStats1.loadMetricStatsMap().containsKey("named2")).isTrue();
+    assertThat(
+        loadStats1.loadMetricStatsMap().get("named1").numRequestsFinishedWithMetric()).isEqualTo(
+        4L);
+    assertThat(loadStats1.loadMetricStatsMap().get("named1").totalMetricValue()).isWithin(TOLERANCE)
+        .of(3.14159 + 1.618 + 99 - 97.23);
+    assertThat(
+        loadStats1.loadMetricStatsMap().get("named2").numRequestsFinishedWithMetric()).isEqualTo(
+        1L);
+    assertThat(loadStats1.loadMetricStatsMap().get("named2").totalMetricValue()).isWithin(TOLERANCE)
+        .of(-2.718);
+
+    UpstreamLocalityStats loadStats2 =
+        findLocalityStats(stats1.upstreamLocalityStatsList(), LOCALITY2);
+    assertThat(loadStats2.totalIssuedRequests()).isEqualTo(9L);
+    assertThat(loadStats2.totalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(loadStats2.totalErrorRequests()).isEqualTo(1L);
+    assertThat(loadStats2.totalRequestsInProgress()).isEqualTo(9L - 1L);
+    assertThat(loadStats2.loadMetricStatsMap().containsKey("named3")).isTrue();
+    assertThat(
+        loadStats2.loadMetricStatsMap().get("named3").numRequestsFinishedWithMetric()).isEqualTo(
+        1L);
+    assertThat(loadStats2.loadMetricStatsMap().get("named3").totalMetricValue()).isWithin(TOLERANCE)
+        .of(0.0009);
+
+    ClusterStats stats2 = findClusterStats(allStats, CLUSTER_NAME1, EDS_SERVICE_NAME2);
+    assertThat(stats2.loadReportIntervalNano()).isEqualTo(TimeUnit.SECONDS.toNanos(5L + 10L));
+    assertThat(stats2.droppedRequestsList()).isEmpty();  // no categorized drops
+    assertThat(stats2.totalDroppedRequests()).isEqualTo(1L);
+    assertThat(stats2.upstreamLocalityStatsList()).isEmpty();  // no per-locality stats
+
+    ClusterStats stats3 = findClusterStats(allStats, CLUSTER_NAME2, null);
+    assertThat(stats3.loadReportIntervalNano()).isEqualTo(TimeUnit.SECONDS.toNanos(5L + 10L));
+    assertThat(stats3.droppedRequestsList()).isEmpty();
+    assertThat(stats3.totalDroppedRequests()).isEqualTo(0L);  // no drops recorded
+    assertThat(stats3.upstreamLocalityStatsList()).hasSize(1);  // one localities
+    UpstreamLocalityStats loadStats3 =
+        Iterables.getOnlyElement(stats3.upstreamLocalityStatsList());
+    assertThat(loadStats3.totalIssuedRequests()).isEqualTo(1L);
+    assertThat(loadStats3.totalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(loadStats3.totalErrorRequests()).isEqualTo(0L);
+    assertThat(loadStats3.totalRequestsInProgress()).isEqualTo(1L);
+    assertThat(loadStats3.loadMetricStatsMap()).isEmpty();
+
+    fakeClock.forwardTime(3L, TimeUnit.SECONDS);
+    List<ClusterStats> clusterStatsList = loadStatsManager.getClusterStatsReports(CLUSTER_NAME1);
+    assertThat(clusterStatsList).hasSize(2);
+    stats1 = findClusterStats(clusterStatsList, CLUSTER_NAME1, EDS_SERVICE_NAME1);
+    assertThat(stats1.loadReportIntervalNano()).isEqualTo(TimeUnit.SECONDS.toNanos(3L));
+    assertThat(stats1.droppedRequestsList()).isEmpty();
+    assertThat(stats1.totalDroppedRequests()).isEqualTo(0L);  // no new drops recorded
+    assertThat(stats1.upstreamLocalityStatsList()).hasSize(2);  // two localities
+    loadStats1 = findLocalityStats(stats1.upstreamLocalityStatsList(), LOCALITY1);
+    assertThat(loadStats1.totalIssuedRequests()).isEqualTo(0L);
+    assertThat(loadStats1.totalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(loadStats1.totalErrorRequests()).isEqualTo(0L);
+    assertThat(loadStats1.totalRequestsInProgress()).isEqualTo(18L);  // still in-progress
+    assertThat(loadStats1.loadMetricStatsMap()).isEmpty();
+    loadStats2 = findLocalityStats(stats1.upstreamLocalityStatsList(), LOCALITY2);
+    assertThat(loadStats2.totalIssuedRequests()).isEqualTo(0L);
+    assertThat(loadStats2.totalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(loadStats2.totalErrorRequests()).isEqualTo(0L);
+    assertThat(loadStats2.totalRequestsInProgress()).isEqualTo(8L);  // still in-progress
+    assertThat(loadStats2.loadMetricStatsMap()).isEmpty();
+
+    stats2 = findClusterStats(clusterStatsList, CLUSTER_NAME1, EDS_SERVICE_NAME2);
+    assertThat(stats2.loadReportIntervalNano()).isEqualTo(TimeUnit.SECONDS.toNanos(3L));
+    assertThat(stats2.droppedRequestsList()).isEmpty();
+    assertThat(stats2.totalDroppedRequests()).isEqualTo(0L);  // no new drops recorded
+    assertThat(stats2.upstreamLocalityStatsList()).isEmpty();  // no per-locality stats
+  }
+
+  @Test
+  public void sharedDropCounterStatsAggregation() {
+    ClusterDropStats ref1 = loadStatsManager.getClusterDropStats(
+        CLUSTER_NAME1, EDS_SERVICE_NAME1);
+    ClusterDropStats ref2 = loadStatsManager.getClusterDropStats(
+        CLUSTER_NAME1, EDS_SERVICE_NAME1);
+    ref1.recordDroppedRequest("lb");
+    ref2.recordDroppedRequest("throttle");
+    ref1.recordDroppedRequest();
+    ref2.recordDroppedRequest();
+
+    ClusterStats stats = Iterables.getOnlyElement(
+        loadStatsManager.getClusterStatsReports(CLUSTER_NAME1));
+    assertThat(stats.droppedRequestsList()).hasSize(2);
+    assertThat(findDroppedRequestCount(stats.droppedRequestsList(), "lb")).isEqualTo(1L);
+    assertThat(findDroppedRequestCount(stats.droppedRequestsList(), "throttle")).isEqualTo(1L);
+    assertThat(stats.totalDroppedRequests()).isEqualTo(4L);  // 2 cagetorized + 2 uncategoized
+  }
+
+  @Test
+  public void dropCounterDelayedDeletionAfterReported() {
+    ClusterDropStats counter = loadStatsManager.getClusterDropStats(
+        CLUSTER_NAME1, EDS_SERVICE_NAME1);
+    counter.recordDroppedRequest("lb");
+    ClusterStats stats = Iterables.getOnlyElement(
+        loadStatsManager.getClusterStatsReports(CLUSTER_NAME1));
+    assertThat(stats.droppedRequestsList()).hasSize(1);
+    assertThat(Iterables.getOnlyElement(stats.droppedRequestsList()).droppedCount())
+        .isEqualTo(1L);
+    assertThat(stats.totalDroppedRequests()).isEqualTo(1L);
+
+    counter.release();
+    stats = Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER_NAME1));
+    assertThat(stats.droppedRequestsList()).isEmpty();
+    assertThat(stats.totalDroppedRequests()).isEqualTo(0L);
+
+    assertThat(loadStatsManager.getClusterStatsReports(CLUSTER_NAME1)).isEmpty();
+  }
+
+  @Test
+  public void sharedLoadCounterStatsAggregation() {
+    ClusterLocalityStats ref1 = loadStatsManager.getClusterLocalityStats(
+        CLUSTER_NAME1, EDS_SERVICE_NAME1, LOCALITY1);
+    ClusterLocalityStats ref2 = loadStatsManager.getClusterLocalityStats(
+        CLUSTER_NAME1, EDS_SERVICE_NAME1, LOCALITY1);
+    ref1.recordCallStarted();
+    ref1.recordBackendLoadMetricStats(ImmutableMap.of("named1", 1.618));
+    ref1.recordBackendLoadMetricStats(ImmutableMap.of("named1", 3.14159));
+    ref1.recordCallFinished(Status.OK);
+    ref2.recordCallStarted();
+    ref2.recordCallStarted();
+    ref2.recordBackendLoadMetricStats(ImmutableMap.of("named1", -1.0, "named2", 2.718));
+    ref2.recordCallFinished(Status.UNAVAILABLE);
+
+    ClusterStats stats = Iterables.getOnlyElement(
+        loadStatsManager.getClusterStatsReports(CLUSTER_NAME1));
+    UpstreamLocalityStats localityStats =
+        Iterables.getOnlyElement(stats.upstreamLocalityStatsList());
+    assertThat(localityStats.totalIssuedRequests()).isEqualTo(1L + 2L);
+    assertThat(localityStats.totalSuccessfulRequests()).isEqualTo(1L);
+    assertThat(localityStats.totalErrorRequests()).isEqualTo(1L);
+    assertThat(localityStats.totalRequestsInProgress()).isEqualTo(1L + 2L - 1L - 1L);
+    assertThat(localityStats.loadMetricStatsMap().containsKey("named1")).isTrue();
+    assertThat(localityStats.loadMetricStatsMap().containsKey("named2")).isTrue();
+    assertThat(
+        localityStats.loadMetricStatsMap().get("named1").numRequestsFinishedWithMetric()).isEqualTo(
+        3L);
+    assertThat(localityStats.loadMetricStatsMap().get("named1").totalMetricValue()).isWithin(
+        TOLERANCE).of(1.618 + 3.14159 - 1);
+    assertThat(
+        localityStats.loadMetricStatsMap().get("named2").numRequestsFinishedWithMetric()).isEqualTo(
+        1L);
+    assertThat(localityStats.loadMetricStatsMap().get("named2").totalMetricValue()).isEqualTo(
+        2.718);
+  }
+
+  @Test
+  public void recordMetrics_orcaLrsPropagationEnabled_specificMetrics() {
+    boolean originalVal = LoadStatsManager2.isEnabledOrcaLrsPropagation;
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = true;
+    BackendMetricPropagation backendMetricPropagation = BackendMetricPropagation.fromMetricSpecs(
+        Arrays.asList("cpu_utilization", "named_metrics.named1"));
+    ClusterLocalityStats stats = loadStatsManager.getClusterLocalityStats(
+        CLUSTER_NAME1, EDS_SERVICE_NAME1, LOCALITY1, backendMetricPropagation);
+
+    stats.recordTopLevelMetrics(0.8, 0.5, 0.0); // cpu, mem, app
+    stats.recordBackendLoadMetricStats(ImmutableMap.of("named1", 123.4, "named2", 567.8));
+    stats.recordCallFinished(Status.OK);
+    ClusterStats report = Iterables.getOnlyElement(
+        loadStatsManager.getClusterStatsReports(CLUSTER_NAME1));
+    UpstreamLocalityStats localityStats =
+        Iterables.getOnlyElement(report.upstreamLocalityStatsList());
+
+    assertThat(localityStats.loadMetricStatsMap()).containsKey("cpu_utilization");
+    assertThat(localityStats.loadMetricStatsMap().get("cpu_utilization").totalMetricValue())
+        .isWithin(TOLERANCE).of(0.8);
+    assertThat(localityStats.loadMetricStatsMap()).doesNotContainKey("mem_utilization");
+    assertThat(localityStats.loadMetricStatsMap()).containsKey("named_metrics.named1");
+    assertThat(localityStats.loadMetricStatsMap().get("named_metrics.named1").totalMetricValue())
+        .isWithin(TOLERANCE).of(123.4);
+    assertThat(localityStats.loadMetricStatsMap()).doesNotContainKey("named_metrics.named2");
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = originalVal;
+  }
+
+  @Test
+  public void recordMetrics_orcaLrsPropagationEnabled_wildcardNamedMetrics() {
+    boolean originalVal = LoadStatsManager2.isEnabledOrcaLrsPropagation;
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = true;
+    BackendMetricPropagation backendMetricPropagation = BackendMetricPropagation.fromMetricSpecs(
+        Arrays.asList("named_metrics.*"));
+    ClusterLocalityStats stats = loadStatsManager.getClusterLocalityStats(
+        CLUSTER_NAME1, EDS_SERVICE_NAME1, LOCALITY1, backendMetricPropagation);
+
+    stats.recordBackendLoadMetricStats(ImmutableMap.of("named1", 123.4, "named2", 567.8));
+    stats.recordCallFinished(Status.OK);
+    ClusterStats report = Iterables.getOnlyElement(
+        loadStatsManager.getClusterStatsReports(CLUSTER_NAME1));
+    UpstreamLocalityStats localityStats =
+        Iterables.getOnlyElement(report.upstreamLocalityStatsList());
+
+    assertThat(localityStats.loadMetricStatsMap()).containsKey("named_metrics.named1");
+    assertThat(localityStats.loadMetricStatsMap().get("named_metrics.named1").totalMetricValue())
+        .isWithin(TOLERANCE).of(123.4);
+    assertThat(localityStats.loadMetricStatsMap()).containsKey("named_metrics.named2");
+    assertThat(localityStats.loadMetricStatsMap().get("named_metrics.named2").totalMetricValue())
+        .isWithin(TOLERANCE).of(567.8);
+    LoadStatsManager2.isEnabledOrcaLrsPropagation = originalVal;
+  }
+
+  @Test
+  public void loadCounterDelayedDeletionAfterAllInProgressRequestsReported() {
+    ClusterLocalityStats counter = loadStatsManager.getClusterLocalityStats(
+        CLUSTER_NAME1, EDS_SERVICE_NAME1, LOCALITY1);
+    counter.recordCallStarted();
+    counter.recordCallStarted();
+    counter.recordBackendLoadMetricStats(ImmutableMap.of("named1", 2.718));
+    counter.recordBackendLoadMetricStats(ImmutableMap.of("named1", 1.414));
+
+    ClusterStats stats = Iterables.getOnlyElement(
+        loadStatsManager.getClusterStatsReports(CLUSTER_NAME1));
+    UpstreamLocalityStats localityStats =
+        Iterables.getOnlyElement(stats.upstreamLocalityStatsList());
+    assertThat(localityStats.totalIssuedRequests()).isEqualTo(2L);
+    assertThat(localityStats.totalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(localityStats.totalErrorRequests()).isEqualTo(0L);
+    assertThat(localityStats.totalRequestsInProgress()).isEqualTo(2L);
+    assertThat(localityStats.loadMetricStatsMap().containsKey("named1")).isTrue();
+    assertThat(
+        localityStats.loadMetricStatsMap().get("named1").numRequestsFinishedWithMetric()).isEqualTo(
+        2L);
+    assertThat(localityStats.loadMetricStatsMap().get("named1").totalMetricValue()).isEqualTo(
+        2.718 + 1.414);
+
+    // release the counter, but requests still in-flight
+    counter.release();
+    stats = Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER_NAME1));
+    localityStats = Iterables.getOnlyElement(stats.upstreamLocalityStatsList());
+    assertThat(localityStats.totalIssuedRequests()).isEqualTo(0L);
+    assertThat(localityStats.totalSuccessfulRequests()).isEqualTo(0L);
+    assertThat(localityStats.totalErrorRequests()).isEqualTo(0L);
+    assertThat(localityStats.totalRequestsInProgress())
+        .isEqualTo(2L);  // retained by in-flight calls
+    assertThat(localityStats.loadMetricStatsMap().isEmpty()).isTrue();
+
+    counter.recordCallFinished(Status.OK);
+    counter.recordCallFinished(Status.UNAVAILABLE);
+    stats = Iterables.getOnlyElement(loadStatsManager.getClusterStatsReports(CLUSTER_NAME1));
+    localityStats = Iterables.getOnlyElement(stats.upstreamLocalityStatsList());
+    assertThat(localityStats.totalIssuedRequests()).isEqualTo(0L);
+    assertThat(localityStats.totalSuccessfulRequests()).isEqualTo(1L);
+    assertThat(localityStats.totalErrorRequests()).isEqualTo(1L);
+    assertThat(localityStats.totalRequestsInProgress()).isEqualTo(0L);
+    assertThat(localityStats.loadMetricStatsMap().isEmpty()).isTrue();
+
+    assertThat(loadStatsManager.getClusterStatsReports(CLUSTER_NAME1)).isEmpty();
+  }
+
+  @Nullable
+  private static ClusterStats findClusterStats(
+      List<ClusterStats> statsList, String cluster, @Nullable String edsServiceName) {
+    for (ClusterStats stats : statsList) {
+      if (stats.clusterName().equals(cluster)
+          && Objects.equals(stats.clusterServiceName(), edsServiceName)) {
+        return stats;
+      }
+    }
+    return null;
+  }
+
+  @Nullable
+  private static UpstreamLocalityStats findLocalityStats(
+      List<UpstreamLocalityStats> localityStatsList, Locality locality) {
+    for (UpstreamLocalityStats stats : localityStatsList) {
+      if (stats.locality().equals(locality)) {
+        return stats;
+      }
+    }
+    return null;
+  }
+
+  private static long findDroppedRequestCount(
+      List<DroppedRequests> droppedRequestsLists, String category) {
+    DroppedRequests drop = null;
+    for (DroppedRequests stats : droppedRequestsLists) {
+      if (stats.category().equals(category)) {
+        drop = stats;
+      }
+    }
+    assertThat(drop).isNotNull();
+    return drop.droppedCount();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/GoogleDefaultXdsCredentialsProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/GoogleDefaultXdsCredentialsProviderTest.java
new file mode 100644
index 00000000000..dd615809bc2
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/GoogleDefaultXdsCredentialsProviderTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2022 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.xds.internal;
+
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.grpc.CompositeChannelCredentials;
+import io.grpc.InternalServiceProviders;
+import io.grpc.xds.XdsCredentialsProvider;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link GoogleDefaultXdsCredentialsProvider}. */
+@RunWith(JUnit4.class)
+public class GoogleDefaultXdsCredentialsProviderTest {
+  private GoogleDefaultXdsCredentialsProvider provider = new GoogleDefaultXdsCredentialsProvider();
+
+  @Test
+  public void provided() {
+    for (XdsCredentialsProvider current
+        : InternalServiceProviders.getCandidatesViaServiceLoader(
+          XdsCredentialsProvider.class, getClass().getClassLoader())) {
+      if (current instanceof GoogleDefaultXdsCredentialsProvider) {
+        return;
+      }
+    }
+    fail("ServiceLoader unable to load GoogleDefaultXdsCredentialsProvider");
+  }
+
+  @Test
+  public void isAvailable() {
+    assertTrue(provider.isAvailable());
+  }
+
+  @Test
+  public void channelCredentials() {
+    assertSame(CompositeChannelCredentials.class,
+        provider.newChannelCredentials(null).getClass());
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/InsecureXdsCredentialsProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/InsecureXdsCredentialsProviderTest.java
new file mode 100644
index 00000000000..583255473eb
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/InsecureXdsCredentialsProviderTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2022 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.xds.internal;
+
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.grpc.InsecureChannelCredentials;
+import io.grpc.InternalServiceProviders;
+import io.grpc.xds.XdsCredentialsProvider;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link InsecureXdsCredentialsProvider}. */
+@RunWith(JUnit4.class)
+public class InsecureXdsCredentialsProviderTest {
+  private InsecureXdsCredentialsProvider provider = new InsecureXdsCredentialsProvider();
+
+  @Test
+  public void provided() {
+    for (XdsCredentialsProvider current
+        : InternalServiceProviders.getCandidatesViaServiceLoader(
+          XdsCredentialsProvider.class, getClass().getClassLoader())) {
+      if (current instanceof InsecureXdsCredentialsProvider) {
+        return;
+      }
+    }
+    fail("ServiceLoader unable to load InsecureXdsCredentialsProvider");
+  }
+
+  @Test
+  public void isAvailable() {
+    assertTrue(provider.isAvailable());
+  }
+
+  @Test
+  public void channelCredentials() {
+    assertSame(InsecureChannelCredentials.class,
+        provider.newChannelCredentials(null).getClass());
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/MatcherTest.java b/xds/src/test/java/io/grpc/xds/internal/MatcherTest.java
new file mode 100644
index 00000000000..4e5d278d50f
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/MatcherTest.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright 2021 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.xds.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.re2j.Pattern;
+import io.grpc.xds.internal.Matchers.CidrMatcher;
+import io.grpc.xds.internal.Matchers.HeaderMatcher;
+import io.grpc.xds.internal.Matchers.HeaderMatcher.Range;
+import io.grpc.xds.internal.Matchers.StringMatcher;
+import java.net.InetAddress;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class MatcherTest {
+
+  @Test
+  public void ipMatcher_ipv4() throws Exception {
+    CidrMatcher matcher = CidrMatcher.create(InetAddress.getByName("10.10.24.10"), 20);
+    assertThat(matcher.matches(InetAddress.getByName("::0"))).isFalse();
+    assertThat(matcher.matches(InetAddress.getByName("10.10.20.0"))).isTrue();
+    assertThat(matcher.matches(InetAddress.getByName("10.10.16.0"))).isTrue();
+    assertThat(matcher.matches(InetAddress.getByName("10.10.24.10"))).isTrue();
+    assertThat(matcher.matches(InetAddress.getByName("10.10.31.0"))).isTrue();
+    assertThat(matcher.matches(InetAddress.getByName("10.10.17.0"))).isTrue();
+    assertThat(matcher.matches(InetAddress.getByName("10.32.20.0"))).isFalse();
+    assertThat(matcher.matches(InetAddress.getByName("10.10.40.0"))).isFalse();
+    matcher = CidrMatcher.create(InetAddress.getByName("0.0.0.0"), 20);
+    assertThat(matcher.matches(InetAddress.getByName("10.32.20.0"))).isFalse();
+    assertThat(matcher.matches(InetAddress.getByName("0.0.31.0"))).isFalse();
+    assertThat(matcher.matches(InetAddress.getByName("0.0.15.0"))).isTrue();
+    assertThat(matcher.matches(null)).isFalse();
+  }
+
+  @Test
+  public void ipMatcher_ipv6() throws Exception {
+    CidrMatcher matcher = CidrMatcher.create(InetAddress.getByName("2012:00fe:d808::"), 36);
+    assertThat(matcher.matches(InetAddress.getByName("0.0.0.0"))).isFalse();
+    assertThat(matcher.matches(InetAddress.getByName("2012:00fe:d000::0"))).isTrue();
+    assertThat(matcher.matches(InetAddress.getByName("2012:00fe:d808::"))).isTrue();
+    assertThat(matcher.matches(InetAddress.getByName("2012:00fe:da81:0909:0008:4018:e930:b019")))
+        .isTrue();
+    assertThat(matcher.matches(InetAddress.getByName("2013:00fe:d000::0"))).isFalse();
+  }
+
+  @Test
+  public void stringMatcher() {
+    StringMatcher matcher = StringMatcher.forExact("essence", false);
+    assertThat(matcher.matches("elite")).isFalse();
+    assertThat(matcher.matches("ess")).isFalse();
+    assertThat(matcher.matches("")).isFalse();
+    assertThat(matcher.matches("essential")).isFalse();
+    assertThat(matcher.matches("Essence")).isFalse();
+    assertThat(matcher.matches("essence")).isTrue();
+    assertThat(matcher.matches((String)null)).isFalse();
+    matcher = StringMatcher.forExact("essence", true);
+    assertThat(matcher.matches("Essence")).isTrue();
+    assertThat(matcher.matches("essence")).isTrue();
+    matcher = StringMatcher.forExact("", true);
+    assertThat(matcher.matches("essence")).isFalse();
+    assertThat(matcher.matches("")).isTrue();
+
+    matcher = StringMatcher.forPrefix("Ess", false);
+    assertThat(matcher.matches("elite")).isFalse();
+    assertThat(matcher.matches("ess")).isFalse();
+    assertThat(matcher.matches("")).isFalse();
+    assertThat(matcher.matches("e")).isFalse();
+    assertThat(matcher.matches("essential")).isFalse();
+    assertThat(matcher.matches("Essence")).isTrue();
+    assertThat(matcher.matches("essence")).isFalse();
+    assertThat(matcher.matches((String)null)).isFalse();
+    matcher = StringMatcher.forPrefix("Ess", true);
+    assertThat(matcher.matches("esSEncE")).isTrue();
+    assertThat(matcher.matches("ess")).isTrue();
+    assertThat(matcher.matches("ES")).isFalse();
+    matcher = StringMatcher.forPrefix("", false);
+    assertThat(matcher.matches("elite")).isTrue();
+
+    matcher = StringMatcher.forSuffix("ess", false);
+    assertThat(matcher.matches("elite")).isFalse();
+    assertThat(matcher.matches("es")).isFalse();
+    assertThat(matcher.matches("")).isFalse();
+    assertThat(matcher.matches("ess")).isTrue();
+    assertThat(matcher.matches("Excess")).isTrue();
+    assertThat(matcher.matches("ExcesS")).isFalse();
+    assertThat(matcher.matches((String)null)).isFalse();
+    matcher = StringMatcher.forSuffix("ess", true);
+    assertThat(matcher.matches("esSEncESs")).isTrue();
+    assertThat(matcher.matches("ess")).isTrue();
+    matcher = StringMatcher.forSuffix("", true);
+    assertThat(matcher.matches("")).isTrue();
+    assertThat(matcher.matches("any")).isTrue();
+
+    matcher = StringMatcher.forContains("ess");
+    assertThat(matcher.matches("elite")).isFalse();
+    assertThat(matcher.matches("es")).isFalse();
+    assertThat(matcher.matches("")).isFalse();
+    assertThat(matcher.matches("essence")).isTrue();
+    assertThat(matcher.matches("eSs")).isFalse();
+    assertThat(matcher.matches("ExcesS")).isFalse();
+    assertThat(matcher.matches((String)null)).isFalse();
+
+    matcher = StringMatcher.forSafeRegEx(Pattern.compile("^es*.*"));
+    assertThat(matcher.matches("essence")).isTrue();
+    assertThat(matcher.matches("")).isFalse();
+  }
+
+  @Test
+  public void headerMatcher() {
+    HeaderMatcher matcher = HeaderMatcher.forExactValue("version", "v1", false);
+    assertThat(matcher.matches("v1")).isTrue();
+    assertThat(matcher.matches("v2")).isFalse();
+    assertThat(matcher.matches(null)).isFalse();
+
+    matcher = HeaderMatcher.forExactValue("version", "v1", true);
+    assertThat(matcher.matches("v1")).isFalse();
+    assertThat(matcher.matches( "v2")).isTrue();
+    assertThat(matcher.matches(null)).isFalse();
+
+    matcher = HeaderMatcher.forPresent("version", true, false);
+    assertThat(matcher.matches("any")).isTrue();
+    assertThat(matcher.matches(null)).isFalse();
+    matcher = HeaderMatcher.forPresent("version", true, true);
+    assertThat(matcher.matches("version")).isFalse();
+    assertThat(matcher.matches(null)).isTrue();
+    matcher = HeaderMatcher.forPresent("version", false, true);
+    assertThat(matcher.matches("tag")).isTrue();
+    assertThat(matcher.matches(null)).isFalse();
+    matcher = HeaderMatcher.forPresent("version", false, false);
+    assertThat(matcher.matches("tag")).isFalse();
+    assertThat(matcher.matches(null)).isTrue();
+
+    matcher = HeaderMatcher.forPrefix("version", "v2", false);
+    assertThat(matcher.matches("v22")).isTrue();
+    assertThat(matcher.matches(null)).isFalse();
+    matcher = HeaderMatcher.forPrefix("version", "v2", true);
+    assertThat(matcher.matches("v22")).isFalse();
+    assertThat(matcher.matches(null)).isFalse();
+
+    matcher = HeaderMatcher.forSuffix("version", "v1", false);
+    assertThat(matcher.matches("xv1")).isTrue();
+    assertThat(matcher.matches("v1x")).isFalse();
+    assertThat(matcher.matches(null)).isFalse();
+    matcher = HeaderMatcher.forSuffix("version", "v2", true);
+    assertThat(matcher.matches("xv1")).isTrue();
+    assertThat(matcher.matches("1v2")).isFalse();
+    assertThat(matcher.matches(null)).isFalse();
+
+    matcher = HeaderMatcher.forContains("version", "v1", false);
+    assertThat(matcher.matches("xv1")).isTrue();
+    assertThat(matcher.matches("1vx")).isFalse();
+    assertThat(matcher.matches(null)).isFalse();
+    matcher = HeaderMatcher.forContains("version", "v1", true);
+    assertThat(matcher.matches("xv1")).isFalse();
+    assertThat(matcher.matches("1vx")).isTrue();
+    assertThat(matcher.matches(null)).isFalse();
+
+    matcher = HeaderMatcher.forSafeRegEx("version", Pattern.compile("v2.*"), false);
+    assertThat(matcher.matches("v2..")).isTrue();
+    assertThat(matcher.matches("v1")).isFalse();
+    assertThat(matcher.matches(null)).isFalse();
+    matcher = HeaderMatcher.forSafeRegEx("version", Pattern.compile("v1\\..*"), true);
+    assertThat(matcher.matches("v1.43")).isFalse();
+    assertThat(matcher.matches("v2")).isTrue();
+    assertThat(matcher.matches(null)).isFalse();
+
+    matcher = HeaderMatcher.forRange("version", Range.create(8080L, 8090L), false);
+    assertThat(matcher.matches("8080")).isTrue();
+    assertThat(matcher.matches("1")).isFalse();
+    assertThat(matcher.matches(null)).isFalse();
+    matcher = HeaderMatcher.forRange("version", Range.create(8080L, 8090L), true);
+    assertThat(matcher.matches("1")).isTrue();
+    assertThat(matcher.matches("8080")).isFalse();
+    assertThat(matcher.matches(null)).isFalse();
+
+    matcher = HeaderMatcher.forString("version", StringMatcher.forExact("v1", true), false);
+    assertThat(matcher.matches("v1")).isTrue();
+    assertThat(matcher.matches("v1x")).isFalse();
+    assertThat(matcher.matches(null)).isFalse();
+    matcher = HeaderMatcher.forString("version", StringMatcher.forExact("v1", true), true);
+    assertThat(matcher.matches("v1x")).isTrue();
+    assertThat(matcher.matches("v1")).isFalse();
+    assertThat(matcher.matches(null)).isFalse();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/ProtobufJsonConverterTest.java b/xds/src/test/java/io/grpc/xds/internal/ProtobufJsonConverterTest.java
new file mode 100644
index 00000000000..86f9be4dda8
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/ProtobufJsonConverterTest.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2024 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.xds.internal;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertEquals;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.ListValue;
+import com.google.protobuf.Struct;
+import com.google.protobuf.Value;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+@RunWith(JUnit4.class)
+public class ProtobufJsonConverterTest {
+
+  @Test
+  public void testEmptyStruct() {
+    Struct emptyStruct = Struct.newBuilder().build();
+    Map<String, Object> result = ProtobufJsonConverter.convertToJson(emptyStruct);
+    assertThat(result).isEmpty();
+  }
+
+  @Test
+  public void testStructWithValues() {
+    Struct struct = Struct.newBuilder()
+        .putFields("stringKey", Value.newBuilder().setStringValue("stringValue").build())
+        .putFields("numberKey", Value.newBuilder().setNumberValue(123.45).build())
+        .putFields("boolKey", Value.newBuilder().setBoolValue(true).build())
+        .putFields("nullKey", Value.newBuilder().setNullValueValue(0).build())
+        .putFields("structKey", Value.newBuilder()
+            .setStructValue(Struct.newBuilder()
+                .putFields("nestedKey", Value.newBuilder().setStringValue("nestedValue").build())
+                .build())
+            .build())
+        .putFields("listKey", Value.newBuilder()
+            .setListValue(ListValue.newBuilder()
+                .addValues(Value.newBuilder().setNumberValue(1).build())
+                .addValues(Value.newBuilder().setStringValue("two").build())
+                .addValues(Value.newBuilder().setBoolValue(false).build())
+                .build())
+            .build())
+        .build();
+
+    Map<String, Object> result = ProtobufJsonConverter.convertToJson(struct);
+
+    Map<String, Object> goldenResult = new HashMap<>();
+    goldenResult.put("stringKey", "stringValue");
+    goldenResult.put("numberKey", 123.45);
+    goldenResult.put("boolKey", true);
+    goldenResult.put("nullKey", null);
+    goldenResult.put("structKey", ImmutableMap.of("nestedKey", "nestedValue"));
+    goldenResult.put("listKey", Arrays.asList(1.0, "two", false));
+
+    assertEquals(goldenResult, result);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void testUnknownValueType() {
+    Value unknownValue = Value.newBuilder().build(); // Default instance with no kind case set.
+    ProtobufJsonConverter.convertToJson(
+        Struct.newBuilder().putFields("unknownKey", unknownValue).build());
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/TlsXdsCredentialsProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/TlsXdsCredentialsProviderTest.java
new file mode 100644
index 00000000000..3ba26bdb281
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/TlsXdsCredentialsProviderTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2022 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.xds.internal;
+
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import io.grpc.InternalServiceProviders;
+import io.grpc.TlsChannelCredentials;
+import io.grpc.xds.XdsCredentialsProvider;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link TlsXdsCredentialsProvider}. */
+@RunWith(JUnit4.class)
+public class TlsXdsCredentialsProviderTest {
+  private TlsXdsCredentialsProvider provider = new TlsXdsCredentialsProvider();
+
+  @Test
+  public void provided() {
+    for (XdsCredentialsProvider current
+        : InternalServiceProviders.getCandidatesViaServiceLoader(
+          XdsCredentialsProvider.class, getClass().getClassLoader())) {
+      if (current instanceof TlsXdsCredentialsProvider) {
+        return;
+      }
+    }
+    fail("ServiceLoader unable to load TlsXdsCredentialsProvider");
+  }
+
+  @Test
+  public void isAvailable() {
+    assertTrue(provider.isAvailable());
+  }
+
+  @Test
+  public void channelCredentials() {
+    assertSame(TlsChannelCredentials.class,
+        provider.newChannelCredentials(null).getClass());
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/rbac/engine/GrpcAuthorizationEngineTest.java b/xds/src/test/java/io/grpc/xds/internal/rbac/engine/GrpcAuthorizationEngineTest.java
new file mode 100644
index 00000000000..10287c11262
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/rbac/engine/GrpcAuthorizationEngineTest.java
@@ -0,0 +1,417 @@
+/*
+ * Copyright 2021 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.xds.internal.rbac.engine;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.nio.charset.StandardCharsets.US_ASCII;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.io.BaseEncoding;
+import io.grpc.Attributes;
+import io.grpc.Grpc;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.MethodDescriptor.MethodType;
+import io.grpc.ServerCall;
+import io.grpc.internal.testing.TestUtils;
+import io.grpc.testing.TestMethodDescriptors;
+import io.grpc.xds.internal.Matchers;
+import io.grpc.xds.internal.Matchers.CidrMatcher;
+import io.grpc.xds.internal.Matchers.StringMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.Action;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AlwaysTrueMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AndMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AuthConfig;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AuthDecision;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AuthHeaderMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.AuthenticatedMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.DestinationIpMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.DestinationPortMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.InvertMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.OrMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.PathMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.PolicyMatcher;
+import io.grpc.xds.internal.rbac.engine.GrpcAuthorizationEngine.SourceIpMatcher;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.security.cert.X509Certificate;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+import javax.security.auth.x500.X500Principal;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class GrpcAuthorizationEngineTest {
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private static final String POLICY_NAME = "policy-name";
+  private static final String HEADER_KEY = "header-key";
+  private static final String HEADER_VALUE = "header-val";
+  private static final String IP_ADDR1 = "10.10.10.0";
+  private static final String IP_ADDR2 = "68.36.0.19";
+  private static final int PORT = 100;
+  private static final String PATH = "/auth/engine";
+  private static final StringMatcher STRING_MATCHER = StringMatcher.forExact("/" + PATH, false);
+  private static final Metadata HEADER = metadata(HEADER_KEY, HEADER_VALUE);
+
+  @Mock
+  private ServerCall<Void,Void> serverCall;
+  @Mock
+  private SSLSession sslSession;
+
+  @Before
+  public void setUp() throws Exception {
+    X509Certificate[] certs = {TestUtils.loadX509Cert("server1.pem")};
+    when(sslSession.getPeerCertificates()).thenReturn(certs);
+    Attributes attributes = Attributes.newBuilder()
+        .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, new InetSocketAddress(IP_ADDR2, PORT))
+        .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, new InetSocketAddress(IP_ADDR1, PORT))
+        .set(Grpc.TRANSPORT_ATTR_SSL_SESSION, sslSession)
+        .build();
+    when(serverCall.getAttributes()).thenReturn(attributes);
+    when(serverCall.getMethodDescriptor()).thenReturn(method().build());
+  }
+
+  @Test
+  public void ipMatcher() throws Exception {
+    CidrMatcher ip1 = CidrMatcher.create(InetAddress.getByName(IP_ADDR1), 24);
+    DestinationIpMatcher destIpMatcher = DestinationIpMatcher.create(ip1);
+    CidrMatcher ip2 = CidrMatcher.create(InetAddress.getByName(IP_ADDR2), 24);
+    SourceIpMatcher sourceIpMatcher = SourceIpMatcher.create(ip2);
+    DestinationPortMatcher portMatcher = DestinationPortMatcher.create(PORT);
+    OrMatcher permission = OrMatcher.create(AndMatcher.create(portMatcher, destIpMatcher));
+    OrMatcher principal = OrMatcher.create(sourceIpMatcher);
+    PolicyMatcher policyMatcher = PolicyMatcher.create(POLICY_NAME, permission, principal);
+
+    GrpcAuthorizationEngine engine = new GrpcAuthorizationEngine(
+        AuthConfig.create(Collections.singletonList(policyMatcher), Action.ALLOW));
+    AuthDecision decision = engine.evaluate(HEADER, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.ALLOW);
+    assertThat(decision.matchingPolicyName()).isEqualTo(POLICY_NAME);
+
+    Attributes attributes = Attributes.newBuilder()
+        .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, new InetSocketAddress(IP_ADDR2, PORT))
+        .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, new InetSocketAddress(IP_ADDR1, 2))
+        .build();
+    when(serverCall.getAttributes()).thenReturn(attributes);
+    decision = engine.evaluate(HEADER, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.DENY);
+    assertThat(decision.matchingPolicyName()).isEqualTo(null);
+
+    attributes = Attributes.newBuilder()
+        .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, null)
+        .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, new InetSocketAddress("1.1.1.1", PORT))
+        .build();
+    when(serverCall.getAttributes()).thenReturn(attributes);
+    decision = engine.evaluate(HEADER, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.DENY);
+    assertThat(decision.matchingPolicyName()).isEqualTo(null);
+
+    engine = new GrpcAuthorizationEngine(
+        AuthConfig.create(Collections.singletonList(policyMatcher), Action.DENY));
+    decision = engine.evaluate(HEADER, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.ALLOW);
+    assertThat(decision.matchingPolicyName()).isEqualTo(null);
+  }
+
+  @Test
+  public void headerMatcher() {
+    AuthHeaderMatcher headerMatcher = AuthHeaderMatcher.create(Matchers.HeaderMatcher
+        .forExactValue(HEADER_KEY, HEADER_VALUE, false));
+    OrMatcher principal = OrMatcher.create(headerMatcher);
+    OrMatcher permission = OrMatcher.create(
+        InvertMatcher.create(DestinationPortMatcher.create(PORT + 1)));
+    PolicyMatcher policyMatcher = PolicyMatcher.create(POLICY_NAME, permission, principal);
+    GrpcAuthorizationEngine engine = new GrpcAuthorizationEngine(
+        AuthConfig.create(Collections.singletonList(policyMatcher), Action.ALLOW));
+    AuthDecision decision = engine.evaluate(HEADER, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.ALLOW);
+    assertThat(decision.matchingPolicyName()).isEqualTo(POLICY_NAME);
+
+    HEADER.put(Metadata.Key.of(HEADER_KEY, Metadata.ASCII_STRING_MARSHALLER), HEADER_VALUE);
+    headerMatcher = AuthHeaderMatcher.create(Matchers.HeaderMatcher
+            .forExactValue(HEADER_KEY, HEADER_VALUE + "," + HEADER_VALUE, false));
+    principal = OrMatcher.create(headerMatcher);
+    policyMatcher = PolicyMatcher.create(POLICY_NAME,
+            OrMatcher.create(AlwaysTrueMatcher.INSTANCE), principal);
+    engine = new GrpcAuthorizationEngine(
+            AuthConfig.create(Collections.singletonList(policyMatcher), Action.ALLOW));
+    decision = engine.evaluate(HEADER, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.ALLOW);
+
+    headerMatcher = AuthHeaderMatcher.create(Matchers.HeaderMatcher
+            .forExactValue(HEADER_KEY + Metadata.BINARY_HEADER_SUFFIX, HEADER_VALUE, false));
+    principal = OrMatcher.create(headerMatcher);
+    policyMatcher = PolicyMatcher.create(POLICY_NAME,
+            OrMatcher.create(AlwaysTrueMatcher.INSTANCE), principal);
+    engine = new GrpcAuthorizationEngine(
+            AuthConfig.create(Collections.singletonList(policyMatcher), Action.ALLOW));
+    decision = engine.evaluate(HEADER, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.DENY);
+  }
+
+  @Test
+  public void headerMatcher_binaryHeader() {
+    AuthHeaderMatcher headerMatcher = AuthHeaderMatcher.create(Matchers.HeaderMatcher
+        .forExactValue(HEADER_KEY + Metadata.BINARY_HEADER_SUFFIX,
+            BaseEncoding.base64().omitPadding().encode(HEADER_VALUE.getBytes(US_ASCII)), false));
+    OrMatcher principal = OrMatcher.create(headerMatcher);
+    OrMatcher permission = OrMatcher.create(
+        InvertMatcher.create(DestinationPortMatcher.create(PORT + 1)));
+    PolicyMatcher policyMatcher = PolicyMatcher.create(POLICY_NAME, permission, principal);
+    GrpcAuthorizationEngine engine = new GrpcAuthorizationEngine(
+        AuthConfig.create(Collections.singletonList(policyMatcher), Action.ALLOW));
+    Metadata metadata = new Metadata();
+    metadata.put(Metadata.Key.of(HEADER_KEY + Metadata.BINARY_HEADER_SUFFIX,
+        Metadata.BINARY_BYTE_MARSHALLER), HEADER_VALUE.getBytes(US_ASCII));
+    AuthDecision decision = engine.evaluate(metadata, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.ALLOW);
+    assertThat(decision.matchingPolicyName()).isEqualTo(POLICY_NAME);
+  }
+
+  @Test
+  public void headerMatcher_hardcodePostMethod() {
+    AuthHeaderMatcher headerMatcher = AuthHeaderMatcher.create(Matchers.HeaderMatcher
+        .forExactValue(":method", "POST", false));
+    OrMatcher principal = OrMatcher.create(headerMatcher);
+    OrMatcher permission = OrMatcher.create(
+        InvertMatcher.create(DestinationPortMatcher.create(PORT + 1)));
+    PolicyMatcher policyMatcher = PolicyMatcher.create(POLICY_NAME, permission, principal);
+    GrpcAuthorizationEngine engine = new GrpcAuthorizationEngine(
+        AuthConfig.create(Collections.singletonList(policyMatcher), Action.ALLOW));
+    AuthDecision decision = engine.evaluate(new Metadata(), serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.ALLOW);
+    assertThat(decision.matchingPolicyName()).isEqualTo(POLICY_NAME);
+  }
+
+  @Test
+  public void headerMatcher_pathHeader() {
+    AuthHeaderMatcher headerMatcher = AuthHeaderMatcher.create(Matchers.HeaderMatcher
+        .forExactValue(":path", "/" + PATH, false));
+    OrMatcher principal = OrMatcher.create(headerMatcher);
+    OrMatcher permission = OrMatcher.create(
+        InvertMatcher.create(DestinationPortMatcher.create(PORT + 1)));
+    PolicyMatcher policyMatcher = PolicyMatcher.create(POLICY_NAME, permission, principal);
+    GrpcAuthorizationEngine engine = new GrpcAuthorizationEngine(
+        AuthConfig.create(Collections.singletonList(policyMatcher), Action.ALLOW));
+    AuthDecision decision = engine.evaluate(HEADER, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.ALLOW);
+    assertThat(decision.matchingPolicyName()).isEqualTo(POLICY_NAME);
+  }
+
+  @Test
+  public void headerMatcher_aliasAuthorityAndHost() {
+    AuthHeaderMatcher headerMatcher = AuthHeaderMatcher.create(Matchers.HeaderMatcher
+        .forExactValue("Host", "google.com", false));
+    OrMatcher principal = OrMatcher.create(headerMatcher);
+    OrMatcher permission = OrMatcher.create(
+        InvertMatcher.create(DestinationPortMatcher.create(PORT + 1)));
+    PolicyMatcher policyMatcher = PolicyMatcher.create(POLICY_NAME, permission, principal);
+    GrpcAuthorizationEngine engine = new GrpcAuthorizationEngine(
+        AuthConfig.create(Collections.singletonList(policyMatcher), Action.ALLOW));
+    when(serverCall.getAuthority()).thenReturn("google.com");
+    AuthDecision decision = engine.evaluate(new Metadata(), serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.ALLOW);
+    assertThat(decision.matchingPolicyName()).isEqualTo(POLICY_NAME);
+  }
+
+  @Test
+  public void pathMatcher() {
+    PathMatcher pathMatcher = PathMatcher.create(STRING_MATCHER);
+    OrMatcher permission = OrMatcher.create(AlwaysTrueMatcher.INSTANCE);
+    OrMatcher principal = OrMatcher.create(pathMatcher);
+    PolicyMatcher policyMatcher = PolicyMatcher.create(POLICY_NAME, permission, principal);
+    GrpcAuthorizationEngine engine = new GrpcAuthorizationEngine(
+        AuthConfig.create(Collections.singletonList(policyMatcher), Action.DENY));
+    AuthDecision decision = engine.evaluate(HEADER, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.DENY);
+    assertThat(decision.matchingPolicyName()).isEqualTo(POLICY_NAME);
+  }
+
+  @Test
+  public void authenticatedMatcher() throws Exception {
+    AuthenticatedMatcher authMatcher = AuthenticatedMatcher.create(
+        StringMatcher.forExact("*.test.google.fr", false));
+    PathMatcher pathMatcher = PathMatcher.create(STRING_MATCHER);
+    OrMatcher permission = OrMatcher.create(authMatcher);
+    OrMatcher principal = OrMatcher.create(pathMatcher);
+    PolicyMatcher policyMatcher = PolicyMatcher.create(POLICY_NAME, permission, principal);
+    GrpcAuthorizationEngine engine = new GrpcAuthorizationEngine(
+        AuthConfig.create(Collections.singletonList(policyMatcher), Action.ALLOW));
+    AuthDecision decision = engine.evaluate(HEADER, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.ALLOW);
+    assertThat(decision.matchingPolicyName()).isEqualTo(POLICY_NAME);
+
+    X509Certificate[] certs = {TestUtils.loadX509Cert("badserver.pem")};
+    when(sslSession.getPeerCertificates()).thenReturn(certs);
+    decision = engine.evaluate(HEADER, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.DENY);
+    assertThat(decision.matchingPolicyName()).isEqualTo(null);
+
+    X509Certificate mockCert = mock(X509Certificate.class);
+    when(sslSession.getPeerCertificates()).thenReturn(new X509Certificate[]{mockCert});
+    assertThat(engine.evaluate(HEADER, serverCall).decision()).isEqualTo(Action.DENY);
+    when(mockCert.getSubjectX500Principal()).thenReturn(new X500Principal(""));
+    assertThat(engine.evaluate(HEADER, serverCall).decision()).isEqualTo(Action.DENY);
+    when(mockCert.getSubjectAlternativeNames()).thenReturn(Arrays.<List<?>>asList(
+        Arrays.asList(2, "*.test.google.fr")));
+    assertThat(engine.evaluate(HEADER, serverCall).decision()).isEqualTo(Action.ALLOW);
+    when(mockCert.getSubjectAlternativeNames()).thenReturn(Arrays.<List<?>>asList(
+        Arrays.asList(6, "*.test.google.fr")));
+    assertThat(engine.evaluate(HEADER, serverCall).decision()).isEqualTo(Action.ALLOW);
+    when(mockCert.getSubjectAlternativeNames()).thenReturn(Arrays.<List<?>>asList(
+        Arrays.asList(10, "*.test.google.fr")));
+    assertThat(engine.evaluate(HEADER, serverCall).decision()).isEqualTo(Action.DENY);
+    when(mockCert.getSubjectAlternativeNames()).thenReturn(Arrays.<List<?>>asList(
+        Arrays.asList(2, "google.com"), Arrays.asList(6, "*.test.google.fr")));
+    assertThat(engine.evaluate(HEADER, serverCall).decision()).isEqualTo(Action.ALLOW);
+    when(mockCert.getSubjectAlternativeNames()).thenReturn(Arrays.<List<?>>asList(
+        Arrays.asList(6, "*.test.google.fr"), Arrays.asList(2, "google.com")));
+    assertThat(engine.evaluate(HEADER, serverCall).decision()).isEqualTo(Action.ALLOW);
+    when(mockCert.getSubjectAlternativeNames()).thenReturn(Arrays.<List<?>>asList(
+        Arrays.asList(2, "*.test.google.fr"), Arrays.asList(6, "google.com")));
+    assertThat(engine.evaluate(HEADER, serverCall).decision()).isEqualTo(Action.DENY);
+    when(mockCert.getSubjectAlternativeNames()).thenReturn(Arrays.<List<?>>asList(
+        Arrays.asList(2, "*.test.google.fr"), Arrays.asList(6, "google.com"),
+        Arrays.asList(6, "*.test.google.fr")));
+    assertThat(engine.evaluate(HEADER, serverCall).decision()).isEqualTo(Action.ALLOW);
+
+    // match any authenticated connection if StringMatcher not set in AuthenticatedMatcher
+    permission = OrMatcher.create(AuthenticatedMatcher.create(null));
+    policyMatcher = PolicyMatcher.create(POLICY_NAME, permission, principal);
+    when(mockCert.getSubjectAlternativeNames()).thenReturn(
+            Arrays.<List<?>>asList(Arrays.asList(6, "random")));
+    engine = new GrpcAuthorizationEngine(AuthConfig.create(Collections.singletonList(policyMatcher),
+            Action.ALLOW));
+    assertThat(engine.evaluate(HEADER, serverCall).decision()).isEqualTo(Action.ALLOW);
+
+    // not match any unauthenticated connection
+    Attributes attributes = Attributes.newBuilder()
+            .set(Grpc.TRANSPORT_ATTR_REMOTE_ADDR, new InetSocketAddress(IP_ADDR2, PORT))
+            .set(Grpc.TRANSPORT_ATTR_LOCAL_ADDR, new InetSocketAddress(IP_ADDR1, PORT))
+            .build();
+    when(serverCall.getAttributes()).thenReturn(attributes);
+    assertThat(engine.evaluate(HEADER, serverCall).decision()).isEqualTo(Action.DENY);
+
+    doThrow(new SSLPeerUnverifiedException("bad")).when(sslSession).getPeerCertificates();
+    decision = engine.evaluate(HEADER, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.DENY);
+    assertThat(decision.matchingPolicyName()).isEqualTo(null);
+  }
+
+  @Test
+  public void multiplePolicies() throws Exception {
+    AuthenticatedMatcher authMatcher = AuthenticatedMatcher.create(
+        StringMatcher.forSuffix("TEST.google.fr", true));
+    PathMatcher pathMatcher = PathMatcher.create(STRING_MATCHER);
+    OrMatcher principal = OrMatcher.create(AndMatcher.create(authMatcher, pathMatcher));
+    OrMatcher permission = OrMatcher.create(AndMatcher.create(pathMatcher,
+        InvertMatcher.create(DestinationPortMatcher.create(PORT + 1))));
+    PolicyMatcher policyMatcher1 = PolicyMatcher.create(POLICY_NAME, permission, principal);
+
+    AuthHeaderMatcher headerMatcher = AuthHeaderMatcher.create(Matchers.HeaderMatcher
+        .forExactValue(HEADER_KEY, HEADER_VALUE + 1, false));
+    authMatcher = AuthenticatedMatcher.create(
+        StringMatcher.forContains("TEST.google.fr"));
+    principal = OrMatcher.create(headerMatcher, authMatcher);
+    CidrMatcher ip1 = CidrMatcher.create(InetAddress.getByName(IP_ADDR1), 24);
+    DestinationIpMatcher destIpMatcher = DestinationIpMatcher.create(ip1);
+    permission = OrMatcher.create(destIpMatcher, pathMatcher);
+    PolicyMatcher policyMatcher2 = PolicyMatcher.create(POLICY_NAME + "-2", permission, principal);
+
+    GrpcAuthorizationEngine engine = new GrpcAuthorizationEngine(
+        AuthConfig.create(ImmutableList.of(policyMatcher1, policyMatcher2), Action.DENY));
+    AuthDecision decision = engine.evaluate(HEADER, serverCall);
+    assertThat(decision.decision()).isEqualTo(Action.DENY);
+    assertThat(decision.matchingPolicyName()).isEqualTo(POLICY_NAME);
+  }
+
+  @Test
+  public void matchersEqualHashcode() throws Exception {
+    PathMatcher pathMatcher = PathMatcher.create(STRING_MATCHER);
+    AuthHeaderMatcher headerMatcher = AuthHeaderMatcher.create(
+        Matchers.HeaderMatcher.forExactValue("foo", "bar", true));
+    DestinationIpMatcher destinationIpMatcher = DestinationIpMatcher.create(
+        CidrMatcher.create(InetAddress.getByName(IP_ADDR1), 24));
+    DestinationPortMatcher destinationPortMatcher = DestinationPortMatcher.create(PORT);
+    GrpcAuthorizationEngine.DestinationPortRangeMatcher portRangeMatcher =
+        GrpcAuthorizationEngine.DestinationPortRangeMatcher.create(PORT, PORT + 1);
+    InvertMatcher invertMatcher = InvertMatcher.create(portRangeMatcher);
+    GrpcAuthorizationEngine.RequestedServerNameMatcher requestedServerNameMatcher =
+        GrpcAuthorizationEngine.RequestedServerNameMatcher.create(STRING_MATCHER);
+    OrMatcher permission = OrMatcher.create(pathMatcher, headerMatcher, destinationIpMatcher,
+        destinationPortMatcher, invertMatcher, requestedServerNameMatcher);
+    AuthenticatedMatcher authenticatedMatcher = AuthenticatedMatcher.create(STRING_MATCHER);
+    SourceIpMatcher sourceIpMatcher1 = SourceIpMatcher.create(
+        CidrMatcher.create(InetAddress.getByName(IP_ADDR1), 24));
+    OrMatcher principal = OrMatcher.create(authenticatedMatcher,
+        AndMatcher.create(sourceIpMatcher1, AlwaysTrueMatcher.INSTANCE));
+    PolicyMatcher policyMatcher1 = PolicyMatcher.create("match", permission, principal);
+    AuthConfig config1 = AuthConfig.create(Collections.singletonList(policyMatcher1), Action.ALLOW);
+
+    PathMatcher pathMatcher2 = PathMatcher.create(STRING_MATCHER);
+    AuthHeaderMatcher headerMatcher2 = AuthHeaderMatcher.create(
+        Matchers.HeaderMatcher.forExactValue("foo", "bar", true));
+    DestinationIpMatcher destinationIpMatcher2 = DestinationIpMatcher.create(
+        CidrMatcher.create(InetAddress.getByName(IP_ADDR1), 24));
+    DestinationPortMatcher destinationPortMatcher2 = DestinationPortMatcher.create(PORT);
+    GrpcAuthorizationEngine.DestinationPortRangeMatcher portRangeMatcher2 =
+        GrpcAuthorizationEngine.DestinationPortRangeMatcher.create(PORT, PORT + 1);
+    InvertMatcher invertMatcher2 = InvertMatcher.create(portRangeMatcher2);
+    GrpcAuthorizationEngine.RequestedServerNameMatcher requestedServerNameMatcher2 =
+        GrpcAuthorizationEngine.RequestedServerNameMatcher.create(STRING_MATCHER);
+    OrMatcher permission2 = OrMatcher.create(pathMatcher2, headerMatcher2, destinationIpMatcher2,
+        destinationPortMatcher2, invertMatcher2, requestedServerNameMatcher2);
+    AuthenticatedMatcher authenticatedMatcher2 = AuthenticatedMatcher.create(STRING_MATCHER);
+    SourceIpMatcher sourceIpMatcher2 = SourceIpMatcher.create(
+        CidrMatcher.create(InetAddress.getByName(IP_ADDR1), 24));
+    OrMatcher principal2 = OrMatcher.create(authenticatedMatcher2,
+        AndMatcher.create(sourceIpMatcher2, AlwaysTrueMatcher.INSTANCE));
+    PolicyMatcher policyMatcher2 = PolicyMatcher.create("match", permission2, principal2);
+    AuthConfig config2 = AuthConfig.create(Collections.singletonList(policyMatcher2), Action.ALLOW);
+    assertThat(config1).isEqualTo(config2);
+    assertThat(config1.hashCode()).isEqualTo(config2.hashCode());
+  }
+
+  private MethodDescriptor.Builder<Void, Void> method() {
+    return MethodDescriptor.<Void,Void>newBuilder()
+            .setType(MethodType.BIDI_STREAMING)
+            .setFullMethodName(PATH)
+            .setRequestMarshaller(TestMethodDescriptors.voidMarshaller())
+            .setResponseMarshaller(TestMethodDescriptors.voidMarshaller());
+  }
+
+  private static Metadata metadata(String key, String value) {
+    Metadata metadata = new Metadata();
+    metadata.put(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER), value);
+    return metadata;
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/ClientSslContextProviderFactoryTest.java b/xds/src/test/java/io/grpc/xds/internal/security/ClientSslContextProviderFactoryTest.java
new file mode 100644
index 00000000000..a0eac581d5c
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/ClientSslContextProviderFactoryTest.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright 2019 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.xds.internal.security;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableSet;
+import io.envoyproxy.envoy.config.core.v3.DataSource;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.TlsCertificate;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.CommonBootstrapperTestUtils;
+import io.grpc.xds.client.XdsInitializationException;
+import io.grpc.xds.internal.security.certprovider.CertProviderClientSslContextProviderFactory;
+import io.grpc.xds.internal.security.certprovider.CertificateProvider;
+import io.grpc.xds.internal.security.certprovider.CertificateProviderProvider;
+import io.grpc.xds.internal.security.certprovider.CertificateProviderRegistry;
+import io.grpc.xds.internal.security.certprovider.CertificateProviderStore;
+import io.grpc.xds.internal.security.certprovider.IgnoreUpdatesWatcher;
+import io.grpc.xds.internal.security.certprovider.TestCertificateProvider;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+/** Unit tests for {@link ClientSslContextProviderFactory}. */
+@RunWith(JUnit4.class)
+public class ClientSslContextProviderFactoryTest {
+
+  CertificateProviderRegistry certificateProviderRegistry;
+  CertificateProviderStore certificateProviderStore;
+  CertProviderClientSslContextProviderFactory certProviderClientSslContextProviderFactory;
+  ClientSslContextProviderFactory clientSslContextProviderFactory;
+
+  @Before
+  public void setUp() {
+    certificateProviderRegistry = new CertificateProviderRegistry();
+    certificateProviderStore = new CertificateProviderStore(certificateProviderRegistry);
+    certProviderClientSslContextProviderFactory =
+        new CertProviderClientSslContextProviderFactory(certificateProviderStore);
+  }
+
+  @Test
+  public void createCertProviderClientSslContextProvider() throws XdsInitializationException {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
+    UpstreamTlsContext upstreamTlsContext =
+        CommonTlsContextTestsUtil.buildUpstreamTlsContextForCertProviderInstance(
+            "gcp_id",
+            "cert-default",
+            "gcp_id",
+            "root-default",
+            /* alpnProtocols= */ null,
+            /* staticCertValidationContext= */ null);
+
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    clientSslContextProviderFactory =
+            new ClientSslContextProviderFactory(
+                    bootstrapInfo, certProviderClientSslContextProviderFactory);
+    SslContextProvider sslContextProvider =
+        clientSslContextProviderFactory.create(upstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderClientSslContextProvider");
+    verifyWatcher(sslContextProvider, watcherCaptor[0], false);
+    // verify that bootstrapInfo is cached...
+    sslContextProvider =
+        clientSslContextProviderFactory.create(upstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderClientSslContextProvider");
+  }
+
+  @Test
+  public void bothPresent_expectCertProviderClientSslContextProvider()
+      throws XdsInitializationException {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
+    UpstreamTlsContext upstreamTlsContext =
+        CommonTlsContextTestsUtil.buildUpstreamTlsContextForCertProviderInstance(
+            "gcp_id",
+            "cert-default",
+            "gcp_id",
+            "root-default",
+            /* alpnProtocols= */ null,
+            /* staticCertValidationContext= */ null);
+
+    CommonTlsContext.Builder builder = upstreamTlsContext.getCommonTlsContext().toBuilder();
+    builder = addFilenames(builder, "foo.pem", "foo.key", "root.pem");
+    upstreamTlsContext = new UpstreamTlsContext(builder.build());
+
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    clientSslContextProviderFactory =
+            new ClientSslContextProviderFactory(
+                    bootstrapInfo, certProviderClientSslContextProviderFactory);
+    SslContextProvider sslContextProvider =
+        clientSslContextProviderFactory.create(upstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderClientSslContextProvider");
+    verifyWatcher(sslContextProvider, watcherCaptor[0], true);
+  }
+
+  @Test
+  public void createCertProviderClientSslContextProvider_onlyRootCert()
+      throws XdsInitializationException {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+            new CertificateProvider.DistributorWatcher[1];
+    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
+    UpstreamTlsContext upstreamTlsContext =
+            CommonTlsContextTestsUtil.buildUpstreamTlsContextForCertProviderInstance(
+                    /* certInstanceName= */ null,
+                    /* certName= */ null,
+                    "gcp_id",
+                    "root-default",
+                    /* alpnProtocols= */ null,
+                    /* staticCertValidationContext= */ null);
+
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    clientSslContextProviderFactory =
+            new ClientSslContextProviderFactory(
+                    bootstrapInfo, certProviderClientSslContextProviderFactory);
+    SslContextProvider sslContextProvider =
+            clientSslContextProviderFactory.create(upstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderClientSslContextProvider");
+    verifyWatcher(sslContextProvider, watcherCaptor[0], true);
+  }
+
+  @Test
+  public void createCertProviderClientSslContextProvider_withStaticContext()
+      throws XdsInitializationException {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+            new CertificateProvider.DistributorWatcher[1];
+    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
+    @SuppressWarnings("deprecation")
+    CertificateValidationContext staticCertValidationContext =
+        CertificateValidationContext.newBuilder()
+            .addAllMatchSubjectAltNames(
+                ImmutableSet.of(
+                    StringMatcher.newBuilder().setExact("foo").build(),
+                    StringMatcher.newBuilder().setExact("bar").build()))
+            .build();
+    UpstreamTlsContext upstreamTlsContext =
+            CommonTlsContextTestsUtil.buildUpstreamTlsContextForCertProviderInstance(
+                    /* certInstanceName= */ null,
+                    /* certName= */ null,
+                    "gcp_id",
+                    "root-default",
+                    /* alpnProtocols= */ null,
+                    staticCertValidationContext);
+
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    clientSslContextProviderFactory =
+            new ClientSslContextProviderFactory(bootstrapInfo,
+                    certProviderClientSslContextProviderFactory);
+    SslContextProvider sslContextProvider =
+            clientSslContextProviderFactory.create(upstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderClientSslContextProvider");
+    verifyWatcher(sslContextProvider, watcherCaptor[0], true);
+  }
+
+  @Test
+  public void createCertProviderClientSslContextProvider_2providers()
+      throws XdsInitializationException {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[2];
+    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
+
+    createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "file_watcher", 1);
+
+    UpstreamTlsContext upstreamTlsContext =
+        CommonTlsContextTestsUtil.buildUpstreamTlsContextForCertProviderInstance(
+            "gcp_id",
+            "cert-default",
+            "file_provider",
+            "root-default",
+            /* alpnProtocols= */ null,
+            /* staticCertValidationContext= */ null);
+
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    clientSslContextProviderFactory =
+            new ClientSslContextProviderFactory(
+                    bootstrapInfo, certProviderClientSslContextProviderFactory);
+    SslContextProvider sslContextProvider =
+        clientSslContextProviderFactory.create(upstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderClientSslContextProvider");
+    verifyWatcher(sslContextProvider, watcherCaptor[0], true);
+    verifyWatcher(sslContextProvider, watcherCaptor[1], true);
+  }
+
+  @Test
+  public void createNewCertProviderClientSslContextProvider_withSans() {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[2];
+    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
+    createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "file_watcher", 1);
+
+    @SuppressWarnings("deprecation")
+    CertificateValidationContext staticCertValidationContext =
+        CertificateValidationContext.newBuilder()
+            .addAllMatchSubjectAltNames(
+                ImmutableSet.of(
+                    StringMatcher.newBuilder().setExact("foo").build(),
+                    StringMatcher.newBuilder().setExact("bar").build()))
+            .build();
+    UpstreamTlsContext upstreamTlsContext =
+        CommonTlsContextTestsUtil.buildNewUpstreamTlsContextForCertProviderInstance(
+            "gcp_id",
+            "cert-default",
+            "file_provider",
+            "root-default",
+            /* alpnProtocols= */ null,
+            staticCertValidationContext);
+
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    clientSslContextProviderFactory =
+        new ClientSslContextProviderFactory(
+            bootstrapInfo, certProviderClientSslContextProviderFactory);
+    SslContextProvider sslContextProvider =
+        clientSslContextProviderFactory.create(upstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderClientSslContextProvider");
+    verifyWatcher(sslContextProvider, watcherCaptor[0], true);
+    verifyWatcher(sslContextProvider, watcherCaptor[1], true);
+  }
+
+  @Test
+  public void createNewCertProviderClientSslContextProvider_onlyRootCert() {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
+    @SuppressWarnings("deprecation")
+    CertificateValidationContext staticCertValidationContext =
+        CertificateValidationContext.newBuilder()
+            .addAllMatchSubjectAltNames(
+                ImmutableSet.of(
+                    StringMatcher.newBuilder().setExact("foo").build(),
+                    StringMatcher.newBuilder().setExact("bar").build()))
+            .build();
+    UpstreamTlsContext upstreamTlsContext =
+        CommonTlsContextTestsUtil.buildNewUpstreamTlsContextForCertProviderInstance(
+            /* certInstanceName= */ null,
+            /* certName= */ null,
+            "gcp_id",
+            "root-default",
+            /* alpnProtocols= */ null,
+            staticCertValidationContext);
+
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    clientSslContextProviderFactory =
+        new ClientSslContextProviderFactory(
+            bootstrapInfo, certProviderClientSslContextProviderFactory);
+    SslContextProvider sslContextProvider =
+        clientSslContextProviderFactory.create(upstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderClientSslContextProvider");
+    verifyWatcher(sslContextProvider, watcherCaptor[0], true);
+  }
+
+  static void createAndRegisterProviderProvider(
+      CertificateProviderRegistry certificateProviderRegistry,
+      final CertificateProvider.DistributorWatcher[] watcherCaptor,
+      String testca,
+      final int i) {
+    final CertificateProviderProvider mockProviderProviderTestCa =
+        mock(CertificateProviderProvider.class);
+    when(mockProviderProviderTestCa.getName()).thenReturn(testca);
+
+    when(mockProviderProviderTestCa.createCertificateProvider(
+            any(Object.class), any(CertificateProvider.DistributorWatcher.class), eq(true)))
+        .thenAnswer(
+            new Answer<CertificateProvider>() {
+              @Override
+              public CertificateProvider answer(InvocationOnMock invocation) throws Throwable {
+                Object[] args = invocation.getArguments();
+                CertificateProvider.DistributorWatcher watcher =
+                    (CertificateProvider.DistributorWatcher) args[1];
+                watcherCaptor[i] = watcher;
+                return new TestCertificateProvider(
+                    watcher, true, args[0], mockProviderProviderTestCa, false);
+              }
+            });
+    certificateProviderRegistry.register(mockProviderProviderTestCa);
+  }
+
+  static void verifyWatcher(
+      SslContextProvider sslContextProvider, CertificateProvider.DistributorWatcher watcherCaptor,
+      boolean usesDelegateWatcher) {
+    assertThat(watcherCaptor).isNotNull();
+    assertThat(watcherCaptor.getDownstreamWatchers()).hasSize(1);
+    if (usesDelegateWatcher) {
+      assertThat(((IgnoreUpdatesWatcher) watcherCaptor.getDownstreamWatchers().iterator().next())
+          .getDelegate())
+          .isSameInstanceAs(sslContextProvider);
+    } else {
+      assertThat(watcherCaptor.getDownstreamWatchers().iterator().next())
+          .isSameInstanceAs(sslContextProvider);
+    }
+  }
+
+  static CommonTlsContext.Builder addFilenames(
+      CommonTlsContext.Builder builder, String certChain, String privateKey, String trustCa) {
+    TlsCertificate tlsCert =
+        TlsCertificate.newBuilder()
+            .setCertificateChain(DataSource.newBuilder().setFilename(certChain))
+            .setPrivateKey(DataSource.newBuilder().setFilename(privateKey))
+            .build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder()
+            .setTrustedCa(DataSource.newBuilder().setFilename(trustCa))
+            .build();
+    CommonTlsContext.CombinedCertificateValidationContext.Builder combinedBuilder =
+        CommonTlsContext.CombinedCertificateValidationContext.newBuilder();
+    combinedBuilder
+        .setDefaultValidationContext(certContext);
+    return builder
+        .addTlsCertificates(tlsCert)
+        .setCombinedValidationContext(combinedBuilder.build());
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/CommonTlsContextTestsUtil.java b/xds/src/test/java/io/grpc/xds/internal/security/CommonTlsContextTestsUtil.java
new file mode 100644
index 00000000000..abacd2038f8
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/CommonTlsContextTestsUtil.java
@@ -0,0 +1,486 @@
+/*
+ * 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.xds.internal.security;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.BoolValue;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateProviderPluginInstance;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext.CombinedCertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import io.grpc.internal.testing.TestUtils;
+import io.grpc.testing.TlsTesting;
+import io.grpc.util.CertificateUtils;
+import io.grpc.xds.EnvoyServerProtoData;
+import io.netty.handler.ssl.SslContext;
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.AbstractMap;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.Executor;
+import javax.annotation.Nullable;
+import javax.net.ssl.X509TrustManager;
+
+/** Utility class for client and server ssl provider tests. */
+public class CommonTlsContextTestsUtil {
+
+  public static final String SERVER_0_PEM_FILE = "server0.pem";
+  public static final String SERVER_0_KEY_FILE = "server0.key";
+  public static final String SERVER_1_PEM_FILE = "server1.pem";
+  public static final String SERVER_1_SPIFFE_PEM_FILE = "server1_spiffe.pem";
+  public static final String SERVER_1_KEY_FILE = "server1.key";
+  public static final String CLIENT_PEM_FILE = "client.pem";
+  public static final String CLIENT_SPIFFE_PEM_FILE = "client_spiffe.pem";
+  public static final String CLIENT_KEY_FILE = "client.key";
+  public static final String CA_PEM_FILE = "ca.pem";
+  public static final String SPIFFE_TRUST_MAP_FILE = "spiffebundle.json";
+  public static final String SPIFFE_TRUST_MAP_1_FILE = "spiffebundle1.json";
+  /** Bad/untrusted server certs. */
+  public static final String BAD_SERVER_PEM_FILE = "badserver.pem";
+  public static final String BAD_SERVER_KEY_FILE = "badserver.key";
+  public static final String BAD_CLIENT_PEM_FILE = "badclient.pem";
+  public static final String BAD_CLIENT_KEY_FILE = "badclient.key";
+  public static final String BAD_WILDCARD_DNS_PEM_FILE =
+      "sni-test-certs/bad_wildcard_dns_certificate.pem";
+
+  /** takes additional values and creates CombinedCertificateValidationContext as needed. */
+  private static CommonTlsContext buildCommonTlsContextWithAdditionalValues(
+      String certInstanceName, String certName,
+      String validationContextCertInstanceName, String validationContextCertName,
+      Iterable<StringMatcher> matchSubjectAltNames,
+      Iterable<String> alpnNames) {
+    @SuppressWarnings("deprecation") // gRFC A29 predates match_typed_subject_alt_names
+    CertificateValidationContext.Builder certificateValidationContextBuilder
+        = CertificateValidationContext.newBuilder()
+        .addAllMatchSubjectAltNames(matchSubjectAltNames);
+    return CommonTlsContext.newBuilder()
+        .setTlsCertificateProviderInstance(CertificateProviderPluginInstance.newBuilder()
+          .setInstanceName(certInstanceName)
+          .setCertificateName(certName))
+        .setCombinedValidationContext(CombinedCertificateValidationContext.newBuilder()
+          .setDefaultValidationContext(certificateValidationContextBuilder
+            .setCaCertificateProviderInstance(CertificateProviderPluginInstance.newBuilder()
+              .setInstanceName(validationContextCertInstanceName)
+              .setCertificateName(validationContextCertName))))
+        .addAllAlpnProtocols(alpnNames)
+        .build();
+  }
+
+  /** Helper method to build DownstreamTlsContext for multiple test classes. */
+  static DownstreamTlsContext buildDownstreamTlsContext(
+      CommonTlsContext commonTlsContext, boolean requireClientCert) {
+    DownstreamTlsContext.Builder downstreamTlsContextBuilder =
+        DownstreamTlsContext.newBuilder()
+            .setRequireClientCertificate(BoolValue.of(requireClientCert));
+    if (commonTlsContext != null) {
+      downstreamTlsContextBuilder = downstreamTlsContextBuilder
+          .setCommonTlsContext(commonTlsContext);
+    }
+    return downstreamTlsContextBuilder.build();
+  }
+
+  /** Helper method to build DownstreamTlsContext for multiple test classes. */
+  public static EnvoyServerProtoData.DownstreamTlsContext buildDownstreamTlsContext(
+      String commonInstanceName, boolean hasRootCert,
+      boolean requireClientCertificate) {
+    return buildDownstreamTlsContextForCertProviderInstance(
+        commonInstanceName,
+        "default",
+        hasRootCert ? commonInstanceName : null,
+        hasRootCert ? "ROOT" : null,
+        /* alpnProtocols= */ null,
+        /* staticCertValidationContext= */ null,
+        /* requireClientCert= */ requireClientCertificate);
+  }
+
+  /** Helper method to build internal DownstreamTlsContext for multiple test classes. */
+  static EnvoyServerProtoData.DownstreamTlsContext buildInternalDownstreamTlsContext(
+      CommonTlsContext commonTlsContext, boolean requireClientCert) {
+    return EnvoyServerProtoData.DownstreamTlsContext.fromEnvoyProtoDownstreamTlsContext(
+        buildDownstreamTlsContext(commonTlsContext, requireClientCert));
+  }
+
+  /** Helper method for creating DownstreamTlsContext values with names. */
+  public static DownstreamTlsContext buildTestDownstreamTlsContext(
+      String certName, String validationContextCertName, boolean useSans) {
+    CommonTlsContext commonTlsContext = null;
+    if (certName != null || validationContextCertName != null || useSans) {
+      commonTlsContext = buildCommonTlsContextWithAdditionalValues(
+          "cert-instance-name", certName,
+          "cert-instance-name", validationContextCertName,
+          useSans ? Arrays.asList(
+              StringMatcher.newBuilder()
+                  .setExact("spiffe://grpc-sds-testing.svc.id.goog/ns/default/sa/bob")
+                  .build()) : Arrays.asList(),
+          Arrays.asList("managed-tls"));
+    }
+    return buildDownstreamTlsContext(commonTlsContext, /* requireClientCert= */ false);
+  }
+
+  public static EnvoyServerProtoData.DownstreamTlsContext buildTestInternalDownstreamTlsContext(
+      String certName, String validationContextName) {
+    return EnvoyServerProtoData.DownstreamTlsContext.fromEnvoyProtoDownstreamTlsContext(
+        buildTestDownstreamTlsContext(certName, validationContextName, true));
+  }
+
+  public static String getTempFileNameForResourcesFile(String resFile) throws IOException {
+    return TestUtils.loadCert(resFile).getAbsolutePath();
+  }
+
+  /**
+   * Helper method to build UpstreamTlsContext for above tests. Called from other classes as well.
+   */
+  static EnvoyServerProtoData.UpstreamTlsContext buildUpstreamTlsContext(
+        CommonTlsContext commonTlsContext) {
+    return buildUpstreamTlsContext(commonTlsContext, "", false, false);
+  }
+
+  /**
+   * Helper method to build UpstreamTlsContext with SNI info.
+   */
+  static EnvoyServerProtoData.UpstreamTlsContext buildUpstreamTlsContext(
+        CommonTlsContext commonTlsContext, String sni, boolean autoHostSni,
+        boolean autoSniSanValidation) {
+    UpstreamTlsContext.Builder upstreamTlsContext =
+        UpstreamTlsContext.newBuilder()
+            .setCommonTlsContext(commonTlsContext)
+            .setAutoHostSni(autoHostSni)
+            .setAutoSniSanValidation(autoSniSanValidation)
+            .setSni(sni);
+    return EnvoyServerProtoData.UpstreamTlsContext.fromEnvoyProtoUpstreamTlsContext(
+        upstreamTlsContext.build());
+  }
+
+  /** Helper method to build UpstreamTlsContext for multiple test classes. */
+  public static EnvoyServerProtoData.UpstreamTlsContext buildUpstreamTlsContext(
+      String commonInstanceName, boolean hasIdentityCert) {
+    return buildUpstreamTlsContextForCertProviderInstance(
+        hasIdentityCert ? commonInstanceName : null,
+        hasIdentityCert ? "default" : null,
+        commonInstanceName,
+        "ROOT",
+        null,
+        null);
+  }
+
+  /** Helper method to build UpstreamTlsContext with SNI info. */
+  public static EnvoyServerProtoData.UpstreamTlsContext buildUpstreamTlsContext(
+      String commonInstanceName, boolean hasIdentityCert, String sni, boolean autoHostSni) {
+    return buildUpstreamTlsContextForCertProviderInstance(
+        hasIdentityCert ? commonInstanceName : null,
+        hasIdentityCert ? "default" : null,
+        commonInstanceName,
+        "ROOT",
+        null,
+        null,
+        sni,
+        autoHostSni,
+        false);
+  }
+
+  /** Gets a cert from contents of a resource. */
+  public static X509Certificate getCertFromResourceName(String resourceName)
+      throws IOException, CertificateException {
+    try (InputStream cert = TlsTesting.loadCert(resourceName)) {
+      return CertificateUtils.getX509Certificates(cert)[0];
+    }
+  }
+
+  private static CommonTlsContext buildCommonTlsContextForCertProviderInstance(
+      String certInstanceName,
+      String certName,
+      String rootInstanceName,
+      String rootCertName,
+      Iterable<String> alpnProtocols,
+      CertificateValidationContext staticCertValidationContext) {
+    CommonTlsContext.Builder builder = CommonTlsContext.newBuilder();
+    if (certInstanceName != null) {
+      builder =
+              builder.setTlsCertificateProviderInstance(
+                      CertificateProviderPluginInstance.newBuilder()
+                              .setInstanceName(certInstanceName)
+                              .setCertificateName(certName));
+    }
+    builder =
+        addCertificateValidationContext(
+            builder, rootInstanceName, rootCertName, staticCertValidationContext);
+    if (alpnProtocols != null) {
+      builder.addAllAlpnProtocols(alpnProtocols);
+    }
+    return builder.build();
+  }
+
+  /** Helper method to build CommonTlsContext using deprecated certificate provider field. */
+  @SuppressWarnings("deprecation")
+  public static CommonTlsContext buildCommonTlsContextWithDeprecatedCertProviderInstance(
+      String certInstanceName,
+      String certName,
+      String rootInstanceName,
+      String rootCertName,
+      Iterable<String> alpnProtocols,
+      CertificateValidationContext staticCertValidationContext) {
+    CommonTlsContext.Builder builder = CommonTlsContext.newBuilder();
+    if (certInstanceName != null) {
+      // Use deprecated field (field 11) instead of current field (field 14)
+      builder =
+              builder.setTlsCertificateCertificateProviderInstance(
+                      CommonTlsContext.CertificateProviderInstance.newBuilder()
+                              .setInstanceName(certInstanceName)
+                              .setCertificateName(certName));
+    }
+    builder =
+        addCertificateValidationContext(
+            builder, rootInstanceName, rootCertName, staticCertValidationContext);
+    if (alpnProtocols != null) {
+      builder.addAllAlpnProtocols(alpnProtocols);
+    }
+    return builder.build();
+  }
+
+  private static CommonTlsContext buildNewCommonTlsContextForCertProviderInstance(
+          String certInstanceName,
+          String certName,
+          String rootInstanceName,
+          String rootCertName,
+          Iterable<String> alpnProtocols,
+          CertificateValidationContext staticCertValidationContext) {
+    CommonTlsContext.Builder builder = CommonTlsContext.newBuilder();
+    if (certInstanceName != null) {
+      builder =
+              builder.setTlsCertificateProviderInstance(
+                      CertificateProviderPluginInstance.newBuilder()
+                              .setInstanceName(certInstanceName)
+                              .setCertificateName(certName));
+    }
+    builder =
+            addNewCertificateValidationContext(
+                    builder, rootInstanceName, rootCertName, staticCertValidationContext);
+    if (alpnProtocols != null) {
+      builder.addAllAlpnProtocols(alpnProtocols);
+    }
+    return builder.build();
+  }
+
+  private static CommonTlsContext.Builder addCertificateValidationContext(
+      CommonTlsContext.Builder builder,
+      String rootInstanceName,
+      String rootCertName,
+      CertificateValidationContext staticCertValidationContext) {
+    if (staticCertValidationContext == null && rootInstanceName == null) {
+      return builder;
+    }
+    CertificateValidationContext.Builder contextBuilder;
+    if (staticCertValidationContext == null) {
+      contextBuilder = CertificateValidationContext.newBuilder();
+    } else {
+      contextBuilder = staticCertValidationContext.toBuilder();
+    }
+    if (rootInstanceName != null) {
+      contextBuilder.setCaCertificateProviderInstance(CertificateProviderPluginInstance.newBuilder()
+          .setInstanceName(rootInstanceName)
+          .setCertificateName(rootCertName));
+      builder.setValidationContext(contextBuilder.build());
+    }
+    return builder.setCombinedValidationContext(CombinedCertificateValidationContext.newBuilder()
+        .setDefaultValidationContext(contextBuilder));
+  }
+
+  private static CommonTlsContext.Builder addNewCertificateValidationContext(
+          CommonTlsContext.Builder builder,
+          String rootInstanceName,
+          String rootCertName,
+          CertificateValidationContext staticCertValidationContext) {
+    CertificateValidationContext.Builder validationContextBuilder =
+        staticCertValidationContext != null ? staticCertValidationContext.toBuilder()
+            : CertificateValidationContext.newBuilder();
+    if (rootInstanceName != null) {
+      CertificateProviderPluginInstance providerInstance =
+          CertificateProviderPluginInstance.newBuilder()
+              .setInstanceName(rootInstanceName)
+              .setCertificateName(rootCertName)
+              .build();
+      validationContextBuilder = validationContextBuilder.setCaCertificateProviderInstance(
+          providerInstance);
+    }
+    return builder.setValidationContext(validationContextBuilder);
+  }
+
+  /** Helper method to build UpstreamTlsContext for CertProvider tests. */
+  public static EnvoyServerProtoData.UpstreamTlsContext
+      buildUpstreamTlsContextForCertProviderInstance(
+          @Nullable String certInstanceName,
+          @Nullable String certName,
+          @Nullable String rootInstanceName,
+          @Nullable String rootCertName,
+          Iterable<String> alpnProtocols,
+          CertificateValidationContext staticCertValidationContext) {
+    return buildUpstreamTlsContext(
+        buildCommonTlsContextForCertProviderInstance(
+            certInstanceName,
+            certName,
+            rootInstanceName,
+            rootCertName,
+            alpnProtocols,
+            staticCertValidationContext),
+        "", false, false);
+  }
+
+  /** Helper method to build UpstreamTlsContext with SNI info for CertProvider tests. */
+  public static EnvoyServerProtoData.UpstreamTlsContext
+      buildUpstreamTlsContextForCertProviderInstance(
+          @Nullable String certInstanceName,
+          @Nullable String certName,
+          @Nullable String rootInstanceName,
+          @Nullable String rootCertName,
+          Iterable<String> alpnProtocols,
+          CertificateValidationContext staticCertValidationContext,
+          String sni,
+          boolean autoHostSni,
+          boolean autoSniSanValidation) {
+    return buildUpstreamTlsContext(
+        buildCommonTlsContextForCertProviderInstance(
+            certInstanceName,
+            certName,
+            rootInstanceName,
+            rootCertName,
+            alpnProtocols,
+            staticCertValidationContext),
+        sni, autoHostSni, autoSniSanValidation);
+  }
+
+  /** Helper method to build UpstreamTlsContext for CertProvider tests. */
+  public static EnvoyServerProtoData.UpstreamTlsContext
+      buildNewUpstreamTlsContextForCertProviderInstance(
+          @Nullable String certInstanceName,
+          @Nullable String certName,
+          @Nullable String rootInstanceName,
+          @Nullable String rootCertName,
+          Iterable<String> alpnProtocols,
+          CertificateValidationContext staticCertValidationContext) {
+    return buildUpstreamTlsContext(
+        buildNewCommonTlsContextForCertProviderInstance(
+            certInstanceName,
+            certName,
+            rootInstanceName,
+            rootCertName,
+            alpnProtocols,
+            staticCertValidationContext),
+    "", false, false);
+  }
+
+  /** Helper method to build DownstreamTlsContext for CertProvider tests. */
+  public static EnvoyServerProtoData.DownstreamTlsContext
+      buildDownstreamTlsContextForCertProviderInstance(
+          @Nullable String certInstanceName,
+          @Nullable String certName,
+          @Nullable String rootInstanceName,
+          @Nullable String rootCertName,
+          Iterable<String> alpnProtocols,
+          CertificateValidationContext staticCertValidationContext,
+          boolean requireClientCert) {
+    return buildInternalDownstreamTlsContext(
+        buildCommonTlsContextForCertProviderInstance(
+            certInstanceName,
+            certName,
+            rootInstanceName,
+            rootCertName,
+            alpnProtocols,
+            staticCertValidationContext), requireClientCert);
+  }
+
+  /** Helper method to build DownstreamTlsContext for CertProvider tests. */
+  public static EnvoyServerProtoData.DownstreamTlsContext
+      buildNewDownstreamTlsContextForCertProviderInstance(
+          @Nullable String certInstanceName,
+          @Nullable String certName,
+          @Nullable String rootInstanceName,
+          @Nullable String rootCertName,
+          Iterable<String> alpnProtocols,
+          CertificateValidationContext staticCertValidationContext,
+          boolean requireClientCert) {
+    return buildInternalDownstreamTlsContext(
+            buildNewCommonTlsContextForCertProviderInstance(
+                    certInstanceName,
+                    certName,
+                    rootInstanceName,
+                    rootCertName,
+                    alpnProtocols,
+                    staticCertValidationContext), requireClientCert);
+  }
+
+  /** Perform some simple checks on sslContext. */
+  public static void doChecksOnSslContext(boolean server,
+      AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> sslContextAndTm,
+      List<String> expectedApnProtos) {
+    if (server) {
+      assertThat(sslContextAndTm.getKey().isServer()).isTrue();
+    } else {
+      assertThat(sslContextAndTm.getKey().isClient()).isTrue();
+    }
+    List<String> apnProtos = sslContextAndTm.getKey().applicationProtocolNegotiator().protocols();
+    assertThat(apnProtos).isNotNull();
+    if (expectedApnProtos != null) {
+      assertThat(apnProtos).isEqualTo(expectedApnProtos);
+    } else {
+      assertThat(apnProtos).contains("h2");
+    }
+  }
+
+  /**
+   * Helper method to get the value thru directExecutor callback. Because of directExecutor this is
+   * a synchronous callback - so need to provide a listener.
+   */
+  public static TestCallback getValueThruCallback(SslContextProvider provider) {
+    return getValueThruCallback(provider, MoreExecutors.directExecutor());
+  }
+
+  /** Helper method to get the value thru callback with a user passed executor. */
+  public static TestCallback getValueThruCallback(SslContextProvider provider, Executor executor) {
+    TestCallback testCallback = new TestCallback(executor);
+    provider.addCallback(testCallback);
+    return testCallback;
+  }
+
+  public static class TestCallback extends SslContextProvider.Callback {
+
+    public AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> updatedSslContext;
+    public Throwable updatedThrowable;
+
+    public TestCallback(Executor executor) {
+      super(executor);
+    }
+
+    @Override
+    public void updateSslContextAndExtendedX509TrustManager(
+        AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> sslContext) {
+      updatedSslContext = sslContext;
+    }
+
+    @Override
+    public void onException(Throwable throwable) {
+      updatedThrowable = throwable;
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/ReferenceCountingMapTest.java b/xds/src/test/java/io/grpc/xds/internal/security/ReferenceCountingMapTest.java
new file mode 100644
index 00000000000..d54a61b5510
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/ReferenceCountingMapTest.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2019 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.xds.internal.security;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.grpc.xds.internal.security.ReferenceCountingMap.ValueFactory;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for {@link ReferenceCountingMap}. */
+@RunWith(JUnit4.class)
+public class ReferenceCountingMapTest {
+
+  @Rule public final MockitoRule mockitoRule = MockitoJUnit.rule();
+
+  @Mock
+  ValueFactory<Integer, SslContextProvider> mockFactory;
+
+  ReferenceCountingMap<Integer, SslContextProvider> map;
+
+  @Before
+  public void setUp() {
+    map = new ReferenceCountingMap<>(mockFactory);
+  }
+
+  @Test
+  public void referenceCountingMap_getAndRelease_closeCalled() throws InterruptedException {
+    SslContextProvider valueFor3 = getTypedMock();
+    when(mockFactory.create(3)).thenReturn(valueFor3);
+    SslContextProvider val = map.get(3);
+    assertThat(val).isSameInstanceAs(valueFor3);
+    verify(valueFor3, never()).close();
+    val = map.get(3);
+    assertThat(val).isSameInstanceAs(valueFor3);
+    // at this point ref-count is 2
+    assertThat(map.release(3, val)).isNull();
+    verify(valueFor3, never()).close();
+    assertThat(map.release(3, val)).isNull(); // after this ref-count is 0
+    verify(valueFor3, times(1)).close();
+  }
+
+  private static SslContextProvider getTypedMock() {
+    return mock(SslContextProvider.class);
+  }
+
+  @Test
+  public void referenceCountingMap_distinctElements() throws InterruptedException {
+    SslContextProvider valueFor3 = getTypedMock();
+    SslContextProvider valueFor4 = getTypedMock();
+    when(mockFactory.create(3)).thenReturn(valueFor3);
+    when(mockFactory.create(4)).thenReturn(valueFor4);
+    SslContextProvider val3 = map.get(3);
+    assertThat(val3).isSameInstanceAs(valueFor3);
+    SslContextProvider val4 = map.get(4);
+    assertThat(val4).isSameInstanceAs(valueFor4);
+    assertThat(map.release(3, val3)).isNull();
+    verify(valueFor3, times(1)).close();
+    verify(valueFor4, never()).close();
+    assertThat(map.release(4, val4)).isNull();
+    verify(valueFor4, times(1)).close();
+  }
+
+  @Test
+  public void referenceCountingMap_releaseWrongElement_expectException()
+      throws InterruptedException {
+    SslContextProvider valueFor3 = getTypedMock();
+    SslContextProvider valueFor4 = getTypedMock();
+    when(mockFactory.create(3)).thenReturn(valueFor3);
+    when(mockFactory.create(4)).thenReturn(valueFor4);
+    SslContextProvider unused = map.get(3);
+    SslContextProvider val4 = map.get(4);
+    // now provide wrong key (3) and value (val4) combination
+    try {
+      map.release(3, val4);
+      fail("exception expected");
+    } catch (IllegalArgumentException expected) {
+      assertThat(expected).hasMessageThat().contains("Releasing the wrong instance");
+    }
+  }
+
+  @Test
+  public void referenceCountingMap_excessRelease_expectException() throws InterruptedException {
+    SslContextProvider valueFor4 = getTypedMock();
+    when(mockFactory.create(4)).thenReturn(valueFor4);
+    SslContextProvider val = map.get(4);
+    assertThat(val).isSameInstanceAs(valueFor4);
+    // at this point ref-count is 1
+    map.release(4, val);
+    // at this point ref-count is 0
+    try {
+      map.release(4, val);
+      fail("exception expected");
+    } catch (IllegalArgumentException expected) {
+      assertThat(expected).hasMessageThat().contains("No cached instance found for 4");
+    }
+  }
+
+  @Test
+  public void referenceCountingMap_releaseAndGet_differentInstance() throws InterruptedException {
+    SslContextProvider valueFor4 = getTypedMock();
+    when(mockFactory.create(4)).thenReturn(valueFor4);
+    SslContextProvider val = map.get(4);
+    assertThat(val).isSameInstanceAs(valueFor4);
+    // at this point ref-count is 1
+    map.release(4, val);
+    // at this point ref-count is 0 and val is removed
+    // should get another instance for 4
+    SslContextProvider valueFor4a = getTypedMock();
+    when(mockFactory.create(4)).thenReturn(valueFor4a);
+    val = map.get(4);
+    assertThat(val).isSameInstanceAs(valueFor4a);
+    // verify it is a different instance from before
+    assertThat(valueFor4).isNotSameInstanceAs(valueFor4a);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/SecurityProtocolNegotiatorsTest.java b/xds/src/test/java/io/grpc/xds/internal/security/SecurityProtocolNegotiatorsTest.java
new file mode 100644
index 00000000000..dcb2fa051a3
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/SecurityProtocolNegotiatorsTest.java
@@ -0,0 +1,618 @@
+/*
+ * Copyright 2019 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.xds.internal.security;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CA_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
+import static io.grpc.xds.internal.security.SecurityProtocolNegotiators.ATTR_SERVER_SSL_CONTEXT_PROVIDER_SUPPLIER;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.common.util.concurrent.SettableFuture;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.grpc.Attributes;
+import io.grpc.ChannelLogger;
+import io.grpc.ChannelLogger.ChannelLogLevel;
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.TestUtils.NoopChannelLogger;
+import io.grpc.netty.GrpcHttp2ConnectionHandler;
+import io.grpc.netty.InternalProtocolNegotiationEvent;
+import io.grpc.netty.InternalProtocolNegotiator.ProtocolNegotiator;
+import io.grpc.netty.InternalProtocolNegotiators;
+import io.grpc.netty.ProtocolNegotiationEvent;
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.TlsContextManager;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.CommonBootstrapperTestUtils;
+import io.grpc.xds.internal.XdsInternalAttributes;
+import io.grpc.xds.internal.security.SecurityProtocolNegotiators.ClientSecurityHandler;
+import io.grpc.xds.internal.security.SecurityProtocolNegotiators.ClientSecurityProtocolNegotiator;
+import io.grpc.xds.internal.security.certprovider.CommonCertProviderTestUtils;
+import io.grpc.xds.internal.security.trust.CertificateUtils;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.ChannelPromise;
+import io.netty.channel.embedded.EmbeddedChannel;
+import io.netty.handler.codec.http2.DefaultHttp2Connection;
+import io.netty.handler.codec.http2.DefaultHttp2ConnectionDecoder;
+import io.netty.handler.codec.http2.DefaultHttp2ConnectionEncoder;
+import io.netty.handler.codec.http2.DefaultHttp2FrameReader;
+import io.netty.handler.codec.http2.DefaultHttp2FrameWriter;
+import io.netty.handler.codec.http2.Http2ConnectionDecoder;
+import io.netty.handler.codec.http2.Http2ConnectionEncoder;
+import io.netty.handler.codec.http2.Http2Settings;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslHandler;
+import io.netty.handler.ssl.SslHandshakeCompletionEvent;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.security.cert.CertStoreException;
+import java.util.AbstractMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import javax.net.ssl.X509TrustManager;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link SecurityProtocolNegotiators}. */
+@RunWith(JUnit4.class)
+public class SecurityProtocolNegotiatorsTest {
+
+  private static final String HOSTNAME = "hostname";
+  private static final String SNI_IN_UTC = "sni-in-upstream-tls-context";
+  private static final String FAKE_AUTHORITY = "authority";
+
+  private final GrpcHttp2ConnectionHandler grpcHandler =
+      FakeGrpcHttp2ConnectionHandler.newHandler();
+
+  private EmbeddedChannel channel = new EmbeddedChannel();
+  private ChannelPipeline pipeline = channel.pipeline();
+  private ChannelHandlerContext channelHandlerCtx;
+
+  @Test
+  public void clientSecurityProtocolNegotiatorNewHandler_noTlsContextAttribute() {
+    ChannelHandler mockChannelHandler = mock(ChannelHandler.class);
+    ProtocolNegotiator mockProtocolNegotiator = mock(ProtocolNegotiator.class);
+    when(mockProtocolNegotiator.newHandler(grpcHandler)).thenReturn(mockChannelHandler);
+    ClientSecurityProtocolNegotiator pn
+        = new ClientSecurityProtocolNegotiator(mockProtocolNegotiator);
+    ChannelHandler newHandler = pn.newHandler(grpcHandler);
+    assertThat(newHandler).isNotNull();
+    assertThat(newHandler).isSameInstanceAs(mockChannelHandler);
+  }
+
+  @Test
+  public void clientSecurityProtocolNegotiatorNewHandler_noFallback_expectException() {
+    ClientSecurityProtocolNegotiator pn =
+        new ClientSecurityProtocolNegotiator(/* fallbackProtocolNegotiator= */ null);
+    try {
+      pn.newHandler(grpcHandler);
+      fail("exception expected!");
+    } catch (NullPointerException expected) {
+      assertThat(expected)
+          .hasMessageThat()
+          .contains("No TLS config and no fallbackProtocolNegotiator!");
+    }
+  }
+
+  @Test
+  public void clientSecurityProtocolNegotiatorNewHandler_withTlsContextAttribute() {
+    UpstreamTlsContext upstreamTlsContext = CommonTlsContextTestsUtil.buildUpstreamTlsContext(
+        CommonTlsContext.newBuilder().build());
+    ClientSecurityProtocolNegotiator pn =
+        new ClientSecurityProtocolNegotiator(InternalProtocolNegotiators.plaintext());
+    GrpcHttp2ConnectionHandler mockHandler = mock(GrpcHttp2ConnectionHandler.class);
+    ChannelLogger logger = mock(ChannelLogger.class);
+    doNothing().when(logger).log(any(ChannelLogLevel.class), anyString());
+    when(mockHandler.getNegotiationLogger()).thenReturn(logger);
+    TlsContextManager mockTlsContextManager = mock(TlsContextManager.class);
+    when(mockHandler.getEagAttributes())
+        .thenReturn(
+            Attributes.newBuilder()
+                .set(SecurityProtocolNegotiators.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER,
+                    new SslContextProviderSupplier(upstreamTlsContext, mockTlsContextManager))
+                .build());
+    ChannelHandler newHandler = pn.newHandler(mockHandler);
+    assertThat(newHandler).isNotNull();
+    assertThat(newHandler).isInstanceOf(ClientSecurityHandler.class);
+  }
+
+  @Test
+  public void clientSecurityProtocolNegotiator_autoHostSni_hostnamePassedToClientSecurityHandlr() {
+    CertificateUtils.isXdsSniEnabled = true;
+    try {
+      UpstreamTlsContext upstreamTlsContext =
+          CommonTlsContextTestsUtil.buildUpstreamTlsContext(
+              CommonTlsContext.newBuilder().build(), "", true, false);
+      ClientSecurityProtocolNegotiator pn =
+          new ClientSecurityProtocolNegotiator(InternalProtocolNegotiators.plaintext());
+      GrpcHttp2ConnectionHandler mockHandler = mock(GrpcHttp2ConnectionHandler.class);
+      ChannelLogger logger = mock(ChannelLogger.class);
+      doNothing().when(logger).log(any(ChannelLogLevel.class), anyString());
+      when(mockHandler.getNegotiationLogger()).thenReturn(logger);
+      TlsContextManager mockTlsContextManager = mock(TlsContextManager.class);
+      when(mockHandler.getEagAttributes())
+          .thenReturn(
+              Attributes.newBuilder()
+                  .set(SecurityProtocolNegotiators.ATTR_SSL_CONTEXT_PROVIDER_SUPPLIER,
+                      new SslContextProviderSupplier(upstreamTlsContext, mockTlsContextManager))
+                  .set(XdsInternalAttributes.ATTR_ADDRESS_NAME, FAKE_AUTHORITY)
+                  .build());
+      ChannelHandler newHandler = pn.newHandler(mockHandler);
+      assertThat(newHandler).isNotNull();
+      assertThat(newHandler).isInstanceOf(ClientSecurityHandler.class);
+      assertThat(((ClientSecurityHandler) newHandler).getSni()).isEqualTo(FAKE_AUTHORITY);
+    } finally {
+      CertificateUtils.isXdsSniEnabled = false;
+    }
+  }
+
+  @Test
+  public void clientSecurityHandler_addLast()
+      throws InterruptedException, TimeoutException, ExecutionException {
+    FakeClock executor = new FakeClock();
+    CommonCertProviderTestUtils.register(executor);
+    Bootstrapper.BootstrapInfo bootstrapInfoForClient = CommonBootstrapperTestUtils
+        .buildBootstrapInfo("google_cloud_private_spiffe-client", CLIENT_KEY_FILE, CLIENT_PEM_FILE,
+            CA_PEM_FILE, null, null, null, null, null);
+    UpstreamTlsContext upstreamTlsContext =
+        CommonTlsContextTestsUtil
+            .buildUpstreamTlsContext("google_cloud_private_spiffe-client", true);
+
+    SslContextProviderSupplier sslContextProviderSupplier =
+        new SslContextProviderSupplier(upstreamTlsContext,
+            new TlsContextManagerImpl(bootstrapInfoForClient));
+    ClientSecurityHandler clientSecurityHandler =
+        new ClientSecurityHandler(grpcHandler, sslContextProviderSupplier, HOSTNAME);
+    pipeline.addLast(clientSecurityHandler);
+    channelHandlerCtx = pipeline.context(clientSecurityHandler);
+    assertNotNull(channelHandlerCtx);
+
+    // kick off protocol negotiation.
+    pipeline.fireUserEventTriggered(InternalProtocolNegotiationEvent.getDefault());
+    final SettableFuture<Object> future = SettableFuture.create();
+    sslContextProviderSupplier
+        .updateSslContext(new SslContextProvider.Callback(MoreExecutors.directExecutor()) {
+          @Override
+          public void updateSslContextAndExtendedX509TrustManager(
+              AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> sslContextAndTm) {
+            future.set(sslContextAndTm);
+          }
+
+          @Override
+          protected void onException(Throwable throwable) {
+            future.set(throwable);
+          }
+        }, false);
+    assertThat(executor.runDueTasks()).isEqualTo(1);
+    channel.runPendingTasks();
+    Object fromFuture = future.get(2, TimeUnit.SECONDS);
+    assertThat(fromFuture).isInstanceOf(AbstractMap.SimpleImmutableEntry.class);
+    channel.runPendingTasks();
+    channelHandlerCtx = pipeline.context(clientSecurityHandler);
+    assertThat(channelHandlerCtx).isNull();
+
+    // pipeline should have SslHandler and ClientTlsHandler
+    Iterator<Map.Entry<String, ChannelHandler>> iterator = pipeline.iterator();
+    assertThat(iterator.next().getValue()).isInstanceOf(SslHandler.class);
+    // ProtocolNegotiators.ClientTlsHandler.class not accessible, get canonical name
+    assertThat(iterator.next().getValue().getClass().getCanonicalName())
+        .contains("ProtocolNegotiators.ClientTlsHandler");
+    CommonCertProviderTestUtils.register0();
+  }
+
+  @Test
+  public void sniInClientSecurityHandler_autoHostSniIsTrue_usesEndpointHostname() {
+    CertificateUtils.isXdsSniEnabled = true;
+    try {
+      Bootstrapper.BootstrapInfo bootstrapInfoForClient = CommonBootstrapperTestUtils
+          .buildBootstrapInfo("google_cloud_private_spiffe-client", CLIENT_KEY_FILE,
+              CLIENT_PEM_FILE, CA_PEM_FILE, null, null, null, null, null);
+      UpstreamTlsContext upstreamTlsContext =
+          CommonTlsContextTestsUtil
+              .buildUpstreamTlsContext("google_cloud_private_spiffe-client", true, "", true);
+      SslContextProviderSupplier sslContextProviderSupplier =
+          new SslContextProviderSupplier(upstreamTlsContext,
+              new TlsContextManagerImpl(bootstrapInfoForClient));
+
+      ClientSecurityHandler clientSecurityHandler =
+          new ClientSecurityHandler(grpcHandler, sslContextProviderSupplier, HOSTNAME);
+
+      assertThat(clientSecurityHandler.getSni()).isEqualTo(HOSTNAME);
+    } finally {
+      CertificateUtils.isXdsSniEnabled = false;
+    }
+  }
+
+  @Test
+  public void sniInClientSecurityHandler_autoHostSni_endpointHostnameIsEmpty_usesSniFromUtc() {
+    CertificateUtils.isXdsSniEnabled = true;
+    try {
+      Bootstrapper.BootstrapInfo bootstrapInfoForClient = CommonBootstrapperTestUtils
+          .buildBootstrapInfo("google_cloud_private_spiffe-client", CLIENT_KEY_FILE,
+              CLIENT_PEM_FILE, CA_PEM_FILE, null, null, null, null, null);
+      UpstreamTlsContext upstreamTlsContext = CommonTlsContextTestsUtil.buildUpstreamTlsContext(
+          "google_cloud_private_spiffe-client", true, SNI_IN_UTC, true);
+      SslContextProviderSupplier sslContextProviderSupplier =
+          new SslContextProviderSupplier(upstreamTlsContext,
+              new TlsContextManagerImpl(bootstrapInfoForClient));
+
+      ClientSecurityHandler clientSecurityHandler =
+          new ClientSecurityHandler(grpcHandler, sslContextProviderSupplier, "");
+
+      assertThat(clientSecurityHandler.getSni()).isEqualTo(SNI_IN_UTC);
+    } finally {
+      CertificateUtils.isXdsSniEnabled = false;
+    }
+  }
+
+  @Test
+  public void sniInClientSecurityHandler_autoHostSni_endpointHostnameIsNull_usesSniFromUtc() {
+    CertificateUtils.isXdsSniEnabled = true;
+    try {
+      Bootstrapper.BootstrapInfo bootstrapInfoForClient = CommonBootstrapperTestUtils
+          .buildBootstrapInfo("google_cloud_private_spiffe-client", CLIENT_KEY_FILE,
+              CLIENT_PEM_FILE, CA_PEM_FILE, null, null, null, null, null);
+      UpstreamTlsContext upstreamTlsContext = CommonTlsContextTestsUtil.buildUpstreamTlsContext(
+          "google_cloud_private_spiffe-client", true, SNI_IN_UTC, true);
+      SslContextProviderSupplier sslContextProviderSupplier =
+          new SslContextProviderSupplier(upstreamTlsContext,
+              new TlsContextManagerImpl(bootstrapInfoForClient));
+
+      ClientSecurityHandler clientSecurityHandler =
+          new ClientSecurityHandler(grpcHandler, sslContextProviderSupplier, null);
+
+      assertThat(clientSecurityHandler.getSni()).isEqualTo(SNI_IN_UTC);
+    } finally {
+      CertificateUtils.isXdsSniEnabled = false;
+    }
+  }
+
+  @Test
+  public void sniInClientSecurityHandler_autoHostSniIsFalse_usesSniFromUpstreamTlsContext() {
+    CertificateUtils.isXdsSniEnabled = true;
+    try {
+      Bootstrapper.BootstrapInfo bootstrapInfoForClient = CommonBootstrapperTestUtils
+          .buildBootstrapInfo("google_cloud_private_spiffe-client", CLIENT_KEY_FILE,
+              CLIENT_PEM_FILE, CA_PEM_FILE, null, null, null, null, null);
+      UpstreamTlsContext upstreamTlsContext = CommonTlsContextTestsUtil.buildUpstreamTlsContext(
+          "google_cloud_private_spiffe-client", true, SNI_IN_UTC, false);
+      SslContextProviderSupplier sslContextProviderSupplier =
+          new SslContextProviderSupplier(upstreamTlsContext,
+              new TlsContextManagerImpl(bootstrapInfoForClient));
+
+      ClientSecurityHandler clientSecurityHandler =
+          new ClientSecurityHandler(grpcHandler, sslContextProviderSupplier, HOSTNAME);
+
+      assertThat(clientSecurityHandler.getSni()).isEqualTo(SNI_IN_UTC);
+    } finally {
+      CertificateUtils.isXdsSniEnabled = false;
+    }
+  }
+
+  @Test
+  public void sniFeatureNotEnabled_usesChannelAuthorityForSni() {
+    CertificateUtils.isXdsSniEnabled = false;
+    Bootstrapper.BootstrapInfo bootstrapInfoForClient = CommonBootstrapperTestUtils
+            .buildBootstrapInfo("google_cloud_private_spiffe-client", CLIENT_KEY_FILE,
+                    CLIENT_PEM_FILE, CA_PEM_FILE, null, null, null, null, null);
+    UpstreamTlsContext upstreamTlsContext =
+            CommonTlsContextTestsUtil
+                .buildUpstreamTlsContext("google_cloud_private_spiffe-client", true);
+    SslContextProviderSupplier sslContextProviderSupplier =
+            new SslContextProviderSupplier(upstreamTlsContext,
+                    new TlsContextManagerImpl(bootstrapInfoForClient));
+
+    ClientSecurityHandler clientSecurityHandler =
+            new ClientSecurityHandler(grpcHandler, sslContextProviderSupplier, HOSTNAME);
+
+    assertThat(clientSecurityHandler.getSni()).isEqualTo(FAKE_AUTHORITY);
+  }
+
+  @Test
+  public void serverSecurityHandler_addLast()
+      throws InterruptedException, TimeoutException, ExecutionException {
+    FakeClock executor = new FakeClock();
+    CommonCertProviderTestUtils.register(executor);
+    // we need InetSocketAddress instead of EmbeddedSocketAddress as localAddress for this test
+    channel =
+        new EmbeddedChannel() {
+          @Override
+          public SocketAddress localAddress() {
+            return new InetSocketAddress("172.168.1.1", 80);
+          }
+
+          @Override
+          public SocketAddress remoteAddress() {
+            return new InetSocketAddress("172.168.2.2", 90);
+          }
+        };
+    pipeline = channel.pipeline();
+    Bootstrapper.BootstrapInfo bootstrapInfoForServer = CommonBootstrapperTestUtils
+        .buildBootstrapInfo("google_cloud_private_spiffe-server", SERVER_1_KEY_FILE,
+            SERVER_1_PEM_FILE, CA_PEM_FILE, null, null, null, null, null);
+    DownstreamTlsContext downstreamTlsContext =
+        CommonTlsContextTestsUtil.buildDownstreamTlsContext(
+            "google_cloud_private_spiffe-server", true, true);
+
+    TlsContextManagerImpl tlsContextManager = new TlsContextManagerImpl(bootstrapInfoForServer);
+    SecurityProtocolNegotiators.HandlerPickerHandler handlerPickerHandler =
+        new SecurityProtocolNegotiators.HandlerPickerHandler(grpcHandler,
+                InternalProtocolNegotiators.serverPlaintext());
+    pipeline.addLast(handlerPickerHandler);
+    channelHandlerCtx = pipeline.context(handlerPickerHandler);
+    assertThat(channelHandlerCtx).isNotNull(); // should find HandlerPickerHandler
+
+    // kick off protocol negotiation: should replace HandlerPickerHandler with ServerSecurityHandler
+    ProtocolNegotiationEvent event = InternalProtocolNegotiationEvent.getDefault();
+    Attributes attr = InternalProtocolNegotiationEvent.getAttributes(event)
+            .toBuilder().set(ATTR_SERVER_SSL_CONTEXT_PROVIDER_SUPPLIER,
+              new SslContextProviderSupplier(downstreamTlsContext, tlsContextManager)).build();
+    pipeline.fireUserEventTriggered(InternalProtocolNegotiationEvent.withAttributes(event, attr));
+    channelHandlerCtx = pipeline.context(handlerPickerHandler);
+    assertThat(channelHandlerCtx).isNull();
+    channelHandlerCtx = pipeline.context(SecurityProtocolNegotiators.ServerSecurityHandler.class);
+    assertThat(channelHandlerCtx).isNotNull();
+
+    SslContextProviderSupplier sslContextProviderSupplier =
+        new SslContextProviderSupplier(downstreamTlsContext, tlsContextManager);
+    final SettableFuture<Object> future = SettableFuture.create();
+    sslContextProviderSupplier
+        .updateSslContext(new SslContextProvider.Callback(MoreExecutors.directExecutor()) {
+          @Override
+          public void updateSslContextAndExtendedX509TrustManager(
+              AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> sslContextAndTm) {
+            future.set(sslContextAndTm);
+          }
+
+          @Override
+          protected void onException(Throwable throwable) {
+            future.set(throwable);
+          }
+        }, false);
+    channel.runPendingTasks(); // need this for tasks to execute on eventLoop
+    assertThat(executor.runDueTasks()).isEqualTo(1);
+    Object fromFuture = future.get(2, TimeUnit.SECONDS);
+    assertThat(fromFuture).isInstanceOf(AbstractMap.SimpleImmutableEntry.class);
+    channel.runPendingTasks();
+    channelHandlerCtx = pipeline.context(SecurityProtocolNegotiators.ServerSecurityHandler.class);
+    assertThat(channelHandlerCtx).isNull();
+
+    // pipeline should only have SslHandler and ServerTlsHandler
+    Iterator<Map.Entry<String, ChannelHandler>> iterator = pipeline.iterator();
+    assertThat(iterator.next().getValue()).isInstanceOf(SslHandler.class);
+    // ProtocolNegotiators.ServerTlsHandler.class is not accessible, get canonical name
+    assertThat(iterator.next().getValue().getClass().getCanonicalName())
+        .contains("ProtocolNegotiators.ServerTlsHandler");
+    CommonCertProviderTestUtils.register0();
+  }
+
+  @Test
+  public void serverSecurityHandler_defaultDownstreamTlsContext_expectFallbackProtocolNegotiator()
+      throws IOException {
+    ChannelHandler mockChannelHandler = mock(ChannelHandler.class);
+    ProtocolNegotiator mockProtocolNegotiator = mock(ProtocolNegotiator.class);
+    when(mockProtocolNegotiator.newHandler(grpcHandler)).thenReturn(mockChannelHandler);
+    // we need InetSocketAddress instead of EmbeddedSocketAddress as localAddress for this test
+    channel =
+        new EmbeddedChannel() {
+          @Override
+          public SocketAddress localAddress() {
+            return new InetSocketAddress("172.168.1.1", 80);
+          }
+        };
+    pipeline = channel.pipeline();
+
+    SecurityProtocolNegotiators.HandlerPickerHandler handlerPickerHandler =
+        new SecurityProtocolNegotiators.HandlerPickerHandler(
+            grpcHandler, mockProtocolNegotiator);
+    pipeline.addLast(handlerPickerHandler);
+    channelHandlerCtx = pipeline.context(handlerPickerHandler);
+    assertThat(channelHandlerCtx).isNotNull(); // should find HandlerPickerHandler
+
+    // kick off protocol negotiation: should replace HandlerPickerHandler with ServerSecurityHandler
+    ProtocolNegotiationEvent event = InternalProtocolNegotiationEvent.getDefault();
+    Attributes attr = InternalProtocolNegotiationEvent.getAttributes(event)
+            .toBuilder().set(ATTR_SERVER_SSL_CONTEXT_PROVIDER_SUPPLIER, null).build();
+    pipeline.fireUserEventTriggered(InternalProtocolNegotiationEvent.withAttributes(event, attr));
+    channelHandlerCtx = pipeline.context(handlerPickerHandler);
+    assertThat(channelHandlerCtx).isNull();
+    channel.runPendingTasks(); // need this for tasks to execute on eventLoop
+    Iterator<Map.Entry<String, ChannelHandler>> iterator = pipeline.iterator();
+    assertThat(iterator.next().getValue()).isSameInstanceAs(mockChannelHandler);
+    // no more handlers in the pipeline
+    assertThat(iterator.hasNext()).isFalse();
+  }
+
+  @Test
+  public void serverSecurityHandler_nullTlsContext_expectFallbackProtocolNegotiator() {
+    ChannelHandler mockChannelHandler = mock(ChannelHandler.class);
+    ProtocolNegotiator mockProtocolNegotiator = mock(ProtocolNegotiator.class);
+    when(mockProtocolNegotiator.newHandler(grpcHandler)).thenReturn(mockChannelHandler);
+    SecurityProtocolNegotiators.HandlerPickerHandler handlerPickerHandler =
+        new SecurityProtocolNegotiators.HandlerPickerHandler(
+            grpcHandler, mockProtocolNegotiator);
+    pipeline.addLast(handlerPickerHandler);
+    channelHandlerCtx = pipeline.context(handlerPickerHandler);
+    assertThat(channelHandlerCtx).isNotNull(); // should find HandlerPickerHandler
+
+    // kick off protocol negotiation
+    pipeline.fireUserEventTriggered(InternalProtocolNegotiationEvent.getDefault());
+    channelHandlerCtx = pipeline.context(handlerPickerHandler);
+    assertThat(channelHandlerCtx).isNull();
+    channel.runPendingTasks(); // need this for tasks to execute on eventLoop
+    Iterator<Map.Entry<String, ChannelHandler>> iterator = pipeline.iterator();
+    assertThat(iterator.next().getValue()).isSameInstanceAs(mockChannelHandler);
+    // no more handlers in the pipeline
+    assertThat(iterator.hasNext()).isFalse();
+  }
+
+  @Test
+  public void nullTlsContext_nullFallbackProtocolNegotiator_expectException() {
+    SecurityProtocolNegotiators.HandlerPickerHandler handlerPickerHandler =
+        new SecurityProtocolNegotiators.HandlerPickerHandler(
+            grpcHandler, null);
+    pipeline.addLast(handlerPickerHandler);
+    channelHandlerCtx = pipeline.context(handlerPickerHandler);
+    assertThat(channelHandlerCtx).isNotNull(); // should find HandlerPickerHandler
+
+    // kick off protocol negotiation
+    pipeline.fireUserEventTriggered(InternalProtocolNegotiationEvent.getDefault());
+    channelHandlerCtx = pipeline.context(handlerPickerHandler);
+    assertThat(channelHandlerCtx).isNotNull(); // HandlerPickerHandler still there
+    try {
+      channel.checkException();
+      fail("exception expected!");
+    } catch (Exception e) {
+      assertThat(e).isInstanceOf(CertStoreException.class);
+      assertThat(e).hasMessageThat().contains("No certificate source found!");
+    }
+  }
+
+  @Test
+  public void clientSecurityProtocolNegotiatorNewHandler_fireProtocolNegotiationEvent()
+          throws InterruptedException, TimeoutException, ExecutionException {
+    CertificateUtils.isXdsSniEnabled = true;
+    try {
+      FakeClock executor = new FakeClock();
+      CommonCertProviderTestUtils.register(executor);
+      Bootstrapper.BootstrapInfo bootstrapInfoForClient = CommonBootstrapperTestUtils
+          .buildBootstrapInfo("google_cloud_private_spiffe-client", CLIENT_KEY_FILE,
+              CLIENT_PEM_FILE, CA_PEM_FILE, null, null, null, null, null);
+      UpstreamTlsContext upstreamTlsContext =
+          CommonTlsContextTestsUtil
+              .buildUpstreamTlsContext("google_cloud_private_spiffe-client", true);
+
+      SslContextProviderSupplier sslContextProviderSupplier =
+          new SslContextProviderSupplier(upstreamTlsContext,
+              new TlsContextManagerImpl(bootstrapInfoForClient));
+      ClientSecurityHandler clientSecurityHandler =
+          new ClientSecurityHandler(grpcHandler, sslContextProviderSupplier, HOSTNAME);
+
+      pipeline.addLast(clientSecurityHandler);
+      channelHandlerCtx = pipeline.context(clientSecurityHandler);
+      assertNotNull(channelHandlerCtx); // non-null since we just added it
+
+      // kick off protocol negotiation.
+      pipeline.fireUserEventTriggered(InternalProtocolNegotiationEvent.getDefault());
+      final SettableFuture<Object> future = SettableFuture.create();
+      sslContextProviderSupplier
+          .updateSslContext(new SslContextProvider.Callback(MoreExecutors.directExecutor()) {
+            @Override
+            public void updateSslContextAndExtendedX509TrustManager(
+                AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> sslContextAndTm) {
+              future.set(sslContextAndTm);
+            }
+
+            @Override
+            protected void onException(Throwable throwable) {
+              future.set(throwable);
+            }
+          }, false);
+      executor.runDueTasks();
+      channel.runPendingTasks(); // need this for tasks to execute on eventLoop
+      Object fromFuture = future.get(5, TimeUnit.SECONDS);
+      assertThat(fromFuture).isInstanceOf(AbstractMap.SimpleImmutableEntry.class);
+      channel.runPendingTasks();
+      channelHandlerCtx = pipeline.context(clientSecurityHandler);
+      assertThat(channelHandlerCtx).isNull();
+      Object sslEvent = SslHandshakeCompletionEvent.SUCCESS;
+
+      pipeline.fireUserEventTriggered(sslEvent);
+      channel.runPendingTasks(); // need this for tasks to execute on eventLoop
+      assertTrue(channel.isOpen());
+      CommonCertProviderTestUtils.register0();
+    } finally {
+      CertificateUtils.isXdsSniEnabled = false;
+    }
+  }
+
+  @Test
+  public void clientSecurityProtocolNegotiatorNewHandler_handleHandlerRemoved() {
+    FakeClock executor = new FakeClock();
+    CommonCertProviderTestUtils.register(executor);
+    Bootstrapper.BootstrapInfo bootstrapInfoForClient = CommonBootstrapperTestUtils
+        .buildBootstrapInfo("google_cloud_private_spiffe-client", CLIENT_KEY_FILE, CLIENT_PEM_FILE,
+            CA_PEM_FILE, null, null, null, null, null);
+    UpstreamTlsContext upstreamTlsContext =
+        CommonTlsContextTestsUtil
+            .buildUpstreamTlsContext("google_cloud_private_spiffe-client", true);
+
+    SslContextProviderSupplier sslContextProviderSupplier =
+        new SslContextProviderSupplier(upstreamTlsContext,
+            new TlsContextManagerImpl(bootstrapInfoForClient));
+    ClientSecurityHandler clientSecurityHandler =
+        new ClientSecurityHandler(grpcHandler, sslContextProviderSupplier, HOSTNAME);
+
+    pipeline.addLast(clientSecurityHandler);
+    channelHandlerCtx = pipeline.context(clientSecurityHandler);
+
+    // kick off protocol negotiation.
+    pipeline.fireUserEventTriggered(InternalProtocolNegotiationEvent.getDefault());
+
+    executor.runDueTasks();
+    pipeline.remove(clientSecurityHandler);
+    channel.runPendingTasks();
+    channel.checkException();
+    CommonCertProviderTestUtils.register0();
+  }
+
+  private static final class FakeGrpcHttp2ConnectionHandler extends GrpcHttp2ConnectionHandler {
+
+    FakeGrpcHttp2ConnectionHandler(
+        ChannelPromise channelUnused,
+        Http2ConnectionDecoder decoder,
+        Http2ConnectionEncoder encoder,
+        Http2Settings initialSettings) {
+      super(channelUnused, decoder, encoder, initialSettings, new NoopChannelLogger());
+    }
+
+    static FakeGrpcHttp2ConnectionHandler newHandler() {
+      DefaultHttp2Connection conn = new DefaultHttp2Connection(/*server=*/ false);
+      DefaultHttp2ConnectionEncoder encoder =
+          new DefaultHttp2ConnectionEncoder(conn, new DefaultHttp2FrameWriter());
+      DefaultHttp2ConnectionDecoder decoder =
+          new DefaultHttp2ConnectionDecoder(conn, encoder, new DefaultHttp2FrameReader());
+      Http2Settings settings = new Http2Settings();
+      return new FakeGrpcHttp2ConnectionHandler(
+          /*channelUnused=*/ null, decoder, encoder, settings);
+    }
+
+    @Override
+    public String getAuthority() {
+      return FAKE_AUTHORITY;
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/ServerSslContextProviderFactoryTest.java b/xds/src/test/java/io/grpc/xds/internal/security/ServerSslContextProviderFactoryTest.java
new file mode 100644
index 00000000000..7a5a6c00639
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/ServerSslContextProviderFactoryTest.java
@@ -0,0 +1,255 @@
+/*
+ * Copyright 2019 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.xds.internal.security;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.internal.security.ClientSslContextProviderFactoryTest.createAndRegisterProviderProvider;
+import static io.grpc.xds.internal.security.ClientSslContextProviderFactoryTest.verifyWatcher;
+
+import com.google.common.collect.ImmutableSet;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CommonTlsContext;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import io.grpc.xds.EnvoyServerProtoData;
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.CommonBootstrapperTestUtils;
+import io.grpc.xds.client.XdsInitializationException;
+import io.grpc.xds.internal.security.certprovider.CertProviderServerSslContextProviderFactory;
+import io.grpc.xds.internal.security.certprovider.CertificateProvider;
+import io.grpc.xds.internal.security.certprovider.CertificateProviderRegistry;
+import io.grpc.xds.internal.security.certprovider.CertificateProviderStore;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link ServerSslContextProviderFactory}. */
+@RunWith(JUnit4.class)
+public class ServerSslContextProviderFactoryTest {
+
+  CertificateProviderRegistry certificateProviderRegistry;
+  CertificateProviderStore certificateProviderStore;
+  CertProviderServerSslContextProviderFactory certProviderServerSslContextProviderFactory;
+  ServerSslContextProviderFactory serverSslContextProviderFactory;
+
+  @Before
+  public void setUp() {
+    certificateProviderRegistry = new CertificateProviderRegistry();
+    certificateProviderStore = new CertificateProviderStore(certificateProviderRegistry);
+    certProviderServerSslContextProviderFactory =
+        new CertProviderServerSslContextProviderFactory(certificateProviderStore);
+  }
+
+  @Test
+  public void createCertProviderServerSslContextProvider() throws XdsInitializationException {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
+    DownstreamTlsContext downstreamTlsContext =
+        CommonTlsContextTestsUtil.buildDownstreamTlsContextForCertProviderInstance(
+            "gcp_id",
+            "cert-default",
+            "gcp_id",
+            "root-default",
+            /* alpnProtocols= */ null,
+            /* staticCertValidationContext= */ null,
+            /* requireClientCert= */ true);
+
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    serverSslContextProviderFactory =
+            new ServerSslContextProviderFactory(
+                    bootstrapInfo, certProviderServerSslContextProviderFactory);
+    SslContextProvider sslContextProvider =
+        serverSslContextProviderFactory.create(downstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderServerSslContextProvider");
+    verifyWatcher(sslContextProvider, watcherCaptor[0], false);
+    // verify that bootstrapInfo is cached...
+    sslContextProvider =
+        serverSslContextProviderFactory.create(downstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderServerSslContextProvider");
+  }
+
+  @Test
+  public void bothPresent_expectCertProviderServerSslContextProvider()
+      throws XdsInitializationException {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
+    DownstreamTlsContext downstreamTlsContext =
+        CommonTlsContextTestsUtil.buildDownstreamTlsContextForCertProviderInstance(
+            "gcp_id",
+            "cert-default",
+            "gcp_id",
+            "root-default",
+            /* alpnProtocols= */ null,
+            /* staticCertValidationContext= */ null,
+            /* requireClientCert= */ true);
+
+    CommonTlsContext.Builder builder = downstreamTlsContext.getCommonTlsContext().toBuilder();
+    builder =
+        ClientSslContextProviderFactoryTest.addFilenames(builder, "foo.pem", "foo.key", "root.pem");
+    downstreamTlsContext =
+        new EnvoyServerProtoData.DownstreamTlsContext(
+            builder.build(), downstreamTlsContext.isRequireClientCertificate());
+
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    serverSslContextProviderFactory =
+            new ServerSslContextProviderFactory(
+                    bootstrapInfo, certProviderServerSslContextProviderFactory);
+    SslContextProvider sslContextProvider =
+        serverSslContextProviderFactory.create(downstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderServerSslContextProvider");
+    verifyWatcher(sslContextProvider, watcherCaptor[0], true);
+  }
+
+  @Test
+  public void createCertProviderServerSslContextProvider_onlyCertInstance()
+      throws XdsInitializationException {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+            new CertificateProvider.DistributorWatcher[1];
+    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
+    DownstreamTlsContext downstreamTlsContext =
+            CommonTlsContextTestsUtil.buildDownstreamTlsContextForCertProviderInstance(
+                    "gcp_id",
+                    "cert-default",
+                    /* rootInstanceName= */ null,
+                    /* rootCertName= */ null,
+                    /* alpnProtocols= */ null,
+                    /* staticCertValidationContext= */ null,
+                    /* requireClientCert= */ true);
+
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    serverSslContextProviderFactory =
+            new ServerSslContextProviderFactory(
+                    bootstrapInfo, certProviderServerSslContextProviderFactory);
+    SslContextProvider sslContextProvider =
+            serverSslContextProviderFactory.create(downstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderServerSslContextProvider");
+    verifyWatcher(sslContextProvider, watcherCaptor[0], true);
+  }
+
+  @Test
+  public void createCertProviderServerSslContextProvider_withStaticContext()
+      throws XdsInitializationException {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+            new CertificateProvider.DistributorWatcher[1];
+    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
+    @SuppressWarnings("deprecation")
+    CertificateValidationContext staticCertValidationContext =
+            CertificateValidationContext.newBuilder()
+                    .addAllMatchSubjectAltNames(
+                            ImmutableSet.of(
+                                    StringMatcher.newBuilder().setExact("foo").build(),
+                                    StringMatcher.newBuilder().setExact("bar").build()))
+                    .build();
+    DownstreamTlsContext downstreamTlsContext =
+            CommonTlsContextTestsUtil.buildDownstreamTlsContextForCertProviderInstance(
+                    "gcp_id",
+                    "cert-default",
+                    "gcp_id",
+                    "root-default",
+                    /* alpnProtocols= */ null,
+                    staticCertValidationContext,
+                    /* requireClientCert= */ true);
+
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    serverSslContextProviderFactory =
+            new ServerSslContextProviderFactory(
+                    bootstrapInfo, certProviderServerSslContextProviderFactory);
+    SslContextProvider sslContextProvider =
+            serverSslContextProviderFactory.create(downstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderServerSslContextProvider");
+    verifyWatcher(sslContextProvider, watcherCaptor[0], false);
+  }
+
+  @Test
+  public void createCertProviderServerSslContextProvider_2providers()
+      throws XdsInitializationException {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[2];
+    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
+
+    createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "file_watcher", 1);
+
+    DownstreamTlsContext downstreamTlsContext =
+        CommonTlsContextTestsUtil.buildDownstreamTlsContextForCertProviderInstance(
+            "gcp_id",
+            "cert-default",
+            "file_provider",
+            "root-default",
+            /* alpnProtocols= */ null,
+            /* staticCertValidationContext= */ null,
+            /* requireClientCert= */ true);
+
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    serverSslContextProviderFactory =
+            new ServerSslContextProviderFactory(
+                    bootstrapInfo, certProviderServerSslContextProviderFactory);
+    SslContextProvider sslContextProvider =
+        serverSslContextProviderFactory.create(downstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderServerSslContextProvider");
+    verifyWatcher(sslContextProvider, watcherCaptor[0], true);
+    verifyWatcher(sslContextProvider, watcherCaptor[1], true);
+  }
+
+  @Test
+  public void createNewCertProviderServerSslContextProvider_withSans()
+      throws XdsInitializationException {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[2];
+    createAndRegisterProviderProvider(certificateProviderRegistry, watcherCaptor, "testca", 0);
+    createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "file_watcher", 1);
+    @SuppressWarnings("deprecation")
+    CertificateValidationContext staticCertValidationContext =
+        CertificateValidationContext.newBuilder()
+            .addAllMatchSubjectAltNames(
+                ImmutableSet.of(
+                    StringMatcher.newBuilder().setExact("foo").build(),
+                    StringMatcher.newBuilder().setExact("bar").build()))
+            .build();
+
+    DownstreamTlsContext downstreamTlsContext =
+        CommonTlsContextTestsUtil.buildNewDownstreamTlsContextForCertProviderInstance(
+            "gcp_id",
+            "cert-default",
+            "file_provider",
+            "root-default",
+            /* alpnProtocols= */ null,
+            staticCertValidationContext,
+            /* requireClientCert= */ true);
+
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    serverSslContextProviderFactory =
+        new ServerSslContextProviderFactory(
+            bootstrapInfo, certProviderServerSslContextProviderFactory);
+    SslContextProvider sslContextProvider =
+        serverSslContextProviderFactory.create(downstreamTlsContext);
+    assertThat(sslContextProvider.getClass().getSimpleName()).isEqualTo(
+        "CertProviderServerSslContextProvider");
+    verifyWatcher(sslContextProvider, watcherCaptor[0], true);
+    verifyWatcher(sslContextProvider, watcherCaptor[1], true);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/SslContextProviderSupplierTest.java b/xds/src/test/java/io/grpc/xds/internal/security/SslContextProviderSupplierTest.java
new file mode 100644
index 00000000000..70a53c53205
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/SslContextProviderSupplierTest.java
@@ -0,0 +1,212 @@
+/*
+ * 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.xds.internal.security;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.buildUpstreamTlsContext;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.grpc.xds.EnvoyServerProtoData;
+import io.grpc.xds.TlsContextManager;
+import io.netty.handler.ssl.SslContext;
+import java.util.AbstractMap;
+import java.util.concurrent.Executor;
+import javax.net.ssl.X509TrustManager;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Unit tests for {@link SslContextProviderSupplier}.
+ */
+@RunWith(JUnit4.class)
+public class SslContextProviderSupplierTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock private TlsContextManager mockTlsContextManager;
+  @Mock private Executor mockExecutor;
+  private SslContextProviderSupplier supplier;
+  private SslContextProvider mockSslContextProvider;
+  private EnvoyServerProtoData.UpstreamTlsContext upstreamTlsContext =
+      buildUpstreamTlsContext("google_cloud_private_spiffe", true);
+  private SslContextProvider.Callback mockCallback;
+
+  private void prepareSupplier() {
+    mockSslContextProvider = mock(SslContextProvider.class);
+    doReturn(mockSslContextProvider)
+            .when(mockTlsContextManager)
+            .findOrCreateClientSslContextProvider(eq(upstreamTlsContext));
+    supplier = new SslContextProviderSupplier(upstreamTlsContext, mockTlsContextManager);
+  }
+
+  private void callUpdateSslContext() {
+    mockCallback = mock(SslContextProvider.Callback.class);
+    doReturn(mockExecutor).when(mockCallback).getExecutor();
+    supplier.updateSslContext(mockCallback, false);
+  }
+
+  @Test
+  public void get_updateSecret() {
+    prepareSupplier();
+    callUpdateSslContext();
+    verify(mockTlsContextManager, times(2))
+        .findOrCreateClientSslContextProvider(eq(upstreamTlsContext));
+    verify(mockTlsContextManager, times(0))
+        .releaseClientSslContextProvider(any(SslContextProvider.class));
+    ArgumentCaptor<SslContextProvider.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(SslContextProvider.Callback.class);
+    verify(mockSslContextProvider, times(1)).addCallback(callbackCaptor.capture());
+    SslContextProvider.Callback capturedCallback = callbackCaptor.getValue();
+    assertThat(capturedCallback).isNotNull();
+    @SuppressWarnings("unchecked")
+    AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> mockSslContextAndTm =
+        mock(AbstractMap.SimpleImmutableEntry.class);
+    capturedCallback.updateSslContextAndExtendedX509TrustManager(mockSslContextAndTm);
+    verify(mockCallback, times(1))
+        .updateSslContextAndExtendedX509TrustManager(eq(mockSslContextAndTm));
+    verify(mockTlsContextManager, times(1))
+        .releaseClientSslContextProvider(eq(mockSslContextProvider));
+    SslContextProvider.Callback mockCallback = mock(SslContextProvider.Callback.class);
+    supplier.updateSslContext(mockCallback, false);
+    verify(mockTlsContextManager, times(3))
+        .findOrCreateClientSslContextProvider(eq(upstreamTlsContext));
+  }
+
+  @Test
+  public void autoHostSniFalse_usesSniFromUpstreamTlsContext() {
+    prepareSupplier();
+    callUpdateSslContext();
+    verify(mockTlsContextManager, times(2))
+            .findOrCreateClientSslContextProvider(eq(upstreamTlsContext));
+    verify(mockTlsContextManager, times(0))
+            .releaseClientSslContextProvider(any(SslContextProvider.class));
+    ArgumentCaptor<SslContextProvider.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(SslContextProvider.Callback.class);
+    verify(mockSslContextProvider, times(1)).addCallback(callbackCaptor.capture());
+    SslContextProvider.Callback capturedCallback = callbackCaptor.getValue();
+    assertThat(capturedCallback).isNotNull();
+    @SuppressWarnings("unchecked")
+    AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> mockSslContextAndTm =
+        mock(AbstractMap.SimpleImmutableEntry.class);
+    capturedCallback.updateSslContextAndExtendedX509TrustManager(mockSslContextAndTm);
+    verify(mockCallback, times(1))
+        .updateSslContextAndExtendedX509TrustManager(eq(mockSslContextAndTm));
+    verify(mockTlsContextManager, times(1))
+        .releaseClientSslContextProvider(eq(mockSslContextProvider));
+    SslContextProvider.Callback mockCallback = mock(SslContextProvider.Callback.class);
+    supplier.updateSslContext(mockCallback, false);
+    verify(mockTlsContextManager, times(3))
+        .findOrCreateClientSslContextProvider(eq(upstreamTlsContext));
+  }
+
+  @Test
+  public void get_onException() {
+    prepareSupplier();
+    callUpdateSslContext();
+    ArgumentCaptor<SslContextProvider.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(SslContextProvider.Callback.class);
+    verify(mockSslContextProvider, times(1))
+            .addCallback(callbackCaptor.capture());
+    SslContextProvider.Callback capturedCallback = callbackCaptor.getValue();
+    assertThat(capturedCallback).isNotNull();
+    Exception exception = new Exception("test");
+    capturedCallback.onException(exception);
+    verify(mockCallback, times(1)).onException(eq(exception));
+    verify(mockTlsContextManager, times(1))
+        .releaseClientSslContextProvider(eq(mockSslContextProvider));
+  }
+
+  @Test
+  public void systemRootCertsWithMtls_callbackExecutedFromProvider() {
+    upstreamTlsContext =
+        CommonTlsContextTestsUtil.buildNewUpstreamTlsContextForCertProviderInstance(
+            "gcp_id",
+            "cert-default",
+            null,
+            "root-default",
+            null,
+            CertificateValidationContext.newBuilder()
+                .setSystemRootCerts(
+                    CertificateValidationContext.SystemRootCerts.getDefaultInstance())
+                .build());
+    prepareSupplier();
+
+    callUpdateSslContext();
+
+    verify(mockTlsContextManager, times(2))
+        .findOrCreateClientSslContextProvider(eq(upstreamTlsContext));
+    verify(mockTlsContextManager, times(0))
+        .releaseClientSslContextProvider(any(SslContextProvider.class));
+    ArgumentCaptor<SslContextProvider.Callback> callbackCaptor =
+        ArgumentCaptor.forClass(SslContextProvider.Callback.class);
+    verify(mockSslContextProvider, times(1)).addCallback(callbackCaptor.capture());
+    SslContextProvider.Callback capturedCallback = callbackCaptor.getValue();
+    assertThat(capturedCallback).isNotNull();
+    @SuppressWarnings("unchecked")
+    AbstractMap.SimpleImmutableEntry<SslContext, X509TrustManager> mockSslContextAndTm =
+        mock(AbstractMap.SimpleImmutableEntry.class);
+    capturedCallback.updateSslContextAndExtendedX509TrustManager(mockSslContextAndTm);
+    verify(mockCallback, times(1))
+        .updateSslContextAndExtendedX509TrustManager(eq(mockSslContextAndTm));
+    verify(mockTlsContextManager, times(1))
+        .releaseClientSslContextProvider(eq(mockSslContextProvider));
+    SslContextProvider.Callback mockCallback = mock(SslContextProvider.Callback.class);
+    supplier.updateSslContext(mockCallback, false);
+    verify(mockTlsContextManager, times(3))
+        .findOrCreateClientSslContextProvider(eq(upstreamTlsContext));
+  }
+
+  @Test
+  public void testClose() {
+    prepareSupplier();
+    callUpdateSslContext();
+    supplier.close();
+    verify(mockTlsContextManager, times(1))
+        .releaseClientSslContextProvider(eq(mockSslContextProvider));
+    supplier.updateSslContext(mockCallback, false);
+    verify(mockTlsContextManager, times(3))
+        .findOrCreateClientSslContextProvider(eq(upstreamTlsContext));
+    verify(mockTlsContextManager, times(1))
+        .releaseClientSslContextProvider(any(SslContextProvider.class));
+  }
+
+  @Test
+  public void testClose_nullSslContextProvider() {
+    prepareSupplier();
+    doThrow(new NullPointerException()).when(mockTlsContextManager)
+        .releaseClientSslContextProvider(null);
+    supplier.close();
+    verify(mockTlsContextManager, never())
+        .releaseClientSslContextProvider(eq(mockSslContextProvider));
+    callUpdateSslContext();
+    verify(mockTlsContextManager, times(1))
+        .findOrCreateClientSslContextProvider(eq(upstreamTlsContext));
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/TlsContextManagerTest.java b/xds/src/test/java/io/grpc/xds/internal/security/TlsContextManagerTest.java
new file mode 100644
index 00000000000..035096a3528
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/TlsContextManagerTest.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright 2019 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.xds.internal.security;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CA_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_0_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.grpc.xds.EnvoyServerProtoData.DownstreamTlsContext;
+import io.grpc.xds.EnvoyServerProtoData.UpstreamTlsContext;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.CommonBootstrapperTestUtils;
+import io.grpc.xds.internal.security.ReferenceCountingMap.ValueFactory;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for {@link TlsContextManagerImpl}. */
+@RunWith(JUnit4.class)
+public class TlsContextManagerTest {
+
+  @Rule public final MockitoRule mockitoRule = MockitoJUnit.rule();
+
+  @Mock ValueFactory<UpstreamTlsContext, SslContextProvider> mockClientFactory;
+
+  @Mock ValueFactory<DownstreamTlsContext, SslContextProvider> mockServerFactory;
+
+  @Test
+  public void createServerSslContextProvider() {
+    Bootstrapper.BootstrapInfo bootstrapInfoForServer = CommonBootstrapperTestUtils
+        .buildBootstrapInfo("google_cloud_private_spiffe-server", SERVER_1_KEY_FILE,
+            SERVER_1_PEM_FILE, CA_PEM_FILE, null, null, null, null, null);
+    DownstreamTlsContext downstreamTlsContext =
+        CommonTlsContextTestsUtil.buildDownstreamTlsContext(
+            "google_cloud_private_spiffe-server", false, false);
+
+    TlsContextManagerImpl tlsContextManagerImpl = new TlsContextManagerImpl(bootstrapInfoForServer);
+    SslContextProvider serverSecretProvider =
+        tlsContextManagerImpl.findOrCreateServerSslContextProvider(downstreamTlsContext);
+    assertThat(serverSecretProvider).isNotNull();
+
+    SslContextProvider serverSecretProvider1 =
+        tlsContextManagerImpl.findOrCreateServerSslContextProvider(downstreamTlsContext);
+    assertThat(serverSecretProvider1).isSameInstanceAs(serverSecretProvider);
+  }
+
+  @Test
+  public void createClientSslContextProvider() {
+    Bootstrapper.BootstrapInfo bootstrapInfoForClient = CommonBootstrapperTestUtils
+        .buildBootstrapInfo("google_cloud_private_spiffe-client", CLIENT_KEY_FILE, CLIENT_PEM_FILE,
+            CA_PEM_FILE, null, null, null, null, null);
+    UpstreamTlsContext upstreamTlsContext =
+        CommonTlsContextTestsUtil
+            .buildUpstreamTlsContext("google_cloud_private_spiffe-client", false);
+
+    TlsContextManagerImpl tlsContextManagerImpl = new TlsContextManagerImpl(bootstrapInfoForClient);
+    SslContextProvider clientSecretProvider =
+        tlsContextManagerImpl.findOrCreateClientSslContextProvider(upstreamTlsContext);
+    assertThat(clientSecretProvider).isNotNull();
+
+    SslContextProvider clientSecretProvider1 =
+        tlsContextManagerImpl.findOrCreateClientSslContextProvider(upstreamTlsContext);
+    assertThat(clientSecretProvider1).isSameInstanceAs(clientSecretProvider);
+  }
+
+  @Test
+  public void createServerSslContextProvider_differentInstance() {
+    Bootstrapper.BootstrapInfo bootstrapInfoForServer = CommonBootstrapperTestUtils
+        .buildBootstrapInfo("google_cloud_private_spiffe-server", SERVER_1_KEY_FILE,
+            SERVER_1_PEM_FILE, CA_PEM_FILE, "cert-instance2", SERVER_0_KEY_FILE, SERVER_0_PEM_FILE,
+            CA_PEM_FILE, null);
+    DownstreamTlsContext downstreamTlsContext =
+        CommonTlsContextTestsUtil.buildDownstreamTlsContext(
+            "google_cloud_private_spiffe-server", false, false);
+
+    TlsContextManagerImpl tlsContextManagerImpl = new TlsContextManagerImpl(bootstrapInfoForServer);
+    SslContextProvider serverSecretProvider =
+        tlsContextManagerImpl.findOrCreateServerSslContextProvider(downstreamTlsContext);
+    assertThat(serverSecretProvider).isNotNull();
+
+    DownstreamTlsContext downstreamTlsContext1 =
+        CommonTlsContextTestsUtil.buildDownstreamTlsContext(
+            "cert-instance2", true, true);
+
+    SslContextProvider serverSecretProvider1 =
+        tlsContextManagerImpl.findOrCreateServerSslContextProvider(downstreamTlsContext1);
+    assertThat(serverSecretProvider1).isNotNull();
+    assertThat(serverSecretProvider1).isNotSameInstanceAs(serverSecretProvider);
+  }
+
+  @Test
+  public void createClientSslContextProvider_differentInstance() {
+    Bootstrapper.BootstrapInfo bootstrapInfoForClient = CommonBootstrapperTestUtils
+        .buildBootstrapInfo("google_cloud_private_spiffe-client", CLIENT_KEY_FILE, CLIENT_PEM_FILE,
+            CA_PEM_FILE, "cert-instance-2", CLIENT_KEY_FILE, CLIENT_PEM_FILE, CA_PEM_FILE, null);
+    UpstreamTlsContext upstreamTlsContext =
+        CommonTlsContextTestsUtil
+            .buildUpstreamTlsContext("google_cloud_private_spiffe-client", false);
+
+    TlsContextManagerImpl tlsContextManagerImpl = new TlsContextManagerImpl(bootstrapInfoForClient);
+    SslContextProvider clientSecretProvider =
+        tlsContextManagerImpl.findOrCreateClientSslContextProvider(upstreamTlsContext);
+    assertThat(clientSecretProvider).isNotNull();
+
+    UpstreamTlsContext upstreamTlsContext1 =
+        CommonTlsContextTestsUtil.buildUpstreamTlsContext("cert-instance-2", true);
+
+    SslContextProvider clientSecretProvider1 =
+        tlsContextManagerImpl.findOrCreateClientSslContextProvider(upstreamTlsContext1);
+    assertThat(clientSecretProvider1).isNotSameInstanceAs(clientSecretProvider);
+  }
+
+  @Test
+  public void createServerSslContextProvider_releaseInstance() {
+    DownstreamTlsContext downstreamTlsContext =
+        CommonTlsContextTestsUtil.buildDownstreamTlsContext(
+            "google_cloud_private_spiffe-server", false, false);
+
+    TlsContextManagerImpl tlsContextManagerImpl =
+        new TlsContextManagerImpl(mockClientFactory, mockServerFactory);
+    SslContextProvider mockProvider = mock(SslContextProvider.class);
+    when(mockServerFactory.create(downstreamTlsContext)).thenReturn(mockProvider);
+    SslContextProvider serverSecretProvider =
+        tlsContextManagerImpl.findOrCreateServerSslContextProvider(downstreamTlsContext);
+    assertThat(serverSecretProvider).isSameInstanceAs(mockProvider);
+    verify(mockProvider, never()).close();
+    when(mockProvider.getDownstreamTlsContext()).thenReturn(downstreamTlsContext);
+    tlsContextManagerImpl.releaseServerSslContextProvider(mockProvider);
+    verify(mockProvider, times(1)).close();
+  }
+
+  @Test
+  public void createClientSslContextProvider_releaseInstance() {
+    UpstreamTlsContext upstreamTlsContext =
+        CommonTlsContextTestsUtil
+            .buildUpstreamTlsContext("google_cloud_private_spiffe-client", true);
+
+    TlsContextManagerImpl tlsContextManagerImpl =
+        new TlsContextManagerImpl(mockClientFactory, mockServerFactory);
+    SslContextProvider mockProvider = mock(SslContextProvider.class);
+    when(mockClientFactory.create(upstreamTlsContext)).thenReturn(mockProvider);
+    SslContextProvider clientSecretProvider =
+        tlsContextManagerImpl.findOrCreateClientSslContextProvider(upstreamTlsContext);
+    assertThat(clientSecretProvider).isSameInstanceAs(mockProvider);
+    verify(mockProvider, never()).close();
+    when(mockProvider.getUpstreamTlsContext()).thenReturn(upstreamTlsContext);
+    tlsContextManagerImpl.releaseClientSslContextProvider(mockProvider);
+    verify(mockProvider, times(1)).close();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CertProviderClientSslContextProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CertProviderClientSslContextProviderTest.java
new file mode 100644
index 00000000000..91f02863ca4
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CertProviderClientSslContextProviderTest.java
@@ -0,0 +1,547 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CA_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.doChecksOnSslContext;
+import static io.grpc.xds.internal.security.certprovider.CommonCertProviderTestUtils.getCertFromResourceName;
+import static org.junit.Assert.fail;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.MoreExecutors;
+import io.envoyproxy.envoy.config.core.v3.DataSource;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.grpc.xds.EnvoyServerProtoData;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.CommonBootstrapperTestUtils;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil.TestCallback;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.Executor;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link CertProviderClientSslContextProvider}. */
+@RunWith(JUnit4.class)
+public class CertProviderClientSslContextProviderTest {
+  private static final Logger logger =
+      Logger.getLogger(CertProviderClientSslContextProviderTest.class.getName());
+
+  CertificateProviderRegistry certificateProviderRegistry;
+  CertificateProviderStore certificateProviderStore;
+  private CertProviderClientSslContextProviderFactory certProviderClientSslContextProviderFactory;
+
+  @Before
+  public void setUp() throws Exception {
+    certificateProviderRegistry = new CertificateProviderRegistry();
+    certificateProviderStore = new CertificateProviderStore(certificateProviderRegistry);
+    certProviderClientSslContextProviderFactory =
+        new CertProviderClientSslContextProviderFactory(certificateProviderStore);
+  }
+
+  /** Helper method to build CertProviderClientSslContextProvider. */
+  private CertProviderClientSslContextProvider getSslContextProvider(
+      String certInstanceName,
+      String rootInstanceName,
+      Bootstrapper.BootstrapInfo bootstrapInfo,
+      Iterable<String> alpnProtocols,
+      CertificateValidationContext staticCertValidationContext,
+      boolean useSystemRootCerts) {
+    EnvoyServerProtoData.UpstreamTlsContext upstreamTlsContext;
+    if (useSystemRootCerts) {
+      upstreamTlsContext =
+              CommonTlsContextTestsUtil.buildNewUpstreamTlsContextForCertProviderInstance(
+                      certInstanceName,
+                      "cert-default",
+                      rootInstanceName,
+                      "root-default",
+                      alpnProtocols,
+                      staticCertValidationContext);
+    } else {
+      upstreamTlsContext =
+              CommonTlsContextTestsUtil.buildUpstreamTlsContextForCertProviderInstance(
+                      certInstanceName,
+                      "cert-default",
+                      rootInstanceName,
+                      "root-default",
+                      alpnProtocols,
+                      staticCertValidationContext);
+    }
+    return (CertProviderClientSslContextProvider)
+        certProviderClientSslContextProviderFactory.getProvider(
+            upstreamTlsContext,
+            bootstrapInfo.node().toEnvoyProtoNode(),
+            bootstrapInfo.certProviders());
+  }
+
+  /** Helper method to build CertProviderClientSslContextProvider. */
+  private CertProviderClientSslContextProvider getNewSslContextProvider(
+          String certInstanceName,
+          String rootInstanceName,
+          Bootstrapper.BootstrapInfo bootstrapInfo,
+          Iterable<String> alpnProtocols,
+          CertificateValidationContext staticCertValidationContext) {
+    EnvoyServerProtoData.UpstreamTlsContext upstreamTlsContext =
+            CommonTlsContextTestsUtil.buildNewUpstreamTlsContextForCertProviderInstance(
+                    certInstanceName,
+                    "cert-default",
+                    rootInstanceName,
+                    "root-default",
+                    alpnProtocols,
+                    staticCertValidationContext);
+    return (CertProviderClientSslContextProvider)
+        certProviderClientSslContextProviderFactory.getProvider(
+            upstreamTlsContext,
+            bootstrapInfo.node().toEnvoyProtoNode(),
+            bootstrapInfo.certProviders());
+  }
+
+  @Test
+  public void testProviderForClient_mtls() throws Exception {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "testca", 0);
+    CertProviderClientSslContextProvider provider =
+        getSslContextProvider(
+            "gcp_id",
+            "gcp_id",
+            CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+            /* alpnProtocols= */ null,
+            /* staticCertValidationContext= */ null, false);
+
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNull();
+
+    // now generate cert update
+    watcherCaptor[0].updateCertificate(
+        CommonCertProviderTestUtils.getPrivateKey(CLIENT_KEY_FILE),
+        ImmutableList.of(getCertFromResourceName(CLIENT_PEM_FILE)));
+    assertThat(provider.savedKey).isNotNull();
+    assertThat(provider.savedCertChain).isNotNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNull();
+
+    // now generate root cert update
+    watcherCaptor[0].updateTrustedRoots(ImmutableList.of(getCertFromResourceName(CA_PEM_FILE)));
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+
+    TestCallback testCallback =
+        CommonTlsContextTestsUtil.getValueThruCallback(provider);
+
+    doChecksOnSslContext(false, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
+    TestCallback testCallback1 =
+        CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isSameInstanceAs(testCallback.updatedSslContext);
+
+    // just do root cert update: sslContext should still be the same
+    watcherCaptor[0].updateTrustedRoots(
+        ImmutableList.of(getCertFromResourceName(SERVER_0_PEM_FILE)));
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNotNull();
+    testCallback1 = CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isSameInstanceAs(testCallback.updatedSslContext);
+
+    // now update id cert: sslContext should be updated i.e.different from the previous one
+    watcherCaptor[0].updateCertificate(
+        CommonCertProviderTestUtils.getPrivateKey(SERVER_1_KEY_FILE),
+        ImmutableList.of(getCertFromResourceName(SERVER_1_PEM_FILE)));
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+    testCallback1 = CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isNotSameInstanceAs(testCallback.updatedSslContext);
+  }
+
+  @Test
+  public void testProviderForClient_systemRootCerts_mtls() throws Exception {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "testca", 0);
+    CertProviderClientSslContextProvider provider =
+        getSslContextProvider(
+            "gcp_id",
+            null,
+            CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+            /* alpnProtocols= */ null,
+            CertificateValidationContext.newBuilder()
+                .setSystemRootCerts(
+                    CertificateValidationContext.SystemRootCerts.getDefaultInstance())
+                .build(),
+        true);
+
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNotNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNull();
+
+    // now generate cert update
+    watcherCaptor[0].updateCertificate(
+        CommonCertProviderTestUtils.getPrivateKey(CLIENT_KEY_FILE),
+        ImmutableList.of(getCertFromResourceName(CLIENT_PEM_FILE)));
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNotNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+
+    TestCallback testCallback =
+        CommonTlsContextTestsUtil.getValueThruCallback(provider);
+
+    doChecksOnSslContext(false, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
+    TestCallback testCallback1 =
+        CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isSameInstanceAs(testCallback.updatedSslContext);
+
+    // now update id cert: sslContext should be updated i.e. different from the previous one
+    watcherCaptor[0].updateCertificate(
+        CommonCertProviderTestUtils.getPrivateKey(SERVER_1_KEY_FILE),
+        ImmutableList.of(getCertFromResourceName(SERVER_1_PEM_FILE)));
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNotNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+    testCallback1 = CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isNotSameInstanceAs(testCallback.updatedSslContext);
+  }
+
+  @Test
+  public void testProviderForClient_systemRootCerts_regularTls() {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+            new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+            certificateProviderRegistry, watcherCaptor, "testca", 0);
+    CertProviderClientSslContextProvider provider =
+        getSslContextProvider(
+                null,
+                null,
+            CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+            /* alpnProtocols= */ null,
+            CertificateValidationContext.newBuilder()
+                .setSystemRootCerts(
+                        CertificateValidationContext.SystemRootCerts.getDefaultInstance())
+                .build(),
+            true);
+
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNotNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+    TestCallback testCallback =
+        CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback.updatedSslContext).isEqualTo(provider.getSslContextAndTrustManager());
+
+    assertThat(watcherCaptor[0]).isNull();
+  }
+
+  @Test
+  public void testProviderForClient_mtls_newXds() throws Exception {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+            new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+            certificateProviderRegistry, watcherCaptor, "testca", 0);
+    CertProviderClientSslContextProvider provider =
+            getNewSslContextProvider(
+                    "gcp_id",
+                    "gcp_id",
+                    CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+                    /* alpnProtocols= */ null,
+                    /* staticCertValidationContext= */ null);
+
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNull();
+
+    // now generate cert update
+    watcherCaptor[0].updateCertificate(
+            CommonCertProviderTestUtils.getPrivateKey(CLIENT_KEY_FILE),
+            ImmutableList.of(getCertFromResourceName(CLIENT_PEM_FILE)));
+    assertThat(provider.savedKey).isNotNull();
+    assertThat(provider.savedCertChain).isNotNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNull();
+
+    // now generate root cert update
+    watcherCaptor[0].updateTrustedRoots(ImmutableList.of(getCertFromResourceName(CA_PEM_FILE)));
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+
+    TestCallback testCallback =
+            CommonTlsContextTestsUtil.getValueThruCallback(provider);
+
+    doChecksOnSslContext(false, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
+    TestCallback testCallback1 =
+            CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isSameInstanceAs(testCallback.updatedSslContext);
+
+    // just do root cert update: sslContext should still be the same
+    watcherCaptor[0].updateTrustedRoots(
+            ImmutableList.of(getCertFromResourceName(SERVER_0_PEM_FILE)));
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNotNull();
+    testCallback1 = CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isSameInstanceAs(testCallback.updatedSslContext);
+
+    // now update id cert: sslContext should be updated i.e.different from the previous one
+    watcherCaptor[0].updateCertificate(
+            CommonCertProviderTestUtils.getPrivateKey(SERVER_1_KEY_FILE),
+            ImmutableList.of(getCertFromResourceName(SERVER_1_PEM_FILE)));
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+    testCallback1 = CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isNotSameInstanceAs(testCallback.updatedSslContext);
+  }
+
+  @Test
+  public void testProviderForClient_queueExecutor() throws Exception {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "testca", 0);
+    CertProviderClientSslContextProvider provider =
+        getSslContextProvider(
+            "gcp_id",
+            "gcp_id",
+            CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+            /* alpnProtocols= */ null,
+            /* staticCertValidationContext= */ null, false);
+    QueuedExecutor queuedExecutor = new QueuedExecutor();
+
+    TestCallback testCallback =
+        CommonTlsContextTestsUtil.getValueThruCallback(provider, queuedExecutor);
+    assertThat(queuedExecutor.runQueue).isEmpty();
+
+    // now generate cert update
+    watcherCaptor[0].updateCertificate(
+        CommonCertProviderTestUtils.getPrivateKey(CLIENT_KEY_FILE),
+        ImmutableList.of(getCertFromResourceName(CLIENT_PEM_FILE)));
+    assertThat(queuedExecutor.runQueue).isEmpty(); // still empty
+
+    // now generate root cert update
+    watcherCaptor[0].updateTrustedRoots(ImmutableList.of(getCertFromResourceName(CA_PEM_FILE)));
+    assertThat(queuedExecutor.runQueue).hasSize(1);
+    queuedExecutor.drain();
+
+    doChecksOnSslContext(false, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
+  }
+
+  @Test
+  public void testProviderForClient_tls() throws Exception {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "testca", 0);
+    CertProviderClientSslContextProvider provider =
+        getSslContextProvider(
+            /* certInstanceName= */ null,
+            "gcp_id",
+            CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+            /* alpnProtocols= */ null,
+            /* staticCertValidationContext= */ null, false);
+
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNull();
+
+    // now generate root cert update
+    watcherCaptor[0].updateTrustedRoots(ImmutableList.of(getCertFromResourceName(CA_PEM_FILE)));
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+
+    TestCallback testCallback =
+        CommonTlsContextTestsUtil.getValueThruCallback(provider);
+
+    doChecksOnSslContext(false, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
+  }
+
+  @Test
+  public void testProviderForClient_sslContextException_onError() throws Exception {
+    CertificateValidationContext staticCertValidationContext =
+            CertificateValidationContext.newBuilder()
+                    .setTrustedCa(DataSource.newBuilder().setInlineString("foo"))
+                    .build();
+
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+            new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+            certificateProviderRegistry, watcherCaptor, "testca", 0);
+    CertProviderClientSslContextProvider provider =
+            getSslContextProvider(
+                    /* certInstanceName= */ null,
+                    "gcp_id",
+                    CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+                    /* alpnProtocols= */null,
+                    staticCertValidationContext, false);
+
+    TestCallback testCallback = new TestCallback(MoreExecutors.directExecutor());
+    provider.addCallback(testCallback);
+    try {
+      watcherCaptor[0].updateTrustedRoots(ImmutableList.of(getCertFromResourceName(CA_PEM_FILE)));
+      fail("exception expected");
+    } catch (RuntimeException expected) {
+      assertThat(expected)
+          .hasMessageThat()
+          .contains("only static certificateValidationContext expected");
+    }
+    assertThat(testCallback.updatedThrowable).isNotNull();
+    assertThat(testCallback.updatedThrowable)
+        .hasCauseThat()
+        .hasMessageThat()
+        .contains("only static certificateValidationContext expected");
+  }
+
+  @Test
+  public void testProviderForClient_rootInstanceNull_and_notUsingSystemRootCerts_expectError()
+      throws Exception {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "testca", 0);
+    try {
+      getSslContextProvider(
+          /* certInstanceName= */ null,
+          /* rootInstanceName= */ null,
+          CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+          /* alpnProtocols= */ null,
+          /* staticCertValidationContext= */ null, false);
+      fail("exception expected");
+    } catch (UnsupportedOperationException expected) {
+      assertThat(expected).hasMessageThat().contains("Unsupported configurations in "
+          + "UpstreamTlsContext!");
+    }
+  }
+
+  @Test
+  public void testProviderForClient_rootInstanceNull_but_isUsingSystemRootCerts_valid()
+      throws Exception {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "testca", 0);
+    getSslContextProvider(
+        /* certInstanceName= */ null,
+        /* rootInstanceName= */ null,
+        CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+        /* alpnProtocols= */ null,
+        CertificateValidationContext.newBuilder()
+            .setSystemRootCerts(
+                CertificateValidationContext.SystemRootCerts.newBuilder().build())
+            .build(), false);
+  }
+
+  @Test
+  public void testProviderForClient_deprecatedCertProviderField() throws Exception {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "testca", 0);
+    
+    // Build UpstreamTlsContext using deprecated field
+    EnvoyServerProtoData.UpstreamTlsContext upstreamTlsContext =
+        new EnvoyServerProtoData.UpstreamTlsContext(
+            CommonTlsContextTestsUtil.buildCommonTlsContextWithDeprecatedCertProviderInstance(
+                "gcp_id",
+                "cert-default",
+                "gcp_id",
+                "root-default",
+                /* alpnProtocols= */ null,
+                /* staticCertValidationContext= */ null));
+    
+    Bootstrapper.BootstrapInfo bootstrapInfo = CommonBootstrapperTestUtils.getTestBootstrapInfo();
+    CertProviderClientSslContextProvider provider =
+        (CertProviderClientSslContextProvider)
+            certProviderClientSslContextProviderFactory.getProvider(
+                upstreamTlsContext,
+                bootstrapInfo.node().toEnvoyProtoNode(),
+                bootstrapInfo.certProviders());
+
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNull();
+
+    // Generate cert update
+    watcherCaptor[0].updateCertificate(
+        CommonCertProviderTestUtils.getPrivateKey(CLIENT_KEY_FILE),
+        ImmutableList.of(getCertFromResourceName(CLIENT_PEM_FILE)));
+    assertThat(provider.savedKey).isNotNull();
+    assertThat(provider.savedCertChain).isNotNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNull();
+
+    // Generate root cert update
+    watcherCaptor[0].updateTrustedRoots(ImmutableList.of(getCertFromResourceName(CA_PEM_FILE)));
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+
+    TestCallback testCallback =
+        CommonTlsContextTestsUtil.getValueThruCallback(provider);
+
+    doChecksOnSslContext(false, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
+  }
+
+  static class QueuedExecutor implements Executor {
+    /** A list of Runnables to be run in order. */
+    @VisibleForTesting final Queue<Runnable> runQueue = new ConcurrentLinkedQueue<>();
+
+    @Override
+    public synchronized void execute(Runnable r) {
+      runQueue.add(checkNotNull(r, "'r' must not be null."));
+    }
+
+    public synchronized void drain() {
+      Runnable r;
+      while ((r = runQueue.poll()) != null) {
+        try {
+          r.run();
+        } catch (RuntimeException e) {
+          // Log it and keep going.
+          logger.log(Level.SEVERE, "Exception while executing runnable " + r, e);
+        }
+      }
+    }
+  }
+
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CertProviderServerSslContextProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CertProviderServerSslContextProviderTest.java
new file mode 100644
index 00000000000..93559f47245
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CertProviderServerSslContextProviderTest.java
@@ -0,0 +1,376 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CA_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_0_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.doChecksOnSslContext;
+import static io.grpc.xds.internal.security.certprovider.CommonCertProviderTestUtils.getCertFromResourceName;
+import static org.junit.Assert.fail;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.MoreExecutors;
+import io.envoyproxy.envoy.config.core.v3.DataSource;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import io.grpc.xds.EnvoyServerProtoData;
+import io.grpc.xds.client.Bootstrapper;
+import io.grpc.xds.client.CommonBootstrapperTestUtils;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil.TestCallback;
+import io.grpc.xds.internal.security.certprovider.CertProviderClientSslContextProviderTest.QueuedExecutor;
+import java.util.Arrays;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link CertProviderServerSslContextProvider}. */
+@RunWith(JUnit4.class)
+public class CertProviderServerSslContextProviderTest {
+
+  CertificateProviderRegistry certificateProviderRegistry;
+  CertificateProviderStore certificateProviderStore;
+  private CertProviderServerSslContextProviderFactory certProviderServerSslContextProviderFactory;
+
+  @Before
+  public void setUp() throws Exception {
+    certificateProviderRegistry = new CertificateProviderRegistry();
+    certificateProviderStore = new CertificateProviderStore(certificateProviderRegistry);
+    certProviderServerSslContextProviderFactory =
+        new CertProviderServerSslContextProviderFactory(certificateProviderStore);
+  }
+
+  /** Helper method to build CertProviderServerSslContextProvider. */
+  private CertProviderServerSslContextProvider getSslContextProvider(
+      String certInstanceName,
+      String rootInstanceName,
+      Bootstrapper.BootstrapInfo bootstrapInfo,
+      Iterable<String> alpnProtocols,
+      CertificateValidationContext staticCertValidationContext,
+      boolean requireClientCert) {
+    EnvoyServerProtoData.DownstreamTlsContext downstreamTlsContext =
+        CommonTlsContextTestsUtil.buildDownstreamTlsContextForCertProviderInstance(
+            certInstanceName,
+            "cert-default",
+            rootInstanceName,
+            "root-default",
+            alpnProtocols,
+            staticCertValidationContext,
+            requireClientCert);
+    return (CertProviderServerSslContextProvider)
+        certProviderServerSslContextProviderFactory.getProvider(
+            downstreamTlsContext,
+            bootstrapInfo.node().toEnvoyProtoNode(),
+            bootstrapInfo.certProviders());
+  }
+
+  /** Helper method to build CertProviderServerSslContextProvider. */
+  private CertProviderServerSslContextProvider getNewSslContextProvider(
+          String certInstanceName,
+          String rootInstanceName,
+          Bootstrapper.BootstrapInfo bootstrapInfo,
+          Iterable<String> alpnProtocols,
+          CertificateValidationContext staticCertValidationContext,
+          boolean requireClientCert) {
+    EnvoyServerProtoData.DownstreamTlsContext downstreamTlsContext =
+            CommonTlsContextTestsUtil.buildNewDownstreamTlsContextForCertProviderInstance(
+                    certInstanceName,
+                    "cert-default",
+                    rootInstanceName,
+                    "root-default",
+                    alpnProtocols,
+                    staticCertValidationContext,
+                    requireClientCert);
+    return (CertProviderServerSslContextProvider)
+        certProviderServerSslContextProviderFactory.getProvider(
+            downstreamTlsContext,
+            bootstrapInfo.node().toEnvoyProtoNode(),
+            bootstrapInfo.certProviders());
+  }
+
+
+  @Test
+  public void testProviderForServer_mtls() throws Exception {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "testca", 0);
+    CertProviderServerSslContextProvider provider =
+        getSslContextProvider(
+            "gcp_id",
+            "gcp_id",
+            CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+            /* alpnProtocols= */ null,
+            /* staticCertValidationContext= */ null,
+            /* requireClientCert= */ true);
+
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNull();
+
+    // now generate cert update
+    watcherCaptor[0].updateCertificate(
+        CommonCertProviderTestUtils.getPrivateKey(SERVER_0_KEY_FILE),
+        ImmutableList.of(getCertFromResourceName(SERVER_0_PEM_FILE)));
+    assertThat(provider.savedKey).isNotNull();
+    assertThat(provider.savedCertChain).isNotNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNull();
+
+    // now generate root cert update
+    watcherCaptor[0].updateTrustedRoots(ImmutableList.of(getCertFromResourceName(CA_PEM_FILE)));
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+
+    TestCallback testCallback =
+        CommonTlsContextTestsUtil.getValueThruCallback(provider);
+
+    doChecksOnSslContext(true, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
+    TestCallback testCallback1 =
+        CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isSameInstanceAs(testCallback.updatedSslContext);
+
+    // just do root cert update: sslContext should still be the same
+    watcherCaptor[0].updateTrustedRoots(
+        ImmutableList.of(getCertFromResourceName(CLIENT_PEM_FILE)));
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNotNull();
+    testCallback1 = CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isSameInstanceAs(testCallback.updatedSslContext);
+
+    // now update id cert: sslContext should be updated i.e.different from the previous one
+    watcherCaptor[0].updateCertificate(
+        CommonCertProviderTestUtils.getPrivateKey(SERVER_1_KEY_FILE),
+        ImmutableList.of(getCertFromResourceName(SERVER_1_PEM_FILE)));
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+    testCallback1 = CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isNotSameInstanceAs(testCallback.updatedSslContext);
+  }
+
+  @Test
+  public void testProviderForServer_mtls_newXds() throws Exception {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+            new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+            certificateProviderRegistry, watcherCaptor, "testca", 0);
+    @SuppressWarnings("deprecation")
+    CertificateValidationContext staticCertValidationContext =
+        CertificateValidationContext.newBuilder().addAllMatchSubjectAltNames(Arrays
+            .asList(StringMatcher.newBuilder().setExact("foo.com").build(),
+                StringMatcher.newBuilder().setExact("bar.com").build())).build();
+    CertProviderServerSslContextProvider provider =
+            getNewSslContextProvider(
+                    "gcp_id",
+                    "gcp_id",
+                    CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+                    /* alpnProtocols= */ null,
+                    staticCertValidationContext,
+                    /* requireClientCert= */ true);
+
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNull();
+
+    // now generate cert update
+    watcherCaptor[0].updateCertificate(
+            CommonCertProviderTestUtils.getPrivateKey(SERVER_0_KEY_FILE),
+            ImmutableList.of(getCertFromResourceName(SERVER_0_PEM_FILE)));
+    assertThat(provider.savedKey).isNotNull();
+    assertThat(provider.savedCertChain).isNotNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNull();
+
+    // now generate root cert update
+    watcherCaptor[0].updateTrustedRoots(ImmutableList.of(getCertFromResourceName(CA_PEM_FILE)));
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+
+    TestCallback testCallback =
+            CommonTlsContextTestsUtil.getValueThruCallback(provider);
+
+    doChecksOnSslContext(true, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
+    TestCallback testCallback1 =
+            CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isSameInstanceAs(testCallback.updatedSslContext);
+
+    // just do root cert update: sslContext should still be the same
+    watcherCaptor[0].updateTrustedRoots(
+            ImmutableList.of(getCertFromResourceName(CLIENT_PEM_FILE)));
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNotNull();
+    testCallback1 = CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isSameInstanceAs(testCallback.updatedSslContext);
+
+    // now update id cert: sslContext should be updated i.e.different from the previous one
+    watcherCaptor[0].updateCertificate(
+            CommonCertProviderTestUtils.getPrivateKey(SERVER_1_KEY_FILE),
+            ImmutableList.of(getCertFromResourceName(SERVER_1_PEM_FILE)));
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+    testCallback1 = CommonTlsContextTestsUtil.getValueThruCallback(provider);
+    assertThat(testCallback1.updatedSslContext).isNotSameInstanceAs(testCallback.updatedSslContext);
+  }
+
+  @Test
+  public void testProviderForServer_queueExecutor() throws Exception {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "testca", 0);
+    CertProviderServerSslContextProvider provider =
+        getSslContextProvider(
+            "gcp_id",
+            "gcp_id",
+            CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+            /* alpnProtocols= */ null,
+            /* staticCertValidationContext= */ null,
+            /* requireClientCert= */ true);
+    QueuedExecutor queuedExecutor = new QueuedExecutor();
+
+    TestCallback testCallback =
+        CommonTlsContextTestsUtil.getValueThruCallback(provider, queuedExecutor);
+    assertThat(queuedExecutor.runQueue).isEmpty();
+
+    // now generate cert update
+    watcherCaptor[0].updateCertificate(
+        CommonCertProviderTestUtils.getPrivateKey(SERVER_0_KEY_FILE),
+        ImmutableList.of(getCertFromResourceName(SERVER_0_PEM_FILE)));
+    assertThat(queuedExecutor.runQueue).isEmpty(); // still empty
+
+    // now generate root cert update
+    watcherCaptor[0].updateTrustedRoots(ImmutableList.of(getCertFromResourceName(CA_PEM_FILE)));
+    assertThat(queuedExecutor.runQueue).hasSize(1);
+    queuedExecutor.drain();
+
+    doChecksOnSslContext(true, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
+  }
+
+  @Test
+  public void testProviderForServer_tls() throws Exception {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "testca", 0);
+    CertProviderServerSslContextProvider provider =
+        getSslContextProvider(
+            "gcp_id",
+            /* rootInstanceName= */ null,
+            CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+            /* alpnProtocols= */ null,
+            /* staticCertValidationContext= */ null,
+            /* requireClientCert= */ false);
+
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+    assertThat(provider.getSslContextAndTrustManager()).isNull();
+
+    // now generate cert update
+    watcherCaptor[0].updateCertificate(
+            CommonCertProviderTestUtils.getPrivateKey(SERVER_0_KEY_FILE),
+            ImmutableList.of(getCertFromResourceName(SERVER_0_PEM_FILE)));
+
+    assertThat(provider.getSslContextAndTrustManager()).isNotNull();
+    assertThat(provider.savedKey).isNull();
+    assertThat(provider.savedCertChain).isNull();
+    assertThat(provider.savedTrustedRoots).isNull();
+
+    TestCallback testCallback =
+        CommonTlsContextTestsUtil.getValueThruCallback(provider);
+
+    doChecksOnSslContext(true, testCallback.updatedSslContext, /* expectedApnProtos= */ null);
+  }
+
+  @Test
+  public void testProviderForServer_sslContextException_onError() throws Exception {
+    CertificateValidationContext staticCertValidationContext =
+            CertificateValidationContext.newBuilder()
+                    .setTrustedCa(DataSource.newBuilder().setInlineString("foo"))
+                    .build();
+
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+            new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+            certificateProviderRegistry, watcherCaptor, "testca", 0);
+    CertProviderServerSslContextProvider provider =
+            getSslContextProvider(
+                    /* certInstanceName= */ "gcp_id",
+                    /* rootInstanceName= */ "gcp_id",
+                    CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+                    /* alpnProtocols= */null,
+                    staticCertValidationContext,
+                    /* requireClientCert= */ true);
+
+    // now generate cert update
+    watcherCaptor[0].updateCertificate(
+            CommonCertProviderTestUtils.getPrivateKey(SERVER_0_KEY_FILE),
+            ImmutableList.of(getCertFromResourceName(SERVER_0_PEM_FILE)));
+
+    TestCallback testCallback = new TestCallback(MoreExecutors.directExecutor());
+    provider.addCallback(testCallback);
+    try {
+      watcherCaptor[0].updateTrustedRoots(ImmutableList.of(getCertFromResourceName(CA_PEM_FILE)));
+      fail("exception expected");
+    } catch (RuntimeException expected) {
+      assertThat(expected)
+          .hasMessageThat()
+          .contains("only static certificateValidationContext expected");
+    }
+    assertThat(testCallback.updatedThrowable).isNotNull();
+    assertThat(testCallback.updatedThrowable)
+        .hasCauseThat()
+        .hasMessageThat()
+        .contains("only static certificateValidationContext expected");
+  }
+
+  @Test
+  public void testProviderForServer_certInstanceNull_expectError() throws Exception {
+    final CertificateProvider.DistributorWatcher[] watcherCaptor =
+        new CertificateProvider.DistributorWatcher[1];
+    TestCertificateProvider.createAndRegisterProviderProvider(
+        certificateProviderRegistry, watcherCaptor, "testca", 0);
+    try {
+      getSslContextProvider(
+          /* certInstanceName= */ null,
+          /* rootInstanceName= */ null,
+          CommonBootstrapperTestUtils.getTestBootstrapInfo(),
+          /* alpnProtocols= */ null,
+          /* staticCertValidationContext= */ null,
+          /* requireClientCert= */ false);
+      fail("exception expected");
+    } catch (NullPointerException expected) {
+      assertThat(expected).hasMessageThat().contains("Server SSL requires certInstance");
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CertificateProviderStoreTest.java b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CertificateProviderStoreTest.java
new file mode 100644
index 00000000000..c0bc095eab6
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CertificateProviderStoreTest.java
@@ -0,0 +1,346 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.Status;
+import java.security.PrivateKey;
+import java.security.cert.X509Certificate;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentMatchers;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+/** Unit tests for {@link CertificateProviderStore}. */
+@RunWith(JUnit4.class)
+public class CertificateProviderStoreTest {
+
+  private CertificateProviderRegistry certificateProviderRegistry;
+  private CertificateProviderStore certificateProviderStore;
+  private boolean throwExceptionForCertUpdates;
+
+  @Before
+  public void setUp() {
+    certificateProviderRegistry = new CertificateProviderRegistry();
+    certificateProviderStore = new CertificateProviderStore(certificateProviderRegistry);
+    throwExceptionForCertUpdates = false;
+  }
+
+  @Test
+  public void pluginNotRegistered_expectException() {
+    CertificateProvider.Watcher mockWatcher = mock(CertificateProvider.Watcher.class);
+    try {
+      CertificateProviderStore.Handle unused = certificateProviderStore.createOrGetProvider(
+              "cert-name1", "plugin1", "config", mockWatcher, true);
+      fail("exception expected");
+    } catch (IllegalArgumentException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Provider not found for plugin1");
+    }
+  }
+
+  @Test
+  public void pluginUnregistered_expectException() {
+    CertificateProviderProvider certificateProviderProvider = registerPlugin("plugin1");
+    CertificateProvider.Watcher mockWatcher = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle = certificateProviderStore.createOrGetProvider(
+            "cert-name1", "plugin1", "config", mockWatcher, true);
+    handle.close();
+    certificateProviderRegistry.deregister(certificateProviderProvider);
+    try {
+      handle = certificateProviderStore.createOrGetProvider(
+              "cert-name1", "plugin1", "config", mockWatcher, true);
+      fail("exception expected");
+    } catch (IllegalArgumentException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Provider not found for plugin1");
+    }
+  }
+
+  @Test
+  public void notifyCertUpdatesNotSupported_expectException() {
+    CertificateProviderProvider unused = registerPlugin("plugin1");
+    throwExceptionForCertUpdates = true;
+    CertificateProvider.Watcher mockWatcher = mock(CertificateProvider.Watcher.class);
+    try {
+      CertificateProviderStore.Handle unused1 =
+            certificateProviderStore.createOrGetProvider(
+                    "cert-name1", "plugin1", "config", mockWatcher, true);
+      fail("exception expected");
+    } catch (UnsupportedOperationException expected) {
+      assertThat(expected)
+          .hasMessageThat()
+          .isEqualTo("Provider does not support Certificate Updates.");
+    }
+  }
+
+  @Test
+  public void notifyCertUpdatesNotSupported_expectExceptionOnSecondCall() {
+    registerPlugin("plugin1");
+    throwExceptionForCertUpdates = true;
+    CertificateProvider.Watcher mockWatcher = mock(CertificateProvider.Watcher.class);
+    try (CertificateProviderStore.Handle unused =
+        certificateProviderStore
+            .createOrGetProvider("cert-name1", "plugin1", "config", mockWatcher, false)) {
+      try {
+        certificateProviderStore.createOrGetProvider(
+                "cert-name1", "plugin1", "config", mockWatcher, true);
+        fail("exception expected");
+      } catch (UnsupportedOperationException expected) {
+        assertThat(expected)
+            .hasMessageThat()
+            .isEqualTo("Provider does not support Certificate Updates.");
+      }
+    }
+  }
+
+  @Test
+  public void onePluginSameConfig_sameInstance() {
+    registerPlugin("plugin1");
+    CertificateProvider.Watcher mockWatcher1 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle1 = certificateProviderStore.createOrGetProvider(
+                "cert-name1", "plugin1", "config", mockWatcher1, true);
+    CertificateProvider.Watcher mockWatcher2 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle2 = certificateProviderStore.createOrGetProvider(
+                "cert-name1", "plugin1", "config", mockWatcher2, true);
+    assertThat(handle1).isNotSameInstanceAs(handle2);
+    assertThat(handle1.certProvider).isSameInstanceAs(handle2.certProvider);
+    assertThat(handle1.certProvider).isInstanceOf(TestCertificateProvider.class);
+    TestCertificateProvider testCertificateProvider =
+        (TestCertificateProvider) handle1.certProvider;
+    assertThat(testCertificateProvider.startCalled).isEqualTo(1);
+    CertificateProvider.DistributorWatcher distWatcher = testCertificateProvider.getWatcher();
+    assertThat(distWatcher.downstreamWatchers).hasSize(2);
+    PrivateKey testKey = mock(PrivateKey.class);
+    X509Certificate cert = mock(X509Certificate.class);
+    List<X509Certificate> testList = ImmutableList.of(cert);
+    testCertificateProvider.getWatcher().updateCertificate(testKey, testList);
+    verify(mockWatcher1, times(1)).updateCertificate(eq(testKey), eq(testList));
+    verify(mockWatcher2, times(1)).updateCertificate(eq(testKey), eq(testList));
+    reset(mockWatcher1);
+    reset(mockWatcher2);
+    testCertificateProvider.getWatcher().updateTrustedRoots(testList);
+    verify(mockWatcher1, times(1)).updateTrustedRoots(eq(testList));
+    verify(mockWatcher2, times(1)).updateTrustedRoots(eq(testList));
+    reset(mockWatcher1);
+    reset(mockWatcher2);
+    handle1.close();
+    assertThat(testCertificateProvider.closeCalled).isEqualTo(0);
+    assertThat(distWatcher.downstreamWatchers).hasSize(1);
+    testCertificateProvider.getWatcher().updateCertificate(testKey, testList);
+    verify(mockWatcher1, never())
+        .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
+    verify(mockWatcher2, times(1)).updateCertificate(eq(testKey), eq(testList));
+    testCertificateProvider.getWatcher().updateTrustedRoots(testList);
+    verify(mockWatcher2, times(1)).updateTrustedRoots(eq(testList));
+    handle2.close();
+    assertThat(testCertificateProvider.closeCalled).isEqualTo(1);
+  }
+
+  @Test
+  public void onePluginSameConfig_secondWatcherAfterFirstNotify() {
+    registerPlugin("plugin1");
+    CertificateProvider.Watcher mockWatcher1 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle1 = certificateProviderStore.createOrGetProvider(
+            "cert-name1", "plugin1", "config", mockWatcher1, true);
+    TestCertificateProvider testCertificateProvider =
+            (TestCertificateProvider) handle1.certProvider;
+    CertificateProvider.DistributorWatcher distWatcher = testCertificateProvider.getWatcher();
+    PrivateKey testKey = mock(PrivateKey.class);
+    X509Certificate cert = mock(X509Certificate.class);
+    List<X509Certificate> testList = ImmutableList.of(cert);
+    testCertificateProvider.getWatcher().updateCertificate(testKey, testList);
+    verify(mockWatcher1, times(1)).updateCertificate(eq(testKey), eq(testList));
+    testCertificateProvider.getWatcher().updateTrustedRoots(testList);
+    verify(mockWatcher1, times(1)).updateTrustedRoots(eq(testList));
+    testCertificateProvider.getWatcher().onError(Status.CANCELLED);
+    verify(mockWatcher1, times(1)).onError(eq(Status.CANCELLED));
+    reset(mockWatcher1);
+
+    // now add the second watcher
+    CertificateProvider.Watcher mockWatcher2 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle unused = certificateProviderStore.createOrGetProvider(
+            "cert-name1", "plugin1", "config", mockWatcher2, true);
+    assertThat(distWatcher.downstreamWatchers).hasSize(2);
+    // updates sent to the second watcher
+    verify(mockWatcher2, times(1)).updateCertificate(eq(testKey), eq(testList));
+    verify(mockWatcher2, times(1)).updateTrustedRoots(eq(testList));
+    // but not errors!
+    verify(mockWatcher2, never()).onError(eq(Status.CANCELLED));
+    // and none to first one
+    verify(mockWatcher1, never())
+            .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
+    verify(mockWatcher1, never()).updateTrustedRoots(ArgumentMatchers.<X509Certificate>anyList());
+    verify(mockWatcher1, never()).onError(any(Status.class));
+  }
+
+  @Test
+  public void onePluginTwoInstances_notifyError() {
+    registerPlugin("plugin1");
+    CertificateProvider.Watcher mockWatcher1 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle1 = certificateProviderStore.createOrGetProvider(
+                            "cert-name1", "plugin1", "config", mockWatcher1, true);
+    CertificateProvider.Watcher mockWatcher2 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle2 = certificateProviderStore.createOrGetProvider(
+                            "cert-name1", "plugin1", "config", mockWatcher2, true);
+    TestCertificateProvider testCertificateProvider =
+        (TestCertificateProvider) handle1.certProvider;
+    testCertificateProvider.getWatcher().onError(Status.CANCELLED);
+    verify(mockWatcher1, times(1)).onError(eq(Status.CANCELLED));
+    verify(mockWatcher2, times(1)).onError(eq(Status.CANCELLED));
+    handle1.close();
+    handle2.close();
+  }
+
+  @Test
+  public void onePluginDifferentConfig_differentInstance() {
+    CertificateProviderProvider certProviderProvider = registerPlugin("plugin1");
+    CertificateProvider.Watcher mockWatcher1 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle1 = certificateProviderStore.createOrGetProvider(
+                "cert-name1", "plugin1", "config", mockWatcher1, true);
+    CertificateProvider.Watcher mockWatcher2 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle2 = certificateProviderStore.createOrGetProvider(
+                "cert-name1", "plugin1", "config2", mockWatcher2, true);
+    checkDifferentInstances(
+        mockWatcher1, handle1, certProviderProvider, mockWatcher2, handle2, certProviderProvider);
+  }
+
+  @Test
+  public void onePluginDifferentCertName_differentInstance() {
+    CertificateProviderProvider certProviderProvider = registerPlugin("plugin1");
+    CertificateProvider.Watcher mockWatcher1 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle1 = certificateProviderStore.createOrGetProvider(
+                "cert-name1", "plugin1", "config", mockWatcher1, true);
+    CertificateProvider.Watcher mockWatcher2 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle2 = certificateProviderStore.createOrGetProvider(
+                "cert-name2", "plugin1", "config", mockWatcher2, true);
+    checkDifferentInstances(
+        mockWatcher1, handle1, certProviderProvider, mockWatcher2, handle2, certProviderProvider);
+  }
+
+  @Test
+  public void onePluginDifferentNotifyValue_sameInstance() {
+    CertificateProviderProvider unused = registerPlugin("plugin1");
+    CertificateProvider.Watcher mockWatcher1 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle1 = certificateProviderStore.createOrGetProvider(
+                "cert-name1", "plugin1", "config", mockWatcher1, true);
+    CertificateProvider.Watcher mockWatcher2 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle2 = certificateProviderStore.createOrGetProvider(
+                "cert-name1", "plugin1", "config", mockWatcher2, false);
+    assertThat(handle1).isNotSameInstanceAs(handle2);
+    assertThat(handle1.certProvider).isSameInstanceAs(handle2.certProvider);
+  }
+
+  @Test
+  public void twoPlugins_differentInstance() {
+    CertificateProviderProvider certProviderProvider1 = registerPlugin("plugin1");
+    CertificateProviderProvider certProviderProvider2 = registerPlugin("plugin2");
+    CertificateProvider.Watcher mockWatcher1 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle1 = certificateProviderStore.createOrGetProvider(
+                "cert-name1", "plugin1", "config", mockWatcher1, true);
+    CertificateProvider.Watcher mockWatcher2 = mock(CertificateProvider.Watcher.class);
+    CertificateProviderStore.Handle handle2 = certificateProviderStore.createOrGetProvider(
+                "cert-name1", "plugin2", "config", mockWatcher2, true);
+    checkDifferentInstances(
+        mockWatcher1, handle1, certProviderProvider1, mockWatcher2, handle2, certProviderProvider2);
+  }
+
+  private static void checkDifferentInstances(
+      CertificateProvider.Watcher mockWatcher1,
+      CertificateProviderStore.Handle handle1,
+      CertificateProviderProvider certProviderProvider1,
+      CertificateProvider.Watcher mockWatcher2,
+      CertificateProviderStore.Handle handle2,
+      CertificateProviderProvider certProviderProvider2) {
+    assertThat(handle1.certProvider).isNotSameInstanceAs(handle2.certProvider);
+    TestCertificateProvider testCertificateProvider1 =
+        (TestCertificateProvider) handle1.certProvider;
+    TestCertificateProvider testCertificateProvider2 =
+        (TestCertificateProvider) handle2.certProvider;
+    assertThat(testCertificateProvider1.certProviderProvider)
+        .isSameInstanceAs(certProviderProvider1);
+    assertThat(testCertificateProvider2.certProviderProvider)
+        .isSameInstanceAs(certProviderProvider2);
+    CertificateProvider.DistributorWatcher distWatcher1 = testCertificateProvider1.getWatcher();
+    assertThat(distWatcher1.downstreamWatchers).hasSize(1);
+    CertificateProvider.DistributorWatcher distWatcher2 = testCertificateProvider2.getWatcher();
+    assertThat(distWatcher2.downstreamWatchers).hasSize(1);
+    PrivateKey testKey1 = mock(PrivateKey.class);
+    X509Certificate cert1 = mock(X509Certificate.class);
+    List<X509Certificate> testList1 = ImmutableList.of(cert1);
+    testCertificateProvider1.getWatcher().updateCertificate(testKey1, testList1);
+    verify(mockWatcher1, times(1)).updateCertificate(eq(testKey1), eq(testList1));
+    verify(mockWatcher2, never())
+        .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
+    reset(mockWatcher1);
+
+    PrivateKey testKey2 = mock(PrivateKey.class);
+    X509Certificate cert2 = mock(X509Certificate.class);
+    List<X509Certificate> testList2 = ImmutableList.of(cert2);
+    testCertificateProvider2.getWatcher().updateCertificate(testKey2, testList2);
+    verify(mockWatcher2, times(1)).updateCertificate(eq(testKey2), eq(testList2));
+    verify(mockWatcher1, never())
+        .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
+    assertThat(testCertificateProvider1.startCalled).isEqualTo(1);
+    assertThat(testCertificateProvider2.startCalled).isEqualTo(1);
+    handle2.close();
+    assertThat(testCertificateProvider2.closeCalled).isEqualTo(1);
+    handle1.close();
+    assertThat(testCertificateProvider1.closeCalled).isEqualTo(1);
+  }
+
+  private CertificateProviderProvider registerPlugin(String pluginName) {
+    final CertificateProviderProvider certProviderProvider =
+        mock(CertificateProviderProvider.class);
+    when(certProviderProvider.getName()).thenReturn(pluginName);
+    when(certProviderProvider.createCertificateProvider(
+            any(Object.class),
+            any(CertificateProvider.DistributorWatcher.class),
+            anyBoolean()))
+        .then(
+            new Answer<CertificateProvider>() {
+
+              @Override
+              public CertificateProvider answer(InvocationOnMock invocation) throws Throwable {
+                Object[] args = invocation.getArguments();
+                Object config = args[0];
+                CertificateProvider.DistributorWatcher watcher =
+                    (CertificateProvider.DistributorWatcher) args[1];
+                boolean notifyCertUpdates = (Boolean) args[2];
+                return new TestCertificateProvider(
+                    watcher, notifyCertUpdates, config, certProviderProvider,
+                    throwExceptionForCertUpdates);
+              }
+            });
+    certificateProviderRegistry.register(certProviderProvider);
+    return certProviderProvider;
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CommonCertProviderTestUtils.java b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CommonCertProviderTestUtils.java
new file mode 100644
index 00000000000..0c71b52901b
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/CommonCertProviderTestUtils.java
@@ -0,0 +1,66 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import io.grpc.internal.FakeClock;
+import io.grpc.internal.TimeProvider;
+import io.grpc.internal.testing.TestUtils;
+import io.grpc.util.CertificateUtils;
+import io.grpc.xds.internal.security.certprovider.FileWatcherCertificateProviderProvider.ScheduledExecutorServiceFactory;
+import java.io.IOException;
+import java.io.InputStream;
+import java.security.PrivateKey;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.concurrent.ScheduledExecutorService;
+
+public class CommonCertProviderTestUtils {
+
+  static PrivateKey getPrivateKey(String resourceName)
+          throws Exception {
+    return CertificateUtils.getPrivateKey(
+        TestUtils.class.getResourceAsStream("/certs/" + resourceName));
+  }
+
+  static X509Certificate getCertFromResourceName(String resourceName)
+          throws IOException, CertificateException {
+    try (InputStream cert = TestUtils.class.getResourceAsStream("/certs/" + resourceName)) {
+      return CertificateUtils.getX509Certificates(cert)[0];
+    }
+  }
+
+  /** Allow tests to register a provider using test clock.
+  */
+  public static void register(final FakeClock fakeClock) {
+    FileWatcherCertificateProviderProvider tmp = new FileWatcherCertificateProviderProvider(
+        FileWatcherCertificateProvider.Factory.getInstance(),
+        new ScheduledExecutorServiceFactory() {
+
+            @Override
+            ScheduledExecutorService create() {
+              return fakeClock.getScheduledExecutorService();
+            }
+          },
+          TimeProvider.SYSTEM_TIME_PROVIDER);
+    CertificateProviderRegistry.getInstance().register(tmp);
+  }
+
+  public static void register0() {
+    CertificateProviderRegistry.getInstance().register(
+            new FileWatcherCertificateProviderProvider());
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProviderProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProviderProviderTest.java
new file mode 100644
index 00000000000..304a2dd5441
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProviderProviderTest.java
@@ -0,0 +1,302 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import io.grpc.internal.JsonParser;
+import io.grpc.internal.TimeProvider;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ScheduledExecutorService;
+import org.junit.After;
+import org.junit.Assume;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for {@link FileWatcherCertificateProviderProvider}. */
+@RunWith(Parameterized.class)
+public class FileWatcherCertificateProviderProviderTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @Mock FileWatcherCertificateProvider.Factory fileWatcherCertificateProviderFactory;
+  @Mock private FileWatcherCertificateProviderProvider.ScheduledExecutorServiceFactory
+      scheduledExecutorServiceFactory;
+  @Mock private TimeProvider timeProvider;
+
+  @Parameter
+  public boolean enableSpiffe;
+  private boolean originalEnableSpiffe;
+  private FileWatcherCertificateProviderProvider provider;
+
+  @Parameters(name = "enableSpiffe={0}")
+  public static Collection<Boolean> data() {
+    return ImmutableList.of(true, false);
+  }
+
+  @Before
+  public void setUp() throws IOException {
+    provider =
+        new FileWatcherCertificateProviderProvider(
+            fileWatcherCertificateProviderFactory, scheduledExecutorServiceFactory, timeProvider);
+    originalEnableSpiffe = FileWatcherCertificateProviderProvider.enableSpiffe;
+    FileWatcherCertificateProviderProvider.enableSpiffe = enableSpiffe;
+  }
+
+  @After
+  public void restoreEnvironment() {
+    FileWatcherCertificateProviderProvider.enableSpiffe = originalEnableSpiffe;
+  }
+
+  @Test
+  public void providerRegisteredName() {
+    CertificateProviderProvider certProviderProvider =
+        CertificateProviderRegistry.getInstance()
+            .getProvider(FileWatcherCertificateProviderProvider.FILE_WATCHER_PROVIDER_NAME);
+    assertThat(certProviderProvider).isInstanceOf(FileWatcherCertificateProviderProvider.class);
+    FileWatcherCertificateProviderProvider fileWatcherCertificateProviderProvider =
+        (FileWatcherCertificateProviderProvider) certProviderProvider;
+    assertThat(fileWatcherCertificateProviderProvider.fileWatcherCertificateProviderFactory)
+        .isSameInstanceAs(FileWatcherCertificateProvider.Factory.getInstance());
+  }
+
+  @Test
+  public void createProvider_minimalConfig() throws IOException {
+    CertificateProvider.DistributorWatcher distWatcher =
+        new CertificateProvider.DistributorWatcher();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(MINIMAL_FILE_WATCHER_CONFIG);
+    ScheduledExecutorService mockService = mock(ScheduledExecutorService.class);
+    when(scheduledExecutorServiceFactory.create()).thenReturn(mockService);
+    provider.createCertificateProvider(map, distWatcher, true);
+    verify(fileWatcherCertificateProviderFactory, times(1))
+        .create(
+            eq(distWatcher),
+            eq(true),
+            eq("/var/run/gke-spiffe/certs/certificates.pem"),
+            eq("/var/run/gke-spiffe/certs/private_key.pem"),
+            eq("/var/run/gke-spiffe/certs/ca_certificates.pem"),
+            eq(null),
+            eq(600L),
+            eq(mockService),
+            eq(timeProvider));
+  }
+
+  @Test
+  public void createProvider_minimalSpiffeConfig() throws IOException {
+    Assume.assumeTrue(enableSpiffe);
+    CertificateProvider.DistributorWatcher distWatcher =
+        new CertificateProvider.DistributorWatcher();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(MINIMAL_FILE_WATCHER_WITH_SPIFFE_CONFIG);
+    ScheduledExecutorService mockService = mock(ScheduledExecutorService.class);
+    when(scheduledExecutorServiceFactory.create()).thenReturn(mockService);
+    provider.createCertificateProvider(map, distWatcher, true);
+    verify(fileWatcherCertificateProviderFactory, times(1))
+        .create(
+            eq(distWatcher),
+            eq(true),
+            eq("/var/run/gke-spiffe/certs/certificates.pem"),
+            eq("/var/run/gke-spiffe/certs/private_key.pem"),
+            eq(null),
+            eq("/var/run/gke-spiffe/certs/spiffe_bundle.json"),
+            eq(600L),
+            eq(mockService),
+            eq(timeProvider));
+  }
+
+  @Test
+  public void createProvider_fullConfig() throws IOException {
+    CertificateProvider.DistributorWatcher distWatcher =
+        new CertificateProvider.DistributorWatcher();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(FULL_FILE_WATCHER_CONFIG);
+    ScheduledExecutorService mockService = mock(ScheduledExecutorService.class);
+    when(scheduledExecutorServiceFactory.create()).thenReturn(mockService);
+    provider.createCertificateProvider(map, distWatcher, true);
+    verify(fileWatcherCertificateProviderFactory, times(1))
+        .create(
+            eq(distWatcher),
+            eq(true),
+            eq("/var/run/gke-spiffe/certs/certificates2.pem"),
+            eq("/var/run/gke-spiffe/certs/private_key3.pem"),
+            eq("/var/run/gke-spiffe/certs/ca_certificates4.pem"),
+            eq(null),
+            eq(7890L),
+            eq(mockService),
+            eq(timeProvider));
+  }
+
+  @Test
+  public void createProvider_spiffeConfig() throws IOException {
+    Assume.assumeTrue(enableSpiffe);
+    CertificateProvider.DistributorWatcher distWatcher =
+        new CertificateProvider.DistributorWatcher();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(FULL_FILE_WATCHER_WITH_SPIFFE_CONFIG);
+    ScheduledExecutorService mockService = mock(ScheduledExecutorService.class);
+    when(scheduledExecutorServiceFactory.create()).thenReturn(mockService);
+    provider.createCertificateProvider(map, distWatcher, true);
+    verify(fileWatcherCertificateProviderFactory, times(1))
+        .create(
+            eq(distWatcher),
+            eq(true),
+            eq("/var/run/gke-spiffe/certs/certificates2.pem"),
+            eq("/var/run/gke-spiffe/certs/private_key3.pem"),
+            eq(null),
+            eq("/var/run/gke-spiffe/certs/spiffe_bundle.json"),
+            eq(7890L),
+            eq(mockService),
+            eq(timeProvider));
+  }
+
+  @Test
+  public void createProvider_zeroRefreshInterval() throws IOException {
+    CertificateProvider.DistributorWatcher distWatcher =
+            new CertificateProvider.DistributorWatcher();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(ZERO_REFRESH_INTERVAL);
+    ScheduledExecutorService mockService = mock(ScheduledExecutorService.class);
+    when(scheduledExecutorServiceFactory.create()).thenReturn(mockService);
+    try {
+      provider.createCertificateProvider(map, distWatcher, true);
+      fail("exception expected");
+    } catch (IllegalArgumentException iae) {
+      assertThat(iae).hasMessageThat().isEqualTo("refreshInterval needs to be greater than 0");
+    }
+  }
+
+  @Test
+  public void createProvider_missingCert_expectException() throws IOException {
+    CertificateProvider.DistributorWatcher distWatcher =
+        new CertificateProvider.DistributorWatcher();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(MISSING_CERT_CONFIG);
+    try {
+      provider.createCertificateProvider(map, distWatcher, true);
+      fail("exception expected");
+    } catch (NullPointerException npe) {
+      assertThat(npe).hasMessageThat().isEqualTo("'certificate_file' is required in the config");
+    }
+  }
+
+  @Test
+  public void createProvider_missingKey_expectException() throws IOException {
+    CertificateProvider.DistributorWatcher distWatcher =
+        new CertificateProvider.DistributorWatcher();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(MISSING_KEY_CONFIG);
+    try {
+      provider.createCertificateProvider(map, distWatcher, true);
+      fail("exception expected");
+    } catch (NullPointerException npe) {
+      assertThat(npe).hasMessageThat().isEqualTo("'private_key_file' is required in the config");
+    }
+  }
+
+  @Test
+  public void createProvider_missingRoot_expectException() throws IOException {
+    String expectedMessage = enableSpiffe ? "either 'ca_certificate_file' or "
+        + "'spiffe_trust_bundle_map_file' is required in the config"
+        : "'ca_certificate_file' is required in the config";
+    CertificateProvider.DistributorWatcher distWatcher =
+        new CertificateProvider.DistributorWatcher();
+    @SuppressWarnings("unchecked")
+    Map<String, ?> map = (Map<String, ?>) JsonParser.parse(MISSING_ROOT_AND_SPIFFE_CONFIG);
+    try {
+      provider.createCertificateProvider(map, distWatcher, true);
+      fail("exception expected");
+    } catch (NullPointerException npe) {
+      assertThat(npe).hasMessageThat().isEqualTo(expectedMessage);
+    }
+  }
+
+  private static final String MINIMAL_FILE_WATCHER_CONFIG =
+      "{\n"
+          + "        \"certificate_file\": \"/var/run/gke-spiffe/certs/certificates.pem\","
+          + "        \"private_key_file\": \"/var/run/gke-spiffe/certs/private_key.pem\","
+          + "        \"ca_certificate_file\": \"/var/run/gke-spiffe/certs/ca_certificates.pem\""
+          + "      }";
+
+  private static final String MINIMAL_FILE_WATCHER_WITH_SPIFFE_CONFIG =
+      "{\n"
+          + "        \"certificate_file\": \"/var/run/gke-spiffe/certs/certificates.pem\","
+          + "        \"private_key_file\": \"/var/run/gke-spiffe/certs/private_key.pem\","
+          + "        \"spiffe_trust_bundle_map_file\":"
+          + " \"/var/run/gke-spiffe/certs/spiffe_bundle.json\""
+          + "      }";
+
+  private static final String FULL_FILE_WATCHER_CONFIG =
+      "{\n"
+          + "        \"certificate_file\": \"/var/run/gke-spiffe/certs/certificates2.pem\","
+          + "        \"private_key_file\": \"/var/run/gke-spiffe/certs/private_key3.pem\","
+          + "        \"ca_certificate_file\": \"/var/run/gke-spiffe/certs/ca_certificates4.pem\","
+          + "        \"refresh_interval\": \"7890s\""
+          + "      }";
+
+  private static final String FULL_FILE_WATCHER_WITH_SPIFFE_CONFIG =
+      "{\n"
+          + "        \"certificate_file\": \"/var/run/gke-spiffe/certs/certificates2.pem\","
+          + "        \"private_key_file\": \"/var/run/gke-spiffe/certs/private_key3.pem\","
+          + "        \"ca_certificate_file\": \"/var/run/gke-spiffe/certs/ca_certificates4.pem\","
+          + "        \"spiffe_trust_bundle_map_file\":"
+          + " \"/var/run/gke-spiffe/certs/spiffe_bundle.json\","
+          + "        \"refresh_interval\": \"7890s\""
+          + "      }";
+
+  private static final String MISSING_CERT_CONFIG =
+      "{\n"
+          + "        \"private_key_file\": \"/var/run/gke-spiffe/certs/private_key.pem\","
+          + "        \"ca_certificate_file\": \"/var/run/gke-spiffe/certs/ca_certificates.pem\""
+          + "      }";
+
+  private static final String MISSING_KEY_CONFIG =
+      "{\n"
+          + "        \"certificate_file\": \"/var/run/gke-spiffe/certs/certificates.pem\","
+          + "        \"ca_certificate_file\": \"/var/run/gke-spiffe/certs/ca_certificates.pem\""
+          + "      }";
+
+  private static final String MISSING_ROOT_AND_SPIFFE_CONFIG =
+      "{\n"
+          + "        \"certificate_file\": \"/var/run/gke-spiffe/certs/certificates.pem\","
+          + "        \"private_key_file\": \"/var/run/gke-spiffe/certs/private_key.pem\""
+          + "      }";
+
+  private static final String ZERO_REFRESH_INTERVAL =
+      "{\n"
+          + "        \"certificate_file\": \"/var/run/gke-spiffe/certs/certificates2.pem\","
+          + "        \"private_key_file\": \"/var/run/gke-spiffe/certs/private_key3.pem\","
+          + "        \"ca_certificate_file\": \"/var/run/gke-spiffe/certs/ca_certificates4.pem\","
+          + "        \"refresh_interval\": \"0s\""
+          + "      }";
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProviderTest.java b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProviderTest.java
new file mode 100644
index 00000000000..620ee0a7ff7
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/FileWatcherCertificateProviderTest.java
@@ -0,0 +1,548 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CA_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_0_KEY_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SPIFFE_TRUST_MAP_1_FILE;
+import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import io.grpc.Status;
+import io.grpc.internal.TimeProvider;
+import io.grpc.xds.internal.security.CommonTlsContextTestsUtil;
+import io.grpc.xds.internal.security.certprovider.CertificateProvider.DistributorWatcher;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.NoSuchFileException;
+import java.nio.file.Paths;
+import java.nio.file.attribute.FileTime;
+import java.security.PrivateKey;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Delayed;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatchers;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/** Unit tests for {@link FileWatcherCertificateProvider}. */
+@RunWith(JUnit4.class)
+public class FileWatcherCertificateProviderTest {
+  /**
+   * Expire time of cert SERVER_0_PEM_FILE.
+   */
+  static final long CERT0_EXPIRY_TIME_MILLIS = 1899853658000L;
+  private static final String CERT_FILE = "cert.pem";
+  private static final String KEY_FILE = "key.pem";
+  private static final String ROOT_FILE = "root.pem";
+  private static final String SPIFFE_TRUST_MAP_FILE = "spiffebundle.json";
+
+  @Mock private CertificateProvider.Watcher mockWatcher;
+  @Mock private ScheduledExecutorService timeService;
+  private final FakeTimeProvider timeProvider = new FakeTimeProvider();
+
+  @Rule public TemporaryFolder tempFolder = new TemporaryFolder();
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private String certFile;
+  private String keyFile;
+  private String rootFile;
+  private String spiffeTrustMapFile;
+
+  private FileWatcherCertificateProvider provider;
+  private DistributorWatcher watcher;
+
+  @Before
+  public void setUp() throws IOException {
+    watcher = new DistributorWatcher();
+    watcher.addWatcher(mockWatcher);
+
+    certFile = new File(tempFolder.getRoot(), CERT_FILE).getAbsolutePath();
+    keyFile = new File(tempFolder.getRoot(), KEY_FILE).getAbsolutePath();
+    rootFile = new File(tempFolder.getRoot(), ROOT_FILE).getAbsolutePath();
+    spiffeTrustMapFile = new File(tempFolder.getRoot(), SPIFFE_TRUST_MAP_FILE).getAbsolutePath();
+    provider =
+        new FileWatcherCertificateProvider(watcher, true, certFile, keyFile, rootFile, null, 600L,
+            timeService, timeProvider);
+  }
+
+  private void populateTarget(
+      String certFileSource,
+      String keyFileSource,
+      String rootFileSource,
+      String spiffeTrustMapFileSource,
+      boolean deleteCurCert,
+      boolean deleteCurKey,
+      boolean deleteCurSpiffeTrustMap,
+      boolean deleteCurRoot)
+      throws IOException {
+    if (deleteCurCert) {
+      Files.delete(Paths.get(certFile));
+    }
+    if (certFileSource != null) {
+      certFileSource = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(certFileSource);
+      Files.copy(Paths.get(certFileSource), Paths.get(certFile), REPLACE_EXISTING);
+      Files.setLastModifiedTime(
+          Paths.get(certFile), FileTime.fromMillis(timeProvider.currentTimeMillis()));
+    }
+    if (deleteCurKey) {
+      Files.delete(Paths.get(keyFile));
+    }
+    if (keyFileSource != null) {
+      keyFileSource = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(keyFileSource);
+      Files.copy(Paths.get(keyFileSource), Paths.get(keyFile), REPLACE_EXISTING);
+      Files.setLastModifiedTime(
+          Paths.get(keyFile), FileTime.fromMillis(timeProvider.currentTimeMillis()));
+    }
+    if (deleteCurRoot) {
+      Files.delete(Paths.get(rootFile));
+    }
+    if (rootFileSource != null) {
+      rootFileSource = CommonTlsContextTestsUtil.getTempFileNameForResourcesFile(rootFileSource);
+      Files.copy(Paths.get(rootFileSource), Paths.get(rootFile), REPLACE_EXISTING);
+      Files.setLastModifiedTime(
+          Paths.get(rootFile), FileTime.fromMillis(timeProvider.currentTimeMillis()));
+    }
+    if (deleteCurSpiffeTrustMap) {
+      Files.delete(Paths.get(spiffeTrustMapFile));
+    }
+    if (spiffeTrustMapFileSource != null) {
+      spiffeTrustMapFileSource = CommonTlsContextTestsUtil
+          .getTempFileNameForResourcesFile(spiffeTrustMapFileSource);
+      Files.copy(Paths.get(spiffeTrustMapFileSource),
+          Paths.get(spiffeTrustMapFile), REPLACE_EXISTING);
+      Files.setLastModifiedTime(
+          Paths.get(spiffeTrustMapFile), FileTime.fromMillis(timeProvider.currentTimeMillis()));
+    }
+  }
+
+  @Test
+  public void getCertificateAndCheckUpdates() throws IOException, CertificateException {
+    TestScheduledFuture<?> scheduledFuture =
+        new TestScheduledFuture<>();
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    populateTarget(CLIENT_PEM_FILE, CLIENT_KEY_FILE, CA_PEM_FILE, null, false, false, false, false);
+    provider.checkAndReloadCertificates();
+    verifyWatcherUpdates(CLIENT_PEM_FILE, CA_PEM_FILE, null);
+    verifyTimeServiceAndScheduledFuture();
+
+    reset(mockWatcher, timeService);
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    provider.checkAndReloadCertificates();
+    verifyWatcherErrorUpdates(null, null, 0, 0, (String[]) null);
+    verifyTimeServiceAndScheduledFuture();
+  }
+
+  @Test
+  public void allUpdateSecondTime() throws IOException, CertificateException, InterruptedException {
+    TestScheduledFuture<?> scheduledFuture =
+        new TestScheduledFuture<>();
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    populateTarget(CLIENT_PEM_FILE, CLIENT_KEY_FILE, CA_PEM_FILE, null, false, false, false, false);
+    provider.checkAndReloadCertificates();
+
+    reset(mockWatcher, timeService);
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    timeProvider.forwardTime(1, TimeUnit.SECONDS);
+    populateTarget(SERVER_0_PEM_FILE, SERVER_0_KEY_FILE, SERVER_1_PEM_FILE, null, false, false,
+        false, false);
+    provider.checkAndReloadCertificates();
+    verifyWatcherUpdates(SERVER_0_PEM_FILE, SERVER_1_PEM_FILE, null);
+    verifyTimeServiceAndScheduledFuture();
+  }
+
+  @Test
+  public void closeDoesNotScheduleNext() throws IOException, CertificateException {
+    TestScheduledFuture<?> scheduledFuture =
+            new TestScheduledFuture<>();
+    doReturn(scheduledFuture)
+            .when(timeService)
+            .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    populateTarget(CLIENT_PEM_FILE, CLIENT_KEY_FILE, CA_PEM_FILE, null, false, false, false, false);
+    provider.close();
+    provider.checkAndReloadCertificates();
+    verify(mockWatcher, never())
+        .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
+    verify(mockWatcher, never()).updateTrustedRoots(ArgumentMatchers.<X509Certificate>anyList());
+    verify(mockWatcher, never()).updateSpiffeTrustMap(ArgumentMatchers.anyMap());
+    verify(timeService, never()).schedule(any(Runnable.class), any(Long.TYPE), any(TimeUnit.class));
+    verify(timeService, times(1)).shutdownNow();
+  }
+
+
+  @Test
+  public void rootFileUpdateOnly() throws IOException, CertificateException, InterruptedException {
+    TestScheduledFuture<?> scheduledFuture =
+        new TestScheduledFuture<>();
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    populateTarget(CLIENT_PEM_FILE, CLIENT_KEY_FILE, CA_PEM_FILE, null, false, false, false, false);
+    provider.checkAndReloadCertificates();
+
+    reset(mockWatcher, timeService);
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    timeProvider.forwardTime(1, TimeUnit.SECONDS);
+    populateTarget(null, null, SERVER_1_PEM_FILE, null, false, false, false, false);
+    provider.checkAndReloadCertificates();
+    verifyWatcherUpdates(null, SERVER_1_PEM_FILE, null);
+    verifyTimeServiceAndScheduledFuture();
+  }
+
+  @Test
+  public void certAndKeyFileUpdateOnly()
+      throws IOException, CertificateException, InterruptedException {
+    TestScheduledFuture<?> scheduledFuture =
+        new TestScheduledFuture<>();
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    populateTarget(CLIENT_PEM_FILE, CLIENT_KEY_FILE, CA_PEM_FILE, null, false, false, false, false);
+    provider.checkAndReloadCertificates();
+
+    reset(mockWatcher, timeService);
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    timeProvider.forwardTime(1, TimeUnit.SECONDS);
+    populateTarget(SERVER_0_PEM_FILE, SERVER_0_KEY_FILE, null, null, false, false, false, false);
+    provider.checkAndReloadCertificates();
+    verifyWatcherUpdates(SERVER_0_PEM_FILE, null, null);
+    verifyTimeServiceAndScheduledFuture();
+  }
+
+  @Test
+  public void spiffeTrustMapFileUpdateOnly() throws Exception {
+    provider = new FileWatcherCertificateProvider(watcher, true, certFile, keyFile, null,
+        spiffeTrustMapFile, 600L, timeService, timeProvider);
+    TestScheduledFuture<?> scheduledFuture =
+        new TestScheduledFuture<>();
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    populateTarget(CLIENT_PEM_FILE, CLIENT_KEY_FILE, null, null, false, false, false, false);
+    provider.checkAndReloadCertificates();
+    verify(mockWatcher, never()).updateSpiffeTrustMap(ArgumentMatchers.anyMap());
+
+    reset(timeService);
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    timeProvider.forwardTime(1, TimeUnit.SECONDS);
+    populateTarget(CLIENT_PEM_FILE, CLIENT_KEY_FILE, null, SPIFFE_TRUST_MAP_FILE, false,
+        false, false, false);
+    provider.checkAndReloadCertificates();
+    verify(mockWatcher, times(1)).updateSpiffeTrustMap(ArgumentMatchers.anyMap());
+
+    reset(timeService);
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    timeProvider.forwardTime(1, TimeUnit.SECONDS);
+    populateTarget(CLIENT_PEM_FILE, CLIENT_KEY_FILE, null, SPIFFE_TRUST_MAP_1_FILE, false,
+        false, false, false);
+    provider.checkAndReloadCertificates();
+    verify(mockWatcher, times(2)).updateSpiffeTrustMap(ArgumentMatchers.anyMap());
+    verifyTimeServiceAndScheduledFuture();
+  }
+
+  @Test
+  public void getCertificate_initialMissingCertFile() throws IOException {
+    TestScheduledFuture<?> scheduledFuture =
+        new TestScheduledFuture<>();
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    populateTarget(null, CLIENT_KEY_FILE, CA_PEM_FILE, null, false, false, false, false);
+    provider.checkAndReloadCertificates();
+    verifyWatcherErrorUpdates(Status.Code.UNKNOWN, NoSuchFileException.class, 0, 1, "cert.pem");
+  }
+
+  @Test
+  public void getCertificate_missingCertFile() throws IOException, InterruptedException {
+    commonErrorTest(
+        null, CLIENT_KEY_FILE, CA_PEM_FILE, null, NoSuchFileException.class, 0, 1, 0, 0,
+        "cert.pem");
+  }
+
+  @Test
+  public void getCertificate_missingKeyFile() throws IOException, InterruptedException {
+    commonErrorTest(
+        CLIENT_PEM_FILE, null, CA_PEM_FILE, null, NoSuchFileException.class, 0, 1, 0, 0, "key.pem");
+  }
+
+  @Test
+  public void getCertificate_badKeyFile() throws IOException, InterruptedException {
+    commonErrorTest(
+        CLIENT_PEM_FILE,
+        SERVER_0_PEM_FILE,
+        CA_PEM_FILE,
+        null,
+        java.security.spec.InvalidKeySpecException.class,
+        0,
+        1,
+        0,
+        0,
+        "Neither RSA nor EC worked");
+  }
+
+  @Test
+  public void getCertificate_missingRootFile() throws IOException, InterruptedException {
+    TestScheduledFuture<?> scheduledFuture =
+        new TestScheduledFuture<>();
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    populateTarget(SERVER_0_PEM_FILE, SERVER_0_KEY_FILE, SERVER_1_PEM_FILE, null, false, false,
+        false, false);
+    provider.checkAndReloadCertificates();
+
+    reset(mockWatcher);
+    timeProvider.forwardTime(1, TimeUnit.SECONDS);
+    populateTarget(CLIENT_PEM_FILE, CLIENT_KEY_FILE, null, null, false, false, false, true);
+    timeProvider.forwardTime(
+        CERT0_EXPIRY_TIME_MILLIS - 610_000L - timeProvider.currentTimeMillis(),
+        TimeUnit.MILLISECONDS);
+    provider.checkAndReloadCertificates();
+    verifyWatcherErrorUpdates(Status.Code.UNKNOWN, NoSuchFileException.class, 1, 0, "root.pem");
+  }
+
+  private void commonErrorTest(
+      String certFile,
+      String keyFile,
+      String rootFile,
+      String spiffeFile,
+      Class<?> throwableType,
+      int firstUpdateCertCount,
+      int firstUpdateRootCount,
+      int secondUpdateCertCount,
+      int secondUpdateRootCount,
+      String... causeMessages)
+      throws IOException, InterruptedException {
+    TestScheduledFuture<?> scheduledFuture =
+        new TestScheduledFuture<>();
+    doReturn(scheduledFuture)
+        .when(timeService)
+        .schedule(any(Runnable.class), any(Long.TYPE), eq(TimeUnit.SECONDS));
+    populateTarget(SERVER_0_PEM_FILE, SERVER_0_KEY_FILE, SERVER_1_PEM_FILE,
+        SPIFFE_TRUST_MAP_1_FILE, false, false, false, false);
+    provider.checkAndReloadCertificates();
+
+    reset(mockWatcher);
+    timeProvider.forwardTime(1, TimeUnit.SECONDS);
+    populateTarget(
+        certFile, keyFile, rootFile, spiffeFile, certFile == null, keyFile == null,
+        rootFile == null, spiffeFile == null);
+    timeProvider.forwardTime(
+        CERT0_EXPIRY_TIME_MILLIS - 610_000L - timeProvider.currentTimeMillis(),
+        TimeUnit.MILLISECONDS);
+    provider.checkAndReloadCertificates();
+    verifyWatcherErrorUpdates(
+        null, null, firstUpdateCertCount, firstUpdateRootCount, (String[]) null);
+
+    reset(mockWatcher);
+    timeProvider.forwardTime(20, TimeUnit.SECONDS);
+    provider.checkAndReloadCertificates();
+    verifyWatcherErrorUpdates(
+        Status.Code.UNKNOWN,
+        throwableType,
+        secondUpdateCertCount,
+        secondUpdateRootCount,
+        causeMessages);
+  }
+
+  private void verifyWatcherErrorUpdates(
+      Status.Code code,
+      Class<?> throwableType,
+      int updateCertCount,
+      int updateRootCount,
+      String... causeMessages) {
+    verify(mockWatcher, times(updateCertCount))
+        .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
+    verify(mockWatcher, times(updateRootCount))
+        .updateTrustedRoots(ArgumentMatchers.<X509Certificate>anyList());
+    if (code == null && throwableType == null && causeMessages == null) {
+      verify(mockWatcher, never()).onError(any(Status.class));
+    } else {
+      ArgumentCaptor<Status> statusCaptor = ArgumentCaptor.forClass(Status.class);
+      verify(mockWatcher, times(1)).onError(statusCaptor.capture());
+      Status status = statusCaptor.getValue();
+      assertThat(status.getCode()).isEqualTo(code);
+      Throwable cause = status.getCause();
+      assertThat(cause).isInstanceOf(throwableType);
+      for (String causeMessage : causeMessages) {
+        assertThat(cause).hasMessageThat().contains(causeMessage);
+        cause = cause.getCause();
+      }
+    }
+  }
+
+  private void verifyTimeServiceAndScheduledFuture() {
+    verify(timeService, times(1)).schedule(any(Runnable.class), eq(600L), eq(TimeUnit.SECONDS));
+    assertThat(provider.scheduledFuture).isNotNull();
+    assertThat(provider.scheduledFuture.isDone()).isFalse();
+    assertThat(provider.scheduledFuture.isCancelled()).isFalse();
+  }
+
+  private void verifyWatcherUpdates(String certPemFile, String rootPemFile, String spiffeFile)
+      throws IOException, CertificateException {
+    if (certPemFile != null) {
+      @SuppressWarnings("unchecked")
+      ArgumentCaptor<List<X509Certificate>> certChainCaptor = ArgumentCaptor.forClass(List.class);
+      verify(mockWatcher, times(1))
+          .updateCertificate(any(PrivateKey.class), certChainCaptor.capture());
+      List<X509Certificate> certChain = certChainCaptor.getValue();
+      assertThat(certChain).hasSize(1);
+      assertThat(certChain.get(0))
+          .isEqualTo(CommonTlsContextTestsUtil.getCertFromResourceName(certPemFile));
+    } else {
+      verify(mockWatcher, never())
+          .updateCertificate(any(PrivateKey.class), ArgumentMatchers.<X509Certificate>anyList());
+    }
+    if (rootPemFile != null) {
+      @SuppressWarnings("unchecked")
+      ArgumentCaptor<List<X509Certificate>> rootsCaptor = ArgumentCaptor.forClass(List.class);
+      verify(mockWatcher, times(1)).updateTrustedRoots(rootsCaptor.capture());
+      List<X509Certificate> roots = rootsCaptor.getValue();
+      assertThat(roots).hasSize(1);
+      assertThat(roots.get(0))
+          .isEqualTo(CommonTlsContextTestsUtil.getCertFromResourceName(rootPemFile));
+      verify(mockWatcher, never()).onError(any(Status.class));
+    } else {
+      verify(mockWatcher, never()).updateTrustedRoots(ArgumentMatchers.<X509Certificate>anyList());
+    }
+    if (spiffeFile != null) {
+      @SuppressWarnings("unchecked")
+      ArgumentCaptor<Map<String, List<X509Certificate>>> spiffeCaptor =
+          ArgumentCaptor.forClass(Map.class);
+      verify(mockWatcher, times(1)).updateSpiffeTrustMap(spiffeCaptor.capture());
+      Map<String, List<X509Certificate>> trustMap = spiffeCaptor.getValue();
+      assertThat(trustMap).hasSize(2);
+      verify(mockWatcher, never()).onError(any(Status.class));
+    } else {
+      verify(mockWatcher, never()).updateSpiffeTrustMap(ArgumentMatchers.anyMap());
+    }
+  }
+
+  static class TestScheduledFuture<V> implements ScheduledFuture<V> {
+
+    static class Record {
+      long timeout;
+      TimeUnit unit;
+
+      Record(long timeout, TimeUnit unit) {
+        this.timeout = timeout;
+        this.unit = unit;
+      }
+    }
+
+    ArrayList<Record> calls = new ArrayList<>();
+
+    @Override
+    public long getDelay(TimeUnit unit) {
+      return 0;
+    }
+
+    @Override
+    public int compareTo(Delayed o) {
+      return 0;
+    }
+
+    @Override
+    public boolean cancel(boolean mayInterruptIfRunning) {
+      return false;
+    }
+
+    @Override
+    public boolean isCancelled() {
+      return false;
+    }
+
+    @Override
+    public boolean isDone() {
+      return false;
+    }
+
+    @Override
+    public V get() {
+      return null;
+    }
+
+    @Override
+    public V get(long timeout, TimeUnit unit) {
+      calls.add(new Record(timeout, unit));
+      return null;
+    }
+  }
+
+  /**
+   * Fake TimeProvider that roughly mirrors FakeClock. Not using FakeClock because it incorrectly
+   * fails to align the wall-time API TimeProvider.currentTimeNanos() with currentTimeMillis() and
+   * fixing it upsets a _lot_ of tests.
+   */
+  static class FakeTimeProvider implements TimeProvider {
+    public long currentTimeNanos = TimeUnit.SECONDS.toNanos(1262332800); /* 2010-01-01 */
+
+    @Override public long currentTimeNanos() {
+      return currentTimeNanos;
+    }
+
+    public void forwardTime(long duration, TimeUnit unit) {
+      currentTimeNanos += unit.toNanos(duration);
+    }
+
+    public long currentTimeMillis() {
+      return TimeUnit.NANOSECONDS.toMillis(currentTimeNanos);
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/certprovider/TestCertificateProvider.java b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/TestCertificateProvider.java
new file mode 100644
index 00000000000..aba7a910813
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/certprovider/TestCertificateProvider.java
@@ -0,0 +1,85 @@
+/*
+ * 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.xds.internal.security.certprovider;
+
+public class TestCertificateProvider extends CertificateProvider {
+  Object config;
+  CertificateProviderProvider certProviderProvider;
+  int closeCalled = 0;
+  int startCalled = 0;
+
+  /** Creates a TestCertificateProvider instance. */
+  public TestCertificateProvider(
+      DistributorWatcher watcher,
+      boolean notifyCertUpdates,
+      Object config,
+      CertificateProviderProvider certificateProviderProvider,
+      boolean throwExceptionForCertUpdates) {
+    super(watcher, notifyCertUpdates);
+    if (throwExceptionForCertUpdates && notifyCertUpdates) {
+      throw new UnsupportedOperationException("Provider does not support Certificate Updates.");
+    }
+    this.config = config;
+    this.certProviderProvider = certificateProviderProvider;
+  }
+
+  @Override
+  public void close() {
+    closeCalled++;
+  }
+
+  @Override
+  public void start() {
+    startCalled++;
+  }
+
+  static void createAndRegisterProviderProvider(
+      CertificateProviderRegistry certificateProviderRegistry,
+      final CertificateProvider.DistributorWatcher[] watcherCaptor,
+      String testca,
+      final int index) {
+    final CertificateProviderProvider mockProviderProviderTestCa =
+        new TestCertificateProviderProvider(testca, watcherCaptor, index);
+    certificateProviderRegistry.register(mockProviderProviderTestCa);
+  }
+
+  private static class TestCertificateProviderProvider implements CertificateProviderProvider {
+
+    private final String testCa;
+    private final CertificateProvider.DistributorWatcher[] watcherCaptor;
+    private final int index;
+
+    TestCertificateProviderProvider(
+        String testCa, CertificateProvider.DistributorWatcher[] watcherCaptor, int index) {
+      this.testCa = testCa;
+      this.watcherCaptor = watcherCaptor;
+      this.index = index;
+    }
+
+    @Override
+    public String getName() {
+      return testCa;
+    }
+
+    @Override
+    public CertificateProvider createCertificateProvider(
+        Object config, DistributorWatcher watcher, boolean notifyCertUpdates) {
+      watcherCaptor[index] = watcher;
+      return new TestCertificateProvider(watcher, true, config, this, false);
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/trust/XdsTrustManagerFactoryTest.java b/xds/src/test/java/io/grpc/xds/internal/security/trust/XdsTrustManagerFactoryTest.java
new file mode 100644
index 00000000000..3077482b10b
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/trust/XdsTrustManagerFactoryTest.java
@@ -0,0 +1,321 @@
+/*
+ * Copyright 2019 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.xds.internal.security.trust;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.BAD_CLIENT_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.BAD_SERVER_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CA_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.ByteString;
+import io.envoyproxy.envoy.config.core.v3.DataSource;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import io.grpc.internal.testing.TestUtils;
+import io.grpc.testing.TlsTesting;
+import java.io.IOException;
+import java.security.cert.CertStoreException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import javax.net.ssl.TrustManager;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link XdsTrustManagerFactory}. */
+@RunWith(JUnit4.class)
+public class XdsTrustManagerFactoryTest {
+
+  @Test
+  public void constructor_fromFile() throws CertificateException, IOException, CertStoreException {
+    XdsTrustManagerFactory factory =
+        new XdsTrustManagerFactory(getCertContextFromPath(CA_PEM_FILE));
+    assertThat(factory).isNotNull();
+    TrustManager[] tms = factory.getTrustManagers();
+    assertThat(tms).isNotNull();
+    assertThat(tms).hasLength(1);
+    TrustManager myTm = tms[0];
+    assertThat(myTm).isInstanceOf(XdsX509TrustManager.class);
+    XdsX509TrustManager xdsX509TrustManager = (XdsX509TrustManager) myTm;
+    X509Certificate[] acceptedIssuers = xdsX509TrustManager.getAcceptedIssuers();
+    assertThat(acceptedIssuers).isNotNull();
+    assertThat(acceptedIssuers).hasLength(1);
+    X509Certificate caCert = acceptedIssuers[0];
+    assertThat(caCert)
+        .isEqualTo(CertificateUtils.toX509Certificates(TlsTesting.loadCert(CA_PEM_FILE))[0]);
+  }
+
+  @Test
+  public void constructor_fromInlineBytes()
+      throws CertificateException, IOException, CertStoreException {
+    XdsTrustManagerFactory factory =
+        new XdsTrustManagerFactory(getCertContextFromPathAsInlineBytes(CA_PEM_FILE));
+    assertThat(factory).isNotNull();
+    TrustManager[] tms = factory.getTrustManagers();
+    assertThat(tms).isNotNull();
+    assertThat(tms).hasLength(1);
+    TrustManager myTm = tms[0];
+    assertThat(myTm).isInstanceOf(XdsX509TrustManager.class);
+    XdsX509TrustManager xdsX509TrustManager = (XdsX509TrustManager) myTm;
+    X509Certificate[] acceptedIssuers = xdsX509TrustManager.getAcceptedIssuers();
+    assertThat(acceptedIssuers).isNotNull();
+    assertThat(acceptedIssuers).hasLength(1);
+    X509Certificate caCert = acceptedIssuers[0];
+    assertThat(caCert)
+        .isEqualTo(CertificateUtils.toX509Certificates(TlsTesting.loadCert(CA_PEM_FILE))[0]);
+  }
+
+  @Test
+  public void constructor_fromRootCert()
+      throws CertificateException, IOException, CertStoreException {
+    X509Certificate x509Cert = TestUtils.loadX509Cert(CA_PEM_FILE);
+    CertificateValidationContext staticValidationContext = buildStaticValidationContext("san1",
+        "san2");
+    XdsTrustManagerFactory factory =
+        new XdsTrustManagerFactory(new X509Certificate[]{x509Cert}, staticValidationContext, false);
+    assertThat(factory).isNotNull();
+    TrustManager[] tms = factory.getTrustManagers();
+    assertThat(tms).isNotNull();
+    assertThat(tms).hasLength(1);
+    TrustManager myTm = tms[0];
+    assertThat(myTm).isInstanceOf(XdsX509TrustManager.class);
+    XdsX509TrustManager xdsX509TrustManager = (XdsX509TrustManager) myTm;
+    X509Certificate[] acceptedIssuers = xdsX509TrustManager.getAcceptedIssuers();
+    assertThat(acceptedIssuers).isNotNull();
+    assertThat(acceptedIssuers).hasLength(1);
+    X509Certificate caCert = acceptedIssuers[0];
+    assertThat(caCert)
+        .isEqualTo(CertificateUtils.toX509Certificates(TlsTesting.loadCert(CA_PEM_FILE))[0]);
+  }
+
+  @Test
+  public void constructor_fromSpiffeTrustMap()
+      throws CertificateException, IOException, CertStoreException {
+    X509Certificate x509Cert = TestUtils.loadX509Cert(CA_PEM_FILE);
+    CertificateValidationContext staticValidationContext = buildStaticValidationContext("san1",
+        "san2");
+    // Single domain and single cert
+    XdsTrustManagerFactory factory = new XdsTrustManagerFactory(ImmutableMap
+        .of("example.com", ImmutableList.of(x509Cert)), staticValidationContext, false);
+    assertThat(factory).isNotNull();
+    TrustManager[] tms = factory.getTrustManagers();
+    assertThat(tms).isNotNull();
+    assertThat(tms).hasLength(1);
+    TrustManager myTm = tms[0];
+    assertThat(myTm).isInstanceOf(XdsX509TrustManager.class);
+    XdsX509TrustManager xdsX509TrustManager = (XdsX509TrustManager) myTm;
+    assertThat(xdsX509TrustManager.getAcceptedIssuers()).isNotNull();
+    assertThat(xdsX509TrustManager.getAcceptedIssuers()).hasLength(1);
+    assertThat(xdsX509TrustManager.getAcceptedIssuers()[0].getIssuerX500Principal().getName())
+        .isEqualTo("CN=testca,O=Internet Widgits Pty Ltd,ST=Some-State,C=AU");
+    // Multiple domains and multiple certs for one of it
+    X509Certificate anotherCert = TestUtils.loadX509Cert(CLIENT_PEM_FILE);
+    factory = new XdsTrustManagerFactory(ImmutableMap
+        .of("example.com", ImmutableList.of(x509Cert),
+            "google.com", ImmutableList.of(x509Cert, anotherCert)), staticValidationContext, false);
+    assertThat(factory).isNotNull();
+    tms = factory.getTrustManagers();
+    assertThat(tms).isNotNull();
+    assertThat(tms).hasLength(1);
+    myTm = tms[0];
+    assertThat(myTm).isInstanceOf(XdsX509TrustManager.class);
+    xdsX509TrustManager = (XdsX509TrustManager) myTm;
+    assertThat(xdsX509TrustManager.getAcceptedIssuers()).isNotNull();
+    assertThat(xdsX509TrustManager.getAcceptedIssuers()).hasLength(2);
+    assertThat(xdsX509TrustManager.getAcceptedIssuers()[0].getIssuerX500Principal().getName())
+        .isEqualTo("CN=testca,O=Internet Widgits Pty Ltd,ST=Some-State,C=AU");
+    assertThat(xdsX509TrustManager.getAcceptedIssuers()[1].getIssuerX500Principal().getName())
+        .isEqualTo("CN=testca,O=Internet Widgits Pty Ltd,ST=Some-State,C=AU");
+  }
+
+  @Test
+  public void constructorRootCert_checkServerTrusted()
+      throws CertificateException, IOException, CertStoreException {
+    X509Certificate x509Cert = TestUtils.loadX509Cert(CA_PEM_FILE);
+    CertificateValidationContext staticValidationContext = buildStaticValidationContext("san1",
+        "waterzooi.test.google.be");
+    XdsTrustManagerFactory factory =
+        new XdsTrustManagerFactory(new X509Certificate[]{x509Cert}, staticValidationContext, false);
+    XdsX509TrustManager xdsX509TrustManager = (XdsX509TrustManager) factory.getTrustManagers()[0];
+    X509Certificate[] serverChain =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    xdsX509TrustManager.checkServerTrusted(serverChain, "RSA");
+  }
+
+  @Test
+  public void constructorRootCert_nonStaticContext_throwsException()
+          throws CertificateException, IOException, CertStoreException {
+    X509Certificate x509Cert = TestUtils.loadX509Cert(CA_PEM_FILE);
+    try {
+      new XdsTrustManagerFactory(
+              new X509Certificate[] {x509Cert}, getCertContextFromPath(CA_PEM_FILE), false);
+      Assert.fail("no exception thrown");
+    } catch (IllegalArgumentException expected) {
+      assertThat(expected)
+              .hasMessageThat()
+              .contains("only static certificateValidationContext expected");
+    }
+  }
+
+  @Test
+  public void constructorRootCert_nonStaticContext_systemRootCerts_valid()
+      throws CertificateException, IOException, CertStoreException {
+    X509Certificate x509Cert = TestUtils.loadX509Cert(CA_PEM_FILE);
+    CertificateValidationContext certValidationContext = CertificateValidationContext.newBuilder()
+        .setTrustedCa(
+            DataSource.newBuilder().setFilename(TestUtils.loadCert(CA_PEM_FILE).getAbsolutePath()))
+        .setSystemRootCerts(CertificateValidationContext.SystemRootCerts.getDefaultInstance())
+        .build();
+    XdsTrustManagerFactory unused =
+        new XdsTrustManagerFactory(new X509Certificate[] {x509Cert}, certValidationContext, false);
+  }
+
+  @Test
+  public void constructorRootCert_checkServerTrusted_throwsException()
+      throws CertificateException, IOException, CertStoreException {
+    X509Certificate x509Cert = TestUtils.loadX509Cert(CA_PEM_FILE);
+    CertificateValidationContext staticValidationContext = buildStaticValidationContext("san1",
+        "san2");
+    XdsTrustManagerFactory factory =
+        new XdsTrustManagerFactory(new X509Certificate[]{x509Cert}, staticValidationContext, false);
+    XdsX509TrustManager xdsX509TrustManager = (XdsX509TrustManager) factory.getTrustManagers()[0];
+    X509Certificate[] serverChain =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    try {
+      xdsX509TrustManager.checkServerTrusted(serverChain, "RSA");
+      Assert.fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected)
+          .hasMessageThat()
+          .contains("Peer certificate SAN check failed");
+    }
+  }
+
+  @Test
+  public void constructorRootCert_checkClientTrusted_throwsException()
+      throws CertificateException, IOException, CertStoreException {
+    X509Certificate x509Cert = TestUtils.loadX509Cert(CA_PEM_FILE);
+    CertificateValidationContext staticValidationContext = buildStaticValidationContext("san1",
+        "san2");
+    XdsTrustManagerFactory factory =
+        new XdsTrustManagerFactory(new X509Certificate[]{x509Cert}, staticValidationContext, false);
+    XdsX509TrustManager xdsX509TrustManager = (XdsX509TrustManager) factory.getTrustManagers()[0];
+    X509Certificate[] clientChain =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    try {
+      xdsX509TrustManager.checkClientTrusted(clientChain, "RSA");
+      Assert.fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected)
+          .hasMessageThat()
+          .contains("Peer certificate SAN check failed");
+    }
+  }
+
+  @Test
+  public void checkServerTrusted_goodCert()
+      throws CertificateException, IOException, CertStoreException {
+    XdsTrustManagerFactory factory =
+        new XdsTrustManagerFactory(getCertContextFromPath(CA_PEM_FILE));
+    XdsX509TrustManager xdsX509TrustManager = (XdsX509TrustManager) factory.getTrustManagers()[0];
+    X509Certificate[] serverChain =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    xdsX509TrustManager.checkServerTrusted(serverChain, "RSA");
+  }
+
+  @Test
+  public void checkClientTrusted_goodCert()
+      throws CertificateException, IOException, CertStoreException {
+    XdsTrustManagerFactory factory =
+        new XdsTrustManagerFactory(getCertContextFromPath(CA_PEM_FILE));
+    XdsX509TrustManager xdsX509TrustManager = (XdsX509TrustManager) factory.getTrustManagers()[0];
+    X509Certificate[] clientChain =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(CLIENT_PEM_FILE));
+    xdsX509TrustManager.checkClientTrusted(clientChain, "RSA");
+  }
+
+  @Test
+  public void checkServerTrusted_badCert_throwsException()
+      throws CertificateException, IOException, CertStoreException {
+    XdsTrustManagerFactory factory =
+        new XdsTrustManagerFactory(getCertContextFromPath(CA_PEM_FILE));
+    XdsX509TrustManager xdsX509TrustManager = (XdsX509TrustManager) factory.getTrustManagers()[0];
+    X509Certificate[] serverChain =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(BAD_SERVER_PEM_FILE));
+    try {
+      xdsX509TrustManager.checkServerTrusted(serverChain, "RSA");
+      Assert.fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected)
+          .hasMessageThat()
+          .contains("unable to find valid certification path to requested target");
+    }
+  }
+
+  @Test
+  public void checkClientTrusted_badCert_throwsException()
+      throws CertificateException, IOException, CertStoreException {
+    XdsTrustManagerFactory factory =
+        new XdsTrustManagerFactory(getCertContextFromPath(CA_PEM_FILE));
+    XdsX509TrustManager xdsX509TrustManager = (XdsX509TrustManager) factory.getTrustManagers()[0];
+    X509Certificate[] clientChain =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(BAD_CLIENT_PEM_FILE));
+    try {
+      xdsX509TrustManager.checkClientTrusted(clientChain, "RSA");
+      Assert.fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected)
+          .hasMessageThat()
+          .contains("unable to find valid certification path to requested target");
+    }
+  }
+
+  /** constructs CertificateValidationContext from the resources file-path. */
+  private static final CertificateValidationContext getCertContextFromPath(String pemFilePath)
+      throws IOException {
+    return CertificateValidationContext.newBuilder()
+        .setTrustedCa(
+            DataSource.newBuilder().setFilename(TestUtils.loadCert(pemFilePath).getAbsolutePath()))
+        .build();
+  }
+
+  /** constructs CertificateValidationContext from pemFilePath and sets contents as inline-bytes. */
+  private static final CertificateValidationContext getCertContextFromPathAsInlineBytes(
+      String pemFilePath) throws IOException, CertificateException {
+    X509Certificate x509Cert = TestUtils.loadX509Cert(pemFilePath);
+    return CertificateValidationContext.newBuilder()
+        .setTrustedCa(
+            DataSource.newBuilder().setInlineBytes(ByteString.copyFrom(x509Cert.getEncoded())))
+        .build();
+  }
+
+  private static final CertificateValidationContext buildStaticValidationContext(
+          String... verifySans) {
+    CertificateValidationContext.Builder builder = CertificateValidationContext.newBuilder();
+    for (String san : verifySans) {
+      @SuppressWarnings("deprecation")
+      CertificateValidationContext.Builder unused =
+          builder.addMatchSubjectAltNames(StringMatcher.newBuilder().setExact(san));
+    }
+    return builder.build();
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/internal/security/trust/XdsX509TrustManagerTest.java b/xds/src/test/java/io/grpc/xds/internal/security/trust/XdsX509TrustManagerTest.java
new file mode 100644
index 00000000000..ffe0536f25b
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/internal/security/trust/XdsX509TrustManagerTest.java
@@ -0,0 +1,834 @@
+/*
+ * Copyright 2019 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.xds.internal.security.trust;
+
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.BAD_SERVER_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.BAD_WILDCARD_DNS_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CA_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.CLIENT_SPIFFE_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_0_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_PEM_FILE;
+import static io.grpc.xds.internal.security.CommonTlsContextTestsUtil.SERVER_1_SPIFFE_PEM_FILE;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.CALLS_REAL_METHODS;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import io.envoyproxy.envoy.extensions.transport_sockets.tls.v3.CertificateValidationContext;
+import io.envoyproxy.envoy.type.matcher.v3.RegexMatcher;
+import io.envoyproxy.envoy.type.matcher.v3.StringMatcher;
+import io.grpc.testing.TlsTesting;
+import java.io.IOException;
+import java.security.cert.CertStoreException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.X509ExtendedTrustManager;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Unit tests for {@link XdsX509TrustManager}.
+ */
+@RunWith(Parameterized.class)
+public class XdsX509TrustManagerTest {
+
+  @Rule
+  public final MockitoRule mockitoRule = MockitoJUnit.rule();
+
+  @Mock
+  private X509ExtendedTrustManager mockDelegate;
+
+  @Mock
+  private SSLSession mockSession;
+
+  private XdsX509TrustManager trustManager;
+
+  private final TestParam testParam;
+
+  public XdsX509TrustManagerTest(TestParam testParam) {
+    this.testParam = testParam;
+  }
+
+  @Test
+  public void nullCertContextTest() throws CertificateException, IOException {
+    trustManager = new XdsX509TrustManager(null, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, new ArrayList<>());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void emptySanListContextTest() throws CertificateException, IOException {
+    CertificateValidationContext certContext = CertificateValidationContext.getDefaultInstance();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void missingPeerCerts() {
+    StringMatcher stringMatcher = StringMatcher.newBuilder().setExact("foo.com").build();
+    @SuppressWarnings("deprecation")
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    try {
+      trustManager.verifySubjectAltNameInChain(null, certContext.getMatchSubjectAltNamesList());
+      fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate(s) missing");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void emptyArrayPeerCerts() {
+    StringMatcher stringMatcher = StringMatcher.newBuilder().setExact("foo.com").build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    try {
+      trustManager.verifySubjectAltNameInChain(
+          new X509Certificate[0], certContext.getMatchSubjectAltNamesList());
+      fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate(s) missing");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void noSansInPeerCerts() throws CertificateException, IOException {
+    StringMatcher stringMatcher = StringMatcher.newBuilder().setExact("foo.com").build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(CLIENT_PEM_FILE));
+    try {
+      trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+      fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCertsVerifies() throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder()
+            .setExact("waterzooi.test.google.be")
+            .setIgnoreCase(false)
+            .build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCertsVerifies_differentCase_expectException()
+      throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder()
+            .setExact("waterZooi.test.Google.be")
+            .setIgnoreCase(false)
+            .build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    try {
+      trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+      fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCertsVerifies_ignoreCase() throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder().setExact("Waterzooi.Test.google.be").setIgnoreCase(true).build();
+    @SuppressWarnings("deprecation")
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCerts_prefix() throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder()
+            .setPrefix("waterzooi.") // test.google.be
+            .setIgnoreCase(false)
+            .build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCertsPrefix_differentCase_expectException()
+      throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder().setPrefix("waterZooi.").setIgnoreCase(false).build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    try {
+      trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+      fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCerts_prefixIgnoreCase() throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder()
+            .setPrefix("WaterZooi.") // test.google.be
+            .setIgnoreCase(true)
+            .build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCerts_suffix() throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder().setSuffix(".google.be").setIgnoreCase(false).build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCertsSuffix_differentCase_expectException()
+      throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder().setSuffix(".gooGle.bE").setIgnoreCase(false).build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    try {
+      trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+      fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCerts_suffixIgnoreCase() throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder().setSuffix(".GooGle.BE").setIgnoreCase(true).build();
+    @SuppressWarnings("deprecation")
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCerts_substring() throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder().setContains("zooi.test.google").setIgnoreCase(false).build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCertsSubstring_differentCase_expectException()
+      throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder().setContains("zooi.Test.gooGle").setIgnoreCase(false).build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    try {
+      trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+      fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCerts_substringIgnoreCase() throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder().setContains("zooI.Test.Google").setIgnoreCase(true).build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCerts_safeRegex() throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder()
+            .setSafeRegex(
+                RegexMatcher.newBuilder().setRegex("water[[:alpha:]]{1}ooi\\.test\\.google\\.be"))
+            .build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCerts_safeRegex1() throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder()
+            .setSafeRegex(
+                RegexMatcher.newBuilder().setRegex("no-match-string|\\*\\.test\\.youtube\\.com"))
+            .build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCerts_safeRegex_ipAddress() throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder()
+            .setSafeRegex(
+                RegexMatcher.newBuilder().setRegex("([[:digit:]]{1,3}\\.){3}[[:digit:]]{1,3}"))
+            .build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCerts_safeRegex_noMatch() throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder()
+            .setSafeRegex(
+                RegexMatcher.newBuilder().setRegex("water[[:alpha:]]{2}ooi\\.test\\.google\\.be"))
+            .build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    try {
+      trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+      fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCertsVerifiesMultipleVerifySans()
+          throws CertificateException, IOException {
+    StringMatcher stringMatcher = StringMatcher.newBuilder().setExact("x.foo.com").build();
+    StringMatcher stringMatcher1 =
+        StringMatcher.newBuilder().setExact("waterzooi.test.google.be").build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder()
+            .addMatchSubjectAltNames(stringMatcher)
+            .addMatchSubjectAltNames(stringMatcher1)
+            .build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneSanInPeerCertsNotFoundException()
+          throws CertificateException, IOException {
+    StringMatcher stringMatcher = StringMatcher.newBuilder().setExact("x.foo.com").build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    try {
+      trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+      fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void wildcardSanInPeerCertsVerifiesMultipleVerifySans()
+          throws CertificateException, IOException {
+    StringMatcher stringMatcher = StringMatcher.newBuilder().setExact("x.foo.com").build();
+    StringMatcher stringMatcher1 =
+        StringMatcher.newBuilder().setSuffix("test.youTube.Com").setIgnoreCase(true).build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder()
+            .addMatchSubjectAltNames(stringMatcher)
+            .addMatchSubjectAltNames(stringMatcher1) // should match suffix test.youTube.Com
+            .build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void wildcardSanInPeerCertsVerifiesMultipleVerifySans1()
+          throws CertificateException, IOException {
+    StringMatcher stringMatcher = StringMatcher.newBuilder().setExact("x.foo.com").build();
+    StringMatcher stringMatcher1 =
+        StringMatcher.newBuilder().setContains("est.Google.f").setIgnoreCase(true).build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder()
+            .addMatchSubjectAltNames(stringMatcher)
+            .addMatchSubjectAltNames(stringMatcher1) // should contain est.Google.f
+            .build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void wildcardSanInPeerCertsSubdomainMismatch()
+          throws CertificateException, IOException {
+    // 2. Asterisk (*) cannot match across domain name labels.
+    //    For example, *.example.com matches test.example.com but does not match
+    //    sub.test.example.com.
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder().setExact("sub.abc.test.youtube.com").build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    try {
+      trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+      fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneIpAddressInPeerCertsVerifies() throws CertificateException, IOException {
+    StringMatcher stringMatcher = StringMatcher.newBuilder().setExact("x.foo.com").build();
+    StringMatcher stringMatcher1 = StringMatcher.newBuilder().setExact("192.168.1.3").build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder()
+            .addMatchSubjectAltNames(stringMatcher)
+            .addMatchSubjectAltNames(stringMatcher1)
+            .build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void oneIpAddressInPeerCertsMismatch() throws CertificateException, IOException {
+    StringMatcher stringMatcher = StringMatcher.newBuilder().setExact("x.foo.com").build();
+    StringMatcher stringMatcher1 = StringMatcher.newBuilder().setExact("192.168.2.3").build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder()
+            .addMatchSubjectAltNames(stringMatcher)
+            .addMatchSubjectAltNames(stringMatcher1)
+            .build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    try {
+      trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+      fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
+    }
+  }
+
+  @Test
+  public void checkServerTrustedSslEngine()
+      throws CertificateException, IOException, CertStoreException {
+    TestSslEngine sslEngine = buildTrustManagerAndGetSslEngine();
+    X509Certificate[] serverCerts =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.checkServerTrusted(serverCerts, "ECDHE_ECDSA", sslEngine);
+    verify(sslEngine, times(1)).getHandshakeSession();
+    assertThat(sslEngine.getSSLParameters().getEndpointIdentificationAlgorithm()).isEmpty();
+  }
+
+  @Test
+  public void checkServerTrustedSslEngineSpiffeTrustMap()
+      throws CertificateException, IOException, CertStoreException {
+    TestSslEngine sslEngine = buildTrustManagerAndGetSslEngine();
+    X509Certificate[] serverCerts =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_SPIFFE_PEM_FILE));
+    List<X509Certificate> caCerts = Arrays.asList(CertificateUtils
+        .toX509Certificates(TlsTesting.loadCert(CA_PEM_FILE)));
+    trustManager = XdsTrustManagerFactory.createX509TrustManager(
+        ImmutableMap.of("example.com", caCerts), null, false);
+    trustManager.checkServerTrusted(serverCerts, "ECDHE_ECDSA", sslEngine);
+    verify(sslEngine, times(1)).getHandshakeSession();
+    assertThat(sslEngine.getSSLParameters().getEndpointIdentificationAlgorithm()).isEmpty();
+  }
+
+  @Test
+  public void checkServerTrustedSslEngineSpiffeTrustMap_missing_spiffe_id()
+      throws CertificateException, IOException, CertStoreException {
+    TestSslEngine sslEngine = buildTrustManagerAndGetSslEngine();
+    X509Certificate[] serverCerts =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    List<X509Certificate> caCerts = Arrays.asList(CertificateUtils
+        .toX509Certificates(TlsTesting.loadCert(CA_PEM_FILE)));
+    trustManager = XdsTrustManagerFactory.createX509TrustManager(
+        ImmutableMap.of("example.com", caCerts), null, false);
+    try {
+      trustManager.checkServerTrusted(serverCerts, "ECDHE_ECDSA", sslEngine);
+      fail("exception expected");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat()
+          .isEqualTo("Failed to extract SPIFFE ID from peer leaf certificate");
+    }
+  }
+
+  @Test
+  public void checkServerTrustedSpiffeSslEngineTrustMap_missing_trust_domain()
+      throws CertificateException, IOException, CertStoreException {
+    TestSslEngine sslEngine = buildTrustManagerAndGetSslEngine();
+    X509Certificate[] serverCerts =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_SPIFFE_PEM_FILE));
+    List<X509Certificate> caCerts = Arrays.asList(CertificateUtils
+        .toX509Certificates(TlsTesting.loadCert(CA_PEM_FILE)));
+    trustManager = XdsTrustManagerFactory.createX509TrustManager(
+        ImmutableMap.of("unknown.com", caCerts), null, false);
+    try {
+      trustManager.checkServerTrusted(serverCerts, "ECDHE_ECDSA", sslEngine);
+      fail("exception expected");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Spiffe Trust Map doesn't contain trust"
+          + " domain 'example.com' from peer leaf certificate");
+    }
+  }
+
+  @Test
+  public void checkClientTrustedSpiffeTrustMap()
+      throws CertificateException, IOException, CertStoreException {
+    X509Certificate[] clientCerts =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(CLIENT_SPIFFE_PEM_FILE));
+    List<X509Certificate> caCerts = Arrays.asList(CertificateUtils
+        .toX509Certificates(TlsTesting.loadCert(CA_PEM_FILE)));
+    trustManager = XdsTrustManagerFactory.createX509TrustManager(
+        ImmutableMap.of("foo.bar.com", caCerts), null, false);
+    trustManager.checkClientTrusted(clientCerts, "RSA");
+  }
+
+  @Test
+  public void checkServerTrustedSslEngine_untrustedServer_expectException()
+      throws CertificateException, IOException, CertStoreException {
+    TestSslEngine sslEngine = buildTrustManagerAndGetSslEngine();
+    X509Certificate[] badServerCert =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(BAD_SERVER_PEM_FILE));
+    try {
+      trustManager.checkServerTrusted(badServerCert, "ECDHE_ECDSA", sslEngine);
+      fail("exception expected");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat()
+          .endsWith("unable to find valid certification path to requested target");
+    }
+    verify(sslEngine, times(1)).getHandshakeSession();
+  }
+
+  @Test
+  public void checkServerTrustedSslSocket()
+      throws CertificateException, IOException, CertStoreException {
+    TestSslSocket sslSocket = buildTrustManagerAndGetSslSocket();
+    X509Certificate[] serverCerts =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_PEM_FILE));
+    trustManager.checkServerTrusted(serverCerts, "ECDHE_ECDSA", sslSocket);
+    verify(sslSocket, times(1)).isConnected();
+    verify(sslSocket, times(1)).getHandshakeSession();
+    assertThat(sslSocket.getSSLParameters().getEndpointIdentificationAlgorithm()).isEmpty();
+  }
+
+  @Test
+  public void checkServerTrustedSslSocketSpiffeTrustMap()
+      throws CertificateException, IOException, CertStoreException {
+    TestSslSocket sslSocket = buildTrustManagerAndGetSslSocket();
+    X509Certificate[] serverCerts =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(SERVER_1_SPIFFE_PEM_FILE));
+    List<X509Certificate> caCerts = Arrays.asList(CertificateUtils
+        .toX509Certificates(TlsTesting.loadCert(CA_PEM_FILE)));
+    trustManager = XdsTrustManagerFactory.createX509TrustManager(
+        ImmutableMap.of("example.com", caCerts), null, false);
+    trustManager.checkServerTrusted(serverCerts, "ECDHE_ECDSA", sslSocket);
+    verify(sslSocket, times(1)).isConnected();
+    verify(sslSocket, times(1)).getHandshakeSession();
+    assertThat(sslSocket.getSSLParameters().getEndpointIdentificationAlgorithm()).isEmpty();
+  }
+
+  @Test
+  public void checkServerTrustedSslSocket_untrustedServer_expectException()
+      throws CertificateException, IOException, CertStoreException {
+    TestSslSocket sslSocket = buildTrustManagerAndGetSslSocket();
+    X509Certificate[] badServerCert =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(BAD_SERVER_PEM_FILE));
+    try {
+      trustManager.checkServerTrusted(badServerCert, "ECDHE_ECDSA", sslSocket);
+      fail("exception expected");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat()
+          .endsWith("unable to find valid certification path to requested target");
+    }
+    verify(sslSocket, times(1)).isConnected();
+    verify(sslSocket, times(1)).getHandshakeSession();
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void unsupportedAltNameType() throws CertificateException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder()
+            .setExact("waterzooi.test.google.be")
+            .setIgnoreCase(false)
+            .build();
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder().addMatchSubjectAltNames(stringMatcher).build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate mockCert = mock(X509Certificate.class);
+
+    when(mockCert.getSubjectAlternativeNames())
+        .thenReturn(Collections.<List<?>>singleton(ImmutableList.of(Integer.valueOf(1), "foo")));
+    X509Certificate[] certs = new X509Certificate[] {mockCert};
+    try {
+      trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+      fail("no exception thrown");
+    } catch (CertificateException expected) {
+      assertThat(expected).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
+    }
+  }
+
+  @Test
+  @SuppressWarnings("deprecation")
+  public void testDnsWildcardPatterns()
+      throws CertificateException, IOException {
+    StringMatcher stringMatcher =
+        StringMatcher.newBuilder()
+            .setExact(testParam.sanPattern)
+            .setIgnoreCase(testParam.ignoreCase)
+            .build();
+    @SuppressWarnings("deprecation")
+    CertificateValidationContext certContext =
+        CertificateValidationContext.newBuilder()
+            .addMatchSubjectAltNames(stringMatcher)
+            .build();
+    trustManager = new XdsX509TrustManager(certContext, mockDelegate, false);
+    X509Certificate[] certs =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(testParam.certFile));
+    try {
+      trustManager.verifySubjectAltNameInChain(certs, certContext.getMatchSubjectAltNamesList());
+      assertThat(testParam.expected).isTrue();
+    } catch (CertificateException certException) {
+      assertThat(testParam.expected).isFalse();
+      assertThat(certException).hasMessageThat().isEqualTo("Peer certificate SAN check failed");
+    }
+  }
+
+  @Parameters(name = "{index}: {0}")
+  public static Collection<Object[]> getParameters() {
+    return Arrays.asList(new Object[][] {
+        {new TestParam("*.test.google.fr", SERVER_1_PEM_FILE, false, true)},
+        {new TestParam("*.test.youtube.com", SERVER_1_PEM_FILE, false, true)},
+        {new TestParam("waterzooi.test.google.be", SERVER_1_PEM_FILE, false, true)},
+        {new TestParam("192.168.1.3", SERVER_1_PEM_FILE, false, true)},
+        {new TestParam("*.TEST.YOUTUBE.com", SERVER_1_PEM_FILE, true, true)},
+        {new TestParam("w*i.test.google.be", SERVER_1_PEM_FILE, false, true)},
+        {new TestParam("w*a.test.google.be", SERVER_1_PEM_FILE, false, false)},
+        {new TestParam("*.test.google.com.au", SERVER_0_PEM_FILE, false, false)},
+        {new TestParam("*.TEST.YOUTUBE.com", SERVER_1_PEM_FILE, false, false)},
+        {new TestParam("*waterzooi", SERVER_1_PEM_FILE, false, false)},
+        {new TestParam("*.lyft.com", BAD_WILDCARD_DNS_PEM_FILE, false, false)},
+        {new TestParam("ly**ft.com", BAD_WILDCARD_DNS_PEM_FILE, false, false)},
+        {new TestParam("*yft.c*m", BAD_WILDCARD_DNS_PEM_FILE, false, false)},
+        {new TestParam("xn--*.lyft.com", BAD_WILDCARD_DNS_PEM_FILE, false, false)},
+        {new TestParam("", BAD_WILDCARD_DNS_PEM_FILE, false, false)},
+    });
+  }
+
+  private TestSslEngine buildTrustManagerAndGetSslEngine()
+      throws CertificateException, IOException, CertStoreException {
+    SSLParameters sslParams = buildTrustManagerAndGetSslParameters();
+
+    TestSslEngine sslEngine = mock(TestSslEngine.class, CALLS_REAL_METHODS);
+    sslEngine.setSSLParameters(sslParams);
+    doReturn(mockSession).when(sslEngine).getHandshakeSession();
+    return sslEngine;
+  }
+
+  private TestSslSocket buildTrustManagerAndGetSslSocket()
+      throws CertificateException, IOException, CertStoreException {
+    SSLParameters sslParams = buildTrustManagerAndGetSslParameters();
+
+    TestSslSocket sslSocket = mock(TestSslSocket.class, CALLS_REAL_METHODS);
+    sslSocket.setSSLParameters(sslParams);
+    doReturn(true).when(sslSocket).isConnected();
+    doReturn(mockSession).when(sslSocket).getHandshakeSession();
+    return sslSocket;
+  }
+
+  private SSLParameters buildTrustManagerAndGetSslParameters()
+      throws CertificateException, IOException, CertStoreException {
+    X509Certificate[] caCerts =
+        CertificateUtils.toX509Certificates(TlsTesting.loadCert(CA_PEM_FILE));
+    trustManager = XdsTrustManagerFactory.createX509TrustManager(caCerts,
+        null, false);
+    when(mockSession.getProtocol()).thenReturn("TLSv1.2");
+    when(mockSession.getPeerHost()).thenReturn("peer-host-from-mock");
+    SSLParameters sslParams = new SSLParameters();
+    sslParams.setEndpointIdentificationAlgorithm("HTTPS");
+    return sslParams;
+  }
+
+  private abstract static class TestSslSocket extends SSLSocket {
+
+    @Override
+    public SSLParameters getSSLParameters() {
+      return sslParameters;
+    }
+
+    @Override
+    public void setSSLParameters(SSLParameters sslParameters) {
+      this.sslParameters = sslParameters;
+    }
+
+    private SSLParameters sslParameters;
+  }
+
+  private abstract static class TestSslEngine extends SSLEngine {
+
+    @Override
+    public SSLParameters getSSLParameters() {
+      return sslParameters;
+    }
+
+    @Override
+    public void setSSLParameters(SSLParameters sslParameters) {
+      this.sslParameters = sslParameters;
+    }
+
+    private SSLParameters sslParameters;
+  }
+
+  private static class TestParam {
+    final String sanPattern;
+    final String certFile;
+    final boolean ignoreCase;
+    final boolean expected;
+
+    TestParam(String sanPattern, String certFile, boolean ignoreCase, boolean expected) {
+      this.sanPattern = sanPattern;
+      this.certFile = certFile;
+      this.ignoreCase = ignoreCase;
+      this.expected = expected;
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/orca/OrcaMetricReportingServerInterceptorTest.java b/xds/src/test/java/io/grpc/xds/orca/OrcaMetricReportingServerInterceptorTest.java
new file mode 100644
index 00000000000..ec56467e5a5
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/orca/OrcaMetricReportingServerInterceptorTest.java
@@ -0,0 +1,330 @@
+/*
+ * Copyright 2019 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.xds.orca;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.github.xds.data.orca.v3.OrcaLoadReport;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientCall;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientInterceptors;
+import io.grpc.Context;
+import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
+import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerInterceptors;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.services.CallMetricRecorder;
+import io.grpc.services.InternalCallMetricRecorder;
+import io.grpc.services.MetricRecorder;
+import io.grpc.stub.ClientCalls;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.testing.protobuf.SimpleRequest;
+import io.grpc.testing.protobuf.SimpleResponse;
+import io.grpc.testing.protobuf.SimpleServiceGrpc;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Tests for {@link OrcaMetricReportingServerInterceptor}.
+ */
+@RunWith(JUnit4.class)
+public class OrcaMetricReportingServerInterceptorTest {
+
+  @Rule
+  public final GrpcCleanupRule grpcCleanupRule = new GrpcCleanupRule();
+
+  private static final MethodDescriptor<SimpleRequest, SimpleResponse> SIMPLE_METHOD =
+      SimpleServiceGrpc.getUnaryRpcMethod();
+
+  private static final SimpleRequest REQUEST =
+      SimpleRequest.newBuilder().setRequestMessage("Simple request").build();
+
+  private final Map<String, Double> applicationUtilizationMetricsMap = new HashMap<>();
+  private final Map<String, Double> applicationCostMetrics = new HashMap<>();
+  private final Map<String, Double> applicationNamedMetrics = new HashMap<>();
+  private double cpuUtilizationMetrics = 0;
+  private double applicationUtilizationMetrics = 0;
+  private double memoryUtilizationMetrics = 0;
+  private double qpsMetrics = 0;
+  private double epsMetrics = 0;
+  private MetricRecorder metricRecorder;
+
+  private final AtomicReference<Metadata> trailersCapture = new AtomicReference<>();
+
+  private Channel channelToUse;
+
+  @Before
+  public void setUp() throws Exception {
+    SimpleServiceGrpc.SimpleServiceImplBase simpleServiceImpl =
+        new SimpleServiceGrpc.SimpleServiceImplBase() {
+          @Override
+          public void unaryRpc(
+              SimpleRequest request, StreamObserver<SimpleResponse> responseObserver) {
+            for (Map.Entry<String, Double> entry : applicationUtilizationMetricsMap.entrySet()) {
+              CallMetricRecorder.getCurrent().recordUtilizationMetric(entry.getKey(),
+                  entry.getValue());
+            }
+            for (Map.Entry<String, Double> entry : applicationCostMetrics.entrySet()) {
+              CallMetricRecorder.getCurrent().recordRequestCostMetric(entry.getKey(),
+                  entry.getValue());
+            }
+            for (Map.Entry<String, Double> entry : applicationNamedMetrics.entrySet()) {
+              CallMetricRecorder.getCurrent().recordNamedMetric(entry.getKey(), entry.getValue());
+            }
+            CallMetricRecorder.getCurrent().recordCpuUtilizationMetric(cpuUtilizationMetrics);
+            CallMetricRecorder.getCurrent()
+                .recordApplicationUtilizationMetric(applicationUtilizationMetrics);
+            CallMetricRecorder.getCurrent().recordMemoryUtilizationMetric(memoryUtilizationMetrics);
+            CallMetricRecorder.getCurrent().recordQpsMetric(qpsMetrics);
+            CallMetricRecorder.getCurrent().recordEpsMetric(epsMetrics);
+            SimpleResponse response =
+                SimpleResponse.newBuilder().setResponseMessage("Simple response").build();
+            responseObserver.onNext(response);
+            responseObserver.onCompleted();
+          }
+        };
+
+    metricRecorder = MetricRecorder.newInstance();
+    ServerInterceptor metricReportingServerInterceptor = new OrcaMetricReportingServerInterceptor(
+        metricRecorder);
+    String serverName = InProcessServerBuilder.generateName();
+    grpcCleanupRule.register(
+        InProcessServerBuilder
+            .forName(serverName)
+            .directExecutor()
+            .addService(
+                ServerInterceptors.intercept(simpleServiceImpl, metricReportingServerInterceptor))
+            .build().start());
+
+    ManagedChannel baseChannel =
+        grpcCleanupRule.register(InProcessChannelBuilder.forName(serverName).build());
+    channelToUse =
+        ClientInterceptors.intercept(
+            baseChannel, new TrailersCapturingClientInterceptor(trailersCapture));
+  }
+
+  @Test
+  public void shareCallMetricRecorderInContext() throws IOException {
+    final CallMetricRecorder callMetricRecorder = new CallMetricRecorder();
+    ServerStreamTracer.Factory callMetricRecorderSharingStreamTracerFactory;
+    callMetricRecorderSharingStreamTracerFactory = new ServerStreamTracer.Factory() {
+      @Override
+      public ServerStreamTracer newServerStreamTracer(String fullMethodName, Metadata headers) {
+        return new ServerStreamTracer() {
+          @Override
+          public Context filterContext(Context context) {
+            return context.withValue(InternalCallMetricRecorder.CONTEXT_KEY, callMetricRecorder);
+          }
+        };
+      }
+    };
+
+    final AtomicReference<CallMetricRecorder> callMetricRecorderCapture = new AtomicReference<>();
+    SimpleServiceGrpc.SimpleServiceImplBase simpleServiceImpl =
+        new SimpleServiceGrpc.SimpleServiceImplBase() {
+          @Override
+          public void unaryRpc(
+              SimpleRequest request, StreamObserver<SimpleResponse> responseObserver) {
+            callMetricRecorderCapture.set(CallMetricRecorder.getCurrent());
+            SimpleResponse response =
+                SimpleResponse.newBuilder().setResponseMessage("Simple response").build();
+            responseObserver.onNext(response);
+            responseObserver.onCompleted();
+          }
+        };
+
+    ServerInterceptor metricReportingServerInterceptor =
+        OrcaMetricReportingServerInterceptor.getInstance();
+    String serverName = InProcessServerBuilder.generateName();
+    grpcCleanupRule.register(
+        InProcessServerBuilder
+            .forName(serverName)
+            .directExecutor()
+            .addStreamTracerFactory(callMetricRecorderSharingStreamTracerFactory)
+            .addService(
+                ServerInterceptors.intercept(simpleServiceImpl, metricReportingServerInterceptor))
+            .build().start());
+
+    ManagedChannel channel =
+        grpcCleanupRule.register(InProcessChannelBuilder.forName(serverName).build());
+    ClientCalls.blockingUnaryCall(channel, SIMPLE_METHOD, CallOptions.DEFAULT, REQUEST);
+
+    assertThat(callMetricRecorderCapture.get()).isSameInstanceAs(callMetricRecorder);
+  }
+
+  @Test
+  public void noTrailerReportIfNoRecordedMetrics() {
+    ClientCalls.blockingUnaryCall(channelToUse, SIMPLE_METHOD, CallOptions.DEFAULT, REQUEST);
+    Metadata receivedTrailers = trailersCapture.get();
+    assertThat(
+        receivedTrailers.get(OrcaMetricReportingServerInterceptor.ORCA_ENDPOINT_LOAD_METRICS_KEY))
+        .isNull();
+  }
+
+  @Test
+  public void responseTrailersContainAllReportedMetricsFromCallMetricRecorder() {
+    applicationCostMetrics.put("cost1", 1231.4543);
+    applicationCostMetrics.put("cost2", 0.1367);
+    applicationCostMetrics.put("cost3", 7614.145);
+    applicationUtilizationMetricsMap.put("util1", 0.1082);
+    applicationUtilizationMetricsMap.put("util2", 0.4936);
+    applicationUtilizationMetricsMap.put("util3", 0.5342);
+    applicationNamedMetrics.put("named1", 0.777);
+    applicationNamedMetrics.put("named2", 737.747);
+    applicationNamedMetrics.put("named3", -0.380);
+    cpuUtilizationMetrics = 0.3465;
+    applicationUtilizationMetrics = 0.99887;
+    memoryUtilizationMetrics = 0.764;
+    qpsMetrics = 3.1415926535;
+    epsMetrics = 1.618;
+    ClientCalls.blockingUnaryCall(channelToUse, SIMPLE_METHOD, CallOptions.DEFAULT, REQUEST);
+    Metadata receivedTrailers = trailersCapture.get();
+    OrcaLoadReport report =
+        receivedTrailers.get(OrcaMetricReportingServerInterceptor.ORCA_ENDPOINT_LOAD_METRICS_KEY);
+    assertThat(report.getUtilizationMap())
+        .containsExactly("util1", 0.1082, "util2", 0.4936, "util3", 0.5342);
+    assertThat(report.getRequestCostMap())
+        .containsExactly("cost1", 1231.4543, "cost2", 0.1367, "cost3", 7614.145);
+    assertThat(report.getNamedMetricsMap())
+        .containsExactly("named1", 0.777, "named2", 737.747, "named3", -0.380);
+    assertThat(report.getCpuUtilization()).isEqualTo(0.3465);
+    assertThat(report.getApplicationUtilization()).isEqualTo(0.99887);
+    assertThat(report.getMemUtilization()).isEqualTo(0.764);
+    assertThat(report.getRpsFractional()).isEqualTo(3.1415926535);
+    assertThat(report.getEps()).isEqualTo(1.618);
+  }
+
+  @Test
+  public void responseTrailersContainMergedMetricsFromCallMetricRecorderAndMetricRecorder() {
+    applicationUtilizationMetricsMap.put("util1", 0.1482);
+    applicationUtilizationMetricsMap.put("util2", 0.4036);
+    applicationUtilizationMetricsMap.put("util3", 0.5742);
+    applicationNamedMetrics.put("named1", 0.777);
+    applicationNamedMetrics.put("named2", 737.747);
+    applicationNamedMetrics.put("named3", -0.380);
+    cpuUtilizationMetrics = 0.3465;
+    memoryUtilizationMetrics = 0.967;
+    metricRecorder.setApplicationUtilizationMetric(2.718);
+    metricRecorder.setMemoryUtilizationMetric(0.764);
+    metricRecorder.setQpsMetric(1.618);
+    metricRecorder.setEpsMetric(3.14159);
+    metricRecorder.putUtilizationMetric("serverUtil1", 0.7467);
+    metricRecorder.putUtilizationMetric("serverUtil2", 0.2233);
+    metricRecorder.putUtilizationMetric("util1", 0.01);
+    metricRecorder.putUtilizationMetric("util3", 0.99);
+
+    ClientCalls.blockingUnaryCall(channelToUse, SIMPLE_METHOD, CallOptions.DEFAULT, REQUEST);
+    Metadata receivedTrailers = trailersCapture.get();
+    OrcaLoadReport report =
+        receivedTrailers.get(OrcaMetricReportingServerInterceptor.ORCA_ENDPOINT_LOAD_METRICS_KEY);
+
+    assertThat(report.getUtilizationMap())
+        .containsExactly("util1", 0.1482, "util2", 0.4036, "util3", 0.5742, "serverUtil1", 0.7467,
+            "serverUtil2", 0.2233);
+    assertThat(report.getNamedMetricsMap())
+        .containsExactly("named1", 0.777, "named2", 737.747, "named3", -0.380);
+    assertThat(report.getRequestCostMap()).isEmpty();
+    assertThat(report.getCpuUtilization()).isEqualTo(0.3465);
+    assertThat(report.getApplicationUtilization()).isEqualTo(2.718);
+    assertThat(report.getMemUtilization()).isEqualTo(0.967);
+    assertThat(report.getRpsFractional()).isEqualTo(1.618);
+    assertThat(report.getEps()).isEqualTo(3.14159);
+  }
+
+  @Test
+  public void responseTrailersContainMergedMetricsFromCallMetricRecorderAndMetricRecorderNoMap() {
+    applicationUtilizationMetrics = 1.414;
+    qpsMetrics = 5142.77;
+    epsMetrics = 2233.88;
+    metricRecorder.setCpuUtilizationMetric(0.314159);
+    metricRecorder.setApplicationUtilizationMetric(2.718);
+    metricRecorder.setMemoryUtilizationMetric(0.764);
+    metricRecorder.setQpsMetric(1.618);
+    metricRecorder.setEpsMetric(3.14159);
+
+    ClientCalls.blockingUnaryCall(channelToUse, SIMPLE_METHOD, CallOptions.DEFAULT, REQUEST);
+    Metadata receivedTrailers = trailersCapture.get();
+    OrcaLoadReport report =
+        receivedTrailers.get(OrcaMetricReportingServerInterceptor.ORCA_ENDPOINT_LOAD_METRICS_KEY);
+
+    assertThat(report.getUtilizationMap()).isEmpty();
+    assertThat(report.getRequestCostMap()).isEmpty();
+    assertThat(report.getCpuUtilization()).isEqualTo(0.314159);
+    assertThat(report.getApplicationUtilization()).isEqualTo(1.414);
+    assertThat(report.getMemUtilization()).isEqualTo(0.764);
+    assertThat(report.getRpsFractional()).isEqualTo(5142.77);
+    assertThat(report.getEps()).isEqualTo(2233.88);
+  }
+
+  private static final class TrailersCapturingClientInterceptor implements ClientInterceptor {
+    final AtomicReference<Metadata> trailersCapture;
+
+    TrailersCapturingClientInterceptor(AtomicReference<Metadata> trailersCapture) {
+      this.trailersCapture = trailersCapture;
+    }
+
+    @Override
+    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
+        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
+      return new TrailersCapturingClientCall<>(next.newCall(method, callOptions));
+    }
+
+    private final class TrailersCapturingClientCall<ReqT, RespT>
+        extends SimpleForwardingClientCall<ReqT, RespT> {
+
+      TrailersCapturingClientCall(ClientCall<ReqT, RespT> call) {
+        super(call);
+      }
+
+      @Override
+      public void start(Listener<RespT> responseListener, Metadata headers) {
+        trailersCapture.set(null);
+        super.start(new TrailersCapturingClientCallListener(responseListener), headers);
+      }
+
+      private final class TrailersCapturingClientCallListener
+          extends SimpleForwardingClientCallListener<RespT> {
+        TrailersCapturingClientCallListener(ClientCall.Listener<RespT> responseListener) {
+          super(responseListener);
+        }
+
+        @Override
+        public void onClose(Status status, Metadata trailers) {
+          trailersCapture.set(trailers);
+          super.onClose(status, trailers);
+        }
+      }
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/orca/OrcaOobUtilTest.java b/xds/src/test/java/io/grpc/xds/orca/OrcaOobUtilTest.java
new file mode 100644
index 00000000000..e2a361d660c
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/orca/OrcaOobUtilTest.java
@@ -0,0 +1,950 @@
+/*
+ * Copyright 2019 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.xds.orca;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+import static com.google.common.truth.Truth.assertThat;
+import static io.grpc.ConnectivityState.CONNECTING;
+import static io.grpc.ConnectivityState.IDLE;
+import static io.grpc.ConnectivityState.READY;
+import static io.grpc.ConnectivityState.SHUTDOWN;
+import static org.junit.Assert.fail;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.github.xds.data.orca.v3.OrcaLoadReport;
+import com.github.xds.service.orca.v3.OpenRcaServiceGrpc;
+import com.github.xds.service.orca.v3.OrcaLoadReportRequest;
+import com.google.common.util.concurrent.MoreExecutors;
+import com.google.protobuf.util.Durations;
+import io.grpc.Attributes;
+import io.grpc.Channel;
+import io.grpc.ChannelLogger;
+import io.grpc.ConnectivityState;
+import io.grpc.ConnectivityStateInfo;
+import io.grpc.Context;
+import io.grpc.Context.CancellationListener;
+import io.grpc.EquivalentAddressGroup;
+import io.grpc.LoadBalancer;
+import io.grpc.LoadBalancer.CreateSubchannelArgs;
+import io.grpc.LoadBalancer.Helper;
+import io.grpc.LoadBalancer.Subchannel;
+import io.grpc.LoadBalancer.SubchannelPicker;
+import io.grpc.LoadBalancer.SubchannelStateListener;
+import io.grpc.ManagedChannel;
+import io.grpc.Status;
+import io.grpc.SynchronizationContext;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.BackoffPolicy;
+import io.grpc.internal.FakeClock;
+import io.grpc.services.MetricReport;
+import io.grpc.stub.StreamObserver;
+import io.grpc.testing.GrpcCleanupRule;
+import io.grpc.util.ForwardingLoadBalancerHelper;
+import io.grpc.xds.orca.OrcaOobUtil.OrcaOobReportListener;
+import io.grpc.xds.orca.OrcaOobUtil.OrcaReportingConfig;
+import io.grpc.xds.orca.OrcaOobUtil.SubchannelImpl;
+import java.net.SocketAddress;
+import java.text.MessageFormat;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Queue;
+import java.util.Random;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Unit tests for {@link OrcaOobUtil} class.
+ */
+@RunWith(JUnit4.class)
+public class OrcaOobUtilTest {
+
+  private static final int NUM_SUBCHANNELS = 2;
+  private static final Attributes.Key<String> SUBCHANNEL_ATTR_KEY =
+      Attributes.Key.create("subchannel-attr-for-test");
+  private static final OrcaReportingConfig SHORT_INTERVAL_CONFIG =
+      OrcaReportingConfig.newBuilder().setReportInterval(5L, TimeUnit.NANOSECONDS).build();
+  private static final OrcaReportingConfig MEDIUM_INTERVAL_CONFIG =
+      OrcaReportingConfig.newBuilder().setReportInterval(543L, TimeUnit.MICROSECONDS).build();
+  private static final OrcaReportingConfig LONG_INTERVAL_CONFIG =
+      OrcaReportingConfig.newBuilder().setReportInterval(1232L, TimeUnit.MILLISECONDS).build();
+  @Rule public final GrpcCleanupRule cleanupRule = new GrpcCleanupRule();
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  @SuppressWarnings({"rawtypes", "unchecked"})
+  private final List<EquivalentAddressGroup>[] eagLists = new List[NUM_SUBCHANNELS];
+  private final SubchannelStateListener[] mockStateListeners =
+      new SubchannelStateListener[NUM_SUBCHANNELS];
+  private final ManagedChannel[] channels = new ManagedChannel[NUM_SUBCHANNELS];
+  private final OpenRcaServiceImp[] orcaServiceImps = new OpenRcaServiceImp[NUM_SUBCHANNELS];
+  private final SynchronizationContext syncContext = new SynchronizationContext(
+      new Thread.UncaughtExceptionHandler() {
+        @Override
+        public void uncaughtException(Thread t, Throwable e) {
+          throw new AssertionError(e);
+        }
+      });
+
+  private final FakeClock fakeClock = new FakeClock();
+  private final Helper origHelper = mock(Helper.class, delegatesTo(new FakeHelper()));
+  @Mock
+  private OrcaOobReportListener mockOrcaListener0;
+  @Mock
+  private OrcaOobReportListener mockOrcaListener1;
+  @Mock
+  private OrcaOobReportListener mockOrcaListener2;
+  @Mock private BackoffPolicy.Provider backoffPolicyProvider;
+  @Mock private BackoffPolicy backoffPolicy1;
+  @Mock private BackoffPolicy backoffPolicy2;
+  private FakeSubchannel[] subchannels = new FakeSubchannel[NUM_SUBCHANNELS];
+  private LoadBalancer.Helper orcaHelper;
+  private LoadBalancer.Helper parentHelper;
+  private LoadBalancer.Helper childHelper;
+  private Subchannel savedParentSubchannel;
+
+  private static FakeSubchannel unwrap(Subchannel s) {
+    return (FakeSubchannel) ((SubchannelImpl) s).delegate();
+  }
+
+  private static OrcaLoadReportRequest buildOrcaRequestFromConfig(
+      OrcaReportingConfig config) {
+    return OrcaLoadReportRequest.newBuilder()
+        .setReportInterval(Durations.fromNanos(config.getReportIntervalNanos()))
+        .build();
+  }
+
+  private static void assertLog(List<String> logs, String expectedLog) {
+    assertThat(logs).contains(expectedLog);
+    logs.clear();
+  }
+
+  @After
+  public void tearDown() {
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      if (subchannels[i] != null) {
+        subchannels[i].shutdown();
+      }
+    }
+  }
+
+  @Test
+  public void orcaReportingConfig_construct() {
+    int interval = new Random().nextInt(Integer.MAX_VALUE);
+    OrcaReportingConfig config =
+        OrcaReportingConfig.newBuilder()
+            .setReportInterval(interval, TimeUnit.MICROSECONDS)
+            .build();
+    assertThat(config.getReportIntervalNanos()).isEqualTo(TimeUnit.MICROSECONDS.toNanos(interval));
+    String str = config.toString();
+    assertThat(str).contains("reportIntervalNanos=");
+    OrcaReportingConfig rebuildedConfig = config.toBuilder().build();
+    assertThat(rebuildedConfig.getReportIntervalNanos())
+        .isEqualTo(TimeUnit.MICROSECONDS.toNanos(interval));
+  }
+
+  @Before
+  public void setUp() throws Exception {
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      orcaServiceImps[i] = new OpenRcaServiceImp();
+      cleanupRule.register(
+          InProcessServerBuilder.forName("orca-reporting-test-" + i)
+              .addService(orcaServiceImps[i])
+              .directExecutor()
+              .build()
+              .start());
+      ManagedChannel channel =
+          cleanupRule.register(
+              InProcessChannelBuilder.forName("orca-reporting-test-" + i).directExecutor().build());
+      channels[i] = channel;
+      EquivalentAddressGroup eag =
+          new EquivalentAddressGroup(new FakeSocketAddress("address-" + i));
+      List<EquivalentAddressGroup> eagList = Arrays.asList(eag);
+      eagLists[i] = eagList;
+      mockStateListeners[i] = mock(SubchannelStateListener.class);
+    }
+
+    when(backoffPolicyProvider.get()).thenReturn(backoffPolicy1, backoffPolicy2);
+    when(backoffPolicy1.nextBackoffNanos()).thenReturn(11L, 21L);
+    when(backoffPolicy2.nextBackoffNanos()).thenReturn(12L, 22L);
+
+    orcaHelper =
+        OrcaOobUtil.newOrcaReportingHelper(
+            origHelper,
+            backoffPolicyProvider,
+            fakeClock.getStopwatchSupplier());
+    parentHelper =
+        new ForwardingLoadBalancerHelper() {
+          @Override
+          protected Helper delegate() {
+            return orcaHelper;
+          }
+
+          @Override
+          public Subchannel createSubchannel(CreateSubchannelArgs args) {
+            Subchannel subchannel = super.createSubchannel(args);
+            savedParentSubchannel = subchannel;
+            return subchannel;
+          }
+        };
+    childHelper =
+        OrcaOobUtil.newOrcaReportingHelper(
+            parentHelper,
+            backoffPolicyProvider,
+            fakeClock.getStopwatchSupplier());
+  }
+
+  @Test
+  public void singlePolicyTypicalWorkflow() {
+    verify(origHelper, atLeast(0)).getSynchronizationContext();
+    verifyNoMoreInteractions(origHelper);
+
+    // Calling createSubchannel() on orcaHelper correctly passes augmented CreateSubchannelArgs
+    // to origHelper.
+    ArgumentCaptor<CreateSubchannelArgs> createArgsCaptor =
+        ArgumentCaptor.forClass(CreateSubchannelArgs.class);
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      String subchannelAttrValue = "eag attr " + i;
+      Attributes attrs =
+          Attributes.newBuilder().set(SUBCHANNEL_ATTR_KEY, subchannelAttrValue).build();
+      Subchannel created = createSubchannel(orcaHelper, i, attrs);
+      assertThat(unwrap(created)).isSameInstanceAs(subchannels[i]);
+      setOrcaReportConfig(created, mockOrcaListener0, SHORT_INTERVAL_CONFIG);
+      verify(origHelper, times(i + 1)).createSubchannel(createArgsCaptor.capture());
+      assertThat(createArgsCaptor.getValue().getAddresses()).isEqualTo(eagLists[i]);
+      assertThat(createArgsCaptor.getValue().getAttributes().get(SUBCHANNEL_ATTR_KEY))
+          .isEqualTo(subchannelAttrValue);
+    }
+
+    // ORCA reporting does not start until underlying Subchannel is READY.
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      FakeSubchannel subchannel = subchannels[i];
+      OpenRcaServiceImp orcaServiceImp = orcaServiceImps[i];
+      SubchannelStateListener mockStateListener = mockStateListeners[i];
+      InOrder inOrder = inOrder(mockStateListener);
+      deliverSubchannelState(i, ConnectivityStateInfo.forNonError(IDLE));
+      deliverSubchannelState(i, ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+      deliverSubchannelState(i, ConnectivityStateInfo.forNonError(CONNECTING));
+
+      inOrder.verify(mockStateListener)
+          .onSubchannelState(eq(ConnectivityStateInfo.forNonError(IDLE)));
+      inOrder.verify(mockStateListener)
+          .onSubchannelState(eq(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE)));
+      inOrder.verify(mockStateListener)
+          .onSubchannelState(eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+      verifyNoMoreInteractions(mockStateListener);
+
+      assertThat(subchannel.logs).isEmpty();
+      assertThat(orcaServiceImp.calls).isEmpty();
+      verifyNoMoreInteractions(mockOrcaListener0);
+      deliverSubchannelState(i, ConnectivityStateInfo.forNonError(READY));
+      verify(mockStateListener).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+      assertThat(orcaServiceImp.calls).hasSize(1);
+      ServerSideCall serverCall = orcaServiceImp.calls.peek();
+      assertThat(serverCall.request).isEqualTo(buildOrcaRequestFromConfig(SHORT_INTERVAL_CONFIG));
+      assertLog(subchannel.logs,
+          "DEBUG: Starting ORCA reporting for " + subchannel.getAllAddresses());
+
+      // Simulate an ORCA service response. Registered listener will receive an ORCA report for
+      // each backend.
+      OrcaLoadReport report = OrcaLoadReport.getDefaultInstance();
+      serverCall.responseObserver.onNext(report);
+      assertLog(subchannel.logs, "DEBUG: Received an ORCA report: " + report);
+      verify(mockOrcaListener0, times(i + 1)).onLoadReport(
+          argThat(new OrcaPerRequestUtilTest.MetricsReportMatcher(
+              OrcaPerRequestUtil.fromOrcaLoadReport(report))));
+    }
+
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      FakeSubchannel subchannel = subchannels[i];
+      SubchannelStateListener mockStateListener = mockStateListeners[i];
+
+      ServerSideCall serverCall = orcaServiceImps[i].calls.peek();
+      assertThat(serverCall.cancelled).isFalse();
+      verifyNoMoreInteractions(mockStateListener);
+
+      // Shutting down the subchannel will cancel the ORCA reporting RPC.
+      subchannel.shutdown();
+      verify(mockStateListener).onSubchannelState(eq(ConnectivityStateInfo.forNonError(SHUTDOWN)));
+      assertThat(serverCall.cancelled).isTrue();
+      assertThat(subchannel.logs).isEmpty();
+      verifyNoMoreInteractions(mockOrcaListener0);
+    }
+
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      assertThat(orcaServiceImps[i].calls).hasSize(1);
+    }
+
+    verifyNoInteractions(backoffPolicyProvider);
+  }
+
+  @Test
+  public void twoLevelPoliciesTypicalWorkflow() {
+    verify(origHelper, atLeast(0)).getSynchronizationContext();
+    verifyNoMoreInteractions(origHelper);
+
+    // Calling createSubchannel() on child helper correctly passes augmented CreateSubchannelArgs
+    // to origHelper.
+    ArgumentCaptor<CreateSubchannelArgs> createArgsCaptor =
+        ArgumentCaptor.forClass(CreateSubchannelArgs.class);
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      String subchannelAttrValue = "eag attr " + i;
+      Attributes attrs =
+          Attributes.newBuilder().set(SUBCHANNEL_ATTR_KEY, subchannelAttrValue).build();
+      Subchannel created = createSubchannel(childHelper, i, attrs);
+      assertThat(unwrap(((SubchannelImpl) created).delegate())).isSameInstanceAs(subchannels[i]);
+      OrcaOobUtil.setListener(created, mockOrcaListener1, SHORT_INTERVAL_CONFIG);
+      verify(origHelper, times(i + 1)).createSubchannel(createArgsCaptor.capture());
+      assertThat(createArgsCaptor.getValue().getAddresses()).isEqualTo(eagLists[i]);
+      assertThat(createArgsCaptor.getValue().getAttributes().get(SUBCHANNEL_ATTR_KEY))
+          .isEqualTo(subchannelAttrValue);
+    }
+
+    // ORCA reporting does not start until underlying Subchannel is READY.
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      FakeSubchannel subchannel = subchannels[i];
+      OpenRcaServiceImp orcaServiceImp = orcaServiceImps[i];
+      SubchannelStateListener mockStateListener = mockStateListeners[i];
+      InOrder inOrder = inOrder(mockStateListener);
+      deliverSubchannelState(i, ConnectivityStateInfo.forNonError(IDLE));
+      deliverSubchannelState(i, ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE));
+      deliverSubchannelState(i, ConnectivityStateInfo.forNonError(CONNECTING));
+
+      inOrder
+          .verify(mockStateListener).onSubchannelState(eq(ConnectivityStateInfo.forNonError(IDLE)));
+      inOrder
+          .verify(mockStateListener)
+          .onSubchannelState(eq(ConnectivityStateInfo.forTransientFailure(Status.UNAVAILABLE)));
+      inOrder
+          .verify(mockStateListener)
+          .onSubchannelState(eq(ConnectivityStateInfo.forNonError(CONNECTING)));
+      verifyNoMoreInteractions(mockStateListener);
+
+      assertThat(subchannel.logs).isEmpty();
+      assertThat(orcaServiceImp.calls).isEmpty();
+      verifyNoMoreInteractions(mockOrcaListener1);
+      verifyNoMoreInteractions(mockOrcaListener2);
+      deliverSubchannelState(i, ConnectivityStateInfo.forNonError(READY));
+      verify(mockStateListener).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+      assertThat(orcaServiceImp.calls).hasSize(1);
+      ServerSideCall serverCall = orcaServiceImp.calls.peek();
+      assertThat(serverCall.request).isEqualTo(buildOrcaRequestFromConfig(SHORT_INTERVAL_CONFIG));
+      assertLog(subchannel.logs,
+          "DEBUG: Starting ORCA reporting for " + subchannel.getAllAddresses());
+
+      // Simulate an ORCA service response. Registered listener will receive an ORCA report for
+      // each backend.
+      OrcaLoadReport report = OrcaLoadReport.getDefaultInstance();
+      serverCall.responseObserver.onNext(report);
+      assertLog(subchannel.logs, "DEBUG: Received an ORCA report: " + report);
+      verify(mockOrcaListener1, times(i + 1)).onLoadReport(
+          argThat(new OrcaPerRequestUtilTest.MetricsReportMatcher(
+              OrcaPerRequestUtil.fromOrcaLoadReport(report))));
+    }
+
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      FakeSubchannel subchannel = subchannels[i];
+      SubchannelStateListener mockStateListener = mockStateListeners[i];
+
+      ServerSideCall serverCall = orcaServiceImps[i].calls.peek();
+      assertThat(serverCall.cancelled).isFalse();
+      verifyNoMoreInteractions(mockStateListener);
+
+      // Shutting down the subchannel will cancel the ORCA reporting RPC.
+      subchannel.shutdown();
+      verify(mockStateListener).onSubchannelState(eq(ConnectivityStateInfo.forNonError(SHUTDOWN)));
+      assertThat(serverCall.cancelled).isTrue();
+      assertThat(subchannel.logs).isEmpty();
+      verifyNoMoreInteractions(mockOrcaListener1, mockOrcaListener2);
+    }
+
+    for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+      assertThat(orcaServiceImps[i].calls).hasSize(1);
+    }
+
+    verifyNoInteractions(backoffPolicyProvider);
+  }
+
+  @Test
+  public void orcReportingDisabledWhenServiceNotImplemented() {
+    final Subchannel created = createSubchannel(orcaHelper, 0, Attributes.EMPTY);
+    OrcaOobUtil.setListener(created, mockOrcaListener0, SHORT_INTERVAL_CONFIG);
+    FakeSubchannel subchannel = subchannels[0];
+    OpenRcaServiceImp orcaServiceImp = orcaServiceImps[0];
+    SubchannelStateListener mockStateListener = mockStateListeners[0];
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    verify(mockStateListener).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+    assertThat(orcaServiceImp.calls).hasSize(1);
+
+    ServerSideCall serverCall = orcaServiceImp.calls.poll();
+    assertThat(serverCall.request).isEqualTo(buildOrcaRequestFromConfig(SHORT_INTERVAL_CONFIG));
+    subchannel.logs.clear();
+    serverCall.responseObserver.onError(Status.UNIMPLEMENTED.asException());
+    assertLog(subchannel.logs,
+        "ERROR: OpenRcaService disabled: " + Status.UNIMPLEMENTED);
+    verifyNoMoreInteractions(mockOrcaListener0);
+
+    // Re-connecting on Subchannel will reset the "disabled" flag and restart ORCA reporting.
+    assertThat(orcaServiceImp.calls).hasSize(0);
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(IDLE));
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    assertLog(subchannel.logs,
+        "DEBUG: Starting ORCA reporting for " + subchannel.getAllAddresses());
+    assertThat(orcaServiceImp.calls).hasSize(1);
+    serverCall = orcaServiceImp.calls.poll();
+    OrcaLoadReport report = OrcaLoadReport.getDefaultInstance();
+    serverCall.responseObserver.onNext(report);
+    assertLog(subchannel.logs, "DEBUG: Received an ORCA report: " + report);
+    verify(mockOrcaListener0).onLoadReport(
+        argThat(new OrcaPerRequestUtilTest.MetricsReportMatcher(
+            OrcaPerRequestUtil.fromOrcaLoadReport(report))));
+    verifyNoInteractions(backoffPolicyProvider);
+  }
+
+  @Test
+  public void orcaReportingStreamClosedAndRetried() {
+    final Subchannel created = createSubchannel(orcaHelper, 0, Attributes.EMPTY);
+    OrcaOobUtil.setListener(created, mockOrcaListener0, SHORT_INTERVAL_CONFIG);
+    FakeSubchannel subchannel = subchannels[0];
+    OpenRcaServiceImp orcaServiceImp = orcaServiceImps[0];
+    SubchannelStateListener mockStateListener = mockStateListeners[0];
+    InOrder inOrder = inOrder(mockStateListener, mockOrcaListener0, backoffPolicyProvider,
+        backoffPolicy1, backoffPolicy2);
+
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    inOrder
+        .verify(mockStateListener).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+    assertLog(subchannel.logs,
+        "DEBUG: Starting ORCA reporting for " + subchannel.getAllAddresses());
+
+    // Server closes the ORCA reporting RPC without any response, will start backoff
+    // sequence 1 (11ns).
+    orcaServiceImp.calls.poll().responseObserver.onCompleted();
+    assertLog(subchannel.logs,
+        "DEBUG: ORCA reporting stream closed with " + Status.OK + ", backoff in 11" + " ns");
+    inOrder.verify(backoffPolicyProvider).get();
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+    verifyRetryAfterNanos(inOrder, orcaServiceImp, 11);
+    assertLog(subchannel.logs,
+        "DEBUG: Starting ORCA reporting for " + subchannel.getAllAddresses());
+
+    // Server closes the ORCA reporting RPC with an error, will continue backoff sequence 1 (21ns).
+    orcaServiceImp.calls.poll().responseObserver.onError(Status.UNAVAILABLE.asException());
+    assertLog(subchannel.logs,
+        "DEBUG: ORCA reporting stream closed with " + Status.UNAVAILABLE + ", backoff in 21"
+            + " ns");
+    inOrder.verify(backoffPolicy1).nextBackoffNanos();
+    verifyRetryAfterNanos(inOrder, orcaServiceImp, 21);
+    assertLog(subchannel.logs,
+        "DEBUG: Starting ORCA reporting for " + subchannel.getAllAddresses());
+
+    // Server responds normally.
+    OrcaLoadReport report = OrcaLoadReport.getDefaultInstance();
+    orcaServiceImp.calls.peek().responseObserver.onNext(report);
+    assertLog(subchannel.logs, "DEBUG: Received an ORCA report: " + report);
+    inOrder.verify(mockOrcaListener0).onLoadReport(
+        argThat(new OrcaPerRequestUtilTest.MetricsReportMatcher(
+            OrcaPerRequestUtil.fromOrcaLoadReport(report))));
+    // Server closes the ORCA reporting RPC after a response, will restart immediately.
+    orcaServiceImp.calls.poll().responseObserver.onCompleted();
+    assertThat(subchannel.logs).containsExactly(
+        "DEBUG: ORCA reporting stream closed with " + Status.OK + ", backoff in 0" + " ns",
+        "DEBUG: Starting ORCA reporting for " + subchannel.getAllAddresses());
+    subchannel.logs.clear();
+
+    // Backoff policy is set to sequence 2 in previous retry.
+    // Server closes the ORCA reporting RPC with an error, will start backoff sequence 2 (12ns).
+    orcaServiceImp.calls.poll().responseObserver.onError(Status.UNAVAILABLE.asException());
+    assertLog(subchannel.logs,
+        "DEBUG: ORCA reporting stream closed with " + Status.UNAVAILABLE + ", backoff in 12"
+            + " ns");
+    inOrder.verify(backoffPolicyProvider).get();
+    inOrder.verify(backoffPolicy2).nextBackoffNanos();
+    verifyRetryAfterNanos(inOrder, orcaServiceImp, 12);
+    assertLog(subchannel.logs,
+        "DEBUG: Starting ORCA reporting for " + subchannel.getAllAddresses());
+
+    verifyNoMoreInteractions(mockStateListener, mockOrcaListener0, backoffPolicyProvider,
+        backoffPolicy1, backoffPolicy2);
+  }
+
+  @Test
+  public void reportingNotStartedUntilConfigured() {
+    Subchannel created = createSubchannel(orcaHelper, 0, Attributes.EMPTY);
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    verify(mockStateListeners[0])
+        .onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+
+    assertThat(orcaServiceImps[0].calls).isEmpty();
+    assertThat(subchannels[0].logs).isEmpty();
+    OrcaOobUtil.setListener(created, mockOrcaListener0, SHORT_INTERVAL_CONFIG);
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    assertLog(subchannels[0].logs,
+        "DEBUG: Starting ORCA reporting for " + subchannels[0].getAllAddresses());
+    assertThat(orcaServiceImps[0].calls.peek().request)
+        .isEqualTo(buildOrcaRequestFromConfig(SHORT_INTERVAL_CONFIG));
+  }
+
+  @Test
+  public void updateListenerThrows() {
+    Subchannel created = createSubchannel(orcaHelper, 0, Attributes.EMPTY);
+    OrcaOobUtil.setListener(created, mockOrcaListener0, SHORT_INTERVAL_CONFIG);
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    verify(mockStateListeners[0])
+        .onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    assertLog(subchannels[0].logs,
+        "DEBUG: Starting ORCA reporting for " + subchannels[0].getAllAddresses());
+    assertThat(orcaServiceImps[0].calls.peek().request)
+        .isEqualTo(buildOrcaRequestFromConfig(SHORT_INTERVAL_CONFIG));
+    assertThat(unwrap(created)).isSameInstanceAs(subchannels[0]);
+    try {
+      OrcaOobUtil.setListener(subchannels[0], mockOrcaListener1, MEDIUM_INTERVAL_CONFIG);
+      fail("Update orca listener on non-orca subchannel should fail");
+    } catch (IllegalArgumentException ex) {
+      assertThat(ex.getMessage()).isEqualTo("Subchannel does not have orca Out-Of-Band "
+          + "stream enabled. Try to use a subchannel created by OrcaOobUtil.OrcaHelper.");
+    }
+  }
+
+  @Test
+  public void removeListener() {
+    Subchannel created = createSubchannel(orcaHelper, 0, Attributes.EMPTY);
+    OrcaOobUtil.setListener(created, null, SHORT_INTERVAL_CONFIG);
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    verify(mockStateListeners[0])
+            .onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+
+    assertThat(orcaServiceImps[0].calls).isEmpty();
+    assertThat(subchannels[0].logs).isEmpty();
+    assertThat(unwrap(created)).isSameInstanceAs(subchannels[0]);
+
+    OrcaOobUtil.setListener(created, mockOrcaListener0, SHORT_INTERVAL_CONFIG);
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    assertLog(subchannels[0].logs,
+            "DEBUG: Starting ORCA reporting for " + subchannels[0].getAllAddresses());
+    assertThat(orcaServiceImps[0].calls.peek().request)
+            .isEqualTo(buildOrcaRequestFromConfig(SHORT_INTERVAL_CONFIG));
+
+    OrcaOobUtil.setListener(created, null, null);
+    assertThat(orcaServiceImps[0].calls.poll().cancelled).isTrue();
+    assertThat(orcaServiceImps[0].calls).isEmpty();
+    assertThat(subchannels[0].logs).isEmpty();
+    assertThat(fakeClock.getPendingTasks()).isEmpty();
+    verifyNoMoreInteractions(mockOrcaListener0);
+    verifyNoInteractions(backoffPolicyProvider);
+  }
+
+  @Test
+  public void updateReportingIntervalBeforeCreatingSubchannel() {
+    Subchannel created = createSubchannel(orcaHelper, 0, Attributes.EMPTY);
+    OrcaOobUtil.setListener(created, mockOrcaListener0, SHORT_INTERVAL_CONFIG);
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    verify(mockStateListeners[0]).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    assertLog(subchannels[0].logs,
+        "DEBUG: Starting ORCA reporting for " + subchannels[0].getAllAddresses());
+    assertThat(orcaServiceImps[0].calls.poll().request)
+        .isEqualTo(buildOrcaRequestFromConfig(SHORT_INTERVAL_CONFIG));
+  }
+
+  @Test
+  public void updateReportingIntervalBeforeSubchannelReady() {
+    Subchannel created = createSubchannel(orcaHelper, 0, Attributes.EMPTY);
+    OrcaOobUtil.setListener(created, mockOrcaListener0, SHORT_INTERVAL_CONFIG);
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    verify(mockStateListeners[0]).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    assertLog(subchannels[0].logs,
+        "DEBUG: Starting ORCA reporting for " + subchannels[0].getAllAddresses());
+    assertThat(orcaServiceImps[0].calls.poll().request)
+        .isEqualTo(buildOrcaRequestFromConfig(SHORT_INTERVAL_CONFIG));
+  }
+
+  @Test
+  public void updateReportingIntervalWhenRpcActive() {
+    // Sets report interval before creating a Subchannel, reporting starts right after suchannel
+    // state becomes READY.
+    Subchannel created = createSubchannel(orcaHelper, 0, Attributes.EMPTY);
+    OrcaOobUtil.setListener(created, mockOrcaListener0,
+        MEDIUM_INTERVAL_CONFIG);
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    verify(mockStateListeners[0]).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    assertLog(subchannels[0].logs,
+        "DEBUG: Starting ORCA reporting for " + subchannels[0].getAllAddresses());
+    assertThat(orcaServiceImps[0].calls.peek().request)
+        .isEqualTo(buildOrcaRequestFromConfig(MEDIUM_INTERVAL_CONFIG));
+
+    // Make reporting less frequent.
+    OrcaOobUtil.setListener(created, mockOrcaListener0, LONG_INTERVAL_CONFIG);
+    assertThat(orcaServiceImps[0].calls.poll().cancelled).isTrue();
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    assertLog(subchannels[0].logs,
+        "DEBUG: Starting ORCA reporting for " + subchannels[0].getAllAddresses());
+    assertThat(orcaServiceImps[0].calls.peek().request)
+        .isEqualTo(buildOrcaRequestFromConfig(LONG_INTERVAL_CONFIG));
+
+    // Configuring with the same report interval again does not restart ORCA RPC.
+    OrcaOobUtil.setListener(created, mockOrcaListener0, LONG_INTERVAL_CONFIG);
+    assertThat(orcaServiceImps[0].calls.peek().cancelled).isFalse();
+    assertThat(subchannels[0].logs).isEmpty();
+
+    // Make reporting more frequent.
+    OrcaOobUtil.setListener(created, mockOrcaListener0,
+        SHORT_INTERVAL_CONFIG);
+    assertThat(orcaServiceImps[0].calls.poll().cancelled).isTrue();
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    assertLog(subchannels[0].logs,
+        "DEBUG: Starting ORCA reporting for " + subchannels[0].getAllAddresses());
+    assertThat(orcaServiceImps[0].calls.poll().request)
+        .isEqualTo(buildOrcaRequestFromConfig(SHORT_INTERVAL_CONFIG));
+  }
+
+  @Test
+  public void updateReportingIntervalWhenRpcPendingRetry() {
+    Subchannel created = createSubchannel(orcaHelper, 0, Attributes.EMPTY);
+    OrcaOobUtil.setListener(created, mockOrcaListener0, SHORT_INTERVAL_CONFIG);
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    verify(mockStateListeners[0]).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    assertLog(subchannels[0].logs,
+        "DEBUG: Starting ORCA reporting for " + subchannels[0].getAllAddresses());
+    assertThat(orcaServiceImps[0].calls.peek().request)
+        .isEqualTo(buildOrcaRequestFromConfig(SHORT_INTERVAL_CONFIG));
+
+    // Server closes the RPC without response, client will retry with backoff.
+    assertThat(fakeClock.getPendingTasks()).isEmpty();
+    orcaServiceImps[0].calls.poll().responseObserver.onCompleted();
+    assertLog(subchannels[0].logs,
+        "DEBUG: ORCA reporting stream closed with " + Status.OK + ", backoff in 11"
+            + " ns");
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
+    assertThat(orcaServiceImps[0].calls).isEmpty();
+
+    // Make reporting less frequent.
+    OrcaOobUtil.setListener(created, mockOrcaListener0, LONG_INTERVAL_CONFIG);
+    // Retry task will be canceled and restarts new RPC immediately.
+    assertThat(fakeClock.getPendingTasks()).isEmpty();
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    assertLog(subchannels[0].logs,
+        "DEBUG: Starting ORCA reporting for " + subchannels[0].getAllAddresses());
+    assertThat(orcaServiceImps[0].calls.peek().request)
+        .isEqualTo(buildOrcaRequestFromConfig(LONG_INTERVAL_CONFIG));
+  }
+
+  @Test
+  public void policiesReceiveSameReportIndependently() {
+    Subchannel childSubchannel = createSubchannel(childHelper, 0, Attributes.EMPTY);
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+
+    // No helper sets ORCA reporting interval, so load reporting is not started.
+    verify(mockStateListeners[0]).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+    assertThat(orcaServiceImps[0].calls).isEmpty();
+    assertThat(subchannels[0].logs).isEmpty();
+
+    // Parent helper requests ORCA reports with a certain interval, load reporting starts.
+    OrcaOobUtil.setListener(savedParentSubchannel, mockOrcaListener1, SHORT_INTERVAL_CONFIG);
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    assertLog(subchannels[0].logs,
+        "DEBUG: Starting ORCA reporting for " + subchannels[0].getAllAddresses());
+
+    OrcaLoadReport report = OrcaLoadReport.getDefaultInstance();
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    orcaServiceImps[0].calls.peek().responseObserver.onNext(report);
+    assertLog(subchannels[0].logs, "DEBUG: Received an ORCA report: " + report);
+    // Only parent helper's listener receives the report.
+    ArgumentCaptor<MetricReport> parentReportCaptor = ArgumentCaptor.forClass(MetricReport.class);
+    verify(mockOrcaListener1).onLoadReport(parentReportCaptor.capture());
+    assertThat(OrcaPerRequestUtilTest.reportEqual(parentReportCaptor.getValue(),
+        OrcaPerRequestUtil.fromOrcaLoadReport(report))).isTrue();
+    verifyNoMoreInteractions(mockOrcaListener2);
+
+    // Now child helper also wants to receive reports.
+    OrcaOobUtil.setListener(childSubchannel, mockOrcaListener2, SHORT_INTERVAL_CONFIG);
+    orcaServiceImps[0].calls.peek().responseObserver.onNext(report);
+    assertLog(subchannels[0].logs, "DEBUG: Received an ORCA report: " + report);
+    // Both helper receives the same report instance.
+    ArgumentCaptor<MetricReport> childReportCaptor = ArgumentCaptor.forClass(MetricReport.class);
+    verify(mockOrcaListener1, times(2))
+        .onLoadReport(parentReportCaptor.capture());
+    verify(mockOrcaListener2)
+        .onLoadReport(childReportCaptor.capture());
+    assertThat(childReportCaptor.getValue()).isSameInstanceAs(parentReportCaptor.getValue());
+  }
+
+  @Test
+  public void reportWithMostFrequentIntervalRequested() {
+    Subchannel created = createSubchannel(childHelper, 0, Attributes.EMPTY);
+    OrcaOobUtil.setListener(created, mockOrcaListener0, LONG_INTERVAL_CONFIG);
+    OrcaOobUtil.setListener(created, mockOrcaListener1, SHORT_INTERVAL_CONFIG);
+    deliverSubchannelState(0, ConnectivityStateInfo.forNonError(READY));
+    verify(mockStateListeners[0]).onSubchannelState(eq(ConnectivityStateInfo.forNonError(READY)));
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    assertLog(subchannels[0].logs,
+        "DEBUG: Starting ORCA reporting for " + subchannels[0].getAllAddresses());
+
+    // The real report interval to be requested is the minimum of intervals requested by helpers.
+    assertThat(Durations.toNanos(orcaServiceImps[0].calls.peek().request.getReportInterval()))
+        .isEqualTo(SHORT_INTERVAL_CONFIG.getReportIntervalNanos());
+
+    // Parent helper wants reporting to be more frequent than its current setting while it is still
+    // less frequent than parent helper. Nothing should happen on existing RPC.
+    OrcaOobUtil.setListener(savedParentSubchannel, mockOrcaListener0, MEDIUM_INTERVAL_CONFIG);
+    assertThat(orcaServiceImps[0].calls.peek().cancelled).isFalse();
+    assertThat(subchannels[0].logs).isEmpty();
+
+    // Parent helper wants reporting to be less frequent.
+    OrcaOobUtil.setListener(created, mockOrcaListener1, MEDIUM_INTERVAL_CONFIG);
+    assertThat(orcaServiceImps[0].calls.poll().cancelled).isTrue();
+    assertThat(orcaServiceImps[0].calls).hasSize(1);
+    assertLog(subchannels[0].logs,
+        "DEBUG: Starting ORCA reporting for " + subchannels[0].getAllAddresses());
+    // ORCA reporting RPC restarts and the the real report interval is adjusted.
+    assertThat(Durations.toNanos(orcaServiceImps[0].calls.poll().request.getReportInterval()))
+        .isEqualTo(MEDIUM_INTERVAL_CONFIG.getReportIntervalNanos());
+  }
+
+  private void verifyRetryAfterNanos(InOrder inOrder, OpenRcaServiceImp orcaServiceImp,
+      long nanos) {
+    assertThat(fakeClock.getPendingTasks()).hasSize(1);
+    assertThat(orcaServiceImp.calls).isEmpty();
+    fakeClock.forwardNanos(nanos - 1);
+    assertThat(orcaServiceImp.calls).isEmpty();
+    inOrder.verifyNoMoreInteractions();
+    fakeClock.forwardNanos(1);
+    assertThat(orcaServiceImp.calls).hasSize(1);
+    assertThat(fakeClock.getPendingTasks()).isEmpty();
+  }
+
+  private void deliverSubchannelState(final int index, final ConnectivityStateInfo newState) {
+    syncContext.execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            subchannels[index].stateListener.onSubchannelState(newState);
+          }
+        });
+  }
+
+  private Subchannel createSubchannel(final Helper helper, final int index,
+      final Attributes attrs) {
+    final AtomicReference<Subchannel> newSubchannel = new AtomicReference<>();
+    syncContext.execute(
+        new Runnable() {
+          @Override
+          public void run() {
+            Subchannel s =
+                helper.createSubchannel(
+                    CreateSubchannelArgs.newBuilder()
+                        .setAddresses(eagLists[index])
+                        .setAttributes(attrs)
+                        .build());
+            s.start(mockStateListeners[index]);
+            newSubchannel.set(s);
+          }
+        });
+    return newSubchannel.get();
+  }
+
+  private void setOrcaReportConfig(
+      final Subchannel subchannel,
+      final OrcaOobReportListener listener,
+      final OrcaReportingConfig config) {
+    OrcaOobUtil.setListener(subchannel, listener, config);
+  }
+
+  private static final class OpenRcaServiceImp extends OpenRcaServiceGrpc.OpenRcaServiceImplBase {
+    final Queue<ServerSideCall> calls = new ArrayDeque<>();
+
+    @Override
+    public void streamCoreMetrics(
+        OrcaLoadReportRequest request, StreamObserver<OrcaLoadReport> responseObserver) {
+      final ServerSideCall call = new ServerSideCall(request, responseObserver);
+      Context.current()
+          .addListener(
+              new CancellationListener() {
+                @Override
+                public void cancelled(Context ctx) {
+                  call.cancelled = true;
+                }
+              },
+              MoreExecutors.directExecutor());
+      calls.add(call);
+    }
+  }
+
+  private static final class ServerSideCall {
+    final OrcaLoadReportRequest request;
+    final StreamObserver<OrcaLoadReport> responseObserver;
+    boolean cancelled;
+
+    ServerSideCall(OrcaLoadReportRequest request, StreamObserver<OrcaLoadReport> responseObserver) {
+      this.request = request;
+      this.responseObserver = responseObserver;
+    }
+  }
+
+  private static final class FakeSocketAddress extends SocketAddress {
+    final String name;
+
+    FakeSocketAddress(String name) {
+      this.name = name;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
+
+  private final class FakeSubchannel extends Subchannel {
+    final List<EquivalentAddressGroup> eagList;
+    final Attributes attrs;
+    final Channel channel;
+    final List<String> logs = new ArrayList<>();
+    final int index;
+    SubchannelStateListener stateListener;
+    private final ChannelLogger logger =
+        new ChannelLogger() {
+          @Override
+          public void log(ChannelLogLevel level, String msg) {
+            logs.add(level + ": " + msg);
+          }
+
+          @Override
+          public void log(ChannelLogLevel level, String template, Object... args) {
+            log(level, MessageFormat.format(template, args));
+          }
+        };
+
+    FakeSubchannel(int index, CreateSubchannelArgs args, Channel channel) {
+      this.index = index;
+      this.eagList = args.getAddresses();
+      this.attrs = args.getAttributes();
+      this.channel = checkNotNull(channel);
+    }
+
+    @Override
+    public void start(SubchannelStateListener listener) {
+      checkState(this.stateListener == null);
+      this.stateListener = listener;
+    }
+
+    @Override
+    public void shutdown() {
+      deliverSubchannelState(index, ConnectivityStateInfo.forNonError(SHUTDOWN));
+    }
+
+    @Override
+    public void requestConnection() {
+      throw new AssertionError("Should not be called");
+    }
+
+    @Override
+    public List<EquivalentAddressGroup> getAllAddresses() {
+      return eagList;
+    }
+
+    @Override
+    public Attributes getAttributes() {
+      return attrs;
+    }
+
+    @Override
+    public Channel asChannel() {
+      return channel;
+    }
+
+    @Override
+    public ChannelLogger getChannelLogger() {
+      return logger;
+    }
+  }
+
+  private final class FakeHelper extends Helper {
+    @Override
+    public Subchannel createSubchannel(CreateSubchannelArgs args) {
+      int index = -1;
+      for (int i = 0; i < NUM_SUBCHANNELS; i++) {
+        if (eagLists[i].equals(args.getAddresses())) {
+          index = i;
+          break;
+        }
+      }
+      checkState(index >= 0, "addrs " + args.getAddresses() + " not found");
+      FakeSubchannel subchannel = new FakeSubchannel(index, args, channels[index]);
+      checkState(subchannels[index] == null, "subchannels[" + index + "] already created");
+      subchannels[index] = subchannel;
+      return subchannel;
+    }
+
+    @Override
+    public void updateBalancingState(ConnectivityState newState, SubchannelPicker newPicker) {
+      throw new AssertionError("Should not be called");
+    }
+
+    @Override
+    public SynchronizationContext getSynchronizationContext() {
+      return syncContext;
+    }
+
+    @Override
+    public ScheduledExecutorService getScheduledExecutorService() {
+      return fakeClock.getScheduledExecutorService();
+    }
+
+    @Override
+    public String getAuthority() {
+      throw new AssertionError("Should not be called");
+    }
+
+    @Override
+    public ManagedChannel createOobChannel(EquivalentAddressGroup eag, String authority) {
+      throw new AssertionError("Should not be called");
+    }
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/orca/OrcaPerRequestUtilTest.java b/xds/src/test/java/io/grpc/xds/orca/OrcaPerRequestUtilTest.java
new file mode 100644
index 00000000000..4d080502915
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/orca/OrcaPerRequestUtilTest.java
@@ -0,0 +1,200 @@
+/*
+ * Copyright 2019 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.xds.orca;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.AdditionalAnswers.delegatesTo;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.github.xds.data.orca.v3.OrcaLoadReport;
+import com.google.common.base.Objects;
+import io.grpc.ClientStreamTracer;
+import io.grpc.Metadata;
+import io.grpc.services.MetricReport;
+import io.grpc.xds.orca.OrcaPerRequestUtil.OrcaPerRequestReportListener;
+import io.grpc.xds.orca.OrcaPerRequestUtil.OrcaReportingTracerFactory;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+/**
+ * Unit tests for {@link OrcaPerRequestUtil} class.
+ */
+@RunWith(JUnit4.class)
+public class OrcaPerRequestUtilTest {
+  @Rule public final MockitoRule mocks = MockitoJUnit.rule();
+
+  private static final ClientStreamTracer.StreamInfo STREAM_INFO =
+      ClientStreamTracer.StreamInfo.newBuilder().build();
+
+  @Mock
+  private OrcaPerRequestReportListener orcaListener1;
+  @Mock
+  private OrcaPerRequestReportListener orcaListener2;
+
+  /**
+   * Tests a single load balance policy's listener receive per-request ORCA reports upon call
+   * trailer arrives.
+   */
+  @Test
+  public void singlePolicyTypicalWorkflow() {
+    // Use a mocked noop stream tracer factory as the original stream tracer factory.
+    ClientStreamTracer.Factory fakeDelegateFactory = mock(ClientStreamTracer.Factory.class);
+    ClientStreamTracer fakeTracer = mock(ClientStreamTracer.class);
+    doNothing().when(fakeTracer).inboundTrailers(any(Metadata.class));
+    when(fakeDelegateFactory.newClientStreamTracer(
+            any(ClientStreamTracer.StreamInfo.class), any(Metadata.class)))
+        .thenReturn(fakeTracer);
+
+    // The OrcaReportingTracerFactory will augment the StreamInfo passed to its
+    // newClientStreamTracer method. The augmented StreamInfo's CallOptions will contain
+    // a OrcaReportBroker, in which has the registered listener.
+    ClientStreamTracer.Factory factory =
+        OrcaPerRequestUtil.getInstance()
+            .newOrcaClientStreamTracerFactory(fakeDelegateFactory, orcaListener1);
+    ClientStreamTracer tracer = factory.newClientStreamTracer(STREAM_INFO, new Metadata());
+    ArgumentCaptor<ClientStreamTracer.StreamInfo> streamInfoCaptor =
+        ArgumentCaptor.forClass(ClientStreamTracer.StreamInfo.class);
+    verify(fakeDelegateFactory)
+        .newClientStreamTracer(streamInfoCaptor.capture(), any(Metadata.class));
+    ClientStreamTracer.StreamInfo capturedInfo = streamInfoCaptor.getValue();
+    assertThat(capturedInfo).isNotEqualTo(STREAM_INFO);
+
+    // When the trailer does not contain ORCA report, listener callback will not be invoked.
+    Metadata trailer = new Metadata();
+    tracer.inboundTrailers(trailer);
+    verifyNoMoreInteractions(orcaListener1);
+
+    // When the trailer contains an ORCA report, listener callback will be invoked.
+    trailer.put(
+        OrcaReportingTracerFactory.ORCA_ENDPOINT_LOAD_METRICS_KEY,
+        OrcaLoadReport.getDefaultInstance());
+    tracer.inboundTrailers(trailer);
+    ArgumentCaptor<MetricReport> reportCaptor = ArgumentCaptor.forClass(MetricReport.class);
+    verify(orcaListener1).onLoadReport(reportCaptor.capture());
+    assertThat(reportEqual(reportCaptor.getValue(),
+        OrcaPerRequestUtil.fromOrcaLoadReport(OrcaLoadReport.getDefaultInstance()))).isTrue();
+  }
+
+  static final class MetricsReportMatcher implements ArgumentMatcher<MetricReport> {
+    private MetricReport original;
+
+    public MetricsReportMatcher(MetricReport report) {
+      this.original = report;
+    }
+
+    @Override
+    public boolean matches(MetricReport argument) {
+      return reportEqual(original, argument);
+    }
+  }
+
+  static boolean reportEqual(MetricReport a,
+                             MetricReport b) {
+    return a.getCpuUtilization() == b.getCpuUtilization()
+        && a.getApplicationUtilization() == b.getApplicationUtilization()
+        && a.getMemoryUtilization() == b.getMemoryUtilization()
+        && a.getQps() == b.getQps()
+        && a.getEps() == b.getEps()
+        && Objects.equal(a.getRequestCostMetrics(), b.getRequestCostMetrics())
+        && Objects.equal(a.getUtilizationMetrics(), b.getUtilizationMetrics())
+        && Objects.equal(a.getNamedMetrics(), b.getNamedMetrics());
+  }
+
+  /**
+   * Tests parent-child load balance policies' listeners both receive per-request ORCA reports upon
+   * call trailer arrives and ORCA report deserialization happens only once.
+   */
+  @Test
+  public void twoLevelPoliciesTypicalWorkflow() {
+    ClientStreamTracer.Factory parentFactory =
+        mock(ClientStreamTracer.Factory.class,
+            delegatesTo(
+                OrcaPerRequestUtil.getInstance().newOrcaClientStreamTracerFactory(orcaListener1)));
+
+    ClientStreamTracer.Factory childFactory =
+        OrcaPerRequestUtil.getInstance()
+            .newOrcaClientStreamTracerFactory(parentFactory, orcaListener2);
+    // Child factory will augment the StreamInfo and pass it to the parent factory.
+    ClientStreamTracer childTracer =
+        childFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+    ArgumentCaptor<ClientStreamTracer.StreamInfo> streamInfoCaptor =
+        ArgumentCaptor.forClass(ClientStreamTracer.StreamInfo.class);
+    verify(parentFactory).newClientStreamTracer(streamInfoCaptor.capture(), any(Metadata.class));
+    ClientStreamTracer.StreamInfo parentStreamInfo = streamInfoCaptor.getValue();
+    assertThat(parentStreamInfo).isNotEqualTo(STREAM_INFO);
+
+    // When the trailer does not contain ORCA report, no listener callback will be invoked.
+    Metadata trailer = new Metadata();
+    childTracer.inboundTrailers(trailer);
+    verifyNoMoreInteractions(orcaListener1);
+    verifyNoMoreInteractions(orcaListener2);
+
+    // When the trailer contains an ORCA report, callbacks for both listeners will be invoked.
+    // Both listener will receive the same ORCA report instance, which means deserialization
+    // happens only once.
+    trailer.put(
+        OrcaReportingTracerFactory.ORCA_ENDPOINT_LOAD_METRICS_KEY,
+        OrcaLoadReport.getDefaultInstance());
+    childTracer.inboundTrailers(trailer);
+    ArgumentCaptor<MetricReport> parentReportCap = ArgumentCaptor.forClass(MetricReport.class);
+    ArgumentCaptor<MetricReport> childReportCap = ArgumentCaptor.forClass(MetricReport.class);
+    verify(orcaListener1).onLoadReport(parentReportCap.capture());
+    verify(orcaListener2).onLoadReport(childReportCap.capture());
+    assertThat(reportEqual(parentReportCap.getValue(),
+        OrcaPerRequestUtil.fromOrcaLoadReport(OrcaLoadReport.getDefaultInstance()))).isTrue();
+    assertThat(childReportCap.getValue()).isSameInstanceAs(parentReportCap.getValue());
+  }
+
+  /**
+   * Tests the case when parent policy creates its own {@link ClientStreamTracer.Factory}, ORCA
+   * reports are only forwarded to the parent's listener.
+   */
+  @Test
+  public void onlyParentPolicyReceivesReportsIfCreatesOwnTracer() {
+    ClientStreamTracer.Factory parentFactory =
+        OrcaPerRequestUtil.getInstance().newOrcaClientStreamTracerFactory(orcaListener1);
+    ClientStreamTracer.Factory childFactory =
+        mock(ClientStreamTracer.Factory.class,
+            delegatesTo(OrcaPerRequestUtil.getInstance()
+                .newOrcaClientStreamTracerFactory(parentFactory, orcaListener2)));
+    ClientStreamTracer parentTracer =
+        parentFactory.newClientStreamTracer(STREAM_INFO, new Metadata());
+    Metadata trailer = new Metadata();
+    OrcaLoadReport report = OrcaLoadReport.getDefaultInstance();
+    trailer.put(
+        OrcaReportingTracerFactory.ORCA_ENDPOINT_LOAD_METRICS_KEY, report);
+    parentTracer.inboundTrailers(trailer);
+    verify(orcaListener1).onLoadReport(
+        argThat(new MetricsReportMatcher(OrcaPerRequestUtil.fromOrcaLoadReport(report))));
+    verifyNoInteractions(childFactory);
+    verifyNoInteractions(orcaListener2);
+  }
+}
diff --git a/xds/src/test/java/io/grpc/xds/orca/OrcaServiceImplTest.java b/xds/src/test/java/io/grpc/xds/orca/OrcaServiceImplTest.java
new file mode 100644
index 00000000000..be3cec548a7
--- /dev/null
+++ b/xds/src/test/java/io/grpc/xds/orca/OrcaServiceImplTest.java
@@ -0,0 +1,330 @@
+/*
+ * Copyright 2022 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.xds.orca;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+
+import com.github.xds.data.orca.v3.OrcaLoadReport;
+import com.github.xds.service.orca.v3.OpenRcaServiceGrpc;
+import com.github.xds.service.orca.v3.OrcaLoadReportRequest;
+import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Duration;
+import io.grpc.BindableService;
+import io.grpc.CallOptions;
+import io.grpc.ClientCall;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.Server;
+import io.grpc.Status;
+import io.grpc.inprocess.InProcessChannelBuilder;
+import io.grpc.inprocess.InProcessServerBuilder;
+import io.grpc.internal.FakeClock;
+import io.grpc.services.MetricRecorder;
+import io.grpc.testing.GrpcCleanupRule;
+import java.util.Iterator;
+import java.util.Random;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(JUnit4.class)
+public class OrcaServiceImplTest {
+  @Rule
+  public final GrpcCleanupRule grpcCleanup = new GrpcCleanupRule();
+  @Rule
+  public final MockitoRule mocks = MockitoJUnit.rule();
+  private ManagedChannel channel;
+  private Server oobServer;
+  private final FakeClock fakeClock = new FakeClock();
+  private MetricRecorder defaultTestService;
+  private BindableService orcaServiceImpl;
+  private final Random random = new Random();
+  @Mock
+  ClientCall.Listener<OrcaLoadReport> listener;
+
+  @Before
+  public void setup() throws Exception {
+    defaultTestService = MetricRecorder.newInstance();
+    orcaServiceImpl = OrcaServiceImpl.createService(fakeClock.getScheduledExecutorService(),
+        defaultTestService, 1, TimeUnit.SECONDS);
+    startServerAndGetChannel(orcaServiceImpl);
+  }
+
+  @After
+  public void teardown() throws Exception {
+    channel.shutdownNow();
+  }
+
+  private void startServerAndGetChannel(BindableService orcaService) throws Exception {
+    oobServer = grpcCleanup.register(
+        InProcessServerBuilder.forName("orca-service-test")
+            .addService(orcaService)
+            .directExecutor()
+            .build()
+            .start());
+    channel = grpcCleanup.register(
+        InProcessChannelBuilder.forName("orca-service-test")
+            .directExecutor().build());
+  }
+
+  @Test
+  public void testReportingLifeCycle() {
+    defaultTestService.setCpuUtilizationMetric(0.1);
+    Iterator<OrcaLoadReport> reports = OpenRcaServiceGrpc.newBlockingStub(channel)
+        .streamCoreMetrics(OrcaLoadReportRequest.newBuilder().build());
+    assertThat(reports.next()).isEqualTo(
+        OrcaLoadReport.newBuilder().setCpuUtilization(0.1).build());
+    assertThat(((OrcaServiceImpl)orcaServiceImpl).clientCount.get()).isEqualTo(1);
+    assertThat(fakeClock.getPendingTasks().size()).isEqualTo(1);
+    assertThat(fakeClock.forwardTime(1, TimeUnit.SECONDS)).isEqualTo(1);
+    assertThat(reports.next()).isEqualTo(
+        OrcaLoadReport.newBuilder().setCpuUtilization(0.1).build());
+    assertThat(fakeClock.getPendingTasks().size()).isEqualTo(1);
+    channel.shutdownNow();
+    assertThat(((OrcaServiceImpl)orcaServiceImpl).clientCount.get()).isEqualTo(0);
+    assertThat(fakeClock.getPendingTasks().size()).isEqualTo(0);
+  }
+
+  @Test
+  public void testReportingLifeCycle_serverShutdown() {
+    ClientCall<OrcaLoadReportRequest, OrcaLoadReport> call = channel.newCall(
+        OpenRcaServiceGrpc.getStreamCoreMetricsMethod(), CallOptions.DEFAULT);
+    defaultTestService.putUtilizationMetric("buffer", 0.2);
+    call.start(listener, new Metadata());
+    call.sendMessage(OrcaLoadReportRequest.newBuilder()
+        .setReportInterval(Duration.newBuilder().setSeconds(0).setNanos(500).build()).build());
+    call.halfClose();
+    call.request(1);
+    OrcaLoadReport expect = OrcaLoadReport.newBuilder().putUtilization("buffer", 0.2).build();
+    assertThat(((OrcaServiceImpl)orcaServiceImpl).clientCount.get()).isEqualTo(1);
+    verify(listener).onMessage(eq(expect));
+    verify(listener, never()).onClose(any(), any());
+    oobServer.shutdownNow();
+    assertThat(fakeClock.forwardTime(1, TimeUnit.SECONDS)).isEqualTo(0);
+    assertThat(((OrcaServiceImpl)orcaServiceImpl).clientCount.get()).isEqualTo(0);
+    ArgumentCaptor<Status> callCloseCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(listener).onClose(callCloseCaptor.capture(), any());
+    assertThat(callCloseCaptor.getValue().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void testRequestIntervalLess() {
+    ClientCall<OrcaLoadReportRequest, OrcaLoadReport> call = channel.newCall(
+        OpenRcaServiceGrpc.getStreamCoreMetricsMethod(), CallOptions.DEFAULT);
+    defaultTestService.putUtilizationMetric("buffer", 0.2);
+    defaultTestService.setApplicationUtilizationMetric(0.314159);
+    defaultTestService.setQpsMetric(1.9);
+    defaultTestService.setEpsMetric(0.2233);
+    call.start(listener, new Metadata());
+    call.sendMessage(OrcaLoadReportRequest.newBuilder()
+        .setReportInterval(Duration.newBuilder().setSeconds(0).setNanos(500).build()).build());
+    call.halfClose();
+    call.request(1);
+    OrcaLoadReport expect = OrcaLoadReport.newBuilder().putUtilization("buffer", 0.2)
+        .setApplicationUtilization(0.314159).setRpsFractional(1.9).setEps(0.2233).build();
+    verify(listener).onMessage(eq(expect));
+    reset(listener);
+    defaultTestService.removeUtilizationMetric("buffer0");
+    defaultTestService.clearApplicationUtilizationMetric();
+    defaultTestService.clearQpsMetric();
+    defaultTestService.clearEpsMetric();
+    assertThat(fakeClock.forwardTime(500, TimeUnit.NANOSECONDS)).isEqualTo(0);
+    verifyNoInteractions(listener);
+    assertThat(fakeClock.forwardTime(1, TimeUnit.SECONDS)).isEqualTo(1);
+    call.request(1);
+    expect = OrcaLoadReport.newBuilder().putUtilization("buffer", 0.2).build();
+    verify(listener).onMessage(eq(expect));
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void testRequestIntervalGreater() {
+    ClientCall<OrcaLoadReportRequest, OrcaLoadReport> call = channel.newCall(
+        OpenRcaServiceGrpc.getStreamCoreMetricsMethod(), CallOptions.DEFAULT);
+    defaultTestService.putUtilizationMetric("buffer", 0.2);
+    call.start(listener, new Metadata());
+    call.sendMessage(OrcaLoadReportRequest.newBuilder()
+        .setReportInterval(Duration.newBuilder().setSeconds(10).build()).build());
+    call.halfClose();
+    call.request(1);
+    OrcaLoadReport expect = OrcaLoadReport.newBuilder().putUtilization("buffer", 0.2).build();
+    verify(listener).onMessage(eq(expect));
+    reset(listener);
+    defaultTestService.removeUtilizationMetric("buffer0");
+    assertThat(fakeClock.forwardTime(1, TimeUnit.SECONDS)).isEqualTo(0);
+    verifyNoInteractions(listener);
+    assertThat(fakeClock.forwardTime(9, TimeUnit.SECONDS)).isEqualTo(1);
+    call.request(1);
+    verify(listener).onMessage(eq(expect));
+  }
+
+  @Test
+  @SuppressWarnings("unchecked")
+  public void testRequestIntervalDefault() throws Exception {
+    defaultTestService = MetricRecorder.newInstance();
+    oobServer.shutdownNow();
+    startServerAndGetChannel(OrcaServiceImpl.createService(
+        fakeClock.getScheduledExecutorService(), defaultTestService));
+    ClientCall<OrcaLoadReportRequest, OrcaLoadReport> call = channel.newCall(
+        OpenRcaServiceGrpc.getStreamCoreMetricsMethod(), CallOptions.DEFAULT);
+    defaultTestService.putUtilizationMetric("buffer", 0.2);
+    call.start(listener, new Metadata());
+    call.sendMessage(OrcaLoadReportRequest.newBuilder()
+        .setReportInterval(Duration.newBuilder().setSeconds(10).build()).build());
+    call.halfClose();
+    call.request(1);
+    OrcaLoadReport expect = OrcaLoadReport.newBuilder().putUtilization("buffer", 0.2).build();
+    verify(listener).onMessage(eq(expect));
+    reset(listener);
+    defaultTestService.removeUtilizationMetric("buffer0");
+    assertThat(fakeClock.forwardTime(10, TimeUnit.SECONDS)).isEqualTo(0);
+    verifyNoInteractions(listener);
+    assertThat(fakeClock.forwardTime(20, TimeUnit.SECONDS)).isEqualTo(1);
+    call.request(1);
+    verify(listener).onMessage(eq(expect));
+  }
+
+  @Test
+  public void testMultipleClients() {
+    ClientCall<OrcaLoadReportRequest, OrcaLoadReport> call = channel.newCall(
+        OpenRcaServiceGrpc.getStreamCoreMetricsMethod(), CallOptions.DEFAULT);
+    defaultTestService.putUtilizationMetric("omg", 1.00);
+    call.start(listener, new Metadata());
+    call.sendMessage(OrcaLoadReportRequest.newBuilder().build());
+    call.halfClose();
+    call.request(1);
+    OrcaLoadReport expect = OrcaLoadReport.newBuilder().putUtilization("omg", 1.00).build();
+    verify(listener).onMessage(eq(expect));
+    defaultTestService.setMemoryUtilizationMetric(0.5);
+    ClientCall<OrcaLoadReportRequest, OrcaLoadReport> call2 = channel.newCall(
+        OpenRcaServiceGrpc.getStreamCoreMetricsMethod(), CallOptions.DEFAULT);
+    call2.start(listener, new Metadata());
+    call2.sendMessage(OrcaLoadReportRequest.newBuilder().build());
+    call2.halfClose();
+    call2.request(1);
+    expect = OrcaLoadReport.newBuilder(expect).setMemUtilization(0.5).build();
+    verify(listener).onMessage(eq(expect));
+    assertThat(((OrcaServiceImpl)orcaServiceImpl).clientCount.get()).isEqualTo(2);
+    assertThat(fakeClock.getPendingTasks().size()).isEqualTo(2);
+    channel.shutdownNow();
+    assertThat(fakeClock.forwardTime(1, TimeUnit.SECONDS)).isEqualTo(0);
+    assertThat(((OrcaServiceImpl)orcaServiceImpl).clientCount.get()).isEqualTo(0);
+    ArgumentCaptor<Status> callCloseCaptor = ArgumentCaptor.forClass(Status.class);
+    verify(listener, times(2)).onClose(callCloseCaptor.capture(), any());
+    assertThat(callCloseCaptor.getValue().getCode()).isEqualTo(Status.Code.UNAVAILABLE);
+  }
+
+  @Test
+  public void testApis() throws Exception {
+    ImmutableMap<String, Double> firstUtilization = ImmutableMap.of("util", 0.1);
+    OrcaLoadReport goldenReport = OrcaLoadReport.newBuilder()
+        .setCpuUtilization(random.nextDouble() * 10)
+        .setApplicationUtilization(random.nextDouble() * 10)
+        .setMemUtilization(random.nextDouble())
+        .putAllUtilization(firstUtilization)
+        .putUtilization("queue", 1.0)
+        .setRpsFractional(1239.01)
+        .setEps(1.618)
+        .build();
+    defaultTestService.setCpuUtilizationMetric(goldenReport.getCpuUtilization());
+    defaultTestService.setApplicationUtilizationMetric(goldenReport.getApplicationUtilization());
+    defaultTestService.setMemoryUtilizationMetric(goldenReport.getMemUtilization());
+    defaultTestService.setAllUtilizationMetrics(firstUtilization);
+    defaultTestService.putUtilizationMetric("queue", 1.0);
+    defaultTestService.setQpsMetric(1239.01);
+    defaultTestService.setEpsMetric(1.618);
+    Iterator<OrcaLoadReport> reports = OpenRcaServiceGrpc.newBlockingStub(channel)
+        .streamCoreMetrics(OrcaLoadReportRequest.newBuilder().build());
+    assertThat(reports.next()).isEqualTo(goldenReport);
+
+    defaultTestService.clearCpuUtilizationMetric();
+    defaultTestService.clearApplicationUtilizationMetric();
+    defaultTestService.clearMemoryUtilizationMetric();
+    defaultTestService.clearQpsMetric();
+    defaultTestService.clearEpsMetric();
+    fakeClock.forwardTime(1, TimeUnit.SECONDS);
+    goldenReport = OrcaLoadReport.newBuilder()
+        .putAllUtilization(firstUtilization)
+        .putUtilization("queue", 1.0)
+        .putUtilization("util", 0.1)
+        .build();
+    assertThat(reports.next()).isEqualTo(goldenReport);
+    defaultTestService.removeUtilizationMetric("util-not-exist");
+    defaultTestService.removeUtilizationMetric("queue-not-exist");
+    fakeClock.forwardTime(1, TimeUnit.SECONDS);
+    assertThat(reports.next()).isEqualTo(goldenReport);
+
+    defaultTestService.setCpuUtilizationMetric(-0.001);
+    defaultTestService.setApplicationUtilizationMetric(-0.001);
+    defaultTestService.setMemoryUtilizationMetric(-0.001);
+    defaultTestService.setMemoryUtilizationMetric(1.001);
+    defaultTestService.setQpsMetric(-0.001);
+    defaultTestService.setEpsMetric(-0.001);
+    defaultTestService.putUtilizationMetric("util-out-of-range", -0.001);
+    defaultTestService.putUtilizationMetric("util-out-of-range", 1.001);
+    fakeClock.forwardTime(1, TimeUnit.SECONDS);
+    assertThat(reports.next()).isEqualTo(goldenReport);
+
+    CyclicBarrier barrier = new CyclicBarrier(2);
+    new Thread(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          barrier.await();
+        } catch (Exception ex) {
+          throw new AssertionError(ex);
+        }
+        defaultTestService.removeUtilizationMetric("util");
+        defaultTestService.setMemoryUtilizationMetric(0.4);
+        defaultTestService.setAllUtilizationMetrics(firstUtilization);
+        try {
+          barrier.await();
+        } catch (Exception ex) {
+          throw new AssertionError(ex);
+        }
+      }
+    }).start();
+    barrier.await();
+    defaultTestService.setMemoryUtilizationMetric(0.4);
+    defaultTestService.removeUtilizationMetric("util");
+    defaultTestService.setAllUtilizationMetrics(firstUtilization);
+    barrier.await();
+    goldenReport = OrcaLoadReport.newBuilder()
+        .putAllUtilization(firstUtilization)
+        .setMemUtilization(0.4)
+        .build();
+    fakeClock.forwardTime(1, TimeUnit.SECONDS);
+    assertThat(reports.next()).isEqualTo(goldenReport);
+  }
+}
diff --git a/xds/src/test/resources/certs/sni-test-certs/README b/xds/src/test/resources/certs/sni-test-certs/README
new file mode 100644
index 00000000000..25e66021192
--- /dev/null
+++ b/xds/src/test/resources/certs/sni-test-certs/README
@@ -0,0 +1,55 @@
+Bad Wildcard DNS Certificate (bad_wildcard_dns_certificate.pem)
+This certificate is used for testing SNI with invalid wildcard DNS SANs. It is issued by a custom, self-signed Certificate Authority (CA).
+
+1. Create the Certificate Authority (CA)
+Create the CA's private key:
+$ openssl genpkey -algorithm RSA -out ca.key -pkeyopt rsa_keygen_bits:2048
+Create the CA's self-signed certificate:
+$ openssl req -x509 -new -nodes -key ca.key -sha256 -days 365 -out ca.pem -subj "/CN=My Internal CA"
+
+2. Generate the Server Certificate
+Next, generate the server's private key and a Certificate Signing Request (CSR).
+Create the server's private key:
+$ openssl genpkey -algorithm RSA -out bad_wildcard_dns.key -pkeyopt rsa_keygen_bits:2048
+Create a configuration file named san.cnf with the following content. This file specifies the Subject Alternative Names (SANs) for the certificate.
+[req]
+distinguished_name = req_distinguished_name
+req_extensions = v3_req
+prompt = no
+
+[req_distinguished_name]
+C = US
+ST = Illinois
+L = Chicago
+O = "Example, Co."
+CN = *.test.google.com
+
+[v3_req]
+keyUsage = nonRepudiation, digitalSignature, keyEncipherment
+extendedKeyUsage = serverAuth
+subjectAltName = @alt_names
+
+[alt_names]
+DNS.1 = *.test.google.fr
+DNS.2 = *.test.youtube.com
+DNS.3 = waterzooi.test.google.be
+DNS.4 = 192.168.1.3
+DNS.5 = *.TEST.YOUTUBE.com
+DNS.6 = w*i.test.google.be
+DNS.7 = w*a.test.google.be
+DNS.8 = *.test.google.com.au
+DNS.9 = *waterzooi
+DNS.10 = *.lyft.com
+DNS.11 = ly**ft.com
+DNS.12 = *yft.c*m
+DNS.13 = xn--*.lyft.com
+
+Create the Certificate Signing Request (CSR):
+$ openssl req -new -key bad_wildcard_dns.key -out bad_wildcard_dns.csr -config san.cnf
+
+3. Sign the Server Certificate
+Finally, use the CA to sign the CSR, which will create the server certificate.
+$ openssl x509 -req -in bad_wildcard_dns.csr -CA ca.pem -CAkey ca.key -CAcreateserial -out bad_wildcard_dns_certificate.pem -days 365 -sha256 -extensions v3_req -extfile san.cnf
+
+4. Clean Up
+$ rm bad_wildcard_dns.key san.cnf bad_wildcard_dns.csr ca.key ca.pem ca.srl
diff --git a/xds/src/test/resources/certs/sni-test-certs/bad_wildcard_dns_certificate.pem b/xds/src/test/resources/certs/sni-test-certs/bad_wildcard_dns_certificate.pem
new file mode 100644
index 00000000000..b015f62e51c
--- /dev/null
+++ b/xds/src/test/resources/certs/sni-test-certs/bad_wildcard_dns_certificate.pem
@@ -0,0 +1,22 @@
+-----BEGIN CERTIFICATE-----
+MIIDsjCCApqgAwIBAgIUCs5j4C2KXgCRVFa48kc5TYRS1JwwDQYJKoZIhvcNAQEL
+BQAwGTEXMBUGA1UEAwwOTXkgSW50ZXJuYWwgQ0EwIBcNMjUwOTIzMDc1NDUzWhgP
+MjEyNTA4MzAwNzU0NTNaMGUxCzAJBgNVBAYTAlVTMREwDwYDVQQIDAhJbGxpbm9p
+czEQMA4GA1UEBwwHQ2hpY2FnbzEVMBMGA1UECgwMRXhhbXBsZSwgQ28uMRowGAYD
+VQQDDBEqLnRlc3QuZ29vZ2xlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCC
+AQoCggEBAKoqcnNh9MV39GH6JjC5KVMN6MO1IoTw6wHJN0JJ/nGNx6ycIsBK8SgJ
+eYRR2BEpT6WZba+f04KChcB4Z9tiPISNvUBpmEv76rAsdtcAZwSpF06q4wxHVE5F
+rX6mNT8hk448mDBDGHUXNAT6g/e/Vlt6U0XRyuu713gbZq1X6JH29FG7EJ3LUx35
+h6sEkvTlZZ3m6NJr7zYoqrYh/gRkPigtPxaNcoXo0gVm4IEde0sYz27SWyNH4v/o
+23NynSulOwx4DwEhBOXekLb5QJHBqwMTPynaMncBQIXF+PXeuxN9a3zR6DSn+jGw
+g008tS0tn2FuAvJDBl0paEykdOr2rNMCAwEAAaOBozCBoDALBgNVHQ8EBAMCBeAw
+EwYDVR0lBAwwCgYIKwYBBQUHAwEwPAYDVR0RBDUwM4IKbHkqKmZ0LmNvbYIIKnlm
+dC5jKm2CCS5seWZ0LmNvbYIOeG4tLSoubHlmdC5jb22CADAdBgNVHQ4EFgQUZoL2
+OzBtK/BUzSYfgXDx3iDjcIQwHwYDVR0jBBgwFoAUHlstFN5WSLSqyJgUDy6BB0z0
+BrgwDQYJKoZIhvcNAQELBQADggEBAMYwVOT7XZJMQ6n32pQqtZhJ/Z0wlVfCAbm0
+7xospeBt6KtOz2zIsvPpq0aqPjowMAeL1EZaBvmfm/XgWUU5e/3hLUIHOHyKfswB
+czDbY0RE8nfVDoF4Ck1ljPjvrFr4tSAxTzVA4JU5o3UXkblBg0LG6tTuLlZ3x5aF
+KtkZnszxjE+vOg6J9MDbFP/xtA1oVHyCvk+cUgnBxAoPShI+87DINGVTmztBSetK
+nJN9dOh7Q88NhTLHOe67Ora9Y0ZP+uFKHaqFv8qj8B/Q6ptb0CAksdL5EunkIHrq
+glKdVdYgIP2JpRwtvVHK5FzWBlGXCi3DxTyYi6FWqsSJ+heCS2w=
+-----END CERTIFICATE-----
diff --git a/xds/third_party/cel-spec/LICENSE b/xds/third_party/cel-spec/LICENSE
new file mode 100644
index 00000000000..d6456956733
--- /dev/null
+++ b/xds/third_party/cel-spec/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/xds/third_party/cel-spec/import.sh b/xds/third_party/cel-spec/import.sh
new file mode 100755
index 00000000000..bba8214fdfb
--- /dev/null
+++ b/xds/third_party/cel-spec/import.sh
@@ -0,0 +1,59 @@
+#!/bin/bash
+# Copyright 2024 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.
+
+# Update VERSION then execute this script
+
+set -e
+VERSION="v0.15.0"
+DOWNLOAD_URL="https://github.com/google/cel-spec/archive/refs/tags/${VERSION}.tar.gz"
+DOWNLOAD_BASE_DIR="cel-spec-${VERSION#v}"
+SOURCE_PROTO_BASE_DIR="${DOWNLOAD_BASE_DIR}/proto"
+TARGET_PROTO_BASE_DIR="src/main/proto"
+# Sorted alphabetically.
+FILES=(
+cel/expr/checked.proto
+cel/expr/syntax.proto
+)
+
+pushd `git rev-parse --show-toplevel`/xds/third_party/cel-spec > /dev/null
+
+# put the repo in a tmp directory
+tmpdir="$(mktemp -d)"
+trap "rm -rf ${tmpdir}" EXIT
+curl -Ls "${DOWNLOAD_URL}" | tar xz -C "${tmpdir}"
+
+cp -p "${tmpdir}/${DOWNLOAD_BASE_DIR}/LICENSE" LICENSE
+
+rm -rf "${TARGET_PROTO_BASE_DIR}"
+mkdir -p "${TARGET_PROTO_BASE_DIR}"
+pushd "${TARGET_PROTO_BASE_DIR}" > /dev/null
+
+# copy proto files to project directory
+TOTAL=${#FILES[@]}
+COPIED=0
+for file in "${FILES[@]}"
+do
+  mkdir -p "$(dirname "${file}")"
+  cp -p "${tmpdir}/${SOURCE_PROTO_BASE_DIR}/${file}" "${file}" && (( ++COPIED ))
+done
+popd > /dev/null
+
+popd > /dev/null
+
+echo "Imported ${COPIED} files."
+if (( COPIED != TOTAL )); then
+  echo "Failed importing $(( TOTAL - COPIED )) files." 1>&2
+  exit 1
+fi
diff --git a/xds/third_party/cel-spec/src/main/proto/cel/expr/checked.proto b/xds/third_party/cel-spec/src/main/proto/cel/expr/checked.proto
new file mode 100644
index 00000000000..e327db9b225
--- /dev/null
+++ b/xds/third_party/cel-spec/src/main/proto/cel/expr/checked.proto
@@ -0,0 +1,344 @@
+// Copyright 2023 Google LLC
+//
+// 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.
+
+syntax = "proto3";
+
+package cel.expr;
+
+import "cel/expr/syntax.proto";
+import "google/protobuf/empty.proto";
+import "google/protobuf/struct.proto";
+
+option cc_enable_arenas = true;
+option go_package = "cel.dev/expr";
+option java_multiple_files = true;
+option java_outer_classname = "DeclProto";
+option java_package = "dev.cel.expr";
+
+// Protos for representing CEL declarations and typed checked expressions.
+
+// A CEL expression which has been successfully type checked.
+message CheckedExpr {
+  // A map from expression ids to resolved references.
+  //
+  // The following entries are in this table:
+  //
+  // - An Ident or Select expression is represented here if it resolves to a
+  //   declaration. For instance, if `a.b.c` is represented by
+  //   `select(select(id(a), b), c)`, and `a.b` resolves to a declaration,
+  //   while `c` is a field selection, then the reference is attached to the
+  //   nested select expression (but not to the id or or the outer select).
+  //   In turn, if `a` resolves to a declaration and `b.c` are field selections,
+  //   the reference is attached to the ident expression.
+  // - Every Call expression has an entry here, identifying the function being
+  //   called.
+  // - Every CreateStruct expression for a message has an entry, identifying
+  //   the message.
+  map<int64, Reference> reference_map = 2;
+
+  // A map from expression ids to types.
+  //
+  // Every expression node which has a type different than DYN has a mapping
+  // here. If an expression has type DYN, it is omitted from this map to save
+  // space.
+  map<int64, Type> type_map = 3;
+
+  // The source info derived from input that generated the parsed `expr` and
+  // any optimizations made during the type-checking pass.
+  SourceInfo source_info = 5;
+
+  // The expr version indicates the major / minor version number of the `expr`
+  // representation.
+  //
+  // The most common reason for a version change will be to indicate to the CEL
+  // runtimes that transformations have been performed on the expr during static
+  // analysis. In some cases, this will save the runtime the work of applying
+  // the same or similar transformations prior to evaluation.
+  string expr_version = 6;
+
+  // The checked expression. Semantically equivalent to the parsed `expr`, but
+  // may have structural differences.
+  Expr expr = 4;
+}
+
+// Represents a CEL type.
+message Type {
+  // List type with typed elements, e.g. `list<example.proto.MyMessage>`.
+  message ListType {
+    // The element type.
+    Type elem_type = 1;
+  }
+
+  // Map type with parameterized key and value types, e.g. `map<string, int>`.
+  message MapType {
+    // The type of the key.
+    Type key_type = 1;
+
+    // The type of the value.
+    Type value_type = 2;
+  }
+
+  // Function type with result and arg types.
+  message FunctionType {
+    // Result type of the function.
+    Type result_type = 1;
+
+    // Argument types of the function.
+    repeated Type arg_types = 2;
+  }
+
+  // Application defined abstract type.
+  message AbstractType {
+    // The fully qualified name of this abstract type.
+    string name = 1;
+
+    // Parameter types for this abstract type.
+    repeated Type parameter_types = 2;
+  }
+
+  // CEL primitive types.
+  enum PrimitiveType {
+    // Unspecified type.
+    PRIMITIVE_TYPE_UNSPECIFIED = 0;
+
+    // Boolean type.
+    BOOL = 1;
+
+    // Int64 type.
+    //
+    // 32-bit integer values are widened to int64.
+    INT64 = 2;
+
+    // Uint64 type.
+    //
+    // 32-bit unsigned integer values are widened to uint64.
+    UINT64 = 3;
+
+    // Double type.
+    //
+    // 32-bit float values are widened to double values.
+    DOUBLE = 4;
+
+    // String type.
+    STRING = 5;
+
+    // Bytes type.
+    BYTES = 6;
+  }
+
+  // Well-known protobuf types treated with first-class support in CEL.
+  enum WellKnownType {
+    // Unspecified type.
+    WELL_KNOWN_TYPE_UNSPECIFIED = 0;
+
+    // Well-known protobuf.Any type.
+    //
+    // Any types are a polymorphic message type. During type-checking they are
+    // treated like `DYN` types, but at runtime they are resolved to a specific
+    // message type specified at evaluation time.
+    ANY = 1;
+
+    // Well-known protobuf.Timestamp type, internally referenced as `timestamp`.
+    TIMESTAMP = 2;
+
+    // Well-known protobuf.Duration type, internally referenced as `duration`.
+    DURATION = 3;
+  }
+
+  // The kind of type.
+  oneof type_kind {
+    // Dynamic type.
+    google.protobuf.Empty dyn = 1;
+
+    // Null value.
+    google.protobuf.NullValue null = 2;
+
+    // Primitive types: `true`, `1u`, `-2.0`, `'string'`, `b'bytes'`.
+    PrimitiveType primitive = 3;
+
+    // Wrapper of a primitive type, e.g. `google.protobuf.Int64Value`.
+    PrimitiveType wrapper = 4;
+
+    // Well-known protobuf type such as `google.protobuf.Timestamp`.
+    WellKnownType well_known = 5;
+
+    // Parameterized list with elements of `list_type`, e.g. `list<timestamp>`.
+    ListType list_type = 6;
+
+    // Parameterized map with typed keys and values.
+    MapType map_type = 7;
+
+    // Function type.
+    FunctionType function = 8;
+
+    // Protocol buffer message type.
+    //
+    // The `message_type` string specifies the qualified message type name. For
+    // example, `google.type.PhoneNumber`.
+    string message_type = 9;
+
+    // Type param type.
+    //
+    // The `type_param` string specifies the type parameter name, e.g. `list<E>`
+    // would be a `list_type` whose element type was a `type_param` type
+    // named `E`.
+    string type_param = 10;
+
+    // Type type.
+    //
+    // The `type` value specifies the target type. e.g. int is type with a
+    // target type of `Primitive.INT64`.
+    Type type = 11;
+
+    // Error type.
+    //
+    // During type-checking if an expression is an error, its type is propagated
+    // as the `ERROR` type. This permits the type-checker to discover other
+    // errors present in the expression.
+    google.protobuf.Empty error = 12;
+
+    // Abstract, application defined type.
+    //
+    // An abstract type has no accessible field names, and it can only be
+    // inspected via helper / member functions.
+    AbstractType abstract_type = 14;
+  }
+}
+
+// Represents a declaration of a named value or function.
+//
+// A declaration is part of the contract between the expression, the agent
+// evaluating that expression, and the caller requesting evaluation.
+message Decl {
+  // Identifier declaration which specifies its type and optional `Expr` value.
+  //
+  // An identifier without a value is a declaration that must be provided at
+  // evaluation time. An identifier with a value should resolve to a constant,
+  // but may be used in conjunction with other identifiers bound at evaluation
+  // time.
+  message IdentDecl {
+    // Required. The type of the identifier.
+    Type type = 1;
+
+    // The constant value of the identifier. If not specified, the identifier
+    // must be supplied at evaluation time.
+    Constant value = 2;
+
+    // Documentation string for the identifier.
+    string doc = 3;
+  }
+
+  // Function declaration specifies one or more overloads which indicate the
+  // function's parameter types and return type.
+  //
+  // Functions have no observable side-effects (there may be side-effects like
+  // logging which are not observable from CEL).
+  message FunctionDecl {
+    // An overload indicates a function's parameter types and return type, and
+    // may optionally include a function body described in terms of
+    // [Expr][cel.expr.Expr] values.
+    //
+    // Functions overloads are declared in either a function or method
+    // call-style. For methods, the `params[0]` is the expected type of the
+    // target receiver.
+    //
+    // Overloads must have non-overlapping argument types after erasure of all
+    // parameterized type variables (similar as type erasure in Java).
+    message Overload {
+      // Required. Globally unique overload name of the function which reflects
+      // the function name and argument types.
+      //
+      // This will be used by a [Reference][cel.expr.Reference] to
+      // indicate the `overload_id` that was resolved for the function `name`.
+      string overload_id = 1;
+
+      // List of function parameter [Type][cel.expr.Type] values.
+      //
+      // Param types are disjoint after generic type parameters have been
+      // replaced with the type `DYN`. Since the `DYN` type is compatible with
+      // any other type, this means that if `A` is a type parameter, the
+      // function types `int<A>` and `int<int>` are not disjoint. Likewise,
+      // `map<string, string>` is not disjoint from `map<K, V>`.
+      //
+      // When the `result_type` of a function is a generic type param, the
+      // type param name also appears as the `type` of on at least one params.
+      repeated Type params = 2;
+
+      // The type param names associated with the function declaration.
+      //
+      // For example, `function ex<K,V>(K key, map<K, V> map) : V` would yield
+      // the type params of `K, V`.
+      repeated string type_params = 3;
+
+      // Required. The result type of the function. For example, the operator
+      // `string.isEmpty()` would have `result_type` of `kind: BOOL`.
+      Type result_type = 4;
+
+      // Whether the function is to be used in a method call-style `x.f(...)`
+      // of a function call-style `f(x, ...)`.
+      //
+      // For methods, the first parameter declaration, `params[0]` is the
+      // expected type of the target receiver.
+      bool is_instance_function = 5;
+
+      // Documentation string for the overload.
+      string doc = 6;
+    }
+
+    // Required. List of function overloads, must contain at least one overload.
+    repeated Overload overloads = 1;
+  }
+
+  // The fully qualified name of the declaration.
+  //
+  // Declarations are organized in containers and this represents the full path
+  // to the declaration in its container, as in `cel.expr.Decl`.
+  //
+  // Declarations used as
+  // [FunctionDecl.Overload][cel.expr.Decl.FunctionDecl.Overload]
+  // parameters may or may not have a name depending on whether the overload is
+  // function declaration or a function definition containing a result
+  // [Expr][cel.expr.Expr].
+  string name = 1;
+
+  // Required. The declaration kind.
+  oneof decl_kind {
+    // Identifier declaration.
+    IdentDecl ident = 2;
+
+    // Function declaration.
+    FunctionDecl function = 3;
+  }
+}
+
+// Describes a resolved reference to a declaration.
+message Reference {
+  // The fully qualified name of the declaration.
+  string name = 1;
+
+  // For references to functions, this is a list of `Overload.overload_id`
+  // values which match according to typing rules.
+  //
+  // If the list has more than one element, overload resolution among the
+  // presented candidates must happen at runtime because of dynamic types. The
+  // type checker attempts to narrow down this list as much as possible.
+  //
+  // Empty if this is not a reference to a
+  // [Decl.FunctionDecl][cel.expr.Decl.FunctionDecl].
+  repeated string overload_id = 3;
+
+  // For references to constants, this may contain the value of the
+  // constant if known at compile time.
+  Constant value = 4;
+}
diff --git a/xds/third_party/cel-spec/src/main/proto/cel/expr/syntax.proto b/xds/third_party/cel-spec/src/main/proto/cel/expr/syntax.proto
new file mode 100644
index 00000000000..ed124a74384
--- /dev/null
+++ b/xds/third_party/cel-spec/src/main/proto/cel/expr/syntax.proto
@@ -0,0 +1,393 @@
+// Copyright 2023 Google LLC
+//
+// 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.
+
+syntax = "proto3";
+
+package cel.expr;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/struct.proto";
+import "google/protobuf/timestamp.proto";
+
+option cc_enable_arenas = true;
+option go_package = "cel.dev/expr";
+option java_multiple_files = true;
+option java_outer_classname = "SyntaxProto";
+option java_package = "dev.cel.expr";
+
+// A representation of the abstract syntax of the Common Expression Language.
+
+// An expression together with source information as returned by the parser.
+message ParsedExpr {
+  // The parsed expression.
+  Expr expr = 2;
+
+  // The source info derived from input that generated the parsed `expr`.
+  SourceInfo source_info = 3;
+}
+
+// An abstract representation of a common expression.
+//
+// Expressions are abstractly represented as a collection of identifiers,
+// select statements, function calls, literals, and comprehensions. All
+// operators with the exception of the '.' operator are modelled as function
+// calls. This makes it easy to represent new operators into the existing AST.
+//
+// All references within expressions must resolve to a
+// [Decl][cel.expr.Decl] provided at type-check for an expression to be
+// valid. A reference may either be a bare identifier `name` or a qualified
+// identifier `google.api.name`. References may either refer to a value or a
+// function declaration.
+//
+// For example, the expression `google.api.name.startsWith('expr')` references
+// the declaration `google.api.name` within a
+// [Expr.Select][cel.expr.Expr.Select] expression, and the function
+// declaration `startsWith`.
+message Expr {
+  // An identifier expression. e.g. `request`.
+  message Ident {
+    // Required. Holds a single, unqualified identifier, possibly preceded by a
+    // '.'.
+    //
+    // Qualified names are represented by the
+    // [Expr.Select][cel.expr.Expr.Select] expression.
+    string name = 1;
+  }
+
+  // A field selection expression. e.g. `request.auth`.
+  message Select {
+    // Required. The target of the selection expression.
+    //
+    // For example, in the select expression `request.auth`, the `request`
+    // portion of the expression is the `operand`.
+    Expr operand = 1;
+
+    // Required. The name of the field to select.
+    //
+    // For example, in the select expression `request.auth`, the `auth` portion
+    // of the expression would be the `field`.
+    string field = 2;
+
+    // Whether the select is to be interpreted as a field presence test.
+    //
+    // This results from the macro `has(request.auth)`.
+    bool test_only = 3;
+  }
+
+  // A call expression, including calls to predefined functions and operators.
+  //
+  // For example, `value == 10`, `size(map_value)`.
+  message Call {
+    // The target of an method call-style expression. For example, `x` in
+    // `x.f()`.
+    Expr target = 1;
+
+    // Required. The name of the function or method being called.
+    string function = 2;
+
+    // The arguments.
+    repeated Expr args = 3;
+  }
+
+  // A list creation expression.
+  //
+  // Lists may either be homogenous, e.g. `[1, 2, 3]`, or heterogeneous, e.g.
+  // `dyn([1, 'hello', 2.0])`
+  message CreateList {
+    // The elements part of the list.
+    repeated Expr elements = 1;
+
+    // The indices within the elements list which are marked as optional
+    // elements.
+    //
+    // When an optional-typed value is present, the value it contains
+    // is included in the list. If the optional-typed value is absent, the list
+    // element is omitted from the CreateList result.
+    repeated int32 optional_indices = 2;
+  }
+
+  // A map or message creation expression.
+  //
+  // Maps are constructed as `{'key_name': 'value'}`. Message construction is
+  // similar, but prefixed with a type name and composed of field ids:
+  // `types.MyType{field_id: 'value'}`.
+  message CreateStruct {
+    // Represents an entry.
+    message Entry {
+      // Required. An id assigned to this node by the parser which is unique
+      // in a given expression tree. This is used to associate type
+      // information and other attributes to the node.
+      int64 id = 1;
+
+      // The `Entry` key kinds.
+      oneof key_kind {
+        // The field key for a message creator statement.
+        string field_key = 2;
+
+        // The key expression for a map creation statement.
+        Expr map_key = 3;
+      }
+
+      // Required. The value assigned to the key.
+      //
+      // If the optional_entry field is true, the expression must resolve to an
+      // optional-typed value. If the optional value is present, the key will be
+      // set; however, if the optional value is absent, the key will be unset.
+      Expr value = 4;
+
+      // Whether the key-value pair is optional.
+      bool optional_entry = 5;
+    }
+
+    // The type name of the message to be created, empty when creating map
+    // literals.
+    string message_name = 1;
+
+    // The entries in the creation expression.
+    repeated Entry entries = 2;
+  }
+
+  // A comprehension expression applied to a list or map.
+  //
+  // Comprehensions are not part of the core syntax, but enabled with macros.
+  // A macro matches a specific call signature within a parsed AST and replaces
+  // the call with an alternate AST block. Macro expansion happens at parse
+  // time.
+  //
+  // The following macros are supported within CEL:
+  //
+  // Aggregate type macros may be applied to all elements in a list or all keys
+  // in a map:
+  //
+  // *  `all`, `exists`, `exists_one` -  test a predicate expression against
+  //    the inputs and return `true` if the predicate is satisfied for all,
+  //    any, or only one value `list.all(x, x < 10)`.
+  // *  `filter` - test a predicate expression against the inputs and return
+  //    the subset of elements which satisfy the predicate:
+  //    `payments.filter(p, p > 1000)`.
+  // *  `map` - apply an expression to all elements in the input and return the
+  //    output aggregate type: `[1, 2, 3].map(i, i * i)`.
+  //
+  // The `has(m.x)` macro tests whether the property `x` is present in struct
+  // `m`. The semantics of this macro depend on the type of `m`. For proto2
+  // messages `has(m.x)` is defined as 'defined, but not set`. For proto3, the
+  // macro tests whether the property is set to its default. For map and struct
+  // types, the macro tests whether the property `x` is defined on `m`.
+  //
+  // Comprehension evaluation can be best visualized as the following
+  // pseudocode:
+  //
+  // ```
+  // let `accu_var` = `accu_init`
+  // for (let `iter_var` in `iter_range`) {
+  //   if (!`loop_condition`) {
+  //     break
+  //   }
+  //   `accu_var` = `loop_step`
+  // }
+  // return `result`
+  // ```
+  message Comprehension {
+    // The name of the iteration variable.
+    string iter_var = 1;
+
+    // The range over which var iterates.
+    Expr iter_range = 2;
+
+    // The name of the variable used for accumulation of the result.
+    string accu_var = 3;
+
+    // The initial value of the accumulator.
+    Expr accu_init = 4;
+
+    // An expression which can contain iter_var and accu_var.
+    //
+    // Returns false when the result has been computed and may be used as
+    // a hint to short-circuit the remainder of the comprehension.
+    Expr loop_condition = 5;
+
+    // An expression which can contain iter_var and accu_var.
+    //
+    // Computes the next value of accu_var.
+    Expr loop_step = 6;
+
+    // An expression which can contain accu_var.
+    //
+    // Computes the result.
+    Expr result = 7;
+  }
+
+  // Required. An id assigned to this node by the parser which is unique in a
+  // given expression tree. This is used to associate type information and other
+  // attributes to a node in the parse tree.
+  int64 id = 2;
+
+  // Required. Variants of expressions.
+  oneof expr_kind {
+    // A constant expression.
+    Constant const_expr = 3;
+
+    // An identifier expression.
+    Ident ident_expr = 4;
+
+    // A field selection expression, e.g. `request.auth`.
+    Select select_expr = 5;
+
+    // A call expression, including calls to predefined functions and operators.
+    Call call_expr = 6;
+
+    // A list creation expression.
+    CreateList list_expr = 7;
+
+    // A map or message creation expression.
+    CreateStruct struct_expr = 8;
+
+    // A comprehension expression.
+    Comprehension comprehension_expr = 9;
+  }
+}
+
+// Represents a primitive literal.
+//
+// Named 'Constant' here for backwards compatibility.
+//
+// This is similar as the primitives supported in the well-known type
+// `google.protobuf.Value`, but richer so it can represent CEL's full range of
+// primitives.
+//
+// Lists and structs are not included as constants as these aggregate types may
+// contain [Expr][cel.expr.Expr] elements which require evaluation and
+// are thus not constant.
+//
+// Examples of constants include: `"hello"`, `b'bytes'`, `1u`, `4.2`, `-2`,
+// `true`, `null`.
+message Constant {
+  // Required. The valid constant kinds.
+  oneof constant_kind {
+    // null value.
+    google.protobuf.NullValue null_value = 1;
+
+    // boolean value.
+    bool bool_value = 2;
+
+    // int64 value.
+    int64 int64_value = 3;
+
+    // uint64 value.
+    uint64 uint64_value = 4;
+
+    // double value.
+    double double_value = 5;
+
+    // string value.
+    string string_value = 6;
+
+    // bytes value.
+    bytes bytes_value = 7;
+
+    // protobuf.Duration value.
+    //
+    // Deprecated: duration is no longer considered a builtin cel type.
+    google.protobuf.Duration duration_value = 8 [deprecated = true];
+
+    // protobuf.Timestamp value.
+    //
+    // Deprecated: timestamp is no longer considered a builtin cel type.
+    google.protobuf.Timestamp timestamp_value = 9 [deprecated = true];
+  }
+}
+
+// Source information collected at parse time.
+message SourceInfo {
+  // The syntax version of the source, e.g. `cel1`.
+  string syntax_version = 1;
+
+  // The location name. All position information attached to an expression is
+  // relative to this location.
+  //
+  // The location could be a file, UI element, or similar. For example,
+  // `acme/app/AnvilPolicy.cel`.
+  string location = 2;
+
+  // Monotonically increasing list of code point offsets where newlines
+  // `\n` appear.
+  //
+  // The line number of a given position is the index `i` where for a given
+  // `id` the `line_offsets[i] < id_positions[id] < line_offsets[i+1]`. The
+  // column may be derived from `id_positions[id] - line_offsets[i]`.
+  repeated int32 line_offsets = 3;
+
+  // A map from the parse node id (e.g. `Expr.id`) to the code point offset
+  // within the source.
+  map<int64, int32> positions = 4;
+
+  // A map from the parse node id where a macro replacement was made to the
+  // call `Expr` that resulted in a macro expansion.
+  //
+  // For example, `has(value.field)` is a function call that is replaced by a
+  // `test_only` field selection in the AST. Likewise, the call
+  // `list.exists(e, e > 10)` translates to a comprehension expression. The key
+  // in the map corresponds to the expression id of the expanded macro, and the
+  // value is the call `Expr` that was replaced.
+  map<int64, Expr> macro_calls = 5;
+
+  // A list of tags for extensions that were used while parsing or type checking
+  // the source expression. For example, optimizations that require special
+  // runtime support may be specified.
+  //
+  // These are used to check feature support between components in separate
+  // implementations. This can be used to either skip redundant work or
+  // report an error if the extension is unsupported.
+  repeated Extension extensions = 6;
+
+  // An extension that was requested for the source expression.
+  message Extension {
+    // Version
+    message Version {
+      // Major version changes indicate different required support level from
+      // the required components.
+      int64 major = 1;
+      // Minor version changes must not change the observed behavior from
+      // existing implementations, but may be provided informationally.
+      int64 minor = 2;
+    }
+
+    // CEL component specifier.
+    enum Component {
+      // Unspecified, default.
+      COMPONENT_UNSPECIFIED = 0;
+      // Parser. Converts a CEL string to an AST.
+      COMPONENT_PARSER = 1;
+      // Type checker. Checks that references in an AST are defined and types
+      // agree.
+      COMPONENT_TYPE_CHECKER = 2;
+      // Runtime. Evaluates a parsed and optionally checked CEL AST against a
+      // context.
+      COMPONENT_RUNTIME = 3;
+    }
+
+    // Identifier for the extension. Example: constant_folding
+    string id = 1;
+
+    // If set, the listed components must understand the extension for the
+    // expression to evaluate correctly.
+    //
+    // This field has set semantics, repeated values should be deduplicated.
+    repeated Component affected_components = 2;
+
+    // Version info. May be skipped if it isn't meaningful for the extension.
+    // (for example constant_folding might always be v0.0).
+    Version version = 3;
+  }
+}
diff --git a/xds/third_party/envoy/LICENSE b/xds/third_party/envoy/LICENSE
new file mode 100644
index 00000000000..d6456956733
--- /dev/null
+++ b/xds/third_party/envoy/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/xds/third_party/envoy/NOTICE b/xds/third_party/envoy/NOTICE
new file mode 100644
index 00000000000..8604a8bbd60
--- /dev/null
+++ b/xds/third_party/envoy/NOTICE
@@ -0,0 +1,4 @@
+Envoy
+Copyright The Envoy Project Authors
+
+Licensed under Apache License 2.0.  See LICENSE for terms.
diff --git a/xds/third_party/envoy/import.sh b/xds/third_party/envoy/import.sh
new file mode 100755
index 00000000000..0ad90f7baf0
--- /dev/null
+++ b/xds/third_party/envoy/import.sh
@@ -0,0 +1,169 @@
+#!/bin/bash
+# Copyright 2018 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.
+
+# Update VERSION then execute this script
+
+set -e
+# import VERSION from the google internal go/envoy-import-status
+VERSION=b6df993feef0340391e6dbf6ad957ab42884ad05
+DOWNLOAD_URL="https://github.com/envoyproxy/envoy/archive/${VERSION}.tar.gz"
+DOWNLOAD_BASE_DIR="envoy-${VERSION}"
+SOURCE_PROTO_BASE_DIR="${DOWNLOAD_BASE_DIR}/api"
+TARGET_PROTO_BASE_DIR=src/main/proto
+# Sorted alphabetically.
+FILES=(
+envoy/admin/v3/config_dump.proto
+envoy/admin/v3/config_dump_shared.proto
+envoy/annotations/deprecation.proto
+envoy/config/accesslog/v3/accesslog.proto
+envoy/config/bootstrap/v3/bootstrap.proto
+envoy/config/cluster/v3/circuit_breaker.proto
+envoy/config/cluster/v3/cluster.proto
+envoy/config/cluster/v3/filter.proto
+envoy/config/cluster/v3/outlier_detection.proto
+envoy/config/common/mutation_rules/v3/mutation_rules.proto
+envoy/config/core/v3/address.proto
+envoy/config/core/v3/backoff.proto
+envoy/config/core/v3/base.proto
+envoy/config/core/v3/config_source.proto
+envoy/config/core/v3/event_service_config.proto
+envoy/config/core/v3/extension.proto
+envoy/config/core/v3/grpc_service.proto
+envoy/config/core/v3/health_check.proto
+envoy/config/core/v3/http_service.proto
+envoy/config/core/v3/http_uri.proto
+envoy/config/core/v3/protocol.proto
+envoy/config/core/v3/proxy_protocol.proto
+envoy/config/core/v3/resolver.proto
+envoy/config/core/v3/socket_cmsg_headers.proto
+envoy/config/core/v3/socket_option.proto
+envoy/config/core/v3/substitution_format_string.proto
+envoy/config/core/v3/udp_socket_config.proto
+envoy/config/endpoint/v3/endpoint.proto
+envoy/config/endpoint/v3/endpoint_components.proto
+envoy/config/endpoint/v3/load_report.proto
+envoy/config/listener/v3/api_listener.proto
+envoy/config/listener/v3/listener.proto
+envoy/config/listener/v3/listener_components.proto
+envoy/config/listener/v3/quic_config.proto
+envoy/config/listener/v3/udp_listener_config.proto
+envoy/config/metrics/v3/stats.proto
+envoy/config/overload/v3/overload.proto
+envoy/config/rbac/v3/rbac.proto
+envoy/config/route/v3/route.proto
+envoy/config/route/v3/route_components.proto
+envoy/config/route/v3/scoped_route.proto
+envoy/config/trace/v3/datadog.proto
+envoy/config/trace/v3/dynamic_ot.proto
+envoy/config/trace/v3/http_tracer.proto
+envoy/config/trace/v3/lightstep.proto
+envoy/config/trace/v3/opentelemetry.proto
+envoy/config/trace/v3/service.proto
+envoy/config/trace/v3/zipkin.proto
+envoy/data/accesslog/v3/accesslog.proto
+envoy/extensions/clusters/aggregate/v3/cluster.proto
+envoy/extensions/filters/common/fault/v3/fault.proto
+envoy/extensions/filters/http/ext_authz/v3/ext_authz.proto
+envoy/extensions/filters/http/fault/v3/fault.proto
+envoy/extensions/filters/http/rate_limit_quota/v3/rate_limit_quota.proto
+envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.proto
+envoy/extensions/filters/http/rbac/v3/rbac.proto
+envoy/extensions/filters/http/router/v3/router.proto
+envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto
+envoy/extensions/grpc_service/call_credentials/access_token/v3/access_token_credentials.proto
+envoy/extensions/grpc_service/channel_credentials/google_default/v3/google_default_credentials.proto
+envoy/extensions/grpc_service/channel_credentials/insecure/v3/insecure_credentials.proto
+envoy/extensions/grpc_service/channel_credentials/local/v3/local_credentials.proto
+envoy/extensions/grpc_service/channel_credentials/tls/v3/tls_credentials.proto
+envoy/extensions/grpc_service/channel_credentials/xds/v3/xds_credentials.proto
+envoy/extensions/load_balancing_policies/client_side_weighted_round_robin/v3/client_side_weighted_round_robin.proto
+envoy/extensions/load_balancing_policies/common/v3/common.proto
+envoy/extensions/load_balancing_policies/least_request/v3/least_request.proto
+envoy/extensions/load_balancing_policies/pick_first/v3/pick_first.proto
+envoy/extensions/load_balancing_policies/ring_hash/v3/ring_hash.proto
+envoy/extensions/load_balancing_policies/round_robin/v3/round_robin.proto
+envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.proto
+envoy/extensions/transport_sockets/http_11_proxy/v3/upstream_http_11_connect.proto
+envoy/extensions/transport_sockets/tls/v3/cert.proto
+envoy/extensions/transport_sockets/tls/v3/common.proto
+envoy/extensions/transport_sockets/tls/v3/secret.proto
+envoy/extensions/transport_sockets/tls/v3/tls.proto
+envoy/service/auth/v3/attribute_context.proto
+envoy/service/auth/v3/external_auth.proto
+envoy/service/discovery/v3/ads.proto
+envoy/service/discovery/v3/discovery.proto
+envoy/service/load_stats/v3/lrs.proto
+envoy/service/rate_limit_quota/v3/rlqs.proto
+envoy/service/status/v3/csds.proto
+envoy/type/http/v3/path_transformation.proto
+envoy/type/matcher/v3/address.proto
+envoy/type/matcher/v3/filter_state.proto
+envoy/type/matcher/v3/http_inputs.proto
+envoy/type/matcher/v3/metadata.proto
+envoy/type/matcher/v3/node.proto
+envoy/type/matcher/v3/number.proto
+envoy/type/matcher/v3/path.proto
+envoy/type/matcher/v3/regex.proto
+envoy/type/matcher/v3/string.proto
+envoy/type/matcher/v3/struct.proto
+envoy/type/matcher/v3/value.proto
+envoy/type/metadata/v3/metadata.proto
+envoy/type/tracing/v3/custom_tag.proto
+envoy/type/v3/http.proto
+envoy/type/v3/http_status.proto
+envoy/type/v3/percent.proto
+envoy/type/v3/range.proto
+envoy/type/v3/ratelimit_strategy.proto
+envoy/type/v3/ratelimit_unit.proto
+envoy/type/v3/semantic_version.proto
+envoy/type/v3/token_bucket.proto
+)
+
+pushd "$(git rev-parse --show-toplevel)/xds/third_party/envoy" > /dev/null
+
+# put the repo in a tmp directory
+tmpdir="$(mktemp -d)"
+echo "Using tmp dir: ${tmpdir}"
+
+# Intentionally expand at the execution time rather than when signalled.
+# shellcheck disable=SC2064
+trap "rm -rf ${tmpdir}" EXIT
+
+curl -Ls "${DOWNLOAD_URL}" | tar xz -C "${tmpdir}"
+
+cp -p "${tmpdir}/${DOWNLOAD_BASE_DIR}/LICENSE" LICENSE
+cp -p "${tmpdir}/${DOWNLOAD_BASE_DIR}/NOTICE" NOTICE
+
+rm -rf "${TARGET_PROTO_BASE_DIR}"
+mkdir -p "${TARGET_PROTO_BASE_DIR}"
+pushd "${TARGET_PROTO_BASE_DIR}" > /dev/null
+
+# copy proto files to project directory
+TOTAL=${#FILES[@]}
+COPIED=0
+for file in "${FILES[@]}"
+do
+  mkdir -p "$(dirname "${file}")"
+  cp -p "${tmpdir}/${SOURCE_PROTO_BASE_DIR}/${file}" "${file}" && (( ++COPIED ))
+done
+popd > /dev/null
+
+popd > /dev/null
+
+echo "Imported ${COPIED} files."
+if (( COPIED != TOTAL )); then
+  echo "Failed importing $(( TOTAL - COPIED )) files." 1>&2
+  exit 1
+fi
diff --git a/xds/third_party/envoy/src/main/proto/envoy/admin/v3/config_dump.proto b/xds/third_party/envoy/src/main/proto/envoy/admin/v3/config_dump.proto
new file mode 100644
index 00000000000..82dc13ebfe8
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/admin/v3/config_dump.proto
@@ -0,0 +1,135 @@
+syntax = "proto3";
+
+package envoy.admin.v3;
+
+import "envoy/admin/v3/config_dump_shared.proto";
+import "envoy/config/bootstrap/v3/bootstrap.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/timestamp.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.admin.v3";
+option java_outer_classname = "ConfigDumpProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/admin/v3;adminv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: ConfigDump]
+
+// The :ref:`/config_dump <operations_admin_interface_config_dump>` admin endpoint uses this wrapper
+// message to maintain and serve arbitrary configuration information from any component in Envoy.
+message ConfigDump {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.admin.v2alpha.ConfigDump";
+
+  // This list is serialized and dumped in its entirety at the
+  // :ref:`/config_dump <operations_admin_interface_config_dump>` endpoint.
+  //
+  // The following configurations are currently supported and will be dumped in the order given
+  // below:
+  //
+  // * ``bootstrap``: :ref:`BootstrapConfigDump <envoy_v3_api_msg_admin.v3.BootstrapConfigDump>`
+  // * ``clusters``: :ref:`ClustersConfigDump <envoy_v3_api_msg_admin.v3.ClustersConfigDump>`
+  // * ``ecds_filter_http``: :ref:`EcdsConfigDump <envoy_v3_api_msg_admin.v3.EcdsConfigDump>`
+  // * ``ecds_filter_quic_listener``: :ref:`EcdsConfigDump <envoy_v3_api_msg_admin.v3.EcdsConfigDump>`
+  // * ``ecds_filter_tcp_listener``: :ref:`EcdsConfigDump <envoy_v3_api_msg_admin.v3.EcdsConfigDump>`
+  // * ``endpoints``:  :ref:`EndpointsConfigDump <envoy_v3_api_msg_admin.v3.EndpointsConfigDump>`
+  // * ``listeners``: :ref:`ListenersConfigDump <envoy_v3_api_msg_admin.v3.ListenersConfigDump>`
+  // * ``scoped_routes``: :ref:`ScopedRoutesConfigDump <envoy_v3_api_msg_admin.v3.ScopedRoutesConfigDump>`
+  // * ``routes``:  :ref:`RoutesConfigDump <envoy_v3_api_msg_admin.v3.RoutesConfigDump>`
+  // * ``secrets``:  :ref:`SecretsConfigDump <envoy_v3_api_msg_admin.v3.SecretsConfigDump>`
+  //
+  // EDS Configuration will only be dumped by using parameter ``?include_eds``
+  //
+  // Currently ECDS is supported in HTTP and listener filters. Note, ECDS configuration for
+  // either HTTP or listener filter will only be dumped if it is actually configured.
+  //
+  // You can filter output with the resource and mask query parameters.
+  // See :ref:`/config_dump?resource={} <operations_admin_interface_config_dump_by_resource>`,
+  // :ref:`/config_dump?mask={} <operations_admin_interface_config_dump_by_mask>`,
+  // or :ref:`/config_dump?resource={},mask={}
+  // <operations_admin_interface_config_dump_by_resource_and_mask>` for more information.
+  repeated google.protobuf.Any configs = 1;
+}
+
+// This message describes the bootstrap configuration that Envoy was started with. This includes
+// any CLI overrides that were merged. Bootstrap configuration information can be used to recreate
+// the static portions of an Envoy configuration by reusing the output as the bootstrap
+// configuration for another Envoy.
+message BootstrapConfigDump {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.admin.v2alpha.BootstrapConfigDump";
+
+  config.bootstrap.v3.Bootstrap bootstrap = 1;
+
+  // The timestamp when the BootstrapConfig was last updated.
+  google.protobuf.Timestamp last_updated = 2;
+}
+
+// Envoys SDS implementation fills this message with all secrets fetched dynamically via SDS.
+message SecretsConfigDump {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.admin.v2alpha.SecretsConfigDump";
+
+  // DynamicSecret contains secret information fetched via SDS.
+  // [#next-free-field: 7]
+  message DynamicSecret {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.admin.v2alpha.SecretsConfigDump.DynamicSecret";
+
+    // The name assigned to the secret.
+    string name = 1;
+
+    // This is the per-resource version information.
+    string version_info = 2;
+
+    // The timestamp when the secret was last updated.
+    google.protobuf.Timestamp last_updated = 3;
+
+    // The actual secret information.
+    // Security sensitive information is redacted (replaced with "[redacted]") for
+    // private keys and passwords in TLS certificates.
+    google.protobuf.Any secret = 4;
+
+    // Set if the last update failed, cleared after the next successful update.
+    // The *error_state* field contains the rejected version of this particular
+    // resource along with the reason and timestamp. For successfully updated or
+    // acknowledged resource, this field should be empty.
+    // [#not-implemented-hide:]
+    UpdateFailureState error_state = 5;
+
+    // The client status of this resource.
+    // [#not-implemented-hide:]
+    ClientResourceStatus client_status = 6;
+  }
+
+  // StaticSecret specifies statically loaded secret in bootstrap.
+  message StaticSecret {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.admin.v2alpha.SecretsConfigDump.StaticSecret";
+
+    // The name assigned to the secret.
+    string name = 1;
+
+    // The timestamp when the secret was last updated.
+    google.protobuf.Timestamp last_updated = 2;
+
+    // The actual secret information.
+    // Security sensitive information is redacted (replaced with "[redacted]") for
+    // private keys and passwords in TLS certificates.
+    google.protobuf.Any secret = 3;
+  }
+
+  // The statically loaded secrets.
+  repeated StaticSecret static_secrets = 1;
+
+  // The dynamically loaded active secrets. These are secrets that are available to service
+  // clusters or listeners.
+  repeated DynamicSecret dynamic_active_secrets = 2;
+
+  // The dynamically loaded warming secrets. These are secrets that are currently undergoing
+  // warming in preparation to service clusters or listeners.
+  repeated DynamicSecret dynamic_warming_secrets = 3;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/admin/v3/config_dump_shared.proto b/xds/third_party/envoy/src/main/proto/envoy/admin/v3/config_dump_shared.proto
new file mode 100644
index 00000000000..b34e004d986
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/admin/v3/config_dump_shared.proto
@@ -0,0 +1,420 @@
+syntax = "proto3";
+
+package envoy.admin.v3;
+
+import "google/protobuf/any.proto";
+import "google/protobuf/timestamp.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.admin.v3";
+option java_outer_classname = "ConfigDumpSharedProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/admin/v3;adminv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: ConfigDump]
+
+// Resource status from the view of a xDS client, which tells the synchronization
+// status between the xDS client and the xDS server.
+enum ClientResourceStatus {
+  // Resource status is not available/unknown.
+  UNKNOWN = 0;
+
+  // Client requested this resource but hasn't received any update from management
+  // server. The client will not fail requests, but will queue them until update
+  // arrives or the client times out waiting for the resource.
+  REQUESTED = 1;
+
+  // This resource has been requested by the client but has either not been
+  // delivered by the server or was previously delivered by the server and then
+  // subsequently removed from resources provided by the server. For more
+  // information, please refer to the :ref:`"Knowing When a Requested Resource
+  // Does Not Exist" <xds_protocol_resource_not_existed>` section.
+  DOES_NOT_EXIST = 2;
+
+  // Client received this resource and replied with ACK.
+  ACKED = 3;
+
+  // Client received this resource and replied with NACK.
+  NACKED = 4;
+
+  // Client received an error from the control plane. The attached config
+  // dump is the most recent accepted one. If no config is accepted yet,
+  // the attached config dump will be empty.
+  RECEIVED_ERROR = 5;
+
+  // Client timed out waiting for the resource from the control plane.
+  TIMEOUT = 6;
+}
+
+message UpdateFailureState {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.admin.v2alpha.UpdateFailureState";
+
+  // What the component configuration would have been if the update had succeeded.
+  // This field may not be populated by xDS clients due to storage overhead.
+  google.protobuf.Any failed_configuration = 1;
+
+  // Time of the latest failed update attempt.
+  google.protobuf.Timestamp last_update_attempt = 2;
+
+  // Details about the last failed update attempt.
+  string details = 3;
+
+  // This is the version of the rejected resource.
+  // [#not-implemented-hide:]
+  string version_info = 4;
+}
+
+// Envoy's listener manager fills this message with all currently known listeners. Listener
+// configuration information can be used to recreate an Envoy configuration by populating all
+// listeners as static listeners or by returning them in a LDS response.
+message ListenersConfigDump {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.admin.v2alpha.ListenersConfigDump";
+
+  // Describes a statically loaded listener.
+  message StaticListener {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.admin.v2alpha.ListenersConfigDump.StaticListener";
+
+    // The listener config.
+    google.protobuf.Any listener = 1;
+
+    // The timestamp when the Listener was last successfully updated.
+    google.protobuf.Timestamp last_updated = 2;
+  }
+
+  message DynamicListenerState {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.admin.v2alpha.ListenersConfigDump.DynamicListenerState";
+
+    // This is the per-resource version information. This version is currently taken from the
+    // :ref:`version_info <envoy_v3_api_field_service.discovery.v3.DiscoveryResponse.version_info>` field at the time
+    // that the listener was loaded. In the future, discrete per-listener versions may be supported
+    // by the API.
+    string version_info = 1;
+
+    // The listener config.
+    google.protobuf.Any listener = 2;
+
+    // The timestamp when the Listener was last successfully updated.
+    google.protobuf.Timestamp last_updated = 3;
+  }
+
+  // Describes a dynamically loaded listener via the LDS API.
+  // [#next-free-field: 7]
+  message DynamicListener {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.admin.v2alpha.ListenersConfigDump.DynamicListener";
+
+    // The name or unique id of this listener, pulled from the DynamicListenerState config.
+    string name = 1;
+
+    // The listener state for any active listener by this name.
+    // These are listeners that are available to service data plane traffic.
+    DynamicListenerState active_state = 2;
+
+    // The listener state for any warming listener by this name.
+    // These are listeners that are currently undergoing warming in preparation to service data
+    // plane traffic. Note that if attempting to recreate an Envoy configuration from a
+    // configuration dump, the warming listeners should generally be discarded.
+    DynamicListenerState warming_state = 3;
+
+    // The listener state for any draining listener by this name.
+    // These are listeners that are currently undergoing draining in preparation to stop servicing
+    // data plane traffic. Note that if attempting to recreate an Envoy configuration from a
+    // configuration dump, the draining listeners should generally be discarded.
+    DynamicListenerState draining_state = 4;
+
+    // Set if the last update failed, cleared after the next successful update.
+    // The ``error_state`` field contains the rejected version of this particular
+    // resource along with the reason and timestamp. For successfully updated or
+    // acknowledged resource, this field should be empty.
+    UpdateFailureState error_state = 5;
+
+    // The client status of this resource.
+    // [#not-implemented-hide:]
+    ClientResourceStatus client_status = 6;
+  }
+
+  // This is the :ref:`version_info <envoy_v3_api_field_service.discovery.v3.DiscoveryResponse.version_info>` in the
+  // last processed LDS discovery response. If there are only static bootstrap listeners, this field
+  // will be "".
+  string version_info = 1;
+
+  // The statically loaded listener configs.
+  repeated StaticListener static_listeners = 2;
+
+  // State for any warming, active, or draining listeners.
+  repeated DynamicListener dynamic_listeners = 3;
+}
+
+// Envoy's cluster manager fills this message with all currently known clusters. Cluster
+// configuration information can be used to recreate an Envoy configuration by populating all
+// clusters as static clusters or by returning them in a CDS response.
+message ClustersConfigDump {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.admin.v2alpha.ClustersConfigDump";
+
+  // Describes a statically loaded cluster.
+  message StaticCluster {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.admin.v2alpha.ClustersConfigDump.StaticCluster";
+
+    // The cluster config.
+    google.protobuf.Any cluster = 1;
+
+    // The timestamp when the Cluster was last updated.
+    google.protobuf.Timestamp last_updated = 2;
+  }
+
+  // Describes a dynamically loaded cluster via the CDS API.
+  // [#next-free-field: 6]
+  message DynamicCluster {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.admin.v2alpha.ClustersConfigDump.DynamicCluster";
+
+    // This is the per-resource version information. This version is currently taken from the
+    // :ref:`version_info <envoy_v3_api_field_service.discovery.v3.DiscoveryResponse.version_info>` field at the time
+    // that the cluster was loaded. In the future, discrete per-cluster versions may be supported by
+    // the API.
+    string version_info = 1;
+
+    // The cluster config.
+    google.protobuf.Any cluster = 2;
+
+    // The timestamp when the Cluster was last updated.
+    google.protobuf.Timestamp last_updated = 3;
+
+    // Set if the last update failed, cleared after the next successful update.
+    // The ``error_state`` field contains the rejected version of this particular
+    // resource along with the reason and timestamp. For successfully updated or
+    // acknowledged resource, this field should be empty.
+    // [#not-implemented-hide:]
+    UpdateFailureState error_state = 4;
+
+    // The client status of this resource.
+    // [#not-implemented-hide:]
+    ClientResourceStatus client_status = 5;
+  }
+
+  // This is the :ref:`version_info <envoy_v3_api_field_service.discovery.v3.DiscoveryResponse.version_info>` in the
+  // last processed CDS discovery response. If there are only static bootstrap clusters, this field
+  // will be "".
+  string version_info = 1;
+
+  // The statically loaded cluster configs.
+  repeated StaticCluster static_clusters = 2;
+
+  // The dynamically loaded active clusters. These are clusters that are available to service
+  // data plane traffic.
+  repeated DynamicCluster dynamic_active_clusters = 3;
+
+  // The dynamically loaded warming clusters. These are clusters that are currently undergoing
+  // warming in preparation to service data plane traffic. Note that if attempting to recreate an
+  // Envoy configuration from a configuration dump, the warming clusters should generally be
+  // discarded.
+  repeated DynamicCluster dynamic_warming_clusters = 4;
+}
+
+// Envoy's RDS implementation fills this message with all currently loaded routes, as described by
+// their RouteConfiguration objects. Static routes that are either defined in the bootstrap configuration
+// or defined inline while configuring listeners are separated from those configured dynamically via RDS.
+// Route configuration information can be used to recreate an Envoy configuration by populating all routes
+// as static routes or by returning them in RDS responses.
+message RoutesConfigDump {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.admin.v2alpha.RoutesConfigDump";
+
+  message StaticRouteConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.admin.v2alpha.RoutesConfigDump.StaticRouteConfig";
+
+    // The route config.
+    google.protobuf.Any route_config = 1;
+
+    // The timestamp when the Route was last updated.
+    google.protobuf.Timestamp last_updated = 2;
+  }
+
+  // [#next-free-field: 6]
+  message DynamicRouteConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.admin.v2alpha.RoutesConfigDump.DynamicRouteConfig";
+
+    // This is the per-resource version information. This version is currently taken from the
+    // :ref:`version_info <envoy_v3_api_field_service.discovery.v3.DiscoveryResponse.version_info>` field at the time that
+    // the route configuration was loaded.
+    string version_info = 1;
+
+    // The route config.
+    google.protobuf.Any route_config = 2;
+
+    // The timestamp when the Route was last updated.
+    google.protobuf.Timestamp last_updated = 3;
+
+    // Set if the last update failed, cleared after the next successful update.
+    // The ``error_state`` field contains the rejected version of this particular
+    // resource along with the reason and timestamp. For successfully updated or
+    // acknowledged resource, this field should be empty.
+    // [#not-implemented-hide:]
+    UpdateFailureState error_state = 4;
+
+    // The client status of this resource.
+    // [#not-implemented-hide:]
+    ClientResourceStatus client_status = 5;
+  }
+
+  // The statically loaded route configs.
+  repeated StaticRouteConfig static_route_configs = 2;
+
+  // The dynamically loaded route configs.
+  repeated DynamicRouteConfig dynamic_route_configs = 3;
+}
+
+// Envoy's scoped RDS implementation fills this message with all currently loaded route
+// configuration scopes (defined via ScopedRouteConfigurationsSet protos). This message lists both
+// the scopes defined inline with the higher order object (i.e., the HttpConnectionManager) and the
+// dynamically obtained scopes via the SRDS API.
+message ScopedRoutesConfigDump {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.admin.v2alpha.ScopedRoutesConfigDump";
+
+  message InlineScopedRouteConfigs {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.admin.v2alpha.ScopedRoutesConfigDump.InlineScopedRouteConfigs";
+
+    // The name assigned to the scoped route configurations.
+    string name = 1;
+
+    // The scoped route configurations.
+    repeated google.protobuf.Any scoped_route_configs = 2;
+
+    // The timestamp when the scoped route config set was last updated.
+    google.protobuf.Timestamp last_updated = 3;
+  }
+
+  // [#next-free-field: 7]
+  message DynamicScopedRouteConfigs {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.admin.v2alpha.ScopedRoutesConfigDump.DynamicScopedRouteConfigs";
+
+    // The name assigned to the scoped route configurations.
+    string name = 1;
+
+    // This is the per-resource version information. This version is currently taken from the
+    // :ref:`version_info <envoy_v3_api_field_service.discovery.v3.DiscoveryResponse.version_info>` field at the time that
+    // the scoped routes configuration was loaded.
+    string version_info = 2;
+
+    // The scoped route configurations.
+    repeated google.protobuf.Any scoped_route_configs = 3;
+
+    // The timestamp when the scoped route config set was last updated.
+    google.protobuf.Timestamp last_updated = 4;
+
+    // Set if the last update failed, cleared after the next successful update.
+    // The ``error_state`` field contains the rejected version of this particular
+    // resource along with the reason and timestamp. For successfully updated or
+    // acknowledged resource, this field should be empty.
+    // [#not-implemented-hide:]
+    UpdateFailureState error_state = 5;
+
+    // The client status of this resource.
+    // [#not-implemented-hide:]
+    ClientResourceStatus client_status = 6;
+  }
+
+  // The statically loaded scoped route configs.
+  repeated InlineScopedRouteConfigs inline_scoped_route_configs = 1;
+
+  // The dynamically loaded scoped route configs.
+  repeated DynamicScopedRouteConfigs dynamic_scoped_route_configs = 2;
+}
+
+// Envoy's admin fill this message with all currently known endpoints. Endpoint
+// configuration information can be used to recreate an Envoy configuration by populating all
+// endpoints as static endpoints or by returning them in an EDS response.
+message EndpointsConfigDump {
+  message StaticEndpointConfig {
+    // The endpoint config.
+    google.protobuf.Any endpoint_config = 1;
+
+    // [#not-implemented-hide:] The timestamp when the Endpoint was last updated.
+    google.protobuf.Timestamp last_updated = 2;
+  }
+
+  // [#next-free-field: 6]
+  message DynamicEndpointConfig {
+    // [#not-implemented-hide:] This is the per-resource version information. This version is currently taken from the
+    // :ref:`version_info <envoy_v3_api_field_service.discovery.v3.DiscoveryResponse.version_info>` field at the time that
+    // the endpoint configuration was loaded.
+    string version_info = 1;
+
+    // The endpoint config.
+    google.protobuf.Any endpoint_config = 2;
+
+    // [#not-implemented-hide:] The timestamp when the Endpoint was last updated.
+    google.protobuf.Timestamp last_updated = 3;
+
+    // Set if the last update failed, cleared after the next successful update.
+    // The ``error_state`` field contains the rejected version of this particular
+    // resource along with the reason and timestamp. For successfully updated or
+    // acknowledged resource, this field should be empty.
+    // [#not-implemented-hide:]
+    UpdateFailureState error_state = 4;
+
+    // The client status of this resource.
+    // [#not-implemented-hide:]
+    ClientResourceStatus client_status = 5;
+  }
+
+  // The statically loaded endpoint configs.
+  repeated StaticEndpointConfig static_endpoint_configs = 2;
+
+  // The dynamically loaded endpoint configs.
+  repeated DynamicEndpointConfig dynamic_endpoint_configs = 3;
+}
+
+// Envoy's ECDS service fills this message with all currently extension
+// configuration. Extension configuration information can be used to recreate
+// an Envoy ECDS listener and HTTP filters as static filters or by returning
+// them in ECDS response.
+message EcdsConfigDump {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.admin.v2alpha.EcdsConfigDump";
+
+  // [#next-free-field: 6]
+  message EcdsFilterConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.admin.v2alpha.EcdsConfigDump.EcdsFilterConfig";
+
+    // This is the per-resource version information. This version is currently
+    // taken from the :ref:`version_info
+    // <envoy_v3_api_field_service.discovery.v3.DiscoveryResponse.version_info>`
+    // field at the time that the ECDS filter was loaded.
+    string version_info = 1;
+
+    // The ECDS filter config.
+    google.protobuf.Any ecds_filter = 2;
+
+    // The timestamp when the ECDS filter was last updated.
+    google.protobuf.Timestamp last_updated = 3;
+
+    // Set if the last update failed, cleared after the next successful update.
+    // The ``error_state`` field contains the rejected version of this
+    // particular resource along with the reason and timestamp. For successfully
+    // updated or acknowledged resource, this field should be empty.
+    // [#not-implemented-hide:]
+    UpdateFailureState error_state = 4;
+
+    // The client status of this resource.
+    // [#not-implemented-hide:]
+    ClientResourceStatus client_status = 5;
+  }
+
+  // The ECDS filter configs.
+  repeated EcdsFilterConfig ecds_filters = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/annotations/deprecation.proto b/xds/third_party/envoy/src/main/proto/envoy/annotations/deprecation.proto
new file mode 100644
index 00000000000..c9a96f1ae27
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/annotations/deprecation.proto
@@ -0,0 +1,34 @@
+syntax = "proto3";
+
+package envoy.annotations;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/annotations";
+
+import "google/protobuf/descriptor.proto";
+
+// [#protodoc-title: Deprecation]
+// Adds annotations for deprecated fields and enums to allow tagging proto
+// fields as fatal by default and the minor version on which the field was
+// deprecated. One Envoy release after deprecation, deprecated fields will be
+// disallowed by default, a state which is reversible with
+// :ref:`runtime overrides <config_runtime_deprecation>`.
+
+// Magic number in this file derived from top 28bit of SHA256 digest of
+// "envoy.annotation.disallowed_by_default" and "envoy.annotation.deprecated_at_minor_version"
+extend google.protobuf.FieldOptions {
+  bool disallowed_by_default = 189503207;
+
+  // The API major and minor version on which the field was deprecated
+  // (e.g., "3.5" for major version 3 and minor version 5).
+  string deprecated_at_minor_version = 157299826;
+}
+
+// Magic number in this file derived from top 28bit of SHA256 digest of
+// "envoy.annotation.disallowed_by_default_enum" and
+// "envoy.annotation.deprecated_at_minor_version_eum"
+extend google.protobuf.EnumValueOptions {
+  bool disallowed_by_default_enum = 70100853;
+
+  // The API major and minor version on which the enum value was deprecated
+  // (e.g., "3.5" for major version 3 and minor version 5).
+  string deprecated_at_minor_version_enum = 181198657;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/accesslog/v3/accesslog.proto b/xds/third_party/envoy/src/main/proto/envoy/config/accesslog/v3/accesslog.proto
new file mode 100644
index 00000000000..6753ab6ab52
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/accesslog/v3/accesslog.proto
@@ -0,0 +1,352 @@
+syntax = "proto3";
+
+package envoy.config.accesslog.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/route/v3/route_components.proto";
+import "envoy/data/accesslog/v3/accesslog.proto";
+import "envoy/type/matcher/v3/metadata.proto";
+import "envoy/type/v3/percent.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.accesslog.v3";
+option java_outer_classname = "AccesslogProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/accesslog/v3;accesslogv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Common access log types]
+
+message AccessLog {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.AccessLog";
+
+  reserved 3;
+
+  reserved "config";
+
+  // The name of the access log extension configuration.
+  string name = 1;
+
+  // Filter which is used to determine if the access log needs to be written.
+  AccessLogFilter filter = 2;
+
+  // Custom configuration that must be set according to the access logger extension being instantiated.
+  // [#extension-category: envoy.access_loggers]
+  oneof config_type {
+    google.protobuf.Any typed_config = 4;
+  }
+}
+
+// [#next-free-field: 14]
+message AccessLogFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.AccessLogFilter";
+
+  oneof filter_specifier {
+    option (validate.required) = true;
+
+    // Status code filter.
+    StatusCodeFilter status_code_filter = 1;
+
+    // Duration filter.
+    DurationFilter duration_filter = 2;
+
+    // Not health check filter.
+    NotHealthCheckFilter not_health_check_filter = 3;
+
+    // Traceable filter.
+    TraceableFilter traceable_filter = 4;
+
+    // Runtime filter.
+    RuntimeFilter runtime_filter = 5;
+
+    // And filter.
+    AndFilter and_filter = 6;
+
+    // Or filter.
+    OrFilter or_filter = 7;
+
+    // Header filter.
+    HeaderFilter header_filter = 8;
+
+    // Response flag filter.
+    ResponseFlagFilter response_flag_filter = 9;
+
+    // gRPC status filter.
+    GrpcStatusFilter grpc_status_filter = 10;
+
+    // Extension filter.
+    // [#extension-category: envoy.access_loggers.extension_filters]
+    ExtensionFilter extension_filter = 11;
+
+    // Metadata Filter
+    MetadataFilter metadata_filter = 12;
+
+    // Log Type Filter
+    LogTypeFilter log_type_filter = 13;
+  }
+}
+
+// Filter on an integer comparison.
+message ComparisonFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.ComparisonFilter";
+
+  enum Op {
+    // =
+    EQ = 0;
+
+    // >=
+    GE = 1;
+
+    // <=
+    LE = 2;
+  }
+
+  // Comparison operator.
+  Op op = 1 [(validate.rules).enum = {defined_only: true}];
+
+  // Value to compare against.
+  core.v3.RuntimeUInt32 value = 2 [(validate.rules).message = {required: true}];
+}
+
+// Filters on HTTP response/status code.
+message StatusCodeFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.StatusCodeFilter";
+
+  // Comparison.
+  ComparisonFilter comparison = 1 [(validate.rules).message = {required: true}];
+}
+
+// Filters based on the duration of the request or stream, in milliseconds.
+// For end of stream access logs, the total duration of the stream will be used.
+// For :ref:`periodic access logs<arch_overview_access_log_periodic>`,
+// the duration of the stream at the time of log recording will be used.
+message DurationFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.DurationFilter";
+
+  // Comparison.
+  ComparisonFilter comparison = 1 [(validate.rules).message = {required: true}];
+}
+
+// Filters for requests that are not health check requests. A health check
+// request is marked by the health check filter.
+message NotHealthCheckFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.NotHealthCheckFilter";
+}
+
+// Filters for requests that are traceable. See the tracing overview for more
+// information on how a request becomes traceable.
+message TraceableFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.TraceableFilter";
+}
+
+// Filters requests based on runtime-configurable sampling rates.
+message RuntimeFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.RuntimeFilter";
+
+  // Specifies a key used to look up a custom sampling rate from the runtime configuration. If a value is found for this
+  // key, it will override the default sampling rate specified in ``percent_sampled``.
+  string runtime_key = 1 [(validate.rules).string = {min_len: 1}];
+
+  // Defines the default sampling percentage when no runtime override is present. If not specified, the default is
+  // **0%** (with a denominator of 100).
+  type.v3.FractionalPercent percent_sampled = 2;
+
+  // Controls how sampling decisions are made.
+  //
+  // - Default behavior (``false``):
+  //
+  //   * Uses the :ref:`x-request-id<config_http_conn_man_headers_x-request-id>` as a consistent sampling pivot.
+  //   * When :ref:`x-request-id<config_http_conn_man_headers_x-request-id>` is present, sampling will be consistent
+  //     across multiple hosts based on both the ``runtime_key`` and
+  //     :ref:`x-request-id<config_http_conn_man_headers_x-request-id>`.
+  //   * Useful for tracking related requests across a distributed system.
+  //
+  // - When set to ``true`` or :ref:`x-request-id<config_http_conn_man_headers_x-request-id>` is missing:
+  //
+  //   * Sampling decisions are made randomly based only on the ``runtime_key``.
+  //   * Useful in complex filter configurations (like nested
+  //     :ref:`AndFilter<envoy_v3_api_msg_config.accesslog.v3.AndFilter>`/
+  //     :ref:`OrFilter<envoy_v3_api_msg_config.accesslog.v3.OrFilter>` blocks) where independent probability
+  //     calculations are desired.
+  //   * Can be used to implement logging kill switches with predictable probability distributions.
+  //
+  bool use_independent_randomness = 3;
+}
+
+// Performs a logical “and” operation on the result of each filter in filters.
+// Filters are evaluated sequentially and if one of them returns false, the
+// filter returns false immediately.
+message AndFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.AndFilter";
+
+  repeated AccessLogFilter filters = 1 [(validate.rules).repeated = {min_items: 2}];
+}
+
+// Performs a logical “or” operation on the result of each individual filter.
+// Filters are evaluated sequentially and if one of them returns true, the
+// filter returns true immediately.
+message OrFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.OrFilter";
+
+  repeated AccessLogFilter filters = 2 [(validate.rules).repeated = {min_items: 2}];
+}
+
+// Filters requests based on the presence or value of a request header.
+message HeaderFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.HeaderFilter";
+
+  // Only requests with a header which matches the specified HeaderMatcher will
+  // pass the filter check.
+  route.v3.HeaderMatcher header = 1 [(validate.rules).message = {required: true}];
+}
+
+// Filters requests that received responses with an Envoy response flag set.
+// A list of the response flags can be found
+// in the access log formatter
+// :ref:`documentation<config_access_log_format_response_flags>`.
+message ResponseFlagFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.ResponseFlagFilter";
+
+  // Only responses with the any of the flags listed in this field will be
+  // logged. This field is optional. If it is not specified, then any response
+  // flag will pass the filter check.
+  repeated string flags = 1 [(validate.rules).repeated = {
+    items {
+      string {
+        in: "LH"
+        in: "UH"
+        in: "UT"
+        in: "LR"
+        in: "UR"
+        in: "UF"
+        in: "UC"
+        in: "UO"
+        in: "NR"
+        in: "DI"
+        in: "FI"
+        in: "RL"
+        in: "UAEX"
+        in: "RLSE"
+        in: "DC"
+        in: "URX"
+        in: "SI"
+        in: "IH"
+        in: "DPE"
+        in: "UMSDR"
+        in: "RFCF"
+        in: "NFCF"
+        in: "DT"
+        in: "UPE"
+        in: "NC"
+        in: "OM"
+        in: "DF"
+        in: "DO"
+        in: "DR"
+        in: "UDO"
+      }
+    }
+  }];
+}
+
+// Filters gRPC requests based on their response status. If a gRPC status is not
+// provided, the filter will infer the status from the HTTP status code.
+message GrpcStatusFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.GrpcStatusFilter";
+
+  enum Status {
+    OK = 0;
+    CANCELED = 1;
+    UNKNOWN = 2;
+    INVALID_ARGUMENT = 3;
+    DEADLINE_EXCEEDED = 4;
+    NOT_FOUND = 5;
+    ALREADY_EXISTS = 6;
+    PERMISSION_DENIED = 7;
+    RESOURCE_EXHAUSTED = 8;
+    FAILED_PRECONDITION = 9;
+    ABORTED = 10;
+    OUT_OF_RANGE = 11;
+    UNIMPLEMENTED = 12;
+    INTERNAL = 13;
+    UNAVAILABLE = 14;
+    DATA_LOSS = 15;
+    UNAUTHENTICATED = 16;
+  }
+
+  // Logs only responses that have any one of the gRPC statuses in this field.
+  repeated Status statuses = 1 [(validate.rules).repeated = {items {enum {defined_only: true}}}];
+
+  // If included and set to true, the filter will instead block all responses
+  // with a gRPC status or inferred gRPC status enumerated in statuses, and
+  // allow all other responses.
+  bool exclude = 2;
+}
+
+// Filters based on matching dynamic metadata.
+// If the matcher path and key correspond to an existing key in dynamic
+// metadata, the request is logged only if the matcher value is equal to the
+// metadata value. If the matcher path and key *do not* correspond to an
+// existing key in dynamic metadata, the request is logged only if
+// match_if_key_not_found is "true" or unset.
+message MetadataFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.MetadataFilter";
+
+  // Matcher to check metadata for specified value. For example, to match on the
+  // access_log_hint metadata, set the filter to "envoy.common" and the path to
+  // "access_log_hint", and the value to "true".
+  type.matcher.v3.MetadataMatcher matcher = 1;
+
+  // Default result if the key does not exist in dynamic metadata: if unset or
+  // true, then log; if false, then don't log.
+  google.protobuf.BoolValue match_if_key_not_found = 2;
+}
+
+// Filters based on access log type.
+message LogTypeFilter {
+  // Logs only records which their type is one of the types defined in this field.
+  repeated data.accesslog.v3.AccessLogType types = 1
+      [(validate.rules).repeated = {items {enum {defined_only: true}}}];
+
+  // If this field is set to true, the filter will instead block all records
+  // with a access log type in types field, and allow all other records.
+  bool exclude = 2;
+}
+
+// Extension filter is statically registered at runtime.
+message ExtensionFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.accesslog.v2.ExtensionFilter";
+
+  reserved 2;
+
+  reserved "config";
+
+  // The name of the filter implementation to instantiate. The name must
+  // match a statically registered filter.
+  string name = 1;
+
+  // Custom configuration that depends on the filter being instantiated.
+  oneof config_type {
+    google.protobuf.Any typed_config = 3;
+  }
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/bootstrap/v3/bootstrap.proto b/xds/third_party/envoy/src/main/proto/envoy/config/bootstrap/v3/bootstrap.proto
new file mode 100644
index 00000000000..28b1eba6680
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/bootstrap/v3/bootstrap.proto
@@ -0,0 +1,757 @@
+syntax = "proto3";
+
+package envoy.config.bootstrap.v3;
+
+import "envoy/config/accesslog/v3/accesslog.proto";
+import "envoy/config/cluster/v3/cluster.proto";
+import "envoy/config/core/v3/address.proto";
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/config_source.proto";
+import "envoy/config/core/v3/event_service_config.proto";
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/core/v3/resolver.proto";
+import "envoy/config/core/v3/socket_option.proto";
+import "envoy/config/listener/v3/listener.proto";
+import "envoy/config/metrics/v3/stats.proto";
+import "envoy/config/overload/v3/overload.proto";
+import "envoy/config/trace/v3/http_tracer.proto";
+import "envoy/extensions/transport_sockets/tls/v3/secret.proto";
+import "envoy/type/v3/percent.proto";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/struct.proto";
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/security.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.bootstrap.v3";
+option java_outer_classname = "BootstrapProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/bootstrap/v3;bootstrapv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Bootstrap]
+// This proto is supplied via the :option:`-c` CLI flag and acts as the root
+// of the Envoy v3 configuration. See the :ref:`v3 configuration overview
+// <config_overview_bootstrap>` for more detail.
+
+// Bootstrap :ref:`configuration overview <config_overview_bootstrap>`.
+// [#next-free-field: 43]
+message Bootstrap {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.bootstrap.v2.Bootstrap";
+
+  message StaticResources {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.bootstrap.v2.Bootstrap.StaticResources";
+
+    // Static :ref:`Listeners <envoy_v3_api_msg_config.listener.v3.Listener>`. These listeners are
+    // available regardless of LDS configuration.
+    repeated listener.v3.Listener listeners = 1;
+
+    // If a network based configuration source is specified for :ref:`cds_config
+    // <envoy_v3_api_field_config.bootstrap.v3.Bootstrap.DynamicResources.cds_config>`, it's necessary
+    // to have some initial cluster definitions available to allow Envoy to know
+    // how to speak to the management server.
+    repeated cluster.v3.Cluster clusters = 2;
+
+    // These static secrets can be used by :ref:`SdsSecretConfig
+    // <envoy_v3_api_msg_extensions.transport_sockets.tls.v3.SdsSecretConfig>`
+    repeated envoy.extensions.transport_sockets.tls.v3.Secret secrets = 3;
+  }
+
+  // [#next-free-field: 7]
+  message DynamicResources {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.bootstrap.v2.Bootstrap.DynamicResources";
+
+    reserved 4;
+
+    // All :ref:`Listeners <envoy_v3_api_msg_config.listener.v3.Listener>` are provided by a single
+    // :ref:`LDS <arch_overview_dynamic_config_lds>` configuration source.
+    core.v3.ConfigSource lds_config = 1;
+
+    // xdstp:// resource locator for listener collection.
+    // [#not-implemented-hide:]
+    string lds_resources_locator = 5;
+
+    // All post-bootstrap :ref:`Cluster <envoy_v3_api_msg_config.cluster.v3.Cluster>` definitions are
+    // provided by a single :ref:`CDS <arch_overview_dynamic_config_cds>`
+    // configuration source.
+    core.v3.ConfigSource cds_config = 2;
+
+    // xdstp:// resource locator for cluster collection.
+    // [#not-implemented-hide:]
+    string cds_resources_locator = 6;
+
+    // A single :ref:`ADS <config_overview_ads>` source may be optionally
+    // specified. This must have :ref:`api_type
+    // <envoy_v3_api_field_config.core.v3.ApiConfigSource.api_type>` :ref:`GRPC
+    // <envoy_v3_api_enum_value_config.core.v3.ApiConfigSource.ApiType.GRPC>`. Only
+    // :ref:`ConfigSources <envoy_v3_api_msg_config.core.v3.ConfigSource>` that have
+    // the :ref:`ads <envoy_v3_api_field_config.core.v3.ConfigSource.ads>` field set will be
+    // streamed on the ADS channel.
+    core.v3.ApiConfigSource ads_config = 3;
+  }
+
+  message ApplicationLogConfig {
+    message LogFormat {
+      oneof log_format {
+        option (validate.required) = true;
+
+        // Flush application logs in JSON format. The configured JSON struct can
+        // support all the format flags specified in the :option:`--log-format`
+        // command line options section, except for the ``%v`` and ``%_`` flags.
+        google.protobuf.Struct json_format = 1;
+
+        // Flush application log in a format defined by a string. The text format
+        // can support all the format flags specified in the :option:`--log-format`
+        // command line option section.
+        string text_format = 2;
+      }
+    }
+
+    // Optional field to set the application logs format. If this field is set, it will override
+    // the default log format. Setting both this field and :option:`--log-format` command line
+    // option is not allowed, and will cause a bootstrap error.
+    LogFormat log_format = 1;
+  }
+
+  message DeferredStatOptions {
+    // When the flag is enabled, Envoy will lazily initialize a subset of the stats (see below).
+    // This will save memory and CPU cycles when creating the objects that own these stats, if those
+    // stats are never referenced throughout the lifetime of the process. However, it will incur additional
+    // memory overhead for these objects, and a small increase of CPU usage when a at least one of the stats
+    // is updated for the first time.
+    // Groups of stats that will be lazily initialized:
+    // - Cluster traffic stats: a subgroup of the :ref:`cluster statistics <config_cluster_manager_cluster_stats>`
+    // that are used when requests are routed to the cluster.
+    bool enable_deferred_creation_stats = 1;
+  }
+
+  message GrpcAsyncClientManagerConfig {
+    // Optional field to set the expiration time for the cached gRPC client object.
+    // The minimal value is 5s and the default is 50s.
+    google.protobuf.Duration max_cached_entry_idle_duration = 1
+        [(validate.rules).duration = {gte {seconds: 5}}];
+  }
+
+  reserved 10, 11;
+
+  reserved "runtime";
+
+  // Node identity to present to the management server and for instance
+  // identification purposes (e.g. in generated headers).
+  core.v3.Node node = 1;
+
+  // A list of :ref:`Node <envoy_v3_api_msg_config.core.v3.Node>` field names
+  // that will be included in the context parameters of the effective
+  // xdstp:// URL that is sent in a discovery request when resource
+  // locators are used for LDS/CDS. Any non-string field will have its JSON
+  // encoding set as the context parameter value, with the exception of
+  // metadata, which will be flattened (see example below). The supported field
+  // names are:
+  // - "cluster"
+  // - "id"
+  // - "locality.region"
+  // - "locality.sub_zone"
+  // - "locality.zone"
+  // - "metadata"
+  // - "user_agent_build_version.metadata"
+  // - "user_agent_build_version.version"
+  // - "user_agent_name"
+  // - "user_agent_version"
+  //
+  // The node context parameters act as a base layer dictionary for the context
+  // parameters (i.e. more specific resource specific context parameters will
+  // override). Field names will be prefixed with “udpa.node.” when included in
+  // context parameters.
+  //
+  // For example, if node_context_params is ``["user_agent_name", "metadata"]``,
+  // the implied context parameters might be::
+  //
+  //   node.user_agent_name: "envoy"
+  //   node.metadata.foo: "{\"bar\": \"baz\"}"
+  //   node.metadata.some: "42"
+  //   node.metadata.thing: "\"thing\""
+  //
+  // [#not-implemented-hide:]
+  repeated string node_context_params = 26;
+
+  // Statically specified resources.
+  StaticResources static_resources = 2;
+
+  // xDS configuration sources.
+  DynamicResources dynamic_resources = 3;
+
+  // Configuration for the cluster manager which owns all upstream clusters
+  // within the server.
+  ClusterManager cluster_manager = 4;
+
+  // Health discovery service config option.
+  // (:ref:`core.ApiConfigSource <envoy_v3_api_msg_config.core.v3.ApiConfigSource>`)
+  core.v3.ApiConfigSource hds_config = 14;
+
+  // Optional file system path to search for startup flag files.
+  string flags_path = 5;
+
+  // Optional set of stats sinks.
+  repeated metrics.v3.StatsSink stats_sinks = 6;
+
+  // Options to control behaviors of deferred creation compatible stats.
+  DeferredStatOptions deferred_stat_options = 39;
+
+  // Configuration for internal processing of stats.
+  metrics.v3.StatsConfig stats_config = 13;
+
+  // Optional duration between flushes to configured stats sinks. For
+  // performance reasons Envoy latches counters and only flushes counters and
+  // gauges at a periodic interval. If not specified the default is 5000ms (5
+  // seconds). Only one of ``stats_flush_interval`` or ``stats_flush_on_admin``
+  // can be set.
+  // Duration must be at least 1ms and at most 5 min.
+  google.protobuf.Duration stats_flush_interval = 7 [
+    (validate.rules).duration = {
+      lt {seconds: 300}
+      gte {nanos: 1000000}
+    },
+    (udpa.annotations.field_migrate).oneof_promotion = "stats_flush"
+  ];
+
+  oneof stats_flush {
+    // Flush stats to sinks only when queried for on the admin interface. If set,
+    // a flush timer is not created. Only one of ``stats_flush_on_admin`` or
+    // ``stats_flush_interval`` can be set.
+    bool stats_flush_on_admin = 29 [(validate.rules).bool = {const: true}];
+  }
+
+  oneof stats_eviction {
+    // Optional duration to perform metric eviction. At every interval, during the stats flush
+    // the unused metrics are removed from the worker caches and the used metrics
+    // are marked as unused. Must be a multiple of the ``stats_flush_interval``.
+    google.protobuf.Duration stats_eviction_interval = 42
+        [(validate.rules).duration = {gte {nanos: 1000000}}];
+  }
+
+  // Optional watchdog configuration.
+  // This is for a single watchdog configuration for the entire system.
+  // Deprecated in favor of ``watchdogs`` which has finer granularity.
+  Watchdog watchdog = 8
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Optional watchdogs configuration.
+  // This is used for specifying different watchdogs for the different subsystems.
+  // [#extension-category: envoy.guarddog_actions]
+  Watchdogs watchdogs = 27;
+
+  // Configuration for an external tracing provider.
+  //
+  // .. attention::
+  //  This field has been deprecated in favor of :ref:`HttpConnectionManager.Tracing.provider
+  //  <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.Tracing.provider>`.
+  trace.v3.Tracing tracing = 9
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Configuration for the runtime configuration provider. If not
+  // specified, a “null” provider will be used which will result in all defaults
+  // being used.
+  LayeredRuntime layered_runtime = 17;
+
+  // Configuration for the local administration HTTP server.
+  Admin admin = 12;
+
+  // Optional overload manager configuration.
+  overload.v3.OverloadManager overload_manager = 15 [
+    (udpa.annotations.security).configure_for_untrusted_downstream = true,
+    (udpa.annotations.security).configure_for_untrusted_upstream = true
+  ];
+
+  // Enable :ref:`stats for event dispatcher <operations_performance>`, defaults to false.
+  // Note that this records a value for each iteration of the event loop on every thread. This
+  // should normally be minimal overhead, but when using
+  // :ref:`statsd <envoy_v3_api_msg_config.metrics.v3.StatsdSink>`, it will send each observed value
+  // over the wire individually because the statsd protocol doesn't have any way to represent a
+  // histogram summary. Be aware that this can be a very large volume of data.
+  bool enable_dispatcher_stats = 16;
+
+  // Optional string which will be used in lieu of x-envoy in prefixing headers.
+  //
+  // For example, if this string is present and set to X-Foo, then x-envoy-retry-on will be
+  // transformed into x-foo-retry-on etc.
+  //
+  // Note this applies to the headers Envoy will generate, the headers Envoy will sanitize, and the
+  // headers Envoy will trust for core code and core extensions only. Be VERY careful making
+  // changes to this string, especially in multi-layer Envoy deployments or deployments using
+  // extensions which are not upstream.
+  string header_prefix = 18;
+
+  // Optional proxy version which will be used to set the value of :ref:`server.version statistic
+  // <server_statistics>` if specified. Envoy will not process this value, it will be sent as is to
+  // :ref:`stats sinks <envoy_v3_api_msg_config.metrics.v3.StatsSink>`.
+  google.protobuf.UInt64Value stats_server_version_override = 19;
+
+  // Always use TCP queries instead of UDP queries for DNS lookups.
+  // This may be overridden on a per-cluster basis in cds_config,
+  // when :ref:`dns_resolvers <envoy_v3_api_field_config.cluster.v3.Cluster.dns_resolvers>` and
+  // :ref:`use_tcp_for_dns_lookups <envoy_v3_api_field_config.cluster.v3.Cluster.use_tcp_for_dns_lookups>` are
+  // specified.
+  // This field is deprecated in favor of ``dns_resolution_config``
+  // which aggregates all of the DNS resolver configuration in a single message.
+  bool use_tcp_for_dns_lookups = 20
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // DNS resolution configuration which includes the underlying dns resolver addresses and options.
+  // This may be overridden on a per-cluster basis in cds_config, when
+  // :ref:`dns_resolution_config <envoy_v3_api_field_config.cluster.v3.Cluster.dns_resolution_config>`
+  // is specified.
+  // This field is deprecated in favor of
+  // :ref:`typed_dns_resolver_config <envoy_v3_api_field_config.bootstrap.v3.Bootstrap.typed_dns_resolver_config>`.
+  core.v3.DnsResolutionConfig dns_resolution_config = 30
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // DNS resolver type configuration extension. This extension can be used to configure c-ares, apple,
+  // or any other DNS resolver types and the related parameters.
+  // For example, an object of
+  // :ref:`CaresDnsResolverConfig <envoy_v3_api_msg_extensions.network.dns_resolver.cares.v3.CaresDnsResolverConfig>`
+  // can be packed into this ``typed_dns_resolver_config``. This configuration replaces the
+  // :ref:`dns_resolution_config <envoy_v3_api_field_config.bootstrap.v3.Bootstrap.dns_resolution_config>`
+  // configuration.
+  // During the transition period when both ``dns_resolution_config`` and ``typed_dns_resolver_config`` exists,
+  // when ``typed_dns_resolver_config`` is in place, Envoy will use it and ignore ``dns_resolution_config``.
+  // When ``typed_dns_resolver_config`` is missing, the default behavior is in place.
+  // [#extension-category: envoy.network.dns_resolver]
+  core.v3.TypedExtensionConfig typed_dns_resolver_config = 31;
+
+  // Specifies optional bootstrap extensions to be instantiated at startup time.
+  // Each item contains extension specific configuration.
+  // [#extension-category: envoy.bootstrap]
+  repeated core.v3.TypedExtensionConfig bootstrap_extensions = 21;
+
+  // Specifies optional extensions instantiated at startup time and
+  // invoked during crash time on the request that caused the crash.
+  repeated FatalAction fatal_actions = 28;
+
+  // Configuration sources that will participate in
+  // xdstp:// URL authority resolution. The algorithm is as
+  // follows:
+  // 1. The authority field is taken from the xdstp:// URL, call
+  //    this ``resource_authority``.
+  // 2. ``resource_authority`` is compared against the authorities in any peer
+  //    ``ConfigSource``. The peer ``ConfigSource`` is the configuration source
+  //    message which would have been used unconditionally for resolution
+  //    with opaque resource names. If there is a match with an authority, the
+  //    peer ``ConfigSource`` message is used.
+  // 3. ``resource_authority`` is compared sequentially with the authorities in
+  //    each configuration source in ``config_sources``. The first ``ConfigSource``
+  //    to match wins.
+  // 4. As a fallback, if no configuration source matches, then
+  //    ``default_config_source`` is used.
+  // 5. If ``default_config_source`` is not specified, resolution fails.
+  // [#not-implemented-hide:]
+  repeated core.v3.ConfigSource config_sources = 22;
+
+  // Default configuration source for xdstp:// URLs if all
+  // other resolution fails.
+  // [#not-implemented-hide:]
+  core.v3.ConfigSource default_config_source = 23;
+
+  // Optional overriding of default socket interface. The value must be the name of one of the
+  // socket interface factories initialized through a bootstrap extension
+  string default_socket_interface = 24;
+
+  // Global map of CertificateProvider instances. These instances are referred to by name in the
+  // :ref:`CommonTlsContext.CertificateProviderInstance.instance_name
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CommonTlsContext.CertificateProviderInstance.instance_name>`
+  // field.
+  // [#not-implemented-hide:]
+  map<string, core.v3.TypedExtensionConfig> certificate_provider_instances = 25;
+
+  // Specifies a set of headers that need to be registered as inline header. This configuration
+  // allows users to customize the inline headers on-demand at Envoy startup without modifying
+  // Envoy's source code.
+  //
+  // Note that the 'set-cookie' header cannot be registered as inline header.
+  repeated CustomInlineHeader inline_headers = 32;
+
+  // Optional path to a file with performance tracing data created by "Perfetto" SDK in binary
+  // ProtoBuf format. The default value is "envoy.pftrace".
+  string perf_tracing_file_path = 33;
+
+  // Optional overriding of default regex engine.
+  // If the value is not specified, Google RE2 will be used by default.
+  // [#extension-category: envoy.regex_engines]
+  core.v3.TypedExtensionConfig default_regex_engine = 34;
+
+  // Optional XdsResourcesDelegate configuration, which allows plugging custom logic into both
+  // fetch and load events during xDS processing.
+  // If a value is not specified, no XdsResourcesDelegate will be used.
+  // TODO(abeyad): Add public-facing documentation.
+  // [#not-implemented-hide:]
+  core.v3.TypedExtensionConfig xds_delegate_extension = 35;
+
+  // Optional XdsConfigTracker configuration, which allows tracking xDS responses in external components,
+  // e.g., external tracer or monitor. It provides the process point when receive, ingest, or fail to
+  // process xDS resources and messages. If a value is not specified, no XdsConfigTracker will be used.
+  //
+  // .. note::
+  //
+  //    There are no in-repo extensions currently, and the :repo:`XdsConfigTracker <envoy/config/xds_config_tracker.h>`
+  //    interface should be implemented before using.
+  //    See :repo:`xds_config_tracker_integration_test <test/integration/xds_config_tracker_integration_test.cc>`
+  //    for an example usage of the interface.
+  core.v3.TypedExtensionConfig xds_config_tracker_extension = 36;
+
+  // [#not-implemented-hide:]
+  // This controls the type of listener manager configured for Envoy. Currently
+  // Envoy only supports ListenerManager for this field and Envoy Mobile
+  // supports ApiListenerManager.
+  core.v3.TypedExtensionConfig listener_manager = 37;
+
+  // Optional application log configuration.
+  ApplicationLogConfig application_log_config = 38;
+
+  // Optional gRPC async manager config.
+  GrpcAsyncClientManagerConfig grpc_async_client_manager_config = 40;
+
+  // Optional configuration for memory allocation manager.
+  // Memory releasing is only supported for `tcmalloc allocator <https://github.com/google/tcmalloc>`_.
+  MemoryAllocatorManager memory_allocator_manager = 41;
+}
+
+// Administration interface :ref:`operations documentation
+// <operations_admin_interface>`.
+// [#next-free-field: 7]
+message Admin {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.config.bootstrap.v2.Admin";
+
+  // Configuration for :ref:`access logs <arch_overview_access_logs>`
+  // emitted by the administration server.
+  repeated accesslog.v3.AccessLog access_log = 5;
+
+  // The path to write the access log for the administration server. If no
+  // access log is desired specify ‘/dev/null’. This is only required if
+  // :ref:`address <envoy_v3_api_field_config.bootstrap.v3.Admin.address>` is set.
+  // Deprecated in favor of ``access_log`` which offers more options.
+  string access_log_path = 1
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // The cpu profiler output path for the administration server. If no profile
+  // path is specified, the default is ‘/var/log/envoy/envoy.prof’.
+  string profile_path = 2;
+
+  // The TCP address that the administration server will listen on.
+  // If not specified, Envoy will not start an administration server.
+  core.v3.Address address = 3;
+
+  // Additional socket options that may not be present in Envoy source code or
+  // precompiled binaries.
+  repeated core.v3.SocketOption socket_options = 4;
+
+  // Indicates whether :ref:`global_downstream_max_connections <config_overload_manager_limiting_connections>`
+  // should apply to the admin interface or not.
+  bool ignore_global_conn_limit = 6;
+}
+
+// Cluster manager :ref:`architecture overview <arch_overview_cluster_manager>`.
+// [#next-free-field: 6]
+message ClusterManager {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.bootstrap.v2.ClusterManager";
+
+  message OutlierDetection {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.bootstrap.v2.ClusterManager.OutlierDetection";
+
+    // Specifies the path to the outlier event log.
+    string event_log_path = 1;
+
+    // [#not-implemented-hide:]
+    // The gRPC service for the outlier detection event service.
+    // If empty, outlier detection events won't be sent to a remote endpoint.
+    core.v3.EventServiceConfig event_service = 2;
+  }
+
+  // Name of the local cluster (i.e., the cluster that owns the Envoy running
+  // this configuration). In order to enable :ref:`zone aware routing
+  // <arch_overview_load_balancing_zone_aware_routing>` this option must be set.
+  // If ``local_cluster_name`` is defined then :ref:`clusters
+  // <envoy_v3_api_msg_config.cluster.v3.Cluster>` must be defined in the :ref:`Bootstrap
+  // static cluster resources
+  // <envoy_v3_api_field_config.bootstrap.v3.Bootstrap.StaticResources.clusters>`. This is unrelated to
+  // the :option:`--service-cluster` option which does not `affect zone aware
+  // routing <https://github.com/envoyproxy/envoy/issues/774>`_.
+  string local_cluster_name = 1;
+
+  // Optional global configuration for outlier detection.
+  OutlierDetection outlier_detection = 2;
+
+  // Optional configuration used to bind newly established upstream connections.
+  // This may be overridden on a per-cluster basis by upstream_bind_config in the cds_config.
+  core.v3.BindConfig upstream_bind_config = 3;
+
+  // A management server endpoint to stream load stats to via
+  // ``StreamLoadStats``. This must have :ref:`api_type
+  // <envoy_v3_api_field_config.core.v3.ApiConfigSource.api_type>` :ref:`GRPC
+  // <envoy_v3_api_enum_value_config.core.v3.ApiConfigSource.ApiType.GRPC>`.
+  core.v3.ApiConfigSource load_stats_config = 4;
+
+  // Whether the ClusterManager will create clusters on the worker threads
+  // inline during requests. This will save memory and CPU cycles in cases where
+  // there are lots of inactive clusters and > 1 worker thread.
+  bool enable_deferred_cluster_creation = 5;
+}
+
+// Allows you to specify different watchdog configs for different subsystems.
+// This allows finer tuned policies for the watchdog. If a subsystem is omitted
+// the default values for that system will be used.
+message Watchdogs {
+  // Watchdog for the main thread.
+  Watchdog main_thread_watchdog = 1;
+
+  // Watchdog for the worker threads.
+  Watchdog worker_watchdog = 2;
+}
+
+// Envoy process watchdog configuration. When configured, this monitors for
+// nonresponsive threads and kills the process after the configured thresholds.
+// See the :ref:`watchdog documentation <operations_performance_watchdog>` for more information.
+// [#next-free-field: 8]
+message Watchdog {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.config.bootstrap.v2.Watchdog";
+
+  message WatchdogAction {
+    // The events are fired in this order: KILL, MULTIKILL, MEGAMISS, MISS.
+    // Within an event type, actions execute in the order they are configured.
+    // For KILL/MULTIKILL there is a default PANIC that will run after the
+    // registered actions and kills the process if it wasn't already killed.
+    // It might be useful to specify several debug actions, and possibly an
+    // alternate FATAL action.
+    enum WatchdogEvent {
+      UNKNOWN = 0;
+      KILL = 1;
+      MULTIKILL = 2;
+      MEGAMISS = 3;
+      MISS = 4;
+    }
+
+    // Extension specific configuration for the action.
+    core.v3.TypedExtensionConfig config = 1;
+
+    WatchdogEvent event = 2 [(validate.rules).enum = {defined_only: true}];
+  }
+
+  // Register actions that will fire on given WatchDog events.
+  // See ``WatchDogAction`` for priority of events.
+  repeated WatchdogAction actions = 7;
+
+  // The duration after which Envoy counts a nonresponsive thread in the
+  // ``watchdog_miss`` statistic. If not specified the default is 200ms.
+  google.protobuf.Duration miss_timeout = 1;
+
+  // The duration after which Envoy counts a nonresponsive thread in the
+  // ``watchdog_mega_miss`` statistic. If not specified the default is
+  // 1000ms.
+  google.protobuf.Duration megamiss_timeout = 2;
+
+  // If a watched thread has been nonresponsive for this duration, assume a
+  // programming error and kill the entire Envoy process. Set to 0 to disable
+  // kill behavior. If not specified the default is 0 (disabled).
+  google.protobuf.Duration kill_timeout = 3;
+
+  // Defines the maximum jitter used to adjust the ``kill_timeout`` if ``kill_timeout`` is
+  // enabled. Enabling this feature would help to reduce risk of synchronized
+  // watchdog kill events across proxies due to external triggers. Set to 0 to
+  // disable. If not specified the default is 0 (disabled).
+  google.protobuf.Duration max_kill_timeout_jitter = 6 [(validate.rules).duration = {gte {}}];
+
+  // If ``max(2, ceil(registered_threads * Fraction(*multikill_threshold*)))``
+  // threads have been nonresponsive for at least this duration kill the entire
+  // Envoy process. Set to 0 to disable this behavior. If not specified the
+  // default is 0 (disabled).
+  google.protobuf.Duration multikill_timeout = 4;
+
+  // Sets the threshold for ``multikill_timeout`` in terms of the percentage of
+  // nonresponsive threads required for the ``multikill_timeout``.
+  // If not specified the default is 0.
+  type.v3.Percent multikill_threshold = 5;
+}
+
+// Fatal actions to run while crashing. Actions can be safe (meaning they are
+// async-signal safe) or unsafe. We run all safe actions before we run unsafe actions.
+// If using an unsafe action that could get stuck or deadlock, it important to
+// have an out of band system to terminate the process.
+//
+// The interface for the extension is ``Envoy::Server::Configuration::FatalAction``.
+// ``FatalAction`` extensions live in the ``envoy.extensions.fatal_actions`` API
+// namespace.
+message FatalAction {
+  // Extension specific configuration for the action. It's expected to conform
+  // to the ``Envoy::Server::Configuration::FatalAction`` interface.
+  core.v3.TypedExtensionConfig config = 1;
+}
+
+// Runtime :ref:`configuration overview <config_runtime>` (deprecated).
+message Runtime {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.config.bootstrap.v2.Runtime";
+
+  // The implementation assumes that the file system tree is accessed via a
+  // symbolic link. An atomic link swap is used when a new tree should be
+  // switched to. This parameter specifies the path to the symbolic link. Envoy
+  // will watch the location for changes and reload the file system tree when
+  // they happen. If this parameter is not set, there will be no disk based
+  // runtime.
+  string symlink_root = 1;
+
+  // Specifies the subdirectory to load within the root directory. This is
+  // useful if multiple systems share the same delivery mechanism. Envoy
+  // configuration elements can be contained in a dedicated subdirectory.
+  string subdirectory = 2;
+
+  // Specifies an optional subdirectory to load within the root directory. If
+  // specified and the directory exists, configuration values within this
+  // directory will override those found in the primary subdirectory. This is
+  // useful when Envoy is deployed across many different types of servers.
+  // Sometimes it is useful to have a per service cluster directory for runtime
+  // configuration. See below for exactly how the override directory is used.
+  string override_subdirectory = 3;
+
+  // Static base runtime. This will be :ref:`overridden
+  // <config_runtime_layering>` by other runtime layers, e.g.
+  // disk or admin. This follows the :ref:`runtime protobuf JSON representation
+  // encoding <config_runtime_proto_json>`.
+  google.protobuf.Struct base = 4;
+}
+
+// [#next-free-field: 6]
+message RuntimeLayer {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.bootstrap.v2.RuntimeLayer";
+
+  // :ref:`Disk runtime <config_runtime_local_disk>` layer.
+  message DiskLayer {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.bootstrap.v2.RuntimeLayer.DiskLayer";
+
+    // The implementation assumes that the file system tree is accessed via a
+    // symbolic link. An atomic link swap is used when a new tree should be
+    // switched to. This parameter specifies the path to the symbolic link.
+    // Envoy will watch the location for changes and reload the file system tree
+    // when they happen. See documentation on runtime :ref:`atomicity
+    // <config_runtime_atomicity>` for further details on how reloads are
+    // treated.
+    string symlink_root = 1;
+
+    // Specifies the subdirectory to load within the root directory. This is
+    // useful if multiple systems share the same delivery mechanism. Envoy
+    // configuration elements can be contained in a dedicated subdirectory.
+    string subdirectory = 3;
+
+    // :ref:`Append <config_runtime_local_disk_service_cluster_subdirs>` the
+    // service cluster to the path under symlink root.
+    bool append_service_cluster = 2;
+  }
+
+  // :ref:`Admin console runtime <config_runtime_admin>` layer.
+  message AdminLayer {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.bootstrap.v2.RuntimeLayer.AdminLayer";
+  }
+
+  // :ref:`Runtime Discovery Service (RTDS) <config_runtime_rtds>` layer.
+  message RtdsLayer {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.bootstrap.v2.RuntimeLayer.RtdsLayer";
+
+    // Resource to subscribe to at ``rtds_config`` for the RTDS layer.
+    string name = 1;
+
+    // RTDS configuration source.
+    core.v3.ConfigSource rtds_config = 2;
+  }
+
+  // Descriptive name for the runtime layer. This is only used for the runtime
+  // :http:get:`/runtime` output.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  oneof layer_specifier {
+    option (validate.required) = true;
+
+    // :ref:`Static runtime <config_runtime_bootstrap>` layer.
+    // This follows the :ref:`runtime protobuf JSON representation encoding
+    // <config_runtime_proto_json>`. Unlike static xDS resources, this static
+    // layer is overridable by later layers in the runtime virtual filesystem.
+    google.protobuf.Struct static_layer = 2;
+
+    DiskLayer disk_layer = 3;
+
+    AdminLayer admin_layer = 4;
+
+    RtdsLayer rtds_layer = 5;
+  }
+}
+
+// Runtime :ref:`configuration overview <config_runtime>`.
+message LayeredRuntime {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.bootstrap.v2.LayeredRuntime";
+
+  // The :ref:`layers <config_runtime_layering>` of the runtime. This is ordered
+  // such that later layers in the list overlay earlier entries.
+  repeated RuntimeLayer layers = 1;
+}
+
+// Used to specify the header that needs to be registered as an inline header.
+//
+// If request or response contain multiple headers with the same name and the header
+// name is registered as an inline header. Then multiple headers will be folded
+// into one, and multiple header values will be concatenated by a suitable delimiter.
+// The delimiter is generally a comma.
+//
+// For example, if 'foo' is registered as an inline header, and the headers contains
+// the following two headers:
+//
+// .. code-block:: text
+//
+//   foo: bar
+//   foo: eep
+//
+// Then they will eventually be folded into:
+//
+// .. code-block:: text
+//
+//   foo: bar, eep
+//
+// Inline headers provide O(1) search performance, but each inline header imposes
+// an additional memory overhead on all instances of the corresponding type of
+// HeaderMap or TrailerMap.
+message CustomInlineHeader {
+  enum InlineHeaderType {
+    REQUEST_HEADER = 0;
+    REQUEST_TRAILER = 1;
+    RESPONSE_HEADER = 2;
+    RESPONSE_TRAILER = 3;
+  }
+
+  // The name of the header that is expected to be set as the inline header.
+  string inline_header_name = 1
+      [(validate.rules).string = {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}];
+
+  // The type of the header that is expected to be set as the inline header.
+  InlineHeaderType inline_header_type = 2 [(validate.rules).enum = {defined_only: true}];
+}
+
+message MemoryAllocatorManager {
+  // Configures tcmalloc to perform background release of free memory in amount of bytes per ``memory_release_interval`` interval.
+  // If equals to ``0``, no memory release will occur. Defaults to ``0``.
+  uint64 bytes_to_release = 1;
+
+  // Interval in milliseconds for memory releasing. If specified, during every
+  // interval Envoy will try to release ``bytes_to_release`` of free memory back to operating system for reuse.
+  // Defaults to 1000 milliseconds.
+  google.protobuf.Duration memory_release_interval = 2;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/cluster/v3/circuit_breaker.proto b/xds/third_party/envoy/src/main/proto/envoy/config/cluster/v3/circuit_breaker.proto
new file mode 100644
index 00000000000..fe798ceb090
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/cluster/v3/circuit_breaker.proto
@@ -0,0 +1,121 @@
+syntax = "proto3";
+
+package envoy.config.cluster.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/type/v3/percent.proto";
+
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.cluster.v3";
+option java_outer_classname = "CircuitBreakerProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/cluster/v3;clusterv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Circuit breakers]
+
+// :ref:`Circuit breaking<arch_overview_circuit_break>` settings can be
+// specified individually for each defined priority.
+message CircuitBreakers {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.cluster.CircuitBreakers";
+
+  // A Thresholds defines CircuitBreaker settings for a
+  // :ref:`RoutingPriority<envoy_v3_api_enum_config.core.v3.RoutingPriority>`.
+  // [#next-free-field: 9]
+  message Thresholds {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.cluster.CircuitBreakers.Thresholds";
+
+    message RetryBudget {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.cluster.CircuitBreakers.Thresholds.RetryBudget";
+
+      // Specifies the limit on concurrent retries as a percentage of the sum of active requests and
+      // active pending requests. For example, if there are 100 active requests and the
+      // budget_percent is set to 25, there may be 25 active retries.
+      //
+      // This parameter is optional. Defaults to 20%.
+      type.v3.Percent budget_percent = 1;
+
+      // Specifies the minimum retry concurrency allowed for the retry budget. The limit on the
+      // number of active retries may never go below this number.
+      //
+      // This parameter is optional. Defaults to 3.
+      google.protobuf.UInt32Value min_retry_concurrency = 2;
+    }
+
+    // The :ref:`RoutingPriority<envoy_v3_api_enum_config.core.v3.RoutingPriority>`
+    // the specified CircuitBreaker settings apply to.
+    core.v3.RoutingPriority priority = 1 [(validate.rules).enum = {defined_only: true}];
+
+    // The maximum number of connections that Envoy will make to the upstream
+    // cluster. If not specified, the default is 1024.
+    google.protobuf.UInt32Value max_connections = 2;
+
+    // The maximum number of pending requests that Envoy will allow to the
+    // upstream cluster. If not specified, the default is 1024.
+    // This limit is applied as a connection limit for non-HTTP traffic.
+    google.protobuf.UInt32Value max_pending_requests = 3;
+
+    // The maximum number of parallel requests that Envoy will make to the
+    // upstream cluster. If not specified, the default is 1024.
+    // This limit does not apply to non-HTTP traffic.
+    google.protobuf.UInt32Value max_requests = 4;
+
+    // The maximum number of parallel retries that Envoy will allow to the
+    // upstream cluster. If not specified, the default is 3.
+    google.protobuf.UInt32Value max_retries = 5;
+
+    // Specifies a limit on concurrent retries in relation to the number of active requests. This
+    // parameter is optional.
+    //
+    // .. note::
+    //
+    //    If this field is set, the retry budget will override any configured retry circuit
+    //    breaker.
+    RetryBudget retry_budget = 8;
+
+    // If track_remaining is true, then stats will be published that expose
+    // the number of resources remaining until the circuit breakers open. If
+    // not specified, the default is false.
+    //
+    // .. note::
+    //
+    //    If a retry budget is used in lieu of the max_retries circuit breaker,
+    //    the remaining retry resources remaining will not be tracked.
+    bool track_remaining = 6;
+
+    // The maximum number of connection pools per cluster that Envoy will concurrently support at
+    // once. If not specified, the default is unlimited. Set this for clusters which create a
+    // large number of connection pools. See
+    // :ref:`Circuit Breaking <arch_overview_circuit_break_cluster_maximum_connection_pools>` for
+    // more details.
+    google.protobuf.UInt32Value max_connection_pools = 7;
+  }
+
+  // If multiple :ref:`Thresholds<envoy_v3_api_msg_config.cluster.v3.CircuitBreakers.Thresholds>`
+  // are defined with the same :ref:`RoutingPriority<envoy_v3_api_enum_config.core.v3.RoutingPriority>`,
+  // the first one in the list is used. If no Thresholds is defined for a given
+  // :ref:`RoutingPriority<envoy_v3_api_enum_config.core.v3.RoutingPriority>`, the default values
+  // are used.
+  repeated Thresholds thresholds = 1;
+
+  // Optional per-host limits which apply to each individual host in a cluster.
+  //
+  // .. note::
+  //  currently only the :ref:`max_connections
+  //  <envoy_v3_api_field_config.cluster.v3.CircuitBreakers.Thresholds.max_connections>` field is supported for per-host limits.
+  //
+  // If multiple per-host :ref:`Thresholds<envoy_v3_api_msg_config.cluster.v3.CircuitBreakers.Thresholds>`
+  // are defined with the same :ref:`RoutingPriority<envoy_v3_api_enum_config.core.v3.RoutingPriority>`,
+  // the first one in the list is used. If no per-host Thresholds are defined for a given
+  // :ref:`RoutingPriority<envoy_v3_api_enum_config.core.v3.RoutingPriority>`,
+  // the cluster will not have per-host limits.
+  repeated Thresholds per_host_thresholds = 2;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/cluster/v3/cluster.proto b/xds/third_party/envoy/src/main/proto/envoy/config/cluster/v3/cluster.proto
new file mode 100644
index 00000000000..c5112458a71
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/cluster/v3/cluster.proto
@@ -0,0 +1,1368 @@
+syntax = "proto3";
+
+package envoy.config.cluster.v3;
+
+import "envoy/config/cluster/v3/circuit_breaker.proto";
+import "envoy/config/cluster/v3/filter.proto";
+import "envoy/config/cluster/v3/outlier_detection.proto";
+import "envoy/config/core/v3/address.proto";
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/config_source.proto";
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/core/v3/health_check.proto";
+import "envoy/config/core/v3/protocol.proto";
+import "envoy/config/core/v3/resolver.proto";
+import "envoy/config/endpoint/v3/endpoint.proto";
+import "envoy/type/metadata/v3/metadata.proto";
+import "envoy/type/v3/percent.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/struct.proto";
+import "google/protobuf/wrappers.proto";
+
+import "xds/core/v3/collection_entry.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/security.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.cluster.v3";
+option java_outer_classname = "ClusterProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/cluster/v3;clusterv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Cluster configuration]
+
+// Cluster list collections. Entries are ``Cluster`` resources or references.
+// [#not-implemented-hide:]
+message ClusterCollection {
+  xds.core.v3.CollectionEntry entries = 1;
+}
+
+// Configuration for a single upstream cluster.
+// [#next-free-field: 59]
+message Cluster {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.Cluster";
+
+  // Refer to :ref:`service discovery type <arch_overview_service_discovery_types>`
+  // for an explanation on each type.
+  enum DiscoveryType {
+    // Refer to the :ref:`static discovery type<arch_overview_service_discovery_types_static>`
+    // for an explanation.
+    STATIC = 0;
+
+    // Refer to the :ref:`strict DNS discovery
+    // type<arch_overview_service_discovery_types_strict_dns>`
+    // for an explanation.
+    STRICT_DNS = 1;
+
+    // Refer to the :ref:`logical DNS discovery
+    // type<arch_overview_service_discovery_types_logical_dns>`
+    // for an explanation.
+    LOGICAL_DNS = 2;
+
+    // Refer to the :ref:`service discovery type<arch_overview_service_discovery_types_eds>`
+    // for an explanation.
+    EDS = 3;
+
+    // Refer to the :ref:`original destination discovery
+    // type<arch_overview_service_discovery_types_original_destination>`
+    // for an explanation.
+    ORIGINAL_DST = 4;
+  }
+
+  // Refer to :ref:`load balancer type <arch_overview_load_balancing_types>` architecture
+  // overview section for information on each type.
+  enum LbPolicy {
+    reserved 4;
+
+    reserved "ORIGINAL_DST_LB";
+
+    // Refer to the :ref:`round robin load balancing
+    // policy<arch_overview_load_balancing_types_round_robin>`
+    // for an explanation.
+    ROUND_ROBIN = 0;
+
+    // Refer to the :ref:`least request load balancing
+    // policy<arch_overview_load_balancing_types_least_request>`
+    // for an explanation.
+    LEAST_REQUEST = 1;
+
+    // Refer to the :ref:`ring hash load balancing
+    // policy<arch_overview_load_balancing_types_ring_hash>`
+    // for an explanation.
+    RING_HASH = 2;
+
+    // Refer to the :ref:`random load balancing
+    // policy<arch_overview_load_balancing_types_random>`
+    // for an explanation.
+    RANDOM = 3;
+
+    // Refer to the :ref:`Maglev load balancing policy<arch_overview_load_balancing_types_maglev>`
+    // for an explanation.
+    MAGLEV = 5;
+
+    // This load balancer type must be specified if the configured cluster provides a cluster
+    // specific load balancer. Consult the configured cluster's documentation for whether to set
+    // this option or not.
+    CLUSTER_PROVIDED = 6;
+
+    // Use the new :ref:`load_balancing_policy
+    // <envoy_v3_api_field_config.cluster.v3.Cluster.load_balancing_policy>` field to determine the LB policy.
+    // This has been deprecated in favor of using the :ref:`load_balancing_policy
+    // <envoy_v3_api_field_config.cluster.v3.Cluster.load_balancing_policy>` field without
+    // setting any value in :ref:`lb_policy<envoy_v3_api_field_config.cluster.v3.Cluster.lb_policy>`.
+    LOAD_BALANCING_POLICY_CONFIG = 7;
+  }
+
+  // When V4_ONLY is selected, the DNS resolver will only perform a lookup for
+  // addresses in the IPv4 family. If V6_ONLY is selected, the DNS resolver will
+  // only perform a lookup for addresses in the IPv6 family. If AUTO is
+  // specified, the DNS resolver will first perform a lookup for addresses in
+  // the IPv6 family and fallback to a lookup for addresses in the IPv4 family.
+  // This is semantically equivalent to a non-existent V6_PREFERRED option.
+  // AUTO is a legacy name that is more opaque than
+  // necessary and will be deprecated in favor of V6_PREFERRED in a future major version of the API.
+  // If V4_PREFERRED is specified, the DNS resolver will first perform a lookup for addresses in the
+  // IPv4 family and fallback to a lookup for addresses in the IPv6 family. i.e., the callback
+  // target will only get v6 addresses if there were NO v4 addresses to return.
+  // If ALL is specified, the DNS resolver will perform a lookup for both IPv4 and IPv6 families,
+  // and return all resolved addresses. When this is used, Happy Eyeballs will be enabled for
+  // upstream connections. Refer to :ref:`Happy Eyeballs Support <arch_overview_happy_eyeballs>`
+  // for more information.
+  // For cluster types other than
+  // :ref:`STRICT_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>` and
+  // :ref:`LOGICAL_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`,
+  // this setting is
+  // ignored.
+  // [#next-major-version: deprecate AUTO in favor of a V6_PREFERRED option.]
+  enum DnsLookupFamily {
+    AUTO = 0;
+    V4_ONLY = 1;
+    V6_ONLY = 2;
+    V4_PREFERRED = 3;
+    ALL = 4;
+  }
+
+  enum ClusterProtocolSelection {
+    // Cluster can only operate on one of the possible upstream protocols (HTTP1.1, HTTP2).
+    // If :ref:`http2_protocol_options <envoy_v3_api_field_config.cluster.v3.Cluster.http2_protocol_options>` are
+    // present, HTTP2 will be used, otherwise HTTP1.1 will be used.
+    USE_CONFIGURED_PROTOCOL = 0;
+
+    // Use HTTP1.1 or HTTP2, depending on which one is used on the downstream connection.
+    USE_DOWNSTREAM_PROTOCOL = 1;
+  }
+
+  // TransportSocketMatch specifies what transport socket config will be used
+  // when the match conditions are satisfied.
+  message TransportSocketMatch {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.Cluster.TransportSocketMatch";
+
+    // The name of the match, used in stats generation.
+    string name = 1 [(validate.rules).string = {min_len: 1}];
+
+    // Optional metadata match criteria.
+    // The connection to the endpoint with metadata matching what is set in this field
+    // will use the transport socket configuration specified here.
+    // The endpoint's metadata entry in ``envoy.transport_socket_match`` is used to match
+    // against the values specified in this field.
+    google.protobuf.Struct match = 2;
+
+    // The configuration of the transport socket.
+    // [#extension-category: envoy.transport_sockets.upstream]
+    core.v3.TransportSocket transport_socket = 3;
+  }
+
+  // Extended cluster type.
+  message CustomClusterType {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.Cluster.CustomClusterType";
+
+    // The type of the cluster to instantiate. The name must match a supported cluster type.
+    string name = 1 [(validate.rules).string = {min_len: 1}];
+
+    // Cluster specific configuration which depends on the cluster being instantiated.
+    // See the supported cluster for further documentation.
+    // [#extension-category: envoy.clusters]
+    google.protobuf.Any typed_config = 2;
+  }
+
+  // Only valid when discovery type is EDS.
+  message EdsClusterConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.Cluster.EdsClusterConfig";
+
+    // Configuration for the source of EDS updates for this Cluster.
+    core.v3.ConfigSource eds_config = 1;
+
+    // Optional alternative to cluster name to present to EDS. This does not
+    // have the same restrictions as cluster name, i.e. it may be arbitrary
+    // length. This may be a xdstp:// URL.
+    string service_name = 2;
+  }
+
+  // Optionally divide the endpoints in this cluster into subsets defined by
+  // endpoint metadata and selected by route and weighted cluster metadata.
+  // [#next-free-field: 9]
+  message LbSubsetConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.Cluster.LbSubsetConfig";
+
+    // If NO_FALLBACK is selected, a result
+    // equivalent to no healthy hosts is reported. If ANY_ENDPOINT is selected,
+    // any cluster endpoint may be returned (subject to policy, health checks,
+    // etc). If DEFAULT_SUBSET is selected, load balancing is performed over the
+    // endpoints matching the values from the default_subset field.
+    enum LbSubsetFallbackPolicy {
+      NO_FALLBACK = 0;
+      ANY_ENDPOINT = 1;
+      DEFAULT_SUBSET = 2;
+    }
+
+    enum LbSubsetMetadataFallbackPolicy {
+      // No fallback. Route metadata will be used as-is.
+      METADATA_NO_FALLBACK = 0;
+
+      // A special metadata key ``fallback_list`` will be used to provide variants of metadata to try.
+      // Value of ``fallback_list`` key has to be a list. Every list element has to be a struct - it will
+      // be merged with route metadata, overriding keys that appear in both places.
+      // ``fallback_list`` entries will be used in order until a host is found.
+      //
+      // ``fallback_list`` key itself is removed from metadata before subset load balancing is performed.
+      //
+      // Example:
+      //
+      // for metadata:
+      //
+      // .. code-block:: yaml
+      //
+      //   version: 1.0
+      //   fallback_list:
+      //     - version: 2.0
+      //       hardware: c64
+      //     - hardware: c32
+      //     - version: 3.0
+      //
+      // at first, metadata:
+      //
+      // .. code-block:: json
+      //
+      //   {"version": "2.0", "hardware": "c64"}
+      //
+      // will be used for load balancing. If no host is found, metadata:
+      //
+      // .. code-block:: json
+      //
+      //   {"version": "1.0", "hardware": "c32"}
+      //
+      // is next to try. If it still results in no host, finally metadata:
+      //
+      // .. code-block:: json
+      //
+      //   {"version": "3.0"}
+      //
+      // is used.
+      FALLBACK_LIST = 1;
+    }
+
+    // Specifications for subsets.
+    message LbSubsetSelector {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.Cluster.LbSubsetConfig.LbSubsetSelector";
+
+      // Allows to override top level fallback policy per selector.
+      enum LbSubsetSelectorFallbackPolicy {
+        // If NOT_DEFINED top level config fallback policy is used instead.
+        NOT_DEFINED = 0;
+
+        // If NO_FALLBACK is selected, a result equivalent to no healthy hosts is reported.
+        NO_FALLBACK = 1;
+
+        // If ANY_ENDPOINT is selected, any cluster endpoint may be returned
+        // (subject to policy, health checks, etc).
+        ANY_ENDPOINT = 2;
+
+        // If DEFAULT_SUBSET is selected, load balancing is performed over the
+        // endpoints matching the values from the default_subset field.
+        DEFAULT_SUBSET = 3;
+
+        // If KEYS_SUBSET is selected, subset selector matching is performed again with metadata
+        // keys reduced to
+        // :ref:`fallback_keys_subset<envoy_v3_api_field_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetSelector.fallback_keys_subset>`.
+        // It allows for a fallback to a different, less specific selector if some of the keys of
+        // the selector are considered optional.
+        KEYS_SUBSET = 4;
+      }
+
+      // List of keys to match with the weighted cluster metadata.
+      repeated string keys = 1;
+
+      // Selects a mode of operation in which each subset has only one host. This mode uses the same rules for
+      // choosing a host, but updating hosts is faster, especially for large numbers of hosts.
+      //
+      // If a match is found to a host, that host will be used regardless of priority levels.
+      //
+      // When this mode is enabled, configurations that contain more than one host with the same metadata value for the single key in ``keys``
+      // will use only one of the hosts with the given key; no requests will be routed to the others. The cluster gauge
+      // :ref:`lb_subsets_single_host_per_subset_duplicate<config_cluster_manager_cluster_stats_subset_lb>` indicates how many duplicates are
+      // present in the current configuration.
+      bool single_host_per_subset = 4;
+
+      // The behavior used when no endpoint subset matches the selected route's
+      // metadata.
+      LbSubsetSelectorFallbackPolicy fallback_policy = 2
+          [(validate.rules).enum = {defined_only: true}];
+
+      // Subset of
+      // :ref:`keys<envoy_v3_api_field_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetSelector.keys>` used by
+      // :ref:`KEYS_SUBSET<envoy_v3_api_enum_value_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetSelector.LbSubsetSelectorFallbackPolicy.KEYS_SUBSET>`
+      // fallback policy.
+      // It has to be a non empty list if KEYS_SUBSET fallback policy is selected.
+      // For any other fallback policy the parameter is not used and should not be set.
+      // Only values also present in
+      // :ref:`keys<envoy_v3_api_field_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetSelector.keys>` are allowed, but
+      // ``fallback_keys_subset`` cannot be equal to ``keys``.
+      repeated string fallback_keys_subset = 3;
+    }
+
+    // The behavior used when no endpoint subset matches the selected route's
+    // metadata. The value defaults to
+    // :ref:`NO_FALLBACK<envoy_v3_api_enum_value_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetFallbackPolicy.NO_FALLBACK>`.
+    LbSubsetFallbackPolicy fallback_policy = 1 [(validate.rules).enum = {defined_only: true}];
+
+    // Specifies the default subset of endpoints used during fallback if
+    // fallback_policy is
+    // :ref:`DEFAULT_SUBSET<envoy_v3_api_enum_value_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetFallbackPolicy.DEFAULT_SUBSET>`.
+    // Each field in default_subset is
+    // compared to the matching LbEndpoint.Metadata under the ``envoy.lb``
+    // namespace. It is valid for no hosts to match, in which case the behavior
+    // is the same as a fallback_policy of
+    // :ref:`NO_FALLBACK<envoy_v3_api_enum_value_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetFallbackPolicy.NO_FALLBACK>`.
+    google.protobuf.Struct default_subset = 2;
+
+    // For each entry, LbEndpoint.Metadata's
+    // ``envoy.lb`` namespace is traversed and a subset is created for each unique
+    // combination of key and value. For example:
+    //
+    // .. code-block:: json
+    //
+    //   { "subset_selectors": [
+    //       { "keys": [ "version" ] },
+    //       { "keys": [ "stage", "hardware_type" ] }
+    //   ]}
+    //
+    // A subset is matched when the metadata from the selected route and
+    // weighted cluster contains the same keys and values as the subset's
+    // metadata. The same host may appear in multiple subsets.
+    repeated LbSubsetSelector subset_selectors = 3;
+
+    // If true, routing to subsets will take into account the localities and locality weights of the
+    // endpoints when making the routing decision.
+    //
+    // There are some potential pitfalls associated with enabling this feature, as the resulting
+    // traffic split after applying both a subset match and locality weights might be undesirable.
+    //
+    // Consider for example a situation in which you have 50/50 split across two localities X/Y
+    // which have 100 hosts each without subsetting. If the subset LB results in X having only 1
+    // host selected but Y having 100, then a lot more load is being dumped on the single host in X
+    // than originally anticipated in the load balancing assignment delivered via EDS.
+    bool locality_weight_aware = 4;
+
+    // When used with locality_weight_aware, scales the weight of each locality by the ratio
+    // of hosts in the subset vs hosts in the original subset. This aims to even out the load
+    // going to an individual locality if said locality is disproportionately affected by the
+    // subset predicate.
+    bool scale_locality_weight = 5;
+
+    // If true, when a fallback policy is configured and its corresponding subset fails to find
+    // a host this will cause any host to be selected instead.
+    //
+    // This is useful when using the default subset as the fallback policy, given the default
+    // subset might become empty. With this option enabled, if that happens the LB will attempt
+    // to select a host from the entire cluster.
+    bool panic_mode_any = 6;
+
+    // If true, metadata specified for a metadata key will be matched against the corresponding
+    // endpoint metadata if the endpoint metadata matches the value exactly OR it is a list value
+    // and any of the elements in the list matches the criteria.
+    bool list_as_any = 7;
+
+    // Fallback mechanism that allows to try different route metadata until a host is found.
+    // If load balancing process, including all its mechanisms (like
+    // :ref:`fallback_policy<envoy_v3_api_field_config.cluster.v3.Cluster.LbSubsetConfig.fallback_policy>`)
+    // fails to select a host, this policy decides if and how the process is repeated using another metadata.
+    //
+    // The value defaults to
+    // :ref:`METADATA_NO_FALLBACK<envoy_v3_api_enum_value_config.cluster.v3.Cluster.LbSubsetConfig.LbSubsetMetadataFallbackPolicy.METADATA_NO_FALLBACK>`.
+    LbSubsetMetadataFallbackPolicy metadata_fallback_policy = 8
+        [(validate.rules).enum = {defined_only: true}];
+  }
+
+  // Configuration for :ref:`slow start mode <arch_overview_load_balancing_slow_start>`.
+  message SlowStartConfig {
+    // Represents the size of slow start window.
+    // If set, the newly created host remains in slow start mode starting from its creation time
+    // for the duration of slow start window.
+    google.protobuf.Duration slow_start_window = 1;
+
+    // This parameter controls the speed of traffic increase over the slow start window. Defaults to 1.0,
+    // so that endpoint would get linearly increasing amount of traffic.
+    // When increasing the value for this parameter, the speed of traffic ramp-up increases non-linearly.
+    // The value of aggression parameter should be greater than 0.0.
+    // By tuning the parameter, is possible to achieve polynomial or exponential shape of ramp-up curve.
+    //
+    // During slow start window, effective weight of an endpoint would be scaled with time factor and aggression:
+    // ``new_weight = weight * max(min_weight_percent, time_factor ^ (1 / aggression))``,
+    // where ``time_factor=(time_since_start_seconds / slow_start_time_seconds)``.
+    //
+    // As time progresses, more and more traffic would be sent to endpoint, which is in slow start window.
+    // Once host exits slow start, time_factor and aggression no longer affect its weight.
+    core.v3.RuntimeDouble aggression = 2;
+
+    // Configures the minimum percentage of origin weight that avoids too small new weight,
+    // which may cause endpoints in slow start mode receive no traffic in slow start window.
+    // If not specified, the default is 10%.
+    type.v3.Percent min_weight_percent = 3;
+  }
+
+  // Specific configuration for the RoundRobin load balancing policy.
+  message RoundRobinLbConfig {
+    // Configuration for slow start mode.
+    // If this configuration is not set, slow start will not be not enabled.
+    SlowStartConfig slow_start_config = 1;
+  }
+
+  // Specific configuration for the LeastRequest load balancing policy.
+  message LeastRequestLbConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.Cluster.LeastRequestLbConfig";
+
+    // The number of random healthy hosts from which the host with the fewest active requests will
+    // be chosen. Defaults to 2 so that we perform two-choice selection if the field is not set.
+    google.protobuf.UInt32Value choice_count = 1 [(validate.rules).uint32 = {gte: 2}];
+
+    // The following formula is used to calculate the dynamic weights when hosts have different load
+    // balancing weights:
+    //
+    // ``weight = load_balancing_weight / (active_requests + 1)^active_request_bias``
+    //
+    // The larger the active request bias is, the more aggressively active requests will lower the
+    // effective weight when all host weights are not equal.
+    //
+    // ``active_request_bias`` must be greater than or equal to 0.0.
+    //
+    // When ``active_request_bias == 0.0`` the Least Request Load Balancer doesn't consider the number
+    // of active requests at the time it picks a host and behaves like the Round Robin Load
+    // Balancer.
+    //
+    // When ``active_request_bias > 0.0`` the Least Request Load Balancer scales the load balancing
+    // weight by the number of active requests at the time it does a pick.
+    //
+    // The value is cached for performance reasons and refreshed whenever one of the Load Balancer's
+    // host sets changes, e.g., whenever there is a host membership update or a host load balancing
+    // weight change.
+    //
+    // .. note::
+    //   This setting only takes effect if all host weights are not equal.
+    core.v3.RuntimeDouble active_request_bias = 2;
+
+    // Configuration for slow start mode.
+    // If this configuration is not set, slow start will not be not enabled.
+    SlowStartConfig slow_start_config = 3;
+  }
+
+  // Specific configuration for the :ref:`RingHash<arch_overview_load_balancing_types_ring_hash>`
+  // load balancing policy.
+  message RingHashLbConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.Cluster.RingHashLbConfig";
+
+    // The hash function used to hash hosts onto the ketama ring.
+    enum HashFunction {
+      // Use `xxHash <https://github.com/Cyan4973/xxHash>`_, this is the default hash function.
+      XX_HASH = 0;
+
+      // Use `MurmurHash2 <https://sites.google.com/site/murmurhash/>`_, this is compatible with
+      // std:hash<string> in GNU libstdc++ 3.4.20 or above. This is typically the case when compiled
+      // on Linux and not macOS.
+      MURMUR_HASH_2 = 1;
+    }
+
+    reserved 2;
+
+    // Minimum hash ring size. The larger the ring is (that is, the more hashes there are for each
+    // provided host) the better the request distribution will reflect the desired weights. Defaults
+    // to 1024 entries, and limited to 8M entries. See also
+    // :ref:`maximum_ring_size<envoy_v3_api_field_config.cluster.v3.Cluster.RingHashLbConfig.maximum_ring_size>`.
+    google.protobuf.UInt64Value minimum_ring_size = 1 [(validate.rules).uint64 = {lte: 8388608}];
+
+    // The hash function used to hash hosts onto the ketama ring. The value defaults to
+    // :ref:`XX_HASH<envoy_v3_api_enum_value_config.cluster.v3.Cluster.RingHashLbConfig.HashFunction.XX_HASH>`.
+    HashFunction hash_function = 3 [(validate.rules).enum = {defined_only: true}];
+
+    // Maximum hash ring size. Defaults to 8M entries, and limited to 8M entries, but can be lowered
+    // to further constrain resource use. See also
+    // :ref:`minimum_ring_size<envoy_v3_api_field_config.cluster.v3.Cluster.RingHashLbConfig.minimum_ring_size>`.
+    google.protobuf.UInt64Value maximum_ring_size = 4 [(validate.rules).uint64 = {lte: 8388608}];
+  }
+
+  // Specific configuration for the :ref:`Maglev<arch_overview_load_balancing_types_maglev>`
+  // load balancing policy.
+  message MaglevLbConfig {
+    // The table size for Maglev hashing. Maglev aims for "minimal disruption" rather than an absolute guarantee.
+    // Minimal disruption means that when the set of upstream hosts change, a connection will likely be sent to the same
+    // upstream as it was before. Increasing the table size reduces the amount of disruption.
+    // The table size must be prime number limited to 5000011. If it is not specified, the default is 65537.
+    google.protobuf.UInt64Value table_size = 1 [(validate.rules).uint64 = {lte: 5000011}];
+  }
+
+  // Specific configuration for the
+  // :ref:`Original Destination <arch_overview_load_balancing_types_original_destination>`
+  // load balancing policy.
+  // [#extension: envoy.clusters.original_dst]
+  message OriginalDstLbConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.Cluster.OriginalDstLbConfig";
+
+    // When true, a HTTP header can be used to override the original dst address. The default header is
+    // :ref:`x-envoy-original-dst-host <config_http_conn_man_headers_x-envoy-original-dst-host>`.
+    //
+    // .. attention::
+    //
+    //   This header isn't sanitized by default, so enabling this feature allows HTTP clients to
+    //   route traffic to arbitrary hosts and/or ports, which may have serious security
+    //   consequences.
+    //
+    // .. note::
+    //
+    //   If the header appears multiple times only the first value is used.
+    bool use_http_header = 1;
+
+    // The http header to override destination address if :ref:`use_http_header <envoy_v3_api_field_config.cluster.v3.Cluster.OriginalDstLbConfig.use_http_header>`.
+    // is set to true. If the value is empty, :ref:`x-envoy-original-dst-host <config_http_conn_man_headers_x-envoy-original-dst-host>` will be used.
+    string http_header_name = 2;
+
+    // The port to override for the original dst address. This port
+    // will take precedence over filter state and header override ports
+    google.protobuf.UInt32Value upstream_port_override = 3 [(validate.rules).uint32 = {lte: 65535}];
+
+    // The dynamic metadata key to override destination address.
+    // First the request metadata is considered, then the connection one.
+    type.metadata.v3.MetadataKey metadata_key = 4;
+  }
+
+  // Common configuration for all load balancer implementations.
+  // [#next-free-field: 9]
+  message CommonLbConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.Cluster.CommonLbConfig";
+
+    // Configuration for :ref:`zone aware routing
+    // <arch_overview_load_balancing_zone_aware_routing>`.
+    message ZoneAwareLbConfig {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.Cluster.CommonLbConfig.ZoneAwareLbConfig";
+
+      // Configures percentage of requests that will be considered for zone aware routing
+      // if zone aware routing is configured. If not specified, the default is 100%.
+      // * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
+      // * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
+      type.v3.Percent routing_enabled = 1;
+
+      // Configures minimum upstream cluster size required for zone aware routing
+      // If upstream cluster size is less than specified, zone aware routing is not performed
+      // even if zone aware routing is configured. If not specified, the default is 6.
+      // * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
+      // * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
+      google.protobuf.UInt64Value min_cluster_size = 2;
+
+      // If set to true, Envoy will not consider any hosts when the cluster is in :ref:`panic
+      // mode<arch_overview_load_balancing_panic_threshold>`. Instead, the cluster will fail all
+      // requests as if all hosts are unhealthy. This can help avoid potentially overwhelming a
+      // failing service.
+      bool fail_traffic_on_panic = 3;
+    }
+
+    // Configuration for :ref:`locality weighted load balancing
+    // <arch_overview_load_balancing_locality_weighted_lb>`
+    message LocalityWeightedLbConfig {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.Cluster.CommonLbConfig.LocalityWeightedLbConfig";
+    }
+
+    // Common Configuration for all consistent hashing load balancers (MaglevLb, RingHashLb, etc.)
+    message ConsistentHashingLbConfig {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.Cluster.CommonLbConfig.ConsistentHashingLbConfig";
+
+      // If set to ``true``, the cluster will use hostname instead of the resolved
+      // address as the key to consistently hash to an upstream host. Only valid for StrictDNS clusters with hostnames which resolve to a single IP address.
+      bool use_hostname_for_hashing = 1;
+
+      // Configures percentage of average cluster load to bound per upstream host. For example, with a value of 150
+      // no upstream host will get a load more than 1.5 times the average load of all the hosts in the cluster.
+      // If not specified, the load is not bounded for any upstream host. Typical value for this parameter is between 120 and 200.
+      // Minimum is 100.
+      //
+      // Applies to both Ring Hash and Maglev load balancers.
+      //
+      // This is implemented based on the method described in the paper https://arxiv.org/abs/1608.01350. For the specified
+      // ``hash_balance_factor``, requests to any upstream host are capped at ``hash_balance_factor/100`` times the average number of requests
+      // across the cluster. When a request arrives for an upstream host that is currently serving at its max capacity, linear probing
+      // is used to identify an eligible host. Further, the linear probe is implemented using a random jump in hosts ring/table to identify
+      // the eligible host (this technique is as described in the paper https://arxiv.org/abs/1908.08762 - the random jump avoids the
+      // cascading overflow effect when choosing the next host in the ring/table).
+      //
+      // If weights are specified on the hosts, they are respected.
+      //
+      // This is an O(N) algorithm, unlike other load balancers. Using a lower ``hash_balance_factor`` results in more hosts
+      // being probed, so use a higher value if you require better performance.
+      google.protobuf.UInt32Value hash_balance_factor = 2 [(validate.rules).uint32 = {gte: 100}];
+    }
+
+    // Configures the :ref:`healthy panic threshold <arch_overview_load_balancing_panic_threshold>`.
+    // If not specified, the default is 50%.
+    // To disable panic mode, set to 0%.
+    //
+    // .. note::
+    //   The specified percent will be truncated to the nearest 1%.
+    type.v3.Percent healthy_panic_threshold = 1;
+
+    oneof locality_config_specifier {
+      ZoneAwareLbConfig zone_aware_lb_config = 2;
+
+      LocalityWeightedLbConfig locality_weighted_lb_config = 3;
+    }
+
+    // If set, all health check/weight/metadata updates that happen within this duration will be
+    // merged and delivered in one shot when the duration expires. The start of the duration is when
+    // the first update happens. This is useful for big clusters, with potentially noisy deploys
+    // that might trigger excessive CPU usage due to a constant stream of healthcheck state changes
+    // or metadata updates. The first set of updates to be seen apply immediately (e.g.: a new
+    // cluster). Please always keep in mind that the use of sandbox technologies may change this
+    // behavior.
+    //
+    // If this is not set, we default to a merge window of 1000ms. To disable it, set the merge
+    // window to 0.
+    //
+    // .. note::
+    //   Merging does not apply to cluster membership changes (e.g.: adds/removes); this is
+    //   because merging those updates isn't currently safe. See
+    //   https://github.com/envoyproxy/envoy/pull/3941.
+    google.protobuf.Duration update_merge_window = 4;
+
+    // If set to true, Envoy will :ref:`exclude <arch_overview_load_balancing_excluded>` new hosts
+    // when computing load balancing weights until they have been health checked for the first time.
+    // This will have no effect unless active health checking is also configured.
+    bool ignore_new_hosts_until_first_hc = 5;
+
+    // If set to ``true``, the cluster manager will drain all existing
+    // connections to upstream hosts whenever hosts are added or removed from the cluster.
+    bool close_connections_on_host_set_change = 6;
+
+    // Common Configuration for all consistent hashing load balancers (MaglevLb, RingHashLb, etc.)
+    ConsistentHashingLbConfig consistent_hashing_lb_config = 7;
+
+    // This controls what hosts are considered valid when using
+    // :ref:`host overrides <arch_overview_load_balancing_override_host>`, which is used by some
+    // filters to modify the load balancing decision.
+    //
+    // If this is unset then [UNKNOWN, HEALTHY, DEGRADED] will be applied by default. If this is
+    // set with an empty set of statuses then host overrides will be ignored by the load balancing.
+    core.v3.HealthStatusSet override_host_status = 8;
+  }
+
+  message RefreshRate {
+    option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.Cluster.RefreshRate";
+
+    // Specifies the base interval between refreshes. This parameter is required and must be greater
+    // than zero and less than
+    // :ref:`max_interval <envoy_v3_api_field_config.cluster.v3.Cluster.RefreshRate.max_interval>`.
+    google.protobuf.Duration base_interval = 1 [(validate.rules).duration = {
+      required: true
+      gt {nanos: 1000000}
+    }];
+
+    // Specifies the maximum interval between refreshes. This parameter is optional, but must be
+    // greater than or equal to the
+    // :ref:`base_interval <envoy_v3_api_field_config.cluster.v3.Cluster.RefreshRate.base_interval>`  if set. The default
+    // is 10 times the :ref:`base_interval <envoy_v3_api_field_config.cluster.v3.Cluster.RefreshRate.base_interval>`.
+    google.protobuf.Duration max_interval = 2 [(validate.rules).duration = {gt {nanos: 1000000}}];
+  }
+
+  message PreconnectPolicy {
+    // Indicates how many streams (rounded up) can be anticipated per-upstream for each
+    // incoming stream. This is useful for high-QPS or latency-sensitive services. Preconnecting
+    // will only be done if the upstream is healthy and the cluster has traffic.
+    //
+    // For example if this is 2, for an incoming HTTP/1.1 stream, 2 connections will be
+    // established, one for the new incoming stream, and one for a presumed follow-up stream. For
+    // HTTP/2, only one connection would be established by default as one connection can
+    // serve both the original and presumed follow-up stream.
+    //
+    // In steady state for non-multiplexed connections a value of 1.5 would mean if there were 100
+    // active streams, there would be 100 connections in use, and 50 connections preconnected.
+    // This might be a useful value for something like short lived single-use connections,
+    // for example proxying HTTP/1.1 if keep-alive were false and each stream resulted in connection
+    // termination. It would likely be overkill for long lived connections, such as TCP proxying SMTP
+    // or regular HTTP/1.1 with keep-alive. For long lived traffic, a value of 1.05 would be more
+    // reasonable, where for every 100 connections, 5 preconnected connections would be in the queue
+    // in case of unexpected disconnects where the connection could not be reused.
+    //
+    // If this value is not set, or set explicitly to one, Envoy will fetch as many connections
+    // as needed to serve streams in flight. This means in steady state if a connection is torn down,
+    // a subsequent streams will pay an upstream-rtt latency penalty waiting for a new connection.
+    //
+    // This is limited somewhat arbitrarily to 3 because preconnecting too aggressively can
+    // harm latency more than the preconnecting helps.
+    google.protobuf.DoubleValue per_upstream_preconnect_ratio = 1
+        [(validate.rules).double = {lte: 3.0 gte: 1.0}];
+
+    // Indicates how many streams (rounded up) can be anticipated across a cluster for each
+    // stream, useful for low QPS services. This is currently supported for a subset of
+    // deterministic non-hash-based load-balancing algorithms (weighted round robin, random).
+    // Unlike ``per_upstream_preconnect_ratio`` this preconnects across the upstream instances in a
+    // cluster, doing best effort predictions of what upstream would be picked next and
+    // pre-establishing a connection.
+    //
+    // Preconnecting will be limited to one preconnect per configured upstream in the cluster and will
+    // only be done if there are healthy upstreams and the cluster has traffic.
+    //
+    // For example if preconnecting is set to 2 for a round robin HTTP/2 cluster, on the first
+    // incoming stream, 2 connections will be preconnected - one to the first upstream for this
+    // cluster, one to the second on the assumption there will be a follow-up stream.
+    //
+    // If this value is not set, or set explicitly to one, Envoy will fetch as many connections
+    // as needed to serve streams in flight, so during warm up and in steady state if a connection
+    // is closed (and per_upstream_preconnect_ratio is not set), there will be a latency hit for
+    // connection establishment.
+    //
+    // If both this and preconnect_ratio are set, Envoy will make sure both predicted needs are met,
+    // basically preconnecting max(predictive-preconnect, per-upstream-preconnect), for each
+    // upstream.
+    google.protobuf.DoubleValue predictive_preconnect_ratio = 2
+        [(validate.rules).double = {lte: 3.0 gte: 1.0}];
+  }
+
+  reserved 12, 15, 7, 11, 35;
+
+  reserved "hosts", "tls_context", "extension_protocol_options";
+
+  // Configuration to use different transport sockets for different endpoints. The entry of
+  // ``envoy.transport_socket_match`` in the :ref:`LbEndpoint.Metadata
+  // <envoy_v3_api_field_config.endpoint.v3.LbEndpoint.metadata>` is used to match against the
+  // transport sockets as they appear in the list. If a match is not found, the search continues in
+  // :ref:`LocalityLbEndpoints.Metadata
+  // <envoy_v3_api_field_config.endpoint.v3.LocalityLbEndpoints.metadata>`. The first :ref:`match
+  // <envoy_v3_api_msg_config.cluster.v3.Cluster.TransportSocketMatch>` is used. For example, with
+  // the following match
+  //
+  // .. code-block:: yaml
+  //
+  //  transport_socket_matches:
+  //  - name: "enableMTLS"
+  //    match:
+  //      acceptMTLS: true
+  //    transport_socket:
+  //      name: envoy.transport_sockets.tls
+  //      config: { ... } # tls socket configuration
+  //  - name: "defaultToPlaintext"
+  //    match: {}
+  //    transport_socket:
+  //      name: envoy.transport_sockets.raw_buffer
+  //
+  // Connections to the endpoints whose metadata value under ``envoy.transport_socket_match``
+  // having "acceptMTLS"/"true" key/value pair use the "enableMTLS" socket configuration.
+  //
+  // If a :ref:`socket match <envoy_v3_api_msg_config.cluster.v3.Cluster.TransportSocketMatch>` with empty match
+  // criteria is provided, that always match any endpoint. For example, the "defaultToPlaintext"
+  // socket match in case above.
+  //
+  // If an endpoint metadata's value under ``envoy.transport_socket_match`` does not match any
+  // ``TransportSocketMatch``, the locality metadata is then checked for a match. Barring any
+  // matches in the endpoint or locality metadata, the socket configuration fallbacks to use the
+  // ``tls_context`` or ``transport_socket`` specified in this cluster.
+  //
+  // This field allows gradual and flexible transport socket configuration changes.
+  //
+  // The metadata of endpoints in EDS can indicate transport socket capabilities. For example,
+  // an endpoint's metadata can have two key value pairs as "acceptMTLS": "true",
+  // "acceptPlaintext": "true". While some other endpoints, only accepting plaintext traffic
+  // has "acceptPlaintext": "true" metadata information.
+  //
+  // Then the xDS server can configure the CDS to a client, Envoy A, to send mutual TLS
+  // traffic for endpoints with "acceptMTLS": "true", by adding a corresponding
+  // ``TransportSocketMatch`` in this field. Other client Envoys receive CDS without
+  // ``transport_socket_match`` set, and still send plain text traffic to the same cluster.
+  //
+  // This field can be used to specify custom transport socket configurations for health
+  // checks by adding matching key/value pairs in a health check's
+  // :ref:`transport socket match criteria <envoy_v3_api_field_config.core.v3.HealthCheck.transport_socket_match_criteria>` field.
+  //
+  // [#comment:TODO(incfly): add a detailed architecture doc on intended usage.]
+  repeated TransportSocketMatch transport_socket_matches = 43;
+
+  // Supplies the name of the cluster which must be unique across all clusters.
+  // The cluster name is used when emitting
+  // :ref:`statistics <config_cluster_manager_cluster_stats>` if :ref:`alt_stat_name
+  // <envoy_v3_api_field_config.cluster.v3.Cluster.alt_stat_name>` is not provided.
+  // Any ``:`` in the cluster name will be converted to ``_`` when emitting statistics.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // An optional alternative to the cluster name to be used for observability. This name is used
+  // for emitting stats for the cluster and access logging the cluster name. This will appear as
+  // additional information in configuration dumps of a cluster's current status as
+  // :ref:`observability_name <envoy_v3_api_field_admin.v3.ClusterStatus.observability_name>`
+  // and as an additional tag "upstream_cluster.name" while tracing.
+  //
+  // .. note::
+  //   Any ``:`` in the name will be converted to ``_`` when emitting statistics. This should not be confused with
+  //   :ref:`Router Filter Header <config_http_filters_router_x-envoy-upstream-alt-stat-name>`.
+  string alt_stat_name = 28 [(udpa.annotations.field_migrate).rename = "observability_name"];
+
+  oneof cluster_discovery_type {
+    // The :ref:`service discovery type <arch_overview_service_discovery_types>`
+    // to use for resolving the cluster.
+    DiscoveryType type = 2 [(validate.rules).enum = {defined_only: true}];
+
+    // The custom cluster type.
+    CustomClusterType cluster_type = 38;
+  }
+
+  // Configuration to use for EDS updates for the Cluster.
+  EdsClusterConfig eds_cluster_config = 3;
+
+  // The timeout for new network connections to hosts in the cluster.
+  // If not set, a default value of 5s will be used.
+  google.protobuf.Duration connect_timeout = 4 [(validate.rules).duration = {gt {}}];
+
+  // Soft limit on size of the cluster’s connections read and write buffers. If
+  // unspecified, an implementation defined default is applied (1MiB).
+  google.protobuf.UInt32Value per_connection_buffer_limit_bytes = 5
+      [(udpa.annotations.security).configure_for_untrusted_upstream = true];
+
+  // The :ref:`load balancer type <arch_overview_load_balancing_types>` to use
+  // when picking a host in the cluster.
+  LbPolicy lb_policy = 6 [(validate.rules).enum = {defined_only: true}];
+
+  // Setting this is required for specifying members of
+  // :ref:`STATIC<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STATIC>`,
+  // :ref:`STRICT_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`
+  // or :ref:`LOGICAL_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>` clusters.
+  // This field supersedes the ``hosts`` field in the v2 API.
+  //
+  // .. attention::
+  //
+  //   Setting this allows non-EDS cluster types to contain embedded EDS equivalent
+  //   :ref:`endpoint assignments<envoy_v3_api_msg_config.endpoint.v3.ClusterLoadAssignment>`.
+  //
+  endpoint.v3.ClusterLoadAssignment load_assignment = 33;
+
+  // Optional :ref:`active health checking <arch_overview_health_checking>`
+  // configuration for the cluster. If no
+  // configuration is specified no health checking will be done and all cluster
+  // members will be considered healthy at all times.
+  repeated core.v3.HealthCheck health_checks = 8;
+
+  // Optional maximum requests for a single upstream connection. This parameter
+  // is respected by both the HTTP/1.1 and HTTP/2 connection pool
+  // implementations. If not specified, there is no limit. Setting this
+  // parameter to 1 will effectively disable keep alive.
+  //
+  // .. attention::
+  //   This field has been deprecated in favor of the :ref:`max_requests_per_connection <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_requests_per_connection>` field.
+  google.protobuf.UInt32Value max_requests_per_connection = 9
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Optional :ref:`circuit breaking <arch_overview_circuit_break>` for the cluster.
+  CircuitBreakers circuit_breakers = 10;
+
+  // HTTP protocol options that are applied only to upstream HTTP connections.
+  // These options apply to all HTTP versions.
+  // This has been deprecated in favor of
+  // :ref:`upstream_http_protocol_options <envoy_v3_api_field_extensions.upstreams.http.v3.HttpProtocolOptions.upstream_http_protocol_options>`
+  // in the :ref:`http_protocol_options <envoy_v3_api_msg_extensions.upstreams.http.v3.HttpProtocolOptions>` message.
+  // upstream_http_protocol_options can be set via the cluster's
+  // :ref:`extension_protocol_options<envoy_v3_api_field_config.cluster.v3.Cluster.typed_extension_protocol_options>`.
+  // See :ref:`upstream_http_protocol_options
+  // <envoy_v3_api_field_extensions.upstreams.http.v3.HttpProtocolOptions.upstream_http_protocol_options>`
+  // for example usage.
+  core.v3.UpstreamHttpProtocolOptions upstream_http_protocol_options = 46
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Additional options when handling HTTP requests upstream. These options will be applicable to
+  // both HTTP1 and HTTP2 requests.
+  // This has been deprecated in favor of
+  // :ref:`common_http_protocol_options <envoy_v3_api_field_extensions.upstreams.http.v3.HttpProtocolOptions.common_http_protocol_options>`
+  // in the :ref:`http_protocol_options <envoy_v3_api_msg_extensions.upstreams.http.v3.HttpProtocolOptions>` message.
+  // common_http_protocol_options can be set via the cluster's
+  // :ref:`extension_protocol_options<envoy_v3_api_field_config.cluster.v3.Cluster.typed_extension_protocol_options>`.
+  // See :ref:`upstream_http_protocol_options
+  // <envoy_v3_api_field_extensions.upstreams.http.v3.HttpProtocolOptions.upstream_http_protocol_options>`
+  // for example usage.
+  core.v3.HttpProtocolOptions common_http_protocol_options = 29
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Additional options when handling HTTP1 requests.
+  // This has been deprecated in favor of http_protocol_options fields in the
+  // :ref:`http_protocol_options <envoy_v3_api_msg_extensions.upstreams.http.v3.HttpProtocolOptions>` message.
+  // http_protocol_options can be set via the cluster's
+  // :ref:`extension_protocol_options<envoy_v3_api_field_config.cluster.v3.Cluster.typed_extension_protocol_options>`.
+  // See :ref:`upstream_http_protocol_options
+  // <envoy_v3_api_field_extensions.upstreams.http.v3.HttpProtocolOptions.upstream_http_protocol_options>`
+  // for example usage.
+  core.v3.Http1ProtocolOptions http_protocol_options = 13
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Even if default HTTP2 protocol options are desired, this field must be
+  // set so that Envoy will assume that the upstream supports HTTP/2 when
+  // making new HTTP connection pool connections. Currently, Envoy only
+  // supports prior knowledge for upstream connections. Even if TLS is used
+  // with ALPN, ``http2_protocol_options`` must be specified. As an aside this allows HTTP/2
+  // connections to happen over plain text.
+  // This has been deprecated in favor of http2_protocol_options fields in the
+  // :ref:`http_protocol_options <envoy_v3_api_msg_extensions.upstreams.http.v3.HttpProtocolOptions>`
+  // message. http2_protocol_options can be set via the cluster's
+  // :ref:`extension_protocol_options<envoy_v3_api_field_config.cluster.v3.Cluster.typed_extension_protocol_options>`.
+  // See :ref:`upstream_http_protocol_options
+  // <envoy_v3_api_field_extensions.upstreams.http.v3.HttpProtocolOptions.upstream_http_protocol_options>`
+  // for example usage.
+  core.v3.Http2ProtocolOptions http2_protocol_options = 14 [
+    deprecated = true,
+    (udpa.annotations.security).configure_for_untrusted_upstream = true,
+    (envoy.annotations.deprecated_at_minor_version) = "3.0"
+  ];
+
+  // The extension_protocol_options field is used to provide extension-specific protocol options
+  // for upstream connections. The key should match the extension filter name, such as
+  // "envoy.filters.network.thrift_proxy". See the extension's documentation for details on
+  // specific options.
+  // [#next-major-version: make this a list of typed extensions.]
+  // [#extension-category: envoy.upstream_options]
+  map<string, google.protobuf.Any> typed_extension_protocol_options = 36;
+
+  // If the DNS refresh rate is specified and the cluster type is either
+  // :ref:`STRICT_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`,
+  // or :ref:`LOGICAL_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`,
+  // this value is used as the cluster’s DNS refresh
+  // rate. The value configured must be at least 1ms. If this setting is not specified, the
+  // value defaults to 5000ms. For cluster types other than
+  // :ref:`STRICT_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`
+  // and :ref:`LOGICAL_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`
+  // this setting is ignored.
+  // This field is deprecated in favor of using the :ref:`cluster_type<envoy_v3_api_field_config.cluster.v3.Cluster.cluster_type>`
+  // extension point and configuring it with :ref:`DnsCluster<envoy_v3_api_msg_extensions.clusters.dns.v3.DnsCluster>`.
+  // If :ref:`cluster_type<envoy_v3_api_field_config.cluster.v3.Cluster.cluster_type>` is configured with
+  // :ref:`DnsCluster<envoy_v3_api_msg_extensions.clusters.dns.v3.DnsCluster>`, this field will be ignored.
+  google.protobuf.Duration dns_refresh_rate = 16 [
+    deprecated = true,
+    (validate.rules).duration = {gt {nanos: 1000000}},
+    (envoy.annotations.deprecated_at_minor_version) = "3.0"
+  ];
+
+  // DNS jitter can be optionally specified if the cluster type is either
+  // :ref:`STRICT_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`,
+  // or :ref:`LOGICAL_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`.
+  // DNS jitter causes the cluster to refresh DNS entries later by a random amount of time to avoid a
+  // stampede of DNS requests. This value sets the upper bound (exclusive) for the random amount.
+  // There will be no jitter if this value is omitted. For cluster types other than
+  // :ref:`STRICT_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`
+  // and :ref:`LOGICAL_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`
+  // this setting is ignored.
+  // This field is deprecated in favor of using the :ref:`cluster_type<envoy_v3_api_field_config.cluster.v3.Cluster.cluster_type>`
+  // extension point and configuring it with :ref:`DnsCluster<envoy_v3_api_msg_extensions.clusters.dns.v3.DnsCluster>`.
+  // If :ref:`cluster_type<envoy_v3_api_field_config.cluster.v3.Cluster.cluster_type>` is configured with
+  // :ref:`DnsCluster<envoy_v3_api_msg_extensions.clusters.dns.v3.DnsCluster>`, this field will be ignored.
+  google.protobuf.Duration dns_jitter = 58 [
+    deprecated = true,
+    (validate.rules).duration = {gte {}},
+    (envoy.annotations.deprecated_at_minor_version) = "3.0"
+  ];
+
+  // If the DNS failure refresh rate is specified and the cluster type is either
+  // :ref:`STRICT_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`,
+  // or :ref:`LOGICAL_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`,
+  // this is used as the cluster’s DNS refresh rate when requests are failing. If this setting is
+  // not specified, the failure refresh rate defaults to the DNS refresh rate. For cluster types
+  // other than :ref:`STRICT_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>` and
+  // :ref:`LOGICAL_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>` this setting is
+  // ignored.
+  // This field is deprecated in favor of using the :ref:`cluster_type<envoy_v3_api_field_config.cluster.v3.Cluster.cluster_type>`
+  // extension point and configuring it with :ref:`DnsCluster<envoy_v3_api_msg_extensions.clusters.dns.v3.DnsCluster>`.
+  // If :ref:`cluster_type<envoy_v3_api_field_config.cluster.v3.Cluster.cluster_type>` is configured with
+  // :ref:`DnsCluster<envoy_v3_api_msg_extensions.clusters.dns.v3.DnsCluster>`, this field will be ignored.
+  RefreshRate dns_failure_refresh_rate = 44
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Optional configuration for setting cluster's DNS refresh rate. If the value is set to true,
+  // cluster's DNS refresh rate will be set to resource record's TTL which comes from DNS
+  // resolution.
+  // This field is deprecated in favor of using the :ref:`cluster_type<envoy_v3_api_field_config.cluster.v3.Cluster.cluster_type>`
+  // extension point and configuring it with :ref:`DnsCluster<envoy_v3_api_msg_extensions.clusters.dns.v3.DnsCluster>`.
+  // If :ref:`cluster_type<envoy_v3_api_field_config.cluster.v3.Cluster.cluster_type>` is configured with
+  // :ref:`DnsCluster<envoy_v3_api_msg_extensions.clusters.dns.v3.DnsCluster>`, this field will be ignored.
+  bool respect_dns_ttl = 39
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // The DNS IP address resolution policy. If this setting is not specified, the
+  // value defaults to
+  // :ref:`AUTO<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DnsLookupFamily.AUTO>`.
+  // For logical and strict dns cluster, this field is deprecated in favor of using the
+  // :ref:`cluster_type<envoy_v3_api_field_config.cluster.v3.Cluster.cluster_type>`
+  // extension point and configuring it with :ref:`DnsCluster<envoy_v3_api_msg_extensions.clusters.dns.v3.DnsCluster>`.
+  // If :ref:`cluster_type<envoy_v3_api_field_config.cluster.v3.Cluster.cluster_type>` is configured with
+  // :ref:`DnsCluster<envoy_v3_api_msg_extensions.clusters.dns.v3.DnsCluster>`, this field will be ignored.
+  DnsLookupFamily dns_lookup_family = 17 [(validate.rules).enum = {defined_only: true}];
+
+  // If DNS resolvers are specified and the cluster type is either
+  // :ref:`STRICT_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`,
+  // or :ref:`LOGICAL_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`,
+  // this value is used to specify the cluster’s dns resolvers.
+  // If this setting is not specified, the value defaults to the default
+  // resolver, which uses /etc/resolv.conf for configuration. For cluster types
+  // other than
+  // :ref:`STRICT_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`
+  // and :ref:`LOGICAL_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`
+  // this setting is ignored.
+  // This field is deprecated in favor of ``dns_resolution_config``
+  // which aggregates all of the DNS resolver configuration in a single message.
+  repeated core.v3.Address dns_resolvers = 18
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Always use TCP queries instead of UDP queries for DNS lookups.
+  // This field is deprecated in favor of ``dns_resolution_config``
+  // which aggregates all of the DNS resolver configuration in a single message.
+  bool use_tcp_for_dns_lookups = 45
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // DNS resolution configuration which includes the underlying dns resolver addresses and options.
+  // This field is deprecated in favor of
+  // :ref:`typed_dns_resolver_config <envoy_v3_api_field_config.cluster.v3.Cluster.typed_dns_resolver_config>`.
+  core.v3.DnsResolutionConfig dns_resolution_config = 53
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // DNS resolver type configuration extension. This extension can be used to configure c-ares, apple,
+  // or any other DNS resolver types and the related parameters.
+  // For example, an object of
+  // :ref:`CaresDnsResolverConfig <envoy_v3_api_msg_extensions.network.dns_resolver.cares.v3.CaresDnsResolverConfig>`
+  // can be packed into this ``typed_dns_resolver_config``. This configuration replaces the
+  // :ref:`dns_resolution_config <envoy_v3_api_field_config.cluster.v3.Cluster.dns_resolution_config>`
+  // configuration.
+  // During the transition period when both ``dns_resolution_config`` and ``typed_dns_resolver_config`` exists,
+  // when ``typed_dns_resolver_config`` is in place, Envoy will use it and ignore ``dns_resolution_config``.
+  // When ``typed_dns_resolver_config`` is missing, the default behavior is in place.
+  // Also note that this field is deprecated for logical dns and strict dns clusters and will be ignored when
+  // :ref:`cluster_type<envoy_v3_api_field_config.cluster.v3.Cluster.cluster_type>` is configured with
+  // :ref:`DnsCluster<envoy_v3_api_msg_extensions.clusters.dns.v3.DnsCluster>`.
+  // [#extension-category: envoy.network.dns_resolver]
+  core.v3.TypedExtensionConfig typed_dns_resolver_config = 55;
+
+  // Optional configuration for having cluster readiness block on warm-up. Currently, only applicable for
+  // :ref:`STRICT_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.STRICT_DNS>`,
+  // or :ref:`LOGICAL_DNS<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.LOGICAL_DNS>`,
+  // or :ref:`Redis Cluster<arch_overview_redis>`.
+  // If true, cluster readiness blocks on warm-up. If false, the cluster will complete
+  // initialization whether or not warm-up has completed. Defaults to true.
+  google.protobuf.BoolValue wait_for_warm_on_init = 54;
+
+  // If specified, outlier detection will be enabled for this upstream cluster.
+  // Each of the configuration values can be overridden via
+  // :ref:`runtime values <config_cluster_manager_cluster_runtime_outlier_detection>`.
+  OutlierDetection outlier_detection = 19;
+
+  // The interval for removing stale hosts from a cluster type
+  // :ref:`ORIGINAL_DST<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.ORIGINAL_DST>`.
+  // Hosts are considered stale if they have not been used
+  // as upstream destinations during this interval. New hosts are added
+  // to original destination clusters on demand as new connections are
+  // redirected to Envoy, causing the number of hosts in the cluster to
+  // grow over time. Hosts that are not stale (they are actively used as
+  // destinations) are kept in the cluster, which allows connections to
+  // them remain open, saving the latency that would otherwise be spent
+  // on opening new connections. If this setting is not specified, the
+  // value defaults to 5000ms. For cluster types other than
+  // :ref:`ORIGINAL_DST<envoy_v3_api_enum_value_config.cluster.v3.Cluster.DiscoveryType.ORIGINAL_DST>`
+  // this setting is ignored.
+  google.protobuf.Duration cleanup_interval = 20 [(validate.rules).duration = {gt {}}];
+
+  // Optional configuration used to bind newly established upstream connections.
+  // This overrides any bind_config specified in the bootstrap proto.
+  // If the address and port are empty, no bind will be performed.
+  core.v3.BindConfig upstream_bind_config = 21;
+
+  // Configuration for load balancing subsetting.
+  LbSubsetConfig lb_subset_config = 22;
+
+  // Optional configuration for the load balancing algorithm selected by
+  // LbPolicy. Currently only
+  // :ref:`RING_HASH<envoy_v3_api_enum_value_config.cluster.v3.Cluster.LbPolicy.RING_HASH>`,
+  // :ref:`MAGLEV<envoy_v3_api_enum_value_config.cluster.v3.Cluster.LbPolicy.MAGLEV>` and
+  // :ref:`LEAST_REQUEST<envoy_v3_api_enum_value_config.cluster.v3.Cluster.LbPolicy.LEAST_REQUEST>`
+  // has additional configuration options.
+  // Specifying ring_hash_lb_config or maglev_lb_config or least_request_lb_config without setting the corresponding
+  // LbPolicy will generate an error at runtime.
+  oneof lb_config {
+    // Optional configuration for the Ring Hash load balancing policy.
+    RingHashLbConfig ring_hash_lb_config = 23;
+
+    // Optional configuration for the Maglev load balancing policy.
+    MaglevLbConfig maglev_lb_config = 52;
+
+    // Optional configuration for the Original Destination load balancing policy.
+    OriginalDstLbConfig original_dst_lb_config = 34;
+
+    // Optional configuration for the LeastRequest load balancing policy.
+    LeastRequestLbConfig least_request_lb_config = 37;
+
+    // Optional configuration for the RoundRobin load balancing policy.
+    RoundRobinLbConfig round_robin_lb_config = 56;
+  }
+
+  // Common configuration for all load balancer implementations.
+  CommonLbConfig common_lb_config = 27;
+
+  // Optional custom transport socket implementation to use for upstream connections.
+  // To setup TLS, set a transport socket with name ``envoy.transport_sockets.tls`` and
+  // :ref:`UpstreamTlsContexts <envoy_v3_api_msg_extensions.transport_sockets.tls.v3.UpstreamTlsContext>` in the ``typed_config``.
+  // If no transport socket configuration is specified, new connections
+  // will be set up with plaintext.
+  core.v3.TransportSocket transport_socket = 24;
+
+  // The Metadata field can be used to provide additional information about the
+  // cluster. It can be used for stats, logging, and varying filter behavior.
+  // Fields should use reverse DNS notation to denote which entity within Envoy
+  // will need the information. For instance, if the metadata is intended for
+  // the Router filter, the filter name should be specified as ``envoy.filters.http.router``.
+  core.v3.Metadata metadata = 25;
+
+  // Determines how Envoy selects the protocol used to speak to upstream hosts.
+  // This has been deprecated in favor of setting explicit protocol selection
+  // in the :ref:`http_protocol_options
+  // <envoy_v3_api_msg_extensions.upstreams.http.v3.HttpProtocolOptions>` message.
+  // http_protocol_options can be set via the cluster's
+  // :ref:`extension_protocol_options<envoy_v3_api_field_config.cluster.v3.Cluster.typed_extension_protocol_options>`.
+  ClusterProtocolSelection protocol_selection = 26
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Optional options for upstream connections.
+  UpstreamConnectionOptions upstream_connection_options = 30;
+
+  // If an upstream host becomes unhealthy (as determined by the configured health checks
+  // or outlier detection), immediately close all connections to the failed host.
+  //
+  // .. note::
+  //
+  //   This is currently only supported for connections created by tcp_proxy.
+  //
+  // .. note::
+  //
+  //   The current implementation of this feature closes all connections immediately when
+  //   the unhealthy status is detected. If there are a large number of connections open
+  //   to an upstream host that becomes unhealthy, Envoy may spend a substantial amount of
+  //   time exclusively closing these connections, and not processing any other traffic.
+  bool close_connections_on_host_health_failure = 31;
+
+  // If set to true, Envoy will ignore the health value of a host when processing its removal
+  // from service discovery. This means that if active health checking is used, Envoy will *not*
+  // wait for the endpoint to go unhealthy before removing it.
+  bool ignore_health_on_host_removal = 32;
+
+  // An (optional) network filter chain, listed in the order the filters should be applied.
+  // The chain will be applied to all outgoing connections that Envoy makes to the upstream
+  // servers of this cluster.
+  repeated Filter filters = 40;
+
+  // If this field is set and is supported by the client, it will supersede the value of
+  // :ref:`lb_policy<envoy_v3_api_field_config.cluster.v3.Cluster.lb_policy>`.
+  LoadBalancingPolicy load_balancing_policy = 41;
+
+  // [#not-implemented-hide:]
+  // If present, tells the client where to send load reports via LRS. If not present, the
+  // client will fall back to a client-side default, which may be either (a) don't send any
+  // load reports or (b) send load reports for all clusters to a single default server
+  // (which may be configured in the bootstrap file).
+  //
+  // Note that if multiple clusters point to the same LRS server, the client may choose to
+  // create a separate stream for each cluster or it may choose to coalesce the data for
+  // multiple clusters onto a single stream. Either way, the client must make sure to send
+  // the data for any given cluster on no more than one stream.
+  //
+  // [#next-major-version: In the v3 API, we should consider restructuring this somehow,
+  // maybe by allowing LRS to go on the ADS stream, or maybe by moving some of the negotiation
+  // from the LRS stream here.]
+  core.v3.ConfigSource lrs_server = 42;
+
+  // A list of metric names from :ref:`ORCA load reports <envoy_v3_api_msg_.xds.data.orca.v3.OrcaLoadReport>` to propagate to LRS.
+  //
+  // If not specified, then ORCA load reports will not be propagated to LRS.
+  //
+  // For map fields in the ORCA proto, the string will be of the form ``<map_field_name>.<map_key>``.
+  // For example, the string ``named_metrics.foo`` will mean to look for the key ``foo`` in the ORCA
+  // :ref:`named_metrics <envoy_v3_api_field_.xds.data.orca.v3.OrcaLoadReport.named_metrics>` field.
+  //
+  // The special map key ``*`` means to report all entries in the map (e.g., ``named_metrics.*`` means to
+  // report all entries in the ORCA named_metrics field). Note that this should be used only with trusted
+  // backends.
+  //
+  // The metric names in LRS will follow the same semantics as this field. In other words, if this field
+  // contains ``named_metrics.foo``, then the LRS load report will include the data with that same string
+  // as the key.
+  repeated string lrs_report_endpoint_metrics = 57;
+
+  // If track_timeout_budgets is true, the :ref:`timeout budget histograms
+  // <config_cluster_manager_cluster_stats_timeout_budgets>` will be published for each
+  // request. These show what percentage of a request's per try and global timeout was used. A value
+  // of 0 would indicate that none of the timeout was used or that the timeout was infinite. A value
+  // of 100 would indicate that the request took the entirety of the timeout given to it.
+  //
+  // .. attention::
+  //
+  //   This field has been deprecated in favor of ``timeout_budgets``, part of
+  //   :ref:`track_cluster_stats <envoy_v3_api_field_config.cluster.v3.Cluster.track_cluster_stats>`.
+  bool track_timeout_budgets = 47
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Optional customization and configuration of upstream connection pool, and upstream type.
+  //
+  // Currently this field only applies for HTTP traffic but is designed for eventual use for custom
+  // TCP upstreams.
+  //
+  // For HTTP traffic, Envoy will generally take downstream HTTP and send it upstream as upstream
+  // HTTP, using the http connection pool and the codec from ``http2_protocol_options``
+  //
+  // For routes where CONNECT termination is configured, Envoy will take downstream CONNECT
+  // requests and forward the CONNECT payload upstream over raw TCP using the tcp connection pool.
+  //
+  // The default pool used is the generic connection pool which creates the HTTP upstream for most
+  // HTTP requests, and the TCP upstream if CONNECT termination is configured.
+  //
+  // If users desire custom connection pool or upstream behavior, for example terminating
+  // CONNECT only if a custom filter indicates it is appropriate, the custom factories
+  // can be registered and configured here.
+  // [#extension-category: envoy.upstreams]
+  core.v3.TypedExtensionConfig upstream_config = 48;
+
+  // Configuration to track optional cluster stats.
+  TrackClusterStats track_cluster_stats = 49;
+
+  // Preconnect configuration for this cluster.
+  PreconnectPolicy preconnect_policy = 50;
+
+  // If ``connection_pool_per_downstream_connection`` is true, the cluster will use a separate
+  // connection pool for every downstream connection
+  bool connection_pool_per_downstream_connection = 51;
+}
+
+// Extensible load balancing policy configuration.
+//
+// Every LB policy defined via this mechanism will be identified via a unique name using reverse
+// DNS notation. If the policy needs configuration parameters, it must define a message for its
+// own configuration, which will be stored in the config field. The name of the policy will tell
+// clients which type of message they should expect to see in the config field.
+//
+// Note that there are cases where it is useful to be able to independently select LB policies
+// for choosing a locality and for choosing an endpoint within that locality. For example, a
+// given deployment may always use the same policy to choose the locality, but for choosing the
+// endpoint within the locality, some clusters may use weighted-round-robin, while others may
+// use some sort of session-based balancing.
+//
+// This can be accomplished via hierarchical LB policies, where the parent LB policy creates a
+// child LB policy for each locality. For each request, the parent chooses the locality and then
+// delegates to the child policy for that locality to choose the endpoint within the locality.
+//
+// To facilitate this, the config message for the top-level LB policy may include a field of
+// type LoadBalancingPolicy that specifies the child policy.
+message LoadBalancingPolicy {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.LoadBalancingPolicy";
+
+  message Policy {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.LoadBalancingPolicy.Policy";
+
+    reserved 2, 1, 3;
+
+    reserved "config", "name", "typed_config";
+
+    // [#extension-category: envoy.load_balancing_policies]
+    core.v3.TypedExtensionConfig typed_extension_config = 4;
+  }
+
+  // Each client will iterate over the list in order and stop at the first policy that it
+  // supports. This provides a mechanism for starting to use new LB policies that are not yet
+  // supported by all clients.
+  repeated Policy policies = 1;
+}
+
+message UpstreamConnectionOptions {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.UpstreamConnectionOptions";
+
+  enum FirstAddressFamilyVersion {
+    // respect the native ranking of destination ip addresses returned from dns
+    // resolution
+    DEFAULT = 0;
+
+    V4 = 1;
+
+    V6 = 2;
+  }
+
+  message HappyEyeballsConfig {
+    // Specify the IP address family to attempt connection first in happy
+    // eyeballs algorithm according to RFC8305#section-4.
+    FirstAddressFamilyVersion first_address_family_version = 1;
+
+    // Specify the number of addresses of the first_address_family_version being
+    // attempted for connection before the other address family.
+    google.protobuf.UInt32Value first_address_family_count = 2 [(validate.rules).uint32 = {gte: 1}];
+  }
+
+  // If set then set SO_KEEPALIVE on the socket to enable TCP Keepalives.
+  core.v3.TcpKeepalive tcp_keepalive = 1;
+
+  // If enabled, associates the interface name of the local address with the upstream connection.
+  // This can be used by extensions during processing of requests. The association mechanism is
+  // implementation specific. Defaults to false due to performance concerns.
+  bool set_local_interface_name_on_upstream_connections = 2;
+
+  // Configurations for happy eyeballs algorithm.
+  // Add configs for first_address_family_version and first_address_family_count
+  // when sorting destination ip addresses.
+  HappyEyeballsConfig happy_eyeballs_config = 3;
+}
+
+message TrackClusterStats {
+  // If timeout_budgets is true, the :ref:`timeout budget histograms
+  // <config_cluster_manager_cluster_stats_timeout_budgets>` will be published for each
+  // request. These show what percentage of a request's per try and global timeout was used. A value
+  // of 0 would indicate that none of the timeout was used or that the timeout was infinite. A value
+  // of 100 would indicate that the request took the entirety of the timeout given to it.
+  bool timeout_budgets = 1;
+
+  // If request_response_sizes is true, then the :ref:`histograms
+  // <config_cluster_manager_cluster_stats_request_response_sizes>`  tracking header and body sizes
+  // of requests and responses will be published. Additionally, number of headers in the requests and responses will be tracked.
+  bool request_response_sizes = 2;
+
+  // If true, some stats will be emitted per-endpoint, similar to the stats in admin ``/clusters``
+  // output.
+  //
+  // This does not currently output correct stats during a hot-restart.
+  //
+  // This is not currently implemented by all stat sinks.
+  //
+  // These stats do not honor filtering or tag extraction rules in :ref:`StatsConfig
+  // <envoy_v3_api_msg_config.metrics.v3.StatsConfig>` (but fixed-value tags are supported). Admin
+  // endpoint filtering is supported.
+  //
+  // This may not be used at the same time as
+  // :ref:`load_stats_config <envoy_v3_api_field_config.bootstrap.v3.ClusterManager.load_stats_config>`.
+  bool per_endpoint_stats = 3;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/cluster/v3/filter.proto b/xds/third_party/envoy/src/main/proto/envoy/config/cluster/v3/filter.proto
new file mode 100644
index 00000000000..54611edbf16
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/cluster/v3/filter.proto
@@ -0,0 +1,40 @@
+syntax = "proto3";
+
+package envoy.config.cluster.v3;
+
+import "envoy/config/core/v3/config_source.proto";
+
+import "google/protobuf/any.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.cluster.v3";
+option java_outer_classname = "FilterProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/cluster/v3;clusterv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Upstream network filters]
+// Upstream network filters apply to the connections to the upstream cluster hosts.
+
+message Filter {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.cluster.Filter";
+
+  // The name of the filter configuration.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // Filter specific configuration which depends on the filter being
+  // instantiated. See the supported filters for further documentation.
+  // Note that Envoy's :ref:`downstream network
+  // filters <config_network_filters>` are not valid upstream network filters.
+  // Only one of typed_config or config_discovery can be used.
+  google.protobuf.Any typed_config = 2;
+
+  // Configuration source specifier for an extension configuration discovery
+  // service. In case of a failure and without the default configuration, the
+  // listener closes the connections.
+  // Only one of typed_config or config_discovery can be used.
+  core.v3.ExtensionConfigSource config_discovery = 3;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/cluster/v3/outlier_detection.proto b/xds/third_party/envoy/src/main/proto/envoy/config/cluster/v3/outlier_detection.proto
new file mode 100644
index 00000000000..822d81da850
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/cluster/v3/outlier_detection.proto
@@ -0,0 +1,180 @@
+syntax = "proto3";
+
+package envoy.config.cluster.v3;
+
+import "envoy/config/core/v3/extension.proto";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.cluster.v3";
+option java_outer_classname = "OutlierDetectionProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/cluster/v3;clusterv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Outlier detection]
+
+// See the :ref:`architecture overview <arch_overview_outlier_detection>` for
+// more information on outlier detection.
+// [#next-free-field: 26]
+message OutlierDetection {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.cluster.OutlierDetection";
+
+  // The number of consecutive server-side error responses (for HTTP traffic,
+  // 5xx responses; for TCP traffic, connection failures; for Redis, failure to
+  // respond PONG; etc.) before a consecutive 5xx ejection occurs. Defaults to 5.
+  google.protobuf.UInt32Value consecutive_5xx = 1;
+
+  // The time interval between ejection analysis sweeps. This can result in
+  // both new ejections as well as hosts being returned to service. Defaults
+  // to 10000ms or 10s.
+  google.protobuf.Duration interval = 2 [(validate.rules).duration = {gt {}}];
+
+  // The base time that a host is ejected for. The real time is equal to the
+  // base time multiplied by the number of times the host has been ejected and is
+  // capped by :ref:`max_ejection_time<envoy_v3_api_field_config.cluster.v3.OutlierDetection.max_ejection_time>`.
+  // Defaults to 30000ms or 30s.
+  google.protobuf.Duration base_ejection_time = 3 [(validate.rules).duration = {gt {}}];
+
+  // The maximum % of an upstream cluster that can be ejected due to outlier detection. Defaults to 10% .
+  // Will eject at least one host regardless of the value if :ref:`always_eject_one_host<envoy_v3_api_field_config.cluster.v3.OutlierDetection.always_eject_one_host>` is enabled.
+  google.protobuf.UInt32Value max_ejection_percent = 4 [(validate.rules).uint32 = {lte: 100}];
+
+  // The % chance that a host will be actually ejected when an outlier status
+  // is detected through consecutive 5xx. This setting can be used to disable
+  // ejection or to ramp it up slowly. Defaults to 100.
+  google.protobuf.UInt32Value enforcing_consecutive_5xx = 5 [(validate.rules).uint32 = {lte: 100}];
+
+  // The % chance that a host will be actually ejected when an outlier status
+  // is detected through success rate statistics. This setting can be used to
+  // disable ejection or to ramp it up slowly. Defaults to 100.
+  google.protobuf.UInt32Value enforcing_success_rate = 6 [(validate.rules).uint32 = {lte: 100}];
+
+  // The number of hosts in a cluster that must have enough request volume to
+  // detect success rate outliers. If the number of hosts is less than this
+  // setting, outlier detection via success rate statistics is not performed
+  // for any host in the cluster. Defaults to 5.
+  google.protobuf.UInt32Value success_rate_minimum_hosts = 7;
+
+  // The minimum number of total requests that must be collected in one
+  // interval (as defined by the interval duration above) to include this host
+  // in success rate based outlier detection. If the volume is lower than this
+  // setting, outlier detection via success rate statistics is not performed
+  // for that host. Defaults to 100.
+  google.protobuf.UInt32Value success_rate_request_volume = 8;
+
+  // This factor is used to determine the ejection threshold for success rate
+  // outlier ejection. The ejection threshold is the difference between the
+  // mean success rate, and the product of this factor and the standard
+  // deviation of the mean success rate: mean - (stdev *
+  // success_rate_stdev_factor). This factor is divided by a thousand to get a
+  // double. That is, if the desired factor is 1.9, the runtime value should
+  // be 1900. Defaults to 1900.
+  google.protobuf.UInt32Value success_rate_stdev_factor = 9;
+
+  // The number of consecutive gateway failures (502, 503, 504 status codes)
+  // before a consecutive gateway failure ejection occurs. Defaults to 5.
+  google.protobuf.UInt32Value consecutive_gateway_failure = 10;
+
+  // The % chance that a host will be actually ejected when an outlier status
+  // is detected through consecutive gateway failures. This setting can be
+  // used to disable ejection or to ramp it up slowly. Defaults to 0.
+  google.protobuf.UInt32Value enforcing_consecutive_gateway_failure = 11
+      [(validate.rules).uint32 = {lte: 100}];
+
+  // Determines whether to distinguish local origin failures from external errors. If set to true
+  // the following configuration parameters are taken into account:
+  // :ref:`consecutive_local_origin_failure<envoy_v3_api_field_config.cluster.v3.OutlierDetection.consecutive_local_origin_failure>`,
+  // :ref:`enforcing_consecutive_local_origin_failure<envoy_v3_api_field_config.cluster.v3.OutlierDetection.enforcing_consecutive_local_origin_failure>`
+  // and
+  // :ref:`enforcing_local_origin_success_rate<envoy_v3_api_field_config.cluster.v3.OutlierDetection.enforcing_local_origin_success_rate>`.
+  // Defaults to false.
+  bool split_external_local_origin_errors = 12;
+
+  // The number of consecutive locally originated failures before ejection
+  // occurs. Defaults to 5. Parameter takes effect only when
+  // :ref:`split_external_local_origin_errors<envoy_v3_api_field_config.cluster.v3.OutlierDetection.split_external_local_origin_errors>`
+  // is set to true.
+  google.protobuf.UInt32Value consecutive_local_origin_failure = 13;
+
+  // The % chance that a host will be actually ejected when an outlier status
+  // is detected through consecutive locally originated failures. This setting can be
+  // used to disable ejection or to ramp it up slowly. Defaults to 100.
+  // Parameter takes effect only when
+  // :ref:`split_external_local_origin_errors<envoy_v3_api_field_config.cluster.v3.OutlierDetection.split_external_local_origin_errors>`
+  // is set to true.
+  google.protobuf.UInt32Value enforcing_consecutive_local_origin_failure = 14
+      [(validate.rules).uint32 = {lte: 100}];
+
+  // The % chance that a host will be actually ejected when an outlier status
+  // is detected through success rate statistics for locally originated errors.
+  // This setting can be used to disable ejection or to ramp it up slowly. Defaults to 100.
+  // Parameter takes effect only when
+  // :ref:`split_external_local_origin_errors<envoy_v3_api_field_config.cluster.v3.OutlierDetection.split_external_local_origin_errors>`
+  // is set to true.
+  google.protobuf.UInt32Value enforcing_local_origin_success_rate = 15
+      [(validate.rules).uint32 = {lte: 100}];
+
+  // The failure percentage to use when determining failure percentage-based outlier detection. If
+  // the failure percentage of a given host is greater than or equal to this value, it will be
+  // ejected. Defaults to 85.
+  google.protobuf.UInt32Value failure_percentage_threshold = 16
+      [(validate.rules).uint32 = {lte: 100}];
+
+  // The % chance that a host will be actually ejected when an outlier status is detected through
+  // failure percentage statistics. This setting can be used to disable ejection or to ramp it up
+  // slowly. Defaults to 0.
+  //
+  // [#next-major-version: setting this without setting failure_percentage_threshold should be
+  // invalid in v4.]
+  google.protobuf.UInt32Value enforcing_failure_percentage = 17
+      [(validate.rules).uint32 = {lte: 100}];
+
+  // The % chance that a host will be actually ejected when an outlier status is detected through
+  // local-origin failure percentage statistics. This setting can be used to disable ejection or to
+  // ramp it up slowly. Defaults to 0.
+  google.protobuf.UInt32Value enforcing_failure_percentage_local_origin = 18
+      [(validate.rules).uint32 = {lte: 100}];
+
+  // The minimum number of hosts in a cluster in order to perform failure percentage-based ejection.
+  // If the total number of hosts in the cluster is less than this value, failure percentage-based
+  // ejection will not be performed. Defaults to 5.
+  google.protobuf.UInt32Value failure_percentage_minimum_hosts = 19;
+
+  // The minimum number of total requests that must be collected in one interval (as defined by the
+  // interval duration above) to perform failure percentage-based ejection for this host. If the
+  // volume is lower than this setting, failure percentage-based ejection will not be performed for
+  // this host. Defaults to 50.
+  google.protobuf.UInt32Value failure_percentage_request_volume = 20;
+
+  // The maximum time that a host is ejected for. See :ref:`base_ejection_time<envoy_v3_api_field_config.cluster.v3.OutlierDetection.base_ejection_time>`
+  // for more information. If not specified, the default value (300000ms or 300s) or
+  // :ref:`base_ejection_time<envoy_v3_api_field_config.cluster.v3.OutlierDetection.base_ejection_time>` value is applied, whatever is larger.
+  google.protobuf.Duration max_ejection_time = 21 [(validate.rules).duration = {gt {}}];
+
+  // The maximum amount of jitter to add to the ejection time, in order to prevent
+  // a 'thundering herd' effect where all proxies try to reconnect to host at the same time.
+  // See :ref:`max_ejection_time_jitter<envoy_v3_api_field_config.cluster.v3.OutlierDetection.base_ejection_time>`
+  // Defaults to 0s.
+  google.protobuf.Duration max_ejection_time_jitter = 22;
+
+  // If active health checking is enabled and a host is ejected by outlier detection, a successful active health check
+  // unejects the host by default and considers it as healthy. Unejection also clears all the outlier detection counters.
+  // To change this default behavior set this config to ``false`` where active health checking will not uneject the host.
+  // Defaults to true.
+  google.protobuf.BoolValue successful_active_health_check_uneject_host = 23;
+
+  // Set of host's passive monitors.
+  // [#not-implemented-hide:]
+  repeated core.v3.TypedExtensionConfig monitors = 24;
+
+  // If enabled, at least one host is ejected regardless of the value of :ref:`max_ejection_percent<envoy_v3_api_field_config.cluster.v3.OutlierDetection.max_ejection_percent>`.
+  // Defaults to false.
+  google.protobuf.BoolValue always_eject_one_host = 25;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/common/mutation_rules/v3/mutation_rules.proto b/xds/third_party/envoy/src/main/proto/envoy/config/common/mutation_rules/v3/mutation_rules.proto
new file mode 100644
index 00000000000..c015db21431
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/common/mutation_rules/v3/mutation_rules.proto
@@ -0,0 +1,113 @@
+syntax = "proto3";
+
+package envoy.config.common.mutation_rules.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/type/matcher/v3/regex.proto";
+import "envoy/type/matcher/v3/string.proto";
+
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.common.mutation_rules.v3";
+option java_outer_classname = "MutationRulesProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/common/mutation_rules/v3;mutation_rulesv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Header mutation rules]
+
+// The HeaderMutationRules structure specifies what headers may be
+// manipulated by a processing filter. This set of rules makes it
+// possible to control which modifications a filter may make.
+//
+// By default, an external processing server may add, modify, or remove
+// any header except for an "Envoy internal" header (which is typically
+// denoted by an x-envoy prefix) or specific headers that may affect
+// further filter processing:
+//
+// * ``host``
+// * ``:authority``
+// * ``:scheme``
+// * ``:method``
+//
+// Every attempt to add, change, append, or remove a header will be
+// tested against the rules here. Disallowed header mutations will be
+// ignored unless ``disallow_is_error`` is set to true.
+//
+// Attempts to remove headers are further constrained -- regardless of the
+// settings, system-defined headers (that start with ``:``) and the ``host``
+// header may never be removed.
+//
+// In addition, a counter will be incremented whenever a mutation is
+// rejected. In the ext_proc filter, that counter is named
+// ``rejected_header_mutations``.
+// [#next-free-field: 8]
+message HeaderMutationRules {
+  // By default, certain headers that could affect processing of subsequent
+  // filters or request routing cannot be modified. These headers are
+  // ``host``, ``:authority``, ``:scheme``, and ``:method``. Setting this parameter
+  // to true allows these headers to be modified as well.
+  google.protobuf.BoolValue allow_all_routing = 1;
+
+  // If true, allow modification of envoy internal headers. By default, these
+  // start with ``x-envoy`` but this may be overridden in the ``Bootstrap``
+  // configuration using the
+  // :ref:`header_prefix <envoy_v3_api_field_config.bootstrap.v3.Bootstrap.header_prefix>`
+  // field. Default is false.
+  google.protobuf.BoolValue allow_envoy = 2;
+
+  // If true, prevent modification of any system header, defined as a header
+  // that starts with a ``:`` character, regardless of any other settings.
+  // A processing server may still override the ``:status`` of an HTTP response
+  // using an ``ImmediateResponse`` message. Default is false.
+  google.protobuf.BoolValue disallow_system = 3;
+
+  // If true, prevent modifications of all header values, regardless of any
+  // other settings. A processing server may still override the ``:status``
+  // of an HTTP response using an ``ImmediateResponse`` message. Default is false.
+  google.protobuf.BoolValue disallow_all = 4;
+
+  // If set, specifically allow any header that matches this regular
+  // expression. This overrides all other settings except for
+  // ``disallow_expression``.
+  type.matcher.v3.RegexMatcher allow_expression = 5;
+
+  // If set, specifically disallow any header that matches this regular
+  // expression regardless of any other settings.
+  type.matcher.v3.RegexMatcher disallow_expression = 6;
+
+  // If true, and if the rules in this list cause a header mutation to be
+  // disallowed, then the filter using this configuration will terminate the
+  // request with a 500 error. In addition, regardless of the setting of this
+  // parameter, any attempt to set, add, or modify a disallowed header will
+  // cause the ``rejected_header_mutations`` counter to be incremented.
+  // Default is false.
+  google.protobuf.BoolValue disallow_is_error = 7;
+}
+
+// The HeaderMutation structure specifies an action that may be taken on HTTP
+// headers.
+message HeaderMutation {
+  message RemoveOnMatch {
+    // A string matcher that will be applied to the header key. If the header key
+    // matches, the header will be removed.
+    type.matcher.v3.StringMatcher key_matcher = 1 [(validate.rules).message = {required: true}];
+  }
+
+  oneof action {
+    option (validate.required) = true;
+
+    // Remove the specified header if it exists.
+    string remove = 1
+        [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+
+    // Append new header by the specified HeaderValueOption.
+    core.v3.HeaderValueOption append = 2;
+
+    // Remove the header if the key matches the specified string matcher.
+    RemoveOnMatch remove_on_match = 3;
+  }
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/address.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/address.proto
new file mode 100644
index 00000000000..238494a09c7
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/address.proto
@@ -0,0 +1,212 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/core/v3/socket_option.proto";
+
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "AddressProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Network addresses]
+
+message Pipe {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.Pipe";
+
+  // Unix Domain Socket path. On Linux, paths starting with '@' will use the
+  // abstract namespace. The starting '@' is replaced by a null byte by Envoy.
+  // Paths starting with '@' will result in an error in environments other than
+  // Linux.
+  string path = 1 [(validate.rules).string = {min_len: 1}];
+
+  // The mode for the Pipe. Not applicable for abstract sockets.
+  uint32 mode = 2 [(validate.rules).uint32 = {lte: 511}];
+}
+
+// The address represents an envoy internal listener.
+// [#comment: TODO(asraa): When address available, remove workaround from test/server/server_fuzz_test.cc:30.]
+message EnvoyInternalAddress {
+  oneof address_name_specifier {
+    option (validate.required) = true;
+
+    // Specifies the :ref:`name <envoy_v3_api_field_config.listener.v3.Listener.name>` of the
+    // internal listener.
+    string server_listener_name = 1;
+  }
+
+  // Specifies an endpoint identifier to distinguish between multiple endpoints for the same internal listener in a
+  // single upstream pool. Only used in the upstream addresses for tracking changes to individual endpoints. This, for
+  // example, may be set to the final destination IP for the target internal listener.
+  string endpoint_id = 2;
+}
+
+// [#next-free-field: 8]
+message SocketAddress {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.SocketAddress";
+
+  enum Protocol {
+    TCP = 0;
+    UDP = 1;
+  }
+
+  Protocol protocol = 1 [(validate.rules).enum = {defined_only: true}];
+
+  // The address for this socket. :ref:`Listeners <config_listeners>` will bind
+  // to the address. An empty address is not allowed. Specify ``0.0.0.0`` or ``::``
+  // to bind to any address. [#comment:TODO(zuercher) reinstate when implemented:
+  // It is possible to distinguish a Listener address via the prefix/suffix matching
+  // in :ref:`FilterChainMatch <envoy_v3_api_msg_config.listener.v3.FilterChainMatch>`.] When used
+  // within an upstream :ref:`BindConfig <envoy_v3_api_msg_config.core.v3.BindConfig>`, the address
+  // controls the source address of outbound connections. For :ref:`clusters
+  // <envoy_v3_api_msg_config.cluster.v3.Cluster>`, the cluster type determines whether the
+  // address must be an IP (``STATIC`` or ``EDS`` clusters) or a hostname resolved by DNS
+  // (``STRICT_DNS`` or ``LOGICAL_DNS`` clusters). Address resolution can be customized
+  // via :ref:`resolver_name <envoy_v3_api_field_config.core.v3.SocketAddress.resolver_name>`.
+  string address = 2 [(validate.rules).string = {min_len: 1}];
+
+  oneof port_specifier {
+    option (validate.required) = true;
+
+    uint32 port_value = 3 [(validate.rules).uint32 = {lte: 65535}];
+
+    // This is only valid if :ref:`resolver_name
+    // <envoy_v3_api_field_config.core.v3.SocketAddress.resolver_name>` is specified below and the
+    // named resolver is capable of named port resolution.
+    string named_port = 4;
+  }
+
+  // The name of the custom resolver. This must have been registered with Envoy. If
+  // this is empty, a context dependent default applies. If the address is a concrete
+  // IP address, no resolution will occur. If address is a hostname this
+  // should be set for resolution other than DNS. Specifying a custom resolver with
+  // ``STRICT_DNS`` or ``LOGICAL_DNS`` will generate an error at runtime.
+  string resolver_name = 5;
+
+  // When binding to an IPv6 address above, this enables `IPv4 compatibility
+  // <https://tools.ietf.org/html/rfc3493#page-11>`_. Binding to ``::`` will
+  // allow both IPv4 and IPv6 connections, with peer IPv4 addresses mapped into
+  // IPv6 space as ``::FFFF:<IPv4-address>``.
+  bool ipv4_compat = 6;
+
+  // Filepath that specifies the Linux network namespace this socket will be created in (see ``man 7
+  // network_namespaces``). If this field is set, Envoy will create the socket in the specified
+  // network namespace.
+  //
+  // .. note::
+  //    Setting this parameter requires Envoy to run with the ``CAP_NET_ADMIN`` capability.
+  //
+  // .. attention::
+  //     Network namespaces are only configurable on Linux. Otherwise, this field has no effect.
+  string network_namespace_filepath = 7;
+}
+
+message TcpKeepalive {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.TcpKeepalive";
+
+  // Maximum number of keepalive probes to send without response before deciding
+  // the connection is dead. Default is to use the OS level configuration (unless
+  // overridden, Linux defaults to 9.)
+  google.protobuf.UInt32Value keepalive_probes = 1;
+
+  // The number of seconds a connection needs to be idle before keep-alive probes
+  // start being sent. Default is to use the OS level configuration (unless
+  // overridden, Linux defaults to 7200s (i.e., 2 hours.)
+  google.protobuf.UInt32Value keepalive_time = 2;
+
+  // The number of seconds between keep-alive probes. Default is to use the OS
+  // level configuration (unless overridden, Linux defaults to 75s.)
+  google.protobuf.UInt32Value keepalive_interval = 3;
+}
+
+message ExtraSourceAddress {
+  // The additional address to bind.
+  SocketAddress address = 1 [(validate.rules).message = {required: true}];
+
+  // Additional socket options that may not be present in Envoy source code or
+  // precompiled binaries. If specified, this will override the
+  // :ref:`socket_options <envoy_v3_api_field_config.core.v3.BindConfig.socket_options>`
+  // in the BindConfig. If specified with no
+  // :ref:`socket_options <envoy_v3_api_field_config.core.v3.SocketOptionsOverride.socket_options>`
+  // or an empty list of :ref:`socket_options <envoy_v3_api_field_config.core.v3.SocketOptionsOverride.socket_options>`,
+  // it means no socket option will apply.
+  SocketOptionsOverride socket_options = 2;
+}
+
+// [#next-free-field: 7]
+message BindConfig {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.BindConfig";
+
+  // The address to bind to when creating a socket.
+  SocketAddress source_address = 1;
+
+  // Whether to set the ``IP_FREEBIND`` option when creating the socket. When this
+  // flag is set to true, allows the :ref:`source_address
+  // <envoy_v3_api_field_config.core.v3.BindConfig.source_address>` to be an IP address
+  // that is not configured on the system running Envoy. When this flag is set
+  // to false, the option ``IP_FREEBIND`` is disabled on the socket. When this
+  // flag is not set (default), the socket is not modified, i.e. the option is
+  // neither enabled nor disabled.
+  google.protobuf.BoolValue freebind = 2;
+
+  // Additional socket options that may not be present in Envoy source code or
+  // precompiled binaries.
+  repeated SocketOption socket_options = 3;
+
+  // Extra source addresses appended to the address specified in the ``source_address``
+  // field. This enables to specify multiple source addresses.
+  // The source address selection is determined by :ref:`local_address_selector
+  // <envoy_v3_api_field_config.core.v3.BindConfig.local_address_selector>`.
+  repeated ExtraSourceAddress extra_source_addresses = 5;
+
+  // Deprecated by
+  // :ref:`extra_source_addresses <envoy_v3_api_field_config.core.v3.BindConfig.extra_source_addresses>`
+  repeated SocketAddress additional_source_addresses = 4
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Custom local address selector to override the default (i.e.
+  // :ref:`DefaultLocalAddressSelector
+  // <envoy_v3_api_msg_config.upstream.local_address_selector.v3.DefaultLocalAddressSelector>`).
+  // [#extension-category: envoy.upstream.local_address_selector]
+  TypedExtensionConfig local_address_selector = 6;
+}
+
+// Addresses specify either a logical or physical address and port, which are
+// used to tell Envoy where to bind/listen, connect to upstream and find
+// management servers.
+message Address {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.Address";
+
+  oneof address {
+    option (validate.required) = true;
+
+    SocketAddress socket_address = 1;
+
+    Pipe pipe = 2;
+
+    // Specifies a user-space address handled by :ref:`internal listeners
+    // <envoy_v3_api_field_config.listener.v3.Listener.internal_listener>`.
+    EnvoyInternalAddress envoy_internal_address = 3;
+  }
+}
+
+// CidrRange specifies an IP Address and a prefix length to construct
+// the subnet mask for a `CIDR <https://tools.ietf.org/html/rfc4632>`_ range.
+message CidrRange {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.CidrRange";
+
+  // IPv4 or IPv6 address, e.g. ``192.0.0.0`` or ``2001:db8::``.
+  string address_prefix = 1 [(validate.rules).string = {min_len: 1}];
+
+  // Length of prefix, e.g. 0, 32. Defaults to 0 when unset.
+  google.protobuf.UInt32Value prefix_len = 2 [(validate.rules).uint32 = {lte: 128}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/backoff.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/backoff.proto
new file mode 100644
index 00000000000..435b36190e0
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/backoff.proto
@@ -0,0 +1,37 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "google/protobuf/duration.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "BackoffProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Backoff strategy]
+
+// Configuration defining a jittered exponential back off strategy.
+message BackoffStrategy {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.BackoffStrategy";
+
+  // The base interval to be used for the next back off computation. It should
+  // be greater than zero and less than or equal to :ref:`max_interval
+  // <envoy_v3_api_field_config.core.v3.BackoffStrategy.max_interval>`.
+  google.protobuf.Duration base_interval = 1 [(validate.rules).duration = {
+    required: true
+    gte {nanos: 1000000}
+  }];
+
+  // Specifies the maximum interval between retries. This parameter is optional,
+  // but must be greater than or equal to the :ref:`base_interval
+  // <envoy_v3_api_field_config.core.v3.BackoffStrategy.base_interval>` if set. The default
+  // is 10 times the :ref:`base_interval
+  // <envoy_v3_api_field_config.core.v3.BackoffStrategy.base_interval>`.
+  google.protobuf.Duration max_interval = 2 [(validate.rules).duration = {gt {}}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/base.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/base.proto
new file mode 100644
index 00000000000..978f365d5f9
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/base.proto
@@ -0,0 +1,662 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "envoy/config/core/v3/address.proto";
+import "envoy/config/core/v3/backoff.proto";
+import "envoy/config/core/v3/http_uri.proto";
+import "envoy/type/v3/percent.proto";
+import "envoy/type/v3/semantic_version.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/struct.proto";
+import "google/protobuf/wrappers.proto";
+
+import "xds/core/v3/context_params.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "BaseProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Common types]
+
+// Envoy supports :ref:`upstream priority routing
+// <arch_overview_http_routing_priority>` both at the route and the virtual
+// cluster level. The current priority implementation uses different connection
+// pool and circuit breaking settings for each priority level. This means that
+// even for HTTP/2 requests, two physical connections will be used to an
+// upstream host. In the future Envoy will likely support true HTTP/2 priority
+// over a single upstream connection.
+enum RoutingPriority {
+  DEFAULT = 0;
+  HIGH = 1;
+}
+
+// HTTP request method.
+enum RequestMethod {
+  METHOD_UNSPECIFIED = 0;
+  GET = 1;
+  HEAD = 2;
+  POST = 3;
+  PUT = 4;
+  DELETE = 5;
+  CONNECT = 6;
+  OPTIONS = 7;
+  TRACE = 8;
+  PATCH = 9;
+}
+
+// Identifies the direction of the traffic relative to the local Envoy.
+enum TrafficDirection {
+  // Default option is unspecified.
+  UNSPECIFIED = 0;
+
+  // The transport is used for incoming traffic.
+  INBOUND = 1;
+
+  // The transport is used for outgoing traffic.
+  OUTBOUND = 2;
+}
+
+// Identifies location of where either Envoy runs or where upstream hosts run.
+message Locality {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.Locality";
+
+  // Region this :ref:`zone <envoy_v3_api_field_config.core.v3.Locality.zone>` belongs to.
+  string region = 1;
+
+  // Defines the local service zone where Envoy is running. Though optional, it
+  // should be set if discovery service routing is used and the discovery
+  // service exposes :ref:`zone data <envoy_v3_api_field_config.endpoint.v3.LocalityLbEndpoints.locality>`,
+  // either in this message or via :option:`--service-zone`. The meaning of zone
+  // is context dependent, e.g. `Availability Zone (AZ)
+  // <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html>`_
+  // on AWS, `Zone <https://cloud.google.com/compute/docs/regions-zones/>`_ on
+  // GCP, etc.
+  string zone = 2;
+
+  // When used for locality of upstream hosts, this field further splits zone
+  // into smaller chunks of sub-zones so they can be load balanced
+  // independently.
+  string sub_zone = 3;
+}
+
+// BuildVersion combines SemVer version of extension with free-form build information
+// (i.e. 'alpha', 'private-build') as a set of strings.
+message BuildVersion {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.BuildVersion";
+
+  // SemVer version of extension.
+  type.v3.SemanticVersion version = 1;
+
+  // Free-form build information.
+  // Envoy defines several well known keys in the source/common/version/version.h file
+  google.protobuf.Struct metadata = 2;
+}
+
+// Version and identification for an Envoy extension.
+// [#next-free-field: 7]
+message Extension {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.Extension";
+
+  // This is the name of the Envoy filter as specified in the Envoy
+  // configuration, e.g. envoy.filters.http.router, com.acme.widget.
+  string name = 1;
+
+  // Category of the extension.
+  // Extension category names use reverse DNS notation. For instance "envoy.filters.listener"
+  // for Envoy's built-in listener filters or "com.acme.filters.http" for HTTP filters from
+  // acme.com vendor.
+  // [#comment:TODO(yanavlasov): Link to the doc with existing envoy category names.]
+  string category = 2;
+
+  // [#not-implemented-hide:] Type descriptor of extension configuration proto.
+  // [#comment:TODO(yanavlasov): Link to the doc with existing configuration protos.]
+  // [#comment:TODO(yanavlasov): Add tests when PR #9391 lands.]
+  string type_descriptor = 3
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // The version is a property of the extension and maintained independently
+  // of other extensions and the Envoy API.
+  // This field is not set when extension did not provide version information.
+  BuildVersion version = 4;
+
+  // Indicates that the extension is present but was disabled via dynamic configuration.
+  bool disabled = 5;
+
+  // Type URLs of extension configuration protos.
+  repeated string type_urls = 6;
+}
+
+// Identifies a specific Envoy instance. The node identifier is presented to the
+// management server, which may use this identifier to distinguish per Envoy
+// configuration for serving.
+// [#next-free-field: 13]
+message Node {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.Node";
+
+  reserved 5;
+
+  reserved "build_version";
+
+  // An opaque node identifier for the Envoy node. This also provides the local
+  // service node name. It should be set if any of the following features are
+  // used: :ref:`statsd <arch_overview_statistics>`, :ref:`CDS
+  // <config_cluster_manager_cds>`, and :ref:`HTTP tracing
+  // <arch_overview_tracing>`, either in this message or via
+  // :option:`--service-node`.
+  string id = 1;
+
+  // Defines the local service cluster name where Envoy is running. Though
+  // optional, it should be set if any of the following features are used:
+  // :ref:`statsd <arch_overview_statistics>`, :ref:`health check cluster
+  // verification
+  // <envoy_v3_api_field_config.core.v3.HealthCheck.HttpHealthCheck.service_name_matcher>`,
+  // :ref:`runtime override directory <envoy_v3_api_msg_config.bootstrap.v3.Runtime>`,
+  // :ref:`user agent addition
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.add_user_agent>`,
+  // :ref:`HTTP global rate limiting <config_http_filters_rate_limit>`,
+  // :ref:`CDS <config_cluster_manager_cds>`, and :ref:`HTTP tracing
+  // <arch_overview_tracing>`, either in this message or via
+  // :option:`--service-cluster`.
+  string cluster = 2;
+
+  // Opaque metadata extending the node identifier. Envoy will pass this
+  // directly to the management server.
+  google.protobuf.Struct metadata = 3;
+
+  // Map from xDS resource type URL to dynamic context parameters. These may vary at runtime (unlike
+  // other fields in this message). For example, the xDS client may have a shard identifier that
+  // changes during the lifetime of the xDS client. In Envoy, this would be achieved by updating the
+  // dynamic context on the Server::Instance's LocalInfo context provider. The shard ID dynamic
+  // parameter then appears in this field during future discovery requests.
+  map<string, xds.core.v3.ContextParams> dynamic_parameters = 12;
+
+  // Locality specifying where the Envoy instance is running.
+  Locality locality = 4;
+
+  // Free-form string that identifies the entity requesting config.
+  // E.g. "envoy" or "grpc"
+  string user_agent_name = 6;
+
+  oneof user_agent_version_type {
+    // Free-form string that identifies the version of the entity requesting config.
+    // E.g. "1.12.2" or "abcd1234", or "SpecialEnvoyBuild"
+    string user_agent_version = 7;
+
+    // Structured version of the entity requesting config.
+    BuildVersion user_agent_build_version = 8;
+  }
+
+  // List of extensions and their versions supported by the node.
+  repeated Extension extensions = 9;
+
+  // Client feature support list. These are well known features described
+  // in the Envoy API repository for a given major version of an API. Client features
+  // use reverse DNS naming scheme, for example ``com.acme.feature``.
+  // See :ref:`the list of features <client_features>` that xDS client may
+  // support.
+  repeated string client_features = 10;
+
+  // Known listening ports on the node as a generic hint to the management server
+  // for filtering :ref:`listeners <config_listeners>` to be returned. For example,
+  // if there is a listener bound to port 80, the list can optionally contain the
+  // SocketAddress ``(0.0.0.0,80)``. The field is optional and just a hint.
+  repeated Address listening_addresses = 11
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+}
+
+// Metadata provides additional inputs to filters based on matched listeners,
+// filter chains, routes and endpoints. It is structured as a map, usually from
+// filter name (in reverse DNS format) to metadata specific to the filter. Metadata
+// key-values for a filter are merged as connection and request handling occurs,
+// with later values for the same key overriding earlier values.
+//
+// An example use of metadata is providing additional values to
+// http_connection_manager in the envoy.http_connection_manager.access_log
+// namespace.
+//
+// Another example use of metadata is to per service config info in cluster metadata, which may get
+// consumed by multiple filters.
+//
+// For load balancing, Metadata provides a means to subset cluster endpoints.
+// Endpoints have a Metadata object associated and routes contain a Metadata
+// object to match against. There are some well defined metadata used today for
+// this purpose:
+//
+// * ``{"envoy.lb": {"canary": <bool> }}`` This indicates the canary status of an
+//   endpoint and is also used during header processing
+//   (x-envoy-upstream-canary) and for stats purposes.
+// [#next-major-version: move to type/metadata/v2]
+message Metadata {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.Metadata";
+
+  // Key is the reverse DNS filter name, e.g. com.acme.widget. The ``envoy.*``
+  // namespace is reserved for Envoy's built-in filters.
+  // If both ``filter_metadata`` and
+  // :ref:`typed_filter_metadata <envoy_v3_api_field_config.core.v3.Metadata.typed_filter_metadata>`
+  // fields are present in the metadata with same keys,
+  // only ``typed_filter_metadata`` field will be parsed.
+  map<string, google.protobuf.Struct> filter_metadata = 1
+      [(validate.rules).map = {keys {string {min_len: 1}}}];
+
+  // Key is the reverse DNS filter name, e.g. com.acme.widget. The ``envoy.*``
+  // namespace is reserved for Envoy's built-in filters.
+  // The value is encoded as google.protobuf.Any.
+  // If both :ref:`filter_metadata <envoy_v3_api_field_config.core.v3.Metadata.filter_metadata>`
+  // and ``typed_filter_metadata`` fields are present in the metadata with same keys,
+  // only ``typed_filter_metadata`` field will be parsed.
+  map<string, google.protobuf.Any> typed_filter_metadata = 2
+      [(validate.rules).map = {keys {string {min_len: 1}}}];
+}
+
+// Runtime derived uint32 with a default when not specified.
+message RuntimeUInt32 {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.RuntimeUInt32";
+
+  // Default value if runtime value is not available.
+  uint32 default_value = 2;
+
+  // Runtime key to get value for comparison. This value is used if defined.
+  string runtime_key = 3;
+}
+
+// Runtime derived percentage with a default when not specified.
+message RuntimePercent {
+  // Default value if runtime value is not available.
+  type.v3.Percent default_value = 1;
+
+  // Runtime key to get value for comparison. This value is used if defined.
+  string runtime_key = 2;
+}
+
+// Runtime derived double with a default when not specified.
+message RuntimeDouble {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.RuntimeDouble";
+
+  // Default value if runtime value is not available.
+  double default_value = 1;
+
+  // Runtime key to get value for comparison. This value is used if defined.
+  string runtime_key = 2;
+}
+
+// Runtime derived bool with a default when not specified.
+message RuntimeFeatureFlag {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.core.RuntimeFeatureFlag";
+
+  // Default value if runtime value is not available.
+  google.protobuf.BoolValue default_value = 1 [(validate.rules).message = {required: true}];
+
+  // Runtime key to get value for comparison. This value is used if defined. The boolean value must
+  // be represented via its
+  // `canonical JSON encoding <https://developers.google.com/protocol-buffers/docs/proto3#json>`_.
+  string runtime_key = 2;
+}
+
+// Please use :ref:`KeyValuePair <envoy_api_msg_config.core.v3.KeyValuePair>` instead.
+// [#not-implemented-hide:]
+message KeyValue {
+  // The key of the key/value pair.
+  string key = 1 [
+    deprecated = true,
+    (validate.rules).string = {min_len: 1 max_bytes: 16384},
+    (envoy.annotations.deprecated_at_minor_version) = "3.0"
+  ];
+
+  // The value of the key/value pair.
+  //
+  // The ``bytes`` type is used. This means if JSON or YAML is used to to represent the
+  // configuration, the value must be base64 encoded. This is unfriendly for users in most
+  // use scenarios of this message.
+  //
+  bytes value = 2 [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+}
+
+message KeyValuePair {
+  // The key of the key/value pair.
+  string key = 1 [(validate.rules).string = {min_len: 1 max_bytes: 16384}];
+
+  // The value of the key/value pair.
+  google.protobuf.Value value = 2;
+}
+
+// Key/value pair plus option to control append behavior. This is used to specify
+// key/value pairs that should be appended to a set of existing key/value pairs.
+message KeyValueAppend {
+  // Describes the supported actions types for key/value pair append action.
+  enum KeyValueAppendAction {
+    // If the key already exists, this action will result in the following behavior:
+    //
+    // - Comma-concatenated value if multiple values are not allowed.
+    // - New value added to the list of values if multiple values are allowed.
+    //
+    // If the key doesn't exist then this will add pair with specified key and value.
+    APPEND_IF_EXISTS_OR_ADD = 0;
+
+    // This action will add the key/value pair if it doesn't already exist. If the
+    // key already exists then this will be a no-op.
+    ADD_IF_ABSENT = 1;
+
+    // This action will overwrite the specified value by discarding any existing
+    // values if the key already exists. If the key doesn't exist then this will add
+    // the pair with specified key and value.
+    OVERWRITE_IF_EXISTS_OR_ADD = 2;
+
+    // This action will overwrite the specified value by discarding any existing
+    // values if the key already exists. If the key doesn't exist then this will
+    // be no-op.
+    OVERWRITE_IF_EXISTS = 3;
+  }
+
+  // The single key/value pair record to be appended or overridden. This field must be set.
+  KeyValuePair record = 3;
+
+  // Key/value pair entry that this option to append or overwrite. This field is deprecated
+  // and please use :ref:`record <envoy_v3_api_field_config.core.v3.KeyValueAppend.record>`
+  // as replacement.
+  // [#not-implemented-hide:]
+  KeyValue entry = 1 [
+    deprecated = true,
+    (validate.rules).message = {skip: true},
+    (envoy.annotations.deprecated_at_minor_version) = "3.0"
+  ];
+
+  // Describes the action taken to append/overwrite the given value for an existing
+  // key or to only add this key if it's absent.
+  KeyValueAppendAction action = 2 [(validate.rules).enum = {defined_only: true}];
+}
+
+// Key/value pair to append or remove.
+message KeyValueMutation {
+  // Key/value pair to append or overwrite. Only one of ``append`` or ``remove`` can be set or
+  // the configuration will be rejected.
+  KeyValueAppend append = 1;
+
+  // Key to remove. Only one of ``append`` or ``remove`` can be set or the configuration will be
+  // rejected.
+  string remove = 2 [(validate.rules).string = {max_bytes: 16384}];
+}
+
+// Query parameter name/value pair.
+message QueryParameter {
+  // The key of the query parameter. Case sensitive.
+  string key = 1 [(validate.rules).string = {min_len: 1}];
+
+  // The value of the query parameter.
+  string value = 2;
+}
+
+// Header name/value pair.
+message HeaderValue {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.HeaderValue";
+
+  // Header name.
+  string key = 1
+      [(validate.rules).string =
+           {min_len: 1 max_bytes: 16384 well_known_regex: HTTP_HEADER_NAME strict: false}];
+
+  // Header value.
+  //
+  // The same :ref:`format specifier <config_access_log_format>` as used for
+  // :ref:`HTTP access logging <config_access_log>` applies here, however
+  // unknown header values are replaced with the empty string instead of ``-``.
+  // Header value is encoded as string. This does not work for non-utf8 characters.
+  // Only one of ``value`` or ``raw_value`` can be set.
+  string value = 2 [
+    (validate.rules).string = {max_bytes: 16384 well_known_regex: HTTP_HEADER_VALUE strict: false},
+    (udpa.annotations.field_migrate).oneof_promotion = "value_type"
+  ];
+
+  // Header value is encoded as bytes which can support non-utf8 characters.
+  // Only one of ``value`` or ``raw_value`` can be set.
+  bytes raw_value = 3 [
+    (validate.rules).bytes = {min_len: 0 max_len: 16384},
+    (udpa.annotations.field_migrate).oneof_promotion = "value_type"
+  ];
+}
+
+// Header name/value pair plus option to control append behavior.
+message HeaderValueOption {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.core.HeaderValueOption";
+
+  // Describes the supported actions types for header append action.
+  enum HeaderAppendAction {
+    // If the header already exists, this action will result in:
+    //
+    // - Comma-concatenated for predefined inline headers.
+    // - Duplicate header added in the ``HeaderMap`` for other headers.
+    //
+    // If the header doesn't exist then this will add new header with specified key and value.
+    APPEND_IF_EXISTS_OR_ADD = 0;
+
+    // This action will add the header if it doesn't already exist. If the header
+    // already exists then this will be a no-op.
+    ADD_IF_ABSENT = 1;
+
+    // This action will overwrite the specified value by discarding any existing values if
+    // the header already exists. If the header doesn't exist then this will add the header
+    // with specified key and value.
+    OVERWRITE_IF_EXISTS_OR_ADD = 2;
+
+    // This action will overwrite the specified value by discarding any existing values if
+    // the header already exists. If the header doesn't exist then this will be no-op.
+    OVERWRITE_IF_EXISTS = 3;
+  }
+
+  // Header name/value pair that this option applies to.
+  HeaderValue header = 1 [(validate.rules).message = {required: true}];
+
+  // Should the value be appended? If true (default), the value is appended to
+  // existing values. Otherwise it replaces any existing values.
+  // This field is deprecated and please use
+  // :ref:`append_action <envoy_v3_api_field_config.core.v3.HeaderValueOption.append_action>` as replacement.
+  //
+  // .. note::
+  //   The :ref:`external authorization service <envoy_v3_api_msg_service.auth.v3.CheckResponse>` and
+  //   :ref:`external processor service <envoy_v3_api_msg_service.ext_proc.v3.ProcessingResponse>` have
+  //   default value (``false``) for this field.
+  google.protobuf.BoolValue append = 2
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Describes the action taken to append/overwrite the given value for an existing header
+  // or to only add this header if it's absent.
+  // Value defaults to :ref:`APPEND_IF_EXISTS_OR_ADD
+  // <envoy_v3_api_enum_value_config.core.v3.HeaderValueOption.HeaderAppendAction.APPEND_IF_EXISTS_OR_ADD>`.
+  HeaderAppendAction append_action = 3 [(validate.rules).enum = {defined_only: true}];
+
+  // Is the header value allowed to be empty? If false (default), custom headers with empty values are dropped,
+  // otherwise they are added.
+  bool keep_empty_value = 4;
+}
+
+// Wrapper for a set of headers.
+message HeaderMap {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.HeaderMap";
+
+  // A list of header names and their values.
+  repeated HeaderValue headers = 1;
+}
+
+// A directory that is watched for changes, e.g. by inotify on Linux. Move/rename
+// events inside this directory trigger the watch.
+message WatchedDirectory {
+  // Directory path to watch.
+  string path = 1 [(validate.rules).string = {min_len: 1}];
+}
+
+// Data source consisting of a file, an inline value, or an environment variable.
+// [#next-free-field: 6]
+message DataSource {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.DataSource";
+
+  oneof specifier {
+    option (validate.required) = true;
+
+    // Local filesystem data source.
+    string filename = 1 [(validate.rules).string = {min_len: 1}];
+
+    // Bytes inlined in the configuration.
+    bytes inline_bytes = 2;
+
+    // String inlined in the configuration.
+    string inline_string = 3;
+
+    // Environment variable data source.
+    string environment_variable = 4 [(validate.rules).string = {min_len: 1}];
+  }
+
+  // Watched directory that is watched for file changes. If this is set explicitly, the file
+  // specified in the ``filename`` field will be reloaded when relevant file move events occur.
+  //
+  // .. note::
+  //   This field only makes sense when the ``filename`` field is set.
+  //
+  // .. note::
+  //   Envoy only updates when the file is replaced by a file move, and not when the file is
+  //   edited in place.
+  //
+  // .. note::
+  //   Not all use cases of ``DataSource`` support watching directories. It depends on the
+  //   specific usage of the ``DataSource``. See the documentation of the parent message for
+  //   details.
+  WatchedDirectory watched_directory = 5;
+}
+
+// The message specifies the retry policy of remote data source when fetching fails.
+// [#next-free-field: 7]
+message RetryPolicy {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.RetryPolicy";
+
+  // See :ref:`RetryPriority <envoy_v3_api_field_config.route.v3.RetryPolicy.retry_priority>`.
+  message RetryPriority {
+    string name = 1 [(validate.rules).string = {min_len: 1}];
+
+    oneof config_type {
+      google.protobuf.Any typed_config = 2;
+    }
+  }
+
+  // See :ref:`RetryHostPredicate <envoy_v3_api_field_config.route.v3.RetryPolicy.retry_host_predicate>`.
+  message RetryHostPredicate {
+    string name = 1 [(validate.rules).string = {min_len: 1}];
+
+    oneof config_type {
+      google.protobuf.Any typed_config = 2;
+    }
+  }
+
+  // Specifies parameters that control :ref:`retry backoff strategy <envoy_v3_api_msg_config.core.v3.BackoffStrategy>`.
+  // This parameter is optional, in which case the default base interval is 1000 milliseconds. The
+  // default maximum interval is 10 times the base interval.
+  BackoffStrategy retry_back_off = 1;
+
+  // Specifies the allowed number of retries. This parameter is optional and
+  // defaults to 1.
+  google.protobuf.UInt32Value num_retries = 2
+      [(udpa.annotations.field_migrate).rename = "max_retries"];
+
+  // For details, see :ref:`retry_on <envoy_v3_api_field_config.route.v3.RetryPolicy.retry_on>`.
+  string retry_on = 3;
+
+  // For details, see :ref:`retry_priority <envoy_v3_api_field_config.route.v3.RetryPolicy.retry_priority>`.
+  RetryPriority retry_priority = 4;
+
+  // For details, see :ref:`RetryHostPredicate <envoy_v3_api_field_config.route.v3.RetryPolicy.retry_host_predicate>`.
+  repeated RetryHostPredicate retry_host_predicate = 5;
+
+  // For details, see :ref:`host_selection_retry_max_attempts <envoy_v3_api_field_config.route.v3.RetryPolicy.host_selection_retry_max_attempts>`.
+  int64 host_selection_retry_max_attempts = 6;
+}
+
+// The message specifies how to fetch data from remote and how to verify it.
+message RemoteDataSource {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.RemoteDataSource";
+
+  // The HTTP URI to fetch the remote data.
+  HttpUri http_uri = 1 [(validate.rules).message = {required: true}];
+
+  // SHA256 string for verifying data.
+  string sha256 = 2 [(validate.rules).string = {min_len: 1}];
+
+  // Retry policy for fetching remote data.
+  RetryPolicy retry_policy = 3;
+}
+
+// Async data source which support async data fetch.
+message AsyncDataSource {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.AsyncDataSource";
+
+  oneof specifier {
+    option (validate.required) = true;
+
+    // Local async data source.
+    DataSource local = 1;
+
+    // Remote async data source.
+    RemoteDataSource remote = 2;
+  }
+}
+
+// Configuration for transport socket in :ref:`listeners <config_listeners>` and
+// :ref:`clusters <envoy_v3_api_msg_config.cluster.v3.Cluster>`. If the configuration is
+// empty, a default transport socket implementation and configuration will be
+// chosen based on the platform and existence of tls_context.
+message TransportSocket {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.TransportSocket";
+
+  reserved 2;
+
+  reserved "config";
+
+  // The name of the transport socket to instantiate. The name must match a supported transport
+  // socket implementation.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // Implementation specific configuration which depends on the implementation being instantiated.
+  // See the supported transport socket implementations for further documentation.
+  oneof config_type {
+    google.protobuf.Any typed_config = 3;
+  }
+}
+
+// Runtime derived FractionalPercent with defaults for when the numerator or denominator is not
+// specified via a runtime key.
+//
+// .. note::
+//
+//   Parsing of the runtime key's data is implemented such that it may be represented as a
+//   :ref:`FractionalPercent <envoy_v3_api_msg_type.v3.FractionalPercent>` proto represented as JSON/YAML
+//   and may also be represented as an integer with the assumption that the value is an integral
+//   percentage out of 100. For instance, a runtime key lookup returning the value "42" would parse
+//   as a ``FractionalPercent`` whose numerator is 42 and denominator is HUNDRED.
+message RuntimeFractionalPercent {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.core.RuntimeFractionalPercent";
+
+  // Default value if the runtime value's for the numerator/denominator keys are not available.
+  type.v3.FractionalPercent default_value = 1 [(validate.rules).message = {required: true}];
+
+  // Runtime key for a YAML representation of a FractionalPercent.
+  string runtime_key = 2;
+}
+
+// Identifies a specific ControlPlane instance that Envoy is connected to.
+message ControlPlane {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.ControlPlane";
+
+  // An opaque control plane identifier that uniquely identifies an instance
+  // of control plane. This can be used to identify which control plane instance,
+  // the Envoy is connected to.
+  string identifier = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/config_source.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/config_source.proto
new file mode 100644
index 00000000000..430562aa5bd
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/config_source.proto
@@ -0,0 +1,283 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/core/v3/grpc_service.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "xds/core/v3/authority.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "ConfigSourceProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Configuration sources]
+
+// xDS API and non-xDS services version. This is used to describe both resource and transport
+// protocol versions (in distinct configuration fields).
+enum ApiVersion {
+  // When not specified, we assume v3; it is the only supported version.
+  AUTO = 0;
+
+  // Use xDS v2 API. This is no longer supported.
+  V2 = 1 [deprecated = true, (envoy.annotations.deprecated_at_minor_version_enum) = "3.0"];
+
+  // Use xDS v3 API.
+  V3 = 2;
+}
+
+// API configuration source. This identifies the API type and cluster that Envoy
+// will use to fetch an xDS API.
+// [#next-free-field: 10]
+message ApiConfigSource {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.ApiConfigSource";
+
+  // APIs may be fetched via either REST or gRPC.
+  enum ApiType {
+    // Ideally this would be 'reserved 0' but one can't reserve the default
+    // value. Instead we throw an exception if this is ever used.
+    DEPRECATED_AND_UNAVAILABLE_DO_NOT_USE = 0
+        [deprecated = true, (envoy.annotations.disallowed_by_default_enum) = true];
+
+    // REST-JSON v2 API. The `canonical JSON encoding
+    // <https://developers.google.com/protocol-buffers/docs/proto3#json>`_ for
+    // the v2 protos is used.
+    REST = 1;
+
+    // SotW gRPC service.
+    GRPC = 2;
+
+    // Using the delta xDS gRPC service, i.e. DeltaDiscovery{Request,Response}
+    // rather than Discovery{Request,Response}. Rather than sending Envoy the entire state
+    // with every update, the xDS server only sends what has changed since the last update.
+    DELTA_GRPC = 3;
+
+    // SotW xDS gRPC with ADS. All resources which resolve to this configuration source will be
+    // multiplexed on a single connection to an ADS endpoint.
+    // [#not-implemented-hide:]
+    AGGREGATED_GRPC = 5;
+
+    // Delta xDS gRPC with ADS. All resources which resolve to this configuration source will be
+    // multiplexed on a single connection to an ADS endpoint.
+    // [#not-implemented-hide:]
+    AGGREGATED_DELTA_GRPC = 6;
+  }
+
+  // API type (gRPC, REST, delta gRPC)
+  ApiType api_type = 1 [(validate.rules).enum = {defined_only: true}];
+
+  // API version for xDS transport protocol. This describes the xDS gRPC/REST
+  // endpoint and version of [Delta]DiscoveryRequest/Response used on the wire.
+  ApiVersion transport_api_version = 8 [(validate.rules).enum = {defined_only: true}];
+
+  // Cluster names should be used only with REST. If > 1
+  // cluster is defined, clusters will be cycled through if any kind of failure
+  // occurs.
+  //
+  // .. note::
+  //
+  //  The cluster with name ``cluster_name`` must be statically defined and its
+  //  type must not be ``EDS``.
+  repeated string cluster_names = 2;
+
+  // Multiple gRPC services be provided for GRPC. If > 1 cluster is defined,
+  // services will be cycled through if any kind of failure occurs.
+  repeated GrpcService grpc_services = 4;
+
+  // For REST APIs, the delay between successive polls.
+  google.protobuf.Duration refresh_delay = 3;
+
+  // For REST APIs, the request timeout. If not set, a default value of 1s will be used.
+  google.protobuf.Duration request_timeout = 5 [(validate.rules).duration = {gt {}}];
+
+  // For GRPC APIs, the rate limit settings. If present, discovery requests made by Envoy will be
+  // rate limited.
+  RateLimitSettings rate_limit_settings = 6;
+
+  // Skip the node identifier in subsequent discovery requests for streaming gRPC config types.
+  bool set_node_on_first_message_only = 7;
+
+  // A list of config validators that will be executed when a new update is
+  // received from the ApiConfigSource. Note that each validator handles a
+  // specific xDS service type, and only the validators corresponding to the
+  // type url (in ``:ref: DiscoveryResponse`` or ``:ref: DeltaDiscoveryResponse``)
+  // will be invoked.
+  // If the validator returns false or throws an exception, the config will be rejected by
+  // the client, and a NACK will be sent.
+  // [#extension-category: envoy.config.validators]
+  repeated TypedExtensionConfig config_validators = 9;
+}
+
+// Aggregated Discovery Service (ADS) options. This is currently empty, but when
+// set in :ref:`ConfigSource <envoy_v3_api_msg_config.core.v3.ConfigSource>` can be used to
+// specify that ADS is to be used.
+message AggregatedConfigSource {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.core.AggregatedConfigSource";
+}
+
+// [#not-implemented-hide:]
+// Self-referencing config source options. This is currently empty, but when
+// set in :ref:`ConfigSource <envoy_v3_api_msg_config.core.v3.ConfigSource>` can be used to
+// specify that other data can be obtained from the same server.
+message SelfConfigSource {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.SelfConfigSource";
+
+  // API version for xDS transport protocol. This describes the xDS gRPC/REST
+  // endpoint and version of [Delta]DiscoveryRequest/Response used on the wire.
+  ApiVersion transport_api_version = 1 [(validate.rules).enum = {defined_only: true}];
+}
+
+// Rate Limit settings to be applied for discovery requests made by Envoy.
+message RateLimitSettings {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.core.RateLimitSettings";
+
+  // Maximum number of tokens to be used for rate limiting discovery request calls. If not set, a
+  // default value of 100 will be used.
+  google.protobuf.UInt32Value max_tokens = 1;
+
+  // Rate at which tokens will be filled per second. If not set, a default fill rate of 10 tokens
+  // per second will be used. The minimal fill rate is once per year. Lower
+  // fill rates will be set to once per year.
+  google.protobuf.DoubleValue fill_rate = 2 [(validate.rules).double = {gt: 0.0}];
+}
+
+// Local filesystem path configuration source.
+message PathConfigSource {
+  // Path on the filesystem to source and watch for configuration updates.
+  // When sourcing configuration for a :ref:`secret <envoy_v3_api_msg_extensions.transport_sockets.tls.v3.Secret>`,
+  // the certificate and key files are also watched for updates.
+  //
+  // .. note::
+  //
+  //  The path to the source must exist at config load time.
+  //
+  // .. note::
+  //
+  //   If ``watched_directory`` is *not* configured, Envoy will watch the file path for *moves*.
+  //   This is because in general only moves are atomic. The same method of swapping files as is
+  //   demonstrated in the :ref:`runtime documentation <config_runtime_symbolic_link_swap>` can be
+  //   used here also. If ``watched_directory`` is configured, no watch will be placed directly on
+  //   this path. Instead, the configured ``watched_directory`` will be used to trigger reloads of
+  //   this path. This is required in certain deployment scenarios. See below for more information.
+  string path = 1 [(validate.rules).string = {min_len: 1}];
+
+  // If configured, this directory will be watched for *moves*. When an entry in this directory is
+  // moved to, the ``path`` will be reloaded. This is required in certain deployment scenarios.
+  //
+  // Specifically, if trying to load an xDS resource using a
+  // `Kubernetes ConfigMap <https://kubernetes.io/docs/concepts/configuration/configmap/>`_, the
+  // following configuration might be used:
+  // 1. Store xds.yaml inside a ConfigMap.
+  // 2. Mount the ConfigMap to ``/config_map/xds``
+  // 3. Configure path ``/config_map/xds/xds.yaml``
+  // 4. Configure watched directory ``/config_map/xds``
+  //
+  // The above configuration will ensure that Envoy watches the owning directory for moves which is
+  // required due to how Kubernetes manages ConfigMap symbolic links during atomic updates.
+  WatchedDirectory watched_directory = 2;
+}
+
+// Configuration for :ref:`listeners <config_listeners>`, :ref:`clusters
+// <config_cluster_manager>`, :ref:`routes
+// <envoy_v3_api_msg_config.route.v3.RouteConfiguration>`, :ref:`endpoints
+// <arch_overview_service_discovery>` etc. may either be sourced from the
+// filesystem or from an xDS API source. Filesystem configs are watched with
+// inotify for updates.
+// [#next-free-field: 9]
+message ConfigSource {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.ConfigSource";
+
+  // Authorities that this config source may be used for. An authority specified in a xdstp:// URL
+  // is resolved to a ``ConfigSource`` prior to configuration fetch. This field provides the
+  // association between authority name and configuration source.
+  // [#not-implemented-hide:]
+  repeated xds.core.v3.Authority authorities = 7;
+
+  oneof config_source_specifier {
+    option (validate.required) = true;
+
+    // Deprecated in favor of ``path_config_source``. Use that field instead.
+    string path = 1 [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+    // Local filesystem path configuration source.
+    PathConfigSource path_config_source = 8;
+
+    // API configuration source.
+    ApiConfigSource api_config_source = 2;
+
+    // When set, ADS will be used to fetch resources. The ADS API configuration
+    // source in the bootstrap configuration is used.
+    AggregatedConfigSource ads = 3;
+
+    // [#not-implemented-hide:]
+    // When set, the client will access the resources from the same server it got the
+    // ConfigSource from, although not necessarily from the same stream. This is similar to the
+    // :ref:`ads<envoy_v3_api_field.ConfigSource.ads>` field, except that the client may use a
+    // different stream to the same server. As a result, this field can be used for things
+    // like LRS that cannot be sent on an ADS stream. It can also be used to link from (e.g.)
+    // LDS to RDS on the same server without requiring the management server to know its name
+    // or required credentials.
+    // [#next-major-version: In xDS v3, consider replacing the ads field with this one, since
+    // this field can implicitly mean to use the same stream in the case where the ConfigSource
+    // is provided via ADS and the specified data can also be obtained via ADS.]
+    SelfConfigSource self = 5;
+  }
+
+  // When this timeout is specified, Envoy will wait no longer than the specified time for first
+  // config response on this xDS subscription during the :ref:`initialization process
+  // <arch_overview_initialization>`. After reaching the timeout, Envoy will move to the next
+  // initialization phase, even if the first config is not delivered yet. The timer is activated
+  // when the xDS API subscription starts, and is disarmed on first config update or on error. 0
+  // means no timeout - Envoy will wait indefinitely for the first xDS config (unless another
+  // timeout applies). The default is 15s.
+  google.protobuf.Duration initial_fetch_timeout = 4;
+
+  // API version for xDS resources. This implies the type URLs that the client
+  // will request for resources and the resource type that the client will in
+  // turn expect to be delivered.
+  ApiVersion resource_api_version = 6 [(validate.rules).enum = {defined_only: true}];
+}
+
+// Configuration source specifier for a late-bound extension configuration. The
+// parent resource is warmed until all the initial extension configurations are
+// received, unless the flag to apply the default configuration is set.
+// Subsequent extension updates are atomic on a per-worker basis. Once an
+// extension configuration is applied to a request or a connection, it remains
+// constant for the duration of processing. If the initial delivery of the
+// extension configuration fails, due to a timeout for example, the optional
+// default configuration is applied. Without a default configuration, the
+// extension is disabled, until an extension configuration is received. The
+// behavior of a disabled extension depends on the context. For example, a
+// filter chain with a disabled extension filter rejects all incoming streams.
+message ExtensionConfigSource {
+  ConfigSource config_source = 1 [(validate.rules).any = {required: true}];
+
+  // Optional default configuration to use as the initial configuration if
+  // there is a failure to receive the initial extension configuration or if
+  // ``apply_default_config_without_warming`` flag is set.
+  google.protobuf.Any default_config = 2;
+
+  // Use the default config as the initial configuration without warming and
+  // waiting for the first discovery response. Requires the default configuration
+  // to be supplied.
+  bool apply_default_config_without_warming = 3;
+
+  // A set of permitted extension type URLs for the type encoded inside of the
+  // :ref:`TypedExtensionConfig <envoy_v3_api_msg_config.core.v3.TypedExtensionConfig>`. Extension
+  // configuration updates are rejected if they do not match any type URL in the set.
+  repeated string type_urls = 4 [(validate.rules).repeated = {min_items: 1}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/event_service_config.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/event_service_config.proto
new file mode 100644
index 00000000000..68c8df4076e
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/event_service_config.proto
@@ -0,0 +1,29 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "envoy/config/core/v3/grpc_service.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "EventServiceConfigProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#not-implemented-hide:]
+// Configuration of the event reporting service endpoint.
+message EventServiceConfig {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.core.EventServiceConfig";
+
+  oneof config_source_specifier {
+    option (validate.required) = true;
+
+    // Specifies the gRPC service that hosts the event reporting service.
+    GrpcService grpc_service = 1;
+  }
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/extension.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/extension.proto
new file mode 100644
index 00000000000..cacc7b00c21
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/extension.proto
@@ -0,0 +1,32 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "google/protobuf/any.proto";
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "ExtensionProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Extension configuration]
+
+// Message type for extension configuration.
+// [#next-major-version: revisit all existing typed_config that doesn't use this wrapper.].
+message TypedExtensionConfig {
+  // The name of an extension. This is not used to select the extension, instead
+  // it serves the role of an opaque identifier.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // The typed config for the extension. The type URL will be used to identify
+  // the extension. In the case that the type URL is ``xds.type.v3.TypedStruct``
+  // (or, for historical reasons, ``udpa.type.v1.TypedStruct``), the inner type
+  // URL of ``TypedStruct`` will be utilized. See the
+  // :ref:`extension configuration overview
+  // <config_overview_extension_configuration>` for further details.
+  google.protobuf.Any typed_config = 2 [(validate.rules).any = {required: true}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/grpc_service.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/grpc_service.proto
new file mode 100644
index 00000000000..f8feb2f516f
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/grpc_service.proto
@@ -0,0 +1,335 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "envoy/config/core/v3/base.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/empty.proto";
+import "google/protobuf/struct.proto";
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/sensitive.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "GrpcServiceProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: gRPC services]
+
+// gRPC service configuration. This is used by :ref:`ApiConfigSource
+// <envoy_v3_api_msg_config.core.v3.ApiConfigSource>` and filter configurations.
+// [#next-free-field: 7]
+message GrpcService {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.GrpcService";
+
+  // [#next-free-field: 6]
+  message EnvoyGrpc {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.core.GrpcService.EnvoyGrpc";
+
+    // The name of the upstream gRPC cluster. SSL credentials will be supplied
+    // in the :ref:`Cluster <envoy_v3_api_msg_config.cluster.v3.Cluster>` :ref:`transport_socket
+    // <envoy_v3_api_field_config.cluster.v3.Cluster.transport_socket>`.
+    string cluster_name = 1 [(validate.rules).string = {min_len: 1}];
+
+    // The ``:authority`` header in the grpc request. If this field is not set, the authority header value will be ``cluster_name``.
+    // Note that this authority does not override the SNI. The SNI is provided by the transport socket of the cluster.
+    string authority = 2
+        [(validate.rules).string =
+             {min_len: 0 max_bytes: 16384 well_known_regex: HTTP_HEADER_VALUE strict: false}];
+
+    // Indicates the retry policy for re-establishing the gRPC stream
+    // This field is optional. If max interval is not provided, it will be set to ten times the provided base interval.
+    // Currently only supported for xDS gRPC streams.
+    // If not set, xDS gRPC streams default base interval:500ms, maximum interval:30s will be applied.
+    RetryPolicy retry_policy = 3;
+
+    // Maximum gRPC message size that is allowed to be received.
+    // If a message over this limit is received, the gRPC stream is terminated with the RESOURCE_EXHAUSTED error.
+    // This limit is applied to individual messages in the streaming response and not the total size of streaming response.
+    // Defaults to 0, which means unlimited.
+    google.protobuf.UInt32Value max_receive_message_length = 4;
+
+    // This provides gRPC client level control over envoy generated headers.
+    // If false, the header will be sent but it can be overridden by per stream option.
+    // If true, the header will be removed and can not be overridden by per stream option.
+    // Default to false.
+    bool skip_envoy_headers = 5;
+  }
+
+  // [#next-free-field: 11]
+  message GoogleGrpc {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.core.GrpcService.GoogleGrpc";
+
+    // See https://grpc.io/grpc/cpp/structgrpc_1_1_ssl_credentials_options.html.
+    message SslCredentials {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.core.GrpcService.GoogleGrpc.SslCredentials";
+
+      // PEM encoded server root certificates.
+      DataSource root_certs = 1;
+
+      // PEM encoded client private key.
+      DataSource private_key = 2 [(udpa.annotations.sensitive) = true];
+
+      // PEM encoded client certificate chain.
+      DataSource cert_chain = 3;
+    }
+
+    // Local channel credentials. Only UDS is supported for now.
+    // See https://github.com/grpc/grpc/pull/15909.
+    message GoogleLocalCredentials {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.core.GrpcService.GoogleGrpc.GoogleLocalCredentials";
+    }
+
+    // See https://grpc.io/docs/guides/auth.html#credential-types to understand Channel and Call
+    // credential types.
+    message ChannelCredentials {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.core.GrpcService.GoogleGrpc.ChannelCredentials";
+
+      oneof credential_specifier {
+        option (validate.required) = true;
+
+        SslCredentials ssl_credentials = 1;
+
+        // https://grpc.io/grpc/cpp/namespacegrpc.html#a6beb3ac70ff94bd2ebbd89b8f21d1f61
+        google.protobuf.Empty google_default = 2;
+
+        GoogleLocalCredentials local_credentials = 3;
+      }
+    }
+
+    // [#next-free-field: 8]
+    message CallCredentials {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials";
+
+      message ServiceAccountJWTAccessCredentials {
+        option (udpa.annotations.versioning).previous_message_type =
+            "envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials."
+            "ServiceAccountJWTAccessCredentials";
+
+        string json_key = 1;
+
+        uint64 token_lifetime_seconds = 2;
+      }
+
+      message GoogleIAMCredentials {
+        option (udpa.annotations.versioning).previous_message_type =
+            "envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.GoogleIAMCredentials";
+
+        string authorization_token = 1;
+
+        string authority_selector = 2;
+      }
+
+      message MetadataCredentialsFromPlugin {
+        option (udpa.annotations.versioning).previous_message_type =
+            "envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials."
+            "MetadataCredentialsFromPlugin";
+
+        reserved 2;
+
+        reserved "config";
+
+        string name = 1;
+
+        // [#extension-category: envoy.grpc_credentials]
+        oneof config_type {
+          google.protobuf.Any typed_config = 3;
+        }
+      }
+
+      // Security token service configuration that allows Google gRPC to
+      // fetch security token from an OAuth 2.0 authorization server.
+      // See https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16 and
+      // https://github.com/grpc/grpc/pull/19587.
+      // [#next-free-field: 10]
+      message StsService {
+        option (udpa.annotations.versioning).previous_message_type =
+            "envoy.api.v2.core.GrpcService.GoogleGrpc.CallCredentials.StsService";
+
+        // URI of the token exchange service that handles token exchange requests.
+        // [#comment:TODO(asraa): Add URI validation when implemented. Tracked by
+        // https://github.com/bufbuild/protoc-gen-validate/issues/303]
+        string token_exchange_service_uri = 1;
+
+        // Location of the target service or resource where the client
+        // intends to use the requested security token.
+        string resource = 2;
+
+        // Logical name of the target service where the client intends to
+        // use the requested security token.
+        string audience = 3;
+
+        // The desired scope of the requested security token in the
+        // context of the service or resource where the token will be used.
+        string scope = 4;
+
+        // Type of the requested security token.
+        string requested_token_type = 5;
+
+        // The path of subject token, a security token that represents the
+        // identity of the party on behalf of whom the request is being made.
+        string subject_token_path = 6 [(validate.rules).string = {min_len: 1}];
+
+        // Type of the subject token.
+        string subject_token_type = 7 [(validate.rules).string = {min_len: 1}];
+
+        // The path of actor token, a security token that represents the identity
+        // of the acting party. The acting party is authorized to use the
+        // requested security token and act on behalf of the subject.
+        string actor_token_path = 8;
+
+        // Type of the actor token.
+        string actor_token_type = 9;
+      }
+
+      oneof credential_specifier {
+        option (validate.required) = true;
+
+        // Access token credentials.
+        // https://grpc.io/grpc/cpp/namespacegrpc.html#ad3a80da696ffdaea943f0f858d7a360d.
+        string access_token = 1;
+
+        // Google Compute Engine credentials.
+        // https://grpc.io/grpc/cpp/namespacegrpc.html#a6beb3ac70ff94bd2ebbd89b8f21d1f61
+        google.protobuf.Empty google_compute_engine = 2;
+
+        // Google refresh token credentials.
+        // https://grpc.io/grpc/cpp/namespacegrpc.html#a96901c997b91bc6513b08491e0dca37c.
+        string google_refresh_token = 3;
+
+        // Service Account JWT Access credentials.
+        // https://grpc.io/grpc/cpp/namespacegrpc.html#a92a9f959d6102461f66ee973d8e9d3aa.
+        ServiceAccountJWTAccessCredentials service_account_jwt_access = 4;
+
+        // Google IAM credentials.
+        // https://grpc.io/grpc/cpp/namespacegrpc.html#a9fc1fc101b41e680d47028166e76f9d0.
+        GoogleIAMCredentials google_iam = 5;
+
+        // Custom authenticator credentials.
+        // https://grpc.io/grpc/cpp/namespacegrpc.html#a823c6a4b19ffc71fb33e90154ee2ad07.
+        // https://grpc.io/docs/guides/auth.html#extending-grpc-to-support-other-authentication-mechanisms.
+        MetadataCredentialsFromPlugin from_plugin = 6;
+
+        // Custom security token service which implements OAuth 2.0 token exchange.
+        // https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16
+        // See https://github.com/grpc/grpc/pull/19587.
+        StsService sts_service = 7;
+      }
+    }
+
+    // Channel arguments.
+    message ChannelArgs {
+      message Value {
+        // Pointer values are not supported, since they don't make any sense when
+        // delivered via the API.
+        oneof value_specifier {
+          option (validate.required) = true;
+
+          string string_value = 1;
+
+          int64 int_value = 2;
+        }
+      }
+
+      // See grpc_types.h GRPC_ARG #defines for keys that work here.
+      map<string, Value> args = 1;
+    }
+
+    // The target URI when using the `Google C++ gRPC client
+    // <https://github.com/grpc/grpc>`_.
+    string target_uri = 1 [(validate.rules).string = {min_len: 1}];
+
+    // The channel credentials to use. See `channel credentials
+    // <https://grpc.io/docs/guides/auth.html#credential-types>`_.
+    // Ignored if ``channel_credentials_plugin`` is set.
+    ChannelCredentials channel_credentials = 2;
+
+    // A list of channel credentials plugins.
+    // The data plane will iterate over the list in order and stop at the first credential type
+    // that it supports. This provides a mechanism for starting to use new credential types that
+    // are not yet supported by all data planes.
+    // [#not-implemented-hide:]
+    repeated google.protobuf.Any channel_credentials_plugin = 9;
+
+    // The call credentials to use. See `channel credentials
+    // <https://grpc.io/docs/guides/auth.html#credential-types>`_.
+    // Ignored if ``call_credentials_plugin`` is set.
+    repeated CallCredentials call_credentials = 3;
+
+    // A list of call credentials plugins. All supported plugins will be used.
+    // Unsupported plugin types will be ignored.
+    // [#not-implemented-hide:]
+    repeated google.protobuf.Any call_credentials_plugin = 10;
+
+    // The human readable prefix to use when emitting statistics for the gRPC
+    // service.
+    //
+    // .. csv-table::
+    //    :header: Name, Type, Description
+    //    :widths: 1, 1, 2
+    //
+    //    streams_total, Counter, Total number of streams opened
+    //    streams_closed_<gRPC status code>, Counter, Total streams closed with <gRPC status code>
+    string stat_prefix = 4 [(validate.rules).string = {min_len: 1}];
+
+    // The name of the Google gRPC credentials factory to use. This must have been registered with
+    // Envoy. If this is empty, a default credentials factory will be used that sets up channel
+    // credentials based on other configuration parameters.
+    string credentials_factory_name = 5;
+
+    // Additional configuration for site-specific customizations of the Google
+    // gRPC library.
+    google.protobuf.Struct config = 6;
+
+    // How many bytes each stream can buffer internally.
+    // If not set an implementation defined default is applied (1MiB).
+    google.protobuf.UInt32Value per_stream_buffer_limit_bytes = 7;
+
+    // Custom channels args.
+    ChannelArgs channel_args = 8;
+  }
+
+  reserved 4;
+
+  oneof target_specifier {
+    option (validate.required) = true;
+
+    // Envoy's in-built gRPC client.
+    // See the :ref:`gRPC services overview <arch_overview_grpc_services>`
+    // documentation for discussion on gRPC client selection.
+    EnvoyGrpc envoy_grpc = 1;
+
+    // `Google C++ gRPC client <https://github.com/grpc/grpc>`_
+    // See the :ref:`gRPC services overview <arch_overview_grpc_services>`
+    // documentation for discussion on gRPC client selection.
+    GoogleGrpc google_grpc = 2;
+  }
+
+  // The timeout for the gRPC request. This is the timeout for a specific
+  // request.
+  google.protobuf.Duration timeout = 3;
+
+  // Additional metadata to include in streams initiated to the GrpcService. This can be used for
+  // scenarios in which additional ad hoc authorization headers (e.g. ``x-foo-bar: baz-key``) are to
+  // be injected. For more information, including details on header value syntax, see the
+  // documentation on :ref:`custom request headers
+  // <config_http_conn_man_headers_custom_request_headers>`.
+  repeated HeaderValue initial_metadata = 5;
+
+  // Optional default retry policy for streams toward the service.
+  // If an async stream doesn't have retry policy configured in its stream options, this retry policy is used.
+  RetryPolicy retry_policy = 6;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/health_check.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/health_check.proto
new file mode 100644
index 00000000000..a4ed6e91818
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/health_check.proto
@@ -0,0 +1,443 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/event_service_config.proto";
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/core/v3/proxy_protocol.proto";
+import "envoy/type/matcher/v3/string.proto";
+import "envoy/type/v3/http.proto";
+import "envoy/type/v3/range.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/struct.proto";
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "HealthCheckProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Health check]
+// * Health checking :ref:`architecture overview <arch_overview_health_checking>`.
+// * If health checking is configured for a cluster, additional statistics are emitted. They are
+//   documented :ref:`here <config_cluster_manager_cluster_stats>`.
+
+// Endpoint health status.
+enum HealthStatus {
+  // The health status is not known. This is interpreted by Envoy as ``HEALTHY``.
+  UNKNOWN = 0;
+
+  // Healthy.
+  HEALTHY = 1;
+
+  // Unhealthy.
+  UNHEALTHY = 2;
+
+  // Connection draining in progress. E.g.,
+  // `<https://aws.amazon.com/blogs/aws/elb-connection-draining-remove-instances-from-service-with-care/>`_
+  // or
+  // `<https://cloud.google.com/compute/docs/load-balancing/enabling-connection-draining>`_.
+  // This is interpreted by Envoy as ``UNHEALTHY``.
+  DRAINING = 3;
+
+  // Health check timed out. This is part of HDS and is interpreted by Envoy as
+  // ``UNHEALTHY``.
+  TIMEOUT = 4;
+
+  // Degraded.
+  DEGRADED = 5;
+}
+
+message HealthStatusSet {
+  // An order-independent set of health status.
+  repeated HealthStatus statuses = 1
+      [(validate.rules).repeated = {items {enum {defined_only: true}}}];
+}
+
+// [#next-free-field: 27]
+message HealthCheck {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.HealthCheck";
+
+  // Describes the encoding of the payload bytes in the payload.
+  message Payload {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.core.HealthCheck.Payload";
+
+    oneof payload {
+      option (validate.required) = true;
+
+      // Hex encoded payload. E.g., "000000FF".
+      string text = 1 [(validate.rules).string = {min_len: 1}];
+
+      // Binary payload.
+      bytes binary = 2;
+    }
+  }
+
+  // [#next-free-field: 15]
+  message HttpHealthCheck {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.core.HealthCheck.HttpHealthCheck";
+
+    reserved 5, 7;
+
+    reserved "service_name", "use_http2";
+
+    // The value of the host header in the HTTP health check request. If
+    // left empty (default value), the name of the cluster this health check is associated
+    // with will be used. The host header can be customized for a specific endpoint by setting the
+    // :ref:`hostname <envoy_v3_api_field_config.endpoint.v3.Endpoint.HealthCheckConfig.hostname>` field.
+    string host = 1 [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE}];
+
+    // Specifies the HTTP path that will be requested during health checking. For example
+    // ``/healthcheck``.
+    string path = 2 [(validate.rules).string = {min_len: 1 well_known_regex: HTTP_HEADER_VALUE}];
+
+    // HTTP specific payload to be sent as the request body during health checking.
+    // If specified, the method should support a request body (POST, PUT, PATCH, etc.).
+    Payload send = 3;
+
+    // Specifies a list of HTTP expected responses to match in the first ``response_buffer_size`` bytes of the response body.
+    // If it is set, both the expected response check and status code determine the health check.
+    // When checking the response, “fuzzy” matching is performed such that each payload block must be found,
+    // and in the order specified, but not necessarily contiguous.
+    //
+    // .. note::
+    //
+    //   It is recommended to set ``response_buffer_size`` based on the total Payload size for efficiency.
+    //   The default buffer size is 1024 bytes when it is not set.
+    repeated Payload receive = 4;
+
+    // Specifies the size of response buffer in bytes that is used to Payload match.
+    // The default value is 1024. Setting to 0 implies that the Payload will be matched against the entire response.
+    google.protobuf.UInt64Value response_buffer_size = 14 [(validate.rules).uint64 = {gte: 0}];
+
+    // Specifies a list of HTTP headers that should be added to each request that is sent to the
+    // health checked cluster. For more information, including details on header value syntax, see
+    // the documentation on :ref:`custom request headers
+    // <config_http_conn_man_headers_custom_request_headers>`.
+    repeated HeaderValueOption request_headers_to_add = 6
+        [(validate.rules).repeated = {max_items: 1000}];
+
+    // Specifies a list of HTTP headers that should be removed from each request that is sent to the
+    // health checked cluster.
+    repeated string request_headers_to_remove = 8 [(validate.rules).repeated = {
+      items {string {well_known_regex: HTTP_HEADER_NAME strict: false}}
+    }];
+
+    // Specifies a list of HTTP response statuses considered healthy. If provided, replaces default
+    // 200-only policy - 200 must be included explicitly as needed. Ranges follow half-open
+    // semantics of :ref:`Int64Range <envoy_v3_api_msg_type.v3.Int64Range>`. The start and end of each
+    // range are required. Only statuses in the range [100, 600) are allowed.
+    repeated type.v3.Int64Range expected_statuses = 9;
+
+    // Specifies a list of HTTP response statuses considered retriable. If provided, responses in this range
+    // will count towards the configured :ref:`unhealthy_threshold <envoy_v3_api_field_config.core.v3.HealthCheck.unhealthy_threshold>`,
+    // but will not result in the host being considered immediately unhealthy. Ranges follow half-open semantics of
+    // :ref:`Int64Range <envoy_v3_api_msg_type.v3.Int64Range>`. The start and end of each range are required.
+    // Only statuses in the range [100, 600) are allowed. The :ref:`expected_statuses <envoy_v3_api_field_config.core.v3.HealthCheck.HttpHealthCheck.expected_statuses>`
+    // field takes precedence for any range overlaps with this field i.e. if status code 200 is both retriable and expected, a 200 response will
+    // be considered a successful health check. By default all responses not in
+    // :ref:`expected_statuses <envoy_v3_api_field_config.core.v3.HealthCheck.HttpHealthCheck.expected_statuses>` will result in
+    // the host being considered immediately unhealthy i.e. if status code 200 is expected and there are no configured retriable statuses, any
+    // non-200 response will result in the host being marked unhealthy.
+    repeated type.v3.Int64Range retriable_statuses = 12;
+
+    // Use specified application protocol for health checks.
+    type.v3.CodecClientType codec_client_type = 10 [(validate.rules).enum = {defined_only: true}];
+
+    // An optional service name parameter which is used to validate the identity of
+    // the health checked cluster using a :ref:`StringMatcher
+    // <envoy_v3_api_msg_type.matcher.v3.StringMatcher>`. See the :ref:`architecture overview
+    // <arch_overview_health_checking_identity>` for more information.
+    type.matcher.v3.StringMatcher service_name_matcher = 11;
+
+    // HTTP Method that will be used for health checking, default is "GET".
+    // GET, HEAD, POST, PUT, DELETE, OPTIONS, TRACE, PATCH methods are supported.
+    // Request body payloads are supported for POST, PUT, PATCH, and OPTIONS methods only.
+    // CONNECT method is disallowed because it is not appropriate for health check request.
+    // If a non-200 response is expected by the method, it needs to be set in :ref:`expected_statuses <envoy_v3_api_field_config.core.v3.HealthCheck.HttpHealthCheck.expected_statuses>`.
+    RequestMethod method = 13 [(validate.rules).enum = {defined_only: true not_in: 6}];
+  }
+
+  message TcpHealthCheck {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.core.HealthCheck.TcpHealthCheck";
+
+    // Empty payloads imply a connect-only health check.
+    Payload send = 1;
+
+    // When checking the response, “fuzzy” matching is performed such that each
+    // payload block must be found, and in the order specified, but not
+    // necessarily contiguous.
+    repeated Payload receive = 2;
+
+    // When setting this value, it tries to attempt health check request with ProxyProtocol.
+    // When ``send`` is presented, they are sent after preceding ProxyProtocol header.
+    // Only ProxyProtocol header is sent when ``send`` is not presented.
+    // It allows to use both ProxyProtocol V1 and V2. In V1, it presents L3/L4. In V2, it includes
+    // LOCAL command and doesn't include L3/L4.
+    ProxyProtocolConfig proxy_protocol_config = 3;
+  }
+
+  message RedisHealthCheck {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.core.HealthCheck.RedisHealthCheck";
+
+    // If set, optionally perform ``EXISTS <key>`` instead of ``PING``. A return value
+    // from Redis of 0 (does not exist) is considered a passing healthcheck. A return value other
+    // than 0 is considered a failure. This allows the user to mark a Redis instance for maintenance
+    // by setting the specified key to any value and waiting for traffic to drain.
+    string key = 1;
+  }
+
+  // `grpc.health.v1.Health
+  // <https://github.com/grpc/grpc/blob/master/src/proto/grpc/health/v1/health.proto>`_-based
+  // healthcheck. See `gRPC doc <https://github.com/grpc/grpc/blob/master/doc/health-checking.md>`_
+  // for details.
+  message GrpcHealthCheck {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.core.HealthCheck.GrpcHealthCheck";
+
+    // An optional service name parameter which will be sent to gRPC service in
+    // `grpc.health.v1.HealthCheckRequest
+    // <https://github.com/grpc/grpc/blob/master/src/proto/grpc/health/v1/health.proto#L20>`_.
+    // message. See `gRPC health-checking overview
+    // <https://github.com/grpc/grpc/blob/master/doc/health-checking.md>`_ for more information.
+    string service_name = 1;
+
+    // The value of the :authority header in the gRPC health check request. If
+    // left empty (default value), the name of the cluster this health check is associated
+    // with will be used. The authority header can be customized for a specific endpoint by setting
+    // the :ref:`hostname <envoy_v3_api_field_config.endpoint.v3.Endpoint.HealthCheckConfig.hostname>` field.
+    string authority = 2
+        [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+
+    // Specifies a list of key-value pairs that should be added to the metadata of each GRPC call
+    // that is sent to the health checked cluster. For more information, including details on header value syntax,
+    // see the documentation on :ref:`custom request headers
+    // <config_http_conn_man_headers_custom_request_headers>`.
+    repeated HeaderValueOption initial_metadata = 3 [(validate.rules).repeated = {max_items: 1000}];
+  }
+
+  // Custom health check.
+  message CustomHealthCheck {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.core.HealthCheck.CustomHealthCheck";
+
+    reserved 2;
+
+    reserved "config";
+
+    // The registered name of the custom health checker.
+    string name = 1 [(validate.rules).string = {min_len: 1}];
+
+    // A custom health checker specific configuration which depends on the custom health checker
+    // being instantiated. See :api:`envoy/config/health_checker` for reference.
+    // [#extension-category: envoy.health_checkers]
+    oneof config_type {
+      google.protobuf.Any typed_config = 3;
+    }
+  }
+
+  // Health checks occur over the transport socket specified for the cluster. This implies that if a
+  // cluster is using a TLS-enabled transport socket, the health check will also occur over TLS.
+  //
+  // This allows overriding the cluster TLS settings, just for health check connections.
+  message TlsOptions {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.core.HealthCheck.TlsOptions";
+
+    // Specifies the ALPN protocols for health check connections. This is useful if the
+    // corresponding upstream is using ALPN-based :ref:`FilterChainMatch
+    // <envoy_v3_api_msg_config.listener.v3.FilterChainMatch>` along with different protocols for health checks
+    // versus data connections. If empty, no ALPN protocols will be set on health check connections.
+    repeated string alpn_protocols = 1;
+  }
+
+  reserved 10;
+
+  // The time to wait for a health check response. If the timeout is reached the
+  // health check attempt will be considered a failure.
+  google.protobuf.Duration timeout = 1 [(validate.rules).duration = {
+    required: true
+    gt {}
+  }];
+
+  // The interval between health checks.
+  google.protobuf.Duration interval = 2 [(validate.rules).duration = {
+    required: true
+    gt {}
+  }];
+
+  // An optional jitter amount in milliseconds. If specified, Envoy will start health
+  // checking after for a random time in ms between 0 and initial_jitter. This only
+  // applies to the first health check.
+  google.protobuf.Duration initial_jitter = 20;
+
+  // An optional jitter amount in milliseconds. If specified, during every
+  // interval Envoy will add interval_jitter to the wait time.
+  google.protobuf.Duration interval_jitter = 3;
+
+  // An optional jitter amount as a percentage of interval_ms. If specified,
+  // during every interval Envoy will add ``interval_ms`` *
+  // ``interval_jitter_percent`` / 100 to the wait time.
+  //
+  // If interval_jitter_ms and interval_jitter_percent are both set, both of
+  // them will be used to increase the wait time.
+  uint32 interval_jitter_percent = 18;
+
+  // The number of unhealthy health checks required before a host is marked
+  // unhealthy. Note that for ``http`` health checking if a host responds with a code not in
+  // :ref:`expected_statuses <envoy_v3_api_field_config.core.v3.HealthCheck.HttpHealthCheck.expected_statuses>`
+  // or :ref:`retriable_statuses <envoy_v3_api_field_config.core.v3.HealthCheck.HttpHealthCheck.retriable_statuses>`,
+  // this threshold is ignored and the host is considered immediately unhealthy.
+  google.protobuf.UInt32Value unhealthy_threshold = 4 [(validate.rules).message = {required: true}];
+
+  // The number of healthy health checks required before a host is marked
+  // healthy. Note that during startup, only a single successful health check is
+  // required to mark a host healthy.
+  google.protobuf.UInt32Value healthy_threshold = 5 [(validate.rules).message = {required: true}];
+
+  // [#not-implemented-hide:] Non-serving port for health checking.
+  google.protobuf.UInt32Value alt_port = 6;
+
+  // Reuse health check connection between health checks. Default is true.
+  google.protobuf.BoolValue reuse_connection = 7;
+
+  oneof health_checker {
+    option (validate.required) = true;
+
+    // HTTP health check.
+    HttpHealthCheck http_health_check = 8;
+
+    // TCP health check.
+    TcpHealthCheck tcp_health_check = 9;
+
+    // gRPC health check.
+    GrpcHealthCheck grpc_health_check = 11;
+
+    // Custom health check.
+    CustomHealthCheck custom_health_check = 13;
+  }
+
+  // The "no traffic interval" is a special health check interval that is used when a cluster has
+  // never had traffic routed to it. This lower interval allows cluster information to be kept up to
+  // date, without sending a potentially large amount of active health checking traffic for no
+  // reason. Once a cluster has been used for traffic routing, Envoy will shift back to using the
+  // standard health check interval that is defined. Note that this interval takes precedence over
+  // any other.
+  //
+  // The default value for "no traffic interval" is 60 seconds.
+  google.protobuf.Duration no_traffic_interval = 12 [(validate.rules).duration = {gt {}}];
+
+  // The "no traffic healthy interval" is a special health check interval that
+  // is used for hosts that are currently passing active health checking
+  // (including new hosts) when the cluster has received no traffic.
+  //
+  // This is useful for when we want to send frequent health checks with
+  // ``no_traffic_interval`` but then revert to lower frequency ``no_traffic_healthy_interval`` once
+  // a host in the cluster is marked as healthy.
+  //
+  // Once a cluster has been used for traffic routing, Envoy will shift back to using the
+  // standard health check interval that is defined.
+  //
+  // If no_traffic_healthy_interval is not set, it will default to the
+  // no traffic interval and send that interval regardless of health state.
+  google.protobuf.Duration no_traffic_healthy_interval = 24 [(validate.rules).duration = {gt {}}];
+
+  // The "unhealthy interval" is a health check interval that is used for hosts that are marked as
+  // unhealthy. As soon as the host is marked as healthy, Envoy will shift back to using the
+  // standard health check interval that is defined.
+  //
+  // The default value for "unhealthy interval" is the same as "interval".
+  google.protobuf.Duration unhealthy_interval = 14 [(validate.rules).duration = {gt {}}];
+
+  // The "unhealthy edge interval" is a special health check interval that is used for the first
+  // health check right after a host is marked as unhealthy. For subsequent health checks
+  // Envoy will shift back to using either "unhealthy interval" if present or the standard health
+  // check interval that is defined.
+  //
+  // The default value for "unhealthy edge interval" is the same as "unhealthy interval".
+  google.protobuf.Duration unhealthy_edge_interval = 15 [(validate.rules).duration = {gt {}}];
+
+  // The "healthy edge interval" is a special health check interval that is used for the first
+  // health check right after a host is marked as healthy. For subsequent health checks
+  // Envoy will shift back to using the standard health check interval that is defined.
+  //
+  // The default value for "healthy edge interval" is the same as the default interval.
+  google.protobuf.Duration healthy_edge_interval = 16 [(validate.rules).duration = {gt {}}];
+
+  // Specifies the path to the :ref:`health check event log <arch_overview_health_check_logging>`.
+  //
+  // .. attention::
+  //   This field is deprecated in favor of the extension
+  //   :ref:`event_logger <envoy_v3_api_field_config.core.v3.HealthCheck.event_logger>` and
+  //   :ref:`event_log_path <envoy_v3_api_field_extensions.health_check.event_sinks.file.v3.HealthCheckEventFileSink.event_log_path>`
+  //   in the file sink extension.
+  string event_log_path = 17
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // A list of event log sinks to process the health check event.
+  // [#extension-category: envoy.health_check.event_sinks]
+  repeated TypedExtensionConfig event_logger = 25;
+
+  // [#not-implemented-hide:]
+  // The gRPC service for the health check event service.
+  // If empty, health check events won't be sent to a remote endpoint.
+  EventServiceConfig event_service = 22;
+
+  // If set to true, health check failure events will always be logged. If set to false, only the
+  // initial health check failure event will be logged.
+  // The default value is false.
+  bool always_log_health_check_failures = 19;
+
+  // If set to true, health check success events will always be logged. If set to false, only host addition event will be logged
+  // if it is the first successful health check, or if the healthy threshold is reached.
+  // The default value is false.
+  bool always_log_health_check_success = 26;
+
+  // This allows overriding the cluster TLS settings, just for health check connections.
+  TlsOptions tls_options = 21;
+
+  // Optional key/value pairs that will be used to match a transport socket from those specified in the cluster's
+  // :ref:`tranport socket matches <envoy_v3_api_field_config.cluster.v3.Cluster.transport_socket_matches>`.
+  // For example, the following match criteria
+  //
+  // .. code-block:: yaml
+  //
+  //  transport_socket_match_criteria:
+  //    useMTLS: true
+  //
+  // Will match the following :ref:`cluster socket match <envoy_v3_api_msg_config.cluster.v3.Cluster.TransportSocketMatch>`
+  //
+  // .. code-block:: yaml
+  //
+  //  transport_socket_matches:
+  //  - name: "useMTLS"
+  //    match:
+  //      useMTLS: true
+  //    transport_socket:
+  //      name: envoy.transport_sockets.tls
+  //      config: { ... } # tls socket configuration
+  //
+  // If this field is set, then for health checks it will supersede an entry of ``envoy.transport_socket`` in the
+  // :ref:`LbEndpoint.Metadata <envoy_v3_api_field_config.endpoint.v3.LbEndpoint.metadata>`.
+  // This allows using different transport socket capabilities for health checking versus proxying to the
+  // endpoint.
+  //
+  // If the key/values pairs specified do not match any
+  // :ref:`transport socket matches <envoy_v3_api_field_config.cluster.v3.Cluster.transport_socket_matches>`,
+  // the cluster's :ref:`transport socket <envoy_v3_api_field_config.cluster.v3.Cluster.transport_socket>`
+  // will be used for health check socket configuration.
+  google.protobuf.Struct transport_socket_match_criteria = 23;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/http_service.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/http_service.proto
new file mode 100644
index 00000000000..426994c033c
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/http_service.proto
@@ -0,0 +1,35 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/http_uri.proto";
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "HttpServiceProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: HTTP services]
+
+// HTTP service configuration.
+message HttpService {
+  // The service's HTTP URI. For example:
+  //
+  // .. code-block:: yaml
+  //
+  //    http_uri:
+  //      uri: https://www.myserviceapi.com/v1/data
+  //      cluster: www.myserviceapi.com|443
+  //
+  HttpUri http_uri = 1;
+
+  // Specifies a list of HTTP headers that should be added to each request
+  // handled by this virtual host.
+  repeated HeaderValueOption request_headers_to_add = 2
+      [(validate.rules).repeated = {max_items: 1000}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/http_uri.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/http_uri.proto
new file mode 100644
index 00000000000..bac37c0d583
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/http_uri.proto
@@ -0,0 +1,58 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "google/protobuf/duration.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "HttpUriProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: HTTP service URI ]
+
+// Envoy external URI descriptor
+message HttpUri {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.HttpUri";
+
+  // The HTTP server URI. It should be a full FQDN with protocol, host and path.
+  //
+  // Example:
+  //
+  // .. code-block:: yaml
+  //
+  //    uri: https://www.googleapis.com/oauth2/v1/certs
+  //
+  string uri = 1 [(validate.rules).string = {min_len: 1}];
+
+  // Specify how ``uri`` is to be fetched. Today, this requires an explicit
+  // cluster, but in the future we may support dynamic cluster creation or
+  // inline DNS resolution. See `issue
+  // <https://github.com/envoyproxy/envoy/issues/1606>`_.
+  oneof http_upstream_type {
+    option (validate.required) = true;
+
+    // A cluster is created in the Envoy "cluster_manager" config
+    // section. This field specifies the cluster name.
+    //
+    // Example:
+    //
+    // .. code-block:: yaml
+    //
+    //    cluster: jwks_cluster
+    //
+    string cluster = 2 [(validate.rules).string = {min_len: 1}];
+  }
+
+  // Sets the maximum duration in milliseconds that a response can take to arrive upon request.
+  google.protobuf.Duration timeout = 3 [(validate.rules).duration = {
+    required: true
+    lt {seconds: 4294967296}
+    gte {}
+  }];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/protocol.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/protocol.proto
new file mode 100644
index 00000000000..74fe641fe3a
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/protocol.proto
@@ -0,0 +1,730 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "envoy/config/core/v3/extension.proto";
+import "envoy/type/matcher/v3/string.proto";
+import "envoy/type/v3/percent.proto";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "xds/annotations/v3/status.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "ProtocolProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Protocol options]
+
+// [#not-implemented-hide:]
+message TcpProtocolOptions {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.core.TcpProtocolOptions";
+}
+
+// Config for keepalive probes in a QUIC connection.
+// Note that QUIC keep-alive probing packets work differently from HTTP/2 keep-alive PINGs in a sense that the probing packet
+// itself doesn't timeout waiting for a probing response. Quic has a shorter idle timeout than TCP, so it doesn't rely on such probing to discover dead connections. If the peer fails to respond, the connection will idle timeout eventually. Thus, they are configured differently from :ref:`connection_keepalive <envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.connection_keepalive>`.
+message QuicKeepAliveSettings {
+  // The max interval for a connection to send keep-alive probing packets (with PING or PATH_RESPONSE). The value should be smaller than :ref:`connection idle_timeout <envoy_v3_api_field_config.listener.v3.QuicProtocolOptions.idle_timeout>` to prevent idle timeout while not less than 1s to avoid throttling the connection or flooding the peer with probes.
+  //
+  // If :ref:`initial_interval <envoy_v3_api_field_config.core.v3.QuicKeepAliveSettings.initial_interval>` is absent or zero, a client connection will use this value to start probing.
+  //
+  // If zero, disable keepalive probing.
+  // If absent, use the QUICHE default interval to probe.
+  google.protobuf.Duration max_interval = 1;
+
+  // The interval to send the first few keep-alive probing packets to prevent connection from hitting the idle timeout. Subsequent probes will be sent, each one with an interval exponentially longer than previous one, till it reaches :ref:`max_interval <envoy_v3_api_field_config.core.v3.QuicKeepAliveSettings.max_interval>`. And the probes afterwards will always use :ref:`max_interval <envoy_v3_api_field_config.core.v3.QuicKeepAliveSettings.max_interval>`.
+  //
+  // The value should be smaller than :ref:`connection idle_timeout <envoy_v3_api_field_config.listener.v3.QuicProtocolOptions.idle_timeout>` to prevent idle timeout and smaller than max_interval to take effect.
+  //
+  // If absent, disable keepalive probing for a server connection. For a client connection, if :ref:`max_interval <envoy_v3_api_field_config.core.v3.QuicKeepAliveSettings.max_interval>` is zero, do not keepalive, otherwise use max_interval or QUICHE default to probe all the time.
+  google.protobuf.Duration initial_interval = 2 [(validate.rules).duration = {
+    lte {}
+    gte {nanos: 1000000}
+  }];
+}
+
+// QUIC protocol options which apply to both downstream and upstream connections.
+// [#next-free-field: 10]
+message QuicProtocolOptions {
+  // Maximum number of streams that the client can negotiate per connection. 100
+  // if not specified.
+  google.protobuf.UInt32Value max_concurrent_streams = 1 [(validate.rules).uint32 = {gte: 1}];
+
+  // `Initial stream-level flow-control receive window
+  // <https://tools.ietf.org/html/draft-ietf-quic-transport-34#section-4.1>`_ size. Valid values range from
+  // 1 to 16777216 (2^24, maximum supported by QUICHE) and defaults to 16777216 (16 * 1024 * 1024).
+  //
+  // .. note::
+  //
+  //   16384 (2^14) is the minimum window size supported in Google QUIC. If configured smaller than it, we will use
+  //   16384 instead. QUICHE IETF Quic implementation supports 1 bytes window. We only support increasing the default
+  //   window size now, so it's also the minimum.
+  //
+  // This field also acts as a soft limit on the number of bytes Envoy will buffer per-stream in the
+  // QUIC stream send and receive buffers. Once the buffer reaches this pointer, watermark callbacks will fire to
+  // stop the flow of data to the stream buffers.
+  google.protobuf.UInt32Value initial_stream_window_size = 2
+      [(validate.rules).uint32 = {lte: 16777216 gte: 1}];
+
+  // Similar to ``initial_stream_window_size``, but for connection-level
+  // flow-control. Valid values range from 1 to 25165824 (24MB, maximum supported by QUICHE) and defaults
+  // to 25165824 (24 * 1024 * 1024).
+  //
+  // .. note::
+  //
+  //   16384 (2^14) is the minimum window size supported in Google QUIC. We only support increasing the default
+  //   window size now, so it's also the minimum.
+  //
+  google.protobuf.UInt32Value initial_connection_window_size = 3
+      [(validate.rules).uint32 = {lte: 25165824 gte: 1}];
+
+  // The number of timeouts that can occur before port migration is triggered for QUIC clients.
+  // This defaults to 4. If set to 0, port migration will not occur on path degrading.
+  // Timeout here refers to QUIC internal path degrading timeout mechanism, such as PTO.
+  // This has no effect on server sessions.
+  google.protobuf.UInt32Value num_timeouts_to_trigger_port_migration = 4
+      [(validate.rules).uint32 = {lte: 5 gte: 0}];
+
+  // Probes the peer at the configured interval to solicit traffic, i.e. ACK or PATH_RESPONSE, from the peer to push back connection idle timeout.
+  // If absent, use the default keepalive behavior of which a client connection sends PINGs every 15s, and a server connection doesn't do anything.
+  QuicKeepAliveSettings connection_keepalive = 5;
+
+  // A comma-separated list of strings representing QUIC connection options defined in
+  // `QUICHE <https://github.com/google/quiche/blob/main/quiche/quic/core/crypto/crypto_protocol.h>`_ and to be sent by upstream connections.
+  string connection_options = 6;
+
+  // A comma-separated list of strings representing QUIC client connection options defined in
+  // `QUICHE <https://github.com/google/quiche/blob/main/quiche/quic/core/crypto/crypto_protocol.h>`_ and to be sent by upstream connections.
+  string client_connection_options = 7;
+
+  // The duration that a QUIC connection stays idle before it closes itself. If this field is not present, QUICHE
+  // default 600s will be applied.
+  // For internal corporate network, a long timeout is often fine.
+  // But for client facing network, 30s is usually a good choice.
+  // Do not add an upper bound here. A long idle timeout is useful for maintaining warm connections at non-front-line proxy for low QPS services."
+  google.protobuf.Duration idle_network_timeout = 8
+      [(validate.rules).duration = {gte {seconds: 1}}];
+
+  // Maximum packet length for QUIC connections. It refers to the largest size of a QUIC packet that can be transmitted over the connection.
+  // If not specified, one of the `default values in QUICHE <https://github.com/google/quiche/blob/main/quiche/quic/core/quic_constants.h>`_ is used.
+  google.protobuf.UInt64Value max_packet_length = 9;
+}
+
+message UpstreamHttpProtocolOptions {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.core.UpstreamHttpProtocolOptions";
+
+  // Set transport socket `SNI <https://en.wikipedia.org/wiki/Server_Name_Indication>`_ for new
+  // upstream connections based on the downstream HTTP host/authority header or any other arbitrary
+  // header when :ref:`override_auto_sni_header <envoy_v3_api_field_config.core.v3.UpstreamHttpProtocolOptions.override_auto_sni_header>`
+  // is set, as seen by the :ref:`router filter <config_http_filters_router>`.
+  // Does nothing if a filter before the http router filter sets the corresponding metadata.
+  //
+  // See :ref:`SNI configuration <start_quick_start_securing_sni_client>` for details on how this
+  // interacts with other validation options.
+  bool auto_sni = 1;
+
+  // Automatic validate upstream presented certificate for new upstream connections based on the
+  // downstream HTTP host/authority header or any other arbitrary header when :ref:`override_auto_sni_header <envoy_v3_api_field_config.core.v3.UpstreamHttpProtocolOptions.override_auto_sni_header>`
+  // is set, as seen by the :ref:`router filter <config_http_filters_router>`.
+  // This field is intended to be set with ``auto_sni`` field.
+  // Does nothing if a filter before the http router filter sets the corresponding metadata.
+  //
+  // See :ref:`validation configuration <start_quick_start_securing_validation>` for how this interacts with
+  // other validation options.
+  bool auto_san_validation = 2;
+
+  // An optional alternative to the host/authority header to be used for setting the SNI value.
+  // It should be a valid downstream HTTP header, as seen by the
+  // :ref:`router filter <config_http_filters_router>`.
+  // If unset, host/authority header will be used for populating the SNI. If the specified header
+  // is not found or the value is empty, host/authority header will be used instead.
+  // This field is intended to be set with ``auto_sni`` and/or ``auto_san_validation`` fields.
+  // If none of these fields are set then setting this would be a no-op.
+  // Does nothing if a filter before the http router filter sets the corresponding metadata.
+  string override_auto_sni_header = 3
+      [(validate.rules).string = {well_known_regex: HTTP_HEADER_NAME ignore_empty: true}];
+}
+
+// Configures the alternate protocols cache which tracks alternate protocols that can be used to
+// make an HTTP connection to an origin server. See https://tools.ietf.org/html/rfc7838 for
+// HTTP Alternative Services and https://datatracker.ietf.org/doc/html/draft-ietf-dnsop-svcb-https-04
+// for the "HTTPS" DNS resource record.
+// [#next-free-field: 6]
+message AlternateProtocolsCacheOptions {
+  // Allows pre-populating the cache with HTTP/3 alternate protocols entries with a 7 day lifetime.
+  // This will cause Envoy to attempt HTTP/3 to those upstreams, even if the upstreams have not
+  // advertised HTTP/3 support. These entries will be overwritten by alt-svc
+  // response headers or cached values.
+  // As with regular cached entries, if the origin response would result in clearing an existing
+  // alternate protocol cache entry, pre-populated entries will also be cleared.
+  // Adding a cache entry with hostname=foo.com port=123 is the equivalent of getting
+  // response headers
+  // alt-svc: h3=:"123"; ma=86400" in a response to a request to foo.com:123
+  message AlternateProtocolsCacheEntry {
+    // The host name for the alternate protocol entry.
+    string hostname = 1
+        [(validate.rules).string = {well_known_regex: HTTP_HEADER_NAME ignore_empty: true}];
+
+    // The port for the alternate protocol entry.
+    uint32 port = 2 [(validate.rules).uint32 = {lt: 65535 gt: 0}];
+  }
+
+  // The name of the cache. Multiple named caches allow independent alternate protocols cache
+  // configurations to operate within a single Envoy process using different configurations. All
+  // alternate protocols cache options with the same name *must* be equal in all fields when
+  // referenced from different configuration components. Configuration will fail to load if this is
+  // not the case.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // The maximum number of entries that the cache will hold. If not specified defaults to 1024.
+  //
+  // .. note:
+  //
+  //   The implementation is approximate and enforced independently on each worker thread, thus
+  //   it is possible for the maximum entries in the cache to go slightly above the configured
+  //   value depending on timing. This is similar to how other circuit breakers work.
+  google.protobuf.UInt32Value max_entries = 2 [(validate.rules).uint32 = {gt: 0}];
+
+  // Allows configuring a persistent
+  // :ref:`key value store <envoy_v3_api_msg_config.common.key_value.v3.KeyValueStoreConfig>` to flush
+  // alternate protocols entries to disk.
+  // This function is currently only supported if concurrency is 1
+  // Cached entries will take precedence over pre-populated entries below.
+  TypedExtensionConfig key_value_store_config = 3;
+
+  // Allows pre-populating the cache with entries, as described above.
+  repeated AlternateProtocolsCacheEntry prepopulated_entries = 4;
+
+  // Optional list of hostnames suffixes for which Alt-Svc entries can be shared. For example, if
+  // this list contained the value ``.c.example.com``, then an Alt-Svc entry for ``foo.c.example.com``
+  // could be shared with ``bar.c.example.com`` but would not be shared with ``baz.example.com``. On
+  // the other hand, if the list contained the value ``.example.com`` then all three hosts could share
+  // Alt-Svc entries. Each entry must start with ``.``. If a hostname matches multiple suffixes, the
+  // first listed suffix will be used.
+  //
+  // Since lookup in this list is O(n), it is recommended that the number of suffixes be limited.
+  // [#not-implemented-hide:]
+  repeated string canonical_suffixes = 5;
+}
+
+// [#next-free-field: 8]
+message HttpProtocolOptions {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.core.HttpProtocolOptions";
+
+  // Action to take when Envoy receives client request with header names containing underscore
+  // characters.
+  // Underscore character is allowed in header names by the RFC-7230 and this behavior is implemented
+  // as a security measure due to systems that treat '_' and '-' as interchangeable. Envoy by default allows client request headers with underscore
+  // characters.
+  enum HeadersWithUnderscoresAction {
+    // Allow headers with underscores. This is the default behavior.
+    ALLOW = 0;
+
+    // Reject client request. HTTP/1 requests are rejected with the 400 status. HTTP/2 requests
+    // end with the stream reset. The "httpN.requests_rejected_with_underscores_in_headers" counter
+    // is incremented for each rejected request.
+    REJECT_REQUEST = 1;
+
+    // Drop the client header with name containing underscores. The header is dropped before the filter chain is
+    // invoked and as such filters will not see dropped headers. The
+    // "httpN.dropped_headers_with_underscores" is incremented for each dropped header.
+    DROP_HEADER = 2;
+  }
+
+  // The idle timeout for connections. The idle timeout is defined as the
+  // period in which there are no active requests. When the
+  // idle timeout is reached the connection will be closed. If the connection is an HTTP/2
+  // downstream connection a drain sequence will occur prior to closing the connection, see
+  // :ref:`drain_timeout
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.drain_timeout>`.
+  // Note that request based timeouts mean that HTTP/2 PINGs will not keep the connection alive.
+  // If not specified, this defaults to 1 hour. To disable idle timeouts explicitly set this to 0.
+  //
+  // .. warning::
+  //   Disabling this timeout has a highly likelihood of yielding connection leaks due to lost TCP
+  //   FIN packets, etc.
+  //
+  // If the :ref:`overload action <config_overload_manager_overload_actions>` "envoy.overload_actions.reduce_timeouts"
+  // is configured, this timeout is scaled for downstream connections according to the value for
+  // :ref:`HTTP_DOWNSTREAM_CONNECTION_IDLE <envoy_v3_api_enum_value_config.overload.v3.ScaleTimersOverloadActionConfig.TimerType.HTTP_DOWNSTREAM_CONNECTION_IDLE>`.
+  google.protobuf.Duration idle_timeout = 1;
+
+  // The maximum duration of a connection. The duration is defined as a period since a connection
+  // was established. If not set, there is no max duration. When max_connection_duration is reached,
+  // the drain sequence will kick-in. The connection will be closed after the drain timeout period
+  // if there are no active streams. See :ref:`drain_timeout
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.drain_timeout>`.
+  google.protobuf.Duration max_connection_duration = 3;
+
+  // The maximum number of headers (request headers if configured on HttpConnectionManager,
+  // response headers when configured on a cluster).
+  // If unconfigured, the default maximum number of headers allowed is 100.
+  // The default value for requests can be overridden by setting runtime key ``envoy.reloadable_features.max_request_headers_count``.
+  // The default value for responses can be overridden by setting runtime key ``envoy.reloadable_features.max_response_headers_count``.
+  // Downstream requests that exceed this limit will receive a 431 response for HTTP/1.x and cause a stream
+  // reset for HTTP/2.
+  // Upstream responses that exceed this limit will result in a 502 response.
+  google.protobuf.UInt32Value max_headers_count = 2 [(validate.rules).uint32 = {gte: 1}];
+
+  // The maximum size of response headers.
+  // If unconfigured, the default is 60 KiB, except for HTTP/1 response headers which have a default
+  // of 80KiB.
+  // The default value can be overridden by setting runtime key ``envoy.reloadable_features.max_response_headers_size_kb``.
+  // Responses that exceed this limit will result in a 503 response.
+  // In Envoy, this setting is only valid when configured on an upstream cluster, not on the
+  // :ref:`HTTP Connection Manager
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.common_http_protocol_options>`.
+  //
+  // .. note::
+  //
+  //   Currently some protocol codecs impose limits on the maximum size of a single header.
+  //
+  //   * HTTP/2 (when using nghttp2) limits a single header to around 100kb.
+  //   * HTTP/3 limits a single header to around 1024kb.
+  //
+  google.protobuf.UInt32Value max_response_headers_kb = 7
+      [(validate.rules).uint32 = {lte: 8192 gt: 0}];
+
+  // Total duration to keep alive an HTTP request/response stream. If the time limit is reached the stream will be
+  // reset independent of any other timeouts. If not specified, this value is not set.
+  google.protobuf.Duration max_stream_duration = 4;
+
+  // Action to take when a client request with a header name containing underscore characters is received.
+  // If this setting is not specified, the value defaults to ALLOW.
+  //
+  // .. note::
+  //
+  //   Upstream responses are not affected by this setting.
+  //
+  // .. note::
+  //
+  //   This only affects client headers. It does not affect headers added by Envoy filters and does not have any
+  //   impact if added to cluster config.
+  HeadersWithUnderscoresAction headers_with_underscores_action = 5;
+
+  // Optional maximum requests for both upstream and downstream connections.
+  // If not specified, there is no limit.
+  // Setting this parameter to 1 will effectively disable keep alive.
+  // For HTTP/2 and HTTP/3, due to concurrent stream processing, the limit is approximate.
+  google.protobuf.UInt32Value max_requests_per_connection = 6;
+}
+
+// [#next-free-field: 12]
+message Http1ProtocolOptions {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.core.Http1ProtocolOptions";
+
+  // [#next-free-field: 9]
+  message HeaderKeyFormat {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.core.Http1ProtocolOptions.HeaderKeyFormat";
+
+    message ProperCaseWords {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.core.Http1ProtocolOptions.HeaderKeyFormat.ProperCaseWords";
+    }
+
+    oneof header_format {
+      option (validate.required) = true;
+
+      // Formats the header by proper casing words: the first character and any character following
+      // a special character will be capitalized if it's an alpha character. For example,
+      // "content-type" becomes "Content-Type", and "foo$b#$are" becomes "Foo$B#$Are".
+      // Note that while this results in most headers following conventional casing, certain headers
+      // are not covered. For example, the "TE" header will be formatted as "Te".
+      ProperCaseWords proper_case_words = 1;
+
+      // Configuration for stateful formatter extensions that allow using received headers to
+      // affect the output of encoding headers. E.g., preserving case during proxying.
+      // [#extension-category: envoy.http.stateful_header_formatters]
+      TypedExtensionConfig stateful_formatter = 8;
+    }
+  }
+
+  // Handle HTTP requests with absolute URLs in the requests. These requests
+  // are generally sent by clients to forward/explicit proxies. This allows clients to configure
+  // envoy as their HTTP proxy. In Unix, for example, this is typically done by setting the
+  // ``http_proxy`` environment variable.
+  google.protobuf.BoolValue allow_absolute_url = 1;
+
+  // Handle incoming HTTP/1.0 and HTTP 0.9 requests.
+  // This is off by default, and not fully standards compliant. There is support for pre-HTTP/1.1
+  // style connect logic, dechunking, and handling lack of client host iff
+  // ``default_host_for_http_10`` is configured.
+  bool accept_http_10 = 2;
+
+  // A default host for HTTP/1.0 requests. This is highly suggested if ``accept_http_10`` is true as
+  // Envoy does not otherwise support HTTP/1.0 without a Host header.
+  // This is a no-op if ``accept_http_10`` is not true.
+  string default_host_for_http_10 = 3;
+
+  // Describes how the keys for response headers should be formatted. By default, all header keys
+  // are lower cased.
+  HeaderKeyFormat header_key_format = 4;
+
+  // Enables trailers for HTTP/1. By default the HTTP/1 codec drops proxied trailers.
+  //
+  // .. attention::
+  //
+  //   Note that this only happens when Envoy is chunk encoding which occurs when:
+  //   - The request is HTTP/1.1.
+  //   - Is neither a HEAD only request nor a HTTP Upgrade.
+  //   - Not a response to a HEAD request.
+  //   - The content length header is not present.
+  bool enable_trailers = 5;
+
+  // Allows Envoy to process requests/responses with both ``Content-Length`` and ``Transfer-Encoding``
+  // headers set. By default such messages are rejected, but if option is enabled - Envoy will
+  // remove Content-Length header and process message.
+  // See `RFC7230, sec. 3.3.3 <https://tools.ietf.org/html/rfc7230#section-3.3.3>`_ for details.
+  //
+  // .. attention::
+  //   Enabling this option might lead to request smuggling vulnerability, especially if traffic
+  //   is proxied via multiple layers of proxies.
+  // [#comment:TODO: This field is ignored when the
+  // :ref:`header validation configuration <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.typed_header_validation_config>`
+  // is present.]
+  bool allow_chunked_length = 6;
+
+  // Allows invalid HTTP messaging. When this option is false, then Envoy will terminate
+  // HTTP/1.1 connections upon receiving an invalid HTTP message. However,
+  // when this option is true, then Envoy will leave the HTTP/1.1 connection
+  // open where possible.
+  // If set, this overrides any HCM :ref:`stream_error_on_invalid_http_messaging
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_error_on_invalid_http_message>`.
+  google.protobuf.BoolValue override_stream_error_on_invalid_http_message = 7;
+
+  // Allows sending fully qualified URLs when proxying the first line of the
+  // response. By default, Envoy will only send the path components in the first line.
+  // If this is true, Envoy will create a fully qualified URI composing scheme
+  // (inferred if not present), host (from the host/:authority header) and path
+  // (from first line or :path header).
+  bool send_fully_qualified_url = 8;
+
+  // [#not-implemented-hide:] Hiding so that field can be removed after BalsaParser is rolled out.
+  // If set, force HTTP/1 parser: BalsaParser if true, http-parser if false.
+  // If unset, HTTP/1 parser is selected based on
+  // envoy.reloadable_features.http1_use_balsa_parser.
+  // See issue #21245.
+  google.protobuf.BoolValue use_balsa_parser = 9
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // [#not-implemented-hide:] Hiding so that field can be removed.
+  // If true, and BalsaParser is used (either `use_balsa_parser` above is true,
+  // or `envoy.reloadable_features.http1_use_balsa_parser` is true and
+  // `use_balsa_parser` is unset), then every non-empty method with only valid
+  // characters is accepted. Otherwise, methods not on the hard-coded list are
+  // rejected.
+  // Once UHV is enabled, this field should be removed, and BalsaParser should
+  // allow any method. UHV validates the method, rejecting empty string or
+  // invalid characters, and provides :ref:`restrict_http_methods
+  // <envoy_v3_api_field_extensions.http.header_validators.envoy_default.v3.HeaderValidatorConfig.restrict_http_methods>`
+  // to reject custom methods.
+  bool allow_custom_methods = 10 [(xds.annotations.v3.field_status).work_in_progress = true];
+
+  // Ignore HTTP/1.1 upgrade values matching any of the supplied matchers.
+  //
+  // .. note::
+  //
+  //   ``h2c`` upgrades are always removed for backwards compatibility, regardless of the
+  //   value in this setting.
+  repeated type.matcher.v3.StringMatcher ignore_http_11_upgrade = 11;
+}
+
+message KeepaliveSettings {
+  // Send HTTP/2 PING frames at this period, in order to test that the connection is still alive.
+  // If this is zero, interval PINGs will not be sent.
+  google.protobuf.Duration interval = 1 [(validate.rules).duration = {gte {nanos: 1000000}}];
+
+  // How long to wait for a response to a keepalive PING. If a response is not received within this
+  // time period, the connection will be aborted. Note that in order to prevent the influence of
+  // Head-of-line (HOL) blocking the timeout period is extended when *any* frame is received on
+  // the connection, under the assumption that if a frame is received the connection is healthy.
+  google.protobuf.Duration timeout = 2 [(validate.rules).duration = {
+    required: true
+    gte {nanos: 1000000}
+  }];
+
+  // A random jitter amount as a percentage of interval that will be added to each interval.
+  // A value of zero means there will be no jitter.
+  // The default value is 15%.
+  type.v3.Percent interval_jitter = 3;
+
+  // If the connection has been idle for this duration, send a HTTP/2 ping ahead
+  // of new stream creation, to quickly detect dead connections.
+  // If this is zero, this type of PING will not be sent.
+  // If an interval ping is outstanding, a second ping will not be sent as the
+  // interval ping will determine if the connection is dead.
+  //
+  // The same feature for HTTP/3 is given by inheritance from QUICHE which uses :ref:`connection idle_timeout <envoy_v3_api_field_config.listener.v3.QuicProtocolOptions.idle_timeout>` and the current PTO of the connection to decide whether to probe before sending a new request.
+  google.protobuf.Duration connection_idle_interval = 4
+      [(validate.rules).duration = {gte {nanos: 1000000}}];
+}
+
+// [#next-free-field: 18]
+message Http2ProtocolOptions {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.core.Http2ProtocolOptions";
+
+  // Defines a parameter to be sent in the SETTINGS frame.
+  // See `RFC7540, sec. 6.5.1 <https://tools.ietf.org/html/rfc7540#section-6.5.1>`_ for details.
+  message SettingsParameter {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.core.Http2ProtocolOptions.SettingsParameter";
+
+    // The 16 bit parameter identifier.
+    google.protobuf.UInt32Value identifier = 1 [
+      (validate.rules).uint32 = {lte: 65535 gte: 0},
+      (validate.rules).message = {required: true}
+    ];
+
+    // The 32 bit parameter value.
+    google.protobuf.UInt32Value value = 2 [(validate.rules).message = {required: true}];
+  }
+
+  // `Maximum table size <https://httpwg.org/specs/rfc7541.html#rfc.section.4.2>`_
+  // (in octets) that the encoder is permitted to use for the dynamic HPACK table. Valid values
+  // range from 0 to 4294967295 (2^32 - 1) and defaults to 4096. 0 effectively disables header
+  // compression.
+  google.protobuf.UInt32Value hpack_table_size = 1;
+
+  // `Maximum concurrent streams <https://httpwg.org/specs/rfc7540.html#rfc.section.5.1.2>`_
+  // allowed for peer on one HTTP/2 connection. Valid values range from 1 to 2147483647 (2^31 - 1)
+  // and defaults to 1024 for safety and should be sufficient for most use cases.
+  //
+  // For upstream connections, this also limits how many streams Envoy will initiate concurrently
+  // on a single connection. If the limit is reached, Envoy may queue requests or establish
+  // additional connections (as allowed per circuit breaker limits).
+  //
+  // This acts as an upper bound: Envoy will lower the max concurrent streams allowed on a given
+  // connection based on upstream settings. Config dumps will reflect the configured upper bound,
+  // not the per-connection negotiated limits.
+  google.protobuf.UInt32Value max_concurrent_streams = 2
+      [(validate.rules).uint32 = {lte: 2147483647 gte: 1}];
+
+  // `Initial stream-level flow-control window
+  // <https://httpwg.org/specs/rfc7540.html#rfc.section.6.9.2>`_ size. Valid values range from 65535
+  // (2^16 - 1, HTTP/2 default) to 2147483647 (2^31 - 1, HTTP/2 maximum) and defaults to
+  // 16MiB (16 * 1024 * 1024).
+  //
+  // .. note::
+  //
+  //   65535 is the initial window size from HTTP/2 spec. We only support increasing the default window size now,
+  //   so it's also the minimum.
+  //
+  // This field also acts as a soft limit on the number of bytes Envoy will buffer per-stream in the
+  // HTTP/2 codec buffers. Once the buffer reaches this pointer, watermark callbacks will fire to
+  // stop the flow of data to the codec buffers.
+  google.protobuf.UInt32Value initial_stream_window_size = 3
+      [(validate.rules).uint32 = {lte: 2147483647 gte: 65535}];
+
+  // Similar to ``initial_stream_window_size``, but for connection-level flow-control
+  // window. The default is 24MiB (24 * 1024 * 1024).
+  google.protobuf.UInt32Value initial_connection_window_size = 4
+      [(validate.rules).uint32 = {lte: 2147483647 gte: 65535}];
+
+  // Allows proxying Websocket and other upgrades over H2 connect.
+  bool allow_connect = 5;
+
+  // [#not-implemented-hide:] Hiding until Envoy has full metadata support.
+  // Still under implementation. DO NOT USE.
+  //
+  // Allows sending and receiving HTTP/2 METADATA frames. See [metadata
+  // docs](https://github.com/envoyproxy/envoy/blob/main/source/docs/h2_metadata.md) for more
+  // information.
+  bool allow_metadata = 6;
+
+  // Limit the number of pending outbound downstream frames of all types (frames that are waiting to
+  // be written into the socket). Exceeding this limit triggers flood mitigation and connection is
+  // terminated. The ``http2.outbound_flood`` stat tracks the number of terminated connections due
+  // to flood mitigation. The default limit is 10000.
+  google.protobuf.UInt32Value max_outbound_frames = 7 [(validate.rules).uint32 = {gte: 1}];
+
+  // Limit the number of pending outbound downstream frames of types PING, SETTINGS and RST_STREAM,
+  // preventing high memory utilization when receiving continuous stream of these frames. Exceeding
+  // this limit triggers flood mitigation and connection is terminated. The
+  // ``http2.outbound_control_flood`` stat tracks the number of terminated connections due to flood
+  // mitigation. The default limit is 1000.
+  google.protobuf.UInt32Value max_outbound_control_frames = 8 [(validate.rules).uint32 = {gte: 1}];
+
+  // Limit the number of consecutive inbound frames of types HEADERS, CONTINUATION and DATA with an
+  // empty payload and no end stream flag. Those frames have no legitimate use and are abusive, but
+  // might be a result of a broken HTTP/2 implementation. The `http2.inbound_empty_frames_flood``
+  // stat tracks the number of connections terminated due to flood mitigation.
+  // Setting this to 0 will terminate connection upon receiving first frame with an empty payload
+  // and no end stream flag. The default limit is 1.
+  google.protobuf.UInt32Value max_consecutive_inbound_frames_with_empty_payload = 9;
+
+  // Limit the number of inbound PRIORITY frames allowed per each opened stream. If the number
+  // of PRIORITY frames received over the lifetime of connection exceeds the value calculated
+  // using this formula::
+  //
+  //   ``max_inbound_priority_frames_per_stream`` * (1 + ``opened_streams``)
+  //
+  // the connection is terminated. For downstream connections the ``opened_streams`` is incremented when
+  // Envoy receives complete response headers from the upstream server. For upstream connection the
+  // ``opened_streams`` is incremented when Envoy send the HEADERS frame for a new stream. The
+  // ``http2.inbound_priority_frames_flood`` stat tracks
+  // the number of connections terminated due to flood mitigation. The default limit is 100.
+  google.protobuf.UInt32Value max_inbound_priority_frames_per_stream = 10;
+
+  // Limit the number of inbound WINDOW_UPDATE frames allowed per DATA frame sent. If the number
+  // of WINDOW_UPDATE frames received over the lifetime of connection exceeds the value calculated
+  // using this formula::
+  //
+  //   5 + 2 * (``opened_streams`` +
+  //            ``max_inbound_window_update_frames_per_data_frame_sent`` * ``outbound_data_frames``)
+  //
+  // the connection is terminated. For downstream connections the ``opened_streams`` is incremented when
+  // Envoy receives complete response headers from the upstream server. For upstream connections the
+  // ``opened_streams`` is incremented when Envoy sends the HEADERS frame for a new stream. The
+  // ``http2.inbound_priority_frames_flood`` stat tracks the number of connections terminated due to
+  // flood mitigation. The default max_inbound_window_update_frames_per_data_frame_sent value is 10.
+  // Setting this to 1 should be enough to support HTTP/2 implementations with basic flow control,
+  // but more complex implementations that try to estimate available bandwidth require at least 2.
+  google.protobuf.UInt32Value max_inbound_window_update_frames_per_data_frame_sent = 11
+      [(validate.rules).uint32 = {gte: 1}];
+
+  // Allows invalid HTTP messaging and headers. When this option is disabled (default), then
+  // the whole HTTP/2 connection is terminated upon receiving invalid HEADERS frame. However,
+  // when this option is enabled, only the offending stream is terminated.
+  //
+  // This is overridden by HCM :ref:`stream_error_on_invalid_http_messaging
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_error_on_invalid_http_message>`
+  // iff present.
+  //
+  // This is deprecated in favor of :ref:`override_stream_error_on_invalid_http_message
+  // <envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.override_stream_error_on_invalid_http_message>`
+  //
+  // See `RFC7540, sec. 8.1 <https://tools.ietf.org/html/rfc7540#section-8.1>`_ for details.
+  bool stream_error_on_invalid_http_messaging = 12
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Allows invalid HTTP messaging and headers. When this option is disabled (default), then
+  // the whole HTTP/2 connection is terminated upon receiving invalid HEADERS frame. However,
+  // when this option is enabled, only the offending stream is terminated.
+  //
+  // This overrides any HCM :ref:`stream_error_on_invalid_http_messaging
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_error_on_invalid_http_message>`
+  //
+  // See `RFC7540, sec. 8.1 <https://tools.ietf.org/html/rfc7540#section-8.1>`_ for details.
+  google.protobuf.BoolValue override_stream_error_on_invalid_http_message = 14;
+
+  // [#not-implemented-hide:]
+  // Specifies SETTINGS frame parameters to be sent to the peer, with two exceptions:
+  //
+  // 1. SETTINGS_ENABLE_PUSH (0x2) is not configurable as HTTP/2 server push is not supported by
+  // Envoy.
+  //
+  // 2. SETTINGS_ENABLE_CONNECT_PROTOCOL (0x8) is only configurable through the named field
+  // 'allow_connect'.
+  //
+  // Note that custom parameters specified through this field can not also be set in the
+  // corresponding named parameters:
+  //
+  // .. code-block:: text
+  //
+  //   ID    Field Name
+  //   ----------------
+  //   0x1   hpack_table_size
+  //   0x3   max_concurrent_streams
+  //   0x4   initial_stream_window_size
+  //
+  // Collisions will trigger config validation failure on load/update. Likewise, inconsistencies
+  // between custom parameters with the same identifier will trigger a failure.
+  //
+  // See `IANA HTTP/2 Settings
+  // <https://www.iana.org/assignments/http2-parameters/http2-parameters.xhtml#settings>`_ for
+  // standardized identifiers.
+  repeated SettingsParameter custom_settings_parameters = 13;
+
+  // Send HTTP/2 PING frames to verify that the connection is still healthy. If the remote peer
+  // does not respond within the configured timeout, the connection will be aborted.
+  KeepaliveSettings connection_keepalive = 15;
+
+  // [#not-implemented-hide:] Hiding so that the field can be removed after oghttp2 is rolled out.
+  // If set, force use of a particular HTTP/2 codec: oghttp2 if true, nghttp2 if false.
+  // If unset, HTTP/2 codec is selected based on envoy.reloadable_features.http2_use_oghttp2.
+  google.protobuf.BoolValue use_oghttp2_codec = 16
+      [(xds.annotations.v3.field_status).work_in_progress = true];
+
+  // Configure the maximum amount of metadata than can be handled per stream. Defaults to 1 MB.
+  google.protobuf.UInt64Value max_metadata_size = 17;
+}
+
+// [#not-implemented-hide:]
+message GrpcProtocolOptions {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.core.GrpcProtocolOptions";
+
+  Http2ProtocolOptions http2_protocol_options = 1;
+}
+
+// A message which allows using HTTP/3.
+// [#next-free-field: 9]
+message Http3ProtocolOptions {
+  QuicProtocolOptions quic_protocol_options = 1;
+
+  // Allows invalid HTTP messaging and headers. When this option is disabled (default), then
+  // the whole HTTP/3 connection is terminated upon receiving invalid HEADERS frame. However,
+  // when this option is enabled, only the offending stream is terminated.
+  //
+  // If set, this overrides any HCM :ref:`stream_error_on_invalid_http_messaging
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_error_on_invalid_http_message>`.
+  google.protobuf.BoolValue override_stream_error_on_invalid_http_message = 2;
+
+  // Allows proxying Websocket and other upgrades over HTTP/3 CONNECT using
+  // the header mechanisms from the `HTTP/2 extended connect RFC
+  // <https://datatracker.ietf.org/doc/html/rfc8441>`_
+  // and settings `proposed for HTTP/3
+  // <https://datatracker.ietf.org/doc/draft-ietf-httpbis-h3-websockets/>`_
+  // Note that HTTP/3 CONNECT is not yet an RFC.
+  bool allow_extended_connect = 5 [(xds.annotations.v3.field_status).work_in_progress = true];
+
+  // [#not-implemented-hide:] Hiding until Envoy has full metadata support.
+  // Still under implementation. DO NOT USE.
+  //
+  // Allows sending and receiving HTTP/3 METADATA frames. See [metadata
+  // docs](https://github.com/envoyproxy/envoy/blob/main/source/docs/h2_metadata.md) for more
+  // information.
+  bool allow_metadata = 6;
+
+  // [#not-implemented-hide:] Hiding until Envoy has full HTTP/3 upstream support.
+  // Still under implementation. DO NOT USE.
+  //
+  // Disables QPACK compression related features for HTTP/3 including:
+  // No huffman encoding, zero dynamic table capacity and no cookie crumbing.
+  // This can be useful for trading off CPU vs bandwidth when an upstream HTTP/3 connection multiplexes multiple downstream connections.
+  bool disable_qpack = 7;
+
+  // Disables connection level flow control for HTTP/3 streams. This is useful in situations where the streams share the same connection
+  // but originate from different end-clients, so that each stream can make progress independently at non-front-line proxies.
+  bool disable_connection_flow_control_for_streams = 8;
+}
+
+// A message to control transformations to the :scheme header
+message SchemeHeaderTransformation {
+  oneof transformation {
+    // Overwrite any Scheme header with the contents of this string.
+    // If set, takes precedence over match_upstream.
+    string scheme_to_overwrite = 1 [(validate.rules).string = {in: "http" in: "https"}];
+  }
+
+  // Set the Scheme header to match the upstream transport protocol. For example, should a
+  // request be sent to the upstream over TLS, the scheme header will be set to "https". Should the
+  // request be sent over plaintext, the scheme header will be set to "http".
+  // If scheme_to_overwrite is set, this field is not used.
+  bool match_upstream = 2;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/proxy_protocol.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/proxy_protocol.proto
new file mode 100644
index 00000000000..564e76cb1e5
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/proxy_protocol.proto
@@ -0,0 +1,90 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "ProxyProtocolProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Proxy protocol]
+
+message ProxyProtocolPassThroughTLVs {
+  enum PassTLVsMatchType {
+    // Pass all TLVs.
+    INCLUDE_ALL = 0;
+
+    // Pass specific TLVs defined in tlv_type.
+    INCLUDE = 1;
+  }
+
+  // The strategy to pass through TLVs. Default is INCLUDE_ALL.
+  // If INCLUDE_ALL is set, all TLVs will be passed through no matter the tlv_type field.
+  PassTLVsMatchType match_type = 1;
+
+  // The TLV types that are applied based on match_type.
+  // TLV type is defined as uint8_t in proxy protocol. See `the spec
+  // <https://www.haproxy.org/download/2.1/doc/proxy-protocol.txt>`_ for details.
+  repeated uint32 tlv_type = 2 [(validate.rules).repeated = {items {uint32 {lt: 256}}}];
+}
+
+// Represents a single Type-Length-Value (TLV) entry.
+message TlvEntry {
+  // The type of the TLV. Must be a uint8 (0-255) as per the Proxy Protocol v2 specification.
+  uint32 type = 1 [(validate.rules).uint32 = {lt: 256}];
+
+  // The value of the TLV. Must be at least one byte long.
+  bytes value = 2 [(validate.rules).bytes = {min_len: 1}];
+}
+
+message ProxyProtocolConfig {
+  enum Version {
+    // PROXY protocol version 1. Human readable format.
+    V1 = 0;
+
+    // PROXY protocol version 2. Binary format.
+    V2 = 1;
+  }
+
+  // The PROXY protocol version to use. See https://www.haproxy.org/download/2.1/doc/proxy-protocol.txt for details
+  Version version = 1;
+
+  // This config controls which TLVs can be passed to upstream if it is Proxy Protocol
+  // V2 header. If there is no setting for this field, no TLVs will be passed through.
+  ProxyProtocolPassThroughTLVs pass_through_tlvs = 2;
+
+  // This config allows additional TLVs to be included in the upstream PROXY protocol
+  // V2 header. Unlike ``pass_through_tlvs``, which passes TLVs from the downstream request,
+  // ``added_tlvs`` provides an extension mechanism for defining new TLVs that are included
+  // with the upstream request. These TLVs may not be present in the downstream request and
+  // can be defined at either the transport socket level or the host level to provide more
+  // granular control over the TLVs that are included in the upstream request.
+  //
+  // Host-level TLVs are specified in the ``metadata.typed_filter_metadata`` field under the
+  // ``envoy.transport_sockets.proxy_protocol`` namespace.
+  //
+  // .. literalinclude:: /_configs/repo/proxy_protocol.yaml
+  //    :language: yaml
+  //    :lines: 49-57
+  //    :linenos:
+  //    :lineno-start: 49
+  //    :caption: :download:`proxy_protocol.yaml </_configs/repo/proxy_protocol.yaml>`
+  //
+  // **Precedence behavior**:
+  //
+  // - When a TLV is defined at both the host level and the transport socket level, the value
+  //   from the host level configuration takes precedence. This allows users to define default TLVs
+  //   at the transport socket level and override them at the host level.
+  // - Any TLV defined in the ``pass_through_tlvs`` field will be overridden by either the host-level
+  //   or transport socket-level TLV.
+  repeated TlvEntry added_tlvs = 3;
+}
+
+message PerHostConfig {
+  // Enables per-host configuration for Proxy Protocol.
+  repeated TlvEntry added_tlvs = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/resolver.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/resolver.proto
new file mode 100644
index 00000000000..f4d103ab038
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/resolver.proto
@@ -0,0 +1,36 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "envoy/config/core/v3/address.proto";
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "ResolverProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Resolver]
+
+// Configuration of DNS resolver option flags which control the behavior of the DNS resolver.
+message DnsResolverOptions {
+  // Use TCP for all DNS queries instead of the default protocol UDP.
+  bool use_tcp_for_dns_lookups = 1;
+
+  // Do not use the default search domains; only query hostnames as-is or as aliases.
+  bool no_default_search_domain = 2;
+}
+
+// DNS resolution configuration which includes the underlying dns resolver addresses and options.
+message DnsResolutionConfig {
+  // A list of dns resolver addresses. If specified, the DNS client library will perform resolution
+  // via the underlying DNS resolvers. Otherwise, the default system resolvers
+  // (e.g., /etc/resolv.conf) will be used.
+  repeated Address resolvers = 1 [(validate.rules).repeated = {min_items: 1}];
+
+  // Configuration of DNS resolver option flags which control the behavior of the DNS resolver.
+  DnsResolverOptions dns_resolver_options = 2;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/socket_cmsg_headers.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/socket_cmsg_headers.proto
new file mode 100644
index 00000000000..cc3e58e0996
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/socket_cmsg_headers.proto
@@ -0,0 +1,28 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "SocketCmsgHeadersProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Socket CMSG headers]
+
+// Configuration for socket cmsg headers.
+// See `:ref:CMSG <https://man7.org/linux/man-pages/man3/cmsg.3.html>`_ for further information.
+message SocketCmsgHeaders {
+  // cmsg level. Default is unset.
+  google.protobuf.UInt32Value level = 1;
+
+  // cmsg type. Default is unset.
+  google.protobuf.UInt32Value type = 2;
+
+  // Expected size of cmsg value. Default is zero.
+  uint32 expected_size = 3;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/socket_option.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/socket_option.proto
new file mode 100644
index 00000000000..ad73d72e490
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/socket_option.proto
@@ -0,0 +1,108 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "SocketOptionProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Socket option]
+
+// Generic socket option message. This would be used to set socket options that
+// might not exist in upstream kernels or precompiled Envoy binaries.
+//
+// For example:
+//
+// .. code-block:: json
+//
+//  {
+//    "description": "support tcp keep alive",
+//    "state": 0,
+//    "level": 1,
+//    "name": 9,
+//    "int_value": 1,
+//  }
+//
+// 1 means SOL_SOCKET and 9 means SO_KEEPALIVE on Linux.
+// With the above configuration, `TCP Keep-Alives <https://www.freesoft.org/CIE/RFC/1122/114.htm>`_
+// can be enabled in socket with Linux, which can be used in
+// :ref:`listener's<envoy_v3_api_field_config.listener.v3.Listener.socket_options>` or
+// :ref:`admin's <envoy_v3_api_field_config.bootstrap.v3.Admin.socket_options>` socket_options etc.
+//
+// It should be noted that the name or level may have different values on different platforms.
+// [#next-free-field: 8]
+message SocketOption {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.core.SocketOption";
+
+  enum SocketState {
+    // Socket options are applied after socket creation but before binding the socket to a port
+    STATE_PREBIND = 0;
+
+    // Socket options are applied after binding the socket to a port but before calling listen()
+    STATE_BOUND = 1;
+
+    // Socket options are applied after calling listen()
+    STATE_LISTENING = 2;
+  }
+
+  // The `socket type <https://linux.die.net/man/2/socket>`_ to apply the socket option to.
+  // Only one field should be set. If multiple fields are set, the precedence order will determine
+  // the selected one. If none of the fields is set, the socket option will be applied to all socket types.
+  //
+  // For example:
+  // If :ref:`stream <envoy_v3_api_field_config.core.v3.SocketOption.SocketType.stream>` is set,
+  // it takes precedence over :ref:`datagram <envoy_v3_api_field_config.core.v3.SocketOption.SocketType.datagram>`.
+  message SocketType {
+    // The stream socket type.
+    message Stream {
+    }
+
+    // The datagram socket type.
+    message Datagram {
+    }
+
+    // Apply the socket option to the stream socket type.
+    Stream stream = 1;
+
+    // Apply the socket option to the datagram socket type.
+    Datagram datagram = 2;
+  }
+
+  // An optional name to give this socket option for debugging, etc.
+  // Uniqueness is not required and no special meaning is assumed.
+  string description = 1;
+
+  // Corresponding to the level value passed to setsockopt, such as IPPROTO_TCP
+  int64 level = 2;
+
+  // The numeric name as passed to setsockopt
+  int64 name = 3;
+
+  oneof value {
+    option (validate.required) = true;
+
+    // Because many sockopts take an int value.
+    int64 int_value = 4;
+
+    // Otherwise it's a byte buffer.
+    bytes buf_value = 5;
+  }
+
+  // The state in which the option will be applied. When used in BindConfig
+  // STATE_PREBIND is currently the only valid value.
+  SocketState state = 6 [(validate.rules).enum = {defined_only: true}];
+
+  // Apply the socket option to the specified `socket type <https://linux.die.net/man/2/socket>`_.
+  // If not specified, the socket option will be applied to all socket types.
+  SocketType type = 7;
+}
+
+message SocketOptionsOverride {
+  repeated SocketOption socket_options = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/substitution_format_string.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/substitution_format_string.proto
new file mode 100644
index 00000000000..3edbf5f5f00
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/substitution_format_string.proto
@@ -0,0 +1,136 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/extension.proto";
+
+import "google/protobuf/struct.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "SubstitutionFormatStringProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Substitution format string]
+
+// Optional configuration options to be used with json_format.
+message JsonFormatOptions {
+  // The output JSON string properties will be sorted.
+  //
+  // .. note::
+  //   As the properties are always sorted, this option has no effect and is deprecated.
+  //
+  bool sort_properties = 1
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+}
+
+// Configuration to use multiple :ref:`command operators <config_access_log_command_operators>`
+// to generate a new string in either plain text or JSON format.
+// [#next-free-field: 8]
+message SubstitutionFormatString {
+  oneof format {
+    option (validate.required) = true;
+
+    // Specify a format with command operators to form a text string.
+    // Its details is described in :ref:`format string<config_access_log_format_strings>`.
+    //
+    // For example, setting ``text_format`` like below,
+    //
+    // .. validated-code-block:: yaml
+    //   :type-name: envoy.config.core.v3.SubstitutionFormatString
+    //
+    //   text_format: "%LOCAL_REPLY_BODY%:%RESPONSE_CODE%:path=%REQ(:path)%\n"
+    //
+    // generates plain text similar to:
+    //
+    // .. code-block:: text
+    //
+    //   upstream connect error:503:path=/foo
+    //
+    // Deprecated in favor of :ref:`text_format_source <envoy_v3_api_field_config.core.v3.SubstitutionFormatString.text_format_source>`. To migrate text format strings, use the :ref:`inline_string <envoy_v3_api_field_config.core.v3.DataSource.inline_string>` field.
+    string text_format = 1
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+    // Specify a format with command operators to form a JSON string.
+    // Its details is described in :ref:`format dictionary<config_access_log_format_dictionaries>`.
+    // Values are rendered as strings, numbers, or boolean values as appropriate.
+    // Nested JSON objects may be produced by some command operators (e.g. FILTER_STATE or DYNAMIC_METADATA).
+    // See the documentation for a specific command operator for details.
+    //
+    // .. validated-code-block:: yaml
+    //   :type-name: envoy.config.core.v3.SubstitutionFormatString
+    //
+    //   json_format:
+    //     status: "%RESPONSE_CODE%"
+    //     message: "%LOCAL_REPLY_BODY%"
+    //
+    // The following JSON object would be created:
+    //
+    // .. code-block:: json
+    //
+    //  {
+    //    "status": 500,
+    //    "message": "My error message"
+    //  }
+    //
+    google.protobuf.Struct json_format = 2 [(validate.rules).message = {required: true}];
+
+    // Specify a format with command operators to form a text string.
+    // Its details is described in :ref:`format string<config_access_log_format_strings>`.
+    //
+    // For example, setting ``text_format`` like below,
+    //
+    // .. validated-code-block:: yaml
+    //   :type-name: envoy.config.core.v3.SubstitutionFormatString
+    //
+    //   text_format_source:
+    //     inline_string: "%LOCAL_REPLY_BODY%:%RESPONSE_CODE%:path=%REQ(:path)%\n"
+    //
+    // generates plain text similar to:
+    //
+    // .. code-block:: text
+    //
+    //   upstream connect error:503:path=/foo
+    //
+    DataSource text_format_source = 5;
+  }
+
+  // If set to true, when command operators are evaluated to null,
+  //
+  // * for ``text_format``, the output of the empty operator is changed from ``-`` to an
+  //   empty string, so that empty values are omitted entirely.
+  // * for ``json_format`` the keys with null values are omitted in the output structure.
+  //
+  // .. note::
+  //   This option does not work perfectly with ``json_format`` as keys with ``null`` values
+  //   will still be included in the output. See https://github.com/envoyproxy/envoy/issues/37941
+  //   for more details.
+  //
+  bool omit_empty_values = 3;
+
+  // Specify a ``content_type`` field.
+  // If this field is not set then ``text/plain`` is used for ``text_format`` and
+  // ``application/json`` is used for ``json_format``.
+  //
+  // .. validated-code-block:: yaml
+  //   :type-name: envoy.config.core.v3.SubstitutionFormatString
+  //
+  //   content_type: "text/html; charset=UTF-8"
+  //
+  string content_type = 4
+      [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+
+  // Specifies a collection of Formatter plugins that can be called from the access log configuration.
+  // See the formatters extensions documentation for details.
+  // [#extension-category: envoy.formatter]
+  repeated TypedExtensionConfig formatters = 6;
+
+  // If json_format is used, the options will be applied to the output JSON string.
+  JsonFormatOptions json_format_options = 7;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/udp_socket_config.proto b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/udp_socket_config.proto
new file mode 100644
index 00000000000..ec9f77f0687
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/core/v3/udp_socket_config.proto
@@ -0,0 +1,32 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "UdpSocketConfigProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: UDP socket config]
+
+// Generic UDP socket configuration.
+message UdpSocketConfig {
+  // The maximum size of received UDP datagrams. Using a larger size will cause Envoy to allocate
+  // more memory per socket. Received datagrams above this size will be dropped. If not set
+  // defaults to 1500 bytes.
+  google.protobuf.UInt64Value max_rx_datagram_size = 1
+      [(validate.rules).uint64 = {lt: 65536 gt: 0}];
+
+  // Configures whether Generic Receive Offload (GRO)
+  // <https://en.wikipedia.org/wiki/Large_receive_offload>_ is preferred when reading from the
+  // UDP socket. The default is context dependent and is documented where UdpSocketConfig is used.
+  // This option affects performance but not functionality. If GRO is not supported by the operating
+  // system, non-GRO receive will be used.
+  google.protobuf.BoolValue prefer_gro = 2;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/endpoint/v3/endpoint.proto b/xds/third_party/envoy/src/main/proto/envoy/config/endpoint/v3/endpoint.proto
new file mode 100644
index 00000000000..a149f6095c1
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/endpoint/v3/endpoint.proto
@@ -0,0 +1,137 @@
+syntax = "proto3";
+
+package envoy.config.endpoint.v3;
+
+import "envoy/config/endpoint/v3/endpoint_components.proto";
+import "envoy/type/v3/percent.proto";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.endpoint.v3";
+option java_outer_classname = "EndpointProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/endpoint/v3;endpointv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Endpoint configuration]
+// Endpoint discovery :ref:`architecture overview <arch_overview_service_discovery_types_eds>`
+
+// Each route from RDS will map to a single cluster or traffic split across
+// clusters using weights expressed in the RDS WeightedCluster.
+//
+// With EDS, each cluster is treated independently from a LB perspective, with
+// LB taking place between the Localities within a cluster and at a finer
+// granularity between the hosts within a locality. The percentage of traffic
+// for each endpoint is determined by both its load_balancing_weight, and the
+// load_balancing_weight of its locality. First, a locality will be selected,
+// then an endpoint within that locality will be chose based on its weight.
+// [#next-free-field: 6]
+message ClusterLoadAssignment {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.ClusterLoadAssignment";
+
+  // Load balancing policy settings.
+  // [#next-free-field: 7]
+  message Policy {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.ClusterLoadAssignment.Policy";
+
+    message DropOverload {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.ClusterLoadAssignment.Policy.DropOverload";
+
+      // Identifier for the policy specifying the drop.
+      string category = 1 [(validate.rules).string = {min_len: 1}];
+
+      // Percentage of traffic that should be dropped for the category.
+      type.v3.FractionalPercent drop_percentage = 2;
+    }
+
+    reserved 1, 5;
+
+    reserved "disable_overprovisioning";
+
+    // Action to trim the overall incoming traffic to protect the upstream
+    // hosts. This action allows protection in case the hosts are unable to
+    // recover from an outage, or unable to autoscale or unable to handle
+    // incoming traffic volume for any reason.
+    //
+    // At the client each category is applied one after the other to generate
+    // the 'actual' drop percentage on all outgoing traffic. For example:
+    //
+    // .. code-block:: json
+    //
+    //  { "drop_overloads": [
+    //      { "category": "throttle", "drop_percentage": 60 }
+    //      { "category": "lb", "drop_percentage": 50 }
+    //  ]}
+    //
+    // The actual drop percentages applied to the traffic at the clients will be
+    //    "throttle"_drop = 60%
+    //    "lb"_drop = 20%  // 50% of the remaining 'actual' load, which is 40%.
+    //    actual_outgoing_load = 20% // remaining after applying all categories.
+    //
+    // Envoy supports only one element and will NACK if more than one element is present.
+    // Other xDS-capable data planes will not necessarily have this limitation.
+    //
+    // In Envoy, this ``drop_overloads`` config can be overridden by a runtime key
+    // "load_balancing_policy.drop_overload_limit" setting. This runtime key can be set to
+    // any integer number between 0 and 100. 0 means drop 0%. 100 means drop 100%.
+    // When both ``drop_overloads`` config and "load_balancing_policy.drop_overload_limit"
+    // setting are in place, the min of these two wins.
+    repeated DropOverload drop_overloads = 2;
+
+    // Priority levels and localities are considered overprovisioned with this
+    // factor (in percentage). This means that we don't consider a priority
+    // level or locality unhealthy until the fraction of healthy hosts
+    // multiplied by the overprovisioning factor drops below 100.
+    // With the default value 140(1.4), Envoy doesn't consider a priority level
+    // or a locality unhealthy until their percentage of healthy hosts drops
+    // below 72%. For example:
+    //
+    // .. code-block:: json
+    //
+    //  { "overprovisioning_factor": 100 }
+    //
+    // Read more at :ref:`priority levels <arch_overview_load_balancing_priority_levels>` and
+    // :ref:`localities <arch_overview_load_balancing_locality_weighted_lb>`.
+    google.protobuf.UInt32Value overprovisioning_factor = 3 [(validate.rules).uint32 = {gt: 0}];
+
+    // The max time until which the endpoints from this assignment can be used.
+    // If no new assignments are received before this time expires the endpoints
+    // are considered stale and should be marked unhealthy.
+    // Defaults to 0 which means endpoints never go stale.
+    google.protobuf.Duration endpoint_stale_after = 4 [(validate.rules).duration = {gt {}}];
+
+    // If true, use the :ref:`load balancing weight
+    // <envoy_v3_api_field_config.endpoint.v3.LbEndpoint.load_balancing_weight>` of healthy and unhealthy
+    // hosts to determine the health of the priority level. If false, use the number of healthy and unhealthy hosts
+    // to determine the health of the priority level, or in other words assume each host has a weight of 1 for
+    // this calculation.
+    //
+    // .. note::
+    //   This is not currently implemented for
+    //   :ref:`locality weighted load balancing <arch_overview_load_balancing_locality_weighted_lb>`.
+    bool weighted_priority_health = 6;
+  }
+
+  // Name of the cluster. This will be the :ref:`service_name
+  // <envoy_v3_api_field_config.cluster.v3.Cluster.EdsClusterConfig.service_name>` value if specified
+  // in the cluster :ref:`EdsClusterConfig
+  // <envoy_v3_api_msg_config.cluster.v3.Cluster.EdsClusterConfig>`.
+  string cluster_name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // List of endpoints to load balance to.
+  repeated LocalityLbEndpoints endpoints = 2;
+
+  // Map of named endpoints that can be referenced in LocalityLbEndpoints.
+  // [#not-implemented-hide:]
+  map<string, Endpoint> named_endpoints = 5;
+
+  // Load balancing policy settings.
+  Policy policy = 4;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/endpoint/v3/endpoint_components.proto b/xds/third_party/envoy/src/main/proto/envoy/config/endpoint/v3/endpoint_components.proto
new file mode 100644
index 00000000000..eacc555df73
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/endpoint/v3/endpoint_components.proto
@@ -0,0 +1,229 @@
+syntax = "proto3";
+
+package envoy.config.endpoint.v3;
+
+import "envoy/config/core/v3/address.proto";
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/config_source.proto";
+import "envoy/config/core/v3/health_check.proto";
+
+import "google/protobuf/wrappers.proto";
+
+import "xds/core/v3/collection_entry.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.endpoint.v3";
+option java_outer_classname = "EndpointComponentsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/endpoint/v3;endpointv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Endpoints]
+
+// Upstream host identifier.
+message Endpoint {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.endpoint.Endpoint";
+
+  // The optional health check configuration.
+  message HealthCheckConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.endpoint.Endpoint.HealthCheckConfig";
+
+    // Optional alternative health check port value.
+    //
+    // By default the health check address port of an upstream host is the same
+    // as the host's serving address port. This provides an alternative health
+    // check port. Setting this with a non-zero value allows an upstream host
+    // to have different health check address port.
+    uint32 port_value = 1 [(validate.rules).uint32 = {lte: 65535}];
+
+    // By default, the host header for L7 health checks is controlled by cluster level configuration
+    // (see: :ref:`host <envoy_v3_api_field_config.core.v3.HealthCheck.HttpHealthCheck.host>` and
+    // :ref:`authority <envoy_v3_api_field_config.core.v3.HealthCheck.GrpcHealthCheck.authority>`). Setting this
+    // to a non-empty value allows overriding the cluster level configuration for a specific
+    // endpoint.
+    string hostname = 2;
+
+    // Optional alternative health check host address.
+    //
+    // .. attention::
+    //
+    //   The form of the health check host address is expected to be a direct IP address.
+    core.v3.Address address = 3;
+
+    // Optional flag to control if perform active health check for this endpoint.
+    // Active health check is enabled by default if there is a health checker.
+    bool disable_active_health_check = 4;
+  }
+
+  message AdditionalAddress {
+    // Additional address that is associated with the endpoint.
+    core.v3.Address address = 1;
+  }
+
+  // The upstream host address.
+  //
+  // .. attention::
+  //
+  //   The form of host address depends on the given cluster type. For STATIC or EDS,
+  //   it is expected to be a direct IP address (or something resolvable by the
+  //   specified :ref:`resolver <envoy_v3_api_field_config.core.v3.SocketAddress.resolver_name>`
+  //   in the Address). For LOGICAL or STRICT DNS, it is expected to be hostname,
+  //   and will be resolved via DNS.
+  core.v3.Address address = 1;
+
+  // The optional health check configuration is used as configuration for the
+  // health checker to contact the health checked host.
+  //
+  // .. attention::
+  //
+  //   This takes into effect only for upstream clusters with
+  //   :ref:`active health checking <arch_overview_health_checking>` enabled.
+  HealthCheckConfig health_check_config = 2;
+
+  // The hostname associated with this endpoint. This hostname is not used for routing or address
+  // resolution. If provided, it will be associated with the endpoint, and can be used for features
+  // that require a hostname, like
+  // :ref:`auto_host_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.auto_host_rewrite>`.
+  string hostname = 3;
+
+  // An ordered list of addresses that together with ``address`` comprise the
+  // list of addresses for an endpoint. The address given in the ``address`` is
+  // prepended to this list. It is assumed that the list must already be
+  // sorted by preference order of the addresses. This will only be supported
+  // for STATIC and EDS clusters.
+  repeated AdditionalAddress additional_addresses = 4;
+}
+
+// An Endpoint that Envoy can route traffic to.
+// [#next-free-field: 6]
+message LbEndpoint {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.endpoint.LbEndpoint";
+
+  // Upstream host identifier or a named reference.
+  oneof host_identifier {
+    Endpoint endpoint = 1;
+
+    // [#not-implemented-hide:]
+    string endpoint_name = 5;
+  }
+
+  // Optional health status when known and supplied by EDS server.
+  core.v3.HealthStatus health_status = 2;
+
+  // The endpoint metadata specifies values that may be used by the load
+  // balancer to select endpoints in a cluster for a given request. The filter
+  // name should be specified as ``envoy.lb``. An example boolean key-value pair
+  // is ``canary``, providing the optional canary status of the upstream host.
+  // This may be matched against in a route's
+  // :ref:`RouteAction <envoy_v3_api_msg_config.route.v3.RouteAction>` metadata_match field
+  // to subset the endpoints considered in cluster load balancing.
+  core.v3.Metadata metadata = 3;
+
+  // The optional load balancing weight of the upstream host; at least 1.
+  // Envoy uses the load balancing weight in some of the built in load
+  // balancers. The load balancing weight for an endpoint is divided by the sum
+  // of the weights of all endpoints in the endpoint's locality to produce a
+  // percentage of traffic for the endpoint. This percentage is then further
+  // weighted by the endpoint's locality's load balancing weight from
+  // LocalityLbEndpoints. If unspecified, will be treated as 1. The sum
+  // of the weights of all endpoints in the endpoint's locality must not
+  // exceed uint32_t maximal value (4294967295).
+  google.protobuf.UInt32Value load_balancing_weight = 4 [(validate.rules).uint32 = {gte: 1}];
+}
+
+// LbEndpoint list collection. Entries are `LbEndpoint` resources or references.
+// [#not-implemented-hide:]
+message LbEndpointCollection {
+  xds.core.v3.CollectionEntry entries = 1;
+}
+
+// A configuration for an LEDS collection.
+message LedsClusterLocalityConfig {
+  // Configuration for the source of LEDS updates for a Locality.
+  core.v3.ConfigSource leds_config = 1;
+
+  // The name of the LbEndpoint collection resource.
+  //
+  // If the name ends in ``/*``, it indicates an LbEndpoint glob collection,
+  // which is supported only in the xDS incremental protocol variants.
+  // Otherwise, it indicates an LbEndpointCollection list collection.
+  //
+  // Envoy currently supports only glob collections.
+  string leds_collection_name = 2;
+}
+
+// A group of endpoints belonging to a Locality.
+// One can have multiple LocalityLbEndpoints for a locality, but only if
+// they have different priorities.
+// [#next-free-field: 10]
+message LocalityLbEndpoints {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.endpoint.LocalityLbEndpoints";
+
+  // [#not-implemented-hide:]
+  // A list of endpoints of a specific locality.
+  message LbEndpointList {
+    repeated LbEndpoint lb_endpoints = 1;
+  }
+
+  // Identifies location of where the upstream hosts run.
+  core.v3.Locality locality = 1;
+
+  // Metadata to provide additional information about the locality endpoints in aggregate.
+  core.v3.Metadata metadata = 9;
+
+  // The group of endpoints belonging to the locality specified.
+  // This is ignored if :ref:`leds_cluster_locality_config
+  // <envoy_v3_api_field_config.endpoint.v3.LocalityLbEndpoints.leds_cluster_locality_config>` is set.
+  repeated LbEndpoint lb_endpoints = 2;
+
+  oneof lb_config {
+    // [#not-implemented-hide:]
+    // Not implemented and deprecated.
+    LbEndpointList load_balancer_endpoints = 7
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+    // LEDS Configuration for the current locality.
+    // If this is set, the :ref:`lb_endpoints
+    // <envoy_v3_api_field_config.endpoint.v3.LocalityLbEndpoints.lb_endpoints>`
+    // field is ignored.
+    LedsClusterLocalityConfig leds_cluster_locality_config = 8;
+  }
+
+  // Optional: Per priority/region/zone/sub_zone weight; at least 1. The load
+  // balancing weight for a locality is divided by the sum of the weights of all
+  // localities  at the same priority level to produce the effective percentage
+  // of traffic for the locality. The sum of the weights of all localities at
+  // the same priority level must not exceed uint32_t maximal value (4294967295).
+  //
+  // Locality weights are only considered when :ref:`locality weighted load
+  // balancing <arch_overview_load_balancing_locality_weighted_lb>` is
+  // configured. These weights are ignored otherwise. If no weights are
+  // specified when locality weighted load balancing is enabled, the locality is
+  // assigned no load.
+  google.protobuf.UInt32Value load_balancing_weight = 3 [(validate.rules).uint32 = {gte: 1}];
+
+  // Optional: the priority for this LocalityLbEndpoints. If unspecified this will
+  // default to the highest priority (0).
+  //
+  // Under usual circumstances, Envoy will only select endpoints for the highest
+  // priority (0). In the event that enough endpoints for a particular priority are
+  // unavailable/unhealthy, Envoy will fail over to selecting endpoints for the
+  // next highest priority group. Read more at :ref:`priority levels <arch_overview_load_balancing_priority_levels>`.
+  //
+  // Priorities should range from 0 (highest) to N (lowest) without skipping.
+  uint32 priority = 5 [(validate.rules).uint32 = {lte: 128}];
+
+  // Optional: Per locality proximity value which indicates how close this
+  // locality is from the source locality. This value only provides ordering
+  // information (lower the value, closer it is to the source locality).
+  // This will be consumed by load balancing schemes that need proximity order
+  // to determine where to route the requests.
+  // [#not-implemented-hide:]
+  google.protobuf.UInt32Value proximity = 6;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/endpoint/v3/load_report.proto b/xds/third_party/envoy/src/main/proto/envoy/config/endpoint/v3/load_report.proto
new file mode 100644
index 00000000000..6d12765cef5
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/endpoint/v3/load_report.proto
@@ -0,0 +1,220 @@
+syntax = "proto3";
+
+package envoy.config.endpoint.v3;
+
+import "envoy/config/core/v3/address.proto";
+import "envoy/config/core/v3/base.proto";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/struct.proto";
+
+import "xds/annotations/v3/status.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.endpoint.v3";
+option java_outer_classname = "LoadReportProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/endpoint/v3;endpointv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Load Report]
+
+// These are stats Envoy reports to the management server at a frequency defined by
+// :ref:`LoadStatsResponse.load_reporting_interval<envoy_v3_api_field_service.load_stats.v3.LoadStatsResponse.load_reporting_interval>`.
+// Stats per upstream region/zone and optionally per subzone.
+// [#next-free-field: 15]
+message UpstreamLocalityStats {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.endpoint.UpstreamLocalityStats";
+
+  // Name of zone, region and optionally endpoint group these metrics were
+  // collected from. Zone and region names could be empty if unknown.
+  core.v3.Locality locality = 1;
+
+  // The total number of requests successfully completed by the endpoints in the
+  // locality.
+  uint64 total_successful_requests = 2;
+
+  // The total number of unfinished requests. A request can be an HTTP request
+  // or a TCP connection for a TCP connection pool.
+  uint64 total_requests_in_progress = 3;
+
+  // The total number of requests that failed due to errors at the endpoint,
+  // aggregated over all endpoints in the locality.
+  uint64 total_error_requests = 4;
+
+  // The total number of requests that were issued by this Envoy since
+  // the last report. This information is aggregated over all the
+  // upstream endpoints in the locality. A request can be an HTTP request
+  // or a TCP connection for a TCP connection pool.
+  uint64 total_issued_requests = 8;
+
+  // The total number of connections in an established state at the time of the
+  // report. This field is aggregated over all the upstream endpoints in the
+  // locality.
+  // In Envoy, this information may be based on ``upstream_cx_active metric``.
+  // [#not-implemented-hide:]
+  uint64 total_active_connections = 9 [(xds.annotations.v3.field_status).work_in_progress = true];
+
+  // The total number of connections opened since the last report.
+  // This field is aggregated over all the upstream endpoints in the locality.
+  // In Envoy, this information may be based on ``upstream_cx_total`` metric
+  // compared to itself between start and end of an interval, i.e.
+  // ``upstream_cx_total``(now) - ``upstream_cx_total``(now -
+  // load_report_interval).
+  // [#not-implemented-hide:]
+  uint64 total_new_connections = 10 [(xds.annotations.v3.field_status).work_in_progress = true];
+
+  // The total number of connection failures since the last report.
+  // This field is aggregated over all the upstream endpoints in the locality.
+  // In Envoy, this information may be based on ``upstream_cx_connect_fail``
+  // metric compared to itself between start and end of an interval, i.e.
+  // ``upstream_cx_connect_fail``(now) - ``upstream_cx_connect_fail``(now -
+  // load_report_interval).
+  // [#not-implemented-hide:]
+  uint64 total_fail_connections = 11 [(xds.annotations.v3.field_status).work_in_progress = true];
+
+  // CPU utilization stats for multi-dimensional load balancing.
+  // This typically comes from endpoint metrics reported via ORCA.
+  UnnamedEndpointLoadMetricStats cpu_utilization = 12;
+
+  // Memory utilization for multi-dimensional load balancing.
+  // This typically comes from endpoint metrics reported via ORCA.
+  UnnamedEndpointLoadMetricStats mem_utilization = 13;
+
+  // Blended application-defined utilization for multi-dimensional load balancing.
+  // This typically comes from endpoint metrics reported via ORCA.
+  UnnamedEndpointLoadMetricStats application_utilization = 14;
+
+  // Named stats for multi-dimensional load balancing.
+  // These typically come from endpoint metrics reported via ORCA.
+  repeated EndpointLoadMetricStats load_metric_stats = 5;
+
+  // Endpoint granularity stats information for this locality. This information
+  // is populated if the Server requests it by setting
+  // :ref:`LoadStatsResponse.report_endpoint_granularity<envoy_v3_api_field_service.load_stats.v3.LoadStatsResponse.report_endpoint_granularity>`.
+  repeated UpstreamEndpointStats upstream_endpoint_stats = 7;
+
+  // [#not-implemented-hide:] The priority of the endpoint group these metrics
+  // were collected from.
+  uint32 priority = 6;
+}
+
+// [#next-free-field: 8]
+message UpstreamEndpointStats {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.endpoint.UpstreamEndpointStats";
+
+  // Upstream host address.
+  core.v3.Address address = 1;
+
+  // Opaque and implementation dependent metadata of the
+  // endpoint. Envoy will pass this directly to the management server.
+  google.protobuf.Struct metadata = 6;
+
+  // The total number of requests successfully completed by the endpoints in the
+  // locality. These include non-5xx responses for HTTP, where errors
+  // originate at the client and the endpoint responded successfully. For gRPC,
+  // the grpc-status values are those not covered by total_error_requests below.
+  uint64 total_successful_requests = 2;
+
+  // The total number of unfinished requests for this endpoint.
+  uint64 total_requests_in_progress = 3;
+
+  // The total number of requests that failed due to errors at the endpoint.
+  // For HTTP these are responses with 5xx status codes and for gRPC the
+  // grpc-status values:
+  //
+  //   - DeadlineExceeded
+  //   - Unimplemented
+  //   - Internal
+  //   - Unavailable
+  //   - Unknown
+  //   - DataLoss
+  uint64 total_error_requests = 4;
+
+  // The total number of requests that were issued to this endpoint
+  // since the last report. A single TCP connection, HTTP or gRPC
+  // request or stream is counted as one request.
+  uint64 total_issued_requests = 7;
+
+  // Stats for multi-dimensional load balancing.
+  repeated EndpointLoadMetricStats load_metric_stats = 5;
+}
+
+message EndpointLoadMetricStats {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.endpoint.EndpointLoadMetricStats";
+
+  // Name of the metric; may be empty.
+  string metric_name = 1;
+
+  // Number of calls that finished and included this metric.
+  uint64 num_requests_finished_with_metric = 2;
+
+  // Sum of metric values across all calls that finished with this metric for
+  // load_reporting_interval.
+  double total_metric_value = 3;
+}
+
+// Same as EndpointLoadMetricStats, except without the metric_name field.
+message UnnamedEndpointLoadMetricStats {
+  // Number of calls that finished and included this metric.
+  uint64 num_requests_finished_with_metric = 1;
+
+  // Sum of metric values across all calls that finished with this metric for
+  // load_reporting_interval.
+  double total_metric_value = 2;
+}
+
+// Per cluster load stats. Envoy reports these stats a management server in a
+// :ref:`LoadStatsRequest<envoy_v3_api_msg_service.load_stats.v3.LoadStatsRequest>`
+// Next ID: 7
+// [#next-free-field: 7]
+message ClusterStats {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.endpoint.ClusterStats";
+
+  message DroppedRequests {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.endpoint.ClusterStats.DroppedRequests";
+
+    // Identifier for the policy specifying the drop.
+    string category = 1 [(validate.rules).string = {min_len: 1}];
+
+    // Total number of deliberately dropped requests for the category.
+    uint64 dropped_count = 2;
+  }
+
+  // The name of the cluster.
+  string cluster_name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // The eds_cluster_config service_name of the cluster.
+  // It's possible that two clusters send the same service_name to EDS,
+  // in that case, the management server is supposed to do aggregation on the load reports.
+  string cluster_service_name = 6;
+
+  // Need at least one.
+  repeated UpstreamLocalityStats upstream_locality_stats = 2
+      [(validate.rules).repeated = {min_items: 1}];
+
+  // Cluster-level stats such as total_successful_requests may be computed by
+  // summing upstream_locality_stats. In addition, below there are additional
+  // cluster-wide stats.
+  //
+  // The total number of dropped requests. This covers requests
+  // deliberately dropped by the drop_overload policy and circuit breaking.
+  uint64 total_dropped_requests = 3;
+
+  // Information about deliberately dropped requests for each category specified
+  // in the DropOverload policy.
+  repeated DroppedRequests dropped_requests = 5;
+
+  // Period over which the actual load report occurred. This will be guaranteed to include every
+  // request reported. Due to system load and delays between the ``LoadStatsRequest`` sent from Envoy
+  // and the ``LoadStatsResponse`` message sent from the management server, this may be longer than
+  // the requested load reporting interval in the ``LoadStatsResponse``.
+  google.protobuf.Duration load_report_interval = 4;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/api_listener.proto b/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/api_listener.proto
new file mode 100644
index 00000000000..a3610e65688
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/api_listener.proto
@@ -0,0 +1,34 @@
+syntax = "proto3";
+
+package envoy.config.listener.v3;
+
+import "google/protobuf/any.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.config.listener.v3";
+option java_outer_classname = "ApiListenerProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/listener/v3;listenerv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: API listener]
+
+// Describes a type of API listener, which is used in non-proxy clients. The type of API
+// exposed to the non-proxy application depends on the type of API listener.
+message ApiListener {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.listener.v2.ApiListener";
+
+  // The type in this field determines the type of API listener. At present, the following
+  // types are supported:
+  // envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager (HTTP)
+  // envoy.extensions.filters.network.http_connection_manager.v3.EnvoyMobileHttpConnectionManager (HTTP)
+  // [#next-major-version: In the v3 API, replace this Any field with a oneof containing the
+  // specific config message for each type of API listener. We could not do this in v2 because
+  // it would have caused circular dependencies for go protos: lds.proto depends on this file,
+  // and http_connection_manager.proto depends on rds.proto, which is in the same directory as
+  // lds.proto, so lds.proto cannot depend on this file.]
+  google.protobuf.Any api_listener = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/listener.proto b/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/listener.proto
new file mode 100644
index 00000000000..ff2f79d1137
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/listener.proto
@@ -0,0 +1,437 @@
+syntax = "proto3";
+
+package envoy.config.listener.v3;
+
+import "envoy/config/accesslog/v3/accesslog.proto";
+import "envoy/config/core/v3/address.proto";
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/config_source.proto";
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/core/v3/socket_option.proto";
+import "envoy/config/listener/v3/api_listener.proto";
+import "envoy/config/listener/v3/listener_components.proto";
+import "envoy/config/listener/v3/udp_listener_config.proto";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "xds/annotations/v3/status.proto";
+import "xds/core/v3/collection_entry.proto";
+import "xds/type/matcher/v3/matcher.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/security.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.listener.v3";
+option java_outer_classname = "ListenerProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/listener/v3;listenerv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Listener configuration]
+// Listener :ref:`configuration overview <config_listeners>`
+
+// The additional address the listener is listening on.
+message AdditionalAddress {
+  core.v3.Address address = 1;
+
+  // Additional socket options that may not be present in Envoy source code or
+  // precompiled binaries. If specified, this will override the
+  // :ref:`socket_options <envoy_v3_api_field_config.listener.v3.Listener.socket_options>`
+  // in the listener. If specified with no
+  // :ref:`socket_options <envoy_v3_api_field_config.core.v3.SocketOptionsOverride.socket_options>`
+  // or an empty list of :ref:`socket_options <envoy_v3_api_field_config.core.v3.SocketOptionsOverride.socket_options>`,
+  // it means no socket option will apply.
+  core.v3.SocketOptionsOverride socket_options = 2;
+}
+
+// Listener list collections. Entries are ``Listener`` resources or references.
+// [#not-implemented-hide:]
+message ListenerCollection {
+  repeated xds.core.v3.CollectionEntry entries = 1;
+}
+
+// [#next-free-field: 37]
+message Listener {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.Listener";
+
+  enum DrainType {
+    // Drain in response to calling /healthcheck/fail admin endpoint (along with the health check
+    // filter), listener removal/modification, and hot restart.
+    DEFAULT = 0;
+
+    // Drain in response to listener removal/modification and hot restart. This setting does not
+    // include /healthcheck/fail. This setting may be desirable if Envoy is hosting both ingress
+    // and egress listeners.
+    MODIFY_ONLY = 1;
+  }
+
+  // [#not-implemented-hide:]
+  message DeprecatedV1 {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.Listener.DeprecatedV1";
+
+    // Whether the listener should bind to the port. A listener that doesn't
+    // bind can only receive connections redirected from other listeners that
+    // set use_original_dst parameter to true. Default is true.
+    //
+    // This is deprecated. Use :ref:`Listener.bind_to_port
+    // <envoy_v3_api_field_config.listener.v3.Listener.bind_to_port>`
+    google.protobuf.BoolValue bind_to_port = 1;
+  }
+
+  // Configuration for listener connection balancing.
+  message ConnectionBalanceConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.Listener.ConnectionBalanceConfig";
+
+    // A connection balancer implementation that does exact balancing. This means that a lock is
+    // held during balancing so that connection counts are nearly exactly balanced between worker
+    // threads. This is "nearly" exact in the sense that a connection might close in parallel thus
+    // making the counts incorrect, but this should be rectified on the next accept. This balancer
+    // sacrifices accept throughput for accuracy and should be used when there are a small number of
+    // connections that rarely cycle (e.g., service mesh gRPC egress).
+    message ExactBalance {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.Listener.ConnectionBalanceConfig.ExactBalance";
+    }
+
+    oneof balance_type {
+      option (validate.required) = true;
+
+      // If specified, the listener will use the exact connection balancer.
+      ExactBalance exact_balance = 1;
+
+      // The listener will use the connection balancer according to ``type_url``. If ``type_url`` is invalid,
+      // Envoy will not attempt to balance active connections between worker threads.
+      // [#extension-category: envoy.network.connection_balance]
+      core.v3.TypedExtensionConfig extend_balance = 2;
+    }
+  }
+
+  // Configuration for envoy internal listener. All the future internal listener features should be added here.
+  message InternalListenerConfig {
+  }
+
+  // Configuration for filter chains discovery.
+  // [#not-implemented-hide:]
+  message FcdsConfig {
+    // Optional name to present to the filter chain discovery service. This may be an arbitrary name with arbitrary
+    // length. If a name is not provided, the listener's name is used. Refer to :ref:`filter_chains <envoy_v3_api_field_config.listener.v3.Listener.name>`.
+    // for details on how listener name is determined if unspecified. In addition, this may be a xdstp:// URL.
+    string name = 1;
+
+    // Configuration for the source of FCDS updates for this listener.
+    // .. note::
+    //   This discovery service only supports ``AGGREGATED_GRPC`` API type.
+    core.v3.ConfigSource config_source = 2;
+  }
+
+  reserved 14, 23;
+
+  // The unique name by which this listener is known. If no name is provided,
+  // Envoy will allocate an internal UUID for the listener. If the listener is to be dynamically
+  // updated or removed via :ref:`LDS <config_listeners_lds>` a unique name must be provided.
+  string name = 1;
+
+  // The address that the listener should listen on. In general, the address must be unique, though
+  // that is governed by the bind rules of the OS. E.g., multiple listeners can listen on port 0 on
+  // Linux as the actual port will be allocated by the OS.
+  // Required unless ``api_listener`` or ``listener_specifier`` is populated.
+  core.v3.Address address = 2;
+
+  // The additional addresses the listener should listen on. The addresses must be unique across all
+  // listeners. Multiple addresses with port 0 can be supplied. When using multiple addresses in a single listener,
+  // all addresses use the same protocol, and multiple internal addresses are not supported.
+  repeated AdditionalAddress additional_addresses = 33;
+
+  // Optional prefix to use on listener stats. If empty, the stats will be rooted at
+  // ``listener.<address as string>.``. If non-empty, stats will be rooted at
+  // ``listener.<stat_prefix>.``.
+  string stat_prefix = 28;
+
+  // A list of filter chains to consider for this listener. The
+  // :ref:`FilterChain <envoy_v3_api_msg_config.listener.v3.FilterChain>` with the most specific
+  // :ref:`FilterChainMatch <envoy_v3_api_msg_config.listener.v3.FilterChainMatch>` criteria is used on a
+  // connection.
+  //
+  // Example using SNI for filter chain selection can be found in the
+  // :ref:`FAQ entry <faq_how_to_setup_sni>`.
+  repeated FilterChain filter_chains = 3;
+
+  // Discover filter chains configurations by external service. Dynamic discovery of filter chains is allowed
+  // while having statically configured filter chains, however, a filter chain name must be unique within a
+  // listener. If a discovered filter chain matches a name of an existing filter chain, it is discarded.
+  // [#not-implemented-hide:]
+  FcdsConfig fcds_config = 36;
+
+  // :ref:`Matcher API <arch_overview_matching_listener>` resolving the filter chain name from the
+  // network properties. This matcher is used as a replacement for the filter chain match condition
+  // :ref:`filter_chain_match
+  // <envoy_v3_api_field_config.listener.v3.FilterChain.filter_chain_match>`. If specified, all
+  // :ref:`filter_chains <envoy_v3_api_field_config.listener.v3.Listener.filter_chains>` must have a
+  // non-empty and unique :ref:`name <envoy_v3_api_field_config.listener.v3.FilterChain.name>` field
+  // and not specify :ref:`filter_chain_match
+  // <envoy_v3_api_field_config.listener.v3.FilterChain.filter_chain_match>` field.
+  //
+  // .. note::
+  //
+  //  Once matched, each connection is permanently bound to its filter chain.
+  //  If the matcher changes but the filter chain remains the same, the
+  //  connections bound to the filter chain are not drained. If, however, the
+  //  filter chain is removed or structurally modified, then the drain for its
+  //  connections is initiated.
+  xds.type.matcher.v3.Matcher filter_chain_matcher = 32
+      [(xds.annotations.v3.field_status).work_in_progress = true];
+
+  // If a connection is redirected using ``iptables``, the port on which the proxy
+  // receives it might be different from the original destination address. When this flag is set to
+  // true, the listener hands off redirected connections to the listener associated with the
+  // original destination address. If there is no listener associated with the original destination
+  // address, the connection is handled by the listener that receives it. Defaults to false.
+  google.protobuf.BoolValue use_original_dst = 4;
+
+  // The default filter chain if none of the filter chain matches. If no default filter chain is supplied,
+  // the connection will be closed. The filter chain match is ignored in this field.
+  FilterChain default_filter_chain = 25;
+
+  // Soft limit on size of the listener’s new connection read and write buffers.
+  // If unspecified, an implementation defined default is applied (1MiB).
+  google.protobuf.UInt32Value per_connection_buffer_limit_bytes = 5
+      [(udpa.annotations.security).configure_for_untrusted_downstream = true];
+
+  // Listener metadata.
+  core.v3.Metadata metadata = 6;
+
+  // [#not-implemented-hide:]
+  DeprecatedV1 deprecated_v1 = 7
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // The type of draining to perform at a listener-wide level.
+  DrainType drain_type = 8;
+
+  // Listener filters have the opportunity to manipulate and augment the connection metadata that
+  // is used in connection filter chain matching, for example. These filters are run before any in
+  // :ref:`filter_chains <envoy_v3_api_field_config.listener.v3.Listener.filter_chains>`. Order matters as the
+  // filters are processed sequentially right after a socket has been accepted by the listener, and
+  // before a connection is created.
+  // UDP Listener filters can be specified when the protocol in the listener socket address in
+  // :ref:`protocol <envoy_v3_api_field_config.core.v3.SocketAddress.protocol>` is :ref:`UDP
+  // <envoy_v3_api_enum_value_config.core.v3.SocketAddress.Protocol.UDP>` and no
+  // :ref:`quic_options <envoy_v3_api_field_config.listener.v3.UdpListenerConfig.quic_options>` is specified in :ref:`udp_listener_config <envoy_v3_api_field_config.listener.v3.Listener.udp_listener_config>`.
+  // QUIC listener filters can be specified when :ref:`quic_options
+  // <envoy_v3_api_field_config.listener.v3.UdpListenerConfig.quic_options>` is
+  // specified in :ref:`udp_listener_config <envoy_v3_api_field_config.listener.v3.Listener.udp_listener_config>`.
+  // They are processed sequentially right before connection creation. And like TCP Listener filters, they can be used to manipulate the connection metadata and socket. But the difference is that they can't be used to pause connection creation.
+  repeated ListenerFilter listener_filters = 9;
+
+  // The timeout to wait for all listener filters to complete operation. If the timeout is reached,
+  // the accepted socket is closed without a connection being created unless
+  // ``continue_on_listener_filters_timeout`` is set to true. Specify 0 to disable the
+  // timeout. If not specified, a default timeout of 15s is used.
+  google.protobuf.Duration listener_filters_timeout = 15;
+
+  // Whether a connection should be created when listener filters timeout. Default is false.
+  //
+  // .. attention::
+  //
+  //   Some listener filters, such as :ref:`Proxy Protocol filter
+  //   <config_listener_filters_proxy_protocol>`, should not be used with this option. It will cause
+  //   unexpected behavior when a connection is created.
+  bool continue_on_listener_filters_timeout = 17;
+
+  // Whether the listener should be set as a transparent socket.
+  // When this flag is set to true, connections can be redirected to the listener using an
+  // ``iptables`` ``TPROXY`` target, in which case the original source and destination addresses and
+  // ports are preserved on accepted connections. This flag should be used in combination with
+  // :ref:`an original_dst <config_listener_filters_original_dst>` :ref:`listener filter
+  // <envoy_v3_api_field_config.listener.v3.Listener.listener_filters>` to mark the connections' local addresses as
+  // "restored." This can be used to hand off each redirected connection to another listener
+  // associated with the connection's destination address. Direct connections to the socket without
+  // using ``TPROXY`` cannot be distinguished from connections redirected using ``TPROXY`` and are
+  // therefore treated as if they were redirected.
+  // When this flag is set to false, the listener's socket is explicitly reset as non-transparent.
+  // Setting this flag requires Envoy to run with the ``CAP_NET_ADMIN`` capability.
+  // When this flag is not set (default), the socket is not modified, i.e. the transparent option
+  // is neither set nor reset.
+  google.protobuf.BoolValue transparent = 10;
+
+  // Whether the listener should set the ``IP_FREEBIND`` socket option. When this
+  // flag is set to true, listeners can be bound to an IP address that is not
+  // configured on the system running Envoy. When this flag is set to false, the
+  // option ``IP_FREEBIND`` is disabled on the socket. When this flag is not set
+  // (default), the socket is not modified, i.e. the option is neither enabled
+  // nor disabled.
+  google.protobuf.BoolValue freebind = 11;
+
+  // Additional socket options that may not be present in Envoy source code or
+  // precompiled binaries.
+  // It is not allowed to update the socket options for any existing address if
+  // :ref:`enable_reuse_port <envoy_v3_api_field_config.listener.v3.Listener.enable_reuse_port>`
+  // is ``false`` to avoid the conflict when creating new sockets for the listener.
+  repeated core.v3.SocketOption socket_options = 13;
+
+  // Whether the listener should accept TCP Fast Open (TFO) connections.
+  // When this flag is set to a value greater than 0, the option TCP_FASTOPEN is enabled on
+  // the socket, with a queue length of the specified size
+  // (see `details in RFC7413 <https://tools.ietf.org/html/rfc7413#section-5.1>`_).
+  // When this flag is set to 0, the option TCP_FASTOPEN is disabled on the socket.
+  // When this flag is not set (default), the socket is not modified,
+  // i.e. the option is neither enabled nor disabled.
+  //
+  // On Linux, the net.ipv4.tcp_fastopen kernel parameter must include flag 0x2 to enable
+  // TCP_FASTOPEN.
+  // See `ip-sysctl.txt <https://www.kernel.org/doc/Documentation/networking/ip-sysctl.txt>`_.
+  //
+  // On macOS, only values of 0, 1, and unset are valid; other values may result in an error.
+  // To set the queue length on macOS, set the net.inet.tcp.fastopen_backlog kernel parameter.
+  google.protobuf.UInt32Value tcp_fast_open_queue_length = 12;
+
+  // Specifies the intended direction of the traffic relative to the local Envoy.
+  // This property is required on Windows for listeners using the original destination filter,
+  // see :ref:`Original Destination <config_listener_filters_original_dst>`.
+  core.v3.TrafficDirection traffic_direction = 16;
+
+  // If the protocol in the listener socket address in :ref:`protocol
+  // <envoy_v3_api_field_config.core.v3.SocketAddress.protocol>` is :ref:`UDP
+  // <envoy_v3_api_enum_value_config.core.v3.SocketAddress.Protocol.UDP>`, this field specifies UDP
+  // listener specific configuration.
+  UdpListenerConfig udp_listener_config = 18;
+
+  // Used to represent an API listener, which is used in non-proxy clients. The type of API
+  // exposed to the non-proxy application depends on the type of API listener.
+  // When this field is set, no other field except for :ref:`name<envoy_v3_api_field_config.listener.v3.Listener.name>`
+  // should be set.
+  //
+  // .. note::
+  //
+  //  Currently only one ApiListener can be installed; and it can only be done via bootstrap config,
+  //  not LDS.
+  //
+  // [#next-major-version: In the v3 API, instead of this messy approach where the socket
+  // listener fields are directly in the top-level Listener message and the API listener types
+  // are in the ApiListener message, the socket listener messages should be in their own message,
+  // and the top-level Listener should essentially be a oneof that selects between the
+  // socket listener and the various types of API listener. That way, a given Listener message
+  // can structurally only contain the fields of the relevant type.]
+  ApiListener api_listener = 19;
+
+  // The listener's connection balancer configuration, currently only applicable to TCP listeners.
+  // If no configuration is specified, Envoy will not attempt to balance active connections between
+  // worker threads.
+  //
+  // In the scenario that the listener X redirects all the connections to the listeners Y1 and Y2
+  // by setting :ref:`use_original_dst <envoy_v3_api_field_config.listener.v3.Listener.use_original_dst>` in X
+  // and :ref:`bind_to_port <envoy_v3_api_field_config.listener.v3.Listener.bind_to_port>` to false in Y1 and Y2,
+  // it is recommended to disable the balance config in listener X to avoid the cost of balancing, and
+  // enable the balance config in Y1 and Y2 to balance the connections among the workers.
+  ConnectionBalanceConfig connection_balance_config = 20;
+
+  // Deprecated. Use ``enable_reuse_port`` instead.
+  bool reuse_port = 21 [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // When this flag is set to true, listeners set the ``SO_REUSEPORT`` socket option and
+  // create one socket for each worker thread. This makes inbound connections
+  // distribute among worker threads roughly evenly in cases where there are a high number
+  // of connections. When this flag is set to false, all worker threads share one socket. This field
+  // defaults to true. The change of field will be rejected during an listener update when the
+  // runtime flag ``envoy.reloadable_features.enable_update_listener_socket_options`` is enabled.
+  // Otherwise, the update of this field will be ignored quietly.
+  //
+  // .. attention::
+  //
+  //   Although this field defaults to true, it has different behavior on different platforms. See
+  //   the following text for more information.
+  //
+  // * On Linux, reuse_port is respected for both TCP and UDP listeners. It also works correctly
+  //   with hot restart.
+  // * On macOS, reuse_port for TCP does not do what it does on Linux. Instead of load balancing,
+  //   the last socket wins and receives all connections/packets. For TCP, reuse_port is force
+  //   disabled and the user is warned. For UDP, it is enabled, but only one worker will receive
+  //   packets. For QUIC/H3, SW routing will send packets to other workers. For "raw" UDP, only
+  //   a single worker will currently receive packets.
+  // * On Windows, reuse_port for TCP has undefined behavior. It is force disabled and the user
+  //   is warned similar to macOS. It is left enabled for UDP with undefined behavior currently.
+  google.protobuf.BoolValue enable_reuse_port = 29;
+
+  // Configuration for :ref:`access logs <arch_overview_access_logs>`
+  // emitted by this listener.
+  repeated accesslog.v3.AccessLog access_log = 22;
+
+  // The maximum length a tcp listener's pending connections queue can grow to. If no value is
+  // provided net.core.somaxconn will be used on Linux and 128 otherwise.
+  google.protobuf.UInt32Value tcp_backlog_size = 24;
+
+  // The maximum number of connections to accept from the kernel per socket
+  // event. Envoy may decide to close these connections after accepting them
+  // from the kernel e.g. due to load shedding, or other policies.
+  // If there are more than max_connections_to_accept_per_socket_event
+  // connections pending accept, connections over this threshold will be
+  // accepted in later event loop iterations.
+  // If no value is provided Envoy will accept all connections pending accept
+  // from the kernel.
+  //
+  // .. note::
+  //
+  //  It is recommended to lower this value for better overload management and reduced per-event cost.
+  //  Setting it to 1 is a viable option with no noticeable impact on performance.
+  google.protobuf.UInt32Value max_connections_to_accept_per_socket_event = 34
+      [(validate.rules).uint32 = {gt: 0}];
+
+  // Whether the listener should bind to the port. A listener that doesn't
+  // bind can only receive connections redirected from other listeners that set
+  // :ref:`use_original_dst <envoy_v3_api_field_config.listener.v3.Listener.use_original_dst>`
+  // to true. Default is true.
+  google.protobuf.BoolValue bind_to_port = 26;
+
+  // The exclusive listener type and the corresponding config.
+  oneof listener_specifier {
+    // Used to represent an internal listener which does not listen on OSI L4 address but can be used by the
+    // :ref:`envoy cluster <envoy_v3_api_msg_config.cluster.v3.Cluster>` to create a user space connection to.
+    // The internal listener acts as a TCP listener. It supports listener filters and network filter chains.
+    // Upstream clusters refer to the internal listeners by their :ref:`name
+    // <envoy_v3_api_field_config.listener.v3.Listener.name>`. :ref:`Address
+    // <envoy_v3_api_field_config.listener.v3.Listener.address>` must not be set on the internal listeners.
+    //
+    // There are some limitations that are derived from the implementation. The known limitations include:
+    //
+    // * :ref:`ConnectionBalanceConfig <envoy_v3_api_msg_config.listener.v3.Listener.ConnectionBalanceConfig>` is not
+    //   allowed because both the cluster connection and the listener connection must be owned by the same dispatcher.
+    // * :ref:`tcp_backlog_size <envoy_v3_api_field_config.listener.v3.Listener.tcp_backlog_size>`
+    // * :ref:`freebind <envoy_v3_api_field_config.listener.v3.Listener.freebind>`
+    // * :ref:`transparent <envoy_v3_api_field_config.listener.v3.Listener.transparent>`
+    InternalListenerConfig internal_listener = 27;
+  }
+
+  // Enable MPTCP (multi-path TCP) on this listener. Clients will be allowed to establish
+  // MPTCP connections. Non-MPTCP clients will fall back to regular TCP.
+  bool enable_mptcp = 30;
+
+  // Whether the listener should limit connections based upon the value of
+  // :ref:`global_downstream_max_connections <config_overload_manager_limiting_connections>`.
+  bool ignore_global_conn_limit = 31;
+
+  // Whether the listener bypasses configured overload manager actions.
+  bool bypass_overload_manager = 35;
+}
+
+// A placeholder proto so that users can explicitly configure the standard
+// Listener Manager via the bootstrap's :ref:`listener_manager <envoy_v3_api_field_config.bootstrap.v3.Bootstrap.listener_manager>`.
+// [#not-implemented-hide:]
+message ListenerManager {
+}
+
+// A placeholder proto so that users can explicitly configure the standard
+// Validation Listener Manager via the bootstrap's :ref:`listener_manager <envoy_v3_api_field_config.bootstrap.v3.Bootstrap.listener_manager>`.
+// [#not-implemented-hide:]
+message ValidationListenerManager {
+}
+
+// A placeholder proto so that users can explicitly configure the API
+// Listener Manager via the bootstrap's :ref:`listener_manager <envoy_v3_api_field_config.bootstrap.v3.Bootstrap.listener_manager>`.
+// [#not-implemented-hide:]
+message ApiListenerManager {
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/listener_components.proto b/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/listener_components.proto
new file mode 100644
index 00000000000..cfa30afbb68
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/listener_components.proto
@@ -0,0 +1,351 @@
+syntax = "proto3";
+
+package envoy.config.listener.v3;
+
+import "envoy/config/core/v3/address.proto";
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/config_source.proto";
+import "envoy/type/v3/range.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.listener.v3";
+option java_outer_classname = "ListenerComponentsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/listener/v3;listenerv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Listener components]
+// Listener :ref:`configuration overview <config_listeners>`
+
+// [#next-free-field: 6]
+message Filter {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.listener.Filter";
+
+  reserved 3, 2;
+
+  reserved "config";
+
+  // The name of the filter configuration.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  oneof config_type {
+    // Filter specific configuration which depends on the filter being
+    // instantiated. See the supported filters for further documentation.
+    // [#extension-category: envoy.filters.network]
+    google.protobuf.Any typed_config = 4;
+
+    // Configuration source specifier for an extension configuration discovery
+    // service. In case of a failure and without the default configuration, the
+    // listener closes the connections.
+    core.v3.ExtensionConfigSource config_discovery = 5;
+  }
+}
+
+// Specifies the match criteria for selecting a specific filter chain for a
+// listener.
+//
+// In order for a filter chain to be selected, *ALL* of its criteria must be
+// fulfilled by the incoming connection, properties of which are set by the
+// networking stack and/or listener filters.
+//
+// The following order applies:
+//
+// 1. Destination port.
+// 2. Destination IP address.
+// 3. Server name (e.g. SNI for TLS protocol),
+// 4. Transport protocol.
+// 5. Application protocols (e.g. ALPN for TLS protocol).
+// 6. Directly connected source IP address (this will only be different from the source IP address
+//    when using a listener filter that overrides the source address, such as the :ref:`Proxy Protocol
+//    listener filter <config_listener_filters_proxy_protocol>`).
+// 7. Source type (e.g. any, local or external network).
+// 8. Source IP address.
+// 9. Source port.
+//
+// For criteria that allow ranges or wildcards, the most specific value in any
+// of the configured filter chains that matches the incoming connection is going
+// to be used (e.g. for SNI ``www.example.com`` the most specific match would be
+// ``www.example.com``, then ``*.example.com``, then ``*.com``, then any filter
+// chain without ``server_names`` requirements).
+//
+// A different way to reason about the filter chain matches:
+// Suppose there exists N filter chains. Prune the filter chain set using the above 8 steps.
+// In each step, filter chains which most specifically matches the attributes continue to the next step.
+// The listener guarantees at most 1 filter chain is left after all of the steps.
+//
+// Example:
+//
+// For destination port, filter chains specifying the destination port of incoming traffic are the
+// most specific match. If none of the filter chains specifies the exact destination port, the filter
+// chains which do not specify ports are the most specific match. Filter chains specifying the
+// wrong port can never be the most specific match.
+//
+// [#comment: Implemented rules are kept in the preference order, with deprecated fields
+// listed at the end, because that's how we want to list them in the docs.
+//
+// [#comment:TODO(PiotrSikora): Add support for configurable precedence of the rules]
+// [#next-free-field: 14]
+message FilterChainMatch {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.listener.FilterChainMatch";
+
+  enum ConnectionSourceType {
+    // Any connection source matches.
+    ANY = 0;
+
+    // Match a connection originating from the same host.
+    SAME_IP_OR_LOOPBACK = 1;
+
+    // Match a connection originating from a different host.
+    EXTERNAL = 2;
+  }
+
+  reserved 1;
+
+  // Optional destination port to consider when use_original_dst is set on the
+  // listener in determining a filter chain match.
+  google.protobuf.UInt32Value destination_port = 8 [(validate.rules).uint32 = {lte: 65535 gte: 1}];
+
+  // If non-empty, an IP address and prefix length to match addresses when the
+  // listener is bound to 0.0.0.0/:: or when use_original_dst is specified.
+  repeated core.v3.CidrRange prefix_ranges = 3;
+
+  // If non-empty, an IP address and suffix length to match addresses when the
+  // listener is bound to 0.0.0.0/:: or when use_original_dst is specified.
+  // [#not-implemented-hide:]
+  string address_suffix = 4;
+
+  // [#not-implemented-hide:]
+  google.protobuf.UInt32Value suffix_len = 5;
+
+  // The criteria is satisfied if the directly connected source IP address of the downstream
+  // connection is contained in at least one of the specified subnets. If the parameter is not
+  // specified or the list is empty, the directly connected source IP address is ignored.
+  repeated core.v3.CidrRange direct_source_prefix_ranges = 13;
+
+  // Specifies the connection source IP match type. Can be any, local or external network.
+  ConnectionSourceType source_type = 12 [(validate.rules).enum = {defined_only: true}];
+
+  // The criteria is satisfied if the source IP address of the downstream
+  // connection is contained in at least one of the specified subnets. If the
+  // parameter is not specified or the list is empty, the source IP address is
+  // ignored.
+  repeated core.v3.CidrRange source_prefix_ranges = 6;
+
+  // The criteria is satisfied if the source port of the downstream connection
+  // is contained in at least one of the specified ports. If the parameter is
+  // not specified, the source port is ignored.
+  repeated uint32 source_ports = 7
+      [(validate.rules).repeated = {items {uint32 {lte: 65535 gte: 1}}}];
+
+  // If non-empty, a list of server names (e.g. SNI for TLS protocol) to consider when determining
+  // a filter chain match. Those values will be compared against the server names of a new
+  // connection, when detected by one of the listener filters.
+  //
+  // The server name will be matched against all wildcard domains, i.e. ``www.example.com``
+  // will be first matched against ``www.example.com``, then ``*.example.com``, then ``*.com``.
+  //
+  // Note that partial wildcards are not supported, and values like ``*w.example.com`` are invalid.
+  // The value ``*`` is also not supported, and ``server_names`` should be omitted instead.
+  //
+  // .. attention::
+  //
+  //   See the :ref:`FAQ entry <faq_how_to_setup_sni>` on how to configure SNI for more
+  //   information.
+  repeated string server_names = 11;
+
+  // If non-empty, a transport protocol to consider when determining a filter chain match.
+  // This value will be compared against the transport protocol of a new connection, when
+  // it's detected by one of the listener filters.
+  //
+  // Suggested values include:
+  //
+  // * ``raw_buffer`` - default, used when no transport protocol is detected,
+  // * ``tls`` - set by :ref:`envoy.filters.listener.tls_inspector <config_listener_filters_tls_inspector>`
+  //   when TLS protocol is detected.
+  string transport_protocol = 9;
+
+  // If non-empty, a list of application protocols (e.g. ALPN for TLS protocol) to consider when
+  // determining a filter chain match. Those values will be compared against the application
+  // protocols of a new connection, when detected by one of the listener filters.
+  //
+  // Suggested values include:
+  //
+  // * ``http/1.1`` - set by :ref:`envoy.filters.listener.tls_inspector
+  //   <config_listener_filters_tls_inspector>`,
+  // * ``h2`` - set by :ref:`envoy.filters.listener.tls_inspector <config_listener_filters_tls_inspector>`
+  //
+  // .. attention::
+  //
+  //   Currently, only :ref:`TLS Inspector <config_listener_filters_tls_inspector>` provides
+  //   application protocol detection based on the requested
+  //   `ALPN <https://en.wikipedia.org/wiki/Application-Layer_Protocol_Negotiation>`_ values.
+  //
+  //   However, the use of ALPN is pretty much limited to the HTTP/2 traffic on the Internet,
+  //   and matching on values other than ``h2`` is going to lead to a lot of false negatives,
+  //   unless all connecting clients are known to use ALPN.
+  repeated string application_protocols = 10;
+}
+
+// A filter chain wraps a set of match criteria, an option TLS context, a set of filters, and
+// various other parameters.
+// [#next-free-field: 10]
+message FilterChain {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.listener.FilterChain";
+
+  reserved 2, 8;
+
+  reserved "tls_context", "on_demand_configuration";
+
+  // The criteria to use when matching a connection to this filter chain.
+  FilterChainMatch filter_chain_match = 1;
+
+  // A list of individual network filters that make up the filter chain for
+  // connections established with the listener. Order matters as the filters are
+  // processed sequentially as connection events happen. Note: If the filter
+  // list is empty, the connection will close by default.
+  //
+  // For QUIC listeners, network filters other than HTTP Connection Manager (HCM)
+  // can be created, but due to differences in the connection implementation compared
+  // to TCP, the onData() method will never be called. Therefore, network filters
+  // for QUIC listeners should only expect to do work at the start of a new connection
+  // (i.e. in onNewConnection()). HCM must be the last (or only) filter in the chain.
+  repeated Filter filters = 3;
+
+  // Whether the listener should expect a PROXY protocol V1 header on new
+  // connections. If this option is enabled, the listener will assume that that
+  // remote address of the connection is the one specified in the header. Some
+  // load balancers including the AWS ELB support this option. If the option is
+  // absent or set to false, Envoy will use the physical peer address of the
+  // connection as the remote address.
+  //
+  // This field is deprecated. Add a
+  // :ref:`PROXY protocol listener filter <config_listener_filters_proxy_protocol>`
+  // explicitly instead.
+  google.protobuf.BoolValue use_proxy_proto = 4
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Filter chain metadata.
+  core.v3.Metadata metadata = 5;
+
+  // Optional custom transport socket implementation to use for downstream connections.
+  // To setup TLS, set a transport socket with name ``envoy.transport_sockets.tls`` and
+  // :ref:`DownstreamTlsContext <envoy_v3_api_msg_extensions.transport_sockets.tls.v3.DownstreamTlsContext>` in the ``typed_config``.
+  // If no transport socket configuration is specified, new connections
+  // will be set up with plaintext.
+  // [#extension-category: envoy.transport_sockets.downstream]
+  core.v3.TransportSocket transport_socket = 6;
+
+  // If present and nonzero, the amount of time to allow incoming connections to complete any
+  // transport socket negotiations. If this expires before the transport reports connection
+  // establishment, the connection is summarily closed.
+  google.protobuf.Duration transport_socket_connect_timeout = 9;
+
+  // The unique name (or empty) by which this filter chain is known.
+  // Note: :ref:`filter_chain_matcher
+  // <envoy_v3_api_field_config.listener.v3.Listener.filter_chain_matcher>`
+  // requires that filter chains are uniquely named within a listener.
+  string name = 7;
+}
+
+// Listener filter chain match configuration. This is a recursive structure which allows complex
+// nested match configurations to be built using various logical operators.
+//
+// Examples:
+//
+// * Matches if the destination port is 3306.
+//
+// .. code-block:: yaml
+//
+//  destination_port_range:
+//   start: 3306
+//   end: 3307
+//
+// * Matches if the destination port is 3306 or 15000.
+//
+// .. code-block:: yaml
+//
+//  or_match:
+//    rules:
+//      - destination_port_range:
+//          start: 3306
+//          end: 3307
+//      - destination_port_range:
+//          start: 15000
+//          end: 15001
+//
+// [#next-free-field: 6]
+message ListenerFilterChainMatchPredicate {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.listener.ListenerFilterChainMatchPredicate";
+
+  // A set of match configurations used for logical operations.
+  message MatchSet {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.listener.ListenerFilterChainMatchPredicate.MatchSet";
+
+    // The list of rules that make up the set.
+    repeated ListenerFilterChainMatchPredicate rules = 1
+        [(validate.rules).repeated = {min_items: 2}];
+  }
+
+  oneof rule {
+    option (validate.required) = true;
+
+    // A set that describes a logical OR. If any member of the set matches, the match configuration
+    // matches.
+    MatchSet or_match = 1;
+
+    // A set that describes a logical AND. If all members of the set match, the match configuration
+    // matches.
+    MatchSet and_match = 2;
+
+    // A negation match. The match configuration will match if the negated match condition matches.
+    ListenerFilterChainMatchPredicate not_match = 3;
+
+    // The match configuration will always match.
+    bool any_match = 4 [(validate.rules).bool = {const: true}];
+
+    // Match destination port. Particularly, the match evaluation must use the recovered local port if
+    // the owning listener filter is after :ref:`an original_dst listener filter <config_listener_filters_original_dst>`.
+    type.v3.Int32Range destination_port_range = 5;
+  }
+}
+
+// [#next-free-field: 6]
+message ListenerFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.listener.ListenerFilter";
+
+  reserved 2;
+
+  reserved "config";
+
+  // The name of the filter configuration.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  oneof config_type {
+    // Filter specific configuration which depends on the filter being
+    // instantiated. See the supported filters for further documentation.
+    // [#extension-category: envoy.filters.listener,envoy.filters.udp_listener]
+    google.protobuf.Any typed_config = 3;
+
+    // Configuration source specifier for an extension configuration discovery
+    // service. In case of a failure and without the default configuration, the
+    // listener closes the connections.
+    core.v3.ExtensionConfigSource config_discovery = 5;
+  }
+
+  // Optional match predicate used to disable the filter. The filter is enabled when this field is empty.
+  // See :ref:`ListenerFilterChainMatchPredicate <envoy_v3_api_msg_config.listener.v3.ListenerFilterChainMatchPredicate>`
+  // for further examples.
+  ListenerFilterChainMatchPredicate filter_disabled = 4;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/quic_config.proto b/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/quic_config.proto
new file mode 100644
index 00000000000..6c0a5bd201f
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/quic_config.proto
@@ -0,0 +1,102 @@
+syntax = "proto3";
+
+package envoy.config.listener.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/core/v3/protocol.proto";
+import "envoy/config/core/v3/socket_cmsg_headers.proto";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "xds/annotations/v3/status.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.listener.v3";
+option java_outer_classname = "QuicConfigProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/listener/v3;listenerv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: QUIC listener config]
+
+// Configuration specific to the UDP QUIC listener.
+// [#next-free-field: 14]
+message QuicProtocolOptions {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.listener.QuicProtocolOptions";
+
+  core.v3.QuicProtocolOptions quic_protocol_options = 1;
+
+  // Maximum number of milliseconds that connection will be alive when there is
+  // no network activity.
+  //
+  // If it is less than 1ms, Envoy will use 1ms. 300000ms if not specified.
+  google.protobuf.Duration idle_timeout = 2;
+
+  // Connection timeout in milliseconds before the crypto handshake is finished.
+  //
+  // If it is less than 5000ms, Envoy will use 5000ms. 20000ms if not specified.
+  google.protobuf.Duration crypto_handshake_timeout = 3;
+
+  // Runtime flag that controls whether the listener is enabled or not. If not specified, defaults
+  // to enabled.
+  core.v3.RuntimeFeatureFlag enabled = 4;
+
+  // A multiplier to number of connections which is used to determine how many packets to read per
+  // event loop. A reasonable number should allow the listener to process enough payload but not
+  // starve TCP and other UDP sockets and also prevent long event loop duration.
+  // The default value is 32. This means if there are N QUIC connections, the total number of
+  // packets to read in each read event will be 32 * N.
+  // The actual number of packets to read in total by the UDP listener is also
+  // bound by 6000, regardless of this field or how many connections there are.
+  google.protobuf.UInt32Value packets_to_read_to_connection_count_ratio = 5
+      [(validate.rules).uint32 = {gte: 1}];
+
+  // Configure which implementation of ``quic::QuicCryptoClientStreamBase`` to be used for this listener.
+  // If not specified the :ref:`QUICHE default one configured by <envoy_v3_api_msg_extensions.quic.crypto_stream.v3.CryptoServerStreamConfig>` will be used.
+  // [#extension-category: envoy.quic.server.crypto_stream]
+  core.v3.TypedExtensionConfig crypto_stream_config = 6;
+
+  // Configure which implementation of ``quic::ProofSource`` to be used for this listener.
+  // If not specified the :ref:`default one configured by <envoy_v3_api_msg_extensions.quic.proof_source.v3.ProofSourceConfig>` will be used.
+  // [#extension-category: envoy.quic.proof_source]
+  core.v3.TypedExtensionConfig proof_source_config = 7;
+
+  // Config which implementation of ``quic::ConnectionIdGeneratorInterface`` to be used for this listener.
+  // If not specified the :ref:`default one configured by <envoy_v3_api_msg_extensions.quic.connection_id_generator.v3.DeterministicConnectionIdGeneratorConfig>` will be used.
+  // [#extension-category: envoy.quic.connection_id_generator]
+  core.v3.TypedExtensionConfig connection_id_generator_config = 8;
+
+  // Configure the server's preferred address to advertise so that client can migrate to it. See :ref:`example <envoy_v3_api_msg_extensions.quic.server_preferred_address.v3.FixedServerPreferredAddressConfig>` which configures a pair of v4 and v6 preferred addresses.
+  // The current QUICHE implementation will advertise only one of the preferred IPv4 and IPv6 addresses based on the address family the client initially connects with.
+  // If not specified, Envoy will not advertise any server's preferred address.
+  // [#extension-category: envoy.quic.server_preferred_address]
+  core.v3.TypedExtensionConfig server_preferred_address_config = 9
+      [(xds.annotations.v3.field_status).work_in_progress = true];
+
+  // Configure the server to send transport parameter `disable_active_migration <https://www.rfc-editor.org/rfc/rfc9000#section-18.2-4.30.1>`_.
+  // Defaults to false (do not send this transport parameter).
+  google.protobuf.BoolValue send_disable_active_migration = 10;
+
+  // Configure which implementation of ``quic::QuicConnectionDebugVisitor`` to be used for this listener.
+  // If not specified, no debug visitor will be attached to connections.
+  // [#extension-category: envoy.quic.connection_debug_visitor]
+  core.v3.TypedExtensionConfig connection_debug_visitor_config = 11;
+
+  // Configure a type of UDP cmsg to pass to listener filters via QuicReceivedPacket.
+  // Both level and type must be specified for cmsg to be saved.
+  // Cmsg may be truncated or omitted if expected size is not set.
+  // If not specified, no cmsg will be saved to QuicReceivedPacket.
+  repeated core.v3.SocketCmsgHeaders save_cmsg_config = 12
+      [(validate.rules).repeated = {max_items: 1}];
+
+  // If true, the listener will reject connection-establishing packets at the
+  // QUIC layer by replying with an empty version negotiation packet to the
+  // client.
+  bool reject_new_connections = 13;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/udp_listener_config.proto b/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/udp_listener_config.proto
new file mode 100644
index 00000000000..4e619b1f760
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/listener/v3/udp_listener_config.proto
@@ -0,0 +1,52 @@
+syntax = "proto3";
+
+package envoy.config.listener.v3;
+
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/core/v3/udp_socket_config.proto";
+import "envoy/config/listener/v3/quic_config.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.config.listener.v3";
+option java_outer_classname = "UdpListenerConfigProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/listener/v3;listenerv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: UDP listener config]
+// Listener :ref:`configuration overview <config_listeners>`
+
+// [#next-free-field: 9]
+message UdpListenerConfig {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.listener.UdpListenerConfig";
+
+  reserved 1, 2, 3, 4, 6;
+
+  reserved "config";
+
+  // UDP socket configuration for the listener. The default for
+  // :ref:`prefer_gro <envoy_v3_api_field_config.core.v3.UdpSocketConfig.prefer_gro>` is false for
+  // listener sockets. If receiving a large amount of datagrams from a small number of sources, it
+  // may be worthwhile to enable this option after performance testing.
+  core.v3.UdpSocketConfig downstream_socket_config = 5;
+
+  // Configuration for QUIC protocol. If empty, QUIC will not be enabled on this listener. Set
+  // to the default object to enable QUIC without modifying any additional options.
+  QuicProtocolOptions quic_options = 7;
+
+  // Configuration for the UDP packet writer. If empty, HTTP/3 will use GSO if available
+  // (:ref:`UdpDefaultWriterFactory <envoy_v3_api_msg_extensions.udp_packet_writer.v3.UdpGsoBatchWriterFactory>`)
+  // or the default kernel sendmsg if not,
+  // (:ref:`UdpDefaultWriterFactory <envoy_v3_api_msg_extensions.udp_packet_writer.v3.UdpDefaultWriterFactory>`)
+  // and raw UDP will use kernel sendmsg.
+  // [#extension-category: envoy.udp_packet_writer]
+  core.v3.TypedExtensionConfig udp_packet_packet_writer_config = 8;
+}
+
+message ActiveRawUdpListenerConfig {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.listener.ActiveRawUdpListenerConfig";
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/metrics/v3/stats.proto b/xds/third_party/envoy/src/main/proto/envoy/config/metrics/v3/stats.proto
new file mode 100644
index 00000000000..02bb23aec9d
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/metrics/v3/stats.proto
@@ -0,0 +1,416 @@
+syntax = "proto3";
+
+package envoy.config.metrics.v3;
+
+import "envoy/config/core/v3/address.proto";
+import "envoy/type/matcher/v3/string.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.metrics.v3";
+option java_outer_classname = "StatsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/metrics/v3;metricsv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Stats]
+// Statistics :ref:`architecture overview <arch_overview_statistics>`.
+
+// Configuration for pluggable stats sinks.
+message StatsSink {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.config.metrics.v2.StatsSink";
+
+  reserved 2;
+
+  reserved "config";
+
+  // The name of the stats sink to instantiate. The name must match a supported
+  // stats sink.
+  // See the :ref:`extensions listed in typed_config below <extension_category_envoy.stats_sinks>` for the default list of available stats sink.
+  // Sinks optionally support tagged/multiple dimensional metrics.
+  string name = 1;
+
+  // Stats sink specific configuration which depends on the sink being instantiated. See
+  // :ref:`StatsdSink <envoy_v3_api_msg_config.metrics.v3.StatsdSink>` for an example.
+  // [#extension-category: envoy.stats_sinks]
+  oneof config_type {
+    google.protobuf.Any typed_config = 3;
+  }
+}
+
+// Statistics configuration such as tagging.
+message StatsConfig {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.metrics.v2.StatsConfig";
+
+  // Each stat name is independently processed through these tag specifiers. When a tag is
+  // matched, the first capture group is not immediately removed from the name, so later
+  // :ref:`TagSpecifiers <envoy_v3_api_msg_config.metrics.v3.TagSpecifier>` can also match that
+  // same portion of the match. After all tag matching is complete, a tag-extracted version of
+  // the name is produced and is used in stats sinks that represent tags, such as Prometheus.
+  repeated TagSpecifier stats_tags = 1;
+
+  // Use all default tag regexes specified in Envoy. These can be combined with
+  // custom tags specified in :ref:`stats_tags
+  // <envoy_v3_api_field_config.metrics.v3.StatsConfig.stats_tags>`. They will be processed before
+  // the custom tags.
+  //
+  // .. note::
+  //
+  //   If any default tags are specified twice, the config will be considered
+  //   invalid.
+  //
+  // See :repo:`well_known_names.h <source/common/config/well_known_names.h>` for a list of the
+  // default tags in Envoy.
+  //
+  // If not provided, the value is assumed to be true.
+  google.protobuf.BoolValue use_all_default_tags = 2;
+
+  // Inclusion/exclusion matcher for stat name creation. If not provided, all stats are instantiated
+  // as normal. Preventing the instantiation of certain families of stats can improve memory
+  // performance for Envoys running especially large configs.
+  //
+  // .. warning::
+  //   Excluding stats may affect Envoy's behavior in undocumented ways. See
+  //   `issue #8771 <https://github.com/envoyproxy/envoy/issues/8771>`_ for more information.
+  //   If any unexpected behavior changes are observed, please open a new issue immediately.
+  StatsMatcher stats_matcher = 3;
+
+  // Defines rules for setting the histogram buckets. Rules are evaluated in order, and the first
+  // match is applied. If no match is found (or if no rules are set), the following default buckets
+  // are used:
+  //
+  //   .. code-block:: json
+  //
+  //     [
+  //       0.5,
+  //       1,
+  //       5,
+  //       10,
+  //       25,
+  //       50,
+  //       100,
+  //       250,
+  //       500,
+  //       1000,
+  //       2500,
+  //       5000,
+  //       10000,
+  //       30000,
+  //       60000,
+  //       300000,
+  //       600000,
+  //       1800000,
+  //       3600000
+  //     ]
+  repeated HistogramBucketSettings histogram_bucket_settings = 4;
+}
+
+// Configuration for disabling stat instantiation.
+message StatsMatcher {
+  // The instantiation of stats is unrestricted by default. If the goal is to configure Envoy to
+  // instantiate all stats, there is no need to construct a StatsMatcher.
+  //
+  // However, StatsMatcher can be used to limit the creation of families of stats in order to
+  // conserve memory. Stats can either be disabled entirely, or they can be
+  // limited by either an exclusion or an inclusion list of :ref:`StringMatcher
+  // <envoy_v3_api_msg_type.matcher.v3.StringMatcher>` protos:
+  //
+  // * If ``reject_all`` is set to ``true``, no stats will be instantiated. If ``reject_all`` is set to
+  //   ``false``, all stats will be instantiated.
+  //
+  // * If an exclusion list is supplied, any stat name matching *any* of the StringMatchers in the
+  //   list will not instantiate.
+  //
+  // * If an inclusion list is supplied, no stats will instantiate, except those matching *any* of
+  //   the StringMatchers in the list.
+  //
+  //
+  // A StringMatcher can be used to match against an exact string, a suffix / prefix, or a regex.
+  // **NB:** For performance reasons, it is highly recommended to use a prefix- or suffix-based
+  // matcher rather than a regex-based matcher.
+  //
+  // Example 1. Excluding all stats.
+  //
+  // .. code-block:: json
+  //
+  //   {
+  //     "statsMatcher": {
+  //       "rejectAll": "true"
+  //     }
+  //   }
+  //
+  // Example 2. Excluding all cluster-specific stats, but not cluster-manager stats:
+  //
+  // .. code-block:: json
+  //
+  //   {
+  //     "statsMatcher": {
+  //       "exclusionList": {
+  //         "patterns": [
+  //           {
+  //             "prefix": "cluster."
+  //           }
+  //         ]
+  //       }
+  //     }
+  //   }
+  //
+  // Example 3. Including only manager-related stats:
+  //
+  // .. code-block:: json
+  //
+  //   {
+  //     "statsMatcher": {
+  //       "inclusionList": {
+  //         "patterns": [
+  //           {
+  //             "prefix": "cluster_manager."
+  //           },
+  //           {
+  //             "prefix": "listener_manager."
+  //           }
+  //         ]
+  //       }
+  //     }
+  //   }
+  //
+
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.metrics.v2.StatsMatcher";
+
+  oneof stats_matcher {
+    option (validate.required) = true;
+
+    // If ``reject_all`` is true, then all stats are disabled. If ``reject_all`` is false, then all
+    // stats are enabled.
+    bool reject_all = 1;
+
+    // Exclusive match. All stats are enabled except for those matching one of the supplied
+    // StringMatcher protos.
+    type.matcher.v3.ListStringMatcher exclusion_list = 2;
+
+    // Inclusive match. No stats are enabled except for those matching one of the supplied
+    // StringMatcher protos.
+    type.matcher.v3.ListStringMatcher inclusion_list = 3;
+  }
+}
+
+// Designates a tag name and value pair. The value may be either a fixed value
+// or a regex providing the value via capture groups. The specified tag will be
+// unconditionally set if a fixed value, otherwise it will only be set if one
+// or more capture groups in the regex match.
+message TagSpecifier {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.metrics.v2.TagSpecifier";
+
+  // Attaches an identifier to the tag values to identify the tag being in the
+  // sink. Envoy has a set of default names and regexes to extract dynamic
+  // portions of existing stats, which can be found in :repo:`well_known_names.h
+  // <source/common/config/well_known_names.h>` in the Envoy repository. If a :ref:`tag_name
+  // <envoy_v3_api_field_config.metrics.v3.TagSpecifier.tag_name>` is provided in the config and
+  // neither :ref:`regex <envoy_v3_api_field_config.metrics.v3.TagSpecifier.regex>` or
+  // :ref:`fixed_value <envoy_v3_api_field_config.metrics.v3.TagSpecifier.fixed_value>` were specified,
+  // Envoy will attempt to find that name in its set of defaults and use the accompanying regex.
+  //
+  // .. note::
+  //
+  //   A stat name may be spelled in such a way that it matches two different
+  //   tag extractors for the same tag name. In that case, all but one of the
+  //   tag values will be dropped. It is not specified which tag value will be
+  //   retained. The extraction will only occur for one of the extractors, and
+  //   only the matched extraction will be removed from the tag name.
+  string tag_name = 1;
+
+  oneof tag_value {
+    // Designates a tag to strip from the tag extracted name and provide as a named
+    // tag value for all statistics. This will only occur if any part of the name
+    // matches the regex provided with one or more capture groups.
+    //
+    // The first capture group identifies the portion of the name to remove. The
+    // second capture group (which will normally be nested inside the first) will
+    // designate the value of the tag for the statistic. If no second capture
+    // group is provided, the first will also be used to set the value of the tag.
+    // All other capture groups will be ignored.
+    //
+    // Example 1. a stat name ``cluster.foo_cluster.upstream_rq_timeout`` and
+    // one tag specifier:
+    //
+    // .. code-block:: json
+    //
+    //   {
+    //     "tag_name": "envoy.cluster_name",
+    //     "regex": "^cluster\\.((.+?)\\.)"
+    //   }
+    //
+    // Note that the regex will remove ``foo_cluster.`` making the tag extracted
+    // name ``cluster.upstream_rq_timeout`` and the tag value for
+    // ``envoy.cluster_name`` will be ``foo_cluster`` (note: there will be no
+    // ``.`` character because of the second capture group).
+    //
+    // Example 2. a stat name
+    // ``http.connection_manager_1.user_agent.ios.downstream_cx_total`` and two
+    // tag specifiers:
+    //
+    // .. code-block:: json
+    //
+    //   [
+    //     {
+    //       "tag_name": "envoy.http_user_agent",
+    //       "regex": "^http(?=\\.).*?\\.user_agent\\.((.+?)\\.)\\w+?$"
+    //     },
+    //     {
+    //       "tag_name": "envoy.http_conn_manager_prefix",
+    //       "regex": "^http\\.((.*?)\\.)"
+    //     }
+    //   ]
+    //
+    // The two regexes of the specifiers will be processed from the elaborated
+    // stat name.
+    //
+    // The first regex will save ``ios.`` as the tag value for ``envoy.http_user_agent``. It will
+    // leave it in the name for potential matching with additional tag specifiers. After all tag
+    // specifiers are processed the tags will be removed from the name.
+    //
+    // The second regex will populate tag ``envoy.http_conn_manager_prefix`` with value
+    // ``connection_manager_1.``, based on the original stat name.
+    //
+    // As a final step, the matched tags are removed, leaving
+    // ``http.user_agent.downstream_cx_total`` as the tag extracted name.
+    string regex = 2 [(validate.rules).string = {max_bytes: 1024}];
+
+    // Specifies a fixed tag value for the ``tag_name``.
+    string fixed_value = 3;
+  }
+}
+
+// Specifies a matcher for stats and the buckets that matching stats should use.
+message HistogramBucketSettings {
+  // The stats that this rule applies to. The match is applied to the original stat name
+  // before tag-extraction, for example ``cluster.exampleclustername.upstream_cx_length_ms``.
+  type.matcher.v3.StringMatcher match = 1 [(validate.rules).message = {required: true}];
+
+  // Each value is the upper bound of a bucket. Each bucket must be greater than 0 and unique.
+  // The order of the buckets does not matter.
+  repeated double buckets = 2 [(validate.rules).repeated = {
+    unique: true
+    items {double {gt: 0.0}}
+  }];
+
+  // Initial number of bins for the ``circllhist`` thread local histogram per time series. Default value is 100.
+  google.protobuf.UInt32Value bins = 3 [(validate.rules).uint32 = {lte: 46082 gt: 0}];
+}
+
+// Stats configuration proto schema for built-in ``envoy.stat_sinks.statsd`` sink. This sink does not support
+// tagged metrics.
+// [#extension: envoy.stat_sinks.statsd]
+message StatsdSink {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.config.metrics.v2.StatsdSink";
+
+  oneof statsd_specifier {
+    option (validate.required) = true;
+
+    // The UDP address of a running `statsd <https://github.com/etsy/statsd>`_
+    // compliant listener. If specified, statistics will be flushed to this
+    // address.
+    core.v3.Address address = 1;
+
+    // The name of a cluster that is running a TCP `statsd
+    // <https://github.com/etsy/statsd>`_ compliant listener. If specified,
+    // Envoy will connect to this cluster to flush statistics.
+    string tcp_cluster_name = 2;
+  }
+
+  // Optional custom prefix for StatsdSink. If
+  // specified, this will override the default prefix.
+  // For example:
+  //
+  // .. code-block:: json
+  //
+  //   {
+  //     "prefix" : "envoy-prod"
+  //   }
+  //
+  // will change emitted stats to
+  //
+  // .. code-block:: cpp
+  //
+  //   envoy-prod.test_counter:1|c
+  //   envoy-prod.test_timer:5|ms
+  //
+  // Note that the default prefix, "envoy", will be used if a prefix is not
+  // specified.
+  //
+  // Stats with default prefix:
+  //
+  // .. code-block:: cpp
+  //
+  //   envoy.test_counter:1|c
+  //   envoy.test_timer:5|ms
+  string prefix = 3;
+}
+
+// Stats configuration proto schema for built-in ``envoy.stat_sinks.dog_statsd`` sink.
+// The sink emits stats with `DogStatsD <https://docs.datadoghq.com/guides/dogstatsd/>`_
+// compatible tags. Tags are configurable via :ref:`StatsConfig
+// <envoy_v3_api_msg_config.metrics.v3.StatsConfig>`.
+// [#extension: envoy.stat_sinks.dog_statsd]
+message DogStatsdSink {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.metrics.v2.DogStatsdSink";
+
+  reserved 2;
+
+  oneof dog_statsd_specifier {
+    option (validate.required) = true;
+
+    // The UDP address of a running DogStatsD compliant listener. If specified,
+    // statistics will be flushed to this address.
+    core.v3.Address address = 1;
+  }
+
+  // Optional custom metric name prefix. See :ref:`StatsdSink's prefix field
+  // <envoy_v3_api_field_config.metrics.v3.StatsdSink.prefix>` for more details.
+  string prefix = 3;
+
+  // Optional max datagram size to use when sending UDP messages. By default Envoy
+  // will emit one metric per datagram. By specifying a max-size larger than a single
+  // metric, Envoy will emit multiple, new-line separated metrics. The max datagram
+  // size should not exceed your network's MTU.
+  //
+  // Note that this value may not be respected if smaller than a single metric.
+  google.protobuf.UInt64Value max_bytes_per_datagram = 4 [(validate.rules).uint64 = {gt: 0}];
+}
+
+// Stats configuration proto schema for built-in ``envoy.stat_sinks.hystrix`` sink.
+// The sink emits stats in `text/event-stream
+// <https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events>`_
+// formatted stream for use by `Hystrix dashboard
+// <https://github.com/Netflix-Skunkworks/hystrix-dashboard/wiki>`_.
+//
+// Note that only a single HystrixSink should be configured.
+//
+// Streaming is started through an admin endpoint :http:get:`/hystrix_event_stream`.
+// [#extension: envoy.stat_sinks.hystrix]
+message HystrixSink {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.metrics.v2.HystrixSink";
+
+  // The number of buckets the rolling statistical window is divided into.
+  //
+  // Each time the sink is flushed, all relevant Envoy statistics are sampled and
+  // added to the rolling window (removing the oldest samples in the window
+  // in the process). The sink then outputs the aggregate statistics across the
+  // current rolling window to the event stream(s).
+  //
+  // ``rolling_window(ms)`` = ``stats_flush_interval(ms)`` * ``num_of_buckets``
+  //
+  // More detailed explanation can be found in `Hystrix wiki
+  // <https://github.com/Netflix/Hystrix/wiki/Metrics-and-Monitoring#hystrixrollingnumber>`_.
+  int64 num_buckets = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/overload/v3/overload.proto b/xds/third_party/envoy/src/main/proto/envoy/config/overload/v3/overload.proto
new file mode 100644
index 00000000000..b5bc2c4d830
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/overload/v3/overload.proto
@@ -0,0 +1,227 @@
+syntax = "proto3";
+
+package envoy.config.overload.v3;
+
+import "envoy/type/v3/percent.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/duration.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.overload.v3";
+option java_outer_classname = "OverloadProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/overload/v3;overloadv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Overload Manager]
+
+// The Overload Manager provides an extensible framework to protect Envoy instances
+// from overload of various resources (memory, cpu, file descriptors, etc).
+// It monitors a configurable set of resources and notifies registered listeners
+// when triggers related to those resources fire.
+
+message ResourceMonitor {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.overload.v2alpha.ResourceMonitor";
+
+  reserved 2;
+
+  reserved "config";
+
+  // The name of the resource monitor to instantiate. Must match a registered
+  // resource monitor type.
+  // See the :ref:`extensions listed in typed_config below <extension_category_envoy.resource_monitors>` for the default list of available resource monitor.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // Configuration for the resource monitor being instantiated.
+  // [#extension-category: envoy.resource_monitors]
+  oneof config_type {
+    google.protobuf.Any typed_config = 3;
+  }
+}
+
+message ThresholdTrigger {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.overload.v2alpha.ThresholdTrigger";
+
+  // If the resource pressure is greater than or equal to this value, the trigger
+  // will enter saturation.
+  double value = 1 [(validate.rules).double = {lte: 1.0 gte: 0.0}];
+}
+
+message ScaledTrigger {
+  // If the resource pressure is greater than this value, the trigger will be in the
+  // :ref:`scaling <arch_overview_overload_manager-triggers-state>` state with value
+  // ``(pressure - scaling_threshold) / (saturation_threshold - scaling_threshold)``.
+  double scaling_threshold = 1 [(validate.rules).double = {lte: 1.0 gte: 0.0}];
+
+  // If the resource pressure is greater than this value, the trigger will enter saturation.
+  double saturation_threshold = 2 [(validate.rules).double = {lte: 1.0 gte: 0.0}];
+}
+
+message Trigger {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.overload.v2alpha.Trigger";
+
+  // The name of the resource this is a trigger for.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  oneof trigger_oneof {
+    option (validate.required) = true;
+
+    ThresholdTrigger threshold = 2;
+
+    ScaledTrigger scaled = 3;
+  }
+}
+
+// Typed configuration for the "envoy.overload_actions.reduce_timeouts" action. See
+// :ref:`the docs <config_overload_manager_reducing_timeouts>` for an example of how to configure
+// the action with different timeouts and minimum values.
+message ScaleTimersOverloadActionConfig {
+  enum TimerType {
+    // Unsupported value; users must explicitly specify the timer they want scaled.
+    UNSPECIFIED = 0;
+
+    // Adjusts the idle timer for downstream HTTP connections that takes effect when there are no active streams.
+    // This affects the value of :ref:`HttpConnectionManager.common_http_protocol_options.idle_timeout
+    // <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.idle_timeout>`
+    HTTP_DOWNSTREAM_CONNECTION_IDLE = 1;
+
+    // Adjusts the idle timer for HTTP streams initiated by downstream clients.
+    // This affects the value of :ref:`RouteAction.idle_timeout <envoy_v3_api_field_config.route.v3.RouteAction.idle_timeout>` and
+    // :ref:`HttpConnectionManager.stream_idle_timeout
+    // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_idle_timeout>`
+    HTTP_DOWNSTREAM_STREAM_IDLE = 2;
+
+    // Adjusts the timer for how long downstream clients have to finish transport-level negotiations
+    // before the connection is closed.
+    // This affects the value of
+    // :ref:`FilterChain.transport_socket_connect_timeout <envoy_v3_api_field_config.listener.v3.FilterChain.transport_socket_connect_timeout>`.
+    TRANSPORT_SOCKET_CONNECT = 3;
+
+    // Adjusts the max connection duration timer for downstream HTTP connections.
+    // This affects the value of
+    // :ref:`HttpConnectionManager.common_http_protocol_options.max_connection_duration
+    // <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_connection_duration>`.
+    HTTP_DOWNSTREAM_CONNECTION_MAX = 4;
+
+    // Adjusts the timeout for the downstream codec to flush an ended stream.
+    // This affects the value of :ref:`RouteAction.flush_timeout
+    // <envoy_v3_api_field_config.route.v3.RouteAction.flush_timeout>` and
+    // :ref:`HttpConnectionManager.stream_flush_timeout
+    // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_flush_timeout>`
+    HTTP_DOWNSTREAM_STREAM_FLUSH = 5;
+  }
+
+  message ScaleTimer {
+    // The type of timer this minimum applies to.
+    TimerType timer = 1 [(validate.rules).enum = {defined_only: true not_in: 0}];
+
+    oneof overload_adjust {
+      option (validate.required) = true;
+
+      // Sets the minimum duration as an absolute value.
+      google.protobuf.Duration min_timeout = 2;
+
+      // Sets the minimum duration as a percentage of the maximum value.
+      type.v3.Percent min_scale = 3;
+    }
+  }
+
+  // A set of timer scaling rules to be applied.
+  repeated ScaleTimer timer_scale_factors = 1 [(validate.rules).repeated = {min_items: 1}];
+}
+
+message OverloadAction {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.overload.v2alpha.OverloadAction";
+
+  // The name of the overload action. This is just a well-known string that
+  // listeners can use for registering callbacks.
+  // Valid known overload actions include:
+  // - envoy.overload_actions.stop_accepting_requests
+  // - envoy.overload_actions.disable_http_keepalive
+  // - envoy.overload_actions.stop_accepting_connections
+  // - envoy.overload_actions.reject_incoming_connections
+  // - envoy.overload_actions.shrink_heap
+  // - envoy.overload_actions.reduce_timeouts
+  // - envoy.overload_actions.reset_high_memory_stream
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // A set of triggers for this action. The state of the action is the maximum
+  // state of all triggers, which can be scalar values between 0 and 1 or
+  // saturated. Listeners are notified when the overload action changes state.
+  // An overload manager action can only have one trigger for a given resource
+  // e.g. :ref:`Trigger.name
+  // <envoy_v3_api_field_config.overload.v3.Trigger.name>` must be unique
+  // in this list.
+  repeated Trigger triggers = 2 [(validate.rules).repeated = {min_items: 1}];
+
+  // Configuration for the action being instantiated if applicable.
+  google.protobuf.Any typed_config = 3;
+}
+
+// A point within the connection or request lifecycle that provides context on
+// whether to shed load at that given stage for the current entity at the
+// point.
+message LoadShedPoint {
+  // This is just a well-known string for the LoadShedPoint.
+  // Deployment specific LoadShedPoints e.g. within a custom extension should
+  // be prefixed by the company / deployment name to avoid colliding with any
+  // open source LoadShedPoints.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // A set of triggers for this LoadShedPoint. The LoadShedPoint will use the
+  // the maximum state of all triggers, which can be scalar values between 0 and
+  // 1 or saturated. A LoadShedPoint can only have one trigger for a given
+  // resource e.g. :ref:`Trigger.name
+  // <envoy_v3_api_field_config.overload.v3.Trigger.name>` must be unique in
+  // this list.
+  repeated Trigger triggers = 2 [(validate.rules).repeated = {min_items: 1}];
+}
+
+// Configuration for which accounts the WatermarkBuffer Factories should
+// track.
+message BufferFactoryConfig {
+  // The minimum power of two at which Envoy starts tracking an account.
+  //
+  // Envoy has 8 power of two buckets starting with the provided exponent below.
+  // Concretely the 1st bucket contains accounts for streams that use
+  // [2^minimum_account_to_track_power_of_two,
+  // 2^(minimum_account_to_track_power_of_two + 1)) bytes.
+  // With the 8th bucket tracking accounts
+  // >= 128 * 2^minimum_account_to_track_power_of_two.
+  //
+  // The maximum value is 56, since we're using uint64_t for bytes counting,
+  // and that's the last value that would use the 8 buckets. In practice,
+  // we don't expect the proxy to be holding 2^56 bytes.
+  //
+  // If omitted, Envoy should not do any tracking.
+  uint32 minimum_account_to_track_power_of_two = 1 [(validate.rules).uint32 = {lte: 56 gte: 10}];
+}
+
+// [#next-free-field: 6]
+message OverloadManager {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.overload.v2alpha.OverloadManager";
+
+  // The interval for refreshing resource usage.
+  google.protobuf.Duration refresh_interval = 1;
+
+  // The set of resources to monitor.
+  repeated ResourceMonitor resource_monitors = 2 [(validate.rules).repeated = {min_items: 1}];
+
+  // The set of overload actions.
+  repeated OverloadAction actions = 3;
+
+  // The set of load shed points.
+  repeated LoadShedPoint loadshed_points = 5;
+
+  // Configuration for buffer factory.
+  BufferFactoryConfig buffer_factory_config = 4;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/rbac/v3/rbac.proto b/xds/third_party/envoy/src/main/proto/envoy/config/rbac/v3/rbac.proto
new file mode 100644
index 00000000000..cdb1267a2c9
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/rbac/v3/rbac.proto
@@ -0,0 +1,462 @@
+syntax = "proto3";
+
+package envoy.config.rbac.v3;
+
+import "envoy/config/core/v3/address.proto";
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/route/v3/route_components.proto";
+import "envoy/type/matcher/v3/filter_state.proto";
+import "envoy/type/matcher/v3/metadata.proto";
+import "envoy/type/matcher/v3/path.proto";
+import "envoy/type/matcher/v3/string.proto";
+import "envoy/type/v3/range.proto";
+
+import "google/api/expr/v1alpha1/checked.proto";
+import "google/api/expr/v1alpha1/syntax.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.rbac.v3";
+option java_outer_classname = "RbacProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/rbac/v3;rbacv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Role Based Access Control (RBAC)]
+
+enum MetadataSource {
+  // Query :ref:`dynamic metadata <well_known_dynamic_metadata>`
+  DYNAMIC = 0;
+
+  // Query :ref:`route metadata <envoy_v3_api_field_config.route.v3.Route.metadata>`
+  ROUTE = 1;
+}
+
+// Role Based Access Control (RBAC) provides service-level and method-level access control for a
+// service. Requests are allowed or denied based on the ``action`` and whether a matching policy is
+// found. For instance, if the action is ALLOW and a matching policy is found the request should be
+// allowed.
+//
+// RBAC can also be used to make access logging decisions by communicating with access loggers
+// through dynamic metadata. When the action is LOG and at least one policy matches, the
+// ``access_log_hint`` value in the shared key namespace 'envoy.common' is set to ``true`` indicating
+// the request should be logged.
+//
+// Here is an example of RBAC configuration. It has two policies:
+//
+// * Service account ``cluster.local/ns/default/sa/admin`` has full access to the service, and so
+//   does "cluster.local/ns/default/sa/superuser".
+//
+// * Any user can read (``GET``) the service at paths with prefix ``/products``, so long as the
+//   destination port is either 80 or 443.
+//
+//  .. code-block:: yaml
+//
+//   action: ALLOW
+//   policies:
+//     "service-admin":
+//       permissions:
+//         - any: true
+//       principals:
+//         - authenticated:
+//             principal_name:
+//               exact: "cluster.local/ns/default/sa/admin"
+//         - authenticated:
+//             principal_name:
+//               exact: "cluster.local/ns/default/sa/superuser"
+//     "product-viewer":
+//       permissions:
+//           - and_rules:
+//               rules:
+//                 - header:
+//                     name: ":method"
+//                     string_match:
+//                       exact: "GET"
+//                 - url_path:
+//                     path: { prefix: "/products" }
+//                 - or_rules:
+//                     rules:
+//                       - destination_port: 80
+//                       - destination_port: 443
+//       principals:
+//         - any: true
+//
+message RBAC {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.config.rbac.v2.RBAC";
+
+  // Should we do safe-list or block-list style access control?
+  enum Action {
+    // The policies grant access to principals. The rest are denied. This is safe-list style
+    // access control. This is the default type.
+    ALLOW = 0;
+
+    // The policies deny access to principals. The rest are allowed. This is block-list style
+    // access control.
+    DENY = 1;
+
+    // The policies set the ``access_log_hint`` dynamic metadata key based on if requests match.
+    // All requests are allowed.
+    LOG = 2;
+  }
+
+  message AuditLoggingOptions {
+    // Deny and allow here refer to RBAC decisions, not actions.
+    enum AuditCondition {
+      // Never audit.
+      NONE = 0;
+
+      // Audit when RBAC denies the request.
+      ON_DENY = 1;
+
+      // Audit when RBAC allows the request.
+      ON_ALLOW = 2;
+
+      // Audit whether RBAC allows or denies the request.
+      ON_DENY_AND_ALLOW = 3;
+    }
+
+    // [#not-implemented-hide:]
+    message AuditLoggerConfig {
+      // Typed logger configuration.
+      //
+      // [#extension-category: envoy.rbac.audit_loggers]
+      core.v3.TypedExtensionConfig audit_logger = 1;
+
+      // If true, when the logger is not supported, the data plane will not NACK but simply ignore it.
+      bool is_optional = 2;
+    }
+
+    // Condition for the audit logging to happen.
+    // If this condition is met, all the audit loggers configured here will be invoked.
+    //
+    // [#not-implemented-hide:]
+    AuditCondition audit_condition = 1 [(validate.rules).enum = {defined_only: true}];
+
+    // Configurations for RBAC-based authorization audit loggers.
+    //
+    // [#not-implemented-hide:]
+    repeated AuditLoggerConfig logger_configs = 2;
+  }
+
+  // The action to take if a policy matches. Every action either allows or denies a request,
+  // and can also carry out action-specific operations.
+  //
+  // Actions:
+  //
+  //  * ``ALLOW``: Allows the request if and only if there is a policy that matches
+  //    the request.
+  //  * ``DENY``: Allows the request if and only if there are no policies that
+  //    match the request.
+  //  * ``LOG``: Allows all requests. If at least one policy matches, the dynamic
+  //    metadata key ``access_log_hint`` is set to the value ``true`` under the shared
+  //    key namespace ``envoy.common``. If no policies match, it is set to ``false``.
+  //    Other actions do not modify this key.
+  //
+  Action action = 1 [(validate.rules).enum = {defined_only: true}];
+
+  // Maps from policy name to policy. A match occurs when at least one policy matches the request.
+  // The policies are evaluated in lexicographic order of the policy name.
+  map<string, Policy> policies = 2;
+
+  // Audit logging options that include the condition for audit logging to happen
+  // and audit logger configurations.
+  //
+  // [#not-implemented-hide:]
+  AuditLoggingOptions audit_logging_options = 3;
+}
+
+// Policy specifies a role and the principals that are assigned/denied the role.
+// A policy matches if and only if at least one of its permissions match the
+// action taking place AND at least one of its principals match the downstream
+// AND the condition is true if specified.
+message Policy {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.config.rbac.v2.Policy";
+
+  // Required. The set of permissions that define a role. Each permission is
+  // matched with OR semantics. To match all actions for this policy, a single
+  // Permission with the ``any`` field set to true should be used.
+  repeated Permission permissions = 1 [(validate.rules).repeated = {min_items: 1}];
+
+  // Required. The set of principals that are assigned/denied the role based on
+  // “action”. Each principal is matched with OR semantics. To match all
+  // downstreams for this policy, a single Principal with the ``any`` field set to
+  // true should be used.
+  repeated Principal principals = 2 [(validate.rules).repeated = {min_items: 1}];
+
+  // An optional symbolic expression specifying an access control
+  // :ref:`condition <arch_overview_condition>`. The condition is combined
+  // with the permissions and the principals as a clause with AND semantics.
+  // Only be used when checked_condition is not used.
+  google.api.expr.v1alpha1.Expr condition = 3
+      [(udpa.annotations.field_migrate).oneof_promotion = "expression_specifier"];
+
+  // [#not-implemented-hide:]
+  // An optional symbolic expression that has been successfully type checked.
+  // Only be used when condition is not used.
+  google.api.expr.v1alpha1.CheckedExpr checked_condition = 4
+      [(udpa.annotations.field_migrate).oneof_promotion = "expression_specifier"];
+}
+
+// SourcedMetadata enables matching against metadata from different sources in the request processing
+// pipeline. It extends the base MetadataMatcher functionality by allowing specification of where the
+// metadata should be sourced from, rather than only matching against dynamic metadata.
+//
+// The matcher can be configured to look up metadata from:
+//
+// * Dynamic metadata: Runtime metadata added by filters during request processing
+// * Route metadata: Static metadata configured on the route entry
+//
+message SourcedMetadata {
+  // Metadata matcher configuration that defines what metadata to match against. This includes the filter name,
+  // metadata key path, and expected value.
+  type.matcher.v3.MetadataMatcher metadata_matcher = 1
+      [(validate.rules).message = {required: true}];
+
+  // Specifies which metadata source should be used for matching. If not set,
+  // defaults to DYNAMIC (dynamic metadata). Set to ROUTE to match against
+  // static metadata configured on the route entry.
+  MetadataSource metadata_source = 2 [(validate.rules).enum = {defined_only: true}];
+}
+
+// Permission defines an action (or actions) that a principal can take.
+// [#next-free-field: 15]
+message Permission {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.config.rbac.v2.Permission";
+
+  // Used in the ``and_rules`` and ``or_rules`` fields in the ``rule`` oneof. Depending on the context,
+  // each are applied with the associated behavior.
+  message Set {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.rbac.v2.Permission.Set";
+
+    repeated Permission rules = 1 [(validate.rules).repeated = {min_items: 1}];
+  }
+
+  oneof rule {
+    option (validate.required) = true;
+
+    // A set of rules that all must match in order to define the action.
+    Set and_rules = 1;
+
+    // A set of rules where at least one must match in order to define the action.
+    Set or_rules = 2;
+
+    // When any is set, it matches any action.
+    bool any = 3 [(validate.rules).bool = {const: true}];
+
+    // A header (or pseudo-header such as ``:path`` or ``:method``) on the incoming HTTP request. Only available
+    // for HTTP request.
+    //
+    // .. note::
+    //
+    //   The pseudo-header ``:path`` includes the query and fragment string. Use the ``url_path`` field if you
+    //   want to match the URL path without the query and fragment string.
+    //
+    route.v3.HeaderMatcher header = 4;
+
+    // A URL path on the incoming HTTP request. Only available for HTTP.
+    type.matcher.v3.PathMatcher url_path = 10;
+
+    // A CIDR block that describes the destination IP.
+    core.v3.CidrRange destination_ip = 5;
+
+    // A port number that describes the destination port connecting to.
+    uint32 destination_port = 6 [(validate.rules).uint32 = {lte: 65535}];
+
+    // A port number range that describes a range of destination ports connecting to.
+    type.v3.Int32Range destination_port_range = 11;
+
+    // Metadata that describes additional information about the action. This field is deprecated; please use
+    // :ref:`sourced_metadata<envoy_v3_api_field_config.rbac.v3.Permission.sourced_metadata>` instead.
+    type.matcher.v3.MetadataMatcher metadata = 7
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+    // Negates matching the provided permission. For instance, if the value of
+    // ``not_rule`` would match, this permission would not match. Conversely, if
+    // the value of ``not_rule`` would not match, this permission would match.
+    Permission not_rule = 8;
+
+    // The request server from the client's connection request. This is typically TLS SNI.
+    //
+    // .. attention::
+    //
+    //   The behavior of this field may be affected by how Envoy is configured
+    //   as explained below.
+    //
+    //   * If the :ref:`TLS Inspector <config_listener_filters_tls_inspector>`
+    //     filter is not added, and if a ``FilterChainMatch`` is not defined for
+    //     the :ref:`server name
+    //     <envoy_v3_api_field_config.listener.v3.FilterChainMatch.server_names>`,
+    //     a TLS connection's requested SNI server name will be treated as if it
+    //     wasn't present.
+    //
+    //   * A :ref:`listener filter <arch_overview_listener_filters>` may
+    //     overwrite a connection's requested server name within Envoy.
+    //
+    // Please refer to :ref:`this FAQ entry <faq_how_to_setup_sni>` to learn how to setup SNI.
+    type.matcher.v3.StringMatcher requested_server_name = 9;
+
+    // Extension for configuring custom matchers for RBAC.
+    // [#extension-category: envoy.rbac.matchers]
+    core.v3.TypedExtensionConfig matcher = 12;
+
+    // URI template path matching.
+    // [#extension-category: envoy.path.match]
+    core.v3.TypedExtensionConfig uri_template = 13;
+
+    // Matches against metadata from either dynamic state or route configuration. Preferred over the
+    // ``metadata`` field as it provides more flexibility in metadata source selection.
+    SourcedMetadata sourced_metadata = 14;
+  }
+}
+
+// Principal defines an identity or a group of identities for a downstream
+// subject.
+// [#next-free-field: 15]
+message Principal {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.config.rbac.v2.Principal";
+
+  // Used in the ``and_ids`` and ``or_ids`` fields in the ``identifier`` oneof.
+  // Depending on the context, each are applied with the associated behavior.
+  message Set {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.rbac.v2.Principal.Set";
+
+    repeated Principal ids = 1 [(validate.rules).repeated = {min_items: 1}];
+  }
+
+  // Authentication attributes for a downstream.
+  // It is recommended to NOT use this type, but instead use
+  // :ref:`MTlsAuthenticated <envoy_v3_api_msg_extensions.rbac.principals.mtls_authenticated.v3.Config>`,
+  // configured via :ref:`custom <envoy_v3_api_field_config.rbac.v3.Principal.custom>`,
+  // which should be used for most use cases due to its improved security.
+  message Authenticated {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.rbac.v2.Principal.Authenticated";
+
+    reserved 1;
+
+    // The name of the principal. If set, The URI SAN or DNS SAN in that order
+    // is used from the certificate, otherwise the subject field is used. If
+    // unset, it applies to any user that is allowed by the downstream TLS configuration.
+    // If :ref:`require_client_certificate <envoy_v3_api_field_extensions.transport_sockets.tls.v3.DownstreamTlsContext.require_client_certificate>`
+    // is false or :ref:`trust_chain_verification <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.trust_chain_verification>`
+    // is set to :ref:`ACCEPT_UNTRUSTED <envoy_v3_api_enum_value_extensions.transport_sockets.tls.v3.CertificateValidationContext.TrustChainVerification.ACCEPT_UNTRUSTED>`,
+    // then no authentication is required.
+    type.matcher.v3.StringMatcher principal_name = 2;
+  }
+
+  oneof identifier {
+    option (validate.required) = true;
+
+    // A set of identifiers that all must match in order to define the downstream.
+    Set and_ids = 1;
+
+    // A set of identifiers at least one must match in order to define the downstream.
+    Set or_ids = 2;
+
+    // When any is set, it matches any downstream.
+    bool any = 3 [(validate.rules).bool = {const: true}];
+
+    // Authenticated attributes that identify the downstream.
+    // It is recommended to NOT use this field, but instead use
+    // :ref:`MTlsAuthenticated <envoy_v3_api_msg_extensions.rbac.principals.mtls_authenticated.v3.Config>`,
+    // configured via :ref:`custom <envoy_v3_api_field_config.rbac.v3.Principal.custom>`,
+    // which should be used for most use cases due to its improved security.
+    Authenticated authenticated = 4;
+
+    // A CIDR block that describes the downstream IP.
+    // This address will honor proxy protocol, but will not honor XFF.
+    //
+    // This field is deprecated; either use :ref:`remote_ip
+    // <envoy_v3_api_field_config.rbac.v3.Principal.remote_ip>` for the same
+    // behavior, or use
+    // :ref:`direct_remote_ip <envoy_v3_api_field_config.rbac.v3.Principal.direct_remote_ip>`.
+    core.v3.CidrRange source_ip = 5
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+    // A CIDR block that describes the downstream remote/origin address.
+    //
+    // .. note::
+    //
+    //   This is always the physical peer even if the
+    //   :ref:`remote_ip <envoy_v3_api_field_config.rbac.v3.Principal.remote_ip>` is inferred from the
+    //   x-forwarder-for header, the proxy protocol, etc.
+    //
+    core.v3.CidrRange direct_remote_ip = 10;
+
+    // A CIDR block that describes the downstream remote/origin address.
+    //
+    // .. note::
+    //
+    //   This may not be the physical peer and could be different from the :ref:`direct_remote_ip
+    //   <envoy_v3_api_field_config.rbac.v3.Principal.direct_remote_ip>`. E.g, if the remote ip is inferred from
+    //   the x-forwarder-for header, the proxy protocol, etc.
+    //
+    core.v3.CidrRange remote_ip = 11;
+
+    // A header (or pseudo-header such as ``:path`` or ``:method``) on the incoming HTTP request. Only available
+    // for HTTP request.
+    //
+    // .. note::
+    //
+    //   The pseudo-header ``:path`` includes the query and fragment string. Use the ``url_path`` field if you
+    //   want to match the URL path without the query and fragment string.
+    //
+    route.v3.HeaderMatcher header = 6;
+
+    // A URL path on the incoming HTTP request. Only available for HTTP.
+    type.matcher.v3.PathMatcher url_path = 9;
+
+    // Metadata that describes additional information about the principal. This field is deprecated; please use
+    // :ref:`sourced_metadata<envoy_v3_api_field_config.rbac.v3.Principal.sourced_metadata>` instead.
+    type.matcher.v3.MetadataMatcher metadata = 7
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+    // Identifies the principal using a filter state object.
+    type.matcher.v3.FilterStateMatcher filter_state = 12;
+
+    // Negates matching the provided principal. For instance, if the value of
+    // ``not_id`` would match, this principal would not match. Conversely, if the
+    // value of ``not_id`` would not match, this principal would match.
+    Principal not_id = 8;
+
+    // Matches against metadata from either dynamic state or route configuration. Preferred over the
+    // ``metadata`` field as it provides more flexibility in metadata source selection.
+    SourcedMetadata sourced_metadata = 13;
+
+    // Extension for configuring custom principals for RBAC.
+    // [#extension-category: envoy.rbac.principals]
+    core.v3.TypedExtensionConfig custom = 14;
+  }
+}
+
+// Action defines the result of allowance or denial when a request matches the matcher.
+message Action {
+  // The name indicates the policy name.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // The action to take if the matcher matches. Every action either allows or denies a request,
+  // and can also carry out action-specific operations.
+  //
+  // **Actions:**
+  //
+  //  * ``ALLOW``: If the request gets matched on ALLOW, it is permitted.
+  //  * ``DENY``: If the request gets matched on DENY, it is not permitted.
+  //  * ``LOG``: If the request gets matched on LOG, it is permitted. Besides, the
+  //    dynamic metadata key ``access_log_hint`` under the shared key namespace
+  //    ``envoy.common`` will be set to the value ``true``.
+  //  * If the request cannot get matched, it will fallback to ``DENY``.
+  //
+  // **Log behavior:**
+  //
+  //  If the RBAC matcher contains at least one LOG action, the dynamic
+  //  metadata key ``access_log_hint`` will be set based on if the request
+  //  get matched on the LOG action.
+  //
+  RBAC.Action action = 2;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/route/v3/route.proto b/xds/third_party/envoy/src/main/proto/envoy/config/route/v3/route.proto
new file mode 100644
index 00000000000..c4d507d22b0
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/route/v3/route.proto
@@ -0,0 +1,165 @@
+syntax = "proto3";
+
+package envoy.config.route.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/config_source.proto";
+import "envoy/config/route/v3/route_components.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.route.v3";
+option java_outer_classname = "RouteProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/route/v3;routev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: HTTP route configuration]
+// * Routing :ref:`architecture overview <arch_overview_http_routing>`
+// * HTTP :ref:`router filter <config_http_filters_router>`
+
+// [#next-free-field: 18]
+message RouteConfiguration {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.RouteConfiguration";
+
+  // The name of the route configuration. For example, it might match
+  // :ref:`route_config_name
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.Rds.route_config_name>` in
+  // :ref:`envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.Rds`.
+  string name = 1;
+
+  // An array of virtual hosts that make up the route table.
+  repeated VirtualHost virtual_hosts = 2;
+
+  // An array of virtual hosts will be dynamically loaded via the VHDS API.
+  // Both ``virtual_hosts`` and ``vhds`` fields will be used when present. ``virtual_hosts`` can be used
+  // for a base routing table or for infrequently changing virtual hosts. ``vhds`` is used for
+  // on-demand discovery of virtual hosts. The contents of these two fields will be merged to
+  // generate a routing table for a given RouteConfiguration, with ``vhds`` derived configuration
+  // taking precedence.
+  Vhds vhds = 9;
+
+  // Optionally specifies a list of HTTP headers that the connection manager
+  // will consider to be internal only. If they are found on external requests they will be cleaned
+  // prior to filter invocation. See :ref:`config_http_conn_man_headers_x-envoy-internal` for more
+  // information.
+  repeated string internal_only_headers = 3 [
+    (validate.rules).repeated = {items {string {well_known_regex: HTTP_HEADER_NAME strict: false}}}
+  ];
+
+  // Specifies a list of HTTP headers that should be added to each response that
+  // the connection manager encodes. Headers specified at this level are applied
+  // after headers from any enclosed :ref:`envoy_v3_api_msg_config.route.v3.VirtualHost` or
+  // :ref:`envoy_v3_api_msg_config.route.v3.RouteAction`. For more information, including details on
+  // header value syntax, see the documentation on :ref:`custom request headers
+  // <config_http_conn_man_headers_custom_request_headers>`.
+  repeated core.v3.HeaderValueOption response_headers_to_add = 4
+      [(validate.rules).repeated = {max_items: 1000}];
+
+  // Specifies a list of HTTP headers that should be removed from each response
+  // that the connection manager encodes.
+  repeated string response_headers_to_remove = 5 [
+    (validate.rules).repeated = {items {string {well_known_regex: HTTP_HEADER_NAME strict: false}}}
+  ];
+
+  // Specifies a list of HTTP headers that should be added to each request
+  // routed by the HTTP connection manager. Headers specified at this level are
+  // applied after headers from any enclosed :ref:`envoy_v3_api_msg_config.route.v3.VirtualHost` or
+  // :ref:`envoy_v3_api_msg_config.route.v3.RouteAction`. For more information, including details on
+  // header value syntax, see the documentation on :ref:`custom request headers
+  // <config_http_conn_man_headers_custom_request_headers>`.
+  repeated core.v3.HeaderValueOption request_headers_to_add = 6
+      [(validate.rules).repeated = {max_items: 1000}];
+
+  // Specifies a list of HTTP headers that should be removed from each request
+  // routed by the HTTP connection manager.
+  repeated string request_headers_to_remove = 8 [
+    (validate.rules).repeated = {items {string {well_known_regex: HTTP_HEADER_NAME strict: false}}}
+  ];
+
+  // Headers mutations at all levels are evaluated, if specified. By default, the order is from most
+  // specific (i.e. route entry level) to least specific (i.e. route configuration level). Later header
+  // mutations may override earlier mutations.
+  // This order can be reversed by setting this field to true. In other words, most specific level mutation
+  // is evaluated last.
+  //
+  bool most_specific_header_mutations_wins = 10;
+
+  // An optional boolean that specifies whether the clusters that the route
+  // table refers to will be validated by the cluster manager. If set to true
+  // and a route refers to a non-existent cluster, the route table will not
+  // load. If set to false and a route refers to a non-existent cluster, the
+  // route table will load and the router filter will return a 404 if the route
+  // is selected at runtime. This setting defaults to true if the route table
+  // is statically defined via the :ref:`route_config
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.route_config>`
+  // option. This setting default to false if the route table is loaded dynamically via the
+  // :ref:`rds
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.rds>`
+  // option. Users may wish to override the default behavior in certain cases (for example when
+  // using CDS with a static route table).
+  google.protobuf.BoolValue validate_clusters = 7;
+
+  // The maximum bytes of the response :ref:`direct response body
+  // <envoy_v3_api_field_config.route.v3.DirectResponseAction.body>` size. If not specified the default
+  // is 4096.
+  //
+  // .. warning::
+  //
+  //   Envoy currently holds the content of :ref:`direct response body
+  //   <envoy_v3_api_field_config.route.v3.DirectResponseAction.body>` in memory. Be careful setting
+  //   this to be larger than the default 4KB, since the allocated memory for direct response body
+  //   is not subject to data plane buffering controls.
+  //
+  google.protobuf.UInt32Value max_direct_response_body_size_bytes = 11;
+
+  // A list of plugins and their configurations which may be used by a
+  // :ref:`cluster specifier plugin name <envoy_v3_api_field_config.route.v3.RouteAction.cluster_specifier_plugin>`
+  // within the route. All ``extension.name`` fields in this list must be unique.
+  repeated ClusterSpecifierPlugin cluster_specifier_plugins = 12;
+
+  // Specify a set of default request mirroring policies which apply to all routes under its virtual hosts.
+  // Note that policies are not merged, the most specific non-empty one becomes the mirror policies.
+  repeated RouteAction.RequestMirrorPolicy request_mirror_policies = 13;
+
+  // By default, port in :authority header (if any) is used in host matching.
+  // With this option enabled, Envoy will ignore the port number in the :authority header (if any) when picking VirtualHost.
+  // NOTE: this option will not strip the port number (if any) contained in route config
+  // :ref:`envoy_v3_api_msg_config.route.v3.VirtualHost`.domains field.
+  bool ignore_port_in_host_matching = 14;
+
+  // Ignore path-parameters in path-matching.
+  // Before RFC3986, URI were like(RFC1808): <scheme>://<net_loc>/<path>;<params>?<query>#<fragment>
+  // Envoy by default takes ":path" as "<path>;<params>".
+  // For users who want to only match path on the "<path>" portion, this option should be true.
+  bool ignore_path_parameters_in_path_matching = 15;
+
+  // This field can be used to provide RouteConfiguration level per filter config. The key should match the
+  // :ref:`filter config name
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpFilter.name>`.
+  // See :ref:`Http filter route specific config <arch_overview_http_filters_per_filter_config>`
+  // for details.
+  // [#comment: An entry's value may be wrapped in a
+  // :ref:`FilterConfig<envoy_v3_api_msg_config.route.v3.FilterConfig>`
+  // message to specify additional options.]
+  map<string, google.protobuf.Any> typed_per_filter_config = 16;
+
+  // The metadata field can be used to provide additional information
+  // about the route configuration. It can be used for configuration, stats, and logging.
+  // The metadata should go under the filter namespace that will need it.
+  // For instance, if the metadata is intended for the Router filter,
+  // the filter name should be specified as ``envoy.filters.http.router``.
+  core.v3.Metadata metadata = 17;
+}
+
+message Vhds {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.Vhds";
+
+  // Configuration source specifier for VHDS.
+  core.v3.ConfigSource config_source = 1 [(validate.rules).message = {required: true}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/route/v3/route_components.proto b/xds/third_party/envoy/src/main/proto/envoy/config/route/v3/route_components.proto
new file mode 100644
index 00000000000..6837ade69d8
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/route/v3/route_components.proto
@@ -0,0 +1,2649 @@
+syntax = "proto3";
+
+package envoy.config.route.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/core/v3/proxy_protocol.proto";
+import "envoy/type/matcher/v3/filter_state.proto";
+import "envoy/type/matcher/v3/metadata.proto";
+import "envoy/type/matcher/v3/regex.proto";
+import "envoy/type/matcher/v3/string.proto";
+import "envoy/type/metadata/v3/metadata.proto";
+import "envoy/type/tracing/v3/custom_tag.proto";
+import "envoy/type/v3/percent.proto";
+import "envoy/type/v3/range.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "xds/type/matcher/v3/matcher.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.route.v3";
+option java_outer_classname = "RouteComponentsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/route/v3;routev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: HTTP route components]
+// * Routing :ref:`architecture overview <arch_overview_http_routing>`
+// * HTTP :ref:`router filter <config_http_filters_router>`
+
+// The top level element in the routing configuration is a virtual host. Each virtual host has
+// a logical name as well as a set of domains that get routed to it based on the incoming request's
+// host header. This allows a single listener to service multiple top level domain path trees. Once
+// a virtual host is selected based on the domain, the routes are processed in order to see which
+// upstream cluster to route to or whether to perform a redirect.
+// [#next-free-field: 26]
+message VirtualHost {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.VirtualHost";
+
+  enum TlsRequirementType {
+    // No TLS requirement for the virtual host.
+    NONE = 0;
+
+    // External requests must use TLS. If a request is external and it is not
+    // using TLS, a 301 redirect will be sent telling the client to use HTTPS.
+    EXTERNAL_ONLY = 1;
+
+    // All requests must use TLS. If a request is not using TLS, a 301 redirect
+    // will be sent telling the client to use HTTPS.
+    ALL = 2;
+  }
+
+  reserved 9, 12;
+
+  reserved "per_filter_config";
+
+  // The logical name of the virtual host. This is used when emitting certain
+  // statistics but is not relevant for routing.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // A list of domains (host/authority header) that will be matched to this
+  // virtual host. Wildcard hosts are supported in the suffix or prefix form.
+  //
+  // Domain search order:
+  //  1. Exact domain names: ``www.foo.com``.
+  //  2. Suffix domain wildcards: ``*.foo.com`` or ``*-bar.foo.com``.
+  //  3. Prefix domain wildcards: ``foo.*`` or ``foo-*``.
+  //  4. Special wildcard ``*`` matching any domain.
+  //
+  // .. note::
+  //
+  //   The wildcard will not match the empty string.
+  //   e.g. ``*-bar.foo.com`` will match ``baz-bar.foo.com`` but not ``-bar.foo.com``.
+  //   The longest wildcards match first.
+  //   Only a single virtual host in the entire route configuration can match on ``*``. A domain
+  //   must be unique across all virtual hosts or the config will fail to load.
+  //
+  // Domains cannot contain control characters. This is validated by the well_known_regex HTTP_HEADER_VALUE.
+  repeated string domains = 2 [(validate.rules).repeated = {
+    min_items: 1
+    items {string {well_known_regex: HTTP_HEADER_VALUE strict: false}}
+  }];
+
+  // The list of routes that will be matched, in order, for incoming requests.
+  // The first route that matches will be used.
+  // Only one of this and ``matcher`` can be specified.
+  repeated Route routes = 3 [(udpa.annotations.field_migrate).oneof_promotion = "route_selection"];
+
+  // The match tree to use when resolving route actions for incoming requests. Only one of this and ``routes``
+  // can be specified.
+  xds.type.matcher.v3.Matcher matcher = 21
+      [(udpa.annotations.field_migrate).oneof_promotion = "route_selection"];
+
+  // Specifies the type of TLS enforcement the virtual host expects. If this option is not
+  // specified, there is no TLS requirement for the virtual host.
+  TlsRequirementType require_tls = 4 [(validate.rules).enum = {defined_only: true}];
+
+  // A list of virtual clusters defined for this virtual host. Virtual clusters
+  // are used for additional statistics gathering.
+  repeated VirtualCluster virtual_clusters = 5;
+
+  // Specifies a set of rate limit configurations that will be applied to the
+  // virtual host.
+  repeated RateLimit rate_limits = 6;
+
+  // Specifies a list of HTTP headers that should be added to each request
+  // handled by this virtual host. Headers specified at this level are applied
+  // after headers from enclosed :ref:`envoy_v3_api_msg_config.route.v3.Route` and before headers from the
+  // enclosing :ref:`envoy_v3_api_msg_config.route.v3.RouteConfiguration`. For more information, including
+  // details on header value syntax, see the documentation on :ref:`custom request headers
+  // <config_http_conn_man_headers_custom_request_headers>`.
+  repeated core.v3.HeaderValueOption request_headers_to_add = 7
+      [(validate.rules).repeated = {max_items: 1000}];
+
+  // Specifies a list of HTTP headers that should be removed from each request
+  // handled by this virtual host.
+  repeated string request_headers_to_remove = 13 [(validate.rules).repeated = {
+    items {string {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}}
+  }];
+
+  // Specifies a list of HTTP headers that should be added to each response
+  // handled by this virtual host. Headers specified at this level are applied
+  // after headers from enclosed :ref:`envoy_v3_api_msg_config.route.v3.Route` and before headers from the
+  // enclosing :ref:`envoy_v3_api_msg_config.route.v3.RouteConfiguration`. For more information, including
+  // details on header value syntax, see the documentation on :ref:`custom request headers
+  // <config_http_conn_man_headers_custom_request_headers>`.
+  repeated core.v3.HeaderValueOption response_headers_to_add = 10
+      [(validate.rules).repeated = {max_items: 1000}];
+
+  // Specifies a list of HTTP headers that should be removed from each response
+  // handled by this virtual host.
+  repeated string response_headers_to_remove = 11 [(validate.rules).repeated = {
+    items {string {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}}
+  }];
+
+  // Indicates that the virtual host has a CORS policy. This field is ignored if related cors policy is
+  // found in the
+  // :ref:`VirtualHost.typed_per_filter_config<envoy_v3_api_field_config.route.v3.VirtualHost.typed_per_filter_config>`.
+  //
+  // .. attention::
+  //
+  //   This option has been deprecated. Please use
+  //   :ref:`VirtualHost.typed_per_filter_config<envoy_v3_api_field_config.route.v3.VirtualHost.typed_per_filter_config>`
+  //   to configure the CORS HTTP filter.
+  CorsPolicy cors = 8 [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // This field can be used to provide virtual host level per filter config. The key should match the
+  // :ref:`filter config name
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpFilter.name>`.
+  // See :ref:`Http filter route specific config <arch_overview_http_filters_per_filter_config>`
+  // for details.
+  // [#comment: An entry's value may be wrapped in a
+  // :ref:`FilterConfig<envoy_v3_api_msg_config.route.v3.FilterConfig>`
+  // message to specify additional options.]
+  map<string, google.protobuf.Any> typed_per_filter_config = 15;
+
+  // Decides whether the :ref:`x-envoy-attempt-count
+  // <config_http_filters_router_x-envoy-attempt-count>` header should be included
+  // in the upstream request. Setting this option will cause it to override any existing header
+  // value, so in the case of two Envoys on the request path with this option enabled, the upstream
+  // will see the attempt count as perceived by the second Envoy. Defaults to false.
+  // This header is unaffected by the
+  // :ref:`suppress_envoy_headers
+  // <envoy_v3_api_field_extensions.filters.http.router.v3.Router.suppress_envoy_headers>` flag.
+  //
+  // [#next-major-version: rename to include_attempt_count_in_request.]
+  bool include_request_attempt_count = 14;
+
+  // Decides whether the :ref:`x-envoy-attempt-count
+  // <config_http_filters_router_x-envoy-attempt-count>` header should be included
+  // in the downstream response. Setting this option will cause the router to override any existing header
+  // value, so in the case of two Envoys on the request path with this option enabled, the downstream
+  // will see the attempt count as perceived by the Envoy closest upstream from itself. Defaults to false.
+  // This header is unaffected by the
+  // :ref:`suppress_envoy_headers
+  // <envoy_v3_api_field_extensions.filters.http.router.v3.Router.suppress_envoy_headers>` flag.
+  bool include_attempt_count_in_response = 19;
+
+  // Indicates the retry policy for all routes in this virtual host. Note that setting a
+  // route level entry will take precedence over this config and it'll be treated
+  // independently (e.g.: values are not inherited).
+  RetryPolicy retry_policy = 16;
+
+  // [#not-implemented-hide:]
+  // Specifies the configuration for retry policy extension. Note that setting a route level entry
+  // will take precedence over this config and it'll be treated independently (e.g.: values are not
+  // inherited). :ref:`Retry policy <envoy_v3_api_field_config.route.v3.VirtualHost.retry_policy>` should not be
+  // set if this field is used.
+  google.protobuf.Any retry_policy_typed_config = 20;
+
+  // Indicates the hedge policy for all routes in this virtual host. Note that setting a
+  // route level entry will take precedence over this config and it'll be treated
+  // independently (e.g.: values are not inherited).
+  HedgePolicy hedge_policy = 17;
+
+  // Decides whether to include the :ref:`x-envoy-is-timeout-retry <config_http_filters_router_x-envoy-is-timeout-retry>`
+  // request header in retries initiated by per try timeouts.
+  bool include_is_timeout_retry_header = 23;
+
+  // The maximum bytes which will be buffered for retries and shadowing. If set, the bytes actually buffered will be
+  // the minimum value of this and the listener ``per_connection_buffer_limit_bytes``.
+  //
+  // .. attention::
+  //
+  //   This field has been deprecated. Please use :ref:`request_body_buffer_limit
+  //   <envoy_v3_api_field_config.route.v3.VirtualHost.request_body_buffer_limit>` instead.
+  //   Only one of ``per_request_buffer_limit_bytes`` and ``request_body_buffer_limit`` could be set.
+  google.protobuf.UInt32Value per_request_buffer_limit_bytes = 18
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // The maximum bytes which will be buffered for request bodies to support large request body
+  // buffering beyond the ``per_connection_buffer_limit_bytes``.
+  //
+  // This limit is specifically for the request body buffering and allows buffering larger payloads while maintaining
+  // flow control.
+  //
+  // Buffer limit precedence (from highest to lowest priority):
+  //
+  // 1. If ``request_body_buffer_limit`` is set, then ``request_body_buffer_limit`` will be used.
+  // 2. If :ref:`per_request_buffer_limit_bytes <envoy_v3_api_field_config.route.v3.VirtualHost.per_request_buffer_limit_bytes>`
+  //    is set but ``request_body_buffer_limit`` is not, then ``min(per_request_buffer_limit_bytes, per_connection_buffer_limit_bytes)``
+  //    will be used.
+  // 3. If neither is set, then ``per_connection_buffer_limit_bytes`` will be used.
+  //
+  // For flow control chunk sizes, ``min(per_connection_buffer_limit_bytes, 16KB)`` will be used.
+  //
+  // Only one of :ref:`per_request_buffer_limit_bytes <envoy_v3_api_field_config.route.v3.VirtualHost.per_request_buffer_limit_bytes>`
+  // and ``request_body_buffer_limit`` could be set.
+  google.protobuf.UInt64Value request_body_buffer_limit = 25
+      [(validate.rules).message = {required: false}];
+
+  // Specify a set of default request mirroring policies for every route under this virtual host.
+  // It takes precedence over the route config mirror policy entirely.
+  // That is, policies are not merged, the most specific non-empty one becomes the mirror policies.
+  repeated RouteAction.RequestMirrorPolicy request_mirror_policies = 22;
+
+  // The metadata field can be used to provide additional information
+  // about the virtual host. It can be used for configuration, stats, and logging.
+  // The metadata should go under the filter namespace that will need it.
+  // For instance, if the metadata is intended for the Router filter,
+  // the filter name should be specified as ``envoy.filters.http.router``.
+  core.v3.Metadata metadata = 24;
+}
+
+// A filter-defined action type.
+message FilterAction {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.FilterAction";
+
+  google.protobuf.Any action = 1;
+}
+
+// This can be used in route matcher :ref:`VirtualHost.matcher <envoy_v3_api_field_config.route.v3.VirtualHost.matcher>`.
+// When the matcher matches, routes will be matched and run.
+message RouteList {
+  // The list of routes that will be matched and run, in order. The first route that matches will be used.
+  repeated Route routes = 1;
+}
+
+// A route is both a specification of how to match a request as well as an indication of what to do
+// next (e.g., redirect, forward, rewrite, etc.).
+//
+// .. attention::
+//
+//   Envoy supports routing on HTTP method via :ref:`header matching
+//   <envoy_v3_api_msg_config.route.v3.HeaderMatcher>`.
+// [#next-free-field: 21]
+message Route {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.Route";
+
+  reserved 6, 8;
+
+  reserved "per_filter_config";
+
+  // Name for the route.
+  string name = 14;
+
+  // Route matching parameters.
+  RouteMatch match = 1 [(validate.rules).message = {required: true}];
+
+  oneof action {
+    option (validate.required) = true;
+
+    // Route request to some upstream cluster.
+    RouteAction route = 2;
+
+    // Return a redirect.
+    RedirectAction redirect = 3;
+
+    // Return an arbitrary HTTP response directly, without proxying.
+    DirectResponseAction direct_response = 7;
+
+    // [#not-implemented-hide:]
+    // A filter-defined action (e.g., it could dynamically generate the RouteAction).
+    // [#comment: TODO(samflattery): Remove cleanup in route_fuzz_test.cc when
+    // implemented]
+    FilterAction filter_action = 17;
+
+    // [#not-implemented-hide:]
+    // An action used when the route will generate a response directly,
+    // without forwarding to an upstream host. This will be used in non-proxy
+    // xDS clients like the gRPC server. It could also be used in the future
+    // in Envoy for a filter that directly generates responses for requests.
+    NonForwardingAction non_forwarding_action = 18;
+  }
+
+  // The Metadata field can be used to provide additional information
+  // about the route. It can be used for configuration, stats, and logging.
+  // The metadata should go under the filter namespace that will need it.
+  // For instance, if the metadata is intended for the Router filter,
+  // the filter name should be specified as ``envoy.filters.http.router``.
+  core.v3.Metadata metadata = 4;
+
+  // Decorator for the matched route.
+  Decorator decorator = 5;
+
+  // This field can be used to provide route specific per filter config. The key should match the
+  // :ref:`filter config name
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpFilter.name>`.
+  // See :ref:`Http filter route specific config <arch_overview_http_filters_per_filter_config>`
+  // for details.
+  // [#comment: An entry's value may be wrapped in a
+  // :ref:`FilterConfig<envoy_v3_api_msg_config.route.v3.FilterConfig>`
+  // message to specify additional options.]
+  map<string, google.protobuf.Any> typed_per_filter_config = 13;
+
+  // Specifies a set of headers that will be added to requests matching this
+  // route. Headers specified at this level are applied before headers from the
+  // enclosing :ref:`envoy_v3_api_msg_config.route.v3.VirtualHost` and
+  // :ref:`envoy_v3_api_msg_config.route.v3.RouteConfiguration`. For more information, including details on
+  // header value syntax, see the documentation on :ref:`custom request headers
+  // <config_http_conn_man_headers_custom_request_headers>`.
+  repeated core.v3.HeaderValueOption request_headers_to_add = 9
+      [(validate.rules).repeated = {max_items: 1000}];
+
+  // Specifies a list of HTTP headers that should be removed from each request
+  // matching this route.
+  repeated string request_headers_to_remove = 12 [(validate.rules).repeated = {
+    items {string {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}}
+  }];
+
+  // Specifies a set of headers that will be added to responses to requests
+  // matching this route. Headers specified at this level are applied before
+  // headers from the enclosing :ref:`envoy_v3_api_msg_config.route.v3.VirtualHost` and
+  // :ref:`envoy_v3_api_msg_config.route.v3.RouteConfiguration`. For more information, including
+  // details on header value syntax, see the documentation on
+  // :ref:`custom request headers <config_http_conn_man_headers_custom_request_headers>`.
+  repeated core.v3.HeaderValueOption response_headers_to_add = 10
+      [(validate.rules).repeated = {max_items: 1000}];
+
+  // Specifies a list of HTTP headers that should be removed from each response
+  // to requests matching this route.
+  repeated string response_headers_to_remove = 11 [(validate.rules).repeated = {
+    items {string {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}}
+  }];
+
+  // Presence of the object defines whether the connection manager's tracing configuration
+  // is overridden by this route specific instance.
+  Tracing tracing = 15;
+
+  // The maximum bytes which will be buffered for retries and shadowing.
+  // If set, the bytes actually buffered will be the minimum value of this and the
+  // listener per_connection_buffer_limit_bytes.
+  //
+  // .. attention::
+  //
+  //   This field has been deprecated. Please use :ref:`request_body_buffer_limit
+  //   <envoy_v3_api_field_config.route.v3.Route.request_body_buffer_limit>` instead.
+  //   Only one of ``per_request_buffer_limit_bytes`` and ``request_body_buffer_limit`` may be set.
+  google.protobuf.UInt32Value per_request_buffer_limit_bytes = 16
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // The human readable prefix to use when emitting statistics for this endpoint.
+  // The statistics are rooted at vhost.<virtual host name>.route.<stat_prefix>.
+  // This should be set for highly critical
+  // endpoints that one wishes to get “per-route” statistics on.
+  // If not set, endpoint statistics are not generated.
+  //
+  // The emitted statistics are the same as those documented for :ref:`virtual clusters <config_http_filters_router_vcluster_stats>`.
+  //
+  // .. warning::
+  //
+  //    We do not recommend setting up a stat prefix for
+  //    every application endpoint. This is both not easily maintainable and
+  //    statistics use a non-trivial amount of memory(approximately 1KiB per route).
+  string stat_prefix = 19;
+
+  // The maximum bytes which will be buffered for request bodies to support large request body
+  // buffering beyond the ``per_connection_buffer_limit_bytes``.
+  //
+  // This limit is specifically for the request body buffering and allows buffering larger payloads while maintaining
+  // flow control.
+  //
+  // Buffer limit precedence (from highest to lowest priority):
+  //
+  // 1. If ``request_body_buffer_limit`` is set: use ``request_body_buffer_limit``
+  // 2. If :ref:`per_request_buffer_limit_bytes <envoy_v3_api_field_config.route.v3.Route.per_request_buffer_limit_bytes>`
+  //    is set but ``request_body_buffer_limit`` is not: use ``min(per_request_buffer_limit_bytes, per_connection_buffer_limit_bytes)``
+  // 3. If neither is set: use ``per_connection_buffer_limit_bytes``
+  //
+  // For flow control chunk sizes, use ``min(per_connection_buffer_limit_bytes, 16KB)``.
+  //
+  // Only one of :ref:`per_request_buffer_limit_bytes <envoy_v3_api_field_config.route.v3.Route.per_request_buffer_limit_bytes>`
+  // and ``request_body_buffer_limit`` may be set.
+  google.protobuf.UInt64Value request_body_buffer_limit = 20;
+}
+
+// Compared to the :ref:`cluster <envoy_v3_api_field_config.route.v3.RouteAction.cluster>` field that specifies a
+// single upstream cluster as the target of a request, the :ref:`weighted_clusters
+// <envoy_v3_api_field_config.route.v3.RouteAction.weighted_clusters>` option allows for specification of
+// multiple upstream clusters along with weights that indicate the percentage of
+// traffic to be forwarded to each cluster. The router selects an upstream cluster based on the
+// weights.
+// [#next-free-field: 6]
+message WeightedCluster {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.WeightedCluster";
+
+  // [#next-free-field: 13]
+  message ClusterWeight {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.route.WeightedCluster.ClusterWeight";
+
+    reserved 7, 8;
+
+    reserved "per_filter_config";
+
+    // Only one of ``name`` and ``cluster_header`` may be specified.
+    // [#next-major-version: Need to add back the validation rule: (validate.rules).string = {min_len: 1}]
+    // Name of the upstream cluster. The cluster must exist in the
+    // :ref:`cluster manager configuration <config_cluster_manager>`.
+    string name = 1 [(udpa.annotations.field_migrate).oneof_promotion = "cluster_specifier"];
+
+    // Only one of ``name`` and ``cluster_header`` may be specified.
+    // [#next-major-version: Need to add back the validation rule: (validate.rules).string = {min_len: 1 }]
+    // Envoy will determine the cluster to route to by reading the value of the
+    // HTTP header named by cluster_header from the request headers. If the
+    // header is not found or the referenced cluster does not exist, Envoy will
+    // return a 404 response.
+    //
+    // .. attention::
+    //
+    //   Internally, Envoy always uses the HTTP/2 ``:authority`` header to represent the HTTP/1
+    //   ``Host`` header. Thus, if attempting to match on ``Host``, match on ``:authority`` instead.
+    //
+    // .. note::
+    //
+    //   If the header appears multiple times only the first value is used.
+    string cluster_header = 12 [
+      (validate.rules).string = {well_known_regex: HTTP_HEADER_NAME strict: false},
+      (udpa.annotations.field_migrate).oneof_promotion = "cluster_specifier"
+    ];
+
+    // The weight of the cluster. This value is relative to the other clusters'
+    // weights. When a request matches the route, the choice of an upstream cluster
+    // is determined by its weight. The sum of weights across all
+    // entries in the clusters array must be greater than 0, and must not exceed
+    // uint32_t maximal value (4294967295).
+    google.protobuf.UInt32Value weight = 2;
+
+    // Optional endpoint metadata match criteria used by the subset load balancer. Only endpoints in
+    // the upstream cluster with metadata matching what is set in this field will be considered for
+    // load balancing. Note that this will be merged with what's provided in
+    // :ref:`RouteAction.metadata_match <envoy_v3_api_field_config.route.v3.RouteAction.metadata_match>`, with
+    // values here taking precedence. The filter name should be specified as ``envoy.lb``.
+    core.v3.Metadata metadata_match = 3;
+
+    // Specifies a list of headers to be added to requests when this cluster is selected
+    // through the enclosing :ref:`envoy_v3_api_msg_config.route.v3.RouteAction`.
+    // Headers specified at this level are applied before headers from the enclosing
+    // :ref:`envoy_v3_api_msg_config.route.v3.Route`, :ref:`envoy_v3_api_msg_config.route.v3.VirtualHost`, and
+    // :ref:`envoy_v3_api_msg_config.route.v3.RouteConfiguration`. For more information, including details on
+    // header value syntax, see the documentation on :ref:`custom request headers
+    // <config_http_conn_man_headers_custom_request_headers>`.
+    repeated core.v3.HeaderValueOption request_headers_to_add = 4
+        [(validate.rules).repeated = {max_items: 1000}];
+
+    // Specifies a list of HTTP headers that should be removed from each request when
+    // this cluster is selected through the enclosing :ref:`envoy_v3_api_msg_config.route.v3.RouteAction`.
+    repeated string request_headers_to_remove = 9 [(validate.rules).repeated = {
+      items {string {well_known_regex: HTTP_HEADER_NAME strict: false}}
+    }];
+
+    // Specifies a list of headers to be added to responses when this cluster is selected
+    // through the enclosing :ref:`envoy_v3_api_msg_config.route.v3.RouteAction`.
+    // Headers specified at this level are applied before headers from the enclosing
+    // :ref:`envoy_v3_api_msg_config.route.v3.Route`, :ref:`envoy_v3_api_msg_config.route.v3.VirtualHost`, and
+    // :ref:`envoy_v3_api_msg_config.route.v3.RouteConfiguration`. For more information, including details on
+    // header value syntax, see the documentation on :ref:`custom request headers
+    // <config_http_conn_man_headers_custom_request_headers>`.
+    repeated core.v3.HeaderValueOption response_headers_to_add = 5
+        [(validate.rules).repeated = {max_items: 1000}];
+
+    // Specifies a list of headers to be removed from responses when this cluster is selected
+    // through the enclosing :ref:`envoy_v3_api_msg_config.route.v3.RouteAction`.
+    repeated string response_headers_to_remove = 6 [(validate.rules).repeated = {
+      items {string {well_known_regex: HTTP_HEADER_NAME strict: false}}
+    }];
+
+    // This field can be used to provide weighted cluster specific per filter config. The key should match the
+    // :ref:`filter config name
+    // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpFilter.name>`.
+    // See :ref:`Http filter route specific config <arch_overview_http_filters_per_filter_config>`
+    // for details.
+    // [#comment: An entry's value may be wrapped in a
+    // :ref:`FilterConfig<envoy_v3_api_msg_config.route.v3.FilterConfig>`
+    // message to specify additional options.]
+    map<string, google.protobuf.Any> typed_per_filter_config = 10;
+
+    oneof host_rewrite_specifier {
+      // Indicates that during forwarding, the host header will be swapped with
+      // this value.
+      string host_rewrite_literal = 11
+          [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+    }
+  }
+
+  // Specifies one or more upstream clusters associated with the route.
+  repeated ClusterWeight clusters = 1 [(validate.rules).repeated = {min_items: 1}];
+
+  // Specifies the total weight across all clusters. The sum of all cluster weights must equal this
+  // value, if this is greater than 0.
+  // This field is now deprecated, and the client will use the sum of all
+  // cluster weights. It is up to the management server to supply the correct weights.
+  google.protobuf.UInt32Value total_weight = 3
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Specifies the runtime key prefix that should be used to construct the
+  // runtime keys associated with each cluster. When the ``runtime_key_prefix`` is
+  // specified, the router will look for weights associated with each upstream
+  // cluster under the key ``runtime_key_prefix`` + ``.`` + ``cluster[i].name`` where
+  // ``cluster[i]`` denotes an entry in the clusters array field. If the runtime
+  // key for the cluster does not exist, the value specified in the
+  // configuration file will be used as the default weight. See the :ref:`runtime documentation
+  // <operations_runtime>` for how key names map to the underlying implementation.
+  string runtime_key_prefix = 2;
+
+  oneof random_value_specifier {
+    // Specifies the header name that is used to look up the random value passed in the request header.
+    // This is used to ensure consistent cluster picking across multiple proxy levels for weighted traffic.
+    // If header is not present or invalid, Envoy will fall back to use the internally generated random value.
+    // This header is expected to be single-valued header as we only want to have one selected value throughout
+    // the process for the consistency. And the value is a unsigned number between 0 and UINT64_MAX.
+    string header_name = 4
+        [(validate.rules).string = {well_known_regex: HTTP_HEADER_NAME strict: false}];
+
+    // When set to true, the hash policies will be used to generate the random value for weighted cluster selection.
+    // This could ensure consistent cluster picking across multiple proxy levels for weighted traffic.
+    google.protobuf.BoolValue use_hash_policy = 5;
+  }
+}
+
+// Configuration for a cluster specifier plugin.
+message ClusterSpecifierPlugin {
+  // The name of the plugin and its opaque configuration.
+  //
+  // [#extension-category: envoy.router.cluster_specifier_plugin]
+  core.v3.TypedExtensionConfig extension = 1 [(validate.rules).message = {required: true}];
+
+  // If is_optional is not set or is set to false and the plugin defined by this message is not a
+  // supported type, the containing resource is NACKed. If is_optional is set to true, the resource
+  // would not be NACKed for this reason. In this case, routes referencing this plugin's name would
+  // not be treated as an illegal configuration, but would result in a failure if the route is
+  // selected.
+  bool is_optional = 2;
+}
+
+// [#next-free-field: 17]
+message RouteMatch {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.RouteMatch";
+
+  message GrpcRouteMatchOptions {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.route.RouteMatch.GrpcRouteMatchOptions";
+  }
+
+  message TlsContextMatchOptions {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.route.RouteMatch.TlsContextMatchOptions";
+
+    // If specified, the route will match against whether or not a certificate is presented.
+    // If not specified, certificate presentation status (true or false) will not be considered when route matching.
+    google.protobuf.BoolValue presented = 1;
+
+    // If specified, the route will match against whether or not a certificate is validated.
+    // If not specified, certificate validation status (true or false) will not be considered when route matching.
+    //
+    // .. warning::
+    //
+    //    Client certificate validation is not currently performed upon TLS session resumption. For
+    //    a resumed TLS session the route will match only when ``validated`` is false, regardless of
+    //    whether the client TLS certificate is valid.
+    //
+    //    The only known workaround for this issue is to disable TLS session resumption entirely, by
+    //    setting both :ref:`disable_stateless_session_resumption <envoy_v3_api_field_extensions.transport_sockets.tls.v3.DownstreamTlsContext.disable_stateless_session_resumption>`
+    //    and :ref:`disable_stateful_session_resumption <envoy_v3_api_field_extensions.transport_sockets.tls.v3.DownstreamTlsContext.disable_stateful_session_resumption>` on the DownstreamTlsContext.
+    google.protobuf.BoolValue validated = 2;
+  }
+
+  // An extensible message for matching CONNECT or CONNECT-UDP requests.
+  message ConnectMatcher {
+  }
+
+  reserved 5, 3;
+
+  reserved "regex";
+
+  oneof path_specifier {
+    option (validate.required) = true;
+
+    // If specified, the route is a prefix rule meaning that the prefix must
+    // match the beginning of the ``:path`` header.
+    string prefix = 1;
+
+    // If specified, the route is an exact path rule meaning that the path must
+    // exactly match the ``:path`` header once the query string is removed.
+    string path = 2;
+
+    // If specified, the route is a regular expression rule meaning that the
+    // regex must match the ``:path`` header once the query string is removed. The entire path
+    // (without the query string) must match the regex. The rule will not match if only a
+    // subsequence of the ``:path`` header matches the regex.
+    //
+    // [#next-major-version: In the v3 API we should redo how path specification works such
+    // that we utilize StringMatcher, and additionally have consistent options around whether we
+    // strip query strings, do a case sensitive match, etc. In the interim it will be too disruptive
+    // to deprecate the existing options. We should even consider whether we want to do away with
+    // path_specifier entirely and just rely on a set of header matchers which can already match
+    // on :path, etc. The issue with that is it is unclear how to generically deal with query string
+    // stripping. This needs more thought.]
+    type.matcher.v3.RegexMatcher safe_regex = 10 [(validate.rules).message = {required: true}];
+
+    // If this is used as the matcher, the matcher will only match CONNECT or CONNECT-UDP requests.
+    // Note that this will not match other Extended CONNECT requests (WebSocket and the like) as
+    // they are normalized in Envoy as HTTP/1.1 style upgrades.
+    // This is the only way to match CONNECT requests for HTTP/1.1. For HTTP/2 and HTTP/3,
+    // where Extended CONNECT requests may have a path, the path matchers will work if
+    // there is a path present.
+    // Note that CONNECT support is currently considered alpha in Envoy.
+    // [#comment: TODO(htuch): Replace the above comment with an alpha tag.]
+    ConnectMatcher connect_matcher = 12;
+
+    // If specified, the route is a path-separated prefix rule meaning that the
+    // ``:path`` header (without the query string) must either exactly match the
+    // ``path_separated_prefix`` or have it as a prefix, followed by ``/``
+    //
+    // For example, ``/api/dev`` would match
+    // ``/api/dev``, ``/api/dev/``, ``/api/dev/v1``, and ``/api/dev?param=true``
+    // but would not match ``/api/developer``
+    //
+    // Expect the value to not contain ``?`` or ``#`` and not to end in ``/``
+    string path_separated_prefix = 14 [(validate.rules).string = {pattern: "^[^?#]+[^?#/]$"}];
+
+    // [#extension-category: envoy.path.match]
+    core.v3.TypedExtensionConfig path_match_policy = 15;
+  }
+
+  // Indicates that prefix/path matching should be case sensitive. The default
+  // is true. Ignored for safe_regex matching.
+  google.protobuf.BoolValue case_sensitive = 4;
+
+  // Indicates that the route should additionally match on a runtime key. Every time the route
+  // is considered for a match, it must also fall under the percentage of matches indicated by
+  // this field. For some fraction N/D, a random number in the range [0,D) is selected. If the
+  // number is <= the value of the numerator N, or if the key is not present, the default
+  // value, the router continues to evaluate the remaining match criteria. A runtime_fraction
+  // route configuration can be used to roll out route changes in a gradual manner without full
+  // code/config deploys. Refer to the :ref:`traffic shifting
+  // <config_http_conn_man_route_table_traffic_splitting_shift>` docs for additional documentation.
+  //
+  // .. note::
+  //
+  //    Parsing this field is implemented such that the runtime key's data may be represented
+  //    as a FractionalPercent proto represented as JSON/YAML and may also be represented as an
+  //    integer with the assumption that the value is an integral percentage out of 100. For
+  //    instance, a runtime key lookup returning the value "42" would parse as a FractionalPercent
+  //    whose numerator is 42 and denominator is HUNDRED. This preserves legacy semantics.
+  core.v3.RuntimeFractionalPercent runtime_fraction = 9;
+
+  // Specifies a set of headers that the route should match on. The router will
+  // check the request’s headers against all the specified headers in the route
+  // config. A match will happen if all the headers in the route are present in
+  // the request with the same values (or based on presence if the value field
+  // is not in the config).
+  repeated HeaderMatcher headers = 6;
+
+  // Specifies a set of URL query parameters on which the route should
+  // match. The router will check the query string from the ``path`` header
+  // against all the specified query parameters. If the number of specified
+  // query parameters is nonzero, they all must match the ``path`` header's
+  // query string for a match to occur. In the event query parameters are
+  // repeated, only the first value for each key will be considered.
+  //
+  // .. note::
+  //
+  //    If query parameters are used to pass request message fields when
+  //    `grpc_json_transcoder <https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_filters/grpc_json_transcoder_filter>`_
+  //    is used, the transcoded message fields maybe different. The query parameters are
+  //    url encoded, but the message fields are not. For example, if a query
+  //    parameter is "foo%20bar", the message field will be "foo bar".
+  repeated QueryParameterMatcher query_parameters = 7;
+
+  // If specified, only gRPC requests will be matched. The router will check
+  // that the content-type header has a application/grpc or one of the various
+  // application/grpc+ values.
+  GrpcRouteMatchOptions grpc = 8;
+
+  // If specified, the client tls context will be matched against the defined
+  // match options.
+  //
+  // [#next-major-version: unify with RBAC]
+  TlsContextMatchOptions tls_context = 11;
+
+  // Specifies a set of dynamic metadata matchers on which the route should match.
+  // The router will check the dynamic metadata against all the specified dynamic metadata matchers.
+  // If the number of specified dynamic metadata matchers is nonzero, they all must match the
+  // dynamic metadata for a match to occur.
+  repeated type.matcher.v3.MetadataMatcher dynamic_metadata = 13;
+
+  // Specifies a set of filter state matchers on which the route should match.
+  // The router will check the filter state against all the specified filter state matchers.
+  // If the number of specified filter state matchers is nonzero, they all must match the
+  // filter state for a match to occur.
+  repeated type.matcher.v3.FilterStateMatcher filter_state = 16;
+}
+
+// Cors policy configuration.
+//
+// .. attention::
+//
+//   This message has been deprecated. Please use
+//   :ref:`CorsPolicy in filter extension <envoy_v3_api_msg_extensions.filters.http.cors.v3.CorsPolicy>`
+//   as as alternative.
+//
+// [#next-free-field: 14]
+message CorsPolicy {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.CorsPolicy";
+
+  reserved 1, 8, 7;
+
+  reserved "allow_origin", "allow_origin_regex", "enabled";
+
+  // Specifies string patterns that match allowed origins. An origin is allowed if any of the
+  // string matchers match.
+  repeated type.matcher.v3.StringMatcher allow_origin_string_match = 11;
+
+  // Specifies the content for the ``access-control-allow-methods`` header.
+  string allow_methods = 2;
+
+  // Specifies the content for the ``access-control-allow-headers`` header.
+  string allow_headers = 3;
+
+  // Specifies the content for the ``access-control-expose-headers`` header.
+  string expose_headers = 4;
+
+  // Specifies the content for the ``access-control-max-age`` header.
+  string max_age = 5;
+
+  // Specifies whether the resource allows credentials.
+  google.protobuf.BoolValue allow_credentials = 6;
+
+  oneof enabled_specifier {
+    // Specifies the % of requests for which the CORS filter is enabled.
+    //
+    // If neither ``enabled``, ``filter_enabled``, nor ``shadow_enabled`` are specified, the CORS
+    // filter will be enabled for 100% of the requests.
+    //
+    // If :ref:`runtime_key <envoy_v3_api_field_config.core.v3.RuntimeFractionalPercent.runtime_key>` is
+    // specified, Envoy will lookup the runtime key to get the percentage of requests to filter.
+    core.v3.RuntimeFractionalPercent filter_enabled = 9;
+  }
+
+  // Specifies the % of requests for which the CORS policies will be evaluated and tracked, but not
+  // enforced.
+  //
+  // This field is intended to be used when ``filter_enabled`` and ``enabled`` are off. One of those
+  // fields have to explicitly disable the filter in order for this setting to take effect.
+  //
+  // If :ref:`runtime_key <envoy_v3_api_field_config.core.v3.RuntimeFractionalPercent.runtime_key>` is specified,
+  // Envoy will lookup the runtime key to get the percentage of requests for which it will evaluate
+  // and track the request's ``Origin`` to determine if it's valid but will not enforce any policies.
+  core.v3.RuntimeFractionalPercent shadow_enabled = 10;
+
+  // Specify whether allow requests whose target server's IP address is more private than that from
+  // which the request initiator was fetched.
+  //
+  // More details refer to https://developer.chrome.com/blog/private-network-access-preflight.
+  google.protobuf.BoolValue allow_private_network_access = 12;
+
+  // Specifies if preflight requests not matching the configured allowed origin should be forwarded
+  // to the upstream. Default is true.
+  google.protobuf.BoolValue forward_not_matching_preflights = 13;
+}
+
+// [#next-free-field: 43]
+message RouteAction {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.RouteAction";
+
+  enum ClusterNotFoundResponseCode {
+    // HTTP status code - 503 Service Unavailable.
+    SERVICE_UNAVAILABLE = 0;
+
+    // HTTP status code - 404 Not Found.
+    NOT_FOUND = 1;
+
+    // HTTP status code - 500 Internal Server Error.
+    INTERNAL_SERVER_ERROR = 2;
+  }
+
+  // Configures :ref:`internal redirect <arch_overview_internal_redirects>` behavior.
+  // [#next-major-version: remove this definition - it's defined in the InternalRedirectPolicy message.]
+  enum InternalRedirectAction {
+    option deprecated = true;
+
+    PASS_THROUGH_INTERNAL_REDIRECT = 0;
+    HANDLE_INTERNAL_REDIRECT = 1;
+  }
+
+  // The router is capable of shadowing traffic from one cluster to another. The current
+  // implementation is "fire and forget," meaning Envoy will not wait for the shadow cluster to
+  // respond before returning the response from the primary cluster. All normal statistics are
+  // collected for the shadow cluster making this feature useful for testing.
+  //
+  // During shadowing, the host/authority header is altered such that ``-shadow`` is appended. This is
+  // useful for logging. For example, ``cluster1`` becomes ``cluster1-shadow``. This behavior can be
+  // disabled by setting ``disable_shadow_host_suffix_append`` to ``true``.
+  //
+  // .. note::
+  //
+  //   Shadowing will not be triggered if the primary cluster does not exist.
+  //
+  // .. note::
+  //
+  //   Shadowing doesn't support Http CONNECT and upgrades.
+  // [#next-free-field: 7]
+  message RequestMirrorPolicy {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.route.RouteAction.RequestMirrorPolicy";
+
+    reserved 2;
+
+    reserved "runtime_key";
+
+    // Only one of ``cluster`` and ``cluster_header`` can be specified.
+    // [#next-major-version: Need to add back the validation rule: (validate.rules).string = {min_len: 1}]
+    // Specifies the cluster that requests will be mirrored to. The cluster must
+    // exist in the cluster manager configuration.
+    string cluster = 1 [(udpa.annotations.field_migrate).oneof_promotion = "cluster_specifier"];
+
+    // Only one of ``cluster`` and ``cluster_header`` can be specified.
+    // Envoy will determine the cluster to route to by reading the value of the
+    // HTTP header named by cluster_header from the request headers. Only the first value in header is used,
+    // and no shadow request will happen if the value is not found in headers. Envoy will not wait for
+    // the shadow cluster to respond before returning the response from the primary cluster.
+    //
+    // .. attention::
+    //
+    //   Internally, Envoy always uses the HTTP/2 ``:authority`` header to represent the HTTP/1
+    //   ``Host`` header. Thus, if attempting to match on ``Host``, match on ``:authority`` instead.
+    //
+    // .. note::
+    //
+    //   If the header appears multiple times only the first value is used.
+    string cluster_header = 5 [
+      (validate.rules).string = {well_known_regex: HTTP_HEADER_NAME strict: false},
+      (udpa.annotations.field_migrate).oneof_promotion = "cluster_specifier"
+    ];
+
+    // If not specified, all requests to the target cluster will be mirrored.
+    //
+    // If specified, this field takes precedence over the ``runtime_key`` field and requests must also
+    // fall under the percentage of matches indicated by this field.
+    //
+    // For some fraction N/D, a random number in the range [0,D) is selected. If the
+    // number is <= the value of the numerator N, or if the key is not present, the default
+    // value, the request will be mirrored.
+    core.v3.RuntimeFractionalPercent runtime_fraction = 3;
+
+    // Specifies whether the trace span for the shadow request should be sampled. If this field is not explicitly set,
+    // the shadow request will inherit the sampling decision of its parent span. This ensures consistency with the trace
+    // sampling policy of the original request and prevents oversampling, especially in scenarios where runtime sampling
+    // is disabled.
+    google.protobuf.BoolValue trace_sampled = 4;
+
+    // Disables appending the ``-shadow`` suffix to the shadowed ``Host`` header. Defaults to ``false``.
+    bool disable_shadow_host_suffix_append = 6;
+  }
+
+  // Specifies the route's hashing policy if the upstream cluster uses a hashing :ref:`load balancer
+  // <arch_overview_load_balancing_types>`.
+  // [#next-free-field: 7]
+  message HashPolicy {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.route.RouteAction.HashPolicy";
+
+    message Header {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.route.RouteAction.HashPolicy.Header";
+
+      // The name of the request header that will be used to obtain the hash
+      // key. If the request header is not present, no hash will be produced.
+      string header_name = 1
+          [(validate.rules).string = {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}];
+
+      // If specified, the request header value will be rewritten and used
+      // to produce the hash key.
+      type.matcher.v3.RegexMatchAndSubstitute regex_rewrite = 2;
+    }
+
+    // CookieAttribute defines an API for adding additional attributes for a HTTP cookie.
+    message CookieAttribute {
+      // The name of the cookie attribute.
+      string name = 1
+          [(validate.rules).string =
+               {min_len: 1 max_bytes: 16384 well_known_regex: HTTP_HEADER_NAME strict: false}];
+
+      // The optional value of the cookie attribute.
+      string value = 2 [(validate.rules).string =
+                            {max_bytes: 16384 well_known_regex: HTTP_HEADER_VALUE strict: false}];
+    }
+
+    // Envoy supports two types of cookie affinity:
+    //
+    // 1. Passive. Envoy takes a cookie that's present in the cookies header and
+    //    hashes on its value.
+    //
+    // 2. Generated. Envoy generates and sets a cookie with an expiration (TTL)
+    //    on the first request from the client in its response to the client,
+    //    based on the endpoint the request gets sent to. The client then
+    //    presents this on the next and all subsequent requests. The hash of
+    //    this is sufficient to ensure these requests get sent to the same
+    //    endpoint. The cookie is generated by hashing the source and
+    //    destination ports and addresses so that multiple independent HTTP2
+    //    streams on the same connection will independently receive the same
+    //    cookie, even if they arrive at the Envoy simultaneously.
+    message Cookie {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.route.RouteAction.HashPolicy.Cookie";
+
+      // The name of the cookie that will be used to obtain the hash key. If the
+      // cookie is not present and ttl below is not set, no hash will be
+      // produced.
+      string name = 1 [(validate.rules).string = {min_len: 1}];
+
+      // If specified, a cookie with the TTL will be generated if the cookie is
+      // not present. If the TTL is present and zero, the generated cookie will
+      // be a session cookie.
+      google.protobuf.Duration ttl = 2;
+
+      // The name of the path for the cookie. If no path is specified here, no path
+      // will be set for the cookie.
+      string path = 3;
+
+      // Additional attributes for the cookie. They will be used when generating a new cookie.
+      repeated CookieAttribute attributes = 4;
+    }
+
+    message ConnectionProperties {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.route.RouteAction.HashPolicy.ConnectionProperties";
+
+      // Hash on source IP address.
+      bool source_ip = 1;
+    }
+
+    message QueryParameter {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.route.RouteAction.HashPolicy.QueryParameter";
+
+      // The name of the URL query parameter that will be used to obtain the hash
+      // key. If the parameter is not present, no hash will be produced. Query
+      // parameter names are case-sensitive. If query parameters are repeated, only
+      // the first value will be considered.
+      string name = 1 [(validate.rules).string = {min_len: 1}];
+    }
+
+    message FilterState {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.route.RouteAction.HashPolicy.FilterState";
+
+      // The name of the Object in the per-request filterState, which is an
+      // Envoy::Hashable object. If there is no data associated with the key,
+      // or the stored object is not Envoy::Hashable, no hash will be produced.
+      string key = 1 [(validate.rules).string = {min_len: 1}];
+    }
+
+    oneof policy_specifier {
+      option (validate.required) = true;
+
+      // Header hash policy.
+      Header header = 1;
+
+      // Cookie hash policy.
+      Cookie cookie = 2;
+
+      // Connection properties hash policy.
+      ConnectionProperties connection_properties = 3;
+
+      // Query parameter hash policy.
+      QueryParameter query_parameter = 5;
+
+      // Filter state hash policy.
+      FilterState filter_state = 6;
+    }
+
+    // The flag that short-circuits the hash computing. This field provides a
+    // 'fallback' style of configuration: "if a terminal policy doesn't work,
+    // fallback to rest of the policy list", it saves time when the terminal
+    // policy works.
+    //
+    // If true, and there is already a hash computed, ignore rest of the
+    // list of hash polices.
+    // For example, if the following hash methods are configured:
+    //
+    //  ========= ========
+    //  specifier terminal
+    //  ========= ========
+    //  Header A  true
+    //  Header B  false
+    //  Header C  false
+    //  ========= ========
+    //
+    // The generateHash process ends if policy "header A" generates a hash, as
+    // it's a terminal policy.
+    bool terminal = 4;
+  }
+
+  // Allows enabling and disabling upgrades on a per-route basis.
+  // This overrides any enabled/disabled upgrade filter chain specified in the
+  // HttpConnectionManager
+  // :ref:`upgrade_configs
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.upgrade_configs>`
+  // but does not affect any custom filter chain specified there.
+  message UpgradeConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.route.RouteAction.UpgradeConfig";
+
+    // Configuration for sending data upstream as a raw data payload. This is used for
+    // CONNECT or POST requests, when forwarding request payload as raw TCP.
+    message ConnectConfig {
+      // If present, the proxy protocol header will be prepended to the CONNECT payload sent upstream.
+      core.v3.ProxyProtocolConfig proxy_protocol_config = 1;
+
+      // If set, the route will also allow forwarding POST payload as raw TCP.
+      bool allow_post = 2;
+    }
+
+    // The case-insensitive name of this upgrade, e.g. "websocket".
+    // For each upgrade type present in upgrade_configs, requests with
+    // Upgrade: [upgrade_type] will be proxied upstream.
+    string upgrade_type = 1
+        [(validate.rules).string = {min_len: 1 well_known_regex: HTTP_HEADER_VALUE strict: false}];
+
+    // Determines if upgrades are available on this route. Defaults to true.
+    google.protobuf.BoolValue enabled = 2;
+
+    // Configuration for sending data upstream as a raw data payload. This is used for
+    // CONNECT requests, when forwarding CONNECT payload as raw TCP.
+    // Note that CONNECT support is currently considered alpha in Envoy.
+    // [#comment: TODO(htuch): Replace the above comment with an alpha tag.]
+    ConnectConfig connect_config = 3;
+  }
+
+  message MaxStreamDuration {
+    // Specifies the maximum duration allowed for streams on the route. If not specified, the value
+    // from the :ref:`max_stream_duration
+    // <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_stream_duration>` field in
+    // :ref:`HttpConnectionManager.common_http_protocol_options
+    // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.common_http_protocol_options>`
+    // is used. If this field is set explicitly to zero, any
+    // HttpConnectionManager max_stream_duration timeout will be disabled for
+    // this route.
+    google.protobuf.Duration max_stream_duration = 1;
+
+    // If present, and the request contains a `grpc-timeout header
+    // <https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md>`_, use that value as the
+    // ``max_stream_duration``, but limit the applied timeout to the maximum value specified here.
+    // If set to 0, the ``grpc-timeout`` header is used without modification.
+    google.protobuf.Duration grpc_timeout_header_max = 2;
+
+    // If present, Envoy will adjust the timeout provided by the ``grpc-timeout`` header by
+    // subtracting the provided duration from the header. This is useful for allowing Envoy to set
+    // its global timeout to be less than that of the deadline imposed by the calling client, which
+    // makes it more likely that Envoy will handle the timeout instead of having the call canceled
+    // by the client. If, after applying the offset, the resulting timeout is zero or negative,
+    // the stream will timeout immediately.
+    google.protobuf.Duration grpc_timeout_header_offset = 3;
+  }
+
+  reserved 12, 18, 19, 16, 22, 21, 10;
+
+  reserved "request_mirror_policy";
+
+  oneof cluster_specifier {
+    option (validate.required) = true;
+
+    // Indicates the upstream cluster to which the request should be routed
+    // to.
+    string cluster = 1 [(validate.rules).string = {min_len: 1}];
+
+    // Envoy will determine the cluster to route to by reading the value of the
+    // HTTP header named by cluster_header from the request headers. If the
+    // header is not found or the referenced cluster does not exist, Envoy will
+    // return a 404 response.
+    //
+    // .. attention::
+    //
+    //   Internally, Envoy always uses the HTTP/2 ``:authority`` header to represent the HTTP/1
+    //   ``Host`` header. Thus, if attempting to match on ``Host``, match on ``:authority`` instead.
+    //
+    // .. note::
+    //
+    //   If the header appears multiple times only the first value is used.
+    string cluster_header = 2
+        [(validate.rules).string = {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}];
+
+    // Multiple upstream clusters can be specified for a given route. The
+    // request is routed to one of the upstream clusters based on weights
+    // assigned to each cluster. See
+    // :ref:`traffic splitting <config_http_conn_man_route_table_traffic_splitting_split>`
+    // for additional documentation.
+    WeightedCluster weighted_clusters = 3;
+
+    // Name of the cluster specifier plugin to use to determine the cluster for requests on this route.
+    // The cluster specifier plugin name must be defined in the associated
+    // :ref:`cluster specifier plugins <envoy_v3_api_field_config.route.v3.RouteConfiguration.cluster_specifier_plugins>`
+    // in the :ref:`name <envoy_v3_api_field_config.core.v3.TypedExtensionConfig.name>` field.
+    string cluster_specifier_plugin = 37;
+
+    // Custom cluster specifier plugin configuration to use to determine the cluster for requests
+    // on this route.
+    ClusterSpecifierPlugin inline_cluster_specifier_plugin = 39;
+  }
+
+  // The HTTP status code to use when configured cluster is not found.
+  // The default response code is 503 Service Unavailable.
+  ClusterNotFoundResponseCode cluster_not_found_response_code = 20
+      [(validate.rules).enum = {defined_only: true}];
+
+  // Optional endpoint metadata match criteria used by the subset load balancer. Only endpoints
+  // in the upstream cluster with metadata matching what's set in this field will be considered
+  // for load balancing. If using :ref:`weighted_clusters
+  // <envoy_v3_api_field_config.route.v3.RouteAction.weighted_clusters>`, metadata will be merged, with values
+  // provided there taking precedence. The filter name should be specified as ``envoy.lb``.
+  core.v3.Metadata metadata_match = 4;
+
+  // Indicates that during forwarding, the matched prefix (or path) should be
+  // swapped with this value. This option allows application URLs to be rooted
+  // at a different path from those exposed at the reverse proxy layer. The router filter will
+  // place the original path before rewrite into the :ref:`x-envoy-original-path
+  // <config_http_filters_router_x-envoy-original-path>` header.
+  //
+  // Only one of :ref:`regex_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.regex_rewrite>`
+  // :ref:`path_rewrite_policy <envoy_v3_api_field_config.route.v3.RouteAction.path_rewrite_policy>`,
+  // or :ref:`prefix_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.prefix_rewrite>` may be specified.
+  //
+  // .. attention::
+  //
+  //   Pay careful attention to the use of trailing slashes in the
+  //   :ref:`route's match <envoy_v3_api_field_config.route.v3.Route.match>` prefix value.
+  //   Stripping a prefix from a path requires multiple Routes to handle all cases. For example,
+  //   rewriting ``/prefix`` to ``/`` and ``/prefix/etc`` to ``/etc`` cannot be done in a single
+  //   :ref:`Route <envoy_v3_api_msg_config.route.v3.Route>`, as shown by the below config entries:
+  //
+  //   .. code-block:: yaml
+  //
+  //     - match:
+  //         prefix: "/prefix/"
+  //       route:
+  //         prefix_rewrite: "/"
+  //     - match:
+  //         prefix: "/prefix"
+  //       route:
+  //         prefix_rewrite: "/"
+  //
+  //   Having above entries in the config, requests to ``/prefix`` will be stripped to ``/``, while
+  //   requests to ``/prefix/etc`` will be stripped to ``/etc``.
+  string prefix_rewrite = 5
+      [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+
+  // Indicates that during forwarding, portions of the path that match the
+  // pattern should be rewritten, even allowing the substitution of capture
+  // groups from the pattern into the new path as specified by the rewrite
+  // substitution string. This is useful to allow application paths to be
+  // rewritten in a way that is aware of segments with variable content like
+  // identifiers. The router filter will place the original path as it was
+  // before the rewrite into the :ref:`x-envoy-original-path
+  // <config_http_filters_router_x-envoy-original-path>` header.
+  //
+  // Only one of :ref:`regex_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.regex_rewrite>`,
+  // :ref:`prefix_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.prefix_rewrite>`, or
+  // :ref:`path_rewrite_policy <envoy_v3_api_field_config.route.v3.RouteAction.path_rewrite_policy>`]
+  // may be specified.
+  //
+  // Examples using Google's `RE2 <https://github.com/google/re2>`_ engine:
+  //
+  // * The path pattern ``^/service/([^/]+)(/.*)$`` paired with a substitution
+  //   string of ``\2/instance/\1`` would transform ``/service/foo/v1/api``
+  //   into ``/v1/api/instance/foo``.
+  //
+  // * The pattern ``one`` paired with a substitution string of ``two`` would
+  //   transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``.
+  //
+  // * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of
+  //   ``\1two\2`` would replace only the first occurrence of ``one``,
+  //   transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``.
+  //
+  // * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/``
+  //   would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
+  //   ``/aaa/yyy/bbb``.
+  type.matcher.v3.RegexMatchAndSubstitute regex_rewrite = 32;
+
+  // [#extension-category: envoy.path.rewrite]
+  core.v3.TypedExtensionConfig path_rewrite_policy = 41;
+
+  // If one of the host rewrite specifiers is set and the
+  // :ref:`suppress_envoy_headers
+  // <envoy_v3_api_field_extensions.filters.http.router.v3.Router.suppress_envoy_headers>` flag is not
+  // set to true, the router filter will place the original host header value before
+  // rewriting into the :ref:`x-envoy-original-host
+  // <config_http_filters_router_x-envoy-original-host>` header.
+  //
+  // And if the
+  // :ref:`append_x_forwarded_host <envoy_v3_api_field_config.route.v3.RouteAction.append_x_forwarded_host>`
+  // is set to true, the original host value will also be appended to the
+  // :ref:`config_http_conn_man_headers_x-forwarded-host` header.
+  //
+  oneof host_rewrite_specifier {
+    // Indicates that during forwarding, the host header will be swapped with
+    // this value.
+    string host_rewrite_literal = 6
+        [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+
+    // Indicates that during forwarding, the host header will be swapped with
+    // the hostname of the upstream host chosen by the cluster manager. This
+    // option is applicable only when the destination cluster for a route is of
+    // type ``strict_dns`` or ``logical_dns``,
+    // or when :ref:`hostname <envoy_v3_api_field_config.endpoint.v3.Endpoint.hostname>`
+    // field is not empty. Setting this to true with other cluster types
+    // has no effect.
+    google.protobuf.BoolValue auto_host_rewrite = 7;
+
+    // Indicates that during forwarding, the host header will be swapped with the content of given
+    // downstream or :ref:`custom <config_http_conn_man_headers_custom_request_headers>` header.
+    // If header value is empty, host header is left intact.
+    //
+    // .. attention::
+    //
+    //   Pay attention to the potential security implications of using this option. Provided header
+    //   must come from trusted source.
+    //
+    // .. note::
+    //
+    //   If the header appears multiple times only the first value is used.
+    string host_rewrite_header = 29
+        [(validate.rules).string = {well_known_regex: HTTP_HEADER_NAME strict: false}];
+
+    // Indicates that during forwarding, the host header will be swapped with
+    // the result of the regex substitution executed on path value with query and fragment removed.
+    // This is useful for transitioning variable content between path segment and subdomain.
+    //
+    // For example with the following config:
+    //
+    //   .. code-block:: yaml
+    //
+    //     host_rewrite_path_regex:
+    //       pattern:
+    //         google_re2: {}
+    //         regex: "^/(.+)/.+$"
+    //       substitution: \1
+    //
+    // Would rewrite the host header to ``envoyproxy.io`` given the path ``/envoyproxy.io/some/path``.
+    type.matcher.v3.RegexMatchAndSubstitute host_rewrite_path_regex = 35;
+  }
+
+  // If set, then a host rewrite action (one of
+  // :ref:`host_rewrite_literal <envoy_v3_api_field_config.route.v3.RouteAction.host_rewrite_literal>`,
+  // :ref:`auto_host_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.auto_host_rewrite>`,
+  // :ref:`host_rewrite_header <envoy_v3_api_field_config.route.v3.RouteAction.host_rewrite_header>`, or
+  // :ref:`host_rewrite_path_regex <envoy_v3_api_field_config.route.v3.RouteAction.host_rewrite_path_regex>`)
+  // causes the original value of the host header, if any, to be appended to the
+  // :ref:`config_http_conn_man_headers_x-forwarded-host` HTTP header if it is different to the last value appended.
+  bool append_x_forwarded_host = 38;
+
+  // Specifies the upstream timeout for the route. If not specified, the default is 15s. This
+  // spans between the point at which the entire downstream request (i.e. end-of-stream) has been
+  // processed and when the upstream response has been completely processed. A value of 0 will
+  // disable the route's timeout.
+  //
+  // .. note::
+  //
+  //   This timeout includes all retries. See also
+  //   :ref:`config_http_filters_router_x-envoy-upstream-rq-timeout-ms`,
+  //   :ref:`config_http_filters_router_x-envoy-upstream-rq-per-try-timeout-ms`, and the
+  //   :ref:`retry overview <arch_overview_http_routing_retry>`.
+  google.protobuf.Duration timeout = 8;
+
+  // Specifies the idle timeout for the route. If not specified, there is no per-route idle timeout,
+  // although the connection manager wide :ref:`stream_idle_timeout
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_idle_timeout>`
+  // will still apply. A value of 0 will completely disable the route's idle timeout, even if a
+  // connection manager stream idle timeout is configured.
+  //
+  // The idle timeout is distinct to :ref:`timeout
+  // <envoy_v3_api_field_config.route.v3.RouteAction.timeout>`, which provides an upper bound
+  // on the upstream response time; :ref:`idle_timeout
+  // <envoy_v3_api_field_config.route.v3.RouteAction.idle_timeout>` instead bounds the amount
+  // of time the request's stream may be idle.
+  //
+  // After header decoding, the idle timeout will apply on downstream and
+  // upstream request events. Each time an encode/decode event for headers or
+  // data is processed for the stream, the timer will be reset. If the timeout
+  // fires, the stream is terminated with a 408 Request Timeout error code if no
+  // upstream response header has been received, otherwise a stream reset
+  // occurs.
+  //
+  // If the :ref:`overload action <config_overload_manager_overload_actions>` "envoy.overload_actions.reduce_timeouts"
+  // is configured, this timeout is scaled according to the value for
+  // :ref:`HTTP_DOWNSTREAM_STREAM_IDLE <envoy_v3_api_enum_value_config.overload.v3.ScaleTimersOverloadActionConfig.TimerType.HTTP_DOWNSTREAM_STREAM_IDLE>`.
+  //
+  // This timeout may also be used in place of ``flush_timeout`` in very specific cases. See the
+  // documentation for ``flush_timeout`` for more details.
+  google.protobuf.Duration idle_timeout = 24;
+
+  // Specifies the codec stream flush timeout for the route.
+  //
+  // If not specified, the first preference is the global :ref:`stream_flush_timeout
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_flush_timeout>`,
+  // but only if explicitly configured.
+  //
+  // If neither the explicit HCM-wide flush timeout nor this route-specific flush timeout is configured,
+  // the route's stream idle timeout is reused for this timeout. This is for
+  // backwards compatibility since both behaviors were historically controlled by the one timeout.
+  //
+  // If the route also does not have an idle timeout configured, the global :ref:`stream_idle_timeout
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_idle_timeout>`. used, again
+  // for backwards compatibility. That timeout defaults to 5 minutes.
+  //
+  // A value of 0 via any of the above paths will completely disable the timeout for a given route.
+  google.protobuf.Duration flush_timeout = 42;
+
+  // Specifies how to send request over TLS early data.
+  // If absent, allows `safe HTTP requests <https://www.rfc-editor.org/rfc/rfc7231#section-4.2.1>`_ to be sent on early data.
+  // [#extension-category: envoy.route.early_data_policy]
+  core.v3.TypedExtensionConfig early_data_policy = 40;
+
+  // Indicates that the route has a retry policy. Note that if this is set,
+  // it'll take precedence over the virtual host level retry policy entirely
+  // (e.g.: policies are not merged, most internal one becomes the enforced policy).
+  RetryPolicy retry_policy = 9;
+
+  // [#not-implemented-hide:]
+  // Specifies the configuration for retry policy extension. Note that if this is set, it'll take
+  // precedence over the virtual host level retry policy entirely (e.g.: policies are not merged,
+  // most internal one becomes the enforced policy). :ref:`Retry policy <envoy_v3_api_field_config.route.v3.VirtualHost.retry_policy>`
+  // should not be set if this field is used.
+  google.protobuf.Any retry_policy_typed_config = 33;
+
+  // Specify a set of route request mirroring policies.
+  // It takes precedence over the virtual host and route config mirror policy entirely.
+  // That is, policies are not merged, the most specific non-empty one becomes the mirror policies.
+  repeated RequestMirrorPolicy request_mirror_policies = 30;
+
+  // Optionally specifies the :ref:`routing priority <arch_overview_http_routing_priority>`.
+  core.v3.RoutingPriority priority = 11 [(validate.rules).enum = {defined_only: true}];
+
+  // Specifies a set of rate limit configurations that could be applied to the
+  // route.
+  repeated RateLimit rate_limits = 13;
+
+  // Specifies if the rate limit filter should include the virtual host rate
+  // limits. By default, if the route configured rate limits, the virtual host
+  // :ref:`rate_limits <envoy_v3_api_field_config.route.v3.VirtualHost.rate_limits>` are not applied to the
+  // request.
+  //
+  // This field is deprecated. Please use :ref:`vh_rate_limits <envoy_v3_api_field_extensions.filters.http.ratelimit.v3.RateLimitPerRoute.vh_rate_limits>`
+  google.protobuf.BoolValue include_vh_rate_limits = 14
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Specifies a list of hash policies to use for ring hash load balancing. Each
+  // hash policy is evaluated individually and the combined result is used to
+  // route the request. The method of combination is deterministic such that
+  // identical lists of hash policies will produce the same hash. Since a hash
+  // policy examines specific parts of a request, it can fail to produce a hash
+  // (i.e. if the hashed header is not present). If (and only if) all configured
+  // hash policies fail to generate a hash, no hash will be produced for
+  // the route. In this case, the behavior is the same as if no hash policies
+  // were specified (i.e. the ring hash load balancer will choose a random
+  // backend). If a hash policy has the "terminal" attribute set to true, and
+  // there is already a hash generated, the hash is returned immediately,
+  // ignoring the rest of the hash policy list.
+  repeated HashPolicy hash_policy = 15;
+
+  // Indicates that the route has a CORS policy. This field is ignored if related cors policy is
+  // found in the :ref:`Route.typed_per_filter_config<envoy_v3_api_field_config.route.v3.Route.typed_per_filter_config>` or
+  // :ref:`WeightedCluster.ClusterWeight.typed_per_filter_config<envoy_v3_api_field_config.route.v3.WeightedCluster.ClusterWeight.typed_per_filter_config>`.
+  //
+  // .. attention::
+  //
+  //   This option has been deprecated. Please use
+  //   :ref:`Route.typed_per_filter_config<envoy_v3_api_field_config.route.v3.Route.typed_per_filter_config>` or
+  //   :ref:`WeightedCluster.ClusterWeight.typed_per_filter_config<envoy_v3_api_field_config.route.v3.WeightedCluster.ClusterWeight.typed_per_filter_config>`
+  //   to configure the CORS HTTP filter.
+  CorsPolicy cors = 17 [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Deprecated by :ref:`grpc_timeout_header_max <envoy_v3_api_field_config.route.v3.RouteAction.MaxStreamDuration.grpc_timeout_header_max>`
+  // If present, and the request is a gRPC request, use the
+  // `grpc-timeout header <https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md>`_,
+  // or its default value (infinity) instead of
+  // :ref:`timeout <envoy_v3_api_field_config.route.v3.RouteAction.timeout>`, but limit the applied timeout
+  // to the maximum value specified here. If configured as 0, the maximum allowed timeout for
+  // gRPC requests is infinity. If not configured at all, the ``grpc-timeout`` header is not used
+  // and gRPC requests time out like any other requests using
+  // :ref:`timeout <envoy_v3_api_field_config.route.v3.RouteAction.timeout>` or its default.
+  // This can be used to prevent unexpected upstream request timeouts due to potentially long
+  // time gaps between gRPC request and response in gRPC streaming mode.
+  //
+  // .. note::
+  //
+  //    If a timeout is specified using :ref:`config_http_filters_router_x-envoy-upstream-rq-timeout-ms`, it takes
+  //    precedence over `grpc-timeout header <https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md>`_, when
+  //    both are present. See also
+  //    :ref:`config_http_filters_router_x-envoy-upstream-rq-timeout-ms`,
+  //    :ref:`config_http_filters_router_x-envoy-upstream-rq-per-try-timeout-ms`, and the
+  //    :ref:`retry overview <arch_overview_http_routing_retry>`.
+  google.protobuf.Duration max_grpc_timeout = 23
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Deprecated by :ref:`grpc_timeout_header_offset <envoy_v3_api_field_config.route.v3.RouteAction.MaxStreamDuration.grpc_timeout_header_offset>`.
+  // If present, Envoy will adjust the timeout provided by the ``grpc-timeout`` header by subtracting
+  // the provided duration from the header. This is useful in allowing Envoy to set its global
+  // timeout to be less than that of the deadline imposed by the calling client, which makes it more
+  // likely that Envoy will handle the timeout instead of having the call canceled by the client.
+  // The offset will only be applied if the provided grpc_timeout is greater than the offset. This
+  // ensures that the offset will only ever decrease the timeout and never set it to 0 (meaning
+  // infinity).
+  google.protobuf.Duration grpc_timeout_offset = 28
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  repeated UpgradeConfig upgrade_configs = 25;
+
+  // If present, Envoy will try to follow an upstream redirect response instead of proxying the
+  // response back to the downstream. An upstream redirect response is defined
+  // by :ref:`redirect_response_codes
+  // <envoy_v3_api_field_config.route.v3.InternalRedirectPolicy.redirect_response_codes>`.
+  InternalRedirectPolicy internal_redirect_policy = 34;
+
+  InternalRedirectAction internal_redirect_action = 26
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // An internal redirect is handled, iff the number of previous internal redirects that a
+  // downstream request has encountered is lower than this value, and
+  // :ref:`internal_redirect_action <envoy_v3_api_field_config.route.v3.RouteAction.internal_redirect_action>`
+  // is set to :ref:`HANDLE_INTERNAL_REDIRECT
+  // <envoy_v3_api_enum_value_config.route.v3.RouteAction.InternalRedirectAction.HANDLE_INTERNAL_REDIRECT>`
+  // In the case where a downstream request is bounced among multiple routes by internal redirect,
+  // the first route that hits this threshold, or has
+  // :ref:`internal_redirect_action <envoy_v3_api_field_config.route.v3.RouteAction.internal_redirect_action>`
+  // set to
+  // :ref:`PASS_THROUGH_INTERNAL_REDIRECT
+  // <envoy_v3_api_enum_value_config.route.v3.RouteAction.InternalRedirectAction.PASS_THROUGH_INTERNAL_REDIRECT>`
+  // will pass the redirect back to downstream.
+  //
+  // If not specified, at most one redirect will be followed.
+  google.protobuf.UInt32Value max_internal_redirects = 31
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Indicates that the route has a hedge policy. Note that if this is set,
+  // it'll take precedence over the virtual host level hedge policy entirely
+  // (e.g.: policies are not merged, most internal one becomes the enforced policy).
+  HedgePolicy hedge_policy = 27;
+
+  // Specifies the maximum stream duration for this route.
+  MaxStreamDuration max_stream_duration = 36;
+}
+
+// HTTP retry :ref:`architecture overview <arch_overview_http_routing_retry>`.
+// [#next-free-field: 14]
+message RetryPolicy {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.RetryPolicy";
+
+  enum ResetHeaderFormat {
+    SECONDS = 0;
+    UNIX_TIMESTAMP = 1;
+  }
+
+  message RetryPriority {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.route.RetryPolicy.RetryPriority";
+
+    reserved 2;
+
+    reserved "config";
+
+    string name = 1 [(validate.rules).string = {min_len: 1}];
+
+    // [#extension-category: envoy.retry_priorities]
+    oneof config_type {
+      google.protobuf.Any typed_config = 3;
+    }
+  }
+
+  message RetryHostPredicate {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.route.RetryPolicy.RetryHostPredicate";
+
+    reserved 2;
+
+    reserved "config";
+
+    string name = 1 [(validate.rules).string = {min_len: 1}];
+
+    // [#extension-category: envoy.retry_host_predicates]
+    oneof config_type {
+      google.protobuf.Any typed_config = 3;
+    }
+  }
+
+  message RetryBackOff {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.route.RetryPolicy.RetryBackOff";
+
+    // Specifies the base interval between retries. This parameter is required and must be greater
+    // than zero. Values less than 1 ms are rounded up to 1 ms.
+    // See :ref:`config_http_filters_router_x-envoy-max-retries` for a discussion of Envoy's
+    // back-off algorithm.
+    google.protobuf.Duration base_interval = 1 [(validate.rules).duration = {
+      required: true
+      gt {}
+    }];
+
+    // Specifies the maximum interval between retries. This parameter is optional, but must be
+    // greater than or equal to the ``base_interval`` if set. The default is 10 times the
+    // ``base_interval``. See :ref:`config_http_filters_router_x-envoy-max-retries` for a discussion
+    // of Envoy's back-off algorithm.
+    google.protobuf.Duration max_interval = 2 [(validate.rules).duration = {gt {}}];
+  }
+
+  message ResetHeader {
+    // The name of the reset header.
+    //
+    // .. note::
+    //
+    //   If the header appears multiple times only the first value is used.
+    string name = 1
+        [(validate.rules).string = {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}];
+
+    // The format of the reset header.
+    ResetHeaderFormat format = 2 [(validate.rules).enum = {defined_only: true}];
+  }
+
+  // A retry back-off strategy that applies when the upstream server rate limits
+  // the request.
+  //
+  // Given this configuration:
+  //
+  // .. code-block:: yaml
+  //
+  //   rate_limited_retry_back_off:
+  //     reset_headers:
+  //     - name: Retry-After
+  //       format: SECONDS
+  //     - name: X-RateLimit-Reset
+  //       format: UNIX_TIMESTAMP
+  //     max_interval: "300s"
+  //
+  // The following algorithm will apply:
+  //
+  //  1. If the response contains the header ``Retry-After`` its value must be on
+  //     the form ``120`` (an integer that represents the number of seconds to
+  //     wait before retrying). If so, this value is used as the back-off interval.
+  //  2. Otherwise, if the response contains the header ``X-RateLimit-Reset`` its
+  //     value must be on the form ``1595320702`` (an integer that represents the
+  //     point in time at which to retry, as a Unix timestamp in seconds). If so,
+  //     the current time is subtracted from this value and the result is used as
+  //     the back-off interval.
+  //  3. Otherwise, Envoy will use the default
+  //     :ref:`exponential back-off <envoy_v3_api_field_config.route.v3.RetryPolicy.retry_back_off>`
+  //     strategy.
+  //
+  // No matter which format is used, if the resulting back-off interval exceeds
+  // ``max_interval`` it is discarded and the next header in ``reset_headers``
+  // is tried. If a request timeout is configured for the route it will further
+  // limit how long the request will be allowed to run.
+  //
+  // To prevent many clients retrying at the same point in time jitter is added
+  // to the back-off interval, so the resulting interval is decided by taking:
+  // ``random(interval, interval * 1.5)``.
+  //
+  // .. attention::
+  //
+  //   Configuring ``rate_limited_retry_back_off`` will not by itself cause a request
+  //   to be retried. You will still need to configure the right retry policy to match
+  //   the responses from the upstream server.
+  message RateLimitedRetryBackOff {
+    // Specifies the reset headers (like ``Retry-After`` or ``X-RateLimit-Reset``)
+    // to match against the response. Headers are tried in order, and matched case
+    // insensitive. The first header to be parsed successfully is used. If no headers
+    // match the default exponential back-off is used instead.
+    repeated ResetHeader reset_headers = 1 [(validate.rules).repeated = {min_items: 1}];
+
+    // Specifies the maximum back off interval that Envoy will allow. If a reset
+    // header contains an interval longer than this then it will be discarded and
+    // the next header will be tried. Defaults to 300 seconds.
+    google.protobuf.Duration max_interval = 2 [(validate.rules).duration = {gt {}}];
+  }
+
+  // Specifies the conditions under which retry takes place. These are the same
+  // conditions documented for :ref:`config_http_filters_router_x-envoy-retry-on` and
+  // :ref:`config_http_filters_router_x-envoy-retry-grpc-on`.
+  string retry_on = 1;
+
+  // Specifies the allowed number of retries. This parameter is optional and
+  // defaults to 1. These are the same conditions documented for
+  // :ref:`config_http_filters_router_x-envoy-max-retries`.
+  google.protobuf.UInt32Value num_retries = 2
+      [(udpa.annotations.field_migrate).rename = "max_retries"];
+
+  // Specifies a non-zero upstream timeout per retry attempt (including the initial attempt). This
+  // parameter is optional. The same conditions documented for
+  // :ref:`config_http_filters_router_x-envoy-upstream-rq-per-try-timeout-ms` apply.
+  //
+  // .. note::
+  //
+  //   If left unspecified, Envoy will use the global
+  //   :ref:`route timeout <envoy_v3_api_field_config.route.v3.RouteAction.timeout>` for the request.
+  //   Consequently, when using a :ref:`5xx <config_http_filters_router_x-envoy-retry-on>` based
+  //   retry policy, a request that times out will not be retried as the total timeout budget
+  //   would have been exhausted.
+  google.protobuf.Duration per_try_timeout = 3;
+
+  // Specifies an upstream idle timeout per retry attempt (including the initial attempt). This
+  // parameter is optional and if absent there is no per try idle timeout. The semantics of the per
+  // try idle timeout are similar to the
+  // :ref:`route idle timeout <envoy_v3_api_field_config.route.v3.RouteAction.timeout>` and
+  // :ref:`stream idle timeout
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_idle_timeout>`
+  // both enforced by the HTTP connection manager. The difference is that this idle timeout
+  // is enforced by the router for each individual attempt and thus after all previous filters have
+  // run, as opposed to *before* all previous filters run for the other idle timeouts. This timeout
+  // is useful in cases in which total request timeout is bounded by a number of retries and a
+  // :ref:`per_try_timeout <envoy_v3_api_field_config.route.v3.RetryPolicy.per_try_timeout>`, but
+  // there is a desire to ensure each try is making incremental progress. Note also that similar
+  // to :ref:`per_try_timeout <envoy_v3_api_field_config.route.v3.RetryPolicy.per_try_timeout>`,
+  // this idle timeout does not start until after both the entire request has been received by the
+  // router *and* a connection pool connection has been obtained. Unlike
+  // :ref:`per_try_timeout <envoy_v3_api_field_config.route.v3.RetryPolicy.per_try_timeout>`,
+  // the idle timer continues once the response starts streaming back to the downstream client.
+  // This ensures that response data continues to make progress without using one of the HTTP
+  // connection manager idle timeouts.
+  google.protobuf.Duration per_try_idle_timeout = 13;
+
+  // Specifies an implementation of a RetryPriority which is used to determine the
+  // distribution of load across priorities used for retries. Refer to
+  // :ref:`retry plugin configuration <arch_overview_http_retry_plugins>` for more details.
+  RetryPriority retry_priority = 4;
+
+  // Specifies a collection of RetryHostPredicates that will be consulted when selecting a host
+  // for retries. If any of the predicates reject the host, host selection will be reattempted.
+  // Refer to :ref:`retry plugin configuration <arch_overview_http_retry_plugins>` for more
+  // details.
+  repeated RetryHostPredicate retry_host_predicate = 5;
+
+  // Retry options predicates that will be applied prior to retrying a request. These predicates
+  // allow customizing request behavior between retries.
+  // [#comment: add [#extension-category: envoy.retry_options_predicates] when there are built-in extensions]
+  repeated core.v3.TypedExtensionConfig retry_options_predicates = 12;
+
+  // The maximum number of times host selection will be reattempted before giving up, at which
+  // point the host that was last selected will be routed to. If unspecified, this will default to
+  // retrying once.
+  int64 host_selection_retry_max_attempts = 6;
+
+  // HTTP status codes that should trigger a retry in addition to those specified by retry_on.
+  repeated uint32 retriable_status_codes = 7;
+
+  // Specifies parameters that control exponential retry back off. This parameter is optional, in which case the
+  // default base interval is 25 milliseconds or, if set, the current value of the
+  // ``upstream.base_retry_backoff_ms`` runtime parameter. The default maximum interval is 10 times
+  // the base interval. The documentation for :ref:`config_http_filters_router_x-envoy-max-retries`
+  // describes Envoy's back-off algorithm.
+  RetryBackOff retry_back_off = 8;
+
+  // Specifies parameters that control a retry back-off strategy that is used
+  // when the request is rate limited by the upstream server. The server may
+  // return a response header like ``Retry-After`` or ``X-RateLimit-Reset`` to
+  // provide feedback to the client on how long to wait before retrying. If
+  // configured, this back-off strategy will be used instead of the
+  // default exponential back off strategy (configured using ``retry_back_off``)
+  // whenever a response includes the matching headers.
+  RateLimitedRetryBackOff rate_limited_retry_back_off = 11;
+
+  // HTTP response headers that trigger a retry if present in the response. A retry will be
+  // triggered if any of the header matches match the upstream response headers.
+  // The field is only consulted if 'retriable-headers' retry policy is active.
+  repeated HeaderMatcher retriable_headers = 9;
+
+  // HTTP headers which must be present in the request for retries to be attempted.
+  repeated HeaderMatcher retriable_request_headers = 10;
+}
+
+// HTTP request hedging :ref:`architecture overview <arch_overview_http_routing_hedging>`.
+message HedgePolicy {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.HedgePolicy";
+
+  // Specifies the number of initial requests that should be sent upstream.
+  // Must be at least 1.
+  // Defaults to 1.
+  // [#not-implemented-hide:]
+  google.protobuf.UInt32Value initial_requests = 1 [(validate.rules).uint32 = {gte: 1}];
+
+  // Specifies a probability that an additional upstream request should be sent
+  // on top of what is specified by initial_requests.
+  // Defaults to 0.
+  // [#not-implemented-hide:]
+  type.v3.FractionalPercent additional_request_chance = 2;
+
+  // Indicates that a hedged request should be sent when the per-try timeout is hit.
+  // This means that a retry will be issued without resetting the original request, leaving multiple upstream requests in flight.
+  // The first request to complete successfully will be the one returned to the caller.
+  //
+  // * At any time, a successful response (i.e. not triggering any of the retry-on conditions) would be returned to the client.
+  // * Before per-try timeout, an error response (per retry-on conditions) would be retried immediately or returned ot the client
+  //   if there are no more retries left.
+  // * After per-try timeout, an error response would be discarded, as a retry in the form of a hedged request is already in progress.
+  //
+  // Note: For this to have effect, you must have a :ref:`RetryPolicy <envoy_v3_api_msg_config.route.v3.RetryPolicy>` that retries at least
+  // one error code and specifies a maximum number of retries.
+  //
+  // Defaults to false.
+  bool hedge_on_per_try_timeout = 3;
+}
+
+// [#next-free-field: 10]
+message RedirectAction {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.RedirectAction";
+
+  enum RedirectResponseCode {
+    // Moved Permanently HTTP Status Code - 301.
+    MOVED_PERMANENTLY = 0;
+
+    // Found HTTP Status Code - 302.
+    FOUND = 1;
+
+    // See Other HTTP Status Code - 303.
+    SEE_OTHER = 2;
+
+    // Temporary Redirect HTTP Status Code - 307.
+    TEMPORARY_REDIRECT = 3;
+
+    // Permanent Redirect HTTP Status Code - 308.
+    PERMANENT_REDIRECT = 4;
+  }
+
+  // When the scheme redirection take place, the following rules apply:
+  //  1. If the source URI scheme is ``http`` and the port is explicitly
+  //     set to ``:80``, the port will be removed after the redirection
+  //  2. If the source URI scheme is ``https`` and the port is explicitly
+  //     set to ``:443``, the port will be removed after the redirection
+  oneof scheme_rewrite_specifier {
+    // The scheme portion of the URL will be swapped with "https".
+    bool https_redirect = 4;
+
+    // The scheme portion of the URL will be swapped with this value.
+    string scheme_redirect = 7;
+  }
+
+  // The host portion of the URL will be swapped with this value.
+  string host_redirect = 1
+      [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+
+  // The port value of the URL will be swapped with this value.
+  uint32 port_redirect = 8;
+
+  oneof path_rewrite_specifier {
+    // The path portion of the URL will be swapped with this value.
+    // Please note that query string in path_redirect will override the
+    // request's query string and will not be stripped.
+    //
+    // For example, let's say we have the following routes:
+    //
+    // - match: { path: "/old-path-1" }
+    //   redirect: { path_redirect: "/new-path-1" }
+    // - match: { path: "/old-path-2" }
+    //   redirect: { path_redirect: "/new-path-2", strip-query: "true" }
+    // - match: { path: "/old-path-3" }
+    //   redirect: { path_redirect: "/new-path-3?foo=1", strip_query: "true" }
+    //
+    // 1. if request uri is "/old-path-1?bar=1", users will be redirected to "/new-path-1?bar=1"
+    // 2. if request uri is "/old-path-2?bar=1", users will be redirected to "/new-path-2"
+    // 3. if request uri is "/old-path-3?bar=1", users will be redirected to "/new-path-3?foo=1"
+    string path_redirect = 2
+        [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+
+    // Indicates that during redirection, the matched prefix (or path)
+    // should be swapped with this value. This option allows redirect URLs be dynamically created
+    // based on the request.
+    //
+    // .. attention::
+    //
+    //   Pay attention to the use of trailing slashes as mentioned in
+    //   :ref:`RouteAction's prefix_rewrite <envoy_v3_api_field_config.route.v3.RouteAction.prefix_rewrite>`.
+    string prefix_rewrite = 5
+        [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+
+    // Indicates that during redirect, portions of the path that match the
+    // pattern should be rewritten, even allowing the substitution of capture
+    // groups from the pattern into the new path as specified by the rewrite
+    // substitution string. This is useful to allow application paths to be
+    // rewritten in a way that is aware of segments with variable content like
+    // identifiers.
+    //
+    // Examples using Google's `RE2 <https://github.com/google/re2>`_ engine:
+    //
+    // * The path pattern ``^/service/([^/]+)(/.*)$`` paired with a substitution
+    //   string of ``\2/instance/\1`` would transform ``/service/foo/v1/api``
+    //   into ``/v1/api/instance/foo``.
+    //
+    // * The pattern ``one`` paired with a substitution string of ``two`` would
+    //   transform ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/two/zzz``.
+    //
+    // * The pattern ``^(.*?)one(.*)$`` paired with a substitution string of
+    //   ``\1two\2`` would replace only the first occurrence of ``one``,
+    //   transforming path ``/xxx/one/yyy/one/zzz`` into ``/xxx/two/yyy/one/zzz``.
+    //
+    // * The pattern ``(?i)/xxx/`` paired with a substitution string of ``/yyy/``
+    //   would do a case-insensitive match and transform path ``/aaa/XxX/bbb`` to
+    //   ``/aaa/yyy/bbb``.
+    type.matcher.v3.RegexMatchAndSubstitute regex_rewrite = 9;
+  }
+
+  // The HTTP status code to use in the redirect response. The default response
+  // code is MOVED_PERMANENTLY (301).
+  RedirectResponseCode response_code = 3 [(validate.rules).enum = {defined_only: true}];
+
+  // Indicates that during redirection, the query portion of the URL will
+  // be removed. Default value is false.
+  bool strip_query = 6;
+}
+
+message DirectResponseAction {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.route.DirectResponseAction";
+
+  // Specifies the HTTP response status to be returned.
+  uint32 status = 1 [(validate.rules).uint32 = {lt: 600 gte: 200}];
+
+  // Specifies the content of the response body. If this setting is omitted,
+  // no body is included in the generated response.
+  //
+  // .. note::
+  //
+  //   Headers can be specified using ``response_headers_to_add`` in the enclosing
+  //   :ref:`envoy_v3_api_msg_config.route.v3.Route`, :ref:`envoy_v3_api_msg_config.route.v3.RouteConfiguration` or
+  //   :ref:`envoy_v3_api_msg_config.route.v3.VirtualHost`.
+  core.v3.DataSource body = 2;
+}
+
+// [#not-implemented-hide:]
+message NonForwardingAction {
+}
+
+message Decorator {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.Decorator";
+
+  // The operation name associated with the request matched to this route. If tracing is
+  // enabled, this information will be used as the span name reported for this request.
+  //
+  // .. note::
+  //
+  //   For ingress (inbound) requests, or egress (outbound) responses, this value may be overridden
+  //   by the :ref:`x-envoy-decorator-operation
+  //   <config_http_filters_router_x-envoy-decorator-operation>` header.
+  string operation = 1 [(validate.rules).string = {min_len: 1}];
+
+  // Whether the decorated details should be propagated to the other party. The default is true.
+  google.protobuf.BoolValue propagate = 2;
+}
+
+message Tracing {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.Tracing";
+
+  // Target percentage of requests managed by this HTTP connection manager that will be force
+  // traced if the :ref:`x-client-trace-id <config_http_conn_man_headers_x-client-trace-id>`
+  // header is set. This field is a direct analog for the runtime variable
+  // 'tracing.client_enabled' in the :ref:`HTTP Connection Manager
+  // <config_http_conn_man_runtime>`.
+  // Default: 100%
+  type.v3.FractionalPercent client_sampling = 1;
+
+  // Target percentage of requests managed by this HTTP connection manager that will be randomly
+  // selected for trace generation, if not requested by the client or not forced. This field is
+  // a direct analog for the runtime variable 'tracing.random_sampling' in the
+  // :ref:`HTTP Connection Manager <config_http_conn_man_runtime>`.
+  // Default: 100%
+  type.v3.FractionalPercent random_sampling = 2;
+
+  // Target percentage of requests managed by this HTTP connection manager that will be traced
+  // after all other sampling checks have been applied (client-directed, force tracing, random
+  // sampling). This field functions as an upper limit on the total configured sampling rate. For
+  // instance, setting client_sampling to 100% but overall_sampling to 1% will result in only 1%
+  // of client requests with the appropriate headers to be force traced. This field is a direct
+  // analog for the runtime variable 'tracing.global_enabled' in the
+  // :ref:`HTTP Connection Manager <config_http_conn_man_runtime>`.
+  // Default: 100%
+  type.v3.FractionalPercent overall_sampling = 3;
+
+  // A list of custom tags with unique tag name to create tags for the active span.
+  // It will take effect after merging with the :ref:`corresponding configuration
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.Tracing.custom_tags>`
+  // configured in the HTTP connection manager. If two tags with the same name are configured
+  // each in the HTTP connection manager and the route level, the one configured here takes
+  // priority.
+  repeated type.tracing.v3.CustomTag custom_tags = 4;
+}
+
+// A virtual cluster is a way of specifying a regex matching rule against
+// certain important endpoints such that statistics are generated explicitly for
+// the matched requests. The reason this is useful is that when doing
+// prefix/path matching Envoy does not always know what the application
+// considers to be an endpoint. Thus, it’s impossible for Envoy to generically
+// emit per endpoint statistics. However, often systems have highly critical
+// endpoints that they wish to get “perfect” statistics on. Virtual cluster
+// statistics are perfect in the sense that they are emitted on the downstream
+// side such that they include network level failures.
+//
+// Documentation for :ref:`virtual cluster statistics <config_http_filters_router_vcluster_stats>`.
+//
+// .. note::
+//
+//    Virtual clusters are a useful tool, but we do not recommend setting up a virtual cluster for
+//    every application endpoint. This is both not easily maintainable and as well the matching and
+//    statistics output are not free.
+message VirtualCluster {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.VirtualCluster";
+
+  reserved 1, 3;
+
+  reserved "pattern", "method";
+
+  // Specifies a list of header matchers to use for matching requests. Each specified header must
+  // match. The pseudo-headers ``:path`` and ``:method`` can be used to match the request path and
+  // method, respectively.
+  repeated HeaderMatcher headers = 4;
+
+  // Specifies the name of the virtual cluster. The virtual cluster name as well
+  // as the virtual host name are used when emitting statistics. The statistics are emitted by the
+  // router filter and are documented :ref:`here <config_http_filters_router_stats>`.
+  string name = 2 [(validate.rules).string = {min_len: 1}];
+}
+
+// Global rate limiting :ref:`architecture overview <arch_overview_global_rate_limit>`.
+// Also applies to Local rate limiting :ref:`using descriptors <config_http_filters_local_rate_limit_descriptors>`.
+// [#next-free-field: 7]
+message RateLimit {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.RateLimit";
+
+  // [#next-free-field: 13]
+  message Action {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.route.RateLimit.Action";
+
+    // The following descriptor entry is appended to the descriptor:
+    //
+    // .. code-block:: cpp
+    //
+    //   ("source_cluster", "<local service cluster>")
+    //
+    // <local service cluster> is derived from the :option:`--service-cluster` option.
+    message SourceCluster {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.route.RateLimit.Action.SourceCluster";
+    }
+
+    // The following descriptor entry is appended to the descriptor:
+    //
+    // .. code-block:: cpp
+    //
+    //   ("destination_cluster", "<routed target cluster>")
+    //
+    // Once a request matches against a route table rule, a routed cluster is determined by one of
+    // the following :ref:`route table configuration <envoy_v3_api_msg_config.route.v3.RouteConfiguration>`
+    // settings:
+    //
+    // * :ref:`cluster <envoy_v3_api_field_config.route.v3.RouteAction.cluster>` indicates the upstream cluster
+    //   to route to.
+    // * :ref:`weighted_clusters <envoy_v3_api_field_config.route.v3.RouteAction.weighted_clusters>`
+    //   chooses a cluster randomly from a set of clusters with attributed weight.
+    // * :ref:`cluster_header <envoy_v3_api_field_config.route.v3.RouteAction.cluster_header>` indicates which
+    //   header in the request contains the target cluster.
+    message DestinationCluster {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.route.RateLimit.Action.DestinationCluster";
+    }
+
+    // The following descriptor entry is appended when a header contains a key that matches the
+    // ``header_name``:
+    //
+    // .. code-block:: cpp
+    //
+    //   ("<descriptor_key>", "<header_value_queried_from_header>")
+    message RequestHeaders {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.route.RateLimit.Action.RequestHeaders";
+
+      // The header name to be queried from the request headers. The header’s
+      // value is used to populate the value of the descriptor entry for the
+      // descriptor_key.
+      string header_name = 1
+          [(validate.rules).string = {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}];
+
+      // The key to use in the descriptor entry.
+      string descriptor_key = 2 [(validate.rules).string = {min_len: 1}];
+
+      // Controls the behavior when the specified header is not present in the request.
+      //
+      // If set to ``false`` (default):
+      //
+      // * Envoy does **NOT** call the rate limiting service for this descriptor.
+      // * Useful if the header is optional and you prefer to skip rate limiting when it's absent.
+      //
+      // If set to ``true``:
+      //
+      // * Envoy calls the rate limiting service but omits this descriptor if the header is missing.
+      // * Useful if you want Envoy to enforce rate limiting even when the header is not present.
+      //
+      bool skip_if_absent = 3;
+    }
+
+    // The following descriptor entry is appended when a query parameter contains a key that matches the
+    // ``query_parameter_name``:
+    //
+    // .. code-block:: cpp
+    //
+    //   ("<descriptor_key>", "<query_parameter_value_queried_from_query_parameter>")
+    message QueryParameters {
+      // The name of the query parameter to use for rate limiting. Value of this query parameter is used to populate
+      // the value of the descriptor entry for the descriptor_key.
+      string query_parameter_name = 1 [(validate.rules).string = {min_len: 1}];
+
+      // The key to use when creating the rate limit descriptor entry. his descriptor key will be used to identify the
+      // rate limit rule in the rate limiting service.
+      string descriptor_key = 2 [(validate.rules).string = {min_len: 1}];
+
+      // Controls the behavior when the specified query parameter is not present in the request.
+      //
+      // If set to ``false`` (default):
+      //
+      // * Envoy does **NOT** call the rate limiting service for this descriptor.
+      // * Useful if the query parameter is optional and you prefer to skip rate limiting when it's absent.
+      //
+      // If set to ``true``:
+      //
+      // * Envoy calls the rate limiting service but omits this descriptor if the query parameter is missing.
+      // * Useful if you want Envoy to enforce rate limiting even when the query parameter is not present.
+      //
+      bool skip_if_absent = 3;
+    }
+
+    // The following descriptor entry is appended to the descriptor and is populated using the
+    // trusted address from :ref:`x-forwarded-for <config_http_conn_man_headers_x-forwarded-for>`:
+    //
+    // .. code-block:: cpp
+    //
+    //   ("remote_address", "<trusted address from x-forwarded-for>")
+    message RemoteAddress {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.route.RateLimit.Action.RemoteAddress";
+    }
+
+    // The following descriptor entry is appended to the descriptor and is populated using the
+    // masked address from :ref:`x-forwarded-for <config_http_conn_man_headers_x-forwarded-for>`:
+    //
+    // .. code-block:: cpp
+    //
+    //   ("masked_remote_address", "<masked address from x-forwarded-for>")
+    message MaskedRemoteAddress {
+      // Length of prefix mask len for IPv4 (e.g. 0, 32).
+      // Defaults to 32 when unset.
+      // For example, trusted address from x-forwarded-for is ``192.168.1.1``,
+      // the descriptor entry is ("masked_remote_address", "192.168.1.1/32");
+      // if mask len is 24, the descriptor entry is ("masked_remote_address", "192.168.1.0/24").
+      google.protobuf.UInt32Value v4_prefix_mask_len = 1 [(validate.rules).uint32 = {lte: 32}];
+
+      // Length of prefix mask len for IPv6 (e.g. 0, 128).
+      // Defaults to 128 when unset.
+      // For example, trusted address from x-forwarded-for is ``2001:abcd:ef01:2345:6789:abcd:ef01:234``,
+      // the descriptor entry is ("masked_remote_address", "2001:abcd:ef01:2345:6789:abcd:ef01:234/128");
+      // if mask len is 64, the descriptor entry is ("masked_remote_address", "2001:abcd:ef01:2345::/64").
+      google.protobuf.UInt32Value v6_prefix_mask_len = 2 [(validate.rules).uint32 = {lte: 128}];
+    }
+
+    // The following descriptor entry is appended to the descriptor:
+    //
+    // .. code-block:: cpp
+    //
+    //   ("generic_key", "<descriptor_value>")
+    message GenericKey {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.route.RateLimit.Action.GenericKey";
+
+      // The value to use in the descriptor entry.
+      string descriptor_value = 1 [(validate.rules).string = {min_len: 1}];
+
+      // An optional key to use in the descriptor entry. If not set it defaults
+      // to 'generic_key' as the descriptor key.
+      string descriptor_key = 2;
+    }
+
+    // The following descriptor entry is appended to the descriptor:
+    //
+    // .. code-block:: cpp
+    //
+    //   ("header_match", "<descriptor_value>")
+    message HeaderValueMatch {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.route.RateLimit.Action.HeaderValueMatch";
+
+      // The key to use in the descriptor entry. Defaults to ``header_match``.
+      string descriptor_key = 4;
+
+      // The value to use in the descriptor entry.
+      string descriptor_value = 1 [(validate.rules).string = {min_len: 1}];
+
+      // If set to true, the action will append a descriptor entry when the
+      // request matches the headers. If set to false, the action will append a
+      // descriptor entry when the request does not match the headers. The
+      // default value is true.
+      google.protobuf.BoolValue expect_match = 2;
+
+      // Specifies a set of headers that the rate limit action should match
+      // on. The action will check the request’s headers against all the
+      // specified headers in the config. A match will happen if all the
+      // headers in the config are present in the request with the same values
+      // (or based on presence if the value field is not in the config).
+      repeated HeaderMatcher headers = 3 [(validate.rules).repeated = {min_items: 1}];
+    }
+
+    // The following descriptor entry is appended when the
+    // :ref:`dynamic metadata <well_known_dynamic_metadata>` contains a key value:
+    //
+    // .. code-block:: cpp
+    //
+    //   ("<descriptor_key>", "<value_queried_from_dynamic_metadata>")
+    //
+    // .. attention::
+    //   This action has been deprecated in favor of the :ref:`metadata <envoy_v3_api_msg_config.route.v3.RateLimit.Action.MetaData>` action
+    message DynamicMetaData {
+      // The key to use in the descriptor entry.
+      string descriptor_key = 1 [(validate.rules).string = {min_len: 1}];
+
+      // Metadata struct that defines the key and path to retrieve the string value. A match will
+      // only happen if the value in the dynamic metadata is of type string.
+      type.metadata.v3.MetadataKey metadata_key = 2 [(validate.rules).message = {required: true}];
+
+      // An optional value to use if ``metadata_key`` is empty. If not set and
+      // no value is present under the metadata_key then no descriptor is generated.
+      string default_value = 3;
+    }
+
+    // The following descriptor entry is appended when the metadata contains a key value:
+    //
+    // .. code-block:: cpp
+    //
+    //   ("<descriptor_key>", "<value_queried_from_metadata>")
+    // [#next-free-field: 6]
+    message MetaData {
+      enum Source {
+        // Query :ref:`dynamic metadata <well_known_dynamic_metadata>`
+        DYNAMIC = 0;
+
+        // Query :ref:`route entry metadata <envoy_v3_api_field_config.route.v3.Route.metadata>`
+        ROUTE_ENTRY = 1;
+      }
+
+      // The key to use in the descriptor entry.
+      string descriptor_key = 1 [(validate.rules).string = {min_len: 1}];
+
+      // Metadata struct that defines the key and path to retrieve the string value. A match will
+      // only happen if the value in the metadata is of type string.
+      type.metadata.v3.MetadataKey metadata_key = 2 [(validate.rules).message = {required: true}];
+
+      // An optional value to use if ``metadata_key`` is empty. If not set and
+      // no value is present under the metadata_key then ``skip_if_absent`` is followed to
+      // skip calling the rate limiting service or skip the descriptor.
+      string default_value = 3;
+
+      // Source of metadata
+      Source source = 4 [(validate.rules).enum = {defined_only: true}];
+
+      // Controls the behavior when the specified ``metadata_key`` is empty and ``default_value`` is not set.
+      //
+      // If set to ``false`` (default):
+      //
+      // * Envoy does **NOT** call the rate limiting service for this descriptor.
+      // * Useful if the metadata is optional and you prefer to skip rate limiting when it's absent.
+      //
+      // If set to ``true``:
+      //
+      // * Envoy calls the rate limiting service but omits this descriptor if the ``metadata_key`` is empty and
+      //   ``default_value`` is missing.
+      // * Useful if you want Envoy to enforce rate limiting even when the metadata is not present.
+      //
+      bool skip_if_absent = 5;
+    }
+
+    // The following descriptor entry is appended to the descriptor:
+    //
+    // .. code-block:: cpp
+    //
+    //   ("query_match", "<descriptor_value>")
+    message QueryParameterValueMatch {
+      // The key to use in the descriptor entry. Defaults to ``query_match``.
+      string descriptor_key = 4;
+
+      // The value to use in the descriptor entry.
+      string descriptor_value = 1 [(validate.rules).string = {min_len: 1}];
+
+      // If set to true, the action will append a descriptor entry when the
+      // request matches the headers. If set to false, the action will append a
+      // descriptor entry when the request does not match the headers. The
+      // default value is true.
+      google.protobuf.BoolValue expect_match = 2;
+
+      // Specifies a set of query parameters that the rate limit action should match
+      // on. The action will check the request’s query parameters against all the
+      // specified query parameters in the config. A match will happen if all the
+      // query parameters in the config are present in the request with the same values
+      // (or based on presence if the value field is not in the config).
+      repeated QueryParameterMatcher query_parameters = 3
+          [(validate.rules).repeated = {min_items: 1}];
+    }
+
+    oneof action_specifier {
+      option (validate.required) = true;
+
+      // Rate limit on source cluster.
+      SourceCluster source_cluster = 1;
+
+      // Rate limit on destination cluster.
+      DestinationCluster destination_cluster = 2;
+
+      // Rate limit on request headers.
+      RequestHeaders request_headers = 3;
+
+      // Rate limit on query parameters.
+      QueryParameters query_parameters = 12;
+
+      // Rate limit on remote address.
+      RemoteAddress remote_address = 4;
+
+      // Rate limit on a generic key.
+      GenericKey generic_key = 5;
+
+      // Rate limit on the existence of request headers.
+      HeaderValueMatch header_value_match = 6;
+
+      // Rate limit on dynamic metadata.
+      //
+      // .. attention::
+      //   This field has been deprecated in favor of the :ref:`metadata <envoy_v3_api_field_config.route.v3.RateLimit.Action.metadata>` field
+      DynamicMetaData dynamic_metadata = 7 [
+        deprecated = true,
+        (envoy.annotations.deprecated_at_minor_version) = "3.0",
+        (envoy.annotations.disallowed_by_default) = true
+      ];
+
+      // Rate limit on metadata.
+      MetaData metadata = 8;
+
+      // Rate limit descriptor extension. See the rate limit descriptor extensions documentation.
+      //
+      // :ref:`HTTP matching input functions <arch_overview_matching_api>` are
+      // permitted as descriptor extensions. The input functions are only
+      // looked up if there is no rate limit descriptor extension matching
+      // the type URL.
+      //
+      // [#extension-category: envoy.rate_limit_descriptors]
+      core.v3.TypedExtensionConfig extension = 9;
+
+      // Rate limit on masked remote address.
+      MaskedRemoteAddress masked_remote_address = 10;
+
+      // Rate limit on the existence of query parameters.
+      QueryParameterValueMatch query_parameter_value_match = 11;
+    }
+  }
+
+  message Override {
+    // Fetches the override from the dynamic metadata.
+    message DynamicMetadata {
+      // Metadata struct that defines the key and path to retrieve the struct value.
+      // The value must be a struct containing an integer "requests_per_unit" property
+      // and a "unit" property with a value parseable to :ref:`RateLimitUnit
+      // enum <envoy_v3_api_enum_type.v3.RateLimitUnit>`
+      type.metadata.v3.MetadataKey metadata_key = 1 [(validate.rules).message = {required: true}];
+    }
+
+    oneof override_specifier {
+      option (validate.required) = true;
+
+      // Limit override from dynamic metadata.
+      DynamicMetadata dynamic_metadata = 1;
+    }
+  }
+
+  message HitsAddend {
+    // Fixed number of hits to add to the rate limit descriptor.
+    //
+    // One of the ``number`` or ``format`` fields should be set but not both.
+    google.protobuf.UInt64Value number = 1 [(validate.rules).uint64 = {lte: 1000000000}];
+
+    // Substitution format string to extract the number of hits to add to the rate limit descriptor.
+    // The same :ref:`format specifier <config_access_log_format>` as used for
+    // :ref:`HTTP access logging <config_access_log>` applies here.
+    //
+    // .. note::
+    //
+    //   The format string must contains only single valid substitution field. If the format string
+    //   not meets the requirement, the configuration will be rejected.
+    //
+    //   The substitution field should generates a non-negative number or string representation of
+    //   a non-negative number. The value of the non-negative number should be less than or equal
+    //   to 1000000000 like the ``number`` field. If the output of the substitution field not meet
+    //   the requirement, this will be treated as an error and the current descriptor will be ignored.
+    //
+    // For example, the ``%BYTES_RECEIVED%`` format string will be replaced with the number of bytes
+    // received in the request.
+    //
+    // One of the ``number`` or ``format`` fields should be set but not both.
+    string format = 2 [(validate.rules).string = {prefix: "%" suffix: "%" ignore_empty: true}];
+  }
+
+  // Refers to the stage set in the filter. The rate limit configuration only
+  // applies to filters with the same stage number. The default stage number is
+  // 0.
+  //
+  // .. note::
+  //
+  //   The filter supports a range of 0 - 10 inclusively for stage numbers.
+  //
+  // .. note::
+  //   This is not supported if the rate limit action is configured in the ``typed_per_filter_config`` like
+  //   :ref:`VirtualHost.typed_per_filter_config<envoy_v3_api_field_config.route.v3.VirtualHost.typed_per_filter_config>` or
+  //   :ref:`Route.typed_per_filter_config<envoy_v3_api_field_config.route.v3.Route.typed_per_filter_config>`, etc.
+  google.protobuf.UInt32Value stage = 1 [(validate.rules).uint32 = {lte: 10}];
+
+  // The key to be set in runtime to disable this rate limit configuration.
+  //
+  // .. note::
+  //   This is not supported if the rate limit action is configured in the ``typed_per_filter_config`` like
+  //   :ref:`VirtualHost.typed_per_filter_config<envoy_v3_api_field_config.route.v3.VirtualHost.typed_per_filter_config>` or
+  //   :ref:`Route.typed_per_filter_config<envoy_v3_api_field_config.route.v3.Route.typed_per_filter_config>`, etc.
+  string disable_key = 2;
+
+  // A list of actions that are to be applied for this rate limit configuration.
+  // Order matters as the actions are processed sequentially and the descriptor
+  // is composed by appending descriptor entries in that sequence. If an action
+  // cannot append a descriptor entry, no descriptor is generated for the
+  // configuration. See :ref:`composing actions
+  // <config_http_filters_rate_limit_composing_actions>` for additional documentation.
+  repeated Action actions = 3 [(validate.rules).repeated = {min_items: 1}];
+
+  // An optional limit override to be appended to the descriptor produced by this
+  // rate limit configuration. If the override value is invalid or cannot be resolved
+  // from metadata, no override is provided. See :ref:`rate limit override
+  // <config_http_filters_rate_limit_rate_limit_override>` for more information.
+  //
+  // .. note::
+  //   This is not supported if the rate limit action is configured in the ``typed_per_filter_config`` like
+  //   :ref:`VirtualHost.typed_per_filter_config<envoy_v3_api_field_config.route.v3.VirtualHost.typed_per_filter_config>` or
+  //   :ref:`Route.typed_per_filter_config<envoy_v3_api_field_config.route.v3.Route.typed_per_filter_config>`, etc.
+  Override limit = 4;
+
+  // An optional hits addend to be appended to the descriptor produced by this rate limit
+  // configuration.
+  //
+  // .. note::
+  //   This is only supported if the rate limit action is configured in the ``typed_per_filter_config`` like
+  //   :ref:`VirtualHost.typed_per_filter_config<envoy_v3_api_field_config.route.v3.VirtualHost.typed_per_filter_config>` or
+  //   :ref:`Route.typed_per_filter_config<envoy_v3_api_field_config.route.v3.Route.typed_per_filter_config>`, etc.
+  HitsAddend hits_addend = 5;
+
+  // If true, the rate limit request will be applied when the stream completes. The default value is false.
+  // This is useful when the rate limit budget needs to reflect the response context that is not available
+  // on the request path.
+  //
+  // For example, let's say the upstream service calculates the usage statistics and returns them in the response body
+  // and we want to utilize these numbers to apply the rate limit action for the subsequent requests.
+  // Combined with another filter that can set the desired addend based on the response (e.g. Lua filter),
+  // this can be used to subtract the usage statistics from the rate limit budget.
+  //
+  // A rate limit applied on the stream completion is "fire-and-forget" by nature, and rate limit is not enforced by this config.
+  // In other words, the current request won't be blocked when this is true, but the budget will be updated for the subsequent
+  // requests based on the action with this field set to true. Users should ensure that the rate limit is enforced by the actions
+  // applied on the request path, i.e. the ones with this field set to false.
+  //
+  // Currently, this is only supported by the HTTP global rate filter.
+  bool apply_on_stream_done = 6;
+}
+
+// .. attention::
+//
+//   Internally, Envoy always uses the HTTP/2 ``:authority`` header to represent the HTTP/1 ``Host``
+//   header. Thus, if attempting to match on ``Host``, match on ``:authority`` instead.
+//
+// .. attention::
+//
+//   To route on HTTP method, use the special HTTP/2 ``:method`` header. This works for both
+//   HTTP/1 and HTTP/2 as Envoy normalizes headers. E.g.,
+//
+//   .. code-block:: json
+//
+//     {
+//       "name": ":method",
+//       "string_match": {
+//         "exact": "POST"
+//       }
+//     }
+//
+// .. attention::
+//   In the absence of any header match specifier, match will default to :ref:`present_match
+//   <envoy_v3_api_field_config.route.v3.HeaderMatcher.present_match>`. i.e, a request that has the :ref:`name
+//   <envoy_v3_api_field_config.route.v3.HeaderMatcher.name>` header will match, regardless of the header's
+//   value.
+//
+//  [#next-major-version: HeaderMatcher should be refactored to use StringMatcher.]
+// [#next-free-field: 15]
+message HeaderMatcher {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.route.HeaderMatcher";
+
+  reserved 2, 3, 5;
+
+  reserved "regex_match";
+
+  // Specifies the name of the header in the request.
+  string name = 1
+      [(validate.rules).string = {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}];
+
+  // Specifies how the header match will be performed to route the request.
+  oneof header_match_specifier {
+    // If specified, header match will be performed based on the value of the header.
+    // This field is deprecated. Please use :ref:`string_match <envoy_v3_api_field_config.route.v3.HeaderMatcher.string_match>`.
+    string exact_match = 4
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+    // If specified, this regex string is a regular expression rule which implies the entire request
+    // header value must match the regex. The rule will not match if only a subsequence of the
+    // request header value matches the regex.
+    // This field is deprecated. Please use :ref:`string_match <envoy_v3_api_field_config.route.v3.HeaderMatcher.string_match>`.
+    type.matcher.v3.RegexMatcher safe_regex_match = 11
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+    // If specified, header match will be performed based on range.
+    // The rule will match if the request header value is within this range.
+    // The entire request header value must represent an integer in base 10 notation: consisting of
+    // an optional plus or minus sign followed by a sequence of digits. The rule will not match if
+    // the header value does not represent an integer. Match will fail for empty values, floating
+    // point numbers or if only a subsequence of the header value is an integer.
+    //
+    // Examples:
+    //
+    // * For range [-10,0), route will match for header value -1, but not for 0, ``somestring``, 10.9,
+    //   ``-1somestring``
+    type.v3.Int64Range range_match = 6;
+
+    // If specified as true, header match will be performed based on whether the header is in the
+    // request. If specified as false, header match will be performed based on whether the header is absent.
+    bool present_match = 7;
+
+    // If specified, header match will be performed based on the prefix of the header value.
+    // Note: empty prefix is not allowed, please use present_match instead.
+    // This field is deprecated. Please use :ref:`string_match <envoy_v3_api_field_config.route.v3.HeaderMatcher.string_match>`.
+    //
+    // Examples:
+    //
+    // * The prefix ``abcd`` matches the value ``abcdxyz``, but not for ``abcxyz``.
+    string prefix_match = 9 [
+      deprecated = true,
+      (validate.rules).string = {min_len: 1},
+      (envoy.annotations.deprecated_at_minor_version) = "3.0"
+    ];
+
+    // If specified, header match will be performed based on the suffix of the header value.
+    // Note: empty suffix is not allowed, please use present_match instead.
+    // This field is deprecated. Please use :ref:`string_match <envoy_v3_api_field_config.route.v3.HeaderMatcher.string_match>`.
+    //
+    // Examples:
+    //
+    // * The suffix ``abcd`` matches the value ``xyzabcd``, but not for ``xyzbcd``.
+    string suffix_match = 10 [
+      deprecated = true,
+      (validate.rules).string = {min_len: 1},
+      (envoy.annotations.deprecated_at_minor_version) = "3.0"
+    ];
+
+    // If specified, header match will be performed based on whether the header value contains
+    // the given value or not.
+    // Note: empty contains match is not allowed, please use present_match instead.
+    // This field is deprecated. Please use :ref:`string_match <envoy_v3_api_field_config.route.v3.HeaderMatcher.string_match>`.
+    //
+    // Examples:
+    //
+    // * The value ``abcd`` matches the value ``xyzabcdpqr``, but not for ``xyzbcdpqr``.
+    string contains_match = 12 [
+      deprecated = true,
+      (validate.rules).string = {min_len: 1},
+      (envoy.annotations.deprecated_at_minor_version) = "3.0"
+    ];
+
+    // If specified, header match will be performed based on the string match of the header value.
+    type.matcher.v3.StringMatcher string_match = 13;
+  }
+
+  // If specified, the match result will be inverted before checking. Defaults to false.
+  //
+  // Examples:
+  //
+  // * The regex ``\d{3}`` does not match the value ``1234``, so it will match when inverted.
+  // * The range [-10,0) will match the value -1, so it will not match when inverted.
+  bool invert_match = 8;
+
+  // If specified, for any header match rule, if the header match rule specified header
+  // does not exist, this header value will be treated as empty. Defaults to false.
+  //
+  // Examples:
+  //
+  // * The header match rule specified header "header1" to range match of [0, 10],
+  //   :ref:`invert_match <envoy_v3_api_field_config.route.v3.HeaderMatcher.invert_match>`
+  //   is set to true and :ref:`treat_missing_header_as_empty <envoy_v3_api_field_config.route.v3.HeaderMatcher.treat_missing_header_as_empty>`
+  //   is set to true; The "header1" header is not present. The match rule will
+  //   treat the "header1" as an empty header. The empty header does not match the range,
+  //   so it will match when inverted.
+  // * The header match rule specified header "header2" to range match of [0, 10],
+  //   :ref:`invert_match <envoy_v3_api_field_config.route.v3.HeaderMatcher.invert_match>`
+  //   is set to true and :ref:`treat_missing_header_as_empty <envoy_v3_api_field_config.route.v3.HeaderMatcher.treat_missing_header_as_empty>`
+  //   is set to false; The "header2" header is not present and the header
+  //   matcher rule for "header2" will be ignored so it will not match.
+  // * The header match rule specified header "header3" to a string regex match
+  //   ``^$`` which means an empty string, and
+  //   :ref:`treat_missing_header_as_empty <envoy_v3_api_field_config.route.v3.HeaderMatcher.treat_missing_header_as_empty>`
+  //   is set to true; The "header3" header is not present.
+  //   The match rule will treat the "header3" header as an empty header so it will match.
+  // * The header match rule specified header "header4" to a string regex match
+  //   ``^$`` which means an empty string, and
+  //   :ref:`treat_missing_header_as_empty <envoy_v3_api_field_config.route.v3.HeaderMatcher.treat_missing_header_as_empty>`
+  //   is set to false; The "header4" header is not present.
+  //   The match rule for "header4" will be ignored so it will not match.
+  bool treat_missing_header_as_empty = 14;
+}
+
+// Query parameter matching treats the query string of a request's :path header
+// as an ampersand-separated list of keys and/or key=value elements.
+// [#next-free-field: 7]
+message QueryParameterMatcher {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.route.QueryParameterMatcher";
+
+  reserved 3, 4;
+
+  reserved "value", "regex";
+
+  // Specifies the name of a key that must be present in the requested
+  // ``path``'s query string.
+  string name = 1 [(validate.rules).string = {min_len: 1 max_bytes: 1024}];
+
+  oneof query_parameter_match_specifier {
+    // Specifies whether a query parameter value should match against a string.
+    type.matcher.v3.StringMatcher string_match = 5 [(validate.rules).message = {required: true}];
+
+    // Specifies whether a query parameter should be present.
+    bool present_match = 6;
+  }
+}
+
+// HTTP Internal Redirect :ref:`architecture overview <arch_overview_internal_redirects>`.
+// [#next-free-field: 6]
+message InternalRedirectPolicy {
+  // An internal redirect is not handled, unless the number of previous internal redirects that a
+  // downstream request has encountered is lower than this value.
+  // In the case where a downstream request is bounced among multiple routes by internal redirect,
+  // the first route that hits this threshold, or does not set :ref:`internal_redirect_policy
+  // <envoy_v3_api_field_config.route.v3.RouteAction.internal_redirect_policy>`
+  // will pass the redirect back to downstream.
+  //
+  // If not specified, at most one redirect will be followed.
+  google.protobuf.UInt32Value max_internal_redirects = 1;
+
+  // Defines what upstream response codes are allowed to trigger internal redirect. If unspecified,
+  // only 302 will be treated as internal redirect.
+  // Only 301, 302, 303, 307 and 308 are valid values. Any other codes will be ignored.
+  repeated uint32 redirect_response_codes = 2 [(validate.rules).repeated = {max_items: 5}];
+
+  // Specifies a list of predicates that are queried when an upstream response is deemed
+  // to trigger an internal redirect by all other criteria. Any predicate in the list can reject
+  // the redirect, causing the response to be proxied to downstream.
+  // [#extension-category: envoy.internal_redirect_predicates]
+  repeated core.v3.TypedExtensionConfig predicates = 3;
+
+  // Allow internal redirect to follow a target URI with a different scheme than the value of
+  // x-forwarded-proto. The default is false.
+  bool allow_cross_scheme_redirect = 4;
+
+  // Specifies a list of headers, by name, to copy from the internal redirect into the subsequent
+  // request. If a header is specified here but not present in the redirect, it will be cleared in
+  // the subsequent request.
+  repeated string response_headers_to_copy = 5 [(validate.rules).repeated = {
+    unique: true
+    items {string {well_known_regex: HTTP_HEADER_NAME strict: false}}
+  }];
+}
+
+// A simple wrapper for an HTTP filter config. This is intended to be used as a wrapper for the
+// map value in
+// :ref:`VirtualHost.typed_per_filter_config<envoy_v3_api_field_config.route.v3.VirtualHost.typed_per_filter_config>`,
+// :ref:`Route.typed_per_filter_config<envoy_v3_api_field_config.route.v3.Route.typed_per_filter_config>`,
+// or :ref:`WeightedCluster.ClusterWeight.typed_per_filter_config<envoy_v3_api_field_config.route.v3.WeightedCluster.ClusterWeight.typed_per_filter_config>`
+// to add additional flags to the filter.
+message FilterConfig {
+  // The filter config.
+  google.protobuf.Any config = 1;
+
+  // If true, the filter is optional, meaning that if the client does
+  // not support the specified filter, it may ignore the map entry rather
+  // than rejecting the config.
+  bool is_optional = 2;
+
+  // If true, the filter is disabled in the route or virtual host and the ``config`` field is ignored.
+  // See :ref:`route based filter chain <arch_overview_http_filters_route_based_filter_chain>`
+  // for more details.
+  //
+  // .. note::
+  //
+  //   This field will take effect when the request arrive and filter chain is created for the request.
+  //   If initial route is selected for the request and a filter is disabled in the initial route, then
+  //   the filter will not be added to the filter chain.
+  //   And if the request is mutated later and re-match to another route, the disabled filter by the
+  //   initial route will not be added back to the filter chain because the filter chain is already
+  //   created and it is too late to change the chain.
+  //
+  //   This field only make sense for the downstream HTTP filters for now.
+  bool disabled = 3;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/route/v3/scoped_route.proto b/xds/third_party/envoy/src/main/proto/envoy/config/route/v3/scoped_route.proto
new file mode 100644
index 00000000000..ff4cc689c89
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/route/v3/scoped_route.proto
@@ -0,0 +1,133 @@
+syntax = "proto3";
+
+package envoy.config.route.v3;
+
+import "envoy/config/route/v3/route.proto";
+
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.route.v3";
+option java_outer_classname = "ScopedRouteProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/route/v3;routev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: HTTP scoped routing configuration]
+// * Routing :ref:`architecture overview <arch_overview_http_routing>`
+
+// Specifies a routing scope, which associates a
+// :ref:`Key<envoy_v3_api_msg_config.route.v3.ScopedRouteConfiguration.Key>` to a
+// :ref:`envoy_v3_api_msg_config.route.v3.RouteConfiguration`.
+// The :ref:`envoy_v3_api_msg_config.route.v3.RouteConfiguration` can be obtained dynamically
+// via RDS (:ref:`route_configuration_name<envoy_v3_api_field_config.route.v3.ScopedRouteConfiguration.route_configuration_name>`)
+// or specified inline (:ref:`route_configuration<envoy_v3_api_field_config.route.v3.ScopedRouteConfiguration.route_configuration>`).
+//
+// The HTTP connection manager builds up a table consisting of these Key to
+// RouteConfiguration mappings, and looks up the RouteConfiguration to use per
+// request according to the algorithm specified in the
+// :ref:`scope_key_builder<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.scope_key_builder>`
+// assigned to the HttpConnectionManager.
+//
+// For example, with the following configurations (in YAML):
+//
+// HttpConnectionManager config:
+//
+// .. code::
+//
+//   ...
+//   scoped_routes:
+//     name: foo-scoped-routes
+//     scope_key_builder:
+//       fragments:
+//         - header_value_extractor:
+//             name: X-Route-Selector
+//             element_separator: ","
+//             element:
+//               separator: =
+//               key: vip
+//
+// ScopedRouteConfiguration resources (specified statically via
+// :ref:`scoped_route_configurations_list<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.scoped_route_configurations_list>`
+// or obtained dynamically via SRDS):
+//
+// .. code::
+//
+//  (1)
+//   name: route-scope1
+//   route_configuration_name: route-config1
+//   key:
+//      fragments:
+//        - string_key: 172.10.10.20
+//
+//  (2)
+//   name: route-scope2
+//   route_configuration_name: route-config2
+//   key:
+//     fragments:
+//       - string_key: 172.20.20.30
+//
+// A request from a client such as:
+//
+// .. code::
+//
+//     GET / HTTP/1.1
+//     Host: foo.com
+//     X-Route-Selector: vip=172.10.10.20
+//
+// would result in the routing table defined by the ``route-config1``
+// RouteConfiguration being assigned to the HTTP request/stream.
+//
+// [#next-free-field: 6]
+message ScopedRouteConfiguration {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.ScopedRouteConfiguration";
+
+  // Specifies a key which is matched against the output of the
+  // :ref:`scope_key_builder<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.scope_key_builder>`
+  // specified in the HttpConnectionManager. The matching is done per HTTP
+  // request and is dependent on the order of the fragments contained in the
+  // Key.
+  message Key {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.ScopedRouteConfiguration.Key";
+
+    message Fragment {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.api.v2.ScopedRouteConfiguration.Key.Fragment";
+
+      oneof type {
+        option (validate.required) = true;
+
+        // A string to match against.
+        string string_key = 1;
+      }
+    }
+
+    // The ordered set of fragments to match against. The order must match the
+    // fragments in the corresponding
+    // :ref:`scope_key_builder<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.scope_key_builder>`.
+    repeated Fragment fragments = 1 [(validate.rules).repeated = {min_items: 1}];
+  }
+
+  // Whether the RouteConfiguration should be loaded on demand.
+  bool on_demand = 4;
+
+  // The name assigned to the routing scope.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // The resource name to use for a :ref:`envoy_v3_api_msg_service.discovery.v3.DiscoveryRequest` to an
+  // RDS server to fetch the :ref:`envoy_v3_api_msg_config.route.v3.RouteConfiguration` associated
+  // with this scope.
+  string route_configuration_name = 2
+      [(udpa.annotations.field_migrate).oneof_promotion = "route_config"];
+
+  // The :ref:`envoy_v3_api_msg_config.route.v3.RouteConfiguration` associated with the scope.
+  RouteConfiguration route_configuration = 5
+      [(udpa.annotations.field_migrate).oneof_promotion = "route_config"];
+
+  // The key to match against.
+  Key key = 3 [(validate.rules).message = {required: true}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/datadog.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/datadog.proto
new file mode 100644
index 00000000000..5359ec74267
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/datadog.proto
@@ -0,0 +1,50 @@
+syntax = "proto3";
+
+package envoy.config.trace.v3;
+
+import "google/protobuf/duration.proto";
+
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.trace.v3";
+option java_outer_classname = "DatadogProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/trace/v3;tracev3";
+option (udpa.annotations.file_migrate).move_to_package = "envoy.extensions.tracers.datadog.v4alpha";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Datadog tracer]
+
+// Configuration for the Remote Configuration feature.
+message DatadogRemoteConfig {
+  // Frequency at which new configuration updates are queried.
+  // If no value is provided, the default value is delegated to the Datadog tracing library.
+  google.protobuf.Duration polling_interval = 1;
+}
+
+// Configuration for the Datadog tracer.
+// [#extension: envoy.tracers.datadog]
+message DatadogConfig {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.trace.v2.DatadogConfig";
+
+  // The cluster to use for submitting traces to the Datadog agent.
+  string collector_cluster = 1 [(validate.rules).string = {min_len: 1}];
+
+  // The name used for the service when traces are generated by envoy.
+  string service_name = 2 [(validate.rules).string = {min_len: 1}];
+
+  // Optional hostname to use when sending spans to the collector_cluster. Useful for collectors
+  // that require a specific hostname. Defaults to :ref:`collector_cluster <envoy_v3_api_field_config.trace.v3.DatadogConfig.collector_cluster>` above.
+  string collector_hostname = 3;
+
+  // Enables and configures remote configuration.
+  // Remote Configuration allows to configure the tracer from Datadog's user interface.
+  // This feature can drastically increase the number of connections to the Datadog Agent.
+  // Each tracer regularly polls for configuration updates, and the number of tracers is the product
+  // of the number of listeners and worker threads.
+  DatadogRemoteConfig remote_config = 4;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/dynamic_ot.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/dynamic_ot.proto
new file mode 100644
index 00000000000..40fe8526a5f
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/dynamic_ot.proto
@@ -0,0 +1,47 @@
+syntax = "proto3";
+
+package envoy.config.trace.v3;
+
+import "google/protobuf/struct.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.trace.v3";
+option java_outer_classname = "DynamicOtProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/trace/v3;tracev3";
+option (udpa.annotations.file_migrate).move_to_package =
+    "envoy.extensions.tracers.dynamic_ot.v4alpha";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Dynamically loadable OpenTracing tracer]
+
+// DynamicOtConfig was used to dynamically load a tracer from a shared library
+// that implements the `OpenTracing dynamic loading API
+// <https://github.com/opentracing/opentracing-cpp>`_.
+// [#not-implemented-hide:]
+message DynamicOtConfig {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.trace.v2.DynamicOtConfig";
+
+  // Dynamic library implementing the `OpenTracing API
+  // <https://github.com/opentracing/opentracing-cpp>`_.
+  string library = 1 [
+    deprecated = true,
+    (validate.rules).string = {min_len: 1},
+    (envoy.annotations.deprecated_at_minor_version) = "3.0",
+    (envoy.annotations.disallowed_by_default) = true
+  ];
+
+  // The configuration to use when creating a tracer from the given dynamic
+  // library.
+  google.protobuf.Struct config = 2 [
+    deprecated = true,
+    (envoy.annotations.deprecated_at_minor_version) = "3.0",
+    (envoy.annotations.disallowed_by_default) = true
+  ];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/http_tracer.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/http_tracer.proto
new file mode 100644
index 00000000000..8bd5151f4b1
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/http_tracer.proto
@@ -0,0 +1,60 @@
+syntax = "proto3";
+
+package envoy.config.trace.v3;
+
+import "google/protobuf/any.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.trace.v3";
+option java_outer_classname = "HttpTracerProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/trace/v3;tracev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Tracing]
+// Tracing :ref:`architecture overview <arch_overview_tracing>`.
+
+// The tracing configuration specifies settings for an HTTP tracer provider used by Envoy.
+//
+// Envoy may support other tracers in the future, but right now the HTTP tracer is the only one
+// supported.
+//
+// .. attention::
+//
+//   Use of this message type has been deprecated in favor of direct use of
+//   :ref:`Tracing.Http <envoy_v3_api_msg_config.trace.v3.Tracing.Http>`.
+message Tracing {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.config.trace.v2.Tracing";
+
+  // Configuration for an HTTP tracer provider used by Envoy.
+  //
+  // The configuration is defined by the
+  // :ref:`HttpConnectionManager.Tracing <envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.Tracing>`
+  // :ref:`provider <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.Tracing.provider>`
+  // field.
+  message Http {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.trace.v2.Tracing.Http";
+
+    reserved 2;
+
+    reserved "config";
+
+    // The name of the HTTP trace driver to instantiate. The name must match a
+    // supported HTTP trace driver.
+    // See the :ref:`extensions listed in typed_config below <extension_category_envoy.tracers>` for the default list of the HTTP trace driver.
+    string name = 1 [(validate.rules).string = {min_len: 1}];
+
+    // Trace driver specific configuration which must be set according to the driver being instantiated.
+    // [#extension-category: envoy.tracers]
+    oneof config_type {
+      google.protobuf.Any typed_config = 3;
+    }
+  }
+
+  // Provides configuration for the HTTP tracer.
+  Http http = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/lightstep.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/lightstep.proto
new file mode 100644
index 00000000000..96dbbedd542
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/lightstep.proto
@@ -0,0 +1,59 @@
+syntax = "proto3";
+
+package envoy.config.trace.v3;
+
+import "envoy/config/core/v3/base.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.trace.v3";
+option java_outer_classname = "LightstepProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/trace/v3;tracev3";
+option (udpa.annotations.file_migrate).move_to_package =
+    "envoy.extensions.tracers.lightstep.v4alpha";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: LightStep tracer]
+
+// Configuration for the LightStep tracer.
+// [#extension: envoy.tracers.lightstep]
+// [#not-implemented-hide:]
+message LightstepConfig {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.trace.v2.LightstepConfig";
+
+  // Available propagation modes
+  enum PropagationMode {
+    // Propagate trace context in the single header x-ot-span-context.
+    ENVOY = 0;
+
+    // Propagate trace context using LightStep's native format.
+    LIGHTSTEP = 1;
+
+    // Propagate trace context using the b3 format.
+    B3 = 2;
+
+    // Propagation trace context using the w3 trace-context standard.
+    TRACE_CONTEXT = 3;
+  }
+
+  // The cluster manager cluster that hosts the LightStep collectors.
+  string collector_cluster = 1 [(validate.rules).string = {min_len: 1}];
+
+  // File containing the access token to the `LightStep
+  // <https://lightstep.com/>`_ API.
+  string access_token_file = 2
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Access token to the `LightStep <https://lightstep.com/>`_ API.
+  core.v3.DataSource access_token = 4;
+
+  // Propagation modes to use by LightStep's tracer.
+  repeated PropagationMode propagation_modes = 3
+      [(validate.rules).repeated = {items {enum {defined_only: true}}}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/opentelemetry.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/opentelemetry.proto
new file mode 100644
index 00000000000..5260d9bd6af
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/opentelemetry.proto
@@ -0,0 +1,67 @@
+syntax = "proto3";
+
+package envoy.config.trace.v3;
+
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/core/v3/grpc_service.proto";
+import "envoy/config/core/v3/http_service.proto";
+
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.config.trace.v3";
+option java_outer_classname = "OpentelemetryProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/trace/v3;tracev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: OpenTelemetry tracer]
+
+// Configuration for the OpenTelemetry tracer.
+//  [#extension: envoy.tracers.opentelemetry]
+// [#next-free-field: 7]
+message OpenTelemetryConfig {
+  // The upstream gRPC cluster that will receive OTLP traces.
+  // Note that the tracer drops traces if the server does not read data fast enough.
+  // This field can be left empty to disable reporting traces to the gRPC service.
+  // Only one of ``grpc_service``, ``http_service`` may be used.
+  core.v3.GrpcService grpc_service = 1
+      [(udpa.annotations.field_migrate).oneof_promotion = "otlp_exporter"];
+
+  // The upstream HTTP cluster that will receive OTLP traces.
+  // This field can be left empty to disable reporting traces to the HTTP service.
+  // Only one of ``grpc_service``, ``http_service`` may be used.
+  //
+  // .. note::
+  //
+  //   Note: The ``request_headers_to_add`` property in the OTLP HTTP exporter service
+  //   does not support the :ref:`format specifier <config_access_log_format>` as used for
+  //   :ref:`HTTP access logging <config_access_log>`.
+  //   The values configured are added as HTTP headers on the OTLP export request
+  //   without any formatting applied.
+  core.v3.HttpService http_service = 3
+      [(udpa.annotations.field_migrate).oneof_promotion = "otlp_exporter"];
+
+  // The name for the service. This will be populated in the ResourceSpan Resource attributes.
+  // If it is not provided, it will default to "unknown_service:envoy".
+  string service_name = 2;
+
+  // An ordered list of resource detectors
+  // [#extension-category: envoy.tracers.opentelemetry.resource_detectors]
+  repeated core.v3.TypedExtensionConfig resource_detectors = 4;
+
+  // Specifies the sampler to be used by the OpenTelemetry tracer.
+  // The configured sampler implements the Sampler interface defined by the OpenTelemetry specification.
+  // This field can be left empty. In this case, the default Envoy sampling decision is used.
+  //
+  // See: `OpenTelemetry sampler specification <https://opentelemetry.io/docs/specs/otel/trace/sdk/#sampler>`_
+  // [#extension-category: envoy.tracers.opentelemetry.samplers]
+  core.v3.TypedExtensionConfig sampler = 5;
+
+  // Envoy caches the span in memory when the OpenTelemetry backend service is temporarily unavailable.
+  // This field specifies the maximum number of spans that can be cached. If not specified, the
+  // default is 1024.
+  google.protobuf.UInt32Value max_cache_size = 6;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/service.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/service.proto
new file mode 100644
index 00000000000..4cb8c44c424
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/service.proto
@@ -0,0 +1,26 @@
+syntax = "proto3";
+
+package envoy.config.trace.v3;
+
+import "envoy/config/core/v3/grpc_service.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.trace.v3";
+option java_outer_classname = "ServiceProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/trace/v3;tracev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Trace Service]
+
+// Configuration structure.
+message TraceServiceConfig {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.trace.v2.TraceServiceConfig";
+
+  // The upstream gRPC cluster that hosts the metrics service.
+  core.v3.GrpcService grpc_service = 1 [(validate.rules).message = {required: true}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/zipkin.proto b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/zipkin.proto
new file mode 100644
index 00000000000..7405c596ed5
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/config/trace/v3/zipkin.proto
@@ -0,0 +1,168 @@
+syntax = "proto3";
+
+package envoy.config.trace.v3;
+
+import "envoy/config/core/v3/http_service.proto";
+
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.config.trace.v3";
+option java_outer_classname = "ZipkinProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/trace/v3;tracev3";
+option (udpa.annotations.file_migrate).move_to_package = "envoy.extensions.tracers.zipkin.v4alpha";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Zipkin tracer]
+
+// Configuration for the Zipkin tracer.
+// [#extension: envoy.tracers.zipkin]
+// [#next-free-field: 10]
+message ZipkinConfig {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.config.trace.v2.ZipkinConfig";
+
+  // Available trace context options for handling different trace header formats.
+  enum TraceContextOption {
+    // Use B3 headers only (default behavior).
+    USE_B3 = 0;
+
+    // Enable B3 and W3C dual header support:
+    // - For downstream: Extract from B3 headers first, fallback to W3C traceparent if B3 is unavailable.
+    // - For upstream: Inject both B3 and W3C traceparent headers.
+    // When this option is NOT set, only B3 headers are used for both extraction and injection.
+    USE_B3_WITH_W3C_PROPAGATION = 1;
+  }
+
+  // Available Zipkin collector endpoint versions.
+  enum CollectorEndpointVersion {
+    // Zipkin API v1, JSON over HTTP.
+    // [#comment: The default implementation of Zipkin client before this field is added was only v1
+    // and the way user configure this was by not explicitly specifying the version. Consequently,
+    // before this is added, the corresponding Zipkin collector expected to receive v1 payload.
+    // Hence the motivation of adding HTTP_JSON_V1 as the default is to avoid a breaking change when
+    // user upgrading Envoy with this change. Furthermore, we also immediately deprecate this field,
+    // since in Zipkin realm this v1 version is considered to be not preferable anymore.]
+    DEPRECATED_AND_UNAVAILABLE_DO_NOT_USE = 0
+        [deprecated = true, (envoy.annotations.disallowed_by_default_enum) = true];
+
+    // Zipkin API v2, JSON over HTTP.
+    HTTP_JSON = 1;
+
+    // Zipkin API v2, protobuf over HTTP.
+    HTTP_PROTO = 2;
+
+    // [#not-implemented-hide:]
+    GRPC = 3;
+  }
+
+  // The cluster manager cluster that hosts the Zipkin collectors.
+  // Note: This field will be deprecated in future releases in favor of
+  // :ref:`collector_service <envoy_v3_api_field_config.trace.v3.ZipkinConfig.collector_service>`.
+  // Either this field or collector_service must be specified.
+  string collector_cluster = 1;
+
+  // The API endpoint of the Zipkin service where the spans will be sent. When
+  // using a standard Zipkin installation.
+  // Note: This field will be deprecated in future releases in favor of
+  // :ref:`collector_service <envoy_v3_api_field_config.trace.v3.ZipkinConfig.collector_service>`.
+  // Required when using collector_cluster.
+  string collector_endpoint = 2;
+
+  // Determines whether a 128bit trace id will be used when creating a new
+  // trace instance. The default value is false, which will result in a 64 bit trace id being used.
+  bool trace_id_128bit = 3;
+
+  // Determines whether client and server spans will share the same span context.
+  // The default value is true.
+  google.protobuf.BoolValue shared_span_context = 4;
+
+  // Determines the selected collector endpoint version.
+  CollectorEndpointVersion collector_endpoint_version = 5;
+
+  // Optional hostname to use when sending spans to the collector_cluster. Useful for collectors
+  // that require a specific hostname. Defaults to :ref:`collector_cluster <envoy_v3_api_field_config.trace.v3.ZipkinConfig.collector_cluster>` above.
+  // Note: This field will be deprecated in future releases in favor of
+  // :ref:`collector_service <envoy_v3_api_field_config.trace.v3.ZipkinConfig.collector_service>`.
+  string collector_hostname = 6;
+
+  // If this is set to true, then Envoy will be treated as an independent hop in trace chain. A complete span pair will be created for a single
+  // request. Server span will be created for the downstream request and client span will be created for the related upstream request.
+  // This should be set to true in the following cases:
+  //
+  // * The Envoy Proxy is used as gateway or ingress.
+  // * The Envoy Proxy is used as sidecar but inbound traffic capturing or outbound traffic capturing is disabled.
+  // * Any case that the :ref:`start_child_span of router <envoy_v3_api_field_extensions.filters.http.router.v3.Router.start_child_span>` is set to true.
+  //
+  // .. attention::
+  //
+  //   If this is set to true, then the
+  //   :ref:`start_child_span of router <envoy_v3_api_field_extensions.filters.http.router.v3.Router.start_child_span>`
+  //   SHOULD be set to true also to ensure the correctness of trace chain.
+  //
+  //   Both this field and ``start_child_span`` are deprecated by the
+  //   :ref:`spawn_upstream_span <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.Tracing.spawn_upstream_span>`.
+  //   Please use that ``spawn_upstream_span`` field to control the span creation.
+  bool split_spans_for_request = 7
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Determines which trace context format to use for trace header extraction and propagation.
+  // This controls both downstream request header extraction and upstream request header injection.
+  // Here is the spec for W3C trace headers: https://www.w3.org/TR/trace-context/
+  // The default value is USE_B3 to maintain backward compatibility.
+  TraceContextOption trace_context_option = 8;
+
+  // HTTP service configuration for the Zipkin collector.
+  // When specified, this configuration takes precedence over the legacy fields:
+  // collector_cluster, collector_endpoint, and collector_hostname.
+  // This provides a complete HTTP service configuration including cluster, URI, timeout, and headers.
+  // If not specified, the legacy fields above will be used for backward compatibility.
+  //
+  // Required fields when using collector_service:
+  //
+  // * ``http_uri.cluster`` - Must be specified and non-empty
+  // * ``http_uri.uri`` - Must be specified and non-empty
+  // * ``http_uri.timeout`` - Optional
+  //
+  // Full URI Support with Automatic Parsing:
+  //
+  // The ``uri`` field supports both path-only and full URI formats:
+  //
+  // .. code-block:: yaml
+  //
+  //   tracing:
+  //     provider:
+  //       name: envoy.tracers.zipkin
+  //       typed_config:
+  //         "@type": type.googleapis.com/envoy.config.trace.v3.ZipkinConfig
+  //         collector_service:
+  //           http_uri:
+  //             # Full URI format - hostname and path are extracted automatically
+  //             uri: "https://zipkin-collector.example.com/api/v2/spans"
+  //             cluster: zipkin
+  //             timeout: 5s
+  //           request_headers_to_add:
+  //             - header:
+  //                 key: "X-Custom-Token"
+  //                 value: "your-custom-token"
+  //             - header:
+  //                 key: "X-Service-ID"
+  //                 value: "your-service-id"
+  //
+  // URI Parsing Behavior:
+  //
+  // * Full URI: ``"https://zipkin-collector.example.com/api/v2/spans"``
+  //
+  //   * Hostname: ``zipkin-collector.example.com`` (sets HTTP ``Host`` header)
+  //   * Path: ``/api/v2/spans`` (sets HTTP request path)
+  //
+  // * Path only: ``"/api/v2/spans"``
+  //
+  //   * Hostname: Uses cluster name as fallback
+  //   * Path: ``/api/v2/spans``
+  core.v3.HttpService collector_service = 9;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/data/accesslog/v3/accesslog.proto b/xds/third_party/envoy/src/main/proto/envoy/data/accesslog/v3/accesslog.proto
new file mode 100644
index 00000000000..da029b7da2e
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/data/accesslog/v3/accesslog.proto
@@ -0,0 +1,547 @@
+syntax = "proto3";
+
+package envoy.data.accesslog.v3;
+
+import "envoy/config/core/v3/address.proto";
+import "envoy/config/core/v3/base.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.data.accesslog.v3";
+option java_outer_classname = "AccesslogProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/data/accesslog/v3;accesslogv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: gRPC access logs]
+// Envoy access logs describe incoming interaction with Envoy over a fixed
+// period of time, and typically cover a single request/response exchange,
+// (e.g. HTTP), stream (e.g. over HTTP/gRPC), or proxied connection (e.g. TCP).
+// Access logs contain fields defined in protocol-specific protobuf messages.
+//
+// Except where explicitly declared otherwise, all fields describe
+// *downstream* interaction between Envoy and a connected client.
+// Fields describing *upstream* interaction will explicitly include ``upstream``
+// in their name.
+
+enum AccessLogType {
+  NotSet = 0;
+  TcpUpstreamConnected = 1;
+  TcpPeriodic = 2;
+  TcpConnectionEnd = 3;
+  DownstreamStart = 4;
+  DownstreamPeriodic = 5;
+  DownstreamEnd = 6;
+  UpstreamPoolReady = 7;
+  UpstreamPeriodic = 8;
+  UpstreamEnd = 9;
+  DownstreamTunnelSuccessfullyEstablished = 10;
+  UdpTunnelUpstreamConnected = 11;
+  UdpPeriodic = 12;
+  UdpSessionEnd = 13;
+}
+
+message TCPAccessLogEntry {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.data.accesslog.v2.TCPAccessLogEntry";
+
+  // Common properties shared by all Envoy access logs.
+  AccessLogCommon common_properties = 1;
+
+  // Properties of the TCP connection.
+  ConnectionProperties connection_properties = 2;
+}
+
+message HTTPAccessLogEntry {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.data.accesslog.v2.HTTPAccessLogEntry";
+
+  // HTTP version
+  enum HTTPVersion {
+    PROTOCOL_UNSPECIFIED = 0;
+    HTTP10 = 1;
+    HTTP11 = 2;
+    HTTP2 = 3;
+    HTTP3 = 4;
+  }
+
+  // Common properties shared by all Envoy access logs.
+  AccessLogCommon common_properties = 1;
+
+  HTTPVersion protocol_version = 2;
+
+  // Description of the incoming HTTP request.
+  HTTPRequestProperties request = 3;
+
+  // Description of the outgoing HTTP response.
+  HTTPResponseProperties response = 4;
+}
+
+// Defines fields for a connection
+message ConnectionProperties {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.data.accesslog.v2.ConnectionProperties";
+
+  // Number of bytes received from downstream.
+  uint64 received_bytes = 1;
+
+  // Number of bytes sent to downstream.
+  uint64 sent_bytes = 2;
+}
+
+// Defines fields that are shared by all Envoy access logs.
+// [#next-free-field: 34]
+message AccessLogCommon {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.data.accesslog.v2.AccessLogCommon";
+
+  // [#not-implemented-hide:]
+  // This field indicates the rate at which this log entry was sampled.
+  // Valid range is (0.0, 1.0].
+  double sample_rate = 1 [(validate.rules).double = {lte: 1.0 gt: 0.0}];
+
+  // This field is the remote/origin address on which the request from the user was received.
+  //
+  // .. note::
+  //   This may not be the actual peer address. For example, it might be derived from headers like ``x-forwarded-for``,
+  //   the proxy protocol, or similar sources.
+  config.core.v3.Address downstream_remote_address = 2;
+
+  // This field is the local/destination address on which the request from the user was received.
+  config.core.v3.Address downstream_local_address = 3;
+
+  // If the connection is secure, this field will contain TLS properties.
+  TLSProperties tls_properties = 4;
+
+  // The time that Envoy started servicing this request. This is effectively the time that the first
+  // downstream byte is received.
+  google.protobuf.Timestamp start_time = 5;
+
+  // Interval between the first downstream byte received and the last
+  // downstream byte received (i.e. time it takes to receive a request).
+  google.protobuf.Duration time_to_last_rx_byte = 6;
+
+  // Interval between the first downstream byte received and the first upstream byte sent. There may
+  // be considerable delta between ``time_to_last_rx_byte`` and this value due to filters.
+  // Additionally, the same caveats apply as documented in ``time_to_last_downstream_tx_byte`` about
+  // not accounting for kernel socket buffer time, etc.
+  google.protobuf.Duration time_to_first_upstream_tx_byte = 7;
+
+  // Interval between the first downstream byte received and the last upstream byte sent. There may
+  // by considerable delta between ``time_to_last_rx_byte`` and this value due to filters.
+  // Additionally, the same caveats apply as documented in ``time_to_last_downstream_tx_byte`` about
+  // not accounting for kernel socket buffer time, etc.
+  google.protobuf.Duration time_to_last_upstream_tx_byte = 8;
+
+  // Interval between the first downstream byte received and the first upstream
+  // byte received (i.e. time it takes to start receiving a response).
+  google.protobuf.Duration time_to_first_upstream_rx_byte = 9;
+
+  // Interval between the first downstream byte received and the last upstream
+  // byte received (i.e. time it takes to receive a complete response).
+  google.protobuf.Duration time_to_last_upstream_rx_byte = 10;
+
+  // Interval between the first downstream byte received and the first downstream byte sent.
+  // There may be a considerable delta between the ``time_to_first_upstream_rx_byte`` and this field
+  // due to filters. Additionally, the same caveats apply as documented in
+  // ``time_to_last_downstream_tx_byte`` about not accounting for kernel socket buffer time, etc.
+  google.protobuf.Duration time_to_first_downstream_tx_byte = 11;
+
+  // Interval between the first downstream byte received and the last downstream byte sent.
+  // Depending on protocol, buffering, windowing, filters, etc. there may be a considerable delta
+  // between ``time_to_last_upstream_rx_byte`` and this field. Note also that this is an approximate
+  // time. In the current implementation it does not include kernel socket buffer time. In the
+  // current implementation it also does not include send window buffering inside the HTTP/2 codec.
+  // In the future it is likely that work will be done to make this duration more accurate.
+  google.protobuf.Duration time_to_last_downstream_tx_byte = 12;
+
+  // The upstream remote/destination address that handles this exchange. This does not include
+  // retries.
+  config.core.v3.Address upstream_remote_address = 13;
+
+  // The upstream local/origin address that handles this exchange. This does not include retries.
+  config.core.v3.Address upstream_local_address = 14;
+
+  // The upstream cluster that ``upstream_remote_address`` belongs to.
+  string upstream_cluster = 15;
+
+  // Flags indicating occurrences during request/response processing.
+  ResponseFlags response_flags = 16;
+
+  // All metadata encountered during request processing, including endpoint
+  // selection.
+  //
+  // This can be used to associate IDs attached to the various configurations
+  // used to process this request with the access log entry. For example, a
+  // route created from a higher level forwarding rule with some ID can place
+  // that ID in this field and cross reference later. It can also be used to
+  // determine if a canary endpoint was used or not.
+  config.core.v3.Metadata metadata = 17;
+
+  // If upstream connection failed due to transport socket (e.g. TLS handshake), provides the
+  // failure reason from the transport socket. The format of this field depends on the configured
+  // upstream transport socket. Common TLS failures are in
+  // :ref:`TLS troubleshooting <arch_overview_ssl_trouble_shooting>`.
+  string upstream_transport_failure_reason = 18;
+
+  // The name of the route
+  string route_name = 19;
+
+  // This field is the downstream direct remote address on which the request from the user was
+  // received. Note: This is always the physical peer, even if the remote address is inferred from
+  // for example the x-forwarder-for header, proxy protocol, etc.
+  config.core.v3.Address downstream_direct_remote_address = 20;
+
+  // Map of filter state in stream info that have been configured to be logged. If the filter
+  // state serialized to any message other than ``google.protobuf.Any`` it will be packed into
+  // ``google.protobuf.Any``.
+  map<string, google.protobuf.Any> filter_state_objects = 21;
+
+  // A list of custom tags, which annotate logs with additional information.
+  // To configure this value, see the documentation for
+  // :ref:`custom_tags <envoy_v3_api_field_extensions.access_loggers.grpc.v3.CommonGrpcAccessLogConfig.custom_tags>`.
+  map<string, string> custom_tags = 22;
+
+  // For HTTP: Total duration in milliseconds of the request from the start time to the last byte out.
+  // For TCP: Total duration in milliseconds of the downstream connection.
+  // This is the total duration of the request (i.e., when the request's ActiveStream is destroyed)
+  // and may be longer than ``time_to_last_downstream_tx_byte``.
+  google.protobuf.Duration duration = 23;
+
+  // For HTTP: Number of times the request is attempted upstream. Note that the field is omitted when the request was never attempted upstream.
+  // For TCP: Number of times the connection request is attempted upstream. Note that the field is omitted when the connect request was never attempted upstream.
+  uint32 upstream_request_attempt_count = 24;
+
+  // Connection termination details may provide additional information about why the connection was terminated by Envoy for L4 reasons.
+  string connection_termination_details = 25;
+
+  // Optional unique id of stream (TCP connection, long-live HTTP2 stream, HTTP request) for logging and tracing.
+  // This could be any format string that could be used to identify one stream.
+  string stream_id = 26;
+
+  // Indicates whether this log entry is the final entry (flushed after the stream completed) or an intermediate entry
+  // (flushed periodically during the stream).
+  //
+  // For long-lived streams (e.g., TCP connections or long-lived HTTP/2 streams), there may be multiple intermediate
+  // entries and only one final entry.
+  //
+  // If needed, a unique identifier (see :ref:`stream_id <envoy_v3_api_field_data.accesslog.v3.AccessLogCommon.stream_id>`)
+  // can be used to correlate all intermediate and final log entries for the same stream.
+  //
+  // .. attention::
+  //
+  //   This field is deprecated in favor of ``access_log_type``, which provides a clearer indication of the log entry
+  //   type.
+  bool intermediate_log_entry = 27
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // If downstream connection in listener failed due to transport socket (e.g. TLS handshake), provides the
+  // failure reason from the transport socket. The format of this field depends on the configured downstream
+  // transport socket. Common TLS failures are in :ref:`TLS troubleshooting <arch_overview_ssl_trouble_shooting>`.
+  string downstream_transport_failure_reason = 28;
+
+  // For HTTP: Total number of bytes sent to the downstream by the http stream.
+  // For TCP: Total number of bytes sent to the downstream by the :ref:`TCP Proxy <config_network_filters_tcp_proxy>`.
+  uint64 downstream_wire_bytes_sent = 29;
+
+  // For HTTP: Total number of bytes received from the downstream by the http stream. Envoy over counts sizes of received HTTP/1.1 pipelined requests by adding up bytes of requests in the pipeline to the one currently being processed.
+  // For TCP: Total number of bytes received from the downstream by the :ref:`TCP Proxy <config_network_filters_tcp_proxy>`.
+  uint64 downstream_wire_bytes_received = 30;
+
+  // For HTTP: Total number of bytes sent to the upstream by the http stream. This value accumulates during upstream retries.
+  // For TCP: Total number of bytes sent to the upstream by the :ref:`TCP Proxy <config_network_filters_tcp_proxy>`.
+  uint64 upstream_wire_bytes_sent = 31;
+
+  // For HTTP: Total number of bytes received from the upstream by the http stream.
+  // For TCP: Total number of bytes sent to the upstream by the :ref:`TCP Proxy <config_network_filters_tcp_proxy>`.
+  uint64 upstream_wire_bytes_received = 32;
+
+  // The type of the access log, which indicates when the log was recorded.
+  // See :ref:`ACCESS_LOG_TYPE <config_access_log_format_access_log_type>` for the available values.
+  // In case the access log was recorded by a flow which does not correspond to one of the supported
+  // values, then the default value will be ``NotSet``.
+  // For more information about how access log behaves and when it is being recorded,
+  // please refer to :ref:`access logging <arch_overview_access_logs>`.
+  AccessLogType access_log_type = 33;
+}
+
+// Flags indicating occurrences during request/response processing.
+// [#next-free-field: 29]
+message ResponseFlags {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.data.accesslog.v2.ResponseFlags";
+
+  message Unauthorized {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.data.accesslog.v2.ResponseFlags.Unauthorized";
+
+    // Reasons why the request was unauthorized
+    enum Reason {
+      REASON_UNSPECIFIED = 0;
+
+      // The request was denied by the external authorization service.
+      EXTERNAL_SERVICE = 1;
+    }
+
+    Reason reason = 1;
+  }
+
+  // Indicates local server healthcheck failed.
+  bool failed_local_healthcheck = 1;
+
+  // Indicates there was no healthy upstream.
+  bool no_healthy_upstream = 2;
+
+  // Indicates there was an upstream request timeout.
+  bool upstream_request_timeout = 3;
+
+  // Indicates local codec level reset was sent on the stream.
+  bool local_reset = 4;
+
+  // Indicates remote codec level reset was received on the stream.
+  bool upstream_remote_reset = 5;
+
+  // Indicates there was a local reset by a connection pool due to an initial connection failure.
+  bool upstream_connection_failure = 6;
+
+  // Indicates the stream was reset due to an upstream connection termination.
+  bool upstream_connection_termination = 7;
+
+  // Indicates the stream was reset because of a resource overflow.
+  bool upstream_overflow = 8;
+
+  // Indicates no route was found for the request.
+  bool no_route_found = 9;
+
+  // Indicates that the request was delayed before proxying.
+  bool delay_injected = 10;
+
+  // Indicates that the request was aborted with an injected error code.
+  bool fault_injected = 11;
+
+  // Indicates that the request was rate-limited locally.
+  bool rate_limited = 12;
+
+  // Indicates if the request was deemed unauthorized and the reason for it.
+  Unauthorized unauthorized_details = 13;
+
+  // Indicates that the request was rejected because there was an error in rate limit service.
+  bool rate_limit_service_error = 14;
+
+  // Indicates the stream was reset due to a downstream connection termination.
+  bool downstream_connection_termination = 15;
+
+  // Indicates that the upstream retry limit was exceeded, resulting in a downstream error.
+  bool upstream_retry_limit_exceeded = 16;
+
+  // Indicates that the stream idle timeout was hit, resulting in a downstream 408.
+  bool stream_idle_timeout = 17;
+
+  // Indicates that the request was rejected because an envoy request header failed strict
+  // validation.
+  bool invalid_envoy_request_headers = 18;
+
+  // Indicates there was an HTTP protocol error on the downstream request.
+  bool downstream_protocol_error = 19;
+
+  // Indicates there was a max stream duration reached on the upstream request.
+  bool upstream_max_stream_duration_reached = 20;
+
+  // Indicates the response was served from a cache filter.
+  bool response_from_cache_filter = 21;
+
+  // Indicates that a filter configuration is not available.
+  bool no_filter_config_found = 22;
+
+  // Indicates that the request or connection exceeded the downstream connection duration.
+  bool duration_timeout = 23;
+
+  // Indicates there was an HTTP protocol error in the upstream response.
+  bool upstream_protocol_error = 24;
+
+  // Indicates no cluster was found for the request.
+  bool no_cluster_found = 25;
+
+  // Indicates overload manager terminated the request.
+  bool overload_manager = 26;
+
+  // Indicates a DNS resolution failed.
+  bool dns_resolution_failure = 27;
+
+  // Indicates a downstream remote codec level reset was received on the stream
+  bool downstream_remote_reset = 28;
+}
+
+// Properties of a negotiated TLS connection.
+// [#next-free-field: 8]
+message TLSProperties {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.data.accesslog.v2.TLSProperties";
+
+  enum TLSVersion {
+    VERSION_UNSPECIFIED = 0;
+    TLSv1 = 1;
+    TLSv1_1 = 2;
+    TLSv1_2 = 3;
+    TLSv1_3 = 4;
+  }
+
+  message CertificateProperties {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.data.accesslog.v2.TLSProperties.CertificateProperties";
+
+    message SubjectAltName {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.data.accesslog.v2.TLSProperties.CertificateProperties.SubjectAltName";
+
+      oneof san {
+        string uri = 1;
+
+        // [#not-implemented-hide:]
+        string dns = 2;
+      }
+    }
+
+    // SANs present in the certificate.
+    repeated SubjectAltName subject_alt_name = 1;
+
+    // The subject field of the certificate.
+    string subject = 2;
+
+    // The issuer field of the certificate.
+    string issuer = 3;
+  }
+
+  // Version of TLS that was negotiated.
+  TLSVersion tls_version = 1;
+
+  // TLS cipher suite negotiated during handshake. The value is a
+  // four-digit hex code defined by the IANA TLS Cipher Suite Registry
+  // (e.g. ``009C`` for ``TLS_RSA_WITH_AES_128_GCM_SHA256``).
+  //
+  // Here it is expressed as an integer.
+  google.protobuf.UInt32Value tls_cipher_suite = 2;
+
+  // SNI hostname from handshake.
+  string tls_sni_hostname = 3;
+
+  // Properties of the local certificate used to negotiate TLS.
+  CertificateProperties local_certificate_properties = 4;
+
+  // Properties of the peer certificate used to negotiate TLS.
+  CertificateProperties peer_certificate_properties = 5;
+
+  // The TLS session ID.
+  string tls_session_id = 6;
+
+  // The ``JA3`` fingerprint when ``JA3`` fingerprinting is enabled.
+  string ja3_fingerprint = 7;
+}
+
+// [#next-free-field: 16]
+message HTTPRequestProperties {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.data.accesslog.v2.HTTPRequestProperties";
+
+  // The request method (RFC 7231/2616).
+  config.core.v3.RequestMethod request_method = 1 [(validate.rules).enum = {defined_only: true}];
+
+  // The scheme portion of the incoming request URI.
+  string scheme = 2;
+
+  // HTTP/2 ``:authority`` or HTTP/1.1 ``Host`` header value.
+  string authority = 3;
+
+  // The port of the incoming request URI
+  // (unused currently, as port is composed onto authority).
+  google.protobuf.UInt32Value port = 4;
+
+  // The path portion from the incoming request URI.
+  string path = 5;
+
+  // Value of the ``User-Agent`` request header.
+  string user_agent = 6;
+
+  // Value of the ``Referer`` request header.
+  string referer = 7;
+
+  // Value of the ``X-Forwarded-For`` request header.
+  string forwarded_for = 8;
+
+  // Value of the ``X-Request-Id`` request header
+  //
+  // This header is used by Envoy to uniquely identify a request.
+  // It will be generated for all external requests and internal requests that
+  // do not already have a request ID.
+  string request_id = 9;
+
+  // Value of the ``x-envoy-original-path`` request header.
+  string original_path = 10;
+
+  // Size of the HTTP request headers in bytes.
+  //
+  // This value is captured from the OSI layer 7 perspective, i.e. it does not
+  // include overhead from framing or encoding at other networking layers.
+  uint64 request_headers_bytes = 11;
+
+  // Size of the HTTP request body in bytes.
+  //
+  // This value is captured from the OSI layer 7 perspective, i.e. it does not
+  // include overhead from framing or encoding at other networking layers.
+  uint64 request_body_bytes = 12;
+
+  // Map of additional headers that have been configured to be logged.
+  map<string, string> request_headers = 13;
+
+  // Number of header bytes sent to the upstream by the http stream, including protocol overhead.
+  //
+  // This value accumulates during upstream retries.
+  uint64 upstream_header_bytes_sent = 14;
+
+  // Number of header bytes received from the downstream by the http stream, including protocol overhead.
+  uint64 downstream_header_bytes_received = 15;
+}
+
+// [#next-free-field: 9]
+message HTTPResponseProperties {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.data.accesslog.v2.HTTPResponseProperties";
+
+  // The HTTP response code returned by Envoy.
+  google.protobuf.UInt32Value response_code = 1;
+
+  // Size of the HTTP response headers in bytes.
+  //
+  // This value is captured from the OSI layer 7 perspective, i.e. it does not
+  // include protocol overhead or overhead from framing or encoding at other networking layers.
+  uint64 response_headers_bytes = 2;
+
+  // Size of the HTTP response body in bytes.
+  //
+  // This value is captured from the OSI layer 7 perspective, i.e. it does not
+  // include overhead from framing or encoding at other networking layers.
+  uint64 response_body_bytes = 3;
+
+  // Map of additional headers configured to be logged.
+  map<string, string> response_headers = 4;
+
+  // Map of trailers configured to be logged.
+  map<string, string> response_trailers = 5;
+
+  // The HTTP response code details.
+  string response_code_details = 6;
+
+  // Number of header bytes received from the upstream by the http stream, including protocol overhead.
+  uint64 upstream_header_bytes_received = 7;
+
+  // Number of header bytes sent to the downstream by the http stream, including protocol overhead.
+  uint64 downstream_header_bytes_sent = 8;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/clusters/aggregate/v3/cluster.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/clusters/aggregate/v3/cluster.proto
new file mode 100644
index 00000000000..d23d767f73b
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/clusters/aggregate/v3/cluster.proto
@@ -0,0 +1,44 @@
+syntax = "proto3";
+
+package envoy.extensions.clusters.aggregate.v3;
+
+import "envoy/config/core/v3/config_source.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.clusters.aggregate.v3";
+option java_outer_classname = "ClusterProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/clusters/aggregate/v3;aggregatev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Aggregate cluster configuration]
+
+// Configuration for the aggregate cluster. See the :ref:`architecture overview
+// <arch_overview_aggregate_cluster>` for more information.
+// [#extension: envoy.clusters.aggregate]
+message ClusterConfig {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.cluster.aggregate.v2alpha.ClusterConfig";
+
+  // Load balancing clusters in aggregate cluster. Clusters are prioritized based on the order they
+  // appear in this list.
+  repeated string clusters = 1 [(validate.rules).repeated = {min_items: 1}];
+}
+
+// Configures an aggregate cluster whose
+// :ref:`ClusterConfig <envoy_v3_api_msg_extensions.clusters.aggregate.v3.ClusterConfig>`
+// is to be fetched from a separate xDS resource.
+// [#extension: envoy.clusters.aggregate_resource]
+// [#not-implemented-hide:]
+message AggregateClusterResource {
+  // Configuration source specifier for the ClusterConfig resource.
+  // Only the aggregated protocol variants are supported; if configured
+  // otherwise, the cluster resource will be NACKed.
+  config.core.v3.ConfigSource config_source = 1 [(validate.rules).message = {required: true}];
+
+  // The name of the ClusterConfig resource to subscribe to.
+  string resource_name = 2 [(validate.rules).string = {min_len: 1}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/common/fault/v3/fault.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/common/fault/v3/fault.proto
new file mode 100644
index 00000000000..ab24f5d2374
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/common/fault/v3/fault.proto
@@ -0,0 +1,97 @@
+syntax = "proto3";
+
+package envoy.extensions.filters.common.fault.v3;
+
+import "envoy/type/v3/percent.proto";
+
+import "google/protobuf/duration.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.filters.common.fault.v3";
+option java_outer_classname = "FaultProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/filters/common/fault/v3;faultv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Common fault injection types]
+
+// Delay specification is used to inject latency into the
+// HTTP/Mongo operation.
+// [#next-free-field: 6]
+message FaultDelay {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.fault.v2.FaultDelay";
+
+  enum FaultDelayType {
+    // Unused and deprecated.
+    FIXED = 0;
+  }
+
+  // Fault delays are controlled via an HTTP header (if applicable). See the
+  // :ref:`HTTP fault filter <config_http_filters_fault_injection_http_header>` documentation for
+  // more information.
+  message HeaderDelay {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.filter.fault.v2.FaultDelay.HeaderDelay";
+  }
+
+  reserved 2, 1;
+
+  reserved "type";
+
+  oneof fault_delay_secifier {
+    option (validate.required) = true;
+
+    // Add a fixed delay before forwarding the operation upstream. See
+    // https://developers.google.com/protocol-buffers/docs/proto3#json for
+    // the JSON/YAML Duration mapping. For HTTP/Mongo, the specified
+    // delay will be injected before a new request/operation.
+    // This is required if type is FIXED.
+    google.protobuf.Duration fixed_delay = 3 [(validate.rules).duration = {gt {}}];
+
+    // Fault delays are controlled via an HTTP header (if applicable).
+    HeaderDelay header_delay = 5;
+  }
+
+  // The percentage of operations/connections/requests on which the delay will be injected.
+  type.v3.FractionalPercent percentage = 4;
+}
+
+// Describes a rate limit to be applied.
+message FaultRateLimit {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.fault.v2.FaultRateLimit";
+
+  // Describes a fixed/constant rate limit.
+  message FixedLimit {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.filter.fault.v2.FaultRateLimit.FixedLimit";
+
+    // The limit supplied in KiB/s.
+    uint64 limit_kbps = 1 [(validate.rules).uint64 = {gte: 1}];
+  }
+
+  // Rate limits are controlled via an HTTP header (if applicable). See the
+  // :ref:`HTTP fault filter <config_http_filters_fault_injection_http_header>` documentation for
+  // more information.
+  message HeaderLimit {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.filter.fault.v2.FaultRateLimit.HeaderLimit";
+  }
+
+  oneof limit_type {
+    option (validate.required) = true;
+
+    // A fixed rate limit.
+    FixedLimit fixed_limit = 1;
+
+    // Rate limits are controlled via an HTTP header (if applicable).
+    HeaderLimit header_limit = 3;
+  }
+
+  // The percentage of operations/connections/requests on which the rate limit will be injected.
+  type.v3.FractionalPercent percentage = 2;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/ext_authz/v3/ext_authz.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/ext_authz/v3/ext_authz.proto
new file mode 100644
index 00000000000..7cf2aac64aa
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/ext_authz/v3/ext_authz.proto
@@ -0,0 +1,529 @@
+syntax = "proto3";
+
+package envoy.extensions.filters.http.ext_authz.v3;
+
+import "envoy/config/common/mutation_rules/v3/mutation_rules.proto";
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/config_source.proto";
+import "envoy/config/core/v3/grpc_service.proto";
+import "envoy/config/core/v3/http_uri.proto";
+import "envoy/type/matcher/v3/metadata.proto";
+import "envoy/type/matcher/v3/string.proto";
+import "envoy/type/v3/http_status.proto";
+
+import "google/protobuf/struct.proto";
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/sensitive.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.filters.http.ext_authz.v3";
+option java_outer_classname = "ExtAuthzProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/filters/http/ext_authz/v3;ext_authzv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: External Authorization]
+// External Authorization :ref:`configuration overview <config_http_filters_ext_authz>`.
+// [#extension: envoy.filters.http.ext_authz]
+
+// [#next-free-field: 30]
+message ExtAuthz {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.http.ext_authz.v3.ExtAuthz";
+
+  reserved 4;
+
+  reserved "use_alpha";
+
+  // External authorization service configuration.
+  oneof services {
+    // gRPC service configuration (default timeout: 200ms).
+    config.core.v3.GrpcService grpc_service = 1;
+
+    // HTTP service configuration (default timeout: 200ms).
+    HttpService http_service = 3;
+  }
+
+  // API version for ext_authz transport protocol. This describes the ext_authz gRPC endpoint and
+  // version of messages used on the wire.
+  config.core.v3.ApiVersion transport_api_version = 12
+      [(validate.rules).enum = {defined_only: true}];
+
+  // Changes the filter's behavior on errors:
+  //
+  // #. When set to ``true``, the filter will ``accept`` the client request even if communication with
+  //    the authorization service has failed, or if the authorization service has returned an HTTP 5xx
+  //    error.
+  //
+  // #. When set to ``false``, the filter will ``reject`` client requests and return ``Forbidden``
+  //    if communication with the authorization service has failed, or if the authorization service
+  //    has returned an HTTP 5xx error.
+  //
+  // Errors can always be tracked in the :ref:`stats <config_http_filters_ext_authz_stats>`.
+  bool failure_mode_allow = 2;
+
+  // When ``failure_mode_allow`` and ``failure_mode_allow_header_add`` are both set to ``true``,
+  // ``x-envoy-auth-failure-mode-allowed: true`` will be added to request headers if the communication
+  // with the authorization service has failed, or if the authorization service has returned a
+  // HTTP 5xx error.
+  bool failure_mode_allow_header_add = 19;
+
+  // Enables the filter to buffer the client request body and send it within the authorization request.
+  // The ``x-envoy-auth-partial-body: false|true`` metadata header will be added to the authorization
+  // request indicating whether the body data is partial.
+  BufferSettings with_request_body = 5;
+
+  // Clears the route cache in order to allow the external authorization service to correctly affect
+  // routing decisions. The filter clears all cached routes when:
+  //
+  // #. The field is set to ``true``.
+  //
+  // #. The status returned from the authorization service is an HTTP 200 or gRPC 0.
+  //
+  // #. At least one ``authorization response header`` is added to the client request, or is used to
+  //    alter another client request header.
+  //
+  bool clear_route_cache = 6;
+
+  // Sets the HTTP status that is returned to the client when the authorization server returns an error
+  // or cannot be reached. The default status is HTTP 403 Forbidden.
+  type.v3.HttpStatus status_on_error = 7;
+
+  // When this is set to ``true``, the filter will check the :ref:`ext_authz response
+  // <envoy_v3_api_msg_service.auth.v3.CheckResponse>` for invalid header and
+  // query parameter mutations. If the side stream response is invalid, it will send a local reply
+  // to the downstream request with status HTTP 500 Internal Server Error.
+  //
+  // .. note::
+  //   Both ``headers_to_remove`` and ``query_parameters_to_remove`` are validated, but invalid elements in
+  //   those fields should not affect any headers and thus will not cause the filter to send a local reply.
+  //
+  // When set to ``false``, any invalid mutations will be visible to the rest of Envoy and may cause
+  // unexpected behavior.
+  //
+  // If you are using ext_authz with an untrusted ext_authz server, you should set this to ``true``.
+  bool validate_mutations = 24;
+
+  // Specifies a list of metadata namespaces whose values, if present, will be passed to the
+  // ext_authz service. The :ref:`filter_metadata <envoy_v3_api_field_config.core.v3.Metadata.filter_metadata>`
+  // is passed as an opaque ``protobuf::Struct``.
+  //
+  // .. note::
+  //   This field applies exclusively to the gRPC ext_authz service and has no effect on the HTTP service.
+  //
+  // For example, if the ``jwt_authn`` filter is used and :ref:`payload_in_metadata
+  // <envoy_v3_api_field_extensions.filters.http.jwt_authn.v3.JwtProvider.payload_in_metadata>` is set,
+  // then the following will pass the jwt payload to the authorization server.
+  //
+  // .. code-block:: yaml
+  //
+  //    metadata_context_namespaces:
+  //    - envoy.filters.http.jwt_authn
+  //
+  repeated string metadata_context_namespaces = 8;
+
+  // Specifies a list of metadata namespaces whose values, if present, will be passed to the
+  // ext_authz service. :ref:`typed_filter_metadata <envoy_v3_api_field_config.core.v3.Metadata.typed_filter_metadata>`
+  // is passed as a ``protobuf::Any``.
+  //
+  // .. note::
+  //   This field applies exclusively to the gRPC ext_authz service and has no effect on the HTTP service.
+  //
+  // This works similarly to ``metadata_context_namespaces`` but allows Envoy and the ext_authz server to share
+  // the protobuf message definition in order to perform safe parsing.
+  //
+  repeated string typed_metadata_context_namespaces = 16;
+
+  // Specifies a list of route metadata namespaces whose values, if present, will be passed to the
+  // ext_authz service at :ref:`route_metadata_context <envoy_v3_api_field_service.auth.v3.AttributeContext.route_metadata_context>` in
+  // :ref:`CheckRequest <envoy_v3_api_field_service.auth.v3.CheckRequest.attributes>`.
+  // :ref:`filter_metadata <envoy_v3_api_field_config.core.v3.Metadata.filter_metadata>` is passed as an opaque ``protobuf::Struct``.
+  repeated string route_metadata_context_namespaces = 21;
+
+  // Specifies a list of route metadata namespaces whose values, if present, will be passed to the
+  // ext_authz service at :ref:`route_metadata_context <envoy_v3_api_field_service.auth.v3.AttributeContext.route_metadata_context>` in
+  // :ref:`CheckRequest <envoy_v3_api_field_service.auth.v3.CheckRequest.attributes>`.
+  // :ref:`typed_filter_metadata <envoy_v3_api_field_config.core.v3.Metadata.typed_filter_metadata>` is passed as a ``protobuf::Any``.
+  repeated string route_typed_metadata_context_namespaces = 22;
+
+  // Specifies if the filter is enabled.
+  //
+  // If :ref:`runtime_key <envoy_v3_api_field_config.core.v3.RuntimeFractionalPercent.runtime_key>` is specified,
+  // Envoy will lookup the runtime key to get the percentage of requests to filter.
+  //
+  // If this field is not specified, the filter will be enabled for all requests.
+  config.core.v3.RuntimeFractionalPercent filter_enabled = 9;
+
+  // Specifies if the filter is enabled with metadata matcher.
+  // If this field is not specified, the filter will be enabled for all requests.
+  type.matcher.v3.MetadataMatcher filter_enabled_metadata = 14;
+
+  // Specifies whether to deny the requests when the filter is disabled.
+  // If :ref:`runtime_key <envoy_v3_api_field_config.core.v3.RuntimeFeatureFlag.runtime_key>` is specified,
+  // Envoy will lookup the runtime key to determine whether to deny requests for filter-protected paths
+  // when the filter is disabled. If the filter is disabled in ``typed_per_filter_config`` for the path,
+  // requests will not be denied.
+  //
+  // If this field is not specified, all requests will be allowed when disabled.
+  //
+  // If a request is denied due to this setting, the response code in :ref:`status_on_error
+  // <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.status_on_error>` will
+  // be returned.
+  config.core.v3.RuntimeFeatureFlag deny_at_disable = 11;
+
+  // Specifies if the peer certificate is sent to the external service.
+  //
+  // When this field is ``true``, Envoy will include the peer X.509 certificate, if available, in the
+  // :ref:`certificate<envoy_v3_api_field_service.auth.v3.AttributeContext.Peer.certificate>`.
+  bool include_peer_certificate = 10;
+
+  // Optional additional prefix to use when emitting statistics. This allows distinguishing
+  // emitted statistics between configured ``ext_authz`` filters in an HTTP filter chain. For example:
+  //
+  // .. code-block:: yaml
+  //
+  //   http_filters:
+  //     - name: envoy.filters.http.ext_authz
+  //       typed_config:
+  //         "@type": type.googleapis.com/envoy.extensions.filters.http.ext_authz.v3.ExtAuthz
+  //         stat_prefix: waf # This emits ext_authz.waf.ok, ext_authz.waf.denied, etc.
+  //     - name: envoy.filters.http.ext_authz
+  //       typed_config:
+  //         "@type": type.googleapis.com/envoy.extensions.filters.http.ext_authz.v3.ExtAuthz
+  //         stat_prefix: blocker # This emits ext_authz.blocker.ok, ext_authz.blocker.denied, etc.
+  //
+  string stat_prefix = 13;
+
+  // Optional labels that will be passed to :ref:`labels<envoy_v3_api_field_service.auth.v3.AttributeContext.Peer.labels>` in
+  // :ref:`destination<envoy_v3_api_field_service.auth.v3.AttributeContext.destination>`.
+  // The labels will be read from :ref:`metadata<envoy_v3_api_msg_config.core.v3.Node>` with the specified key.
+  string bootstrap_metadata_labels_key = 15;
+
+  // Check request to authorization server will include the client request headers that have a correspondent match
+  // in the :ref:`list <envoy_v3_api_msg_type.matcher.v3.ListStringMatcher>`. If this option isn't specified, then
+  // all client request headers are included in the check request to a gRPC authorization server, whereas no client request headers
+  // (besides the ones allowed by default - see note below) are included in the check request to an HTTP authorization server.
+  // This inconsistency between gRPC and HTTP servers is to maintain backwards compatibility with legacy behavior.
+  //
+  // .. note::
+  //
+  //  For requests to an HTTP authorization server: in addition to the user's supplied matchers, ``Host``, ``Method``, ``Path``,
+  //  ``Content-Length``, and ``Authorization`` are **additionally included** in the list.
+  //
+  // .. note::
+  //
+  //  For requests to an HTTP authorization server: the value of ``Content-Length`` will be set to ``0`` and the request to the
+  //  authorization server will not have a message body. However, the check request can include the buffered
+  //  client request body (controlled by :ref:`with_request_body
+  //  <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.with_request_body>` setting);
+  //  consequently, the value of ``Content-Length`` in the authorization request reflects the size of its payload.
+  //
+  // .. note::
+  //
+  //  This can be overridden by the field ``disallowed_headers`` below. That is, if a header
+  //  matches for both ``allowed_headers`` and ``disallowed_headers``, the header will NOT be sent.
+  type.matcher.v3.ListStringMatcher allowed_headers = 17;
+
+  // If set, specifically disallow any header in this list to be forwarded to the external
+  // authentication server. This overrides the above ``allowed_headers`` if a header matches both.
+  type.matcher.v3.ListStringMatcher disallowed_headers = 25;
+
+  // Specifies if the TLS session level details like SNI are sent to the external service.
+  //
+  // When this field is ``true``, Envoy will include the SNI name used for TLSClientHello, if available, in the
+  // :ref:`tls_session<envoy_v3_api_field_service.auth.v3.AttributeContext.tls_session>`.
+  bool include_tls_session = 18;
+
+  // Whether to increment cluster statistics (e.g. cluster.<cluster_name>.upstream_rq_*) on authorization failure.
+  // Defaults to ``true``.
+  google.protobuf.BoolValue charge_cluster_response_stats = 20;
+
+  // Whether to encode the raw headers (i.e., unsanitized values and unconcatenated multi-line headers)
+  // in the authorization request. Works with both HTTP and gRPC clients.
+  //
+  // When this is set to ``true``, header values are not sanitized. Headers with the same key will also
+  // not be combined into a single, comma-separated header.
+  // Requests to gRPC services will populate the field
+  // :ref:`header_map<envoy_v3_api_field_service.auth.v3.AttributeContext.HttpRequest.header_map>`.
+  // Requests to HTTP services will be constructed with the unsanitized header values and preserved
+  // multi-line headers with the same key.
+  //
+  // If this field is set to ``false``, header values will be sanitized, with any non-UTF-8-compliant
+  // bytes replaced with ``'!'``. Headers with the same key will have their values concatenated into a
+  // single comma-separated header value.
+  // Requests to gRPC services will populate the field
+  // :ref:`headers<envoy_v3_api_field_service.auth.v3.AttributeContext.HttpRequest.headers>`.
+  // Requests to HTTP services will have their header values sanitized and will not preserve
+  // multi-line headers with the same key.
+  //
+  // It is recommended to set this to ``true`` unless you rely on the previous behavior.
+  //
+  // It is set to ``false`` by default for backwards compatibility.
+  bool encode_raw_headers = 23;
+
+  // Rules for what modifications an ext_authz server may make to the request headers before
+  // continuing decoding / forwarding upstream.
+  //
+  // If set to anything, enables header mutation checking against configured rules. Note that
+  // :ref:`HeaderMutationRules <envoy_v3_api_msg_config.common.mutation_rules.v3.HeaderMutationRules>`
+  // has defaults that change ext_authz behavior. Also note that if this field is set to anything,
+  // ext_authz can no longer append to :-prefixed headers.
+  //
+  // If empty, header mutation rule checking is completely disabled.
+  //
+  // Regardless of what is configured here, ext_authz cannot remove :-prefixed headers.
+  //
+  // This field and ``validate_mutations`` have different use cases. ``validate_mutations`` enables
+  // correctness checks for all header / query parameter mutations (e.g. for invalid characters).
+  // This field allows the filter to reject mutations to specific headers.
+  config.common.mutation_rules.v3.HeaderMutationRules decoder_header_mutation_rules = 26;
+
+  // Enable or disable ingestion of dynamic metadata from the ext_authz service.
+  //
+  // If ``false``, the filter will ignore dynamic metadata injected by the ext_authz service. If the
+  // ext_authz service tries injecting dynamic metadata, the filter will log, increment the
+  // ``ignored_dynamic_metadata`` stat, then continue handling the response.
+  //
+  // If ``true``, the filter will ingest dynamic metadata entries as normal.
+  //
+  // If unset, defaults to ``true``.
+  google.protobuf.BoolValue enable_dynamic_metadata_ingestion = 27;
+
+  // Additional metadata to be added to the filter state for logging purposes. The metadata will be
+  // added to StreamInfo's filter state under the namespace corresponding to the ext_authz filter
+  // name.
+  google.protobuf.Struct filter_metadata = 28;
+
+  // When set to ``true``, the filter will emit per-stream stats for access logging. The filter state
+  // key will be the same as the filter name.
+  //
+  // If using Envoy gRPC, emits latency, bytes sent / received, upstream info, and upstream cluster
+  // info. If not using Envoy gRPC, emits only latency. Note that stats are ONLY added to filter
+  // state if a check request is actually made to an ext_authz service.
+  //
+  // If this is ``false`` the filter will not emit stats, but filter_metadata will still be respected if
+  // it has a value.
+  //
+  // Field ``latency_us`` is exposed for CEL and logging when using gRPC or HTTP service.
+  // Fields ``bytesSent`` and ``bytesReceived`` are exposed for CEL and logging only when using gRPC service.
+  bool emit_filter_state_stats = 29;
+}
+
+// Configuration for buffering the request data.
+message BufferSettings {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.http.ext_authz.v2.BufferSettings";
+
+  // Sets the maximum size of a message body that the filter will hold in memory. Envoy will return
+  // ``HTTP 413`` and will *not* initiate the authorization process when the buffer reaches the size
+  // set in this field. Note that this setting will have precedence over :ref:`failure_mode_allow
+  // <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.failure_mode_allow>`.
+  uint32 max_request_bytes = 1 [(validate.rules).uint32 = {gt: 0}];
+
+  // When this field is ``true``, Envoy will buffer the message until ``max_request_bytes`` is reached.
+  // The authorization request will be dispatched and no 413 HTTP error will be returned by the
+  // filter.
+  bool allow_partial_message = 2;
+
+  // If ``true``, the body sent to the external authorization service is set as raw bytes and populates
+  // :ref:`raw_body<envoy_v3_api_field_service.auth.v3.AttributeContext.HttpRequest.raw_body>`
+  // in the HTTP request attribute context. Otherwise, :ref:`body
+  // <envoy_v3_api_field_service.auth.v3.AttributeContext.HttpRequest.body>` will be populated
+  // with a UTF-8 string request body.
+  //
+  // This field only affects configurations using a :ref:`grpc_service
+  // <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.grpc_service>`. In configurations that use
+  // an :ref:`http_service <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.http_service>`, this
+  // has no effect.
+  bool pack_as_bytes = 3;
+}
+
+// HttpService is used for raw HTTP communication between the filter and the authorization service.
+// When configured, the filter will parse the client request and use these attributes to call the
+// authorization server. Depending on the response, the filter may reject or accept the client
+// request. Note that in any of these events, metadata can be added, removed or overridden by the
+// filter:
+//
+// On authorization request, a list of allowed request headers may be supplied. See
+// :ref:`allowed_headers
+// <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.AuthorizationRequest.allowed_headers>`
+// for details. Additional headers metadata may be added to the authorization request. See
+// :ref:`headers_to_add
+// <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.AuthorizationRequest.headers_to_add>` for
+// details.
+//
+// On authorization response status ``HTTP 200 OK``, the filter will allow traffic to the upstream and
+// additional headers metadata may be added to the original client request. See
+// :ref:`allowed_upstream_headers
+// <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.AuthorizationResponse.allowed_upstream_headers>`
+// for details. Additionally, the filter may add additional headers to the client's response. See
+// :ref:`allowed_client_headers_on_success
+// <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.AuthorizationResponse.allowed_client_headers_on_success>`
+// for details.
+//
+// On other authorization response statuses, the filter will not allow traffic. Additional headers
+// metadata as well as body may be added to the client's response. See :ref:`allowed_client_headers
+// <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.AuthorizationResponse.allowed_client_headers>`
+// for details.
+// [#next-free-field: 9]
+message HttpService {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.http.ext_authz.v2.HttpService";
+
+  reserved 3, 4, 5, 6;
+
+  // Sets the HTTP server URI which the authorization requests must be sent to.
+  config.core.v3.HttpUri server_uri = 1;
+
+  // Sets a prefix to the value of authorization request header ``Path``.
+  string path_prefix = 2;
+
+  // Settings used for controlling authorization request metadata.
+  AuthorizationRequest authorization_request = 7;
+
+  // Settings used for controlling authorization response metadata.
+  AuthorizationResponse authorization_response = 8;
+}
+
+message AuthorizationRequest {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.http.ext_authz.v2.AuthorizationRequest";
+
+  // Authorization request includes the client request headers that have a corresponding match
+  // in the :ref:`list <envoy_v3_api_msg_type.matcher.v3.ListStringMatcher>`.
+  // This field has been deprecated in favor of :ref:`allowed_headers
+  // <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.allowed_headers>`.
+  //
+  // .. note::
+  //
+  //   In addition to the user's supplied matchers, ``Host``, ``Method``, ``Path``,
+  //   ``Content-Length``, and ``Authorization`` are **automatically included** in the list.
+  //
+  // .. note::
+  //
+  //   By default, the ``Content-Length`` header is set to ``0`` and the request to the authorization
+  //   service has no message body. However, the authorization request *may* include the buffered
+  //   client request body (controlled by :ref:`with_request_body
+  //   <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.with_request_body>`
+  //   setting); hence the value of its ``Content-Length`` reflects the size of its payload.
+  //
+  type.matcher.v3.ListStringMatcher allowed_headers = 1
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Sets a list of headers that will be included in the request to the authorization service. Note that
+  // client request headers with the same key will be overridden.
+  repeated config.core.v3.HeaderValue headers_to_add = 2;
+}
+
+// [#next-free-field: 6]
+message AuthorizationResponse {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.http.ext_authz.v2.AuthorizationResponse";
+
+  // When this :ref:`list <envoy_v3_api_msg_type.matcher.v3.ListStringMatcher>` is set, authorization
+  // response headers that have a correspondent match will be added to the original client request.
+  // Note that coexistent headers will be overridden.
+  type.matcher.v3.ListStringMatcher allowed_upstream_headers = 1;
+
+  // When this :ref:`list <envoy_v3_api_msg_type.matcher.v3.ListStringMatcher>` is set, authorization
+  // response headers that have a correspondent match will be added to the original client request.
+  // Note that coexistent headers will be appended.
+  type.matcher.v3.ListStringMatcher allowed_upstream_headers_to_append = 3;
+
+  // When this :ref:`list <envoy_v3_api_msg_type.matcher.v3.ListStringMatcher>` is set, authorization
+  // response headers that have a correspondent match will be added to the client's response. Note
+  // that when this list is *not* set, all the authorization response headers, except ``Authority
+  // (Host)`` will be in the response to the client. When a header is included in this list, ``Path``,
+  // ``Status``, ``Content-Length``, ``WWWAuthenticate`` and ``Location`` are automatically added.
+  type.matcher.v3.ListStringMatcher allowed_client_headers = 2;
+
+  // When this :ref:`list <envoy_v3_api_msg_type.matcher.v3.ListStringMatcher>` is set, authorization
+  // response headers that have a correspondent match will be added to the client's response when
+  // the authorization response itself is successful, i.e. not failed or denied. When this list is
+  // *not* set, no additional headers will be added to the client's response on success.
+  type.matcher.v3.ListStringMatcher allowed_client_headers_on_success = 4;
+
+  // When this :ref:`list <envoy_v3_api_msg_type.matcher.v3.ListStringMatcher>` is set, authorization
+  // response headers that have a correspondent match will be emitted as dynamic metadata to be consumed
+  // by the next filter. This metadata lives in a namespace specified by the canonical name of extension filter
+  // that requires it:
+  //
+  // - :ref:`envoy.filters.http.ext_authz <config_http_filters_ext_authz_dynamic_metadata>` for HTTP filter.
+  // - :ref:`envoy.filters.network.ext_authz <config_network_filters_ext_authz_dynamic_metadata>` for network filter.
+  type.matcher.v3.ListStringMatcher dynamic_metadata_from_headers = 5;
+}
+
+// Extra settings on a per virtualhost/route/weighted-cluster level.
+message ExtAuthzPerRoute {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.http.ext_authz.v2.ExtAuthzPerRoute";
+
+  oneof override {
+    option (validate.required) = true;
+
+    // Disable the ext auth filter for this particular vhost or route.
+    // If disabled is specified in multiple per-filter-configs, the most specific one will be used.
+    // If the filter is disabled by default and this is set to ``false``, the filter will be enabled
+    // for this vhost or route.
+    bool disabled = 1;
+
+    // Check request settings for this route.
+    CheckSettings check_settings = 2 [(validate.rules).message = {required: true}];
+  }
+}
+
+// Extra settings for the check request.
+// [#next-free-field: 6]
+message CheckSettings {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.http.ext_authz.v2.CheckSettings";
+
+  // Context extensions to set on the CheckRequest's
+  // :ref:`AttributeContext.context_extensions<envoy_v3_api_field_service.auth.v3.AttributeContext.context_extensions>`
+  //
+  // You can use this to provide extra context for the external authorization server on specific
+  // virtual hosts/routes. For example, adding a context extension on the virtual host level can
+  // give the ext-authz server information on what virtual host is used without needing to parse the
+  // host header. If CheckSettings is specified in multiple per-filter-configs, they will be merged
+  // in order, and the result will be used.
+  //
+  // Merge semantics for this field are such that keys from more specific configs override.
+  //
+  // .. note::
+  //   These settings are only applied to a filter configured with a
+  //   :ref:`grpc_service<envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.grpc_service>`.
+  map<string, string> context_extensions = 1 [(udpa.annotations.sensitive) = true];
+
+  // When set to ``true``, disable the configured :ref:`with_request_body
+  // <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.with_request_body>` for a specific route.
+  //
+  // Only one of ``disable_request_body_buffering`` and
+  // :ref:`with_request_body <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.CheckSettings.with_request_body>`
+  // may be specified.
+  bool disable_request_body_buffering = 2;
+
+  // Enable or override request body buffering, which is configured using the
+  // :ref:`with_request_body <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.with_request_body>`
+  // option for a specific route.
+  //
+  // Only one of ``with_request_body`` and
+  // :ref:`disable_request_body_buffering <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.CheckSettings.disable_request_body_buffering>`
+  // may be specified.
+  BufferSettings with_request_body = 3;
+
+  // Override the external authorization service for this route.
+  // This allows different routes to use different external authorization service backends
+  // and service types (gRPC or HTTP). If specified, this overrides the filter-level service
+  // configuration regardless of the original service type.
+  oneof service_override {
+    // Override with a gRPC service configuration.
+    config.core.v3.GrpcService grpc_service = 4;
+
+    // Override with an HTTP service configuration.
+    HttpService http_service = 5;
+  }
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/fault/v3/fault.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/fault/v3/fault.proto
new file mode 100644
index 00000000000..01f056e7927
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/fault/v3/fault.proto
@@ -0,0 +1,159 @@
+syntax = "proto3";
+
+package envoy.extensions.filters.http.fault.v3;
+
+import "envoy/config/route/v3/route_components.proto";
+import "envoy/extensions/filters/common/fault/v3/fault.proto";
+import "envoy/type/v3/percent.proto";
+
+import "google/protobuf/struct.proto";
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.filters.http.fault.v3";
+option java_outer_classname = "FaultProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/filters/http/fault/v3;faultv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Fault Injection]
+// Fault Injection :ref:`configuration overview <config_http_filters_fault_injection>`.
+// [#extension: envoy.filters.http.fault]
+
+// [#next-free-field: 6]
+message FaultAbort {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.http.fault.v2.FaultAbort";
+
+  // Fault aborts are controlled via an HTTP header (if applicable). See the
+  // :ref:`HTTP fault filter <config_http_filters_fault_injection_http_header>` documentation for
+  // more information.
+  message HeaderAbort {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.filter.http.fault.v2.FaultAbort.HeaderAbort";
+  }
+
+  reserved 1;
+
+  oneof error_type {
+    option (validate.required) = true;
+
+    // HTTP status code to use to abort the HTTP request.
+    uint32 http_status = 2 [(validate.rules).uint32 = {lt: 600 gte: 200}];
+
+    // gRPC status code to use to abort the gRPC request.
+    uint32 grpc_status = 5;
+
+    // Fault aborts are controlled via an HTTP header (if applicable).
+    HeaderAbort header_abort = 4;
+  }
+
+  // The percentage of requests/operations/connections that will be aborted with the error code
+  // provided.
+  type.v3.FractionalPercent percentage = 3;
+}
+
+// [#next-free-field: 17]
+message HTTPFault {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.http.fault.v2.HTTPFault";
+
+  // If specified, the filter will inject delays based on the values in the
+  // object.
+  common.fault.v3.FaultDelay delay = 1;
+
+  // If specified, the filter will abort requests based on the values in
+  // the object. At least ``abort`` or ``delay`` must be specified.
+  FaultAbort abort = 2;
+
+  // Specifies the name of the (destination) upstream cluster that the
+  // filter should match on. Fault injection will be restricted to requests
+  // bound to the specific upstream cluster.
+  string upstream_cluster = 3;
+
+  // Specifies a set of headers that the filter should match on. The fault
+  // injection filter can be applied selectively to requests that match a set of
+  // headers specified in the fault filter config. The chances of actual fault
+  // injection further depend on the value of the :ref:`percentage
+  // <envoy_v3_api_field_extensions.filters.http.fault.v3.FaultAbort.percentage>` field.
+  // The filter will check the request's headers against all the specified
+  // headers in the filter config. A match will happen if all the headers in the
+  // config are present in the request with the same values (or based on
+  // presence if the ``value`` field is not in the config).
+  repeated config.route.v3.HeaderMatcher headers = 4;
+
+  // Faults are injected for the specified list of downstream hosts. If this
+  // setting is not set, faults are injected for all downstream nodes.
+  // Downstream node name is taken from :ref:`the HTTP
+  // x-envoy-downstream-service-node
+  // <config_http_conn_man_headers_downstream-service-node>` header and compared
+  // against downstream_nodes list.
+  repeated string downstream_nodes = 5;
+
+  // The maximum number of faults that can be active at a single time via the configured fault
+  // filter. Note that because this setting can be overridden at the route level, it's possible
+  // for the number of active faults to be greater than this value (if injected via a different
+  // route). If not specified, defaults to unlimited. This setting can be overridden via
+  // ``runtime <config_http_filters_fault_injection_runtime>`` and any faults that are not injected
+  // due to overflow will be indicated via the ``faults_overflow
+  // <config_http_filters_fault_injection_stats>`` stat.
+  //
+  // .. attention::
+  //   Like other :ref:`circuit breakers <arch_overview_circuit_break>` in Envoy, this is a fuzzy
+  //   limit. It's possible for the number of active faults to rise slightly above the configured
+  //   amount due to the implementation details.
+  google.protobuf.UInt32Value max_active_faults = 6;
+
+  // The response rate limit to be applied to the response body of the stream. When configured,
+  // the percentage can be overridden by the :ref:`fault.http.rate_limit.response_percent
+  // <config_http_filters_fault_injection_runtime>` runtime key.
+  //
+  // .. attention::
+  //  This is a per-stream limit versus a connection level limit. This means that concurrent streams
+  //  will each get an independent limit.
+  common.fault.v3.FaultRateLimit response_rate_limit = 7;
+
+  // The runtime key to override the :ref:`default <config_http_filters_fault_injection_runtime>`
+  // runtime. The default is: fault.http.delay.fixed_delay_percent
+  string delay_percent_runtime = 8;
+
+  // The runtime key to override the :ref:`default <config_http_filters_fault_injection_runtime>`
+  // runtime. The default is: fault.http.abort.abort_percent
+  string abort_percent_runtime = 9;
+
+  // The runtime key to override the :ref:`default <config_http_filters_fault_injection_runtime>`
+  // runtime. The default is: fault.http.delay.fixed_duration_ms
+  string delay_duration_runtime = 10;
+
+  // The runtime key to override the :ref:`default <config_http_filters_fault_injection_runtime>`
+  // runtime. The default is: fault.http.abort.http_status
+  string abort_http_status_runtime = 11;
+
+  // The runtime key to override the :ref:`default <config_http_filters_fault_injection_runtime>`
+  // runtime. The default is: fault.http.max_active_faults
+  string max_active_faults_runtime = 12;
+
+  // The runtime key to override the :ref:`default <config_http_filters_fault_injection_runtime>`
+  // runtime. The default is: fault.http.rate_limit.response_percent
+  string response_rate_limit_percent_runtime = 13;
+
+  // The runtime key to override the :ref:`default <config_http_filters_fault_injection_runtime>`
+  // runtime. The default is: fault.http.abort.grpc_status
+  string abort_grpc_status_runtime = 14;
+
+  // To control whether stats storage is allocated dynamically for each downstream server.
+  // If set to true, "x-envoy-downstream-service-cluster" field of header will be ignored by this filter.
+  // If set to false, dynamic stats storage will be allocated for the downstream cluster name.
+  // Default value is false.
+  bool disable_downstream_cluster_stats = 15;
+
+  // When an abort or delay fault is executed, the metadata struct provided here will be added to the
+  // request's dynamic metadata under the namespace corresponding to the name of the fault filter.
+  // This data can be logged as part of Access Logs using the :ref:`command operator
+  // <config_access_log_command_operators>` %DYNAMIC_METADATA(NAMESPACE)%, where NAMESPACE is the name of
+  // the fault filter.
+  google.protobuf.Struct filter_metadata = 16;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.proto
new file mode 100644
index 00000000000..f4646389f7e
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/gcp_authn/v3/gcp_authn.proto
@@ -0,0 +1,87 @@
+syntax = "proto3";
+
+package envoy.extensions.filters.http.gcp_authn.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/http_uri.proto";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.filters.http.gcp_authn.v3";
+option java_outer_classname = "GcpAuthnProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/filters/http/gcp_authn/v3;gcp_authnv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: GCP authentication]
+// GCP authentication :ref:`configuration overview <config_http_filters_gcp_authn>`.
+// [#extension: envoy.filters.http.gcp_authn]
+
+// Filter configuration.
+// [#next-free-field: 7]
+message GcpAuthnFilterConfig {
+  // The HTTP URI to fetch tokens from GCE Metadata Server(https://cloud.google.com/compute/docs/metadata/overview).
+  // The URL format is "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/identity?audience=[AUDIENCE]"
+  //
+  // This field is deprecated because it does not match the API surface provided by the google auth libraries.
+  // Control planes should not attempt to override the metadata server URI.
+  // The cluster and timeout can be configured using the ``cluster`` and ``timeout`` fields instead.
+  // For backward compatibility, the cluster and timeout configured in this field will be used
+  // if the new ``cluster`` and ``timeout`` fields are not set.
+  config.core.v3.HttpUri http_uri = 1
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Retry policy for fetching tokens.
+  // Not supported by all data planes.
+  config.core.v3.RetryPolicy retry_policy = 2;
+
+  // Token cache configuration. This field is optional.
+  TokenCacheConfig cache_config = 3;
+
+  // Request header location to extract the token. By default (i.e. if this field is not specified), the token
+  // is extracted to the Authorization HTTP header, in the format "Authorization: Bearer <token>".
+  // Not supported by all data planes.
+  TokenHeader token_header = 4;
+
+  // Cluster to send traffic to the GCE metadata server. Not supported
+  // by all data planes; a data plane may instead have its own mechanism
+  // for contacting the metadata server.
+  string cluster = 5;
+
+  // Timeout for fetching the tokens from the GCE metadata server.
+  // Not supported by all data planes.
+  google.protobuf.Duration timeout = 6 [(validate.rules).duration = {
+    lt {seconds: 4294967296}
+    gte {}
+  }];
+}
+
+// Audience is the URL of the receiving service that performs token authentication.
+// It will be provided to the filter through cluster's typed_filter_metadata.
+message Audience {
+  string url = 1 [(validate.rules).string = {min_len: 1}];
+}
+
+// Token Cache configuration.
+message TokenCacheConfig {
+  // The number of cache entries. The maximum number of entries is INT64_MAX as it is constrained by underlying cache implementation.
+  // Default value 0 (i.e., proto3 defaults) disables the cache by default. Other default values will enable the cache.
+  google.protobuf.UInt64Value cache_size = 1 [(validate.rules).uint64 = {lte: 9223372036854775807}];
+}
+
+message TokenHeader {
+  // The HTTP header's name.
+  string name = 1
+      [(validate.rules).string = {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}];
+
+  // The header's prefix. The format is "value_prefix<token>"
+  // For example, for "Authorization: Bearer <token>", value_prefix="Bearer " with a space at the
+  // end.
+  string value_prefix = 2
+      [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/rate_limit_quota/v3/rate_limit_quota.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/rate_limit_quota/v3/rate_limit_quota.proto
new file mode 100644
index 00000000000..57b8bdecd78
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/rate_limit_quota/v3/rate_limit_quota.proto
@@ -0,0 +1,423 @@
+syntax = "proto3";
+
+package envoy.extensions.filters.http.rate_limit_quota.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/core/v3/grpc_service.proto";
+import "envoy/type/v3/http_status.proto";
+import "envoy/type/v3/ratelimit_strategy.proto";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+import "google/rpc/status.proto";
+
+import "xds/annotations/v3/status.proto";
+import "xds/type/matcher/v3/matcher.proto";
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.filters.http.rate_limit_quota.v3";
+option java_outer_classname = "RateLimitQuotaProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/filters/http/rate_limit_quota/v3;rate_limit_quotav3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+option (xds.annotations.v3.file_status).work_in_progress = true;
+
+// [#protodoc-title: Rate Limit Quota]
+// Rate Limit Quota :ref:`configuration overview <config_http_filters_rate_limit_quota>`.
+// [#extension: envoy.filters.http.rate_limit_quota]
+
+// Configures the Rate Limit Quota filter.
+//
+// Can be overridden in the per-route and per-host configurations.
+// The more specific definition completely overrides the less specific definition.
+// [#next-free-field: 7]
+message RateLimitQuotaFilterConfig {
+  // Configures the gRPC Rate Limit Quota Service (RLQS) RateLimitQuotaService.
+  config.core.v3.GrpcService rlqs_server = 1 [(validate.rules).message = {required: true}];
+
+  // The application domain to use when calling the service. This enables sharing the quota
+  // server between different applications without fear of overlap.
+  // E.g., "envoy".
+  string domain = 2 [(validate.rules).string = {min_len: 1}];
+
+  // The match tree to use for grouping incoming requests into buckets.
+  //
+  // Example:
+  //
+  // .. validated-code-block:: yaml
+  //   :type-name: xds.type.matcher.v3.Matcher
+  //
+  //   matcher_list:
+  //     matchers:
+  //     # Assign requests with header['env'] set to 'staging' to the bucket { name: 'staging' }
+  //     - predicate:
+  //         single_predicate:
+  //           input:
+  //             typed_config:
+  //               '@type': type.googleapis.com/envoy.type.matcher.v3.HttpRequestHeaderMatchInput
+  //               header_name: env
+  //           value_match:
+  //             exact: staging
+  //       on_match:
+  //         action:
+  //           typed_config:
+  //             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
+  //             bucket_id_builder:
+  //               bucket_id_builder:
+  //                 name:
+  //                   string_value: staging
+  //
+  //     # Assign requests with header['user_group'] set to 'admin' to the bucket { acl: 'admin_users' }
+  //     - predicate:
+  //         single_predicate:
+  //           input:
+  //             typed_config:
+  //               '@type': type.googleapis.com/xds.type.matcher.v3.HttpAttributesCelMatchInput
+  //           custom_match:
+  //             typed_config:
+  //               '@type': type.googleapis.com/xds.type.matcher.v3.CelMatcher
+  //               expr_match:
+  //                 # Shortened for illustration purposes. Here should be parsed CEL expression:
+  //                 # request.headers['user_group'] == 'admin'
+  //                 parsed_expr: {}
+  //       on_match:
+  //         action:
+  //           typed_config:
+  //             '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
+  //             bucket_id_builder:
+  //               bucket_id_builder:
+  //                 acl:
+  //                   string_value: admin_users
+  //
+  //   # Catch-all clause for the requests not matched by any of the matchers.
+  //   # In this example, deny all requests.
+  //   on_no_match:
+  //     action:
+  //       typed_config:
+  //         '@type': type.googleapis.com/envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings
+  //         no_assignment_behavior:
+  //           fallback_rate_limit:
+  //             blanket_rule: DENY_ALL
+  //
+  // .. attention::
+  //  The first matched group wins. Once the request is matched into a bucket, matcher
+  //  evaluation ends.
+  //
+  // Use ``on_no_match`` field to assign the catch-all bucket. If a request is not matched
+  // into any bucket, and there's no  ``on_no_match`` field configured, the request will be
+  // ALLOWED by default. It will NOT be reported to the RLQS server.
+  //
+  // Refer to :ref:`Unified Matcher API <envoy_v3_api_msg_.xds.type.matcher.v3.Matcher>`
+  // documentation for more information on the matcher trees.
+  xds.type.matcher.v3.Matcher bucket_matchers = 3 [(validate.rules).message = {required: true}];
+
+  // If set, this will enable -- but not necessarily enforce -- the rate limit for the given
+  // fraction of requests.
+  //
+  // Defaults to 100% of requests.
+  config.core.v3.RuntimeFractionalPercent filter_enabled = 4;
+
+  // If set, this will enforce the rate limit decisions for the given fraction of requests.
+  // For requests that are not enforced the filter will still obtain the quota and include it
+  // in the load computation, however the request will always be allowed regardless of the outcome
+  // of quota application. This allows validation or testing of the rate limiting service
+  // infrastructure without disrupting existing traffic.
+  //
+  // Note: this only applies to the fraction of enabled requests.
+  //
+  // Defaults to 100% of requests.
+  config.core.v3.RuntimeFractionalPercent filter_enforced = 5;
+
+  // Specifies a list of HTTP headers that should be added to each request that
+  // has been rate limited and is also forwarded upstream. This can only occur when the
+  // filter is enabled but not enforced.
+  repeated config.core.v3.HeaderValueOption request_headers_to_add_when_not_enforced = 6
+      [(validate.rules).repeated = {max_items: 10}];
+}
+
+// Per-route and per-host configuration overrides. The more specific definition completely
+// overrides the less specific definition.
+message RateLimitQuotaOverride {
+  // The application domain to use when calling the service. This enables sharing the quota
+  // server between different applications without fear of overlap.
+  // E.g., "envoy".
+  //
+  // If empty, inherits the value from the less specific definition.
+  string domain = 1;
+
+  // The match tree to use for grouping incoming requests into buckets.
+  //
+  // If set, fully overrides the bucket matchers provided on the less specific definition.
+  // If not set, inherits the value from the less specific definition.
+  //
+  // See usage example: :ref:`RateLimitQuotaFilterConfig.bucket_matchers
+  // <envoy_v3_api_field_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaFilterConfig.bucket_matchers>`.
+  xds.type.matcher.v3.Matcher bucket_matchers = 2;
+}
+
+// Rate Limit Quota Bucket Settings to apply on the successful ``bucket_matchers`` match.
+//
+// Specify this message in the :ref:`Matcher.OnMatch.action
+// <envoy_v3_api_field_.xds.type.matcher.v3.Matcher.OnMatch.action>` field of the
+// ``bucket_matchers`` matcher tree to assign the matched requests to the Quota Bucket.
+// Usage example: :ref:`RateLimitQuotaFilterConfig.bucket_matchers
+// <envoy_v3_api_field_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaFilterConfig.bucket_matchers>`.
+// [#next-free-field: 6]
+message RateLimitQuotaBucketSettings {
+  // Configures the behavior after the first request has been matched to the bucket, and before the
+  // the RLQS server returns the first quota assignment.
+  message NoAssignmentBehavior {
+    oneof no_assignment_behavior {
+      option (validate.required) = true;
+
+      // Apply pre-configured rate limiting strategy until the server sends the first assignment.
+      type.v3.RateLimitStrategy fallback_rate_limit = 1;
+    }
+  }
+
+  // Specifies the behavior when the bucket's assignment has expired, and cannot be refreshed for
+  // any reason.
+  message ExpiredAssignmentBehavior {
+    // Reuse the last known quota assignment, effectively extending it for the duration
+    // specified in the :ref:`expired_assignment_behavior_timeout
+    // <envoy_v3_api_field_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.ExpiredAssignmentBehavior.expired_assignment_behavior_timeout>`
+    // field.
+    message ReuseLastAssignment {
+    }
+
+    // Limit the time :ref:`ExpiredAssignmentBehavior
+    // <envoy_v3_api_msg_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.ExpiredAssignmentBehavior>`
+    // is applied. If the server doesn't respond within this duration:
+    //
+    // 1. Selected ``ExpiredAssignmentBehavior`` is no longer applied.
+    // 2. The bucket is abandoned. The process of abandoning the bucket is described in the
+    //    :ref:`AbandonAction <envoy_v3_api_msg_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.AbandonAction>`
+    //    message.
+    // 3. If a new request is matched into the bucket that has become abandoned,
+    //    the data plane restarts the subscription to the bucket. The process of restarting the
+    //    subscription is described in the :ref:`AbandonAction
+    //    <envoy_v3_api_msg_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.AbandonAction>`
+    //    message.
+    //
+    // If not set, defaults to zero, and the bucket is abandoned immediately.
+    google.protobuf.Duration expired_assignment_behavior_timeout = 1
+        [(validate.rules).duration = {gt {}}];
+
+    oneof expired_assignment_behavior {
+      option (validate.required) = true;
+
+      // Apply the rate limiting strategy to all requests matched into the bucket until the RLQS
+      // server sends a new assignment, or the :ref:`expired_assignment_behavior_timeout
+      // <envoy_v3_api_field_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.ExpiredAssignmentBehavior.expired_assignment_behavior_timeout>`
+      // runs out.
+      type.v3.RateLimitStrategy fallback_rate_limit = 2;
+
+      // Reuse the last ``active`` assignment until the RLQS server sends a new assignment, or the
+      // :ref:`expired_assignment_behavior_timeout
+      // <envoy_v3_api_field_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.ExpiredAssignmentBehavior.expired_assignment_behavior_timeout>`
+      // runs out.
+      ReuseLastAssignment reuse_last_assignment = 3;
+    }
+  }
+
+  // Customize the deny response to the requests over the rate limit.
+  message DenyResponseSettings {
+    // HTTP response code to deny for HTTP requests (gRPC excluded).
+    // Defaults to 429 (:ref:`StatusCode.TooManyRequests<envoy_v3_api_enum_value_type.v3.StatusCode.TooManyRequests>`).
+    type.v3.HttpStatus http_status = 1;
+
+    // HTTP response body used to deny for HTTP requests (gRPC excluded).
+    // If not set, an empty body is returned.
+    google.protobuf.BytesValue http_body = 2;
+
+    // Configure the deny response for gRPC requests over the rate limit.
+    // Allows to specify the `RPC status code
+    // <https://cloud.google.com/natural-language/docs/reference/rpc/google.rpc#google.rpc.Code>`_,
+    // and the error message.
+    // Defaults to the Status with the RPC Code ``UNAVAILABLE`` and empty message.
+    //
+    // To identify gRPC requests, Envoy checks that the ``Content-Type`` header is
+    // ``application/grpc``, or one of the various ``application/grpc+`` values.
+    //
+    // .. note::
+    //   The HTTP code for a gRPC response is always 200.
+    google.rpc.Status grpc_status = 3;
+
+    // Specifies a list of HTTP headers that should be added to each response for requests that
+    // have been rate limited. Applies both to plain HTTP, and gRPC requests.
+    // The headers are added even when the rate limit quota was not enforced.
+    repeated config.core.v3.HeaderValueOption response_headers_to_add = 4
+        [(validate.rules).repeated = {max_items: 10}];
+  }
+
+  // ``BucketIdBuilder`` makes it possible to build :ref:`BucketId
+  // <envoy_v3_api_msg_service.rate_limit_quota.v3.BucketId>` with values substituted
+  // from the dynamic properties associated with each individual request. See usage examples in
+  // the docs to :ref:`bucket_id_builder
+  // <envoy_v3_api_field_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.bucket_id_builder>`
+  // field.
+  message BucketIdBuilder {
+    // Produces the value of the :ref:`BucketId
+    // <envoy_v3_api_msg_service.rate_limit_quota.v3.BucketId>` map.
+    message ValueBuilder {
+      oneof value_specifier {
+        option (validate.required) = true;
+
+        // Static string value — becomes the value in the :ref:`BucketId
+        // <envoy_v3_api_msg_service.rate_limit_quota.v3.BucketId>` map as is.
+        string string_value = 1;
+
+        // Dynamic value — evaluated for each request. Must produce a string output, which becomes
+        // the value in the :ref:`BucketId <envoy_v3_api_msg_service.rate_limit_quota.v3.BucketId>`
+        // map. For example, extensions with the ``envoy.matching.http.input`` category can be used.
+        config.core.v3.TypedExtensionConfig custom_value = 2;
+      }
+    }
+
+    // The map translated into the ``BucketId`` map.
+    //
+    // The ``string key`` of this map and becomes the key of ``BucketId`` map as is.
+    //
+    // The ``ValueBuilder value`` for the key can be:
+    //
+    // * static ``StringValue string_value`` — becomes the value in the ``BucketId`` map as is.
+    // * dynamic ``TypedExtensionConfig custom_value`` — evaluated for each request. Must produce
+    //   a string output, which becomes the value in the the ``BucketId`` map.
+    //
+    // See usage examples in the docs to :ref:`bucket_id_builder
+    // <envoy_v3_api_field_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.bucket_id_builder>`
+    // field.
+    map<string, ValueBuilder> bucket_id_builder = 1 [(validate.rules).map = {min_pairs: 1}];
+  }
+
+  // ``BucketId`` builder.
+  //
+  // :ref:`BucketId <envoy_v3_api_msg_service.rate_limit_quota.v3.BucketId>` is a map from
+  // the string key to the string value which serves as bucket identifier common for on
+  // the control plane and the data plane.
+  //
+  // While ``BucketId`` is always static, ``BucketIdBuilder`` allows to populate map values
+  // with the dynamic properties associated with the each individual request.
+  //
+  // Example 1: static fields only
+  //
+  // ``BucketIdBuilder``:
+  //
+  // .. validated-code-block:: yaml
+  //   :type-name: envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.BucketIdBuilder
+  //
+  //   bucket_id_builder:
+  //     name:
+  //       string_value: my_bucket
+  //     hello:
+  //       string_value: world
+  //
+  // Produces the following ``BucketId`` for all requests:
+  //
+  // .. validated-code-block:: yaml
+  //   :type-name: envoy.service.rate_limit_quota.v3.BucketId
+  //
+  //   bucket:
+  //     name: my_bucket
+  //     hello: world
+  //
+  // Example 2: static and dynamic fields
+  //
+  // .. validated-code-block:: yaml
+  //   :type-name: envoy.extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.BucketIdBuilder
+  //
+  //   bucket_id_builder:
+  //     name:
+  //       string_value: my_bucket
+  //     env:
+  //       custom_value:
+  //         typed_config:
+  //           '@type': type.googleapis.com/envoy.type.matcher.v3.HttpRequestHeaderMatchInput
+  //           header_name: environment
+  //
+  // In this example, the value of ``BucketId`` key ``env`` is substituted from the ``environment``
+  // request header.
+  //
+  // This is equivalent to the following ``pseudo-code``:
+  //
+  // .. code-block:: yaml
+  //
+  //    name: 'my_bucket'
+  //    env: $header['environment']
+  //
+  // For example, the request with the HTTP header ``env`` set to ``staging`` will produce
+  // the following ``BucketId``:
+  //
+  // .. validated-code-block:: yaml
+  //   :type-name: envoy.service.rate_limit_quota.v3.BucketId
+  //
+  //   bucket:
+  //     name: my_bucket
+  //     env: staging
+  //
+  // For the request with the HTTP header ``environment`` set to ``prod``, will produce:
+  //
+  // .. validated-code-block:: yaml
+  //   :type-name: envoy.service.rate_limit_quota.v3.BucketId
+  //
+  //   bucket:
+  //     name: my_bucket
+  //     env: prod
+  //
+  // .. note::
+  //   The order of ``BucketId`` keys do not matter. Buckets ``{ a: 'A', b: 'B' }`` and
+  //   ``{ b: 'B', a: 'A' }`` are identical.
+  //
+  // If not set, requests will NOT be reported to the server, and will always limited
+  // according to :ref:`no_assignment_behavior
+  // <envoy_v3_api_field_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.no_assignment_behavior>`
+  // configuration.
+  BucketIdBuilder bucket_id_builder = 1;
+
+  // The interval at which the data plane (RLQS client) is to report quota usage for this bucket.
+  //
+  // When the first request is matched to a bucket with no assignment, the data plane is to report
+  // the request immediately in the :ref:`RateLimitQuotaUsageReports
+  // <envoy_v3_api_msg_service.rate_limit_quota.v3.RateLimitQuotaUsageReports>` message.
+  // For the RLQS server, this signals that the data plane is now subscribed to
+  // the quota assignments in this bucket, and will start sending the assignment as described in
+  // the :ref:`RLQS documentation <envoy_v3_api_file_envoy/service/rate_limit_quota/v3/rlqs.proto>`.
+  //
+  // After sending the initial report, the data plane is to continue reporting the bucket usage with
+  // the internal specified in this field.
+  //
+  // If for any reason RLQS client doesn't receive the initial assignment for the reported bucket,
+  // the data plane will eventually consider the bucket abandoned and stop sending the usage
+  // reports. This is explained in more details at :ref:`Rate Limit Quota Service (RLQS)
+  // <envoy_v3_api_file_envoy/service/rate_limit_quota/v3/rlqs.proto>`.
+  //
+  // [#comment: 100000000 nanoseconds = 0.1 seconds]
+  google.protobuf.Duration reporting_interval = 2 [(validate.rules).duration = {
+    required: true
+    gt {nanos: 100000000}
+  }];
+
+  // Customize the deny response to the requests over the rate limit.
+  // If not set, the filter will be configured as if an empty message is set,
+  // and will behave according to the defaults specified in :ref:`DenyResponseSettings
+  // <envoy_v3_api_msg_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.DenyResponseSettings>`.
+  DenyResponseSettings deny_response_settings = 3;
+
+  // Configures the behavior in the "no assignment" state: after the first request has been
+  // matched to the bucket, and before the the RLQS server returns the first quota assignment.
+  //
+  // If not set, the default behavior is to allow all requests.
+  NoAssignmentBehavior no_assignment_behavior = 4;
+
+  // Configures the behavior in the "expired assignment" state: the bucket's assignment has expired,
+  // and cannot be refreshed.
+  //
+  // If not set, the bucket is abandoned when its ``active`` assignment expires.
+  // The process of abandoning the bucket, and restarting the subscription is described in the
+  // :ref:`AbandonAction <envoy_v3_api_msg_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.AbandonAction>`
+  // message.
+  ExpiredAssignmentBehavior expired_assignment_behavior = 5;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/rbac/v3/rbac.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/rbac/v3/rbac.proto
new file mode 100644
index 00000000000..6efd47ac58b
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/rbac/v3/rbac.proto
@@ -0,0 +1,89 @@
+syntax = "proto3";
+
+package envoy.extensions.filters.http.rbac.v3;
+
+import "envoy/config/rbac/v3/rbac.proto";
+
+import "xds/annotations/v3/status.proto";
+import "xds/type/matcher/v3/matcher.proto";
+
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.filters.http.rbac.v3";
+option java_outer_classname = "RbacProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/filters/http/rbac/v3;rbacv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: RBAC]
+// Role-Based Access Control :ref:`configuration overview <config_http_filters_rbac>`.
+// [#extension: envoy.filters.http.rbac]
+
+// RBAC filter config.
+// [#next-free-field: 8]
+message RBAC {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.http.rbac.v2.RBAC";
+
+  // The primary RBAC policy which will be applied globally, to all the incoming requests.
+  //
+  // * If absent, no RBAC enforcement occurs.
+  // * If set but empty, all requests are denied.
+  //
+  // .. note::
+  //
+  //   When both ``rules`` and ``matcher`` are configured, ``rules`` will be ignored.
+  //
+  config.rbac.v3.RBAC rules = 1
+      [(udpa.annotations.field_migrate).oneof_promotion = "rules_specifier"];
+
+  // If specified, rules will emit stats with the given prefix.
+  // This is useful for distinguishing metrics when multiple RBAC filters are configured.
+  string rules_stat_prefix = 6;
+
+  // Match tree for evaluating RBAC actions on incoming requests. Requests not matching any matcher will be denied.
+  //
+  // * If absent, no RBAC enforcement occurs.
+  // * If set but empty, all requests are denied.
+  //
+  xds.type.matcher.v3.Matcher matcher = 4
+      [(udpa.annotations.field_migrate).oneof_promotion = "rules_specifier"];
+
+  // Shadow policy for testing RBAC rules without enforcing them. These rules generate stats and logs but do not deny
+  // requests. If absent, no shadow RBAC policy will be applied.
+  //
+  // .. note::
+  //
+  //   When both ``shadow_rules`` and ``shadow_matcher`` are configured, ``shadow_rules`` will be ignored.
+  //
+  config.rbac.v3.RBAC shadow_rules = 2
+      [(udpa.annotations.field_migrate).oneof_promotion = "shadow_rules_specifier"];
+
+  // If absent, no shadow matcher will be applied.
+  // Match tree for testing RBAC rules through stats and logs without enforcing them.
+  // If absent, no shadow matching occurs.
+  xds.type.matcher.v3.Matcher shadow_matcher = 5 [
+    (udpa.annotations.field_migrate).oneof_promotion = "shadow_rules_specifier",
+    (xds.annotations.v3.field_status).work_in_progress = true
+  ];
+
+  // If specified, shadow rules will emit stats with the given prefix.
+  // This is useful for distinguishing metrics when multiple RBAC filters use shadow rules.
+  string shadow_rules_stat_prefix = 3;
+
+  // If ``track_per_rule_stats`` is ``true``, counters will be published for each rule and shadow rule.
+  bool track_per_rule_stats = 7;
+}
+
+message RBACPerRoute {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.http.rbac.v2.RBACPerRoute";
+
+  reserved 1;
+
+  // Per-route specific RBAC configuration that overrides the global RBAC configuration.
+  // If absent, RBAC policy will be disabled for this route.
+  RBAC rbac = 2;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/router/v3/router.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/router/v3/router.proto
new file mode 100644
index 00000000000..d3996a96798
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/http/router/v3/router.proto
@@ -0,0 +1,137 @@
+syntax = "proto3";
+
+package envoy.extensions.filters.http.router.v3;
+
+import "envoy/config/accesslog/v3/accesslog.proto";
+import "envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.filters.http.router.v3";
+option java_outer_classname = "RouterProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/filters/http/router/v3;routerv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Router]
+// Router :ref:`configuration overview <config_http_filters_router>`.
+// [#extension: envoy.filters.http.router]
+
+// [#next-free-field: 10]
+message Router {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.http.router.v2.Router";
+
+  message UpstreamAccessLogOptions {
+    // If set to true, an upstream access log will be recorded when an upstream stream is
+    // associated to an http request. Note: Each HTTP request received for an already established
+    // connection will result in an upstream access log record. This includes, for example,
+    // consecutive HTTP requests over the same connection or a request that is retried.
+    // In case a retry is applied, an upstream access log will be recorded for each retry.
+    bool flush_upstream_log_on_upstream_stream = 1;
+
+    // The interval to flush the upstream access logs. By default, the router will flush an upstream
+    // access log on stream close, when the HTTP request is complete. If this field is set, the router
+    // will flush access logs periodically at the specified interval. This is especially useful in the
+    // case of long-lived requests, such as CONNECT and Websockets.
+    // The interval must be at least 1 millisecond.
+    google.protobuf.Duration upstream_log_flush_interval = 2
+        [(validate.rules).duration = {gte {nanos: 1000000}}];
+  }
+
+  // Whether the router generates dynamic cluster statistics. Defaults to
+  // true. Can be disabled in high performance scenarios.
+  google.protobuf.BoolValue dynamic_stats = 1;
+
+  // Whether to start a child span for egress routed calls. This can be
+  // useful in scenarios where other filters (auth, ratelimit, etc.) make
+  // outbound calls and have child spans rooted at the same ingress
+  // parent. Defaults to false.
+  //
+  // .. attention::
+  //   This field is deprecated by the
+  //   :ref:`spawn_upstream_span <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.Tracing.spawn_upstream_span>`.
+  //   Please use that ``spawn_upstream_span`` field to control the span creation.
+  bool start_child_span = 2
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Configuration for HTTP upstream logs emitted by the router. Upstream logs
+  // are configured in the same way as access logs, but each log entry represents
+  // an upstream request. Presuming retries are configured, multiple upstream
+  // requests may be made for each downstream (inbound) request.
+  repeated config.accesslog.v3.AccessLog upstream_log = 3;
+
+  // Additional upstream access log options.
+  UpstreamAccessLogOptions upstream_log_options = 9;
+
+  // Do not add any additional ``x-envoy-`` headers to requests or responses. This
+  // only affects the :ref:`router filter generated x-envoy- headers
+  // <config_http_filters_router_headers_set>`, other Envoy filters and the HTTP
+  // connection manager may continue to set ``x-envoy-`` headers.
+  bool suppress_envoy_headers = 4;
+
+  // Specifies a list of HTTP headers to strictly validate. Envoy will reject a
+  // request and respond with HTTP status 400 if the request contains an invalid
+  // value for any of the headers listed in this field. Strict header checking
+  // is only supported for the following headers:
+  //
+  // Value must be a ','-delimited list (i.e. no spaces) of supported retry
+  // policy values:
+  //
+  // * :ref:`config_http_filters_router_x-envoy-retry-grpc-on`
+  // * :ref:`config_http_filters_router_x-envoy-retry-on`
+  //
+  // Value must be an integer:
+  //
+  // * :ref:`config_http_filters_router_x-envoy-max-retries`
+  // * :ref:`config_http_filters_router_x-envoy-upstream-rq-timeout-ms`
+  // * :ref:`config_http_filters_router_x-envoy-upstream-rq-per-try-timeout-ms`
+  repeated string strict_check_headers = 5 [(validate.rules).repeated = {
+    items {
+      string {
+        in: "x-envoy-upstream-rq-timeout-ms"
+        in: "x-envoy-upstream-rq-per-try-timeout-ms"
+        in: "x-envoy-max-retries"
+        in: "x-envoy-retry-grpc-on"
+        in: "x-envoy-retry-on"
+      }
+    }
+  }];
+
+  // If not set, ingress Envoy will ignore
+  // :ref:`config_http_filters_router_x-envoy-expected-rq-timeout-ms` header, populated by egress
+  // Envoy, when deriving timeout for upstream cluster.
+  bool respect_expected_rq_timeout = 6;
+
+  // If set, Envoy will avoid incrementing HTTP failure code stats
+  // on gRPC requests. This includes the individual status code value
+  // (e.g. upstream_rq_504) and group stats (e.g. upstream_rq_5xx).
+  // This field is useful if interested in relying only on the gRPC
+  // stats filter to define success and failure metrics for gRPC requests
+  // as not all failed gRPC requests charge HTTP status code metrics. See
+  // :ref:`gRPC stats filter<config_http_filters_grpc_stats>` documentation
+  // for more details.
+  bool suppress_grpc_request_failure_code_stats = 7;
+
+  // Optional HTTP filters for the upstream HTTP filter chain.
+  //
+  // .. note::
+  //   Upstream HTTP filters are currently in alpha.
+  //
+  // These filters will be applied for all requests that pass through the router.
+  // They will also be applied to shadowed requests.
+  // Upstream HTTP filters cannot change route or cluster.
+  // Upstream HTTP filters specified on the cluster will override these filters.
+  //
+  // If using upstream HTTP filters, please be aware that local errors sent by
+  // upstream HTTP filters will not trigger retries, and local errors sent by
+  // upstream HTTP filters will count as a final response if hedging is configured.
+  // [#extension-category: envoy.filters.http.upstream]
+  repeated network.http_connection_manager.v3.HttpFilter upstream_http_filters = 8;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto
new file mode 100644
index 00000000000..730e065e6c4
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/filters/network/http_connection_manager/v3/http_connection_manager.proto
@@ -0,0 +1,1275 @@
+syntax = "proto3";
+
+package envoy.extensions.filters.network.http_connection_manager.v3;
+
+import "envoy/config/accesslog/v3/accesslog.proto";
+import "envoy/config/core/v3/address.proto";
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/config_source.proto";
+import "envoy/config/core/v3/extension.proto";
+import "envoy/config/core/v3/protocol.proto";
+import "envoy/config/core/v3/substitution_format_string.proto";
+import "envoy/config/route/v3/route.proto";
+import "envoy/config/route/v3/scoped_route.proto";
+import "envoy/config/trace/v3/http_tracer.proto";
+import "envoy/type/http/v3/path_transformation.proto";
+import "envoy/type/tracing/v3/custom_tag.proto";
+import "envoy/type/v3/percent.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/security.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.filters.network.http_connection_manager.v3";
+option java_outer_classname = "HttpConnectionManagerProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/filters/network/http_connection_manager/v3;http_connection_managerv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: HTTP connection manager]
+// HTTP connection manager :ref:`configuration overview <config_http_conn_man>`.
+// [#extension: envoy.filters.network.http_connection_manager]
+
+// [#next-free-field: 60]
+message HttpConnectionManager {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager";
+
+  enum CodecType {
+    // For every new connection, the connection manager will determine which
+    // codec to use. This mode supports both ALPN for TLS listeners as well as
+    // protocol inference for plaintext listeners. If ALPN data is available, it
+    // is preferred, otherwise protocol inference is used. In almost all cases,
+    // this is the right option to choose for this setting.
+    AUTO = 0;
+
+    // The connection manager will assume that the client is speaking HTTP/1.1.
+    HTTP1 = 1;
+
+    // The connection manager will assume that the client is speaking HTTP/2
+    // (Envoy does not require HTTP/2 to take place over TLS or to use ALPN.
+    // Prior knowledge is allowed).
+    HTTP2 = 2;
+
+    // The connection manager will assume that the client is speaking HTTP/3.
+    // This needs to be consistent with listener and transport socket config.
+    HTTP3 = 3;
+  }
+
+  enum ServerHeaderTransformation {
+    // Overwrite any Server header with the contents of server_name.
+    OVERWRITE = 0;
+
+    // If no Server header is present, append Server server_name
+    // If a Server header is present, pass it through.
+    APPEND_IF_ABSENT = 1;
+
+    // Pass through the value of the server header, and do not append a header
+    // if none is present.
+    PASS_THROUGH = 2;
+  }
+
+  // How to handle the :ref:`config_http_conn_man_headers_x-forwarded-client-cert` (XFCC) HTTP
+  // header.
+  enum ForwardClientCertDetails {
+    // Do not send the XFCC header to the next hop. This is the default value.
+    SANITIZE = 0;
+
+    // When the client connection is mTLS (Mutual TLS), forward the XFCC header
+    // in the request.
+    FORWARD_ONLY = 1;
+
+    // When the client connection is mTLS, append the client certificate
+    // information to the request’s XFCC header and forward it.
+    APPEND_FORWARD = 2;
+
+    // When the client connection is mTLS, reset the XFCC header with the client
+    // certificate information and send it to the next hop.
+    SANITIZE_SET = 3;
+
+    // Always forward the XFCC header in the request, regardless of whether the
+    // client connection is mTLS.
+    ALWAYS_FORWARD_ONLY = 4;
+  }
+
+  // Determines the action for request that contain ``%2F``, ``%2f``, ``%5C`` or ``%5c`` sequences in the URI path.
+  // This operation occurs before URL normalization and the merge slashes transformations if they were enabled.
+  enum PathWithEscapedSlashesAction {
+    // Default behavior specific to implementation (i.e. Envoy) of this configuration option.
+    // Envoy, by default, takes the KEEP_UNCHANGED action.
+    //
+    // .. note::
+    //
+    //   The implementation may change the default behavior at-will.
+    IMPLEMENTATION_SPECIFIC_DEFAULT = 0;
+
+    // Keep escaped slashes.
+    KEEP_UNCHANGED = 1;
+
+    // Reject client request with the 400 status. gRPC requests will be rejected with the INTERNAL (13) error code.
+    // The ``httpN.downstream_rq_failed_path_normalization`` counter is incremented for each rejected request.
+    REJECT_REQUEST = 2;
+
+    // Unescape ``%2F`` and ``%5C`` sequences and redirect request to the new path if these sequences were present.
+    // Redirect occurs after path normalization and merge slashes transformations if they were configured.
+    //
+    // .. note::
+    //
+    //   gRPC requests will be rejected with the INTERNAL (13) error code. This option minimizes possibility of path
+    //   confusion exploits by forcing request with unescaped slashes to traverse all parties: downstream client,
+    //   intermediate proxies, Envoy and upstream server. The ``httpN.downstream_rq_redirected_with_normalized_path``
+    //   counter is incremented for each redirected request.
+    //
+    UNESCAPE_AND_REDIRECT = 3;
+
+    // Unescape ``%2F`` and ``%5C`` sequences.
+    //
+    // .. note::
+    //
+    //   This option should not be enabled if intermediaries perform path based access control as it may lead to path
+    //   confusion vulnerabilities.
+    //
+    UNESCAPE_AND_FORWARD = 4;
+  }
+
+  // [#next-free-field: 11]
+  message Tracing {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager.Tracing";
+
+    enum OperationName {
+      // The HTTP listener is used for ingress/incoming requests.
+      INGRESS = 0;
+
+      // The HTTP listener is used for egress/outgoing requests.
+      EGRESS = 1;
+    }
+
+    reserved 1, 2;
+
+    reserved "operation_name", "request_headers_for_tags";
+
+    // Target percentage of requests managed by this HTTP connection manager that will be force
+    // traced if the :ref:`x-client-trace-id <config_http_conn_man_headers_x-client-trace-id>`
+    // header is set. This field is a direct analog for the runtime variable
+    // 'tracing.client_enabled' in the :ref:`HTTP Connection Manager
+    // <config_http_conn_man_runtime>`.
+    // Default: 100%
+    type.v3.Percent client_sampling = 3;
+
+    // Target percentage of requests managed by this HTTP connection manager that will be randomly
+    // selected for trace generation, if not requested by the client or not forced. This field is
+    // a direct analog for the runtime variable 'tracing.random_sampling' in the
+    // :ref:`HTTP Connection Manager <config_http_conn_man_runtime>`.
+    // Default: 100%
+    type.v3.Percent random_sampling = 4;
+
+    // Target percentage of requests managed by this HTTP connection manager that will be traced
+    // after all other sampling checks have been applied (client-directed, force tracing, random
+    // sampling). This field functions as an upper limit on the total configured sampling rate. For
+    // instance, setting client_sampling to 100% but overall_sampling to 1% will result in only 1%
+    // of client requests with the appropriate headers to be force traced. This field is a direct
+    // analog for the runtime variable 'tracing.global_enabled' in the
+    // :ref:`HTTP Connection Manager <config_http_conn_man_runtime>`.
+    // Default: 100%
+    type.v3.Percent overall_sampling = 5;
+
+    // Whether to annotate spans with additional data. If true, spans will include logs for stream
+    // events.
+    bool verbose = 6;
+
+    // Maximum length of the request path to extract and include in the HttpUrl tag. Used to
+    // truncate lengthy request paths to meet the needs of a tracing backend.
+    // Default: 256
+    google.protobuf.UInt32Value max_path_tag_length = 7;
+
+    // A list of custom tags with unique tag name to create tags for the active span.
+    repeated type.tracing.v3.CustomTag custom_tags = 8;
+
+    // Configuration for an external tracing provider.
+    // If not specified, no tracing will be performed.
+    config.trace.v3.Tracing.Http provider = 9;
+
+    // Create separate tracing span for each upstream request if true. And if this flag is set to true,
+    // the tracing provider will assume that Envoy will be independent hop in the trace chain and may
+    // set span type to client or server based on this flag.
+    // This will deprecate the
+    // :ref:`start_child_span <envoy_v3_api_field_extensions.filters.http.router.v3.Router.start_child_span>`
+    // in the router.
+    //
+    // Users should set appropriate value based on their tracing provider and actual scenario:
+    //
+    // * If Envoy is used as sidecar and users want to make the sidecar and its application as only one
+    //   hop in the trace chain, this flag should be set to false. And please also make sure the
+    //   :ref:`start_child_span <envoy_v3_api_field_extensions.filters.http.router.v3.Router.start_child_span>`
+    //   in the router is not set to true.
+    // * If Envoy is used as gateway or independent proxy, or users want to make the sidecar and its
+    //   application as different hops in the trace chain, this flag should be set to true.
+    // * If tracing provider that has explicit requirements on span creation (like SkyWalking),
+    //   this flag should be set to true.
+    //
+    // The default value is false for now for backward compatibility.
+    google.protobuf.BoolValue spawn_upstream_span = 10;
+  }
+
+  message InternalAddressConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager."
+        "InternalAddressConfig";
+
+    // Whether unix socket addresses should be considered internal.
+    bool unix_sockets = 1;
+
+    // List of CIDR ranges that are treated as internal. If unset, then RFC1918 / RFC4193
+    // IP addresses will be considered internal.
+    repeated config.core.v3.CidrRange cidr_ranges = 2;
+  }
+
+  // [#next-free-field: 7]
+  message SetCurrentClientCertDetails {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager."
+        "SetCurrentClientCertDetails";
+
+    reserved 2;
+
+    // Whether to forward the subject of the client cert. Defaults to false.
+    google.protobuf.BoolValue subject = 1;
+
+    // Whether to forward the entire client cert in URL encoded PEM format. This will appear in the
+    // XFCC header comma separated from other values with the value Cert="PEM".
+    // Defaults to false.
+    bool cert = 3;
+
+    // Whether to forward the entire client cert chain (including the leaf cert) in URL encoded PEM
+    // format. This will appear in the XFCC header comma separated from other values with the value
+    // Chain="PEM".
+    // Defaults to false.
+    bool chain = 6;
+
+    // Whether to forward the DNS type Subject Alternative Names of the client cert.
+    // Defaults to false.
+    bool dns = 4;
+
+    // Whether to forward the URI type Subject Alternative Name of the client cert. Defaults to
+    // false.
+    bool uri = 5;
+  }
+
+  // The configuration for HTTP upgrades.
+  // For each upgrade type desired, an UpgradeConfig must be added.
+  //
+  // .. warning::
+  //
+  //    The current implementation of upgrade headers does not handle multi-valued upgrade headers. Support for
+  //    multi-valued headers may be added in the future if needed.
+  //
+  // .. warning::
+  //    The current implementation of upgrade headers does not work with HTTP/2 upstreams.
+  //
+  message UpgradeConfig {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.filter.network.http_connection_manager.v2.HttpConnectionManager."
+        "UpgradeConfig";
+
+    // The case-insensitive name of this upgrade, e.g. "websocket".
+    // For each upgrade type present in upgrade_configs, requests with
+    // Upgrade: [upgrade_type]
+    // will be proxied upstream.
+    string upgrade_type = 1;
+
+    // If present, this represents the filter chain which will be created for
+    // this type of upgrade. If no filters are present, the filter chain for
+    // HTTP connections will be used for this upgrade type.
+    repeated HttpFilter filters = 2;
+
+    // Determines if upgrades are enabled or disabled by default. Defaults to true.
+    // This can be overridden on a per-route basis with :ref:`cluster
+    // <envoy_v3_api_field_config.route.v3.RouteAction.upgrade_configs>` as documented in the
+    // :ref:`upgrade documentation <arch_overview_upgrades>`.
+    google.protobuf.BoolValue enabled = 3;
+  }
+
+  // [#not-implemented-hide:] Transformations that apply to path headers. Transformations are applied
+  // before any processing of requests by HTTP filters, routing, and matching. Only the normalized
+  // path will be visible internally if a transformation is enabled. Any path rewrites that the
+  // router performs (e.g. :ref:`regex_rewrite
+  // <envoy_v3_api_field_config.route.v3.RouteAction.regex_rewrite>` or :ref:`prefix_rewrite
+  // <envoy_v3_api_field_config.route.v3.RouteAction.prefix_rewrite>`) will apply to the ``:path`` header
+  // destined for the upstream.
+  //
+  // .. note::
+  //
+  //   Access logging and tracing will show the original ``:path`` header.
+  //
+  message PathNormalizationOptions {
+    // [#not-implemented-hide:] Normalization applies internally before any processing of requests by
+    // HTTP filters, routing, and matching *and* will affect the forwarded ``:path`` header. Defaults
+    // to :ref:`NormalizePathRFC3986
+    // <envoy_v3_api_msg_type.http.v3.PathTransformation.Operation.NormalizePathRFC3986>`. When not
+    // specified, this value may be overridden by the runtime variable
+    // :ref:`http_connection_manager.normalize_path<config_http_conn_man_runtime_normalize_path>`.
+    // Envoy will respond with 400 to paths that are malformed (e.g. for paths that fail RFC 3986
+    // normalization due to disallowed characters.)
+    type.http.v3.PathTransformation forwarding_transformation = 1;
+
+    // [#not-implemented-hide:] Normalization only applies internally before any processing of
+    // requests by HTTP filters, routing, and matching. These will be applied after full
+    // transformation is applied. The ``:path`` header before this transformation will be restored in
+    // the router filter and sent upstream unless it was mutated by a filter. Defaults to no
+    // transformations.
+    // Multiple actions can be applied in the same Transformation, forming a sequential
+    // pipeline. The transformations will be performed in the order that they appear. Envoy will
+    // respond with 400 to paths that are malformed (e.g. for paths that fail RFC 3986
+    // normalization due to disallowed characters.)
+    type.http.v3.PathTransformation http_filter_transformation = 2;
+  }
+
+  // Configures the manner in which the Proxy-Status HTTP response header is
+  // populated.
+  //
+  // See the [Proxy-Status
+  // RFC](https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-proxy-status-08).
+  // [#comment:TODO: Update this with the non-draft URL when finalized.]
+  //
+  // The Proxy-Status header is a string of the form:
+  //
+  //   "<server_name>; error=<error_type>; details=<details>"
+  // [#next-free-field: 7]
+  message ProxyStatusConfig {
+    // If true, the details field of the Proxy-Status header is not populated with stream_info.response_code_details.
+    // This value defaults to ``false``, i.e. the ``details`` field is populated by default.
+    bool remove_details = 1;
+
+    // If true, the details field of the Proxy-Status header will not contain
+    // connection termination details. This value defaults to ``false``, i.e. the
+    // ``details`` field will contain connection termination details by default.
+    bool remove_connection_termination_details = 2;
+
+    // If true, the details field of the Proxy-Status header will not contain an
+    // enumeration of the Envoy ResponseFlags. This value defaults to ``false``,
+    // i.e. the ``details`` field will contain a list of ResponseFlags by default.
+    bool remove_response_flags = 3;
+
+    // If true, overwrites the existing Status header with the response code
+    // recommended by the Proxy-Status spec.
+    // This value defaults to ``false``, i.e. the HTTP response code is not
+    // overwritten.
+    bool set_recommended_response_code = 4;
+
+    // The name of the proxy as it appears at the start of the Proxy-Status
+    // header.
+    //
+    // If neither of these values are set, this value defaults to ``server_name``,
+    // which itself defaults to "envoy".
+    oneof proxy_name {
+      // If ``use_node_id`` is set, Proxy-Status headers will use the Envoy's node
+      // ID as the name of the proxy.
+      bool use_node_id = 5;
+
+      // If ``literal_proxy_name`` is set, Proxy-Status headers will use this
+      // value as the name of the proxy.
+      string literal_proxy_name = 6;
+    }
+  }
+
+  message HcmAccessLogOptions {
+    // The interval to flush the above access logs. By default, the HCM will flush exactly one access log
+    // on stream close, when the HTTP request is complete. If this field is set, the HCM will flush access
+    // logs periodically at the specified interval. This is especially useful in the case of long-lived
+    // requests, such as CONNECT and Websockets. Final access logs can be detected via the
+    // ``requestComplete()`` method of ``StreamInfo`` in access log filters, or through the ``%DURATION%`` substitution
+    // string.
+    // The interval must be at least 1 millisecond.
+    google.protobuf.Duration access_log_flush_interval = 1
+        [(validate.rules).duration = {gte {nanos: 1000000}}];
+
+    // If set to true, HCM will flush an access log when a new HTTP request is received, after request
+    // headers have been evaluated, before iterating through the HTTP filter chain.
+    // This log record, if enabled, does not depend on periodic log records or request completion log.
+    // Details related to upstream cluster, such as upstream host, will not be available for this log.
+    bool flush_access_log_on_new_request = 2;
+
+    // If true, the HCM will flush an access log when a tunnel is successfully established. For example,
+    // this could be when an upstream has successfully returned 101 Switching Protocols, or when the proxy
+    // has returned 200 to a CONNECT request.
+    bool flush_log_on_tunnel_successfully_established = 3;
+  }
+
+  reserved 27, 11;
+
+  reserved "idle_timeout";
+
+  // Supplies the type of codec that the connection manager should use.
+  CodecType codec_type = 1 [(validate.rules).enum = {defined_only: true}];
+
+  // The human readable prefix to use when emitting statistics for the
+  // connection manager. See the :ref:`statistics documentation <config_http_conn_man_stats>` for
+  // more information.
+  string stat_prefix = 2 [(validate.rules).string = {min_len: 1}];
+
+  oneof route_specifier {
+    option (validate.required) = true;
+
+    // The connection manager’s route table will be dynamically loaded via the RDS API.
+    Rds rds = 3;
+
+    // The route table for the connection manager is static and is specified in this property.
+    config.route.v3.RouteConfiguration route_config = 4;
+
+    // A route table will be dynamically assigned to each request based on request attributes
+    // (e.g., the value of a header). The "routing scopes" (i.e., route tables) and "scope keys" are
+    // specified in this message.
+    ScopedRoutes scoped_routes = 31;
+  }
+
+  // A list of individual HTTP filters that make up the filter chain for
+  // requests made to the connection manager. :ref:`Order matters <arch_overview_http_filters_ordering>`
+  // as the filters are processed sequentially as request events happen.
+  repeated HttpFilter http_filters = 5;
+
+  // Whether the connection manager manipulates the :ref:`config_http_conn_man_headers_user-agent`
+  // and :ref:`config_http_conn_man_headers_downstream-service-cluster` headers. See the linked
+  // documentation for more information. Defaults to false.
+  google.protobuf.BoolValue add_user_agent = 6;
+
+  // Presence of the object defines whether the connection manager
+  // emits :ref:`tracing <arch_overview_tracing>` data to the :ref:`configured tracing provider
+  // <envoy_v3_api_msg_config.trace.v3.Tracing>`.
+  Tracing tracing = 7;
+
+  // Additional settings for HTTP requests handled by the connection manager. These will be
+  // applicable to both HTTP/1.1 and HTTP/2 requests.
+  config.core.v3.HttpProtocolOptions common_http_protocol_options = 35
+      [(udpa.annotations.security).configure_for_untrusted_downstream = true];
+
+  // If set to ``true``, Envoy will not initiate an immediate drain timer for downstream HTTP/1 connections
+  // once :ref:`common_http_protocol_options.max_connection_duration
+  // <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_connection_duration>` is exceeded.
+  // Instead, Envoy will wait until the next downstream request arrives, add a ``connection: close`` header
+  // to the response, and then gracefully close the connection once the stream has completed.
+  //
+  // This behavior adheres to `RFC 9112, Section 9.6 <https://www.rfc-editor.org/rfc/rfc9112#name-tear-down>`_.
+  //
+  // If set to ``false``, exceeding ``max_connection_duration`` triggers Envoy's default drain behavior for HTTP/1,
+  // where the connection is eventually closed after all active streams finish.
+  //
+  // This option has no effect if ``max_connection_duration`` is not configured.
+  // Defaults to ``false``.
+  bool http1_safe_max_connection_duration = 58;
+
+  // Additional HTTP/1 settings that are passed to the HTTP/1 codec.
+  // [#comment:TODO: The following fields are ignored when the
+  // :ref:`header validation configuration <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.typed_header_validation_config>`
+  // is present:
+  // 1. :ref:`allow_chunked_length <envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.allow_chunked_length>`]
+  config.core.v3.Http1ProtocolOptions http_protocol_options = 8;
+
+  // Additional HTTP/2 settings that are passed directly to the HTTP/2 codec.
+  config.core.v3.Http2ProtocolOptions http2_protocol_options = 9
+      [(udpa.annotations.security).configure_for_untrusted_downstream = true];
+
+  // Additional HTTP/3 settings that are passed directly to the HTTP/3 codec.
+  config.core.v3.Http3ProtocolOptions http3_protocol_options = 44;
+
+  // An optional override that the connection manager will write to the server
+  // header in responses. If not set, the default is ``envoy``.
+  string server_name = 10
+      [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+
+  // Defines the action to be applied to the Server header on the response path.
+  // By default, Envoy will overwrite the header with the value specified in
+  // server_name.
+  ServerHeaderTransformation server_header_transformation = 34
+      [(validate.rules).enum = {defined_only: true}];
+
+  // Allows for explicit transformation of the :scheme header on the request path.
+  // If not set, Envoy's default :ref:`scheme  <config_http_conn_man_headers_scheme>`
+  // handling applies.
+  config.core.v3.SchemeHeaderTransformation scheme_header_transformation = 48;
+
+  // The maximum request headers size for incoming connections.
+  // If unconfigured, the default max request headers allowed is 60 KiB.
+  // The default value can be overridden by setting runtime key ``envoy.reloadable_features.max_request_headers_size_kb``.
+  // Requests that exceed this limit will receive a 431 response.
+  //
+  // .. note::
+  //
+  //   Currently some protocol codecs impose limits on the maximum size of a single header.
+  //
+  //   * HTTP/2 (when using nghttp2) limits a single header to around 100kb.
+  //   * HTTP/3 limits a single header to around 1024kb.
+  //
+  google.protobuf.UInt32Value max_request_headers_kb = 29
+      [(validate.rules).uint32 = {lte: 8192 gt: 0}];
+
+  // The stream idle timeout for connections managed by the connection manager.
+  // If not specified, this defaults to 5 minutes. The default value was selected
+  // so as not to interfere with any smaller configured timeouts that may have
+  // existed in configurations prior to the introduction of this feature, while
+  // introducing robustness to TCP connections that terminate without a FIN.
+  //
+  // This idle timeout applies to new streams and is overridable by the
+  // :ref:`route-level idle_timeout
+  // <envoy_v3_api_field_config.route.v3.RouteAction.idle_timeout>`. Even on a stream in
+  // which the override applies, prior to receipt of the initial request
+  // headers, the :ref:`stream_idle_timeout
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_idle_timeout>`
+  // applies. Each time an encode/decode event for headers or data is processed
+  // for the stream, the timer will be reset. If the timeout fires, the stream
+  // is terminated with a 408 Request Timeout error code if no upstream response
+  // header has been received, otherwise a stream reset occurs.
+  //
+  // If the :ref:`overload action <config_overload_manager_overload_actions>` "envoy.overload_actions.reduce_timeouts"
+  // is configured, this timeout is scaled according to the value for
+  // :ref:`HTTP_DOWNSTREAM_STREAM_IDLE <envoy_v3_api_enum_value_config.overload.v3.ScaleTimersOverloadActionConfig.TimerType.HTTP_DOWNSTREAM_STREAM_IDLE>`.
+  //
+  // Note that it is possible to idle timeout even if the wire traffic for a stream is non-idle, due
+  // to the granularity of events presented to the connection manager. For example, while receiving
+  // very large request headers, it may be the case that there is traffic regularly arriving on the
+  // wire while the connection manage is only able to observe the end-of-headers event, hence the
+  // stream may still idle timeout.
+  //
+  // A value of 0 will completely disable the connection manager stream idle
+  // timeout, although per-route idle timeout overrides will continue to apply.
+  //
+  // This timeout is also used as the default value for :ref:`stream_flush_timeout
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.stream_flush_timeout>`.
+  google.protobuf.Duration stream_idle_timeout = 24
+      [(udpa.annotations.security).configure_for_untrusted_downstream = true];
+
+  // The stream flush timeout for connections managed by the connection manager.
+  //
+  // If not specified, the value of stream_idle_timeout is used. This is for backwards compatibility
+  // since this was the original behavior. In essence this timeout is an override for the
+  // stream_idle_timeout that applies specifically to the end of stream flush case.
+  //
+  // This timeout specifies the amount of time that Envoy will wait for the peer to open enough
+  // window to write any remaining stream data once the entirety of stream data (local end stream is
+  // true) has been buffered pending available window. In other words, this timeout defends against
+  // a peer that does not release enough window to completely write the stream, even though all
+  // data has been proxied within available flow control windows. If the timeout is hit in this
+  // case, the :ref:`tx_flush_timeout <config_http_conn_man_stats_per_codec>` counter will be
+  // incremented. Note that :ref:`max_stream_duration
+  // <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_stream_duration>` does not apply to
+  // this corner case.
+  google.protobuf.Duration stream_flush_timeout = 59;
+
+  // The amount of time that Envoy will wait for the entire request to be received.
+  // The timer is activated when the request is initiated, and is disarmed when the last byte of the
+  // request is sent upstream (i.e. all decoding filters have processed the request), OR when the
+  // response is initiated. If not specified or set to 0, this timeout is disabled.
+  google.protobuf.Duration request_timeout = 28
+      [(udpa.annotations.security).configure_for_untrusted_downstream = true];
+
+  // The amount of time that Envoy will wait for the request headers to be received. The timer is
+  // activated when the first byte of the headers is received, and is disarmed when the last byte of
+  // the headers has been received. If not specified or set to 0, this timeout is disabled.
+  google.protobuf.Duration request_headers_timeout = 41 [
+    (validate.rules).duration = {gte {}},
+    (udpa.annotations.security).configure_for_untrusted_downstream = true
+  ];
+
+  // The time that Envoy will wait between sending an HTTP/2 “shutdown
+  // notification” (GOAWAY frame with max stream ID) and a final GOAWAY frame.
+  // This is used so that Envoy provides a grace period for new streams that
+  // race with the final GOAWAY frame. During this grace period, Envoy will
+  // continue to accept new streams. After the grace period, a final GOAWAY
+  // frame is sent and Envoy will start refusing new streams. Draining occurs
+  // either when a connection hits the idle timeout, when :ref:`max_connection_duration
+  // <envoy_v3_api_field_config.core.v3.HttpProtocolOptions.max_connection_duration>`
+  // is reached, or during general server draining. The default grace period is
+  // 5000 milliseconds (5 seconds) if this option is not specified.
+  google.protobuf.Duration drain_timeout = 12;
+
+  // The delayed close timeout is for downstream connections managed by the HTTP connection manager.
+  // It is defined as a grace period after connection close processing has been locally initiated
+  // during which Envoy will wait for the peer to close (i.e., a TCP FIN/RST is received by Envoy
+  // from the downstream connection) prior to Envoy closing the socket associated with that
+  // connection.
+  //
+  // .. note::
+  //
+  //   This timeout is enforced even when the socket associated with the downstream connection is pending a flush of
+  //   the write buffer. However, any progress made writing data to the socket will restart the timer associated with
+  //   this timeout. This means that the total grace period for a socket in this state will be
+  //   <total_time_waiting_for_write_buffer_flushes>+<delayed_close_timeout>.
+  //
+  // Delaying Envoy's connection close and giving the peer the opportunity to initiate the close
+  // sequence mitigates a race condition that exists when downstream clients do not drain/process
+  // data in a connection's receive buffer after a remote close has been detected via a socket
+  // ``write()``. This race leads to such clients failing to process the response code sent by Envoy,
+  // which could result in erroneous downstream processing.
+  //
+  // If the timeout triggers, Envoy will close the connection's socket.
+  //
+  // The default timeout is 1000 ms if this option is not specified.
+  //
+  // .. note::
+  //    To be useful in avoiding the race condition described above, this timeout must be set
+  //    to *at least* <max round trip time expected between clients and Envoy>+<100ms to account for
+  //    a reasonable "worst" case processing time for a full iteration of Envoy's event loop>.
+  //
+  // .. warning::
+  //    A value of ``0`` will completely disable delayed close processing. When disabled, the downstream
+  //    connection's socket will be closed immediately after the write flush is completed or will
+  //    never close if the write flush does not complete.
+  //
+  google.protobuf.Duration delayed_close_timeout = 26;
+
+  // Configuration for :ref:`HTTP access logs <arch_overview_access_logs>`
+  // emitted by the connection manager.
+  repeated config.accesslog.v3.AccessLog access_log = 13;
+
+  // The interval to flush the above access logs.
+  //
+  // .. attention::
+  //
+  //   This field is deprecated in favor of
+  //   :ref:`access_log_flush_interval
+  //   <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.HcmAccessLogOptions.access_log_flush_interval>`.
+  //   Note that if both this field and :ref:`access_log_flush_interval
+  //   <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.HcmAccessLogOptions.access_log_flush_interval>`
+  //   are specified, the former (deprecated field) is ignored.
+  google.protobuf.Duration access_log_flush_interval = 54 [
+    deprecated = true,
+    (validate.rules).duration = {gte {nanos: 1000000}},
+    (envoy.annotations.deprecated_at_minor_version) = "3.0"
+  ];
+
+  // If set to true, HCM will flush an access log once when a new HTTP request is received, after the request
+  // headers have been evaluated, and before iterating through the HTTP filter chain.
+  //
+  // .. attention::
+  //
+  //   This field is deprecated in favor of
+  //   :ref:`flush_access_log_on_new_request
+  //   <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.HcmAccessLogOptions.flush_access_log_on_new_request>`.
+  //   Note that if both this field and :ref:`flush_access_log_on_new_request
+  //   <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.HcmAccessLogOptions.flush_access_log_on_new_request>`
+  //   are specified, the former (deprecated field) is ignored.
+  bool flush_access_log_on_new_request = 55
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Additional access log options for HTTP connection manager.
+  HcmAccessLogOptions access_log_options = 56;
+
+  // If set to true, the connection manager will use the real remote address
+  // of the client connection when determining internal versus external origin and manipulating
+  // various headers. If set to false or absent, the connection manager will use the
+  // :ref:`config_http_conn_man_headers_x-forwarded-for` HTTP header. See the documentation for
+  // :ref:`config_http_conn_man_headers_x-forwarded-for`,
+  // :ref:`config_http_conn_man_headers_x-envoy-internal`, and
+  // :ref:`config_http_conn_man_headers_x-envoy-external-address` for more information.
+  google.protobuf.BoolValue use_remote_address = 14
+      [(udpa.annotations.security).configure_for_untrusted_downstream = true];
+
+  // The number of additional ingress proxy hops from the right side of the
+  // :ref:`config_http_conn_man_headers_x-forwarded-for` HTTP header to trust when
+  // determining the origin client's IP address. The default is zero if this option
+  // is not specified. See the documentation for
+  // :ref:`config_http_conn_man_headers_x-forwarded-for` for more information.
+  uint32 xff_num_trusted_hops = 19;
+
+  // Configuration for original IP detection extensions.
+  //
+  // When these extensions are configured, Envoy will invoke them with the incoming request headers and
+  // details about the downstream connection, including the directly connected address. Each extension uses
+  // this information to determine the effective remote IP address for the request. If an extension cannot
+  // identify the original IP address and isn't set to reject the request, Envoy will sequentially attempt
+  // the remaining extensions until one successfully determines the IP or explicitly rejects the request.
+  // If all extensions fail without rejection, Envoy defaults to using the directly connected remote address.
+  //
+  // .. warning::
+  //    These extensions cannot be configured simultaneously with :ref:`use_remote_address
+  //    <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.use_remote_address>`
+  //    or :ref:`xff_num_trusted_hops
+  //    <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.xff_num_trusted_hops>`.
+  //
+  // [#extension-category: envoy.http.original_ip_detection]
+  repeated config.core.v3.TypedExtensionConfig original_ip_detection_extensions = 46;
+
+  // The configuration for the early header mutation extensions.
+  //
+  // When configured the extensions will be called before any routing, tracing, or any filter processing.
+  // Each extension will be applied in the order they are configured.
+  // If the same header is mutated by multiple extensions, then the last extension will win.
+  //
+  // [#extension-category: envoy.http.early_header_mutation]
+  repeated config.core.v3.TypedExtensionConfig early_header_mutation_extensions = 52;
+
+  // Configures what network addresses are considered internal for stats and header sanitation
+  // purposes. If unspecified, only RFC1918 IP addresses will be considered internal.
+  // See the documentation for :ref:`config_http_conn_man_headers_x-envoy-internal` for more
+  // information about internal/external addresses.
+  //
+  // .. warning::
+  //     As of Envoy 1.33.0 no IP addresses will be considered trusted. If you have tooling such as probes
+  //     on your private network which need to be treated as trusted (e.g. changing arbitrary x-envoy headers)
+  //     you will have to manually include those addresses or CIDR ranges like:
+  //
+  // .. validated-code-block:: yaml
+  //   :type-name: envoy.extensions.filters.network.http_connection_manager.v3.InternalAddressConfig
+  //
+  //   cidr_ranges:
+  //       address_prefix: 10.0.0.0
+  //       prefix_len: 8
+  //   cidr_ranges:
+  //       address_prefix: 192.168.0.0
+  //       prefix_len: 16
+  //   cidr_ranges:
+  //       address_prefix: 172.16.0.0
+  //       prefix_len: 12
+  //   cidr_ranges:
+  //       address_prefix: 127.0.0.1
+  //       prefix_len: 32
+  //   cidr_ranges:
+  //       address_prefix: fd00::
+  //       prefix_len: 8
+  //   cidr_ranges:
+  //       address_prefix: ::1
+  //       prefix_len: 128
+  //
+  InternalAddressConfig internal_address_config = 25;
+
+  // If set, Envoy will not append the remote address to the
+  // :ref:`config_http_conn_man_headers_x-forwarded-for` HTTP header. This may be used in
+  // conjunction with HTTP filters that explicitly manipulate XFF after the HTTP connection manager
+  // has mutated the request headers. While :ref:`use_remote_address
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.use_remote_address>`
+  // will also suppress XFF addition, it has consequences for logging and other
+  // Envoy uses of the remote address, so ``skip_xff_append`` should be used
+  // when only an elision of XFF addition is intended.
+  bool skip_xff_append = 21;
+
+  // Via header value to append to request and response headers. If this is
+  // empty, no via header will be appended.
+  string via = 22 [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+
+  // Whether the connection manager will generate the :ref:`x-request-id
+  // <config_http_conn_man_headers_x-request-id>` header if it does not exist. This defaults to
+  // true. Generating a random UUID4 is expensive so in high throughput scenarios where this feature
+  // is not desired it can be disabled.
+  google.protobuf.BoolValue generate_request_id = 15;
+
+  // Whether the connection manager will keep the :ref:`x-request-id
+  // <config_http_conn_man_headers_x-request-id>` header if passed for a request that is edge
+  // (Edge request is the request from external clients to front Envoy) and not reset it, which
+  // is the current Envoy behaviour. This defaults to false.
+  bool preserve_external_request_id = 32;
+
+  // If set, Envoy will always set :ref:`x-request-id <config_http_conn_man_headers_x-request-id>` header in response.
+  // If this is false or not set, the request ID is returned in responses only if tracing is forced using
+  // :ref:`x-envoy-force-trace <config_http_conn_man_headers_x-envoy-force-trace>` header.
+  bool always_set_request_id_in_response = 37;
+
+  // How to handle the :ref:`config_http_conn_man_headers_x-forwarded-client-cert` (XFCC) HTTP
+  // header.
+  ForwardClientCertDetails forward_client_cert_details = 16
+      [(validate.rules).enum = {defined_only: true}];
+
+  // This field is valid only when :ref:`forward_client_cert_details
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.forward_client_cert_details>`
+  // is APPEND_FORWARD or SANITIZE_SET and the client connection is mTLS. It specifies the fields in
+  // the client certificate to be forwarded. Note that in the
+  // :ref:`config_http_conn_man_headers_x-forwarded-client-cert` header, ``Hash`` is always set, and
+  // ``By`` is always set when the client certificate presents the URI type Subject Alternative Name
+  // value.
+  SetCurrentClientCertDetails set_current_client_cert_details = 17;
+
+  // If proxy_100_continue is true, Envoy will proxy incoming "Expect:
+  // 100-continue" headers upstream, and forward "100 Continue" responses
+  // downstream. If this is false or not set, Envoy will instead strip the
+  // "Expect: 100-continue" header, and send a "100 Continue" response itself.
+  bool proxy_100_continue = 18;
+
+  // If
+  // :ref:`use_remote_address
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.use_remote_address>`
+  // is true and represent_ipv4_remote_address_as_ipv4_mapped_ipv6 is true and the remote address is
+  // an IPv4 address, the address will be mapped to IPv6 before it is appended to ``x-forwarded-for``.
+  // This is useful for testing compatibility of upstream services that parse the header value. For
+  // example, 50.0.0.1 is represented as ::FFFF:50.0.0.1. See `IPv4-Mapped IPv6 Addresses
+  // <https://tools.ietf.org/html/rfc4291#section-2.5.5.2>`_ for details. This will also affect the
+  // :ref:`config_http_conn_man_headers_x-envoy-external-address` header. See
+  // :ref:`http_connection_manager.represent_ipv4_remote_address_as_ipv4_mapped_ipv6
+  // <config_http_conn_man_runtime_represent_ipv4_remote_address_as_ipv4_mapped_ipv6>` for runtime
+  // control.
+  // [#not-implemented-hide:]
+  bool represent_ipv4_remote_address_as_ipv4_mapped_ipv6 = 20;
+
+  repeated UpgradeConfig upgrade_configs = 23;
+
+  // Should paths be normalized according to RFC 3986 before any processing of
+  // requests by HTTP filters or routing? This affects the upstream ``:path`` header
+  // as well. For paths that fail this check, Envoy will respond with 400 to
+  // paths that are malformed. This defaults to false currently but will default
+  // true in the future. When not specified, this value may be overridden by the
+  // runtime variable
+  // :ref:`http_connection_manager.normalize_path<config_http_conn_man_runtime_normalize_path>`.
+  // See `Normalization and Comparison <https://tools.ietf.org/html/rfc3986#section-6>`_
+  // for details of normalization.
+  // Note that Envoy does not perform
+  // `case normalization <https://tools.ietf.org/html/rfc3986#section-6.2.2.1>`_
+  // [#comment:TODO: This field is ignored when the
+  // :ref:`header validation configuration <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.typed_header_validation_config>`
+  // is present.]
+  google.protobuf.BoolValue normalize_path = 30;
+
+  // Determines if adjacent slashes in the path are merged into one before any processing of
+  // requests by HTTP filters or routing. This affects the upstream ``:path`` header as well. Without
+  // setting this option, incoming requests with path ``//dir///file`` will not match against route
+  // with ``prefix`` match set to ``/dir``. Defaults to ``false``. Note that slash merging is not part of
+  // `HTTP spec <https://tools.ietf.org/html/rfc3986>`_ and is provided for convenience.
+  // [#comment:TODO: This field is ignored when the
+  // :ref:`header validation configuration <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.typed_header_validation_config>`
+  // is present.]
+  bool merge_slashes = 33;
+
+  // Action to take when request URL path contains escaped slash sequences (%2F, %2f, %5C and %5c).
+  // The default value can be overridden by the :ref:`http_connection_manager.path_with_escaped_slashes_action<config_http_conn_man_runtime_path_with_escaped_slashes_action>`
+  // runtime variable.
+  // The :ref:`http_connection_manager.path_with_escaped_slashes_action_sampling<config_http_conn_man_runtime_path_with_escaped_slashes_action_enabled>` runtime
+  // variable can be used to apply the action to a portion of all requests.
+  // [#comment:TODO: This field is ignored when the
+  // :ref:`header validation configuration <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.typed_header_validation_config>`
+  // is present.]
+  PathWithEscapedSlashesAction path_with_escaped_slashes_action = 45;
+
+  // The configuration of the request ID extension. This includes operations such as
+  // generation, validation, and associated tracing operations. If empty, the
+  // :ref:`UuidRequestIdConfig <envoy_v3_api_msg_extensions.request_id.uuid.v3.UuidRequestIdConfig>`
+  // default extension is used with default parameters. See the documentation for that extension
+  // for details on what it does. Customizing the configuration for the default extension can be
+  // achieved by configuring it explicitly here. For example, to disable trace reason packing,
+  // the following configuration can be used:
+  //
+  // .. validated-code-block:: yaml
+  //   :type-name: envoy.extensions.filters.network.http_connection_manager.v3.RequestIDExtension
+  //
+  //   typed_config:
+  //     "@type": type.googleapis.com/envoy.extensions.request_id.uuid.v3.UuidRequestIdConfig
+  //     pack_trace_reason: false
+  //
+  // [#extension-category: envoy.request_id]
+  RequestIDExtension request_id_extension = 36;
+
+  // The configuration to customize local reply returned by Envoy. It can customize status code,
+  // body text and response content type. If not specified, status code and text body are hard
+  // coded in Envoy, the response content type is plain text.
+  LocalReplyConfig local_reply_config = 38;
+
+  // Determines if the port part should be removed from host/authority header before any processing
+  // of request by HTTP filters or routing. The port would be removed only if it is equal to the :ref:`listener's<envoy_v3_api_field_config.listener.v3.Listener.address>`
+  // local port. This affects the upstream host header unless the method is
+  // CONNECT in which case if no filter adds a port the original port will be restored before headers are
+  // sent upstream.
+  // Without setting this option, incoming requests with host ``example:443`` will not match against
+  // route with :ref:`domains<envoy_v3_api_field_config.route.v3.VirtualHost.domains>` match set to ``example``. Defaults to ``false``. Note that port removal is not part
+  // of `HTTP spec <https://tools.ietf.org/html/rfc3986>`_ and is provided for convenience.
+  // Only one of ``strip_matching_host_port`` or ``strip_any_host_port`` can be set.
+  bool strip_matching_host_port = 39
+      [(udpa.annotations.field_migrate).oneof_promotion = "strip_port_mode"];
+
+  oneof strip_port_mode {
+    // Determines if the port part should be removed from host/authority header before any processing
+    // of request by HTTP filters or routing.
+    // This affects the upstream host header unless the method is CONNECT in
+    // which case if no filter adds a port the original port will be restored before headers are sent upstream.
+    // Without setting this option, incoming requests with host ``example:443`` will not match against
+    // route with :ref:`domains<envoy_v3_api_field_config.route.v3.VirtualHost.domains>` match set to ``example``. Defaults to ``false``. Note that port removal is not part
+    // of `HTTP spec <https://tools.ietf.org/html/rfc3986>`_ and is provided for convenience.
+    // Only one of ``strip_matching_host_port`` or ``strip_any_host_port`` can be set.
+    bool strip_any_host_port = 42;
+  }
+
+  // Governs Envoy's behavior when receiving invalid HTTP from downstream.
+  // If this option is false (default), Envoy will err on the conservative side handling HTTP
+  // errors, terminating both HTTP/1.1 and HTTP/2 connections when receiving an invalid request.
+  // If this option is set to true, Envoy will be more permissive, only resetting the invalid
+  // stream in the case of HTTP/2 and leaving the connection open where possible (if the entire
+  // request is read for HTTP/1.1)
+  // In general this should be true for deployments receiving trusted traffic (L2 Envoys,
+  // company-internal mesh) and false when receiving untrusted traffic (edge deployments).
+  //
+  // If different behaviors for invalid_http_message for HTTP/1 and HTTP/2 are
+  // desired, one should use the new HTTP/1 option :ref:`override_stream_error_on_invalid_http_message
+  // <envoy_v3_api_field_config.core.v3.Http1ProtocolOptions.override_stream_error_on_invalid_http_message>` or the new HTTP/2 option
+  // :ref:`override_stream_error_on_invalid_http_message
+  // <envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.override_stream_error_on_invalid_http_message>`
+  // ``not`` the deprecated but similarly named :ref:`stream_error_on_invalid_http_messaging
+  // <envoy_v3_api_field_config.core.v3.Http2ProtocolOptions.stream_error_on_invalid_http_messaging>`
+  google.protobuf.BoolValue stream_error_on_invalid_http_message = 40;
+
+  // [#not-implemented-hide:] Path normalization configuration. This includes
+  // configurations for transformations (e.g. RFC 3986 normalization or merge
+  // adjacent slashes) and the policy to apply them. The policy determines
+  // whether transformations affect the forwarded ``:path`` header. RFC 3986 path
+  // normalization is enabled by default and the default policy is that the
+  // normalized header will be forwarded. See :ref:`PathNormalizationOptions
+  // <envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.PathNormalizationOptions>`
+  // for details.
+  PathNormalizationOptions path_normalization_options = 43;
+
+  // Determines if trailing dot of the host should be removed from host/authority header before any
+  // processing of request by HTTP filters or routing.
+  // This affects the upstream host header.
+  // Without setting this option, incoming requests with host ``example.com.`` will not match against
+  // route with :ref:`domains<envoy_v3_api_field_config.route.v3.VirtualHost.domains>` match set to ``example.com``. Defaults to ``false``.
+  // When the incoming request contains a host/authority header that includes a port number,
+  // setting this option will strip a trailing dot, if present, from the host section,
+  // leaving the port as is (e.g. host value ``example.com.:443`` will be updated to ``example.com:443``).
+  bool strip_trailing_host_dot = 47;
+
+  // Proxy-Status HTTP response header configuration.
+  // If this config is set, the Proxy-Status HTTP response header field is
+  // populated. By default, it is not.
+  ProxyStatusConfig proxy_status_config = 49;
+
+  // Configuration options for Header Validation (UHV).
+  // UHV is an extensible mechanism for checking validity of HTTP requests as well as providing
+  // normalization for request attributes, such as URI path.
+  // If the typed_header_validation_config is present it overrides the following options:
+  // ``normalize_path``, ``merge_slashes``, ``path_with_escaped_slashes_action``
+  // ``http_protocol_options.allow_chunked_length``, ``common_http_protocol_options.headers_with_underscores_action``.
+  //
+  // The default UHV checks the following:
+  //
+  // #. HTTP/1 header map validity according to `RFC 7230 section 3.2<https://datatracker.ietf.org/doc/html/rfc7230#section-3.2>`_
+  // #. Syntax of HTTP/1 request target URI and response status
+  // #. HTTP/2 header map validity according to `RFC 7540 section 8.1.2<https://datatracker.ietf.org/doc/html/rfc7540#section-8.1.2`_
+  // #. Syntax of HTTP/2 pseudo headers
+  // #. HTTP/3 header map validity according to `RFC 9114 section 4.3 <https://www.rfc-editor.org/rfc/rfc9114.html>`_
+  // #. Syntax of HTTP/3 pseudo headers
+  // #. Syntax of ``Content-Length`` and ``Transfer-Encoding``
+  // #. Validation of HTTP/1 requests with both ``Content-Length`` and ``Transfer-Encoding`` headers
+  // #. Normalization of the URI path according to `Normalization and Comparison <https://datatracker.ietf.org/doc/html/rfc3986#section-6>`_
+  //    without `case normalization <https://datatracker.ietf.org/doc/html/rfc3986#section-6.2.2.1>`_
+  //
+  // [#not-implemented-hide:]
+  // [#extension-category: envoy.http.header_validators]
+  config.core.v3.TypedExtensionConfig typed_header_validation_config = 50;
+
+  // Append the ``x-forwarded-port`` header with the port value client used to connect to Envoy. It
+  // will be ignored if the ``x-forwarded-port`` header has been set by any trusted proxy in front of Envoy.
+  bool append_x_forwarded_port = 51;
+
+  // Append the :ref:`config_http_conn_man_headers_x-envoy-local-overloaded` HTTP header in the scenario where
+  // the Overload Manager has been triggered.
+  bool append_local_overload = 57;
+
+  // Whether the HCM will add ProxyProtocolFilterState to the Connection lifetime filter state. Defaults to ``true``.
+  // This should be set to ``false`` in cases where Envoy's view of the downstream address may not correspond to the
+  // actual client address, for example, if there's another proxy in front of the Envoy.
+  google.protobuf.BoolValue add_proxy_protocol_connection_state = 53;
+}
+
+// The configuration to customize local reply returned by Envoy.
+message LocalReplyConfig {
+  // Configuration of list of mappers which allows to filter and change local response.
+  // The mappers will be checked by the specified order until one is matched.
+  repeated ResponseMapper mappers = 1;
+
+  // The configuration to form response body from the :ref:`command operators <config_access_log_command_operators>`
+  // and to specify response content type as one of: plain/text or application/json.
+  //
+  // Example one: "plain/text" ``body_format``.
+  //
+  // .. validated-code-block:: yaml
+  //   :type-name: envoy.config.core.v3.SubstitutionFormatString
+  //
+  //   text_format: "%LOCAL_REPLY_BODY%:%RESPONSE_CODE%:path=%REQ(:path)%\n"
+  //
+  // The following response body in "plain/text" format will be generated for a request with
+  // local reply body of "upstream connection error", response_code=503 and path=/foo.
+  //
+  // .. code-block:: text
+  //
+  //   upstream connect error:503:path=/foo
+  //
+  // Example two: "application/json" ``body_format``.
+  //
+  // .. validated-code-block:: yaml
+  //   :type-name: envoy.config.core.v3.SubstitutionFormatString
+  //
+  //   json_format:
+  //     status: "%RESPONSE_CODE%"
+  //     message: "%LOCAL_REPLY_BODY%"
+  //     path: "%REQ(:path)%"
+  //
+  // The following response body in "application/json" format would be generated for a request with
+  // local reply body of "upstream connection error", response_code=503 and path=/foo.
+  //
+  // .. code-block:: json
+  //
+  //  {
+  //    "status": 503,
+  //    "message": "upstream connection error",
+  //    "path": "/foo"
+  //  }
+  //
+  config.core.v3.SubstitutionFormatString body_format = 2;
+}
+
+// The configuration to filter and change local response.
+// [#next-free-field: 6]
+message ResponseMapper {
+  // Filter to determine if this mapper should apply.
+  config.accesslog.v3.AccessLogFilter filter = 1 [(validate.rules).message = {required: true}];
+
+  // The new response status code if specified.
+  google.protobuf.UInt32Value status_code = 2 [(validate.rules).uint32 = {lt: 600 gte: 200}];
+
+  // The new local reply body text if specified. It will be used in the ``%LOCAL_REPLY_BODY%``
+  // command operator in the ``body_format``.
+  config.core.v3.DataSource body = 3;
+
+  // A per mapper ``body_format`` to override the :ref:`body_format <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.LocalReplyConfig.body_format>`.
+  // It will be used when this mapper is matched.
+  config.core.v3.SubstitutionFormatString body_format_override = 4;
+
+  // HTTP headers to add to a local reply. This allows the response mapper to append, to add
+  // or to override headers of any local reply before it is sent to a downstream client.
+  repeated config.core.v3.HeaderValueOption headers_to_add = 5
+      [(validate.rules).repeated = {max_items: 1000}];
+}
+
+message Rds {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.network.http_connection_manager.v2.Rds";
+
+  // Configuration source specifier for RDS.
+  config.core.v3.ConfigSource config_source = 1;
+
+  // The name of the route configuration. This name will be passed to the RDS
+  // API. This allows an Envoy configuration with multiple HTTP listeners (and
+  // associated HTTP connection manager filters) to use different route
+  // configurations.
+  string route_config_name = 2;
+}
+
+// This message is used to work around the limitations with 'oneof' and repeated fields.
+message ScopedRouteConfigurationsList {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.network.http_connection_manager.v2.ScopedRouteConfigurationsList";
+
+  repeated config.route.v3.ScopedRouteConfiguration scoped_route_configurations = 1
+      [(validate.rules).repeated = {min_items: 1}];
+}
+
+// [#next-free-field: 6]
+message ScopedRoutes {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.network.http_connection_manager.v2.ScopedRoutes";
+
+  // Specifies the mechanism for constructing "scope keys" based on HTTP request attributes. These
+  // keys are matched against a set of :ref:`Key<envoy_v3_api_msg_config.route.v3.ScopedRouteConfiguration.Key>`
+  // objects assembled from :ref:`ScopedRouteConfiguration<envoy_v3_api_msg_config.route.v3.ScopedRouteConfiguration>`
+  // messages distributed via SRDS (the Scoped Route Discovery Service) or assigned statically via
+  // :ref:`scoped_route_configurations_list<envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.scoped_route_configurations_list>`.
+  //
+  // Upon receiving a request's headers, the Router will build a key using the algorithm specified
+  // by this message. This key will be used to look up the routing table (i.e., the
+  // :ref:`RouteConfiguration<envoy_v3_api_msg_config.route.v3.RouteConfiguration>`) to use for the request.
+  message ScopeKeyBuilder {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.config.filter.network.http_connection_manager.v2.ScopedRoutes.ScopeKeyBuilder";
+
+    // Specifies the mechanism for constructing key fragments which are composed into scope keys.
+    message FragmentBuilder {
+      option (udpa.annotations.versioning).previous_message_type =
+          "envoy.config.filter.network.http_connection_manager.v2.ScopedRoutes.ScopeKeyBuilder."
+          "FragmentBuilder";
+
+      // Specifies how the value of a header should be extracted.
+      // The following example maps the structure of a header to the fields in this message.
+      //
+      // .. code::
+      //
+      //              <0> <1>   <-- index
+      //    X-Header: a=b;c=d
+      //    |         || |
+      //    |         || \----> <element_separator>
+      //    |         ||
+      //    |         |\----> <element.separator>
+      //    |         |
+      //    |         \----> <element.key>
+      //    |
+      //    \----> <name>
+      //
+      //    Each 'a=b' key-value pair constitutes an 'element' of the header field.
+      message HeaderValueExtractor {
+        option (udpa.annotations.versioning).previous_message_type =
+            "envoy.config.filter.network.http_connection_manager.v2.ScopedRoutes.ScopeKeyBuilder."
+            "FragmentBuilder.HeaderValueExtractor";
+
+        // Specifies a header field's key value pair to match on.
+        message KvElement {
+          option (udpa.annotations.versioning).previous_message_type =
+              "envoy.config.filter.network.http_connection_manager.v2.ScopedRoutes.ScopeKeyBuilder."
+              "FragmentBuilder.HeaderValueExtractor.KvElement";
+
+          // The separator between key and value (e.g., '=' separates 'k=v;...').
+          // If an element is an empty string, the element is ignored.
+          // If an element contains no separator, the whole element is parsed as key and the
+          // fragment value is an empty string.
+          // If there are multiple values for a matched key, the first value is returned.
+          string separator = 1 [(validate.rules).string = {min_len: 1}];
+
+          // The key to match on.
+          string key = 2 [(validate.rules).string = {min_len: 1}];
+        }
+
+        // The name of the header field to extract the value from.
+        //
+        // .. note::
+        //
+        //   If the header appears multiple times only the first value is used.
+        string name = 1 [
+          (validate.rules).string = {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}
+        ];
+
+        // The element separator (e.g., ';' separates 'a;b;c;d').
+        // Default: empty string. This causes the entirety of the header field to be extracted.
+        // If this field is set to an empty string and 'index' is used in the oneof below, 'index'
+        // must be set to 0.
+        string element_separator = 2;
+
+        oneof extract_type {
+          // Specifies the zero based index of the element to extract.
+          // Note Envoy concatenates multiple values of the same header key into a comma separated
+          // string, the splitting always happens after the concatenation.
+          uint32 index = 3;
+
+          // Specifies the key value pair to extract the value from.
+          KvElement element = 4;
+        }
+      }
+
+      oneof type {
+        option (validate.required) = true;
+
+        // Specifies how a header field's value should be extracted.
+        HeaderValueExtractor header_value_extractor = 1;
+      }
+    }
+
+    // The final(built) scope key consists of the ordered union of these fragments, which are compared in order with the
+    // fragments of a :ref:`ScopedRouteConfiguration<envoy_v3_api_msg_config.route.v3.ScopedRouteConfiguration>`.
+    // A missing fragment during comparison will make the key invalid, i.e., the computed key doesn't match any key.
+    repeated FragmentBuilder fragments = 1 [(validate.rules).repeated = {min_items: 1}];
+  }
+
+  // The name assigned to the scoped routing configuration.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // The algorithm to use for constructing a scope key for each request.
+  ScopeKeyBuilder scope_key_builder = 2 [(validate.rules).message = {required: true}];
+
+  // Configuration source specifier for RDS.
+  // This config source is used to subscribe to RouteConfiguration resources specified in
+  // ScopedRouteConfiguration messages.
+  config.core.v3.ConfigSource rds_config_source = 3;
+
+  oneof config_specifier {
+    option (validate.required) = true;
+
+    // The set of routing scopes corresponding to the HCM. A scope is assigned to a request by
+    // matching a key constructed from the request's attributes according to the algorithm specified
+    // by the
+    // :ref:`ScopeKeyBuilder<envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.ScopeKeyBuilder>`
+    // in this message.
+    ScopedRouteConfigurationsList scoped_route_configurations_list = 4;
+
+    // The set of routing scopes associated with the HCM will be dynamically loaded via the SRDS
+    // API. A scope is assigned to a request by matching a key constructed from the request's
+    // attributes according to the algorithm specified by the
+    // :ref:`ScopeKeyBuilder<envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.ScopedRoutes.ScopeKeyBuilder>`
+    // in this message.
+    ScopedRds scoped_rds = 5;
+  }
+}
+
+message ScopedRds {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.network.http_connection_manager.v2.ScopedRds";
+
+  // Configuration source specifier for scoped RDS.
+  config.core.v3.ConfigSource scoped_rds_config_source = 1
+      [(validate.rules).message = {required: true}];
+
+  // xdstp:// resource locator for scoped RDS collection.
+  // [#not-implemented-hide:]
+  string srds_resources_locator = 2;
+}
+
+// [#next-free-field: 8]
+message HttpFilter {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.network.http_connection_manager.v2.HttpFilter";
+
+  reserved 3, 2;
+
+  reserved "config";
+
+  // The name of the filter configuration. It also serves as a resource name in ExtensionConfigDS.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  oneof config_type {
+    // Filter specific configuration which depends on the filter being instantiated. See the supported
+    // filters for further documentation.
+    //
+    // To support configuring a :ref:`match tree <arch_overview_matching_api>`, use an
+    // :ref:`ExtensionWithMatcher <envoy_v3_api_msg_extensions.common.matching.v3.ExtensionWithMatcher>`
+    // with the desired HTTP filter.
+    // [#extension-category: envoy.filters.http]
+    google.protobuf.Any typed_config = 4;
+
+    // Configuration source specifier for an extension configuration discovery service.
+    // In case of a failure and without the default configuration, the HTTP listener responds with code 500.
+    // Extension configs delivered through this mechanism are not expected to require warming (see https://github.com/envoyproxy/envoy/issues/12061).
+    //
+    // To support configuring a :ref:`match tree <arch_overview_matching_api>`, use an
+    // :ref:`ExtensionWithMatcher <envoy_v3_api_msg_extensions.common.matching.v3.ExtensionWithMatcher>`
+    // with the desired HTTP filter. This works for both the default filter configuration as well
+    // as for filters provided via the API.
+    config.core.v3.ExtensionConfigSource config_discovery = 5;
+  }
+
+  // If true, clients that do not support this filter may ignore the
+  // filter but otherwise accept the config.
+  // Otherwise, clients that do not support this filter must reject the config.
+  bool is_optional = 6;
+
+  // If true, the filter is disabled by default and must be explicitly enabled by setting
+  // per filter configuration in the route configuration.
+  // See :ref:`route based filter chain <arch_overview_http_filters_route_based_filter_chain>`
+  // for more details.
+  //
+  // Terminal filters (e.g. ``envoy.filters.http.router``) cannot be marked as disabled.
+  bool disabled = 7;
+}
+
+message RequestIDExtension {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.config.filter.network.http_connection_manager.v2.RequestIDExtension";
+
+  // Request ID extension specific configuration.
+  google.protobuf.Any typed_config = 1;
+}
+
+// [#protodoc-title: Envoy Mobile HTTP connection manager]
+// HTTP connection manager for use in Envoy mobile.
+// [#extension: envoy.filters.network.envoy_mobile_http_connection_manager]
+message EnvoyMobileHttpConnectionManager {
+  // The configuration for the underlying HttpConnectionManager which will be
+  // instantiated for Envoy mobile.
+  HttpConnectionManager config = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/call_credentials/access_token/v3/access_token_credentials.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/call_credentials/access_token/v3/access_token_credentials.proto
new file mode 100644
index 00000000000..45ee3839e6f
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/call_credentials/access_token/v3/access_token_credentials.proto
@@ -0,0 +1,19 @@
+syntax = "proto3";
+
+package envoy.extensions.grpc_service.call_credentials.access_token.v3;
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.grpc_service.call_credentials.access_token.v3";
+option java_outer_classname = "AccessTokenCredentialsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/grpc_service/call_credentials/access_token/v3;access_tokenv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: gRPC Access Token Credentials]
+
+// [#not-implemented-hide:]
+message AccessTokenCredentials {
+  // The access token.
+  string token = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/google_default/v3/google_default_credentials.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/google_default/v3/google_default_credentials.proto
new file mode 100644
index 00000000000..77c3af41fdd
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/google_default/v3/google_default_credentials.proto
@@ -0,0 +1,17 @@
+syntax = "proto3";
+
+package envoy.extensions.grpc_service.channel_credentials.google_default.v3;
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.grpc_service.channel_credentials.google_default.v3";
+option java_outer_classname = "GoogleDefaultCredentialsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/grpc_service/channel_credentials/google_default/v3;google_defaultv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: gRPC Google Default Credentials]
+
+// [#not-implemented-hide:]
+message GoogleDefaultCredentials {
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/insecure/v3/insecure_credentials.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/insecure/v3/insecure_credentials.proto
new file mode 100644
index 00000000000..70d58451e2d
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/insecure/v3/insecure_credentials.proto
@@ -0,0 +1,17 @@
+syntax = "proto3";
+
+package envoy.extensions.grpc_service.channel_credentials.insecure.v3;
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.grpc_service.channel_credentials.insecure.v3";
+option java_outer_classname = "InsecureCredentialsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/grpc_service/channel_credentials/insecure/v3;insecurev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: gRPC Insecure Credentials]
+
+// [#not-implemented-hide:]
+message InsecureCredentials {
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/local/v3/local_credentials.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/local/v3/local_credentials.proto
new file mode 100644
index 00000000000..00514a0e847
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/local/v3/local_credentials.proto
@@ -0,0 +1,17 @@
+syntax = "proto3";
+
+package envoy.extensions.grpc_service.channel_credentials.local.v3;
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.grpc_service.channel_credentials.local.v3";
+option java_outer_classname = "LocalCredentialsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/grpc_service/channel_credentials/local/v3;localv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: gRPC Local Credentials]
+
+// [#not-implemented-hide:]
+message LocalCredentials {
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/tls/v3/tls_credentials.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/tls/v3/tls_credentials.proto
new file mode 100644
index 00000000000..f64c16bb684
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/tls/v3/tls_credentials.proto
@@ -0,0 +1,27 @@
+syntax = "proto3";
+
+package envoy.extensions.grpc_service.channel_credentials.tls.v3;
+
+import "envoy/extensions/transport_sockets/tls/v3/tls.proto";
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.grpc_service.channel_credentials.tls.v3";
+option java_outer_classname = "TlsCredentialsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/grpc_service/channel_credentials/tls/v3;tlsv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: gRPC TLS Credentials]
+
+// [#not-implemented-hide:]
+message TlsCredentials {
+  // The certificate provider instance for the root cert. Must be set.
+  transport_sockets.tls.v3.CommonTlsContext.CertificateProviderInstance root_certificate_provider =
+      1;
+
+  // The certificate provider instance for the identity cert. Optional;
+  // if unset, no identity certificate will be sent to the server.
+  transport_sockets.tls.v3.CommonTlsContext.CertificateProviderInstance
+      identity_certificate_provider = 2;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/xds/v3/xds_credentials.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/xds/v3/xds_credentials.proto
new file mode 100644
index 00000000000..ba8d471dd49
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/grpc_service/channel_credentials/xds/v3/xds_credentials.proto
@@ -0,0 +1,21 @@
+syntax = "proto3";
+
+package envoy.extensions.grpc_service.channel_credentials.xds.v3;
+
+import "google/protobuf/any.proto";
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.grpc_service.channel_credentials.xds.v3";
+option java_outer_classname = "XdsCredentialsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/grpc_service/channel_credentials/xds/v3;xdsv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: gRPC xDS Credentials]
+
+// [#not-implemented-hide:]
+message XdsCredentials {
+  // Fallback credentials. Required.
+  google.protobuf.Any fallback_credentials = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/client_side_weighted_round_robin/v3/client_side_weighted_round_robin.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/client_side_weighted_round_robin/v3/client_side_weighted_round_robin.proto
new file mode 100644
index 00000000000..f913cb6a257
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/client_side_weighted_round_robin/v3/client_side_weighted_round_robin.proto
@@ -0,0 +1,85 @@
+syntax = "proto3";
+
+package envoy.extensions.load_balancing_policies.client_side_weighted_round_robin.v3;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.load_balancing_policies.client_side_weighted_round_robin.v3";
+option java_outer_classname = "ClientSideWeightedRoundRobinProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/load_balancing_policies/client_side_weighted_round_robin/v3;client_side_weighted_round_robinv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Client-Side Weighted Round Robin Load Balancing Policy]
+// [#extension: envoy.load_balancing_policies.client_side_weighted_round_robin]
+
+// Configuration for the client_side_weighted_round_robin LB policy.
+//
+// This policy differs from the built-in ROUND_ROBIN policy in terms of
+// how the endpoint weights are determined. In the ROUND_ROBIN policy,
+// the endpoint weights are sent by the control plane via EDS. However,
+// in this policy, the endpoint weights are instead determined via qps (queries
+// per second), eps (errors per second), and utilization metrics sent by the
+// endpoint using the Open Request Cost Aggregation (ORCA) protocol. Utilization
+// is determined by using the ORCA application_utilization field, if set, or
+// else falling back to the cpu_utilization field. All queries count toward qps,
+// regardless of result. Only failed queries count toward eps. A config
+// parameter error_utilization_penalty controls the penalty to adjust endpoint
+// weights using eps and qps. The weight of a given endpoint is computed as:
+// ``qps / (utilization + eps/qps * error_utilization_penalty)``.
+//
+// Note that Envoy will forward the ORCA response headers/trailers from the upstream
+// cluster to the downstream client. This means that if the downstream client is also
+// configured to use ``client_side_weighted_round_robin`` it will load balance against
+// Envoy based on upstream weights. This can happen when Envoy is used as a reverse proxy.
+// To avoid this issue you can configure the :ref:`header_mutation filter  <envoy_v3_api_msg_extensions.filters.http.header_mutation.v3.HeaderMutation>` to remove
+// the ORCA payload from the response headers/trailers.
+//
+// See the :ref:`load balancing architecture
+// overview<arch_overview_load_balancing_types>` for more information.
+//
+// [#next-free-field: 8]
+message ClientSideWeightedRoundRobin {
+  // Whether to enable out-of-band utilization reporting collection from
+  // the endpoints. By default, per-request utilization reporting is used.
+  google.protobuf.BoolValue enable_oob_load_report = 1;
+
+  // Load reporting interval to request from the server. Note that the
+  // server may not provide reports as frequently as the client requests.
+  // Used only when enable_oob_load_report is true. Default is 10 seconds.
+  google.protobuf.Duration oob_reporting_period = 2;
+
+  // A given endpoint must report load metrics continuously for at least
+  // this long before the endpoint weight will be used. This avoids
+  // churn when the set of endpoint addresses changes. Takes effect
+  // both immediately after we establish a connection to an endpoint and
+  // after weight_expiration_period has caused us to stop using the most
+  // recent load metrics. Default is 10 seconds.
+  google.protobuf.Duration blackout_period = 3;
+
+  // If a given endpoint has not reported load metrics in this long,
+  // then we stop using the reported weight. This ensures that we do
+  // not continue to use very stale weights. Once we stop using a stale
+  // value, if we later start seeing fresh reports again, the
+  // blackout_period applies. Defaults to 3 minutes.
+  google.protobuf.Duration weight_expiration_period = 4;
+
+  // How often endpoint weights are recalculated. Values less than 100ms are
+  // capped at 100ms. Default is 1 second.
+  google.protobuf.Duration weight_update_period = 5;
+
+  // The multiplier used to adjust endpoint weights with the error rate
+  // calculated as eps/qps. Configuration is rejected if this value is negative.
+  // Default is 1.0.
+  google.protobuf.FloatValue error_utilization_penalty = 6 [(validate.rules).float = {gte: 0.0}];
+
+  // By default, endpoint weight is computed based on the :ref:`application_utilization <envoy_v3_api_field_.xds.data.orca.v3.OrcaLoadReport.application_utilization>` field reported by the endpoint.
+  // If that field is not set, then utilization will instead be computed by taking the max of the values of the metrics specified here.
+  // For map fields in the ORCA proto, the string will be of the form ``<map_field_name>.<map_key>``. For example, the string ``named_metrics.foo`` will mean to look for the key ``foo`` in the ORCA :ref:`named_metrics <envoy_v3_api_field_.xds.data.orca.v3.OrcaLoadReport.named_metrics>` field.
+  // If none of the specified metrics are present in the load report, then :ref:`cpu_utilization <envoy_v3_api_field_.xds.data.orca.v3.OrcaLoadReport.cpu_utilization>` is used instead.
+  repeated string metric_names_for_computing_utilization = 7;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/common/v3/common.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/common/v3/common.proto
new file mode 100644
index 00000000000..22faf11b9c5
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/common/v3/common.proto
@@ -0,0 +1,161 @@
+syntax = "proto3";
+
+package envoy.extensions.load_balancing_policies.common.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/route/v3/route_components.proto";
+import "envoy/type/v3/percent.proto";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.load_balancing_policies.common.v3";
+option java_outer_classname = "CommonProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/load_balancing_policies/common/v3;commonv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Common configuration for two or more load balancing policy extensions]
+
+message LocalityLbConfig {
+  // Configuration for :ref:`zone aware routing
+  // <arch_overview_load_balancing_zone_aware_routing>`.
+  // [#next-free-field: 7]
+  message ZoneAwareLbConfig {
+    // Basis for computing per-locality percentages in zone-aware routing.
+    enum LocalityBasis {
+      // Use the number of healthy hosts in each locality.
+      HEALTHY_HOSTS_NUM = 0;
+
+      // Use the weights of healthy hosts in each locality.
+      HEALTHY_HOSTS_WEIGHT = 1;
+    }
+
+    // Configures Envoy to always route requests to the local zone regardless of the
+    // upstream zone structure. In Envoy's default configuration, traffic is distributed proportionally
+    // across all upstream hosts while trying to maximize local routing when possible. The approach
+    // with force_local_zone aims to be more predictable and if there are upstream hosts in the local
+    // zone, they will receive all traffic.
+    // * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
+    // * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
+    message ForceLocalZone {
+      // Configures the minimum number of upstream hosts in the local zone required when force_local_zone
+      // is enabled. If the number of upstream hosts in the local zone is less than the specified value,
+      // Envoy will fall back to the default proportional-based distribution across localities.
+      // If not specified, the default is 1.
+      // * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
+      // * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
+      google.protobuf.UInt32Value min_size = 1;
+    }
+
+    // Configures percentage of requests that will be considered for zone aware routing
+    // if zone aware routing is configured. If not specified, the default is 100%.
+    // * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
+    // * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
+    type.v3.Percent routing_enabled = 1;
+
+    // Configures minimum upstream cluster size required for zone aware routing
+    // If upstream cluster size is less than specified, zone aware routing is not performed
+    // even if zone aware routing is configured. If not specified, the default is 6.
+    // * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
+    // * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
+    google.protobuf.UInt64Value min_cluster_size = 2;
+
+    // If set to true, Envoy will not consider any hosts when the cluster is in :ref:`panic
+    // mode<arch_overview_load_balancing_panic_threshold>`. Instead, the cluster will fail all
+    // requests as if all hosts are unhealthy. This can help avoid potentially overwhelming a
+    // failing service.
+    bool fail_traffic_on_panic = 3;
+
+    // If set to true, Envoy will force LocalityDirect routing if a local locality exists.
+    bool force_locality_direct_routing = 4
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+    ForceLocalZone force_local_zone = 5;
+
+    // Determines how locality percentages are computed:
+    // - HEALTHY_HOSTS_NUM: proportional to the count of healthy hosts.
+    // - HEALTHY_HOSTS_WEIGHT: proportional to the weights of healthy hosts.
+    // Default value is HEALTHY_HOSTS_NUM if unset.
+    LocalityBasis locality_basis = 6;
+  }
+
+  // Configuration for :ref:`locality weighted load balancing
+  // <arch_overview_load_balancing_locality_weighted_lb>`
+  message LocalityWeightedLbConfig {
+  }
+
+  oneof locality_config_specifier {
+    option (validate.required) = true;
+
+    // Configuration for local zone aware load balancing.
+    ZoneAwareLbConfig zone_aware_lb_config = 1;
+
+    // Enable locality weighted load balancing.
+    LocalityWeightedLbConfig locality_weighted_lb_config = 2;
+  }
+}
+
+// Configuration for :ref:`slow start mode <arch_overview_load_balancing_slow_start>`.
+message SlowStartConfig {
+  // Represents the size of slow start window.
+  // If set, the newly created host remains in slow start mode starting from its creation time
+  // for the duration of slow start window.
+  google.protobuf.Duration slow_start_window = 1;
+
+  // This parameter controls the speed of traffic increase over the slow start window. Defaults to 1.0,
+  // so that endpoint would get linearly increasing amount of traffic.
+  // When increasing the value for this parameter, the speed of traffic ramp-up increases non-linearly.
+  // The value of aggression parameter should be greater than 0.0.
+  // By tuning the parameter, is possible to achieve polynomial or exponential shape of ramp-up curve.
+  //
+  // During slow start window, effective weight of an endpoint would be scaled with time factor and aggression:
+  // ``new_weight = weight * max(min_weight_percent, time_factor ^ (1 / aggression))``,
+  // where ``time_factor=(time_since_start_seconds / slow_start_time_seconds)``.
+  //
+  // As time progresses, more and more traffic would be sent to endpoint, which is in slow start window.
+  // Once host exits slow start, time_factor and aggression no longer affect its weight.
+  config.core.v3.RuntimeDouble aggression = 2;
+
+  // Configures the minimum percentage of origin weight that avoids too small new weight,
+  // which may cause endpoints in slow start mode receive no traffic in slow start window.
+  // If not specified, the default is 10%.
+  type.v3.Percent min_weight_percent = 3;
+}
+
+// Common Configuration for all consistent hashing load balancers (MaglevLb, RingHashLb, etc.)
+message ConsistentHashingLbConfig {
+  // If set to ``true``, the cluster will use hostname instead of the resolved
+  // address as the key to consistently hash to an upstream host. Only valid for StrictDNS clusters with hostnames which resolve to a single IP address.
+  bool use_hostname_for_hashing = 1;
+
+  // Configures percentage of average cluster load to bound per upstream host. For example, with a value of 150
+  // no upstream host will get a load more than 1.5 times the average load of all the hosts in the cluster.
+  // If not specified, the load is not bounded for any upstream host. Typical value for this parameter is between 120 and 200.
+  // Minimum is 100.
+  //
+  // Applies to both Ring Hash and Maglev load balancers.
+  //
+  // This is implemented based on the method described in the paper https://arxiv.org/abs/1608.01350. For the specified
+  // ``hash_balance_factor``, requests to any upstream host are capped at ``hash_balance_factor/100`` times the average number of requests
+  // across the cluster. When a request arrives for an upstream host that is currently serving at its max capacity, linear probing
+  // is used to identify an eligible host. Further, the linear probe is implemented using a random jump in hosts ring/table to identify
+  // the eligible host (this technique is as described in the paper https://arxiv.org/abs/1908.08762 - the random jump avoids the
+  // cascading overflow effect when choosing the next host in the ring/table).
+  //
+  // If weights are specified on the hosts, they are respected.
+  //
+  // This is an O(N) algorithm, unlike other load balancers. Using a lower ``hash_balance_factor`` results in more hosts
+  // being probed, so use a higher value if you require better performance.
+  google.protobuf.UInt32Value hash_balance_factor = 2 [(validate.rules).uint32 = {gte: 100}];
+
+  //  Specifies a list of hash policies to use for ring hash load balancing. If ``hash_policy`` is
+  // set, then
+  // :ref:`route level hash policy <envoy_v3_api_field_config.route.v3.RouteAction.hash_policy>`
+  // will be ignored.
+  repeated config.route.v3.RouteAction.HashPolicy hash_policy = 3;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/least_request/v3/least_request.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/least_request/v3/least_request.proto
new file mode 100644
index 00000000000..095f6075286
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/least_request/v3/least_request.proto
@@ -0,0 +1,97 @@
+syntax = "proto3";
+
+package envoy.extensions.load_balancing_policies.least_request.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/extensions/load_balancing_policies/common/v3/common.proto";
+
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.load_balancing_policies.least_request.v3";
+option java_outer_classname = "LeastRequestProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/load_balancing_policies/least_request/v3;least_requestv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Least Request Load Balancing Policy]
+// [#extension: envoy.load_balancing_policies.least_request]
+
+// This configuration allows the built-in LEAST_REQUEST LB policy to be configured via the LB policy
+// extension point. See the :ref:`load balancing architecture overview
+// <arch_overview_load_balancing_types>` for more information.
+// [#next-free-field: 7]
+message LeastRequest {
+  // Available methods for selecting the host set from which to return the host with the
+  // fewest active requests.
+  enum SelectionMethod {
+    // Return host with fewest requests from a set of ``choice_count`` randomly selected hosts.
+    // Best selection method for most scenarios.
+    N_CHOICES = 0;
+
+    // Return host with fewest requests from all hosts.
+    // Useful in some niche use cases involving low request rates and one of:
+    // (example 1) low request limits on workloads, or (example 2) few hosts.
+    //
+    // Example 1: Consider a workload type that can only accept one connection at a time.
+    // If such workloads are deployed across many hosts, only a small percentage of those
+    // workloads have zero connections at any given time, and the rate of new connections is low,
+    // the ``FULL_SCAN`` method is more likely to select a suitable host than ``N_CHOICES``.
+    //
+    // Example 2: Consider a workload type that is only deployed on 2 hosts. With default settings,
+    // the ``N_CHOICES`` method will return the host with more active requests 25% of the time.
+    // If the request rate is sufficiently low, the behavior of always selecting the host with least
+    // requests as of the last metrics refresh may be preferable.
+    FULL_SCAN = 1;
+  }
+
+  // The number of random healthy hosts from which the host with the fewest active requests will
+  // be chosen. Defaults to 2 so that we perform two-choice selection if the field is not set.
+  // Only applies to the ``N_CHOICES`` selection method.
+  google.protobuf.UInt32Value choice_count = 1 [(validate.rules).uint32 = {gte: 2}];
+
+  // The following formula is used to calculate the dynamic weights when hosts have different load
+  // balancing weights:
+  //
+  // ``weight = load_balancing_weight / (active_requests + 1)^active_request_bias``
+  //
+  // The larger the active request bias is, the more aggressively active requests will lower the
+  // effective weight when all host weights are not equal.
+  //
+  // ``active_request_bias`` must be greater than or equal to 0.0.
+  //
+  // When ``active_request_bias == 0.0`` the Least Request Load Balancer doesn't consider the number
+  // of active requests at the time it picks a host and behaves like the Round Robin Load
+  // Balancer.
+  //
+  // When ``active_request_bias > 0.0`` the Least Request Load Balancer scales the load balancing
+  // weight by the number of active requests at the time it does a pick.
+  //
+  // The value is cached for performance reasons and refreshed whenever one of the Load Balancer's
+  // host sets changes, e.g., whenever there is a host membership update or a host load balancing
+  // weight change.
+  //
+  // .. note::
+  //   This setting only takes effect if all host weights are not equal.
+  config.core.v3.RuntimeDouble active_request_bias = 2;
+
+  // Configuration for slow start mode.
+  // If this configuration is not set, slow start will not be not enabled.
+  common.v3.SlowStartConfig slow_start_config = 3;
+
+  // Configuration for local zone aware load balancing or locality weighted load balancing.
+  common.v3.LocalityLbConfig locality_lb_config = 4;
+
+  // [#not-implemented-hide:]
+  // Unused. Replaced by the `selection_method` enum for better extensibility.
+  google.protobuf.BoolValue enable_full_scan = 5
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Method for selecting the host set from which to return the host with the fewest active requests.
+  //
+  // Defaults to ``N_CHOICES``.
+  SelectionMethod selection_method = 6 [(validate.rules).enum = {defined_only: true}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/pick_first/v3/pick_first.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/pick_first/v3/pick_first.proto
new file mode 100644
index 00000000000..2a7db058e21
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/pick_first/v3/pick_first.proto
@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+package envoy.extensions.load_balancing_policies.pick_first.v3;
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.load_balancing_policies.pick_first.v3";
+option java_outer_classname = "PickFirstProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/load_balancing_policies/pick_first/v3;pick_firstv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Pick First Load Balancing Policy]
+// [#not-implemented-hide:]
+
+// This configuration allows the built-in PICK_FIRST LB policy to be configured
+// via the LB policy extension point.
+message PickFirst {
+  // If set to true, instructs the LB policy to shuffle the list of addresses
+  // received from the name resolver before attempting to connect to them.
+  bool shuffle_address_list = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/ring_hash/v3/ring_hash.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/ring_hash/v3/ring_hash.proto
new file mode 100644
index 00000000000..f154be55a7d
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/ring_hash/v3/ring_hash.proto
@@ -0,0 +1,97 @@
+syntax = "proto3";
+
+package envoy.extensions.load_balancing_policies.ring_hash.v3;
+
+import "envoy/extensions/load_balancing_policies/common/v3/common.proto";
+
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.load_balancing_policies.ring_hash.v3";
+option java_outer_classname = "RingHashProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/load_balancing_policies/ring_hash/v3;ring_hashv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Ring Hash Load Balancing Policy]
+// [#extension: envoy.load_balancing_policies.ring_hash]
+
+// This configuration allows the built-in RING_HASH LB policy to be configured via the LB policy
+// extension point. See the :ref:`load balancing architecture overview
+// <arch_overview_load_balancing_types>` for more information.
+// [#next-free-field: 8]
+message RingHash {
+  // The hash function used to hash hosts onto the ketama ring.
+  enum HashFunction {
+    // Currently defaults to XX_HASH.
+    DEFAULT_HASH = 0;
+
+    // Use `xxHash <https://github.com/Cyan4973/xxHash>`_.
+    XX_HASH = 1;
+
+    // Use `MurmurHash2 <https://sites.google.com/site/murmurhash/>`_, this is compatible with
+    // std:hash<string> in GNU libstdc++ 3.4.20 or above. This is typically the case when compiled
+    // on Linux and not macOS.
+    MURMUR_HASH_2 = 2;
+  }
+
+  // The hash function used to hash hosts onto the ketama ring. The value defaults to
+  // :ref:`XX_HASH<envoy_v3_api_enum_value_config.cluster.v3.Cluster.RingHashLbConfig.HashFunction.XX_HASH>`.
+  HashFunction hash_function = 1 [(validate.rules).enum = {defined_only: true}];
+
+  // Minimum hash ring size. The larger the ring is (that is, the more hashes there are for each
+  // provided host) the better the request distribution will reflect the desired weights. Defaults
+  // to 1024 entries, and limited to 8M entries. See also
+  // :ref:`maximum_ring_size<envoy_v3_api_field_config.cluster.v3.Cluster.RingHashLbConfig.maximum_ring_size>`.
+  google.protobuf.UInt64Value minimum_ring_size = 2
+      [(validate.rules).uint64 = {lte: 8388608 gte: 1}];
+
+  // Maximum hash ring size. Defaults to 8M entries, and limited to 8M entries, but can be lowered
+  // to further constrain resource use. See also
+  // :ref:`minimum_ring_size<envoy_v3_api_field_config.cluster.v3.Cluster.RingHashLbConfig.minimum_ring_size>`.
+  google.protobuf.UInt64Value maximum_ring_size = 3 [(validate.rules).uint64 = {lte: 8388608}];
+
+  // If set to ``true``, the cluster will use hostname instead of the resolved
+  // address as the key to consistently hash to an upstream host. Only valid for StrictDNS clusters with hostnames which resolve to a single IP address.
+  //
+  // .. note::
+  //   This is deprecated and please use :ref:`consistent_hashing_lb_config
+  //   <envoy_v3_api_field_extensions.load_balancing_policies.ring_hash.v3.RingHash.consistent_hashing_lb_config>` instead.
+  bool use_hostname_for_hashing = 4
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Configures percentage of average cluster load to bound per upstream host. For example, with a value of 150
+  // no upstream host will get a load more than 1.5 times the average load of all the hosts in the cluster.
+  // If not specified, the load is not bounded for any upstream host. Typical value for this parameter is between 120 and 200.
+  // Minimum is 100.
+  //
+  // This is implemented based on the method described in the paper https://arxiv.org/abs/1608.01350. For the specified
+  // ``hash_balance_factor``, requests to any upstream host are capped at ``hash_balance_factor/100`` times the average number of requests
+  // across the cluster. When a request arrives for an upstream host that is currently serving at its max capacity, linear probing
+  // is used to identify an eligible host. Further, the linear probe is implemented using a random jump in hosts ring/table to identify
+  // the eligible host (this technique is as described in the paper https://arxiv.org/abs/1908.08762 - the random jump avoids the
+  // cascading overflow effect when choosing the next host in the ring/table).
+  //
+  // If weights are specified on the hosts, they are respected.
+  //
+  // This is an O(N) algorithm, unlike other load balancers. Using a lower ``hash_balance_factor`` results in more hosts
+  // being probed, so use a higher value if you require better performance.
+  //
+  // .. note::
+  //   This is deprecated and please use :ref:`consistent_hashing_lb_config
+  //   <envoy_v3_api_field_extensions.load_balancing_policies.ring_hash.v3.RingHash.consistent_hashing_lb_config>` instead.
+  google.protobuf.UInt32Value hash_balance_factor = 5 [
+    deprecated = true,
+    (validate.rules).uint32 = {gte: 100},
+    (envoy.annotations.deprecated_at_minor_version) = "3.0"
+  ];
+
+  // Common configuration for hashing-based load balancing policies.
+  common.v3.ConsistentHashingLbConfig consistent_hashing_lb_config = 6;
+
+  // Enable locality weighted load balancing for ring hash lb explicitly.
+  common.v3.LocalityLbConfig.LocalityWeightedLbConfig locality_weighted_lb_config = 7;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/round_robin/v3/round_robin.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/round_robin/v3/round_robin.proto
new file mode 100644
index 00000000000..63fe49e9b0b
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/round_robin/v3/round_robin.proto
@@ -0,0 +1,28 @@
+syntax = "proto3";
+
+package envoy.extensions.load_balancing_policies.round_robin.v3;
+
+import "envoy/extensions/load_balancing_policies/common/v3/common.proto";
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.load_balancing_policies.round_robin.v3";
+option java_outer_classname = "RoundRobinProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/load_balancing_policies/round_robin/v3;round_robinv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Round Robin Load Balancing Policy]
+// [#extension: envoy.load_balancing_policies.round_robin]
+
+// This configuration allows the built-in ROUND_ROBIN LB policy to be configured via the LB policy
+// extension point. See the :ref:`load balancing architecture overview
+// <arch_overview_load_balancing_types>` for more information.
+message RoundRobin {
+  // Configuration for slow start mode.
+  // If this configuration is not set, slow start will not be not enabled.
+  common.v3.SlowStartConfig slow_start_config = 1;
+
+  // Configuration for local zone aware load balancing or locality weighted load balancing.
+  common.v3.LocalityLbConfig locality_lb_config = 2;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.proto
new file mode 100644
index 00000000000..ab8367a401a
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/load_balancing_policies/wrr_locality/v3/wrr_locality.proto
@@ -0,0 +1,25 @@
+syntax = "proto3";
+
+package envoy.extensions.load_balancing_policies.wrr_locality.v3;
+
+import "envoy/config/cluster/v3/cluster.proto";
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.load_balancing_policies.wrr_locality.v3";
+option java_outer_classname = "WrrLocalityProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/load_balancing_policies/wrr_locality/v3;wrr_localityv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Weighted Round Robin Locality-Picking Load Balancing Policy]
+// [#not-implemented-hide:]
+
+// Configuration for the wrr_locality LB policy. See the :ref:`load balancing architecture overview
+// <arch_overview_load_balancing_types>` for more information.
+message WrrLocality {
+  // The child LB policy to create for endpoint-picking within the chosen locality.
+  config.cluster.v3.LoadBalancingPolicy endpoint_picking_policy = 1
+      [(validate.rules).message = {required: true}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/http_11_proxy/v3/upstream_http_11_connect.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/http_11_proxy/v3/upstream_http_11_connect.proto
new file mode 100644
index 00000000000..2c9b5333f41
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/http_11_proxy/v3/upstream_http_11_connect.proto
@@ -0,0 +1,38 @@
+syntax = "proto3";
+
+package envoy.extensions.transport_sockets.http_11_proxy.v3;
+
+import "envoy/config/core/v3/base.proto";
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.transport_sockets.http_11_proxy.v3";
+option java_outer_classname = "UpstreamHttp11ConnectProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/transport_sockets/http_11_proxy/v3;http_11_proxyv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Upstream HTTP/1.1 Proxy]
+// [#extension: envoy.transport_sockets.http_11_proxy]
+
+// HTTP/1.1 proxy transport socket establishes an upstream connection to a proxy address
+// instead of the target host's address. This behavior is triggered when the transport
+// socket is configured and proxy information is provided.
+//
+// Behavior when proxying:
+// =======================
+// When an upstream connection is established, instead of connecting directly to the endpoint
+// address, the client will connect to the specified proxy address, send an HTTP/1.1 ``CONNECT`` request
+// indicating the endpoint address, and process the response. If the response has HTTP status 200,
+// the connection will be passed down to the underlying transport socket.
+//
+// Configuring proxy information:
+// ==============================
+// Set ``typed_filter_metadata`` in :ref:`LbEndpoint.Metadata <envoy_v3_api_field_config.endpoint.v3.lbendpoint.metadata>` or :ref:`LocalityLbEndpoints.Metadata <envoy_v3_api_field_config.endpoint.v3.LocalityLbEndpoints.metadata>`.
+// using the key ``envoy.http11_proxy_transport_socket.proxy_address`` and the
+// proxy address in ``config::core::v3::Address`` format.
+//
+message Http11ProxyUpstreamTransport {
+  // The underlying transport socket being wrapped. Defaults to plaintext (raw_buffer) if unset.
+  config.core.v3.TransportSocket transport_socket = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/tls/v3/cert.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/tls/v3/cert.proto
new file mode 100644
index 00000000000..8a5f8962bd1
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/tls/v3/cert.proto
@@ -0,0 +1,12 @@
+syntax = "proto3";
+
+package envoy.extensions.transport_sockets.tls.v3;
+
+import public "envoy/extensions/transport_sockets/tls/v3/common.proto";
+import public "envoy/extensions/transport_sockets/tls/v3/secret.proto";
+import public "envoy/extensions/transport_sockets/tls/v3/tls.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.transport_sockets.tls.v3";
+option java_outer_classname = "CertProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/transport_sockets/tls/v3;tlsv3";
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/tls/v3/common.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/tls/v3/common.proto
new file mode 100644
index 00000000000..9bc5fb5d029
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/tls/v3/common.proto
@@ -0,0 +1,597 @@
+syntax = "proto3";
+
+package envoy.extensions.transport_sockets.tls.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/extension.proto";
+import "envoy/type/matcher/v3/string.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/sensitive.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.transport_sockets.tls.v3";
+option java_outer_classname = "CommonProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/transport_sockets/tls/v3;tlsv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Common TLS configuration]
+
+// [#next-free-field: 7]
+message TlsParameters {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.auth.TlsParameters";
+
+  enum TlsProtocol {
+    // Envoy will choose the optimal TLS version.
+    TLS_AUTO = 0;
+
+    // TLS 1.0
+    TLSv1_0 = 1;
+
+    // TLS 1.1
+    TLSv1_1 = 2;
+
+    // TLS 1.2
+    TLSv1_2 = 3;
+
+    // TLS 1.3
+    TLSv1_3 = 4;
+  }
+
+  enum CompliancePolicy {
+    // FIPS_202205 configures a TLS connection to use:
+    //
+    //   * TLS 1.2 or 1.3
+    //   * For TLS 1.2, only ECDHE_[RSA|ECDSA]_WITH_AES_*_GCM_SHA*.
+    //   * For TLS 1.3, only AES-GCM
+    //   * P-256 or P-384 for key agreement.
+    //   * For server signatures, only ``PKCS#1/PSS`` with ``SHA256/384/512``, or ECDSA
+    //     with P-256 or P-384.
+    //
+    // .. attention::
+    //
+    //   Please refer to `BoringSSL policies <https://boringssl.googlesource.com/boringssl/+/refs/tags/0.20240913.0/include/openssl/ssl.h#5608>`_
+    //   for details.
+    FIPS_202205 = 0;
+  }
+
+  // Minimum TLS protocol version. By default, it's ``TLSv1_2`` for both clients and servers.
+  //
+  // TLS protocol versions below TLSv1_2 require setting compatible ciphers with the
+  // ``cipher_suites`` setting as the default ciphers no longer include compatible ciphers.
+  //
+  // .. attention::
+  //
+  //   Using TLS protocol versions below TLSv1_2 has serious security considerations and risks.
+  TlsProtocol tls_minimum_protocol_version = 1 [(validate.rules).enum = {defined_only: true}];
+
+  // Maximum TLS protocol version. By default, it's ``TLSv1_2`` for clients and ``TLSv1_3`` for
+  // servers.
+  TlsProtocol tls_maximum_protocol_version = 2 [(validate.rules).enum = {defined_only: true}];
+
+  // If specified, the TLS listener will only support the specified `cipher list
+  // <https://commondatastorage.googleapis.com/chromium-boringssl-docs/ssl.h.html#Cipher-suite-configuration>`_
+  // when negotiating TLS 1.0-1.2 (this setting has no effect when negotiating TLS 1.3).
+  //
+  // If not specified, a default list will be used. Defaults are different for server (downstream) and
+  // client (upstream) TLS configurations.
+  // Defaults will change over time in response to security considerations; If you care, configure
+  // it instead of using the default.
+  //
+  // In non-FIPS builds, the default server cipher list is:
+  //
+  // .. code-block:: none
+  //
+  //   [ECDHE-ECDSA-AES128-GCM-SHA256|ECDHE-ECDSA-CHACHA20-POLY1305]
+  //   [ECDHE-RSA-AES128-GCM-SHA256|ECDHE-RSA-CHACHA20-POLY1305]
+  //   ECDHE-ECDSA-AES256-GCM-SHA384
+  //   ECDHE-RSA-AES256-GCM-SHA384
+  //
+  // In builds using :ref:`BoringSSL FIPS <arch_overview_ssl_fips>`, the default server cipher list is:
+  //
+  // .. code-block:: none
+  //
+  //   ECDHE-ECDSA-AES128-GCM-SHA256
+  //   ECDHE-RSA-AES128-GCM-SHA256
+  //   ECDHE-ECDSA-AES256-GCM-SHA384
+  //   ECDHE-RSA-AES256-GCM-SHA384
+  //
+  // In non-FIPS builds, the default client cipher list is:
+  //
+  // .. code-block:: none
+  //
+  //   [ECDHE-ECDSA-AES128-GCM-SHA256|ECDHE-ECDSA-CHACHA20-POLY1305]
+  //   [ECDHE-RSA-AES128-GCM-SHA256|ECDHE-RSA-CHACHA20-POLY1305]
+  //   ECDHE-ECDSA-AES256-GCM-SHA384
+  //   ECDHE-RSA-AES256-GCM-SHA384
+  //
+  // In builds using :ref:`BoringSSL FIPS <arch_overview_ssl_fips>`, the default client cipher list is:
+  //
+  // .. code-block:: none
+  //
+  //   ECDHE-ECDSA-AES128-GCM-SHA256
+  //   ECDHE-RSA-AES128-GCM-SHA256
+  //   ECDHE-ECDSA-AES256-GCM-SHA384
+  //   ECDHE-RSA-AES256-GCM-SHA384
+  repeated string cipher_suites = 3;
+
+  // If specified, the TLS connection will only support the specified ECDH
+  // curves. If not specified, the default curves will be used.
+  //
+  // In non-FIPS builds, the default curves are:
+  //
+  // .. code-block:: none
+  //
+  //   X25519
+  //   P-256
+  //
+  // In builds using :ref:`BoringSSL FIPS <arch_overview_ssl_fips>`, the default curve is:
+  //
+  // .. code-block:: none
+  //
+  //   P-256
+  repeated string ecdh_curves = 4;
+
+  // If specified, the TLS connection will only support the specified signature algorithms.
+  // The list is ordered by preference.
+  // If not specified, the default signature algorithms defined by BoringSSL will be used.
+  //
+  // Default signature algorithms selected by BoringSSL (may be out of date):
+  //
+  // .. code-block:: none
+  //
+  //   ecdsa_secp256r1_sha256
+  //   rsa_pss_rsae_sha256
+  //   rsa_pkcs1_sha256
+  //   ecdsa_secp384r1_sha384
+  //   rsa_pss_rsae_sha384
+  //   rsa_pkcs1_sha384
+  //   rsa_pss_rsae_sha512
+  //   rsa_pkcs1_sha512
+  //   rsa_pkcs1_sha1
+  //
+  // Signature algorithms supported by BoringSSL (may be out of date):
+  //
+  // .. code-block:: none
+  //
+  //   rsa_pkcs1_sha256
+  //   rsa_pkcs1_sha384
+  //   rsa_pkcs1_sha512
+  //   ecdsa_secp256r1_sha256
+  //   ecdsa_secp384r1_sha384
+  //   ecdsa_secp521r1_sha512
+  //   rsa_pss_rsae_sha256
+  //   rsa_pss_rsae_sha384
+  //   rsa_pss_rsae_sha512
+  //   ed25519
+  //   rsa_pkcs1_sha1
+  //   ecdsa_sha1
+  repeated string signature_algorithms = 5;
+
+  // Compliance policies configure various aspects of the TLS based on the given policy.
+  // The policies are applied last during configuration and may override the other TLS
+  // parameters, or any previous policy.
+  repeated CompliancePolicy compliance_policies = 6 [(validate.rules).repeated = {max_items: 1}];
+}
+
+// BoringSSL private key method configuration. The private key methods are used for external
+// (potentially asynchronous) signing and decryption operations. Some use cases for private key
+// methods would be TPM support and TLS acceleration.
+message PrivateKeyProvider {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.auth.PrivateKeyProvider";
+
+  reserved 2;
+
+  reserved "config";
+
+  // Private key method provider name. The name must match a
+  // supported private key method provider type.
+  string provider_name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // Private key method provider specific configuration.
+  oneof config_type {
+    google.protobuf.Any typed_config = 3 [(udpa.annotations.sensitive) = true];
+  }
+
+  // If the private key provider isn't available (eg. the required hardware capability doesn't existed),
+  // Envoy will fallback to the BoringSSL default implementation when the ``fallback`` is true.
+  // The default value is ``false``.
+  bool fallback = 4;
+}
+
+// [#next-free-field: 9]
+message TlsCertificate {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.auth.TlsCertificate";
+
+  // The TLS certificate chain.
+  //
+  // If ``certificate_chain`` is a filesystem path, a watch will be added to the
+  // parent directory for any file moves to support rotation. This currently
+  // only applies to dynamic secrets, when the ``TlsCertificate`` is delivered via
+  // SDS.
+  config.core.v3.DataSource certificate_chain = 1;
+
+  // The TLS private key.
+  //
+  // If ``private_key`` is a filesystem path, a watch will be added to the parent
+  // directory for any file moves to support rotation. This currently only
+  // applies to dynamic secrets, when the ``TlsCertificate`` is delivered via SDS.
+  config.core.v3.DataSource private_key = 2 [(udpa.annotations.sensitive) = true];
+
+  // ``Pkcs12`` data containing TLS certificate, chain, and private key.
+  //
+  // If ``pkcs12`` is a filesystem path, the file will be read, but no watch will
+  // be added to the parent directory, since ``pkcs12`` isn't used by SDS.
+  // This field is mutually exclusive with ``certificate_chain``, ``private_key`` and ``private_key_provider``.
+  // This can't be marked as ``oneof`` due to API compatibility reasons. Setting
+  // both :ref:`private_key <envoy_v3_api_field_extensions.transport_sockets.tls.v3.TlsCertificate.private_key>`,
+  // :ref:`certificate_chain <envoy_v3_api_field_extensions.transport_sockets.tls.v3.TlsCertificate.certificate_chain>`,
+  // or :ref:`private_key_provider <envoy_v3_api_field_extensions.transport_sockets.tls.v3.TlsCertificate.private_key_provider>`
+  // and :ref:`pkcs12 <envoy_v3_api_field_extensions.transport_sockets.tls.v3.TlsCertificate.pkcs12>`
+  // fields will result in an error. Use :ref:`password
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.TlsCertificate.password>`
+  // to specify the password to unprotect the ``PKCS12`` data, if necessary.
+  config.core.v3.DataSource pkcs12 = 8 [(udpa.annotations.sensitive) = true];
+
+  // If specified, updates of file-based ``certificate_chain`` and ``private_key``
+  // sources will be triggered by this watch. The certificate/key pair will be
+  // read together and validated for atomic read consistency (i.e. no
+  // intervening modification occurred between cert/key read, verified by file
+  // hash comparisons). This allows explicit control over the path watched, by
+  // default the parent directories of the filesystem paths in
+  // ``certificate_chain`` and ``private_key`` are watched if this field is not
+  // specified. This only applies when a ``TlsCertificate`` is delivered by SDS
+  // with references to filesystem paths. See the :ref:`SDS key rotation
+  // <sds_key_rotation>` documentation for further details.
+  config.core.v3.WatchedDirectory watched_directory = 7;
+
+  // BoringSSL private key method provider. This is an alternative to :ref:`private_key
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.TlsCertificate.private_key>` field.
+  // When both :ref:`private_key <envoy_v3_api_field_extensions.transport_sockets.tls.v3.TlsCertificate.private_key>` and
+  // :ref:`private_key_provider <envoy_v3_api_field_extensions.transport_sockets.tls.v3.TlsCertificate.private_key_provider>` fields are set,
+  // ``private_key_provider`` takes precedence.
+  // If ``private_key_provider`` is unavailable and :ref:`fallback
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.PrivateKeyProvider.fallback>`
+  // is enabled, ``private_key`` will be used.
+  PrivateKeyProvider private_key_provider = 6;
+
+  // The password to decrypt the TLS private key. If this field is not set, it is assumed that the
+  // TLS private key is not password encrypted.
+  config.core.v3.DataSource password = 3 [(udpa.annotations.sensitive) = true];
+
+  // The OCSP response to be stapled with this certificate during the handshake.
+  // The response must be DER-encoded and may only be  provided via ``filename`` or
+  // ``inline_bytes``. The response may pertain to only one certificate.
+  config.core.v3.DataSource ocsp_staple = 4;
+
+  // [#not-implemented-hide:]
+  repeated config.core.v3.DataSource signed_certificate_timestamp = 5;
+}
+
+message TlsSessionTicketKeys {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.auth.TlsSessionTicketKeys";
+
+  // Keys for encrypting and decrypting TLS session tickets. The
+  // first key in the array contains the key to encrypt all new sessions created by this context.
+  // All keys are candidates for decrypting received tickets. This allows for easy rotation of keys
+  // by, for example, putting the new key first, and the previous key second.
+  //
+  // If :ref:`session_ticket_keys <envoy_v3_api_field_extensions.transport_sockets.tls.v3.DownstreamTlsContext.session_ticket_keys>`
+  // is not specified, the TLS library will still support resuming sessions via tickets, but it will
+  // use an internally-generated and managed key, so sessions cannot be resumed across hot restarts
+  // or on different hosts.
+  //
+  // Each key must contain exactly 80 bytes of cryptographically-secure random data. For
+  // example, the output of ``openssl rand 80``.
+  //
+  // .. attention::
+  //
+  //   Using this feature has serious security considerations and risks. Improper handling of keys
+  //   may result in loss of secrecy in connections, even if ciphers supporting perfect forward
+  //   secrecy are used. See https://www.imperialviolet.org/2013/06/27/botchingpfs.html for some
+  //   discussion. To minimize the risk, you must:
+  //
+  //   * Keep the session ticket keys at least as secure as your TLS certificate private keys
+  //   * Rotate session ticket keys at least daily, and preferably hourly
+  //   * Always generate keys using a cryptographically-secure random data source
+  repeated config.core.v3.DataSource keys = 1
+      [(validate.rules).repeated = {min_items: 1}, (udpa.annotations.sensitive) = true];
+}
+
+// Indicates a certificate to be obtained from a named CertificateProvider plugin instance.
+// The plugin instances are defined in the client's bootstrap file.
+// The plugin allows certificates to be fetched/refreshed over the network asynchronously with
+// respect to the TLS handshake.
+// [#not-implemented-hide:]
+message CertificateProviderPluginInstance {
+  // Provider instance name.
+  //
+  // Instance names should generally be defined not in terms of the underlying provider
+  // implementation (e.g., "file_watcher") but rather in terms of the function of the
+  // certificates (e.g., "foo_deployment_identity").
+  string instance_name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // Opaque name used to specify certificate instances or types. For example, "ROOTCA" to specify
+  // a root-certificate (validation context) or "example.com" to specify a certificate for a
+  // particular domain. Not all provider instances will actually use this field, so the value
+  // defaults to the empty string.
+  string certificate_name = 2;
+}
+
+// Matcher for subject alternative names, to match both type and value of the SAN.
+message SubjectAltNameMatcher {
+  // Indicates the choice of GeneralName as defined in section 4.2.1.5 of RFC 5280 to match
+  // against.
+  enum SanType {
+    SAN_TYPE_UNSPECIFIED = 0;
+    EMAIL = 1;
+    DNS = 2;
+    URI = 3;
+    IP_ADDRESS = 4;
+    OTHER_NAME = 5;
+  }
+
+  // Specification of type of SAN. Note that the default enum value is an invalid choice.
+  SanType san_type = 1 [(validate.rules).enum = {defined_only: true not_in: 0}];
+
+  // Matcher for SAN value.
+  //
+  // If the :ref:`san_type <envoy_v3_api_field_extensions.transport_sockets.tls.v3.SubjectAltNameMatcher.san_type>`
+  // is :ref:`DNS <envoy_v3_api_enum_value_extensions.transport_sockets.tls.v3.SubjectAltNameMatcher.SanType.DNS>`
+  // and the matcher type is :ref:`exact <envoy_v3_api_field_type.matcher.v3.StringMatcher.exact>`, DNS wildcards are evaluated
+  // according to the rules in https://www.rfc-editor.org/rfc/rfc6125#section-6.4.3.
+  // For example, ``*.example.com`` would match ``test.example.com`` but not ``example.com`` and not
+  // ``a.b.example.com``.
+  //
+  // The string matching for OTHER_NAME SAN values depends on their ASN.1 type:
+  //
+  //          * OBJECT: Validated against its dotted numeric notation (e.g., "1.2.3.4")
+  //          * BOOLEAN: Validated against strings "true" or "false"
+  //          * INTEGER/ENUMERATED: Validated against a string containing the integer value
+  //          * NULL: Validated against an empty string
+  //          * Other types: Validated directly against the string value
+  type.matcher.v3.StringMatcher matcher = 2 [(validate.rules).message = {required: true}];
+
+  // OID Value which is required if OTHER_NAME SAN type is used.
+  // For example, UPN OID is 1.3.6.1.4.1.311.20.2.3
+  // (Reference: http://oid-info.com/get/1.3.6.1.4.1.311.20.2.3).
+  //
+  // If set for SAN types other than OTHER_NAME, it will be ignored.
+  string oid = 3;
+}
+
+// [#next-free-field: 18]
+message CertificateValidationContext {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.auth.CertificateValidationContext";
+
+  // Peer certificate verification mode.
+  enum TrustChainVerification {
+    // Perform default certificate verification (e.g., against CA / verification lists)
+    VERIFY_TRUST_CHAIN = 0;
+
+    // Connections where the certificate fails verification will be permitted.
+    // For HTTP connections, the result of certificate verification can be used in route matching. (
+    // see :ref:`validated <envoy_v3_api_field_config.route.v3.RouteMatch.TlsContextMatchOptions.validated>` ).
+    ACCEPT_UNTRUSTED = 1;
+  }
+
+  message SystemRootCerts {
+  }
+
+  reserved 4, 5;
+
+  reserved "verify_subject_alt_name";
+
+  // TLS certificate data containing certificate authority certificates to use in verifying
+  // a presented peer certificate (e.g. server certificate for clusters or client certificate
+  // for listeners). If not specified and a peer certificate is presented it will not be
+  // verified. By default, a client certificate is optional, unless one of the additional
+  // options (:ref:`require_client_certificate
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.DownstreamTlsContext.require_client_certificate>`,
+  // :ref:`verify_certificate_spki
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_spki>`,
+  // :ref:`verify_certificate_hash
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_hash>`, or
+  // :ref:`match_typed_subject_alt_names
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.match_typed_subject_alt_names>`) is also
+  // specified.
+  //
+  // It can optionally contain certificate revocation lists, in which case Envoy will verify
+  // that the presented peer certificate has not been revoked by one of the included CRLs. Note
+  // that if a CRL is provided for any certificate authority in a trust chain, a CRL must be
+  // provided for all certificate authorities in that chain. Failure to do so will result in
+  // verification failure for both revoked and unrevoked certificates from that chain.
+  // The behavior of requiring all certificates to contain CRLs can be altered by
+  // setting :ref:`only_verify_leaf_cert_crl <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.only_verify_leaf_cert_crl>`
+  // true. If set to true, only the final certificate in the chain undergoes CRL verification.
+  //
+  // See :ref:`the TLS overview <arch_overview_ssl_enabling_verification>` for a list of common
+  // system CA locations.
+  //
+  // If ``trusted_ca`` is a filesystem path, a watch will be added to the parent
+  // directory for any file moves to support rotation. This currently only
+  // applies to dynamic secrets, when the ``CertificateValidationContext`` is
+  // delivered via SDS.
+  //
+  // X509_V_FLAG_PARTIAL_CHAIN is set by default, so non-root/intermediate ca certificate in ``trusted_ca``
+  // can be treated as trust anchor as well. It allows verification with building valid partial chain instead
+  // of a full chain.
+  //
+  // If ``ca_certificate_provider_instance`` is set, it takes precedence over ``trusted_ca``.
+  config.core.v3.DataSource trusted_ca = 1
+      [(udpa.annotations.field_migrate).oneof_promotion = "ca_cert_source"];
+
+  // Certificate provider instance for fetching TLS certificates.
+  //
+  // If set, takes precedence over ``trusted_ca``.
+  // [#not-implemented-hide:]
+  CertificateProviderPluginInstance ca_certificate_provider_instance = 13
+      [(udpa.annotations.field_migrate).oneof_promotion = "ca_cert_source"];
+
+  // Use system root certs for validation.
+  // If present, system root certs are used only if neither of the ``trusted_ca``
+  // or ``ca_certificate_provider_instance`` fields are set.
+  // [#not-implemented-hide:]
+  SystemRootCerts system_root_certs = 17;
+
+  // If specified, updates of a file-based ``trusted_ca`` source will be triggered
+  // by this watch. This allows explicit control over the path watched, by
+  // default the parent directory of the filesystem path in ``trusted_ca`` is
+  // watched if this field is not specified. This only applies when a
+  // ``CertificateValidationContext`` is delivered by SDS with references to
+  // filesystem paths. See the :ref:`SDS key rotation <sds_key_rotation>`
+  // documentation for further details.
+  config.core.v3.WatchedDirectory watched_directory = 11;
+
+  // An optional list of base64-encoded SHA-256 hashes. If specified, Envoy will verify that the
+  // SHA-256 of the DER-encoded Subject Public Key Information (SPKI) of the presented certificate
+  // matches one of the specified values.
+  //
+  // A base64-encoded SHA-256 of the Subject Public Key Information (SPKI) of the certificate
+  // can be generated with the following command:
+  //
+  // .. code-block:: bash
+  //
+  //   $ openssl x509 -in path/to/client.crt -noout -pubkey
+  //     | openssl pkey -pubin -outform DER
+  //     | openssl dgst -sha256 -binary
+  //     | openssl enc -base64
+  //   NvqYIYSbgK2vCJpQhObf77vv+bQWtc5ek5RIOwPiC9A=
+  //
+  // This is the format used in HTTP Public Key Pinning.
+  //
+  // When both:
+  // :ref:`verify_certificate_hash
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_hash>` and
+  // :ref:`verify_certificate_spki
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_spki>` are specified,
+  // a hash matching value from either of the lists will result in the certificate being accepted.
+  //
+  // .. attention::
+  //
+  //   This option is preferred over :ref:`verify_certificate_hash
+  //   <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_hash>`,
+  //   because SPKI is tied to a private key, so it doesn't change when the certificate
+  //   is renewed using the same private key.
+  repeated string verify_certificate_spki = 3
+      [(validate.rules).repeated = {items {string {min_len: 44 max_bytes: 44}}}];
+
+  // An optional list of hex-encoded SHA-256 hashes. If specified, Envoy will verify that
+  // the SHA-256 of the DER-encoded presented certificate matches one of the specified values.
+  //
+  // A hex-encoded SHA-256 of the certificate can be generated with the following command:
+  //
+  // .. code-block:: bash
+  //
+  //   $ openssl x509 -in path/to/client.crt -outform DER | openssl dgst -sha256 | cut -d" " -f2
+  //   df6ff72fe9116521268f6f2dd4966f51df479883fe7037b39f75916ac3049d1a
+  //
+  // A long hex-encoded and colon-separated SHA-256 (a.k.a. "fingerprint") of the certificate
+  // can be generated with the following command:
+  //
+  // .. code-block:: bash
+  //
+  //   $ openssl x509 -in path/to/client.crt -noout -fingerprint -sha256 | cut -d"=" -f2
+  //   DF:6F:F7:2F:E9:11:65:21:26:8F:6F:2D:D4:96:6F:51:DF:47:98:83:FE:70:37:B3:9F:75:91:6A:C3:04:9D:1A
+  //
+  // Both of those formats are acceptable.
+  //
+  // When both:
+  // :ref:`verify_certificate_hash
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_hash>` and
+  // :ref:`verify_certificate_spki
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.verify_certificate_spki>` are specified,
+  // a hash matching value from either of the lists will result in the certificate being accepted.
+  repeated string verify_certificate_hash = 2
+      [(validate.rules).repeated = {items {string {min_len: 64 max_bytes: 95}}}];
+
+  // An optional list of Subject Alternative name matchers. If specified, Envoy will verify that the
+  // Subject Alternative Name of the presented certificate matches one of the specified matchers.
+  // The matching uses "any" semantics, that is to say, the SAN is verified if at least one matcher is
+  // matched.
+  //
+  // When a certificate has wildcard DNS SAN entries, to match a specific client, it should be
+  // configured with exact match type in the :ref:`string matcher <envoy_v3_api_msg_type.matcher.v3.StringMatcher>`.
+  // For example if the certificate has "\*.example.com" as DNS SAN entry, to allow only "api.example.com",
+  // it should be configured as shown below.
+  //
+  // .. code-block:: yaml
+  //
+  //  match_typed_subject_alt_names:
+  //  - san_type: DNS
+  //    matcher:
+  //      exact: "api.example.com"
+  //
+  // .. attention::
+  //
+  //   Subject Alternative Names are easily spoofable and verifying only them is insecure,
+  //   therefore this option must be used together with :ref:`trusted_ca
+  //   <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.trusted_ca>`.
+  repeated SubjectAltNameMatcher match_typed_subject_alt_names = 15;
+
+  // This field is deprecated in favor of
+  // :ref:`match_typed_subject_alt_names
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.match_typed_subject_alt_names>`.
+  // Note that if both this field and :ref:`match_typed_subject_alt_names
+  // <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.match_typed_subject_alt_names>`
+  // are specified, the former (deprecated field) is ignored.
+  repeated type.matcher.v3.StringMatcher match_subject_alt_names = 9
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // [#not-implemented-hide:] Must present signed certificate time-stamp.
+  google.protobuf.BoolValue require_signed_certificate_timestamp = 6;
+
+  // An optional `certificate revocation list
+  // <https://en.wikipedia.org/wiki/Certificate_revocation_list>`_
+  // (in PEM format). If specified, Envoy will verify that the presented peer
+  // certificate has not been revoked by this CRL. If this DataSource contains
+  // multiple CRLs, all of them will be used. Note that if a CRL is provided
+  // for any certificate authority in a trust chain, a CRL must be provided
+  // for all certificate authorities in that chain. Failure to do so will
+  // result in verification failure for both revoked and unrevoked certificates
+  // from that chain. This default behavior can be altered by setting
+  // :ref:`only_verify_leaf_cert_crl <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.only_verify_leaf_cert_crl>` to
+  // true.
+  //
+  // If ``crl`` is a filesystem path, a watch will be added to the parent
+  // directory for any file moves to support rotation. This currently only
+  // applies to dynamic secrets, when the ``CertificateValidationContext`` is
+  // delivered via SDS.
+  config.core.v3.DataSource crl = 7;
+
+  // If specified, Envoy will not reject expired certificates.
+  bool allow_expired_certificate = 8;
+
+  // Certificate trust chain verification mode.
+  TrustChainVerification trust_chain_verification = 10
+      [(validate.rules).enum = {defined_only: true}];
+
+  // The configuration of an extension specific certificate validator.
+  // If specified, all validation is done by the specified validator,
+  // and the behavior of all other validation settings is defined by the specified validator (and may be entirely ignored, unused, and unvalidated).
+  // Refer to the documentation for the specified validator. If you do not want a custom validation algorithm, do not set this field.
+  // [#extension-category: envoy.tls.cert_validator]
+  config.core.v3.TypedExtensionConfig custom_validator_config = 12;
+
+  // If this option is set to true, only the certificate at the end of the
+  // certificate chain will be subject to validation by :ref:`CRL <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.crl>`.
+  bool only_verify_leaf_cert_crl = 14;
+
+  // Defines maximum depth of a certificate chain accepted in verification, the default limit is 100, though this can be system-dependent.
+  // This number does not include the leaf but includes the trust anchor, so a depth of 1 allows the leaf and one CA certificate. If a trusted issuer
+  // appears in the chain, but in a depth larger than configured, the certificate validation will fail.
+  // This matches the semantics of ``SSL_CTX_set_verify_depth`` in OpenSSL 1.0.x and older versions of BoringSSL. It differs from ``SSL_CTX_set_verify_depth``
+  // in OpenSSL 1.1.x and newer versions of BoringSSL in that the trust anchor is included.
+  // Trusted issues are specified by setting :ref:`trusted_ca <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.trusted_ca>`
+  google.protobuf.UInt32Value max_verify_depth = 16 [(validate.rules).uint32 = {lte: 100}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/tls/v3/secret.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/tls/v3/secret.proto
new file mode 100644
index 00000000000..94660e2da9f
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/tls/v3/secret.proto
@@ -0,0 +1,61 @@
+syntax = "proto3";
+
+package envoy.extensions.transport_sockets.tls.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/core/v3/config_source.proto";
+import "envoy/extensions/transport_sockets/tls/v3/common.proto";
+
+import "udpa/annotations/sensitive.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.transport_sockets.tls.v3";
+option java_outer_classname = "SecretProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/transport_sockets/tls/v3;tlsv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Secrets configuration]
+
+message GenericSecret {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.auth.GenericSecret";
+
+  // Secret of generic type and is available to filters. It is expected
+  // that only only one of secret and secrets is set.
+  config.core.v3.DataSource secret = 1 [(udpa.annotations.sensitive) = true];
+
+  // For cases where multiple associated secrets need to be distributed together. It is expected
+  // that only only one of secret and secrets is set.
+  map<string, config.core.v3.DataSource> secrets = 2 [(udpa.annotations.sensitive) = true];
+}
+
+message SdsSecretConfig {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.auth.SdsSecretConfig";
+
+  // Name by which the secret can be uniquely referred to. When both name and config are specified,
+  // then secret can be fetched and/or reloaded via SDS. When only name is specified, then secret
+  // will be loaded from static resources.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  config.core.v3.ConfigSource sds_config = 2;
+}
+
+// [#next-free-field: 6]
+message Secret {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.auth.Secret";
+
+  // Name (FQDN, UUID, SPKI, SHA256, etc.) by which the secret can be uniquely referred to.
+  string name = 1;
+
+  oneof type {
+    TlsCertificate tls_certificate = 2;
+
+    TlsSessionTicketKeys session_ticket_keys = 3;
+
+    CertificateValidationContext validation_context = 4;
+
+    GenericSecret generic_secret = 5;
+  }
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/tls/v3/tls.proto b/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/tls/v3/tls.proto
new file mode 100644
index 00000000000..b292b18c45d
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/extensions/transport_sockets/tls/v3/tls.proto
@@ -0,0 +1,365 @@
+syntax = "proto3";
+
+package envoy.extensions.transport_sockets.tls.v3;
+
+import "envoy/config/core/v3/address.proto";
+import "envoy/config/core/v3/extension.proto";
+import "envoy/extensions/transport_sockets/tls/v3/common.proto";
+import "envoy/extensions/transport_sockets/tls/v3/secret.proto";
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.extensions.transport_sockets.tls.v3";
+option java_outer_classname = "TlsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/extensions/transport_sockets/tls/v3;tlsv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: TLS transport socket]
+// [#extension: envoy.transport_sockets.tls]
+// The TLS contexts below provide the transport socket configuration for upstream/downstream TLS.
+
+// [#next-free-field: 8]
+message UpstreamTlsContext {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.auth.UpstreamTlsContext";
+
+  // Common TLS context settings.
+  //
+  // .. attention::
+  //
+  //   Server certificate verification is not enabled by default. To enable verification, configure
+  //   :ref:`trusted_ca<envoy_v3_api_field_extensions.transport_sockets.tls.v3.CertificateValidationContext.trusted_ca>`.
+  CommonTlsContext common_tls_context = 1;
+
+  // SNI string to use when creating TLS backend connections.
+  string sni = 2 [(validate.rules).string = {max_bytes: 255}];
+
+  // If true, replaces the SNI for the connection with the hostname of the upstream host, if
+  // the hostname is known due to either a DNS cluster type or the
+  // :ref:`hostname <envoy_v3_api_field_config.endpoint.v3.Endpoint.hostname>` is set on
+  // the host.
+  //
+  // See :ref:`SNI configuration <start_quick_start_securing_sni_client>` for details on how this
+  // interacts with other validation options.
+  bool auto_host_sni = 6;
+
+  // If true, replaces any Subject Alternative Name (SAN) validations with a validation for a DNS SAN matching
+  // the SNI value sent. The validation uses the actual requested SNI, regardless of how the SNI is configured.
+  //
+  // For common cases where an SNI value is present and the server certificate should include a corresponding SAN,
+  // this option ensures the SAN is properly validated.
+  //
+  // See the :ref:`validation configuration <start_quick_start_securing_validation>` for how this interacts with
+  // other validation options.
+  bool auto_sni_san_validation = 7;
+
+  // If true, server-initiated TLS renegotiation will be allowed.
+  //
+  // .. attention::
+  //
+  //   TLS renegotiation is considered insecure and shouldn't be used unless absolutely necessary.
+  bool allow_renegotiation = 3;
+
+  // Maximum number of session keys (Pre-Shared Keys for TLSv1.3+, Session IDs and Session Tickets
+  // for TLSv1.2 and older) to be stored for session resumption.
+  //
+  // Defaults to 1, setting this to 0 disables session resumption.
+  google.protobuf.UInt32Value max_session_keys = 4;
+
+  // Controls enforcement of the ``keyUsage`` extension in peer certificates. If set to ``true``, the handshake will fail if
+  // the ``keyUsage`` is incompatible with TLS usage.
+  //
+  // .. note::
+  //   The default value is ``false`` (i.e., enforcement off). It is expected to change to ``true`` in a future release.
+  //
+  // The ``ssl.was_key_usage_invalid`` in :ref:`listener metrics <config_listener_stats>` metric will be incremented
+  // for configurations that would fail if this option were enabled.
+  google.protobuf.BoolValue enforce_rsa_key_usage = 5;
+}
+
+// [#next-free-field: 12]
+message DownstreamTlsContext {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.auth.DownstreamTlsContext";
+
+  enum OcspStaplePolicy {
+    // OCSP responses are optional. If absent or expired, the certificate is used without stapling.
+    LENIENT_STAPLING = 0;
+
+    // OCSP responses are optional. If absent, the certificate is used without stapling. If present but expired,
+    // the certificate is not used for subsequent connections. Connections are rejected if no suitable certificate
+    // is found.
+    STRICT_STAPLING = 1;
+
+    // OCSP responses are required. Connections fail if a certificate lacks a valid OCSP response. Expired responses
+    // prevent certificate use in new connections, and connections are rejected if no suitable certificate is available.
+    MUST_STAPLE = 2;
+  }
+
+  // Common TLS context settings.
+  CommonTlsContext common_tls_context = 1;
+
+  // If specified, Envoy will reject connections without a valid client
+  // certificate.
+  google.protobuf.BoolValue require_client_certificate = 2;
+
+  // If specified, Envoy will reject connections without a valid and matching SNI.
+  // [#not-implemented-hide:]
+  google.protobuf.BoolValue require_sni = 3;
+
+  oneof session_ticket_keys_type {
+    // TLS session ticket key settings.
+    TlsSessionTicketKeys session_ticket_keys = 4;
+
+    // Config for fetching TLS session ticket keys via SDS API.
+    SdsSecretConfig session_ticket_keys_sds_secret_config = 5;
+
+    // Config for controlling stateless TLS session resumption: setting this to true will cause the TLS
+    // server to not issue TLS session tickets for the purposes of stateless TLS session resumption.
+    // If set to false, the TLS server will issue TLS session tickets and encrypt/decrypt them using
+    // the keys specified through either :ref:`session_ticket_keys <envoy_v3_api_field_extensions.transport_sockets.tls.v3.DownstreamTlsContext.session_ticket_keys>`
+    // or :ref:`session_ticket_keys_sds_secret_config <envoy_v3_api_field_extensions.transport_sockets.tls.v3.DownstreamTlsContext.session_ticket_keys_sds_secret_config>`.
+    // If this config is set to false and no keys are explicitly configured, the TLS server will issue
+    // TLS session tickets and encrypt/decrypt them using an internally-generated and managed key, with the
+    // implication that sessions cannot be resumed across hot restarts or on different hosts.
+    bool disable_stateless_session_resumption = 7;
+  }
+
+  // If ``true``, the TLS server will not maintain a session cache of TLS sessions.
+  //
+  // .. note::
+  //   This applies only to TLSv1.2 and earlier.
+  //
+  bool disable_stateful_session_resumption = 10;
+
+  // Maximum lifetime of TLS sessions. If specified, ``session_timeout`` will change the maximum lifetime
+  // of the TLS session.
+  //
+  // This serves as a hint for the `TLS session ticket lifetime (for TLSv1.2) <https://tools.ietf.org/html/rfc5077#section-5.6>`_.
+  // Only whole seconds are considered; fractional seconds are ignored.
+  google.protobuf.Duration session_timeout = 6 [(validate.rules).duration = {
+    lt {seconds: 4294967296}
+    gte {}
+  }];
+
+  // Configuration for handling certificates without an OCSP response or with expired responses.
+  //
+  // Defaults to ``LENIENT_STAPLING``
+  OcspStaplePolicy ocsp_staple_policy = 8 [(validate.rules).enum = {defined_only: true}];
+
+  // Multiple certificates are allowed in Downstream transport socket to serve different SNI.
+  // This option controls the behavior when no matching certificate is found for the received SNI value,
+  // or no SNI value was sent. If enabled, all certificates will be evaluated for a match for non-SNI criteria
+  // such as key type and OCSP settings. If disabled, the first provided certificate will be used.
+  // Defaults to ``false``. See more details in :ref:`Multiple TLS certificates <arch_overview_ssl_cert_select>`.
+  google.protobuf.BoolValue full_scan_certs_on_sni_mismatch = 9;
+
+  // If ``true``, the downstream client's preferred cipher is used during the handshake. If ``false``, Envoy
+  // uses its preferred cipher.
+  //
+  // .. note::
+  //   This has no effect when using TLSv1_3.
+  //
+  bool prefer_client_ciphers = 11;
+}
+
+// TLS key log configuration.
+// The key log file format is "format used by NSS for its SSLKEYLOGFILE debugging output" (text taken from openssl man page)
+message TlsKeyLog {
+  // Path to save the TLS key log.
+  string path = 1 [(validate.rules).string = {min_len: 1}];
+
+  // Local IP address ranges to filter connections for TLS key logging. If not set, matches any local IP address.
+  repeated config.core.v3.CidrRange local_address_range = 2;
+
+  // Remote IP address ranges to filter connections for TLS key logging. If not set, matches any remote IP address.
+  repeated config.core.v3.CidrRange remote_address_range = 3;
+}
+
+// TLS context shared by both client and server TLS contexts.
+// [#next-free-field: 17]
+message CommonTlsContext {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.auth.CommonTlsContext";
+
+  // Config for the Certificate Provider to fetch certificates. Certificates are fetched/refreshed asynchronously over
+  // the network relative to the TLS handshake.
+  //
+  // DEPRECATED: This message is not currently used, but if we ever do need it, we will want to
+  // move it out of CommonTlsContext and into common.proto, similar to the existing
+  // CertificateProviderPluginInstance message.
+  //
+  // [#not-implemented-hide:]
+  message CertificateProvider {
+    // opaque name used to specify certificate instances or types. For example, "ROOTCA" to specify
+    // a root-certificate (validation context) or "TLS" to specify a new tls-certificate.
+    string name = 1 [(validate.rules).string = {min_len: 1}];
+
+    // Provider specific config.
+    // Note: an implementation is expected to dedup multiple instances of the same config
+    // to maintain a single certificate-provider instance. The sharing can happen, for
+    // example, among multiple clusters or between the tls_certificate and validation_context
+    // certificate providers of a cluster.
+    // This config could be supplied inline or (in future) a named xDS resource.
+    oneof config {
+      option (validate.required) = true;
+
+      config.core.v3.TypedExtensionConfig typed_config = 2;
+    }
+  }
+
+  // Similar to CertificateProvider above, but allows the provider instances to be configured on
+  // the client side instead of being sent from the control plane.
+  //
+  // DEPRECATED: This message was moved outside of CommonTlsContext
+  // and now lives in common.proto.
+  //
+  // [#not-implemented-hide:]
+  message CertificateProviderInstance {
+    // Provider instance name. This name must be defined in the client's configuration (e.g., a
+    // bootstrap file) to correspond to a provider instance (i.e., the same data in the typed_config
+    // field that would be sent in the CertificateProvider message if the config was sent by the
+    // control plane). If not present, defaults to "default".
+    //
+    // Instance names should generally be defined not in terms of the underlying provider
+    // implementation (e.g., "file_watcher") but rather in terms of the function of the
+    // certificates (e.g., "foo_deployment_identity").
+    string instance_name = 1;
+
+    // Opaque name used to specify certificate instances or types. For example, "ROOTCA" to specify
+    // a root-certificate (validation context) or "example.com" to specify a certificate for a
+    // particular domain. Not all provider instances will actually use this field, so the value
+    // defaults to the empty string.
+    string certificate_name = 2;
+  }
+
+  message CombinedCertificateValidationContext {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.api.v2.auth.CommonTlsContext.CombinedCertificateValidationContext";
+
+    // How to validate peer certificates.
+    CertificateValidationContext default_validation_context = 1
+        [(validate.rules).message = {required: true}];
+
+    // Config for fetching validation context via SDS API. Note SDS API allows certificates to be
+    // fetched/refreshed over the network asynchronously with respect to the TLS handshake.
+    SdsSecretConfig validation_context_sds_secret_config = 2
+        [(validate.rules).message = {required: true}];
+
+    // Certificate provider for fetching CA certs. This will populate the
+    // ``default_validation_context.trusted_ca`` field.
+    // [#not-implemented-hide:]
+    CertificateProvider validation_context_certificate_provider = 3
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+    // Certificate provider instance for fetching CA certs. This will populate the
+    // ``default_validation_context.trusted_ca`` field.
+    // [#not-implemented-hide:]
+    CertificateProviderInstance validation_context_certificate_provider_instance = 4
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+  }
+
+  reserved 5;
+
+  // TLS protocol versions, cipher suites etc.
+  TlsParameters tls_params = 1;
+
+  // Only a single TLS certificate is supported in client contexts. In server contexts,
+  // :ref:`Multiple TLS certificates <arch_overview_ssl_cert_select>` can be associated with the
+  // same context to allow both RSA and ECDSA certificates and support SNI-based selection.
+  //
+  // If ``tls_certificate_provider_instance`` is set, this field is ignored.
+  // If this field is set, ``tls_certificate_sds_secret_configs`` is ignored.
+  repeated TlsCertificate tls_certificates = 2;
+
+  // Configs for fetching TLS certificates via SDS API. Note SDS API allows certificates to be
+  // fetched/refreshed over the network asynchronously with respect to the TLS handshake.
+  //
+  // The same number and types of certificates as :ref:`tls_certificates <envoy_v3_api_field_extensions.transport_sockets.tls.v3.CommonTlsContext.tls_certificates>`
+  // are valid in the certificates fetched through this setting.
+  //
+  // If ``tls_certificates`` or ``tls_certificate_provider_instance`` are set, this field
+  // is ignored.
+  repeated SdsSecretConfig tls_certificate_sds_secret_configs = 6;
+
+  // Certificate provider instance for fetching TLS certs.
+  //
+  // If this field is set, ``tls_certificates`` and ``tls_certificate_provider_instance``
+  // are ignored.
+  // [#not-implemented-hide:]
+  CertificateProviderPluginInstance tls_certificate_provider_instance = 14;
+
+  // Custom TLS certificate selector.
+  //
+  // Select TLS certificate based on TLS client hello.
+  // If empty, defaults to native TLS certificate selection behavior:
+  // DNS SANs or Subject Common Name in TLS certificates is extracted as server name pattern to match SNI.
+  config.core.v3.TypedExtensionConfig custom_tls_certificate_selector = 16;
+
+  // Certificate provider for fetching TLS certificates.
+  // [#not-implemented-hide:]
+  CertificateProvider tls_certificate_certificate_provider = 9
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Certificate provider instance for fetching TLS certificates.
+  // [#not-implemented-hide:]
+  CertificateProviderInstance tls_certificate_certificate_provider_instance = 11
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  oneof validation_context_type {
+    // How to validate peer certificates.
+    CertificateValidationContext validation_context = 3;
+
+    // Config for fetching validation context via SDS API. Note SDS API allows certificates to be
+    // fetched/refreshed over the network asynchronously with respect to the TLS handshake.
+    SdsSecretConfig validation_context_sds_secret_config = 7;
+
+    // Combines the default ``CertificateValidationContext`` with the SDS-provided dynamic context for certificate
+    // validation.
+    //
+    // When the SDS server returns a dynamic ``CertificateValidationContext``, it is merged
+    // with the default context using ``Message::MergeFrom()``. The merging rules are as follows:
+    //
+    // * **Singular Fields:** Dynamic fields override the default singular fields.
+    // * **Repeated Fields:** Dynamic repeated fields are concatenated with the default repeated fields.
+    // * **Boolean Fields:** Boolean fields are combined using a logical OR operation.
+    //
+    // The resulting ``CertificateValidationContext`` is used to perform certificate validation.
+    CombinedCertificateValidationContext combined_validation_context = 8;
+
+    // Certificate provider for fetching validation context.
+    // [#not-implemented-hide:]
+    CertificateProvider validation_context_certificate_provider = 10
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+    // Certificate provider instance for fetching validation context.
+    // [#not-implemented-hide:]
+    CertificateProviderInstance validation_context_certificate_provider_instance = 12
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+  }
+
+  // Supplies the list of ALPN protocols that the listener should expose. In
+  // practice this is likely to be set to one of two values (see the
+  // :ref:`codec_type
+  // <envoy_v3_api_field_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.codec_type>`
+  // parameter in the HTTP connection manager for more information):
+  //
+  // * "h2,http/1.1" If the listener is going to support both HTTP/2 and HTTP/1.1.
+  // * "http/1.1" If the listener is only going to support HTTP/1.1.
+  //
+  // There is no default for this parameter. If empty, Envoy will not expose ALPN.
+  repeated string alpn_protocols = 4;
+
+  // Custom TLS handshaker. If empty, defaults to native TLS handshaking
+  // behavior.
+  config.core.v3.TypedExtensionConfig custom_handshaker = 13;
+
+  // TLS key log configuration
+  TlsKeyLog key_log = 15;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/service/auth/v3/attribute_context.proto b/xds/third_party/envoy/src/main/proto/envoy/service/auth/v3/attribute_context.proto
new file mode 100644
index 00000000000..2c4fbb4b73e
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/service/auth/v3/attribute_context.proto
@@ -0,0 +1,222 @@
+syntax = "proto3";
+
+package envoy.service.auth.v3;
+
+import "envoy/config/core/v3/address.proto";
+import "envoy/config/core/v3/base.proto";
+
+import "google/protobuf/timestamp.proto";
+
+import "udpa/annotations/migrate.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.service.auth.v3";
+option java_outer_classname = "AttributeContextProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/service/auth/v3;authv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Attribute context]
+
+// See :ref:`network filter configuration overview <config_network_filters_ext_authz>`
+// and :ref:`HTTP filter configuration overview <config_http_filters_ext_authz>`.
+
+// An attribute is a piece of metadata that describes an activity on a network.
+// For example, the size of an HTTP request, or the status code of an HTTP response.
+//
+// Each attribute has a type and a name, which is logically defined as a proto message field
+// of the ``AttributeContext``. The ``AttributeContext`` is a collection of individual attributes
+// supported by Envoy authorization system.
+// [#comment: The following items are left out of this proto
+// Request.Auth field for JWTs
+// Request.Api for api management
+// Origin peer that originated the request
+// Caching Protocol
+// request_context return values to inject back into the filter chain
+// peer.claims -- from X.509 extensions
+// Configuration
+// - field mask to send
+// - which return values from request_context are copied back
+// - which return values are copied into request_headers]
+// [#next-free-field: 14]
+message AttributeContext {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.service.auth.v2.AttributeContext";
+
+  // This message defines attributes for a node that handles a network request.
+  // The node can be either a service or an application that sends, forwards,
+  // or receives the request. Service peers should fill in the ``service``,
+  // ``principal``, and ``labels`` as appropriate.
+  // [#next-free-field: 6]
+  message Peer {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.service.auth.v2.AttributeContext.Peer";
+
+    // The address of the peer, this is typically the IP address.
+    // It can also be UDS path, or others.
+    config.core.v3.Address address = 1;
+
+    // The canonical service name of the peer.
+    // It should be set to :ref:`the HTTP x-envoy-downstream-service-cluster
+    // <config_http_conn_man_headers_downstream-service-cluster>`
+    // If a more trusted source of the service name is available through mTLS/secure naming, it
+    // should be used.
+    string service = 2;
+
+    // The labels associated with the peer.
+    // These could be pod labels for Kubernetes or tags for VMs.
+    // The source of the labels could be an X.509 certificate or other configuration.
+    map<string, string> labels = 3;
+
+    // The authenticated identity of this peer.
+    // For example, the identity associated with the workload such as a service account.
+    // If an X.509 certificate is used to assert the identity this field should be sourced from
+    // ``URI Subject Alternative Names``, ``DNS Subject Alternate Names`` or ``Subject`` in that order.
+    // The primary identity should be the principal. The principal format is issuer specific.
+    //
+    // Examples:
+    //
+    // - SPIFFE format is ``spiffe://trust-domain/path``.
+    // - Google account format is ``https://accounts.google.com/{userid}``.
+    string principal = 4;
+
+    // The X.509 certificate used to authenticate the identify of this peer.
+    // When present, the certificate contents are encoded in URL and PEM format.
+    string certificate = 5;
+  }
+
+  // Represents a network request, such as an HTTP request.
+  message Request {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.service.auth.v2.AttributeContext.Request";
+
+    // The timestamp when the proxy receives the first byte of the request.
+    google.protobuf.Timestamp time = 1;
+
+    // Represents an HTTP request or an HTTP-like request.
+    HttpRequest http = 2;
+  }
+
+  // This message defines attributes for an HTTP request.
+  // HTTP/1.x, HTTP/2, gRPC are all considered as HTTP requests.
+  // [#next-free-field: 14]
+  message HttpRequest {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.service.auth.v2.AttributeContext.HttpRequest";
+
+    // The unique ID for a request, which can be propagated to downstream
+    // systems. The ID should have low probability of collision
+    // within a single day for a specific service.
+    // For HTTP requests, it should be X-Request-ID or equivalent.
+    string id = 1;
+
+    // The HTTP request method, such as ``GET``, ``POST``.
+    string method = 2;
+
+    // The HTTP request headers. If multiple headers share the same key, they
+    // must be merged according to the HTTP spec. All header keys must be
+    // lower-cased, because HTTP header keys are case-insensitive.
+    // Header value is encoded as UTF-8 string. Non-UTF-8 characters will be replaced by "!".
+    // This field will not be set if
+    // :ref:`encode_raw_headers <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.encode_raw_headers>`
+    // is set to true.
+    map<string, string> headers = 3
+        [(udpa.annotations.field_migrate).oneof_promotion = "headers_type"];
+
+    // A list of the raw HTTP request headers. This is used instead of
+    // :ref:`headers <envoy_v3_api_field_service.auth.v3.AttributeContext.HttpRequest.headers>` when
+    // :ref:`encode_raw_headers <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.encode_raw_headers>`
+    // is set to true.
+    //
+    // Note that this is not actually a map type. ``header_map`` contains a single repeated field
+    // ``headers``.
+    //
+    // Here, only the ``key`` and ``raw_value`` fields will be populated for each HeaderValue, and
+    // that is only when
+    // :ref:`encode_raw_headers <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.ExtAuthz.encode_raw_headers>`
+    // is set to true.
+    //
+    // Also, unlike the
+    // :ref:`headers <envoy_v3_api_field_service.auth.v3.AttributeContext.HttpRequest.headers>`
+    // field, headers with the same key are not combined into a single comma separated header.
+    config.core.v3.HeaderMap header_map = 13
+        [(udpa.annotations.field_migrate).oneof_promotion = "headers_type"];
+
+    // The request target, as it appears in the first line of the HTTP request. This includes
+    // the URL path and query-string. No decoding is performed.
+    string path = 4;
+
+    // The HTTP request ``Host`` or ``:authority`` header value.
+    string host = 5;
+
+    // The HTTP URL scheme, such as ``http`` and ``https``.
+    string scheme = 6;
+
+    // This field is always empty, and exists for compatibility reasons. The HTTP URL query is
+    // included in ``path`` field.
+    string query = 7;
+
+    // This field is always empty, and exists for compatibility reasons. The URL fragment is
+    // not submitted as part of HTTP requests; it is unknowable.
+    string fragment = 8;
+
+    // The HTTP request size in bytes. If unknown, it must be -1.
+    int64 size = 9;
+
+    // The network protocol used with the request, such as "HTTP/1.0", "HTTP/1.1", or "HTTP/2".
+    //
+    // See :repo:`headers.h:ProtocolStrings <source/common/http/headers.h>` for a list of all
+    // possible values.
+    string protocol = 10;
+
+    // The HTTP request body.
+    string body = 11;
+
+    // The HTTP request body in bytes. This is used instead of
+    // :ref:`body <envoy_v3_api_field_service.auth.v3.AttributeContext.HttpRequest.body>` when
+    // :ref:`pack_as_bytes <envoy_v3_api_field_extensions.filters.http.ext_authz.v3.BufferSettings.pack_as_bytes>`
+    // is set to true.
+    bytes raw_body = 12;
+  }
+
+  // This message defines attributes for the underlying TLS session.
+  message TLSSession {
+    // SNI used for TLS session.
+    string sni = 1;
+  }
+
+  // The source of a network activity, such as starting a TCP connection.
+  // In a multi hop network activity, the source represents the sender of the
+  // last hop.
+  Peer source = 1;
+
+  // The destination of a network activity, such as accepting a TCP connection.
+  // In a multi hop network activity, the destination represents the receiver of
+  // the last hop.
+  Peer destination = 2;
+
+  // Represents a network request, such as an HTTP request.
+  Request request = 4;
+
+  // This is analogous to http_request.headers, however these contents will not be sent to the
+  // upstream server. Context_extensions provide an extension mechanism for sending additional
+  // information to the auth server without modifying the proto definition. It maps to the
+  // internal opaque context in the filter chain.
+  map<string, string> context_extensions = 10;
+
+  // Dynamic metadata associated with the request.
+  config.core.v3.Metadata metadata_context = 11;
+
+  // Metadata associated with the selected route.
+  config.core.v3.Metadata route_metadata_context = 13;
+
+  // TLS session details of the underlying connection.
+  // This is not populated by default and will be populated only if the ext_authz filter has
+  // been specifically configured to include this information.
+  // For HTTP ext_authz, that requires :ref:`include_tls_session <config_http_filters_ext_authz>`
+  // to be set to true.
+  // For network ext_authz, that requires :ref:`include_tls_session <config_network_filters_ext_authz>`
+  // to be set to true.
+  TLSSession tls_session = 12;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/service/auth/v3/external_auth.proto b/xds/third_party/envoy/src/main/proto/envoy/service/auth/v3/external_auth.proto
new file mode 100644
index 00000000000..1f3ed5787d8
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/service/auth/v3/external_auth.proto
@@ -0,0 +1,144 @@
+syntax = "proto3";
+
+package envoy.service.auth.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/service/auth/v3/attribute_context.proto";
+import "envoy/type/v3/http_status.proto";
+
+import "google/protobuf/struct.proto";
+import "google/rpc/status.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.service.auth.v3";
+option java_outer_classname = "ExternalAuthProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/service/auth/v3;authv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Authorization service]
+
+// The authorization service request messages used by external authorization :ref:`network filter
+// <config_network_filters_ext_authz>` and :ref:`HTTP filter <config_http_filters_ext_authz>`.
+
+// A generic interface for performing authorization check on incoming
+// requests to a networked service.
+service Authorization {
+  // Performs authorization check based on the attributes associated with the
+  // incoming request, and returns status `OK` or not `OK`.
+  rpc Check(CheckRequest) returns (CheckResponse) {
+  }
+}
+
+message CheckRequest {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.service.auth.v2.CheckRequest";
+
+  // The request attributes.
+  AttributeContext attributes = 1;
+}
+
+// HTTP attributes for a denied response.
+message DeniedHttpResponse {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.service.auth.v2.DeniedHttpResponse";
+
+  // This field allows the authorization service to send an HTTP response status code to the
+  // downstream client. If not set, Envoy sends ``403 Forbidden`` HTTP status code by default.
+  type.v3.HttpStatus status = 1;
+
+  // This field allows the authorization service to send HTTP response headers
+  // to the downstream client. Note that the :ref:`append field in HeaderValueOption <envoy_v3_api_field_config.core.v3.HeaderValueOption.append>` defaults to
+  // false when used in this message.
+  repeated config.core.v3.HeaderValueOption headers = 2;
+
+  // This field allows the authorization service to send a response body data
+  // to the downstream client.
+  string body = 3;
+}
+
+// HTTP attributes for an OK response.
+// [#next-free-field: 9]
+message OkHttpResponse {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.service.auth.v2.OkHttpResponse";
+
+  // HTTP entity headers in addition to the original request headers. This allows the authorization
+  // service to append, to add or to override headers from the original request before
+  // dispatching it to the upstream. Note that the :ref:`append field in HeaderValueOption <envoy_v3_api_field_config.core.v3.HeaderValueOption.append>` defaults to
+  // false when used in this message. By setting the ``append`` field to ``true``,
+  // the filter will append the correspondent header value to the matched request header.
+  // By leaving ``append`` as false, the filter will either add a new header, or override an existing
+  // one if there is a match.
+  repeated config.core.v3.HeaderValueOption headers = 2;
+
+  // HTTP entity headers to remove from the original request before dispatching
+  // it to the upstream. This allows the authorization service to act on auth
+  // related headers (like ``Authorization``), process them, and consume them.
+  // Under this model, the upstream will either receive the request (if it's
+  // authorized) or not receive it (if it's not), but will not see headers
+  // containing authorization credentials.
+  //
+  // Pseudo headers (such as ``:authority``, ``:method``, ``:path`` etc), as well as
+  // the header ``Host``, may not be removed as that would make the request
+  // malformed. If mentioned in ``headers_to_remove`` these special headers will
+  // be ignored.
+  //
+  // When using the HTTP service this must instead be set by the HTTP
+  // authorization service as a comma separated list like so:
+  // ``x-envoy-auth-headers-to-remove: one-auth-header, another-auth-header``.
+  repeated string headers_to_remove = 5;
+
+  // This field has been deprecated in favor of :ref:`CheckResponse.dynamic_metadata
+  // <envoy_v3_api_field_service.auth.v3.CheckResponse.dynamic_metadata>`. Until it is removed,
+  // setting this field overrides :ref:`CheckResponse.dynamic_metadata
+  // <envoy_v3_api_field_service.auth.v3.CheckResponse.dynamic_metadata>`.
+  google.protobuf.Struct dynamic_metadata = 3
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // This field allows the authorization service to send HTTP response headers
+  // to the downstream client on success. Note that the :ref:`append field in HeaderValueOption <envoy_v3_api_field_config.core.v3.HeaderValueOption.append>`
+  // defaults to false when used in this message.
+  repeated config.core.v3.HeaderValueOption response_headers_to_add = 6;
+
+  // This field allows the authorization service to set (and overwrite) query
+  // string parameters on the original request before it is sent upstream.
+  repeated config.core.v3.QueryParameter query_parameters_to_set = 7;
+
+  // This field allows the authorization service to specify which query parameters
+  // should be removed from the original request before it is sent upstream. Each
+  // element in this list is a case-sensitive query parameter name to be removed.
+  repeated string query_parameters_to_remove = 8;
+}
+
+// Intended for gRPC and Network Authorization servers ``only``.
+message CheckResponse {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.service.auth.v2.CheckResponse";
+
+  // Status ``OK`` allows the request. Any other status indicates the request should be denied, and
+  // for HTTP filter, if not overridden by :ref:`denied HTTP response status <envoy_v3_api_field_service.auth.v3.DeniedHttpResponse.status>`
+  // Envoy sends ``403 Forbidden`` HTTP status code by default.
+  google.rpc.Status status = 1;
+
+  // An message that contains HTTP response attributes. This message is
+  // used when the authorization service needs to send custom responses to the
+  // downstream client or, to modify/add request headers being dispatched to the upstream.
+  oneof http_response {
+    // Supplies http attributes for a denied response.
+    DeniedHttpResponse denied_response = 2;
+
+    // Supplies http attributes for an ok response.
+    OkHttpResponse ok_response = 3;
+  }
+
+  // Optional response metadata that will be emitted as dynamic metadata to be consumed by the next
+  // filter. This metadata lives in a namespace specified by the canonical name of extension filter
+  // that requires it:
+  //
+  // - :ref:`envoy.filters.http.ext_authz <config_http_filters_ext_authz_dynamic_metadata>` for HTTP filter.
+  // - :ref:`envoy.filters.network.ext_authz <config_network_filters_ext_authz_dynamic_metadata>` for network filter.
+  google.protobuf.Struct dynamic_metadata = 4;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v3/ads.proto b/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v3/ads.proto
new file mode 100644
index 00000000000..50f2af4fe48
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v3/ads.proto
@@ -0,0 +1,44 @@
+syntax = "proto3";
+
+package envoy.service.discovery.v3;
+
+import "envoy/service/discovery/v3/discovery.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.service.discovery.v3";
+option java_outer_classname = "AdsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/service/discovery/v3;discoveryv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Aggregated Discovery Service (ADS)]
+
+// Discovery services for endpoints, clusters, routes,
+// and listeners are retained in the package `envoy.api.v2` for backwards
+// compatibility with existing management servers. New development in discovery
+// services should proceed in the package `envoy.service.discovery.v2`.
+
+// See https://github.com/envoyproxy/envoy-api#apis for a description of the role of
+// ADS and how it is intended to be used by a management server. ADS requests
+// have the same structure as their singleton xDS counterparts, but can
+// multiplex many resource types on a single stream. The type_url in the
+// DiscoveryRequest/DiscoveryResponse provides sufficient information to recover
+// the multiplexed singleton APIs at the Envoy instance and management server.
+service AggregatedDiscoveryService {
+  // This is a gRPC-only API.
+  rpc StreamAggregatedResources(stream DiscoveryRequest) returns (stream DiscoveryResponse) {
+  }
+
+  rpc DeltaAggregatedResources(stream DeltaDiscoveryRequest)
+      returns (stream DeltaDiscoveryResponse) {
+  }
+}
+
+// [#not-implemented-hide:] Not configuration. Workaround c++ protobuf issue with importing
+// services: https://github.com/google/protobuf/issues/4221
+message AdsDummy {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.service.discovery.v2.AdsDummy";
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v3/discovery.proto b/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v3/discovery.proto
new file mode 100644
index 00000000000..e1ce827a48f
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/service/discovery/v3/discovery.proto
@@ -0,0 +1,443 @@
+syntax = "proto3";
+
+package envoy.service.discovery.v3;
+
+import "envoy/config/core/v3/base.proto";
+
+import "google/protobuf/any.proto";
+import "google/protobuf/duration.proto";
+import "google/rpc/status.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.service.discovery.v3";
+option java_outer_classname = "DiscoveryProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/service/discovery/v3;discoveryv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Common discovery API components]
+
+// Specifies a resource to be subscribed to.
+message ResourceLocator {
+  // The resource name to subscribe to.
+  string name = 1;
+
+  // A set of dynamic parameters used to match against the dynamic parameter
+  // constraints on the resource. This allows clients to select between
+  // multiple variants of the same resource.
+  map<string, string> dynamic_parameters = 2;
+}
+
+// Specifies a concrete resource name.
+message ResourceName {
+  // The name of the resource.
+  string name = 1;
+
+  // Dynamic parameter constraints associated with this resource. To be used by client-side caches
+  // (including xDS proxies) when matching subscribed resource locators.
+  DynamicParameterConstraints dynamic_parameter_constraints = 2;
+}
+
+// [#not-implemented-hide:]
+// An error associated with a specific resource name, returned to the
+// client by the server.
+message ResourceError {
+  // The name of the resource.
+  ResourceName resource_name = 1;
+
+  // The error reported for the resource.
+  google.rpc.Status error_detail = 2;
+}
+
+// A DiscoveryRequest requests a set of versioned resources of the same type for
+// a given Envoy node on some API.
+// [#next-free-field: 8]
+message DiscoveryRequest {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.DiscoveryRequest";
+
+  // The ``version_info`` provided in the request messages will be the ``version_info``
+  // received with the most recent successfully processed response or empty on
+  // the first request. It is expected that no new request is sent after a
+  // response is received until the Envoy instance is ready to ACK/NACK the new
+  // configuration. ACK/NACK takes place by returning the new API config version
+  // as applied or the previous API config version respectively. Each ``type_url``
+  // (see below) has an independent version associated with it.
+  string version_info = 1;
+
+  // The node making the request.
+  config.core.v3.Node node = 2;
+
+  // List of resources to subscribe to, e.g. list of cluster names or a route
+  // configuration name. If this is empty, all resources for the API are
+  // returned. LDS/CDS may have empty ``resource_names``, which will cause all
+  // resources for the Envoy instance to be returned. The LDS and CDS responses
+  // will then imply a number of resources that need to be fetched via EDS/RDS,
+  // which will be explicitly enumerated in ``resource_names``.
+  repeated string resource_names = 3;
+
+  // [#not-implemented-hide:]
+  // Alternative to ``resource_names`` field that allows specifying dynamic
+  // parameters along with each resource name. Clients that populate this
+  // field must be able to handle responses from the server where resources
+  // are wrapped in a Resource message.
+  //
+  // .. note::
+  //   It is legal for a request to have some resources listed
+  //   in ``resource_names`` and others in ``resource_locators``.
+  //
+  repeated ResourceLocator resource_locators = 7;
+
+  // Type of the resource that is being requested, e.g.
+  // ``type.googleapis.com/envoy.api.v2.ClusterLoadAssignment``. This is implicit
+  // in requests made via singleton xDS APIs such as CDS, LDS, etc. but is
+  // required for ADS.
+  string type_url = 4;
+
+  // nonce corresponding to ``DiscoveryResponse`` being ACK/NACKed. See above
+  // discussion on ``version_info`` and the ``DiscoveryResponse`` nonce comment. This
+  // may be empty only if:
+  //
+  // * This is a non-persistent-stream xDS such as HTTP, or
+  // * The client has not yet accepted an update in this xDS stream (unlike
+  //   delta, where it is populated only for new explicit ACKs).
+  //
+  string response_nonce = 5;
+
+  // This is populated when the previous :ref:`DiscoveryResponse <envoy_v3_api_msg_service.discovery.v3.DiscoveryResponse>`
+  // failed to update configuration. The ``message`` field in ``error_details`` provides the Envoy
+  // internal exception related to the failure. It is only intended for consumption during manual
+  // debugging, the string provided is not guaranteed to be stable across Envoy versions.
+  google.rpc.Status error_detail = 6;
+}
+
+// [#next-free-field: 8]
+message DiscoveryResponse {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.DiscoveryResponse";
+
+  // The version of the response data.
+  string version_info = 1;
+
+  // The response resources. These resources are typed and depend on the API being called.
+  repeated google.protobuf.Any resources = 2;
+
+  // [#not-implemented-hide:]
+  // Canary is used to support two Envoy command line flags:
+  //
+  // * ``--terminate-on-canary-transition-failure``. When set, Envoy is able to
+  //   terminate if it detects that configuration is stuck at canary. Consider
+  //   this example sequence of updates:
+  //
+  //   * Management server applies a canary config successfully.
+  //   * Management server rolls back to a production config.
+  //   * Envoy rejects the new production config.
+  //
+  //   Since there is no sensible way to continue receiving configuration
+  //   updates, Envoy will then terminate and apply production config from a
+  //   clean slate.
+  //
+  // * ``--dry-run-canary``. When set, a canary response will never be applied, only
+  //   validated via a dry run.
+  //
+  bool canary = 3;
+
+  // Type URL for resources. Identifies the xDS API when muxing over ADS.
+  // Must be consistent with the ``type_url`` in the 'resources' repeated Any (if non-empty).
+  string type_url = 4;
+
+  // For gRPC based subscriptions, the nonce provides a way to explicitly ack a
+  // specific ``DiscoveryResponse`` in a following ``DiscoveryRequest``. Additional
+  // messages may have been sent by Envoy to the management server for the
+  // previous version on the stream prior to this ``DiscoveryResponse``, that were
+  // unprocessed at response send time. The nonce allows the management server
+  // to ignore any further ``DiscoveryRequests`` for the previous version until a
+  // ``DiscoveryRequest`` bearing the nonce. The nonce is optional and is not
+  // required for non-stream based xDS implementations.
+  string nonce = 5;
+
+  // The control plane instance that sent the response.
+  config.core.v3.ControlPlane control_plane = 6;
+
+  // [#not-implemented-hide:]
+  // Errors associated with specific resources. Clients are expected to
+  // remember the most recent error for a given resource across responses;
+  // the error condition is not considered to be cleared until a response is
+  // received that contains the resource in the 'resources' field.
+  repeated ResourceError resource_errors = 7;
+}
+
+// DeltaDiscoveryRequest and DeltaDiscoveryResponse are used in a new gRPC
+// endpoint for Delta xDS.
+//
+// With Delta xDS, the DeltaDiscoveryResponses do not need to include a full
+// snapshot of the tracked resources. Instead, DeltaDiscoveryResponses are a
+// diff to the state of a xDS client.
+// In Delta XDS there are per-resource versions, which allow tracking state at
+// the resource granularity.
+// An xDS Delta session is always in the context of a gRPC bidirectional
+// stream. This allows the xDS server to keep track of the state of xDS clients
+// connected to it.
+//
+// In Delta xDS the nonce field is required and used to pair
+// ``DeltaDiscoveryResponse`` to a ``DeltaDiscoveryRequest`` ACK or NACK.
+// Optionally, a response message level ``system_version_info`` is present for
+// debugging purposes only.
+//
+// ``DeltaDiscoveryRequest`` plays two independent roles. Any ``DeltaDiscoveryRequest``
+// can be either or both of:
+//
+// * Informing the server of what resources the client has gained/lost interest in
+//   (using ``resource_names_subscribe`` and ``resource_names_unsubscribe``), or
+// * (N)ACKing an earlier resource update from the server (using ``response_nonce``,
+//   with presence of ``error_detail`` making it a NACK).
+//
+// Additionally, the first message (for a given ``type_url``) of a reconnected gRPC stream
+// has a third role: informing the server of the resources (and their versions)
+// that the client already possesses, using the ``initial_resource_versions`` field.
+//
+// As with state-of-the-world, when multiple resource types are multiplexed (ADS),
+// all requests/acknowledgments/updates are logically walled off by ``type_url``:
+// a Cluster ACK exists in a completely separate world from a prior Route NACK.
+// In particular, ``initial_resource_versions`` being sent at the "start" of every
+// gRPC stream actually entails a message for each ``type_url``, each with its own
+// ``initial_resource_versions``.
+// [#next-free-field: 10]
+message DeltaDiscoveryRequest {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.DeltaDiscoveryRequest";
+
+  // The node making the request.
+  config.core.v3.Node node = 1;
+
+  // Type of the resource that is being requested, e.g.
+  // ``type.googleapis.com/envoy.api.v2.ClusterLoadAssignment``. This does not need to be set if
+  // resources are only referenced via ``xds_resource_subscribe`` and
+  // ``xds_resources_unsubscribe``.
+  string type_url = 2;
+
+  // DeltaDiscoveryRequests allow the client to add or remove individual
+  // resources to the set of tracked resources in the context of a stream.
+  // All resource names in the ``resource_names_subscribe`` list are added to the
+  // set of tracked resources and all resource names in the ``resource_names_unsubscribe``
+  // list are removed from the set of tracked resources.
+  //
+  // *Unlike* state-of-the-world xDS, an empty ``resource_names_subscribe`` or
+  // ``resource_names_unsubscribe`` list simply means that no resources are to be
+  // added or removed to the resource list.
+  // *Like* state-of-the-world xDS, the server must send updates for all tracked
+  // resources, but can also send updates for resources the client has not subscribed to.
+  //
+  // .. note::
+  //   The server must respond with all resources listed in ``resource_names_subscribe``,
+  //   even if it believes the client has the most recent version of them. The reason:
+  //   the client may have dropped them, but then regained interest before it had a chance
+  //   to send the unsubscribe message. See DeltaSubscriptionStateTest.RemoveThenAdd.
+  //
+  // These two fields can be set in any ``DeltaDiscoveryRequest``, including ACKs
+  // and ``initial_resource_versions``.
+  //
+  // A list of Resource names to add to the list of tracked resources.
+  repeated string resource_names_subscribe = 3;
+
+  // A list of Resource names to remove from the list of tracked resources.
+  repeated string resource_names_unsubscribe = 4;
+
+  // [#not-implemented-hide:]
+  // Alternative to ``resource_names_subscribe`` field that allows specifying dynamic parameters
+  // along with each resource name.
+  //
+  // .. note::
+  //   It is legal for a request to have some resources listed
+  //   in ``resource_names_subscribe`` and others in ``resource_locators_subscribe``.
+  //
+  repeated ResourceLocator resource_locators_subscribe = 8;
+
+  // [#not-implemented-hide:]
+  // Alternative to ``resource_names_unsubscribe`` field that allows specifying dynamic parameters
+  // along with each resource name.
+  //
+  // .. note::
+  //   It is legal for a request to have some resources listed
+  //   in ``resource_names_unsubscribe`` and others in ``resource_locators_unsubscribe``.
+  //
+  repeated ResourceLocator resource_locators_unsubscribe = 9;
+
+  // Informs the server of the versions of the resources the xDS client knows of, to enable the
+  // client to continue the same logical xDS session even in the face of gRPC stream reconnection.
+  // It will not be populated:
+  //
+  // * In the very first stream of a session, since the client will not yet have any resources.
+  // * In any message after the first in a stream (for a given ``type_url``), since the server will
+  //   already be correctly tracking the client's state.
+  //
+  // (In ADS, the first message ``of each type_url`` of a reconnected stream populates this map.)
+  // The map's keys are names of xDS resources known to the xDS client.
+  // The map's values are opaque resource versions.
+  map<string, string> initial_resource_versions = 5;
+
+  // When the ``DeltaDiscoveryRequest`` is a ACK or NACK message in response
+  // to a previous ``DeltaDiscoveryResponse``, the ``response_nonce`` must be the
+  // nonce in the ``DeltaDiscoveryResponse``.
+  // Otherwise (unlike in ``DiscoveryRequest``) ``response_nonce`` must be omitted.
+  string response_nonce = 6;
+
+  // This is populated when the previous :ref:`DiscoveryResponse <envoy_v3_api_msg_service.discovery.v3.DiscoveryResponse>`
+  // failed to update configuration. The ``message`` field in ``error_details``
+  // provides the Envoy internal exception related to the failure.
+  google.rpc.Status error_detail = 7;
+}
+
+// [#next-free-field: 10]
+message DeltaDiscoveryResponse {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.api.v2.DeltaDiscoveryResponse";
+
+  // The version of the response data (used for debugging).
+  string system_version_info = 1;
+
+  // The response resources. These are typed resources, whose types must match
+  // the ``type_url`` field.
+  repeated Resource resources = 2;
+
+  // field id 3 IS available!
+
+  // Type URL for resources. Identifies the xDS API when muxing over ADS.
+  // Must be consistent with the ``type_url`` in the Any within 'resources' if 'resources' is non-empty.
+  string type_url = 4;
+
+  // Resource names of resources that have been deleted and to be removed from the xDS Client.
+  // Removed resources for missing resources can be ignored.
+  repeated string removed_resources = 6;
+
+  // Alternative to ``removed_resources`` that allows specifying which variant of
+  // a resource is being removed. This variant must be used for any resource
+  // for which dynamic parameter constraints were sent to the client.
+  repeated ResourceName removed_resource_names = 8;
+
+  // The nonce provides a way for ``DeltaDiscoveryRequests`` to uniquely
+  // reference a ``DeltaDiscoveryResponse`` when (N)ACKing. The nonce is required.
+  string nonce = 5;
+
+  // [#not-implemented-hide:]
+  // The control plane instance that sent the response.
+  config.core.v3.ControlPlane control_plane = 7;
+
+  // [#not-implemented-hide:]
+  // Errors associated with specific resources.
+  //
+  // .. note::
+  //   A resource in this field with a status of NOT_FOUND should be treated the same as
+  //   a resource listed in the ``removed_resources`` or ``removed_resource_names`` fields.
+  //
+  repeated ResourceError resource_errors = 9;
+}
+
+// A set of dynamic parameter constraints associated with a variant of an individual xDS resource.
+// These constraints determine whether the resource matches a subscription based on the set of
+// dynamic parameters in the subscription, as specified in the
+// :ref:`ResourceLocator.dynamic_parameters <envoy_v3_api_field_service.discovery.v3.ResourceLocator.dynamic_parameters>`
+// field. This allows xDS implementations (clients, servers, and caching proxies) to determine
+// which variant of a resource is appropriate for a given client.
+message DynamicParameterConstraints {
+  // A single constraint for a given key.
+  message SingleConstraint {
+    message Exists {
+    }
+
+    // The key to match against.
+    string key = 1;
+
+    oneof constraint_type {
+      option (validate.required) = true;
+
+      // Matches this exact value.
+      string value = 2;
+
+      // Key is present (matches any value except for the key being absent).
+      // This allows setting a default constraint for clients that do
+      // not send a key at all, while there may be other clients that need
+      // special configuration based on that key.
+      Exists exists = 3;
+    }
+  }
+
+  message ConstraintList {
+    repeated DynamicParameterConstraints constraints = 1;
+  }
+
+  oneof type {
+    // A single constraint to evaluate.
+    SingleConstraint constraint = 1;
+
+    // A list of constraints that match if any one constraint in the list
+    // matches.
+    ConstraintList or_constraints = 2;
+
+    // A list of constraints that must all match.
+    ConstraintList and_constraints = 3;
+
+    // The inverse (NOT) of a set of constraints.
+    DynamicParameterConstraints not_constraints = 4;
+  }
+}
+
+// [#next-free-field: 10]
+message Resource {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.api.v2.Resource";
+
+  // Cache control properties for the resource.
+  // [#not-implemented-hide:]
+  message CacheControl {
+    // If true, xDS proxies may not cache this resource.
+    //
+    // .. note::
+    //   This does not apply to clients other than xDS proxies, which must cache resources
+    //   for their own use, regardless of the value of this field.
+    //
+    bool do_not_cache = 1;
+  }
+
+  // The resource's name, to distinguish it from others of the same type of resource.
+  // Only one of ``name`` or ``resource_name`` may be set.
+  string name = 3;
+
+  // Alternative to the ``name`` field, to be used when the server supports
+  // multiple variants of the named resource that are differentiated by
+  // dynamic parameter constraints.
+  // Only one of ``name`` or ``resource_name`` may be set.
+  ResourceName resource_name = 8;
+
+  // The aliases are a list of other names that this resource can go by.
+  repeated string aliases = 4;
+
+  // The resource level version. It allows xDS to track the state of individual
+  // resources.
+  string version = 1;
+
+  // The resource being tracked.
+  google.protobuf.Any resource = 2;
+
+  // Time-to-live value for the resource. For each resource, a timer is started. The timer is
+  // reset each time the resource is received with a new TTL. If the resource is received with
+  // no TTL set, the timer is removed for the resource. Upon expiration of the timer, the
+  // configuration for the resource will be removed.
+  //
+  // The TTL can be refreshed or changed by sending a response that doesn't change the resource
+  // version. In this case the ``resource`` field does not need to be populated, which allows for
+  // light-weight "heartbeat" updates to keep a resource with a TTL alive.
+  //
+  // The TTL feature is meant to support configurations that should be removed in the event of
+  // a management server failure. For example, the feature may be used for fault injection
+  // testing where the fault injection should be terminated in the event that Envoy loses contact
+  // with the management server.
+  google.protobuf.Duration ttl = 6;
+
+  // Cache control properties for the resource.
+  // [#not-implemented-hide:]
+  CacheControl cache_control = 7;
+
+  // The Metadata field can be used to provide additional information for the resource.
+  // E.g. the trace data for debugging.
+  config.core.v3.Metadata metadata = 9;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/service/load_stats/v3/lrs.proto b/xds/third_party/envoy/src/main/proto/envoy/service/load_stats/v3/lrs.proto
new file mode 100644
index 00000000000..37410628c8c
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/service/load_stats/v3/lrs.proto
@@ -0,0 +1,102 @@
+syntax = "proto3";
+
+package envoy.service.load_stats.v3;
+
+import "envoy/config/core/v3/base.proto";
+import "envoy/config/endpoint/v3/load_report.proto";
+
+import "google/protobuf/duration.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.service.load_stats.v3";
+option java_outer_classname = "LrsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/service/load_stats/v3;load_statsv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Load reporting service (LRS)]
+
+// Load Reporting Service is an Envoy API to emit load reports. Envoy will initiate a bi-directional
+// stream with a management server. Upon connecting, the management server can send a
+// :ref:`LoadStatsResponse <envoy_v3_api_msg_service.load_stats.v3.LoadStatsResponse>` to a node it is
+// interested in getting the load reports for. Envoy in this node will start sending
+// :ref:`LoadStatsRequest <envoy_v3_api_msg_service.load_stats.v3.LoadStatsRequest>`. This is done periodically
+// based on the :ref:`load reporting interval <envoy_v3_api_field_service.load_stats.v3.LoadStatsResponse.load_reporting_interval>`
+// For details, take a look at the :ref:`Load Reporting Service sandbox example <install_sandboxes_load_reporting_service>`.
+
+service LoadReportingService {
+  // Advanced API to allow for multi-dimensional load balancing by remote
+  // server. For receiving LB assignments, the steps are:
+  // 1, The management server is configured with per cluster/zone/load metric
+  //    capacity configuration. The capacity configuration definition is
+  //    outside of the scope of this document.
+  // 2. Envoy issues a standard {Stream,Fetch}Endpoints request for the clusters
+  //    to balance.
+  //
+  // Independently, Envoy will initiate a StreamLoadStats bidi stream with a
+  // management server:
+  // 1. Once a connection establishes, the management server publishes a
+  //    LoadStatsResponse for all clusters it is interested in learning load
+  //    stats about.
+  // 2. For each cluster, Envoy load balances incoming traffic to upstream hosts
+  //    based on per-zone weights and/or per-instance weights (if specified)
+  //    based on intra-zone LbPolicy. This information comes from the above
+  //    {Stream,Fetch}Endpoints.
+  // 3. When upstream hosts reply, they optionally add header <define header
+  //    name> with ASCII representation of EndpointLoadMetricStats.
+  // 4. Envoy aggregates load reports over the period of time given to it in
+  //    LoadStatsResponse.load_reporting_interval. This includes aggregation
+  //    stats Envoy maintains by itself (total_requests, rpc_errors etc.) as
+  //    well as load metrics from upstream hosts.
+  // 5. When the timer of load_reporting_interval expires, Envoy sends new
+  //    LoadStatsRequest filled with load reports for each cluster.
+  // 6. The management server uses the load reports from all reported Envoys
+  //    from around the world, computes global assignment and prepares traffic
+  //    assignment destined for each zone Envoys are located in. Goto 2.
+  rpc StreamLoadStats(stream LoadStatsRequest) returns (stream LoadStatsResponse) {
+  }
+}
+
+// A load report Envoy sends to the management server.
+message LoadStatsRequest {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.service.load_stats.v2.LoadStatsRequest";
+
+  // Node identifier for Envoy instance.
+  config.core.v3.Node node = 1;
+
+  // A list of load stats to report.
+  repeated config.endpoint.v3.ClusterStats cluster_stats = 2;
+}
+
+// The management server sends envoy a LoadStatsResponse with all clusters it
+// is interested in learning load stats about.
+message LoadStatsResponse {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.service.load_stats.v2.LoadStatsResponse";
+
+  // Clusters to report stats for.
+  // Not populated if ``send_all_clusters`` is true.
+  repeated string clusters = 1;
+
+  // If true, the client should send all clusters it knows about.
+  // Only clients that advertise the "envoy.lrs.supports_send_all_clusters" capability in their
+  // :ref:`client_features<envoy_v3_api_field_config.core.v3.Node.client_features>` field will honor this field.
+  bool send_all_clusters = 4;
+
+  // The minimum interval of time to collect stats over. This is only a minimum for two reasons:
+  //
+  // 1. There may be some delay from when the timer fires until stats sampling occurs.
+  // 2. For clusters that were already feature in the previous ``LoadStatsResponse``, any traffic
+  //    that is observed in between the corresponding previous ``LoadStatsRequest`` and this
+  //    ``LoadStatsResponse`` will also be accumulated and billed to the cluster. This avoids a period
+  //    of inobservability that might otherwise exists between the messages. New clusters are not
+  //    subject to this consideration.
+  google.protobuf.Duration load_reporting_interval = 2;
+
+  // Set to ``true`` if the management server supports endpoint granularity
+  // report.
+  bool report_endpoint_granularity = 3;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/service/rate_limit_quota/v3/rlqs.proto b/xds/third_party/envoy/src/main/proto/envoy/service/rate_limit_quota/v3/rlqs.proto
new file mode 100644
index 00000000000..b8fa2cd8982
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/service/rate_limit_quota/v3/rlqs.proto
@@ -0,0 +1,258 @@
+syntax = "proto3";
+
+package envoy.service.rate_limit_quota.v3;
+
+import "envoy/type/v3/ratelimit_strategy.proto";
+
+import "google/protobuf/duration.proto";
+
+import "xds/annotations/v3/status.proto";
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.service.rate_limit_quota.v3";
+option java_outer_classname = "RlqsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/service/rate_limit_quota/v3;rate_limit_quotav3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+option (xds.annotations.v3.file_status).work_in_progress = true;
+
+// [#protodoc-title: Rate Limit Quota Service (RLQS)]
+
+// The Rate Limit Quota Service (RLQS) is a Envoy global rate limiting service that allows to
+// delegate rate limit decisions to a remote service. The service will aggregate the usage reports
+// from multiple data plane instances, and distribute Rate Limit Assignments to each instance
+// based on its business logic. The logic is outside of the scope of the protocol API.
+//
+// The protocol is designed as a streaming-first API. It utilizes watch-like subscription model.
+// The data plane groups requests into Quota Buckets as directed by the filter config,
+// and periodically reports them to the RLQS server along with the Bucket identifier, :ref:`BucketId
+// <envoy_v3_api_msg_service.rate_limit_quota.v3.BucketId>`. Once RLQS server has collected enough
+// reports to make a decision, it'll send back the assignment with the rate limiting instructions.
+//
+// The first report sent by the data plane is interpreted by the RLQS server as a "watch" request,
+// indicating that the data plane instance is interested in receiving further updates for the
+// ``BucketId``. From then on, RLQS server may push assignments to this instance at will, even if
+// the instance is not sending usage reports. It's the responsibility of the RLQS server
+// to determine when the data plane instance didn't send ``BucketId`` reports for too long,
+// and to respond with the :ref:`AbandonAction
+// <envoy_v3_api_msg_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.AbandonAction>`,
+// indicating that the server has now stopped sending quota assignments for the ``BucketId`` bucket,
+// and the data plane instance should :ref:`abandon
+// <envoy_v3_api_field_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.abandon_action>`
+// it.
+//
+// If for any reason the RLQS client doesn't receive the initial assignment for the reported bucket,
+// in order to prevent memory exhaustion, the data plane will limit the time such bucket
+// is retained. The exact time to wait for the initial assignment is chosen by the filter,
+// and may vary based on the implementation.
+// Once the duration ends, the data plane will stop reporting bucket usage, reject any enqueued
+// requests, and purge the bucket from the memory. Subsequent requests matched into the bucket
+// will re-initialize the bucket in the "no assignment" state, restarting the reports.
+//
+// Refer to Rate Limit Quota :ref:`configuration overview <config_http_filters_rate_limit_quota>`
+// for further details.
+
+// Defines the Rate Limit Quota Service (RLQS).
+service RateLimitQuotaService {
+  // Main communication channel: the data plane sends usage reports to the RLQS server,
+  // and the server asynchronously responding with the assignments.
+  rpc StreamRateLimitQuotas(stream RateLimitQuotaUsageReports)
+      returns (stream RateLimitQuotaResponse) {
+  }
+}
+
+message RateLimitQuotaUsageReports {
+  // The usage report for a bucket.
+  //
+  // .. note::
+  //   Note that the first report sent for a ``BucketId`` indicates to the RLQS server that
+  //   the RLQS client is subscribing for the future assignments for this ``BucketId``.
+  message BucketQuotaUsage {
+    // ``BucketId`` for which request quota usage is reported.
+    BucketId bucket_id = 1 [(validate.rules).message = {required: true}];
+
+    // Time elapsed since the last report.
+    google.protobuf.Duration time_elapsed = 2 [(validate.rules).duration = {
+      required: true
+      gt {}
+    }];
+
+    // Requests the data plane has allowed through.
+    uint64 num_requests_allowed = 3;
+
+    // Requests throttled.
+    uint64 num_requests_denied = 4;
+  }
+
+  // All quota requests must specify the domain. This enables sharing the quota
+  // server between different applications without fear of overlap.
+  // E.g., "envoy".
+  //
+  // Should only be provided in the first report, all subsequent messages on the same
+  // stream are considered to be in the same domain. In case the domain needs to be
+  // changes, close the stream, and reopen a new one with the different domain.
+  string domain = 1 [(validate.rules).string = {min_len: 1}];
+
+  // A list of quota usage reports. The list is processed by the RLQS server in the same order
+  // it's provided by the client.
+  repeated BucketQuotaUsage bucket_quota_usages = 2 [(validate.rules).repeated = {min_items: 1}];
+}
+
+message RateLimitQuotaResponse {
+  // Commands the data plane to apply one of the actions to the bucket with the
+  // :ref:`bucket_id <envoy_v3_api_field_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.bucket_id>`.
+  message BucketAction {
+    // Quota assignment for the bucket. Configures the rate limiting strategy and the duration
+    // for the given :ref:`bucket_id
+    // <envoy_v3_api_field_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.bucket_id>`.
+    //
+    // **Applying the first assignment to the bucket**
+    //
+    // Once the data plane receives the ``QuotaAssignmentAction``, it must send the current usage
+    // report for the bucket, and start rate limiting requests matched into the bucket
+    // using the strategy configured in the :ref:`rate_limit_strategy
+    // <envoy_v3_api_field_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.QuotaAssignmentAction.rate_limit_strategy>`
+    // field. The assignment becomes bucket's ``active`` assignment.
+    //
+    // **Expiring the assignment**
+    //
+    // The duration of the assignment defined in the :ref:`assignment_time_to_live
+    // <envoy_v3_api_field_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.QuotaAssignmentAction.assignment_time_to_live>`
+    // field. When the duration runs off, the assignment is ``expired``, and no longer ``active``.
+    // The data plane should stop applying the rate limiting strategy to the bucket, and transition
+    // the bucket to the "expired assignment" state. This activates the behavior configured in the
+    // :ref:`expired_assignment_behavior <envoy_v3_api_field_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.expired_assignment_behavior>`
+    // field.
+    //
+    // **Replacing the assignment**
+    //
+    // * If the rate limiting strategy is different from bucket's ``active`` assignment, or
+    //   the current bucket assignment is ``expired``, the data plane must immediately
+    //   end the current assignment, report the bucket usage, and apply the new assignment.
+    //   The new assignment becomes bucket's ``active`` assignment.
+    // * If the rate limiting strategy is the same as the bucket's ``active`` (not ``expired``)
+    //   assignment, the data plane should extend the duration of the ``active`` assignment
+    //   for the duration of the new assignment provided in the :ref:`assignment_time_to_live
+    //   <envoy_v3_api_field_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.QuotaAssignmentAction.assignment_time_to_live>`
+    //   field. The ``active`` assignment is considered unchanged.
+    message QuotaAssignmentAction {
+      // A duration after which the assignment is be considered ``expired``. The process of the
+      // expiration is described :ref:`above
+      // <envoy_v3_api_msg_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.QuotaAssignmentAction>`.
+      //
+      // * If unset, the assignment has no expiration date.
+      // * If set to ``0``, the assignment expires immediately, forcing the client into the
+      //   :ref:`"expired assignment"
+      //   <envoy_v3_api_field_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.ExpiredAssignmentBehavior.expired_assignment_behavior_timeout>`
+      //   state. This may be used by the RLQS server in cases when it needs clients to proactively
+      //   fall back to the pre-configured :ref:`ExpiredAssignmentBehavior
+      //   <envoy_v3_api_msg_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.ExpiredAssignmentBehavior>`,
+      //   f.e. before the server going into restart.
+      //
+      // .. attention::
+      //   Note that :ref:`expiring
+      //   <envoy_v3_api_msg_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.QuotaAssignmentAction>`
+      //   the assignment is not the same as :ref:`abandoning
+      //   <envoy_v3_api_msg_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.AbandonAction>`
+      //   the assignment. While expiring the assignment just transitions the bucket to
+      //   the "expired assignment" state; abandoning the assignment completely erases
+      //   the bucket from the data plane memory, and stops the usage reports.
+      google.protobuf.Duration assignment_time_to_live = 2 [(validate.rules).duration = {gte {}}];
+
+      // Configures the local rate limiter for the request matched to the bucket.
+      // If not set, allow all requests.
+      type.v3.RateLimitStrategy rate_limit_strategy = 3;
+    }
+
+    // Abandon action for the bucket. Indicates that the RLQS server will no longer be
+    // sending updates for the given :ref:`bucket_id
+    // <envoy_v3_api_field_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.bucket_id>`.
+    //
+    // If no requests are reported for a bucket, after some time the server considers the bucket
+    // inactive. The server stops tracking the bucket, and instructs the the data plane to abandon
+    // the bucket via this message.
+    //
+    // **Abandoning the assignment**
+    //
+    // The data plane is to erase the bucket (including its usage data) from the memory.
+    // It should stop tracking the bucket, and stop reporting its usage. This effectively resets
+    // the data plane to the state prior to matching the first request into the bucket.
+    //
+    // **Restarting the subscription**
+    //
+    // If a new request is matched into a bucket previously abandoned, the data plane must behave
+    // as if it has never tracked the bucket, and it's the first request matched into it:
+    //
+    // 1. The process of :ref:`subscription and reporting
+    //    <envoy_v3_api_field_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.reporting_interval>`
+    //    starts from the beginning.
+    //
+    // 2. The bucket transitions to the :ref:`"no assignment"
+    //    <envoy_v3_api_field_extensions.filters.http.rate_limit_quota.v3.RateLimitQuotaBucketSettings.no_assignment_behavior>`
+    //    state.
+    //
+    // 3. Once the new assignment is received, it's applied per
+    //    "Applying the first assignment to the bucket" section of the :ref:`QuotaAssignmentAction
+    //    <envoy_v3_api_msg_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.QuotaAssignmentAction>`.
+    message AbandonAction {
+    }
+
+    // ``BucketId`` for which request the action is applied.
+    BucketId bucket_id = 1 [(validate.rules).message = {required: true}];
+
+    oneof bucket_action {
+      option (validate.required) = true;
+
+      // Apply the quota assignment to the bucket.
+      //
+      // Commands the data plane to apply a rate limiting strategy to the bucket.
+      // The process of applying and expiring the rate limiting strategy is detailed in the
+      // :ref:`QuotaAssignmentAction
+      // <envoy_v3_api_msg_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.QuotaAssignmentAction>`
+      // message.
+      QuotaAssignmentAction quota_assignment_action = 2;
+
+      // Abandon the bucket.
+      //
+      // Commands the data plane to abandon the bucket.
+      // The process of abandoning the bucket is described in the :ref:`AbandonAction
+      // <envoy_v3_api_msg_service.rate_limit_quota.v3.RateLimitQuotaResponse.BucketAction.AbandonAction>`
+      // message.
+      AbandonAction abandon_action = 3;
+    }
+  }
+
+  // An ordered list of actions to be applied to the buckets. The actions are applied in the
+  // given order, from top to bottom.
+  repeated BucketAction bucket_action = 1 [(validate.rules).repeated = {min_items: 1}];
+}
+
+// The identifier for the bucket. Used to match the bucket between the control plane (RLQS server),
+// and the data plane (RLQS client), f.e.:
+//
+// * the data plane sends a usage report for requests matched into the bucket with ``BucketId``
+//   to the control plane
+// * the control plane sends an assignment for the bucket with ``BucketId`` to the data plane
+//   Bucket ID.
+//
+// Example:
+//
+// .. validated-code-block:: yaml
+//   :type-name: envoy.service.rate_limit_quota.v3.BucketId
+//
+//   bucket:
+//     name: my_bucket
+//     env: staging
+//
+// .. note::
+//   The order of ``BucketId`` keys do not matter. Buckets ``{ a: 'A', b: 'B' }`` and
+//   ``{ b: 'B', a: 'A' }`` are identical.
+message BucketId {
+  map<string, string> bucket = 1 [(validate.rules).map = {
+    min_pairs: 1
+    keys {string {min_len: 1}}
+    values {string {min_len: 1}}
+  }];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/service/status/v3/csds.proto b/xds/third_party/envoy/src/main/proto/envoy/service/status/v3/csds.proto
new file mode 100644
index 00000000000..de62fbf9b0f
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/service/status/v3/csds.proto
@@ -0,0 +1,206 @@
+syntax = "proto3";
+
+package envoy.service.status.v3;
+
+import "envoy/admin/v3/config_dump_shared.proto";
+import "envoy/config/core/v3/base.proto";
+import "envoy/type/matcher/v3/node.proto";
+
+import "google/api/annotations.proto";
+import "google/protobuf/any.proto";
+import "google/protobuf/timestamp.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.service.status.v3";
+option java_outer_classname = "CsdsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/service/status/v3;statusv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Client status discovery service (CSDS)]
+
+// CSDS is Client Status Discovery Service. It can be used to get the status of
+// an xDS-compliant client from the management server's point of view. It can
+// also be used to get the current xDS states directly from the client.
+service ClientStatusDiscoveryService {
+  rpc StreamClientStatus(stream ClientStatusRequest) returns (stream ClientStatusResponse) {
+  }
+
+  rpc FetchClientStatus(ClientStatusRequest) returns (ClientStatusResponse) {
+    option (google.api.http).post = "/v3/discovery:client_status";
+    option (google.api.http).body = "*";
+  }
+}
+
+// Status of a config from a management server view.
+enum ConfigStatus {
+  // Status info is not available/unknown.
+  UNKNOWN = 0;
+
+  // Management server has sent the config to client and received ACK.
+  SYNCED = 1;
+
+  // Config is not sent.
+  NOT_SENT = 2;
+
+  // Management server has sent the config to client but hasn’t received
+  // ACK/NACK.
+  STALE = 3;
+
+  // Management server has sent the config to client but received NACK. The
+  // attached config dump will be the latest config (the rejected one), since
+  // it is the persisted version in the management server.
+  ERROR = 4;
+}
+
+// Config status from a client-side view.
+enum ClientConfigStatus {
+  // Config status is not available/unknown.
+  CLIENT_UNKNOWN = 0;
+
+  // Client requested the config but hasn't received any config from management
+  // server yet.
+  CLIENT_REQUESTED = 1;
+
+  // Client received the config and replied with ACK.
+  CLIENT_ACKED = 2;
+
+  // Client received the config and replied with NACK. Notably, the attached
+  // config dump is not the NACKed version, but the most recent accepted one. If
+  // no config is accepted yet, the attached config dump will be empty.
+  CLIENT_NACKED = 3;
+
+  // Client received an error from the control plane. The attached config
+  // dump is the most recent accepted one. If no config is accepted yet,
+  // the attached config dump will be empty.
+  CLIENT_RECEIVED_ERROR = 4;
+}
+
+// Request for client status of clients identified by a list of NodeMatchers.
+message ClientStatusRequest {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.service.status.v2.ClientStatusRequest";
+
+  // Management server can use these match criteria to identify clients.
+  // The match follows OR semantics.
+  repeated type.matcher.v3.NodeMatcher node_matchers = 1;
+
+  // The node making the csds request.
+  config.core.v3.Node node = 2;
+
+  // If true, the server will not include the resource contents in the response
+  // (i.e., the generic_xds_configs.xds_config field will not be populated).
+  // [#not-implemented-hide:]
+  bool exclude_resource_contents = 3;
+}
+
+// Detailed config (per xDS) with status.
+// [#next-free-field: 8]
+message PerXdsConfig {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.service.status.v2.PerXdsConfig";
+
+  // Config status generated by management servers. Will not be present if the
+  // CSDS server is an xDS client.
+  ConfigStatus status = 1;
+
+  // Client config status is populated by xDS clients. Will not be present if
+  // the CSDS server is an xDS server. No matter what the client config status
+  // is, xDS clients should always dump the most recent accepted xDS config.
+  //
+  // .. attention::
+  //   This field is deprecated. Use :ref:`ClientResourceStatus
+  //   <envoy_v3_api_enum_admin.v3.ClientResourceStatus>` for per-resource
+  //   config status instead.
+  ClientConfigStatus client_status = 7
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  oneof per_xds_config {
+    admin.v3.ListenersConfigDump listener_config = 2;
+
+    admin.v3.ClustersConfigDump cluster_config = 3;
+
+    admin.v3.RoutesConfigDump route_config = 4;
+
+    admin.v3.ScopedRoutesConfigDump scoped_route_config = 5;
+
+    admin.v3.EndpointsConfigDump endpoint_config = 6;
+  }
+}
+
+// All xds configs for a particular client.
+message ClientConfig {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.service.status.v2.ClientConfig";
+
+  // GenericXdsConfig is used to specify the config status and the dump
+  // of any xDS resource identified by their type URL. It is the generalized
+  // version of the now deprecated ListenersConfigDump, ClustersConfigDump etc
+  // [#next-free-field: 10]
+  message GenericXdsConfig {
+    // Type_url represents the fully qualified name of xDS resource type
+    // like envoy.v3.Cluster, envoy.v3.ClusterLoadAssignment etc.
+    string type_url = 1;
+
+    // Name of the xDS resource
+    string name = 2;
+
+    // This is the :ref:`version_info <envoy_v3_api_field_service.discovery.v3.DiscoveryResponse.version_info>`
+    // in the last processed xDS discovery response. If there are only
+    // static bootstrap listeners, this field will be ""
+    string version_info = 3;
+
+    // The xDS resource config. Actual content depends on the type
+    google.protobuf.Any xds_config = 4;
+
+    // Timestamp when the xDS resource was last updated
+    google.protobuf.Timestamp last_updated = 5;
+
+    // Per xDS resource config status. It is generated by management servers.
+    // It will not be present if the CSDS server is an xDS client.
+    ConfigStatus config_status = 6;
+
+    // Per xDS resource status from the view of a xDS client
+    admin.v3.ClientResourceStatus client_status = 7;
+
+    // Set if the last update failed, cleared after the next successful
+    // update. The *error_state* field contains the rejected version of
+    // this particular resource along with the reason and timestamp. For
+    // successfully updated or acknowledged resource, this field should
+    // be empty.
+    // [#not-implemented-hide:]
+    admin.v3.UpdateFailureState error_state = 8;
+
+    // Is static resource is true if it is specified in the config supplied
+    // through the file at the startup.
+    bool is_static_resource = 9;
+  }
+
+  // Node for a particular client.
+  config.core.v3.Node node = 1;
+
+  // This field is deprecated in favor of generic_xds_configs which is
+  // much simpler and uniform in structure.
+  repeated PerXdsConfig xds_config = 2
+      [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+
+  // Represents generic xDS config and the exact config structure depends on
+  // the type URL (like Cluster if it is CDS)
+  repeated GenericXdsConfig generic_xds_configs = 3;
+
+  // For xDS clients, the scope in which the data is used.
+  // For example, gRPC indicates the data plane target or that the data is
+  // associated with gRPC server(s).
+  string client_scope = 4;
+}
+
+message ClientStatusResponse {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.service.status.v2.ClientStatusResponse";
+
+  // Client configs for the clients specified in the ClientStatusRequest.
+  repeated ClientConfig config = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/http/v3/path_transformation.proto b/xds/third_party/envoy/src/main/proto/envoy/type/http/v3/path_transformation.proto
new file mode 100644
index 00000000000..2e974ca383b
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/http/v3/path_transformation.proto
@@ -0,0 +1,58 @@
+syntax = "proto3";
+
+package envoy.type.http.v3;
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.http.v3";
+option java_outer_classname = "PathTransformationProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/http/v3;httpv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Path Transformations API]
+
+// PathTransformation defines an API to apply a sequence of operations that can be used to alter
+// text before it is used for matching or routing. Multiple actions can be applied in the same
+// Transformation, forming a sequential pipeline. The transformations will be performed in the order
+// that they appear.
+//
+// This API is a work in progress.
+
+message PathTransformation {
+  // A type of operation to alter text.
+  message Operation {
+    // Should text be normalized according to RFC 3986? This typically is used for path headers
+    // before any processing of requests by HTTP filters or routing. This applies percent-encoded
+    // normalization and path segment normalization. Fails on characters disallowed in URLs
+    // (e.g. NULLs). See `Normalization and Comparison
+    // <https://tools.ietf.org/html/rfc3986#section-6>`_ for details of normalization. Note that
+    // this options does not perform `case normalization
+    // <https://tools.ietf.org/html/rfc3986#section-6.2.2.1>`_
+    message NormalizePathRFC3986 {
+    }
+
+    // Determines if adjacent slashes are merged into one. A common use case is for a request path
+    // header. Using this option in ``:ref: PathNormalizationOptions
+    // <envoy_v3_api_msg_extensions.filters.network.http_connection_manager.v3.HttpConnectionManager.PathNormalizationOptions>``
+    // will allow incoming requests with path ``//dir///file`` to match against route with ``prefix``
+    // match set to ``/dir``. When using for header transformations, note that slash merging is not
+    // part of `HTTP spec <https://tools.ietf.org/html/rfc3986>`_ and is provided for convenience.
+    message MergeSlashes {
+    }
+
+    oneof operation_specifier {
+      option (validate.required) = true;
+
+      // Enable path normalization per RFC 3986.
+      NormalizePathRFC3986 normalize_path_rfc_3986 = 2;
+
+      // Enable merging adjacent slashes.
+      MergeSlashes merge_slashes = 3;
+    }
+  }
+
+  // A list of operations to apply. Transformations will be performed in the order that they appear.
+  repeated Operation operations = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/address.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/address.proto
new file mode 100644
index 00000000000..8a03a5320af
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/address.proto
@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+package envoy.type.matcher.v3;
+
+import "xds/core/v3/cidr.proto";
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.type.matcher.v3";
+option java_outer_classname = "AddressProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3;matcherv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Address Matcher]
+
+// Match an IP against a repeated CIDR range. This matcher is intended to be
+// used in other matchers, for example in the filter state matcher to match a
+// filter state object as an IP.
+message AddressMatcher {
+  repeated xds.core.v3.CidrRange ranges = 1;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/filter_state.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/filter_state.proto
new file mode 100644
index 00000000000..8c38a515ae9
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/filter_state.proto
@@ -0,0 +1,33 @@
+syntax = "proto3";
+
+package envoy.type.matcher.v3;
+
+import "envoy/type/matcher/v3/address.proto";
+import "envoy/type/matcher/v3/string.proto";
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.matcher.v3";
+option java_outer_classname = "FilterStateProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3;matcherv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Filter state matcher]
+
+// FilterStateMatcher provides a general interface for matching the filter state objects.
+message FilterStateMatcher {
+  // The filter state key to retrieve the object.
+  string key = 1 [(validate.rules).string = {min_len: 1}];
+
+  oneof matcher {
+    option (validate.required) = true;
+
+    // Matches the filter state object as a string value.
+    StringMatcher string_match = 2;
+
+    // Matches the filter state object as a ip Instance.
+    AddressMatcher address_match = 3;
+  }
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/http_inputs.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/http_inputs.proto
new file mode 100644
index 00000000000..c90199eb618
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/http_inputs.proto
@@ -0,0 +1,71 @@
+syntax = "proto3";
+
+package envoy.type.matcher.v3;
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.matcher.v3";
+option java_outer_classname = "HttpInputsProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3;matcherv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Common HTTP inputs]
+
+// Match input indicates that matching should be done on a specific request header.
+// The resulting input string will be all headers for the given key joined by a comma,
+// e.g. if the request contains two 'foo' headers with value 'bar' and 'baz', the input
+// string will be 'bar,baz'.
+// [#comment:TODO(snowp): Link to unified matching docs.]
+// [#extension: envoy.matching.inputs.request_headers]
+message HttpRequestHeaderMatchInput {
+  // The request header to match on.
+  string header_name = 1
+      [(validate.rules).string = {well_known_regex: HTTP_HEADER_NAME strict: false}];
+}
+
+// Match input indicates that matching should be done on a specific request trailer.
+// The resulting input string will be all headers for the given key joined by a comma,
+// e.g. if the request contains two 'foo' headers with value 'bar' and 'baz', the input
+// string will be 'bar,baz'.
+// [#comment:TODO(snowp): Link to unified matching docs.]
+// [#extension: envoy.matching.inputs.request_trailers]
+message HttpRequestTrailerMatchInput {
+  // The request trailer to match on.
+  string header_name = 1
+      [(validate.rules).string = {well_known_regex: HTTP_HEADER_NAME strict: false}];
+}
+
+// Match input indicating that matching should be done on a specific response header.
+// The resulting input string will be all headers for the given key joined by a comma,
+// e.g. if the response contains two 'foo' headers with value 'bar' and 'baz', the input
+// string will be 'bar,baz'.
+// [#comment:TODO(snowp): Link to unified matching docs.]
+// [#extension: envoy.matching.inputs.response_headers]
+message HttpResponseHeaderMatchInput {
+  // The response header to match on.
+  string header_name = 1
+      [(validate.rules).string = {well_known_regex: HTTP_HEADER_NAME strict: false}];
+}
+
+// Match input indicates that matching should be done on a specific response trailer.
+// The resulting input string will be all headers for the given key joined by a comma,
+// e.g. if the request contains two 'foo' headers with value 'bar' and 'baz', the input
+// string will be 'bar,baz'.
+// [#comment:TODO(snowp): Link to unified matching docs.]
+// [#extension: envoy.matching.inputs.response_trailers]
+message HttpResponseTrailerMatchInput {
+  // The response trailer to match on.
+  string header_name = 1
+      [(validate.rules).string = {well_known_regex: HTTP_HEADER_NAME strict: false}];
+}
+
+// Match input indicates that matching should be done on a specific query parameter.
+// The resulting input string will be the first query parameter for the value
+// 'query_param'.
+// [#extension: envoy.matching.inputs.query_params]
+message HttpRequestQueryParamMatchInput {
+  // The query parameter to match on.
+  string query_param = 1 [(validate.rules).string = {min_len: 1}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/metadata.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/metadata.proto
new file mode 100644
index 00000000000..30abde97c09
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/metadata.proto
@@ -0,0 +1,110 @@
+syntax = "proto3";
+
+package envoy.type.matcher.v3;
+
+import "envoy/type/matcher/v3/value.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.matcher.v3";
+option java_outer_classname = "MetadataProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3;matcherv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Metadata matcher]
+
+// ``MetadataMatcher`` provides a general interface to check if a given value is matched in
+// :ref:`Metadata <envoy_v3_api_msg_config.core.v3.Metadata>`. It uses ``filter`` and ``path`` to retrieve the value
+// from the ``Metadata`` and then check if it's matched to the specified value.
+//
+// For example, for the following ``Metadata``:
+//
+// .. code-block:: yaml
+//
+//    filter_metadata:
+//      envoy.filters.http.rbac:
+//        fields:
+//          a:
+//            struct_value:
+//              fields:
+//                b:
+//                  struct_value:
+//                    fields:
+//                      c:
+//                        string_value: pro
+//                t:
+//                  list_value:
+//                    values:
+//                      - string_value: m
+//                      - string_value: n
+//
+// The following ``MetadataMatcher`` is matched as the path ``[a, b, c]`` will retrieve a string value ``pro``
+// from the ``Metadata`` which is matched to the specified prefix match.
+//
+// .. code-block:: yaml
+//
+//    filter: envoy.filters.http.rbac
+//    path:
+//    - key: a
+//    - key: b
+//    - key: c
+//    value:
+//      string_match:
+//        prefix: pr
+//
+// The following ``MetadataMatcher`` is matched as the code will match one of the string values in the
+// list at the path [a, t].
+//
+// .. code-block:: yaml
+//
+//    filter: envoy.filters.http.rbac
+//    path:
+//    - key: a
+//    - key: t
+//    value:
+//      list_match:
+//        one_of:
+//          string_match:
+//            exact: m
+//
+// An example use of ``MetadataMatcher`` is specifying additional metadata in ``envoy.filters.http.rbac`` to
+// enforce access control based on dynamic metadata in a request. See :ref:`Permission
+// <envoy_v3_api_msg_config.rbac.v3.Permission>` and :ref:`Principal
+// <envoy_v3_api_msg_config.rbac.v3.Principal>`.
+
+// [#next-major-version: MetadataMatcher should use StructMatcher]
+message MetadataMatcher {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.matcher.MetadataMatcher";
+
+  // Specifies the segment in a path to retrieve value from ``Metadata``.
+  //
+  // .. note::
+  //   Currently it's not supported to retrieve a value from a list in ``Metadata``. This means that
+  //   if the segment key refers to a list, it has to be the last segment in a path.
+  message PathSegment {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.type.matcher.MetadataMatcher.PathSegment";
+
+    oneof segment {
+      option (validate.required) = true;
+
+      // If specified, use the key to retrieve the value in a ``Struct``.
+      string key = 1 [(validate.rules).string = {min_len: 1}];
+    }
+  }
+
+  // The filter name to retrieve the ``Struct`` from the ``Metadata``.
+  string filter = 1 [(validate.rules).string = {min_len: 1}];
+
+  // The path to retrieve the ``Value`` from the ``Struct``.
+  repeated PathSegment path = 2 [(validate.rules).repeated = {min_items: 1}];
+
+  // The ``MetadataMatcher`` is matched if the value retrieved by path is matched to this value.
+  ValueMatcher value = 3 [(validate.rules).message = {required: true}];
+
+  // If true, the match result will be inverted.
+  bool invert = 4;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/node.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/node.proto
new file mode 100644
index 00000000000..baa92fb6035
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/node.proto
@@ -0,0 +1,29 @@
+syntax = "proto3";
+
+package envoy.type.matcher.v3;
+
+import "envoy/type/matcher/v3/string.proto";
+import "envoy/type/matcher/v3/struct.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.type.matcher.v3";
+option java_outer_classname = "NodeProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3;matcherv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Node matcher]
+
+// Specifies the way to match a Node.
+// The match follows AND semantics.
+message NodeMatcher {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.matcher.NodeMatcher";
+
+  // Specifies match criteria on the node id.
+  StringMatcher node_id = 1;
+
+  // Specifies match criteria on the node metadata.
+  repeated StructMatcher node_metadatas = 2;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/number.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/number.proto
new file mode 100644
index 00000000000..99681c989ca
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/number.proto
@@ -0,0 +1,33 @@
+syntax = "proto3";
+
+package envoy.type.matcher.v3;
+
+import "envoy/type/v3/range.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.matcher.v3";
+option java_outer_classname = "NumberProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3;matcherv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Number matcher]
+
+// Specifies the way to match a double value.
+message DoubleMatcher {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.matcher.DoubleMatcher";
+
+  oneof match_pattern {
+    option (validate.required) = true;
+
+    // If specified, the input double value must be in the range specified here.
+    // Note: The range is using half-open interval semantics [start, end).
+    type.v3.DoubleRange range = 1;
+
+    // If specified, the input double value must be equal to the value specified here.
+    double exact = 2;
+  }
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/path.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/path.proto
new file mode 100644
index 00000000000..46b758e22ef
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/path.proto
@@ -0,0 +1,31 @@
+syntax = "proto3";
+
+package envoy.type.matcher.v3;
+
+import "envoy/type/matcher/v3/string.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.matcher.v3";
+option java_outer_classname = "PathProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3;matcherv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Path matcher]
+
+// Specifies the way to match a path on HTTP request.
+message PathMatcher {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.matcher.PathMatcher";
+
+  oneof rule {
+    option (validate.required) = true;
+
+    // The ``path`` must match the URL path portion of the :path header. The query and fragment
+    // string (if present) are removed in the URL path portion.
+    // For example, the path ``/data`` will match the ``:path`` header ``/data#fragment?param=value``.
+    StringMatcher path = 1 [(validate.rules).message = {required: true}];
+  }
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/regex.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/regex.proto
new file mode 100644
index 00000000000..10b3970ff84
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/regex.proto
@@ -0,0 +1,97 @@
+syntax = "proto3";
+
+package envoy.type.matcher.v3;
+
+import "google/protobuf/wrappers.proto";
+
+import "envoy/annotations/deprecation.proto";
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.matcher.v3";
+option java_outer_classname = "RegexProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3;matcherv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Regex matcher]
+
+// A regex matcher designed for safety when used with untrusted input.
+message RegexMatcher {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.matcher.RegexMatcher";
+
+  // Google's `RE2 <https://github.com/google/re2>`_ regex engine. The regex string must adhere to
+  // the documented `syntax <https://github.com/google/re2/wiki/Syntax>`_. The engine is designed
+  // to complete execution in linear time as well as limit the amount of memory used.
+  //
+  // Envoy supports program size checking via runtime. The runtime keys ``re2.max_program_size.error_level``
+  // and ``re2.max_program_size.warn_level`` can be set to integers as the maximum program size or
+  // complexity that a compiled regex can have before an exception is thrown or a warning is
+  // logged, respectively. ``re2.max_program_size.error_level`` defaults to 100, and
+  // ``re2.max_program_size.warn_level`` has no default if unset (will not check/log a warning).
+  //
+  // Envoy emits two stats for tracking the program size of regexes: the histogram ``re2.program_size``,
+  // which records the program size, and the counter ``re2.exceeded_warn_level``, which is incremented
+  // each time the program size exceeds the warn level threshold.
+  message GoogleRE2 {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.type.matcher.RegexMatcher.GoogleRE2";
+
+    // This field controls the RE2 "program size" which is a rough estimate of how complex a
+    // compiled regex is to evaluate. A regex that has a program size greater than the configured
+    // value will fail to compile. In this case, the configured max program size can be increased
+    // or the regex can be simplified. If not specified, the default is 100.
+    //
+    // This field is deprecated; regexp validation should be performed on the management server
+    // instead of being done by each individual client.
+    //
+    // .. note::
+    //
+    //  Although this field is deprecated, the program size will still be checked against the
+    //  global ``re2.max_program_size.error_level`` runtime value.
+    //
+    google.protobuf.UInt32Value max_program_size = 1
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+  }
+
+  oneof engine_type {
+    // Google's RE2 regex engine.
+    GoogleRE2 google_re2 = 1
+        [deprecated = true, (envoy.annotations.deprecated_at_minor_version) = "3.0"];
+  }
+
+  // The regex match string. The string must be supported by the configured engine. The regex is matched
+  // against the full string, not as a partial match.
+  string regex = 2 [(validate.rules).string = {min_len: 1}];
+}
+
+// Describes how to match a string and then produce a new string using a regular
+// expression and a substitution string.
+message RegexMatchAndSubstitute {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.type.matcher.RegexMatchAndSubstitute";
+
+  // The regular expression used to find portions of a string (hereafter called
+  // the "subject string") that should be replaced. When a new string is
+  // produced during the substitution operation, the new string is initially
+  // the same as the subject string, but then all matches in the subject string
+  // are replaced by the substitution string. If replacing all matches isn't
+  // desired, regular expression anchors can be used to ensure a single match,
+  // so as to replace just one occurrence of a pattern. Capture groups can be
+  // used in the pattern to extract portions of the subject string, and then
+  // referenced in the substitution string.
+  RegexMatcher pattern = 1 [(validate.rules).message = {required: true}];
+
+  // The string that should be substituted into matching portions of the
+  // subject string during a substitution operation to produce a new string.
+  // Capture groups in the pattern can be referenced in the substitution
+  // string. Note, however, that the syntax for referring to capture groups is
+  // defined by the chosen regular expression engine. Google's `RE2
+  // <https://github.com/google/re2>`_ regular expression engine uses a
+  // backslash followed by the capture group number to denote a numbered
+  // capture group. E.g., ``\1`` refers to capture group 1, and ``\2`` refers
+  // to capture group 2.
+  string substitution = 2
+      [(validate.rules).string = {well_known_regex: HTTP_HEADER_VALUE strict: false}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/string.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/string.proto
new file mode 100644
index 00000000000..56d39565ca5
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/string.proto
@@ -0,0 +1,94 @@
+syntax = "proto3";
+
+package envoy.type.matcher.v3;
+
+import "envoy/type/matcher/v3/regex.proto";
+
+import "xds/core/v3/extension.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.matcher.v3";
+option java_outer_classname = "StringProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3;matcherv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: String matcher]
+
+// Specifies the way to match a string.
+// [#next-free-field: 9]
+message StringMatcher {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.matcher.StringMatcher";
+
+  reserved 4;
+
+  reserved "regex";
+
+  oneof match_pattern {
+    option (validate.required) = true;
+
+    // The input string must match exactly the string specified here.
+    //
+    // Examples:
+    //
+    // * ``abc`` only matches the value ``abc``.
+    string exact = 1;
+
+    // The input string must have the prefix specified here.
+    //
+    // .. note::
+    //
+    //  Empty prefix match is not allowed, please use ``safe_regex`` instead.
+    //
+    // Examples:
+    //
+    // * ``abc`` matches the value ``abc.xyz``
+    string prefix = 2 [(validate.rules).string = {min_len: 1}];
+
+    // The input string must have the suffix specified here.
+    //
+    // .. note::
+    //
+    //  Empty suffix match is not allowed, please use ``safe_regex`` instead.
+    //
+    // Examples:
+    //
+    // * ``abc`` matches the value ``xyz.abc``
+    string suffix = 3 [(validate.rules).string = {min_len: 1}];
+
+    // The input string must match the regular expression specified here.
+    RegexMatcher safe_regex = 5 [(validate.rules).message = {required: true}];
+
+    // The input string must have the substring specified here.
+    //
+    // .. note::
+    //
+    //  Empty contains match is not allowed, please use ``safe_regex`` instead.
+    //
+    // Examples:
+    //
+    // * ``abc`` matches the value ``xyz.abc.def``
+    string contains = 7 [(validate.rules).string = {min_len: 1}];
+
+    // Use an extension as the matcher type.
+    // [#extension-category: envoy.string_matcher]
+    xds.core.v3.TypedExtensionConfig custom = 8;
+  }
+
+  // If ``true``, indicates the exact/prefix/suffix/contains matching should be case insensitive. This
+  // has no effect for the ``safe_regex`` match.
+  // For example, the matcher ``data`` will match both input string ``Data`` and ``data`` if this option
+  // is set to ``true``.
+  bool ignore_case = 6;
+}
+
+// Specifies a list of ways to match a string.
+message ListStringMatcher {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.type.matcher.ListStringMatcher";
+
+  repeated StringMatcher patterns = 1 [(validate.rules).repeated = {min_items: 1}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/struct.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/struct.proto
new file mode 100644
index 00000000000..1b963343b30
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/struct.proto
@@ -0,0 +1,91 @@
+syntax = "proto3";
+
+package envoy.type.matcher.v3;
+
+import "envoy/type/matcher/v3/value.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.matcher.v3";
+option java_outer_classname = "StructProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3;matcherv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Struct matcher]
+
+// StructMatcher provides a general interface to check if a given value is matched in
+// google.protobuf.Struct. It uses ``path`` to retrieve the value
+// from the struct and then check if it's matched to the specified value.
+//
+// For example, for the following Struct:
+//
+// .. code-block:: yaml
+//
+//        fields:
+//          a:
+//            struct_value:
+//              fields:
+//                b:
+//                  struct_value:
+//                    fields:
+//                      c:
+//                        string_value: pro
+//                t:
+//                  list_value:
+//                    values:
+//                      - string_value: m
+//                      - string_value: n
+//
+// The following MetadataMatcher is matched as the path [a, b, c] will retrieve a string value "pro"
+// from the Metadata which is matched to the specified prefix match.
+//
+// .. code-block:: yaml
+//
+//    path:
+//    - key: a
+//    - key: b
+//    - key: c
+//    value:
+//      string_match:
+//        prefix: pr
+//
+// The following StructMatcher is matched as the code will match one of the string values in the
+// list at the path [a, t].
+//
+// .. code-block:: yaml
+//
+//    path:
+//    - key: a
+//    - key: t
+//    value:
+//      list_match:
+//        one_of:
+//          string_match:
+//            exact: m
+//
+// An example use of StructMatcher is to match metadata in envoy.v*.core.Node.
+message StructMatcher {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.matcher.StructMatcher";
+
+  // Specifies the segment in a path to retrieve value from Struct.
+  message PathSegment {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.type.matcher.StructMatcher.PathSegment";
+
+    oneof segment {
+      option (validate.required) = true;
+
+      // If specified, use the key to retrieve the value in a Struct.
+      string key = 1 [(validate.rules).string = {min_len: 1}];
+    }
+  }
+
+  // The path to retrieve the Value from the Struct.
+  repeated PathSegment path = 2 [(validate.rules).repeated = {min_items: 1}];
+
+  // The StructMatcher is matched if the value retrieved by path is matched to this value.
+  ValueMatcher value = 3 [(validate.rules).message = {required: true}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/value.proto b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/value.proto
new file mode 100644
index 00000000000..8d65c457ccc
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/matcher/v3/value.proto
@@ -0,0 +1,80 @@
+syntax = "proto3";
+
+package envoy.type.matcher.v3;
+
+import "envoy/type/matcher/v3/number.proto";
+import "envoy/type/matcher/v3/string.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.matcher.v3";
+option java_outer_classname = "ValueProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/matcher/v3;matcherv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Value matcher]
+
+// Specifies the way to match a Protobuf::Value. Primitive values and ListValue are supported.
+// StructValue is not supported and is always not matched.
+// [#next-free-field: 8]
+message ValueMatcher {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.matcher.ValueMatcher";
+
+  // NullMatch is an empty message to specify a null value.
+  message NullMatch {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.type.matcher.ValueMatcher.NullMatch";
+  }
+
+  // Specifies how to match a value.
+  oneof match_pattern {
+    option (validate.required) = true;
+
+    // If specified, a match occurs if and only if the target value is a NullValue.
+    NullMatch null_match = 1;
+
+    // If specified, a match occurs if and only if the target value is a double value and is
+    // matched to this field.
+    DoubleMatcher double_match = 2;
+
+    // If specified, a match occurs if and only if the target value is a string value and is
+    // matched to this field.
+    StringMatcher string_match = 3;
+
+    // If specified, a match occurs if and only if the target value is a bool value and is equal
+    // to this field.
+    bool bool_match = 4;
+
+    // If specified, value match will be performed based on whether the path is referring to a
+    // valid primitive value in the metadata. If the path is referring to a non-primitive value,
+    // the result is always not matched.
+    bool present_match = 5;
+
+    // If specified, a match occurs if and only if the target value is a list value and
+    // is matched to this field.
+    ListMatcher list_match = 6;
+
+    // If specified, a match occurs if and only if any of the alternatives in the match accept the value.
+    OrMatcher or_match = 7;
+  }
+}
+
+// Specifies the way to match a list value.
+message ListMatcher {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.matcher.ListMatcher";
+
+  oneof match_pattern {
+    option (validate.required) = true;
+
+    // If specified, at least one of the values in the list must match the value specified.
+    ValueMatcher one_of = 1;
+  }
+}
+
+// Specifies a list of alternatives for the match.
+message OrMatcher {
+  repeated ValueMatcher value_matchers = 1 [(validate.rules).repeated = {min_items: 2}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/metadata/v3/metadata.proto b/xds/third_party/envoy/src/main/proto/envoy/type/metadata/v3/metadata.proto
new file mode 100644
index 00000000000..d131635bf9f
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/metadata/v3/metadata.proto
@@ -0,0 +1,117 @@
+syntax = "proto3";
+
+package envoy.type.metadata.v3;
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.metadata.v3";
+option java_outer_classname = "MetadataProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/metadata/v3;metadatav3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Metadata]
+
+// MetadataKey provides a way to retrieve values from
+// :ref:`Metadata <envoy_v3_api_msg_config.core.v3.Metadata>` using a ``key`` and a ``path``.
+//
+// For example, consider the following Metadata:
+//
+// .. code-block:: yaml
+//
+//    filter_metadata:
+//      envoy.xxx:
+//        prop:
+//          foo: bar
+//          xyz:
+//            hello: envoy
+//
+// The following MetadataKey would retrieve the string value "bar" from the Metadata:
+//
+// .. code-block:: yaml
+//
+//    key: envoy.xxx
+//    path:
+//    - key: prop
+//    - key: foo
+//
+message MetadataKey {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.metadata.v2.MetadataKey";
+
+  // Specifies a segment in a path for retrieving values from Metadata.
+  // Currently, only key-based segments (field names) are supported.
+  message PathSegment {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.type.metadata.v2.MetadataKey.PathSegment";
+
+    oneof segment {
+      option (validate.required) = true;
+
+      // If specified, use this key to retrieve the value in a Struct.
+      string key = 1 [(validate.rules).string = {min_len: 1}];
+    }
+  }
+
+  // The key name of the Metadata from which to retrieve the Struct.
+  // This typically represents a builtin subsystem or custom extension.
+  string key = 1 [(validate.rules).string = {min_len: 1}];
+
+  // The path used to retrieve a specific Value from the Struct.
+  // This can be either a prefix or a full path, depending on the use case.
+  // For example, ``[prop, xyz]`` would retrieve a struct or ``[prop, foo]`` would retrieve a string
+  // in the example above.
+  //
+  // .. note::
+  //   Since only key-type segments are supported, a path cannot specify a list
+  //   unless the list is the last segment.
+  repeated PathSegment path = 2 [(validate.rules).repeated = {min_items: 1}];
+}
+
+// Describes different types of metadata sources.
+message MetadataKind {
+  option (udpa.annotations.versioning).previous_message_type =
+      "envoy.type.metadata.v2.MetadataKind";
+
+  // Represents dynamic metadata associated with the request.
+  message Request {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.type.metadata.v2.MetadataKind.Request";
+  }
+
+  // Represents metadata from :ref:`the route<envoy_v3_api_field_config.route.v3.Route.metadata>`.
+  message Route {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.type.metadata.v2.MetadataKind.Route";
+  }
+
+  // Represents metadata from :ref:`the upstream cluster<envoy_v3_api_field_config.cluster.v3.Cluster.metadata>`.
+  message Cluster {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.type.metadata.v2.MetadataKind.Cluster";
+  }
+
+  // Represents metadata from :ref:`the upstream
+  // host<envoy_v3_api_field_config.endpoint.v3.LbEndpoint.metadata>`.
+  message Host {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.type.metadata.v2.MetadataKind.Host";
+  }
+
+  oneof kind {
+    option (validate.required) = true;
+
+    // Request kind of metadata.
+    Request request = 1;
+
+    // Route kind of metadata.
+    Route route = 2;
+
+    // Cluster kind of metadata.
+    Cluster cluster = 3;
+
+    // Host kind of metadata.
+    Host host = 4;
+  }
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/tracing/v3/custom_tag.proto b/xds/third_party/envoy/src/main/proto/envoy/type/tracing/v3/custom_tag.proto
new file mode 100644
index 00000000000..feb57e8eb66
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/tracing/v3/custom_tag.proto
@@ -0,0 +1,102 @@
+syntax = "proto3";
+
+package envoy.type.tracing.v3;
+
+import "envoy/type/metadata/v3/metadata.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.tracing.v3";
+option java_outer_classname = "CustomTagProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/tracing/v3;tracingv3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Custom Tag]
+
+// Describes custom tags for the active span.
+// [#next-free-field: 6]
+message CustomTag {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.tracing.v2.CustomTag";
+
+  // Literal type custom tag with static value for the tag value.
+  message Literal {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.type.tracing.v2.CustomTag.Literal";
+
+    // Static literal value to populate the tag value.
+    string value = 1 [(validate.rules).string = {min_len: 1}];
+  }
+
+  // Environment type custom tag with environment name and default value.
+  message Environment {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.type.tracing.v2.CustomTag.Environment";
+
+    // Environment variable name to obtain the value to populate the tag value.
+    string name = 1 [(validate.rules).string = {min_len: 1}];
+
+    // When the environment variable is not found,
+    // the tag value will be populated with this default value if specified,
+    // otherwise no tag will be populated.
+    string default_value = 2;
+  }
+
+  // Header type custom tag with header name and default value.
+  message Header {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.type.tracing.v2.CustomTag.Header";
+
+    // Header name to obtain the value to populate the tag value.
+    string name = 1
+        [(validate.rules).string = {min_len: 1 well_known_regex: HTTP_HEADER_NAME strict: false}];
+
+    // When the header does not exist,
+    // the tag value will be populated with this default value if specified,
+    // otherwise no tag will be populated.
+    string default_value = 2;
+  }
+
+  // Metadata type custom tag using
+  // :ref:`MetadataKey <envoy_v3_api_msg_type.metadata.v3.MetadataKey>` to retrieve the protobuf value
+  // from :ref:`Metadata <envoy_v3_api_msg_config.core.v3.Metadata>`, and populate the tag value with
+  // `the canonical JSON <https://developers.google.com/protocol-buffers/docs/proto3#json>`_
+  // representation of it.
+  message Metadata {
+    option (udpa.annotations.versioning).previous_message_type =
+        "envoy.type.tracing.v2.CustomTag.Metadata";
+
+    // Specify what kind of metadata to obtain tag value from.
+    metadata.v3.MetadataKind kind = 1;
+
+    // Metadata key to define the path to retrieve the tag value.
+    metadata.v3.MetadataKey metadata_key = 2;
+
+    // When no valid metadata is found,
+    // the tag value would be populated with this default value if specified,
+    // otherwise no tag would be populated.
+    string default_value = 3;
+  }
+
+  // Used to populate the tag name.
+  string tag = 1 [(validate.rules).string = {min_len: 1}];
+
+  // Used to specify what kind of custom tag.
+  oneof type {
+    option (validate.required) = true;
+
+    // A literal custom tag.
+    Literal literal = 2;
+
+    // An environment custom tag.
+    Environment environment = 3;
+
+    // A request header custom tag.
+    Header request_header = 4;
+
+    // A custom tag to obtain tag value from the metadata.
+    Metadata metadata = 5;
+  }
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/v3/http.proto b/xds/third_party/envoy/src/main/proto/envoy/type/v3/http.proto
new file mode 100644
index 00000000000..a1a5a04fc87
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/v3/http.proto
@@ -0,0 +1,24 @@
+syntax = "proto3";
+
+package envoy.type.v3;
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.type.v3";
+option java_outer_classname = "HttpProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/v3;typev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: HTTP]
+
+enum CodecClientType {
+  HTTP1 = 0;
+
+  HTTP2 = 1;
+
+  // [#not-implemented-hide:] QUIC implementation is not production ready yet. Use this enum with
+  // caution to prevent accidental execution of QUIC code. I.e. `!= HTTP2` is no longer sufficient
+  // to distinguish HTTP1 and HTTP2 traffic.
+  HTTP3 = 2;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/v3/http_status.proto b/xds/third_party/envoy/src/main/proto/envoy/type/v3/http_status.proto
new file mode 100644
index 00000000000..40d697beefc
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/v3/http_status.proto
@@ -0,0 +1,199 @@
+syntax = "proto3";
+
+package envoy.type.v3;
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.v3";
+option java_outer_classname = "HttpStatusProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/v3;typev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: HTTP status codes]
+
+// HTTP response codes supported in Envoy.
+// For more details: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+enum StatusCode {
+  // Empty - This code not part of the HTTP status code specification, but it is needed for proto
+  // `enum` type.
+  Empty = 0;
+
+  // Continue - ``100`` status code.
+  Continue = 100;
+
+  // OK - ``200`` status code.
+  OK = 200;
+
+  // Created - ``201`` status code.
+  Created = 201;
+
+  // Accepted - ``202`` status code.
+  Accepted = 202;
+
+  // NonAuthoritativeInformation - ``203`` status code.
+  NonAuthoritativeInformation = 203;
+
+  // NoContent - ``204`` status code.
+  NoContent = 204;
+
+  // ResetContent - ``205`` status code.
+  ResetContent = 205;
+
+  // PartialContent - ``206`` status code.
+  PartialContent = 206;
+
+  // MultiStatus - ``207`` status code.
+  MultiStatus = 207;
+
+  // AlreadyReported - ``208`` status code.
+  AlreadyReported = 208;
+
+  // IMUsed - ``226`` status code.
+  IMUsed = 226;
+
+  // MultipleChoices - ``300`` status code.
+  MultipleChoices = 300;
+
+  // MovedPermanently - ``301`` status code.
+  MovedPermanently = 301;
+
+  // Found - ``302`` status code.
+  Found = 302;
+
+  // SeeOther - ``303`` status code.
+  SeeOther = 303;
+
+  // NotModified - ``304`` status code.
+  NotModified = 304;
+
+  // UseProxy - ``305`` status code.
+  UseProxy = 305;
+
+  // TemporaryRedirect - ``307`` status code.
+  TemporaryRedirect = 307;
+
+  // PermanentRedirect - ``308`` status code.
+  PermanentRedirect = 308;
+
+  // BadRequest - ``400`` status code.
+  BadRequest = 400;
+
+  // Unauthorized - ``401`` status code.
+  Unauthorized = 401;
+
+  // PaymentRequired - ``402`` status code.
+  PaymentRequired = 402;
+
+  // Forbidden - ``403`` status code.
+  Forbidden = 403;
+
+  // NotFound - ``404`` status code.
+  NotFound = 404;
+
+  // MethodNotAllowed - ``405`` status code.
+  MethodNotAllowed = 405;
+
+  // NotAcceptable - ``406`` status code.
+  NotAcceptable = 406;
+
+  // ProxyAuthenticationRequired - ``407`` status code.
+  ProxyAuthenticationRequired = 407;
+
+  // RequestTimeout - ``408`` status code.
+  RequestTimeout = 408;
+
+  // Conflict - ``409`` status code.
+  Conflict = 409;
+
+  // Gone - ``410`` status code.
+  Gone = 410;
+
+  // LengthRequired - ``411`` status code.
+  LengthRequired = 411;
+
+  // PreconditionFailed - ``412`` status code.
+  PreconditionFailed = 412;
+
+  // PayloadTooLarge - ``413`` status code.
+  PayloadTooLarge = 413;
+
+  // URITooLong - ``414`` status code.
+  URITooLong = 414;
+
+  // UnsupportedMediaType - ``415`` status code.
+  UnsupportedMediaType = 415;
+
+  // RangeNotSatisfiable - ``416`` status code.
+  RangeNotSatisfiable = 416;
+
+  // ExpectationFailed - ``417`` status code.
+  ExpectationFailed = 417;
+
+  // MisdirectedRequest - ``421`` status code.
+  MisdirectedRequest = 421;
+
+  // UnprocessableEntity - ``422`` status code.
+  UnprocessableEntity = 422;
+
+  // Locked - ``423`` status code.
+  Locked = 423;
+
+  // FailedDependency - ``424`` status code.
+  FailedDependency = 424;
+
+  // UpgradeRequired - ``426`` status code.
+  UpgradeRequired = 426;
+
+  // PreconditionRequired - ``428`` status code.
+  PreconditionRequired = 428;
+
+  // TooManyRequests - ``429`` status code.
+  TooManyRequests = 429;
+
+  // RequestHeaderFieldsTooLarge - ``431`` status code.
+  RequestHeaderFieldsTooLarge = 431;
+
+  // InternalServerError - ``500`` status code.
+  InternalServerError = 500;
+
+  // NotImplemented - ``501`` status code.
+  NotImplemented = 501;
+
+  // BadGateway - ``502`` status code.
+  BadGateway = 502;
+
+  // ServiceUnavailable - ``503`` status code.
+  ServiceUnavailable = 503;
+
+  // GatewayTimeout - ``504`` status code.
+  GatewayTimeout = 504;
+
+  // HTTPVersionNotSupported - ``505`` status code.
+  HTTPVersionNotSupported = 505;
+
+  // VariantAlsoNegotiates - ``506`` status code.
+  VariantAlsoNegotiates = 506;
+
+  // InsufficientStorage - ``507`` status code.
+  InsufficientStorage = 507;
+
+  // LoopDetected - ``508`` status code.
+  LoopDetected = 508;
+
+  // NotExtended - ``510`` status code.
+  NotExtended = 510;
+
+  // NetworkAuthenticationRequired - ``511`` status code.
+  NetworkAuthenticationRequired = 511;
+}
+
+// HTTP status.
+message HttpStatus {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.HttpStatus";
+
+  // Supplies HTTP response code.
+  StatusCode code = 1 [(validate.rules).enum = {defined_only: true not_in: 0}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/v3/percent.proto b/xds/third_party/envoy/src/main/proto/envoy/type/v3/percent.proto
new file mode 100644
index 00000000000..e041ecddc78
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/v3/percent.proto
@@ -0,0 +1,57 @@
+syntax = "proto3";
+
+package envoy.type.v3;
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.v3";
+option java_outer_classname = "PercentProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/v3;typev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Percent]
+
+// Identifies a percentage, in the range [0.0, 100.0].
+message Percent {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.Percent";
+
+  double value = 1 [(validate.rules).double = {lte: 100.0 gte: 0.0}];
+}
+
+// A fractional percentage is used in cases in which for performance reasons performing floating
+// point to integer conversions during randomness calculations is undesirable. The message includes
+// both a numerator and denominator that together determine the final fractional value.
+//
+// * **Example**: 1/100 = 1%.
+// * **Example**: 3/10000 = 0.03%.
+message FractionalPercent {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.FractionalPercent";
+
+  // Fraction percentages support several fixed denominator values.
+  enum DenominatorType {
+    // 100.
+    //
+    // **Example**: 1/100 = 1%.
+    HUNDRED = 0;
+
+    // 10,000.
+    //
+    // **Example**: 1/10000 = 0.01%.
+    TEN_THOUSAND = 1;
+
+    // 1,000,000.
+    //
+    // **Example**: 1/1000000 = 0.0001%.
+    MILLION = 2;
+  }
+
+  // Specifies the numerator. Defaults to 0.
+  uint32 numerator = 1;
+
+  // Specifies the denominator. If the denominator specified is less than the numerator, the final
+  // fractional percentage is capped at 1 (100%).
+  DenominatorType denominator = 2 [(validate.rules).enum = {defined_only: true}];
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/v3/range.proto b/xds/third_party/envoy/src/main/proto/envoy/type/v3/range.proto
new file mode 100644
index 00000000000..3b1af814858
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/v3/range.proto
@@ -0,0 +1,50 @@
+syntax = "proto3";
+
+package envoy.type.v3;
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.type.v3";
+option java_outer_classname = "RangeProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/v3;typev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Range]
+
+// Specifies the int64 start and end of the range using half-open interval semantics [start,
+// end).
+message Int64Range {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.Int64Range";
+
+  // start of the range (inclusive)
+  int64 start = 1;
+
+  // end of the range (exclusive)
+  int64 end = 2;
+}
+
+// Specifies the int32 start and end of the range using half-open interval semantics [start,
+// end).
+message Int32Range {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.Int32Range";
+
+  // start of the range (inclusive)
+  int32 start = 1;
+
+  // end of the range (exclusive)
+  int32 end = 2;
+}
+
+// Specifies the double start and end of the range using half-open interval semantics [start,
+// end).
+message DoubleRange {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.DoubleRange";
+
+  // start of the range (inclusive)
+  double start = 1;
+
+  // end of the range (exclusive)
+  double end = 2;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/v3/ratelimit_strategy.proto b/xds/third_party/envoy/src/main/proto/envoy/type/v3/ratelimit_strategy.proto
new file mode 100644
index 00000000000..a86da55b854
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/v3/ratelimit_strategy.proto
@@ -0,0 +1,79 @@
+syntax = "proto3";
+
+package envoy.type.v3;
+
+import "envoy/type/v3/ratelimit_unit.proto";
+import "envoy/type/v3/token_bucket.proto";
+
+import "xds/annotations/v3/status.proto";
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.v3";
+option java_outer_classname = "RatelimitStrategyProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/v3;typev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+option (xds.annotations.v3.file_status).work_in_progress = true;
+
+// [#protodoc-title: Rate Limit Strategies]
+
+message RateLimitStrategy {
+  // Choose between allow all and deny all.
+  enum BlanketRule {
+    ALLOW_ALL = 0;
+    DENY_ALL = 1;
+  }
+
+  // Best-effort limit of the number of requests per time unit.
+  //
+  // Allows to specify the desired requests per second (RPS, QPS), requests per minute (QPM, RPM),
+  // etc., without specifying a rate limiting algorithm implementation.
+  //
+  // ``RequestsPerTimeUnit`` strategy does not demand any specific rate limiting algorithm to be
+  // used (in contrast to the :ref:`TokenBucket <envoy_v3_api_msg_type.v3.TokenBucket>`,
+  // for example). It implies that the implementation details of rate limiting algorithm are
+  // irrelevant as long as the configured number of "requests per time unit" is achieved.
+  //
+  // Note that the ``TokenBucket`` is still a valid implementation of the ``RequestsPerTimeUnit``
+  // strategy, and may be chosen to enforce the rate limit. However, there's no guarantee it will be
+  // the ``TokenBucket`` in particular, and not the Leaky Bucket, the Sliding Window, or any other
+  // rate limiting algorithm that fulfills the requirements.
+  message RequestsPerTimeUnit {
+    // The desired number of requests per :ref:`time_unit
+    // <envoy_v3_api_field_type.v3.RateLimitStrategy.RequestsPerTimeUnit.time_unit>` to allow.
+    // If set to ``0``, deny all (equivalent to ``BlanketRule.DENY_ALL``).
+    //
+    // .. note::
+    //   Note that the algorithm implementation determines the course of action for the requests
+    //   over the limit. As long as the ``requests_per_time_unit`` converges on the desired value,
+    //   it's allowed to treat this field as a soft-limit: allow bursts, redistribute the allowance
+    //   over time, etc.
+    //
+    uint64 requests_per_time_unit = 1;
+
+    // The unit of time. Ignored when :ref:`requests_per_time_unit
+    // <envoy_v3_api_field_type.v3.RateLimitStrategy.RequestsPerTimeUnit.requests_per_time_unit>`
+    // is ``0`` (deny all).
+    RateLimitUnit time_unit = 2 [(validate.rules).enum = {defined_only: true}];
+  }
+
+  oneof strategy {
+    option (validate.required) = true;
+
+    // Allow or Deny the requests.
+    // If unset, allow all.
+    BlanketRule blanket_rule = 1 [(validate.rules).enum = {defined_only: true}];
+
+    // Best-effort limit of the number of requests per time unit, f.e. requests per second.
+    // Does not prescribe any specific rate limiting algorithm, see :ref:`RequestsPerTimeUnit
+    // <envoy_v3_api_msg_type.v3.RateLimitStrategy.RequestsPerTimeUnit>` for details.
+    RequestsPerTimeUnit requests_per_time_unit = 2;
+
+    // Limit the requests by consuming tokens from the Token Bucket.
+    // Allow the same number of requests as the number of tokens available in
+    // the token bucket.
+    TokenBucket token_bucket = 3;
+  }
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/v3/ratelimit_unit.proto b/xds/third_party/envoy/src/main/proto/envoy/type/v3/ratelimit_unit.proto
new file mode 100644
index 00000000000..1a96497926d
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/v3/ratelimit_unit.proto
@@ -0,0 +1,37 @@
+syntax = "proto3";
+
+package envoy.type.v3;
+
+import "udpa/annotations/status.proto";
+
+option java_package = "io.envoyproxy.envoy.type.v3";
+option java_outer_classname = "RatelimitUnitProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/v3;typev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Ratelimit Time Unit]
+
+// Identifies the unit of of time for rate limit.
+enum RateLimitUnit {
+  // The time unit is not known.
+  UNKNOWN = 0;
+
+  // The time unit representing a second.
+  SECOND = 1;
+
+  // The time unit representing a minute.
+  MINUTE = 2;
+
+  // The time unit representing an hour.
+  HOUR = 3;
+
+  // The time unit representing a day.
+  DAY = 4;
+
+  // The time unit representing a month.
+  MONTH = 5;
+
+  // The time unit representing a year.
+  YEAR = 6;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/v3/semantic_version.proto b/xds/third_party/envoy/src/main/proto/envoy/type/v3/semantic_version.proto
new file mode 100644
index 00000000000..e032b4cd22d
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/v3/semantic_version.proto
@@ -0,0 +1,27 @@
+syntax = "proto3";
+
+package envoy.type.v3;
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+
+option java_package = "io.envoyproxy.envoy.type.v3";
+option java_outer_classname = "SemanticVersionProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/v3;typev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Semantic version]
+
+// Envoy uses SemVer (https://semver.org/). Major/minor versions indicate
+// expected behaviors and APIs, the patch version field is used only
+// for security fixes and can be generally ignored.
+message SemanticVersion {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.SemanticVersion";
+
+  uint32 major_number = 1;
+
+  uint32 minor_number = 2;
+
+  uint32 patch = 3;
+}
diff --git a/xds/third_party/envoy/src/main/proto/envoy/type/v3/token_bucket.proto b/xds/third_party/envoy/src/main/proto/envoy/type/v3/token_bucket.proto
new file mode 100644
index 00000000000..157a271efc9
--- /dev/null
+++ b/xds/third_party/envoy/src/main/proto/envoy/type/v3/token_bucket.proto
@@ -0,0 +1,39 @@
+syntax = "proto3";
+
+package envoy.type.v3;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/wrappers.proto";
+
+import "udpa/annotations/status.proto";
+import "udpa/annotations/versioning.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.type.v3";
+option java_outer_classname = "TokenBucketProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/type/v3;typev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: Token bucket]
+
+// Configures a token bucket, typically used for rate limiting.
+message TokenBucket {
+  option (udpa.annotations.versioning).previous_message_type = "envoy.type.TokenBucket";
+
+  // The maximum tokens that the bucket can hold. This is also the number of tokens that the bucket
+  // initially contains.
+  uint32 max_tokens = 1 [(validate.rules).uint32 = {gt: 0}];
+
+  // The number of tokens added to the bucket during each fill interval. If not specified, defaults
+  // to a single token.
+  google.protobuf.UInt32Value tokens_per_fill = 2 [(validate.rules).uint32 = {gt: 0}];
+
+  // The fill interval that tokens are added to the bucket. During each fill interval
+  // ``tokens_per_fill`` are added to the bucket. The bucket will never contain more than
+  // ``max_tokens`` tokens.
+  google.protobuf.Duration fill_interval = 3 [(validate.rules).duration = {
+    required: true
+    gt {}
+  }];
+}
diff --git a/xds/third_party/googleapis/LICENSE b/xds/third_party/googleapis/LICENSE
new file mode 100644
index 00000000000..261eeb9e9f8
--- /dev/null
+++ b/xds/third_party/googleapis/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/xds/third_party/googleapis/import.sh b/xds/third_party/googleapis/import.sh
new file mode 100755
index 00000000000..683b8cec952
--- /dev/null
+++ b/xds/third_party/googleapis/import.sh
@@ -0,0 +1,51 @@
+#!/bin/bash
+# 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.
+
+# Update VERSION then execute this script
+
+set -e
+VERSION=114a745b2841a044e98cdbb19358ed29fcf4a5f1
+DOWNLOAD_URL="https://github.com/googleapis/googleapis/archive/${VERSION}.tar.gz"
+DOWNLOAD_BASE_DIR="googleapis-${VERSION}"
+SOURCE_PROTO_BASE_DIR="${DOWNLOAD_BASE_DIR}"
+TARGET_PROTO_BASE_DIR=src/main/proto
+# Sorted alphabetically.
+FILES=(
+google/api/expr/v1alpha1/checked.proto
+google/api/expr/v1alpha1/syntax.proto
+)
+
+pushd `git rev-parse --show-toplevel`/xds/third_party/googleapis
+
+# put the repo in a tmp directory
+tmpdir="$(mktemp -d)"
+trap "rm -rf ${tmpdir}" EXIT
+curl -Ls "${DOWNLOAD_URL}" | tar xz -C "${tmpdir}"
+
+cp -p "${tmpdir}/${DOWNLOAD_BASE_DIR}/LICENSE" LICENSE
+
+rm -rf "${TARGET_PROTO_BASE_DIR}"
+mkdir -p "${TARGET_PROTO_BASE_DIR}"
+pushd "${TARGET_PROTO_BASE_DIR}"
+
+# copy proto files to project directory
+for file in "${FILES[@]}"
+do
+  mkdir -p "$(dirname "${file}")"
+  cp -p "${tmpdir}/${SOURCE_PROTO_BASE_DIR}/${file}" "${file}"
+done
+popd
+
+popd
diff --git a/xds/third_party/googleapis/src/main/proto/google/api/expr/v1alpha1/checked.proto b/xds/third_party/googleapis/src/main/proto/google/api/expr/v1alpha1/checked.proto
new file mode 100644
index 00000000000..930dc4f0090
--- /dev/null
+++ b/xds/third_party/googleapis/src/main/proto/google/api/expr/v1alpha1/checked.proto
@@ -0,0 +1,343 @@
+// Copyright 2022 Google LLC
+//
+// 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.
+
+syntax = "proto3";
+
+package google.api.expr.v1alpha1;
+
+import "google/api/expr/v1alpha1/syntax.proto";
+import "google/protobuf/empty.proto";
+import "google/protobuf/struct.proto";
+
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/genproto/googleapis/api/expr/v1alpha1;expr";
+option java_multiple_files = true;
+option java_outer_classname = "DeclProto";
+option java_package = "com.google.api.expr.v1alpha1";
+
+// Protos for representing CEL declarations and typed checked expressions.
+
+// A CEL expression which has been successfully type checked.
+message CheckedExpr {
+  // A map from expression ids to resolved references.
+  //
+  // The following entries are in this table:
+  //
+  // - An Ident or Select expression is represented here if it resolves to a
+  //   declaration. For instance, if `a.b.c` is represented by
+  //   `select(select(id(a), b), c)`, and `a.b` resolves to a declaration,
+  //   while `c` is a field selection, then the reference is attached to the
+  //   nested select expression (but not to the id or or the outer select).
+  //   In turn, if `a` resolves to a declaration and `b.c` are field selections,
+  //   the reference is attached to the ident expression.
+  // - Every Call expression has an entry here, identifying the function being
+  //   called.
+  // - Every CreateStruct expression for a message has an entry, identifying
+  //   the message.
+  map<int64, Reference> reference_map = 2;
+
+  // A map from expression ids to types.
+  //
+  // Every expression node which has a type different than DYN has a mapping
+  // here. If an expression has type DYN, it is omitted from this map to save
+  // space.
+  map<int64, Type> type_map = 3;
+
+  // The source info derived from input that generated the parsed `expr` and
+  // any optimizations made during the type-checking pass.
+  SourceInfo source_info = 5;
+
+  // The expr version indicates the major / minor version number of the `expr`
+  // representation.
+  //
+  // The most common reason for a version change will be to indicate to the CEL
+  // runtimes that transformations have been performed on the expr during static
+  // analysis. In some cases, this will save the runtime the work of applying
+  // the same or similar transformations prior to evaluation.
+  string expr_version = 6;
+
+  // The checked expression. Semantically equivalent to the parsed `expr`, but
+  // may have structural differences.
+  Expr expr = 4;
+}
+
+// Represents a CEL type.
+message Type {
+  // List type with typed elements, e.g. `list<example.proto.MyMessage>`.
+  message ListType {
+    // The element type.
+    Type elem_type = 1;
+  }
+
+  // Map type with parameterized key and value types, e.g. `map<string, int>`.
+  message MapType {
+    // The type of the key.
+    Type key_type = 1;
+
+    // The type of the value.
+    Type value_type = 2;
+  }
+
+  // Function type with result and arg types.
+  message FunctionType {
+    // Result type of the function.
+    Type result_type = 1;
+
+    // Argument types of the function.
+    repeated Type arg_types = 2;
+  }
+
+  // Application defined abstract type.
+  message AbstractType {
+    // The fully qualified name of this abstract type.
+    string name = 1;
+
+    // Parameter types for this abstract type.
+    repeated Type parameter_types = 2;
+  }
+
+  // CEL primitive types.
+  enum PrimitiveType {
+    // Unspecified type.
+    PRIMITIVE_TYPE_UNSPECIFIED = 0;
+
+    // Boolean type.
+    BOOL = 1;
+
+    // Int64 type.
+    //
+    // Proto-based integer values are widened to int64.
+    INT64 = 2;
+
+    // Uint64 type.
+    //
+    // Proto-based unsigned integer values are widened to uint64.
+    UINT64 = 3;
+
+    // Double type.
+    //
+    // Proto-based float values are widened to double values.
+    DOUBLE = 4;
+
+    // String type.
+    STRING = 5;
+
+    // Bytes type.
+    BYTES = 6;
+  }
+
+  // Well-known protobuf types treated with first-class support in CEL.
+  enum WellKnownType {
+    // Unspecified type.
+    WELL_KNOWN_TYPE_UNSPECIFIED = 0;
+
+    // Well-known protobuf.Any type.
+    //
+    // Any types are a polymorphic message type. During type-checking they are
+    // treated like `DYN` types, but at runtime they are resolved to a specific
+    // message type specified at evaluation time.
+    ANY = 1;
+
+    // Well-known protobuf.Timestamp type, internally referenced as `timestamp`.
+    TIMESTAMP = 2;
+
+    // Well-known protobuf.Duration type, internally referenced as `duration`.
+    DURATION = 3;
+  }
+
+  // The kind of type.
+  oneof type_kind {
+    // Dynamic type.
+    google.protobuf.Empty dyn = 1;
+
+    // Null value.
+    google.protobuf.NullValue null = 2;
+
+    // Primitive types: `true`, `1u`, `-2.0`, `'string'`, `b'bytes'`.
+    PrimitiveType primitive = 3;
+
+    // Wrapper of a primitive type, e.g. `google.protobuf.Int64Value`.
+    PrimitiveType wrapper = 4;
+
+    // Well-known protobuf type such as `google.protobuf.Timestamp`.
+    WellKnownType well_known = 5;
+
+    // Parameterized list with elements of `list_type`, e.g. `list<timestamp>`.
+    ListType list_type = 6;
+
+    // Parameterized map with typed keys and values.
+    MapType map_type = 7;
+
+    // Function type.
+    FunctionType function = 8;
+
+    // Protocol buffer message type.
+    //
+    // The `message_type` string specifies the qualified message type name. For
+    // example, `google.plus.Profile`.
+    string message_type = 9;
+
+    // Type param type.
+    //
+    // The `type_param` string specifies the type parameter name, e.g. `list<E>`
+    // would be a `list_type` whose element type was a `type_param` type
+    // named `E`.
+    string type_param = 10;
+
+    // Type type.
+    //
+    // The `type` value specifies the target type. e.g. int is type with a
+    // target type of `Primitive.INT`.
+    Type type = 11;
+
+    // Error type.
+    //
+    // During type-checking if an expression is an error, its type is propagated
+    // as the `ERROR` type. This permits the type-checker to discover other
+    // errors present in the expression.
+    google.protobuf.Empty error = 12;
+
+    // Abstract, application defined type.
+    AbstractType abstract_type = 14;
+  }
+}
+
+// Represents a declaration of a named value or function.
+//
+// A declaration is part of the contract between the expression, the agent
+// evaluating that expression, and the caller requesting evaluation.
+message Decl {
+  // Identifier declaration which specifies its type and optional `Expr` value.
+  //
+  // An identifier without a value is a declaration that must be provided at
+  // evaluation time. An identifier with a value should resolve to a constant,
+  // but may be used in conjunction with other identifiers bound at evaluation
+  // time.
+  message IdentDecl {
+    // Required. The type of the identifier.
+    Type type = 1;
+
+    // The constant value of the identifier. If not specified, the identifier
+    // must be supplied at evaluation time.
+    Constant value = 2;
+
+    // Documentation string for the identifier.
+    string doc = 3;
+  }
+
+  // Function declaration specifies one or more overloads which indicate the
+  // function's parameter types and return type.
+  //
+  // Functions have no observable side-effects (there may be side-effects like
+  // logging which are not observable from CEL).
+  message FunctionDecl {
+    // An overload indicates a function's parameter types and return type, and
+    // may optionally include a function body described in terms of
+    // [Expr][google.api.expr.v1alpha1.Expr] values.
+    //
+    // Functions overloads are declared in either a function or method
+    // call-style. For methods, the `params[0]` is the expected type of the
+    // target receiver.
+    //
+    // Overloads must have non-overlapping argument types after erasure of all
+    // parameterized type variables (similar as type erasure in Java).
+    message Overload {
+      // Required. Globally unique overload name of the function which reflects
+      // the function name and argument types.
+      //
+      // This will be used by a [Reference][google.api.expr.v1alpha1.Reference]
+      // to indicate the `overload_id` that was resolved for the function
+      // `name`.
+      string overload_id = 1;
+
+      // List of function parameter [Type][google.api.expr.v1alpha1.Type]
+      // values.
+      //
+      // Param types are disjoint after generic type parameters have been
+      // replaced with the type `DYN`. Since the `DYN` type is compatible with
+      // any other type, this means that if `A` is a type parameter, the
+      // function types `int<A>` and `int<int>` are not disjoint. Likewise,
+      // `map<string, string>` is not disjoint from `map<K, V>`.
+      //
+      // When the `result_type` of a function is a generic type param, the
+      // type param name also appears as the `type` of on at least one params.
+      repeated Type params = 2;
+
+      // The type param names associated with the function declaration.
+      //
+      // For example, `function ex<K,V>(K key, map<K, V> map) : V` would yield
+      // the type params of `K, V`.
+      repeated string type_params = 3;
+
+      // Required. The result type of the function. For example, the operator
+      // `string.isEmpty()` would have `result_type` of `kind: BOOL`.
+      Type result_type = 4;
+
+      // Whether the function is to be used in a method call-style `x.f(...)`
+      // or a function call-style `f(x, ...)`.
+      //
+      // For methods, the first parameter declaration, `params[0]` is the
+      // expected type of the target receiver.
+      bool is_instance_function = 5;
+
+      // Documentation string for the overload.
+      string doc = 6;
+    }
+
+    // Required. List of function overloads, must contain at least one overload.
+    repeated Overload overloads = 1;
+  }
+
+  // The fully qualified name of the declaration.
+  //
+  // Declarations are organized in containers and this represents the full path
+  // to the declaration in its container, as in `google.api.expr.Decl`.
+  //
+  // Declarations used as
+  // [FunctionDecl.Overload][google.api.expr.v1alpha1.Decl.FunctionDecl.Overload]
+  // parameters may or may not have a name depending on whether the overload is
+  // function declaration or a function definition containing a result
+  // [Expr][google.api.expr.v1alpha1.Expr].
+  string name = 1;
+
+  // Required. The declaration kind.
+  oneof decl_kind {
+    // Identifier declaration.
+    IdentDecl ident = 2;
+
+    // Function declaration.
+    FunctionDecl function = 3;
+  }
+}
+
+// Describes a resolved reference to a declaration.
+message Reference {
+  // The fully qualified name of the declaration.
+  string name = 1;
+
+  // For references to functions, this is a list of `Overload.overload_id`
+  // values which match according to typing rules.
+  //
+  // If the list has more than one element, overload resolution among the
+  // presented candidates must happen at runtime because of dynamic types. The
+  // type checker attempts to narrow down this list as much as possible.
+  //
+  // Empty if this is not a reference to a
+  // [Decl.FunctionDecl][google.api.expr.v1alpha1.Decl.FunctionDecl].
+  repeated string overload_id = 3;
+
+  // For references to constants, this may contain the value of the
+  // constant if known at compile time.
+  Constant value = 4;
+}
diff --git a/xds/third_party/googleapis/src/main/proto/google/api/expr/v1alpha1/syntax.proto b/xds/third_party/googleapis/src/main/proto/google/api/expr/v1alpha1/syntax.proto
new file mode 100644
index 00000000000..8219ba68924
--- /dev/null
+++ b/xds/third_party/googleapis/src/main/proto/google/api/expr/v1alpha1/syntax.proto
@@ -0,0 +1,343 @@
+// Copyright 2022 Google LLC
+//
+// 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.
+
+syntax = "proto3";
+
+package google.api.expr.v1alpha1;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/struct.proto";
+import "google/protobuf/timestamp.proto";
+
+option cc_enable_arenas = true;
+option go_package = "google.golang.org/genproto/googleapis/api/expr/v1alpha1;expr";
+option java_multiple_files = true;
+option java_outer_classname = "SyntaxProto";
+option java_package = "com.google.api.expr.v1alpha1";
+
+// A representation of the abstract syntax of the Common Expression Language.
+
+// An expression together with source information as returned by the parser.
+message ParsedExpr {
+  // The parsed expression.
+  Expr expr = 2;
+
+  // The source info derived from input that generated the parsed `expr`.
+  SourceInfo source_info = 3;
+}
+
+// An abstract representation of a common expression.
+//
+// Expressions are abstractly represented as a collection of identifiers,
+// select statements, function calls, literals, and comprehensions. All
+// operators with the exception of the '.' operator are modelled as function
+// calls. This makes it easy to represent new operators into the existing AST.
+//
+// All references within expressions must resolve to a [Decl][google.api.expr.v1alpha1.Decl] provided at
+// type-check for an expression to be valid. A reference may either be a bare
+// identifier `name` or a qualified identifier `google.api.name`. References
+// may either refer to a value or a function declaration.
+//
+// For example, the expression `google.api.name.startsWith('expr')` references
+// the declaration `google.api.name` within a [Expr.Select][google.api.expr.v1alpha1.Expr.Select] expression, and
+// the function declaration `startsWith`.
+message Expr {
+  // An identifier expression. e.g. `request`.
+  message Ident {
+    // Required. Holds a single, unqualified identifier, possibly preceded by a
+    // '.'.
+    //
+    // Qualified names are represented by the [Expr.Select][google.api.expr.v1alpha1.Expr.Select] expression.
+    string name = 1;
+  }
+
+  // A field selection expression. e.g. `request.auth`.
+  message Select {
+    // Required. The target of the selection expression.
+    //
+    // For example, in the select expression `request.auth`, the `request`
+    // portion of the expression is the `operand`.
+    Expr operand = 1;
+
+    // Required. The name of the field to select.
+    //
+    // For example, in the select expression `request.auth`, the `auth` portion
+    // of the expression would be the `field`.
+    string field = 2;
+
+    // Whether the select is to be interpreted as a field presence test.
+    //
+    // This results from the macro `has(request.auth)`.
+    bool test_only = 3;
+  }
+
+  // A call expression, including calls to predefined functions and operators.
+  //
+  // For example, `value == 10`, `size(map_value)`.
+  message Call {
+    // The target of an method call-style expression. For example, `x` in
+    // `x.f()`.
+    Expr target = 1;
+
+    // Required. The name of the function or method being called.
+    string function = 2;
+
+    // The arguments.
+    repeated Expr args = 3;
+  }
+
+  // A list creation expression.
+  //
+  // Lists may either be homogenous, e.g. `[1, 2, 3]`, or heterogeneous, e.g.
+  // `dyn([1, 'hello', 2.0])`
+  message CreateList {
+    // The elements part of the list.
+    repeated Expr elements = 1;
+
+    // The indices within the elements list which are marked as optional
+    // elements.
+    //
+    // When an optional-typed value is present, the value it contains
+    // is included in the list. If the optional-typed value is absent, the list
+    // element is omitted from the CreateList result.
+    repeated int32 optional_indices = 2;
+  }
+
+  // A map or message creation expression.
+  //
+  // Maps are constructed as `{'key_name': 'value'}`. Message construction is
+  // similar, but prefixed with a type name and composed of field ids:
+  // `types.MyType{field_id: 'value'}`.
+  message CreateStruct {
+    // Represents an entry.
+    message Entry {
+      // Required. An id assigned to this node by the parser which is unique
+      // in a given expression tree. This is used to associate type
+      // information and other attributes to the node.
+      int64 id = 1;
+
+      // The `Entry` key kinds.
+      oneof key_kind {
+        // The field key for a message creator statement.
+        string field_key = 2;
+
+        // The key expression for a map creation statement.
+        Expr map_key = 3;
+      }
+
+      // Required. The value assigned to the key.
+      //
+      // If the optional_entry field is true, the expression must resolve to an
+      // optional-typed value. If the optional value is present, the key will be
+      // set; however, if the optional value is absent, the key will be unset.
+      Expr value = 4;
+
+      // Whether the key-value pair is optional.
+      bool optional_entry = 5;
+    }
+
+    // The type name of the message to be created, empty when creating map
+    // literals.
+    string message_name = 1;
+
+    // The entries in the creation expression.
+    repeated Entry entries = 2;
+  }
+
+  // A comprehension expression applied to a list or map.
+  //
+  // Comprehensions are not part of the core syntax, but enabled with macros.
+  // A macro matches a specific call signature within a parsed AST and replaces
+  // the call with an alternate AST block. Macro expansion happens at parse
+  // time.
+  //
+  // The following macros are supported within CEL:
+  //
+  // Aggregate type macros may be applied to all elements in a list or all keys
+  // in a map:
+  //
+  // *  `all`, `exists`, `exists_one` -  test a predicate expression against
+  //    the inputs and return `true` if the predicate is satisfied for all,
+  //    any, or only one value `list.all(x, x < 10)`.
+  // *  `filter` - test a predicate expression against the inputs and return
+  //    the subset of elements which satisfy the predicate:
+  //    `payments.filter(p, p > 1000)`.
+  // *  `map` - apply an expression to all elements in the input and return the
+  //    output aggregate type: `[1, 2, 3].map(i, i * i)`.
+  //
+  // The `has(m.x)` macro tests whether the property `x` is present in struct
+  // `m`. The semantics of this macro depend on the type of `m`. For proto2
+  // messages `has(m.x)` is defined as 'defined, but not set`. For proto3, the
+  // macro tests whether the property is set to its default. For map and struct
+  // types, the macro tests whether the property `x` is defined on `m`.
+  message Comprehension {
+    // The name of the iteration variable.
+    string iter_var = 1;
+
+    // The range over which var iterates.
+    Expr iter_range = 2;
+
+    // The name of the variable used for accumulation of the result.
+    string accu_var = 3;
+
+    // The initial value of the accumulator.
+    Expr accu_init = 4;
+
+    // An expression which can contain iter_var and accu_var.
+    //
+    // Returns false when the result has been computed and may be used as
+    // a hint to short-circuit the remainder of the comprehension.
+    Expr loop_condition = 5;
+
+    // An expression which can contain iter_var and accu_var.
+    //
+    // Computes the next value of accu_var.
+    Expr loop_step = 6;
+
+    // An expression which can contain accu_var.
+    //
+    // Computes the result.
+    Expr result = 7;
+  }
+
+  // Required. An id assigned to this node by the parser which is unique in a
+  // given expression tree. This is used to associate type information and other
+  // attributes to a node in the parse tree.
+  int64 id = 2;
+
+  // Required. Variants of expressions.
+  oneof expr_kind {
+    // A literal expression.
+    Constant const_expr = 3;
+
+    // An identifier expression.
+    Ident ident_expr = 4;
+
+    // A field selection expression, e.g. `request.auth`.
+    Select select_expr = 5;
+
+    // A call expression, including calls to predefined functions and operators.
+    Call call_expr = 6;
+
+    // A list creation expression.
+    CreateList list_expr = 7;
+
+    // A map or message creation expression.
+    CreateStruct struct_expr = 8;
+
+    // A comprehension expression.
+    Comprehension comprehension_expr = 9;
+  }
+}
+
+// Represents a primitive literal.
+//
+// Named 'Constant' here for backwards compatibility.
+//
+// This is similar as the primitives supported in the well-known type
+// `google.protobuf.Value`, but richer so it can represent CEL's full range of
+// primitives.
+//
+// Lists and structs are not included as constants as these aggregate types may
+// contain [Expr][google.api.expr.v1alpha1.Expr] elements which require evaluation and are thus not constant.
+//
+// Examples of literals include: `"hello"`, `b'bytes'`, `1u`, `4.2`, `-2`,
+// `true`, `null`.
+message Constant {
+  // Required. The valid constant kinds.
+  oneof constant_kind {
+    // null value.
+    google.protobuf.NullValue null_value = 1;
+
+    // boolean value.
+    bool bool_value = 2;
+
+    // int64 value.
+    int64 int64_value = 3;
+
+    // uint64 value.
+    uint64 uint64_value = 4;
+
+    // double value.
+    double double_value = 5;
+
+    // string value.
+    string string_value = 6;
+
+    // bytes value.
+    bytes bytes_value = 7;
+
+    // protobuf.Duration value.
+    //
+    // Deprecated: duration is no longer considered a builtin cel type.
+    google.protobuf.Duration duration_value = 8 [deprecated = true];
+
+    // protobuf.Timestamp value.
+    //
+    // Deprecated: timestamp is no longer considered a builtin cel type.
+    google.protobuf.Timestamp timestamp_value = 9 [deprecated = true];
+  }
+}
+
+// Source information collected at parse time.
+message SourceInfo {
+  // The syntax version of the source, e.g. `cel1`.
+  string syntax_version = 1;
+
+  // The location name. All position information attached to an expression is
+  // relative to this location.
+  //
+  // The location could be a file, UI element, or similar. For example,
+  // `acme/app/AnvilPolicy.cel`.
+  string location = 2;
+
+  // Monotonically increasing list of code point offsets where newlines
+  // `\n` appear.
+  //
+  // The line number of a given position is the index `i` where for a given
+  // `id` the `line_offsets[i] < id_positions[id] < line_offsets[i+1]`. The
+  // column may be derivd from `id_positions[id] - line_offsets[i]`.
+  repeated int32 line_offsets = 3;
+
+  // A map from the parse node id (e.g. `Expr.id`) to the code point offset
+  // within the source.
+  map<int64, int32> positions = 4;
+
+  // A map from the parse node id where a macro replacement was made to the
+  // call `Expr` that resulted in a macro expansion.
+  //
+  // For example, `has(value.field)` is a function call that is replaced by a
+  // `test_only` field selection in the AST. Likewise, the call
+  // `list.exists(e, e > 10)` translates to a comprehension expression. The key
+  // in the map corresponds to the expression id of the expanded macro, and the
+  // value is the call `Expr` that was replaced.
+  map<int64, Expr> macro_calls = 5;
+}
+
+// A specific position in source.
+message SourcePosition {
+  // The soucre location name (e.g. file name).
+  string location = 1;
+
+  // The UTF-8 code unit offset.
+  int32 offset = 2;
+
+  // The 1-based index of the starting line in the source text
+  // where the issue occurs, or 0 if unknown.
+  int32 line = 3;
+
+  // The 0-based index of the starting position within the line of source text
+  // where the issue occurs.  Only meaningful if line is nonzero.
+  int32 column = 4;
+}
diff --git a/xds/third_party/protoc-gen-validate/LICENSE b/xds/third_party/protoc-gen-validate/LICENSE
new file mode 100644
index 00000000000..d6456956733
--- /dev/null
+++ b/xds/third_party/protoc-gen-validate/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/xds/third_party/protoc-gen-validate/NOTICE b/xds/third_party/protoc-gen-validate/NOTICE
new file mode 100644
index 00000000000..60884a05905
--- /dev/null
+++ b/xds/third_party/protoc-gen-validate/NOTICE
@@ -0,0 +1,4 @@
+protoc-gen-validate
+Copyright 2019 Envoy Project Authors
+
+Licensed under Apache License 2.0. See LICENSE for terms.
diff --git a/xds/third_party/protoc-gen-validate/import.sh b/xds/third_party/protoc-gen-validate/import.sh
new file mode 100755
index 00000000000..64c92b16c20
--- /dev/null
+++ b/xds/third_party/protoc-gen-validate/import.sh
@@ -0,0 +1,52 @@
+#!/bin/bash
+# Copyright 2018 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.
+
+# Update VERSION then execute this script
+
+set -e
+# import VERSION from one of the google internal CLs
+VERSION=dfcdc5ea103dda467963fb7079e4df28debcfd28
+DOWNLOAD_URL="https://github.com/envoyproxy/protoc-gen-validate/archive/${VERSION}.tar.gz"
+DOWNLOAD_BASE_DIR="protoc-gen-validate-${VERSION}"
+SOURCE_PROTO_BASE_DIR="${DOWNLOAD_BASE_DIR}"
+TARGET_PROTO_BASE_DIR=src/main/proto
+# Sorted alphabetically.
+FILES=(
+validate/validate.proto
+)
+
+pushd `git rev-parse --show-toplevel`/xds/third_party/protoc-gen-validate
+
+# put the repo in a tmp directory
+tmpdir="$(mktemp -d)"
+trap "rm -rf ${tmpdir}" EXIT
+curl -Ls "${DOWNLOAD_URL}" | tar xz -C "${tmpdir}"
+
+cp -p "${tmpdir}/${DOWNLOAD_BASE_DIR}/LICENSE" LICENSE
+cp -p "${tmpdir}/${DOWNLOAD_BASE_DIR}/NOTICE" NOTICE
+
+rm -rf "${TARGET_PROTO_BASE_DIR}"
+mkdir -p "${TARGET_PROTO_BASE_DIR}"
+pushd "${TARGET_PROTO_BASE_DIR}"
+
+# copy proto files to project directory
+for file in "${FILES[@]}"
+do
+  mkdir -p "$(dirname "${file}")"
+  cp -p "${tmpdir}/${SOURCE_PROTO_BASE_DIR}/${file}" "${file}"
+done
+popd
+
+popd
diff --git a/xds/third_party/protoc-gen-validate/src/main/proto/validate/validate.proto b/xds/third_party/protoc-gen-validate/src/main/proto/validate/validate.proto
new file mode 100644
index 00000000000..705d382aac4
--- /dev/null
+++ b/xds/third_party/protoc-gen-validate/src/main/proto/validate/validate.proto
@@ -0,0 +1,862 @@
+syntax = "proto2";
+package validate;
+
+option go_package = "github.com/envoyproxy/protoc-gen-validate/validate";
+option java_package = "io.envoyproxy.pgv.validate";
+
+import "google/protobuf/descriptor.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+
+// Validation rules applied at the message level
+extend google.protobuf.MessageOptions {
+    // Disabled nullifies any validation rules for this message, including any
+    // message fields associated with it that do support validation.
+    optional bool disabled = 1071;
+    // Ignore skips generation of validation methods for this message.
+    optional bool ignored = 1072;
+}
+
+// Validation rules applied at the oneof level
+extend google.protobuf.OneofOptions {
+    // Required ensures that exactly one the field options in a oneof is set;
+    // validation fails if no fields in the oneof are set.
+    optional bool required = 1071;
+}
+
+// Validation rules applied at the field level
+extend google.protobuf.FieldOptions {
+    // Rules specify the validations to be performed on this field. By default,
+    // no validation is performed against a field.
+    optional FieldRules rules = 1071;
+}
+
+// FieldRules encapsulates the rules for each type of field. Depending on the
+// field, the correct set should be used to ensure proper validations.
+message FieldRules {
+    optional MessageRules message = 17;
+    oneof type {
+        // Scalar Field Types
+        FloatRules    float    = 1;
+        DoubleRules   double   = 2;
+        Int32Rules    int32    = 3;
+        Int64Rules    int64    = 4;
+        UInt32Rules   uint32   = 5;
+        UInt64Rules   uint64   = 6;
+        SInt32Rules   sint32   = 7;
+        SInt64Rules   sint64   = 8;
+        Fixed32Rules  fixed32  = 9;
+        Fixed64Rules  fixed64  = 10;
+        SFixed32Rules sfixed32 = 11;
+        SFixed64Rules sfixed64 = 12;
+        BoolRules     bool     = 13;
+        StringRules   string   = 14;
+        BytesRules    bytes    = 15;
+
+        // Complex Field Types
+        EnumRules     enum     = 16;
+        RepeatedRules repeated = 18;
+        MapRules      map      = 19;
+
+        // Well-Known Field Types
+        AnyRules       any       = 20;
+        DurationRules  duration  = 21;
+        TimestampRules timestamp = 22;
+    }
+}
+
+// FloatRules describes the constraints applied to `float` values
+message FloatRules {
+    // Const specifies that this field must be exactly the specified value
+    optional float const = 1;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional float lt = 2;
+
+    // Lte specifies that this field must be less than or equal to the
+    // specified value, inclusive
+    optional float lte = 3;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
+    // range is reversed.
+    optional float gt = 4;
+
+    // Gte specifies that this field must be greater than or equal to the
+    // specified value, inclusive. If the value of Gte is larger than a
+    // specified Lt or Lte, the range is reversed.
+    optional float gte = 5;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated float in = 6;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated float not_in = 7;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 8;
+}
+
+// DoubleRules describes the constraints applied to `double` values
+message DoubleRules {
+    // Const specifies that this field must be exactly the specified value
+    optional double const = 1;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional double lt = 2;
+
+    // Lte specifies that this field must be less than or equal to the
+    // specified value, inclusive
+    optional double lte = 3;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
+    // range is reversed.
+    optional double gt = 4;
+
+    // Gte specifies that this field must be greater than or equal to the
+    // specified value, inclusive. If the value of Gte is larger than a
+    // specified Lt or Lte, the range is reversed.
+    optional double gte = 5;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated double in = 6;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated double not_in = 7;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 8;
+}
+
+// Int32Rules describes the constraints applied to `int32` values
+message Int32Rules {
+    // Const specifies that this field must be exactly the specified value
+    optional int32 const = 1;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional int32 lt = 2;
+
+    // Lte specifies that this field must be less than or equal to the
+    // specified value, inclusive
+    optional int32 lte = 3;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
+    // range is reversed.
+    optional int32 gt = 4;
+
+    // Gte specifies that this field must be greater than or equal to the
+    // specified value, inclusive. If the value of Gte is larger than a
+    // specified Lt or Lte, the range is reversed.
+    optional int32 gte = 5;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated int32 in = 6;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated int32 not_in = 7;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 8;
+}
+
+// Int64Rules describes the constraints applied to `int64` values
+message Int64Rules {
+    // Const specifies that this field must be exactly the specified value
+    optional int64 const = 1;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional int64 lt = 2;
+
+    // Lte specifies that this field must be less than or equal to the
+    // specified value, inclusive
+    optional int64 lte = 3;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
+    // range is reversed.
+    optional int64 gt = 4;
+
+    // Gte specifies that this field must be greater than or equal to the
+    // specified value, inclusive. If the value of Gte is larger than a
+    // specified Lt or Lte, the range is reversed.
+    optional int64 gte = 5;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated int64 in = 6;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated int64 not_in = 7;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 8;
+}
+
+// UInt32Rules describes the constraints applied to `uint32` values
+message UInt32Rules {
+    // Const specifies that this field must be exactly the specified value
+    optional uint32 const = 1;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional uint32 lt = 2;
+
+    // Lte specifies that this field must be less than or equal to the
+    // specified value, inclusive
+    optional uint32 lte = 3;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
+    // range is reversed.
+    optional uint32 gt = 4;
+
+    // Gte specifies that this field must be greater than or equal to the
+    // specified value, inclusive. If the value of Gte is larger than a
+    // specified Lt or Lte, the range is reversed.
+    optional uint32 gte = 5;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated uint32 in = 6;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated uint32 not_in = 7;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 8;
+}
+
+// UInt64Rules describes the constraints applied to `uint64` values
+message UInt64Rules {
+    // Const specifies that this field must be exactly the specified value
+    optional uint64 const = 1;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional uint64 lt = 2;
+
+    // Lte specifies that this field must be less than or equal to the
+    // specified value, inclusive
+    optional uint64 lte = 3;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
+    // range is reversed.
+    optional uint64 gt = 4;
+
+    // Gte specifies that this field must be greater than or equal to the
+    // specified value, inclusive. If the value of Gte is larger than a
+    // specified Lt or Lte, the range is reversed.
+    optional uint64 gte = 5;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated uint64 in = 6;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated uint64 not_in = 7;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 8;
+}
+
+// SInt32Rules describes the constraints applied to `sint32` values
+message SInt32Rules {
+    // Const specifies that this field must be exactly the specified value
+    optional sint32 const = 1;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional sint32 lt = 2;
+
+    // Lte specifies that this field must be less than or equal to the
+    // specified value, inclusive
+    optional sint32 lte = 3;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
+    // range is reversed.
+    optional sint32 gt = 4;
+
+    // Gte specifies that this field must be greater than or equal to the
+    // specified value, inclusive. If the value of Gte is larger than a
+    // specified Lt or Lte, the range is reversed.
+    optional sint32 gte = 5;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated sint32 in = 6;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated sint32 not_in = 7;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 8;
+}
+
+// SInt64Rules describes the constraints applied to `sint64` values
+message SInt64Rules {
+    // Const specifies that this field must be exactly the specified value
+    optional sint64 const = 1;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional sint64 lt = 2;
+
+    // Lte specifies that this field must be less than or equal to the
+    // specified value, inclusive
+    optional sint64 lte = 3;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
+    // range is reversed.
+    optional sint64 gt = 4;
+
+    // Gte specifies that this field must be greater than or equal to the
+    // specified value, inclusive. If the value of Gte is larger than a
+    // specified Lt or Lte, the range is reversed.
+    optional sint64 gte = 5;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated sint64 in = 6;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated sint64 not_in = 7;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 8;
+}
+
+// Fixed32Rules describes the constraints applied to `fixed32` values
+message Fixed32Rules {
+    // Const specifies that this field must be exactly the specified value
+    optional fixed32 const = 1;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional fixed32 lt = 2;
+
+    // Lte specifies that this field must be less than or equal to the
+    // specified value, inclusive
+    optional fixed32 lte = 3;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
+    // range is reversed.
+    optional fixed32 gt = 4;
+
+    // Gte specifies that this field must be greater than or equal to the
+    // specified value, inclusive. If the value of Gte is larger than a
+    // specified Lt or Lte, the range is reversed.
+    optional fixed32 gte = 5;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated fixed32 in = 6;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated fixed32 not_in = 7;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 8;
+}
+
+// Fixed64Rules describes the constraints applied to `fixed64` values
+message Fixed64Rules {
+    // Const specifies that this field must be exactly the specified value
+    optional fixed64 const = 1;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional fixed64 lt = 2;
+
+    // Lte specifies that this field must be less than or equal to the
+    // specified value, inclusive
+    optional fixed64 lte = 3;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
+    // range is reversed.
+    optional fixed64 gt = 4;
+
+    // Gte specifies that this field must be greater than or equal to the
+    // specified value, inclusive. If the value of Gte is larger than a
+    // specified Lt or Lte, the range is reversed.
+    optional fixed64 gte = 5;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated fixed64 in = 6;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated fixed64 not_in = 7;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 8;
+}
+
+// SFixed32Rules describes the constraints applied to `sfixed32` values
+message SFixed32Rules {
+    // Const specifies that this field must be exactly the specified value
+    optional sfixed32 const = 1;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional sfixed32 lt = 2;
+
+    // Lte specifies that this field must be less than or equal to the
+    // specified value, inclusive
+    optional sfixed32 lte = 3;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
+    // range is reversed.
+    optional sfixed32 gt = 4;
+
+    // Gte specifies that this field must be greater than or equal to the
+    // specified value, inclusive. If the value of Gte is larger than a
+    // specified Lt or Lte, the range is reversed.
+    optional sfixed32 gte = 5;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated sfixed32 in = 6;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated sfixed32 not_in = 7;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 8;
+}
+
+// SFixed64Rules describes the constraints applied to `sfixed64` values
+message SFixed64Rules {
+    // Const specifies that this field must be exactly the specified value
+    optional sfixed64 const = 1;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional sfixed64 lt = 2;
+
+    // Lte specifies that this field must be less than or equal to the
+    // specified value, inclusive
+    optional sfixed64 lte = 3;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
+    // range is reversed.
+    optional sfixed64 gt = 4;
+
+    // Gte specifies that this field must be greater than or equal to the
+    // specified value, inclusive. If the value of Gte is larger than a
+    // specified Lt or Lte, the range is reversed.
+    optional sfixed64 gte = 5;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated sfixed64 in = 6;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated sfixed64 not_in = 7;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 8;
+}
+
+// BoolRules describes the constraints applied to `bool` values
+message BoolRules {
+    // Const specifies that this field must be exactly the specified value
+    optional bool const = 1;
+}
+
+// StringRules describe the constraints applied to `string` values
+message StringRules {
+    // Const specifies that this field must be exactly the specified value
+    optional string const = 1;
+
+    // Len specifies that this field must be the specified number of
+    // characters (Unicode code points). Note that the number of
+    // characters may differ from the number of bytes in the string.
+    optional uint64 len = 19;
+
+    // MinLen specifies that this field must be the specified number of
+    // characters (Unicode code points) at a minimum. Note that the number of
+    // characters may differ from the number of bytes in the string.
+    optional uint64 min_len = 2;
+
+    // MaxLen specifies that this field must be the specified number of
+    // characters (Unicode code points) at a maximum. Note that the number of
+    // characters may differ from the number of bytes in the string.
+    optional uint64 max_len = 3;
+
+    // LenBytes specifies that this field must be the specified number of bytes
+    optional uint64 len_bytes = 20;
+
+    // MinBytes specifies that this field must be the specified number of bytes
+    // at a minimum
+    optional uint64 min_bytes = 4;
+
+    // MaxBytes specifies that this field must be the specified number of bytes
+    // at a maximum
+    optional uint64 max_bytes = 5;
+
+    // Pattern specifes that this field must match against the specified
+    // regular expression (RE2 syntax). The included expression should elide
+    // any delimiters.
+    optional string pattern  = 6;
+
+    // Prefix specifies that this field must have the specified substring at
+    // the beginning of the string.
+    optional string prefix   = 7;
+
+    // Suffix specifies that this field must have the specified substring at
+    // the end of the string.
+    optional string suffix   = 8;
+
+    // Contains specifies that this field must have the specified substring
+    // anywhere in the string.
+    optional string contains = 9;
+
+    // NotContains specifies that this field cannot have the specified substring
+    // anywhere in the string.
+    optional string not_contains = 23;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated string in     = 10;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated string not_in = 11;
+
+    // WellKnown rules provide advanced constraints against common string
+    // patterns
+    oneof well_known {
+        // Email specifies that the field must be a valid email address as
+        // defined by RFC 5322
+        bool email    = 12;
+
+        // Hostname specifies that the field must be a valid hostname as
+        // defined by RFC 1034. This constraint does not support
+        // internationalized domain names (IDNs).
+        bool hostname = 13;
+
+        // Ip specifies that the field must be a valid IP (v4 or v6) address.
+        // Valid IPv6 addresses should not include surrounding square brackets.
+        bool ip       = 14;
+
+        // Ipv4 specifies that the field must be a valid IPv4 address.
+        bool ipv4     = 15;
+
+        // Ipv6 specifies that the field must be a valid IPv6 address. Valid
+        // IPv6 addresses should not include surrounding square brackets.
+        bool ipv6     = 16;
+
+        // Uri specifies that the field must be a valid, absolute URI as defined
+        // by RFC 3986
+        bool uri      = 17;
+
+        // UriRef specifies that the field must be a valid URI as defined by RFC
+        // 3986 and may be relative or absolute.
+        bool uri_ref  = 18;
+
+        // Address specifies that the field must be either a valid hostname as
+        // defined by RFC 1034 (which does not support internationalized domain
+        // names or IDNs), or it can be a valid IP (v4 or v6).
+        bool address  = 21;
+
+        // Uuid specifies that the field must be a valid UUID as defined by
+        // RFC 4122
+        bool uuid     = 22;
+
+        // WellKnownRegex specifies a common well known pattern defined as a regex.
+        KnownRegex well_known_regex = 24;
+    }
+
+  // This applies to regexes HTTP_HEADER_NAME and HTTP_HEADER_VALUE to enable
+  // strict header validation.
+  // By default, this is true, and HTTP header validations are RFC-compliant.
+  // Setting to false will enable a looser validations that only disallows
+  // \r\n\0 characters, which can be used to bypass header matching rules.
+  optional bool strict = 25 [default = true];
+
+  // IgnoreEmpty specifies that the validation rules of this field should be
+  // evaluated only if the field is not empty
+  optional bool ignore_empty = 26;
+}
+
+// WellKnownRegex contain some well-known patterns.
+enum KnownRegex {
+  UNKNOWN = 0;
+
+  // HTTP header name as defined by RFC 7230.
+  HTTP_HEADER_NAME = 1;
+
+  // HTTP header value as defined by RFC 7230.
+  HTTP_HEADER_VALUE = 2;
+}
+
+// BytesRules describe the constraints applied to `bytes` values
+message BytesRules {
+    // Const specifies that this field must be exactly the specified value
+    optional bytes const = 1;
+
+    // Len specifies that this field must be the specified number of bytes
+    optional uint64 len = 13;
+
+    // MinLen specifies that this field must be the specified number of bytes
+    // at a minimum
+    optional uint64 min_len = 2;
+
+    // MaxLen specifies that this field must be the specified number of bytes
+    // at a maximum
+    optional uint64 max_len = 3;
+
+    // Pattern specifes that this field must match against the specified
+    // regular expression (RE2 syntax). The included expression should elide
+    // any delimiters.
+    optional string pattern  = 4;
+
+    // Prefix specifies that this field must have the specified bytes at the
+    // beginning of the string.
+    optional bytes  prefix   = 5;
+
+    // Suffix specifies that this field must have the specified bytes at the
+    // end of the string.
+    optional bytes  suffix   = 6;
+
+    // Contains specifies that this field must have the specified bytes
+    // anywhere in the string.
+    optional bytes  contains = 7;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated bytes in     = 8;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated bytes not_in = 9;
+
+    // WellKnown rules provide advanced constraints against common byte
+    // patterns
+    oneof well_known {
+        // Ip specifies that the field must be a valid IP (v4 or v6) address in
+        // byte format
+        bool ip   = 10;
+
+        // Ipv4 specifies that the field must be a valid IPv4 address in byte
+        // format
+        bool ipv4 = 11;
+
+        // Ipv6 specifies that the field must be a valid IPv6 address in byte
+        // format
+        bool ipv6 = 12;
+    }
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 14;
+}
+
+// EnumRules describe the constraints applied to enum values
+message EnumRules {
+    // Const specifies that this field must be exactly the specified value
+    optional int32 const        = 1;
+
+    // DefinedOnly specifies that this field must be only one of the defined
+    // values for this enum, failing on any undefined value.
+    optional bool  defined_only = 2;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated int32 in           = 3;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated int32 not_in       = 4;
+}
+
+// MessageRules describe the constraints applied to embedded message values.
+// For message-type fields, validation is performed recursively.
+message MessageRules {
+    // Skip specifies that the validation rules of this field should not be
+    // evaluated
+    optional bool skip     = 1;
+
+    // Required specifies that this field must be set
+    optional bool required = 2;
+}
+
+// RepeatedRules describe the constraints applied to `repeated` values
+message RepeatedRules {
+    // MinItems specifies that this field must have the specified number of
+    // items at a minimum
+    optional uint64 min_items = 1;
+
+    // MaxItems specifies that this field must have the specified number of
+    // items at a maximum
+    optional uint64 max_items = 2;
+
+    // Unique specifies that all elements in this field must be unique. This
+    // contraint is only applicable to scalar and enum types (messages are not
+    // supported).
+    optional bool   unique    = 3;
+
+    // Items specifies the contraints to be applied to each item in the field.
+    // Repeated message fields will still execute validation against each item
+    // unless skip is specified here.
+    optional FieldRules items = 4;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 5;
+}
+
+// MapRules describe the constraints applied to `map` values
+message MapRules {
+    // MinPairs specifies that this field must have the specified number of
+    // KVs at a minimum
+    optional uint64 min_pairs = 1;
+
+    // MaxPairs specifies that this field must have the specified number of
+    // KVs at a maximum
+    optional uint64 max_pairs = 2;
+
+    // NoSparse specifies values in this field cannot be unset. This only
+    // applies to map's with message value types.
+    optional bool no_sparse = 3;
+
+    // Keys specifies the constraints to be applied to each key in the field.
+    optional FieldRules keys   = 4;
+
+    // Values specifies the constraints to be applied to the value of each key
+    // in the field. Message values will still have their validations evaluated
+    // unless skip is specified here.
+    optional FieldRules values = 5;
+
+    // IgnoreEmpty specifies that the validation rules of this field should be
+    // evaluated only if the field is not empty
+    optional bool ignore_empty = 6;
+}
+
+// AnyRules describe constraints applied exclusively to the
+// `google.protobuf.Any` well-known type
+message AnyRules {
+    // Required specifies that this field must be set
+    optional bool required = 1;
+
+    // In specifies that this field's `type_url` must be equal to one of the
+    // specified values.
+    repeated string in     = 2;
+
+    // NotIn specifies that this field's `type_url` must not be equal to any of
+    // the specified values.
+    repeated string not_in = 3;
+}
+
+// DurationRules describe the constraints applied exclusively to the
+// `google.protobuf.Duration` well-known type
+message DurationRules {
+    // Required specifies that this field must be set
+    optional bool required = 1;
+
+    // Const specifies that this field must be exactly the specified value
+    optional google.protobuf.Duration const = 2;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional google.protobuf.Duration lt = 3;
+
+    // Lt specifies that this field must be less than the specified value,
+    // inclusive
+    optional google.protobuf.Duration lte = 4;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive
+    optional google.protobuf.Duration gt = 5;
+
+    // Gte specifies that this field must be greater than the specified value,
+    // inclusive
+    optional google.protobuf.Duration gte = 6;
+
+    // In specifies that this field must be equal to one of the specified
+    // values
+    repeated google.protobuf.Duration in = 7;
+
+    // NotIn specifies that this field cannot be equal to one of the specified
+    // values
+    repeated google.protobuf.Duration not_in = 8;
+}
+
+// TimestampRules describe the constraints applied exclusively to the
+// `google.protobuf.Timestamp` well-known type
+message TimestampRules {
+    // Required specifies that this field must be set
+    optional bool required = 1;
+
+    // Const specifies that this field must be exactly the specified value
+    optional google.protobuf.Timestamp const = 2;
+
+    // Lt specifies that this field must be less than the specified value,
+    // exclusive
+    optional google.protobuf.Timestamp lt = 3;
+
+    // Lte specifies that this field must be less than the specified value,
+    // inclusive
+    optional google.protobuf.Timestamp lte = 4;
+
+    // Gt specifies that this field must be greater than the specified value,
+    // exclusive
+    optional google.protobuf.Timestamp gt = 5;
+
+    // Gte specifies that this field must be greater than the specified value,
+    // inclusive
+    optional google.protobuf.Timestamp gte = 6;
+
+    // LtNow specifies that this must be less than the current time. LtNow
+    // can only be used with the Within rule.
+    optional bool lt_now  = 7;
+
+    // GtNow specifies that this must be greater than the current time. GtNow
+    // can only be used with the Within rule.
+    optional bool gt_now  = 8;
+
+    // Within specifies that this field must be within this duration of the
+    // current time. This constraint can be used alone or with the LtNow and
+    // GtNow rules.
+    optional google.protobuf.Duration within = 9;
+}
diff --git a/xds/third_party/xds/LICENSE b/xds/third_party/xds/LICENSE
new file mode 100644
index 00000000000..261eeb9e9f8
--- /dev/null
+++ b/xds/third_party/xds/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.
diff --git a/xds/third_party/xds/import.sh b/xds/third_party/xds/import.sh
new file mode 100755
index 00000000000..7af5c8489d1
--- /dev/null
+++ b/xds/third_party/xds/import.sh
@@ -0,0 +1,79 @@
+#!/bin/bash
+# Copyright 2018 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.
+
+# Update VERSION then execute this script
+
+set -e
+# import VERSION from one of the google internal CLs
+VERSION=2ac532fd44436293585084f8d94c6bdb17835af0
+DOWNLOAD_URL="https://github.com/cncf/xds/archive/${VERSION}.tar.gz"
+DOWNLOAD_BASE_DIR="xds-${VERSION}"
+SOURCE_PROTO_BASE_DIR="${DOWNLOAD_BASE_DIR}"
+TARGET_PROTO_BASE_DIR=src/main/proto
+# Sorted alphabetically.
+FILES=(
+udpa/annotations/migrate.proto
+udpa/annotations/security.proto
+udpa/annotations/security.proto
+udpa/annotations/sensitive.proto
+udpa/annotations/status.proto
+udpa/annotations/versioning.proto
+udpa/type/v1/typed_struct.proto
+xds/annotations/v3/migrate.proto
+xds/annotations/v3/security.proto
+xds/annotations/v3/security.proto
+xds/annotations/v3/sensitive.proto
+xds/annotations/v3/status.proto
+xds/annotations/v3/versioning.proto
+xds/core/v3/authority.proto
+xds/core/v3/collection_entry.proto
+xds/core/v3/context_params.proto
+xds/core/v3/cidr.proto
+xds/core/v3/extension.proto
+xds/core/v3/resource_locator.proto
+xds/core/v3/resource_name.proto
+xds/data/orca/v3/orca_load_report.proto
+xds/service/orca/v3/orca.proto
+xds/type/matcher/v3/cel.proto
+xds/type/matcher/v3/matcher.proto
+xds/type/matcher/v3/regex.proto
+xds/type/matcher/v3/string.proto
+xds/type/v3/cel.proto
+xds/type/matcher/v3/http_inputs.proto
+xds/type/v3/typed_struct.proto
+)
+
+pushd `git rev-parse --show-toplevel`/xds/third_party/xds
+
+# put the repo in a tmp directory
+tmpdir="$(mktemp -d)"
+trap "rm -rf ${tmpdir}" EXIT
+curl -Ls "${DOWNLOAD_URL}" | tar xz -C "${tmpdir}"
+
+cp -p "${tmpdir}/${DOWNLOAD_BASE_DIR}/LICENSE" LICENSE
+
+rm -rf "${TARGET_PROTO_BASE_DIR}"
+mkdir -p "${TARGET_PROTO_BASE_DIR}"
+pushd "${TARGET_PROTO_BASE_DIR}"
+
+# copy proto files to project directory
+for file in "${FILES[@]}"
+do
+  mkdir -p "$(dirname "${file}")"
+  cp -p "${tmpdir}/${SOURCE_PROTO_BASE_DIR}/${file}" "${file}"
+done
+popd
+
+popd
diff --git a/xds/third_party/xds/src/main/proto/udpa/annotations/migrate.proto b/xds/third_party/xds/src/main/proto/udpa/annotations/migrate.proto
new file mode 100644
index 00000000000..5f5f389b7d2
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/udpa/annotations/migrate.proto
@@ -0,0 +1,55 @@
+// THIS FILE IS DEPRECATED
+// Users should instead use the corresponding proto in the xds tree.
+// No new changes will be accepted here.
+
+syntax = "proto3";
+
+package udpa.annotations;
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "github.com/cncf/xds/go/udpa/annotations";
+
+// Magic number in this file derived from top 28bit of SHA256 digest of
+// "udpa.annotation.migrate".
+
+extend google.protobuf.MessageOptions {
+  MigrateAnnotation message_migrate = 171962766;
+}
+
+extend google.protobuf.FieldOptions {
+  FieldMigrateAnnotation field_migrate = 171962766;
+}
+
+extend google.protobuf.EnumOptions {
+  MigrateAnnotation enum_migrate = 171962766;
+}
+
+extend google.protobuf.EnumValueOptions {
+  MigrateAnnotation enum_value_migrate = 171962766;
+}
+
+extend google.protobuf.FileOptions {
+  FileMigrateAnnotation file_migrate = 171962766;
+}
+
+message MigrateAnnotation {
+  // Rename the message/enum/enum value in next version.
+  string rename = 1;
+}
+
+message FieldMigrateAnnotation {
+  // Rename the field in next version.
+  string rename = 1;
+
+  // Add the field to a named oneof in next version. If this already exists, the
+  // field will join its siblings under the oneof, otherwise a new oneof will be
+  // created with the given name.
+  string oneof_promotion = 2;
+}
+
+message FileMigrateAnnotation {
+  // Move all types in the file to another package, this implies changing proto
+  // file path.
+  string move_to_package = 2;
+}
diff --git a/xds/third_party/xds/src/main/proto/udpa/annotations/security.proto b/xds/third_party/xds/src/main/proto/udpa/annotations/security.proto
new file mode 100644
index 00000000000..0ef919716da
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/udpa/annotations/security.proto
@@ -0,0 +1,34 @@
+// THIS FILE IS DEPRECATED
+// Users should instead use the corresponding proto in the xds tree.
+// No new changes will be accepted here.
+
+syntax = "proto3";
+
+package udpa.annotations;
+
+import "udpa/annotations/status.proto";
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "github.com/cncf/xds/go/udpa/annotations";
+
+// All annotations in this file are experimental and subject to change. Their
+// only consumer today is the Envoy APIs and SecuritAnnotationValidator protoc
+// plugin in this repository.
+option (udpa.annotations.file_status).work_in_progress = true;
+
+extend google.protobuf.FieldOptions {
+  // Magic number is the 28 most significant bits in the sha256sum of
+  // "udpa.annotations.security".
+  FieldSecurityAnnotation security = 11122993;
+}
+
+// These annotations indicate metadata for the purpose of understanding the
+// security significance of fields.
+message FieldSecurityAnnotation {
+  // Field should be set in the presence of untrusted downstreams.
+  bool configure_for_untrusted_downstream = 1;
+
+  // Field should be set in the presence of untrusted upstreams.
+  bool configure_for_untrusted_upstream = 2;
+}
diff --git a/xds/third_party/xds/src/main/proto/udpa/annotations/sensitive.proto b/xds/third_party/xds/src/main/proto/udpa/annotations/sensitive.proto
new file mode 100644
index 00000000000..c7d8af608be
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/udpa/annotations/sensitive.proto
@@ -0,0 +1,20 @@
+// THIS FILE IS DEPRECATED
+// Users should instead use the corresponding proto in the xds tree.
+// No new changes will be accepted here.
+
+syntax = "proto3";
+
+package udpa.annotations;
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "github.com/cncf/xds/go/udpa/annotations";
+
+extend google.protobuf.FieldOptions {
+  // Magic number is the 28 most significant bits in the sha256sum of "udpa.annotations.sensitive".
+  // When set to true, `sensitive` indicates that this field contains sensitive data, such as
+  // personally identifiable information, passwords, or private keys, and should be redacted for
+  // display by tools aware of this annotation. Note that that this has no effect on standard
+  // Protobuf functions such as `TextFormat::PrintToString`.
+  bool sensitive = 76569463;
+}
diff --git a/xds/third_party/xds/src/main/proto/udpa/annotations/status.proto b/xds/third_party/xds/src/main/proto/udpa/annotations/status.proto
new file mode 100644
index 00000000000..5a90bde29c7
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/udpa/annotations/status.proto
@@ -0,0 +1,40 @@
+// THIS FILE IS DEPRECATED
+// Users should instead use the corresponding proto in the xds tree.
+// No new changes will be accepted here.
+
+syntax = "proto3";
+
+package udpa.annotations;
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "github.com/cncf/xds/go/udpa/annotations";
+
+// Magic number in this file derived from top 28bit of SHA256 digest of
+// "udpa.annotation.status".
+extend google.protobuf.FileOptions {
+  StatusAnnotation file_status = 222707719;
+}
+
+enum PackageVersionStatus {
+  // Unknown package version status.
+  UNKNOWN = 0;
+
+  // This version of the package is frozen.
+  FROZEN = 1;
+
+  // This version of the package is the active development version.
+  ACTIVE = 2;
+
+  // This version of the package is the candidate for the next major version. It
+  // is typically machine generated from the active development version.
+  NEXT_MAJOR_VERSION_CANDIDATE = 3;
+}
+
+message StatusAnnotation {
+  // The entity is work-in-progress and subject to breaking changes.
+  bool work_in_progress = 1;
+
+  // The entity belongs to a package with the given version status.
+  PackageVersionStatus package_version_status = 2;
+}
diff --git a/xds/third_party/xds/src/main/proto/udpa/annotations/versioning.proto b/xds/third_party/xds/src/main/proto/udpa/annotations/versioning.proto
new file mode 100644
index 00000000000..06df78d818f
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/udpa/annotations/versioning.proto
@@ -0,0 +1,23 @@
+// THIS FILE IS DEPRECATED
+// Users should instead use the corresponding proto in the xds tree.
+// No new changes will be accepted here.
+
+syntax = "proto3";
+
+package udpa.annotations;
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "github.com/cncf/xds/go/udpa/annotations";
+
+extend google.protobuf.MessageOptions {
+  // Magic number derived from 0x78 ('x') 0x44 ('D') 0x53 ('S')
+  VersioningAnnotation versioning = 7881811;
+}
+
+message VersioningAnnotation {
+  // Track the previous message type. E.g. this message might be
+  // udpa.foo.v3alpha.Foo and it was previously udpa.bar.v2.Bar. This
+  // information is consumed by UDPA via proto descriptors.
+  string previous_message_type = 1;
+}
diff --git a/xds/third_party/xds/src/main/proto/udpa/type/v1/typed_struct.proto b/xds/third_party/xds/src/main/proto/udpa/type/v1/typed_struct.proto
new file mode 100644
index 00000000000..10eaef1a661
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/udpa/type/v1/typed_struct.proto
@@ -0,0 +1,46 @@
+// THIS FILE IS DEPRECATED
+// Users should instead use the corresponding proto in the xds tree.
+// No new changes will be accepted here.
+
+syntax = "proto3";
+
+package udpa.type.v1;
+
+option java_outer_classname = "TypedStructProto";
+option java_multiple_files = true;
+option java_package = "com.github.udpa.udpa.type.v1";
+option go_package = "github.com/cncf/xds/go/udpa/type/v1";
+
+import "google/protobuf/struct.proto";
+
+// A TypedStruct contains an arbitrary JSON serialized protocol buffer message with a URL that
+// describes the type of the serialized message. This is very similar to google.protobuf.Any,
+// instead of having protocol buffer binary, this employs google.protobuf.Struct as value.
+//
+// This message is intended to be embedded inside Any, so it shouldn't be directly referred
+// from other UDPA messages.
+//
+// When packing an opaque extension config, packing the expected type into Any is preferred
+// wherever possible for its efficiency. TypedStruct should be used only if a proto descriptor
+// is not available, for example if:
+// - A control plane sends opaque message that is originally from external source in human readable
+//   format such as JSON or YAML.
+// - The control plane doesn't have the knowledge of the protocol buffer schema hence it cannot
+//   serialize the message in protocol buffer binary format.
+// - The DPLB doesn't have have the knowledge of the protocol buffer schema its plugin or extension
+//   uses. This has to be indicated in the DPLB capability negotiation.
+//
+// When a DPLB receives a TypedStruct in Any, it should:
+// - Check if the type_url of the TypedStruct matches the type the extension expects.
+// - Convert value to the type described in type_url and perform validation.
+// TODO(lizan): Figure out how TypeStruct should be used with DPLB extensions that doesn't link
+// protobuf descriptor with DPLB itself, (e.g. gRPC LB Plugin, Envoy WASM extensions).
+message TypedStruct {
+  // A URL that uniquely identifies the type of the serialize protocol buffer message.
+  // This has same semantics and format described in google.protobuf.Any:
+  // https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto
+  string type_url = 1;
+
+  // A JSON representation of the above specified type.
+  google.protobuf.Struct value = 2;
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/annotations/v3/migrate.proto b/xds/third_party/xds/src/main/proto/xds/annotations/v3/migrate.proto
new file mode 100644
index 00000000000..13859274c85
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/annotations/v3/migrate.proto
@@ -0,0 +1,46 @@
+syntax = "proto3";
+
+package xds.annotations.v3;
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "github.com/cncf/xds/go/xds/annotations/v3";
+
+// Magic number in this file derived from top 28bit of SHA256 digest of
+// "xds.annotation.v3.migrate".
+extend google.protobuf.MessageOptions {
+  MigrateAnnotation message_migrate = 112948430;
+}
+extend google.protobuf.FieldOptions {
+  FieldMigrateAnnotation field_migrate = 112948430;
+}
+extend google.protobuf.EnumOptions {
+  MigrateAnnotation enum_migrate = 112948430;
+}
+extend google.protobuf.EnumValueOptions {
+  MigrateAnnotation enum_value_migrate = 112948430;
+}
+extend google.protobuf.FileOptions {
+  FileMigrateAnnotation file_migrate = 112948430;
+}
+
+message MigrateAnnotation {
+  // Rename the message/enum/enum value in next version.
+  string rename = 1;
+}
+
+message FieldMigrateAnnotation {
+  // Rename the field in next version.
+  string rename = 1;
+
+  // Add the field to a named oneof in next version. If this already exists, the
+  // field will join its siblings under the oneof, otherwise a new oneof will be
+  // created with the given name.
+  string oneof_promotion = 2;
+}
+
+message FileMigrateAnnotation {
+  // Move all types in the file to another package, this implies changing proto
+  // file path.
+  string move_to_package = 2;
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/annotations/v3/security.proto b/xds/third_party/xds/src/main/proto/xds/annotations/v3/security.proto
new file mode 100644
index 00000000000..f1f9f40da0a
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/annotations/v3/security.proto
@@ -0,0 +1,30 @@
+syntax = "proto3";
+
+package xds.annotations.v3;
+
+import "xds/annotations/v3/status.proto";
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "github.com/cncf/xds/go/xds/annotations/v3";
+
+// All annotations in this file are experimental and subject to change. Their
+// only consumer today is the Envoy APIs and SecuritAnnotationValidator protoc
+// plugin in this repository.
+option (xds.annotations.v3.file_status).work_in_progress = true;
+
+extend google.protobuf.FieldOptions {
+  // Magic number is the 28 most significant bits in the sha256sum of
+  // "xds.annotations.v3.security".
+  FieldSecurityAnnotation security = 99044135;
+}
+
+// These annotations indicate metadata for the purpose of understanding the
+// security significance of fields.
+message FieldSecurityAnnotation {
+  // Field should be set in the presence of untrusted downstreams.
+  bool configure_for_untrusted_downstream = 1;
+
+  // Field should be set in the presence of untrusted upstreams.
+  bool configure_for_untrusted_upstream = 2;
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/annotations/v3/sensitive.proto b/xds/third_party/xds/src/main/proto/xds/annotations/v3/sensitive.proto
new file mode 100644
index 00000000000..e2cc0b792ef
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/annotations/v3/sensitive.proto
@@ -0,0 +1,16 @@
+syntax = "proto3";
+
+package xds.annotations.v3;
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "github.com/cncf/xds/go/xds/annotations/v3";
+
+extend google.protobuf.FieldOptions {
+  // Magic number is the 28 most significant bits in the sha256sum of "xds.annotations.v3.sensitive".
+  // When set to true, `sensitive` indicates that this field contains sensitive data, such as
+  // personally identifiable information, passwords, or private keys, and should be redacted for
+  // display by tools aware of this annotation. Note that that this has no effect on standard
+  // Protobuf functions such as `TextFormat::PrintToString`.
+  bool sensitive = 61008053;
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/annotations/v3/status.proto b/xds/third_party/xds/src/main/proto/xds/annotations/v3/status.proto
new file mode 100644
index 00000000000..367e784f671
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/annotations/v3/status.proto
@@ -0,0 +1,59 @@
+syntax = "proto3";
+
+package xds.annotations.v3;
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "github.com/cncf/xds/go/xds/annotations/v3";
+
+// Magic number in this file derived from top 28bit of SHA256 digest of
+// "xds.annotations.v3.status".
+extend google.protobuf.FileOptions {
+  FileStatusAnnotation file_status = 226829418;
+}
+
+extend google.protobuf.MessageOptions {
+  MessageStatusAnnotation message_status = 226829418;
+}
+
+extend google.protobuf.FieldOptions {
+  FieldStatusAnnotation field_status = 226829418;
+}
+
+message FileStatusAnnotation {
+  // The entity is work-in-progress and subject to breaking changes.
+  bool work_in_progress = 1;
+}
+
+message MessageStatusAnnotation {
+  // The entity is work-in-progress and subject to breaking changes.
+  bool work_in_progress = 1;
+}
+
+message FieldStatusAnnotation {
+  // The entity is work-in-progress and subject to breaking changes.
+  bool work_in_progress = 1;
+}
+
+enum PackageVersionStatus {
+  // Unknown package version status.
+  UNKNOWN = 0;
+
+  // This version of the package is frozen.
+  FROZEN = 1;
+
+  // This version of the package is the active development version.
+  ACTIVE = 2;
+
+  // This version of the package is the candidate for the next major version. It
+  // is typically machine generated from the active development version.
+  NEXT_MAJOR_VERSION_CANDIDATE = 3;
+}
+
+message StatusAnnotation {
+  // The entity is work-in-progress and subject to breaking changes.
+  bool work_in_progress = 1;
+
+  // The entity belongs to a package with the given version status.
+  PackageVersionStatus package_version_status = 2;
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/annotations/v3/versioning.proto b/xds/third_party/xds/src/main/proto/xds/annotations/v3/versioning.proto
new file mode 100644
index 00000000000..b6440f1949b
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/annotations/v3/versioning.proto
@@ -0,0 +1,20 @@
+syntax = "proto3";
+
+package xds.annotations.v3;
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "github.com/cncf/xds/go/xds/annotations/v3";
+
+extend google.protobuf.MessageOptions {
+  // Magic number is the 28 most significant bits in the sha256sum of
+  // "xds.annotations.v3.versioning".
+  VersioningAnnotation versioning = 92389011;
+}
+
+message VersioningAnnotation {
+  // Track the previous message type. E.g. this message might be
+  // xds.foo.v3alpha.Foo and it was previously xds.bar.v2.Bar. This
+  // information is consumed by UDPA via proto descriptors.
+  string previous_message_type = 1;
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/core/v3/authority.proto b/xds/third_party/xds/src/main/proto/xds/core/v3/authority.proto
new file mode 100644
index 00000000000..d666c38eafa
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/core/v3/authority.proto
@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+package xds.core.v3;
+
+import "xds/annotations/v3/status.proto";
+
+import "validate/validate.proto";
+
+option java_outer_classname = "AuthorityProto";
+option java_multiple_files = true;
+option java_package = "com.github.xds.core.v3";
+option go_package = "github.com/cncf/xds/go/xds/core/v3";
+
+option (xds.annotations.v3.file_status).work_in_progress = true;
+
+// xDS authority information.
+message Authority {
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // .. space reserved for additional authority addressing information, e.g. for
+  // resource signing, items such as CA trust chain, cert pinning may be added.
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/core/v3/cidr.proto b/xds/third_party/xds/src/main/proto/xds/core/v3/cidr.proto
new file mode 100644
index 00000000000..b8471bc8078
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/core/v3/cidr.proto
@@ -0,0 +1,25 @@
+syntax = "proto3";
+
+package xds.core.v3;
+
+import "xds/annotations/v3/status.proto";
+import "google/protobuf/wrappers.proto";
+
+import "validate/validate.proto";
+
+option java_outer_classname = "CidrRangeProto";
+option java_multiple_files = true;
+option java_package = "com.github.xds.core.v3";
+option go_package = "github.com/cncf/xds/go/xds/core/v3";
+
+option (xds.annotations.v3.file_status).work_in_progress = true;
+
+// CidrRange specifies an IP Address and a prefix length to construct
+// the subnet mask for a `CIDR <https://tools.ietf.org/html/rfc4632>`_ range.
+message CidrRange {
+  // IPv4 or IPv6 address, e.g. ``192.0.0.0`` or ``2001:db8::``.
+  string address_prefix = 1 [(validate.rules).string = {min_len: 1}];
+
+  // Length of prefix, e.g. 0, 32. Defaults to 0 when unset.
+  google.protobuf.UInt32Value prefix_len = 2 [(validate.rules).uint32 = {lte: 128}];
+}
\ No newline at end of file
diff --git a/xds/third_party/xds/src/main/proto/xds/core/v3/collection_entry.proto b/xds/third_party/xds/src/main/proto/xds/core/v3/collection_entry.proto
new file mode 100644
index 00000000000..c844d614e4f
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/core/v3/collection_entry.proto
@@ -0,0 +1,55 @@
+syntax = "proto3";
+
+package xds.core.v3;
+
+import "google/protobuf/any.proto";
+
+import "xds/annotations/v3/status.proto";
+import "xds/core/v3/resource_locator.proto";
+
+import "validate/validate.proto";
+
+option java_outer_classname = "CollectionEntryProto";
+option java_multiple_files = true;
+option java_package = "com.github.xds.core.v3";
+option go_package = "github.com/cncf/xds/go/xds/core/v3";
+
+option (xds.annotations.v3.file_status).work_in_progress = true;
+
+// xDS collection resource wrapper. This encapsulates a xDS resource when
+// appearing inside a list collection resource. List collection resources are
+// regular Resource messages of type:
+//
+// .. code-block:: proto
+//
+//   message <T>Collection {
+//     repeated CollectionEntry resources = 1;
+//   }
+//
+message CollectionEntry {
+  // Inlined resource entry.
+  message InlineEntry {
+    // Optional name to describe the inlined resource. Resource names must match
+    // ``[a-zA-Z0-9_-\./]+`` (TODO(htuch): turn this into a PGV constraint once
+    // finalized, probably should be a RFC3986 pchar). This name allows
+    // reference via the #entry directive in ResourceLocator.
+    string name = 1 [(validate.rules).string.pattern = "^[0-9a-zA-Z_\\-\\.~:]+$"];
+
+    // The resource's logical version. It is illegal to have the same named xDS
+    // resource name at a given version with different resource payloads.
+    string version = 2;
+
+    // The resource payload, including type URL.
+    google.protobuf.Any resource = 3;
+  }
+
+  oneof resource_specifier {
+    option (validate.required) = true;
+
+    // A resource locator describing how the member resource is to be located.
+    ResourceLocator locator = 1;
+
+    // The resource is inlined in the list collection.
+    InlineEntry inline_entry = 2;
+  }
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/core/v3/context_params.proto b/xds/third_party/xds/src/main/proto/xds/core/v3/context_params.proto
new file mode 100644
index 00000000000..a42c7a85960
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/core/v3/context_params.proto
@@ -0,0 +1,23 @@
+syntax = "proto3";
+
+package xds.core.v3;
+
+import "xds/annotations/v3/status.proto";
+
+option java_outer_classname = "ContextParamsProto";
+option java_multiple_files = true;
+option java_package = "com.github.xds.core.v3";
+option go_package = "github.com/cncf/xds/go/xds/core/v3";
+
+option (xds.annotations.v3.file_status).work_in_progress = true;
+
+// Additional parameters that can be used to select resource variants. These include any
+// global context parameters, per-resource type client feature capabilities and per-resource
+// type functional attributes. All per-resource type attributes will be `xds.resource.`
+// prefixed and some of these are documented below:
+//
+// `xds.resource.listening_address`: The value is "IP:port" (e.g. "10.1.1.3:8080") which is
+//   the listening address of a Listener. Used in a Listener resource query.
+message ContextParams {
+    map<string, string> params = 1;
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/core/v3/extension.proto b/xds/third_party/xds/src/main/proto/xds/core/v3/extension.proto
new file mode 100644
index 00000000000..dd489eb9912
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/core/v3/extension.proto
@@ -0,0 +1,26 @@
+syntax = "proto3";
+
+package xds.core.v3;
+
+option java_outer_classname = "ExtensionProto";
+option java_multiple_files = true;
+option java_package = "com.github.xds.core.v3";
+option go_package = "github.com/cncf/xds/go/xds/core/v3";
+
+import "validate/validate.proto";
+import "google/protobuf/any.proto";
+
+// Message type for extension configuration.
+message TypedExtensionConfig {
+  // The name of an extension. This is not used to select the extension, instead
+  // it serves the role of an opaque identifier.
+  string name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // The typed config for the extension. The type URL will be used to identify
+  // the extension. In the case that the type URL is *xds.type.v3.TypedStruct*
+  // (or, for historical reasons, *udpa.type.v1.TypedStruct*), the inner type
+  // URL of *TypedStruct* will be utilized. See the
+  // :ref:`extension configuration overview
+  // <config_overview_extension_configuration>` for further details.
+  google.protobuf.Any typed_config = 2 [(validate.rules).any = {required: true}];
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/core/v3/resource_locator.proto b/xds/third_party/xds/src/main/proto/xds/core/v3/resource_locator.proto
new file mode 100644
index 00000000000..9b40d52fc43
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/core/v3/resource_locator.proto
@@ -0,0 +1,118 @@
+syntax = "proto3";
+
+package xds.core.v3;
+
+import "xds/annotations/v3/status.proto";
+import "xds/core/v3/context_params.proto";
+
+import "validate/validate.proto";
+
+option java_outer_classname = "ResourceLocatorProto";
+option java_multiple_files = true;
+option java_package = "com.github.xds.core.v3";
+option go_package = "github.com/cncf/xds/go/xds/core/v3";
+
+option (xds.annotations.v3.file_status).work_in_progress = true;
+
+// xDS resource locators identify a xDS resource name and instruct the
+// data-plane load balancer on how the resource may be located.
+//
+// Resource locators have a canonical xdstp:// URI representation:
+//
+//   xdstp://{authority}/{type_url}/{id}?{context_params}{#directive,*}
+//
+// where context_params take the form of URI query parameters.
+//
+// Resource locators have a similar canonical http:// URI representation:
+//
+//   http://{authority}/{type_url}/{id}?{context_params}{#directive,*}
+//
+// Resource locators also have a simplified file:// URI representation:
+//
+//   file:///{id}{#directive,*}
+//
+message ResourceLocator {
+  enum Scheme {
+    XDSTP = 0;
+    HTTP = 1;
+    FILE = 2;
+  }
+
+  // URI scheme.
+  Scheme scheme = 1 [(validate.rules).enum = {defined_only: true}];
+
+  // Opaque identifier for the resource. Any '/' will not be escaped during URI
+  // encoding and will form part of the URI path. This may end
+  // with ‘*’ for glob collection references.
+  string id = 2;
+
+  // Logical authority for resource (not necessarily transport network address).
+  // Authorities are opaque in the xDS API, data-plane load balancers will map
+  // them to concrete network transports such as an xDS management server, e.g.
+  // via envoy.config.core.v3.ConfigSource.
+  string authority = 3;
+
+  // Fully qualified resource type (as in type URL without types.googleapis.com/
+  // prefix).
+  string resource_type = 4 [(validate.rules).string = {min_len: 1}];
+
+  oneof context_param_specifier {
+    // Additional parameters that can be used to select resource variants.
+    // Matches must be exact, i.e. all context parameters must match exactly and
+    // there must be no additional context parameters set on the matched
+    // resource.
+    ContextParams exact_context = 5;
+
+    // .. space reserved for future potential matchers, e.g. CEL expressions.
+  }
+
+  // Directives provide information to data-plane load balancers on how xDS
+  // resource names are to be interpreted and potentially further resolved. For
+  // example, they may provide alternative resource locators for when primary
+  // resolution fails. Directives are not part of resource names and do not
+  // appear in a xDS transport discovery request.
+  //
+  // When encoding to URIs, directives take the form:
+  //
+  // <directive name>=<string representation of directive value>
+  //
+  // For example, we can have alt=xdstp://foo/bar or entry=some%20thing. Each
+  // directive value type may have its own string encoding, in the case of
+  // ResourceLocator there is a recursive URI encoding.
+  //
+  // Percent encoding applies to the URI encoding of the directive value.
+  // Multiple directives are comma-separated, so the reserved characters that
+  // require percent encoding in a directive value are [',', '#', '[', ']',
+  // '%']. These are the RFC3986 fragment reserved characters with the addition
+  // of the xDS scheme specific ','. See
+  // https://tools.ietf.org/html/rfc3986#page-49 for further details on URI ABNF
+  // and reserved characters.
+  message Directive {
+    oneof directive {
+      option (validate.required) = true;
+
+      // An alternative resource locator for fallback if the resource is
+      // unavailable. For example, take the resource locator:
+      //
+      //   xdstp://foo/some-type/some-route-table#alt=xdstp://bar/some-type/another-route-table
+      //
+      // If the data-plane load balancer is unable to reach `foo` to fetch the
+      // resource, it will fallback to `bar`. Alternative resources do not need
+      // to have equivalent content, but they should be functional substitutes.
+      ResourceLocator alt = 1;
+
+      // List collections support inlining of resources via the entry field in
+      // Resource. These inlined Resource objects may have an optional name
+      // field specified. When specified, the entry directive allows
+      // ResourceLocator to directly reference these inlined resources, e.g.
+      // xdstp://.../foo#entry=bar.
+      string entry = 2 [(validate.rules).string = {min_len: 1, pattern: "^[0-9a-zA-Z_\\-\\./~:]+$"}];
+    }
+  }
+
+  // A list of directives that appear in the xDS resource locator #fragment.
+  //
+  // When encoding to URI form, directives are percent encoded with comma
+  // separation.
+  repeated Directive directives = 6;
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/core/v3/resource_name.proto b/xds/third_party/xds/src/main/proto/xds/core/v3/resource_name.proto
new file mode 100644
index 00000000000..0f3d9974079
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/core/v3/resource_name.proto
@@ -0,0 +1,42 @@
+syntax = "proto3";
+
+package xds.core.v3;
+
+import "xds/annotations/v3/status.proto";
+import "xds/core/v3/context_params.proto";
+
+import "validate/validate.proto";
+
+option java_outer_classname = "ResourceNameProto";
+option java_multiple_files = true;
+option java_package = "com.github.xds.core.v3";
+option go_package = "github.com/cncf/xds/go/xds/core/v3";
+
+option (xds.annotations.v3.file_status).work_in_progress = true;
+
+// xDS resource name. This has a canonical xdstp:// URI representation:
+//
+//   xdstp://{authority}/{type_url}/{id}?{context_params}
+//
+// where context_params take the form of URI query parameters.
+//
+// A xDS resource name fully identifies a network resource for transport
+// purposes. xDS resource names in this form appear only in discovery
+// request/response messages used with the xDS transport.
+message ResourceName {
+  // Opaque identifier for the resource. Any '/' will not be escaped during URI
+  // encoding and will form part of the URI path.
+  string id = 1;
+
+  // Logical authority for resource (not necessarily transport network address).
+  // Authorities are opaque in the xDS API, data-plane load balancers will map
+  // them to concrete network transports such as an xDS management server.
+  string authority = 2;
+
+  // Fully qualified resource type (as in type URL without types.googleapis.com/
+  // prefix).
+  string resource_type = 3 [(validate.rules).string = {min_len: 1}];
+
+  // Additional parameters that can be used to select resource variants.
+  ContextParams context = 4;
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/data/orca/v3/orca_load_report.proto b/xds/third_party/xds/src/main/proto/xds/data/orca/v3/orca_load_report.proto
new file mode 100644
index 00000000000..1b0847585a4
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/data/orca/v3/orca_load_report.proto
@@ -0,0 +1,58 @@
+syntax = "proto3";
+
+package xds.data.orca.v3;
+
+option java_outer_classname = "OrcaLoadReportProto";
+option java_multiple_files = true;
+option java_package = "com.github.xds.data.orca.v3";
+option go_package = "github.com/cncf/xds/go/xds/data/orca/v3";
+
+import "validate/validate.proto";
+
+// See section `ORCA load report format` of the design document in
+// https://github.com/envoyproxy/envoy/issues/6614.
+
+message OrcaLoadReport {
+  // CPU utilization expressed as a fraction of available CPU resources. This
+  // should be derived from the latest sample or measurement. The value may be
+  // larger than 1.0 when the usage exceeds the reporter dependent notion of
+  // soft limits.
+  double cpu_utilization = 1 [(validate.rules).double.gte = 0];
+
+  // Memory utilization expressed as a fraction of available memory
+  // resources. This should be derived from the latest sample or measurement.
+  double mem_utilization = 2 [(validate.rules).double.gte = 0, (validate.rules).double.lte = 1];
+
+  // Total RPS being served by an endpoint. This should cover all services that an endpoint is
+  // responsible for.
+  // Deprecated -- use ``rps_fractional`` field instead.
+  uint64 rps = 3 [deprecated = true];
+
+  // Application specific requests costs. Each value is an absolute cost (e.g. 3487 bytes of
+  // storage) associated with the request.
+  map<string, double> request_cost = 4;
+
+  // Resource utilization values. Each value is expressed as a fraction of total resources
+  // available, derived from the latest sample or measurement.
+  map<string, double> utilization = 5
+      [(validate.rules).map.values.double.gte = 0, (validate.rules).map.values.double.lte = 1];
+
+  // Total RPS being served by an endpoint. This should cover all services that an endpoint is
+  // responsible for.
+  double rps_fractional = 6 [(validate.rules).double.gte = 0];
+
+  // Total EPS (errors/second) being served by an endpoint. This should cover
+  // all services that an endpoint is responsible for.
+  double eps = 7 [(validate.rules).double.gte = 0];
+
+  // Application specific opaque metrics.
+  map<string, double> named_metrics = 8;
+
+  // Application specific utilization expressed as a fraction of available
+  // resources. For example, an application may report the max of CPU and memory
+  // utilization for better load balancing if it is both CPU and memory bound.
+  // This should be derived from the latest sample or measurement.
+  // The value may be larger than 1.0 when the usage exceeds the reporter
+  // dependent notion of soft limits.
+  double application_utilization = 9 [(validate.rules).double.gte = 0];
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/service/orca/v3/orca.proto b/xds/third_party/xds/src/main/proto/xds/service/orca/v3/orca.proto
new file mode 100644
index 00000000000..03126cdcaa6
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/service/orca/v3/orca.proto
@@ -0,0 +1,36 @@
+syntax = "proto3";
+
+package xds.service.orca.v3;
+
+option java_outer_classname = "OrcaProto";
+option java_multiple_files = true;
+option java_package = "com.github.xds.service.orca.v3";
+option go_package = "github.com/cncf/xds/go/xds/service/orca/v3";
+
+import "xds/data/orca/v3/orca_load_report.proto";
+
+import "google/protobuf/duration.proto";
+
+// See section `Out-of-band (OOB) reporting` of the design document in
+// :ref:`https://github.com/envoyproxy/envoy/issues/6614`.
+
+// Out-of-band (OOB) load reporting service for the additional load reporting
+// agent that does not sit in the request path. Reports are periodically sampled
+// with sufficient frequency to provide temporal association with requests.
+// OOB reporting compensates the limitation of in-band reporting in revealing
+// costs for backends that do not provide a steady stream of telemetry such as
+// long running stream operations and zero QPS services. This is a server
+// streaming service, client needs to terminate current RPC and initiate
+// a new call to change backend reporting frequency.
+service OpenRcaService {
+  rpc StreamCoreMetrics(OrcaLoadReportRequest) returns (stream xds.data.orca.v3.OrcaLoadReport);
+}
+
+message OrcaLoadReportRequest {
+  // Interval for generating Open RCA core metric responses.
+  google.protobuf.Duration report_interval = 1;
+  // Request costs to collect. If this is empty, all known requests costs tracked by
+  // the load reporting agent will be returned. This provides an opportunity for
+  // the client to selectively obtain a subset of tracked costs.
+  repeated string request_cost_names = 2;
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/cel.proto b/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/cel.proto
new file mode 100644
index 00000000000..a45af9534a0
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/cel.proto
@@ -0,0 +1,37 @@
+syntax = "proto3";
+
+package xds.type.matcher.v3;
+
+import "xds/type/v3/cel.proto";
+import "validate/validate.proto";
+
+option java_package = "com.github.xds.type.matcher.v3";
+option java_outer_classname = "CelProto";
+option java_multiple_files = true;
+option go_package = "github.com/cncf/xds/go/xds/type/matcher/v3";
+
+// [#protodoc-title: Common Expression Language (CEL) matchers]
+
+// Performs a match by evaluating a `Common Expression Language
+// <https://github.com/google/cel-spec>`_ (CEL) expression against the standardized set of
+// :ref:`HTTP attributes <arch_overview_attributes>` specified via ``HttpAttributesCelMatchInput``.
+//
+// .. attention::
+//
+//   The match is ``true``, iff the result of the evaluation is a bool AND true.
+//   In all other cases, the match is ``false``, including but not limited to: non-bool types,
+//   ``false``, ``null``, ``int(1)``, etc.
+//   In case CEL expression raises an error, the result of the evaluation is interpreted "no match".
+//
+// Refer to :ref:`Unified Matcher API <envoy_v3_api_msg_.xds.type.matcher.v3.Matcher>` documentation
+// for usage details.
+//
+// [#comment: envoy.matching.matchers.cel_matcher]
+message CelMatcher {
+  // Either parsed or checked representation of the CEL program.
+  type.v3.CelExpression expr_match = 1 [(validate.rules).message = {required: true}];
+
+  // Free-form description of the CEL AST, e.g. the original expression text, to be
+  // used for debugging assistance.
+  string description = 2;
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/http_inputs.proto b/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/http_inputs.proto
new file mode 100644
index 00000000000..5709d64501b
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/http_inputs.proto
@@ -0,0 +1,23 @@
+syntax = "proto3";
+
+package xds.type.matcher.v3;
+
+option java_package = "com.github.xds.type.matcher.v3";
+option java_outer_classname = "HttpInputsProto";
+option java_multiple_files = true;
+option go_package = "github.com/cncf/xds/go/xds/type/matcher/v3";
+
+// [#protodoc-title: Common HTTP Inputs]
+
+// Specifies that matching should be performed on the set of :ref:`HTTP attributes
+// <arch_overview_attributes>`.
+//
+// The attributes will be exposed via `Common Expression Language
+// <https://github.com/google/cel-spec>`_ runtime to associated CEL matcher.
+//
+// Refer to :ref:`Unified Matcher API <envoy_v3_api_msg_.xds.type.matcher.v3.Matcher>` documentation
+// for usage details.
+//
+// [#comment: envoy.matching.inputs.cel_data_input]
+message HttpAttributesCelMatchInput {
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/matcher.proto b/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/matcher.proto
new file mode 100644
index 00000000000..cc03ff6e98f
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/matcher.proto
@@ -0,0 +1,144 @@
+syntax = "proto3";
+
+package xds.type.matcher.v3;
+
+import "xds/core/v3/extension.proto";
+import "xds/type/matcher/v3/string.proto";
+
+import "validate/validate.proto";
+
+option java_package = "com.github.xds.type.matcher.v3";
+option java_outer_classname = "MatcherProto";
+option java_multiple_files = true;
+option go_package = "github.com/cncf/xds/go/xds/type/matcher/v3";
+
+// [#protodoc-title: Unified Matcher API]
+
+// A matcher, which may traverse a matching tree in order to result in a match action.
+// During matching, the tree will be traversed until a match is found, or if no match
+// is found the action specified by the most specific on_no_match will be evaluated.
+// As an on_no_match might result in another matching tree being evaluated, this process
+// might repeat several times until the final OnMatch (or no match) is decided.
+message Matcher {
+  // What to do if a match is successful.
+  message OnMatch {
+    oneof on_match {
+      option (validate.required) = true;
+
+      // Nested matcher to evaluate.
+      // If the nested matcher does not match and does not specify
+      // on_no_match, then this matcher is considered not to have
+      // matched, even if a predicate at this level or above returned
+      // true.
+      Matcher matcher = 1;
+
+      // Protocol-specific action to take.
+      core.v3.TypedExtensionConfig action = 2;
+    }
+
+    // If true and the Matcher matches, the action will be taken but the caller
+    // will behave as if the Matcher did not match. A subsequent matcher or
+    // on_no_match action will be used instead.
+    // This field is not supported in all contexts in which the matcher API is
+    // used. If this field is set in a context in which it's not supported,
+    // the resource will be rejected.
+    bool keep_matching = 3;
+  }
+
+  // A linear list of field matchers.
+  // The field matchers are evaluated in order, and the first match
+  // wins.
+  message MatcherList {
+    // Predicate to determine if a match is successful.
+    message Predicate {
+      // Predicate for a single input field.
+      message SinglePredicate {
+        // Protocol-specific specification of input field to match on.
+        // [#extension-category: envoy.matching.common_inputs]
+        core.v3.TypedExtensionConfig input = 1 [(validate.rules).message = {required: true}];
+
+        oneof matcher {
+          option (validate.required) = true;
+
+          // Built-in string matcher.
+          type.matcher.v3.StringMatcher value_match = 2;
+
+          // Extension for custom matching logic.
+          // [#extension-category: envoy.matching.input_matchers]
+          core.v3.TypedExtensionConfig custom_match = 3;
+        }
+      }
+
+      // A list of two or more matchers. Used to allow using a list within a oneof.
+      message PredicateList {
+        repeated Predicate predicate = 1 [(validate.rules).repeated = {min_items: 2}];
+      }
+
+      oneof match_type {
+        option (validate.required) = true;
+
+        // A single predicate to evaluate.
+        SinglePredicate single_predicate = 1;
+
+        // A list of predicates to be OR-ed together.
+        PredicateList or_matcher = 2;
+
+        // A list of predicates to be AND-ed together.
+        PredicateList and_matcher = 3;
+
+        // The invert of a predicate
+        Predicate not_matcher = 4;
+      }
+    }
+
+    // An individual matcher.
+    message FieldMatcher {
+      // Determines if the match succeeds.
+      Predicate predicate = 1 [(validate.rules).message = {required: true}];
+
+      // What to do if the match succeeds.
+      OnMatch on_match = 2 [(validate.rules).message = {required: true}];
+    }
+
+    // A list of matchers. First match wins.
+    repeated FieldMatcher matchers = 1 [(validate.rules).repeated = {min_items: 1}];
+  }
+
+  message MatcherTree {
+    // A map of configured matchers. Used to allow using a map within a oneof.
+    message MatchMap {
+      map<string, OnMatch> map = 1 [(validate.rules).map = {min_pairs: 1}];
+    }
+
+    // Protocol-specific specification of input field to match on.
+    core.v3.TypedExtensionConfig input = 1 [(validate.rules).message = {required: true}];
+
+    // Exact or prefix match maps in which to look up the input value.
+    // If the lookup succeeds, the match is considered successful, and
+    // the corresponding OnMatch is used.
+    oneof tree_type {
+      option (validate.required) = true;
+
+      MatchMap exact_match_map = 2;
+
+      // Longest matching prefix wins.
+      MatchMap prefix_match_map = 3;
+
+      // Extension for custom matching logic.
+      core.v3.TypedExtensionConfig custom_match = 4;
+    }
+  }
+
+  oneof matcher_type {
+    // A linear list of matchers to evaluate.
+    MatcherList matcher_list = 1;
+
+    // A match tree to evaluate.
+    MatcherTree matcher_tree = 2;
+  }
+
+  // Optional OnMatch to use if no matcher above matched (e.g., if there are no matchers specified
+  // above, or if none of the matches specified above succeeded).
+  // If no matcher above matched and this field is not populated, the match will be considered unsuccessful.
+  OnMatch on_no_match = 3;
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/regex.proto b/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/regex.proto
new file mode 100644
index 00000000000..3ff4ca95c2c
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/regex.proto
@@ -0,0 +1,46 @@
+syntax = "proto3";
+
+package xds.type.matcher.v3;
+
+import "validate/validate.proto";
+
+option java_package = "com.github.xds.type.matcher.v3";
+option java_outer_classname = "RegexProto";
+option java_multiple_files = true;
+option go_package = "github.com/cncf/xds/go/xds/type/matcher/v3";
+
+// [#protodoc-title: Regex matcher]
+
+// A regex matcher designed for safety when used with untrusted input.
+message RegexMatcher {
+  // Google's `RE2 <https://github.com/google/re2>`_ regex engine. The regex
+  // string must adhere to the documented `syntax
+  // <https://github.com/google/re2/wiki/Syntax>`_. The engine is designed to
+  // complete execution in linear time as well as limit the amount of memory
+  // used.
+  //
+  // Envoy supports program size checking via runtime. The runtime keys
+  // `re2.max_program_size.error_level` and `re2.max_program_size.warn_level`
+  // can be set to integers as the maximum program size or complexity that a
+  // compiled regex can have before an exception is thrown or a warning is
+  // logged, respectively. `re2.max_program_size.error_level` defaults to 100,
+  // and `re2.max_program_size.warn_level` has no default if unset (will not
+  // check/log a warning).
+  //
+  // Envoy emits two stats for tracking the program size of regexes: the
+  // histogram `re2.program_size`, which records the program size, and the
+  // counter `re2.exceeded_warn_level`, which is incremented each time the
+  // program size exceeds the warn level threshold.
+  message GoogleRE2 {}
+
+  oneof engine_type {
+    option (validate.required) = true;
+
+    // Google's RE2 regex engine.
+    GoogleRE2 google_re2 = 1 [ (validate.rules).message = {required : true} ];
+  }
+
+  // The regex match string. The string must be supported by the configured
+  // engine.
+  string regex = 2 [ (validate.rules).string = {min_len : 1} ];
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/string.proto b/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/string.proto
new file mode 100644
index 00000000000..e58cb413e96
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/type/matcher/v3/string.proto
@@ -0,0 +1,71 @@
+syntax = "proto3";
+
+package xds.type.matcher.v3;
+
+import "xds/core/v3/extension.proto";
+import "xds/type/matcher/v3/regex.proto";
+
+import "validate/validate.proto";
+
+option java_package = "com.github.xds.type.matcher.v3";
+option java_outer_classname = "StringProto";
+option java_multiple_files = true;
+option go_package = "github.com/cncf/xds/go/xds/type/matcher/v3";
+
+// [#protodoc-title: String matcher]
+
+// Specifies the way to match a string.
+// [#next-free-field: 9]
+message StringMatcher {
+  oneof match_pattern {
+    option (validate.required) = true;
+
+    // The input string must match exactly the string specified here.
+    //
+    // Examples:
+    //
+    // * *abc* only matches the value *abc*.
+    string exact = 1;
+
+    // The input string must have the prefix specified here.
+    // Note: empty prefix is not allowed, please use regex instead.
+    //
+    // Examples:
+    //
+    // * *abc* matches the value *abc.xyz*
+    string prefix = 2 [(validate.rules).string = {min_len: 1}];
+
+    // The input string must have the suffix specified here.
+    // Note: empty prefix is not allowed, please use regex instead.
+    //
+    // Examples:
+    //
+    // * *abc* matches the value *xyz.abc*
+    string suffix = 3 [(validate.rules).string = {min_len: 1}];
+
+    // The input string must match the regular expression specified here.
+    RegexMatcher safe_regex = 5 [(validate.rules).message = {required: true}];
+
+    // The input string must have the substring specified here.
+    // Note: empty contains match is not allowed, please use regex instead.
+    //
+    // Examples:
+    //
+    // * *abc* matches the value *xyz.abc.def*
+    string contains = 7 [(validate.rules).string = {min_len: 1}];
+
+    // Use an extension as the matcher type.
+    // [#extension-category: envoy.string_matcher]
+    xds.core.v3.TypedExtensionConfig custom = 8;
+  }
+
+  // If true, indicates the exact/prefix/suffix matching should be case insensitive. This has no
+  // effect for the safe_regex match.
+  // For example, the matcher *data* will match both input string *Data* and *data* if set to true.
+  bool ignore_case = 6;
+}
+
+// Specifies a list of ways to match a string.
+message ListStringMatcher {
+  repeated StringMatcher patterns = 1 [(validate.rules).repeated = {min_items: 1}];
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/type/v3/cel.proto b/xds/third_party/xds/src/main/proto/xds/type/v3/cel.proto
new file mode 100644
index 00000000000..043990401c6
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/type/v3/cel.proto
@@ -0,0 +1,77 @@
+syntax = "proto3";
+
+package xds.type.v3;
+
+import "google/api/expr/v1alpha1/checked.proto";
+import "google/api/expr/v1alpha1/syntax.proto";
+import "cel/expr/checked.proto";
+import "cel/expr/syntax.proto";
+import "google/protobuf/wrappers.proto";
+
+import "xds/annotations/v3/status.proto";
+
+import "validate/validate.proto";
+
+option java_package = "com.github.xds.type.v3";
+option java_outer_classname = "CelProto";
+option java_multiple_files = true;
+option go_package = "github.com/cncf/xds/go/xds/type/v3";
+
+option (xds.annotations.v3.file_status).work_in_progress = true;
+
+// [#protodoc-title: Common Expression Language (CEL)]
+
+// Either parsed or checked representation of the `Common Expression Language
+// <https://github.com/google/cel-spec>`_ (CEL) program.
+message CelExpression {
+  oneof expr_specifier {
+    // Parsed expression in abstract syntax tree (AST) form.
+    //
+    // Deprecated -- use ``cel_expr_parsed`` field instead.
+    // If ``cel_expr_parsed`` or ``cel_expr_checked`` is set, this field is not used.
+    google.api.expr.v1alpha1.ParsedExpr parsed_expr = 1  [deprecated = true];
+
+    // Parsed expression in abstract syntax tree (AST) form that has been successfully type checked.
+    //
+    // Deprecated -- use ``cel_expr_checked`` field instead.
+    // If ``cel_expr_parsed`` or ``cel_expr_checked`` is set, this field is not used.
+    google.api.expr.v1alpha1.CheckedExpr checked_expr = 2  [deprecated = true];
+  }
+
+  // Parsed expression in abstract syntax tree (AST) form.
+  //
+  // If ``cel_expr_checked`` is set, this field is not used.
+  cel.expr.ParsedExpr cel_expr_parsed = 3;
+
+  // Parsed expression in abstract syntax tree (AST) form that has been successfully type checked.
+  //
+  // If set, takes precedence over ``cel_expr_parsed``.
+  cel.expr.CheckedExpr cel_expr_checked = 4;
+
+  // Unparsed expression in string form. For example, ``request.headers['x-env'] == 'prod'`` will
+  // get ``x-env`` header value and compare it with ``prod``.
+  // Check the `Common Expression Language <https://github.com/google/cel-spec>`_ for more details.
+  //
+  // If set, takes precedence over ``cel_expr_parsed`` and ``cel_expr_checked``.
+  string cel_expr_string = 5;
+}
+
+// Extracts a string by evaluating a `Common Expression Language
+// <https://github.com/google/cel-spec>`_ (CEL) expression against the standardized set of
+// :ref:`HTTP attributes <arch_overview_attributes>`.
+//
+// .. attention::
+//
+//   Besides CEL evaluation raising an error explicitly, CEL program returning a type other than
+//   the ``string``, or not returning anything, are considered an error as well.
+//
+// [#comment:TODO(sergiitk): When implemented, add the extension tag.]
+message CelExtractString {
+  // The CEL expression used to extract a string from the CEL environment.
+  // the "subject string") that should be replaced.
+  CelExpression expr_extract = 1 [(validate.rules).message = {required: true}];
+
+  // If CEL expression evaluates to an error, this value is be returned to the caller.
+  // If not set, the error is propagated to the caller.
+  google.protobuf.StringValue default_value = 2;
+}
diff --git a/xds/third_party/xds/src/main/proto/xds/type/v3/typed_struct.proto b/xds/third_party/xds/src/main/proto/xds/type/v3/typed_struct.proto
new file mode 100644
index 00000000000..40d0a8dac80
--- /dev/null
+++ b/xds/third_party/xds/src/main/proto/xds/type/v3/typed_struct.proto
@@ -0,0 +1,44 @@
+syntax = "proto3";
+
+package xds.type.v3;
+
+option java_outer_classname = "TypedStructProto";
+option java_multiple_files = true;
+option java_package = "com.github.xds.type.v3";
+option go_package = "github.com/cncf/xds/go/xds/type/v3";
+
+import "google/protobuf/struct.proto";
+
+// A TypedStruct contains an arbitrary JSON serialized protocol buffer message with a URL that
+// describes the type of the serialized message. This is very similar to google.protobuf.Any,
+// instead of having protocol buffer binary, this employs google.protobuf.Struct as value.
+//
+// This message is intended to be embedded inside Any, so it shouldn't be directly referred
+// from other UDPA messages.
+//
+// When packing an opaque extension config, packing the expected type into Any is preferred
+// wherever possible for its efficiency. TypedStruct should be used only if a proto descriptor
+// is not available, for example if:
+//
+// - A control plane sends opaque message that is originally from external source in human readable
+//   format such as JSON or YAML.
+// - The control plane doesn't have the knowledge of the protocol buffer schema hence it cannot
+//   serialize the message in protocol buffer binary format.
+// - The DPLB doesn't have have the knowledge of the protocol buffer schema its plugin or extension
+//   uses. This has to be indicated in the DPLB capability negotiation.
+//
+// When a DPLB receives a TypedStruct in Any, it should:
+// - Check if the type_url of the TypedStruct matches the type the extension expects.
+// - Convert value to the type described in type_url and perform validation.
+//
+// TODO(lizan): Figure out how TypeStruct should be used with DPLB extensions that doesn't link
+// protobuf descriptor with DPLB itself, (e.g. gRPC LB Plugin, Envoy WASM extensions).
+message TypedStruct {
+  // A URL that uniquely identifies the type of the serialize protocol buffer message.
+  // This has same semantics and format described in google.protobuf.Any:
+  // https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/any.proto
+  string type_url = 1;
+
+  // A JSON representation of the above specified type.
+  google.protobuf.Struct value = 2;
+}
diff --git a/xds/third_party/zero-allocation-hashing/LICENSE b/xds/third_party/zero-allocation-hashing/LICENSE
new file mode 100644
index 00000000000..760a01df5b2
--- /dev/null
+++ b/xds/third_party/zero-allocation-hashing/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner].
+
+   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.
\ No newline at end of file
diff --git a/xds/third_party/zero-allocation-hashing/NOTICE b/xds/third_party/zero-allocation-hashing/NOTICE
new file mode 100644
index 00000000000..cf7255542df
--- /dev/null
+++ b/xds/third_party/zero-allocation-hashing/NOTICE
@@ -0,0 +1,4 @@
+zero-allocation-hashing
+Copyright 2015 Higher Frequency Trading http://www.higherfrequencytrading.com
+
+Licensed under Apache License 2.0. See LICENSE for terms.
diff --git a/xds/third_party/zero-allocation-hashing/main/java/io/grpc/xds/XxHash64.java b/xds/third_party/zero-allocation-hashing/main/java/io/grpc/xds/XxHash64.java
new file mode 100644
index 00000000000..9ca9ebc7762
--- /dev/null
+++ b/xds/third_party/zero-allocation-hashing/main/java/io/grpc/xds/XxHash64.java
@@ -0,0 +1,287 @@
+/*
+ * Copyright 2021 Higher Frequency Trading http://www.higherfrequencytrading.com
+ *
+ * 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.
+ */
+/*
+ * Forked from zero-allocation-hashing-0.14 (https://github.com/OpenHFT/Zero-Allocation-Hashing).
+ * Modified by the gRPC Authors
+ */
+
+package io.grpc.xds;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static com.google.common.base.Preconditions.checkNotNull;
+
+import java.nio.ByteOrder;
+
+/**
+ * The XxHash is a fast, non-cryptographic, 64-bit hash function that has excellent avalanche
+ * and 2-way bit independence properties.
+ *
+ * <p>This implementation is a simplified version adapted from
+ * <a href="https://github.com/OpenHFT/Zero-Allocation-Hashing/blob/master/src/main/java/net/openhft/hashing/XxHash.java">
+ * OpenHFT/Zero-Allocation-Hashing</a>.
+ */
+final class XxHash64 {
+  static final XxHash64 INSTANCE = new XxHash64(0);
+
+  // Primes if treated as unsigned
+  private static final long P1 = -7046029288634856825L;
+  private static final long P2 = -4417276706812531889L;
+  private static final long P3 = 1609587929392839161L;
+  private static final long P4 = -8796714831421723037L;
+  private static final long P5 = 2870177450012600261L;
+
+  private static final ByteOrder byteOrder = ByteOrder.nativeOrder();
+  private final long seed;
+  private final long voidHash;
+
+  XxHash64(long seed) {
+    this.seed = seed;
+    this.voidHash = finalize(seed + P5);
+  }
+
+  long hashLong(long input) {
+    input = byteOrder == ByteOrder.LITTLE_ENDIAN ? input : Long.reverseBytes(input);
+    long hash = seed + P5 + 8;
+    input *= P2;
+    input = Long.rotateLeft(input, 31);
+    input *= P1;
+    hash ^= input;
+    hash = Long.rotateLeft(hash, 27) * P1 + P4;
+    return finalize(hash);
+  }
+
+  long hashInt(int input) {
+    input = byteOrder == ByteOrder.LITTLE_ENDIAN ? input : Integer.reverseBytes(input);
+    long hash = seed + P5 + 4;
+    hash ^= (input & 0xFFFFFFFFL) * P1;
+    hash = Long.rotateLeft(hash, 23) * P2 + P3;
+    return finalize(hash);
+  }
+
+  long hashShort(short input) {
+    input = byteOrder == ByteOrder.LITTLE_ENDIAN ? input : Short.reverseBytes(input);
+    long hash = seed + P5 + 2;
+    hash ^= (input & 0xFFL) * P5;
+    hash = Long.rotateLeft(hash, 11) * P1;
+    hash ^= ((input >> 8) & 0xFFL) * P5;
+    hash = Long.rotateLeft(hash, 11) * P1;
+    return finalize(hash);
+  }
+
+  long hashChar(char input) {
+    return hashShort((short) input);
+  }
+
+  long hashByte(byte input) {
+    long hash = seed + P5 + 1;
+    hash ^= (input & 0xFF) * P5;
+    hash = Long.rotateLeft(hash, 11) * P1;
+    return finalize(hash);
+  }
+
+  long hashVoid() {
+    return voidHash;
+  }
+
+  long hashAsciiString(String input) {
+    ByteSupplier supplier = new AsciiStringByteSupplier(input);
+    return hashBytes(supplier);
+  }
+
+  long hashBytes(byte[] bytes) {
+    ByteSupplier supplier = new PlainByteSupplier(bytes);
+    return hashBytes(supplier);
+  }
+
+  long hashBytes(byte[] bytes, int offset, int len) {
+    ByteSupplier supplier = new PlainByteSupplier(bytes, offset, len);
+    return hashBytes(supplier);
+  }
+
+  private long hashBytes(ByteSupplier supplier) {
+    long hash;
+    if (supplier.remaining() >= 32) {
+      long v1 = seed + P1 + P2;
+      long v2 = seed + P2;
+      long v3 = seed;
+      long v4 = seed - P1;
+
+      do {
+        v1 += supplier.next64() * P2;
+        v1 = Long.rotateLeft(v1, 31);
+        v1 *= P1;
+
+        v2 += supplier.next64() * P2;
+        v2 = Long.rotateLeft(v2, 31);
+        v2 *= P1;
+
+        v3 += supplier.next64() * P2;
+        v3 = Long.rotateLeft(v3, 31);
+        v3 *= P1;
+
+        v4 += supplier.next64() * P2;
+        v4 = Long.rotateLeft(v4, 31);
+        v4 *= P1;
+      } while (supplier.remaining() >= 32);
+
+      hash = Long.rotateLeft(v1, 1)
+          + Long.rotateLeft(v2, 7)
+          + Long.rotateLeft(v3, 12)
+          + Long.rotateLeft(v4, 18);
+
+      v1 *= P2;
+      v1 = Long.rotateLeft(v1, 31);
+      v1 *= P1;
+      hash ^= v1;
+      hash = (hash * P1) + P4;
+
+      v2 *= P2;
+      v2 = Long.rotateLeft(v2, 31);
+      v2 *= P1;
+      hash ^= v2;
+      hash = (hash * P1) + P4;
+
+      v3 *= P2;
+      v3 = Long.rotateLeft(v3, 31);
+      v3 *= P1;
+      hash ^= v3;
+      hash = (hash * P1) + P4;
+
+      v4 *= P2;
+      v4 = Long.rotateLeft(v4, 31);
+      v4 *= P1;
+      hash ^= v4;
+      hash = (hash * P1) + P4;
+    } else {
+      hash = seed + P5;
+    }
+
+    hash += supplier.bytes();
+
+    while (supplier.remaining() >= 8) {
+      long k1 = supplier.next64();
+      k1 *= P2;
+      k1 = Long.rotateLeft(k1, 31);
+      k1 *= P1;
+      hash ^= k1;
+      hash = (Long.rotateLeft(hash, 27) * P1) + P4;
+    }
+
+    if (supplier.remaining() >= 4) { //treat as unsigned ints
+      hash ^= (supplier.next32() & 0xFFFFFFFFL) * P1;
+      hash = (Long.rotateLeft(hash, 23) * P2) + P3;
+    }
+
+    while (supplier.remaining() != 0) { //treat as unsigned bytes
+      hash ^= (supplier.next8() & 0xFF) * P5;
+      hash = Long.rotateLeft(hash, 11) * P1;
+    }
+
+    return finalize(hash);
+  }
+
+  private static long finalize(long hash) {
+    hash ^= hash >>> 33;
+    hash *= P2;
+    hash ^= hash >>> 29;
+    hash *= P3;
+    hash ^= hash >>> 32;
+    return hash;
+  }
+
+  private static class PlainByteSupplier extends ByteSupplier {
+    private final byte[] src;
+    private final int len;
+    private int pos;
+    private int remain;
+
+    private PlainByteSupplier(byte[] src) {
+      this(src, 0, src.length);
+    }
+
+    private PlainByteSupplier(byte[] src, int offset, int len) {
+      this.src = checkNotNull(src, "src");
+      checkArgument(offset <= src.length, "offset > src length");
+      checkArgument(offset + len <= src.length, "offset + len > src length");
+      this.len = len;
+      pos = offset;
+      remain = len;
+    }
+
+    @Override
+    public long bytes() {
+      return len;
+    }
+
+    @Override
+    public long remaining() {
+      return remain;
+    }
+
+    @Override
+    public byte next8() {
+      remain--;
+      return src[pos++];
+    }
+  }
+
+  private static class AsciiStringByteSupplier extends ByteSupplier {
+    private final String str;
+    private final int bytes;
+    private int pos;
+
+    private AsciiStringByteSupplier(String str) {
+      this.str = checkNotNull(str, "str");
+      this.bytes = str.length();
+    }
+
+    @Override
+    public long bytes() {
+      return bytes;
+    }
+
+    @Override
+    public long remaining() {
+      return (long) bytes - pos;
+    }
+
+    @Override
+    public byte next8() {
+      return (byte) str.charAt(pos++);
+    }
+  }
+
+  private abstract static class ByteSupplier {
+
+    public long next64() {
+      return ((next32() & 0xFFFFFFFFL) | ((next32() & 0xFFFFFFFFL) << 32));
+    }
+
+    public int next32() {
+      return ((next16() & 0xFFFF) | ((next16() & 0xFFFF) << 16));
+    }
+
+    char next16() {
+      return (char) ((next8() & 0xFF) | ((next8() & 0xFF) << 8));
+    }
+
+    abstract byte next8();
+
+    abstract long bytes();
+
+    abstract long remaining();
+  }
+}
diff --git a/xds/third_party/zero-allocation-hashing/test/java/io/grpc/xds/XxHash64Test.java b/xds/third_party/zero-allocation-hashing/test/java/io/grpc/xds/XxHash64Test.java
new file mode 100644
index 00000000000..10219a2f72e
--- /dev/null
+++ b/xds/third_party/zero-allocation-hashing/test/java/io/grpc/xds/XxHash64Test.java
@@ -0,0 +1,2266 @@
+/*
+ * Copyright 2021 Higher Frequency Trading http://www.higherfrequencytrading.com
+ *
+ * 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.
+ */
+/*
+ * Forked from zero-allocation-hashing-0.14 (https://github.com/OpenHFT/Zero-Allocation-Hashing).
+ * Modified by the gRPC Authors
+ */
+
+package io.grpc.xds;
+
+import static org.junit.Assert.assertEquals;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.junit.runners.Parameterized;
+
+/**
+ * Unit tests for {@link XxHash64}. Adapted from
+ * <a href="https://github.com/OpenHFT/Zero-Allocation-Hashing/blob/master/src/test/java/net/openhft/hashing/LongHashFunctionTest.java">
+ * OpenHFT/Zero-Allocation-Hashing</a>.
+ */
+@RunWith(Enclosed.class)
+public class XxHash64Test {
+
+  @RunWith(Parameterized.class)
+  public static class HashingTest {
+
+    /** Data for test. */
+    @Parameterized.Parameters
+    public static Collection<Object[]> data() {
+      ArrayList<Object[]> data = new ArrayList<>();
+      for (int len = 0; len < 1025; len++) {
+        data.add(new Object[]{len});
+      }
+      return data;
+    }
+
+    @Parameterized.Parameter
+    public int len;
+
+    @Test
+    public void withoutSeeds() {
+      test(XxHash64.INSTANCE, HASHES_OF_LOOPING_BYTES_WITHOUT_SEED);
+    }
+
+    @Test
+    public void withOneSeed() {
+      test(new XxHash64(42L), HASHES_OF_LOOPING_BYTES_WITH_SEED_42);
+    }
+
+    private void test(XxHash64 f, long[] hashesOfLoopingBytes) {
+      byte[] data = new byte[len];
+      for (int j = 0; j < data.length; j++) {
+        data[j] = (byte) j;
+      }
+      test(f, data, hashesOfLoopingBytes[len]);
+    }
+
+    private static void test(XxHash64 f, byte[] data, long eh) {
+      int len = data.length;
+      testVoid(f, eh, len);
+      testBytes(f, eh, data);
+      testAsciiString(f, eh, len, data);
+      ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
+      testByte(f, eh, len, bb);
+      testShort(f, eh, len, bb);
+      testChar(f, eh, len, bb);
+      testInt(f, eh, len, bb);
+      testLong(f, eh, len, bb);
+      testNegativePrimitives(f, len);
+    }
+
+    private static void testVoid(XxHash64 f, long eh, int len) {
+      if (len == 0) {
+        assertEquals("void", eh, f.hashVoid());
+      }
+    }
+
+    private static void testByte(XxHash64 f, long eh, int len, ByteBuffer bb) {
+      if (len == 1) {
+        assertEquals("byte hash", eh, f.hashByte(bb.get(0)));
+      }
+    }
+
+    private static void testShort(XxHash64 f, long eh, int len, ByteBuffer bb) {
+      if (len == 2) {
+        assertEquals("short hash", eh, f.hashShort(bb.getShort(0)));
+      }
+    }
+
+    private static void testChar(XxHash64 f, long eh, int len, ByteBuffer bb) {
+      if (len == 2) {
+        assertEquals("char hash", eh, f.hashChar(bb.getChar(0)));
+      }
+    }
+
+    private static void testInt(XxHash64 f, long eh, int len, ByteBuffer bb) {
+      if (len == 4) {
+        assertEquals("int hash", eh, f.hashInt(bb.getInt(0)));
+      }
+    }
+
+    private static void testLong(XxHash64 f, long eh, int len, ByteBuffer bb) {
+      if (len == 8) {
+        assertEquals("long hash", eh, f.hashLong(bb.getLong(0)));
+      }
+    }
+
+    private static void testNegativePrimitives(XxHash64 f, int len) {
+      if (len == 0) {
+        byte[] bytes = new byte[8];
+        Arrays.fill(bytes, (byte) -1);
+        long oneByteExpected = f.hashBytes(bytes, 0, 1);
+        long twoByteExpected = f.hashBytes(bytes, 0, 2);
+        long fourByteExpected = f.hashBytes(bytes, 0, 4);
+        long eightByteExpected = f.hashBytes(bytes);
+        assertEquals("byte hash", oneByteExpected, f.hashByte((byte) -1));
+        assertEquals("short hash", twoByteExpected, f.hashShort((short) -1));
+        assertEquals("char hash", twoByteExpected, f.hashChar(Character.MAX_VALUE));
+        assertEquals("int hash", fourByteExpected, f.hashInt(-1));
+        assertEquals("long hash", eightByteExpected, f.hashLong(-1L));
+      }
+    }
+
+    private static void testBytes(XxHash64 f, long eh, byte[] data) {
+      assertEquals("byte array", eh, f.hashBytes(data));
+    }
+
+    private static void testAsciiString(XxHash64 f, long eh, int len, byte[] data) {
+      if (len <= 128) {
+        assertEquals("string hash", eh, f.hashAsciiString(
+            new String(data, StandardCharsets.US_ASCII)));
+      }
+    }
+  }
+
+  @RunWith(JUnit4.class)
+  public static class CollisionTest {
+
+    @SuppressWarnings("ConstantOverflow")
+    @Test
+    public void collisionTest() {
+      XxHash64 f = XxHash64.INSTANCE;
+      ByteBuffer sequence = ByteBuffer.allocate(128);
+      sequence.order(ByteOrder.LITTLE_ENDIAN);
+      sequence.putLong(0, 1);
+      sequence.putLong(16, 42);
+      sequence.putLong(32, 2);
+      long h1 = f.hashBytes(sequence.array());
+
+      sequence.putLong(0, 1 + 0xBA79078168D4BAFL);
+      sequence.putLong(32, 2 + 0x9C90005B80000000L);
+      long h2 = f.hashBytes(sequence.array());
+      assertEquals(h1, h2);
+
+      sequence.putLong(0, 1 + 0xBA79078168D4BAFL * 2);
+      sequence.putLong(32, 2 + 0x9C90005B80000000L * 2);
+
+      long h3 = f.hashBytes(sequence.array());
+      assertEquals(h2, h3);
+    }
+  }
+
+  /*
+   * Test data is output of the following program with xxHash implementation
+   * from https://github.com/Cyan4973/xxHash
+   *
+   * #include "xxhash.c"
+   * #include <stdlib.h>
+   * #include <stdio.h>
+   * int main()
+   * {
+   *     char* src = (char*) malloc(1024);
+   *     const int N = 1024;
+   *     for (int i = 0; i < N; i++) {
+   *         src[i] = (char) i;
+   *     }
+   *
+   *     printf("without seed\n");
+   *     for (int i = 0; i <= N; i++) {
+   *        printf("%lldL,\n", (long long) XXH64(src, i, 0));
+   *     }
+   *
+   *     printf("with seed 42\n");
+   *     for (int i = 0; i <= N; i++) {
+   *        printf("%lldL,\n", (long long) XXH64(src, i, 42));
+   *     }
+   * }
+   */
+
+  private static final long[] HASHES_OF_LOOPING_BYTES_WITHOUT_SEED = {
+      -1205034819632174695L,
+      -1642502924627794072L,
+      5216751715308240086L,
+      -1889335612763511331L,
+      -13835840860730338L,
+      -2521325055659080948L,
+      4867868962443297827L,
+      1498682999415010002L,
+      -8626056615231480947L,
+      7482827008138251355L,
+      -617731006306969209L,
+      7289733825183505098L,
+      4776896707697368229L,
+      1428059224718910376L,
+      6690813482653982021L,
+      -6248474067697161171L,
+      4951407828574235127L,
+      6198050452789369270L,
+      5776283192552877204L,
+      -626480755095427154L,
+      -6637184445929957204L,
+      8370873622748562952L,
+      -1705978583731280501L,
+      -7898818752540221055L,
+      -2516210193198301541L,
+      8356900479849653862L,
+      -4413748141896466000L,
+      -6040072975510680789L,
+      1451490609699316991L,
+      -7948005844616396060L,
+      8567048088357095527L,
+      -4375578310507393311L,
+      -3749919242623962444L,
+      888155921178136237L,
+      -228195649085979072L,
+      -521095004075279741L,
+      -2458702038214709156L,
+      -2792334161285995319L,
+      7509323632532862410L,
+      46046374822258777L,
+      -731200582691896855L,
+      933917387460394992L,
+      5623144551929396680L,
+      6456984547425914359L,
+      -6398540474588876142L,
+      1224372500617079775L,
+      -931727396974525131L,
+      979677643219401656L,
+      -8078270932489049756L,
+      -92767506898879473L,
+      2379112167176776082L,
+      2065719310945572007L,
+      -4972682801816081667L,
+      -7346559332994187462L,
+      4674729779638751546L,
+      5844780159702313017L,
+      925606237565008152L,
+      8164325403643669774L,
+      5124005065773312983L,
+      -4646462236086916483L,
+      4733593776494364101L,
+      -6408850806317360L,
+      7405089268865026700L,
+      -2131704682637193649L,
+      -592659849139514384L,
+      -4386868621773355429L,
+      -2216833672566288862L,
+      4022619316305276641L,
+      -60464713570988944L,
+      2416749694506796597L,
+      3576590985110933976L,
+      3368688771415645536L,
+      -357157638897078259L,
+      3484358739758473117L,
+      2078888409435083535L,
+      8053093288416703076L,
+      -4934736471585554038L,
+      -7784370683223414061L,
+      -4109284735634941390L,
+      5982490102027564625L,
+      -4991107002810882893L,
+      8664747912276562373L,
+      8536879438728327651L,
+      2358675440174594061L,
+      5352236919104495867L,
+      6340852522718110192L,
+      5075606340464035668L,
+      -6313168920073458239L,
+      -6428599582591385786L,
+      -7278654800402467208L,
+      -6630626099856243581L,
+      -7548742438664634646L,
+      5514383762309532642L,
+      -5996126265702944431L,
+      4011116741319319261L,
+      -7289240093981845088L,
+      4975257207486779926L,
+      -3945500877932691916L,
+      1973955144068521079L,
+      3884425912161913184L,
+      7692681977284421015L,
+      -1616730378439673826L,
+      4799493270916844476L,
+      -6107310582897997679L,
+      3643294092300179537L,
+      5406040598516899149L,
+      -3032420409304067208L,
+      5044227119457305622L,
+      9165032773225506149L,
+      7553488247682850248L,
+      2247298339072845043L,
+      7380491470304042584L,
+      -456791943260357427L,
+      -1906500292613319324L,
+      -4025157985304129897L,
+      6167829983725509611L,
+      -8678196943431064825L,
+      -636391087313417831L,
+      5757999497725839182L,
+      8999325347316115948L,
+      -6042339776328081249L,
+      7988836354190359013L,
+      2818448030979902104L,
+      -8484201484113382447L,
+      -1140175406473847155L,
+      3042776987426497381L,
+      3147338037480432386L,
+      5065714330193756569L,
+      8827021486636772242L,
+      838335823706922959L,
+      481844220820054909L,
+      5333474685474667077L,
+      -3722898251196013565L,
+      7909417627390150381L,
+      7116148225996109646L,
+      7520381989775811302L,
+      6045444672904719015L,
+      169039646730338133L,
+      -2144629916252757106L,
+      -3752608501798118554L,
+      8374704774878780935L,
+      -5830926781667225570L,
+      3202139393110256022L,
+      4400219135677717216L,
+      -5663710220155589201L,
+      -2589002340345751622L,
+      -8240133511464343390L,
+      -4036798392879835146L,
+      501599054729008501L,
+      -4851415719238782188L,
+      7565157933617774080L,
+      -6428091359957700043L,
+      4081845077806300175L,
+      -9016659258880122392L,
+      7811786097015457596L,
+      1357606791019752376L,
+      6522211979684949668L,
+      -3462397075047559451L,
+      3075504459164148117L,
+      3055992297861390732L,
+      -7230492327399411047L,
+      -1128103378253532506L,
+      1834607408788151585L,
+      7065978976369231860L,
+      6566122632438908362L,
+      -3440855531356735824L,
+      6271453770746181891L,
+      413365468403580071L,
+      -8342682158827061522L,
+      -3713303136987568731L,
+      -8959326895824091541L,
+      -2793862582117663595L,
+      -184756427409317729L,
+      -7052502019782453427L,
+      3666196071825438258L,
+      170204095295428634L,
+      -1880693509859077843L,
+      5179169206996749826L,
+      2866097700453114958L,
+      1859104195026275510L,
+      3782323564639128125L,
+      -6485194456269981193L,
+      6761934873296236857L,
+      5764605515941066448L,
+      597754945258033208L,
+      -4888986062036739232L,
+      -6490228233091577705L,
+      3234089784845854336L,
+      -5506883591180767430L,
+      1491493862343818933L,
+      3232293217886687768L,
+      -4079803366160739972L,
+      4884134040093556099L,
+      -7274733680156962461L,
+      5265680254123454403L,
+      1036855740788018258L,
+      423439784169709263L,
+      -3627743032115866622L,
+      -6311378083791982305L,
+      -3058076915688265687L,
+      5826550132901840796L,
+      8049712006832885455L,
+      1707844692241288946L,
+      -3293048440386932248L,
+      -2458638193238955307L,
+      943059295184967928L,
+      3899561579431348819L,
+      -1516862862245909493L,
+      4448476568037673976L,
+      8738531437146688925L,
+      -1033913449611929894L,
+      733668166271378558L,
+      438686375775205249L,
+      -4325889118346169305L,
+      -238178883117433622L,
+      -7972205050662019794L,
+      -1263398103237492853L,
+      -8333197763892905802L,
+      7796341294364809534L,
+      -1381767618016537445L,
+      2892579485651013970L,
+      -3376209887503828920L,
+      -8575120126045607817L,
+      -1609355362031172055L,
+      -386138918275547508L,
+      4598874691849543747L,
+      -2961781601824749597L,
+      -3032925351997820092L,
+      -4256249198066449735L,
+      6712291718681474012L,
+      -4281614253751277086L,
+      3727487933918100016L,
+      -2744649548868700294L,
+      8662377383917584333L,
+      -9154398439761221404L,
+      -6895275824272461794L,
+      3394857180017540444L,
+      2010825527298793302L,
+      4894417464710366872L,
+      -6879244364314087051L,
+      83677167865178033L,
+      -8258406393927169823L,
+      5042126978317943321L,
+      6485279223034053259L,
+      4442956705009100620L,
+      316801800427881731L,
+      1381431847939703076L,
+      5172932759041399062L,
+      -69656533526213521L,
+      -5302643413630076306L,
+      -3956089084400440856L,
+      372087412941022771L,
+      4711314482928419386L,
+      3255220726505012060L,
+      8917854303046844847L,
+      1116214654602499731L,
+      2282408585429094475L,
+      -9207590323584417562L,
+      8881688165595519866L,
+      1731908113181957442L,
+      3847295165012256987L,
+      4457829016858233661L,
+      4944046822375522396L,
+      3445091217248591320L,
+      -5055680960069278553L,
+      -399195423199498362L,
+      -8109174165388156886L,
+      4967185977968814820L,
+      -5911973391056763118L,
+      2239508324487797550L,
+      -954783563382788523L,
+      8523699184200726144L,
+      932575865292832326L,
+      -7491448407022023047L,
+      1809887519026638446L,
+      -8610524715250756725L,
+      6158809695983348998L,
+      4948400960714316843L,
+      -4513370424175692831L,
+      -3955280856263842959L,
+      6440233015885550592L,
+      8756942107256956958L,
+      7895095834297147376L,
+      370033091003609904L,
+      948078545203432448L,
+      -8523229038380945151L,
+      100794871657160943L,
+      -2186420796072284323L,
+      -9221115378196347951L,
+      8102537654803861332L,
+      5857339063191690550L,
+      -4554257374958739421L,
+      6607496554818971053L,
+      -778402196622557070L,
+      -3817535277727878318L,
+      3564122000469288769L,
+      -44446230828995950L,
+      1322708749649533240L,
+      6150374672341998205L,
+      -3300275952549095391L,
+      5700833512536085850L,
+      -8559358370491270937L,
+      5434443260519512697L,
+      -8031025173259990945L,
+      7117462129248544172L,
+      5425177419943569451L,
+      -7215427371174054838L,
+      -5728669976971194528L,
+      -2096361446095323077L,
+      -4247416835972286805L,
+      4912769047482466787L,
+      7755341152739082452L,
+      6797061233443658471L,
+      4089361562209715474L,
+      5830701413838808929L,
+      5514515889578551370L,
+      609334005368729318L,
+      177310574483850759L,
+      -820431153866372784L,
+      7188454041446661654L,
+      7480194911613035473L,
+      4564607884390103056L,
+      888496928954372093L,
+      -5480535802290619117L,
+      9100964700413324707L,
+      510523132632789099L,
+      8249362675875046694L,
+      5340321809639671537L,
+      -4633081050124361874L,
+      -839915092967986193L,
+      -7377542419053401928L,
+      1820485955145562839L,
+      8517645770425584256L,
+      -1877318739474090786L,
+      7674371564231889244L,
+      -3311130470964498678L,
+      -880090321525066135L,
+      -5670998531776225745L,
+      -8828737503035152589L,
+      -6029750416835830307L,
+      -6535608738168818581L,
+      -550872341393232043L,
+      2831504667559924912L,
+      -4613341433216920241L,
+      502960879991989691L,
+      576723875877375776L,
+      -2575765564594953903L,
+      -4642144349520453953L,
+      7939746291681241029L,
+      6486356905694539404L,
+      -9086235573768687853L,
+      5369903658359590823L,
+      3199947475395774092L,
+      8384948078622146995L,
+      -3365598033653273878L,
+      -2525526479099052030L,
+      2648498634302427751L,
+      3715448294999624219L,
+      -4734466095330028983L,
+      -8440427851760401644L,
+      -371198022355334589L,
+      8864079431738600817L,
+      -4205600060099565684L,
+      6617166152874298882L,
+      -6515522971156180292L,
+      7254251246745292298L,
+      -420587237082849417L,
+      1190495815435763349L,
+      -474540026828753709L,
+      -8150622114536376016L,
+      -5790621848044235275L,
+      -2780522220219318167L,
+      -2991155855957250848L,
+      1692932912262846366L,
+      8814949734565782733L,
+      -8746818869495012552L,
+      7931250816026891600L,
+      -7434629709560596700L,
+      4388261932396122996L,
+      7154847153195510802L,
+      -2810154398655124882L,
+      2601892684639182965L,
+      7781574423676509607L,
+      -6647000723020388462L,
+      -8679132292226137672L,
+      -2447013202020963672L,
+      3658855631326217196L,
+      2176620921764007759L,
+      3654402165357492705L,
+      4511989090021652156L,
+      -3254638803798424003L,
+      9050506214967102331L,
+      922579360317805810L,
+      609820949221381248L,
+      5723875594772949290L,
+      4637721466210023638L,
+      6195303339320487374L,
+      -38202587086649325L,
+      -2142927092331878341L,
+      5355751314914287101L,
+      -7170892783575760055L,
+      -7506612729078573199L,
+      8645580445823695595L,
+      3221950179890871958L,
+      1638211443525398634L,
+      7356718304253861777L,
+      -296260062751271549L,
+      -1790105985391377345L,
+      -7004118620405119098L,
+      7056012094479909462L,
+      -7673357898031223798L,
+      -8929502135696203556L,
+      7527161467311997998L,
+      6182865571027510002L,
+      -2163310275402596869L,
+      6285112477695252864L,
+      3703909999924067987L,
+      962491298117560533L,
+      138936592567072793L,
+      6094857527471100960L,
+      5914305068838335718L,
+      -8896724991235492552L,
+      -2667562314507789198L,
+      -7456492499188304500L,
+      -3422709784851063201L,
+      -1511644999824238281L,
+      -7130158069449057322L,
+      6243266426571961929L,
+      2713895636371672711L,
+      5765589573821453640L,
+      2624585483746388367L,
+      3933828437519859601L,
+      -5664404238108533781L,
+      7086393398544811684L,
+      1322058227068490376L,
+      -8232508114671021371L,
+      -5963804389649678229L,
+      -3318229976491806899L,
+      -6261789542948241754L,
+      199130260709663583L,
+      7521707465510595039L,
+      507353862067534334L,
+      -7737968456769005928L,
+      -8964687882992257099L,
+      -7735003539801528311L,
+      6989812739838460574L,
+      -6986289777499051441L,
+      1881562796144865699L,
+      -6077719780113966592L,
+      -5427071388091979746L,
+      1660707436425817310L,
+      -4338189980197421104L,
+      5330934977599207307L,
+      4461280425701571033L,
+      -7426107478263746863L,
+      4258305289832328199L,
+      -8003283151332860979L,
+      -2500604212764835216L,
+      -8883941775298564436L,
+      -5059709834257638733L,
+      -4582947579039913741L,
+      1371959565630689983L,
+      -1925163414161391371L,
+      -1180269729544278896L,
+      -6603171789097590304L,
+      8985062706306079731L,
+      -3588748723254272836L,
+      -6052032019910018725L,
+      6200960040430493088L,
+      2146343936795524980L,
+      7785948646708747443L,
+      4524411768393719400L,
+      749211414228926779L,
+      -163844243342465015L,
+      1066801203344117463L,
+      -3687825939602944988L,
+      -4873811917429870500L,
+      -3765115783578949524L,
+      3344884226049804020L,
+      -22793631121165636L,
+      -5636541624133159076L,
+      -6201449576244177151L,
+      -4533734412127714050L,
+      -2064657727206266594L,
+      -1325853623186040989L,
+      -2651306529045029511L,
+      903264360879626406L,
+      6082283797495873520L,
+      6185446819995987847L,
+      -5727850940826115079L,
+      8356646143516726527L,
+      -7705915341280821272L,
+      9137633133909463406L,
+      6613483969797411894L,
+      8598514961735984460L,
+      6805925079991408361L,
+      6009403222422527608L,
+      2216303622650116705L,
+      -3736062178532154638L,
+      -7139008962939637477L,
+      -1537711200058404375L,
+      8896755073380580322L,
+      -6063426810787442347L,
+      -3472064301690015285L,
+      -4568131486464952371L,
+      -8141256104294687045L,
+      5627435360893599536L,
+      1136003802967708029L,
+      2730027518034735037L,
+      1985287040172139729L,
+      -3643431491383365431L,
+      -9042919736106376701L,
+      8879968900590373568L,
+      8504486139877409399L,
+      5832665747670146536L,
+      4202923651402292496L,
+      1738511892080946286L,
+      4512683881549777042L,
+      9200194457599870145L,
+      -1948301178705617139L,
+      8655715314401162523L,
+      412698981651521600L,
+      -1479274044808688580L,
+      2688302549664693359L,
+      -3059920027366623178L,
+      -4275753325231806565L,
+      -8321791698013769889L,
+      -3678119714812414102L,
+      -2500922551770832553L,
+      9018541633115002061L,
+      5713301371152396803L,
+      4180584812840471799L,
+      3062416401091271879L,
+      -8125716681035757962L,
+      -2076056159878596225L,
+      8855540523533374738L,
+      2402007906402689092L,
+      2020584786288649542L,
+      1707405964421070701L,
+      -3681994462249973122L,
+      -3982567775984742012L,
+      7133200226358561844L,
+      -5270514263562558963L,
+      9060760368219219429L,
+      -6967162372382490281L,
+      -9094664463528453384L,
+      -3968518633408880046L,
+      8618660189330281694L,
+      -4668946581954397558L,
+      -8596433172676363407L,
+      -1264942061713169049L,
+      -5309493221793643795L,
+      -1099320768477039529L,
+      8925041285873295227L,
+      -6809278181760513499L,
+      -7039439984223885585L,
+      6188209901527865226L,
+      1487353394192637059L,
+      2402097349430126337L,
+      -3818359601525025681L,
+      4123217079279439249L,
+      -1424515143377220376L,
+      1742298536803356877L,
+      -2836832784751148874L,
+      -4838603242771410698L,
+      2383745618623084414L,
+      -2790832243316548423L,
+      -1176683649587660160L,
+      1862928178605117401L,
+      5208694030074527671L,
+      4339841406618876548L,
+      -7704801448691668472L,
+      500068664415229033L,
+      -2111184635274274347L,
+      -1387769336519960517L,
+      -2368660677263980293L,
+      -4980481392402938776L,
+      -6856361166068680884L,
+      1708658704968066797L,
+      -9013068514618931938L,
+      -2616479975851677179L,
+      7121103440247327570L,
+      -7094192881960646061L,
+      -4042342930006488618L,
+      5294323611741266775L,
+      5235545113690922502L,
+      -2562011392475214878L,
+      -4613304566070234734L,
+      -3784386310583029381L,
+      -4526148219816534267L,
+      -8643470129031767968L,
+      -4573761335510927866L,
+      -8255399593563317902L,
+      -1925488377092111963L,
+      -1747797357090594237L,
+      7292772921748919564L,
+      3951718848780851600L,
+      5339305877764077075L,
+      7889570407201305102L,
+      -8935437555550449315L,
+      -1858205318388884024L,
+      381779657795494278L,
+      -3769854251228686168L,
+      -7957724087073627355L,
+      4349540075286824743L,
+      -2476434494603040708L,
+      -4506107235113109706L,
+      -7120863144673563848L,
+      -8534342596639587598L,
+      2205658724629050493L,
+      604438195864305027L,
+      4530331938860561927L,
+      -2074141653226683751L,
+      -1114378227875974007L,
+      3377301950002508302L,
+      5369356700690664306L,
+      -1747063224581819445L,
+      -6320380781966280801L,
+      -2075443262555773155L,
+      1028541493355576591L,
+      -4694402890123574860L,
+      -5250660999767019003L,
+      3847087895315315136L,
+      -4448050214964317066L,
+      -4591316307978008151L,
+      4894820902772635901L,
+      3088847887353411593L,
+      -6699208183127463352L,
+      4636731998354510780L,
+      9095126525233209263L,
+      4135373626035182291L,
+      3835688804093949701L,
+      -3490782692819028324L,
+      -561453348486424761L,
+      -3329283619698366365L,
+      3251154327320814221L,
+      -8006986328190314286L,
+      5856651505286251345L,
+      -8871425101391073L,
+      7806993676637210959L,
+      7586479850833664643L,
+      -7091216108599847229L,
+      -3410137297792125447L,
+      -8251963871271100526L,
+      -8849730915506517177L,
+      8400334327557485676L,
+      1676125861848906502L,
+      -8480324002538122254L,
+      -1402216371589796114L,
+      5951911012328622382L,
+      8596811512609928773L,
+      -2266336480397111285L,
+      -8840962712683931463L,
+      4301675602445909557L,
+      1843369157327547440L,
+      2169755460218905712L,
+      -1592865257954325910L,
+      -8763867324602133653L,
+      -4283855559993550994L,
+      -7577702976577664015L,
+      -5152834259238990784L,
+      4596243922610406362L,
+      -4326545138850544854L,
+      1480440096894990716L,
+      8548031958586152418L,
+      6705615952497668303L,
+      -2915454802887967935L,
+      -6137002913510169520L,
+      2908515186908319288L,
+      5834242853393037250L,
+      -6721431559266056630L,
+      -7810820823419696676L,
+      1954209413716096740L,
+      6657013078387802473L,
+      2214178984740031680L,
+      8789512881373922013L,
+      1240231669311237626L,
+      8694612319028097761L,
+      492180561068515854L,
+      -6047127535609489112L,
+      7436686740711762797L,
+      -4520261623507558716L,
+      938282189116272147L,
+      3232025564608101134L,
+      -5425498066931840551L,
+      932123105892452494L,
+      9054941090932531526L,
+      8066693670021084601L,
+      764877609198828864L,
+      -489112437588815338L,
+      4827691353685521957L,
+      1948321254606741278L,
+      6117773063719937712L,
+      4645962658121906639L,
+      -7846887104148029590L,
+      4210795945791252618L,
+      -8879516722990993098L,
+      -2621063563373927241L,
+      2094675051444850863L,
+      -8681225697045319537L,
+      6072534474938492189L,
+      6181923696407824226L,
+      5463607676777614919L,
+      3708342890820711111L,
+      8844501223821777366L,
+      -1459359143442302680L,
+      2225439088478089068L,
+      -3866259492807347627L,
+      5715020051188773955L,
+      3922300588924895992L,
+      -9142841818158905228L,
+      2234845285375211931L,
+      2466598091809457099L,
+      -5086614780930363190L,
+      -59740786891006359L,
+      3484340182077240897L,
+      5684798394905475931L,
+      8492255409537329167L,
+      5276601975076232447L,
+      -723955912320185993L,
+      9032937149732310432L,
+      2226206333274026280L,
+      5631303328800272036L,
+      3943832708526382713L,
+      -3756282686478033644L,
+      -5407377327559185078L,
+      2025162219823732106L,
+      -8802502232162774782L,
+      9039368856081455195L,
+      663058667658971174L,
+      3624269418844967319L,
+      1835338408542062149L,
+      6821836507221295281L,
+      6273547355770435776L,
+      -3104373869480308814L,
+      1150888014781722836L,
+      7638478751521711777L,
+      -6407096352658729423L,
+      -2242514077180426481L,
+      -3181824045541296523L,
+      -4562287221569080073L,
+      -5550768647534615669L,
+      -5786611484859469238L,
+      -6147722345444149090L,
+      3737249616177808079L,
+      3401215612108618403L,
+      -713522925214097648L,
+      7938558781452631257L,
+      -2822931074351003413L,
+      -6484774850345918944L,
+      3384659068511379086L,
+      6976459554734427695L,
+      4254162229878558339L,
+      -3312164339867139602L,
+      7263045146222903358L,
+      4561625003713187235L,
+      -3350421200373539593L,
+      -6329267008823047447L,
+      -6889593333717619051L,
+      -6470291206680780949L,
+      -1925391510610223335L,
+      4955720513801530785L,
+      -6515999401129420095L,
+      -5146900596178823847L,
+      2572121582663686783L,
+      -4958678197003031937L,
+      -1295912792184970105L,
+      -8320363273488883198L,
+      -8213501149234986129L,
+      -3883775881968950160L,
+      -8925953418077243474L,
+      3199784299548492168L,
+      -6836506744583692202L,
+      -5007347279129330642L,
+      7387675960164975441L,
+      -5841389805259238070L,
+      6263589037534776610L,
+      3327727201189139791L,
+      3673450414312153409L,
+      -1563909967243907088L,
+      -3758518049401683145L,
+      6368282934319908146L,
+      -6025191831649813215L,
+      1223512633484628943L,
+      -8540335264335924099L,
+      -8569704496403127098L,
+      -5712355262561236939L,
+      -6468621715016340600L,
+      7015005898276272746L,
+      -1037164971883038884L,
+      -6108649908647520338L,
+      -6781540054819591698L,
+      -2762739023866345855L,
+      -270930832663123436L,
+      -2387080926579956105L,
+      -3984603512651136889L,
+      2367015942733558542L,
+      2997123688964990405L,
+      -424413420483149165L,
+      2906467516125124288L,
+      7979917630945955701L,
+      2879736983084566817L,
+      558436267366797870L,
+      6471658168855475843L,
+      -3453803644372811678L,
+      95470628886709014L,
+      5666911245054448862L,
+      1594133734978640945L,
+      3790246368687946045L,
+      8636400206261643605L,
+      5901994795106283147L,
+      -6774812279971490610L,
+      -4622588246534854941L,
+      5395884908872287278L,
+      7381412950348018556L,
+      5461775216423433041L,
+      2851500852422732203L,
+      1153428834012773824L,
+      2567326223464897798L,
+      6290362916558214218L,
+      6095765709335097474L,
+      -3526424734043456674L,
+      -8411274175041022530L,
+      7565408328520233290L,
+      -1318636864706103626L,
+      1261242784453012654L,
+      -472643963000448611L,
+      -7126293899612852456L,
+      5072187962931197668L,
+      4775251504230927816L,
+      -1624676500499667689L,
+      2252385971292411863L,
+      7908437759266752884L,
+      -8948829914565397845L,
+      5258787823809553293L,
+      3885696202809019506L,
+      -4551784314460062669L,
+      5315762970089305011L,
+      7218180419200466576L,
+      109471822471146966L,
+      3901499100759315793L,
+      -5613018173558603696L,
+      5782419706003468119L,
+      8285176821902721729L,
+      -2944182278904878473L,
+      8089487615165958290L,
+      6934039118340963316L,
+      8481603619533191729L,
+      -6321491167299496492L,
+      6441589800192421521L,
+      6436057639713571196L,
+      6819921695214365155L,
+      1185928916708893611L,
+      2597068862418243401L,
+      -7637601550649263782L,
+      9129303862479379164L,
+      4047905726243458335L,
+      6672087858539795207L,
+      -4841432774404255351L,
+      5501215987763227677L,
+      -5300305896512100453L,
+      1635946349436492617L,
+      -5017459781050596604L,
+      -7313558338536196566L,
+      4625509831332846264L,
+      -1241826701278444028L,
+      2916178164108211239L,
+      -6947453283344846915L,
+      5520544791845620925L,
+      5009241392834567026L,
+      -630825152277572403L,
+      6246654103747517292L,
+      -5632205909016659384L,
+      -5099826214945383802L,
+      2466330894206710401L,
+      -1463559257726812272L,
+      4922422449110036517L,
+      -4940410396057186660L,
+      8835766963654337957L,
+      -1984334093384497740L,
+      5616151800825184227L,
+      -8442970605804311782L,
+      -5396399970392474268L,
+      2711274356126287353L,
+      -5090439840321959043L,
+      6638617029380445409L,
+      -6424875729377006548L,
+      -7243574969986334324L,
+      -904268348341193502L,
+      -6196811069886893217L,
+      -7742123331454617135L,
+      1449632469607275832L,
+      3212140938119717436L,
+      8676942774083692265L,
+      -6625590425417154859L,
+      8720904664575676760L,
+      9151723732605931383L,
+      7642401923610349184L,
+      -3454390566366389884L,
+      -232373658792783206L,
+      -8933620623437682010L,
+      2514068248201398743L,
+      6757007617821370359L,
+      -2870340646674679163L,
+      416331333845426881L,
+      -5319172016123138702L,
+      3294412564645954555L,
+      2812538484970453169L,
+      -9128349093860081905L,
+      6784456254618976198L,
+      -2861881330654872638L,
+      3912429093271518508L,
+      -2562542119887175820L,
+      4835616088583228965L,
+      427639171891209425L,
+      2590582080178010045L,
+      -6288067880951692635L,
+      -3204510905067065501L,
+      9008426291442999873L,
+      -4085962609397876083L,
+      -3786041297813905157L,
+      -6006475053574578261L,
+      -6174022276199807178L,
+      7958957647277035097L,
+      2915785807118517755L,
+      2139592530283433011L,
+      -8562048562533248017L,
+      -4991735207930685025L,
+      393144860250454082L,
+      -5852177196425420458L,
+      -2652303154023739579L,
+      2079679586901234739L,
+      -1386526064824772584L,
+      1574420554361329695L,
+      -855542130447493508L,
+      8291940350733154044L,
+      -5330200233059892402L,
+      5140782607921164290L,
+      -977254437067235218L,
+      -261520846651909307L,
+      -7369143208070837455L,
+      -4728766390712852111L,
+      -8572213434879266955L,
+      -6754813768712497692L,
+      7946121307356573089L,
+      504268959085012646L,
+      -5536654029698676818L,
+      -6021520522792328781L,
+      6968613512520500871L,
+      4029920623217569312L,
+      2738878342460920492L,
+      4562432005481165726L,
+      -1279037845195368028L,
+      1746645308450474697L,
+      2538150989161378915L,
+      2012299649948738944L,
+      -3997559675475377347L,
+      -5939431505669672858L,
+      2077103722387383456L,
+      -6188261335534632204L,
+      8772504603740967633L,
+      -1653698997940568281L,
+      1676948989756529271L,
+      2377579815165102226L,
+      -2667481192445387240L,
+      -5498860615033631762L,
+      -2490865541169744469L,
+      -1233441883399707566L,
+      5445263795307566596L,
+      2288458809413275798L,
+      -5908274826918996877L,
+      2909363406069168415L,
+      2376032171261335687L,
+      -5215189045919902574L,
+      -6083327007632847329L,
+      2462785604224107327L,
+      -6684045035730714275L,
+      2409356208468676804L,
+      2814747114160772803L,
+      -4529204412661254980L,
+      -8437511853472556883L,
+      1819323657613892915L,
+      6862685309651627151L,
+      -9210337863564319258L,
+      -3641041551811494963L,
+      -6791020794026796740L,
+      -5261661996953805298L,
+      -1953516254626596632L,
+      -5901591005960707793L,
+      -7413695905040596911L,
+      2952256922297384020L,
+      -8427771021447591769L,
+      -6920139339436245233L,
+      2967149838604559395L,
+      -3253499104068010353L,
+      -8473804925120692039L,
+      -3561285603521886085L,
+      -4453849179065102447L,
+      2050092642498054323L,
+      -5626434133619314199L,
+      7995075368278704248L,
+      7685996432951370136L,
+      -8037783900933102779L,
+      4601459625295412851L,
+      -4491938778497306775L,
+      -9089886217821142309L,
+      -3947191644612298897L,
+      1364225714229764884L,
+      2580394324892542249L,
+      -3765315378396862242L,
+      6023794482194323576L,
+      -662753714084561214L,
+      3080495347149127717L,
+      911710215008202776L,
+      -803705685664586056L,
+      -6101059689379533503L,
+      -2122356322512227634L,
+      8012110874513406695L,
+      -4158551223425336367L,
+      8282080141813519654L,
+      4172879384244246799L,
+      708522065347490110L,
+      -6997269001146828181L,
+      1887955086977822594L,
+      8014460039616323415L
+  };
+
+  private static final long[] HASHES_OF_LOOPING_BYTES_WITH_SEED_42 = {
+      -7444071767201028348L,
+      -8959994473701255385L,
+      7116559933691734543L,
+      6019482000716350659L,
+      -6625277557348586272L,
+      -5507563483608914162L,
+      1540412690865189709L,
+      4522324563441226749L,
+      -7143238906056518746L,
+      -7989831429045113014L,
+      -7103973673268129917L,
+      -2319060423616348937L,
+      -7576144055863289344L,
+      -8903544572546912743L,
+      6376815151655939880L,
+      5913754614426879871L,
+      6466567997237536608L,
+      -869838547529805462L,
+      -2416009472486582019L,
+      -3059673981515537339L,
+      4211239092494362041L,
+      1414635639471257331L,
+      166863084165354636L,
+      -3761330575439628223L,
+      3524931906845391329L,
+      6070229753198168844L,
+      -3740381894759773016L,
+      -1268276809699008557L,
+      1518581707938531581L,
+      7988048690914090770L,
+      -4510281763783422346L,
+      -8988936099728967847L,
+      -8644129751861931918L,
+      2046936095001747419L,
+      339737284852751748L,
+      -8493525091666023417L,
+      -3962890767051635164L,
+      -5799948707353228709L,
+      -6503577434416464161L,
+      7718729912902936653L,
+      191197390694726650L,
+      -2677870679247057207L,
+      20411540801847004L,
+      2738354376741059902L,
+      -3754251900675510347L,
+      -3208495075154651980L,
+      5505877218642938179L,
+      6710910171520780908L,
+      -9060809096139575515L,
+      6936438027860748388L,
+      -6675099569841255629L,
+      -5358120966884144380L,
+      -4970515091611332076L,
+      -1810965683604454696L,
+      -516197887510505242L,
+      1240864593087756274L,
+      6033499571835033332L,
+      7223146028771530185L,
+      909128106589125206L,
+      1567720774747329341L,
+      -1867353301780159863L,
+      4655107429511759333L,
+      5356891185236995950L,
+      182631115370802890L,
+      -3582744155969569138L,
+      595148673029792797L,
+      495183136068540256L,
+      5536689004903505647L,
+      -8472683670935785889L,
+      -4335021702965928166L,
+      7306662983232020244L,
+      4285260837125010956L,
+      8288813008819191181L,
+      -3442351913745287612L,
+      4883297703151707194L,
+      9135546183059994964L,
+      123663780425483012L,
+      509606241253238381L,
+      5940344208569311369L,
+      -2650142344608291176L,
+      3232776678942440459L,
+      -922581627593772181L,
+      7617977317085633049L,
+      7154902266379028518L,
+      -5806388675416795571L,
+      4368003766009575737L,
+      -2922716024457242064L,
+      4771160713173250118L,
+      3275897444752647349L,
+      -297220751499763878L,
+      5095659287766176401L,
+      1181843887132908826L,
+      9058283605301070357L,
+      3984713963471276643L,
+      6050484112980480005L,
+      1551535065359244224L,
+      565337293533335618L,
+      7412521035272884309L,
+      -4735469481351389369L,
+      6998597101178745656L,
+      -9107075101236275961L,
+      5879828914430779796L,
+      6034964979406620806L,
+      5666406915264701514L,
+      -4666218379625258428L,
+      2749972203764815656L,
+      -782986256139071446L,
+      6830581400521008570L,
+      2588852022632995043L,
+      -5484725487363818922L,
+      -3319556935687817112L,
+      6481961252981840893L,
+      2204492445852963006L,
+      -5301091763401031066L,
+      -2615065677047206256L,
+      -6769817545131782460L,
+      -8421640685322953142L,
+      -3669062629317949176L,
+      -9167016978640750490L,
+      2783671191687959562L,
+      -7599469568522039782L,
+      -7589134103255480011L,
+      -5932706841188717592L,
+      -8689756354284562694L,
+      -3934347391198581249L,
+      -1344748563236040701L,
+      2172701592984478834L,
+      -5322052340624064417L,
+      -8493945390573620511L,
+      3349021988137788403L,
+      -1806262525300459538L,
+      -8091524448239736618L,
+      4022306289903960690L,
+      -8346915997379834224L,
+      -2106001381993805461L,
+      -5784123934724688161L,
+      6775158099649720388L,
+      -3869682756870293568L,
+      4356490186652082006L,
+      8469371446702290916L,
+      -2972961082318458602L,
+      -7188106622222784561L,
+      -4961006366631572412L,
+      3199991182014172900L,
+      2917435868590434179L,
+      8385845305547872127L,
+      7706824402560674655L,
+      -1587379863634865277L,
+      -4212156212298809650L,
+      -1305209322000720233L,
+      -7866728337506665880L,
+      8195089740529247049L,
+      -4876930125798534239L,
+      798222697981617129L,
+      -2441020897729372845L,
+      -3926158482651178666L,
+      -1254795122048514130L,
+      5192463866522217407L,
+      -5426289318796042964L,
+      -3267454004443530826L,
+      471043133625225785L,
+      -660956397365869974L,
+      -6149209189144999161L,
+      -2630977660039166559L,
+      8512219789663151219L,
+      -3309844068134074620L,
+      -6211275327487847132L,
+      -2130171729366885995L,
+      6569302074205462321L,
+      4855778342281619706L,
+      3867211421508653033L,
+      -3002480002418725542L,
+      -8297543107467502696L,
+      8049642289208775831L,
+      -5439825716055425635L,
+      7251760070798756432L,
+      -4774526021749797528L,
+      -3892389575184442548L,
+      5162451061244344424L,
+      6000530226398686578L,
+      -5713092252241819676L,
+      8740913206879606081L,
+      -8693282419677309723L,
+      1576205127972543824L,
+      5760354502610401246L,
+      3173225529903529385L,
+      1785166236732849743L,
+      -1024443476832068882L,
+      -7389053248306187459L,
+      1171021620017782166L,
+      1471572212217428724L,
+      7720766400407679932L,
+      -8844781213239282804L,
+      -7030159830170200877L,
+      2195066352895261150L,
+      1343620937208608634L,
+      9178233160016731645L,
+      -757883447602665223L,
+      3303032934975960867L,
+      -3685775162104101116L,
+      -4454903657585596656L,
+      -5721532367620482629L,
+      8453227136542829644L,
+      5397498317904798888L,
+      7820279586106842836L,
+      -2369852356421022546L,
+      3910437403657116169L,
+      6072677490463894877L,
+      -2651044781586183960L,
+      5173762670440434510L,
+      -2970017317595590978L,
+      -1024698859439768763L,
+      -3098335260967738522L,
+      -1983156467650050768L,
+      -8132353894276010246L,
+      -1088647368768943835L,
+      -3942884234250555927L,
+      7169967005748210436L,
+      2870913702735953746L,
+      -2207022373847083021L,
+      1104181306093040609L,
+      5026420573696578749L,
+      -5874879996794598513L,
+      -4777071762424874671L,
+      -7506667858329720470L,
+      -2926679936584725232L,
+      -5530649174168373609L,
+      5282408526788020384L,
+      3589529249264153135L,
+      -6220724706210580398L,
+      -7141769650716479812L,
+      5142537361821482047L,
+      -7029808662366864423L,
+      -6593520217660744466L,
+      1454581737122410695L,
+      -139542971769349865L,
+      1727752089112067235L,
+      -775001449688420017L,
+      -5011311035350652032L,
+      -8671171179275033159L,
+      -2850915129917664667L,
+      -5258897903906998781L,
+      -6954153088230718761L,
+      -4070351752166223959L,
+      -6902592976462171099L,
+      -7850366369290661391L,
+      -4562443925864904705L,
+      3186922928616271015L,
+      2208521081203400591L,
+      -2727824999830592777L,
+      -3817861137262331295L,
+      2236720618756809066L,
+      -4888946967413746075L,
+      -446884183491477687L,
+      -43021963625359034L,
+      -5857689226703189898L,
+      -2156533592262354883L,
+      -2027655907961967077L,
+      7151844076490292500L,
+      -5029149124756905464L,
+      526404452686156976L,
+      8741076980297445408L,
+      7962851518384256467L,
+      -105985852299572102L,
+      -2614605270539434398L,
+      -8265006689379110448L,
+      8158561071761524496L,
+      -6923530157382047308L,
+      5551949335037580397L,
+      565709346370307061L,
+      -4780869469938333359L,
+      6931895917517004830L,
+      565234767538051407L,
+      -8663136372880869656L,
+      1427340323685448983L,
+      6492705666640232290L,
+      1481585578088475369L,
+      -1712711110946325531L,
+      3281685342714380741L,
+      6441384790483098576L,
+      -1073539554682358394L,
+      5704050067194788964L,
+      -5495724689443043319L,
+      -5425043165837577535L,
+      8349736730194941321L,
+      -4123620508872850061L,
+      4687874980541143573L,
+      -468891940172550975L,
+      -3212254545038049829L,
+      -6830802881920725628L,
+      9033050533972480988L,
+      4204031879107709260L,
+      -677513987701096310L,
+      -3286978557209370155L,
+      1644111582609113135L,
+      2040089403280131741L,
+      3323690950628902653L,
+      -7686964480987925756L,
+      -4664519769497402737L,
+      3358384147145476542L,
+      -4699919744264452277L,
+      -4795197464927839170L,
+      5051607253379734527L,
+      -8987703459734976898L,
+      8993686795574431834L,
+      -2688919474688811047L,
+      375938183536293311L,
+      1049459889197081920L,
+      -1213022037395838295L,
+      4932989235110984138L,
+      -6647247877090282452L,
+      -7698817539128166242L,
+      -3264029336002462659L,
+      6487828018122309795L,
+      -2660821091484592878L,
+      7104391069028909121L,
+      -1765840012354703384L,
+      85428166783788931L,
+      -6732726318028261938L,
+      7566202549055682933L,
+      229664898114413280L,
+      -1474237851782211353L,
+      -1571058880058007603L,
+      -7926453582850712144L,
+      2487148368914275243L,
+      8740031015380673473L,
+      1908345726881363169L,
+      -2510061320536523178L,
+      7854780026906019630L,
+      -6023415596650016493L,
+      -6264841978089051107L,
+      4024998278016087488L,
+      -4266288992025826072L,
+      -3222176619422665563L,
+      -1999258726038299316L,
+      1715270077442385636L,
+      6764658837948099754L,
+      -8646962299105812577L,
+      -51484064212171546L,
+      -1482515279051057493L,
+      -8663965522608868414L,
+      -256555202123523670L,
+      1973279596140303801L,
+      -7280796173024508575L,
+      -5691760367231354704L,
+      -5915786562256300861L,
+      -3697715074906156565L,
+      3710290115318541949L,
+      6796151623958134374L,
+      -935299482515386356L,
+      -7078378973978660385L,
+      5379481350768846927L,
+      -9011221735308556302L,
+      5936568631579608418L,
+      -6060732654964511813L,
+      -4243141607840017809L,
+      3198488845875349355L,
+      -7809288876010447646L,
+      4371587872421472389L,
+      -1304197371105522943L,
+      7389861473143460103L,
+      -1892352887992004024L,
+      2214828764044713398L,
+      6347546952883613388L,
+      1275694314105480954L,
+      -5262663163358903733L,
+      1524757505892047607L,
+      1474285098416162746L,
+      -7976447341881911786L,
+      4014100291977623265L,
+      8994982266451461043L,
+      -7737118961020539453L,
+      -2303955536994331092L,
+      1383016539349937136L,
+      1771516393548245271L,
+      -5441914919967503849L,
+      5449813464890411403L,
+      -3321280356474552496L,
+      4084073849712624363L,
+      4290039323210935932L,
+      2449523715173349652L,
+      7494827882138362156L,
+      9035007221503623051L,
+      5722056230130603177L,
+      -5443061851556843748L,
+      -7554957764207092109L,
+      447883090204372074L,
+      533916651576859197L,
+      -3104765246501904165L,
+      -4002281505194601516L,
+      -8402008431255610992L,
+      -408273018037005304L,
+      214196458752109430L,
+      6458513309998070914L,
+      2665048360156607904L,
+      96698248584467992L,
+      -3238403026096269033L,
+      6759639479763272920L,
+      -4231971627796170796L,
+      -2149574977639731179L,
+      -1437035755788460036L,
+      -6000005629185669767L,
+      145244292800946348L,
+      -3056352941404947199L,
+      3748284277779018970L,
+      7328354565489106580L,
+      -2176895260373660284L,
+      3077983936372755601L,
+      1215485830019410079L,
+      683050801367331140L,
+      -3173237622987755212L,
+      -1951990779107873701L,
+      -4714366021269652421L,
+      4934690664256059008L,
+      1674823104333774474L,
+      -3974408282362828040L,
+      2001478896492417760L,
+      -4115105568354384199L,
+      -2039694725495941666L,
+      -587763432329933431L,
+      -391276713546911316L,
+      -5543400904809469053L,
+      1882564440421402418L,
+      -4991793588968693036L,
+      3454088185914578321L,
+      2290855447126188424L,
+      3027910585026909453L,
+      2136873580213167431L,
+      -6243562989966916730L,
+      5887939953208193029L,
+      -3491821629467655741L,
+      -3138303216306660662L,
+      8572629205737718669L,
+      4154439973110146459L,
+      5542921963475106759L,
+      -2025215496720103521L,
+      -4047933760493641640L,
+      -169455456138383823L,
+      -1164572689128024473L,
+      -8551078127234162906L,
+      -7247713218016599028L,
+      8725299775220778242L,
+      6263466461599623132L,
+      7931568057263751768L,
+      7365493014712655238L,
+      -7343740914722477108L,
+      8294118602089088477L,
+      7677867223984211483L,
+      -7052188421655969232L,
+      -3739992520633991431L,
+      772835781531324307L,
+      881441588914692737L,
+      6321450879891466401L,
+      5682516032668315027L,
+      8493068269270840662L,
+      -3895212467022280567L,
+      -3241911302335746277L,
+      -7199586338775635848L,
+      -4606922569968527974L,
+      -806850906331637768L,
+      2433670352784844513L,
+      -5787982146811444512L,
+      7852193425348711165L,
+      8669396209073850051L,
+      -6898875695148963118L,
+      6523939610287206782L,
+      -8084962379210153174L,
+      8159432443823995836L,
+      -2631068535470883494L,
+      -338649779993793113L,
+      6514650029997052016L,
+      3926259678521802094L,
+      5443275905907218528L,
+      7312187582713433551L,
+      -2993773587362997676L,
+      -1068335949405953411L,
+      4499730398606216151L,
+      8538015793827433712L,
+      -4057209365270423575L,
+      -1504284818438273559L,
+      -6460688570035010846L,
+      1765077117408991117L,
+      8278320303525164177L,
+      8510128922449361533L,
+      1305722765578569816L,
+      7250861238779078656L,
+      -576624504295396147L,
+      -4363714566147521011L,
+      -5932111494795524073L,
+      1837387625936544674L,
+      -4186755953373944712L,
+      -7657073597826358867L,
+      140408487263951108L,
+      5578463635002659628L,
+      3400326044813475885L,
+      -6092804808386714986L,
+      -2410324417287268694L,
+      3222007930183458970L,
+      4932471983280850419L,
+      3554114546976144528L,
+      -7216067928362857082L,
+      -6115289896923351748L,
+      -6769646077108881947L,
+      4263895947722578066L,
+      2939136721007694271L,
+      1426030606447416658L,
+      -1316192446807442076L,
+      5366182640480055129L,
+      6527003877470258527L,
+      5849680119000207603L,
+      5263993237214222328L,
+      -6936533648789185663L,
+      -9063642143790846605L,
+      3795892210758087672L,
+      4987213125282940176L,
+      2505500970421590750L,
+      -1014022559552365387L,
+      -3574736245968367770L,
+      1180676507127340259L,
+      -2261908445207512503L,
+      -8416682633172243509L,
+      1114990703652673283L,
+      7753746660364401380L,
+      1874908722469707905L,
+      2033421444403047677L,
+      21412168602505589L,
+      385957952615286205L,
+      2053171460074727107L,
+      1915131899400103774L,
+      6680879515029368390L,
+      568807208929724162L,
+      -6211541450459087674L,
+      -5026690733412145448L,
+      1384781941404886235L,
+      -98027820852587266L,
+      1806580495924249669L,
+      6322077317403503963L,
+      9078162931419569939L,
+      -2809061215428363978L,
+      7697867577577415733L,
+      -5270063855897737274L,
+      5649864555290587388L,
+      -6970990547695444247L,
+      579684606137331754L,
+      3871931565451195154L,
+      2030008578322050218L,
+      -5012357307111799829L,
+      -2271365921756144065L,
+      4551962665158074190L,
+      -3385474923040271312L,
+      -7647625164191633577L,
+      6634635380316963029L,
+      -5201190933687061585L,
+      8864818738548593973L,
+      2855828214210882907L,
+      9154512990734024165L,
+      -6945306719789457786L,
+      1200243352799481087L,
+      875998327415853787L,
+      1275313054449881011L,
+      -6105772045375948736L,
+      -2926927684328291437L,
+      9200050852144954779L,
+      5188726645765880663L,
+      5197037323312705176L,
+      3434926231010121611L,
+      -5054013669361906544L,
+      2582959199749224670L,
+      -6053757512723474059L,
+      -5016308176846054473L,
+      -2509827316698626133L,
+      7700343644503853204L,
+      -1997627249894596731L,
+      3993168688325352290L,
+      -8181743677541277704L,
+      3719056119682565597L,
+      -7264411659282947790L,
+      7177028972346484464L,
+      -5460831176884283278L,
+      1799904662416293978L,
+      -6549616005092764514L,
+      5472403994001122052L,
+      8683463751708388502L,
+      -7873363037838316398L,
+      689134758256487260L,
+      -1287443614028696450L,
+      4452712919702709507L,
+      762909374167538893L,
+      6594302592326281411L,
+      1183786629674781984L,
+      5021847859620133476L,
+      -2490098069181538915L,
+      5105145136026716679L,
+      4437836948098585718L,
+      1987270426215858862L,
+      6170312798826946249L,
+      634297557126003407L,
+      -1672811625495999581L,
+      6282971595586218191L,
+      4549149305727581687L,
+      -5652165370435317782L,
+      1064501550023753890L,
+      -5334885527127139723L,
+      -6904378001629481237L,
+      -1807576691784201230L,
+      -205688432992053911L,
+      7621619053293393289L,
+      6258649161313982470L,
+      -1111634238359342096L,
+      -8044260779481691987L,
+      400270655839010807L,
+      -7806833581382890725L,
+      -2970563349459508036L,
+      -7392591524816802798L,
+      2918924613160219805L,
+      -6444161627929149002L,
+      6096497501321778876L,
+      -1477975665655830038L,
+      1690651307597306138L,
+      -2364076888826085362L,
+      -6521987420014905821L,
+      -4419193480146960582L,
+      3538587780233092477L,
+      8374665961716940404L,
+      7492412312405424500L,
+      6311662249091276767L,
+      -1240235198282023566L,
+      5478559631401166447L,
+      3476714419313462133L,
+      377427285984503784L,
+      2570472638778991109L,
+      -2741381313777447835L,
+      -7123472905503039596L,
+      2493658686946955193L,
+      1024677789035847585L,
+      -2916713904339582981L,
+      -4532003852004642304L,
+      -2202143560366234111L,
+      5832267856442755135L,
+      -261740607772957384L,
+      239435959690278014L,
+      5755548341947719409L,
+      6138795458221887696L,
+      -7709506987360146385L,
+      -6657487758065140444L,
+      -7006376793203657499L,
+      6544409861846502033L,
+      3171929352014159247L,
+      1051041925048792869L,
+      2617300158375649749L,
+      952652799620095175L,
+      -576661730162168147L,
+      -1634191369221345988L,
+      4833656816115993519L,
+      647566759700005786L,
+      2473810683785291822L,
+      3005977181064745326L,
+      -3321881966853149523L,
+      7595337666427588699L,
+      6004093624251057224L,
+      -563917505657690279L,
+      6117428527147449302L,
+      -6287297509522976113L,
+      -4527219334756214406L,
+      742626429298092489L,
+      3057351806086972041L,
+      645967551210272605L,
+      -4428701157828864227L,
+      3236379103879435414L,
+      -8477089892132066300L,
+      -6127365537275859058L,
+      -4052490484706946358L,
+      -8004854976625046469L,
+      -3679456917426613424L,
+      -8212793762082595299L,
+      -818288739465424130L,
+      1358812099481667095L,
+      7835987612195254310L,
+      -3663247409614323059L,
+      -2931105150130396604L,
+      7296136776835614792L,
+      -2014557408985889628L,
+      7267662411237959788L,
+      3699280615819277743L,
+      -212010675469091396L,
+      -6518374332458360120L,
+      145026010541628849L,
+      1879297324213501001L,
+      -7146296067751816833L,
+      -5002958800391379931L,
+      6060682439924517608L,
+      -432234782921170964L,
+      -6669688947353256956L,
+      7728943532792041267L,
+      830911367341171721L,
+      3396934884314289432L,
+      -779464156662780749L,
+      2330041851883352285L,
+      -4783350380736276693L,
+      -5758476056890049254L,
+      -7551552301614791791L,
+      1253334187723911710L,
+      -2685018208308798978L,
+      5379636036360946454L,
+      6154668487114681217L,
+      -8641287462255458898L,
+      4676087643800649558L,
+      -2405142641398691475L,
+      1088685126864246881L,
+      6431149082338374041L,
+      -607357695335069155L,
+      -720970692129524140L,
+      2648766932394044468L,
+      8408344790179354573L,
+      -6193808387735667350L,
+      7722524628524697419L,
+      -6975433852560238120L,
+      -2925851029234475295L,
+      -4274458387165211028L,
+      -8355836377702147319L,
+      5278146397877332061L,
+      8502098812383680707L,
+      2292836642336580326L,
+      -6127608082651070062L,
+      2222301962240611208L,
+      -1930887695854799378L,
+      7640503480494894592L,
+      1162652186586436094L,
+      -1918002592943761683L,
+      7648998601717261840L,
+      -8472603250832757057L,
+      -988877663117552456L,
+      2368458128168026494L,
+      -6480813811998475245L,
+      -5896967824416018967L,
+      -2593783161701820446L,
+      6950098417530252598L,
+      6362589545555771236L,
+      7981389665448567125L,
+      3954017080198558850L,
+      1626078615050230622L,
+      6650159066527969109L,
+      697345338922935394L,
+      -1226816215461768626L,
+      8740408765973837440L,
+      -4194155864629568323L,
+      7016680023232424746L,
+      6043281358142429469L,
+      -4201005667174376809L,
+      1216727117859013155L,
+      6367202436544203935L,
+      35414869396444636L,
+      3715622794033998412L,
+      488654435687670554L,
+      -2503747297224687460L,
+      3147101919441470388L,
+      -8248611218693190922L,
+      970697264481229955L,
+      3411465763826851418L,
+      9117405004661599969L,
+      -5204346498331519734L,
+      -19637460819385174L,
+      -5039124225167977219L,
+      2990108874601696668L,
+      -2623857460235459202L,
+      4256291692861397446L,
+      6724147860870760443L,
+      3558616688507246537L,
+      6487680097936412800L,
+      -6470792832935928161L,
+      4314814550912237614L,
+      -1292878983006062345L,
+      6791915152630414174L,
+      5971652079925815310L,
+      2557529546662864312L,
+      466175054322801580L,
+      -585216717310746872L,
+      -2486640422147349036L,
+      7212029603994220134L,
+      3958995069888972500L,
+      4950471855791412790L,
+      -3721948842035712763L,
+      -6184503487488243051L,
+      4079570444585775332L,
+      -3952156172546996872L,
+      4543894231118208322L,
+      -1739995588466209963L,
+      9155948355455935530L,
+      5821980345462207860L,
+      -2431287667309520417L,
+      -3890108130519441316L,
+      -558124689277030490L,
+      6079823537335801717L,
+      5409742395192364262L,
+      -2329885777717160453L,
+      -7332804342513677651L,
+      1466490574975950555L,
+      -420549419907427929L,
+      -5249909814389692516L,
+      -5145692168206210661L,
+      5934113980649113921L,
+      3241618428555359661L,
+      -6622110266160980250L,
+      5048250878669516223L,
+      5747219637359976174L,
+      2975906212588223728L,
+      5730216838646273215L,
+      -176713127129024690L,
+      6734624279336671146L,
+      5127866734316017180L,
+      7111761230887705595L,
+      3457811808274317235L,
+      3362961434604932375L,
+      -1877869936854991246L,
+      7171428594877765665L,
+      -8252167178400462374L,
+      -6306888185035821047L,
+      -6684702191247683887L,
+      -7754928454824190529L,
+      -1902605599135704386L,
+      -4037319846689421239L,
+      8493746058123583457L,
+      -8156648963857047193L,
+      2051510355149839497L,
+      -1256416624177218909L,
+      -3344927996254072010L,
+      -1838853051925943568L,
+      316927471680974556L,
+      -1502257066700798003L,
+      -5836095610125837606L,
+      -1594125583615895424L,
+      1442211486559637962L,
+      -144295071206619569L,
+      5159850900959273410L,
+      4589139881166423678L,
+      -7038726987463097509L,
+      2886082400772974595L,
+      2780759114707171916L,
+      5694649587906297495L,
+      1260349041268169667L,
+      4921517488271434890L,
+      644696475796073018L,
+      6262811963753436289L,
+      -6128198676595868773L,
+      -3625352083004760261L,
+      -8751453332943236675L,
+      8749249479868749221L,
+      -2450808199545048250L,
+      -6517435817046180917L,
+      -3433321727429234998L,
+      -2591586258908763451L,
+      3847750870868804507L,
+      6603614438546398643L,
+      -7598682191291031287L,
+      8710261565627204971L,
+      4753389483755344355L,
+      -4645333069458786881L,
+      -6742695046613492214L,
+      643070478568866643L,
+      -7543096104151965610L,
+      7171495384655926161L,
+      595063872610714431L,
+      3292310150781130424L,
+      4326847806055440904L,
+      -4580020566072794152L,
+      3142286571820373678L,
+      5530356537440155930L,
+      546372639737516181L,
+      7401214477400367500L,
+      7406531960402873109L,
+      3287639667219172570L,
+      4977301681213633671L,
+      5253257820925174498L,
+      2906216636104297878L,
+      6142955758238347523L,
+      -3498651268741727235L,
+      -5875053958265588593L,
+      3896719087169993883L,
+      -910904726885775073L,
+      380107493197368177L,
+      -4993591912695447004L,
+      2970487257212582761L,
+      2551762717569548774L,
+      953061649962736812L,
+      8949739538606589463L,
+      -2962839167079475801L,
+      -1375673191272573835L,
+      3761793818361866390L,
+      -389577789190726878L,
+      5661262051502180269L,
+      -6558556411143987683L,
+      -702798336372315031L,
+      -336662820551371779L,
+      998576401126580155L,
+      -5945021269112582755L,
+      6108533925730179871L,
+      2207095297001999618L,
+      -9042779159998880435L,
+      -6177868444342118372L,
+      6775965402605895077L,
+      -3788428885163306576L,
+      7790055010527190387L,
+      3581587652196995358L,
+      -6176354155561607694L,
+      -5859381340906321207L,
+      395898765763528395L,
+      8132967590863909348L,
+      -3329092504090544483L,
+      -6785855381158040247L,
+      1497218517051796750L,
+      -5352392845588925911L,
+      -6271364901230559194L,
+      2314830370653350118L,
+      -7617588269001325450L,
+      1423166885758213795L,
+      8538612578307869519L,
+      -61918791718295474L,
+      -8177103503192338593L,
+      -4740086042584326695L,
+      3677931948215558698L,
+      6558856291580149558L,
+      2674975452453336335L,
+      5133796555646930522L,
+      5139252693299337100L,
+      7949476871295347205L,
+      4407815324662880678L,
+      -3758305875280581215L,
+      6066309507576587415L,
+      -7368508486398350973L,
+      -3181640264332856492L,
+      6905100869343314145L,
+      3677177673848733417L,
+      8862933624870506941L,
+      -8575223195813810568L,
+      9178470351355678144L,
+      4677809017145408358L,
+      -1194833416287894989L,
+      3436364743255571183L,
+      -5204770725795363579L,
+      560599448536335263L,
+      -3192077522964776200L,
+      -751575299648803575L,
+      6334581746534596579L,
+      -8358187891202563300L,
+      -1462480609823525055L,
+      5605961062646987941L,
+      4968399805931440889L,
+      7968693270782626653L,
+      -5868205923557518188L,
+      1830234928743560617L,
+      -8435261076693154407L,
+      2138416970728681332L,
+      8088740745199685138L,
+      806532400344230520L,
+      1800590379902909333L,
+      -8909128842071238901L,
+      -7357495566969170860L,
+      3679766664126940553L,
+      2060050474865839094L,
+      2363972840121763414L,
+      525695004292982714L,
+      -1224842191746529593L,
+      7011317848855545003L,
+      -6337167558180299938L,
+      -5184688833363785939L,
+      -8426673387248359061L,
+      -5035438815930785229L,
+      3521810320608058994L,
+      4803742557254962242L,
+      6623527039545786598L,
+      -1221475882122634738L,
+      -3344794405518401087L,
+      6510298498414053658L,
+      2844753907937720338L,
+      90502309714994895L,
+      -750403235344282494L,
+      -4825474181021465833L,
+      -3405519947983849510L,
+      3503875590944089793L,
+      7286294700691822468L,
+      7828126881500292486L,
+      8437899353709338096L,
+      136052254470293480L,
+      1113259077339995086L,
+      -8244887265606191121L,
+      8089569503800461649L,
+      -1429698194850157567L,
+      1575595674002364989L,
+      3576095286627428675L,
+      -7653655285807569222L,
+      -6053506977362539111L,
+      -3923855345805787169L,
+      -8001149080454232377L,
+      -4382867706931832271L,
+      4212860258835896297L,
+      4207674254247034014L,
+      5519424058779519159L,
+      -754483042161434654L,
+      1434113479814210082L,
+      -6416645032698336896L,
+      5624329676066514819L,
+      -8229557208322175959L,
+      3922640911653270376L,
+      7826932478782081910L,
+      -4862787164488635842L,
+      1449234668827944573L,
+      -1781657689570106327L,
+      5442827552725289699L,
+      3589862161007644641L,
+      4787115581650652778L,
+      -3512152721942525726L,
+      -6750103117958685206L,
+      5012970446659949261L,
+      6797752795961689017L,
+      5086454597639943700L,
+      -7616068364979994076L,
+      1492846825433110217L,
+      2967476304433704510L,
+      -8413824338284112078L,
+      -1319049442043273974L,
+      -1756090916806844109L,
+      -9061091728950139525L,
+      -6864767830358160810L,
+      4879532090226251157L,
+      5528644708740739488L
+  };
+}